diff --git a/.claude/.gitignore b/.claude/.gitignore
new file mode 100644
index 0000000000..9df52a07c2
--- /dev/null
+++ b/.claude/.gitignore
@@ -0,0 +1,4 @@
+*
+!skills/
+!skills/**
+!.gitignore
diff --git a/.claude/skills/tests/SKILL.md b/.claude/skills/tests/SKILL.md
new file mode 100644
index 0000000000..e3b140fc93
--- /dev/null
+++ b/.claude/skills/tests/SKILL.md
@@ -0,0 +1,179 @@
+---
+name: tests
+description: Anything test-related in the drizzle-orm monorepo — running, writing, debugging, or fixing tests. Use whenever the user mentions tests in any way.
+---
+
+# Running tests in drizzle-orm
+
+This monorepo's tests fall into two buckets: **unit-style** (no DB, run anywhere) and **DB-backed** (need a real Postgres / MySQL / MariaDB / CockroachDB / MSSQL / SingleStore on a specific port). The DB-backed ones read connection-string env vars from `drizzle-kit/.env`, which itself maps to ports owned by `compose/*.yml`. If any of those three layers is missing — env file, DB container, port match — the test fails with a confusing error (most often `connect ECONNREFUSED` or `process.env.X is not set`). This skill is the fast path through the setup so the user doesn't waste time debugging environment instead of code.
+
+## ⛔ Hard rule — never spawn Docker from test code, test runs, or agent narration
+
+**This rule has four halves. Violating any one of them reads to the user as "tests spawned Docker again".**
+
+**1. Test code must not spawn containers.** Never `import Docker`/`dockerode`/`testcontainers`/`GenericContainer` and never `execSync('docker ...')` in a new test file. The legacy `drizzle-kit/tests/<dialect>/mocks.ts::createDockerDB()` and `integration-tests/tests/{pg,mysql,cockroach,mssql,bun,seeder}/*.test.ts::createDockerDB()` paths exist for historical reasons — DO NOT add new ones, and DO NOT call existing ones from new tests. Wrap new DB-backed tests in `describe.skipIf(!process.env.X)` so a missing env var skips silently.
+
+**2. Latent trigger: legacy `?? createDockerDB()` fallbacks are still wired up.** Many `integration-tests/tests/{pg,mysql,cockroach,mssql,bun,seeder}/*.test.ts` files contain `process.env.X ?? await createDockerDB()`. Running `pnpm --filter integration-tests test:*` without the matching env var will silently spin up a container via `dockerode` — even if you've already brought DBs up via `compose/dockers.sh`. The same fallthrough exists in `drizzle-kit/tests/<dialect>/mocks.ts::prepareTestDatabase()`. **Setting env vars is not optional — it is what prevents Docker spawn.** Always export the connection string before invoking these scripts, even when "just running the suite to see what passes". If you discover a new test using this pattern, flag it as tech debt — do not extend it.
+
+**3. Agent narration must not tempt operators into `docker run`.** When you (or a spawned subagent) summarize how to run a new DB-backed test, **always** reference `bash compose/dockers.sh up <dialect>` plus the connection-string env var. Never write "this test starts a postgres container" or suggest `docker run` in a final message — the user pattern-matches that as "tests spawned Docker again", even when the underlying code is well-behaved.
+
+**4. Spawned subagents do not inherit this skill.** When delegating any test-writing or test-running work via the Agent tool, paste rules 1–3 verbatim into the subagent prompt. Subagents only see the prompt you give them, not the project's `.claude/skills/` directory. If a subagent's diff adds `import Docker` or its summary tells the operator to `docker run`, that's the failure mode this rule prevents.
+
+## Writing tests — design & quality
+
+The full, authoritative rules live in `.planning/codebase/TESTING.md` § **Test Quality Guidelines (drizzle-kit)**. The essentials (drizzle-kit):
+
+- **Minimize mocks; drive against real in-memory DBs.** PGlite (postgres, via the real `pglite` driver — pass `{ driver: 'pglite', client }` as credentials), `new BetterSqlite3(':memory:')` (sqlite), `@libsql/client` `:memory:` (turso); real servers for mysql/mssql/cockroach/singlestore. Run the REAL diff/introspect/`suggestions` engine — never `vi.doMock` `*/ddl`/`*/diff`/`*/serializer`/`*/introspect` to fabricate output.
+- **Only test what a real DB can actually produce.** Test redaction / error envelopes by triggering a real failure (unreachable URL + sentinel credential), not by injecting a fabricated error string. If a behavior can't occur on a real DB, drop it or move it to that dialect's real-DB test.
+- **One real-DB test per distinct behavior** — no per-dialect envelope matrices; keep dialect-specific behavior in that dialect's tests.
+- **Prefer dependency injection over module mocking** — e.g. `SchemaSource.fromSchema(fromExports(entities))` instead of `vi.doMock`-ing `prepareFromSchemaFiles`.
+- **Drop low-value tests** — things unlikely to ever change (presence/frontmatter/static reads), CLI≡SDK parity (shared core guarantees it), pure-function idempotence, defensive `expect(x).toBeDefined()`.
+- **No subprocess / built-`dist` / network deps** — no `spawnSync` tsx/node/npx, no `npx …@latest` — unless a single deliberate E2E smoke needs it (`tests/other/bin.test.ts`).
+- **House style** — no requirement-ID nomenclature (`MCP-05`, `CHECK-05`, `D-13`) or essay JSDoc in tests; explicit named tests over `test.each` where it aids readability; reuse `tests/<dialect>/mocks.ts`; express fixtures via `fromExports(...)`, not hand-built `{ tables, views, relations }` literals.
+- **Tests must run in a CI shard** — `kit:*` runs `./mysql ./sqlite ./other`, `./postgres`, `./cockroach`, `./mssql`, NOT `tests/sdk`/`tests/mcp`/`tests/skills`. Land new tests in `tests/other/`.
+
+When delegating test-writing to a subagent, paste these into the prompt too (subagents don't see this skill).
+
+## Workflow (always run in this order)
+
+### 1. Ensure `drizzle-kit/.env` exists
+
+The committed template is `drizzle-kit/.env.example`; the real file `drizzle-kit/.env` is gitignored and needs to exist for `dotenv/config` (loaded by `tests/{mariadb,mysql,singlestore}/pull.test.ts` and Vitest's built-in dotenv loader) to populate `process.env`.
+
+```bash
+[ -f drizzle-kit/.env ] || cp drizzle-kit/.env.example drizzle-kit/.env
+```
+
+Skip if `drizzle-kit/.env` already exists — never overwrite the user's local edits. If a test still says `process.env.X is not set` after this, look in `drizzle-kit/.env.example` to see whether the variable is even defined there; if not, the test is reading a key the example doesn't ship and that's a real bug.
+
+### 2. Identify the test target and which DB(s) it needs
+
+Pick the right script. Most users want one of these:
+
+| Command | Cwd | Needs DB? | Compose dialect(s) | Env vars consumed |
+|---|---|---|---|---|
+| `pnpm --filter drizzle-kit test` | repo root | no | — | (TEST_CONFIG_PATH_PREFIX) |
+| `pnpm --filter drizzle-kit test:types` | repo root | no | — | — |
+| `pnpm --filter drizzle-kit test:postgres` | repo root | yes (PGlite by default) | none required; **set `PG_VERSION=16\|17\|18`** to use real postgres → then need `postgres16` / `postgres17` / `postgres18`; postgis subset → `postgres-postgis` | `PG_VERSION`, `PG16_URL`, `PG17_URL`, `PG18_URL`, `POSTGIS_URL` |
+| `pnpm --filter drizzle-kit test:other` | repo root | yes (mysql subset) | `mysql` | `MYSQL_CONNECTION_STRING` |
+| `pnpm --filter drizzle-kit test:cockroach` | repo root | yes | `cockroach` (or `cockroach-many` for `;`-separated multi-URL parallelism) | `COCKROACH_CONNECTION_STRING` |
+| `pnpm --filter drizzle-kit test:mssql` | repo root | yes | `mssql` | `MSSQL_CONNECTION_STRING` |
+| `pnpm --filter drizzle-kit test:singlestore` | repo root | yes | `singlestore` (see overload below) | `MYSQL_CONNECTION_STRING` |
+| `pnpm --filter drizzle-orm test` | repo root | no | — | — |
+| `pnpm --filter drizzle-orm test:types` | repo root | no | — | — |
+| `pnpm --filter drizzle-seed test` | repo root | no | — | — |
+| `pnpm --filter eslint-plugin-drizzle test` | repo root | no | — | — |
+| `pnpm --filter integration-tests test:postgres` | repo root | yes | `postgres` (canonical compose port 55433) | `PG_CONNECTION_STRING` (NB: integration-tests has its own `.env`, not drizzle-kit's) |
+| `pnpm --filter integration-tests test:mysql` | repo root | yes | `mysql` | `MYSQL_CONNECTION_STRING` |
+
+Notes:
+- `drizzle-kit test:postgres` runs against PGlite (in-process) **unless** `PG_VERSION` is set. If the user wants to test against real Postgres (e.g., to repro a production-only behavior), set `PG_VERSION=18` (or 17/16) AND have the matching `postgres18` dialect running.
+- `drizzle-kit test:other` mixes pure-vitest sqlite/`other` tests with mysql tests — only the mysql portion needs Docker.
+- `integration-tests` is a separate package with a separate `.env` (`integration-tests/.env`) and different port conventions — do not confuse the two .env files.
+
+### 3. SingleStore overload — important footgun
+
+`drizzle-kit/tests/singlestore/mocks.ts` reads **`MYSQL_CONNECTION_STRING`**, not a separate `SINGLESTORE_CONNECTION_STRING`. So when running `test:singlestore`, the user must:
+
+- Comment the MySQL line in `drizzle-kit/.env`
+- Uncomment the SingleStore line that points at `mysql://root:singlestore@127.0.0.1:33307/`
+
+The `.env.example` documents this in a comment block. Don't try to "fix" this in the test code — the overload is intentional and documented as out-of-scope in the `.env.example` header. If the user is running `test:mysql` and `test:singlestore` back-to-back, remind them about the swap.
+
+### 4. Bring up the DBs via `compose/dockers.sh`
+
+Always use `compose/dockers.sh` — never let test mocks spin up Docker via `dockerode`, and never invent ad-hoc `docker run` commands. The script is the single source of truth for "which port is which dialect on", and each compose YAML carries the canonical healthcheck. Spawned subagents must be told this explicitly because they don't see this skill by default.
+
+```bash
+# Start exactly the dialects the test needs:
+bash compose/dockers.sh up <dialect> [<dialect>...]
+
+# Examples:
+bash compose/dockers.sh up postgres                    # for PG_CONNECTION_STRING tests
+bash compose/dockers.sh up postgres18                  # for PG_VERSION=18 ./postgres/ tests
+bash compose/dockers.sh up mysql                       # for test:other (mysql subset) or test:mysql
+bash compose/dockers.sh up cockroach                   # for test:cockroach
+bash compose/dockers.sh up mssql                       # for test:mssql
+bash compose/dockers.sh up singlestore                 # for test:singlestore (after .env swap)
+bash compose/dockers.sh up postgres mysql cockroach    # multiple dialects in one go
+
+# No-args = bring up every supported dialect (postgres, postgres16/17/18, postgres-postgis,
+# postgres-vector, mysql, mariadb, cockroach, cockroach-many, mssql, singlestore, singlestore-many).
+# Heavy on macOS — ~10GB RAM peak. Prefer naming the dialects you actually need.
+bash compose/dockers.sh up
+```
+
+The `up` subcommand runs `docker compose ... up -d --wait --wait-timeout 120` and then `bash compose/wait.sh <dialect>` so the script returns only after the host-side TCP probe succeeds. **Tests are safe to launch immediately after the script returns.** No `sleep` loops needed.
+
+If `bash compose/dockers.sh up <dialect>` reports `Unknown dialect '...'`, the dialect name is wrong; the script prints the valid list. Common mistakes: `postgres-15` (doesn't exist — only 16/17/18), `singlestore2` (use `singlestore-many`).
+
+### 5. Run the test
+
+After `dockers.sh up` returns:
+
+```bash
+pnpm --filter <package> <script>     # e.g., pnpm --filter drizzle-kit test:cockroach
+```
+
+Run from the repo root with `--filter`; this respects pnpm workspaces and avoids cwd bugs. Internally each package's test:* script invokes `vitest run`, which auto-loads `.env` files from the package directory.
+
+### 6. Tear down (optional)
+
+```bash
+bash compose/dockers.sh down <dialect>     # one dialect, wipes its volumes
+bash compose/dockers.sh down               # all dialects
+```
+
+`down` uses `-v` to wipe volumes — test DBs are ephemeral and `mocks.ts` `clear()` recreates the schema each run, so persistent volumes have no value here. Leaving DBs running between iterations is fine and the common workflow during active development.
+
+## Before debugging a failing test: check for expired `.skipIf` postpones
+
+Many tests in this repo are wrapped in a date-gated postpone:
+
+```ts
+test.skipIf(Date.now() < +new Date('2026-06-01'))('add table #16', async () => { ... })
+```
+
+The convention: a known-failing test gets postponed to a future date instead of being fixed immediately. While `Date.now() < +new Date(...)` the test is skipped; once the date passes, the test runs again. **If a test starts failing and you don't recognize it as a recent change, grep for it first** — it's very likely an expired postpone, not a regression you introduced.
+
+```bash
+grep -rn "skipIf" --include="*.ts" drizzle-kit/tests integration-tests/tests drizzle-orm/tests
+```
+
+When the failing test has an expired `.skipIf` date (i.e., today's date ≥ the date in the call), **bump the date to one month from today** rather than try to fix it in-band — that's the established workflow for this repo. Use the actual calendar date (the global context provides today's date), not a relative offset, and use the same `'YYYY-MM-DD'` format already in the file.
+
+If the same test also has a `// @ts-ignore skipIf(Date.now() < +new Date('YYYY-MM-DD')) - just to make it searchable` comment nearby (see `integration-tests/tests/pg/common-pt2.ts:6674` for the pattern), bump the date in the comment too so the search stays consistent.
+
+Only after ruling out an expired postpone should you start debugging the test logic, the schema, or the dialect.
+
+## Common failure patterns and the fix
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| A previously-passing test suddenly fails with no obvious code change | Expired `.skipIf(Date.now() < +new Date('YYYY-MM-DD'))` postpone — the gate just opened | See "Before debugging" section above; bump the date(s) to one month from today |
+| `process.env.PG18_URL is not set` (or any `_URL`/`_CONNECTION_STRING`) | `drizzle-kit/.env` missing or env var commented out | Run step 1; check the line is uncommented in `drizzle-kit/.env` |
+| `connect ECONNREFUSED 127.0.0.1:55433` (or any port) | DB container not running, or running on the wrong port | `bash compose/dockers.sh up <dialect>`; if it's already up, check `bash compose/dockers.sh ps <dialect>` shows it healthy on the expected port |
+| Tests hang after starting | Older `dockers.sh` was inline `docker run` with mismatched ports — `git pull` first; the new dispatcher gates on `wait.sh` | `git status` to confirm `compose/dockers.sh` is the dispatcher form, not the old inline form |
+| Singlestore tests connect to MySQL | `MYSQL_CONNECTION_STRING` still points at mysql:3306 | Swap the env var per step 3 (singlestore overload) |
+| `port is already allocated` from `compose up` | Previous container left bound | `bash compose/dockers.sh down <dialect>` then re-up; or `docker ps` to find the stray container |
+| `EACCES`/permission errors writing tests/postgres/tmp | Stale tmp dir owned by docker | `rm -rf drizzle-kit/tests/<dialect>/tmp/` and re-run |
+
+## Quick reference: dialect → port → image
+
+| Dialect | Port | Image | Compose file |
+|---|---|---|---|
+| postgres | 55433 | postgres:17-alpine | compose/postgres.yml |
+| postgres16 | 54323 | pgvector/pgvector:pg16 | compose/postgres16.yml |
+| postgres17 | 54324 | pgvector/pgvector:pg17 | compose/postgres17.yml |
+| postgres18 | 54325 | pgvector/pgvector:pg18 | compose/postgres18.yml |
+| postgres-postgis | 54322 | postgis/postgis:16-3.4 | compose/postgres-postgis.yml |
+| postgres-vector | 54321 | pgvector/pgvector:pg16 | compose/postgres-vector.yml |
+| mysql | 3306 | mysql:8 | compose/mysql.yml |
+| mariadb | 33306 | mariadb:11.8 | compose/mariadb.yml |
+| cockroach | 26257 | cockroachdb/cockroach:v25.2.0 | compose/cockroach.yml |
+| cockroach-many | 26260–26262 | (3× cockroach) | compose/cockroach-many.yml |
+| mssql | 1433 | mcr.microsoft.com/azure-sql-edge | compose/mssql.yml |
+| singlestore | 33307 | singlestoredb-dev:0.2.67 | compose/singlestore.yml |
+| singlestore-many | 3308–3311 | (4× singlestoredb-dev) | compose/singlestore-many.yml |
+
+For the connection-string format that pairs with each port, copy the matching line from `drizzle-kit/.env.example` — it's the source of truth and tracks every port/credential change.
diff --git a/.envrc b/.envrc
deleted file mode 100644
index 9955774037..0000000000
--- a/.envrc
+++ /dev/null
@@ -1,3 +0,0 @@
-use flake
-dotenv_if_exists
-PATH_add ./node_modules/.bin
diff --git a/.eslintignore b/.eslintignore
deleted file mode 100644
index be4acda785..0000000000
--- a/.eslintignore
+++ /dev/null
@@ -1,11 +0,0 @@
-node_modules
-dist
-dist-dts
-examples
-**/*.js
-**/*.mjs
-**/*.cjs
-**/playground
-integration-tests/tests/prisma/*/client
-integration-tests/tests/prisma/*/drizzle
-drizzle-kit/*
diff --git a/.eslintrc.yaml b/.eslintrc.yaml
deleted file mode 100644
index 906d73ffac..0000000000
--- a/.eslintrc.yaml
+++ /dev/null
@@ -1,84 +0,0 @@
-root: true
-extends:
-  - 'eslint:recommended'
-  - 'plugin:@typescript-eslint/recommended'
-  - 'plugin:unicorn/recommended'
-parser: '@typescript-eslint/parser'
-parserOptions:
-  project: './tsconfig.json'
-plugins:
-  - import
-  - unused-imports
-  - no-instanceof
-  - drizzle-internal
-overrides:
-  - files:
-      - '**/tests/**/*.ts'
-      - '**/type-tests/**/*.ts'
-    rules:
-      import/extensions: 'off'
-      no-instanceof: 'off'
-  - files: 'eslint-plugin-drizzle/**/*'
-    rules:
-      import/extensions: 'off'
-rules:
-  '@typescript-eslint/consistent-type-imports':
-    - error
-    - disallowTypeAnnotations: false
-      fixStyle: separate-type-imports
-  '@typescript-eslint/no-import-type-side-effects': 'error'
-  import/no-cycle: error
-  import/no-self-import: error
-  import/no-empty-named-blocks: error
-  unused-imports/no-unused-imports: error
-  import/no-useless-path-segments: error
-  import/newline-after-import: error
-  import/no-duplicates: error
-  import/extensions:
-    - error
-    - always
-    - ignorePackages: true
-  '@typescript-eslint/no-explicit-any': 'off'
-  '@typescript-eslint/no-non-null-assertion': 'off'
-  '@typescript-eslint/no-namespace': 'off'
-  '@typescript-eslint/no-unused-vars':
-    - error
-    - argsIgnorePattern: '^_'
-      varsIgnorePattern: '^_'
-  '@typescript-eslint/ban-types':
-    - error
-    - extendDefaults: true
-      types:
-        '{}' : false
-  '@typescript-eslint/no-this-alias': 'off'
-  '@typescript-eslint/no-var-requires': 'off'
-  'unicorn/prefer-node-protocol': 'off'
-  'unicorn/prefer-top-level-await': 'off'
-  'unicorn/prevent-abbreviations': 'off'
-  'unicorn/prefer-switch': 'off'
-  'unicorn/catch-error-name': 'off'
-  'unicorn/no-null': 'off'
-  'unicorn/numeric-separators-style': 'off'
-  'unicorn/explicit-length-check': 'off'
-  'unicorn/filename-case': 'off'
-  'unicorn/prefer-module': 'off'
-  'unicorn/no-array-reduce': 'off'
-  'unicorn/no-nested-ternary': 'off'
-  'unicorn/no-useless-undefined':
-    - error
-    - checkArguments: false
-  'unicorn/no-this-assignment': 'off'
-  'unicorn/empty-brace-spaces': 'off'
-  'unicorn/no-thenable': 'off'
-  'unicorn/consistent-function-scoping': 'off'
-  'unicorn/prefer-type-error': 'off'
-  'unicorn/relative-url-style': 'off'
-  'eqeqeq': 'error'
-  'no-instanceof/no-instanceof': 'error'
-  'drizzle-internal/require-entity-kind': 'error'
-  'unicorn/prefer-string-replace-all': 'off'
-  'unicorn/no-process-exit': 'off'
-  '@typescript-eslint/ban-ts-comment': 'off'
-  '@typescript-eslint/no-empty-interface': 'off'
-  '@typescript-eslint/no-unsafe-declaration-merging': 'off'
-  'no-inner-declarations': 'off'
diff --git a/.github/workflows/release-feature-branch-beelink.yaml b/.github/workflows/release-feature-branch-beelink.yaml
new file mode 100644
index 0000000000..01fcfe853e
--- /dev/null
+++ b/.github/workflows/release-feature-branch-beelink.yaml
@@ -0,0 +1,431 @@
+name: Release (feature branch)
+
+on:
+  workflow_call:
+    secrets:
+      PLANETSCALE_CONNECTION_STRING:
+        required: true
+      NEON_CONNECTION_STRING:
+        required: true
+      NEON_HTTP_CONNECTION_STRING:
+        required: true
+      TIDB_CONNECTION_STRING:
+        required: true
+      XATA_API_KEY:
+        required: true
+      XATA_BRANCH:
+        required: true
+      LIBSQL_REMOTE_URL:
+        required: true
+      LIBSQL_REMOTE_TOKEN:
+        required: true
+      TURSODATABASE_REMOTE_URL:
+        required: true
+      TURSODATABASE_REMOTE_TOKEN:
+        required: true
+      SQLITE_CLOUD_CONNECTION_STRING:
+        required: true
+      SQLITE_MANY_CLOUD_CONNECTION_STRING:
+        required: true
+
+concurrency:
+  group: feature-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # Shared local artifacts directory
+  ARTIFACTS_DIR: /opt/runners/cache/artifacts/${{ github.run_id }}
+  # Shared cache directories for self-hosted runners
+  PNPM_STORE_DIR: /opt/runners/cache/pnpm-store
+  TURBO_CACHE_DIR: /opt/runners/cache/turbo
+  npm_config_cache: /opt/runners/cache/npm
+  BUN_INSTALL_CACHE_DIR: /opt/runners/cache/bun
+
+jobs:
+  prepare:
+    runs-on: self-hosted
+    timeout-minutes: 25
+    env:
+      # TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+      TURBO_TEAM: 'team_KbvYUtAn1Tqytsj8HbNcYDqV'
+    steps:
+      - name: Setup PATH
+        run: |
+          echo "/home/alex/.volta/bin" >> $GITHUB_PATH
+          echo "/home/alex/.bun/bin" >> $GITHUB_PATH
+      - uses: actions/checkout@v5
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      - name: Compute version suffix
+        id: meta
+        shell: bash
+        run: echo "suffix=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"
+      - name: Build all
+        run: pnpm build:artifact
+      
+      # Save build artifacts locally (shared filesystem)
+      - name: Save build-dist locally
+        run: |
+          mkdir -p "$ARTIFACTS_DIR/build-dist"
+          find . -type d -name "dist" -not -path "./node_modules/*" | while read dir; do
+            target_dir="$ARTIFACTS_DIR/build-dist/$dir"
+            mkdir -p "$(dirname "$target_dir")"
+            cp -r "$dir" "$target_dir"
+          done
+          find . -name "*.tsbuildinfo" -not -path "./node_modules/*" | while read file; do
+            target_file="$ARTIFACTS_DIR/build-dist/$file"
+            mkdir -p "$(dirname "$target_file")"
+            cp "$file" "$target_file"
+          done
+      
+      - name: Pack
+        run: pnpm pack:artifact
+      
+      # Save package tarballs locally
+      - name: Save packages locally
+        run: |
+          mkdir -p "$ARTIFACTS_DIR/packages"
+          for pkg in drizzle-orm drizzle-kit drizzle-zod drizzle-seed drizzle-typebox drizzle-valibot drizzle-arktype eslint-plugin-drizzle; do
+            if [ -f "$pkg/package.tgz" ]; then
+              mkdir -p "$ARTIFACTS_DIR/packages/$pkg"
+              cp "$pkg/package.tgz" "$ARTIFACTS_DIR/packages/$pkg/"
+            fi
+          done
+
+      # Marker so other jobs know build is ready
+      - name: Create build-ready marker
+        run: |
+          echo "ok" > "$ARTIFACTS_DIR/build-ready"
+      - name: test:types & lint
+        run: pnpm test:types-lint
+
+  test:
+    # NOTE: no 'needs: [prepare]' on purpose — start early, warm DBs, then wait for artifacts
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: self-hosted
+    timeout-minutes: 45
+    env:
+      # TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+      TURBO_TEAM: 'team_KbvYUtAn1Tqytsj8HbNcYDqV'
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - shard: int:mysql
+            dbs: [mysql]
+          - shard: int:postgres
+            dbs: [postgres]
+          - shard: int:sqlite
+            dbs: []
+          - shard: int:turso-serverless
+            dbs: []
+          - shard: int:other
+            dbs: [mysql, mssql, cockroach, postgres, postgres-postgis, postgres-vector]
+          - shard: int:planetscale
+            dbs: []
+          - shard: int:cockroach
+            dbs: [cockroach]
+          #  TODO:
+          # - shard: int:bun
+          #   dbs: [postgres, mysql]
+          - shard: int:mssql
+            dbs: [mssql]
+          - shard: orm
+            dbs: []
+          - shard: kit:other
+            dbs: [mysql]
+          - shard: kit:postgres
+            dbs: [postgres, postgres-postgis]
+          - shard: kit:cockroach
+            dbs: [cockroach-many]
+          - shard: kit:mssql
+            dbs: [mssql]
+          - shard: seed
+            dbs: [cockroach, mysql, mssql, postgres-postgis]
+          - shard: validators
+            dbs: []
+         
+    name: ${{ matrix.shard }}
+    steps:
+      - name: Setup PATH
+        run: |
+          echo "/home/alex/.volta/bin" >> $GITHUB_PATH
+          echo "/home/alex/.bun/bin" >> $GITHUB_PATH
+      - uses: actions/checkout@v5
+      - run: pnpm install --frozen-lockfile --prefer-offline
+
+      - name: Start DBs needed by shard (pre-warm)
+        if: ${{ matrix.dbs && join(matrix.dbs, ',') != '' }}
+        shell: bash
+        run: |
+          set -euxo pipefail
+          
+          compose_files=()
+          for db in ${{ join(matrix.dbs, ' ') }}; do
+            case "$db" in
+              postgres)            compose_files+=("-f" "compose/postgres.yml") ;;
+              postgres-postgis)    compose_files+=("-f" "compose/postgres-postgis.yml") ;;
+              postgres-vector)     compose_files+=("-f" "compose/postgres-vector.yml") ;;
+              mysql)               compose_files+=("-f" "compose/mysql.yml") ;;
+              mssql)               compose_files+=("-f" "compose/mssql.yml") ;;
+              cockroach)           compose_files+=("-f" "compose/cockroach.yml") ;;
+              cockroach-many)      compose_files+=("-f" "compose/cockroach-many.yml") ;;
+              *) echo "Unknown db '$db'"; exit 1 ;;
+            esac
+          done
+          docker compose "${compose_files[@]}" up -d
+
+          chmod +x compose/wait.sh
+          compose/wait.sh ${{ join(matrix.dbs, ' ') }}
+
+      - name: Wait for 'prepare' to finish (poll local marker)
+        shell: bash
+        run: |
+          set -euo pipefail
+          echo "Waiting for build-ready marker at $ARTIFACTS_DIR/build-ready..."
+          for i in $(seq 1 120); do
+            if [ -f "$ARTIFACTS_DIR/build-ready" ]; then
+              echo "build-ready found!"
+              break
+            fi
+            echo "...still waiting ($i/120)"
+            sleep 5
+          done
+          if [ ! -f "$ARTIFACTS_DIR/build-ready" ]; then
+            echo "ERROR: Timed out waiting for build-ready marker"
+            exit 1
+          fi
+
+      # Restore build artifacts from local filesystem
+      - name: Restore build-dist locally
+        run: |
+          if [ -d "$ARTIFACTS_DIR/build-dist" ]; then
+            cp -r "$ARTIFACTS_DIR/build-dist/." .
+          else
+            echo "ERROR: build-dist not found at $ARTIFACTS_DIR/build-dist"
+            exit 1
+          fi
+
+      # No `pnpm build` here — we reuse dist to save time
+
+      - name: Run tests
+        env:
+          PG_CONNECTION_STRING: postgres://postgres:postgres@localhost:55433/drizzle
+          PG_VECTOR_CONNECTION_STRING: postgres://postgres:postgres@localhost:54321/drizzle
+          PG_POSTGIS_CONNECTION_STRING: postgres://postgres:postgres@localhost:54322/drizzle
+          POSTGIS_URL: postgres://postgres:postgres@localhost:54322/drizzle
+          MYSQL_CONNECTION_STRING: mysql://root:mysql@localhost:3306/drizzle
+          PLANETSCALE_CONNECTION_STRING: ${{ secrets.PLANETSCALE_CONNECTION_STRING }}
+          NEON_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
+          TIDB_CONNECTION_STRING: ${{ secrets.TIDB_CONNECTION_STRING }}
+          XATA_API_KEY: ${{ secrets.XATA_API_KEY }}
+          XATA_BRANCH: ${{ secrets.XATA_BRANCH }}
+          LIBSQL_URL: file:local.db
+          LIBSQL_REMOTE_URL: ${{ secrets.LIBSQL_REMOTE_URL }}
+          LIBSQL_REMOTE_TOKEN: ${{ secrets.LIBSQL_REMOTE_TOKEN }}
+          TURSODATABASE_REMOTE_URL: ${{ secrets.TURSODATABASE_REMOTE_URL }}
+          TURSODATABASE_REMOTE_TOKEN: ${{ secrets.TURSODATABASE_REMOTE_TOKEN }}
+          COCKROACH_CONNECTION_STRING: postgresql://root@127.0.0.1:26257/defaultdb?sslmode=disable
+          MSSQL_CONNECTION_STRING: mssql://SA:drizzle123PASSWORD!@localhost:1433?encrypt=true&trustServerCertificate=true
+          TEST_CONFIG_PATH_PREFIX: ./tests/cli/
+          SQLITE_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_CLOUD_CONNECTION_STRING }}
+          SQLITE_MANY_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_MANY_CLOUD_CONNECTION_STRING }}
+        working-directory: integration-tests
+        shell: bash
+        run: |
+          set -euxo pipefail
+          if [[ ${{ github.event_name }} != "push" && "${{ github.event.pull_request.head.repo.full_name }}" != "${{ github.repository }}" ]]; then
+            export SKIP_EXTERNAL_DB_TESTS=1
+          fi
+          case ${{ matrix.shard }} in
+            int:postgres)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream vitest --reporter=verbose --silent=false run tests/pg/
+              fi
+            ;;
+            int:mysql)
+              pnpm --stream test:mysql
+            ;;
+            int:tidb)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream vitest --reporter=verbose --silent=false tests/mysql/tidb
+              fi
+            ;;
+            int:planetscale)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream test:planetscale
+              fi
+            ;;
+            int:cockroach) pnpm --stream vitest --reporter=verbose --silent=false run tests/cockroach ;;
+            int:mssql) pnpm --stream vitest --reporter=verbose --silent=false run tests/mssql ;;
+            int:sqlite) pnpm --stream test:sqlite ;;
+            int:turso-serverless) pnpm --stream vitest --reporter=verbose --silent=false --test-timeout=200000 --hook-timeout=200000 run tests/sqlite/tursodatabase-serverless.test.ts ;;
+            kit:other) cd ../drizzle-kit && pnpm --stream run test:other ;;
+            kit:postgres) cd ../drizzle-kit && pnpm --stream run test:postgres ;;
+            kit:cockroach)
+              export COCKROACH_CONNECTION_STRING="postgresql://root@127.0.0.1:26260/defaultdb?sslmode=disable;postgresql://root@127.0.0.1:26261/defaultdb?sslmode=disable;postgresql://root@127.0.0.1:26262/defaultdb?sslmode=disable"
+              cd ../drizzle-kit && pnpm --stream run test:cockroach
+            ;;
+            kit:mssql) cd ../drizzle-kit && pnpm --stream run test:mssql ;;
+            validators) 
+              (cd ../drizzle-zod && pnpm --stream test --reporter=verbose --silent=false)
+              (cd ../drizzle-valibot && pnpm --stream test --reporter=verbose --silent=false)
+              (cd ../drizzle-arktype && pnpm --stream test --reporter=verbose --silent=false)
+              (cd ../drizzle-typebox && pnpm --stream test --reporter=verbose --silent=false)
+            ;;
+            orm|seed)
+              (cd ../drizzle-${{ matrix.shard }} && pnpm --stream test --reporter=verbose --silent=false)
+            ;;
+          
+            int:bun)  bun test ./tests/bun/ ;;
+
+            int:other)
+              pnpm --stream vitest --reporter=verbose --silent=false run tests \
+                --exclude ./tests/mysql/ \
+                --exclude ./tests/cockroach/ \
+                --exclude ./tests/mssql/ \
+                --exclude ./tests/pg/ \
+                --exclude ./tests/sqlite/ \
+                --exclude ./tests/bun/
+            ;;
+            *) echo "Unknown shard: ${{matrix.shard}}"; exit 1 ;;
+          esac
+
+  attw:
+    needs: [prepare]
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: self-hosted
+    timeout-minutes: 20
+    steps:
+      - name: Setup PATH
+        run: |
+          echo "/home/alex/.volta/bin" >> $GITHUB_PATH
+          echo "/home/alex/.bun/bin" >> $GITHUB_PATH
+      - uses: actions/checkout@v4
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      
+      # Restore packages from local filesystem
+      - name: Restore packages locally
+        run: |
+          mkdir -p ./artifacts
+          cp -r "$ARTIFACTS_DIR/packages/." ./artifacts/
+      
+      - name: Run @arethetypeswrong/cli
+        run: |
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-kit/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-zod/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-seed/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-typebox/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-valibot/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-arktype/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/eslint-plugin-drizzle/package.tgz
+        env:
+          ATTW_FORMAT: concise
+
+  attw-orm:
+    needs: [prepare]
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: self-hosted
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        package: [node16-cjs, node16-esm, bundler]
+    steps:
+      - name: Setup PATH
+        run: |
+          echo "/home/alex/.volta/bin" >> $GITHUB_PATH
+          echo "/home/alex/.bun/bin" >> $GITHUB_PATH
+      - uses: actions/checkout@v4
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      
+      # Restore packages from local filesystem
+      - name: Restore packages locally
+        run: |
+          mkdir -p ./artifacts
+          cp -r "$ARTIFACTS_DIR/packages/." ./artifacts/
+      
+      - name: Run @arethetypeswrong/cli
+        working-directory: drizzle-orm
+        run: bun --bun run ../attw-fork/src/run.ts ../artifacts/drizzle-orm/package.tgz ${{ matrix.package }}
+        env:
+          ATTW_FORMAT: concise
+
+  release:
+    needs: [test, prepare, attw, attw-orm]
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: self-hosted
+    timeout-minutes: 20
+    permissions: { contents: read, id-token: write }
+    
+    # force empty so npm can use OIDC
+    env:
+      NODE_AUTH_TOKEN: ""   
+      NPM_TOKEN: ""
+    strategy:
+      matrix:
+        package: [drizzle-orm, drizzle-kit, drizzle-zod, drizzle-seed, drizzle-typebox, drizzle-valibot, drizzle-arktype, eslint-plugin-drizzle]
+    steps:
+      - name: Setup PATH
+        run: |
+          echo "/home/alex/.volta/bin" >> $GITHUB_PATH
+          echo "/home/alex/.bun/bin" >> $GITHUB_PATH
+      - uses: actions/checkout@v5
+      
+      # nuke, so npm can use OIDC
+      - name: Remove temp npmrc
+        run: rm -f "$NPM_CONFIG_USERCONFIG"
+    
+      # >= 11.5.1 for trusted publishing
+      - name: Update NPM
+        run: npm install -g npm@latest
+      
+      # Restore packages from local filesystem
+      - name: Restore packages locally
+        run: |
+          mkdir -p ./artifacts
+          cp -r "$ARTIFACTS_DIR/packages/." ./artifacts/
+      - name: Check preconditions (from tarball)
+        id: checks
+        shell: bash
+        run: |
+          set -euxo pipefail
+          
+          _version="$(tar -xOf ./artifacts/${{ matrix.package }}/package.tgz package/package.json | jq -r .version)"
+          tag="${{ github.ref_name }}"
+          suffix=$(git rev-parse --short HEAD)
+          version="$_version-$suffix"
+          tmpdir="$(mktemp -d)"
+          tar -xzf ./artifacts/${{ matrix.package }}/package.tgz -C "$tmpdir"
+
+          jq --arg v "$version" '.version = $v' \
+            "$tmpdir/package/package.json" > "$tmpdir/package/package.json.tmp"
+            mv "$tmpdir/package/package.json.tmp" "$tmpdir/package/package.json"
+
+          tar -czf ./artifacts/${{ matrix.package }}/package.tgz -C "$tmpdir" package
+          rm -rf "$tmpdir"
+
+          is_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
+          if [[ "$is_published" == "true" ]]; then
+            echo "\`${{ matrix.package }}@$version\` already published, tagging \`$tag\`" >> $GITHUB_STEP_SUMMARY
+          else
+            { echo "version=$version"; echo "tag=$tag"; echo "has_new_release=true"; } >> $GITHUB_OUTPUT
+          fi
+      - name: Publish (from tarball)
+        if: steps.checks.outputs.has_new_release == 'true'
+        shell: bash
+        run: |
+          set -euxo pipefail
+          npm publish ./artifacts/${{ matrix.package }}/package.tgz --tag "${{ steps.checks.outputs.tag }}"
+          echo "npm: \`${{ matrix.package }}@${{ steps.checks.outputs.tag }} | ${{ steps.checks.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+
+  # Cleanup local artifacts after workflow completes
+  cleanup:
+    runs-on: self-hosted
+    if: always()
+    needs: [release]
+    steps:
+      - name: Cleanup local artifacts
+        run: |
+          if [ -d "$ARTIFACTS_DIR" ]; then
+            rm -rf "$ARTIFACTS_DIR"
+            echo "Cleaned up artifacts at $ARTIFACTS_DIR"
+          fi
\ No newline at end of file
diff --git a/.github/workflows/release-feature-branch.yaml b/.github/workflows/release-feature-branch.yaml
index db482b5fc5..eefb038e57 100644
--- a/.github/workflows/release-feature-branch.yaml
+++ b/.github/workflows/release-feature-branch.yaml
@@ -1,418 +1,477 @@
 name: Release (feature branch)
 
 on:
-  push:
-    branches-ignore:
-      - main
-  pull_request: {}
+  workflow_call:
+    secrets:
+      PLANETSCALE_CONNECTION_STRING:
+        required: true
+      NEON_CONNECTION_STRING:
+        required: true
+      NEON_HTTP_CONNECTION_STRING:
+        required: true
+      TIDB_CONNECTION_STRING:
+        required: true
+      XATA_API_KEY:
+        required: true
+      XATA_BRANCH:
+        required: true
+      LIBSQL_REMOTE_URL:
+        required: true
+      LIBSQL_REMOTE_TOKEN:
+        required: true
+      TURSODATABASE_REMOTE_URL:
+        required: true
+      TURSODATABASE_REMOTE_TOKEN:
+        required: true
+      SQLITE_CLOUD_CONNECTION_STRING:
+        required: true
+      SQLITE_MANY_CLOUD_CONNECTION_STRING:
+        required: true
+      TURBO_TOKEN: 
+        required: true
+      NETLIFY_DB_URL: 
+        required: true
+
+concurrency:
+  group: feature-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  test:
-    # only run on all pushes or pull requests from forks
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
-    strategy:
-      matrix:
-        shard:
-          - gel
-          - planetscale
-          - singlestore-core
-          - singlestore-proxy
-          - singlestore-prefixed
-          - singlestore-custom
-          - neon-http
-          - neon-serverless
-          - drizzle-orm
-          - drizzle-kit
-          - drizzle-zod
-          - drizzle-seed
-          - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
-          - other
-    runs-on: ubuntu-22.04
-    services:
-      postgres-postgis:
-        image: postgis/postgis:16-3.4
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 54322:5432
-      postgres-vector:
-        image: pgvector/pgvector:pg16
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 54321:5432
-      postgres:
-        image: postgres:14
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 55433:5432
-      mysql:
-        image: mysql:8
-        env:
-          MYSQL_ROOT_PASSWORD: root
-          MYSQL_DATABASE: drizzle
-        options: >-
-          --health-cmd "mysqladmin ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 33306:3306
-      singlestore:
-        image: ghcr.io/singlestore-labs/singlestoredb-dev:latest
-        env:
-          ROOT_PASSWORD: singlestore
-        ports:
-          - 33307:3306
+  prepare:
+    if: github.repository == 'drizzle-team/drizzle-orm'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 25
+    env:
+      TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+      TURBO_TEAM: 'team_KbvYUtAn1Tqytsj8HbNcYDqV'
     steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
+      - uses: oven-sh/setup-bun@v2
+      - uses: actions/checkout@v5
+      - uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - uses: actions/setup-node@v6
+        with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      - name: Compute version suffix
+        id: meta
+        shell: bash
+        run: echo "suffix=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"
+      - name: Build all
+        run: pnpm build:artifact
+      - name: Upload build-dist
+        uses: actions/upload-artifact@v4
         with:
-          node-version: '20.19'
-          registry-url: 'https://registry.npmjs.org'
-
-      - uses: pnpm/action-setup@v3
-        name: Install pnpm
-        id: pnpm-install
+          name: build-dist
+          path: |
+            **/dist
+            **/*.tsbuildinfo
+      - name: Pack
+        run: pnpm pack:artifact
+      - uses: actions/upload-artifact@v4
+        with: 
+          name: packages
+          path: |
+            drizzle-orm/package.tgz
+            drizzle-kit/package.tgz
+            drizzle-seed/package.tgz
+            eslint-plugin-drizzle/package.tgz
+
+      # Tiny marker so other jobs can wait without failing
+      - name: Upload build-ready marker
+        run: mkdir -p .gh && echo "ok" > .gh/build-ready
+      - uses: actions/upload-artifact@v4
         with:
-          version: latest
-          run_install: false
+          name: build-ready
+          path: .gh/build-ready
+      - name: test:types & lint
+        run: pnpm test:types-lint
 
-      - name: Get pnpm store directory
-        id: pnpm-cache
+  test:
+    if: github.repository == 'drizzle-team/drizzle-orm'
+    # NOTE: no 'needs: [prepare]' on purpose — start early, warm DBs, then wait for artifacts
+    runs-on: ubuntu-24.04
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # - shard: int:singlestore
+          #   dbs: [singlestore]
+          # - shard: int:singlestore-core
+          #   dbs: [singlestore-many]
+          # - shard: int:singlestore-proxy
+          #   dbs: [singlestore-many]
+          - shard: int:mysql
+            dbs: [mysql]
+          - shard: int:postgres
+            dbs: [postgres]
+          - shard: int:sqlite
+            dbs: []
+          - shard: int:turso-serverless
+            dbs: []
+          - shard: int:other
+            dbs: [mysql, postgres, postgres-postgis, postgres-vector]
+          - shard: int:seeder
+            dbs: [mysql, postgres]
+          - shard: int:imports
+            dbs: []
+          - shard: int:planetscale
+            dbs: []
+          - shard: int:cockroach
+            dbs: [cockroach]
+          #  TODO:
+          # - shard: int:bun
+          #   dbs: [postgres, mysql]
+          - shard: int:mssql
+            dbs: [mssql]
+          - shard: orm
+            dbs: []
+          - shard: kit:other
+            dbs: [mysql]
+          - shard: kit:postgres
+            dbs: [postgres, postgres-postgis]
+          - shard: kit:postgres18
+            dbs: [postgres, postgres-postgis, postgres18]
+          - shard: kit:postgres17
+            dbs: [postgres, postgres-postgis, postgres17]
+          - shard: kit:postgres16
+            dbs: [postgres, postgres-postgis, postgres16]
+          - shard: kit:cockroach
+            dbs: [cockroach]
+          - shard: kit:mssql
+            dbs: [mssql]
+          - shard: seed
+            dbs: [cockroach, mysql, mssql, postgres-postgis, singlestore]
+          - shard: validators
+            dbs: []
+         
+    name: ${{ matrix.shard }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - uses: actions/setup-node@v6
+        with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - run: pnpm install --frozen-lockfile --prefer-offline
+
+      - name: Start DBs needed by shard (pre-warm)
+        if: ${{ matrix.dbs && join(matrix.dbs, ',') != '' }}
         shell: bash
         run: |
-          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_OUTPUT
-
-      - uses: actions/cache@v4
-        name: Setup pnpm cache
+          set -euxo pipefail
+          
+          compose_files=()
+          for db in ${{ join(matrix.dbs, ' ') }}; do
+            case "$db" in
+              postgres)            compose_files+=("-f" "compose/postgres.yml") ;;
+              postgres-postgis)    compose_files+=("-f" "compose/postgres-postgis.yml") ;;
+              postgres-vector)     compose_files+=("-f" "compose/postgres-vector.yml") ;;
+              postgres18)          compose_files+=("-f" "compose/postgres18.yml") ;;
+              postgres17)          compose_files+=("-f" "compose/postgres17.yml") ;;
+              postgres16)          compose_files+=("-f" "compose/postgres16.yml") ;;
+              mysql)               compose_files+=("-f" "compose/mysql.yml") ;;
+              singlestore)         compose_files+=("-f" "compose/singlestore.yml") ;;
+              singlestore-many)    compose_files+=("-f" "compose/singlestore-many.yml") ;;
+              mssql)               compose_files+=("-f" "compose/mssql.yml") ;;
+              cockroach)           compose_files+=("-f" "compose/cockroach.yml") ;;
+              *) echo "Unknown db '$db'"; exit 1 ;;
+            esac
+          done
+          docker compose "${compose_files[@]}" up -d
+
+          chmod +x compose/wait.sh
+          compose/wait.sh ${{ join(matrix.dbs, ' ') }}
+
+      - name: Wait for 'prepare' to finish (poll artifact)
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          run_id="${{ github.run_id }}"
+          repo="${{ github.repository }}"
+          echo "Waiting for 'build-ready' artifact from prepare job in run $run_id..."
+          for i in $(seq 1 120); do
+            artifacts_json="$(curl -fsSL -H "Authorization: Bearer $GH_TOKEN" \
+              -H "X-GitHub-Api-Version: 2022-11-28" \
+              -H "Accept: application/vnd.github+json" \
+              "https://api.github.com/repos/${repo}/actions/runs/${run_id}/artifacts")"
+            echo "$artifacts_json" | jq -e '.artifacts[] | select(.name=="build-ready")' >/dev/null 2>&1 && { echo "build-ready found"; break; }
+            echo "…still waiting ($i/120)"
+            sleep 5
+          done
+
+      - name: Download build-dist (compiled JS)
+        uses: actions/download-artifact@v4
         with:
-          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-store-
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Build Prisma client
-        working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
+          name: build-dist
+          path: .
 
-      - name: Build
-        run: pnpm build
+      # No `pnpm build` here — we reuse dist to save time
 
+      - uses: oven-sh/setup-bun@v2
       - name: Run tests
         env:
           PG_CONNECTION_STRING: postgres://postgres:postgres@localhost:55433/drizzle
           PG_VECTOR_CONNECTION_STRING: postgres://postgres:postgres@localhost:54321/drizzle
           PG_POSTGIS_CONNECTION_STRING: postgres://postgres:postgres@localhost:54322/drizzle
-          MYSQL_CONNECTION_STRING: mysql://root:root@localhost:33306/drizzle
+          PG18_URL: postgres://postgres:postgres@localhost:54325/drizzle
+          PG17_URL: postgres://postgres:postgres@localhost:54324/drizzle
+          PG16_URL: postgres://postgres:postgres@localhost:54323/drizzle
+          POSTGIS_URL: postgres://postgres:postgres@localhost:54322/drizzle
+          MYSQL_CONNECTION_STRING: mysql://root:mysql@localhost:3306/drizzle
           PLANETSCALE_CONNECTION_STRING: ${{ secrets.PLANETSCALE_CONNECTION_STRING }}
           NEON_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
-          # NEON_HTTP_CONNECTION_STRING: postgres://postgres:postgres@db.localtest.me:5432/postgres
-          NEON_HTTP_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
-          NEON_SERVERLESS_CONNECTION_STRING: postgres://postgres:postgres@localhost:5445/postgres
           TIDB_CONNECTION_STRING: ${{ secrets.TIDB_CONNECTION_STRING }}
           XATA_API_KEY: ${{ secrets.XATA_API_KEY }}
           XATA_BRANCH: ${{ secrets.XATA_BRANCH }}
           LIBSQL_URL: file:local.db
           LIBSQL_REMOTE_URL: ${{ secrets.LIBSQL_REMOTE_URL }}
           LIBSQL_REMOTE_TOKEN: ${{ secrets.LIBSQL_REMOTE_TOKEN }}
+          TURSODATABASE_REMOTE_URL: ${{ secrets.TURSODATABASE_REMOTE_URL }}
+          TURSODATABASE_REMOTE_TOKEN: ${{ secrets.TURSODATABASE_REMOTE_TOKEN }}
           SINGLESTORE_CONNECTION_STRING: singlestore://root:singlestore@localhost:33307/
+          SINGLESTORE_MANY_CONNECTION_STRING: singlestore://root:singlestore@localhost:3308/;singlestore://root:singlestore@localhost:3309/;singlestore://root:singlestore@localhost:3310/;singlestore://root:singlestore@localhost:3311/
+          COCKROACH_CONNECTION_STRING: postgresql://root@127.0.0.1:26257/defaultdb?sslmode=disable
+          MSSQL_CONNECTION_STRING: mssql://SA:drizzle123PASSWORD!@localhost:1433?encrypt=true&trustServerCertificate=true
+          TEST_CONFIG_PATH_PREFIX: ./tests/cli/
+          SQLITE_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_CLOUD_CONNECTION_STRING }}
+          SQLITE_MANY_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_MANY_CLOUD_CONNECTION_STRING }}
+          NETLIFY_DB_URL: ${{ secrets.NETLIFY_DB_URL }}
         working-directory: integration-tests
+        shell: bash
         run: |
-          if [[ ${{ github.event_name }} != "push" && "${{ github.event.pull_request.head.repo.full_name }}" != "${{ github.repository }}" ]]; then
+          set -euxo pipefail
+          if [[ "${{ github.event_name }}" == "pull_request" && "${{ github.event.pull_request.head.repo.full_name }}" != "${{ github.repository }}" ]]; then
             export SKIP_EXTERNAL_DB_TESTS=1
           fi
-
           case ${{ matrix.shard }} in
-
-            gel)
-              if [[ -z "$SKIP_EXTERNAL_DB_TESTS" ]]; then
-                pnpm vitest run tests/gel
-              fi
-            ;;
-
-            planetscale)
-              if [[ -z "$SKIP_EXTERNAL_DB_TESTS" ]]; then
-                pnpm vitest run \
-                  tests/mysql/mysql-planetscale.test.ts \
-                  tests/relational/mysql.planetscale-v1.test.ts \
-                  tests/relational/mysql.planetscale.test.ts
+            int:singlestore) pnpm --stream vitest --reporter=verbose --silent=false run ./singlestore/singlestore-prefixed.test.ts ./singlestore/singlestore-custom.test.ts ;;
+            int:singlestore-core) pnpm --stream vitest --reporter=verbose --silent=false run ./singlestore/singlestore.test.ts ;;
+            int:singlestore-proxy) pnpm --stream vitest --reporter=verbose --silent=false run ./singlestore/singlestore-proxy.test.ts ;;
+            int:postgres)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream test:postgres
               fi
             ;;
-
-            singlestore-core)
-              pnpm vitest run tests/singlestore/singlestore.test.ts
-            ;;
-
-            singlestore-proxy)
-              pnpm vitest run tests/singlestore/singlestore-proxy.test.ts
+            int:mysql)
+              pnpm --stream test:mysql
             ;;
-
-            singlestore-prefixed)
-              pnpm vitest run tests/singlestore/singlestore-prefixed.test.ts
-            ;;
-
-            singlestore-custom)
-              pnpm vitest run tests/singlestore/singlestore-custom.test.ts
+            int:tidb)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream vitest --reporter=verbose --silent=false tests/mysql/tidb
+              fi
             ;;
-
-            neon-http)
-              if [[ -z "$SKIP_EXTERNAL_DB_TESTS" ]]; then
-                pnpm vitest run tests/pg/neon-http.test.ts tests/pg/neon-http-batch.test.ts
+            int:planetscale)
+              if [[ -z "${SKIP_EXTERNAL_DB_TESTS:-}" ]]; then
+                pnpm --stream test:planetscale
               fi
             ;;
-
-            neon-serverless)
-              docker compose -f docker-neon.yml up -d
-              pnpm vitest run --config=./vitest-ci.config.ts tests/pg/neon-serverless.test.ts
-              docker compose -f docker-neon.yml down
+            int:cockroach) pnpm --stream vitest --reporter=verbose --silent=false run tests/cockroach ;;
+            int:mssql) pnpm --stream vitest --reporter=verbose --silent=false run tests/mssql ;;
+            int:sqlite) pnpm --stream test:sqlite ;;
+            int:turso-serverless) pnpm --stream vitest --reporter=verbose --silent=false --test-timeout=200000 --hook-timeout=200000 run tests/sqlite/tursodatabase-serverless.test.ts ;;
+            kit:other) cd ../drizzle-kit && pnpm --stream run test:other ;;
+            kit:postgres) cd ../drizzle-kit && pnpm --stream run test:postgres ;;
+            kit:postgres18) cd ../drizzle-kit && PG_VERSION=18 pnpm --stream run test:postgres ;;
+            kit:postgres17) cd ../drizzle-kit && PG_VERSION=17 pnpm --stream run test:postgres ;;
+            kit:postgres16) cd ../drizzle-kit && PG_VERSION=16 pnpm --stream run test:postgres ;;
+            kit:cockroach) cd ../drizzle-kit && pnpm --stream run test:cockroach ;;
+            kit:mssql) cd ../drizzle-kit && pnpm --stream run test:mssql ;;
+            validators)
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/validators
             ;;
-
-            drizzle-orm|drizzle-kit|drizzle-zod|drizzle-seed|drizzle-typebox|drizzle-valibot|drizzle-arktype)
-              (cd .. && pnpm test --filter ${{ matrix.shard }})
+            orm|seed)
+              (cd ../drizzle-${{ matrix.shard }} && pnpm --stream test --reporter=verbose --silent=false)
             ;;
+            
+            int:bun)  bun test ./tests/bun/ ;;
 
-            other)
-              pnpm vitest run \
-                --exclude tests/gel \
-                --exclude tests/mysql/mysql-planetscale.test.ts \
-                --exclude tests/relational/mysql.planetscale-v1.test.ts \
-                --exclude tests/relational/mysql.planetscale.test.ts \
-                --exclude tests/singlestore/singlestore.test.ts \
-                --exclude tests/singlestore/singlestore-proxy.test.ts \
-                --exclude tests/singlestore/singlestore-prefixed.test.ts \
-                --exclude tests/singlestore/singlestore-custom.test.ts \
-                --exclude tests/pg/neon-http.test.ts \
-                --exclude tests/pg/neon-http-batch.test.ts \
-                --exclude tests/pg/neon-serverless.test.ts
-            ;;
+            int:seeder) pnpm --stream test:seeder ;;
+            int:imports) pnpm --stream test:imports ;;
+            int:other) pnpm --stream test:other ;;
 
+            *) echo "Unknown shard: ${{matrix.shard}}"; exit 1 ;;
           esac
 
   attw:
-    # only run on all pushes or pull requests from forks
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
-    strategy:
-      matrix:
-        package:
-          - drizzle-orm
-          - drizzle-kit
-          - drizzle-zod
-          - drizzle-seed
-          - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
-          - eslint-plugin-drizzle
-    runs-on: ubuntu-22.04
+    if: github.repository == 'drizzle-team/drizzle-orm'
+    needs: [prepare]
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
-
-      - uses: pnpm/action-setup@v3
-        name: Install pnpm
-        id: pnpm-install
+      - uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - uses: actions/setup-node@v6
+        with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      - uses: oven-sh/setup-bun@v2
+      - name: Download package tarball
+        uses: actions/download-artifact@v4
         with:
-          version: latest
-          run_install: false
-
-      - name: Get pnpm store directory
-        id: pnpm-cache
-        shell: bash
+          name: packages
+          path: ./artifacts
+      - name: Run @arethetypeswrong/cli
         run: |
-          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_OUTPUT
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-kit/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/drizzle-seed/package.tgz
+          bun --bun run ./attw-fork/src/run.ts ./artifacts/eslint-plugin-drizzle/package.tgz
+        env:
+          ATTW_FORMAT: concise
 
-      - uses: actions/cache@v4
-        name: Setup pnpm cache
+  attw-orm:
+    if: github.repository == 'drizzle-team/drizzle-orm'
+    needs: [prepare]
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    strategy:
+      matrix:
+        package: [node16-cjs, node16-esm, bundler]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - uses: actions/setup-node@v6
+        with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - run: pnpm fetch && pnpm install --frozen-lockfile --prefer-offline
+      - uses: oven-sh/setup-bun@v2
+      - name: Download drizzle-orm tarball
+        uses: actions/download-artifact@v4
         with:
-          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-store-
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Install Bun
-        uses: oven-sh/setup-bun@v2
-
-      - name: Check preconditions
-        id: checks
-        shell: bash
-        working-directory: ${{ matrix.package }}
-        run: |
-          old_version="$(jq -r .version package.json)"
-          version="$old_version-$(git rev-parse --short HEAD)"
-          npm version $version
-          tag="${{ github.ref_name }}"
-          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
-
-          if [[ "$is_version_published" == "true" ]]; then
-            echo "\`${{ matrix.package }}$version\` already published, adding tag \`$tag\`" >> $GITHUB_STEP_SUMMARY
-            npm dist-tag add ${{ matrix.package }}@$version $tag
-          else
-            {
-              echo "version=$version"
-              echo "tag=$tag"
-              echo "has_new_release=true"
-            } >> $GITHUB_OUTPUT
-          fi
-
-      - name: Build Prisma client
-        if: steps.checks.outputs.has_new_release == 'true'
+          name: packages
+          path: ./artifacts
+      - name: Run @arethetypeswrong/cli
         working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
+        run: bun --bun run ../attw-fork/src/run.ts ../artifacts/drizzle-orm/package.tgz ${{ matrix.package }}
+        env:
+          ATTW_FORMAT: concise
 
-      - name: Build
-        if: steps.checks.outputs.has_new_release == 'true'
-        run: pnpm build
-      
-      - name: Pack
-        if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: ${{ matrix.package }}
-        run: npm run pack
-  
-      - name: Run @arethetypeswrong/cli
-        if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: ${{ matrix.package }}
-        run: bunx attw package.tgz
+  replit:
+    if: github.repository == 'replit/drizzle-orm'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+      - uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - uses: actions/setup-node@v6
+        with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - run: pnpm install --frozen-lockfile --prefer-offline
+      - name: Lint
+        run: pnpm lint:check
+      - name: Build Drizzle ORM dependency
+        run: pnpm --filter drizzle-orm build
+      - name: Test Drizzle Kit types
+        run: pnpm --filter drizzle-kit test:types
+      - name: Build upstream Drizzle Kit
+        if: hashFiles('drizzle-kit/tests/other/replit-api.test.ts') == ''
+        run: pnpm --filter drizzle-kit build
+      - name: Test Replit compatibility API
+        if: hashFiles('drizzle-kit/tests/other/replit-api.test.ts') != ''
+        run: pnpm --dir drizzle-kit exec vitest run tests/other/replit-api.test.ts
+      - name: Build Replit package
+        if: hashFiles('drizzle-kit/tests/other/replit-api.test.ts') != ''
+        run: pnpm --filter drizzle-kit pack:replit
+
+  skills-revision-gate:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    steps:
+      - name: Skip on non-pull-request events
+        if: github.event_name != 'pull_request'
+        run: echo "Not a pull request — skills revision gate does not apply"
+      - if: github.event_name == 'pull_request'
+        uses: actions/checkout@v5
+        with: { fetch-depth: 0 }
+      - if: github.event_name == 'pull_request'
+        uses: pnpm/action-setup@v4
+        with: { run_install: false }
+      - if: github.event_name == 'pull_request'
+        uses: actions/setup-node@v6
+        with: { node-version: '24', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - name: Skills revision gate
+        if: github.event_name == 'pull_request'
+        working-directory: drizzle-kit
+        env:
+          GH_BASE_SHA: ${{ github.event.pull_request.base.sha }}
+        run: |
+          pnpm install --frozen-lockfile --prefer-offline
+          pnpm skills:revision:check
 
   release:
-    # only run on all pushes or pull requests from forks
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
-    needs:
-      - test
-      - attw
+    needs: [test, prepare, attw, attw-orm, skills-revision-gate]
+    # workflow_dispatch only: this job holds `id-token: write` and is the sole path to
+    # the publish step, so PR/push events must never enter it — that would both expose
+    # OIDC minting to untrusted PR code and auto-publish on push.
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    permissions: { contents: read, id-token: write }
+    
+    # force empty so npm can use OIDC
+    env:
+      NODE_AUTH_TOKEN: ""   
+      NPM_TOKEN: ""
     strategy:
       matrix:
-        package:
-          - drizzle-orm
-          - drizzle-kit
-          - drizzle-zod
-          - drizzle-seed
-          - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
-          - eslint-plugin-drizzle
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: read
-      id-token: write
+        package: [drizzle-orm, drizzle-kit, drizzle-seed, eslint-plugin-drizzle]
     steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
+      - uses: actions/checkout@v5
 
-      - uses: pnpm/action-setup@v3
-        name: Install pnpm
-        id: pnpm-install
-        with:
-          version: latest
-          run_install: false
-
-      - name: Get pnpm store directory
-        id: pnpm-cache
-        shell: bash
-        run: |
-          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_OUTPUT
-
-      - uses: actions/cache@v4
-        name: Setup pnpm cache
+      # don't specify registry url, so there's no .npmrc config file
+      - uses: actions/setup-node@v6
+        with: { node-version: '24' }
+      
+      # nuke, so npm can use OIDC
+      - name: Remove temp npmrc
+        run: rm -f "$NPM_CONFIG_USERCONFIG"
+    
+      # >= 11.5.1 for trusted publishing
+      - name: Update NPM
+        run: npm install -g npm@latest
+      - name: Download package tarball
+        uses: actions/download-artifact@v4
         with:
-          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-store-
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Check preconditions
+          name: packages
+          path: ./artifacts
+      - name: Check preconditions (from tarball)
         id: checks
         shell: bash
-        working-directory: ${{ matrix.package }}
         run: |
-          old_version="$(jq -r .version package.json)"
-          version="$old_version-$(git rev-parse --short HEAD)"
-          npm version $version
-          tag="${{ github.ref_name }}"
-          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
-
-          if [[ "$is_version_published" == "true" ]]; then
-            echo "\`${{ matrix.package }}$version\` already published, adding tag \`$tag\`" >> $GITHUB_STEP_SUMMARY
-            npm dist-tag add ${{ matrix.package }}@$version $tag
+          set -euxo pipefail
+          
+          _version="$(tar -xOf ./artifacts/${{ matrix.package }}/package.tgz package/package.json | jq -r .version)"
+          branch="${{ github.ref_name }}"
+          if [[ "$branch" == "beta" ]]; then
+            tag="rc"
+            version="$_version"
           else
-            {
-              echo "version=$version"
-              echo "tag=$tag"
-              echo "has_new_release=true"
-            } >> $GITHUB_OUTPUT
+            tag="$branch"
+            suffix=$(git rev-parse --short HEAD)
+            version="$_version-$suffix"
           fi
+          tmpdir="$(mktemp -d)"
+          tar -xzf ./artifacts/${{ matrix.package }}/package.tgz -C "$tmpdir"
 
-      - name: Build Prisma client
-        working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
+          jq --arg v "$version" '.version = $v' \
+            "$tmpdir/package/package.json" > "$tmpdir/package/package.json.tmp"
+            mv "$tmpdir/package/package.json.tmp" "$tmpdir/package/package.json"
 
-      - name: Build
-        if: steps.checks.outputs.has_new_release == 'true'
-        run: pnpm build
+          tar -czf ./artifacts/${{ matrix.package }}/package.tgz -C "$tmpdir" package
+          rm -rf "$tmpdir"
 
-      - name: Pack
+          is_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
+          if [[ "$is_published" == "true" ]]; then
+            echo "\`${{ matrix.package }}@$version\` already published, tagging \`$tag\`" >> $GITHUB_STEP_SUMMARY
+          else
+            { echo "version=$version"; echo "tag=$tag"; echo "has_new_release=true"; } >> $GITHUB_OUTPUT
+          fi
+      - name: Publish (from tarball)
         if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: ${{ matrix.package }}
         shell: bash
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
-        run: npm run pack
-
-      - name: Publish
-        if: github.event_name == 'push' && steps.checks.outputs.has_new_release == 'true'
         run: |
-          tag="${{ steps.checks.outputs.tag }}"
-          version="${{ steps.checks.outputs.version }}"
-
-          echo "Publishing ${{ matrix.package }}@$tag using version $version"
-          npm run publish -- --tag $tag
-
-          echo "npm: \`${{ matrix.package }}@$tag | ${{ matrix.package }}@$version\`" >> $GITHUB_STEP_SUMMARY
-
-          # Post release message to Discord
-          # curl -X POST -H "Content-Type: application/json" -d "{\"embeds\": [{\"title\": \"New \`${{ matrix.package }}\` release! 🎉\", \"url\": \"https://www.npmjs.com/package/${{ matrix.package }}/v/$version\", \"color\": \"12907856\", \"fields\": [{\"name\": \"Version\", \"value\": \"\`$version\`\"}, {\"name\": \"Tag\", \"value\": \"\`$tag\`\"}]}]}" ${{ secrets.DISCORD_DEV_RELEASE_WEBHOOK_URL }}
-        working-directory: ${{ matrix.package }}
-        shell: bash
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
\ No newline at end of file
+          set -euxo pipefail
+          npm publish ./artifacts/${{ matrix.package }}/package.tgz --tag "${{ steps.checks.outputs.tag }}"
+          echo "npm: \`${{ matrix.package }}@${{ steps.checks.outputs.tag }} | ${{ steps.checks.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
diff --git a/.github/workflows/release-latest.yaml b/.github/workflows/release-latest.yaml
index 6f31f99c5b..7c0023375c 100644
--- a/.github/workflows/release-latest.yaml
+++ b/.github/workflows/release-latest.yaml
@@ -1,13 +1,44 @@
 name: Release (latest)
 
-on: workflow_dispatch
+on:
+  workflow_call:
+    secrets:
+      PLANETSCALE_CONNECTION_STRING:
+        required: true
+      NEON_CONNECTION_STRING:
+        required: true
+      NEON_HTTP_CONNECTION_STRING:
+        required: true
+      TIDB_CONNECTION_STRING:
+        required: true
+      XATA_API_KEY:
+        required: true
+      XATA_BRANCH:
+        required: true
+      LIBSQL_REMOTE_URL:
+        required: true
+      LIBSQL_REMOTE_TOKEN:
+        required: true
+      TURSODATABASE_REMOTE_URL:
+        required: true
+      TURSODATABASE_REMOTE_TOKEN:
+        required: true
+      SQLITE_CLOUD_CONNECTION_STRING:
+        required: true
+      SQLITE_MANY_CLOUD_CONNECTION_STRING:
+        required: true
+      TURBO_TOKEN: 
+        required: true
+
+env:
+  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+  TURBO_TEAM: 'team_KbvYUtAn1Tqytsj8HbNcYDqV'
 
 jobs:
   test:
     strategy:
       matrix:
         shard:
-          - gel
           - planetscale
           - singlestore-core
           - singlestore-proxy
@@ -15,13 +46,14 @@ jobs:
           - singlestore-custom
           - neon-http
           - neon-serverless
+          - cockroach
+          - mssql
           - drizzle-orm
           - drizzle-kit
-          - drizzle-zod
+          - drizzle-kit-cockroach 
+          - drizzle-kit-mssql 
           - drizzle-seed
-          - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
+          - validators
           - other
     runs-on: ubuntu-22.04
     services:
@@ -77,11 +109,22 @@ jobs:
         ports:
           - 33306:3306
       singlestore:
-        image: ghcr.io/singlestore-labs/singlestoredb-dev:latest
+        image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
         env:
           ROOT_PASSWORD: singlestore
         ports:
           - 33307:3306
+      mssql:
+        image: mcr.microsoft.com/azure-sql-edge
+        env:
+          ACCEPT_EULA: 1
+          MSSQL_SA_PASSWORD: drizzle123PASSWORD!
+        ports:
+          - 1433:1433
+      cockroachdb:
+        image: sukairo02/cockroachdb-launched:latest
+        ports:
+          - 26257:26257
     steps:
       - uses: actions/checkout@v4
 
@@ -111,13 +154,15 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
+      - uses: actions/cache@v4
+        name: Cache node_modules
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules
+
       - name: Install dependencies
         run: pnpm install
 
-      - name: Build Prisma client
-        working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
-
       - name: Build
         run: pnpm build
 
@@ -131,62 +176,93 @@ jobs:
           NEON_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
           # NEON_HTTP_CONNECTION_STRING: postgres://postgres:postgres@db.localtest.me:5432/postgres
           NEON_HTTP_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
-          NEON_SERVERLESS_CONNECTION_STRING: postgres://postgres:postgres@localhost:5445/postgres
+          # NEON_CONNECTION_STRING: postgres://postgres:postgres@localhost:5445/postgres
           TIDB_CONNECTION_STRING: ${{ secrets.TIDB_CONNECTION_STRING }}
           XATA_API_KEY: ${{ secrets.XATA_API_KEY }}
           XATA_BRANCH: ${{ secrets.XATA_BRANCH }}
           LIBSQL_URL: file:local.db
           LIBSQL_REMOTE_URL: ${{ secrets.LIBSQL_REMOTE_URL }}
           LIBSQL_REMOTE_TOKEN: ${{ secrets.LIBSQL_REMOTE_TOKEN }}
+          TURSODATABASE_REMOTE_URL: ${{ secrets.TURSODATABASE_REMOTE_URL }}
+          TURSODATABASE_REMOTE_TOKEN: ${{ secrets.TURSODATABASE_REMOTE_TOKEN }}
           SINGLESTORE_CONNECTION_STRING: singlestore://root:singlestore@localhost:33307/
+          COCKROACH_CONNECTION_STRING: postgresql://root@127.0.0.1:26257/defaultdb?sslmode=disable
+          MSSQL_CONNECTION_STRING: mssql://SA:drizzle123PASSWORD!@localhost:1433?encrypt=true&trustServerCertificate=true
+          TEST_CONFIG_PATH_PREFIX: ./tests/cli/
+          SQLITE_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_CLOUD_CONNECTION_STRING }}
         working-directory: integration-tests
         run: |
           case ${{ matrix.shard }} in
 
-            gel)
-              pnpm vitest run tests/gel
-            ;;
-
             planetscale)
-              pnpm vitest run \
+              pnpm --stream vitest --reporter=verbose --silent=false run \
                 tests/mysql/mysql-planetscale.test.ts \
                 tests/relational/mysql.planetscale-v1.test.ts \
                 tests/relational/mysql.planetscale.test.ts
             ;;
 
             singlestore-core)
-              pnpm vitest run tests/singlestore/singlestore.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/singlestore/singlestore.test.ts
             ;;
 
             singlestore-proxy)
-              pnpm vitest run tests/singlestore/singlestore-proxy.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/singlestore/singlestore-proxy.test.ts
             ;;
 
             singlestore-prefixed)
-              pnpm vitest run tests/singlestore/singlestore-prefixed.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/singlestore/singlestore-prefixed.test.ts
             ;;
 
             singlestore-custom)
-              pnpm vitest run tests/singlestore/singlestore-custom.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/singlestore/singlestore-custom.test.ts
             ;;
 
             neon-http)
-              pnpm vitest run tests/pg/neon-http.test.ts tests/pg/neon-http-batch.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/pg/neon-http.test.ts tests/pg/neon-http-batch.test.ts
             ;;
 
             neon-serverless)
               docker compose -f docker-neon.yml up -d
-              pnpm vitest run tests/pg/neon-serverless.test.ts
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/pg/neon-serverless.test.ts
               docker compose -f docker-neon.yml down
             ;;
 
-            drizzle-orm|drizzle-kit|drizzle-zod|drizzle-seed|drizzle-typebox|drizzle-valibot|drizzle-arktype)
+            cockroach)
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/cockroach
+            ;;
+
+            mssql)
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/mssql
+            ;;
+
+            drizzle-kit)
+              cd ../drizzle-kit
+              pnpm test:types
+              pnpm --stream vitest --reporter=verbose --silent=false run\
+              --exclude tests/cockroach \
+              --exclude tests/mssql
+            ;;
+
+            drizzle-kit-cockroach)
+              cd ../drizzle-kit
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/cockroach
+            ;;
+
+            drizzle-kit-mssql)
+              cd ../drizzle-kit
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/mssql
+            ;;
+
+            drizzle-orm|drizzle-seed)
               (cd .. && pnpm test --filter ${{ matrix.shard }})
             ;;
 
+            validators)
+              pnpm --stream vitest --reporter=verbose --silent=false run tests/validators
+            ;;
+
             other)
-              pnpm vitest run \
-                --exclude tests/gel \
+              pnpm --stream vitest --reporter=verbose --silent=false run \
                 --exclude tests/mysql/mysql-planetscale.test.ts \
                 --exclude tests/relational/mysql.planetscale-v1.test.ts \
                 --exclude tests/relational/mysql.planetscale.test.ts \
@@ -196,7 +272,10 @@ jobs:
                 --exclude tests/singlestore/singlestore-custom.test.ts \
                 --exclude tests/pg/neon-http.test.ts \
                 --exclude tests/pg/neon-http-batch.test.ts \
-                --exclude tests/pg/neon-serverless.test.ts
+                --exclude tests/pg/neon-serverless.test.ts \
+                --exclude tests/cockroach \
+                --exclude tests/mssql \
+                --exclude tests/validators
             ;;
 
           esac
@@ -205,13 +284,9 @@ jobs:
     strategy:
       matrix:
         package:
-          - drizzle-orm
           - drizzle-kit
-          - drizzle-zod
           - drizzle-seed
           - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
           - eslint-plugin-drizzle
     runs-on: ubuntu-22.04
     steps:
@@ -243,6 +318,12 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
+      - uses: actions/cache@v4
+        name: Cache node_modules
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules
+
       - name: Install dependencies
         run: pnpm install
 
@@ -266,10 +347,93 @@ jobs:
             } >> $GITHUB_OUTPUT
           fi
 
-      - name: Build Prisma client
+      - name: Build
+        if: steps.checks.outputs.has_new_release == 'true'
+        run: pnpm build
+      
+      - name: Pack
         if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        run: npm run pack
+  
+      - name: Run @arethetypeswrong/cli
+        if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        run: bun --bun run ../attw-fork/src/run.ts package.tgz
+        env:
+          ATTW_FORMAT: concise
+
+
+  attw-orm:
+    strategy:
+      matrix:
+        shard:
+          - node16-cjs
+          - node16-esm
+          - bundler
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - uses: pnpm/action-setup@v3
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: latest
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - uses: actions/cache@v4
+        name: Cache node_modules
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Install Bun
+        uses: oven-sh/setup-bun@v2
+
+      - name: Check preconditions
+        id: checks
+        shell: bash
         working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
+        run: |
+          old_version="$(jq -r .version package.json)"
+          version="$old_version-$(git rev-parse --short HEAD)"
+          npm version $version
+          tag="${{ github.ref_name }}"
+          is_version_published="$(npm view drizzle-orm versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
+
+          if [[ "$is_version_published" == "true" ]]; then
+            echo "\`drizzle-orm$version\` already published, adding tag \`$tag\`" >> $GITHUB_STEP_SUMMARY
+            npm dist-tag add drizzle-orm@$version $tag
+          else
+            {
+              echo "version=$version"
+              echo "tag=$tag"
+              echo "has_new_release=true"
+            } >> $GITHUB_OUTPUT
+          fi
 
       - name: Build
         if: steps.checks.outputs.has_new_release == 'true'
@@ -277,91 +441,39 @@ jobs:
       
       - name: Pack
         if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: ${{ matrix.package }}
+        working-directory: drizzle-orm
         run: npm run pack
   
       - name: Run @arethetypeswrong/cli
         if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: ${{ matrix.package }}
-        run: bunx attw package.tgz
+        working-directory: drizzle-orm
+        run: bun --bun run ../attw-fork/src/run.ts package.tgz ${{ matrix.shard }}
+        env:
+          ATTW_FORMAT: concise
 
   release:
-    permissions: write-all
+    permissions:
+      contents: write # for creating GitHub releases
+      id-token: write # for OIDC
     needs:
       - test
       - attw
+      - attw-orm
     strategy:
       fail-fast: false
       matrix:
         package:
           - drizzle-orm
           - drizzle-kit
-          - drizzle-zod
           - drizzle-seed
-          - drizzle-typebox
-          - drizzle-valibot
-          - drizzle-arktype
           - eslint-plugin-drizzle
     runs-on: ubuntu-22.04
-    services:
-      postgres-postgis:
-        image: postgis/postgis:16-3.4
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 54322:5432
-      postgres-vector:
-        image: pgvector/pgvector:pg16
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 54321:5432
-      postgres:
-        image: postgres:14
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: drizzle
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 55433:5432
-      mysql:
-        image: mysql:8
-        env:
-          MYSQL_ROOT_PASSWORD: root
-          MYSQL_DATABASE: drizzle
-        options: >-
-          --health-cmd "mysqladmin ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 33306:3306
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
+      # don't specify registry url, so there's no .npmrc config file
+      - uses: actions/setup-node@v6
+        with: { node-version: '24' }
 
       - uses: pnpm/action-setup@v3
         name: Install pnpm
@@ -384,6 +496,12 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
+      - uses: actions/cache@v4
+        name: Cache node_modules
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules
+
       - name: Install dependencies
         run: pnpm install
 
@@ -398,7 +516,6 @@ jobs:
 
           if [[ "$is_version_published" == "true" ]]; then
             echo "\`${{ matrix.package }}@$version\` already published, adding tag \`latest\`" >> $GITHUB_STEP_SUMMARY
-            npm dist-tag add ${{ matrix.package }}@$version latest
           elif [[ "$latest" != "$version" ]]; then
             echo "Latest:  $latest"
             echo "Current: $version"
@@ -419,11 +536,6 @@ jobs:
             echo "\`$version\` is already latest on NPM" >> $GITHUB_STEP_SUMMARY
           fi
 
-      - name: Build Prisma client
-        if: steps.checks.outputs.has_new_release == 'true'
-        working-directory: drizzle-orm
-        run: pnpm prisma generate --schema src/prisma/schema.prisma
-
       - name: Build
         if: steps.checks.outputs.has_new_release == 'true'
         run: pnpm build
@@ -432,16 +544,12 @@ jobs:
         if: steps.checks.outputs.has_new_release == 'true'
         working-directory: ${{ matrix.package }}
         shell: bash
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
         run: npm run pack
-
+      
       - name: Publish
         if: steps.checks.outputs.has_new_release == 'true'
         working-directory: ${{ matrix.package }}
         shell: bash
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
         run: |
           version="${{ steps.checks.outputs.version }}"
 
diff --git a/.github/workflows/router.yaml b/.github/workflows/router.yaml
new file mode 100644
index 0000000000..df8daf631b
--- /dev/null
+++ b/.github/workflows/router.yaml
@@ -0,0 +1,65 @@
+name: Release Router
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  switch:
+    runs-on: ubuntu-24.04
+    outputs:
+      target: ${{ steps.route.outputs.target }}
+    steps:
+      - name: Route release
+        id: route
+        shell: bash
+        run: |
+          HEAD_REPO="${{ github.event.pull_request.head.repo.full_name }}"
+          if [[ "$GITHUB_EVENT_NAME" == "workflow_dispatch" && "${GITHUB_REF##*/}" == "main" ]]; then
+            echo "target=latest" >> $GITHUB_OUTPUT
+          else
+            # workflow_dispatch on a non-main ref and any pull request (same-repo or
+            # fork) run the feature pipeline. Fork PRs run via the standard pull-request
+            # event so they get no repo secrets; the publish step is separately gated to
+            # workflow_dispatch only.
+            echo "target=feature" >> $GITHUB_OUTPUT
+          fi
+
+  run-feature:
+    needs: switch
+    if: needs.switch.outputs.target == 'feature'
+    uses: ./.github/workflows/release-feature-branch.yaml
+    secrets:
+      PLANETSCALE_CONNECTION_STRING: ${{ secrets.PLANETSCALE_CONNECTION_STRING }}
+      NEON_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
+      NEON_HTTP_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
+      TIDB_CONNECTION_STRING: ${{ secrets.TIDB_CONNECTION_STRING }}
+      XATA_API_KEY: ${{ secrets.XATA_API_KEY }}
+      XATA_BRANCH: ${{ secrets.XATA_BRANCH }}
+      LIBSQL_REMOTE_URL: ${{ secrets.LIBSQL_REMOTE_URL }}
+      LIBSQL_REMOTE_TOKEN: ${{ secrets.LIBSQL_REMOTE_TOKEN }}
+      TURSODATABASE_REMOTE_URL: ${{ secrets.TURSODATABASE_REMOTE_URL }}
+      TURSODATABASE_REMOTE_TOKEN: ${{ secrets.TURSODATABASE_REMOTE_TOKEN }}
+      SQLITE_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_CLOUD_CONNECTION_STRING }}
+      SQLITE_MANY_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_MANY_CLOUD_CONNECTION_STRING }}
+      TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+      NETLIFY_DB_URL: ${{ secrets.NETLIFY_DB_URL }}
+
+  run-latest:
+    needs: switch
+    if: needs.switch.outputs.target == 'latest'
+    uses: ./.github/workflows/release-latest.yaml
+    secrets:
+      PLANETSCALE_CONNECTION_STRING: ${{ secrets.PLANETSCALE_CONNECTION_STRING }}
+      NEON_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
+      NEON_HTTP_CONNECTION_STRING: ${{ secrets.NEON_CONNECTION_STRING }}
+      TIDB_CONNECTION_STRING: ${{ secrets.TIDB_CONNECTION_STRING }}
+      XATA_API_KEY: ${{ secrets.XATA_API_KEY }}
+      XATA_BRANCH: ${{ secrets.XATA_BRANCH }}
+      LIBSQL_REMOTE_URL: ${{ secrets.LIBSQL_REMOTE_URL }}
+      LIBSQL_REMOTE_TOKEN: ${{ secrets.LIBSQL_REMOTE_TOKEN }}
+      TURSODATABASE_REMOTE_URL: ${{ secrets.TURSODATABASE_REMOTE_URL }}
+      TURSODATABASE_REMOTE_TOKEN: ${{ secrets.TURSODATABASE_REMOTE_TOKEN }}
+      SQLITE_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_CLOUD_CONNECTION_STRING }}
+      SQLITE_MANY_CLOUD_CONNECTION_STRING: ${{ secrets.SQLITE_MANY_CLOUD_CONNECTION_STRING }}
+      TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
\ No newline at end of file
diff --git a/.github/workflows/unpublish-release-feature-branch.yaml b/.github/workflows/unpublish-release-feature-branch.yaml
index 4c27303f55..ad08e79a20 100644
--- a/.github/workflows/unpublish-release-feature-branch.yaml
+++ b/.github/workflows/unpublish-release-feature-branch.yaml
@@ -21,7 +21,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: '22'
+          node-version: '24'
           registry-url: 'https://registry.npmjs.org'
 
       - name: Unpublish
diff --git a/.gitignore b/.gitignore
index 3930b3b241..d47305c86e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
 node_modules
-.vscode
 dist
 dist.new
 *.tsbuildinfo
@@ -8,9 +7,18 @@ dist.new
 .cache
 .turbo
 .rollup.cache
+.wrangler
 dist-dts
 rollup.config-*.mjs
 *.log
 .DS_Store
 drizzle-seed/src/dev
-.direnv
+drizzle-orm/tmp
+drizzle-orm/types-bench.ts
+typeperf-test/tmp.tsconfig.json
+typeperf-test/trace
+typeperf-test/lib/big-schema.ts
+typeperf-test/lib/big-schema-rels.ts
+typeperf-test/.attest
+
+drizzle-kit/.env
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100644
index 0000000000..ea8c532e7e
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1,6 @@
+if command -v pnpm >/dev/null 2>&1; then
+  pnpm lint-staged
+else
+  echo "pnpm unavailable, trying via docker..."
+  sh ./compose/lint.sh
+fi
diff --git a/.nvmrc b/.nvmrc
index 8fdd954df9..a45fd52cc5 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-22
\ No newline at end of file
+24
diff --git a/.oxlintrc.json b/.oxlintrc.json
new file mode 100644
index 0000000000..3763784e26
--- /dev/null
+++ b/.oxlintrc.json
@@ -0,0 +1,125 @@
+{
+	"jsPlugins": ["./eslint/eslint-plugin-drizzle-internal/index.mjs"],
+	"lint-staged": {
+		"!**/eslint/eslint-plugin-drizzle-internal/**": "echo skip"
+	},
+	"rules": {
+		"typescript/consistent-type-imports": [
+			"error",
+			{
+				"prefer": "type-imports",
+				"disallowTypeAnnotations": true,
+				"fixStyle": "separate-type-imports"
+			}
+		],
+		"typescript/no-import-type-side-effects": "error",
+		"import/consistent-type-specifier-style Style": "error",
+		"import/no-cycle": "error",
+		"import/no-self-import": "error",
+		"import/no-empty-named-blocks": "error",
+		"import/no-duplicates": "error",
+		"import/extensions": [
+			"error",
+			"always",
+			{
+				"ignorePackages": true,
+				"checkTypeImports": true
+			}
+		],
+		"typescript/no-explicit-any": "off",
+		"typescript/no-non-null-assertion": "off",
+		"typescript/no-namespace": "off",
+		"no-unused-vars": [
+			"error",
+			{
+				"argsIgnorePattern": "^_",
+				"varsIgnorePattern": "^_"
+			}
+		],
+		"typescript/no-this-alias": "off",
+		"typescript/no-var-requires": "off",
+		"unicorn/prefer-node-protocol": "off",
+		"unicorn/prefer-top-level-await": "off",
+		"unicorn/catch-error-name": "off",
+		"unicorn/no-null": "off",
+		"unicorn/numeric-separators-style": "off",
+		"unicorn/explicit-length-check": "off",
+		"unicorn/filename-case": "off",
+		"unicorn/no-array-reduce": "off",
+		"unicorn/no-nested-ternary": "off",
+		"unicorn/no-useless-undefined": [
+			"error",
+			{
+				"checkArguments": false
+			}
+		],
+		"unicorn/no-this-assignment": "off",
+		"unicorn/empty-brace-spaces": "off",
+		"unicorn/no-thenable": "off",
+		"unicorn/consistent-function-scoping": "off",
+		"unicorn/prefer-type-error": "off",
+		"eqeqeq": "error",
+		"unicorn/no-instanceof-builtins": "error",
+		"unicorn/prefer-string-replace-all": "off",
+		"unicorn/no-process-exit": "off",
+		"unicorn/no-empty-file": "off",
+		"typescript/ban-ts-comment": "off",
+		"typescript/no-empty-interface": "off",
+		"typescript/no-unsafe-declaration-merging": "off",
+		"no-inner-declarations": "off",
+		"drizzle-internal/require-entity-kind": "error"
+	},
+	"overrides": [
+		{
+			"files": ["drizzle-orm/**/*"],
+			"rules": {
+				"drizzle-internal/no-instanceof": "error"
+			}
+		},
+		{
+			"files": [
+				"**/tests/**/*.ts",
+				"**/type-tests/**/*.ts",
+				"**/typeperf-test/**/*.ts"
+			],
+			"rules": {
+				"import/extensions": "off",
+				"no-useless-escape": "off",
+				"consistent-type-imports": "off",
+				"no-unused-vars": "off",
+				"no-unused-expressions": "off",
+				"drizzle-internal/require-entity-kind": "off"
+			}
+		},
+		{
+			"files": ["eslint-plugin-drizzle/**/*"],
+			"rules": {
+				"import/extensions": "off"
+			}
+		},
+		{
+			"files": ["**/*.d.ts"],
+			"rules": {
+				"typescript/consistent-type-imports": "off"
+			}
+		},
+		{
+			"files": ["drizzle-kit/**/*"],
+			"rules": {
+				"drizzle-internal/require-entity-kind": "off"
+			}
+		}
+	],
+	"ignorePatterns": [
+		"node_modules",
+		"dist",
+		"dist-dts",
+		"examples",
+		"**/*.js",
+		"**/*.mjs",
+		"**/*.cjs",
+		"**/playground",
+		"integration-tests/tests/prisma/*/client",
+		"integration-tests/tests/prisma/*/drizzle"
+	]
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000..f6d2925217
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,26 @@
+{
+	"typescript.tsdk": "node_modules/typescript/lib",
+	"editor.defaultFormatter": "dprint.dprint",
+	"[javascript]": {
+		"editor.defaultFormatter": "dprint.dprint"
+	},
+	"[typescript]": {
+		"editor.defaultFormatter": "dprint.dprint"
+	},
+	"[json]": {
+		"editor.defaultFormatter": "dprint.dprint"
+	},
+	"[markdown]": {
+		"editor.defaultFormatter": "dprint.dprint"
+	},
+	"oxc.enable": true,
+	"postman.settings.dotenv-detection-notification-visibility": false,
+	"files.watcherExclude": {
+		"**/dist/**": true,
+		"**/dist.new/**": true,
+		"**/.cache/**": true,
+		"**/.turbo/**": true,
+		"**/.rollup.cache/**": true,
+		"**/dist-dts/**": true
+	}
+}
diff --git a/README.md b/README.md
index 00499cacfd..ea8205d066 100644
--- a/README.md
+++ b/README.md
@@ -15,20 +15,11 @@
 <br/>
 <br/>
 
-### Replit development
-
-We use `drizzle-kit` for handling database migrations. However in order expose `drizzle-kit`s internal functions (which are not exported by default) they suggested cloning the `drizzle-orm` repo and making our changes just to the `drizzle-kit/api` file ([see here](./drizzle-kit/src/api.ts)) to build an external API particular for our use case.
-
-We do not require/import any of the other packages in this repo.
-
-#### Getting started
-To get started see the `drizzle-kit` ([README.md]./drizzle-kit/README.md).
-
 ### What's Drizzle?
 Drizzle is a modern TypeScript ORM developers [wanna use in their next project](https://stateofdb.com/tools/drizzle). 
 It is [lightweight](https://bundlephobia.com/package/drizzle-orm) at only ~7.4kb minified+gzipped, and it's tree shakeable with exactly 0 dependencies. 
 
-**Drizzle supports every PostgreSQL, MySQL and SQLite database**, including serverless ones like [Turso](https://orm.drizzle.team/docs/get-started-sqlite#turso), [Neon](https://orm.drizzle.team/docs/get-started-postgresql#neon), [Xata](xata.io), [PlanetScale](https://orm.drizzle.team/docs/get-started-mysql#planetscale), [Cloudflare D1](https://orm.drizzle.team/docs/get-started-sqlite#cloudflare-d1), [FlyIO LiteFS](https://fly.io/docs/litefs/), [Vercel Postgres](https://orm.drizzle.team/docs/get-started-postgresql#vercel-postgres), [Supabase](https://orm.drizzle.team/docs/get-started-postgresql#supabase) and [AWS Data API](https://orm.drizzle.team/docs/get-started-postgresql#aws-data-api). No bells and whistles, no Rust binaries, no serverless adapters, everything just works out of the box.
+**Drizzle supports every PostgreSQL, MySQL and SQLite database**, including serverless ones like [Turso](https://orm.drizzle.team/docs/get-started-sqlite#turso), [Neon](https://orm.drizzle.team/docs/get-started-postgresql#neon), [Xata](https://orm.drizzle.team/docs/connect-xata), [PlanetScale](https://orm.drizzle.team/docs/get-started-mysql#planetscale), [Cloudflare D1](https://orm.drizzle.team/docs/get-started-sqlite#cloudflare-d1), [FlyIO LiteFS](https://fly.io/docs/litefs/), [Vercel Postgres](https://orm.drizzle.team/docs/get-started-postgresql#vercel-postgres), [Supabase](https://orm.drizzle.team/docs/get-started-postgresql#supabase) and [AWS Data API](https://orm.drizzle.team/docs/get-started-postgresql#aws-data-api). No bells and whistles, no Rust binaries, no serverless adapters, everything just works out of the box.
 
 **Drizzle is serverless-ready by design**. It works in every major JavaScript runtime like NodeJS, Bun, Deno, Cloudflare Workers, Supabase functions, any Edge runtime, and even in browsers.  
 With Drizzle you can be [**fast out of the box**](https://orm.drizzle.team/benchmarks) and save time and costs while never introducing any data proxies into your infrastructure. 
diff --git a/actions/check/README.md b/actions/check/README.md
new file mode 100644
index 0000000000..c3bdef1660
--- /dev/null
+++ b/actions/check/README.md
@@ -0,0 +1,150 @@
+# Drizzle check action
+
+Runs the drizzle-kit installed in your project (`drizzle-kit check --output json`) against the
+checked-out repo and posts the result as a single sticky comment on the pull request. The comment
+flips to green when migrations are commutative and shows a per-conflict report when they are not.
+The step exits non-zero on conflicts, so CI goes red and the check can be marked as required.
+
+## Usage
+
+Add a step to a `pull_request`-triggered workflow that checks out the repo, installs your project's
+dependencies (`pnpm` shown below; `npm`, `yarn`, and `bun` are also detected automatically), then
+references this action. The package manager is auto-detected from the nearest lockfile at or above
+`working-directory`.
+
+```yaml
+name: Drizzle check
+on: pull_request
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+
+      - uses: drizzle-team/drizzle-orm/actions/check@main
+```
+
+## Custom config location
+
+`drizzle.config.ts` at the repository root is used by default. If your config lives elsewhere or
+has a different name, point the `config` input at it:
+
+```yaml
+      - uses: drizzle-team/drizzle-orm/actions/check@main
+        with:
+          config: config/drizzle.config.ts
+```
+
+## Monorepos
+
+Run the check from the package that declares `drizzle-kit` by setting `working-directory`; the
+`config` path is resolved relative to it:
+
+```yaml
+      - uses: drizzle-team/drizzle-orm/actions/check@main
+        with:
+          working-directory: packages/db
+```
+
+If `drizzle-kit` cannot be resolved in `working-directory` (for example, it is only installed in a
+nested package), the action posts a setup-guidance comment and fails the step instead of running
+the check.
+
+## Inputs
+
+| Input               | Description                                                                       | Default              |
+| ------------------- | --------------------------------------------------------------------------------- | -------------------- |
+| `config`            | Path to the drizzle config file, relative to `working-directory`.                 | `drizzle.config.ts`  |
+| `working-directory` | Directory to run the check in (package manager detected from the nearest lockfile at or above it). | `.`                  |
+| `github-token`      | Token used to post the sticky PR comment.                                         | `${{ github.token }}` |
+| `diagram`           | Whether to include a Mermaid diagram of the conflict in the PR comment (`true`/`false`). | auto (see below)     |
+
+## The conflict report
+
+When conflicts are found, the comment shows the affected part of the migration history in two
+forms: an optional Mermaid diagram and a text representation that is always present. The examples
+below all show the same situation: the current branch adds `0005_drop-inactive` while the base
+branch already gained `0005_add-banned`, both forked from `0004_add-status-enum` and both touching
+the `user_status` enum.
+
+### Diagram
+
+A Mermaid flowchart showing the conflicting migrations grouped by branch. Conflicting migrations
+are highlighted (solid for this branch's, outlined for ones already on the base branch) and
+annotated with the objects they touch; fork parents sharing the same conflicts collapse into a
+single node whose arrows point at the branch blocks. Migrations not involved in the conflict are
+omitted. Where GitHub renders Mermaid interactively (github.com and GitHub Enterprise Cloud),
+every migration name links to its folder at the checked commit.
+
+The diagram is controlled by the `diagram` input. When the input is not set, it is included where
+GitHub renders Mermaid — github.com, GitHub Enterprise Cloud, and GitHub Enterprise Server 3.7+ —
+and omitted on older GitHub Enterprise Server instances or when the server version cannot be
+determined. Set `diagram: true` or `diagram: false` to skip the detection and force it on or off.
+
+```mermaid
+%%{init: {"flowchart": {"subGraphTitleMargin": {"top": 4, "bottom": 24}, "wrappingWidth": 800}, "themeCSS": ".cluster-label p { text-align: center; line-height: 1.1; font-size: 0.8em; } .cluster-label p::first-line { font-size: 1.25em; } .forkone p { line-height: 1.1; font-size: 0.8em; } .forkone p::first-line { font-size: 1.25em; } .nodeLabel a { color: inherit !important; text-decoration: underline !important; } .nodeLabel { display: inline-block; min-width: 220px; }"}}%%
+flowchart TD
+    accTitle: Conflicting migrations
+    accDescr: Migrations on drop-inactive-status conflict with migrations already on main; all diverge from add-status-enum.
+    m0["<a href='https://github.com/acme/app/tree/da39a3ee/drizzle/0004_add-status-enum'>add-status-enum</a><br/>&nbsp;(parent migration)&nbsp;"]:::forkone
+    subgraph basebranch["main<br/>&nbsp;(base branch)&nbsp;"]
+        m1["<a href='https://github.com/acme/app/tree/da39a3ee/drizzle/0005_add-banned'>add-banned</a><br/>⚠ user_status"]
+    end
+    subgraph thisbranch["drop-inactive-status<br/>&nbsp;(this branch)&nbsp;"]
+        m2["<a href='https://github.com/acme/app/tree/da39a3ee/drizzle/0005_drop-inactive'>drop-inactive</a><br/>⚠ user_status"]
+    end
+    m0 -->|1 conflicting| basebranch
+    m0 -->|1 conflicting| thisbranch
+    style basebranch fill:#6e7781,fill-opacity:0.08,stroke:#6e7781,stroke-opacity:0.5
+    style thisbranch fill:#0969da,fill-opacity:0.08,stroke:#0969da,stroke-opacity:0.5
+    classDef conflictours fill:#cf222e,stroke:#82071e,color:#ffffff
+    class m2 conflictours
+    classDef conflictbase fill:none,stroke:#cf222e,stroke-width:2px,stroke-dasharray:4
+    class m1 conflictbase
+```
+
+*Solid red: conflicting migrations from this branch. Outlined red: conflicting migrations already
+on `main`.*
+
+### Text representation
+
+A nested, marker-less rendering of the conflict, always present below the diagram (and standalone
+when the diagram is off); every migration links to its folder at the checked commit. The markers
+mirror the diagram: 🔴 conflicting migration from this branch, ⭕ conflicting migration already on
+the base branch:
+
+<dl><dd>🔀 <code>drizzle/0004_add-status-enum</code> <em>(fork point)</em></dd><dd><dl><dd>🔴 <code>drizzle/0005_drop-inactive</code> <em>(this branch)</em> — recreates enum <code>user_status</code> in schema <code>public</code></dd><dd>⭕ <code>drizzle/0005_add-banned</code> <em>(from <code>main</code>)</em> — alters enum <code>user_status</code> in schema <code>public</code></dd></dl></dd></dl>
+
+## Permissions
+
+The job needs `pull-requests: write` so the action can create and update the sticky comment.
+The step exits non-zero when conflicts are detected, so it can be made a required check.
+
+## Branch protection
+
+The check runs on `pull_request` events, so it only sees the base branch as it was when the PR was
+last pushed. If another PR with a conflicting migration merges first, the existing green check (and
+comment) become stale — nothing re-runs them, and the conflict would only surface after both PRs
+land. Re-running the workflow manually does not help either: a re-run reuses the merge commit from
+the original event.
+
+To close this gap, protect the base branch with both:
+
+- the `check` job marked as a **required status check**, and
+- **"Require branches to be up to date before merging"** enabled.
+
+GitHub then forces the PR branch to be updated with the latest base before merging, which fires a
+`synchronize` event and re-runs the check against the real merge result — conflicting migrations
+flip the comment to red and block the merge instead of slipping through.
diff --git a/actions/check/action.yml b/actions/check/action.yml
new file mode 100644
index 0000000000..305c950bec
--- /dev/null
+++ b/actions/check/action.yml
@@ -0,0 +1,83 @@
+name: Drizzle check
+description: Run the project's `drizzle-kit check` and post the result as a sticky PR comment; fails on conflicts.
+
+inputs:
+  config:
+    description: Path to the drizzle config file, relative to working-directory.
+    required: false
+    default: drizzle.config.ts
+  working-directory:
+    description: Directory to run the check in.
+    required: false
+    default: .
+  github-token:
+    description: 'Token used to post the sticky PR comment. Needs `pull-requests: write`.'
+    required: false
+    default: ${{ github.token }}
+  diagram:
+    description: >-
+      Whether to include a Mermaid diagram of the conflicting migrations in the PR comment
+      (true/false). When unset, the diagram is included where GitHub renders Mermaid:
+      github.com, GitHub Enterprise Cloud, and GitHub Enterprise Server 3.7+.
+    required: false
+    default: ''
+
+runs:
+  using: composite
+  steps:
+    - id: check
+      shell: bash
+      working-directory: ${{ inputs.working-directory }}
+      env:
+        DRIZZLE_CONFIG: ${{ inputs.config }}
+      run: |
+        # In monorepos the lockfile usually lives above working-directory; walk up to find it.
+        dir=$(pwd)
+        pm_exec="npx --no-install"
+        while :; do
+          if [ -f "$dir/pnpm-lock.yaml" ]; then pm_exec="pnpm exec"; break; fi
+          if [ -f "$dir/yarn.lock" ]; then pm_exec="yarn"; break; fi
+          if [ -f "$dir/bun.lockb" ] || [ -f "$dir/bun.lock" ]; then pm_exec="bun x"; break; fi
+          if [ "$dir" = "/" ] || [ "$dir" = "${GITHUB_WORKSPACE:-}" ]; then break; fi
+          dir=$(dirname "$dir")
+        done
+
+        if ! $pm_exec drizzle-kit --version >/dev/null 2>&1; then
+          echo "::error::drizzle-kit could not be resolved in $(pwd) (tried '$pm_exec drizzle-kit')."
+          {
+            echo "not_found=true"
+            echo "envelope="
+            echo "exit_code=127"
+            echo "pm_exec=$pm_exec"
+          } >> "$GITHUB_OUTPUT"
+          exit 0
+        fi
+
+        set +e
+        envelope=$($pm_exec drizzle-kit check --config "$DRIZZLE_CONFIG" --output json)
+        code=$?
+        set -e
+
+        delimiter="DRIZZLE_ENVELOPE_$RANDOM$RANDOM"
+        {
+          echo "not_found=false"
+          echo "envelope<<$delimiter"
+          echo "$envelope"
+          echo "$delimiter"
+          echo "exit_code=$code"
+          echo "pm_exec=$pm_exec"
+        } >> "$GITHUB_OUTPUT"
+
+    - id: comment
+      shell: bash
+      working-directory: ${{ inputs.working-directory }}
+      env:
+        DRIZZLE_CHECK_ENVELOPE: ${{ steps.check.outputs.envelope }}
+        DRIZZLE_CHECK_EXIT_CODE: ${{ steps.check.outputs.exit_code }}
+        DRIZZLE_CHECK_NOT_FOUND: ${{ steps.check.outputs.not_found }}
+        DRIZZLE_WORKING_DIRECTORY: ${{ inputs.working-directory }}
+        DRIZZLE_PM_EXEC: ${{ steps.check.outputs.pm_exec }}
+        DRIZZLE_CONFIG: ${{ inputs.config }}
+        DRIZZLE_DIAGRAM: ${{ inputs.diagram }}
+        GITHUB_TOKEN: ${{ inputs.github-token }}
+      run: node "${{ github.action_path }}/post-comment.mjs"
diff --git a/actions/check/post-comment.mjs b/actions/check/post-comment.mjs
new file mode 100644
index 0000000000..2f4eb82ff2
--- /dev/null
+++ b/actions/check/post-comment.mjs
@@ -0,0 +1,659 @@
+// @ts-nocheck
+import { readFileSync } from 'node:fs';
+
+const MARKER = '<!-- drizzle-check -->';
+
+const env = process.env;
+
+function notice(message) {
+	process.stdout.write(`::notice::${message}\n`);
+}
+
+function readEvent() {
+	const path = env.GITHUB_EVENT_PATH;
+	if (!path) return null;
+	try {
+		return JSON.parse(readFileSync(path, 'utf8'));
+	} catch {
+		return null;
+	}
+}
+
+function resolvePrNumber(event) {
+	if (!event) return null;
+	return event.pull_request?.number ?? event.issue?.number ?? null;
+}
+
+function parseEnvelope(raw) {
+	if (!raw) return null;
+	const lines = raw
+		.split('\n')
+		.map((line) => line.trim())
+		.filter((line) => line.startsWith('{') && line.endsWith('}'));
+	for (let i = lines.length - 1; i >= 0; i--) {
+		try {
+			return JSON.parse(lines[i]);
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+
+function renderClean(envelope) {
+	const dialect = envelope.dialect ?? 'your migrations';
+	return `### ✅ No migration conflicts\n\n`
+		+ `\`drizzle-kit check\` found no conflicting migrations for \`${dialect}\`.`;
+}
+
+const ACTION_VERBS = {
+	create: 'creates',
+	drop: 'drops',
+	alter: 'alters',
+	recreate: 'recreates',
+	rename: 'renames',
+	move: 'moves',
+	add: 'adds',
+	remove: 'removes',
+	delete: 'deletes',
+};
+
+const SPECIAL_ACTIONS = {
+	alter_type_drop_value: 'removes a value from enum',
+};
+
+function humanizeAction(action) {
+	if (action in SPECIAL_ACTIONS) return SPECIAL_ACTIONS[action];
+	const [verb, ...rest] = action.split('_');
+	const conjugated = ACTION_VERBS[verb];
+	if (!conjugated) return action.replace(/_/g, ' ');
+	return rest.length ? `${conjugated} ${rest.join(' ')}` : conjugated;
+}
+
+function describeBranch(branch) {
+	const action = branch.action ?? '';
+	const target = branch.target;
+	if (!target || typeof target.name !== 'string') {
+		return humanizeAction(action);
+	}
+	const { name, schema, table } = target;
+	if (table) return `${humanizeAction(action)} \`${name}\` on table \`${table}\``;
+	if (schema) return `${humanizeAction(action)} \`${name}\` in schema \`${schema}\``;
+	return `${humanizeAction(action)} \`${name}\``;
+}
+
+function normalizedWd() {
+	return (env.DRIZZLE_WORKING_DIRECTORY || '.').replace(/^\.\/?/, '').replace(/\/+$/, '');
+}
+
+// Links a migration folder at the commit the check ran against (the PR merge commit),
+// so every listed migration — including ones coming from the base branch — resolves.
+function migrationUrl(path) {
+	const repo = env.GITHUB_REPOSITORY;
+	const sha = env.GITHUB_SHA;
+	if (!path || !repo || !sha) return null;
+	const server = env.GITHUB_SERVER_URL || 'https://github.com';
+	const wd = normalizedWd();
+	const fullPath = wd ? `${wd}/${path}` : path;
+	return `${server}/${repo}/tree/${sha}/${fullPath}`;
+}
+
+function migrationLink(path) {
+	const url = migrationUrl(path);
+	return url ? `[\`${path}\`](${url})` : `\`${path}\``;
+}
+
+async function fetchPrFiles(repo, prNumber, token) {
+	const files = [];
+	let page = 1;
+	while (true) {
+		const response = await gh(
+			'GET',
+			`/repos/${repo}/pulls/${prNumber}/files?per_page=100&page=${page}`,
+			token,
+		);
+		const batch = await response.json();
+		if (!Array.isArray(batch) || batch.length === 0) break;
+		files.push(...batch);
+		if (batch.length < 100) break;
+		page++;
+	}
+	return files;
+}
+
+// Classifies the conflict's migrations: folders added by this PR belong to the
+// current branch; everything else is already on the base branch.
+function buildBranchContext(error, files, event) {
+	const details = Array.isArray(error.details) ? error.details : [];
+	const outDirs = new Set();
+	for (const conflict of details) {
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			if (typeof branch.leafPath === 'string' && branch.leafPath.includes('/')) {
+				outDirs.add(branch.leafPath.split('/')[0]);
+			}
+		}
+	}
+	if (outDirs.size === 0) return null;
+
+	const wd = normalizedWd();
+	const wdPrefix = wd ? `${wd}/` : '';
+	const ownedFolders = new Set();
+	for (const file of files) {
+		if (file.status !== 'added' || typeof file.filename !== 'string') continue;
+		if (!file.filename.startsWith(wdPrefix)) continue;
+		const rel = file.filename.slice(wdPrefix.length);
+		const segments = rel.split('/');
+		if (segments.length < 3 || !outDirs.has(segments[0])) continue;
+		ownedFolders.add(`${segments[0]}/${segments[1]}`);
+	}
+
+	return {
+		ownedFolders: [...ownedFolders].sort(),
+		baseRef: event?.pull_request?.base?.ref ?? null,
+		headRef: event?.pull_request?.head?.ref ?? null,
+	};
+}
+
+// Diagram labels drop the timestamp prefix — the text representation below the
+// diagram carries the full folder names.
+function migrationName(folder) {
+	return folder.split('/').pop().replace(/^\d+_/, '');
+}
+
+// Truncation (paired with the wrappingWidth bump in the init directive) keeps
+// every label on a single line.
+function truncateEnd(label, max = 32) {
+	return label.length > max ? `${label.slice(0, max - 1)}…` : label;
+}
+
+function descriptionsByLeaf(error) {
+	const map = new Map();
+	for (const conflict of Array.isArray(error.details) ? error.details : []) {
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			if (!branch.leafPath) continue;
+			if (!map.has(branch.leafPath)) map.set(branch.leafPath, new Set());
+			map.get(branch.leafPath).add(describeBranch(branch));
+		}
+	}
+	return map;
+}
+
+// Object names (enum/table/column) each conflicting migration touches, keyed by folder.
+function conflictTargets(error) {
+	const map = new Map();
+	for (const conflict of Array.isArray(error.details) ? error.details : []) {
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			if (!branch.leafPath) continue;
+			const name = branch.target?.name;
+			if (typeof name !== 'string' || name.length === 0) continue;
+			if (!map.has(branch.leafPath)) map.set(branch.leafPath, new Set());
+			map.get(branch.leafPath).add(name);
+		}
+	}
+	return map;
+}
+
+function renderMermaid(error, ctx) {
+	const ownedSet = new Set(ctx?.ownedFolders ?? []);
+	const targets = conflictTargets(error);
+	const details = Array.isArray(error.details) ? error.details : [];
+
+	// Only the conflicting migrations are drawn, grouped by branch; all fork
+	// parents collapse into one node whose arrows point at the branch blocks
+	// rather than at individual migrations (the text representation below keeps
+	// the per-parent detail).
+	const leafPaths = new Set();
+	const parents = [];
+	for (const conflict of details) {
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			if (branch.leafPath) leafPaths.add(branch.leafPath);
+		}
+		const parentName = conflict.parentPath
+			? migrationName(conflict.parentPath)
+			: conflict.parentId ?? 'unknown parent';
+		if (!parents.some((parent) => parent.name === parentName)) {
+			parents.push({ name: parentName, path: conflict.parentPath ?? null });
+		}
+	}
+
+	const idMap = new Map();
+	let counter = 0;
+	const idFor = (key) => {
+		if (!idMap.has(key)) idMap.set(key, `m${counter++}`);
+		return idMap.get(key);
+	};
+
+	// Wraps just the migration name in an anchor, so only the name — not the whole
+	// node — is the click target. GitHub's renderer keeps <a> in label HTML and
+	// routes clicks to the top page; renderers that encode label HTML instead are
+	// already incompatible with the <br/> labels used throughout.
+	const linkedName = (name, path, max) => {
+		const label = truncateEnd(name, max);
+		const url = migrationUrl(path);
+		return url ? `<a href='${url}'>${label}</a>` : label;
+	};
+
+	const declareLeaf = (path) => {
+		const targetList = [...targets.get(path) ?? []];
+		const suffix = targetList.length > 0 ? `<br/>⚠ ${truncateEnd(targetList.join(', '))}` : '';
+		return `    ${idFor(path)}["${linkedName(migrationName(path), path, 28)}${suffix}"]`;
+	};
+
+	const lines = [
+		'```mermaid',
+		// subGraphTitleMargin reserves room for the two-line subgraph titles so nodes
+		// don't overlap them; themeCSS centers the title and shrinks its second line
+		// (::first-line restores the branch name to full size — there is no inline
+		// tag for font sizing that survives mermaid's sanitizer, so CSS is the only
+		// way in). wrappingWidth keeps labels on one line; truncation bounds length.
+		'%%{init: {"flowchart": {"subGraphTitleMargin": {"top": 4, "bottom": 24}, "wrappingWidth": 800}, '
+		+ '"themeCSS": ".cluster-label p { text-align: center; line-height: 1.1; font-size: 0.8em; } '
+		+ '.cluster-label p::first-line { font-size: 1.25em; } '
+		// forkone sizes the fork node's role line down to match the subgraph titles'
+		// role lines; see the fork label construction.
+		+ '.forkone p { line-height: 1.1; font-size: 0.8em; } '
+		+ '.forkone p::first-line { font-size: 1.25em; } '
+		// Migration names are inline anchors; !important outranks the host page's
+		// link styling so they keep the node text color (white on the red conflict
+		// nodes) and stay underlined as the link affordance.
+		+ '.nodeLabel a { color: inherit !important; text-decoration: underline !important; } '
+		// min-width on labels equalizes migration node widths.
+		+ '.nodeLabel { display: inline-block; min-width: 220px; }"}}%%',
+		'flowchart TD',
+	];
+
+	const accBranches = ctx
+		? `Migrations on ${ctx.headRef ?? 'this branch'} conflict with migrations already on ${
+			ctx.baseRef ?? 'the base branch'
+		}`
+		: 'Migrations generated in parallel conflict with each other';
+	lines.push(
+		'    accTitle: Conflicting migrations',
+		`    accDescr: ${accBranches}; all diverge from ${parents.map((parent) => parent.name).join(', ')}.`,
+	);
+
+	// The role line is shrunk via ::first-line — the only per-line CSS hook — which
+	// works only when it trails a single name line (the forkone rules restore the
+	// name to full size); with several parents the role line is omitted.
+	const parentNames = parents.map((parent) => linkedName(parent.name, parent.path, 30));
+	lines.push(
+		parentNames.length === 1
+			? `    ${idFor('fork')}["${parentNames[0]}<br/>&nbsp;(parent migration)&nbsp;"]:::forkone`
+			: `    ${idFor('fork')}["${parentNames.join('<br/>')}"]`,
+	);
+
+	const base = [...leafPaths].filter((path) => !ownedSet.has(path));
+	const owned = [...leafPaths].filter((path) => ownedSet.has(path));
+
+	if (ctx && base.length > 0) {
+		// The nbsp padding buffers the role line against label-width measurement
+		// happening before the final fonts apply, which otherwise clips its edges.
+		lines.push(
+			`    subgraph basebranch["${
+				ctx.baseRef ? `${truncateEnd(ctx.baseRef, 28)}<br/>&nbsp;(base branch)&nbsp;` : 'base branch'
+			}"]`,
+		);
+		for (const path of base) lines.push(`    ${declareLeaf(path)}`);
+		lines.push('    end');
+	} else {
+		for (const path of base) lines.push(declareLeaf(path));
+	}
+	if (owned.length > 0) {
+		lines.push(
+			`    subgraph thisbranch["${
+				ctx?.headRef ? `${truncateEnd(ctx.headRef, 28)}<br/>&nbsp;(this branch)&nbsp;` : 'this branch'
+			}"]`,
+		);
+		for (const path of owned) lines.push(`    ${declareLeaf(path)}`);
+		lines.push('    end');
+	}
+
+	const forkId = idFor('fork');
+	if (ctx) {
+		// Base branch edge first — edge order places its block on the left.
+		if (base.length > 0) lines.push(`    ${forkId} -->|${base.length} conflicting| basebranch`);
+		if (owned.length > 0) lines.push(`    ${forkId} -->|${owned.length} conflicting| thisbranch`);
+	} else {
+		for (const path of leafPaths) lines.push(`    ${forkId} --> ${idFor(path)}`);
+	}
+
+	// Semi-transparent tints stay legible on both GitHub themes: blue marks this
+	// branch's block, gray the base branch's.
+	if (ctx && base.length > 0) {
+		lines.push('    style basebranch fill:#6e7781,fill-opacity:0.08,stroke:#6e7781,stroke-opacity:0.5');
+	}
+	if (owned.length > 0) {
+		lines.push('    style thisbranch fill:#0969da,fill-opacity:0.08,stroke:#0969da,stroke-opacity:0.5');
+	}
+
+	// Solid mid-tone fill with explicit white text stays readable in both light
+	// and dark GitHub themes; theme-adaptive defaults only restyle unclassed nodes.
+	const oursConflicts = owned.map((path) => idFor(path));
+	const baseConflicts = base.map((path) => idFor(path));
+	if (ctx && oursConflicts.length + baseConflicts.length > 0) {
+		if (oursConflicts.length > 0) {
+			lines.push('    classDef conflictours fill:#cf222e,stroke:#82071e,color:#ffffff');
+			lines.push(`    class ${oursConflicts.join(',')} conflictours`);
+		}
+		if (baseConflicts.length > 0) {
+			lines.push('    classDef conflictbase fill:none,stroke:#cf222e,stroke-width:2px,stroke-dasharray:4');
+			lines.push(`    class ${baseConflicts.join(',')} conflictbase`);
+		}
+	} else if (oursConflicts.length + baseConflicts.length > 0) {
+		lines.push('    classDef conflict fill:#cf222e,stroke:#82071e,color:#ffffff');
+		lines.push(`    class ${[...oursConflicts, ...baseConflicts].join(',')} conflict`);
+	}
+	lines.push('```');
+
+	if (ctx) {
+		const baseName = ctx.baseRef ? `\`${ctx.baseRef}\`` : 'the base branch';
+		lines.push(
+			'',
+			`*Solid red: conflicting migrations from this branch. Outlined red: conflicting migrations already on ${baseName}.*`,
+		);
+	} else {
+		lines.push('', '*Red: conflicting migrations.*');
+	}
+	return lines;
+}
+
+function htmlEscape(text) {
+	return text
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;');
+}
+
+// Markdown is not processed inside HTML blocks, so inline code spans in the
+// humanized descriptions convert to <code> tags explicitly.
+function inlineHtml(text) {
+	return text
+		.split('`')
+		.map((part, i) => (i % 2 === 1 ? `<code>${htmlEscape(part)}</code>` : htmlEscape(part)))
+		.join('');
+}
+
+function migrationLinkHtml(path) {
+	const label = `<code>${htmlEscape(path)}</code>`;
+	const url = migrationUrl(path);
+	return url ? `<a href="${url}">${label}</a>` : label;
+}
+
+// Rendered as <dl>/<dd> blocks: indented like a nested list, but without markers,
+// and wrapped lines keep their row's indentation.
+function renderNestedList(error, ctx) {
+	const descriptions = descriptionsByLeaf(error);
+	const baseLabel = ctx?.baseRef ? `from <code>${htmlEscape(ctx.baseRef)}</code>` : 'from the base branch';
+	const ownedSet = new Set(ctx?.ownedFolders ?? []);
+	const origin = (folder) => {
+		if (!ctx) return '';
+		return ownedSet.has(folder) ? ' <em>(this branch)</em>' : ` <em>(${baseLabel})</em>`;
+	};
+	// Mirrors the diagram: solid red for this branch's conflicts, outlined for the base's.
+	const conflictEmoji = (folder) => (!ctx || ownedSet.has(folder)) ? '🔴' : '⭕';
+	const descsHtml = (path) => {
+		const list = [...descriptions.get(path) ?? []].filter(Boolean);
+		return list.length > 0 ? ` — ${inlineHtml(list.join('; '))}` : '';
+	};
+
+	const byParent = new Map();
+	for (const conflict of Array.isArray(error.details) ? error.details : []) {
+		const parent = conflict.parentPath
+			? migrationLinkHtml(conflict.parentPath)
+			: `<code>${htmlEscape(conflict.parentId ?? '(unknown parent)')}</code>`;
+		if (!byParent.has(parent)) byParent.set(parent, new Map());
+		const leaves = byParent.get(parent);
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			const key = branch.leafPath ?? branch.leafId ?? '(unknown migration)';
+			if (!leaves.has(key)) leaves.set(key, branch.leafPath ?? null);
+		}
+	}
+
+	const groups = [];
+	for (const [parent, leaves] of byParent) {
+		const leafItems = [...leaves].map(([key, path]) => {
+			const label = path ? migrationLinkHtml(path) : `<code>${htmlEscape(key)}</code>`;
+			const emoji = path ? conflictEmoji(path) : '🔴';
+			return `<dd>${emoji} ${label}${path ? origin(path) : ''}${path ? descsHtml(path) : ''}</dd>`;
+		});
+		// Children go into a sibling wrapper <dd> rather than the parent's own <dd>:
+		// every line then carries the same dd bottom margin, keeping spacing uniform.
+		groups.push(`<dd>🔀 ${parent} <em>(fork point)</em></dd><dd><dl>${leafItems.join('')}</dl></dd>`);
+	}
+	return [`<dl>${groups.join('')}</dl>`];
+}
+
+function regenerateCommands(ctx) {
+	const wd = normalizedWd();
+	const pmExec = (env.DRIZZLE_PM_EXEC || 'npx --no-install') === 'npx --no-install'
+		? 'npx'
+		: env.DRIZZLE_PM_EXEC;
+	const config = env.DRIZZLE_CONFIG && env.DRIZZLE_CONFIG !== 'drizzle.config.ts'
+		? ` --config ${env.DRIZZLE_CONFIG}`
+		: '';
+
+	const lastFolder = ctx.ownedFolders[ctx.ownedFolders.length - 1];
+	const lastName = lastFolder.split('/').pop().split('_').slice(1).join('_');
+
+	const commands = [];
+	if (wd) commands.push(`cd ${wd}`);
+	commands.push(`rm -rf ${ctx.ownedFolders.join(' ')}`);
+	commands.push(`${pmExec} drizzle-kit generate${lastName ? ` --name ${lastName}` : ''}${config}`);
+	return commands;
+}
+
+// Mermaid renders on github.com and GitHub Enterprise Cloud unconditionally, and on
+// GitHub Enterprise Server starting with 3.7. Rendering happens client-side, so the
+// server version is the only queryable signal.
+async function mermaidSupported(token) {
+	const server = env.GITHUB_SERVER_URL || 'https://github.com';
+	let host;
+	try {
+		host = new URL(server).hostname;
+	} catch {
+		return false;
+	}
+	if (host === 'github.com' || host === 'ghe.com' || host.endsWith('.ghe.com')) return true;
+
+	try {
+		const api = env.GITHUB_API_URL || `${server.replace(/\/+$/, '')}/api/v3`;
+		const response = await fetch(`${api}/meta`, {
+			headers: {
+				Accept: 'application/vnd.github+json',
+				'User-Agent': 'drizzle-check-action',
+				...(token ? { Authorization: `Bearer ${token}` } : {}),
+			},
+		});
+		if (!response.ok) return false;
+		const meta = await response.json();
+		const match = typeof meta?.installed_version === 'string'
+			? meta.installed_version.match(/^(\d+)\.(\d+)/)
+			: null;
+		if (!match) return false;
+		const major = Number(match[1]);
+		const minor = Number(match[2]);
+		return major > 3 || (major === 3 && minor >= 7);
+	} catch {
+		return false;
+	}
+}
+
+function renderConflicts(error, ctx, includeDiagram) {
+	const details = Array.isArray(error.details) ? error.details : [];
+	const count = typeof error.conflicts === 'number' ? error.conflicts : details.length;
+
+	const leafIds = new Set();
+	for (const conflict of details) {
+		for (const branch of Array.isArray(conflict.branches) ? conflict.branches : []) {
+			leafIds.add(branch.leafId ?? branch.leafPath);
+		}
+	}
+
+	const lines = [
+		`### ❌ Conflicting migrations detected`,
+		'',
+		`Found **${count}** conflict${count === 1 ? '' : 's'}`
+		+ (leafIds.size > 0 ? ` across **${leafIds.size}** migration${leafIds.size === 1 ? '' : 's'}.` : '.'),
+		'',
+		'These migrations were generated in parallel from the same parent migration and modify the same '
+		+ 'database objects, so the resulting database state depends on the order they are applied in.',
+	];
+
+	if (includeDiagram) {
+		lines.push('', ...renderMermaid(error, ctx));
+	}
+	lines.push('', ...renderNestedList(error, ctx));
+
+	if (ctx && ctx.ownedFolders.length > 0) {
+		const plural = ctx.ownedFolders.length === 1 ? '' : 's';
+		lines.push(
+			'',
+			`To resolve this, update the branch with the latest ${ctx.baseRef ? `\`${ctx.baseRef}\`` : 'base branch'} `
+				+ `(merge or rebase), then regenerate this branch's migration${plural} on top of the migrations it brings in:`,
+			'',
+			'```sh',
+			...regenerateCommands(ctx),
+			'```',
+			'',
+			'Commit the result and push.',
+		);
+	} else {
+		lines.push(
+			'',
+			'To resolve this, regenerate the migration that belongs to this branch: update the branch with '
+				+ "the latest base branch, delete this branch's conflicting migration folder, and run "
+				+ '`drizzle-kit generate` again so the migration is created on top of the latest one.',
+		);
+	}
+
+	return lines.join('\n');
+}
+
+function renderError(error, exitCode) {
+	const kind = error?.kind ? ` (\`${error.kind}\`)` : '';
+	const message = error?.message ?? `drizzle-kit check failed with exit code ${exitCode}`;
+	return `### ⚠️ drizzle-kit check failed${kind}\n\n${message}`;
+}
+
+function renderNotFound(workingDirectory) {
+	return `### ⚠️ drizzle-kit not found\n\n`
+		+ `\`drizzle-kit\` could not be resolved in \`${workingDirectory}\`. `
+		+ `Make sure the workflow installs dependencies before this step and that \`drizzle-kit\` is a `
+		+ `dependency of the package containing your drizzle config. In a monorepo, point the `
+		+ `\`working-directory\` input at that package.`;
+}
+
+async function gh(method, path, token, body) {
+	const response = await fetch(`https://api.github.com${path}`, {
+		method,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: 'application/vnd.github+json',
+			'X-GitHub-Api-Version': '2022-11-28',
+			'User-Agent': 'drizzle-check-action',
+			'Content-Type': 'application/json',
+		},
+		body: body ? JSON.stringify(body) : undefined,
+	});
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`GitHub API ${method} ${path} failed: ${response.status} ${text}`);
+	}
+	return response;
+}
+
+async function findExistingComment(repo, prNumber, token) {
+	let page = 1;
+	while (true) {
+		const response = await gh(
+			'GET',
+			`/repos/${repo}/issues/${prNumber}/comments?per_page=100&page=${page}`,
+			token,
+		);
+		const comments = await response.json();
+		if (!Array.isArray(comments) || comments.length === 0) return null;
+		const match = comments.find((comment) => typeof comment.body === 'string' && comment.body.includes(MARKER));
+		if (match) return match;
+		if (comments.length < 100) return null;
+		page++;
+	}
+}
+
+async function upsertComment(repo, prNumber, token, body) {
+	const fullBody = `${MARKER}\n${body}`;
+	const existing = await findExistingComment(repo, prNumber, token);
+	if (existing) {
+		await gh('PATCH', `/repos/${repo}/issues/comments/${existing.id}`, token, { body: fullBody });
+	} else {
+		await gh('POST', `/repos/${repo}/issues/${prNumber}/comments`, token, { body: fullBody });
+	}
+}
+
+async function main() {
+	const exitCode = Number.parseInt(env.DRIZZLE_CHECK_EXIT_CODE ?? '0', 10) || 0;
+	const envelope = parseEnvelope(env.DRIZZLE_CHECK_ENVELOPE);
+
+	const token = env.GITHUB_TOKEN;
+	const repo = env.GITHUB_REPOSITORY;
+	const event = readEvent();
+	const prNumber = resolvePrNumber(event);
+
+	let body;
+	let hasConflicts = false;
+	let failed = exitCode !== 0;
+
+	if (env.DRIZZLE_CHECK_NOT_FOUND === 'true') {
+		body = renderNotFound(env.DRIZZLE_WORKING_DIRECTORY || '.');
+		failed = true;
+	} else if (envelope?.status === 'ok') {
+		body = renderClean(envelope);
+		failed = exitCode !== 0;
+	} else if (
+		envelope?.status === 'error'
+		&& envelope.error?.code === 'check_error'
+		&& envelope.error?.kind === 'conflicts'
+	) {
+		let ctx = null;
+		if (prNumber && token && repo) {
+			try {
+				const files = await fetchPrFiles(repo, prNumber, token);
+				ctx = buildBranchContext(envelope.error, files, event);
+			} catch (e) {
+				notice(`Could not determine which migrations belong to this PR: ${e instanceof Error ? e.message : e}`);
+			}
+		}
+		const diagramInput = (env.DRIZZLE_DIAGRAM || '').toLowerCase().trim();
+		const includeDiagram = diagramInput === ''
+			? await mermaidSupported(token)
+			: diagramInput !== 'false';
+		body = renderConflicts(envelope.error, ctx, includeDiagram);
+		hasConflicts = true;
+		failed = true;
+	} else if (envelope?.status === 'error') {
+		body = renderError(envelope.error, exitCode);
+		failed = true;
+	} else {
+		body = renderError(undefined, exitCode);
+		failed = true;
+	}
+
+	if (!prNumber || !token || !repo) {
+		notice('No pull request context — skipping sticky comment.');
+	} else {
+		try {
+			await upsertComment(repo, prNumber, token, body);
+		} catch (e) {
+			process.stdout.write(`::error::${e instanceof Error ? e.message : String(e)}\n`);
+			// A comment-write failure must not mask a clean check, but must not hide conflicts either.
+			if (!failed) process.exit(1);
+		}
+	}
+
+	process.exit(hasConflicts || failed ? 1 : 0);
+}
+
+main().catch((e) => {
+	process.stdout.write(`::error::${e instanceof Error ? e.message : String(e)}\n`);
+	process.exit(1);
+});
diff --git a/attw-fork/LICENSE b/attw-fork/LICENSE
new file mode 100644
index 0000000000..fee6e3657d
--- /dev/null
+++ b/attw-fork/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2023 Andrew Branch
+
+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.
\ No newline at end of file
diff --git a/attw-fork/package.json b/attw-fork/package.json
new file mode 100644
index 0000000000..4741dc1dcd
--- /dev/null
+++ b/attw-fork/package.json
@@ -0,0 +1,53 @@
+{
+	"name": "attw-fork",
+	"version": "0.18.2-drizzlefork",
+	"description": "Fork of arethetypeswrong.github.io that allows for resolving packages in only specified modes for performance reasons",
+	"author": "Andrew Branch",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/arethetypeswrong/arethetypeswrong.github.io.git",
+		"directory": "packages/core"
+	},
+	"files": [
+		"LICENSE",
+		"src"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"run": "bun --bun run src/run.ts",
+		"build": "echo skip...",
+		"build:artifact": "pnpm run build",
+		"pack": "echo skip...",
+		"pack:artifact": "pnpm run pack",
+		"test": "echo skip...",
+		"test:types": "echo skip..."
+	},
+	"type": "module",
+	"dependencies": {
+		"@andrewbranch/untar.js": "^1.0.3",
+		"@loaderkit/resolve": "^1.0.2",
+		"chalk": "^4.1.2",
+		"cjs-module-lexer": "^1.2.3",
+		"cli-table3": "^0.6.3",
+		"fflate": "^0.8.2",
+		"lru-cache": "^11.0.1",
+		"marked": "9.1.2",
+		"marked-terminal": "7.1.0",
+		"semver": "^7.5.4",
+		"typescript": "5.9.3",
+		"validate-npm-package-name": "^5.0.0"
+	},
+	"devDependencies": {
+		"@types/marked-terminal": "3.1.3",
+		"@types/node": "^24.5.0",
+		"@types/semver": "^7.5.0",
+		"@types/validate-npm-package-name": "^4.0.0",
+		"ts-expose-internals": "5.6.3"
+	},
+	"engines": {
+		"node": ">=20"
+	}
+}
diff --git a/attw-fork/src/checkPackage.ts b/attw-fork/src/checkPackage.ts
new file mode 100644
index 0000000000..87ab44b0b8
--- /dev/null
+++ b/attw-fork/src/checkPackage.ts
@@ -0,0 +1,140 @@
+import { init as initCjsLexer } from 'cjs-module-lexer';
+import type { Package } from './createPackage.ts';
+import checks from './internal/checks/index.ts';
+import type { AnyCheck, CheckDependenciesContext } from './internal/defineCheck.ts';
+import { getBuildTools, getEntrypointInfo, getModuleKinds } from './internal/getEntrypointInfo.ts';
+import { createCompilerHosts } from './internal/multiCompilerHost.ts';
+import type {
+	AnalysisTypes,
+	CheckResult,
+	EntrypointResolutionAnalysis,
+	Problem,
+	ProgramInfo,
+	ResolutionOption,
+} from './types.ts';
+import { getResolutionOption, visitResolutions } from './utils.ts';
+
+export interface CheckPackageOptions {
+	/**
+	 * Exhaustive list of entrypoints to check. The package root is `"."`.
+	 * Specifying this option disables automatic entrypoint discovery,
+	 * and overrides the `includeEntrypoints` and `excludeEntrypoints` options.
+	 */
+	entrypoints?: string[];
+	/**
+	 * Entrypoints to check in addition to automatically discovered ones.
+	 */
+	includeEntrypoints?: string[];
+	/**
+	 * Entrypoints to exclude from checking.
+	 */
+	excludeEntrypoints?: (string | RegExp)[];
+
+	/**
+	 * Whether to automatically consider all published files as entrypoints
+	 * in the absence of any other detected or configured entrypoints.
+	 */
+	entrypointsLegacy?: boolean;
+
+	/**
+	 * Resolution modes that package's files will be loaded in.
+	 * Unwanted mode must be set to `false` to exclude.
+	 */
+	modes?: {
+		bundler?: boolean;
+		node10?: boolean;
+		'node16-cjs'?: boolean;
+		'node16-esm'?: boolean;
+	};
+}
+
+export async function checkPackage(pkg: Package, options?: CheckPackageOptions): Promise<CheckResult> {
+	const types: AnalysisTypes | false = pkg.typesPackage
+		? {
+			kind: '@types',
+			...pkg.typesPackage,
+			definitelyTypedUrl: JSON.parse(pkg.readFile(`/node_modules/${pkg.typesPackage.packageName}/package.json`))
+				.homepage,
+		}
+		: pkg.containsTypes()
+		? { kind: 'included' }
+		: false;
+	const { packageName, packageVersion } = pkg;
+	if (!types) {
+		return { packageName, packageVersion, types };
+	}
+
+	const hosts = createCompilerHosts(pkg);
+	const entrypointResolutions = getEntrypointInfo(packageName, pkg, hosts, options);
+	const programInfo: Record<ResolutionOption, ProgramInfo> = {
+		node10: {},
+		node16: { moduleKinds: getModuleKinds(entrypointResolutions, 'node16', hosts) },
+		bundler: {},
+	};
+
+	await initCjsLexer();
+	const problems: Problem[] = [];
+	const problemIdsToIndices = new Map<string, number[]>();
+	visitResolutions(entrypointResolutions, (analysis, info) => {
+		for (const check of checks) {
+			const context = {
+				pkg,
+				hosts,
+				entrypoints: entrypointResolutions,
+				programInfo,
+				subpath: info.subpath,
+				resolutionKind: analysis.resolutionKind,
+				resolutionOption: getResolutionOption(analysis.resolutionKind),
+				fileName: undefined,
+			};
+			if (check.enumerateFiles) {
+				for (const fileName of analysis.files ?? []) {
+					runCheck(check, { ...context, fileName }, analysis);
+				}
+				if (analysis.implementationResolution) {
+					runCheck(check, { ...context, fileName: analysis.implementationResolution.fileName }, analysis);
+				}
+			} else {
+				runCheck(check, context, analysis);
+			}
+		}
+	});
+
+	return {
+		packageName,
+		packageVersion,
+		types,
+		buildTools: getBuildTools(JSON.parse(pkg.readFile(`/node_modules/${packageName}/package.json`))),
+		entrypoints: entrypointResolutions,
+		programInfo,
+		problems,
+	};
+
+	function runCheck(
+		check: AnyCheck,
+		context: CheckDependenciesContext<boolean>,
+		analysis: EntrypointResolutionAnalysis,
+	) {
+		const dependencies = check.dependencies(context);
+		const id = check.name
+			+ JSON.stringify(dependencies, (_, value) => {
+				if (typeof value === 'function') {
+					throw new Error('Encountered unexpected function in check dependencies');
+				}
+				return value;
+			});
+		let indices = problemIdsToIndices.get(id);
+		if (indices) {
+			(analysis.visibleProblems ??= []).push(...indices);
+		} else {
+			indices = [];
+			const checkProblems = check.execute(dependencies, context);
+			for (const problem of Array.isArray(checkProblems) ? checkProblems : checkProblems ? [checkProblems] : []) {
+				indices.push(problems.length);
+				problems.push(problem);
+			}
+			problemIdsToIndices.set(id, indices);
+			(analysis.visibleProblems ??= []).push(...indices);
+		}
+	}
+}
diff --git a/attw-fork/src/cli/asciiTable.ts b/attw-fork/src/cli/asciiTable.ts
new file mode 100644
index 0000000000..e8d27a5a33
--- /dev/null
+++ b/attw-fork/src/cli/asciiTable.ts
@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import type { GenericTable, HorizontalTableRow } from 'cli-table3';
+
+export function asciiTable(table: GenericTable<HorizontalTableRow>) {
+	return table.options.head
+		.slice(1)
+		.map((entryPoint, i) => {
+			const keyValuePairs = table.reduce((acc, cur) => {
+				const key = cur[0]?.toString();
+				const value = cur[i + 1]?.toString();
+				return acc + `${key}: ${value}\n`;
+			}, '');
+			return `${chalk.bold.blue(entryPoint)}
+
+${keyValuePairs}
+***********************************`;
+		})
+		.join('\n\n');
+}
diff --git a/attw-fork/src/cli/getExitCode.ts b/attw-fork/src/cli/getExitCode.ts
new file mode 100644
index 0000000000..39f9b73f65
--- /dev/null
+++ b/attw-fork/src/cli/getExitCode.ts
@@ -0,0 +1,20 @@
+import type { CheckResult } from '../types.ts';
+import { problemFlags } from './problemUtils.ts';
+import type { RenderOptions } from './renderOptions.ts';
+
+export function getExitCode(analysis: CheckResult, opts?: RenderOptions): number {
+	if (!analysis.types) {
+		return 0;
+	}
+	const ignoreRules = opts?.ignoreRules ?? [];
+	const ignoreResolutions = opts?.ignoreResolutions ?? [];
+	return analysis.problems.some((problem) => {
+			const notRuleIgnored = !ignoreRules.includes(problemFlags[problem.kind]);
+			const notResolutionIgnored = 'resolutionKind' in problem
+				? !ignoreResolutions.includes(problem.resolutionKind)
+				: true;
+			return notRuleIgnored && notResolutionIgnored;
+		})
+		? 1
+		: 0;
+}
diff --git a/attw-fork/src/cli/problemUtils.ts b/attw-fork/src/cli/problemUtils.ts
new file mode 100644
index 0000000000..e502c389c6
--- /dev/null
+++ b/attw-fork/src/cli/problemUtils.ts
@@ -0,0 +1,30 @@
+import type * as core from '../index.ts';
+import type { ProblemKind } from '../index.ts';
+
+export const problemFlags = {
+	NoResolution: 'no-resolution',
+	UntypedResolution: 'untyped-resolution',
+	FalseCJS: 'false-cjs',
+	FalseESM: 'false-esm',
+	CJSResolvesToESM: 'cjs-resolves-to-esm',
+	FallbackCondition: 'fallback-condition',
+	CJSOnlyExportsDefault: 'cjs-only-exports-default',
+	NamedExports: 'named-exports',
+	FalseExportDefault: 'false-export-default',
+	MissingExportEquals: 'missing-export-equals',
+	UnexpectedModuleSyntax: 'unexpected-module-syntax',
+	InternalResolutionError: 'internal-resolution-error',
+} as const satisfies Record<ProblemKind, string>;
+
+export const resolutionKinds: Record<core.ResolutionKind, string> = {
+	node10: 'node10',
+	'node16-cjs': 'node16 (from CJS)',
+	'node16-esm': 'node16 (from ESM)',
+	bundler: 'bundler',
+};
+
+export const moduleKinds = {
+	1: '(CJS)',
+	99: '(ESM)',
+	'': '',
+};
diff --git a/attw-fork/src/cli/renderOptions.ts b/attw-fork/src/cli/renderOptions.ts
new file mode 100644
index 0000000000..5264bb6c77
--- /dev/null
+++ b/attw-fork/src/cli/renderOptions.ts
@@ -0,0 +1,11 @@
+import type { problemFlags, resolutionKinds } from './problemUtils.ts';
+
+export type Format = 'auto' | 'table' | 'table-flipped' | 'ascii' | 'json' | 'concise';
+export interface RenderOptions {
+	ignoreRules?: (typeof problemFlags)[keyof typeof problemFlags][];
+	ignoreResolutions?: (keyof typeof resolutionKinds)[];
+	format?: Format;
+	color?: boolean;
+	summary?: boolean;
+	emoji?: boolean;
+}
diff --git a/attw-fork/src/cli/typed.ts b/attw-fork/src/cli/typed.ts
new file mode 100644
index 0000000000..6280d51016
--- /dev/null
+++ b/attw-fork/src/cli/typed.ts
@@ -0,0 +1,235 @@
+import chalk from 'chalk';
+import Table, { type GenericTable, type HorizontalTableRow } from 'cli-table3';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+import type * as core from '../index.ts';
+import {
+	filterProblems,
+	problemAffectsEntrypoint,
+	problemAffectsEntrypointResolution,
+	problemAffectsResolutionKind,
+	problemKindInfo,
+} from '../problems.ts';
+import { allResolutionKinds, getResolutionOption, groupProblemsByKind } from '../utils.ts';
+import { asciiTable } from './asciiTable.ts';
+import { moduleKinds, problemFlags, resolutionKinds } from './problemUtils.ts';
+import type { RenderOptions } from './renderOptions.ts';
+
+export async function typed(
+	analysis: core.Analysis,
+	{ emoji = true, summary = true, format = 'auto', ignoreRules = [], ignoreResolutions = [] }: RenderOptions,
+): Promise<string> {
+	const isConciseFormat = format === 'concise';
+	let output = '';
+	const problems = analysis.problems.filter(
+		(problem) => !ignoreRules || !ignoreRules.includes(problemFlags[problem.kind]),
+	);
+	// sort resolutions with required (impacts result) first and ignored after
+	const requiredResolutions = allResolutionKinds.filter((kind) => !ignoreResolutions.includes(kind));
+	const ignoredResolutions = allResolutionKinds.filter((kind) => ignoreResolutions.includes(kind));
+	const resolutions = requiredResolutions.concat(ignoredResolutions);
+	const entrypoints = Object.keys(analysis.entrypoints);
+	marked.setOptions({
+		renderer: new TerminalRenderer(),
+	});
+
+	out(`${analysis.packageName} v${analysis.packageVersion}`);
+	if (analysis.types.kind === '@types') {
+		out(`${analysis.types.packageName} v${analysis.types.packageVersion}`);
+	}
+	out();
+	if (Object.keys(analysis.buildTools).length) {
+		out('Build tools:');
+		out(
+			Object.entries(analysis.buildTools)
+				.map(([tool, version]) => `- ${tool}@${version}`)
+				.join('\n'),
+		);
+		out();
+	}
+
+	if (ignoreRules && ignoreRules.length) {
+		out(chalk.gray(` (ignoring rules: ${ignoreRules.map((rule) => `'${rule}'`).join(', ')})\n`));
+	}
+	if (ignoreResolutions && ignoreResolutions.length) {
+		out(
+			chalk.gray(` (ignoring resolutions: ${ignoreResolutions.map((resolution) => `'${resolution}'`).join(', ')})\n`),
+		);
+	}
+
+	if (summary) {
+		const defaultSummary = marked(!emoji ? ' No problems found' : ' No problems found 🌟');
+		const grouped = groupProblemsByKind(problems);
+
+		const summaryTexts = Object.entries(grouped)
+			.filter(([_, kindProblems]) =>
+				isConciseFormat
+					? true
+					: kindProblems.some((p) => requiredResolutions.some((r) => problemAffectsResolutionKind(p, r, analysis)))
+			)
+			.map(([kind, kindProblems]) => {
+				const info = problemKindInfo[kind as core.ProblemKind];
+				const affectsRequiredResolution = !isConciseFormat
+					&& kindProblems.some((p) => requiredResolutions.some((r) => problemAffectsResolutionKind(p, r, analysis)));
+				const description = marked(
+					`${info.description}${info.details ? ` Use \`-f json\` to see ${info.details}.` : ''} ${info.docsUrl}`,
+				);
+				return `${affectsRequiredResolution ? '' : '(ignored per resolution) '}${
+					emoji ? `${info.emoji} ` : ''
+				}${description}`;
+			});
+		out(summaryTexts.join('') || defaultSummary);
+	}
+
+	if (format === 'concise') {
+		const failedEntrypoints = entrypoints.filter((subpath) =>
+			problems.some((p) => requiredResolutions.some((r) => problemAffectsEntrypointResolution(p, subpath, r, analysis)))
+		);
+		const passedEntrypoints = entrypoints.filter((subpath) =>
+			!problems.some((p) =>
+				requiredResolutions.some((r) => problemAffectsEntrypointResolution(p, subpath, r, analysis))
+			)
+		);
+
+		if (passedEntrypoints.length > 0 || failedEntrypoints.length === 0) {
+			out();
+			out(chalk.greenBright((emoji ? `✅ ` : '') + `Passed (${passedEntrypoints.length})`));
+		}
+
+		if (failedEntrypoints.length > 0) {
+			out();
+			out(chalk.redBright((emoji ? `❌ ` : '') + `Failed (${failedEntrypoints.length}):`));
+			out();
+
+			failedEntrypoints.forEach((subpath) => {
+				const entrypointName = subpath === '.'
+					? analysis.packageName
+					: `${analysis.packageName}/${subpath.substring(2)}`;
+				out(chalk.bold.redBright(`"${entrypointName}"`));
+
+				requiredResolutions.forEach((resolutionKind) => {
+					const problemsForCell = filterProblems(problems, analysis, { entrypoint: subpath, resolutionKind });
+					if (problemsForCell.length > 0) {
+						const grouped = groupProblemsByKind(problemsForCell);
+						const problemDescriptions = Object.keys(grouped).map((kind) => {
+							const info = problemKindInfo[kind as core.ProblemKind];
+							return emoji ? `${info.emoji} ${info.shortDescription}` : info.shortDescription;
+						}).join(', ');
+
+						out(`  ${resolutionKinds[resolutionKind]}: ${problemDescriptions}`);
+					}
+				});
+				out();
+			});
+		}
+	} else {
+		const entrypointNames = entrypoints.map(
+			(s) => `"${s === '.' ? analysis.packageName : `${analysis.packageName}/${s.substring(2)}`}"`,
+		);
+		const entrypointHeaders = entrypoints.map((s, i) => {
+			const hasProblems = problems.some((p) => problemAffectsEntrypoint(p, s, analysis));
+			const color = hasProblems ? 'redBright' : 'greenBright';
+			return chalk.bold[color](entrypointNames[i]);
+		});
+
+		const getCellContents = memo((subpath: string, resolutionKind: core.ResolutionKind) => {
+			const ignoredPrefix = ignoreResolutions.includes(resolutionKind) ? '(ignored) ' : '';
+			const problemsForCell = groupProblemsByKind(
+				filterProblems(problems, analysis, { entrypoint: subpath, resolutionKind }),
+			);
+			const entrypoint = analysis.entrypoints[subpath]!.resolutions[resolutionKind];
+			const resolution = entrypoint.resolution;
+			const kinds = Object.keys(problemsForCell) as core.ProblemKind[];
+			if (kinds.length) {
+				return kinds
+					.map(
+						(kind) =>
+							ignoredPrefix + (emoji ? `${problemKindInfo[kind].emoji} ` : '') + problemKindInfo[kind].shortDescription,
+					)
+					.join('\n');
+			}
+
+			const jsonResult = !emoji ? 'OK (JSON)' : '🟢 (JSON)';
+			const moduleResult = entrypoint.isWildcard
+				? '(wildcard)'
+				: (!emoji ? 'OK ' : '🟢 ')
+					+ moduleKinds[
+						analysis.programInfo[getResolutionOption(resolutionKind)].moduleKinds?.[resolution?.fileName ?? '']
+							?.detectedKind || ''
+					];
+			return ignoredPrefix + (resolution?.isJson ? jsonResult : moduleResult);
+		});
+
+		const flippedTable = format === 'auto' || format === 'table-flipped'
+			? new Table({
+				head: [
+					'',
+					...resolutions.map((kind) =>
+						chalk.reset(resolutionKinds[kind] + (ignoreResolutions.includes(kind) ? ' (ignored)' : ''))
+					),
+				],
+			})
+			: undefined;
+		if (flippedTable) {
+			entrypoints.forEach((subpath, i) => {
+				flippedTable.push([
+					entrypointHeaders[i],
+					...resolutions.map((resolutionKind) => getCellContents(subpath, resolutionKind)),
+				]);
+			});
+		}
+
+		const table = format === 'auto' || !flippedTable
+			? (new Table({
+				head: ['', ...entrypointHeaders],
+			}) as GenericTable<HorizontalTableRow>)
+			: undefined;
+		if (table) {
+			resolutions.forEach((kind) => {
+				table.push([resolutionKinds[kind], ...entrypoints.map((entrypoint) => getCellContents(entrypoint, kind))]);
+			});
+		}
+
+		switch (format) {
+			case 'table':
+				out(table!.toString());
+				break;
+			case 'table-flipped':
+				out(flippedTable!.toString());
+				break;
+			case 'ascii':
+				out(asciiTable(table!));
+				break;
+			case 'auto':
+				const terminalWidth = process.stdout.columns || 133; // This looks like GitHub Actions' width
+				if (table!.width <= terminalWidth) {
+					out(table!.toString());
+				} else if (flippedTable!.width <= terminalWidth) {
+					out(flippedTable!.toString());
+				} else {
+					out(asciiTable(table!));
+				}
+				break;
+		}
+	}
+
+	return output.trimEnd();
+
+	function out(s: string = '') {
+		output += s + '\n';
+	}
+}
+
+function memo<Args extends (string | number)[], Result>(fn: (...args: Args) => Result): (...args: Args) => Result {
+	const cache = new Map();
+	return (...args) => {
+		const key = '' + args;
+		if (cache.has(key)) {
+			return cache.get(key);
+		}
+
+		const result = fn(...args);
+		cache.set(key, result);
+		return result;
+	};
+}
diff --git a/attw-fork/src/cli/untyped.ts b/attw-fork/src/cli/untyped.ts
new file mode 100644
index 0000000000..80f42c43bb
--- /dev/null
+++ b/attw-fork/src/cli/untyped.ts
@@ -0,0 +1,5 @@
+import type { UntypedResult } from '../types.ts';
+
+export function untyped(analysis: UntypedResult) {
+	return 'This package does not contain types.\nDetails: ' + JSON.stringify(analysis, null, 2);
+}
diff --git a/attw-fork/src/cli/write.ts b/attw-fork/src/cli/write.ts
new file mode 100644
index 0000000000..32066cc890
--- /dev/null
+++ b/attw-fork/src/cli/write.ts
@@ -0,0 +1,27 @@
+import { Readable, type Writable } from 'node:stream';
+
+// JSON output is often longer than 64 kb, so we need to use streams to write it to stdout
+// in order to avoid truncation when piping to other commands.
+export async function write(data: string, out: Writable): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const stream = new Readable({
+			read() {
+				this.push(data);
+				this.push('\n');
+				this.push(null);
+			},
+		});
+
+		stream.on('data', (chunk) => {
+			out.write(chunk);
+		});
+
+		stream.on('end', () => {
+			resolve();
+		});
+
+		out.on('error', (err) => {
+			reject(err);
+		});
+	});
+}
diff --git a/attw-fork/src/createPackage.ts b/attw-fork/src/createPackage.ts
new file mode 100644
index 0000000000..a50ce7baab
--- /dev/null
+++ b/attw-fork/src/createPackage.ts
@@ -0,0 +1,310 @@
+/* eslint-disable unicorn/no-array-callback-reference */
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { untar } from '@andrewbranch/untar.js';
+import { Gunzip } from 'fflate';
+import { major, maxSatisfying, minor, valid, validRange } from 'semver';
+import ts from 'typescript';
+import { type ParsedPackageSpec, parsePackageSpec } from './utils.ts';
+
+export class Package {
+	#files: Record<string, string | Uint8Array> = {};
+	readonly packageName: string;
+	readonly packageVersion: string;
+	readonly resolvedUrl?: string;
+	readonly typesPackage?: {
+		packageName: string;
+		packageVersion: string;
+		resolvedUrl?: string;
+	};
+
+	constructor(
+		files: Record<string, string | Uint8Array>,
+		packageName: string,
+		packageVersion: string,
+		resolvedUrl?: string,
+		typesPackage?: Package['typesPackage'],
+	) {
+		this.#files = files;
+		this.packageName = packageName;
+		this.packageVersion = packageVersion;
+		this.resolvedUrl = resolvedUrl;
+		this.typesPackage = typesPackage;
+	}
+
+	tryReadFile(path: string): string | undefined {
+		const file = this.#files[path];
+		if (file === undefined) {
+			return undefined;
+		}
+		if (typeof file === 'string') {
+			return file;
+		}
+		const content = new TextDecoder().decode(file);
+		this.#files[path] = content;
+		return content;
+	}
+
+	readFile(path: string): string {
+		const content = this.tryReadFile(path);
+		if (content === undefined) {
+			throw new Error(`File not found: ${path}`);
+		}
+		return content;
+	}
+
+	fileExists(path: string): boolean {
+		return path in this.#files;
+	}
+
+	directoryExists(path: string): boolean {
+		path = ts.ensureTrailingDirectorySeparator(path);
+		for (const file in this.#files) {
+			if (file.startsWith(path)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	containsTypes(directory = '/'): boolean {
+		return this.listFiles(directory).some(ts.hasTSFileExtension);
+	}
+
+	listFiles(directory = '/'): string[] {
+		directory = ts.ensureTrailingDirectorySeparator(directory);
+		return directory === '/'
+			? Object.keys(this.#files)
+			: Object.keys(this.#files).filter((f) => f.startsWith(directory));
+	}
+
+	mergedWithTypes(typesPackage: Package): Package {
+		const files = { ...this.#files, ...typesPackage.#files };
+		return new Package(files, this.packageName, this.packageVersion, this.resolvedUrl, {
+			packageName: typesPackage.packageName,
+			packageVersion: typesPackage.packageVersion,
+			resolvedUrl: typesPackage.resolvedUrl,
+		});
+	}
+}
+
+export interface CreatePackageFromNpmOptions {
+	/**
+	 * Controls inclusion of a corresponding `@types` package. Ignored if the implementation
+	 * package contains TypeScript files. The value is the version or SemVer range of the
+	 * `@types` package to include, `true` to infer the version from the implementation
+	 * package version, or `false` to prevent inclusion of a `@types` package.
+	 * @default true
+	 */
+	definitelyTyped?: string | boolean;
+	before?: Date;
+	allowDeprecated?: boolean;
+}
+
+export async function createPackageFromNpm(
+	packageSpec: string,
+	{ definitelyTyped = true, ...options }: CreatePackageFromNpmOptions = {},
+): Promise<Package> {
+	const parsed = parsePackageSpec(packageSpec);
+	if (parsed.status === 'error') {
+		throw new Error(parsed.error);
+	}
+	const packageName = parsed.data.name;
+	const typesPackageName = ts.getTypesPackageName(packageName);
+	const { tarballUrl, packageVersion } = parsed.data.versionKind === 'none' && typeof definitelyTyped === 'string'
+		? await resolveImplementationPackageForTypesPackage(typesPackageName, definitelyTyped, options)
+		: await getNpmTarballUrl([parsed.data], options);
+	const pkg = await createPackageFromTarballUrl(tarballUrl);
+	if (!definitelyTyped || pkg.containsTypes()) {
+		return pkg;
+	}
+
+	const typesPackageData = await (definitelyTyped === true
+		? resolveTypesPackageForPackage(packageName, packageVersion, options)
+		: getNpmTarballUrl(
+			[
+				{
+					name: typesPackageName,
+					versionKind: valid(definitelyTyped) ? 'exact' : validRange(definitelyTyped) ? 'range' : 'tag',
+					version: definitelyTyped,
+				},
+			],
+			options,
+		));
+
+	if (typesPackageData) {
+		return pkg.mergedWithTypes(await createPackageFromTarballUrl(typesPackageData.tarballUrl));
+	}
+	return pkg;
+}
+
+export async function resolveImplementationPackageForTypesPackage(
+	typesPackageName: string,
+	typesPackageVersion: string,
+	options?: Omit<CreatePackageFromNpmOptions, 'definitelyTyped'>,
+): Promise<ResolvedPackageId> {
+	if (!typesPackageName.startsWith('@types/')) {
+		throw new Error(`'resolveImplementationPackageForTypesPackage' expects an @types package name and version`);
+	}
+	const packageName = ts.unmangleScopedPackageName(typesPackageName.slice('@types/'.length));
+	const version = valid(typesPackageVersion);
+	if (version) {
+		return getNpmTarballUrl(
+			[
+				parsePackageSpec(`${packageName}@${major(version)}.${minor(version)}`).data!,
+				parsePackageSpec(`${packageName}@${major(version)}`).data!,
+				parsePackageSpec(`${packageName}@latest`).data!,
+			],
+			options,
+		);
+	}
+
+	const range = validRange(typesPackageVersion);
+	if (range) {
+		return getNpmTarballUrl(
+			[
+				{ name: packageName, versionKind: 'range', version: range },
+				{ name: packageName, versionKind: 'tag', version: 'latest' },
+			],
+			options,
+		);
+	}
+
+	throw new Error(`'resolveImplementationPackageForTypesPackage' expects a valid SemVer version or range`);
+}
+
+export async function resolveTypesPackageForPackage(
+	packageName: string,
+	packageVersion: string,
+	options?: Omit<CreatePackageFromNpmOptions, 'definitelyTyped'>,
+): Promise<ResolvedPackageId | undefined> {
+	const typesPackageName = ts.getTypesPackageName(packageName);
+	try {
+		return await getNpmTarballUrl(
+			[
+				{
+					name: typesPackageName,
+					versionKind: 'range',
+					version: `${major(packageVersion)}.${minor(packageVersion)}`,
+				},
+				{
+					name: typesPackageName,
+					versionKind: 'range',
+					version: `${major(packageVersion)}`,
+				},
+				{
+					name: typesPackageName,
+					versionKind: 'tag',
+					version: 'latest',
+				},
+			],
+			options,
+		);
+	} catch {}
+
+	return undefined;
+}
+
+export interface ResolvedPackageId {
+	packageName: string;
+	packageVersion: string;
+	tarballUrl: string;
+}
+
+async function getNpmTarballUrl(
+	packageSpecs: readonly ParsedPackageSpec[],
+	{ before, allowDeprecated }: Omit<CreatePackageFromNpmOptions, 'definitelyTyped'> = {},
+): Promise<ResolvedPackageId> {
+	const fetchPackument = packageSpecs.some(
+		(spec) => spec.versionKind === 'range' || (spec.versionKind === 'tag' && spec.version !== 'latest'),
+	);
+	const packumentUrl = `https://registry.npmjs.org/${packageSpecs[0]!.name}`;
+	const includeTimes = before !== undefined && packageSpecs.some((spec) => spec.versionKind !== 'exact');
+	const Accept = includeTimes ? 'application/json' : 'application/vnd.npm.install-v1+json';
+	const packument = fetchPackument
+		? await fetch(packumentUrl, { headers: { Accept } }).then((r) => r.json())
+		: undefined;
+
+	for (const packageSpec of packageSpecs) {
+		const manifestUrl = `https://registry.npmjs.org/${packageSpec.name}/${packageSpec.version || 'latest'}`;
+		const doc = packument || (await fetch(manifestUrl).then((r) => r.json()));
+		if (typeof doc !== 'object' || (doc.error && doc.error !== 'Not found')) {
+			throw new Error(`Unexpected response from ${manifestUrl}: ${JSON.stringify(doc)}`);
+		}
+		const isManifest = !!doc.version;
+		let tarballUrl, packageVersion;
+		if (packageSpec.versionKind === 'range') {
+			packageVersion = doc.versions
+				&& maxSatisfying(
+					Object.keys(doc.versions).filter(
+						(v) =>
+							(allowDeprecated || !doc.versions[v].deprecated)
+							&& (!before || !doc.time || new Date(doc.time[v]) <= before),
+					),
+					packageSpec.version,
+				);
+			if (!packageVersion) {
+				continue;
+			}
+			tarballUrl = doc.versions[packageVersion].dist.tarball;
+		} else if (packageSpec.versionKind === 'tag' && packageSpec.version !== 'latest') {
+			packageVersion = doc['dist-tags'][packageSpec.version];
+			if (!packageVersion) {
+				continue;
+			}
+			if (before && doc.time && new Date(doc.time[packageVersion]) > before) {
+				continue;
+			}
+			tarballUrl = doc.versions[packageVersion].dist.tarball;
+		} else if (isManifest) {
+			packageVersion = doc.version;
+			tarballUrl = doc.dist?.tarball;
+		} else {
+			packageVersion = doc['dist-tags']?.latest;
+			tarballUrl = doc.versions?.[packageVersion].dist.tarball;
+		}
+
+		if (packageVersion && tarballUrl) {
+			return { packageName: packageSpec.name, packageVersion, tarballUrl };
+		}
+	}
+	throw new Npm404Error(packageSpecs);
+}
+
+export class Npm404Error extends Error {
+	kind = 'Npm404Error';
+	constructor(public packageSpecs: readonly ParsedPackageSpec[]) {
+		super(`Failed to find a matching version for ${packageSpecs[0]!.name}`);
+	}
+}
+
+export async function createPackageFromTarballUrl(tarballUrl: string): Promise<Package> {
+	const tarball = await fetchTarball(tarballUrl);
+	const { files, packageName, packageVersion } = extractTarball(tarball);
+	return new Package(files, packageName, packageVersion, tarballUrl);
+}
+
+async function fetchTarball(tarballUrl: string) {
+	return new Uint8Array((await fetch(tarballUrl).then((r) => r.arrayBuffer())) satisfies ArrayBuffer);
+}
+
+export function createPackageFromTarballData(tarball: Uint8Array): Package {
+	const { files, packageName, packageVersion } = extractTarball(tarball);
+	return new Package(files, packageName, packageVersion);
+}
+
+function extractTarball(tarball: Uint8Array) {
+	// Use streaming API to work around https://github.com/101arrowz/fflate/issues/207
+	let unzipped: Uint8Array;
+	new Gunzip((chunk) => (unzipped = chunk)).push(tarball, /*final*/ true);
+	const data = untar(unzipped!.buffer as ArrayBuffer);
+	const prefix = data[0]!.filename.slice(0, Math.max(0, data[0]!.filename.indexOf('/') + 1));
+	const packageJsonText = data.find((f) => f.filename === `${prefix}package.json`)?.fileData;
+	const packageJson = JSON.parse(new TextDecoder().decode(packageJsonText));
+	const packageName = packageJson.name;
+	const packageVersion = packageJson.version;
+	const files = data.reduce((acc: Record<string, Uint8Array>, file) => {
+		acc[ts.combinePaths('/node_modules/' + packageName, file.filename.slice(prefix.length))] = file.fileData;
+		return acc;
+	}, {});
+	return { files, packageName, packageVersion };
+}
diff --git a/attw-fork/src/index.ts b/attw-fork/src/index.ts
new file mode 100644
index 0000000000..b0a56e30d8
--- /dev/null
+++ b/attw-fork/src/index.ts
@@ -0,0 +1,3 @@
+export * from './checkPackage.ts';
+export * from './createPackage.ts';
+export type * from './types.ts';
diff --git a/attw-fork/src/internal/checks/cjsOnlyExportsDefault.ts b/attw-fork/src/internal/checks/cjsOnlyExportsDefault.ts
new file mode 100644
index 0000000000..8c80f85844
--- /dev/null
+++ b/attw-fork/src/internal/checks/cjsOnlyExportsDefault.ts
@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import { defineCheck } from '../defineCheck.ts';
+
+export default defineCheck({
+	name: 'CJSOnlyExportsDefault',
+	dependencies: ({ entrypoints, subpath, resolutionKind }) => {
+		const entrypoint = entrypoints[subpath]!.resolutions[resolutionKind];
+		const implementationFileName = entrypoint.implementationResolution?.fileName;
+		return [implementationFileName, resolutionKind];
+	},
+	execute: ([implementationFileName, resolutionKind], context) => {
+		if (!implementationFileName) {
+			return;
+		}
+		if (resolutionKind === 'node10' || resolutionKind === 'node16-cjs') {
+			// Here, we have a CJS file (most likely transpiled ESM) resolving to a
+			// CJS transpiled ESM file. This is fine when considered in isolation.
+			// The pattern of having `module.exports.default = ...` is a problem
+			// primarily because ESM-detected files in Node (and the same files in
+			// Webpack/esbuild) will treat `module.exports` as the default export,
+			// which is both unexpected and different from Babel-style interop seen
+			// in transpiled default imports and most bundler scenarios. But if Node,
+			// Webpack, and esbuild never see this file, then it's fine. So, while
+			// the problematic pattern is a feature of the file alone, the bad outcome
+			// comes from a combination of the file and the module system that imports
+			// it. For dual packages that point Node imports and bundlers to a true
+			// ESM default export, while pointing requires to this CJS "default export,"
+			// we don't want to report a problem.
+			//
+			// TODO: It would be nice to report this information *somehow*, as neutral
+			// metadata attached to the file (c.f. `Analysis["programInfo"]`).
+			return;
+		}
+		const host = context.hosts.findHostForFiles([implementationFileName]) ?? context.hosts.bundler;
+		const sourceFile = host.getSourceFile(implementationFileName)!;
+		if (
+			!sourceFile.externalModuleIndicator
+			&& sourceFile.commonJsModuleIndicator
+			&& sourceFile.symbol?.exports?.has(ts.InternalSymbolName.Default)
+			&& sourceFile.symbol.exports.has(ts.escapeLeadingUnderscores('__esModule'))
+			&& !sourceFile.symbol.exports.has(ts.InternalSymbolName.ExportEquals)
+		) {
+			const decl = sourceFile.symbol.exports.get(ts.InternalSymbolName.Default)!.declarations![0];
+			return {
+				kind: 'CJSOnlyExportsDefault',
+				fileName: implementationFileName,
+				pos: decl!.getStart(sourceFile),
+				end: decl!.end,
+			};
+		}
+
+		return;
+	},
+});
diff --git a/attw-fork/src/internal/checks/entrypointResolutions.ts b/attw-fork/src/internal/checks/entrypointResolutions.ts
new file mode 100644
index 0000000000..c4d3dff8fb
--- /dev/null
+++ b/attw-fork/src/internal/checks/entrypointResolutions.ts
@@ -0,0 +1,57 @@
+import ts from 'typescript';
+import type { Problem } from '../../types.ts';
+import { resolvedThroughFallback } from '../../utils.ts';
+import { defineCheck } from '../defineCheck.ts';
+
+export default defineCheck({
+	name: 'EntrypointResolutions',
+	dependencies: ({ subpath, resolutionKind }) => [subpath, resolutionKind],
+	execute: ([subpath, resolutionKind], context) => {
+		const problems: Problem[] = [];
+		const entrypoint = context.entrypoints[subpath]!.resolutions[resolutionKind];
+		if (entrypoint.isWildcard) {
+			return;
+		}
+
+		if (!entrypoint.resolution) {
+			problems.push({
+				kind: 'NoResolution',
+				entrypoint: subpath,
+				resolutionKind,
+			});
+		} else if (!entrypoint.resolution.isTypeScript && !entrypoint.resolution.isJson) {
+			problems.push({
+				kind: 'UntypedResolution',
+				entrypoint: subpath,
+				resolutionKind,
+			});
+		}
+
+		if (
+			resolutionKind === 'node16-cjs'
+			&& ((!entrypoint.implementationResolution
+				&& entrypoint.resolution
+				&& context.programInfo['node16'].moduleKinds![entrypoint.resolution.fileName]?.detectedKind
+					=== ts.ModuleKind.ESNext)
+				|| (entrypoint.implementationResolution
+					&& context.programInfo['node16'].moduleKinds![entrypoint.implementationResolution.fileName]?.detectedKind
+						=== ts.ModuleKind.ESNext))
+		) {
+			problems.push({
+				kind: 'CJSResolvesToESM',
+				entrypoint: subpath,
+				resolutionKind,
+			});
+		}
+
+		if (entrypoint.resolution && resolvedThroughFallback(entrypoint.resolution.trace)) {
+			problems.push({
+				kind: 'FallbackCondition',
+				entrypoint: subpath,
+				resolutionKind,
+			});
+		}
+
+		return problems;
+	},
+});
diff --git a/attw-fork/src/internal/checks/exportDefaultDisagreement.ts b/attw-fork/src/internal/checks/exportDefaultDisagreement.ts
new file mode 100644
index 0000000000..a3ff7ddec1
--- /dev/null
+++ b/attw-fork/src/internal/checks/exportDefaultDisagreement.ts
@@ -0,0 +1,348 @@
+import ts from 'typescript';
+import { getResolutionOption } from '../../utils.ts';
+import { defineCheck } from '../defineCheck.ts';
+import { type Export, getProbableExports } from '../getProbableExports.ts';
+
+const bindOptions: ts.CompilerOptions = {
+	target: ts.ScriptTarget.Latest,
+	allowJs: true,
+	checkJs: true,
+};
+
+export default defineCheck({
+	name: 'ExportDefaultDisagreement',
+	dependencies: ({ entrypoints, subpath, resolutionKind, programInfo }) => {
+		const entrypoint = entrypoints[subpath]!.resolutions[resolutionKind];
+		const typesFileName = entrypoint.resolution?.fileName;
+		const implementationFileName = entrypoint.implementationResolution?.fileName;
+		if (
+			(typesFileName
+				&& programInfo[getResolutionOption(resolutionKind)].moduleKinds?.[typesFileName]?.detectedKind
+					=== ts.ModuleKind.ESNext)
+			|| (implementationFileName
+				&& programInfo[getResolutionOption(resolutionKind)].moduleKinds?.[implementationFileName]?.detectedKind
+					=== ts.ModuleKind.ESNext)
+		) {
+			return [];
+		}
+		return [typesFileName, implementationFileName];
+	},
+	execute: ([typesFileName, implementationFileName], context) => {
+		// Technically, much of this implementation should go in `dependencies`, since
+		// different resolution modes can result in different program graphs, resulting
+		// in different types, which are queried heavily here. However, it would be much
+		// more expensive to run this type-heavy code in `dependencies`, where it would
+		// reevaluate for every entrypoint/resolution matrix cell, when chances are
+		// extremely high that a given pair of types/implementation files are intended
+		// to act the same under all resolution modes.
+		if (!typesFileName || !implementationFileName || !ts.hasTSFileExtension(typesFileName)) {
+			return;
+		}
+		const host = context.hosts.findHostForFiles([typesFileName])!;
+		const typesSourceFile = host.getSourceFile(typesFileName)!;
+		ts.bindSourceFile(typesSourceFile, bindOptions);
+		if (!typesSourceFile.symbol?.exports) {
+			return;
+		}
+		const implementationSourceFile = host.getSourceFile(implementationFileName)!;
+		ts.bindSourceFile(implementationSourceFile, bindOptions);
+		if (!implementationSourceFile.symbol?.exports || implementationSourceFile.externalModuleIndicator) {
+			return;
+		}
+
+		// FalseExportDefault: types have a default, JS doesn't.
+		// For this check, we're going to require the types to have a top-level
+		// default export, which means we might miss something like:
+		//
+		// declare namespace foo {
+		//   const _default: string;
+		//   export { _default as default };
+		// }
+		// export = foo;
+		//
+		// But that's not a mistake people really make. If we don't need to
+		// recognize that pattern, we can avoid creating a program and checker
+		// for this error.
+		const typesHaveSyntacticDefault = typesSourceFile.symbol.exports.has(ts.InternalSymbolName.Default);
+		if (typesHaveSyntacticDefault && !getImplHasDefault() && implIsAnalyzable()) {
+			return {
+				kind: 'FalseExportDefault',
+				typesFileName,
+				implementationFileName,
+			};
+		}
+
+		// MissingExportEquals: types and JS have a default, but JS also has a
+		// module.exports = not reflected in the types.
+		// There are a few variations of this problem. The most straightforward
+		// is when the types declare *only* a default export, and the JS declares
+		// a module.exports and a module.exports.default in different declarations:
+		//
+		// module.exports = SomeClass;
+		// module.exports.default = SomeClass;
+		//
+		// Then, there's the slight variation on this where the `default` property
+		// is separately declared on `SomeClass`. This requires the type checker.
+		// Finally, there's the case where the types declare a default export along
+		// with other named exports. That *could* accurately represent a
+		// `module.exports = { default, ... }` in JS, but only if the named exports
+		// are values, not types. It also *couldn't* accurately represent a
+		// `module.exports = SomeClass`, where the exported value is callable,
+		// constructable, or a primitive.
+
+		if (!getImplHasDefault() || !implIsAnalyzable()) {
+			// The implementation not having a default doesn't necessarily mean the
+			// following checks are irrelevant, but this rule is designed primarily
+			// to catch cases where type definition authors correctly notice that
+			// their implementation has a `module.exports.default`, but don't realize
+			// that the same object is exposed as `module.exports`. We bail early
+			// here primarily because these checks are expensive.
+			return;
+		}
+
+		if (
+			!typesSourceFile.symbol.exports.has(ts.InternalSymbolName.ExportEquals)
+			&& implementationSourceFile.symbol.exports.has(ts.InternalSymbolName.ExportEquals)
+			&& getTypesDefaultSymbol()
+			&& ((getImplExportEqualsIsExportDefault()
+				&& getTypesChecker().typeHasCallOrConstructSignatures(getTypesTypeOfDefault()))
+				|| getImplChecker().typeHasCallOrConstructSignatures(getImplTypeOfModuleExports()))
+		) {
+			return {
+				kind: 'MissingExportEquals',
+				typesFileName,
+				implementationFileName,
+			};
+		}
+
+		// TODO: does not account for export *
+		const typesHaveNonDefaultValueExport = [...typesSourceFile.symbol.exports.values()].some((s) => {
+			if (s.escapedName === 'default') {
+				return false;
+			}
+			if (s.flags & ts.SymbolFlags.Value) {
+				return true;
+			}
+			while (s.flags & ts.SymbolFlags.Alias) {
+				s = getTypesChecker().getAliasedSymbol(s);
+				if (s.flags & ts.SymbolFlags.Value) {
+					return true;
+				}
+			}
+
+			return;
+		});
+
+		if (
+			!typesHaveNonDefaultValueExport
+			&& typeIsObjecty(getTypesTypeOfDefault(), getTypesChecker())
+			&& ([...implementationSourceFile.symbol.exports.keys()].some((name) =>
+				isNotDefaultOrEsModule(ts.unescapeLeadingUnderscores(name))
+			)
+				|| getImplProbableExports().some(({ name }) => isNotDefaultOrEsModule(name)))
+			&& getTypesDefaultSymbol()
+		) {
+			// Here, the types have a lone default export of a non-callable object,
+			// and the implementation has multiple named exports along with `default`.
+			// This is the biggest heuristic leap for this rule, but the assumption is
+			// that the default export in the types was intended to represent the object
+			// shape of `module.exports`, not `module.exports.default`. This may result
+			// in false positives, but those false positives can be silenced by adding
+			// exports in the types for other named exports in the JS. It's detecting
+			// a definite problem; it's just not always accurate about the diagnosis.
+			return {
+				kind: 'MissingExportEquals',
+				typesFileName,
+				implementationFileName,
+			};
+		}
+
+		// eslint-disable-next-line no-var
+		var implProbableExports: unknown,
+			implChecker: unknown,
+			implHasDefault: unknown,
+			implTypeOfModuleExports: unknown,
+			implExportEqualsIsExportDefault: unknown,
+			typesChecker: unknown,
+			typesDefaultSymbol: unknown,
+			typesTypeOfDefault: unknown;
+		function getImplProbableExports(): Export[] {
+			return ((implProbableExports as Export[]) ??= getProbableExports(implementationSourceFile));
+		}
+		function getImplChecker(): ts.TypeChecker {
+			return ((implChecker as ts.TypeChecker) ??= host
+				.createAuxiliaryProgram([implementationFileName!])
+				.getTypeChecker());
+		}
+		function getImplHasDefault(): boolean {
+			return ((implHasDefault as boolean) ??=
+				implementationSourceFile?.symbol?.exports?.has(ts.InternalSymbolName.Default)
+				|| getImplProbableExports()?.some((s) => s.name === 'default')
+				|| (!!implementationSourceFile.symbol?.exports?.size
+					&& getImplChecker()
+						.getExportsAndPropertiesOfModule(implementationSourceFile.symbol)
+						.some((s) => s.name === 'default')));
+		}
+		function getTypesChecker(): ts.TypeChecker {
+			return ((typesChecker as ts.TypeChecker) ??= host.createAuxiliaryProgram([typesFileName!]).getTypeChecker());
+		}
+		function getTypesDefaultSymbol(): ts.Symbol | undefined {
+			return ((typesDefaultSymbol as ts.Symbol | undefined) ??=
+				typesSourceFile.symbol.exports!.get(ts.InternalSymbolName.Default)
+					?? getTypesChecker()
+						.getExportsAndPropertiesOfModule(typesSourceFile.symbol)
+						.find((s) => s.escapedName === 'default'));
+		}
+		function getTypesTypeOfDefault(): ts.Type {
+			const symbol = getTypesDefaultSymbol();
+			return ((typesTypeOfDefault as ts.Type) ??= symbol
+				? getTypesChecker().getTypeOfSymbol(symbol)
+				: getTypesChecker().getAnyType());
+		}
+		function getImplTypeOfModuleExports(): ts.Type {
+			if (implTypeOfModuleExports) {
+				return implTypeOfModuleExports as ts.Type;
+			}
+			const type = getImplChecker().getTypeOfSymbol(
+				getImplChecker().resolveExternalModuleSymbol(implementationSourceFile.symbol),
+			);
+			if (type.flags & ts.TypeFlags.Any && getImplExportEqualsIsExportDefault()) {
+				return (implTypeOfModuleExports = getImplChecker().getTypeOfSymbol(
+					implementationSourceFile.symbol.exports!.get(ts.InternalSymbolName.Default)!,
+				));
+			}
+			return (implTypeOfModuleExports = type);
+		}
+		function getImplExportEqualsIsExportDefault(): boolean {
+			// TypeScript has a circularity error on `module.exports = exports.default`, so
+			// detect that pattern syntactically.
+			if (implExportEqualsIsExportDefault !== undefined) {
+				return implExportEqualsIsExportDefault as boolean;
+			}
+			const exportEquals = implementationSourceFile.symbol.exports!.get(ts.InternalSymbolName.ExportEquals);
+			if (!exportEquals) {
+				return (implExportEqualsIsExportDefault = false);
+			}
+			const exportDefault = implementationSourceFile.symbol.exports!.get(ts.InternalSymbolName.Default);
+			if (!exportDefault) {
+				return (implExportEqualsIsExportDefault = false);
+			}
+			for (
+				const assignment of [
+					exportEquals.valueDeclaration,
+					ts.findAncestor(exportDefault.declarations?.[0], ts.isBinaryExpression),
+				]
+			) {
+				let seenModuleExports = false,
+					seenExportsDefault = false;
+				if (
+					assignment
+					&& ts.isBinaryExpression(assignment)
+					&& assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken
+				) {
+					const res = !!forEachAssignmentTarget(assignment, (target) => {
+						if (!seenExportsDefault && isExportsDefault(target)) {
+							seenExportsDefault = true;
+						} else if (!seenModuleExports && isModuleExports(target)) {
+							seenModuleExports = true;
+						}
+
+						return seenExportsDefault && seenModuleExports;
+					});
+					if (res) {
+						return (implExportEqualsIsExportDefault = true);
+					}
+				}
+			}
+			return (implExportEqualsIsExportDefault = false);
+		}
+		function implIsAnalyzable(): boolean {
+			if (implementationSourceFile.symbol.exports!.get(ts.InternalSymbolName.ExportEquals)!.declarations!.length > 1) {
+				// Multiple assignments in different function bodies is probably a bundle we can't analyze.
+				// Multiple assignments in the same function body might just be an environment-conditional
+				// module.exports inside an IIFE.
+				let commonContainer;
+				for (
+					const decl of implementationSourceFile.symbol.exports!.get(ts.InternalSymbolName.ExportEquals)!
+						.declarations!
+				) {
+					const container = ts.findAncestor(decl, (node) => ts.isFunctionBlock(node) || ts.isSourceFile(node));
+					if (commonContainer === undefined) {
+						commonContainer = container;
+					} else if (commonContainer !== container) {
+						return false;
+					}
+				}
+			}
+			return !!(implementationSourceFile.symbol.exports!.size || getImplProbableExports()?.length);
+		}
+		return;
+	},
+});
+
+function typeIsObjecty(type: ts.Type, checker: ts.TypeChecker) {
+	return (
+		type.flags & ts.TypeFlags.Object
+		&& !(type.flags & ts.TypeFlags.Primitive)
+		&& !checker.typeHasCallOrConstructSignatures(type)
+	);
+}
+
+function isModuleExports(target: ts.Expression) {
+	return (
+		(ts.isAccessExpression(target)
+			&& ts.isIdentifier(target.expression)
+			&& target.expression.text === 'module'
+			&& getNameOfAccessExpression(target) === 'exports')
+		|| (ts.isIdentifier(target) && target.text === 'exports')
+	);
+}
+
+function isExportsDefault(target: ts.Expression) {
+	return (
+		(ts.isAccessExpression(target)
+			&& ts.isIdentifier(target.expression)
+			&& target.expression.text === 'exports'
+			&& getNameOfAccessExpression(target) === 'default')
+		|| (ts.isAccessExpression(target)
+			&& ts.isAccessExpression(target.expression)
+			&& ts.isIdentifier(target.expression.expression)
+			&& target.expression.expression.text === 'module'
+			&& getNameOfAccessExpression(target.expression) === 'exports'
+			&& getNameOfAccessExpression(target) === 'default')
+	);
+}
+
+function isNotDefaultOrEsModule(name: string) {
+	return name !== 'default' && name !== '__esModule';
+}
+
+function forEachAssignmentTarget<ReturnT>(
+	assignment: ts.BinaryExpression,
+	cb: (target: ts.Expression) => ReturnT | undefined,
+): ReturnT | undefined {
+	// For `module.exports = exports = exports.default`, fires `cb` once for
+	// `exports.default`, once for `exports`, and once for `module.exports`.
+	const target = ts.skipParentheses(assignment.right);
+	if (ts.isBinaryExpression(target) && target.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+		const res = forEachAssignmentTarget(target, cb);
+		if (res) {
+			return res;
+		}
+	} else {
+		const res = cb(target);
+		if (res) {
+			return res;
+		}
+	}
+	return cb(ts.skipParentheses(assignment.left));
+}
+
+function getNameOfAccessExpression(accessExpression: ts.AccessExpression): string | undefined {
+	const node = ts.getNameOfAccessExpression(accessExpression);
+	if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
+		return node.text;
+	}
+
+	return undefined;
+}
diff --git a/attw-fork/src/internal/checks/index.ts b/attw-fork/src/internal/checks/index.ts
new file mode 100644
index 0000000000..4bdc72e1d3
--- /dev/null
+++ b/attw-fork/src/internal/checks/index.ts
@@ -0,0 +1,17 @@
+import cjsOnlyExportsDefault from './cjsOnlyExportsDefault.ts';
+import entrypointResolutions from './entrypointResolutions.ts';
+import exportDefaultDisagreement from './exportDefaultDisagreement.ts';
+import internalResolutionError from './internalResolutionError.ts';
+import moduleKindDisagreement from './moduleKindDisagreement.ts';
+import namedExports from './namedExports.ts';
+import unexpectedModuleSyntax from './unexpectedModuleSyntax.ts';
+
+export default [
+	entrypointResolutions,
+	moduleKindDisagreement,
+	exportDefaultDisagreement,
+	namedExports,
+	cjsOnlyExportsDefault,
+	unexpectedModuleSyntax,
+	internalResolutionError,
+];
diff --git a/attw-fork/src/internal/checks/internalResolutionError.ts b/attw-fork/src/internal/checks/internalResolutionError.ts
new file mode 100644
index 0000000000..3906c68856
--- /dev/null
+++ b/attw-fork/src/internal/checks/internalResolutionError.ts
@@ -0,0 +1,53 @@
+import ts from 'typescript';
+import type { InternalResolutionErrorProblem } from '../../types.ts';
+import { defineCheck } from '../defineCheck.ts';
+
+export default defineCheck({
+	name: 'InternalResolutionError',
+	enumerateFiles: true,
+	dependencies: ({ resolutionOption, fileName }) => [resolutionOption, fileName],
+	execute: ([resolutionOption, fileName], context) => {
+		if (!ts.hasTSFileExtension(fileName)) {
+			return;
+		}
+		const host = context.hosts[resolutionOption];
+		const sourceFile = host.getSourceFile(fileName);
+		if (sourceFile?.imports) {
+			const problems: InternalResolutionErrorProblem[] = [];
+			for (const moduleSpecifier of sourceFile.imports) {
+				const reference = moduleSpecifier.text;
+				if (
+					reference !== context.pkg.packageName
+					&& !reference.startsWith(`${context.pkg.packageName}/`)
+					&& reference[0] !== '#'
+					&& !ts.pathIsRelative(reference)
+				) {
+					// Probably a reference to something we'd have to npm install.
+					// These can definitely be errors, but I'm not installing a whole
+					// graph for now.
+					continue;
+				}
+				const resolutionMode = ts.getModeForUsageLocation(sourceFile, moduleSpecifier, host.getCompilerOptions());
+				const resolution = host.getResolvedModule(sourceFile, moduleSpecifier.text, resolutionMode);
+				if (!resolution) {
+					throw new Error(`Expected resolution for '${moduleSpecifier.text}' in ${fileName}`);
+				}
+
+				if (!resolution.resolvedModule) {
+					problems.push({
+						kind: 'InternalResolutionError',
+						resolutionOption,
+						fileName,
+						moduleSpecifier: reference,
+						pos: moduleSpecifier.pos,
+						end: moduleSpecifier.end,
+						resolutionMode,
+						trace: host.getTrace(fileName, moduleSpecifier.text, resolutionMode)!,
+					});
+				}
+			}
+			return problems;
+		}
+		return;
+	},
+});
diff --git a/attw-fork/src/internal/checks/moduleKindDisagreement.ts b/attw-fork/src/internal/checks/moduleKindDisagreement.ts
new file mode 100644
index 0000000000..cba042738b
--- /dev/null
+++ b/attw-fork/src/internal/checks/moduleKindDisagreement.ts
@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { defineCheck } from '../defineCheck.ts';
+
+export default defineCheck({
+	name: 'ModuleKindDisagreement',
+	dependencies: ({ entrypoints, subpath, resolutionKind, resolutionOption, programInfo }) => {
+		const entrypoint = entrypoints[subpath]!.resolutions[resolutionKind];
+		const typesFileName = entrypoint.resolution?.fileName;
+		const implementationFileName = entrypoint.implementationResolution?.fileName;
+		return [
+			typesFileName,
+			implementationFileName,
+			typesFileName ? programInfo[resolutionOption]?.moduleKinds?.[typesFileName] : undefined,
+			implementationFileName ? programInfo[resolutionOption]?.moduleKinds?.[implementationFileName] : undefined,
+		];
+	},
+	execute: ([typesFileName, implementationFileName, typesModuleKind, implementationModuleKind]) => {
+		if (typesFileName && implementationFileName && typesModuleKind && implementationModuleKind) {
+			if (
+				typesModuleKind.detectedKind === ts.ModuleKind.ESNext
+				&& implementationModuleKind.detectedKind === ts.ModuleKind.CommonJS
+			) {
+				return {
+					kind: 'FalseESM',
+					typesFileName,
+					implementationFileName,
+					typesModuleKind,
+					implementationModuleKind,
+				};
+			} else if (
+				typesModuleKind.detectedKind === ts.ModuleKind.CommonJS
+				&& implementationModuleKind.detectedKind === ts.ModuleKind.ESNext
+			) {
+				return {
+					kind: 'FalseCJS',
+					typesFileName,
+					implementationFileName,
+					typesModuleKind,
+					implementationModuleKind,
+				};
+			}
+		}
+		return;
+	},
+});
diff --git a/attw-fork/src/internal/checks/namedExports.ts b/attw-fork/src/internal/checks/namedExports.ts
new file mode 100644
index 0000000000..a2799de800
--- /dev/null
+++ b/attw-fork/src/internal/checks/namedExports.ts
@@ -0,0 +1,86 @@
+import ts from 'typescript';
+import { getResolutionOption } from '../../utils.ts';
+import { defineCheck } from '../defineCheck.ts';
+import { getEsmModuleNamespace } from '../esm/esmNamespace.ts';
+
+export default defineCheck({
+	name: 'NamedExports',
+	dependencies: ({ entrypoints, subpath, resolutionKind, programInfo }) => {
+		const entrypoint = entrypoints[subpath]!.resolutions[resolutionKind];
+		const typesFileName = entrypoint.resolution?.isTypeScript && entrypoint.resolution.fileName;
+		const resolutionOption = getResolutionOption(resolutionKind);
+		const typesModuleKind = typesFileName ? programInfo[resolutionOption].moduleKinds?.[typesFileName] : undefined;
+		const implementationFileName = entrypoint.implementationResolution?.fileName;
+		const implementationModuleKind = implementationFileName
+			? programInfo[resolutionOption].moduleKinds?.[implementationFileName]
+			: undefined;
+		return [implementationFileName, implementationModuleKind, typesFileName, typesModuleKind, resolutionKind];
+	},
+	execute: (
+		[implementationFileName, implementationModuleKind, typesFileName, typesModuleKind, resolutionKind],
+		context,
+	) => {
+		if (
+			!implementationFileName
+			|| !typesFileName
+			|| resolutionKind !== 'node16-esm'
+			|| typesModuleKind?.detectedKind !== ts.ModuleKind.CommonJS
+			|| implementationModuleKind?.detectedKind !== ts.ModuleKind.CommonJS
+		) {
+			return;
+		}
+
+		// Get declared exported names from TypeScript
+		const host = context.hosts.findHostForFiles([typesFileName])!;
+		const typesSourceFile = host.getSourceFile(typesFileName)!;
+		if (typesSourceFile.scriptKind === ts.ScriptKind.JSON || !typesSourceFile.symbol) {
+			return;
+		}
+
+		const typeChecker = host.createAuxiliaryProgram([typesFileName]).getTypeChecker();
+		const moduleType = typeChecker.getTypeOfSymbol(typeChecker.resolveExternalModuleSymbol(typesSourceFile.symbol));
+		if (typeChecker.isArrayLikeType(moduleType) || typeChecker.getPropertyOfType(moduleType, '0')) {
+			return;
+		}
+		const expectedNames = [
+			...new Set(
+				typeChecker
+					.getExportsAndPropertiesOfModule(typesSourceFile.symbol)
+					.filter((symbol) => {
+						return (
+							// TS treats `prototype` and other static class members as exports. There's possibly
+							// a fix to be done in TS itself, since these show up as auto-imports.
+							symbol.name !== 'prototype'
+							// @ts-expect-error `getSymbolFlags` extra arguments are not declared on TypeChecker
+							&& typeChecker.getSymbolFlags(symbol, /*excludeTypeOnlyMeanings*/ true) & ts.SymbolFlags.Value
+						);
+					})
+					.map((symbol) => symbol.name),
+			),
+		];
+
+		// Get actual exported names as seen by nodejs
+		let exports: readonly string[] | undefined;
+		try {
+			exports = getEsmModuleNamespace(context.pkg, implementationFileName);
+		} catch {
+			// If this fails then the result is indeterminate. This could happen in many cases, but
+			// a common one would be for packages which re-export from another another package.
+			return;
+		}
+
+		const missing = expectedNames.filter((name) => !exports.includes(name));
+		if (missing.length > 0) {
+			const lengthWithoutDefault = (names: readonly string[]) => names.length - (names.includes('default') ? 1 : 0);
+			return {
+				kind: 'NamedExports',
+				implementationFileName,
+				typesFileName,
+				isMissingAllNamed: lengthWithoutDefault(missing) === lengthWithoutDefault(expectedNames),
+				missing,
+			};
+		}
+
+		return;
+	},
+});
diff --git a/attw-fork/src/internal/checks/unexpectedModuleSyntax.ts b/attw-fork/src/internal/checks/unexpectedModuleSyntax.ts
new file mode 100644
index 0000000000..361c10b25c
--- /dev/null
+++ b/attw-fork/src/internal/checks/unexpectedModuleSyntax.ts
@@ -0,0 +1,35 @@
+import ts from 'typescript';
+import { defineCheck } from '../defineCheck.ts';
+
+export default defineCheck({
+	name: 'UnexpectedModuleSyntax',
+	enumerateFiles: true,
+	dependencies: ({ fileName, resolutionOption, programInfo }) => {
+		return [fileName, programInfo[resolutionOption].moduleKinds?.[fileName]];
+	},
+	execute: ([fileName, expectedModuleKind], context) => {
+		if (!expectedModuleKind || !ts.hasJSFileExtension(fileName)) {
+			return;
+		}
+		const host = context.hosts.findHostForFiles([fileName]) ?? context.hosts.bundler;
+		const sourceFile = host.getSourceFile(fileName)!;
+		const syntaxImpliedModuleKind = sourceFile.externalModuleIndicator
+			? ts.ModuleKind.ESNext
+			: sourceFile.commonJsModuleIndicator
+			? ts.ModuleKind.CommonJS
+			: undefined;
+		if (syntaxImpliedModuleKind !== undefined && expectedModuleKind.detectedKind !== syntaxImpliedModuleKind) {
+			// Value cannot be `true` because we set `moduleDetection: "legacy"`
+			const syntax = (sourceFile.externalModuleIndicator ?? sourceFile.commonJsModuleIndicator) as ts.Node;
+			return {
+				kind: 'UnexpectedModuleSyntax',
+				fileName,
+				moduleKind: expectedModuleKind,
+				syntax: syntaxImpliedModuleKind,
+				pos: syntax.getStart(sourceFile),
+				end: syntax.end,
+			};
+		}
+		return;
+	},
+});
diff --git a/attw-fork/src/internal/defineCheck.ts b/attw-fork/src/internal/defineCheck.ts
new file mode 100644
index 0000000000..6b36f9df79
--- /dev/null
+++ b/attw-fork/src/internal/defineCheck.ts
@@ -0,0 +1,52 @@
+import type { Package } from '../createPackage.ts';
+import type { Analysis, Problem, ResolutionKind, ResolutionOption } from '../types.ts';
+import type { CompilerHosts } from './multiCompilerHost.ts';
+
+export interface CheckDependenciesContext<EnumerateFiles extends boolean = false> extends CheckExecutionContext {
+	subpath: string;
+	resolutionKind: ResolutionKind;
+	resolutionOption: ResolutionOption;
+	fileName: EnumerateFiles extends true ? string : undefined;
+}
+
+export interface CheckExecutionContext {
+	pkg: Package;
+	hosts: CompilerHosts;
+	entrypoints: Analysis['entrypoints'];
+	programInfo: Analysis['programInfo'];
+}
+
+// Interface types are not assignable to Serializable due to missing index signature.
+// This breaks them down into an equivalently structured object type, which have
+// implicit index signatures for assignability purposes.
+type Structure<T> = T extends (...args: never) => any ? T : { [K in keyof T]: Structure<T[K]> };
+
+export type EnsureSerializable<T> = [T] extends [Serializable] ? T
+	: [T] extends [object] ? Structure<T> extends Serializable ? T
+		: never
+	: never;
+
+export type Serializable =
+	| string
+	| number
+	| null
+	| undefined
+	| boolean
+	| { [key: string]: Serializable }
+	| readonly Serializable[];
+
+export interface AnyCheck {
+	name: string;
+	enumerateFiles?: boolean;
+	dependencies: (context: CheckDependenciesContext<boolean>) => EnsureSerializable<readonly any[]>;
+	execute: (dependencies: any, context: CheckExecutionContext) => Problem[] | Problem | undefined;
+}
+
+export function defineCheck<const Dependencies extends readonly any[], EnumerateFiles extends boolean>(options: {
+	name: string;
+	enumerateFiles?: EnumerateFiles;
+	dependencies: (context: CheckDependenciesContext<EnumerateFiles>) => EnsureSerializable<Dependencies>;
+	execute: (dependencies: Dependencies, context: CheckExecutionContext) => Problem[] | Problem | undefined;
+}) {
+	return options;
+}
diff --git a/attw-fork/src/internal/esm/cjsBindings.ts b/attw-fork/src/internal/esm/cjsBindings.ts
new file mode 100644
index 0000000000..b83d99afb1
--- /dev/null
+++ b/attw-fork/src/internal/esm/cjsBindings.ts
@@ -0,0 +1,6 @@
+import type { Exports } from 'cjs-module-lexer';
+import { parse as cjsParse } from 'cjs-module-lexer';
+
+export function getCjsModuleBindings(sourceText: string): Exports {
+	return cjsParse(sourceText);
+}
diff --git a/attw-fork/src/internal/esm/cjsNamespace.ts b/attw-fork/src/internal/esm/cjsNamespace.ts
new file mode 100644
index 0000000000..d285e9e5d9
--- /dev/null
+++ b/attw-fork/src/internal/esm/cjsNamespace.ts
@@ -0,0 +1,29 @@
+import type { Package } from '../../createPackage.ts';
+import { getCjsModuleBindings } from './cjsBindings.ts';
+import { cjsResolve } from './resolve.ts';
+
+export function getCjsModuleNamespace(fs: Package, file: URL, seen = new Set<string>()): Set<string> {
+	seen.add(file.pathname);
+	const exports = new Set<string>();
+	const bindings = getCjsModuleBindings(fs.readFile(file.pathname));
+	for (const name of bindings.exports) exports.add(name);
+
+	// CJS always exports `default`
+	if (!exports.has('default')) {
+		exports.add('default');
+	}
+
+	// Additionally, resolve facade reexports
+
+	for (const source of bindings.reexports.reverse()) {
+		try {
+			const { format, url } = cjsResolve(fs, source, file);
+			if (format === 'commonjs' && !seen.has(url.pathname)) {
+				const reexported = getCjsModuleNamespace(fs, url, seen);
+				for (const name of reexported) exports.add(name);
+			}
+		} catch {}
+	}
+
+	return exports;
+}
diff --git a/attw-fork/src/internal/esm/esmBindings.ts b/attw-fork/src/internal/esm/esmBindings.ts
new file mode 100644
index 0000000000..40fc80690b
--- /dev/null
+++ b/attw-fork/src/internal/esm/esmBindings.ts
@@ -0,0 +1,114 @@
+import type { Exports } from 'cjs-module-lexer';
+import ts from 'typescript';
+
+// Note: There is a pretty solid module `es-module-lexer` which performs a similar lexing operation
+// as `cjs-module-lexer`, but has some limitations in what it can express. This implementation
+// should be more complete.
+
+function* extractDestructedNames(node: ts.BindingName): Iterable<string> {
+	switch (node.kind) {
+		case ts.SyntaxKind.ArrayBindingPattern: {
+			for (const element of node.elements) {
+				if (element.kind === ts.SyntaxKind.BindingElement) {
+					yield* extractDestructedNames(element.name);
+				}
+			}
+			break;
+		}
+
+		case ts.SyntaxKind.Identifier: {
+			yield node.text;
+			break;
+		}
+
+		case ts.SyntaxKind.ObjectBindingPattern: {
+			for (const element of node.elements) {
+				yield* extractDestructedNames(element.name);
+			}
+			break;
+		}
+
+		default: {
+			node satisfies never;
+		}
+	}
+}
+
+export function getEsmModuleBindings(sourceText: string): Exports {
+	const options: ts.CreateSourceFileOptions = {
+		languageVersion: ts.ScriptTarget.ESNext,
+		impliedNodeFormat: ts.ModuleKind.ESNext,
+	};
+	const sourceFile = ts.createSourceFile('module.cjs', sourceText, options, false, ts.ScriptKind.JS);
+
+	const exports: string[] = [];
+	const reexports: string[] = [];
+	for (const statement of sourceFile.statements) {
+		switch (statement.kind) {
+			case ts.SyntaxKind.ExportDeclaration: {
+				const declaration = statement as ts.ExportDeclaration;
+				const { exportClause, isTypeOnly, moduleSpecifier } = declaration;
+				if (!isTypeOnly) {
+					if (exportClause) {
+						if (exportClause.kind === ts.SyntaxKind.NamedExports) {
+							// `export { foo }`;
+							// `export { foo } from 'specifier'`;
+							for (const element of exportClause.elements) {
+								if (!element.isTypeOnly) {
+									exports.push(element.name.text);
+								}
+							}
+						} else {
+							// `export * as namespace from 'specifier'`
+							exports.push(exportClause.name.text);
+						}
+					} else if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+						// `export * from 'specifier'`
+						reexports.push(moduleSpecifier.text);
+					}
+				}
+				break;
+			}
+
+			case ts.SyntaxKind.ExportAssignment: {
+				const assignment = statement as ts.ExportAssignment;
+				if (!assignment.isExportEquals) {
+					// `export default ...`
+					exports.push('default');
+				}
+				break;
+			}
+
+			case ts.SyntaxKind.ClassDeclaration:
+			case ts.SyntaxKind.FunctionDeclaration: {
+				const declaration = statement as ts.ClassDeclaration | ts.FunctionDeclaration;
+				if (ts.hasSyntacticModifier(declaration, ts.ModifierFlags.Export)) {
+					if (ts.hasSyntacticModifier(declaration, ts.ModifierFlags.Default)) {
+						// `export default class {}`
+						// `export default function () {}`
+						exports.push('default');
+					} else if (declaration.name) {
+						// `export class Foo {}`
+						// `export function foo() {}`
+						exports.push(declaration.name.text);
+					}
+				}
+				break;
+			}
+
+			case ts.SyntaxKind.VariableStatement: {
+				const declaration = statement as ts.VariableStatement;
+				if (ts.hasSyntacticModifier(declaration, ts.ModifierFlags.Export)) {
+					// `export const foo = null;`
+					// `export const { foo, bar } = null;`
+					for (const declarator of declaration.declarationList.declarations) {
+						exports.push(...extractDestructedNames(declarator.name));
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	return { exports, reexports };
+}
diff --git a/attw-fork/src/internal/esm/esmNamespace.ts b/attw-fork/src/internal/esm/esmNamespace.ts
new file mode 100644
index 0000000000..5a22fb5f61
--- /dev/null
+++ b/attw-fork/src/internal/esm/esmNamespace.ts
@@ -0,0 +1,39 @@
+import type { Package } from '../../createPackage.ts';
+import { getCjsModuleNamespace } from './cjsNamespace.ts';
+import { getEsmModuleBindings } from './esmBindings.ts';
+import { esmResolve } from './resolve.ts';
+
+// Note: this doesn't handle ambiguous indirect exports which probably isn't worth the
+// implementation complexity.
+
+export function getEsmModuleNamespace(
+	fs: Package,
+	specifier: string,
+	parentURL = new URL('file:///'),
+	seen = new Set<string>(),
+): string[] {
+	// Resolve specifier
+	const { format, url } = esmResolve(fs, specifier, parentURL);
+
+	// Don't recurse for circular indirect exports
+	if (seen.has(url.pathname)) {
+		return [];
+	}
+	seen.add(url.pathname);
+
+	if (format === 'commonjs') {
+		return [...getCjsModuleNamespace(fs, url)];
+	}
+
+	// Parse module bindings
+	const bindings = (format ?? 'module') === 'module'
+		? getEsmModuleBindings(fs.readFile(url.pathname))
+		// Maybe JSON, WASM, etc
+		: { exports: ['default'], reexports: [] };
+
+	// Concat indirect exports
+	const indirect = bindings.reexports
+		.flatMap((specifier) => getEsmModuleNamespace(fs, specifier, url, seen))
+		.filter((name) => name !== 'default');
+	return [...new Set([...bindings.exports, ...indirect])];
+}
diff --git a/attw-fork/src/internal/esm/resolve.ts b/attw-fork/src/internal/esm/resolve.ts
new file mode 100644
index 0000000000..59a1e91af9
--- /dev/null
+++ b/attw-fork/src/internal/esm/resolve.ts
@@ -0,0 +1,21 @@
+import * as cjs from '@loaderkit/resolve/cjs';
+import * as esm from '@loaderkit/resolve/esm';
+import type { FileSystemSync } from '@loaderkit/resolve/fs';
+import type { Package } from '../../createPackage.ts';
+
+function makeFileSystemAdapter(fs: Package): FileSystemSync {
+	return {
+		directoryExists: (url) => fs.directoryExists(url.pathname),
+		fileExists: (url) => fs.fileExists(url.pathname),
+		readFileJSON: (url) => JSON.parse(fs.readFile(url.pathname)),
+		readLink: (): undefined => {},
+	};
+}
+
+export function cjsResolve(fs: Package, specifier: string, parentURL: URL) {
+	return cjs.resolveSync(makeFileSystemAdapter(fs), specifier, parentURL);
+}
+
+export function esmResolve(fs: Package, specifier: string, parentURL: URL) {
+	return esm.resolveSync(makeFileSystemAdapter(fs), specifier, parentURL);
+}
diff --git a/attw-fork/src/internal/getEntrypointInfo.ts b/attw-fork/src/internal/getEntrypointInfo.ts
new file mode 100644
index 0000000000..522e8f30d9
--- /dev/null
+++ b/attw-fork/src/internal/getEntrypointInfo.ts
@@ -0,0 +1,246 @@
+import ts from 'typescript';
+import type { CheckPackageOptions } from '../checkPackage.ts';
+import type { Package } from '../createPackage.ts';
+import type {
+	BuildTool,
+	EntrypointInfo,
+	EntrypointResolutionAnalysis,
+	ModuleKind,
+	Resolution,
+	ResolutionKind,
+	ResolutionOption,
+} from '../types.ts';
+import { allBuildTools, getResolutionKinds } from '../utils.ts';
+import type { CompilerHosts, CompilerHostWrapper } from './multiCompilerHost.ts';
+
+const extensions = new Set(['.jsx', '.tsx', '.js', '.ts', '.mjs', '.cjs', '.mts', '.cjs']);
+
+function getEntrypoints(fs: Package, exportsObject: unknown, options: CheckPackageOptions | undefined): string[] {
+	if (options?.entrypoints) {
+		return options.entrypoints.map((e) => formatEntrypointString(e, fs.packageName));
+	}
+	if (exportsObject === undefined && fs) {
+		const rootDir = `/node_modules/${fs.packageName}`;
+		const proxies = getProxyDirectories(rootDir, fs);
+		if (proxies.length === 0) {
+			if (options?.entrypointsLegacy) {
+				return fs
+					.listFiles()
+					.filter((f) => !ts.isDeclarationFileName(f) && extensions.has(f.slice(f.lastIndexOf('.'))))
+					.map((f) => '.' + f.slice(rootDir.length));
+			}
+			return ['.'];
+		}
+		return proxies;
+	}
+	const detectedSubpaths = getSubpaths(exportsObject);
+	if (detectedSubpaths.length === 0) {
+		detectedSubpaths.push('.');
+	}
+	const included = unique([
+		...detectedSubpaths,
+		...(options?.includeEntrypoints?.map((e) => formatEntrypointString(e, fs.packageName)) ?? []),
+	]);
+	if (!options?.excludeEntrypoints) {
+		return included;
+	}
+	return included.filter((entrypoint) => {
+		return !options.excludeEntrypoints!.some((exclusion) => {
+			if (typeof exclusion === 'string') {
+				return formatEntrypointString(exclusion, fs.packageName) === entrypoint;
+			}
+			return exclusion.test(entrypoint);
+		});
+	});
+}
+
+function formatEntrypointString(path: string, packageName: string) {
+	return (
+		path === '.' || path.startsWith('./')
+			? path
+			: path === packageName
+			? '.'
+			: path.startsWith(`${packageName}/`)
+			? `.${path.slice(packageName.length)}`
+			: `./${path}`
+	).trim();
+}
+
+function getSubpaths(exportsObject: any): string[] {
+	if (!exportsObject || typeof exportsObject !== 'object' || Array.isArray(exportsObject)) {
+		return [];
+	}
+	const keys = Object.keys(exportsObject);
+	if (keys[0]!.startsWith('.')) {
+		return keys;
+	}
+	return keys.flatMap((key) => getSubpaths(exportsObject[key]));
+}
+
+function getProxyDirectories(rootDir: string, fs: Package) {
+	const vendorDirectories = new Set<string>();
+	const proxyDirectories: string[] = [];
+	const files = fs.listFiles().sort((a, b) => a.length - b.length);
+	for (const file of files) {
+		if (file.startsWith(rootDir) && file.endsWith('/package.json')) {
+			try {
+				const packageJson = JSON.parse(fs.readFile(file));
+				if (packageJson.name && !packageJson.name.startsWith(fs.packageName)) {
+					// Name unrelated to the root package, this is a vendored package
+					const vendorDir = file.slice(0, file.lastIndexOf('/'));
+					vendorDirectories.add(vendorDir);
+				} else if ('main' in packageJson && !isInsideVendorDirectory(file)) {
+					// No name or name starting with root package name, this is intended to be an entrypoint
+					const proxyDir = '.' + file.slice(rootDir.length, file.lastIndexOf('/'));
+					proxyDirectories.push(proxyDir);
+				}
+			} catch {}
+		}
+	}
+
+	return proxyDirectories.sort((a, b) => {
+		return ts.comparePathsCaseInsensitive(a, b);
+	});
+
+	function isInsideVendorDirectory(file: string) {
+		return !!ts.forEachAncestorDirectory(file, (dir) => {
+			if (vendorDirectories.has(dir)) {
+				return true;
+			}
+
+			return;
+		});
+	}
+}
+
+export function getEntrypointInfo(
+	packageName: string,
+	fs: Package,
+	hosts: CompilerHosts,
+	options: CheckPackageOptions | undefined,
+): Record<string, EntrypointInfo> {
+	const packageJson = JSON.parse(fs.readFile(`/node_modules/${packageName}/package.json`));
+	let entrypoints = getEntrypoints(fs, packageJson.exports, options);
+	if (fs.typesPackage) {
+		const typesPackageJson = JSON.parse(fs.readFile(`/node_modules/${fs.typesPackage.packageName}/package.json`));
+		const typesEntrypoints = getEntrypoints(fs, typesPackageJson.exports, options);
+		entrypoints = unique([...entrypoints, ...typesEntrypoints]);
+	}
+	const result: Record<string, EntrypointInfo> = {};
+	for (const entrypoint of entrypoints) {
+		const resolutions: Record<ResolutionKind, EntrypointResolutionAnalysis> = {
+			node10: options?.modes?.['node10'] === false
+				? { name: entrypoint, resolutionKind: 'node10' }
+				: getEntrypointResolution(packageName, hosts.node10, 'node10', entrypoint),
+			'node16-cjs': options?.modes?.['node16-cjs'] === false
+				? { name: entrypoint, resolutionKind: 'node16-cjs' }
+				: getEntrypointResolution(packageName, hosts.node16, 'node16-cjs', entrypoint),
+			'node16-esm': options?.modes?.['node16-esm'] === false
+				? { name: entrypoint, resolutionKind: 'node16-esm' }
+				: getEntrypointResolution(packageName, hosts.node16, 'node16-esm', entrypoint),
+			bundler: options?.modes?.['bundler'] === false
+				? { name: entrypoint, resolutionKind: 'bundler' }
+				: getEntrypointResolution(packageName, hosts.bundler, 'bundler', entrypoint),
+		};
+		result[entrypoint] = {
+			subpath: entrypoint,
+			resolutions,
+			hasTypes: Object.values(resolutions).some((r) => r.resolution?.isTypeScript),
+			isWildcard: !!resolutions.bundler.isWildcard,
+		};
+	}
+	return result;
+}
+function getEntrypointResolution(
+	packageName: string,
+	host: CompilerHostWrapper,
+	resolutionKind: ResolutionKind,
+	entrypoint: string,
+): EntrypointResolutionAnalysis {
+	if (entrypoint.includes('*')) {
+		return { name: entrypoint, resolutionKind, isWildcard: true };
+	}
+	const moduleSpecifier = packageName + entrypoint.slice(1); // remove leading . before slash
+	const importingFileName = resolutionKind === 'node16-esm' ? '/index.mts' : '/index.ts';
+	const resolutionMode = resolutionKind === 'node16-esm'
+		? ts.ModuleKind.ESNext
+		: resolutionKind === 'node16-cjs'
+		? ts.ModuleKind.CommonJS
+		: undefined;
+	const resolution = tryResolve();
+	const implementationResolution = tryResolve(/*noDtsResolution*/ true);
+	const files = resolution
+		? host
+			.createPrimaryProgram(resolution.fileName)
+			.getSourceFiles()
+			.map((f) => f.fileName)
+		: undefined;
+
+	return {
+		name: entrypoint,
+		resolutionKind,
+		resolution,
+		implementationResolution,
+		files,
+	};
+
+	function tryResolve(noDtsResolution?: boolean): Resolution | undefined {
+		const { resolution, trace } = host.resolveModuleName(
+			moduleSpecifier,
+			importingFileName,
+			resolutionMode,
+			noDtsResolution,
+		);
+		const fileName = resolution.resolvedModule?.resolvedFileName;
+		if (!fileName) {
+			return undefined;
+		}
+
+		return {
+			fileName,
+			isJson: resolution.resolvedModule.extension === ts.Extension.Json,
+			isTypeScript: ts.hasTSFileExtension(resolution.resolvedModule.resolvedFileName),
+			trace,
+		};
+	}
+}
+function unique<T>(array: readonly T[]): T[] {
+	return array.filter((value, index) => array.indexOf(value) === index);
+}
+export function getBuildTools(packageJson: any): Partial<Record<BuildTool, string>> {
+	if (!packageJson.devDependencies) {
+		return {};
+	}
+	const result: Partial<Record<BuildTool, string>> = {};
+	for (const buildTool of allBuildTools) {
+		if (buildTool in packageJson.devDependencies) {
+			result[buildTool] = packageJson.devDependencies[buildTool];
+		}
+	}
+	return result;
+}
+export function getModuleKinds(
+	entrypoints: Record<string, EntrypointInfo>,
+	resolutionOption: ResolutionOption,
+	hosts: CompilerHosts,
+): Record<string, ModuleKind> {
+	const host = hosts[resolutionOption];
+	const result: Record<string, ModuleKind> = {};
+	for (const resolutionKind of getResolutionKinds(resolutionOption)) {
+		for (const entrypoint of Object.values(entrypoints)) {
+			const resolution = entrypoint.resolutions[resolutionKind];
+			for (const fileName of resolution.files ?? []) {
+				if (!result[fileName]) {
+					result[fileName] = host.getModuleKindForFile(fileName)!;
+				}
+			}
+			if (resolution.implementationResolution) {
+				const fileName = resolution.implementationResolution.fileName;
+				if (!result[fileName]) {
+					result[fileName] = host.getModuleKindForFile(fileName)!;
+				}
+			}
+		}
+	}
+	return result;
+}
diff --git a/attw-fork/src/internal/getProbableExports.ts b/attw-fork/src/internal/getProbableExports.ts
new file mode 100644
index 0000000000..71c5464d84
--- /dev/null
+++ b/attw-fork/src/internal/getProbableExports.ts
@@ -0,0 +1,96 @@
+import ts from 'typescript';
+
+const minifiedVariableAssignmentPattern = /\S;(?:var|let|const) \w=\S/;
+
+export interface Export {
+	name: string;
+	node: ts.Node;
+}
+
+export function getProbableExports(sourceFile: ts.SourceFile): Export[] {
+	return getEsbuildBabelSwcExports(sourceFile) ?? [];
+}
+
+function getEsbuildBabelSwcExports(sourceFile: ts.SourceFile): Export[] | undefined {
+	let possibleIndex = sourceFile.text.indexOf('\n__export(');
+	if (possibleIndex === -1) {
+		possibleIndex = sourceFile.text.indexOf('\n_export(');
+	}
+	if (possibleIndex === -1 && !isProbablyMinified(sourceFile.text)) {
+		return undefined;
+	}
+
+	for (const statement of sourceFile.statements) {
+		if (possibleIndex !== -1 && statement.end < possibleIndex) {
+			continue;
+		}
+		if (possibleIndex !== -1 && statement.pos > possibleIndex) {
+			break;
+		}
+		if (
+			ts.isExpressionStatement(statement)
+			&& ts.isCallExpression(statement.expression)
+			&& ts.isIdentifier(statement.expression.expression)
+			&& statement.expression.arguments.length === 2
+			&& ts.isIdentifier(statement.expression.arguments[0]!)
+			&& ts.isObjectLiteralExpression(statement.expression.arguments[1]!)
+		) {
+			const callTarget = statement.expression.expression;
+			const isExport = ts.unescapeLeadingUnderscores(callTarget.escapedText) === '__export'
+				|| callTarget.escapedText === '_export'
+				|| isEsbuildExportFunction(sourceFile.locals?.get(callTarget.escapedText)?.valueDeclaration);
+			if (isExport) {
+				return statement.expression.arguments[1].properties.flatMap((prop): Export[] => {
+					if (
+						ts.isPropertyAssignment(prop)
+						&& (ts.isIdentifier(prop.name) || ts.isStringOrNumericLiteralLike(prop.name))
+					) {
+						return [{ name: prop.name.text, node: prop }];
+					}
+					if (ts.isShorthandPropertyAssignment(prop)) {
+						return [{ name: prop.name.text, node: prop }];
+					}
+					return [];
+				});
+			}
+		}
+	}
+
+	return undefined;
+}
+
+function isEsbuildExportFunction(decl: ts.Declaration | undefined) {
+	/*
+  esbuild:
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  esbuild min:
+  b=(o,r)=>{for(var e in r)n(o,e,{get:r[e],enumerable:!0})}
+
+  swc?
+  function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+  }
+  */
+	if (!decl) {
+		return false;
+	}
+	return (
+		ts.isVariableDeclaration(decl)
+		&& decl.initializer
+		&& ts.isFunctionExpressionOrArrowFunction(decl.initializer)
+		&& ts.isBlock(decl.initializer.body)
+		&& decl.initializer.body.statements.length === 1
+		&& ts.isForInStatement(decl.initializer.body.statements[0]!)
+	);
+}
+
+function isProbablyMinified(text: string): boolean {
+	return minifiedVariableAssignmentPattern.test(text);
+}
diff --git a/attw-fork/src/internal/minimalLibDts.ts b/attw-fork/src/internal/minimalLibDts.ts
new file mode 100644
index 0000000000..68081ed182
--- /dev/null
+++ b/attw-fork/src/internal/minimalLibDts.ts
@@ -0,0 +1,78 @@
+// The contents of this string are derived from typescript/lib/lib.es5.d.ts.
+// These types are all that are needed for the NamedExports check to work.
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+export default `
+interface ReadonlyArray<T> {
+  readonly length: number;
+  toString(): string;
+  toLocaleString(): string;
+  concat(...items: ConcatArray<T>[]): T[];
+  concat(...items: (T | ConcatArray<T>)[]): T[];
+  join(separator?: string): string;
+  slice(start?: number, end?: number): T[];
+  indexOf(searchElement: T, fromIndex?: number): number;
+  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  every<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[];
+  every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+  some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+  forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+  map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+  filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
+  filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+  readonly [n: number]: T;
+}
+
+interface Array<T> {
+  length: number;
+  toString(): string;
+  toLocaleString(): string;
+  pop(): T | undefined;
+  push(...items: T[]): number;
+  concat(...items: ConcatArray<T>[]): T[];
+  concat(...items: (T | ConcatArray<T>)[]): T[];
+  join(separator?: string): string;
+  reverse(): T[];
+  shift(): T | undefined;
+  slice(start?: number, end?: number): T[];
+  sort(compareFn?: (a: T, b: T) => number): this;
+  splice(start: number, deleteCount?: number): T[];
+  splice(start: number, deleteCount: number, ...items: T[]): T[];
+  unshift(...items: T[]): number;
+  indexOf(searchElement: T, fromIndex?: number): number;
+  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
+  every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+  some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+  forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+  map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+  filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
+  filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+  reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+  [n: number]: T;
+}
+`;
diff --git a/attw-fork/src/internal/multiCompilerHost.ts b/attw-fork/src/internal/multiCompilerHost.ts
new file mode 100644
index 0000000000..c8bc71e089
--- /dev/null
+++ b/attw-fork/src/internal/multiCompilerHost.ts
@@ -0,0 +1,322 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { LRUCache } from 'lru-cache';
+import ts from 'typescript';
+import type { Package } from '../createPackage.ts';
+import type { ModuleKind } from '../types.ts';
+import minimalLibDts from './minimalLibDts.ts';
+
+export interface ResolveModuleNameResult {
+	resolution: ts.ResolvedModuleWithFailedLookupLocations;
+	trace: string[];
+}
+
+export interface CompilerHosts {
+	node10: CompilerHostWrapper;
+	node16: CompilerHostWrapper;
+	bundler: CompilerHostWrapper;
+	findHostForFiles(files: string[]): CompilerHostWrapper | undefined;
+}
+
+export function createCompilerHosts(fs: Package): CompilerHosts {
+	const node10 = new CompilerHostWrapper(fs, ts.ModuleResolutionKind.Node10, ts.ModuleKind.CommonJS);
+	const node16 = new CompilerHostWrapper(fs, ts.ModuleResolutionKind.Node16, ts.ModuleKind.Node16);
+	const bundler = new CompilerHostWrapper(fs, ts.ModuleResolutionKind.Bundler, ts.ModuleKind.ESNext);
+
+	return {
+		node10,
+		node16,
+		bundler,
+		findHostForFiles(files: string[]) {
+			for (const host of [node10, node16, bundler]) {
+				if (files.every((f) => host.getSourceFileFromCache(f) !== undefined)) {
+					return host;
+				}
+			}
+
+			return;
+		},
+	};
+}
+
+const getCanonicalFileName = ts.createGetCanonicalFileName(false);
+const toPath = (fileName: string) => ts.toPath(fileName, '/', getCanonicalFileName);
+
+export class CompilerHostWrapper {
+	private programCache = new LRUCache<string, ts.Program>({ max: 2 });
+	private compilerHost: ts.CompilerHost;
+	private compilerOptions: ts.CompilerOptions;
+	private normalModuleResolutionCache: ts.ModuleResolutionCache;
+	private noDtsResolutionModuleResolutionCache: ts.ModuleResolutionCache;
+
+	private moduleResolutionCache: Record<
+		/*FromFileName*/ string,
+		Record</*Key*/ string, { resolution: ts.ResolvedModuleWithFailedLookupLocations; trace: string[] }>
+	> = {};
+	private traceCollector: TraceCollector = new TraceCollector();
+	private sourceFileCache: Map<ts.Path, ts.SourceFile> = new Map();
+	private resolvedModules: Exclude<ts.Program['resolvedModules'], undefined> = new Map();
+	private languageVersion = ts.ScriptTarget.Latest;
+
+	constructor(fs: Package, moduleResolution: ts.ModuleResolutionKind, moduleKind: ts.ModuleKind) {
+		this.compilerOptions = {
+			moduleResolution,
+			module: moduleKind,
+			// So `sourceFile.externalModuleIndicator` is set to a node
+			moduleDetection: ts.ModuleDetectionKind.Legacy,
+			target: ts.ScriptTarget.Latest,
+			resolveJsonModule: true,
+			traceResolution: true,
+		};
+		this.normalModuleResolutionCache = ts.createModuleResolutionCache('/', getCanonicalFileName, this.compilerOptions);
+		this.noDtsResolutionModuleResolutionCache = ts.createModuleResolutionCache(
+			'/',
+			getCanonicalFileName,
+			this.compilerOptions,
+		);
+		this.compilerHost = this.createCompilerHost(fs, this.sourceFileCache);
+	}
+
+	getCompilerOptions() {
+		return this.compilerOptions;
+	}
+
+	getSourceFile(fileName: string): ts.SourceFile | undefined {
+		return this.compilerHost.getSourceFile(fileName, this.languageVersion);
+	}
+
+	getSourceFileFromCache(fileName: string): ts.SourceFile | undefined {
+		return this.sourceFileCache.get(toPath(fileName));
+	}
+
+	getModuleKindForFile(fileName: string): ModuleKind | undefined {
+		const kind = this.getImpliedNodeFormatForFile(fileName);
+		if (kind) {
+			const extension = ts.getAnyExtensionFromPath(fileName);
+			const isExtension = extension === ts.Extension.Cjs
+				|| extension === ts.Extension.Cts
+				|| extension === ts.Extension.Dcts
+				|| extension === ts.Extension.Mjs
+				|| extension === ts.Extension.Mts
+				|| extension === ts.Extension.Dmts;
+			const reasonPackageJsonInfo = isExtension ? undefined : this.getPackageScopeForPath(fileName);
+			const reasonFileName = isExtension
+				? fileName
+				: reasonPackageJsonInfo
+				? reasonPackageJsonInfo.packageDirectory + '/package.json'
+				: fileName;
+			const reasonPackageJsonType = reasonPackageJsonInfo?.contents?.packageJsonContent.type;
+			return {
+				detectedKind: kind,
+				detectedReason: isExtension ? 'extension' : reasonPackageJsonType ? 'type' : 'no:type',
+				reasonFileName,
+			};
+		}
+
+		return undefined;
+	}
+
+	resolveModuleName(
+		moduleName: string,
+		containingFile: string,
+		resolutionMode?: ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS,
+		noDtsResolution?: boolean,
+		allowJs?: boolean,
+	): ResolveModuleNameResult {
+		const moduleKey = this.getModuleKey(moduleName, resolutionMode, noDtsResolution, allowJs);
+		if (this.moduleResolutionCache[containingFile]?.[moduleKey]) {
+			const { resolution, trace } = this.moduleResolutionCache[containingFile][moduleKey];
+			return {
+				resolution,
+				trace,
+			};
+		}
+		this.traceCollector.clear();
+		const resolution = ts.resolveModuleName(
+			moduleName,
+			containingFile,
+			noDtsResolution ? { ...this.compilerOptions, noDtsResolution, allowJs } : this.compilerOptions,
+			this.compilerHost,
+			noDtsResolution ? this.noDtsResolutionModuleResolutionCache : this.normalModuleResolutionCache,
+			/*redirectedReference*/ undefined,
+			resolutionMode,
+		);
+		const trace = this.traceCollector.read();
+		if (!this.moduleResolutionCache[containingFile]?.[moduleKey]) {
+			(this.moduleResolutionCache[containingFile] ??= {})[moduleKey] = { resolution, trace };
+		}
+		return {
+			resolution,
+			trace,
+		};
+	}
+
+	getTrace(
+		fromFileName: string,
+		moduleSpecifier: string,
+		resolutionMode: ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS | undefined,
+	): string[] | undefined {
+		return this.moduleResolutionCache[fromFileName]?.[
+			this.getModuleKey(moduleSpecifier, resolutionMode, /*noDtsResolution*/ undefined, /*allowJs*/ undefined)
+		]?.trace;
+	}
+
+	private getModuleKey(
+		moduleSpecifier: string,
+		resolutionMode: ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS | undefined,
+		noDtsResolution: boolean | undefined,
+		allowJs: boolean | undefined,
+	) {
+		return `${resolutionMode ?? 1}:${+!!noDtsResolution}:${+!!allowJs}:${moduleSpecifier}`;
+	}
+
+	private getProgram(rootNames: readonly string[], options: ts.CompilerOptions) {
+		const key = programKey(rootNames, options);
+		let program = this.programCache.get(key);
+		if (!program) {
+			this.programCache.set(key, program = ts.createProgram({ rootNames, options, host: this.compilerHost }));
+		}
+		return program;
+	}
+
+	createPrimaryProgram(rootName: string) {
+		const program = this.getProgram([rootName], this.compilerOptions);
+
+		if (program.resolvedModules) {
+			for (const [path, cache] of program.resolvedModules.entries()) {
+				let ownCache = this.resolvedModules.get(path);
+				if (!ownCache) {
+					this.resolvedModules.set(path, ownCache = ts.createModeAwareCache());
+				}
+				// eslint-disable-next-line unicorn/no-array-for-each
+				cache.forEach((resolution, key, mode) => {
+					ownCache!.set(key, mode, resolution);
+				});
+			}
+		}
+
+		return program;
+	}
+
+	createAuxiliaryProgram(rootNames: string[], extraOptions?: ts.CompilerOptions): ts.Program {
+		if (
+			extraOptions
+			&& ts.changesAffectModuleResolution(
+				// allowJs and noDtsResolution are part of the cache key, but any other resolution-affecting options
+				// are assumed to be constant for the host.
+				{
+					...this.compilerOptions,
+					allowJs: extraOptions.allowJs,
+					checkJs: extraOptions.checkJs,
+					noDtsResolution: extraOptions.noDtsResolution,
+				},
+				{ ...this.compilerOptions, ...extraOptions },
+			)
+		) {
+			throw new Error('Cannot override resolution-affecting options for host due to potential cache pollution');
+		}
+		const options = extraOptions ? { ...this.compilerOptions, ...extraOptions } : this.compilerOptions;
+		return this.getProgram(rootNames, options);
+	}
+
+	getResolvedModule(sourceFile: ts.SourceFile, moduleName: string, resolutionMode: ts.ResolutionMode) {
+		return this.resolvedModules.get(sourceFile.path)?.get(moduleName, resolutionMode);
+	}
+
+	private createCompilerHost(fs: Package, sourceFileCache: Map<ts.Path, ts.SourceFile>): ts.CompilerHost {
+		return {
+			fileExists: fs.fileExists.bind(fs),
+			readFile: fs.readFile.bind(fs),
+			directoryExists: fs.directoryExists.bind(fs),
+			getSourceFile: (fileName) => {
+				const path = toPath(fileName);
+				const cached = sourceFileCache.get(path);
+				if (cached) {
+					return cached;
+				}
+				const content = fileName === '/node_modules/typescript/lib/lib.d.ts' ? minimalLibDts : fs.tryReadFile(fileName);
+				if (content === undefined) {
+					return;
+				}
+
+				const sourceFile = ts.createSourceFile(
+					fileName,
+					content,
+					{
+						languageVersion: this.languageVersion,
+						impliedNodeFormat: this.getImpliedNodeFormatForFile(fileName),
+					},
+					/*setParentNodes*/ true,
+				);
+				sourceFileCache.set(path, sourceFile);
+				return sourceFile;
+			},
+			getDefaultLibFileName: () => '/node_modules/typescript/lib/lib.d.ts',
+			getCurrentDirectory: () => '/',
+			writeFile: () => {
+				throw new Error('Not implemented');
+			},
+			getCanonicalFileName,
+			useCaseSensitiveFileNames: () => false,
+			getNewLine: () => '\n',
+			trace: this.traceCollector.trace,
+			resolveModuleNameLiterals: (
+				moduleLiterals,
+				containingFile,
+				_redirectedReference,
+				options,
+				containingSourceFile,
+			) => {
+				return moduleLiterals.map(
+					(literal) =>
+						this.resolveModuleName(
+							literal.text,
+							containingFile,
+							ts.getModeForUsageLocation(containingSourceFile, literal, this.compilerOptions),
+							options.noDtsResolution,
+						).resolution,
+				);
+			},
+		};
+	}
+
+	private getImpliedNodeFormatForFile(fileName: string): ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS | undefined {
+		return ts.getImpliedNodeFormatForFile(
+			toPath(fileName),
+			this.normalModuleResolutionCache.getPackageJsonInfoCache(),
+			this.compilerHost,
+			this.compilerOptions,
+		);
+	}
+
+	private getPackageScopeForPath(fileName: string): ts.PackageJsonInfo | undefined {
+		return ts.getPackageScopeForPath(
+			fileName,
+			ts.getTemporaryModuleResolutionState(
+				// TODO: consider always using the node16 cache because package.json should be a hit
+				this.normalModuleResolutionCache.getPackageJsonInfoCache(),
+				this.compilerHost,
+				this.compilerOptions,
+			),
+		);
+	}
+}
+
+class TraceCollector {
+	private traces: string[] = [];
+
+	trace = (message: string) => {
+		this.traces.push(message);
+	};
+	read() {
+		const result = [...this.traces];
+		this.clear();
+		return result;
+	}
+	clear() {
+		this.traces.length = 0;
+	}
+}
+
+function programKey(rootNames: readonly string[], options: ts.CompilerOptions) {
+	return JSON.stringify([rootNames, Object.entries(options).sort(([k1], [k2]) => k1.localeCompare(k2))]);
+}
diff --git a/attw-fork/src/problems.ts b/attw-fork/src/problems.ts
new file mode 100644
index 0000000000..ecd8e77c1f
--- /dev/null
+++ b/attw-fork/src/problems.ts
@@ -0,0 +1,201 @@
+import type { Analysis, Problem, ProblemKind, ResolutionKind, ResolutionOption } from './types.ts';
+import { getResolutionKinds } from './utils.ts';
+
+export interface ProblemKindInfo {
+	title: string;
+	emoji: string;
+	shortDescription: string;
+	description: string;
+	details?: string;
+	docsUrl: string;
+}
+
+export const problemKindInfo: Record<ProblemKind, ProblemKindInfo> = {
+	NoResolution: {
+		emoji: '💀',
+		title: 'Resolution failed',
+		shortDescription: 'Resolution failed',
+		description: 'Import failed to resolve to type declarations or JavaScript files.',
+		docsUrl: 'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NoResolution.md',
+	},
+	UntypedResolution: {
+		emoji: '❌',
+		title: 'Could not find types',
+		shortDescription: 'No types',
+		description: 'Import resolved to JavaScript files, but no type declarations were found.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UntypedResolution.md',
+	},
+	FalseCJS: {
+		emoji: '🎭',
+		title: 'Types are CJS, but implementation is ESM',
+		shortDescription: 'Masquerading as CJS',
+		description: 'Import resolved to a CommonJS type declaration file, but an ESM JavaScript file.',
+		docsUrl: 'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseCJS.md',
+	},
+	FalseESM: {
+		emoji: '👺',
+		title: 'Types are ESM, but implementation is CJS',
+		shortDescription: 'Masquerading as ESM',
+		description: 'Import resolved to an ESM type declaration file, but a CommonJS JavaScript file.',
+		docsUrl: 'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseESM.md',
+	},
+	NamedExports: {
+		emoji: '🕵️',
+		title: 'Named exports cannot be detected by Node.ts',
+		shortDescription: 'Named exports',
+		description:
+			'TypeScript allows ESM named imports of the properties of this CommonJS module, but they will crash at runtime because they don’t exist or can’t be statically detected by Node.js in the JavaScript file.',
+		details: 'the list of exports TypeScript can see but Node.js cannot',
+		docsUrl: 'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NamedExports.md',
+	},
+	CJSResolvesToESM: {
+		emoji: '⚠️',
+		title: 'Entrypoint is ESM-only',
+		shortDescription: 'ESM (dynamic import only)',
+		description:
+			'A `require` call resolved to an ESM JavaScript file, which is an error in Node and some bundlers. CommonJS consumers will need to use a dynamic import.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSResolvesToESM.md',
+	},
+	FallbackCondition: {
+		emoji: '🐛',
+		title: 'Resolved through fallback condition',
+		shortDescription: 'Used fallback condition',
+		description:
+			'Import resolved to types through a conditional package.json export, but only after failing to resolve through an earlier condition. This behavior is a [TypeScript bug](https://github.com/microsoft/TypeScript/issues/50762). It may misrepresent the runtime behavior of this import and should not be relied upon.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FallbackCondition.md',
+	},
+	CJSOnlyExportsDefault: {
+		emoji: '🤨',
+		title: 'CJS module uses default export',
+		shortDescription: 'CJS default export',
+		description:
+			'CommonJS module simulates a default export with `exports.default` and `exports.__esModule`, but does not also set `module.exports` for compatibility with Node. Node, and [some bundlers under certain conditions](https://andrewbranch.github.io/interop-test/#synthesizing-default-exports-for-cjs-modules), do not respect the `__esModule` marker, so accessing the intended default export will require a `.default` property access on the default import.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSOnlyExportsDefault.md',
+	},
+	FalseExportDefault: {
+		emoji: '❗️',
+		title: 'Types incorrectly use default export',
+		shortDescription: 'Incorrect default export',
+		description:
+			'The resolved types use `export default` where the JavaScript file appears to use `module.exports =`. This will cause TypeScript under the `node16` module mode to think an extra `.default` property access is required, but that will likely fail at runtime. These types should use `export =` instead of `export default`.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseExportDefault.md',
+	},
+	MissingExportEquals: {
+		emoji: '❓',
+		title: 'Types are missing an `export =`',
+		shortDescription: 'Missing `export =`',
+		description:
+			'The JavaScript appears to set both `module.exports` and `module.exports.default` for improved compatibility, but the types only reflect the latter (by using `export default`). This will cause TypeScript under the `node16` module mode to think an extra `.default` property access is required, which will work at runtime but is not necessary. These types should `export =` an object with a `default` property instead of using `export default`.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/MissingExportEquals.md',
+	},
+	UnexpectedModuleSyntax: {
+		emoji: '🚭',
+		title: 'Syntax is incompatible with detected module kind',
+		shortDescription: 'Unexpected module syntax',
+		description:
+			'Syntax detected in the module is incompatible with the module kind according to the package.json or file extension. This is an error in Node and may cause problems in some bundlers.',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UnexpectedModuleSyntax.md',
+	},
+	InternalResolutionError: {
+		emoji: '🥴',
+		title: 'Internal resolution error',
+		shortDescription: 'Internal resolution error',
+		description:
+			'Import found in a type declaration file failed to resolve. Either this indicates that runtime resolution errors will occur, or (more likely) the types misrepresent the contents of the JavaScript files.',
+		details: 'the imports that failed to resolve',
+		docsUrl:
+			'https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/InternalResolutionError.md',
+	},
+};
+
+export const allProblemKinds = Object.keys(problemKindInfo) as ProblemKind[];
+
+export interface ProblemFilter {
+	kind?: readonly ProblemKind[];
+	entrypoint?: string;
+	resolutionKind?: ResolutionKind;
+	resolutionOption?: ResolutionOption;
+}
+
+export function filterProblems(analysis: Analysis, filter: ProblemFilter): Problem[];
+export function filterProblems(problems: readonly Problem[], analysis: Analysis, filter: ProblemFilter): Problem[];
+export function filterProblems(
+	...args:
+		| [analysis: Analysis, filter: ProblemFilter]
+		| [problems: readonly Problem[], analysis: Analysis, filter: ProblemFilter]
+) {
+	const [problems, analysis, filter] = args.length === 2 ? [args[0].problems, ...args] : args;
+	return problems.filter((p) => {
+		if (filter.kind && !filter.kind.includes(p.kind)) {
+			return false;
+		}
+		if (filter.entrypoint && filter.resolutionKind) {
+			return problemAffectsEntrypointResolution(p, filter.entrypoint, filter.resolutionKind, analysis);
+		}
+		if (filter.entrypoint && filter.resolutionOption) {
+			return getResolutionKinds(filter.resolutionOption).every((resolutionKind) =>
+				problemAffectsEntrypointResolution(p, filter.entrypoint!, resolutionKind, analysis)
+			);
+		}
+		if (filter.entrypoint) {
+			return problemAffectsEntrypoint(p, filter.entrypoint, analysis);
+		}
+		if (filter.resolutionKind) {
+			return problemAffectsResolutionKind(p, filter.resolutionKind, analysis);
+		}
+		return true;
+	});
+}
+
+export function problemAffectsResolutionKind(
+	problem: Problem,
+	resolutionKind: ResolutionKind,
+	analysis: Analysis,
+): boolean {
+	const index = getProblemIndex(analysis, problem);
+	for (const entrypoint of Object.values(analysis.entrypoints)) {
+		if (entrypoint.resolutions[resolutionKind].visibleProblems?.includes(index)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function problemAffectsEntrypoint(problem: Problem, entrypoint: string, analysis: Analysis): boolean {
+	const index = getProblemIndex(analysis, problem);
+	for (const resolution of Object.values(analysis.entrypoints[entrypoint]!.resolutions)) {
+		if (resolution.visibleProblems?.includes(index)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function problemAffectsEntrypointResolution(
+	problem: Problem,
+	entrypoint: string,
+	resolutionKind: ResolutionKind,
+	analysis: Analysis,
+): boolean {
+	const index = getProblemIndex(analysis, problem);
+	return analysis.entrypoints[entrypoint]!.resolutions[resolutionKind].visibleProblems?.includes(index) ?? false;
+}
+
+function getProblemIndex(analysis: Analysis, problem: Problem) {
+	let index = analysis.problems.indexOf(problem);
+	if (index === -1) {
+		const serialized = JSON.stringify(problem);
+		index = analysis.problems.findIndex((p) => JSON.stringify(p) === serialized);
+		if (index === -1) {
+			throw new Error(`Could not find problem in analysis`);
+		}
+	}
+	return index;
+}
diff --git a/attw-fork/src/run.ts b/attw-fork/src/run.ts
new file mode 100755
index 0000000000..a1510ef091
--- /dev/null
+++ b/attw-fork/src/run.ts
@@ -0,0 +1,100 @@
+import { readFile } from 'fs/promises';
+import { checkPackage } from './checkPackage.ts';
+import { getExitCode } from './cli/getExitCode.ts';
+import type { Format } from './cli/renderOptions.ts';
+import { typed } from './cli/typed.ts';
+import { untyped } from './cli/untyped.ts';
+import { write } from './cli/write.ts';
+import { createPackageFromTarballData } from './createPackage.ts';
+import type { ResolutionKind, UntypedResult } from './types.ts';
+
+try {
+	const path = process.argv[2];
+	const mode = process.argv[3];
+	const format = (process.env['ATTW_FORMAT'] as Format) || 'auto';
+	const modes: Record<ResolutionKind, boolean> | undefined = mode
+		? mode === 'node10'
+			? {
+				node10: true,
+				'node16-cjs': false,
+				'node16-esm': false,
+				bundler: false,
+			}
+			: mode === 'node16-esm'
+			? {
+				node10: false,
+				'node16-cjs': false,
+				'node16-esm': true,
+				bundler: false,
+			}
+			: mode === 'node16-cjs'
+			? {
+				node10: false,
+				'node16-cjs': true,
+				'node16-esm': false,
+				bundler: false,
+			}
+			: mode === 'bundler'
+			? {
+				node10: false,
+				'node16-cjs': false,
+				'node16-esm': false,
+				bundler: true,
+			}
+			: undefined
+		// no explicit mode: check node16-cjs/esm + bundler, but not legacy node10 resolution
+		: {
+			node10: false,
+			'node16-cjs': true,
+			'node16-esm': true,
+			bundler: true,
+		};
+
+	const ignoreResolutions = modes
+		? Object.entries(modes)
+			.filter(([, v]) => v === false)
+			.map(([k]) => k as ResolutionKind)
+		: undefined;
+
+	if (path === undefined) throw new Error('Missing target path');
+	if (modes === undefined && mode !== undefined) {
+		throw new Error(`Invalid mode: '${mode}'. Allowed modes: 'bundler' | 'node10' | 'node16-cjs' | 'node16-esm'.`);
+	}
+
+	const file = await readFile(path);
+	const data = new Uint8Array(file);
+	const pkg = createPackageFromTarballData(data);
+
+	const analysis = await checkPackage(pkg, {
+		modes,
+	});
+
+	console.log('Mode:', mode);
+	console.log('Ignore:', ignoreResolutions);
+
+	const out = process.stdout;
+	await write('', out);
+	if (analysis.types) {
+		await write(
+			await typed(analysis, {
+				ignoreResolutions,
+				format,
+			}),
+			out,
+		);
+		process.exitCode = getExitCode(analysis, {
+			ignoreResolutions,
+		});
+	} else {
+		await write(untyped(analysis as UntypedResult), out);
+	}
+} catch (error) {
+	console.error(error);
+	if (error && typeof error === 'object' && 'message' in error) {
+		console.error(`Error while checking package:\n${error.message}`);
+	} else {
+		console.error(`Unknown error while checking package:\n${error}`);
+	}
+
+	process.exit(3);
+}
diff --git a/attw-fork/src/types.ts b/attw-fork/src/types.ts
new file mode 100644
index 0000000000..79da5e7aa5
--- /dev/null
+++ b/attw-fork/src/types.ts
@@ -0,0 +1,188 @@
+import type ts from 'typescript';
+
+export type ResolutionKind = 'node10' | 'node16-cjs' | 'node16-esm' | 'bundler';
+export type ResolutionOption = 'node10' | 'node16' | 'bundler';
+export interface EntrypointInfo {
+	subpath: string;
+	resolutions: Record<ResolutionKind, EntrypointResolutionAnalysis>;
+	hasTypes: boolean;
+	isWildcard: boolean;
+}
+
+export interface IncludedTypes {
+	kind: 'included';
+}
+export interface TypesPackage {
+	kind: '@types';
+	packageName: string;
+	packageVersion: string;
+	definitelyTypedUrl?: string;
+}
+export type AnalysisTypes = IncludedTypes | TypesPackage;
+
+export type BuildTool =
+	| '@arethetypeswrong/cli'
+	| 'typescript'
+	| 'rollup'
+	| '@rollup/plugin-typescript'
+	| '@rollup/plugin-typescript2'
+	| 'webpack'
+	| 'esbuild'
+	| 'parcel-bundler'
+	| '@preconstruct/cli'
+	| 'vite'
+	| 'snowpack'
+	| 'microbundle'
+	| '@microsoft/api-extractor'
+	| 'tshy'
+	| '@rspack/cli'
+	| 'tsup'
+	| 'tsdown';
+
+export interface Analysis {
+	packageName: string;
+	packageVersion: string;
+	buildTools: Partial<Record<BuildTool, string>>;
+	types: AnalysisTypes;
+	entrypoints: Record<string, EntrypointInfo>;
+	programInfo: Record<ResolutionOption, ProgramInfo>;
+	problems: Problem[];
+}
+
+export interface UntypedResult {
+	packageName: string;
+	packageVersion: string;
+	types: false;
+}
+
+export type CheckResult = Analysis | UntypedResult;
+
+export interface EntrypointResolutionAnalysis {
+	name: string;
+	resolutionKind: ResolutionKind;
+	isWildcard?: boolean;
+	resolution?: Resolution;
+	implementationResolution?: Resolution;
+	files?: string[];
+	/** Indices into `analysis.problems` */
+	visibleProblems?: number[];
+}
+
+export interface Resolution {
+	fileName: string;
+	isTypeScript: boolean;
+	isJson: boolean;
+	trace: string[];
+}
+
+export interface ProgramInfo {
+	moduleKinds?: Record<string, ModuleKind>;
+}
+
+export type ModuleKindReason = 'extension' | 'type' | 'no:type';
+export interface ModuleKind {
+	detectedKind: ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS;
+	detectedReason: ModuleKindReason;
+	reasonFileName: string;
+}
+
+export interface EntrypointResolutionProblem {
+	entrypoint: string;
+	resolutionKind: ResolutionKind;
+}
+
+export interface FilePairProblem {
+	typesFileName: string;
+	implementationFileName: string;
+}
+
+export interface ModuleKindPairProblem {
+	typesModuleKind: ModuleKind;
+	implementationModuleKind: ModuleKind;
+}
+
+export interface FileTextRangeProblem {
+	fileName: string;
+	pos: number;
+	end: number;
+}
+
+export interface NoResolutionProblem extends EntrypointResolutionProblem {
+	kind: 'NoResolution';
+}
+
+export interface UntypedResolutionProblem extends EntrypointResolutionProblem {
+	kind: 'UntypedResolution';
+}
+
+export interface FalseESMProblem extends FilePairProblem, ModuleKindPairProblem {
+	kind: 'FalseESM';
+}
+
+export interface FalseCJSProblem extends FilePairProblem, ModuleKindPairProblem {
+	kind: 'FalseCJS';
+}
+
+export interface CJSResolvesToESMProblem extends EntrypointResolutionProblem {
+	kind: 'CJSResolvesToESM';
+}
+
+export interface NamedExportsProblem extends FilePairProblem {
+	kind: 'NamedExports';
+	isMissingAllNamed: boolean;
+	missing: string[];
+}
+
+export interface FallbackConditionProblem extends EntrypointResolutionProblem {
+	kind: 'FallbackCondition';
+}
+
+export interface FalseExportDefaultProblem extends FilePairProblem {
+	kind: 'FalseExportDefault';
+}
+
+export interface MissingExportEqualsProblem extends FilePairProblem {
+	kind: 'MissingExportEquals';
+}
+
+export interface InternalResolutionErrorProblem extends FileTextRangeProblem {
+	kind: 'InternalResolutionError';
+	resolutionOption: ResolutionOption;
+	moduleSpecifier: string;
+	resolutionMode: ts.ResolutionMode;
+	trace: string[];
+}
+
+export interface UnexpectedModuleSyntaxProblem extends FileTextRangeProblem {
+	kind: 'UnexpectedModuleSyntax';
+	syntax: ts.ModuleKind.ESNext | ts.ModuleKind.CommonJS;
+	moduleKind: ModuleKind;
+}
+
+export interface CJSOnlyExportsDefaultProblem extends FileTextRangeProblem {
+	kind: 'CJSOnlyExportsDefault';
+}
+
+export type Problem =
+	| NoResolutionProblem
+	| UntypedResolutionProblem
+	| FalseESMProblem
+	| FalseCJSProblem
+	| CJSResolvesToESMProblem
+	| NamedExportsProblem
+	| FallbackConditionProblem
+	| FalseExportDefaultProblem
+	| MissingExportEqualsProblem
+	| InternalResolutionErrorProblem
+	| UnexpectedModuleSyntaxProblem
+	| CJSOnlyExportsDefaultProblem;
+
+export type ProblemKind = Problem['kind'];
+
+export type Failable<T> = { status: 'error'; error: string; data?: never } | { status: 'success'; data: T };
+
+export interface ParsedPackageSpec {
+	name: string;
+	versionKind: 'none' | 'exact' | 'range' | 'tag';
+	version: string;
+}
diff --git a/attw-fork/src/utils.ts b/attw-fork/src/utils.ts
new file mode 100644
index 0000000000..40a2db0945
--- /dev/null
+++ b/attw-fork/src/utils.ts
@@ -0,0 +1,182 @@
+import { valid, validRange } from 'semver';
+import validatePackgeName from 'validate-npm-package-name';
+import type {
+	BuildTool,
+	EntrypointInfo,
+	EntrypointResolutionAnalysis,
+	Failable,
+	ParsedPackageSpec,
+	Problem,
+	ProblemKind,
+	ResolutionKind,
+	ResolutionOption,
+} from './types.ts';
+
+export const allResolutionOptions: ResolutionOption[] = ['node10', 'node16', 'bundler'];
+export const allResolutionKinds: ResolutionKind[] = ['node10', 'node16-cjs', 'node16-esm', 'bundler'];
+
+export function getResolutionOption(resolutionKind: ResolutionKind): ResolutionOption {
+	switch (resolutionKind) {
+		case 'node10': {
+			return 'node10';
+		}
+		case 'node16-cjs':
+		case 'node16-esm': {
+			return 'node16';
+		}
+		case 'bundler': {
+			return 'bundler';
+		}
+	}
+}
+
+export function getResolutionKinds(resolutionOption: ResolutionOption): ResolutionKind[] {
+	switch (resolutionOption) {
+		case 'node10': {
+			return ['node10'];
+		}
+		case 'node16': {
+			return ['node16-cjs', 'node16-esm'];
+		}
+		case 'bundler': {
+			return ['bundler'];
+		}
+	}
+}
+
+export function isDefined<T>(value: T | undefined): value is T {
+	return value !== undefined;
+}
+
+export function resolvedThroughFallback(traces: string[]) {
+	let i = 0;
+	while (i < traces.length) {
+		i = traces.indexOf('Entering conditional exports.', i);
+		if (i === -1) {
+			return false;
+		}
+		if (conditionalExportsResolvedThroughFallback()) {
+			return true;
+		}
+	}
+
+	function conditionalExportsResolvedThroughFallback(): boolean {
+		i++;
+		let seenFailure = false;
+		for (; i < traces.length; i++) {
+			if (traces[i]!.startsWith("Failed to resolve under condition '")) {
+				seenFailure = true;
+			} else if (seenFailure && traces[i]!.startsWith("Resolved under condition '")) {
+				return true;
+			} else if (traces[i] === 'Entering conditional exports.') {
+				if (conditionalExportsResolvedThroughFallback()) {
+					return true;
+				}
+			} else if (traces[i] === 'Exiting conditional exports.') {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	return;
+}
+
+export function visitResolutions(
+	entrypoints: Record<string, EntrypointInfo>,
+	visitor: (analysis: EntrypointResolutionAnalysis, info: EntrypointInfo) => unknown,
+) {
+	for (const entrypoint of Object.values(entrypoints)) {
+		for (const resolution of Object.values(entrypoint.resolutions)) {
+			if (visitor(resolution, entrypoint)) {
+				return;
+			}
+		}
+	}
+}
+
+export function groupProblemsByKind<K extends ProblemKind>(
+	problems: (Problem & { kind: K })[],
+): Partial<Record<K, (Problem & { kind: K })[]>> {
+	const result: Partial<Record<K, (Problem & { kind: K })[]>> = {};
+	for (const problem of problems) {
+		(result[problem.kind] ??= []).push(problem);
+	}
+	return result;
+}
+
+export function parsePackageSpec(input: string): Failable<ParsedPackageSpec> {
+	let name;
+	let version;
+	let i = 0;
+	if (input.startsWith('@')) {
+		i = input.indexOf('/');
+		if (i === -1 || i === 1) {
+			return {
+				status: 'error',
+				error: 'Invalid package name',
+			};
+		}
+		i++;
+	}
+	i = input.indexOf('@', i);
+	if (i === -1) {
+		name = input;
+	} else {
+		name = input.slice(0, i);
+		version = input.slice(i + 1);
+	}
+
+	if (validatePackgeName(name).errors) {
+		return {
+			status: 'error',
+			error: 'Invalid package name',
+		};
+	}
+	if (!version) {
+		return {
+			status: 'success',
+			data: { versionKind: 'none', name, version: '' },
+		};
+	}
+	if (valid(version)) {
+		return {
+			status: 'success',
+			data: { versionKind: 'exact', name, version },
+		};
+	}
+	if (validRange(version)) {
+		return {
+			status: 'success',
+			data: { versionKind: 'range', name, version },
+		};
+	}
+	return {
+		status: 'success',
+		data: { versionKind: 'tag', name, version },
+	};
+}
+
+export const allBuildTools = Object.keys(
+	{
+		'@arethetypeswrong/cli': true,
+		typescript: true,
+		rollup: true,
+		'@rollup/plugin-typescript': true,
+		'@rollup/plugin-typescript2': true,
+		webpack: true,
+		esbuild: true,
+		'parcel-bundler': true,
+		'@preconstruct/cli': true,
+		vite: true,
+		snowpack: true,
+		microbundle: true,
+		'@microsoft/api-extractor': true,
+		tshy: true,
+		'@rspack/cli': true,
+		tsup: true,
+		tsdown: true,
+	} satisfies Record<BuildTool, any>,
+) as BuildTool[];
+
+export { type ParsedPackageSpec } from './types.ts';
diff --git a/attw-fork/src/versions.ts b/attw-fork/src/versions.ts
new file mode 100644
index 0000000000..274273963a
--- /dev/null
+++ b/attw-fork/src/versions.ts
@@ -0,0 +1,13 @@
+import ts from 'typescript';
+
+// @ts-ignore
+// This file is only accessible from Node, but the rest of the package
+// needs to run in the browser, so we don't have @types/node installed.
+import { createRequire } from 'module';
+
+const packageJson = createRequire(import.meta.url)('../package.json');
+
+export const versions = {
+	core: packageJson.version,
+	typescript: ts.version,
+};
diff --git a/attw-fork/tsconfig.json b/attw-fork/tsconfig.json
new file mode 100644
index 0000000000..02a2e75906
--- /dev/null
+++ b/attw-fork/tsconfig.json
@@ -0,0 +1,16 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"allowImportingTsExtensions": true,
+		"paths": {
+			"~/*": ["src/*"]
+		},
+		"lib": ["WebWorker", "ESNext"],
+		"declaration": true,
+		"outDir": "dist",
+		"noEmit": true,
+		"types": ["ts-expose-internals", "node"]
+	},
+	"include": ["src"]
+}
diff --git a/changelogs/drizzle-kit/0.30.1.md b/changelogs/drizzle-kit/0.30.1.md
index 1b671312da..bcbb9697f1 100644
--- a/changelogs/drizzle-kit/0.30.1.md
+++ b/changelogs/drizzle-kit/0.30.1.md
@@ -22,9 +22,9 @@ npx drizzle-kit export
 will output this string to console
 ```bash
 CREATE TABLE "users" (
-        "id" serial PRIMARY KEY NOT NULL,
-        "email" text NOT NULL,
-        "name" text
+  "id" serial PRIMARY KEY NOT NULL,
+  "email" text NOT NULL,
+  "name" text
 );
 ```
 
diff --git a/changelogs/drizzle-kit/0.31.2.md b/changelogs/drizzle-kit/0.31.2.md
new file mode 100644
index 0000000000..3eab8ad70b
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.2.md
@@ -0,0 +1,3 @@
+### Bug fixes
+
+- Fixed relations extraction to not interfere with Drizzle Studio.
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.3.md b/changelogs/drizzle-kit/0.31.3.md
new file mode 100644
index 0000000000..d7752d74c8
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.3.md
@@ -0,0 +1 @@
+- Internal changes to Studio context. Added `databaseName` and `packageName` properties for Studio
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.4.md b/changelogs/drizzle-kit/0.31.4.md
new file mode 100644
index 0000000000..be0111db46
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.4.md
@@ -0,0 +1 @@
+- Fixed `halfvec`, `bit` and `sparsevec` type generation bug in drizzle-kit
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.5.md b/changelogs/drizzle-kit/0.31.5.md
new file mode 100644
index 0000000000..0a2f29b6ae
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.5.md
@@ -0,0 +1 @@
+- Add casing support to studio configuration and related functions
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.6.md b/changelogs/drizzle-kit/0.31.6.md
new file mode 100644
index 0000000000..c1ee0a6f80
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.6.md
@@ -0,0 +1,3 @@
+### Bug fixes
+
+- [[BUG]: Importing drizzle-kit/api fails in ESM modules](https://github.com/drizzle-team/drizzle-orm/issues/2853)
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.7.md b/changelogs/drizzle-kit/0.31.7.md
new file mode 100644
index 0000000000..0b384f8370
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.7.md
@@ -0,0 +1,3 @@
+### Bug fixes
+
+- [[BUG]: Drizzle Kit push to Postgres 18 produces unecessary DROP SQL when the schema was NOT changed](https://github.com/drizzle-team/drizzle-orm/issues/4944)
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/0.31.8.md b/changelogs/drizzle-kit/0.31.8.md
new file mode 100644
index 0000000000..3acc55fbeb
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.8.md
@@ -0,0 +1,4 @@
+### Bug fixes
+
+- Fixed `algorythm` => `algorithm` typo.
+- Fixed external dependencies in build configuration.
diff --git a/changelogs/drizzle-kit/0.31.9.md b/changelogs/drizzle-kit/0.31.9.md
new file mode 100644
index 0000000000..3bdb169da8
--- /dev/null
+++ b/changelogs/drizzle-kit/0.31.9.md
@@ -0,0 +1 @@
+- drizzle-kit api improvements for D1 connections
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.1.md b/changelogs/drizzle-kit/1.0.0-beta.1.md
new file mode 100644
index 0000000000..70b94f8687
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.1.md
@@ -0,0 +1 @@
+- Updated `drizzle-kit pull` command to pull new Relations v2 schema from database
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.10.md b/changelogs/drizzle-kit/1.0.0-beta.10.md
new file mode 100644
index 0000000000..f14df7cef6
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.10.md
@@ -0,0 +1,3 @@
+## Bug fixes
+
+- Fixed usage of `pg` dialect functions while using `bun-sql` with `sqlite`, `mysql` dialects  
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.11.md b/changelogs/drizzle-kit/1.0.0-beta.11.md
new file mode 100644
index 0000000000..f8ec69e1e3
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.11.md
@@ -0,0 +1,18 @@
+## Bug fixes
+
+- [[BUG]:drizzle-kit pull generates incorrect schema for functional/computed index](https://github.com/drizzle-team/drizzle-orm/issues/5224)
+- [[BUG]: drizzle-kit pull generates invalid code for MySQL datetime with DEFAULT CURRENT_TIMESTAMP ON UPDATE](https://github.com/drizzle-team/drizzle-orm/issues/5212)
+- [[BUG]: Drizzle-kit - push tries to delete non-public schemas by default (pscale_extensions)](https://github.com/drizzle-team/drizzle-orm/issues/5190)
+- [[BUG]: JSON.stringify cannot serialize BigInt](https://github.com/drizzle-team/drizzle-orm/issues/5227)
+
+- Commutativity for `MySQL` `now(N)` and `CURRENT_TIMESTAMP(N)`
+
+**MySQL pull command**:
+- Creation of a primary key when a column had only `UNIQUE` and `NOT NULL`
+- `varbinary()` config was ignored in a ts schema file
+- Foreign key column duplication when constraint names matched across multiple databases
+- Inconsistent casing between `schema.ts` and `relations.ts`
+- Cyclic references are generated as inline `.references((): AnyMySqlColumn => ...)` to avoid type errors for single-column references
+
+**Common**:
+- Relation name collisions with column names during introspection. If a relation name collides with a column name - the relation is renamed to `<name>Relation`
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.12.md b/changelogs/drizzle-kit/1.0.0-beta.12.md
new file mode 100644
index 0000000000..70265c35cb
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.12.md
@@ -0,0 +1,23 @@
+## Bug fixes
+
+- [[BUG]: drizzle-kit generate silently exits with code 1](https://github.com/drizzle-team/drizzle-orm/issues/5263)
+- [[BUG]:Unable to resolve module node:crypto](https://github.com/drizzle-team/drizzle-orm/issues/5183)
+- [[BUG]: The package at "node_modules/.bun/drizzle-orm@1.0.0-beta.2-6565b14+35e4bda3077d71da/node_modules/drizzle-orm/migrator.js" attempted to import the Node standard library module "node:crypto". It failed because the native React runtime does not include the Node standard library.](https://github.com/drizzle-team/drizzle-orm/issues/5126)
+- [[BUG]: Problem with backslash in check constraint](https://github.com/drizzle-team/drizzle-orm/issues/4655)
+- [[BUG]: drizzle-kit up throws error "Cannot convert undefined or null to object"](https://github.com/drizzle-team/drizzle-orm/issues/5099)
+
+Postgresql dialect now have extra schema errors in ts files on `generate` and `push` commands:
+- `table_name_duplicate` - duplicate table name across schema
+- `column_name_duplicate` - duplicate column name across table
+- `enum_name_duplicate` - duplicate enum name across schema
+- `enum_values_duplicate` - duplicate values inside enum
+- `privilege_duplicate` - duplicate privilege name
+- `role_duplicate` - duplicate role name
+- `schema_name_duplicate` - duplicate schema name
+
+SQLite dialect now have extra schema errors in ts files on `generate` and `push` commands:
+- `conflict_column` - duplicate column name across table
+- `conflict_fk` - duplicate fk name
+- `conflict_index` - duplicate index name
+- `conflict_pk` - duplicate pk name
+- `table_no_columns` - table has no columns
diff --git a/changelogs/drizzle-kit/1.0.0-beta.13.md b/changelogs/drizzle-kit/1.0.0-beta.13.md
new file mode 100644
index 0000000000..62ffd370fb
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.13.md
@@ -0,0 +1,3 @@
+- Enabled top-level await in `drizzle-kit.config` and schema files on Node.js by replacing `require()` with `async loadModule()` using `jiti`
+- Fixed [[FEATURE]: Support Top-level await in drizzle.config.ts](https://github.com/drizzle-team/drizzle-orm/issues/1982)
+- Fixed [[BUG]: SyntaxError: Cannot use import statement outside a module with drizzle-kit](https://github.com/drizzle-team/drizzle-orm/issues/819)
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.14.md b/changelogs/drizzle-kit/1.0.0-beta.14.md
new file mode 100644
index 0000000000..0ea2ddba44
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.14.md
@@ -0,0 +1,14 @@
+## Migrator update
+The migrator now applies all changes that are missing in the database. Previously the migrator only looked for local migrations with a creation date later than the last migration applied in the database
+Now it detects and applies all missing migrations
+
+- Fixed `generate` and `pull` commands to display the `SQL file` instead of the `folder` path in the migration output message
+> Your SQL migration ➜ <path>
+
+## Bug fixed
+
+- [[BUG]: Cache is not invalidated after table updates](https://github.com/drizzle-team/drizzle-orm/issues/4677)
+- [[BUG]: Composite index with sort outputs a malformed SQL](https://github.com/drizzle-team/drizzle-orm/issues/4704)
+- [[BUG]: db introspection generates broken schema.ts syntax](https://github.com/drizzle-team/drizzle-orm/issues/4582)
+- Postgres: `DROP INDEX` statement did not respect schema
+- [`random` property is set on `Array.prototype` with `enumerable: true`](https://github.com/drizzle-team/drizzle-orm/issues/4484)
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.16.md b/changelogs/drizzle-kit/1.0.0-beta.16.md
new file mode 100644
index 0000000000..62e3824f2e
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.16.md
@@ -0,0 +1,90 @@
+# Drizzle ORM beta.16 updates
+
+We've fixed a regression in migrations introduced in `beta.13` that persisted through `beta.15`, and used the opportunity to significantly improve the entire migration infrastructure going forward.
+
+After receiving github issue, we focused on not just fixing the symptoms but rethinking how migrations are tracked, validated, and applied. As we always do with Drizzle we went deeper and redesigned the underlying architecture so it can be stable for all future changes, additions, and edge cases
+
+We went through how we check migrations, how we store them, and how we help developers keep their migration flow reliable. After several iterations of rewriting the `migrate` function in both ORM and Kit, adding migration table versioning, and building a new commutativity check system: here's what changed and why.
+
+## What happened in beta.12–beta.15 and what caused the issue
+
+On `latest` (pre-beta) versions, the migrations folder used a journal-based structure. A `meta/_journal.json` file stored a timestamp for each migration in **milliseconds**. That same millis value was stored in the database's `created_at` column and used to determine which migrations had been applied. Because the journal enforced ordering, we could simply fetch the last applied migration from the database and apply everything after it.
+
+With the new v3 folder structure (introduced in beta), each migration lives in its own folder named `<YYYYMMDDHHmmss>_<name>`. This format only has **second** precision. The new structure also intentionally allows out-of-order migrations (as it should for team workflows), so we switched to reading *all* migrations from the database and comparing against all local migrations.
+
+The problem appeared after `drizzle-kit up` converted the old journal structure to v3 folders. It mapped millis timestamps to the `YYYYMMDDHHmmss_name` format, stripping away the millisecond precision. So when the new migration checker compared what was in the database (millis) to what was on disk (seconds), nothing matched causing migrations to be re-applied on every run.
+
+**This only affected beta users who upgraded from the journal-based format. Users on `latest` were not impacted.**
+
+## How we fixed it
+
+### 1. Versioned migration table
+
+We introduced an internal version number for the migrations table schema. On `beta.16`, the table will automatically upgrade itself from `version_0` to `version_1` the first time you run `migrate`.
+
+**Version 0** (old schema):
+| Column | Type |
+|---|---|
+| `id` | serial |
+| `hash` | text |
+| `created_at` | bigint (millis) |
+
+**Version 1** (new schema):
+| Column | Type | |
+|---|---| ---|
+| `id` | serial |
+| `hash` | text |
+| `created_at` | bigint | (legacy) |
+| `name` | text |
+| `applied_at` | timestamp |
+| `version` | integer |
+
+The `name` column stores the full folder name of the migration (e.g. `20250220153045_brave_wolverine`). The `applied_at` column records when the migration was actually executed. For pre-existing migrations that were backfilled during upgrade, `applied_at` is set to `NULL` to distinguish them from newly applied ones.
+
+This versioning system means we can add more fields in the future (like migration state for rollbacks) without any disruption for developers
+
+### 2. Matching by folder name instead of timestamps
+
+All migrations are now checked against the **full folder name**:  the combination of a 14-digit UTC timestamp and a name suffix (random or custom). Even if two migrations are generated within the same second, the name suffix guarantees uniqueness.
+
+The detection logic is simple: build a set of `name` values from the database, filter local migrations whose name isn't in that set, and apply those. No more timestamp arithmetic, no more precision mismatches.
+
+### 3. Automatic upgrade with smart backfilling
+
+When `beta.16` detects a `version_0` table, it adds the new columns and backfills the `name` for each existing row using a multi-step matching strategy:
+
+1. **Millis match**: truncate the stored millis to seconds and match against local migration folder timestamps
+2. **Hash tiebreaker**: if multiple migrations share the same second, use the SQL hash to pick the right one
+3. **Hash-only fallback**: if millis matching fails entirely, fall back to matching by hash alone
+
+This means the upgrade handles all edge cases: normal single-developer projects, teams with closely-timed migrations, and even cases where the old journal data doesn't perfectly align with the new folder names.
+
+### 4. New commutativity checks (`drizzle-kit check`)
+
+When working in teams, multiple developers may generate migrations from the same base schema on different branches. These migrations can conflict in non-obvious ways, for example, two branches both adding a column to the same table, or one renaming a table that another is altering.
+
+We built a new `drizzle-kit check` command that detects these non-commutative migrations. It works by:
+
+- Building a DAG (directed acyclic graph) from snapshot `prevIds` to understand the branch structure
+- Finding fork points where branches diverged
+- Computing the DDL diff from the parent snapshot to each branch leaf
+- Checking for conflicting operations using a comprehensive footprint map that knows which DDL statement types can interfere with each other
+
+This is available for PostgreSQL and MySQL today. If conflicts are found, the report tells you exactly which migrations on which branches are incompatible and what statements are conflicting.
+
+The new folder structure also changed snapshot metadata from `prevId: string` to `prevIds: string[]`, enabling proper DAG representation of migration history across branches.
+
+## Upgrading to beta.16
+
+The upgrade is automatic. When you run `migrate` for the first time on `beta.16`:
+
+1. Drizzle detects your migration table version
+2. If it's `version_0`, it adds the new columns and backfills `name` from your local migration files
+3. All future migrations are tracked by name
+4. No manual steps required
+
+If you're also upgrading your migration **folder structure** from the old journal format, run `drizzle-kit up` first to convert to the v3 folder layout, then `migrate` will handle the rest.
+
+## Upgrading to beta.16 is not fixing my problem
+
+If you're still hitting migration issues after upgrading, please reach out to us directly - drop a message in [Discord](https://discord.gg/7NKUQWP9c8) or open a [GitHub issue](https://github.com/drizzle-team/drizzle-orm/issues/new/choose) with your migration folder structure and the contents of your migrations table. We'll help you sort it out.
diff --git a/changelogs/drizzle-kit/1.0.0-beta.18.md b/changelogs/drizzle-kit/1.0.0-beta.18.md
new file mode 100644
index 0000000000..4432f75d37
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.18.md
@@ -0,0 +1,10 @@
+## New driver support for `kit` and `studio`
+
+You can now use the `node:sqlite` driver to run migrations and browse Drizzle Studio. If `node:sqlite` is available at runtime, we will automatically detect it and use it.
+
+## Fixes 
+
+- resolved tsconfig path aliases in drizzle-kit loader using get-tsconfig + jiti alias mapping
+- added fixtures and tests covering wildcard and non-wildcard path aliases
+- ensured schema load succeeds for alias imports
+- Updated to `hanji@0.0.8` - native bun `stringWidth`, `stripANSI` support, errors for non-TTY environments  
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.19.md b/changelogs/drizzle-kit/1.0.0-beta.19.md
new file mode 100644
index 0000000000..95a5d969b1
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.19.md
@@ -0,0 +1,16 @@
+## Bug fixed
+
+- [[BUG]: drizzle-kit push attempts to drop policies in excluded schemas (e.g. cron) despite schemaFilter: ["public"]](https://github.com/drizzle-team/drizzle-orm/issues/5329)
+- [[BUG]: error attempting to drizzle-kit migrate table with char array field generated using drizzle-kit generate](https://github.com/drizzle-team/drizzle-orm/issues/5370)
+- [[BUG]: Ignore Vim *.swp files in drizzle-kit generate](https://github.com/drizzle-team/drizzle-orm/issues/4906)
+- [[BUG]: drizzle-kit pull outputs access method name instead of operator class for ivfflat indexes](https://github.com/drizzle-team/drizzle-orm/issues/5495)
+- [[BUG]: drizzle-kit pull generates not enough data provided to build the relation](https://github.com/drizzle-team/drizzle-orm/issues/5493)
+- [drizzle-kit push fails with Turso/libSQL on table recreation: "cannot commit - no transaction is active"](https://github.com/drizzle-team/drizzle-orm/issues/5489)
+- [[BUG]: Cannot read properties of undefined (reading 'requestLayout') when running drizzle-kit introspect (MySQL)](https://github.com/drizzle-team/drizzle-orm/issues/5488)
+- [[BUG (beta)]: RDS Data API pulling schema error](https://github.com/drizzle-team/drizzle-orm/issues/5308)
+- [[BUG]: drizzle-kit commutative migrations takes only last leaf migration into account](https://github.com/drizzle-team/drizzle-orm/issues/5504)
+
+## Updates
+The behavior for reading schema files has been updated. From now only files with the following extensions will be processed: `.js` `.mjs` `.cjs` `.jsx` `.ts` `.mts` `.cts` `.tsx`
+All other file types will be ignored
+
diff --git a/changelogs/drizzle-kit/1.0.0-beta.21.md b/changelogs/drizzle-kit/1.0.0-beta.21.md
new file mode 100644
index 0000000000..6881326f40
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.21.md
@@ -0,0 +1,4 @@
+More fixes for the drizzle-kit migration process and commutativity checks
+
+- Adding a value to a PostgreSQL enum will no longer be treated as commutative
+- Enum values added in different leaves will now be merged properly
diff --git a/changelogs/drizzle-kit/1.0.0-beta.22.md b/changelogs/drizzle-kit/1.0.0-beta.22.md
new file mode 100644
index 0000000000..7379c969c1
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.22.md
@@ -0,0 +1,14 @@
+## Bug fixed
+
+- [drizzle-kit generate fails to generate correct migrations.js file on Windows](https://github.com/drizzle-team/drizzle-orm/issues/5514)
+- [[BUG]: MSSQL real() column returns imprecise float64 values -- missing mapFromDriverValue](https://github.com/drizzle-team/drizzle-orm/issues/5527)
+- [Object key collision](https://github.com/drizzle-team/drizzle-orm/issues/5525)
+- [[BUG]:beta20 Migration to Cloudflare D1 fails](https://github.com/drizzle-team/drizzle-orm/issues/5602)
+- [[BUG]: drizzle-kit migrate: migration SQL failures exit with code 1 but print no error (MigrateProgress hides rejection)](https://github.com/drizzle-team/drizzle-orm/issues/5601)
+- [[BUG]: MS SQL Filtered Index - Drizzle Kit incorrectly generates fully qualified column name in WHERE clause](https://github.com/drizzle-team/drizzle-orm/issues/5593)
+- [[BUG]: [Drizzle-kit][Pg] Altering a UNIQUE constraint: generated SQL ignores the new changes](https://github.com/drizzle-team/drizzle-orm/issues/5585)
+- [[BUG]: Non-commutative migration false positive: create_index commutativity check ignores table name](https://github.com/drizzle-team/drizzle-orm/issues/5639)
+
+- Commutativity checks were updated for PostgreSQL and MySQL. Before, `create_index` statements could be reported as non-commutative even when they targeted different tables, and `--ignore-conflicts` could still collapse multi-parent history down to a single parent. Now index/table/schema footprints are resolved more accurately, unrelated index branches are accepted, and `--ignore-conflicts` preserves all open leaf parents for the next migration
+
+- fix: mark mssql and @types/mssql as optional peer dependencies
diff --git a/changelogs/drizzle-kit/1.0.0-beta.3.md b/changelogs/drizzle-kit/1.0.0-beta.3.md
new file mode 100644
index 0000000000..afe8f8153f
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.3.md
@@ -0,0 +1,18 @@
+## Breaking changes (for MSSQL users)
+
+The MSSQL snapshot has been upgraded to version 2. When you generate the next migration Drizzle Kit will ask you to update your current snapshot to version 2 if you have not done it already
+
+"indexes.columns" field was updated in snapshot
+
+This change allows to proper handle sql`` values inside index().on(<HERE>)
+
+## Bug fixes
+
+- [[BUG]: truncated tables on ALTER COLUMN statements](https://github.com/drizzle-team/drizzle-orm/issues/4245)
+- [[BUG]: Drizzle generates incorrect SQL migration for policy permission string changes](https://github.com/drizzle-team/drizzle-orm/issues/4198)
+- [[BUG]: Introspect PG _text type not recognized as an array](https://github.com/drizzle-team/drizzle-orm/issues/4215)
+- [[BUG]: drizzle-kit pull fails if db includes views which are not in "tablesFilter"](https://github.com/drizzle-team/drizzle-orm/issues/4170)
+- [[BUG]: AnySQLiteColumn in generated schema is not prefixed by "type" keyword](https://github.com/drizzle-team/drizzle-orm/issues/4247)
+- [[BUG]: drizzle-kit generate fails with "undefined" is not valid JSON](https://github.com/drizzle-team/drizzle-orm/issues/3255)
+- [[BUG]: Primary key migration fails when changing from one column to another](https://github.com/drizzle-team/drizzle-orm/issues/3496)
+- [[BUG]: Operator precedence of = and IS NULL is disrespected when using eq and isNull](https://github.com/drizzle-team/drizzle-orm/issues/4878)
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.4.md b/changelogs/drizzle-kit/1.0.0-beta.4.md
new file mode 100644
index 0000000000..fa46ebedee
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.4.md
@@ -0,0 +1,8 @@
+Regression issues fixed(from `-beta.x` releases)
+
+- [[BUG]: migrations.sort in migrator.js does nothing - migrations run in wrong order on Linux](https://github.com/drizzle-team/drizzle-orm/issues/5123)
+- [[BUG]: drizzle-kit generate not working without error](https://github.com/drizzle-team/drizzle-orm/issues/5124)
+
+Issues fixed(from latest tag)
+
+- [[BUG]: drizzle-kit check wrongly tries to use AWS Data API](https://github.com/drizzle-team/drizzle-orm/issues/4775)
diff --git a/changelogs/drizzle-kit/1.0.0-beta.5.md b/changelogs/drizzle-kit/1.0.0-beta.5.md
new file mode 100644
index 0000000000..c6df01895a
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.5.md
@@ -0,0 +1,80 @@
+## Bug fixes
+
+- [[BUG]: error: type "serial" does not exist](https://github.com/drizzle-team/drizzle-orm/issues/2183)
+- [[BUG]: jsonb default with boolean literals gets generated truen instead of true](https://github.com/drizzle-team/drizzle-orm/issues/5149)
+- [[BUG]: MSSQL view incorrect syntax](https://github.com/drizzle-team/drizzle-orm/issues/5113)
+- Fixed `blob` columns in MySQL to work properly with RQB mapper
+
+## Changes to SQLite `drizzle-kit up` command
+
+> Important!
+>
+> If you were already using SQLite in any `beta.x` version and have used the `drizzle-kit up` command, you will not receive the latest `up` changes from this release. If you are unable to reset migrations and start from scratch, you will need to contact us for support with upgrading
+
+### What was changed?
+
+#### Handling of UNIQUE constraints in SQLite
+
+In the new version `drizzle-kit` handles `UNIQUE` constraints. This decision was made because when a unique constraint is created it cannot be removed, whereas an index can be dropped
+
+Previous version of Drizzle-Kit always created `.unique()` as a `uniqueIndex` and stored it in the snapshot that way. Because of this during an up we lack of sufficient information and if a user used `.unique()` an upped will generate a diff on generate and push
+
+**Solution:**
+
+We are replacing all unique constraints with `uniqueIndex`
+
+`uniqueIndex` requires a name and the name must follow this format:
+
+`<table>_<column1>*_*<column2>_..._unique`
+
+#### Foreign key name handling in the old(pre 1.0) drizzle-kit
+
+The old `drizzle-kit` did not handle foreign key names when generated sql migrations. A foreign key name could be defined in the ts schema, but it was not passed through when generating sql
+
+```tsx
+export const table = sqliteTable("table", {
+    column1: integer(),
+    column2: integer()},
+  (t) => [
+    foreignKey({
+      name: "name",
+      columns: [t.column1],
+      foreignColumns: [t.column2],
+    }),
+  ]
+);
+
+// no name provided
+FOREIGN KEY (`timest`) REFERENCES `b`(`timest1`) ON UPDATE no action ON DELETE no action
+```
+
+On `introspect` new drizzle-kit parses ddl to find constraint name, if no name found - use default name
+
+After running `drizzle-kit up` the first `push` command will result in a diff that recreates the table (no name from db, but there is name in ts schema). To avoid this foreign key names should be removed - in that case no diff will be generated.
+
+`drizzle-kit generate` command will behave as expected, no changes needed.
+
+#### Bug in the old drizzle-kit related to foreign keys
+
+If you add a column to an existing table that has a foreign key and specify `onDelete` or `onUpdate`, column will be added with the foreign key, but without those parameters
+
+```tsx
+export const table = sqliteTable("table", {
+	column1: integer()
+});
+
+export const table = sqliteTable("table", {
+	column1: integer(),
+	column2: integer().references((): AnySQLiteColumn => table.column1, 
+		{
+			onDelete: "set null", 
+			onUpdate: "set default"
+		})
+});
+
+ALTER TABLE `table` ADD `column2` integer REFERENCES table(column1);
+```
+
+There is no way to fix this in the old snapshot. It led to table recreation during subsequent `push` operations (in the pre-v1.0 drizzle-kit version)
+
+New `drizzle-kit` will recreate table after push command with the correct SQL. When using `generate` command, no diffs will appear, but the actual database state may differ
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.6.md b/changelogs/drizzle-kit/1.0.0-beta.6.md
new file mode 100644
index 0000000000..ce4caf1e54
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.6.md
@@ -0,0 +1,11 @@
+## Bug fixes
+
+- [[BUG]: 1.0.0-beta.2 - drizzle-kit push does consider json (jsonb) key order relevant](https://github.com/drizzle-team/drizzle-orm/issues/5119)
+- [[BUG]: drizzle-kit pull generates string instead of sql statement for default value](https://github.com/drizzle-team/drizzle-orm/issues/5093)
+- [[BUG]: Failed schema with d1 table](https://github.com/drizzle-team/drizzle-orm/issues/3590)
+
+- [[BUG]: drizzle-kit: push runs already applied migration](https://github.com/drizzle-team/drizzle-orm/issues/3844)
+and related
+- [[BUG]: Drizzle-Kit detects change when Composite Primary Key Columns are in different order than in schema definition]https://github.com/drizzle-team/drizzle-orm/issues/3103
+
+- [[BUG]: drizzle-kit push always shows columns with custom types as changed even tho the type didn't change](https://github.com/drizzle-team/drizzle-orm/issues/3047);
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.7.md b/changelogs/drizzle-kit/1.0.0-beta.7.md
new file mode 100644
index 0000000000..6b73aca816
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.7.md
@@ -0,0 +1,38 @@
+## Bug fixes
+
+- https://github.com/drizzle-team/drizzle-orm/issues/5143
+- [[BUG]: drizzle-kit push removes migration table (doesn't recognize custom migration table name)](https://github.com/drizzle-team/drizzle-orm/issues/5083)
+- [[BUG]:Drizzle pull generate invalid autosummarize](https://github.com/drizzle-team/drizzle-orm/issues/5196)
+- [[BUG]: drizzle-kit pull generated wrong syntax](https://github.com/drizzle-team/drizzle-orm/issues/5193)
+- [[BUG]: [drizzle-kit] MSSQL - Foreign Key Constraints Generated via drizzle-kit generate are not scoped to the Correct Schema](https://github.com/drizzle-team/drizzle-orm/issues/5182)
+
+- **Push** command now respects a custom migration schema or/and table from ***drizzle.config*** and ignores them during the execution
+
+## Breaking changes
+
+### The `migrations`.`prefix` field was removed from `drizzle-kit` config
+The following syntax is now deprecated:
+```ts
+migrations: {
+    prefix: 'index'
+}
+```
+You can no longer use it to define your `drizzle.config.ts` file like this:
+```ts {11-13}
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: "postgres://postgres:postgres@localhost:5432/postgres",
+  },
+  // ❌ deprecated, will be removed
+  migrations: {
+    prefix: 'index'
+  }
+});
+```
+There is no alternatives for `prefix` at the moment.
+We will consider adding one in the future for compatibility with some providers.
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-beta.9.md b/changelogs/drizzle-kit/1.0.0-beta.9.md
new file mode 100644
index 0000000000..cffc87ec0e
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-beta.9.md
@@ -0,0 +1,2 @@
+- We've migrated away from `esbuild-register` to `tsx` loader, it will now allow to use drizzle-kit seamlessly with both ESM and CJS modules  
+- We've also added native Bun and Deno launch support, which will not trigger tsx loader and utilise native bun and deno imports capabilities and faster startup times
\ No newline at end of file
diff --git a/changelogs/drizzle-kit/1.0.0-rc.2.md b/changelogs/drizzle-kit/1.0.0-rc.2.md
new file mode 100644
index 0000000000..925d56714c
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-rc.2.md
@@ -0,0 +1,25 @@
+### Migration updates in SQLite
+
+- Added migration conflict detection for SQLite. When migration history has multiple open branches, `drizzle-kit generate` now checks whether those branches can be merged safely before creating the next migration. This helps catch cases where two migrations were created from the same parent and then changed the same SQLite object in incompatible ways, for example two branches changing the same table, index, or view.
+
+```bash
+npx drizzle-kit generate
+```
+
+- If the conflict is expected and you want to continue anyway, pass `--ignore-conflicts` to skip the conflict check for that command.
+
+```bash
+npx drizzle-kit generate --ignore-conflicts
+npx drizzle-kit check --ignore-conflicts
+```
+
+- Added proper SQLite migration tree merging. New snapshots now collect all open leaf snapshot IDs and write them as parents, instead of keeping only one latest parent. This means a new migration generated after branching can merge all open leaves and use the combined SQLite state for the next snapshot diff.
+
+```json
+{
+  "prevIds": ["first-open-leaf-id", "second-open-leaf-id"]
+}
+```
+
+- Fixed `DrizzleQueryError` and `TransactionRollbackError` constructors to properly set the error name for better instanceof checks
+- Fixed error handling in aws-data-api to properly show database error messages
diff --git a/changelogs/drizzle-kit/1.0.0-rc.4.md b/changelogs/drizzle-kit/1.0.0-rc.4.md
new file mode 100644
index 0000000000..cc59ae760f
--- /dev/null
+++ b/changelogs/drizzle-kit/1.0.0-rc.4.md
@@ -0,0 +1,6 @@
+# v1.0.0-rc.4
+
+- Fixed postgres pull from failing for non-admin roles (fixes [#5568](https://github.com/drizzle-team/drizzle-orm/issues/5568))
+
+- Fixed: [[BUG]: [mssql] INSERT includes generatedAlwaysAs (computed) columns in the column list — SQL Server error 271
+](https://github.com/drizzle-team/drizzle-orm/issues/5881)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.44.2.md b/changelogs/drizzle-orm/0.44.2.md
new file mode 100644
index 0000000000..87b80f612b
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.2.md
@@ -0,0 +1 @@
+- [BUG]: Fixed type issues with joins with certain variations of `tsconfig`: [#4535](https://github.com/drizzle-team/drizzle-orm/issues/4535), [#4457](https://github.com/drizzle-team/drizzle-orm/issues/4457)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.44.3.md b/changelogs/drizzle-orm/0.44.3.md
new file mode 100644
index 0000000000..4a21fb7354
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.3.md
@@ -0,0 +1,7 @@
+- Fixed types of `$client` for clients created by drizzle function
+
+```ts
+await db.$client.[...]
+```
+
+- Added the `updated_at` column to the `neon_auth.users_sync` table definition.
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.44.4.md b/changelogs/drizzle-orm/0.44.4.md
new file mode 100644
index 0000000000..3c618dfd41
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.4.md
@@ -0,0 +1 @@
+- Fix wrong DrizzleQueryError export. thanks @nathankleyn
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.44.5.md b/changelogs/drizzle-orm/0.44.5.md
new file mode 100644
index 0000000000..5b0b2cd29e
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.5.md
@@ -0,0 +1,4 @@
+- Fixed invalid usage of `.one()` in `durable-sqlite` session
+- Fixed spread operator related crash in sqlite `blob` columns
+- Better browser support for sqlite `blob` columns 
+- Improved sqlite `blob` mapping
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.44.6.md b/changelogs/drizzle-orm/0.44.6.md
new file mode 100644
index 0000000000..a3ed777abf
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.6.md
@@ -0,0 +1 @@
+- feat: add $replicas reference #4874
diff --git a/changelogs/drizzle-orm/0.44.7.md b/changelogs/drizzle-orm/0.44.7.md
new file mode 100644
index 0000000000..ac4308e355
--- /dev/null
+++ b/changelogs/drizzle-orm/0.44.7.md
@@ -0,0 +1 @@
+- fix durable sqlite transaction return value #3746 - thanks @joaocstro
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.45.0.md b/changelogs/drizzle-orm/0.45.0.md
new file mode 100644
index 0000000000..f7ba9e87da
--- /dev/null
+++ b/changelogs/drizzle-orm/0.45.0.md
@@ -0,0 +1,5 @@
+- Fixed pg-native Pool detection in node-postgres transactions  
+- Allowed subqueries in select fields  
+- Updated typo algorythm => algorithm  
+- Fixed `$onUpdate` not handling `SQL` values (fixes [#2388](https://github.com/drizzle-team/drizzle-orm/issues/2388), tests implemented by [L-Mario564](https://github.com/L-Mario564) in [#2911](https://github.com/drizzle-team/drizzle-orm/pull/2911))
+- Fixed `pg` mappers not handling `Date` instances in `bun-sql:postgresql` driver responses for `date`, `timestamp` types (fixes [#4493](https://github.com/drizzle-team/drizzle-orm/issues/4493))  
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/0.45.1.md b/changelogs/drizzle-orm/0.45.1.md
new file mode 100644
index 0000000000..128c52c22b
--- /dev/null
+++ b/changelogs/drizzle-orm/0.45.1.md
@@ -0,0 +1 @@
+- Fixed pg-native Pool detection in node-postgres transactions breaking in environments with forbidden `require()` ([#5107](https://github.com/drizzle-team/drizzle-orm/issues/5107))  
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.1.md b/changelogs/drizzle-orm/1.0.0-beta.1.md
new file mode 100644
index 0000000000..79916840d1
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.1.md
@@ -0,0 +1,341 @@
+# Relational Queries v2
+
+```ts
+import { drizzle } from 'drizzle-orm/…';
+import { defineRelations } from 'drizzle-orm';
+import * as p from 'drizzle-orm/pg-core';
+
+export const users = p.pgTable('users', {
+  id: p.integer().primaryKey(),
+  name: p.text().notNull()
+});
+export const posts = p.pgTable('posts', {
+  id: p.integer().primaryKey(),
+  content: p.text().notNull(),
+  ownerId: p.integer('owner_id'),
+});
+
+const relations = defineRelations({ users, posts }, (r) => ({
+  posts: {
+    author: r.one.users({
+      from: r.posts.ownerId,
+      to: r.users.id,
+    }),
+  }
+}))
+
+const db = drizzle(client, { relations });
+
+const result = db.query.posts.findMany({
+  with: {
+    author: true,
+  },
+});
+```
+
+## API changes
+
+### What is working differently from v1
+
+One of the biggest updates were in Relations Schema definition
+
+The first difference is that you no longer need to specify relations for each table separately in different objects and then pass them all to drizzle() along with your schema. In Relational Queries v2, you now have one dedicated place to specify all the relations for all the tables you need.
+
+The r parameter in the callback provides comprehensive autocomplete functionality - including all tables from your schema and functions such as one, many, and through - essentially offering everything you need to specify your relations.
+
+```ts
+// relations.ts
+import * as schema from "./schema"
+import { defineRelations } from "drizzle-orm"
+export const relations = defineRelations(schema, (r) => ({
+    ...
+}));
+
+...
+
+// index.ts
+import { relations } from "./relations"
+import { drizzle } from "drizzle-orm/..."
+const db = drizzle(process.env.DATABASE_URL, { relations })
+```
+
+#### 1. One place for all your relations
+
+```ts
+import { defineRelations } from "drizzle-orm";
+import * as schema from "./schema";
+export const relations = defineRelations(schema, (r) => ({
+  users: {
+    invitee: r.one.users({
+      from: r.users.invitedBy,
+      to: r.users.id,
+    }),
+    posts: r.many.posts(),
+  },
+  posts: {
+    author: r.one.users({
+      from: r.posts.authorId,
+      to: r.users.id,
+    }),
+  },
+}));
+```
+
+#### 2. Define `many` without `one`
+
+```ts
+import { defineRelations } from "drizzle-orm";
+import * as schema from "./schema";
+export const relations = defineRelations(schema, (r) => ({
+  users: {
+    posts: r.many.posts({
+      from: r.users.id,
+      to: r.posts.authorId,
+    }),
+  },
+}));
+```
+
+#### 3. No `modes` in drizzle()
+
+We found a way to use the same strategy for all MySQL dialects, so there’s no need to specify them
+
+#### 4. `from` and `to` upgrades
+
+We’ve renamed fields to from and references to to, and we made both accept either a single value or an array
+
+```ts
+author: r.one.users({
+  from: r.posts.authorId,
+  to: r.users.id,
+}),
+
+// or
+
+author: r.one.users({
+  from: [r.posts.authorId],
+  to: [r.users.id],
+}),
+```
+
+#### 5. `relationName` -> `alias` rename
+
+```ts
+import { defineRelations } from "drizzle-orm";
+import * as schema from "./schema";
+export const relations = defineRelations(schema, (r) => ({
+  posts: {
+    author: r.one.users({
+      from: r.posts.authorId,
+      to: r.users.id,
+      alias: "author_post",
+    }),
+  },
+}));
+```
+
+#### 6. `where` is now object
+
+```ts
+const response = db.query.users.findMany({
+  where: {
+    id: 1,
+  },
+});
+```
+
+#### 7. `orderBy` is now object
+
+```ts
+const response = db.query.users.findMany({
+  orderBy: { id: "asc" },
+});
+```
+
+---
+
+### What is new?
+
+#### 1. through for many-to-many relations
+
+```ts
+import * as schema from './schema';
+import { defineRelations } from 'drizzle-orm';
+export const relations = defineRelations(schema, (r) => ({
+  users: {
+    groups: r.many.groups({
+      from: r.users.id.through(r.usersToGroups.userId),
+      to: r.groups.id.through(r.usersToGroups.groupId),
+    }),
+  },
+  groups: {
+    participants: r.many.users(),
+  },
+}));
+
+...
+
+// Query example
+const response = await db.query.users.findMany({
+  with: {
+    groups: true,
+  },
+});
+```
+
+#### 2. Predefined filters
+
+```ts
+import * as schema from './schema';
+import { defineRelations } from 'drizzle-orm';
+export const relations = defineRelations(schema,
+  (r) => ({
+    groups: {
+      verifiedUsers: r.many.users({
+        from: r.groups.id.through(r.usersToGroups.groupId),
+        to: r.users.id.through(r.usersToGroups.userId),
+        where: {
+          verified: true,
+        },
+      }),
+    },
+  })
+);
+
+... 
+
+// Query example: get groups with all verified users
+const response = await db.query.groups.findMany({
+  with: {
+    verifiedUsers: true,
+  },
+});
+```
+
+#### 3. Filtering by relations
+
+Example: Get all users whose ID>10 and who have at least one post with content starting with “M”
+
+```ts
+const usersWithPosts = await db.query.usersTable.findMany({
+  where: {
+    id: {
+      gt: 10
+    }
+  },
+  posts: {
+    content: {
+      like: 'M%'
+    }
+  }
+});
+```
+
+#### 4. Using `offset` on related objects
+
+```ts
+await db.query.posts.findMany({
+  limit: 5,
+  offset: 2, // correct ✅
+  with: {
+    comments: {
+      offset: 3, // correct ✅
+      limit: 3,
+    },
+  },
+});
+```
+
+If you have any questions about these topics:
+
+- How to migrate relations schema definition from v1 to v2
+- How to migrate queries from v1 to v2
+- Partial upgrade or how to stay on RQB v1 even after an upgrade?
+- Internal type and import changes
+
+you can refer to our migration guide, which contains all the relevant information and is available [here]()
+
+# Breaking changes
+
+## Column encoders and decoders changes
+
+Several types in the PostgreSQL dialect across all drivers were incorrectly mapping `arrays` of `intervals`, `timestamps`, `dates`, and `datetimes`. As a result, Drizzle was responding with different runtime values than what the types were showing. We've fixed this issue, but if you were already mapping those responses after Drizzle and ignoring the types, this may be a breaking change for you. Please review this part in your projects
+
+## Imports and internal types changes
+
+1. Every `drizzle` database, `session`, `migrator` and `transaction` instance, gained 2 additional generic arguments for RQB v2 queries
+
+```ts
+// before
+
+```
+
+```ts
+// now
+
+```
+
+2. Updated `DrizzleConfig` generic with `TRelations` argument and `relations: TRelations` field
+
+```ts
+// before
+
+```
+
+```ts
+// now
+
+```
+
+3. The following entities have been moved from `drizzle-orm` and `drizzle-orm/relations` to `drizzle-orm/_relations`. The original imports now include new types used by Relational Queries v2, so make sure to update your imports if you intend to use the older types:
+
+```
+- `Relation`
+- `Relations`
+- `One`
+- `Many`
+- `TableRelationsKeysOnly`
+- `ExtractTableRelationsFromSchema`
+- `ExtractObjectValues`
+- `ExtractRelationsFromTableExtraConfigSchema`
+- `getOperators`
+- `Operators`
+- `getOrderByOperators`
+- `OrderByOperators`
+- `FindTableByDBName`
+- `DBQueryConfig`
+- `TableRelationalConfig`
+- `TablesRelationalConfig`
+- `RelationalSchemaConfig`
+- `ExtractTablesWithRelations`
+- `ReturnTypeOrValue`
+- `BuildRelationResult`
+- `NonUndefinedKeysOnly`
+- `BuildQueryResult`
+- `RelationConfig`
+- `extractTablesRelationalConfig`
+- `relations`
+- `createOne`
+- `createMany`
+- `NormalizedRelation`
+- `normalizeRelation`
+- `createTableRelationsHelpers`
+- `TableRelationsHelpers`
+- `BuildRelationalQueryResult`
+- `mapRelationalRow`
+```
+
+4. In the same manner, `${dialect}-core/query-builders/query` files were moved to `${dialect}-core/query-builders/_query`
+with RQB v2's alternatives being put in their place
+
+```ts
+// before
+
+
+```
+
+```ts
+// now
+
+
+```
diff --git a/changelogs/drizzle-orm/1.0.0-beta.10.md b/changelogs/drizzle-orm/1.0.0-beta.10.md
new file mode 100644
index 0000000000..789c963572
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.10.md
@@ -0,0 +1,2 @@
+- Tagged `DrizzleError`, `DrizzleQueryError`, `TransactionRollbackError` error variants for `Effect` drivers for usage with `Effect.catchTag('DrizzleQueryError', (e: TaggedDrizzleQueryError) => { ... })`  
+- Fixed broken type inferrence of `PgColumn`s with `"strictNullChecks": false` typescript option caused by updates in `1.0.0-beta.9`  
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.11.md b/changelogs/drizzle-orm/1.0.0-beta.11.md
new file mode 100644
index 0000000000..f69effeb69
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.11.md
@@ -0,0 +1,3 @@
+- Defaulted `PgTimestampString` timezone offset to be `+00` when value gets returned as `Date` instance
+- `Pg`: Cache is now used only when explicitly defined. In recent `beta` versions caching was still applied even when no cache was configured
+- Separated date and int-exclusive column methods from common `pg builder` (separeted .defaultNow(), .generatedAlwaysAsIdentity(), .generatedByDefaultAsIdentity())
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.12.md b/changelogs/drizzle-orm/1.0.0-beta.12.md
new file mode 100644
index 0000000000..ea79ae0aee
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.12.md
@@ -0,0 +1,13 @@
+## Breaking changes
+
+- .generatedAlwaysAs() know only accepts **sql\``** and **() => sql\``**
+
+## Bug fixes
+
+- Fixed `bun-sqlite` `db.get(...)` returning data in array mode instead of object mode
+- Fixed `effect-postgres` driver ignoring cache config option
+- [[BUG]: Types do not allow for placeholder usage in onConflictDoUpdate.set](https://github.com/drizzle-team/drizzle-orm/issues/5084)
+- [[BUG]: alias doesn't work with views (Postgres)](https://github.com/drizzle-team/drizzle-orm/issues/4875)
+- [[BUG]: `select()...for("...", { of: table })` uses qualified name of table](https://github.com/drizzle-team/drizzle-orm/issues/4950)
+- [[BUG]: arrayContains() generates incorrect SQL parameters for PostgreSQL, leading to operator does not exist: text[] @> record error](https://github.com/drizzle-team/drizzle-orm/issues/4578)
+- [[BUG]: Params not inlined for single-table selects](https://github.com/drizzle-team/drizzle-orm/issues/4612)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.13.md b/changelogs/drizzle-orm/1.0.0-beta.13.md
new file mode 100644
index 0000000000..78697a590b
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.13.md
@@ -0,0 +1,192 @@
+## Drizzle Effect Postgres update
+
+We've updated an API and the Drizzle+Effect usage example to make it feel more native to Effect's style:
+
+**Before `beta.13`**
+
+```ts
+import 'dotenv/config';
+import { drizzle } from 'drizzle-orm/effect-postgres';
+import { Effect, Redacted } from 'effect';
+import { PgClient } from '@effect/sql-pg'
+import { types } from 'pg';
+const clientLayer = PgClient.layer({
+    url: Redacted.make(process.env.DATABASE_URL!);
+    types: {
+      getTypeParser: (typeId, format) => {
+        if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) { 
+          return (val: any) => val;
+        }
+        return types.getTypeParser(typeId, format);
+      },
+    },
+});
+const program = Effect.gen(function*() {
+  const client = yield* PgClient.PgClient;
+  const db = drizzle(client, { logger: true, /*...*/ });
+});
+await Effect.runPromise(program).pipe(Effect.provide(clientLayer));
+```
+
+**now for `beta.13+`**
+
+```ts
+import 'dotenv/config';
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { PgClient } from '@effect/sql-pg';
+import * as Effect from 'effect/Effect';
+import * as Redacted from 'effect/Redacted';
+import { sql } from 'drizzle-orm';
+import { types } from 'pg';
+
+// Configure the PgClient layer with type parsers
+const PgClientLive = PgClient.layer({
+  url: Redacted.make(process.env.DATABASE_URL!),
+  types: {
+    getTypeParser: (typeId, format) => {
+      // Return raw values for date/time types to let Drizzle handle parsing
+      if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) {
+        return (val: any) => val;
+      }
+      return types.getTypeParser(typeId, format);
+    },
+  },
+});
+
+const program = Effect.gen(function*() {
+  // Create the database with default services (no logging, no caching)
+  const db = yield* PgDrizzle.makeWithDefaults();
+  // Execute queries
+  const result = yield* db.execute<{ id: number }>(sql`SELECT 1 as id`);
+  console.log(result);
+});
+
+// Run the program with the PgClient layer
+Effect.runPromise(program.pipe(Effect.provide(PgClientLive)));
+```
+
+```ts
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { PgClient } from '@effect/sql-pg';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Redacted from 'effect/Redacted';
+import { types } from 'pg';
+import * as relations from './schema/relations';
+
+// Configure the PgClient layer
+const PgClientLive = PgClient.layer({
+  url: Redacted.make(process.env.DATABASE_URL!),
+  types: {
+    getTypeParser: (typeId, format) => {
+      if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) {
+        return (val: any) => val;
+      }
+      return types.getTypeParser(typeId, format);
+    },
+  },
+});
+
+// Create the DB effect with default services
+const dbEffect = PgDrizzle.make({ relations }).pipe(
+  Effect.provide(PgDrizzle.DefaultServices)
+);
+
+// Define a DB service tag for dependency injection
+class DB extends Context.Tag('DB')<DB, Effect.Effect.Success<typeof dbEffect>>() {}
+
+// Create a layer that provides the DB service
+const DBLive = Layer.effect(
+  DB,
+  Effect.gen(function*() {
+    return yield* dbEffect;
+  }),
+);
+
+// Compose all layers together
+const AppLive = Layer.provideMerge(DBLive, PgClientLive);
+
+// Use the DB service in your application
+const program = Effect.gen(function*() {
+  const db = yield* DB;
+  const users = yield* db.select().from(usersTable);
+  return users;
+});
+
+// Run with all dependencies provided
+Effect.runPromise(program.pipe(Effect.provide(AppLive)));
+```
+
+## Native Effect Logger integration
+
+By default, `makeWithDefaults()` uses a no-op logger (no logging). You can enable logging by providing a different `EffectLogger` implementation:
+
+```ts
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { EffectLogger } from 'drizzle-orm/effect-postgres';
+import * as Effect from 'effect/Effect';
+
+const program = Effect.gen(function*() {
+  const db = yield* PgDrizzle.make({ /* schema, relations, casing */ }).pipe(
+    // Enable Effect-based logging (uses Effect.log with annotations)
+    Effect.provide(EffectLogger.layer),
+    // Provide remaining default services (cache)
+    Effect.provide(PgDrizzle.DefaultServices),
+  );
+  const users = yield* db.select().from(usersTable);
+  return users;
+});
+```
+
+Available logger options:
+
+- `EffectLogger.Default` - No-op logger (no logging occurs) - this is the default
+- `EffectLogger.layer` - Logs queries using Effect’s Effect.log() with annotations for query SQL and parameters. Integrates with Effect’s logging infrastructure.
+- `EffectLogger.fromDrizzle(logger)` - Wraps a Drizzle Logger instance for use with Effect
+- `EffectLogger.layerFromDrizzle(logger)` - Creates an Effect Layer from a Drizzle logger
+
+> When using EffectLogger.layer, queries are logged via Effect’s logging system. You can configure the output format by providing a different Effect logger layer (e.g., Logger.pretty for development, Logger.json for production).
+
+Using a Drizzle logger:
+
+```ts
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { EffectLogger } from 'drizzle-orm/effect-postgres';
+import * as Effect from 'effect/Effect';
+import { DefaultLogger } from 'drizzle-orm';
+
+const program = Effect.gen(function*() {
+  const db = yield* PgDrizzle.make({ /* schema, relations, casing */ }).pipe(
+    // Use a Drizzle logger wrapped for Effect
+    Effect.provide(EffectLogger.layerFromDrizzle(new DefaultLogger())),
+    // Provide remaining default services (cache)
+    Effect.provide(PgDrizzle.DefaultServices),
+  );
+  const users = yield* db.select().from(usersTable);
+  return users;
+});
+```
+
+## Effect Cache configuration
+
+Similarly, you can provide a custom cache implementation:
+
+```ts
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { EffectLogger } from 'drizzle-orm/effect-postgres';
+import { EffectCache } from 'drizzle-orm/cache/core/cache-effect';
+import * as Effect from 'effect/Effect';
+import { MyCustomCache } from './cache';
+
+const program = Effect.gen(function*() {
+  const db = yield* PgDrizzle.make({ /* schema, relations, casing */ }).pipe(
+    // Provide a custom cache wrapped for Effect
+    Effect.provide(EffectCache.layerFromDrizzle(new MyCustomCache())),
+    // Provide remaining default services (logger)
+    Effect.provide(PgDrizzle.DefaultServices),
+  );
+  const users = yield* db.select().from(usersTable);
+  return users;
+});
+```
diff --git a/changelogs/drizzle-orm/1.0.0-beta.14.md b/changelogs/drizzle-orm/1.0.0-beta.14.md
new file mode 100644
index 0000000000..05f50f25b2
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.14.md
@@ -0,0 +1,5 @@
+## Bug fixes
+
+- [Fixed error TS7056 appearing when using "declaration": true in defineRelations with reworked PgColumns](https://github.com/drizzle-team/drizzle-orm/issues/5272)
+- Restricted usage of async functions in sync drivers' transactions
+- [[BUG]: mssql transaction is not a function](https://github.com/drizzle-team/drizzle-orm/issues/5328)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.15.md b/changelogs/drizzle-orm/1.0.0-beta.15.md
new file mode 100644
index 0000000000..6b213bb057
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.15.md
@@ -0,0 +1,87 @@
+## Changes
+
+We've stopped maintaining separate validator packages (e.g., `drizzle-zod`, `drizzle-valibot`) and moved them into the `drizzle-orm` repo. This consolidates everything into a single package and eliminates the need to manage separate peer dependencies and versioning.
+
+All packages are now available via `drizzle-orm` imports:
+
+- `drizzle-zod` -> `drizzle-orm/zod`
+- `drizzle-valibot` -> `drizzle-orm/valibot`
+- `drizzle-typebox` -> `drizzle-orm/typebox-legacy` (using `@sinclair/typebox`)
+- `drizzle-typebox` -> `drizzle-orm/typebox` (using `typebox`)
+- `drizzle-arktype` -> `drizzle-orm/arktype`
+
+You can still use the old packages, but we recommend removing them and importing directly from `drizzle-orm`. There should be no breaking changes and a simple import change should work
+
+## New Features
+
+New validation package is available: `drizzle-orm/effect-schema`
+
+```ts
+import * as p from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { Schema } from 'effect';
+
+const users = p.pgTable('users', {
+  id: p.serial().primaryKey(),
+  name: p.text().notNull(),
+  email: p.text().notNull(),
+  role: p.text({ enum: ['admin', 'user'] }).notNull(),
+  createdAt: p.timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const UserInsert = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const UserUpdate = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const UserSelect = createSelectSchema(users);
+
+// Overriding the fields
+const UserInsert = createInsertSchema(users, {
+  role: Schema.String,
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const UserInsert = createInsertSchema(users, {
+  id: (schema) => schema.pipe(Schema.greaterThanOrEqualTo(0)),
+  role: Schema.String,
+});
+
+// Usage
+
+const program = Effect.gen(function*() {
+  const parsedUser = yield* Schema.validate(UserInsert)({
+    name: 'John Doe',
+    email: 'johndoe@test.com',
+    role: 'admin',
+  });
+});
+```
+
+## Improvements
+
+- Fixed sqlite select not allowing SQL.Aliased in `.orderBy(...)`, `.groupBy(...)`
+
+This is now allowed:
+
+```ts
+const sq1 = db.$with('sq1').as((qb) =>
+        qb.select({
+          aliased: sql`count(*)`.mapWith(Number).as('alias'),
+        }).from(users)
+      );
+      const sq2 = db.$with('sq2').as((qb) =>
+        qb.select({
+          aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+        }).from(users)
+      );
+
+      const result = await db.with(sq1, sq2).select({
+        count: sq1.aliased,
+        sum: sq2.aliased,
+      }).from(sq1).crossJoin(sq2);
+```
+
+- Made `name` argument in `.prepare(name)` optional in `Gel`, `Postgres`, `Cockroach` dialects (generated automatically if not passed)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.16.md b/changelogs/drizzle-orm/1.0.0-beta.16.md
new file mode 100644
index 0000000000..73245ddf13
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.16.md
@@ -0,0 +1,87 @@
+# Drizzle ORM beta.16 updates
+
+We've fixed a regression in migrations introduced in `beta.13` that persisted through `beta.15`, and used the opportunity to significantly improve the entire migration infrastructure going forward.
+
+After receiving github issue, we focused on not just fixing the symptoms but rethinking how migrations are tracked, validated, and applied. As we always do with Drizzle we went deeper and redesigned the underlying architecture so it can be stable for all future changes, additions, and edge cases
+
+We went through how we check migrations, how we store them, and how we help developers keep their migration flow reliable. After several iterations of rewriting the `migrate` function in both ORM and Kit, adding migration table versioning, and building a new commutativity check system: here's what changed and why.
+
+## What happened in beta.12–beta.15 and what caused the issue
+
+On `latest` (pre-beta) versions, the migrations folder used a journal-based structure. A `meta/_journal.json` file stored a timestamp for each migration in **milliseconds**. That same millis value was stored in the database's `created_at` column and used to determine which migrations had been applied. Because the journal enforced ordering, we could simply fetch the last applied migration from the database and apply everything after it.
+
+With the new v3 folder structure (introduced in beta), each migration lives in its own folder named `<YYYYMMDDHHmmss>_<name>`. This format only has **second** precision. The new structure also intentionally allows out-of-order migrations (as it should for team workflows), so we switched to reading *all* migrations from the database and comparing against all local migrations.
+
+The problem appeared after `drizzle-kit up` converted the old journal structure to v3 folders. It mapped millis timestamps to the `YYYYMMDDHHmmss_name` format, stripping away the millisecond precision. So when the new migration checker compared what was in the database (millis) to what was on disk (seconds), nothing matched causing migrations to be re-applied on every run.
+
+**This only affected beta users who upgraded from the journal-based format. Users on `latest` were not impacted.**
+
+## How we fixed it
+
+### 1. Versioned migration table
+
+**Version 0** (old schema):
+| Column | Type |
+|---|---|
+| `id` | serial |
+| `hash` | text |
+| `created_at` | bigint (millis) |
+
+**Version 1** (new schema):
+| Column | Type | |
+|---|---| ---|
+| `id` | serial |
+| `hash` | text |
+| `created_at` | bigint | (legacy) |
+| `name` | text |
+| `applied_at` | timestamp |
+
+The `name` column stores the full folder name of the migration (e.g. `20250220153045_brave_wolverine`). The `applied_at` column records when the migration was actually executed. For pre-existing migrations that were backfilled during upgrade, `applied_at` is set to `NULL` to distinguish them from newly applied ones.
+
+This versioning system means we can add more fields in the future (like migration state for rollbacks) without any disruption for developers
+
+### 2. Matching by folder name instead of timestamps
+
+All migrations are now checked against the **full folder name**:  the combination of a 14-digit UTC timestamp and a name suffix (random or custom). Even if two migrations are generated within the same second, the name suffix guarantees uniqueness.
+
+The detection logic is simple: build a set of `name` values from the database, filter local migrations whose name isn't in that set, and apply those. No more timestamp arithmetic, no more precision mismatches.
+
+### 3. Automatic upgrade with smart backfilling
+
+When `beta.16` detects a `version_0` table, it adds the new columns and backfills the `name` for each existing row using a multi-step matching strategy:
+
+1. **Millis match**: truncate the stored millis to seconds and match against local migration folder timestamps
+2. **Hash tiebreaker**: if multiple migrations share the same second, use the SQL hash to pick the right one
+3. **Hash-only fallback**: if millis matching fails entirely, fall back to matching by hash alone
+
+This means the upgrade handles all edge cases: normal single-developer projects, teams with closely-timed migrations, and even cases where the old journal data doesn't perfectly align with the new folder names.
+
+### 4. New commutativity checks (`drizzle-kit check`)
+
+When working in teams, multiple developers may generate migrations from the same base schema on different branches. These migrations can conflict in non-obvious ways, for example, two branches both adding a column to the same table, or one renaming a table that another is altering.
+
+We built a new `drizzle-kit check` command that detects these non-commutative migrations. It works by:
+
+- Building a DAG (directed acyclic graph) from snapshot `prevIds` to understand the branch structure
+- Finding fork points where branches diverged
+- Computing the DDL diff from the parent snapshot to each branch leaf
+- Checking for conflicting operations using a comprehensive footprint map that knows which DDL statement types can interfere with each other
+
+This is available for PostgreSQL and MySQL today. If conflicts are found, the report tells you exactly which migrations on which branches are incompatible and what statements are conflicting.
+
+The new folder structure also changed snapshot metadata from `prevId: string` to `prevIds: string[]`, enabling proper DAG representation of migration history across branches.
+
+## Upgrading to beta.16
+
+The upgrade is automatic. When you run `migrate` for the first time on `beta.16`:
+
+1. Drizzle detects your migration table version
+2. If it's `version_0`, it adds the new columns and backfills `name` from your local migration files
+3. All future migrations are tracked by name
+4. No manual steps required
+
+If you're also upgrading your migration **folder structure** from the old journal format, run `drizzle-kit up` first to convert to the v3 folder layout, then `migrate` will handle the rest.
+
+## Upgrading to beta.16 is not fixing my problem
+
+If you're still hitting migration issues after upgrading, please reach out to us directly - drop a message in [Discord](https://discord.gg/7NKUQWP9c8) or open a [GitHub issue](https://github.com/drizzle-team/drizzle-orm/issues/new/choose) with your migration folder structure and the contents of your migrations table. We'll help you sort it out.
diff --git a/changelogs/drizzle-orm/1.0.0-beta.17.md b/changelogs/drizzle-orm/1.0.0-beta.17.md
new file mode 100644
index 0000000000..d45cf94466
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.17.md
@@ -0,0 +1,27 @@
+## New SQLite driver `node-sqlite`
+
+**Usage example:**
+
+```typescript copy
+import { drizzle } from 'drizzle-orm/node-sqlite';
+
+const db = drizzle("sqlite.db");
+
+const result = db.select().from(...);
+```
+
+If you need to provide your existing driver:
+
+```typescript copy
+import { drizzle } from 'drizzle-orm/node-sqlite';
+import { DatabaseSync } from 'node:sqlite';
+
+const sqlite = new DatabaseSync('sqlite.db');
+const db = drizzle({ client: sqlite });
+
+const result = db.select().from(...);
+```
+
+## Fixes
+
+We added a few checks to the migration upgrade logic introduced in `beta.16`. Now, when your migrations table is upgraded, we double-check that all entities in the table have been updated. If any are missing, we prompt you to pull all migrations into your environment so that we can properly update the `drizzle_migrations` table
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.19.md b/changelogs/drizzle-orm/1.0.0-beta.19.md
new file mode 100644
index 0000000000..93a2f0e91d
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.19.md
@@ -0,0 +1,39 @@
+## New Features
+
+### `sqlcommenter` support for PostgreSQL and MySQL
+
+You can now add custom tags to the query. These tags will be appended to the end of each query, helping the database add metadata/tags to it. This will be especially useful with PlanetScale’s new [Database Traffic Control](https://planetscale.com/blog/introducing-database-traffic-control) feature
+
+```ts
+// raw string support
+db.select().from().comment("key='val'");
+db.select().from().comment("my_first_tag");
+
+// developer friendly dedicated to tags
+db.select().from().comment({ key: 'val' });
+```
+
+Example:
+
+```ts
+db.select().from(comments).comment({ priority: 'high', category: "analytics" });
+```
+```sql
+select "id", "name" from "comments" /*priority='high',category='analytics'*/
+```
+
+The only limitation is that you can't use comments with a prepared statement:
+
+```ts
+// can't be used
+const p = db.select().from().prepare();
+// ❌
+p.comment({ key: 'val' }).execute();
+```
+
+## Bug fixes
+
+- [Fixed error message for the defineRelations function](https://github.com/drizzle-team/drizzle-orm/issues/5350)
+
+## Updates
+Updated `migrate()` function for mysql dialect to correctly manage multiple databases
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.2.md b/changelogs/drizzle-orm/1.0.0-beta.2.md
new file mode 100644
index 0000000000..a5878f8df2
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.2.md
@@ -0,0 +1,441 @@
+
+> We've introduced a lot of changes in this version, and something will definitely break. If anything goes wrong, you can either downgrade to version `1.0.0-beta.1` or `0.44.7`, and please report any issues on GitHub or our Discord!
+
+# New Features
+
+## MSSQL dialect 
+
+Drizzle now supports MSSQL in `drizzle-orm`, `drizzle-kit` and `drizzle-seed` packages. It support most of the columns, query builder capabilities, migration strategies, etc.
+
+The only feature that is not yet supported is `RQBv2`
+
+```ts
+// Make sure to install the 'mssql' package 
+import { drizzle } from 'drizzle-orm/node-mssql';
+
+const db = drizzle(process.env.DATABASE_URL);
+ 
+const result = await db.execute('select 1');
+```
+```ts
+// Make sure to install the 'pg' package 
+import { drizzle } from 'drizzle-orm/node-mssql';
+
+// You can specify any property from the mssql connection options
+const db = drizzle({ 
+  connection: { 
+    connectionString: process.env.DATABASE_URL,
+    ssl: true
+  }
+});
+ 
+const result = await db.execute('select 1');
+```
+
+## CockroachDB dialect
+
+Drizzle now supports MSSQL in `drizzle-orm`, `drizzle-kit` and `drizzle-seed` packages. It support most of the columns, query builder capabilities, migration strategies, etc.
+
+The only feature that is not yet supported is `RQBv2`
+
+```ts
+// Make sure to install the 'pg' package 
+import { drizzle } from 'drizzle-orm/cockroach';
+
+const db = drizzle(process.env.DATABASE_URL);
+ 
+const result = await db.execute('select 1');
+```
+```ts
+// Make sure to install the 'pg' package 
+import { drizzle } from 'drizzle-orm/cockroach';
+
+// You can specify any property from the node-postgres connection options
+const db = drizzle({ 
+  connection: { 
+    connectionString: process.env.DATABASE_URL,
+    ssl: true
+  }
+});
+ 
+const result = await db.execute('select 1');
+```
+
+## Relational Query Parts
+
+In a case you need to separate relations config into several parts you can use `defineRelationsPart` helpers
+
+```ts
+import { defineRelations, defineRelationsPart } from 'drizzle-orm';
+import * as schema from "./schema";
+export const relations = defineRelations(schema, (r) => ({
+  users: {
+    invitee: r.one.users({
+      from: r.users.invitedBy,
+      to: r.users.id,
+    }),
+    posts: r.many.posts(),
+  }
+}));
+export const part = defineRelationsPart(schema, (r) => ({
+  posts: {
+    author: r.one.users({
+      from: r.posts.authorId,
+      to: r.users.id,
+    }),
+  }
+}));
+```
+
+and then you can provide it to the db instance
+
+```ts
+const db = drizzle(process.env.DB_URL, { relations: { ...relations, ...part } })
+```
+
+## Folders v3 migrations
+
+[WIP]
+
+## Full `drizzle-kit` rewrite
+
+Architecture rewrite that will close major kit and migration issues. We've done a set of very valuable and needed updates to iterate faster, having better test coverage, etc.
+
+The work that was done:
+[WIP]
+
+## Bugs fixed
+
+- [[BUG]: Drizzle-kit pulls postgres functions as Typescript methods](https://github.com/drizzle-team/drizzle-orm/issues/4916)
+
+- [[BUG]: Changing from VARCHAR -> CITEXT (custom type) column generates "undefined"."citext" rather than "citext"](https://github.com/drizzle-team/drizzle-orm/issues/4806)
+
+- [[BUG]: When setting the casing to snake_case, the constraint name for unique fields isn't converted](https://github.com/drizzle-team/drizzle-orm/issues/4800)
+
+- [[BUG]: `drizzle-kit push` append `DROP SCHEMA` at the end for other schema name](https://github.com/drizzle-team/drizzle-orm/issues/4796)
+
+- [[BUG]: `drizzle-kit push` incorrectly tries to drop composite unique constraint despite no changes made](https://github.com/drizzle-team/drizzle-orm/issues/4789)
+
+- [[BUG]: MySQL enum defaults with value '0' are ignored during introspection](https://github.com/drizzle-team/drizzle-orm/issues/4786)
+
+- [[BUG]: drizzle-kit / Amazon Aurora DSQL : `drizzle-kit push` tries to drop the primary key index on reapply without changes](https://github.com/drizzle-team/drizzle-orm/issues/4779)
+
+- [[BUG]: `drizzle-kit check` wrongly tries to use AWS Data API](https://github.com/drizzle-team/drizzle-orm/issues/4775)
+
+- [[BUG]: bunx drizzle-kit push Freezes at “Reading config file” in Version ^0.31.4](https://github.com/drizzle-team/drizzle-orm/issues/4771)
+
+- [[BUG]: Introspect generated files don't show columns in Views as arrays](https://github.com/drizzle-team/drizzle-orm/issues/4764)
+
+- [[BUG]: drizzle kit wrong  schema with default string](https://github.com/drizzle-team/drizzle-orm/issues/4760)
+
+- [[BUG]: drizzle-kit pull fails to wrap gen_random_uuid() with sql function call resulting in syntax errors](https://github.com/drizzle-team/drizzle-orm/issues/4730)
+
+- [[BUG]: `drizzle-kit introspect` empty `''` mysqlEnum nad default introspect error](https://github.com/drizzle-team/drizzle-orm/issues/4713)
+
+- [[BUG]: CHECK constraints with operator functions generate invalid SQL with parameterized values](https://github.com/drizzle-team/drizzle-orm/issues/4661)
+
+- [[BUG]: tinyint, bigint doesn't include when run drizzle-kit pull](https://github.com/drizzle-team/drizzle-orm/issues/4653)
+
+- [[BUG]:drizzle-kit pull missing one ' letter column with default empty text](https://github.com/drizzle-team/drizzle-orm/issues/4644)
+
+- [[BUG]: Unable to create composite foreign key: order of SQL statements [Postgres]](https://github.com/drizzle-team/drizzle-orm/issues/4638)
+
+- [[BUG]: drizzle-kit MySQL Serializer doesn't see PKs and CHECK constraints](https://github.com/drizzle-team/drizzle-orm/issues/4602)
+
+- [[BUG]: unique key names for multiple columns doesn't respect casing configuration](https://github.com/drizzle-team/drizzle-orm/issues/4541)
+
+- [[BUG]: `drizzle-kit push` fails if the target postgres database has a `jsonb` column with a default value](https://github.com/drizzle-team/drizzle-orm/issues/4529)
+
+- [[BUG]: `drizzle-kit generate` generates out of order/ incorrect migrations](https://github.com/drizzle-team/drizzle-orm/issues/4456)
+
+- [[BUG]: `with:` columns resulting in `any` values](https://github.com/drizzle-team/drizzle-orm/issues/4432)
+
+- [[BUG]: Drizzle not pulling foreign key names using introspect command in ts + mysql](https://github.com/drizzle-team/drizzle-orm/issues/4415)
+
+- [[BUG]: Invalid SQL query generated for MySQL when using "with" feature](https://github.com/drizzle-team/drizzle-orm/issues/4412)
+
+- [[BUG]: with Relation in findMany Returns Flattened Array Instead of Key-Value Object](https://github.com/drizzle-team/drizzle-orm/issues/4409)
+
+- [[BUG]: drizzle-orm@beta query object is empty in NuxtHub project](https://github.com/drizzle-team/drizzle-orm/issues/4390)
+
+- [[BUG]: Big int precision loss when data fetched with json_agg](https://github.com/drizzle-team/drizzle-orm/issues/4380)
+
+- [[BUG]: Incorrect column types when using `with` for table created with helper function](https://github.com/drizzle-team/drizzle-orm/issues/4358)
+
+- [[BUG]: drizzle-orm@beta SQLite error in queries w/ `with`](https://github.com/drizzle-team/drizzle-orm/issues/4357)
+
+- [[BUG]: Identifier is too long (should not exceed 63 characters)](https://github.com/drizzle-team/drizzle-orm/issues/4238)
+
+- [[BUG]: Unable to create MySQL foreign string keys](https://github.com/drizzle-team/drizzle-orm/issues/4221)
+
+- [[BUG]: Drizzle type inferrence doesn't work properly with many tables](https://github.com/drizzle-team/drizzle-orm/issues/4199)
+
+- [findFirst Date returned as string](https://github.com/drizzle-team/drizzle-orm/issues/4186)
+
+- [[BUG]: Can't drop a foreign key in Turso dialect](https://github.com/drizzle-team/drizzle-orm/issues/4167)
+
+- [[BUG]: wrong table name generated in `$count` sub-expression](https://github.com/drizzle-team/drizzle-orm/issues/4164)
+
+- [[BUG]:Unknown column in where](https://github.com/drizzle-team/drizzle-orm/issues/4159)
+
+- [[BUG]: drizzle-kit generate when dropping table attempts to delete already deleted constraint](https://github.com/drizzle-team/drizzle-orm/issues/4155)
+
+- [[BUG]: Incomplete inferred result type in query API when using optional columns](https://github.com/drizzle-team/drizzle-orm/issues/4153)
+
+- [SQLite columns are not marked as unique, instead a unique index has been created](https://github.com/drizzle-team/drizzle-orm/issues/4152)
+
+- [[BUG]:Introspect does not pull foreign key names when `on delete` and  `on update` are set to other than `no action`](https://github.com/drizzle-team/drizzle-orm/issues/4115)
+
+- [[BUG]: `drizzle-kit pull` made a broken schema as TypeScript. (looks forget to import `tinyint` from drizzle-orm/mysql-core)](https://github.com/drizzle-team/drizzle-orm/issues/4110)
+
+- [[BUG]: Drizzle Relational Query not filtering well](https://github.com/drizzle-team/drizzle-orm/issues/4080)
+
+- [[BUG]:Inconsistent behavior in many-to-many relations with junction table: identical patterns yield different results](https://github.com/drizzle-team/drizzle-orm/issues/3937)
+
+- [[BUG]:Error Typescript for query where in relation (version  "drizzle-orm": "^0.38.3")](https://github.com/drizzle-team/drizzle-orm/issues/3911)
+
+- [[BUG]: findFirst not return undefined or null when not data is found.](https://github.com/drizzle-team/drizzle-orm/issues/3872)
+
+- [[DOCS]: Nullable Relation](https://github.com/drizzle-team/drizzle-orm/issues/3855)
+
+- [[BUG]: Type error when performing filter select according to docs](https://github.com/drizzle-team/drizzle-orm/issues/3804)
+
+- [[BUG]: Incorrect Non-Nullable Type Inference for One-to-One Related Entities](https://github.com/drizzle-team/drizzle-orm/issues/3799)
+
+- [[BUG]: Allow specifying relationName for one-to-one relationships on the side without field definitions](https://github.com/drizzle-team/drizzle-orm/issues/3763)
+
+- [[BUG]: Custom types not working when insert with onConflictDoUpdate in Sqlite](https://github.com/drizzle-team/drizzle-orm/issues/3730)
+
+- [[FEATURE]: Scopes API](https://github.com/drizzle-team/drizzle-orm/issues/3646)
+
+- [[BUG]: Column name conversion not working when using `sql.js`](https://github.com/drizzle-team/drizzle-orm/issues/3642)
+
+- [[BUG]: Drizzle-kit no longer supporting the special characters in enum values (MySQL)](https://github.com/drizzle-team/drizzle-orm/issues/3613)
+
+- [[BUG]:drizzle-kit pull returns .with({"securityInvoker":"on"})](https://github.com/drizzle-team/drizzle-orm/issues/3585)
+
+- [[BUG]: db.query creates slow (?) queries in related queries](https://github.com/drizzle-team/drizzle-orm/issues/3581)
+
+- [[BUG]:push creates duplicate statements for unique column index](https://github.com/drizzle-team/drizzle-orm/issues/3574)
+
+- [[BUG]: findMany (and likely others) building an invalid query when other tables are referenced in the where clause](https://github.com/drizzle-team/drizzle-orm/issues/3573)
+
+- [[BUG]: $count() generates the wrong Postgres subquery](https://github.com/drizzle-team/drizzle-orm/issues/3564)
+
+- [[BUG]:drizzle-kit pull generate wrong schema.ts](https://github.com/drizzle-team/drizzle-orm/issues/3559)
+
+- [[BUG]: Instrospect doesn't put `.primaryKey()` in my tables](https://github.com/drizzle-team/drizzle-orm/issues/3552)
+
+- [[BUG]: extras in findMany count relations is not working](https://github.com/drizzle-team/drizzle-orm/issues/3546)
+
+- [[BUG]: TypeError: Cannot read properties of undefined (reading 'columns')](https://github.com/drizzle-team/drizzle-orm/issues/3539)
+
+- [[BUG]: `pgEnum` generates faulty migrations](https://github.com/drizzle-team/drizzle-orm/issues/3514)
+
+- [[BUG]: Query include relations => relation table has jsonb field =>  SqliteError: JSON cannot hold BLOB values ](https://github.com/drizzle-team/drizzle-orm/issues/3497)
+
+- [MYSQL Introspect: Warning: Can't parse bit(1) from database](https://github.com/drizzle-team/drizzle-orm/issues/3480)
+
+- [Certain Postgres types are not handled by `introspect:pg`](https://github.com/drizzle-team/drizzle-orm/issues/3479)
+
+- [BUG `drizzle-kit push:mysql` with Two Primary Keys](https://github.com/drizzle-team/drizzle-orm/issues/3473)
+
+- [push:mysql fails to drop a serial column and replace with another column type](https://github.com/drizzle-team/drizzle-orm/issues/3471)
+
+- [db push just hangs, verbose doesn't show any details](https://github.com/drizzle-team/drizzle-orm/issues/3470)
+
+- [Drizzle Studio giving error due to `CURRENT_TIMESTAMP` in schema](https://github.com/drizzle-team/drizzle-orm/issues/3453)
+
+- [[Mysql] Drizzle kit generates invalid SQL syntax for `onUpdateNow` when an `fsp` is provided to timestamp](https://github.com/drizzle-team/drizzle-orm/issues/3373)
+
+- [drizzle-kit push with PostGIS geometry column type](https://github.com/drizzle-team/drizzle-orm/issues/3347)
+
+- [[BUG]: Mysql new .unique().notNull(), `add constraint` is put before `add column`, throwing error.](https://github.com/drizzle-team/drizzle-orm/issues/3329)
+
+- [Double quotes on defaults](https://github.com/drizzle-team/drizzle-orm/issues/3318)
+
+- [There are three cases where drizzle-kit's introspect:mysql does not work. ](https://github.com/drizzle-team/drizzle-orm/issues/3297)
+
+- [MySQL & PostgreSQL: not detecting all new cascades](https://github.com/drizzle-team/drizzle-orm/issues/3293)
+
+- [[BUG]:array of enum occurs error when drizzle-kit pushing](https://github.com/drizzle-team/drizzle-orm/issues/3278)
+
+- [[BUG]:Deep nested queries](https://github.com/drizzle-team/drizzle-orm/issues/3277)
+
+- [[BUG]: `findMany`/`findFirst` incorrectly substituting table names in sql operator](https://github.com/drizzle-team/drizzle-orm/issues/3268)
+
+- [[BUG]: Incorrect bigint value retrieval using findMany with relations (postgresql)](https://github.com/drizzle-team/drizzle-orm/issues/3267)
+
+- [[BUG]: bit type goes to postgresql as a string](https://github.com/drizzle-team/drizzle-orm/issues/3254)
+
+- [[BUG]: Foreign key name length](https://github.com/drizzle-team/drizzle-orm/issues/3244)
+
+- [[BUG]: "unix_timestamp is not defined"](https://github.com/drizzle-team/drizzle-orm/issues/3237)
+
+- [[BUG]: Pressing `escape` while in the `push` confirmation dialog runs the push](https://github.com/drizzle-team/drizzle-orm/issues/3230)
+
+- [[BUG]: arrayContains, arrayContained, arrayOverlaps aren't there in queries find callbacks](https://github.com/drizzle-team/drizzle-orm/issues/3169)
+
+- [[BUG]: Query extras resolve table names incorrectly](https://github.com/drizzle-team/drizzle-orm/issues/3110)
+
+- [[BUG]: UUID Error on push, but no issue via generate / migrate](https://github.com/drizzle-team/drizzle-orm/issues/3090)
+
+- [[BUG]: default value in migration generates invalid sql.ts file](https://github.com/drizzle-team/drizzle-orm/issues/3087)
+
+- [[BUG]: drizzle-kit triggers a _ZodError when uniqueIndex is used together with sql lower](https://github.com/drizzle-team/drizzle-orm/issues/3062)
+
+- [[BUG]: drizzle-kit introspect TypeError: Cannot read properties of null (reading 'camelCase')](https://github.com/drizzle-team/drizzle-orm/issues/3046)
+
+- [[BUG]: Types aren't correctly inferred for nested `with: { where }` clauses](https://github.com/drizzle-team/drizzle-orm/issues/3045)
+
+- [[BUG]: drizzle-kit introspection does not import "bigint" type when introspecting a MySql database.](https://github.com/drizzle-team/drizzle-orm/issues/2988)
+
+- [[BUG]: findFirst and findMany queries using the 'with' statement can't parse the models if the related table has a geomtery column](https://github.com/drizzle-team/drizzle-orm/issues/2961)
+
+- [[FEATURE]: API for to 'flatten' response shapes when querying data from complex schemas and their relations.](https://github.com/drizzle-team/drizzle-orm/issues/2933)
+
+- [[FEATURE]: Add `where` in one-to-one querying](https://github.com/drizzle-team/drizzle-orm/issues/2903)
+
+- [[DOCUMENTATION]: Typo in the code](https://github.com/drizzle-team/drizzle-orm/issues/2840)
+
+- [[BUG]: migrations do not work - table already exists - ER_TABLE_EXISTS_ERROR - mysql](https://github.com/drizzle-team/drizzle-orm/issues/2815)
+
+- [[BUG]: pg geometry is preventing migration](https://github.com/drizzle-team/drizzle-orm/issues/2806)
+
+- [[BUG]: Do statement double dollar sign not escaping cases where you want a "$" as a value](https://github.com/drizzle-team/drizzle-orm/issues/2710)
+
+- [[BUG]: Drizzle Query Returns Different Result Than Select](https://github.com/drizzle-team/drizzle-orm/issues/2703)
+
+- [[BUG]: drizzle-orm imported operators `eq`, `lt`, etc. unable to recognize left hand "table.column" param while callback syntax works](https://github.com/drizzle-team/drizzle-orm/issues/2698)
+
+- [[BUG]: PG Numeric inferred as string, but is numeric at runtime](https://github.com/drizzle-team/drizzle-orm/issues/2681)
+
+- [[BUG]: Geometry type ignores SRID option](https://github.com/drizzle-team/drizzle-orm/issues/2675)
+
+- [[FEATURE]: Drizzle relations with materialized views ](https://github.com/drizzle-team/drizzle-orm/issues/2653)
+
+- [[BUG]: MySQL generatedAlwaysAs with notNull](https://github.com/drizzle-team/drizzle-orm/issues/2616)
+
+- [[BUG]: Unique key reconciliation with upstream schema is inconsistent](https://github.com/drizzle-team/drizzle-orm/issues/2599)
+
+- [[BUG]: Aggregated results from many-to-one relations doesn't return timestamp using postgres DB](https://github.com/drizzle-team/drizzle-orm/issues/2555)
+
+- [[BUG]: Issues with nested conditions & placeholders in SQLite query](https://github.com/drizzle-team/drizzle-orm/issues/2529)
+
+- [[BUG]:  Postgis `geometry` query select fails when using `with`](https://github.com/drizzle-team/drizzle-orm/issues/2526)
+
+- [[BUG]: Geometry config type doesn't appear to affect the output sql](https://github.com/drizzle-team/drizzle-orm/issues/2454)
+
+- [[BUG]: relation query API default alias is different than regular alias](https://github.com/drizzle-team/drizzle-orm/issues/2431)
+
+- [[BUG]: Unable to provide sql value in $onUpdate](https://github.com/drizzle-team/drizzle-orm/issues/2388)
+
+- [[BUG]: Typing issue when using tables with the same name across different schemas](https://github.com/drizzle-team/drizzle-orm/issues/2387)
+
+- [Support nested orderBy](https://github.com/drizzle-team/drizzle-orm/issues/2297)
+
+- [[BUG]: Timestamp formatted differently if fetched as relation rather than directly](https://github.com/drizzle-team/drizzle-orm/issues/2282)
+
+- [[FEATURE]: Allow for hardcoded values in relations](https://github.com/drizzle-team/drizzle-orm/issues/2268)
+
+- [[BUG]: Adding new column and unique key on the new column generates invalid migration file](https://github.com/drizzle-team/drizzle-orm/issues/2236)
+
+- [[BUG]: encoding issue with non-ASCII characters](https://github.com/drizzle-team/drizzle-orm/issues/2235)
+
+- [[BUG]: Query API does not include schema name when including child relations ](https://github.com/drizzle-team/drizzle-orm/issues/2194)
+
+- [[BUG]: Planetscale got packets out of order for 'serial' type on push](https://github.com/drizzle-team/drizzle-orm/issues/2180)
+
+- [[BUG]: Postgres customType generate invalid SQL.](https://github.com/drizzle-team/drizzle-orm/issues/2087)
+
+- [[BUG]: Deeply nested queries fail due to table name length](https://github.com/drizzle-team/drizzle-orm/issues/2066)
+
+- [[BUG]: on cascade delete issue with multiple foreign keys and migrations](https://github.com/drizzle-team/drizzle-orm/issues/2018)
+
+- [[DOCS]: Relationships should have their own page](https://github.com/drizzle-team/drizzle-orm/issues/1913)
+
+- [[BUG]: Schema name is not prepended to the table name when aliased const.](https://github.com/drizzle-team/drizzle-orm/issues/1903)
+
+- [[BUG]: `Do not know how to serialize a BigInt` errors when using BigInt in `default(0n)` directive](https://github.com/drizzle-team/drizzle-orm/issues/1879)
+
+- [[BUG]: Typescript doesn't recognize One-To-One Relation](https://github.com/drizzle-team/drizzle-orm/issues/1869)
+
+- [[BUG]: sql`` interpolates the wrong table name when used in extras](https://github.com/drizzle-team/drizzle-orm/issues/1815)
+
+- [[BUG]: pg-native Pools don't work with Transactions](https://github.com/drizzle-team/drizzle-orm/issues/1707)
+
+- [[BUG]: Custom types not working in `with` queries](https://github.com/drizzle-team/drizzle-orm/issues/1572)
+
+- [[BUG]: ERROR: operator does not exist](https://github.com/drizzle-team/drizzle-orm/issues/1570)
+
+- [[BUG]:Property 'notNull` in the timstamp type](https://github.com/drizzle-team/drizzle-orm/issues/1535)
+
+- [[BUG]: eq function is nor working in 0.29.0](https://github.com/drizzle-team/drizzle-orm/issues/1488)
+
+- [[BUG]: does nesting with blocks has threshold with pg](https://github.com/drizzle-team/drizzle-orm/issues/1477)
+
+- [[FEATURE]: infer possible undefined columns value if is a boolean (not specifically true or false)](https://github.com/drizzle-team/drizzle-orm/issues/1438)
+
+- [[BUG]: ER_WRONG_AUTO_KEY - Drizzle Kit not detecting primary keys](https://github.com/drizzle-team/drizzle-orm/issues/1428)
+
+- [[BUG]: Error: Multiple primary key defined](https://github.com/drizzle-team/drizzle-orm/issues/1413)
+
+- [[BUG]: Unable to use orderBy clause on multiple relations when placed adjacently in a query (MySQL)](https://github.com/drizzle-team/drizzle-orm/issues/1396)
+
+- [[BUG]: wrong typeHint when using relations (one and automatic limit: 1)](https://github.com/drizzle-team/drizzle-orm/issues/1368)
+
+- [[BUG]: orderBy causes relational query to fail](https://github.com/drizzle-team/drizzle-orm/issues/1249)
+
+- [[BUG]: `columns` partial select gives bad type with dynamic conditions](https://github.com/drizzle-team/drizzle-orm/issues/1163)
+
+- [[BUG]: `mapWith` isn't working on `extras` when doing relational queries with `findFirst` or `findMany`](https://github.com/drizzle-team/drizzle-orm/issues/1157)
+
+- [[BUG]: `findFirst` and `findMany` isn't correctly setting the table name when using sql directive `sql`${table}``](https://github.com/drizzle-team/drizzle-orm/issues/1149)
+
+- [[FEATURE]: Add back filtering by nested relations in relational queries](https://github.com/drizzle-team/drizzle-orm/issues/1069)
+
+- [[FEATURE]: Optional One-to-One Relation](https://github.com/drizzle-team/drizzle-orm/issues/1066)
+
+- [[FEATURE]: Support Polymorphic Association](https://github.com/drizzle-team/drizzle-orm/issues/1051)
+
+- [[BUG]: where clause on relational query overwrites the table name](https://github.com/drizzle-team/drizzle-orm/issues/975)
+
+- [[BUG]: error: column "role" cannot be cast automatically to type user_role](https://github.com/drizzle-team/drizzle-orm/issues/930)
+
+- [[FEATURE]: How much support for cockroachdb?](https://github.com/drizzle-team/drizzle-orm/issues/845)
+
+- [[BUG]: Relations inferring incorrect table with non-default Postgres schema](https://github.com/drizzle-team/drizzle-orm/issues/830)
+
+- [[FEATURE]: Filtered & ordered relationships](https://github.com/drizzle-team/drizzle-orm/issues/821)
+
+- [[BUG]: Relational queries break customTypes with underlying DECIMAL dataTypes](https://github.com/drizzle-team/drizzle-orm/issues/820)
+
+- [[BUG]: Column with custom type not working with `default()`](https://github.com/drizzle-team/drizzle-orm/issues/818)
+
+- [[BUG]: Can't use views with relations API](https://github.com/drizzle-team/drizzle-orm/issues/769)
+
+- [[FEATURE]: Add extra conditions to the joins](https://github.com/drizzle-team/drizzle-orm/issues/756)
+
+- [[BUG]: Drizzle is bloating indexes on MySQL](https://github.com/drizzle-team/drizzle-orm/issues/706)
+
+- [[BUG]: Relational query on sqlite/d1 with order-by has issues](https://github.com/drizzle-team/drizzle-orm/issues/705)
+
+- [Allow referencing deeply nested properties in relational queries](https://github.com/drizzle-team/drizzle-orm/issues/696)
+
+- [[FEATURE]: Customizable many relations](https://github.com/drizzle-team/drizzle-orm/issues/674)
+
+- [[FEATURE]: "through" relation queries](https://github.com/drizzle-team/drizzle-orm/issues/607)
+
+- [[FEATURE]: MSSQL dialect](https://github.com/drizzle-team/drizzle-orm/issues/585)
+
+- [[BUG]: planetscale - now() and current_timestamp() doesn't work when FSP is specified for timestamp](https://github.com/drizzle-team/drizzle-orm/issues/472)
+
+- [[BUG]: MySQL alter table fails where tablename is reserved word](https://github.com/drizzle-team/drizzle-orm/issues/364)
+
+# Updates and Fixes
+
+- Fixed pg-native Pool detection in node-postgres transactions  
+- Allowed subqueries in select fields  
+- Updated typo algorythm => algorithm  
+- Fixed `$onUpdate` not handling `SQL` values (fixes [#2388](https://github.com/drizzle-team/drizzle-orm/issues/2388), tests implemented by [L-Mario564](https://github.com/L-Mario564) in [#2911](https://github.com/drizzle-team/drizzle-orm/pull/2911))
+- Fixed `pg` mappers not handling `Date` instances in `bun-sql:postgresql` driver responses for `date`, `timestamp` types (fixes [#4493](https://github.com/drizzle-team/drizzle-orm/issues/4493))  
diff --git a/changelogs/drizzle-orm/1.0.0-beta.20.md b/changelogs/drizzle-orm/1.0.0-beta.20.md
new file mode 100644
index 0000000000..f46908a288
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.20.md
@@ -0,0 +1,4 @@
+- Fixed `sql.identifier()`, `sql.as()` escaping issues. Previously all the values passed to this functions were not properly escaped
+causing a possible SQL Injection (CWE-89) vulnerability
+
+Thanks to @EthanKim88, @0x90sh and @wgoodall01 for reaching out to us with a reproduction and suggested fix
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.23.md b/changelogs/drizzle-orm/1.0.0-beta.23.md
new file mode 100644
index 0000000000..01f9d18f04
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.23.md
@@ -0,0 +1,34 @@
+## New Netlify Database Driver
+
+> Note: The Netlify Database driver is developed and maintained by the Netlify team.
+
+**Installation:**
+```bash
+npm install @netlify/database
+```
+
+**Usage example:**
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+const db = drizzle();
+
+const result = await db.execute('select 1');
+```
+
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+const db = drizzle(process.env.DATABASE_URL);
+
+const result = await db.execute('select 1');
+```
+
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+// Explicit client — consumer controls the driver
+const db = drizzle({ client: netlifyDbClient });
+
+const result = await db.execute('select 1');
+```
diff --git a/changelogs/drizzle-orm/1.0.0-beta.3.md b/changelogs/drizzle-orm/1.0.0-beta.3.md
new file mode 100644
index 0000000000..a7062fff03
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.3.md
@@ -0,0 +1 @@
+- MySQL use/force/ingore index now accepts `unique constraints`
diff --git a/changelogs/drizzle-orm/1.0.0-beta.4.md b/changelogs/drizzle-orm/1.0.0-beta.4.md
new file mode 100644
index 0000000000..dd1b58648a
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.4.md
@@ -0,0 +1,8 @@
+Regression issues fixed(from `-beta.x` releases)
+
+- [[BUG]: migrations.sort in migrator.js does nothing - migrations run in wrong order on Linux](https://github.com/drizzle-team/drizzle-orm/issues/5123)
+- [[BUG]: drizzle-kit generate not working without error](https://github.com/drizzle-team/drizzle-orm/issues/5124)
+
+Issues fixed(from latest tag)
+
+- [[BUG]: drizzle-kit check wrongly tries to use AWS Data API](https://github.com/drizzle-team/drizzle-orm/issues/4775)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.5.md b/changelogs/drizzle-orm/1.0.0-beta.5.md
new file mode 100644
index 0000000000..c6df01895a
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.5.md
@@ -0,0 +1,80 @@
+## Bug fixes
+
+- [[BUG]: error: type "serial" does not exist](https://github.com/drizzle-team/drizzle-orm/issues/2183)
+- [[BUG]: jsonb default with boolean literals gets generated truen instead of true](https://github.com/drizzle-team/drizzle-orm/issues/5149)
+- [[BUG]: MSSQL view incorrect syntax](https://github.com/drizzle-team/drizzle-orm/issues/5113)
+- Fixed `blob` columns in MySQL to work properly with RQB mapper
+
+## Changes to SQLite `drizzle-kit up` command
+
+> Important!
+>
+> If you were already using SQLite in any `beta.x` version and have used the `drizzle-kit up` command, you will not receive the latest `up` changes from this release. If you are unable to reset migrations and start from scratch, you will need to contact us for support with upgrading
+
+### What was changed?
+
+#### Handling of UNIQUE constraints in SQLite
+
+In the new version `drizzle-kit` handles `UNIQUE` constraints. This decision was made because when a unique constraint is created it cannot be removed, whereas an index can be dropped
+
+Previous version of Drizzle-Kit always created `.unique()` as a `uniqueIndex` and stored it in the snapshot that way. Because of this during an up we lack of sufficient information and if a user used `.unique()` an upped will generate a diff on generate and push
+
+**Solution:**
+
+We are replacing all unique constraints with `uniqueIndex`
+
+`uniqueIndex` requires a name and the name must follow this format:
+
+`<table>_<column1>*_*<column2>_..._unique`
+
+#### Foreign key name handling in the old(pre 1.0) drizzle-kit
+
+The old `drizzle-kit` did not handle foreign key names when generated sql migrations. A foreign key name could be defined in the ts schema, but it was not passed through when generating sql
+
+```tsx
+export const table = sqliteTable("table", {
+    column1: integer(),
+    column2: integer()},
+  (t) => [
+    foreignKey({
+      name: "name",
+      columns: [t.column1],
+      foreignColumns: [t.column2],
+    }),
+  ]
+);
+
+// no name provided
+FOREIGN KEY (`timest`) REFERENCES `b`(`timest1`) ON UPDATE no action ON DELETE no action
+```
+
+On `introspect` new drizzle-kit parses ddl to find constraint name, if no name found - use default name
+
+After running `drizzle-kit up` the first `push` command will result in a diff that recreates the table (no name from db, but there is name in ts schema). To avoid this foreign key names should be removed - in that case no diff will be generated.
+
+`drizzle-kit generate` command will behave as expected, no changes needed.
+
+#### Bug in the old drizzle-kit related to foreign keys
+
+If you add a column to an existing table that has a foreign key and specify `onDelete` or `onUpdate`, column will be added with the foreign key, but without those parameters
+
+```tsx
+export const table = sqliteTable("table", {
+	column1: integer()
+});
+
+export const table = sqliteTable("table", {
+	column1: integer(),
+	column2: integer().references((): AnySQLiteColumn => table.column1, 
+		{
+			onDelete: "set null", 
+			onUpdate: "set default"
+		})
+});
+
+ALTER TABLE `table` ADD `column2` integer REFERENCES table(column1);
+```
+
+There is no way to fix this in the old snapshot. It led to table recreation during subsequent `push` operations (in the pre-v1.0 drizzle-kit version)
+
+New `drizzle-kit` will recreate table after push command with the correct SQL. When using `generate` command, no diffs will appear, but the actual database state may differ
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.7.md b/changelogs/drizzle-orm/1.0.0-beta.7.md
new file mode 100644
index 0000000000..b9b4cea5c9
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.7.md
@@ -0,0 +1,3 @@
+## Bug fixes
+
+- [[BUG]: findFirst fails with TypeError: null is not an object (evaluating 'row[selectionItem.key]') if no results are found](https://github.com/drizzle-team/drizzle-orm/issues/5189)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-beta.9.md b/changelogs/drizzle-orm/1.0.0-beta.9.md
new file mode 100644
index 0000000000..99ee583854
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-beta.9.md
@@ -0,0 +1,6 @@
+- Drizzle now has native `@effect/sql-pg` driver support  
+That is a big milestone for Drizzle. We did rework our query builder chain and it supports both EffectLike and PromiseLike flows, we will gather feedback from the community and ship other dialects support  
+- We did also rework(simplified) `PgColumn` type chain, it's now mostly decoupled from other dialects, it now has better type performance and simpler declaration chain. We did remove PgArray column recursive wrapper, every `PgColumn` now has dimensions property both in runtime and type chain for external usage like validation packages
+- We have 1 breaking API change too, postgres `.array()` is now not chainable, if you want to have multidimensional array it's now `.array('[][]')`,`.array('[][][]')`, etc.  
+- Fixed lack of query result recalculation on pg dynamic update with joins  
+- Switched `MySQL2` default client from `CallbackPool` to `Pool`  
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-rc.1.md b/changelogs/drizzle-orm/1.0.0-rc.1.md
new file mode 100644
index 0000000000..3f885f4af0
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-rc.1.md
@@ -0,0 +1,125 @@
+# v1.0.0-rc.1
+⚠️ This release introduced a breaking change into our `casing` API([see below](#new-casing-api)) and remove RQB v1 `._query`
+## JIT mappers
+Drizzle ORM now has an opt-in API for JIT(just in time compilated) mappers which make most expensive part of the db request pipeline(row mapping) as fast as humanly possible. 
+```ts
+const db = drizzle({ ..., jit: true })
+
+const query = db.select().from(users).prepare();
+// ^ here drizzle generates a jit mapper which will then be reused during each invocation
+
+server.get('users', (c) => {
+  const users = await query.execute(); // as fast as using raw driver
+  return c.json(users)
+})
+```
+We've reworked internals of Drizzle ORM with the new system of `codecs`. Those are now in charge of normalising responses and requests for diffrent drivers across pg dialect. They helped us not only properly fix a set of data mapping issues but also massively improve performance by not doing unnecessary work.
+We've seen a 25%-30% reduction in latency, while +800rps(14500->15300) in our benchmarks
+Give it a go and let us know if everything works just fine!
+
+## Effect v4
+`drizzle-orm@1.0.0-rc.1` comes with native support for Effect v4 via: 
+```ts
+import { PgClient } from '@effect/sql-pg';
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import * as Effect from 'effect/Effect';
+import * as Redacted from 'effect/Redacted';
+import { relations } from '../relations';
+
+const connectionStr = Redacted.make(process.env['PG_CONNECTION_STRING']!);
+const PgClientLive = PgClient.layer({
+  url: connectionStr,
+});
+
+const DB = PgDrizzle.make({ relations }).pipe(Effect.provide(PgDrizzle.DefaultServices));
+const program = Effect.gen(function*() {
+  const db = yield* DB;
+
+  const users = yield* db.select().from(usersTable);
+}).pipe(Effect.provide(PgClientLive));
+
+await Effect.runPromise(program);
+```
+
+## New Casing API
+⚠️ BREAKING CHANGE
+In `rc.1` we've finally reworked our legacy casing API of `const db = drizzle({..., casing: "camel" })` which turned out to not be a proper solution, it required duplication in drizzle-orm instantiation and drizzle-kit config and introduced and set of endless bugs all around query builder chain. All of the above is now fixed with new API: 
+```ts
+import * as d from "drizzle-orm/pg-core";
+
+const users = d.snakeCase.table("users", {
+  id: d.serial().primaryKey(),
+  email: d.text().unique(),
+  fullName: d.text(), // full_name in db
+  createdAt: d.timestamp().defaultNow(), // created_at in db
+})
+
+// --- for namespaces/schemas you can use
+
+const schema2 = d.camelCase.schema("schema2");
+
+const usersInSchema2 = schema2.table("users", ...);
+const ordersInSchema2 = schema2.table("orders", ...);
+// ^ all entities in schema2 will be scnake_cased
+
+
+// --- all available entities
+import { snakeCase, camelCase } from "drizzle-orm/pg-core";
+
+snakeCase.view
+snakeCase.materializedView
+snakeCase.schema
+snakeCase.table
+
+camelCase.view
+camelCase.materializedView
+camelCase.schema
+camelCase.table
+```
+
+## New Netlify Database Driver
+> Note: The Netlify Database driver is developed and maintained by the Netlify team.
+
+**Installation:**
+```bash
+npm install @netlify/database
+```
+
+**Usage example:**
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+const db = drizzle();
+
+const result = await db.execute('select 1');
+```
+
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+const db = drizzle(process.env.DATABASE_URL);
+
+const result = await db.execute('select 1');
+```
+
+```typescript
+import { drizzle } from 'drizzle-orm/netlify-db';
+
+// Explicit client — consumer controls the driver
+const db = drizzle({ client: netlifyDbClient });
+
+const result = await db.execute('select 1');
+```
+
+## Bug fixes and improvements:
+- Codec system for `postgres` - resolves issues created by differences of data types returned by different drivers or different contexts of query (regular select, JSON object, postgres array). Currently only handles supported by drizzle constructors column types. (fixes #3018, #5090, #5287)
+- Optimized query mappers for `postgres`
+- Opt-in JIT-generated mappers for all dialects 
+- Optimized RQBv2 mappers for all dialects
+- ⚠️ BREAKING CHANGE: Removed RQBv1 (`db._query`) from `postgres`
+- Moved pg array utils (`makePgArray`, `parsePgArray`) from `drizzle-orm/pg-core/utils[/array]` to `drizzle-orm/pg-core/array`
+- Simplified `postgres` sessions & prepared queries
+- Fixed `neon-http` `bytea` data corruption
+- Fixed `bun-sql/postgres` timestamp timezone truncation, `json[b]` data double stringification  
+- ⚠️ BREAKING CHANGE: Reworked casing API - moved casing control from `db` instance to `table` \ `view` \ `schema` via `import { snakeCase, camelCase } from "drizzle-orm/dialect-core"`, fixed #5112 #5282 #4181 #4209
+- Switched from Effect V3 to Effect V4 beta for `effect-schema`, `effect-postgres` (fixes #5414)
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-rc.2.md b/changelogs/drizzle-orm/1.0.0-rc.2.md
new file mode 100644
index 0000000000..f9e4c4dd17
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-rc.2.md
@@ -0,0 +1,8 @@
+- Disabled default codec type selectors for custom columns (fixes [#5711](https://github.com/drizzle-team/drizzle-orm/issues/5711))
+- Сallback type overload for codec selector in custom pg columns (`codec: (config) => config?.withTimeZone ? 'timestamptz' : 'timestamp'`)
+- Extended list of postgis types for codecs (improvement for [#5711](https://github.com/drizzle-team/drizzle-orm/issues/5711))
+- Updated codecs: `geometry` -> `geometry(point)`, `geometry:tuple` -> `geometry(point):tuple`
+- Switched PG transactions from class properties back to class methods (fixes [#5709](https://github.com/drizzle-team/drizzle-orm/issues/5709))
+- Updated `AWS Data Api` codecs, removed query typings, improved input param mapping  
+- Removed prepared query `typings` field from all builders    
+- Added `column` argument to `CastParam`,`CastArrayParam` codecs
diff --git a/changelogs/drizzle-orm/1.0.0-rc.3.md b/changelogs/drizzle-orm/1.0.0-rc.3.md
new file mode 100644
index 0000000000..dbf8ad6029
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-rc.3.md
@@ -0,0 +1,10 @@
+# v1.0.0-rc.3
+
+Porting all the changes that were made in PostgreSQL to other dialects. This release is about MySQL:
+
+- Removed RQBv1 from `mysql` dialect (`._query`)
+- Internal MySQL sessions refactoring and moving to a unified query preparation function
+- Fallback to regular queries on iterators for drivers that don't support streaming instead of throwing an error for compatibility
+- Enabled optimized non-jit mappers for regular queries for MySQL dialect
+- Switched RQBv2 to array mode querying, disabled root query level JSON conversions
+- Fixed MySQL proxy driver not using `lastInsertId`, `affectedRows` from dedicated response fields
\ No newline at end of file
diff --git a/changelogs/drizzle-orm/1.0.0-rc.4.md b/changelogs/drizzle-orm/1.0.0-rc.4.md
new file mode 100644
index 0000000000..70e29225ee
--- /dev/null
+++ b/changelogs/drizzle-orm/1.0.0-rc.4.md
@@ -0,0 +1,66 @@
+# v1.0.0-rc.4
+
+- Fixed broken `View` types when using `Subquery` in selection  
+- Fixed custom types' JSON field API not being applied when column is used as a decoder on `SQL` fields  
+- Fixed codecs not getting applied to `SQL` field when `.mapWith(column)` is set  (fixes [#5724](https://github.com/drizzle-team/drizzle-orm/issues/5724))
+- Fixed `Subquery` fields' columns' codecs not being applied to subquery  
+- Fixed broken in `rc.3` `db.select` in `bun-sql/pg` driver (fixes [#5779](https://github.com/drizzle-team/drizzle-orm/issues/5779))  
+- Updated SQLite `db.$count` builder to include `.sync()` executor for sync drivers
+- Removed RQBv1 from `sqlite`, removed RQBv1 `TSchema`, `TFullSchema` arguments from `sqlite` entities' generics  
+- Fixed instances of `sqlite` query errors not being wrapped in `DrizzleQueryError` (`db.batch()` excluded due to api incompatibility)  
+- Fixed type error on `CockroachArrayBuilder` constructor caused by referencing internal field's type  
+- Removed `mapResult` method from `PreparedQuery` interface, removed `mapResult`, `mapBatchResult` from `pg` and `sqlite` raw queries  
+- Fixed wrong `bun-sqlite` run result type  
+- Switched `sqlite` RQBv2 to array mode  
+- Enabled optimized default query mappers for `sqlite`  
+- Reworked `sqlite` sessions: replaced per-driver `PreparedQuery` instances with executors passed via sessions, similar to current `postgresql` and `mysql` implementations, moved `useJitMappers` flag handling to dialect  
+- Fixed missing `string` overload on `.comment(sqlCommenterComment)` in query builders  
+- Supported nested transactions in `@tursodatabase/database`, `@tursodatabase/database-wasm`  
+- Added filesytem-less migrator for `@tursodatabase/database-wasm` at `drizzle-orm/tursodatbase/wasm-migrator`  
+- Split SQLite into `async`, `effect` versions (`sync` remains subtype of `async`)  
+- Removed `SQLiteSyncDialect`, `SQLiteAsyncDialect`, moved generic SQLite `async`\\`sync` migrators to `sqlite-core/async/session` as `migrateSync`, `migrateAsync` 
+- Fixed `sqlite` cache using same cache entry for different execute methods   
+- Moved `EffectDrizzlePgConfig` to `drizzle-orm/pg-core/effect/utils`  
+- Made `cache` field in `EffectCacheShape` optional  
+- Split `mysql` into `async`, `effect` versions
+- Added codec system to `mysql`
+- Fixed `mysql` `float` rounding to either 6 digits or double
+- Fixed `mysql` cropping `.000` from `timestamp(3)`
+- Moved subquery mapper selection from `dialect.buildSelection` to `orderSelectedFields`;
+- [`PG`, `MySQL`] Improved codec system in set operators:
+  - When different db types are crossed in a union, db casts them to type it deems as closest compatible to all types involved 
+  - If columns with codecs are set on both sides of union - codec of combined type will apply
+  - If only the left-hand side of union has field with codec - left hand side's codec is preserved
+  - If left-hand side field is devoid of codecs - field is not processed by codecs; 
+  - Set operator queries are switched from `[QUERY 1] UNION [QUERY 2]` to `SELECT ... FROM ([QUERY 1] UNION [QUERY 2]) "drizzle_union"` so cast codecs would apply after union's type mutation
+  - Retrieved data of union with different types still may be lossy due to db's own conversion
+- Bump required `effect` package versions to `4.0.0-beta.83`
+- Fixed `sql.param` passing `Placeholder` as expected input value to encoder function instead of `Placeholder`'s value type 
+- Fixed unguarded `Buffer` reference in `drizzle-orm/effect-schema` that caused error in environments without `Buffer`  
+- Fixed `sqlite` `blob` column runtime-type default mode mismatch (fixes [#1064](https://github.com/drizzle-team/drizzle-orm/issues/1064)) 
+- Improved typed `sql` operator - preserved nullability, inferred initial data type to `mapWith`callback argument, added `.nullable()` method to modify output type with `| null` (fixes [#571](https://github.com/drizzle-team/drizzle-orm/issues/571)): 
+  ```typescript
+    // Before:
+    sql<Type | null>`...`.mapWith((v: any) => String(v)) // Output type: string
+    // After:
+    sql<Type | null>`...`.mapWith((v: Type) => String(v)) // Output type: string | null
+    // `.nullable()` method:
+    sql`...`.mapWith((v: unknown) => new Type(v)).nullable() // Output type: Type | null
+  ```
+- Fixed `generatedByDefaultAsIdentity` columns not being filtered from inserts in runtime in `postgres` dialect  
+- Improved `db.insert(table).select(...)`: removed column order match requirement, allowed skipping selection for columns with defaults or nullability (fixes [#3608](https://github.com/drizzle-team/drizzle-orm/issues/3608))  
+
+## Drivers
+- Updated `@tursodatabase/database`, `@tursodatabase/database-wasm` to v0.6.0, updated session internals for asynchronous prepare on driver side  
+- Added `@tursodatabase/serverless` driver support  
+- Added `@tursodatabase/sync` driver support  
+- Added `@effect/sql-pglite` driver support  
+- Added `@effect/sql-sqlite-node` driver support  
+- Added `@effect/sql-sqlite-bun` driver support  
+- Added `@effect/sql-sqlite-do` driver support  
+- Added `@effect/sql-sqlite-wasm` driver support  
+- Added `@effect/sql-libsql` driver support  
+- Added `@effect/sql-d1` driver support  
+- Added `@effect/sql-mysql2` driver support
+- Fixed `@effect/sql-pg` driver returning object response instead of raw response on `db.execute`
+- `pg-proxy`: added dialect config to optional dialect creator callback
\ No newline at end of file
diff --git a/changelogs/drizzle-seed/0.3.2.md b/changelogs/drizzle-seed/0.3.2.md
new file mode 100644
index 0000000000..9a4c5fbcc7
--- /dev/null
+++ b/changelogs/drizzle-seed/0.3.2.md
@@ -0,0 +1,145 @@
+## Bug fixes
+
+- https://github.com/drizzle-team/drizzle-orm/issues/3914
+
+Both the `seed` and `reset` functions didn't include `LibSQLDatabase<any>` in their generic type parameters.
+As a result, the `seed` function accepts a `db` parameter like this:
+
+```ts
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "./schema.ts";
+
+const db = drizzle({
+  connection: {
+    url: "",
+    authToken: "",
+  },
+});
+
+await seed(db, schema);
+```
+
+But it will reject a `db` parameter defined like this:
+
+```ts
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "./schema.ts";
+
+const db = drizzle({
+  schema,
+  connection: {
+    url: "",
+    authToken: "",
+  },
+});
+
+await seed(db, schema);
+```
+
+- https://github.com/drizzle-team/drizzle-orm/issues/4194
+
+drizzle-seed misinterpreted `realEstateTypeEnum` enum as a `real` type.
+
+- https://github.com/drizzle-team/drizzle-orm/issues/3915
+
+drizzle seed breaks serial sequence sync with Postgres serial type.
+
+## Features
+
+- ignore column in refinements
+
+Now you can let drizzle-seed know if you want to ignore column during seeding.
+
+```ts
+// schema.ts
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+  age: integer(),
+  photo: text(),
+});
+```
+
+```ts
+// index.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { seed } from "drizzle-seed";
+import * as schema from "./schema.ts";
+
+async function main() {
+  const db = drizzle(process.env["DATABASE_URL"]!);
+  await seed(db, schema).refine((f) => ({
+    users: {
+      count: 5,
+      columns: {
+        name: f.fullName(),
+        photo: false, // the photo column will not be seeded, allowing the database to use its default value.
+      },
+    },
+  }));
+}
+
+main();
+```
+
+## Improvements
+
+- added minTime, maxTime parameters to `time` generator
+
+```ts
+await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
+  timeTable: {
+    count,
+    columns: {
+      time: funcs.time({
+        minTime: "13:12:13",
+        maxTime: "15:12:13",
+      }),
+    },
+  },
+}));
+```
+
+- added minTimestamp, maxTimestamp parameters to `timestamp` generator
+
+```ts
+await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
+  timestampTable: {
+    count,
+    columns: {
+      timestamp: funcs.timestamp({
+        minTimestamp: "2025-03-07 13:12:13.123Z",
+        maxTimestamp: "2025-03-09 15:12:13.456Z",
+      }),
+    },
+  },
+}));
+```
+
+- added minDatetime, maxDatetime parameters to `datetime` generator
+
+```ts
+await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
+  datetimeTable: {
+    count,
+    columns: {
+      datetime: funcs.datetime({
+        minDatetime: "2025-03-07 13:12:13Z",
+        maxDatetime: "2025-03-09 15:12:13Z",
+      }),
+    },
+  },
+}));
+```
+
+- exported `AbstractGenerator` so that users can build their own custom generator classes.
+
+- drizzle-seed now updates PostgreSQL sequences after seeding.
+
+  drizzle-seed iterates through each column in a table, selects columns of type smallint, integer, bigint, smallserial, serial, or bigserial, and (if a sequence exists) updates it to the column’s maximum seeded value.
+
+  ```sql
+  select setval(pg_get_serial_sequence('"schema_name"."table_name"', 'column_name'), 3, true);
+  ```
diff --git a/changelogs/drizzle-seed/0.4.0.md b/changelogs/drizzle-seed/0.4.0.md
new file mode 100644
index 0000000000..4ee0e88c5e
--- /dev/null
+++ b/changelogs/drizzle-seed/0.4.0.md
@@ -0,0 +1,295 @@
+## Features
+
+- ### Added support for MS SQL database
+
+```ts
+import { int, mssqlTable, text } from "drizzle-orm/mssql-core";
+import { drizzle } from "drizzle-orm/node-mssql";
+import { seed } from "drizzle-seed";
+
+const users = mssqlTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+});
+
+async function main() {
+  const db = drizzle(process.env.DATABASE_URL!);
+  await seed(db, { users });
+}
+
+main();
+```
+
+- ### Added support for CockroachDB database
+
+```ts
+import { cockroachTable, int4, text } from "drizzle-orm/cockroach-core";
+import { drizzle } from "drizzle-orm/cockroach";
+import { seed } from "drizzle-seed";
+
+const users = cockroachTable("users", {
+  id: int4().primaryKey(),
+  name: text().notNull(),
+});
+
+async function main() {
+  const db = drizzle(process.env.DATABASE_URL!);
+  await seed(db, { users });
+}
+
+main();
+```
+
+- ### Added support for SingleStore database
+
+```ts
+import { int, singlestoreTable, text } from "drizzle-orm/singlestore-core";
+import { drizzle } from "drizzle-orm/singlestore";
+import { seed } from "drizzle-seed";
+
+const users = singlestoreTable("users", {
+  id: int().primaryKey(),
+  name: text().notNull(),
+});
+
+async function main() {
+  const db = drizzle(process.env.DATABASE_URL!);
+  await seed(db, { users });
+}
+
+main();
+```
+
+- ### Added new generator `bitString` for CockroachDB and PostgreSQL `bit` type.
+
+#### Generates bit strings based on specified parameters:
+
+- param `isUnique` - property that controls if generated values gonna be unique or not;
+
+- param `arraySize` - number of elements in each one-dimensional array (If specified, arrays will be generated);
+
+- param `dimensions` - desired length of each bit string (e.g., `dimensions = 3` produces values like `'010'`).
+
+  Defaults to the value of the database column bit-length
+
+```ts
+await seed(db, { bitStringTable: schema.bitStringTable }).refine((funcs) => ({
+  bitStringTable: {
+    count,
+    columns: {
+      bit: funcs.bitString({
+        dimensions: 12,
+        isUnique: true,
+      }),
+    },
+  },
+}));
+```
+
+- ### Added new generator `inet` for CockroachDB and PostgreSQL `inet` type.
+
+#### Generates ip addresses based on specified parameters:
+
+- param `isUnique` - property that controls if generated values gonna be unique or not;
+
+- param `arraySize` - number of elements in each one-dimensional array (If specified, arrays will be generated);
+
+- param `ipAddress` - type of IP address to generate — either "ipv4" or "ipv6";
+
+  Defaults to `'ipv4'`
+
+- param `includeCidr` - determines whether generated IPs include a CIDR suffix.
+
+  Defaults to `true`
+
+```ts
+await seed(db, { inetTable: schema.inetTable }).refine((funcs) => ({
+  inetTable: {
+    count,
+    columns: {
+      inet: funcs.inet({
+        ipAddress: "ipv4",
+        includeCidr: true,
+        isUnique: true,
+      }),
+    },
+  },
+}));
+```
+
+- ### Added new generator `geometry` for CockroachDB and PostgreSQL `geometry` type.
+
+#### Generates PostGIS geometry objects based on the given parameters:
+
+- param `isUnique` - property that controls if generated values gonna be unique or not;
+
+- param `arraySize` - number of elements in each one-dimensional array (If specified, arrays will be generated);
+
+- param `type` - geometry type to generate; currently only `'point'` is supported;
+
+  Defaults to `'point'`
+
+- param `srid` - Spatial Reference System Identifier: determines what type of point will be generated - either `4326` or `3857`;
+
+  Defaults to `4326`
+
+- param `decimalPlaces` - number of decimal places for points when `srid` is `4326` (e.g., `decimalPlaces = 3` produces values like `'point(30.723 46.482)'`).
+
+  Defaults to `6`
+
+```ts
+await seed(db, { geometryTable: schema.geometryTable }).refine((funcs) => ({
+  geometryTable: {
+    count,
+    columns: {
+      geometryPointTuple: funcs.geometry({
+        type: "point",
+        srid: 4326,
+        decimalPlaces: 5,
+        isUnique: true,
+      }),
+    },
+  },
+}));
+```
+
+- ### Added new generator `vector` for CockroachDB, PostgreSQL and SingleStore `vector` type.
+
+#### Generates vectors based on the provided parameters:
+
+- param `isUnique` - property that controls if generated values gonna be unique or not;
+
+- param `arraySize` - number of elements in each one-dimensional array (If specified, arrays will be generated);
+
+- param `decimalPlaces` - number of decimal places for each vector element (e.g., `decimalPlaces = 3` produces values like `1.123`);
+
+  Defaults to `2`
+
+- param `dimensions` - number of elements in each generated vector (e.g., `dimensions = 3` produces values like `[1,2,3]`);
+
+  Defaults to the value of the database column's dimensions
+
+- param `minValue` - minimum allowed value for each vector element;
+
+  Defaults to `-1000`
+
+- param `maxValue` - maximum allowed value for each vector element.
+
+  Defaults to `1000`
+
+```ts
+await seed(db, { vectorTable: schema.vectorTable }).refine((funcs) => ({
+  vectorTable: {
+    count,
+    columns: {
+      vector: funcs.vector({
+        decimalPlaces: 5,
+        dimensions: 12,
+        minValue: -100,
+        maxValue: 100,
+        isUnique: true,
+      }),
+    },
+  },
+}));
+```
+
+- ### Added support for composite unique constraints
+
+  #### Example:
+
+  Table with a composite unique constraint:
+
+  ```ts
+  import { integer, pgTable, text, unique } from "drizzle-orm/pg-core";
+
+  const composite = pgTable(
+    "composite_example",
+    {
+      id: integer("id").notNull(),
+      name: text("name").notNull(),
+    },
+    (t) => [unique("custom_name").on(t.id, t.name)]
+  );
+  ```
+
+  Seeding script:
+
+  ```ts
+  await seed(db, { composite: composite }, { count: 16 }).refine((funcs) => ({
+    composite: {
+      columns: {
+        id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+        name: funcs.valuesFromArray({ values: ["a", "b", "c", "d"] }),
+      },
+    },
+  }));
+  ```
+
+  #### Limitations:
+
+  - Seeding is not supported when two composite unique constraints share a column:
+    ```ts
+    const composite = pgTable(
+      "composite_example",
+      {
+        id: integer("id").notNull(),
+        name: text("name").notNull(),
+        slug: text("slug").notNull(),
+      },
+      (t) => [
+        unique("custom_name").on(t.id, t.name),
+        unique("custom_name1").on(t.name, t.slug),
+      ]
+    );
+    ```
+    This is allowed, however, if one of the constraints is a single-column unique constraint:
+    ```ts
+    unique("custom_name1").on(t.name);
+    ```
+  - You can’t use a generator that doesn’t expose an `isUnique` option in its config, unless it’s one of the always-unique generators: `intPrimaryKey`, `email`, `phoneNumber`, or `uuid`.
+
+## Bug Fixes
+
+- fixed type error in `seed` and `reset` functions when using a drizzle db instance that was created with a schema in `DrizzleConfig`.
+
+  https://github.com/drizzle-team/drizzle-orm/issues/4435
+
+## Breaking changes
+
+### Hash generating function was changed and upgraded to v3
+
+```ts
+await seed(db, { table }).refine((f) => ({
+  table: {
+    columns: {
+      // all generators will output different values compared to the previous version, even with the same seed number.
+      column1: f.interval({ isUnique: true }),
+    }
+  }
+}))
+```
+
+**Reason for upgrade**
+
+The previous version of the hash generating function generated different hashes depending on whether Bun or Node.js was used, and hashes also varied across versions of Node.js.
+
+The new hash generating function will generate the same hash regardless of the version of Node.js or Bun, resulting in deterministic data generation across all versions.
+
+**Usage**
+```ts
+await seed(db, schema);
+// or explicit
+await seed(db, schema, { version: '3' });
+```
+
+**Switch to the old version**
+
+The previous version of hash generating function is v1.
+```ts
+await seed(db, schema, { version: '1' });
+```
+To use the v2 generators while maintaining the v1 hash generating function:
+```ts
+await seed(db, schema, { version: '2' });
+```
diff --git a/changelogs/drizzle-seed/1.0.0-beta.13.md b/changelogs/drizzle-seed/1.0.0-beta.13.md
new file mode 100644
index 0000000000..1ba88604b3
--- /dev/null
+++ b/changelogs/drizzle-seed/1.0.0-beta.13.md
@@ -0,0 +1,3 @@
+## Bug fixes
+
+- [Fixed an error when seeding a composite unique column that includes a foreign key](https://github.com/drizzle-team/drizzle-orm/issues/4354)
\ No newline at end of file
diff --git a/changelogs/drizzle-seed/1.0.0-beta.8.md b/changelogs/drizzle-seed/1.0.0-beta.8.md
new file mode 100644
index 0000000000..d09a339639
--- /dev/null
+++ b/changelogs/drizzle-seed/1.0.0-beta.8.md
@@ -0,0 +1,168 @@
+## Bug fixes
+
+- [[BUG]: drizzle seed doesn't work with libSQL](https://github.com/drizzle-team/drizzle-orm/issues/3914)
+- [[BUG]: Seed UUIDs not compatible with Zod/v4](https://github.com/drizzle-team/drizzle-orm/issues/4551)
+- [[BUG]: drizzle seed generates invalid input value (number) for enum strings (pg)](https://github.com/drizzle-team/drizzle-orm/issues/4194)
+- [[BUG]: drizzle seed breaks serial sequence sync with Postgres serial type](https://github.com/drizzle-team/drizzle-orm/issues/3915)
+
+## Features
+
+### ignore column in refinements
+
+Now you can let drizzle-seed know if you want to ignore column during seeding.
+
+```ts
+// schema.ts
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+  age: integer(),
+  photo: text(),
+});
+```
+
+```ts
+// index.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { seed } from "drizzle-seed";
+import * as schema from "./schema.ts";
+
+async function main() {
+  const db = drizzle(process.env["DATABASE_URL"]!);
+  await seed(db, schema).refine((f) => ({
+    users: {
+      count: 5,
+      columns: {
+        name: f.fullName(),
+        photo: false, // the photo column will not be seeded, allowing the database to use its default value.
+      },
+    },
+  }));
+}
+
+main();
+```
+
+## Improvements
+
+### Added `min`, `max` parameters to `time` generator
+
+```ts
+await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
+  timeTable: {
+    count,
+    columns: {
+      time: funcs.time({
+        min: "13:12:13",
+        max: "15:12:13",
+      }),
+    },
+  },
+}));
+```
+
+### Added `min`, `max` parameters to `timestamp` generator
+
+```ts
+await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
+  timestampTable: {
+    count,
+    columns: {
+      timestamp: funcs.timestamp({
+        min: "2025-03-07 13:12:13.123Z",
+        max: "2025-03-09 15:12:13.456Z",
+      }),
+    },
+  },
+}));
+```
+
+### Added `min`, `max` parameters to `datetime` generator
+
+```ts
+await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
+  datetimeTable: {
+    count,
+    columns: {
+      datetime: funcs.datetime({
+        min: "2025-03-07 13:12:13Z",
+        max: "2025-03-09 15:12:13Z",
+      }),
+    },
+  },
+}));
+```
+
+### PostgreSQL sequences updating after seed
+
+`drizzle-seed` iterates through each column in a table, selects columns of type smallint, integer, bigint, smallserial, serial, or bigserial, and (if a sequence exists) updates it to the column’s maximum seeded value.
+
+```sql
+select setval(pg_get_serial_sequence('"schema_name"."table_name"', 'column_name'), 3, true);
+```
+
+## Breaking changes
+
+### `uuid` generator was changed and upgraded to v4
+
+```ts
+await seed(db, { table }).refine((f) => ({
+  table: {
+    columns: {
+      // AA97B177-9383-4934-8543-0F91A7A02836
+      //                    ^
+      //                    1
+      // the digit at position 1 is always one of '8', '9', 'A' or 'B'
+      column1: f.uuid(),
+    }
+  }
+}))
+```
+
+**Reason for upgrade**
+
+UUID values generated by the old version of the `uuid` generator fail Zod’s v4 UUID validation.
+
+example
+```ts
+import { createSelectSchema } from 'drizzle-zod';
+import { seed } from 'drizzle-seed';
+
+await seed(db, { uuidTest: schema.uuidTest }, { count: 1 }).refine((funcs) => ({
+		uuidTest: {
+			columns: {
+				col1: funcs.uuid()
+			}
+		}
+	})
+);
+
+const uuidSelectSchema = createSelectSchema(schema.uuidTest);
+const res = await db.select().from(schema.uuidTest);
+// the line below will throw an error when using old version of uuid generator
+uuidSelectSchema.parse(res[0]);
+```
+
+**Usage**
+```ts
+await seed(db, schema);
+// or explicit
+await seed(db, schema, { version: '4' });
+```
+
+**Switch to the old version**
+
+The previous version of `uuid` generator is v1.
+```ts
+await seed(db, schema, { version: '1' });
+```
+To use the v2 generators while maintaining the v1 `uuid` generator:
+```ts
+await seed(db, schema, { version: '2' });
+```
+To use the v3 generators while maintaining the v1 `uuid` generator:
+```ts
+await seed(db, schema, { version: '3' });
+```
\ No newline at end of file
diff --git a/changelogs/drizzle-zod/0.8.3.md b/changelogs/drizzle-zod/0.8.3.md
new file mode 100644
index 0000000000..6906352a0f
--- /dev/null
+++ b/changelogs/drizzle-zod/0.8.3.md
@@ -0,0 +1 @@
+- Update peerDeps for zod
\ No newline at end of file
diff --git a/clean.ts b/clean.ts
new file mode 100644
index 0000000000..8a05413fd7
--- /dev/null
+++ b/clean.ts
@@ -0,0 +1,33 @@
+// import { existsSync, lstatSync, readdirSync, rmSync } from 'node:fs';
+// import { join } from 'node:path';
+
+// const printTree = (path: string, indentation: number) => {
+// 	for (const it of readdirSync(path)) {
+// 		if (it === 'node_modules') continue;
+// 		if (it === '.git') continue;
+// 		if (it === '.github') continue;
+// 		if (it === '.turbo') continue;
+// 		if (it === 'dist') continue;
+
+// 		const full = join(path, it);
+// 		const stat = existsSync(full) ? lstatSync(full) : undefined;
+// 		if (!stat) continue;
+
+// 		if (stat.isDirectory()) {
+// 			printTree(full, indentation + 1);
+// 		} else {
+// 			if (
+// 				full.endsWith('.js')
+// 				&& existsSync(full.replace('.js', '.js.map'))
+// 				&& existsSync(full.replace('.js', '.ts'))
+// 			) {
+// 				console.log(full);
+// 				rmSync(full);
+// 				rmSync(full.replace('.js', '.js.map'));
+// 			}
+// 		}
+// 	}
+// };
+
+// I've accidentally ran tsc which generated .d.ts files for all ts files in repo
+// printTree(".");
diff --git a/compose/cockroach-many.yml b/compose/cockroach-many.yml
new file mode 100644
index 0000000000..a1682b12fe
--- /dev/null
+++ b/compose/cockroach-many.yml
@@ -0,0 +1,36 @@
+services:
+  cockroach0:
+    image: cockroachdb/cockroach:v25.2.0
+    command: start-single-node --insecure --store=type=mem,size=2GiB
+    ports:
+      - "26260:26257"
+      - "8081:8080"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 26257"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
+
+  cockroach1:
+    image: cockroachdb/cockroach:v25.2.0
+    command: start-single-node --insecure --store=type=mem,size=2GiB
+    ports:
+      - "26261:26257"
+      - "8082:8080"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 26257"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
+
+  cockroach2:
+    image: cockroachdb/cockroach:v25.2.0
+    command: start-single-node --insecure --store=type=mem,size=2GiB
+    ports:
+      - "26262:26257"
+      - "8083:8080"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 26257"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
diff --git a/compose/cockroach.yml b/compose/cockroach.yml
new file mode 100644
index 0000000000..d67f6e8b10
--- /dev/null
+++ b/compose/cockroach.yml
@@ -0,0 +1,12 @@
+services:
+  cockroach:
+    image: cockroachdb/cockroach:v25.2.0
+    command: start-single-node --insecure --store=type=mem,size=2GiB
+    ports:
+      - "26257:26257"
+      - "8080:8080"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 26257"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
diff --git a/compose/dockers.sh b/compose/dockers.sh
new file mode 100644
index 0000000000..0f924f4dc9
--- /dev/null
+++ b/compose/dockers.sh
@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ALL_DIALECTS=(
+  postgres
+  postgres16
+  postgres17
+  postgres18
+  postgres-postgis
+  postgres-vector
+  mysql
+  mariadb
+  cockroach
+  cockroach-many
+  mssql
+  singlestore
+  singlestore-many
+)
+
+_resolve_compose_file() {
+  case "$1" in
+    postgres)         echo "postgres.yml" ;;
+    postgres16)       echo "postgres16.yml" ;;
+    postgres17)       echo "postgres17.yml" ;;
+    postgres18)       echo "postgres18.yml" ;;
+    postgres-postgis) echo "postgres-postgis.yml" ;;
+    postgres-vector)  echo "postgres-vector.yml" ;;
+    mysql)            echo "mysql.yml" ;;
+    mariadb)          echo "mariadb.yml" ;;
+    cockroach)        echo "cockroach.yml" ;;
+    cockroach-many)   echo "cockroach-many.yml" ;;
+    mssql)            echo "mssql.yml" ;;
+    singlestore)      echo "singlestore.yml" ;;
+    singlestore-many) echo "singlestore-many.yml" ;;
+    *)
+      echo "Unknown dialect '$1'. Valid dialects: ${ALL_DIALECTS[*]}" >&2
+      return 1
+      ;;
+  esac
+}
+
+_compose() {
+  local dialect="$1"; shift
+  local file
+  file="$(_resolve_compose_file "$dialect")"
+  docker compose -p "drizzle-${dialect}" -f "compose/${file}" "$@"
+}
+
+_up_one() {
+  local dialect="$1"
+  _compose "$dialect" up -d --wait --wait-timeout 120
+  bash compose/wait.sh "$dialect"
+}
+
+_down_one() {
+  local dialect="$1"
+  _compose "$dialect" down -v
+}
+
+_ps_one() {
+  local dialect="$1"
+  _compose "$dialect" ps
+}
+
+_validate_all() {
+  local dialect
+  for dialect in "$@"; do
+    _resolve_compose_file "$dialect" >/dev/null
+  done
+}
+
+cmd_up() {
+  if [ "$#" -eq 0 ]; then
+    set -- "${ALL_DIALECTS[@]}"
+  else
+    _validate_all "$@"
+  fi
+  local dialect
+  for dialect in "$@"; do
+    _up_one "$dialect"
+  done
+}
+
+cmd_down() {
+  if [ "$#" -eq 0 ]; then
+    set -- "${ALL_DIALECTS[@]}"
+  else
+    _validate_all "$@"
+  fi
+  local dialect
+  for dialect in "$@"; do
+    _down_one "$dialect"
+  done
+}
+
+cmd_ps() {
+  if [ "$#" -eq 0 ]; then
+    set -- "${ALL_DIALECTS[@]}"
+  else
+    _validate_all "$@"
+  fi
+  local dialect
+  for dialect in "$@"; do
+    _ps_one "$dialect"
+  done
+}
+
+cmd_logs() {
+  if [ "$#" -ne 1 ]; then
+    echo "Usage: bash compose/dockers.sh logs <dialect>" >&2
+    return 1
+  fi
+  _validate_all "$1"
+  _compose "$1" logs --tail=200 -f
+}
+
+cmd_wait() {
+  if [ "$#" -lt 1 ]; then
+    echo "Usage: bash compose/dockers.sh wait <dialect> [<dialect> ...]" >&2
+    return 1
+  fi
+  bash compose/wait.sh "$@"
+}
+
+cmd_help() {
+  cat <<EOF
+Usage: bash compose/dockers.sh <subcommand> [<dialect> ...]
+
+Subcommands:
+  up    [<dialect> ...]   Start dialect(s) via docker compose, then gate on compose/wait.sh.
+                          With no args, starts every supported dialect.
+  down  [<dialect> ...]   Tear down dialect(s) with 'down -v' (volumes wiped).
+                          With no args, tears down every supported dialect.
+  ps    [<dialect> ...]   Show containers for dialect(s). No args -> all.
+  logs  <dialect>         Tail logs for one dialect (docker compose logs --tail=200 -f).
+  wait  <dialect> ...     Probe TCP readiness via compose/wait.sh.
+  help                    Show this message.
+
+Each invocation passes -p drizzle-<dialect> so projects do not collide.
+
+Valid dialects: ${ALL_DIALECTS[*]}
+
+Examples:
+  bash compose/dockers.sh up postgres mysql
+  bash compose/dockers.sh down
+  bash compose/dockers.sh logs mariadb
+EOF
+}
+
+main() {
+  local cmd
+  local args=()
+  if [ "$#" -eq 0 ]; then
+    cmd=up
+  else
+    cmd="$1"; shift
+    args=("$@")
+  fi
+
+  case "$cmd" in
+    up)               cmd_up ${args[@]+"${args[@]}"} ;;
+    down)             cmd_down ${args[@]+"${args[@]}"} ;;
+    ps)               cmd_ps ${args[@]+"${args[@]}"} ;;
+    logs)             cmd_logs ${args[@]+"${args[@]}"} ;;
+    wait)             cmd_wait ${args[@]+"${args[@]}"} ;;
+    help|-h|--help)   cmd_help ;;
+    *)
+      echo "Unknown subcommand '$cmd'." >&2
+      cmd_help >&2
+      return 1
+      ;;
+  esac
+}
+
+main "$@"
diff --git a/compose/lint.sh b/compose/lint.sh
new file mode 100644
index 0000000000..32b6dd0e44
--- /dev/null
+++ b/compose/lint.sh
@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Always run from repo root
+PROJECT_ROOT="$(git rev-parse --show-toplevel)"
+cd "$PROJECT_ROOT"
+
+# Name of the pnpm store volume used as cache between runs
+PNPM_STORE_VOLUME="pnpm-store"
+PNPM_COREPACK_CACHE_VOLUME="pnpm-corepack-cache"
+APK_CACHE_VOLUME="apk-cache"
+
+docker run --rm \
+  -e CI=1 \
+  -v "$PROJECT_ROOT":/src \
+  -v "${PNPM_STORE_VOLUME}":/pnpm/store \
+  -v "${PNPM_COREPACK_CACHE_VOLUME}":/root/.cache \
+  -v "${APK_CACHE_VOLUME}":/var/cache/apk \
+  node:24-alpine \
+  sh -lc '
+    set -euo pipefail
+
+    apk add --no-cache git >/dev/null
+
+    APP_DIR="$(mktemp -d)"
+
+    tar \
+      --exclude="node_modules" \
+      --exclude="*/node_modules" \
+      --exclude=".turbo" \
+      --exclude=".git" \
+      --exclude=".pnpm-store" \
+      --exclude="dist" \
+      --exclude="*/dist" \
+      --exclude="coverage" \
+      -C /src \
+      -cf - . \
+      | tar -C "$APP_DIR" -xf -
+
+    rm -rf "$APP_DIR/.git"
+    ln -s /src/.git "$APP_DIR/.git"
+
+    cd "$APP_DIR"
+
+    export PNPM_HOME=/pnpm
+    export PNPM_STORE_DIR=/pnpm/store
+    export PATH="$PNPM_HOME:$PATH"
+
+    corepack enable pnpm
+
+    pnpm install \
+      --frozen-lockfile \
+      --prefer-offline \
+      --ignore-scripts \
+      --filter .
+
+    pnpm lint-staged
+  '
diff --git a/compose/mariadb.yml b/compose/mariadb.yml
new file mode 100644
index 0000000000..fe24a9845a
--- /dev/null
+++ b/compose/mariadb.yml
@@ -0,0 +1,15 @@
+services:
+  mariadb:
+    image: mariadb:11.8
+    environment:
+      MARIADB_ROOT_PASSWORD: mariadb
+      MARIADB_DATABASE: drizzle
+      TZ: UTC
+    ports:
+      - "33306:3306"
+    healthcheck:
+      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
+      interval: 2s
+      timeout: 3s
+      retries: 40
+      start_period: 10s
diff --git a/compose/mssql.yml b/compose/mssql.yml
new file mode 100644
index 0000000000..45e49ade41
--- /dev/null
+++ b/compose/mssql.yml
@@ -0,0 +1,14 @@
+services:
+  mssql:
+    image: mcr.microsoft.com/azure-sql-edge:latest
+    environment:
+      ACCEPT_EULA: "1"
+      MSSQL_SA_PASSWORD: "drizzle123PASSWORD!"
+      TZ: UTC
+    ports:
+      - "1433:1433"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 1433"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
diff --git a/compose/mysql.yml b/compose/mysql.yml
new file mode 100644
index 0000000000..8ba9c8d49c
--- /dev/null
+++ b/compose/mysql.yml
@@ -0,0 +1,15 @@
+services:
+  mysql:
+    image: mysql:8
+    environment:
+      MYSQL_ROOT_PASSWORD: mysql
+      MYSQL_DATABASE: drizzle
+      TZ: UTC
+    ports:
+      - "3306:3306"
+    healthcheck:
+      test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -proot --silent"]
+      interval: 2s
+      timeout: 3s
+      retries: 40
+
diff --git a/compose/postgres-postgis.yml b/compose/postgres-postgis.yml
new file mode 100644
index 0000000000..c1278309e5
--- /dev/null
+++ b/compose/postgres-postgis.yml
@@ -0,0 +1,15 @@
+services: 
+  postgres-postgis:
+    image: postgis/postgis:16-3.4
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "54322:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
diff --git a/compose/postgres-vector.yml b/compose/postgres-vector.yml
new file mode 100644
index 0000000000..57d05cefe6
--- /dev/null
+++ b/compose/postgres-vector.yml
@@ -0,0 +1,15 @@
+services: 
+  postgres-vector:
+    image: pgvector/pgvector:pg16
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "54321:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
\ No newline at end of file
diff --git a/compose/postgres.yml b/compose/postgres.yml
new file mode 100644
index 0000000000..927453795c
--- /dev/null
+++ b/compose/postgres.yml
@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: postgres:17-alpine # change to 18-alpine when ready
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "55433:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
diff --git a/compose/postgres16.yml b/compose/postgres16.yml
new file mode 100644
index 0000000000..c2a39d8bcf
--- /dev/null
+++ b/compose/postgres16.yml
@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: pgvector/pgvector:pg16
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "54323:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
diff --git a/compose/postgres17.yml b/compose/postgres17.yml
new file mode 100644
index 0000000000..9ac082ef4e
--- /dev/null
+++ b/compose/postgres17.yml
@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: pgvector/pgvector:pg17
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "54324:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
diff --git a/compose/postgres18.yml b/compose/postgres18.yml
new file mode 100644
index 0000000000..22c22cf1b2
--- /dev/null
+++ b/compose/postgres18.yml
@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: pgvector/pgvector:pg18
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: drizzle
+      TZ: UTC
+    ports:
+      - "54325:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d drizzle"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
diff --git a/compose/singlestore-many.yml b/compose/singlestore-many.yml
new file mode 100644
index 0000000000..6e022acfc9
--- /dev/null
+++ b/compose/singlestore-many.yml
@@ -0,0 +1,52 @@
+services:
+  singlestore0:
+    image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
+    environment:
+      ROOT_PASSWORD: singlestore
+      TZ: UTC
+    ports:
+      - "3308:3306"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 3306"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
+
+  singlestore1:
+    image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
+    environment:
+      ROOT_PASSWORD: singlestore
+      TZ: UTC
+    ports:
+      - "3309:3306"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 3306"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
+
+  singlestore2:
+    image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
+    environment:
+      ROOT_PASSWORD: singlestore
+      TZ: UTC
+    ports:
+      - "3310:3306"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 3306"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
+
+  singlestore3:
+    image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
+    environment:
+      ROOT_PASSWORD: singlestore
+      TZ: UTC
+    ports:
+      - "3311:3306"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 3306"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
diff --git a/compose/singlestore.yml b/compose/singlestore.yml
new file mode 100644
index 0000000000..ecd4a3c815
--- /dev/null
+++ b/compose/singlestore.yml
@@ -0,0 +1,13 @@
+services:
+  singlestore:
+    image: ghcr.io/singlestore-labs/singlestoredb-dev:0.2.67
+    environment:
+      ROOT_PASSWORD: singlestore
+      TZ: UTC
+    ports:
+      - "33307:3306"
+    healthcheck:
+      test: ["CMD", "bash", "-lc", "nc -z 127.0.0.1 3306"]
+      interval: 2s
+      timeout: 3s
+      retries: 60
diff --git a/compose/wait.sh b/compose/wait.sh
new file mode 100644
index 0000000000..1427b0e1c6
--- /dev/null
+++ b/compose/wait.sh
@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+wait_tcp() {
+  host="$1"; port="$2"; name="$3"; tries="${4:-120}"
+  for i in $(seq 1 "$tries"); do
+    if nc -z "$host" "$port" >/dev/null 2>&1; then
+      echo "$name is up on $host:$port"
+      return 0
+    fi
+    sleep 1
+  done
+  echo "Timed out waiting for $name on $host:$port" >&2
+  return 1
+}
+
+for db in "$@"; do
+  case "$db" in
+    postgres)             wait_tcp 127.0.0.1 55433 "postgres" ;;
+    postgres-postgis)     wait_tcp 127.0.0.1 54322 "postgres" ;;
+    postgres-vector)      wait_tcp 127.0.0.1 54321 "postgres" ;;
+    postgres18)           wait_tcp 127.0.0.1 54325 "postgres" ;;
+    postgres17)           wait_tcp 127.0.0.1 54324 "postgres" ;;
+    postgres16)           wait_tcp 127.0.0.1 54323 "postgres" ;;
+    mariadb)              wait_tcp 127.0.0.1 33306 "mariadb" ;;
+    mysql)                wait_tcp 127.0.0.1 3306  "mysql" ;;
+    singlestore)          wait_tcp 127.0.0.1 33307 "singlestore" ;;
+    singlestore-many)
+      # loop through 5 ports (33307–33311)
+      for i in $(seq 3308 3311); do
+        wait_tcp 127.0.0.1 "$i" "singlestore-$((i-3308))"
+      done
+      ;;
+    mssql)                wait_tcp 127.0.0.1 1433  "mssql" ;;
+    cockroach)            wait_tcp 127.0.0.1 26257 "cockroach" ;;
+    cockroach-many)
+      for i in $(seq 26260 26262); do
+        wait_tcp 127.0.0.1 "$i" "cockroach-$((i-26260))"
+      done
+      ;;
+    neon)                 wait_tcp 127.0.0.1 5446  "neon-serverless" ;;
+    *) echo "Unknown db '$db'" >&2; exit 1 ;;
+  esac
+done
diff --git a/dprint.json b/dprint.json
index 385b610b65..45652bc0f2 100644
--- a/dprint.json
+++ b/dprint.json
@@ -22,12 +22,13 @@
 		"**/_journal.json",
 		"**/tsup.config*.mjs",
 		"**/.sst",
+		"rollup.config-*.mjs",
 		"integration-tests/tests/prisma/*/client",
 		"integration-tests/tests/prisma/*/drizzle"
 	],
 	"plugins": [
-		"https://plugins.dprint.dev/typescript-0.91.1.wasm",
-		"https://plugins.dprint.dev/json-0.19.3.wasm",
-		"https://plugins.dprint.dev/markdown-0.17.1.wasm"
+		"https://unpkg.com/@dprint/typescript@0.91.1/plugin.wasm",
+		"https://unpkg.com/@dprint/json@0.19.3/plugin.wasm",
+		"https://unpkg.com/@dprint/markdown@0.17.1/plugin.wasm"
 	]
 }
diff --git a/drizzle-arktype/README.md b/drizzle-arktype/README.md
deleted file mode 100644
index b99d8f6aae..0000000000
--- a/drizzle-arktype/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-`drizzle-arktype` is a plugin for [Drizzle ORM](https://github.com/drizzle-team/drizzle-orm) that allows you to generate [arktype](https://arktype.io/) schemas from Drizzle ORM schemas.
-
-**Features**
-
-- Create a select schema for tables, views and enums.
-- Create insert and update schemas for tables.
-- Supports all dialects: PostgreSQL, MySQL and SQLite.
-
-# Usage
-
-```ts
-import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import { createInsertSchema, createSelectSchema } from 'drizzle-arktype';
-import { type } from 'arktype';
-
-const users = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-	role: text('role', { enum: ['admin', 'user'] }).notNull(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-// Schema for inserting a user - can be used to validate API requests
-const insertUserSchema = createInsertSchema(users);
-
-// Schema for updating a user - can be used to validate API requests
-const updateUserSchema = createUpdateSchema(users);
-
-// Schema for selecting a user - can be used to validate API responses
-const selectUserSchema = createSelectSchema(users);
-
-// Overriding the fields
-const insertUserSchema = createInsertSchema(users, {
-	role: type('string'),
-});
-
-// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
-const insertUserSchema = createInsertSchema(users, {
-	id: (schema) => schema.atLeast(1),
-	role: type('string'),
-});
-
-// Usage
-
-const isUserValid = parse(insertUserSchema, {
-	name: 'John Doe',
-	email: 'johndoe@test.com',
-	role: 'admin',
-});
-```
diff --git a/drizzle-arktype/benchmarks/types.ts b/drizzle-arktype/benchmarks/types.ts
deleted file mode 100644
index c9318de72b..0000000000
--- a/drizzle-arktype/benchmarks/types.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { bench, setup } from '@ark/attest';
-import { type } from 'arktype';
-import { boolean, integer, pgTable, text } from 'drizzle-orm/pg-core';
-import { createSelectSchema } from '~/index.ts';
-
-const users = pgTable('users', {
-	id: integer().primaryKey(),
-	firstName: text().notNull(),
-	middleName: text(),
-	lastName: text().notNull(),
-	age: integer().notNull(),
-	admin: boolean().notNull().default(false),
-});
-
-const teardown = setup();
-
-bench('select schema', () => {
-	return createSelectSchema(users);
-}).types([13129, 'instantiations']);
-
-bench('select schema with refinements', () => {
-	return createSelectSchema(users, {
-		firstName: (t) => t.atMostLength(100),
-		middleName: (t) => t.atMostLength(100),
-		lastName: (t) => t.atMostLength(100),
-		age: type.number.atLeast(1),
-	});
-}).types([21631, 'instantiations']);
-
-teardown();
diff --git a/drizzle-arktype/package.json b/drizzle-arktype/package.json
deleted file mode 100644
index a5da601b39..0000000000
--- a/drizzle-arktype/package.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
-	"name": "drizzle-arktype",
-	"version": "0.1.3",
-	"description": "Generate arktype schemas from Drizzle ORM schemas",
-	"type": "module",
-	"scripts": {
-		"build": "tsx scripts/build.ts",
-		"b": "pnpm build",
-		"test:types": "cd tests && tsc",
-		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
-		"publish": "npm publish package.tgz",
-		"test": "vitest run",
-		"bench:types": "tsx ./benchmarks/types.ts"
-	},
-	"exports": {
-		".": {
-			"import": {
-				"types": "./index.d.mts",
-				"default": "./index.mjs"
-			},
-			"require": {
-				"types": "./index.d.cjs",
-				"default": "./index.cjs"
-			},
-			"types": "./index.d.ts",
-			"default": "./index.mjs"
-		}
-	},
-	"main": "./index.cjs",
-	"module": "./index.mjs",
-	"types": "./index.d.ts",
-	"publishConfig": {
-		"provenance": true
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/drizzle-team/drizzle-orm.git"
-	},
-	"keywords": [
-		"arktype",
-		"validate",
-		"validation",
-		"schema",
-		"drizzle",
-		"orm",
-		"pg",
-		"mysql",
-		"postgresql",
-		"postgres",
-		"sqlite",
-		"database",
-		"sql",
-		"typescript",
-		"ts"
-	],
-	"author": "Drizzle Team",
-	"license": "Apache-2.0",
-	"peerDependencies": {
-		"arktype": ">=2.0.0",
-		"drizzle-orm": ">=0.36.0"
-	},
-	"devDependencies": {
-		"@ark/attest": "^0.45.8",
-		"@rollup/plugin-typescript": "^11.1.0",
-		"@types/node": "^18.15.10",
-		"arktype": "^2.1.10",
-		"cpy": "^10.1.0",
-		"drizzle-orm": "link:../drizzle-orm/dist",
-		"json-rules-engine": "7.3.1",
-		"rimraf": "^5.0.0",
-		"rollup": "^3.29.5",
-		"tsx": "^4.19.3",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
-		"zx": "^7.2.2"
-	}
-}
diff --git a/drizzle-arktype/rollup.config.ts b/drizzle-arktype/rollup.config.ts
deleted file mode 100644
index dfc5346b60..0000000000
--- a/drizzle-arktype/rollup.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-export default defineConfig([
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				format: 'esm',
-				dir: 'dist',
-				entryFileNames: '[name].mjs',
-				chunkFileNames: '[name]-[hash].mjs',
-				sourcemap: true,
-			},
-			{
-				format: 'cjs',
-				dir: 'dist',
-				entryFileNames: '[name].cjs',
-				chunkFileNames: '[name]-[hash].cjs',
-				sourcemap: true,
-			},
-		],
-		external: [
-			/^drizzle-orm\/?/,
-			'arktype',
-		],
-		plugins: [
-			typescript({
-				tsconfig: 'tsconfig.build.json',
-			}),
-		],
-	},
-]);
diff --git a/drizzle-arktype/scripts/build.ts b/drizzle-arktype/scripts/build.ts
deleted file mode 100755
index 07330ffd0a..0000000000
--- a/drizzle-arktype/scripts/build.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
-
-await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await fs.copy('package.json', 'dist/package.json');
-await $`scripts/fix-imports.ts`;
diff --git a/drizzle-arktype/scripts/fix-imports.ts b/drizzle-arktype/scripts/fix-imports.ts
deleted file mode 100755
index a90057c5b9..0000000000
--- a/drizzle-arktype/scripts/fix-imports.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-
-import path from 'node:path';
-import { parse, print, visit } from 'recast';
-import parser from 'recast/parsers/typescript';
-
-function resolvePathAlias(importPath: string, file: string) {
-	if (importPath.startsWith('~/')) {
-		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
-		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
-	}
-
-	return importPath;
-}
-
-function fixImportPath(importPath: string, file: string, ext: string) {
-	importPath = resolvePathAlias(importPath, file);
-
-	if (!/\..*\.(js|ts)$/.test(importPath)) {
-		return importPath;
-	}
-
-	return importPath.replace(/\.(js|ts)$/, ext);
-}
-
-const cjsFiles = await glob('dist/**/*.{cjs,d.cts}');
-
-await Promise.all(cjsFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitCallExpression(path) {
-			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
-				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-let esmFiles = await glob('dist/**/*.{js,d.ts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.js');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-esmFiles = await glob('dist/**/*.{mjs,d.mts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
diff --git a/drizzle-arktype/src/column.ts b/drizzle-arktype/src/column.ts
deleted file mode 100644
index 0532fed2d9..0000000000
--- a/drizzle-arktype/src/column.ts
+++ /dev/null
@@ -1,294 +0,0 @@
-import { type Type, type } from 'arktype';
-import type { Column, ColumnBaseConfig } from 'drizzle-orm';
-import type {
-	MySqlBigInt53,
-	MySqlChar,
-	MySqlDouble,
-	MySqlFloat,
-	MySqlInt,
-	MySqlMediumInt,
-	MySqlReal,
-	MySqlSerial,
-	MySqlSmallInt,
-	MySqlText,
-	MySqlTinyInt,
-	MySqlVarChar,
-	MySqlYear,
-} from 'drizzle-orm/mysql-core';
-import type {
-	PgArray,
-	PgBigInt53,
-	PgBigSerial53,
-	PgBinaryVector,
-	PgChar,
-	PgDoublePrecision,
-	PgGeometry,
-	PgGeometryObject,
-	PgHalfVector,
-	PgInteger,
-	PgLineABC,
-	PgLineTuple,
-	PgPointObject,
-	PgPointTuple,
-	PgReal,
-	PgSerial,
-	PgSmallInt,
-	PgSmallSerial,
-	PgUUID,
-	PgVarchar,
-	PgVector,
-} from 'drizzle-orm/pg-core';
-import type {
-	SingleStoreBigInt53,
-	SingleStoreChar,
-	SingleStoreDouble,
-	SingleStoreFloat,
-	SingleStoreInt,
-	SingleStoreMediumInt,
-	SingleStoreReal,
-	SingleStoreSerial,
-	SingleStoreSmallInt,
-	SingleStoreText,
-	SingleStoreTinyInt,
-	SingleStoreVarChar,
-	SingleStoreYear,
-} from 'drizzle-orm/singlestore-core';
-import type { SQLiteInteger, SQLiteReal, SQLiteText } from 'drizzle-orm/sqlite-core';
-import { CONSTANTS } from './constants.ts';
-import { isColumnType, isWithEnum } from './utils.ts';
-
-export const literalSchema = type.string.or(type.number).or(type.boolean).or(type.null);
-export const jsonSchema = literalSchema.or(type.unknown.as<any>().array()).or(type.object.as<Record<string, any>>());
-export const bufferSchema = type.unknown.narrow((value) => value instanceof Buffer).as<Buffer>().describe( // eslint-disable-line no-instanceof/no-instanceof
-	'a Buffer instance',
-);
-
-export function columnToSchema(column: Column): Type {
-	let schema!: Type;
-
-	if (isWithEnum(column)) {
-		schema = column.enumValues.length ? type.enumerated(...column.enumValues) : type.string;
-	}
-
-	if (!schema) {
-		// Handle specific types
-		if (isColumnType<PgGeometry<any> | PgPointTuple<any>>(column, ['PgGeometry', 'PgPointTuple'])) {
-			schema = type([type.number, type.number]);
-		} else if (
-			isColumnType<PgPointObject<any> | PgGeometryObject<any>>(column, ['PgGeometryObject', 'PgPointObject'])
-		) {
-			schema = type({
-				x: type.number,
-				y: type.number,
-			});
-		} else if (isColumnType<PgHalfVector<any> | PgVector<any>>(column, ['PgHalfVector', 'PgVector'])) {
-			schema = column.dimensions
-				? type.number.array().exactlyLength(column.dimensions)
-				: type.number.array();
-		} else if (isColumnType<PgLineTuple<any>>(column, ['PgLine'])) {
-			schema = type([type.number, type.number, type.number]);
-		} else if (isColumnType<PgLineABC<any>>(column, ['PgLineABC'])) {
-			schema = type({
-				a: type.number,
-				b: type.number,
-				c: type.number,
-			});
-		} // Handle other types
-		else if (isColumnType<PgArray<any, any>>(column, ['PgArray'])) {
-			const arraySchema = columnToSchema(column.baseColumn).array();
-			schema = column.size ? arraySchema.exactlyLength(column.size) : arraySchema;
-		} else if (column.dataType === 'array') {
-			schema = type.unknown.array();
-		} else if (column.dataType === 'number') {
-			schema = numberColumnToSchema(column);
-		} else if (column.dataType === 'bigint') {
-			schema = bigintColumnToSchema(column);
-		} else if (column.dataType === 'boolean') {
-			schema = type.boolean;
-		} else if (column.dataType === 'date') {
-			schema = type.Date;
-		} else if (column.dataType === 'string') {
-			schema = stringColumnToSchema(column);
-		} else if (column.dataType === 'json') {
-			schema = jsonSchema;
-		} else if (column.dataType === 'custom') {
-			schema = type.unknown;
-		} else if (column.dataType === 'buffer') {
-			schema = bufferSchema;
-		}
-	}
-
-	if (!schema) {
-		schema = type.unknown;
-	}
-
-	return schema;
-}
-
-function numberColumnToSchema(column: Column): Type<number, any> {
-	let unsigned = column.getSQLType().includes('unsigned');
-	let min!: number;
-	let max!: number;
-	let integer = false;
-
-	if (isColumnType<MySqlTinyInt<any> | SingleStoreTinyInt<any>>(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
-		min = unsigned ? 0 : CONSTANTS.INT8_MIN;
-		max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
-		integer = true;
-	} else if (
-		isColumnType<PgSmallInt<any> | PgSmallSerial<any> | MySqlSmallInt<any> | SingleStoreSmallInt<any>>(column, [
-			'PgSmallInt',
-			'PgSmallSerial',
-			'MySqlSmallInt',
-			'SingleStoreSmallInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT16_MIN;
-		max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			PgReal<any> | MySqlFloat<any> | MySqlMediumInt<any> | SingleStoreFloat<any> | SingleStoreMediumInt<any>
-		>(column, [
-			'PgReal',
-			'MySqlFloat',
-			'MySqlMediumInt',
-			'SingleStoreFloat',
-			'SingleStoreMediumInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT24_MIN;
-		max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
-		integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
-	} else if (
-		isColumnType<PgInteger<any> | PgSerial<any> | MySqlInt<any> | SingleStoreInt<any>>(column, [
-			'PgInteger',
-			'PgSerial',
-			'MySqlInt',
-			'SingleStoreInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT32_MIN;
-		max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			| PgDoublePrecision<any>
-			| MySqlReal<any>
-			| MySqlDouble<any>
-			| SingleStoreReal<any>
-			| SingleStoreDouble<any>
-			| SQLiteReal<any>
-		>(column, [
-			'PgDoublePrecision',
-			'MySqlReal',
-			'MySqlDouble',
-			'SingleStoreReal',
-			'SingleStoreDouble',
-			'SQLiteReal',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT48_MIN;
-		max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
-	} else if (
-		isColumnType<
-			| PgBigInt53<any>
-			| PgBigSerial53<any>
-			| MySqlBigInt53<any>
-			| MySqlSerial<any>
-			| SingleStoreBigInt53<any>
-			| SingleStoreSerial<any>
-			| SQLiteInteger<any>
-		>(
-			column,
-			[
-				'PgBigInt53',
-				'PgBigSerial53',
-				'MySqlBigInt53',
-				'MySqlSerial',
-				'SingleStoreBigInt53',
-				'SingleStoreSerial',
-				'SQLiteInteger',
-			],
-		)
-	) {
-		unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
-		min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-		integer = true;
-	} else if (isColumnType<MySqlYear<any> | SingleStoreYear<any>>(column, ['MySqlYear', 'SingleStoreYear'])) {
-		min = 1901;
-		max = 2155;
-		integer = true;
-	} else {
-		min = Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-	}
-
-	return (integer ? type.keywords.number.integer : type.number).atLeast(min).atMost(max);
-}
-
-/** @internal */
-export const unsignedBigintNarrow = (v: bigint, ctx: { mustBe: (expected: string) => false }) =>
-	v < 0n ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_UNSIGNED_MAX ? ctx.mustBe('less than') : true;
-
-/** @internal */
-export const bigintNarrow = (v: bigint, ctx: { mustBe: (expected: string) => false }) =>
-	v < CONSTANTS.INT64_MIN ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_MAX ? ctx.mustBe('less than') : true;
-
-function bigintColumnToSchema(column: Column): Type {
-	const unsigned = column.getSQLType().includes('unsigned');
-	return type.bigint.narrow(unsigned ? unsignedBigintNarrow : bigintNarrow);
-}
-
-function stringColumnToSchema(column: Column): Type {
-	if (isColumnType<PgUUID<ColumnBaseConfig<'string', 'PgUUID'>>>(column, ['PgUUID'])) {
-		return type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID');
-	}
-	if (
-		isColumnType<
-			PgBinaryVector<
-				ColumnBaseConfig<'string', 'PgBinaryVector'> & {
-					dimensions: number;
-				}
-			>
-		>(column, ['PgBinaryVector'])
-	) {
-		return type(`/^[01]{${column.dimensions}}$/`)
-			.describe(`a string containing ones or zeros while being ${column.dimensions} characters long`);
-	}
-
-	let max: number | undefined;
-	let fixed = false;
-
-	if (isColumnType<PgVarchar<any> | SQLiteText<any>>(column, ['PgVarchar', 'SQLiteText'])) {
-		max = column.length;
-	} else if (
-		isColumnType<MySqlVarChar<any> | SingleStoreVarChar<any>>(column, ['MySqlVarChar', 'SingleStoreVarChar'])
-	) {
-		max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
-	} else if (isColumnType<MySqlText<any> | SingleStoreText<any>>(column, ['MySqlText', 'SingleStoreText'])) {
-		if (column.textType === 'longtext') {
-			max = CONSTANTS.INT32_UNSIGNED_MAX;
-		} else if (column.textType === 'mediumtext') {
-			max = CONSTANTS.INT24_UNSIGNED_MAX;
-		} else if (column.textType === 'text') {
-			max = CONSTANTS.INT16_UNSIGNED_MAX;
-		} else {
-			max = CONSTANTS.INT8_UNSIGNED_MAX;
-		}
-	}
-
-	if (
-		isColumnType<PgChar<any> | MySqlChar<any> | SingleStoreChar<any>>(column, [
-			'PgChar',
-			'MySqlChar',
-			'SingleStoreChar',
-		])
-	) {
-		max = column.length;
-		fixed = true;
-	}
-
-	return max && fixed ? type.string.exactlyLength(max) : max ? type.string.atMostLength(max) : type.string;
-}
diff --git a/drizzle-arktype/src/column.types.ts b/drizzle-arktype/src/column.types.ts
deleted file mode 100644
index 533704815c..0000000000
--- a/drizzle-arktype/src/column.types.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { Type, type } from 'arktype';
-import type { Column } from 'drizzle-orm';
-import type { Json } from './utils.ts';
-
-export type ArktypeNullable<TSchema> = Type<type.infer<TSchema> | null>;
-
-export type ArktypeOptional<TSchema> = [Type<type.infer<TSchema>>, '?'];
-
-export type GetArktypeType<
-	TColumn extends Column,
-> = TColumn['_']['columnType'] extends
-	'PgJson' | 'PgJsonb' | 'MySqlJson' | 'SingleStoreJson' | 'SQLiteTextJson' | 'SQLiteBlobJson'
-	? unknown extends TColumn['_']['data'] ? Type<Json> : Type<TColumn['_']['data']>
-	: Type<TColumn['_']['data']>;
-
-type HandleSelectColumn<
-	TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TSchema
-	: ArktypeNullable<TSchema>;
-
-type HandleInsertColumn<
-	TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? ArktypeOptional<TSchema>
-	: TSchema
-	: ArktypeOptional<ArktypeNullable<TSchema>>;
-
-type HandleUpdateColumn<
-	TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? ArktypeOptional<TSchema>
-	: ArktypeOptional<ArktypeNullable<TSchema>>;
-
-export type HandleColumn<
-	TType extends 'select' | 'insert' | 'update',
-	TColumn extends Column,
-> = TType extends 'select' ? HandleSelectColumn<GetArktypeType<TColumn>, TColumn>
-	: TType extends 'insert' ? HandleInsertColumn<GetArktypeType<TColumn>, TColumn>
-	: TType extends 'update' ? HandleUpdateColumn<GetArktypeType<TColumn>, TColumn>
-	: GetArktypeType<TColumn>;
diff --git a/drizzle-arktype/src/constants.ts b/drizzle-arktype/src/constants.ts
deleted file mode 100644
index 99f5d7a422..0000000000
--- a/drizzle-arktype/src/constants.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-export const CONSTANTS = {
-	INT8_MIN: -128,
-	INT8_MAX: 127,
-	INT8_UNSIGNED_MAX: 255,
-	INT16_MIN: -32768,
-	INT16_MAX: 32767,
-	INT16_UNSIGNED_MAX: 65535,
-	INT24_MIN: -8388608,
-	INT24_MAX: 8388607,
-	INT24_UNSIGNED_MAX: 16777215,
-	INT32_MIN: -2147483648,
-	INT32_MAX: 2147483647,
-	INT32_UNSIGNED_MAX: 4294967295,
-	INT48_MIN: -140737488355328,
-	INT48_MAX: 140737488355327,
-	INT48_UNSIGNED_MAX: 281474976710655,
-	INT64_MIN: -9223372036854775808n,
-	INT64_MAX: 9223372036854775807n,
-	INT64_UNSIGNED_MAX: 18446744073709551615n,
-};
diff --git a/drizzle-arktype/src/index.ts b/drizzle-arktype/src/index.ts
deleted file mode 100644
index 225d3e880f..0000000000
--- a/drizzle-arktype/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export { bufferSchema, jsonSchema, literalSchema } from './column.ts';
-export * from './column.types.ts';
-export * from './schema.ts';
-export * from './schema.types.internal.ts';
-export * from './schema.types.ts';
-export * from './utils.ts';
diff --git a/drizzle-arktype/src/schema.ts b/drizzle-arktype/src/schema.ts
deleted file mode 100644
index 0523e41796..0000000000
--- a/drizzle-arktype/src/schema.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { Type, type } from 'arktype';
-import { Column, getTableColumns, getViewSelectedFields, is, isTable, isView, SQL } from 'drizzle-orm';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import { columnToSchema } from './column.ts';
-import type { Conditions } from './schema.types.internal.ts';
-import type { CreateInsertSchema, CreateSelectSchema, CreateUpdateSchema } from './schema.types.ts';
-import { isPgEnum } from './utils.ts';
-
-function getColumns(tableLike: Table | View) {
-	return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
-}
-
-function handleColumns(
-	columns: Record<string, any>,
-	refinements: Record<string, any>,
-	conditions: Conditions,
-): Type {
-	const columnSchemas: Record<string, Type> = {};
-
-	for (const [key, selected] of Object.entries(columns)) {
-		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
-			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
-			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
-			continue;
-		}
-
-		const refinement = refinements[key];
-		if (
-			refinement !== undefined
-			&& (typeof refinement !== 'function' || (typeof refinement === 'function' && refinement.expression !== undefined))
-		) {
-			columnSchemas[key] = refinement;
-			continue;
-		}
-
-		const column = is(selected, Column) ? selected : undefined;
-		const schema = column ? columnToSchema(column) : type.unknown;
-		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
-
-		if (conditions.never(column)) {
-			continue;
-		} else {
-			columnSchemas[key] = refined;
-		}
-
-		if (column) {
-			if (conditions.nullable(column)) {
-				columnSchemas[key] = columnSchemas[key]!.or(type.null);
-			}
-
-			if (conditions.optional(column)) {
-				columnSchemas[key] = columnSchemas[key]!.optional() as any;
-			}
-		}
-	}
-
-	return type(columnSchemas);
-}
-
-export const createSelectSchema = ((
-	entity: Table | View | PgEnum<[string, ...string[]]>,
-	refine?: Record<string, any>,
-) => {
-	if (isPgEnum(entity)) {
-		return type.enumerated(...entity.enumValues);
-	}
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: () => false,
-		optional: () => false,
-		nullable: (column) => !column.notNull,
-	}) as any;
-}) as CreateSelectSchema;
-
-export const createInsertSchema = ((
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-		optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
-		nullable: (column) => !column.notNull,
-	}) as any;
-}) as CreateInsertSchema;
-
-export const createUpdateSchema = ((
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-		optional: () => true,
-		nullable: (column) => !column.notNull,
-	}) as any;
-}) as CreateUpdateSchema;
diff --git a/drizzle-arktype/src/schema.types.internal.ts b/drizzle-arktype/src/schema.types.internal.ts
deleted file mode 100644
index fa77b61d33..0000000000
--- a/drizzle-arktype/src/schema.types.internal.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import type { Type, type } from 'arktype';
-import type { Column, DrizzleTypeError, SelectedFieldsFlat, Simplify, Table, View } from 'drizzle-orm';
-import type { ArktypeNullable, ArktypeOptional, GetArktypeType, HandleColumn } from './column.types.ts';
-import type { ColumnIsGeneratedAlwaysAs, GetSelection } from './utils.ts';
-
-export interface Conditions {
-	never: (column?: Column) => boolean;
-	optional: (column: Column) => boolean;
-	nullable: (column: Column) => boolean;
-}
-
-type GenericSchema = type.cast<unknown> | [type.cast<unknown>, '?'];
-
-type BuildRefineField<T> = T extends GenericSchema ? ((schema: T) => GenericSchema) | GenericSchema : never;
-
-export type BuildRefine<
-	TColumns extends Record<string, any>,
-> = {
-	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
-		TColumns[K] extends Column ? BuildRefineField<GetArktypeType<TColumns[K]>>
-			: BuildRefine<GetSelection<TColumns[K]>>;
-};
-
-type HandleRefinement<
-	TType extends 'select' | 'insert' | 'update',
-	TRefinement,
-	TColumn extends Column,
-> = TRefinement extends (schema: any) => GenericSchema ? (
-		TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
-			: ArktypeNullable<ReturnType<TRefinement>>
-	) extends infer TSchema ? TType extends 'update' ? ArktypeOptional<TSchema>
-		: TSchema
-	: Type<any>
-	: TRefinement;
-
-type IsRefinementDefined<
-	TRefinements extends Record<string | symbol | number, any> | undefined,
-	TKey extends string | symbol | number,
-> = TRefinements extends object ? TRefinements[TKey] extends GenericSchema | ((schema: any) => any) ? true
-	: false
-	: false;
-
-export type BuildSchema<
-	TType extends 'select' | 'insert' | 'update',
-	TColumns extends Record<string, any>,
-	TRefinements extends Record<string, any> | undefined,
-> = type.instantiate<
-	Simplify<
-		{
-			readonly [K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? never : K]:
-				TColumns[K] extends infer TColumn extends Column
-					? IsRefinementDefined<TRefinements, K> extends true
-						? HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>
-					: HandleColumn<TType, TColumn>
-					: TColumns[K] extends infer TNested extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
-							TType,
-							GetSelection<TNested>,
-							TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
-						>
-					: any;
-		}
-	>
->;
-
-export type NoUnknownKeys<
-	TRefinement extends Record<string, any>,
-	TCompare extends Record<string, any>,
-> = {
-	[K in keyof TRefinement]: K extends keyof TCompare
-		? TRefinement[K] extends Record<string, GenericSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
-		: TRefinement[K]
-		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
-};
diff --git a/drizzle-arktype/src/schema.types.ts b/drizzle-arktype/src/schema.types.ts
deleted file mode 100644
index b9711a3ba3..0000000000
--- a/drizzle-arktype/src/schema.types.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { Type } from 'arktype';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
-
-export interface CreateSelectSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<TTable['_']['columns']>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferSelect']>,
-	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
-
-	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
-	<
-		TView extends View,
-		TRefine extends BuildRefine<TView['_']['selectedFields']>,
-	>(
-		view: TView,
-		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
-	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
-
-	<TEnum extends PgEnum<any>>(enum_: TEnum): Type<TEnum['enumValues'][number]>;
-}
-
-export interface CreateInsertSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferInsert']>,
-	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
-}
-
-export interface CreateUpdateSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: TRefine,
-	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
-}
diff --git a/drizzle-arktype/src/utils.ts b/drizzle-arktype/src/utils.ts
deleted file mode 100644
index b2b4d4275e..0000000000
--- a/drizzle-arktype/src/utils.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { type } from 'arktype';
-import type { Column, SelectedFieldsFlat, Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { literalSchema } from './column.ts';
-
-export function isColumnType<T extends Column>(column: Column, columnTypes: string[]): column is T {
-	return columnTypes.includes(column.columnType);
-}
-
-export function isWithEnum(column: Column): column is typeof column & { enumValues: [string, ...string[]] } {
-	return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
-}
-
-export const isPgEnum: (entity: any) => entity is PgEnum<[string, ...string[]]> = isWithEnum as any;
-
-type Literal = type.infer<typeof literalSchema>;
-export type Json = Literal | Record<string, any> | any[];
-
-export type ColumnIsGeneratedAlwaysAs<TColumn> = TColumn extends Column
-	? TColumn['_']['identity'] extends 'always' ? true
-	: TColumn['_']['generated'] extends { type: 'byDefault' } | undefined ? false
-	: true
-	: false;
-
-export type GetSelection<T extends SelectedFieldsFlat<Column> | Table | View> = T extends Table ? T['_']['columns']
-	: T extends View ? T['_']['selectedFields']
-	: T;
diff --git a/drizzle-arktype/tests/mysql.test.ts b/drizzle-arktype/tests/mysql.test.ts
deleted file mode 100644
index f49e910f8a..0000000000
--- a/drizzle-arktype/tests/mysql.test.ts
+++ /dev/null
@@ -1,501 +0,0 @@
-import { Type, type } from 'arktype';
-import { type Equal, sql } from 'drizzle-orm';
-import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { bigintNarrow, jsonSchema, unsignedBigintNarrow } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
-const serialNumberModeSchema = type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER);
-const textSchema = type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX);
-
-test('table - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = mysqlSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema,
-		age: intSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: serialNumberModeSchema, age: type('unknown.any') });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = mysqlView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = type({
-		id: serialNumberModeSchema,
-		nested: type({ name: textSchema, age: type('unknown.any') }),
-		table: type({ id: serialNumberModeSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema,
-		c3: intSchema.or(type.null),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema,
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000).optional(),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		nested: {
-			c5: (schema) => schema.atMost(1000),
-			c6: type.string.pipe(Number),
-		},
-		table: {
-			c2: (schema) => schema.atMost(1000),
-			c3: type.string.pipe(Number),
-		},
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000).or(type.null),
-		c3: type.string.pipe(Number),
-		nested: type({
-			c4: intSchema.or(type.null),
-			c5: intSchema.atMost(1000).or(type.null),
-			c6: type.string.pipe(Number),
-		}),
-		table: type({
-			c1: intSchema.or(type.null),
-			c2: intSchema.atMost(1000).or(type.null),
-			c3: type.string.pipe(Number),
-			c4: intSchema.or(type.null),
-			c5: intSchema.or(type.null),
-			c6: intSchema.or(type.null),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = mysqlTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		mysqlEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
-		bigint2: type.bigint.narrow(bigintNarrow),
-		bigint3: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
-		bigint4: type.bigint.narrow(unsignedBigintNarrow),
-		binary: type.string,
-		boolean: type.boolean,
-		char1: type.string.exactlyLength(10),
-		char2: type.enumerated('a', 'b', 'c'),
-		date1: type.Date,
-		date2: type.string,
-		datetime1: type.Date,
-		datetime2: type.string,
-		decimal1: type.string,
-		decimal2: type.string,
-		double1: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		double2: type.number.atLeast(0).atMost(CONSTANTS.INT48_UNSIGNED_MAX),
-		float1: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
-		float2: type.number.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
-		int1: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
-		int2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT32_UNSIGNED_MAX),
-		json: jsonSchema,
-		mediumint1: type.keywords.number.integer.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
-		mediumint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
-		enum: type.enumerated('a', 'b', 'c'),
-		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		serial: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
-		smallint1: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
-		smallint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT16_UNSIGNED_MAX),
-		text1: type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX),
-		text2: type.enumerated('a', 'b', 'c'),
-		time: type.string,
-		timestamp1: type.Date,
-		timestamp2: type.string,
-		tinyint1: type.keywords.number.integer.atLeast(CONSTANTS.INT8_MIN).atMost(CONSTANTS.INT8_MAX),
-		tinyint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT8_UNSIGNED_MAX),
-		varchar1: type.string.atMostLength(10),
-		varchar2: type.enumerated('a', 'b', 'c'),
-		varbinary: type.string,
-		year: type.keywords.number.integer.atLeast(1901).atMost(2155),
-		longtext1: type.string.atMostLength(CONSTANTS.INT32_UNSIGNED_MAX),
-		longtext2: type.enumerated('a', 'b', 'c'),
-		mediumtext1: type.string.atMostLength(CONSTANTS.INT24_UNSIGNED_MAX),
-		mediumtext2: type.enumerated('a', 'b', 'c'),
-		tinytext1: type.string.atMostLength(CONSTANTS.INT8_UNSIGNED_MAX),
-		tinytext2: type.enumerated('a', 'b', 'c'),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: Type<TopLevelCondition, {}> = type('unknown.any') as any;
-	const table = mysqlTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = type({
-		json: TopLevelCondition.or(type.null),
-	});
-	Expect<Equal<type.infer<typeof result>, type.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = mysqlTable('test', { id: int() });
-	const view = mysqlView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = mysqlView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-}
diff --git a/drizzle-arktype/tests/pg.test.ts b/drizzle-arktype/tests/pg.test.ts
deleted file mode 100644
index 3792e417a8..0000000000
--- a/drizzle-arktype/tests/pg.test.ts
+++ /dev/null
@@ -1,557 +0,0 @@
-import { Type, type } from 'arktype';
-import { type Equal, sql } from 'drizzle-orm';
-import {
-	customType,
-	integer,
-	json,
-	jsonb,
-	pgEnum,
-	pgMaterializedView,
-	pgSchema,
-	pgTable,
-	pgView,
-	serial,
-	text,
-} from 'drizzle-orm/pg-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { bigintNarrow, jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectEnumValues, expectSchemaShape } from './utils.ts';
-
-const integerSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
-const textSchema = type.string;
-
-test('table - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = pgSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({ name: textSchema, age: integerSchema.or(type.null).optional() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		name: textSchema.optional(),
-		age: integerSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: integerSchema, age: type('unknown.any') });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: integerSchema, age: type('unknown.any') });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = type({
-		id: integerSchema,
-		nested: { name: textSchema, age: type('unknown.any') },
-		table: { id: integerSchema, name: textSchema },
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('enum - select', (t) => {
-	const enum_ = pgEnum('test', ['a', 'b', 'c']);
-
-	const result = createSelectSchema(enum_);
-	const expected = type.enumerated('a', 'b', 'c');
-	expectEnumValues(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		c1: integerSchema.or(type.null),
-		c2: integerSchema,
-		c3: integerSchema.or(type.null),
-		c4: integerSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		c1: integerSchema.or(type.null).optional(),
-		c2: integerSchema,
-		c3: integerSchema.or(type.null).optional(),
-		c4: integerSchema.optional(),
-		c7: integerSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-});
-
-test('nullability - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		c1: integerSchema.or(type.null).optional(),
-		c2: integerSchema.optional(),
-		c3: integerSchema.or(type.null).optional(),
-		c4: integerSchema.optional(),
-		c7: integerSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: integerSchema.or(type.null),
-		c2: integerSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-	const expected = type({
-		c1: integerSchema.or(type.null),
-		c2: integerSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: integerSchema.or(type.null).optional(),
-		c2: integerSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: integerSchema.or(type.null).optional(),
-		c2: integerSchema.atMost(1000).optional(),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer(),
-		c3: integer(),
-		c4: integer(),
-		c5: integer(),
-		c6: integer(),
-	});
-	const view = pgView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		nested: {
-			c5: (schema) => schema.atMost(1000),
-			c6: type.string.pipe(Number),
-		},
-		table: {
-			c2: (schema) => schema.atMost(1000),
-			c3: type.string.pipe(Number),
-		},
-	});
-	const expected = type({
-		c1: integerSchema.or(type.null),
-		c2: integerSchema.atMost(1000).or(type.null),
-		c3: type.string.pipe(Number),
-		nested: type({
-			c4: integerSchema.or(type.null),
-			c5: integerSchema.atMost(1000).or(type.null),
-			c6: type.string.pipe(Number),
-		}),
-		table: type({
-			c1: integerSchema.or(type.null),
-			c2: integerSchema.atMost(1000).or(type.null),
-			c3: type.string.pipe(Number),
-			c4: integerSchema.or(type.null),
-			c5: integerSchema.or(type.null),
-			c6: integerSchema.or(type.null),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = pgTable('test', ({
-		bigint,
-		bigserial,
-		bit,
-		boolean,
-		date,
-		char,
-		cidr,
-		doublePrecision,
-		geometry,
-		halfvec,
-		inet,
-		integer,
-		interval,
-		json,
-		jsonb,
-		line,
-		macaddr,
-		macaddr8,
-		numeric,
-		point,
-		real,
-		serial,
-		smallint,
-		smallserial,
-		text,
-		sparsevec,
-		time,
-		timestamp,
-		uuid,
-		varchar,
-		vector,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigserial1: bigserial({ mode: 'number' }).notNull(),
-		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
-		bit: bit({ dimensions: 5 }).notNull(),
-		boolean: boolean().notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		cidr: cidr().notNull(),
-		doublePrecision: doublePrecision().notNull(),
-		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
-		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
-		halfvec: halfvec({ dimensions: 3 }).notNull(),
-		inet: inet().notNull(),
-		integer: integer().notNull(),
-		interval: interval().notNull(),
-		json: json().notNull(),
-		jsonb: jsonb().notNull(),
-		line1: line({ mode: 'abc' }).notNull(),
-		line2: line({ mode: 'tuple' }).notNull(),
-		macaddr: macaddr().notNull(),
-		macaddr8: macaddr8().notNull(),
-		numeric: numeric().notNull(),
-		point1: point({ mode: 'xy' }).notNull(),
-		point2: point({ mode: 'tuple' }).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint: smallint().notNull(),
-		smallserial: smallserial().notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		uuid: uuid().notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		vector: vector({ dimensions: 3 }).notNull(),
-		array1: integer().array().notNull(),
-		array2: integer().array().array(2).notNull(),
-		array3: varchar({ length: 10 }).array().array(2).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
-		bigint2: type.bigint.narrow(bigintNarrow),
-		bigserial1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
-		bigserial2: type.bigint.narrow(bigintNarrow),
-		bit: type(/^[01]{5}$/).describe('a string containing ones or zeros while being 5 characters long'),
-		boolean: type.boolean,
-		date1: type.Date,
-		date2: type.string,
-		char1: type.string.exactlyLength(10),
-		char2: type.enumerated('a', 'b', 'c'),
-		cidr: type.string,
-		doublePrecision: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		geometry1: type([type.number, type.number]),
-		geometry2: type({ x: type.number, y: type.number }),
-		halfvec: type.number.array().exactlyLength(3),
-		inet: type.string,
-		integer: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
-		interval: type.string,
-		json: jsonSchema,
-		jsonb: jsonSchema,
-		line1: type({ a: type.number, b: type.number, c: type.number }),
-		line2: type([type.number, type.number, type.number]),
-		macaddr: type.string,
-		macaddr8: type.string,
-		numeric: type.string,
-		point1: type({ x: type.number, y: type.number }),
-		point2: type([type.number, type.number]),
-		real: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
-		serial: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
-		smallint: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
-		smallserial: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
-		text1: type.string,
-		text2: type.enumerated('a', 'b', 'c'),
-		sparsevec: type.string,
-		time: type.string,
-		timestamp1: type.Date,
-		timestamp2: type.string,
-		uuid: type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID'),
-		varchar1: type.string.atMostLength(10),
-		varchar2: type.enumerated('a', 'b', 'c'),
-		vector: type.number.array().exactlyLength(3),
-		array1: integerSchema.array(),
-		array2: integerSchema.array().array().exactlyLength(2),
-		array3: type.string.atMostLength(10).array().array().exactlyLength(2),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: Type<TopLevelCondition, {}> = type('unknown.any') as any;
-	const table = pgTable('test', {
-		json: json().$type<TopLevelCondition>().notNull(),
-		jsonb: jsonb().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = type({
-		json: TopLevelCondition,
-		jsonb: TopLevelCondition.or(type.null),
-	});
-	Expect<Equal<type.infer<typeof result>, type.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = pgTable('test', { id: integer() });
-	const view = pgView('test').as((qb) => qb.select().from(table));
-	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: type.string });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = pgView('test', { id: integer() }).as(sql``);
-	const mView = pgView('test', { id: integer() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: type.string });
-}
diff --git a/drizzle-arktype/tests/singlestore.test.ts b/drizzle-arktype/tests/singlestore.test.ts
deleted file mode 100644
index 99ac40bde3..0000000000
--- a/drizzle-arktype/tests/singlestore.test.ts
+++ /dev/null
@@ -1,503 +0,0 @@
-import { Type, type } from 'arktype';
-import { type Equal } from 'drizzle-orm';
-import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { bigintNarrow, jsonSchema, unsignedBigintNarrow } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
-const serialNumberModeSchema = type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER);
-const textSchema = type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX);
-
-test('table - select', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = singlestoreSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema,
-		age: intSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// TODO: SingleStore doesn't support views yet. Add these tests when they're added
-
-// test('view qb - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({ id: serialNumberModeSchema, age: v.any() });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view columns - select', (t) => {
-// 	const view = mysqlView('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	}).as(sql``);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view with nested fields - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			id: table.id,
-// 			nested: {
-// 				name: table.name,
-// 				age: sql``.as('age'),
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({
-// 		id: serialNumberModeSchema,
-// 		nested: v.object({ name: textSchema, age: v.any() }),
-// 		table: v.object({ id: serialNumberModeSchema, name: textSchema }),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('nullability - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema,
-		c3: intSchema.or(type.null),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema,
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000).optional(),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// test('refine view - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		c1: int(),
-// 		c2: int(),
-// 		c3: int(),
-// 		c4: int(),
-// 		c5: int(),
-// 		c6: int(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			c1: table.c1,
-// 			c2: table.c2,
-// 			c3: table.c3,
-// 			nested: {
-// 				c4: table.c4,
-// 				c5: table.c5,
-// 				c6: table.c6,
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view, {
-// 		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 		c3: v.pipe(type.string, v.transform(Number)),
-// 		nested: {
-// 			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 			c6: v.pipe(type.string, v.transform(Number)),
-// 		},
-// 		table: {
-// 			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 			c3: v.pipe(type.string, v.transform(Number)),
-// 		},
-// 	});
-// 	const expected = v.object({
-// 		c1: v.nullable(intSchema),
-// 		c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 		c3: v.pipe(type.string, v.transform(Number)),
-// 		nested: v.object({
-// 			c4: v.nullable(intSchema),
-// 			c5: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 			c6: v.pipe(type.string, v.transform(Number)),
-// 		}),
-// 		table: v.object({
-// 			c1: v.nullable(intSchema),
-// 			c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 			c3: v.pipe(type.string, v.transform(Number)),
-// 			c4: v.nullable(intSchema),
-// 			c5: v.nullable(intSchema),
-// 			c6: v.nullable(intSchema),
-// 		}),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('all data types', (t) => {
-	const table = singlestoreTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		singlestoreEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
-		bigint2: type.bigint.narrow(bigintNarrow),
-		bigint3: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
-		bigint4: type.bigint.narrow(unsignedBigintNarrow),
-		binary: type.string,
-		boolean: type.boolean,
-		char1: type.string.exactlyLength(10),
-		char2: type.enumerated('a', 'b', 'c'),
-		date1: type.Date,
-		date2: type.string,
-		datetime1: type.Date,
-		datetime2: type.string,
-		decimal1: type.string,
-		decimal2: type.string,
-		double1: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		double2: type.number.atLeast(0).atMost(CONSTANTS.INT48_UNSIGNED_MAX),
-		float1: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
-		float2: type.number.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
-		int1: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
-		int2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT32_UNSIGNED_MAX),
-		json: jsonSchema,
-		mediumint1: type.keywords.number.integer.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
-		mediumint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
-		enum: type.enumerated('a', 'b', 'c'),
-		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		serial: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
-		smallint1: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
-		smallint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT16_UNSIGNED_MAX),
-		text1: type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX),
-		text2: type.enumerated('a', 'b', 'c'),
-		time: type.string,
-		timestamp1: type.Date,
-		timestamp2: type.string,
-		tinyint1: type.keywords.number.integer.atLeast(CONSTANTS.INT8_MIN).atMost(CONSTANTS.INT8_MAX),
-		tinyint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT8_UNSIGNED_MAX),
-		varchar1: type.string.atMostLength(10),
-		varchar2: type.enumerated('a', 'b', 'c'),
-		varbinary: type.string,
-		year: type.keywords.number.integer.atLeast(1901).atMost(2155),
-		longtext1: type.string.atMostLength(CONSTANTS.INT32_UNSIGNED_MAX),
-		longtext2: type.enumerated('a', 'b', 'c'),
-		mediumtext1: type.string.atMostLength(CONSTANTS.INT24_UNSIGNED_MAX),
-		mediumtext2: type.enumerated('a', 'b', 'c'),
-		tinytext1: type.string.atMostLength(CONSTANTS.INT8_UNSIGNED_MAX),
-		tinytext2: type.enumerated('a', 'b', 'c'),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: Type<TopLevelCondition, {}> = type('unknown.any') as any;
-	const table = singlestoreTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = type({
-		json: TopLevelCondition.or(type.null),
-	});
-	Expect<Equal<type.infer<typeof result>, type.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: type.string });
-}
-
-// /* Disallow unknown keys in view qb - select */ {
-// 	const table = singlestoreTable('test', { id: int() });
-// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
-// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: type.string });
-// 	// @ts-expect-error
-// 	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
-// }
-
-// /* Disallow unknown keys in view columns - select */ {
-// 	const view = mysqlView('test', { id: int() }).as(sql``);
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: type.string });
-// }
diff --git a/drizzle-arktype/tests/sqlite.test.ts b/drizzle-arktype/tests/sqlite.test.ts
deleted file mode 100644
index e7a01cb434..0000000000
--- a/drizzle-arktype/tests/sqlite.test.ts
+++ /dev/null
@@ -1,400 +0,0 @@
-import { Type, type } from 'arktype';
-import { type Equal, sql } from 'drizzle-orm';
-import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { bigintNarrow, bufferSchema, jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER);
-const textSchema = type.string;
-
-test('table - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({ id: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({ id: intSchema.optional(), name: textSchema, age: intSchema.or(type.null).optional() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		id: intSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.or(type.null).optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: intSchema, age: type('unknown.any') });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = sqliteView('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = type({ id: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = type({
-		id: intSchema,
-		nested: type({ name: textSchema, age: type('unknown.any') }),
-		table: type({ id: intSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema,
-		c3: intSchema.or(type.null),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema,
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.or(type.null).optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-	});
-	const expected = type({
-		c1: intSchema.or(type.null).optional(),
-		c2: intSchema.atMost(1000).optional(),
-		c3: type.string.pipe(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.atMost(1000),
-		c3: type.string.pipe(Number),
-		nested: {
-			c5: (schema) => schema.atMost(1000),
-			c6: type.string.pipe(Number),
-		},
-		table: {
-			c2: (schema) => schema.atMost(1000),
-			c3: type.string.pipe(Number),
-		},
-	});
-	const expected = type({
-		c1: intSchema.or(type.null),
-		c2: intSchema.atMost(1000).or(type.null),
-		c3: type.string.pipe(Number),
-		nested: type({
-			c4: intSchema.or(type.null),
-			c5: intSchema.atMost(1000).or(type.null),
-			c6: type.string.pipe(Number),
-		}),
-		table: type({
-			c1: intSchema.or(type.null),
-			c2: intSchema.atMost(1000).or(type.null),
-			c3: type.string.pipe(Number),
-			c4: intSchema.or(type.null),
-			c5: intSchema.or(type.null),
-			c6: intSchema.or(type.null),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = sqliteTable('test', ({
-		blob,
-		integer,
-		numeric,
-		real,
-		text,
-	}) => ({
-		blob1: blob({ mode: 'buffer' }).notNull(),
-		blob2: blob({ mode: 'bigint' }).notNull(),
-		blob3: blob({ mode: 'json' }).notNull(),
-		integer1: integer({ mode: 'number' }).notNull(),
-		integer2: integer({ mode: 'boolean' }).notNull(),
-		integer3: integer({ mode: 'timestamp' }).notNull(),
-		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
-		numeric: numeric().notNull(),
-		real: real().notNull(),
-		text1: text({ mode: 'text' }).notNull(),
-		text2: text({ mode: 'text', length: 10 }).notNull(),
-		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
-		text4: text({ mode: 'json' }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = type({
-		blob1: bufferSchema,
-		blob2: type.bigint.narrow(bigintNarrow),
-		blob3: jsonSchema,
-		integer1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
-		integer2: type.boolean,
-		integer3: type.Date,
-		integer4: type.Date,
-		numeric: type.string,
-		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
-		text1: type.string,
-		text2: type.string.atMostLength(10),
-		text3: type.enumerated('a', 'b', 'c'),
-		text4: jsonSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: Type<TopLevelCondition, {}> = type('unknown.any') as any;
-	const table = sqliteTable('test', {
-		json1: text({ mode: 'json' }).$type<TopLevelCondition>().notNull(),
-		json2: blob({ mode: 'json' }).$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = type({
-		json1: TopLevelCondition,
-		json2: TopLevelCondition.or(type.null),
-	});
-	Expect<Equal<type.infer<typeof result>, type.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: type.string });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = sqliteTable('test', { id: int() });
-	const view = sqliteView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = sqliteView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: type.string });
-}
diff --git a/drizzle-arktype/tests/tsconfig.json b/drizzle-arktype/tests/tsconfig.json
deleted file mode 100644
index 18f5dee497..0000000000
--- a/drizzle-arktype/tests/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"noEmit": true,
-		"rootDir": "..",
-		"outDir": "./.cache"
-	},
-	"include": [".", "../src"]
-}
diff --git a/drizzle-arktype/tests/utils.ts b/drizzle-arktype/tests/utils.ts
deleted file mode 100644
index 9c51655337..0000000000
--- a/drizzle-arktype/tests/utils.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { Type } from 'arktype';
-import { expect, type TaskContext } from 'vitest';
-
-export function expectSchemaShape<T extends Type<any, any>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(actual.json).toStrictEqual(expected.json);
-			expect(actual.expression).toStrictEqual(expected.expression);
-		},
-	};
-}
-
-export const expectEnumValues = expectSchemaShape;
-
-export function Expect<_ extends true>() {}
diff --git a/drizzle-arktype/tsconfig.build.json b/drizzle-arktype/tsconfig.build.json
deleted file mode 100644
index 3377281baa..0000000000
--- a/drizzle-arktype/tsconfig.build.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"extends": "./tsconfig.json",
-	"compilerOptions": {
-		"rootDir": "src"
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-arktype/tsconfig.json b/drizzle-arktype/tsconfig.json
deleted file mode 100644
index a8d7c00116..0000000000
--- a/drizzle-arktype/tsconfig.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"baseUrl": ".",
-		"declaration": true,
-		"noEmit": true,
-		"paths": {
-			"~/*": ["src/*"]
-		}
-	},
-	"include": ["src", "*.ts", "benchmarks"]
-}
diff --git a/drizzle-arktype/vitest.config.ts b/drizzle-arktype/vitest.config.ts
deleted file mode 100644
index 1f0eb7ad9a..0000000000
--- a/drizzle-arktype/vitest.config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-	test: {
-		include: [
-			'tests/**/*.test.ts',
-		],
-		exclude: [
-			'tests/bun/**/*',
-		],
-		typecheck: {
-			tsconfig: 'tsconfig.json',
-		},
-		testTimeout: 100000,
-		hookTimeout: 100000,
-		isolate: false,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-	},
-	plugins: [tsconfigPaths()],
-});
diff --git a/drizzle-kit/.env.example b/drizzle-kit/.env.example
new file mode 100644
index 0000000000..cc5c18efcc
--- /dev/null
+++ b/drizzle-kit/.env.example
@@ -0,0 +1,35 @@
+# drizzle-kit/.env.example — template for drizzle-kit test connection strings.
+# Copy to drizzle-kit/.env (git-ignored) and adjust as needed. Ports must match
+# the canonical compose/*.yml port bindings driven by compose/dockers.sh.
+
+# Postgres (compose/postgres.yml — port 55433)
+PG_CONNECTION_STRING=postgres://postgres:postgres@127.0.0.1:55433/drizzle
+
+# Postgres version-pinned (compose/postgres16.yml, postgres17.yml, postgres18.yml, postgres-postgis.yml)
+PG16_URL=postgres://postgres:postgres@127.0.0.1:54323/drizzle
+PG17_URL=postgres://postgres:postgres@127.0.0.1:54324/drizzle
+PG18_URL=postgres://postgres:postgres@127.0.0.1:54325/drizzle
+POSTGIS_URL=postgres://postgres:postgres@127.0.0.1:54322/drizzle
+
+# MySQL (compose/mysql.yml — port 3306)
+MYSQL_CONNECTION_STRING=mysql://root:mysql@127.0.0.1:3306/drizzle
+
+# MariaDB (compose/mariadb.yml — port 33306)
+MARIADB_CONNECTION_STRING=mysql://root:mariadb@127.0.0.1:33306/drizzle
+
+# Cockroach single-node (compose/cockroach.yml — port 26257). /defaultdb is intentional:
+# fresh single-node cockroach has no `drizzle` DB; prepareClient creates per-worker DBs at runtime.
+COCKROACH_CONNECTION_STRING=postgres://root@127.0.0.1:26257/defaultdb?sslmode=disable
+
+# Cockroach 3-node (compose/cockroach-many.yml — ports 26260–26262). Uncomment for parallel cockroach tests.
+# COCKROACH_CONNECTION_STRING=postgres://root@127.0.0.1:26260/defaultdb?sslmode=disable;postgres://root@127.0.0.1:26261/defaultdb?sslmode=disable;postgres://root@127.0.0.1:26262/defaultdb?sslmode=disable
+
+# MSSQL (compose/mssql.yml — port 1433)
+MSSQL_CONNECTION_STRING=mssql://SA:drizzle123PASSWORD!@127.0.0.1:1433?encrypt=true&trustServerCertificate=true
+
+# SingleStore overload — drizzle-kit/tests/singlestore/mocks.ts reads MYSQL_CONNECTION_STRING
+# (NOT a separate SINGLESTORE_CONNECTION_STRING). When running `pnpm test:singlestore`,
+# swap MYSQL_CONNECTION_STRING above to the singlestore line below. This task does NOT
+# refactor the test code — see CONTEXT §domain (out of scope).
+# SingleStore (compose/singlestore.yml — port 33307)
+# MYSQL_CONNECTION_STRING=mysql://root:singlestore@127.0.0.1:33307/
diff --git a/drizzle-kit/.gitignore b/drizzle-kit/.gitignore
index 4916f095a2..863b15087b 100644
--- a/drizzle-kit/.gitignore
+++ b/drizzle-kit/.gitignore
@@ -3,23 +3,35 @@
 
 !src
 !imports-checker
+!scripts
+!skills
 !tests
+tests/**/tmp/
 !vitest.config.ts
 !README.md
 !CONTRIBUTING.md
-!schema.ts
+!JSON_CONTRACT.md
+!SDK.md
+!MCP.md
+!OUTPUT_MODES.md
+!HINTS.md
 
 !.eslint
 !.gitignore
 !package.json
 !tsconfig.json
+!tsconfig.typetest.json
 !tsconfig.cli-types.json
 !tsconfig.build.json
 !pnpm-lock.yaml
 !.github
 !build.ts
 !build.dev.ts
+!build.ext.ts
+!build.cli.ts
 
 tests/test.ts
 
 !patches
+
+!.env.example
diff --git a/drizzle-kit/HINTS.md b/drizzle-kit/HINTS.md
new file mode 100644
index 0000000000..3f5b7f5db2
--- /dev/null
+++ b/drizzle-kit/HINTS.md
@@ -0,0 +1,267 @@
+# Drizzle Kit hints
+
+This document describes the output-agnostic hint vocabulary shared by `drizzle-kit generate` and `push`: the rename-vs-create disambiguation, `confirm_data_loss` approvals, the `kind` / `reason` catalogs, and the identifier-tuple formats. The same vocabulary applies whether decisions surface as a JSON `missing_hints` envelope (see [JSON_CONTRACT.md](./JSON_CONTRACT.md)) or as the text report (see [OUTPUT_MODES.md](./OUTPUT_MODES.md)).
+
+## Hints flow
+
+Some schema changes are ambiguous (rename vs. create+delete) or unsafe to apply automatically (drops on non-empty data, recreating a SQLite table to add a `NOT NULL` column, etc.). In interactive mode, Drizzle Kit prompts the user. When non-interactive there are no prompts: callers either supply hints up front, or receive the unresolved decisions and reply with hints.
+
+For example, renaming a column in the schema:
+
+```diff
+ export const users = pgTable('users', {
+   id: serial('id').primaryKey(),
+-  full_name: text('full_name'),
++  display_name: text('display_name'),
+ });
+```
+
+From the diff alone, Drizzle Kit cannot tell whether `display_name` is the renamed `full_name` or an unrelated new column whose addition coincides with `full_name`'s removal — hence a `rename_or_create` unresolved item:
+
+```sh
+$ drizzle-kit push --output json
+{
+  "status": "missing_hints",
+  "unresolved": [
+    {
+      "type": "rename_or_create",
+      "kind": "column",
+      "entity": ["public", "users", "display_name"]
+    }
+  ]
+}
+
+$ drizzle-kit push --output json --hints '[{"type":"rename","kind":"column","from":["public","users","full_name"],"to":["public","users","display_name"]}]'
+{ "status": "ok", "dialect": "postgresql" }
+```
+
+A caller's `Hint` resolves a runtime-emitted `MissingHint` by reusing its `kind` and `entity` (and, for `rename_or_create`, choosing a `rename` vs `create` resolution).
+
+| Unresolved item (`MissingHint`) | Caller responds with (`Hint`) | What's reused |
+|---------------------------------|------------------------------|---------------|
+| `{ type: "rename_or_create", kind, entity }` | `{ type: "rename", kind, from, to }` **or** `{ type: "create", kind, entity }` | Same `kind`. For `create`: same `entity`. For `rename`: pick `from` from a deleted entity (same `kind`); the unresolved item's `entity` becomes `to`. |
+| `{ type: "confirm_data_loss", kind, entity, reason, [reason_details] }` | `{ type: "confirm_data_loss", kind, entity }` | Same `kind` and `entity`. `reason` and `reason_details` are runtime-only metadata — callers do not include them. |
+
+Available `kind` values, identifier shapes, and `reason` semantics are catalogued in [Catalog: kinds](#catalog-kinds-in-unresolved-items), [Catalog: reasons](#catalog-reasons-confirm_data_loss-only), and [Identifier formats](#identifier-formats).
+
+## Providing hints
+
+Hints can be passed either inline or from a file:
+
+- `--hints '<json array>'`
+- `--hints-file ./hints.json`
+
+Both forms use the same JSON array format.
+
+## `rename` / `create`
+
+`rename` tells Drizzle Kit a change is one logical entity moving from `from` to `to`. `create` tells Drizzle Kit `entity` is newly created — if the diff also contains a removed entity of the same `kind`, the outcome stays create+delete instead of being interpreted as a rename.
+
+Available `kind` values, identifier shapes, and which `MissingHint.type` each can resolve are listed under [Catalog: kinds](#catalog-kinds-in-unresolved-items).
+
+### Rename a table
+
+```json
+[
+  {
+    "type": "rename",
+    "kind": "table",
+    "from": ["public", "orders_old"],
+    "to": ["public", "orders"]
+  }
+]
+```
+
+### Rename a column
+
+Treat `display_name` as the same column previously named `full_name`:
+
+```json
+[
+  {
+    "type": "rename",
+    "kind": "column",
+    "from": ["public", "users", "full_name"],
+    "to": ["public", "users", "display_name"]
+  }
+]
+```
+
+### Create + delete instead of rename
+
+Treat `display_name` as a truly new column. If `full_name` is also removed in the same diff, this means Drizzle Kit should create the new column and keep the old column as a separate delete instead of interpreting the change as a rename:
+
+```json
+[
+  {
+    "type": "create",
+    "kind": "column",
+    "entity": ["public", "users", "display_name"]
+  }
+]
+```
+
+### Declare that a new schema is truly new
+
+```json
+[
+  {
+    "type": "create",
+    "kind": "schema",
+    "entity": ["tenant_a"]
+  }
+]
+```
+
+## `confirm_data_loss`
+
+Approves a potentially destructive step — dropping a non-empty entity, recreating a SQLite table to add a `NOT NULL` column (which wipes its rows), or changing an existing column's SQL type. Adding `NOT NULL` / `UNIQUE` on the server dialects (postgresql, mysql, mssql, cockroach, singlestore) does not trigger a confirmation request: the `ALTER` runs and the database enforces the constraint, rejecting a genuine violation cleanly.
+
+Available `kind` values and the `reason` each can fire under are catalogued in [Catalog: kinds](#catalog-kinds-in-unresolved-items) and [Catalog: reasons](#catalog-reasons-confirm_data_loss-only).
+
+### Confirm a destructive action
+
+```json
+[
+  {
+    "type": "confirm_data_loss",
+    "kind": "table",
+    "entity": ["public", "users"]
+  }
+]
+```
+
+### `column`
+
+`type_change` is the only `reason` that carries `reason_details`. Example `MissingHint` payload (as emitted in `unresolved`):
+
+```json
+{
+  "type": "confirm_data_loss",
+  "kind": "column",
+  "entity": ["public", "users", "name"],
+  "reason": "type_change",
+  "reason_details": { "from": "varchar(100)", "to": "varchar(50)" }
+}
+```
+
+Formal hint shapes are declared via the [`Hint` type](./src/cli/hints.ts).
+
+## Proactive hints
+
+Hints do not need to be provided only after receiving an unresolved decision.
+
+Callers can provide hints proactively when they already know the intended outcome. This is useful when:
+
+- replaying a migration workflow in CI
+- applying a previously reviewed rename plan
+- approving known data-loss steps in automation
+- retrying the same command with stable schema transitions
+
+For example, when a caller knows ahead of time that a table is being renamed (`users` → `members`):
+
+```json
+[
+  {
+    "type": "rename",
+    "kind": "table",
+    "from": ["public", "users"],
+    "to": ["public", "members"]
+  }
+]
+```
+
+Or that a column is being renamed (`full_name` → `display_name`):
+
+```json
+[
+  {
+    "type": "rename",
+    "kind": "column",
+    "from": ["public", "users", "full_name"],
+    "to": ["public", "users", "display_name"]
+  }
+]
+```
+
+## Redundant hints are safe
+
+Callers may provide more hints than the current command run needs.
+
+If a hint does not match an actual unresolved step in the current diff, it is ignored.
+
+That means it is safe to:
+
+- send a larger precomputed hint set
+- reuse the same hint file across retries
+- include hints for entities that are not part of the current run
+
+## Catalog: kinds in unresolved items
+
+Tuple shape per `kind` is listed in [Identifier formats](#identifier-formats); these tables enumerate the kind set and per-dialect applicability only.
+
+Unmarked kinds apply to all dialects (`postgresql`, `mysql`, `sqlite`, `turso`, `mssql`, `cockroach`, `singlestore`); footnotes call out dialect-restricted ones.
+
+`MissingHint.type: "rename_or_create"` carries one of these `kind` values:
+
+- `table`
+- `column`
+- `default`
+- `view`
+- `check`
+- `index`
+- `unique`
+- `primary_key`
+- `foreign key`
+- `schema`¹
+- `enum`²
+- `sequence`²
+- `policy`²
+- `role`²
+- `privilege`²
+
+¹ `postgresql`, `mssql`, `cockroach` only.
+
+² `postgresql`, `cockroach` only.
+
+`MissingHint.type: "confirm_data_loss"` carries one of these `kind` values:
+
+- `table`
+- `column`
+- `add_not_null`¹
+- `schema`²
+- `view`³
+- `primary_key`⁴
+
+¹ `sqlite`, `turso` only. The server dialects (`postgresql`, `mysql`, `mssql`, `cockroach`, `singlestore`) add `NOT NULL` / `UNIQUE` without triggering a confirmation request — the `ALTER` runs and the database enforces the constraint, rejecting a genuine violation cleanly — so neither `add_not_null` nor `add_unique` surfaces as a `confirm_data_loss` on those dialects.
+
+² `postgresql`, `mssql`, `cockroach` only.
+
+³ `postgresql`, `cockroach` only — materialized-view drops only; regular-view drops do not emit `confirm_data_loss`.
+
+⁴ `postgresql`, `mysql`, `mssql`, `cockroach`, `singlestore` only (no `sqlite`/`turso`).
+
+## Catalog: reasons (`confirm_data_loss` only)
+
+`MissingHint` items of `type: "confirm_data_loss"` carry a `reason` field naming why approval is needed.
+
+| `reason` | applicable `kind`s | explanation | `reason_details` |
+|----------|--------------------|-------------|------------------|
+| `non_empty` | `table`, `column`, `schema`, `view`, `primary_key` | Runtime probed the target entity and found at least one row of existing data. Approval authorizes the DDL to proceed and acknowledges that existing rows will be lost. | — |
+| `table_recreate` | `add_not_null` (`sqlite` / `turso` only) | SQLite has no in-place path to add a `NOT NULL` column, so confirming wipes all rows and recreates the table. Approval acknowledges that the table is recreated and its existing rows are lost. | — |
+| `type_change` | `column` | An existing column's SQL type would change via `alter_column` on MySQL or SingleStore. Approval authorizes the type change. `from`/`to` carry dialect-native column-type spellings (e.g. `varchar(100)`, `int`, `decimal(10,4)`) sourced from the underlying `JsonStatement`. | `{ from: string, to: string }` |
+
+## Identifier formats
+
+Each hint identifies an entity using an `entity`, `from`, or `to` tuple. The arity depends on the entity kind.
+
+| Format | Used by `kind` | Example |
+|--------|----------------|---------|
+| `[name]` | `schema`, `role` | `["tenant_a"]` |
+| `[schema, name]` | `table`, `enum`, `sequence`, `view` | `["public", "users"]` |
+| `[schema, table, name]` | `column`, `default`, `policy`, `check`, `index`, `unique`, `primary_key`, `foreign key`, `add_not_null`¹ | `["public", "users", "email"]` |
+| `[grantor, grantee, schema, table, type]` | `privilege` | `["postgres", "app_user", "public", "users", "select"]` |
+
+¹ `confirm_data_loss` only (`sqlite` / `turso`).
+
+The leading namespace segment keeps tuple arity uniform across dialects, but only postgresql, cockroach, and mssql have a real schema namespace — the `schema` entity kind is wired only for those three. On the schemaless dialects (mysql, sqlite, singlestore) that leading segment is a synthesized `'public'` placeholder, not a real schema. Echo it verbatim; on a schemaless dialect it is filler, never build a separate `schema` rename or create from it.
diff --git a/drizzle-kit/JSON_CONTRACT.md b/drizzle-kit/JSON_CONTRACT.md
new file mode 100644
index 0000000000..907805051e
--- /dev/null
+++ b/drizzle-kit/JSON_CONTRACT.md
@@ -0,0 +1,538 @@
+# Drizzle Kit JSON contract
+
+This document describes the machine-readable contract for `drizzle-kit` commands that support `--output json`.
+
+It is written for tools and services that call Drizzle Kit programmatically.
+
+## Supported commands
+
+`--output json` is supported on:
+
+- `drizzle-kit generate --output json`
+- `drizzle-kit push --output json`
+- `drizzle-kit check --output json`
+- `drizzle-kit pull --output json`
+- `drizzle-kit up --output json`
+- `drizzle-kit export --output json`
+
+When `--output json` is set, callers should treat `stdout` as the JSON channel. Each command invocation writes a single JSON object to `stdout`.
+
+## Programmatic API
+
+The same JSON contract documented in this file is available as typed root-level exports of the `drizzle-kit` package for programmatic callers — agents, build tools, custom orchestrators. The CLI and SDK share one implementation; the response shapes, status discriminator, hint vocabulary, and error codes documented below apply identically to SDK return values.
+
+```typescript
+import { generate, push, check } from 'drizzle-kit';
+import type { GenerateJsonResponse } from 'drizzle-kit';
+
+const response: GenerateJsonResponse = await generate({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+});
+
+if (response.status === 'missing_hints') {
+  // Resolve unresolved items and re-invoke with `hints`. See SDK.md for the full pattern.
+}
+```
+
+What the SDK gives you over the CLI:
+
+- Typed inputs (`GenerateOptions`, `PushOptions`, `CheckOptions`) — your editor narrows option names and types
+- Typed responses (`GenerateJsonResponse`, `PushJsonResponse`) — the union discriminator on `status` lets TypeScript narrow into the `ok`, `no_changes`, `missing_hints`, and `error` branches
+- No `--output json` flag handling, no stdout parsing — the response object is what the JSON mode would have printed
+
+Cross-reference map:
+
+- All `status` values — see [Response statuses](#response-statuses)
+- All `kind` values inside `unresolved`, identifier shapes, and `reason` semantics — see [HINTS.md](./HINTS.md)
+- All `error.code` values — see [Error codes](#error-codes)
+- The `--explain` envelope (SDK callers receive the same payload when `explain: true` is passed) — see [`--explain` in JSON mode](#--explain-in-json-mode)
+- The recommended retry-with-hints flow (the SDK equivalent) — see [Recommended automation flow](#recommended-automation-flow)
+
+For a full end-to-end example including `missing_hints` handling, see [SDK.md](./SDK.md).
+
+## Hints
+
+The hint vocabulary — the rename-vs-create disambiguation, `confirm_data_loss` approvals, the `kind` / `reason` catalogs, and the identifier-tuple formats — is output-agnostic and documented in [HINTS.md](./HINTS.md). In JSON mode there are no prompts: callers either supply hints up front, or receive a `status: "missing_hints"` response (exit code 2) and reply with hints via `--hints` / `--hints-file`. The `missing_hints` envelope shape is documented in [`status: "missing_hints"`](#status-missing_hints) below; the `invalid_hints` error path is in [Error codes](#error-codes).
+
+## Response statuses
+
+### `status: "ok"`
+
+Used when the command completed successfully.
+
+Depending on the command, this can mean:
+
+- explain mode completed successfully
+- changes were applied successfully
+
+Examples:
+
+`generate --output json` success (non-explain):
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "migration_path": "drizzle/20260427153000_name/migration.sql"
+}
+```
+
+`generate --output json --explain` and `push --output json --explain` success (non-empty diff):
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "statements": [],
+  "hints": []
+}
+```
+
+`push --output json` success (non-explain):
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql"
+}
+```
+
+`dialect` is always present on `status: "ok"` responses.
+
+### `status: "no_changes"`
+
+Used when a command succeeds and there is nothing to do.
+
+This includes `generate --output json`, `generate --output json --explain`, `push --output json`, and `push --output json --explain` when the diff is empty.
+
+Current JSON-mode examples:
+
+```json
+{ "status": "no_changes", "dialect": "postgresql" }
+```
+
+```json
+{ "status": "no_changes", "dialect": "sqlite" }
+```
+
+### `status: "missing_hints"`
+
+Used when JSON mode needs explicit caller guidance before it can continue. The full `MissingHint` type definition lives in [hints.ts](./src/cli/hints.ts).
+
+Example response (one item of each `MissingHint.type`):
+
+```json
+{
+  "status": "missing_hints",
+  "unresolved": [
+    {
+      "type": "rename_or_create",
+      "kind": "schema",
+      "entity": ["next_schema"]
+    },
+    {
+      "type": "confirm_data_loss",
+      "kind": "table",
+      "entity": ["public", "users"],
+      "reason": "non_empty"
+    }
+  ]
+}
+```
+
+When this response is emitted, the process exits with code `2`.
+
+Under `--output text` (non-TTY) the same unresolved decisions render as a human-readable report instead — see [OUTPUT_MODES.md](./OUTPUT_MODES.md).
+
+The available `kind` values (per `MissingHint.type`), their per-dialect applicability, the `reason` semantics for `confirm_data_loss`, and the identifier-tuple formats are catalogued in [HINTS.md](./HINTS.md#catalog-kinds-in-unresolved-items).
+
+### `status: "error"`
+
+Used for structured CLI or runtime errors that are surfaced through the JSON error path.
+
+Specific error codes for hint-related impossible operations are enumerated in [Error codes](#error-codes) below; for the full list of CLI error codes, see [errors.ts](./src/cli/errors.ts).
+
+Examples:
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "ambiguous_params_error",
+    "command": "check",
+    "configOption": "config"
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "query_error",
+    "sql": "select 1 from \"users\" limit 1",
+    "params": []
+  }
+}
+```
+
+## Error codes
+
+Structured error responses with `status: "error"` use a `code` field to identify the specific failure. The codes below cover hint-related and impossible-operation paths emitted in JSON mode; for the full list of CLI error codes, see [errors.ts](./src/cli/errors.ts).
+
+| `code` | meta shape | applicable dialects | when emitted |
+|--------|------------|---------------------|--------------|
+| `unsupported_schema_change` | see [unsupported_schema_change variants](#unsupported_schema_change) | `mysql`, `mssql`, `singlestore` | The schema diff would emit a DDL operation that the target dialect cannot execute or rejects (per `meta.kind`) |
+| `invalid_hints` | see [invalid_hints variants](#invalid_hints) | `postgresql`, `mysql`, `sqlite`, `turso`, `mssql`, `cockroach`, `singlestore` | Hints payload could not be loaded, parsed, validated, or applied — see [`invalid_hints`](#invalid_hints) below |
+| `check_error` | see [`check` outcomes](#check) | `postgresql`, `mysql`, `sqlite`, `turso`, `mssql`, `cockroach`, `singlestore` | `check` found a snapshot-integrity problem (`kind: 'unsupported' \| 'malformed' \| 'non_latest'`, carries `snapshot`) or unreported branch conflicts (`kind: 'conflicts'`, carries `conflicts` + `details`) — see [`check`](#check) below |
+| `database_driver_error` | `database`, `packages`, `note?` | `postgresql`, `mysql`, `sqlite`, `turso`, `mssql`, `cockroach`, `singlestore` | A command that connects to a live database (`push`, `pull`) cannot select a connection driver: the required driver package is not installed, or the installed driver is incompatible with the target (for example a local-only turso driver used against a remote turso database). This code is emitted by both connecting commands, push, pull; for `pull` it also covers the connect/introspect span and the `--init` migrate span. `database` is the dialect, `packages` lists the drivers that would satisfy the connection, and `note` carries an optional install caveat. The credential-bearing detail (the connection string, SQL, and params) is never spread into the envelope — only `database`, `packages`, and `note?` are surfaced. |
+
+The example payloads in each variant sub-table show only the `error` object; the full response wraps them in `{"status":"error","error":{…}}`.
+
+### `unsupported_schema_change`
+
+`unsupported_schema_change` is emitted by several different push handlers when the schema diff would produce a DDL operation that the target dialect cannot execute or rejects. The `meta.kind` discriminator selects which of the four variants the response carries; the rest of the meta object follows the variant.
+
+| `meta.kind` | Meta keys | Dialect(s) | When it fires |
+|-------------|-----------|------------|---------------|
+| `drop_pk_dependency` | `kind`, `table`, `columns`, `blocking_fks` | `mysql`, `singlestore` | `ALTER TABLE … DROP PRIMARY KEY` would be rejected because a foreign key references the dropped columns and no covering UNIQUE index exists |
+| `fk_target_not_unique` | `kind`, `table`, `columns`, `table_to`, `columns_to` | `mysql`, `singlestore` | `CREATE FOREIGN KEY` would be rejected because the referenced columns are neither unique nor a primary key |
+| `rename_blocked_by_check_constraint` | `kind`, `schema`, `table`, `from`, `to` | `mssql` | `sp_rename` of a column would be rejected because the column appears in a `CHECK` constraint |
+| `rename_schema_unsupported` | `kind`, `from`, `to`, `dialect` | `mssql` | A `rename_schema` operation was requested — MSSQL does not support schema rename at all |
+
+Examples:
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "unsupported_schema_change",
+    "meta": {
+      "kind": "drop_pk_dependency",
+      "table": "users",
+      "columns": ["id"],
+      "blocking_fks": ["orders_user_id_fk"]
+    }
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "unsupported_schema_change",
+    "meta": {
+      "kind": "fk_target_not_unique",
+      "table": "orders",
+      "columns": ["user_email"],
+      "table_to": "users",
+      "columns_to": ["email"]
+    }
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "unsupported_schema_change",
+    "meta": {
+      "kind": "rename_blocked_by_check_constraint",
+      "schema": "dbo",
+      "table": "users",
+      "from": "old_email",
+      "to": "email"
+    }
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "unsupported_schema_change",
+    "meta": {
+      "kind": "rename_schema_unsupported",
+      "from": "old_analytics",
+      "to": "analytics",
+      "dialect": "mssql"
+    }
+  }
+}
+```
+
+### `invalid_hints`
+
+`invalid_hints` is emitted by several different runtime paths. The meta shape varies by cause; discriminate by checking which keys are present.
+
+| Cause | Meta keys | When it fires |
+|-------|-----------|---------------|
+| File read failure | `source: "file"`, `path` | `--hints-file` was provided but the file could not be read |
+| JSON parse failure | `source: "file"` or `source: "inline"` | Hints JSON failed to parse |
+| Schema validation failure | `source: "file"` or `source: "inline"`, `issues` | One or more hints failed shape validation; `issues` is an array of zod-style issue records |
+| Rename `from` mismatch | `kind`, `from` | A `rename` hint's `from` tuple did not match any entity scheduled for deletion — re-running with the same hint won't change the outcome, so the caller must correct `from` |
+
+Examples:
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "invalid_hints",
+    "source": "file",
+    "path": "hints.json"
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "invalid_hints",
+    "source": "inline",
+    "issues": [{ "path": ["0", "kind"], "message": "Invalid enum value" }]
+  }
+}
+```
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "invalid_hints",
+    "kind": "table",
+    "from": ["public", "users"]
+  }
+}
+```
+
+## `--explain` in JSON mode
+
+`--explain` with `--output json` returns a dry-run result as structured JSON when the diff is non-empty.
+
+`push` and `generate` use the same payload shape:
+
+```json
+{
+  "status": "ok",
+  "dialect": "mysql",
+  "statements": [],
+  "hints": []
+}
+```
+
+When the diff is empty, `push --output json --explain` and `generate --output json --explain` return `status: "no_changes"` instead of this payload.
+
+### `statements`
+
+`statements` is the structured plan Drizzle Kit would execute.
+
+The exact statement objects depend on the dialect and the diff being produced.
+
+Object shapes:
+
+| Dialect | `JsonStatement` definition |
+|---------|----------------------------|
+| PostgreSQL | [`src/dialects/postgres/statements.ts`](./src/dialects/postgres/statements.ts) |
+| MySQL | [`src/dialects/mysql/statements.ts`](./src/dialects/mysql/statements.ts) |
+| SQLite | [`src/dialects/sqlite/statements.ts`](./src/dialects/sqlite/statements.ts) |
+| MSSQL | [`src/dialects/mssql/statements.ts`](./src/dialects/mssql/statements.ts) |
+| CockroachDB | [`src/dialects/cockroach/statements.ts`](./src/dialects/cockroach/statements.ts) |
+| SingleStore | inherits MySQL's `JsonStatement` shape |
+
+### `hints`
+
+`hints` contains human-readable warnings that are safe to show in automation or UIs.
+
+Example:
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "statements": [],
+  "hints": [
+    {
+      "hint": "You're about to delete non-empty users table"
+    }
+  ]
+}
+```
+
+## `check`
+
+`drizzle-kit check --output json` validates the migrations folder — snapshot integrity plus branch commutativity — and emits one of three envelopes. It never prompts and takes no hints. The `check()` SDK export returns the same envelopes verbatim.
+
+### `check` success
+
+When every snapshot is valid and the branches commute, `check` emits the `ok` envelope and exits with code `0`:
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql"
+}
+```
+
+`dialect` is always present, consistent with every other `status: "ok"` response.
+
+### `check` integrity errors
+
+When a snapshot fails integrity validation, `check` emits an `error` envelope with `code: "check_error"` and a `kind` discriminator, and exits with code `1`. The meta is flattened into `error` — `kind` and `snapshot` are siblings of `code`:
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "check_error",
+    "kind": "unsupported",
+    "snapshot": "drizzle/meta/0001_snapshot.json"
+  }
+}
+```
+
+`kind` is one of:
+
+- `unsupported` — the snapshot was written by a Drizzle Kit version this binary cannot read.
+- `malformed` — the snapshot could not be parsed.
+- `non_latest` — the snapshot is not at the latest internal version and must be upgraded.
+
+`snapshot` identifies the offending snapshot.
+
+### `check` conflicts
+
+When the branches do not commute and `--ignore-conflicts` was not passed, `check` emits an `error` envelope with `code: "check_error"`, `kind: "conflicts"`, a `conflicts` count, and a `details` array, and exits with code `1`:
+
+```json
+{
+  "status": "error",
+  "error": {
+    "code": "check_error",
+    "kind": "conflicts",
+    "conflicts": 1,
+    "details": [
+      {
+        "parentId": "0000_initial",
+        "parentPath": "drizzle/0000_initial.sql",
+        "branches": [
+          { "leafId": "0001_a", "leafPath": "drizzle/0001_a.sql", "statementDescription": "create table a" },
+          { "leafId": "0001_b", "leafPath": "drizzle/0001_b.sql", "statementDescription": "create table b" }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Key semantics:
+
+- `conflicts` — the conflict count. `details.length === conflicts`.
+- `details[]` — one entry per conflict.
+  - `parentId` — the common parent migration id.
+  - `parentPath` — the parent migration path, present only when the conflict carries one.
+  - `branches` — always a two-element array (the two diverging branches). Each entry is `{ leafId, leafPath, statementDescription }`, where `leafId` / `leafPath` are the id / path of the last migration in that branch chain (`null` when a chain is empty) and `statementDescription` summarizes the branch.
+
+### `check` exit codes
+
+| outcome | envelope | exit code |
+| --- | --- | --- |
+| valid (snapshots intact, branches commute) | `{ status: "ok", dialect }` | `0` |
+| integrity error (`unsupported` / `malformed` / `non_latest`) | `{ status: "error", error: { code: "check_error", kind, snapshot } }` | `1` |
+| conflicts (no `--ignore-conflicts`) | `{ status: "error", error: { code: "check_error", kind: "conflicts", conflicts, details } }` | `1` |
+| conflicts with `--ignore-conflicts` | `{ status: "ok", dialect }` | `0` |
+
+## `pull`
+
+`drizzle-kit pull --output json` introspects a live database and writes `schema.ts`, an optional `relations.ts`, and a snapshot to the configured `out` directory. The `pull()` SDK export returns the same envelope verbatim. `pull` is **ok-or-error only** — it never emits `missing_hints` (it diffs the introspected database against empty DDL, so there is no rename/data-loss consent surface) and never emits `no_changes` (a pull always writes the introspected files).
+
+### `pull` success
+
+On success `pull` emits a paths-manifest `ok` envelope and exits with code `0`:
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "schemaPath": "drizzle/schema.ts",
+  "relationsPath": "drizzle/relations.ts",
+  "snapshotPath": "drizzle/meta/0000_snapshot.json"
+}
+```
+
+Keys:
+
+- `dialect` — always present, consistent with every other `status: "ok"` response.
+- `schemaPath` — the written `schema.ts`. Always present.
+- `snapshotPath` — the written snapshot JSON. Always present.
+- `relationsPath?` — the written `relations.ts`. **Optional**: present for `postgresql`, `mysql`, `sqlite`, `turso`, `cockroach`, and `singlestore`; omitted for `mssql` (it does not generate a relations file).
+- `migrationPath?` — **Optional**: present only when `--init` ran the initial migration against the live database and wrote a migration file.
+
+With `--init` having written an initial migration:
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "schemaPath": "drizzle/schema.ts",
+  "relationsPath": "drizzle/relations.ts",
+  "snapshotPath": "drizzle/meta/0000_snapshot.json",
+  "migrationPath": "drizzle/0000_init/migration.sql"
+}
+```
+
+On a connect, introspect, or `--init` migrate failure, `pull` emits a `status: "error"` envelope — most commonly [`database_driver_error`](#error-codes), whose meta is redacted to `{ database, packages, note? }` (the connection string / SQL / params are never spread into the envelope).
+
+## `up`
+
+`drizzle-kit up --output json` upgrades on-disk migration snapshots to the latest internal format, rewriting `meta/*_snapshot.json` in place. The `up()` SDK export returns the same envelope verbatim.
+
+### `up` success
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "upgraded": ["drizzle/meta/0000_snapshot.json"]
+}
+```
+
+`upgraded` is the array of rewritten snapshot paths; `[]` means every snapshot was already at the latest format (a no-op).
+
+## `export`
+
+`drizzle-kit export --output json` renders the full schema as a SQL dump by diffing against empty state — no database connection, nothing written. The `exportSql()` SDK export (named to avoid the reserved word `export`) returns the same envelope verbatim.
+
+### `export` success
+
+```json
+{
+  "status": "ok",
+  "dialect": "postgresql",
+  "statements": ["CREATE TABLE \"users\" (\n\t\"id\" serial PRIMARY KEY NOT NULL\n);"],
+  "warnings": []
+}
+```
+
+Keys:
+
+- `statements` — the individual SQL statements that recreate the schema.
+- `warnings` — rendered schema-warning strings; `[]` when none.
+
+There is no joined `sql` field on the `export` envelope; callers join `statements` themselves if a single SQL string is needed.
+
+## Recommended automation flow
+
+1. Run the command with `--output json`.
+2. If the response is `ok`, continue.
+3. If the response is `no_changes`, stop successfully.
+4. If the response is `missing_hints`, inspect `unresolved`.
+5. Build the required hints.
+6. Retry the same command with `--hints` or `--hints-file`.
+
+For programmatic callers, prefer hints over `--force`. The `--force` flag remains available for interactive (non-JSON) push UX where a human user is at the prompt; in `--output json` mode, all warnings must be resolved by supplying hints via `--hints` or `--hints-file`.
diff --git a/drizzle-kit/MCP.md b/drizzle-kit/MCP.md
new file mode 100644
index 0000000000..a54a4e1604
--- /dev/null
+++ b/drizzle-kit/MCP.md
@@ -0,0 +1,48 @@
+# drizzle-kit MCP server
+
+`drizzle-kit mcp` starts a [Model Context Protocol](https://modelcontextprotocol.io) server over stdio, exposing drizzle-kit's migration lifecycle as MCP tools to any MCP-capable agent (Claude Code, Cursor, and others). Launch it from the project root so config resolution defaults to the right working directory:
+
+```sh
+npx drizzle-kit mcp
+```
+
+In a monorepo, "project root" means the workspace package where `drizzle-kit` and `drizzle-orm` are installed — point the server's working directory there, not the repository root. `npx` runs the `drizzle-kit` resolved from that directory; if it finds no local install it fetches a separate copy that cannot resolve your project's `drizzle-orm` and fails the version check.
+
+## Adding the server to your client
+
+See your MCP client's documentation for how to register a stdio server. As an example, a project-scoped entry looks like:
+
+```json
+{ "mcpServers": { "drizzle": { "command": "npx", "args": ["drizzle-kit", "mcp"] } } }
+```
+
+## Tools
+
+| Tool | Parameters | Annotations |
+|------|-----------|-------------|
+| `generate` | `config?`, `hints?`, `name?`, `custom?`, `ignoreConflicts?` | non-destructive |
+| `push` | `config?`, `hints?` | destructive |
+| `check` | `config?`, `ignoreConflicts?` | read-only, idempotent |
+| `export` | `config?` | read-only, idempotent |
+| `up` | `config?` | idempotent (not read-only — rewrites snapshots in place) |
+| `pull` | `config?`, `init?` | `destructiveHint: false` (static — see the `--init` signal below) |
+
+Each tool returns the same JSON envelope as the CLI `--output json` / SDK contract — see [JSON_CONTRACT.md](./JSON_CONTRACT.md) for the full envelope spec.
+
+## Consent round-trip (`missing_hints`)
+
+When `generate` or `push` encounters an ambiguous or destructive change it cannot auto-resolve (a rename, a data-loss operation), the tool returns `status: 'missing_hints'` with an `isError: true` result carrying an `unresolved[]` array. The agent inspects each item, picks a resolution, and re-calls the same tool with a `hints[]` array. The tools expose no `force` parameter — every unresolved decision must be acknowledged explicitly. See [SDK.md — Handling `status: 'missing_hints'`](./SDK.md) for the hint vocabulary and round-trip example.
+
+## `pull --init` destructive signal
+
+The static `listTools` annotation for `pull` is `destructiveHint: false` and cannot flip per call. When the agent calls `pull` with `init: true`, the tool runs the initial migration against the live database — a destructive write — and signals this per-call on the result rather than on the static annotation. The escalation rides the result `_meta` key:
+
+```json
+{ "_meta": { "com.drizzle.team/pull.destructiveHint": true } }
+```
+
+The `_meta` key is set whenever `init: true`, derived from the input alone and independent of `isError`, so a failed `init` call still warns the client. A `pull` without `init` (or with `init: false`) carries no such `_meta` key. This is implemented in `src/mcp/server.ts`.
+
+## Explicit `config` parameter
+
+Every tool accepts an optional `config` path (e.g. `config: "drizzle.config.ts"`). When omitted, resolution follows the standard `drizzle.config.*` lookup in the directory where `drizzle-kit mcp` was launched — the server process cwd, typically the project root. This means config resolution is anchored to the server, never to the MCP client's working directory.
diff --git a/drizzle-kit/OUTPUT_MODES.md b/drizzle-kit/OUTPUT_MODES.md
new file mode 100644
index 0000000000..56c8b05dd2
--- /dev/null
+++ b/drizzle-kit/OUTPUT_MODES.md
@@ -0,0 +1,69 @@
+# Drizzle Kit output modes
+
+Drizzle Kit commands render their results in one of two output modes, selected with `--output`:
+
+- `--output text` (the default) renders human-readable progress and results, including a human-readable report when a command needs decisions you haven't supplied.
+- `--output json` emits the single machine-readable JSON envelope documented in [`./JSON_CONTRACT.md`](./JSON_CONTRACT.md).
+
+Output format, interactivity, and hint resolution are three orthogonal axes. The output mode controls *how* results are rendered; interactivity controls *whether* the CLI may prompt; hints (`--hints` / `--hints-file`) supply decisions ahead of time so the CLI never has to ask.
+
+## `--output text | json`
+
+`generate`, `push`, `check`, `pull`, `up`, and `export` all accept `--output text | json`.
+
+| Mode | Default | Emits |
+| --- | --- | --- |
+| `text` | yes | Human-readable progress and results on stdout; typed errors on stderr. When a command has unresolved decisions, the missing-decisions report (below) is written to stdout and the process exits with code 2. |
+| `json` | no | The single JSON envelope described in [`./JSON_CONTRACT.md`](./JSON_CONTRACT.md), on stdout, for every status (including errors). |
+
+Connection-layer driver-selection chatter (the `Using '<driver>' driver for database querying` lines a connecting command prints while it picks a database driver) follows the same rule: under `--output json` it is suppressed so stdout stays a single JSON envelope, and under `--output text` it still prints as human progress.
+
+`check` is a no-hint, non-interactive gate, so it never reaches the missing-decisions path. Under `--output text` it keeps its current human output (`Everything's fine 🐶🔥` on success, the colorized conflict tree on non-commutativity); under `--output json` it emits the `ok` / `check_error` envelopes documented in [`./JSON_CONTRACT.md`](./JSON_CONTRACT.md).
+
+`pull`, `up`, and `export` are likewise non-interactive (none of them ever reaches the missing-decisions path):
+
+- `pull` — under `--output text` it keeps its banners and hanji introspection progress; under `--output json` it suppresses that chatter and emits the single paths-manifest `ok` envelope (or an `error` envelope on a connect/introspect failure). `pull` connects to a live database, so the driver-selection chatter rule above applies to it too.
+- `export` — under `--output text` it prints the SQL statements and any schema warnings; under `--output json` it emits the `{ status, dialect, statements, warnings }` envelope.
+- `up` — under `--output text` its output is byte-identical to today's human output; under `--output json` it emits the `{ status, dialect, upgraded }` envelope.
+
+## Interactivity
+
+A command is interactive only when it is rendering text **and** stdin is a TTY:
+
+```
+interactive = output === 'text' && !!process.stdin.isTTY
+```
+
+`--output json` is therefore always non-interactive, regardless of whether stdin is a TTY. Under `--output text`, interactivity is determined solely by whether stdin is a TTY (`!process.stdin.isTTY` means non-interactive).
+
+When the CLI is non-interactive and a command reaches a decision it cannot resolve from your `--hints` / `--hints-file`, it does not prompt. Under `--output json` it returns a `missing_hints` envelope; under `--output text` it prints the missing-decisions report below.
+
+## Missing-decisions text report
+
+When you run a command with `--output text` but the CLI is non-interactive (stdin is not a TTY) and at least one decision is still unresolved, the CLI prints a human-readable report to stdout and exits with code 2. The rendered example below shows the full format.
+
+The `from` placeholders are intentionally invalid JSON: you must replace the angle-bracket segments with the real identifier of the entity being renamed before re-running. The placeholder is keyed off the entity's arity, e.g. a two-segment identifier produces `["<schema>", "<old_name>"]`. The CLI never suggests `--hints-file` in the report — only the inline `--hints '<json-array>'` form.
+
+Under `--output text` the report fires only when stdout is not a TTY, so the ANSI styling auto-downgrades to plain ASCII — which is exactly what a piped caller reads. A two-item run renders like this:
+
+```
+missing_hints: 2 unresolved decisions
+
+1. Rename or create  —  table  public.users_v2
+   Add to --hints:
+     { "type": "rename", "kind": "table", "from": ["<schema>", "<old_name>"], "to": ["public", "users_v2"] }
+     OR
+     { "type": "create", "kind": "table", "entity": ["public", "users_v2"] }
+
+2. Confirm data loss  —  table  public.legacy_audit  (reason: non_empty)
+   Add to --hints:
+     { "type": "confirm_data_loss", "kind": "table", "entity": ["public", "legacy_audit"] }
+
+Re-run with --hints '<json-array>'. Exit code 2.
+```
+
+## See also
+
+- [`./HINTS.md`](./HINTS.md) — the output-agnostic hint vocabulary (kinds, reasons, identifier formats, rename/create/confirm semantics).
+- [`./JSON_CONTRACT.md`](./JSON_CONTRACT.md) — the machine-readable JSON envelope contract (statuses, error codes).
+- [`./SDK.md`](./SDK.md) — the programmatic SDK surface, which always receives the JSON envelope.
diff --git a/drizzle-kit/README.md b/drizzle-kit/README.md
index a49ca24dac..abd20ac505 100644
--- a/drizzle-kit/README.md
+++ b/drizzle-kit/README.md
@@ -1,62 +1,35 @@
-## Replit development
-Exposing `drizzle-kit` internal functions via the `drizzle-kit/api` file ([see here](./src/api.ts)) for preparing database migrations in the deploy flow.
+## Drizzle Kit
 
-#### Getting started
-Run the below in the project root:
+Drizzle Kit is a CLI migrator tool for Drizzle ORM. It is probably the one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like deletions and renames by prompting user input.
+<https://github.com/drizzle-team/drizzle-kit-mirror> - is a mirror repository for issues.
 
-```bash
-pnpm install && pnpm build
-```
+## Documentation
 
-#### Development
-Make any changes you require to the `drizzle-kit/api` file ([see here](./drizzle-kit/src/api.ts)), then run (from `drizzle-kit`):
-```bash
-pnpm build
-```
-This will build a `dist` file that you can import into `repl-it-web` using the `file:` by running:
-```bash
-cd pkg/pid2/
+Check the full documentation on [the website](https://orm.drizzle.team/kit-docs/overview).
 
-pnpm add @drizzle-team/drizzle-kit@file:../../../drizzle-orm/drizzle-kit/dist
-```
-Which should add the following to `pkg/pid2/package.json`:
-```
-"@drizzle-team/drizzle-kit": "file:../drizzle-orm/drizzle-kit/dist",
-```
-> [!NOTE]
-> - After any changes to you'll need to run the build command again.
-> - If you're using `drizzle-kit` in pid2 you'll also need to rebuild your pid2 build and re-upload.
+### AI agent skills
 
-#### Publishing changes
-Once your changes have been made, bump the package version in `drizzle-kit/package.json`:
-```
-  "version": "0.31.1",
-```
-Then rebuild to make sure the version number is updated:
-```bash
-pnpm build
-```
-Then run the pack command via `npm`:
-```
-npm run pack
-```
-This should generate a file `package.tgz`, then run the following via `npm`:
-```
-npm run login
-npm run publish
+Drizzle Kit ships installable [Agent Skills](https://skills.sh) for AI coding assistants — Claude Code, Cursor, GitHub Copilot, OpenAI Codex CLI, Gemini CLI, OpenCode, and any other tool that loads the open standard.
+
+Install into your project's agent config:
+
+```sh
+npx drizzle-kit skills
 ```
-> [!NOTE]
-> - In repl-it-web we scope drizzle packages to our replit-internal npm registry via the @drizzle-team scope, hence we've updated the package name to `@drizzle-team/drizzle-kit` and not just `drizzle-kit`.
-> - Because we don't require the rest of `drizzle-orm` we import it via a package and not the pnpm workspace, e.g `"drizzle-orm": "0.44.1",` vs `"drizzle-orm": "workspace:./drizzle-orm/dist",`. This means we don't have to build the whole drizzle-orm library in order to make changes. If at any point we decide to import more private packages from drizzle-orm then we can revert.
 
-## Drizzle Kit
+Under the hood the command runs the [skills](https://skills.sh) CLI against drizzle-kit's bundled skill catalog and installs `SKILL.md` files directly into your agent's native skills directory — `.claude/skills/<slug>/SKILL.md` for Claude Code, and `.agents/skills/<slug>/SKILL.md` for Codex, Cursor, Gemini CLI, Cline, GitHub Copilot, and any other agent that follows the universal `AGENTS.md` skills convention.
 
-Drizzle Kit is a CLI migrator tool for Drizzle ORM. It is probably the one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like deletions and renames by prompting user input.
-<https://github.com/drizzle-team/drizzle-kit-mirror> - is a mirror repository for issues.
+TanStack Intent users can still surface the same skills via `intent list` — `SKILL.md` files remain bundled in the npm tarball.
 
-## Documentation
+### MCP server
 
-Check the full documentation on [the website](https://orm.drizzle.team/kit-docs/overview).
+`drizzle-kit mcp` starts a Model Context Protocol server over stdio, exposing drizzle-kit's migration lifecycle (`generate`, `push`, `check`) as MCP tools to any MCP-capable agent. Launch it from the project root so config resolution defaults to the right working directory:
+
+```sh
+npx drizzle-kit mcp
+```
+
+See your MCP client's docs for how to add a server. For details, see [MCP.md](./MCP.md).
 
 ### How it works
 
diff --git a/drizzle-kit/SDK.md b/drizzle-kit/SDK.md
new file mode 100644
index 0000000000..1a80e37460
--- /dev/null
+++ b/drizzle-kit/SDK.md
@@ -0,0 +1,235 @@
+# Drizzle Kit SDK
+
+The same JSON contract the `drizzle-kit` CLI emits is available as typed root-level exports for programmatic callers — agents, build tools, custom orchestrators. The CLI and SDK share one implementation; behavior, status discriminators, hint vocabulary, and error codes are identical to what is documented in [JSON_CONTRACT.md](./JSON_CONTRACT.md).
+
+This document covers the public SDK surface. For the full machine-readable contract (status table, error code table), read [JSON_CONTRACT.md](./JSON_CONTRACT.md); the hint vocabulary is in [HINTS.md](./HINTS.md).
+
+## Install
+
+```bash
+npm install drizzle-kit drizzle-orm
+```
+
+## Public surface
+
+`--output` is a CLI-only concept. The SDK is implicitly JSON: `generate`, `push`, `check`, `pull`, `up`, and `exportSql` always resolve to the JSON envelope documented in [JSON_CONTRACT.md](./JSON_CONTRACT.md), and there is no caller-supplied output mode (the option types omit `output`). Callers narrow the result on its `status` discriminator rather than selecting a format.
+
+Seven root-level values plus the per-function option-type aliases:
+
+| Export | Kind | Purpose |
+|---|---|---|
+| `defineConfig` | function | Type-checked Drizzle config builder (CLI parity) |
+| `generate` | async function | Programmatic equivalent of `drizzle-kit generate --output json` |
+| `push` | async function | Programmatic equivalent of `drizzle-kit push --output json` |
+| `check` | async function | Programmatic equivalent of `drizzle-kit check --output json` |
+| `pull` | async function | Programmatic equivalent of `drizzle-kit pull --output json` |
+| `up` | async function | Programmatic equivalent of `drizzle-kit up --output json` |
+| `exportSql` | async function | Programmatic equivalent of `drizzle-kit export --output json` (named `exportSql` because `export` is a reserved word) |
+| `Config` | type | Discriminated union of dialect configs |
+| `GenerateOptions` | type | Input shape for `generate` |
+| `PushOptions` | type | Input shape for `push` |
+| `CheckOptions` | type | Input shape for `check` |
+| `PullOptions` | type | Input shape for `pull` (includes `init?`) |
+| `UpOptions` | type | Input shape for `up` |
+| `ExportOptions` | type | Input shape for `exportSql` |
+
+The response shape is not a named export: infer it from the call with `Awaited<ReturnType<typeof generate>>` / `Awaited<ReturnType<typeof push>>` / `Awaited<ReturnType<typeof check>>` / `Awaited<ReturnType<typeof pull>>` / `Awaited<ReturnType<typeof up>>` / `Awaited<ReturnType<typeof exportSql>>` (see the examples below). All other public-surface details (status discriminator values, error codes in [JSON_CONTRACT.md](./JSON_CONTRACT.md); hint kinds in [HINTS.md](./HINTS.md)) apply identically to SDK return values — they are not restated here.
+
+```typescript
+import { defineConfig, generate, push, check, pull, up, exportSql } from 'drizzle-kit';
+import type { Config, GenerateOptions, PushOptions, CheckOptions, PullOptions, UpOptions, ExportOptions } from 'drizzle-kit';
+```
+
+## Minimal `generate` example
+
+```typescript
+import { generate } from 'drizzle-kit';
+
+type GenerateResponse = Awaited<ReturnType<typeof generate>>;
+
+const response: GenerateResponse = await generate({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+});
+
+if (response.status === 'ok') {
+  // `migration_path` is present for dialects that write a migration file (e.g. postgresql, sqlite).
+  if ('migration_path' in response) {
+    console.log(`Generated migration at ${response.migration_path}`);
+  } else {
+    console.log('Generated migration');
+  }
+} else if (response.status === 'no_changes') {
+  console.log('Schema in sync — no migration needed');
+} else if (response.status === 'error') {
+  console.error(`generate failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Minimal `push` example
+
+```typescript
+import { push } from 'drizzle-kit';
+
+type PushResponse = Awaited<ReturnType<typeof push>>;
+
+const response: PushResponse = await push({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  url: process.env.DATABASE_URL!,
+});
+
+if (response.status === 'ok') {
+  console.log(`Applied schema changes to the live ${response.dialect} database`);
+} else if (response.status === 'no_changes') {
+  console.log('Database already in sync');
+} else if (response.status === 'error') {
+  console.error(`push failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Minimal `check` example
+
+```typescript
+import { check } from 'drizzle-kit';
+
+type CheckResponse = Awaited<ReturnType<typeof check>>;
+
+const response: CheckResponse = await check({
+  dialect: 'postgresql',
+  out: './drizzle',
+});
+
+if (response.status === 'ok') {
+  console.log(`Migrations folder is valid (${response.dialect})`);
+} else if (response.status === 'error') {
+  console.error(`check failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Minimal `pull` example
+
+`pull` is ok-or-error only — it never returns `missing_hints` or `no_changes`.
+
+```typescript
+import { pull } from 'drizzle-kit';
+
+type PullResponse = Awaited<ReturnType<typeof pull>>;
+
+const response: PullResponse = await pull({
+  dialect: 'postgresql',
+  out: './drizzle',
+});
+
+if (response.status === 'ok') {
+  console.log(`Wrote ${response.schemaPath} and ${response.snapshotPath}`);
+  // `relationsPath` is present for every dialect except mssql; `migrationPath` only with `init: true`.
+  if ('relationsPath' in response) {
+    console.log(`Relations: ${response.relationsPath}`);
+  }
+} else if (response.status === 'error') {
+  console.error(`pull failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Minimal `up` example
+
+```typescript
+import { up } from 'drizzle-kit';
+
+type UpResponse = Awaited<ReturnType<typeof up>>;
+
+const response: UpResponse = await up({
+  dialect: 'postgresql',
+  out: './drizzle',
+});
+
+if (response.status === 'ok') {
+  // `upgraded` lists rewritten snapshot paths; [] means everything was already current.
+  console.log(`Upgraded ${response.upgraded.length} snapshot(s)`);
+} else if (response.status === 'error') {
+  console.error(`up failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Minimal `export` example
+
+```typescript
+import { exportSql } from 'drizzle-kit';
+
+type ExportResponse = Awaited<ReturnType<typeof exportSql>>;
+
+const response: ExportResponse = await exportSql({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+});
+
+if (response.status === 'ok') {
+  // The full schema as individual SQL statements; join them yourself if you need one string.
+  console.log(response.statements.join('\n'));
+} else if (response.status === 'error') {
+  console.error(`export failed (${response.error.code})`);
+  process.exit(1);
+}
+```
+
+## Handling `status: 'missing_hints'`
+
+The most important agent-facing branch. When `generate` or `push` detects an ambiguity (a rename vs. drop+create, a destructive operation needing confirmation, a new schema declaration), it returns `status: 'missing_hints'` with an `unresolved` array describing each ambiguity. The caller picks a resolution for each item, builds a hint array, and re-invokes with the same options plus `hints`.
+
+Hint vocabulary (which `kind` values are valid, what each `meta` shape contains) is documented in [HINTS.md](./HINTS.md) — this guide shows only the SDK call pattern.
+
+```typescript
+import { generate, type Hint } from 'drizzle-kit';
+
+type GenerateResponse = Awaited<ReturnType<typeof generate>>;
+type Unresolved = Extract<GenerateResponse, { status: 'missing_hints' }>['unresolved'][number];
+
+async function generateWithHints(): Promise<GenerateResponse> {
+  const baseOptions = {
+    dialect: 'postgresql' as const,
+    schema: './src/db/schema.ts',
+    out: './drizzle',
+  };
+
+  // First call — no hints.
+  const first: GenerateResponse = await generate(baseOptions);
+  if (first.status !== 'missing_hints') return first;
+  // first.status === 'missing_hints' from here on — `unresolved` is now narrowed.
+
+  // Build resolutions. Each unresolved item dictates which `kind` and `meta` to send.
+  // See HINTS.md "Catalog: kinds in unresolved items" for the full mapping.
+  const hints = first.unresolved.map((item) => resolveHint(item));
+
+  // Re-invoke with the raw hint array — the SDK takes `Hint[]` directly.
+  return generate({
+    ...baseOptions,
+    hints,
+  });
+}
+
+function resolveHint(item: Unresolved): Hint {
+  // Application-specific resolution policy — agent prompts, user prompts, or static rules.
+  throw new Error(`Provide a hint resolution for ${JSON.stringify(item)}`);
+}
+```
+
+Notes:
+
+- `hints` is a raw `Hint[]` (the CLI `--hints` flag is the JSON-string form of the same array). For long hint sets, use `hintsFile` with a path to a JSON file instead.
+- A second `missing_hints` response after providing hints means the hint set was incomplete or invalid — see [JSON_CONTRACT.md Error codes](./JSON_CONTRACT.md#error-codes) for `invalid_hints` diagnostics.
+- The same flow applies to `push` — substitute `push` and its inferred `Awaited<ReturnType<typeof push>>` response everywhere.
+
+## Cross-references
+
+- [JSON_CONTRACT.md Programmatic API](./JSON_CONTRACT.md#programmatic-api) — short SDK pitch in the v1-stable contract doc
+- [JSON_CONTRACT.md Response statuses](./JSON_CONTRACT.md#response-statuses) — full status catalog
+- [HINTS.md](./HINTS.md) — hint vocabulary and shapes
+- [JSON_CONTRACT.md Error codes](./JSON_CONTRACT.md#error-codes) — error.code table
+- [JSON_CONTRACT.md Recommended automation flow](./JSON_CONTRACT.md#recommended-automation-flow) — CLI-side equivalent of the SDK pattern above
diff --git a/drizzle-kit/build.cli.ts b/drizzle-kit/build.cli.ts
new file mode 100644
index 0000000000..416e3013c2
--- /dev/null
+++ b/drizzle-kit/build.cli.ts
@@ -0,0 +1,44 @@
+/// <reference types="bun-types" />
+import * as esbuild from 'esbuild';
+import pkg from './package.json';
+import { readSkillsRevisionFromDisk } from './scripts/lib/read-skills-revision';
+
+const driversPackages = [
+	// postgres drivers
+	'pg',
+	'postgres',
+	'@vercel/postgres',
+	'@neondatabase/serverless',
+	'@electric-sql/pglite',
+	//  mysql drivers
+	'mysql2',
+	'@planetscale/database',
+	// sqlite drivers
+	'@libsql/client',
+	'better-sqlite3',
+	'bun:sqlite',
+	'@sqlitecloud/drivers',
+	'@tursodatabase/database',
+	'bun',
+];
+
+esbuild.buildSync({
+	entryPoints: ['./src/cli/index.ts'],
+	bundle: true,
+	outfile: 'dist/bin.cjs',
+	format: 'cjs',
+	target: 'node16',
+	platform: 'node',
+	define: {
+		'process.env.DRIZZLE_KIT_VERSION': `"${pkg.version}"`,
+		'process.env.DRIZZLE_KIT_SKILLS_REVISION': `"${readSkillsRevisionFromDisk('./skills')}"`,
+	},
+	external: [
+		'esbuild',
+		'drizzle-orm',
+		...driversPackages,
+	],
+	banner: {
+		js: `#!/usr/bin/env node`,
+	},
+});
diff --git a/drizzle-kit/build.dev.ts b/drizzle-kit/build.dev.ts
index 58879d9c17..3997dda5ba 100644
--- a/drizzle-kit/build.dev.ts
+++ b/drizzle-kit/build.dev.ts
@@ -7,27 +7,19 @@ const driversPackages = [
 	'postgres',
 	'@vercel/postgres',
 	'@neondatabase/serverless',
+	'@electric-sql/pglite',
 	//  mysql drivers
 	'mysql2',
 	'@planetscale/database',
 	// sqlite drivers
 	'@libsql/client',
 	'better-sqlite3',
+	'bun:sqlite',
+	'@sqlitecloud/drivers',
+	'@tursodatabase/database',
+	'bun',
 ];
 
-esbuild.buildSync({
-	entryPoints: ['./src/utils.ts'],
-	bundle: true,
-	outfile: 'dist/utils.js',
-	format: 'cjs',
-	target: 'node16',
-	platform: 'node',
-	external: ['drizzle-orm', 'esbuild', ...driversPackages],
-	banner: {
-		js: `#!/usr/bin/env -S node --loader @esbuild-kit/esm-loader --no-warnings`,
-	},
-});
-
 esbuild.buildSync({
 	entryPoints: ['./src/cli/index.ts'],
 	bundle: true,
diff --git a/drizzle-kit/build.ext.ts b/drizzle-kit/build.ext.ts
new file mode 100644
index 0000000000..3a0a6a5688
--- /dev/null
+++ b/drizzle-kit/build.ext.ts
@@ -0,0 +1,65 @@
+import * as tsup from 'tsup';
+// import { readFileSync, writeFileSync } from 'node:fs';
+
+const main = async () => {
+	// await tsup.build({
+	// 	entryPoints: ['./src/utils/studio.ts'],
+	// 	outDir: './dist',
+	// 	external: [],
+	// 	splitting: false,
+	// 	dts: true,
+	// 	platform: 'browser',
+	// 	format: ['esm'],
+	// });
+
+	await tsup.build({
+		entryPoints: ['./src/ext/studio-sqlite.ts'],
+		outDir: './dist',
+		external: [],
+		splitting: false,
+		dts: true,
+		platform: 'browser',
+		format: ['esm'],
+	});
+
+	await tsup.build({
+		entryPoints: ['./src/ext/studio-postgres.ts'],
+		outDir: './dist',
+		external: [],
+		splitting: false,
+		dts: true,
+		platform: 'browser',
+		format: ['esm'],
+		// noExternal: ['@js-temporal/polyfill'],
+	});
+
+	await tsup.build({
+		entryPoints: ['./src/ext/studio-mysql.ts'],
+		outDir: './dist',
+		external: [],
+		splitting: false,
+		dts: true,
+		platform: 'browser',
+		format: ['esm'],
+	});
+
+	// await tsup.build({
+	// 	entryPoints: ['./src/utils/mover-postgres.ts', './src/utils/mover-mysql.ts'],
+	// 	outDir: './dist',
+	// 	external: [],
+	// 	splitting: false,
+	// 	dts: true,
+	// 	platform: 'browser',
+	// 	format: ['esm'],
+	// });
+};
+
+main().then(() => {
+	process.exit(0);
+}).catch((e) => {
+	console.error(e);
+	process.exit(1);
+});
+
+// const apiCjs = readFileSync('./dist/api.js', 'utf8').replace(/await import\(/g, 'require(');
+// writeFileSync('./dist/api.js', apiCjs);
diff --git a/drizzle-kit/build.ts b/drizzle-kit/build.ts
index e11e10724d..bec3ded177 100644
--- a/drizzle-kit/build.ts
+++ b/drizzle-kit/build.ts
@@ -3,6 +3,7 @@ import * as esbuild from 'esbuild';
 import { readFileSync, writeFileSync } from 'node:fs';
 import * as tsup from 'tsup';
 import pkg from './package.json';
+import { readSkillsRevisionFromDisk } from './scripts/lib/read-skills-revision';
 
 const driversPackages = [
 	// postgres drivers
@@ -18,51 +19,14 @@ const driversPackages = [
 	'@libsql/client',
 	'better-sqlite3',
 	'bun:sqlite',
+	'@sqlitecloud/drivers',
+	'@tursodatabase/database',
+	'bun',
+	// duckdb drivers
+	'duckdb',
+	'@duckdb/node-api',
 ];
 
-// Problematic dependencies that should be external
-const externalDeps = [
-	'json-diff',
-	'commander',
-	'glob',
-];
-
-esbuild.buildSync({
-	entryPoints: ['./src/utils.ts'],
-	bundle: true,
-	outfile: 'dist/utils.js',
-	format: 'cjs',
-	target: 'node16',
-	platform: 'node',
-	external: [
-		'esbuild',
-		'drizzle-orm',
-		...driversPackages,
-		...externalDeps,
-	],
-	banner: {
-		js: `#!/usr/bin/env node`,
-	},
-});
-
-esbuild.buildSync({
-	entryPoints: ['./src/utils.ts'],
-	bundle: true,
-	outfile: 'dist/utils.mjs',
-	format: 'esm',
-	target: 'node16',
-	platform: 'node',
-	external: [
-		'esbuild',
-		'drizzle-orm',
-		...driversPackages,
-		...externalDeps,
-	],
-	banner: {
-		js: `#!/usr/bin/env node`,
-	},
-});
-
 esbuild.buildSync({
 	entryPoints: ['./src/cli/index.ts'],
 	bundle: true,
@@ -72,6 +36,7 @@ esbuild.buildSync({
 	platform: 'node',
 	define: {
 		'process.env.DRIZZLE_KIT_VERSION': `"${pkg.version}"`,
+		'process.env.DRIZZLE_KIT_SKILLS_REVISION': `"${readSkillsRevisionFromDisk('./skills')}"`,
 	},
 	external: [
 		'esbuild',
@@ -85,15 +50,49 @@ esbuild.buildSync({
 
 const main = async () => {
 	await tsup.build({
-		entryPoints: ['./src/index.ts', './src/api.ts'],
+		entryPoints: ['./src/index.ts'],
+		outDir: './dist',
+		external: driversPackages,
+		splitting: false,
+		dts: true,
+		format: ['cjs', 'esm'],
+		outExtension: (ctx) => {
+			if (ctx.format === 'cjs') {
+				return {
+					dts: '.d.ts',
+					js: '.js',
+				};
+			}
+			return {
+				dts: '.d.mts',
+				js: '.mjs',
+			};
+		},
+	});
+
+	await tsup.build({
+		entryPoints: ['./src/ext/api-postgres.ts', './src/ext/api-mysql.ts', './src/ext/api-sqlite.ts'],
 		outDir: './dist',
 		external: [
-			'bun:sqlite',
-			...externalDeps,
+			'esbuild',
+			'drizzle-orm',
+			...driversPackages,
 		],
 		splitting: false,
 		dts: true,
 		format: ['cjs', 'esm'],
+		banner: (ctx) => {
+			/**
+			 * fix dynamic require in ESM ("glob" -> "fs.realpath" requires 'fs' module)
+			 * @link https://github.com/drizzle-team/drizzle-orm/issues/2853
+			 */
+			if (ctx.format === 'esm') {
+				return {
+					js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+				};
+			}
+			return;
+		},
 		outExtension: (ctx) => {
 			if (ctx.format === 'cjs') {
 				return {
@@ -108,8 +107,124 @@ const main = async () => {
 		},
 	});
 
-	const apiCjs = readFileSync('./dist/api.js', 'utf8').replace(/await import\(/g, 'require(');
-	writeFileSync('./dist/api.js', apiCjs);
+	writeFileSync(
+		'./dist/api-postgres.js',
+		readFileSync('./dist/api-postgres.js', 'utf8').replace(/await import\(/g, 'require('),
+	);
+
+	// await tsup.build({
+	// 	entryPoints: [],
+	// 	outDir: './dist',
+	// 	external: ['bun:sqlite'],
+	// 	splitting: false,
+	// 	dts: true,
+	// 	format: ['cjs', 'esm'],
+	// 	banner: (ctx) => {
+	// 		/**
+	// 		 * fix dynamic require in ESM ("glob" -> "fs.realpath" requires 'fs' module)
+	// 		 * @link https://github.com/drizzle-team/drizzle-orm/issues/2853
+	// 		 */
+	// 		if (ctx.format === 'esm') {
+	// 			return {
+	// 				js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+	// 			};
+	// 		}
+	// 		return;
+	// 	},
+	// 	outExtension: (ctx) => {
+	// 		if (ctx.format === 'cjs') {
+	// 			return {
+	// 				dts: '.d.ts',
+	// 				js: '.js',
+	// 			};
+	// 		}
+	// 		return {
+	// 			dts: '.d.mts',
+	// 			js: '.mjs',
+	// 		};
+	// 	},
+	// });
+
+	writeFileSync(
+		'./dist/api-mysql.js',
+		readFileSync('./dist/api-mysql.js', 'utf8').replace(/await import\(/g, 'require('),
+	);
+
+	// await tsup.build({
+	// 	entryPoints: [],
+	// 	outDir: './dist',
+	// 	external: ['bun:sqlite'],
+	// 	splitting: false,
+	// 	dts: true,
+	// 	format: ['cjs', 'esm'],
+	// 	banner: (ctx) => {
+	// 		/**
+	// 		 * fix dynamic require in ESM ("glob" -> "fs.realpath" requires 'fs' module)
+	// 		 * @link https://github.com/drizzle-team/drizzle-orm/issues/2853
+	// 		 */
+	// 		if (ctx.format === 'esm') {
+	// 			return {
+	// 				js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+	// 			};
+	// 		}
+	// 		return;
+	// 	},
+	// 	outExtension: (ctx) => {
+	// 		if (ctx.format === 'cjs') {
+	// 			return {
+	// 				dts: '.d.ts',
+	// 				js: '.js',
+	// 			};
+	// 		}
+	// 		return {
+	// 			dts: '.d.mts',
+	// 			js: '.mjs',
+	// 		};
+	// 	},
+	// });
+
+	writeFileSync(
+		'./dist/api-sqlite.js',
+		readFileSync('./dist/api-sqlite.js', 'utf8').replace(/await import\(/g, 'require('),
+	);
+
+	// await tsup.build({
+	// 	entryPoints: ['./src/ext/api-singlestore.ts'],
+	// 	outDir: './dist',
+	// 	external: ['bun:sqlite'],
+	// 	splitting: false,
+	// 	dts: true,
+	// 	format: ['cjs', 'esm'],
+	// 	banner: (ctx) => {
+	// 		/**
+	// 		 * fix dynamic require in ESM ("glob" -> "fs.realpath" requires 'fs' module)
+	// 		 * @link https://github.com/drizzle-team/drizzle-orm/issues/2853
+	// 		 */
+	// 		if (ctx.format === 'esm') {
+	// 			return {
+	// 				js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+	// 			};
+	// 		}
+	// 		return;
+	// 	},
+	// 	outExtension: (ctx) => {
+	// 		if (ctx.format === 'cjs') {
+	// 			return {
+	// 				dts: '.d.ts',
+	// 				js: '.js',
+	// 			};
+	// 		}
+	// 		return {
+	// 			dts: '.d.mts',
+	// 			js: '.mjs',
+	// 		};
+	// 	},
+	// });
+
+	// writeFileSync(
+	// 	'./dist/api-singlestore.js',
+	// 	readFileSync('./dist/api-singlestore.js', 'utf8').replace(/await import\(/g, 'require('),
+	// );
 };
 
 main().catch((e) => {
diff --git a/drizzle-kit/imports-checker/analyze.ts b/drizzle-kit/imports-checker/analyze.ts
index b31686e166..8db4e4f276 100644
--- a/drizzle-kit/imports-checker/analyze.ts
+++ b/drizzle-kit/imports-checker/analyze.ts
@@ -45,9 +45,10 @@ function init(collection: CollectionItem[]) {
 
 		ImportExpr_From(kImport, importInner, kFrom, importSource) {
 			const ruleName = importInner.children[0]!.ctorName;
-			const importType = ruleName === 'ImportInner_Type' || ruleName === 'ImportInner_Types'
-				? 'types'
-				: 'data';
+			const importType =
+				ruleName === 'ImportInner_Type' || ruleName === 'ImportInner_Types' || ruleName === 'ImportInner_AllTypes'
+					? 'types'
+					: 'data';
 
 			collection.push({
 				source: importSource.children[1]!.sourceString!,
diff --git a/drizzle-kit/imports-checker/checker.ts b/drizzle-kit/imports-checker/checker.ts
index d8fc4b2195..06ea81475a 100644
--- a/drizzle-kit/imports-checker/checker.ts
+++ b/drizzle-kit/imports-checker/checker.ts
@@ -49,7 +49,7 @@ class ImportAnalyzer {
 	private isDirectory = (path: string) => {
 		try {
 			return fs.lstatSync(path).isDirectory();
-		} catch (e) {
+		} catch {
 			return false;
 		}
 	};
@@ -57,7 +57,7 @@ class ImportAnalyzer {
 	private isFile = (path: string) => {
 		try {
 			return fs.lstatSync(path).isFile();
-		} catch (e) {
+		} catch {
 			return false;
 		}
 	};
@@ -154,8 +154,6 @@ class ImportAnalyzer {
 					type: type,
 				});
 			}
-		} catch (e) {
-			throw e;
 		} finally {
 			this.visited.add(target);
 		}
diff --git a/drizzle-kit/imports-checker/grammar/grammar.ohm b/drizzle-kit/imports-checker/grammar/grammar.ohm
index de1459942c..64ffeb9a2f 100644
--- a/drizzle-kit/imports-checker/grammar/grammar.ohm
+++ b/drizzle-kit/imports-checker/grammar/grammar.ohm
@@ -16,6 +16,7 @@ JSImports {
     ImportInner = 
     | ("type" "{" NonemptyListOf<ImportExtendedSelectionTypeless, ","> ","? "}")            -- Type
     | ("{" NonemptyListOf<ImportExtendedSelectionTypes, ","> ","? "}")                      -- Types
+    | ("type " "*")                                                                         -- AllTypes
     | ("{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")                           -- Extended
     | (identifier ("," "type"? "{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")?) -- Mixed
     | ("*" ("as" identifier)?)                                                              -- All
@@ -29,7 +30,7 @@ JSImports {
     Import = identifier ("as" identifier)?
     TypeImport = "type" Import ("as" identifier)?
 
-    identifier = letter alnum*
+    identifier = (letter | "_" | "$" | "~" ) (alnum | "_" | "$" | "~")*
     quote = "\"" | "'" | "`"
     notQuote = ~quote any
     importSource =
diff --git a/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.d.ts b/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.d.ts
index 64b5dfb787..abe3d43677 100644
--- a/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.d.ts
+++ b/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.d.ts
@@ -31,6 +31,7 @@ export interface JSImportsActionDict<T> extends BaseActionDict<T> {
 		arg2: IterationNode,
 		arg3: TerminalNode,
 	) => T;
+	ImportInner_AllTypes?: (this: NonterminalNode, arg0: TerminalNode, arg1: TerminalNode) => T;
 	ImportInner_Extended?: (
 		this: NonterminalNode,
 		arg0: TerminalNode,
@@ -62,7 +63,7 @@ export interface JSImportsActionDict<T> extends BaseActionDict<T> {
 		arg2: IterationNode,
 		arg3: IterationNode,
 	) => T;
-	identifier?: (this: NonterminalNode, arg0: NonterminalNode, arg1: IterationNode) => T;
+	identifier?: (this: NonterminalNode, arg0: NonterminalNode | TerminalNode, arg1: IterationNode) => T;
 	quote?: (this: NonterminalNode, arg0: TerminalNode) => T;
 	notQuote?: (this: NonterminalNode, arg0: NonterminalNode) => T;
 	importSource?: (this: NonterminalNode, arg0: TerminalNode, arg1: IterationNode, arg2: TerminalNode) => T;
diff --git a/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.js b/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.js
index 9a889d66f3..c826dad18d 100644
--- a/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.js
+++ b/drizzle-kit/imports-checker/grammar/grammar.ohm-bundle.js
@@ -3,7 +3,7 @@ const result = makeRecipe([
 	'grammar',
 	{
 		source:
-			'JSImports {\n    JSImports = (Expr ";"?)*\n\n    Expr = \n    | comment\n    | stringLiteral\n    | ImportExpr\n    | Rest\n\n    ImportExpr =\n    | "import" ImportInner "from" importSource -- From\n    | "import" importSource -- NoFrom\n\n    Rest = (~(ImportExpr | comment | stringLiteral) any)+\n\n    ImportInner = \n    | ("type" "{" NonemptyListOf<ImportExtendedSelectionTypeless, ","> ","? "}")            -- Type\n    | ("{" NonemptyListOf<ImportExtendedSelectionTypes, ","> ","? "}")                      -- Types\n    | ("{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")                           -- Extended\n    | (identifier ("," "type"? "{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")?) -- Mixed\n    | ("*" ("as" identifier)?)                                                              -- All\n    | (identifier ("as" identifier)?)                                                       -- Default\n    \n\n    ImportExtendedSelection = TypeImport | Import\n    ImportExtendedSelectionTypes = TypeImport\n    ImportExtendedSelectionTypeless = Import\n\n    Import = identifier ("as" identifier)?\n    TypeImport = "type" Import ("as" identifier)?\n\n    identifier = letter alnum*\n    quote = "\\"" | "\'" | "`"\n    notQuote = ~quote any\n    importSource =\n    | "\\"" notQuote+ "\\""\n    | "\'" notQuote+ "\'"\n    | "`" notQuote+ "`"\n\n    lineTerminator = "\\n" | "\\r" | "\\u2028" | "\\u2029"\n    lineTerminatorSequence = "\\n" | "\\r" ~"\\n" | "\\u2028" | "\\u2029" | "\\r\\n"\n    \n    comment = multiLineComment | singleLineComment\n\n    multiLineComment = "/*" (~"*/" any)* "*/"\n    singleLineComment = "//" (~lineTerminator any)*\n\n    stringLiteral =\n    | "\\"" doubleStringCharacter* "\\""\n    | "\'" singleStringCharacter* "\'"\n    | "`" templateStringCharacter* "`"\n    doubleStringCharacter =\n    | ~("\\"" | "\\\\" | lineTerminator) any   -- NonEscaped\n    | "\\\\" escapeSequence                   -- Escaped\n    | lineContinuation                      -- LineContinuation\n    singleStringCharacter =\n    | ~("\'" | "\\\\" | lineTerminator) any    -- NonEscaped\n    | "\\\\" escapeSequence                   -- Escaped\n    | lineContinuation                      -- LineContinuation\n    templateStringCharacter = \n    | ~ ("`" | "\\\\") any                    -- NonEscaped\n    | "\\\\" escapeSequence                        -- Escaped\n    lineContinuation = "\\\\" lineTerminatorSequence\n    escapeSequence = unicodeEscapeSequence | hexEscapeSequence | octalEscapeSequence | characterEscapeSequence\n    characterEscapeSequence = singleEscapeCharacter | nonEscapeCharacter\n    singleEscapeCharacter = "\'" | "\\"" | "\\\\" | "b" | "f" | "n" | "r" | "t" | "v"\n    nonEscapeCharacter = ~(escapeCharacter | lineTerminator) any\n    escapeCharacter = singleEscapeCharacter | decimalDigit | "x" | "u"\n    octalEscapeSequence =\n    | zeroToThree octalDigit octalDigit     -- Whole\n    | fourToSeven octalDigit                -- EightTimesfourToSeven\n    | zeroToThree octalDigit ~decimalDigit  -- EightTimesZeroToThree\n    | octalDigit ~decimalDigit              -- Octal\n    hexEscapeSequence = "x" hexDigit hexDigit\n    unicodeEscapeSequence = "u" hexDigit hexDigit hexDigit hexDigit\n\n    zeroToThree = "0".."3"\n    fourToSeven = "4".."7"\n    decimalDigit = "0".."9"\n    nonZeroDigit = "1".."9"\n    octalDigit = "0".."7"\n\n    regularExpressionLiteral = "/" regularExpressionBody "/" regularExpressionFlags\n    regularExpressionBody = regularExpressionFirstChar regularExpressionChar*\n    regularExpressionFirstChar =\n    | ~("*" | "\\\\" | "/" | "[") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    | regularExpressionClass\n    regularExpressionChar = ~("\\\\" | "/" | "[") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    | regularExpressionClass\n    regularExpressionBackslashSequence = "\\\\" regularExpressionNonTerminator\n    regularExpressionNonTerminator = ~(lineTerminator) any\n    regularExpressionClass = "[" regularExpressionClassChar* "]"\n    regularExpressionClassChar =\n    | ~("]" | "\\\\") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    regularExpressionFlags = identifierPart*\n\n    multiLineCommentNoNL = "/*" (~("*/" | lineTerminator) any)* "*/"\n\n    identifierStart =\n    | letter | "$" | "_"\n    | "\\\\" unicodeEscapeSequence -- escaped\n    identifierPart =\n    | identifierStart | unicodeCombiningMark\n    | unicodeDigit | unicodeConnectorPunctuation\n    | "\\u200C" | "\\u200D"\n    letter += unicodeCategoryNl\n    unicodeCategoryNl\n    = "\\u2160".."\\u2182" | "\\u3007" | "\\u3021".."\\u3029"\n    unicodeDigit (a digit)\n    = "\\u0030".."\\u0039" | "\\u0660".."\\u0669" | "\\u06F0".."\\u06F9" | "\\u0966".."\\u096F" | "\\u09E6".."\\u09EF" | "\\u0A66".."\\u0A6F" | "\\u0AE6".."\\u0AEF" | "\\u0B66".."\\u0B6F" | "\\u0BE7".."\\u0BEF" | "\\u0C66".."\\u0C6F" | "\\u0CE6".."\\u0CEF" | "\\u0D66".."\\u0D6F" | "\\u0E50".."\\u0E59" | "\\u0ED0".."\\u0ED9" | "\\u0F20".."\\u0F29" | "\\uFF10".."\\uFF19"\n\n    unicodeCombiningMark (a Unicode combining mark)\n    = "\\u0300".."\\u0345" | "\\u0360".."\\u0361" | "\\u0483".."\\u0486" | "\\u0591".."\\u05A1" | "\\u05A3".."\\u05B9" | "\\u05BB".."\\u05BD" | "\\u05BF".."\\u05BF" | "\\u05C1".."\\u05C2" | "\\u05C4".."\\u05C4" | "\\u064B".."\\u0652" | "\\u0670".."\\u0670" | "\\u06D6".."\\u06DC" | "\\u06DF".."\\u06E4" | "\\u06E7".."\\u06E8" | "\\u06EA".."\\u06ED" | "\\u0901".."\\u0902" | "\\u093C".."\\u093C" | "\\u0941".."\\u0948" | "\\u094D".."\\u094D" | "\\u0951".."\\u0954" | "\\u0962".."\\u0963" | "\\u0981".."\\u0981" | "\\u09BC".."\\u09BC" | "\\u09C1".."\\u09C4" | "\\u09CD".."\\u09CD" | "\\u09E2".."\\u09E3" | "\\u0A02".."\\u0A02" | "\\u0A3C".."\\u0A3C" | "\\u0A41".."\\u0A42" | "\\u0A47".."\\u0A48" | "\\u0A4B".."\\u0A4D" | "\\u0A70".."\\u0A71" | "\\u0A81".."\\u0A82" | "\\u0ABC".."\\u0ABC" | "\\u0AC1".."\\u0AC5" | "\\u0AC7".."\\u0AC8" | "\\u0ACD".."\\u0ACD" | "\\u0B01".."\\u0B01" | "\\u0B3C".."\\u0B3C" | "\\u0B3F".."\\u0B3F" | "\\u0B41".."\\u0B43" | "\\u0B4D".."\\u0B4D" | "\\u0B56".."\\u0B56" | "\\u0B82".."\\u0B82" | "\\u0BC0".."\\u0BC0" | "\\u0BCD".."\\u0BCD" | "\\u0C3E".."\\u0C40" | "\\u0C46".."\\u0C48" | "\\u0C4A".."\\u0C4D" | "\\u0C55".."\\u0C56" | "\\u0CBF".."\\u0CBF" | "\\u0CC6".."\\u0CC6" | "\\u0CCC".."\\u0CCD" | "\\u0D41".."\\u0D43" | "\\u0D4D".."\\u0D4D" | "\\u0E31".."\\u0E31" | "\\u0E34".."\\u0E3A" | "\\u0E47".."\\u0E4E" | "\\u0EB1".."\\u0EB1" | "\\u0EB4".."\\u0EB9" | "\\u0EBB".."\\u0EBC" | "\\u0EC8".."\\u0ECD" | "\\u0F18".."\\u0F19" | "\\u0F35".."\\u0F35" | "\\u0F37".."\\u0F37" | "\\u0F39".."\\u0F39" | "\\u0F71".."\\u0F7E" | "\\u0F80".."\\u0F84" | "\\u0F86".."\\u0F87" | "\\u0F90".."\\u0F95" | "\\u0F97".."\\u0F97" | "\\u0F99".."\\u0FAD" | "\\u0FB1".."\\u0FB7" | "\\u0FB9".."\\u0FB9" | "\\u20D0".."\\u20DC" | "\\u20E1".."\\u20E1" | "\\u302A".."\\u302F" | "\\u3099".."\\u309A" | "\\uFB1E".."\\uFB1E" | "\\uFE20".."\\uFE23"\n\n    unicodeConnectorPunctuation = "\\u005F" | "\\u203F".."\\u2040" | "\\u30FB" | "\\uFE33".."\\uFE34" | "\\uFE4D".."\\uFE4F" | "\\uFF3F" | "\\uFF65"\n    unicodeSpaceSeparator = "\\u2000".."\\u200B" | "\\u3000"\n\n}',
+			'JSImports {\n    JSImports = (Expr ";"?)*\n\n    Expr = \n    | comment\n    | stringLiteral\n    | ImportExpr\n    | Rest\n\n    ImportExpr =\n    | "import" ImportInner "from" importSource -- From\n    | "import" importSource -- NoFrom\n\n    Rest = (~(ImportExpr | comment | stringLiteral) any)+\n\n    ImportInner = \n    | ("type" "{" NonemptyListOf<ImportExtendedSelectionTypeless, ","> ","? "}")            -- Type\n    | ("{" NonemptyListOf<ImportExtendedSelectionTypes, ","> ","? "}")                      -- Types\n    | ("type " "*")                                                                         -- AllTypes\n    | ("{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")                           -- Extended\n    | (identifier ("," "type"? "{" NonemptyListOf<ImportExtendedSelection, ","> ","? "}")?) -- Mixed\n    | ("*" ("as" identifier)?)                                                              -- All\n    | (identifier ("as" identifier)?)                                                       -- Default\n    \n\n    ImportExtendedSelection = TypeImport | Import\n    ImportExtendedSelectionTypes = TypeImport\n    ImportExtendedSelectionTypeless = Import\n\n    Import = identifier ("as" identifier)?\n    TypeImport = "type" Import ("as" identifier)?\n\n    identifier = (letter | "_" | "$" | "~" ) (alnum | "_" | "$" | "~")*\n    quote = "\\"" | "\'" | "`"\n    notQuote = ~quote any\n    importSource =\n    | "\\"" notQuote+ "\\""\n    | "\'" notQuote+ "\'"\n    | "`" notQuote+ "`"\n\n    lineTerminator = "\\n" | "\\r" | "\\u2028" | "\\u2029"\n    lineTerminatorSequence = "\\n" | "\\r" ~"\\n" | "\\u2028" | "\\u2029" | "\\r\\n"\n    \n    comment = multiLineComment | singleLineComment\n\n    multiLineComment = "/*" (~"*/" any)* "*/"\n    singleLineComment = "//" (~lineTerminator any)*\n\n    stringLiteral =\n    | "\\"" doubleStringCharacter* "\\""\n    | "\'" singleStringCharacter* "\'"\n    | "`" templateStringCharacter* "`"\n    doubleStringCharacter =\n    | ~("\\"" | "\\\\" | lineTerminator) any   -- NonEscaped\n    | "\\\\" escapeSequence                   -- Escaped\n    | lineContinuation                      -- LineContinuation\n    singleStringCharacter =\n    | ~("\'" | "\\\\" | lineTerminator) any    -- NonEscaped\n    | "\\\\" escapeSequence                   -- Escaped\n    | lineContinuation                      -- LineContinuation\n    templateStringCharacter = \n    | ~ ("`" | "\\\\") any                    -- NonEscaped\n    | "\\\\" escapeSequence                        -- Escaped\n    lineContinuation = "\\\\" lineTerminatorSequence\n    escapeSequence = unicodeEscapeSequence | hexEscapeSequence | octalEscapeSequence | characterEscapeSequence\n    characterEscapeSequence = singleEscapeCharacter | nonEscapeCharacter\n    singleEscapeCharacter = "\'" | "\\"" | "\\\\" | "b" | "f" | "n" | "r" | "t" | "v"\n    nonEscapeCharacter = ~(escapeCharacter | lineTerminator) any\n    escapeCharacter = singleEscapeCharacter | decimalDigit | "x" | "u"\n    octalEscapeSequence =\n    | zeroToThree octalDigit octalDigit     -- Whole\n    | fourToSeven octalDigit                -- EightTimesfourToSeven\n    | zeroToThree octalDigit ~decimalDigit  -- EightTimesZeroToThree\n    | octalDigit ~decimalDigit              -- Octal\n    hexEscapeSequence = "x" hexDigit hexDigit\n    unicodeEscapeSequence = "u" hexDigit hexDigit hexDigit hexDigit\n\n    zeroToThree = "0".."3"\n    fourToSeven = "4".."7"\n    decimalDigit = "0".."9"\n    nonZeroDigit = "1".."9"\n    octalDigit = "0".."7"\n\n    regularExpressionLiteral = "/" regularExpressionBody "/" regularExpressionFlags\n    regularExpressionBody = regularExpressionFirstChar regularExpressionChar*\n    regularExpressionFirstChar =\n    | ~("*" | "\\\\" | "/" | "[") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    | regularExpressionClass\n    regularExpressionChar = ~("\\\\" | "/" | "[") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    | regularExpressionClass\n    regularExpressionBackslashSequence = "\\\\" regularExpressionNonTerminator\n    regularExpressionNonTerminator = ~(lineTerminator) any\n    regularExpressionClass = "[" regularExpressionClassChar* "]"\n    regularExpressionClassChar =\n    | ~("]" | "\\\\") regularExpressionNonTerminator\n    | regularExpressionBackslashSequence\n    regularExpressionFlags = identifierPart*\n\n    multiLineCommentNoNL = "/*" (~("*/" | lineTerminator) any)* "*/"\n\n    identifierStart =\n    | letter | "$" | "_"\n    | "\\\\" unicodeEscapeSequence -- escaped\n    identifierPart =\n    | identifierStart | unicodeCombiningMark\n    | unicodeDigit | unicodeConnectorPunctuation\n    | "\\u200C" | "\\u200D"\n    letter += unicodeCategoryNl\n    unicodeCategoryNl\n    = "\\u2160".."\\u2182" | "\\u3007" | "\\u3021".."\\u3029"\n    unicodeDigit (a digit)\n    = "\\u0030".."\\u0039" | "\\u0660".."\\u0669" | "\\u06F0".."\\u06F9" | "\\u0966".."\\u096F" | "\\u09E6".."\\u09EF" | "\\u0A66".."\\u0A6F" | "\\u0AE6".."\\u0AEF" | "\\u0B66".."\\u0B6F" | "\\u0BE7".."\\u0BEF" | "\\u0C66".."\\u0C6F" | "\\u0CE6".."\\u0CEF" | "\\u0D66".."\\u0D6F" | "\\u0E50".."\\u0E59" | "\\u0ED0".."\\u0ED9" | "\\u0F20".."\\u0F29" | "\\uFF10".."\\uFF19"\n\n    unicodeCombiningMark (a Unicode combining mark)\n    = "\\u0300".."\\u0345" | "\\u0360".."\\u0361" | "\\u0483".."\\u0486" | "\\u0591".."\\u05A1" | "\\u05A3".."\\u05B9" | "\\u05BB".."\\u05BD" | "\\u05BF".."\\u05BF" | "\\u05C1".."\\u05C2" | "\\u05C4".."\\u05C4" | "\\u064B".."\\u0652" | "\\u0670".."\\u0670" | "\\u06D6".."\\u06DC" | "\\u06DF".."\\u06E4" | "\\u06E7".."\\u06E8" | "\\u06EA".."\\u06ED" | "\\u0901".."\\u0902" | "\\u093C".."\\u093C" | "\\u0941".."\\u0948" | "\\u094D".."\\u094D" | "\\u0951".."\\u0954" | "\\u0962".."\\u0963" | "\\u0981".."\\u0981" | "\\u09BC".."\\u09BC" | "\\u09C1".."\\u09C4" | "\\u09CD".."\\u09CD" | "\\u09E2".."\\u09E3" | "\\u0A02".."\\u0A02" | "\\u0A3C".."\\u0A3C" | "\\u0A41".."\\u0A42" | "\\u0A47".."\\u0A48" | "\\u0A4B".."\\u0A4D" | "\\u0A70".."\\u0A71" | "\\u0A81".."\\u0A82" | "\\u0ABC".."\\u0ABC" | "\\u0AC1".."\\u0AC5" | "\\u0AC7".."\\u0AC8" | "\\u0ACD".."\\u0ACD" | "\\u0B01".."\\u0B01" | "\\u0B3C".."\\u0B3C" | "\\u0B3F".."\\u0B3F" | "\\u0B41".."\\u0B43" | "\\u0B4D".."\\u0B4D" | "\\u0B56".."\\u0B56" | "\\u0B82".."\\u0B82" | "\\u0BC0".."\\u0BC0" | "\\u0BCD".."\\u0BCD" | "\\u0C3E".."\\u0C40" | "\\u0C46".."\\u0C48" | "\\u0C4A".."\\u0C4D" | "\\u0C55".."\\u0C56" | "\\u0CBF".."\\u0CBF" | "\\u0CC6".."\\u0CC6" | "\\u0CCC".."\\u0CCD" | "\\u0D41".."\\u0D43" | "\\u0D4D".."\\u0D4D" | "\\u0E31".."\\u0E31" | "\\u0E34".."\\u0E3A" | "\\u0E47".."\\u0E4E" | "\\u0EB1".."\\u0EB1" | "\\u0EB4".."\\u0EB9" | "\\u0EBB".."\\u0EBC" | "\\u0EC8".."\\u0ECD" | "\\u0F18".."\\u0F19" | "\\u0F35".."\\u0F35" | "\\u0F37".."\\u0F37" | "\\u0F39".."\\u0F39" | "\\u0F71".."\\u0F7E" | "\\u0F80".."\\u0F84" | "\\u0F86".."\\u0F87" | "\\u0F90".."\\u0F95" | "\\u0F97".."\\u0F97" | "\\u0F99".."\\u0FAD" | "\\u0FB1".."\\u0FB7" | "\\u0FB9".."\\u0FB9" | "\\u20D0".."\\u20DC" | "\\u20E1".."\\u20E1" | "\\u302A".."\\u302F" | "\\u3099".."\\u309A" | "\\uFB1E".."\\uFB1E" | "\\uFE20".."\\uFE23"\n\n    unicodeConnectorPunctuation = "\\u005F" | "\\u203F".."\\u2040" | "\\u30FB" | "\\uFE33".."\\uFE34" | "\\uFE4D".."\\uFE4F" | "\\uFF3F" | "\\uFF65"\n    unicodeSpaceSeparator = "\\u2000".."\\u200B" | "\\u3000"\n\n}',
 	},
 	'JSImports',
 	null,
@@ -77,676 +77,691 @@ const result = makeRecipe([
 		], ['terminal', { sourceInterval: [462, 465] }, ',']]], ['opt', { sourceInterval: [467, 471] }, ['terminal', {
 			sourceInterval: [467, 470],
 		}, ',']], ['terminal', { sourceInterval: [472, 475] }, '}']]],
-		ImportInner_Extended: ['define', { sourceInterval: [513, 610] }, null, [], ['seq', { sourceInterval: [513, 572] }, [
+		ImportInner_AllTypes: ['define', { sourceInterval: [513, 610] }, null, [], ['seq', { sourceInterval: [513, 526] }, [
 			'terminal',
-			{ sourceInterval: [514, 517] },
+			{ sourceInterval: [514, 521] },
+			'type ',
+		], ['terminal', { sourceInterval: [522, 525] }, '*']]],
+		ImportInner_Extended: ['define', { sourceInterval: [617, 714] }, null, [], ['seq', { sourceInterval: [617, 676] }, [
+			'terminal',
+			{ sourceInterval: [618, 621] },
 			'{',
-		], ['app', { sourceInterval: [518, 562] }, 'NonemptyListOf', [[
+		], ['app', { sourceInterval: [622, 666] }, 'NonemptyListOf', [[
 			'app',
-			{ sourceInterval: [533, 556] },
+			{ sourceInterval: [637, 660] },
 			'ImportExtendedSelection',
 			[],
-		], ['terminal', { sourceInterval: [558, 561] }, ',']]], ['opt', { sourceInterval: [563, 567] }, ['terminal', {
-			sourceInterval: [563, 566],
-		}, ',']], ['terminal', { sourceInterval: [568, 571] }, '}']]],
-		ImportInner_Mixed: ['define', { sourceInterval: [617, 711] }, null, [], ['seq', { sourceInterval: [617, 702] }, [
+		], ['terminal', { sourceInterval: [662, 665] }, ',']]], ['opt', { sourceInterval: [667, 671] }, ['terminal', {
+			sourceInterval: [667, 670],
+		}, ',']], ['terminal', { sourceInterval: [672, 675] }, '}']]],
+		ImportInner_Mixed: ['define', { sourceInterval: [721, 815] }, null, [], ['seq', { sourceInterval: [721, 806] }, [
 			'app',
-			{ sourceInterval: [618, 628] },
+			{ sourceInterval: [722, 732] },
 			'identifier',
 			[],
-		], ['opt', { sourceInterval: [629, 701] }, [
+		], ['opt', { sourceInterval: [733, 805] }, [
 			'seq',
-			{ sourceInterval: [630, 699] },
-			['terminal', { sourceInterval: [630, 633] }, ','],
-			['opt', { sourceInterval: [634, 641] }, ['terminal', { sourceInterval: [634, 640] }, 'type']],
-			['terminal', { sourceInterval: [642, 645] }, '{'],
-			['app', { sourceInterval: [646, 690] }, 'NonemptyListOf', [[
+			{ sourceInterval: [734, 803] },
+			['terminal', { sourceInterval: [734, 737] }, ','],
+			['opt', { sourceInterval: [738, 745] }, ['terminal', { sourceInterval: [738, 744] }, 'type']],
+			['terminal', { sourceInterval: [746, 749] }, '{'],
+			['app', { sourceInterval: [750, 794] }, 'NonemptyListOf', [[
 				'app',
-				{ sourceInterval: [661, 684] },
+				{ sourceInterval: [765, 788] },
 				'ImportExtendedSelection',
 				[],
-			], ['terminal', { sourceInterval: [686, 689] }, ',']]],
-			['opt', { sourceInterval: [691, 695] }, ['terminal', { sourceInterval: [691, 694] }, ',']],
-			['terminal', { sourceInterval: [696, 699] }, '}'],
+			], ['terminal', { sourceInterval: [790, 793] }, ',']]],
+			['opt', { sourceInterval: [795, 799] }, ['terminal', { sourceInterval: [795, 798] }, ',']],
+			['terminal', { sourceInterval: [800, 803] }, '}'],
 		]]]],
-		ImportInner_All: ['define', { sourceInterval: [718, 810] }, null, [], ['seq', { sourceInterval: [718, 742] }, [
+		ImportInner_All: ['define', { sourceInterval: [822, 914] }, null, [], ['seq', { sourceInterval: [822, 846] }, [
 			'terminal',
-			{ sourceInterval: [719, 722] },
+			{ sourceInterval: [823, 826] },
 			'*',
-		], ['opt', { sourceInterval: [723, 741] }, ['seq', { sourceInterval: [724, 739] }, ['terminal', {
-			sourceInterval: [724, 728],
-		}, 'as'], ['app', { sourceInterval: [729, 739] }, 'identifier', []]]]]],
-		ImportInner_Default: ['define', { sourceInterval: [817, 913] }, null, [], ['seq', { sourceInterval: [817, 848] }, [
+		], ['opt', { sourceInterval: [827, 845] }, ['seq', { sourceInterval: [828, 843] }, ['terminal', {
+			sourceInterval: [828, 832],
+		}, 'as'], ['app', { sourceInterval: [833, 843] }, 'identifier', []]]]]],
+		ImportInner_Default: ['define', { sourceInterval: [921, 1017] }, null, [], ['seq', { sourceInterval: [921, 952] }, [
 			'app',
-			{ sourceInterval: [818, 828] },
+			{ sourceInterval: [922, 932] },
 			'identifier',
 			[],
-		], ['opt', { sourceInterval: [829, 847] }, ['seq', { sourceInterval: [830, 845] }, ['terminal', {
-			sourceInterval: [830, 834],
-		}, 'as'], ['app', { sourceInterval: [835, 845] }, 'identifier', []]]]]],
-		ImportInner: ['define', { sourceInterval: [291, 913] }, null, [], [
+		], ['opt', { sourceInterval: [933, 951] }, ['seq', { sourceInterval: [934, 949] }, ['terminal', {
+			sourceInterval: [934, 938],
+		}, 'as'], ['app', { sourceInterval: [939, 949] }, 'identifier', []]]]]],
+		ImportInner: ['define', { sourceInterval: [291, 1017] }, null, [], [
 			'alt',
-			{ sourceInterval: [310, 913] },
+			{ sourceInterval: [310, 1017] },
 			['app', { sourceInterval: [312, 386] }, 'ImportInner_Type', []],
 			['app', { sourceInterval: [412, 476] }, 'ImportInner_Types', []],
-			['app', { sourceInterval: [513, 572] }, 'ImportInner_Extended', []],
-			['app', { sourceInterval: [617, 702] }, 'ImportInner_Mixed', []],
-			['app', { sourceInterval: [718, 742] }, 'ImportInner_All', []],
-			['app', { sourceInterval: [817, 848] }, 'ImportInner_Default', []],
+			['app', { sourceInterval: [513, 526] }, 'ImportInner_AllTypes', []],
+			['app', { sourceInterval: [617, 676] }, 'ImportInner_Extended', []],
+			['app', { sourceInterval: [721, 806] }, 'ImportInner_Mixed', []],
+			['app', { sourceInterval: [822, 846] }, 'ImportInner_All', []],
+			['app', { sourceInterval: [921, 952] }, 'ImportInner_Default', []],
 		]],
-		ImportExtendedSelection: ['define', { sourceInterval: [924, 969] }, null, [], [
+		ImportExtendedSelection: ['define', { sourceInterval: [1028, 1073] }, null, [], [
 			'alt',
-			{ sourceInterval: [950, 969] },
-			['app', { sourceInterval: [950, 960] }, 'TypeImport', []],
-			['app', { sourceInterval: [963, 969] }, 'Import', []],
+			{ sourceInterval: [1054, 1073] },
+			['app', { sourceInterval: [1054, 1064] }, 'TypeImport', []],
+			['app', { sourceInterval: [1067, 1073] }, 'Import', []],
 		]],
-		ImportExtendedSelectionTypes: ['define', { sourceInterval: [974, 1015] }, null, [], [
+		ImportExtendedSelectionTypes: ['define', { sourceInterval: [1078, 1119] }, null, [], [
 			'app',
-			{ sourceInterval: [1005, 1015] },
+			{ sourceInterval: [1109, 1119] },
 			'TypeImport',
 			[],
 		]],
-		ImportExtendedSelectionTypeless: ['define', { sourceInterval: [1020, 1060] }, null, [], [
+		ImportExtendedSelectionTypeless: ['define', { sourceInterval: [1124, 1164] }, null, [], [
 			'app',
-			{ sourceInterval: [1054, 1060] },
+			{ sourceInterval: [1158, 1164] },
 			'Import',
 			[],
 		]],
-		Import: ['define', { sourceInterval: [1066, 1104] }, null, [], ['seq', { sourceInterval: [1075, 1104] }, [
+		Import: ['define', { sourceInterval: [1170, 1208] }, null, [], ['seq', { sourceInterval: [1179, 1208] }, [
 			'app',
-			{ sourceInterval: [1075, 1085] },
+			{ sourceInterval: [1179, 1189] },
 			'identifier',
 			[],
-		], ['opt', { sourceInterval: [1086, 1104] }, ['seq', { sourceInterval: [1087, 1102] }, ['terminal', {
-			sourceInterval: [1087, 1091],
-		}, 'as'], ['app', { sourceInterval: [1092, 1102] }, 'identifier', []]]]]],
-		TypeImport: ['define', { sourceInterval: [1109, 1154] }, null, [], [
+		], ['opt', { sourceInterval: [1190, 1208] }, ['seq', { sourceInterval: [1191, 1206] }, ['terminal', {
+			sourceInterval: [1191, 1195],
+		}, 'as'], ['app', { sourceInterval: [1196, 1206] }, 'identifier', []]]]]],
+		TypeImport: ['define', { sourceInterval: [1213, 1258] }, null, [], [
 			'seq',
-			{ sourceInterval: [1122, 1154] },
-			['terminal', { sourceInterval: [1122, 1128] }, 'type'],
-			['app', { sourceInterval: [1129, 1135] }, 'Import', []],
-			['opt', { sourceInterval: [1136, 1154] }, ['seq', { sourceInterval: [1137, 1152] }, ['terminal', {
-				sourceInterval: [1137, 1141],
-			}, 'as'], ['app', { sourceInterval: [1142, 1152] }, 'identifier', []]]],
-		]],
-		identifier: ['define', { sourceInterval: [1160, 1186] }, null, [], ['seq', { sourceInterval: [1173, 1186] }, [
-			'app',
-			{ sourceInterval: [1173, 1179] },
-			'letter',
-			[],
-		], ['star', { sourceInterval: [1180, 1186] }, ['app', { sourceInterval: [1180, 1185] }, 'alnum', []]]]],
-		quote: ['define', { sourceInterval: [1191, 1215] }, null, [], [
+			{ sourceInterval: [1226, 1258] },
+			['terminal', { sourceInterval: [1226, 1232] }, 'type'],
+			['app', { sourceInterval: [1233, 1239] }, 'Import', []],
+			['opt', { sourceInterval: [1240, 1258] }, ['seq', { sourceInterval: [1241, 1256] }, ['terminal', {
+				sourceInterval: [1241, 1245],
+			}, 'as'], ['app', { sourceInterval: [1246, 1256] }, 'identifier', []]]],
+		]],
+		identifier: ['define', { sourceInterval: [1264, 1331] }, null, [], ['seq', { sourceInterval: [1277, 1331] }, [
+			'alt',
+			{ sourceInterval: [1278, 1302] },
+			['app', { sourceInterval: [1278, 1284] }, 'letter', []],
+			['terminal', { sourceInterval: [1287, 1290] }, '_'],
+			['terminal', { sourceInterval: [1293, 1296] }, '$'],
+			['terminal', { sourceInterval: [1299, 1302] }, '~'],
+		], ['star', { sourceInterval: [1305, 1331] }, [
 			'alt',
-			{ sourceInterval: [1199, 1215] },
-			['terminal', { sourceInterval: [1199, 1203] }, '"'],
-			['terminal', { sourceInterval: [1206, 1209] }, "'"],
-			['terminal', { sourceInterval: [1212, 1215] }, '`'],
-		]],
-		notQuote: ['define', { sourceInterval: [1220, 1241] }, null, [], ['seq', { sourceInterval: [1231, 1241] }, ['not', {
-			sourceInterval: [1231, 1237],
-		}, ['app', { sourceInterval: [1232, 1237] }, 'quote', []]], ['app', { sourceInterval: [1238, 1241] }, 'any', []]]],
-		importSource: ['define', { sourceInterval: [1246, 1334] }, null, [], [
+			{ sourceInterval: [1306, 1329] },
+			['app', { sourceInterval: [1306, 1311] }, 'alnum', []],
+			['terminal', { sourceInterval: [1314, 1317] }, '_'],
+			['terminal', { sourceInterval: [1320, 1323] }, '$'],
+			['terminal', { sourceInterval: [1326, 1329] }, '~'],
+		]]]],
+		quote: ['define', { sourceInterval: [1336, 1360] }, null, [], [
+			'alt',
+			{ sourceInterval: [1344, 1360] },
+			['terminal', { sourceInterval: [1344, 1348] }, '"'],
+			['terminal', { sourceInterval: [1351, 1354] }, "'"],
+			['terminal', { sourceInterval: [1357, 1360] }, '`'],
+		]],
+		notQuote: ['define', { sourceInterval: [1365, 1386] }, null, [], ['seq', { sourceInterval: [1376, 1386] }, ['not', {
+			sourceInterval: [1376, 1382],
+		}, ['app', { sourceInterval: [1377, 1382] }, 'quote', []]], ['app', { sourceInterval: [1383, 1386] }, 'any', []]]],
+		importSource: ['define', { sourceInterval: [1391, 1479] }, null, [], [
 			'alt',
-			{ sourceInterval: [1265, 1334] },
-			['seq', { sourceInterval: [1267, 1286] }, ['terminal', { sourceInterval: [1267, 1271] }, '"'], ['plus', {
-				sourceInterval: [1272, 1281],
-			}, ['app', { sourceInterval: [1272, 1280] }, 'notQuote', []]], [
+			{ sourceInterval: [1410, 1479] },
+			['seq', { sourceInterval: [1412, 1431] }, ['terminal', { sourceInterval: [1412, 1416] }, '"'], ['plus', {
+				sourceInterval: [1417, 1426],
+			}, ['app', { sourceInterval: [1417, 1425] }, 'notQuote', []]], [
 				'terminal',
-				{ sourceInterval: [1282, 1286] },
+				{ sourceInterval: [1427, 1431] },
 				'"',
 			]],
-			['seq', { sourceInterval: [1293, 1310] }, ['terminal', { sourceInterval: [1293, 1296] }, "'"], ['plus', {
-				sourceInterval: [1297, 1306],
-			}, ['app', { sourceInterval: [1297, 1305] }, 'notQuote', []]], [
+			['seq', { sourceInterval: [1438, 1455] }, ['terminal', { sourceInterval: [1438, 1441] }, "'"], ['plus', {
+				sourceInterval: [1442, 1451],
+			}, ['app', { sourceInterval: [1442, 1450] }, 'notQuote', []]], [
 				'terminal',
-				{ sourceInterval: [1307, 1310] },
+				{ sourceInterval: [1452, 1455] },
 				"'",
 			]],
-			['seq', { sourceInterval: [1317, 1334] }, ['terminal', { sourceInterval: [1317, 1320] }, '`'], ['plus', {
-				sourceInterval: [1321, 1330],
-			}, ['app', { sourceInterval: [1321, 1329] }, 'notQuote', []]], [
+			['seq', { sourceInterval: [1462, 1479] }, ['terminal', { sourceInterval: [1462, 1465] }, '`'], ['plus', {
+				sourceInterval: [1466, 1475],
+			}, ['app', { sourceInterval: [1466, 1474] }, 'notQuote', []]], [
 				'terminal',
-				{ sourceInterval: [1331, 1334] },
+				{ sourceInterval: [1476, 1479] },
 				'`',
 			]],
 		]],
-		lineTerminator: ['define', { sourceInterval: [1340, 1390] }, null, [], [
+		lineTerminator: ['define', { sourceInterval: [1485, 1535] }, null, [], [
 			'alt',
-			{ sourceInterval: [1357, 1390] },
-			['terminal', { sourceInterval: [1357, 1361] }, '\n'],
-			['terminal', { sourceInterval: [1364, 1368] }, '\r'],
-			['terminal', { sourceInterval: [1371, 1379] }, '\u2028'],
-			['terminal', { sourceInterval: [1382, 1390] }, '\u2029'],
+			{ sourceInterval: [1502, 1535] },
+			['terminal', { sourceInterval: [1502, 1506] }, '\n'],
+			['terminal', { sourceInterval: [1509, 1513] }, '\r'],
+			['terminal', { sourceInterval: [1516, 1524] }, '\u2028'],
+			['terminal', { sourceInterval: [1527, 1535] }, '\u2029'],
 		]],
-		lineTerminatorSequence: ['define', { sourceInterval: [1395, 1468] }, null, [], [
+		lineTerminatorSequence: ['define', { sourceInterval: [1540, 1613] }, null, [], [
 			'alt',
-			{ sourceInterval: [1420, 1468] },
-			['terminal', { sourceInterval: [1420, 1424] }, '\n'],
-			['seq', { sourceInterval: [1427, 1437] }, ['terminal', { sourceInterval: [1427, 1431] }, '\r'], ['not', {
-				sourceInterval: [1432, 1437],
-			}, ['terminal', { sourceInterval: [1433, 1437] }, '\n']]],
-			['terminal', { sourceInterval: [1440, 1448] }, '\u2028'],
-			['terminal', { sourceInterval: [1451, 1459] }, '\u2029'],
-			['terminal', { sourceInterval: [1462, 1468] }, '\r\n'],
-		]],
-		comment: ['define', { sourceInterval: [1478, 1524] }, null, [], ['alt', { sourceInterval: [1488, 1524] }, [
+			{ sourceInterval: [1565, 1613] },
+			['terminal', { sourceInterval: [1565, 1569] }, '\n'],
+			['seq', { sourceInterval: [1572, 1582] }, ['terminal', { sourceInterval: [1572, 1576] }, '\r'], ['not', {
+				sourceInterval: [1577, 1582],
+			}, ['terminal', { sourceInterval: [1578, 1582] }, '\n']]],
+			['terminal', { sourceInterval: [1585, 1593] }, '\u2028'],
+			['terminal', { sourceInterval: [1596, 1604] }, '\u2029'],
+			['terminal', { sourceInterval: [1607, 1613] }, '\r\n'],
+		]],
+		comment: ['define', { sourceInterval: [1623, 1669] }, null, [], ['alt', { sourceInterval: [1633, 1669] }, [
 			'app',
-			{ sourceInterval: [1488, 1504] },
+			{ sourceInterval: [1633, 1649] },
 			'multiLineComment',
 			[],
-		], ['app', { sourceInterval: [1507, 1524] }, 'singleLineComment', []]]],
-		multiLineComment: ['define', { sourceInterval: [1530, 1571] }, null, [], ['seq', { sourceInterval: [1549, 1571] }, [
+		], ['app', { sourceInterval: [1652, 1669] }, 'singleLineComment', []]]],
+		multiLineComment: ['define', { sourceInterval: [1675, 1716] }, null, [], ['seq', { sourceInterval: [1694, 1716] }, [
 			'terminal',
-			{ sourceInterval: [1549, 1553] },
+			{ sourceInterval: [1694, 1698] },
 			'/*',
-		], ['star', { sourceInterval: [1554, 1566] }, ['seq', { sourceInterval: [1555, 1564] }, ['not', {
-			sourceInterval: [1555, 1560],
-		}, ['terminal', { sourceInterval: [1556, 1560] }, '*/']], ['app', { sourceInterval: [1561, 1564] }, 'any', []]]], [
+		], ['star', { sourceInterval: [1699, 1711] }, ['seq', { sourceInterval: [1700, 1709] }, ['not', {
+			sourceInterval: [1700, 1705],
+		}, ['terminal', { sourceInterval: [1701, 1705] }, '*/']], ['app', { sourceInterval: [1706, 1709] }, 'any', []]]], [
 			'terminal',
-			{ sourceInterval: [1567, 1571] },
+			{ sourceInterval: [1712, 1716] },
 			'*/',
 		]]],
-		singleLineComment: ['define', { sourceInterval: [1576, 1623] }, null, [], [
+		singleLineComment: ['define', { sourceInterval: [1721, 1768] }, null, [], [
 			'seq',
-			{ sourceInterval: [1596, 1623] },
-			['terminal', { sourceInterval: [1596, 1600] }, '//'],
-			['star', { sourceInterval: [1601, 1623] }, ['seq', { sourceInterval: [1602, 1621] }, ['not', {
-				sourceInterval: [1602, 1617],
-			}, ['app', { sourceInterval: [1603, 1617] }, 'lineTerminator', []]], [
+			{ sourceInterval: [1741, 1768] },
+			['terminal', { sourceInterval: [1741, 1745] }, '//'],
+			['star', { sourceInterval: [1746, 1768] }, ['seq', { sourceInterval: [1747, 1766] }, ['not', {
+				sourceInterval: [1747, 1762],
+			}, ['app', { sourceInterval: [1748, 1762] }, 'lineTerminator', []]], [
 				'app',
-				{ sourceInterval: [1618, 1621] },
+				{ sourceInterval: [1763, 1766] },
 				'any',
 				[],
 			]]],
 		]],
-		stringLiteral: ['define', { sourceInterval: [1629, 1759] }, null, [], ['alt', { sourceInterval: [1649, 1759] }, [
+		stringLiteral: ['define', { sourceInterval: [1774, 1904] }, null, [], ['alt', { sourceInterval: [1794, 1904] }, [
 			'seq',
-			{ sourceInterval: [1651, 1683] },
-			['terminal', { sourceInterval: [1651, 1655] }, '"'],
-			['star', { sourceInterval: [1656, 1678] }, [
+			{ sourceInterval: [1796, 1828] },
+			['terminal', { sourceInterval: [1796, 1800] }, '"'],
+			['star', { sourceInterval: [1801, 1823] }, [
 				'app',
-				{ sourceInterval: [1656, 1677] },
+				{ sourceInterval: [1801, 1822] },
 				'doubleStringCharacter',
 				[],
 			]],
-			['terminal', { sourceInterval: [1679, 1683] }, '"'],
-		], ['seq', { sourceInterval: [1690, 1720] }, ['terminal', { sourceInterval: [1690, 1693] }, "'"], ['star', {
-			sourceInterval: [1694, 1716],
-		}, ['app', { sourceInterval: [1694, 1715] }, 'singleStringCharacter', []]], ['terminal', {
-			sourceInterval: [1717, 1720],
-		}, "'"]], ['seq', { sourceInterval: [1727, 1759] }, ['terminal', { sourceInterval: [1727, 1730] }, '`'], ['star', {
-			sourceInterval: [1731, 1755],
-		}, ['app', { sourceInterval: [1731, 1754] }, 'templateStringCharacter', []]], ['terminal', {
-			sourceInterval: [1756, 1759],
+			['terminal', { sourceInterval: [1824, 1828] }, '"'],
+		], ['seq', { sourceInterval: [1835, 1865] }, ['terminal', { sourceInterval: [1835, 1838] }, "'"], ['star', {
+			sourceInterval: [1839, 1861],
+		}, ['app', { sourceInterval: [1839, 1860] }, 'singleStringCharacter', []]], ['terminal', {
+			sourceInterval: [1862, 1865],
+		}, "'"]], ['seq', { sourceInterval: [1872, 1904] }, ['terminal', { sourceInterval: [1872, 1875] }, '`'], ['star', {
+			sourceInterval: [1876, 1900],
+		}, ['app', { sourceInterval: [1876, 1899] }, 'templateStringCharacter', []]], ['terminal', {
+			sourceInterval: [1901, 1904],
 		}, '`']]]],
-		doubleStringCharacter_NonEscaped: ['define', { sourceInterval: [1794, 1845] }, null, [], ['seq', {
-			sourceInterval: [1794, 1829],
-		}, ['not', { sourceInterval: [1794, 1825] }, [
+		doubleStringCharacter_NonEscaped: ['define', { sourceInterval: [1939, 1990] }, null, [], ['seq', {
+			sourceInterval: [1939, 1974],
+		}, ['not', { sourceInterval: [1939, 1970] }, [
 			'alt',
-			{ sourceInterval: [1796, 1824] },
-			['terminal', { sourceInterval: [1796, 1800] }, '"'],
-			['terminal', { sourceInterval: [1803, 1807] }, '\\'],
-			['app', { sourceInterval: [1810, 1824] }, 'lineTerminator', []],
-		]], ['app', { sourceInterval: [1826, 1829] }, 'any', []]]],
-		doubleStringCharacter_Escaped: ['define', { sourceInterval: [1852, 1900] }, null, [], [
+			{ sourceInterval: [1941, 1969] },
+			['terminal', { sourceInterval: [1941, 1945] }, '"'],
+			['terminal', { sourceInterval: [1948, 1952] }, '\\'],
+			['app', { sourceInterval: [1955, 1969] }, 'lineTerminator', []],
+		]], ['app', { sourceInterval: [1971, 1974] }, 'any', []]]],
+		doubleStringCharacter_Escaped: ['define', { sourceInterval: [1997, 2045] }, null, [], [
 			'seq',
-			{ sourceInterval: [1852, 1871] },
-			['terminal', { sourceInterval: [1852, 1856] }, '\\'],
-			['app', { sourceInterval: [1857, 1871] }, 'escapeSequence', []],
+			{ sourceInterval: [1997, 2016] },
+			['terminal', { sourceInterval: [1997, 2001] }, '\\'],
+			['app', { sourceInterval: [2002, 2016] }, 'escapeSequence', []],
 		]],
-		doubleStringCharacter_LineContinuation: ['define', { sourceInterval: [1907, 1964] }, null, [], [
+		doubleStringCharacter_LineContinuation: ['define', { sourceInterval: [2052, 2109] }, null, [], [
 			'app',
-			{ sourceInterval: [1907, 1923] },
+			{ sourceInterval: [2052, 2068] },
 			'lineContinuation',
 			[],
 		]],
-		doubleStringCharacter: ['define', { sourceInterval: [1764, 1964] }, null, [], [
+		doubleStringCharacter: ['define', { sourceInterval: [1909, 2109] }, null, [], [
 			'alt',
-			{ sourceInterval: [1792, 1964] },
-			['app', { sourceInterval: [1794, 1829] }, 'doubleStringCharacter_NonEscaped', []],
-			['app', { sourceInterval: [1852, 1871] }, 'doubleStringCharacter_Escaped', []],
-			['app', { sourceInterval: [1907, 1923] }, 'doubleStringCharacter_LineContinuation', []],
-		]],
-		singleStringCharacter_NonEscaped: ['define', { sourceInterval: [1999, 2050] }, null, [], ['seq', {
-			sourceInterval: [1999, 2033],
-		}, ['not', { sourceInterval: [1999, 2029] }, [
+			{ sourceInterval: [1937, 2109] },
+			['app', { sourceInterval: [1939, 1974] }, 'doubleStringCharacter_NonEscaped', []],
+			['app', { sourceInterval: [1997, 2016] }, 'doubleStringCharacter_Escaped', []],
+			['app', { sourceInterval: [2052, 2068] }, 'doubleStringCharacter_LineContinuation', []],
+		]],
+		singleStringCharacter_NonEscaped: ['define', { sourceInterval: [2144, 2195] }, null, [], ['seq', {
+			sourceInterval: [2144, 2178],
+		}, ['not', { sourceInterval: [2144, 2174] }, [
 			'alt',
-			{ sourceInterval: [2001, 2028] },
-			['terminal', { sourceInterval: [2001, 2004] }, "'"],
-			['terminal', { sourceInterval: [2007, 2011] }, '\\'],
-			['app', { sourceInterval: [2014, 2028] }, 'lineTerminator', []],
-		]], ['app', { sourceInterval: [2030, 2033] }, 'any', []]]],
-		singleStringCharacter_Escaped: ['define', { sourceInterval: [2057, 2105] }, null, [], [
+			{ sourceInterval: [2146, 2173] },
+			['terminal', { sourceInterval: [2146, 2149] }, "'"],
+			['terminal', { sourceInterval: [2152, 2156] }, '\\'],
+			['app', { sourceInterval: [2159, 2173] }, 'lineTerminator', []],
+		]], ['app', { sourceInterval: [2175, 2178] }, 'any', []]]],
+		singleStringCharacter_Escaped: ['define', { sourceInterval: [2202, 2250] }, null, [], [
 			'seq',
-			{ sourceInterval: [2057, 2076] },
-			['terminal', { sourceInterval: [2057, 2061] }, '\\'],
-			['app', { sourceInterval: [2062, 2076] }, 'escapeSequence', []],
+			{ sourceInterval: [2202, 2221] },
+			['terminal', { sourceInterval: [2202, 2206] }, '\\'],
+			['app', { sourceInterval: [2207, 2221] }, 'escapeSequence', []],
 		]],
-		singleStringCharacter_LineContinuation: ['define', { sourceInterval: [2112, 2169] }, null, [], [
+		singleStringCharacter_LineContinuation: ['define', { sourceInterval: [2257, 2314] }, null, [], [
 			'app',
-			{ sourceInterval: [2112, 2128] },
+			{ sourceInterval: [2257, 2273] },
 			'lineContinuation',
 			[],
 		]],
-		singleStringCharacter: ['define', { sourceInterval: [1969, 2169] }, null, [], [
+		singleStringCharacter: ['define', { sourceInterval: [2114, 2314] }, null, [], [
 			'alt',
-			{ sourceInterval: [1997, 2169] },
-			['app', { sourceInterval: [1999, 2033] }, 'singleStringCharacter_NonEscaped', []],
-			['app', { sourceInterval: [2057, 2076] }, 'singleStringCharacter_Escaped', []],
-			['app', { sourceInterval: [2112, 2128] }, 'singleStringCharacter_LineContinuation', []],
-		]],
-		templateStringCharacter_NonEscaped: ['define', { sourceInterval: [2207, 2258] }, null, [], ['seq', {
-			sourceInterval: [2207, 2225],
-		}, ['not', { sourceInterval: [2207, 2221] }, ['alt', { sourceInterval: [2210, 2220] }, ['terminal', {
-			sourceInterval: [2210, 2213],
-		}, '`'], ['terminal', { sourceInterval: [2216, 2220] }, '\\']]], [
+			{ sourceInterval: [2142, 2314] },
+			['app', { sourceInterval: [2144, 2178] }, 'singleStringCharacter_NonEscaped', []],
+			['app', { sourceInterval: [2202, 2221] }, 'singleStringCharacter_Escaped', []],
+			['app', { sourceInterval: [2257, 2273] }, 'singleStringCharacter_LineContinuation', []],
+		]],
+		templateStringCharacter_NonEscaped: ['define', { sourceInterval: [2352, 2403] }, null, [], ['seq', {
+			sourceInterval: [2352, 2370],
+		}, ['not', { sourceInterval: [2352, 2366] }, ['alt', { sourceInterval: [2355, 2365] }, ['terminal', {
+			sourceInterval: [2355, 2358],
+		}, '`'], ['terminal', { sourceInterval: [2361, 2365] }, '\\']]], [
 			'app',
-			{ sourceInterval: [2222, 2225] },
+			{ sourceInterval: [2367, 2370] },
 			'any',
 			[],
 		]]],
-		templateStringCharacter_Escaped: ['define', { sourceInterval: [2265, 2318] }, null, [], [
+		templateStringCharacter_Escaped: ['define', { sourceInterval: [2410, 2463] }, null, [], [
 			'seq',
-			{ sourceInterval: [2265, 2284] },
-			['terminal', { sourceInterval: [2265, 2269] }, '\\'],
-			['app', { sourceInterval: [2270, 2284] }, 'escapeSequence', []],
+			{ sourceInterval: [2410, 2429] },
+			['terminal', { sourceInterval: [2410, 2414] }, '\\'],
+			['app', { sourceInterval: [2415, 2429] }, 'escapeSequence', []],
 		]],
-		templateStringCharacter: ['define', { sourceInterval: [2174, 2318] }, null, [], [
+		templateStringCharacter: ['define', { sourceInterval: [2319, 2463] }, null, [], [
 			'alt',
-			{ sourceInterval: [2205, 2318] },
-			['app', { sourceInterval: [2207, 2225] }, 'templateStringCharacter_NonEscaped', []],
-			['app', { sourceInterval: [2265, 2284] }, 'templateStringCharacter_Escaped', []],
+			{ sourceInterval: [2350, 2463] },
+			['app', { sourceInterval: [2352, 2370] }, 'templateStringCharacter_NonEscaped', []],
+			['app', { sourceInterval: [2410, 2429] }, 'templateStringCharacter_Escaped', []],
 		]],
-		lineContinuation: ['define', { sourceInterval: [2323, 2369] }, null, [], ['seq', { sourceInterval: [2342, 2369] }, [
+		lineContinuation: ['define', { sourceInterval: [2468, 2514] }, null, [], ['seq', { sourceInterval: [2487, 2514] }, [
 			'terminal',
-			{ sourceInterval: [2342, 2346] },
+			{ sourceInterval: [2487, 2491] },
 			'\\',
-		], ['app', { sourceInterval: [2347, 2369] }, 'lineTerminatorSequence', []]]],
-		escapeSequence: ['define', { sourceInterval: [2374, 2480] }, null, [], [
+		], ['app', { sourceInterval: [2492, 2514] }, 'lineTerminatorSequence', []]]],
+		escapeSequence: ['define', { sourceInterval: [2519, 2625] }, null, [], [
 			'alt',
-			{ sourceInterval: [2391, 2480] },
-			['app', { sourceInterval: [2391, 2412] }, 'unicodeEscapeSequence', []],
-			['app', { sourceInterval: [2415, 2432] }, 'hexEscapeSequence', []],
-			['app', { sourceInterval: [2435, 2454] }, 'octalEscapeSequence', []],
-			['app', { sourceInterval: [2457, 2480] }, 'characterEscapeSequence', []],
+			{ sourceInterval: [2536, 2625] },
+			['app', { sourceInterval: [2536, 2557] }, 'unicodeEscapeSequence', []],
+			['app', { sourceInterval: [2560, 2577] }, 'hexEscapeSequence', []],
+			['app', { sourceInterval: [2580, 2599] }, 'octalEscapeSequence', []],
+			['app', { sourceInterval: [2602, 2625] }, 'characterEscapeSequence', []],
 		]],
-		characterEscapeSequence: ['define', { sourceInterval: [2485, 2553] }, null, [], [
+		characterEscapeSequence: ['define', { sourceInterval: [2630, 2698] }, null, [], [
 			'alt',
-			{ sourceInterval: [2511, 2553] },
-			['app', { sourceInterval: [2511, 2532] }, 'singleEscapeCharacter', []],
-			['app', { sourceInterval: [2535, 2553] }, 'nonEscapeCharacter', []],
+			{ sourceInterval: [2656, 2698] },
+			['app', { sourceInterval: [2656, 2677] }, 'singleEscapeCharacter', []],
+			['app', { sourceInterval: [2680, 2698] }, 'nonEscapeCharacter', []],
 		]],
-		singleEscapeCharacter: ['define', { sourceInterval: [2558, 2635] }, null, [], [
+		singleEscapeCharacter: ['define', { sourceInterval: [2703, 2780] }, null, [], [
 			'alt',
-			{ sourceInterval: [2582, 2635] },
-			['terminal', { sourceInterval: [2582, 2585] }, "'"],
-			['terminal', { sourceInterval: [2588, 2592] }, '"'],
-			['terminal', { sourceInterval: [2595, 2599] }, '\\'],
-			['terminal', { sourceInterval: [2602, 2605] }, 'b'],
-			['terminal', { sourceInterval: [2608, 2611] }, 'f'],
-			['terminal', { sourceInterval: [2614, 2617] }, 'n'],
-			['terminal', { sourceInterval: [2620, 2623] }, 'r'],
-			['terminal', { sourceInterval: [2626, 2629] }, 't'],
-			['terminal', { sourceInterval: [2632, 2635] }, 'v'],
-		]],
-		nonEscapeCharacter: ['define', { sourceInterval: [2640, 2700] }, null, [], [
+			{ sourceInterval: [2727, 2780] },
+			['terminal', { sourceInterval: [2727, 2730] }, "'"],
+			['terminal', { sourceInterval: [2733, 2737] }, '"'],
+			['terminal', { sourceInterval: [2740, 2744] }, '\\'],
+			['terminal', { sourceInterval: [2747, 2750] }, 'b'],
+			['terminal', { sourceInterval: [2753, 2756] }, 'f'],
+			['terminal', { sourceInterval: [2759, 2762] }, 'n'],
+			['terminal', { sourceInterval: [2765, 2768] }, 'r'],
+			['terminal', { sourceInterval: [2771, 2774] }, 't'],
+			['terminal', { sourceInterval: [2777, 2780] }, 'v'],
+		]],
+		nonEscapeCharacter: ['define', { sourceInterval: [2785, 2845] }, null, [], [
 			'seq',
-			{ sourceInterval: [2661, 2700] },
-			['not', { sourceInterval: [2661, 2696] }, ['alt', { sourceInterval: [2663, 2695] }, [
+			{ sourceInterval: [2806, 2845] },
+			['not', { sourceInterval: [2806, 2841] }, ['alt', { sourceInterval: [2808, 2840] }, [
 				'app',
-				{ sourceInterval: [2663, 2678] },
+				{ sourceInterval: [2808, 2823] },
 				'escapeCharacter',
 				[],
-			], ['app', { sourceInterval: [2681, 2695] }, 'lineTerminator', []]]],
-			['app', { sourceInterval: [2697, 2700] }, 'any', []],
+			], ['app', { sourceInterval: [2826, 2840] }, 'lineTerminator', []]]],
+			['app', { sourceInterval: [2842, 2845] }, 'any', []],
 		]],
-		escapeCharacter: ['define', { sourceInterval: [2705, 2771] }, null, [], [
+		escapeCharacter: ['define', { sourceInterval: [2850, 2916] }, null, [], [
 			'alt',
-			{ sourceInterval: [2723, 2771] },
-			['app', { sourceInterval: [2723, 2744] }, 'singleEscapeCharacter', []],
-			['app', { sourceInterval: [2747, 2759] }, 'decimalDigit', []],
-			['terminal', { sourceInterval: [2762, 2765] }, 'x'],
-			['terminal', { sourceInterval: [2768, 2771] }, 'u'],
+			{ sourceInterval: [2868, 2916] },
+			['app', { sourceInterval: [2868, 2889] }, 'singleEscapeCharacter', []],
+			['app', { sourceInterval: [2892, 2904] }, 'decimalDigit', []],
+			['terminal', { sourceInterval: [2907, 2910] }, 'x'],
+			['terminal', { sourceInterval: [2913, 2916] }, 'u'],
 		]],
-		octalEscapeSequence_Whole: ['define', { sourceInterval: [2804, 2850] }, null, [], [
+		octalEscapeSequence_Whole: ['define', { sourceInterval: [2949, 2995] }, null, [], [
 			'seq',
-			{ sourceInterval: [2804, 2837] },
-			['app', { sourceInterval: [2804, 2815] }, 'zeroToThree', []],
-			['app', { sourceInterval: [2816, 2826] }, 'octalDigit', []],
-			['app', { sourceInterval: [2827, 2837] }, 'octalDigit', []],
+			{ sourceInterval: [2949, 2982] },
+			['app', { sourceInterval: [2949, 2960] }, 'zeroToThree', []],
+			['app', { sourceInterval: [2961, 2971] }, 'octalDigit', []],
+			['app', { sourceInterval: [2972, 2982] }, 'octalDigit', []],
 		]],
-		octalEscapeSequence_EightTimesfourToSeven: ['define', { sourceInterval: [2857, 2919] }, null, [], [
+		octalEscapeSequence_EightTimesfourToSeven: ['define', { sourceInterval: [3002, 3064] }, null, [], [
 			'seq',
-			{ sourceInterval: [2857, 2879] },
-			['app', { sourceInterval: [2857, 2868] }, 'fourToSeven', []],
-			['app', { sourceInterval: [2869, 2879] }, 'octalDigit', []],
+			{ sourceInterval: [3002, 3024] },
+			['app', { sourceInterval: [3002, 3013] }, 'fourToSeven', []],
+			['app', { sourceInterval: [3014, 3024] }, 'octalDigit', []],
 		]],
-		octalEscapeSequence_EightTimesZeroToThree: ['define', { sourceInterval: [2926, 2988] }, null, [], [
+		octalEscapeSequence_EightTimesZeroToThree: ['define', { sourceInterval: [3071, 3133] }, null, [], [
 			'seq',
-			{ sourceInterval: [2926, 2962] },
-			['app', { sourceInterval: [2926, 2937] }, 'zeroToThree', []],
-			['app', { sourceInterval: [2938, 2948] }, 'octalDigit', []],
-			['not', { sourceInterval: [2949, 2962] }, ['app', { sourceInterval: [2950, 2962] }, 'decimalDigit', []]],
+			{ sourceInterval: [3071, 3107] },
+			['app', { sourceInterval: [3071, 3082] }, 'zeroToThree', []],
+			['app', { sourceInterval: [3083, 3093] }, 'octalDigit', []],
+			['not', { sourceInterval: [3094, 3107] }, ['app', { sourceInterval: [3095, 3107] }, 'decimalDigit', []]],
 		]],
-		octalEscapeSequence_Octal: ['define', { sourceInterval: [2995, 3041] }, null, [], [
+		octalEscapeSequence_Octal: ['define', { sourceInterval: [3140, 3186] }, null, [], [
 			'seq',
-			{ sourceInterval: [2995, 3019] },
-			['app', { sourceInterval: [2995, 3005] }, 'octalDigit', []],
-			['not', { sourceInterval: [3006, 3019] }, ['app', { sourceInterval: [3007, 3019] }, 'decimalDigit', []]],
+			{ sourceInterval: [3140, 3164] },
+			['app', { sourceInterval: [3140, 3150] }, 'octalDigit', []],
+			['not', { sourceInterval: [3151, 3164] }, ['app', { sourceInterval: [3152, 3164] }, 'decimalDigit', []]],
 		]],
-		octalEscapeSequence: ['define', { sourceInterval: [2776, 3041] }, null, [], [
+		octalEscapeSequence: ['define', { sourceInterval: [2921, 3186] }, null, [], [
 			'alt',
-			{ sourceInterval: [2802, 3041] },
-			['app', { sourceInterval: [2804, 2837] }, 'octalEscapeSequence_Whole', []],
-			['app', { sourceInterval: [2857, 2879] }, 'octalEscapeSequence_EightTimesfourToSeven', []],
-			['app', { sourceInterval: [2926, 2962] }, 'octalEscapeSequence_EightTimesZeroToThree', []],
-			['app', { sourceInterval: [2995, 3019] }, 'octalEscapeSequence_Octal', []],
+			{ sourceInterval: [2947, 3186] },
+			['app', { sourceInterval: [2949, 2982] }, 'octalEscapeSequence_Whole', []],
+			['app', { sourceInterval: [3002, 3024] }, 'octalEscapeSequence_EightTimesfourToSeven', []],
+			['app', { sourceInterval: [3071, 3107] }, 'octalEscapeSequence_EightTimesZeroToThree', []],
+			['app', { sourceInterval: [3140, 3164] }, 'octalEscapeSequence_Octal', []],
 		]],
-		hexEscapeSequence: ['define', { sourceInterval: [3046, 3087] }, null, [], [
+		hexEscapeSequence: ['define', { sourceInterval: [3191, 3232] }, null, [], [
 			'seq',
-			{ sourceInterval: [3066, 3087] },
-			['terminal', { sourceInterval: [3066, 3069] }, 'x'],
-			['app', { sourceInterval: [3070, 3078] }, 'hexDigit', []],
-			['app', { sourceInterval: [3079, 3087] }, 'hexDigit', []],
+			{ sourceInterval: [3211, 3232] },
+			['terminal', { sourceInterval: [3211, 3214] }, 'x'],
+			['app', { sourceInterval: [3215, 3223] }, 'hexDigit', []],
+			['app', { sourceInterval: [3224, 3232] }, 'hexDigit', []],
 		]],
-		unicodeEscapeSequence: ['define', { sourceInterval: [3092, 3155] }, null, [], [
+		unicodeEscapeSequence: ['define', { sourceInterval: [3237, 3300] }, null, [], [
 			'seq',
-			{ sourceInterval: [3116, 3155] },
-			['terminal', { sourceInterval: [3116, 3119] }, 'u'],
-			['app', { sourceInterval: [3120, 3128] }, 'hexDigit', []],
-			['app', { sourceInterval: [3129, 3137] }, 'hexDigit', []],
-			['app', { sourceInterval: [3138, 3146] }, 'hexDigit', []],
-			['app', { sourceInterval: [3147, 3155] }, 'hexDigit', []],
-		]],
-		zeroToThree: ['define', { sourceInterval: [3161, 3183] }, null, [], [
+			{ sourceInterval: [3261, 3300] },
+			['terminal', { sourceInterval: [3261, 3264] }, 'u'],
+			['app', { sourceInterval: [3265, 3273] }, 'hexDigit', []],
+			['app', { sourceInterval: [3274, 3282] }, 'hexDigit', []],
+			['app', { sourceInterval: [3283, 3291] }, 'hexDigit', []],
+			['app', { sourceInterval: [3292, 3300] }, 'hexDigit', []],
+		]],
+		zeroToThree: ['define', { sourceInterval: [3306, 3328] }, null, [], [
 			'range',
-			{ sourceInterval: [3175, 3183] },
+			{ sourceInterval: [3320, 3328] },
 			'0',
 			'3',
 		]],
-		fourToSeven: ['define', { sourceInterval: [3188, 3210] }, null, [], [
+		fourToSeven: ['define', { sourceInterval: [3333, 3355] }, null, [], [
 			'range',
-			{ sourceInterval: [3202, 3210] },
+			{ sourceInterval: [3347, 3355] },
 			'4',
 			'7',
 		]],
-		decimalDigit: ['define', { sourceInterval: [3215, 3238] }, null, [], [
+		decimalDigit: ['define', { sourceInterval: [3360, 3383] }, null, [], [
 			'range',
-			{ sourceInterval: [3230, 3238] },
+			{ sourceInterval: [3375, 3383] },
 			'0',
 			'9',
 		]],
-		nonZeroDigit: ['define', { sourceInterval: [3243, 3266] }, null, [], [
+		nonZeroDigit: ['define', { sourceInterval: [3388, 3411] }, null, [], [
 			'range',
-			{ sourceInterval: [3258, 3266] },
+			{ sourceInterval: [3403, 3411] },
 			'1',
 			'9',
 		]],
-		octalDigit: ['define', { sourceInterval: [3271, 3292] }, null, [], [
+		octalDigit: ['define', { sourceInterval: [3416, 3437] }, null, [], [
 			'range',
-			{ sourceInterval: [3284, 3292] },
+			{ sourceInterval: [3429, 3437] },
 			'0',
 			'7',
 		]],
-		regularExpressionLiteral: ['define', { sourceInterval: [3298, 3377] }, null, [], [
+		regularExpressionLiteral: ['define', { sourceInterval: [3443, 3522] }, null, [], [
 			'seq',
-			{ sourceInterval: [3325, 3377] },
-			['terminal', { sourceInterval: [3325, 3328] }, '/'],
-			['app', { sourceInterval: [3329, 3350] }, 'regularExpressionBody', []],
-			['terminal', { sourceInterval: [3351, 3354] }, '/'],
-			['app', { sourceInterval: [3355, 3377] }, 'regularExpressionFlags', []],
+			{ sourceInterval: [3470, 3522] },
+			['terminal', { sourceInterval: [3470, 3473] }, '/'],
+			['app', { sourceInterval: [3474, 3495] }, 'regularExpressionBody', []],
+			['terminal', { sourceInterval: [3496, 3499] }, '/'],
+			['app', { sourceInterval: [3500, 3522] }, 'regularExpressionFlags', []],
 		]],
-		regularExpressionBody: ['define', { sourceInterval: [3382, 3455] }, null, [], [
+		regularExpressionBody: ['define', { sourceInterval: [3527, 3600] }, null, [], [
 			'seq',
-			{ sourceInterval: [3406, 3455] },
-			['app', { sourceInterval: [3406, 3432] }, 'regularExpressionFirstChar', []],
-			['star', { sourceInterval: [3433, 3455] }, [
+			{ sourceInterval: [3551, 3600] },
+			['app', { sourceInterval: [3551, 3577] }, 'regularExpressionFirstChar', []],
+			['star', { sourceInterval: [3578, 3600] }, [
 				'app',
-				{ sourceInterval: [3433, 3454] },
+				{ sourceInterval: [3578, 3599] },
 				'regularExpressionChar',
 				[],
 			]],
 		]],
-		regularExpressionFirstChar: ['define', { sourceInterval: [3460, 3621] }, null, [], ['alt', {
-			sourceInterval: [3493, 3621],
-		}, ['seq', { sourceInterval: [3495, 3551] }, ['not', { sourceInterval: [3495, 3520] }, [
+		regularExpressionFirstChar: ['define', { sourceInterval: [3605, 3766] }, null, [], ['alt', {
+			sourceInterval: [3638, 3766],
+		}, ['seq', { sourceInterval: [3640, 3696] }, ['not', { sourceInterval: [3640, 3665] }, [
 			'alt',
-			{ sourceInterval: [3497, 3519] },
-			['terminal', { sourceInterval: [3497, 3500] }, '*'],
-			['terminal', { sourceInterval: [3503, 3507] }, '\\'],
-			['terminal', { sourceInterval: [3510, 3513] }, '/'],
-			['terminal', { sourceInterval: [3516, 3519] }, '['],
-		]], ['app', { sourceInterval: [3521, 3551] }, 'regularExpressionNonTerminator', []]], [
+			{ sourceInterval: [3642, 3664] },
+			['terminal', { sourceInterval: [3642, 3645] }, '*'],
+			['terminal', { sourceInterval: [3648, 3652] }, '\\'],
+			['terminal', { sourceInterval: [3655, 3658] }, '/'],
+			['terminal', { sourceInterval: [3661, 3664] }, '['],
+		]], ['app', { sourceInterval: [3666, 3696] }, 'regularExpressionNonTerminator', []]], [
 			'app',
-			{ sourceInterval: [3558, 3592] },
+			{ sourceInterval: [3703, 3737] },
 			'regularExpressionBackslashSequence',
 			[],
-		], ['app', { sourceInterval: [3599, 3621] }, 'regularExpressionClass', []]]],
-		regularExpressionChar: ['define', { sourceInterval: [3626, 3770] }, null, [], ['alt', {
-			sourceInterval: [3650, 3770],
-		}, ['seq', { sourceInterval: [3650, 3700] }, ['not', { sourceInterval: [3650, 3669] }, [
+		], ['app', { sourceInterval: [3744, 3766] }, 'regularExpressionClass', []]]],
+		regularExpressionChar: ['define', { sourceInterval: [3771, 3915] }, null, [], ['alt', {
+			sourceInterval: [3795, 3915],
+		}, ['seq', { sourceInterval: [3795, 3845] }, ['not', { sourceInterval: [3795, 3814] }, [
 			'alt',
-			{ sourceInterval: [3652, 3668] },
-			['terminal', { sourceInterval: [3652, 3656] }, '\\'],
-			['terminal', { sourceInterval: [3659, 3662] }, '/'],
-			['terminal', { sourceInterval: [3665, 3668] }, '['],
-		]], ['app', { sourceInterval: [3670, 3700] }, 'regularExpressionNonTerminator', []]], [
+			{ sourceInterval: [3797, 3813] },
+			['terminal', { sourceInterval: [3797, 3801] }, '\\'],
+			['terminal', { sourceInterval: [3804, 3807] }, '/'],
+			['terminal', { sourceInterval: [3810, 3813] }, '['],
+		]], ['app', { sourceInterval: [3815, 3845] }, 'regularExpressionNonTerminator', []]], [
 			'app',
-			{ sourceInterval: [3707, 3741] },
+			{ sourceInterval: [3852, 3886] },
 			'regularExpressionBackslashSequence',
 			[],
-		], ['app', { sourceInterval: [3748, 3770] }, 'regularExpressionClass', []]]],
-		regularExpressionBackslashSequence: ['define', { sourceInterval: [3775, 3847] }, null, [], [
+		], ['app', { sourceInterval: [3893, 3915] }, 'regularExpressionClass', []]]],
+		regularExpressionBackslashSequence: ['define', { sourceInterval: [3920, 3992] }, null, [], [
 			'seq',
-			{ sourceInterval: [3812, 3847] },
-			['terminal', { sourceInterval: [3812, 3816] }, '\\'],
-			['app', { sourceInterval: [3817, 3847] }, 'regularExpressionNonTerminator', []],
+			{ sourceInterval: [3957, 3992] },
+			['terminal', { sourceInterval: [3957, 3961] }, '\\'],
+			['app', { sourceInterval: [3962, 3992] }, 'regularExpressionNonTerminator', []],
 		]],
-		regularExpressionNonTerminator: ['define', { sourceInterval: [3852, 3906] }, null, [], [
+		regularExpressionNonTerminator: ['define', { sourceInterval: [3997, 4051] }, null, [], [
 			'seq',
-			{ sourceInterval: [3885, 3906] },
-			['not', { sourceInterval: [3885, 3902] }, ['app', { sourceInterval: [3887, 3901] }, 'lineTerminator', []]],
-			['app', { sourceInterval: [3903, 3906] }, 'any', []],
+			{ sourceInterval: [4030, 4051] },
+			['not', { sourceInterval: [4030, 4047] }, ['app', { sourceInterval: [4032, 4046] }, 'lineTerminator', []]],
+			['app', { sourceInterval: [4048, 4051] }, 'any', []],
 		]],
-		regularExpressionClass: ['define', { sourceInterval: [3911, 3971] }, null, [], [
+		regularExpressionClass: ['define', { sourceInterval: [4056, 4116] }, null, [], [
 			'seq',
-			{ sourceInterval: [3936, 3971] },
-			['terminal', { sourceInterval: [3936, 3939] }, '['],
-			['star', { sourceInterval: [3940, 3967] }, [
+			{ sourceInterval: [4081, 4116] },
+			['terminal', { sourceInterval: [4081, 4084] }, '['],
+			['star', { sourceInterval: [4085, 4112] }, [
 				'app',
-				{ sourceInterval: [3940, 3966] },
+				{ sourceInterval: [4085, 4111] },
 				'regularExpressionClassChar',
 				[],
 			]],
-			['terminal', { sourceInterval: [3968, 3971] }, ']'],
+			['terminal', { sourceInterval: [4113, 4116] }, ']'],
 		]],
-		regularExpressionClassChar: ['define', { sourceInterval: [3976, 4096] }, null, [], ['alt', {
-			sourceInterval: [4009, 4096],
-		}, ['seq', { sourceInterval: [4011, 4055] }, ['not', { sourceInterval: [4011, 4024] }, [
+		regularExpressionClassChar: ['define', { sourceInterval: [4121, 4241] }, null, [], ['alt', {
+			sourceInterval: [4154, 4241],
+		}, ['seq', { sourceInterval: [4156, 4200] }, ['not', { sourceInterval: [4156, 4169] }, [
 			'alt',
-			{ sourceInterval: [4013, 4023] },
-			['terminal', { sourceInterval: [4013, 4016] }, ']'],
-			['terminal', { sourceInterval: [4019, 4023] }, '\\'],
-		]], ['app', { sourceInterval: [4025, 4055] }, 'regularExpressionNonTerminator', []]], [
+			{ sourceInterval: [4158, 4168] },
+			['terminal', { sourceInterval: [4158, 4161] }, ']'],
+			['terminal', { sourceInterval: [4164, 4168] }, '\\'],
+		]], ['app', { sourceInterval: [4170, 4200] }, 'regularExpressionNonTerminator', []]], [
 			'app',
-			{ sourceInterval: [4062, 4096] },
+			{ sourceInterval: [4207, 4241] },
 			'regularExpressionBackslashSequence',
 			[],
 		]]],
-		regularExpressionFlags: ['define', { sourceInterval: [4101, 4141] }, null, [], ['star', {
-			sourceInterval: [4126, 4141],
-		}, ['app', { sourceInterval: [4126, 4140] }, 'identifierPart', []]]],
-		multiLineCommentNoNL: ['define', { sourceInterval: [4147, 4211] }, null, [], [
+		regularExpressionFlags: ['define', { sourceInterval: [4246, 4286] }, null, [], ['star', {
+			sourceInterval: [4271, 4286],
+		}, ['app', { sourceInterval: [4271, 4285] }, 'identifierPart', []]]],
+		multiLineCommentNoNL: ['define', { sourceInterval: [4292, 4356] }, null, [], [
 			'seq',
-			{ sourceInterval: [4170, 4211] },
-			['terminal', { sourceInterval: [4170, 4174] }, '/*'],
-			['star', { sourceInterval: [4175, 4206] }, ['seq', { sourceInterval: [4176, 4204] }, ['not', {
-				sourceInterval: [4176, 4200],
-			}, ['alt', { sourceInterval: [4178, 4199] }, ['terminal', { sourceInterval: [4178, 4182] }, '*/'], [
+			{ sourceInterval: [4315, 4356] },
+			['terminal', { sourceInterval: [4315, 4319] }, '/*'],
+			['star', { sourceInterval: [4320, 4351] }, ['seq', { sourceInterval: [4321, 4349] }, ['not', {
+				sourceInterval: [4321, 4345],
+			}, ['alt', { sourceInterval: [4323, 4344] }, ['terminal', { sourceInterval: [4323, 4327] }, '*/'], [
 				'app',
-				{ sourceInterval: [4185, 4199] },
+				{ sourceInterval: [4330, 4344] },
 				'lineTerminator',
 				[],
-			]]], ['app', { sourceInterval: [4201, 4204] }, 'any', []]]],
-			['terminal', { sourceInterval: [4207, 4211] }, '*/'],
+			]]], ['app', { sourceInterval: [4346, 4349] }, 'any', []]]],
+			['terminal', { sourceInterval: [4352, 4356] }, '*/'],
 		]],
-		identifierStart_escaped: ['define', { sourceInterval: [4266, 4303] }, null, [], [
+		identifierStart_escaped: ['define', { sourceInterval: [4411, 4448] }, null, [], [
 			'seq',
-			{ sourceInterval: [4266, 4292] },
-			['terminal', { sourceInterval: [4266, 4270] }, '\\'],
-			['app', { sourceInterval: [4271, 4292] }, 'unicodeEscapeSequence', []],
+			{ sourceInterval: [4411, 4437] },
+			['terminal', { sourceInterval: [4411, 4415] }, '\\'],
+			['app', { sourceInterval: [4416, 4437] }, 'unicodeEscapeSequence', []],
 		]],
-		identifierStart: ['define', { sourceInterval: [4217, 4303] }, null, [], [
+		identifierStart: ['define', { sourceInterval: [4362, 4448] }, null, [], [
 			'alt',
-			{ sourceInterval: [4239, 4303] },
-			['app', { sourceInterval: [4241, 4247] }, 'letter', []],
-			['terminal', { sourceInterval: [4250, 4253] }, '$'],
-			['terminal', { sourceInterval: [4256, 4259] }, '_'],
-			['app', { sourceInterval: [4266, 4292] }, 'identifierStart_escaped', []],
+			{ sourceInterval: [4384, 4448] },
+			['app', { sourceInterval: [4386, 4392] }, 'letter', []],
+			['terminal', { sourceInterval: [4395, 4398] }, '$'],
+			['terminal', { sourceInterval: [4401, 4404] }, '_'],
+			['app', { sourceInterval: [4411, 4437] }, 'identifierStart_escaped', []],
 		]],
-		identifierPart: ['define', { sourceInterval: [4308, 4444] }, null, [], [
+		identifierPart: ['define', { sourceInterval: [4453, 4589] }, null, [], [
 			'alt',
-			{ sourceInterval: [4329, 4444] },
-			['app', { sourceInterval: [4331, 4346] }, 'identifierStart', []],
-			['app', { sourceInterval: [4349, 4369] }, 'unicodeCombiningMark', []],
-			['app', { sourceInterval: [4376, 4388] }, 'unicodeDigit', []],
-			['app', { sourceInterval: [4391, 4418] }, 'unicodeConnectorPunctuation', []],
-			['terminal', { sourceInterval: [4425, 4433] }, '‌'],
-			['terminal', { sourceInterval: [4436, 4444] }, '‍'],
-		]],
-		letter: ['extend', { sourceInterval: [4449, 4476] }, null, [], [
+			{ sourceInterval: [4474, 4589] },
+			['app', { sourceInterval: [4476, 4491] }, 'identifierStart', []],
+			['app', { sourceInterval: [4494, 4514] }, 'unicodeCombiningMark', []],
+			['app', { sourceInterval: [4521, 4533] }, 'unicodeDigit', []],
+			['app', { sourceInterval: [4536, 4563] }, 'unicodeConnectorPunctuation', []],
+			['terminal', { sourceInterval: [4570, 4578] }, '‌'],
+			['terminal', { sourceInterval: [4581, 4589] }, '‍'],
+		]],
+		letter: ['extend', { sourceInterval: [4594, 4621] }, null, [], [
 			'app',
-			{ sourceInterval: [4459, 4476] },
+			{ sourceInterval: [4604, 4621] },
 			'unicodeCategoryNl',
 			[],
 		]],
-		unicodeCategoryNl: ['define', { sourceInterval: [4481, 4555] }, null, [], [
+		unicodeCategoryNl: ['define', { sourceInterval: [4626, 4700] }, null, [], [
 			'alt',
-			{ sourceInterval: [4505, 4555] },
-			['range', { sourceInterval: [4505, 4523] }, 'Ⅰ', 'ↂ'],
-			['terminal', { sourceInterval: [4526, 4534] }, '〇'],
-			['range', { sourceInterval: [4537, 4555] }, '〡', '〩'],
+			{ sourceInterval: [4650, 4700] },
+			['range', { sourceInterval: [4650, 4668] }, 'Ⅰ', 'ↂ'],
+			['terminal', { sourceInterval: [4671, 4679] }, '〇'],
+			['range', { sourceInterval: [4682, 4700] }, '〡', '〩'],
 		]],
-		unicodeDigit: ['define', { sourceInterval: [4560, 4922] }, 'a digit', [], [
+		unicodeDigit: ['define', { sourceInterval: [4705, 5067] }, 'a digit', [], [
 			'alt',
-			{ sourceInterval: [4589, 4922] },
-			['range', { sourceInterval: [4589, 4607] }, '0', '9'],
-			['range', { sourceInterval: [4610, 4628] }, '٠', '٩'],
-			['range', { sourceInterval: [4631, 4649] }, '۰', '۹'],
-			['range', { sourceInterval: [4652, 4670] }, '०', '९'],
-			['range', { sourceInterval: [4673, 4691] }, '০', '৯'],
-			['range', { sourceInterval: [4694, 4712] }, '੦', '੯'],
-			['range', { sourceInterval: [4715, 4733] }, '૦', '૯'],
-			['range', { sourceInterval: [4736, 4754] }, '୦', '୯'],
-			['range', { sourceInterval: [4757, 4775] }, '௧', '௯'],
-			['range', { sourceInterval: [4778, 4796] }, '౦', '౯'],
-			['range', { sourceInterval: [4799, 4817] }, '೦', '೯'],
-			['range', { sourceInterval: [4820, 4838] }, '൦', '൯'],
-			['range', { sourceInterval: [4841, 4859] }, '๐', '๙'],
-			['range', { sourceInterval: [4862, 4880] }, '໐', '໙'],
-			['range', { sourceInterval: [4883, 4901] }, '༠', '༩'],
-			['range', { sourceInterval: [4904, 4922] }, '０', '９'],
-		]],
-		unicodeCombiningMark: ['define', { sourceInterval: [4928, 6659] }, 'a Unicode combining mark', [], [
+			{ sourceInterval: [4734, 5067] },
+			['range', { sourceInterval: [4734, 4752] }, '0', '9'],
+			['range', { sourceInterval: [4755, 4773] }, '٠', '٩'],
+			['range', { sourceInterval: [4776, 4794] }, '۰', '۹'],
+			['range', { sourceInterval: [4797, 4815] }, '०', '९'],
+			['range', { sourceInterval: [4818, 4836] }, '০', '৯'],
+			['range', { sourceInterval: [4839, 4857] }, '੦', '੯'],
+			['range', { sourceInterval: [4860, 4878] }, '૦', '૯'],
+			['range', { sourceInterval: [4881, 4899] }, '୦', '୯'],
+			['range', { sourceInterval: [4902, 4920] }, '௧', '௯'],
+			['range', { sourceInterval: [4923, 4941] }, '౦', '౯'],
+			['range', { sourceInterval: [4944, 4962] }, '೦', '೯'],
+			['range', { sourceInterval: [4965, 4983] }, '൦', '൯'],
+			['range', { sourceInterval: [4986, 5004] }, '๐', '๙'],
+			['range', { sourceInterval: [5007, 5025] }, '໐', '໙'],
+			['range', { sourceInterval: [5028, 5046] }, '༠', '༩'],
+			['range', { sourceInterval: [5049, 5067] }, '０', '９'],
+		]],
+		unicodeCombiningMark: ['define', { sourceInterval: [5073, 6804] }, 'a Unicode combining mark', [], [
 			'alt',
-			{ sourceInterval: [4982, 6659] },
-			['range', { sourceInterval: [4982, 5000] }, '̀', 'ͅ'],
-			['range', { sourceInterval: [5003, 5021] }, '͠', '͡'],
-			['range', { sourceInterval: [5024, 5042] }, '҃', '҆'],
-			['range', { sourceInterval: [5045, 5063] }, '֑', '֡'],
-			['range', { sourceInterval: [5066, 5084] }, '֣', 'ֹ'],
-			['range', { sourceInterval: [5087, 5105] }, 'ֻ', 'ֽ'],
-			['range', { sourceInterval: [5108, 5126] }, 'ֿ', 'ֿ'],
-			['range', { sourceInterval: [5129, 5147] }, 'ׁ', 'ׂ'],
-			['range', { sourceInterval: [5150, 5168] }, 'ׄ', 'ׄ'],
-			['range', { sourceInterval: [5171, 5189] }, 'ً', 'ْ'],
-			['range', { sourceInterval: [5192, 5210] }, 'ٰ', 'ٰ'],
-			['range', { sourceInterval: [5213, 5231] }, 'ۖ', 'ۜ'],
-			['range', { sourceInterval: [5234, 5252] }, '۟', 'ۤ'],
-			['range', { sourceInterval: [5255, 5273] }, 'ۧ', 'ۨ'],
-			['range', { sourceInterval: [5276, 5294] }, '۪', 'ۭ'],
-			['range', { sourceInterval: [5297, 5315] }, 'ँ', 'ं'],
-			['range', { sourceInterval: [5318, 5336] }, '़', '़'],
-			['range', { sourceInterval: [5339, 5357] }, 'ु', 'ै'],
-			['range', { sourceInterval: [5360, 5378] }, '्', '्'],
-			['range', { sourceInterval: [5381, 5399] }, '॑', '॔'],
-			['range', { sourceInterval: [5402, 5420] }, 'ॢ', 'ॣ'],
-			['range', { sourceInterval: [5423, 5441] }, 'ঁ', 'ঁ'],
-			['range', { sourceInterval: [5444, 5462] }, '়', '়'],
-			['range', { sourceInterval: [5465, 5483] }, 'ু', 'ৄ'],
-			['range', { sourceInterval: [5486, 5504] }, '্', '্'],
-			['range', { sourceInterval: [5507, 5525] }, 'ৢ', 'ৣ'],
-			['range', { sourceInterval: [5528, 5546] }, 'ਂ', 'ਂ'],
-			['range', { sourceInterval: [5549, 5567] }, '਼', '਼'],
-			['range', { sourceInterval: [5570, 5588] }, 'ੁ', 'ੂ'],
-			['range', { sourceInterval: [5591, 5609] }, 'ੇ', 'ੈ'],
-			['range', { sourceInterval: [5612, 5630] }, 'ੋ', '੍'],
-			['range', { sourceInterval: [5633, 5651] }, 'ੰ', 'ੱ'],
-			['range', { sourceInterval: [5654, 5672] }, 'ઁ', 'ં'],
-			['range', { sourceInterval: [5675, 5693] }, '઼', '઼'],
-			['range', { sourceInterval: [5696, 5714] }, 'ુ', 'ૅ'],
-			['range', { sourceInterval: [5717, 5735] }, 'ે', 'ૈ'],
-			['range', { sourceInterval: [5738, 5756] }, '્', '્'],
-			['range', { sourceInterval: [5759, 5777] }, 'ଁ', 'ଁ'],
-			['range', { sourceInterval: [5780, 5798] }, '଼', '଼'],
-			['range', { sourceInterval: [5801, 5819] }, 'ି', 'ି'],
-			['range', { sourceInterval: [5822, 5840] }, 'ୁ', 'ୃ'],
-			['range', { sourceInterval: [5843, 5861] }, '୍', '୍'],
-			['range', { sourceInterval: [5864, 5882] }, 'ୖ', 'ୖ'],
-			['range', { sourceInterval: [5885, 5903] }, 'ஂ', 'ஂ'],
-			['range', { sourceInterval: [5906, 5924] }, 'ீ', 'ீ'],
-			['range', { sourceInterval: [5927, 5945] }, '்', '்'],
-			['range', { sourceInterval: [5948, 5966] }, 'ా', 'ీ'],
-			['range', { sourceInterval: [5969, 5987] }, 'ె', 'ై'],
-			['range', { sourceInterval: [5990, 6008] }, 'ొ', '్'],
-			['range', { sourceInterval: [6011, 6029] }, 'ౕ', 'ౖ'],
-			['range', { sourceInterval: [6032, 6050] }, 'ಿ', 'ಿ'],
-			['range', { sourceInterval: [6053, 6071] }, 'ೆ', 'ೆ'],
-			['range', { sourceInterval: [6074, 6092] }, 'ೌ', '್'],
-			['range', { sourceInterval: [6095, 6113] }, 'ു', 'ൃ'],
-			['range', { sourceInterval: [6116, 6134] }, '്', '്'],
-			['range', { sourceInterval: [6137, 6155] }, 'ั', 'ั'],
-			['range', { sourceInterval: [6158, 6176] }, 'ิ', 'ฺ'],
-			['range', { sourceInterval: [6179, 6197] }, '็', '๎'],
-			['range', { sourceInterval: [6200, 6218] }, 'ັ', 'ັ'],
-			['range', { sourceInterval: [6221, 6239] }, 'ິ', 'ູ'],
-			['range', { sourceInterval: [6242, 6260] }, 'ົ', 'ຼ'],
-			['range', { sourceInterval: [6263, 6281] }, '່', 'ໍ'],
-			['range', { sourceInterval: [6284, 6302] }, '༘', '༙'],
-			['range', { sourceInterval: [6305, 6323] }, '༵', '༵'],
-			['range', { sourceInterval: [6326, 6344] }, '༷', '༷'],
-			['range', { sourceInterval: [6347, 6365] }, '༹', '༹'],
-			['range', { sourceInterval: [6368, 6386] }, 'ཱ', 'ཾ'],
-			['range', { sourceInterval: [6389, 6407] }, 'ྀ', '྄'],
-			['range', { sourceInterval: [6410, 6428] }, '྆', '྇'],
-			['range', { sourceInterval: [6431, 6449] }, 'ྐ', 'ྕ'],
-			['range', { sourceInterval: [6452, 6470] }, 'ྗ', 'ྗ'],
-			['range', { sourceInterval: [6473, 6491] }, 'ྙ', 'ྭ'],
-			['range', { sourceInterval: [6494, 6512] }, 'ྱ', 'ྷ'],
-			['range', { sourceInterval: [6515, 6533] }, 'ྐྵ', 'ྐྵ'],
-			['range', { sourceInterval: [6536, 6554] }, '⃐', '⃜'],
-			['range', { sourceInterval: [6557, 6575] }, '⃡', '⃡'],
-			['range', { sourceInterval: [6578, 6596] }, '〪', '〯'],
-			['range', { sourceInterval: [6599, 6617] }, '゙', '゚'],
-			['range', { sourceInterval: [6620, 6638] }, 'ﬞ', 'ﬞ'],
-			['range', { sourceInterval: [6641, 6659] }, '︠', '︣'],
-		]],
-		unicodeConnectorPunctuation: ['define', { sourceInterval: [6665, 6799] }, null, [], [
+			{ sourceInterval: [5127, 6804] },
+			['range', { sourceInterval: [5127, 5145] }, '̀', 'ͅ'],
+			['range', { sourceInterval: [5148, 5166] }, '͠', '͡'],
+			['range', { sourceInterval: [5169, 5187] }, '҃', '҆'],
+			['range', { sourceInterval: [5190, 5208] }, '֑', '֡'],
+			['range', { sourceInterval: [5211, 5229] }, '֣', 'ֹ'],
+			['range', { sourceInterval: [5232, 5250] }, 'ֻ', 'ֽ'],
+			['range', { sourceInterval: [5253, 5271] }, 'ֿ', 'ֿ'],
+			['range', { sourceInterval: [5274, 5292] }, 'ׁ', 'ׂ'],
+			['range', { sourceInterval: [5295, 5313] }, 'ׄ', 'ׄ'],
+			['range', { sourceInterval: [5316, 5334] }, 'ً', 'ْ'],
+			['range', { sourceInterval: [5337, 5355] }, 'ٰ', 'ٰ'],
+			['range', { sourceInterval: [5358, 5376] }, 'ۖ', 'ۜ'],
+			['range', { sourceInterval: [5379, 5397] }, '۟', 'ۤ'],
+			['range', { sourceInterval: [5400, 5418] }, 'ۧ', 'ۨ'],
+			['range', { sourceInterval: [5421, 5439] }, '۪', 'ۭ'],
+			['range', { sourceInterval: [5442, 5460] }, 'ँ', 'ं'],
+			['range', { sourceInterval: [5463, 5481] }, '़', '़'],
+			['range', { sourceInterval: [5484, 5502] }, 'ु', 'ै'],
+			['range', { sourceInterval: [5505, 5523] }, '्', '्'],
+			['range', { sourceInterval: [5526, 5544] }, '॑', '॔'],
+			['range', { sourceInterval: [5547, 5565] }, 'ॢ', 'ॣ'],
+			['range', { sourceInterval: [5568, 5586] }, 'ঁ', 'ঁ'],
+			['range', { sourceInterval: [5589, 5607] }, '়', '়'],
+			['range', { sourceInterval: [5610, 5628] }, 'ু', 'ৄ'],
+			['range', { sourceInterval: [5631, 5649] }, '্', '্'],
+			['range', { sourceInterval: [5652, 5670] }, 'ৢ', 'ৣ'],
+			['range', { sourceInterval: [5673, 5691] }, 'ਂ', 'ਂ'],
+			['range', { sourceInterval: [5694, 5712] }, '਼', '਼'],
+			['range', { sourceInterval: [5715, 5733] }, 'ੁ', 'ੂ'],
+			['range', { sourceInterval: [5736, 5754] }, 'ੇ', 'ੈ'],
+			['range', { sourceInterval: [5757, 5775] }, 'ੋ', '੍'],
+			['range', { sourceInterval: [5778, 5796] }, 'ੰ', 'ੱ'],
+			['range', { sourceInterval: [5799, 5817] }, 'ઁ', 'ં'],
+			['range', { sourceInterval: [5820, 5838] }, '઼', '઼'],
+			['range', { sourceInterval: [5841, 5859] }, 'ુ', 'ૅ'],
+			['range', { sourceInterval: [5862, 5880] }, 'ે', 'ૈ'],
+			['range', { sourceInterval: [5883, 5901] }, '્', '્'],
+			['range', { sourceInterval: [5904, 5922] }, 'ଁ', 'ଁ'],
+			['range', { sourceInterval: [5925, 5943] }, '଼', '଼'],
+			['range', { sourceInterval: [5946, 5964] }, 'ି', 'ି'],
+			['range', { sourceInterval: [5967, 5985] }, 'ୁ', 'ୃ'],
+			['range', { sourceInterval: [5988, 6006] }, '୍', '୍'],
+			['range', { sourceInterval: [6009, 6027] }, 'ୖ', 'ୖ'],
+			['range', { sourceInterval: [6030, 6048] }, 'ஂ', 'ஂ'],
+			['range', { sourceInterval: [6051, 6069] }, 'ீ', 'ீ'],
+			['range', { sourceInterval: [6072, 6090] }, '்', '்'],
+			['range', { sourceInterval: [6093, 6111] }, 'ా', 'ీ'],
+			['range', { sourceInterval: [6114, 6132] }, 'ె', 'ై'],
+			['range', { sourceInterval: [6135, 6153] }, 'ొ', '్'],
+			['range', { sourceInterval: [6156, 6174] }, 'ౕ', 'ౖ'],
+			['range', { sourceInterval: [6177, 6195] }, 'ಿ', 'ಿ'],
+			['range', { sourceInterval: [6198, 6216] }, 'ೆ', 'ೆ'],
+			['range', { sourceInterval: [6219, 6237] }, 'ೌ', '್'],
+			['range', { sourceInterval: [6240, 6258] }, 'ു', 'ൃ'],
+			['range', { sourceInterval: [6261, 6279] }, '്', '്'],
+			['range', { sourceInterval: [6282, 6300] }, 'ั', 'ั'],
+			['range', { sourceInterval: [6303, 6321] }, 'ิ', 'ฺ'],
+			['range', { sourceInterval: [6324, 6342] }, '็', '๎'],
+			['range', { sourceInterval: [6345, 6363] }, 'ັ', 'ັ'],
+			['range', { sourceInterval: [6366, 6384] }, 'ິ', 'ູ'],
+			['range', { sourceInterval: [6387, 6405] }, 'ົ', 'ຼ'],
+			['range', { sourceInterval: [6408, 6426] }, '່', 'ໍ'],
+			['range', { sourceInterval: [6429, 6447] }, '༘', '༙'],
+			['range', { sourceInterval: [6450, 6468] }, '༵', '༵'],
+			['range', { sourceInterval: [6471, 6489] }, '༷', '༷'],
+			['range', { sourceInterval: [6492, 6510] }, '༹', '༹'],
+			['range', { sourceInterval: [6513, 6531] }, 'ཱ', 'ཾ'],
+			['range', { sourceInterval: [6534, 6552] }, 'ྀ', '྄'],
+			['range', { sourceInterval: [6555, 6573] }, '྆', '྇'],
+			['range', { sourceInterval: [6576, 6594] }, 'ྐ', 'ྕ'],
+			['range', { sourceInterval: [6597, 6615] }, 'ྗ', 'ྗ'],
+			['range', { sourceInterval: [6618, 6636] }, 'ྙ', 'ྭ'],
+			['range', { sourceInterval: [6639, 6657] }, 'ྱ', 'ྷ'],
+			['range', { sourceInterval: [6660, 6678] }, 'ྐྵ', 'ྐྵ'],
+			['range', { sourceInterval: [6681, 6699] }, '⃐', '⃜'],
+			['range', { sourceInterval: [6702, 6720] }, '⃡', '⃡'],
+			['range', { sourceInterval: [6723, 6741] }, '〪', '〯'],
+			['range', { sourceInterval: [6744, 6762] }, '゙', '゚'],
+			['range', { sourceInterval: [6765, 6783] }, 'ﬞ', 'ﬞ'],
+			['range', { sourceInterval: [6786, 6804] }, '︠', '︣'],
+		]],
+		unicodeConnectorPunctuation: ['define', { sourceInterval: [6810, 6944] }, null, [], [
 			'alt',
-			{ sourceInterval: [6695, 6799] },
-			['terminal', { sourceInterval: [6695, 6703] }, '_'],
-			['range', { sourceInterval: [6706, 6724] }, '‿', '⁀'],
-			['terminal', { sourceInterval: [6727, 6735] }, '・'],
-			['range', { sourceInterval: [6738, 6756] }, '︳', '︴'],
-			['range', { sourceInterval: [6759, 6777] }, '﹍', '﹏'],
-			['terminal', { sourceInterval: [6780, 6788] }, '＿'],
-			['terminal', { sourceInterval: [6791, 6799] }, '･'],
-		]],
-		unicodeSpaceSeparator: ['define', { sourceInterval: [6804, 6857] }, null, [], [
+			{ sourceInterval: [6840, 6944] },
+			['terminal', { sourceInterval: [6840, 6848] }, '_'],
+			['range', { sourceInterval: [6851, 6869] }, '‿', '⁀'],
+			['terminal', { sourceInterval: [6872, 6880] }, '・'],
+			['range', { sourceInterval: [6883, 6901] }, '︳', '︴'],
+			['range', { sourceInterval: [6904, 6922] }, '﹍', '﹏'],
+			['terminal', { sourceInterval: [6925, 6933] }, '＿'],
+			['terminal', { sourceInterval: [6936, 6944] }, '･'],
+		]],
+		unicodeSpaceSeparator: ['define', { sourceInterval: [6949, 7002] }, null, [], [
 			'alt',
-			{ sourceInterval: [6828, 6857] },
-			['range', { sourceInterval: [6828, 6846] }, ' ', '​'],
-			['terminal', { sourceInterval: [6849, 6857] }, '　'],
+			{ sourceInterval: [6973, 7002] },
+			['range', { sourceInterval: [6973, 6991] }, ' ', '​'],
+			['terminal', { sourceInterval: [6994, 7002] }, '　'],
 		]],
 	},
 ]);
diff --git a/drizzle-kit/imports-checker/index.ts b/drizzle-kit/imports-checker/index.ts
index 7a4e908382..c25fa09c4a 100644
--- a/drizzle-kit/imports-checker/index.ts
+++ b/drizzle-kit/imports-checker/index.ts
@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { analyzeImports, ChainLink } from './checker';
+import type { ChainLink } from './checker';
+import { analyzeImports } from './checker';
 
 const issues = analyzeImports({
 	basePath: './drizzle-kit',
diff --git a/drizzle-kit/package.json b/drizzle-kit/package.json
index 9e24f04927..8a887914b3 100644
--- a/drizzle-kit/package.json
+++ b/drizzle-kit/package.json
@@ -1,6 +1,6 @@
 {
-	"name": "@drizzle-team/drizzle-kit",
-	"version": "0.32.1",
+	"name": "drizzle-kit",
+	"version": "1.0.0-rc.4",
 	"homepage": "https://orm.drizzle.team",
 	"keywords": [
 		"drizzle",
@@ -17,7 +17,10 @@
 		"ts",
 		"drizzle-kit",
 		"migrations",
-		"schema"
+		"schema",
+		"tanstack-intent",
+		"skills",
+		"agent-skills"
 	],
 	"publishConfig": {
 		"provenance": true
@@ -35,88 +38,95 @@
 		"api": "tsx ./dev/api.ts",
 		"migrate:old": "drizzle-kit generate:mysql",
 		"cli": "tsx ./src/cli/index.ts",
-		"test": "pnpm tsc && TEST_CONFIG_PATH_PREFIX=./tests/cli/ vitest",
-		"build": "rm -rf ./dist && tsx build.ts && cp package.json dist/ && attw --pack dist",
+		"test": "TEST_CONFIG_PATH_PREFIX=./tests/cli/ vitest run",
+		"test:types": "pnpm tsc -p ./tsconfig.typetest.json",
+		"build": "bun --bun run scripts/build.ts",
+		"build:artifact": "pnpm run build",
+		"build:cli": "rm -rf ./dist && tsx build.cli.ts && cp package.json dist/",
 		"build:dev": "rm -rf ./dist && tsx build.dev.ts && tsc -p tsconfig.cli-types.json && chmod +x ./dist/index.cjs",
-		"pack": "cd dist && PACK_FILE=$(npm pack --pack-destination ..) && cd .. && rm -f package.tgz && mv \"$PACK_FILE\" package.tgz",
-		"tsc": "tsc -p tsconfig.build.json --noEmit",
-		"login": "npx google-artifactregistry-auth --repo-config ~/.npmrc",
-		"publish": "npm publish package.tgz --provenance=false"
+		"build:ext": "rm -rf ./dist && vitest run bin.test && vitest run ./tests/postgres/ && vitest run ./tests/sqlite && vitest run ./tests/mysql && tsx build.ext.ts",
+		"pack": "cp package.json README.md dist/ && (cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
+		"pack:artifact": "pnpm run pack",
+		"publish": "npm publish package.tgz",
+		"test:postgres": "vitest run ./postgres/",
+		"test:other": "vitest run ./mysql/ ./sqlite/ ./other",
+		"test:cockroach": "vitest run ./cockroach",
+		"test:mssql": "vitest run ./mssql",
+		"test:singlestore": "vitest run ./singlestore",
+		"skills:revision:check": "tsx scripts/check-skills-revision.ts"
 	},
 	"dependencies": {
-		"@drizzle-team/brocli": "^0.10.2",
-		"@esbuild-kit/esm-loader": "^2.5.5",
-		"esbuild": "^0.25.4",
-		"esbuild-register": "^3.5.0",
-		"postgres-array": "^3.0.4"
+		"@drizzle-team/brocli": "^0.12.0",
+		"@js-temporal/polyfill": "^0.5.1",
+		"esbuild": "^0.25.10",
+		"get-tsconfig": "^4.13.6",
+		"jiti": "^2.6.1"
 	},
 	"devDependencies": {
-		"@arethetypeswrong/cli": "^0.15.3",
 		"@aws-sdk/client-rds-data": "^3.556.0",
+		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@cloudflare/workers-types": "^4.20230518.0",
-		"@electric-sql/pglite": "^0.2.12",
+		"@duckdb/node-api": "1.5.0-r.1",
+		"@effect/sql": "^0.48.5",
+		"@electric-sql/pglite": "^0.4.6",
 		"@hono/node-server": "^1.9.0",
 		"@hono/zod-validator": "^0.2.1",
 		"@libsql/client": "^0.10.0",
-		"@neondatabase/serverless": "^0.9.1",
+		"@neondatabase/serverless": "^1.0.2",
 		"@originjs/vite-plugin-commonjs": "^1.0.3",
-		"@planetscale/database": "^1.16.0",
+		"@planetscale/database": "^1.19.0",
+		"@sqlitecloud/drivers": "^1.0.653",
+		"@tursodatabase/database": "0.6.0-pre.28",
+		"@tursodatabase/serverless": "^1.1.3",
 		"@types/better-sqlite3": "^7.6.13",
+		"@types/bun": "^1.3.2",
 		"@types/dockerode": "^3.3.28",
 		"@types/glob": "^8.1.0",
 		"@types/json-diff": "^1.0.3",
 		"@types/micromatch": "^4.0.9",
 		"@types/minimatch": "^5.1.2",
-		"@types/node": "^18.11.15",
+		"@types/mssql": "^9.1.4",
+		"@types/node": "^24.7.2",
 		"@types/pg": "^8.10.7",
 		"@types/pluralize": "^0.0.33",
 		"@types/semver": "^7.5.5",
 		"@types/uuid": "^9.0.8",
 		"@types/ws": "^8.5.10",
-		"@typescript-eslint/eslint-plugin": "^7.2.0",
-		"@typescript-eslint/parser": "^7.2.0",
 		"@vercel/postgres": "^0.8.0",
 		"ava": "^5.1.0",
 		"better-sqlite3": "^11.9.1",
-		"bun-types": "^0.6.6",
+		"bun-types": "^1.3.2",
 		"camelcase": "^7.0.1",
 		"chalk": "^5.2.0",
 		"commander": "^12.1.0",
 		"dockerode": "^4.0.6",
 		"dotenv": "^16.0.3",
-		"drizzle-kit": "0.25.0-b1faa33",
-		"drizzle-orm": "0.44.1",
+		"drizzle-kit": "^0.31.6",
+		"drizzle-orm": "workspace:./drizzle-orm/dist",
 		"env-paths": "^3.0.0",
-		"esbuild-node-externals": "^1.9.0",
-		"eslint": "^8.57.0",
-		"eslint-config-prettier": "^9.1.0",
-		"eslint-plugin-prettier": "^5.1.3",
-		"gel": "^2.0.0",
 		"get-port": "^6.1.2",
 		"glob": "^8.1.0",
-		"hanji": "^0.0.5",
+		"hanji": "^0.0.8",
 		"hono": "^4.7.9",
 		"json-diff": "1.0.6",
 		"micromatch": "^4.0.8",
 		"minimatch": "^7.4.3",
+		"mssql": "^12.0.0",
 		"mysql2": "3.14.1",
 		"node-fetch": "^3.3.2",
 		"ohm-js": "^17.1.0",
+		"orm044": "npm:drizzle-orm@0.44.1",
 		"pg": "^8.11.5",
 		"pluralize": "^8.0.0",
 		"postgres": "^3.4.4",
 		"prettier": "^3.5.3",
 		"semver": "^7.7.2",
-		"superjson": "^2.2.1",
-		"tsup": "^8.3.5",
-		"tsx": "^3.12.1",
-		"typescript": "^5.6.3",
+		"tsx": "^4.20.6",
+		"typescript": "5.9.3",
 		"uuid": "^9.0.1",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
 		"ws": "^8.18.2",
-		"zod": "^3.20.2",
-		"zx": "^8.3.2"
+		"zod": "^3.25",
+		"zx": "^8.8.5"
 	},
 	"exports": {
 		".": {
@@ -131,17 +141,101 @@
 			"types": "./index.d.mts",
 			"default": "./index.mjs"
 		},
-		"./api": {
+		"./api-postgres": {
 			"import": {
-				"types": "./api.d.mts",
-				"default": "./api.mjs"
+				"types": "./api-postgres.d.mts",
+				"default": "./api-postgres.mjs"
 			},
 			"require": {
-				"types": "./api.d.ts",
-				"default": "./api.js"
+				"types": "./api-postgres.d.ts",
+				"default": "./api-postgres.js"
 			},
-			"types": "./api.d.mts",
-			"default": "./api.mjs"
+			"types": "./api-postgres.d.mts",
+			"default": "./api-postgres.mjs"
+		},
+		"./api-mysql": {
+			"import": {
+				"types": "./api-mysql.d.mts",
+				"default": "./api-mysql.mjs"
+			},
+			"require": {
+				"types": "./api-mysql.d.ts",
+				"default": "./api-mysql.js"
+			},
+			"types": "./api-mysql.d.mts",
+			"default": "./api-mysql.mjs"
+		},
+		"./api-sqlite": {
+			"import": {
+				"types": "./api-sqlite.d.mts",
+				"default": "./api-sqlite.mjs"
+			},
+			"require": {
+				"types": "./api-sqlite.d.ts",
+				"default": "./api-sqlite.js"
+			},
+			"types": "./api-sqlite.d.mts",
+			"default": "./api-sqlite.mjs"
+		},
+		"./cli": {
+			"import": {
+				"types": "./cli.d.mts",
+				"default": "./cli.mjs"
+			},
+			"require": {
+				"types": "./cli.d.ts",
+				"default": "./cli.js"
+			},
+			"types": "./cli.d.mts",
+			"default": "./cli.mjs"
+		},
+		"./payload/postgres": {
+			"import": {
+				"types": "./payload-postgres.d.mts",
+				"default": "./payload-postgres.mjs"
+			},
+			"require": {
+				"types": "./payload-postgres.d.ts",
+				"default": "./payload-postgres.js"
+			},
+			"types": "./payload-postgres.d.mts",
+			"default": "./payload-postgres.mjs"
+		},
+		"./payload/mysql": {
+			"import": {
+				"types": "./payload-mysql.d.mts",
+				"default": "./payload-mysql.mjs"
+			},
+			"require": {
+				"types": "./payload-mysql.d.ts",
+				"default": "./payload-mysql.js"
+			},
+			"types": "./payload-mysql.d.mts",
+			"default": "./payload-mysql.mjs"
+		},
+		"./payload/sqlite": {
+			"import": {
+				"types": "./payload-sqlite.d.mts",
+				"default": "./payload-sqlite.mjs"
+			},
+			"require": {
+				"types": "./payload-sqlite.d.ts",
+				"default": "./payload-sqlite.js"
+			},
+			"types": "./payload-sqlite.d.mts",
+			"default": "./payload-sqlite.mjs"
+		},
+		"./payload/mssql": {
+			"import": {
+				"types": "./payload-mssql.d.mts",
+				"default": "./payload-mssql.mjs"
+			},
+			"require": {
+				"types": "./payload-mssql.d.ts",
+				"default": "./payload-mssql.js"
+			},
+			"types": "./payload-mssql.d.mts",
+			"default": "./payload-mssql.mjs"
 		}
 	}
 }
diff --git a/drizzle-kit/scripts/build.ts b/drizzle-kit/scripts/build.ts
new file mode 100644
index 0000000000..9f02ac80e1
--- /dev/null
+++ b/drizzle-kit/scripts/build.ts
@@ -0,0 +1,304 @@
+#!/usr/bin/env bun
+import { existsSync, rmSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import { rolldown } from 'rolldown';
+import { build as tsdown } from 'tsdown';
+import pkg from '../package.json';
+import { readSkillsRevisionFromDisk } from './lib/read-skills-revision';
+
+const driversPackages = [
+	// postgres drivers
+	'pg',
+	'postgres',
+	'@vercel/postgres',
+	'@neondatabase/serverless',
+	'@electric-sql/pglite',
+	// mysql drivers
+	'mysql2',
+	'@planetscale/database',
+	// sqlite drivers
+	'@libsql/client',
+	'better-sqlite3',
+	'bun:sqlite',
+	'@sqlitecloud/drivers',
+	'@tursodatabase/database',
+	'bun',
+	// mssql drivers
+	'mssql',
+	// duckdb drivers
+	'duckdb',
+	'@duckdb/node-api',
+];
+
+const external = [
+	'esbuild',
+	/^drizzle-orm\/?/,
+	...driversPackages,
+];
+
+async function buildBundle(options: {
+	name: string;
+	input: string;
+	outputName: string;
+	format: 'cjs' | 'esm';
+	banner?: string;
+}) {
+	const build = await rolldown({
+		input: options.input,
+		platform: 'node',
+		external,
+		tsconfig: 'tsconfig.json',
+	});
+
+	await build.write({
+		dir: 'dist',
+		format: options.format,
+		entryFileNames: options.outputName,
+		codeSplitting: false,
+		banner: options.banner,
+	});
+
+	await build.close();
+	console.log(`  Built ${options.outputName}`);
+}
+
+async function buildCli() {
+	const build = await rolldown({
+		input: './src/cli/index.ts',
+		platform: 'node',
+		external,
+		tsconfig: 'tsconfig.json',
+	});
+
+	await build.write({
+		dir: 'dist',
+		format: 'cjs',
+		entryFileNames: 'bin.cjs',
+		banner: '#!/usr/bin/env node',
+		codeSplitting: false,
+	});
+
+	await build.close();
+
+	const binContent = await fs.readFile('dist/bin.cjs', 'utf8');
+	const patched = binContent
+		.replace(/process\.env\.DRIZZLE_KIT_VERSION/g, JSON.stringify(pkg.version))
+		.replace(/process\.env\.DRIZZLE_KIT_SKILLS_REVISION/g, JSON.stringify(readSkillsRevisionFromDisk('./skills')));
+	await fs.writeFile('dist/bin.cjs', patched);
+
+	console.log('  Built bin.cjs');
+}
+
+// tsdown's `emitDtsOnly: true` still emits chunked .js files alongside the
+// declarations. If tsdown writes to ./dist it overwrites rolldown's clean
+// single-file bundles and produces a CJS entry that fails to load. Direct
+// tsdown's output at a temp dir and copy only .d.ts / .d.mts back into ./dist.
+const TSDOWN_TEMP_DIR = './dist/__dts-temp';
+
+async function buildDeclarations() {
+	// Use tsdown for declaration bundling - it handles path resolution and creates bundled .d.ts files
+	await tsdown({
+		entry: { index: './src/index.ts', cli: './src/cli-sdk/index.ts' },
+		outDir: TSDOWN_TEMP_DIR,
+		external: [...driversPackages, /^drizzle-orm\/?/],
+		dts: { emitDtsOnly: true },
+		format: ['cjs', 'es'],
+		logLevel: 'silent',
+		clean: false,
+		outExtensions: (ctx) => {
+			if (ctx.format === 'cjs') {
+				return { dts: '.d.ts', js: '.js' };
+			}
+			return { dts: '.d.mts', js: '.mjs' };
+		},
+	});
+
+	await tsdown({
+		entry: {
+			'api-postgres': './src/ext/api-postgres.ts',
+			'api-mysql': './src/ext/api-mysql.ts',
+			'api-sqlite': './src/ext/api-sqlite.ts',
+			'payload-postgres': './src/payload/postgres.ts',
+			'payload-mysql': './src/payload/mysql.ts',
+			'payload-sqlite': './src/payload/sqlite.ts',
+			'payload-mssql': './src/payload/mssql.ts',
+		},
+		outDir: TSDOWN_TEMP_DIR,
+		external: ['esbuild', 'drizzle-orm', ...driversPackages, /^drizzle-orm\/?/],
+		dts: { emitDtsOnly: true },
+		format: ['cjs', 'es'],
+		logLevel: 'silent',
+		clean: false,
+		outExtensions: (ctx) => {
+			if (ctx.format === 'cjs') {
+				return { dts: '.d.ts', js: '.js' };
+			}
+			return { dts: '.d.mts', js: '.mjs' };
+		},
+	});
+
+	console.log('  Built declarations');
+}
+
+async function copyDeclarationsAndCleanTemp() {
+	const entries = await fs.readdir(TSDOWN_TEMP_DIR);
+	await Promise.all(
+		entries
+			.filter((f) => f.endsWith('.d.ts') || f.endsWith('.d.mts'))
+			.map((f) => fs.copyFile(`${TSDOWN_TEMP_DIR}/${f}`, `dist/${f}`)),
+	);
+	rmSync(TSDOWN_TEMP_DIR, { recursive: true, force: true });
+}
+
+async function postProcessApiFiles() {
+	const apiFiles = [
+		'dist/api-postgres.js',
+		'dist/api-mysql.js',
+		'dist/api-sqlite.js',
+		'dist/payload-postgres.js',
+		'dist/payload-mysql.js',
+		'dist/payload-sqlite.js',
+		'dist/payload-mssql.js',
+	];
+	await Promise.all(
+		apiFiles.map(async (file) => {
+			if (existsSync(file)) {
+				const content = await fs.readFile(file, 'utf8');
+				await fs.writeFile(file, content.replace(/await import\(/g, 'require('));
+			}
+		}),
+	);
+}
+
+async function main() {
+	const startTime = Date.now();
+	rmSync('dist', { recursive: true, force: true });
+
+	await Promise.all([
+		buildCli(),
+		buildBundle({
+			name: 'index-cjs',
+			input: './src/index.ts',
+			outputName: 'index.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'index-esm',
+			input: './src/index.ts',
+			outputName: 'index.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'api-postgres-cjs',
+			input: './src/ext/api-postgres.ts',
+			outputName: 'api-postgres.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'api-postgres-esm',
+			input: './src/ext/api-postgres.ts',
+			outputName: 'api-postgres.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'api-mysql-cjs',
+			input: './src/ext/api-mysql.ts',
+			outputName: 'api-mysql.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'api-mysql-esm',
+			input: './src/ext/api-mysql.ts',
+			outputName: 'api-mysql.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'api-sqlite-cjs',
+			input: './src/ext/api-sqlite.ts',
+			outputName: 'api-sqlite.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'api-sqlite-esm',
+			input: './src/ext/api-sqlite.ts',
+			outputName: 'api-sqlite.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'cli-cjs',
+			input: './src/cli-sdk/index.ts',
+			outputName: 'cli.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'cli-esm',
+			input: './src/cli-sdk/index.ts',
+			outputName: 'cli.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'payload-postgres-cjs',
+			input: './src/payload/postgres.ts',
+			outputName: 'payload-postgres.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'payload-postgres-esm',
+			input: './src/payload/postgres.ts',
+			outputName: 'payload-postgres.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'payload-mysql-cjs',
+			input: './src/payload/mysql.ts',
+			outputName: 'payload-mysql.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'payload-mysql-esm',
+			input: './src/payload/mysql.ts',
+			outputName: 'payload-mysql.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'payload-sqlite-cjs',
+			input: './src/payload/sqlite.ts',
+			outputName: 'payload-sqlite.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'payload-sqlite-esm',
+			input: './src/payload/sqlite.ts',
+			outputName: 'payload-sqlite.mjs',
+			format: 'esm',
+		}),
+		buildBundle({
+			name: 'payload-mssql-cjs',
+			input: './src/payload/mssql.ts',
+			outputName: 'payload-mssql.js',
+			format: 'cjs',
+		}),
+		buildBundle({
+			name: 'payload-mssql-esm',
+			input: './src/payload/mssql.ts',
+			outputName: 'payload-mssql.mjs',
+			format: 'esm',
+		}),
+		buildDeclarations(),
+	]);
+
+	await copyDeclarationsAndCleanTemp();
+	await Promise.all([
+		postProcessApiFiles(),
+		fs.copyFile('package.json', 'dist/package.json'),
+		fs.cp('skills', 'dist/skills', { recursive: true }),
+	]);
+
+	const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+	console.log(`Build completed successfully in ${elapsed}s`);
+}
+
+await main().catch((e) => {
+	console.error(e);
+	process.exit(1);
+}).then(() => process.exit(0));
diff --git a/drizzle-kit/scripts/check-skills-revision.ts b/drizzle-kit/scripts/check-skills-revision.ts
new file mode 100644
index 0000000000..b1259ba9bb
--- /dev/null
+++ b/drizzle-kit/scripts/check-skills-revision.ts
@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseSkillsRevision, readSkillsRevisionFromDisk } from './lib/read-skills-revision';
+
+const REPO_ROOT = resolve(__dirname, '..', '..');
+const SKILLS_DIR = resolve(__dirname, '..', 'skills');
+const UMBRELLA_RELPATH = 'drizzle-kit/skills/drizzle/SKILL.md';
+
+const sh = (cmd: string, args: string[]) => spawnSync(cmd, args, { cwd: REPO_ROOT, encoding: 'utf8' });
+
+// The gate runs only in pull-request context, where it diffs the whole branch against the PR's
+// base branch SHA (set from `github.event.pull_request.base.sha`). Requires `actions/checkout`
+// with `fetch-depth: 0` so the base commit is reachable.
+const computeBaseline = (): string => {
+	const baseSha = process.env['GH_BASE_SHA']?.trim();
+	if (!baseSha) {
+		throw new Error(
+			'GH_BASE_SHA is not set; the skills revision gate only runs in pull-request context. '
+				+ 'Omit this step for non-PR runs (e.g. manual publish).',
+		);
+	}
+	return baseSha;
+};
+
+const skillsTouched = (baseline: string): string[] => {
+	const r = sh('git', ['diff', '--name-only', `${baseline}..HEAD`, '--', 'drizzle-kit/skills/']);
+	if (r.status !== 0) throw new Error(`git diff failed: ${r.stderr}`);
+	return r.stdout.split('\n').map((l) => l.trim()).filter(Boolean);
+};
+
+const revisionAtBaseline = (baseline: string): { kind: 'new' } | { kind: 'value'; value: number } => {
+	const r = sh('git', ['show', `${baseline}:${UMBRELLA_RELPATH}`]);
+	// `git show <sha>:<path>` reports a missing path with two distinct messages depending on
+	// whether the worktree has the file: "does not exist in '<sha>'" when absent from the worktree,
+	// "exists on disk, but not in '<sha>'" when present in the worktree but not in the commit.
+	// Both mean the file didn't exist at the baseline — treat as first introduction.
+	if (r.status === 128 && /does not exist in|exists on disk, but not in/.test(r.stderr)) return { kind: 'new' };
+	if (r.status !== 0) throw new Error(`git show ${baseline}:${UMBRELLA_RELPATH} failed: ${r.stderr}`);
+	// Pre-rename baselines carried `metadata.skillsRevision` as a semver string. The new parser will
+	// throw on those; treat the parse failure as revision 0 so the first post-rename bump still
+	// passes the strict-increase check. Remove this fallback once `main` no longer carries the
+	// legacy field at any reachable baseline.
+	try {
+		return { kind: 'value', value: Number.parseInt(parseSkillsRevision(r.stdout), 10) };
+	} catch {
+		return { kind: 'value', value: 0 };
+	}
+};
+
+const main = (): number => {
+	const baseline = computeBaseline();
+	const touched = skillsTouched(baseline);
+	if (touched.length === 0) {
+		console.log(`No files under drizzle-kit/skills/ changed since ${baseline}; nothing to check.`);
+		return 0;
+	}
+	const at = revisionAtBaseline(baseline);
+	if (at.kind === 'value' && !existsSync(resolve(SKILLS_DIR, 'drizzle', 'SKILL.md'))) {
+		console.error(
+			`Umbrella SKILL.md is missing at HEAD but present at baseline (${baseline.slice(0, 8)}).\n`
+				+ `  Path: ${UMBRELLA_RELPATH}\n`
+				+ `Restore the file (or revert its deletion); the umbrella owns the canonical metadata.revision the publish gate reads.`,
+		);
+		return 1;
+	}
+	const head = Number.parseInt(readSkillsRevisionFromDisk(SKILLS_DIR), 10);
+	if (at.kind === 'new') {
+		console.log(`Umbrella SKILL.md was introduced in this range; treating revision ${head} as the initial bump.`);
+		return 0;
+	}
+	if (head <= at.value) {
+		const reason = head === at.value
+			? `was not bumped`
+			: `moved ${at.value} -> ${head} (not a strict increase)`;
+		console.error(
+			`Skills bundle drift detected; metadata.revision ${reason}.\n`
+				+ `  baseline (${baseline.slice(0, 8)}): ${at.value}\n`
+				+ `  HEAD: ${head}\n`
+				+ `  Files changed under drizzle-kit/skills/:\n`
+				+ touched.map((f) => `    ${f}`).join('\n')
+				+ `\nIncrement metadata.revision in ${UMBRELLA_RELPATH} and commit it in the same range.`,
+		);
+		return 1;
+	}
+	console.log(`metadata.revision bumped ${at.value} -> ${head}; ${touched.length} skills files changed.`);
+	return 0;
+};
+
+process.exit(main());
diff --git a/drizzle-kit/scripts/lib/read-skills-revision.ts b/drizzle-kit/scripts/lib/read-skills-revision.ts
new file mode 100644
index 0000000000..ba27c91d4d
--- /dev/null
+++ b/drizzle-kit/scripts/lib/read-skills-revision.ts
@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+
+// Positive integer starting from 1 — leading zeros rejected to keep the wire format unambiguous.
+const POSITIVE_INTEGER = /^[1-9]\d*$/;
+
+export const parseSkillsRevision = (markdown: string): string => {
+	const block = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!block) throw new Error('umbrella SKILL.md missing YAML frontmatter');
+	const meta = block[1]!.match(/^metadata:\s*\r?\n((?:[ \t]+\S.*\r?\n?)+)/m);
+	if (!meta) throw new Error('umbrella SKILL.md frontmatter missing `metadata:` block');
+	const field = meta[1]!.match(/^[ \t]+revision:\s*["']?([^"'\r\n]+)["']?\s*$/m);
+	if (!field) throw new Error('umbrella SKILL.md `metadata.revision` not found');
+	const value = field[1]!.trim();
+	if (!POSITIVE_INTEGER.test(value)) throw new Error(`metadata.revision must be a positive integer, got '${value}'`);
+	return value;
+};
+
+export const readSkillsRevisionFromDisk = (skillsDir: string): string => {
+	return parseSkillsRevision(readFileSync(`${skillsDir}/drizzle/SKILL.md`, 'utf8'));
+};
diff --git a/drizzle-kit/skills/drizzle-generate/SKILL.md b/drizzle-kit/skills/drizzle-generate/SKILL.md
new file mode 100644
index 0000000000..99a131b02e
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-generate/SKILL.md
@@ -0,0 +1,107 @@
+---
+name: drizzle-generate
+description: Create a new drizzle migration SQL file by diffing the schema against the latest snapshot. Load before running `drizzle-kit generate` or calling the `generate(...)` SDK, after any Drizzle schema edit when the next step is producing migration SQL, or when the task is to generate, scaffold, or make a new migration.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle generate
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+The CLI flag `--output json` and the SDK `generate(...)` function emit the same discriminated-union envelope, and the envelope (not the stdout text) is what the agent decodes. Output format and interactivity are separate axes: `--output json` selects the machine-readable envelope and is always non-interactive, so pass it whenever an agent calls the CLI. Under the default `--output text` the CLI prompts only when stdin is a TTY; in a non-TTY it prints the missing-decisions report and exits 2 (it never hangs prompting). See the `drizzle-output-modes` skill for the two modes and the interactivity rule. The SDK runs in JSON mode internally with no flag needed at the call site. This skill assumes a working Drizzle schema and a `drizzle.config.ts` already exist; it does not author schemas.
+
+## CLI form
+
+```bash
+drizzle-kit generate --output json [--config drizzle.config.ts] [--dialect <d>] [--schema <path>] [--out <dir>] [--explain] [--hints '<json>' | --hints-file ./hints.json]
+```
+
+Flag surface:
+
+- `--config` — path to `drizzle.config.ts` (default: `drizzle.config.ts` at CWD).
+- `--dialect`, `--schema`, `--out` — override the corresponding `defineConfig` fields.
+- `--output json` — switches stdout to one JSON line carrying the envelope and is always non-interactive. Use it for agent / CI / scripted contexts. Under the default `--output text` the CLI prompts only on a TTY and otherwise prints the missing-decisions report (exit 2).
+- `--explain` — dry-run mode. Returns planned SQL statements and computed hints instead of writing a migration file.
+- `--hints` — inline JSON array of hint resolutions (see the `drizzle-hints` skill).
+- `--hints-file` — same payload as `--hints`, read from a JSON file. Use for long hint sets.
+
+Minimal example:
+
+```bash
+drizzle-kit generate --output json --config drizzle.config.ts
+# → {"status":"ok","dialect":"postgresql","migration_path":"drizzle/0001_name/migration.sql"}
+```
+
+The process exits with the code that matches `status` (see Response envelope below). Agents read both stdout (the envelope) and the exit code.
+
+## SDK form
+
+```typescript
+import { generate } from 'drizzle-kit';
+
+const response = await generate({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+});
+
+if (response.status === 'ok') {
+  // response.migration_path is the path to the new SQL file
+} else if (response.status === 'no_changes') {
+  // schema matches the most recent migration — nothing was written
+} else if (response.status === 'missing_hints') {
+  // response.unresolved lists ambiguities — see the drizzle-hints skill
+} else if (response.status === 'error') {
+  // response.error.code identifies the failure — see drizzle-responses-and-errors
+}
+```
+
+The SDK is the public-surface entry point. It always runs in JSON mode internally — no `--output json` flag needed at the call site — and returns the same envelope the CLI prints. Narrow on `response.status` to extract typed branches:
+
+- `'ok'` → `response.dialect`, `response.migration_path` (or `response.statements`, `response.hints` in explain mode).
+- `'no_changes'` → `response.dialect`.
+- `'missing_hints'` → `response.unresolved` (array of items).
+- `'error'` → `response.error.code` plus per-code metadata.
+
+The SDK does not throw on user-level failures — every outcome flows through the envelope. Unexpected runtime exceptions are wrapped as `status: 'error'` with `code: 'internal_error'`.
+
+## Response shape
+
+`'ok'` (write mode) carries `{ status, dialect, migration_path }`; `'ok'` (explain mode) carries `{ status, dialect, statements, hints }`. `'no_changes'`, `'missing_hints'`, and `'error'` are shared across operations. Full envelope shapes, exit-code mapping, and per-code error metadata live in the `drizzle-responses-and-errors` skill's response-envelope section.
+
+`'missing_hints'` (exit 2) means the diff is ambiguous or unsafe — the resolution loop lives in the `drizzle-hints` skill. The most common error codes for `generate` are `config_validation_error`, `config_file_not_found_error`, `schema_files_not_found_error`, `orm_version_error`, `invalid_hints`, `unsupported_schema_change`, `internal_error`.
+
+## Dialect notes
+
+Per-dialect quirks (postgresql, mysql, sqlite, mssql, cockroach, singlestore) — the same diff engine and dialect surface drives both `generate` and `push`, so the notes are shared. See the `drizzle-migrations` skill's dialect-notes section.
+
+## Examples
+
+```bash
+# Happy path
+drizzle-kit generate --output json --config drizzle.config.ts
+# → {"status":"ok","dialect":"postgresql","migration_path":"drizzle/0001_init/migration.sql"}
+
+# Idempotent re-run on an up-to-date schema
+drizzle-kit generate --output json --config drizzle.config.ts
+# → {"status":"no_changes","dialect":"postgresql"}
+
+# Ambiguous diff — caller must supply hints and retry
+drizzle-kit generate --output json --config drizzle.config.ts
+# → {"status":"missing_hints","unresolved":[{"type":"rename_or_create","kind":"column","entity":["public","users","email_v2"]}]}
+# (resolution loop: see the drizzle-hints skill)
+
+# Hard error
+drizzle-kit generate --output json --config missing.ts
+# → {"status":"error","error":{"code":"config_file_not_found_error","path":"missing.ts"}}
+```
+
+SDK equivalent of the happy path:
+
+```typescript
+import { generate } from 'drizzle-kit';
+
+const r = await generate({ dialect: 'postgresql', schema: './src/db/schema.ts', out: './drizzle' });
+if (r.status === 'ok') console.log(r.migration_path);
+```
diff --git a/drizzle-kit/skills/drizzle-hints/SKILL.md b/drizzle-kit/skills/drizzle-hints/SKILL.md
new file mode 100644
index 0000000000..a0147f86d7
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-hints/SKILL.md
@@ -0,0 +1,181 @@
+---
+name: drizzle-hints
+description: Resolve `missing_hints` responses from drizzle-kit `generate` or `push` — covers rename-vs-create disambiguation, `confirm_data_loss` approvals, and the `Hint` reply array shape for the retry. Load whenever drizzle-kit output shows `missing_hints` status, prompts to confirm a rename or destructive change, or the next step is constructing a `hints` array for a retry call.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle hints
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+`status: 'missing_hints'` means the diff is ambiguous (a rename could also be a drop + create) or unsafe (would drop a non-empty entity, or would recreate a SQLite table and wipe its rows). Until hints are supplied the operation cannot proceed — the CLI exits `2`, the SDK returns the envelope without writing or applying anything.
+
+Under `--output text` + non-TTY the same unresolved decisions surface as the human-readable missing-decisions report on stdout (also exit code 2) rather than this envelope — the `drizzle-output-modes` skill covers the text-report shape.
+
+Resolution is one round trip: read each item in `unresolved`, build one reply `Hint` per item, re-invoke the same command with the array. Both the missing-hints request shape and the reply shape are typed and validated by the runtime — wrong arity, wrong spelling, or wrong reply discriminator returns `status: 'error'` with `error.code: 'invalid_hints'`. See the `drizzle-responses-and-errors` skill for that branch.
+
+## Reply types
+
+A reply is an array of `Hint`. Each `Hint` is one of these three shapes:
+
+```typescript
+{ type: 'rename', kind: K, from: <entity-tuple>, to: <entity-tuple> }   // resolves a rename_or_create AS a rename
+{ type: 'create', kind: K, entity: <entity-tuple> }                     // resolves a rename_or_create AS a create
+{ type: 'confirm_data_loss', kind: K, entity: <entity-tuple> }          // approves a destructive change
+```
+
+The `confirm_data_loss` reply omits the `reason` and `reason_details` keys that the request carries — those are runtime-only metadata used to explain why the prompt fired. The reply only needs `type`, `kind`, and `entity`.
+
+Each unresolved item maps to exactly one reply:
+
+| unresolved item type | reply type |
+|----------------------|------------|
+| `'rename_or_create'` | `'rename'` (pick a deleted entity of the same kind to be the `from`) OR `'create'` |
+| `'confirm_data_loss'` | `'confirm_data_loss'` (same `kind` + `entity`) |
+
+## Rename-vs-create kinds
+
+The `kind` literal in the reply must match the literal in the unresolved item exactly. Note that `foreign key` carries a single space — it is the one remaining non-snake_case literal in the union.
+
+| kind | entity-tuple arity | dialect availability |
+|---|---|---|
+| `schema` | `[name]` | postgresql, cockroach, mssql |
+| `role` | `[name]` | postgresql, cockroach |
+| `table` | `[schema, name]` | all |
+| `enum` | `[schema, name]` | postgresql, cockroach |
+| `sequence` | `[schema, name]` | postgresql, cockroach |
+| `view` | `[schema, name]` | all |
+| `column` | `[schema, table, name]` | all |
+| `default` | `[schema, table, name]` | all |
+| `policy` | `[schema, table, name]` | postgresql, cockroach |
+| `check` | `[schema, table, name]` | all |
+| `index` | `[schema, table, name]` | all |
+| `unique` | `[schema, table, name]` | all |
+| `primary_key` | `[schema, table, name]` | all |
+| `foreign key` | `[schema, table, name]` | all |
+| `privilege` | `[grantor, grantee, schema, table, type]` | postgresql, cockroach |
+
+The runtime only emits unresolved items for kinds that exist on the target dialect, so the dialect-availability column is informational — an agent that just echoes whatever shows up in `unresolved` never sees a kind that doesn't apply. For `rename`, both `from` and `to` are entity tuples of the same arity (the `from` is a deleted entity of the same kind that the new one is being matched against). For `create`, only `entity` is set.
+
+## Confirm-data-loss kinds
+
+Confirm-data-loss replies carry `type`, `kind`, and `entity` only — the `reason` and `reason_details` fields the request carries are runtime-only metadata and are dropped from the reply.
+
+| kind | entity-tuple arity | dialect availability |
+|---|---|---|
+| `schema` | `[name]` | postgresql, cockroach, mssql |
+| `table` | `[schema, name]` | all |
+| `view` | `[schema, name]` | postgresql, cockroach (materialized views only) |
+| `column` | `[schema, table, name]` | all |
+| `primary_key` | `[schema, table, name]` | all except sqlite / turso |
+| `add_not_null` | `[schema, table, name]` | sqlite / turso only |
+
+`add_not_null` is the only confirmation-triggering constraint addition, and it fires only on sqlite / turso. The server dialects (postgresql, mysql, mssql, cockroach, singlestore) add `NOT NULL` / `UNIQUE` constraints without triggering a confirmation request — the `ALTER` runs and the database enforces the constraint, rejecting a genuine violation cleanly — so neither `add_not_null` nor `add_unique` surfaces as a `confirm_data_loss` on those dialects.
+
+## Reasons
+
+The unresolved item for a `confirm_data_loss` carries a `reason` (and, for `type_change`, a `reason_details`). The reply does not carry the reason — it carries only `type`, `kind`, `entity`.
+
+| reason | applicable kinds | meaning | reason_details |
+|--------|------------------|---------|----------------|
+| `non_empty` | `table`, `column`, `schema`, `view`, `primary_key` | Target entity has ≥1 row; drop will lose data | — |
+| `table_recreate` | `add_not_null` (sqlite / turso only) | Adding the `NOT NULL` column has no in-place path on SQLite, so confirming wipes all rows and recreates the table | — |
+| `type_change` | `column` | Existing column SQL type changes (e.g. mysql / singlestore `ALTER COLUMN`) | `{ from: string, to: string }` |
+
+## Resolution loop
+
+1. **Invoke.** Run `drizzle-kit generate --output json` / `push --output json` (CLI) or `await generate(...)` / `await push(...)` (SDK).
+2. **Read the envelope.** If `status === 'missing_hints'`, the response carries `unresolved: MissingHint[]`. Each item has a `type` of `'rename_or_create'` or `'confirm_data_loss'`.
+3. **Build the reply.** For every `unresolved[i]`, append exactly one `Hint` to the reply array:
+   - `rename_or_create` → pick `rename` (provide `from` as a deleted entity of the same `kind`) OR `create` (just echo `entity`).
+   - `confirm_data_loss` → echo the same `kind` and `entity`; drop `reason` and `reason_details`.
+4. **Re-invoke** the same command, passing the reply array via the CLI flag or the SDK option (see below). Repeat from step 2 if more hints surface.
+
+The reply must cover every item in `unresolved` — partial replies that still leave ambiguities return `missing_hints` again with the still-unresolved items.
+
+## CLI form
+
+Pass the reply array as JSON via one of two flags on `generate` or `push`:
+
+- `--hints '<json>'` — inline JSON array of `Hint` objects. Watch shell quoting; the JSON has to survive your shell intact.
+- `--hints-file ./hints.json` — same JSON array read from a file. Preferred for arrays of more than one or two items.
+
+```bash
+drizzle-kit push --output json --config drizzle.config.ts --hints-file ./hints.json
+```
+
+`--hints` and `--hints-file` are mutually exclusive at the source level — pass one or the other, not both. A malformed JSON file or a hint that fails shape validation returns `status: 'error'` with `error.code: 'invalid_hints'` and `meta.source: 'file' | 'inline'`.
+
+## SDK form
+
+Pass the reply array as a raw `Hint[]` via the `hints` option to `generate` / `push` (or use `hintsFile` with a file path instead):
+
+```typescript
+import { generate, push } from 'drizzle-kit';
+
+const r1 = await generate({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  hints: [
+    { type: 'rename', kind: 'column', from: ['public', 'users', 'email'], to: ['public', 'users', 'email_v2'] },
+  ],
+});
+
+const r2 = await push({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  url: process.env.DATABASE_URL!,
+  hints: [
+    { type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy_id'] },
+  ],
+});
+```
+
+The SDK and CLI consume the exact same `Hint` shape — anything that validates against `--hints-file` validates against `hints:` and vice versa.
+
+## Worked example
+
+A first invocation against a SQLite database returns two ambiguities — one rename-or-create, one confirm-data-loss:
+
+```json
+{
+  "status": "missing_hints",
+  "unresolved": [
+    { "type": "rename_or_create", "kind": "column",
+      "entity": ["public", "users", "email_v2"] },
+    { "type": "confirm_data_loss", "kind": "add_not_null",
+      "entity": ["public", "users", "handle"],
+      "reason": "table_recreate" }
+  ]
+}
+```
+
+The `table_recreate` reason fires because SQLite has no in-place way to add a `NOT NULL` column — confirming it recreates the `users` table and wipes its rows. The reply resolves the rename-or-create as a rename of `email` → `email_v2`, and approves the `NOT NULL` addition:
+
+```json
+[
+  { "type": "rename", "kind": "column",
+    "from": ["public", "users", "email"],
+    "to":   ["public", "users", "email_v2"] },
+  { "type": "confirm_data_loss", "kind": "add_not_null",
+    "entity": ["public", "users", "handle"] }
+]
+```
+
+Re-invoke with this array via `--hints-file ./hints.json` (CLI) or `hints: [...]` (SDK). The successful retry returns `status: 'ok'` (with `migration_path` for `generate`, or just `dialect` for `push`).
+
+### Privilege 5-tuple rename
+
+`privilege` is the only kind whose entity tuple has five slots: `[grantor, grantee, schema, table, type]`. Renaming the underlying table renames each privilege grant against it:
+
+```json
+{ "type": "rename", "kind": "privilege",
+  "from": ["app_owner", "analytics_role", "public", "orders", "SELECT"],
+  "to":   ["app_owner", "analytics_role", "public", "orders_v2", "SELECT"] }
+```
+
+## Schema-namespace placeholder
+
+Every entity tuple leads with a namespace segment so its arity is uniform across dialects, but only postgresql, cockroach, and mssql have a real schema namespace — the `schema` entity kind is wired for those three dialects only. On the schemaless dialects (mysql, sqlite, singlestore) that leading segment is a synthesized `'public'` placeholder, not a real schema. Echo whatever the unresolved item carries in that slot verbatim; on a schemaless dialect it is filler — never build a separate `schema` rename or create from it.
diff --git a/drizzle-kit/skills/drizzle-migrations/SKILL.md b/drizzle-kit/skills/drizzle-migrations/SKILL.md
new file mode 100644
index 0000000000..417e4d90e4
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-migrations/SKILL.md
@@ -0,0 +1,88 @@
+---
+name: drizzle-migrations
+description: Orient to the drizzle-kit migration workflow — `defineConfig`, `generate` vs `push`, and per-dialect quirks across postgresql, mysql, sqlite, mssql, cockroach, and singlestore. Load whenever drizzle migrations are being set up or modified, `drizzle.config.ts` is being read or edited, the generate-vs-push choice is being made, or any Drizzle schema file has just been edited.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle migrations
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+Entry-point skill for the drizzle-kit migration workflow. Three responsibilities live here: the `defineConfig` reference, the `generate` vs `push` comparison, and the per-dialect quirks catalog. Invocation details (CLI form, SDK form, response shapes) live in the operation skills.
+
+## Configuration
+
+`defineConfig` is the type-safe entry point. The same object shape is used by both the CLI (loaded automatically from `drizzle.config.ts`) and the SDK (passed inline to `generate` / `push`).
+
+Required fields:
+
+- **`dialect`** — one of `postgresql`, `mysql`, `sqlite`, `turso`, `mssql`, `cockroach`, `singlestore`. For Turso / libsql set `dialect: 'turso'` (with the `@libsql/client` or `@tursodatabase/serverless` driver) — it is a first-class dialect value, not a `sqlite` alias.
+- **`schema`** — path or path-glob to the schema file(s). Examples: `'./src/db/schema.ts'`, `['./src/db/**/*.ts']`.
+- **`out`** — directory where `generate` writes `.sql` migration files. Conventional: `'./drizzle'`.
+- **`dbCredentials`** — per-dialect credential shape. Required for `push` (which connects to a live database) and for the introspect side of some `generate` codepaths. Either a `url` field or a structured object (`{ host, port, user, password, database }`-style); the exact shape varies by dialect. Use environment variables — never hard-code secrets.
+
+Minimal example (postgresql):
+
+```typescript
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: './drizzle',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+## Generate vs push
+
+- **`generate`** — file-based. Computes the diff, writes a `.sql` file under `out`, and exits. The agent (or a human, or CI) reviews the SQL and applies it later via the driver's migrate runner. Safest for production. Pairs naturally with code-review workflows. Load the `drizzle-generate` skill for invocation details.
+- **`push`** — direct application. Computes the diff and executes the DDL against the live database immediately. No migration file. Fastest feedback loop during development. In production, destructive changes (dropping a non-empty entity, changing a column's SQL type, or recreating a SQLite table to add a `NOT NULL` column) return `status: 'missing_hints'` and require explicit approval via the `drizzle-hints` resolution loop before they apply. Load the `drizzle-push` skill for invocation details.
+
+Choose `generate` for production releases and review workflows; choose `push` for rapid local iteration. Both operations share one JSON envelope (decoded by the `drizzle-responses-and-errors` skill) and one hint vocabulary.
+
+To go the other direction — introspect an existing database into a Drizzle schema instead of driving the database from a schema — see the `drizzle-pull` skill.
+
+## Dialect notes
+
+The diff engine and dialect surface are shared by `generate` and `push`, so the per-dialect quirks below apply uniformly to both operations.
+
+- `postgresql` — full surface: schemas, enums, sequences, views, policies, roles, privileges. `confirm_data_loss` on `view` fires only for materialized views (regular views drop silently). `serial` / `bigserial` columns auto-create their sequences with no `confirm_data_loss` prompt.
+- `mysql` — `confirm_data_loss` with `reason: 'type_change'` fires on any `ALTER COLUMN` whose dialect-native type would change; `reason_details` carries `{ from, to }` with dialect-native spellings. `unsupported_schema_change/drop_pk_dependency` blocks `DROP PRIMARY KEY` when foreign keys reference the dropped columns and no covering UNIQUE exists. `unsupported_schema_change/fk_target_not_unique` blocks `CREATE FOREIGN KEY` when the referenced columns are not unique. No `schema` / `enum` / `sequence` / `policy` / `role` / `privilege` kinds.
+- `sqlite` — table-rebuild semantics: most ALTERs emit `recreate_table` statements (copy-into-new-table, swap, drop-old). `confirm_data_loss/add_not_null` issues a `DELETE` to truncate nulls before the rebuild — approve only when row loss is acceptable. No `primary_key` / `add_unique` `confirm_data_loss` kinds. `turso` (libsql) shares the sqlite handler over the libsql driver.
+- `mssql` — `unsupported_schema_change/rename_blocked_by_check_constraint` fires when `sp_rename` would fail because the column is referenced by a `CHECK` constraint; the agent must drop the constraint, rename, then recreate. `unsupported_schema_change/rename_schema_unsupported` is unconditional — MSSQL has no schema rename. `schema` kind is available for create / drop.
+- `cockroach` — postgres-family; surface largely mirrors `postgresql`. Materialized-view drops are the only `confirm_data_loss/view` trigger. Distributed-schema notes surface in `--explain` mode.
+- `singlestore` — inherits the MySQL handler shape. Same `unsupported_schema_change` variants apply (`drop_pk_dependency`, `fk_target_not_unique`). No `schema` / `enum` / `sequence` / `policy` / `role` / `privilege` kinds.
+
+## Collapsing snapshot diffs in code review
+
+Every migration `generate` writes carries a machine-generated `meta/<n>_snapshot.json` alongside the `.sql` — the full schema state, regenerated wholesale on each migration. Reviewers want to read the SQL, not the snapshot churn, so keep these generated files out of code-review noise through `.gitattributes`. This is PR-review hygiene, not a drizzle-kit command.
+
+Target only the snapshot glob `drizzle/**/meta/*_snapshot.json`. It mirrors the configured `out` dir: the default is `drizzle/`, so an `out: 'migrations'` project uses `migrations/**/meta/*_snapshot.json` instead — adjust the leading directory to match `out`. Scope the glob to `*_snapshot.json` only; do not broaden to `meta/*`, because the sibling `meta/_journal.json` is small and human-meaningful and is intentionally not a collapse target.
+
+Per platform:
+
+- **GitHub** — mark the snapshots as generated so Linguist collapses them by default (reviewers can still expand):
+
+  ```gitattributes
+  drizzle/**/meta/*_snapshot.json linguist-generated=true
+  ```
+
+  Linguist auto-detects many generated files by filename and content heuristics, but `*_snapshot.json` is not on that list, so the explicit attribute is required.
+
+- **GitLab** — collapse via the `gitlab-generated` attribute (GA on 16.11+, no feature flag):
+
+  ```gitattributes
+  drizzle/**/meta/*_snapshot.json gitlab-generated
+  ```
+
+- **Bitbucket and Gerrit** — neither has a native generated-file collapse mechanism, and neither honors `linguist-generated` or `gitlab-generated`; there is no path-based auto-collapse in their web review UIs. The closest git-native lever is the `-diff` attribute:
+
+  ```gitattributes
+  drizzle/**/meta/*_snapshot.json -diff
+  ```
+
+  Be honest about what `-diff` does: it tells git to treat the path as non-text, so `git diff` prints "Binary files differ" instead of the textual hunk (and renders as a suppressed/binary diff on GitHub and GitLab too). But it does NOT collapse the file in the Bitbucket or Gerrit web review UIs — the snapshot still appears in the changed-files list, just without a readable diff — and it removes a diff that is locally useful, since the snapshot is real JSON. Treat `-diff` as a deliberate tradeoff for those platforms, not a blanket recommendation.
diff --git a/drizzle-kit/skills/drizzle-output-modes/SKILL.md b/drizzle-kit/skills/drizzle-output-modes/SKILL.md
new file mode 100644
index 0000000000..21a83c04e3
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-output-modes/SKILL.md
@@ -0,0 +1,51 @@
+---
+name: drizzle-output-modes
+description: "Choose and interpret drizzle-kit `--output text` vs `--output json`, reason about interactivity in non-TTY contexts, and read the human-readable missing-decisions text report. Load when deciding which `--output` mode to pass, when a drizzle-kit run in a non-TTY context needs to stay non-interactive, or when parsing a `missing_hints: N unresolved decisions` text report."
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle output modes
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+Drizzle Kit `generate` / `push` / `check` render results in one of two output modes, selected with `--output`. Output format and interactivity are separate axes: the output mode controls *how* results are rendered; interactivity controls *whether* the CLI may prompt.
+
+- `--output text` (the default) renders human-readable progress and results on stdout, with typed errors on stderr. When a command has unresolved decisions and cannot prompt, it writes the missing-decisions report (below) to stdout and exits with code 2.
+- `--output json` emits a single machine-readable JSON envelope on stdout for every status (including errors), and is always non-interactive.
+
+`check --output json` rides the same plumbing: it is a no-hint, non-interactive gate that emits an `ok` envelope when the migrations folder is valid and a `check_error` envelope for snapshot-integrity problems or unreported branch conflicts. It never reaches the missing-decisions path. The `drizzle-responses-and-errors` skill decodes the `check_error` envelope.
+
+## Interactivity
+
+A command is interactive only when it is rendering text **and** stdin is a TTY:
+
+```
+interactive = output === 'text' && !!process.stdin.isTTY
+```
+
+`--output json` is therefore always non-interactive, regardless of whether stdin is a TTY. Under `--output text`, interactivity is determined solely by whether stdin is a TTY (`!process.stdin.isTTY` means non-interactive).
+
+When the CLI is non-interactive and reaches a decision it cannot resolve from your `--hints` / `--hints-file`, it does not prompt. Under `--output json` it returns a `missing_hints` envelope; under `--output text` it prints the missing-decisions report below. The `drizzle-hints` skill covers building the reply that resolves those decisions.
+
+## Missing-decisions text report
+
+Under `--output text`, when the CLI is non-interactive (stdin is not a TTY) and at least one decision is still unresolved, it prints a human-readable report to stdout and exits with code 2. `rename_or_create` decisions are listed first (discovery order), then `confirm_data_loss` decisions (discovery order), with a continuous 1-based index across both groups. Each item shows an `Add to --hints:` block with the snippet(s) to supply; `rename_or_create` items show both a `rename` and a `create` snippet joined by `OR`.
+
+The `from` placeholders are intentionally invalid JSON — replace the angle-bracket segments with the real identifier of the entity being renamed before re-running. The report only suggests the inline `--hints '<json-array>'` form, never `--hints-file`. A two-item run renders like this:
+
+```
+missing_hints: 2 unresolved decisions
+
+1. Rename or create  —  table  public.users_v2
+   Add to --hints:
+     { "type": "rename", "kind": "table", "from": ["<schema>", "<old_name>"], "to": ["public", "users_v2"] }
+     OR
+     { "type": "create", "kind": "table", "entity": ["public", "users_v2"] }
+
+2. Confirm data loss  —  table  public.legacy_audit  (reason: non_empty)
+   Add to --hints:
+     { "type": "confirm_data_loss", "kind": "table", "entity": ["public", "legacy_audit"] }
+
+Re-run with --hints '<json-array>'. Exit code 2.
+```
diff --git a/drizzle-kit/skills/drizzle-pull/SKILL.md b/drizzle-kit/skills/drizzle-pull/SKILL.md
new file mode 100644
index 0000000000..c6b7dc8612
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-pull/SKILL.md
@@ -0,0 +1,108 @@
+---
+name: drizzle-pull
+description: Introspect an existing database into a Drizzle schema — the reverse of generate and push, which drive a database from a schema. Load whenever the task is to generate a Drizzle schema from a live database, reverse-engineer or import an existing database, or decode the result manifest or a connect/introspect failure from a pull.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle pull
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+Pull introspects an existing database and writes a Drizzle schema from it: it connects, reads the live DDL, and emits `schema.ts`, a `relations.ts` (for the dialects that have one), and a snapshot under the configured `out` dir. It is the inverse of `generate` / `push` — those start from a schema and drive the database; pull starts from the database and writes the schema. The `drizzle-migrations` skill covers where pull sits in the overall workflow. Output format and interactivity are separate axes the same way they are for the other verbs — the `drizzle-output-modes` skill covers the text-vs-json choice — and `drizzle-responses-and-errors` decodes the envelope shapes below.
+
+## CLI form
+
+```bash
+drizzle-kit pull --output json [--config drizzle.config.ts] [--dialect <d>] [--out <dir>] [--breakpoints] [--casing camel|preserve] [--init]
+```
+
+Flag surface:
+
+- `--config` — path to `drizzle.config.ts` (default: `drizzle.config.ts` at CWD). Pull reads `dbCredentials` from the config; there is no CLI flag for the credentials object as a whole.
+- `--dialect`, `--out` — override the corresponding `defineConfig` fields. `--out` is where `schema.ts` / `relations.ts` / the snapshot are written.
+- `--url` / `--host` / `--port` / `--user` / `--password` / `--database` / `--ssl` / `--auth-token` — direct connection overrides for the corresponding `dbCredentials` fields. Most projects set these in the config file instead.
+- `--breakpoints` — emit statement-breakpoint markers in any generated migration SQL.
+- `--casing camel|preserve` — how introspected identifiers are cased in the emitted schema (`camel` camel-cases columns; `preserve` keeps the database spelling).
+- `--output json` — switches stdout to one JSON line carrying the envelope and is always non-interactive. Use it for agent / CI / scripted contexts. Under the default `--output text` pull prints human-readable progress and the result.
+- `--init` — also run the initial migration against the live database. This is a destructive write (see the `--init` note below); it adds `migrationPath` to the ok manifest.
+
+Minimal example — `drizzle.config.ts` carries the credentials, the CLI invocation is just the verb:
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  dialect: 'postgresql',
+  out: './drizzle',
+  dbCredentials: { url: process.env.DATABASE_URL! },
+});
+```
+
+```bash
+drizzle-kit pull --output json --config drizzle.config.ts
+# → {"status":"ok","dialect":"postgresql","schemaPath":"drizzle/schema.ts","relationsPath":"drizzle/relations.ts","snapshotPath":"drizzle/meta/0000_snapshot.json"}
+```
+
+The process exits with the code that matches `status` (`0` for ok, `1` for error). Agents read both stdout (the envelope) and the exit code.
+
+## SDK form
+
+```typescript
+import { pull } from 'drizzle-kit';
+
+const response = await pull({
+  dialect: 'postgresql',
+  out: './drizzle',
+  url: process.env.DATABASE_URL!,
+});
+
+if (response.status === 'ok') {
+  // introspection succeeded; the manifest names the written files:
+  //   response.schemaPath    — always present
+  //   response.snapshotPath  — always present
+  //   response.relationsPath — present except mssql (no relations file)
+  //   response.migrationPath — present only when called with init: true
+} else {
+  // response.status === 'error'
+  // response.error.code identifies the failure, e.g. database_driver_error
+  // (connect/introspect/init failures are credential-redacted) — decode it
+  // with the drizzle-responses-and-errors skill
+}
+```
+
+`pull` is a real root SDK function. It always runs in JSON mode internally — no `--output json` flag needed at the call site — and returns the same envelope the CLI prints. In SDK form the credential fields are passed flat on the call (`url`, or the broken-out `host` / `port` / `user` / `password` / `database` set); pass `init: true` to also run the initial migration. The status is `ok` or `error` only — there is no `no_changes` branch and no `missing_hints` branch (see Contract below).
+
+## Response shape
+
+The `'ok'` envelope is a paths-manifest — it names the files pull wrote, not the introspected DDL:
+
+```jsonc
+// postgres / mysql / sqlite / turso / cockroach / singlestore — relationsPath present
+{ "status": "ok", "dialect": "postgresql", "schemaPath": "drizzle/schema.ts", "relationsPath": "drizzle/relations.ts", "snapshotPath": "drizzle/meta/0000_snapshot.json" }
+
+// mssql — relationsPath omitted (no relations file is generated)
+{ "status": "ok", "dialect": "mssql", "schemaPath": "drizzle/schema.ts", "snapshotPath": "drizzle/meta/0000_snapshot.json" }
+
+// with init: true — an initial migration was also written, so migrationPath appears
+{ "status": "ok", "dialect": "postgresql", "schemaPath": "drizzle/schema.ts", "relationsPath": "drizzle/relations.ts", "snapshotPath": "drizzle/meta/0000_snapshot.json", "migrationPath": "drizzle/0000_init/migration.sql" }
+```
+
+So the manifest is `{ schemaPath, snapshotPath, relationsPath?, migrationPath? }`: `schemaPath` and `snapshotPath` are always present; `relationsPath?` is optional and omitted for mssql; `migrationPath?` is optional and present only with `--init`. The envelope carries no inline DDL array.
+
+The `'error'` envelope, when the driver cannot connect or introspection fails:
+
+```json
+{ "status": "error", "error": { "code": "database_driver_error", "database": "postgresql", "packages": ["pg", "postgres"], "note": "<optional connection hint>" } }
+```
+
+`database_driver_error` carries only `database`, `packages`, and an optional `note` — the connection string, sql, and params are deliberately kept out of the envelope, so no credential substring ever reaches stdout. The `drizzle-responses-and-errors` skill decodes this and the other error codes. Example payloads here use placeholder paths and dialects only — never a real connection string, url, or password.
+
+## Contract
+
+Pull is ok/error only. It never emits `missing_hints`: it introspects against an empty starting DDL, constructs no hints handler, and exposes no consent surface — there are no ambiguous renames or destructive-change prompts to resolve. The only outcomes are `ok` (the manifest is returned) or a thrown typed error surfaced as the `error` envelope.
+
+## --init
+
+`--init` (CLI) / `init: true` (SDK) runs the initial migration against the live database in addition to writing the schema. That is a destructive write — it executes DDL against the connected database, not just disk — and on success it adds `migrationPath` to the ok manifest. The MCP `pull` tool surfaces this `init` escalation as a per-call destructive signal on its result; the `drizzle-responses-and-errors` skill carries the canonical shape of that signal.
diff --git a/drizzle-kit/skills/drizzle-push/SKILL.md b/drizzle-kit/skills/drizzle-push/SKILL.md
new file mode 100644
index 0000000000..c05d1405a0
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-push/SKILL.md
@@ -0,0 +1,159 @@
+---
+name: drizzle-push
+description: Apply drizzle schema changes directly to a live database without writing a migration file. Load before running `drizzle-kit push` or calling the `push(...)` SDK, when syncing a Drizzle schema directly to a live DB (prototyping, dev resets, ephemeral test databases), or when the task is to push, sync, apply, or deploy a schema.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle push
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+The CLI flag `--output json` and the SDK `push(...)` function emit the same discriminated-union envelope, and the envelope (not the stdout text) is what the agent decodes. Output format and interactivity are separate axes: `--output json` selects the machine-readable envelope and is always non-interactive, so pass it whenever an agent calls the CLI. Under the default `--output text` the CLI prompts only when stdin is a TTY; in a non-TTY it prints the missing-decisions report and exits 2 (it never hangs prompting). See the `drizzle-output-modes` skill for the two modes and the interactivity rule. The SDK runs in JSON mode internally with no flag needed at the call site. Push is the live-DB counterpart to `generate`: `generate` is offline and writes a migration SQL file to disk, `push` connects to the database and executes the diff against it. The `drizzle-generate` skill covers the offline path; the `drizzle-migrations` skill covers the day-to-day workflow that combines them.
+
+## CLI form
+
+```bash
+drizzle-kit push --output json [--config drizzle.config.ts] [--dialect <d>] [--schema <path>] [--explain] [--hints '<json>' | --hints-file ./hints.json]
+```
+
+Flag surface:
+
+- `--config` — path to `drizzle.config.ts` (default: `drizzle.config.ts` at CWD). Push reads `dbCredentials` from the config; there is no CLI flag for the credentials object as a whole.
+- `--dialect`, `--schema` — override the corresponding `defineConfig` fields.
+- `--output json` — switches stdout to one JSON line carrying the envelope and is always non-interactive. Use it for agent / CI / scripted contexts. Under the default `--output text` the CLI prompts only on a TTY and otherwise prints the missing-decisions report (exit 2).
+- `--explain` — dry-run mode. Returns planned SQL statements and computed hints instead of executing them against the database.
+- `--hints` — inline JSON array of hint resolutions (see the `drizzle-hints` skill).
+- `--hints-file` — same payload as `--hints`, read from a JSON file. Use for long hint sets.
+- `--url` / `--host` / `--port` / `--user` / `--password` / `--database` / `--ssl` / `--auth-token` — direct connection-string overrides for the corresponding `dbCredentials` fields. Most projects set these in the config file instead.
+
+Minimal example — `drizzle.config.ts` carries the credentials, the CLI invocation is just the verb:
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  dbCredentials: { url: process.env.DATABASE_URL! },
+});
+```
+
+```bash
+drizzle-kit push --output json --config drizzle.config.ts
+# → {"status":"ok","dialect":"postgresql"}
+```
+
+The process exits with the code that matches `status` (see Response envelope below). Agents read both stdout (the envelope) and the exit code.
+
+## SDK form
+
+```typescript
+import { push } from 'drizzle-kit';
+
+const response = await push({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  url: process.env.DATABASE_URL!,
+});
+
+if (response.status === 'ok') {
+  // schema applied to the live database
+} else if (response.status === 'no_changes') {
+  // live DB already matches the schema — nothing executed
+} else if (response.status === 'missing_hints') {
+  // response.unresolved lists ambiguities or destructive ops — see the drizzle-hints skill
+} else if (response.status === 'error') {
+  // response.error.code identifies the failure — see drizzle-responses-and-errors
+}
+```
+
+The SDK is the public-surface entry point. It always runs in JSON mode internally — no `--output json` flag needed at the call site — and returns the same envelope the CLI prints. In SDK form the credential fields are passed flat on the call (`url`, or the broken-out `host`/`port`/`user`/`password`/`database` set) — there is no `dbCredentials` wrapper and no `drizzle.config.ts` file is required. Narrow on `response.status` to extract typed branches:
+
+- `'ok'` → `response.dialect` (plus `response.statements`, `response.hints` in explain mode).
+- `'no_changes'` → `response.dialect`.
+- `'missing_hints'` → `response.unresolved` (array of items).
+- `'error'` → `response.error.code` plus per-code metadata.
+
+The SDK does not throw on user-level failures — every outcome flows through the envelope. Unexpected runtime exceptions are wrapped as `status: 'error'` with `code: 'internal_error'`.
+
+## Response shape
+
+Push's `'ok'` envelope is `{ status, dialect }` — no `migration_path`, since push executes the diff against the live DB rather than writing a file. `'ok'` (explain) carries `{ status, dialect, statements, hints }`. `'no_changes'`, `'missing_hints'`, and `'error'` are shared across operations. Full envelope shapes, exit-code mapping, and per-code error metadata live in the `drizzle-responses-and-errors` skill's response-envelope section.
+
+`'missing_hints'` (exit 2) means the diff is ambiguous or unsafe — the resolution loop lives in the `drizzle-hints` skill. The most common error codes for `push` are `config_validation_error`, `config_connection_error`, `database_driver_error`, `query_error`, `unsupported_schema_change`, `invalid_hints`, `required_packages_error`, `internal_error`.
+
+## Connection
+
+Push requires a live database connection. In `drizzle.config.ts` (CLI form) the credentials nest under a `dbCredentials` object; in SDK form the same fields are passed flat on the `push(...)` call — no `dbCredentials` wrapper. The shape varies per dialect; common fields are `url` (preferred when the driver supports it) or the broken-out `host` / `port` / `user` / `password` / `database` set, plus `ssl` for TLS and `authToken` for turso/libsql. The per-dialect shapes below show the config (`dbCredentials`) form; in the SDK, drop the wrapper and pass these fields directly on the call.
+
+```typescript
+// postgresql / cockroach
+dbCredentials: { url: process.env.DATABASE_URL! }
+// or: { host, port, user, password, database, ssl }
+
+// mysql / singlestore
+dbCredentials: { url: process.env.DATABASE_URL! }
+// or: { host, port, user, password, database }
+
+// sqlite
+dbCredentials: { url: 'file:./local.db' }
+
+// turso (libsql)
+dbCredentials: { url: process.env.TURSO_URL!, authToken: process.env.TURSO_AUTH_TOKEN }
+
+// mssql
+dbCredentials: { url: process.env.MSSQL_URL! }
+// or: { server, port, user, password, database }
+```
+
+Secrets belong in environment variables (`process.env.DATABASE_URL`, etc.) — `drizzle.config.ts` typically ships with the repo, so hard-coded credentials leak through source control once committed. When credentials are absent or malformed, push returns `status: 'error'` with `code: 'config_connection_error'`; when the driver itself fails to connect (wrong host, bad TLS, server down), `code: 'database_driver_error'`. The `drizzle-responses-and-errors` skill decodes both.
+
+## Destructive changes
+
+When push would drop a non-empty table, column, schema, or view, drop a primary key, change a column's SQL type, or recreate a SQLite table to add a `NOT NULL` column (which wipes its rows), it does not execute. Instead it returns `status: 'missing_hints'` with `unresolved` items of `type: 'confirm_data_loss'`. The agent must approve each item with a matching `Hint` and re-invoke.
+
+Adding `NOT NULL` or `UNIQUE` on the server dialects (postgresql, mysql, mssql, cockroach, singlestore) does not trigger a confirmation request — the `ALTER` runs and the database enforces the constraint, rejecting a genuine violation cleanly. Only SQLite's `add_not_null` is a `confirm_data_loss`, because SQLite has no in-place path to add the column and so recreates the table and deletes all rows (reason `table_recreate`).
+
+The `confirm_data_loss` kinds that fire here: `table`, `column`, `schema`, `view`, `primary_key`, and (sqlite / turso only) `add_not_null`. The reasons (`non_empty`, `table_recreate`, `type_change`) and the kinds they apply to are catalogued in the `drizzle-hints` skill's reasons section. See the `drizzle-hints` skill for the full resolution loop (parse `unresolved` → build a `Hint` per item → pass `hints` back → re-invoke).
+
+Every entity tuple leads with a namespace segment for uniform arity, but only postgresql, cockroach, and mssql have a real schema namespace (the `schema` entity kind is wired only for those three). On the schemaless dialects (mysql, sqlite, singlestore) that leading segment is a synthesized `'public'` placeholder, not a real schema — echo it verbatim; on a schemaless dialect it is filler, never build a separate `schema` rename or create from it.
+
+## Dialect notes
+
+Per-dialect quirks (postgresql, mysql, sqlite, mssql, cockroach, singlestore) — the same diff engine and dialect surface drives both `generate` and `push`, so the notes are shared. See the `drizzle-migrations` skill's dialect-notes section.
+
+## Examples
+
+```bash
+# Happy path — diff applied against the live DB
+drizzle-kit push --output json --config drizzle.config.ts
+# → {"status":"ok","dialect":"postgresql"}
+
+# Idempotent re-run — live DB already matches the schema
+drizzle-kit push --output json --config drizzle.config.ts
+# → {"status":"no_changes","dialect":"postgresql"}
+
+# Destructive change — caller must supply confirm_data_loss hints and retry
+drizzle-kit push --output json --config drizzle.config.ts
+# → {"status":"missing_hints","unresolved":[{"type":"confirm_data_loss","kind":"column","entity":["public","users","legacy_id"],"reason":"non_empty"}]}
+# (resolution loop: see the drizzle-hints skill)
+
+# Hard error — wrong credential shape for the driver
+drizzle-kit push --output json --config drizzle.config.ts
+# → {"status":"error","error":{"code":"config_connection_error","driver":"pg","params":["url"]}}
+```
+
+SDK equivalent of the happy path:
+
+```typescript
+import { push } from 'drizzle-kit';
+
+const r = await push({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  url: process.env.DATABASE_URL!,
+});
+if (r.status === 'ok') console.log('applied');
+```
diff --git a/drizzle-kit/skills/drizzle-responses-and-errors/SKILL.md b/drizzle-kit/skills/drizzle-responses-and-errors/SKILL.md
new file mode 100644
index 0000000000..59c1c90418
--- /dev/null
+++ b/drizzle-kit/skills/drizzle-responses-and-errors/SKILL.md
@@ -0,0 +1,156 @@
+---
+name: drizzle-responses-and-errors
+description: Decode the drizzle-kit response JSON envelope, error codes, and exit codes — from the CLI `--output json` output or any drizzle-kit SDK return value. Load whenever drizzle-kit output contains a non-zero exit, an error code (`config_validation_error`, `database_driver_error`, `invalid_hints`, `unsupported_schema_change`, etc.), or any drizzle-kit JSON response needs parsing or inspection.
+metadata:
+  version: "1.0.0"
+---
+
+# Drizzle responses and errors
+
+If the `drizzle` skill has not been loaded yet this session, load it first — it carries the staleness check and the MCP-vs-CLI surface-selection rule that govern every drizzle-kit invocation.
+
+Both invocation surfaces share one envelope: the CLI prints it on stdout when `--output json` is passed, and the SDK functions `generate(...)` / `push(...)` / `check(...)` return the same object. The discriminator is always `status`. Decoding logic written for one surface works on the other. This skill does not invoke commands or author schemas — see `drizzle-generate` and `drizzle-push` for invocation, `drizzle-hints` for the `missing_hints` resolution loop.
+
+## Response envelope
+
+The discriminated union (identical for CLI stdout and SDK return value):
+
+| status            | exit code | shape                                                   |
+| ----------------- | --------- | ------------------------------------------------------- |
+| `'ok'`            | 0         | `{ status, dialect, ... }` (per-operation extras below) |
+| `'no_changes'`    | 0         | `{ status, dialect }`                                   |
+| `'missing_hints'` | 2         | `{ status, unresolved: MissingHint[] }`                 |
+| `'error'`         | 1         | `{ status, error: { code, ...meta } }`                  |
+
+Per-operation extras on `'ok'`:
+
+- `generate` (write mode) — `{ status, dialect, migration_path }`
+- `push` (write mode) — `{ status, dialect }`
+- `pull` — `{ status, dialect, schemaPath, snapshotPath, relationsPath?, migrationPath? }` (`relationsPath?` omitted for mssql; `migrationPath?` only with `--init`). `pull` is ok-or-error only — never `missing_hints`, never `no_changes`.
+- `export` — `{ status, dialect, statements, warnings }` (the individual SQL statements plus rendered warnings — there is no joined `sql` field).
+- `up` — `{ status, dialect, upgraded }` (`upgraded` is the array of rewritten snapshot paths; `[]` means a no-op).
+- `--explain` (either command, non-empty diff) — `{ status, dialect, statements, hints }`
+
+`'missing_hints'` carries `unresolved`, an array of items the agent must resolve before retrying. Each item is `{ type: 'rename_or_create', kind, entity }` or `{ type: 'confirm_data_loss', kind, entity, reason, reason_details? }`. The resolution loop lives in the `drizzle-hints` skill.
+
+The table above describes `--output json`. Under `--output text` + non-TTY the same `missing_hints` information renders as the human-readable missing-decisions report on stdout, still exiting with code 2 — see the `drizzle-output-modes` skill for the text-report shape.
+
+`'error'` carries `error.code` plus `meta` keys (variable per code). The runtime serializer flattens `{ code, ...meta }` into the `error` object — `code` is always present; the remaining keys vary. The envelope is the only shape an agent observes; no other fields are surfaced.
+
+Exit code is the canonical second signal — agents spawning the CLI can branch on either the envelope or the exit code; agents using the SDK only see the envelope.
+
+## Error codes
+
+The canonical subset surfacing from `generate` and `push`. `code` is the discriminator; `meta` keys are listed alongside.
+
+| code                                | when                                                                                | meta keys                                                       |
+| ----------------------------------- | ----------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `invalid_hints`                     | hints payload could not be loaded, parsed, validated, or matched to the diff        | `source: 'file'\|'inline'`, `path?`, `issues?`, `kind?`, `from?` |
+| `unsupported_schema_change`         | the diff would emit DDL the target dialect cannot execute (see variants below)      | `kind`, plus per-variant keys                                   |
+| `check_error`                       | `check` found a snapshot-integrity problem or unreported branch conflicts (see below) | `kind: 'unsupported'\|'malformed'\|'non_latest'\|'conflicts'`, `snapshot?`, `conflicts?`, `details?` |
+| `query_error`                       | runtime SQL against the live DB threw                                               | `sql`, `params`                                                 |
+| `internal_error`                    | uncaught exception escaped the run boundary — likely a bug to report                | `message`                                                       |
+| `config_validation_error`           | `drizzle.config.ts` failed shape validation                                         | `issues?` (zod-style records)                                   |
+| `config_file_not_found_error`       | config path did not resolve to a file                                               | `path`                                                          |
+| `schema_files_not_found_error`      | schema glob(s) matched zero files                                                   | `paths`                                                         |
+| `missing_required_params_error`     | a required CLI flag or config field was absent                                      | `params`                                                        |
+| `ambiguous_params_error`            | a flag conflicts with a `defineConfig` field (or two flags collide)                 | `command`, `configOption`                                       |
+| `unsupported_command_dialect_error` | the requested command isn't valid for the chosen dialect                            | `command`, `dialect?`                                           |
+| `config_connection_error`           | `dbCredentials` shape doesn't match the chosen driver                               | `driver`, `params`, `command?`                                  |
+| `database_driver_error`             | driver-specific connect failure — usually a missing or version-mismatched package; also arises from `pull`'s connect/introspect span and its `--init` migrate span | `database`, `packages`, `note?`                                 |
+| `orm_version_error`                 | `drizzle-orm` is missing, too old, or `drizzle-kit` itself is outdated              | `kind: 'orm_missing'\|'orm_too_old'\|'kit_outdated'`            |
+| `required_packages_error`           | one or more dialect driver packages need installing                                 | `packages`                                                      |
+| `migrations_outdated_error`         | migrations folder format is outdated and needs upgrading                            | `out`                                                           |
+
+Ordering above is roughly most-likely-first from `generate` / `push`. Other codes can surface (see the live `drizzle-kit` source); the table covers the curated subset relevant to the day-to-day workflow.
+
+## Unsupported schema changes
+
+`unsupported_schema_change` is a discriminated meta union — `meta.kind` selects the variant.
+
+| meta.kind                            | dialect(s)         | meta keys                                                       |
+| ------------------------------------ | ------------------ | --------------------------------------------------------------- |
+| `drop_pk_dependency`                 | mysql, singlestore | `kind`, `table`, `columns`, `blocking_fks`                      |
+| `fk_target_not_unique`               | mysql, singlestore | `kind`, `table`, `columns`, `table_to`, `columns_to`            |
+| `rename_blocked_by_check_constraint` | mssql              | `kind`, `schema`, `table`, `from`, `to`                         |
+| `rename_schema_unsupported`          | mssql              | `kind`, `from`, `to`, `dialect: 'mssql'`                        |
+
+When fired:
+
+- `drop_pk_dependency` — `ALTER TABLE … DROP PRIMARY KEY` is rejected because a foreign key references the dropped columns and no covering UNIQUE index exists. Add a UNIQUE on those columns first, then drop.
+- `fk_target_not_unique` — `CREATE FOREIGN KEY` is rejected because the referenced columns on `table_to` are neither UNIQUE nor a PRIMARY KEY. Add a UNIQUE on `columns_to` first.
+- `rename_blocked_by_check_constraint` — `sp_rename` of `schema.table.from` is rejected because the column appears in a CHECK constraint. Drop the constraint, rename, recreate the constraint.
+- `rename_schema_unsupported` — MSSQL does not support schema rename at all. Recreate the schema and move objects manually, or keep the old schema name.
+
+## Check errors
+
+`check_error` surfaces from the `check()` SDK export and `drizzle-kit check`, returning the envelope on integrity or conflict failures exactly as the CLI does. It also surfaces from `generate` / `migrate` when their pre-flight migrations-folder gate fails. It exits with code 1 and carries a `kind` discriminator.
+
+| meta.kind     | meta keys                | when fired                                                              |
+| ------------- | ------------------------ | ---------------------------------------------------------------------- |
+| `unsupported` | `kind`, `snapshot`       | a snapshot was written by a newer drizzle-kit and cannot be read       |
+| `malformed`   | `kind`, `snapshot`       | a snapshot could not be parsed                                         |
+| `non_latest`  | `kind`, `snapshot`       | a snapshot is not at the latest internal version and must be upgraded  |
+| `conflicts`   | `kind`, `conflicts`, `details` | branches in the migrations folder do not commute (run without `--ignore-conflicts`) |
+
+For the integrity kinds, `snapshot` names the offending file. For `conflicts`, `conflicts` is the count and `details` is an array of length `conflicts`; each entry is `{ parentId, parentPath?, branches }` where `branches` is always a two-element array of `{ leafId, leafPath, statementDescription }` describing the two diverging branches off the common parent. `leafId` / `leafPath` are `null` when a branch chain is empty.
+
+## Decoding pattern (CLI + SDK)
+
+Narrow on `status` and then on `error.code`:
+
+```typescript
+import { generate } from 'drizzle-kit';
+
+const response = await generate({ dialect: 'postgresql', schema: './src/db/schema.ts', out: './drizzle' });
+
+switch (response.status) {
+  case 'ok':
+    // response.dialect is present; response.migration_path when not in explain mode
+    break;
+  case 'no_changes':
+    // response.dialect is present; nothing to do
+    break;
+  case 'missing_hints':
+    // response.unresolved holds the items to resolve (see drizzle-hints)
+    break;
+  case 'error':
+    switch (response.error.code) {
+      case 'config_file_not_found_error':
+        // response.error.path
+        break;
+      case 'invalid_hints':
+        // response.error.source, response.error.issues, etc.
+        break;
+      case 'check_error':
+        // migrations-folder pre-flight gate failed; response.error.kind, response.error.snapshot / conflicts / details
+        break;
+      // ...other codes from the table above
+    }
+    break;
+}
+```
+
+CLI equivalent — parse `stdout` as JSON, switch on `response.status` the same way. Exit codes map: `exit 0` for `ok` / `no_changes`, `exit 1` for `error`, `exit 2` for `missing_hints`.
+
+## Troubleshooting
+
+Common failure modes and their fixes — keyed by `error.code` / `meta.kind`:
+
+- `config_file_not_found_error` — `meta.path` names the missing file. Pass `--config <path>` (CLI) or point the SDK call's `configPath` at the right location; the default lookup is `drizzle.config.ts` in CWD.
+- `schema_files_not_found_error` — `meta.paths` lists the globs that resolved to nothing. Use a concrete `.ts` extension in the path, or expand the glob to cover the directory the schema lives in.
+- `config_validation_error` — `meta.issues` carries a zod-style array (`path`, `message`). Fix the named fields in `drizzle.config.ts`; the most common cause is a missing `dialect` or a `dbCredentials` block whose shape doesn't match the dialect.
+- `missing_required_params_error` — `meta.params` names the missing fields (e.g. `['dialect']`). Add them via config or CLI flag.
+- `ambiguous_params_error` — a flag and a `defineConfig` field both set the same value. Pick one source of truth — `meta.command` plus `meta.configOption` name the conflict.
+- `config_connection_error` — the `dbCredentials` keys don't match what `meta.driver` expects. `meta.params` lists the keys the driver needs. Reshape `dbCredentials` accordingly.
+- `database_driver_error` — driver could not connect. `meta.packages` lists the npm packages required for the driver; install them. `meta.note` may carry a connection-specific hint (e.g. SSL). Beyond `push`, this also fires from `pull`'s connect/introspect span and the `--init` migrate span — the meta is always the redacted `{ database, packages, note? }`; the connection string, SQL, and params are never spread into the envelope.
+- `orm_version_error` — `meta.kind` discriminates: `orm_missing` (install `drizzle-orm`), `orm_too_old` (bump `drizzle-orm`), `kit_outdated` (bump `drizzle-kit` itself).
+- `required_packages_error` — `meta.packages` lists the npm packages to install. Common for dialect drivers (`pg`, `mysql2`, `better-sqlite3`, `@libsql/client`, `mssql`).
+- `unsupported_command_dialect_error` — the command isn't supported for `meta.dialect`. Use a different command or switch dialects.
+- `migrations_outdated_error` — the migrations folder under `meta.out` uses an older snapshot format. Run `drizzle-kit up` to migrate the folder forward.
+- `invalid_hints` — discriminated by which keys are present in `meta`: `path` means a file read failed, `issues` means schema validation failed, `kind` + `from` together mean a `rename` hint's `from` tuple did not match any deleted entity. For schema-validation failures, fix the named issues; for a `from` mismatch, correct the tuple (the entity must be one the diff would otherwise delete).
+- `unsupported_schema_change` — refer to the variant table above; each variant has a specific remediation path.
+- `query_error` — the live DB threw on `meta.sql` with `meta.params`. Run the same query manually against the target DB to surface the underlying DBMS error; fix the schema or the data.
+- `internal_error` — an unexpected exception escaped. `meta.message` carries the underlying error text. File an issue if reproducible; the SDK never throws for known failures, only for genuine bugs.
+
+For `missing_hints` (status, not an error code) — see the `drizzle-hints` skill for the resolve-and-retry loop. For workflow context — when to use `generate` vs `push`, how migrations folders work — see `drizzle-migrations`.
diff --git a/drizzle-kit/skills/drizzle/SKILL.md b/drizzle-kit/skills/drizzle/SKILL.md
new file mode 100644
index 0000000000..0d5e3c014d
--- /dev/null
+++ b/drizzle-kit/skills/drizzle/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: drizzle
+description: Run a one-time staleness check against the installed `drizzle-kit` and notify the user if it ships a newer agent-skills bundle than what's embedded here. Load before reading or editing any Drizzle file (anything importing from `drizzle-orm/*`), touching `drizzle.config.ts`, invoking `drizzle-kit <command>` or using the Drizzle SDK, or handling drizzle-kit output.
+metadata:
+  revision: 12
+---
+
+# Drizzle
+
+This skill runs a one-time staleness check against the installed `drizzle-kit` binary. If `drizzle-kit` ships a newer agent-skills bundle than the revision embedded in this file (the skills currently in use), surface a single user-facing notice with the refresh command.
+
+## Staleness check
+
+Run once per session when this skill is loaded — cache the result for the rest of the conversation and do not re-run on subsequent drizzle work.
+
+Locate the working directory where `drizzle-kit` is meant to run. This is the package that owns `drizzle-kit`, which in a monorepo is often a workspace package rather than the repo root — not a bare binary on `PATH`. Use your judgment to find it. Signals you may draw on, none of them binding and none of them a fixed precedence: the current working directory, the Drizzle file being worked on, the nearest `drizzle.config.ts`, and the nearest `package.json` that declares `drizzle-kit`.
+
+Invoke `drizzle-kit` through whatever package manager the project already uses, determined at your discretion (read the lockfile, the `packageManager` field, or the running agent's environment — no fixed ordering). Use that package manager's mechanism for running an already-installed binary (for example `pnpm exec`, `yarn`, `bun x`, or `npx` without the yes flag), or run the local `node_modules/.bin/drizzle-kit` directly.
+
+The check must run the project-INSTALLED `drizzle-kit` and must NEVER use a download-latest form — not `pnpm dlx`, not `bunx`, not `npx -y`, not `yarn dlx`. Downloading latest always reports the newest revision, which would make this check structurally incapable of ever detecting staleness. This invariant overrides the discretion above: the discretion is only about HOW to locate and invoke the installed binary, never about installed-versus-latest.
+
+Run the resolved `drizzle-kit skills version` in the resolved directory, then compare. The trimmed stdout is the revision the installed `drizzle-kit` ships; this skill's own `metadata.revision` (read from this file's frontmatter when it loads) is the revision of the skills currently in use. Parse both as integers. If the revision `drizzle-kit` ships is strictly greater than this skill's own revision, the skills in use are outdated — surface this message verbatim to the user:
+
+```
+drizzle-kit ships a newer agent-skills bundle (revision X) than what's installed (revision Y). Run `drizzle-kit skills` to refresh.
+```
+
+Substitute X with the revision the installed `drizzle-kit` ships (the `drizzle-kit skills version` value) and Y with this skill's own `metadata.revision`. Do not auto-update, do not prompt, do not write anything to the project — the recovery action is identical to first-install (re-run `drizzle-kit skills`). If the revision `drizzle-kit` ships is less than or equal to this skill's own revision, stop silently.
+
+If no project-installed `drizzle-kit` can be found or run AND the pending operation actually requires it — running a `drizzle-kit` command, using the Drizzle SDK, performing a migration verb (`generate` / `push` / `pull` / `up` / `check` / `export`), or handling drizzle-kit output — tell the user in one short line that `drizzle-kit` is required for that operation and to install it with the project's package manager. For example: "`drizzle-kit` is required to run `push` — install it with the project's package manager." If `drizzle-kit` is absent but the pending operation does not require it (just reading or editing a `drizzle-orm/*` source file), stay silent — do not nag.
+
+If `drizzle-kit` is found and runs but the call errors — non-zero exit, stdout that does not parse as a positive integer, or any other failure — stop silently as before. The "required" notice is only for the not-found case above.
+
+## Surface selection
+
+drizzle-kit exposes the same migration verbs (`generate`, `push`, `pull`, `up`, `check`, `export`) over three surfaces — CLI, SDK, and an MCP server — that all return the identical JSON envelope and consume the same `hints` array. The procedural skills (`drizzle-hints`, `drizzle-responses-and-errors`) apply unchanged regardless of surface; only the invocation differs. Pick the surface per verb:
+
+1. If a `mcp__drizzle__<verb>` tool is available in the session, prefer it over shelling out. Its `structuredContent` is the same envelope; resolve a `missing_hints` result with the same `hints` array and re-call the tool.
+2. Otherwise fall back to the CLI: `drizzle-kit <verb> --output json`.
+
+Two cases where the CLI is the better surface even when the MCP tool exists:
+
+- **Monorepos.** The target package is often a workspace package, not the repo root, and the MCP server resolves config from its own process cwd, not the client's. If the server was launched outside the target package, pass an explicit `config` to the tool, or run the CLI from that package through the package manager the project uses.
+- **Path overrides.** MCP tools take only `config` / `hints` / etc. — there is no `schema` / `out` / `dialect` override. When a task needs those, use the CLI flags.
diff --git a/drizzle-kit/src/@types/utils.ts b/drizzle-kit/src/@types/utils.ts
index e71d45b896..6b28f13a5b 100644
--- a/drizzle-kit/src/@types/utils.ts
+++ b/drizzle-kit/src/@types/utils.ts
@@ -5,7 +5,6 @@ declare global {
 		capitalise(): string;
 		camelCase(): string;
 		snake_case(): string;
-
 		concatIf(it: string, condition: boolean): string;
 	}
 
@@ -51,8 +50,13 @@ String.prototype.snake_case = function() {
 	return this && this.length > 0 ? `${this.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)}` : String(this);
 };
 
-Array.prototype.random = function() {
-	return this[~~(Math.random() * this.length)];
-};
+Object.defineProperty(Array.prototype, 'random', {
+	value: function() {
+		return this[~~(Math.random() * this.length)];
+	},
+	enumerable: false,
+	writable: true,
+	configurable: true,
+});
 
 export {};
diff --git a/drizzle-kit/src/api.ts b/drizzle-kit/src/api.ts
deleted file mode 100644
index 70960756a9..0000000000
--- a/drizzle-kit/src/api.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-import { MigrationConfig } from 'drizzle-orm/migrator';
-import { Minimatch } from 'minimatch';
-import {
-	columnsResolver,
-	enumsResolver,
-	indPolicyResolver,
-	policyResolver,
-	roleResolver,
-	schemasResolver,
-	sequencesResolver,
-	tablesResolver,
-	viewsResolver,
-} from './cli/commands/migrate';
-import { pgSuggestions } from './cli/commands/pgPushUtils';
-import { PostgresCredentials } from './cli/validations/postgres';
-import { originUUID } from './global';
-import { MySqlSchema as MySQLSchemaKit } from './serializer/mysqlSchema';
-import { PgSchema as PgSchemaKit, pgSchema, Role, squashPgScheme, View } from './serializer/pgSchema';
-import { fromDatabase } from './serializer/pgSerializer';
-import { SingleStoreSchema as SingleStoreSchemaKit } from './serializer/singlestoreSchema';
-import { SQLiteSchema as SQLiteSchemaKit } from './serializer/sqliteSchema';
-import { ProxyParams } from './serializer/studio';
-import type { DB, Proxy } from './utils';
-import './@types/utils';
-export type DrizzleSnapshotJSON = PgSchemaKit;
-export type DrizzleSQLiteSnapshotJSON = SQLiteSchemaKit;
-export type DrizzleMySQLSnapshotJSON = MySQLSchemaKit;
-export type DrizzleSingleStoreSnapshotJSON = SingleStoreSchemaKit;
-
-// Replit api
-export type DrizzlePostgresCredentials = PostgresCredentials;
-export type DrizzlePgDB = DB & {
-	proxy: Proxy;
-	migrate: (config: string | MigrationConfig) => Promise<void>;
-};
-export type PreparePgDBOptions = {
-	queryConcurrency?: number;
-};
-export type DrizzlePgDBIntrospectSchema = Omit<
-	PgSchemaKit,
-	'internal'
->;
-
-function createConcurrencyLimiter(concurrency?: number) {
-	if (concurrency === undefined) {
-		return <T>(fn: () => Promise<T>) => fn();
-	}
-
-	if (!Number.isInteger(concurrency) || concurrency < 1) {
-		throw new RangeError('queryConcurrency must be a positive integer');
-	}
-
-	let activeCount = 0;
-	const queue: Array<() => void> = [];
-
-	const runNext = () => {
-		if (activeCount >= concurrency) return;
-
-		const next = queue.shift();
-		if (!next) return;
-
-		activeCount += 1;
-		next();
-	};
-
-	return <T>(fn: () => Promise<T>) => {
-		return new Promise<T>((resolve, reject) => {
-			queue.push(() => {
-				Promise.resolve()
-					.then(fn)
-					.then(resolve, reject)
-					.finally(() => {
-						activeCount -= 1;
-						runNext();
-					});
-			});
-
-			runNext();
-		});
-	};
-}
-
-export const introspectPgDB = async (
-	db: DrizzlePgDB,
-	filters: string[],
-	schemaFilters: string[],
-): Promise<DrizzlePgDBIntrospectSchema> => {
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const res = await fromDatabase(
-		db,
-		filter,
-		schemaFilters,
-		undefined,
-		undefined,
-		undefined,
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as PgSchemaKit;
-	const { internal, ...schemaWithoutInternals } = schema;
-	return schemaWithoutInternals;
-};
-
-export const preparePgDB = async (
-	pool: import('pg').Pool | import('pg').PoolClient,
-	options: PreparePgDBOptions = {},
-): Promise<
-	DrizzlePgDB
-> => {
-	const { default: pg } = await import('pg');
-
-	const { drizzle } = await import('drizzle-orm/node-postgres');
-	const { migrate } = await import('drizzle-orm/node-postgres/migrator');
-
-	// Override pg default date parsers
-	const types: { getTypeParser: typeof pg.types.getTypeParser } = {
-		// @ts-ignore
-		getTypeParser: (typeId, format) => {
-			if (typeId === pg.types.builtins.TIMESTAMPTZ) {
-				return (val: any) => val;
-			}
-			if (typeId === pg.types.builtins.TIMESTAMP) {
-				return (val: any) => val;
-			}
-			if (typeId === pg.types.builtins.DATE) {
-				return (val: any) => val;
-			}
-			if (typeId === pg.types.builtins.INTERVAL) {
-				return (val: any) => val;
-			}
-			// @ts-ignore
-			return pg.types.getTypeParser(typeId, format);
-		},
-	};
-
-	const db = drizzle(pool);
-	const migrateFn = async (config: MigrationConfig) => {
-		return migrate(db, config);
-	};
-	const limitQuery = createConcurrencyLimiter(options.queryConcurrency);
-
-	const query = async (sql: string, params?: any[]) => {
-		const result = await limitQuery(() => {
-			return pool.query({
-				text: sql,
-				values: params ?? [],
-				types,
-			});
-		});
-		return result.rows;
-	};
-
-	const proxy: Proxy = async (params: ProxyParams) => {
-		const result = await limitQuery(() => {
-			return pool.query({
-				text: params.sql,
-				values: params.params,
-				...(params.mode === 'array' && { rowMode: 'array' }),
-				types,
-			});
-		});
-		return result.rows;
-	};
-
-	return { query, proxy, migrate: migrateFn };
-};
-
-export type { SelectResolverInput, SelectResolverOutput } from './cli/commands/pgPushUtils';
-export { applyPgSnapshotsDiff } from './snapshotsDiffer';
-export type {
-	ColumnsResolverInput,
-	Enum,
-	PolicyResolverInput,
-	ResolverInput,
-	RolesResolverInput,
-	Sequence,
-	Table,
-	TablePolicyResolverInput,
-} from './snapshotsDiffer';
-export {
-	columnsResolver,
-	enumsResolver,
-	indPolicyResolver,
-	pgSchema,
-	pgSuggestions,
-	policyResolver,
-	roleResolver,
-	schemasResolver,
-	sequencesResolver,
-	squashPgScheme,
-	tablesResolver,
-	viewsResolver,
-};
-export type { Role, View };
diff --git a/drizzle-kit/src/cli-sdk/check.ts b/drizzle-kit/src/cli-sdk/check.ts
new file mode 100644
index 0000000000..88139c44c3
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/check.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { CheckOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { prepareCheck, runCheck } from '../cli/schema';
+
+export const check = (opts: CheckOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await prepareCheck(opts as Parameters<typeof prepareCheck>[0]);
+			return await runCheck(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli-sdk/export.ts b/drizzle-kit/src/cli-sdk/export.ts
new file mode 100644
index 0000000000..694fdf1403
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/export.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { ExportOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { prepareExport, runExport } from '../cli/schema';
+
+export const exportSql = (opts: ExportOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await prepareExport(opts as Parameters<typeof prepareExport>[0]);
+			return await runExport(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli-sdk/generate.ts b/drizzle-kit/src/cli-sdk/generate.ts
new file mode 100644
index 0000000000..bab357d25b
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/generate.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { GenerateOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { prepareGenerate, runGenerate } from '../cli/schema';
+
+export const generate = (opts: GenerateOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await prepareGenerate(opts as Parameters<typeof prepareGenerate>[0]);
+			return await runGenerate(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli-sdk/index.ts b/drizzle-kit/src/cli-sdk/index.ts
new file mode 100644
index 0000000000..dca0a23610
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/index.ts
@@ -0,0 +1,16 @@
+export { check } from './check';
+export { exportSql } from './export';
+export { generate } from './generate';
+export { pull } from './pull';
+export { push } from './push';
+export { up } from './up';
+
+export type {
+	CheckOptions,
+	ExportOptions,
+	GenerateOptions,
+	PullOptions,
+	PushOptions,
+	UpOptions,
+} from '../cli/contract';
+export type { Hint, MissingHint } from '../cli/hints';
diff --git a/drizzle-kit/src/cli-sdk/pull.ts b/drizzle-kit/src/cli-sdk/pull.ts
new file mode 100644
index 0000000000..57b94044f7
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/pull.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { PullOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { preparePull, runPull } from '../cli/schema';
+
+export const pull = (opts: PullOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await preparePull(opts as Parameters<typeof preparePull>[0]);
+			return await runPull(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli-sdk/push.ts b/drizzle-kit/src/cli-sdk/push.ts
new file mode 100644
index 0000000000..1788c7ac5f
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/push.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { PushOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { preparePush, runPush } from '../cli/schema';
+
+export const push = (opts: PushOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await preparePush(opts as Parameters<typeof preparePush>[0]);
+			return await runPush(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli-sdk/up.ts b/drizzle-kit/src/cli-sdk/up.ts
new file mode 100644
index 0000000000..b71a29c4d6
--- /dev/null
+++ b/drizzle-kit/src/cli-sdk/up.ts
@@ -0,0 +1,14 @@
+import { runWithCliContext } from '../cli/context';
+import type { UpOptions } from '../cli/contract';
+import { errorToEnvelope } from '../cli/errors';
+import { prepareUp, runUp } from '../cli/schema';
+
+export const up = (opts: UpOptions) =>
+	runWithCliContext({ output: 'json', interactive: false }, async () => {
+		try {
+			const cfg = await prepareUp(opts as Parameters<typeof prepareUp>[0]);
+			return await runUp(cfg);
+		} catch (e) {
+			return errorToEnvelope(e);
+		}
+	});
diff --git a/drizzle-kit/src/cli/commands/_es5.ts b/drizzle-kit/src/cli/commands/_es5.ts
deleted file mode 100644
index 51838ffe59..0000000000
--- a/drizzle-kit/src/cli/commands/_es5.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-const _ = '';
-export default _;
diff --git a/drizzle-kit/src/cli/commands/check.ts b/drizzle-kit/src/cli/commands/check.ts
index 092057372d..d788b653ec 100644
--- a/drizzle-kit/src/cli/commands/check.ts
+++ b/drizzle-kit/src/cli/commands/check.ts
@@ -1,52 +1,233 @@
-import { Dialect } from '../../schemaValidator';
-import { prepareOutFolder, validateWithReport } from '../../utils';
-
-export const checkHandler = (out: string, dialect: Dialect) => {
-	const { snapshots } = prepareOutFolder(out, dialect);
-	const report = validateWithReport(snapshots, dialect);
-
-	if (report.nonLatest.length > 0) {
-		console.log(
-			report.nonLatest
-				.map((it) => {
-					return `${it} is not of the latest version, please run "drizzle-kit up"`;
-				})
-				.join('\n'),
-		);
-		process.exit(1);
-	}
-
-	if (report.malformed.length) {
-		const message = report.malformed
-			.map((it) => {
-				return `${it} data is malformed`;
-			})
-			.join('\n');
-		console.log(message);
-	}
-
-	const collisionEntries = Object.entries(report.idsMap).filter(
-		(it) => it[1].snapshots.length > 1,
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { getCommutativityDialect } from '../../commutativity';
+import type { MigrationNode, NonCommutativityReport, UnifiedBranchConflict } from '../../commutativity/types';
+import type { Dialect } from '../../utils/schemaValidator';
+import { prepareOutFolder, validatorForDialect } from '../../utils/utils-node';
+import { CheckCliError } from '../errors';
+import { humanLog } from '../views';
+
+export type CheckHandlerResult = {
+	statements: unknown[];
+	parentSnapshot: unknown | null;
+	parentId?: string;
+	leafIds?: string[];
+	nonCommutativityMessage?: string;
+};
+
+const emptyResult = (nonCommutativityMessage?: string): CheckHandlerResult => ({
+	statements: [],
+	parentSnapshot: null,
+	nonCommutativityMessage,
+});
+
+const selectOpenCommutativeBranch = (report: NonCommutativityReport) => {
+	const branches = report.commutativeBranches ?? [];
+	if (branches.length === 0) return null;
+
+	const leafSet = new Set(report.leafNodes);
+	return (
+		branches.find(
+			(branch) =>
+				branch.leafs.length > 1
+				&& branch.leafs.length === leafSet.size
+				&& branch.leafs.every((leaf) => leafSet.has(leaf.id)),
+		) ?? null
+	);
+};
+
+const countLeafs = (conflicts: UnifiedBranchConflict[]): number => {
+	const ids = new Set<string>();
+	for (const c of conflicts) {
+		const lastA = c.branchA.chain[c.branchA.chain.length - 1];
+		const lastB = c.branchB.chain[c.branchB.chain.length - 1];
+		if (lastA) ids.add(lastA.id);
+		if (lastB) ids.add(lastB.id);
+	}
+	return ids.size;
+};
+
+const headerBadge = (conflicts: UnifiedBranchConflict[]): string => {
+	const leafCount = countLeafs(conflicts);
+	return (
+		`${chalk.white.bgRed(' Non-commutative migrations detected ')} `
+		+ `Found ${chalk.bold(String(conflicts.length))} conflict${conflicts.length === 1 ? '' : 's'} `
+		+ `across ${chalk.bold(String(leafCount))} migration${leafCount === 1 ? '' : 's'}`
 	);
+};
 
-	const message = collisionEntries
-		.map((it) => {
-			const data = it[1];
-			return `[${
-				data.snapshots.join(
-					', ',
-				)
-			}] are pointing to a parent snapshot: ${data.parent}/snapshot.json which is a collision.`;
-		})
-		.join('\n');
+export const generateReportDirectory = (
+	report: NonCommutativityReport,
+): string => {
+	const { conflicts } = report;
+	const lines: string[] = ['', headerBadge(conflicts), ''];
 
-	if (message) {
-		console.log(message);
+	// Group conflicts by parentId
+	const byParent: Record<string, UnifiedBranchConflict[]> = {};
+	for (const c of conflicts) {
+		(byParent[c.parentId] ??= []).push(c);
 	}
 
-	const abort = report.malformed.length!! || collisionEntries.length > 0;
+	const parentEntries = Object.entries(byParent);
+
+	for (let p = 0; p < parentEntries.length; p++) {
+		const [parentId, parentConflicts] = parentEntries[p];
+		const parentLabel = parentConflicts[0].parentPath ?? parentId;
+
+		// Collect unique branches, dedupe by leaf id
+		const branches: { chain: MigrationNode[]; descriptions: string[] }[] = [];
+		const seenLeafs: Record<string, number> = {};
+
+		for (const c of parentConflicts) {
+			for (const branch of [c.branchA, c.branchB]) {
+				const leafId = branch.chain[branch.chain.length - 1]?.id ?? '';
+				if (leafId in seenLeafs) {
+					const descs = branches[seenLeafs[leafId]].descriptions;
+					if (!descs.includes(branch.statementDescription)) {
+						descs.push(branch.statementDescription);
+					}
+				} else {
+					seenLeafs[leafId] = branches.length;
+					branches.push({
+						chain: branch.chain,
+						descriptions: [branch.statementDescription],
+					});
+				}
+			}
+		}
+
+		lines.push(`  ${chalk.white(parentLabel)}`);
+
+		for (let b = 0; b < branches.length; b++) {
+			const { chain, descriptions } = branches[b];
+			const isLast = b === branches.length - 1;
+			const prefix = isLast ? '    ' : '│   ';
+
+			for (let m = 0; m < chain.length; m++) {
+				const label = m === chain.length - 1
+					? chalk.red.bold(chain[m].path)
+					: chalk.green(chain[m].path);
 
-	if (abort) {
-		process.exit(1);
+				lines.push(
+					m === 0
+						? `  ${chalk.gray(isLast ? '└──' : '├──')} ${label}`
+						: `  ${chalk.gray(prefix)}${label}`,
+				);
+			}
+
+			for (let d = 0; d < descriptions.length; d++) {
+				const connector = d === descriptions.length - 1 ? '└─' : '├─';
+				lines.push(
+					`  ${chalk.gray(prefix)}${chalk.gray(connector)} ${chalk.yellow('⚠')} ${chalk.yellow(descriptions[d])}`,
+				);
+			}
+		}
+
+		if (p < parentEntries.length - 1) lines.push('');
 	}
+
+	// Need to add a proper guide to uncomment
+	// lines.push(
+	// 	chalk.gray('\nPlease refer to our guide on how to resolve such conflicts:'),
+	// 	chalk.bold.underline.blue('https://orm.drizzle.team/docs/migrations'),
+	// );
+	return lines.join('\n');
+};
+
+export const checkHandler = async (
+	out: string,
+	dialect: Dialect,
+	ignoreConflicts?: boolean,
+	shouldExitOnConflict = true,
+): Promise<CheckHandlerResult> => {
+	const { snapshots } = prepareOutFolder(out);
+	const validator = validatorForDialect(dialect);
+
+	// const parsedInputs: ParsedSnapshotInput[] = [];
+	for (const snapshot of snapshots) {
+		let raw: object;
+		try {
+			const parsed: unknown = JSON.parse(readFileSync(snapshot).toString());
+			if (typeof parsed !== 'object' || parsed === null) {
+				throw new CheckCliError('malformed', `${snapshot} data is malformed`, { snapshot });
+			}
+			raw = parsed;
+		} catch (e) {
+			if (e instanceof CheckCliError) throw e;
+			throw new CheckCliError('malformed', `${snapshot} data is malformed`, { snapshot });
+		}
+
+		const res = validator(raw);
+		switch (res.status) {
+			case 'valid':
+				// parsedInputs.push({ path: snapshot, snapshot: raw });
+				break;
+			case 'unsupported':
+				throw new CheckCliError(
+					'unsupported',
+					`${snapshot} snapshot is of unsupported version, please update drizzle-kit`,
+					{ snapshot },
+				);
+			case 'malformed':
+				throw new CheckCliError('malformed', `${snapshot} data is malformed`, { snapshot });
+			case 'nonLatest':
+				throw new CheckCliError(
+					'non_latest',
+					`${snapshot} is not of the latest version, please run "drizzle-kit up"`,
+					{ snapshot },
+				);
+		}
+	}
+
+	const commutativity = getCommutativityDialect(dialect);
+	if (!commutativity) {
+		return emptyResult();
+	}
+
+	const response = await commutativity.detectNonCommutative(snapshots);
+	if (response.conflicts.length > 0) {
+		const nonCommutativityMessage = generateReportDirectory(response);
+		if (!ignoreConflicts) {
+			if (shouldExitOnConflict) {
+				const leafOf = (chain: MigrationNode[]) => chain[chain.length - 1];
+				const details = response.conflicts.map((conflict) => ({
+					parentId: conflict.parentId,
+					...(conflict.parentPath !== undefined && { parentPath: conflict.parentPath }),
+					branches: [conflict.branchA, conflict.branchB].map((branch) => ({
+						leafId: leafOf(branch.chain)?.id ?? null,
+						leafPath: leafOf(branch.chain)?.path ?? null,
+						statementDescription: branch.statementDescription,
+						target: branch.target,
+						action: branch.action,
+					})),
+				}));
+				throw new CheckCliError('conflicts', nonCommutativityMessage, {
+					conflicts: response.conflicts.length,
+					details,
+				});
+			}
+			humanLog(nonCommutativityMessage);
+			return emptyResult(nonCommutativityMessage);
+		}
+	}
+
+	const selectedBranch = selectOpenCommutativeBranch(response);
+	if (selectedBranch) {
+		return {
+			statements: selectedBranch.statements,
+			parentSnapshot: selectedBranch.parentSnapshot,
+			parentId: selectedBranch.parentId,
+			leafIds: selectedBranch.leafs.map((leaf) => leaf.id),
+		};
+	}
+
+	if (ignoreConflicts && response.leafNodes.length > 1) {
+		return {
+			statements: [],
+			parentSnapshot: null,
+			leafIds: [...response.leafNodes].sort((left, right) => left.localeCompare(right)),
+		};
+	}
+
+	return emptyResult();
 };
diff --git a/drizzle-kit/src/cli/commands/drop.ts b/drizzle-kit/src/cli/commands/drop.ts
deleted file mode 100644
index 183e9459d2..0000000000
--- a/drizzle-kit/src/cli/commands/drop.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import chalk from 'chalk';
-import { readFileSync, rmSync, writeFileSync } from 'fs';
-import fs from 'fs';
-import { render } from 'hanji';
-import { join } from 'path';
-import { Journal } from '../../utils';
-import { DropMigrationView } from '../views';
-import { embeddedMigrations } from './migrate';
-
-export const dropMigration = async ({
-	out,
-	bundle,
-}: {
-	out: string;
-	bundle: boolean;
-}) => {
-	const metaFilePath = join(out, 'meta', '_journal.json');
-	const journal = JSON.parse(readFileSync(metaFilePath, 'utf-8')) as Journal;
-
-	if (journal.entries.length === 0) {
-		console.log(
-			`[${chalk.blue('i')}] no migration entries found in ${metaFilePath}`,
-		);
-		return;
-	}
-
-	const result = await render(new DropMigrationView(journal.entries));
-	if (result.status === 'aborted') return;
-
-	delete journal.entries[journal.entries.indexOf(result.data!)];
-
-	const resultJournal: Journal = {
-		...journal,
-		entries: journal.entries.filter(Boolean),
-	};
-	const sqlFilePath = join(out, `${result.data.tag}.sql`);
-	const snapshotFilePath = join(
-		out,
-		'meta',
-		`${result.data.tag.split('_')[0]}_snapshot.json`,
-	);
-	rmSync(sqlFilePath);
-	rmSync(snapshotFilePath);
-	writeFileSync(metaFilePath, JSON.stringify(resultJournal, null, 2));
-
-	if (bundle) {
-		fs.writeFileSync(
-			join(out, `migrations.js`),
-			embeddedMigrations(resultJournal),
-		);
-	}
-
-	console.log(
-		`[${chalk.green('✓')}] ${
-			chalk.bold(
-				result.data.tag,
-			)
-		} migration successfully dropped`,
-	);
-};
diff --git a/drizzle-kit/src/cli/commands/generate-cockroach.ts b/drizzle-kit/src/cli/commands/generate-cockroach.ts
new file mode 100644
index 0000000000..2d2644dfaf
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-cockroach.ts
@@ -0,0 +1,123 @@
+import type {
+	CheckConstraint,
+	CockroachEntities,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Schema,
+	Sequence,
+	View,
+} from '../../dialects/cockroach/ddl';
+import { createDDL, interimToDDL } from '../../dialects/cockroach/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/cockroach/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/cockroach/drizzle';
+import { prepareSnapshot } from '../../dialects/cockroach/serializer';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { cockroachSchemaError, cockroachSchemaWarning, explain, explainJsonOutput, humanLog } from '../views';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const handle = async (config: GenerateConfig) => {
+	const { out: outFolder, filenames } = config;
+	const json = outputFormat() === 'json';
+
+	const { snapshots } = prepareOutFolder(outFolder);
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSnapshot(snapshots, filenames);
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'cockroach',
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<Schema>('schema', config.hints),
+		resolver<Enum>('enum', config.hints),
+		resolver<Sequence>('sequence', config.hints),
+		resolver<Policy>('policy', config.hints),
+		resolver<CockroachEntities['tables']>('table', config.hints),
+		resolver<Column>('column', config.hints),
+		resolver<View>('view', config.hints),
+		resolver<Index>('index', config.hints),
+		resolver<CheckConstraint>('check', config.hints),
+		resolver<PrimaryKey>('primary_key', config.hints),
+		resolver<ForeignKey>('foreign key', config.hints),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	if (!config.explain) {
+		return writeResult({
+			snapshot: snapshot,
+			sqlStatements,
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'cockroach',
+			renames,
+			snapshots,
+		});
+	}
+
+	if (json) {
+		if (sqlStatements.length === 0) {
+			return { status: 'no_changes' as const, dialect: 'cockroach' };
+		}
+		return explainJsonOutput('cockroach', statements, []);
+	}
+
+	const explainMessage = explain('cockroach', groupedStatements, []);
+	if (explainMessage) {
+		humanLog(explainMessage);
+	}
+
+	return { status: 'ok' as const, dialect: 'cockroach' };
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+
+	// TODO: do we wanna respect entity filter while exporting to sql?
+	// cc: @AleksandrSherman
+	const { schema, errors, warnings } = fromDrizzleSchema(res, () => true);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => cockroachSchemaError(it)).join('\n'), {
+			stage: 'schema',
+			dialect: 'cockroach',
+		});
+	}
+
+	const { ddl, errors: errors2 } = interimToDDL(schema);
+
+	if (errors2.length > 0) {
+		throw new CommandOutputCliError('export', errors2.map((it) => cockroachSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'cockroach',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl, 'default');
+	return {
+		statements: sqlStatements,
+		warnings: warnings.map((it) => cockroachSchemaWarning(it)),
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/generate-common.ts b/drizzle-kit/src/cli/commands/generate-common.ts
new file mode 100644
index 0000000000..3c7d5af198
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-common.ts
@@ -0,0 +1,157 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { render } from 'hanji';
+import path, { join } from 'path';
+import type { CockroachSnapshot } from '../../dialects/cockroach/snapshot';
+import type { MssqlSnapshot } from '../../dialects/mssql/snapshot';
+import type { MysqlSnapshot } from '../../dialects/mysql/snapshot';
+import type { PostgresSnapshot } from '../../dialects/postgres/snapshot';
+import type { SingleStoreSnapshot } from '../../dialects/singlestore/snapshot';
+import type { SqliteSnapshot } from '../../dialects/sqlite/snapshot';
+import { BREAKPOINT } from '../../utils';
+import { prepareMigrationMetadata } from '../../utils/words';
+import { outputFormat } from '../context';
+import type { Driver } from '../validations/common';
+import { humanLog } from '../views';
+
+type WriteResultConfigBase = {
+	snapshot: SqliteSnapshot | PostgresSnapshot | MysqlSnapshot | MssqlSnapshot | CockroachSnapshot | SingleStoreSnapshot;
+	sqlStatements: string[];
+	outFolder: string;
+	breakpoints: boolean;
+	name?: string;
+	bundle?: boolean;
+	dialect?: string;
+	driver?: Driver;
+	renames: string[];
+	snapshots: string[];
+};
+
+export function writeResult(
+	config: WriteResultConfigBase & { type: 'introspect' },
+): { snapshotPath: string; migrationPath: string };
+export function writeResult(
+	config: WriteResultConfigBase & { type?: 'custom' | 'none' },
+):
+	| { status: 'no_changes'; dialect: string | undefined }
+	| { status: 'ok'; dialect: string | undefined; migration_path: string };
+export function writeResult(
+	config: WriteResultConfigBase & { type?: 'introspect' | 'custom' | 'none' },
+) {
+	const {
+		snapshot,
+		sqlStatements,
+		outFolder,
+		breakpoints,
+		name,
+		renames,
+		bundle = false,
+		type = 'none',
+		dialect,
+		driver,
+		snapshots,
+	} = config;
+	const json = outputFormat() === 'json';
+
+	if (type === 'none') {
+		if (sqlStatements.length === 0) {
+			humanLog('No schema changes, nothing to migrate 😴');
+			return { status: 'no_changes' as const, dialect };
+		}
+	}
+
+	const { tag } = prepareMigrationMetadata(name);
+
+	snapshot.renames = renames;
+
+	fs.mkdirSync(join(outFolder, tag));
+	fs.writeFileSync(
+		join(outFolder, `${tag}/snapshot.json`),
+		JSON.stringify(JSON.parse(JSON.stringify(snapshot)), null, 2),
+	);
+
+	const sqlDelimiter = breakpoints ? BREAKPOINT : '\n';
+	let sql = sqlStatements.join(sqlDelimiter);
+
+	if (type === 'introspect') {
+		sql =
+			`-- Current sql file was generated after introspecting the database\n-- If you want to run this migration please uncomment this code before executing migrations\n/*\n${sql}\n*/`;
+	}
+
+	if (type === 'custom') {
+		humanLog('Prepared empty file for your custom SQL migration!');
+		sql = '-- Custom SQL migration file, put your code below! --';
+	}
+
+	fs.writeFileSync(join(outFolder, `${tag}/migration.sql`), sql);
+	const migrationPath = path.join(`${outFolder}/${tag}/migration.sql`);
+
+	// js file with .sql imports for React Native / Expo and Durable Sqlite Objects
+	if (bundle) {
+		// adding new migration to the list of all migrations
+		const js = embeddedMigrations([...snapshots || [], join(outFolder, `${tag}/snapshot.json`)], driver);
+		fs.writeFileSync(`${outFolder}/migrations.js`, js);
+	}
+
+	if (!json) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your SQL migration ➜ ${
+				chalk.bold.underline.blue(
+					migrationPath,
+				)
+			} 🚀`,
+		);
+	}
+
+	if (type === 'introspect') {
+		return { snapshotPath: join(outFolder, `${tag}/snapshot.json`), migrationPath };
+	}
+
+	return { status: 'ok' as const, dialect, migration_path: migrationPath };
+}
+
+export const embeddedMigrations = (snapshots: string[], driver?: Driver) => {
+	let content = driver === 'expo'
+		? '// This file is required for Expo/React Native SQLite migrations - https://orm.drizzle.team/quick-sqlite/expo\n\n'
+		: '';
+
+	const migrations: Record<string, string> = {};
+
+	snapshots.forEach((entry, idx) => {
+		const prefix = entry.split(path.sep)[entry.split(path.sep).length - 2];
+		const importName = idx.toString().padStart(4, '0');
+		content += `import m${importName} from './${prefix}/migration.sql';\n`;
+		migrations[prefix] = importName;
+	});
+
+	content += `
+  export default {
+    migrations: {
+      ${Object.entries(migrations).map(([key, query]) => `"${key}": m${query}`).join(',\n')}
+}
+  }
+  `;
+
+	return content;
+};
+
+export const prepareSnapshotFolderName = (ms?: number) => {
+	const now = ms ? new Date(ms) : new Date();
+	return `${now.getFullYear()}${two(now.getUTCMonth() + 1)}${
+		two(
+			now.getUTCDate(),
+		)
+	}${two(now.getUTCHours())}${two(now.getUTCMinutes())}${
+		two(
+			now.getUTCSeconds(),
+		)
+	}`;
+};
+
+const two = (input: number): string => {
+	return input.toString().padStart(2, '0');
+};
diff --git a/drizzle-kit/src/cli/commands/generate-libsql.ts b/drizzle-kit/src/cli/commands/generate-libsql.ts
new file mode 100644
index 0000000000..0b3f7c9bab
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-libsql.ts
@@ -0,0 +1 @@
+export { handle, handleExport } from './generate-sqlite';
diff --git a/drizzle-kit/src/cli/commands/generate-mssql.ts b/drizzle-kit/src/cli/commands/generate-mssql.ts
new file mode 100644
index 0000000000..fcd5862cbf
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-mssql.ts
@@ -0,0 +1,139 @@
+import chalk from 'chalk';
+import { createDDL, type DefaultConstraint, interimToDDL } from '../../dialects/mssql/ddl';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+} from '../../dialects/mssql/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/mssql/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/mssql/drizzle';
+import { prepareSnapshot } from '../../dialects/mssql/serializer';
+import type { JsonStatement } from '../../dialects/mssql/statements';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { withStyle } from '../validations/outputs';
+import { explain, explainJsonOutput, humanLog, mssqlSchemaError } from '../views';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const handle = async (config: GenerateConfig) => {
+	const { out: outFolder, filenames } = config;
+	const json = outputFormat() === 'json';
+	const { snapshots } = prepareOutFolder(outFolder);
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSnapshot(snapshots, filenames);
+
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'mssql',
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<Schema>('schema', config.hints, 'dbo'),
+		resolver<MssqlEntities['tables']>('table', config.hints, 'dbo'),
+		resolver<Column>('column', config.hints, 'dbo'),
+		resolver<View>('view', config.hints, 'dbo'),
+		resolver<UniqueConstraint>('unique', config.hints, 'dbo'),
+		resolver<Index>('index', config.hints, 'dbo'),
+		resolver<CheckConstraint>('check', config.hints, 'dbo'),
+		resolver<PrimaryKey>('primary_key', config.hints, 'dbo'),
+		resolver<ForeignKey>('foreign key', config.hints, 'dbo'),
+		resolver<DefaultConstraint>('default', config.hints, 'dbo'),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	const recreateIdentity = statements.find((it): it is Extract<JsonStatement, { type: 'recreate_identity_column' }> =>
+		it.type === 'recreate_identity_column'
+	);
+	if (
+		recreateIdentity && Boolean(recreateIdentity.column.identity?.to)
+		&& !recreateIdentity.column.identity?.from
+	) {
+		humanLog(
+			withStyle.warning(
+				chalk.red.bold('You are about to add an identity property to an existing column.')
+					+ '\n'
+					+ chalk.red(
+						'This operation may result in data loss as the column must be recreated. Identity columns cannot be added to existing ones and do not permit manual value insertion.',
+					)
+					+ '\n'
+					+ chalk.red('All existing data in the column will be overwritten with new identity values'),
+			),
+		);
+	}
+
+	if (!config.explain) {
+		return writeResult({
+			snapshot: snapshot,
+			sqlStatements,
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'mssql',
+			renames,
+			snapshots,
+		});
+	}
+
+	if (json) {
+		if (sqlStatements.length === 0) {
+			return { status: 'no_changes' as const, dialect: 'mssql' };
+		}
+		return explainJsonOutput('mssql', statements, []);
+	}
+
+	const explainMessage = explain('mssql', groupedStatements, []);
+	if (explainMessage) {
+		humanLog(explainMessage);
+	}
+
+	return { status: 'ok' as const, dialect: 'mssql' };
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+
+	// TODO: do we want to respect config filter here?
+	// cc: @AleksandrSherman
+	const { schema, errors } = fromDrizzleSchema(res, () => true);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => mssqlSchemaError(it)).join('\n'), {
+			stage: 'schema',
+			dialect: 'mssql',
+		});
+	}
+
+	const { ddl, errors: errors2 } = interimToDDL(schema);
+	if (errors2.length > 0) {
+		throw new CommandOutputCliError('export', errors2.map((it) => mssqlSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'mssql',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl, 'default');
+	return { statements: sqlStatements, warnings: [] };
+};
diff --git a/drizzle-kit/src/cli/commands/generate-mysql.ts b/drizzle-kit/src/cli/commands/generate-mysql.ts
new file mode 100644
index 0000000000..0a8092c17b
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-mysql.ts
@@ -0,0 +1,192 @@
+import { type Column, createDDL, interimToDDL, type MysqlDDL, type Table, type View } from '../../dialects/mysql/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/mysql/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/mysql/drizzle';
+import { prepareSnapshot } from '../../dialects/mysql/serializer';
+import type { JsonStatement } from '../../dialects/mysql/statements';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { withStyle } from '../validations/outputs';
+import { explain, explainJsonOutput, humanLog, mysqlSchemaError } from '../views';
+import type { CheckHandlerResult } from './check';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const suggestions = (
+	jsonStatements: JsonStatement[],
+	ddl2: MysqlDDL,
+) => {
+	const grouped: { hints: string[]; errors: string[] } = {
+		errors: [],
+		hints: [],
+	};
+
+	for (const statement of jsonStatements) {
+		if (statement.type === 'create_fk' && statement.cause !== 'alter_pk') {
+			const { columnsTo, table, tableTo, columns } = statement.fk;
+
+			const indexes = ddl2.indexes.list({ isUnique: true, table: tableTo });
+			const pk = ddl2.pks.one({ table: tableTo });
+
+			const columnsToSet = new Set(columnsTo);
+
+			const isUniqueFound = indexes.some((index) => {
+				if (index.columns.length !== columnsToSet.size) {
+					return false;
+				}
+
+				return index.columns.every((col) => columnsToSet.has(col.value));
+			});
+
+			const isPkFound = pk
+				&& pk.columns.length === columnsToSet.size
+				&& pk.columns.every((col) => columnsToSet.has(col));
+
+			if (isPkFound || isUniqueFound) continue;
+
+			let composite = columnsTo.length > 1 ? 'composite ' : '';
+			grouped.errors.push(
+				`You are trying to add reference from "${table}" ("${columns.join('", ')}") to "${tableTo}" ("${
+					columnsTo.join(
+						'", ',
+					)
+				}"). The referenced columns are not guaranteed to be unique together. A foreign key must point to a PRIMARY KEY or a set of columns with a UNIQUE constraint. You should add a ${composite}unique constraint to the referenced columns`,
+			);
+
+			continue;
+		}
+
+		if (statement.type === 'drop_pk') {
+			const { table, columns } = statement.pk;
+
+			const fks = ddl2.fks.list({ tableTo: table });
+			const indexes = ddl2.indexes.list({ table: table });
+
+			const fkFound = fks.filter((fk) => {
+				if (fk.columnsTo.length !== columns.length) return false;
+
+				return fk.columnsTo.every((fkCol) => columns.includes(fkCol));
+			});
+
+			if (fkFound.length === 0) continue;
+
+			const indexesFound = indexes.some((index) => {
+				if (index.columns.length !== columns.length) {
+					return false;
+				}
+
+				return index.columns.every((col) => columns.includes(col.value));
+			});
+
+			if (indexesFound) continue;
+
+			grouped.errors.push(
+				`You are trying to drop primary key from "${table}" ("${
+					columns.join(
+						'", ',
+					)
+				}"), but there is an existing reference on this column. You must either add a UNIQUE constraint to ("${
+					columns.join(
+						'", ',
+					)
+				}") or drop the foreign key constraint that references this column.`,
+			);
+
+			continue;
+		}
+	}
+
+	return grouped;
+};
+
+export const handle = async (
+	config: GenerateConfig,
+	checkResult?: CheckHandlerResult,
+) => {
+	const { out: outFolder, filenames } = config;
+	const json = outputFormat() === 'json';
+
+	const { snapshots } = prepareOutFolder(outFolder);
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSnapshot(
+		snapshots,
+		filenames,
+		checkResult,
+	);
+
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'mysql',
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<Table>('table', config.hints),
+		resolver<Column>('column', config.hints),
+		resolver<View>('view', config.hints),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	const { errors } = suggestions(statements, ddlCur);
+	if (errors.length) {
+		throw new CommandOutputCliError('generate', errors.map((err) => withStyle.errorWarning(err)).join('\n\n'), {
+			stage: 'suggestions',
+			dialect: 'mysql',
+		});
+	}
+
+	if (config.explain) {
+		if (json) {
+			if (sqlStatements.length === 0) {
+				return { status: 'no_changes' as const, dialect: 'mysql' };
+			}
+			return explainJsonOutput('mysql', statements, []);
+		}
+		const explainMessage = explain('mysql', groupedStatements, []);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'mysql' };
+	}
+
+	return writeResult({
+		snapshot,
+		sqlStatements,
+		outFolder,
+		name: config.name,
+		breakpoints: config.breakpoints,
+		dialect: 'mysql',
+		renames,
+		snapshots,
+	});
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+	const schema = fromDrizzleSchema(res.tables, res.views);
+	const { ddl, errors } = interimToDDL(schema);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => mysqlSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'mysql',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl, 'default');
+	return { statements: sqlStatements, warnings: [] };
+};
diff --git a/drizzle-kit/src/cli/commands/generate-postgres.ts b/drizzle-kit/src/cli/commands/generate-postgres.ts
new file mode 100644
index 0000000000..6a7114b6cb
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-postgres.ts
@@ -0,0 +1,141 @@
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+} from '../../dialects/postgres/ddl';
+import { createDDL, interimToDDL } from '../../dialects/postgres/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/postgres/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/postgres/drizzle';
+import type { SchemaSource } from '../../dialects/postgres/drizzle';
+import { prepareSnapshot } from '../../dialects/postgres/serializer';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { explain, explainJsonOutput, humanLog, postgresSchemaError, postgresSchemaWarning } from '../views';
+import type { CheckHandlerResult } from './check';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const handle = async (
+	config: GenerateConfig<SchemaSource>,
+	checkResult?: CheckHandlerResult,
+) => {
+	const { out: outFolder } = config;
+	const json = outputFormat() === 'json';
+
+	const { snapshots } = prepareOutFolder(outFolder);
+	const prepared = await config.schemaSource.load();
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSnapshot(
+		snapshots,
+		prepared,
+		checkResult,
+	);
+
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'postgresql',
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<Schema>('schema', config.hints),
+		resolver<Enum>('enum', config.hints),
+		resolver<Sequence>('sequence', config.hints),
+		resolver<Policy>('policy', config.hints),
+		resolver<Role>('role', config.hints),
+		resolver<Privilege>('privilege', config.hints),
+		resolver<PostgresEntities['tables']>('table', config.hints),
+		resolver<Column>('column', config.hints),
+		resolver<View>('view', config.hints),
+		resolver<UniqueConstraint>('unique', config.hints),
+		resolver<Index>('index', config.hints),
+		resolver<CheckConstraint>('check', config.hints),
+		resolver<PrimaryKey>('primary_key', config.hints),
+		resolver<ForeignKey>('foreign key', config.hints),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	if (!config.explain) {
+		return writeResult({
+			snapshot: snapshot,
+			sqlStatements,
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'postgresql',
+			renames,
+			snapshots,
+		});
+	}
+
+	if (json) {
+		if (sqlStatements.length === 0) {
+			return { status: 'no_changes' as const, dialect: 'postgresql' };
+		}
+		return explainJsonOutput('postgresql', statements, []);
+	}
+
+	const explainMessage = explain('postgres', groupedStatements, []);
+	if (explainMessage) {
+		humanLog(explainMessage);
+	}
+
+	return { status: 'ok' as const, dialect: 'postgresql' };
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+	// TODO: do we wan't to export everything or ignore .existing and respect entity filters in config
+	const { schema, errors, warnings } = fromDrizzleSchema(
+		res,
+		() => true,
+	);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => postgresSchemaError(it)).join('\n'), {
+			stage: 'schema',
+			dialect: 'postgresql',
+		});
+	}
+
+	const { ddl, errors: errors2 } = interimToDDL(schema);
+
+	if (errors2.length > 0) {
+		throw new CommandOutputCliError('export', errors2.map((it) => postgresSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'postgresql',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl, 'default');
+	return {
+		statements: sqlStatements,
+		warnings: warnings.map((it) => postgresSchemaWarning(it)),
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/generate-singlestore.ts b/drizzle-kit/src/cli/commands/generate-singlestore.ts
new file mode 100644
index 0000000000..0bfb748e04
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-singlestore.ts
@@ -0,0 +1,89 @@
+import type { Column, Table, View } from '../../dialects/mysql/ddl';
+import { createDDL, interimToDDL } from '../../dialects/mysql/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/singlestore/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/singlestore/drizzle';
+import { prepareSnapshot } from '../../dialects/singlestore/serializer';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { explain, explainJsonOutput, humanLog, mysqlSchemaError } from '../views';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const handle = async (config: GenerateConfig) => {
+	const { out: outFolder, filenames } = config;
+	const json = outputFormat() === 'json';
+	const { snapshots } = prepareOutFolder(outFolder);
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSnapshot(snapshots, filenames);
+
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'singlestore',
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<Table>('table', config.hints),
+		resolver<Column>('column', config.hints),
+		resolver<View>('view', config.hints),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	if (!config.explain) {
+		return writeResult({
+			snapshot,
+			sqlStatements,
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect: 'singlestore',
+			renames,
+			snapshots,
+		});
+	}
+
+	if (json) {
+		if (sqlStatements.length === 0) {
+			return { status: 'no_changes' as const, dialect: 'singlestore' };
+		}
+		return explainJsonOutput('singlestore', statements, []);
+	}
+
+	const explainMessage = explain('singlestore', groupedStatements, []);
+	if (explainMessage) {
+		humanLog(explainMessage);
+	}
+
+	return { status: 'ok' as const, dialect: 'singlestore' };
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+	const schema = fromDrizzleSchema(res.tables);
+	const { ddl, errors } = interimToDDL(schema);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => mysqlSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'singlestore',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl);
+	return { statements: sqlStatements, warnings: [] };
+};
diff --git a/drizzle-kit/src/cli/commands/generate-sqlite.ts b/drizzle-kit/src/cli/commands/generate-sqlite.ts
new file mode 100644
index 0000000000..7d696ed5ac
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/generate-sqlite.ts
@@ -0,0 +1,106 @@
+import { type Column, createDDL, interimToDDL, type SqliteEntities } from '../../dialects/sqlite/ddl';
+import { ddlDiff, ddlDiffDry } from '../../dialects/sqlite/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/sqlite/drizzle';
+import type { SchemaSource } from '../../dialects/sqlite/drizzle';
+import { prepareSqliteSnapshot } from '../../dialects/sqlite/serializer';
+import { prepareOutFolder } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import { explain, explainJsonOutput, humanLog, sqliteSchemaError, warning } from '../views';
+import type { CheckHandlerResult } from './check';
+import { writeResult } from './generate-common';
+import type { ExportConfig, GenerateConfig } from './utils';
+
+export const handle = async (
+	config: GenerateConfig<SchemaSource>,
+	checkResult?: CheckHandlerResult,
+) => {
+	const dialect = config.dialect === 'turso' ? 'turso' : 'sqlite';
+	const json = outputFormat() === 'json';
+	const { out: outFolder } = config;
+	const { snapshots } = prepareOutFolder(outFolder);
+	const prepared = await config.schemaSource.load();
+	const { ddlCur, ddlPrev, snapshot, custom } = await prepareSqliteSnapshot(
+		snapshots,
+		prepared,
+		checkResult,
+	);
+	if (config.custom) {
+		return writeResult({
+			snapshot: custom,
+			sqlStatements: [],
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect,
+			bundle: config.bundle,
+			type: 'custom',
+			renames: [],
+			snapshots,
+		});
+	}
+
+	const { sqlStatements, warnings, renames, groupedStatements, statements } = await ddlDiff(
+		ddlPrev,
+		ddlCur,
+		resolver<SqliteEntities['tables']>('table', config.hints),
+		resolver<Column>('column', config.hints),
+		'default',
+	);
+
+	if (config.hints.hasMissingHints()) {
+		return config.hints.toResponse();
+	}
+
+	if (!json) {
+		for (const w of warnings) {
+			warning(w);
+		}
+	}
+
+	if (!config.explain) {
+		return writeResult({
+			snapshot: snapshot,
+			sqlStatements,
+			renames,
+			outFolder,
+			name: config.name,
+			breakpoints: config.breakpoints,
+			dialect,
+			bundle: config.bundle,
+			driver: config.driver,
+			snapshots,
+		});
+	}
+
+	if (json) {
+		if (sqlStatements.length === 0) {
+			return { status: 'no_changes' as const, dialect };
+		}
+		return explainJsonOutput(dialect, statements, []);
+	}
+
+	const explainMessage = explain('sqlite', groupedStatements, []);
+	if (explainMessage) {
+		humanLog(explainMessage);
+	}
+
+	return { status: 'ok' as const, dialect };
+};
+
+export const handleExport = async (config: ExportConfig) => {
+	const res = await prepareFromSchemaFiles(config.filenames);
+	const schema = fromDrizzleSchema(res.tables, res.views);
+	const { ddl, errors } = interimToDDL(schema);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('export', errors.map((it) => sqliteSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'sqlite',
+		});
+	}
+
+	const { sqlStatements } = await ddlDiffDry(createDDL(), ddl, 'default');
+	return { statements: sqlStatements, warnings: [] };
+};
diff --git a/drizzle-kit/src/cli/commands/introspect.ts b/drizzle-kit/src/cli/commands/introspect.ts
deleted file mode 100644
index 9b445a7ee2..0000000000
--- a/drizzle-kit/src/cli/commands/introspect.ts
+++ /dev/null
@@ -1,900 +0,0 @@
-import chalk from 'chalk';
-import { writeFileSync } from 'fs';
-import { render, renderWithTask } from 'hanji';
-import { Minimatch } from 'minimatch';
-import { join } from 'path';
-import { plural, singular } from 'pluralize';
-import { GelSchema } from 'src/serializer/gelSchema';
-import { drySingleStore, SingleStoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
-import { assertUnreachable, originUUID } from '../../global';
-import { schemaToTypeScript as gelSchemaToTypeScript } from '../../introspect-gel';
-import { schemaToTypeScript as mysqlSchemaToTypeScript } from '../../introspect-mysql';
-import { paramNameFor, schemaToTypeScript as postgresSchemaToTypeScript } from '../../introspect-pg';
-import { schemaToTypeScript as singlestoreSchemaToTypeScript } from '../../introspect-singlestore';
-import { schemaToTypeScript as sqliteSchemaToTypeScript } from '../../introspect-sqlite';
-import { fromDatabase as fromGelDatabase } from '../../serializer/gelSerializer';
-import { dryMySql, MySqlSchema, squashMysqlScheme } from '../../serializer/mysqlSchema';
-import { fromDatabase as fromMysqlDatabase } from '../../serializer/mysqlSerializer';
-import { dryPg, type PgSchema, squashPgScheme } from '../../serializer/pgSchema';
-import { fromDatabase as fromPostgresDatabase } from '../../serializer/pgSerializer';
-import { fromDatabase as fromSingleStoreDatabase } from '../../serializer/singlestoreSerializer';
-import { drySQLite, type SQLiteSchema, squashSqliteScheme } from '../../serializer/sqliteSchema';
-import { fromDatabase as fromSqliteDatabase } from '../../serializer/sqliteSerializer';
-import {
-	applyLibSQLSnapshotsDiff,
-	applyMysqlSnapshotsDiff,
-	applyPgSnapshotsDiff,
-	applySingleStoreSnapshotsDiff,
-	applySqliteSnapshotsDiff,
-} from '../../snapshotsDiffer';
-import { prepareOutFolder } from '../../utils';
-import { Entities } from '../validations/cli';
-import type { Casing, Prefix } from '../validations/common';
-import { GelCredentials } from '../validations/gel';
-import { LibSQLCredentials } from '../validations/libsql';
-import type { MysqlCredentials } from '../validations/mysql';
-import type { PostgresCredentials } from '../validations/postgres';
-import { SingleStoreCredentials } from '../validations/singlestore';
-import type { SqliteCredentials } from '../validations/sqlite';
-import { IntrospectProgress } from '../views';
-import {
-	columnsResolver,
-	enumsResolver,
-	indPolicyResolver,
-	mySqlViewsResolver,
-	policyResolver,
-	roleResolver,
-	schemasResolver,
-	sequencesResolver,
-	sqliteViewsResolver,
-	tablesResolver,
-	viewsResolver,
-	writeResult,
-} from './migrate';
-
-export const introspectPostgres = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: PostgresCredentials,
-	tablesFilter: string[],
-	schemasFilter: string[],
-	prefix: Prefix,
-	entities: Entities,
-) => {
-	const { preparePostgresDB } = await import('../connections');
-	const db = await preparePostgresDB(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress(true);
-
-	const res = await renderWithTask(
-		progress,
-		fromPostgresDatabase(
-			db,
-			filter,
-			schemasFilter,
-			entities,
-			(stage, count, status) => {
-				progress.update(stage, count, status);
-			},
-		),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as PgSchema;
-	const ts = postgresSchemaToTypeScript(schema, casing);
-	const relationsTs = relationsToTypeScript(schema, casing);
-	const { internal, ...schemaWithoutInternals } = schema;
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	const relationsFile = join(out, 'relations.ts');
-	writeFileSync(relationsFile, relationsTs.file);
-	console.log();
-
-	const { snapshots, journal } = prepareOutFolder(out, 'postgresql');
-
-	if (snapshots.length === 0) {
-		const { sqlStatements, _meta } = await applyPgSnapshotsDiff(
-			squashPgScheme(dryPg),
-			squashPgScheme(schema),
-			schemasResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			dryPg,
-			schema,
-		);
-
-		writeResult({
-			cur: schema,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder: out,
-			breakpoints,
-			type: 'introspect',
-			prefixMode: prefix,
-		});
-	} else {
-		render(
-			`[${
-				chalk.blue(
-					'i',
-				)
-			}] No SQL generated, you already have migrations in project`,
-		);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your relations file is ready ➜ ${
-			chalk.bold.underline.blue(
-				relationsFile,
-			)
-		} 🚀`,
-	);
-	process.exit(0);
-};
-
-export const introspectGel = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: GelCredentials | undefined,
-	tablesFilter: string[],
-	schemasFilter: string[],
-	prefix: Prefix,
-	entities: Entities,
-) => {
-	const { prepareGelDB } = await import('../connections');
-	const db = await prepareGelDB(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress(true);
-
-	const res = await renderWithTask(
-		progress,
-		fromGelDatabase(
-			db,
-			filter,
-			schemasFilter,
-			entities,
-			(stage, count, status) => {
-				progress.update(stage, count, status);
-			},
-		),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as GelSchema;
-	const ts = gelSchemaToTypeScript(schema, casing);
-	const relationsTs = relationsToTypeScript(schema, casing);
-	const { internal, ...schemaWithoutInternals } = schema;
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	const relationsFile = join(out, 'relations.ts');
-	writeFileSync(relationsFile, relationsTs.file);
-	console.log();
-
-	// const { snapshots, journal } = prepareOutFolder(out, 'gel');
-
-	// if (snapshots.length === 0) {
-	// 	const { sqlStatements, _meta } = await applyGelSnapshotsDiff(
-	// 		squashGelScheme(dryGel),
-	// 		squashGelScheme(schema),
-	// 		schemasResolver,
-	// 		enumsResolver,
-	// 		sequencesResolver,
-	// 		policyResolver,
-	// 		indPolicyResolver,
-	// 		roleResolver,
-	// 		tablesResolver,
-	// 		columnsResolver,
-	// 		viewsResolver,
-	// 		dryPg,
-	// 		schema,
-	// 	);
-
-	// 	writeResult({
-	// 		cur: schema,
-	// 		sqlStatements,
-	// 		journal,
-	// 		_meta,
-	// 		outFolder: out,
-	// 		breakpoints,
-	// 		type: 'introspect',
-	// 		prefixMode: prefix,
-	// 	});
-	// } else {
-	// 	render(
-	// 		`[${
-	// 			chalk.blue(
-	// 				'i',
-	// 			)
-	// 		}] No SQL generated, you already have migrations in project`,
-	// 	);
-	// }
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your relations file is ready ➜ ${
-			chalk.bold.underline.blue(
-				relationsFile,
-			)
-		} 🚀`,
-	);
-	process.exit(0);
-};
-
-export const introspectMysql = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: MysqlCredentials,
-	tablesFilter: string[],
-	prefix: Prefix,
-) => {
-	const { connectToMySQL } = await import('../connections');
-	const { db, database } = await connectToMySQL(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress();
-	const res = await renderWithTask(
-		progress,
-		fromMysqlDatabase(db, database, filter, (stage, count, status) => {
-			progress.update(stage, count, status);
-		}),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as MySqlSchema;
-	const ts = mysqlSchemaToTypeScript(schema, casing);
-	const relationsTs = relationsToTypeScript(schema, casing);
-	const { internal, ...schemaWithoutInternals } = schema;
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	const relationsFile = join(out, 'relations.ts');
-	writeFileSync(relationsFile, relationsTs.file);
-	console.log();
-
-	const { snapshots, journal } = prepareOutFolder(out, 'mysql');
-
-	if (snapshots.length === 0) {
-		const { sqlStatements, _meta } = await applyMysqlSnapshotsDiff(
-			squashMysqlScheme(dryMySql),
-			squashMysqlScheme(schema),
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			dryMySql,
-			schema,
-		);
-
-		writeResult({
-			cur: schema,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder: out,
-			breakpoints,
-			type: 'introspect',
-			prefixMode: prefix,
-		});
-	} else {
-		render(
-			`[${
-				chalk.blue(
-					'i',
-				)
-			}] No SQL generated, you already have migrations in project`,
-		);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your relations file is ready ➜ ${
-			chalk.bold.underline.blue(
-				relationsFile,
-			)
-		} 🚀`,
-	);
-	process.exit(0);
-};
-
-export const introspectSingleStore = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: SingleStoreCredentials,
-	tablesFilter: string[],
-	prefix: Prefix,
-) => {
-	const { connectToSingleStore } = await import('../connections');
-	const { db, database } = await connectToSingleStore(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress();
-	const res = await renderWithTask(
-		progress,
-		fromSingleStoreDatabase(db, database, filter, (stage, count, status) => {
-			progress.update(stage, count, status);
-		}),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as SingleStoreSchema;
-	const ts = singlestoreSchemaToTypeScript(schema, casing);
-	const { internal, ...schemaWithoutInternals } = schema;
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	console.log();
-
-	const { snapshots, journal } = prepareOutFolder(out, 'postgresql');
-
-	if (snapshots.length === 0) {
-		const { sqlStatements, _meta } = await applySingleStoreSnapshotsDiff(
-			squashSingleStoreScheme(drySingleStore),
-			squashSingleStoreScheme(schema),
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			drySingleStore,
-			schema,
-		);
-
-		writeResult({
-			cur: schema,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder: out,
-			breakpoints,
-			type: 'introspect',
-			prefixMode: prefix,
-		});
-	} else {
-		render(
-			`[${
-				chalk.blue(
-					'i',
-				)
-			}] No SQL generated, you already have migrations in project`,
-		);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] You schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	process.exit(0);
-};
-
-export const introspectSqlite = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: SqliteCredentials,
-	tablesFilter: string[],
-	prefix: Prefix,
-) => {
-	const { connectToSQLite } = await import('../connections');
-	const db = await connectToSQLite(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress();
-	const res = await renderWithTask(
-		progress,
-		fromSqliteDatabase(db, filter, (stage, count, status) => {
-			progress.update(stage, count, status);
-		}),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as SQLiteSchema;
-	const ts = sqliteSchemaToTypeScript(schema, casing);
-	const relationsTs = relationsToTypeScript(schema, casing);
-
-	// check orm and orm-pg api version
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	const relationsFile = join(out, 'relations.ts');
-	writeFileSync(relationsFile, relationsTs.file);
-	console.log();
-
-	const { snapshots, journal } = prepareOutFolder(out, 'sqlite');
-
-	if (snapshots.length === 0) {
-		const { sqlStatements, _meta } = await applySqliteSnapshotsDiff(
-			squashSqliteScheme(drySQLite),
-			squashSqliteScheme(schema),
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			drySQLite,
-			schema,
-		);
-
-		writeResult({
-			cur: schema,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder: out,
-			breakpoints,
-			type: 'introspect',
-			prefixMode: prefix,
-		});
-	} else {
-		render(
-			`[${
-				chalk.blue(
-					'i',
-				)
-			}] No SQL generated, you already have migrations in project`,
-		);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] You schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] You relations file is ready ➜ ${
-			chalk.bold.underline.blue(
-				relationsFile,
-			)
-		} 🚀`,
-	);
-	process.exit(0);
-};
-
-export const introspectLibSQL = async (
-	casing: Casing,
-	out: string,
-	breakpoints: boolean,
-	credentials: LibSQLCredentials,
-	tablesFilter: string[],
-	prefix: Prefix,
-) => {
-	const { connectToLibSQL } = await import('../connections');
-	const db = await connectToLibSQL(credentials);
-
-	const matchers = tablesFilter.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress();
-	const res = await renderWithTask(
-		progress,
-		fromSqliteDatabase(db, filter, (stage, count, status) => {
-			progress.update(stage, count, status);
-		}),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as SQLiteSchema;
-	const ts = sqliteSchemaToTypeScript(schema, casing);
-	const relationsTs = relationsToTypeScript(schema, casing);
-
-	// check orm and orm-pg api version
-
-	const schemaFile = join(out, 'schema.ts');
-	writeFileSync(schemaFile, ts.file);
-	const relationsFile = join(out, 'relations.ts');
-	writeFileSync(relationsFile, relationsTs.file);
-	console.log();
-
-	const { snapshots, journal } = prepareOutFolder(out, 'sqlite');
-
-	if (snapshots.length === 0) {
-		const { sqlStatements, _meta } = await applyLibSQLSnapshotsDiff(
-			squashSqliteScheme(drySQLite),
-			squashSqliteScheme(schema),
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			drySQLite,
-			schema,
-		);
-
-		writeResult({
-			cur: schema,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder: out,
-			breakpoints,
-			type: 'introspect',
-			prefixMode: prefix,
-		});
-	} else {
-		render(
-			`[${
-				chalk.blue(
-					'i',
-				)
-			}] No SQL generated, you already have migrations in project`,
-		);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
-	);
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your relations file is ready ➜ ${
-			chalk.bold.underline.blue(
-				relationsFile,
-			)
-		} 🚀`,
-	);
-	process.exit(0);
-};
-
-const withCasing = (value: string, casing: Casing) => {
-	if (casing === 'preserve') {
-		return value;
-	}
-	if (casing === 'camel') {
-		return value.camelCase();
-	}
-
-	assertUnreachable(casing);
-};
-
-export const relationsToTypeScript = (
-	schema: {
-		tables: Record<
-			string,
-			{
-				schema?: string;
-				foreignKeys: Record<
-					string,
-					{
-						name: string;
-						tableFrom: string;
-						columnsFrom: string[];
-						tableTo: string;
-						schemaTo?: string;
-						columnsTo: string[];
-						onUpdate?: string | undefined;
-						onDelete?: string | undefined;
-					}
-				>;
-			}
-		>;
-	},
-	casing: Casing,
-) => {
-	const imports: string[] = [];
-	const tableRelations: Record<
-		string,
-		{
-			name: string;
-			type: 'one' | 'many';
-			tableFrom: string;
-			schemaFrom?: string;
-			columnFrom: string;
-			tableTo: string;
-			schemaTo?: string;
-			columnTo: string;
-			relationName?: string;
-		}[]
-	> = {};
-
-	Object.values(schema.tables).forEach((table) => {
-		Object.values(table.foreignKeys).forEach((fk) => {
-			const tableNameFrom = paramNameFor(fk.tableFrom, table.schema);
-			const tableNameTo = paramNameFor(fk.tableTo, fk.schemaTo);
-			const tableFrom = withCasing(tableNameFrom.replace(/:+/g, ''), casing);
-			const tableTo = withCasing(tableNameTo.replace(/:+/g, ''), casing);
-			const columnFrom = withCasing(fk.columnsFrom[0], casing);
-			const columnTo = withCasing(fk.columnsTo[0], casing);
-
-			imports.push(tableTo, tableFrom);
-
-			// const keyFrom = `${schemaFrom}.${tableFrom}`;
-			const keyFrom = tableFrom;
-
-			if (!tableRelations[keyFrom]) {
-				tableRelations[keyFrom] = [];
-			}
-
-			tableRelations[keyFrom].push({
-				name: singular(tableTo),
-				type: 'one',
-				tableFrom,
-				columnFrom,
-				tableTo,
-				columnTo,
-			});
-
-			// const keyTo = `${schemaTo}.${tableTo}`;
-			const keyTo = tableTo;
-
-			if (!tableRelations[keyTo]) {
-				tableRelations[keyTo] = [];
-			}
-
-			tableRelations[keyTo].push({
-				name: plural(tableFrom),
-				type: 'many',
-				tableFrom: tableTo,
-				columnFrom: columnTo,
-				tableTo: tableFrom,
-				columnTo: columnFrom,
-			});
-		});
-	});
-
-	const uniqueImports = [...new Set(imports)];
-
-	const importsTs = `import { relations } from "drizzle-orm/relations";\nimport { ${
-		uniqueImports.join(
-			', ',
-		)
-	} } from "./schema";\n\n`;
-
-	const relationStatements = Object.entries(tableRelations).map(
-		([table, relations]) => {
-			const hasOne = relations.some((it) => it.type === 'one');
-			const hasMany = relations.some((it) => it.type === 'many');
-
-			// * change relation names if they are duplicated or if there are multiple relations between two tables
-			const preparedRelations = relations.map(
-				(relation, relationIndex, originArray) => {
-					let name = relation.name;
-					let relationName;
-					const hasMultipleRelations = originArray.some(
-						(it, originIndex) => relationIndex !== originIndex && it.tableTo === relation.tableTo,
-					);
-					if (hasMultipleRelations) {
-						relationName = relation.type === 'one'
-							? `${relation.tableFrom}_${relation.columnFrom}_${relation.tableTo}_${relation.columnTo}`
-							: `${relation.tableTo}_${relation.columnTo}_${relation.tableFrom}_${relation.columnFrom}`;
-					}
-					const hasDuplicatedRelation = originArray.some(
-						(it, originIndex) => relationIndex !== originIndex && it.name === relation.name,
-					);
-					if (hasDuplicatedRelation) {
-						name = `${relation.name}_${relation.type === 'one' ? relation.columnFrom : relation.columnTo}`;
-					}
-					return {
-						...relation,
-						name,
-						relationName,
-					};
-				},
-			);
-
-			const fields = preparedRelations.map((relation) => {
-				if (relation.type === 'one') {
-					return `\t${relation.name}: one(${relation.tableTo}, {\n\t\tfields: [${relation.tableFrom}.${relation.columnFrom}],\n\t\treferences: [${relation.tableTo}.${relation.columnTo}]${
-						relation.relationName
-							? `,\n\t\trelationName: "${relation.relationName}"`
-							: ''
-					}\n\t}),`;
-				} else {
-					return `\t${relation.name}: many(${relation.tableTo}${
-						relation.relationName
-							? `, {\n\t\trelationName: "${relation.relationName}"\n\t}`
-							: ''
-					}),`;
-				}
-			});
-
-			return `export const ${table}Relations = relations(${table}, ({${hasOne ? 'one' : ''}${
-				hasOne && hasMany ? ', ' : ''
-			}${hasMany ? 'many' : ''}}) => ({\n${fields.join('\n')}\n}));`;
-		},
-	);
-
-	return {
-		file: importsTs + relationStatements.join('\n\n'),
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/libSqlPushUtils.ts b/drizzle-kit/src/cli/commands/libSqlPushUtils.ts
deleted file mode 100644
index 31e90c8722..0000000000
--- a/drizzle-kit/src/cli/commands/libSqlPushUtils.ts
+++ /dev/null
@@ -1,355 +0,0 @@
-import chalk from 'chalk';
-
-import { JsonStatement } from 'src/jsonStatements';
-import { findAddedAndRemoved, SQLiteDB } from 'src/utils';
-import { SQLiteSchemaInternal, SQLiteSchemaSquashed, SQLiteSquasher } from '../../serializer/sqliteSchema';
-import {
-	CreateSqliteIndexConvertor,
-	fromJson,
-	LibSQLModifyColumn,
-	SQLiteCreateTableConvertor,
-	SQLiteDropTableConvertor,
-	SqliteRenameTableConvertor,
-} from '../../sqlgenerator';
-
-export const getOldTableName = (
-	tableName: string,
-	meta: SQLiteSchemaInternal['_meta'],
-) => {
-	for (const key of Object.keys(meta.tables)) {
-		const value = meta.tables[key];
-		if (`"${tableName}"` === value) {
-			return key.substring(1, key.length - 1);
-		}
-	}
-	return tableName;
-};
-
-export const _moveDataStatements = (
-	tableName: string,
-	json: SQLiteSchemaSquashed,
-	dataLoss: boolean = false,
-) => {
-	const statements: string[] = [];
-
-	const newTableName = `__new_${tableName}`;
-
-	// create table statement from a new json2 with proper name
-	const tableColumns = Object.values(json.tables[tableName].columns);
-	const referenceData = Object.values(json.tables[tableName].foreignKeys);
-	const compositePKs = Object.values(
-		json.tables[tableName].compositePrimaryKeys,
-	).map((it) => SQLiteSquasher.unsquashPK(it));
-	const checkConstraints = Object.values(json.tables[tableName].checkConstraints);
-
-	const fks = referenceData.map((it) => SQLiteSquasher.unsquashPushFK(it));
-
-	const mappedCheckConstraints: string[] = checkConstraints.map((it) =>
-		it.replaceAll(`"${tableName}".`, `"${newTableName}".`)
-			.replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`)
-			.replaceAll(`${tableName}.`, `${newTableName}.`)
-			.replaceAll(`'${tableName}'.`, `\`${newTableName}\`.`)
-	);
-
-	// create new table
-	statements.push(
-		new SQLiteCreateTableConvertor().convert({
-			type: 'sqlite_create_table',
-			tableName: newTableName,
-			columns: tableColumns,
-			referenceData: fks,
-			compositePKs,
-			checkConstraints: mappedCheckConstraints,
-		}),
-	);
-
-	// move data
-	if (!dataLoss) {
-		const columns = Object.keys(json.tables[tableName].columns).map(
-			(c) => `"${c}"`,
-		);
-
-		statements.push(
-			`INSERT INTO \`${newTableName}\`(${
-				columns.join(
-					', ',
-				)
-			}) SELECT ${columns.join(', ')} FROM \`${tableName}\`;`,
-		);
-	}
-
-	statements.push(
-		new SQLiteDropTableConvertor().convert({
-			type: 'drop_table',
-			tableName: tableName,
-			schema: '',
-		}),
-	);
-
-	// rename table
-	statements.push(
-		new SqliteRenameTableConvertor().convert({
-			fromSchema: '',
-			tableNameFrom: newTableName,
-			tableNameTo: tableName,
-			toSchema: '',
-			type: 'rename_table',
-		}),
-	);
-
-	for (const idx of Object.values(json.tables[tableName].indexes)) {
-		statements.push(
-			new CreateSqliteIndexConvertor().convert({
-				type: 'create_index',
-				tableName: tableName,
-				schema: '',
-				data: idx,
-			}),
-		);
-	}
-	return statements;
-};
-
-export const libSqlLogSuggestionsAndReturn = async (
-	connection: SQLiteDB,
-	statements: JsonStatement[],
-	json1: SQLiteSchemaSquashed,
-	json2: SQLiteSchemaSquashed,
-	meta: SQLiteSchemaInternal['_meta'],
-) => {
-	let shouldAskForApprove = false;
-	const statementsToExecute: string[] = [];
-	const infoToPrint: string[] = [];
-
-	const tablesToRemove: string[] = [];
-	const columnsToRemove: string[] = [];
-	const tablesToTruncate: string[] = [];
-
-	for (const statement of statements) {
-		if (statement.type === 'drop_table') {
-			const res = await connection.query<{ count: string }>(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table with ${count} items`,
-				);
-				tablesToRemove.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-			const fromJsonStatement = fromJson([statement], 'turso', 'push', json2);
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (statement.type === 'alter_table_drop_column') {
-			const tableName = statement.tableName;
-
-			const res = await connection.query<{ count: string }>(
-				`select count(*) as count from \`${tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column in ${tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-
-			const fromJsonStatement = fromJson([statement], 'turso', 'push', json2);
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (
-			statement.type === 'sqlite_alter_table_add_column'
-			&& statement.column.notNull
-			&& !statement.column.default
-		) {
-			const newTableName = statement.tableName;
-			const res = await connection.query<{ count: string }>(
-				`select count(*) as count from \`${newTableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to add not-null ${
-						chalk.underline(
-							statement.column.name,
-						)
-					} column without default value, which contains ${count} items`,
-				);
-
-				tablesToTruncate.push(newTableName);
-				statementsToExecute.push(`delete from ${newTableName};`);
-
-				shouldAskForApprove = true;
-			}
-
-			const fromJsonStatement = fromJson([statement], 'turso', 'push', json2);
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
-			const tableName = statement.tableName;
-
-			if (
-				statement.type === 'alter_table_alter_column_set_notnull'
-				&& typeof statement.columnDefault === 'undefined'
-			) {
-				const res = await connection.query<{ count: string }>(
-					`select count(*) as count from \`${tableName}\``,
-				);
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to add not-null constraint to ${
-							chalk.underline(
-								statement.columnName,
-							)
-						} column without default value, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(tableName);
-					statementsToExecute.push(`delete from \`${tableName}\``);
-					shouldAskForApprove = true;
-				}
-			}
-
-			const modifyStatements = new LibSQLModifyColumn().convert(statement, json2);
-
-			statementsToExecute.push(
-				...(Array.isArray(modifyStatements) ? modifyStatements : [modifyStatements]),
-			);
-		} else if (statement.type === 'recreate_table') {
-			const tableName = statement.tableName;
-
-			let dataLoss = false;
-
-			const oldTableName = getOldTableName(tableName, meta);
-
-			const prevColumnNames = Object.keys(json1.tables[oldTableName].columns);
-			const currentColumnNames = Object.keys(json2.tables[tableName].columns);
-			const { removedColumns, addedColumns } = findAddedAndRemoved(
-				prevColumnNames,
-				currentColumnNames,
-			);
-
-			if (removedColumns.length) {
-				for (const removedColumn of removedColumns) {
-					const res = await connection.query<{ count: string }>(
-						`select count(\`${tableName}\`.\`${removedColumn}\`) as count from \`${tableName}\``,
-					);
-
-					const count = Number(res[0].count);
-					if (count > 0) {
-						infoToPrint.push(
-							`· You're about to delete ${
-								chalk.underline(
-									removedColumn,
-								)
-							} column in ${tableName} table with ${count} items`,
-						);
-						columnsToRemove.push(removedColumn);
-						shouldAskForApprove = true;
-					}
-				}
-			}
-
-			if (addedColumns.length) {
-				for (const addedColumn of addedColumns) {
-					const [res] = await connection.query<{ count: string }>(
-						`select count(*) as count from \`${tableName}\``,
-					);
-
-					const columnConf = json2.tables[tableName].columns[addedColumn];
-
-					const count = Number(res.count);
-					if (count > 0 && columnConf.notNull && !columnConf.default) {
-						dataLoss = true;
-
-						infoToPrint.push(
-							`· You're about to add not-null ${
-								chalk.underline(
-									addedColumn,
-								)
-							} column without default value to table, which contains ${count} items`,
-						);
-						shouldAskForApprove = true;
-						tablesToTruncate.push(tableName);
-
-						statementsToExecute.push(`DELETE FROM \`${tableName}\`;`);
-					}
-				}
-			}
-
-			// check if some tables referencing current for pragma
-			const tablesReferencingCurrent: string[] = [];
-
-			for (const table of Object.values(json2.tables)) {
-				const tablesRefs = Object.values(json2.tables[table.name].foreignKeys)
-					.filter((t) => SQLiteSquasher.unsquashPushFK(t).tableTo === tableName)
-					.map((it) => SQLiteSquasher.unsquashPushFK(it).tableFrom);
-
-				tablesReferencingCurrent.push(...tablesRefs);
-			}
-
-			if (!tablesReferencingCurrent.length) {
-				statementsToExecute.push(..._moveDataStatements(tableName, json2, dataLoss));
-				continue;
-			}
-
-			// recreate table
-			statementsToExecute.push(
-				..._moveDataStatements(tableName, json2, dataLoss),
-			);
-		} else if (
-			statement.type === 'alter_table_alter_column_set_generated'
-			|| statement.type === 'alter_table_alter_column_drop_generated'
-		) {
-			const tableName = statement.tableName;
-
-			const res = await connection.query<{ count: string }>(
-				`select count("${statement.columnName}") as count from \`${tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column in ${tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-			const fromJsonStatement = fromJson([statement], 'turso', 'push', json2);
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else {
-			const fromJsonStatement = fromJson([statement], 'turso', 'push', json2);
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		}
-	}
-
-	return {
-		statementsToExecute: [...new Set(statementsToExecute)],
-		shouldAskForApprove,
-		infoToPrint,
-		columnsToRemove: [...new Set(columnsToRemove)],
-		tablesToTruncate: [...new Set(tablesToTruncate)],
-		tablesToRemove: [...new Set(tablesToRemove)],
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/migrate.ts b/drizzle-kit/src/cli/commands/migrate.ts
deleted file mode 100644
index 707d2b6829..0000000000
--- a/drizzle-kit/src/cli/commands/migrate.ts
+++ /dev/null
@@ -1,1496 +0,0 @@
-import fs from 'fs';
-import {
-	prepareMySqlDbPushSnapshot,
-	prepareMySqlMigrationSnapshot,
-	preparePgDbPushSnapshot,
-	preparePgMigrationSnapshot,
-	prepareSingleStoreDbPushSnapshot,
-	prepareSingleStoreMigrationSnapshot,
-	prepareSQLiteDbPushSnapshot,
-	prepareSqliteMigrationSnapshot,
-} from '../../migrationPreparator';
-
-import chalk from 'chalk';
-import { render } from 'hanji';
-import path, { join } from 'path';
-import { SingleStoreSchema, singlestoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
-import { TypeOf } from 'zod';
-import type { CommonSchema } from '../../schemaValidator';
-import { MySqlSchema, mysqlSchema, squashMysqlScheme, ViewSquashed } from '../../serializer/mysqlSchema';
-import { PgSchema, pgSchema, Policy, Role, squashPgScheme, View } from '../../serializer/pgSchema';
-import { SQLiteSchema, sqliteSchema, squashSqliteScheme, View as SQLiteView } from '../../serializer/sqliteSchema';
-import {
-	applyLibSQLSnapshotsDiff,
-	applyMysqlSnapshotsDiff,
-	applyPgSnapshotsDiff,
-	applySingleStoreSnapshotsDiff,
-	applySqliteSnapshotsDiff,
-	Column,
-	ColumnsResolverInput,
-	ColumnsResolverOutput,
-	Enum,
-	PolicyResolverInput,
-	PolicyResolverOutput,
-	ResolverInput,
-	ResolverOutput,
-	ResolverOutputWithMoved,
-	RolesResolverInput,
-	RolesResolverOutput,
-	Sequence,
-	Table,
-	TablePolicyResolverInput,
-	TablePolicyResolverOutput,
-} from '../../snapshotsDiffer';
-import { assertV1OutFolder, Journal, prepareMigrationFolder } from '../../utils';
-import { prepareMigrationMetadata } from '../../utils/words';
-import { CasingType, Driver, Prefix } from '../validations/common';
-import { withStyle } from '../validations/outputs';
-import {
-	isRenamePromptItem,
-	RenamePropmtItem,
-	ResolveColumnSelect,
-	ResolveSchemasSelect,
-	ResolveSelect,
-	ResolveSelectNamed,
-	schema,
-} from '../views';
-import { ExportConfig, GenerateConfig } from './utils';
-
-export type Named = {
-	name: string;
-};
-
-export type NamedWithSchema = {
-	name: string;
-	schema: string;
-};
-
-export const schemasResolver = async (
-	input: ResolverInput<Named>,
-): Promise<ResolverOutput<Named>> => {
-	try {
-		const { created, deleted, renamed } = await promptSchemasConflict(
-			input.created,
-			input.deleted,
-		);
-
-		return { created: created, deleted: deleted, renamed: renamed };
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const tablesResolver = async (
-	input: ResolverInput<Table>,
-): Promise<ResolverOutputWithMoved<Table>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'table',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const viewsResolver = async (
-	input: ResolverInput<View>,
-): Promise<ResolverOutputWithMoved<View>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'view',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const mySqlViewsResolver = async (
-	input: ResolverInput<ViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'view',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-/* export const singleStoreViewsResolver = async (
-	input: ResolverInput<SingleStoreViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<SingleStoreViewSquashed>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'view',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-}; */
-
-export const sqliteViewsResolver = async (
-	input: ResolverInput<SQLiteView & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<SQLiteView>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'view',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const sequencesResolver = async (
-	input: ResolverInput<Sequence>,
-): Promise<ResolverOutputWithMoved<Sequence>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'sequence',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const roleResolver = async (
-	input: RolesResolverInput<Role>,
-): Promise<RolesResolverOutput<Role>> => {
-	const result = await promptNamedConflict(
-		input.created,
-		input.deleted,
-		'role',
-	);
-	return {
-		created: result.created,
-		deleted: result.deleted,
-		renamed: result.renamed,
-	};
-};
-
-export const policyResolver = async (
-	input: TablePolicyResolverInput<Policy>,
-): Promise<TablePolicyResolverOutput<Policy>> => {
-	const result = await promptColumnsConflicts(
-		input.tableName,
-		input.created,
-		input.deleted,
-	);
-	return {
-		tableName: input.tableName,
-		schema: input.schema,
-		created: result.created,
-		deleted: result.deleted,
-		renamed: result.renamed,
-	};
-};
-
-export const indPolicyResolver = async (
-	input: PolicyResolverInput<Policy>,
-): Promise<PolicyResolverOutput<Policy>> => {
-	const result = await promptNamedConflict(input.created, input.deleted, 'policy');
-	return {
-		created: result.created,
-		deleted: result.deleted,
-		renamed: result.renamed,
-	};
-};
-
-export const enumsResolver = async (
-	input: ResolverInput<Enum>,
-): Promise<ResolverOutputWithMoved<Enum>> => {
-	try {
-		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
-			input.created,
-			input.deleted,
-			'enum',
-		);
-
-		return {
-			created: created,
-			deleted: deleted,
-			moved: moved,
-			renamed: renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const columnsResolver = async (
-	input: ColumnsResolverInput<Column>,
-): Promise<ColumnsResolverOutput<Column>> => {
-	const result = await promptColumnsConflicts(
-		input.tableName,
-		input.created,
-		input.deleted,
-	);
-	return {
-		tableName: input.tableName,
-		schema: input.schema,
-		created: result.created,
-		deleted: result.deleted,
-		renamed: result.renamed,
-	};
-};
-
-export const prepareAndMigratePg = async (config: GenerateConfig) => {
-	const outFolder = config.out;
-	const schemaPath = config.schema;
-	const casing = config.casing;
-
-	try {
-		assertV1OutFolder(outFolder);
-
-		const { snapshots, journal } = prepareMigrationFolder(
-			outFolder,
-			'postgresql',
-		);
-
-		const { prev, cur, custom } = await preparePgMigrationSnapshot(
-			snapshots,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = pgSchema.parse(prev);
-		const validatedCur = pgSchema.parse(cur);
-
-		if (config.custom) {
-			writeResult({
-				cur: custom,
-				sqlStatements: [],
-				journal,
-				outFolder,
-				name: config.name,
-				breakpoints: config.breakpoints,
-				type: 'custom',
-				prefixMode: config.prefix,
-			});
-			return;
-		}
-
-		const squashedPrev = squashPgScheme(validatedPrev);
-		const squashedCur = squashPgScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applyPgSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			schemasResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		writeResult({
-			cur,
-			sqlStatements,
-			journal,
-			outFolder,
-			name: config.name,
-			breakpoints: config.breakpoints,
-			prefixMode: config.prefix,
-		});
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndExportPg = async (config: ExportConfig) => {
-	const schemaPath = config.schema;
-
-	try {
-		const { prev, cur } = await preparePgMigrationSnapshot(
-			[], // no snapshots before
-			schemaPath,
-			undefined,
-		);
-
-		const validatedPrev = pgSchema.parse(prev);
-		const validatedCur = pgSchema.parse(cur);
-
-		const squashedPrev = squashPgScheme(validatedPrev);
-		const squashedCur = squashPgScheme(validatedCur);
-
-		const { sqlStatements } = await applyPgSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			schemasResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		console.log(sqlStatements.join('\n'));
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const preparePgPush = async (
-	cur: PgSchema,
-	prev: PgSchema,
-) => {
-	const validatedPrev = pgSchema.parse(prev);
-	const validatedCur = pgSchema.parse(cur);
-
-	const squashedPrev = squashPgScheme(validatedPrev, 'push');
-	const squashedCur = squashPgScheme(validatedCur, 'push');
-
-	const { sqlStatements, statements, _meta } = await applyPgSnapshotsDiff(
-		squashedPrev,
-		squashedCur,
-		schemasResolver,
-		enumsResolver,
-		sequencesResolver,
-		policyResolver,
-		indPolicyResolver,
-		roleResolver,
-		tablesResolver,
-		columnsResolver,
-		viewsResolver,
-		validatedPrev,
-		validatedCur,
-		'push',
-	);
-
-	return { sqlStatements, statements, squashedPrev, squashedCur };
-};
-
-// Not needed for now
-function mysqlSchemaSuggestions(
-	curSchema: TypeOf<typeof mysqlSchema>,
-	prevSchema: TypeOf<typeof mysqlSchema>,
-) {
-	const suggestions: string[] = [];
-	const usedSuggestions: string[] = [];
-	const suggestionTypes = {
-		serial: withStyle.errorWarning(
-			`We deprecated the use of 'serial' for MySQL starting from version 0.20.0. In MySQL, 'serial' is simply an alias for 'bigint unsigned not null auto_increment unique,' which creates all constraints and indexes for you. This may make the process less explicit for both users and drizzle-kit push commands`,
-		),
-	};
-
-	for (const table of Object.values(curSchema.tables)) {
-		for (const column of Object.values(table.columns)) {
-			if (column.type === 'serial') {
-				if (!usedSuggestions.includes('serial')) {
-					suggestions.push(suggestionTypes['serial']);
-				}
-
-				const uniqueForSerial = Object.values(
-					prevSchema.tables[table.name].uniqueConstraints,
-				).find((it) => it.columns[0] === column.name);
-
-				suggestions.push(
-					`\n`
-						+ withStyle.suggestion(
-							`We are suggesting to change ${
-								chalk.blue(
-									column.name,
-								)
-							} column in ${
-								chalk.blueBright(
-									table.name,
-								)
-							} table from serial to bigint unsigned\n\n${
-								chalk.blueBright(
-									`bigint("${column.name}", { mode: "number", unsigned: true }).notNull().autoincrement().unique(${
-										uniqueForSerial?.name ? `"${uniqueForSerial?.name}"` : ''
-									})`,
-								)
-							}`,
-						),
-				);
-			}
-		}
-	}
-
-	return suggestions;
-}
-
-// Intersect with prepareAnMigrate
-export const prepareMySQLPush = async (
-	schemaPath: string | string[],
-	snapshot: MySqlSchema,
-	casing: CasingType | undefined,
-) => {
-	try {
-		const { prev, cur } = await prepareMySqlDbPushSnapshot(
-			snapshot,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = mysqlSchema.parse(prev);
-		const validatedCur = mysqlSchema.parse(cur);
-
-		const squashedPrev = squashMysqlScheme(validatedPrev);
-		const squashedCur = squashMysqlScheme(validatedCur);
-
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		return { sqlStatements, statements, validatedCur, validatedPrev };
-	} catch (e) {
-		console.error(e);
-		process.exit(1);
-	}
-};
-
-export const prepareAndMigrateMysql = async (config: GenerateConfig) => {
-	const outFolder = config.out;
-	const schemaPath = config.schema;
-	const casing = config.casing;
-
-	try {
-		// TODO: remove
-		assertV1OutFolder(outFolder);
-
-		const { snapshots, journal } = prepareMigrationFolder(outFolder, 'mysql');
-		const { prev, cur, custom } = await prepareMySqlMigrationSnapshot(
-			snapshots,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = mysqlSchema.parse(prev);
-		const validatedCur = mysqlSchema.parse(cur);
-
-		if (config.custom) {
-			writeResult({
-				cur: custom,
-				sqlStatements: [],
-				journal,
-				outFolder,
-				name: config.name,
-				breakpoints: config.breakpoints,
-				type: 'custom',
-				prefixMode: config.prefix,
-			});
-			return;
-		}
-
-		const squashedPrev = squashMysqlScheme(validatedPrev);
-		const squashedCur = squashMysqlScheme(validatedCur);
-
-		const { sqlStatements, statements, _meta } = await applyMysqlSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		writeResult({
-			cur,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder,
-			name: config.name,
-			breakpoints: config.breakpoints,
-			prefixMode: config.prefix,
-		});
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-// Not needed for now
-function singleStoreSchemaSuggestions(
-	curSchema: TypeOf<typeof singlestoreSchema>,
-	prevSchema: TypeOf<typeof singlestoreSchema>,
-) {
-	const suggestions: string[] = [];
-	const usedSuggestions: string[] = [];
-	const suggestionTypes = {
-		// TODO: Check if SingleStore has serial type
-		serial: withStyle.errorWarning(
-			`We deprecated the use of 'serial' for SingleStore starting from version 0.20.0. In SingleStore, 'serial' is simply an alias for 'bigint unsigned not null auto_increment unique,' which creates all constraints and indexes for you. This may make the process less explicit for both users and drizzle-kit push commands`,
-		),
-	};
-
-	for (const table of Object.values(curSchema.tables)) {
-		for (const column of Object.values(table.columns)) {
-			if (column.type === 'serial') {
-				if (!usedSuggestions.includes('serial')) {
-					suggestions.push(suggestionTypes['serial']);
-				}
-
-				const uniqueForSerial = Object.values(
-					prevSchema.tables[table.name].uniqueConstraints,
-				).find((it) => it.columns[0] === column.name);
-
-				suggestions.push(
-					`\n`
-						+ withStyle.suggestion(
-							`We are suggesting to change ${
-								chalk.blue(
-									column.name,
-								)
-							} column in ${
-								chalk.blueBright(
-									table.name,
-								)
-							} table from serial to bigint unsigned\n\n${
-								chalk.blueBright(
-									`bigint("${column.name}", { mode: "number", unsigned: true }).notNull().autoincrement().unique(${
-										uniqueForSerial?.name ? `"${uniqueForSerial?.name}"` : ''
-									})`,
-								)
-							}`,
-						),
-				);
-			}
-		}
-	}
-
-	return suggestions;
-}
-
-// Intersect with prepareAnMigrate
-export const prepareSingleStorePush = async (
-	schemaPath: string | string[],
-	snapshot: SingleStoreSchema,
-	casing: CasingType | undefined,
-) => {
-	try {
-		const { prev, cur } = await prepareSingleStoreDbPushSnapshot(
-			snapshot,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = singlestoreSchema.parse(prev);
-		const validatedCur = singlestoreSchema.parse(cur);
-
-		const squashedPrev = squashSingleStoreScheme(validatedPrev);
-		const squashedCur = squashSingleStoreScheme(validatedCur);
-
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		return { sqlStatements, statements, validatedCur, validatedPrev };
-	} catch (e) {
-		console.error(e);
-		process.exit(1);
-	}
-};
-
-export const prepareAndMigrateSingleStore = async (config: GenerateConfig) => {
-	const outFolder = config.out;
-	const schemaPath = config.schema;
-	const casing = config.casing;
-
-	try {
-		// TODO: remove
-		assertV1OutFolder(outFolder);
-
-		const { snapshots, journal } = prepareMigrationFolder(outFolder, 'singlestore');
-		const { prev, cur, custom } = await prepareSingleStoreMigrationSnapshot(
-			snapshots,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = singlestoreSchema.parse(prev);
-		const validatedCur = singlestoreSchema.parse(cur);
-
-		if (config.custom) {
-			writeResult({
-				cur: custom,
-				sqlStatements: [],
-				journal,
-				outFolder,
-				name: config.name,
-				breakpoints: config.breakpoints,
-				type: 'custom',
-				prefixMode: config.prefix,
-			});
-			return;
-		}
-
-		const squashedPrev = squashSingleStoreScheme(validatedPrev);
-		const squashedCur = squashSingleStoreScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applySingleStoreSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			validatedPrev,
-			validatedCur,
-		);
-
-		writeResult({
-			cur,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder,
-			name: config.name,
-			breakpoints: config.breakpoints,
-			prefixMode: config.prefix,
-		});
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndExportSinglestore = async (config: ExportConfig) => {
-	const schemaPath = config.schema;
-
-	try {
-		const { prev, cur } = await prepareSingleStoreMigrationSnapshot(
-			[],
-			schemaPath,
-			undefined,
-		);
-
-		const validatedPrev = singlestoreSchema.parse(prev);
-		const validatedCur = singlestoreSchema.parse(cur);
-
-		const squashedPrev = squashSingleStoreScheme(validatedPrev);
-		const squashedCur = squashSingleStoreScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applySingleStoreSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			validatedPrev,
-			validatedCur,
-		);
-
-		console.log(sqlStatements.join('\n'));
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndExportMysql = async (config: ExportConfig) => {
-	const schemaPath = config.schema;
-
-	try {
-		const { prev, cur, custom } = await prepareMySqlMigrationSnapshot(
-			[],
-			schemaPath,
-			undefined,
-		);
-
-		const validatedPrev = mysqlSchema.parse(prev);
-		const validatedCur = mysqlSchema.parse(cur);
-
-		const squashedPrev = squashMysqlScheme(validatedPrev);
-		const squashedCur = squashMysqlScheme(validatedCur);
-
-		const { sqlStatements, statements, _meta } = await applyMysqlSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		console.log(sqlStatements.join('\n'));
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndMigrateSqlite = async (config: GenerateConfig) => {
-	const outFolder = config.out;
-	const schemaPath = config.schema;
-	const casing = config.casing;
-
-	try {
-		assertV1OutFolder(outFolder);
-
-		const { snapshots, journal } = prepareMigrationFolder(outFolder, 'sqlite');
-		const { prev, cur, custom } = await prepareSqliteMigrationSnapshot(
-			snapshots,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = sqliteSchema.parse(prev);
-		const validatedCur = sqliteSchema.parse(cur);
-
-		if (config.custom) {
-			writeResult({
-				cur: custom,
-				sqlStatements: [],
-				journal,
-				outFolder,
-				name: config.name,
-				breakpoints: config.breakpoints,
-				bundle: config.bundle,
-				type: 'custom',
-				prefixMode: config.prefix,
-			});
-			return;
-		}
-
-		const squashedPrev = squashSqliteScheme(validatedPrev);
-		const squashedCur = squashSqliteScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applySqliteSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		writeResult({
-			cur,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder,
-			name: config.name,
-			breakpoints: config.breakpoints,
-			bundle: config.bundle,
-			prefixMode: config.prefix,
-			driver: config.driver,
-		});
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndExportSqlite = async (config: ExportConfig) => {
-	const schemaPath = config.schema;
-
-	try {
-		const { prev, cur } = await prepareSqliteMigrationSnapshot(
-			[],
-			schemaPath,
-			undefined,
-		);
-
-		const validatedPrev = sqliteSchema.parse(prev);
-		const validatedCur = sqliteSchema.parse(cur);
-
-		const squashedPrev = squashSqliteScheme(validatedPrev);
-		const squashedCur = squashSqliteScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applySqliteSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		console.log(sqlStatements.join('\n'));
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndMigrateLibSQL = async (config: GenerateConfig) => {
-	const outFolder = config.out;
-	const schemaPath = config.schema;
-	const casing = config.casing;
-
-	try {
-		assertV1OutFolder(outFolder);
-
-		const { snapshots, journal } = prepareMigrationFolder(outFolder, 'sqlite');
-		const { prev, cur, custom } = await prepareSqliteMigrationSnapshot(
-			snapshots,
-			schemaPath,
-			casing,
-		);
-
-		const validatedPrev = sqliteSchema.parse(prev);
-		const validatedCur = sqliteSchema.parse(cur);
-
-		if (config.custom) {
-			writeResult({
-				cur: custom,
-				sqlStatements: [],
-				journal,
-				outFolder,
-				name: config.name,
-				breakpoints: config.breakpoints,
-				bundle: config.bundle,
-				type: 'custom',
-				prefixMode: config.prefix,
-			});
-			return;
-		}
-
-		const squashedPrev = squashSqliteScheme(validatedPrev);
-		const squashedCur = squashSqliteScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applyLibSQLSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		writeResult({
-			cur,
-			sqlStatements,
-			journal,
-			_meta,
-			outFolder,
-			name: config.name,
-			breakpoints: config.breakpoints,
-			bundle: config.bundle,
-			prefixMode: config.prefix,
-		});
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareAndExportLibSQL = async (config: ExportConfig) => {
-	const schemaPath = config.schema;
-
-	try {
-		const { prev, cur, custom } = await prepareSqliteMigrationSnapshot(
-			[],
-			schemaPath,
-			undefined,
-		);
-
-		const validatedPrev = sqliteSchema.parse(prev);
-		const validatedCur = sqliteSchema.parse(cur);
-
-		const squashedPrev = squashSqliteScheme(validatedPrev);
-		const squashedCur = squashSqliteScheme(validatedCur);
-
-		const { sqlStatements, _meta } = await applyLibSQLSnapshotsDiff(
-			squashedPrev,
-			squashedCur,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-
-		console.log(sqlStatements.join('\n'));
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const prepareSQLitePush = async (
-	schemaPath: string | string[],
-	snapshot: SQLiteSchema,
-	casing: CasingType | undefined,
-) => {
-	const { prev, cur } = await prepareSQLiteDbPushSnapshot(snapshot, schemaPath, casing);
-
-	const validatedPrev = sqliteSchema.parse(prev);
-	const validatedCur = sqliteSchema.parse(cur);
-
-	const squashedPrev = squashSqliteScheme(validatedPrev, 'push');
-	const squashedCur = squashSqliteScheme(validatedCur, 'push');
-
-	const { sqlStatements, statements, _meta } = await applySqliteSnapshotsDiff(
-		squashedPrev,
-		squashedCur,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		validatedPrev,
-		validatedCur,
-		'push',
-	);
-
-	return {
-		sqlStatements,
-		statements,
-		squashedPrev,
-		squashedCur,
-		meta: _meta,
-	};
-};
-
-export const prepareLibSQLPush = async (
-	schemaPath: string | string[],
-	snapshot: SQLiteSchema,
-	casing: CasingType | undefined,
-) => {
-	const { prev, cur } = await prepareSQLiteDbPushSnapshot(snapshot, schemaPath, casing);
-
-	const validatedPrev = sqliteSchema.parse(prev);
-	const validatedCur = sqliteSchema.parse(cur);
-
-	const squashedPrev = squashSqliteScheme(validatedPrev, 'push');
-	const squashedCur = squashSqliteScheme(validatedCur, 'push');
-
-	const { sqlStatements, statements, _meta } = await applyLibSQLSnapshotsDiff(
-		squashedPrev,
-		squashedCur,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		validatedPrev,
-		validatedCur,
-		'push',
-	);
-
-	return {
-		sqlStatements,
-		statements,
-		squashedPrev,
-		squashedCur,
-		meta: _meta,
-	};
-};
-
-const freeeeeeze = (obj: any) => {
-	Object.freeze(obj);
-	for (let key in obj) {
-		if (obj.hasOwnProperty(key) && typeof obj[key] === 'object') {
-			freeeeeeze(obj[key]);
-		}
-	}
-};
-
-export const promptColumnsConflicts = async <T extends Named>(
-	tableName: string,
-	newColumns: T[],
-	missingColumns: T[],
-) => {
-	if (newColumns.length === 0 || missingColumns.length === 0) {
-		return { created: newColumns, renamed: [], deleted: missingColumns };
-	}
-	const result: { created: T[]; renamed: { from: T; to: T }[]; deleted: T[] } = {
-		created: [],
-		renamed: [],
-		deleted: [],
-	};
-
-	let index = 0;
-	let leftMissing = [...missingColumns];
-
-	do {
-		const created = newColumns[index];
-
-		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
-			return { from: it, to: created };
-		});
-
-		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
-
-		const { status, data } = await render(
-			new ResolveColumnSelect<T>(tableName, created, promptData),
-		);
-		if (status === 'aborted') {
-			console.error('ERROR');
-			process.exit(1);
-		}
-
-		if (isRenamePromptItem(data)) {
-			console.log(
-				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
-					chalk.gray(
-						'column will be renamed',
-					)
-				}`,
-			);
-			result.renamed.push(data);
-			// this will make [item1, undefined, item2]
-			delete leftMissing[leftMissing.indexOf(data.from)];
-			// this will make [item1, item2]
-			leftMissing = leftMissing.filter(Boolean);
-		} else {
-			console.log(
-				`${chalk.green('+')} ${data.name} ${
-					chalk.gray(
-						'column will be created',
-					)
-				}`,
-			);
-			result.created.push(created);
-		}
-		index += 1;
-	} while (index < newColumns.length);
-	console.log(
-		chalk.gray(`--- all columns conflicts in ${tableName} table resolved ---\n`),
-	);
-
-	result.deleted.push(...leftMissing);
-	return result;
-};
-
-export const promptNamedConflict = async <T extends Named>(
-	newItems: T[],
-	missingItems: T[],
-	entity: 'role' | 'policy',
-): Promise<{
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}> => {
-	if (missingItems.length === 0 || newItems.length === 0) {
-		return {
-			created: newItems,
-			renamed: [],
-			deleted: missingItems,
-		};
-	}
-
-	const result: {
-		created: T[];
-		renamed: { from: T; to: T }[];
-		deleted: T[];
-	} = { created: [], renamed: [], deleted: [] };
-	let index = 0;
-	let leftMissing = [...missingItems];
-	do {
-		const created = newItems[index];
-		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
-			return { from: it, to: created };
-		});
-
-		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
-
-		const { status, data } = await render(
-			new ResolveSelectNamed<T>(created, promptData, entity),
-		);
-		if (status === 'aborted') {
-			console.error('ERROR');
-			process.exit(1);
-		}
-
-		if (isRenamePromptItem(data)) {
-			console.log(
-				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
-					chalk.gray(
-						`${entity} will be renamed/moved`,
-					)
-				}`,
-			);
-
-			if (data.from.name !== data.to.name) {
-				result.renamed.push(data);
-			}
-
-			delete leftMissing[leftMissing.indexOf(data.from)];
-			leftMissing = leftMissing.filter(Boolean);
-		} else {
-			console.log(
-				`${chalk.green('+')} ${data.name} ${
-					chalk.gray(
-						`${entity} will be created`,
-					)
-				}`,
-			);
-			result.created.push(created);
-		}
-		index += 1;
-	} while (index < newItems.length);
-	console.log(chalk.gray(`--- all ${entity} conflicts resolved ---\n`));
-	result.deleted.push(...leftMissing);
-	return result;
-};
-
-export const promptNamedWithSchemasConflict = async <T extends NamedWithSchema>(
-	newItems: T[],
-	missingItems: T[],
-	entity: 'table' | 'enum' | 'sequence' | 'view',
-): Promise<{
-	created: T[];
-	renamed: { from: T; to: T }[];
-	moved: { name: string; schemaFrom: string; schemaTo: string }[];
-	deleted: T[];
-}> => {
-	if (missingItems.length === 0 || newItems.length === 0) {
-		return {
-			created: newItems,
-			renamed: [],
-			moved: [],
-			deleted: missingItems,
-		};
-	}
-
-	const result: {
-		created: T[];
-		renamed: { from: T; to: T }[];
-		moved: { name: string; schemaFrom: string; schemaTo: string }[];
-		deleted: T[];
-	} = { created: [], renamed: [], moved: [], deleted: [] };
-	let index = 0;
-	let leftMissing = [...missingItems];
-	do {
-		const created = newItems[index];
-		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
-			return { from: it, to: created };
-		});
-
-		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
-
-		const { status, data } = await render(
-			new ResolveSelect<T>(created, promptData, entity),
-		);
-		if (status === 'aborted') {
-			console.error('ERROR');
-			process.exit(1);
-		}
-
-		if (isRenamePromptItem(data)) {
-			const schemaFromPrefix = !data.from.schema || data.from.schema === 'public'
-				? ''
-				: `${data.from.schema}.`;
-			const schemaToPrefix = !data.to.schema || data.to.schema === 'public'
-				? ''
-				: `${data.to.schema}.`;
-
-			console.log(
-				`${chalk.yellow('~')} ${schemaFromPrefix}${data.from.name} › ${schemaToPrefix}${data.to.name} ${
-					chalk.gray(
-						`${entity} will be renamed/moved`,
-					)
-				}`,
-			);
-
-			if (data.from.name !== data.to.name) {
-				result.renamed.push(data);
-			}
-
-			if (data.from.schema !== data.to.schema) {
-				result.moved.push({
-					name: data.from.name,
-					schemaFrom: data.from.schema || 'public',
-					schemaTo: data.to.schema || 'public',
-				});
-			}
-
-			delete leftMissing[leftMissing.indexOf(data.from)];
-			leftMissing = leftMissing.filter(Boolean);
-		} else {
-			console.log(
-				`${chalk.green('+')} ${data.name} ${
-					chalk.gray(
-						`${entity} will be created`,
-					)
-				}`,
-			);
-			result.created.push(created);
-		}
-		index += 1;
-	} while (index < newItems.length);
-	console.log(chalk.gray(`--- all ${entity} conflicts resolved ---\n`));
-	result.deleted.push(...leftMissing);
-	return result;
-};
-
-export const promptSchemasConflict = async <T extends Named>(
-	newSchemas: T[],
-	missingSchemas: T[],
-): Promise<{ created: T[]; renamed: { from: T; to: T }[]; deleted: T[] }> => {
-	if (missingSchemas.length === 0 || newSchemas.length === 0) {
-		return { created: newSchemas, renamed: [], deleted: missingSchemas };
-	}
-
-	const result: { created: T[]; renamed: { from: T; to: T }[]; deleted: T[] } = {
-		created: [],
-		renamed: [],
-		deleted: [],
-	};
-	let index = 0;
-	let leftMissing = [...missingSchemas];
-	do {
-		const created = newSchemas[index];
-		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
-			return { from: it, to: created };
-		});
-
-		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
-
-		const { status, data } = await render(
-			new ResolveSchemasSelect<T>(created, promptData),
-		);
-		if (status === 'aborted') {
-			console.error('ERROR');
-			process.exit(1);
-		}
-
-		if (isRenamePromptItem(data)) {
-			console.log(
-				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
-					chalk.gray(
-						'schema will be renamed',
-					)
-				}`,
-			);
-			result.renamed.push(data);
-			delete leftMissing[leftMissing.indexOf(data.from)];
-			leftMissing = leftMissing.filter(Boolean);
-		} else {
-			console.log(
-				`${chalk.green('+')} ${data.name} ${
-					chalk.gray(
-						'schema will be created',
-					)
-				}`,
-			);
-			result.created.push(created);
-		}
-		index += 1;
-	} while (index < newSchemas.length);
-	console.log(chalk.gray('--- all schemas conflicts resolved ---\n'));
-	result.deleted.push(...leftMissing);
-	return result;
-};
-
-export const BREAKPOINT = '--> statement-breakpoint\n';
-
-export const writeResult = ({
-	cur,
-	sqlStatements,
-	journal,
-	_meta = {
-		columns: {},
-		schemas: {},
-		tables: {},
-	},
-	outFolder,
-	breakpoints,
-	name,
-	bundle = false,
-	type = 'none',
-	prefixMode,
-	driver,
-}: {
-	cur: CommonSchema;
-	sqlStatements: string[];
-	journal: Journal;
-	_meta?: any;
-	outFolder: string;
-	breakpoints: boolean;
-	prefixMode: Prefix;
-	name?: string;
-	bundle?: boolean;
-	type?: 'introspect' | 'custom' | 'none';
-	driver?: Driver;
-}) => {
-	if (type === 'none') {
-		console.log(schema(cur));
-
-		if (sqlStatements.length === 0) {
-			console.log('No schema changes, nothing to migrate 😴');
-			return;
-		}
-	}
-
-	// append entry to _migrations.json
-	// append entry to _journal.json->entries
-	// dialect in _journal.json
-	// append sql file to out folder
-	// append snapshot file to meta folder
-	const lastEntryInJournal = journal.entries[journal.entries.length - 1];
-	const idx = typeof lastEntryInJournal === 'undefined' ? 0 : lastEntryInJournal.idx + 1;
-
-	const { prefix, tag } = prepareMigrationMetadata(idx, prefixMode, name);
-
-	const toSave = JSON.parse(JSON.stringify(cur));
-	toSave['_meta'] = _meta;
-
-	// todo: save results to a new migration folder
-	const metaFolderPath = join(outFolder, 'meta');
-	const metaJournal = join(metaFolderPath, '_journal.json');
-
-	fs.writeFileSync(
-		join(metaFolderPath, `${prefix}_snapshot.json`),
-		JSON.stringify(toSave, null, 2),
-	);
-
-	const sqlDelimiter = breakpoints ? BREAKPOINT : '\n';
-	let sql = sqlStatements.join(sqlDelimiter);
-
-	if (type === 'introspect') {
-		sql =
-			`-- Current sql file was generated after introspecting the database\n-- If you want to run this migration please uncomment this code before executing migrations\n/*\n${sql}\n*/`;
-	}
-
-	if (type === 'custom') {
-		console.log('Prepared empty file for your custom SQL migration!');
-		sql = '-- Custom SQL migration file, put your code below! --';
-	}
-
-	journal.entries.push({
-		idx,
-		version: cur.version,
-		when: +new Date(),
-		tag,
-		breakpoints: breakpoints,
-	});
-
-	fs.writeFileSync(metaJournal, JSON.stringify(journal, null, 2));
-
-	fs.writeFileSync(`${outFolder}/${tag}.sql`, sql);
-
-	// js file with .sql imports for React Native / Expo and Durable Sqlite Objects
-	if (bundle) {
-		const js = embeddedMigrations(journal, driver);
-		fs.writeFileSync(`${outFolder}/migrations.js`, js);
-	}
-
-	render(
-		`[${
-			chalk.green(
-				'✓',
-			)
-		}] Your SQL migration file ➜ ${
-			chalk.bold.underline.blue(
-				path.join(`${outFolder}/${tag}.sql`),
-			)
-		} 🚀`,
-	);
-};
-
-export const embeddedMigrations = (journal: Journal, driver?: Driver) => {
-	let content = driver === 'expo'
-		? '// This file is required for Expo/React Native SQLite migrations - https://orm.drizzle.team/quick-sqlite/expo\n\n'
-		: '';
-
-	content += "import journal from './meta/_journal.json';\n";
-	journal.entries.forEach((entry) => {
-		content += `import m${entry.idx.toString().padStart(4, '0')} from './${entry.tag}.sql';\n`;
-	});
-
-	content += `
-  export default {
-    journal,
-    migrations: {
-      ${
-		journal.entries
-			.map((it) => `m${it.idx.toString().padStart(4, '0')}`)
-			.join(',\n')
-	}
-    }
-  }
-  `;
-	return content;
-};
-
-export const prepareSnapshotFolderName = () => {
-	const now = new Date();
-	return `${now.getFullYear()}${two(now.getUTCMonth() + 1)}${
-		two(
-			now.getUTCDate(),
-		)
-	}${two(now.getUTCHours())}${two(now.getUTCMinutes())}${
-		two(
-			now.getUTCSeconds(),
-		)
-	}`;
-};
-
-const two = (input: number): string => {
-	return input.toString().padStart(2, '0');
-};
diff --git a/drizzle-kit/src/cli/commands/mysqlIntrospect.ts b/drizzle-kit/src/cli/commands/mysqlIntrospect.ts
deleted file mode 100644
index f0132be647..0000000000
--- a/drizzle-kit/src/cli/commands/mysqlIntrospect.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { renderWithTask } from 'hanji';
-import { Minimatch } from 'minimatch';
-import { originUUID } from '../../global';
-import type { MySqlSchema } from '../../serializer/mysqlSchema';
-import { fromDatabase } from '../../serializer/mysqlSerializer';
-import type { DB } from '../../utils';
-import { ProgressView } from '../views';
-
-export const mysqlPushIntrospect = async (
-	db: DB,
-	databaseName: string,
-	filters: string[],
-) => {
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new ProgressView(
-		'Pulling schema from database...',
-		'Pulling schema from database...',
-	);
-	const res = await renderWithTask(
-		progress,
-		fromDatabase(db, databaseName, filter),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as MySqlSchema;
-	const { internal, ...schemaWithoutInternals } = schema;
-	return { schema: schemaWithoutInternals };
-};
diff --git a/drizzle-kit/src/cli/commands/mysqlPushUtils.ts b/drizzle-kit/src/cli/commands/mysqlPushUtils.ts
deleted file mode 100644
index db1134e63b..0000000000
--- a/drizzle-kit/src/cli/commands/mysqlPushUtils.ts
+++ /dev/null
@@ -1,352 +0,0 @@
-import chalk from 'chalk';
-import { render } from 'hanji';
-import { TypeOf } from 'zod';
-import { JsonAlterColumnTypeStatement, JsonStatement } from '../../jsonStatements';
-import { mysqlSchema, MySqlSquasher } from '../../serializer/mysqlSchema';
-import type { DB } from '../../utils';
-import { Select } from '../selector-ui';
-import { withStyle } from '../validations/outputs';
-
-export const filterStatements = (
-	statements: JsonStatement[],
-	currentSchema: TypeOf<typeof mysqlSchema>,
-	prevSchema: TypeOf<typeof mysqlSchema>,
-) => {
-	return statements.filter((statement) => {
-		if (statement.type === 'alter_table_alter_column_set_type') {
-			// Don't need to handle it on migrations step and introspection
-			// but for both it should be skipped
-			if (
-				statement.oldDataType.startsWith('tinyint')
-				&& statement.newDataType.startsWith('boolean')
-			) {
-				return false;
-			}
-
-			if (
-				statement.oldDataType.startsWith('bigint unsigned')
-				&& statement.newDataType.startsWith('serial')
-			) {
-				return false;
-			}
-
-			if (
-				statement.oldDataType.startsWith('serial')
-				&& statement.newDataType.startsWith('bigint unsigned')
-			) {
-				return false;
-			}
-		} else if (statement.type === 'alter_table_alter_column_set_default') {
-			if (
-				statement.newDefaultValue === false
-				&& statement.oldDefaultValue === 0
-				&& statement.newDataType === 'boolean'
-			) {
-				return false;
-			}
-			if (
-				statement.newDefaultValue === true
-				&& statement.oldDefaultValue === 1
-				&& statement.newDataType === 'boolean'
-			) {
-				return false;
-			}
-		} else if (statement.type === 'delete_unique_constraint') {
-			const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
-			// only if constraint was removed from a serial column, than treat it as removed
-			// const serialStatement = statements.find(
-			//   (it) => it.type === "alter_table_alter_column_set_type"
-			// ) as JsonAlterColumnTypeStatement;
-			// if (
-			//   serialStatement?.oldDataType.startsWith("bigint unsigned") &&
-			//   serialStatement?.newDataType.startsWith("serial") &&
-			//   serialStatement.columnName ===
-			//     MySqlSquasher.unsquashUnique(statement.data).columns[0]
-			// ) {
-			//   return false;
-			// }
-			// Check if uniqueindex was only on this column, that is serial
-
-			// if now serial and was not serial and was unique index
-			if (
-				unsquashed.columns.length === 1
-				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.type === 'serial'
-				&& prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.type === 'serial'
-				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.name === unsquashed.columns[0]
-			) {
-				return false;
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_notnull') {
-			// only if constraint was removed from a serial column, than treat it as removed
-			const serialStatement = statements.find(
-				(it) => it.type === 'alter_table_alter_column_set_type',
-			) as JsonAlterColumnTypeStatement;
-			if (
-				serialStatement?.oldDataType.startsWith('bigint unsigned')
-				&& serialStatement?.newDataType.startsWith('serial')
-				&& serialStatement.columnName === statement.columnName
-				&& serialStatement.tableName === statement.tableName
-			) {
-				return false;
-			}
-			if (statement.newDataType === 'serial' && !statement.columnNotNull) {
-				return false;
-			}
-			if (statement.columnAutoIncrement) {
-				return false;
-			}
-		}
-
-		return true;
-	});
-};
-
-export const logSuggestionsAndReturn = async (
-	db: DB,
-	statements: JsonStatement[],
-	json2: TypeOf<typeof mysqlSchema>,
-) => {
-	let shouldAskForApprove = false;
-	const statementsToExecute: string[] = [];
-	const infoToPrint: string[] = [];
-
-	const tablesToRemove: string[] = [];
-	const columnsToRemove: string[] = [];
-	const schemasToRemove: string[] = [];
-	const tablesToTruncate: string[] = [];
-
-	for (const statement of statements) {
-		if (statement.type === 'drop_table') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table with ${count} items`,
-				);
-				tablesToRemove.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_drop_column') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column in ${statement.tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'drop_schema') {
-			const res = await db.query(
-				`select count(*) as count from information_schema.tables where table_schema = \`${statement.name}\`;`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.name,
-						)
-					} schema with ${count} tables`,
-				);
-				schemasToRemove.push(statement.name);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_set_type') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column type from ${
-						chalk.underline(
-							statement.oldDataType,
-						)
-					} to ${chalk.underline(statement.newDataType)} with ${count} items`,
-				);
-				statementsToExecute.push(`truncate table ${statement.tableName};`);
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_default') {
-			if (statement.columnNotNull) {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to remove default value from ${
-							chalk.underline(
-								statement.columnName,
-							)
-						} not-null column with ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-			// shouldAskForApprove = true;
-		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
-			if (typeof statement.columnDefault === 'undefined') {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to set not-null constraint to ${
-							chalk.underline(
-								statement.columnName,
-							)
-						} column without default, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_pk') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-
-			// if drop pk and json2 has autoincrement in table -> exit process with error
-			if (
-				Object.values(json2.tables[statement.tableName].columns).filter(
-					(column) => column.autoincrement,
-				).length > 0
-			) {
-				console.log(
-					`${
-						withStyle.errorWarning(
-							`You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} primary key. This statements may fail and you table may left without primary key`,
-				);
-
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'delete_composite_pk') {
-			// if drop pk and json2 has autoincrement in table -> exit process with error
-			if (
-				Object.values(json2.tables[statement.tableName].columns).filter(
-					(column) => column.autoincrement,
-				).length > 0
-			) {
-				console.log(
-					`${
-						withStyle.errorWarning(
-							`You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-		} else if (statement.type === 'alter_table_add_column') {
-			if (
-				statement.column.notNull
-				&& typeof statement.column.default === 'undefined'
-			) {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to add not-null ${
-							chalk.underline(
-								statement.column.name,
-							)
-						} column without default value, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'create_unique_constraint') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				const unsquashedUnique = MySqlSquasher.unsquashUnique(statement.data);
-				console.log(
-					`· You're about to add ${
-						chalk.underline(
-							unsquashedUnique.name,
-						)
-					} unique constraint to the table, which contains ${count} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table?\n`,
-				);
-				const { status, data } = await render(
-					new Select([
-						'No, add the constraint without truncating the table',
-						`Yes, truncate the table`,
-					]),
-				);
-				if (data?.index === 1) {
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-					shouldAskForApprove = true;
-				}
-			}
-		}
-	}
-
-	return {
-		statementsToExecute,
-		shouldAskForApprove,
-		infoToPrint,
-		columnsToRemove: [...new Set(columnsToRemove)],
-		schemasToRemove: [...new Set(schemasToRemove)],
-		tablesToTruncate: [...new Set(tablesToTruncate)],
-		tablesToRemove: [...new Set(tablesToRemove)],
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/mysqlUp.ts b/drizzle-kit/src/cli/commands/mysqlUp.ts
index 8b467090b6..7d21b03348 100644
--- a/drizzle-kit/src/cli/commands/mysqlUp.ts
+++ b/drizzle-kit/src/cli/commands/mysqlUp.ts
@@ -1,10 +1,30 @@
-import chalk from 'chalk';
-import fs, { writeFileSync } from 'fs';
-import path from 'path';
-import { Column, MySqlSchema, MySqlSchemaV4, MySqlSchemaV5, mysqlSchemaV5, Table } from '../../serializer/mysqlSchema';
-import { prepareOutFolder, validateWithReport } from '../../utils';
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { Column, MySqlSchemaV4, MySqlSchemaV5, Table } from '../../legacy/mysql-v5/mysqlSchema';
+import type { Journal } from '../../utils';
 
-export const upMysqlHandler = (out: string) => {};
+export const upMysqlHandler = (out: string) => {
+	// if there is meta folder - and there is a journal - it's version <8
+	const metaPath = join(out, 'meta');
+	const journalPath = join(metaPath, '_journal.json');
+	if (existsSync(metaPath) && existsSync(journalPath)) {
+		const journal: Journal = JSON.parse(readFileSync(journalPath).toString());
+		if (Number(journal.version) < 8) {
+			for (const entry of journal.entries) {
+				const snapshotPrefix = entry.tag.split('_')[0];
+				const oldSnapshot = readFileSync(join(metaPath, `${snapshotPrefix}_snapshot.json`));
+				const oldSql = readFileSync(join(out, `${entry.tag}.sql`));
+
+				writeFileSync(join(out, `${entry.tag}/snapshot.json`), oldSnapshot);
+				writeFileSync(join(out, `${entry.tag}/migration.sql`), oldSql);
+
+				unlinkSync(join(out, `${entry.tag}.sql`));
+			}
+
+			rmSync(metaPath);
+		}
+	}
+};
 
 export const upMySqlHandlerV4toV5 = (obj: MySqlSchemaV4): MySqlSchemaV5 => {
 	const mappedTables: Record<string, Table> = {};
diff --git a/drizzle-kit/src/cli/commands/pgIntrospect.ts b/drizzle-kit/src/cli/commands/pgIntrospect.ts
deleted file mode 100644
index 02867fae9f..0000000000
--- a/drizzle-kit/src/cli/commands/pgIntrospect.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { renderWithTask } from 'hanji';
-import { Minimatch } from 'minimatch';
-import { originUUID } from '../../global';
-import type { PgSchema, PgSchemaInternal } from '../../serializer/pgSchema';
-import { fromDatabase } from '../../serializer/pgSerializer';
-import type { DB } from '../../utils';
-import { Entities } from '../validations/cli';
-import { ProgressView } from '../views';
-
-export const pgPushIntrospect = async (
-	db: DB,
-	filters: string[],
-	schemaFilters: string[],
-	entities: Entities,
-	tsSchema?: PgSchemaInternal,
-) => {
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-	const progress = new ProgressView(
-		'Pulling schema from database...',
-		'Pulling schema from database...',
-	);
-	const res = await renderWithTask(
-		progress,
-		fromDatabase(db, filter, schemaFilters, entities, undefined, tsSchema),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as PgSchema;
-	const { internal, ...schemaWithoutInternals } = schema;
-	return { schema: schemaWithoutInternals };
-};
diff --git a/drizzle-kit/src/cli/commands/pgPushUtils.ts b/drizzle-kit/src/cli/commands/pgPushUtils.ts
deleted file mode 100644
index f59935304d..0000000000
--- a/drizzle-kit/src/cli/commands/pgPushUtils.ts
+++ /dev/null
@@ -1,304 +0,0 @@
-import chalk from 'chalk';
-import { render } from 'hanji';
-import type { JsonStatement } from '../../jsonStatements';
-import { PgSquasher } from '../../serializer/pgSchema';
-import { fromJson } from '../../sqlgenerator';
-import type { DB } from '../../utils';
-import { Select } from '../selector-ui';
-
-// export const filterStatements = (statements: JsonStatement[]) => {
-//   return statements.filter((statement) => {
-//     if (statement.type === "alter_table_alter_column_set_type") {
-//       // Don't need to handle it on migrations step and introspection
-//       // but for both it should be skipped
-//       if (
-//         statement.oldDataType.startsWith("tinyint") &&
-//         statement.newDataType.startsWith("boolean")
-//       ) {
-//         return false;
-//       }
-//     } else if (statement.type === "alter_table_alter_column_set_default") {
-//       if (
-//         statement.newDefaultValue === false &&
-//         statement.oldDefaultValue === 0 &&
-//         statement.newDataType === "boolean"
-//       ) {
-//         return false;
-//       }
-//       if (
-//         statement.newDefaultValue === true &&
-//         statement.oldDefaultValue === 1 &&
-//         statement.newDataType === "boolean"
-//       ) {
-//         return false;
-//       }
-//     }
-//     return true;
-//   });
-// };
-
-function concatSchemaAndTableName(schema: string | undefined, table: string) {
-	return schema ? `"${schema}"."${table}"` : `"${table}"`;
-}
-
-function tableNameWithSchemaFrom(
-	schema: string | undefined,
-	tableName: string,
-	renamedSchemas: Record<string, string>,
-	renamedTables: Record<string, string>,
-) {
-	const newSchemaName = schema ? (renamedSchemas[schema] ? renamedSchemas[schema] : schema) : undefined;
-
-	const newTableName = renamedTables[concatSchemaAndTableName(newSchemaName, tableName)]
-		? renamedTables[concatSchemaAndTableName(newSchemaName, tableName)]
-		: tableName;
-
-	return concatSchemaAndTableName(newSchemaName, newTableName);
-}
-
-export type SelectResolverInput = {
-	entity: {
-		type: 'createUniqueConstraint';
-		name: string;
-		count: number;
-		tableName: string;
-	};
-	items: string[];
-};
-
-export type SelectResolverOutput = {
-	data: {
-		index: number;
-		value: string;
-	};
-};
-
-export const pgSuggestions = async (
-	db: DB,
-	statements: JsonStatement[],
-	selectResolver?: (
-		input: SelectResolverInput,
-	) => Promise<SelectResolverOutput>,
-) => {
-	let shouldAskForApprove = false;
-	const statementsToExecute: string[] = [];
-	const infoToPrint: string[] = [];
-
-	const tablesToRemove: string[] = [];
-	const columnsToRemove: string[] = [];
-	const schemasToRemove: string[] = [];
-	const tablesToTruncate: string[] = [];
-	const matViewsToRemove: string[] = [];
-
-	let renamedSchemas: Record<string, string> = {};
-	let renamedTables: Record<string, string> = {};
-
-	for (const statement of statements) {
-		if (statement.type === 'rename_schema') {
-			renamedSchemas[statement.to] = statement.from;
-		} else if (statement.type === 'rename_table') {
-			renamedTables[concatSchemaAndTableName(statement.toSchema, statement.tableNameTo)] = statement.tableNameFrom;
-		} else if (statement.type === 'drop_table') {
-			const res = await db.query(
-				`select count(*) as count from ${
-					tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-				}`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(`· You're about to delete ${chalk.underline(statement.tableName)} table with ${count} items`);
-				// statementsToExecute.push(
-				//   `truncate table ${tableNameWithSchemaFrom(statement)} cascade;`
-				// );
-				tablesToRemove.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'drop_view' && statement.materialized) {
-			const res = await db.query(`select count(*) as count from "${statement.schema ?? 'public'}"."${statement.name}"`);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete "${chalk.underline(statement.name)}" materialized view with ${count} items`,
-				);
-
-				matViewsToRemove.push(statement.name);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_drop_column') {
-			const res = await db.query(
-				`select count(*) as count from ${
-					tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-				}`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(statement.columnName)
-					} column in ${statement.tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'drop_schema') {
-			const res = await db.query(
-				`select count(*) as count from information_schema.tables where table_schema = '${statement.name}';`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(`· You're about to delete ${chalk.underline(statement.name)} schema with ${count} tables`);
-				schemasToRemove.push(statement.name);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_set_type') {
-			const res = await db.query(
-				`select count(*) as count from ${
-					tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-				}`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${chalk.underline(statement.columnName)} column type from ${
-						chalk.underline(statement.oldDataType)
-					} to ${
-						chalk.underline(
-							statement.newDataType,
-						)
-					} with ${count} items`,
-				);
-				statementsToExecute.push(
-					`truncate table ${
-						tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-					} cascade;`,
-				);
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_pk') {
-			const res = await db.query(
-				`select count(*) as count from ${
-					tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-				}`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${
-						chalk.underline(statement.tableName)
-					} primary key. This statements may fail and you table may left without primary key`,
-				);
-
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-
-			const tableNameWithSchema = tableNameWithSchemaFrom(
-				statement.schema,
-				statement.tableName,
-				renamedSchemas,
-				renamedTables,
-			);
-
-			const pkNameResponse = await db.query(
-				`SELECT constraint_name FROM information_schema.table_constraints
-        WHERE table_schema = '${
-					typeof statement.schema === 'undefined' || statement.schema === '' ? 'public' : statement.schema
-				}'
-            AND table_name = '${statement.tableName}'
-            AND constraint_type = 'PRIMARY KEY';`,
-			);
-
-			statementsToExecute.push(
-				`ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${pkNameResponse[0].constraint_name}"`,
-			);
-			// we will generate statement for drop pk here and not after all if-else statements
-			continue;
-		} else if (statement.type === 'alter_table_add_column') {
-			if (statement.column.notNull && typeof statement.column.default === 'undefined') {
-				const res = await db.query(
-					`select count(*) as count from ${
-						tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-					}`,
-				);
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to add not-null ${
-							chalk.underline(statement.column.name)
-						} column without default value, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(
-						`truncate table ${
-							tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-						} cascade;`,
-					);
-
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'create_unique_constraint') {
-			const res = await db.query(
-				`select count(*) as count from ${
-					tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-				}`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				const unsquashedUnique = PgSquasher.unsquashUnique(statement.data);
-				console.log(
-					`· You're about to add ${
-						chalk.underline(
-							unsquashedUnique.name,
-						)
-					} unique constraint to the table, which contains ${count} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table?\n`,
-				);
-
-				const entity = {
-					type: 'createUniqueConstraint' as const,
-					name: unsquashedUnique.name,
-					count,
-					tableName: statement.tableName,
-				};
-				const items = ['no', 'yes'];
-
-				const { data } = selectResolver ? await selectResolver({ entity, items }) : await render(
-					new Select([
-						'No, add the constraint without truncating the table',
-						`Yes, truncate the table`,
-					]),
-				);
-				if (data?.index === 1) {
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(
-						`truncate table ${
-							tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)
-						} cascade;`,
-					);
-					shouldAskForApprove = true;
-				}
-			}
-		}
-		const stmnt = fromJson([statement], 'postgresql', 'push');
-		if (typeof stmnt !== 'undefined') {
-			statementsToExecute.push(...stmnt);
-		}
-	}
-
-	return {
-		statementsToExecute: [...new Set(statementsToExecute)],
-		shouldAskForApprove,
-		infoToPrint,
-		matViewsToRemove: [...new Set(matViewsToRemove)],
-		columnsToRemove: [...new Set(columnsToRemove)],
-		schemasToRemove: [...new Set(schemasToRemove)],
-		tablesToTruncate: [...new Set(tablesToTruncate)],
-		tablesToRemove: [...new Set(tablesToRemove)],
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/pgUp.ts b/drizzle-kit/src/cli/commands/pgUp.ts
deleted file mode 100644
index 52a2fc4a11..0000000000
--- a/drizzle-kit/src/cli/commands/pgUp.ts
+++ /dev/null
@@ -1,179 +0,0 @@
-import chalk from 'chalk';
-import { writeFileSync } from 'fs';
-import {
-	Column,
-	Index,
-	PgSchema,
-	PgSchemaV4,
-	PgSchemaV5,
-	pgSchemaV5,
-	PgSchemaV6,
-	pgSchemaV6,
-	Table,
-	TableV5,
-} from '../../serializer/pgSchema';
-import { prepareOutFolder, validateWithReport } from '../../utils';
-
-export const upPgHandler = (out: string) => {
-	const { snapshots } = prepareOutFolder(out, 'postgresql');
-	const report = validateWithReport(snapshots, 'postgresql');
-
-	report.nonLatest
-		.map((it) => ({
-			path: it,
-			raw: report.rawMap[it]!! as Record<string, any>,
-		}))
-		.forEach((it) => {
-			const path = it.path;
-
-			let resultV6 = it.raw;
-			if (it.raw.version === '5') {
-				resultV6 = updateUpToV6(it.raw);
-			}
-
-			const result = updateUpToV7(resultV6);
-
-			console.log(`[${chalk.green('✓')}] ${path}`);
-
-			writeFileSync(path, JSON.stringify(result, null, 2));
-		});
-
-	console.log("Everything's fine 🐶🔥");
-};
-
-export const updateUpToV6 = (json: Record<string, any>): PgSchemaV6 => {
-	const schema = pgSchemaV5.parse(json);
-	const tables = Object.fromEntries(
-		Object.entries(schema.tables).map((it) => {
-			const table = it[1];
-			const schema = table.schema || 'public';
-			return [`${schema}.${table.name}`, table];
-		}),
-	);
-	const enums = Object.fromEntries(
-		Object.entries(schema.enums).map((it) => {
-			const en = it[1];
-			return [
-				`public.${en.name}`,
-				{
-					name: en.name,
-					schema: 'public',
-					values: Object.values(en.values),
-				},
-			];
-		}),
-	);
-	return {
-		...schema,
-		version: '6',
-		dialect: 'postgresql',
-		tables: tables,
-		enums,
-	};
-};
-
-// Changed index format stored in snapshot for PostgreSQL in 0.22.0
-export const updateUpToV7 = (json: Record<string, any>): PgSchema => {
-	const schema = pgSchemaV6.parse(json);
-	const tables = Object.fromEntries(
-		Object.entries(schema.tables).map((it) => {
-			const table = it[1];
-			const mappedIndexes = Object.fromEntries(
-				Object.entries(table.indexes).map((idx) => {
-					const { columns, ...rest } = idx[1];
-					const mappedColumns = columns.map<Index['columns'][number]>((it) => {
-						return {
-							expression: it,
-							isExpression: false,
-							asc: true,
-							nulls: 'last',
-							opClass: undefined,
-						};
-					});
-					return [idx[0], { columns: mappedColumns, with: {}, ...rest }];
-				}),
-			);
-			return [it[0], { ...table, indexes: mappedIndexes, policies: {}, isRLSEnabled: false, checkConstraints: {} }];
-		}),
-	);
-
-	return {
-		...schema,
-		version: '7',
-		dialect: 'postgresql',
-		sequences: {},
-		tables: tables,
-		policies: {},
-		views: {},
-		roles: {},
-	};
-};
-
-// major migration with of folder structure, etc...
-export const upPgHandlerV4toV5 = (obj: PgSchemaV4): PgSchemaV5 => {
-	const mappedTables: Record<string, TableV5> = {};
-
-	for (const [key, table] of Object.entries(obj.tables)) {
-		const mappedColumns: Record<string, Column> = {};
-		for (const [ckey, column] of Object.entries(table.columns)) {
-			let newDefault: any = column.default;
-			let newType: string = column.type;
-			if (column.type.toLowerCase() === 'date') {
-				if (typeof column.default !== 'undefined') {
-					if (column.default.startsWith("'") && column.default.endsWith("'")) {
-						newDefault = `'${
-							column.default
-								.substring(1, column.default.length - 1)
-								.split('T')[0]
-						}'`;
-					} else {
-						newDefault = column.default.split('T')[0];
-					}
-				}
-			} else if (column.type.toLowerCase().startsWith('timestamp')) {
-				if (typeof column.default !== 'undefined') {
-					if (column.default.startsWith("'") && column.default.endsWith("'")) {
-						newDefault = `'${
-							column.default
-								.substring(1, column.default.length - 1)
-								.replace('T', ' ')
-								.slice(0, 23)
-						}'`;
-					} else {
-						newDefault = column.default.replace('T', ' ').slice(0, 23);
-					}
-				}
-				newType = column.type
-					.toLowerCase()
-					.replace('timestamp (', 'timestamp(');
-			} else if (column.type.toLowerCase().startsWith('time')) {
-				newType = column.type.toLowerCase().replace('time (', 'time(');
-			} else if (column.type.toLowerCase().startsWith('interval')) {
-				newType = column.type.toLowerCase().replace(' (', '(');
-			}
-			mappedColumns[ckey] = { ...column, default: newDefault, type: newType };
-		}
-
-		mappedTables[key] = {
-			...table,
-			columns: mappedColumns,
-			compositePrimaryKeys: {},
-			uniqueConstraints: {},
-		};
-	}
-
-	return {
-		version: '5',
-		dialect: obj.dialect,
-		id: obj.id,
-		prevId: obj.prevId,
-		tables: mappedTables,
-		enums: obj.enums,
-		schemas: obj.schemas,
-		_meta: {
-			schemas: {} as Record<string, string>,
-			tables: {} as Record<string, string>,
-			columns: {} as Record<string, string>,
-		},
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/pull-cockroach.ts b/drizzle-kit/src/cli/commands/pull-cockroach.ts
new file mode 100644
index 0000000000..b4455b6c40
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-cockroach.ts
@@ -0,0 +1,179 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import type { TaskView } from 'hanji';
+import { render, renderWithTask } from 'hanji';
+import { join } from 'path';
+import type {
+	CheckConstraint,
+	CockroachEntities,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Schema,
+	Sequence,
+	View,
+} from '../../dialects/cockroach/ddl';
+import { cockroachToRelationsPull, createDDL, interimToDDL } from '../../dialects/cockroach/ddl';
+import { ddlDiff } from '../../dialects/cockroach/diff';
+import { fromDatabaseForDrizzle } from '../../dialects/cockroach/introspect';
+import { toJsonSnapshot } from '../../dialects/cockroach/snapshot';
+import { ddlToTypeScript as cockroachSequenceSchemaToTypeScript } from '../../dialects/cockroach/typescript';
+import type { EntityFilter } from '../../dialects/pull-utils';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { originUUID } from '../../utils';
+import type { DB } from '../../utils';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { prepareCockroach } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import type { CockroachCredentials } from '../validations/cockroach';
+import type { Casing, EntitiesFilterConfig } from '../validations/common';
+import { humanLog, IntrospectProgress, type IntrospectStage, type IntrospectStatus } from '../views';
+import { writeResult } from './generate-common';
+import { relationsToTypeScript, summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: CockroachCredentials,
+	filters: EntitiesFilterConfig,
+	migrations: {
+		schema: string;
+		table: string;
+	},
+	db?: Awaited<ReturnType<typeof prepareCockroach>>,
+) => {
+	if (!db) {
+		const { prepareCockroach } = await import('../connections');
+		db = await prepareCockroach(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const filter = prepareEntityFilter('cockroach', filters, []);
+
+	let res: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>;
+	if (text) {
+		const progress = new IntrospectProgress(true);
+		const task = fromDatabaseForDrizzle(
+			db,
+			filter,
+			(stage, count, status) => {
+				progress.update(stage, count, status);
+			},
+			migrations,
+		);
+		res = await renderWithTask(progress, task);
+	} else {
+		res = await fromDatabaseForDrizzle(db, filter, () => {}, migrations);
+	}
+
+	const { ddl: ddl2, errors } = interimToDDL(res);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = cockroachSequenceSchemaToTypeScript(ddl2, res.viewColumns, casing);
+	const relationsTs = relationsToTypeScript(cockroachToRelationsPull(ddl2), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+	const relationsFile = join(out, 'relations.ts');
+	writeFileSync(relationsFile, relationsTs.file);
+	humanLog();
+
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+	if (snapshots.length === 0) {
+		const { sqlStatements, renames } = await ddlDiff(
+			createDDL(), // dry ddl
+			ddl2,
+			resolver<Schema>('schema'),
+			resolver<Enum>('enum'),
+			resolver<Sequence>('sequence'),
+			resolver<Policy>('policy'),
+			resolver<CockroachEntities['tables']>('table'),
+			resolver<Column>('column'),
+			resolver<View>('view'),
+			resolver<Index>('index'),
+			resolver<CheckConstraint>('check'),
+			resolver<PrimaryKey>('primary_key'),
+			resolver<ForeignKey>('foreign key'),
+			'push',
+		);
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl2, [originUUID], renames),
+			sqlStatements,
+			renames,
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your relations file is ready ➜ ${
+				chalk.bold.underline.blue(
+					relationsFile,
+				)
+			} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		relationsPath: relationsFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
+
+export const introspect = async (
+	db: DB,
+	filter: EntityFilter,
+	progress: TaskView,
+	callback: (stage: IntrospectStage, count: number, status: IntrospectStatus) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const schema = await renderWithTask(
+		progress,
+		fromDatabaseForDrizzle(db, filter, callback, migrations),
+	);
+	return { schema };
+};
diff --git a/drizzle-kit/src/cli/commands/pull-common.ts b/drizzle-kit/src/cli/commands/pull-common.ts
new file mode 100644
index 0000000000..a3ba70b4cd
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-common.ts
@@ -0,0 +1,327 @@
+import { toCamelCase } from 'drizzle-orm/casing';
+import { plural, singular } from 'pluralize';
+import { paramNameFor } from '../../dialects/postgres/typescript';
+import { assertUnreachable } from '../../utils';
+import type { Casing } from '../validations/common';
+
+// interimToDDL mapping errors are schema-shape descriptors ({ type, schema?,
+// table?, name? }) and carry no driver credentials, so they're safe to surface.
+// Bounded to keep the message/meta from ballooning on large schemas.
+type SchemaMappingError = { type: string; schema?: string; table?: string; name?: string; column?: string };
+
+export const summarizeSchemaMappingErrors = (errors: SchemaMappingError[], limit = 5): string => {
+	const describe = (e: SchemaMappingError) => {
+		const target = [e.schema, e.table, e.column ?? e.name].filter(Boolean).join('.');
+		return target ? `${e.type} (${target})` : e.type;
+	};
+	const head = errors.slice(0, limit).map(describe).join('; ');
+	const rest = errors.length > limit ? ` (+${errors.length - limit} more)` : '';
+	return `${head}${rest}`;
+};
+
+const withCasing = (value: string, casing: Casing) => {
+	if (casing === 'preserve') {
+		return value;
+	}
+	if (casing === 'camel') {
+		return toCamelCase(value);
+	}
+
+	assertUnreachable(casing);
+};
+
+export type SchemaForPull = {
+	schema?: string;
+	foreignKeys: {
+		schema?: string;
+		table: string;
+		nameExplicit: boolean;
+		columns: string[];
+		schemaTo?: string;
+		tableTo: string;
+		columnsTo: string[];
+		onUpdate?: 'NO ACTION' | 'RESTRICT' | 'SET NULL' | 'CASCADE' | 'SET DEFAULT' | string | null;
+		onDelete?: 'NO ACTION' | 'RESTRICT' | 'SET NULL' | 'CASCADE' | 'SET DEFAULT' | string | null;
+		name: string;
+		entityType: 'fks';
+	}[];
+	columns?: { name: string }[];
+	// both unique constraints and unique indexes
+	uniques: {
+		columns: string[];
+	}[];
+}[];
+
+function prepareNameFor(name: string, tableColumns: string[]) {
+	return tableColumns.includes(name) ? `${name}Relation` : name;
+}
+
+export const relationsToTypeScript = (
+	schema: SchemaForPull,
+	casing: Casing,
+	schemaPath?: string, // for tests purposes
+) => {
+	const imports: string[] = [];
+	const tableRelations: Record<
+		string,
+		{
+			name: string;
+			type: 'one' | 'many' | 'through' | 'many-through' | 'one-one';
+			tableFrom: string;
+			schemaFrom?: string;
+			columnsFrom: string[];
+			tableTo: string;
+			schemaTo?: string;
+			columnsTo: string[];
+			relationName?: string;
+			tableThrough?: string;
+			columnsThroughFrom?: string[];
+			columnsThroughTo?: string[];
+		}[]
+	> =
+		// {} links to Object.prototype that has "constructor" property
+		// table can be named so
+		Object.create(null);
+
+	// Process all foreign keys as before.
+	schema.forEach((table) => {
+		const fks = Object.values(table.foreignKeys);
+		const tableColumns = table.columns?.map((it) => withCasing(it.name, casing)) ?? [];
+
+		if (fks.length === 2) {
+			const [fk1, fk2] = fks;
+			// reference to different tables, means it can be through many-many
+			const toTable1 = withCasing(paramNameFor(fk1.tableTo, fk1.schemaTo), casing);
+			const columnsTo1 = fk1.columnsTo.map((it) => withCasing(it, casing));
+
+			const toTable2 = withCasing(paramNameFor(fk2.tableTo, fk2.schemaTo), casing);
+			const columnsTo2 = fk2.columnsTo.map((it) => withCasing(it, casing));
+
+			const tableThrough = withCasing(paramNameFor(fk1.table, table.schema), casing);
+			// const tableFrom2 = withCasing(paramNameFor(fk2.table, table.schema), casing);
+			const columnsThroughFrom = fk1.columns.map((it) => withCasing(it, casing));
+			const columnsThroughTo = fk2.columns.map((it) => withCasing(it, casing));
+
+			if (
+				toTable1 !== toTable2
+			) {
+				if (!tableRelations[toTable1]) {
+					tableRelations[toTable1] = [];
+				}
+
+				tableRelations[toTable1].push({
+					name: prepareNameFor(plural(toTable2), tableColumns),
+					type: 'through',
+					tableFrom: toTable1,
+					columnsFrom: columnsTo1,
+					tableTo: toTable2,
+					columnsTo: columnsTo2,
+					tableThrough,
+					columnsThroughFrom,
+					columnsThroughTo,
+				});
+
+				if (!tableRelations[toTable2]) {
+					tableRelations[toTable2] = [];
+				}
+
+				tableRelations[toTable2].push({
+					name: prepareNameFor(plural(toTable1), tableColumns),
+					// this type is used for .many() side of relation, when another side has .through() with from and to fields
+					type: 'many-through',
+					tableFrom: toTable2,
+					columnsFrom: columnsTo2,
+					tableTo: toTable1,
+					columnsTo: columnsTo1,
+					tableThrough,
+					columnsThroughFrom,
+					columnsThroughTo,
+				});
+			}
+		} else {
+			fks.forEach((fk) => {
+				const tableNameFrom = paramNameFor(fk.table, table.schema);
+				const tableNameTo = paramNameFor(fk.tableTo, fk.schemaTo);
+				const tableFrom = withCasing(tableNameFrom.replace(/:+/g, ''), casing);
+				const tableTo = withCasing(tableNameTo.replace(/:+/g, ''), casing);
+				const columnsFrom = fk.columns.map((it) => withCasing(it, casing));
+				const columnsTo = fk.columnsTo.map((it) => withCasing(it, casing));
+
+				imports.push(tableTo, tableFrom);
+
+				const keyFrom = tableFrom;
+				if (!tableRelations[keyFrom]) {
+					tableRelations[keyFrom] = [];
+				}
+
+				tableRelations[keyFrom].push({
+					name: prepareNameFor(singular(tableTo), tableColumns),
+					type: 'one',
+					tableFrom,
+					columnsFrom,
+					tableTo,
+					columnsTo,
+				});
+
+				const keyTo = tableTo;
+				if (!tableRelations[keyTo]) {
+					tableRelations[keyTo] = [];
+				}
+
+				// if this table has a unique on a column, that is used for 1-m, then we can assume that it's 1-1 relation
+				// we will check that all of the fk columns are unique, so we can assume it's 1-1
+				// not matter if it's 1 column, 2 columns or more
+				if (
+					table.uniques.find((constraint) =>
+						constraint.columns.length === columnsFrom.length
+						&& constraint.columns.every((col, i) => col === columnsFrom[i])
+					)
+				) {
+					// the difference between one and one-one is that one-one won't contain from and to
+					// maybe it can be done by introducing some sort of flag or just not providing columnsFrom and columnsTo
+					// but I decided just to have a different type field here
+					tableRelations[keyTo].push({
+						name: prepareNameFor(plural(tableFrom), tableColumns),
+						type: 'one-one',
+						tableFrom: tableTo,
+						columnsFrom: columnsTo,
+						tableTo: tableFrom,
+						columnsTo: columnsFrom,
+					});
+				} else {
+					tableRelations[keyTo].push({
+						name: prepareNameFor(plural(tableFrom), tableColumns),
+						type: 'many',
+						tableFrom: tableTo,
+						columnsFrom: columnsTo,
+						tableTo: tableFrom,
+						columnsTo: columnsFrom,
+					});
+				}
+			});
+		}
+	});
+
+	const importsTs = `import { defineRelations } from "drizzle-orm";\nimport * as schema from "${
+		schemaPath ?? './schema'
+	}";\n\n`;
+
+	let relationString = `export const relations = defineRelations(schema, (r) => ({`;
+
+	Object.entries(tableRelations).forEach(([table, relations]) => {
+		// Adjust duplicate names if needed.
+		const preparedRelations = relations.map(
+			(relation, relationIndex, originArray) => {
+				let name = relation.name;
+				let relationName;
+				const hasMultipleRelations = originArray.some(
+					(it, originIndex) => relationIndex !== originIndex && it.tableTo === relation.tableTo,
+				);
+				if (hasMultipleRelations) {
+					// if one relation - we need to name a relation from this table to "many" table
+					if (relation.type === 'one') {
+						relationName = `${relation.tableFrom}_${relation.columnsFrom.join('_')}_${relation.tableTo}_${
+							relation.columnsTo.join('_')
+						}`;
+						// if many relation - name in in different order, so alias names will match
+					} else if (relation.type === 'many' || relation.type === 'one-one') {
+						relationName = `${relation.tableTo}_${relation.columnsTo.join('_')}_${relation.tableFrom}_${
+							relation.columnsFrom.join('_')
+						}`;
+						// if through relation - we need to name a relation from this table to "many" table and include "via"
+					} else if (relation.type === 'through') {
+						relationName = `${relation.tableFrom}_${relation.columnsFrom.join('_')}_${relation.tableTo}_${
+							relation.columnsTo.join('_')
+						}_via_${relation.tableThrough}`;
+						// else is for many-through, meaning we need to reverse the order for tables and columns, but leave "via" the same
+					} else {
+						relationName = `${relation.tableTo}_${relation.columnsTo.join('_')}_${relation.tableFrom}_${
+							relation.columnsFrom.join('_')
+						}_via_${relation.tableThrough}`;
+					}
+				}
+				const hasDuplicatedRelation = originArray.some(
+					(it, originIndex) => relationIndex !== originIndex && it.name === relation.name,
+				);
+				if (hasDuplicatedRelation) {
+					name = `${relation.name}_${
+						relation.type === 'through'
+							? `via_${relation.tableThrough}`
+							: relation.type === 'many-through'
+							? `via_${relation.tableThrough}`
+							: relation.type === 'one'
+							? relation.columnsFrom.join('_')
+							: relation.columnsTo.join('_')
+					}`;
+				}
+				return {
+					...relation,
+					name: withCasing(name, casing),
+					relationName,
+				};
+			},
+		);
+
+		relationString += `\n\t${table}: {`;
+		preparedRelations.forEach((relation) => {
+			if (relation.type === 'one') {
+				const from = relation.columnsFrom.length === 1
+					? `r.${relation.tableFrom}.${relation.columnsFrom[0]}`
+					: `[${
+						relation.columnsFrom
+							.map((it) => `r.${relation.tableFrom}.${it}`)
+							.join(', ')
+					}]`;
+				const to = relation.columnsTo.length === 1
+					? `r.${relation.tableTo}.${relation.columnsTo[0]}`
+					: `[${
+						relation.columnsTo
+							.map((it) => `r.${relation.tableTo}.${it}`)
+							.join(', ')
+					}]`;
+
+				relationString += `\n\t\t${relation.name}: r.one.${relation.tableTo}({\n\t\t\tfrom: ${from},\n\t\t\tto: ${to}`
+					+ (relation.relationName ? `,\n\t\t\talias: "${relation.relationName}"` : '')
+					+ `\n\t\t}),`;
+			} else if (relation.type === 'many' || relation.type === 'many-through') {
+				relationString += `\n\t\t${relation.name}: r.many.${relation.tableTo}(`
+					+ (relation.relationName ? `{\n\t\t\talias: "${relation.relationName}"\n\t\t}` : '')
+					+ `),`;
+			} else if (relation.type === 'one-one') {
+				relationString += `\n\t\t${relation.name}: r.one.${relation.tableTo}(`
+					+ (relation.relationName ? `{\n\t\t\talias: "${relation.relationName}"\n\t\t}` : '')
+					+ `),`;
+			} else {
+				const from = relation.columnsThroughFrom!.length === 1
+					? `r.${relation.tableFrom}.${relation.columnsFrom[0]}.through(r.${relation.tableThrough}.${
+						relation.columnsThroughFrom![0]
+					})`
+					: `[${
+						relation.columnsThroughFrom!
+							.map((it) => `r.${relation.tableFrom}.${it}.through(${relation.tableThrough}.${it})`)
+							.join(', ')
+					}]`;
+				const to = relation.columnsThroughTo!.length === 1
+					? `r.${relation.tableTo}.${relation.columnsTo![0]}.through(r.${relation.tableThrough}.${
+						relation.columnsThroughTo![0]
+					})`
+					: `[${
+						relation.columnsThroughTo!
+							.map((it) => `r.${relation.tableTo}.${it}.through(${relation.tableThrough}.${it})`)
+							.join(', ')
+					}]`;
+
+				relationString += `\n\t\t${relation.name}: r.many.${relation.tableTo}({\n\t\t\tfrom: ${from},\n\t\t\tto: ${to}`
+					+ (relation.relationName ? `,\n\t\t\talias: "${relation.relationName}"` : '')
+					+ `\n\t\t}),`;
+			}
+		});
+		relationString += `\n\t},`;
+	});
+
+	relationString += `\n}))`;
+
+	return {
+		file: importsTs + relationString,
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/pull-libsql.ts b/drizzle-kit/src/cli/commands/pull-libsql.ts
new file mode 100644
index 0000000000..6cb4a6a432
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-libsql.ts
@@ -0,0 +1 @@
+export { handle } from './pull-sqlite';
diff --git a/drizzle-kit/src/cli/commands/pull-mssql.ts b/drizzle-kit/src/cli/commands/pull-mssql.ts
new file mode 100644
index 0000000000..300cbf0b09
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-mssql.ts
@@ -0,0 +1,164 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import type { TaskView } from 'hanji';
+import { render, renderWithTask } from 'hanji';
+import { join } from 'path';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	ForeignKey,
+	Index,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+} from '../../dialects/mssql/ddl';
+import { createDDL, interimToDDL } from '../../dialects/mssql/ddl';
+import { ddlDiff } from '../../dialects/mssql/diff';
+import { fromDatabaseForDrizzle } from '../../dialects/mssql/introspect';
+import { toJsonSnapshot } from '../../dialects/mssql/snapshot';
+import { ddlToTypeScript } from '../../dialects/mssql/typescript';
+import type { EntityFilter } from '../../dialects/pull-utils';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { type DB, originUUID } from '../../utils';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { connectToMsSQL } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import type { Casing, EntitiesFilterConfig } from '../validations/common';
+import type { MssqlCredentials } from '../validations/mssql';
+import { humanLog, IntrospectProgress } from '../views';
+import { writeResult } from './generate-common';
+import { summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: MssqlCredentials,
+	filters: EntitiesFilterConfig,
+	migrations: {
+		schema: string;
+		table: string;
+	},
+	db?: Awaited<ReturnType<typeof connectToMsSQL>>,
+) => {
+	if (!db) {
+		const { connectToMsSQL } = await import('../connections');
+		db = await connectToMsSQL(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const filter = prepareEntityFilter('mssql', filters, []);
+
+	let res: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>;
+	if (text) {
+		const progress = new IntrospectProgress(true);
+		const task = fromDatabaseForDrizzle(
+			db.db,
+			filter,
+			(stage, count, status) => {
+				progress.update(stage, count, status);
+			},
+			migrations,
+		);
+		res = await renderWithTask(progress, task);
+	} else {
+		res = await fromDatabaseForDrizzle(db.db, filter, () => {}, migrations);
+	}
+
+	const { ddl: ddl2, errors } = interimToDDL(res);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = ddlToTypeScript(ddl2, res.viewColumns, casing);
+	// const relationsTs = relationsToTypeScript(ddl2.fks.list(), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+	// const relationsFile = join(out, 'relations.ts');
+	// writeFileSync(relationsFile, relationsTs.file);
+	humanLog();
+
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+	if (snapshots.length === 0) {
+		const { sqlStatements, renames } = await ddlDiff(
+			createDDL(), // dry ddl
+			ddl2,
+			resolver<Schema>('schema'),
+			resolver<MssqlEntities['tables']>('table'),
+			resolver<Column>('column'),
+			resolver<View>('view'),
+			resolver<UniqueConstraint>('unique', undefined, 'dbo'), // uniques
+			resolver<Index>('index', undefined, 'dbo'), // indexes
+			resolver<CheckConstraint>('check', undefined, 'dbo'), // checks
+			resolver<PrimaryKey>('primary_key', undefined, 'dbo'), // pks
+			resolver<ForeignKey>('foreign key', undefined, 'dbo'), // fks
+			resolver<DefaultConstraint>('default', undefined, 'dbo'), // defaults
+			'default',
+		);
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl2, [originUUID], renames),
+			sqlStatements,
+			renames,
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
+
+export const introspect = async (
+	db: DB,
+	filter: EntityFilter,
+	progress: TaskView,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const schema = await renderWithTask(
+		progress,
+		fromDatabaseForDrizzle(db, filter, () => {}, migrations),
+	);
+
+	return { schema };
+};
diff --git a/drizzle-kit/src/cli/commands/pull-mysql.ts b/drizzle-kit/src/cli/commands/pull-mysql.ts
new file mode 100644
index 0000000000..1585627d90
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-mysql.ts
@@ -0,0 +1,166 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import type { TaskView } from 'hanji';
+import { renderWithTask } from 'hanji';
+import { render } from 'hanji';
+import { join } from 'path';
+import { createDDL, interimToDDL, mysqlToRelationsPull } from '../../dialects/mysql/ddl';
+import { ddlDiff } from '../../dialects/mysql/diff';
+import { fromDatabaseForDrizzle } from '../../dialects/mysql/introspect';
+import { toJsonSnapshot } from '../../dialects/mysql/snapshot';
+import { ddlToTypeScript } from '../../dialects/mysql/typescript';
+import type { EntityFilter } from '../../dialects/pull-utils';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { DB } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { connectToMySQL } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { Casing } from '../validations/common';
+import type { MysqlCredentials } from '../validations/mysql';
+import type { IntrospectStage, IntrospectStatus } from '../views';
+import { humanLog, IntrospectProgress } from '../views';
+import { writeResult } from './generate-common';
+import { relationsToTypeScript, summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: MysqlCredentials,
+	filters: EntitiesFilterConfig,
+	migrations: {
+		schema: string;
+		table: string;
+	},
+	db?: Awaited<ReturnType<typeof connectToMySQL>>,
+) => {
+	if (!db) {
+		const { connectToMySQL } = await import('../connections');
+		db = await connectToMySQL(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const filter = prepareEntityFilter('mysql', filters, []);
+	let schema: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>;
+	if (text) {
+		const progress = new IntrospectProgress();
+		({ schema } = await introspect({
+			db: db.db,
+			database: db.database,
+			progress,
+			progressCallback: (stage, count, status) => {
+				progress.update(stage, count, status);
+			},
+			filter,
+			migrations,
+		}));
+	} else {
+		schema = await fromDatabaseForDrizzle(db.db, db.database, filter, () => {}, migrations);
+	}
+	const { ddl, errors } = interimToDDL(schema);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = ddlToTypeScript(ddl, schema.viewColumns, casing, 'mysql');
+	const relations = relationsToTypeScript(mysqlToRelationsPull(ddl), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+
+	const relationsFile = join(out, 'relations.ts');
+	writeFileSync(relationsFile, relations.file);
+	humanLog();
+
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+
+	if (snapshots.length === 0) {
+		const { sqlStatements } = await ddlDiff(
+			createDDL(),
+			ddl,
+			mockResolver(new Set()),
+			mockResolver(new Set()),
+			mockResolver(new Set()),
+			'push',
+		);
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl, [], []),
+			sqlStatements,
+			renames: [],
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your relations file is ready ➜ ${
+				chalk.bold.underline.blue(
+					relationsFile,
+				)
+			} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		relationsPath: relationsFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
+
+export const introspect = async (props: {
+	db: DB;
+	database: string;
+	filter: EntityFilter;
+	progress: TaskView;
+	progressCallback?: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void;
+	migrations: {
+		table: string;
+		schema: string;
+	};
+}) => {
+	const { db, database, progress, filter, migrations } = props;
+	const pcb = props.progressCallback ?? (() => {});
+
+	const res = await renderWithTask(progress, fromDatabaseForDrizzle(db, database, filter, pcb, migrations));
+	return { schema: res };
+};
diff --git a/drizzle-kit/src/cli/commands/pull-postgres.ts b/drizzle-kit/src/cli/commands/pull-postgres.ts
new file mode 100644
index 0000000000..fec07df771
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-postgres.ts
@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import type { TaskView } from 'hanji';
+import { render, renderWithTask } from 'hanji';
+import { join } from 'path';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+} from '../../dialects/postgres/ddl';
+import { createDDL, interimToDDL, postgresToRelationsPull } from '../../dialects/postgres/ddl';
+import { ddlDiff } from '../../dialects/postgres/diff';
+import { fromDatabaseForDrizzle } from '../../dialects/postgres/introspect';
+import { toJsonSnapshot } from '../../dialects/postgres/snapshot';
+import { ddlToTypeScript as postgresSchemaToTypeScript } from '../../dialects/postgres/typescript';
+import type { EntityFilter } from '../../dialects/pull-utils';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { originUUID } from '../../utils';
+import type { DB } from '../../utils';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { preparePostgresDB } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { resolver } from '../prompts';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { Casing } from '../validations/common';
+import type { PostgresCredentials } from '../validations/postgres';
+import type { IntrospectStage, IntrospectStatus } from '../views';
+import { humanLog, IntrospectProgress } from '../views';
+import { writeResult } from './generate-common';
+import { relationsToTypeScript, summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: PostgresCredentials,
+	filtersConfig: EntitiesFilterConfig,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	db?: Awaited<ReturnType<typeof preparePostgresDB>>,
+) => {
+	if (!db) {
+		const { preparePostgresDB } = await import('../connections');
+		db = await preparePostgresDB(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const entityFilter = prepareEntityFilter('postgresql', filtersConfig, []);
+
+	let res: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>;
+	if (text) {
+		const progress = new IntrospectProgress(true);
+		({ schema: res } = await renderWithTask(
+			progress,
+			introspect(
+				db,
+				entityFilter,
+				progress,
+				(stage, count, status) => {
+					progress.update(stage, count, status);
+				},
+				migrations,
+			),
+		));
+	} else {
+		res = await fromDatabaseForDrizzle(db, entityFilter, () => {}, migrations);
+	}
+
+	const { ddl: ddl2, errors } = interimToDDL(res);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = postgresSchemaToTypeScript(ddl2, res.viewColumns, casing);
+	const relationsTs = relationsToTypeScript(postgresToRelationsPull(ddl2), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+	const relationsFile = join(out, 'relations.ts');
+	writeFileSync(relationsFile, relationsTs.file);
+	humanLog();
+
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+	if (snapshots.length === 0) {
+		const { sqlStatements, renames } = await ddlDiff(
+			createDDL(), // dry ddl
+			ddl2,
+			resolver<Schema>('schema'),
+			resolver<Enum>('enum'),
+			resolver<Sequence>('sequence'),
+			resolver<Policy>('policy'),
+			resolver<Role>('role'),
+			resolver<Privilege>('privilege'),
+			resolver<PostgresEntities['tables']>('table'),
+			resolver<Column>('column'),
+			resolver<View>('view'),
+			resolver<UniqueConstraint>('unique'),
+			resolver<Index>('index'),
+			resolver<CheckConstraint>('check'),
+			resolver<PrimaryKey>('primary_key'),
+			resolver<ForeignKey>('foreign key'),
+			'push',
+		);
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl2, [originUUID], renames),
+			sqlStatements,
+			renames,
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your relations file is ready ➜ ${
+				chalk.bold.underline.blue(
+					relationsFile,
+				)
+			} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		relationsPath: relationsFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
+
+export const introspect = async (
+	db: DB,
+	filter: EntityFilter,
+	progress: TaskView,
+	callback: (stage: IntrospectStage, count: number, status: IntrospectStatus) => void = () => {},
+	migrations: {
+		schema: string;
+		table: string;
+	},
+) => {
+	const schema = await renderWithTask(
+		progress,
+		fromDatabaseForDrizzle(db, filter, callback, migrations),
+	);
+	return { schema };
+};
diff --git a/drizzle-kit/src/cli/commands/pull-singlestore.ts b/drizzle-kit/src/cli/commands/pull-singlestore.ts
new file mode 100644
index 0000000000..9b83c92001
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-singlestore.ts
@@ -0,0 +1,135 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { render, renderWithTask } from 'hanji';
+import { join } from 'path';
+import { createDDL, interimToDDL, mysqlToRelationsPull } from '../../dialects/mysql/ddl';
+import { fromDatabaseForDrizzle } from '../../dialects/mysql/introspect';
+import { ddlToTypeScript } from '../../dialects/mysql/typescript';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { ddlDiff } from '../../dialects/singlestore/diff';
+import { toJsonSnapshot } from '../../dialects/singlestore/snapshot';
+import { mockResolver } from '../../utils/mocks';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { connectToSingleStore } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { Casing } from '../validations/common';
+import type { SingleStoreCredentials } from '../validations/singlestore';
+import { humanLog, IntrospectProgress } from '../views';
+import { writeResult } from './generate-common';
+import { relationsToTypeScript, summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: SingleStoreCredentials,
+	filters: EntitiesFilterConfig,
+	migrations: {
+		schema: string;
+		table: string;
+	},
+	db?: Awaited<ReturnType<typeof connectToSingleStore>>,
+) => {
+	if (!db) {
+		const { connectToSingleStore } = await import('../connections');
+		db = await connectToSingleStore(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const filter = prepareEntityFilter('singlestore', filters, []);
+
+	let res: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>;
+	if (text) {
+		const progress = new IntrospectProgress();
+		const task = fromDatabaseForDrizzle(db.db, db.database, filter, (stage, count, status) => {
+			progress.update(stage, count, status);
+		}, migrations);
+		res = await renderWithTask(progress, task);
+	} else {
+		res = await fromDatabaseForDrizzle(db.db, db.database, filter, () => {}, migrations);
+	}
+
+	const { ddl, errors } = interimToDDL(res);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = ddlToTypeScript(ddl, res.viewColumns, casing, 'singlestore');
+	const relations = relationsToTypeScript(mysqlToRelationsPull(ddl), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+
+	const relationsFile = join(out, 'relations.ts');
+	writeFileSync(relationsFile, relations.file);
+	humanLog();
+
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+
+	if (snapshots.length === 0) {
+		const { sqlStatements } = await ddlDiff(
+			createDDL(),
+			ddl,
+			mockResolver(new Set()),
+			mockResolver(new Set()),
+			mockResolver(new Set()),
+			'push',
+		);
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl, [], []),
+			sqlStatements,
+			renames: [],
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your relations file is ready ➜ ${
+				chalk.bold.underline.blue(
+					relationsFile,
+				)
+			} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		relationsPath: relationsFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/pull-sqlite.ts b/drizzle-kit/src/cli/commands/pull-sqlite.ts
new file mode 100644
index 0000000000..0d0ba1481f
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/pull-sqlite.ts
@@ -0,0 +1,151 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import type { TaskView } from 'hanji';
+import { render, renderWithTask } from 'hanji';
+import { join } from 'path';
+import type { EntityFilter } from '../../dialects/pull-utils';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { createDDL, interimToDDL, sqliteToRelationsPull } from '../../dialects/sqlite/ddl';
+import { ddlDiffDry } from '../../dialects/sqlite/diff';
+import { fromDatabaseForDrizzle } from '../../dialects/sqlite/introspect';
+import { toJsonSnapshot } from '../../dialects/sqlite/snapshot';
+import { ddlToTypeScript } from '../../dialects/sqlite/typescript';
+import { originUUID } from '../../utils';
+import type { SQLiteDB } from '../../utils';
+import { prepareOutFolder } from '../../utils/utils-node';
+import type { connectToSQLite } from '../connections';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { Casing } from '../validations/common';
+import type { SqliteCredentials } from '../validations/sqlite';
+import { humanLog, IntrospectProgress, type IntrospectStage, type IntrospectStatus } from '../views';
+import { writeResult } from './generate-common';
+import { relationsToTypeScript, summarizeSchemaMappingErrors } from './pull-common';
+
+export const handle = async (
+	casing: Casing,
+	out: string,
+	breakpoints: boolean,
+	credentials: SqliteCredentials,
+	filters: EntitiesFilterConfig,
+	type: 'sqlite' | 'libsql' = 'sqlite',
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	db?: Awaited<ReturnType<typeof connectToSQLite>>,
+) => {
+	if (!db) {
+		const { connectToSQLite } = await import('../connections');
+		db = await connectToSQLite(credentials);
+	}
+
+	const text = outputFormat() === 'text';
+	const filter = prepareEntityFilter('sqlite', filters, []);
+	let ddl: ReturnType<typeof interimToDDL>['ddl'];
+	let errors: ReturnType<typeof interimToDDL>['errors'];
+	let viewColumns: Awaited<ReturnType<typeof fromDatabaseForDrizzle>>['viewsToColumns'];
+	if (text) {
+		const progress = new IntrospectProgress();
+		({ ddl, errors, viewColumns } = await introspect(db, filter, progress, (stage, count, status) => {
+			progress.update(stage, count, status);
+		}, migrations));
+	} else {
+		const schema = await fromDatabaseForDrizzle(db, filter, () => {}, migrations);
+		({ ddl, errors } = interimToDDL(schema));
+		viewColumns = schema.viewsToColumns;
+	}
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('pull', 'Failed to map the introspected schema', {
+			errors: summarizeSchemaMappingErrors(errors),
+		});
+	}
+
+	const ts = ddlToTypeScript(ddl, casing, viewColumns, type);
+	const relationsTs = relationsToTypeScript(sqliteToRelationsPull(ddl), casing);
+
+	const schemaFile = join(out, 'schema.ts');
+	writeFileSync(schemaFile, ts.file);
+
+	const relationsFile = join(out, 'relations.ts');
+	writeFileSync(relationsFile, relationsTs.file);
+
+	humanLog();
+	let snapshotPath: string;
+	let migrationPath: string | undefined;
+	const { snapshots } = prepareOutFolder(out);
+
+	if (snapshots.length === 0) {
+		const { sqlStatements, renames } = await ddlDiffDry(createDDL(), ddl, 'default');
+
+		({ snapshotPath, migrationPath } = writeResult({
+			snapshot: toJsonSnapshot(ddl, originUUID, [], renames),
+			sqlStatements,
+			renames,
+			outFolder: out,
+			breakpoints,
+			type: 'introspect',
+			snapshots,
+		}));
+	} else {
+		snapshotPath = snapshots[snapshots.length - 1];
+		if (text) {
+			render(
+				`[${
+					chalk.blue(
+						'i',
+					)
+				}] No SQL generated, you already have migrations in project`,
+			);
+		}
+	}
+
+	if (text) {
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your schema file is ready ➜ ${chalk.bold.underline.blue(schemaFile)} 🚀`,
+		);
+		render(
+			`[${
+				chalk.green(
+					'✓',
+				)
+			}] Your relations file is ready ➜ ${
+				chalk.bold.underline.blue(
+					relationsFile,
+				)
+			} 🚀`,
+		);
+	}
+
+	return {
+		schemaPath: schemaFile,
+		relationsPath: relationsFile,
+		snapshotPath,
+		...(migrationPath ? { migrationPath } : {}),
+	};
+};
+
+export const introspect = async (
+	db: SQLiteDB,
+	filter: EntityFilter,
+	taskView: TaskView,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const schema = await renderWithTask(taskView, fromDatabaseForDrizzle(db, filter, progressCallback, migrations));
+	const res = interimToDDL(schema);
+	return { ...res, viewColumns: schema.viewsToColumns };
+};
diff --git a/drizzle-kit/src/cli/commands/push-cockroach.ts b/drizzle-kit/src/cli/commands/push-cockroach.ts
new file mode 100644
index 0000000000..a118d0ca91
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-cockroach.ts
@@ -0,0 +1,293 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import type {
+	CheckConstraint,
+	CockroachEntities,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Schema,
+	Sequence,
+	View,
+} from '../../dialects/cockroach/ddl';
+import { interimToDDL } from '../../dialects/cockroach/ddl';
+import { ddlDiff } from '../../dialects/cockroach/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/cockroach/drizzle';
+import type { JsonStatement } from '../../dialects/cockroach/statements';
+import { extractCrdbExisting } from '../../dialects/drizzle';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { DB } from '../../utils';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { CockroachCredentials } from '../validations/cockroach';
+import type { EntitiesFilterConfig } from '../validations/common';
+import {
+	cockroachSchemaError,
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	postgresSchemaWarning,
+	ProgressView,
+} from '../views';
+
+export const handle = async (
+	filenames: string[],
+	verbose: boolean,
+	credentials: CockroachCredentials,
+	filters: EntitiesFilterConfig,
+	force: boolean,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+
+	const { prepareCockroach } = await import('../connections');
+	const { introspect: cockroachPushIntrospect } = await import('./pull-cockroach');
+
+	const db = await prepareCockroach(credentials);
+	const res = await prepareFromSchemaFiles(filenames);
+
+	const existing = extractCrdbExisting(res.schemas, res.views, res.matViews);
+	const filter = prepareEntityFilter('cockroach', filters, existing);
+
+	const { schema: schemaTo, errors, warnings } = fromDrizzleSchema(res, filter);
+
+	if (warnings.length > 0) {
+		humanLog(warnings.map((it) => postgresSchemaWarning(it)).join('\n\n'));
+	}
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('push', errors.map((it) => cockroachSchemaError(it)).join('\n'), {
+			stage: 'schema',
+			dialect: 'cockroach',
+		});
+	}
+
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView('Pulling schema from database...', 'Pulling schema from database...');
+	const { schema: schemaFrom } = await cockroachPushIntrospect(
+		db,
+		filter,
+		progress,
+		() => {},
+		migrations,
+	);
+
+	const { ddl: ddl1 } = interimToDDL(schemaFrom);
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(schemaTo);
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => cockroachSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'cockroach',
+		});
+	}
+
+	const { sqlStatements, statements: jsonStatements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Schema>('schema', hints),
+		resolver<Enum>('enum', hints),
+		resolver<Sequence>('sequence', hints),
+		resolver<Policy>('policy', hints),
+		resolver<CockroachEntities['tables']>('table', hints),
+		resolver<Column>('column', hints),
+		resolver<View>('view', hints),
+		resolver<Index>('index', hints),
+		resolver<CheckConstraint>('check', hints),
+		resolver<PrimaryKey>('primary_key', hints),
+		resolver<ForeignKey>('foreign key', hints),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect: 'cockroach' };
+	}
+
+	const suggestionHints = await suggestions(db, jsonStatements, hints);
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+	if (explain) {
+		if (json) {
+			return explainJsonOutput('cockroach', jsonStatements, suggestionHints);
+		}
+		const explainMessage = explainView('cockroach', groupedStatements, suggestionHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'cockroach' };
+	}
+	if (!force && !json && isInteractive() && suggestionHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = suggestionHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	for (const statement of [...lossStatements, ...sqlStatements]) {
+		if (verbose) humanLog(highlightSQL(statement));
+
+		await db.query(statement);
+	}
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect: 'cockroach' };
+};
+
+const identifier = (it: { schema?: string; name: string }) => {
+	const { schema, name } = it;
+	const schemakey = schema && schema !== 'public' ? `"${schema}".` : '';
+	return `${schemakey}"${name}"`;
+};
+
+export const suggestions = async (db: DB, jsonStatements: JsonStatement[], hints: HintsHandler) => {
+	const json = outputFormat() === 'json';
+	const useHints = json || !isInteractive();
+	const grouped: { hint: string; statement?: string }[] = [];
+
+	const filtered = jsonStatements.filter((it) => {
+		// discussion -
+		if (it.type === 'recreate_view') return false;
+
+		/*
+			drizzle-kit push does not handle alternations of views definitions
+			just like with check constraints we can only reliably handle this with introduction of shadow db
+
+			for now we encourage developers to `remove view from drizzle schema -> push -> add view to drizzle schema -> push`
+		 */
+		if (it.type === 'alter_column' && it.diff.generated) return false;
+
+		/*
+      [Update] it does now, we have origin of creation
+
+      drizzle-kit push does not handle alternation of check constraints
+      that's a limitation due to a nature of in-database way of persisting check constraints values
+
+      in order to properly support one - we'd need to either fully implement in-database DDL,
+      or implement proper commutativity checks or use shadow DB for push command(the most reasonable way)
+		*/
+		// if (it.type === 'alter_column') return false;
+
+		return true;
+	});
+
+	for (const statement of filtered) {
+		if (statement.type === 'drop_table') {
+			const entity = [statement.table.schema, statement.table.name] as const;
+			if (hints.matchConfirm('table', entity)) continue;
+			const res = await db.query(`select 1 from ${statement.key} limit 1`);
+
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'table', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete non-empty ${statement.key} table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_view' && statement.view.materialized) {
+			const id = identifier(statement.view);
+			const entity = [statement.view.schema, statement.view.name] as const;
+			if (hints.matchConfirm('view', entity)) continue;
+			const res = await db.query(`select 1 from ${id} limit 1`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'view', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete non-empty ${id} materialized view` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_column') {
+			const column = statement.column;
+			const id = identifier({ schema: column.schema, name: column.table });
+			const entity = [column.schema, column.table, column.name] as const;
+			if (hints.matchConfirm('column', entity)) continue;
+			const res = await db.query(`select 1 from ${id} limit 1`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete non-empty ${column.name} column in ${id} table` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_schema') {
+			const entity = [statement.name] as const;
+			if (hints.matchConfirm('schema', entity)) continue;
+			// count tables in schema
+			const res = await db.query(
+				`select count(*) as count from information_schema.tables where table_schema = '${statement.name}';`,
+			);
+			const count = Number(res[0].count);
+			if (count === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'schema', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete ${chalk.underline(statement.name)} schema with ${count} tables` });
+			}
+			continue;
+		}
+
+		// drop pk
+		if (statement.type === 'drop_pk') {
+			const schema = statement.pk.schema ?? 'public';
+			const table = statement.pk.table;
+			const id = `"${schema}"."${table}"`;
+			const entity = [schema, table, statement.pk.name] as const;
+			if (hints.matchConfirm('primary_key', entity)) continue;
+			const res = await db.query(
+				`select 1 from ${id} limit 1`,
+			);
+
+			if (res.length > 0) {
+				const hint = `You're about to drop ${
+					chalk.underline(id)
+				} primary key, these statements may fail and your table may lose the primary key`;
+
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'primary_key', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint });
+				}
+			}
+
+			continue;
+		}
+	}
+
+	return grouped;
+};
diff --git a/drizzle-kit/src/cli/commands/push-mssql.ts b/drizzle-kit/src/cli/commands/push-mssql.ts
new file mode 100644
index 0000000000..9cfa11b3d5
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-mssql.ts
@@ -0,0 +1,289 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import { extractMssqlExisting } from '../../dialects/drizzle';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	ForeignKey,
+	Index,
+	MssqlDDL,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+} from '../../dialects/mssql/ddl';
+import { interimToDDL } from '../../dialects/mssql/ddl';
+import { ddlDiff } from '../../dialects/mssql/diff';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../dialects/mssql/drizzle';
+import type { JsonStatement } from '../../dialects/mssql/statements';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { DB } from '../../utils';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError, UnsupportedSchemaChangeError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { MssqlCredentials } from '../validations/mssql';
+import {
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	mssqlSchemaError,
+	ProgressView,
+} from '../views';
+
+export const handle = async (
+	filenames: string[],
+	verbose: boolean,
+	credentials: MssqlCredentials,
+	filters: EntitiesFilterConfig,
+	force: boolean,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+
+	const { connectToMsSQL } = await import('../connections');
+	const { introspect } = await import('./pull-mssql');
+
+	const { db } = await connectToMsSQL(credentials);
+	const res = await prepareFromSchemaFiles(filenames);
+
+	const existing = extractMssqlExisting(res.schemas, res.views);
+	const filter = prepareEntityFilter('mssql', filters, existing);
+
+	const { schema: schemaTo, errors } = fromDrizzleSchema(res, filter);
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('push', errors.map((it) => mssqlSchemaError(it)).join('\n'), {
+			dialect: 'mssql',
+		});
+	}
+
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView('Pulling schema from database...', 'Pulling schema from database...');
+	const { schema: schemaFrom } = await introspect(db, filter, progress, migrations);
+
+	const { ddl: ddl1 } = interimToDDL(schemaFrom);
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(schemaTo);
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => mssqlSchemaError(it)).join('\n'), {
+			dialect: 'mssql',
+		});
+	}
+
+	const { sqlStatements, statements: jsonStatements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Schema>('schema', hints, 'dbo'),
+		resolver<MssqlEntities['tables']>('table', hints, 'dbo'),
+		resolver<Column>('column', hints, 'dbo'),
+		resolver<View>('view', hints, 'dbo'),
+		resolver<UniqueConstraint>('unique', hints, 'dbo'),
+		resolver<Index>('index', hints, 'dbo'),
+		resolver<CheckConstraint>('check', hints, 'dbo'),
+		resolver<PrimaryKey>('primary_key', hints, 'dbo'),
+		resolver<ForeignKey>('foreign key', hints, 'dbo'),
+		resolver<DefaultConstraint>('default', hints, 'dbo'),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect: 'mssql' };
+	}
+
+	const suggestionHints = await suggestions(db, jsonStatements, ddl2, hints);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (explain) {
+		if (json) {
+			return explainJsonOutput('mssql', jsonStatements, suggestionHints);
+		}
+		const explainMessage = explainView('mssql', groupedStatements, suggestionHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'mssql' };
+	}
+
+	if (!force && !json && isInteractive() && suggestionHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = suggestionHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	for (const statement of [...lossStatements, ...sqlStatements]) {
+		if (verbose) humanLog(highlightSQL(statement));
+
+		await db.query(statement);
+	}
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect: 'mssql' };
+};
+
+const identifier = (it: { schema?: string; table: string }) => {
+	const { schema, table } = it;
+
+	const schemaKey = schema && schema !== 'dbo' ? `[${schema}].` : '';
+	const tableKey = `[${table}]`;
+
+	return `${schemaKey}${tableKey}`;
+};
+
+export const suggestions = async (db: DB, jsonStatements: JsonStatement[], ddl2: MssqlDDL, hints: HintsHandler) => {
+	const json = outputFormat() === 'json';
+	const useHints = json || !isInteractive();
+	const grouped: { hint: string; statement?: string }[] = [];
+
+	const filtered = jsonStatements.filter((it) => {
+		if (it.type === 'alter_column' && it.diff.generated) return false;
+
+		return true;
+	});
+
+	for (const statement of filtered) {
+		if (statement.type === 'drop_table') {
+			const tableName = identifier({ schema: statement.table.schema, table: statement.table.name });
+			const entity = [statement.table.schema ?? 'dbo', statement.table.name] as const;
+			if (hints.matchConfirm('table', entity)) continue;
+			const res = await db.query(`select top(1) 1 from ${tableName};`);
+
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'table', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete non-empty [${statement.table.name}] table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_column') {
+			const column = statement.column;
+
+			const key = identifier({ schema: column.schema, table: column.table });
+			const entity = [column.schema ?? 'dbo', column.table, column.name] as const;
+			if (hints.matchConfirm('column', entity)) continue;
+
+			const res = await db.query(`SELECT TOP(1) 1 FROM ${key} WHERE [${column.name}] IS NOT NULL;`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete non-empty [${column.name}] column in [${column.table}] table` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_schema') {
+			const entity = [statement.name] as const;
+			if (hints.matchConfirm('schema', entity)) continue;
+			// count tables in schema
+			const res = await db.query(
+				`select count(*) as count from information_schema.tables where table_schema = '${statement.name}';`,
+			);
+			const count = Number(res[0].count);
+			if (count === 0) continue;
+
+			const tableGrammar = count === 1 ? 'table' : 'tables';
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'schema', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete [${statement.name}] schema with ${count} ${tableGrammar}` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_pk') {
+			const schema = statement.pk.schema ?? 'dbo';
+			const table = statement.pk.table;
+			const id = identifier({ table: table, schema: schema });
+			const entity = [schema, table, statement.pk.name] as const;
+			if (hints.matchConfirm('primary_key', entity)) continue;
+			const res = await db.query(
+				`select top(1) 1 from ${id};`,
+			);
+
+			if (res.length > 0) {
+				const hint = `You're about to drop ${
+					chalk.underline(id)
+				} primary key, this statements may fail and your table may lose primary key`;
+
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'primary_key', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint });
+				}
+			}
+
+			continue;
+		}
+
+		if (
+			statement.type === 'rename_column'
+			&& ddl2.checks.one({ schema: statement.to.schema, table: statement.to.table })
+		) {
+			if (useHints) {
+				throw new UnsupportedSchemaChangeError({
+					kind: 'rename_blocked_by_check_constraint',
+					schema: statement.to.schema ?? 'dbo',
+					table: statement.to.table,
+					from: statement.from.name,
+					to: statement.to.name,
+				});
+			}
+			grouped.push({
+				hint:
+					`You are trying to rename column from ${statement.from.name} to ${statement.to.name}, but it is not possible to rename a column if it is used in a check constraint on the table.\nTo rename the column, first drop the check constraint, then rename the column, and finally recreate the check constraint`,
+			});
+			continue;
+		}
+
+		if (statement.type === 'rename_schema') {
+			if (useHints) {
+				throw new UnsupportedSchemaChangeError({
+					kind: 'rename_schema_unsupported',
+					from: statement.from.name,
+					to: statement.to.name,
+					dialect: 'mssql',
+				});
+			}
+			grouped.push({
+				hint:
+					`You are trying to rename schema ${statement.from.name} to ${statement.to.name}, but it is not supported to rename a schema in mssql.\nYou should create new schema and transfer everything to it`,
+			});
+			continue;
+		}
+	}
+
+	return grouped;
+};
diff --git a/drizzle-kit/src/cli/commands/push-mysql.ts b/drizzle-kit/src/cli/commands/push-mysql.ts
new file mode 100644
index 0000000000..ef0daecd50
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-mysql.ts
@@ -0,0 +1,309 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import { extractMysqlExisting } from '../../dialects/drizzle';
+import type { Column, MysqlDDL, Table, View } from '../../dialects/mysql/ddl';
+import { interimToDDL } from '../../dialects/mysql/ddl';
+import { ddlDiff } from '../../dialects/mysql/diff';
+import type { JsonStatement } from '../../dialects/mysql/statements';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { DB } from '../../utils';
+import { connectToMySQL } from '../connections';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError, UnsupportedSchemaChangeError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { MysqlCredentials } from '../validations/mysql';
+import {
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	mysqlSchemaError,
+	ProgressView,
+} from '../views';
+import { introspect } from './pull-mysql';
+
+export const handle = async (
+	filenames: string[],
+	credentials: MysqlCredentials,
+	verbose: boolean,
+	force: boolean,
+	filters: EntitiesFilterConfig,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+
+	const { prepareFromSchemaFiles, fromDrizzleSchema } = await import('../../dialects/mysql/drizzle');
+
+	const res = await prepareFromSchemaFiles(filenames);
+
+	const existing = extractMysqlExisting(res.views);
+	const filter = prepareEntityFilter('mysql', filters, existing);
+
+	const { db, database } = await connectToMySQL(credentials);
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView(
+			'Pulling schema from database...',
+			'Pulling schema from database...',
+		);
+
+	const { schema: interimFromDB } = await introspect({ db, database, progress, filter, migrations });
+
+	const interimFromFiles = fromDrizzleSchema(res.tables, res.views);
+
+	const { ddl: ddl1 } = interimToDDL(interimFromDB);
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(interimFromFiles);
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => mysqlSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'mysql',
+		});
+	}
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Table>('table', hints),
+		resolver<Column>('column', hints),
+		resolver<View>('view', hints),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect: 'mysql' };
+	}
+
+	const suggestionHints = await suggestions(db, statements, ddl2, hints);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (explain) {
+		if (json) {
+			return explainJsonOutput('mysql', statements, suggestionHints);
+		}
+		const explainMessage = explainView('mysql', groupedStatements, suggestionHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'mysql' };
+	}
+
+	if (!force && !json && isInteractive() && suggestionHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = suggestionHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	for (const statement of [...lossStatements, ...sqlStatements]) {
+		if (verbose) humanLog(highlightSQL(statement));
+
+		await db.query(statement);
+	}
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect: 'mysql' };
+};
+
+const identifier = ({ table, column }: { table?: string; column?: string }) => {
+	return [table, column].filter(Boolean).map((t) => `\`${t}\``).join('.');
+};
+export const suggestions = async (db: DB, jsonStatements: JsonStatement[], ddl2: MysqlDDL, hints: HintsHandler) => {
+	const json = outputFormat() === 'json';
+	const useHints = json || !isInteractive();
+	const grouped: { hint: string; statement?: string }[] = [];
+
+	const filtered = jsonStatements.filter((it) => {
+		if (it.type === 'alter_column' && it.diff.generated) return false;
+
+		return true;
+	});
+
+	for (const statement of filtered) {
+		if (statement.type === 'drop_table') {
+			const entity = ['public', statement.table] as const;
+			if (hints.matchConfirm('table', entity)) continue;
+			const res = await db.query(`select 1 from ${identifier({ table: statement.table })} limit 1`);
+
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'table', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete non-empty ${chalk.underline(statement.table)} table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_column') {
+			const column = statement.column;
+			const entity = ['public', column.table, column.name] as const;
+			if (hints.matchConfirm('column', entity)) continue;
+			const res = await db.query(`select 1 from ${identifier({ table: column.table })} limit 1`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({
+					hint: `You're about to delete non-empty ${chalk.underline(column.name)} column in ${
+						chalk.underline(column.table)
+					} table`,
+				});
+			}
+			continue;
+		}
+
+		// drop pk
+		if (statement.type === 'drop_pk') {
+			const { table, columns } = statement.pk;
+			const id = identifier({ table });
+			const entity = ['public', table, statement.pk.name] as const;
+			if (hints.matchConfirm('primary_key', entity)) continue;
+			const res = await db.query(
+				`select 1 from ${id} limit 1`,
+			);
+
+			if (res.length > 0) {
+				const hint = `You're about to drop ${
+					chalk.underline(table)
+				} primary key, this statements may fail and your table may lose primary key`;
+
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'primary_key', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint });
+				}
+			}
+
+			const fks = ddl2.fks.list({ tableTo: table });
+			const indexes = ddl2.indexes.list({ isUnique: true, table: table });
+
+			const fkFound = fks.filter((fk) => {
+				if (fk.columnsTo.length !== columns.length) return false;
+
+				return fk.columnsTo.every((fkCol) => columns.includes(fkCol));
+			});
+
+			if (fkFound.length === 0) continue;
+
+			const indexesFound = indexes.some((index) => {
+				if (index.columns.length !== columns.length) {
+					return false;
+				}
+
+				return index.columns.every((col) => columns.includes(col.value));
+			});
+
+			if (indexesFound) continue;
+
+			if (useHints) {
+				throw new UnsupportedSchemaChangeError({
+					kind: 'drop_pk_dependency',
+					table,
+					columns,
+					blocking_fks: fkFound.map((fk) => fk.name),
+				});
+			}
+			grouped.push({
+				hint: `You are trying to drop primary key from "${table}" ("${
+					columns.join('", ')
+				}"), but there is an existing reference on this column. You must either add a UNIQUE constraint to ("${
+					columns.join('", ')
+				}") or drop the foreign key constraint that references this column.`,
+			});
+			continue;
+		}
+
+		if (statement.type === 'alter_column') {
+			const tableName = identifier({ table: statement.origin.table });
+			const columnName = identifier({ column: statement.origin.column });
+
+			if (statement.diff.type) {
+				const entity = ['public', statement.column.table, statement.column.name] as const;
+				if (!hints.matchConfirm('column', entity)) {
+					if (useHints) {
+						hints.pushMissingHint({
+							type: 'confirm_data_loss',
+							kind: 'column',
+							entity,
+							reason: 'type_change',
+							reason_details: { from: statement.diff.type.from, to: statement.diff.type.to },
+						});
+					} else {
+						const hint = `You're about to change ${
+							chalk.underline(
+								columnName,
+							)
+						} column type in ${tableName} from ${
+							chalk.underline(
+								statement.diff.type.from,
+							)
+						} to ${chalk.underline(statement.diff.type.to)}`;
+
+						grouped.push({ hint });
+					}
+				}
+			}
+
+			continue;
+		}
+
+		if (statement.type === 'create_fk' && statement.cause !== 'alter_pk') {
+			const { columnsTo, table, tableTo, columns } = statement.fk;
+
+			const indexes = ddl2.indexes.list({ isUnique: true, table: tableTo });
+			const pk = ddl2.pks.one({ table: tableTo });
+
+			const columnsToSet = new Set(columnsTo);
+
+			const isUniqueFound = indexes.some((index) => {
+				if (index.columns.length !== columnsToSet.size) {
+					return false;
+				}
+
+				return index.columns.every((col) => columnsToSet.has(col.value));
+			});
+
+			const isPkFound = pk && pk.columns.length === columnsToSet.size
+				&& pk.columns.every((col) => columnsToSet.has(col));
+
+			if (isPkFound || isUniqueFound) continue;
+
+			throw new UnsupportedSchemaChangeError({
+				kind: 'fk_target_not_unique',
+				table,
+				columns,
+				table_to: tableTo,
+				columns_to: columnsTo,
+			});
+		}
+	}
+
+	return grouped;
+};
diff --git a/drizzle-kit/src/cli/commands/push-postgres.ts b/drizzle-kit/src/cli/commands/push-postgres.ts
new file mode 100644
index 0000000000..eae4c4f589
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-postgres.ts
@@ -0,0 +1,320 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import { extractPostgresExisting } from '../../dialects/drizzle';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+} from '../../dialects/postgres/ddl';
+import { interimToDDL } from '../../dialects/postgres/ddl';
+import { ddlDiff } from '../../dialects/postgres/diff';
+import { fromDrizzleSchema } from '../../dialects/postgres/drizzle';
+import type { SchemaSource } from '../../dialects/postgres/drizzle';
+import type { JsonStatement } from '../../dialects/postgres/statements';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { DB } from '../../utils';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { PostgresCredentials } from '../validations/postgres';
+import {
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	postgresSchemaError,
+	postgresSchemaWarning,
+	ProgressView,
+} from '../views';
+
+export const handle = async (
+	schemaSource: SchemaSource,
+	verbose: boolean,
+	credentials: PostgresCredentials,
+	filters: EntitiesFilterConfig,
+	force: boolean,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+	const { preparePostgresDB } = await import('../connections');
+	const { introspect } = await import('./pull-postgres');
+
+	const db = await preparePostgresDB(credentials);
+	const res = await schemaSource.load();
+
+	const existing = extractPostgresExisting(res.schemas, res.views, res.matViews);
+	const entityFilter = prepareEntityFilter('postgresql', filters, existing);
+
+	const { schema: schemaTo, errors, warnings } = fromDrizzleSchema(res, entityFilter);
+
+	if (warnings.length > 0) {
+		humanLog(warnings.map((it) => postgresSchemaWarning(it)).join('\n\n'));
+	}
+
+	if (errors.length > 0) {
+		throw new CommandOutputCliError('push', errors.map((it) => postgresSchemaError(it)).join('\n'), {
+			stage: 'schema',
+			dialect: 'postgresql',
+		});
+	}
+
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView('Pulling schema from database...', 'Pulling schema from database...');
+
+	const { schema: schemaFrom } = await introspect(
+		db,
+		entityFilter,
+		progress,
+		() => {},
+		migrations,
+	);
+
+	const { ddl: ddl1 } = interimToDDL(schemaFrom);
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(schemaTo);
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => postgresSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'postgresql',
+		});
+	}
+
+	// const blanks = new Set<string>();
+	const { sqlStatements, statements: jsonStatements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Schema>('schema', hints),
+		resolver<Enum>('enum', hints),
+		resolver<Sequence>('sequence', hints),
+		resolver<Policy>('policy', hints),
+		resolver<Role>('role', hints),
+		resolver<Privilege>('privilege', hints),
+		resolver<PostgresEntities['tables']>('table', hints),
+		resolver<Column>('column', hints),
+		resolver<View>('view', hints),
+		resolver<UniqueConstraint>('unique', hints),
+		resolver<Index>('index', hints),
+		resolver<CheckConstraint>('check', hints),
+		resolver<PrimaryKey>('primary_key', hints),
+		resolver<ForeignKey>('foreign key', hints),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect: 'postgresql' };
+	}
+
+	const dataLossHints = await suggestions(db, jsonStatements, hints);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (explain) {
+		if (json) {
+			return explainJsonOutput('postgresql', jsonStatements, dataLossHints);
+		}
+		const explainMessage = explainView('postgres', groupedStatements, dataLossHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'postgresql' };
+	}
+
+	if (!force && !json && isInteractive() && dataLossHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = dataLossHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	for (const statement of [...lossStatements, ...sqlStatements]) {
+		if (verbose) humanLog(highlightSQL(statement));
+
+		await db.query(statement);
+	}
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect: 'postgresql' };
+};
+
+const identifier = (it: { schema?: string; name: string }) => {
+	const { schema, name } = it;
+	const schemakey = schema && schema !== 'public' ? `"${schema}".` : '';
+	return `${schemakey}"${name}"`;
+};
+
+export const suggestions = async (db: DB, jsonStatements: JsonStatement[], hints: HintsHandler) => {
+	const json = outputFormat() === 'json';
+	const useHints = json || !isInteractive();
+	const grouped: { hint: string; statement?: string }[] = [];
+
+	const filtered = jsonStatements.filter((it) => {
+		// TODO: discussion -
+		if (it.type === 'drop_view' && it.cause) return false;
+
+		/*
+			drizzle-kit push does not handle alternations of postgres views definitions
+			just like with check constraints we can only reliably handle this with introduction of shadow db
+
+			for now we encourage developers to `remove view from drizzle schema -> push -> add view to drizzle schema -> push`
+		 */
+		if (it.type === 'alter_column' && it.diff.generated) return false;
+
+		/*
+      [Update] it does now, we have origin of creation
+
+      drizzle-kit push does not handle alternation of check constraints
+      that's a limitation due to a nature of in-database way of persisting check constraints values
+
+      in order to properly support one - we'd need to either fully implement in-database DDL,
+      or implement proper commutativity checks or use shadow DB for push command(the most reasonable way)
+		*/
+		// if (it.type === 'alter_column') return false;
+
+		return true;
+	});
+
+	for (const statement of filtered) {
+		if (statement.type === 'drop_table') {
+			const entity = [statement.table.schema, statement.table.name] as const;
+			if (hints.matchConfirm('table', entity)) continue;
+			const res = await db.query(`select 1 from ${statement.key} limit 1`);
+
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'table', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete non-empty ${statement.key} table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_view' && statement.view.materialized) {
+			const id = identifier(statement.view);
+			const entity = [statement.view.schema, statement.view.name] as const;
+			if (hints.matchConfirm('view', entity)) continue;
+			const res = await db.query(`select 1 from ${id} limit 1`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'view', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete non-empty ${id} materialized view` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_column') {
+			const column = statement.column;
+			const id = identifier({ schema: column.schema, name: column.table });
+			const entity = [column.schema, column.table, column.name] as const;
+			if (hints.matchConfirm('column', entity)) continue;
+			const res = await db.query(`select 1 from ${id} limit 1`);
+			if (res.length === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({ hint: `You're about to delete non-empty ${column.name} column in ${id} table` });
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_schema') {
+			const entity = [statement.name] as const;
+			if (hints.matchConfirm('schema', entity)) continue;
+			// count tables in schema
+			const res = await db.query(
+				`select count(*) as count from information_schema.tables where table_schema = '${statement.name}';`,
+			);
+			const count = Number(res[0].count);
+			if (count === 0) continue;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'schema', entity, reason: 'non_empty' });
+			} else {
+				grouped.push({
+					hint: `You're about to delete ${chalk.underline(statement.name)} schema with ${count} tables`,
+				});
+			}
+			continue;
+		}
+
+		// drop pk
+		if (statement.type === 'drop_pk') {
+			const schema = statement.pk.schema ?? 'public';
+			const table = statement.pk.table;
+			const id = `"${schema}"."${table}"`;
+			const entity = [schema, table, statement.pk.name] as const;
+			if (hints.matchConfirm('primary_key', entity)) continue;
+			const res = await db.query(
+				`select 1 from ${id} limit 1`,
+			);
+
+			if (res.length === 0) continue;
+
+			const hint = `You're about to drop ${
+				chalk.underline(id)
+			} primary key, this statements may fail and your table may lose primary key`;
+
+			if (useHints) {
+				hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'primary_key', entity, reason: 'non_empty' });
+				continue;
+			}
+
+			if (statement.pk.nameExplicit) {
+				grouped.push({ hint });
+				continue;
+			}
+
+			const [{ name: pkName }] = await db.query<{ name: string }>(`
+        SELECT constraint_name as name 
+        FROM information_schema.table_constraints
+        WHERE 
+          table_schema = '${schema}'
+          AND table_name = '${table}'
+          AND constraint_type = 'PRIMARY KEY';`);
+
+			grouped.push({ hint, statement: `ALTER TABLE ${id} DROP CONSTRAINT "${pkName}"` });
+			continue;
+		}
+	}
+
+	return grouped;
+};
diff --git a/drizzle-kit/src/cli/commands/push-singlestore.ts b/drizzle-kit/src/cli/commands/push-singlestore.ts
new file mode 100644
index 0000000000..ceacec1904
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-singlestore.ts
@@ -0,0 +1,231 @@
+import chalk from 'chalk';
+import { render, renderWithTask } from 'hanji';
+import type { Column, Table, View } from '../../dialects/mysql/ddl';
+import { interimToDDL } from '../../dialects/mysql/ddl';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import { ddlDiff } from '../../dialects/singlestore/diff';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { MysqlCredentials } from '../validations/mysql';
+import {
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	mysqlSchemaError,
+	ProgressView,
+} from '../views';
+import { suggestions } from './push-mysql';
+
+export const handle = async (
+	filenames: string[],
+	credentials: MysqlCredentials,
+	filters: EntitiesFilterConfig,
+	verbose: boolean,
+	force: boolean,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+
+	const { connectToSingleStore } = await import('../connections');
+	const { fromDatabaseForDrizzle } = await import('../../dialects/mysql/introspect');
+
+	/*
+		schemas in singlestore are ignored just like in mysql
+		there're now views in singlestore either, so no entities with .existing() for now
+	 */
+	const filter = prepareEntityFilter('singlestore', filters, []);
+
+	const { db, database } = await connectToSingleStore(credentials);
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView(
+			'Pulling schema from database...',
+			'Pulling schema from database...',
+		);
+	const interimFromDB = await renderWithTask(
+		progress,
+		fromDatabaseForDrizzle(db, database, filter, () => {}, migrations),
+	);
+
+	const { prepareFromSchemaFiles, fromDrizzleSchema } = await import('../../dialects/singlestore/drizzle');
+
+	const res = await prepareFromSchemaFiles(filenames);
+	const interimFromFiles = fromDrizzleSchema(res.tables);
+
+	const { ddl: ddl1 } = interimToDDL(interimFromDB);
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(interimFromFiles);
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => mysqlSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect: 'singlestore',
+		});
+	}
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Table>('table', hints),
+		resolver<Column>('column', hints),
+		resolver<View>('view', hints),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect: 'singlestore' };
+	}
+
+	const suggestionHints = await suggestions(db, statements, ddl2, hints);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (explain) {
+		if (json) {
+			return explainJsonOutput('singlestore', statements, suggestionHints);
+		}
+		const explainMessage = explainView('singlestore', groupedStatements, suggestionHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect: 'singlestore' };
+	}
+
+	if (!force && !json && isInteractive() && suggestionHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = suggestionHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	for (const statement of [...lossStatements, ...sqlStatements]) {
+		if (verbose) humanLog(highlightSQL(statement));
+
+		await db.query(statement);
+	}
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect: 'singlestore' };
+};
+
+// TODO: check
+// export const filterStatements = (
+// 	statements: JsonStatement[],
+// 	currentSchema: TypeOf<typeof mysqlSchema>,
+// 	prevSchema: TypeOf<typeof mysqlSchema>,
+// ) => {
+// 	return statements.filter((statement) => {
+// 		if (statement.type === 'alter_table_alter_column_set_type') {
+// 			// Don't need to handle it on migrations step and introspection
+// 			// but for both it should be skipped
+// 			if (
+// 				statement.oldDataType.startsWith('tinyint')
+// 				&& statement.newDataType.startsWith('boolean')
+// 			) {
+// 				return false;
+// 			}
+
+// 			if (
+// 				statement.oldDataType.startsWith('bigint unsigned')
+// 				&& statement.newDataType.startsWith('serial')
+// 			) {
+// 				return false;
+// 			}
+
+// 			if (
+// 				statement.oldDataType.startsWith('serial')
+// 				&& statement.newDataType.startsWith('bigint unsigned')
+// 			) {
+// 				return false;
+// 			}
+// 		} else if (statement.type === 'alter_table_alter_column_set_default') {
+// 			if (
+// 				statement.newDefaultValue === false
+// 				&& statement.oldDefaultValue === 0
+// 				&& statement.newDataType === 'boolean'
+// 			) {
+// 				return false;
+// 			}
+// 			if (
+// 				statement.newDefaultValue === true
+// 				&& statement.oldDefaultValue === 1
+// 				&& statement.newDataType === 'boolean'
+// 			) {
+// 				return false;
+// 			}
+// 		} else if (statement.type === 'delete_unique_constraint') {
+// 			const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+// 			// only if constraint was removed from a serial column, than treat it as removed
+// 			// const serialStatement = statements.find(
+// 			//   (it) => it.type === "alter_table_alter_column_set_type"
+// 			// ) as JsonAlterColumnTypeStatement;
+// 			// if (
+// 			//   serialStatement?.oldDataType.startsWith("bigint unsigned") &&
+// 			//   serialStatement?.newDataType.startsWith("serial") &&
+// 			//   serialStatement.columnName ===
+// 			//     MySqlSquasher.unsquashUnique(statement.data).columns[0]
+// 			// ) {
+// 			//   return false;
+// 			// }
+// 			// Check if uniqueindex was only on this column, that is serial
+
+// 			// if now serial and was not serial and was unique index
+// 			if (
+// 				unsquashed.columns.length === 1
+// 				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
+// 						.type === 'serial'
+// 				&& prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
+// 						.type === 'serial'
+// 				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
+// 						.name === unsquashed.columns[0]
+// 			) {
+// 				return false;
+// 			}
+// 		} else if (statement.type === 'alter_table_alter_column_drop_notnull') {
+// 			// only if constraint was removed from a serial column, than treat it as removed
+// 			const serialStatement = statements.find(
+// 				(it) => it.type === 'alter_table_alter_column_set_type',
+// 			) as JsonAlterColumnTypeStatement;
+// 			if (
+// 				serialStatement?.oldDataType.startsWith('bigint unsigned')
+// 				&& serialStatement?.newDataType.startsWith('serial')
+// 				&& serialStatement.columnName === statement.columnName
+// 				&& serialStatement.tableName === statement.tableName
+// 			) {
+// 				return false;
+// 			}
+// 			if (statement.newDataType === 'serial' && !statement.columnNotNull) {
+// 				return false;
+// 			}
+// 			if (statement.columnAutoIncrement) {
+// 				return false;
+// 			}
+// 		}
+
+// 		return true;
+// 	});
+// };
diff --git a/drizzle-kit/src/cli/commands/push-sqlite.ts b/drizzle-kit/src/cli/commands/push-sqlite.ts
new file mode 100644
index 0000000000..dcf2741cba
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/push-sqlite.ts
@@ -0,0 +1,238 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import { extractSqliteExisting } from '../../dialects/drizzle';
+import { prepareEntityFilter } from '../../dialects/pull-utils';
+import type { Column, Table } from '../../dialects/sqlite/ddl';
+import { interimToDDL } from '../../dialects/sqlite/ddl';
+import { ddlDiff } from '../../dialects/sqlite/diff';
+import { fromDrizzleSchema } from '../../dialects/sqlite/drizzle';
+import type { SchemaSource } from '../../dialects/sqlite/drizzle';
+import type { JsonStatement } from '../../dialects/sqlite/statements';
+import type { SQLiteClient } from '../../utils';
+import { isInteractive, outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { highlightSQL } from '../highlighter';
+import type { HintsHandler } from '../hints';
+import { resolver } from '../prompts';
+import { Select } from '../selector-ui';
+import type { EntitiesFilterConfig } from '../validations/common';
+import type { SqliteCredentials } from '../validations/sqlite';
+import {
+	EmptyProgressView,
+	explain as explainView,
+	explainJsonOutput,
+	humanLog,
+	ProgressView,
+	sqliteSchemaError,
+} from '../views';
+
+export const handle = async (
+	db: SQLiteClient,
+	schemaSource: SchemaSource,
+	verbose: boolean,
+	credentials: SqliteCredentials,
+	filters: EntitiesFilterConfig,
+	force: boolean,
+	explain: boolean,
+	migrations: {
+		table: string;
+		schema: string;
+	},
+	dialect: 'sqlite' | 'turso',
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+
+	const { introspect: sqliteIntrospect } = await import('./pull-sqlite');
+
+	const res = await schemaSource.load();
+
+	const existing = extractSqliteExisting(res.views);
+	const filter = prepareEntityFilter('sqlite', filters, existing);
+
+	const { ddl: ddl2, errors: errors1 } = interimToDDL(fromDrizzleSchema(res.tables, res.views));
+
+	if (errors1.length > 0) {
+		throw new CommandOutputCliError('push', errors1.map((it) => sqliteSchemaError(it)).join('\n'), {
+			stage: 'ddl',
+			dialect,
+		});
+	}
+
+	const progress = json
+		? new EmptyProgressView()
+		: new ProgressView(
+			'Pulling schema from database...',
+			'Pulling schema from database...',
+		);
+
+	const { ddl: ddl1 } = await sqliteIntrospect(db, filter, progress, () => {}, migrations);
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		resolver<Table>('table', hints),
+		resolver<Column>('column', hints),
+		'push',
+	);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (sqlStatements.length === 0) {
+		if (!json) {
+			render(`\n[${chalk.blue('i')}] No changes detected`);
+		}
+		return { status: 'no_changes' as const, dialect };
+	}
+
+	const suggestionHints = await suggestions(db, statements, hints);
+
+	if (hints.hasMissingHints()) {
+		return hints.toResponse();
+	}
+
+	if (explain) {
+		if (json) {
+			return explainJsonOutput(dialect, statements, suggestionHints);
+		}
+		const explainMessage = explainView('sqlite', groupedStatements, suggestionHints);
+		if (explainMessage) {
+			humanLog(explainMessage);
+		}
+		return { status: 'ok' as const, dialect };
+	}
+
+	if (!force && !json && isInteractive() && suggestionHints.length > 0) {
+		const { data } = await render(new Select(['No, abort', 'Yes, I want to execute all statements']));
+
+		if (data?.index === 0) {
+			render(`[${chalk.red('x')}] All changes were aborted`);
+			process.exit(0);
+		}
+	}
+
+	const lossStatements = suggestionHints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+
+	const allStatements = [...lossStatements, ...sqlStatements];
+
+	if (verbose) humanLog(highlightSQL(allStatements.join('\n')));
+
+	// no need to re-enable or re-disable PRAGMA foreign_keys, because this config lives per-connection
+	// https://sqlite.org/pragma.html#pragma_foreign_keys
+	// | Changing the foreign_keys setting affects the execution of all statements prepared using the database connection, including those prepared before the setting was changed.
+	await db.batch(allStatements);
+
+	if (!json) {
+		render(`[${chalk.green('\u2713')}] Changes applied`);
+	}
+	return { status: 'ok' as const, dialect };
+};
+
+export const suggestions = async (
+	connection: SQLiteClient,
+	jsonStatements: JsonStatement[],
+	hints: HintsHandler,
+) => {
+	const json = outputFormat() === 'json';
+	const useHints = json || !isInteractive();
+	const grouped: { hint: string; statement?: string }[] = [];
+
+	// TODO: generate truncations/recreates ??
+	for (const statement of jsonStatements) {
+		if (statement.type === 'drop_table') {
+			const name = statement.tableName;
+			const entity = ['public', name] as const;
+			if (hints.matchConfirm('table', entity)) continue;
+			const res = await connection.query(`select 1 from "${name}" limit 1;`);
+
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'table', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete non-empty '${name}' table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'drop_column') {
+			const { table, name } = statement.column;
+			const entity = ['public', table, name] as const;
+			if (hints.matchConfirm('column', entity)) continue;
+
+			const res = await connection.query(`select 1 from "${table}" limit 1;`);
+			if (res.length > 0) {
+				if (useHints) {
+					hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+				} else {
+					grouped.push({ hint: `You're about to delete '${name}' column in a non-empty '${table}' table` });
+				}
+			}
+			continue;
+		}
+
+		if (statement.type === 'add_column' && (statement.column.notNull && !statement.column.default)) {
+			const { table, name } = statement.column;
+			const entity = ['public', table, name] as const;
+			const res = await connection.query(`select 1 from "${table}" limit 1`);
+			const tableNonEmpty = res.length > 0;
+
+			if (hints.matchConfirm('add_not_null', entity)) {
+				if (tableNonEmpty) {
+					grouped.push({ hint: '', statement: `DELETE FROM "${table}" where true;` });
+				}
+				continue;
+			}
+
+			if (tableNonEmpty) {
+				if (useHints) {
+					hints.pushMissingHint({
+						type: 'confirm_data_loss',
+						kind: 'add_not_null',
+						entity,
+						reason: 'table_recreate',
+					});
+				} else {
+					grouped.push(
+						{
+							hint: `You're about to add not-null '${name}' column without default value to non-empty '${table}' table`,
+							statement: `DELETE FROM "${table}" where true;`,
+						},
+					);
+				}
+			}
+
+			continue;
+		}
+
+		if (statement.type === 'recreate_table') {
+			const droppedColumns = statement.from.columns.filter((col) =>
+				!statement.to.columns.some((c) => c.name === col.name)
+			);
+			if (droppedColumns.length === 0) continue;
+
+			const res = await connection.query(`select 1 from "${statement.from.name}" limit 1`);
+			if (res.length > 0) {
+				if (useHints) {
+					for (const droppedColumn of droppedColumns) {
+						const entity = ['public', statement.from.name, droppedColumn.name] as const;
+						if (hints.matchConfirm('column', entity)) continue;
+						hints.pushMissingHint({ type: 'confirm_data_loss', kind: 'column', entity, reason: 'non_empty' });
+					}
+				} else {
+					grouped.push(
+						{
+							hint: `You're about to drop ${
+								droppedColumns.map((col) => `'${col.name}'`).join(', ')
+							} column(s) in a non-empty '${statement.from.name}' table`,
+						},
+					);
+				}
+			}
+		}
+	}
+
+	return grouped;
+};
diff --git a/drizzle-kit/src/cli/commands/push.ts b/drizzle-kit/src/cli/commands/push.ts
deleted file mode 100644
index 31dd78722e..0000000000
--- a/drizzle-kit/src/cli/commands/push.ts
+++ /dev/null
@@ -1,639 +0,0 @@
-import chalk from 'chalk';
-import { randomUUID } from 'crypto';
-import { render } from 'hanji';
-import { serializePg } from 'src/serializer';
-import { fromJson } from '../../sqlgenerator';
-import { Select } from '../selector-ui';
-import { Entities } from '../validations/cli';
-import { CasingType } from '../validations/common';
-import { LibSQLCredentials } from '../validations/libsql';
-import type { MysqlCredentials } from '../validations/mysql';
-import { withStyle } from '../validations/outputs';
-import type { PostgresCredentials } from '../validations/postgres';
-import { SingleStoreCredentials } from '../validations/singlestore';
-import type { SqliteCredentials } from '../validations/sqlite';
-import { libSqlLogSuggestionsAndReturn } from './libSqlPushUtils';
-import {
-	filterStatements as mySqlFilterStatements,
-	logSuggestionsAndReturn as mySqlLogSuggestionsAndReturn,
-} from './mysqlPushUtils';
-import { pgSuggestions } from './pgPushUtils';
-import {
-	filterStatements as singleStoreFilterStatements,
-	logSuggestionsAndReturn as singleStoreLogSuggestionsAndReturn,
-} from './singlestorePushUtils';
-import { logSuggestionsAndReturn as sqliteSuggestions } from './sqlitePushUtils';
-
-export const mysqlPush = async (
-	schemaPath: string | string[],
-	credentials: MysqlCredentials,
-	tablesFilter: string[],
-	strict: boolean,
-	verbose: boolean,
-	force: boolean,
-	casing: CasingType | undefined,
-) => {
-	const { connectToMySQL } = await import('../connections');
-	const { mysqlPushIntrospect } = await import('./mysqlIntrospect');
-
-	const { db, database } = await connectToMySQL(credentials);
-
-	const { schema } = await mysqlPushIntrospect(db, database, tablesFilter);
-	const { prepareMySQLPush } = await import('./migrate');
-
-	const statements = await prepareMySQLPush(schemaPath, schema, casing);
-
-	const filteredStatements = mySqlFilterStatements(
-		statements.statements ?? [],
-		statements.validatedCur,
-		statements.validatedPrev,
-	);
-
-	try {
-		if (filteredStatements.length === 0) {
-			render(`[${chalk.blue('i')}] No changes detected`);
-		} else {
-			const {
-				shouldAskForApprove,
-				statementsToExecute,
-				columnsToRemove,
-				tablesToRemove,
-				tablesToTruncate,
-				infoToPrint,
-			} = await mySqlLogSuggestionsAndReturn(
-				db,
-				filteredStatements,
-				statements.validatedCur,
-			);
-
-			const filteredSqlStatements = fromJson(filteredStatements, 'mysql');
-
-			const uniqueSqlStatementsToExecute: string[] = [];
-			statementsToExecute.forEach((ss) => {
-				if (!uniqueSqlStatementsToExecute.includes(ss)) {
-					uniqueSqlStatementsToExecute.push(ss);
-				}
-			});
-			const uniqueFilteredSqlStatements: string[] = [];
-			filteredSqlStatements.forEach((ss) => {
-				if (!uniqueFilteredSqlStatements.includes(ss)) {
-					uniqueFilteredSqlStatements.push(ss);
-				}
-			});
-
-			if (verbose) {
-				console.log();
-				console.log(
-					withStyle.warning('You are about to execute current statements:'),
-				);
-				console.log();
-				console.log(
-					[...uniqueSqlStatementsToExecute, ...uniqueFilteredSqlStatements]
-						.map((s) => chalk.blue(s))
-						.join('\n'),
-				);
-				console.log();
-			}
-
-			if (!force && strict) {
-				if (!shouldAskForApprove) {
-					const { status, data } = await render(
-						new Select(['No, abort', `Yes, I want to execute all statements`]),
-					);
-					if (data?.index === 0) {
-						render(`[${chalk.red('x')}] All changes were aborted`);
-						process.exit(0);
-					}
-				}
-			}
-
-			if (!force && shouldAskForApprove) {
-				console.log(withStyle.warning('Found data-loss statements:'));
-				console.log(infoToPrint.join('\n'));
-				console.log();
-				console.log(
-					chalk.red.bold(
-						'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-					),
-				);
-
-				console.log(chalk.white('Do you still want to push changes?'));
-
-				const { status, data } = await render(
-					new Select([
-						'No, abort',
-						`Yes, I want to${
-							tablesToRemove.length > 0
-								? ` remove ${tablesToRemove.length} ${tablesToRemove.length > 1 ? 'tables' : 'table'},`
-								: ' '
-						}${
-							columnsToRemove.length > 0
-								? ` remove ${columnsToRemove.length} ${columnsToRemove.length > 1 ? 'columns' : 'column'},`
-								: ' '
-						}${
-							tablesToTruncate.length > 0
-								? ` truncate ${tablesToTruncate.length} ${tablesToTruncate.length > 1 ? 'tables' : 'table'}`
-								: ''
-						}`
-							.replace(/(^,)|(,$)/g, '')
-							.replace(/ +(?= )/g, ''),
-					]),
-				);
-				if (data?.index === 0) {
-					render(`[${chalk.red('x')}] All changes were aborted`);
-					process.exit(0);
-				}
-			}
-
-			for (const dStmnt of uniqueSqlStatementsToExecute) {
-				await db.query(dStmnt);
-			}
-
-			for (const statement of uniqueFilteredSqlStatements) {
-				await db.query(statement);
-			}
-			if (filteredStatements.length > 0) {
-				render(`[${chalk.green('✓')}] Changes applied`);
-			} else {
-				render(`[${chalk.blue('i')}] No changes detected`);
-			}
-		}
-	} catch (e) {
-		console.log(e);
-	}
-};
-
-export const singlestorePush = async (
-	schemaPath: string | string[],
-	credentials: SingleStoreCredentials,
-	tablesFilter: string[],
-	strict: boolean,
-	verbose: boolean,
-	force: boolean,
-	casing: CasingType | undefined,
-) => {
-	const { connectToSingleStore } = await import('../connections');
-	const { singlestorePushIntrospect } = await import('./singlestoreIntrospect');
-
-	const { db, database } = await connectToSingleStore(credentials);
-
-	const { schema } = await singlestorePushIntrospect(
-		db,
-		database,
-		tablesFilter,
-	);
-	const { prepareSingleStorePush } = await import('./migrate');
-
-	const statements = await prepareSingleStorePush(schemaPath, schema, casing);
-
-	const filteredStatements = singleStoreFilterStatements(
-		statements.statements ?? [],
-		statements.validatedCur,
-		statements.validatedPrev,
-	);
-
-	try {
-		if (filteredStatements.length === 0) {
-			render(`[${chalk.blue('i')}] No changes detected`);
-		} else {
-			const {
-				shouldAskForApprove,
-				statementsToExecute,
-				columnsToRemove,
-				tablesToRemove,
-				tablesToTruncate,
-				infoToPrint,
-				schemasToRemove,
-			} = await singleStoreLogSuggestionsAndReturn(
-				db,
-				filteredStatements,
-				statements.validatedCur,
-				statements.validatedPrev,
-			);
-
-			if (verbose) {
-				console.log();
-				console.log(
-					withStyle.warning('You are about to execute current statements:'),
-				);
-				console.log();
-				console.log(statementsToExecute.map((s) => chalk.blue(s)).join('\n'));
-				console.log();
-			}
-
-			if (!force && strict) {
-				if (!shouldAskForApprove) {
-					const { status, data } = await render(
-						new Select(['No, abort', `Yes, I want to execute all statements`]),
-					);
-					if (data?.index === 0) {
-						render(`[${chalk.red('x')}] All changes were aborted`);
-						process.exit(0);
-					}
-				}
-			}
-
-			if (!force && shouldAskForApprove) {
-				console.log(withStyle.warning('Found data-loss statements:'));
-				console.log(infoToPrint.join('\n'));
-				console.log();
-				console.log(
-					chalk.red.bold(
-						'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-					),
-				);
-
-				console.log(chalk.white('Do you still want to push changes?'));
-
-				const { status, data } = await render(
-					new Select([
-						'No, abort',
-						`Yes, I want to${
-							tablesToRemove.length > 0
-								? ` remove ${tablesToRemove.length} ${tablesToRemove.length > 1 ? 'tables' : 'table'},`
-								: ' '
-						}${
-							columnsToRemove.length > 0
-								? ` remove ${columnsToRemove.length} ${columnsToRemove.length > 1 ? 'columns' : 'column'},`
-								: ' '
-						}${
-							tablesToTruncate.length > 0
-								? ` truncate ${tablesToTruncate.length} ${tablesToTruncate.length > 1 ? 'tables' : 'table'}`
-								: ''
-						}`
-							.replace(/(^,)|(,$)/g, '')
-							.replace(/ +(?= )/g, ''),
-					]),
-				);
-				if (data?.index === 0) {
-					render(`[${chalk.red('x')}] All changes were aborted`);
-					process.exit(0);
-				}
-			}
-
-			for (const dStmnt of statementsToExecute) {
-				await db.query(dStmnt);
-			}
-
-			if (filteredStatements.length > 0) {
-				render(`[${chalk.green('✓')}] Changes applied`);
-			} else {
-				render(`[${chalk.blue('i')}] No changes detected`);
-			}
-		}
-	} catch (e) {
-		console.log(e);
-	}
-};
-
-export const pgPush = async (
-	schemaPath: string | string[],
-	verbose: boolean,
-	strict: boolean,
-	credentials: PostgresCredentials,
-	tablesFilter: string[],
-	schemasFilter: string[],
-	entities: Entities,
-	force: boolean,
-	casing: CasingType | undefined,
-) => {
-	const { preparePostgresDB } = await import('../connections');
-	const { pgPushIntrospect } = await import('./pgIntrospect');
-
-	const db = await preparePostgresDB(credentials);
-	const serialized = await serializePg(schemaPath, casing, schemasFilter);
-
-	const { schema } = await pgPushIntrospect(db, tablesFilter, schemasFilter, entities, serialized);
-
-	const { preparePgPush } = await import('./migrate');
-
-	const statements = await preparePgPush(
-		{ id: randomUUID(), prevId: schema.id, ...serialized },
-		schema,
-	);
-
-	try {
-		if (statements.sqlStatements.length === 0) {
-			render(`[${chalk.blue('i')}] No changes detected`);
-		} else {
-			// const filteredStatements = filterStatements(statements.statements);
-			const {
-				shouldAskForApprove,
-				statementsToExecute,
-				columnsToRemove,
-				tablesToRemove,
-				matViewsToRemove,
-				tablesToTruncate,
-				infoToPrint,
-				schemasToRemove,
-			} = await pgSuggestions(db, statements.statements);
-
-			if (verbose) {
-				console.log();
-				// console.log(chalk.gray('Verbose logs:'));
-				console.log(
-					withStyle.warning('You are about to execute current statements:'),
-				);
-				console.log();
-				console.log(statementsToExecute.map((s) => chalk.blue(s)).join('\n'));
-				console.log();
-			}
-
-			if (!force && strict) {
-				if (!shouldAskForApprove) {
-					const { status, data } = await render(
-						new Select(['No, abort', `Yes, I want to execute all statements`]),
-					);
-					if (data?.index === 0) {
-						render(`[${chalk.red('x')}] All changes were aborted`);
-						process.exit(0);
-					}
-				}
-			}
-
-			if (!force && shouldAskForApprove) {
-				console.log(withStyle.warning('Found data-loss statements:'));
-				console.log(infoToPrint.join('\n'));
-				console.log();
-				console.log(
-					chalk.red.bold(
-						'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-					),
-				);
-
-				console.log(chalk.white('Do you still want to push changes?'));
-
-				const { status, data } = await render(
-					new Select([
-						'No, abort',
-						`Yes, I want to${
-							tablesToRemove.length > 0
-								? ` remove ${tablesToRemove.length} ${tablesToRemove.length > 1 ? 'tables' : 'table'},`
-								: ' '
-						}${
-							columnsToRemove.length > 0
-								? ` remove ${columnsToRemove.length} ${columnsToRemove.length > 1 ? 'columns' : 'column'},`
-								: ' '
-						}${
-							tablesToTruncate.length > 0
-								? ` truncate ${tablesToTruncate.length} ${tablesToTruncate.length > 1 ? 'tables' : 'table'}`
-								: ''
-						}${
-							matViewsToRemove.length > 0
-								? ` remove ${matViewsToRemove.length} ${
-									matViewsToRemove.length > 1 ? 'materialized views' : 'materialize view'
-								},`
-								: ' '
-						}`
-							.replace(/(^,)|(,$)/g, '')
-							.replace(/ +(?= )/g, ''),
-					]),
-				);
-				if (data?.index === 0) {
-					render(`[${chalk.red('x')}] All changes were aborted`);
-					process.exit(0);
-				}
-			}
-
-			for (const dStmnt of statementsToExecute) {
-				await db.query(dStmnt);
-			}
-
-			if (statements.statements.length > 0) {
-				render(`[${chalk.green('✓')}] Changes applied`);
-			} else {
-				render(`[${chalk.blue('i')}] No changes detected`);
-			}
-		}
-	} catch (e) {
-		console.error(e);
-	}
-};
-
-export const sqlitePush = async (
-	schemaPath: string | string[],
-	verbose: boolean,
-	strict: boolean,
-	credentials: SqliteCredentials,
-	tablesFilter: string[],
-	force: boolean,
-	casing: CasingType | undefined,
-) => {
-	const { connectToSQLite } = await import('../connections');
-	const { sqlitePushIntrospect } = await import('./sqliteIntrospect');
-
-	const db = await connectToSQLite(credentials);
-	const { schema } = await sqlitePushIntrospect(db, tablesFilter);
-	const { prepareSQLitePush } = await import('./migrate');
-
-	const statements = await prepareSQLitePush(schemaPath, schema, casing);
-
-	if (statements.sqlStatements.length === 0) {
-		render(`\n[${chalk.blue('i')}] No changes detected`);
-	} else {
-		const {
-			shouldAskForApprove,
-			statementsToExecute,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-			schemasToRemove,
-		} = await sqliteSuggestions(
-			db,
-			statements.statements,
-			statements.squashedPrev,
-			statements.squashedCur,
-			statements.meta!,
-		);
-
-		if (verbose && statementsToExecute.length > 0) {
-			console.log();
-			console.log(
-				withStyle.warning('You are about to execute current statements:'),
-			);
-			console.log();
-			console.log(statementsToExecute.map((s) => chalk.blue(s)).join('\n'));
-			console.log();
-		}
-
-		if (!force && strict) {
-			if (!shouldAskForApprove) {
-				const { status, data } = await render(
-					new Select(['No, abort', `Yes, I want to execute all statements`]),
-				);
-				if (data?.index === 0) {
-					render(`[${chalk.red('x')}] All changes were aborted`);
-					process.exit(0);
-				}
-			}
-		}
-
-		if (!force && shouldAskForApprove) {
-			console.log(withStyle.warning('Found data-loss statements:'));
-			console.log(infoToPrint.join('\n'));
-			console.log();
-			console.log(
-				chalk.red.bold(
-					'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-				),
-			);
-
-			console.log(chalk.white('Do you still want to push changes?'));
-
-			const { status, data } = await render(
-				new Select([
-					'No, abort',
-					`Yes, I want to${
-						tablesToRemove.length > 0
-							? ` remove ${tablesToRemove.length} ${tablesToRemove.length > 1 ? 'tables' : 'table'},`
-							: ' '
-					}${
-						columnsToRemove.length > 0
-							? ` remove ${columnsToRemove.length} ${columnsToRemove.length > 1 ? 'columns' : 'column'},`
-							: ' '
-					}${
-						tablesToTruncate.length > 0
-							? ` truncate ${tablesToTruncate.length} ${tablesToTruncate.length > 1 ? 'tables' : 'table'}`
-							: ''
-					}`
-						.trimEnd()
-						.replace(/(^,)|(,$)/g, '')
-						.replace(/ +(?= )/g, ''),
-				]),
-			);
-			if (data?.index === 0) {
-				render(`[${chalk.red('x')}] All changes were aborted`);
-				process.exit(0);
-			}
-		}
-
-		if (statementsToExecute.length === 0) {
-			render(`\n[${chalk.blue('i')}] No changes detected`);
-		} else {
-			// D1-HTTP does not support transactions
-			// there might a be a better way to fix this
-			// in the db connection itself
-			const isNotD1 = !('driver' in credentials && credentials.driver === 'd1-http');
-			isNotD1 ?? await db.run('begin');
-			try {
-				for (const dStmnt of statementsToExecute) {
-					await db.run(dStmnt);
-				}
-				isNotD1 ?? await db.run('commit');
-			} catch (e) {
-				console.error(e);
-				isNotD1 ?? await db.run('rollback');
-				process.exit(1);
-			}
-			render(`[${chalk.green('✓')}] Changes applied`);
-		}
-	}
-};
-
-export const libSQLPush = async (
-	schemaPath: string | string[],
-	verbose: boolean,
-	strict: boolean,
-	credentials: LibSQLCredentials,
-	tablesFilter: string[],
-	force: boolean,
-	casing: CasingType | undefined,
-) => {
-	const { connectToLibSQL } = await import('../connections');
-	const { sqlitePushIntrospect } = await import('./sqliteIntrospect');
-
-	const db = await connectToLibSQL(credentials);
-	const { schema } = await sqlitePushIntrospect(db, tablesFilter);
-
-	const { prepareLibSQLPush } = await import('./migrate');
-
-	const statements = await prepareLibSQLPush(schemaPath, schema, casing);
-
-	if (statements.sqlStatements.length === 0) {
-		render(`\n[${chalk.blue('i')}] No changes detected`);
-	} else {
-		const {
-			shouldAskForApprove,
-			statementsToExecute,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-		} = await libSqlLogSuggestionsAndReturn(
-			db,
-			statements.statements,
-			statements.squashedPrev,
-			statements.squashedCur,
-			statements.meta!,
-		);
-
-		if (verbose && statementsToExecute.length > 0) {
-			console.log();
-			console.log(
-				withStyle.warning('You are about to execute current statements:'),
-			);
-			console.log();
-			console.log(statementsToExecute.map((s) => chalk.blue(s)).join('\n'));
-			console.log();
-		}
-
-		if (!force && strict) {
-			if (!shouldAskForApprove) {
-				const { status, data } = await render(
-					new Select(['No, abort', `Yes, I want to execute all statements`]),
-				);
-				if (data?.index === 0) {
-					render(`[${chalk.red('x')}] All changes were aborted`);
-					process.exit(0);
-				}
-			}
-		}
-
-		if (!force && shouldAskForApprove) {
-			console.log(withStyle.warning('Found data-loss statements:'));
-			console.log(infoToPrint.join('\n'));
-			console.log();
-			console.log(
-				chalk.red.bold(
-					'THIS ACTION WILL CAUSE DATA LOSS AND CANNOT BE REVERTED\n',
-				),
-			);
-
-			console.log(chalk.white('Do you still want to push changes?'));
-
-			const { status, data } = await render(
-				new Select([
-					'No, abort',
-					`Yes, I want to${
-						tablesToRemove.length > 0
-							? ` remove ${tablesToRemove.length} ${tablesToRemove.length > 1 ? 'tables' : 'table'},`
-							: ' '
-					}${
-						columnsToRemove.length > 0
-							? ` remove ${columnsToRemove.length} ${columnsToRemove.length > 1 ? 'columns' : 'column'},`
-							: ' '
-					}${
-						tablesToTruncate.length > 0
-							? ` truncate ${tablesToTruncate.length} ${tablesToTruncate.length > 1 ? 'tables' : 'table'}`
-							: ''
-					}`
-						.trimEnd()
-						.replace(/(^,)|(,$)/g, '')
-						.replace(/ +(?= )/g, ''),
-				]),
-			);
-			if (data?.index === 0) {
-				render(`[${chalk.red('x')}] All changes were aborted`);
-				process.exit(0);
-			}
-		}
-
-		if (statementsToExecute.length === 0) {
-			render(`\n[${chalk.blue('i')}] No changes detected`);
-		} else {
-			await db.batchWithPragma!(statementsToExecute);
-			render(`[${chalk.green('✓')}] Changes applied`);
-		}
-	}
-};
diff --git a/drizzle-kit/src/cli/commands/singlestoreIntrospect.ts b/drizzle-kit/src/cli/commands/singlestoreIntrospect.ts
deleted file mode 100644
index 27d8c59c50..0000000000
--- a/drizzle-kit/src/cli/commands/singlestoreIntrospect.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { renderWithTask } from 'hanji';
-import { Minimatch } from 'minimatch';
-import { originUUID } from '../../global';
-import type { SingleStoreSchema } from '../../serializer/singlestoreSchema';
-import { fromDatabase } from '../../serializer/singlestoreSerializer';
-import type { DB } from '../../utils';
-import { ProgressView } from '../views';
-
-export const singlestorePushIntrospect = async (
-	db: DB,
-	databaseName: string,
-	filters: string[],
-) => {
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new ProgressView(
-		'Pulling schema from database...',
-		'Pulling schema from database...',
-	);
-	const res = await renderWithTask(
-		progress,
-		fromDatabase(db, databaseName, filter),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as SingleStoreSchema;
-	const { internal, ...schemaWithoutInternals } = schema;
-	return { schema: schemaWithoutInternals };
-};
diff --git a/drizzle-kit/src/cli/commands/singlestorePushUtils.ts b/drizzle-kit/src/cli/commands/singlestorePushUtils.ts
deleted file mode 100644
index 5a550a2397..0000000000
--- a/drizzle-kit/src/cli/commands/singlestorePushUtils.ts
+++ /dev/null
@@ -1,456 +0,0 @@
-import chalk from 'chalk';
-import { render } from 'hanji';
-import { fromJson } from 'src/sqlgenerator';
-import { TypeOf } from 'zod';
-import { JsonAlterColumnTypeStatement, JsonStatement } from '../../jsonStatements';
-import { Column, SingleStoreSchemaSquashed, SingleStoreSquasher } from '../../serializer/singlestoreSchema';
-import { singlestoreSchema } from '../../serializer/singlestoreSchema';
-import { type DB, findAddedAndRemoved } from '../../utils';
-import { Select } from '../selector-ui';
-import { withStyle } from '../validations/outputs';
-
-export const filterStatements = (
-	statements: JsonStatement[],
-	currentSchema: TypeOf<typeof singlestoreSchema>,
-	prevSchema: TypeOf<typeof singlestoreSchema>,
-) => {
-	return statements.filter((statement) => {
-		if (statement.type === 'alter_table_alter_column_set_type') {
-			// Don't need to handle it on migrations step and introspection
-			// but for both it should be skipped
-			if (
-				statement.oldDataType.startsWith('tinyint')
-				&& statement.newDataType.startsWith('boolean')
-			) {
-				return false;
-			}
-
-			if (
-				statement.oldDataType.startsWith('bigint unsigned')
-				&& statement.newDataType.startsWith('serial')
-			) {
-				return false;
-			}
-
-			if (
-				statement.oldDataType.startsWith('serial')
-				&& statement.newDataType.startsWith('bigint unsigned')
-			) {
-				return false;
-			}
-		} else if (statement.type === 'alter_table_alter_column_set_default') {
-			if (
-				statement.newDefaultValue === false
-				&& statement.oldDefaultValue === 0
-				&& statement.newDataType === 'boolean'
-			) {
-				return false;
-			}
-			if (
-				statement.newDefaultValue === true
-				&& statement.oldDefaultValue === 1
-				&& statement.newDataType === 'boolean'
-			) {
-				return false;
-			}
-		} else if (statement.type === 'delete_unique_constraint') {
-			const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
-			// only if constraint was removed from a serial column, than treat it as removed
-			// const serialStatement = statements.find(
-			//   (it) => it.type === "alter_table_alter_column_set_type"
-			// ) as JsonAlterColumnTypeStatement;
-			// if (
-			//   serialStatement?.oldDataType.startsWith("bigint unsigned") &&
-			//   serialStatement?.newDataType.startsWith("serial") &&
-			//   serialStatement.columnName ===
-			//     SingleStoreSquasher.unsquashUnique(statement.data).columns[0]
-			// ) {
-			//   return false;
-			// }
-			// Check if uniqueindex was only on this column, that is serial
-
-			// if now serial and was not serial and was unique index
-			if (
-				unsquashed.columns.length === 1
-				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.type === 'serial'
-				&& prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.type === 'serial'
-				&& currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]]
-						.name === unsquashed.columns[0]
-			) {
-				return false;
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_notnull') {
-			// only if constraint was removed from a serial column, than treat it as removed
-			const serialStatement = statements.find(
-				(it) => it.type === 'alter_table_alter_column_set_type',
-			) as JsonAlterColumnTypeStatement;
-			if (
-				serialStatement?.oldDataType.startsWith('bigint unsigned')
-				&& serialStatement?.newDataType.startsWith('serial')
-				&& serialStatement.columnName === statement.columnName
-				&& serialStatement.tableName === statement.tableName
-			) {
-				return false;
-			}
-			if (statement.newDataType === 'serial' && !statement.columnNotNull) {
-				return false;
-			}
-			if (statement.columnAutoIncrement) {
-				return false;
-			}
-		}
-
-		return true;
-	});
-};
-
-export function findColumnTypeAlternations(
-	columns1: Record<string, Column>,
-	columns2: Record<string, Column>,
-): string[] {
-	const changes: string[] = [];
-
-	for (const key in columns1) {
-		if (columns1.hasOwnProperty(key) && columns2.hasOwnProperty(key)) {
-			const col1 = columns1[key];
-			const col2 = columns2[key];
-			if (col1.type !== col2.type) {
-				changes.push(col2.name);
-			}
-		}
-	}
-
-	return changes;
-}
-
-export const logSuggestionsAndReturn = async (
-	db: DB,
-	statements: JsonStatement[],
-	json2: TypeOf<typeof singlestoreSchema>,
-	json1: TypeOf<typeof singlestoreSchema>,
-) => {
-	let shouldAskForApprove = false;
-	const statementsToExecute: string[] = [];
-	const infoToPrint: string[] = [];
-
-	const tablesToRemove: string[] = [];
-	const columnsToRemove: string[] = [];
-	const schemasToRemove: string[] = [];
-	const tablesToTruncate: string[] = [];
-
-	for (const statement of statements) {
-		if (statement.type === 'drop_table') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table with ${count} items`,
-				);
-				tablesToRemove.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_drop_column') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column in ${statement.tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'drop_schema') {
-			const res = await db.query(
-				`select count(*) as count from information_schema.tables where table_schema = \`${statement.name}\`;`,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.name,
-						)
-					} schema with ${count} tables`,
-				);
-				schemasToRemove.push(statement.name);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_set_type') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${
-						chalk.underline(
-							statement.columnName,
-						)
-					} column type from ${
-						chalk.underline(
-							statement.oldDataType,
-						)
-					} to ${chalk.underline(statement.newDataType)} with ${count} items`,
-				);
-				statementsToExecute.push(`truncate table ${statement.tableName};`);
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_default') {
-			if (statement.columnNotNull) {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to remove default value from ${
-							chalk.underline(
-								statement.columnName,
-							)
-						} not-null column with ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-			// shouldAskForApprove = true;
-		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
-			if (typeof statement.columnDefault === 'undefined') {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to set not-null constraint to ${
-							chalk.underline(
-								statement.columnName,
-							)
-						} column without default, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_pk') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-
-			// if drop pk and json2 has autoincrement in table -> exit process with error
-			if (
-				Object.values(json2.tables[statement.tableName].columns).filter(
-					(column) => column.autoincrement,
-				).length > 0
-			) {
-				console.log(
-					`${
-						withStyle.errorWarning(
-							`You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to change ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} primary key. This statements may fail and you table may left without primary key`,
-				);
-
-				tablesToTruncate.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-		} else if (statement.type === 'delete_composite_pk') {
-			// if drop pk and json2 has autoincrement in table -> exit process with error
-			if (
-				Object.values(json2.tables[statement.tableName].columns).filter(
-					(column) => column.autoincrement,
-				).length > 0
-			) {
-				console.log(
-					`${
-						withStyle.errorWarning(
-							`You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-		} else if (statement.type === 'alter_table_add_column') {
-			if (
-				statement.column.notNull
-				&& typeof statement.column.default === 'undefined'
-			) {
-				const res = await db.query(
-					`select count(*) as count from \`${statement.tableName}\``,
-				);
-				const count = Number(res[0].count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about to add not-null ${
-							chalk.underline(
-								statement.column.name,
-							)
-						} column without default value, which contains ${count} items`,
-					);
-
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'create_unique_constraint') {
-			const res = await db.query(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				const unsquashedUnique = SingleStoreSquasher.unsquashUnique(statement.data);
-				console.log(
-					`· You're about to add ${
-						chalk.underline(
-							unsquashedUnique.name,
-						)
-					} unique constraint to the table, which contains ${count} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table?\n`,
-				);
-				const { status, data } = await render(
-					new Select([
-						'No, add the constraint without truncating the table',
-						`Yes, truncate the table`,
-					]),
-				);
-				if (data?.index === 1) {
-					tablesToTruncate.push(statement.tableName);
-					statementsToExecute.push(`truncate table ${statement.tableName};`);
-					shouldAskForApprove = true;
-				}
-			}
-		} else if (statement.type === 'singlestore_recreate_table') {
-			const tableName = statement.tableName;
-
-			const prevColumns = json1.tables[tableName].columns;
-			const currentColumns = json2.tables[tableName].columns;
-			const { removedColumns, addedColumns } = findAddedAndRemoved(
-				Object.keys(prevColumns),
-				Object.keys(currentColumns),
-			);
-
-			if (removedColumns.length) {
-				for (const removedColumn of removedColumns) {
-					const res = await db.query<{ count: string }>(
-						`select count(\`${tableName}\`.\`${removedColumn}\`) as count from \`${tableName}\``,
-					);
-
-					const count = Number(res[0].count);
-					if (count > 0) {
-						infoToPrint.push(
-							`· You're about to delete ${
-								chalk.underline(
-									removedColumn,
-								)
-							} column in ${tableName} table with ${count} items`,
-						);
-						columnsToRemove.push(removedColumn);
-						shouldAskForApprove = true;
-					}
-				}
-			}
-
-			if (addedColumns.length) {
-				for (const addedColumn of addedColumns) {
-					const [res] = await db.query<{ count: string }>(
-						`select count(*) as count from \`${tableName}\``,
-					);
-
-					const columnConf = json2.tables[tableName].columns[addedColumn];
-
-					const count = Number(res.count);
-					if (count > 0 && columnConf.notNull && !columnConf.default) {
-						infoToPrint.push(
-							`· You're about to add not-null ${
-								chalk.underline(
-									addedColumn,
-								)
-							} column without default value to table, which contains ${count} items`,
-						);
-						shouldAskForApprove = true;
-						tablesToTruncate.push(tableName);
-
-						statementsToExecute.push(`TRUNCATE TABLE \`${tableName}\`;`);
-					}
-				}
-			}
-
-			const columnWithChangedType = findColumnTypeAlternations(prevColumns, currentColumns);
-			for (const column of columnWithChangedType) {
-				const [res] = await db.query<{ count: string }>(
-					`select count(*) as count from \`${tableName}\` WHERE \`${tableName}\`.\`${column}\` IS NOT NULL;`,
-				);
-
-				const count = Number(res.count);
-				if (count > 0) {
-					infoToPrint.push(
-						`· You're about recreate ${chalk.underline(tableName)} table with data type changing for ${
-							chalk.underline(
-								column,
-							)
-						} column, which contains ${count} items`,
-					);
-					shouldAskForApprove = true;
-					tablesToTruncate.push(tableName);
-
-					statementsToExecute.push(`TRUNCATE TABLE \`${tableName}\`;`);
-				}
-			}
-		}
-
-		const stmnt = fromJson([statement], 'singlestore', 'push');
-		if (typeof stmnt !== 'undefined') {
-			statementsToExecute.push(...stmnt);
-		}
-	}
-
-	return {
-		statementsToExecute,
-		shouldAskForApprove,
-		infoToPrint,
-		columnsToRemove: [...new Set(columnsToRemove)],
-		schemasToRemove: [...new Set(schemasToRemove)],
-		tablesToTruncate: [...new Set(tablesToTruncate)],
-		tablesToRemove: [...new Set(tablesToRemove)],
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/singlestoreUp.ts b/drizzle-kit/src/cli/commands/singlestoreUp.ts
index dc5004ed09..1325952fb8 100644
--- a/drizzle-kit/src/cli/commands/singlestoreUp.ts
+++ b/drizzle-kit/src/cli/commands/singlestoreUp.ts
@@ -1 +1,26 @@
-export const upSinglestoreHandler = (out: string) => {};
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { Journal } from '../../utils';
+
+export const upSinglestoreHandler = (out: string) => {
+	// if there is meta folder - and there is a journal - it's version <8
+	const metaPath = join(out, 'meta');
+	const journalPath = join(metaPath, '_journal.json');
+	if (existsSync(metaPath) && existsSync(journalPath)) {
+		const journal: Journal = JSON.parse(readFileSync(journalPath).toString());
+		if (Number(journal.version) < 8) {
+			for (const entry of journal.entries) {
+				const snapshotPrefix = entry.tag.split('_')[0];
+				const oldSnapshot = readFileSync(join(metaPath, `${snapshotPrefix}_snapshot.json`));
+				const oldSql = readFileSync(join(out, `${entry.tag}.sql`));
+
+				writeFileSync(join(out, `${entry.tag}/snapshot.json`), oldSnapshot);
+				writeFileSync(join(out, `${entry.tag}/migration.sql`), oldSql);
+
+				unlinkSync(join(out, `${entry.tag}.sql`));
+			}
+
+			rmSync(metaPath);
+		}
+	}
+};
diff --git a/drizzle-kit/src/cli/commands/sqliteIntrospect.ts b/drizzle-kit/src/cli/commands/sqliteIntrospect.ts
deleted file mode 100644
index 1c62498f5e..0000000000
--- a/drizzle-kit/src/cli/commands/sqliteIntrospect.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { renderWithTask } from 'hanji';
-import { Minimatch } from 'minimatch';
-import { originUUID } from '../../global';
-import { schemaToTypeScript } from '../../introspect-sqlite';
-import type { SQLiteSchema } from '../../serializer/sqliteSchema';
-import { fromDatabase } from '../../serializer/sqliteSerializer';
-import type { SQLiteDB } from '../../utils';
-import { Casing } from '../validations/common';
-import type { SqliteCredentials } from '../validations/sqlite';
-import { IntrospectProgress, ProgressView } from '../views';
-
-export const sqliteIntrospect = async (
-	credentials: SqliteCredentials,
-	filters: string[],
-	casing: Casing,
-) => {
-	const { connectToSQLite } = await import('../connections');
-	const db = await connectToSQLite(credentials);
-
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new IntrospectProgress();
-	const res = await renderWithTask(
-		progress,
-		fromDatabase(db, filter, (stage, count, status) => {
-			progress.update(stage, count, status);
-		}),
-	);
-
-	const schema = { id: originUUID, prevId: '', ...res } as SQLiteSchema;
-	const ts = schemaToTypeScript(schema, casing);
-	return { schema, ts };
-};
-
-export const sqlitePushIntrospect = async (db: SQLiteDB, filters: string[]) => {
-	const matchers = filters.map((it) => {
-		return new Minimatch(it);
-	});
-
-	const filter = (tableName: string) => {
-		if (matchers.length === 0) return true;
-
-		let flags: boolean[] = [];
-
-		for (let matcher of matchers) {
-			if (matcher.negate) {
-				if (!matcher.match(tableName)) {
-					flags.push(false);
-				}
-			}
-
-			if (matcher.match(tableName)) {
-				flags.push(true);
-			}
-		}
-
-		if (flags.length > 0) {
-			return flags.every(Boolean);
-		}
-		return false;
-	};
-
-	const progress = new ProgressView(
-		'Pulling schema from database...',
-		'Pulling schema from database...',
-	);
-	const res = await renderWithTask(progress, fromDatabase(db, filter));
-
-	const schema = { id: originUUID, prevId: '', ...res } as SQLiteSchema;
-	return { schema };
-};
diff --git a/drizzle-kit/src/cli/commands/sqlitePushUtils.ts b/drizzle-kit/src/cli/commands/sqlitePushUtils.ts
deleted file mode 100644
index a18b369451..0000000000
--- a/drizzle-kit/src/cli/commands/sqlitePushUtils.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import chalk from 'chalk';
-
-import { SQLiteSchemaInternal, SQLiteSchemaSquashed, SQLiteSquasher } from '../../serializer/sqliteSchema';
-import {
-	CreateSqliteIndexConvertor,
-	fromJson,
-	SQLiteCreateTableConvertor,
-	SQLiteDropTableConvertor,
-	SqliteRenameTableConvertor,
-} from '../../sqlgenerator';
-
-import type { JsonStatement } from '../../jsonStatements';
-import { findAddedAndRemoved, type SQLiteDB } from '../../utils';
-
-export const _moveDataStatements = (
-	tableName: string,
-	json: SQLiteSchemaSquashed,
-	dataLoss: boolean = false,
-) => {
-	const statements: string[] = [];
-
-	const newTableName = `__new_${tableName}`;
-
-	// create table statement from a new json2 with proper name
-	const tableColumns = Object.values(json.tables[tableName].columns);
-	const referenceData = Object.values(json.tables[tableName].foreignKeys);
-	const compositePKs = Object.values(
-		json.tables[tableName].compositePrimaryKeys,
-	).map((it) => SQLiteSquasher.unsquashPK(it));
-	const checkConstraints = Object.values(json.tables[tableName].checkConstraints);
-
-	const mappedCheckConstraints: string[] = checkConstraints.map((it) =>
-		it.replaceAll(`"${tableName}".`, `"${newTableName}".`)
-			.replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`)
-			.replaceAll(`${tableName}.`, `${newTableName}.`)
-			.replaceAll(`'${tableName}'.`, `\`${newTableName}\`.`)
-	);
-
-	const fks = referenceData.map((it) => SQLiteSquasher.unsquashPushFK(it));
-
-	// create new table
-	statements.push(
-		new SQLiteCreateTableConvertor().convert({
-			type: 'sqlite_create_table',
-			tableName: newTableName,
-			columns: tableColumns,
-			referenceData: fks,
-			compositePKs,
-			checkConstraints: mappedCheckConstraints,
-		}),
-	);
-
-	// move data
-	if (!dataLoss) {
-		const columns = Object.keys(json.tables[tableName].columns).map(
-			(c) => `"${c}"`,
-		);
-
-		statements.push(
-			`INSERT INTO \`${newTableName}\`(${
-				columns.join(
-					', ',
-				)
-			}) SELECT ${columns.join(', ')} FROM \`${tableName}\`;`,
-		);
-	}
-
-	statements.push(
-		new SQLiteDropTableConvertor().convert({
-			type: 'drop_table',
-			tableName: tableName,
-			schema: '',
-		}),
-	);
-
-	// rename table
-	statements.push(
-		new SqliteRenameTableConvertor().convert({
-			fromSchema: '',
-			tableNameFrom: newTableName,
-			tableNameTo: tableName,
-			toSchema: '',
-			type: 'rename_table',
-		}),
-	);
-
-	for (const idx of Object.values(json.tables[tableName].indexes)) {
-		statements.push(
-			new CreateSqliteIndexConvertor().convert({
-				type: 'create_index',
-				tableName: tableName,
-				schema: '',
-				data: idx,
-			}),
-		);
-	}
-
-	return statements;
-};
-
-export const getOldTableName = (
-	tableName: string,
-	meta: SQLiteSchemaInternal['_meta'],
-) => {
-	for (const key of Object.keys(meta.tables)) {
-		const value = meta.tables[key];
-		if (`"${tableName}"` === value) {
-			return key.substring(1, key.length - 1);
-		}
-	}
-	return tableName;
-};
-
-export const getNewTableName = (
-	tableName: string,
-	meta: SQLiteSchemaInternal['_meta'],
-) => {
-	if (typeof meta.tables[`"${tableName}"`] !== 'undefined') {
-		return meta.tables[`"${tableName}"`].substring(
-			1,
-			meta.tables[`"${tableName}"`].length - 1,
-		);
-	}
-	return tableName;
-};
-
-export const logSuggestionsAndReturn = async (
-	connection: SQLiteDB,
-	statements: JsonStatement[],
-	json1: SQLiteSchemaSquashed,
-	json2: SQLiteSchemaSquashed,
-	meta: SQLiteSchemaInternal['_meta'],
-) => {
-	let shouldAskForApprove = false;
-	const statementsToExecute: string[] = [];
-	const infoToPrint: string[] = [];
-
-	const tablesToRemove: string[] = [];
-	const columnsToRemove: string[] = [];
-	const schemasToRemove: string[] = [];
-	const tablesToTruncate: string[] = [];
-
-	for (const statement of statements) {
-		if (statement.type === 'drop_table') {
-			const res = await connection.query<{ count: string }>(
-				`select count(*) as count from \`${statement.tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							statement.tableName,
-						)
-					} table with ${count} items`,
-				);
-				tablesToRemove.push(statement.tableName);
-				shouldAskForApprove = true;
-			}
-
-			const fromJsonStatement = fromJson([statement], 'sqlite', 'push');
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (statement.type === 'alter_table_drop_column') {
-			const tableName = statement.tableName;
-			const columnName = statement.columnName;
-
-			const res = await connection.query<{ count: string }>(
-				`select count(\`${tableName}\`.\`${columnName}\`) as count from \`${tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to delete ${
-						chalk.underline(
-							columnName,
-						)
-					} column in ${tableName} table with ${count} items`,
-				);
-				columnsToRemove.push(`${tableName}_${statement.columnName}`);
-				shouldAskForApprove = true;
-			}
-
-			const fromJsonStatement = fromJson([statement], 'sqlite', 'push');
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (
-			statement.type === 'sqlite_alter_table_add_column'
-			&& (statement.column.notNull && !statement.column.default)
-		) {
-			const tableName = statement.tableName;
-			const columnName = statement.column.name;
-			const res = await connection.query<{ count: string }>(
-				`select count(*) as count from \`${tableName}\``,
-			);
-			const count = Number(res[0].count);
-			if (count > 0) {
-				infoToPrint.push(
-					`· You're about to add not-null ${
-						chalk.underline(
-							columnName,
-						)
-					} column without default value, which contains ${count} items`,
-				);
-
-				tablesToTruncate.push(tableName);
-				statementsToExecute.push(`delete from ${tableName};`);
-
-				shouldAskForApprove = true;
-			}
-
-			const fromJsonStatement = fromJson([statement], 'sqlite', 'push');
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		} else if (statement.type === 'recreate_table') {
-			const tableName = statement.tableName;
-			const oldTableName = getOldTableName(tableName, meta);
-
-			let dataLoss = false;
-
-			const prevColumnNames = Object.keys(json1.tables[oldTableName].columns);
-			const currentColumnNames = Object.keys(json2.tables[tableName].columns);
-			const { removedColumns, addedColumns } = findAddedAndRemoved(
-				prevColumnNames,
-				currentColumnNames,
-			);
-
-			if (removedColumns.length) {
-				for (const removedColumn of removedColumns) {
-					const res = await connection.query<{ count: string }>(
-						`select count(\`${tableName}\`.\`${removedColumn}\`) as count from \`${tableName}\``,
-					);
-
-					const count = Number(res[0].count);
-					if (count > 0) {
-						infoToPrint.push(
-							`· You're about to delete ${
-								chalk.underline(
-									removedColumn,
-								)
-							} column in ${tableName} table with ${count} items`,
-						);
-						columnsToRemove.push(removedColumn);
-						shouldAskForApprove = true;
-					}
-				}
-			}
-
-			if (addedColumns.length) {
-				for (const addedColumn of addedColumns) {
-					const [res] = await connection.query<{ count: string }>(
-						`select count(*) as count from \`${tableName}\``,
-					);
-
-					const columnConf = json2.tables[tableName].columns[addedColumn];
-
-					const count = Number(res.count);
-					if (count > 0 && columnConf.notNull && !columnConf.default) {
-						dataLoss = true;
-						infoToPrint.push(
-							`· You're about to add not-null ${
-								chalk.underline(
-									addedColumn,
-								)
-							} column without default value to table, which contains ${count} items`,
-						);
-						shouldAskForApprove = true;
-						tablesToTruncate.push(tableName);
-
-						statementsToExecute.push(`DELETE FROM \`${tableName}\`;`);
-					}
-				}
-			}
-
-			// check if some tables referencing current for pragma
-			const tablesReferencingCurrent: string[] = [];
-
-			for (const table of Object.values(json2.tables)) {
-				const tablesRefs = Object.values(json2.tables[table.name].foreignKeys)
-					.filter((t) => SQLiteSquasher.unsquashPushFK(t).tableTo === tableName)
-					.map((it) => SQLiteSquasher.unsquashPushFK(it).tableFrom);
-
-				tablesReferencingCurrent.push(...tablesRefs);
-			}
-
-			if (!tablesReferencingCurrent.length) {
-				statementsToExecute.push(..._moveDataStatements(tableName, json2, dataLoss));
-				continue;
-			}
-
-			const [{ foreign_keys: pragmaState }] = await connection.query<{
-				foreign_keys: number;
-			}>(`PRAGMA foreign_keys;`);
-
-			if (pragmaState) {
-				statementsToExecute.push(`PRAGMA foreign_keys=OFF;`);
-			}
-			statementsToExecute.push(..._moveDataStatements(tableName, json2, dataLoss));
-			if (pragmaState) {
-				statementsToExecute.push(`PRAGMA foreign_keys=ON;`);
-			}
-		} else {
-			const fromJsonStatement = fromJson([statement], 'sqlite', 'push');
-			statementsToExecute.push(
-				...(Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]),
-			);
-		}
-	}
-
-	return {
-		statementsToExecute,
-		shouldAskForApprove,
-		infoToPrint,
-		columnsToRemove: [...new Set(columnsToRemove)],
-		schemasToRemove: [...new Set(schemasToRemove)],
-		tablesToTruncate: [...new Set(tablesToTruncate)],
-		tablesToRemove: [...new Set(tablesToRemove)],
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/sqliteUp.ts b/drizzle-kit/src/cli/commands/sqliteUp.ts
deleted file mode 100644
index aaa1fa7b91..0000000000
--- a/drizzle-kit/src/cli/commands/sqliteUp.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import chalk from 'chalk';
-import { writeFileSync } from 'fs';
-import { mapEntries } from 'src/global';
-import { SQLiteSchema, sqliteSchemaV5 } from 'src/serializer/sqliteSchema';
-import { prepareOutFolder, validateWithReport } from 'src/utils';
-
-export const upSqliteHandler = (out: string) => {
-	const { snapshots } = prepareOutFolder(out, 'sqlite');
-	const report = validateWithReport(snapshots, 'sqlite');
-
-	report.nonLatest
-		.map((it) => ({
-			path: it,
-			raw: report.rawMap[it]!! as Record<string, any>,
-		}))
-		.forEach((it) => {
-			const path = it.path;
-			const result = updateUpToV6(it.raw);
-
-			console.log(`[${chalk.green('✓')}] ${path}`);
-
-			writeFileSync(path, JSON.stringify(result, null, 2));
-		});
-
-	console.log("Everything's fine 🐶🔥");
-};
-
-const updateUpToV6 = (json: Record<string, any>): SQLiteSchema => {
-	const schema = sqliteSchemaV5.parse(json);
-
-	const tables = mapEntries(schema.tables, (tableKey, table) => {
-		const columns = mapEntries(table.columns, (key, value) => {
-			if (
-				value.default
-				&& (typeof value.default === 'object' || Array.isArray(value.default))
-			) {
-				value.default = `'${JSON.stringify(value.default)}'`;
-			}
-			return [key, value];
-		});
-		table.columns = columns;
-		return [tableKey, table];
-	});
-
-	return {
-		...schema,
-		version: '6',
-		dialect: 'sqlite',
-		tables: tables,
-		views: {},
-	};
-};
diff --git a/drizzle-kit/src/cli/commands/studio.ts b/drizzle-kit/src/cli/commands/studio.ts
new file mode 100644
index 0000000000..82162fda8b
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/studio.ts
@@ -0,0 +1,984 @@
+/// <reference types="@cloudflare/workers-types" />
+import type { PGlite } from '@electric-sql/pglite';
+import { serve } from '@hono/node-server';
+import { zValidator } from '@hono/zod-validator';
+import { createHash } from 'crypto';
+import type { AnyColumn, AnyTable } from 'drizzle-orm';
+import { is } from 'drizzle-orm';
+import type { TablesRelationalConfig } from 'drizzle-orm/_relations';
+import {
+	createTableRelationsHelpers,
+	extractTablesRelationalConfig,
+	Many,
+	normalizeRelation,
+	One,
+	Relations,
+} from 'drizzle-orm/_relations';
+import type { AnyMsSqlTable } from 'drizzle-orm/mssql-core';
+import { getTableConfig as mssqlTableConfig, MsSqlTable } from 'drizzle-orm/mssql-core';
+import type { AnyMySqlTable } from 'drizzle-orm/mysql-core';
+import { getTableConfig as mysqlTableConfig, MySqlTable } from 'drizzle-orm/mysql-core';
+import type { AnyPgTable } from 'drizzle-orm/pg-core';
+import { getTableConfig as pgTableConfig, PgTable } from 'drizzle-orm/pg-core';
+import type { AnySingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { getTableConfig as singlestoreTableConfig, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import type { AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+import { getTableConfig as sqliteTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import fs from 'fs';
+import { Hono } from 'hono';
+import { compress } from 'hono/compress';
+import { cors } from 'hono/cors';
+import { createServer } from 'node:https';
+import { z } from 'zod';
+import type { BenchmarkProxy, Proxy, TransactionProxy } from '../../utils';
+import { assertUnreachable } from '../../utils';
+import { loadModule, prepareFilenames } from '../../utils/utils-node';
+import { JSONB } from '../../utils/when-json-met-bigint';
+import type { DuckDbCredentials } from '../validations/duckdb';
+import type { LibSQLCredentials } from '../validations/libsql';
+import type { MysqlCredentials } from '../validations/mysql';
+import type { PostgresCredentials } from '../validations/postgres';
+import type { SingleStoreCredentials } from '../validations/singlestore';
+import type { SqliteCredentials } from '../validations/sqlite';
+
+type CustomDefault = {
+	schema: string;
+	table: string;
+	column: string;
+	func: () => unknown;
+};
+
+type SchemaFile = {
+	name: string;
+	content: string;
+};
+
+export type Setup = {
+	dbHash: string;
+	dialect: 'postgresql' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb';
+	packageName:
+		| '@aws-sdk/client-rds-data'
+		| 'pglite'
+		| 'pg'
+		| 'postgres'
+		| '@vercel/postgres'
+		| '@neondatabase/serverless'
+		| 'mysql2'
+		| '@planetscale/database'
+		| 'd1-http'
+		| 'd1'
+		| '@libsql/client'
+		| 'better-sqlite3'
+		| '@sqlitecloud/drivers'
+		| '@tursodatabase/database'
+		| '@tursodatabase/serverless'
+		| 'bun'
+		| 'duckdb'
+		| '@duckdb/node-api'
+		| 'node:sqlite';
+	driver?: 'aws-data-api' | 'd1-http' | 'd1' | 'turso' | 'pglite' | 'sqlite-cloud';
+	databaseName?: string; // for planetscale (driver remove database name from connection string)
+	proxy: Proxy;
+	transactionProxy: TransactionProxy;
+	benchmarkProxy?: BenchmarkProxy;
+	customDefaults: CustomDefault[];
+	schema: Record<string, Record<string, AnyTable<any>>>;
+	relations: Record<string, Relations>;
+	schemaFiles?: SchemaFile[];
+};
+
+export type ProxyParams = {
+	sql: string;
+	params?: any[];
+	mode: 'array' | 'object';
+	method: 'values' | 'get' | 'all' | 'run' | 'execute';
+};
+
+export const preparePgSchema = async (path: string | string[]) => {
+	const imports = prepareFilenames(path);
+	const pgSchema: Record<string, Record<string, AnyPgTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	// files content as string
+	const files = imports.map((it, index) => ({
+		// get the file name from the path
+		name: it.split('/').pop() || `schema${index}.ts`,
+		content: fs.readFileSync(it, 'utf-8'),
+	}));
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const i0values = Object.entries(i0);
+
+		i0values.forEach(([k, t]) => {
+			if (is(t, PgTable)) {
+				const schema = pgTableConfig(t).schema || 'public';
+				pgSchema[schema] = pgSchema[schema] || {};
+				pgSchema[schema][k] = t;
+			}
+
+			if (is(t, Relations)) {
+				relations[k] = t;
+			}
+		});
+	}
+
+	return { schema: pgSchema, relations, files };
+};
+
+export const prepareMySqlSchema = async (path: string | string[]) => {
+	const imports = prepareFilenames(path);
+	const mysqlSchema: Record<string, Record<string, AnyMySqlTable>> = {
+		public: {},
+	};
+	const relations: Record<string, Relations> = {};
+
+	// files content as string
+	const files = imports.map((it, index) => ({
+		// get the file name from the path
+		name: it.split('/').pop() || `schema${index}.ts`,
+		content: fs.readFileSync(it, 'utf-8'),
+	}));
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const i0values = Object.entries(i0);
+
+		i0values.forEach(([k, t]) => {
+			if (is(t, MySqlTable)) {
+				const schema = mysqlTableConfig(t).schema || 'public';
+				mysqlSchema[schema][k] = t;
+			}
+
+			if (is(t, Relations)) {
+				relations[k] = t;
+			}
+		});
+	}
+
+	return { schema: mysqlSchema, relations, files };
+};
+
+export const prepareMsSqlSchema = async (path: string | string[]) => {
+	const imports = prepareFilenames(path);
+	const mssqlSchema: Record<string, Record<string, AnyMsSqlTable>> = {
+		public: {},
+	};
+	const relations: Record<string, Relations> = {};
+
+	// files content as string
+	const files = imports.map((it, index) => ({
+		// get the file name from the path
+		name: it.split('/').pop() || `schema${index}.ts`,
+		content: fs.readFileSync(it, 'utf-8'),
+	}));
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const i0values = Object.entries(i0);
+
+		i0values.forEach(([k, t]) => {
+			if (is(t, MsSqlTable)) {
+				const schema = mssqlTableConfig(t).schema || 'public';
+				mssqlSchema[schema][k] = t;
+			}
+
+			if (is(t, Relations)) {
+				relations[k] = t;
+			}
+		});
+	}
+
+	return { schema: mssqlSchema, relations, files };
+};
+
+export const prepareSQLiteSchema = async (path: string | string[]) => {
+	const imports = prepareFilenames(path);
+	const sqliteSchema: Record<string, Record<string, AnySQLiteTable>> = {
+		public: {},
+	};
+	const relations: Record<string, Relations> = {};
+
+	// files content as string
+	const files = imports.map((it, index) => ({
+		// get the file name from the path
+		name: it.split('/').pop() || `schema${index}.ts`,
+		content: fs.readFileSync(it, 'utf-8'),
+	}));
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const i0values = Object.entries(i0);
+
+		i0values.forEach(([k, t]) => {
+			if (is(t, SQLiteTable)) {
+				const schema = 'public'; // sqlite does not have schemas
+				sqliteSchema[schema][k] = t;
+			}
+
+			if (is(t, Relations)) {
+				relations[k] = t;
+			}
+		});
+	}
+
+	return { schema: sqliteSchema, relations, files };
+};
+
+export const prepareSingleStoreSchema = async (path: string | string[]) => {
+	const imports = prepareFilenames(path);
+	const singlestoreSchema: Record<
+		string,
+		Record<string, AnySingleStoreTable>
+	> = {
+		public: {},
+	};
+	const relations: Record<string, Relations> = {};
+
+	// files content as string
+	const files = imports.map((it, index) => ({
+		// get the file name from the path
+		name: it.split('/').pop() || `schema${index}.ts`,
+		content: fs.readFileSync(it, 'utf-8'),
+	}));
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const i0values = Object.entries(i0);
+
+		i0values.forEach(([k, t]) => {
+			if (is(t, SingleStoreTable)) {
+				const schema = singlestoreTableConfig(t).schema || 'public';
+				singlestoreSchema[schema][k] = t;
+			}
+
+			if (is(t, Relations)) {
+				relations[k] = t;
+			}
+		});
+	}
+
+	return { schema: singlestoreSchema, relations, files };
+};
+
+const getCustomDefaults = <T extends AnyTable<{}>>(
+	schema: Record<string, Record<string, T>>,
+): CustomDefault[] => {
+	const customDefaults: CustomDefault[] = [];
+
+	Object.entries(schema).map(([schema, tables]) => {
+		Object.entries(tables).map(([, table]) => {
+			let tableConfig: {
+				name: string;
+				columns: AnyColumn[];
+			};
+			if (is(table, PgTable)) {
+				tableConfig = pgTableConfig(table);
+			} else if (is(table, MySqlTable)) {
+				tableConfig = mysqlTableConfig(table);
+			} else if (is(table, SQLiteTable)) {
+				tableConfig = sqliteTableConfig(table);
+			} else {
+				tableConfig = singlestoreTableConfig(table as SingleStoreTable);
+			}
+
+			tableConfig.columns.map((column) => {
+				if (column.defaultFn) {
+					customDefaults.push({
+						schema,
+						table: tableConfig.name,
+						column: column.name,
+						func: column.defaultFn,
+					});
+				}
+			});
+		});
+	});
+
+	return customDefaults;
+};
+
+export const drizzleForPostgres = async (
+	credentials: PostgresCredentials | {
+		driver: 'pglite';
+		client: PGlite;
+	},
+	pgSchema: Record<string, Record<string, AnyPgTable>>,
+	relations: Record<string, Relations>,
+	schemaFiles?: SchemaFile[],
+): Promise<Setup> => {
+	const { preparePostgresDB } = await import('../connections');
+	const db = await preparePostgresDB(credentials);
+	const customDefaults = getCustomDefaults(pgSchema);
+
+	let dbUrl: string;
+
+	if ('driver' in credentials) {
+		const { driver } = credentials;
+		if (driver === 'aws-data-api') {
+			dbUrl = `aws-data-api://${credentials.database}/${credentials.secretArn}/${credentials.resourceArn}`;
+		} else if (driver === 'pglite') {
+			dbUrl = 'client' in credentials ? credentials.client.dataDir || 'pglite://custom-client' : credentials.url;
+		} else {
+			assertUnreachable(driver);
+		}
+	} else if ('url' in credentials) {
+		dbUrl = credentials.url;
+	} else {
+		dbUrl =
+			`postgresql://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
+	}
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'postgresql',
+		driver: 'driver' in credentials ? credentials.driver : undefined,
+		packageName: db.packageName,
+		proxy: db.proxy,
+		transactionProxy: db.transactionProxy,
+		benchmarkProxy: db.benchmarkProxy,
+		customDefaults,
+		schema: pgSchema,
+		relations,
+		schemaFiles,
+	};
+};
+
+export const drizzleForDuckDb = async (
+	credentials: DuckDbCredentials,
+): Promise<Setup> => {
+	const { prepareDuckDb } = await import('../connections');
+	const db = await prepareDuckDb(credentials);
+
+	const dbUrl = `duckdb://${credentials.url}`;
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'duckdb',
+		driver: undefined,
+		packageName: db.packageName,
+		proxy: db.proxy,
+		transactionProxy: db.transactionProxy,
+		customDefaults: [],
+		schema: {},
+		relations: {},
+	};
+};
+
+export const drizzleForMySQL = async (
+	credentials: MysqlCredentials,
+	mysqlSchema: Record<string, Record<string, AnyMySqlTable>>,
+	relations: Record<string, Relations>,
+	schemaFiles?: SchemaFile[],
+): Promise<Setup> => {
+	const { connectToMySQL } = await import('../connections');
+	const { proxy, transactionProxy, benchmarkProxy, database, packageName } = await connectToMySQL(credentials);
+
+	const customDefaults = getCustomDefaults(mysqlSchema);
+
+	let dbUrl: string;
+
+	if ('url' in credentials) {
+		dbUrl = credentials.url;
+	} else {
+		dbUrl =
+			`mysql://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
+	}
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'mysql',
+		packageName,
+		databaseName: database,
+		proxy,
+		transactionProxy,
+		benchmarkProxy,
+		customDefaults,
+		schema: mysqlSchema,
+		relations,
+		schemaFiles,
+	};
+};
+
+// export const drizzleForMsSQL = async (
+// 	credentials: MssqlCredentials,
+// 	mssqlSchema: Record<string, Record<string, AnyMsSqlTable>>,
+// 	relations: Record<string, Relations>,
+// 	schemaFiles?: SchemaFile[],
+// ): Promise<Setup> => {
+// 	const { connectToMsSQL } = await import('../cli/connections');
+// 	const { proxy } = await connectToMsSQL(credentials);
+
+// 	const customDefaults = getCustomDefaults(mssqlSchema);
+
+// 	let dbUrl: string;
+
+// 	if ('url' in credentials) {
+// 		dbUrl = credentials.url;
+// 	} else {
+// 		// TODO() change it!
+// 		dbUrl =
+// 			`mysql://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
+// 	}
+
+// 	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+// 	return {
+// 		dbHash,
+// 		dialect: 'mysql',
+// 		proxy,
+// 		customDefaults,
+// 		schema: mssqlSchema,
+// 		relations,
+// 		schemaFiles,
+// 	};
+// };
+
+// D1 binding credentials type (mirrors the one in connections.ts)
+type D1BindingCredentials = {
+	driver: 'd1';
+	binding: D1Database;
+};
+
+export const drizzleForSQLite = async (
+	credentials: SqliteCredentials | D1BindingCredentials,
+	sqliteSchema: Record<string, Record<string, AnySQLiteTable>>,
+	relations: Record<string, Relations>,
+	schemaFiles?: SchemaFile[],
+): Promise<Setup> => {
+	const customDefaults = getCustomDefaults(sqliteSchema);
+
+	if ('driver' in credentials && credentials.driver === 'd1') {
+		const { connectToD1 } = await import('../connections');
+		const sqliteDB = await connectToD1(credentials.binding);
+
+		const dbUrl = 'd1://binding';
+		const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+		return {
+			dbHash,
+			dialect: 'sqlite',
+			driver: 'd1',
+			packageName: 'd1',
+			proxy: sqliteDB.proxy,
+			transactionProxy: sqliteDB.transactionProxy,
+			customDefaults,
+			schema: sqliteSchema,
+			relations,
+			schemaFiles,
+		};
+	}
+
+	const { connectToSQLite } = await import('../connections');
+	const sqliteDB = await connectToSQLite(credentials);
+
+	let dbUrl: string;
+
+	if ('driver' in credentials) {
+		const { driver } = credentials;
+		if (driver === 'd1-http') {
+			dbUrl = `d1-http://${credentials.accountId}/${credentials.databaseId}/${credentials.token}`;
+		} else if (driver === 'sqlite-cloud') {
+			dbUrl = credentials.url;
+		} else {
+			assertUnreachable(driver);
+		}
+	} else {
+		dbUrl = credentials.url;
+	}
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'sqlite',
+		driver: 'driver' in credentials ? credentials.driver : undefined,
+		packageName: sqliteDB.packageName,
+		proxy: sqliteDB.proxy,
+		transactionProxy: sqliteDB.transactionProxy,
+		customDefaults,
+		schema: sqliteSchema,
+		relations,
+		schemaFiles,
+	};
+};
+export const drizzleForLibSQL = async (
+	credentials: LibSQLCredentials,
+	sqliteSchema: Record<string, Record<string, AnySQLiteTable>>,
+	relations: Record<string, Relations>,
+	schemaFiles?: SchemaFile[],
+): Promise<Setup> => {
+	const { connectToTursoRemote: connectToLibSQL } = await import('../connections');
+
+	const sqliteDB = await connectToLibSQL(credentials);
+	const customDefaults = getCustomDefaults(sqliteSchema);
+
+	let dbUrl: string = `turso://${credentials.url}/${credentials.authToken}`;
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'sqlite',
+		driver: undefined,
+		packageName: sqliteDB.packageName,
+		proxy: sqliteDB.proxy,
+		transactionProxy: sqliteDB.transactionProxy,
+		customDefaults,
+		schema: sqliteSchema,
+		relations,
+		schemaFiles,
+	};
+};
+
+export const drizzleForSingleStore = async (
+	credentials: SingleStoreCredentials,
+	singlestoreSchema: Record<string, Record<string, AnySingleStoreTable>>,
+	relations: Record<string, Relations>,
+	schemaFiles?: SchemaFile[],
+): Promise<Setup> => {
+	const { connectToSingleStore } = await import('../connections');
+	const { proxy, transactionProxy, database, packageName } = await connectToSingleStore(credentials);
+
+	const customDefaults = getCustomDefaults(singlestoreSchema);
+
+	let dbUrl: string;
+
+	if ('url' in credentials) {
+		dbUrl = credentials.url;
+	} else {
+		dbUrl =
+			`singlestore://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
+	}
+
+	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
+
+	return {
+		dbHash,
+		dialect: 'singlestore',
+		databaseName: database,
+		packageName,
+		proxy,
+		transactionProxy,
+		customDefaults,
+		schema: singlestoreSchema,
+		relations,
+		schemaFiles,
+	};
+};
+
+type Relation = {
+	name: string;
+	type: 'one' | 'many';
+	table: string;
+	schema: string;
+	columns: string[];
+	refTable: string;
+	refSchema: string;
+	refColumns: string[];
+};
+
+export const extractRelations = (
+	tablesConfig: {
+		tables: TablesRelationalConfig;
+		tableNamesMap: Record<string, string>;
+	},
+): Relation[] => {
+	const relations = Object.values(tablesConfig.tables)
+		.map((it) =>
+			Object.entries(it.relations).map(([name, relation]) => {
+				try {
+					const normalized = normalizeRelation(
+						tablesConfig.tables,
+						tablesConfig.tableNamesMap,
+						relation,
+					);
+					const rel = relation;
+					const refTableName = rel.referencedTableName;
+					const refTable = rel.referencedTable;
+					const fields = normalized.fields
+						.map((it) => it.name)
+						.flat();
+					const refColumns = normalized.references
+						.map((it) => it.name)
+						.flat();
+
+					let refSchema: string | undefined;
+					if (is(refTable, PgTable)) {
+						refSchema = pgTableConfig(refTable).schema;
+					} else if (is(refTable, MySqlTable)) {
+						refSchema = mysqlTableConfig(refTable).schema;
+					} else if (is(refTable, SQLiteTable)) {
+						refSchema = undefined;
+					} else if (is(refTable, SingleStoreTable)) {
+						refSchema = singlestoreTableConfig(refTable).schema;
+					} else {
+						throw new Error('unsupported dialect');
+					}
+
+					let type: 'one' | 'many';
+					if (is(rel, One)) {
+						type = 'one';
+					} else if (is(rel, Many)) {
+						type = 'many';
+					} else {
+						throw new Error('unsupported relation type');
+					}
+
+					return {
+						name,
+						type,
+						table: it.dbName,
+						schema: it.schema || 'public',
+						columns: fields,
+						refTable: refTableName,
+						refSchema: refSchema || 'public',
+						refColumns: refColumns,
+					};
+				} catch {
+					throw new Error(
+						`Invalid relation "${relation.fieldName}" for table "${
+							it.schema ? `${it.schema}.${it.dbName}` : it.dbName
+						}"`,
+					);
+				}
+			})
+		)
+		.flat();
+	return relations;
+};
+
+const init = z.object({
+	type: z.literal('init'),
+});
+
+const proxySchema = z.object({
+	type: z.literal('proxy'),
+	data: z.object({
+		sql: z.string(),
+		params: z.array(z.any()).optional(),
+		mode: z.enum(['array', 'object']).default('object'),
+		method: z.union([
+			z.literal('values'),
+			z.literal('get'),
+			z.literal('all'),
+			z.literal('run'),
+			z.literal('execute'),
+		]),
+	}),
+});
+
+const transactionProxySchema = z.object({
+	type: z.literal('tproxy'),
+	data: z
+		.object({
+			sql: z.string(),
+			method: z
+				.union([
+					z.literal('values'),
+					z.literal('get'),
+					z.literal('all'),
+					z.literal('run'),
+					z.literal('execute'),
+				])
+				.optional(),
+		})
+		.array(),
+});
+
+const benchmarkProxySchema = z.object({
+	type: z.literal('bproxy'),
+	data: z.object({
+		query: z
+			.object({
+				sql: z.string(),
+				params: z.array(z.any()).optional(),
+				method: z
+					.union([
+						z.literal('values'),
+						z.literal('get'),
+						z.literal('all'),
+						z.literal('run'),
+						z.literal('execute'),
+					])
+					.optional(),
+			}),
+		repeats: z.number().min(1).optional(),
+	}),
+});
+
+const defaultsSchema = z.object({
+	type: z.literal('defaults'),
+	data: z
+		.array(
+			z.object({
+				schema: z.string(),
+				table: z.string(),
+				column: z.string(),
+			}),
+		)
+		.min(1),
+});
+
+const schema = z.union([
+	init,
+	proxySchema,
+	transactionProxySchema,
+	benchmarkProxySchema,
+	defaultsSchema,
+]);
+
+const jsonStringify = (data: any) => {
+	return JSONB.stringify(data, (_key, value) => {
+		// Convert Error to object
+		if (value instanceof Error) {
+			return {
+				error: value.message,
+			};
+		}
+
+		// Convert Buffer and ArrayBuffer to base64
+		if (
+			(value
+				&& typeof value === 'object'
+				&& 'type' in value
+				&& 'data' in value
+				&& value.type === 'Buffer')
+			|| value instanceof ArrayBuffer
+			|| value instanceof Buffer
+		) {
+			return Buffer.from(value).toString('base64');
+		}
+
+		return value;
+	});
+};
+
+export type Server = {
+	start: (params: {
+		host: string;
+		port: number;
+		key?: string;
+		cert?: string;
+		cb: (err: Error | null, address: string) => void;
+	}) => void;
+};
+
+export const prepareServer = async (
+	{
+		dialect,
+		driver,
+		packageName,
+		databaseName,
+		proxy,
+		transactionProxy,
+		benchmarkProxy,
+		customDefaults,
+		schema: drizzleSchema,
+		relations,
+		dbHash,
+		schemaFiles,
+	}: Setup,
+	app?: Hono,
+): Promise<Server> => {
+	app = app !== undefined ? app : new Hono();
+
+	app.use(compress());
+	app.use(async (ctx, next) => {
+		await next();
+		// * https://wicg.github.io/private-network-access/#headers
+		// * https://github.com/drizzle-team/drizzle-orm/issues/1857#issuecomment-2395724232
+		ctx.header('Access-Control-Allow-Private-Network', 'true');
+	});
+	app.use(cors());
+	app.onError((err, ctx) => {
+		console.error(err);
+		return ctx.json({
+			status: 'error',
+			error: err.message,
+		});
+	});
+
+	const relationalSchema: Record<string, unknown> = {
+		...Object.fromEntries(
+			Object.entries(drizzleSchema)
+				.map(([schemaName, schema]) => {
+					// have unique keys across schemas
+					const mappedTableEntries = Object.entries(schema).map(
+						([tableName, table]) => {
+							return [`__${schemaName}__.${tableName}`, table];
+						},
+					);
+
+					return mappedTableEntries;
+				})
+				.flat(),
+		),
+		...relations,
+	};
+
+	const relationsConfig = extractTablesRelationalConfig(
+		relationalSchema,
+		createTableRelationsHelpers,
+	);
+
+	app.post('/', zValidator('json', schema), async (c) => {
+		const body = c.req.valid('json');
+		const { type } = body;
+
+		if (type === 'init') {
+			const preparedDefaults = customDefaults.map((d) => ({
+				schema: d.schema,
+				table: d.table,
+				column: d.column,
+			}));
+
+			let relations: Relation[] = [];
+			// Attempt to extract relations from the relational config.
+			// An error may occur if the relations are ambiguous or misconfigured.
+			try {
+				relations = extractRelations(relationsConfig);
+			} catch (error) {
+				console.warn(
+					'Failed to extract relations. This is likely due to ambiguous or misconfigured relations.',
+				);
+				console.warn(
+					'Please check your schema and ensure that all relations are correctly defined.',
+				);
+				console.warn(
+					'See: https://orm.drizzle.team/docs/relations#disambiguating-relations',
+				);
+				console.warn('Error message:', (error as Error).message);
+			}
+
+			return c.json({
+				version: '6.3',
+				dialect,
+				driver,
+				packageName,
+				schemaFiles,
+				customDefaults: preparedDefaults,
+				relations,
+				dbHash,
+				databaseName,
+			});
+		}
+
+		if (type === 'proxy') {
+			const result = await proxy({
+				...body.data,
+				params: body.data.params || [],
+			});
+			const res = jsonStringify(result)!;
+			return c.body(
+				res,
+				{
+					headers: {
+						'Content-Type': 'application/json',
+					},
+				},
+			);
+		}
+
+		if (type === 'tproxy') {
+			const result = await transactionProxy(body.data);
+			const res = jsonStringify(result)!;
+			return c.body(
+				res,
+				{
+					headers: {
+						'Content-Type': 'application/json',
+					},
+				},
+			);
+		}
+
+		if (type === 'bproxy') {
+			if (!benchmarkProxy) {
+				throw new Error('Benchmark proxy is not configured for this database.');
+			}
+			const result = await benchmarkProxy(body.data.query, body.data.repeats || 1);
+			const res = jsonStringify(result)!;
+			return c.body(
+				res,
+				{
+					headers: {
+						'Content-Type': 'application/json',
+					},
+				},
+			);
+		}
+
+		if (type === 'defaults') {
+			const columns = body.data;
+
+			const result = columns.map((column) => {
+				const found = customDefaults.find((d) => {
+					return (
+						d.schema === column.schema
+						&& d.table === column.table
+						&& d.column === column.column
+					);
+				});
+
+				if (!found) {
+					throw new Error(
+						`Custom default not found for ${column.schema}.${column.table}.${column.column}`,
+					);
+				}
+
+				const value = found.func();
+
+				return {
+					...column,
+					value,
+				};
+			});
+			const res = jsonStringify(result)!;
+			return c.body(
+				res,
+				{
+					headers: {
+						'Content-Type': 'application/json',
+					},
+				},
+			);
+		}
+
+		throw new Error(`Unknown type: ${type}`);
+	});
+
+	return {
+		start: (params: Parameters<Server['start']>[0]) => {
+			serve(
+				{
+					fetch: app!.fetch,
+					createServer: params.key ? createServer : undefined,
+					hostname: params.host,
+					port: params.port,
+					serverOptions: {
+						key: params.key,
+						cert: params.cert,
+					},
+				},
+				() => params.cb(null, `${params.host}:${params.port}`),
+			);
+		},
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/up-cockroach.ts b/drizzle-kit/src/cli/commands/up-cockroach.ts
new file mode 100644
index 0000000000..988167c809
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-cockroach.ts
@@ -0,0 +1,10 @@
+import { outputFormat } from '../context';
+
+export const upCockroachHandler = (_out: string): string[] => {
+	// const { snapshots } = prepareOutFolder(out, "cockroach");
+	// const report = validateWithReport(snapshots, "cockroach");
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return [];
+};
diff --git a/drizzle-kit/src/cli/commands/up-mssql.ts b/drizzle-kit/src/cli/commands/up-mssql.ts
new file mode 100644
index 0000000000..9265aa740d
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-mssql.ts
@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { upToV2 } from '../../dialects/mssql/versions';
+import { prepareOutFolder, validateWithReport } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+
+export const upMssqlHandler = (out: string): string[] => {
+	const { snapshots } = prepareOutFolder(out);
+	const report = validateWithReport(snapshots, 'mssql');
+
+	const upgraded: string[] = [];
+	report.nonLatest
+		.map((it) => ({
+			path: it,
+			raw: report.rawMap[it]! as Record<string, any>,
+		}))
+		.forEach((it) => {
+			const path = it.path;
+
+			const { snapshot } = upToV2(it.raw);
+
+			if (outputFormat() === 'text') console.log(`[${chalk.green('✓')}] ${path}`);
+
+			writeFileSync(path, JSON.stringify(snapshot, null, 2));
+
+			upgraded.push(path);
+		});
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return upgraded;
+};
diff --git a/drizzle-kit/src/cli/commands/up-mysql.ts b/drizzle-kit/src/cli/commands/up-mysql.ts
new file mode 100644
index 0000000000..e7e3181d4d
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-mysql.ts
@@ -0,0 +1,211 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { createDDL } from '../../dialects/mysql/ddl';
+import { Binary, Varbinary } from '../../dialects/mysql/grammar';
+import type { MysqlSchemaV6, MysqlSnapshot } from '../../dialects/mysql/snapshot';
+import { trimChar } from '../../utils';
+import { prepareOutFolder, validateWithReport } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { migrateToFoldersV3 } from './utils';
+
+export const upMysqlHandler = (out: string): string[] => {
+	migrateToFoldersV3(out);
+
+	const { snapshots } = prepareOutFolder(out);
+	const report = validateWithReport(snapshots, 'mysql');
+
+	const upgraded: string[] = [];
+	report.nonLatest
+		.map((it) => ({
+			path: it,
+			raw: report.rawMap[it] as Record<string, any>,
+		}))
+		.forEach((it) => {
+			const path = it.path;
+
+			const snapshot = upToV6(it.raw);
+
+			if (outputFormat() === 'text') console.log(`[${chalk.green('✓')}] ${path}`);
+
+			writeFileSync(path, JSON.stringify(snapshot, null, 2));
+
+			upgraded.push(path);
+		});
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return upgraded;
+};
+
+export const upToV6 = (it: Record<string, any>): MysqlSnapshot => {
+	const json = it as MysqlSchemaV6;
+
+	const ddl = createDDL();
+
+	for (const table of Object.values(json.tables)) {
+		ddl.tables.push({ name: table.name });
+
+		for (const column of Object.values(table.columns)) {
+			let def = typeof column.default === 'undefined' ? null : String(column.default);
+			if (def !== null) {
+				if (column.type.startsWith('decimal')) def = `(${trimChar(def, "'")})`;
+				if (column.type.startsWith('binary')) {
+					const trimmed = trimChar(def, "'");
+					if (trimmed !== def) def = Binary.defaultFromDrizzle(trimmed)!;
+				}
+				if (column.type.startsWith('varbinary')) {
+					const trimmed = trimChar(def, "'");
+					// check if it's not an expression
+					if (trimmed !== def) def = Varbinary.defaultFromDrizzle(trimmed);
+				}
+			}
+
+			ddl.columns.push({
+				table: table.name,
+				name: column.name,
+				type: column.type,
+				notNull: column.notNull,
+				default: def,
+				autoIncrement: column.autoincrement ?? false,
+				onUpdateNow: column.onUpdate ?? false,
+				generated: column.generated,
+				// TODO: @AleksandrSherman check
+				charSet: null,
+				collation: null,
+				onUpdateNowFsp: null,
+			});
+		}
+	}
+	for (const table of Object.values(json.tables)) {
+		for (const index of Object.values(table.indexes)) {
+			/* legacy columns mapper
+				const uniqueString = unsquashedUnique.columns
+					.map((it) => {
+						return internals?.indexes
+							? internals?.indexes[unsquashedUnique.name]?.columns[it]
+									?.isExpression
+								? it
+								: `\`${it}\``
+							: `\`${it}\``;
+					})
+					.join(',');
+			 */
+
+			const columns = index.columns.map((x) => {
+				const nameToCheck = trimChar(x, '`');
+				const isColumn = !!ddl.columns.one({
+					table: table.name,
+					name: nameToCheck,
+				});
+				return { value: x, isExpression: !isColumn };
+			});
+
+			ddl.indexes.push({
+				table: table.name,
+				name: index.name,
+				columns,
+				algorithm: index.algorithm ?? null,
+				isUnique: index.isUnique,
+				lock: index.lock ?? null,
+				using: index.using ?? null,
+				nameExplicit: true,
+			});
+		}
+
+		if (table.uniqueConstraints) {
+			for (const unique of Object.values(table.uniqueConstraints)) {
+				/* legacy columns mapper
+				const uniqueString = unsquashedUnique.columns
+					.map((it) => {
+						return internals?.indexes
+							? internals?.indexes[unsquashedUnique.name]?.columns[it]
+									?.isExpression
+								? it
+								: `\`${it}\``
+							: `\`${it}\``;
+					})
+					.join(',');
+			 */
+				const columns = unique.columns.map((x) => {
+					const nameToCheck = trimChar(x, '`');
+					const isColumn = !!ddl.columns.one({
+						table: table.name,
+						name: nameToCheck,
+					});
+					return { value: x, isExpression: !isColumn };
+				});
+
+				let nameImplicit = `${table.name}_${unique.columns.join('_')}_unique` === unique.name
+					|| `${table.name}_${unique.columns.join('_')}` === unique.name;
+
+				ddl.indexes.push({
+					table: table.name,
+					name: unique.name,
+					columns,
+					algorithm: null,
+					isUnique: true,
+					lock: null,
+					using: null,
+					nameExplicit: !nameImplicit,
+				});
+			}
+		}
+
+		if (table.foreignKeys) {
+			for (const fk of Object.values(table.foreignKeys)) {
+				const isNameImplicit = `${fk.tableFrom}_${fk.columnsFrom.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fk`
+					=== fk.name;
+
+				ddl.fks.push({
+					table: table.name,
+					name: fk.name,
+					columns: fk.columnsFrom,
+					columnsTo: fk.columnsTo,
+					tableTo: fk.tableTo,
+					onUpdate: (fk.onUpdate?.toUpperCase() as any) ?? null,
+					onDelete: (fk.onDelete?.toUpperCase() as any) ?? null,
+					nameExplicit: !isNameImplicit,
+				});
+			}
+		}
+
+		if (table.checkConstraint) {
+			for (const check of Object.values(table.checkConstraint)) {
+				ddl.checks.push({
+					table: table.name,
+					name: check.name,
+					value: check.value,
+				});
+			}
+
+			for (const pk of Object.values(table.compositePrimaryKeys)) {
+				ddl.pks.push({
+					table: table.name,
+					name: 'PRIMARY',
+					columns: pk.columns,
+				});
+			}
+		}
+	}
+
+	if (json.views) {
+		for (const view of Object.values(json.views)) {
+			ddl.views.push({
+				name: view.name,
+				algorithm: view.algorithm ?? null,
+				sqlSecurity: view.sqlSecurity ?? null,
+				withCheckOption: view.withCheckOption ?? null,
+				definition: view.definition!,
+			});
+		}
+	}
+
+	return {
+		version: '6',
+		id: json.id,
+		prevIds: [json.prevId],
+		dialect: 'mysql',
+		ddl: ddl.entities.list(),
+		renames: [],
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/up-postgres.ts b/drizzle-kit/src/cli/commands/up-postgres.ts
new file mode 100644
index 0000000000..a6357a4832
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-postgres.ts
@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { upToV8 } from '../../dialects/postgres/versions';
+import { prepareOutFolder, validateWithReport } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { migrateToFoldersV3 } from './utils';
+
+export const upPgHandler = (out: string): string[] => {
+	migrateToFoldersV3(out);
+
+	const { snapshots } = prepareOutFolder(out);
+	const report = validateWithReport(snapshots, 'postgresql');
+
+	const upgraded: string[] = [];
+	report.nonLatest
+		.map((it) => ({
+			path: it,
+			raw: report.rawMap[it]! as Record<string, any>,
+		}))
+		.forEach((it) => {
+			const path = it.path;
+
+			const { snapshot } = upToV8(it.raw);
+
+			if (outputFormat() === 'text') console.log(`[${chalk.green('✓')}] ${path}`);
+
+			writeFileSync(path, JSON.stringify(snapshot, null, 2));
+
+			upgraded.push(path);
+		});
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return upgraded;
+};
diff --git a/drizzle-kit/src/cli/commands/up-singlestore.ts b/drizzle-kit/src/cli/commands/up-singlestore.ts
new file mode 100644
index 0000000000..bbe0222206
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-singlestore.ts
@@ -0,0 +1,197 @@
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { createDDL } from '../../dialects/mysql/ddl';
+import { Binary, Varbinary } from '../../dialects/mysql/grammar';
+import type { SchemaV1, SingleStoreSnapshot } from '../../dialects/singlestore/snapshot';
+import { trimChar } from '../../utils';
+import { prepareOutFolder, validateWithReport } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { migrateToFoldersV3 } from './utils';
+
+export const upSinglestoreHandler = (out: string): string[] => {
+	migrateToFoldersV3(out);
+
+	const { snapshots } = prepareOutFolder(out);
+	const report = validateWithReport(snapshots, 'singlestore');
+
+	const upgraded: string[] = [];
+	report.nonLatest
+		.map((it) => ({
+			path: it,
+			raw: report.rawMap[it] as Record<string, any>,
+		}))
+		.forEach((it) => {
+			const path = it.path;
+
+			const snapshot = upToV2(it.raw);
+
+			if (outputFormat() === 'text') console.log(`[${chalk.green('✓')}] ${path}`);
+
+			writeFileSync(path, JSON.stringify(snapshot, null, 2));
+
+			upgraded.push(path);
+		});
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return upgraded;
+};
+
+export const upToV2 = (it: Record<string, any>): SingleStoreSnapshot => {
+	const json = it as SchemaV1;
+
+	const ddl = createDDL();
+
+	for (const table of Object.values(json.tables)) {
+		ddl.tables.push({ name: table.name });
+
+		for (const column of Object.values(table.columns)) {
+			let def = typeof column.default === 'undefined' ? null : String(column.default);
+			if (def !== null) {
+				if (column.type.startsWith('decimal')) def = `(${trimChar(def, "'")})`;
+				if (column.type.startsWith('binary')) {
+					const trimmed = trimChar(def, "'");
+					if (trimmed !== def) def = Binary.defaultFromDrizzle(trimmed)!;
+				}
+				if (column.type.startsWith('varbinary')) {
+					const trimmed = trimChar(def, "'");
+					// check if it's not an expression
+					if (trimmed !== def) def = Varbinary.defaultFromDrizzle(trimmed);
+				}
+			}
+
+			ddl.columns.push({
+				table: table.name,
+				name: column.name,
+				type: column.type,
+				notNull: column.notNull,
+				default: def,
+				autoIncrement: column.autoincrement ?? false,
+				onUpdateNow: column.onUpdate ?? false,
+				generated: column.generated,
+				// TODO: @AleksandrSherman check
+				charSet: null,
+				collation: null,
+				onUpdateNowFsp: null,
+			});
+		}
+	}
+	for (const table of Object.values(json.tables)) {
+		for (const index of Object.values(table.indexes)) {
+			/* legacy columns mapper
+                const uniqueString = unsquashedUnique.columns
+                    .map((it) => {
+                        return internals?.indexes
+                            ? internals?.indexes[unsquashedUnique.name]?.columns[it]
+                                    ?.isExpression
+                                ? it
+                                : `\`${it}\``
+                            : `\`${it}\``;
+                    })
+                    .join(',');
+             */
+
+			const columns = index.columns.map((x) => {
+				const nameToCheck = trimChar(x, '`');
+				const isColumn = !!ddl.columns.one({ table: table.name, name: nameToCheck });
+				return { value: x, isExpression: !isColumn };
+			});
+
+			ddl.indexes.push({
+				table: table.name,
+				name: index.name,
+				columns,
+				algorithm: index.algorithm ?? null,
+				isUnique: index.isUnique,
+				lock: index.lock ?? null,
+				using: index.using ?? null,
+				nameExplicit: true,
+			});
+		}
+
+		for (const unique of Object.values(table.uniqueConstraints)) {
+			/* legacy columns mapper
+                const uniqueString = unsquashedUnique.columns
+                    .map((it) => {
+                        return internals?.indexes
+                            ? internals?.indexes[unsquashedUnique.name]?.columns[it]
+                                    ?.isExpression
+                                ? it
+                                : `\`${it}\``
+                            : `\`${it}\``;
+                    })
+                    .join(',');
+             */
+			const columns = unique.columns.map((x) => {
+				const nameToCheck = trimChar(x, '`');
+				const isColumn = !!ddl.columns.one({ table: table.name, name: nameToCheck });
+				return { value: x, isExpression: !isColumn };
+			});
+
+			let nameImplicit = `${table.name}_${unique.columns.join('_')}_unique` === unique.name
+				|| `${table.name}_${unique.columns.join('_')}` === unique.name;
+
+			ddl.indexes.push({
+				table: table.name,
+				name: unique.name,
+				columns,
+				algorithm: null,
+				isUnique: true,
+				lock: null,
+				using: null,
+				nameExplicit: !nameImplicit,
+			});
+		}
+
+		// for (const fk of Object.values(table.foreignKeys)) {
+		//     const isNameImplicit =
+		//         `${fk.tableFrom}_${fk.columnsFrom.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fk` === fk.name;
+
+		//     ddl.fks.push({
+		//         table: table.name,
+		//         name: fk.name,
+		//         columns: fk.columnsFrom,
+		//         columnsTo: fk.columnsTo,
+		//         tableTo: fk.tableTo,
+		//         onUpdate: fk.onUpdate?.toUpperCase() as any ?? null,
+		//         onDelete: fk.onDelete?.toUpperCase() as any ?? null,
+		//         nameExplicit: !isNameImplicit,
+		//     });
+		// }
+
+		// for (const check of Object.values(table.checkConstraint)) {
+		//     ddl.checks.push({
+		//         table: table.name,
+		//         name: check.name,
+		//         value: check.value,
+		//     });
+		// }
+
+		for (const pk of Object.values(table.compositePrimaryKeys)) {
+			ddl.pks.push({
+				table: table.name,
+				name: 'PRIMARY',
+				columns: pk.columns,
+			});
+		}
+	}
+
+	// for (const view of Object.values(json.views)) {
+	//     ddl.views.push({
+	//         name: view.name,
+	//         algorithm: view.algorithm ?? null,
+	//         sqlSecurity: view.sqlSecurity ?? null,
+	//         withCheckOption: view.withCheckOption ?? null,
+	//         definition: view.definition!,
+	//     });
+	// }
+
+	return {
+		version: '2',
+		id: json.id,
+		prevIds: [json.prevId],
+		dialect: 'singlestore',
+		ddl: ddl.entities.list(),
+		renames: [],
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/up-sqlite.ts b/drizzle-kit/src/cli/commands/up-sqlite.ts
new file mode 100644
index 0000000000..f7fb1a633a
--- /dev/null
+++ b/drizzle-kit/src/cli/commands/up-sqlite.ts
@@ -0,0 +1,196 @@
+import chalk from 'chalk';
+import type { UpdateDeleteAction } from 'drizzle-orm/sqlite-core';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { createDDL } from '../../dialects/sqlite/ddl';
+import { transformOnUpdateDelete } from '../../dialects/sqlite/grammar';
+import { nameForPk } from '../../dialects/sqlite/grammar';
+import {
+	sqliteSchemaV5,
+	type SQLiteSchemaV6,
+	sqliteSchemaV6,
+	type SqliteSnapshot,
+} from '../../dialects/sqlite/snapshot';
+import { mapEntries } from '../../utils';
+import { prepareOutFolder, validateWithReport } from '../../utils/utils-node';
+import { outputFormat } from '../context';
+import { CommandOutputCliError } from '../errors';
+import { embeddedMigrations } from './generate-common';
+import { migrateToFoldersV3 } from './utils';
+
+export const upSqliteHandler = (out: string): string[] => {
+	migrateToFoldersV3(out);
+
+	const { snapshots } = prepareOutFolder(out);
+	const report = validateWithReport(snapshots, 'sqlite');
+
+	const upgraded: string[] = [];
+	report.nonLatest
+		.map((it) => ({
+			path: it,
+			raw: report.rawMap[it]! as Record<string, any>,
+		}))
+		.forEach((it) => {
+			const path = it.path;
+
+			let result: SqliteSnapshot;
+			if (it.raw['version'] === '5') {
+				result = updateToV7(updateUpToV6(it.raw));
+			} else if (it.raw['version'] === '6') {
+				result = updateToV7(sqliteSchemaV6.parse(it.raw));
+			} else {
+				throw new CommandOutputCliError('up', `unexpected version of SQLite snapshot: ${it.raw['version']}`);
+			}
+
+			if (outputFormat() === 'text') console.log(`[${chalk.green('✓')}] ${path}`);
+			writeFileSync(path, JSON.stringify(result, null, 2));
+
+			upgraded.push(path);
+		});
+
+	if (existsSync(join(out, 'migrations.js'))) {
+		const js = embeddedMigrations(snapshots);
+		writeFileSync(`${out}/migrations.js`, js);
+	}
+
+	if (outputFormat() === 'text') console.log("Everything's fine 🐶🔥");
+
+	return upgraded;
+};
+
+export const updateToV7 = (snapshot: SQLiteSchemaV6): SqliteSnapshot => {
+	const ddl = createDDL();
+	for (const table of Object.values(snapshot.tables)) {
+		ddl.tables.push({
+			name: table.name,
+		});
+
+		for (const column of Object.values(table.columns)) {
+			let def: string | null = typeof column.default === 'undefined' ? null : String(column.default);
+
+			ddl.columns.push({
+				table: table.name,
+				name: column.name,
+				type: column.type,
+				notNull: column.notNull && !column.primaryKey,
+				default: def,
+				autoincrement: column.autoincrement,
+				generated: column.generated ?? null,
+			});
+
+			if (column.primaryKey) {
+				ddl.pks.push({
+					table: table.name,
+					columns: [column.name],
+					name: nameForPk(table.name),
+					nameExplicit: false,
+				});
+			}
+		}
+
+		for (const pk of Object.values(table.compositePrimaryKeys)) {
+			const implicit = pk.name === `${table.name}_${pk.columns.join('_')}_pk`;
+
+			ddl.pks.push({
+				table: table.name,
+				name: pk.name!,
+				columns: pk.columns,
+				nameExplicit: !implicit,
+			});
+		}
+
+		for (const index of Object.values(table.indexes)) {
+			ddl.indexes.push({
+				table: table.name,
+				name: index.name,
+				columns: index.columns.map((it) => ({ value: it, isExpression: false })),
+				isUnique: index.isUnique,
+				where: index.where,
+				origin: 'manual',
+			});
+		}
+
+		for (const unique of Object.values(table.uniqueConstraints)) {
+			const implicit = unique.name === `${table.name}_${unique.columns.join('_')}_unique`;
+			ddl.uniques.push({
+				table: table.name,
+				name: unique.name,
+				columns: unique.columns,
+				nameExplicit: !implicit,
+			});
+		}
+
+		for (const check of Object.values(table.checkConstraints)) {
+			ddl.checks.push({
+				table: table.name,
+				name: check.name,
+				value: check.value,
+			});
+		}
+
+		for (const fk of Object.values(table.foreignKeys)) {
+			const nameExplicit =
+				fk.name !== `${table.name}_${fk.columnsFrom.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fk`;
+			ddl.fks.push({
+				table: table.name,
+				name: fk.name,
+				columns: fk.columnsFrom,
+				tableTo: fk.tableTo,
+				columnsTo: fk.columnsTo,
+				onDelete: transformOnUpdateDelete((fk.onDelete as UpdateDeleteAction | undefined) ?? 'no action'),
+				onUpdate: transformOnUpdateDelete((fk.onUpdate as UpdateDeleteAction | undefined) ?? 'no action'),
+				nameExplicit: nameExplicit,
+			});
+		}
+	}
+
+	for (const view of Object.values(snapshot.views)) {
+		ddl.views.push({
+			name: view.name,
+			definition: view.definition,
+			isExisting: view.isExisting,
+			error: null,
+		});
+	}
+
+	const renames = [...Object.entries(snapshot._meta.tables), ...Object.entries(snapshot._meta.columns)].map(
+		([key, value]) => {
+			return `${key}->${value}`;
+		},
+	);
+
+	return {
+		dialect: 'sqlite',
+		id: snapshot.id,
+		prevIds: [snapshot.prevId],
+		version: '7',
+		ddl: ddl.entities.list(),
+		renames: renames,
+	};
+};
+
+const updateUpToV6 = (json: object): SQLiteSchemaV6 => {
+	const schema = sqliteSchemaV5.parse(json);
+
+	const tables = mapEntries(schema.tables, (tableKey, table) => {
+		const columns = mapEntries(table.columns, (key, value) => {
+			if (
+				value.default
+				&& (typeof value.default === 'object' || Array.isArray(value.default))
+			) {
+				value.default = `'${JSON.stringify(value.default)}'`;
+			}
+			return [key, value];
+		});
+		table.columns = columns;
+		return [tableKey, table];
+	});
+
+	return {
+		...schema,
+		version: '6',
+		dialect: 'sqlite',
+		tables: tables,
+		views: {},
+	};
+};
diff --git a/drizzle-kit/src/cli/commands/utils.ts b/drizzle-kit/src/cli/commands/utils.ts
index d0abcee72e..42c3e0a9b7 100644
--- a/drizzle-kit/src/cli/commands/utils.ts
+++ b/drizzle-kit/src/cli/commands/utils.ts
@@ -1,94 +1,49 @@
 import chalk from 'chalk';
-import { existsSync } from 'fs';
-import { render } from 'hanji';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { object, string } from 'zod';
-import { getTablesFilterByExtensions } from '../../extensions/getTablesFilterByExtensions';
-import { assertUnreachable } from '../../global';
-import { type Dialect, dialect } from '../../schemaValidator';
-import { prepareFilenames } from '../../serializer';
-import { Entities, pullParams, pushParams } from '../validations/cli';
+import { assertUnreachable, type Journal } from '../../utils';
+import { type Dialect, dialect } from '../../utils/schemaValidator';
+import { prepareFilenames } from '../../utils/utils-node';
+import { loadModule } from '../../utils/utils-node';
 import {
-	Casing,
-	CasingType,
-	CliConfig,
-	configCommonSchema,
-	configMigrations,
-	Driver,
-	Prefix,
-	wrapParam,
-} from '../validations/common';
-import { GelCredentials, gelCredentials } from '../validations/gel';
-import { printConfigConnectionIssues as printIssuesGel } from '../validations/gel';
-import {
-	LibSQLCredentials,
-	libSQLCredentials,
-	printConfigConnectionIssues as printIssuesLibSQL,
-} from '../validations/libsql';
-import {
-	MysqlCredentials,
-	mysqlCredentials,
-	printConfigConnectionIssues as printIssuesMysql,
-} from '../validations/mysql';
+	ConfigFileNotFoundCliError,
+	ConfigValidationCliError,
+	MigrationSnapshotNotFoundCliError,
+	MigrationSqlFilesConflictCliError,
+	MissingDialectCliError,
+	RequiredParamsCliError,
+	UnsupportedCommandCliError,
+} from '../errors';
+import { type Hint, HintsHandler } from '../hints';
+import type { CockroachCredentials } from '../validations/cockroach';
+import { cockroachCredentials } from '../validations/cockroach';
+import { printConfigConnectionIssues as printCockroachIssues } from '../validations/cockroach';
+import type { EntitiesFilterConfig } from '../validations/common';
+import { pullParams, pushParams } from '../validations/common';
+import type { Casing, CliConfig, Driver } from '../validations/common';
+import { configCommonSchema, configMigrations, wrapParam } from '../validations/common';
+import { studioCliParams, studioConfig } from '../validations/common';
+import { duckdbCredentials, printConfigConnectionIssues as printIssuesDuckDb } from '../validations/duckdb';
+import type { LibSQLCredentials } from '../validations/libsql';
+import { libSQLCredentials, printConfigConnectionIssues as printIssuesLibSQL } from '../validations/libsql';
+import { printConfigConnectionIssues as printMssqlIssues } from '../validations/mssql';
+import type { MssqlCredentials } from '../validations/mssql';
+import { mssqlCredentials } from '../validations/mssql';
+import type { MysqlCredentials } from '../validations/mysql';
+import { mysqlCredentials, printConfigConnectionIssues as printIssuesMysql } from '../validations/mysql';
 import { outputs } from '../validations/outputs';
-import {
-	PostgresCredentials,
-	postgresCredentials,
-	printConfigConnectionIssues as printIssuesPg,
-} from '../validations/postgres';
+import type { PostgresCredentials } from '../validations/postgres';
+import { postgresCredentials, printConfigConnectionIssues as printIssuesPg } from '../validations/postgres';
+import type { SingleStoreCredentials } from '../validations/singlestore';
 import {
 	printConfigConnectionIssues as printIssuesSingleStore,
-	SingleStoreCredentials,
 	singlestoreCredentials,
 } from '../validations/singlestore';
-import {
-	printConfigConnectionIssues as printIssuesSqlite,
-	SqliteCredentials,
-	sqliteCredentials,
-} from '../validations/sqlite';
-import { studioCliParams, studioConfig } from '../validations/studio';
-import { error, grey } from '../views';
-
-// NextJs default config is target: es5, which esbuild-register can't consume
-const assertES5 = async (unregister: () => void) => {
-	try {
-		require('./_es5.ts');
-	} catch (e: any) {
-		if ('errors' in e && Array.isArray(e.errors) && e.errors.length > 0) {
-			const es5Error = (e.errors as any[]).filter((it) => it.text?.includes(`("es5") is not supported yet`)).length > 0;
-			if (es5Error) {
-				console.log(
-					error(
-						`Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`,
-					),
-				);
-				process.exit(1);
-			}
-		}
-		console.error(e);
-		process.exit(1);
-	}
-};
-
-export const safeRegister = async () => {
-	const { register } = await import('esbuild-register/dist/node');
-	let res: { unregister: () => void };
-	try {
-		res = register({
-			format: 'cjs',
-			loader: 'ts',
-		});
-	} catch {
-		// tsx fallback
-		res = {
-			unregister: () => {},
-		};
-	}
-
-	// has to be outside try catch to be able to run with tsx
-	await assertES5(res.unregister);
-	return res;
-};
+import type { SqliteCredentials } from '../validations/sqlite';
+import { printConfigConnectionIssues as printIssuesSqlite, sqliteCredentials } from '../validations/sqlite';
+import { error, humanLog } from '../views';
+import { prepareSnapshotFolderName } from './generate-common';
 
 export const prepareCheckParams = async (
 	options: {
@@ -102,14 +57,12 @@ export const prepareCheckParams = async (
 		? await drizzleConfigFromFile(options.config as string | undefined)
 		: options;
 
-	if (!config.out || !config.dialect) {
-		let text = `Please provide required params for AWS Data API driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('database', config.out));
-		console.log(wrapParam('secretArn', config.dialect));
-		process.exit(1);
+	if (!config.dialect) {
+		throw new MissingDialectCliError(
+			[error('Please provide required params:'), wrapParam('dialect', config.dialect)].join('\n'),
+		);
 	}
-	return { out: config.out, dialect: config.dialect };
+	return { out: config.out || 'drizzle', dialect: config.dialect };
 };
 
 export const prepareDropParams = async (
@@ -125,35 +78,33 @@ export const prepareDropParams = async (
 		? await drizzleConfigFromFile(options.config as string | undefined)
 		: options;
 
-	if (config.dialect === 'gel') {
-		console.log(
-			error(
-				`You can't use 'drop' command with Gel dialect`,
-			),
-		);
-		process.exit(1);
-	}
-
 	return { out: config.out || 'drizzle', bundle: config.driver === 'expo' };
 };
 
-export type GenerateConfig = {
+export type CheckConfig = { out: string; dialect: Dialect; ignoreConflicts: boolean | undefined };
+
+type AnySchemaSource = { load(): Promise<unknown> };
+
+export type GenerateConfig<S extends AnySchemaSource = AnySchemaSource> = {
 	dialect: Dialect;
-	schema: string | string[];
+	filenames: string[];
+	schemaSource: S;
 	out: string;
 	breakpoints: boolean;
 	name?: string;
-	prefix: Prefix;
 	custom: boolean;
 	bundle: boolean;
-	casing?: CasingType;
 	driver?: Driver;
+	ignoreConflicts?: boolean;
+	explain: boolean;
+	hints: HintsHandler;
 };
 
 export type ExportConfig = {
 	dialect: Dialect;
-	schema: string | string[];
 	sql: boolean;
+	filenames: string[];
+	output: 'text' | 'json';
 };
 
 export const prepareGenerateConfig = async (
@@ -166,43 +117,49 @@ export const prepareGenerateConfig = async (
 		name?: string;
 		dialect?: Dialect;
 		driver?: Driver;
-		prefix?: Prefix;
-		casing?: CasingType;
+		ignoreConflicts?: boolean;
+		explain?: boolean;
+		// `string` arrives only from the CLI `--hints` flag; the SDK passes a raw `Hint[]`.
+		hints?: string | Hint[];
+		hintsFile?: string;
 	},
 	from: 'config' | 'cli',
 ): Promise<GenerateConfig> => {
 	const config = from === 'config' ? await drizzleConfigFromFile(options.config) : options;
+	const hints = await HintsHandler.fromCli(options);
 
-	const { schema, out, breakpoints, dialect, driver, casing } = config;
+	const { schema, out, breakpoints, dialect, driver } = config;
 
 	if (!schema || !dialect) {
-		console.log(error('Please provide required params:'));
-		console.log(wrapParam('schema', schema));
-		console.log(wrapParam('dialect', dialect));
-		console.log(wrapParam('out', out, true));
-		process.exit(1);
+		throw new RequiredParamsCliError(
+			['dialect', 'schema'],
+			[
+				error('Please provide required params:'),
+				wrapParam('dialect', dialect),
+				wrapParam('schema', schema),
+			].join('\n'),
+		);
 	}
 
 	const fileNames = prepareFilenames(schema);
-	if (fileNames.length === 0) {
-		render(`[${chalk.blue('i')}] No schema file in ${schema} was found`);
-		process.exit(0);
-	}
 
-	const prefix = ('migrations' in config ? config.migrations?.prefix : options.prefix)
-		|| 'index';
+	const { SchemaSource } = dialect === 'sqlite' || dialect === 'turso'
+		? await import('../../dialects/sqlite/drizzle')
+		: await import('../../dialects/postgres/drizzle');
 
 	return {
 		dialect: dialect,
 		name: options.name,
 		custom: options.custom || false,
-		prefix,
 		breakpoints: breakpoints ?? true,
-		schema: schema,
+		filenames: fileNames,
+		schemaSource: SchemaSource.fromFilenames(fileNames),
 		out: out || 'drizzle',
 		bundle: driver === 'expo' || driver === 'durable-sqlite',
-		casing,
 		driver,
+		ignoreConflicts: options.ignoreConflicts !== undefined && options.ignoreConflicts,
+		explain: options.explain ?? false,
+		hints,
 	};
 };
 
@@ -211,30 +168,33 @@ export const prepareExportConfig = async (
 		config?: string;
 		schema?: string;
 		dialect?: Dialect;
-		sql: boolean;
+		sql?: boolean;
 	},
 	from: 'config' | 'cli',
-): Promise<ExportConfig> => {
-	const config = from === 'config' ? await drizzleConfigFromFile(options.config, true) : options;
+): Promise<Omit<ExportConfig, 'output'>> => {
+	const config = from === 'config'
+		? await drizzleConfigFromFile(options.config, true)
+		: options;
 
-	const { schema, dialect, sql } = config;
+	const { schema, dialect } = config;
+	const sql = options.sql ?? (config as { sql?: boolean }).sql ?? true;
 
 	if (!schema || !dialect) {
-		console.log(error('Please provide required params:'));
-		console.log(wrapParam('schema', schema));
-		console.log(wrapParam('dialect', dialect));
-		process.exit(1);
+		throw new RequiredParamsCliError(
+			['dialect', 'schema'],
+			[
+				error('Please provide required params:'),
+				wrapParam('dialect', dialect),
+				wrapParam('schema', schema),
+			].join('\n'),
+		);
 	}
 
 	const fileNames = prepareFilenames(schema);
-	if (fileNames.length === 0) {
-		render(`[${chalk.blue('i')}] No schema file in ${schema} was found`);
-		process.exit(0);
-	}
 	return {
 		dialect: dialect,
-		schema: schema,
 		sql: sql,
+		filenames: fileNames,
 	};
 };
 
@@ -286,17 +246,31 @@ export const preparePushConfig = async (
 			dialect: 'singlestore';
 			credentials: SingleStoreCredentials;
 		}
+		| {
+			dialect: 'mssql';
+			credentials: MssqlCredentials;
+		}
+		| {
+			dialect: 'cockroach';
+			credentials: CockroachCredentials;
+		}
 	) & {
-		schemaPath: string | string[];
 		verbose: boolean;
-		strict: boolean;
 		force: boolean;
-		tablesFilter: string[];
-		schemasFilter: string[];
-		casing?: CasingType;
-		entities?: Entities;
+		explain: boolean;
+		hints: HintsHandler;
+		filters: EntitiesFilterConfig;
+		migrations: {
+			table: string;
+			schema: string;
+		};
+		filenames: string[];
 	}
 > => {
+	const hints = await HintsHandler.fromCli({
+		hints: options.hints as string | Hint[] | undefined,
+		hintsFile: options.hintsFile as string | undefined,
+	});
 	const raw = flattenDatabaseCredentials(
 		from === 'config'
 			? await drizzleConfigFromFile(options.config as string | undefined)
@@ -309,144 +283,161 @@ export const preparePushConfig = async (
 	const parsed = pushParams.safeParse(raw);
 
 	if (parsed.error) {
-		console.log(error('Please provide required params:'));
-		console.log(wrapParam('dialect', raw.dialect));
-		console.log(wrapParam('schema', raw.schema));
-		process.exit(1);
+		throw new RequiredParamsCliError(
+			['dialect', 'schema'],
+			[
+				error('Please provide required params:'),
+				wrapParam('dialect', raw.dialect),
+				wrapParam('schema', raw.schema),
+			].join('\n'),
+		);
 	}
 
 	const config = parsed.data;
 
 	const schemaFiles = prepareFilenames(config.schema);
-	if (schemaFiles.length === 0) {
-		render(`[${chalk.blue('i')}] No schema file in ${config.schema} was found`);
-		process.exit(0);
-	}
-
-	const tablesFilterConfig = config.tablesFilter;
-	const tablesFilter = tablesFilterConfig
-		? typeof tablesFilterConfig === 'string'
-			? [tablesFilterConfig]
-			: tablesFilterConfig
-		: [];
-
-	const schemasFilterConfig = config.schemaFilter;
+	humanLog(chalk.gray(`Reading schema files:\n${schemaFiles.join('\n')}\n`));
 
-	const schemasFilter = schemasFilterConfig
-		? typeof schemasFilterConfig === 'string'
-			? [schemasFilterConfig]
-			: schemasFilterConfig
-		: [];
-
-	tablesFilter.push(...getTablesFilterByExtensions(config));
+	const filters = {
+		tables: config.tablesFilter,
+		schemas: config.schemaFilter,
+		entities: config.entities,
+		extensions: config.extensionsFilters,
+	} as const;
 
 	if (config.dialect === 'postgresql') {
 		const parsed = postgresCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesPg(config);
-			process.exit(1);
-		}
-
-		return {
-			dialect: 'postgresql',
-			schemaPath: config.schema,
-			strict: config.strict ?? false,
-			verbose: config.verbose ?? false,
-			force: (options.force as boolean) ?? false,
-			credentials: parsed.data,
-			casing: config.casing,
-			tablesFilter,
-			schemasFilter,
-			entities: config.entities,
-		};
+		if (parsed.success) {
+			return {
+				dialect: 'postgresql',
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printIssuesPg(config);
 	}
 
 	if (config.dialect === 'mysql') {
 		const parsed = mysqlCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesMysql(config);
-			process.exit(1);
-		}
-		return {
-			dialect: 'mysql',
-			schemaPath: config.schema,
-			strict: config.strict ?? false,
-			verbose: config.verbose ?? false,
-			force: (options.force as boolean) ?? false,
-			credentials: parsed.data,
-			casing: config.casing,
-			tablesFilter,
-			schemasFilter,
-		};
+		if (parsed.success) {
+			return {
+				dialect: 'mysql',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printIssuesMysql(config);
 	}
 
 	if (config.dialect === 'singlestore') {
 		const parsed = singlestoreCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesSingleStore(config);
-			process.exit(1);
-		}
-
-		return {
-			dialect: 'singlestore',
-			schemaPath: config.schema,
-			strict: config.strict ?? false,
-			verbose: config.verbose ?? false,
-			force: (options.force as boolean) ?? false,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-		};
+		if (parsed.success) {
+			return {
+				dialect: 'singlestore',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printIssuesSingleStore(config);
 	}
 
 	if (config.dialect === 'sqlite') {
 		const parsed = sqliteCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesSqlite(config, 'push');
-			process.exit(1);
-		}
-		return {
-			dialect: 'sqlite',
-			schemaPath: config.schema,
-			strict: config.strict ?? false,
-			verbose: config.verbose ?? false,
-			force: (options.force as boolean) ?? false,
-			credentials: parsed.data,
-			casing: config.casing,
-			tablesFilter,
-			schemasFilter,
-		};
+		if (parsed.success) {
+			return {
+				dialect: 'sqlite',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printIssuesSqlite(config, 'push');
 	}
 
 	if (config.dialect === 'turso') {
 		const parsed = libSQLCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesSqlite(config, 'push');
-			process.exit(1);
-		}
-		return {
-			dialect: 'turso',
-			schemaPath: config.schema,
-			strict: config.strict ?? false,
-			verbose: config.verbose ?? false,
-			force: (options.force as boolean) ?? false,
-			credentials: parsed.data,
-			casing: config.casing,
-			tablesFilter,
-			schemasFilter,
-		};
-	}
-
-	if (config.dialect === 'gel') {
-		console.log(
-			error(
-				`You can't use 'push' command with Gel dialect`,
-			),
-		);
-		process.exit(1);
+		if (parsed.success) {
+			return {
+				dialect: 'turso',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printIssuesLibSQL(config, 'push');
+	}
+
+	if (config.dialect === 'mssql') {
+		const parsed = mssqlCredentials.safeParse(config);
+		if (parsed.success) {
+			return {
+				dialect: 'mssql',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printMssqlIssues(config);
+	}
+
+	if (config.dialect === 'cockroach') {
+		const parsed = cockroachCredentials.safeParse(config);
+		if (parsed.success) {
+			return {
+				dialect: 'cockroach',
+				verbose: config.verbose ?? false,
+				force: (options.force as boolean) ?? false,
+				credentials: parsed.data,
+				filters,
+				explain: (options.explain as boolean) ?? false,
+				hints,
+				migrations: config.migrations,
+				filenames: schemaFiles,
+			};
+		}
+		printCockroachIssues(config);
+	}
+
+	if (config.dialect === 'duckdb') {
+		throw new UnsupportedCommandCliError('push', error(`You can't use 'push' command with DuckDb dialect`), {
+			dialect: 'DuckDb',
+		});
 	}
 
-	assertUnreachable(config.dialect);
+	throw new Error(`Unexpected dialect: ${config.dialect}`);
 };
 
 export const preparePullConfig = async (
@@ -475,17 +466,23 @@ export const preparePullConfig = async (
 			credentials: SingleStoreCredentials;
 		}
 		| {
-			dialect: 'gel';
-			credentials?: GelCredentials;
+			dialect: 'mssql';
+			credentials: MssqlCredentials;
+		}
+		| {
+			dialect: 'cockroach';
+			credentials: CockroachCredentials;
 		}
 	) & {
 		out: string;
 		breakpoints: boolean;
 		casing: Casing;
-		tablesFilter: string[];
-		schemasFilter: string[];
-		prefix: Prefix;
-		entities: Entities;
+		filters: EntitiesFilterConfig;
+		init: boolean;
+		migrations: {
+			table: string;
+			schema: string;
+		};
 	}
 > => {
 	const raw = flattenPull(
@@ -496,156 +493,153 @@ export const preparePullConfig = async (
 	const parsed = pullParams.safeParse(raw);
 
 	if (parsed.error) {
-		console.log(error('Please provide required params:'));
-		console.log(wrapParam('dialect', raw.dialect));
-		process.exit(1);
+		throw new RequiredParamsCliError(
+			['dialect'],
+			[
+				error('Please provide required params:'),
+				wrapParam('dialect', raw.dialect),
+			].join('\n'),
+		);
 	}
 
 	const config = parsed.data;
 	const dialect = config.dialect;
 
-	const tablesFilterConfig = config.tablesFilter;
-	const tablesFilter = tablesFilterConfig
-		? typeof tablesFilterConfig === 'string'
-			? [tablesFilterConfig]
-			: tablesFilterConfig
-		: [];
-
-	if (config.extensionsFilters) {
-		if (
-			config.extensionsFilters.includes('postgis')
-			&& dialect === 'postgresql'
-		) {
-			tablesFilter.push(
-				...['!geography_columns', '!geometry_columns', '!spatial_ref_sys'],
-			);
-		}
-	}
+	const migrations = config.migrations;
 
-	const schemasFilterConfig = config.schemaFilter; // TODO: consistent naming
-	const schemasFilter = schemasFilterConfig
-		? typeof schemasFilterConfig === 'string'
-			? [schemasFilterConfig]
-			: schemasFilterConfig
-		: [];
+	const filters = {
+		tables: config.tablesFilter,
+		schemas: config.schemaFilter,
+		entities: config.entities,
+		extensions: config.extensionsFilters,
+	} as const;
 
 	if (dialect === 'postgresql') {
 		const parsed = postgresCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesPg(config);
-			process.exit(1);
+		if (parsed.success) {
+			return {
+				dialect: 'postgresql',
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
 		}
-
-		return {
-			dialect: 'postgresql',
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
+		printIssuesPg(config);
 	}
 
 	if (dialect === 'mysql') {
 		const parsed = mysqlCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesMysql(config);
-			process.exit(1);
+		if (parsed.success) {
+			return {
+				dialect: 'mysql',
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
 		}
-		return {
-			dialect: 'mysql',
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
+		printIssuesMysql(config);
 	}
 
 	if (dialect === 'singlestore') {
 		const parsed = singlestoreCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesSingleStore(config);
-			process.exit(1);
+		if (parsed.success) {
+			return {
+				dialect: 'singlestore',
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
 		}
-
-		return {
-			dialect: 'singlestore',
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
+		printIssuesSingleStore(config);
 	}
 
 	if (dialect === 'sqlite') {
 		const parsed = sqliteCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesSqlite(config, 'pull');
-			process.exit(1);
+		if (parsed.success) {
+			return {
+				dialect: 'sqlite',
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
 		}
-		return {
-			dialect: 'sqlite',
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
+		printIssuesSqlite(config, 'pull');
 	}
 
 	if (dialect === 'turso') {
 		const parsed = libSQLCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesLibSQL(config, 'pull');
-			process.exit(1);
-		}
-		return {
-			dialect,
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
-	}
-
-	if (dialect === 'gel') {
-		const parsed = gelCredentials.safeParse(config);
-		if (!parsed.success) {
-			printIssuesGel(config);
-			process.exit(1);
-		}
-		return {
-			dialect,
-			out: config.out,
-			breakpoints: config.breakpoints,
-			casing: config.casing,
-			credentials: parsed.data,
-			tablesFilter,
-			schemasFilter,
-			prefix: config.migrations?.prefix || 'index',
-			entities: config.entities,
-		};
+		if (parsed.success) {
+			return {
+				dialect,
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
+		}
+		printIssuesLibSQL(config, 'pull');
+	}
+
+	if (dialect === 'mssql') {
+		const parsed = mssqlCredentials.safeParse(config);
+		if (parsed.success) {
+			return {
+				dialect,
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
+		}
+		printMssqlIssues(config);
+	}
+
+	if (dialect === 'cockroach') {
+		const parsed = cockroachCredentials.safeParse(config);
+		if (parsed.success) {
+			return {
+				dialect,
+				out: config.out,
+				breakpoints: config.breakpoints,
+				casing: config.casing,
+				credentials: parsed.data,
+				filters,
+				init: !!options.init,
+				migrations,
+			};
+		}
+		printCockroachIssues(config);
+	}
+
+	if (dialect === 'duckdb') {
+		throw new UnsupportedCommandCliError('pull', error(`You can't use 'pull' command with DuckDb dialect`), {
+			dialect: 'DuckDb',
+		});
 	}
 
-	assertUnreachable(dialect);
+	throw new Error(`Unexpected dialect: ${dialect}`);
 };
 
 export const prepareStudioConfig = async (options: Record<string, unknown>) => {
@@ -654,13 +648,13 @@ export const prepareStudioConfig = async (options: Record<string, unknown>) => {
 	const result = studioConfig.safeParse(config);
 	if (!result.success) {
 		if (!('dialect' in config)) {
-			console.log(outputs.studio.noDialect());
+			humanLog(outputs.studio.noDialect());
 		}
 		process.exit(1);
 	}
 
 	if (!('dbCredentials' in config)) {
-		console.log(outputs.studio.noCredentials());
+		humanLog(outputs.studio.noCredentials());
 		process.exit(1);
 	}
 	const { host, port } = params;
@@ -747,13 +741,40 @@ export const prepareStudioConfig = async (options: Record<string, unknown>) => {
 		};
 	}
 
-	if (dialect === 'gel') {
-		console.log(
-			error(
-				`You can't use 'studio' command with Gel dialect`,
-			),
-		);
-		process.exit(1);
+	if (dialect === 'cockroach') {
+		const parsed = cockroachCredentials.safeParse(flattened);
+		if (!parsed.success) {
+			printCockroachIssues(flattened as Record<string, unknown>);
+			process.exit(1);
+		}
+		const credentials = parsed.data;
+		return {
+			dialect,
+			schema,
+			host,
+			port,
+			credentials,
+		};
+	}
+
+	if (dialect === 'mssql') {
+		throw new Error(`You can't use 'studio' command with MsSql dialect yet`);
+	}
+
+	if (dialect === 'duckdb') {
+		const parsed = duckdbCredentials.safeParse(flattened);
+		if (!parsed.success) {
+			printIssuesDuckDb(flattened as Record<string, unknown>);
+			process.exit(1);
+		}
+		const credentials = parsed.data;
+		return {
+			dialect,
+			schema,
+			host,
+			port,
+			credentials,
+		};
 	}
 
 	assertUnreachable(dialect);
@@ -769,9 +790,13 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	const config = await drizzleConfigFromFile(configPath);
 	const parsed = migrateConfig.safeParse(config);
 	if (parsed.error) {
-		console.log(error('Please provide required params:'));
-		console.log(wrapParam('dialect', config.dialect));
-		process.exit(1);
+		throw new RequiredParamsCliError(
+			['dialect'],
+			[
+				error('Please provide required params:'),
+				wrapParam('dialect', config.dialect),
+			].join('\n'),
+		);
 	}
 
 	const { dialect, out } = parsed.data;
@@ -781,8 +806,7 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	if (dialect === 'postgresql') {
 		const parsed = postgresCredentials.safeParse(flattened);
 		if (!parsed.success) {
-			printIssuesPg(flattened as Record<string, unknown>);
-			process.exit(1);
+			return printIssuesPg(flattened as Record<string, unknown>);
 		}
 		const credentials = parsed.data;
 		return {
@@ -797,8 +821,7 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	if (dialect === 'mysql') {
 		const parsed = mysqlCredentials.safeParse(flattened);
 		if (!parsed.success) {
-			printIssuesMysql(flattened as Record<string, unknown>);
-			process.exit(1);
+			return printIssuesMysql(flattened as Record<string, unknown>);
 		}
 		const credentials = parsed.data;
 		return {
@@ -813,8 +836,7 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	if (dialect === 'singlestore') {
 		const parsed = singlestoreCredentials.safeParse(flattened);
 		if (!parsed.success) {
-			printIssuesSingleStore(flattened as Record<string, unknown>);
-			process.exit(1);
+			return printIssuesSingleStore(flattened as Record<string, unknown>);
 		}
 		const credentials = parsed.data;
 		return {
@@ -829,8 +851,7 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	if (dialect === 'sqlite') {
 		const parsed = sqliteCredentials.safeParse(flattened);
 		if (!parsed.success) {
-			printIssuesSqlite(flattened as Record<string, unknown>, 'migrate');
-			process.exit(1);
+			return printIssuesSqlite(flattened as Record<string, unknown>, 'migrate');
 		}
 		const credentials = parsed.data;
 		return {
@@ -844,8 +865,7 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 	if (dialect === 'turso') {
 		const parsed = libSQLCredentials.safeParse(flattened);
 		if (!parsed.success) {
-			printIssuesLibSQL(flattened as Record<string, unknown>, 'migrate');
-			process.exit(1);
+			return printIssuesLibSQL(flattened as Record<string, unknown>, 'migrate');
 		}
 		const credentials = parsed.data;
 		return {
@@ -857,13 +877,40 @@ export const prepareMigrateConfig = async (configPath: string | undefined) => {
 		};
 	}
 
-	if (dialect === 'gel') {
-		console.log(
-			error(
-				`You can't use 'migrate' command with Gel dialect`,
-			),
-		);
-		process.exit(1);
+	if (dialect === 'mssql') {
+		const parsed = mssqlCredentials.safeParse(flattened);
+		if (!parsed.success) {
+			return printMssqlIssues(flattened as Record<string, unknown>);
+		}
+		const credentials = parsed.data;
+		return {
+			dialect,
+			out,
+			credentials,
+			schema,
+			table,
+		};
+	}
+
+	if (dialect === 'cockroach') {
+		const parsed = cockroachCredentials.safeParse(flattened);
+		if (!parsed.success) {
+			return printCockroachIssues(flattened as Record<string, unknown>);
+		}
+		const credentials = parsed.data;
+		return {
+			dialect,
+			out,
+			credentials,
+			schema,
+			table,
+		};
+	}
+
+	if (dialect === 'duckdb') {
+		throw new UnsupportedCommandCliError('migrate', error(`You can't use 'migrate' command with DuckDb dialect`), {
+			dialect: 'DuckDb',
+		});
 	}
 
 	assertUnreachable(dialect);
@@ -875,11 +922,15 @@ export const drizzleConfigFromFile = async (
 ): Promise<CliConfig> => {
 	const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
 
-	const defaultTsConfigExists = existsSync(resolve(join(prefix, 'drizzle.config.ts')));
-	const defaultJsConfigExists = existsSync(resolve(join(prefix, 'drizzle.config.js')));
-	const defaultJsonConfigExists = existsSync(
-		join(resolve('drizzle.config.json')),
+	const defaultTsConfigExists = existsSync(
+		resolve(join(prefix, 'drizzle.config.ts')),
+	);
+	const defaultJsConfigExists = existsSync(
+		resolve(join(prefix, 'drizzle.config.js')),
 	);
+	// const defaultJsonConfigExists = existsSync(
+	// 	join(resolve('drizzle.config.json')),
+	// );
 
 	const defaultConfigPath = defaultTsConfigExists
 		? 'drizzle.config.ts'
@@ -888,7 +939,7 @@ export const drizzleConfigFromFile = async (
 		: 'drizzle.config.json';
 
 	if (!configPath && !isExport) {
-		console.log(
+		humanLog(
 			chalk.gray(
 				`No config path provided, using default '${defaultConfigPath}'`,
 			),
@@ -898,26 +949,73 @@ export const drizzleConfigFromFile = async (
 	const path: string = resolve(join(prefix, configPath ?? defaultConfigPath));
 
 	if (!existsSync(path)) {
-		console.log(`${path} file does not exist`);
-		process.exit(1);
+		throw new ConfigFileNotFoundCliError(path);
 	}
 
-	if (!isExport) console.log(chalk.grey(`Reading config file '${path}'`));
+	if (!isExport) humanLog(`Reading config file '${path}'`);
 
-	const { unregister } = await safeRegister();
-	const required = require(`${path}`);
-	const content = required.default ?? required;
-	unregister();
+	const content = await loadModule<any>(path, { defaultExport: true });
 
 	// --- get response and then check by each dialect independently
 	const res = configCommonSchema.safeParse(content);
 	if (!res.success) {
-		console.log(res.error);
-		if (!('dialect' in content)) {
-			console.log(error("Please specify 'dialect' param in config file"));
-		}
-		process.exit(1);
+		throw new ConfigValidationCliError(res.error.message, res.error.issues as never, { cause: res.error });
 	}
 
 	return res.data;
 };
+
+export const migrateToFoldersV3 = (out: string) => {
+	// if there is meta folder - and there is a journal - it's version 8
+	const metaPath = join(out, 'meta');
+	const journalPath = join(metaPath, '_journal.json');
+	if (existsSync(metaPath) && existsSync(journalPath)) {
+		const journal: Journal = JSON.parse(readFileSync(journalPath).toString());
+		const sqlFiles = readdirSync(out);
+		for (const entry of journal.entries) {
+			const folderName = prepareSnapshotFolderName(entry.when);
+			// Reading Snapshots files
+			const [snapshotPrefix, ...rest] = entry.tag.split('_');
+			const migrationName = rest.join('_');
+			const oldSnapshotPath = join(metaPath, `${snapshotPrefix}_snapshot.json`);
+
+			if (!existsSync(oldSnapshotPath)) {
+				// If for some reason this happens we need to throw an error
+				// This can't happen unless there were wrong drizzle-kit migrations usage
+				throw new MigrationSnapshotNotFoundCliError(oldSnapshotPath);
+			}
+
+			const oldSnapshot = readFileSync(oldSnapshotPath);
+
+			// Reading SQL files
+			let oldSqlPath = join(out, `${entry.tag}.sql`);
+			const sqlFileFromJournal = join(out, `${entry.tag}.sql`);
+			if (!existsSync(sqlFileFromJournal)) {
+				// We will try to find it by prefix, but this is a sign that something went wrong
+				// with properly using drizzle-kit migrations
+				const sqlFileName = sqlFiles.find((file) => file.startsWith(snapshotPrefix));
+				if (!sqlFileName) continue;
+				if (sqlFileName?.length > 1) {
+					throw new MigrationSqlFilesConflictCliError(snapshotPrefix);
+				}
+			}
+			const oldSql = readFileSync(oldSqlPath);
+
+			mkdirSync(join(out, `${folderName}_${migrationName}`));
+			writeFileSync(
+				join(out, `${folderName}_${migrationName}/snapshot.json`),
+				oldSnapshot,
+			);
+			writeFileSync(
+				join(out, `${folderName}_${migrationName}/migration.sql`),
+				oldSql,
+			);
+
+			unlinkSync(oldSqlPath);
+		}
+
+		rmSync(metaPath, { recursive: true, force: true });
+		return true;
+	}
+	return false;
+};
diff --git a/drizzle-kit/src/cli/connections.ts b/drizzle-kit/src/cli/connections.ts
index 98cf299a19..e314b8516b 100644
--- a/drizzle-kit/src/cli/connections.ts
+++ b/drizzle-kit/src/cli/connections.ts
@@ -1,41 +1,71 @@
-import type { AwsDataApiPgQueryResult, AwsDataApiSessionOptions } from 'drizzle-orm/aws-data-api/pg';
-import type { MigrationConfig } from 'drizzle-orm/migrator';
+/// <reference types="@cloudflare/workers-types" />
+import type { PGlite } from '@electric-sql/pglite';
+import type { SQLiteCloudRowset } from '@sqlitecloud/drivers';
+import { DrizzleQueryError, is } from 'drizzle-orm';
+import type { AwsDataApiSessionOptions } from 'drizzle-orm/aws-data-api/pg';
+import type { MigrationConfig, MigratorInitFailResponse } from 'drizzle-orm/migrator';
 import type { PreparedQueryConfig } from 'drizzle-orm/pg-core';
+import type { config } from 'mssql';
+import type { Connection, ConnectionConfig, Query } from 'mysql2';
+import net from 'net';
 import fetch from 'node-fetch';
+import type { Client as PgClient } from 'pg';
 import ws from 'ws';
-import { assertUnreachable } from '../global';
-import type { ProxyParams } from '../serializer/studio';
-import {
-	type DB,
-	LibSQLDB,
-	normalisePGliteUrl,
-	normaliseSQLiteUrl,
-	type Proxy,
-	type SQLiteDB,
-	type SqliteProxy,
-} from '../utils';
-import { assertPackages, checkPackage } from './utils';
-import { GelCredentials } from './validations/gel';
-import { LibSQLCredentials } from './validations/libsql';
+import type { BenchmarkProxy, QueriesTimings, TransactionProxy } from '../utils';
+import { assertUnreachable } from '../utils';
+import type { LibSQLDB } from '../utils';
+import type { DB, Proxy, SQLiteDB } from '../utils';
+import { normaliseSQLiteUrl } from '../utils/utils-node';
+import { JSONB } from '../utils/when-json-met-bigint';
+import type { ProxyParams } from './commands/studio';
+import { ConnectionStringDatabaseCliError, DatabaseDriverCliError } from './errors';
+import { assertPackages, checkPackage, QueryError } from './utils';
+import type { DuckDbCredentials } from './validations/duckdb';
+import type { LibSQLCredentials } from './validations/libsql';
+import type { MssqlCredentials } from './validations/mssql';
 import type { MysqlCredentials } from './validations/mysql';
 import { withStyle } from './validations/outputs';
 import type { PostgresCredentials } from './validations/postgres';
-import { SingleStoreCredentials } from './validations/singlestore';
+import type { SingleStoreCredentials } from './validations/singlestore';
 import type { SqliteCredentials } from './validations/sqlite';
+import { humanLog } from './views';
+
+const ms = (a: bigint, b: bigint) => Number(b - a) / 1_000_000;
+
+const normalisePGliteUrl = (it: string) => {
+	if (it.startsWith('file:')) {
+		return it.substring(5);
+	}
+
+	return it;
+};
 
 export const preparePostgresDB = async (
-	credentials: PostgresCredentials,
+	credentials: PostgresCredentials | {
+		driver: 'pglite';
+		client: PGlite;
+	},
 ): Promise<
 	DB & {
+		packageName:
+			| '@aws-sdk/client-rds-data'
+			| 'pglite'
+			| 'pg'
+			| 'postgres'
+			| '@vercel/postgres'
+			| '@neondatabase/serverless'
+			| 'bun';
 		proxy: Proxy;
-		migrate: (config: string | MigrationConfig) => Promise<void>;
+		transactionProxy: TransactionProxy;
+		benchmarkProxy?: BenchmarkProxy;
+		migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
 	}
 > => {
 	if ('driver' in credentials) {
 		const { driver } = credentials;
 		if (driver === 'aws-data-api') {
 			assertPackages('@aws-sdk/client-rds-data');
-			const { RDSDataClient, ExecuteStatementCommand, TypeHint } = await import(
+			const { RDSDataClient } = await import(
 				'@aws-sdk/client-rds-data'
 			);
 			const { AwsDataApiSession, drizzle } = await import(
@@ -53,53 +83,68 @@ export const preparePostgresDB = async (
 			const session = new AwsDataApiSession(
 				rdsClient,
 				new PgDialect(),
-				undefined,
+				{},
 				config,
 				undefined,
 			);
 
-			const db = drizzle(rdsClient, config);
+			const db = drizzle({ client: rdsClient, ...config });
 			const migrateFn = async (config: MigrationConfig) => {
 				return migrate(db, config);
 			};
 
-			const query = async (sql: string, params: any[]) => {
-				const prepared = session.prepareQuery(
+			const query = async (sql: string, params: any[]): Promise<any[]> => {
+				const prepared = session.prepareQuery<
+					PreparedQueryConfig & {
+						execute: any[];
+					}
+				>(
 					{ sql, params: params ?? [] },
-					undefined,
-					undefined,
+					'objects',
 					false,
+					undefined,
 				);
-				const result = await prepared.all();
-				return result as any[];
+
+				return prepared.execute().catch((e) => {
+					// * AwsDataApiSession wraps all errors into DrizzleQueryError, so we need to check the cause
+					if (e instanceof DrizzleQueryError && e.cause instanceof Error) {
+						throw new QueryError(e.cause, sql, params);
+					}
+					throw new QueryError(e, sql, params);
+				});
 			};
 			const proxy = async (params: ProxyParams) => {
 				const prepared = session.prepareQuery<
 					PreparedQueryConfig & {
-						execute: AwsDataApiPgQueryResult<unknown>;
-						values: AwsDataApiPgQueryResult<unknown[]>;
+						execute: unknown[];
 					}
 				>(
 					{
 						sql: params.sql,
 						params: params.params ?? [],
-						typings: params.typings,
 					},
+					params.mode === 'array' ? 'arrays' : 'objects',
+					false,
 					undefined,
-					undefined,
-					params.mode === 'array',
 				);
-				if (params.mode === 'array') {
-					const result = await prepared.values();
-					return result.rows;
-				}
-				const result = await prepared.execute();
-				return result.rows;
+
+				return prepared.execute().catch((e) => {
+					// * AwsDataApiSession wraps all errors into DrizzleQueryError, so we need to check the cause
+					if (is(e, DrizzleQueryError) && e.cause instanceof Error) {
+						throw new QueryError(e.cause, params.sql, params.params || []);
+					}
+					throw new QueryError(e, params.sql, params.params || []);
+				});
+			};
+			const transactionProxy: TransactionProxy = async (_queries) => {
+				throw new Error('Transaction not supported');
 			};
 
 			return {
+				packageName: '@aws-sdk/client-rds-data',
 				query,
 				proxy,
+				transactionProxy,
 				migrate: migrateFn,
 			};
 		}
@@ -110,9 +155,9 @@ export const preparePostgresDB = async (
 			const { drizzle } = await import('drizzle-orm/pglite');
 			const { migrate } = await import('drizzle-orm/pglite/migrator');
 
-			const pglite = new PGlite(normalisePGliteUrl(credentials.url));
+			const pglite = 'client' in credentials ? credentials.client : new PGlite(normalisePGliteUrl(credentials.url));
 			await pglite.waitReady;
-			const drzl = drizzle(pglite);
+			const drzl = drizzle({ client: pglite });
 			const migrateFn = async (config: MigrationConfig) => {
 				return migrate(drzl, config);
 			};
@@ -127,27 +172,54 @@ export const preparePostgresDB = async (
 			const query = async <T>(sql: string, params: any[] = []) => {
 				const result = await pglite.query(sql, params, {
 					parsers,
+				}).catch((e) => {
+					throw new QueryError(e, sql, params);
 				});
 				return result.rows as T[];
 			};
 
 			const proxy = async (params: ProxyParams) => {
-				const preparedParams = preparePGliteParams(params.params);
+				const preparedParams = preparePGliteParams(params.params || []);
 				const result = await pglite.query(params.sql, preparedParams, {
 					rowMode: params.mode,
 					parsers,
+				}).catch((e) => {
+					throw new QueryError(e, params.sql, params.params || []);
 				});
 				return result.rows;
 			};
 
-			return { query, proxy, migrate: migrateFn };
+			const transactionProxy: TransactionProxy = async (queries) => {
+				const results: any[] = [];
+				try {
+					await pglite.transaction(async (tx) => {
+						for (const query of queries) {
+							const result = await tx.query(query.sql, undefined, {
+								parsers,
+							});
+							results.push(result.rows);
+						}
+					});
+				} catch (error) {
+					results.push(error as Error);
+				}
+				return results;
+			};
+
+			return {
+				packageName: 'pglite',
+				query,
+				proxy,
+				transactionProxy,
+				migrate: migrateFn,
+			};
 		}
 
 		assertUnreachable(driver);
 	}
 
 	if (await checkPackage('pg')) {
-		console.log(withStyle.info(`Using 'pg' driver for database querying`));
+		humanLog(withStyle.info(`Using 'pg' driver for database querying`));
 		const { default: pg } = await import('pg');
 		const { drizzle } = await import('drizzle-orm/node-postgres');
 		const { migrate } = await import('drizzle-orm/node-postgres/migrator');
@@ -178,44 +250,210 @@ export const preparePostgresDB = async (
 				if (typeId === pg.types.builtins.INTERVAL) {
 					return (val: any) => val;
 				}
+				if (typeId === pg.types.builtins.JSON || typeId === pg.types.builtins.JSONB) {
+					return (val: any) => JSONB.parse(val);
+				}
 				// @ts-ignore
 				return pg.types.getTypeParser(typeId, format);
 			},
 		};
 
-		const client = 'url' in credentials
+		const pool = 'url' in credentials
 			? new pg.Pool({ connectionString: credentials.url, max: 1 })
 			: new pg.Pool({ ...credentials, ssl, max: 1 });
 
-		const db = drizzle(client);
+		const db = drizzle({ client: pool });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
 
 		const query = async (sql: string, params?: any[]) => {
-			const result = await client.query({
+			const result = await pool.query({
 				text: sql,
 				values: params ?? [],
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, sql, params || []);
 			});
 			return result.rows;
 		};
 
-		const proxy: Proxy = async (params: ProxyParams) => {
-			const result = await client.query({
+		const proxy: Proxy = async (params) => {
+			const result = await pool.query({
 				text: params.sql,
 				values: params.params,
 				...(params.mode === 'array' && { rowMode: 'array' }),
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
 			});
 			return result.rows;
 		};
 
-		return { query, proxy, migrate: migrateFn };
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			const tx = await pool.connect();
+			try {
+				await tx.query('BEGIN');
+				for (const query of queries) {
+					const result = await tx.query({
+						text: query.sql,
+						types,
+					});
+					results.push(result.rows);
+				}
+				await tx.query('COMMIT');
+			} catch (error) {
+				await tx.query('ROLLBACK');
+				results.push(error as Error);
+			} finally {
+				tx.release();
+			}
+			return results;
+		};
+
+		const benchmarkQuery = async (
+			client: PgClient,
+			sql: string,
+			params?: any[],
+		): Promise<QueriesTimings['queries'][number]> => {
+			const explainResult = await pool.query({
+				text: `EXPLAIN ANALYZE ${sql}`,
+				values: params ?? [],
+				types,
+			});
+			const stringifiedResult = JSON.stringify(explainResult.rows);
+			const planningMatch = stringifiedResult.match(/Planning Time:\s*([\d.]+)\s*ms/i)!;
+			const executionMatch = stringifiedResult.match(/Execution Time:\s*([\d.]+)\s*ms/i)!;
+
+			let planningTime = Number(planningMatch[1]);
+			let executionTime = Number(executionMatch[1]);
+			let querySentAt: bigint = 0n;
+			let firstDataAt: bigint = 0n;
+			let lastDataAt: bigint = 0n;
+			let lastRowParsedAt: bigint = 0n;
+			let queryCompletedAt: bigint = 0n;
+			let bytesReceived = 0;
+			let rowCount = 0;
+			let parseTime = 0;
+			let lastParseTime = 0;
+
+			const rowDescriptionListener = (data: { length: number }) => {
+				if (firstDataAt === 0n) {
+					firstDataAt = process.hrtime.bigint();
+				}
+				bytesReceived += data.length;
+			};
+
+			const originalRowListener = client.connection.listeners('dataRow')[0] as (...args: any[]) => void;
+			const wrappedRowListener = (data: { length: number }) => {
+				rowCount += 1;
+				const start = process.hrtime.bigint();
+				lastDataAt = start;
+				originalRowListener.apply(client.connection, [data]);
+				const end = process.hrtime.bigint();
+				lastRowParsedAt = end;
+				lastParseTime = ms(start, end);
+				parseTime += lastParseTime;
+				bytesReceived += data.length;
+			};
+			client.connection.removeAllListeners('dataRow');
+			client.connection.addListener('dataRow', wrappedRowListener);
+
+			client.connection.prependListener('rowDescription', rowDescriptionListener);
+
+			querySentAt = process.hrtime.bigint();
+			await client.query({
+				text: sql,
+				values: params,
+				types,
+			});
+			queryCompletedAt = process.hrtime.bigint();
+
+			client.connection.removeListener('rowDescription', rowDescriptionListener);
+			client.connection.removeAllListeners('dataRow');
+			client.connection.addListener('dataRow', originalRowListener);
+
+			let querySentTime = ms(querySentAt, firstDataAt) - executionTime - planningTime;
+			if (querySentTime < 0) {
+				// Adjust planning and execution times proportionally to accommodate negative query sent time (10% for network)
+				const percent = 0.10;
+				const overflow = -querySentTime;
+				const keepForSent = overflow * percent;
+				const adjustedOverflow = overflow * (1 + percent);
+				const total = planningTime + executionTime;
+				const ratioPlanning = planningTime / total;
+				const ratioExecution = executionTime / total;
+				planningTime -= adjustedOverflow * ratioPlanning;
+				executionTime -= adjustedOverflow * ratioExecution;
+				querySentTime = keepForSent;
+			}
+
+			const networkLatencyBefore = querySentTime / 2;
+			const networkLatencyAfter = querySentTime / 2;
+			// Minus parse time divided by row count to remove last row parse time overlap
+			const downloadTime = ms(firstDataAt, lastDataAt) - (rowCount > 1 ? parseTime - lastParseTime : 0);
+			const total = ms(querySentAt, queryCompletedAt);
+			const calculatedTotal = networkLatencyBefore + planningTime + executionTime + networkLatencyAfter + downloadTime
+				+ parseTime + ms(lastRowParsedAt, queryCompletedAt);
+			const errorMargin = Math.abs(total - calculatedTotal);
+
+			return {
+				networkLatencyBefore,
+				planning: planningTime,
+				execution: executionTime,
+				networkLatencyAfter,
+				dataDownload: downloadTime,
+				dataParse: parseTime,
+				total,
+				errorMargin,
+				dataSize: bytesReceived,
+			};
+		};
+
+		const benchmarkProxy: BenchmarkProxy = async ({ sql, params }, repeats) => {
+			let startAt: bigint = 0n;
+			let tcpConnectedAt: bigint = 0n;
+			let tlsConnectedAt: bigint | null = null;
+			let dbReadyAt: bigint = 0n;
+
+			const client = 'url' in credentials
+				? new pg.Client({ connectionString: credentials.url })
+				: new pg.Client({ ...credentials, ssl });
+
+			client.connection.once('connect', () => {
+				tcpConnectedAt = process.hrtime.bigint();
+			});
+			client.connection.prependOnceListener('sslconnect', () => {
+				tlsConnectedAt = process.hrtime.bigint();
+			});
+			client.connection.prependOnceListener('readyForQuery', () => {
+				dbReadyAt = process.hrtime.bigint();
+			});
+
+			startAt = process.hrtime.bigint();
+			await client.connect();
+
+			const results = [];
+			for (let i = 0; i < repeats; i++) {
+				const r = await benchmarkQuery(client, sql, params);
+				results.push(r);
+			}
+			await client.end();
+
+			return {
+				tcpHandshake: ms(startAt, tcpConnectedAt),
+				tlsHandshake: tlsConnectedAt ? ms(tcpConnectedAt, tlsConnectedAt) : null,
+				dbHandshake: ms(tlsConnectedAt ?? tcpConnectedAt, dbReadyAt),
+				queries: results,
+			};
+		};
+
+		return { packageName: 'pg', query, proxy, transactionProxy, benchmarkProxy, migrate: migrateFn };
 	}
 
 	if (await checkPackage('postgres')) {
-		console.log(
+		humanLog(
 			withStyle.info(`Using 'postgres' driver for database querying`),
 		);
 		const postgres = await import('postgres');
@@ -237,31 +475,58 @@ export const preparePostgresDB = async (
 		client.options.serializers['114'] = transparentParser;
 		client.options.serializers['3802'] = transparentParser;
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
 
 		const query = async (sql: string, params?: any[]) => {
-			const result = await client.unsafe(sql, params ?? []);
+			const result = await client.unsafe(sql, params ?? []).catch((e) => {
+				throw new QueryError(e, sql, params || []);
+			});
 			return result as any[];
 		};
 
-		const proxy = async (params: ProxyParams) => {
-			if (params.mode === 'object') {
-				return await client.unsafe(params.sql, params.params);
+		const proxy: Proxy = async (params) => {
+			if (params.mode === 'array') {
+				return client.unsafe(params.sql, params.params).values().catch((e) => {
+					throw new QueryError(e, params.sql, params.params || []);
+				});
 			}
-			return await client.unsafe(params.sql, params.params).values();
+			return client.unsafe(params.sql, params.params).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
+			});
 		};
 
-		return { query, proxy, migrate: migrateFn };
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await client.begin(async (sql) => {
+					for (const query of queries) {
+						const result = await sql.unsafe(query.sql);
+						results.push(result);
+					}
+				});
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return {
+			packageName: 'postgres',
+			query,
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
 	}
 
 	if (await checkPackage('@vercel/postgres')) {
-		console.log(
+		humanLog(
 			withStyle.info(`Using '@vercel/postgres' driver for database querying`),
 		);
-		console.log(
+		humanLog(
 			withStyle.fullWarning(
 				"'@vercel/postgres' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket",
 			),
@@ -306,7 +571,7 @@ export const preparePostgresDB = async (
 
 		await client.connect();
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
@@ -316,35 +581,71 @@ export const preparePostgresDB = async (
 				text: sql,
 				values: params ?? [],
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, sql, params || []);
 			});
 			return result.rows;
 		};
 
-		const proxy: Proxy = async (params: ProxyParams) => {
+		const proxy: Proxy = async (params) => {
 			const result = await client.query({
 				text: params.sql,
 				values: params.params,
 				...(params.mode === 'array' && { rowMode: 'array' }),
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
 			});
 			return result.rows;
 		};
 
-		return { query, proxy, migrate: migrateFn };
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			const tx = await client.connect();
+			try {
+				await tx.query('BEGIN');
+				for (const query of queries) {
+					const result = await tx.query({
+						text: query.sql,
+						types,
+					});
+					results.push(result.rows);
+				}
+				await tx.query('COMMIT');
+			} catch (error) {
+				await tx.query('ROLLBACK');
+				results.push(error as Error);
+			} finally {
+				tx.release();
+			}
+			return results;
+		};
+
+		return {
+			packageName: '@vercel/postgres',
+			query,
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
 	}
 
 	if (await checkPackage('@neondatabase/serverless')) {
-		console.log(
+		humanLog(
 			withStyle.info(
 				`Using '@neondatabase/serverless' driver for database querying`,
 			),
 		);
-		console.log(
+		humanLog(
 			withStyle.fullWarning(
 				"'@neondatabase/serverless' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket",
 			),
 		);
-		const { Pool, neonConfig, types: pgTypes } = await import('@neondatabase/serverless');
+		const {
+			Pool,
+			neonConfig,
+			types: pgTypes,
+		} = await import('@neondatabase/serverless');
 		const { drizzle } = await import('drizzle-orm/neon-serverless');
 		const { migrate } = await import('drizzle-orm/neon-serverless/migrator');
 
@@ -384,7 +685,7 @@ export const preparePostgresDB = async (
 			: new Pool({ ...credentials, max: 1, ssl });
 		neonConfig.webSocketConstructor = ws;
 
-		const db = drizzle(client);
+		const db = drizzle({ client: client as any });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
@@ -394,6 +695,8 @@ export const preparePostgresDB = async (
 				text: sql,
 				values: params ?? [],
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, sql, params || []);
 			});
 			return result.rows;
 		};
@@ -404,83 +707,320 @@ export const preparePostgresDB = async (
 				values: params.params,
 				...(params.mode === 'array' && { rowMode: 'array' }),
 				types,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
 			});
 			return result.rows;
 		};
 
-		return { query, proxy, migrate: migrateFn };
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			const tx = await client.connect();
+			try {
+				await tx.query('BEGIN');
+				for (const query of queries) {
+					const result = await tx.query({
+						text: query.sql,
+						types,
+					});
+					results.push(result.rows);
+				}
+				await tx.query('COMMIT');
+			} catch (error) {
+				await tx.query('ROLLBACK');
+				results.push(error as Error);
+			} finally {
+				tx.release();
+			}
+			return results;
+		};
+
+		return {
+			packageName: '@neondatabase/serverless',
+			query,
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
+	}
+
+	if (await checkPackage('bun')) {
+		humanLog(withStyle.info(`Using 'bun' driver for database querying`));
+		const { SQL } = await import('bun');
+		const { drizzle } = await import('drizzle-orm/bun-sql/postgres');
+		const { migrate } = await import('drizzle-orm/bun-sql/postgres/migrator');
+
+		const ssl = 'ssl' in credentials
+			? credentials.ssl === 'prefer'
+					|| credentials.ssl === 'require'
+					|| credentials.ssl === 'allow'
+				? true
+				: false
+			: undefined;
+
+		const client = new SQL({
+			adapter: 'postgres',
+			...credentials,
+			ssl,
+			max: 1,
+		});
+		const db = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.unsafe(sql, params ?? []);
+			return result;
+		};
+
+		const proxy: Proxy = async (params) => {
+			const query = client.unsafe(params.sql, params.params);
+			if (params.mode === 'array') {
+				return await query.values();
+			}
+			return await query;
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await client.transaction(async (tx) => {
+					for (const query of queries) {
+						const result = await tx.unsafe(query.sql);
+						results.push(result);
+					}
+				});
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return { packageName: 'bun', query, proxy, transactionProxy, migrate: migrateFn };
 	}
 
-	console.error(
-		"To connect to Postgres database - please install either of 'pg', 'postgres', '@neondatabase/serverless' or '@vercel/postgres' drivers",
+	throw new DatabaseDriverCliError(
+		'postgresql',
+		['pg', 'postgres', 'bun', '@neondatabase/serverless', '@vercel/postgres'],
+		"To connect to Postgres database - please install either of 'pg', 'postgres', 'bun', '@neondatabase/serverless' or '@vercel/postgres' drivers\nFor the 'bun' driver, run your script using: bun --bun",
+		"For the 'bun' driver, run your script using: bun --bun",
 	);
-	process.exit(1);
 };
 
-export const prepareGelDB = async (
-	credentials?: GelCredentials,
+export const prepareDuckDb = async (
+	credentials: DuckDbCredentials,
 ): Promise<
 	DB & {
+		packageName: 'duckdb' | '@duckdb/node-api';
 		proxy: Proxy;
+		transactionProxy: TransactionProxy;
+		migrate: (config: string | MigrationConfig) => Promise<void>;
 	}
 > => {
-	if (await checkPackage('gel')) {
-		const gel = await import('gel');
+	// ! Cannot find module node_modules/duckdb/lib/duckdb-binding.js
+	// if (await checkPackage('duckdb')) {
+	// 	console.log(withStyle.info(`Using 'duckdb' driver for database querying`));
+	// 	const duckdb = await import('duckdb');
+
+	// 	const client = await new Promise<InstanceType<typeof duckdb.Database>>((resolve, reject) => {
+	// 		const db = new duckdb.Database(credentials.url, (err) => {
+	// 			if (err) {
+	// 				reject(err);
+	// 			}
+	// 			resolve(db);
+	// 		});
+	// 	});
+
+	// 	const query = async (sql: string, params: any[] = []) =>
+	// 		new Promise<any[]>((resolve, reject) => {
+	// 			client.all(sql, ...params, (err, rows) => {
+	// 				if (err) {
+	// 					reject(err);
+	// 				}
+	// 				resolve(rows);
+	// 			});
+	// 		});
+
+	// 	const proxy: Proxy = async (params) => {
+	// 		const rows = await query(params.sql, params.params);
+	// 		return params.mode === 'array'
+	// 			// not safe, but DuckDB does not support array mode
+	// 			? rows.map((row) => Object.values(row))
+	// 			: rows;
+	// 	};
+
+	// 	const transactionProxy: TransactionProxy = async (queries) => {
+	// 		const results: any[] = [];
+	// 		const tx = client.connect();
+	// 		try {
+	// 			tx.run('BEGIN');
+	// 			for (const query of queries) {
+	// 				const rows = await new Promise<any[]>((resolve, reject) => {
+	// 					client.all(query.sql, (err, rows) => {
+	// 						if (err) {
+	// 							reject(err);
+	// 						}
+	// 						resolve(rows);
+	// 					});
+	// 				});
+	// 				results.push(rows);
+	// 			}
+	// 			tx.run('COMMIT');
+	// 		} catch (error) {
+	// 			tx.run('ROLLBACK');
+	// 			results.push(error as Error);
+	// 		} finally {
+	// 			tx.close();
+	// 		}
+	// 		return results;
+	// 	};
+
+	// 	return {
+	// 		packageName: 'duckdb',
+	// 		query,
+	// 		proxy,
+	// 		transactionProxy,
+	// 		migrate: () => {
+	// 			throw new Error('DuckDB does not support migrations');
+	// 		},
+	// 	};
+	// }
+
+	if (await checkPackage('@duckdb/node-api')) {
+		humanLog(
+			withStyle.info(`Using '@duckdb/node-api' driver for database querying`),
+		);
+		const { DuckDBInstance } = await import('@duckdb/node-api');
+
+		const instance = await DuckDBInstance.create(credentials.url);
+		const client = await instance.connect();
+
+		const query = async (sql: string, params: any[] = []) => {
+			const result = await client.run(sql, params);
+			const rows = await result.getRowObjectsJson();
+			return rows as any[];
+		};
+
+		const proxy: Proxy = async (params) => {
+			const result = await client.run(params.sql, params.params);
+			return params.mode === 'array' ? await result.getRowsJson() : await result.getRowObjectsJson();
+		};
 
-		let client: any;
-		if (!credentials) {
-			client = gel.createClient();
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
 			try {
-				await client.querySQL(`select 1;`);
-			} catch (error: any) {
-				if (error instanceof gel.ClientConnectionError) {
-					console.error(
-						`It looks like you forgot to link the Gel project or provide the database credentials.
-To link your project, please refer https://docs.geldata.com/reference/cli/gel_instance/gel_instance_link, or add the dbCredentials to your configuration file.`,
-					);
-					process.exit(1);
+				await client.run('BEGIN');
+				for (const query of queries) {
+					const result = await client.run(query.sql);
+					results.push(await result.getRowObjectsJson());
 				}
-
-				throw error;
+				await client.run('COMMIT');
+			} catch (error) {
+				await client.run('ROLLBACK');
+				results.push(error as Error);
 			}
-		} else if ('url' in credentials) {
-			'tlsSecurity' in credentials
-				? client = gel.createClient({ dsn: credentials.url, tlsSecurity: credentials.tlsSecurity, concurrency: 1 })
-				: client = gel.createClient({ dsn: credentials.url, concurrency: 1 });
-		} else {
-			gel.createClient({ ...credentials, concurrency: 1 });
-		}
+			return results;
+		};
 
-		const query = async (sql: string, params?: any[]) => {
-			const result = params?.length ? await client.querySQL(sql, params) : await client.querySQL(sql);
-			return result as any[];
+		return {
+			packageName: '@duckdb/node-api',
+			query,
+			proxy,
+			transactionProxy,
+			migrate: () => {
+				throw new Error('DuckDB does not support migrations');
+			},
 		};
+	}
 
-		const proxy: Proxy = async (params: ProxyParams) => {
-			const { method, mode, params: sqlParams, sql, typings } = params;
+	throw new DatabaseDriverCliError(
+		'duckdb',
+		['@duckdb/node-api'],
+		"To connect to DuckDb database - please install '@duckdb/node-api' driver",
+	);
+};
 
-			let result: any[];
-			switch (mode) {
-				case 'array':
-					result = sqlParams.length
-						? await client.withSQLRowMode('array').querySQL(sql, sqlParams)
-						: await client.querySQL(sql);
-					break;
-				case 'object':
-					result = sqlParams.length ? await client.querySQL(sql, sqlParams) : await client.querySQL(sql);
-					break;
-			}
+export const prepareCockroach = async (
+	credentials: PostgresCredentials,
+): Promise<
+	DB & {
+		proxy: Proxy;
+		migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
+	}
+> => {
+	if (await checkPackage('pg')) {
+		const { default: pg } = await import('pg');
+		const { drizzle } = await import('drizzle-orm/cockroach');
+		const { migrate } = await import('drizzle-orm/cockroach/migrator');
 
-			return result;
+		const ssl = 'ssl' in credentials
+			? credentials.ssl === 'prefer'
+					|| credentials.ssl === 'require'
+					|| credentials.ssl === 'allow'
+				? { rejectUnauthorized: false }
+				: credentials.ssl === 'verify-full'
+				? {}
+				: credentials.ssl
+			: {};
+
+		// Override pg default date parsers
+		const types: { getTypeParser: typeof pg.types.getTypeParser } = {
+			// @ts-ignore
+			getTypeParser: (typeId, format) => {
+				if (typeId === pg.types.builtins.TIMESTAMPTZ) {
+					return (val: any) => val;
+				}
+				if (typeId === pg.types.builtins.TIMESTAMP) {
+					return (val: any) => val;
+				}
+				if (typeId === pg.types.builtins.DATE) {
+					return (val: any) => val;
+				}
+				if (typeId === pg.types.builtins.INTERVAL) {
+					return (val: any) => val;
+				}
+				// @ts-ignore
+				return pg.types.getTypeParser(typeId, format);
+			},
+		};
+
+		const client = 'url' in credentials
+			? new pg.Pool({ connectionString: credentials.url, max: 1 })
+			: new pg.Pool({ ...credentials, ssl, max: 1 });
+
+		const db = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.query({
+				text: sql,
+				values: params ?? [],
+				types,
+			}).catch((e) => {
+				throw new QueryError(e, sql, params || []);
+			});
+			return result.rows;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await client.query({
+				text: params.sql,
+				values: params.params,
+				...(params.mode === 'array' && { rowMode: 'array' }),
+				types,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
+			});
+			return result.rows;
 		};
 
-		return { query, proxy };
+		return { query, proxy, migrate: migrateFn };
 	}
 
-	console.error(
-		"To connect to gel database - please install 'edgedb' driver",
-	);
-	process.exit(1);
+	throw new DatabaseDriverCliError('cockroach', ['pg'], "To connect to Cockroach - please install 'pg' package");
 };
 
 const parseSingleStoreCredentials = (credentials: SingleStoreCredentials) => {
@@ -492,10 +1032,10 @@ const parseSingleStoreCredentials = (credentials: SingleStoreCredentials) => {
 
 		const database = pathname.split('/')[pathname.split('/').length - 1];
 		if (!database) {
-			console.error(
+			throw new ConnectionStringDatabaseCliError(
+				'singlestore',
 				'You should specify a database name in connection string (singlestore://USER:PASSWORD@HOST:PORT/DATABASE)',
 			);
-			process.exit(1);
 		}
 		return { database, url };
 	} else {
@@ -510,9 +1050,11 @@ export const connectToSingleStore = async (
 	it: SingleStoreCredentials,
 ): Promise<{
 	db: DB;
+	packageName: 'mysql2';
 	proxy: Proxy;
+	transactionProxy: TransactionProxy;
 	database: string;
-	migrate: (config: MigrationConfig) => Promise<void>;
+	migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
 }> => {
 	const result = parseSingleStoreCredentials(it);
 
@@ -525,7 +1067,7 @@ export const connectToSingleStore = async (
 			? await createConnection(result.url)
 			: await createConnection(result.credentials!); // needed for some reason!
 
-		const db = drizzle(connection);
+		const db = drizzle({ client: connection });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
@@ -548,18 +1090,37 @@ export const connectToSingleStore = async (
 			return result[0] as any[];
 		};
 
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await connection.beginTransaction();
+				for (const query of queries) {
+					const res = await connection.query(query.sql);
+					results.push(res[0]);
+				}
+				await connection.commit();
+			} catch (error) {
+				await connection.rollback();
+				results.push(error as Error);
+			}
+			return results;
+		};
+
 		return {
 			db: { query },
+			packageName: 'mysql2',
 			proxy,
+			transactionProxy,
 			database: result.database,
 			migrate: migrateFn,
 		};
 	}
 
-	console.error(
-		"To connect to SingleStore database - please install 'singlestore' driver",
+	throw new DatabaseDriverCliError(
+		'singlestore',
+		['mysql2'],
+		"To connect to SingleStore database - please install 'mysql2' driver",
 	);
-	process.exit(1);
 };
 
 const parseMysqlCredentials = (credentials: MysqlCredentials) => {
@@ -571,10 +1132,10 @@ const parseMysqlCredentials = (credentials: MysqlCredentials) => {
 
 		const database = pathname.split('/')[pathname.split('/').length - 1];
 		if (!database) {
-			console.error(
+			throw new ConnectionStringDatabaseCliError(
+				'mysql',
 				'You should specify a database name in connection string (mysql://USER:PASSWORD@HOST:PORT/DATABASE)',
 			);
-			process.exit(1);
 		}
 		return { database, url };
 	} else {
@@ -589,13 +1150,17 @@ export const connectToMySQL = async (
 	it: MysqlCredentials,
 ): Promise<{
 	db: DB;
+	packageName: 'mysql2' | '@planetscale/database' | 'bun';
 	proxy: Proxy;
+	transactionProxy: TransactionProxy;
+	benchmarkProxy?: BenchmarkProxy;
 	database: string;
-	migrate: (config: MigrationConfig) => Promise<void>;
+	migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
 }> => {
 	const result = parseMysqlCredentials(it);
 
 	if (await checkPackage('mysql2')) {
+		humanLog(withStyle.info(`Using 'mysql2' driver for database querying`));
 		const { createConnection } = await import('mysql2/promise');
 		const { drizzle } = await import('drizzle-orm/mysql2');
 		const { migrate } = await import('drizzle-orm/mysql2/migrator');
@@ -604,19 +1169,22 @@ export const connectToMySQL = async (
 			? await createConnection(result.url)
 			: await createConnection(result.credentials!); // needed for some reason!
 
-		const db = drizzle(connection);
+		const db = drizzle({ client: connection });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
 
 		const typeCast = (field: any, next: any) => {
-			if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+			if (
+				field.type === 'TIMESTAMP'
+				|| field.type === 'DATETIME'
+				|| field.type === 'DATE'
+			) {
 				return field.string();
 			}
 			return next();
 		};
 
-		await connection.connect();
 		const query: DB['query'] = async <T>(
 			sql: string,
 			params?: any[],
@@ -625,6 +1193,8 @@ export const connectToMySQL = async (
 				sql,
 				values: params,
 				typeCast,
+			}).catch((e) => {
+				throw new QueryError(e, sql, params || []);
 			});
 			return res[0] as any;
 		};
@@ -635,57 +1205,416 @@ export const connectToMySQL = async (
 				values: params.params,
 				rowsAsArray: params.mode === 'array',
 				typeCast,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
 			});
 			return result[0] as any[];
 		};
 
-		return {
-			db: { query },
-			proxy,
-			database: result.database,
-			migrate: migrateFn,
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await connection.beginTransaction();
+				for (const query of queries) {
+					const res = await connection.query({
+						sql: query.sql,
+						typeCast,
+					});
+					results.push(res[0]);
+				}
+				await connection.commit();
+			} catch (error) {
+				await connection.rollback();
+				results.push(error as Error);
+			}
+			return results;
 		};
-	}
 
-	if (await checkPackage('@planetscale/database')) {
-		const { Client } = await import('@planetscale/database');
-		const { drizzle } = await import('drizzle-orm/planetscale-serverless');
-		const { migrate } = await import(
-			'drizzle-orm/planetscale-serverless/migrator'
-		);
+		const benchmarkQuery = async (
+			newConnection: Connection,
+			sql: string,
+			params?: any[],
+		): Promise<QueriesTimings['queries'][number]> => {
+			const explainResult = await connection.query({
+				sql: `EXPLAIN ANALYZE ${sql}`,
+				values: params ?? [],
+				typeCast,
+			});
+			const stringifiedResult = JSON.stringify(explainResult[0]);
+			const timeMatch = stringifiedResult.match(
+				/actual time=([0-9.eE+-]+)\.\.([0-9.eE+-]+)/,
+			)!;
+			// const firstRowTime = Number(timeMatch[1]);
+			const lastRowTime = Number(timeMatch[2]);
+			let executionTime = lastRowTime;
+
+			let querySentAt: bigint = 0n;
+			let firstDataAt: bigint = 0n;
+			let lastDataAt: bigint = 0n;
+			let lastRowParsedAt: bigint = 0n;
+			let queryCompletedAt: bigint = 0n;
+			let bytesReceived = 0;
+			let rowCount = 0;
+			let parseTime = 0;
+			let lastParseTime = 0;
+
+			querySentAt = process.hrtime.bigint();
+			await new Promise<void>((resolve, reject) => {
+				const query = newConnection.query({
+					sql,
+					values: params ?? [],
+					typeCast,
+				}) as Query & {
+					row: (...args: any[]) => any;
+				};
+				const originalRowHandler = query.row;
+				let packets = 0;
+				const wrappedRowListener = (
+					packet: { buffer: Buffer; isEOF: () => {}; length: () => number; start: number },
+					connection: any,
+				) => {
+					packets += 1;
+					if (firstDataAt === 0n) {
+						firstDataAt = process.hrtime.bigint();
+						// First packet also contains some bytes before row data starts
+						bytesReceived += packet.start;
+					}
+					const start = process.hrtime.bigint();
+					lastDataAt = start;
+					const res = originalRowHandler.apply(query, [packet, connection]);
+					const end = process.hrtime.bigint();
+					lastRowParsedAt = end;
+					lastParseTime = ms(start, end);
+					parseTime += lastParseTime;
+					bytesReceived += packet.length();
+					if (!res || packet.isEOF()) {
+						return res;
+					}
+					return wrappedRowListener;
+				};
+				query.row = wrappedRowListener;
+
+				query.on('result', () => {
+					rowCount += 1;
+				});
+				query.on('error', (err) => {
+					reject(err);
+				});
+				query.on('end', () => {
+					resolve();
+				});
+			});
+			queryCompletedAt = process.hrtime.bigint();
+
+			let querySentTime = ms(querySentAt, firstDataAt) - executionTime;
+			if (querySentTime < 0) {
+				// Adjust planning and execution times proportionally to accommodate negative query sent time (10% for network)
+				const percent = 0.10;
+				const overflow = -querySentTime;
+				const keepForSent = overflow * percent;
+				const adjustedOverflow = overflow * (1 + percent);
+				const total = executionTime;
+				const ratioExecution = executionTime / total;
+				executionTime -= adjustedOverflow * ratioExecution;
+				querySentTime = keepForSent;
+			}
+
+			const networkLatencyBefore = querySentTime / 2;
+			const networkLatencyAfter = querySentTime / 2;
+			// Minus parse time divided by row count to remove last row parse time overlap
+			const downloadTime = ms(firstDataAt, lastDataAt) - (rowCount > 1 ? parseTime - lastParseTime : 0);
+			const total = ms(querySentAt, queryCompletedAt);
+			const calculatedTotal = networkLatencyBefore + executionTime + networkLatencyAfter + downloadTime
+				+ parseTime + ms(lastRowParsedAt, queryCompletedAt);
+			const errorMargin = Math.abs(total - calculatedTotal);
+
+			return {
+				networkLatencyBefore,
+				planning: null,
+				execution: executionTime,
+				networkLatencyAfter,
+				dataDownload: downloadTime,
+				dataParse: parseTime,
+				total,
+				errorMargin,
+				dataSize: bytesReceived,
+			};
+		};
+
+		const benchmarkProxy: BenchmarkProxy = async ({ sql, params }, repeats) => {
+			const { createConnection } = await import('mysql2');
+
+			let startAt: bigint = 0n;
+			let tcpConnectedAt: bigint = 0n;
+			let tlsConnectedAt: bigint | null = null;
+
+			const createStream = ({ config }: { config: ConnectionConfig }) => {
+				let stream: net.Socket;
+				if (config.socketPath) {
+					stream = net.connect(config.socketPath);
+				} else {
+					stream = net.connect(config.port!, config.host);
+				}
+				if (config.enableKeepAlive) {
+					stream.on('connect', () => {
+						stream.setKeepAlive(true, config.keepAliveInitialDelay);
+					});
+				}
+				stream.setNoDelay(true);
+				stream.once('connect', () => {
+					tcpConnectedAt = process.hrtime.bigint();
+				});
+				return stream;
+			};
+
+			startAt = process.hrtime.bigint();
+			const connection = result.url
+				? createConnection({
+					uri: result.url,
+					stream: createStream,
+				})
+				: createConnection({
+					...result.credentials!,
+					stream: createStream,
+				});
+			await new Promise<void>((resolve, reject) => {
+				connection.connect((err) => {
+					tlsConnectedAt = process.hrtime.bigint();
+					if (err) {
+						reject(err);
+					} else {
+						resolve();
+					}
+				});
+			});
+
+			const results = [];
+			for (let i = 0; i < repeats; i++) {
+				const r = await benchmarkQuery(connection, sql, params);
+				results.push(r);
+			}
+			connection.end();
+
+			return {
+				tcpHandshake: ms(startAt, tcpConnectedAt),
+				tlsHandshake: tlsConnectedAt ? ms(tcpConnectedAt, tlsConnectedAt) : null,
+				dbHandshake: null,
+				queries: results,
+			};
+		};
+
+		return {
+			db: { query },
+			packageName: 'mysql2',
+			proxy,
+			transactionProxy,
+			benchmarkProxy,
+			database: result.database,
+			migrate: migrateFn,
+		};
+	}
+
+	if (await checkPackage('@planetscale/database')) {
+		humanLog(withStyle.info(`Using '@planetscale/database' driver for database querying`));
+		const { Client } = await import('@planetscale/database');
+		const { drizzle } = await import('drizzle-orm/planetscale-serverless');
+		const { migrate } = await import(
+			'drizzle-orm/planetscale-serverless/migrator'
+		);
 
 		const connection = new Client(result);
 
-		const db = drizzle(connection);
+		const db = drizzle({ client: connection });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(db, config);
 		};
 
 		const query = async <T>(sql: string, params?: any[]): Promise<T[]> => {
-			const res = await connection.execute(sql, params);
+			const res = await connection.execute(sql, params).catch((e) => {
+				throw new QueryError(e, sql, params || []);
+			});
 			return res.rows as T[];
 		};
 		const proxy: Proxy = async (params: ProxyParams) => {
-			const result = params.mode === 'object'
-				? await connection.execute(params.sql, params.params)
-				: await connection.execute(params.sql, params.params, {
-					as: 'array',
-				});
+			const result = await connection.execute(
+				params.sql,
+				params.params,
+				params.mode === 'array' ? { as: 'array' } : undefined,
+			).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
+			});
 			return result.rows;
 		};
 
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await connection.transaction(async (tx) => {
+					for (const query of queries) {
+						const res = await tx.execute(query.sql);
+						results.push(res.rows);
+					}
+				});
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
 		return {
 			db: { query },
+			packageName: '@planetscale/database',
 			proxy,
+			transactionProxy,
 			database: result.database,
 			migrate: migrateFn,
 		};
 	}
 
-	console.error(
-		"To connect to MySQL database - please install either of 'mysql2' or '@planetscale/database' drivers",
+	if (await checkPackage('bun')) {
+		humanLog(withStyle.info(`Using 'bun' driver for database querying`));
+		const { SQL } = await import('bun');
+		const { drizzle } = await import('drizzle-orm/bun-sql/mysql');
+		const { migrate } = await import('drizzle-orm/bun-sql/mysql/migrator');
+
+		const ssl = result.credentials && 'ssl' in result.credentials
+			? result.credentials.ssl === 'prefer'
+					|| result.credentials.ssl === 'require'
+					|| result.credentials.ssl === 'allow'
+				? true
+				: false
+			: undefined;
+
+		const client = result.url
+			? new SQL(result.url)
+			: new SQL({
+				adapter: 'mysql',
+				...result.credentials,
+				ssl,
+			});
+
+		const db = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.unsafe(sql, params ?? []);
+			return result;
+		};
+
+		const proxy: Proxy = async (params) => {
+			const query = client.unsafe(params.sql, params.params);
+			if (params.mode === 'array') {
+				return await query.values();
+			}
+			return await query;
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await client.transaction(async (tx) => {
+					for (const query of queries) {
+						const result = await tx.unsafe(query.sql);
+						results.push(result);
+					}
+				});
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return {
+			packageName: 'bun',
+			db: { query },
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+			database: result.database,
+		};
+	}
+
+	throw new DatabaseDriverCliError(
+		'mysql',
+		['mysql2', 'bun', '@planetscale/database'],
+		"To connect to MySQL database - please install either of 'mysql2', 'bun' or '@planetscale/database' drivers\nFor the 'bun' driver, run your script using: bun --bun",
+		"For the 'bun' driver, run your script using: bun --bun",
 	);
-	process.exit(1);
+};
+
+function parseMssqlUrl(url: URL): config {
+	return {
+		user: url.username,
+		password: url.password,
+		server: url.hostname,
+		port: Number.parseInt(url.port, 10),
+		database: url.pathname.replace(/^\//, ''),
+		options: {
+			encrypt: url.searchParams.get('encrypt') === 'true',
+			trustServerCertificate: url.searchParams.get('trustServerCertificate') === 'true',
+		},
+	};
+}
+
+const parseMssqlCredentials = (credentials: MssqlCredentials) => {
+	if ('url' in credentials) {
+		try {
+			const url = new URL(credentials.url);
+			const parsedCredentials = parseMssqlUrl(url);
+			return {
+				database: parsedCredentials.database,
+				credentials: parsedCredentials,
+			};
+		} catch {
+			return { url: credentials.url };
+		}
+	} else {
+		return {
+			database: credentials.database,
+			credentials,
+		};
+	}
+};
+
+export const connectToMsSQL = async (
+	it: MssqlCredentials,
+): Promise<{
+	db: DB;
+	migrate: (config: MigrationConfig) => Promise<void | MigratorInitFailResponse>;
+}> => {
+	const result = parseMssqlCredentials(it);
+
+	if (await checkPackage('mssql')) {
+		const mssql = await import('mssql');
+		const { drizzle } = await import('drizzle-orm/node-mssql');
+		const { migrate } = await import('drizzle-orm/node-mssql/migrator');
+		const connection = result.url
+			? await mssql.default.connect(result.url)
+			: await mssql.default.connect(result.credentials!);
+
+		const db = drizzle({ client: connection });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query: DB['query'] = async <T>(
+			sql: string,
+		): Promise<T[]> => {
+			const res = await connection.query(sql).catch((e) => {
+				throw new QueryError(e, sql, []);
+			});
+			return res.recordset as any;
+		};
+
+		return {
+			db: { query },
+			migrate: migrateFn,
+		};
+	}
+
+	throw new DatabaseDriverCliError('mssql', ['mssql'], "To connect to MsSQL database - please install 'mssql' driver");
 };
 
 const prepareSqliteParams = (params: any[], driver?: string) => {
@@ -701,7 +1630,7 @@ const prepareSqliteParams = (params: any[], driver?: string) => {
 				? JSON.stringify(param.value)
 				: (param.value as string);
 
-			if (driver === 'd1-http') {
+			if (driver === 'd1-http' || driver === 'd1') {
 				return value;
 			}
 
@@ -730,12 +1659,102 @@ const preparePGliteParams = (params: any[]) => {
 	});
 };
 
+export type D1Credentials = {
+	driver: 'd1';
+	binding: D1Database;
+};
+
+export const connectToD1 = async (
+	d1: D1Database,
+): Promise<
+	& SQLiteDB
+	& {
+		packageName: 'd1';
+		migrate: (config: MigrationConfig) => Promise<void | MigratorInitFailResponse>;
+		proxy: Proxy;
+		transactionProxy: TransactionProxy;
+	}
+> => {
+	const db: SQLiteDB = {
+		query: async <T>(sql: string, params?: any[]) => {
+			const stmt = d1.prepare(sql);
+			const boundStmt = params && params.length > 0 ? stmt.bind(...params) : stmt;
+			const result = await boundStmt.all<T>();
+			return (result.results ?? []) as T[];
+		},
+		run: async (query: string) => {
+			const stmt = d1.prepare(query);
+			await stmt.run();
+		},
+		batch: async (statements: string[]) => {
+			await d1.batch(statements.map((s) => d1.prepare(s)));
+		},
+	};
+
+	const proxy: Proxy = async (params) => {
+		const preparedParams = prepareSqliteParams(params.params || [], 'd1');
+		const stmt = d1.prepare(params.sql);
+		const boundStmt = preparedParams.length > 0 ? stmt.bind(...preparedParams) : stmt;
+
+		try {
+			if (params.mode === 'array') {
+				return await boundStmt.raw();
+			}
+			const result = await boundStmt.all();
+			return result.results ?? [];
+		} catch (error: any) {
+			// D1 doesn't allow certain introspection queries (sqlite_master with pragma functions)
+			// Return empty array for SQLITE_AUTH errors on these system queries
+			if (error?.message?.includes('SQLITE_AUTH') || error?.message?.includes('not authorized')) {
+				return [];
+			}
+			throw error;
+		}
+	};
+
+	const transactionProxy: TransactionProxy = async (queries) => {
+		const results: any[] = [];
+		try {
+			// D1 doesn't support true transactions via binding, use batch instead
+			const statements = queries.map((q) => d1.prepare(q.sql));
+			const batchResults = await d1.batch(statements);
+			for (const result of batchResults) {
+				results.push(result.results ?? []);
+			}
+		} catch (error) {
+			results.push(error as Error);
+		}
+		return results;
+	};
+
+	const { drizzle } = await import('drizzle-orm/d1');
+	const { migrate } = await import('drizzle-orm/d1/migrator');
+	const drzl = drizzle(d1);
+	const migrateFn = async (config: MigrationConfig) => {
+		return migrate(drzl, config);
+	};
+
+	return { ...db, packageName: 'd1', proxy, transactionProxy, migrate: migrateFn };
+};
+
 export const connectToSQLite = async (
 	credentials: SqliteCredentials,
 ): Promise<
 	& SQLiteDB
-	& SqliteProxy
-	& { migrate: (config: MigrationConfig) => Promise<void> }
+	& {
+		packageName:
+			| 'd1-http'
+			| '@libsql/client'
+			| 'better-sqlite3'
+			| '@sqlitecloud/drivers'
+			| '@tursodatabase/database'
+			| '@tursodatabase/serverless'
+			| 'bun'
+			| 'node:sqlite';
+		migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
+		proxy: Proxy;
+		transactionProxy: TransactionProxy;
+	}
 > => {
 	if ('driver' in credentials) {
 		const { driver } = credentials;
@@ -743,6 +1762,23 @@ export const connectToSQLite = async (
 			const { drizzle } = await import('drizzle-orm/sqlite-proxy');
 			const { migrate } = await import('drizzle-orm/sqlite-proxy/migrator');
 
+			type D1Response =
+				| {
+					success: true;
+					result: {
+						results:
+							| any[]
+							| {
+								columns: string[];
+								rows: any[][];
+							};
+					}[];
+				}
+				| {
+					success: false;
+					errors: { code: number; message: string }[];
+				};
+
 			const remoteCallback: Parameters<typeof drizzle>[0] = async (
 				sql,
 				params,
@@ -760,24 +1796,47 @@ export const connectToSQLite = async (
 							Authorization: `Bearer ${credentials.token}`,
 						},
 					},
+				).catch((e) => {
+					throw new QueryError(e, sql, params || []);
+				});
+
+				const data = (await res.json()) as D1Response;
+
+				if (!data.success) {
+					throw new QueryError(
+						new Error(data.errors.map((it) => `${it.code}: ${it.message}`).join('\n')),
+						sql,
+						params || [],
+					);
+				}
+
+				const result = data.result[0].results;
+				const rows = Array.isArray(result) ? result : result.rows;
+
+				return {
+					rows,
+				};
+			};
+
+			const remoteBatchCallback = async (
+				queries: {
+					sql: string;
+				}[],
+			) => {
+				const sql = queries.map((q) => q.sql).join('; ');
+				const res = await fetch(
+					`https://api.cloudflare.com/client/v4/accounts/${credentials.accountId}/d1/database/${credentials.databaseId}/query`,
+					{
+						method: 'POST',
+						body: JSON.stringify({ sql }),
+						headers: {
+							'Content-Type': 'application/json',
+							Authorization: `Bearer ${credentials.token}`,
+						},
+					},
 				);
 
-				const data = (await res.json()) as
-					| {
-						success: true;
-						result: {
-							results:
-								| any[]
-								| {
-									columns: string[];
-									rows: any[][];
-								};
-						}[];
-					}
-					| {
-						success: false;
-						errors: { code: number; message: string }[];
-					};
+				const data = (await res.json()) as D1Response;
 
 				if (!data.success) {
 					throw new Error(
@@ -785,8 +1844,10 @@ export const connectToSQLite = async (
 					);
 				}
 
-				const result = data.result[0].results;
-				const rows = Array.isArray(result) ? result : result.rows;
+				const rows = data.result.map((result) => {
+					const res = result.results;
+					return Array.isArray(res) ? res : res.rows;
+				});
 
 				return {
 					rows,
@@ -798,42 +1859,154 @@ export const connectToSQLite = async (
 				return migrate(
 					drzl,
 					async (queries) => {
-						for (const query of queries) {
-							await remoteCallback(query, [], 'run');
+						// run migrations in transaction
+						if (queries.length > 0) {
+							await remoteBatchCallback(queries.map((sql) => ({ sql })));
 						}
 					},
 					config,
 				);
 			};
 
-			const db: SQLiteDB = {
-				query: async <T>(sql: string, params?: any[]) => {
-					const res = await remoteCallback(sql, params || [], 'all');
-					return res.rows as T[];
-				},
-				run: async (query: string) => {
-					await remoteCallback(query, [], 'run');
-				},
+			const query = async <T>(sql: string, params?: any[]) => {
+				const res = await remoteCallback(sql, params || [], 'all');
+				return res.rows as T[];
+			};
+			const run = async (query: string) => {
+				await remoteCallback(query, [], 'run');
+			};
+			const batch = async (queries: string[]) => {
+				await remoteBatchCallback(queries.map((sql) => ({ sql })));
 			};
-			const proxy: SqliteProxy = {
-				proxy: async (params: ProxyParams) => {
-					const preparedParams = prepareSqliteParams(params.params, 'd1-http');
-					const result = await remoteCallback(
-						params.sql,
-						preparedParams,
-						params.mode === 'array' ? 'values' : 'all',
-					);
 
-					return result.rows;
-				},
+			const proxy: Proxy = async (params) => {
+				const preparedParams = prepareSqliteParams(
+					params.params || [],
+					'd1-http',
+				);
+				const result = await remoteCallback(
+					params.sql,
+					preparedParams,
+					params.mode === 'array' ? 'values' : 'all',
+				);
+
+				return result.rows;
+			};
+			const transactionProxy: TransactionProxy = async (queries) => {
+				const result = await remoteBatchCallback(queries);
+				return result.rows;
+			};
+
+			return { query, run, batch, packageName: 'd1-http', proxy, transactionProxy, migrate: migrateFn };
+		} else if (driver === 'sqlite-cloud') {
+			assertPackages('@sqlitecloud/drivers');
+			const { Database } = await import('@sqlitecloud/drivers');
+			const { drizzle } = await import('drizzle-orm/sqlite-cloud');
+			const { migrate } = await import('drizzle-orm/sqlite-cloud/migrator');
+
+			const client = new Database(credentials.url);
+			const drzl = drizzle({ client });
+			const migrateFn = async (config: MigrationConfig) => {
+				return migrate(drzl, config);
+			};
+
+			const query = async <T>(sql: string, params?: any[]) => {
+				const stmt = client.prepare(sql).bind(params || []);
+				return await new Promise<T[]>((resolve, reject) => {
+					stmt.all((e: Error | null, d: SQLiteCloudRowset) => {
+						if (e) return reject(e);
+
+						return resolve(d.map((v) => Object.fromEntries(Object.entries(v))));
+					});
+				});
+			};
+			const run = async (query: string) => {
+				return await new Promise<void>((resolve, reject) => {
+					client.exec(query, (e: Error | null) => {
+						if (e) return reject(e);
+						return resolve();
+					});
+				});
+			};
+			const batch = async (queries: string[]) => {
+				for (const query of queries) {
+					await new Promise<void>((resolve, reject) => {
+						client.exec(query, (e: Error | null) => {
+							if (e) return reject(e);
+							return resolve();
+						});
+					});
+				}
+			};
+
+			const proxy = async (params: ProxyParams) => {
+				const preparedParams = prepareSqliteParams(params.params || []);
+				const stmt = client.prepare(params.sql).bind(preparedParams);
+				return await new Promise<any[]>((resolve, reject) => {
+					stmt.all((e: Error | null, d: SQLiteCloudRowset | undefined) => {
+						if (e) return reject(e);
+
+						if (params.mode === 'array') {
+							return resolve((d || []).map((v) => v.getData()));
+						} else {
+							return resolve((d || []).map((v) => Object.fromEntries(Object.entries(v))));
+						}
+					});
+				});
+			};
+
+			const transactionProxy: TransactionProxy = async (queries) => {
+				const results: (any[] | Error)[] = [];
+				try {
+					await new Promise<void>((resolve, reject) => {
+						client.exec('BEGIN', (e: Error | null) => {
+							if (e) return reject(e);
+							return resolve();
+						});
+					});
+					for (const query of queries) {
+						const result = await new Promise<any[]>((resolve, reject) => {
+							client.all(query.sql, (e: Error | null, d: SQLiteCloudRowset | undefined) => {
+								if (e) return reject(e);
+								return resolve((d || []).map((v) => Object.fromEntries(Object.entries(v))));
+							});
+						});
+						results.push(result);
+					}
+					await new Promise<void>((resolve, reject) => {
+						client.exec('COMMIT', (e: Error | null) => {
+							if (e) return reject(e);
+							return resolve();
+						});
+					});
+				} catch (error) {
+					results.push(error as Error);
+					await new Promise<void>((resolve, reject) => {
+						client.exec('ROLLBACK', (e: Error | null) => {
+							if (e) return reject(e);
+							return resolve();
+						});
+					});
+				}
+				return results;
+			};
+
+			return {
+				query,
+				run,
+				batch,
+				packageName: '@sqlitecloud/drivers',
+				proxy,
+				transactionProxy,
+				migrate: migrateFn,
 			};
-			return { ...db, ...proxy, migrate: migrateFn };
 		} else {
 			assertUnreachable(driver);
 		}
 	}
 
 	if (await checkPackage('@libsql/client')) {
+		humanLog(withStyle.info(`Using '@libsql/client' driver for database querying`));
 		const { createClient } = await import('@libsql/client');
 		const { drizzle } = await import('drizzle-orm/libsql');
 		const { migrate } = await import('drizzle-orm/libsql/migrator');
@@ -841,41 +2014,189 @@ export const connectToSQLite = async (
 		const client = createClient({
 			url: normaliseSQLiteUrl(credentials.url, 'libsql'),
 		});
-		const drzl = drizzle(client);
+		const drzl = drizzle({ client });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(drzl, config);
 		};
 
-		const db: SQLiteDB = {
-			query: async <T>(sql: string, params?: any[]) => {
-				const res = await client.execute({ sql, args: params || [] });
-				return res.rows as T[];
-			},
+		const query = async <T>(sql: string, params?: any[]) => {
+			const res = await client.execute({ sql, args: params || [] });
+			return res.rows as T[];
+		};
+		const run = async (query: string) => {
+			await client.execute(query);
+		};
+		const batch = async (queries: string[]) => {
+			await client.migrate(queries);
+		};
+
+		type Transaction = Awaited<ReturnType<typeof client.transaction>>;
+
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			const result = await client.execute({
+				sql: params.sql,
+				args: preparedParams,
+			}).catch((e) => {
+				throw new QueryError(e, params.sql, params.params || []);
+			});
+
+			if (params.mode === 'array') {
+				return result.rows.map((row) => Object.values(row));
+			} else {
+				return result.rows;
+			}
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			let transaction: Transaction | null = null;
+			try {
+				transaction = await client.transaction();
+				for (const query of queries) {
+					const result = await transaction.execute(query.sql);
+					results.push(result.rows);
+				}
+				await transaction.commit();
+			} catch (error) {
+				results.push(error as Error);
+				await transaction?.rollback();
+			} finally {
+				transaction?.close();
+			}
+			return results;
+		};
+
+		return { query, run, batch, packageName: '@libsql/client', proxy, transactionProxy, migrate: migrateFn };
+	}
+
+	if (await checkPackage('@tursodatabase/database')) {
+		humanLog(withStyle.info(`Using '@tursodatabase/database' driver for database querying`));
+		const { Database } = await import('@tursodatabase/database');
+		const { drizzle } = await import('drizzle-orm/tursodatabase/database');
+		const { migrate } = await import('drizzle-orm/tursodatabase/migrator');
+
+		const client = new Database(normaliseSQLiteUrl(credentials.url, '@tursodatabase/database'));
+		const drzl = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]) => {
+			const res = await client.all(sql, ...prepareSqliteParams(params || []));
+			return res as T[];
+		};
+		const batch = async (queries: string[]) => {
+			await client.transaction(async () => {
+				for (const query of queries) {
+					await client.run(query);
+				}
+			})();
+		};
+
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			if (params.mode === 'array') {
+				// Do not use .prepare(query).then() - https://github.com/tursodatabase/turso/issues/6732
+				const stmt = await client.prepare(params.sql);
+				return stmt.raw(true).all(...preparedParams);
+			}
+			return client.all(params.sql, ...preparedParams);
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			try {
+				const tx = client.transaction(async () => {
+					for (const query of queries) {
+						const result = await client.all(query.sql);
+						results.push(result);
+					}
+				});
+				await tx();
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return {
+			query,
+			batch,
+			packageName: '@tursodatabase/database',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
 			run: async (query: string) => {
-				await client.execute(query);
+				await client.exec(query).catch((e) => {
+					throw new QueryError(e, query, []);
+				});
 			},
 		};
+	}
+
+	if (await checkPackage('@tursodatabase/serverless')) {
+		humanLog(withStyle.info(`Using '@tursodatabase/serverless' driver for database querying`));
+		const { connect } = await import('@tursodatabase/serverless');
+		const { drizzle } = await import('drizzle-orm/tursodatabase-serverless');
+		const { migrate } = await import('drizzle-orm/tursodatabase-serverless/migrator');
+
+		const client = connect({ url: normaliseSQLiteUrl(credentials.url, 'libsql') });
+		const drzl = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]) => {
+			const res = await client.all(sql, ...prepareSqliteParams(params || []));
+			return res as T[];
+		};
+		const batch = async (queries: string[]) => {
+			await client.batch(queries);
+		};
 
-		const proxy: SqliteProxy = {
-			proxy: async (params: ProxyParams) => {
-				const preparedParams = prepareSqliteParams(params.params);
-				const result = await client.execute({
-					sql: params.sql,
-					args: preparedParams,
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			if (params.mode === 'array') {
+				const stmt = await client.prepare(params.sql);
+				return stmt.raw(true).all(preparedParams);
+			}
+			return client.all(params.sql, ...preparedParams);
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			try {
+				const tx = client.transaction(async () => {
+					for (const query of queries) {
+						const result = await client.all(query.sql);
+						results.push(result);
+					}
 				});
+				await tx();
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
 
-				if (params.mode === 'array') {
-					return result.rows.map((row) => Object.values(row));
-				} else {
-					return result.rows;
-				}
+		return {
+			query,
+			batch,
+			packageName: '@tursodatabase/serverless',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+			run: async (query: string) => {
+				await client.exec(query).catch((e) => {
+					throw new QueryError(e, query, []);
+				});
 			},
 		};
-
-		return { ...db, ...proxy, migrate: migrateFn };
 	}
 
 	if (await checkPackage('better-sqlite3')) {
+		humanLog(withStyle.info(`Using 'better-sqlite3' driver for database querying`));
 		const { default: Database } = await import('better-sqlite3');
 		const { drizzle } = await import('drizzle-orm/better-sqlite3');
 		const { migrate } = await import('drizzle-orm/better-sqlite3/migrator');
@@ -883,7 +2204,7 @@ export const connectToSQLite = async (
 		const sqlite = new Database(
 			normaliseSQLiteUrl(credentials.url, 'better-sqlite'),
 		);
-		const drzl = drizzle(sqlite);
+		const drzl = drizzle({ client: sqlite });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(drzl, config);
 		};
@@ -895,40 +2216,237 @@ export const connectToSQLite = async (
 			run: async (query: string) => {
 				sqlite.prepare(query).run();
 			},
+			batch: async (queries: string[]) => {
+				for (const query of queries) {
+					sqlite.prepare(query).run();
+				}
+			},
+		};
+
+		const proxy: Proxy = async (params) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			if (
+				params.method === 'values'
+				|| params.method === 'get'
+				|| params.method === 'all'
+			) {
+				return sqlite
+					.prepare(params.sql)
+					.raw(params.mode === 'array')
+					.all(preparedParams);
+			}
+
+			sqlite.prepare(params.sql).run(preparedParams);
+
+			return [];
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+
+			const tx = sqlite.transaction(
+				(queries: Parameters<TransactionProxy>[0]) => {
+					for (const query of queries) {
+						let result: any[] = [];
+						if (
+							query.method === 'values'
+							|| query.method === 'get'
+							|| query.method === 'all'
+						) {
+							result = sqlite.prepare(query.sql).all();
+						} else {
+							sqlite.prepare(query.sql).run();
+						}
+						results.push(result);
+					}
+				},
+			);
+
+			try {
+				tx(queries);
+			} catch (error) {
+				results.push(error as Error);
+			}
+
+			return results;
+		};
+
+		return {
+			query: db.query,
+			run: db.run,
+			batch: db.batch,
+			packageName: 'better-sqlite3',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
+	}
+
+	if (await checkPackage('bun')) {
+		humanLog(withStyle.info(`Using 'bun' driver for database querying`));
+		const { SQL } = await import('bun');
+		const { drizzle } = await import('drizzle-orm/bun-sql/sqlite');
+		const { migrate } = await import('drizzle-orm/bun-sql/sqlite/migrator');
+
+		const client = new SQL({
+			adapter: 'sqlite',
+			filename: normaliseSQLiteUrl(credentials.url, 'bun'),
+		});
+
+		const db = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.unsafe(sql, params ?? []);
+			return result;
+		};
+		const run = async (sql: string) => {
+			await client.unsafe(sql);
+		};
+		const batch = async (queries: string[]) => {
+			for (const query of queries) {
+				await client.unsafe(query);
+			}
+		};
+
+		const proxy: Proxy = async (params) => {
+			const query = client.unsafe(params.sql, params.params);
+			if (params.mode === 'array') {
+				return await query.values();
+			}
+			return await query;
 		};
 
-		const proxy: SqliteProxy = {
-			proxy: async (params: ProxyParams) => {
-				const preparedParams = prepareSqliteParams(params.params);
-				if (
-					params.method === 'values'
-					|| params.method === 'get'
-					|| params.method === 'all'
-				) {
-					return sqlite
-						.prepare(params.sql)
-						.raw(params.mode === 'array')
-						.all(preparedParams);
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: any[] = [];
+			try {
+				await client.transaction(async (tx) => {
+					for (const query of queries) {
+						const result = await tx.unsafe(query.sql);
+						results.push(result);
+					}
+				});
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return {
+			packageName: 'bun',
+			query,
+			run,
+			batch,
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
+	}
+
+	if (await checkPackage('node:sqlite')) {
+		humanLog(withStyle.info(`Using 'node:sqlite' driver for database querying`));
+		const { DatabaseSync } = await import('node:sqlite');
+		const { drizzle } = await import('drizzle-orm/node-sqlite');
+		const { migrate } = await import('drizzle-orm/node-sqlite/migrator');
+
+		const client = new DatabaseSync(credentials.url);
+
+		const db = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]) => {
+			const result = client.prepare(sql).all(...(params || []));
+			return result as T[];
+		};
+		const run = async (sql: string) => {
+			client.prepare(sql).run();
+		};
+		const batch = async (queries: string[]) => {
+			for (const query of queries) {
+				client.prepare(query).run();
+			}
+		};
+
+		const proxy: Proxy = async (params) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+
+			const stmt = client.prepare(params.sql);
+			if (
+				params.method === 'values'
+				|| params.method === 'get'
+				|| params.method === 'all'
+			) {
+				stmt.setReturnArrays(params.mode === 'array');
+				return stmt.all(...preparedParams);
+			}
+
+			stmt.run(...preparedParams);
+
+			return [];
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+
+			try {
+				client.prepare('BEGIN').run();
+
+				for (const query of queries) {
+					const stmt = client.prepare(query.sql);
+					if (
+						query.method === 'values'
+						|| query.method === 'get'
+						|| query.method === 'all'
+					) {
+						const res = stmt.all();
+						results.push(res);
+					} else {
+						stmt.run();
+					}
 				}
+				client.prepare('COMMIT').run();
+			} catch (error: any) {
+				client.prepare('ROLLBACK').run();
+				results.push(error as Error);
+			}
 
-				return sqlite.prepare(params.sql).run(preparedParams);
-			},
+			return results;
+		};
+
+		return {
+			packageName: 'node:sqlite',
+			query,
+			run,
+			batch,
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
 		};
-		return { ...db, ...proxy, migrate: migrateFn };
 	}
 
-	console.log(
-		"Please install either 'better-sqlite3' or '@libsql/client' for Drizzle Kit to connect to SQLite databases",
+	throw new DatabaseDriverCliError(
+		'sqlite',
+		['better-sqlite3', 'bun', '@libsql/client', '@tursodatabase/database', 'node:sqlite'],
+		"Please install either 'better-sqlite3', 'bun', '@libsql/client' or '@tursodatabase/database' for Drizzle Kit to connect to SQLite databases\nTo use 'node:sqlite' driver, ensure you're running Node.js v22.5.0 or higher\nFor the 'bun' driver, run your script using: bun --bun",
+		"To use 'node:sqlite' driver, ensure you're running Node.js v22.5.0 or higher",
 	);
-	process.exit(1);
 };
 
-export const connectToLibSQL = async (credentials: LibSQLCredentials): Promise<
-	& LibSQLDB
-	& SqliteProxy
-	& { migrate: (config: MigrationConfig) => Promise<void> }
+export const connectToTursoRemote = async (
+	credentials: LibSQLCredentials,
+): Promise<
+	LibSQLDB & {
+		packageName: '@libsql/client' | '@tursodatabase/serverless' | '@tursodatabase/database';
+		migrate: (config: string | MigrationConfig) => Promise<void | MigratorInitFailResponse>;
+		proxy: Proxy;
+		transactionProxy: TransactionProxy;
+	}
 > => {
-	if (await checkPackage('@libsql/client')) {
+	if ((await checkPackage('@libsql/client'))) {
 		const { createClient } = await import('@libsql/client');
 		const { drizzle } = await import('drizzle-orm/libsql');
 		const { migrate } = await import('drizzle-orm/libsql/migrator');
@@ -937,45 +2455,217 @@ export const connectToLibSQL = async (credentials: LibSQLCredentials): Promise<
 			url: normaliseSQLiteUrl(credentials.url, 'libsql'),
 			authToken: credentials.authToken,
 		});
-		const drzl = drizzle(client);
+		const drzl = drizzle({ client });
 		const migrateFn = async (config: MigrationConfig) => {
 			return migrate(drzl, config);
 		};
 
 		const db: LibSQLDB = {
 			query: async <T>(sql: string, params?: any[]) => {
-				const res = await client.execute({ sql, args: params || [] });
+				const res = await client.execute({ sql, args: params || [] }).catch((e) => {
+					throw new QueryError(e, sql, params || []);
+				});
 				return res.rows as T[];
 			},
 			run: async (query: string) => {
-				await client.execute(query);
+				await client.execute(query).catch((e) => {
+					throw new QueryError(e, query, []);
+				});
 			},
-			batchWithPragma: async (queries: string[]) => {
+			batch: async (queries: string[]) => {
 				await client.migrate(queries);
 			},
 		};
 
-		const proxy: SqliteProxy = {
-			proxy: async (params: ProxyParams) => {
-				const preparedParams = prepareSqliteParams(params.params);
-				const result = await client.execute({
-					sql: params.sql,
-					args: preparedParams,
-				});
+		type Transaction = Awaited<ReturnType<typeof client.transaction>>;
 
-				if (params.mode === 'array') {
-					return result.rows.map((row) => Object.values(row));
-				} else {
-					return result.rows;
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			const result = await client.execute({
+				sql: params.sql,
+				args: preparedParams,
+			});
+
+			if (params.mode === 'array') {
+				return result.rows.map((row) => Object.values(row));
+			} else {
+				return result.rows;
+			}
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			let transaction: Transaction | null = null;
+			try {
+				transaction = await client.transaction();
+				for (const query of queries) {
+					const result = await transaction.execute(query.sql);
+					results.push(result.rows);
 				}
+				await transaction.commit();
+			} catch (error) {
+				results.push(error as Error);
+				await transaction?.rollback();
+			} finally {
+				transaction?.close();
+			}
+			return results;
+		};
+
+		return {
+			query: db.query,
+			run: db.run,
+			batch: db.batch,
+			packageName: '@libsql/client',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+		};
+	}
+
+	if (
+		await checkPackage('@tursodatabase/serverless') && !(
+			// Prefer dedicated local driver for local databases
+			credentials.authToken === undefined && await checkPackage('@tursodatabase/database')
+		)
+	) {
+		humanLog(withStyle.info(`Using '@tursodatabase/serverless' driver for database querying`));
+		const { connect } = await import('@tursodatabase/serverless');
+		const { drizzle } = await import('drizzle-orm/tursodatabase-serverless');
+		const { migrate } = await import('drizzle-orm/tursodatabase-serverless/migrator');
+
+		const client = connect({ url: normaliseSQLiteUrl(credentials.url, 'libsql'), authToken: credentials.authToken });
+		const drzl = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]) => {
+			const res = await client.all(sql, ...prepareSqliteParams(params || []));
+			return res as T[];
+		};
+		const batch = async (queries: string[]) => {
+			await client.batch(queries);
+		};
+
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			if (params.mode === 'array') {
+				const stmt = await client.prepare(params.sql);
+				return stmt.raw(true).all(preparedParams);
+			}
+			return client.all(params.sql, ...preparedParams);
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			try {
+				const tx = client.transaction(async () => {
+					for (const query of queries) {
+						const result = await client.all(query.sql);
+						results.push(result);
+					}
+				});
+				await tx();
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
+
+		return {
+			query,
+			batch,
+			packageName: '@tursodatabase/serverless',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+			run: async (query: string) => {
+				await client.exec(query).catch((e) => {
+					throw new QueryError(e, query, []);
+				});
 			},
 		};
+	}
+
+	if (await checkPackage('@tursodatabase/database')) {
+		if (credentials.authToken !== undefined) {
+			throw new DatabaseDriverCliError(
+				'turso',
+				['@libsql/client', '@tursodatabase/serverless'],
+				`Unable to use '@tursodatabase/database' with remote turso database\nPlease install '@libsql/client' or '@tursodatabase/serverless' for Drizzle Kit to connect to remote turso databases`,
+			);
+		}
+
+		humanLog(withStyle.info(`Using '@tursodatabase/database' driver for database querying`));
+		const { Database } = await import('@tursodatabase/database');
+		const { drizzle } = await import('drizzle-orm/tursodatabase/database');
+		const { migrate } = await import('drizzle-orm/tursodatabase/migrator');
+
+		const client = new Database(normaliseSQLiteUrl(credentials.url, '@tursodatabase/database'));
+		const drzl = drizzle({ client });
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]) => {
+			const res = await client.all(sql, ...prepareSqliteParams(params || []));
+			return res as T[];
+		};
+		const batch = async (queries: string[]) => {
+			await client.transaction(async () => {
+				for (const query of queries) {
+					await client.run(query);
+				}
+			})();
+		};
+
+		const proxy = async (params: ProxyParams) => {
+			const preparedParams = prepareSqliteParams(params.params || []);
+			if (params.mode === 'array') {
+				// Do not use .prepare(query).then() - https://github.com/tursodatabase/turso/issues/6732
+				const stmt = await client.prepare(params.sql);
+				return stmt.raw(true).all(...preparedParams);
+			}
+			return client.all(params.sql, ...preparedParams);
+		};
+
+		const transactionProxy: TransactionProxy = async (queries) => {
+			const results: (any[] | Error)[] = [];
+			try {
+				const tx = client.transaction(async () => {
+					for (const query of queries) {
+						const result = await client.all(query.sql);
+						results.push(result);
+					}
+				});
+				await tx();
+			} catch (error) {
+				results.push(error as Error);
+			}
+			return results;
+		};
 
-		return { ...db, ...proxy, migrate: migrateFn };
+		return {
+			query,
+			batch,
+			packageName: '@tursodatabase/database',
+			proxy,
+			transactionProxy,
+			migrate: migrateFn,
+			run: async (query: string) => {
+				await client.exec(query).catch((e) => {
+					throw new QueryError(e, query, []);
+				});
+			},
+		};
 	}
 
-	console.log(
-		"Please install '@libsql/client' for Drizzle Kit to connect to LibSQL databases",
+	throw new DatabaseDriverCliError(
+		'turso',
+		['@libsql/client', '@tursodatabase/database', '@tursodatabase/serverless'],
+		typeof credentials.authToken === 'string'
+			? `Please install '@libsql/client' or '@tursodatabase/serverless' for Drizzle Kit to connect to remote turso databases`
+			: `Please install '@libsql/client', '@tursodatabase/database' or '@tursodatabase/serverless' for Drizzle Kit to connect to turso databases`,
 	);
-	process.exit(1);
 };
diff --git a/drizzle-kit/src/cli/context.ts b/drizzle-kit/src/cli/context.ts
new file mode 100644
index 0000000000..4500ac27b5
--- /dev/null
+++ b/drizzle-kit/src/cli/context.ts
@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export type CliContext = {
+	output: 'text' | 'json';
+	interactive: boolean;
+};
+
+const cliContext = new AsyncLocalStorage<CliContext>();
+
+export const runWithCliContext = <T>(context: CliContext, callback: () => T): T => {
+	return cliContext.run(context, callback);
+};
+
+export const getCliContext = (): CliContext => {
+	return cliContext.getStore() ?? { output: 'text', interactive: false };
+};
+
+export const outputFormat = (): 'text' | 'json' => {
+	return getCliContext().output;
+};
+
+export const isInteractive = (): boolean => {
+	return getCliContext().interactive;
+};
+
+/** Mutates the active AsyncLocalStorage frame in place; must be called from inside an existing `runWithCliContext` frame (e.g. from a brocli `transform` hook). Does NOT create a new frame. */
+export const setCliContext = (context: CliContext): void => {
+	cliContext.enterWith(context);
+};
diff --git a/drizzle-kit/src/cli/contract.ts b/drizzle-kit/src/cli/contract.ts
new file mode 100644
index 0000000000..af46ca85eb
--- /dev/null
+++ b/drizzle-kit/src/cli/contract.ts
@@ -0,0 +1,43 @@
+import type { GenericBuilderInternals, Simplify } from '@drizzle-team/brocli';
+import type { Dialect } from '../utils/schemaValidator';
+import type { Hint } from './hints';
+import type { checkOptions, exportOptions, generateOptions, pullOptions, pushOptions, upOptions } from './schema';
+
+type BrocliInputOf<TOptions extends Record<string, GenericBuilderInternals>> = Simplify<
+	{
+		[K in keyof TOptions]?: TOptions[K]['_']['$output'] | undefined;
+	}
+>;
+
+export type GenerateOptionsInput = BrocliInputOf<typeof generateOptions> & { dialect?: Dialect };
+export type PushOptionsInput = BrocliInputOf<typeof pushOptions> & { dialect?: Dialect };
+
+/**
+ * Public SDK option type; the `output` flag is omitted because the SDK always
+ * runs in JSON mode internally and never accepts a caller-supplied output mode.
+ * `hints` is a raw `Hint[]`, whereas the CLI `--hints` flag takes a JSON string.
+ */
+export type GenerateOptions = Omit<GenerateOptionsInput, 'output' | 'hints'> & { hints?: Hint[] };
+
+/**
+ * Public SDK option type; the `output` flag is omitted because the SDK always
+ * runs in JSON mode internally and never accepts a caller-supplied output mode.
+ * `hints` is a raw `Hint[]`, whereas the CLI `--hints` flag takes a JSON string.
+ */
+export type PushOptions = Omit<PushOptionsInput, 'output' | 'hints'> & { hints?: Hint[] };
+
+export type CheckOptionsInput = BrocliInputOf<typeof checkOptions> & { dialect?: Dialect };
+
+export type CheckOptions = Omit<CheckOptionsInput, 'output'>;
+
+export type ExportOptionsInput = BrocliInputOf<typeof exportOptions> & { dialect?: Dialect };
+
+export type ExportOptions = Omit<ExportOptionsInput, 'output'>;
+
+export type UpOptionsInput = BrocliInputOf<typeof upOptions> & { dialect?: Dialect };
+
+export type UpOptions = Omit<UpOptionsInput, 'output'>;
+
+export type PullOptionsInput = BrocliInputOf<typeof pullOptions> & { dialect?: Dialect };
+
+export type PullOptions = Omit<PullOptionsInput, 'output'>;
diff --git a/drizzle-kit/src/cli/dotenv-quiet.ts b/drizzle-kit/src/cli/dotenv-quiet.ts
new file mode 100644
index 0000000000..565bace20c
--- /dev/null
+++ b/drizzle-kit/src/cli/dotenv-quiet.ts
@@ -0,0 +1,8 @@
+// Imported before `dotenv/config` so it runs first. Under `mcp`, stdout must carry only
+// JSON-RPC frames, but dotenv logs the "injecting env" / debug lines to stdout when
+// DOTENV_CONFIG_QUIET is false or DOTENV_CONFIG_DEBUG is set in the environment. Force both
+// off for the server process while leaving every other DOTENV_CONFIG_* option intact.
+if (process.argv.includes('mcp')) {
+	process.env.DOTENV_CONFIG_QUIET = 'true';
+	delete process.env.DOTENV_CONFIG_DEBUG;
+}
diff --git a/drizzle-kit/src/cli/errors.ts b/drizzle-kit/src/cli/errors.ts
new file mode 100644
index 0000000000..b62c208e26
--- /dev/null
+++ b/drizzle-kit/src/cli/errors.ts
@@ -0,0 +1,276 @@
+import { QueryError } from './utils';
+import { error, errText, info } from './views';
+
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+export type DrizzleCliErrorMeta = Record<string, JsonValue>;
+
+export class DrizzleCliError extends Error {
+	readonly code: string;
+	readonly meta?: DrizzleCliErrorMeta;
+	readonly humanMessage: string;
+
+	constructor(code: string, humanMessage: string, meta?: DrizzleCliErrorMeta, options?: ErrorOptions) {
+		super(humanMessage, options);
+		this.name = new.target.name;
+		this.code = code;
+		this.meta = meta;
+		this.humanMessage = humanMessage;
+	}
+}
+
+export class OrmVersionCliError extends DrizzleCliError {
+	constructor(humanMessage: string, kind: 'orm_missing' | 'orm_too_old' | 'kit_outdated') {
+		super('orm_version_error', humanMessage, { kind });
+	}
+}
+
+export class RequiredPackagesCliError extends DrizzleCliError {
+	constructor(packages: string[]) {
+		super(
+			'required_packages_error',
+			errText(`please install required packages: ${packages.map((it) => `'${it}'`).join(' ')}`),
+			{ packages },
+		);
+	}
+}
+
+export class RequiredEitherPackagesCliError extends DrizzleCliError {
+	constructor(packages: string[]) {
+		super(
+			'required_either_packages_error',
+			errText(`Please install one of those packages are needed: ${packages.map((it) => `'${it}'`).join(' or ')}`),
+			{ packages },
+		);
+	}
+}
+
+export class StudioNodeVersionCliError extends DrizzleCliError {
+	constructor() {
+		super('studio_node_version_error', errText('Drizzle Studio requires NodeJS v18 or above'));
+	}
+}
+
+export class AmbiguousParamsCliError extends DrizzleCliError {
+	constructor(command: string, humanMessage: string) {
+		super('ambiguous_params_error', humanMessage, {
+			command,
+			configOption: 'config',
+		});
+	}
+}
+
+export class MissingRequiredParamsCliError extends DrizzleCliError {
+	constructor(params: string[]) {
+		super('missing_required_params_error', `Please provide required params: ${params.join(', ')}`, { params });
+	}
+}
+
+export class RequiredParamsCliError extends DrizzleCliError {
+	constructor(params: string[], humanMessage: string) {
+		super('missing_required_params_error', humanMessage, { params });
+	}
+}
+
+export class ConfigFileNotFoundCliError extends DrizzleCliError {
+	constructor(path: string) {
+		super('config_file_not_found_error', `${path} file does not exist`, { path });
+	}
+}
+
+export class SchemaFilesNotFoundCliError extends DrizzleCliError {
+	constructor(paths: string[]) {
+		super(
+			'schema_files_not_found_error',
+			[
+				error(`No schema files found for path config [${paths.map((it) => `'${it}'`).join(', ')}]`),
+				error('If path represents a file - please make sure to use .ts or other extension in the path'),
+			].join('\n'),
+			{ paths },
+		);
+	}
+}
+
+export class ConfigValidationCliError extends DrizzleCliError {
+	constructor(humanMessage: string, issues?: JsonValue[], options?: ErrorOptions) {
+		super('config_validation_error', humanMessage, issues ? { issues } : undefined, options);
+	}
+}
+
+export class MissingConfigDialectCliError extends DrizzleCliError {
+	constructor() {
+		super('missing_config_dialect_error', error("Please specify 'dialect' param in config file"), { field: 'dialect' });
+	}
+}
+
+export class UnsupportedSnapshotVersionCliError extends DrizzleCliError {
+	constructor(path: string) {
+		super(
+			'unsupported_snapshot_version_error',
+			info(`${path} snapshot is of unsupported version, please update drizzle-kit`),
+			{ path },
+		);
+	}
+}
+
+export class MigrationSnapshotNotFoundCliError extends DrizzleCliError {
+	constructor(snapshotPath?: string) {
+		super('migration_snapshot_not_found_error', 'No snapshot was found', snapshotPath ? { snapshotPath } : undefined);
+	}
+}
+
+export class MigrationSqlFilesConflictCliError extends DrizzleCliError {
+	constructor(prefix?: string) {
+		super('migration_sql_files_conflict_error', 'Several sql files were found', prefix ? { prefix } : undefined);
+	}
+}
+
+export class UnsupportedCommandDialectCliError extends DrizzleCliError {
+	constructor(command: string, dialect: string) {
+		super('unsupported_command_dialect_error', error(`You can't use '${command}' command with ${dialect} dialect`), {
+			command,
+			dialect,
+		});
+	}
+}
+
+export class UnsupportedCommandCliError extends DrizzleCliError {
+	constructor(command: string, humanMessage: string, meta?: DrizzleCliErrorMeta) {
+		super('unsupported_command_dialect_error', humanMessage, {
+			command,
+			...meta,
+		});
+	}
+}
+
+export class MissingDialectCliError extends DrizzleCliError {
+	constructor(humanMessage: string) {
+		super('missing_required_params_error', humanMessage, {
+			params: ['dialect'],
+		});
+	}
+}
+
+export class ConfigConnectionCliError extends DrizzleCliError {
+	constructor(driver: string, params: string[], humanMessage: string, command?: string) {
+		super('config_connection_error', humanMessage, {
+			driver,
+			params,
+			...(command ? { command } : {}),
+		});
+	}
+}
+
+export class DatabaseDriverCliError extends DrizzleCliError {
+	constructor(database: string, packages: string[], humanMessage: string, note?: string) {
+		super('database_driver_error', humanMessage, {
+			database,
+			packages,
+			...(note ? { note } : {}),
+		});
+	}
+}
+
+export class ConnectionStringDatabaseCliError extends DrizzleCliError {
+	constructor(driver: string, humanMessage: string) {
+		super('connection_string_database_error', humanMessage, { driver });
+	}
+}
+
+export class GelProjectLinkCliError extends DrizzleCliError {
+	constructor() {
+		super(
+			'gel_project_link_error',
+			`It looks like you forgot to link the Gel project or provide the database credentials.
+To link your project, please refer https://docs.geldata.com/reference/cli/gel_instance/gel_instance_link, or add the dbCredentials to your configuration file.`,
+		);
+	}
+}
+
+export class CommandOutputCliError extends DrizzleCliError {
+	constructor(command: string, humanMessage: string, meta?: DrizzleCliErrorMeta) {
+		super('command_output_error', humanMessage, { command, ...meta });
+	}
+}
+
+export class OrmDriverVersionCliError extends DrizzleCliError {
+	constructor(driver: string, minVersion: string, humanMessage: string) {
+		super('orm_driver_version_error', humanMessage, { driver, minVersion });
+	}
+}
+
+export class CheckCliError extends DrizzleCliError {
+	constructor(
+		kind: 'unsupported' | 'malformed' | 'non_latest' | 'conflicts',
+		humanMessage: string,
+		meta?: DrizzleCliErrorMeta,
+	) {
+		super('check_error', humanMessage, { kind, ...meta });
+	}
+}
+
+export class InvalidHintsCliError extends DrizzleCliError {
+	constructor(humanMessage: string, meta?: DrizzleCliErrorMeta, options?: ErrorOptions) {
+		super('invalid_hints', humanMessage, meta, options);
+	}
+}
+
+export class MigrationsOutdatedCliError extends DrizzleCliError {
+	constructor(out: string) {
+		super(
+			'migrations_outdated_error',
+			`Your migrations folder format is outdated, please run drizzle-kit up`,
+			{ out },
+		);
+	}
+}
+
+export type UnsupportedSchemaChangeMeta =
+	| { kind: 'drop_pk_dependency'; table: string; columns: string[]; blocking_fks: string[] }
+	| { kind: 'fk_target_not_unique'; table: string; columns: string[]; table_to: string; columns_to: string[] }
+	| { kind: 'rename_blocked_by_check_constraint'; schema: string; table: string; from: string; to: string }
+	| { kind: 'rename_schema_unsupported'; from: string; to: string; dialect: 'mssql' };
+
+export class UnsupportedSchemaChangeError extends DrizzleCliError {
+	override readonly meta: UnsupportedSchemaChangeMeta;
+
+	constructor(meta: UnsupportedSchemaChangeMeta) {
+		super('unsupported_schema_change', defaultMessage(meta), meta as DrizzleCliErrorMeta);
+		this.meta = meta;
+	}
+}
+
+export const errorToEnvelope = (e: unknown) => {
+	if (e instanceof DrizzleCliError) {
+		return { status: 'error' as const, error: { code: e.code, ...e.meta } };
+	}
+	if (e instanceof QueryError) {
+		return {
+			status: 'error' as const,
+			error: { code: 'query_error', sql: e.sql, params: e.params },
+		};
+	}
+	return {
+		status: 'error' as const,
+		error: { code: 'internal_error', message: e instanceof Error ? e.message : String(e) },
+	};
+};
+
+function defaultMessage(meta: UnsupportedSchemaChangeMeta): string {
+	switch (meta.kind) {
+		case 'drop_pk_dependency':
+			return `Cannot drop primary key on '${meta.table}': blocked by foreign keys [${meta.blocking_fks.join(', ')}]`;
+		case 'fk_target_not_unique':
+			return `Cannot create foreign key on '${meta.table}': referenced columns on '${meta.table_to}' are not unique`;
+		case 'rename_blocked_by_check_constraint':
+			return `Cannot rename '${meta.schema}.${meta.table}.${meta.from}' to '${meta.to}': column is used in a check constraint`;
+		case 'rename_schema_unsupported':
+			return `Cannot rename schema '${meta.from}' to '${meta.to}': ${meta.dialect} does not support schema rename`;
+		// exhaustive: adding a kind here forces the new branch above
+		default: {
+			const _: never = meta;
+			return _;
+		}
+	}
+}
diff --git a/drizzle-kit/src/cli/highlighter.ts b/drizzle-kit/src/cli/highlighter.ts
new file mode 100644
index 0000000000..89738f7e02
--- /dev/null
+++ b/drizzle-kit/src/cli/highlighter.ts
@@ -0,0 +1,304 @@
+import chalk from 'chalk';
+
+type TokenType =
+	| 'keyword'
+	| 'string'
+	| 'variable'
+	| 'operator'
+	| 'type'
+	| 'number'
+	| 'comment'
+	| 'built_in'
+	| 'literal'
+	| 'whitespace'
+	| 'punctuation'
+	| 'identifier';
+
+interface Token {
+	type: TokenType;
+	value: string;
+}
+
+const KEYWORDS = new Set([
+	'WITH',
+	'AS',
+	'SELECT',
+	'FROM',
+	'JOIN',
+	'ON',
+	'WHERE',
+	'BETWEEN',
+	'AND',
+	'GROUP',
+	'BY',
+	'ORDER',
+	'LIMIT',
+	'DESC',
+	'ASC',
+	'IS',
+	'NOT',
+	'NULL',
+	'OVER',
+	'PARTITION',
+	'RANK',
+	'HAVING',
+	'INSERT',
+	'INTO',
+	'VALUES',
+	'UPDATE',
+	'CASCADE',
+	'SET',
+	'DELETE',
+	'CREATE',
+	'SCHEMA',
+	'TABLE',
+	'COLUMN',
+	'ALTER',
+	'DROP',
+	'UNION',
+	'ALL',
+	'DISTINCT',
+	'CASE',
+	'WHEN',
+	'THEN',
+	'ELSE',
+	'END',
+	'LEFT',
+	'RIGHT',
+	'INNER',
+	'OUTER',
+	'DEFAULT',
+	'UNIQUE',
+	'TYPE',
+	'ADD',
+	'CONSTRAINT',
+	'REFERENCES',
+	'FOREIGN',
+	'KEY',
+]);
+
+const BUILT_INS = new Set([
+	'SUM',
+	'COUNT',
+	'ROUND',
+	'AVG',
+	'MIN',
+	'MAX',
+	'COALESCE',
+	'NOW',
+	'DATE',
+	'CAST',
+	'CONVERT',
+	'SUBSTRING',
+	'TRIM',
+	'LOWER',
+	'UPPER',
+	'CURRENT_TIMESTAMP',
+]);
+
+const TYPES = new Set([
+	'int',
+	'integer',
+	'varchar',
+	'char',
+	'text',
+	'date',
+	'timestamp',
+	'numeric',
+	'decimal',
+	'float',
+	'double',
+	'boolean',
+	'json',
+	'jsonb',
+]);
+
+const LITERALS = new Set(['true', 'false']);
+
+function getTokenType(value: string): TokenType {
+	const upper = value.toUpperCase();
+	if (KEYWORDS.has(upper)) return 'keyword';
+	if (BUILT_INS.has(upper)) return 'built_in';
+	if (TYPES.has(value.toLowerCase())) return 'type';
+	if (LITERALS.has(value.toLowerCase())) return 'literal';
+	return 'identifier';
+}
+
+export function tokenize(code: string): Token[] {
+	const tokens: Token[] = [];
+	let current = 0;
+
+	while (current < code.length) {
+		const char = code[current];
+		if (!char) break; // Safety check
+
+		// Whitespace
+		if (/\s/.test(char)) {
+			let value = '';
+			while (current < code.length && /\s/.test(code[current] || '')) {
+				value += code[current];
+				current++;
+			}
+			tokens.push({ type: 'whitespace', value });
+			continue;
+		}
+
+		// Strings (single quotes)
+		if (char === "'") {
+			let value = "'";
+			current++;
+			while (current < code.length) {
+				const c = code[current];
+				const next = code[current + 1];
+				if (c === "'" && next === "'") {
+					value += "''";
+					current += 2;
+				} else if (c === "'") {
+					value += "'";
+					current++;
+					break;
+				} else {
+					value += c || '';
+					current++;
+				}
+			}
+			tokens.push({ type: 'string', value });
+			continue;
+		}
+
+		// Numbers
+		if (/[0-9]/.test(char)) {
+			let value = '';
+			while (current < code.length && /[0-9.]/.test(code[current] || '')) {
+				value += code[current];
+				current++;
+			}
+			tokens.push({ type: 'number', value });
+			continue;
+		}
+
+		// Comments (-- style)
+		if (char === '-' && code[current + 1] === '-') {
+			let value = '';
+			while (current < code.length && code[current] !== '\n') {
+				value += code[current] || '';
+				current++;
+			}
+			tokens.push({ type: 'comment', value });
+			continue;
+		}
+
+		// Operators and Punctuation
+		if (/[(),;.]/.test(char)) {
+			tokens.push({ type: 'punctuation', value: char });
+			current++;
+			continue;
+		}
+
+		if (/[=<>!+\-*/|:]/.test(char)) {
+			let value = '';
+			while (current < code.length && /[=<>!+\-*/|:]/.test(code[current] || '')) {
+				value += code[current];
+				current++;
+			}
+			tokens.push({ type: 'operator', value });
+			continue;
+		}
+
+		// Quoted Identifiers ("" or ``)
+		if (char === '"' || char === '`') {
+			const quote = char;
+			let value = quote;
+			current++;
+			while (current < code.length) {
+				const c = code[current];
+				const next = code[current + 1];
+				if (c === quote && next === quote) {
+					value += quote + quote;
+					current += 2;
+				} else if (c === quote) {
+					value += quote;
+					current++;
+					break;
+				} else {
+					value += c || '';
+					current++;
+				}
+			}
+			tokens.push({ type: 'identifier', value });
+			continue;
+		}
+
+		// Bracket Identifiers ([])
+		if (char === '[') {
+			let value = '[';
+			current++;
+			while (current < code.length) {
+				const c = code[current];
+				const next = code[current + 1];
+				if (c === ']' && next === ']') {
+					value += ']]';
+					current += 2;
+				} else if (c === ']') {
+					value += ']';
+					current++;
+					break;
+				} else {
+					value += c || '';
+					current++;
+				}
+			}
+			tokens.push({ type: 'identifier', value });
+			continue;
+		}
+
+		// Identifiers and Keywords
+		if (/[a-zA-Z_]/.test(char)) {
+			let value = '';
+			while (current < code.length && /[a-zA-Z0-9_]/.test(code[current] || '')) {
+				value += code[current];
+				current++;
+			}
+			tokens.push({ type: getTokenType(value), value });
+			continue;
+		}
+
+		// Fallback for unknown characters
+		tokens.push({ type: 'identifier', value: char });
+		current++;
+	}
+
+	return tokens;
+}
+
+export function highlightSQL(code: string): string {
+	const tokens = tokenize(code);
+	return tokens.map((token) => {
+		switch (token.type) {
+			case 'keyword':
+				return chalk.redBright.bold(token.value);
+			case 'string':
+				return chalk.green(token.value);
+			case 'variable':
+				return chalk.blue(token.value); // Not explicitly detected in simple lexer, usually identifiers
+			case 'operator':
+				return chalk.gray(token.value);
+			case 'type':
+				return chalk.magenta(token.value);
+			case 'number':
+				return chalk.yellow(token.value);
+			case 'comment':
+				return chalk.gray.italic(token.value);
+			case 'built_in':
+				return chalk.redBright(token.value);
+			case 'literal':
+				return chalk.yellow(token.value);
+			case 'identifier':
+				return chalk.italic(token.value); // Default color for identifiers
+			case 'punctuation':
+				return chalk.gray(token.value);
+			default:
+				return token.value;
+		}
+	}).join('');
+}
diff --git a/drizzle-kit/src/cli/hints.ts b/drizzle-kit/src/cli/hints.ts
new file mode 100644
index 0000000000..72687a441b
--- /dev/null
+++ b/drizzle-kit/src/cli/hints.ts
@@ -0,0 +1,351 @@
+import { readFile } from 'fs/promises';
+import { z, type ZodIssue } from 'zod';
+import { InvalidHintsCliError, type JsonValue } from './errors';
+
+const singleTupleSchema = z.tuple([z.string()]);
+const pairTupleSchema = z.tuple([z.string(), z.string()]);
+const tripleTupleSchema = z.tuple([z.string(), z.string(), z.string()]);
+const privilegeTupleSchema = z.tuple([z.string(), z.string(), z.string(), z.string(), z.string()]);
+
+const renameCreateEntitySchemas = [
+	{ kind: 'table', schema: pairTupleSchema },
+	{ kind: 'column', schema: tripleTupleSchema },
+	{ kind: 'default', schema: tripleTupleSchema },
+	{ kind: 'schema', schema: singleTupleSchema },
+	{ kind: 'enum', schema: pairTupleSchema },
+	{ kind: 'sequence', schema: pairTupleSchema },
+	{ kind: 'view', schema: pairTupleSchema },
+	{ kind: 'policy', schema: tripleTupleSchema },
+	{ kind: 'role', schema: singleTupleSchema },
+	{ kind: 'privilege', schema: privilegeTupleSchema },
+	{ kind: 'check', schema: tripleTupleSchema },
+	{ kind: 'index', schema: tripleTupleSchema },
+	{ kind: 'unique', schema: tripleTupleSchema },
+	{ kind: 'primary_key', schema: tripleTupleSchema },
+	{ kind: 'foreign key', schema: tripleTupleSchema },
+] as const satisfies readonly { readonly kind: string; readonly schema: z.ZodTypeAny }[];
+
+export type RenameCreateHintKind = typeof renameCreateEntitySchemas[number]['kind'];
+
+const confirmEntitySchemas = [
+	{ kind: 'table', schema: pairTupleSchema },
+	{ kind: 'column', schema: tripleTupleSchema },
+	{ kind: 'schema', schema: singleTupleSchema },
+	{ kind: 'view', schema: pairTupleSchema },
+	{ kind: 'primary_key', schema: tripleTupleSchema },
+	{ kind: 'add_not_null', schema: tripleTupleSchema },
+	{ kind: 'add_unique', schema: tripleTupleSchema },
+] as const satisfies readonly { readonly kind: string; readonly schema: z.ZodTypeAny }[];
+
+export type ConfirmEntityKind = typeof confirmEntitySchemas[number]['kind'];
+
+type RenameCreateSchemaFor<K extends RenameCreateHintKind> = Extract<
+	typeof renameCreateEntitySchemas[number],
+	{ kind: K }
+>['schema'];
+
+type ConfirmSchemaFor<K extends ConfirmEntityKind> = Extract<
+	typeof confirmEntitySchemas[number],
+	{ kind: K }
+>['schema'];
+
+export type IdFor<K extends RenameCreateHintKind> = Readonly<z.infer<RenameCreateSchemaFor<K>>>;
+
+export type ConfirmIdFor<K extends ConfirmEntityKind> = Readonly<z.infer<ConfirmSchemaFor<K>>>;
+
+export type RenameHint = {
+	[K in RenameCreateHintKind]: { type: 'rename'; kind: K; from: IdFor<K>; to: IdFor<K> };
+}[RenameCreateHintKind];
+
+export type CreateHint = {
+	[K in RenameCreateHintKind]: { type: 'create'; kind: K; entity: IdFor<K> };
+}[RenameCreateHintKind];
+
+export type ConfirmDataLossHint = {
+	[K in ConfirmEntityKind]: { type: 'confirm_data_loss'; kind: K; entity: ConfirmIdFor<K> };
+}[ConfirmEntityKind];
+
+export type Hint = RenameHint | CreateHint | ConfirmDataLossHint;
+
+type RenameCreateMissingHint<K extends RenameCreateHintKind> = {
+	type: 'rename_or_create';
+	kind: K;
+	entity: IdFor<K>;
+};
+
+type ConfirmDataLossReasonDetails =
+	| { reason: 'non_empty' }
+	| { reason: 'table_recreate' }
+	| { reason: 'type_change'; reason_details: { from: string; to: string } };
+
+type ConfirmDataLossMissingHint<K extends ConfirmEntityKind> = {
+	type: 'confirm_data_loss';
+	kind: K;
+	entity: ConfirmIdFor<K>;
+} & ConfirmDataLossReasonDetails;
+
+export type MissingHint =
+	| {
+		[K in RenameCreateHintKind]: RenameCreateMissingHint<K>;
+	}[RenameCreateHintKind]
+	| {
+		[K in ConfirmEntityKind]: ConfirmDataLossMissingHint<K>;
+	}[ConfirmEntityKind];
+
+export type MissingHintsResponse = {
+	status: 'missing_hints';
+	unresolved: readonly MissingHint[];
+};
+
+type Hints = {
+	renames: RenameHint[];
+	creates: CreateHint[];
+	confirms: ConfirmDataLossHint[];
+};
+
+type InvalidHintShapeCliErrorMeta = {
+	issues: readonly ZodIssue[];
+};
+
+type RenameHintMember<E> = E extends { kind: infer K extends string; schema: infer S extends z.ZodTypeAny }
+	? z.ZodObject<{
+		type: z.ZodLiteral<'rename'>;
+		kind: z.ZodLiteral<K>;
+		from: S;
+		to: S;
+	}, 'strict'>
+	: never;
+
+type CreateHintMember<E> = E extends { kind: infer K extends string; schema: infer S extends z.ZodTypeAny }
+	? z.ZodObject<{
+		type: z.ZodLiteral<'create'>;
+		kind: z.ZodLiteral<K>;
+		entity: S;
+	}, 'strict'>
+	: never;
+
+type ConfirmHintMember<E> = E extends { kind: infer K extends string; schema: infer S extends z.ZodTypeAny }
+	? z.ZodObject<{
+		type: z.ZodLiteral<'confirm_data_loss'>;
+		kind: z.ZodLiteral<K>;
+		entity: S;
+	}, 'strict'>
+	: never;
+
+type RenameHintMembers = {
+	-readonly [I in keyof typeof renameCreateEntitySchemas]: RenameHintMember<typeof renameCreateEntitySchemas[I]>;
+};
+
+type CreateHintMembers = {
+	-readonly [I in keyof typeof renameCreateEntitySchemas]: CreateHintMember<typeof renameCreateEntitySchemas[I]>;
+};
+
+type ConfirmHintMembers = {
+	-readonly [I in keyof typeof confirmEntitySchemas]: ConfirmHintMember<typeof confirmEntitySchemas[I]>;
+};
+
+type UnionInput<T extends readonly z.ZodTypeAny[]> = T & [T[number], T[number], ...T[number][]];
+
+const renameHintSchema = z.union(
+	renameCreateEntitySchemas.map(({ kind, schema }) =>
+		z.object({
+			type: z.literal('rename'),
+			kind: z.literal(kind),
+			from: schema,
+			to: schema,
+		}).strict()
+	) as unknown as UnionInput<RenameHintMembers>,
+);
+
+const createHintSchema = z.union(
+	renameCreateEntitySchemas.map(({ kind, schema }) =>
+		z.object({
+			type: z.literal('create'),
+			kind: z.literal(kind),
+			entity: schema,
+		}).strict()
+	) as unknown as UnionInput<CreateHintMembers>,
+);
+
+const confirmHintSchema = z.union(
+	confirmEntitySchemas.map(({ kind, schema }) =>
+		z.object({
+			type: z.literal('confirm_data_loss'),
+			kind: z.literal(kind),
+			entity: schema,
+		}).strict()
+	) as unknown as UnionInput<ConfirmHintMembers>,
+);
+
+export const hintSchema = z.array(z.union([
+	renameHintSchema,
+	createHintSchema,
+	confirmHintSchema,
+]));
+
+class InvalidHintShapeCliError extends Error {
+	readonly code = 'invalid_hints' as const;
+	readonly meta: InvalidHintShapeCliErrorMeta;
+
+	constructor(meta: InvalidHintShapeCliErrorMeta) {
+		const [issue] = meta.issues;
+		const location = formatIssuePath(issue?.path ?? []);
+
+		super(issue ? `Invalid hint shape at ${location}: ${issue.message}` : 'Invalid hint shape');
+		this.name = new.target.name;
+		this.meta = meta;
+	}
+}
+
+export class HintsHandler {
+	private readonly userHints: Hints;
+	readonly missingHints: MissingHint[] = [];
+
+	constructor(hints: readonly Hint[] = []) {
+		this.userHints = buildHints(hints);
+	}
+
+	static async fromCli(opts: { hints?: string | Hint[]; hintsFile?: string }): Promise<HintsHandler> {
+		let source: 'file' | 'inline';
+		let parsedJson: unknown;
+
+		if (Array.isArray(opts.hints)) {
+			source = 'inline';
+			parsedJson = opts.hints;
+		} else {
+			let rawText: string;
+			if (opts.hintsFile) {
+				source = 'file';
+				try {
+					rawText = await readFile(opts.hintsFile, 'utf8');
+				} catch (error) {
+					throw new InvalidHintsCliError(
+						`Failed to read hints file '${opts.hintsFile}': ${(error as Error).message}`,
+						{ source, path: opts.hintsFile },
+						{ cause: error as Error },
+					);
+				}
+			} else if (opts.hints) {
+				source = 'inline';
+				rawText = opts.hints;
+			} else {
+				return new HintsHandler();
+			}
+
+			try {
+				parsedJson = JSON.parse(rawText);
+			} catch (error) {
+				throw new InvalidHintsCliError(
+					`Failed to parse hints JSON from ${source}: ${(error as Error).message}`,
+					{ source },
+					{ cause: error as Error },
+				);
+			}
+		}
+
+		try {
+			return new HintsHandler(parseHints(parsedJson));
+		} catch (error) {
+			if (error instanceof InvalidHintShapeCliError) {
+				throw new InvalidHintsCliError(
+					error.message,
+					{ source, issues: error.meta.issues as unknown as JsonValue },
+					{ cause: error },
+				);
+			}
+
+			throw error;
+		}
+	}
+
+	matchRename<K extends RenameCreateHintKind>(kind: K, toId: IdFor<K>) {
+		return this.userHints.renames.find((hint): hint is Extract<RenameHint, { kind: K }> => {
+			return hint.kind === kind && tuplesEqual(hint.to, toId);
+		});
+	}
+
+	matchCreate<K extends RenameCreateHintKind>(kind: K, entityId: IdFor<K>) {
+		return this.userHints.creates.find((hint): hint is Extract<CreateHint, { kind: K }> => {
+			return hint.kind === kind && tuplesEqual(hint.entity, entityId);
+		});
+	}
+
+	matchConfirm<K extends ConfirmEntityKind>(kind: K, entityId: ConfirmIdFor<K>) {
+		return this.userHints.confirms.find((hint): hint is Extract<ConfirmDataLossHint, { kind: K }> => {
+			return hint.kind === kind && tuplesEqual(hint.entity, entityId);
+		});
+	}
+
+	pushMissingHint<K extends RenameCreateHintKind>(kind: K, entity: IdFor<K>): void;
+	pushMissingHint(hint: MissingHint): void;
+	pushMissingHint(
+		...args: [MissingHint] | [RenameCreateHintKind, IdFor<RenameCreateHintKind>]
+	): void {
+		if (args.length === 1) {
+			this.missingHints.push(args[0]);
+			return;
+		}
+		const [kind, entity] = args;
+		this.missingHints.push({ type: 'rename_or_create', kind, entity } as MissingHint);
+	}
+
+	hasMissingHints(): boolean {
+		return this.missingHints.length > 0;
+	}
+
+	toResponse(): MissingHintsResponse {
+		return {
+			status: 'missing_hints',
+			unresolved: this.missingHints,
+		};
+	}
+}
+
+function formatIssuePath(path: readonly (string | number)[]): string {
+	if (path.length === 0) {
+		return '<root>';
+	}
+
+	return path.map((segment) => typeof segment === 'number' ? `[${segment}]` : `.${segment}`).join('');
+}
+
+export function parseHints(raw: unknown): Hint[] {
+	const result = hintSchema.safeParse(raw);
+	if (!result.success) {
+		throw new InvalidHintShapeCliError({ issues: result.error.issues });
+	}
+
+	return result.data;
+}
+
+function buildHints(hints: readonly Hint[]): Hints {
+	const set: Hints = {
+		renames: [],
+		creates: [],
+		confirms: [],
+	};
+
+	for (const hint of hints) {
+		if (hint.type === 'rename') {
+			set.renames.push(hint);
+			continue;
+		}
+
+		if (hint.type === 'create') {
+			set.creates.push(hint);
+			continue;
+		}
+
+		set.confirms.push(hint);
+	}
+
+	return set;
+}
+
+export function tuplesEqual(left: readonly string[], right: readonly string[]): boolean {
+	if (left.length !== right.length) {
+		return false;
+	}
+
+	return left.every((segment, index) => segment === right[index]);
+}
diff --git a/drizzle-kit/src/cli/index.ts b/drizzle-kit/src/cli/index.ts
index 42730be1d5..e48c360b7d 100644
--- a/drizzle-kit/src/cli/index.ts
+++ b/drizzle-kit/src/cli/index.ts
@@ -1,7 +1,65 @@
-import { command, run } from '@drizzle-team/brocli';
+import './dotenv-quiet';
+import 'dotenv/config';
+import { type BroCliEvent, command, getCommandNameWithParents, run } from '@drizzle-team/brocli';
 import chalk from 'chalk';
-import { check, drop, exportRaw, generate, migrate, pull, push, studio, up } from './schema';
-import { ormCoreVersions } from './utils';
+import { outputFormat, runWithCliContext } from './context';
+import { DrizzleCliError, errorToEnvelope } from './errors';
+import { highlightSQL } from './highlighter';
+import { check, exportRaw, generate, mcp, migrate, pull, push, skills, studio, up } from './schema';
+import { ormCoreVersions, QueryError } from './utils';
+import { error, humanError, humanLog } from './views';
+
+const writeStderr = (message: string) => {
+	process.stderr.write(`${message}\n`);
+};
+
+const formatQueryError = (e: QueryError) => {
+	let msg = `┌── ${chalk.bgRed.bold('query error:')} ${chalk.red(e.message)}\n\n`;
+	msg += `${highlightSQL(e.sql)}\n`;
+	if (e.params.length > 0) msg += '| ' + chalk.gray(`--- params: ${e.params || '[]'}\n\n`);
+	msg += '└──';
+	return msg;
+};
+
+const getBroCliErrorMessage = (event: BroCliEvent & { type: 'error' }) => {
+	if (event.violation === 'missing_args_error') {
+		return `Missing required arguments: ${event.missing.map((group) => group.join(' | ')).join(', ')}`;
+	}
+
+	if (event.violation === 'unrecognized_args_error') {
+		return `Unrecognized arguments: ${event.unrecognized.join(', ')}`;
+	}
+
+	if (event.violation === 'unknown_command_error') {
+		return `Unknown command: ${event.offender}`;
+	}
+
+	if (event.violation === 'unknown_subcommand_error') {
+		return `Unknown subcommand: ${event.offender}`;
+	}
+
+	if (event.violation === 'unknown_error') {
+		const candidate = event.error;
+		if (candidate instanceof QueryError || candidate instanceof DrizzleCliError) {
+			return candidate.message;
+		}
+
+		if (
+			typeof candidate === 'object' && candidate !== null && 'message' in candidate
+			&& typeof candidate.message === 'string'
+		) {
+			return candidate.message;
+		}
+
+		return 'Unknown error';
+	}
+
+	const optionName = 'option' in event ? event.option.name : 'option';
+	const offender = 'offender' in event
+		? [event.offender.namePart, event.offender.dataPart].filter(Boolean).join(' ')
+		: '';
+	return `Invalid value for --${optionName}${offender ? `: ${offender}` : ''}`;
+};
 
 const version = async () => {
 	const { npmVersion } = await ormCoreVersions();
@@ -9,15 +67,24 @@ const version = async () => {
 	const envVersion = process.env.DRIZZLE_KIT_VERSION;
 	const kitVersion = envVersion ? `v${envVersion}` : '--';
 	const versions = `drizzle-kit: ${kitVersion}\n${ormVersion}`;
-	console.log(chalk.gray(versions), '\n');
+	humanLog(chalk.gray(versions), '\n');
 };
 
-const legacyCommand = (name: string, newName: string) => {
+const legacyCommand = (
+	{ name, newName, customMessage }: { name: string; newName?: string; customMessage?: string },
+) => {
 	return command({
 		name,
 		hidden: true,
 		handler: () => {
-			console.log(
+			// in this case command was deleted and there is no new command
+			if (!newName) {
+				humanLog(
+					`This command is deprecated. ${customMessage}`,
+				);
+				return;
+			}
+			humanLog(
 				`This command is deprecated, please use updated '${newName}' command (see https://orm.drizzle.team/kit-docs/upgrade-21#how-to-migrate-to-0210)`,
 			);
 		},
@@ -25,24 +92,88 @@ const legacyCommand = (name: string, newName: string) => {
 };
 
 const legacy = [
-	legacyCommand('generate:pg', 'generate'),
-	legacyCommand('generate:mysql', 'generate'),
-	legacyCommand('generate:sqlite', 'generate'),
-	legacyCommand('push:pg', 'push'),
-	legacyCommand('push:mysql', 'push'),
-	legacyCommand('push:sqlite', 'push'),
-	legacyCommand('introspect:pg', 'introspect'),
-	legacyCommand('introspect:mysql', 'introspect'),
-	legacyCommand('introspect:sqlite', 'introspect'),
-	legacyCommand('up:pg', 'up'),
-	legacyCommand('up:mysql', 'up'),
-	legacyCommand('up:sqlite', 'up'),
-	legacyCommand('check:pg', 'check'),
-	legacyCommand('check:mysql', 'check'),
-	legacyCommand('check:sqlite', 'check'),
+	legacyCommand({ name: 'generate:pg', newName: 'generate' }),
+	legacyCommand({ name: 'generate:mysql', newName: 'generate' }),
+	legacyCommand({ name: 'generate:sqlite', newName: 'generate' }),
+	legacyCommand({ name: 'push:pg', newName: 'push' }),
+	legacyCommand({ name: 'push:mysql', newName: 'push' }),
+	legacyCommand({ name: 'push:sqlite', newName: 'push' }),
+	legacyCommand({ name: 'introspect:pg', newName: 'introspect' }),
+	legacyCommand({ name: 'introspect:mysql', newName: 'introspect' }),
+	legacyCommand({ name: 'introspect:sqlite', newName: 'introspect' }),
+	legacyCommand({ name: 'up:pg', newName: 'up' }),
+	legacyCommand({ name: 'up:mysql', newName: 'up' }),
+	legacyCommand({ name: 'up:sqlite', newName: 'up' }),
+	legacyCommand({ name: 'check:pg', newName: 'check' }),
+	legacyCommand({ name: 'check:mysql', newName: 'check' }),
+	legacyCommand({ name: 'check:sqlite', newName: 'check' }),
+
+	// after folders v3 update
+	legacyCommand({ name: 'drop', customMessage: 'To drop a migration you can remove a migration folder manually' }),
 ];
 
-run([generate, migrate, pull, push, studio, up, check, drop, exportRaw, ...legacy], {
-	name: 'drizzle-kit',
-	version: version,
-});
+const main = async () => {
+	await runWithCliContext({ output: 'text', interactive: false }, async () => {
+		await run([generate, migrate, pull, push, studio, up, check, exportRaw, skills, mcp, ...legacy], {
+			name: 'drizzle-kit',
+			version: () => version(),
+
+			hook: (event, command) => {
+				const name = getCommandNameWithParents(command);
+				if (event === 'after' && name !== 'studio' && name !== 'mcp') process.exit(0);
+			},
+			theme: (event) => {
+				if (event.type === 'error') {
+					if (outputFormat() === 'json') {
+						if (event.violation === 'unknown_error' && event.error instanceof QueryError) {
+							writeStderr(formatQueryError(event.error));
+							process.stdout.write(JSON.stringify(errorToEnvelope(event.error)) + '\n');
+							return true;
+						}
+
+						if (event.violation === 'unknown_error' && event.error instanceof DrizzleCliError) {
+							writeStderr(event.error.humanMessage);
+							process.stdout.write(JSON.stringify(errorToEnvelope(event.error)) + '\n');
+							return true;
+						}
+
+						writeStderr(getBroCliErrorMessage(event));
+						process.stdout.write(
+							JSON.stringify({
+								status: 'error',
+								error: { code: event.violation, message: getBroCliErrorMessage(event) },
+							}) + '\n',
+						);
+						return true;
+					}
+
+					if (event.violation !== 'unknown_error') return false;
+
+					const e = event.error;
+					if (e instanceof QueryError) {
+						const msg = formatQueryError(e);
+						humanError();
+						humanError(msg);
+						return true;
+					}
+
+					if (e instanceof DrizzleCliError) {
+						humanError(e.humanMessage);
+						return true;
+					}
+
+					if (
+						!(typeof e === 'object' && e !== null && 'message' in e && typeof e.message === 'string')
+					) return false;
+
+					humanError(error(e.message));
+					return true;
+				}
+
+				return false;
+			},
+		});
+	});
+};
+
+void main();
diff --git a/drizzle-kit/src/cli/missing-hints-report.ts b/drizzle-kit/src/cli/missing-hints-report.ts
new file mode 100644
index 0000000000..a7678ffb23
--- /dev/null
+++ b/drizzle-kit/src/cli/missing-hints-report.ts
@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import type { MissingHint, MissingHintsResponse } from './hints';
+import { humanizeKind } from './views';
+
+const entityDisplay = (entity: readonly string[]): string => entity.join('.');
+
+const jsonArray = (segments: readonly string[]): string => `[${segments.map((s) => JSON.stringify(s)).join(', ')}]`;
+
+const entityToJsonArray = (entity: readonly string[]): string => jsonArray(entity);
+
+// Placeholders are intentionally invalid JSON — the user MUST replace the angle-bracket
+// segments before re-running. Enumerating real candidate `from` values would bloat the
+// snippet count proportional to deleted-of-same-kind (D-05).
+const fromPlaceholder = (entity: readonly string[]): string => {
+	const labels = entity.map((_, idx) => {
+		if (entity.length === 1) return '<old_name>';
+		if (entity.length === 2) return idx === 0 ? '<schema>' : '<old_name>';
+		if (entity.length === 3) {
+			if (idx === 0) return '<schema>';
+			if (idx === 1) return '<table>';
+			return '<old_name>';
+		}
+		if (idx === entity.length - 1) return '<old_name>';
+		return `<segment_${idx + 1}>`;
+	});
+	return jsonArray(labels);
+};
+
+const renderRenameOrCreate = (index: number, item: Extract<MissingHint, { type: 'rename_or_create' }>): string[] => {
+	const header = `${index}. Rename or create  ${chalk.gray('—')}  ${humanizeKind(item.kind)}  ${
+		chalk.bold.cyan(entityDisplay(item.entity))
+	}`;
+	const renameSnippet = `     { "type": "rename", "kind": "${item.kind}", "from": ${
+		fromPlaceholder(item.entity)
+	}, "to": ${entityToJsonArray(item.entity)} }`;
+	const createSnippet = `     { "type": "create", "kind": "${item.kind}", "entity": ${
+		entityToJsonArray(item.entity)
+	} }`;
+	return [
+		header,
+		'   Add to --hints:',
+		renameSnippet,
+		'     OR',
+		createSnippet,
+	];
+};
+
+const confirmReasonProse = (item: Extract<MissingHint, { type: 'confirm_data_loss' }>): string => {
+	switch (item.reason) {
+		case 'non_empty':
+			return `non-empty ${humanizeKind(item.kind)}`;
+		case 'table_recreate':
+			return 'confirming wipes all rows and recreates the table';
+		case 'type_change':
+			return `type change from ${item.reason_details.from} to ${item.reason_details.to}`;
+	}
+};
+
+const renderConfirmDataLoss = (index: number, item: Extract<MissingHint, { type: 'confirm_data_loss' }>): string[] => {
+	const header = `${index}. Confirm data loss  ${chalk.gray('—')}  ${humanizeKind(item.kind)}  ${
+		chalk.bold.cyan(entityDisplay(item.entity))
+	}  ${chalk.gray(confirmReasonProse(item))}`;
+	const snippet = `     { "type": "confirm_data_loss", "kind": "${item.kind}", "entity": ${
+		entityToJsonArray(item.entity)
+	} }`;
+	return [header, '   Add to --hints:', snippet];
+};
+
+export const formatMissingHintsText = (env: MissingHintsResponse): string => {
+	const renameOrCreate = env.unresolved.filter(
+		(item): item is Extract<MissingHint, { type: 'rename_or_create' }> => item.type === 'rename_or_create',
+	);
+	const confirmDataLoss = env.unresolved.filter(
+		(item): item is Extract<MissingHint, { type: 'confirm_data_loss' }> => item.type === 'confirm_data_loss',
+	);
+
+	const lines: string[] = [chalk.yellow.bold(`missing_hints: ${env.unresolved.length} unresolved decisions`)];
+
+	let index = 1;
+	const itemBlocks: string[][] = [];
+	for (const item of renameOrCreate) {
+		itemBlocks.push(renderRenameOrCreate(index, item));
+		index += 1;
+	}
+	for (const item of confirmDataLoss) {
+		itemBlocks.push(renderConfirmDataLoss(index, item));
+		index += 1;
+	}
+
+	for (const block of itemBlocks) {
+		lines.push('');
+		lines.push(...block);
+	}
+
+	lines.push('');
+	lines.push(chalk.gray(`Re-run with --hints '<json-array>'. Exit code 2.`));
+
+	return lines.join('\n') + '\n';
+};
diff --git a/drizzle-kit/src/cli/prompts.ts b/drizzle-kit/src/cli/prompts.ts
new file mode 100644
index 0000000000..944d9163a0
--- /dev/null
+++ b/drizzle-kit/src/cli/prompts.ts
@@ -0,0 +1,247 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import type { Resolver } from '../dialects/common';
+import { isInteractive } from './context';
+import { InvalidHintsCliError } from './errors';
+import { tuplesEqual } from './hints';
+import type { HintsHandler, IdFor, RenameCreateHintKind } from './hints';
+import type { RenamePromptItem } from './views';
+import { humanizeKind, humanLog, isRenamePromptItem, ResolveSelect } from './views';
+
+type PromptEntityBase = { name: string; schema?: string; table?: string };
+
+const entityId = <K extends RenameCreateHintKind>(
+	kind: K,
+	entity: PromptEntityBase,
+	defaultSchema: 'dbo' | 'public',
+): IdFor<K> => {
+	switch (kind) {
+		case 'schema':
+			return [entity.name] as unknown as IdFor<K>;
+		case 'role':
+			return [entity.name] as unknown as IdFor<K>;
+		case 'table':
+		case 'enum':
+		case 'sequence':
+		case 'view':
+			return [entity.schema ?? defaultSchema, entity.name] as unknown as IdFor<K>;
+		case 'column':
+		case 'default':
+		case 'policy':
+		case 'check':
+		case 'index':
+		case 'unique':
+		case 'primary_key':
+		case 'foreign key': {
+			if (typeof entity.table !== 'string') {
+				throw new Error(`Expected ${kind} resolver entity to include a table name`);
+			}
+			return [entity.schema ?? defaultSchema, entity.table, entity.name] as unknown as IdFor<K>;
+		}
+		case 'privilege': {
+			const record = entity as Record<string, unknown>;
+			const required = (property: string): string => {
+				const value = record[property];
+				if (typeof value !== 'string') {
+					throw new Error(`Expected ${kind} resolver entity to include a string ${property} field`);
+				}
+				return value;
+			};
+			if (typeof entity.table !== 'string') {
+				throw new Error(`Expected ${kind} resolver entity to include a table name`);
+			}
+			return [
+				required('grantor'),
+				required('grantee'),
+				entity.schema ?? defaultSchema,
+				entity.table,
+				required('type'),
+			] as unknown as IdFor<K>;
+		}
+	}
+};
+
+export const resolver = <T extends PromptEntityBase>(
+	entity: RenameCreateHintKind,
+	hints?: HintsHandler,
+	defaultSchema: 'public' | 'dbo' = 'public',
+): Resolver<T> => {
+	/**
+	 * Resolves rename-or-create ambiguity for one entity kind by comparing the
+	 * created and deleted sides of a diff.
+	 *
+	 * Hint-driven mode and TTY mode follow different control flows: hint-driven
+	 * mode consults pre-supplied hints and records any missing hints without
+	 * prompting, while TTY mode interactively asks the user to choose the
+	 * resolution.
+	 */
+	return async (it: { created: T[]; deleted: T[] }) => {
+		const { created, deleted } = it;
+
+		if (created.length === 0 || deleted.length === 0) {
+			return { created, deleted, renamedOrMoved: [] };
+		}
+
+		const createResult = () => ({
+			created: [] as T[],
+			deleted: [] as T[],
+			renamedOrMoved: [] as { from: T; to: T }[],
+		});
+
+		const resolveFromHints = async () => {
+			const kind = entity;
+
+			if (!hints) {
+				throw new Error(`Internal error: resolver(${entity}) was called without a HintsHandler`);
+			}
+
+			const result = createResult();
+			let index = 0;
+			let leftMissing = [...deleted];
+
+			do {
+				const newItem = created[index]!;
+				const newItemId = entityId(kind, newItem, defaultSchema);
+				const renameHint = hints.matchRename(kind, newItemId);
+				const createHint = hints.matchCreate(kind, newItemId);
+				const renameSource = renameHint
+					? leftMissing.find((item) => tuplesEqual(entityId(kind, item, defaultSchema), renameHint.from))
+					: undefined;
+
+				if (renameSource) {
+					applySelection({ from: renameSource, to: newItem }, newItem, leftMissing, result, entity, defaultSchema);
+					leftMissing = leftMissing.filter(Boolean);
+					index += 1;
+					continue;
+				}
+
+				if (renameHint) {
+					throw new InvalidHintsCliError(
+						`rename hint's \`from\` ${JSON.stringify(renameHint.from)} doesn't match any deleted ${kind}`,
+						{ kind, from: [...renameHint.from] },
+					);
+				}
+
+				if (!createHint && leftMissing.length > 0) {
+					hints.pushMissingHint(kind, newItemId);
+				}
+
+				applySelection(newItem, newItem, leftMissing, result, entity, defaultSchema);
+				index += 1;
+			} while (index < created.length);
+
+			// Any deleted entities left over were not matched during this resolution pass.
+			humanLog(chalk.gray(`--- all ${humanizeKind(entity)} conflicts resolved ---\n`));
+			result.deleted.push(...leftMissing);
+
+			return result;
+		};
+
+		const resolveTtyMode = async () => {
+			const kind = entity;
+			const result = createResult();
+			let index = 0;
+			let leftMissing = [...deleted];
+
+			do {
+				const newItem = created[index]!;
+
+				if (hints) {
+					const newItemId = entityId(kind, newItem, defaultSchema);
+					const renameHint = hints.matchRename(kind, newItemId);
+					const createHint = hints.matchCreate(kind, newItemId);
+					const renameSource = renameHint
+						? leftMissing.find((item) => tuplesEqual(entityId(kind, item, defaultSchema), renameHint.from))
+						: undefined;
+
+					if (renameSource) {
+						applySelection({ from: renameSource, to: newItem }, newItem, leftMissing, result, entity, defaultSchema);
+						leftMissing = leftMissing.filter(Boolean);
+						index += 1;
+						continue;
+					}
+
+					if (renameHint) {
+						throw new InvalidHintsCliError(
+							`rename hint's \`from\` ${JSON.stringify(renameHint.from)} doesn't match any deleted ${kind}`,
+							{ kind, from: [...renameHint.from] },
+						);
+					}
+
+					if (createHint) {
+						applySelection(newItem, newItem, leftMissing, result, entity, defaultSchema);
+						leftMissing = leftMissing.filter(Boolean);
+						index += 1;
+						continue;
+					}
+				}
+
+				// Present the new entity plus every possible rename candidate to the user.
+				const renames: RenamePromptItem<T>[] = leftMissing.map((item) => ({ from: item, to: newItem }));
+				const promptData: (RenamePromptItem<T> | T)[] = [newItem, ...renames];
+				const { status, data } = await render(new ResolveSelect(newItem, promptData, entity, defaultSchema));
+
+				// Preserve the existing abort behavior for interactive runs.
+				if (status === 'aborted') {
+					console.error('ERROR');
+					process.exit(1);
+				}
+
+				// Apply the selected rename or keep the entity as a create.
+				applySelection(data, newItem, leftMissing, result, entity, defaultSchema);
+				leftMissing = leftMissing.filter(Boolean);
+				index += 1;
+			} while (index < created.length);
+
+			// Any deleted entities still present were not chosen during prompting.
+			humanLog(chalk.gray(`--- all ${humanizeKind(entity)} conflicts resolved ---\n`));
+			result.deleted.push(...leftMissing);
+
+			return result;
+		};
+
+		return isInteractive() ? resolveTtyMode() : resolveFromHints();
+	};
+};
+
+const applySelection = <T extends PromptEntityBase>(
+	selection: RenamePromptItem<T> | T,
+	newItem: T,
+	leftMissing: T[],
+	result: {
+		created: T[];
+		deleted: T[];
+		renamedOrMoved: { from: T; to: T }[];
+	},
+	entity: RenameCreateHintKind,
+	defaultSchema: 'dbo' | 'public',
+): void => {
+	if (isRenamePromptItem(selection)) {
+		const to = selection.to;
+
+		const schemaFromPrefix = newItem.schema ? newItem.schema !== defaultSchema ? `${newItem.schema}.` : '' : '';
+		const tableFromPrefix = newItem.table ? `${newItem.table}.` : '';
+		const fromEntity = `${schemaFromPrefix}${tableFromPrefix}${selection.from.name}`;
+
+		const schemaToPrefix = to.schema ? to.schema !== defaultSchema ? `${to.schema}.` : '' : '';
+		const tableToPrefix = to.table ? `${to.table}.` : '';
+		const toEntity = `${schemaToPrefix}${tableToPrefix}${to.name}`;
+
+		humanLog(
+			`${chalk.yellow('~')} ${fromEntity} › ${toEntity} ${chalk.gray(`${humanizeKind(entity)} will be renamed/moved`)}`,
+		);
+
+		result.renamedOrMoved.push(selection);
+		const idx = leftMissing.indexOf(selection.from);
+		if (idx === -1) {
+			throw new Error(
+				`applySelection: rename source not present in leftMissing for ${entity} ${selection.from.name}`,
+			);
+		}
+		delete leftMissing[idx];
+		return;
+	}
+
+	humanLog(`${chalk.green('+')} ${newItem.name} ${chalk.gray(`${humanizeKind(entity)} will be created`)}`);
+	result.created.push(newItem);
+};
diff --git a/drizzle-kit/src/cli/schema.ts b/drizzle-kit/src/cli/schema.ts
index 5f9651c1d7..6609810c6d 100644
--- a/drizzle-kit/src/cli/schema.ts
+++ b/drizzle-kit/src/cli/schema.ts
@@ -1,23 +1,26 @@
-import { boolean, command, number, string } from '@drizzle-team/brocli';
+import { boolean, command, type GenericBuilderInternals, number, string } from '@drizzle-team/brocli';
 import chalk from 'chalk';
-import 'dotenv/config';
 import { mkdirSync } from 'fs';
 import { renderWithTask } from 'hanji';
-import { dialects } from 'src/schemaValidator';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { dialects } from '../utils/schemaValidator';
 import '../@types/utils';
-import { assertUnreachable } from '../global';
-import { type Setup } from '../serializer/studio';
-import { assertV1OutFolder } from '../utils';
-import { certs } from '../utils/certs';
+import type { MigrationConfig, MigratorInitFailResponse } from 'drizzle-orm/migrator';
+import { assertUnreachable } from '../utils';
+import { assertV3OutFolder } from '../utils/utils-node';
 import { checkHandler } from './commands/check';
-import { dropMigration } from './commands/drop';
-import { upMysqlHandler } from './commands/mysqlUp';
-import { upPgHandler } from './commands/pgUp';
-import { upSinglestoreHandler } from './commands/singlestoreUp';
-import { upSqliteHandler } from './commands/sqliteUp';
+import type { Setup } from './commands/studio';
+import { upCockroachHandler } from './commands/up-cockroach';
+import { upMssqlHandler } from './commands/up-mssql';
+import { upMysqlHandler } from './commands/up-mysql';
+import { upPgHandler } from './commands/up-postgres';
+import { upSinglestoreHandler } from './commands/up-singlestore';
+import { upSqliteHandler } from './commands/up-sqlite';
 import {
+	type CheckConfig,
 	prepareCheckParams,
-	prepareDropParams,
 	prepareExportConfig,
 	prepareGenerateConfig,
 	prepareMigrateConfig,
@@ -25,15 +28,280 @@ import {
 	preparePushConfig,
 	prepareStudioConfig,
 } from './commands/utils';
+import { outputFormat, setCliContext } from './context';
+import type {
+	CheckOptionsInput,
+	ExportOptionsInput,
+	GenerateOptionsInput,
+	PullOptionsInput,
+	PushOptionsInput,
+	UpOptionsInput,
+} from './contract';
+import {
+	CommandOutputCliError,
+	DatabaseDriverCliError,
+	OrmDriverVersionCliError,
+	UnsupportedCommandCliError,
+	UnsupportedCommandDialectCliError,
+} from './errors';
+import { formatMissingHintsText } from './missing-hints-report';
 import { assertOrmCoreVersion, assertPackages, assertStudioNodeVersion, ormVersionGt } from './utils';
-import { assertCollisions, drivers, prefixes } from './validations/common';
+import { assertCollisions, drivers } from './validations/common';
+import type { LibSQLCredentials } from './validations/libsql';
 import { withStyle } from './validations/outputs';
-import { error, grey, MigrateProgress } from './views';
+import type { SqliteCredentials } from './validations/sqlite';
+import { grey, MigrateProgress } from './views';
+
+type EnvelopeStatus =
+	| Awaited<ReturnType<typeof runGenerate>>['status']
+	| Awaited<ReturnType<typeof runPush>>['status']
+	| 'error';
+
+// Identify already-typed CLI errors structurally rather than via instanceof: under
+// test module-resetting the errors module can be duplicated, breaking instanceof.
+const isTypedCliError = (e: unknown): boolean =>
+	e instanceof Error && typeof (e as { code?: unknown }).code === 'string'
+	&& typeof (e as { humanMessage?: unknown }).humanMessage === 'string';
+
+export const statusToExitCode = (status: EnvelopeStatus): 0 | 1 | 2 => {
+	switch (status) {
+		case 'ok':
+			return 0;
+		case 'no_changes':
+			return 0;
+		case 'missing_hints':
+			return 2;
+		case 'error':
+			return 1;
+		default:
+			assertUnreachable(status);
+	}
+};
+
+export const prepareGenerate = async (opts: GenerateOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions(
+		'generate',
+		opts,
+		['name', 'custom', 'ignoreConflicts', 'explain', 'output', 'hints', 'hintsFile'],
+		['driver', 'breakpoints', 'schema', 'out', 'dialect'],
+	);
+	return prepareGenerateConfig(opts as Parameters<typeof prepareGenerateConfig>[0], from);
+};
+
+export const runGenerate = async (
+	config: Awaited<ReturnType<typeof prepareGenerate>>,
+) => {
+	await assertOrmCoreVersion();
+	await assertPackages('drizzle-orm');
+
+	assertV3OutFolder(config.out);
+
+	const dialect = config.dialect;
+	const checkResult = await checkHandler(
+		config.out,
+		dialect,
+		config.ignoreConflicts,
+	);
+
+	if (dialect === 'postgresql') {
+		const { handle } = await import('./commands/generate-postgres');
+		return await handle(config as Parameters<typeof handle>[0], checkResult);
+	} else if (dialect === 'mysql') {
+		const { handle } = await import('./commands/generate-mysql');
+		return await handle(config, checkResult);
+	} else if (dialect === 'sqlite') {
+		const { handle } = await import('./commands/generate-sqlite');
+		return await handle(config as Parameters<typeof handle>[0], checkResult);
+	} else if (dialect === 'turso') {
+		const { handle } = await import('./commands/generate-libsql');
+		return await handle(config as Parameters<typeof handle>[0], checkResult);
+	} else if (dialect === 'singlestore') {
+		const { handle } = await import('./commands/generate-singlestore');
+		return await handle(config);
+	} else if (dialect === 'mssql') {
+		const { handle } = await import('./commands/generate-mssql');
+		return await handle(config);
+	} else if (dialect === 'cockroach') {
+		const { handle } = await import('./commands/generate-cockroach');
+		return await handle(config);
+	} else if (dialect === 'duckdb') {
+		throw new UnsupportedCommandCliError(
+			'generate',
+			"You can't use 'generate' command with DuckDb dialect",
+			{
+				dialect: 'DuckDb',
+			},
+		);
+	}
+	assertUnreachable(dialect);
+};
+
+export const preparePush = async (opts: PushOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions(
+		'push',
+		opts,
+		['force', 'verbose', 'strict', 'explain', 'output', 'hints', 'hintsFile'],
+		[
+			'schema',
+			'dialect',
+			'driver',
+			'url',
+			'host',
+			'port',
+			'user',
+			'password',
+			'database',
+			'ssl',
+			'authToken',
+			'schemaFilters',
+			'extensionsFilters',
+			'tablesFilter',
+			'tlsSecurity',
+		],
+	);
+
+	if (typeof opts.strict !== 'undefined') {
+		throw new UnsupportedCommandCliError(
+			'push',
+			withStyle.fullWarning("⚠️ Deprecated: Do not use 'strict' flag. Use 'explain' instead"),
+			{ option: 'strict' },
+		);
+	}
+
+	return preparePushConfig(opts, from);
+};
+
+export const runPush = async (
+	config: Awaited<ReturnType<typeof preparePush>>,
+) => {
+	await assertPackages('drizzle-orm');
+	await assertOrmCoreVersion();
+
+	const {
+		dialect,
+		verbose,
+		credentials,
+		force,
+		filters,
+		explain,
+		migrations,
+		filenames,
+		hints,
+	} = config;
+
+	if (dialect === 'mysql') {
+		const { handle } = await import('./commands/push-mysql');
+		return await handle(
+			filenames,
+			credentials,
+			verbose,
+			force,
+			filters,
+			explain,
+			migrations,
+			hints,
+		);
+	} else if (dialect === 'postgresql') {
+		if ('driver' in credentials) {
+			const { driver } = credentials;
+			if (driver === 'aws-data-api' && !(await ormVersionGt('0.30.10'))) {
+				throw new OrmDriverVersionCliError(
+					'aws-data-api',
+					'0.30.10',
+					"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
+				);
+			}
+			if (driver === 'pglite' && !(await ormVersionGt('0.30.6'))) {
+				throw new OrmDriverVersionCliError(
+					'pglite',
+					'0.30.6',
+					"To use 'pglite' driver - please update drizzle-orm to the latest version",
+				);
+			}
+		}
+
+		const { SchemaSource } = await import('../dialects/postgres/drizzle');
+		const { handle } = await import('./commands/push-postgres');
+		return await handle(
+			SchemaSource.fromFilenames(filenames),
+			verbose,
+			credentials,
+			filters,
+			force,
+			explain,
+			migrations,
+			hints,
+		);
+	} else if (dialect === 'sqlite' || dialect === 'turso') {
+		const { connectToSQLite, connectToTursoRemote: connectToLibSQL } = await import('./connections');
+		const db = dialect === 'sqlite'
+			? await connectToSQLite(credentials as SqliteCredentials)
+			: await connectToLibSQL(credentials as LibSQLCredentials);
+
+		const { SchemaSource } = await import('../dialects/sqlite/drizzle');
+		const { handle: sqlitePush } = await import('./commands/push-sqlite');
+		return await sqlitePush(
+			db,
+			SchemaSource.fromFilenames(filenames),
+			verbose,
+			credentials,
+			filters,
+			force,
+			explain,
+			migrations,
+			dialect === 'turso' ? 'turso' : 'sqlite',
+			hints,
+		);
+	} else if (dialect === 'singlestore') {
+		const { handle } = await import('./commands/push-singlestore');
+		return await handle(
+			filenames,
+			credentials,
+			filters,
+			verbose,
+			force,
+			explain,
+			migrations,
+			hints,
+		);
+	} else if (dialect === 'cockroach') {
+		const { handle } = await import('./commands/push-cockroach');
+		return await handle(
+			filenames,
+			verbose,
+			credentials,
+			filters,
+			force,
+			explain,
+			migrations,
+			hints,
+		);
+	} else if (dialect === 'mssql') {
+		const { handle } = await import('./commands/push-mssql');
+		return await handle(
+			filenames,
+			verbose,
+			credentials,
+			filters,
+			force,
+			explain,
+			migrations,
+			hints,
+		);
+	}
+	assertUnreachable(dialect);
+};
 
 const optionDialect = string('dialect')
 	.enum(...dialects)
 	.desc(
-		`Database dialect: 'gel', 'postgresql', 'mysql', 'sqlite', 'turso' or 'singlestore'`,
+		`Database dialect: 'postgresql', 'mysql', 'sqlite', 'turso', 'singlestore', 'duckdb' or 'mssql'`,
 	);
 const optionOut = string().desc("Output folder, 'drizzle' by default");
 const optionConfig = string().desc('Path to drizzle config file');
@@ -45,70 +313,42 @@ const optionDriver = string()
 	.enum(...drivers)
 	.desc('Database driver');
 
-const optionCasing = string().enum('camelCase', 'snake_case').desc('Casing for serialization');
+const optionIgnoreConflicts = boolean('ignore-conflicts').desc(
+	'Skip commutativity conflict checks',
+);
+const optionHints = string().desc('Inline JSON array of hints');
+const optionHintsFile = string('hints-file').desc('Path to a JSON file containing a hints array');
+const optionOutput = string('output').enum('text', 'json').desc('Output format').default('text');
+
+export const generateOptions = {
+	config: optionConfig,
+	dialect: optionDialect,
+	driver: optionDriver,
+	schema: string().desc('Path to a schema file or folder'),
+	out: optionOut,
+	name: string().desc('Migration file name'),
+	breakpoints: optionBreakpoints,
+	custom: boolean()
+		.desc('Prepare empty migration file for custom SQL')
+		.default(false),
+	ignoreConflicts: optionIgnoreConflicts,
+	explain: boolean()
+		.desc('Print the planned SQL changes (dry run)')
+		.default(false),
+	output: optionOutput,
+	hints: optionHints,
+	hintsFile: optionHintsFile,
+} as const satisfies Record<string, GenericBuilderInternals>;
 
 export const generate = command({
 	name: 'generate',
-	options: {
-		config: optionConfig,
-		dialect: optionDialect,
-		driver: optionDriver,
-		casing: optionCasing,
-		schema: string().desc('Path to a schema file or folder'),
-		out: optionOut,
-		name: string().desc('Migration file name'),
-		breakpoints: optionBreakpoints,
-		custom: boolean()
-			.desc('Prepare empty migration file for custom SQL')
-			.default(false),
-		prefix: string()
-			.enum(...prefixes)
-			.default('index'),
-	},
-	transform: async (opts) => {
-		const from = assertCollisions(
-			'generate',
-			opts,
-			['prefix', 'name', 'custom'],
-			['driver', 'breakpoints', 'schema', 'out', 'dialect', 'casing'],
-		);
-		return prepareGenerateConfig(opts, from);
-	},
-	handler: async (opts) => {
-		await assertOrmCoreVersion();
-		await assertPackages('drizzle-orm');
-
-		// const parsed = cliConfigGenerate.parse(opts);
-
-		const {
-			prepareAndMigratePg,
-			prepareAndMigrateMysql,
-			prepareAndMigrateSqlite,
-			prepareAndMigrateLibSQL,
-			prepareAndMigrateSingleStore,
-		} = await import('./commands/migrate');
-
-		const dialect = opts.dialect;
-		if (dialect === 'postgresql') {
-			await prepareAndMigratePg(opts);
-		} else if (dialect === 'mysql') {
-			await prepareAndMigrateMysql(opts);
-		} else if (dialect === 'sqlite') {
-			await prepareAndMigrateSqlite(opts);
-		} else if (dialect === 'turso') {
-			await prepareAndMigrateLibSQL(opts);
-		} else if (dialect === 'singlestore') {
-			await prepareAndMigrateSingleStore(opts);
-		} else if (dialect === 'gel') {
-			console.log(
-				error(
-					`You can't use 'generate' command with Gel dialect`,
-				),
-			);
-			process.exit(1);
-		} else {
-			assertUnreachable(dialect);
-		}
+	options: generateOptions,
+	transform: prepareGenerate,
+	handler: async (cfg) => {
+		const env = await runGenerate(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		else if (env.status === 'missing_hints') process.stdout.write(formatMissingHintsText(env));
+		process.exit(statusToExitCode(env.status));
 	},
 });
 
@@ -116,107 +356,125 @@ export const migrate = command({
 	name: 'migrate',
 	options: {
 		config: optionConfig,
+		ignoreConflicts: optionIgnoreConflicts,
 	},
 	transform: async (opts) => {
-		return await prepareMigrateConfig(opts.config);
+		const migrateConf = await prepareMigrateConfig(opts.config);
+		return {
+			...migrateConf,
+			...(opts.ignoreConflicts !== undefined && {
+				ignoreConflicts: opts.ignoreConflicts,
+			}),
+		};
 	},
 	handler: async (opts) => {
 		await assertOrmCoreVersion();
 		await assertPackages('drizzle-orm');
+		assertV3OutFolder(opts.out);
+		const { dialect, schema, table, out, credentials, ignoreConflicts } = opts;
 
-		const { dialect, schema, table, out, credentials } = opts;
-		try {
-			if (dialect === 'postgresql') {
-				if ('driver' in credentials) {
-					const { driver } = credentials;
-					if (driver === 'aws-data-api') {
-						if (!(await ormVersionGt('0.30.10'))) {
-							console.log(
-								"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else if (driver === 'pglite') {
-						if (!(await ormVersionGt('0.30.6'))) {
-							console.log(
-								"To use 'pglite' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else {
-						assertUnreachable(driver);
+		await checkHandler(out, dialect, ignoreConflicts);
+
+		if (dialect === 'postgresql') {
+			if ('driver' in credentials) {
+				const { driver } = credentials;
+				if (driver === 'aws-data-api') {
+					if (!(await ormVersionGt('0.30.10'))) {
+						console.log(
+							"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
+						);
+						process.exit(1);
 					}
+				} else if (driver === 'pglite') {
+					if (!(await ormVersionGt('0.30.6'))) {
+						console.log(
+							"To use 'pglite' driver - please update drizzle-orm to the latest version",
+						);
+						process.exit(1);
+					}
+				} else {
+					assertUnreachable(driver);
 				}
-				const { preparePostgresDB } = await import('./connections');
-				const { migrate } = await preparePostgresDB(credentials);
-				await renderWithTask(
-					new MigrateProgress(),
-					migrate({
-						migrationsFolder: out,
-						migrationsTable: table,
-						migrationsSchema: schema,
-					}),
-				);
-			} else if (dialect === 'mysql') {
-				const { connectToMySQL } = await import('./connections');
-				const { migrate } = await connectToMySQL(credentials);
-				await renderWithTask(
-					new MigrateProgress(),
-					migrate({
-						migrationsFolder: out,
-						migrationsTable: table,
-						migrationsSchema: schema,
-					}),
-				);
-			} else if (dialect === 'singlestore') {
-				const { connectToSingleStore } = await import('./connections');
-				const { migrate } = await connectToSingleStore(credentials);
-				await renderWithTask(
-					new MigrateProgress(),
-					migrate({
-						migrationsFolder: out,
-						migrationsTable: table,
-						migrationsSchema: schema,
-					}),
-				);
-			} else if (dialect === 'sqlite') {
-				const { connectToSQLite } = await import('./connections');
-				const { migrate } = await connectToSQLite(credentials);
-				await renderWithTask(
-					new MigrateProgress(),
-					migrate({
-						migrationsFolder: opts.out,
-						migrationsTable: table,
-						migrationsSchema: schema,
-					}),
-				);
-			} else if (dialect === 'turso') {
-				const { connectToLibSQL } = await import('./connections');
-				const { migrate } = await connectToLibSQL(credentials);
-				await renderWithTask(
-					new MigrateProgress(),
-					migrate({
-						migrationsFolder: opts.out,
-						migrationsTable: table,
-						migrationsSchema: schema,
-					}),
-				);
-			} else if (dialect === 'gel') {
-				console.log(
-					error(
-						`You can't use 'migrate' command with Gel dialect`,
-					),
-				);
-				process.exit(1);
-			} else {
-				assertUnreachable(dialect);
 			}
-		} catch (e) {
-			console.error(e);
-			process.exit(1);
+			const { preparePostgresDB } = await import('./connections');
+			const { migrate } = await preparePostgresDB(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'mysql') {
+			const { connectToMySQL } = await import('./connections');
+			const { migrate } = await connectToMySQL(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'singlestore') {
+			const { connectToSingleStore } = await import('./connections');
+			const { migrate } = await connectToSingleStore(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'sqlite') {
+			const { connectToSQLite } = await import('./connections');
+			const { migrate } = await connectToSQLite(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: opts.out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'turso') {
+			const { connectToTursoRemote: connectToLibSQL } = await import('./connections');
+			const { migrate } = await connectToLibSQL(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: opts.out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'cockroach') {
+			const { prepareCockroach } = await import('./connections');
+			const { migrate } = await prepareCockroach(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else if (dialect === 'mssql') {
+			const { connectToMsSQL } = await import('./connections');
+			const { migrate } = await connectToMsSQL(credentials);
+			await renderWithTask(
+				new MigrateProgress(),
+				migrate({
+					migrationsFolder: out,
+					migrationsTable: table,
+					migrationsSchema: schema,
+				}),
+			);
+		} else {
+			assertUnreachable(dialect);
 		}
-
-		process.exit(0);
 	},
 });
 
@@ -244,408 +502,447 @@ const optionsDatabaseCredentials = {
 	driver: optionDriver,
 } as const;
 
+export const pushOptions = {
+	config: optionConfig,
+	dialect: optionDialect,
+	schema: string().desc('Path to a schema file or folder'),
+	...optionsFilters,
+	...optionsDatabaseCredentials,
+	verbose: boolean()
+		.desc('Print all statements for each push')
+		.default(false),
+	strict: boolean().desc('Always ask for confirmation'),
+	force: boolean()
+		.desc(
+			'Auto-approve all data loss statements. Note: Data loss statements may truncate your tables and data',
+		)
+		.default(false),
+	output: optionOutput,
+	explain: boolean()
+		.desc('Print the planned SQL changes (dry run)')
+		.default(false),
+	hints: optionHints,
+	hintsFile: optionHintsFile,
+} as const satisfies Record<string, GenericBuilderInternals>;
+
 export const push = command({
 	name: 'push',
-	options: {
-		config: optionConfig,
-		dialect: optionDialect,
-		casing: optionCasing,
-		schema: string().desc('Path to a schema file or folder'),
-		...optionsFilters,
-		...optionsDatabaseCredentials,
-		verbose: boolean()
-			.desc('Print all statements for each push')
-			.default(false),
-		strict: boolean().desc('Always ask for confirmation').default(false),
-		force: boolean()
-			.desc(
-				'Auto-approve all data loss statements. Note: Data loss statements may truncate your tables and data',
-			)
-			.default(false),
-	},
-	transform: async (opts) => {
-		const from = assertCollisions(
-			'push',
-			opts,
-			['force', 'verbose', 'strict'],
-			[
-				'schema',
-				'dialect',
-				'driver',
-				'url',
-				'host',
-				'port',
-				'user',
-				'password',
-				'database',
-				'ssl',
-				'authToken',
-				'schemaFilters',
-				'extensionsFilters',
-				'tablesFilter',
-				'casing',
-				'tlsSecurity',
-			],
-		);
-
-		return preparePushConfig(opts, from);
+	options: pushOptions,
+	transform: preparePush,
+	handler: async (cfg) => {
+		const env = await runPush(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		else if (env.status === 'missing_hints') process.stdout.write(formatMissingHintsText(env));
+		process.exit(statusToExitCode(env.status));
 	},
-	handler: async (config) => {
-		await assertPackages('drizzle-orm');
-		await assertOrmCoreVersion();
+});
 
-		const {
-			dialect,
-			schemaPath,
-			strict,
-			verbose,
-			credentials,
-			tablesFilter,
-			schemasFilter,
-			force,
-			casing,
-			entities,
-		} = config;
+export const checkOptions = {
+	config: optionConfig,
+	dialect: optionDialect,
+	out: optionOut,
+	ignoreConflicts: optionIgnoreConflicts,
+	output: optionOutput,
+} as const satisfies Record<string, GenericBuilderInternals>;
 
-		try {
-			if (dialect === 'mysql') {
-				const { mysqlPush } = await import('./commands/push');
-				await mysqlPush(
-					schemaPath,
-					credentials,
-					tablesFilter,
-					strict,
-					verbose,
-					force,
-					casing,
-				);
-			} else if (dialect === 'postgresql') {
-				if ('driver' in credentials) {
-					const { driver } = credentials;
-					if (driver === 'aws-data-api') {
-						if (!(await ormVersionGt('0.30.10'))) {
-							console.log(
-								"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else if (driver === 'pglite') {
-						if (!(await ormVersionGt('0.30.6'))) {
-							console.log(
-								"To use 'pglite' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else {
-						assertUnreachable(driver);
-					}
-				}
+export const prepareCheck = async (opts: CheckOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions(
+		'check',
+		opts,
+		['ignoreConflicts', 'output'],
+		['dialect', 'out'],
+	);
+	const config: CheckConfig & { output: 'text' | 'json' } = {
+		...(await prepareCheckParams(opts, from)),
+		ignoreConflicts: opts.ignoreConflicts,
+		output,
+	};
+	return config;
+};
 
-				const { pgPush } = await import('./commands/push');
-				await pgPush(
-					schemaPath,
-					verbose,
-					strict,
-					credentials,
-					tablesFilter,
-					schemasFilter,
-					entities,
-					force,
-					casing,
-				);
-			} else if (dialect === 'sqlite') {
-				const { sqlitePush } = await import('./commands/push');
-				await sqlitePush(
-					schemaPath,
-					verbose,
-					strict,
-					credentials,
-					tablesFilter,
-					force,
-					casing,
-				);
-			} else if (dialect === 'turso') {
-				const { libSQLPush } = await import('./commands/push');
-				await libSQLPush(
-					schemaPath,
-					verbose,
-					strict,
-					credentials,
-					tablesFilter,
-					force,
-					casing,
-				);
-			} else if (dialect === 'singlestore') {
-				const { singlestorePush } = await import('./commands/push');
-				await singlestorePush(
-					schemaPath,
-					credentials,
-					tablesFilter,
-					strict,
-					verbose,
-					force,
-					casing,
-				);
-			} else if (dialect === 'gel') {
-				console.log(
-					error(
-						`You can't use 'push' command with Gel dialect`,
-					),
-				);
-				process.exit(1);
-			} else {
-				assertUnreachable(dialect);
-			}
-		} catch (e) {
-			console.error(e);
-		}
-		process.exit(0);
-	},
-});
+export const runCheck = async (
+	config: Awaited<ReturnType<typeof prepareCheck>>,
+) => {
+	await assertOrmCoreVersion();
+	assertV3OutFolder(config.out);
+	const { out, dialect, ignoreConflicts } = config;
+	await checkHandler(out, dialect, ignoreConflicts);
+	return { status: 'ok' as const, dialect };
+};
 
 export const check = command({
 	name: 'check',
-	options: {
-		config: optionConfig,
-		dialect: optionDialect,
-		out: optionOut,
-	},
-	transform: async (opts) => {
-		const from = assertCollisions('check', opts, [], ['dialect', 'out']);
-		return prepareCheckParams(opts, from);
-	},
-	handler: async (config) => {
-		await assertOrmCoreVersion();
-
-		const { out, dialect } = config;
-		checkHandler(out, dialect);
-		console.log("Everything's fine 🐶🔥");
+	options: checkOptions,
+	transform: prepareCheck,
+	handler: async (cfg) => {
+		const env = await runCheck(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		else console.log("Everything's fine 🐶🔥");
+		process.exit(statusToExitCode(env.status));
 	},
 });
 
+export const upOptions = {
+	config: optionConfig,
+	dialect: optionDialect,
+	out: optionOut,
+	output: optionOutput,
+} as const satisfies Record<string, GenericBuilderInternals>;
+
+export const prepareUp = async (opts: UpOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions('up', opts, ['output'], ['dialect', 'out']);
+	const config = { ...(await prepareCheckParams(opts, from)), output };
+	return config;
+};
+
+export const runUp = async (
+	config: Awaited<ReturnType<typeof prepareUp>>,
+) => {
+	await assertOrmCoreVersion();
+	await assertPackages('drizzle-orm');
+
+	const { out, dialect } = config;
+	let upgraded: string[];
+	if (dialect === 'postgresql') {
+		upgraded = upPgHandler(out);
+	} else if (dialect === 'mysql') {
+		upgraded = upMysqlHandler(out);
+	} else if (dialect === 'sqlite' || dialect === 'turso') {
+		upgraded = upSqliteHandler(out);
+	} else if (dialect === 'singlestore') {
+		upgraded = upSinglestoreHandler(out);
+	} else if (dialect === 'cockroach') {
+		upgraded = upCockroachHandler(out);
+	} else if (dialect === 'mssql') {
+		upgraded = upMssqlHandler(out);
+	} else if (dialect === 'duckdb') {
+		throw new UnsupportedCommandDialectCliError('up', 'duckdb');
+	} else {
+		assertUnreachable(dialect);
+	}
+
+	return { status: 'ok' as const, dialect, upgraded };
+};
+
 export const up = command({
 	name: 'up',
-	options: {
-		config: optionConfig,
-		dialect: optionDialect,
-		out: optionOut,
-	},
-	transform: async (opts) => {
-		const from = assertCollisions('check', opts, [], ['dialect', 'out']);
-		return prepareCheckParams(opts, from);
+	options: upOptions,
+	transform: prepareUp,
+	handler: async (cfg) => {
+		const env = await runUp(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		process.exit(statusToExitCode(env.status));
 	},
-	handler: async (config) => {
-		await assertOrmCoreVersion();
+});
 
-		const { out, dialect } = config;
-		await assertPackages('drizzle-orm');
+export const pullOptions = {
+	config: optionConfig,
+	dialect: optionDialect,
+	out: optionOut,
+	breakpoints: optionBreakpoints,
+	casing: string('introspect-casing').enum('camel', 'preserve'),
+	init: boolean('init').desc(
+		'Create migration metadata for pulled schema in database',
+	),
+	...optionsFilters,
+	...optionsDatabaseCredentials,
+	output: optionOutput,
+} as const satisfies Record<string, GenericBuilderInternals>;
 
-		if (dialect === 'postgresql') {
-			upPgHandler(out);
+export const preparePull = async (opts: PullOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions(
+		'introspect',
+		opts,
+		['init', 'output'],
+		[
+			'dialect',
+			'driver',
+			'out',
+			'url',
+			'host',
+			'port',
+			'user',
+			'password',
+			'database',
+			'ssl',
+			'authToken',
+			'casing',
+			'breakpoints',
+			'tablesFilter',
+			'schemaFilters',
+			'extensionsFilters',
+			'tlsSecurity',
+		],
+	);
+	return { ...(await preparePullConfig(opts, from)), output };
+};
+
+type PullManifest = {
+	schemaPath: string;
+	relationsPath?: string;
+	snapshotPath: string;
+	migrationPath?: string;
+};
+
+export const runPull = async (
+	config: Awaited<ReturnType<typeof preparePull>>,
+) => {
+	await assertPackages('drizzle-orm');
+	await assertOrmCoreVersion();
+
+	const {
+		dialect,
+		credentials,
+		out,
+		casing,
+		breakpoints,
+		filters,
+		init,
+		migrations,
+	} = config;
+	mkdirSync(out, { recursive: true });
+
+	let migrate:
+		| ((config: MigrationConfig) => Promise<void | MigratorInitFailResponse>)
+		| undefined;
+	// Redaction descriptor captured per-dialect so the `--init` migrate span can
+	// re-throw driver failures as the same DatabaseDriverCliError used above,
+	// instead of leaking QueryError sql/params/credentials into the json envelope.
+	let driverError: { database: string; packages: string[]; message: string } | undefined;
+	let manifest: PullManifest;
+	if (dialect === 'postgresql') {
+		if ('driver' in credentials) {
+			const { driver } = credentials;
+			if (driver === 'aws-data-api' && !(await ormVersionGt('0.30.10'))) {
+				throw new OrmDriverVersionCliError(
+					'aws-data-api',
+					'0.30.10',
+					"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
+				);
+			}
+			if (driver === 'pglite' && !(await ormVersionGt('0.30.6'))) {
+				throw new OrmDriverVersionCliError(
+					'pglite',
+					'0.30.6',
+					"To use 'pglite' driver - please update drizzle-orm to the latest version",
+				);
+			}
 		}
 
-		if (dialect === 'mysql') {
-			upMysqlHandler(out);
+		// connectX returns lazy query proxies; runtime connect/introspect failures
+		// surface as QueryError and would leak sql/params/credentials into the
+		// envelope, so re-throw as a redacted DatabaseDriverCliError.
+		try {
+			const { preparePostgresDB } = await import('./connections');
+			const db = await preparePostgresDB(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'postgresql',
+				packages: ['pg', 'postgres', 'bun', '@neondatabase/serverless', '@vercel/postgres'],
+				message: 'Failed to connect to or introspect the Postgres database',
+			};
+
+			const { handle: introspectPostgres } = await import(
+				'./commands/pull-postgres'
+			);
+			manifest = await introspectPostgres(casing, out, breakpoints, credentials, filters, migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'postgresql',
+				['pg', 'postgres', 'bun', '@neondatabase/serverless', '@vercel/postgres'],
+				'Failed to connect to or introspect the Postgres database',
+			);
 		}
+	} else if (dialect === 'mysql') {
+		try {
+			const { connectToMySQL } = await import('./connections');
+			const db = await connectToMySQL(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'mysql',
+				packages: ['mysql2', 'bun', '@planetscale/database'],
+				message: 'Failed to connect to or introspect the MySQL database',
+			};
 
-		if (dialect === 'sqlite' || dialect === 'turso') {
-			upSqliteHandler(out);
+			const { handle: introspectMysql } = await import('./commands/pull-mysql');
+			manifest = await introspectMysql(casing, out, breakpoints, credentials, filters, migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'mysql',
+				['mysql2', 'bun', '@planetscale/database'],
+				'Failed to connect to or introspect the MySQL database',
+			);
 		}
+	} else if (dialect === 'sqlite') {
+		try {
+			const { connectToSQLite } = await import('./connections');
+			const db = await connectToSQLite(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'sqlite',
+				packages: ['better-sqlite3', 'bun', '@libsql/client', '@tursodatabase/database', 'node:sqlite'],
+				message: 'Failed to connect to or introspect the SQLite database',
+			};
 
-		if (dialect === 'singlestore') {
-			upSinglestoreHandler(out);
+			const { handle } = await import('./commands/pull-sqlite');
+			manifest = await handle(casing, out, breakpoints, credentials, filters, 'sqlite', migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'sqlite',
+				['better-sqlite3', 'bun', '@libsql/client', '@tursodatabase/database', 'node:sqlite'],
+				'Failed to connect to or introspect the SQLite database',
+			);
 		}
+	} else if (dialect === 'turso') {
+		try {
+			const { connectToTursoRemote: connectToLibSQL } = await import('./connections');
+			const db = await connectToLibSQL(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'turso',
+				packages: ['@libsql/client', '@tursodatabase/database', '@tursodatabase/serverless'],
+				message: 'Failed to connect to or introspect the Turso database',
+			};
 
-		if (dialect === 'gel') {
-			console.log(
-				error(
-					`You can't use 'up' command with Gel dialect`,
-				),
+			const { handle } = await import('./commands/pull-libsql');
+			manifest = await handle(casing, out, breakpoints, credentials, filters, 'libsql', migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'turso',
+				['@libsql/client', '@tursodatabase/database', '@tursodatabase/serverless'],
+				'Failed to connect to or introspect the Turso database',
 			);
-			process.exit(1);
 		}
-	},
-});
+	} else if (dialect === 'singlestore') {
+		try {
+			const { connectToSingleStore } = await import('./connections');
+			const db = await connectToSingleStore(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'singlestore',
+				packages: ['mysql2'],
+				message: 'Failed to connect to or introspect the SingleStore database',
+			};
 
-export const pull = command({
-	name: 'introspect',
-	aliases: ['pull'],
-	options: {
-		config: optionConfig,
-		dialect: optionDialect,
-		out: optionOut,
-		breakpoints: optionBreakpoints,
-		casing: string('introspect-casing').enum('camel', 'preserve'),
-		...optionsFilters,
-		...optionsDatabaseCredentials,
-	},
-	transform: async (opts) => {
-		const from = assertCollisions(
-			'introspect',
-			opts,
-			[],
-			[
-				'dialect',
-				'driver',
-				'out',
-				'url',
-				'host',
-				'port',
-				'user',
-				'password',
-				'database',
-				'ssl',
-				'authToken',
-				'casing',
-				'breakpoints',
-				'tablesFilter',
-				'schemaFilters',
-				'extensionsFilters',
-				'tlsSecurity',
-			],
-		);
-		return preparePullConfig(opts, from);
-	},
-	handler: async (config) => {
-		await assertPackages('drizzle-orm');
-		await assertOrmCoreVersion();
+			const { handle } = await import('./commands/pull-singlestore');
+			manifest = await handle(casing, out, breakpoints, credentials, filters, migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'singlestore',
+				['mysql2'],
+				'Failed to connect to or introspect the SingleStore database',
+			);
+		}
+	} else if (dialect === 'mssql') {
+		try {
+			const { connectToMsSQL } = await import('./connections');
+			const db = await connectToMsSQL(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'mssql',
+				packages: ['mssql'],
+				message: 'Failed to connect to or introspect the MsSQL database',
+			};
 
-		const {
-			dialect,
-			credentials,
-			out,
-			casing,
-			breakpoints,
-			tablesFilter,
-			schemasFilter,
-			prefix,
-			entities,
-		} = config;
-		mkdirSync(out, { recursive: true });
-
-		console.log(
-			grey(
-				`Pulling from [${
-					schemasFilter
-						.map((it) => `'${it}'`)
-						.join(', ')
-				}] list of schemas`,
-			),
-		);
-		console.log();
+			const { handle } = await import('./commands/pull-mssql');
+			manifest = await handle(casing, out, breakpoints, credentials, filters, migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'mssql',
+				['mssql'],
+				'Failed to connect to or introspect the MsSQL database',
+			);
+		}
+	} else if (dialect === 'cockroach') {
+		try {
+			const { prepareCockroach } = await import('./connections');
+			const db = await prepareCockroach(credentials);
+			migrate = db.migrate;
+			driverError = {
+				database: 'cockroach',
+				packages: ['pg'],
+				message: 'Failed to connect to or introspect the Cockroach database',
+			};
+
+			const { handle } = await import('./commands/pull-cockroach');
+			manifest = await handle(casing, out, breakpoints, credentials, filters, migrations, db);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(
+				'cockroach',
+				['pg'],
+				'Failed to connect to or introspect the Cockroach database',
+			);
+		}
+	} else {
+		assertUnreachable(dialect);
+	}
+
+	if (init) {
+		if (outputFormat() === 'text') {
+			console.log();
+			console.log(grey('Applying migration metadata to the database'));
+		}
+
+		const migrateInput = {
+			migrationsFolder: out,
+			migrationsTable: migrations.table,
+			migrationsSchema: migrations.schema,
+			// Internal param - won't be displayed in types. Do not remove.
+			init: true,
+		};
 
+		// migrate() runs live driver queries; an unexpected failure throws a raw
+		// QueryError carrying sql/params (and possibly credentials in e.message),
+		// so re-throw it redacted exactly like the connect/introspect span above.
+		let error: void | MigratorInitFailResponse;
 		try {
-			if (dialect === 'postgresql') {
-				if ('driver' in credentials) {
-					const { driver } = credentials;
-					if (driver === 'aws-data-api') {
-						if (!(await ormVersionGt('0.30.10'))) {
-							console.log(
-								"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else if (driver === 'pglite') {
-						if (!(await ormVersionGt('0.30.6'))) {
-							console.log(
-								"To use 'pglite' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else {
-						assertUnreachable(driver);
-					}
-				}
+			error = await migrate!(migrateInput);
+		} catch (e) {
+			if (isTypedCliError(e)) throw e;
+			throw new DatabaseDriverCliError(driverError!.database, driverError!.packages, driverError!.message);
+		}
 
-				const { introspectPostgres } = await import('./commands/introspect');
-				await introspectPostgres(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					schemasFilter,
-					prefix,
-					entities,
-				);
-			} else if (dialect === 'mysql') {
-				const { introspectMysql } = await import('./commands/introspect');
-				await introspectMysql(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					prefix,
-				);
-			} else if (dialect === 'sqlite') {
-				const { introspectSqlite } = await import('./commands/introspect');
-				await introspectSqlite(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					prefix,
-				);
-			} else if (dialect === 'turso') {
-				const { introspectLibSQL } = await import('./commands/introspect');
-				await introspectLibSQL(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					prefix,
-				);
-			} else if (dialect === 'singlestore') {
-				const { introspectSingleStore } = await import('./commands/introspect');
-				await introspectSingleStore(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					prefix,
-				);
-			} else if (dialect === 'gel') {
-				const { introspectGel } = await import('./commands/introspect');
-				await introspectGel(
-					casing,
-					out,
-					breakpoints,
-					credentials,
-					tablesFilter,
-					schemasFilter,
-					prefix,
-					entities,
+		if (error) {
+			if (error.exitCode === 'localMigrations') {
+				throw new CommandOutputCliError('pull', "--init can't be used with existing migrations");
+			}
+			if (error.exitCode === 'databaseMigrations') {
+				throw new CommandOutputCliError(
+					'pull',
+					"--init can't be used when database already has migrations set",
 				);
-			} else {
-				assertUnreachable(dialect);
 			}
-		} catch (e) {
-			console.error(e);
 		}
-		process.exit(0);
-	},
-});
+	}
 
-export const drop = command({
-	name: 'drop',
-	options: {
-		config: optionConfig,
-		out: optionOut,
-		driver: optionDriver,
-	},
-	transform: async (opts) => {
-		const from = assertCollisions('check', opts, [], ['driver', 'out']);
-		return prepareDropParams(opts, from);
-	},
-	handler: async (config) => {
-		await assertOrmCoreVersion();
+	return { status: 'ok' as const, dialect, ...manifest };
+};
 
-		assertV1OutFolder(config.out);
-		await dropMigration(config);
+export const pull = command({
+	name: 'pull',
+	aliases: ['introspect'],
+	options: pullOptions,
+	transform: preparePull,
+	handler: async (cfg) => {
+		const env = await runPull(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		process.exit(statusToExitCode(env.status));
 	},
 });
 
@@ -659,19 +956,16 @@ export const studio = command({
 			.default(false)
 			.desc('Print all stataments that are executed by Studio'),
 	},
+	transform: async (opts) => {
+		return await prepareStudioConfig(opts);
+	},
 	handler: async (opts) => {
 		await assertOrmCoreVersion();
 		await assertPackages('drizzle-orm');
 
 		assertStudioNodeVersion();
 
-		const {
-			dialect,
-			schema: schemaPath,
-			port,
-			host,
-			credentials,
-		} = await prepareStudioConfig(opts);
+		const { credentials, dialect, host, port, schema: schemaPath } = opts;
 
 		const {
 			drizzleForPostgres,
@@ -683,172 +977,278 @@ export const studio = command({
 			prepareSingleStoreSchema,
 			drizzleForSingleStore,
 			drizzleForLibSQL,
-		} = await import('../serializer/studio');
+			drizzleForDuckDb,
+			// drizzleForMsSQL,
+		} = await import('./commands/studio');
 
 		let setup: Setup;
-		try {
-			if (dialect === 'postgresql') {
-				if ('driver' in credentials) {
-					const { driver } = credentials;
-					if (driver === 'aws-data-api') {
-						if (!(await ormVersionGt('0.30.10'))) {
-							console.log(
-								"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else if (driver === 'pglite') {
-						if (!(await ormVersionGt('0.30.6'))) {
-							console.log(
-								"To use 'pglite' driver - please update drizzle-orm to the latest version",
-							);
-							process.exit(1);
-						}
-					} else {
-						assertUnreachable(driver);
+
+		if (dialect === 'postgresql') {
+			if ('driver' in credentials) {
+				const { driver } = credentials;
+				if (driver === 'aws-data-api') {
+					if (!(await ormVersionGt('0.30.10'))) {
+						console.log(
+							"To use 'aws-data-api' driver - please update drizzle-orm to the latest version",
+						);
+						process.exit(1);
+					}
+				} else if (driver === 'pglite') {
+					if (!(await ormVersionGt('0.30.6'))) {
+						console.log(
+							"To use 'pglite' driver - please update drizzle-orm to the latest version",
+						);
+						process.exit(1);
 					}
+				} else {
+					assertUnreachable(driver);
 				}
-
-				const { schema, relations, files } = schemaPath
-					? await preparePgSchema(schemaPath)
-					: { schema: {}, relations: {}, files: [] };
-				setup = await drizzleForPostgres(credentials, schema, relations, files);
-			} else if (dialect === 'mysql') {
-				const { schema, relations, files } = schemaPath
-					? await prepareMySqlSchema(schemaPath)
-					: { schema: {}, relations: {}, files: [] };
-				setup = await drizzleForMySQL(credentials, schema, relations, files);
-			} else if (dialect === 'sqlite') {
-				const { schema, relations, files } = schemaPath
-					? await prepareSQLiteSchema(schemaPath)
-					: { schema: {}, relations: {}, files: [] };
-				setup = await drizzleForSQLite(credentials, schema, relations, files);
-			} else if (dialect === 'turso') {
-				const { schema, relations, files } = schemaPath
-					? await prepareSQLiteSchema(schemaPath)
-					: { schema: {}, relations: {}, files: [] };
-				setup = await drizzleForLibSQL(credentials, schema, relations, files);
-			} else if (dialect === 'singlestore') {
-				const { schema, relations, files } = schemaPath
-					? await prepareSingleStoreSchema(schemaPath)
-					: { schema: {}, relations: {}, files: [] };
-				setup = await drizzleForSingleStore(
-					credentials,
-					schema,
-					relations,
-					files,
-				);
-			} else if (dialect === 'gel') {
-				console.log(
-					error(
-						`You can't use 'studio' command with Gel dialect`,
-					),
-				);
-				process.exit(1);
-			} else {
-				assertUnreachable(dialect);
 			}
 
-			const { prepareServer } = await import('../serializer/studio');
-
-			const server = await prepareServer(setup);
-
-			console.log();
-			console.log(
-				withStyle.fullWarning(
-					'Drizzle Studio is currently in Beta. If you find anything that is not working as expected or should be improved, feel free to create an issue on GitHub: https://github.com/drizzle-team/drizzle-kit-mirror/issues/new or write to us on Discord: https://discord.gg/WcRKz2FFxN',
-				),
+			const { schema, relations, files } = schemaPath
+				? await preparePgSchema(schemaPath)
+				: { schema: {}, relations: {}, files: [] };
+			setup = await drizzleForPostgres(
+				credentials,
+				schema,
+				relations,
+				files,
+			);
+		} else if (dialect === 'mysql') {
+			const { schema, relations, files } = schemaPath
+				? await prepareMySqlSchema(schemaPath)
+				: { schema: {}, relations: {}, files: [] };
+			setup = await drizzleForMySQL(
+				credentials,
+				schema,
+				relations,
+				files,
+			);
+		} else if (dialect === 'sqlite') {
+			const { schema, relations, files } = schemaPath
+				? await prepareSQLiteSchema(schemaPath)
+				: { schema: {}, relations: {}, files: [] };
+			setup = await drizzleForSQLite(
+				credentials,
+				schema,
+				relations,
+				files,
+			);
+		} else if (dialect === 'turso') {
+			const { schema, relations, files } = schemaPath
+				? await prepareSQLiteSchema(schemaPath)
+				: { schema: {}, relations: {}, files: [] };
+			setup = await drizzleForLibSQL(
+				credentials,
+				schema,
+				relations,
+				files,
+			);
+		} else if (dialect === 'singlestore') {
+			const { schema, relations, files } = schemaPath
+				? await prepareSingleStoreSchema(schemaPath)
+				: { schema: {}, relations: {}, files: [] };
+			setup = await drizzleForSingleStore(
+				credentials,
+				schema,
+				relations,
+				files,
+			);
+		} else if (dialect === 'duckdb') {
+			setup = await drizzleForDuckDb(credentials);
+		} else if (dialect === 'cockroach') {
+			throw new Error(
+				`You can't use 'studio' command with 'cockroach' dialect`,
 			);
+		} else {
+			assertUnreachable(dialect);
+		}
 
-			const { key, cert } = (await certs()) || {};
-			server.start({
-				host,
-				port,
-				key,
-				cert,
-				cb: (err, address) => {
-					if (err) {
-						console.error(err);
-					} else {
-						const queryParams: { port?: number; host?: string } = {};
-						if (port !== 4983) {
-							queryParams.port = port;
-						}
-
-						if (host !== '127.0.0.1') {
-							queryParams.host = host;
-						}
-
-						const queryString = Object.keys(queryParams)
-							.map((key: keyof { port?: number; host?: string }) => {
-								return `${key}=${queryParams[key]}`;
-							})
-							.join('&');
+		const { prepareServer } = await import('./commands/studio');
+		const server = await prepareServer(setup);
 
-						console.log(
-							`\nDrizzle Studio is up and running on ${
-								chalk.blue(
-									`https://local.drizzle.studio${queryString ? `?${queryString}` : ''}`,
-								)
-							}`,
-						);
+		const { certs } = await import('../utils/certs');
+		const { key, cert } = (await certs()) || {};
+		server.start({
+			host,
+			port,
+			key,
+			cert,
+			cb: (err, _address) => {
+				if (err) {
+					console.error(err);
+				} else {
+					const queryParams: { port?: number; host?: string } = {};
+					if (port !== 4983) {
+						queryParams.port = port;
 					}
-				},
-			});
-		} catch (e) {
-			console.error(e);
-			process.exit(0);
-		}
+
+					if (host !== '127.0.0.1') {
+						queryParams.host = host;
+					}
+
+					const queryString = Object.keys(queryParams)
+						.map((key: keyof { port?: number; host?: string }) => {
+							return `${key}=${queryParams[key]}`;
+						})
+						.join('&');
+
+					console.log(
+						`\nDrizzle Studio is up and running on ${
+							chalk.blue(
+								`https://local.drizzle.studio${queryString ? `?${queryString}` : ''}`,
+							)
+						}`,
+					);
+				}
+			},
+		});
 	},
 });
 
+export const exportOptions = {
+	sql: boolean('sql').default(true).desc('Generate as sql'),
+	config: optionConfig,
+	dialect: optionDialect,
+	schema: string().desc('Path to a schema file or folder'),
+	output: optionOutput,
+} as const satisfies Record<string, GenericBuilderInternals>;
+
+export const prepareExport = async (opts: ExportOptionsInput) => {
+	const output = opts.output ?? outputFormat();
+	const interactive = output === 'text' && !!process.stdin.isTTY;
+	setCliContext({ output, interactive });
+	const from = assertCollisions(
+		'export',
+		opts,
+		['sql', 'output'],
+		['dialect', 'schema'],
+	);
+	const config = { ...(await prepareExportConfig(opts, from)), output };
+	return config;
+};
+
+export const runExport = async (
+	config: Awaited<ReturnType<typeof prepareExport>>,
+) => {
+	await assertOrmCoreVersion();
+	await assertPackages('drizzle-orm');
+
+	const dialect = config.dialect;
+	let statements: string[];
+	let warnings: string[];
+	if (dialect === 'postgresql') {
+		const { handleExport } = await import('./commands/generate-postgres');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'mysql') {
+		const { handleExport } = await import('./commands/generate-mysql');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'sqlite') {
+		const { handleExport } = await import('./commands/generate-sqlite');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'turso') {
+		const { handleExport } = await import('./commands/generate-libsql');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'singlestore') {
+		const { handleExport } = await import('./commands/generate-singlestore');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'mssql') {
+		const { handleExport } = await import('./commands/generate-mssql');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'cockroach') {
+		const { handleExport } = await import('./commands/generate-cockroach');
+		({ statements, warnings } = await handleExport(config));
+	} else if (dialect === 'duckdb') {
+		throw new UnsupportedCommandDialectCliError('export', 'duckdb');
+	} else {
+		assertUnreachable(dialect);
+	}
+
+	return { status: 'ok' as const, dialect, statements, warnings };
+};
+
 export const exportRaw = command({
 	name: 'export',
 	desc: 'Generate diff between current state and empty state in specified formats: sql',
-	options: {
-		sql: boolean('sql').default(true).desc('Generate as sql'),
-		config: optionConfig,
-		dialect: optionDialect,
-		schema: string().desc('Path to a schema file or folder'),
+	options: exportOptions,
+	transform: prepareExport,
+	handler: async (cfg) => {
+		const env = await runExport(cfg);
+		if (outputFormat() === 'json') process.stdout.write(JSON.stringify(env) + '\n');
+		else {
+			if (env.warnings.length > 0) console.log(env.warnings.join('\n\n'));
+			console.log(env.statements.join('\n'));
+		}
+		process.exit(statusToExitCode(env.status));
 	},
-	transform: async (opts) => {
-		const from = assertCollisions('export', opts, ['sql'], ['dialect', 'schema']);
-		return prepareExportConfig(opts, from);
+});
+
+const detectInstaller = (): { cmd: 'pnpm' | 'bunx' | 'yarn' | 'npx'; args: string[] } => {
+	const userAgent = process.env.npm_config_user_agent ?? '';
+	const token = userAgent.split(' ')[0] ?? '';
+	const [name, version] = token.split('/');
+
+	if (name === 'pnpm') return { cmd: 'pnpm', args: ['dlx'] };
+	if (name === 'bun') return { cmd: 'bunx', args: [] };
+	if (name === 'yarn') {
+		const major = Number.parseInt(version ?? '', 10);
+		if (Number.isFinite(major) && major >= 2) return { cmd: 'yarn', args: ['dlx'] };
+		return { cmd: 'npx', args: ['-y'] };
+	}
+	return { cmd: 'npx', args: ['-y'] };
+};
+
+const skillsVersion = command({
+	name: 'version',
+	options: {},
+	handler: () => {
+		const revision = process.env.DRIZZLE_KIT_SKILLS_REVISION;
+		process.stdout.write(`${revision ? revision : '--'}\n`);
 	},
-	handler: async (opts) => {
-		await assertOrmCoreVersion();
-		await assertPackages('drizzle-orm');
+});
 
-		const {
-			prepareAndExportPg,
-			prepareAndExportMysql,
-			prepareAndExportSqlite,
-			prepareAndExportLibSQL,
-			prepareAndExportSinglestore,
-		} = await import(
-			'./commands/migrate'
-		);
+export const mcp = command({
+	name: 'mcp',
+	options: {},
+	handler: async () => {
+		const { startMcpServer } = await import('../mcp/server');
+		await startMcpServer();
+	},
+});
 
-		const dialect = opts.dialect;
-		if (dialect === 'postgresql') {
-			await prepareAndExportPg(opts);
-		} else if (dialect === 'mysql') {
-			await prepareAndExportMysql(opts);
-		} else if (dialect === 'sqlite') {
-			await prepareAndExportSqlite(opts);
-		} else if (dialect === 'turso') {
-			await prepareAndExportLibSQL(opts);
-		} else if (dialect === 'singlestore') {
-			await prepareAndExportSinglestore(opts);
-		} else if (dialect === 'gel') {
-			console.log(
-				error(
-					`You can't use 'export' command with Gel dialect`,
-				),
-			);
+export const skills = command({
+	name: 'skills',
+	options: {},
+	subcommands: [skillsVersion],
+	handler: async () => {
+		const candidates = [resolve(__dirname, 'skills'), resolve(__dirname, '../../skills')];
+		const skillsDir = candidates.find((p) => existsSync(p));
+		if (!skillsDir) {
+			process.stderr.write('Could not locate bundled skills directory.\n');
 			process.exit(1);
-		} else {
-			assertUnreachable(dialect);
 		}
+
+		const { cmd, args } = detectInstaller();
+		process.stderr.write(`Installing via ${cmd}…\n`);
+		// On Windows `shell: true` re-tokenizes argv via cmd.exe, so a `skillsDir` with spaces
+		// (e.g. `C:\Program Files\…`) would split across args. Quote the path to neutralize that.
+		const onWindows = process.platform === 'win32';
+		const skillsArg = onWindows ? `"${skillsDir}"` : skillsDir;
+		const child = spawn(cmd, [...args, 'skills@latest', 'add', skillsArg], {
+			stdio: 'inherit',
+			shell: onWindows,
+		});
+		// Awaiting child exit prevents the outer brocli `after` hook from racing process.exit(0)
+		// past a non-zero child exit code.
+		const exitCode = await new Promise<number>((resolve) => {
+			child.on('error', () => {
+				process.stderr.write(`Failed to spawn ${cmd}. Make sure ${cmd} is installed and on PATH.\n`);
+				resolve(1);
+			});
+			child.on('exit', (code, signal) => {
+				resolve(signal ? 1 : (code ?? 0));
+			});
+		});
+		process.exit(exitCode);
 	},
 });
diff --git a/drizzle-kit/src/cli/selector-ui.ts b/drizzle-kit/src/cli/selector-ui.ts
index f384831d0e..815bc6ec97 100644
--- a/drizzle-kit/src/cli/selector-ui.ts
+++ b/drizzle-kit/src/cli/selector-ui.ts
@@ -23,7 +23,7 @@ export class Select extends Prompt<{ index: number; value: string }> {
 			text += idx === this.data.selectedIdx
 				? `${chalk.green('❯ ' + it.label)}`
 				: `  ${it.label}`;
-			text += idx != this.data.items.length - 1 ? '\n' : '';
+			text += idx !== this.data.items.length - 1 ? '\n' : '';
 		});
 
 		return text;
diff --git a/drizzle-kit/src/cli/utils.ts b/drizzle-kit/src/cli/utils.ts
index a4c28851e7..11d8c4a0fa 100644
--- a/drizzle-kit/src/cli/utils.ts
+++ b/drizzle-kit/src/cli/utils.ts
@@ -1,5 +1,10 @@
 import semver from 'semver';
-import { err, warning } from './views';
+import {
+	OrmVersionCliError,
+	RequiredEitherPackagesCliError,
+	RequiredPackagesCliError,
+	StudioNodeVersionCliError,
+} from './errors';
 
 export const assertExists = (it?: any) => {
 	if (!it) throw new Error();
@@ -15,16 +20,14 @@ export const ormVersionGt = async (version: string) => {
 
 export const assertStudioNodeVersion = () => {
 	if (semver.gte(process.version, '18.0.0')) return;
-
-	err('Drizzle Studio requires NodeJS v18 or above');
-	process.exit(1);
+	throw new StudioNodeVersionCliError();
 };
 
 export const checkPackage = async (it: string) => {
 	try {
 		await import(it);
 		return true;
-	} catch (e) {
+	} catch {
 		return false;
 	}
 };
@@ -35,15 +38,8 @@ export const assertPackages = async (...pkgs: string[]) => {
 			const it = pkgs[i];
 			await import(it);
 		}
-	} catch (e) {
-		err(
-			`please install required packages: ${
-				pkgs
-					.map((it) => `'${it}'`)
-					.join(' ')
-			}`,
-		);
-		process.exit(1);
+	} catch {
+		throw new RequiredPackagesCliError(pkgs);
 	}
 };
 
@@ -57,47 +53,40 @@ export const assertEitherPackage = async (
 			const it = pkgs[i];
 			await import(it);
 			availables.push(it);
-		} catch (e) {}
+		} catch {}
 	}
 
 	if (availables.length > 0) {
 		return availables;
 	}
-
-	err(
-		`Please install one of those packages are needed: ${
-			pkgs
-				.map((it) => `'${it}'`)
-				.join(' or ')
-		}`,
-	);
-	process.exit(1);
+	throw new RequiredEitherPackagesCliError(pkgs);
 };
 
-const requiredApiVersion = 10;
+const requiredApiVersion = 14;
 export const assertOrmCoreVersion = async () => {
 	try {
 		const { compatibilityVersion } = await import('drizzle-orm/version');
 
-		await import('drizzle-orm/relations');
+		await import('drizzle-orm/_relations');
 
-		if (compatibilityVersion && compatibilityVersion === requiredApiVersion) {
+		if (Number(compatibilityVersion) === requiredApiVersion) {
 			return;
 		}
 
 		if (!compatibilityVersion || compatibilityVersion < requiredApiVersion) {
-			console.log(
+			throw new OrmVersionCliError(
 				'This version of drizzle-kit requires newer version of drizzle-orm\nPlease update drizzle-orm package to the latest version 👍',
+				'orm_too_old',
 			);
 		} else {
-			console.log(
+			throw new OrmVersionCliError(
 				'This version of drizzle-kit is outdated\nPlease update drizzle-kit package to the latest version 👍',
+				'kit_outdated',
 			);
 		}
-	} catch (e) {
-		console.log('Please install latest version of drizzle-orm');
+	} catch {
+		throw new OrmVersionCliError('Please install latest version of drizzle-orm', 'orm_missing');
 	}
-	process.exit(1);
 };
 
 export const ormCoreVersions = async () => {
@@ -106,7 +95,13 @@ export const ormCoreVersions = async () => {
 			'drizzle-orm/version'
 		);
 		return { compatibilityVersion, npmVersion };
-	} catch (e) {
+	} catch {
 		return {};
 	}
 };
+
+export class QueryError extends Error {
+	constructor(wrapped: Error, public readonly sql: string, public readonly params: any[]) {
+		super(wrapped.message, { cause: wrapped });
+	}
+}
diff --git a/drizzle-kit/src/cli/validations/cli.ts b/drizzle-kit/src/cli/validations/cli.ts
deleted file mode 100644
index a2a5ad81fd..0000000000
--- a/drizzle-kit/src/cli/validations/cli.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { array, boolean, intersection, literal, object, string, TypeOf, union } from 'zod';
-import { dialect } from '../../schemaValidator';
-import { casing, casingType, prefix } from './common';
-
-export const cliConfigGenerate = object({
-	dialect: dialect.optional(),
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	config: string().optional(),
-	name: string().optional(),
-	prefix: prefix.optional(),
-	breakpoints: boolean().optional().default(true),
-	custom: boolean().optional().default(false),
-}).strict();
-
-export type CliConfigGenerate = TypeOf<typeof cliConfigGenerate>;
-
-export const pushParams = object({
-	dialect: dialect,
-	casing: casingType.optional(),
-	schema: union([string(), string().array()]),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()])
-		.optional()
-		.default(['public']),
-	extensionsFilters: literal('postgis').array().optional(),
-	verbose: boolean().optional(),
-	strict: boolean().optional(),
-	entities: object({
-		roles: boolean().or(object({
-			provider: string().optional(),
-			include: string().array().optional(),
-			exclude: string().array().optional(),
-		})).optional().default(false),
-	}).optional(),
-}).passthrough();
-
-export type PushParams = TypeOf<typeof pushParams>;
-
-export const pullParams = object({
-	config: string().optional(),
-	dialect: dialect,
-	out: string().optional().default('drizzle'),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()])
-		.optional()
-		.default(['public']),
-	extensionsFilters: literal('postgis').array().optional(),
-	casing,
-	breakpoints: boolean().optional().default(true),
-	migrations: object({
-		prefix: prefix.optional().default('index'),
-	}).optional(),
-	entities: object({
-		roles: boolean().or(object({
-			provider: string().optional(),
-			include: string().array().optional(),
-			exclude: string().array().optional(),
-		})).optional().default(false),
-	}).optional(),
-}).passthrough();
-
-export type Entities = TypeOf<typeof pullParams>['entities'];
-
-export type PullParams = TypeOf<typeof pullParams>;
-
-export const configCheck = object({
-	dialect: dialect.optional(),
-	out: string().optional(),
-});
-
-export const cliConfigCheck = intersection(
-	object({
-		config: string().optional(),
-	}),
-	configCheck,
-);
-
-export type CliCheckConfig = TypeOf<typeof cliConfigCheck>;
diff --git a/drizzle-kit/src/cli/validations/cockroach.ts b/drizzle-kit/src/cli/validations/cockroach.ts
new file mode 100644
index 0000000000..8b9ed091b2
--- /dev/null
+++ b/drizzle-kit/src/cli/validations/cockroach.ts
@@ -0,0 +1,70 @@
+import type { TypeOf } from 'zod';
+import { boolean, coerce, literal, object, string, union } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
+import { error } from '../views';
+import { wrapParam } from './common';
+
+export const cockroachCredentials = union([
+	object({
+		host: string().min(1),
+		port: coerce.number().min(1).optional(),
+		user: string().min(1).optional(),
+		password: string().min(1).optional(),
+		database: string().min(1),
+		// TODO update ssl params
+		ssl: union([
+			literal('require'),
+			literal('allow'),
+			literal('prefer'),
+			literal('verify-full'),
+			boolean(),
+			object({}).passthrough(),
+		]).optional(),
+	}),
+	object({
+		url: string().min(1),
+	}),
+]);
+
+export type CockroachCredentials = TypeOf<typeof cockroachCredentials>;
+
+export const printConfigConnectionIssues = (
+	options: Record<string, unknown>,
+): never => {
+	if ('url' in options) {
+		let text = `Please provide required params for Cockroach dialect:\n`;
+		throw new ConfigConnectionCliError(
+			'cockroach',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url, false, 'url'),
+			].join('\n'),
+		);
+	}
+
+	if ('host' in options || 'database' in options) {
+		let text = `Please provide required params for Cockroach dialect:\n`;
+		throw new ConfigConnectionCliError(
+			'cockroach',
+			['host', 'database', 'user', 'server'],
+			[
+				error(text),
+				wrapParam('host', options.host),
+				wrapParam('port', options.port, true),
+				wrapParam('user', options.user, true),
+				wrapParam('password', options.password, true, 'secret'),
+				wrapParam('database', options.database),
+				wrapParam('ssl', options.ssl, true),
+			].join('\n'),
+		);
+	}
+
+	throw new ConfigConnectionCliError(
+		'cockroach',
+		['url', 'host', 'database', 'user', 'server'],
+		error(
+			`Either connection "url" or "host", "database", "user", "server" are required for Cockroach connection`,
+		),
+	);
+};
diff --git a/drizzle-kit/src/cli/validations/common.ts b/drizzle-kit/src/cli/validations/common.ts
index 721f6effae..e414004ad4 100644
--- a/drizzle-kit/src/cli/validations/common.ts
+++ b/drizzle-kit/src/cli/validations/common.ts
@@ -1,7 +1,9 @@
 import chalk from 'chalk';
-import { UnionToIntersection } from 'hono/utils/types';
-import { any, boolean, enum as enum_, literal, object, string, TypeOf, union } from 'zod';
-import { dialect } from '../../schemaValidator';
+import type { UnionToIntersection } from 'hono/utils/types';
+import type { TypeOf } from 'zod';
+import { any, boolean, coerce, enum as enum_, literal, object, string, union } from 'zod';
+import { dialect } from '../../utils/schemaValidator';
+import { AmbiguousParamsCliError } from '../errors';
 import { outputs } from './outputs';
 
 export type Commands =
@@ -13,7 +15,7 @@ export type Commands =
 	| 'push'
 	| 'export';
 
-type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+// type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
 type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
 type LastTupleElement<TArr extends any[]> = TArr extends [
 	...start: infer _,
@@ -37,7 +39,7 @@ export const assertCollisions = <
 	command: Commands,
 	options: T,
 	whitelist: Exclude<TKeys, 'config'>,
-	remainingKeys: UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
+	_remainingKeys: UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
 ): IsUnion<LastTupleElement<UNIQ>> extends false ? 'cli' | 'config' : TKeys => {
 	const { config, ...rest } = options;
 
@@ -57,14 +59,14 @@ export const assertCollisions = <
 	}
 
 	// if config and cli - return error - write a reason
-	console.log(outputs.common.ambiguousParams(command));
-	process.exit(1);
+	throw new AmbiguousParamsCliError(command, outputs.common.ambiguousParams(command));
 };
 
 export const sqliteDriversLiterals = [
 	literal('d1-http'),
 	literal('expo'),
 	literal('durable-sqlite'),
+	literal('sqlite-cloud'),
 ] as const;
 
 export const postgresqlDriversLiterals = [
@@ -72,20 +74,6 @@ export const postgresqlDriversLiterals = [
 	literal('pglite'),
 ] as const;
 
-export const prefixes = [
-	'index',
-	'timestamp',
-	'supabase',
-	'unix',
-	'none',
-] as const;
-export const prefix = enum_(prefixes);
-export type Prefix = (typeof prefixes)[number];
-
-{
-	const _: Prefix = '' as TypeOf<typeof prefix>;
-}
-
 export const casingTypes = ['snake_case', 'camelCase'] as const;
 export const casingType = enum_(casingTypes);
 export type CasingType = (typeof casingTypes)[number];
@@ -94,78 +82,127 @@ export const sqliteDriver = union(sqliteDriversLiterals);
 export const postgresDriver = union(postgresqlDriversLiterals);
 export const driver = union([sqliteDriver, postgresDriver]);
 
+export const drivers = ['d1-http', 'expo', 'aws-data-api', 'pglite', 'durable-sqlite', 'sqlite-cloud'] as const;
+
+export type Casing = TypeOf<typeof casing>;
+
 export const configMigrations = object({
-	table: string().optional(),
-	schema: string().optional(),
-	prefix: prefix.optional().default('index'),
-}).optional();
+	table: string().default('__drizzle_migrations'),
+	schema: string().default('drizzle'),
+}).default({ table: '__drizzle_migrations', schema: 'drizzle' });
+
+export const casing = union([literal('camel'), literal('preserve')]).default(
+	'camel',
+);
+
+export type Driver = (typeof drivers)[number];
+
+export const entitiesParams = {
+	tablesFilter: union([string(), string().array()]).optional(),
+	schemaFilter: union([string(), string().array()])
+		.optional(),
+	extensionsFilters: literal('postgis').array().optional(),
+	entities: object({
+		roles: boolean().or(object({
+			provider: string().optional(),
+			include: string().array().optional(),
+			exclude: string().array().optional(),
+		})).optional().default(false),
+	}).optional(),
+};
+export type EntitiesFilter = TypeOf<typeof entitiesParams['entities']>;
+export type TablesFilter = TypeOf<typeof entitiesParams['tablesFilter']>;
+export type SchemasFilter = TypeOf<typeof entitiesParams['schemaFilter']>;
+export type ExtensionsFilter = TypeOf<typeof entitiesParams['extensionsFilters']>;
+export type EntitiesFilterConfig = {
+	schemas: SchemasFilter;
+	tables: TablesFilter;
+	entities: EntitiesFilter;
+	extensions: ExtensionsFilter;
+};
 
 export const configCommonSchema = object({
-	dialect: dialect,
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional(),
+	dialect: dialect.optional(),
+	out: string().default('drizzle'),
 	breakpoints: boolean().optional().default(true),
 	verbose: boolean().optional().default(false),
 	driver: driver.optional(),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	migrations: configMigrations,
 	dbCredentials: any().optional(),
-	casing: casingType.optional(),
-	sql: boolean().default(true),
 }).passthrough();
 
-export const casing = union([literal('camel'), literal('preserve')]).default(
-	'camel',
-);
+export type CliConfig = TypeOf<typeof configCommonSchema> & {
+	schema?: string | string[];
+	sql?: boolean;
+	migrations?: TypeOf<typeof configMigrations>;
+	tablesFilter?: string | string[];
+	schemaFilter?: string | string[];
+};
 
-export const introspectParams = object({
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	introspect: object({
-		casing,
-	}).default({ casing: 'camel' }),
+export const configPull = configCommonSchema.extend({
+	casing,
+	migrations: configMigrations,
+	...entitiesParams,
 });
 
-export type IntrospectParams = TypeOf<typeof introspectParams>;
-export type Casing = TypeOf<typeof casing>;
+export const configCheck = configCommonSchema;
 
-export const configIntrospectCliSchema = object({
-	schema: union([string(), string().array()]).optional(),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	introspectCasing: union([literal('camel'), literal('preserve')]).default(
-		'camel',
-	),
+export const configGenerate = configCommonSchema.extend({
+	schema: union([string(), string().array()]),
+});
+
+export const configPush = configCommonSchema.extend({
+	schema: union([string(), string().array()]),
+	explain: boolean().optional(),
+	migrations: configMigrations,
+	...entitiesParams,
 });
 
-export const configGenerateSchema = object({
+export const configExport = configCommonSchema.extend({
 	schema: union([string(), string().array()]),
-	out: string().optional().default('./drizzle'),
-	breakpoints: boolean().default(true),
 });
 
-export type GenerateSchema = TypeOf<typeof configGenerateSchema>;
+export const studioCliParams = object({
+	port: coerce.number().optional().default(4983),
+	host: string().optional().default('127.0.0.1'),
+	config: string().optional(),
+});
+
+export const configStudio = configCommonSchema.extend({
+	schema: union([string(), string().array()]).optional(),
+});
+
+export const configMigrate = configCommonSchema.extend({
+	migrations: configMigrations,
+});
 
-export const configPushSchema = object({
+export const pushParams = object({
 	dialect: dialect,
 	schema: union([string(), string().array()]),
-	tablesFilter: union([string(), string().array()]).optional(),
-	schemaFilter: union([string(), string().array()]).default(['public']),
-	verbose: boolean().default(false),
-	strict: boolean().default(false),
-	out: string().optional(),
-});
+	verbose: boolean().optional(),
+	strict: boolean().optional(),
+	explain: boolean().optional(),
+	hints: string().optional(),
+	hintsFile: string().optional(),
+	migrations: configMigrations,
+	...entitiesParams,
+}).passthrough();
 
-export type CliConfig = TypeOf<typeof configCommonSchema>;
-export const drivers = ['d1-http', 'expo', 'aws-data-api', 'pglite', 'durable-sqlite'] as const;
-export type Driver = (typeof drivers)[number];
-const _: Driver = '' as TypeOf<typeof driver>;
+export type PushParams = TypeOf<typeof pushParams>;
+
+export const pullParams = object({
+	config: string().optional(),
+	dialect: dialect,
+	out: string().optional().default('drizzle'),
+	casing,
+	breakpoints: boolean().optional().default(true),
+	migrations: configMigrations,
+	...entitiesParams,
+}).passthrough();
+
+export const studioConfig = object({
+	dialect,
+	schema: union([string(), string().array()]).optional(),
+});
 
 export const wrapParam = (
 	name: string,
diff --git a/drizzle-kit/src/cli/validations/duckdb.ts b/drizzle-kit/src/cli/validations/duckdb.ts
new file mode 100644
index 0000000000..485119433f
--- /dev/null
+++ b/drizzle-kit/src/cli/validations/duckdb.ts
@@ -0,0 +1,28 @@
+import { object, string, type TypeOf, undefined as undefinedType } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
+import { error } from '../views';
+import { wrapParam } from './common';
+
+export const duckdbCredentials = object({
+	driver: undefinedType(),
+	url: string().min(1),
+}).transform<{ url: string }>((o) => {
+	delete o.driver;
+	return o;
+});
+
+export type DuckDbCredentials = TypeOf<typeof duckdbCredentials>;
+
+export const printConfigConnectionIssues = (
+	options: Record<string, unknown>,
+): never => {
+	const text = `Please provide required params:\n`;
+	throw new ConfigConnectionCliError(
+		'duckdb',
+		['url'],
+		[
+			error(text),
+			wrapParam('url', options.url),
+		].join('\n'),
+	);
+};
diff --git a/drizzle-kit/src/cli/validations/gel.ts b/drizzle-kit/src/cli/validations/gel.ts
deleted file mode 100644
index cf6d38614d..0000000000
--- a/drizzle-kit/src/cli/validations/gel.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { coerce, literal, object, string, TypeOf, undefined as undefinedType, union } from 'zod';
-import { error } from '../views';
-import { wrapParam } from './common';
-
-export const gelCredentials = union([
-	object({
-		driver: undefinedType(),
-		host: string().min(1),
-		port: coerce.number().min(1).optional(),
-		user: string().min(1).optional(),
-		password: string().min(1).optional(),
-		database: string().min(1),
-		tlsSecurity: union([
-			literal('insecure'),
-			literal('no_host_verification'),
-			literal('strict'),
-			literal('default'),
-		]).optional(),
-	}).transform((o) => {
-		delete o.driver;
-		return o as Omit<typeof o, 'driver'>;
-	}),
-	object({
-		driver: undefinedType(),
-		url: string().min(1),
-		tlsSecurity: union([
-			literal('insecure'),
-			literal('no_host_verification'),
-			literal('strict'),
-			literal('default'),
-		]).optional(),
-	}).transform<{
-		url: string;
-		tlsSecurity?:
-			| 'insecure'
-			| 'no_host_verification'
-			| 'strict'
-			| 'default';
-	}>((o) => {
-		delete o.driver;
-		return o;
-	}),
-	object({
-		driver: undefinedType(),
-	}).transform<undefined>((o) => {
-		return undefined;
-	}),
-]);
-
-export type GelCredentials = TypeOf<typeof gelCredentials>;
-
-export const printConfigConnectionIssues = (
-	options: Record<string, unknown>,
-) => {
-	if ('url' in options) {
-		let text = `Please provide required params for Gel driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
-	}
-
-	if ('host' in options || 'database' in options) {
-		let text = `Please provide required params for Gel driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('host', options.host));
-		console.log(wrapParam('port', options.port, true));
-		console.log(wrapParam('user', options.user, true));
-		console.log(wrapParam('password', options.password, true, 'secret'));
-		console.log(wrapParam('database', options.database));
-		console.log(wrapParam('tlsSecurity', options.tlsSecurity, true));
-		process.exit(1);
-	}
-
-	console.log(
-		error(
-			`Either connection "url" or "host", "database" are required for Gel database connection`,
-		),
-	);
-	process.exit(1);
-};
diff --git a/drizzle-kit/src/cli/validations/libsql.ts b/drizzle-kit/src/cli/validations/libsql.ts
index a9b03c1687..69aab82c62 100644
--- a/drizzle-kit/src/cli/validations/libsql.ts
+++ b/drizzle-kit/src/cli/validations/libsql.ts
@@ -1,5 +1,6 @@
-import { softAssertUnreachable } from 'src/global';
-import { object, string, TypeOf } from 'zod';
+import type { TypeOf } from 'zod';
+import { object, string } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
 import { error } from '../views';
 import { wrapParam } from './common';
 
@@ -17,11 +18,17 @@ const _: LibSQLCredentials = {} as TypeOf<typeof libSQLCredentials>;
 
 export const printConfigConnectionIssues = (
 	options: Record<string, unknown>,
-	command: 'generate' | 'migrate' | 'push' | 'pull' | 'studio',
-) => {
+	_command: 'generate' | 'migrate' | 'push' | 'pull' | 'studio',
+): never => {
 	let text = `Please provide required params for 'turso' dialect:\n`;
-	console.log(error(text));
-	console.log(wrapParam('url', options.url));
-	console.log(wrapParam('authToken', options.authToken, true, 'secret'));
-	process.exit(1);
+	throw new ConfigConnectionCliError(
+		'turso',
+		['url'],
+		[
+			error(text),
+			wrapParam('url', options.url),
+			wrapParam('authToken', options.authToken, true, 'secret'),
+		].join('\n'),
+		_command,
+	);
 };
diff --git a/drizzle-kit/src/cli/validations/mssql.ts b/drizzle-kit/src/cli/validations/mssql.ts
new file mode 100644
index 0000000000..6b1d0fed73
--- /dev/null
+++ b/drizzle-kit/src/cli/validations/mssql.ts
@@ -0,0 +1,70 @@
+import type { TypeOf } from 'zod';
+import { boolean, coerce, object, string, union } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
+import { error } from '../views';
+import { wrapParam } from './common';
+
+export const mssqlCredentials = union([
+	object({
+		port: coerce.number().min(1).optional(),
+		user: string().min(1),
+		password: string().min(1),
+		database: string().min(1).optional(),
+		server: string().min(1),
+		options: object({
+			encrypt: boolean().optional(),
+			trustServerCertificate: boolean().optional(),
+		}).optional(),
+	}),
+	object({
+		url: string().min(1),
+	}),
+]);
+
+export type MssqlCredentials = TypeOf<typeof mssqlCredentials>;
+
+export const printConfigConnectionIssues = (
+	options: Record<string, unknown>,
+	_command?: 'generate' | 'migrate' | 'push' | 'pull' | 'studio',
+): never => {
+	if ('url' in options) {
+		let text = `Please provide required params for MsSQL driver:\n`;
+		throw new ConfigConnectionCliError(
+			'mssql',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url, false, 'url'),
+			].join('\n'),
+			_command,
+		);
+	}
+
+	if (
+		'server' in options || 'database' in options || 'port' in options || 'user' in options || 'password' in options
+		|| 'options' in options
+	) {
+		let text = `Please provide required params for MsSQL driver:\n`;
+		throw new ConfigConnectionCliError(
+			'mssql',
+			['server', 'user', 'password', 'database'],
+			[
+				error(text),
+				wrapParam('server', options.server),
+				wrapParam('port', options.port, true),
+				wrapParam('user', options.user),
+				wrapParam('password', options.password, false, 'secret'),
+				wrapParam('database', options.database, true),
+				wrapParam('options', options.options, true),
+			].join('\n'),
+			_command,
+		);
+	}
+
+	throw new ConfigConnectionCliError(
+		'mssql',
+		['url', 'server', 'database'],
+		error(`Either connection "url" or "server", "user", "password" are required for MsSQL database connection`),
+		_command,
+	);
+};
diff --git a/drizzle-kit/src/cli/validations/mysql.ts b/drizzle-kit/src/cli/validations/mysql.ts
index 1841dbdd6f..d4ce399572 100644
--- a/drizzle-kit/src/cli/validations/mysql.ts
+++ b/drizzle-kit/src/cli/validations/mysql.ts
@@ -1,5 +1,7 @@
-import { boolean, coerce, object, string, TypeOf, union } from 'zod';
-import { error } from '../views';
+import type { TypeOf } from 'zod';
+import { boolean, coerce, object, string, union } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
+import { error, humanLog } from '../views';
 import { wrapParam } from './common';
 import { outputs } from './outputs';
 
@@ -35,27 +37,37 @@ export const printCliConnectionIssues = (options: any) => {
 	const { uri, host, database } = options || {};
 
 	if (!uri && (!host || !database)) {
-		console.log(outputs.mysql.connection.required());
+		humanLog(outputs.mysql.connection.required());
 	}
 };
 
 export const printConfigConnectionIssues = (
 	options: Record<string, unknown>,
-) => {
+): never => {
 	if ('url' in options) {
 		let text = `Please provide required params for MySQL driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'mysql',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url, false, 'url'),
+			].join('\n'),
+		);
 	}
 
 	let text = `Please provide required params for MySQL driver:\n`;
-	console.log(error(text));
-	console.log(wrapParam('host', options.host));
-	console.log(wrapParam('port', options.port, true));
-	console.log(wrapParam('user', options.user, true));
-	console.log(wrapParam('password', options.password, true, 'secret'));
-	console.log(wrapParam('database', options.database));
-	console.log(wrapParam('ssl', options.ssl, true));
-	process.exit(1);
+	throw new ConfigConnectionCliError(
+		'mysql',
+		['host', 'database'],
+		[
+			error(text),
+			wrapParam('host', options.host),
+			wrapParam('port', options.port, true),
+			wrapParam('user', options.user, true),
+			wrapParam('password', options.password, true, 'secret'),
+			wrapParam('database', options.database),
+			wrapParam('ssl', options.ssl, true),
+		].join('\n'),
+	);
 };
diff --git a/drizzle-kit/src/cli/validations/outputs.ts b/drizzle-kit/src/cli/validations/outputs.ts
index 6e9d520dd6..896ed4bf88 100644
--- a/drizzle-kit/src/cli/validations/outputs.ts
+++ b/drizzle-kit/src/cli/validations/outputs.ts
@@ -57,6 +57,15 @@ export const outputs = {
 				),
 		},
 	},
+	mssql: {
+		connection: {
+			driver: () => withStyle.error(`Only "mssql" is available options for "--driver"`),
+			required: () =>
+				withStyle.error(
+					`Either "url" or "host", "database" are required for database connection`,
+				),
+		},
+	},
 	sqlite: {
 		connection: {
 			driver: () => {
diff --git a/drizzle-kit/src/cli/validations/postgres.ts b/drizzle-kit/src/cli/validations/postgres.ts
index 658760c614..814196737c 100644
--- a/drizzle-kit/src/cli/validations/postgres.ts
+++ b/drizzle-kit/src/cli/validations/postgres.ts
@@ -1,10 +1,12 @@
-import { boolean, coerce, literal, object, string, TypeOf, undefined, union } from 'zod';
+import type { TypeOf } from 'zod';
+import { boolean, coerce, literal, object, string, undefined as zUndefined, union } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
 import { error } from '../views';
 import { wrapParam } from './common';
 
 export const postgresCredentials = union([
 	object({
-		driver: undefined(),
+		driver: zUndefined(),
 		host: string().min(1),
 		port: coerce.number().min(1).optional(),
 		user: string().min(1).optional(),
@@ -23,7 +25,7 @@ export const postgresCredentials = union([
 		return o as Omit<typeof o, 'driver'>;
 	}),
 	object({
-		driver: undefined(),
+		driver: zUndefined(),
 		url: string().min(1),
 	}).transform<{ url: string }>((o) => {
 		delete o.driver;
@@ -45,39 +47,55 @@ export type PostgresCredentials = TypeOf<typeof postgresCredentials>;
 
 export const printConfigConnectionIssues = (
 	options: Record<string, unknown>,
-) => {
+): never => {
 	if (options.driver === 'aws-data-api') {
 		let text = `Please provide required params for AWS Data API driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('database', options.database));
-		console.log(wrapParam('secretArn', options.secretArn, false, 'secret'));
-		console.log(wrapParam('resourceArn', options.resourceArn, false, 'secret'));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'aws-data-api',
+			['database', 'secretArn', 'resourceArn'],
+			[
+				error(text),
+				wrapParam('database', options.database),
+				wrapParam('secretArn', options.secretArn, false, 'secret'),
+				wrapParam('resourceArn', options.resourceArn, false, 'secret'),
+			].join('\n'),
+		);
 	}
 
 	if ('url' in options) {
 		let text = `Please provide required params for Postgres driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'postgresql',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url, false, 'url'),
+			].join('\n'),
+		);
 	}
 
 	if ('host' in options || 'database' in options) {
 		let text = `Please provide required params for Postgres driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('host', options.host));
-		console.log(wrapParam('port', options.port, true));
-		console.log(wrapParam('user', options.user, true));
-		console.log(wrapParam('password', options.password, true, 'secret'));
-		console.log(wrapParam('database', options.database));
-		console.log(wrapParam('ssl', options.ssl, true));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'postgresql',
+			['host', 'database'],
+			[
+				error(text),
+				wrapParam('host', options.host),
+				wrapParam('port', options.port, true),
+				wrapParam('user', options.user, true),
+				wrapParam('password', options.password, true, 'secret'),
+				wrapParam('database', options.database),
+				wrapParam('ssl', options.ssl, true),
+			].join('\n'),
+		);
 	}
 
-	console.log(
+	throw new ConfigConnectionCliError(
+		'postgresql',
+		['url', 'host', 'database'],
 		error(
 			`Either connection "url" or "host", "database" are required for PostgreSQL database connection`,
 		),
 	);
-	process.exit(1);
 };
diff --git a/drizzle-kit/src/cli/validations/singlestore.ts b/drizzle-kit/src/cli/validations/singlestore.ts
index ebe0cc5f01..ec107ce09b 100644
--- a/drizzle-kit/src/cli/validations/singlestore.ts
+++ b/drizzle-kit/src/cli/validations/singlestore.ts
@@ -1,5 +1,7 @@
-import { boolean, coerce, object, string, TypeOf, union } from 'zod';
-import { error } from '../views';
+import type { TypeOf } from 'zod';
+import { boolean, coerce, object, string, union } from 'zod';
+import { ConfigConnectionCliError } from '../errors';
+import { error, humanLog } from '../views';
 import { wrapParam } from './common';
 import { outputs } from './outputs';
 
@@ -35,27 +37,37 @@ export const printCliConnectionIssues = (options: any) => {
 	const { uri, host, database } = options || {};
 
 	if (!uri && (!host || !database)) {
-		console.log(outputs.singlestore.connection.required());
+		humanLog(outputs.singlestore.connection.required());
 	}
 };
 
 export const printConfigConnectionIssues = (
 	options: Record<string, unknown>,
-) => {
+): never => {
 	if ('url' in options) {
 		let text = `Please provide required params for SingleStore driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('url', options.url, false, 'url'));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'singlestore',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url, false, 'url'),
+			].join('\n'),
+		);
 	}
 
 	let text = `Please provide required params for SingleStore driver:\n`;
-	console.log(error(text));
-	console.log(wrapParam('host', options.host));
-	console.log(wrapParam('port', options.port, true));
-	console.log(wrapParam('user', options.user, true));
-	console.log(wrapParam('password', options.password, true, 'secret'));
-	console.log(wrapParam('database', options.database));
-	console.log(wrapParam('ssl', options.ssl, true));
-	process.exit(1);
+	throw new ConfigConnectionCliError(
+		'singlestore',
+		['host', 'database'],
+		[
+			error(text),
+			wrapParam('host', options.host),
+			wrapParam('port', options.port, true),
+			wrapParam('user', options.user, true),
+			wrapParam('password', options.password, true, 'secret'),
+			wrapParam('database', options.database),
+			wrapParam('ssl', options.ssl, true),
+		].join('\n'),
+	);
 };
diff --git a/drizzle-kit/src/cli/validations/sqlite.ts b/drizzle-kit/src/cli/validations/sqlite.ts
index 863886010a..dbcf00c9b2 100644
--- a/drizzle-kit/src/cli/validations/sqlite.ts
+++ b/drizzle-kit/src/cli/validations/sqlite.ts
@@ -1,5 +1,7 @@
-import { softAssertUnreachable } from 'src/global';
-import { literal, object, string, TypeOf, undefined, union } from 'zod';
+import type { TypeOf } from 'zod';
+import { literal, object, string, undefined as zUndefined, union } from 'zod';
+import { softAssertUnreachable } from '../../utils';
+import { ConfigConnectionCliError, UnsupportedCommandCliError } from '../errors';
 import { error } from '../views';
 import { sqliteDriver, wrapParam } from './common';
 
@@ -16,7 +18,11 @@ export const sqliteCredentials = union([
 		token: string().min(1),
 	}),
 	object({
-		driver: undefined(),
+		driver: literal('sqlite-cloud'),
+		url: string().min(1),
+	}),
+	object({
+		driver: zUndefined(),
 		url: string().min(1),
 	}).transform<{ url: string }>((o) => {
 		delete o.driver;
@@ -24,81 +30,124 @@ export const sqliteCredentials = union([
 	}),
 ]);
 
-export type SqliteCredentials =
-	| {
-		driver: 'd1-http';
-		accountId: string;
-		databaseId: string;
-		token: string;
-	}
-	| {
-		url: string;
-	};
+export type SqliteCredentials = {
+	driver: 'd1-http';
+	accountId: string;
+	databaseId: string;
+	token: string;
+} | {
+	driver: 'sqlite-cloud';
+	url: string;
+} | {
+	url: string;
+};
 
 const _: SqliteCredentials = {} as TypeOf<typeof sqliteCredentials>;
 
 export const printConfigConnectionIssues = (
 	options: Record<string, unknown>,
 	command: 'generate' | 'migrate' | 'push' | 'pull' | 'studio',
-) => {
+): never => {
 	const parsedDriver = sqliteDriver.safeParse(options.driver);
 	const driver = parsedDriver.success ? parsedDriver.data : ('' as never);
 
 	if (driver === 'expo') {
 		if (command === 'migrate') {
-			console.log(
+			throw new UnsupportedCommandCliError(
+				'migrate',
 				error(
 					`You can't use 'migrate' command with Expo SQLite, please follow migration instructions in our docs - https://orm.drizzle.team/docs/get-started-sqlite#expo-sqlite`,
 				),
+				{ dialect: 'Expo SQLite' },
 			);
 		} else if (command === 'studio') {
-			console.log(
+			throw new UnsupportedCommandCliError(
+				'studio',
 				error(
 					`You can't use 'studio' command with Expo SQLite, please use Expo Plugin https://www.npmjs.com/package/expo-drizzle-studio-plugin`,
 				),
+				{ dialect: 'Expo SQLite' },
 			);
 		} else if (command === 'pull') {
-			console.log(error("You can't use 'pull' command with Expo SQLite"));
+			throw new UnsupportedCommandCliError('pull', error("You can't use 'pull' command with Expo SQLite"), {
+				dialect: 'Expo SQLite',
+			});
 		} else if (command === 'push') {
-			console.log(error("You can't use 'push' command with Expo SQLite"));
+			throw new UnsupportedCommandCliError('push', error("You can't use 'push' command with Expo SQLite"), {
+				dialect: 'Expo SQLite',
+			});
 		} else {
-			console.log(error('Unexpected error with expo driver 🤔'));
+			throw new ConfigConnectionCliError('expo', ['driver'], error('Unexpected error with expo driver 🤔'), command);
 		}
-		process.exit(1);
 	} else if (driver === 'd1-http') {
 		let text = `Please provide required params for D1 HTTP driver:\n`;
-		console.log(error(text));
-		console.log(wrapParam('accountId', options.accountId));
-		console.log(wrapParam('databaseId', options.databaseId));
-		console.log(wrapParam('token', options.token, false, 'secret'));
-		process.exit(1);
+		throw new ConfigConnectionCliError(
+			'd1-http',
+			['accountId', 'databaseId', 'token'],
+			[
+				error(text),
+				wrapParam('accountId', options.accountId),
+				wrapParam('databaseId', options.databaseId),
+				wrapParam('token', options.token, false, 'secret'),
+			].join('\n'),
+			command,
+		);
 	} else if (driver === 'durable-sqlite') {
 		if (command === 'migrate') {
-			console.log(
-				error(
-					`You can't use 'migrate' command with SQLite Durable Objects`,
-				),
+			throw new UnsupportedCommandCliError(
+				'migrate',
+				error(`You can't use 'migrate' command with SQLite Durable Objects`),
+				{
+					dialect: 'SQLite Durable Objects',
+				},
 			);
 		} else if (command === 'studio') {
-			console.log(
-				error(
-					`You can't use 'studio' command with SQLite Durable Objects`,
-				),
+			throw new UnsupportedCommandCliError(
+				'studio',
+				error(`You can't use 'studio' command with SQLite Durable Objects`),
+				{
+					dialect: 'SQLite Durable Objects',
+				},
 			);
 		} else if (command === 'pull') {
-			console.log(error("You can't use 'pull' command with SQLite Durable Objects"));
+			throw new UnsupportedCommandCliError('pull', error("You can't use 'pull' command with SQLite Durable Objects"), {
+				dialect: 'SQLite Durable Objects',
+			});
 		} else if (command === 'push') {
-			console.log(error("You can't use 'push' command with SQLite Durable Objects"));
+			throw new UnsupportedCommandCliError('push', error("You can't use 'push' command with SQLite Durable Objects"), {
+				dialect: 'SQLite Durable Objects',
+			});
 		} else {
-			console.log(error('Unexpected error with SQLite Durable Object driver 🤔'));
+			throw new ConfigConnectionCliError(
+				'durable-sqlite',
+				['driver'],
+				error('Unexpected error with SQLite Durable Object driver 🤔'),
+				command,
+			);
 		}
-		process.exit(1);
+	} else if (driver === 'sqlite-cloud') {
+		let text = `Please provide required params for SQLite Cloud driver:\n`;
+		throw new ConfigConnectionCliError(
+			'sqlite-cloud',
+			['url'],
+			[
+				error(text),
+				wrapParam('url', options.url),
+			].join('\n'),
+			command,
+		);
 	} else {
 		softAssertUnreachable(driver);
 	}
 
 	let text = `Please provide required params:\n`;
-	console.log(error(text));
-	console.log(wrapParam('url', options.url));
-	process.exit(1);
+	throw new ConfigConnectionCliError(
+		'sqlite',
+		['url'],
+		[
+			error(text),
+			wrapParam('url', options.url),
+		].join('\n'),
+		command,
+	);
 };
diff --git a/drizzle-kit/src/cli/validations/studio.ts b/drizzle-kit/src/cli/validations/studio.ts
deleted file mode 100644
index cbbb3ac252..0000000000
--- a/drizzle-kit/src/cli/validations/studio.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { coerce, intersection, object, string, TypeOf, union } from 'zod';
-import { dialect } from '../../schemaValidator';
-import { mysqlCredentials } from './mysql';
-import { postgresCredentials } from './postgres';
-import { sqliteCredentials } from './sqlite';
-
-export const credentials = intersection(
-	postgresCredentials,
-	mysqlCredentials,
-	sqliteCredentials,
-);
-
-export type Credentials = TypeOf<typeof credentials>;
-
-export const studioCliParams = object({
-	port: coerce.number().optional().default(4983),
-	host: string().optional().default('127.0.0.1'),
-	config: string().optional(),
-});
-
-export const studioConfig = object({
-	dialect,
-	schema: union([string(), string().array()]).optional(),
-});
diff --git a/drizzle-kit/src/cli/views.ts b/drizzle-kit/src/cli/views.ts
index 9106d31cd8..34b1daea40 100644
--- a/drizzle-kit/src/cli/views.ts
+++ b/drizzle-kit/src/cli/views.ts
@@ -1,16 +1,52 @@
 import chalk from 'chalk';
 import { Prompt, render, SelectState, TaskView } from 'hanji';
-import type { CommonSchema } from '../schemaValidator';
-import { objectValues } from '../utils';
-import type { Named, NamedWithSchema } from './commands/migrate';
+import { stripAnsi } from 'hanji/utils';
+import type {
+	SchemaError as CockroachSchemaError,
+	SchemaWarning as CockroachSchemaWarning,
+} from '../dialects/cockroach/ddl';
+import type { JsonStatement as StatementCockroach } from '../dialects/cockroach/statements';
+import type { SchemaError as MssqlSchemaError } from '../dialects/mssql/ddl';
+import type { JsonStatement as StatementMssql } from '../dialects/mssql/statements';
+import type { SchemaError as MysqlSchemaError } from '../dialects/mysql/ddl';
+import type { JsonStatement as StatementMysql } from '../dialects/mysql/statements';
+import type {
+	SchemaError as PostgresSchemaError,
+	SchemaWarning as PostgresSchemaWarning,
+	View,
+} from '../dialects/postgres/ddl';
+import { vectorOps } from '../dialects/postgres/grammar';
+import type { JsonStatement as StatementPostgres } from '../dialects/postgres/statements';
+import type { SchemaError as SqliteSchemaError } from '../dialects/sqlite/ddl';
+import type { JsonStatement as StatementSqlite } from '../dialects/sqlite/statements';
+import type { Named, NamedWithSchema } from '../dialects/utils';
+import { assertUnreachable } from '../utils';
+import { outputFormat } from './context';
+import { highlightSQL } from './highlighter';
+import { withStyle } from './validations/outputs';
 
 export const warning = (msg: string) => {
 	render(`[${chalk.yellow('Warning')}] ${msg}`);
 };
+
 export const err = (msg: string) => {
-	render(`${chalk.bold.red('Error')} ${msg}`);
+	render(errText(msg));
+};
+
+export const errText = (msg: string) => `${chalk.bold.red('Error')} ${msg}`;
+
+export const humanLog = (...args: Parameters<typeof console.log>) => {
+	if (outputFormat() === 'json') return;
+	console.log(...args);
 };
 
+export const humanError = (...args: Parameters<typeof console.error>) => {
+	if (outputFormat() === 'json') return;
+	console.error(...args);
+};
+
+export const humanizeKind = (kind: string): string => kind.replaceAll('_', ' ');
+
 export const info = (msg: string, greyMsg: string = ''): string => {
 	return `${chalk.blue.bold('Info:')} ${msg} ${greyMsg ? chalk.grey(greyMsg) : ''}`.trim();
 };
@@ -22,79 +58,1243 @@ export const error = (error: string, greyMsg: string = ''): string => {
 	return `${chalk.bgRed.bold(' Error ')} ${error} ${greyMsg ? chalk.grey(greyMsg) : ''}`.trim();
 };
 
-export const schema = (schema: CommonSchema): string => {
-	type TableEntry = (typeof schema)['tables'][keyof (typeof schema)['tables']];
-	const tables = Object.values(schema.tables) as unknown as TableEntry[];
-
-	let msg = chalk.bold(`${tables.length} tables\n`);
-
-	msg += tables
-		.map((t) => {
-			const columnsCount = Object.values(t.columns).length;
-			const indexesCount = Object.values(t.indexes).length;
-			let foreignKeys: number = 0;
-			// Singlestore doesn't have foreign keys
-			if (schema.dialect !== 'singlestore') {
-				// @ts-expect-error
-				foreignKeys = Object.values(t.foreignKeys).length;
+export const postgresSchemaWarning = (warning: PostgresSchemaWarning): string => {
+	if (warning.type === 'policy_not_linked') {
+		return withStyle.errorWarning(
+			`"Policy ${warning.policy} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`,
+		);
+	}
+
+	assertUnreachable(warning.type);
+};
+
+export const cockroachSchemaWarning = (warning: CockroachSchemaWarning): string => {
+	if (warning.type === 'policy_not_linked') {
+		return withStyle.errorWarning(
+			`"Policy ${warning.policy} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`,
+		);
+	}
+
+	assertUnreachable(warning.type);
+};
+
+export const sqliteSchemaError = (error: SqliteSchemaError): string => {
+	if (error.type === 'conflict_table') {
+		return `'${error.table}' table name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_check') {
+		return `'${error.name}' check constraint name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_unique') {
+		return `'${error.name}' unique constraint name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_view') {
+		return `'${error.view}' view name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_column') {
+		return `'${error.column}' column name is a duplicate across '${error.table}' table`;
+	}
+
+	if (error.type === 'conflict_fk') {
+		return `'${error.name}' foreign key name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_index') {
+		return `'${error.name}' index name is a duplicate`;
+	}
+
+	if (error.type === 'conflict_pk') {
+		return `'${error.name}' primary key name is a duplicate`;
+	}
+
+	if (error.type === 'table_no_columns') {
+		return `'${error.table}' table has no columns`;
+	}
+
+	assertUnreachable(error);
+};
+
+function formatOptionChanges(
+	oldState: Record<string, string | boolean | number | null> | null,
+	newState: Record<string, string | boolean | number | null> | null,
+): string {
+	if (oldState === null && newState) {
+		const keys = Object.keys(newState) as Array<keyof View['with']>;
+		return keys
+			.map((key) => `${key}: null -> ${key}: ${String(newState[key])}`)
+			.join('\n');
+	}
+
+	if (newState === null && oldState) {
+		const keys = Object.keys(oldState) as Array<keyof View['with']>;
+		return keys
+			.map((key) => `${key}: ${String(oldState[key])} -> ${key}: null`)
+			.join('\n');
+	}
+
+	if (oldState && newState) {
+		const keys = Object.keys(newState) as Array<keyof View['with']>;
+		return keys
+			.filter((key) => oldState[key] !== newState[key])
+			.map((key) => `${key}: ${String(oldState[key])} -> ${key}: ${String(newState[key])}`)
+			.join('\n');
+	}
+
+	return '';
+}
+
+export const explain = (
+	dialect: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'mssql' | 'common' | 'cockroach',
+	grouped: {
+		jsonStatement: StatementPostgres | StatementSqlite | StatementMysql | StatementMssql | StatementCockroach;
+		sqlStatements: string[];
+	}[],
+	hints: { hint: string; statement?: string }[],
+) => {
+	const res = [];
+	const explains = [];
+	for (const { jsonStatement, sqlStatements } of grouped) {
+		const res = dialect === 'postgres'
+			? psqlExplain(jsonStatement as StatementPostgres)
+			: dialect === 'sqlite'
+			? sqliteExplain(jsonStatement as StatementSqlite)
+			: dialect === 'mysql'
+			? mysqlExplain(jsonStatement as StatementMysql)
+			: dialect === 'mssql'
+			? mssqlExplain(jsonStatement as StatementMssql)
+			: dialect === 'cockroach'
+			? cockroachExplain(jsonStatement as StatementCockroach)
+			: null;
+
+		if (res) {
+			let msg = `┌─── ${res.title}\n`;
+			msg += res.cause;
+			msg += `├───\n`;
+			for (const sql of sqlStatements) {
+				msg += `│ ${highlightSQL(sql)}\n`;
 			}
+			msg += `└───\n`;
+			explains.push(msg);
+		} else {
+			explains.push(...sqlStatements.map((x) => highlightSQL(x)));
+		}
+	}
 
-			return `${chalk.bold.blue(t.name)} ${
-				chalk.gray(
-					`${columnsCount} columns ${indexesCount} indexes ${foreignKeys} fks`,
-				)
-			}`;
-		})
-		.join('\n');
-
-	msg += '\n';
-
-	const enums = objectValues(
-		'enums' in schema
-			? 'values' in schema['enums']
-				? schema['enums']
-				: {}
-			: {},
-	);
-
-	if (enums.length > 0) {
-		msg += '\n';
-		msg += chalk.bold(`${enums.length} enums\n`);
-
-		msg += enums
-			.map((it) => {
-				return `${chalk.bold.blue(it.name)} ${
-					chalk.gray(
-						`[${Object.values(it.values).join(', ')}]`,
+	if (explains.length > 0) {
+		res.push('\n');
+		res.push(chalk.gray(`--- Generated migration statements ---\n`));
+		res.push(explains.join('\n'));
+	}
+
+	if (hints.length > 0) {
+		res.push('\n\n');
+		res.push(withStyle.warning(`There're potential data loss statements:\n`));
+
+		for (const h of hints) {
+			res.push(`· ${h.hint}\n`);
+			if (h.statement) res.push(highlightSQL(h.statement), '\n');
+		}
+	}
+	return res.join('');
+};
+
+export const psqlExplain = (st: StatementPostgres) => {
+	let title = '';
+	let cause = '';
+
+	if (st.type === 'alter_column') {
+		const r = st.to;
+		const d = st.diff;
+
+		const key = `${r.schema}.${r.table}.${r.name}`;
+		title += `${key} column changed:`;
+		if (d.default) cause += `│ default: ${d.default.from} -> ${d.default.to}\n`;
+		if (d.type) cause += `│ type: ${d.type.from} -> ${d.type.to}\n`;
+		if (d.notNull) cause += `│ notNull: ${d.notNull.from} -> ${d.notNull.to}\n`;
+		if (d.dimensions) cause += `│ dimensions: ${d.dimensions.from} -> ${d.dimensions.to}\n`;
+
+		// TODO check manually
+		if (d.identity) cause += `│ identity: ${formatOptionChanges(d.identity.from, d.identity.to)}\n`;
+	}
+
+	if (st.type === 'recreate_column') {
+		const { diff: d } = st;
+
+		const key = `${d.$right.schema}.${d.$right.table}.${d.$right.name}`;
+		title += `${key} column recreated:`;
+		if (d.generated) {
+			const from = d.generated.from ? `${d.generated.from.as} ${d.generated.from.type}` : 'null';
+			const to = d.generated.to ? `${d.generated.to.as} ${d.generated.to.type}` : 'null';
+			cause += `│ generated: ${from} -> ${to}\n`;
+		}
+	}
+
+	if (st.type === 'recreate_index') {
+		const diff = st.diff;
+		const idx = diff.$right;
+		const key = `${idx.schema}.${idx.table}.${idx.name}`;
+		title += `${key} index changed:`;
+		if (diff.isUnique) cause += `│ unique: ${diff.isUnique.from} -> ${diff.isUnique.to}\n`;
+		if (diff.where) cause += `│ where: ${diff.where.from} -> ${diff.where.to}\n`;
+		if (diff.method) cause += `│ where: ${diff.method.from} -> ${diff.method.to}\n`;
+	}
+
+	if (st.type === 'recreate_fk') {
+		const { fk, diff } = st;
+		const key = `${fk.schema}.${fk.table}.${fk.name}`;
+		title += `${key} index changed:`;
+		if (diff.onUpdate) cause += `│ where: ${diff.onUpdate.from} -> ${diff.onUpdate.to}\n`;
+		if (diff.onDelete) cause += `│ onDelete: ${diff.onDelete.from} -> ${diff.onDelete.to}\n`;
+	}
+
+	if (st.type === 'recreate_enum') {
+		const { to, from } = st;
+		title = `${to.schema}.${to.name} enum changed:`;
+		cause += `│ values shuffled/removed: [${from.values.join(',')}] -> [${to.values.join(',')}]\n`;
+	}
+
+	if (st.type === 'alter_enum') {
+		const r = st.to;
+		const l = st.from;
+		const d = st.diff;
+
+		title = `${r.schema}.${r.name} enum changed:`;
+		cause += `│ changes: [${r.values.join(',')}] -> [${l.values.join(',')}]\n`;
+		cause += `│ values added: ${d.filter((it) => it.type === 'added').map((it) => it.value).join(',')}\n`;
+	}
+
+	if (st.type === 'alter_role') {
+		const d = st.diff;
+		const to = st.role;
+
+		const key = `${to.name}`;
+		title = `${key} role changed:`;
+		if (d.bypassRls) cause += `│ bypassRls: ${d.bypassRls.from} -> ${d.bypassRls.to}\n`;
+		if (d.canLogin) cause += `│ canLogin: ${d.canLogin.from} -> ${d.canLogin.to}\n`;
+		if (d.connLimit) cause += `│ connLimit: ${d.connLimit.from} -> ${d.connLimit.to}\n`;
+		if (d.createDb) cause += `│ createDb: ${d.createDb.from} -> ${d.createDb.to}\n`;
+		if (d.createRole) cause += `│ createRole: ${d.createRole.from} -> ${d.createRole.to}\n`;
+		if (d.inherit) cause += `│ inherit: ${d.inherit.from} -> ${d.inherit.to}\n`;
+		if (d.password) cause += `│ password: ${d.password.from} -> ${d.password.to}\n`;
+		if (d.replication) cause += `│ replication: ${d.replication.from} -> ${d.replication.to}\n`;
+		if (d.superuser) cause += `│ superuser: ${d.superuser.from} -> ${d.superuser.to}\n`;
+		if (d.validUntil) cause += `│ validUntil: ${d.validUntil.from} -> ${d.validUntil.to}\n`;
+	}
+
+	if (st.type === 'alter_sequence') {
+		const d = st.diff;
+		const to = st.sequence;
+
+		const key = `${to.schema}.${to.name}`;
+		title = `${key} sequence changed:`;
+		if (d.cacheSize) cause += `│ cacheSize: ${d.cacheSize.from} -> ${d.cacheSize.to}\n`;
+		if (d.cycle) cause += `│ cycle: ${d.cycle.from} -> ${d.cycle.to}\n`;
+		if (d.incrementBy) cause += `│ incrementBy: ${d.incrementBy.from} -> ${d.incrementBy.to}\n`;
+		if (d.maxValue) cause += `│ maxValue: ${d.maxValue.from} -> ${d.maxValue.to}\n`;
+		if (d.minValue) cause += `│ minValue: ${d.minValue.from} -> ${d.minValue.to}\n`;
+		if (d.startWith) cause += `│ startWith: ${d.startWith.from} -> ${d.startWith.to}\n`;
+	}
+
+	if (st.type === 'alter_rls') {
+		const key = `${st.schema}.${st.name}`;
+		title = `${key} rls changed:\n`;
+		cause += `│ rlsEnabled: ${!st.isRlsEnabled} -> ${st.isRlsEnabled}\n`;
+	}
+
+	if (st.type === 'alter_policy' || st.type === 'recreate_policy') {
+		const d = st.diff;
+		const to = st.policy;
+
+		const key = `${to.schema}.${to.table}.${to.name}`;
+		title = `${key} policy changed:`;
+		if (d.as) cause += `│ as: ${d.as.from} -> ${d.as.to}\n`;
+		if (d.for) cause += `│ for: ${d.for.from} -> ${d.for.to}\n`;
+		if (d.roles) cause += `│ roles: [${d.roles.from.join(',')}] -> [${d.roles.to.join(',')}]\n`;
+		if (d.using) cause += `│ using: ${d.using.from} -> ${d.using.to}\n`;
+		if (d.withCheck) cause += `│ withCheck: ${d.withCheck.from} -> ${d.withCheck.to}\n`;
+	}
+
+	if (st.type === 'alter_unique') {
+		const d = st.diff;
+		const to = d.$right;
+
+		const key = `${to.schema}.${to.table}.${to.name}`;
+		title = `${key} unique changed:`;
+		if (d.nullsNotDistinct) cause += `│ nullsNotDistinct: ${d.nullsNotDistinct.from} -> ${d.nullsNotDistinct.to}\n`;
+		if (d.columns) cause += `│ columns: [${d.columns.from.join(',')}] -> [${d.columns.to.join(',')}]\n`;
+	}
+
+	if (st.type === 'alter_check') {
+		const d = st.diff;
+
+		const key = `${d.schema}.${d.table}.${d.name}`;
+		title = `${key} check changed:`;
+		if (d.value) cause += `│ definition: ${d.value.from} -> ${d.value.to}\n`;
+	}
+
+	if (st.type === 'alter_pk') {
+		const d = st.diff;
+
+		const key = `${d.schema}.${d.table}.${d.name}`;
+		title += `${key} pk changed:`;
+		if (d.columns) cause += `│ columns: [${d.columns.from.join(',')}] -> [${d.columns.to.join(',')}]\n`;
+	}
+
+	if (st.type === 'alter_view') {
+		const d = st.diff;
+
+		const key = `${d.schema}.${d.name}`;
+		title += `${key} view changed:`;
+		// This should trigger recreate_view
+		// if (d.definition) msg += `│ definition: ${d.definition.from} -> ${d.definition.to}\n`;
+
+		// TODO alter materialized? Should't it be recreate?
+		if (d.materialized) cause += `│ materialized: ${d.materialized.from} -> ${d.materialized.to}\n`;
+
+		if (d.tablespace) cause += `│ tablespace: ${d.tablespace.from} -> ${d.tablespace.to}\n`;
+		if (d.using) cause += `│ using: ${d.using.from} -> ${d.using.to}\n`;
+		if (d.withNoData) cause += `│ withNoData: ${d.withNoData.from} -> ${d.withNoData.to}\n`;
+		if (d.with) cause += `| with: ${formatOptionChanges(d.with.from, d.with.to)}`;
+	}
+
+	if (st.type === 'drop_view' && st.cause) {
+		const { cause: from, view: to } = st;
+
+		const key = `${to.schema}.${to.name}`;
+		title += `${key} view changed:`;
+		cause += `│ definition: [${from.definition}] -> [${to.definition}]\n`;
+	}
+
+	if (st.type === 'regrant_privilege') {
+		const { privilege, diff } = st;
+
+		const key = `${privilege.name}`;
+		title += `${key} privilege changed:`;
+		if (diff.grantee) cause += `│ grantee: [${diff.grantee.from}] -> [${diff.grantee.to}]\n`;
+		if (diff.grantor) cause += `│ grantor: [${diff.grantor.from}] -> [${diff.grantor.to}]\n`;
+		if (diff.isGrantable) cause += `│ isGrantable: [${diff.isGrantable.from}] -> [${diff.isGrantable.to}]\n`;
+		if (diff.type) cause += `│ type: [${diff.type.from}] -> [${diff.type.to}]\n`;
+	}
+
+	if (title) return { title, cause };
+
+	return null;
+};
+
+export const cockroachExplain = (st: StatementCockroach) => {
+	let title = '';
+	let cause = '';
+
+	if (st.type === 'alter_column') {
+		const r = st.to;
+		const d = st.diff;
+
+		const key = `${r.schema}.${r.table}.${r.name}`;
+		title += `${key} column changed:`;
+		if (d.default) cause += `│ default: ${d.default.from} -> ${d.default.to}\n`;
+		if (d.type) cause += `│ type: ${d.type.from} -> ${d.type.to}\n`;
+		if (d.notNull) cause += `│ notNull: ${d.notNull.from} -> ${d.notNull.to}\n`;
+		if (d.dimensions) cause += `│ dimensions: ${d.dimensions.from} -> ${d.dimensions.to}\n`;
+
+		// TODO check manually
+		if (d.identity) cause += `│ identity: ${formatOptionChanges(d.identity.from, d.identity.to)}\n`;
+	}
+
+	if (st.type === 'recreate_column') {
+		const { diff: d } = st;
+
+		const key = `${d.$right.schema}.${d.$right.table}.${d.$right.name}`;
+		title += `${key} column recreated:`;
+		if (d.generated) {
+			const from = d.generated.from ? `${d.generated.from.as} ${d.generated.from.type}` : 'null';
+			const to = d.generated.to ? `${d.generated.to.as} ${d.generated.to.type}` : 'null';
+			cause += `│ generated: ${from} -> ${to}\n`;
+		}
+	}
+
+	if (st.type === 'recreate_index') {
+		const diff = st.diff;
+		const idx = diff.$right;
+		const key = `${idx.schema}.${idx.table}.${idx.name}`;
+		title += `${key} index changed:`;
+		if (diff.isUnique) cause += `│ unique: ${diff.isUnique.from} -> ${diff.isUnique.to}\n`;
+		if (diff.where) cause += `│ where: ${diff.where.from} -> ${diff.where.to}\n`;
+		if (diff.method) cause += `│ method: ${diff.method.from} -> ${diff.method.to}\n`;
+	}
+
+	if (st.type === 'recreate_fk') {
+		const { fk, diff } = st;
+		const key = `${fk.schema}.${fk.table}.${fk.name}`;
+		title += `${key} index changed:`;
+		if (diff.onUpdate) cause += `│ where: ${diff.onUpdate.from} -> ${diff.onUpdate.to}\n`;
+		if (diff.onDelete) cause += `│ onDelete: ${diff.onDelete.from} -> ${diff.onDelete.to}\n`;
+	}
+
+	if (st.type === 'recreate_enum') {
+		const { to, from } = st;
+		title = `${to.schema}.${to.name} enum changed:`;
+		cause += `│ values shuffled/removed: [${from.values.join(',')}] -> [${to.values.join(',')}]\n`;
+	}
+
+	if (st.type === 'alter_enum') {
+		const r = st.to;
+		const l = st.from;
+		const d = st.diff;
+
+		title = `${r.schema}.${r.name} enum changed:`;
+		cause += `│ changes: [${r.values.join(',')}] -> [${l.values.join(',')}]\n`;
+		cause += `│ values added: ${d.filter((it) => it.type === 'added').map((it) => it.value).join(',')}\n`;
+	}
+
+	if (st.type === 'alter_role') {
+		const d = st.diff;
+		const to = st.role;
+
+		const key = `${to.name}`;
+		title = `${key} role changed:`;
+		if (d.createDb) cause += `│ createDb: ${d.createDb.from} -> ${d.createDb.to}\n`;
+		if (d.createRole) cause += `│ createRole: ${d.createRole.from} -> ${d.createRole.to}\n`;
+	}
+
+	if (st.type === 'alter_sequence') {
+		const d = st.diff;
+		const to = st.sequence;
+
+		const key = `${to.schema}.${to.name}`;
+		title = `${key} sequence changed:`;
+		if (d.cacheSize) cause += `│ cacheSize: ${d.cacheSize.from} -> ${d.cacheSize.to}\n`;
+		if (d.incrementBy) cause += `│ incrementBy: ${d.incrementBy.from} -> ${d.incrementBy.to}\n`;
+		if (d.maxValue) cause += `│ maxValue: ${d.maxValue.from} -> ${d.maxValue.to}\n`;
+		if (d.minValue) cause += `│ minValue: ${d.minValue.from} -> ${d.minValue.to}\n`;
+		if (d.startWith) cause += `│ startWith: ${d.startWith.from} -> ${d.startWith.to}\n`;
+	}
+
+	if (st.type === 'alter_rls') {
+		const key = `${st.schema}.${st.name}`;
+		title = `${key} rls changed:\n`;
+		cause += `│ rlsEnabled: ${!st.isRlsEnabled} -> ${st.isRlsEnabled}\n`;
+	}
+
+	if (st.type === 'alter_policy' || st.type === 'recreate_policy') {
+		const d = st.diff;
+		const to = st.policy;
+
+		const key = `${to.schema}.${to.table}.${to.name}`;
+		title = `${key} policy changed:`;
+		if (d.as) cause += `│ as: ${d.as.from} -> ${d.as.to}\n`;
+		if (d.for) cause += `│ for: ${d.for.from} -> ${d.for.to}\n`;
+		if (d.roles) cause += `│ roles: [${d.roles.from.join(',')}] -> [${d.roles.to.join(',')}]\n`;
+		if (d.using) cause += `│ using: ${d.using.from} -> ${d.using.to}\n`;
+		if (d.withCheck) cause += `│ withCheck: ${d.withCheck.from} -> ${d.withCheck.to}\n`;
+	}
+
+	if (st.type === 'alter_check') {
+		const d = st.diff;
+
+		const key = `${d.schema}.${d.table}.${d.name}`;
+		title = `${key} check changed:`;
+		if (d.value) cause += `│ definition: ${d.value.from} -> ${d.value.to}\n`;
+	}
+
+	if (st.type === 'alter_pk') {
+		const d = st.diff;
+
+		const key = `${d.schema}.${d.table}.${d.name}`;
+		title += `${key} pk changed:`;
+		if (d.columns) cause += `│ columns: [${d.columns.from.join(',')}] -> [${d.columns.to.join(',')}]\n`;
+	}
+
+	if (st.type === 'recreate_view') {
+		const { from, to } = st;
+
+		const key = `${to.schema}.${to.name}`;
+		title += `${key} view changed:`;
+		cause += `│ definition: [${from.definition}] -> [${to.definition}]\n`;
+	}
+
+	if (title) return { title, cause };
+
+	return null;
+};
+
+export const mysqlExplain = (
+	st: StatementMysql,
+) => {
+	let title = '';
+	let cause = '';
+
+	if (st.type === 'alter_column') {
+		const r = st.diff.$right;
+		const d = st.diff;
+
+		const key = `${r.table}.${r.name}`;
+		title += `${key} column changed:\n`;
+		if (d.default) cause += `│ default: ${d.default.from} -> ${d.default.to}\n`;
+		if (d.type) cause += `│ type: ${d.type.from} -> ${d.type.to}\n`;
+		if (d.notNull) cause += `│ notNull: ${d.notNull.from} -> ${d.notNull.to}\n`;
+		if (d.autoIncrement) cause += `│ autoIncrement: ${d.autoIncrement.from} -> ${d.autoIncrement.to}\n`;
+		if (d.charSet) cause += `│ charSet: ${d.charSet.from} -> ${d.charSet.to}\n`;
+		if (d.collation) cause += `│ collation: ${d.collation.from} -> ${d.collation.to}\n`;
+		if (d.onUpdateNow) cause += `│ onUpdateNow: ${d.onUpdateNow.from} -> ${d.onUpdateNow.to}\n`;
+		if (d.onUpdateNowFsp) cause += `│ onUpdateNowFsp: ${d.onUpdateNowFsp.from} -> ${d.onUpdateNowFsp.to}\n`;
+	}
+
+	if (st.type === 'recreate_column') {
+		const { column, diff } = st;
+
+		const key = `${column.table}.${column.name}`;
+		title += `${key} column recreated:\n`;
+		if (diff.generated) {
+			const from = diff.generated.from ? `${diff.generated.from.as} ${diff.generated.from.type}` : 'null';
+			const to = diff.generated.to ? `${diff.generated.to.as} ${diff.generated.to.type}` : 'null';
+			cause += `│ generated: ${from} -> ${to}\n`;
+		}
+	}
+
+	if (st.type === 'alter_view') {
+		const { diff, view } = st;
+
+		const key = `${view.name}`;
+		title += `${key} view changed:\n`;
+		if (diff.algorithm) cause += `│ algorithm: ${diff.algorithm.from} -> ${diff.algorithm.to}\n`;
+		if (diff.definition) cause += `│ definition: ${diff.definition.from} -> ${diff.definition.to}\n`;
+		if (diff.sqlSecurity) cause += `│ sqlSecurity: ${diff.sqlSecurity.from} -> ${diff.sqlSecurity.to}\n`;
+		if (diff.withCheckOption) {
+			cause += `│ withCheckOption: ${diff.withCheckOption.from} -> ${diff.withCheckOption.to}\n`;
+		}
+	}
+
+	if (title) return { title, cause };
+
+	return null;
+};
+
+export const mssqlExplain = (
+	st: StatementMssql,
+) => {
+	let title = '';
+	let cause = '';
+
+	if (st.type === 'alter_column') {
+		const r = st.diff.$right;
+		const d = st.diff;
+
+		const key = `${r.schema}.${r.table}.${r.name}`;
+		title += `${key} column changed:\n`;
+		if (d.type) cause += `│ type: ${d.type.from} -> ${d.type.to}\n`;
+		if (d.notNull) cause += `│ notNull: ${d.notNull.from} -> ${d.notNull.to}\n`;
+	}
+
+	if (st.type === 'recreate_column') {
+		const { diff } = st;
+
+		const key = `${diff.$right.schema}.${diff.$right.table}.${diff.$right.name}`;
+		title += `${key} column recreated:\n`;
+		if (diff.generated) {
+			const from = diff.generated.from ? `${diff.generated.from.as} ${diff.generated.from.type}` : 'null';
+			const to = diff.generated.to ? `${diff.generated.to.as} ${diff.generated.to.type}` : 'null';
+			cause += `│ generated: ${from} -> ${to}\n`;
+		}
+	}
+	if (st.type === 'recreate_identity_column') {
+		const { column } = st;
+
+		const key = `${column.$right.schema}.${column.$right.table}.${column.$right.name}`;
+		title += `${key} column recreated:\n`;
+		if (column.identity) {
+			const from = column.identity.from ? `${column.identity.from.increment} ${column.identity.from.seed}` : 'null';
+			const to = column.identity.to ? `${column.identity.to.increment} ${column.identity.to.seed}` : 'null';
+			cause += `│ identity: ${from} -> ${to}\n`;
+		}
+	}
+
+	if (st.type === 'alter_view') {
+		const { diff, view } = st;
+
+		const key = `${view.schema}.${view.name}`;
+		title += `${key} view changed:\n`;
+		if (diff.checkOption) cause += `│ checkOption: ${diff.checkOption.from} -> ${diff.checkOption.to}\n`;
+		if (diff.definition) cause += `│ definition: ${diff.definition.from} -> ${diff.definition.to}\n`;
+		if (diff.encryption) cause += `│ encryption: ${diff.encryption.from} -> ${diff.encryption.to}\n`;
+		if (diff.schemaBinding) {
+			cause += `│ schemaBinding: ${diff.schemaBinding.from} -> ${diff.schemaBinding.to}\n`;
+		}
+		if (diff.viewMetadata) {
+			cause += `│ viewMetadata: ${diff.viewMetadata.from} -> ${diff.viewMetadata.to}\n`;
+		}
+	}
+
+	if (st.type === 'recreate_default') {
+		const { from, to } = st;
+
+		const key = `${to.schema}.${to.name}`;
+		title += `${key} default changed:\n`;
+		cause += `│ default: ${from.default} -> ${to.default}\n`;
+	}
+
+	if (title) return { title, cause };
+
+	return null;
+};
+
+export const sqliteExplain = (
+	st: StatementSqlite,
+) => {
+	let title = '';
+	let cause = '';
+
+	if (st.type === 'recreate_table') {
+		const {
+			to,
+			alteredColumnsBecameGenerated,
+			checkDiffs,
+			checksAlters,
+			columnAlters,
+			fksAlters,
+			fksDiff,
+			indexesDiff,
+			newStoredColumns,
+			pksAlters,
+			pksDiff,
+			uniquesAlters,
+			uniquesDiff,
+		} = st;
+
+		const key = `${to.name}`;
+
+		title += `${key} table recreated:\n`;
+
+		const blocks: string[][] = [];
+
+		if (alteredColumnsBecameGenerated.length) {
+			blocks.push([
+				`│ Columns become generated stored: ${alteredColumnsBecameGenerated.map((it) => `${it.name}`).join(', ')}\n`,
+				`│ It is not possible to make existing column as generated STORED\n`,
+			]);
+		}
+
+		if (checkDiffs.length) {
+			const createdChecks = checkDiffs.filter((it) => it.$diffType === 'create');
+			const droppedChecks = checkDiffs.filter((it) => it.$diffType === 'drop');
+
+			if (createdChecks.length) {
+				blocks.push([`| Check constraints added: ${createdChecks.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+
+			if (droppedChecks.length) {
+				blocks.push([`| Check constraints dropped: ${droppedChecks.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+		}
+
+		if (checksAlters.length) {
+			blocks.push([
+				`│ Check constraints altered definition:\n`,
+				`│ ${checksAlters.map((it) => `${it.name}: ${it.$left.value} -> ${it.$right.value}`).join(',\n')}\n`,
+			]);
+		}
+
+		if (columnAlters.filter((it) => it.type || it.default || it.autoincrement || it.notNull).length) {
+			let res: string = '';
+			const alteredNotNull = columnAlters.filter((it) => it.notNull);
+			const alteredType = columnAlters.filter((it) => it.type);
+			const alteredDefault = columnAlters.filter((it) => it.default);
+			const alteredAutoincrement = columnAlters.filter((it) => it.autoincrement);
+
+			res += `│ Columns altered:\n`;
+			if (alteredNotNull.length) {
+				res += `${
+					alteredNotNull.map((it) => `│ ${it.name} => notNull: ${it.notNull?.from} -> ${it.notNull?.to}`).join(
+						'\n',
 					)
-				}`;
-			})
-			.join('\n');
-		msg += '\n';
+				}\n`;
+			}
+			if (alteredType.length) {
+				res += `${alteredType.map((it) => `│ ${it.name} => type: ${it.type?.from} -> ${it.type?.to}`).join('\n')}\n`;
+			}
+			if (alteredDefault.length) {
+				res += `${
+					alteredDefault.map((it) => `│ ${it.name} => default: ${it.default?.from} -> ${it.default?.to}`).join(
+						'\n',
+					)
+				}\n`;
+			}
+			if (alteredAutoincrement.length) {
+				res += `${
+					alteredAutoincrement.map((it) =>
+						`│ ${it.name} => autoincrement: ${it.autoincrement?.from} -> ${it.autoincrement?.to}`
+					).join('\n')
+				}\n`;
+			}
+
+			blocks.push([res]);
+		}
+
+		if (uniquesDiff.length) {
+			const uniquesCreated = uniquesDiff.filter((it) => it.$diffType === 'create');
+			const uniquesDropped = uniquesDiff.filter((it) => it.$diffType === 'drop');
+			if (uniquesCreated.length) {
+				blocks.push([`│ Unique constraints added: ${uniquesCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (uniquesDropped.length) {
+				blocks.push([`│ Unique constraints dropped: ${uniquesDropped.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+		}
+
+		if (pksDiff.length) {
+			const pksCreated = pksDiff.filter((it) => it.$diffType === 'create');
+			const pksDropped = pksDiff.filter((it) => it.$diffType === 'drop');
+
+			if (pksCreated.length) {
+				blocks.push([`│ Primary key constraints added: ${pksCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (pksDropped.length) {
+				blocks.push([`│ Primary key constraints dropped: ${pksDropped.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+		}
+
+		if (newStoredColumns.length) {
+			blocks.push([
+				`| Stored columns added: ${newStoredColumns.map((it) => `${it.name}`).join(', ')}\n`,
+			]);
+		}
+
+		if (pksAlters.length) {
+			blocks.push([
+				`│ Primary key was altered:\n`,
+				`${
+					pksAlters.filter((it) => it.columns).map((it) =>
+						`[${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
+					)
+				}\n`,
+			]);
+		}
+
+		if (uniquesAlters.length) {
+			blocks.push([
+				`│ Unique constraint was altered:\n`,
+				`${
+					uniquesAlters.filter((it) => it.columns).map((it) =>
+						`│ name: ${it.name} => columns: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]\n`
+					)
+				}\n`,
+			]);
+		}
+
+		if (fksAlters.length) {
+			let res: string = '';
+
+			const columnsAltered = fksAlters.filter((it) => it.columns);
+			const columnsToAltered = fksAlters.filter((it) => it.columnsTo);
+			const tablesToAltered = fksAlters.filter((it) => it.tableTo);
+			const onUpdateAltered = fksAlters.filter((it) => it.onUpdate);
+			const onDeleteAltered = fksAlters.filter((it) => it.onDelete);
+
+			res += columnsAltered.length > 0 && columnsToAltered.length > 0 && tablesToAltered.length > 0
+					&& onUpdateAltered.length > 0 && onDeleteAltered.length > 0
+				? `│ Foreign key constraint was altered:\n`
+				: '';
+			if (columnsAltered.length) {
+				res += `${
+					columnsAltered.map((it) =>
+						`│ name: ${it.name} => columns: [${it.columns?.from.join(',')}] -> [${it.columns?.to.join(',')}]`
+					)
+				}\n`;
+			}
+			if (columnsToAltered.length) {
+				res += ` ${
+					columnsToAltered.map((it) =>
+						`│ name: ${it.name} => columnsTo: [${it.columnsTo?.from.join(',')}] -> [${it.columnsTo?.to.join(',')}]`
+					)
+				}\n`;
+			}
+			if (tablesToAltered.length) {
+				res += `${
+					tablesToAltered.map((it) => `│ name: ${it.name} => tableTo: [${it.tableTo?.from}] -> [${it.tableTo?.to}]`)
+				}\n`;
+			}
+			if (onUpdateAltered.length) {
+				res += `${
+					onUpdateAltered.map((it) => `│ name: ${it.name} => onUpdate: [${it.onUpdate?.from}] -> [${it.onUpdate?.to}]`)
+				}\n`;
+			}
+			if (onDeleteAltered.length) {
+				res += `${
+					onDeleteAltered.map((it) => `│ name: ${it.name} => onDelete: [${it.onDelete?.from}] -> [${it.onDelete?.to}]`)
+				}\n`;
+			}
+
+			if (res) blocks.push([res]);
+		}
+
+		if (fksDiff.length) {
+			const fksCreated = fksDiff.filter((it) => it.$diffType === 'create');
+			const fksDropped = fksDiff.filter((it) => it.$diffType === 'drop');
+			if (fksCreated.length) {
+				blocks.push([`| Foreign key constraints added: ${fksCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (fksDropped.length) {
+				blocks.push([`| Foreign key constraints dropped: ${fksDropped.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+		}
+
+		if (indexesDiff.filter((it) => it.isUnique && it.origin === 'auto').length) {
+			const indexCreated = indexesDiff.filter((it) => it.$diffType === 'create');
+			const indexDropped = indexesDiff.filter((it) => it.$diffType === 'drop');
+			if (indexCreated.length) {
+				blocks.push([`| System generated index added: ${indexCreated.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+			if (indexDropped.length) {
+				blocks.push([`| System generated index dropped: ${indexDropped.map((it) => `${it.name}`).join(', ')}\n`]);
+			}
+		}
+
+		cause += blocks.map((it) => it.join('')).join('├─\n');
+	}
+
+	if (st.type === 'recreate_column') {
+		const {
+			column,
+			diffGenerated,
+		} = st;
+
+		const key = `${column.name}`;
+
+		title += `${key} column recreated:\n`;
+
+		cause += `| generated: ${
+			diffGenerated && diffGenerated.from ? diffGenerated.from.as + ' ' + diffGenerated.from.type : 'null'
+		} -> ${diffGenerated && diffGenerated.to ? diffGenerated.to.as + ' ' + diffGenerated.to.type : 'null'}`;
+	}
+
+	if (title) return { title, cause };
+
+	return null;
+};
+
+export const explainJsonOutput = (
+	dialect: string,
+	statements: (StatementPostgres | StatementSqlite | StatementMysql | StatementMssql | StatementCockroach)[],
+	hints: { hint: string; statement?: string }[],
+) => {
+	return {
+		status: 'ok' as const,
+		dialect,
+		statements,
+		hints: hints.map((h) => ({ hint: stripAnsi(h.hint) })),
+	};
+};
+
+export const postgresSchemaError = (error: PostgresSchemaError): string => {
+	if (error.type === 'constraint_name_duplicate') {
+		const { name, schema, table } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		const constraintName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate constraint name ${constraintName} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'index_duplicate') {
+		// check for index names duplicates
+		const { schema, table, name } = error;
+		const sch = chalk.underline.blue(`"${schema}"`);
+		const idx = chalk.underline.blue(`'${name}'`);
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate index name ${idx} in ${sch} schema in ${tableName}`,
+		);
+	}
+
+	if (error.type === 'index_no_name') {
+		const { schema, table, sql } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`Please specify an index name in ${tableName} table that has "${sql}" expression.\n\nWe can generate index names for indexes on columns only; for expressions in indexes, you need to specify index name yourself.`,
+		);
+	}
+
+	if (error.type === 'pgvector_index_noop') {
+		const { table, indexName, column, method } = error;
+		return withStyle.errorWarning(
+			`You are specifying an index on the ${
+				chalk.blueBright(
+					column,
+				)
+			} column inside the ${
+				chalk.blueBright(
+					table,
+				)
+			} table with the ${
+				chalk.blueBright(
+					'vector',
+				)
+			} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${
+				vectorOps
+					.map((it) => `${chalk.underline(`${it}`)}`)
+					.join(', ')
+			}].\n\nYou can specify it using current syntax: ${
+				chalk.underline(
+					`index("${indexName}").using("${method}", table.${column}.op("${vectorOps[0]}"))`,
+				)
+			}\n\nYou can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing\n`,
+		);
+	}
+
+	if (error.type === 'policy_duplicate') {
+		const { schema, table, policy } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+
+		return withStyle.errorWarning(
+			`We've found duplicated policy name across ${tableName} table. Please rename one of the policies with ${
+				chalk.underline.blue(
+					policy,
+				)
+			} name`,
+		);
+	}
+
+	if (error.type === 'view_name_duplicate') {
+		const schema = chalk.underline.blue(error.schema ?? 'public');
+		const name = chalk.underline.blue(error.name);
+		return withStyle.errorWarning(
+			`There's a view duplicate name ${name} in ${schema} schema`,
+		);
+	}
+
+	if (error.type === 'sequence_name_duplicate') {
+		return withStyle.errorWarning(`There's a sequence name duplicate '${error.name}' in '${error.schema}' schema`);
+	}
+
+	if (error.type === 'table_name_duplicate') {
+		const { name, schema } = error;
+		const schemaName = chalk.underline.blue(`"${schema}"`);
+		const tableName = chalk.underline.blue(`"${name}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate table name ${tableName} in ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'column_name_duplicate') {
+		const { name, schema, table } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		const columnName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate column name ${columnName} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'enum_name_duplicate') {
+		const { name, schema } = error;
+		const schemaName = chalk.underline.blue(`"${schema}"`);
+		const enumName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate enum name ${enumName} in ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'enum_values_duplicate') {
+		const { name, schema } = error;
+		const schemaName = chalk.underline.blue(`"${schema}"`);
+		const enumName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There are duplicate values in enum ${enumName} in ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'privilege_duplicate') {
+		const { name } = error;
+		const privilegeName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate privilege name ${privilegeName}`,
+		);
+	}
+
+	if (error.type === 'role_duplicate') {
+		const { name } = error;
+		const roleName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate role name ${roleName}`,
+		);
+	}
+
+	if (error.type === 'schema_name_duplicate') {
+		const { name } = error;
+		const schemaName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate schema name ${schemaName}`,
+		);
+	}
+
+	assertUnreachable(error);
+};
+
+export const cockroachSchemaError = (error: CockroachSchemaError): string => {
+	if (error.type === 'constraint_name_duplicate') {
+		const { name, schema, table } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		const constraintName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate constraint name ${constraintName} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'index_duplicate') {
+		// check for index names duplicates
+		const { schema, table, name } = error;
+		const sch = chalk.underline.blue(`"${schema}"`);
+		const idx = chalk.underline.blue(`'${name}'`);
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate index name ${idx} in ${sch} schema in ${tableName}`,
+		);
+	}
+
+	if (error.type === 'index_no_name') {
+		const { schema, table, sql } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`Please specify an index name in ${tableName} table that has "${sql}" expression.\n\nWe can generate index names for indexes on columns only; for expressions in indexes, you need to specify index name yourself.`,
+		);
+	}
+
+	if (error.type === 'pgvector_index_noop') {
+		const { table, indexName, column, method } = error;
+		return withStyle.errorWarning(
+			`You are specifying an index on the ${
+				chalk.blueBright(
+					`"${column}"`,
+				)
+			} column inside the ${
+				chalk.blueBright(
+					`"${table}"`,
+				)
+			} table with the ${
+				chalk.blueBright(
+					'vector',
+				)
+			} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${
+				vectorOps
+					.map((it) => `${chalk.underline(`${it}`)}`)
+					.join(', ')
+			}].\n\nYou can specify it using current syntax: ${
+				chalk.underline(
+					`index("${indexName}").using("${method}", table.${column}.op("${vectorOps[0]}"))`,
+				)
+			}\n\nYou can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing\n`,
+		);
+	}
+
+	if (error.type === 'policy_duplicate') {
+		const { schema, table, policy } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+
+		return withStyle.errorWarning(
+			`We've found duplicated policy name across ${tableName} table. Please rename one of the policies with ${
+				chalk.underline.blue(
+					`"${policy}"`,
+				)
+			} name`,
+		);
+	}
+
+	if (error.type === 'view_name_duplicate') {
+		const schema = chalk.underline.blue(`"${error.schema ?? 'public'}"`);
+		const name = chalk.underline.blue(`"${error.name}"`);
+		return withStyle.errorWarning(
+			`There's a view duplicate name ${name} in ${schema} schema`,
+		);
 	}
-	return msg;
+
+	if (error.type === 'sequence_name_duplicate') {
+		return withStyle.errorWarning(`There's a sequence name duplicate '${error.name}' in '${error.schema}' schema`);
+	}
+
+	if (error.type === 'column_name_duplicate') {
+		const { name, schema, table } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		const columnName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate column name ${columnName} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'enum_name_duplicate') {
+		const { name, schema } = error;
+		const schemaName = chalk.underline.blue(`"${schema}"`);
+		const enumName = chalk.underline.blue(`'${name}'`);
+		return withStyle.errorWarning(
+			`There's a duplicate enum name ${enumName} in ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'table_name_duplicate') {
+		const { name, schema } = error;
+		const schemaName = chalk.underline.blue(`"${schema}"`);
+		const tableName = chalk.underline.blue(`"${name}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate table name ${tableName} in ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'schema_name_duplicate') {
+		const { name } = error;
+		const schemaName = chalk.underline.blue(`"${name}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate schema name ${schemaName}`,
+		);
+	}
+
+	if (error.type === 'role_duplicate') {
+		const { name } = error;
+		const roleName = chalk.underline.blue(`"${name}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate role name ${roleName}`,
+		);
+	}
+
+	assertUnreachable(error);
 };
 
-export interface RenamePropmtItem<T> {
+export const mysqlSchemaError = (error: MysqlSchemaError): string => {
+	if (error.type === 'column_name_conflict') {
+		const { name, table } = error;
+		const tableName = chalk.underline.blue(`\`${table}\``);
+		const columnName = chalk.underline.blue(`\`${name}\``);
+		return withStyle.errorWarning(
+			`There's a duplicate column name ${columnName} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'table_name_conflict') {
+		const { name: table } = error;
+		const tableName = chalk.underline.blue(`\`${table}\``);
+		return withStyle.errorWarning(
+			`There's a duplicate table name ${tableName}`,
+		);
+	}
+
+	if (error.type === 'column_unsupported_unique') {
+		const { table, columns } = error;
+		const tableName = chalk.underline.blue(`\`${table}\``);
+		const columnsName = chalk.underline.blue(`\`${columns.join('`, `')}\``);
+
+		const warningText = `You tried to add${columns.length > 1 ? ` COMPOSITE` : ''} UNIQUE on ${columnsName} ${
+			columns.length > 1 ? 'columns' : 'column'
+		} in ${tableName} table
+It's not currently possible to create a UNIQUE constraint on BLOB/TEXT column type.
+To enforce uniqueness, create a UNIQUE INDEX instead, specifying a prefix length with sql\`\`
+Ex. 
+const users = mysqlTable('users', {
+	username: text()
+}, (t) => [${chalk.underline.green('uniqueIndex("name").on(sql`username(10)`)')}]`;
+
+		return withStyle.errorWarning(warningText);
+	}
+
+	if (error.type === 'column_unsupported_default_on_autoincrement') {
+		const { table, column } = error;
+		const tableName = chalk.underline.blue(`\`${table}\``);
+		const columnName = chalk.underline.blue(`\`${column}\``);
+
+		const warningText =
+			`You tried to add DEFAULT value to ${columnName} in ${tableName}. AUTO_INCREMENT or SERIAL automatically generate their values. You can not set a default for it`;
+
+		return withStyle.errorWarning(warningText);
+	}
+
+	assertUnreachable(error);
+};
+
+export const mssqlSchemaError = (error: MssqlSchemaError): string => {
+	if (error.type === 'constraint_duplicate') {
+		const { name, schema } = error;
+		const constraintName = chalk.underline.blue(`'${name}'`);
+		const schemaName = chalk.underline.blue(`'${schema}'`);
+
+		return withStyle.errorWarning(
+			`There's a duplicate constraint name ${constraintName} across ${schemaName} schema`,
+		);
+	}
+
+	if (error.type === 'index_duplicate') {
+		// check for index names duplicates
+		const { schema, table, name } = error;
+		const sch = chalk.underline.blue(`"${schema}"`);
+		const idx = chalk.underline.blue(`'${name}'`);
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`There's a duplicate index name ${idx} in ${sch} schema in ${tableName}`,
+		);
+	}
+
+	if (error.type === 'index_no_name') {
+		const { schema, table, sql } = error;
+		const tableName = chalk.underline.blue(`"${schema}"."${table}"`);
+		return withStyle.errorWarning(
+			`Please specify an index name in ${tableName} table that has "${sql}" expression.\n\nWe can generate index names for indexes on columns only; for expressions in indexes, you need to specify index name yourself.`,
+		);
+	}
+
+	if (error.type === 'view_name_duplicate') {
+		const schema = chalk.underline.blue(error.schema);
+		const name = chalk.underline.blue(error.name);
+		return withStyle.errorWarning(
+			`There's a view duplicate name ${name} across ${schema} schema`,
+		);
+	}
+
+	if (error.type === 'column_duplicate') {
+		const schema = chalk.underline.blue(error.schema);
+		const name = chalk.underline.blue(error.name);
+		const tableName = chalk.underline.blue(`"${schema}"."${error.table}"`);
+		return withStyle.errorWarning(
+			`There's a column duplicate name ${name} in ${tableName} table`,
+		);
+	}
+
+	if (error.type === 'schema_duplicate') {
+		const schemaName = chalk.underline.blue(error.name);
+		return withStyle.errorWarning(
+			`There's a schema duplicate name ${schemaName}`,
+		);
+	}
+
+	if (error.type === 'table_duplicate') {
+		const schema = chalk.underline.blue(error.schema);
+		const tableName = chalk.underline.blue(`"${schema}"."${error.name}"`);
+
+		return withStyle.errorWarning(
+			`There's a table duplicate name ${tableName} across ${schema} schema`,
+		);
+	}
+
+	assertUnreachable(error);
+};
+
+export interface RenamePromptItem<T> {
 	from: T;
 	to: T;
 }
 
-export const isRenamePromptItem = <T extends Named>(
-	item: RenamePropmtItem<T> | T,
-): item is RenamePropmtItem<T> => {
+export const isRenamePromptItem = <T extends EntityBase>(
+	item: RenamePromptItem<T> | T,
+): item is RenamePromptItem<T> => {
 	return 'from' in item && 'to' in item;
 };
 
 export class ResolveColumnSelect<T extends Named> extends Prompt<
-	RenamePropmtItem<T> | T
+	RenamePromptItem<T> | T
 > {
-	private readonly data: SelectState<RenamePropmtItem<T> | T>;
+	private readonly data: SelectState<RenamePromptItem<T> | T>;
 
 	constructor(
 		private readonly tableName: string,
 		private readonly base: Named,
-		data: (RenamePropmtItem<T> | T)[],
+		data: (RenamePromptItem<T> | T)[],
 	) {
 		super();
 		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
@@ -127,7 +1327,7 @@ export class ResolveColumnSelect<T extends Named> extends Prompt<
 
 		const labelLength: number = this.data.items
 			.filter((it) => isRenamePromptItem(it))
-			.map((it: RenamePropmtItem<T>) => {
+			.map((it: RenamePromptItem<T>) => {
 				return this.base.name.length + 3 + it['from'].name.length;
 			})
 			.reduce((a, b) => {
@@ -148,12 +1348,12 @@ export class ResolveColumnSelect<T extends Named> extends Prompt<
 				: `${chalk.green('+')} ${title} ${chalk.gray('create column')}`;
 
 			text += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
-			text += idx != this.data.items.length - 1 ? '\n' : '';
+			text += idx !== this.data.items.length - 1 ? '\n' : '';
 		});
 		return text;
 	}
 
-	result(): RenamePropmtItem<T> | T {
+	result(): RenamePromptItem<T> | T {
 		return this.data.items[this.data.selectedIdx]!;
 	}
 }
@@ -165,20 +1365,19 @@ export const tableKey = (it: NamedWithSchema) => {
 };
 
 export class ResolveSelectNamed<T extends Named> extends Prompt<
-	RenamePropmtItem<T> | T
+	RenamePromptItem<T> | T
 > {
-	private readonly state: SelectState<RenamePropmtItem<T> | T>;
+	private readonly state: SelectState<RenamePromptItem<T> | T>;
 
 	constructor(
 		private readonly base: T,
-		data: (RenamePropmtItem<T> | T)[],
+		data: (RenamePromptItem<T> | T)[],
 		private readonly entityType: 'role' | 'policy',
 	) {
 		super();
 		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
 		this.state = new SelectState(data);
 		this.state.bind(this);
-		this.base = base;
 	}
 
 	render(status: 'idle' | 'submitted' | 'aborted'): string {
@@ -186,8 +1385,9 @@ export class ResolveSelectNamed<T extends Named> extends Prompt<
 			return '';
 		}
 		const key = this.base.name;
+		const humanType = humanizeKind(this.entityType);
 
-		let text = `\nIs ${chalk.bold.blue(key)} ${this.entityType} created or renamed from another ${this.entityType}?\n`;
+		let text = `\nIs ${chalk.bold.blue(key)} ${humanType} created or renamed from another ${humanType}?\n`;
 
 		const isSelectedRenamed = isRenamePromptItem(
 			this.state.items[this.state.selectedIdx],
@@ -200,7 +1400,7 @@ export class ResolveSelectNamed<T extends Named> extends Prompt<
 		const labelLength: number = this.state.items
 			.filter((it) => isRenamePromptItem(it))
 			.map((_) => {
-				const it = _ as RenamePropmtItem<T>;
+				const it = _ as RenamePromptItem<T>;
 				const keyFrom = it.from.name;
 				return key.length + 3 + keyFrom.length;
 			})
@@ -211,7 +1411,7 @@ export class ResolveSelectNamed<T extends Named> extends Prompt<
 				return b;
 			}, 0);
 
-		const entityType = this.entityType;
+		const entityType = humanizeKind(this.entityType);
 		this.state.items.forEach((it, idx) => {
 			const isSelected = idx === this.state.selectedIdx;
 			const isRenamed = isRenamePromptItem(it);
@@ -225,40 +1425,64 @@ export class ResolveSelectNamed<T extends Named> extends Prompt<
 				: `${chalk.green('+')} ${title} ${chalk.gray(`create ${entityType}`)}`;
 
 			text += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
-			text += idx != this.state.items.length - 1 ? '\n' : '';
+			text += idx !== this.state.items.length - 1 ? '\n' : '';
 		});
 		return text;
 	}
 
-	result(): RenamePropmtItem<T> | T {
+	result(): RenamePromptItem<T> | T {
 		return this.state.items[this.state.selectedIdx]!;
 	}
 }
 
-export class ResolveSelect<T extends NamedWithSchema> extends Prompt<
-	RenamePropmtItem<T> | T
+type EntityBase = { schema?: string; table?: string; name: string };
+
+const keyFor = (it: EntityBase, defaultSchema: 'dbo' | 'public' = 'public') => {
+	const schemaPrefix = it.schema && it.schema !== defaultSchema ? `${it.schema}.` : '';
+	const tablePrefix = it.table ? `${it.table}.` : '';
+	return `${schemaPrefix}${tablePrefix}${it.name}`;
+};
+
+export class ResolveSelect<T extends EntityBase> extends Prompt<
+	RenamePromptItem<T> | T
 > {
-	private readonly state: SelectState<RenamePropmtItem<T> | T>;
+	private readonly state: SelectState<RenamePromptItem<T> | T>;
 
 	constructor(
 		private readonly base: T,
-		data: (RenamePropmtItem<T> | T)[],
-		private readonly entityType: 'table' | 'enum' | 'sequence' | 'view' | 'role',
+		data: (RenamePromptItem<T> | T)[],
+		private readonly entityType:
+			| 'schema'
+			| 'enum'
+			| 'table'
+			| 'column'
+			| 'default'
+			| 'sequence'
+			| 'view'
+			| 'privilege'
+			| 'policy'
+			| 'role'
+			| 'check'
+			| 'index'
+			| 'unique'
+			| 'primary_key'
+			| 'foreign key',
+		private defaultSchema: 'dbo' | 'public' = 'public',
 	) {
 		super();
 		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
 		this.state = new SelectState(data);
 		this.state.bind(this);
-		this.base = base;
 	}
 
 	render(status: 'idle' | 'submitted' | 'aborted'): string {
 		if (status === 'submitted' || status === 'aborted') {
 			return '';
 		}
-		const key = tableKey(this.base);
 
-		let text = `\nIs ${chalk.bold.blue(key)} ${this.entityType} created or renamed from another ${this.entityType}?\n`;
+		const key = keyFor(this.base, this.defaultSchema);
+		const humanType = humanizeKind(this.entityType);
+		let text = `\nIs ${chalk.bold.blue(key)} ${humanType} created or renamed from another ${humanType}?\n`;
 
 		const isSelectedRenamed = isRenamePromptItem(
 			this.state.items[this.state.selectedIdx],
@@ -271,8 +1495,8 @@ export class ResolveSelect<T extends NamedWithSchema> extends Prompt<
 		const labelLength: number = this.state.items
 			.filter((it) => isRenamePromptItem(it))
 			.map((_) => {
-				const it = _ as RenamePropmtItem<T>;
-				const keyFrom = tableKey(it.from);
+				const it = _ as RenamePromptItem<T>;
+				const keyFrom = keyFor(it.from);
 				return key.length + 3 + keyFrom.length;
 			})
 			.reduce((a, b) => {
@@ -282,41 +1506,40 @@ export class ResolveSelect<T extends NamedWithSchema> extends Prompt<
 				return b;
 			}, 0);
 
-		const entityType = this.entityType;
+		const entityType = humanizeKind(this.entityType);
 		this.state.items.forEach((it, idx) => {
 			const isSelected = idx === this.state.selectedIdx;
 			const isRenamed = isRenamePromptItem(it);
 
 			const title = isRenamed
-				? `${tableKey(it.from)} › ${tableKey(it.to)}`.padEnd(labelLength, ' ')
-				: tableKey(it).padEnd(labelLength, ' ');
+				? `${keyFor(it.from, this.defaultSchema)} › ${keyFor(it.to, this.defaultSchema)}`.padEnd(labelLength, ' ')
+				: keyFor(it, this.defaultSchema).padEnd(labelLength, ' ');
 
 			const label = isRenamed
 				? `${chalk.yellow('~')} ${title} ${chalk.gray(`rename ${entityType}`)}`
 				: `${chalk.green('+')} ${title} ${chalk.gray(`create ${entityType}`)}`;
 
 			text += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
-			text += idx != this.state.items.length - 1 ? '\n' : '';
+			text += idx !== this.state.items.length - 1 ? '\n' : '';
 		});
 		return text;
 	}
 
-	result(): RenamePropmtItem<T> | T {
+	result(): RenamePromptItem<T> | T {
 		return this.state.items[this.state.selectedIdx]!;
 	}
 }
 
 export class ResolveSchemasSelect<T extends Named> extends Prompt<
-	RenamePropmtItem<T> | T
+	RenamePromptItem<T> | T
 > {
-	private readonly state: SelectState<RenamePropmtItem<T> | T>;
+	private readonly state: SelectState<RenamePromptItem<T> | T>;
 
-	constructor(private readonly base: Named, data: (RenamePropmtItem<T> | T)[]) {
+	constructor(private readonly base: Named, data: (RenamePromptItem<T> | T)[]) {
 		super();
 		this.on('attach', (terminal) => terminal.toggleCursor('hide'));
 		this.state = new SelectState(data);
 		this.state.bind(this);
-		this.base = base;
 	}
 
 	render(status: 'idle' | 'submitted' | 'aborted'): string {
@@ -338,7 +1561,7 @@ export class ResolveSchemasSelect<T extends Named> extends Prompt<
 
 		const labelLength: number = this.state.items
 			.filter((it) => isRenamePromptItem(it))
-			.map((it: RenamePropmtItem<T>) => {
+			.map((it: RenamePromptItem<T>) => {
 				return this.base.name.length + 3 + it['from'].name.length;
 			})
 			.reduce((a, b) => {
@@ -359,12 +1582,12 @@ export class ResolveSchemasSelect<T extends Named> extends Prompt<
 				: `${chalk.green('+')} ${title} ${chalk.gray('create schema')}`;
 
 			text += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
-			text += idx != this.state.items.length - 1 ? '\n' : '';
+			text += idx !== this.state.items.length - 1 ? '\n' : '';
 		});
 		return text;
 	}
 
-	result(): RenamePropmtItem<T> | T {
+	result(): RenamePromptItem<T> | T {
 		return this.state.items[this.state.selectedIdx]!;
 	}
 }
@@ -389,16 +1612,16 @@ class Spinner {
 	};
 }
 
-const frames = function(values: string[]): () => string {
-	let index = 0;
-	const iterator = () => {
-		const frame = values[index];
-		index += 1;
-		index %= values.length;
-		return frame!;
-	};
-	return iterator;
-};
+// const frames = function(values: string[]): () => string {
+// 	let index = 0;
+// 	const iterator = () => {
+// 		const frame = values[index];
+// 		index += 1;
+// 		index %= values.length;
+// 		return frame!;
+// 	};
+// 	return iterator;
+// };
 
 type ValueOf<T> = T[keyof T];
 export type IntrospectStatus = 'fetching' | 'done';
@@ -471,7 +1694,9 @@ export class IntrospectProgress extends TaskView {
 		super();
 		this.timeout = setInterval(() => {
 			this.spinner.tick();
-			this.requestLayout();
+			if (this.terminal) {
+				this.requestLayout();
+			}
 		}, 128);
 
 		this.on('detach', () => clearInterval(this.timeout));
@@ -484,7 +1709,9 @@ export class IntrospectProgress extends TaskView {
 	) {
 		this.state[stage].count = count;
 		this.state[stage].status = status;
-		this.requestLayout();
+		if (this.terminal) {
+			this.requestLayout();
+		}
 	}
 
 	private formatCount = (count: number) => {
@@ -510,7 +1737,13 @@ export class IntrospectProgress extends TaskView {
 		return `${prefix} ${suffix}\n`;
 	};
 
-	render(): string {
+	render(
+		status: 'pending' | 'done' | 'rejected' = 'pending',
+		error?: Error,
+	): string {
+		if (status === 'rejected' && error) {
+			return `[${chalk.red('✗')}] Error during introspection:\n${chalk.red(error.message)}\n${error.stack ?? ''}\n`;
+		}
 		let info = '';
 		const spin = this.spinner.value();
 		info += this.statusText(spin, this.state.tables);
@@ -540,7 +1773,18 @@ export class MigrateProgress extends TaskView {
 		this.on('detach', () => clearInterval(this.timeout));
 	}
 
-	render(status: 'pending' | 'done'): string {
+	render(status: 'pending' | 'done' | 'rejected', error?: Error): string {
+		if (status === 'rejected') {
+			if (error?.cause) {
+				console.log('\n');
+				console.log(error.cause); // render full object
+			}
+
+			return `[${chalk.red('✗')}] Error during migration:\n${
+				chalk.red(error ? error.message : 'unknown error occured')
+			}\n`;
+		}
+
 		if (status === 'pending') {
 			const spin = this.spinner.value();
 			return `[${spin}] applying migrations...`;
@@ -549,6 +1793,12 @@ export class MigrateProgress extends TaskView {
 	}
 }
 
+export class EmptyProgressView extends TaskView {
+	override render(): string {
+		return '';
+	}
+}
+
 export class ProgressView extends TaskView {
 	private readonly spinner: Spinner = new Spinner('⣷⣯⣟⡿⢿⣻⣽⣾'.split(''));
 	private timeout: NodeJS.Timeout | undefined;
@@ -566,7 +1816,29 @@ export class ProgressView extends TaskView {
 		this.on('detach', () => clearInterval(this.timeout));
 	}
 
-	render(status: 'pending' | 'done'): string {
+	stop() {
+		if (this.timeout) {
+			clearInterval(this.timeout);
+			this.timeout = undefined;
+		}
+	}
+
+	render(status: 'pending' | 'done' | 'rejected', error?: Error): string {
+		if (outputFormat() === 'json') {
+			return '';
+		}
+
+		if (status === 'rejected') {
+			if (error?.cause) {
+				console.log('\n');
+				console.log(error.cause); // render full object
+			}
+
+			return `[${chalk.red('✗')}] ${this.progressText}\n${
+				chalk.red(error ? error.message : 'unknown error occured')
+			}\n`;
+		}
+
 		if (status === 'pending') {
 			const spin = this.spinner.value();
 			return `[${spin}] ${this.progressText}\n`;
@@ -612,7 +1884,7 @@ export class DropMigrationView<T extends { tag: string }> extends Prompt<T> {
 			title = isSelected ? chalk.yellow(title) : title;
 
 			text += isSelected ? `${selectedPrefix}${title}` : `  ${title}`;
-			text += idx != this.data.items.length - 1 ? '\n' : '';
+			text += idx !== this.data.items.length - 1 ? '\n' : '';
 		});
 
 		text += data.endTrimmed ? '  ...\n' : '';
diff --git a/drizzle-kit/src/commutativity/engine.ts b/drizzle-kit/src/commutativity/engine.ts
new file mode 100644
index 0000000000..52e887edf0
--- /dev/null
+++ b/drizzle-kit/src/commutativity/engine.ts
@@ -0,0 +1,593 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname } from 'path';
+import type { ConflictTarget, NonCommutativityReport, UnifiedBranchConflict } from './types';
+
+type SnapshotNode<TSnapshot extends { id: string; prevIds: string[] }> = {
+	id: string;
+	prevIds: string[];
+	path: string;
+	folderPath: string;
+	raw: TSnapshot;
+};
+export type SnapshotHeader = {
+	id: string;
+	prevIds: string[];
+};
+
+export type ParsedSnapshotInput<TSnapshot extends SnapshotHeader = SnapshotHeader> = {
+	path: string;
+	snapshot: TSnapshot;
+};
+
+function buildPrevToChildren<TNode extends { id: string; prevIds: string[] }>(
+	nodes: Record<string, TNode>,
+): Record<string, string[]> {
+	const prevToChildren: Record<string, string[]> = {};
+	for (const node of Object.values(nodes)) {
+		for (const parentId of node.prevIds) {
+			(prevToChildren[parentId] ??= []).push(node.id);
+		}
+	}
+	return prevToChildren;
+}
+
+function collectLeaves(
+	prevToChildren: Record<string, string[]>,
+	startId: string,
+): string[] {
+	const leaves: string[] = [];
+	const visited = new Set<string>();
+	const stack: string[] = [startId];
+
+	while (stack.length) {
+		const id = stack.pop()!;
+		if (visited.has(id)) continue;
+		visited.add(id);
+
+		const children = prevToChildren[id];
+		if (!children || children.length === 0) {
+			leaves.push(id);
+			continue;
+		}
+		for (const child of children) {
+			if (!visited.has(child)) stack.push(child);
+		}
+	}
+
+	return leaves;
+}
+
+function ancestorsOf(
+	nodes: Record<string, { prevIds: string[] }>,
+	startId: string,
+	cache: Map<string, Set<string>>,
+): Set<string> {
+	const cached = cache.get(startId);
+	if (cached) return cached;
+
+	const result = new Set<string>();
+	const stack: string[] = [startId];
+	while (stack.length) {
+		const id = stack.pop()!;
+		if (result.has(id)) continue;
+		const node = nodes[id];
+		// ORIGIN sentinel ids (and any id without a snapshot) are not real
+		// ancestor nodes, so they never qualify as a composition base.
+		if (!node) continue;
+		result.add(id);
+		for (const prev of node.prevIds) stack.push(prev);
+	}
+
+	cache.set(startId, result);
+	return result;
+}
+
+/**
+ * Lowest common ancestor of a set of leaves in the snapshot DAG.
+ *
+ * Returns the deepest node that is an ancestor (inclusive of itself) of every
+ * leaf, i.e. the most recent point the open heads still share. Used as the merge
+ * base so that segments already collapsed by a merge node below it are not
+ * replayed. Returns `null` when the leaves share no real-node ancestor (their
+ * only common ancestor is the ORIGIN sentinel), in which case the caller falls
+ * back to the dry snapshot.
+ */
+function lowestCommonAncestor(
+	nodes: Record<string, { prevIds: string[] }>,
+	leafIds: string[],
+): string | null {
+	const cache = new Map<string, Set<string>>();
+
+	let common: Set<string> | null = null;
+	for (const leafId of leafIds) {
+		const ancestors = ancestorsOf(nodes, leafId, cache);
+		if (common === null) {
+			common = new Set(ancestors);
+			continue;
+		}
+		for (const id of common) {
+			if (!ancestors.has(id)) common.delete(id);
+		}
+		if (common.size === 0) return null;
+	}
+	if (!common || common.size === 0) return null;
+
+	// The lowest common ancestor is the common ancestor whose own ancestor set
+	// contains every other common ancestor (the deepest one). Prefer the
+	// candidate reaching the most ancestors to break ties deterministically.
+	let best: string | null = null;
+	let bestSize = -1;
+	for (const candidate of common) {
+		const candidateAncestors = ancestorsOf(nodes, candidate, cache);
+		const containsAllCommon = [...common].every((id) => candidateAncestors.has(id));
+		if (containsAllCommon && candidateAncestors.size > bestSize) {
+			best = candidate;
+			bestSize = candidateAncestors.size;
+		}
+	}
+	if (best !== null) return best;
+
+	// Diamond history with no single deepest common ancestor: fall back to the
+	// common ancestor closest to the leaves (largest ancestor set).
+	for (const candidate of common) {
+		const size = ancestorsOf(nodes, candidate, cache).size;
+		if (size > bestSize) {
+			best = candidate;
+			bestSize = size;
+		}
+	}
+	return best;
+}
+
+function composeMergeStatements<TStatement>(
+	leafStatements: TStatement[][],
+): TStatement[] {
+	const seen = new Set<string>();
+	const composed: TStatement[] = [];
+	for (const statements of leafStatements) {
+		for (const statement of statements) {
+			const key = JSON.stringify(statement);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			composed.push(statement);
+		}
+	}
+	return composed;
+}
+
+export type CommutativityStatementInfo<
+	TStatement extends { type: string },
+	TTarget,
+> = {
+	action: TStatement['type'];
+	primary: TTarget;
+	ancestors: TTarget[];
+};
+
+export type CommutativityStatementTargets<TTarget> = {
+	primary: TTarget;
+	ancestors?: TTarget[];
+};
+
+export type CommutativityStatementDefinition<
+	TAllStatements extends { type: string },
+	TStatement extends TAllStatements,
+	TTarget,
+> = {
+	conflicts: TAllStatements['type'][];
+	buildInfo: (statement: TStatement) => CommutativityStatementTargets<TTarget>;
+};
+
+export type CommutativityStatementDefinitions<
+	TStatement extends { type: string },
+	TTarget,
+> = {
+	[TType in TStatement['type']]: CommutativityStatementDefinition<
+		TStatement,
+		Extract<TStatement, { type: TType }>,
+		TTarget
+	>;
+};
+
+export abstract class AbstractCommutativity<
+	TStatement extends { type: string },
+	TSnapshot extends { id: string; prevIds: string[] },
+	TTarget,
+> {
+	private statementDefinitionsCache?: CommutativityStatementDefinitions<
+		TStatement,
+		TTarget
+	>;
+
+	protected abstract getStatementDefinitions(): CommutativityStatementDefinitions<
+		TStatement,
+		TTarget
+	>;
+
+	protected abstract formatFootprintTarget(
+		action: TStatement['type'],
+		target: TTarget,
+	): string;
+
+	protected abstract describeStatement(
+		statement: TStatement,
+		info: CommutativityStatementInfo<TStatement, TTarget>,
+	): string;
+
+	protected abstract describeStatementTarget(
+		statement: TStatement,
+		info: CommutativityStatementInfo<TStatement, TTarget>,
+	): ConflictTarget;
+
+	protected getImplicitAncestors(_target: TTarget): TTarget[] {
+		return [];
+	}
+
+	protected abstract getDrySnapshot(): TSnapshot;
+
+	protected abstract diffSnapshots(
+		fromSnapshot: TSnapshot,
+		toSnapshot: TSnapshot,
+	): Promise<{ statements: TStatement[] }>;
+
+	protected resolveStatement(statement: TStatement): {
+		conflicts: TStatement['type'][];
+		info: CommutativityStatementInfo<TStatement, TTarget>;
+	} {
+		const definition = this.getSpecificStatementDefinition(statement);
+		const built = definition.buildInfo(statement);
+
+		return {
+			conflicts: definition.conflicts,
+			info: {
+				action: statement.type,
+				primary: built.primary,
+				ancestors: built.ancestors ?? [],
+			},
+		};
+	}
+
+	public footprint(
+		statement: TStatement,
+		_snapshot?: TSnapshot,
+	): [string[], string[]] {
+		const { info, conflicts } = this.resolveStatement(statement);
+
+		const statementFootprints = this.statementTargets(info).map((target) =>
+			this.formatFootprintTarget(statement.type, target)
+		);
+
+		const conflictFootprints = conflicts.map((conflictType) => this.formatFootprintTarget(conflictType, info.primary));
+
+		return [statementFootprints, conflictFootprints];
+	}
+
+	public async getReasonsFromStatements(
+		aStatements: TStatement[],
+		bStatements: TStatement[],
+		parentSnapshot?: TSnapshot,
+	) {
+		const snapshot = parentSnapshot ?? this.getDrySnapshot();
+		const branchAFootprints = this.generateLeafFootprints(aStatements, snapshot);
+		const branchBFootprints = this.generateLeafFootprints(bStatements, snapshot);
+
+		return this.findFootprintIntersections(
+			branchAFootprints.statementHashes,
+			branchAFootprints.conflictFootprints,
+			branchBFootprints.statementHashes,
+			branchBFootprints.conflictFootprints,
+		);
+	}
+
+	public async detectNonCommutative(
+		snapshots: string[] | ParsedSnapshotInput[],
+	): Promise<NonCommutativityReport> {
+		const nodes = this.buildSnapshotGraph(snapshots);
+		const prevToChildren = buildPrevToChildren(nodes);
+
+		const diffCache = new Map<string, Promise<{ statements: TStatement[] }>>();
+		const drySnapshot = this.getDrySnapshot();
+		const drySnapshotId = '__dry__';
+
+		const diffOnce = (from: TSnapshot, to: TSnapshot) => {
+			const fromId = from === drySnapshot ? drySnapshotId : from.id;
+			const key = `${fromId}::${to.id}`;
+			const cached = diffCache.get(key);
+			if (cached) return cached;
+			const pending = this.diffSnapshots(from, to);
+			diffCache.set(key, pending);
+			return pending;
+		};
+
+		const conflicts: UnifiedBranchConflict[] = [];
+		const commutativeBranches: NonCommutativityReport['commutativeBranches'] = [];
+
+		for (const [prevId, childIds] of Object.entries(prevToChildren)) {
+			if (childIds.length <= 1) continue;
+
+			const parentNode = nodes[prevId];
+			const parentSnapshot = parentNode ? parentNode.raw : drySnapshot;
+			const childToLeaves: Record<string, string[]> = {};
+
+			for (const childId of childIds) {
+				childToLeaves[childId] = collectLeaves(prevToChildren, childId);
+			}
+
+			const leafStatementsCache: Record<
+				string,
+				Promise<{ statements: TStatement[]; path: string }>
+			> = {};
+
+			const resolveLeaf = (leafId: string) => {
+				const cached = leafStatementsCache[leafId];
+				if (cached) return cached;
+				const leafNode = nodes[leafId]!;
+				const pending = diffOnce(parentSnapshot, leafNode.raw).then((d) => ({
+					statements: d.statements,
+					path: leafNode.folderPath,
+				}));
+				leafStatementsCache[leafId] = pending;
+				return pending;
+			};
+
+			for (let i = 0; i < childIds.length; i++) {
+				for (let j = i + 1; j < childIds.length; j++) {
+					const groupA = childToLeaves[childIds[i]] ?? [];
+					const groupB = childToLeaves[childIds[j]] ?? [];
+					const groupASet = new Set(groupA);
+					const hasMergedOverlap = groupB.some((leafId) => groupASet.has(leafId));
+					if (hasMergedOverlap) continue;
+
+					for (const aId of groupA) {
+						for (const bId of groupB) {
+							if (aId === bId) continue;
+
+							const [{ statements: aStatements }, { statements: bStatements }] = await Promise.all([
+								resolveLeaf(aId),
+								resolveLeaf(bId),
+							]);
+
+							const intersected = await this.getReasonsFromStatements(
+								aStatements,
+								bStatements,
+								parentSnapshot,
+							);
+
+							if (!intersected) continue;
+
+							const chainA = this.buildChain(
+								nodes,
+								prevToChildren,
+								childIds[i],
+								aId,
+							);
+							const chainB = this.buildChain(
+								nodes,
+								prevToChildren,
+								childIds[j],
+								bId,
+							);
+
+							const leftInfo = this.resolveStatement(intersected.leftStatement).info;
+							const rightInfo = this.resolveStatement(intersected.rightStatement).info;
+
+							conflicts.push({
+								parentId: prevId,
+								parentPath: parentNode?.folderPath,
+								branchA: {
+									chain: chainA,
+									statementDescription: this.describeStatement(
+										intersected.leftStatement,
+										leftInfo,
+									),
+									target: this.describeStatementTarget(
+										intersected.leftStatement,
+										leftInfo,
+									),
+									action: leftInfo.action,
+								},
+								branchB: {
+									chain: chainB,
+									statementDescription: this.describeStatement(
+										intersected.rightStatement,
+										rightInfo,
+									),
+									target: this.describeStatementTarget(
+										intersected.rightStatement,
+										rightInfo,
+									),
+									action: rightInfo.action,
+								},
+							});
+						}
+					}
+				}
+			}
+		}
+
+		const leafNodes: string[] = [];
+		for (const id of Object.keys(nodes)) {
+			if (!prevToChildren[id]) leafNodes.push(id);
+		}
+
+		// Open commutative merge. When the whole history is conflict-free and more
+		// than one head is open, every pair of open heads is commutative (the loop
+		// above compares every cross-branch leaf pair), so all of them can be merged
+		// at once. The merge base is the lowest common ancestor of the open heads —
+		// not a higher fork — so segments already collapsed by a merge node below it
+		// are never replayed. Each head contributes diff(LCA -> head); statements
+		// inherited from a nested fork below the LCA show up in more than one head's
+		// diff and are de-duplicated by the consumer before they are replayed.
+		if (conflicts.length === 0 && leafNodes.length > 1) {
+			const lcaId = lowestCommonAncestor(nodes, leafNodes);
+			const baseNode = lcaId ? nodes[lcaId] : undefined;
+			const baseSnapshot = baseNode ? baseNode.raw : drySnapshot;
+
+			// Sort heads by id so the composed migration and leaf ids are
+			// deterministic regardless of file read order.
+			const sortedLeafIds = [...leafNodes].sort((a, b) => a.localeCompare(b));
+			const leafs = await Promise.all(
+				sortedLeafIds.map(async (leafId) => {
+					const leafNode = nodes[leafId]!;
+					const { statements } = await diffOnce(baseSnapshot, leafNode.raw);
+					return {
+						id: leafId,
+						path: leafNode.folderPath,
+						statements,
+					};
+				}),
+			);
+
+			commutativeBranches.push({
+				parentId: lcaId ?? drySnapshot.id,
+				parentPath: baseNode?.folderPath,
+				parentSnapshot: baseSnapshot,
+				statements: composeMergeStatements(leafs.map((leaf) => leaf.statements)),
+				leafs,
+			});
+		}
+
+		return { conflicts, leafNodes, commutativeBranches };
+	}
+
+	private getDefinitions() {
+		this.statementDefinitionsCache ??= this.getStatementDefinitions();
+		return this.statementDefinitionsCache;
+	}
+
+	private getSpecificStatementDefinition<TSpecificStatement extends TStatement>(
+		statement: TSpecificStatement,
+	): CommutativityStatementDefinition<TStatement, TSpecificStatement, TTarget> {
+		return this.getDefinitions()[
+			statement.type as TStatement['type']
+		] as unknown as CommutativityStatementDefinition<
+			TStatement,
+			TSpecificStatement,
+			TTarget
+		>;
+	}
+
+	private statementTargets(
+		info: CommutativityStatementInfo<TStatement, TTarget>,
+	): TTarget[] {
+		return [info.primary, ...info.ancestors, ...this.getImplicitAncestors(info.primary)];
+	}
+
+	private generateLeafFootprints(
+		statements: TStatement[],
+		_snapshot?: TSnapshot,
+	): {
+		statementHashes: Array<{ hash: string; statement: TStatement }>;
+		conflictFootprints: Array<{ hash: string; statement: TStatement }>;
+	} {
+		const statementHashes: Array<{ hash: string; statement: TStatement }> = [];
+		const conflictFootprints: Array<{ hash: string; statement: TStatement }> = [];
+
+		for (const statement of statements) {
+			const [hashes, conflicts] = this.footprint(statement);
+
+			for (const hash of hashes) {
+				statementHashes.push({ hash, statement });
+			}
+
+			for (const conflict of conflicts) {
+				conflictFootprints.push({ hash: conflict, statement });
+			}
+		}
+
+		return { statementHashes, conflictFootprints };
+	}
+
+	private findFootprintIntersections(
+		branchAHashes: Array<{ hash: string; statement: TStatement }>,
+		branchAConflicts: Array<{ hash: string; statement: TStatement }>,
+		branchBHashes: Array<{ hash: string; statement: TStatement }>,
+		branchBConflicts: Array<{ hash: string; statement: TStatement }>,
+	) {
+		const branchAConflictByHash = new Map<string, TStatement>();
+		for (const c of branchAConflicts) branchAConflictByHash.set(c.hash, c.statement);
+
+		const branchBConflictByHash = new Map<string, TStatement>();
+		for (const c of branchBConflicts) branchBConflictByHash.set(c.hash, c.statement);
+
+		for (const a of branchAHashes) {
+			const match = branchBConflictByHash.get(a.hash);
+			if (match) {
+				return { leftStatement: a.statement, rightStatement: match };
+			}
+		}
+
+		for (const b of branchBHashes) {
+			const match = branchAConflictByHash.get(b.hash);
+			if (match) {
+				return { leftStatement: b.statement, rightStatement: match };
+			}
+		}
+	}
+
+	private buildSnapshotGraph(
+		snapshots: string[] | ParsedSnapshotInput[],
+	): Record<string, SnapshotNode<TSnapshot>> {
+		const byId: Record<string, SnapshotNode<TSnapshot>> = {};
+		for (const input of snapshots) {
+			let file: string;
+			// The engine accepts snapshots whose shape we only know to have `id`
+			// and `prevIds`. The full snapshot is then handed to the dialect's
+			// `diffSnapshots`, which is the only place that requires the rest
+			// of `TSnapshot` and is responsible for that contract.
+			let raw: TSnapshot;
+			if (typeof input === 'string') {
+				file = input;
+				if (!existsSync(file)) continue;
+				raw = JSON.parse(readFileSync(file, 'utf8')) as TSnapshot;
+			} else {
+				file = input.path;
+				raw = input.snapshot as TSnapshot;
+			}
+			byId[raw.id] = {
+				id: raw.id,
+				prevIds: raw.prevIds,
+				path: file,
+				folderPath: dirname(file),
+				raw,
+			};
+		}
+
+		return byId;
+	}
+
+	private buildChain(
+		graph: Record<string, SnapshotNode<TSnapshot>>,
+		prevToChildren: Record<string, string[]>,
+		startId: string,
+		targetId: string,
+	): { id: string; path: string }[] {
+		const queue: string[][] = [[startId]];
+		const visited = new Set<string>();
+
+		while (queue.length > 0) {
+			const path = queue.shift()!;
+			const current = path[path.length - 1];
+
+			if (current === targetId) {
+				return path.map((id) => ({
+					id,
+					path: graph[id]?.folderPath ?? id,
+				}));
+			}
+
+			if (visited.has(current)) continue;
+			visited.add(current);
+
+			const children = prevToChildren[current] ?? [];
+			for (const child of children) {
+				if (!visited.has(child)) {
+					queue.push([...path, child]);
+				}
+			}
+		}
+
+		const leafNode = graph[targetId];
+		return [{ id: targetId, path: leafNode?.folderPath ?? targetId }];
+	}
+}
diff --git a/drizzle-kit/src/commutativity/index.ts b/drizzle-kit/src/commutativity/index.ts
new file mode 100644
index 0000000000..bfff91cf3f
--- /dev/null
+++ b/drizzle-kit/src/commutativity/index.ts
@@ -0,0 +1,22 @@
+import { mysqlCommutativity } from '../dialects/mysql/commutativity';
+import { postgresCommutativity } from '../dialects/postgres/commutativity';
+import { sqliteCommutativity } from '../dialects/sqlite/commutativity';
+import type { Dialect } from '../utils/schemaValidator';
+
+export const commutativityDialects = {
+	postgresql: postgresCommutativity,
+	mysql: mysqlCommutativity,
+	sqlite: sqliteCommutativity,
+	turso: sqliteCommutativity,
+} as const;
+
+export const getCommutativityDialect = (dialect: Dialect) => {
+	if (
+		dialect === 'postgresql'
+		|| dialect === 'mysql'
+		|| dialect === 'sqlite'
+		|| dialect === 'turso'
+	) {
+		return commutativityDialects[dialect];
+	}
+};
diff --git a/drizzle-kit/src/commutativity/types.ts b/drizzle-kit/src/commutativity/types.ts
new file mode 100644
index 0000000000..6ecbb58c41
--- /dev/null
+++ b/drizzle-kit/src/commutativity/types.ts
@@ -0,0 +1,44 @@
+export type MigrationNode = {
+	id: string;
+	path: string;
+};
+
+export type ConflictTarget = {
+	kind: string;
+	name: string;
+	schema?: string;
+	table?: string;
+};
+
+export type UnifiedBranchConflict = {
+	parentId: string;
+	parentPath?: string;
+	branchA: {
+		chain: MigrationNode[];
+		statementDescription: string;
+		target: ConflictTarget;
+		action: string;
+	};
+	branchB: {
+		chain: MigrationNode[];
+		statementDescription: string;
+		target: ConflictTarget;
+		action: string;
+	};
+};
+
+export type NonCommutativityReport = {
+	conflicts: UnifiedBranchConflict[];
+	leafNodes: string[];
+	commutativeBranches?: {
+		parentId: string;
+		parentPath?: string;
+		parentSnapshot: unknown;
+		statements: unknown[];
+		leafs: {
+			id: string;
+			path: string;
+			statements: unknown[];
+		}[];
+	}[];
+};
diff --git a/drizzle-kit/src/dialects/cockroach/convertor.ts b/drizzle-kit/src/dialects/cockroach/convertor.ts
new file mode 100644
index 0000000000..4250f4e2c2
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/convertor.ts
@@ -0,0 +1,796 @@
+import { escapeSingleQuotes, type Simplify } from '../../utils';
+import { defaultNameForPK, defaults, defaultToSQL, isDefaultAction } from './grammar';
+import type { JsonStatement } from './statements';
+
+export const convertor = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	convertor: (statement: Simplify<Omit<TStatement, 'type'>>) => string | string[],
+) => {
+	return {
+		type,
+		can: (st: JsonStatement) => {
+			return st.type === type;
+		},
+		convert: convertor,
+	};
+};
+
+const createSchemaConvertor = convertor('create_schema', (st) => {
+	return `CREATE SCHEMA "${st.name}";\n`;
+});
+
+const dropSchemaConvertor = convertor('drop_schema', (st) => {
+	return `DROP SCHEMA "${st.name}";\n`;
+});
+
+const renameSchemaConvertor = convertor('rename_schema', (st) => {
+	return `ALTER SCHEMA "${st.from.name}" RENAME TO "${st.to.name}";\n`;
+});
+
+const createViewConvertor = convertor('create_view', (st) => {
+	const { definition, name: viewName, schema, materialized, withNoData } = st.view;
+
+	const name = schema !== 'public' ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+	let statement = materialized ? `CREATE MATERIALIZED VIEW ${name}` : `CREATE VIEW ${name}`;
+
+	statement += ` AS (${definition})`;
+	if (withNoData) statement += ` WITH NO DATA`;
+	statement += `;`;
+
+	return statement;
+});
+
+const dropViewConvertor = convertor('drop_view', (st) => {
+	const { name: viewName, schema, materialized } = st.view;
+	const name = schema !== 'public' ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+	return `DROP${materialized ? ' MATERIALIZED' : ''} VIEW ${name};`;
+});
+
+const renameViewConvertor = convertor('rename_view', (st) => {
+	const materialized = st.from.materialized;
+	const nameFrom = st.from.schema !== 'public' ? `"${st.from.schema}"."${st.from.name}"` : `"${st.from.name}"`;
+
+	return `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW ${nameFrom} RENAME TO "${st.to.name}";`;
+});
+
+const moveViewConvertor = convertor('move_view', (st) => {
+	const { fromSchema, toSchema, view } = st;
+	const from = fromSchema === 'public' ? `"${view.name}"` : `"${fromSchema}"."${view.name}"`;
+	return `ALTER${view.materialized ? ' MATERIALIZED' : ''} VIEW ${from} SET SCHEMA "${toSchema}";`;
+});
+
+const recreateViewConvertor = convertor('recreate_view', (st) => {
+	const drop = dropViewConvertor.convert({ view: st.from }) as string;
+	const create = createViewConvertor.convert({ view: st.to }) as string;
+	return [drop, create];
+});
+
+const createTableConvertor = convertor('create_table', (st) => {
+	const { schema, name, columns, pk, checks, policies, isRlsEnabled, indexes } = st.table;
+
+	const uniqueIndexes = indexes.filter((it) =>
+		it.isUnique && (!it.method || it.method === defaults.index.method) && !it.where
+	);
+
+	const statements = [] as string[];
+	let statement = '';
+	const key = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	statement += `CREATE TABLE ${key} (\n`;
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === column.name
+			&& pk.name === defaultNameForPK(column.table);
+
+		const primaryKeyStatement = isPK ? ' PRIMARY KEY' : '';
+		const notNullStatement = pk?.columns.includes(column.name)
+			? ''
+			: column.notNull && !column.identity
+			? ' NOT NULL'
+			: '';
+
+		const defaultStatement = column.default ? ` DEFAULT ${defaultToSQL(column)}` : '';
+
+		const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+			? `"${column.typeSchema}".`
+			: '';
+		let type = column.typeSchema
+			? `"${column.type}"`
+			: column.type;
+		type = `${schemaPrefix}${type}${'[]'.repeat(column.dimensions)}`;
+
+		const generated = column.generated;
+
+		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+		const identity = column.identity
+			? ` GENERATED ${column.identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'} AS IDENTITY (${
+				column.identity.increment ? `INCREMENT BY ${column.identity.increment}` : ''
+			}${column.identity.minValue ? ` MINVALUE ${column.identity.minValue}` : ''}${
+				column.identity.maxValue ? ` MAXVALUE ${column.identity.maxValue}` : ''
+			}${column.identity.startWith ? ` START WITH ${column.identity.startWith}` : ''}${
+				column.identity.cache ? ` CACHE ${column.identity.cache}` : ''
+			})`
+			: '';
+
+		statement += '\t'
+			+ `"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identity}`;
+		statement += i === columns.length - 1 ? '' : ',\n';
+	}
+
+	for (const unique of uniqueIndexes) {
+		statement += ',\n';
+		const uniqueString = unique.columns.map((it) => (it.isExpression ? `${it.value}` : `"${it.value}"`)).join(',');
+
+		statement += `\tCONSTRAINT "${unique.name}" UNIQUE(${uniqueString})`;
+	}
+
+	if (pk && (pk.columns.length > 1 || pk.name !== defaultNameForPK(st.table.name))) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT "${pk.name}" PRIMARY KEY("${pk.columns.join(`","`)}")`;
+	}
+
+	for (const check of checks) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT "${check.name}" CHECK (${check.value})`;
+	}
+
+	statement += `\n);`;
+	statement += `\n`;
+	statements.push(statement);
+
+	if ((policies && policies.length > 0) || isRlsEnabled) {
+		statements.push(
+			toggleRlsConvertor.convert({
+				isRlsEnabled: true,
+				name: st.table.name,
+				schema: st.table.schema,
+			}) as string,
+		);
+	}
+
+	return statements;
+});
+
+const dropTableConvertor = convertor('drop_table', (st) => {
+	const { name, schema, policies } = st.table;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	const droppedPolicies = policies.map((policy) => dropPolicyConvertor.convert({ policy }) as string);
+
+	return [...droppedPolicies, `DROP TABLE ${tableNameWithSchema};`];
+});
+
+const renameTableConvertor = convertor('rename_table', (st) => {
+	const schemaPrefix = st.schema !== 'public' ? `"${st.schema}".` : '';
+
+	return `ALTER TABLE ${schemaPrefix}"${st.from}" RENAME TO "${st.to}";`;
+});
+
+const moveTableConvertor = convertor('move_table', (st) => {
+	const from = st.from !== 'public' ? `"${st.from}"."${st.name}"` : `"${st.name}"`;
+
+	return `ALTER TABLE ${from} SET SCHEMA "${st.to}";\n`;
+});
+
+const addColumnConvertor = convertor('add_column', (st) => {
+	const { schema, table, name, identity, generated } = st.column;
+	const column = st.column;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	const defaultStatement = column.default ? ` DEFAULT ${defaultToSQL(column)}` : '';
+
+	const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+		? `"${column.typeSchema}".`
+		: '';
+	const type = column.typeSchema
+		? `"${column.type}"`
+		: column.type;
+	let fixedType = `${schemaPrefix}${type}${'[]'.repeat(column.dimensions)}`;
+
+	// unlike postgres cockroach requires explicit not null columns for pk
+	const notNullStatement = column.notNull && !identity && !generated ? ' NOT NULL' : '';
+
+	const identityStatement = identity
+		? ` GENERATED ${identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'} AS IDENTITY (${
+			identity.increment ? `INCREMENT BY ${identity.increment}` : ''
+		}${identity.minValue ? ` MINVALUE ${identity.minValue}` : ''}${
+			identity.maxValue ? ` MAXVALUE ${identity.maxValue}` : ''
+		}${identity.startWith ? ` START WITH ${identity.startWith}` : ''}${
+			identity.cache ? ` CACHE ${identity.cache}` : ''
+		})`
+		: '';
+
+	const generatedStatement = column.generated ? ` GENERATED ALWAYS AS (${column.generated.as}) STORED` : '';
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
+});
+
+const dropColumnConvertor = convertor('drop_column', (st) => {
+	const { schema, table, name } = st.column;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${name}";`;
+});
+
+const renameColumnConvertor = convertor('rename_column', (st) => {
+	const { table, schema } = st.from;
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${st.from.name}" TO "${st.to.name}";`;
+});
+
+const recreateColumnConvertor = convertor('recreate_column', (st) => {
+	// AlterTableAlterColumnSetExpressionConvertor
+	// AlterTableAlterColumnAlterGeneratedConvertor
+
+	const drop = dropColumnConvertor.convert({ column: st.diff.$right }) as string;
+	const add = addColumnConvertor.convert({
+		column: st.diff.$right,
+	}) as string;
+
+	return [drop, add];
+});
+
+const alterColumnConvertor = convertor('alter_column', (st) => {
+	const { diff, to: column, isEnum, wasEnum } = st;
+	const statements = [] as string[];
+
+	const key = column.schema !== 'public' ? `"${column.schema}"."${column.table}"` : `"${column.table}"`;
+
+	// TODO need to recheck this
+	const recreateDefault = diff.type && (isEnum || wasEnum) && (diff.$left.default);
+	if (recreateDefault) {
+		statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+	}
+
+	if (diff.type) {
+		const typeSchema = column.typeSchema && column.typeSchema !== 'public' ? `"${column.typeSchema}".` : '';
+		const textProxy = wasEnum && isEnum ? 'text::' : ''; // using enum1::text::enum2
+		const suffix = isEnum
+			? ` USING "${column.name}"::${textProxy}${typeSchema}"${column.type}"${'[]'.repeat(column.dimensions)}`
+			: '';
+
+		const type = diff.typeSchema?.to && diff.typeSchema.to !== 'public'
+			? `"${diff.typeSchema.to}"."${diff.type.to}"`
+			: isEnum
+			? `"${diff.type.to}"`
+			: diff.type.to;
+
+		statements.push(
+			`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE ${type}${
+				'[]'.repeat(column.dimensions)
+			}${suffix};`,
+		);
+
+		if (recreateDefault && column.default) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${defaultToSQL(column)};`);
+		}
+	}
+
+	if (diff.default && !recreateDefault) {
+		if (diff.default.to) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${defaultToSQL(diff.$right)};`);
+		} else {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+		}
+	}
+
+	if (diff.identity) {
+		if (diff.identity.from === null) {
+			const identity = column.identity!;
+			const typeClause = identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+			const incrementClause = identity.increment ? `INCREMENT BY ${identity.increment}` : '';
+			const minClause = identity.minValue ? ` MINVALUE ${identity.minValue}` : '';
+			const maxClause = identity.maxValue ? ` MAXVALUE ${identity.maxValue}` : '';
+			const startWith = identity.startWith ? ` START WITH ${identity.startWith}` : '';
+			const cache = identity.cache ? ` CACHE ${identity.cache}` : '';
+			const identityStatement =
+				`GENERATED ${typeClause} AS IDENTITY (${incrementClause}${minClause}${maxClause}${startWith}${cache})`;
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" ADD ${identityStatement};`);
+		} else if (diff.identity.to === null) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP IDENTITY;`);
+		} else {
+			const { from, to } = diff.identity;
+
+			// TODO: when to.prop === null?
+			if (from.type !== to.type) {
+				const typeClause = to.type === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET GENERATED ${typeClause};`);
+			}
+			if (from.minValue !== to.minValue) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET MINVALUE ${to.minValue};`);
+			}
+
+			if (from.maxValue !== to.maxValue) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET MAXVALUE ${to.maxValue};`);
+			}
+
+			if (from.increment !== to.increment) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET INCREMENT BY ${to.increment};`);
+			}
+
+			if (from.startWith !== to.startWith) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET START WITH ${to.startWith};`);
+			}
+
+			if (from.cache !== to.cache) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET CACHE ${to.cache};`);
+			}
+		}
+	}
+
+	return statements;
+});
+
+const alterColumnAddNotNullConvertor = convertor('alter_add_column_not_null', (st) => {
+	const { table, schema, column } = st;
+	const statements = [] as string[];
+
+	const key = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column}" SET NOT NULL;`);
+	return statements;
+});
+const alterColumnDropNotNullConvertor = convertor('alter_drop_column_not_null', (st) => {
+	const { table, schema, column } = st;
+	const statements = [] as string[];
+
+	const key = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column}" DROP NOT NULL;`);
+	return statements;
+});
+
+const createIndexConvertor = convertor('create_index', (st) => {
+	const { schema, table, name, columns, isUnique, method, where } = st.index;
+	const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+	const value = columns
+		.map((it) => {
+			const expr = it.isExpression ? it.value : `"${it.value}"`;
+
+			// ASC - default
+			const ord = it.asc ? '' : ' DESC';
+
+			return `${expr}${ord}`;
+		})
+		.join(',');
+
+	const key = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	const whereClause = where ? ` WHERE ${where}` : '';
+	const using = method !== defaults.index.method ? method : null;
+
+	let statement = `CREATE ${indexPart} "${name}" ON ${key}`;
+	if (using === 'hash') {
+		statement += ` (${value}) USING ${using}`;
+	} else {
+		statement += (using ? ` USING ${using}` : '') + ` (${value})`;
+	}
+	statement += `${whereClause};`;
+
+	return statement;
+});
+
+const dropIndexConvertor = convertor('drop_index', (st) => {
+	const { index } = st;
+
+	const cascade = index.isUnique ? ' CASCADE' : '';
+
+	const key = index.schema !== 'public'
+		? `"${index.schema}".`
+		: '';
+
+	return `DROP INDEX ${key}"${st.index.name}"${cascade};`;
+});
+
+const recreateIndexConvertor = convertor('recreate_index', (st) => {
+	const { diff } = st;
+	const drop = dropIndexConvertor.convert({ index: diff.$right }) as string;
+	const create = createIndexConvertor.convert({ index: diff.$right, newTable: false }) as string;
+	return [drop, create];
+});
+
+const renameIndexConvertor = convertor('rename_index', (st) => {
+	const key = st.schema !== 'public' ? `"${st.schema}"."${st.from}"` : `"${st.from}"`;
+
+	return `ALTER INDEX ${key} RENAME TO "${st.to}";`;
+});
+
+const addPrimaryKeyConvertor = convertor('add_pk', (st) => {
+	const { pk } = st;
+	const key = pk.schema !== 'public' ? `"${pk.schema}"."${pk.table}"` : `"${pk.table}"`;
+
+	if (!pk.nameExplicit) {
+		return `ALTER TABLE ${key} ADD PRIMARY KEY ("${pk.columns.join('","')}");`;
+	}
+	return `ALTER TABLE ${key} ADD CONSTRAINT "${pk.name}" PRIMARY KEY("${pk.columns.join('","')}");`;
+});
+
+const dropPrimaryKeyConvertor = convertor('drop_pk', (st) => {
+	const pk = st.pk;
+	const key = pk.schema !== 'public' ? `"${pk.schema}"."${pk.table}"` : `"${pk.table}"`;
+
+	return `ALTER TABLE ${key} DROP CONSTRAINT "${pk.name}";`;
+});
+
+const alterPrimaryKeyConvertor = convertor('alter_pk', (it) => {
+	const key = it.pk.schema !== 'public' ? `"${it.pk.schema}"."${it.pk.table}"` : `"${it.pk.table}"`;
+
+	return `ALTER TABLE ${key} DROP CONSTRAINT "${it.pk.name}", ADD CONSTRAINT "${it.pk.name}" PRIMARY KEY("${
+		it.pk.columns.join('","')
+	}");`;
+});
+
+const recreatePrimaryKeyConvertor = convertor('recreate_pk', (it) => {
+	const { left, right } = it;
+
+	const key = it.right.schema !== 'public' ? `"${right.schema}"."${right.table}"` : `"${right.table}"`;
+
+	return `ALTER TABLE ${key} DROP CONSTRAINT "${left.name}", ADD CONSTRAINT "${right.name}" PRIMARY KEY("${
+		right.columns.join('","')
+	}");`;
+});
+
+const renameConstraintConvertor = convertor('rename_constraint', (st) => {
+	const key = st.schema !== 'public' ? `"${st.schema}"."${st.table}"` : `"${st.table}"`;
+
+	return `ALTER TABLE ${key} RENAME CONSTRAINT "${st.from}" TO "${st.to}";`;
+});
+
+const createForeignKeyConvertor = convertor('create_fk', (st) => {
+	const { schema, table, name, tableTo, columns, columnsTo, onDelete, onUpdate, schemaTo } = st.fk;
+
+	const onDeleteStatement = onDelete && !isDefaultAction(onDelete) ? ` ON DELETE ${onDelete}` : '';
+	const onUpdateStatement = onUpdate && !isDefaultAction(onUpdate) ? ` ON UPDATE ${onUpdate}` : '';
+	const fromColumnsString = columns.map((it) => `"${it}"`).join(',');
+	const toColumnsString = columnsTo.map((it) => `"${it}"`).join(',');
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	const tableToNameWithSchema = schemaTo !== 'public' ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+});
+
+const recreateFKConvertor = convertor('recreate_fk', (st) => {
+	const { fk } = st;
+
+	const key = fk.schema !== 'public' ? `"${fk.schema}"."${fk.table}"` : `"${fk.table}"`;
+
+	const onDeleteStatement = fk.onDelete !== 'NO ACTION' ? ` ON DELETE ${fk.onDelete}` : '';
+	const onUpdateStatement = fk.onUpdate !== 'NO ACTION' ? ` ON UPDATE ${fk.onUpdate}` : '';
+
+	const fromColumnsString = fk.columns.map((it) => `"${it}"`).join(',');
+	const toColumnsString = fk.columnsTo.map((it) => `"${it}"`).join(',');
+
+	const tableToNameWithSchema = fk.schemaTo !== 'public' ? `"${fk.schemaTo}"."${fk.tableTo}"` : `"${fk.tableTo}"`;
+
+	let sql = `ALTER TABLE ${key} DROP CONSTRAINT "${fk.name}", `;
+	sql += `ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${fromColumnsString}) `;
+	sql += `REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+	return sql;
+});
+
+const dropForeignKeyConvertor = convertor('drop_fk', (st) => {
+	const { schema, table, name } = st.fk;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name}";`;
+});
+
+const addCheckConvertor = convertor('add_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'public' ? `"${check.schema}"."${check.table}"` : `"${check.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${check.name}" CHECK (${check.value});`;
+});
+
+const dropCheckConvertor = convertor('drop_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'public' ? `"${check.schema}"."${check.table}"` : `"${check.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${check.name}";`;
+});
+
+const recreateCheckConvertor = convertor('alter_check', (st) => {
+	const { check } = st;
+
+	const key = check.schema !== 'public' ? `"${check.schema}"."${check.table}"` : `"${check.table}"`;
+
+	let sql = [`ALTER TABLE ${key} DROP CONSTRAINT "${check.name}";`];
+	sql.push(`ALTER TABLE ${key} ADD CONSTRAINT "${check.name}" CHECK (${check.value});`);
+
+	return sql;
+});
+
+const createEnumConvertor = convertor('create_enum', (st) => {
+	const { name, schema, values } = st.enum;
+	const enumNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	let valuesStatement = '(';
+	valuesStatement += values.map((it) => `'${escapeSingleQuotes(it)}'`).join(', ');
+	valuesStatement += ')';
+
+	return `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+});
+
+const dropEnumConvertor = convertor('drop_enum', (st) => {
+	const { name, schema } = st.enum;
+	const enumNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+	return `DROP TYPE ${enumNameWithSchema};`;
+});
+
+const renameEnumConvertor = convertor('rename_enum', (st) => {
+	const from = st.schema !== 'public' ? `"${st.schema}"."${st.from}"` : `"${st.from}"`;
+	return `ALTER TYPE ${from} RENAME TO "${st.to}";`;
+});
+
+const moveEnumConvertor = convertor('move_enum', (st) => {
+	const { from, to } = st;
+
+	const enumNameWithSchema = from.schema !== 'public' ? `"${from.schema}"."${from.name}"` : `"${from.name}"`;
+	return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${to.schema || 'public'}";`;
+});
+
+const alterEnumConvertor = convertor('alter_enum', (st) => {
+	const { diff, to } = st;
+	const key = to.schema !== 'public' ? `"${to.schema}"."${to.name}"` : `"${to.name}"`;
+
+	const statements = [] as string[];
+	for (const d of diff.filter((it) => it.type === 'added')) {
+		if (d.beforeValue) {
+			statements.push(`ALTER TYPE ${key} ADD VALUE '${d.value}' BEFORE '${d.beforeValue}';`);
+		} else {
+			statements.push(`ALTER TYPE ${key} ADD VALUE '${d.value}';`);
+		}
+	}
+	return statements;
+});
+
+const recreateEnumConvertor = convertor('recreate_enum', (st) => {
+	const { to, columns } = st;
+
+	const statements: string[] = [];
+	for (const column of columns) {
+		const key = column.schema !== 'public' ? `"${column.schema}"."${column.table}"` : `"${column.table}"`;
+		statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE text;`);
+		if (column.default.left) statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+	}
+	statements.push(dropEnumConvertor.convert({ enum: to }) as string);
+	statements.push(createEnumConvertor.convert({ enum: to }) as string);
+
+	for (const column of columns) {
+		const key = column.schema !== 'public' ? `"${column.schema}"."${column.table}"` : `"${column.table}"`;
+		const arr = column.dimensions > 0 ? '[]' : '';
+		const enumType = to.schema !== 'public' ? `"${to.schema}"."${to.name}"${arr}` : `"${to.name}"${arr}`;
+		statements.push(
+			`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE ${enumType} USING "${column.name}"::${enumType};`,
+		);
+		if (column.default.right) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${
+				defaultToSQL({
+					default: column.default.right,
+					dimensions: column.dimensions,
+					type: column.type,
+					typeSchema: column.typeSchema,
+				})
+			};`);
+		}
+	}
+
+	return statements;
+});
+
+const createSequenceConvertor = convertor('create_sequence', (st) => {
+	const { name, schema, minValue, maxValue, incrementBy, startWith, cacheSize } = st.sequence;
+	const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+	return `CREATE SEQUENCE ${sequenceWithSchema}${incrementBy ? ` INCREMENT BY ${incrementBy}` : ''}${
+		minValue ? ` MINVALUE ${minValue}` : ''
+	}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+		cacheSize ? ` CACHE ${cacheSize}` : ''
+	};`;
+});
+
+const dropSequenceConvertor = convertor('drop_sequence', (st) => {
+	const { name, schema } = st.sequence;
+	const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+	return `DROP SEQUENCE ${sequenceWithSchema};`;
+});
+
+const renameSequenceConvertor = convertor('rename_sequence', (st) => {
+	const sequenceWithSchemaFrom = st.from.schema !== 'public'
+		? `"${st.from.schema}"."${st.from.name}"`
+		: `"${st.from.name}"`;
+	return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${st.to.name}";`;
+});
+
+const moveSequenceConvertor = convertor('move_sequence', (st) => {
+	const { from, to } = st;
+	const sequenceWithSchema = from.schema !== 'public' ? `"${from.schema}"."${from.name}"` : `"${from.name}"`;
+	const seqSchemaTo = `"${to.schema}"`;
+	return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
+});
+
+const alterSequenceConvertor = convertor('alter_sequence', (st) => {
+	const { schema, name, incrementBy, minValue, maxValue, startWith, cacheSize } = st.sequence;
+
+	const sequenceWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	return `ALTER SEQUENCE ${sequenceWithSchema}${incrementBy ? ` INCREMENT BY ${incrementBy}` : ''}${
+		minValue ? ` MINVALUE ${minValue}` : ''
+	}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+		cacheSize ? ` CACHE ${cacheSize}` : ''
+	};`;
+});
+
+const createRoleConvertor = convertor('create_role', (st) => {
+	const { name, createDb, createRole } = st.role;
+	const withClause = createDb || createRole
+		? ` WITH${createDb ? ' CREATEDB' : ''}${createRole ? ' CREATEROLE' : ''}`
+		: '';
+
+	return `CREATE ROLE "${name}"${withClause};`;
+});
+
+const dropRoleConvertor = convertor('drop_role', (st) => {
+	return `DROP ROLE "${st.role.name}";`;
+});
+
+const alterRoleConvertor = convertor('alter_role', (st) => {
+	const { name, createDb, createRole } = st.role;
+	return `ALTER ROLE "${name}"${` WITH${createDb ? ' CREATEDB' : ' NOCREATEDB'}${
+		createRole ? ' CREATEROLE' : ' NOCREATEROLE'
+	}`};`;
+});
+
+const createPolicyConvertor = convertor('create_policy', (st) => {
+	const { schema, table } = st.policy;
+	const policy = st.policy;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`;
+
+	const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+	const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+	const policyToPart = policy.roles?.map((v) => (['current_user', 'session_user', 'public'].includes(v) ? v : `"${v}"`))
+		.join(', ');
+
+	return `CREATE POLICY "${policy.name}" ON ${tableNameWithSchema} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+});
+
+const dropPolicyConvertor = convertor('drop_policy', (st) => {
+	const policy = st.policy;
+
+	const tableNameWithSchema = policy.schema !== 'public' ? `"${policy.schema}"."${policy.table}"` : `"${policy.table}"`;
+
+	return `DROP POLICY "${policy.name}" ON ${tableNameWithSchema};`;
+});
+
+const renamePolicyConvertor = convertor('rename_policy', (st) => {
+	const { from, to } = st;
+
+	const tableNameWithSchema = to.schema !== 'public' ? `"${to.schema}"."${to.table}"` : `"${to.table}"`;
+
+	return `ALTER POLICY "${from.name}" ON ${tableNameWithSchema} RENAME TO "${to.name}";`;
+});
+
+const alterPolicyConvertor = convertor('alter_policy', (st) => {
+	const { policy } = st;
+
+	const tableNameWithSchema = policy.schema !== 'public' ? `"${policy.schema}"."${policy.table}"` : `"${policy.table}"`;
+
+	const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+	const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+	const toClause = policy.roles?.map((
+		v,
+	) => (['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`)).join(', ');
+
+	return `ALTER POLICY "${policy.name}" ON ${tableNameWithSchema} TO ${toClause}${usingPart}${withCheckPart};`;
+});
+
+const recreatePolicy = convertor('recreate_policy', (st) => {
+	return [
+		dropPolicyConvertor.convert({ policy: st.policy }) as string,
+		createPolicyConvertor.convert({ policy: st.policy }) as string,
+	];
+});
+
+const toggleRlsConvertor = convertor('alter_rls', (st) => {
+	const { schema, name, isRlsEnabled } = st;
+
+	const tableNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ${isRlsEnabled ? 'ENABLE' : 'DISABLE'} ROW LEVEL SECURITY;`;
+});
+
+const convertors = [
+	createSchemaConvertor,
+	dropSchemaConvertor,
+	renameSchemaConvertor,
+	createViewConvertor,
+	dropViewConvertor,
+	renameViewConvertor,
+	moveViewConvertor,
+	recreateViewConvertor,
+	createTableConvertor,
+	dropTableConvertor,
+	renameTableConvertor,
+	moveTableConvertor,
+	addColumnConvertor,
+	dropColumnConvertor,
+	renameColumnConvertor,
+	recreateColumnConvertor,
+	alterColumnConvertor,
+	createIndexConvertor,
+	dropIndexConvertor,
+	recreateIndexConvertor,
+	renameIndexConvertor,
+	addPrimaryKeyConvertor,
+	dropPrimaryKeyConvertor,
+	recreatePrimaryKeyConvertor,
+	createForeignKeyConvertor,
+	recreateFKConvertor,
+	dropForeignKeyConvertor,
+	addCheckConvertor,
+	dropCheckConvertor,
+	recreateCheckConvertor,
+	renameConstraintConvertor,
+	createEnumConvertor,
+	dropEnumConvertor,
+	renameEnumConvertor,
+	moveEnumConvertor,
+	alterEnumConvertor,
+	recreateEnumConvertor,
+	createSequenceConvertor,
+	dropSequenceConvertor,
+	renameSequenceConvertor,
+	moveSequenceConvertor,
+	alterSequenceConvertor,
+	createRoleConvertor,
+	dropRoleConvertor,
+	alterRoleConvertor,
+	createPolicyConvertor,
+	dropPolicyConvertor,
+	renamePolicyConvertor,
+	alterPolicyConvertor,
+	recreatePolicy,
+	toggleRlsConvertor,
+	alterPrimaryKeyConvertor,
+	alterColumnAddNotNullConvertor,
+	alterColumnDropNotNullConvertor,
+];
+
+export function fromJson(statements: JsonStatement[]) {
+	const grouped = statements
+		.map((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+			if (!convertor) throw new Error(`No convertor for: ${statement.type} statement`);
+
+			const sqlStatements = convertor.convert(statement as any);
+			const statements = typeof sqlStatements === 'string' ? [sqlStatements] : sqlStatements;
+			return { jsonStatement: statement, sqlStatements: statements };
+		})
+		.filter((it) => it !== null);
+
+	const result = {
+		sqlStatements: grouped.map((it) => it.sqlStatements).flat(),
+		groupedStatements: grouped,
+	};
+	return result;
+}
diff --git a/drizzle-kit/src/dialects/cockroach/ddl.ts b/drizzle-kit/src/dialects/cockroach/ddl.ts
new file mode 100644
index 0000000000..5318b5bb35
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/ddl.ts
@@ -0,0 +1,497 @@
+import type { SchemaForPull } from '../../cli/commands/pull-common';
+import { create } from '../dialect';
+import { defaultNameForPK, defaultNameForUnique } from './grammar';
+import { defaults } from './grammar';
+
+export const createDDL = () => {
+	return create({
+		schemas: {},
+		tables: { schema: 'required', isRlsEnabled: 'boolean' },
+		enums: {
+			schema: 'required',
+			values: 'string[]',
+		},
+		columns: {
+			schema: 'required',
+			table: 'required',
+			type: 'string',
+			typeSchema: 'string?',
+			notNull: 'boolean',
+			dimensions: 'number',
+			default: 'string?',
+			generated: {
+				type: ['stored', 'virtual'],
+				as: 'string',
+			},
+			identity: {
+				type: ['always', 'byDefault'],
+				increment: 'string?',
+				minValue: 'string?',
+				maxValue: 'string?',
+				startWith: 'string?',
+				cache: 'number?',
+			},
+		},
+		indexes: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: [
+				{
+					value: 'string',
+					isExpression: 'boolean',
+					asc: 'boolean',
+				},
+			],
+			isUnique: 'boolean',
+			where: 'string?',
+			method: 'string?',
+		},
+		fks: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+			schemaTo: 'string',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+			onDelete: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+		},
+		pks: {
+			schema: 'required',
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+		},
+		checks: {
+			schema: 'required',
+			table: 'required',
+			value: 'string',
+		},
+		sequences: {
+			schema: 'required',
+			incrementBy: 'string?',
+			minValue: 'string?',
+			maxValue: 'string?',
+			startWith: 'string?',
+			cacheSize: 'number?',
+		},
+		roles: {
+			createDb: 'boolean?',
+			createRole: 'boolean?',
+		},
+		policies: {
+			schema: 'required',
+			table: 'required',
+			as: ['PERMISSIVE', 'RESTRICTIVE'],
+			for: ['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE'],
+			roles: 'string[]', // TO { role_name | PUBLIC | CURRENT_ROLE | SESSION_USER }
+			using: 'string?',
+			withCheck: 'string?',
+		},
+		views: {
+			schema: 'required',
+			definition: 'string?',
+			withNoData: 'boolean?',
+			materialized: 'boolean',
+		},
+	});
+};
+
+export type CockroachDDL = ReturnType<typeof createDDL>;
+
+export type CockroachEntities = CockroachDDL['_']['types'];
+export type CockroachEntity = CockroachEntities[keyof CockroachEntities];
+
+export type DiffEntities = CockroachDDL['_']['diffs']['alter'];
+
+export type Schema = CockroachEntities['schemas'];
+export type Enum = CockroachEntities['enums'];
+export type Sequence = CockroachEntities['sequences'];
+export type Column = CockroachEntities['columns'];
+export type Identity = Column['identity'];
+export type Role = CockroachEntities['roles'];
+export type Index = CockroachEntities['indexes'];
+export type ForeignKey = CockroachEntities['fks'];
+export type PrimaryKey = CockroachEntities['pks'];
+export type CheckConstraint = CockroachEntities['checks'];
+export type Policy = CockroachEntities['policies'];
+export type View = CockroachEntities['views'];
+export type ViewColumn = {
+	schema: string;
+	view: string;
+	type: string;
+	typeSchema: string | null;
+	notNull: boolean;
+	dimensions: number;
+	name: string;
+};
+
+export type Table = {
+	schema: string;
+	name: string;
+	columns: Column[];
+	indexes: Index[];
+	pk: PrimaryKey | null;
+	fks: ForeignKey[];
+	checks: CheckConstraint[];
+	policies: Policy[];
+	isRlsEnabled: boolean;
+};
+
+export type InterimColumn = Omit<Column, 'primaryKey'> & {
+	pk: boolean;
+	pkName: string | null;
+} & {
+	unique: boolean;
+	uniqueName: string | null;
+};
+
+export type InterimIndex = Index & {
+	forPK: boolean;
+};
+
+export interface InterimSchema {
+	schemas: Schema[];
+	enums: Enum[];
+	tables: CockroachEntities['tables'][];
+	columns: InterimColumn[];
+	indexes: InterimIndex[];
+	pks: PrimaryKey[];
+	fks: ForeignKey[];
+	checks: CheckConstraint[];
+	sequences: Sequence[];
+	roles: Role[];
+	policies: Policy[];
+	views: View[];
+	viewColumns: ViewColumn[];
+}
+
+export const tableFromDDL = (
+	table: CockroachEntities['tables'],
+	ddl: CockroachDDL,
+): Table => {
+	const filter = { schema: table.schema, table: table.name } as const;
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+	const policies = ddl.policies.list(filter);
+	return {
+		...table,
+		columns,
+		pk,
+		fks,
+		checks,
+		indexes,
+		policies,
+	};
+};
+
+interface SchemaDuplicate {
+	type: 'schema_name_duplicate';
+	name: string;
+}
+
+interface EnumDuplicate {
+	type: 'enum_name_duplicate';
+	name: string;
+	schema: string;
+}
+
+interface TableDuplicate {
+	type: 'table_name_duplicate';
+	name: string;
+	schema: string;
+}
+interface ColumnDuplicate {
+	type: 'column_name_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+
+interface ConstraintDuplicate {
+	type: 'constraint_name_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+interface SequenceDuplicate {
+	type: 'sequence_name_duplicate';
+	schema: string;
+	name: string;
+}
+
+interface ViewDuplicate {
+	type: 'view_name_duplicate';
+	schema: string;
+	name: string;
+}
+
+interface IndexWithoutName {
+	type: 'index_no_name';
+	schema: string;
+	table: string;
+	sql: string;
+}
+
+interface IndexDuplicate {
+	type: 'index_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+
+interface PgVectorIndexNoOp {
+	type: 'pgvector_index_noop';
+	table: string;
+	column: string;
+	indexName: string;
+	method: string;
+}
+
+interface PolicyDuplicate {
+	type: 'policy_duplicate';
+	schema: string;
+	table: string;
+	policy: string;
+}
+
+interface RoleDuplicate {
+	type: 'role_duplicate';
+	name: string;
+}
+
+export type SchemaError =
+	| SchemaDuplicate
+	| EnumDuplicate
+	| TableDuplicate
+	| ColumnDuplicate
+	| ViewDuplicate
+	| ConstraintDuplicate
+	| SequenceDuplicate
+	| IndexWithoutName
+	| IndexDuplicate
+	| PgVectorIndexNoOp
+	| RoleDuplicate
+	| PolicyDuplicate;
+
+interface PolicyNotLinked {
+	type: 'policy_not_linked';
+	policy: string;
+}
+export type SchemaWarning = PolicyNotLinked;
+
+export const fromEntities = (entities: CockroachEntity[]) => {
+	const ddl = createDDL();
+	for (const it of entities) {
+		ddl.entities.push(it);
+	}
+
+	return ddl;
+};
+export const interimToDDL = (
+	schema: InterimSchema,
+): { ddl: CockroachDDL; errors: SchemaError[] } => {
+	const ddl = createDDL();
+	const errors: SchemaError[] = [];
+
+	for (const it of schema.schemas) {
+		const res = ddl.schemas.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'schema_name_duplicate', name: it.name });
+		}
+	}
+
+	for (const it of schema.enums) {
+		const res = ddl.enums.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'enum_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.tables) {
+		const res = ddl.tables.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'table_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const column of schema.columns) {
+		const { pk: _1, pkName: _2, unique: _3, uniqueName: _4, ...rest } = column;
+		const res = ddl.columns.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'column_name_duplicate',
+				schema: column.schema,
+				table: column.table,
+				name: column.name,
+			});
+		}
+	}
+
+	for (const it of schema.indexes) {
+		const { forPK: _, ...rest } = it;
+		const isConflictNamePerSchema = ddl.indexes.one({ schema: it.schema, name: it.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'index_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+
+		ddl.indexes.push(rest);
+	}
+
+	for (const it of schema.fks) {
+		const isConflictNamePerSchema = ddl.fks.one({ schema: it.schema, name: it.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+		ddl.fks.push(it);
+	}
+
+	for (const it of schema.pks) {
+		const isConflictNamePerSchema = ddl.pks.one({ schema: it.schema, name: it.name });
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+		ddl.pks.push(it);
+	}
+
+	for (const column of schema.columns.filter((it) => it.pk)) {
+		const name = column.pkName !== null ? column.pkName : defaultNameForPK(column.table);
+		const exists = ddl.pks.one({ schema: column.schema, table: column.table, name: name }) !== null;
+		if (exists) continue;
+
+		ddl.pks.push({
+			schema: column.schema,
+			table: column.table,
+			name,
+			nameExplicit: column.pkName !== null,
+			columns: [column.name],
+		});
+	}
+
+	for (const column of schema.columns.filter((it) => it.unique)) {
+		const name = column.uniqueName !== null ? column.uniqueName : defaultNameForUnique(column.table, column.name);
+		const exists = ddl.indexes.one({ schema: column.schema, table: column.table, name: name }) !== null;
+		if (exists) continue;
+
+		ddl.indexes.push({
+			table: column.table,
+			name,
+			isUnique: true,
+			method: defaults.index.method,
+			nameExplicit: !!column.uniqueName,
+			where: null,
+			schema: column.schema,
+			columns: [{ asc: true, isExpression: false, value: column.name }],
+		});
+	}
+
+	for (const it of schema.checks) {
+		const isConflictNamePerSchema = ddl.checks.one({ schema: it.schema, name: it.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+		ddl.checks.push(it);
+	}
+
+	for (const it of schema.sequences) {
+		const isConflictNamePerSchema = ddl.sequences.one({ schema: it.schema, name: it.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'sequence_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+		ddl.sequences.push(it);
+	}
+
+	for (const it of schema.roles) {
+		const res = ddl.roles.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'role_duplicate', name: it.name });
+		}
+	}
+	for (const it of schema.policies) {
+		const res = ddl.policies.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'policy_duplicate',
+				schema: it.schema,
+				table: it.table,
+				policy: it.name,
+			});
+		}
+	}
+	for (const it of schema.views) {
+		const res = ddl.views.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'view_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of ddl.entities.list()) {
+		if (!ddl.entities.validate(it)) {
+			throw new Error(`Invalid entity: ${JSON.stringify(it)}`);
+		}
+	}
+
+	return { ddl, errors };
+};
+
+export function cockroachToRelationsPull(schema: CockroachDDL): SchemaForPull {
+	return Object.values(schema.tables.list()).map((table) => {
+		const rawTable = tableFromDDL(table, schema);
+		return {
+			schema: rawTable.schema,
+			foreignKeys: rawTable.fks,
+			uniques: Object.values(rawTable.indexes).map((idx) => ({
+				columns: idx.columns.map((idxc) => {
+					if (!idxc.isExpression && idx.isUnique) {
+						return idxc.value;
+					}
+				}).filter((item) => item !== undefined),
+			})),
+		};
+	});
+}
diff --git a/drizzle-kit/src/dialects/cockroach/diff.ts b/drizzle-kit/src/dialects/cockroach/diff.ts
new file mode 100644
index 0000000000..0329cb60a4
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/diff.ts
@@ -0,0 +1,1108 @@
+import { prepareMigrationRenames } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import { diffStringArrays } from '../../utils/sequence-matcher';
+import type { Resolver } from '../common';
+import { diff } from '../dialect';
+import { groupDiffs, preserveEntityNames } from '../utils';
+import { fromJson } from './convertor';
+import type {
+	CheckConstraint,
+	CockroachDDL,
+	CockroachEntities,
+	Column,
+	DiffEntities,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Schema,
+	Sequence,
+	View,
+} from './ddl';
+import { createDDL, tableFromDDL } from './ddl';
+import { defaults, defaultsCommutative, typesCommutative } from './grammar';
+import type {
+	JsonAlterColumn,
+	JsonAlterColumnAddNotNull,
+	JsonAlterColumnDropNotNull,
+	JsonStatement,
+} from './statements';
+import { prepareStatement } from './statements';
+
+export const ddlDiffDry = async (ddlFrom: CockroachDDL, ddlTo: CockroachDDL, mode: 'default' | 'push') => {
+	const mocks = new Set<string>();
+	return ddlDiff(
+		ddlFrom,
+		ddlTo,
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mode,
+	);
+};
+
+export const ddlDiff = async (
+	ddl1: CockroachDDL,
+	ddl2: CockroachDDL,
+	schemasResolver: Resolver<Schema>,
+	enumsResolver: Resolver<Enum>,
+	sequencesResolver: Resolver<Sequence>,
+	policyResolver: Resolver<Policy>,
+	tablesResolver: Resolver<CockroachEntities['tables']>,
+	columnsResolver: Resolver<Column>,
+	viewsResolver: Resolver<View>,
+	indexesResolver: Resolver<Index>,
+	checksResolver: Resolver<CheckConstraint>,
+	pksResolver: Resolver<PrimaryKey>,
+	fksResolver: Resolver<ForeignKey>,
+	mode: 'default' | 'push',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: { jsonStatement: JsonStatement; sqlStatements: string[] }[];
+	renames: string[];
+}> => {
+	const ddl1Copy = createDDL();
+	for (const entity of ddl1.entities.list()) {
+		ddl1Copy.entities.push(entity);
+	}
+
+	const schemasDiff = diff(ddl1, ddl2, 'schemas');
+	const { created: createdSchemas, deleted: deletedSchemas, renamedOrMoved: renamedSchemas } = await schemasResolver({
+		created: schemasDiff.filter((it) => it.$diffType === 'create'),
+		deleted: schemasDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const rename of renamedSchemas) {
+		ddl1.entities.update({
+			set: {
+				schema: rename.to.name,
+			},
+			where: {
+				schema: rename.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.name,
+			},
+		});
+	}
+
+	const enumsDiff = diff(ddl1, ddl2, 'enums');
+	const { created: createdEnums, deleted: deletedEnums, renamedOrMoved: renamedOrMovedEnums } = await enumsResolver({
+		created: enumsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: enumsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedEnums = renamedOrMovedEnums.filter((it) => it.from.name !== it.to.name);
+	const movedEnums = renamedOrMovedEnums.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedEnums) {
+		ddl1.enums.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+		ddl1.columns.update({
+			set: {
+				type: rename.to.name,
+				typeSchema: rename.to.schema,
+			},
+			where: {
+				type: rename.from.name,
+				typeSchema: rename.from.schema,
+			},
+		});
+	}
+	for (const move of movedEnums) {
+		ddl1.enums.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+		ddl1.columns.update({
+			set: {
+				typeSchema: move.to.schema,
+			},
+			where: {
+				type: move.from.name,
+				typeSchema: move.from.schema,
+			},
+		});
+	}
+
+	const sequencesDiff = diff(ddl1, ddl2, 'sequences');
+	const { created: createdSequences, deleted: deletedSequences, renamedOrMoved: renamedOrMovedSequences } =
+		await sequencesResolver({
+			created: sequencesDiff.filter((it) => it.$diffType === 'create'),
+			deleted: sequencesDiff.filter((it) => it.$diffType === 'drop'),
+		});
+
+	const renamedSequences = renamedOrMovedSequences.filter((it) => it.from.schema === it.to.schema);
+	const movedSequences = renamedOrMovedSequences.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedSequences) {
+		ddl1.sequences.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	for (const move of movedSequences) {
+		ddl1.sequences.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+	}
+
+	const rolesDiff = diff(ddl1, ddl2, 'roles');
+	// Cockroach does not allow to rename roles
+	const createdRoles = rolesDiff.filter((it) => it.$diffType === 'create');
+	const deletedRoles = rolesDiff.filter((it) => it.$diffType === 'drop');
+
+	const tablesDiff = diff(ddl1, ddl2, 'tables');
+
+	const { created: createdTables, deleted: deletedTables, renamedOrMoved: renamedOrMovedTables } = await tablesResolver(
+		{
+			created: tablesDiff.filter((it) => it.$diffType === 'create'),
+			deleted: tablesDiff.filter((it) => it.$diffType === 'drop'),
+		},
+	);
+
+	const renamedTables = renamedOrMovedTables.filter((it) => it.from.name !== it.to.name);
+	const movedTables = renamedOrMovedTables.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedOrMovedTables) {
+		ddl1.tables.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.schema,
+				tableTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schema: rename.to.schema,
+				table: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.name,
+			},
+		});
+
+		ddl1.entities.update({
+			set: {
+				table: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				table: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const columnsDiff = diff(ddl1, ddl2, 'columns');
+	const columnRenames = [] as { from: Column; to: Column }[];
+	const columnsToCreate = [] as Column[];
+	const columnsToDelete = [] as Column[];
+
+	const groupedByTable = groupDiffs(columnsDiff);
+
+	for (let it of groupedByTable) {
+		const { created, deleted, renamedOrMoved } = await columnsResolver({ created: it.inserted, deleted: it.deleted });
+
+		columnsToCreate.push(...created);
+		columnsToDelete.push(...deleted);
+		columnRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of columnRenames) {
+		ddl1.columns.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl1.indexes.update({
+			set: {
+				columns: (it) => {
+					if (!it.isExpression && it.value === rename.from.name) {
+						return { ...it, value: rename.to.name };
+					}
+					return it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+
+		ddl1.pks.update({
+			set: {
+				columns: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				columns: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				columnsTo: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.table,
+			},
+		});
+
+		ddl1.checks.update({
+			set: {
+				value: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+				value: rename.from.name,
+			},
+		});
+	}
+
+	preserveEntityNames(ddl1.fks, ddl2.fks, mode);
+	preserveEntityNames(ddl1.pks, ddl2.pks, mode);
+	preserveEntityNames(ddl1.indexes, ddl2.indexes, mode);
+
+	const diffChecks = diff(ddl1, ddl2, 'checks');
+	const groupedChecksDiff = groupDiffs(diffChecks);
+	const checkRenames = [] as { from: CheckConstraint; to: CheckConstraint }[];
+	const checkCreates = [] as CheckConstraint[];
+	const checkDeletes = [] as CheckConstraint[];
+
+	for (const entry of groupedChecksDiff) {
+		const { renamedOrMoved, created, deleted } = await checksResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		checkCreates.push(...created);
+		checkDeletes.push(...deleted);
+		checkRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of checkRenames) {
+		ddl1.checks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffIndexes = diff(ddl1, ddl2, 'indexes');
+	const groupedIndexesDiff = groupDiffs(diffIndexes);
+	const indexesRenames = [] as { from: Index; to: Index }[];
+	const indexesCreates = [] as Index[];
+	const indexesDeletes = [] as Index[];
+
+	for (const entry of groupedIndexesDiff) {
+		const { renamedOrMoved, created, deleted } = await indexesResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		indexesCreates.push(...created);
+		indexesDeletes.push(...deleted);
+		indexesRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of indexesRenames) {
+		ddl1.indexes.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffPKs = diff(ddl1, ddl2, 'pks');
+	const groupedPKsDiff = groupDiffs(diffPKs);
+	const pksRenames = [] as { from: PrimaryKey; to: PrimaryKey }[];
+	const pksCreates = [] as PrimaryKey[];
+	const pksDeletes = [] as PrimaryKey[];
+
+	for (const entry of groupedPKsDiff) {
+		const { renamedOrMoved, created, deleted } = await pksResolver({ created: entry.inserted, deleted: entry.deleted });
+
+		pksCreates.push(...created);
+		pksDeletes.push(...deleted);
+		pksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of pksRenames) {
+		ddl1.pks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffFKs = diff(ddl1, ddl2, 'fks');
+	const groupedFKsDiff = groupDiffs(diffFKs);
+	const fksRenames = [] as { from: ForeignKey; to: ForeignKey }[];
+	const fksCreates = [] as ForeignKey[];
+	const fksDeletes = [] as ForeignKey[];
+
+	for (const entry of groupedFKsDiff) {
+		const { renamedOrMoved, created, deleted } = await fksResolver({ created: entry.inserted, deleted: entry.deleted });
+
+		fksCreates.push(...created);
+		fksDeletes.push(...deleted);
+		fksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of fksRenames) {
+		ddl1.fks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const policiesDiff = diff(ddl1, ddl2, 'policies');
+	const policiesDiffGrouped = groupDiffs(policiesDiff);
+
+	const policyRenames = [] as { from: Policy; to: Policy }[];
+	const policyCreates = [] as Policy[];
+	const policyDeletes = [] as Policy[];
+
+	for (const entry of policiesDiffGrouped) {
+		const { renamedOrMoved, created, deleted } = await policyResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		policyCreates.push(...created);
+		policyDeletes.push(...deleted);
+		policyRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of policyRenames) {
+		ddl1.policies.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const viewsDiff = diff(ddl1, ddl2, 'views');
+
+	const { created: createdViews, deleted: deletedViews, renamedOrMoved: renamedOrMovedViews } = await viewsResolver({
+		created: viewsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: viewsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedViews = renamedOrMovedViews.filter((it) => it.from.schema === it.to.schema);
+	const movedViews = renamedOrMovedViews.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedViews) {
+		ddl1.views.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+	for (const move of movedViews) {
+		ddl1.views.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+	}
+
+	const alters = diff.alters(ddl1, ddl2);
+
+	const jsonStatements: JsonStatement[] = [];
+
+	/*
+		with new DDL when table gets created with constraints, etc.
+		or existing table with constraints and indexes gets deleted,
+		those entites are treated by diff as newly created or deleted
+
+		we filter them out, because we either create them on table creation
+		or they get automatically deleted when table is deleted
+	*/
+	const tablesFilter = (type: 'deleted' | 'created') => {
+		return (it: { schema: string; table: string }) => {
+			if (type === 'created') {
+				return !createdTables.some((t) => t.schema === it.schema && t.name === it.table);
+			} else {
+				return !deletedTables.some((t) => t.schema === it.schema && t.name === it.table);
+			}
+		};
+	};
+
+	const jsonCreateIndexes = indexesCreates
+		.map((index) => {
+			const tableCreated = !tablesFilter('created')({
+				schema: index.schema,
+				table: index.table,
+			});
+			return prepareStatement('create_index', { index, newTable: tableCreated });
+		}).filter((st) => {
+			const { index, newTable } = st;
+			const forCreateTable = index.isUnique && (!index.method || index.method === defaults.index.method)
+				&& !index.where;
+			return !(newTable && forCreateTable);
+		});
+	const jsonDropIndexes = indexesDeletes.filter(tablesFilter('deleted')).map((index) =>
+		prepareStatement('drop_index', { index })
+	);
+
+	const jsonRenameIndexes = indexesRenames.map((r) => {
+		return prepareStatement('rename_index', { schema: r.to.schema, from: r.from.name, to: r.to.name });
+	});
+
+	const indexesAlters = alters.filter((it): it is DiffEntities['indexes'] => {
+		if (it.entityType !== 'indexes') return false;
+
+		return ddl2.indexes.hasDiff(it);
+	});
+
+	const jsonRecreateIndexes = indexesAlters.filter((idx) => {
+		const forWhere = !!idx.where && (idx.where.from !== null && idx.where.to !== null ? mode !== 'push' : true);
+		const forColumns = !!idx.columns && (idx.columns.from.length === idx.columns.to.length ? mode !== 'push' : true);
+
+		return idx.isUnique || idx.method || forColumns || forWhere;
+	}).map((x) => {
+		return prepareStatement('recreate_index', { diff: x });
+	});
+
+	const jsonDropTables = deletedTables.map((it) => {
+		const oldSchema = renamedSchemas.find((x) => x.to.name === it.schema);
+		const key = oldSchema ? `"${oldSchema.from.name}"."${it.name}"` : `"${it.schema}"."${it.name}"`;
+		return prepareStatement('drop_table', { table: tableFromDDL(it, ddl2), key });
+	});
+	const jsonRenameTables = renamedTables.map((it) =>
+		prepareStatement('rename_table', {
+			schema: it.from.schema,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonRenameColumnsStatements = columnRenames.map((it) => prepareStatement('rename_column', it));
+	const jsonDropColumnsStatemets = columnsToDelete.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_column', { column: it })
+	);
+	const jsonAddColumnsStatemets = columnsToCreate.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_column', {
+			column: it,
+		})
+	);
+
+	// defaults
+	const columnAlters = alters
+		.filter((it) => it.entityType === 'columns')
+		.filter((it) => {
+			// decimal(19) === decimal(19,0)
+			if (it.type && it.type.from.replace(',0)', ')') === it.type.to) {
+				delete it.type;
+			}
+
+			if (
+				!it.type && it.default
+				&& defaultsCommutative(it.default, it.$right.type, it.$right.dimensions, Boolean(it.$right.typeSchema))
+				&& mode === 'push' // TODO check on push only??
+			) {
+				delete it.default;
+			}
+
+			return ddl2.columns.hasDiff(it);
+		});
+
+	const columnsToRecreate = columnAlters
+		.filter((it) => it.generated)
+		.filter((it) => {
+			// if push and definition changed
+			return !(it.generated?.to && it.generated.from && mode === 'push');
+		});
+
+	const jsonRecreateColumns = columnsToRecreate.map((it) =>
+		prepareStatement('recreate_column', {
+			diff: it,
+		})
+	);
+
+	const jsonRenamePrimaryKey = pksRenames.map((it) => {
+		return prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		});
+	});
+
+	const jsonSetTableSchemas = movedTables.map((it) =>
+		prepareStatement('move_table', {
+			name: it.to.name, // raname of table comes first
+			from: it.from.schema,
+			to: it.to.schema,
+		})
+	);
+
+	const jsonCreatedCheckConstraints = checkCreates.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_check', { check: it })
+	);
+	const jsonDropCheckConstraints = checkDeletes.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_check', { check: it })
+	);
+
+	const alteredChecks = alters.filter((it) => it.entityType === 'checks');
+
+	// group by tables?
+	const alteredPKs = alters
+		.filter((it) => it.entityType === 'pks')
+		.filter((it) => {
+			return !!it.columns; // ignore explicit name change
+		});
+	const jsonAlteredPKs = alteredPKs.map((it) => prepareStatement('alter_pk', { diff: it, pk: it.$right }));
+
+	const jsonRecreatePk = pksCreates.flatMap((created) => {
+		const matchingDeleted = pksDeletes.find((deleted) =>
+			created.schema === deleted.schema && created.table === deleted.table
+		);
+
+		return matchingDeleted ? [prepareStatement('recreate_pk', { left: matchingDeleted, right: created })] : [];
+	});
+
+	const pksRecreatedFilter = () => {
+		return (it: { schema: string; table: string }) => {
+			return !jsonRecreatePk.some((t) =>
+				(t.left.schema === it.schema && t.left.table === it.table)
+				|| (t.right.schema === it.schema && t.right.table === it.table)
+			);
+		};
+	};
+	const jsonAddPrimaryKeys = pksCreates
+		.filter(tablesFilter('created'))
+		.filter(pksRecreatedFilter())
+		.map((it) => prepareStatement('add_pk', { pk: it }));
+	const jsonDropPrimaryKeys = pksDeletes
+		.filter(tablesFilter('deleted'))
+		.filter(pksRecreatedFilter())
+		.map((it) => prepareStatement('drop_pk', { pk: it }));
+
+	const jsonRecreateFKs = alters
+		.filter((it) => it.entityType === 'fks')
+		.filter((x) => {
+			if (
+				x.nameExplicit
+				&& ((mode === 'push' && x.nameExplicit.from && !x.nameExplicit.to)
+					|| (x.nameExplicit.to && !x.nameExplicit.from))
+			) {
+				delete x.nameExplicit;
+			}
+
+			return ddl2.fks.hasDiff(x);
+		})
+		.map((it) => prepareStatement('recreate_fk', { fk: it.$right, diff: it }));
+
+	const jsonCreateFKs = fksCreates.map((it) => prepareStatement('create_fk', { fk: it }));
+
+	const jsonDropFks = fksDeletes.filter((fk) => {
+		const fromDeletedTable = deletedTables.some((x) => x.schema === fk.schema && x.name === fk.table);
+		const sameTable = fk.schema === fk.schemaTo && fk.table === fk.tableTo;
+		const toDeletedTable = !sameTable && deletedTables.some((x) => x.schema === fk.schemaTo && x.name === fk.tableTo);
+
+		if (fromDeletedTable && !toDeletedTable) return false;
+		return true;
+	})
+		.map((it) => prepareStatement('drop_fk', { fk: it }));
+
+	const jsonRenameFks = fksRenames.map((it) =>
+		prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonAlterCheckConstraints = alteredChecks.filter((it) => it.value && mode !== 'push').map((it) =>
+		prepareStatement('alter_check', { check: it.$right, diff: it })
+	);
+	const jsonCreatePoliciesStatements = policyCreates.map((it) => prepareStatement('create_policy', { policy: it }));
+	const jsonDropPoliciesStatements = policyDeletes.map((it) => prepareStatement('drop_policy', { policy: it }));
+	const jsonRenamePoliciesStatements = policyRenames.map((it) => prepareStatement('rename_policy', it));
+
+	const alteredPolicies = alters.filter((it) => it.entityType === 'policies');
+
+	// using/withcheck in policy is a SQL expression which can be formatted by database in a different way,
+	// thus triggering recreations/alternations on push
+	const jsonAlterOrRecreatePoliciesStatements = alteredPolicies
+		.filter((it) => {
+			return it.as || it.for || it.roles || !((it.using || it.withCheck) && mode === 'push');
+		})
+		.map((it) => {
+			const to = ddl2.policies.one({
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			})!;
+			if (it.for || it.as) {
+				return prepareStatement('recreate_policy', {
+					policy: to,
+					diff: it,
+				});
+			} else {
+				return prepareStatement('alter_policy', {
+					diff: it,
+					policy: to,
+				});
+			}
+		});
+
+	// explicit rls alters
+	const rlsAlters = alters.filter((it) => it.entityType === 'tables').filter((it) => it.isRlsEnabled);
+
+	const jsonAlterRlsStatements = rlsAlters.map((it) =>
+		prepareStatement('alter_rls', {
+			schema: it.schema,
+			name: it.name,
+			isRlsEnabled: it.isRlsEnabled?.to || false,
+		})
+	);
+
+	for (const it of policyDeletes) {
+		if (rlsAlters.some((alter) => alter.schema === it.schema && alter.name === it.table)) continue; // skip for explicit
+
+		const had = ddl1.policies.list({ schema: it.schema, table: it.table }).length;
+		const has = ddl2.policies.list({ schema: it.schema, table: it.table }).length;
+
+		const prevTable = ddl1.tables.one({ schema: it.schema, name: it.table });
+		const table = ddl2.tables.one({ schema: it.schema, name: it.table });
+
+		// I don't want dedup here, not a valuable optimisation
+		if (
+			table !== null // not external table
+			&& had > 0
+			&& has === 0
+			&& prevTable
+			&& prevTable.isRlsEnabled === false
+			&& !jsonAlterRlsStatements.some((st) => st.schema === it.schema && st.name === it.table)
+		) {
+			jsonAlterRlsStatements.push(
+				prepareStatement('alter_rls', {
+					schema: it.schema,
+					name: it.table,
+					isRlsEnabled: false,
+				}),
+			);
+		}
+	}
+
+	for (const it of policyCreates) {
+		if (rlsAlters.some((alter) => alter.schema === it.schema && alter.name === it.table)) continue; // skip for explicit
+		if (createdTables.some((t) => t.schema === it.schema && t.name === it.table)) continue; // skip for created tables
+		if (jsonAlterRlsStatements.some((st) => st.schema === it.schema && st.name === it.table)) continue; // skip for existing rls toggles
+
+		const had = ddl1.policies.list({ schema: it.schema, table: it.table }).length;
+		const has = ddl2.policies.list({ schema: it.schema, table: it.table }).length;
+
+		const table = ddl2.tables.one({ schema: it.schema, name: it.table });
+
+		if (
+			table !== null // not external table
+			&& had === 0
+			&& has > 0
+			&& !table.isRlsEnabled
+		) {
+			jsonAlterRlsStatements.push(
+				prepareStatement('alter_rls', {
+					schema: it.schema,
+					name: it.table,
+					isRlsEnabled: true,
+				}),
+			);
+		}
+	}
+
+	// if I drop policy/ies, I should check if table only had this policy/ies and turn off
+	// for non explicit rls =
+
+	const policiesAlters = alters.filter((it) => it.entityType === 'policies');
+	// TODO:
+	const _jsonPloiciesAlterStatements = policiesAlters.map((it) =>
+		prepareStatement('alter_policy', { diff: it, policy: it.$right })
+	);
+
+	const jsonCreateEnums = createdEnums.map((it) => prepareStatement('create_enum', { enum: it }));
+	const jsonDropEnums = deletedEnums.map((it) => prepareStatement('drop_enum', { enum: it }));
+	const jsonMoveEnums = movedEnums.map((it) => prepareStatement('move_enum', it));
+	const jsonRenameEnums = renamedEnums.map((it) =>
+		prepareStatement('rename_enum', {
+			schema: it.to.schema,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+	const enumsAlters = alters.filter((it) => it.entityType === 'enums');
+
+	const recreateEnums = [] as Extract<JsonStatement, { type: 'recreate_enum' }>[];
+	const jsonAlterEnums = [] as Extract<JsonStatement, { type: 'alter_enum' }>[];
+
+	for (const alter of enumsAlters) {
+		const values = alter.values!;
+		const res = diffStringArrays(values.from, values.to);
+		const e = { ...alter, values: values.to };
+
+		if (res.some((it) => it.type === 'removed')) {
+			// recreate enum
+			const columns = ddl1.columns.list({ typeSchema: alter.schema, type: alter.name }).map((it) => {
+				const c2 = ddl2.columns.one({ schema: it.schema, table: it.table, name: it.name })!;
+
+				const def = {
+					right: c2.default,
+					left: it.default,
+				};
+				return { ...it, default: def };
+			});
+			recreateEnums.push(prepareStatement('recreate_enum', { to: e.$right, columns, from: e.$left }));
+		} else {
+			jsonAlterEnums.push(prepareStatement('alter_enum', { diff: res, to: e.$left, from: e.$right }));
+		}
+	}
+
+	const jsonAlterAddNotNull: JsonAlterColumnAddNotNull[] = [];
+	const jsonAlterDropNotNull: JsonAlterColumnDropNotNull[] = [];
+	const jsonAlterColumns: JsonAlterColumn[] = [];
+	const filteredColumnAlters = columnAlters
+		.filter((it) => !it.generated)
+		.filter((it) => {
+			// if column is of type enum we're about to recreate - we will reset default anyway
+			if (
+				it.default
+				&& recreateEnums.some((x) =>
+					x.columns.some((c) => it.schema === c.schema && it.table === c.table && it.name === c.name)
+				)
+			) {
+				delete it.default;
+			}
+
+			if (it.type && typesCommutative(it.type.from, it.type.to)) {
+				delete it.type;
+			}
+
+			if (it.notNull && it.notNull.to && (it.$right.generated || it.$right.identity)) {
+				delete it.notNull;
+			}
+
+			if (it.notNull && (it.notNull.to && it.identity?.to)) {
+				delete it.notNull;
+			}
+
+			return ddl2.columns.hasDiff(it);
+		});
+
+	// TODO: move to alter_column convertor
+	// cc: @AleksandrSherman
+	for (const it of filteredColumnAlters) {
+		if (it.notNull) {
+			if (it.notNull.from) {
+				jsonAlterDropNotNull.push(
+					prepareStatement('alter_drop_column_not_null', {
+						table: it.table,
+						schema: it.schema,
+						column: it.name,
+					}),
+				);
+			} else {
+				jsonAlterAddNotNull.push(prepareStatement('alter_add_column_not_null', {
+					table: it.table,
+					schema: it.schema,
+					column: it.name,
+				}));
+			}
+		}
+
+		const column = it.$right;
+		jsonAlterColumns.push(prepareStatement('alter_column', {
+			diff: it,
+			isEnum: ddl2.enums.one({ schema: column.typeSchema ?? 'public', name: column.type }) !== null,
+			wasEnum: (it.type && ddl1.enums.one({ schema: column.typeSchema ?? 'public', name: it.type.from }) !== null)
+				?? false,
+			to: column,
+		}));
+	}
+
+	const createSequences = createdSequences.map((it) => prepareStatement('create_sequence', { sequence: it }));
+	const dropSequences = deletedSequences.map((it) => prepareStatement('drop_sequence', { sequence: it }));
+	const moveSequences = movedSequences.map((it) => prepareStatement('move_sequence', it));
+	const renameSequences = renamedSequences.map((it) => prepareStatement('rename_sequence', it));
+	const sequencesAlter = alters.filter((it) => it.entityType === 'sequences');
+	const jsonAlterSequences = sequencesAlter.map((it) =>
+		prepareStatement('alter_sequence', { diff: it, sequence: it.$right })
+	);
+
+	const jsonCreateRoles = createdRoles.map((it) => prepareStatement('create_role', { role: it }));
+	const jsonDropRoles = deletedRoles.map((it) => prepareStatement('drop_role', { role: it }));
+	const jsonAlterRoles = alters.filter((it) => it.entityType === 'roles').map((it) =>
+		prepareStatement('alter_role', { diff: it, role: it.$right })
+	);
+
+	const createSchemas = createdSchemas.map((it) => prepareStatement('create_schema', it));
+	const dropSchemas = deletedSchemas.map((it) => prepareStatement('drop_schema', it));
+	const renameSchemas = renamedSchemas.map((it) => prepareStatement('rename_schema', it));
+
+	const createTables = createdTables.map((it) => prepareStatement('create_table', { table: tableFromDDL(it, ddl2) }));
+
+	const createViews = createdViews.map((it) => prepareStatement('create_view', { view: it }));
+	const jsonDropViews = deletedViews.map((it) => prepareStatement('drop_view', { view: it }));
+
+	const jsonMoveViews = movedViews.map((it) =>
+		prepareStatement('move_view', { fromSchema: it.from.schema, toSchema: it.to.schema, view: it.to })
+	);
+
+	const filteredViewAlters = alters.filter((it): it is DiffEntities['views'] => {
+		if (it.entityType !== 'views') return false;
+
+		if (mode === 'push' && it.definition) {
+			delete it.definition;
+		}
+
+		if (mode === 'push' && it.withNoData) {
+			delete it.withNoData;
+		}
+
+		return ddl2.views.hasDiff(it);
+	});
+
+	const viewsAlters = filteredViewAlters.map((it) => ({ diff: it, view: it.$right }));
+
+	const jsonRecreateViews = viewsAlters.map((entry) => {
+		const it = entry.view;
+		const schemaRename = renamedSchemas.find((r) => r.to.name === it.schema);
+		const schema = schemaRename ? schemaRename.from.name : it.schema;
+		const viewRename = renamedViews.find((r) => r.to.schema === it.schema && r.to.name === it.name);
+		const name = viewRename ? viewRename.from.name : it.name;
+		const from = ddl1Copy.views.one({ schema, name });
+
+		if (!from) {
+			throw new Error(`
+				Missing view in original ddl:
+				${it.schema}:${it.name}
+				${schema}:${name}
+				`);
+		}
+		return prepareStatement('recreate_view', { from, to: it });
+	});
+
+	const recreatedTargets = new Set(jsonRecreateViews.map((stmt) => `${stmt.to.schema}:${stmt.to.name}`));
+	const jsonRenameViews = renamedViews.filter(({ to }) => !recreatedTargets.has(`${to.schema}:${to.name}`)).map((
+		rename,
+	) => prepareStatement('rename_view', rename));
+
+	jsonStatements.push(...createSchemas);
+	jsonStatements.push(...renameSchemas);
+	jsonStatements.push(...jsonCreateEnums);
+	jsonStatements.push(...jsonMoveEnums);
+	jsonStatements.push(...jsonRenameEnums);
+	jsonStatements.push(...jsonAlterEnums);
+
+	jsonStatements.push(...createSequences);
+	jsonStatements.push(...moveSequences);
+	jsonStatements.push(...renameSequences);
+	jsonStatements.push(...jsonAlterSequences);
+
+	jsonStatements.push(...jsonDropRoles);
+	jsonStatements.push(...jsonCreateRoles);
+	jsonStatements.push(...jsonAlterRoles);
+
+	jsonStatements.push(...createTables);
+
+	jsonStatements.push(...jsonAlterRlsStatements);
+	jsonStatements.push(...jsonDropViews);
+	jsonStatements.push(...jsonRenameViews);
+	jsonStatements.push(...jsonMoveViews);
+	jsonStatements.push(...jsonRecreateViews);
+
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonDropFks);
+
+	jsonStatements.push(...jsonDropPoliciesStatements); // before drop tables
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonSetTableSchemas);
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...jsonDropCheckConstraints);
+
+	// TODO: ? will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonRenameIndexes);
+	jsonStatements.push(...jsonDropIndexes);
+	jsonStatements.push(...jsonRecreateIndexes);
+	jsonStatements.push(...jsonDropPrimaryKeys);
+
+	jsonStatements.push(...jsonRenamePrimaryKey);
+	jsonStatements.push(...jsonRenameFks);
+	jsonStatements.push(...jsonAddColumnsStatemets);
+	jsonStatements.push(...jsonRecreateColumns);
+
+	jsonStatements.push(...recreateEnums);
+
+	jsonStatements.push(...jsonAlterAddNotNull);
+	jsonStatements.push(...jsonAlterColumns);
+	jsonStatements.push(...jsonAddPrimaryKeys);
+	jsonStatements.push(...jsonAlteredPKs);
+	jsonStatements.push(...jsonRecreatePk);
+	jsonStatements.push(...jsonAlterDropNotNull);
+
+	jsonStatements.push(...jsonCreateFKs);
+	jsonStatements.push(...jsonRecreateFKs);
+	jsonStatements.push(...jsonCreateIndexes);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+
+	jsonStatements.push(...jsonAlterCheckConstraints);
+
+	jsonStatements.push(...createViews);
+
+	jsonStatements.push(...jsonRenamePoliciesStatements);
+	jsonStatements.push(...jsonCreatePoliciesStatements);
+	jsonStatements.push(...jsonAlterOrRecreatePoliciesStatements);
+
+	jsonStatements.push(...jsonDropEnums);
+	jsonStatements.push(...dropSequences);
+	jsonStatements.push(...dropSchemas);
+
+	const { groupedStatements, sqlStatements } = fromJson(jsonStatements);
+
+	const renames = prepareMigrationRenames([
+		...renameSchemas,
+		...renamedEnums,
+		...renamedOrMovedTables,
+		...columnRenames,
+		...checkRenames,
+		...indexesRenames,
+		...pksRenames,
+		...fksRenames,
+		...policyRenames,
+		...renamedOrMovedViews,
+		...renamedOrMovedSequences,
+	]);
+
+	return {
+		statements: jsonStatements,
+		sqlStatements,
+		groupedStatements: groupedStatements,
+		renames: renames,
+	};
+};
diff --git a/drizzle-kit/src/dialects/cockroach/drizzle.ts b/drizzle-kit/src/dialects/cockroach/drizzle.ts
new file mode 100644
index 0000000000..781c2cfa52
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/drizzle.ts
@@ -0,0 +1,738 @@
+import { getTableName, is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type {
+	AnyCockroachColumn,
+	AnyCockroachTable,
+	CockroachEnum,
+	CockroachMaterializedView,
+	CockroachSequence,
+	UpdateDeleteAction,
+} from 'drizzle-orm/cockroach-core';
+import {
+	CockroachArray,
+	CockroachDialect,
+	CockroachEnumColumn,
+	CockroachGeometry,
+	CockroachGeometryObject,
+	CockroachPolicy,
+	CockroachRole,
+	CockroachSchema,
+	CockroachTable,
+	CockroachView,
+	getMaterializedViewConfig,
+	getTableConfig,
+	getViewConfig,
+	IndexedColumn,
+	isCockroachEnum,
+	isCockroachMaterializedView,
+	isCockroachSequence,
+	isCockroachView,
+} from 'drizzle-orm/cockroach-core';
+import { assertUnreachable } from '../../utils';
+import { loadModule } from '../../utils/utils-node';
+import type { EntityFilter } from '../pull-utils';
+import type {
+	CheckConstraint,
+	CockroachEntities,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PrimaryKey,
+	Schema,
+	SchemaError,
+	SchemaWarning,
+} from './ddl';
+import {
+	defaultNameForFK,
+	defaultNameForPK,
+	defaultNameForUnique,
+	defaults,
+	GeometryPoint,
+	indexName,
+	maxRangeForIdentityBasedOn,
+	minRangeForIdentityBasedOn,
+	splitSqlType,
+	stringFromIdentityProperty,
+	trimDefaultValueSuffix,
+	typeFor,
+} from './grammar';
+
+export const policyFrom = (policy: CockroachPolicy, dialect: CockroachDialect) => {
+	const mappedTo = !policy.to
+		? ['public']
+		: typeof policy.to === 'string'
+		? [policy.to]
+		: is(policy.to, CockroachRole)
+		? [(policy.to as CockroachRole).name]
+		: Array.isArray(policy.to)
+		? policy.to.map((it) => {
+			if (typeof it === 'string') {
+				return it;
+			} else if (is(it, CockroachRole)) {
+				return it.name;
+			}
+			return '' as never; // unreachable unless error in types
+		})
+		: ('' as never); // unreachable unless error in types
+
+	const policyAs = (policy.as?.toUpperCase() as Policy['as']) ?? 'PERMISSIVE';
+	const policyFor = (policy.for?.toUpperCase() as Policy['for']) ?? 'ALL';
+	const policyTo = mappedTo.sort(); // TODO: ??
+	const policyUsing = is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : null;
+	const withCheck = is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : null;
+
+	return {
+		name: policy.name,
+		as: policyAs,
+		for: policyFor,
+		roles: policyTo,
+		using: policyUsing,
+		withCheck,
+	};
+};
+
+export const unwrapColumn = (column: AnyCockroachColumn) => {
+	const { baseColumn, dimensions } = is(column, CockroachArray)
+		? unwrapArray(column)
+		: { baseColumn: column, dimensions: 0 };
+
+	const isEnum = is(baseColumn, CockroachEnumColumn);
+	const typeSchema = isEnum ? baseColumn.enum.schema || 'public' : null;
+
+	/* TODO: legacy, for not to patch orm and don't up snapshot */
+	let sqlBaseType = baseColumn.getSQLType();
+	sqlBaseType = sqlBaseType.startsWith('timestamp (') ? sqlBaseType.replace('timestamp (', 'timestamp(') : sqlBaseType;
+
+	const { type, options } = splitSqlType(sqlBaseType);
+	const sqlType = dimensions > 0 ? `${sqlBaseType}${'[]'.repeat(dimensions)}` : sqlBaseType;
+
+	return {
+		baseColumn,
+		dimensions,
+		isEnum,
+		typeSchema,
+		sqlType,
+		baseType: type,
+		options,
+	};
+};
+
+export const unwrapArray = (
+	column: CockroachArray<any, any>,
+	dimensions: number = 1,
+): { baseColumn: AnyCockroachColumn; dimensions: number } => {
+	const baseColumn = column.baseColumn;
+	if (is(baseColumn, CockroachArray)) return unwrapArray(baseColumn, dimensions + 1);
+
+	return { baseColumn, dimensions };
+};
+
+export const transformOnUpdateDelete = (on: UpdateDeleteAction): ForeignKey['onUpdate'] => {
+	if (on === 'no action') return 'NO ACTION';
+	if (on === 'cascade') return 'CASCADE';
+	if (on === 'restrict') return 'RESTRICT';
+	if (on === 'set default') return 'SET DEFAULT';
+	if (on === 'set null') return 'SET NULL';
+
+	assertUnreachable(on);
+};
+
+export const defaultFromColumn = (
+	base: AnyCockroachColumn,
+	def: unknown,
+	dimensions: number,
+	dialect: CockroachDialect,
+): Column['default'] => {
+	if (typeof def === 'undefined') return null;
+
+	if (is(def, SQL)) {
+		let sql = dialect.sqlToQuery(def).sql;
+		sql = trimDefaultValueSuffix(sql);
+
+		// TODO: check if needed
+
+		// const isText = /^'(?:[^']|'')*'$/.test(sql);
+		// sql = isText ? trimChar(sql, "'") : sql;
+
+		return sql;
+	}
+	const { baseColumn, isEnum } = unwrapColumn(base);
+	const grammarType = typeFor(base.getSQLType(), isEnum);
+
+	if (is(baseColumn, CockroachGeometry) || is(baseColumn, CockroachGeometryObject)) {
+		return (dimensions > 0 && Array.isArray(def))
+			? def.flat(5).length === 0
+				? "'{}'"
+				: GeometryPoint.defaultArrayFromDrizzle(def, baseColumn.mode, baseColumn.srid)
+			: GeometryPoint.defaultFromDrizzle(def, baseColumn.mode, baseColumn.srid);
+	}
+
+	if (grammarType) {
+		if (dimensions > 0 && Array.isArray(def)) {
+			if (def.flat(5).length === 0) return "'{}'";
+
+			return grammarType.defaultArrayFromDrizzle(def);
+		}
+
+		return grammarType.defaultFromDrizzle(def);
+	}
+
+	throw new Error(`Unhandled type: ${base.getSQLType()}`);
+};
+
+/*
+	We map drizzle entities into interim schema entities,
+	so that both Drizzle Kit and Drizzle Studio are able to share
+	common business logic of composing and diffing InternalSchema
+
+	By having interim schemas based on arrays instead of records - we can postpone
+	collissions(duplicate indexes, columns, etc.) checking/or printing via extra `errors` field upwards,
+	while trimming serializer.ts of Hanji & Chalk dependencies
+*/
+export const fromDrizzleSchema = (
+	schema: {
+		schemas: CockroachSchema[];
+		tables: AnyCockroachTable[];
+		enums: CockroachEnum<any>[];
+		sequences: CockroachSequence[];
+		roles: CockroachRole[];
+		policies: CockroachPolicy[];
+		views: CockroachView[];
+		matViews: CockroachMaterializedView[];
+	},
+	filter: EntityFilter,
+): {
+	schema: InterimSchema;
+	errors: SchemaError[];
+	warnings: SchemaWarning[];
+} => {
+	const dialect = new CockroachDialect();
+	const errors: SchemaError[] = [];
+	const warnings: SchemaWarning[] = [];
+
+	const res: InterimSchema = {
+		indexes: [],
+		pks: [],
+		fks: [],
+		checks: [],
+		columns: [],
+		policies: [],
+		enums: [],
+		roles: [],
+		schemas: [],
+		sequences: [],
+		tables: [],
+		viewColumns: [],
+		views: [],
+	};
+
+	res.schemas = schema.schemas
+		.filter((x) => {
+			return !x.isExisting && x.schemaName !== 'public' && filter({ type: 'schema', name: x.schemaName });
+		})
+		.map<Schema>((it) => ({
+			entityType: 'schemas',
+			name: it.schemaName,
+		}));
+
+	const tableConfigPairs = schema.tables.map((it) => {
+		return { config: getTableConfig(it), table: it };
+	}).filter((it) => {
+		return filter({ type: 'table', schema: it.config.schema ?? 'public', name: it.config.name });
+	});
+
+	for (const policy of schema.policies) {
+		if (!('_linkedTable' in policy) || typeof policy._linkedTable === 'undefined') {
+			warnings.push({ type: 'policy_not_linked', policy: policy.name });
+			continue;
+		}
+
+		// @ts-expect-error
+		const { schema: configSchema, name: tableName } = getTableConfig(policy._linkedTable);
+
+		const p = policyFrom(policy, dialect);
+		res.policies.push({
+			entityType: 'policies',
+			schema: configSchema ?? 'public',
+			table: tableName,
+			name: p.name,
+			as: p.as,
+			for: p.for,
+			roles: p.roles,
+			using: p.using,
+			withCheck: p.withCheck,
+		});
+	}
+
+	res.tables = tableConfigPairs.map((it) => {
+		const config = it.config;
+		const schema = config.schema ?? 'public';
+		const isRlsEnabled = config.enableRLS || config.policies.length > 0
+			|| res.policies.some((x) => x.schema === schema && x.table === config.name);
+
+		return {
+			entityType: 'tables',
+			schema,
+			name: config.name,
+			isRlsEnabled,
+		} satisfies CockroachEntities['tables'];
+	});
+
+	for (const { config } of tableConfigPairs) {
+		const {
+			name: tableName,
+			columns: drizzleColumns,
+			indexes: drizzleIndexes,
+			foreignKeys: drizzleFKs,
+			checks: drizzleChecks,
+			schema: drizzleSchema,
+			primaryKeys: drizzlePKs,
+			uniqueConstraints: drizzleUniques,
+			policies: drizzlePolicies,
+		} = config;
+
+		const schema = drizzleSchema || 'public';
+
+		res.pks.push(
+			...drizzlePKs.map<PrimaryKey>((pk) => {
+				const columnNames = pk.columns.map((c) => c.name);
+
+				const name = pk.name || defaultNameForPK(tableName);
+				return {
+					entityType: 'pks',
+					schema: schema,
+					table: tableName,
+					name: name,
+					columns: columnNames,
+					nameExplicit: pk.isNameExplicit,
+				};
+			}),
+		);
+
+		res.columns.push(
+			...drizzleColumns.map<InterimColumn>((column) => {
+				const { name } = column;
+				const notNull = column.notNull;
+
+				const generated = column.generated;
+				const identity = column.generatedIdentity;
+
+				const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
+				const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
+					?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
+				const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
+					?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
+				const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
+					?? (parseFloat(increment) < 0 ? maxValue : minValue);
+				const cache = Number(stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? 1);
+
+				const generatedValue: Column['generated'] = generated
+					? {
+						as: is(generated.as, SQL)
+							? dialect.sqlToQuery(generated.as as SQL).sql
+							: typeof generated.as === 'function'
+							? dialect.sqlToQuery(generated.as() as SQL).sql
+							: String(generated.as),
+
+						type: 'stored', // TODO: why only stored? https://orm.drizzle.team/docs/generated-columns
+					}
+					: null;
+
+				const identityValue = identity
+					? {
+						type: identity.type,
+						increment,
+						startWith,
+						minValue,
+						maxValue,
+						cache,
+					}
+					: null;
+
+				const { dimensions, sqlType, typeSchema, baseColumn } = unwrapColumn(column);
+
+				const columnDefault = defaultFromColumn(baseColumn, column.default, dimensions, dialect);
+
+				const isPk = column.primary
+					|| config.primaryKeys.find((pk) =>
+							pk.columns.some((col) => col.name ? col.name === column.name : col.keyAsName === column.keyAsName)
+						) !== undefined;
+
+				return {
+					entityType: 'columns',
+					schema: schema,
+					table: tableName,
+					name,
+					type: sqlType.replaceAll('[]', ''),
+					typeSchema: typeSchema ?? null,
+					dimensions: dimensions,
+					pk: column.primary,
+					pkName: null,
+					notNull: notNull || isPk,
+					default: columnDefault,
+					generated: generatedValue,
+					unique: column.isUnique,
+					uniqueName: column.uniqueName ?? null,
+					identity: identityValue,
+				} satisfies InterimColumn;
+			}),
+		);
+
+		res.fks.push(
+			...drizzleFKs.map<ForeignKey>((fk) => {
+				const onDelete = fk.onDelete;
+				const onUpdate = fk.onUpdate;
+				const reference = fk.reference();
+
+				const tableTo = getTableName(reference.foreignTable);
+
+				const schemaTo = getTableConfig(reference.foreignTable).schema || 'public';
+				const columnsFrom = reference.columns.map((it) => it.name);
+				const columnsTo = reference.foreignColumns.map((it) => it.name);
+
+				const name = fk.getName() || defaultNameForFK(tableName, columnsFrom, tableTo, columnsTo);
+
+				return {
+					entityType: 'fks',
+					schema: schema,
+					table: tableName,
+					name,
+					nameExplicit: fk.isNameExplicit(),
+					tableTo,
+					schemaTo,
+					columns: columnsFrom,
+					columnsTo,
+					onDelete: onDelete ? transformOnUpdateDelete(onDelete) : null,
+					onUpdate: onUpdate ? transformOnUpdateDelete(onUpdate) : null,
+				} satisfies ForeignKey;
+			}),
+		);
+
+		for (const index of drizzleIndexes) {
+			const columns = index.config.columns;
+			for (const column of columns) {
+				if (is(column, IndexedColumn) && column.type !== 'CockroachVector') continue;
+
+				if (is(column, SQL) && !index.isNameExplicit) {
+					errors.push({
+						type: 'index_no_name',
+						schema: schema,
+						table: getTableName(index.config.table),
+						sql: dialect.sqlToQuery(column).sql,
+					});
+					continue;
+				}
+			}
+		}
+
+		for (const unique of drizzleUniques) {
+			const columns: InterimIndex['columns'] = unique.columns.map((c) => {
+				if (is(c, SQL)) {
+					const sql = dialect.sqlToQuery(c).sql;
+					return { value: sql, isExpression: true, asc: true };
+				}
+				return { value: c.name, isExpression: false, asc: true };
+			});
+
+			const name = unique.name
+				?? defaultNameForUnique(tableName, ...unique.columns.filter((c) => !is(c, SQL)).map((c) => c.name));
+
+			res.indexes.push({
+				entityType: 'indexes',
+				columns: columns,
+				forPK: false,
+				isUnique: true,
+				method: defaults.index.method,
+				nameExplicit: unique.isNameExplicit,
+				name: name,
+				schema: schema,
+				table: tableName,
+				where: null,
+			});
+		}
+
+		res.indexes.push(
+			...drizzleIndexes.map<InterimIndex>((value) => {
+				const columns = value.config.columns;
+
+				let indexColumnNames = columns.map((it) => {
+					const name = (it as IndexedColumn).name;
+					return name;
+				});
+
+				const name = value.config.name
+					?? (value.config.unique
+						? defaultNameForUnique(tableName, ...indexColumnNames)
+						: indexName(tableName, indexColumnNames));
+				const nameExplicit = value.isNameExplicit;
+
+				let indexColumns = columns.map((it) => {
+					if (is(it, SQL)) {
+						return {
+							value: dialect.sqlToQuery(it, 'indexes').sql,
+							isExpression: true,
+							asc: true,
+						} satisfies Index['columns'][number];
+					} else {
+						it = it as IndexedColumn;
+
+						const asc = it.indexConfig?.order ? it.indexConfig.order === 'asc' : true;
+						return {
+							value: (it as IndexedColumn).name,
+							isExpression: false,
+							asc: asc,
+						} satisfies Index['columns'][number];
+					}
+				});
+
+				let where = value.config.where ? dialect.sqlToQuery(value.config.where).sql : '';
+				where = where === 'true' ? '' : where;
+
+				return {
+					entityType: 'indexes',
+					schema,
+					table: tableName,
+					name,
+					nameExplicit,
+					columns: indexColumns,
+					isUnique: value.config.unique,
+					where: where ? where : null,
+					method: value.config.method ?? defaults.index.method,
+					forPK: false,
+				} satisfies InterimIndex;
+			}),
+		);
+
+		res.policies.push(
+			...drizzlePolicies.map<Policy>((policy) => {
+				const p = policyFrom(policy, dialect);
+				return {
+					entityType: 'policies',
+					schema: schema,
+					table: tableName,
+					name: p.name,
+					as: p.as,
+					for: p.for,
+					roles: p.roles,
+					using: p.using,
+					withCheck: p.withCheck,
+				};
+			}),
+		);
+
+		res.checks.push(
+			...drizzleChecks.map<CheckConstraint>((check) => {
+				const checkName = check.name;
+				return {
+					entityType: 'checks',
+					schema,
+					table: tableName,
+					name: checkName,
+					value: dialect.sqlToQuery(check.value).sql,
+				};
+			}),
+		);
+	}
+
+	for (const sequence of schema.sequences) {
+		const name = sequence.seqName!;
+		const increment = stringFromIdentityProperty(sequence.seqOptions?.increment) ?? '1';
+		const minValue = stringFromIdentityProperty(sequence.seqOptions?.minValue)
+			?? (parseFloat(increment) < 0 ? '-9223372036854775808' : '1');
+		const maxValue = stringFromIdentityProperty(sequence.seqOptions?.maxValue)
+			?? (parseFloat(increment) < 0 ? '-1' : '9223372036854775807');
+		const startWith = stringFromIdentityProperty(sequence.seqOptions?.startWith)
+			?? (parseFloat(increment) < 0 ? maxValue : minValue);
+		const cache = Number(stringFromIdentityProperty(sequence.seqOptions?.cache) ?? 1);
+		res.sequences.push({
+			entityType: 'sequences',
+			schema: sequence.schema ?? 'public',
+			incrementBy: increment,
+			startWith,
+			name,
+			minValue,
+			maxValue,
+			cacheSize: cache,
+		});
+	}
+
+	for (const _role of schema.roles) {
+		const role = _role as any;
+		if (role._existing) continue;
+
+		res.roles.push({
+			entityType: 'roles',
+			name: role.name,
+			createDb: role.createDb ?? false,
+			createRole: role.createRole ?? false,
+		});
+	}
+
+	const combinedViews = [...schema.views, ...schema.matViews].sort((a, b) => {
+		// see in "./dialects/postgres/drizzle.ts" for more
+		const aConfig = is(a, CockroachView) ? getViewConfig(a) : getMaterializedViewConfig(a);
+		const bConfig = is(b, CockroachView) ? getViewConfig(b) : getMaterializedViewConfig(b);
+
+		// If a's fields include b, a depends on b → b comes first
+		if (aConfig.query?.queryChunks.includes(b)) return 1;
+
+		// If b's fields include a, b depends on a → a comes first
+		if (bConfig.query?.queryChunks.includes(a)) return -1;
+
+		return 0;
+	}).map((it) => {
+		if (is(it, CockroachView)) {
+			return {
+				...getViewConfig(it),
+				materialized: false,
+				tablespace: undefined,
+				using: undefined,
+				withNoData: undefined,
+			};
+		} else {
+			return { ...getMaterializedViewConfig(it), materialized: true };
+		}
+	});
+
+	for (const view of combinedViews) {
+		if (view.isExisting) continue;
+		if (!filter({ type: 'table', schema: view.schema ?? 'public', name: view.name })) continue;
+
+		const { name: viewName, schema, query, withNoData, materialized } = view;
+
+		const viewSchema = schema ?? 'public';
+
+		res.views.push({
+			entityType: 'views',
+			definition: dialect.sqlToQuery(query!).sql,
+			name: viewName,
+			schema: viewSchema,
+			withNoData: withNoData ?? null,
+			materialized,
+		});
+	}
+
+	res.enums = schema.enums.map<Enum>((e) => {
+		return {
+			entityType: 'enums',
+			name: e.enumName,
+			schema: e.schema || 'public',
+			values: e.enumValues,
+		};
+	});
+
+	return {
+		schema: res,
+		errors,
+		warnings,
+	};
+};
+
+export const fromExports = (exports: Record<string, unknown>) => {
+	const tables: AnyCockroachTable[] = [];
+	const enums: CockroachEnum<any>[] = [];
+	const schemas: CockroachSchema[] = [];
+	const sequences: CockroachSequence[] = [];
+	const roles: CockroachRole[] = [];
+	const policies: CockroachPolicy[] = [];
+	const views: CockroachView[] = [];
+	const matViews: CockroachMaterializedView[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (isCockroachEnum(t)) {
+			enums.push(t);
+			return;
+		}
+		if (is(t, CockroachTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, CockroachSchema)) {
+			schemas.push(t);
+		}
+
+		if (isCockroachView(t)) {
+			views.push(t);
+		}
+
+		if (isCockroachMaterializedView(t)) {
+			matViews.push(t);
+		}
+
+		if (isCockroachSequence(t)) {
+			sequences.push(t);
+		}
+
+		if (is(t, CockroachRole)) {
+			roles.push(t);
+		}
+
+		if (is(t, CockroachPolicy)) {
+			policies.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return {
+		tables,
+		enums,
+		schemas,
+		sequences,
+		views,
+		matViews,
+		roles,
+		policies,
+		relations,
+	};
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnyCockroachTable[] = [];
+	const enums: CockroachEnum<any>[] = [];
+	const schemas: CockroachSchema[] = [];
+	const sequences: CockroachSequence[] = [];
+	const views: CockroachView[] = [];
+	const roles: CockroachRole[] = [];
+	const policies: CockroachPolicy[] = [];
+	const matViews: CockroachMaterializedView[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = fromExports(i0);
+
+		tables.push(...prepared.tables);
+		enums.push(...prepared.enums);
+		schemas.push(...prepared.schemas);
+		sequences.push(...prepared.sequences);
+		views.push(...prepared.views);
+		matViews.push(...prepared.matViews);
+		roles.push(...prepared.roles);
+		policies.push(...prepared.policies);
+		relations.push(...prepared.relations);
+	}
+
+	return {
+		tables,
+		enums,
+		schemas,
+		sequences,
+		views,
+		matViews,
+		roles,
+		policies,
+		relations,
+	};
+};
diff --git a/drizzle-kit/src/dialects/cockroach/grammar.ts b/drizzle-kit/src/dialects/cockroach/grammar.ts
new file mode 100644
index 0000000000..30b2f9feb7
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/grammar.ts
@@ -0,0 +1,1821 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type { possibleIntervals } from '../../utils';
+import {
+	dateExtractRegex,
+	hasTimeZoneSuffix,
+	parseEWKB,
+	parseIntervalFields,
+	stringifyArray,
+	stringifyTuplesArray,
+	timeTzRegex,
+	timezoneSuffixRegexp,
+	trimChar,
+	wrapWith,
+} from '../../utils';
+import { parseArray } from '../../utils/parse-pgarray';
+import { parse, stringify } from '../../utils/when-json-met-bigint';
+import { hash } from '../common';
+import { numberForTs, parseParams } from '../utils';
+import type { CockroachEntities, Column, DiffEntities } from './ddl';
+import type { Import } from './typescript';
+
+export const splitSqlType = (sqlType: string) => {
+	const toMatch = sqlType.replaceAll('[]', '');
+	const match = toMatch.match(/^(\w+(?:\s+\w+)*)\(([^)]*)\)?$/i);
+	let type = match ? match[1] : toMatch;
+	let options = match ? match[2].replaceAll(', ', ',') : null;
+
+	return { type, options };
+};
+
+export const vectorOps = [
+	'vector_l2_ops',
+	'vector_ip_ops',
+	'vector_cosine_ops',
+	'vector_l1_ops',
+	'bit_hamming_ops',
+	'bit_jaccard_ops',
+	'halfvec_l2_ops',
+	'sparsevec_l2_ops',
+];
+
+export const indexName = (tableName: string, columns: string[]) => {
+	return `${tableName}_${columns.join('_')}_index`;
+};
+
+export function stringFromIdentityProperty(field: string | number | undefined): string | undefined {
+	return typeof field === 'string' ? (field as string) : typeof field === 'undefined' ? undefined : String(field);
+}
+
+export function maxRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'int4' ? '2147483647' : columnType === 'int8' ? '9223372036854775807' : '32767';
+}
+
+export function minRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'int4' ? '-2147483648' : columnType === 'int8' ? '-9223372036854775808' : '-32768';
+}
+
+export function stringFromDatabaseIdentityProperty(field: any): string | null {
+	return typeof field === 'string'
+		? (field as string)
+		: typeof field === 'undefined' || field === null
+		? null
+		: typeof field === 'bigint'
+		? field.toString()
+		: String(field);
+}
+
+export type OnAction = CockroachEntities['fks']['onUpdate'];
+export const parseOnType = (type: string): OnAction => {
+	switch (type) {
+		case 'a':
+			return 'NO ACTION';
+		case 'r':
+			return 'RESTRICT';
+		case 'n':
+			return 'SET NULL';
+		case 'c':
+			return 'CASCADE';
+		case 'd':
+			return 'SET DEFAULT';
+		default:
+			throw new Error(`Unknown foreign key type: ${type}`);
+	}
+};
+
+export const systemNamespaceNames = ['crdb_internal', 'information_schema', 'pg_catalog', 'pg_extension'];
+export const isSystemNamespace = (name: string) => {
+	return systemNamespaceNames.indexOf(name) >= 0;
+};
+
+export const systemRoles = ['admin', 'root', 'node'];
+export const isSystemRole = (name: string) => {
+	return systemRoles.indexOf(name) >= 0;
+};
+
+/*
+	CHECK (((email)::text <> 'test@gmail.com'::text))
+	Where (email) is column in table
+*/
+export const parseCheckDefinition = (value: string): string => {
+	return value.replace(/^CHECK\s*\(\(/, '').replace(/\)\)\s*$/, '');
+};
+
+export const parseViewDefinition = (value: string | null | undefined): string | null => {
+	if (!value) return null;
+	return value.replace(/\s+/g, ' ').replace(';', '').trim();
+};
+
+export const defaultNameForIdentitySequence = (table: string, column: string) => {
+	return `${table}_${column}_seq`;
+};
+
+export const defaultNameForPK = (table: string) => {
+	return `${table}_pkey`;
+};
+
+export const defaultNameForFK = (table: string, columns: string[], tableTo: string, columnsTo: string[]) => {
+	const desired = `${table}_${columns.join('_')}_${tableTo}_${columnsTo.join('_')}_fkey`;
+	const res = desired.length > 63
+		? table.length < 63 - 18 // _{hash(12)}_fkey
+			? `${table}_${hash(desired)}_fkey`
+			: `${hash(desired)}_fkey` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const defaultNameForUnique = (table: string, ...columns: string[]) => {
+	return `${table}_${columns.join('_')}_key`;
+};
+
+export const defaultNameForIndex = (table: string, columns: string[]) => {
+	return `${table}_${columns.join('_')}_idx`;
+};
+
+// ::text, ::varchar(256), ::text::varchar(256)
+export function trimDefaultValueSuffix(defaultValue: string) {
+	let res = defaultValue.endsWith('[]') ? defaultValue.slice(0, -2) : defaultValue;
+	res = res.replace(/(::[a-zA-Z_][\w\s.]*?(?:\([^()]*\))?(?:\[\])?)+$/g, '');
+	return res;
+}
+
+export const defaultForColumn = (
+	type: string,
+	def: string | boolean | number | null | undefined,
+	dimensions: number,
+	isEnum: boolean,
+): Column['default'] => {
+	if (def === null || def === undefined) {
+		return null;
+	}
+
+	// trim ::type and []
+	let value = trimDefaultValueSuffix(String(def));
+
+	const grammarType = typeFor(type, isEnum);
+	if (grammarType) {
+		if (dimensions > 0) return grammarType.defaultArrayFromIntrospect(value);
+		return grammarType.defaultFromIntrospect(String(value));
+	}
+
+	throw Error();
+};
+
+export const defaultToSQL = (it: Pick<Column, 'default' | 'dimensions' | 'type' | 'typeSchema'>) => {
+	if (!it.default) return '';
+
+	const { type: columnType, dimensions, typeSchema } = it;
+	const value = it.default;
+
+	if (typeSchema) {
+		const schemaPrefix = typeSchema && typeSchema !== 'public' ? `"${typeSchema}".` : '';
+		return `${value}::${schemaPrefix}"${columnType}"${dimensions > 0 ? '[]' : ''}`;
+	}
+
+	//   const { type: rawType } = splitSqlType(columnType);
+	const suffix = dimensions > 0 ? `::${columnType}[]` : '';
+
+	const grammarType = typeFor(columnType, Boolean(typeSchema));
+
+	if (grammarType) {
+		const value = it.default ?? '';
+		return `${value}${suffix}`;
+	}
+
+	throw Error();
+
+	// assertUnreachable(defaultType);
+};
+
+const dateTimeRegex =
+	/^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?|\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?)$/;
+const dateRegex =
+	/^(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?)?|\d{4}-\d{2}-\d{2})$/;
+// TODO write descriptions for all functions
+// why that was made, etc.
+
+export function formatTimestamp(date: string, modify: boolean, precision?: number) {
+	if (!dateTimeRegex.test(date)) return date;
+
+	// Convert to Temporal.Instant
+	const instant = hasTimeZoneSuffix(date) ? Temporal.Instant.from(date) : Temporal.Instant.from(date + 'Z');
+
+	const iso = instant.toString();
+
+	const fractionalDigits = iso.replace('Z', '').split('.')[1]?.length ?? 0;
+
+	if (!precision && fractionalDigits > 6) precision = 6;
+
+	if (!precision) return iso;
+
+	// decide whether to limit precision
+	const formattedPrecision = fractionalDigits > precision
+		// @ts-expect-error
+		? instant.toString({ fractionalSecondDigits: precision })
+		: iso;
+
+	return modify ? formattedPrecision : iso;
+}
+export function formatTime(date: string, modify: boolean, precision: number = 0) {
+	const match = date.match(timeTzRegex);
+	if (!match) return date;
+	const time: string = match[0];
+
+	const timestampInstant = hasTimeZoneSuffix(time)
+		? Temporal.Instant.from(`1970-01-01T${time}`)
+		: Temporal.Instant.from(`1970-01-01T${time}` + 'Z');
+	const iso = timestampInstant.toString();
+
+	// 2024-05-23T14:20:33.123Z
+	const fractionalDigits = iso.replace('Z', '').split('.')[1]?.length ?? 0;
+
+	if (!precision && fractionalDigits > 6) precision = 6;
+
+	if (!precision) return iso;
+	// decide whether to limit precision
+	const formattedPrecision = fractionalDigits > precision
+		// @ts-expect-error
+		? timestampInstant.toString({ fractionalSecondDigits: precision })
+		: iso;
+
+	return modify ? formattedPrecision : iso;
+}
+export function formatDate(date: string) {
+	if (!dateRegex.test(date)) return date; // invalid format
+	const match = date.match(dateExtractRegex);
+	if (!match) return date;
+
+	const extractedDate: string = match[0];
+
+	return extractedDate;
+}
+// CockroachDb trims and pads defaults under the hood
+export function formatDecimal(type: string, value: string) {
+	const { options } = splitSqlType(type);
+	const [integerPart, dp] = value.split('.');
+	const decimalPart = dp ?? '';
+
+	let scale: number | undefined;
+
+	// if precision exists and scale not -> scale = 0
+	// if scale exists -> scale = scale
+	// if options does not exists (p,s are not present) -> scale is undefined
+	if (options) {
+		// if option exists we have 2 possible variants
+		// 1. p exists
+		// 2. p and s exists
+		const [_, s] = options.split(',');
+
+		// if scale exists - use scale
+		// else use 0 (cause p exists)
+		scale = s !== undefined ? Number(s) : 0;
+	}
+
+	if (typeof scale === 'undefined') return value;
+	if (scale === 0) return integerPart;
+	if (scale === decimalPart.length) return value;
+
+	const fixedDecimal = scale > decimalPart.length ? decimalPart.padEnd(scale, '0') : decimalPart.slice(0, scale);
+
+	return `${integerPart}.${fixedDecimal}`;
+}
+export function formatBit(type: string, value?: string | null, trimToOneLength: boolean = false) {
+	if (!value) return value;
+
+	const { options } = splitSqlType(type);
+
+	const length = !options ? (trimToOneLength ? 1 : Number(options)) : Number(options);
+	if (value.length > length) return value.substring(0, length);
+	return value.padEnd(length, '0');
+}
+export function formatString(type: string, value: string, mode: 'default' | 'arr' = 'default') {
+	if (!value) return value;
+
+	const { options } = splitSqlType(type);
+
+	if (!options && mode === 'default') {
+		return value;
+	}
+
+	const length = !options ? 1 : Number(options);
+
+	if (value.length <= length) return value;
+	value = value.substring(0, length);
+
+	return value;
+}
+
+export const escapeForSqlDefault = (input: string, mode: 'default' | 'arr' | 'enum-arr' = 'default') => {
+	let value = input.replace(/\\/g, '\\\\');
+	if (mode === 'arr') value = value.replace(/'/g, "''").replaceAll('"', '\\"');
+	else if (mode === ('enum-arr')) value = value.replace(/'/g, "''").replaceAll('"', '\\"').replace(',', '\\,');
+	else value = value.replace(/'/g, "\\'");
+
+	return value;
+};
+// export const escapeJsonbForSqlDefault = (input: string) => {
+// 	let value = input.replace(/\\/g, '\\\\');
+// 	if (mode === 'arr') value = value.replace(/'/g, "''").replaceAll('"', '\\"');
+// 	else value = value.replace(/'/g, "\\'");
+
+// 	return value;
+// };
+
+export const unescapeFromSqlDefault = (input: string) => {
+	// starts with e' and ends with '
+	input = /^e'.*'$/s.test(input) ? input.replace(/e'/g, "'") : input;
+
+	input = trimChar(input, "'");
+
+	let res = input.replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, '\\');
+
+	// if (mode === 'arr') return res;
+	return res;
+};
+
+export const escapeForTsLiteral = (input: string) => {
+	return input.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+};
+
+export const isDefaultAction = (action: string) => {
+	return action.toLowerCase() === 'no action';
+};
+
+export const defaults = {
+	identity: {
+		startWith: '1',
+		increment: '1',
+		min: '1',
+		maxFor: (type: string) => {
+			if (type === 'int2') return '32767';
+			if (type === 'int4') return '2147483647';
+			if (type === 'int8') return '9223372036854775807';
+			throw new Error(`Unknow identity column type: ${type}`);
+		},
+		cache: 1,
+	},
+	index: {
+		method: 'btree',
+	},
+} as const;
+
+// from -> db
+// to -> code
+// TODO write description
+export const defaultsCommutative = (
+	diffDef: DiffEntities['columns']['default'],
+	type: string,
+	dimensions: number,
+	isEnum: boolean,
+): boolean => {
+	if (!diffDef) return false;
+
+	if (diffDef.from === diffDef.to) return true;
+
+	let from = diffDef.from;
+	let to = diffDef.to;
+
+	if (from === to) return true;
+
+	const commutativeTypes = [
+		['current_timestamp', 'now', 'now()', 'current_timestamp()'],
+	];
+	for (const it of commutativeTypes) {
+		const leftIn = it.some((x) => x === from);
+		const rightIn = it.some((x) => x === to);
+
+		if (leftIn && rightIn) return true;
+	}
+
+	if (dimensions > 0 && from && to) {
+		from = trimChar(from, "'");
+		to = trimChar(to, "'");
+	}
+
+	if (isEnum && dimensions > 0 && from && to) {
+		try {
+			to = stringifyArray(parseArray(to), 'ts', (v) => `"${v}"`);
+			from = stringifyArray(parseArray(from), 'ts', (v) => {
+				v = unescapeFromSqlDefault(v);
+
+				return `"${v}"`;
+			});
+
+			if (to === from) return true;
+		} catch {}
+		return false;
+	}
+
+	if ((type.startsWith('bit') || type.startsWith('varbit')) && from && to) {
+		if (
+			formatBit(type, diffDef.from, true) === formatBit(type, diffDef?.to, true)
+		) {
+			return true;
+		}
+
+		try {
+			const stringify = (v: any) => {
+				return `${formatBit(type, v, true)}`;
+			};
+			const toArray = stringifyArray(parseArray(to), 'sql', stringify);
+			if (from === toArray) return true;
+		} catch {}
+
+		return false;
+	}
+
+	// only if array
+	if (type.startsWith('decimal') && dimensions > 0 && from && to) {
+		try {
+			const stringify = (v: any) => {
+				return `${formatDecimal(type, v)}`;
+			};
+			const toArray = stringifyArray(parseArray(to), 'sql', stringify);
+			if (from === toArray) return true;
+		} catch {}
+		return false;
+	}
+
+	if (type.startsWith('timestamp')) {
+		// "Z" can be inserted in mode:string
+		from = from?.replace('Z', '+00') ?? null;
+		to = to?.replace('Z', '+00') ?? null;
+		if (from === to) return true;
+
+		const { options } = splitSqlType(type);
+		const precision = options ? Number(options) : undefined; // def precision
+
+		if (from && to) {
+			from = trimChar(from, "'");
+			to = trimChar(to, "'");
+
+			if (dimensions > 0) {
+				try {
+					const stringify = (v: any, modify: boolean) => {
+						v = trimChar(v, '"');
+						if (!type.includes('tz')) v = v.replace(timezoneSuffixRegexp, '');
+
+						const formatted = formatTimestamp(v, modify, precision);
+						return `"${type.includes('tz') ? formatted : formatted.replace(timezoneSuffixRegexp, '')}"`;
+					};
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => stringify(v, true));
+
+					const fromArrayOriginal = stringifyArray(parseArray(from), 'sql', (v) => stringify(v, false));
+
+					if (fromArrayOriginal === toArray) return true;
+				} catch {
+				}
+
+				return false;
+			}
+
+			const trimTz = (value: string, type: string) => {
+				return type.includes('tz') ? value : value.replace(timezoneSuffixRegexp, '');
+			};
+
+			from = trimTz(from, type);
+			to = trimTz(to, type);
+			const formattedTo = trimTz(formatTimestamp(to, true, precision), type);
+			const formattedFromOriginal = trimTz(formatTimestamp(from, false, precision), type);
+			if (formattedFromOriginal === formattedTo) return true;
+		}
+
+		return false;
+	}
+
+	if (type.startsWith('time')) {
+		from = from?.replace('Z', '+00') ?? null;
+		to = to?.replace('Z', '+00') ?? null;
+
+		if (from === to) return true;
+
+		const { options } = splitSqlType(type);
+		const precision = options ? Number(options) : undefined; // def precision
+
+		if (from && to) {
+			from = trimChar(from, "'");
+			to = trimChar(to, "'");
+
+			if (dimensions > 0) {
+				try {
+					const stringify = (v: any, modify: boolean) => {
+						if (!type.includes('tz')) v = v.replace(timezoneSuffixRegexp, '');
+
+						const formatted = formatTime(v, modify, precision);
+						return `"${type.includes('tz') ? formatted : formatted.replace(timezoneSuffixRegexp, '')}"`;
+					};
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => stringify(v, true));
+
+					const fromArrayOriginal = stringifyArray(parseArray(from), 'sql', (v) => stringify(v, false));
+
+					if (fromArrayOriginal === toArray) return true;
+				} catch {}
+
+				return false;
+			}
+
+			const trimTz = (value: string, type: string) => {
+				return type.includes('tz') ? value : value.replace(timezoneSuffixRegexp, '');
+			};
+
+			from = trimTz(from, type);
+			to = trimTz(to, type);
+
+			const formattedTo = trimTz(formatTime(to, true, precision), type);
+			const formattedFromOriginal = trimTz(formatTime(from, false, precision), type);
+			if (formattedFromOriginal === formattedTo) return true;
+		}
+
+		return false;
+	}
+
+	if (type.startsWith('date')) {
+		if (from && to) {
+			from = trimChar(from, "'");
+			to = trimChar(to, "'");
+
+			if (dimensions > 0) {
+				try {
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => formatDate(v));
+					if (from === toArray) return true;
+				} catch {}
+
+				return false;
+			}
+
+			if (from === formatDate(to)) return true;
+		}
+
+		return false;
+	}
+
+	if (type.startsWith('char') || type.startsWith('varchar') || type.startsWith('text') || type.startsWith('string')) {
+		if (from && to) {
+			if (dimensions > 0) {
+				try {
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => formatString(type, v, 'arr'));
+
+					// parse to identical format
+					const fromArrayOriginal = stringifyArray(parseArray(from), 'sql', (v) => String(v));
+					if (fromArrayOriginal === toArray) return true;
+				} catch {}
+
+				return false;
+			}
+		}
+		return false;
+	}
+
+	// const timeCommutatives = [['now', 'now()', 'current_timestamp', 'current_timestamp()']];
+	// if (type.startsWith('timestamp')) {
+	// 	for (const it of timeCommutatives) {
+	// 		const leftIn = it.some((x) => x === diffDef.from);
+	// 		const rightIn = it.some((x) => x === diffDef.to);
+
+	// 		if (leftIn && rightIn) return true;
+	// 	}
+	// }
+
+	if (type.startsWith('vector')) {
+		if (from?.replaceAll('.0', '') === to) return true;
+		if (to?.replaceAll('.0', '') === from) return true;
+	}
+
+	// real and float adds .0 to the end for the numbers
+	// 100 === 100.0
+	const dataTypesWithExtraZero = ['real', 'float'];
+	if (
+		dataTypesWithExtraZero.find((dataType) => type.startsWith(dataType))
+		&& (from?.replace('.0', '') === to || to === from?.replace('.0', ''))
+	) {
+		return true;
+	}
+
+	if (type === 'jsonb' && from && to) {
+		const left = stringify(parse(trimChar(from, "'")));
+		const right = stringify(parse(trimChar(to, "'")));
+		if (left === right) return true;
+	}
+
+	return false;
+};
+
+const commutativeTypes = [['char(1)', 'char']];
+export const typesCommutative = (left: string, right: string) => {
+	for (const it of commutativeTypes) {
+		const leftIn = it.some((x) => x === left);
+		const rightIn = it.some((x) => x === right);
+
+		if (leftIn && rightIn) return true;
+	}
+};
+
+export interface SqlType {
+	is(type: string): boolean;
+	drizzleImport(): Import;
+	defaultFromDrizzle(value: unknown, mode?: string, config?: unknown): Column['default'];
+	defaultArrayFromDrizzle(value: any[], mode?: string, config?: unknown): Column['default'];
+	defaultFromIntrospect(value: string): Column['default'];
+	defaultArrayFromIntrospect(value: string): Column['default']; // todo: remove?
+	toTs(type: string, value: string | null): { options?: Record<string, unknown>; default: string; customType?: string };
+	toArrayTs(
+		type: string,
+		value: string | null,
+	): { options?: Record<string, unknown>; default: string; customType?: string };
+}
+
+export const Int2: SqlType = {
+	is: (type: string) => /^\s*int2(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'int2',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value; // 10, but '-10'
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `${v}`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Int4: SqlType = {
+	is: (type: string) => /^\s*int4(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'int4',
+	defaultFromDrizzle: Int2.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Int2.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Int2.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Int2.defaultArrayFromIntrospect,
+	toTs: Int2.toTs,
+	toArrayTs: Int2.toArrayTs,
+};
+
+export const Int8: SqlType = {
+	is: (type: string) => /^\s*int8(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'int8',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value; // 10, but '-10'
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (_, value) => {
+		if (!value) return { options: { mode: 'number' }, default: '' };
+		const { mode, value: def } = numberForTs(value);
+		return { options: { mode }, default: def };
+	},
+	toArrayTs: (_, value) => {
+		if (!value) return { options: { mode: 'number' }, default: '' };
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+			return {
+				options: { mode: 'bigint' },
+				default: stringifyArray(res, 'ts', (v) => `${v}n`),
+			};
+		} catch {
+			return { options: { mode: 'bigint' }, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Bool: SqlType = {
+	is: (type: string) => /^\s*bool(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'bool',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return trimChar(value, "'");
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return v === 'true' ? 'true' : 'false';
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Uuid: SqlType = {
+	is: (type: string) => /^\s*uuid(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'uuid',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		value = trimChar(value, "'");
+		if (value === 'gen_random_uuid()') {
+			return { options, default: '.defaultRandom()' };
+		}
+		return { options, default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Real: SqlType = {
+	is: (type: string) => /^\s*real(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'real',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		// 100 will be stored as 100.0
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `${v}`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Float: SqlType = {
+	is: (type: string) => /^\s*float(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'float',
+	defaultFromDrizzle: Real.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Real.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Real.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Real.defaultArrayFromIntrospect,
+	toTs: Real.toTs,
+	toArrayTs: Real.toArrayTs,
+};
+
+export const Decimal: SqlType = {
+	// decimal OR decimal(1)[] OR decimal(2,1)[]
+	is: (type: string) => /^\s*decimal(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'decimal',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const [precision, scale] = parseParams(type);
+		const options = {} as any;
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+
+		const { mode, value: def } = numberForTs(value);
+
+		if (mode === 'number') return { options, default: `"${def}"` };
+
+		return { default: def, options: { mode, ...options } };
+	},
+	toArrayTs: (type, value) => {
+		const [precision, scale] = parseParams(type);
+		const options = {} as any;
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+		/*
+			If we'd want it to be smart - we need to check if decimal array has
+			any bigints recuresively, it's waaaaay easier to just do sql``
+		 */
+		// try {
+		// 	const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+		// 	const res = parseArray(trimmed);
+
+		// 	return {
+		// 		options: { mode: 'bigint', ...options },
+		// 		default: stringifyArray(res, 'ts', (v) => {
+
+		// 			return `${v}`;
+		// 		}),
+		// 	};
+		// } catch {
+		return { options, default: `sql\`${value}\`` };
+		// }
+	},
+};
+
+export const Bit: SqlType = {
+	is: (type: string) => /^\s*bit(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'bit',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		// it is stored as B'<value>'
+		return value.replace(/^B'/, "'");
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const [length] = parseParams(type);
+		const options = length ? { length: Number(length) } : {};
+
+		if (!value) return { options, default: '' };
+
+		if (/^'[01]+'$/.test(value)) {
+			return { options, default: value };
+		}
+
+		return { options, default: `sql\`${value}\`` };
+	},
+	toArrayTs: (type, value) => {
+		const [length] = parseParams(type);
+		const options = length ? { length: Number(length) } : {};
+
+		if (!value) return { options, default: '' };
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (!/^[01]+$/.test(v)) isDrizzleSql = true;
+				return `"${v}"`;
+			});
+
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const VarBit: SqlType = {
+	is: (type: string) => /^\s*varbit(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'varbit',
+	defaultFromDrizzle: Bit.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Bit.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Bit.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Bit.defaultArrayFromIntrospect,
+	toTs: Bit.toTs,
+	toArrayTs: Bit.toArrayTs,
+};
+
+export const Timestamp: SqlType = {
+	is: (type) => /^\s*timestamp(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'timestamp',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `'${value.toISOString().replace('T', ' ').replace('Z', '')}'`;
+		}
+
+		return `'${String(value)}'`;
+	},
+	defaultArrayFromDrizzle(value) {
+		return `'${
+			stringifyArray(value, 'sql', (v) => {
+				if (v instanceof Date) {
+					return `"${v.toISOString().replace('T', ' ').replace('Z', '')}"`;
+				}
+
+				return `"${String(v)}"`;
+			})
+		}'`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: { mode: string; precision?: number } = { mode: 'string' };
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		if (value === 'now()' || value === 'current_timestamp()') {
+			return { default: '.defaultNow()', options };
+		}
+
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+	toArrayTs: (type, value) => {
+		const options: { mode: string; precision?: number } = { mode: 'string' };
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => `"${v}"`),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const TimestampTZ: SqlType = {
+	is: (type) => /^\s*timestamptz(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'timestamp',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `'${value.toISOString().replace('T', ' ').replace('Z', '+00')}'`;
+		}
+
+		return `'${String(value)}'`;
+	},
+	defaultArrayFromDrizzle(value) {
+		return `'${
+			stringifyArray(value, 'sql', (v) => {
+				if (v instanceof Date) {
+					return `"${v.toISOString().replace('T', ' ').replace('Z', '+00')}"`;
+				}
+
+				return `"${String(v)}"`;
+			})
+		}'`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: { mode: string; withTimezone: boolean; precision?: number } = { mode: 'string', withTimezone: true };
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		if (value === 'now()' || value === 'current_timestamp()') {
+			return { default: '.defaultNow()', options };
+		}
+
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+	toArrayTs: (type, value) => {
+		const options: { mode: string; withTimezone: boolean; precision?: number } = { withTimezone: true, mode: 'string' };
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => `"${v}"`),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Time: SqlType = {
+	is: (type) => /^\s*time(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: (value: unknown) => {
+		return `'${String(value)}'`;
+	},
+	defaultArrayFromDrizzle(value) {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: { precision?: number } = {};
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		if (value === 'now()' || value === 'current_timestamp()') {
+			return { default: '.defaultNow()', options };
+		}
+
+		// check for valid date
+		try {
+			Temporal.PlainTime.from(value.substring(1, value.length - 1));
+			return { default: value, options };
+		} catch {
+			return { default: `sql\`${value}\``, options };
+		}
+	},
+	toArrayTs: (type, value) => {
+		const options: { precision?: number } = {};
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => `"${v}"`),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const TimeTz: SqlType = {
+	is: (type) => /^\s*timetz(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: Time.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Time.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Time.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Time.defaultArrayFromIntrospect,
+	toTs: (type, value) => {
+		const options: { withTimezone: boolean; precision?: number } = {
+			withTimezone: true,
+		};
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		if (value === 'now()' || value === 'current_timestamp()') {
+			return { default: '.defaultNow()', options };
+		}
+
+		// check for valid date
+		try {
+			Temporal.PlainTime.from(value.substring(1, value.length - 1));
+			return { default: value, options };
+		} catch {
+			return { default: `sql\`${value}\``, options };
+		}
+	},
+	toArrayTs: (type, value) => {
+		const options: { withTimezone: boolean; precision?: number } = {
+			withTimezone: true,
+		};
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => `"${v}"`),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const DateType: SqlType = {
+	is: (type) => /^\s*date(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'date',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `'${value.toISOString().split('T')[0]}'`;
+		}
+
+		return `'${String(value)}'`;
+	},
+	defaultArrayFromDrizzle(value) {
+		return `'${
+			stringifyArray(value, 'sql', (v) => {
+				if (v instanceof Date) {
+					return v.toISOString().split('T')[0];
+				}
+
+				return String(v);
+			})
+		}'`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (_, value) => {
+		const options: { mode: string } = { mode: 'string' };
+
+		if (!value) return { default: '', options };
+
+		if (value === 'now()' || value === 'current_timestamp()') {
+			return { default: '.defaultNow()', options };
+		}
+
+		// check for valid date
+		try {
+			Temporal.PlainDate.from(value.substring(1, value.length - 1));
+			return { default: value, options };
+		} catch {
+			return { default: `sql\`${value}\``, options };
+		}
+	},
+	toArrayTs: (type, value) => {
+		const options: { mode: string; precision?: number } = { mode: 'string' };
+
+		const [precision] = parseParams(type);
+		if (precision) options.precision = Number(precision);
+
+		if (!value) return { default: '', options };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => `"${v}"`),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Char: SqlType = {
+	is: (type: string) => /^\s*char|character(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'char',
+	defaultFromDrizzle: (value) => {
+		const escaped = escapeForSqlDefault(String(value));
+		const result = String(value).includes('\\') || String(value).includes("'")
+			? `e'${escaped}'`
+			: `'${escaped}'`;
+
+		return result;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			const escaped = escapeForSqlDefault(v, 'arr');
+			if (v.includes('\\') || v.includes('"') || v.includes(',')) {
+				return `"${escaped}"`;
+			}
+
+			return escaped;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+		const escaped = escapeForTsLiteral(unescapeFromSqlDefault(value));
+		return { options, default: `"${escaped}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(unescapeFromSqlDefault(v));
+					return `"${escaped}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const Varchar: SqlType = {
+	is: (type: string) => /^\s*varchar|character varying(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'varchar',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Char.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Char.defaultArrayFromIntrospect,
+	toTs: Char.toTs,
+	toArrayTs: Char.toArrayTs,
+};
+// export const Text: SqlType = {
+// 	is: (type: string) => /^\s*(?:text)(?:[\s(].*)*\s*$/i.test(type),
+// 	drizzleImport: () => 'text',
+// 	defaultFromDrizzle: Char.defaultFromDrizzle,
+// 	defaultArrayFromDrizzle: Char.defaultArrayFromDrizzle,
+// 	defaultFromIntrospect: Char.defaultFromIntrospect,
+// 	defaultArrayFromIntrospect: Char.defaultArrayFromIntrospect,
+// 	toTs: Char.toTs,
+// 	toArrayTs: Char.toArrayTs,
+// };
+export const StringType: SqlType = {
+	is: (type: string) => /^\s*string(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'string',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Char.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Char.defaultArrayFromIntrospect,
+	toTs: Char.toTs,
+	toArrayTs: Char.toArrayTs,
+};
+
+export const Jsonb: SqlType = {
+	is: (type: string) => /^\s*jsonb\s*$/i.test(type),
+	drizzleImport: () => 'jsonb',
+	defaultFromDrizzle: (value) => {
+		let shouldEscape = false;
+		const stringified = stringify(
+			value,
+			(_, value) => {
+				if (typeof value !== 'string') return value;
+				if (value.includes("'") || value.includes('"') || value.includes('\\')) shouldEscape = true;
+				return value;
+			},
+			undefined,
+			undefined,
+		);
+		return shouldEscape
+			? `e'${stringified.replaceAll("'", "\\'").replaceAll('\\"', '\\\\"')}'`
+			: `'${stringified}'`;
+	},
+	// not supported
+	defaultArrayFromDrizzle: () => {
+		return `'[]'`;
+	},
+	/*
+		TODO: make less hacky,
+		from: { type: 'unknown', value: `'{"key": "value"}'` },
+		to:   { type: 'unknown', value: `'{"key":"value"}'` }
+	 */
+	defaultFromIntrospect: (value) => value.replaceAll(`": "`, `":"`),
+	// not supported
+	defaultArrayFromIntrospect: () => {
+		return `'[]'`;
+	},
+	toTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		const trimmed = trimChar(unescapeFromSqlDefault(value), "'");
+
+		try {
+			const parsed = parse(trimmed);
+			const stringified = stringify(
+				parsed,
+				(_, value) => {
+					return value;
+				},
+				undefined,
+				true,
+			)!;
+			return { default: stringified };
+		} catch {
+			/*(e: any)*/
+			// console.log('error: ', e);
+		}
+		return { default: `sql\`${value}\`` };
+	},
+	// not supported
+	toArrayTs: () => {
+		return {
+			default: '',
+			options: {},
+		};
+	},
+};
+
+// This is not handled the way cockroach stores it
+// since user can pass `1 2:3:4` and it will be stored as `1 day 02:03:04`
+// so we just compare row values
+export const Interval: SqlType = {
+	is: (type: string) =>
+		/^interval(\s+(year|month|day|hour|minute|second)(\s+to\s+(month|day|hour|minute|second))?)?(?:\((\d+)\))?(\[\])?$/i
+			.test(type),
+	drizzleImport: () => 'interval',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return `"${v}"`;
+		});
+
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: {
+			precision?: number;
+			fields?: (typeof possibleIntervals)[number];
+		} = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		const fields = parseIntervalFields(type);
+		if (fields.fields) options['fields'] = fields.fields;
+
+		if (!value) return { options, default: '' };
+
+		return { options, default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		const fields = parseIntervalFields(type);
+		if (fields.fields) options['fields'] = fields.fields;
+
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Vector: SqlType = {
+	is: (type: string) => /^\s*vector(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'vector',
+	defaultFromDrizzle: (value) => {
+		return `'[${String(value).replaceAll(' ', '')}]'`;
+	},
+	// not supported
+	defaultArrayFromDrizzle: () => {
+		return '';
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	// not supported
+	defaultArrayFromIntrospect: () => {
+		return '';
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [dimensions] = parseParams(type);
+		if (dimensions) options['dimensions'] = Number(dimensions);
+
+		if (!value) return { options, default: '' };
+
+		return { options, default: trimChar(value, "'") };
+	},
+	// not supported
+	toArrayTs: () => {
+		return { default: '', options: {} };
+	},
+};
+
+// Enums in cockroach are stored in strange way
+// '{text\\text}' is parsed to '{"e''text\\\\text''"}'
+// BUT if try to create table with default '{"e''text\\\\text''"}' query will fail
+// so create in simplest way and check in diff
+export const Enum: SqlType = {
+	is: (_type: string) => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'cockroachEnum',
+	defaultFromDrizzle: (value: string) => {
+		if (!value) return '';
+
+		if (value.includes("'") || value.includes('\\')) {
+			return `e'${escapeForSqlDefault(value, 'default')}'`;
+		}
+		return `'${value}'`;
+	},
+
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(
+			value,
+			'sql',
+			(v) => {
+				if (typeof v !== 'string') throw new Error();
+				const escaped = escapeForSqlDefault(v, 'enum-arr');
+
+				if (v.includes("'") || v.includes(',') || v.includes('\\') || v.includes('"')) return `"${escaped}"`;
+				return escaped;
+			},
+		);
+
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+
+		const escaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(value, "'")));
+		return { options, default: `"${escaped}"` };
+	},
+	toArrayTs: (type, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(unescapeFromSqlDefault(v));
+
+					return `"${escaped}"`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Custom: SqlType = {
+	is: (_type: string) => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'customType',
+	defaultFromDrizzle: (value) => {
+		if (!value) return '';
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '', customType: type };
+		const escaped = escapeForTsLiteral(value);
+		return { default: `"${escaped}"`, customType: type };
+	},
+	toArrayTs: (type, value) => {
+		if (!value) return { default: '', customType: type };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(v);
+					return `"${escaped}"`;
+				}),
+				customType: type,
+			};
+		} catch {
+			return { default: `sql\`${value}\``, customType: type };
+		}
+	},
+};
+
+export const GeometryPoint: SqlType = {
+	is: (type: string) => /^\s*geometry\(point(?:,\d+)?\)(?:\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'geometry',
+	defaultFromDrizzle: (value, mode, config) => {
+		if (!value) return '';
+
+		const srid: number | undefined = config ? Number(config) : undefined;
+		let sridPrefix = srid ? `SRID=${srid};` : '';
+		if (mode === 'tuple') {
+			const v: number[] = value as number[];
+			return v.length > 0 ? `'${sridPrefix}POINT(${v[0]} ${v[1]})'` : '';
+		}
+
+		if (mode === 'object') {
+			const v: { x: number; y: number } = value as { x: number; y: number };
+			return Object.values(v).length > 0
+				? `'${sridPrefix}POINT(${v.x} ${v.y})'`
+				: '';
+		}
+
+		throw new Error('unknown geometry type');
+	},
+	defaultArrayFromDrizzle: function(value: any[], mode: string, config: unknown): Column['default'] {
+		let res: string;
+		const srid: number | undefined = config ? Number(config) : undefined;
+		let sridPrefix = srid ? `SRID=${srid};` : '';
+
+		if (mode === 'tuple') {
+			res = stringifyTuplesArray(value, 'sql', (x: number[]) => {
+				const res = `${sridPrefix}POINT(${x[0]} ${x[1]})`;
+				return res;
+			});
+		} else if (mode === 'object') {
+			res = stringifyArray(value, 'sql', (x: { x: number; y: number }, _depth: number) => {
+				const res = `${sridPrefix}POINT(${x.x} ${x.y})`;
+				return res;
+			});
+		} else throw new Error('unknown geometry type');
+
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		try {
+			const { point, srid } = parseEWKB(trimChar(value, "'"));
+			value = `'${(srid ? `SRID=${srid};` : ``) + `POINT(${point[0]} ${point[1]})`}'`;
+		} catch {}
+
+		return value;
+	},
+	defaultArrayFromIntrospect: function(value: string): Column['default'] {
+		try {
+			const parsedArray = parseArray(trimChar(value, "'"));
+
+			value = stringifyArray(parsedArray, 'sql', (v) => {
+				const { srid, point } = parseEWKB(v);
+				return (srid ? `SRID=${srid};` : ``) + `POINT(${point[0]} ${point[1]})`;
+			});
+
+			value = wrapWith(value, "'");
+		} catch {}
+
+		return value;
+	},
+	toTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		const options: { srid?: number; type: 'point' } = { type: 'point' };
+
+		const sridOption = splitSqlType(type).options?.split(',')[1];
+		if (sridOption) options.srid = Number(sridOption);
+		if (!value) return { default: '', options };
+
+		if (!value.includes('POINT(')) return { default: `sql\`${value}\``, options };
+
+		const sridInDef = value.startsWith("'SRID=") ? Number(value.split('SRID=')[1].split(';')[0]) : undefined;
+		if (!sridOption && sridInDef) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		const [res1, res2] = value.split('POINT(')[1].split(')')[0].split(' ');
+
+		return { default: `[${res1},${res2}]`, options };
+	},
+	toArrayTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		const options: { srid?: number; type: 'point' } = { type: 'point' };
+		const sridOption = splitSqlType(type).options?.split(',')[1];
+		if (sridOption) options.srid = Number(sridOption);
+
+		if (!value) return { default: '', options };
+
+		let isDrizzleSql;
+		const srids: number[] = [];
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (v.includes('SRID=')) {
+					srids.push(Number(v.split('SRID=')[1].split(';')[0]));
+				}
+				const [res1, res2] = value.split('POINT(')[1].split(')')[0].split(' ');
+				if (!value.includes('POINT(')) isDrizzleSql = true;
+
+				return `[${res1}, ${res2}]`;
+			});
+
+			if (!isDrizzleSql) isDrizzleSql = srids.some((it) => it !== srids[0]);
+			// if there is no srid in type and user defines srids in default
+			// we need to return point with srids
+			if (!isDrizzleSql && !sridOption && srids.length > 0) isDrizzleSql = true;
+
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Inet: SqlType = {
+	is: (type: string) => /^\s*inet(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'inet',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		value = trimChar(value, "'");
+		return { options, default: `"${value}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const typeFor = (type: string, isEnum: boolean): SqlType => {
+	if (isEnum) return Enum;
+	if (Int2.is(type)) return Int2;
+	if (Int4.is(type)) return Int4;
+	if (Int8.is(type)) return Int8;
+	if (Bool.is(type)) return Bool;
+	if (Uuid.is(type)) return Uuid;
+	if (Real.is(type)) return Real;
+	if (Float.is(type)) return Float;
+	if (Decimal.is(type)) return Decimal;
+	if (Bit.is(type)) return Bit;
+	if (VarBit.is(type)) return VarBit;
+	if (Timestamp.is(type)) return Timestamp;
+	if (TimestampTZ.is(type)) return TimestampTZ;
+	if (Time.is(type)) return Time;
+	if (TimeTz.is(type)) return TimeTz;
+	if (DateType.is(type)) return DateType;
+	if (Char.is(type)) return Char;
+	if (Varchar.is(type)) return Varchar;
+	// if (Text.is(type)) return Text;
+	if (StringType.is(type)) return StringType;
+	if (Jsonb.is(type)) return Jsonb;
+	if (Interval.is(type)) return Interval;
+	if (Vector.is(type)) return Vector;
+	if (GeometryPoint.is(type)) return GeometryPoint;
+	if (Inet.is(type)) return Inet;
+	return Custom;
+};
diff --git a/drizzle-kit/src/dialects/cockroach/introspect.ts b/drizzle-kit/src/dialects/cockroach/introspect.ts
new file mode 100644
index 0000000000..49c6a505e2
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/introspect.ts
@@ -0,0 +1,1144 @@
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import { type DB, splitExpressions, trimChar } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import { filterMigrationsSchema } from '../utils';
+import type {
+	CheckConstraint,
+	CockroachEntities,
+	Enum,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PrimaryKey,
+	Role,
+	Schema,
+	Sequence,
+	View,
+	ViewColumn,
+} from './ddl';
+import {
+	defaultForColumn,
+	isSystemNamespace,
+	parseOnType,
+	parseViewDefinition,
+	stringFromDatabaseIdentityProperty as parseIdentityProperty,
+} from './grammar';
+
+// TODO: tables/schema/entities -> filter: (entity: {type: ..., metadata....})=>boolean;
+// TODO: since we by default only introspect public
+export const fromDatabase = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (stage: IntrospectStage, count: number, status: IntrospectStatus) => void = () => {},
+	queryCallback: (id: string, rows: Record<string, unknown>[], error: Error | null) => void = () => {},
+): Promise<InterimSchema> => {
+	const schemas: Schema[] = [];
+	const enums: Enum[] = [];
+	const tables: CockroachEntities['tables'][] = [];
+	const columns: InterimColumn[] = [];
+	const indexes: InterimIndex[] = [];
+	const pks: PrimaryKey[] = [];
+	const fks: ForeignKey[] = [];
+	const checks: CheckConstraint[] = [];
+	const sequences: Sequence[] = [];
+	const roles: Role[] = [];
+	const policies: Policy[] = [];
+	const views: View[] = [];
+	const viewColumns: ViewColumn[] = [];
+
+	type Namespace = {
+		oid: number;
+		name: string;
+	};
+
+	// TODO: potential improvements
+	// --- default access method
+	// SHOW default_table_access_method;
+	// SELECT current_setting('default_table_access_method') AS default_am;
+
+	const accessMethodsQuery = db
+		.query<{ oid: number; name: string }>(`SELECT oid, amname as name FROM pg_am WHERE amtype = 't' ORDER BY amname;`)
+		.then((rows) => {
+			queryCallback('accessMethods', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('accessMethods', [], err);
+			throw err;
+		});
+
+	const tablespacesQuery = db
+		.query<{
+			oid: number;
+			name: string;
+		}>('SELECT oid, spcname as "name" FROM pg_tablespace ORDER BY lower(spcname);')
+		.then((rows) => {
+			queryCallback('tablespaces', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('tablespaces', [], err);
+			throw err;
+		});
+
+	const namespacesQuery = db
+		.query<Namespace>('select oid, nspname as name from pg_namespace ORDER BY lower(nspname);')
+		.then((rows) => {
+			queryCallback('namespaces', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('namespaces', [], err);
+			throw err;
+		});
+
+	const [_ams, _tablespaces, namespaces] = await Promise.all([
+		accessMethodsQuery,
+		tablespacesQuery,
+		namespacesQuery,
+	]);
+
+	const { system: _, other: filteredNamespaces } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
+		(acc, it) => {
+			if (isSystemNamespace(it.name)) {
+				acc.system.push(it);
+			} else {
+				acc.other.push(it);
+			}
+			return acc;
+		},
+		{ system: [], other: [] },
+	);
+
+	const filteredNamespacesStringForSQL = filteredNamespaces.map((ns) => `'${ns.name}'`).join(',');
+
+	schemas.push(...filteredNamespaces.map<Schema>((it) => ({ entityType: 'schemas', name: it.name })));
+
+	const tablesList = await db
+		.query<{
+			oid: number;
+			schema: string;
+			name: string;
+
+			/* r - table, v - view, m - materialized view */
+			kind: 'r' | 'v' | 'm';
+			accessMethod: number;
+			options: string[] | null;
+			rlsEnabled: boolean;
+			tablespaceid: number;
+			definition: string | null;
+		}>(
+			`
+			SELECT
+				pg_class.oid,
+				nspname as "schema",
+				relname AS "name",
+				relkind AS "kind",
+				relam as "accessMethod",
+				reloptions::text[] as "options",
+				reltablespace as "tablespaceid",
+				relrowsecurity AS "rlsEnabled",
+				CASE
+					WHEN relkind OPERATOR(pg_catalog.=) 'v' OR relkind OPERATOR(pg_catalog.=) 'm'
+						THEN pg_catalog.pg_get_viewdef(pg_class.oid, true)
+					ELSE null
+				END as "definition"
+			FROM
+				pg_catalog.pg_class
+			JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) relnamespace
+			WHERE
+				relkind IN ('r', 'p', 'v', 'm')
+				AND nspname IN (${filteredNamespacesStringForSQL})
+			ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);`,
+		)
+		.then((rows) => {
+			queryCallback('tables', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('tables', [], err);
+			throw err;
+		});
+
+	const viewsList = tablesList.filter((it) => (it.kind === 'v' || it.kind === 'm'))
+		.map((it) => {
+			return {
+				...it,
+				schema: trimChar(it.schema, '"'),
+			};
+		});
+	const filteredTables = tablesList
+		.filter((it) => it.kind === 'r')
+		.map((it) => {
+			return {
+				...it,
+				schema: trimChar(it.schema, '"'), // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+			};
+		});
+	const filteredTableIds = filteredTables.map((it) => it.oid);
+	const viewsIds = viewsList.map((it) => it.oid);
+	const filteredViewsAndTableIds = [...filteredTableIds, ...viewsIds];
+
+	const filterByTableIds = filteredTableIds.length > 0 ? `(${filteredTableIds.join(',')})` : '';
+	const filterByTableAndViewIds = filteredViewsAndTableIds.length > 0 ? `(${filteredViewsAndTableIds.join(',')})` : '';
+
+	for (const table of filteredTables) {
+		tables.push({
+			entityType: 'tables',
+			schema: table.schema,
+			name: table.name,
+			isRlsEnabled: table.rlsEnabled,
+		});
+	}
+
+	const dependQuery = db
+		.query<{
+			oid: number;
+			tableId: number;
+			ordinality: number;
+
+			/*
+			a - An “auto” dependency means the dependent object can be dropped separately,
+					and will be automatically removed if the referenced object is dropped—regardless of CASCADE or RESTRICT.
+					Example: A named constraint on a table is auto-dependent on the table, so it vanishes when the table is dropped
+
+					i - An “internal” dependency marks objects that were created as part of building another object.
+					Directly dropping the dependent is disallowed—you must drop the referenced object instead.
+					Dropping the referenced object always cascades to the dependent
+					Example: A trigger enforcing a foreign-key constraint is internally dependent on its pg_constraint entry
+		 */
+			deptype: 'a' | 'i';
+		}>(
+			`
+		SELECT
+			-- sequence id
+			objid as oid,
+			refobjid as "tableId",
+			refobjsubid as "ordinality",
+			
+			-- a = auto
+			deptype
+		FROM
+			pg_depend
+		where ${filterByTableIds ? ` refobjid in ${filterByTableIds}` : 'false'};
+	`,
+		)
+		.then((rows) => {
+			queryCallback('dependencies', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('dependencies', [], err);
+			throw err;
+		});
+
+	const enumsQuery = db
+		.query<{
+			oid: number;
+			name: string;
+			schema: string;
+			arrayTypeId: number;
+			ordinality: number;
+			value: string;
+		}>(
+			`SELECT
+				pg_type.oid as "oid",
+				typname as "name",
+				nspname as "schema",
+				pg_type.typarray as "arrayTypeId",
+				pg_enum.enumsortorder AS "ordinality",
+				pg_enum.enumlabel AS "value"
+			FROM
+				pg_catalog.pg_type
+			JOIN pg_catalog.pg_enum ON pg_enum.enumtypid OPERATOR(pg_catalog.=) pg_type.oid
+			JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_type.typnamespace
+			WHERE
+				pg_type.typtype OPERATOR(pg_catalog.=) 'e'
+				AND nspname IN (${filteredNamespacesStringForSQL})
+			ORDER BY pg_type.oid, pg_enum.enumsortorder
+		`,
+		)
+		.then((rows) => {
+			queryCallback('enums', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('enums', [], err);
+			throw err;
+		});
+
+	const sequencesQuery = db
+		.query<{
+			schema: string;
+			oid: number;
+			name: string;
+			startWith: string;
+			minValue: string;
+			maxValue: string;
+			incrementBy: string;
+			cycle: boolean;
+			cacheSize: string;
+		}>(
+			`SELECT 
+			nspname as "schema",
+			relname as "name",
+			seqrelid as "oid",
+			seqstart as "startWith", 
+			seqmin as "minValue", 
+			seqmax as "maxValue", 
+			seqincrement as "incrementBy", 
+			seqcycle as "cycle", 
+			COALESCE(pgs.cache_size, pg_sequence.seqcache) as "cacheSize"
+		FROM pg_catalog.pg_sequence
+		JOIN pg_catalog.pg_class ON pg_sequence.seqrelid OPERATOR(pg_catalog.=) pg_class.oid
+		JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_class.relnamespace
+		LEFT JOIN pg_sequences pgs ON (
+		    pgs.sequencename = pg_class.relname 
+    		AND pgs.schemaname = pg_class.relnamespace::regnamespace::text
+		)
+		WHERE nspname IN (${filteredNamespacesStringForSQL})
+		ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+;`,
+		)
+		.then((rows) => {
+			queryCallback('sequences', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('sequences', [], err);
+			throw err;
+		});
+
+	// I'm not yet aware of how we handle policies down the pipeline for push,
+	// and since postgres does not have any default policies, we can safely fetch all of them for now
+	// and filter them out in runtime, simplifying filterings
+	const policiesQuery = db
+		.query<{
+			schema: string;
+			table: string;
+			name: string;
+			as: Policy['as'];
+			to: string | string[]; // TODO: | string[] ??
+			for: Policy['for'];
+			using: string | undefined | null;
+			withCheck: string | undefined | null;
+		}>(
+			`SELECT 
+			schemaname as "schema", 
+			tablename as "table", 
+			policyname as "name", 
+			UPPER(permissive) as "as", 
+			roles as "to", 
+			cmd as "for", 
+			qual as "using", 
+			with_check as "withCheck" 
+		FROM pg_policies
+		ORDER BY lower(schemaname), lower(tablename), lower(policyname)
+		;`,
+		)
+		.then((rows) => {
+			queryCallback('policies', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('policies', [], err);
+			throw err;
+		});
+
+	const rolesQuery = db
+		.query<{ username: string; options: string; member_of: string[] }>(
+			`SHOW roles;`,
+		)
+		.then((rows) => {
+			queryCallback('roles', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('roles', [], err);
+			throw err;
+		});
+
+	const constraintsQuery = db
+		.query<{
+			oid: number;
+			schemaId: number;
+			tableId: number;
+			name: string;
+			type: 'p' | 'u' | 'f' | 'c'; // p - primary key, u - unique, f - foreign key, c - check
+			definition: string;
+			indexId: number;
+			columnsOrdinals: number[];
+			tableToId: number;
+			columnsToOrdinals: number[];
+			onUpdate: 'a' | 'd' | 'r' | 'c' | 'n';
+			onDelete: 'a' | 'd' | 'r' | 'c' | 'n';
+		}>(
+			`
+    SELECT
+      oid,
+      connamespace AS "schemaId",
+      conrelid AS "tableId",
+      conname AS "name",
+      contype AS "type", 
+      pg_get_constraintdef(oid) AS "definition",
+      conindid AS "indexId",
+      conkey AS "columnsOrdinals",
+      confrelid AS "tableToId",
+      confkey AS "columnsToOrdinals",
+      confupdtype AS "onUpdate",
+      confdeltype AS "onDelete"
+    FROM
+      pg_constraint
+    WHERE ${filterByTableIds ? ` conrelid in ${filterByTableIds}` : 'false'}
+	ORDER BY connamespace, conrelid, lower(conname)
+  `,
+		)
+		.then((rows) => {
+			queryCallback('constraints', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('constraints', [], err);
+			throw err;
+		});
+
+	const defaultsQuery = db
+		.query<{
+			tableId: number;
+			ordinality: number;
+			expression: string;
+		}>(
+			`
+		SELECT
+			adrelid AS "tableId",
+			adnum AS "ordinality",
+			pg_get_expr(adbin, adrelid) AS "expression"
+		FROM
+			pg_attrdef
+      WHERE ${filterByTableAndViewIds ? `adrelid IN ${filterByTableAndViewIds}` : 'false'};
+	`,
+		)
+		.then((rows) => {
+			queryCallback('defaults', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('defaults', [], err);
+			throw err;
+		});
+
+	// for serials match with pg_attrdef via attrelid(tableid)+adnum(ordinal position), for enums with pg_enum above
+	const columnsQuery = db
+		.query<{
+			tableId: number;
+			kind: 'r' | 'v' | 'm';
+			name: string;
+			ordinality: number;
+			notNull: boolean;
+			type: string;
+			typeId: number;
+			/* s - stored */
+			generatedType: 's' | '';
+			/*
+		'a' for GENERATED ALWAYS
+		'd' for GENERATED BY DEFAULT
+		*/
+			identityType: 'a' | 'd' | '';
+			metadata: {
+				seqId: string | null;
+				generation: string | null;
+				start: string | null;
+				increment: string | null;
+				max: string | null;
+				min: string | null;
+				cycle: string;
+				generated: 'ALWAYS' | 'BY DEFAULT';
+				expression: string | null;
+			} | null;
+			isHidden: boolean;
+			dimensions: '0' | '1';
+		}>(
+			`SELECT
+				attrelid AS "tableId",
+				relkind AS "kind",
+				attname AS "name",
+				attnum AS "ordinality",
+				attnotnull AS "notNull",
+				atttypid as "typeId",
+				attgenerated as "generatedType", 
+				attidentity as "identityType",
+				format_type(atttypid, atttypmod) as "type",
+				CASE
+    			    WHEN typ.typcategory = 'A' THEN 1
+    			    ELSE 0
+    			END AS "dimensions",
+				CASE
+					WHEN attidentity in ('a', 'd') or attgenerated = 's' THEN (
+						SELECT
+							row_to_json(c.*)
+						FROM
+							(
+								SELECT
+									pg_get_serial_sequence(
+										quote_ident("table_schema") || '.' || quote_ident("table_name"), 
+										"attname"
+									)::regclass::oid as "seqId",
+									"identity_generation" AS generation,
+									"identity_start" AS "start",
+									"identity_increment" AS "increment",
+									"identity_maximum" AS "max",
+									"identity_minimum" AS "min",
+									"identity_cycle" AS "cycle",
+									"generation_expression" AS "expression"
+								FROM
+									information_schema.columns c
+								WHERE
+									c.column_name = attname
+									-- relnamespace is schemaId, regnamescape::text converts to schemaname
+									AND c.table_schema = cls.relnamespace::regnamespace::text
+									-- attrelid is tableId, regclass::text converts to table name
+									AND c.table_name = attrelid::regclass::text
+							) c
+						)
+					ELSE NULL
+				END AS "metadata",
+				CASE 
+					WHEN tc.is_hidden = 'YES' then true 
+					WHEN tc.is_hidden = 'NO' then false 
+					ELSE null
+				END AS "isHidden"
+			FROM
+				pg_attribute attr
+				LEFT JOIN pg_class cls ON cls.oid = attr.attrelid
+				LEFT JOIN information_schema.columns tc ON tc.table_schema = cls.relnamespace::regnamespace::text AND tc.table_name = cls.relname AND tc.column_name = attname
+				LEFT JOIN pg_type typ ON typ.oid = attr.atttypid
+			WHERE
+			${filterByTableAndViewIds ? ` attrelid in ${filterByTableAndViewIds}` : 'false'}
+				AND attnum > 0
+				AND attisdropped = FALSE
+			ORDER BY attnum
+		;`,
+		)
+		.then((rows) => {
+			queryCallback('columns', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('columns', [], err);
+			throw err;
+		});
+
+	const extraColumnDataTypesQuery = db
+		.query<{
+			table_schema: string;
+			table_name: string;
+			column_name: string;
+			data_type: string;
+		}>(
+			`SELECT 
+			table_schema as table_schema, 
+			table_name as table_name, 
+			column_name as column_name, 
+			lower(crdb_sql_type) as data_type  
+		FROM information_schema.columns 
+		WHERE  ${tablesList.length ? `table_name in (${tablesList.map((it) => `'${it.name}'`).join(', ')})` : 'false'}
+	`,
+		)
+		.then((rows) => {
+			queryCallback('extraColumnDataTypes', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('extraColumnDataTypes', [], err);
+			throw err;
+		});
+
+	const [
+		dependList,
+		enumsList,
+		sequencesList,
+		policiesList,
+		rolesList,
+		constraintsList,
+		columnsList,
+		extraColumnDataTypesList,
+		defaultsList,
+	] = await Promise.all([
+		dependQuery,
+		enumsQuery,
+		sequencesQuery,
+		policiesQuery,
+		rolesQuery,
+		constraintsQuery,
+		columnsQuery,
+		extraColumnDataTypesQuery,
+		defaultsQuery,
+	]);
+
+	const groupedEnums = enumsList.reduce(
+		(acc, it) => {
+			if (!(it.oid in acc)) {
+				acc[it.oid] = {
+					oid: it.oid,
+					schema: it.schema,
+					name: it.name,
+					values: [it.value],
+				};
+			} else {
+				acc[it.oid].values.push(it.value);
+			}
+			return acc;
+		},
+		{} as Record<number, { oid: number; schema: string; name: string; values: string[] }>,
+	);
+
+	const groupedArrEnums = enumsList.reduce(
+		(acc, it) => {
+			if (!(it.arrayTypeId in acc)) {
+				acc[it.arrayTypeId] = {
+					oid: it.oid,
+					schema: it.schema,
+					name: it.name,
+					values: [it.value],
+				};
+			} else {
+				acc[it.arrayTypeId].values.push(it.value);
+			}
+			return acc;
+		},
+		{} as Record<number, { oid: number; schema: string; name: string; values: string[] }>,
+	);
+
+	for (const it of Object.values(groupedEnums)) {
+		enums.push({
+			entityType: 'enums',
+			schema: it.schema,
+			name: it.name,
+			values: it.values,
+		});
+	}
+
+	let columnsCount = columnsList.filter((it) => !it.isHidden).length;
+	let indexesCount = 0;
+	let foreignKeysCount = constraintsList.filter((it) => it.type === 'f').length;
+	let tableCount = tablesList.filter((it) => it.kind === 'r').length;
+	let checksCount = constraintsList.filter((it) => it.type === 'c').length;
+	let viewsCount = tablesList.filter((it) => it.kind === 'm' || it.kind === 'v').length;
+
+	for (const seq of sequencesList) {
+		const depend = dependList.find((it) => it.oid === seq.oid);
+
+		if (depend && (depend.deptype === 'a' || depend.deptype === 'i')) {
+			// TODO: add type field to sequence in DDL
+			// skip fo sequences or identity columns
+			// console.log('skip for auto created', seq.name);
+			continue;
+		}
+
+		sequences.push({
+			entityType: 'sequences',
+			schema: seq.schema,
+			name: seq.name,
+			startWith: parseIdentityProperty(seq.startWith),
+			minValue: parseIdentityProperty(seq.minValue),
+			maxValue: parseIdentityProperty(seq.maxValue),
+			incrementBy: parseIdentityProperty(seq.incrementBy),
+			cacheSize: Number(parseIdentityProperty(seq.cacheSize) ?? 1),
+		});
+	}
+
+	progressCallback('enums', Object.keys(groupedEnums).length, 'done');
+
+	for (const dbRole of rolesList) {
+		const createDb = dbRole.options.includes('CREATEDB');
+		const createRole = dbRole.options.includes('CREATEROLE');
+		roles.push({
+			entityType: 'roles',
+			name: dbRole.username,
+			createDb: createDb,
+			createRole: createRole,
+		});
+	}
+
+	for (const it of policiesList) {
+		policies.push({
+			entityType: 'policies',
+			schema: it.schema,
+			table: it.table,
+			name: it.name,
+			as: it.as,
+			for: it.for,
+			roles: typeof it.to === 'string' ? it.to.slice(1, -1).split(',') : it.to,
+			using: it.using ?? null,
+			withCheck: it.withCheck ?? null,
+		});
+	}
+
+	progressCallback('policies', policiesList.length, 'done');
+
+	type DBColumn = (typeof columnsList)[number];
+
+	for (const column of columnsList.filter((x) => x.kind === 'r' && !x.isHidden)) {
+		const table = tablesList.find((it) => it.oid === column.tableId)!;
+		const extraColumnConfig = extraColumnDataTypesList.find((it) =>
+			it.column_name === column.name && it.table_name === table.name && it.table_schema === table.schema
+		)!;
+
+		// supply enums
+		const enumType = column.typeId in groupedEnums
+			? groupedEnums[column.typeId]
+			: column.typeId in groupedArrEnums
+			? groupedArrEnums[column.typeId]
+			: null;
+
+		let columnTypeMapped;
+
+		columnTypeMapped = enumType
+			? enumType.name
+			: extraColumnConfig.data_type.replace('character', 'char').replace('float8', 'float').replace(
+				'float4',
+				'real',
+			).replaceAll('[]', '');
+		const columnDimensions = Number(column.dimensions);
+
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+
+		const columnDefault = defaultsList.find((it) =>
+			it.tableId === column.tableId && it.ordinality === column.ordinality
+		);
+
+		const defaultValue = defaultForColumn(
+			columnTypeMapped,
+			columnDefault?.expression,
+			columnDimensions,
+			Boolean(enumType),
+		);
+
+		const unique = constraintsList.find((it) => {
+			return it.type === 'u' && it.tableId === column.tableId && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const pk = constraintsList.find((it) => {
+			return it.type === 'p' && it.tableId === column.tableId && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const metadata = column.metadata;
+		if (column.generatedType === 's' && (!metadata || !metadata.expression)) {
+			throw new Error(
+				`Generated ${table.schema}.${table.name}.${column.name} columns missing expression: \n${
+					JSON.stringify(column.metadata)
+				}`,
+			);
+		}
+
+		if (column.identityType !== '' && !metadata) {
+			throw new Error(
+				`Identity ${table.schema}.${table.name}.${column.name} columns missing metadata: \n${
+					JSON.stringify(column.metadata)
+				}`,
+			);
+		}
+
+		const sequence = metadata?.seqId ? (sequencesList.find((it) => it.oid === Number(metadata.seqId)) ?? null) : null;
+
+		columns.push({
+			entityType: 'columns',
+			schema: table.schema,
+			table: table.name,
+			name: column.name,
+			type: columnTypeMapped,
+			typeSchema: enumType ? enumType.schema ?? 'public' : null,
+			dimensions: columnDimensions,
+			default: column.generatedType === 's' || column.identityType ? null : defaultValue,
+			unique: !!unique,
+			uniqueName: unique ? unique.name : null,
+			notNull: column.notNull,
+			pk: pk !== null,
+			pkName: pk !== null ? pk.name : null,
+			generated: column.generatedType === 's' ? { type: 'stored', as: metadata!.expression! } : null,
+			identity: column.identityType !== ''
+				? {
+					type: column.identityType === 'a' ? 'always' : 'byDefault',
+					increment: parseIdentityProperty(metadata?.increment),
+					minValue: parseIdentityProperty(metadata?.min),
+					maxValue: parseIdentityProperty(metadata?.max),
+					startWith: parseIdentityProperty(metadata?.start),
+					cache: Number(sequence?.cacheSize ?? 1),
+				}
+				: null,
+		});
+	}
+
+	for (const pk of constraintsList.filter((it) => it.type === 'p')) {
+		const table = tablesList.find((it) => it.oid === pk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === pk.schemaId)!;
+
+		// Check if any column in the PK is hidden, skip if so
+		const hasHiddenColumn = pk.columnsOrdinals.some((ordinal) => {
+			const column = columnsList.find((column) => column.tableId === pk.tableId && column.ordinality === ordinal);
+			return !column || column.isHidden; // skip if not found or hidden
+		});
+
+		if (hasHiddenColumn) {
+			continue;
+		}
+
+		const columns: typeof columnsList = [];
+		for (const ordinal of pk.columnsOrdinals) {
+			const column = columnsList.find((column) => column.tableId === pk.tableId && column.ordinality === ordinal);
+
+			if (!column) {
+				continue;
+			}
+
+			columns.push(column);
+		}
+
+		if (columns.some((c) => c.isHidden)) continue;
+
+		pks.push({
+			entityType: 'pks',
+			schema: schema.name,
+			table: table.name,
+			name: pk.name,
+			columns: columns.map((c) => c.name),
+			nameExplicit: true,
+		});
+	}
+
+	for (const fk of constraintsList.filter((it) => it.type === 'f')) {
+		const table = tablesList.find((it) => it.oid === fk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === fk.schemaId)!;
+		const tableTo = tablesList.find((it) => it.oid === fk.tableToId)!;
+
+		const columns = fk.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === fk.tableId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		const columnsTo = fk.columnsToOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === fk.tableToId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		fks.push({
+			entityType: 'fks',
+			schema: schema.name,
+			table: table.name,
+			name: fk.name,
+			nameExplicit: true,
+			columns,
+			tableTo: tableTo.name,
+			schemaTo: tableTo.schema,
+			columnsTo,
+			onUpdate: parseOnType(fk.onUpdate),
+			onDelete: parseOnType(fk.onDelete),
+		});
+	}
+
+	for (const check of constraintsList.filter((it) => it.type === 'c')) {
+		const table = tablesList.find((it) => it.oid === check.tableId)!;
+		const schema = namespaces.find((it) => it.oid === check.schemaId)!;
+
+		// Check if any column in the PK is hidden, skip if so
+		const hasHiddenColumn = check.columnsOrdinals && check.columnsOrdinals.some((ordinal) => {
+			const column = columnsList.find((column) => column.tableId === check.tableId && column.ordinality === ordinal);
+			return !column || column.isHidden; // skip if not found or hidden
+		});
+
+		if (hasHiddenColumn) {
+			continue;
+		}
+
+		checks.push({
+			entityType: 'checks',
+			schema: schema.name,
+			table: table.name,
+			name: check.name,
+			value: check.definition.startsWith('CHECK (') ? check.definition.slice(7, -1) : check.definition,
+		});
+	}
+
+	const idxs = await db
+		.query<{
+			oid: number;
+			schemaId: number;
+			name: string;
+			accessMethod: string;
+			with?: string[];
+			metadata: {
+				tableId: number;
+				expression: string | null;
+				where: string;
+				columnOrdinals: number[];
+				index_def: string;
+				opclassIds: number[];
+				options: number[];
+				isUnique: boolean;
+				isPrimary: boolean;
+			};
+		}>(
+			`
+      SELECT
+        pg_class.oid,
+        relnamespace AS "schemaId",
+        relname AS "name",
+        am.amname AS "accessMethod",
+        reloptions AS "with",
+        row_to_json(metadata.*) as "metadata"
+      FROM
+        pg_class
+      JOIN pg_am am ON am.oid = pg_class.relam
+      LEFT JOIN LATERAL (
+        SELECT
+          pg_get_expr(indexprs, indrelid) AS "expression",
+          pg_get_expr(indpred, indrelid) AS "where",
+          indrelid::int AS "tableId",
+          pg_get_indexdef(indexrelid) AS index_def,
+          indkey::int[] as "columnOrdinals",
+          indclass::int[] as "opclassIds",
+          indoption::int[] as "options",
+					indisunique as "isUnique",
+					indisprimary as "isPrimary"
+        FROM
+          pg_index
+        WHERE
+          pg_index.indexrelid = pg_class.oid
+      ) metadata ON TRUE
+      WHERE
+        relkind = 'i' and ${filterByTableIds ? `metadata."tableId" in ${filterByTableIds}` : 'false'}
+	  ORDER BY relnamespace, lower(relname)
+    `,
+		)
+		.then((rows) => {
+			queryCallback('indexes', rows, null);
+			return rows;
+		})
+		.catch((err) => {
+			queryCallback('indexes', [], err);
+			throw err;
+		});
+
+	for (const idx of idxs) {
+		const { metadata, accessMethod } = idx;
+
+		// filter for drizzle only?
+		const forPK = metadata.isPrimary && constraintsList.some((x) => x.type === 'p' && x.indexId === idx.oid);
+		if (!forPK) indexesCount += 1;
+
+		const expr = splitExpressions(metadata.expression);
+
+		const schema = namespaces.find((it) => it.oid === idx.schemaId)!;
+		const table = tablesList.find((it) => it.oid === idx.metadata.tableId)!;
+
+		const nonColumnsCount = metadata.columnOrdinals.reduce((acc, it) => {
+			if (it === 0) acc += 1;
+			return acc;
+		}, 0);
+
+		if (expr.length !== nonColumnsCount) {
+			throw new Error(
+				`expression split doesn't match non-columns count: [${
+					metadata.columnOrdinals.join(', ')
+				}] '${metadata.expression}':${expr.length}:${nonColumnsCount}`,
+			);
+		}
+
+		const opts = metadata.options.map((it) => {
+			return {
+				descending: (it & 1) === 1,
+			};
+		});
+
+		const res = [] as (({ type: 'expression'; value: string } | { type: 'column'; value: DBColumn }) & {
+			options: (typeof opts)[number];
+		})[];
+
+		let k = 0;
+		for (let i = 0; i < metadata.columnOrdinals.length; i++) {
+			const ordinal = metadata.columnOrdinals[i];
+			if (ordinal === 0) {
+				res.push({
+					type: 'expression',
+					value: expr[k],
+					options: opts[i],
+				});
+				k += 1;
+			} else {
+				const column = columnsList.find((column) => {
+					return column.tableId === metadata.tableId && column.ordinality === ordinal;
+				});
+
+				if (column?.isHidden) continue;
+				if (!column) throw new Error(`missing column: ${metadata.tableId}:${ordinal}`);
+
+				res.push({
+					type: 'column',
+					value: column,
+					options: opts[i],
+				});
+			}
+		}
+
+		const columns = res.map((it) => {
+			return {
+				asc: !it.options.descending,
+				isExpression: it.type === 'expression',
+				value: it.type === 'expression' ? it.value : it.value.name, // column name
+			} satisfies Index['columns'][number];
+		});
+
+		const getUsing = (def: string, accessMethod: string): Index['method'] => {
+			const regex = /USING\s+(HASH|CSPANN)/gi;
+
+			let match: RegExpExecArray | null;
+			while ((match = regex.exec(def)) !== null) {
+				const beforeMatch = def.slice(0, match.index);
+
+				// count how many double quotes before this match
+				const quoteCount = (beforeMatch.match(/"/g) || []).length;
+
+				// if even number of quotes - outside quotes
+				if (quoteCount % 2 === 0) {
+					return match[1].toLowerCase();
+				}
+			}
+
+			if (accessMethod === 'inverted') return 'gin';
+
+			return 'btree';
+		};
+
+		const indexAccessMethod = getUsing(metadata.index_def, accessMethod);
+
+		indexes.push({
+			entityType: 'indexes',
+			schema: schema.name,
+			table: table.name,
+			name: idx.name,
+			nameExplicit: true,
+			method: indexAccessMethod,
+			isUnique: metadata.isUnique,
+			where: idx.metadata.where,
+			columns: columns,
+			forPK,
+		});
+	}
+
+	progressCallback('columns', columnsCount, 'fetching');
+	progressCallback('checks', checksCount, 'fetching');
+	progressCallback('indexes', indexesCount, 'fetching');
+	progressCallback('tables', tableCount, 'fetching');
+	progressCallback('views', viewsCount, 'fetching');
+
+	for (const it of columnsList.filter((x) => (x.kind === 'm' || x.kind === 'v') && !x.isHidden)) {
+		const view = viewsList.find((x) => x.oid === it.tableId)!;
+
+		const enumType = it.typeId in groupedEnums
+			? groupedEnums[it.typeId]
+			: it.typeId in groupedArrEnums
+			? groupedArrEnums[it.typeId]
+			: null;
+
+		let columnTypeMapped = enumType ? enumType.name : it.type.replace('[]', '');
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+		for (let i = 0; i < Number(it.dimensions); i++) {
+			columnTypeMapped += '[]';
+		}
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char')
+			.replace('integer', 'int4')
+			.replace('bigint', 'int8')
+			.replace('smallint', 'int2');
+
+		viewColumns.push({
+			schema: view.schema,
+			view: view.name,
+			name: it.name,
+			type: columnTypeMapped,
+			notNull: it.notNull,
+			dimensions: Number(it.dimensions),
+			typeSchema: enumType ? enumType.schema : null,
+		});
+	}
+
+	for (const view of viewsList) {
+		const definition = parseViewDefinition(view.definition);
+
+		views.push({
+			entityType: 'views',
+			schema: view.schema,
+			name: view.name,
+			definition,
+			materialized: view.kind === 'm',
+			withNoData: null,
+		});
+	}
+
+	progressCallback('tables', tableCount, 'done');
+	progressCallback('columns', columnsCount, 'done');
+	progressCallback('indexes', indexesCount, 'done');
+	progressCallback('fks', foreignKeysCount, 'done');
+	progressCallback('checks', checksCount, 'done');
+	progressCallback('views', viewsCount, 'done');
+
+	const resultSchemas = schemas.filter((x) => filter({ type: 'schema', name: x.name }));
+	const resultTables = tables.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultEnums = enums.filter((x) => resultSchemas.some((s) => s.name === x.schema));
+	const resultColumns = columns.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultIndexes = indexes.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultPKs = pks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultFKs = fks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultChecks = checks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultSequences = sequences.filter((x) => resultSchemas.some((t) => t.name === x.schema));
+	// TODO: drizzle link
+	const resultRoles = roles.filter((x) => filter({ type: 'role', name: x.name }));
+	const resultViews = views.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultViewColumns = viewColumns.filter((x) =>
+		resultViews.some((v) => v.schema === x.schema && v.name === x.view)
+	);
+
+	return {
+		schemas: resultSchemas,
+		tables: resultTables,
+		enums: resultEnums,
+		columns: resultColumns,
+		indexes: resultIndexes,
+		pks: resultPKs,
+		fks: resultFKs,
+		checks: resultChecks,
+		sequences: resultSequences,
+		roles: resultRoles,
+		policies,
+		views: resultViews,
+		viewColumns: resultViewColumns,
+	} satisfies InterimSchema;
+};
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (stage: IntrospectStage, count: number, status: IntrospectStatus) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const res = await fromDatabase(db, filter, progressCallback);
+
+	res.schemas = res.schemas.filter((it) => it.name !== 'public');
+	res.indexes = res.indexes.filter((it) => !it.forPK);
+
+	filterMigrationsSchema(res, migrations);
+
+	return res;
+};
diff --git a/drizzle-kit/src/dialects/cockroach/serializer.ts b/drizzle-kit/src/dialects/cockroach/serializer.ts
new file mode 100644
index 0000000000..4cb24eb152
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/serializer.ts
@@ -0,0 +1,82 @@
+import { cockroachSchemaError, cockroachSchemaWarning, humanLog } from '../../cli/views';
+import { findLeafSnapshotIds } from '../../utils/utils-node';
+import type { CockroachDDL } from './ddl';
+import { createDDL, interimToDDL } from './ddl';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from './drizzle';
+import type { CockroachSnapshot } from './snapshot';
+import { drySnapshot, snapshotValidator } from './snapshot';
+
+export const prepareSnapshot = async (
+	snapshots: string[],
+	filenames: string[],
+): Promise<{
+	ddlPrev: CockroachDDL;
+	ddlCur: CockroachDDL;
+	snapshot: CockroachSnapshot;
+	snapshotPrev: CockroachSnapshot;
+	custom: CockroachSnapshot;
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const prevSnapshot = snapshots.length === 0
+		? drySnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+
+	const res = await prepareFromSchemaFiles(filenames);
+
+	// TODO: do we want to export everything or ignore .existing and respect entity filters in config
+	const { schema, errors, warnings } = fromDrizzleSchema(
+		res,
+		() => true,
+	);
+
+	if (warnings.length > 0) {
+		humanLog(warnings.map((it) => cockroachSchemaWarning(it)).join('\n\n'));
+	}
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => cockroachSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const { ddl: ddlCur, errors: errors2 } = interimToDDL(schema);
+
+	if (errors2.length > 0) {
+		humanLog(errors2.map((it) => cockroachSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const id = randomUUID();
+	const prevIds = snapshots.length === 0 ? [prevSnapshot.id] : findLeafSnapshotIds(snapshots);
+
+	const snapshot = {
+		version: '1',
+		dialect: 'cockroach',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies CockroachSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	// that's for custom migrations, when we need new IDs, but old snapshot
+	const custom: CockroachSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return { ddlPrev, ddlCur, snapshot, snapshotPrev: prevSnapshot, custom };
+};
diff --git a/drizzle-kit/src/dialects/cockroach/snapshot.ts b/drizzle-kit/src/dialects/cockroach/snapshot.ts
new file mode 100644
index 0000000000..cb7d25f484
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/snapshot.ts
@@ -0,0 +1,243 @@
+import { randomUUID } from 'crypto';
+import type { TypeOf } from 'zod';
+import { any, boolean, enum as enumType, literal, number, object, record, string } from 'zod';
+import { originUUID } from '../../utils';
+import { array, validator } from '../simpleValidator';
+import type { CockroachDDL, CockroachEntity } from './ddl';
+import { createDDL } from './ddl';
+import { defaults } from './grammar';
+
+const enumSchema = object({
+	name: string(),
+	schema: string(),
+	values: string().array(),
+}).strict();
+
+const indexColumn = object({
+	expression: string(),
+	isExpression: boolean(),
+	asc: boolean(),
+	nulls: string().optional(),
+	opclass: string().optional(),
+});
+
+export type IndexColumnType = TypeOf<typeof indexColumn>;
+
+const index = object({
+	name: string(),
+	columns: indexColumn.array(),
+	isUnique: boolean(),
+	with: record(string(), any()).optional(),
+	method: string().default(defaults.index.method),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	schemaTo: string().optional(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+export const sequenceSchema = object({
+	name: string(),
+	increment: string().optional(),
+	minValue: string().optional(),
+	maxValue: string().optional(),
+	startWith: string().optional(),
+	cache: string().optional(),
+	cycle: boolean().optional(),
+	schema: string(),
+}).strict();
+
+export const identitySchema = sequenceSchema.omit({ schema: true }).merge(
+	object({ type: enumType(['always', 'byDefault']) }),
+);
+
+export const roleSchema = object({
+	name: string(),
+	createDb: boolean().optional(),
+	createRole: boolean().optional(),
+	inherit: boolean().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	generated: object({
+		type: literal('stored'),
+		as: string(),
+	}).optional(),
+	identity: identitySchema.optional(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+	nullsNotDistinct: boolean(),
+}).strict();
+
+export const policy = object({
+	name: string(),
+	as: enumType(['PERMISSIVE', 'RESTRICTIVE']).optional(),
+	for: enumType(['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE']).optional(),
+	to: string().array().optional(),
+	using: string().optional(),
+	withCheck: string().optional(),
+	on: string().optional(),
+	schema: string().optional(),
+}).strict();
+
+const viewWithOption = object({
+	checkOption: enumType(['local', 'cascaded']).optional(),
+	securityBarrier: boolean().optional(),
+	securityInvoker: boolean().optional(),
+}).strict();
+
+const matViewWithOption = object({
+	fillfactor: number().optional(),
+	toastTupleTarget: number().optional(),
+	parallelWorkers: number().optional(),
+	autovacuumEnabled: boolean().optional(),
+	vacuumIndexCleanup: enumType(['auto', 'off', 'on']).optional(),
+	vacuumTruncate: boolean().optional(),
+	autovacuumVacuumThreshold: number().optional(),
+	autovacuumVacuumScaleFactor: number().optional(),
+	autovacuumVacuumCostDelay: number().optional(),
+	autovacuumVacuumCostLimit: number().optional(),
+	autovacuumFreezeMinAge: number().optional(),
+	autovacuumFreezeMaxAge: number().optional(),
+	autovacuumFreezeTableAge: number().optional(),
+	autovacuumMultixactFreezeMinAge: number().optional(),
+	autovacuumMultixactFreezeMaxAge: number().optional(),
+	autovacuumMultixactFreezeTableAge: number().optional(),
+	logAutovacuumMinDuration: number().optional(),
+	userCatalogTable: boolean().optional(),
+}).strict();
+
+export const mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
+
+export const view = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	materialized: boolean(),
+	with: mergedViewWithOption.optional(),
+	isExisting: boolean(),
+	withNoData: boolean().optional(),
+	using: string().optional(),
+	tablespace: string().optional(),
+}).strict();
+
+const table = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	policies: record(string(), policy).default({}),
+	checkConstraints: record(string(), checkConstraint).default({}),
+	isRLSEnabled: boolean().default(false).optional(),
+}).strict();
+
+const schemaHash = object({
+	id: string(),
+	prevId: string(),
+});
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({
+					isArray: boolean().optional(),
+					dimensions: number().optional(),
+					rawType: string().optional(),
+					isDefaultAnExpression: boolean().optional(),
+				}).optional(),
+			),
+		}).optional(),
+	),
+}).optional();
+
+export const cockroachSchemaInternal = object({
+	version: literal('1'),
+	dialect: literal('cockroach'),
+	tables: record(string(), table),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	views: record(string(), view).default({}),
+	sequences: record(string(), sequenceSchema).default({}),
+	roles: record(string(), roleSchema).default({}),
+	policies: record(string(), policy).default({}),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const cockroachSchema = cockroachSchemaInternal.merge(schemaHash);
+
+export type CockroachSchema = TypeOf<typeof cockroachSchema>;
+
+export type Index = TypeOf<typeof index>;
+export type Column = TypeOf<typeof column>;
+
+export const toJsonSnapshot = (ddl: CockroachDDL, prevIds: string[], renames: string[]): CockroachSnapshot => {
+	return { dialect: 'cockroach', id: randomUUID(), prevIds, version: '1', ddl: ddl.entities.list(), renames };
+};
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['1'],
+	dialect: ['cockroach'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<CockroachEntity>((it) => {
+		const res = ddl.entities.validate(it);
+		if (!res) {
+			console.error(JSON.stringify(it));
+		}
+		return res;
+	}),
+	renames: array<string>((_) => true),
+});
+
+export type CockroachSnapshot = typeof snapshotValidator.shape;
+
+export const drySnapshot = snapshotValidator.strict(
+	{
+		version: '1',
+		dialect: 'cockroach',
+		id: originUUID,
+		prevIds: [],
+		ddl: [],
+		renames: [],
+	} satisfies CockroachSnapshot,
+);
diff --git a/drizzle-kit/src/dialects/cockroach/statements.ts b/drizzle-kit/src/dialects/cockroach/statements.ts
new file mode 100644
index 0000000000..9344cdc56f
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/statements.ts
@@ -0,0 +1,450 @@
+import type { Simplify } from '../../utils';
+import type {
+	CheckConstraint,
+	Column,
+	DiffEntities,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Role,
+	Schema,
+	Sequence,
+	Table,
+	View,
+} from './ddl';
+
+export interface JsonCreateTable {
+	type: 'create_table';
+	table: Table;
+}
+
+export interface JsonDropTable {
+	type: 'drop_table';
+	table: Table;
+	key: string;
+}
+
+export interface JsonRenameTable {
+	type: 'rename_table';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonCreateEnum {
+	type: 'create_enum';
+	enum: Enum;
+}
+
+export interface JsonDropEnum {
+	type: 'drop_enum';
+	enum: Enum;
+}
+
+export interface JsonMoveEnum {
+	type: 'move_enum';
+	from: { name: string; schema: string | null };
+	to: { name: string; schema: string | null };
+}
+
+export interface JsonRenameEnum {
+	type: 'rename_enum';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonRecreateEnum {
+	type: 'recreate_enum';
+	to: Enum;
+	columns: (Omit<Column, 'default'> & {
+		default: {
+			left: Column['default'];
+			right: Column['default'];
+		};
+	})[];
+	from: Enum;
+}
+
+export interface JsonAlterEnum {
+	type: 'alter_enum';
+	to: Enum;
+	from: Enum;
+	diff: {
+		type: 'same' | 'removed' | 'added';
+		value: string;
+		beforeValue?: string;
+	}[];
+}
+
+export interface JsonAlterColumnAddNotNull {
+	type: 'alter_add_column_not_null';
+	table: string;
+	schema: string;
+	column: string;
+}
+
+export interface JsonAlterColumnDropNotNull {
+	type: 'alter_drop_column_not_null';
+	table: string;
+	schema: string;
+	column: string;
+}
+
+export interface JsonCreateRole {
+	type: 'create_role';
+	role: Role;
+}
+
+export interface JsonDropRole {
+	type: 'drop_role';
+	role: Role;
+}
+export interface JsonRenameRole {
+	type: 'rename_role';
+	from: Role;
+	to: Role;
+}
+
+export interface JsonAlterRole {
+	type: 'alter_role';
+	diff: DiffEntities['roles'];
+	role: Role;
+}
+
+export interface JsonDropValueFromEnum {
+	type: 'alter_type_drop_value';
+	deletedValues: string[];
+	enum: Enum;
+	columns: Column[];
+}
+
+export interface JsonCreateSequence {
+	type: 'create_sequence';
+	sequence: Sequence;
+}
+
+export interface JsonDropSequence {
+	type: 'drop_sequence';
+	sequence: Sequence;
+}
+
+export interface JsonMoveSequence {
+	type: 'move_sequence';
+	from: { name: string; schema: string | null };
+	to: { name: string; schema: string | null };
+}
+
+export interface JsonRenameSequence {
+	type: 'rename_sequence';
+	from: Sequence;
+	to: Sequence;
+}
+
+export interface JsonAlterSequence {
+	type: 'alter_sequence';
+	diff: DiffEntities['sequences'];
+	sequence: Sequence;
+}
+
+export interface JsonDropColumn {
+	type: 'drop_column';
+	column: Column;
+}
+
+export interface JsonAddColumn {
+	type: 'add_column';
+	column: Column;
+}
+
+export interface JsonCreatePolicy {
+	type: 'create_policy';
+	policy: Policy;
+}
+
+export interface JsonDropPolicy {
+	type: 'drop_policy';
+	policy: Policy;
+}
+
+export interface JsonRenamePolicy {
+	type: 'rename_policy';
+	from: Policy;
+	to: Policy;
+}
+
+export interface JsonAlterRLS {
+	type: 'alter_rls';
+	schema: string;
+	name: string;
+	isRlsEnabled: boolean;
+}
+
+export interface JsonAlterPolicy {
+	type: 'alter_policy';
+	diff: DiffEntities['policies'];
+	policy: Policy;
+}
+export interface JsonRecreatePolicy {
+	type: 'recreate_policy';
+	diff: DiffEntities['policies'];
+	policy: Policy;
+}
+
+export interface JsonCreateIndex {
+	type: 'create_index';
+	index: Index;
+	newTable: boolean;
+}
+
+export interface JsonRecreateIndex {
+	type: 'recreate_index';
+	diff: DiffEntities['indexes'];
+}
+
+export interface JsonCreateFK {
+	type: 'create_fk';
+	fk: ForeignKey;
+}
+
+export interface JsonDropFK {
+	type: 'drop_fk';
+	fk: ForeignKey;
+}
+
+export interface JsonRecreateFK {
+	type: 'recreate_fk';
+	fk: ForeignKey;
+	diff: DiffEntities['fks'];
+}
+
+export interface JsonAddCheck {
+	type: 'add_check';
+	check: CheckConstraint;
+}
+
+export interface JsonDropCheck {
+	type: 'drop_check';
+	check: CheckConstraint;
+}
+
+export interface JsonAlterCheck {
+	type: 'alter_check';
+	check: CheckConstraint;
+	diff: DiffEntities['checks'];
+}
+
+export interface JsonAddPrimaryKey {
+	type: 'add_pk';
+	pk: PrimaryKey;
+}
+
+export interface JsonDropPrimaryKey {
+	type: 'drop_pk';
+	pk: PrimaryKey;
+}
+
+export interface JsonRenameConstraint {
+	type: 'rename_constraint';
+	schema: string;
+	table: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonAlterPrimaryKey {
+	type: 'alter_pk';
+	pk: PrimaryKey;
+	diff: DiffEntities['pks'];
+}
+
+export interface JsonRecreatePrimaryKey {
+	type: 'recreate_pk';
+	right: PrimaryKey;
+	left: PrimaryKey;
+}
+
+export interface JsonMoveTable {
+	type: 'move_table';
+	name: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonAlterTableRemoveFromSchema {
+	type: 'remove_from_schema';
+	table: string;
+	schema: string;
+}
+
+export interface JsonAlterTableSetNewSchema {
+	type: 'set_new_schema';
+	table: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonDropIndex {
+	type: 'drop_index';
+	index: Index;
+}
+
+export interface JsonRenameIndex {
+	type: 'rename_index';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonRenameColumn {
+	type: 'rename_column';
+	from: Column;
+	to: Column;
+}
+
+export interface JsonAlterColumn {
+	type: 'alter_column';
+	to: Column;
+	wasEnum: boolean;
+	isEnum: boolean;
+	diff: DiffEntities['columns'];
+}
+
+export interface JsonRecreateColumn {
+	type: 'recreate_column';
+	diff: DiffEntities['columns'];
+}
+
+export interface JsonAlterColumnSetPrimaryKey {
+	type: 'alter_column_set_pk';
+	table: string;
+	schema: string;
+	column: string;
+}
+
+export interface JsonCreateSchema {
+	type: 'create_schema';
+	name: string;
+}
+
+export interface JsonDropSchema {
+	type: 'drop_schema';
+	name: string;
+}
+
+export interface JsonRenameSchema {
+	type: 'rename_schema';
+	from: Schema;
+	to: Schema;
+}
+
+export interface JsonCreateView {
+	type: 'create_view';
+	view: View;
+}
+
+export interface JsonDropView {
+	type: 'drop_view';
+	view: View;
+}
+
+export interface JsonRenameView {
+	type: 'rename_view';
+	from: View;
+	to: View;
+}
+
+export interface JsonMoveView {
+	type: 'move_view';
+	fromSchema: string;
+	toSchema: string;
+	view: View;
+}
+
+export interface JsonAlterView {
+	type: 'alter_view';
+	diff: DiffEntities['views'];
+	view: View;
+}
+
+export interface JsonRecreateView {
+	type: 'recreate_view';
+	from: View;
+	to: View;
+}
+
+export type JsonStatement =
+	| JsonCreateTable
+	| JsonDropTable
+	| JsonRenameTable
+	| JsonRenameColumn
+	| JsonAlterColumn
+	| JsonRecreateColumn
+	| JsonMoveView
+	| JsonAlterView
+	| JsonRecreateView
+	| JsonCreateEnum
+	| JsonDropEnum
+	| JsonMoveEnum
+	| JsonRenameEnum
+	| JsonRecreateEnum
+	| JsonAlterEnum
+	| JsonDropColumn
+	| JsonAddColumn
+	| JsonCreateIndex
+	| JsonDropIndex
+	| JsonRecreateIndex
+	| JsonRenameIndex
+	| JsonAddPrimaryKey
+	| JsonDropPrimaryKey
+	| JsonRenameConstraint
+	| JsonAlterPrimaryKey
+	| JsonCreateFK
+	| JsonDropFK
+	| JsonRecreateFK
+	| JsonDropCheck
+	| JsonAddCheck
+	| JsonCreateSchema
+	| JsonDropSchema
+	| JsonRenameSchema
+	| JsonMoveTable
+	| JsonAlterTableRemoveFromSchema
+	| JsonAlterTableSetNewSchema
+	| JsonAlterSequence
+	| JsonDropSequence
+	| JsonCreateSequence
+	| JsonMoveSequence
+	| JsonRenameSequence
+	| JsonDropPolicy
+	| JsonCreatePolicy
+	| JsonAlterPolicy
+	| JsonRecreatePolicy
+	| JsonRenamePolicy
+	| JsonAlterRLS
+	| JsonRenameRole
+	| JsonCreateRole
+	| JsonDropRole
+	| JsonAlterRole
+	| JsonCreateView
+	| JsonDropView
+	| JsonRenameView
+	| JsonAlterCheck
+	| JsonDropValueFromEnum
+	| JsonAlterColumnAddNotNull
+	| JsonAlterColumnDropNotNull
+	| JsonRecreatePrimaryKey;
+
+export const prepareStatement = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	args: Omit<TStatement, 'type'>,
+): Simplify<TStatement> => {
+	return {
+		type,
+		...args,
+	} as TStatement;
+};
diff --git a/drizzle-kit/src/dialects/cockroach/typescript.ts b/drizzle-kit/src/dialects/cockroach/typescript.ts
new file mode 100644
index 0000000000..a8f062c47b
--- /dev/null
+++ b/drizzle-kit/src/dialects/cockroach/typescript.ts
@@ -0,0 +1,706 @@
+import '../../@types/utils';
+import { toCamelCase } from 'drizzle-orm/casing';
+import type { Casing } from '../../cli/validations/common';
+import { assertUnreachable, trimChar } from '../../utils';
+import { inspect } from '../utils';
+import type { CheckConstraint, CockroachDDL, Column, ForeignKey, Index, Policy, PrimaryKey, ViewColumn } from './ddl';
+import { tableFromDDL } from './ddl';
+import { defaults, typeFor } from './grammar';
+
+// TODO: omit defaults opclass...
+const imports = [
+	'cockroachEnum',
+	'int2',
+	'int4',
+	'int8',
+	'bool',
+	'varchar',
+	'char',
+	'decimal',
+	'real',
+	'json',
+	'jsonb',
+	'time',
+	'timestamp',
+	'date',
+	'interval',
+	'inet',
+	'uuid',
+	'vector',
+	'bit',
+	'geometry',
+	'float',
+	'string',
+	'text',
+	'varbit',
+	'customType',
+] as const;
+export type Import = (typeof imports)[number];
+
+const cockroachImportsList = new Set(['cockroachTable', ...imports]);
+
+const objToStatement2 = (json: { [s: string]: unknown }) => {
+	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
+
+	const keys = Object.keys(json);
+	if (keys.length === 0) return;
+
+	let statement = '{ ';
+	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
+	statement += ' }';
+	return statement;
+};
+
+// const intervalStrToObj = (str: string) => {
+// 	if (str.startsWith('interval(')) {
+// 		return {
+// 			precision: Number(str.substring('interval('.length, str.length - 1)),
+// 		};
+// 	}
+// 	const splitted = str.split(' ');
+// 	if (splitted.length === 1) {
+// 		return {};
+// 	}
+// 	const rest = splitted.slice(1, splitted.length).join(' ');
+// 	if (possibleIntervals.includes(rest)) {
+// 		return { fields: `"${rest}"` };
+// 	}
+
+// 	for (const s of possibleIntervals) {
+// 		if (rest.startsWith(`${s}(`)) {
+// 			return {
+// 				fields: `"${s}"`,
+// 				precision: Number(rest.substring(s.length + 1, rest.length - 1)),
+// 			};
+// 		}
+// 	}
+// 	return {};
+// };
+
+const relations = new Set<string>();
+
+const escapeColumnKey = (value: string) => {
+	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
+		return `"${value}"`;
+	}
+	return value;
+};
+
+const withCasing = (value: string, casing: Casing) => {
+	if (casing === 'preserve') {
+		return escapeColumnKey(value);
+	}
+	if (casing === 'camel') {
+		return escapeColumnKey(toCamelCase(value));
+	}
+
+	assertUnreachable(casing);
+};
+
+const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
+	if (casing === 'preserve') {
+		return '';
+	}
+	if (casing === 'camel') {
+		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
+	}
+
+	assertUnreachable(casing);
+};
+
+// export const relationsToTypeScriptForStudio = (
+// 	schema: Record<string, Record<string, AnyCockroachTable<{}>>>,
+// 	relations: Record<string, Relations<string, Relations<string, Record<string, Relation<string>>>>>,
+// ) => {
+// 	const relationalSchema: Record<string, unknown> = {
+// 		...Object.fromEntries(
+// 			Object.entries(schema)
+// 				.map(([key, val]) => {
+// 					// have unique keys across schemas
+// 					const mappedTableEntries = Object.entries(val).map((tableEntry) => {
+// 						return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
+// 					});
+
+// 					return mappedTableEntries;
+// 				})
+// 				.flat(),
+// 		),
+// 		...relations,
+// 	};
+
+// 	const relationsConfig = extractTablesRelationalConfig(relationalSchema, createTableRelationsHelpers);
+
+// 	let result = '';
+
+// 	function findColumnKey(table: AnyCockroachTable, columnName: string) {
+// 		for (const tableEntry of Object.entries(table)) {
+// 			const key = tableEntry[0];
+// 			const value = tableEntry[1];
+
+// 			if (value.name === columnName) {
+// 				return key;
+// 			}
+// 		}
+// 	}
+
+// 	Object.values(relationsConfig.tables).forEach((table) => {
+// 		const tableName = table.tsName.split('.')[1];
+// 		const relations = table.relations;
+// 		let hasRelations = false;
+// 		let relationsObjAsStr = '';
+// 		let hasOne = false;
+// 		let hasMany = false;
+
+// 		Object.values(relations).forEach((relation) => {
+// 			hasRelations = true;
+
+// 			if (is(relation, Many)) {
+// 				hasMany = true;
+// 				relationsObjAsStr += `\t\t${relation.fieldName}: many(${
+// 					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
+// 				}${typeof relation.relationName !== 'undefined' ? `, { relationName: "${relation.relationName}"}` : ''}),`;
+// 			}
+
+// 			if (is(relation, One)) {
+// 				hasOne = true;
+// 				relationsObjAsStr += `\t\t${relation.fieldName}: one(${
+// 					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
+// 				}, { fields: [${
+// 					relation.config?.fields.map(
+// 						(c) =>
+// 							`${relationsConfig.tableNamesMap[getTableName(relation.sourceTable)].split('.')[1]}.${
+// 								findColumnKey(relation.sourceTable, c.name)
+// 							}`,
+// 					)
+// 				}], references: [${
+// 					relation.config?.references.map(
+// 						(c) =>
+// 							`${relationsConfig.tableNamesMap[getTableName(relation.referencedTable)].split('.')[1]}.${
+// 								findColumnKey(relation.referencedTable, c.name)
+// 							}`,
+// 					)
+// 				}]${typeof relation.relationName !== 'undefined' ? `, relationName: "${relation.relationName}"` : ''}}),`;
+// 			}
+// 		});
+
+// 		if (hasRelations) {
+// 			result += `export const ${tableName}Relation = relations(${tableName}, ({${hasOne ? 'one' : ''}${
+// 				hasOne && hasMany ? ', ' : ''
+// 			}${hasMany ? 'many' : ''}}) => ({
+//         ${relationsObjAsStr}
+//       }));\n`;
+// 		}
+// 	});
+
+// 	return result;
+// };
+
+function generateIdentityParams(column: Column) {
+	if (column.identity === null) return '';
+	const identity = column.identity;
+
+	const tuples = [];
+
+	if (identity.startWith && defaults.identity.startWith !== identity.startWith) {
+		tuples.push(['startWith', identity.startWith]);
+	}
+	if (identity.increment && defaults.identity.increment !== identity.increment) {
+		tuples.push(['increment', identity.increment]);
+	}
+	if (identity.minValue && defaults.identity.min !== identity.minValue) tuples.push(['minValue', identity.minValue]);
+	if (identity.maxValue && defaults.identity.maxFor(column.type) !== identity.maxValue) {
+		tuples.push(['maxValue', identity.maxValue]);
+	}
+	if (identity.cache && defaults.identity.cache !== identity.cache) tuples.push(['cache', identity.cache]);
+
+	const params = tuples.length > 0 ? `{ ${tuples.map((x) => `${x[0]}: ${x[1]}`).join(' ,')} }` : '';
+
+	if (identity?.type === 'always') {
+		return `.generatedAlwaysAsIdentity(${params})`;
+	}
+	return `.generatedByDefaultAsIdentity(${params})`;
+}
+
+export const paramNameFor = (name: string, schema: string | null) => {
+	const schemaSuffix = schema && schema !== 'public' ? `In${schema.capitalise()}` : '';
+	return `${name}${schemaSuffix}`;
+};
+
+export const ddlToTypeScript = (ddl: CockroachDDL, columnsForViews: ViewColumn[], casing: Casing) => {
+	const tableFn = `cockroachTable`;
+	for (const fk of ddl.fks.list()) {
+		relations.add(`${fk.table}-${fk.tableTo}`);
+	}
+
+	const schemas = Object.fromEntries(
+		ddl.schemas
+			.list()
+			.filter((it) => it.name !== 'public')
+			.map((it) => {
+				return [it.name, withCasing(it.name, casing)];
+			}),
+	);
+
+	const enumTypes = new Set(ddl.enums.list().map((x) => `${x.schema}.${x.name}`));
+
+	const imports = new Set<string>();
+	const vcs = columnsForViews.map((it) => ({ entityType: 'viewColumns' as const, ...it }));
+	const entities = [...ddl.entities.list(), ...vcs];
+	for (const x of entities) {
+		if (x.entityType === 'schemas' && x.name !== 'public') imports.add('cockroachSchema');
+		if (x.entityType === 'enums' && x.schema === 'public') imports.add('cockroachEnum');
+		if (x.entityType === 'tables') imports.add(tableFn);
+
+		if (x.entityType === 'indexes') {
+			if (x.isUnique) imports.add('uniqueIndex');
+			else imports.add('index');
+		}
+
+		if (x.entityType === 'fks') {
+			imports.add('foreignKey');
+
+			if (isCyclic(x) && !isSelf(x)) imports.add('type AnyCockroachColumn');
+		}
+		if (x.entityType === 'pks') imports.add('primaryKey');
+		if (x.entityType === 'checks') imports.add('check');
+		if (x.entityType === 'views' && x.schema === 'public') {
+			if (x.materialized) imports.add('cockroachMaterializedView');
+			else imports.add('cockroachView');
+		}
+
+		if (x.entityType === 'columns' || x.entityType === 'viewColumns') {
+			let patched = x.type.replace('[]', '');
+			const isEnum = Boolean(x.typeSchema);
+			const grammarType = typeFor(x.type, isEnum);
+			if (grammarType) imports.add(grammarType.drizzleImport());
+			if (cockroachImportsList.has(patched)) imports.add(patched);
+		}
+
+		if (x.entityType === 'sequences' && x.schema === 'public') imports.add('cockroachSequence');
+		if (x.entityType === 'enums' && x.schema === 'public') imports.add('cockroachEnum');
+		if (x.entityType === 'policies') imports.add('cockroachPolicy');
+		if (x.entityType === 'roles') imports.add('cockroachRole');
+	}
+
+	const enumStatements = ddl.enums
+		.list()
+		.map((it) => {
+			const enumSchema = schemas[it.schema];
+			// const func = schema || schema === "public" ? "cockroachTable" : schema;
+			const paramName = paramNameFor(it.name, enumSchema);
+
+			const func = enumSchema ? `${enumSchema}.enum` : 'cockroachEnum';
+
+			const values = Object.values(it.values)
+				.map((it) => {
+					return `\`${it.replaceAll('\\', '\\\\').replace('`', '\\`')}\``;
+				})
+				.join(', ');
+			return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", [${values}])\n`;
+		})
+		.join('')
+		.concat('\n');
+
+	const sequencesStatements = ddl.sequences
+		.list()
+		.map((it) => {
+			const seqSchema = schemas[it.schema];
+			const paramName = paramNameFor(it.name, seqSchema);
+
+			const func = seqSchema ? `${seqSchema}.sequence` : 'cockroachSequence';
+
+			let params = '';
+			if (it.startWith) params += `, startWith: "${it.startWith}"`;
+			if (it.incrementBy) params += `, increment: "${it.incrementBy}"`;
+			if (it.minValue) params += `, minValue: "${it.minValue}"`;
+			if (it.maxValue) params += `, maxValue: "${it.maxValue}"`;
+			if (it.cacheSize) params += `, cache: "${it.cacheSize}"`;
+			else params += `, cycle: false`;
+
+			params = params ? `, { ${trimChar(params, ',')} }` : '';
+
+			return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}"${params})\n`;
+		})
+		.join('')
+		.concat('');
+
+	const schemaStatements = Object.entries(schemas)
+		.map((it) => {
+			return `export const ${it[1]} = cockroachSchema("${it[0]}");\n`;
+		})
+		.join('');
+
+	const rolesNameToTsKey: Record<string, string> = {};
+	const rolesStatements = ddl.roles.list().map((it) => {
+		const identifier = withCasing(it.name, casing);
+		rolesNameToTsKey[it.name] = identifier;
+		const params = {
+			...(it.createDb ? { createDb: true } : {}),
+			...(it.createRole ? { createRole: true } : {}),
+		};
+		const paramsString = inspect(params);
+		const comma = paramsString ? ', ' : '';
+
+		return `export const ${identifier} = cockroachRole("${it.name}"${comma}${paramsString});\n`;
+	})
+		.join('');
+
+	const tableStatements = ddl.tables.list().map((it) => {
+		const tableSchema = schemas[it.schema];
+		const paramName = paramNameFor(it.name, tableSchema);
+		const table = tableFromDDL(it, ddl);
+		const columns = ddl.columns.list({ schema: table.schema, table: table.name });
+		const fks = ddl.fks.list({ schema: table.schema, table: table.name });
+
+		let func = tableSchema ? `${tableSchema}.table` : tableFn;
+		func += table.isRlsEnabled ? '.withRLS' : '';
+		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${table.name}", {\n`;
+		statement += createTableColumns(columns, table.pk, fks, enumTypes, schemas, casing);
+		statement += '}';
+
+		// copied from pg
+		const filteredFKs = table.fks.filter((it) => {
+			return it.columns.length > 1 || isSelf(it);
+		});
+
+		const hasCallback = table.indexes.length > 0 || filteredFKs.length > 0 || table.policies.length > 0
+			|| (table.pk && table.pk.columns.length > 1) || table.checks.length > 0;
+
+		if (hasCallback) {
+			statement += ', ';
+			statement += '(table) => [\n';
+			// TODO: or pk has non-default name
+			statement += table.pk && table.pk.columns.length > 1 ? createTablePK(table.pk, casing) : '';
+			statement += createTableFKs(filteredFKs, schemas, casing);
+			statement += createTableIndexes(table.name, table.indexes, casing);
+			statement += createTablePolicies(table.policies, casing, rolesNameToTsKey);
+			statement += createTableChecks(table.checks, casing);
+			statement += ']';
+		}
+		statement += ');';
+		return statement;
+	});
+
+	const viewsStatements = Object.values(ddl.views.list())
+		.map((it) => {
+			const viewSchema = schemas[it.schema];
+			const paramName = paramNameFor(it.name, viewSchema);
+
+			// TODO: casing?
+			const func = it.schema !== 'public'
+				? (it.materialized ? `${viewSchema}.materializedView` : `${viewSchema}.view`)
+				: it.materialized
+				? 'cockroachMaterializedView'
+				: 'cockroachView';
+
+			const as = `sql\`${it.definition}\``;
+
+			const viewColumns = columnsForViews.filter((x) => x.schema === it.schema && x.view === it.name);
+
+			const columns = createViewColumns(viewColumns, enumTypes, casing);
+
+			let statement = `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", {${columns}})`;
+			statement += `.as(${as});`;
+
+			return statement;
+		})
+		.join('\n\n');
+
+	const uniqueCockroachImports = [...imports];
+
+	const importsTs = `import { ${uniqueCockroachImports.join(', ')} } from "drizzle-orm/cockroach-core"
+import { sql } from "drizzle-orm"\n\n`;
+
+	let decalrations = schemaStatements;
+	decalrations += rolesStatements;
+	decalrations += enumStatements;
+	decalrations += sequencesStatements;
+	decalrations += '\n';
+	decalrations += tableStatements.join('\n\n');
+	decalrations += '\n';
+	decalrations += viewsStatements;
+
+	const file = importsTs + decalrations;
+
+	// for drizzle studio query runner
+	const schemaEntry = `
+    {
+      ${
+		Object.values(ddl.tables)
+			.map((it) => withCasing(it.name, casing))
+			.join(',\n')
+	}
+    }
+  `;
+
+	return { file, imports: importsTs, decalrations, schemaEntry };
+};
+
+const isCyclic = (fk: ForeignKey) => {
+	const key = `${fk.table}-${fk.tableTo}`;
+	const reverse = `${fk.tableTo}-${fk.table}`;
+	return relations.has(key) && relations.has(reverse);
+};
+
+const isSelf = (fk: ForeignKey) => {
+	return fk.table === fk.tableTo;
+};
+
+const column = (
+	type: string,
+	dimensions: number,
+	name: string,
+	typeSchema: string | null,
+	casing: Casing,
+	def: Column['default'],
+) => {
+	const isEnum = Boolean(typeSchema);
+	const grammarType = typeFor(type, isEnum);
+
+	const { options, default: defaultValue, customType } = dimensions > 0
+		? grammarType.toArrayTs(type, def ?? null)
+		: grammarType.toTs(type, def ?? null);
+
+	const dbName = dbColumnName({ name, casing });
+	const opts = inspect(options);
+	const comma = (dbName && opts) ? ', ' : '';
+
+	let columnStatement = `${withCasing(name, casing)}: ${
+		isEnum ? withCasing(paramNameFor(type, typeSchema), casing) : grammarType.drizzleImport()
+	}${customType ? `({ dataType: () => '${customType}' })` : ''}(${dbName}${comma}${opts})`;
+	columnStatement += '.array()'.repeat(dimensions);
+
+	if (defaultValue) columnStatement += `.default(${defaultValue})`;
+	return columnStatement;
+};
+
+const createViewColumns = (columns: ViewColumn[], enumTypes: Set<string>, casing: Casing) => {
+	let statement = '';
+
+	columns.forEach((it) => {
+		const columnStatement = column(it.type, it.dimensions, it.name, it.typeSchema, casing, null);
+		statement += '\t';
+		statement += columnStatement;
+		// Provide just this in column function
+		statement += '.array()'.repeat(it.dimensions);
+		statement += it.notNull ? '.notNull()' : '';
+		statement += ',\n';
+	});
+	return statement;
+};
+
+const createTableColumns = (
+	columns: Column[],
+	primaryKey: PrimaryKey | null,
+	fks: ForeignKey[],
+	enumTypes: Set<string>,
+	schemas: Record<string, string>,
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	// no self refs and no cyclic
+	const oneColumnsFKs = Object.values(fks)
+		.filter((it) => {
+			return !isSelf(it);
+		})
+		.filter((it) => it.columns.length === 1);
+
+	const fkByColumnName = oneColumnsFKs.reduce(
+		(res, it) => {
+			const arr = res[it.columns[0]] || [];
+			arr.push(it);
+			res[it.columns[0]] = arr;
+			return res;
+		},
+		{} as Record<string, ForeignKey[]>,
+	);
+
+	for (const it of columns) {
+		const { name, type, dimensions, default: def, identity, generated, typeSchema } = it;
+		const stripped = type.replaceAll('[]', '');
+		const isEnum = Boolean(typeSchema);
+		const grammarType = typeFor(stripped, isEnum);
+
+		const { options, default: defaultValue, customType } = dimensions > 0
+			? grammarType.toArrayTs(type, def ?? null)
+			: grammarType.toTs(type, def ?? null);
+
+		const dbName = dbColumnName({ name, casing });
+		const opts = inspect(options);
+		const comma = (dbName && opts) ? ', ' : '';
+
+		const pk = primaryKey && primaryKey.columns.length === 1 && primaryKey.columns[0] === it.name
+			? primaryKey
+			: null;
+
+		let columnStatement = `${withCasing(name, casing)}: ${
+			isEnum ? withCasing(paramNameFor(type, typeSchema), casing) : grammarType.drizzleImport()
+		}${customType ? `({ dataType: () => '${customType}' })` : ''}(${dbName}${comma}${opts})`;
+		columnStatement += '.array()'.repeat(dimensions);
+		if (defaultValue) columnStatement += defaultValue.startsWith('.') ? defaultValue : `.default(${defaultValue})`;
+		if (pk) columnStatement += '.primaryKey()';
+		if (it.notNull && !it.identity && !pk) columnStatement += '.notNull()';
+		if (identity) columnStatement += generateIdentityParams(it);
+		if (generated) columnStatement += `.generatedAlwaysAs(sql\`${generated.as}\`)`;
+
+		statement += '\t';
+		statement += columnStatement;
+		// Provide just this in column function
+
+		const fks = fkByColumnName[it.name];
+		// Andrii: I switched it off until we will get a custom naem setting in references
+		if (fks) {
+			const fksStatement = fks
+				.map((it) => {
+					const onDelete = it.onDelete && it.onDelete !== 'NO ACTION' ? it.onDelete.toLowerCase() : null;
+					const onUpdate = it.onUpdate && it.onUpdate !== 'NO ACTION' ? it.onUpdate.toLowerCase() : null;
+					const params = { onDelete, onUpdate };
+
+					const typeSuffix = isCyclic(it) ? ': AnyCockroachColumn' : '';
+
+					const paramsStr = objToStatement2(params);
+					const tableSchema = schemas[it.schemaTo || ''];
+					const paramName = paramNameFor(it.tableTo, tableSchema);
+					if (paramsStr) {
+						return `.references(()${typeSuffix} => ${
+							withCasing(
+								paramName,
+								casing,
+							)
+						}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
+					}
+					return `.references(()${typeSuffix} => ${
+						withCasing(
+							paramName,
+							casing,
+						)
+					}.${withCasing(it.columnsTo[0], casing)})`;
+				})
+				.join('');
+			statement += fksStatement;
+		}
+
+		statement += ',\n';
+	}
+
+	return statement;
+};
+
+const createTableIndexes = (tableName: string, idxs: Index[], casing: Casing): string => {
+	let statement = '';
+
+	idxs.forEach((it) => {
+		// TODO: cc: @AndriiSherman we have issue when index is called as table called
+		// let idxKey = it.name.startsWith(tableName) && it.name !== tableName ? it.name.slice(tableName.length + 1) : it.name;
+		// idxKey = idxKey.endsWith('_index') ? idxKey.slice(0, -'_index'.length) + '_idx' : idxKey;
+		// idxKey = withCasing(idxKey, casing);
+		// const indexGeneratedName = indexName(
+		// 	tableName,
+		// 	it.columns.map((it) => it.value),
+		// );
+
+		const name = it.nameExplicit ? it.name : '';
+		// const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
+
+		statement += it.isUnique ? '\tuniqueIndex(' : '\tindex(';
+		statement += name ? `"${name}")` : ')';
+
+		statement += `.using("${it.method}", ${
+			it.columns
+				.map((it) => {
+					if (it.isExpression) {
+						return `sql\`${it.value}\``;
+					} else {
+						return `table.${withCasing(it.value, casing)}${it.asc ? '.asc()' : '.desc()'}`;
+					}
+				})
+				.join(', ')
+		})`;
+		statement += it.where ? `.where(sql\`${it.where}\`)` : '';
+
+		statement += `,\n`;
+	});
+
+	return statement;
+};
+
+const createTablePK = (it: PrimaryKey, casing: Casing): string => {
+	let statement = '\tprimaryKey({ columns: [';
+	statement += `${
+		it.columns
+			.map((c) => {
+				return `table.${withCasing(c, casing)}`;
+			})
+			.join(', ')
+	}`;
+	statement += `]${it.nameExplicit ? `, name: "${it.name}"` : ''}}),\n`;
+	return statement;
+};
+
+// get a map of db role name to ts key
+// if to by key is in this map - no quotes, otherwise - quotes
+
+const createTablePolicies = (
+	policies: Policy[],
+	casing: Casing,
+	rolesNameToTsKey: Record<string, string> = {},
+): string => {
+	let statement = '';
+
+	policies.forEach((it) => {
+		const mappedItTo = it.roles.map((v) => {
+			return rolesNameToTsKey[v] ? withCasing(rolesNameToTsKey[v], casing) : `"${v}"`;
+		});
+
+		const tuples = [];
+		if (it.as === 'RESTRICTIVE') tuples.push(['as', `"${it.as.toLowerCase}"`]);
+		if (it.for !== 'ALL') tuples.push(['for', `"${it.for.toLowerCase()}"`]);
+		if (!(mappedItTo.length === 1 && mappedItTo[0] === '"public"')) {
+			tuples.push(['to', `[${mappedItTo.map((x) => `${x}`).join(', ')}]`]);
+		}
+		if (it.using !== null) tuples.push(['using', `sql\`${it.using}\``]);
+		if (it.withCheck !== null) tuples.push(['withCheck', `sql\`${it.withCheck}\``]);
+		const opts = tuples.length > 0 ? `, { ${tuples.map((x) => `${x[0]}: ${x[1]}`).join(', ')} }` : '';
+		statement += `\tcockroachPolicy("${it.name}"${opts}),\n`;
+	});
+
+	return statement;
+};
+
+const createTableChecks = (checkConstraints: CheckConstraint[], _casing: Casing) => {
+	let statement = '';
+
+	checkConstraints.forEach((it) => {
+		statement += 'check(';
+		statement += `"${it.name}", `;
+		statement += `sql\`${it.value}\`)`;
+		statement += `,`;
+	});
+
+	return statement;
+};
+
+const createTableFKs = (fks: ForeignKey[], schemas: Record<string, string>, casing: Casing): string => {
+	let statement = '';
+
+	fks.forEach((it) => {
+		const tableSchema = it.schemaTo === 'public' ? '' : schemas[it.schemaTo];
+		const paramName = paramNameFor(it.tableTo, tableSchema);
+
+		const isSelf = it.tableTo === it.table;
+		const tableTo = isSelf ? 'table' : `${withCasing(paramName, casing)}`;
+		statement += `\tforeignKey({\n`;
+		statement += `\t\tcolumns: [${it.columns.map((i) => `table.${withCasing(i, casing)}`).join(', ')}],\n`;
+		statement += `\t\tforeignColumns: [${
+			it.columnsTo.map((i) => `${tableTo}.${withCasing(i, casing)}`).join(', ')
+		}],\n`;
+		statement += it.nameExplicit ? `\t\tname: "${it.name}"\n` : '';
+		statement += `\t})`;
+
+		statement += it.onUpdate && it.onUpdate !== 'NO ACTION' ? `.onUpdate("${it.onUpdate.toLowerCase()}")` : '';
+		statement += it.onDelete && it.onDelete !== 'NO ACTION' ? `.onDelete("${it.onDelete.toLowerCase()}")` : '';
+		statement += `,\n`;
+	});
+	return statement;
+};
diff --git a/drizzle-kit/src/dialects/common.ts b/drizzle-kit/src/dialects/common.ts
new file mode 100644
index 0000000000..1112390d52
--- /dev/null
+++ b/drizzle-kit/src/dialects/common.ts
@@ -0,0 +1,36 @@
+export type ResolverOutput<T> = {
+	created: T[];
+	deleted: T[];
+	renamedOrMoved: { from: T; to: T }[];
+};
+
+export type Resolver<T extends { name: string; schema?: string; table?: string }> = (it: {
+	created: T[];
+	deleted: T[];
+}) => Promise<ResolverOutput<T>>;
+
+const dictionary = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+
+export const hash = (input: string, len: number = 12) => {
+	const dictLen = BigInt(dictionary.length);
+	const combinationsCount = BigInt(dictionary.length) ** BigInt(len);
+	const p = 53n;
+	let power = 1n;
+
+	let hash = 0n;
+	for (const ch of input) {
+		hash = (hash + (BigInt(ch.codePointAt(0) || 0) * power)) % combinationsCount;
+		power = (power * p) % combinationsCount;
+	}
+
+	const result = [] as string[];
+
+	let index = hash;
+	for (let i = len - 1; i >= 0; i--) {
+		const element = dictionary[Number(index % dictLen)]!;
+		result.unshift(element);
+		index = index / dictLen;
+	}
+
+	return result.join('');
+};
diff --git a/drizzle-kit/src/dialects/dialect.ts b/drizzle-kit/src/dialects/dialect.ts
new file mode 100644
index 0000000000..2551f81054
--- /dev/null
+++ b/drizzle-kit/src/dialects/dialect.ts
@@ -0,0 +1,999 @@
+type DataType = 'string' | 'string[]' | 'number' | 'boolean';
+
+type TypeMap = {
+	string: string;
+	number: number;
+	boolean: boolean;
+	'string[]': string[];
+};
+
+type Simplify<T> =
+	& {
+		[K in keyof T]: T[K];
+	}
+	& {};
+
+type Assume<T, U> = T extends U ? T : U;
+
+type ExtendedType =
+	| (`${Exclude<DataType, 'string[]'>}?` | DataType)
+	| 'required'
+	| [string, ...(string | null)[]]
+	| {
+		[K: string]: Exclude<ExtendedType, 'required'>;
+	}
+	| ([{
+		[K: string]: Exclude<ExtendedType, 'required'>;
+	}]);
+
+type InferField<T extends ExtendedType> = T extends (string | null)[] ? T[number]
+	: T extends [Record<string, ExtendedType>] ? {
+			[K in keyof T[0]]: InferField<T[0][K]>;
+		}[]
+	: T extends Record<string, ExtendedType> ?
+			| {
+				[K in keyof T]: InferField<T[K]>;
+			}
+			| null
+	: T extends `${infer Type extends DataType}?` ? TypeMap[Type] | null
+	: T extends DataType ? TypeMap[T]
+	: never;
+
+type Definition = Record<string, Schema>;
+
+type InferSchema<TSchema extends Schema> = Simplify<
+	{
+		-readonly [K in keyof TSchema]: K extends keyof Common ? Exclude<Common[K], null>
+			: InferField<Assume<TSchema[K], ExtendedType>>;
+	}
+>;
+
+type NullAsUndefined<TData extends Record<string, any>> =
+	& {
+		[K in keyof TData as null extends TData[K] ? K : never]: TData[K] | undefined;
+	}
+	& {
+		[K in keyof TData as null extends TData[K] ? never : K]: TData[K];
+	};
+
+type Schema =
+	& Record<string, ExtendedType>
+	& {
+		[K in keyof Common as null extends Common[K] ? K : never]?: 'required';
+	}
+	& {
+		[K in keyof Common as null extends Common[K] ? never : K]?: never;
+	}
+	& {
+		[K in `${keyof Common}?`]?: never;
+	}
+	& {
+		entityType?: never;
+		CONTAINS?: never;
+	};
+
+type Common = {
+	schema: string | null;
+	table: string | null;
+	name: string;
+};
+
+const commonConfig: Record<string, `${DataType}${'' | '?'}`> = {
+	schema: 'string?',
+	table: 'string?',
+	name: 'string',
+};
+
+type InferEntities<
+	TDefinition extends Definition,
+> = {
+	[K in keyof TDefinition]: Simplify<
+		& InferSchema<TDefinition[K]>
+		& {
+			[C in keyof Common as C extends keyof TDefinition[K] ? never : null extends Common[C] ? never : C]: Common[C];
+		}
+		& {
+			entityType: K;
+		}
+	>;
+};
+
+type Filter<TInput extends Record<string, any> = Record<string, any>> = {
+	[K in keyof TInput]?:
+		| TInput[K]
+		| (TInput[K] extends (any[] | null) ? {
+				CONTAINS: TInput[K][number];
+			}
+			: never);
+};
+
+type UpdateOperators<TInput extends Record<string, any>> = {
+	[K in keyof TInput]?:
+		| TInput[K]
+		| ((
+			item: TInput[K] extends any[] | null ? Exclude<TInput[K], null>[number] : TInput[K],
+		) => TInput[K] extends any[] | null ? Exclude<TInput[K], null>[number] : TInput[K]);
+};
+
+type CollectionStore = {
+	collection: Record<string, any>[];
+};
+
+function matchesFilters(item: Record<string, any>, filter: Filter): boolean {
+	for (const [k, v] of Object.entries(filter)) {
+		if (v === undefined) continue;
+		const target = item[k];
+
+		if ((v && typeof v === 'object' && v.CONTAINS !== undefined)) {
+			if (!Array.isArray(target)) return false;
+			if (!target.find((e) => isEqual(e, v.CONTAINS))) return false;
+		} else {
+			if (!isEqual(target, v)) return false;
+		}
+	}
+
+	return true;
+}
+
+function filterCollection(collection: Record<string, any>[], filter: Filter) {
+	return collection.filter((e) => matchesFilters(e, filter));
+}
+
+type CommonEntity = Common & {
+	entityType: string;
+};
+
+function getCompositeKey(
+	row: CommonEntity,
+): string {
+	return `${row.schema ?? ''}:${row.table ?? ''}:${row.name}:${row.entityType}`;
+}
+
+function findCompositeKey(dataSource: (CommonEntity)[], target: CommonEntity) {
+	const targetKey = getCompositeKey(target);
+	const match = dataSource.find((e) => getCompositeKey(e) === targetKey);
+
+	return match;
+}
+
+function findCompositeKeys(dataSource: (CommonEntity)[], target: CommonEntity) {
+	const targetKey = getCompositeKey(target);
+	const match = dataSource.filter((e) => getCompositeKey(e) === targetKey);
+
+	return match;
+}
+
+// function replaceValue(arr: Array<any>, target: any, update: any) {
+// 	for (var i = 0; i < arr.length; i++) {
+// 		if (arr[i] === target) {
+// 			arr[i] = update;
+// 		}
+// 	}
+// 	return arr;
+// }
+
+export type InferInsert<TShape extends Record<string, any>, TCommon extends boolean = false> = TShape extends
+	infer Shape ? Simplify<
+		TCommon extends true ? NullAsUndefined<
+				{
+					[
+						K in keyof Shape as K extends keyof Common ? (null extends Common[K] ? null extends Shape[K] ? never
+								: K
+								: K)
+							: K
+					]: Shape[K];
+				}
+			>
+			: Omit<
+				NullAsUndefined<
+					{
+						[
+							K in keyof TShape as K extends keyof Common ? (null extends Common[K] ? null extends TShape[K] ? never
+									: K
+									: K)
+								: K
+						]: TShape[K];
+					}
+				>,
+				'entityType'
+			>
+	>
+	: never;
+
+type PushFn<
+	TInput extends Record<string, any>,
+	TCommon extends boolean = false,
+> = (
+	input: InferInsert<TInput, TCommon>,
+	uniques?: TInput extends infer Input ? (Exclude<Assume<keyof Input, string>, 'entityType'>)[] : never,
+) => {
+	status: 'OK' | 'CONFLICT';
+	data: TInput extends [Record<string, any>, Record<string, any>, ...Record<string, any>[]] ? TInput[] : TInput;
+};
+type ListFn<TInput extends Record<string, any>> = (where?: Filter<TInput>) => TInput[];
+type OneFn<TInput extends Record<string, any>> = (where?: Filter<TInput>) => TInput | null;
+type UpdateFn<TInput extends Record<string, any>> = (
+	config: TInput extends infer Input extends Record<string, any>
+		? { set: Simplify<UpdateOperators<Omit<Input, 'entityType'>>>; where?: Filter<Input> }
+		: never,
+) => {
+	status: 'OK' | 'CONFLICT';
+	data: TInput[];
+};
+type DeleteFn<TInput extends Record<string, any>> = (
+	where?: TInput extends infer Input extends Record<string, any> ? Filter<Input> : never,
+) => TInput[];
+type ValidateFn<TInput extends Record<string, any>> = (data: unknown) => data is TInput;
+type HasDiffFn<
+	TSchema extends Record<string, any>,
+	TType extends string,
+> = (
+	input: DiffAlter<TSchema, TType>,
+) => boolean;
+
+type PushAllFn = (
+	items: Iterable<Record<string, any>>,
+) => { status: 'OK'; count: number } | { status: 'CONFLICT'; key: string };
+
+const generatePushAll: (configs: Record<string, Config>, store: CollectionStore, type?: string) => PushAllFn = (
+	configs,
+	store,
+	type,
+) => {
+	const nullsByType = new Map<string, Record<string, any>>();
+	const getNulls = (entityType: string) => {
+		let cached = nullsByType.get(entityType);
+		if (cached) return cached;
+		cached = Object.fromEntries(
+			Object.keys(configs[entityType]).map((e) => [e, null]),
+		);
+		nullsByType.set(entityType, cached);
+		return cached;
+	};
+
+	return (items) => {
+		const seen = new Set<string>();
+		for (const existing of store.collection as CommonEntity[]) {
+			seen.add(getCompositeKey(existing));
+		}
+
+		const prepared: Record<string, any>[] = [];
+		for (const input of items) {
+			const filtered: Record<string, any> = {};
+			for (const k in input) {
+				if (input[k] !== undefined) filtered[k] = input[k];
+			}
+			const entityType = (type ?? filtered.entityType) as string;
+			const mapped = { ...getNulls(entityType), ...filtered, entityType };
+			const key = getCompositeKey(mapped as CommonEntity);
+			if (seen.has(key)) {
+				return { status: 'CONFLICT', key };
+			}
+			seen.add(key);
+			prepared.push(mapped);
+		}
+
+		for (const row of prepared) store.collection.push(row);
+		return { status: 'OK', count: prepared.length };
+	};
+};
+
+const generateInsert: (configs: Record<string, Config>, store: CollectionStore, type?: string) => PushFn<any> = (
+	configs,
+	store,
+	type,
+) => {
+	let nulls = type
+		? Object.fromEntries(
+			Object.keys(configs[type]).filter((e) => !commonConfig[e] || !(commonConfig[e] as string).endsWith('?')).map((
+				e,
+			) => [e, null]),
+		)
+		: undefined;
+
+	return (input, uniques) => {
+		const filteredElement = Object.fromEntries(Object.entries(input).filter(([_, value]) => value !== undefined));
+		const localType = (type ?? filteredElement.entityType) as string;
+		const localNulls = nulls ?? Object.fromEntries(
+			Object.keys(configs[localType]).map((
+				e,
+			) => [e, null]),
+		);
+
+		const mapped = {
+			...localNulls,
+			...filteredElement,
+			entityType: localType,
+		};
+
+		const conflict = uniques
+			? store.collection.find((e) => {
+				if ((e as CommonEntity).entityType !== mapped.entityType) return false;
+				for (const k of uniques) {
+					if (k in mapped && !isEqual(mapped[k as keyof typeof mapped], e[k])) return false;
+				}
+
+				return true;
+			})
+			: findCompositeKey(store.collection as CommonEntity[], mapped as CommonEntity);
+		if (conflict) {
+			return { status: 'CONFLICT', data: conflict };
+		}
+
+		store.collection.push(mapped);
+
+		return { status: 'OK', data: mapped };
+	};
+};
+
+const generateList: (store: CollectionStore, type?: string) => ListFn<any> = (
+	store,
+	type,
+) => {
+	return (where) => {
+		const from = type
+			? filterCollection(store.collection, {
+				entityType: type,
+			})
+			: store.collection;
+
+		if (!where) return from;
+
+		return (filterCollection(from, where));
+	};
+};
+
+const generateOne: (store: CollectionStore, type?: string) => OneFn<any> = (
+	store,
+	type,
+) => {
+	return (where) => {
+		const from = type
+			? filterCollection(store.collection, {
+				entityType: type,
+			})
+			: store.collection;
+
+		if (!where) return from[0] ?? null;
+
+		return (filterCollection(from, where)[0] ?? null);
+	};
+};
+
+const generateUpdate: (store: CollectionStore, type?: string) => UpdateFn<any> = (
+	store,
+	type,
+) => {
+	return ({ set, where }) => {
+		const filter = type
+			? {
+				...where,
+				entityType: type,
+			}
+			: where;
+
+		const targets = filter ? filterCollection(store.collection, filter) : store.collection;
+		const entries = Object.entries(set);
+		const newItems: {
+			index: number;
+			item: Record<string, any>;
+		}[] = [];
+		let i = 0;
+		const dupes: Record<string, any>[] = [];
+
+		for (const item of targets) {
+			const newItem: Record<string, any> = { ...item };
+
+			for (const [k, v] of entries) {
+				if (!(k in item)) continue;
+				const target = item[k];
+
+				newItem[k] = typeof v === 'function'
+					? (Array.isArray(target))
+						? target.map(v)
+						: v(target)
+					: v;
+			}
+
+			const dupe = findCompositeKeys(store.collection as CommonEntity[], newItem as CommonEntity).filter((e) =>
+				e !== item
+			);
+
+			dupes.push(...dupe.filter((e) => !dupes.find((d) => d === e)));
+
+			if (!dupe.length) {
+				newItems.push({
+					item: newItem,
+					index: i++,
+				});
+			}
+		}
+
+		// Swap this
+		if (dupes.length) {
+			return {
+				status: 'CONFLICT',
+				data: dupes,
+			};
+		}
+
+		// ^ with this
+		// If you want non-conflicting changes to apply regardless of conflicts' existence
+		for (const { index, item } of newItems) {
+			Object.assign(targets[index]!, item);
+		}
+
+		return { status: 'OK', data: targets };
+	};
+};
+
+const generateDelete: (store: CollectionStore, type?: string) => DeleteFn<any> = (
+	store,
+	type,
+) => {
+	return (where) => {
+		const updatedCollection = [] as Record<string, any>[];
+		const deleted = [] as Record<string, any>[];
+
+		const filter = type
+			? {
+				...where,
+				entityType: type,
+			}
+			: where;
+
+		if (!filter) {
+			store.collection = updatedCollection;
+
+			return deleted;
+		}
+
+		store.collection.forEach((e) => {
+			if (matchesFilters(e, filter)) deleted.push(e);
+			else updatedCollection.push(e);
+		});
+
+		store.collection = updatedCollection;
+
+		return deleted;
+	};
+};
+
+const generateHasDiff: (
+	lengths: Record<string, number>,
+) => HasDiffFn<any, any> = (
+	lengths,
+) => {
+	return (input) => {
+		const type = input.entityType;
+		const length = lengths[type];
+
+		return Object.keys(input).length > length;
+	};
+};
+
+function validate(data: any, schema: Config, deep = false): boolean {
+	if (typeof data !== 'object' || data === null) return false;
+
+	for (const k of Array.from(new Set([...Object.keys(data), ...Object.keys(schema)]))) {
+		if (!deep && k === 'entityType') continue;
+
+		if (!schema[k]) return false;
+
+		if (schema[k] === 'string[]') {
+			if (!Array.isArray(data[k])) return false;
+
+			if (!data[k].every((e) => typeof e === 'string')) return false;
+		} else if (typeof schema[k] === 'string') {
+			const isNullable = schema[k].endsWith('?');
+			if (data[k] === null && !isNullable) return false;
+			if (data[k] !== null && typeof data[k] !== removeQuestionMark(schema[k])) return false;
+		} else if (Array.isArray(schema[k])) {
+			if (typeof schema[k][0] === 'string') {
+				if (!schema[k].some((e) => e === data[k])) return false;
+			} else {
+				if (!Array.isArray(data[k])) return false;
+				if (
+					!data[k].every(
+						(e) => validate(e, (schema[k] as [Config])[0]),
+						true,
+					)
+				) return false;
+			}
+		} else {
+			if (data[k] !== null && !validate(data[k], schema[k], true)) return false;
+		}
+	}
+
+	return true;
+}
+
+const generateValidate: (configs: Record<string, Config>, type?: string) => ValidateFn<any> = (
+	configs,
+	type,
+) => {
+	return ((data) => {
+		if (typeof data !== 'object' || data === null) return false;
+
+		const localType = type ?? (<any> data).entityType as string;
+		if (typeof localType !== 'string' || (<any> data).entityType !== localType) return false;
+
+		const config = configs[localType];
+		if (!config) return false;
+
+		return validate(data, config);
+	}) as ValidateFn<any>;
+};
+
+type GenerateProcessors<
+	T extends AnyDbConfig,
+	TCommon extends boolean = false,
+	TTypes extends Record<string, any> = T['types'],
+> = {
+	[K in keyof TTypes]: {
+		push: PushFn<TTypes[K], TCommon>;
+		pushAll: PushAllFn;
+		list: ListFn<TTypes[K]>;
+		one: OneFn<TTypes[K]>;
+		update: UpdateFn<TTypes[K]>;
+		delete: DeleteFn<TTypes[K]>;
+		validate: ValidateFn<TTypes[K]>;
+		hasDiff: HasDiffFn<T['definition'], K & string>;
+	};
+};
+
+function initSchemaProcessors<T extends Omit<DbConfig<any>, 'diffs'>, TCommon extends boolean>(
+	{ entities }: T,
+	store: CollectionStore,
+	common: TCommon,
+	extraConfigs?: Record<string, Config>,
+): GenerateProcessors<T, TCommon> {
+	const entries = Object.entries(entities);
+
+	// left, right, entityType, diffType
+	const extraKeys = 4;
+
+	const lengths: Record<string, number> = Object.fromEntries(
+		Object.entries(common ? extraConfigs! : entities).map(([k, v]) => {
+			// name, table?, schema?
+			const commonCount = Object.keys(v).filter((e) => e in commonConfig).length;
+
+			return [k, commonCount + extraKeys];
+		}),
+	);
+
+	return Object.fromEntries(entries.map(([k, _v]) => {
+		return [k, {
+			push: generateInsert(common ? extraConfigs! : entities, store, common ? undefined : k),
+			pushAll: generatePushAll(common ? extraConfigs! : entities, store, common ? undefined : k),
+			list: generateList(store, common ? undefined : k),
+			one: generateOne(store, common ? undefined : k),
+			update: generateUpdate(store, common ? undefined : k),
+			delete: generateDelete(store, common ? undefined : k),
+			validate: generateValidate(common ? extraConfigs! : entities, common ? undefined : k),
+			hasDiff: generateHasDiff(lengths),
+		}];
+	})) as GenerateProcessors<T, TCommon>;
+}
+
+export type Config = {
+	[K: string]: `${Exclude<DataType, 'string['>}?` | DataType | [string, ...string[]] | Config | [Config];
+};
+
+type DbConfig<TDefinition extends Definition> = {
+	/** Type-level fields only, do not attempt to access at runtime */
+	types: InferEntities<TDefinition>;
+	/** Type-level fields only, do not attempt to access at runtime */
+	definition: TDefinition;
+	entities: {
+		[K in keyof TDefinition]: Config;
+	};
+	diffs: {
+		alter: {
+			[K in keyof TDefinition | 'entities']: DiffAlter<TDefinition, K>;
+		};
+		create: {
+			[K in keyof TDefinition | 'entities']: DiffCreate<TDefinition, K>;
+		};
+		drop: {
+			[K in keyof TDefinition | 'entities']: DiffDrop<TDefinition, K>;
+		};
+		createdrop: {
+			[K in keyof TDefinition | 'entities']: DiffCreate<TDefinition, K> | DiffDrop<TDefinition, K>;
+		};
+		all: {
+			[K in keyof TDefinition | 'entities']: DiffStatement<TDefinition, K>;
+		};
+	};
+	store: CollectionStore;
+};
+
+type AnyDbConfig = {
+	/** Type-level fields only, do not attempt to access at runtime */
+	types: Record<string, Record<string, any>>;
+	entities: Record<string, Config>;
+	definition: Record<string, any>;
+};
+
+type ValueOf<T> = T[keyof T];
+
+export type DiffCreate<
+	TSchema extends Definition = {},
+	TType extends keyof TSchema | 'entities' = string,
+	TShape extends Record<string, any> = TType extends 'entities' ? {} : Simplify<
+		InferSchema<TSchema[TType]> & Omit<Common, keyof TSchema[TType]> & {
+			entityType: TType;
+		}
+	>,
+> = TType extends 'entities' ? ValueOf<
+		{
+			[K in keyof TSchema]: DiffCreate<TSchema, K>;
+		}
+	>
+	: Simplify<
+		& {
+			$diffType: 'create';
+			entityType: TType;
+		}
+		& {
+			[
+				K in keyof Common as K extends keyof TShape ? null extends TShape[K] ? never : K : K
+			]: Exclude<Common[K], null>;
+		}
+		& Omit<TShape, keyof CommonEntity>
+	>;
+
+export type DiffDrop<
+	TSchema extends Definition = {},
+	TType extends keyof TSchema | 'entities' = string,
+	TShape extends Record<string, any> = TType extends 'entities' ? {} : Simplify<
+		InferSchema<TSchema[TType]> & Omit<Common, keyof TSchema[TType]> & {
+			entityType: TType;
+		}
+	>,
+> = TType extends 'entities' ? ValueOf<
+		{
+			[K in keyof TSchema]: DiffDrop<TSchema, K>;
+		}
+	>
+	: Simplify<
+		& {
+			$diffType: 'drop';
+			entityType: TType;
+		}
+		& {
+			[
+				K in keyof Common as K extends keyof TShape ? null extends TShape[K] ? never : K : K
+			]: Exclude<Common[K], null>;
+		}
+		& Omit<TShape, keyof CommonEntity>
+	>;
+
+export type DiffAlter<
+	TSchema extends Definition = {},
+	TType extends keyof TSchema | 'entities' = string,
+	TShape extends Record<string, any> = TType extends 'entities' ? {} : Simplify<
+		InferSchema<TSchema[TType]> & Omit<Common, keyof TSchema[TType]> & {
+			entityType: TType;
+		}
+	>,
+	TFullShape extends Record<string, any> = TType extends 'entities' ? {} : Simplify<
+		& InferSchema<TSchema[TType]>
+		& {
+			[C in keyof Common as C extends keyof TSchema[TType] ? never : null extends Common[C] ? never : C]: Common[C];
+		}
+		& {
+			entityType: TType;
+		}
+	>,
+> = TType extends 'entities' ? ValueOf<
+		{
+			[K in keyof TSchema]: DiffAlter<TSchema, K>;
+		}
+	>
+	: Simplify<
+		& {
+			$diffType: 'alter';
+			entityType: TType;
+		}
+		& {
+			[
+				K in keyof Common as K extends keyof TShape ? null extends TShape[K] ? never : K : K
+			]: Exclude<Common[K], null>;
+		}
+		& {
+			[K in Exclude<keyof TShape, keyof CommonEntity>]?: {
+				from: TShape[K];
+				to: TShape[K];
+			};
+		}
+		& {
+			$left: TFullShape;
+			$right: TFullShape;
+		}
+	>;
+
+export type DiffStatement<
+	TSchema extends Definition,
+	TType extends keyof TSchema | 'entities',
+> =
+	| DiffCreate<TSchema, TType>
+	| DiffDrop<TSchema, TType>
+	| DiffAlter<TSchema, TType>;
+
+type CollectionRow = Record<string, any> & Common & {
+	entityType: string;
+	key: string;
+};
+
+const ignoreChanges: Record<keyof Common | 'entityType', true> = {
+	entityType: true,
+	name: true,
+	schema: true,
+	table: true,
+};
+
+function isEqual(a: any, b: any): boolean {
+	if (typeof a !== typeof b) return false;
+
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((v, i) => isEqual(v, b[i]));
+	}
+
+	if (typeof a === 'object') {
+		if (a === b) return true;
+		if ((a === null || b === null) && a !== b) return false;
+
+		const keys = Array.from(new Set([...Object.keys(a), ...Object.keys(b)]));
+
+		return keys.every((k) => isEqual(a[k], b[k]));
+	}
+
+	return a === b;
+}
+
+function sanitizeRow(row: Record<string, any>) {
+	return Object.fromEntries(
+		Object.entries(row).filter(([k, _v]) => !ignoreChanges[k as keyof typeof ignoreChanges]),
+	);
+}
+
+function getRowCommons(row: Record<string, any>): {
+	[K in keyof Common]: Common[K];
+} {
+	const res: Record<string, any> = {};
+	for (const k of Object.keys(commonConfig)) {
+		if (row[k] === undefined || row[k] === null) continue;
+
+		res[k] = row[k];
+	}
+
+	return res as any;
+}
+
+function _diff<
+	TDefinition extends Definition,
+	TCollection extends keyof TDefinition | 'entities' = 'entities',
+	TMode extends 'all' | 'create' | 'drop' | 'createdrop' | 'alter' = 'all',
+	TDataBase extends SimpleDb<TDefinition> = SimpleDb<TDefinition>,
+>(
+	dbOld: SimpleDb<TDefinition>,
+	dbNew: SimpleDb<TDefinition>,
+	collection?: TCollection,
+	mode?: TMode,
+): Simplify<TDataBase['_']['diffs'][TMode][TCollection]>[] {
+	collection = collection ?? 'entities' as TCollection;
+	mode = mode ?? 'all' as TMode;
+
+	const leftEntities = dbOld.entities.list(
+		collection === 'entities' ? undefined : {
+			// @ts-ignore
+			entityType: collection,
+		},
+	) as CollectionRow[];
+	const rightEntities = dbNew.entities.list(
+		collection === 'entities' ? undefined : {
+			// @ts-ignore
+			entityType: collection,
+		},
+	) as CollectionRow[];
+
+	const left: Record<string, CollectionRow> = {};
+	const right: Record<string, CollectionRow> = {};
+
+	for (const row of leftEntities) {
+		left[getCompositeKey(row)] = row;
+	}
+	for (const row of rightEntities) {
+		right[getCompositeKey(row)] = row;
+	}
+
+	const created: DiffCreate[] = [];
+	const dropped: DiffDrop[] = [];
+	const altered: DiffAlter[] = [];
+
+	for (const [key, oldRow] of Object.entries(left)) {
+		const newRow = right[key];
+		if (!newRow) {
+			if (mode === 'all' || mode === 'drop' || mode === 'createdrop') {
+				dropped.push({
+					$diffType: 'drop',
+					entityType: oldRow.entityType,
+					...getRowCommons(oldRow),
+					...sanitizeRow(oldRow),
+				});
+			}
+		} else if (mode === 'all' || mode === 'alter') {
+			const changes: Record<string, any> = {};
+			let isChanged = false;
+
+			for (const [k, _v] of Object.entries(oldRow)) {
+				if (ignoreChanges[k as keyof typeof ignoreChanges]) continue;
+
+				if (!isEqual(oldRow[k], newRow[k])) {
+					isChanged = true;
+					changes[k] = { from: oldRow[k], to: newRow[k] };
+				}
+			}
+
+			if (isChanged) {
+				altered.push({
+					$diffType: 'alter',
+					entityType: newRow.entityType,
+					...getRowCommons(newRow),
+					...changes,
+					$left: oldRow,
+					$right: newRow,
+				});
+			}
+		}
+
+		delete right[key];
+	}
+
+	if (mode === 'all' || mode === 'create' || mode === 'createdrop') {
+		for (const newRow of Object.values(right)) {
+			created.push({
+				$diffType: 'create',
+				entityType: newRow.entityType as string,
+				...getRowCommons(newRow),
+				...sanitizeRow(newRow),
+			});
+		}
+	}
+
+	return [...created, ...dropped, ...altered] as any;
+}
+
+export function diff<
+	TDefinition extends Definition,
+	TCollection extends keyof TDefinition | 'entities' = 'entities',
+>(dbOld: SimpleDb<TDefinition>, dbNew: SimpleDb<TDefinition>, collection?: TCollection) {
+	return _diff(dbOld, dbNew, collection, 'createdrop');
+}
+
+export namespace diff {
+	export function all<
+		TDefinition extends Definition,
+		TCollection extends keyof TDefinition | 'entities' = 'entities',
+	>(dbOld: SimpleDb<TDefinition>, dbNew: SimpleDb<TDefinition>, collection?: TCollection) {
+		return _diff(dbOld, dbNew, collection, 'all');
+	}
+
+	export function creates<
+		TDefinition extends Definition,
+		TCollection extends keyof TDefinition | 'entities' = 'entities',
+	>(dbOld: SimpleDb<TDefinition>, dbNew: SimpleDb<TDefinition>, collection?: TCollection) {
+		return _diff(dbOld, dbNew, collection, 'create');
+	}
+
+	export function drops<
+		TDefinition extends Definition,
+		TCollection extends keyof TDefinition | 'entities' = 'entities',
+	>(dbOld: SimpleDb<TDefinition>, dbNew: SimpleDb<TDefinition>, collection?: TCollection) {
+		return _diff(dbOld, dbNew, collection, 'drop');
+	}
+
+	export function alters<
+		TDefinition extends Definition,
+		TCollection extends keyof TDefinition | 'entities' = 'entities',
+	>(dbOld: SimpleDb<TDefinition>, dbNew: SimpleDb<TDefinition>, collection?: TCollection) {
+		return _diff(dbOld, dbNew, collection, 'alter');
+	}
+}
+
+function removeQuestionMark<T extends string, TResult extends string = T extends `${infer R}?` ? R : T>(
+	str: T,
+): TResult {
+	if (!str.endsWith('?')) return str as string as TResult;
+
+	return str.slice(0, str.length - 1) as TResult;
+}
+
+class SimpleDb<TDefinition extends Definition = Record<string, any>> {
+	public readonly _: DbConfig<TDefinition> = {
+		diffs: {} as any,
+		store: {
+			collection: [] as Record<string, any>[],
+		},
+	} as any;
+
+	public entities: GenerateProcessors<{
+		types: {
+			entities: InferEntities<TDefinition> extends infer TInferred ? Simplify<
+					ValueOf<TInferred>
+				>
+				: never;
+		};
+		entities: any;
+		definition: TDefinition;
+	}, true>['entities'];
+
+	constructor(definition: TDefinition) {
+		const entries = Object.entries(definition);
+		const configs = Object.fromEntries(entries.map(([type, def]) => {
+			if (type === 'entities' || type === '_') throw new Error(`Illegal entity type name: "${type}"`);
+			const cloneDef: Record<string, any> = {};
+
+			Object.entries(def).forEach(([fieldName, fieldValue]) => {
+				cloneDef[fieldName] = fieldValue;
+
+				if (fieldValue === 'required') {
+					if (!(fieldName in commonConfig)) {
+						throw new Error(
+							`Type value "required" is only applicable to common keys [ ${
+								Object.keys(commonConfig).map((e) => `"${e}"`).join(', ')
+							} ], used on: "${fieldName}"`,
+						);
+					}
+
+					cloneDef[fieldName] = (removeQuestionMark(commonConfig[fieldName] as string)) as Exclude<
+						ExtendedType,
+						'required'
+					>;
+				} else {
+					if (fieldName in commonConfig) {
+						throw new Error(`Used forbidden key "${fieldName}" in entity "${type}"`);
+					}
+				}
+			});
+
+			for (const k in commonConfig) {
+				if (commonConfig[k].endsWith('?')) continue;
+
+				cloneDef[k] = commonConfig[k];
+			}
+
+			return [type, cloneDef];
+		}));
+
+		this._.entities = configs as any;
+
+		const entConfig = {
+			...this._,
+			entities: {
+				entities: commonConfig,
+			},
+		};
+
+		this.entities = initSchemaProcessors(entConfig, this._.store, true, this._.entities).entities as any;
+	}
+}
+
+export function create<
+	TDefinition extends Definition,
+	TResult = SimpleDb<TDefinition> extends infer DB extends SimpleDb<any> ? Simplify<DB & GenerateProcessors<DB['_']>>
+		: never,
+>(
+	definition: TDefinition,
+): TResult {
+	const db = new SimpleDb(definition);
+
+	const processors = initSchemaProcessors(db._, db._.store, false);
+	for (const [k, v] of Object.entries(processors)) {
+		(db as any)[k] = v;
+	}
+
+	return db as any;
+}
diff --git a/drizzle-kit/src/dialects/drizzle.ts b/drizzle-kit/src/dialects/drizzle.ts
new file mode 100644
index 0000000000..b3ec20c299
--- /dev/null
+++ b/drizzle-kit/src/dialects/drizzle.ts
@@ -0,0 +1,125 @@
+import type { SQL } from 'drizzle-orm';
+import {
+	type CockroachMaterializedView,
+	type CockroachSchema,
+	type CockroachView,
+	getMaterializedViewConfig as crdbMatViewConfig,
+	getViewConfig as crdbViewConfig,
+} from 'drizzle-orm/cockroach-core';
+import { getViewConfig as mssqlViewConfig, type MsSqlSchema, type MsSqlView } from 'drizzle-orm/mssql-core';
+import { getViewConfig as mysqlViewConfig, type MySqlView } from 'drizzle-orm/mysql-core';
+import {
+	getMaterializedViewConfig as pgMatViewConfig,
+	getViewConfig as pgViewConfig,
+	type PgMaterializedView,
+	type PgSchema,
+	type PgView,
+} from 'drizzle-orm/pg-core';
+import { getViewConfig as sqliteViewConfig, type SQLiteView } from 'drizzle-orm/sqlite-core';
+import type { Schema, Table } from './pull-utils';
+
+export const extractPostgresExisting = (
+	schemas: PgSchema[],
+	views: PgView[],
+	matViews: PgMaterializedView[],
+): (Schema | Table)[] => {
+	const existingSchemas = schemas.filter((x) => x.isExisting).map<Schema>((x) => ({
+		type: 'schema',
+		name: x.schemaName,
+	}));
+	const existingViews = views.map((x) => pgViewConfig(x)).filter((x) => x.isExisting).map<Table>((x) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+	const existingMatViews = matViews.map((x) => pgMatViewConfig(x)).filter((x) => x.isExisting).map<Table>((
+		x,
+	) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	return [...existingSchemas, ...existingViews, ...existingMatViews];
+};
+
+export const extractCrdbExisting = (
+	schemas: CockroachSchema[],
+	views: CockroachView[],
+	matViews: CockroachMaterializedView[],
+): (Schema | Table)[] => {
+	const existingSchemas = schemas.filter((x) => x.isExisting).map<Schema>((x) => ({
+		type: 'schema',
+		name: x.schemaName,
+	}));
+	const existingViews = views.map((x) => crdbViewConfig(x)).filter((x) => x.isExisting).map<Table>((x) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	const existingMatViews = matViews.map((x) => crdbMatViewConfig(x)).filter((x) => x.isExisting).map<Table>((
+		x,
+	) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	return [...existingSchemas, ...existingViews, ...existingMatViews];
+};
+
+export const extractMssqlExisting = (
+	schemas: MsSqlSchema[],
+	views: MsSqlView[],
+): (Schema | Table)[] => {
+	const existingSchemas = schemas.filter((x) => x.isExisting).map<Schema>((x) => ({
+		type: 'schema',
+		name: x.schemaName,
+	}));
+	const existingViews = views.map((x) => mssqlViewConfig(x)).filter((x) => x.isExisting).map<Table>((x) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	return [...existingSchemas, ...existingViews];
+};
+
+export const extractMysqlExisting = (
+	views: MySqlView[],
+): Table[] => {
+	const existingViews = views.map((x) => mysqlViewConfig(x)).filter((x) => x.isExisting).map<Table>((x) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	return [...existingViews];
+};
+
+export const extractSqliteExisting = (
+	views: SQLiteView[],
+): Table[] => {
+	const existingViews = views.map((x) => sqliteViewConfig(x)).filter((x) => x.isExisting).map<Table>((x) => ({
+		type: 'table',
+		schema: x.schema ?? 'public',
+		name: x.name,
+	}));
+
+	return [...existingViews];
+};
+
+export const sqlToStr = (sql: SQL) => {
+	return sql.toQuery({
+		escapeName: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeParam: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeString: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+	}).sql;
+};
diff --git a/drizzle-kit/src/dialects/mssql/convertor.ts b/drizzle-kit/src/dialects/mssql/convertor.ts
new file mode 100644
index 0000000000..44637642b7
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/convertor.ts
@@ -0,0 +1,564 @@
+import type { Simplify } from '../../utils';
+import type { DefaultConstraint } from './ddl';
+import type { DropColumn, JsonStatement, RenameColumn } from './statements';
+
+export const convertor = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	convertor: (statement: Simplify<Omit<TStatement, 'type'>>) => string | string[],
+) => {
+	return {
+		type,
+		can: (st: JsonStatement) => {
+			return st.type === type;
+		},
+		convert: convertor,
+	};
+};
+
+const createTable = convertor('create_table', (st) => {
+	const { name, schema, columns, pk, checks, uniques, defaults } = st.table;
+
+	let statement = '';
+
+	const key = schema !== 'dbo' ? `[${schema}].[${name}]` : `[${name}]`;
+	statement += `CREATE TABLE ${key} (\n`;
+
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+
+		const isPK = pk && pk.columns.includes(column.name);
+
+		const identity = column.identity;
+		const identityStatement = identity ? ` IDENTITY(${identity.seed}, ${identity.increment})` : '';
+		const notNullStatement = isPK ? '' : column.notNull && !column.identity && !column.generated ? ' NOT NULL' : '';
+
+		const hasDefault = defaults.find((it) =>
+			it.table === column.table && it.column === column.name && it.schema === column.schema
+		);
+		const defaultStatement = !hasDefault
+			? ''
+			: ` CONSTRAINT [${hasDefault.name}] DEFAULT ${hasDefault.default}`;
+
+		const generatedType = column.generated?.type.toUpperCase() === 'VIRTUAL'
+			? ''
+			: column.generated?.type.toUpperCase();
+		const generatedStatement = column.generated
+			? ` AS (${column.generated?.as})${' ' + generatedType}`
+			: '';
+
+		statement += '\t'
+			+ `[${column.name}] ${
+				generatedStatement ? '' : column.type
+			}${identityStatement}${generatedStatement}${notNullStatement}${defaultStatement}`;
+		statement += i === columns.length - 1 ? '' : ',\n';
+	}
+
+	if (pk) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT [${pk.name}] PRIMARY KEY([${pk.columns.join(`],[`)}])`;
+	}
+
+	for (const unique of uniques) {
+		statement += ',\n';
+		const uniqueString = unique.columns.join('],[');
+
+		statement += `\tCONSTRAINT [${unique.name}] UNIQUE([${uniqueString}])`;
+	}
+
+	for (const check of checks) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT [${check.name}] CHECK (${check.value})`;
+	}
+
+	statement += `\n);`;
+	statement += `\n`;
+	return statement;
+});
+
+const dropTable = convertor('drop_table', (st) => {
+	const { table } = st;
+
+	const key = table.schema !== 'dbo' ? `[${table.schema}].[${table.name}]` : `[${table.name}]`;
+
+	return `DROP TABLE ${key};`;
+});
+
+const renameTable = convertor('rename_table', (st) => {
+	const { from, schema, to } = st;
+
+	const key = schema !== 'dbo' ? `${schema}.${from}` : `${from}`;
+
+	return `EXEC sp_rename '${key}', [${to}];`;
+});
+
+const addColumn = convertor('add_column', (st) => {
+	const { column, defaults } = st;
+	const {
+		name,
+		notNull,
+		table,
+		generated,
+		identity,
+		schema,
+	} = column;
+
+	const notNullStatement = notNull && !column.generated && !column.identity ? ' NOT NULL' : '';
+	const identityStatement = identity ? ` IDENTITY(${identity.seed}, ${identity.increment})` : '';
+
+	const generatedType = column.generated?.type.toUpperCase() === 'VIRTUAL'
+		? ''
+		: column.generated?.type.toUpperCase();
+	const generatedStatement = generated
+		? ` AS (${generated?.as})${generatedType ? ' ' + generatedType : ''}`
+		: '';
+
+	const hasDefault = defaults.find((it) =>
+		it.table === column.table && it.column === column.name && it.schema === column.schema
+	);
+	const defaultStatement = !hasDefault
+		? ''
+		: ` CONSTRAINT [${hasDefault.name}] DEFAULT ${hasDefault.default}`;
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+
+	let statement = `ALTER TABLE ${key} ADD [${name}]`;
+	if (!generated) statement += ` ${column.type}`;
+	statement += `${identityStatement}${generatedStatement}${notNullStatement}${defaultStatement};`;
+
+	return statement;
+});
+
+const dropColumn = convertor('drop_column', (st) => {
+	const { column } = st;
+
+	const key = column.schema !== 'dbo' ? `[${column.schema}].[${column.table}]` : `[${column.table}]`;
+	return `ALTER TABLE ${key} DROP COLUMN [${st.column.name}];`;
+});
+
+const renameColumn = convertor('rename_column', (st) => {
+	const { table: tableFrom, name: columnFrom, schema } = st.from;
+
+	const key = schema !== 'dbo' ? `${schema}.${tableFrom}.${columnFrom}` : `${tableFrom}.${columnFrom}`;
+
+	const { name: columnTo } = st.to;
+	return `EXEC sp_rename '${key}', [${columnTo}], 'COLUMN';`;
+});
+
+const alterColumn = convertor('alter_column', (st) => {
+	const { diff } = st;
+
+	const column = diff.$right;
+	const notNullStatement = `${column.notNull ? ' NOT NULL' : ''}`;
+
+	const key = column.schema !== 'dbo' ? `[${column.schema}].[${column.table}]` : `[${column.table}]`;
+
+	return `ALTER TABLE ${key} ALTER COLUMN [${column.name}] ${column.type}${notNullStatement};`;
+});
+
+const recreateColumn = convertor('recreate_column', (st) => {
+	return [
+		dropColumn.convert({ column: st.diff.$left }) as string,
+		addColumn.convert({ column: st.diff.$right, defaults: [], isPK: false }) as string,
+	];
+});
+
+const recreateIdentityColumn = convertor('recreate_identity_column', (st) => {
+	const { column, constraintsToCreate, constraintsToDelete } = st;
+
+	const shouldTransferData = column.identity?.from && Boolean(!column.identity.to);
+	const statements = [];
+
+	for (const toDelete of constraintsToDelete) {
+		if (toDelete.entityType === 'fks') statements.push(dropForeignKey.convert({ fk: toDelete }) as string);
+		if (toDelete.entityType === 'checks') statements.push(dropCheck.convert({ check: toDelete }) as string);
+		if (toDelete.entityType === 'defaults') statements.push(dropDefault.convert({ default: toDelete }) as string);
+		if (toDelete.entityType === 'pks') statements.push(dropPK.convert({ pk: toDelete }) as string);
+		if (toDelete.entityType === 'indexes') statements.push(dropIndex.convert({ index: toDelete }) as string);
+		if (toDelete.entityType === 'uniques') statements.push(dropUnique.convert({ unique: toDelete }) as string);
+	}
+
+	const renamedColumnName = `__old_${column.name}`;
+	statements.push(
+		renameColumn.convert({
+			from: { table: column.table, name: column.name, schema: column.schema },
+			to: { name: renamedColumnName },
+		} as RenameColumn) as string,
+	);
+
+	const defaultsToCreate: DefaultConstraint[] = constraintsToCreate.filter((it) => it.entityType === 'defaults');
+	statements.push(addColumn.convert({ column: column.$right, defaults: defaultsToCreate, isPK: false }) as string);
+
+	if (shouldTransferData) {
+		statements.push(
+			`INSERT INTO [${column.table}] ([${column.name}]) SELECT [${renamedColumnName}] FROM [${column.table}];`,
+		);
+	}
+
+	statements.push(
+		dropColumn.convert(
+			{ column: { name: renamedColumnName, schema: column.schema, table: column.table } } as DropColumn,
+		) as string,
+	);
+
+	for (const toCreate of constraintsToCreate) {
+		if (toCreate.entityType === 'checks') statements.push(addCheck.convert({ check: toCreate }) as string);
+		if (toCreate.entityType === 'fks') statements.push(createFK.convert({ fk: toCreate }) as string);
+		if (toCreate.entityType === 'pks') statements.push(createPK.convert({ pk: toCreate }) as string);
+		if (toCreate.entityType === 'indexes') statements.push(createIndex.convert({ index: toCreate }) as string);
+		if (toCreate.entityType === 'uniques') statements.push(addUnique.convert({ unique: toCreate }) as string);
+	}
+
+	return statements;
+});
+
+const createIndex = convertor('create_index', (st) => {
+	const { name, table, columns, isUnique, where, schema } = st.index;
+	const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+
+	const uniqueString = `${
+		columns.map((it) => {
+			return it.isExpression ? it.value : `[${it.value}]`;
+		})
+	}`;
+
+	const whereClause = where ? ` WHERE ${where}` : '';
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	return `CREATE ${indexPart} [${name}] ON ${key} (${uniqueString})${whereClause};`;
+});
+
+const dropIndex = convertor('drop_index', (st) => {
+	const { schema, name, table } = st.index;
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	return `DROP INDEX [${name}] ON ${key};`;
+});
+
+const createFK = convertor('create_fk', (st) => {
+	const {
+		name,
+		table,
+		columns,
+		tableTo,
+		columnsTo,
+		onDelete,
+		onUpdate,
+		schema,
+		schemaTo,
+	} = st.fk;
+	const onDeleteStatement = onDelete !== 'NO ACTION' ? ` ON DELETE ${onDelete}` : '';
+	const onUpdateStatement = onUpdate !== 'NO ACTION' ? ` ON UPDATE ${onUpdate}` : '';
+	const fromColumnsString = columns.map((it) => `[${it}]`).join(',');
+	const toColumnsString = columnsTo.map((it) => `[${it}]`).join(',');
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	const keyTo = schemaTo !== 'dbo' ? `[${schemaTo}].[${tableTo}]` : `[${tableTo}]`;
+
+	return `ALTER TABLE ${key} ADD CONSTRAINT [${name}] FOREIGN KEY (${fromColumnsString}) REFERENCES ${keyTo}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+});
+
+const createPK = convertor('create_pk', (st) => {
+	const { name, schema, table, columns } = st.pk;
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	return `ALTER TABLE ${key} ADD CONSTRAINT [${name}] PRIMARY KEY ([${columns.join('],[')}]);`;
+});
+
+const renamePk = convertor('rename_pk', (st) => {
+	const { name: nameFrom, schema: schemaFrom } = st.from;
+	const { name: nameTo } = st.to;
+
+	const key = schemaFrom !== 'dbo' ? `${schemaFrom}.${nameFrom}` : `${nameFrom}`;
+	return `EXEC sp_rename '${key}', [${nameTo}], 'OBJECT';`;
+});
+
+const renameCheck = convertor('rename_check', (st) => {
+	const { name: nameFrom, schema: schemaFrom } = st.from;
+	const { name: nameTo } = st.to;
+
+	const key = schemaFrom !== 'dbo' ? `${schemaFrom}.${nameFrom}` : `${nameFrom}`;
+	return `EXEC sp_rename '${key}', [${nameTo}], 'OBJECT';`;
+});
+
+const renameFk = convertor('rename_fk', (st) => {
+	const { name: nameFrom, schema: schemaFrom } = st.from;
+	const { name: nameTo } = st.to;
+
+	const key = schemaFrom !== 'dbo' ? `${schemaFrom}.${nameFrom}` : `${nameFrom}`;
+	return `EXEC sp_rename '${key}', [${nameTo}], 'OBJECT';`;
+});
+
+const renameIndex = convertor('rename_index', (st) => {
+	const { name: nameFrom, schema: schemaFrom, table: tableFrom } = st.from;
+	const { name: nameTo } = st.to;
+
+	const key = schemaFrom !== 'dbo' ? `${schemaFrom}.${tableFrom}.${nameFrom}` : `${tableFrom}.${nameFrom}`;
+	return `EXEC sp_rename '${key}', [${nameTo}], 'INDEX';`;
+});
+
+const renameUnique = convertor('rename_unique', (st) => {
+	const { name: nameFrom, schema: schemaFrom } = st.from;
+	const { name: nameTo } = st.to;
+
+	const key = schemaFrom !== 'dbo' ? `${schemaFrom}.${nameFrom}` : `${nameFrom}`;
+	return `EXEC sp_rename '${key}', [${nameTo}], 'OBJECT';`;
+});
+
+const createCheck = convertor('create_check', (st) => {
+	const { name, schema, table, value } = st.check;
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	return `ALTER TABLE ${key} ADD CONSTRAINT [${name}] CHECK (${value});`;
+});
+
+const dropConstraint = convertor('drop_constraint', (st) => {
+	const { constraint, table, schema } = st;
+
+	const key = schema !== 'dbo' ? `[${schema}].[${table}]` : `[${table}]`;
+	return `ALTER TABLE ${key} DROP CONSTRAINT [${constraint}];`;
+});
+
+const createView = convertor('create_view', (st) => {
+	const { definition, name, checkOption, encryption, schemaBinding, viewMetadata, schema } = st.view;
+
+	let statement = `CREATE `;
+
+	const key = schema === 'dbo' ? `[${name}]` : `[${schema}].[${name}]`;
+	statement += `VIEW ${key}`;
+
+	if (encryption || schemaBinding || viewMetadata) {
+		const options: string[] = [];
+		statement += `\nWITH`;
+
+		if (encryption) options.push(`ENCRYPTION`);
+		if (schemaBinding) options.push(`SCHEMABINDING`);
+		if (viewMetadata) options.push(`VIEW_METADATA`);
+
+		statement += ` ${options.join(', ')}`;
+	}
+	statement += ` AS ${definition}`;
+	statement += checkOption ? `\nWITH CHECK OPTION` : '';
+
+	statement += ';';
+
+	return statement;
+});
+
+const dropView = convertor('drop_view', (st) => {
+	const { schema, name } = st.view;
+	const key = schema === 'dbo' ? `[${name}]` : `[${schema}].[${name}]`;
+
+	return `DROP VIEW ${key};`;
+});
+
+const renameView = convertor('rename_view', (st) => {
+	const { schema, name } = st.from;
+	const key = schema === 'dbo' ? `${name}` : `${schema}.${name}`;
+
+	return `EXEC sp_rename '${key}', [${st.to.name}];`;
+});
+
+const alterView = convertor('alter_view', (st) => {
+	const { definition, name, checkOption, encryption, schemaBinding, viewMetadata, schema } = st.view;
+
+	const key = schema === 'dbo' ? `[${name}]` : `[${schema}].[${name}]`;
+	let statement = `ALTER VIEW ${key}`;
+
+	if (encryption || schemaBinding || viewMetadata) {
+		const options: string[] = [];
+		statement += `\nWITH`;
+
+		if (encryption) options.push(`ENCRYPTION`);
+		if (schemaBinding) options.push(`SCHEMABINDING`);
+		if (viewMetadata) options.push(`VIEW_METADATA`);
+
+		statement += ` ${options.join(', ')}`;
+	}
+	statement += ` AS ${definition}`;
+	statement += checkOption ? `\nWITH CHECK OPTION` : '';
+
+	statement += ';';
+
+	return statement;
+});
+
+const createSchema = convertor('create_schema', (st) => {
+	return `CREATE SCHEMA [${st.name}];\n`;
+});
+
+const dropSchema = convertor('drop_schema', (st) => {
+	return `DROP SCHEMA [${st.name}];\n`;
+});
+
+const renameSchema = convertor('rename_schema', (_st) => {
+	return `/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`;
+});
+
+const moveTable = convertor('move_table', (st) => {
+	const { from, name, to } = st;
+	return `ALTER SCHEMA [${to}] TRANSFER [${from}].[${name}];\n`;
+});
+
+const moveView = convertor('move_view', (st) => {
+	const { fromSchema, toSchema, view } = st;
+	const from = fromSchema === 'dbo' ? `[${view.name}]` : `[${fromSchema}].[${view.name}]`;
+
+	return `ALTER SCHEMA [${toSchema}] TRANSFER ${from};`;
+});
+
+const addUnique = convertor('add_unique', (st) => {
+	const { unique } = st;
+	const tableNameWithSchema = unique.schema !== 'dbo'
+		? `[${unique.schema}].[${unique.table}]`
+		: `[${unique.table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT [${unique.name}] UNIQUE([${unique.columns.join('],[')}]);`;
+});
+
+const dropPK = convertor('drop_pk', (st) => {
+	const pk = st.pk;
+	const key = pk.schema !== 'dbo'
+		? `[${pk.schema}].[${pk.table}]`
+		: `[${pk.table}]`;
+
+	return `ALTER TABLE ${key} DROP CONSTRAINT [${pk.name}];`;
+});
+
+const addCheck = convertor('add_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'dbo'
+		? `[${check.schema}].[${check.table}]`
+		: `[${check.table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT [${check.name}] CHECK (${check.value});`;
+});
+
+const dropCheck = convertor('drop_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'dbo'
+		? `[${check.schema}].[${check.table}]`
+		: `[${check.table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT [${check.name}];`;
+});
+
+const dropUnique = convertor('drop_unique', (st) => {
+	const { unique } = st;
+
+	const tableNameWithSchema = unique.schema !== 'dbo'
+		? `[${unique.schema}].[${unique.table}]`
+		: `[${unique.table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT [${unique.name}];`;
+});
+
+const dropForeignKey = convertor('drop_fk', (st) => {
+	const { schema, table, name } = st.fk;
+
+	const tableNameWithSchema = schema !== 'dbo'
+		? `[${schema}].[${table}]`
+		: `[${table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT [${name}];\n`;
+});
+
+const addDefault = convertor('create_default', (st) => {
+	const { schema, table, name, default: tableDefault, column } = st.default;
+
+	const tableNameWithSchema = schema !== 'dbo'
+		? `[${schema}].[${table}]`
+		: `[${table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT [${name}] DEFAULT ${tableDefault} FOR [${column}];`;
+});
+
+const dropDefault = convertor('drop_default', (st) => {
+	const { schema, table, name } = st.default;
+
+	const tableNameWithSchema = schema !== 'dbo'
+		? `[${schema}].[${table}]`
+		: `[${table}]`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT [${name}];`;
+});
+
+const renameDefault = convertor('recreate_default', (st) => {
+	const { from, to } = st;
+
+	return [dropDefault.convert({ default: from }) as string, addDefault.convert({ default: to }) as string];
+});
+
+const convertors = [
+	createTable,
+	dropTable,
+	renameTable,
+	addColumn,
+	dropColumn,
+	renameColumn,
+	alterColumn,
+	recreateColumn,
+	recreateIdentityColumn,
+	createIndex,
+	dropIndex,
+	createFK,
+	createPK,
+	dropPK,
+	createCheck,
+	dropConstraint,
+	createView,
+	dropView,
+	renameView,
+	alterView,
+	createSchema,
+	dropSchema,
+	moveTable,
+	moveView,
+	addCheck,
+	dropCheck,
+	renameSchema,
+	addUnique,
+	renamePk,
+	renameCheck,
+	renameFk,
+	renameIndex,
+	dropUnique,
+	dropForeignKey,
+	renameUnique,
+	addDefault,
+	dropDefault,
+	renameDefault,
+];
+
+export function fromJson(
+	statements: JsonStatement[],
+) {
+	const grouped = statements
+		.map((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+			if (!convertor) throw new Error(`No convertor for: ${statement.type} statement`);
+
+			const sqlStatements = convertor.convert(statement as any);
+			const statements = typeof sqlStatements === 'string' ? [sqlStatements] : sqlStatements;
+			return { jsonStatement: statement, sqlStatements: statements };
+		})
+		.filter((it) => it !== null);
+
+	const result = {
+		sqlStatements: grouped.map((it) => it.sqlStatements).flat(),
+		groupedStatements: grouped,
+	};
+	return result;
+}
diff --git a/drizzle-kit/src/dialects/mssql/ddl.ts b/drizzle-kit/src/dialects/mssql/ddl.ts
new file mode 100644
index 0000000000..e75c8516e2
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/ddl.ts
@@ -0,0 +1,413 @@
+import { create } from '../dialect';
+import { defaultNameForPK, defaultNameForUnique } from './grammar';
+
+// old
+export const createDDLV1 = () => {
+	return create({
+		schemas: {},
+		tables: { schema: 'required' },
+		columns: {
+			schema: 'required',
+			table: 'required',
+			type: 'string',
+			notNull: 'boolean',
+			generated: {
+				type: ['persisted', 'virtual'],
+				as: 'string',
+			},
+			identity: {
+				increment: 'number',
+				seed: 'number',
+			},
+		},
+		pks: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+		},
+		fks: {
+			schema: 'required',
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+			schemaTo: 'string',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: ['NO ACTION', 'CASCADE', 'SET NULL', 'SET DEFAULT'],
+			onDelete: ['NO ACTION', 'CASCADE', 'SET NULL', 'SET DEFAULT'],
+		},
+		indexes: {
+			schema: 'required',
+			table: 'required',
+			columns: 'string[]', // does not supported indexing expressions
+			isUnique: 'boolean',
+			where: 'string?',
+		},
+		uniques: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+		},
+		checks: {
+			schema: 'required',
+			table: 'required',
+			value: 'string',
+		},
+		defaults: {
+			schema: 'required',
+			table: 'required',
+			column: 'string',
+			// this field will be required for name preserving
+			nameExplicit: 'boolean',
+			default: 'string?',
+		},
+		views: {
+			schema: 'required',
+			definition: 'string',
+			encryption: 'boolean?',
+			schemaBinding: 'boolean?',
+			viewMetadata: 'boolean?',
+			checkOption: 'boolean?',
+		},
+	});
+};
+
+export const createDDL = () => {
+	return create({
+		schemas: {},
+		tables: { schema: 'required' },
+		columns: {
+			schema: 'required',
+			table: 'required',
+			type: 'string',
+			notNull: 'boolean',
+			generated: {
+				type: ['persisted', 'virtual'],
+				as: 'string',
+			},
+			identity: {
+				increment: 'number',
+				seed: 'number',
+			},
+		},
+		pks: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+		},
+		fks: {
+			schema: 'required',
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+			schemaTo: 'string',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: ['NO ACTION', 'CASCADE', 'SET NULL', 'SET DEFAULT'],
+			onDelete: ['NO ACTION', 'CASCADE', 'SET NULL', 'SET DEFAULT'],
+		},
+		indexes: {
+			schema: 'required',
+			table: 'required',
+			// TODO add asc/desc: asc and desc feature exists in mssql
+			columns: [
+				{
+					value: 'string',
+					isExpression: 'boolean',
+				},
+			],
+			isUnique: 'boolean',
+			where: 'string?',
+		},
+		uniques: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+		},
+		checks: {
+			schema: 'required',
+			table: 'required',
+			value: 'string',
+		},
+		defaults: {
+			schema: 'required',
+			table: 'required',
+			column: 'string',
+			// this field will be required for name preserving
+			nameExplicit: 'boolean',
+			default: 'string?',
+		},
+		views: {
+			schema: 'required',
+			definition: 'string',
+			encryption: 'boolean?',
+			schemaBinding: 'boolean?',
+			viewMetadata: 'boolean?',
+			checkOption: 'boolean?',
+		},
+	});
+};
+
+export type MssqlDDLV1 = ReturnType<typeof createDDLV1>;
+export type MssqlEntitiesV1 = MssqlDDLV1['_']['types'];
+export type MssqlEntityV1 = MssqlEntitiesV1[keyof MssqlEntitiesV1];
+
+export type MssqlDDL = ReturnType<typeof createDDL>;
+
+export type MssqlEntities = MssqlDDL['_']['types'];
+export type MssqlEntity = MssqlEntities[keyof MssqlEntities];
+export type DiffEntities = MssqlDDL['_']['diffs']['alter'];
+
+export type Schema = MssqlEntities['schemas'];
+export type Table = MssqlEntities['tables'];
+export type Column = MssqlEntities['columns'];
+export type Index = MssqlEntities['indexes'];
+export type DefaultConstraint = MssqlEntities['defaults'];
+export type UniqueConstraint = MssqlEntities['uniques'];
+export type ForeignKey = MssqlEntities['fks'];
+export type PrimaryKey = MssqlEntities['pks'];
+export type CheckConstraint = MssqlEntities['checks'];
+export type View = MssqlEntities['views'];
+
+export type InterimColumn = Column & {
+	isPK: boolean;
+	pkName: string | null;
+	isUnique: boolean;
+	uniqueName: string | null;
+};
+
+export type ViewColumn = {
+	schema: string;
+	view: string;
+	name: string;
+	type: string;
+	notNull: boolean;
+};
+
+export type InterimSchema = {
+	schemas: Schema[];
+	tables: Table[];
+	columns: InterimColumn[];
+	pks: PrimaryKey[];
+	fks: ForeignKey[];
+	indexes: Index[];
+	checks: CheckConstraint[];
+	views: View[];
+	viewColumns: ViewColumn[];
+	uniques: UniqueConstraint[];
+	defaults: DefaultConstraint[];
+};
+
+export type TableFull = {
+	schema: string;
+	name: string;
+	columns: Column[];
+	uniques: UniqueConstraint[];
+	pk: PrimaryKey | null;
+	fks: ForeignKey[];
+	checks: CheckConstraint[];
+	indexes: Index[];
+	defaults: DefaultConstraint[];
+};
+
+export const fullTableFromDDL = (table: Table, ddl: MssqlDDL): TableFull => {
+	const filter = { schema: table.schema, table: table.name } as const;
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const uniques = ddl.uniques.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+	const defaults = ddl.defaults.list(filter);
+
+	return {
+		...table,
+		columns,
+		pk,
+		fks,
+		uniques,
+		checks,
+		indexes,
+		defaults,
+	};
+};
+
+export type SchemaError = {
+	type: 'table_duplicate';
+	name: string;
+	schema: string;
+} | {
+	type: 'column_duplicate';
+	table: string;
+	name: string;
+	schema: string;
+} | {
+	type: 'view_name_duplicate';
+	schema: string;
+	name: string;
+} | {
+	type: 'schema_duplicate';
+	name: string;
+} | {
+	type: 'index_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+} | {
+	type: 'index_no_name';
+	schema: string;
+	table: string;
+	sql: string;
+} | {
+	type: 'constraint_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+};
+
+export const interimToDDL = (interim: InterimSchema): { ddl: MssqlDDL; errors: SchemaError[] } => {
+	const errors = [] as SchemaError[];
+	const ddl = createDDL();
+
+	for (const it of interim.schemas) {
+		const res = ddl.schemas.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'schema_duplicate', name: it.name });
+		}
+	}
+
+	for (const table of interim.tables) {
+		const res = ddl.tables.push(table);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'table_duplicate', name: table.name, schema: res.data.schema });
+		}
+	}
+
+	for (const column of interim.columns) {
+		const { isPK: _1, isUnique: _2, pkName: _3, uniqueName: _4, ...rest } = column;
+
+		const res = ddl.columns.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'column_duplicate', table: column.table, name: column.name, schema: res.data.schema });
+		}
+	}
+
+	for (const index of interim.indexes) {
+		const isConflictNamePerSchema = ddl.indexes.one({ schema: index.schema, name: index.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'index_duplicate',
+				schema: index.schema,
+				table: index.table,
+				name: index.name,
+			});
+		}
+		ddl.indexes.push(index);
+	}
+
+	for (const unique of interim.uniques) {
+		const isConflictNamePerSchema = ddl.uniques.one({ schema: unique.schema, name: unique.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'constraint_duplicate',
+				schema: unique.schema,
+				table: unique.table,
+				name: unique.name,
+			});
+		}
+		ddl.uniques.push(unique);
+	}
+
+	for (const fk of interim.fks) {
+		const isConflictNamePerSchema = ddl.fks.one({ schema: fk.schema, name: fk.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({ type: 'constraint_duplicate', name: fk.name, table: fk.table, schema: fk.schema });
+		}
+
+		ddl.fks.push(fk);
+	}
+
+	for (const pk of interim.pks) {
+		const isConflictNamePerSchema = ddl.pks.one({ schema: pk.schema, name: pk.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({ type: 'constraint_duplicate', name: pk.name, table: pk.table, schema: pk.schema });
+		}
+		ddl.pks.push(pk);
+	}
+
+	for (const column of interim.columns.filter((it) => it.isPK)) {
+		const name = column.pkName !== null ? column.pkName : defaultNameForPK(column.table);
+		const exists = ddl.pks.one({ schema: column.schema, table: column.table, name: name }) !== null;
+		if (exists) continue;
+
+		ddl.pks.push({
+			table: column.table,
+			name,
+			nameExplicit: column.pkName !== null,
+			columns: [column.name],
+			schema: column.schema,
+		});
+	}
+
+	for (const column of interim.columns.filter((it) => it.isUnique)) {
+		const name = column.uniqueName !== null ? column.uniqueName : defaultNameForUnique(column.table, [column.name]);
+		const exists = ddl.uniques.one({ schema: column.schema, table: column.table, name: name }) !== null;
+		if (exists) continue;
+
+		ddl.uniques.push({
+			schema: column.schema,
+			table: column.table,
+			name,
+			nameExplicit: column.uniqueName !== null,
+			columns: [column.name],
+		});
+	}
+
+	for (const columnDefault of interim.defaults) {
+		const res = ddl.defaults.push(columnDefault);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'constraint_duplicate',
+				schema: columnDefault.schema,
+				table: columnDefault.table,
+				name: columnDefault.name,
+			});
+		}
+	}
+
+	for (const check of interim.checks) {
+		const isConflictNamePerSchema = ddl.checks.one({ schema: check.schema, name: check.name });
+
+		if (isConflictNamePerSchema) {
+			errors.push({
+				type: 'constraint_duplicate',
+				schema: check.schema,
+				table: check.table,
+				name: check.name,
+			});
+		}
+
+		ddl.checks.push(check);
+	}
+
+	for (const view of interim.views) {
+		const res = ddl.views.push(view);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'view_name_duplicate',
+				schema: view.schema,
+				name: view.name,
+			});
+		}
+	}
+
+	return { ddl, errors };
+};
diff --git a/drizzle-kit/src/dialects/mssql/diff.ts b/drizzle-kit/src/dialects/mssql/diff.ts
new file mode 100644
index 0000000000..abfad3d7d3
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/diff.ts
@@ -0,0 +1,1045 @@
+import { prepareMigrationRenames, trimChar } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import type { Resolver } from '../common';
+import { diff } from '../dialect';
+import { groupDiffs, preserveEntityNames } from '../utils';
+import { fromJson } from './convertor';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	DiffEntities,
+	ForeignKey,
+	Index,
+	MssqlDDL,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+} from './ddl';
+import { createDDL, fullTableFromDDL } from './ddl';
+import { typesCommutative } from './grammar';
+import type { JsonStatement } from './statements';
+import { prepareStatement } from './statements';
+
+export const ddlDiffDry = async (ddlFrom: MssqlDDL, ddlTo: MssqlDDL, mode: 'default' | 'push') => {
+	const mocks = new Set<string>();
+	return ddlDiff(
+		ddlFrom,
+		ddlTo,
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mode,
+	);
+};
+
+export const ddlDiff = async (
+	ddl1: MssqlDDL,
+	ddl2: MssqlDDL,
+	schemasResolver: Resolver<Schema>,
+	tablesResolver: Resolver<MssqlEntities['tables']>,
+	columnsResolver: Resolver<Column>,
+	viewsResolver: Resolver<View>,
+	uniquesResolver: Resolver<UniqueConstraint>,
+	indexesResolver: Resolver<Index>,
+	checksResolver: Resolver<CheckConstraint>,
+	pksResolver: Resolver<PrimaryKey>,
+	fksResolver: Resolver<ForeignKey>,
+	defaultsResolver: Resolver<DefaultConstraint>,
+	mode: 'default' | 'push',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: { jsonStatement: JsonStatement; sqlStatements: string[] }[];
+	renames: string[];
+}> => {
+	const ddl1Copy = createDDL();
+	for (const entity of ddl1.entities.list()) {
+		ddl1Copy.entities.push(entity);
+	}
+
+	const schemasDiff = diff(ddl1, ddl2, 'schemas');
+	const { created: createdSchemas, deleted: deletedSchemas, renamedOrMoved: renamedSchemas } = await schemasResolver({
+		created: schemasDiff.filter((it) => it.$diffType === 'create'),
+		deleted: schemasDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const rename of renamedSchemas) {
+		ddl1.entities.update({
+			set: {
+				schema: rename.to.name,
+			},
+			where: {
+				schema: rename.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.name,
+			},
+		});
+	}
+
+	const createSchemas = createdSchemas.map((it) => prepareStatement('create_schema', it));
+	const dropSchemas = deletedSchemas.map((it) => prepareStatement('drop_schema', it));
+	const renameSchemas = renamedSchemas.map((it) => prepareStatement('rename_schema', it));
+
+	const tablesDiff = diff(ddl1, ddl2, 'tables');
+
+	const { created: createdTables, deleted: deletedTables, renamedOrMoved: renamedOrMovedTables } = await tablesResolver(
+		{
+			created: tablesDiff.filter((it) => it.$diffType === 'create'),
+			deleted: tablesDiff.filter((it) => it.$diffType === 'drop'),
+		},
+	);
+
+	const renamedTables = renamedOrMovedTables.filter((it) => it.from.name !== it.to.name);
+	const movedTables = renamedOrMovedTables.filter((it) => it.from.schema !== it.to.schema);
+
+	const pksRenames = [] as { from: PrimaryKey; to: PrimaryKey }[];
+	const uniqueRenames = [] as { from: UniqueConstraint; to: UniqueConstraint }[];
+	const fksRenames = [] as { from: ForeignKey; to: ForeignKey }[];
+	const checkRenames = [] as { from: CheckConstraint; to: CheckConstraint }[];
+
+	for (const rename of renamedOrMovedTables) {
+		ddl1.tables.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.schema,
+				tableTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.name,
+			},
+		});
+		ddl1.fks.update({
+			set: {
+				schema: rename.to.schema,
+				table: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.name,
+			},
+		});
+
+		ddl1.entities.update({
+			set: {
+				table: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				table: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const columnsDiff = diff(ddl1, ddl2, 'columns');
+	const columnRenames = [] as { from: Column; to: Column }[];
+	const columnsToCreate = [] as Column[];
+	const columnsToDelete = [] as Column[];
+
+	const groupedByTable = groupDiffs(columnsDiff);
+
+	for (let it of groupedByTable) {
+		const { created, deleted, renamedOrMoved } = await columnsResolver({ created: it.inserted, deleted: it.deleted });
+
+		columnsToCreate.push(...created);
+		columnsToDelete.push(...deleted);
+		columnRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of columnRenames) {
+		ddl1.columns.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl1.pks.update({
+			set: {
+				columns: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				columns: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+		ddl1.fks.update({
+			set: {
+				columnsTo: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.table,
+			},
+		});
+
+		ddl1.uniques.update({
+			set: {
+				columns: (it) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		});
+
+		ddl1.defaults.update({
+			set: { column: rename.to.name },
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+				column: rename.from.name,
+			},
+		});
+
+		ddl1.checks.update({
+			set: {
+				value: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+				value: rename.from.name,
+			},
+		});
+	}
+
+	preserveEntityNames(ddl1.uniques, ddl2.uniques, mode);
+	preserveEntityNames(ddl1.fks, ddl2.fks, mode);
+	preserveEntityNames(ddl1.pks, ddl2.pks, mode);
+	preserveEntityNames(ddl1.defaults, ddl2.defaults, mode);
+
+	const uniquesDiff = diff(ddl1, ddl2, 'uniques');
+	const groupedUniquesDiff = groupDiffs(uniquesDiff);
+
+	const uniqueCreates = [] as UniqueConstraint[];
+	const uniqueDeletes = [] as UniqueConstraint[];
+
+	for (const entry of groupedUniquesDiff) {
+		const { renamedOrMoved: renamed, created, deleted } = await uniquesResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		uniqueCreates.push(...created);
+		uniqueDeletes.push(...deleted);
+		uniqueRenames.push(...renamed);
+	}
+
+	for (const rename of uniqueRenames) {
+		ddl1.uniques.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffChecks = diff(ddl1, ddl2, 'checks');
+	const groupedChecksDiff = groupDiffs(diffChecks);
+	const checkCreates = [] as CheckConstraint[];
+	const checkDeletes = [] as CheckConstraint[];
+
+	for (const entry of groupedChecksDiff) {
+		const { renamedOrMoved, created, deleted } = await checksResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		checkCreates.push(...created);
+		checkDeletes.push(...deleted);
+		checkRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of checkRenames) {
+		ddl1.checks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffIndexes = diff(ddl1, ddl2, 'indexes');
+	const groupedIndexesDiff = groupDiffs(diffIndexes);
+	const indexesRenames = [] as { from: Index; to: Index }[];
+	const indexesCreates = [] as Index[];
+	const indexesDeletes = [] as Index[];
+
+	for (const entry of groupedIndexesDiff) {
+		const { renamedOrMoved, created, deleted } = await indexesResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		indexesCreates.push(...created);
+		indexesDeletes.push(...deleted);
+		indexesRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of indexesRenames) {
+		ddl1.indexes.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffPKs = diff(ddl1, ddl2, 'pks');
+	const groupedPKsDiff = groupDiffs(diffPKs);
+	const pksCreates = [] as PrimaryKey[];
+	const pksDeletes = [] as PrimaryKey[];
+
+	for (const entry of groupedPKsDiff) {
+		const { renamedOrMoved, created, deleted } = await pksResolver({ created: entry.inserted, deleted: entry.deleted });
+
+		pksCreates.push(...created);
+		pksDeletes.push(...deleted);
+		pksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of pksRenames) {
+		ddl1.pks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffFKs = diff(ddl1, ddl2, 'fks');
+	const groupedFKsDiff = groupDiffs(diffFKs);
+	const fksCreates = [] as ForeignKey[];
+	const fksDeletes = [] as ForeignKey[];
+
+	for (const entry of groupedFKsDiff) {
+		const { renamedOrMoved, created, deleted } = await fksResolver({ created: entry.inserted, deleted: entry.deleted });
+
+		fksCreates.push(...created);
+		fksDeletes.push(...deleted);
+		fksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of fksRenames) {
+		ddl1.fks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const viewsDiff = diff(ddl1, ddl2, 'views');
+
+	const { created: createdViews, deleted: deletedViews, renamedOrMoved: renamedOrMovedViews } = await viewsResolver({
+		created: viewsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: viewsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedViews = renamedOrMovedViews.filter((it) => it.from.schema === it.to.schema);
+	const movedViews = renamedOrMovedViews.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedViews) {
+		ddl1.views.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+	for (const move of movedViews) {
+		ddl1.views.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+	}
+
+	const diffDefaults = diff(ddl1, ddl2, 'defaults');
+	const defaultsCreates: DefaultConstraint[] = diffDefaults.filter((it) => it.$diffType === 'create').map((it) => ({
+		...it,
+		$diffType: undefined,
+	}));
+	const defaultsDeletes: DefaultConstraint[] = diffDefaults.filter((it) => it.$diffType === 'drop').map((it) => ({
+		...it,
+		$diffType: undefined,
+	}));
+
+	// TODO for now drizzle-orm does not provides passing names for defaults
+	// for (const entry of groupedDefaultsDiff) {
+	// 	const { renamedOrMoved, created, deleted } = await defaultsResolver({
+	// 		created: entry.inserted,
+	// 		deleted: entry.deleted,
+	// 	});
+
+	// 	defaultsCreates.push(...created);
+	// 	defaultsDeletes.push(...deleted);
+	// 	defaultsRenames.push(...renamedOrMoved);
+	// }
+	// for (const rename of defaultsRenames) {
+	// 	ddl1.defaults.update({
+	// 		set: {
+	// 			name: rename.to.name,
+	// 			schema: rename.to.schema,
+	// 		},
+	// 		where: {
+	// 			name: rename.from.name,
+	// 			schema: rename.from.schema,
+	// 		},
+	// 	});
+	// }
+
+	const alters = diff.alters(ddl1, ddl2);
+
+	const jsonStatements: JsonStatement[] = [];
+
+	/*
+		with new DDL when table gets created with constraints, etc.
+		or existing table with constraints and indexes gets deleted,
+		those entites are treated by diff as newly created or deleted
+
+		we filter them out, because we either create them on table creation
+		or they get automatically deleted when table is deleted
+	*/
+	const tablesFilter = (type: 'deleted' | 'created') => {
+		return (it: { schema: string; table: string }) => {
+			if (type === 'created') {
+				return !createdTables.some((t) => t.schema === it.schema && t.name === it.table);
+			} else {
+				return !deletedTables.some((t) => t.schema === it.schema && t.name === it.table);
+			}
+		};
+	};
+
+	const columnsFilter = (_type: 'added') => {
+		return (it: { schema: string; table: string; column: string }) => {
+			return !columnsToCreate.some((t) => t.schema === it.schema && t.table === it.table && t.name === it.column);
+		};
+	};
+
+	const createTables = createdTables.map((it) =>
+		prepareStatement('create_table', { table: fullTableFromDDL(it, ddl2) })
+	);
+
+	const jsonDropTables = deletedTables.map((it) =>
+		prepareStatement('drop_table', { table: fullTableFromDDL(it, ddl2) })
+	);
+	const jsonRenameTables = renamedTables.map((it) =>
+		prepareStatement('rename_table', {
+			schema: it.from.schema,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonRenameColumnsStatements = columnRenames.map((it) => prepareStatement('rename_column', it));
+	const jsonDropColumnsStatemets = columnsToDelete.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_column', { column: it })
+	);
+	const jsonAddColumnsStatemets = columnsToCreate.filter(tablesFilter('created')).map((it) => {
+		const isPK = ddl2.pks.one({ schema: it.schema, table: it.table, columns: { CONTAINS: it.name } }) !== null;
+		return prepareStatement('add_column', {
+			column: it,
+			defaults: ddl2.defaults.list(),
+			isPK,
+		});
+	});
+	const columnAlters = alters.filter((it) => it.entityType === 'columns').filter((it) => Object.keys(it).length > 5); // $difftype, entitytype, schema, table, name
+
+	const columnsToRecreate = columnAlters.filter((it) => it.generated).filter((it) => {
+		return !(mode === 'push' && it.generated && it.generated.from && it.generated.to
+			&& it.generated.from.as !== it.generated.to.as && it.generated.from.type === it.generated.to.type);
+	});
+
+	const jsonRecreateColumns = columnsToRecreate.map((it) =>
+		prepareStatement('recreate_column', {
+			diff: it,
+		})
+	);
+
+	// identity alters are not allowed, only recreate
+	const jsonAlterColumns = columnAlters.filter((it) => !(it.generated) && !(it.identity)).filter((it) => {
+		if (it.notNull && (it.$right.generated || it.$right.identity)) {
+			delete it.notNull;
+		}
+
+		if (it.type && typesCommutative(it.type.from, it.type.to, mode)) {
+			delete it.type;
+		}
+
+		// const pkIn2 = ddl2.pks.one({ schema: it.schema, table: it.table, columns: { CONTAINS: it.name } });
+		// When adding primary key to column it is needed to add not null first
+		// if (it.notNull && pkIn2) {
+		// 	delete it.notNull;
+		// }
+
+		// const pkIn1 = ddl1.pks.one({ schema: it.schema, table: it.table, columns: { CONTAINS: it.name } });
+		// if (it.notNull && it.notNull.from && pkIn1 && !pkIn2) {
+		// 	delete it.notNull;
+		// }
+
+		if ((it.$right.generated || it.$left.generated) && it.$right.type !== it.$left.type) {
+			delete it.type;
+		}
+
+		return ddl2.columns.hasDiff(it);
+	}).map(
+		(it) => {
+			return prepareStatement('alter_column', {
+				diff: it,
+			});
+		},
+	);
+
+	const jsonSetTableSchemas = movedTables.map((it) =>
+		prepareStatement('move_table', {
+			name: it.to.name, // raname of table comes first
+			from: it.from.schema,
+			to: it.to.schema,
+		})
+	);
+
+	const jsonRecreateIdentityColumns = columnAlters.filter((it) => it.identity).map((column) => {
+		const checksToCreate = ddl2.checks.list({
+			schema: column.schema,
+			table: column.table,
+		});
+		const uniquesToCreate = ddl2.uniques.list({
+			schema: column.schema,
+			table: column.table,
+			columns: {
+				CONTAINS: column.name,
+			},
+		});
+		const pksToCreate = ddl2.pks.list({
+			schema: column.schema,
+			table: column.table,
+			columns: {
+				CONTAINS: column.name,
+			},
+		});
+		const defToCreate = ddl2.defaults.list({
+			schema: column.schema,
+			table: column.table,
+			column: column.name,
+		});
+		const fk1ToCreate = ddl2.fks.list({
+			schema: column.schema,
+			table: column.table,
+			columns: { CONTAINS: column.name },
+		});
+		const fk2ToCreate = ddl2.fks.list({
+			schemaTo: column.schema,
+			tableTo: column.table,
+			columnsTo: { CONTAINS: column.name },
+		});
+		const indexesToCreate = ddl2.indexes.list({
+			schema: column.schema,
+			table: column.table,
+		}).filter((index) => index.columns.some((x) => trimChar(trimChar(x.value, '['), ']') === column.name));
+
+		const checksToDelete = ddl1.checks.list({
+			schema: column.schema,
+			table: column.table,
+		});
+		const uniquesToDelete = ddl1.uniques.list({
+			schema: column.schema,
+			table: column.table,
+			columns: {
+				CONTAINS: column.name,
+			},
+		});
+		const pksToDelete = ddl1.pks.list({
+			schema: column.schema,
+			table: column.table,
+			columns: {
+				CONTAINS: column.name,
+			},
+		});
+		const defToDelete = ddl1.defaults.list({
+			schema: column.schema,
+			table: column.table,
+			column: column.name,
+		});
+		const fk1ToDelete = ddl1.fks.list({
+			schema: column.schema,
+			table: column.table,
+			columns: { CONTAINS: column.name },
+		});
+		const fk2ToDelete = ddl1.fks.list({
+			schemaTo: column.schema,
+			tableTo: column.table,
+			columnsTo: { CONTAINS: column.name },
+		});
+		const indexesToDelete = ddl1.indexes.list({
+			schema: column.schema,
+			table: column.table,
+		}).filter((index) => index.columns.some((x) => trimChar(trimChar(x.value, '['), ']') === column.name));
+
+		return prepareStatement('recreate_identity_column', {
+			column: column,
+			constraintsToCreate: [
+				...checksToCreate,
+				...uniquesToCreate,
+				...pksToCreate,
+				...defToCreate,
+				...fk1ToCreate,
+				...fk2ToCreate,
+				...indexesToCreate,
+			],
+			constraintsToDelete: [
+				...checksToDelete,
+				...fk1ToDelete,
+				...fk2ToDelete,
+				...uniquesToDelete,
+				...pksToDelete,
+				...defToDelete,
+				...indexesToDelete,
+			],
+			defaults: ddl2.defaults.list(),
+		});
+	});
+
+	// filter identity
+	const checkIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: CheckConstraint | DiffEntities['checks']) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'checks'
+					&& constraint.name === it.name
+					&& constraint.table === it.table
+					&& constraint.schema === it.schema
+				);
+			});
+		};
+	};
+	const jsonCreatedCheckConstraints = checkCreates.filter(tablesFilter('created')).filter(
+		checkIdentityFilter('created'),
+	).map((
+		it,
+	) => prepareStatement('add_check', { check: it }));
+	const jsonDeletedCheckConstraints = checkDeletes.filter(tablesFilter('deleted')).filter(
+		checkIdentityFilter('deleted'),
+	).map((
+		it,
+	) => prepareStatement('drop_check', { check: it }));
+	const jsonRenamedCheckConstraints = checkRenames.map((it) =>
+		prepareStatement('rename_check', { from: it.from, to: it.to })
+	);
+
+	const filteredChecksAlters = alters.filter((it) => it.entityType === 'checks').filter(
+		(it): it is DiffEntities['checks'] => {
+			if (it.entityType !== 'checks') return false;
+
+			if (it.value && mode === 'push') {
+				delete it.value;
+			}
+
+			return ddl2.checks.hasDiff(it);
+		},
+	);
+
+	const alteredChecks = filteredChecksAlters.filter(checkIdentityFilter('created')).filter(
+		checkIdentityFilter('deleted'),
+	);
+	alteredChecks.forEach((it) => {
+		jsonCreatedCheckConstraints.push(prepareStatement('add_check', { check: it.$right }));
+		jsonDeletedCheckConstraints.push(prepareStatement('drop_check', { check: it.$left }));
+	});
+
+	// filter identity
+	const uniquesIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: UniqueConstraint) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'uniques'
+					&& constraint.name === it.name
+					&& constraint.table === it.table
+					&& constraint.schema === it.schema
+				);
+			});
+		};
+	};
+	const jsonAddedUniqueConstraints = uniqueCreates.filter(tablesFilter('created')).filter(
+		uniquesIdentityFilter('created'),
+	).map((it) => prepareStatement('add_unique', { unique: it }));
+	const jsonDeletedUniqueConstraints = uniqueDeletes.filter(tablesFilter('deleted')).filter(
+		uniquesIdentityFilter('deleted'),
+	).map((it) => {
+		return prepareStatement('drop_unique', { unique: it });
+	});
+	const jsonRenameUniqueConstraints = uniqueRenames.map((it) =>
+		prepareStatement('rename_unique', { from: it.from, to: it.to })
+	);
+
+	// filter identity
+	const primaryKeysIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: PrimaryKey | DiffEntities['pks']) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'pks'
+					&& constraint.name === it.name
+					&& constraint.table === it.table
+					&& constraint.schema === it.schema
+				);
+			});
+		};
+	};
+	const jsonAddPrimaryKeys = pksCreates.filter(tablesFilter('created')).filter(primaryKeysIdentityFilter('created'))
+		.map((it) => prepareStatement('create_pk', { pk: it }));
+	const jsonDropPrimaryKeys = pksDeletes.filter(tablesFilter('deleted')).filter(primaryKeysIdentityFilter('deleted'))
+		.map((it) => prepareStatement('drop_pk', { pk: it }));
+	const jsonRenamePrimaryKeys = pksRenames.map((it) => prepareStatement('rename_pk', { from: it.from, to: it.to }));
+	const alteredPKs = alters.filter((it) => it.entityType === 'pks').filter((it) => {
+		return !!it.columns;
+	});
+	alteredPKs.filter(primaryKeysIdentityFilter('deleted')).filter(primaryKeysIdentityFilter('deleted')).forEach((it) => {
+		jsonAddPrimaryKeys.push({ pk: it.$right, type: 'create_pk' });
+		jsonDropPrimaryKeys.push({ pk: it.$left, type: 'drop_pk' });
+	});
+
+	// filter identity
+	const defaultsIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: DefaultConstraint | DiffEntities['defaults']) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'defaults'
+					&& constraint.name === it.name
+					&& constraint.table === it.table
+					&& constraint.schema === it.schema
+				);
+			});
+		};
+	};
+	const jsonCreateDefaults = defaultsCreates.filter(tablesFilter('created'))
+		.filter(columnsFilter('added'))
+		.filter(
+			defaultsIdentityFilter('created'),
+		)
+		.map((defaultValue) =>
+			prepareStatement('create_default', {
+				default: defaultValue,
+			})
+		);
+	const jsonDropDefaults = defaultsDeletes.filter(tablesFilter('deleted'))
+		.filter(defaultsIdentityFilter('deleted'))
+		.map((defaultValue) => prepareStatement('drop_default', { default: defaultValue }));
+	const alteredDefaults = alters.filter((it) => it.entityType === 'defaults')
+		.filter((it) => {
+			if (it.nameExplicit) {
+				delete it.nameExplicit;
+			}
+
+			if (it.default) {
+				let deleteDefault = false;
+				deleteDefault ||= it.default.from === it.default.to;
+
+				const column = ddl2.columns.one({ name: it.column?.to, schema: it.schema, table: it.table })!;
+				const numbers = ['bigint', 'decimal', 'numeric', 'real', 'float'];
+
+				// When user defined value in drizzle sql that is bigger than `max mssql integer` it will be stored with dot
+				// 1. === 1 (same values in mssql)
+				// For commutativity replace all this
+				// For .default this will be handled automatically via introspection, but this is for drizzlesql cases
+				if (numbers.find((it) => column.type.startsWith(it)) && it.default.from && it.default.to) {
+					it.default.from = it.default.from.replace('.)', ')').replace(".'", "'");
+					it.default.to = it.default.to.replace('.)', ')').replace(".'", "'");
+					deleteDefault ||= it.default.from === it.default.to;
+				}
+
+				// any literal number from drizzle sql is parsed as (<number>), not ((<number>)) as from .default
+				// this will cause diff, but still (10) === ((10))
+				deleteDefault ||= it.default.from === `(${it.default.to})`; // for drizzle sql numbers: (<number>) === ((<number>))
+				deleteDefault ||= it.default.to === `(${it.default.from})`; // for drizzle sql numbers: (<number>) === ((<number>))
+
+				if (deleteDefault) {
+					delete it.default;
+				}
+			}
+
+			return ddl2.defaults.hasDiff(it);
+		})
+		.filter(defaultsIdentityFilter('created'))
+		.filter(defaultsIdentityFilter('deleted'));
+	const jsonRecreatedDefaults = alteredDefaults.map((it) =>
+		prepareStatement('recreate_default', {
+			from: it.$left,
+			to: it.$right,
+		})
+	);
+
+	// filter identity
+	const fksIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: ForeignKey | DiffEntities['fks']) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'fks'
+					&& constraint.name === it.name
+					&& ((constraint.table === it.table && constraint.schema === it.schema)
+						|| (constraint.schemaTo === it.schemaTo && it.tableTo === constraint.tableTo))
+				);
+			});
+		};
+	};
+	const jsonCreateReferences = fksCreates.filter(fksIdentityFilter('created')).map((
+		it,
+	) => prepareStatement('create_fk', { fk: it }));
+
+	const jsonDropReferences = fksDeletes.filter((x) => {
+		const fromDeletedTable = ddl2.tables.one({ schema: x.schema, name: x.table }) === null;
+		const toDeletedTable = (x.schema !== x.schemaTo
+			|| x.tableTo !== x.table) && ddl2.tables.one({ schema: x.schemaTo, name: x.tableTo }) === null;
+		if (fromDeletedTable && !toDeletedTable) return false;
+		return true;
+	}).filter(fksIdentityFilter('deleted')).map((it) => prepareStatement('drop_fk', { fk: it }));
+
+	const jsonRenameReferences = fksRenames.map((it) =>
+		prepareStatement('rename_fk', {
+			from: it.from,
+			to: it.to,
+		})
+	);
+	alters.filter((it) => it.entityType === 'fks').filter((x) => {
+		if (
+			x.nameExplicit
+			&& ((mode === 'push' && x.nameExplicit.from && !x.nameExplicit.to)
+				|| x.nameExplicit.to && !x.nameExplicit.from)
+		) {
+			delete x.nameExplicit;
+		}
+
+		return ddl2.fks.hasDiff(x);
+	}).filter(fksIdentityFilter('created')).filter(
+		fksIdentityFilter('deleted'),
+	).forEach((it) => {
+		jsonDropReferences.push(prepareStatement('drop_fk', { fk: it.$left }));
+		jsonCreateReferences.push(prepareStatement('create_fk', { fk: it.$right }));
+	});
+
+	// filter identity
+	const indexesIdentityFilter = (type: 'created' | 'deleted') => {
+		return (it: Index | DiffEntities['indexes']) => {
+			return !jsonRecreateIdentityColumns.some((column) => {
+				const constraints = type === 'created' ? column.constraintsToCreate : column.constraintsToDelete;
+
+				return constraints.some((constraint) =>
+					constraint.entityType === 'indexes'
+					&& constraint.name === it.name
+					&& constraint.table === it.table
+					&& constraint.schema === it.schema
+				);
+			});
+		};
+	};
+	const jsonCreateIndexes = indexesCreates.filter(indexesIdentityFilter('created')).map((index) =>
+		prepareStatement('create_index', { index })
+	);
+	const jsonDropIndexes = indexesDeletes.filter(indexesIdentityFilter('deleted')).filter(tablesFilter('deleted')).map((
+		index,
+	) => prepareStatement('drop_index', { index }));
+	const jsonRenameIndex = indexesRenames.map((it) => prepareStatement('rename_index', { from: it.from, to: it.to }));
+	for (
+		const idx of alters.filter((it) => it.entityType === 'indexes').filter(indexesIdentityFilter('created')).filter(
+			indexesIdentityFilter('deleted'),
+		)
+	) {
+		const forWhere = !!idx.where && (idx.where.from !== null && idx.where.to !== null ? mode !== 'push' : true);
+		const forColumns = !!idx.columns && (idx.columns.from.length === idx.columns.to.length ? mode !== 'push' : true);
+
+		// TODO recheck this
+		if (idx.isUnique || forColumns || forWhere) {
+			const index = ddl2.indexes.one({ schema: idx.schema, table: idx.table, name: idx.name })!;
+			jsonDropIndexes.push(prepareStatement('drop_index', { index }));
+			jsonCreateIndexes.push(prepareStatement('create_index', { index }));
+		}
+	}
+
+	const createViews = createdViews.map((it) => prepareStatement('create_view', { view: it }));
+
+	const jsonDropViews = deletedViews.map((it) => prepareStatement('drop_view', { view: it }));
+
+	const jsonRenameViews = renamedViews.map((it) => prepareStatement('rename_view', it));
+
+	const jsonMoveViews = movedViews.map((it) =>
+		prepareStatement('move_view', { fromSchema: it.from.schema, toSchema: it.to.schema, view: it.to })
+	);
+
+	const filteredViewAlters = alters.filter((it): it is DiffEntities['views'] => {
+		if (it.entityType !== 'views') return false;
+
+		if (it.definition && mode === 'push' && !it.schemaBinding) {
+			delete it.definition;
+		}
+
+		return ddl2.views.hasDiff(it);
+	});
+	const jsonAlterViews = filteredViewAlters.map((it) => {
+		return prepareStatement('alter_view', {
+			diff: it,
+			view: ddl2.views.one({ schema: it.schema, name: it.name })!,
+		});
+	});
+
+	jsonStatements.push(...createSchemas);
+	jsonStatements.push(...renameSchemas);
+
+	jsonStatements.push(...createTables);
+
+	jsonStatements.push(...jsonDropViews);
+	jsonStatements.push(...jsonRenameViews);
+	jsonStatements.push(...jsonMoveViews);
+	jsonStatements.push(...jsonAlterViews);
+	jsonStatements.push(...jsonRecreatedDefaults);
+
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonDropReferences);
+
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonSetTableSchemas);
+
+	jsonStatements.push(...jsonDeletedCheckConstraints); // should be before renaming column
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...jsonDeletedUniqueConstraints);
+	jsonStatements.push(...jsonDropDefaults);
+
+	// Will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonDropIndexes);
+	jsonStatements.push(...jsonDropPrimaryKeys);
+
+	jsonStatements.push(...jsonAddColumnsStatemets);
+	jsonStatements.push(...jsonRecreateColumns);
+	jsonStatements.push(...jsonRecreateIdentityColumns);
+	jsonStatements.push(...jsonAlterColumns);
+	jsonStatements.push(...jsonAddPrimaryKeys);
+	jsonStatements.push(...jsonRenamePrimaryKeys);
+
+	jsonStatements.push(...jsonCreateReferences);
+	jsonStatements.push(...jsonCreateDefaults);
+	jsonStatements.push(...jsonCreateIndexes);
+	jsonStatements.push(...jsonRenameIndex);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+
+	jsonStatements.push(...jsonAddedUniqueConstraints);
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+	jsonStatements.push(...jsonRenamedCheckConstraints);
+	jsonStatements.push(...jsonRenameUniqueConstraints);
+	jsonStatements.push(...jsonRenameReferences);
+	// jsonStatements.push(...jsonRenameDefaults);
+
+	jsonStatements.push(...createViews);
+
+	jsonStatements.push(...dropSchemas);
+
+	const { groupedStatements, sqlStatements } = fromJson(jsonStatements);
+
+	const renames = prepareMigrationRenames([
+		...renameSchemas,
+		...renamedOrMovedTables,
+		...columnRenames,
+		...uniqueRenames,
+		...checkRenames,
+		...indexesRenames,
+		...pksRenames,
+		...fksRenames,
+		...renamedOrMovedViews,
+	]);
+
+	return {
+		statements: jsonStatements,
+		sqlStatements,
+		groupedStatements: groupedStatements,
+		renames: renames,
+	};
+};
diff --git a/drizzle-kit/src/dialects/mssql/drizzle.ts b/drizzle-kit/src/dialects/mssql/drizzle.ts
new file mode 100644
index 0000000000..33e7079ac1
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/drizzle.ts
@@ -0,0 +1,412 @@
+import { getTableName, is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { AnyMsSqlColumn, AnyMsSqlTable } from 'drizzle-orm/mssql-core';
+import {
+	getTableConfig,
+	getViewConfig,
+	MsSqlColumn,
+	MsSqlDialect,
+	MsSqlSchema,
+	MsSqlTable,
+	MsSqlView,
+} from 'drizzle-orm/mssql-core';
+import { loadModule } from '../../utils/utils-node';
+import { sqlToStr } from '../drizzle';
+import type { EntityFilter } from '../pull-utils';
+import type { DefaultConstraint, InterimSchema, MssqlEntities, Schema, SchemaError } from './ddl';
+import { defaultNameForDefault, defaultNameForFK, defaultNameForPK, defaultNameForUnique, typeFor } from './grammar';
+
+export const upper = <T extends string>(value: T | undefined): Uppercase<T> | null => {
+	if (!value) return null;
+	return value.toUpperCase() as Uppercase<T>;
+};
+
+export const defaultFromColumn = (
+	column: AnyMsSqlColumn,
+): DefaultConstraint['default'] | null => {
+	if (typeof column.default === 'undefined') return null;
+	const def = column.default;
+
+	const sqlTypeLowered = column.getSQLType().toLowerCase();
+
+	if (is(def, SQL)) {
+		// extra wrapping
+		const str = sqlToStr(def);
+		if (!str.startsWith('(')) return `(${str})`;
+
+		return str;
+	}
+
+	const grammarType = typeFor(sqlTypeLowered);
+	if (grammarType) return grammarType.defaultFromDrizzle(def);
+
+	throw new Error(`unexpected default: ${column.getSQLType().toLowerCase()} ${column.default}`);
+};
+
+export const fromDrizzleSchema = (
+	schema: {
+		schemas: MsSqlSchema[];
+		tables: AnyMsSqlTable[];
+		views: MsSqlView[];
+	},
+	filter: EntityFilter,
+): { schema: InterimSchema; errors: SchemaError[] } => {
+	const dialect = new MsSqlDialect();
+	const errors: SchemaError[] = [];
+
+	const schemas = schema.schemas
+		.filter((x) => {
+			return !x.isExisting && x.schemaName !== 'dbo' && filter({ type: 'schema', name: x.schemaName });
+		})
+		.map<Schema>((it) => ({
+			entityType: 'schemas',
+			name: it.schemaName,
+		}));
+
+	const tableConfigPairs = schema.tables.map((it) => {
+		return { config: getTableConfig(it), table: it };
+	});
+
+	const tables = tableConfigPairs.map((it) => {
+		const config = it.config;
+
+		return {
+			entityType: 'tables',
+			schema: config.schema ?? 'dbo',
+			name: config.name,
+		} satisfies MssqlEntities['tables'];
+	});
+
+	const result: InterimSchema = {
+		schemas: schemas,
+		tables: tables,
+		columns: [],
+		pks: [],
+		fks: [],
+		indexes: [],
+		checks: [],
+		views: [],
+		viewColumns: [],
+		uniques: [],
+		defaults: [],
+	};
+
+	for (const { config } of tableConfigPairs) {
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			foreignKeys,
+			schema: drizzleSchema,
+			checks,
+			primaryKeys,
+			uniqueConstraints,
+		} = config;
+
+		const schema = drizzleSchema || 'dbo';
+		if (!filter({ type: 'table', schema, name: tableName })) {
+			continue;
+		}
+
+		for (const pk of primaryKeys) {
+			const columnNames = pk.columns.map((c: any) => c.name);
+
+			const name = pk.name || defaultNameForPK(tableName);
+
+			result.pks.push({
+				entityType: 'pks',
+				table: tableName,
+				schema: schema,
+				name: name,
+				nameExplicit: pk.isNameExplicit,
+				columns: columnNames,
+			});
+		}
+
+		for (const column of columns) {
+			const columnName = column.name;
+
+			const isPk = result.pks.find((it) =>
+				it.columns.includes(columnName) && it.table === tableName && it.schema === schema
+			) !== undefined;
+
+			// if column is part of composite primary key, it is implicitly not null in db
+			const notNull: boolean = column.notNull || Boolean(isPk);
+
+			// @ts-expect-error
+			// Drizzle ORM gives this value in runtime, but not in types.
+			// After sync with Andrew, we decided to fix this with Dan later
+			// That's due to architecture problems we have in columns and complex abstraction we should avoid
+			// for now we are sure this value is here
+			// If it's undefined - than users didn't provide any identity
+			// If it's an object with seed/increment and a) both are undefined - use default identity startegy
+			// b) some of them have values - use them
+			// Note: you can't have only one value. Either both are undefined or both are defined
+			const identity = column.identity as { seed: number; increment: number } | undefined;
+
+			const generated = column.generated
+				? {
+					as: is(column.generated.as, SQL)
+						? dialect.sqlToQuery(column.generated.as as SQL).sql
+						: typeof column.generated.as === 'function'
+						? dialect.sqlToQuery(column.generated.as() as SQL).sql
+						: `${column.generated.as}`,
+					type: column.generated.mode ?? 'virtual',
+				}
+				: null;
+
+			result.columns.push({
+				schema,
+				entityType: 'columns',
+				table: tableName,
+				name: columnName,
+				type: column.getSQLType(),
+				pkName: null,
+				notNull: notNull,
+				// @ts-expect-error
+				// TODO update description
+				// 'virtual' | 'stored' for all dialects
+				// 'virtual' | 'persisted' for mssql
+				// We should remove this option from common Column and store it per dialect common
+				// Was discussed with Andrew
+				// Type erorr because of common in drizzle orm for all dialects (includes virtual' | 'stored' | 'persisted')
+				generated,
+				identity: identity ?? null,
+				isPK: column.primary,
+				isUnique: column.isUnique,
+				uniqueName: column.uniqueName ?? null,
+			});
+
+			if (typeof column.default !== 'undefined') {
+				result.defaults.push({
+					entityType: 'defaults',
+					name: defaultNameForDefault(tableName, columnName),
+					nameExplicit: false,
+					schema,
+					column: columnName,
+					table: tableName,
+					default: defaultFromColumn(column),
+				});
+			}
+		}
+
+		for (const unique of uniqueConstraints) {
+			const columns = unique.columns.map((c) => {
+				return c.name;
+			});
+
+			const name = unique.name ?? defaultNameForUnique(tableName, unique.columns.map((c) => c.name));
+
+			result.uniques.push({
+				entityType: 'uniques',
+				table: tableName,
+				name: name,
+				schema: schema,
+				nameExplicit: unique.isNameExplicit,
+				columns: columns,
+			});
+		}
+
+		for (const fk of foreignKeys) {
+			const reference = fk.reference();
+
+			const referenceFT = reference.foreignTable;
+
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			const tableTo = getTableName(referenceFT);
+
+			const columnsFrom = reference.columns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => it.name);
+
+			let name = fk.getName() || defaultNameForFK(tableName, columnsFrom, tableTo, columnsTo);
+			result.fks.push({
+				entityType: 'fks',
+				table: tableName,
+				name,
+				schema,
+				columns: columnsFrom,
+				tableTo,
+				columnsTo,
+				nameExplicit: fk.isNameExplicit(),
+				schemaTo: getTableConfig(fk.reference().foreignTable).schema || 'dbo',
+				onUpdate: upper(fk.onUpdate) ?? 'NO ACTION',
+				onDelete: upper(fk.onDelete) ?? 'NO ACTION',
+			});
+		}
+
+		for (const index of indexes) {
+			const columns = index.config.columns;
+			const name = index.config.name;
+
+			for (const column of columns) {
+				// TODO index names are required, why this is here?
+				// potentially can be removed
+				if (is(column, SQL) && !index.config.name) {
+					errors.push({
+						type: 'index_no_name',
+						schema: schema,
+						table: getTableName(index.config.table),
+						sql: dialect.sqlToQuery(column).sql,
+					});
+					continue;
+				}
+			}
+
+			let where = index.config.where ? dialect.sqlToQuery(index.config.where, 'indexes').sql : '';
+			where = where === 'true' ? '' : where;
+
+			result.indexes.push({
+				entityType: 'indexes',
+				table: tableName,
+				name,
+				schema,
+				columns: columns.map((it) => {
+					if (is(it, SQL)) {
+						const sql = dialect.sqlToQuery(it, 'indexes').sql;
+						return { value: sql, isExpression: true };
+					} else {
+						return { value: it.name, isExpression: false };
+					}
+				}),
+				isUnique: index.config.unique ?? false,
+				where: where ? where : null,
+			});
+		}
+
+		for (const check of checks) {
+			const name = check.name;
+			const value = check.value;
+
+			result.checks.push({
+				entityType: 'checks',
+				table: tableName,
+				schema,
+				name,
+				value: dialect.sqlToQuery(value, 'mssql-check').sql,
+			});
+		}
+	}
+
+	for (
+		// see in "./dialects/postgres/drizzle.ts" for more
+		const view of schema.views.sort((a, b) => {
+			const aConfig = getViewConfig(a);
+			const bConfig = getViewConfig(b);
+
+			// If a's fields include b, a depends on b → b comes first
+			if (aConfig.query?.queryChunks.includes(b)) return 1;
+
+			// If b's fields include a, b depends on a → a comes first
+			if (bConfig.query?.queryChunks.includes(a)) return -1;
+
+			return 0;
+		})
+	) {
+		const cfg = getViewConfig(view);
+		const {
+			isExisting,
+			name,
+			query,
+			schema: drizzleSchema,
+			selectedFields,
+			checkOption,
+			encryption,
+			schemaBinding,
+			viewMetadata,
+		} = cfg;
+
+		if (isExisting) continue;
+		if (!filter({ type: 'table', schema: drizzleSchema ?? 'dbo', name })) continue;
+
+		const schema = drizzleSchema ?? 'dbo';
+
+		for (const key in selectedFields) {
+			if (is(selectedFields[key], MsSqlColumn)) {
+				const column = selectedFields[key];
+				const notNull: boolean = column.notNull;
+
+				result.viewColumns.push({
+					view: name,
+					schema,
+					name: column.name,
+					type: column.getSQLType(),
+					notNull: notNull,
+				});
+			}
+		}
+
+		result.views.push({
+			entityType: 'views',
+			name,
+			definition: query
+				? dialect.sqlToQuery(query, schemaBinding ? 'mssql-view-with-schemabinding' : undefined).sql
+				: '',
+			checkOption: checkOption ?? false, // defaut
+			encryption: encryption ?? false, // default
+			schema,
+			schemaBinding: schemaBinding ?? false, // default
+			viewMetadata: viewMetadata ?? false, // default
+		});
+	}
+
+	return { schema: result, errors };
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnyMsSqlTable[] = [];
+	const schemas: MsSqlSchema[] = [];
+	const views: MsSqlView[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = fromExports(i0);
+
+		tables.push(...prepared.tables);
+		schemas.push(...prepared.schemas);
+		views.push(...prepared.views);
+		relations.push(...prepared.relations);
+	}
+
+	return {
+		tables,
+		schemas,
+		views,
+		relations,
+	};
+};
+
+export const fromExports = (exports: Record<string, unknown>) => {
+	const tables: AnyMsSqlTable[] = [];
+	const schemas: MsSqlSchema[] = [];
+	const views: MsSqlView[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (is(t, MsSqlTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, MsSqlSchema)) {
+			schemas.push(t);
+		}
+
+		if (is(t, MsSqlView)) {
+			views.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return {
+		tables,
+		schemas,
+		views,
+		relations,
+	};
+};
diff --git a/drizzle-kit/src/dialects/mssql/grammar.ts b/drizzle-kit/src/dialects/mssql/grammar.ts
new file mode 100644
index 0000000000..8b0f9ff0d8
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/grammar.ts
@@ -0,0 +1,778 @@
+import { assertUnreachable, trimChar } from '../../utils';
+import { parse, stringify } from '../../utils/when-json-met-bigint';
+import { hash } from '../common';
+import { escapeForSqlDefault, escapeForTsLiteral, parseParams, unescapeFromSqlDefault } from '../utils';
+import type { DefaultConstraint, MssqlEntities } from './ddl';
+import type { Import } from './typescript';
+
+const getDefaultOptions = (x: keyof typeof defaults.options): string | null => {
+	return defaults.options[x as keyof typeof defaults.options]
+		? Object.values(defaults.options[x as keyof typeof defaults.options]).join(',')
+		: null;
+};
+const getFloatPrecisionFrom = (x: number) => {
+	return 1 <= x && x <= 24 ? 24 : 25 <= x && x <= 53 ? 53 : x;
+};
+export const defaults = {
+	options: {
+		numeric: {
+			precision: 18,
+			scale: 0,
+		},
+		decimal: {
+			precision: 18,
+			scale: 0,
+		},
+		time: {
+			precision: 7,
+		},
+		float: {
+			precision: 53,
+		},
+		varchar: {
+			length: 1,
+		},
+		char: {
+			length: 1,
+		},
+		nvarchar: {
+			length: 1,
+		},
+		nchar: {
+			length: 1,
+		},
+		datetime2: {
+			precision: 7,
+		},
+		datetimeoffset: {
+			precision: 7,
+		},
+		binary: {
+			length: 1,
+		},
+		varbinary: {
+			length: 1,
+		},
+	},
+	max_int_value: 2147483647,
+	min_int_value: -2147483648,
+} as const;
+
+export const defaultNameForPK = (table: string) => {
+	const desired = `${table}_pkey`;
+	const res = desired.length > 128
+		? `${hash(desired)}_pkey` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const defaultNameForUnique = (table: string, column: string[]) => {
+	const desired = `${table}_${column.join('_')}_key`;
+	const res = desired.length > 128
+		? table.length < 128 - 18 // _{hash(12)}_key
+			? `${table}_${hash(desired)}_key`
+			: `${hash(desired)}_key` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const defaultNameForFK = (table: string, columns: string[], tableTo: string, columnsTo: string[]) => {
+	const desired = `${table}_${columns.join('_')}_${tableTo}_${columnsTo.join('_')}_fk`;
+	const res = desired.length > 128
+		? table.length < 128 - 18 // _{hash(12)}_fkey
+			? `${table}_${hash(desired)}_fk`
+			: `${hash(desired)}_fk` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const defaultNameForDefault = (table: string, column: string) => {
+	const desired = `${table}_${column}_default`;
+	const res = desired.length > 128
+		? table.length < 128 - 18 // _{hash(12)}_default
+			? `${table}_${hash(desired)}__default`
+			: `${hash(desired)}__default` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export type OnAction = MssqlEntities['fks']['onUpdate'];
+export const parseFkAction = (type: string): OnAction => {
+	switch (type) {
+		case 'NO_ACTION':
+			return 'NO ACTION';
+		case 'SET_NULL':
+			return 'SET NULL';
+		case 'CASCADE':
+			return 'CASCADE';
+		case 'SET_DEFAULT':
+			return 'SET DEFAULT';
+		default:
+			throw new Error(`Unknown foreign key type: ${type}`);
+	}
+};
+
+const viewAsStatementRegex =
+	/\bAS\b\s*\(?\s*(WITH[\s\S]+?SELECT[\s\S]*?|SELECT[\s\S]*?)\)?(?=\s+WITH CHECK OPTION\b|\s*;?$)/i;
+export const parseViewSQL = (sql: string | null): string | null => {
+	if (!sql) return ''; // this means that used is_encrypted
+
+	const match = sql.match(viewAsStatementRegex);
+	return match ? match[1] : null;
+};
+
+const viewMetadataRegex = /\bwith\b\s+([^)]*\bview_metadata\b[^)]*)(\s+as\b|\s*,)/i;
+export const parseViewMetadataFlag = (sql: string | null): boolean => {
+	if (!sql) return false;
+
+	const match = sql.match(viewMetadataRegex);
+	return match ? true : false;
+};
+
+export const bufferToBinary = (str: Buffer) => {
+	return '0x' + (str.toString('hex')).toUpperCase();
+};
+
+export const parseDefault = (type: string, def: string) => {
+	const grammarType = typeFor(type);
+	return grammarType.defaultFromIntrospect(def);
+};
+
+const commutativeTypes = [
+	['char', `char(${getDefaultOptions('char')})`],
+	['nchar', `nchar(${getDefaultOptions('nchar')})`],
+	['varchar', `varchar(${getDefaultOptions('varchar')})`],
+	['nvarchar', `nvarchar(${getDefaultOptions('nvarchar')})`],
+	['datetime2', `datetime2(${getDefaultOptions('datetime2')})`],
+	['datetimeoffset', `datetimeoffset(${getDefaultOptions('datetimeoffset')})`],
+	['time', `time(${getDefaultOptions('time')})`],
+	['binary', `binary(${getDefaultOptions('binary')})`],
+	['varbinary', `varbinary(${getDefaultOptions('varbinary')})`],
+	['decimal', `decimal(${getDefaultOptions('decimal')})`],
+	['numeric', `numeric(${getDefaultOptions('numeric')})`],
+	['float', `float(${getDefaultOptions('float')})`],
+];
+export const typesCommutative = (
+	left: string,
+	right: string,
+	mode: 'push' | 'default',
+) => {
+	for (const it of commutativeTypes) {
+		const leftIn = it.some((x) => x === left);
+		const rightIn = it.some((x) => x === right);
+
+		if (leftIn && rightIn) return true;
+	}
+
+	if (mode === 'push') {
+		if (left.replace(',0)', ')') === right.replace(',0)', ')')) return true; // { from: 'decimal(19,0)', to: 'decimal(19)' }
+
+		// SQL Server treats n as one of two possible values. If 1<=n<=24, n is treated as 24. If 25<=n<=53, n is treated as 53
+		// https://learn.microsoft.com/en-us/sql/t-sql/data-types/float-and-real-transact-sql?view=sql-server-ver16
+		// SQL Server treats float(24) as real
+		if (left === 'real' && right.startsWith('float')) {
+			const rightOptions = parseParams(right).join(',');
+
+			if (Number(rightOptions) <= 24) return true;
+		}
+		if (right.startsWith('float') && right === 'float') {
+			const leftOptions = parseParams(left).join(',');
+
+			if (Number(leftOptions) <= 24) return true;
+		}
+		if (right.startsWith('float') && right.startsWith('float')) {
+			const leftOptions = parseParams(left).join(',');
+			const rightOptions = parseParams(right).join(',');
+
+			if (getFloatPrecisionFrom(Number(leftOptions)) === getFloatPrecisionFrom(Number(rightOptions))) return true;
+		}
+	}
+	return false;
+};
+
+const checkNumber = (it: string) => {
+	const check = Number(it);
+
+	if (Number.isNaN(check)) return 'NaN';
+	if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) return 'number';
+	return 'bigint';
+};
+
+export interface SqlType {
+	is(type: string): boolean;
+	drizzleImport(): Import;
+	defaultFromDrizzle(value: unknown): DefaultConstraint['default'];
+	defaultFromIntrospect(value: string): DefaultConstraint['default'];
+	toTs(
+		type: string,
+		value: DefaultConstraint['default'],
+	): { options?: Record<string, unknown>; default: string; customType?: string };
+}
+
+export const Int: SqlType = {
+	is: (type: string) => type === 'int',
+	drizzleImport: () => 'int',
+	defaultFromDrizzle: (value: unknown) => {
+		const stringified = String(value);
+
+		// mssql wraps each number in extra ()
+		return `((${stringified}))`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		// mssql stores values that are bigger than `int` with dots
+		const tmp = value.replace('.))', '))');
+		const checked = checkNumber(trimChar(trimChar(tmp, ['(', ')']), ['(', ')']));
+		if (checked === 'NaN') return value;
+		return tmp;
+	},
+	toTs: (_type, value) => {
+		if (!value) return { default: '' };
+
+		// cases from introspect:
+		// int DEFAULT '10' --> ('10')
+		// int DEFAULT 10  --> ((10))
+		value = value.substring(1, value.length - 1);
+
+		const trimmed = trimChar(value, ['(', ')']);
+
+		const numType = checkNumber(trimmed);
+		if (numType === 'NaN') return { default: `sql\`${value}\`` };
+		return { default: trimmed };
+	},
+};
+export const TinyInt: SqlType = {
+	is: (type: string) => type === 'tinyint',
+	drizzleImport: () => 'tinyint',
+	defaultFromDrizzle: Int.defaultFromDrizzle,
+	defaultFromIntrospect: Int.defaultFromIntrospect,
+	toTs: Int.toTs,
+};
+export const SmallInt: SqlType = {
+	is: (type: string) => type === 'smallint',
+	drizzleImport: () => 'smallint',
+	defaultFromDrizzle: Int.defaultFromDrizzle,
+	defaultFromIntrospect: Int.defaultFromIntrospect,
+	toTs: Int.toTs,
+};
+export const BigInt: SqlType = {
+	is: (type: string) => type === 'bigint',
+	drizzleImport: () => 'bigint',
+	defaultFromDrizzle: (value: unknown) => {
+		return `((${String(value)}))`;
+	},
+	defaultFromIntrospect: Int.defaultFromIntrospect,
+	toTs: (_type, value) => {
+		if (value === null) return { options: { mode: 'number' }, default: '' };
+
+		// cases from introspect:
+		// bigintint DEFAULT '10' --> ('10')
+		// bigintint DEFAULT '9007199254740994' --> ('9007199254740994')
+		// bigintint DEFAULT '9007199254740994.' --> ('9007199254740994.')
+		// bigintint DEFAULT 9007199254740994 --> ((9007199254740994.))
+		// bigintint DEFAULT 10  --> ((10))
+		value = value.substring(1, value.length - 1);
+
+		const tmp = value.replaceAll('.)', ')');
+		const trimmed = trimChar(tmp, ['(', ')']);
+
+		const numType = checkNumber(trimmed);
+
+		if (numType === 'NaN') return { options: { mode: 'bigint' }, default: `sql\`${value}\`` };
+		if (numType === 'number') return { options: { mode: 'number' }, default: trimmed };
+		if (numType === 'bigint') return { options: { mode: 'bigint' }, default: `${trimmed}n` };
+		assertUnreachable(numType);
+	},
+};
+
+export const Bit: SqlType = {
+	is: (type) => type === 'bit',
+	drizzleImport: () => 'bit',
+	defaultFromDrizzle: (value: unknown) => {
+		return String(value) === 'true' ? '((1))' : '((0))';
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	toTs: (_type, value) => {
+		if (value === null) return { default: '' };
+
+		// cases
+		// bit 1 -> ((1))
+		// bit 1. -> ((1.)) -> edge case
+		// bit '1' -> ('1') -> edge case
+		// bit '1.' -> ('1.') -> this is not valid syntax to insert
+		value = value.substring(1, value.length - 1);
+		if (value === '(1)') return { default: 'true' };
+		if (value === '(0)') return { default: 'false' };
+
+		return { default: `sql\`${value}\`` };
+	},
+};
+
+export const Char: SqlType = {
+	is: (type: string) => type === 'char' || type.startsWith('char('),
+	drizzleImport: () => 'char',
+	defaultFromDrizzle: (value) => {
+		const val = String(value);
+
+		return `('${escapeForSqlDefault(val)}')`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		// for text compatibility
+		let optionsToSet: { length: number | 'max' } | undefined;
+
+		const param = parseParams(type)[0];
+		if (param) optionsToSet = { length: param === 'max' ? 'max' : Number(param) };
+
+		if (!value) return { default: '', options: optionsToSet };
+
+		// ('text')
+		// remove outer ( and )
+		value = value.substring(1, value.length - 1);
+		const isTSQLStringLiteral = (str: string) => {
+			// Trim and check if string starts and ends with a single quote
+			if (!/^'.*'$/.test(str.trim())) return false;
+
+			// Remove the surrounding quotes
+			const inner = str.trim().slice(1, -1);
+
+			// Check for valid internal quote escaping: only doubled single quotes are allowed
+			return !/[^']'[^']/.test(inner); // there should be no unescaped (lonely) single quotes
+		};
+
+		if (isTSQLStringLiteral(value)) {
+			// remove extra ' and '
+			value = value.substring(1, value.length - 1);
+			const unescaped = unescapeFromSqlDefault(value);
+			const escaped = escapeForTsLiteral(unescaped);
+
+			return { options: optionsToSet, default: escaped };
+		}
+
+		return { options: optionsToSet, default: `sql\`${value}\`` };
+	},
+};
+export const NChar: SqlType = {
+	is: (type: string) => type === 'nchar' || type.startsWith('nchar('),
+	drizzleImport: () => 'nchar',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	toTs: Char.toTs,
+};
+export const Varchar: SqlType = {
+	is: (type) => type === 'varchar' || type.startsWith('varchar('),
+	drizzleImport: () => 'varchar',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	toTs: Char.toTs,
+};
+export const NVarchar: SqlType = {
+	is: (type: string) => type === 'nvarchar' || type.startsWith('nvarchar('),
+	drizzleImport: () => 'nvarchar',
+	defaultFromDrizzle: (value: unknown) => {
+		let result: string;
+
+		if (typeof value === 'string') result = escapeForSqlDefault(value);
+		else if (typeof value === 'object' || Array.isArray(value)) {
+			result = stringify(value, (_, value) => {
+				if (typeof value !== 'string') return value;
+				return value.replaceAll("'", "''");
+			});
+		} else {
+			throw new Error(`unexpected default: ${value}`);
+		}
+
+		return `('${result}')`;
+	},
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	toTs: (type, value) => {
+		// for text compatibility
+		let optionsToSet: { length: number | 'max' } | undefined;
+
+		const param = parseParams(type)[0];
+		if (param) optionsToSet = { length: param === 'max' ? 'max' : Number(param) };
+
+		if (!value) return { default: '', options: optionsToSet };
+
+		// ('text')
+		// remove outer ( and )
+		value = value.substring(1, value.length - 1);
+		const isTSQLStringLiteral = (str: string) => {
+			// Trim and check if string starts and ends with a single quote
+			if (!/^'.*'$/.test(str.trim())) return false;
+
+			// Remove the surrounding quotes
+			const inner = str.trim().slice(1, -1);
+
+			// Check for valid internal quote escaping: only doubled single quotes are allowed
+			// 'text'+'text' - not pass
+			// 'text''text' - pass
+			return !/[^']'[^']/.test(inner); // there should be no unescaped (lonely) single quotes
+		};
+
+		if (!isTSQLStringLiteral(value)) {
+			return { options: optionsToSet, default: `sql\`${value}\`` };
+		}
+
+		try {
+			const parsed = parse(trimChar(value, "'"), (_, v) => {
+				if (typeof v === 'string') {
+					return unescapeFromSqlDefault(v);
+				}
+				return v;
+			});
+
+			return {
+				default: stringify(parsed, undefined, undefined, true)!,
+				options: { mode: 'json', ...optionsToSet },
+			};
+		} catch {}
+
+		// remove extra ' and '
+		value = value.substring(1, value.length - 1);
+		const unescaped = unescapeFromSqlDefault(value);
+		const escaped = escapeForTsLiteral(unescaped);
+
+		return { options: optionsToSet, default: escaped };
+	},
+};
+export const Text: SqlType = {
+	is: (type: string) => type === 'text' || type.startsWith('text('),
+	drizzleImport: () => 'text',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	toTs: Char.toTs,
+};
+export const NText: SqlType = {
+	is: (type: string) => type === 'ntext' || type.startsWith('ntext('),
+	drizzleImport: () => 'ntext',
+	defaultFromDrizzle: Text.defaultFromDrizzle,
+	defaultFromIntrospect: Text.defaultFromIntrospect,
+	toTs: Text.toTs,
+};
+
+export const Decimal: SqlType = {
+	is: (type: string) => type === 'decimal' || type.startsWith('decimal('),
+	drizzleImport: () => 'decimal',
+	defaultFromDrizzle: (value) => {
+		return `((${String(value)}))`;
+	},
+	defaultFromIntrospect: (value) => {
+		// mssql stores values that are bigger than `int` with dots
+		const tmp = value.replace('.))', '))');
+		const checked = checkNumber(trimChar(trimChar(tmp, ['(', ')']), ['(', ')']));
+		if (checked === 'NaN') return value;
+		return tmp;
+	},
+	toTs: (type, value) => {
+		const optionsToSet: any = {};
+
+		const params = parseParams(type);
+		if (params.length) {
+			const [p, s] = params;
+			if (p) optionsToSet['precision'] = Number(p);
+			if (s) optionsToSet['scale'] = Number(s);
+		}
+
+		if (!value) return { options: optionsToSet, default: '' };
+		// cases:
+		// [column] decimal DEFAULT '6.32' --> ('6.32') -> edge case
+		// [column1] decimal DEFAULT '6.' --> ('6.') -> edge case
+		// [column2] decimal DEFAULT '6' --> ('6') -> edge case
+		// [column3] decimal DEFAULT 6.32 --> ((6.32))
+		// [column5] decimal DEFAULT 6 --> ((6))
+		value = value.substring(1, value.length - 1);
+
+		const trimmed = trimChar(value, ['(', ')']);
+
+		const numType = checkNumber(trimmed);
+
+		if (numType === 'NaN') return { options: { ...optionsToSet, mode: 'bigint' }, default: `sql\`${value}\`` };
+		if (numType === 'number') return { options: { ...optionsToSet, mode: 'number' }, default: trimmed };
+		if (numType === 'bigint') return { options: { ...optionsToSet, mode: 'bigint' }, default: `${trimmed}n` };
+		assertUnreachable(numType);
+	},
+};
+export const Numeric: SqlType = {
+	is: (type: string) => type === 'numeric' || type.startsWith('numeric('),
+	drizzleImport: () => 'numeric',
+	defaultFromDrizzle: Decimal.defaultFromDrizzle,
+	defaultFromIntrospect: Decimal.defaultFromIntrospect,
+	toTs: Decimal.toTs,
+};
+
+export const Float: SqlType = {
+	is: (type: string) => type === 'float' || type.startsWith('float('),
+	drizzleImport: () => 'float',
+	defaultFromDrizzle: (value) => {
+		return `((${String(value)}))`;
+	},
+	defaultFromIntrospect: (value) => {
+		// mssql stores values that are bigger than `int` with dots
+		const tmp = value.replace('.))', '))');
+		const checked = checkNumber(trimChar(trimChar(tmp, ['(', ')']), ['(', ')']));
+		if (checked === 'NaN') return value;
+		return tmp;
+	},
+	toTs: (type, value) => {
+		const param = parseParams(type)[0];
+		const optionsToSet = { precision: Number(param) };
+
+		if (!value) return { default: '', options: optionsToSet };
+
+		// cases:
+		// [column] float DEFAULT '6.32' --> ('6.32') -> mapped to ((6.32))
+		// [column2] float DEFAULT '6' --> ('6') -> mapped to ((6))
+		// [column3] float DEFAULT 6.32 --> ((6.32))
+		// [column5] float DEFAULT 6 --> ((6))
+		value = value.substring(1, value.length - 1);
+
+		const trimmed = trimChar(value, ['(', ')']);
+
+		const numType = checkNumber(trimmed);
+
+		if (numType === 'NaN') return { options: optionsToSet, default: `sql\`${value}\`` };
+		return { options: optionsToSet, default: trimmed };
+	},
+};
+export const Real: SqlType = {
+	is: (type: string) => type === 'real' || type.startsWith('real('),
+	drizzleImport: () => 'real',
+	defaultFromDrizzle: Float.defaultFromDrizzle,
+	defaultFromIntrospect: Float.defaultFromIntrospect,
+	toTs: (_type, value) => {
+		if (!value) return { default: '' };
+
+		// cases:
+		// [column] float DEFAULT '6.32' --> ('6.32') -> edge case
+		// [column1] float DEFAULT '6.' --> ('6.') -> edge case
+		// [column2] float DEFAULT '6' --> ('6') -> edge case
+		// [column3] float DEFAULT 6.32 --> ((6.32))
+		// [column5] float DEFAULT 6 --> ((6))
+		value = value.substring(1, value.length - 1);
+
+		const trimmed = trimChar(value, ['(', ')']);
+
+		const numType = checkNumber(trimmed);
+		if (numType === 'NaN') return { default: `sql\`${value}\`` };
+		if (numType === 'number') return { default: trimmed };
+		if (numType === 'bigint') return { default: `${trimmed}n` };
+		assertUnreachable(numType);
+	},
+};
+
+export const Datetime: SqlType = {
+	is: (type) => type === 'datetime' || type.startsWith('datetime('),
+	drizzleImport: () => 'datetime',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `('${value.toISOString().replace('T', ' ').replace('Z', '')}')`;
+		}
+
+		return `('${String(value)}')`;
+	},
+	defaultFromIntrospect: (value: string) => {
+		return value;
+	},
+	toTs: (_type, value) => {
+		const options: { mode: string } = { mode: 'string' };
+
+		if (!value) return { default: '', options };
+
+		if (value === '(getdate())') return { default: '.defaultGetDate()', options };
+
+		// remove ( and )
+		// ('2024-12-42 12:00:00')
+		value = value.substring(1, value.length - 1);
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+};
+export const DateType: SqlType = {
+	is: (type) => type === 'date' || type.startsWith('date('),
+	drizzleImport: () => 'date',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `('${value.toISOString().split('T')[0]}')`;
+		}
+
+		return `('${String(value)}')`;
+	},
+	defaultFromIntrospect: Datetime.defaultFromIntrospect,
+	toTs: Datetime.toTs,
+};
+export const Datetime2: SqlType = {
+	is: (type) => type === 'datetime2' || type.startsWith('datetime2('),
+	drizzleImport: () => 'datetime2',
+	defaultFromDrizzle: Datetime.defaultFromDrizzle,
+	defaultFromIntrospect: Datetime.defaultFromIntrospect,
+	toTs: (type, value) => {
+		const options: { mode: string; precision: number } = {
+			mode: 'string',
+			precision: defaults.options.datetime2.precision,
+		};
+
+		const param = parseParams(type)[0];
+		if (param) options['precision'] = Number(param);
+
+		if (!value) return { default: '', options };
+
+		// remove ( and )
+		// ('2024-12-42 12:00:00')
+		value = value.substring(1, value.length - 1);
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+};
+export const Datetimeoffset: SqlType = {
+	is: (type) => type === 'datetimeoffset' || type.startsWith('datetimeoffset('),
+	drizzleImport: () => 'datetimeoffset',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `('${value.toISOString()}')`;
+		}
+
+		return `('${String(value)}')`;
+	},
+	defaultFromIntrospect: Datetime.defaultFromIntrospect,
+	toTs: (type, value) => {
+		const options: { mode: string; precision: number } = {
+			mode: 'string',
+			precision: defaults.options.datetimeoffset.precision,
+		};
+
+		const param = parseParams(type)[0];
+		if (param) options['precision'] = Number(param);
+
+		if (!value) return { default: '', options };
+
+		if (value === '(getdate())') return { default: '.defaultGetDate()', options };
+
+		// remove ( and )
+		// ('2024-12-42 12:00:00')
+		value = value.substring(1, value.length - 1);
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+};
+export const Time: SqlType = {
+	is: (type) => type === 'time' || type.startsWith('time('),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: (value: unknown) => {
+		if (value instanceof Date) {
+			return `('${value.toISOString().split('T')[1].replace('Z', '')}')`;
+		}
+
+		return `('${String(value)}')`;
+	},
+	defaultFromIntrospect: Datetime.defaultFromIntrospect,
+	toTs: (type, value) => {
+		const options: { mode: string; precision: number } = {
+			mode: 'string',
+			precision: defaults.options.time.precision,
+		};
+
+		const param = parseParams(type)[0];
+		if (param) options['precision'] = Number(param);
+
+		if (!value) return { default: '', options };
+
+		// remove ( and )
+		// ('2024-12-42 12:00:00')
+		value = value.substring(1, value.length - 1);
+		// check for valid date
+		if (isNaN(Date.parse(value.substring(1, value.length - 1)))) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		return { default: value, options };
+	},
+};
+
+export const Binary: SqlType = {
+	is: (type) => type === 'binary' || type.startsWith('binary('),
+	drizzleImport: () => 'binary',
+	defaultFromDrizzle: (value) => {
+		if (Buffer.isBuffer(value)) {
+			return `(${bufferToBinary(value)})`;
+		}
+		throw Error('unexpected binary default');
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const optionsToSet: { length: number | 'max' } = { length: defaults.options.binary.length };
+
+		const param = parseParams(type)[0];
+		if (param) optionsToSet['length'] = param === 'max' ? 'max' : Number(param);
+
+		// (0x...)
+		const def = value ? `sql\`${value.substring(1, value.length - 1)}\`` : '';
+		return { options: optionsToSet, default: def };
+	},
+};
+export const Varbinary: SqlType = {
+	is: (type) => type === 'varbinary' || type.startsWith('varbinary('),
+	drizzleImport: () => 'varbinary',
+	defaultFromDrizzle: Binary.defaultFromDrizzle,
+	defaultFromIntrospect: Binary.defaultFromIntrospect,
+	toTs: Binary.toTs,
+};
+
+export const Custom: SqlType = {
+	is: () => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'customType',
+	defaultFromDrizzle: (value) => {
+		return `('${String(value)}')`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		return { default: `sql\`${value}\``, customType: type };
+	},
+};
+
+export const typeFor = (sqlType: string): SqlType => {
+	if (Int.is(sqlType)) return Int;
+	if (TinyInt.is(sqlType)) return TinyInt;
+	if (SmallInt.is(sqlType)) return SmallInt;
+	if (BigInt.is(sqlType)) return BigInt;
+	if (Bit.is(sqlType)) return Bit;
+	if (Char.is(sqlType)) return Char;
+	if (NChar.is(sqlType)) return NChar;
+	if (Varchar.is(sqlType)) return Varchar;
+	if (NVarchar.is(sqlType)) return NVarchar;
+	if (Text.is(sqlType)) return Text;
+	if (NText.is(sqlType)) return NText;
+	if (Decimal.is(sqlType)) return Decimal;
+	if (Numeric.is(sqlType)) return Numeric;
+	if (Float.is(sqlType)) return Float;
+	if (Real.is(sqlType)) return Real;
+	if (DateType.is(sqlType)) return DateType;
+	if (Datetime.is(sqlType)) return Datetime;
+	if (Datetime2.is(sqlType)) return Datetime2;
+	if (Datetimeoffset.is(sqlType)) return Datetimeoffset;
+	if (Time.is(sqlType)) return Time;
+	if (Binary.is(sqlType)) return Binary;
+	if (Varbinary.is(sqlType)) return Varbinary;
+	return Custom;
+};
diff --git a/drizzle-kit/src/dialects/mssql/introspect.ts b/drizzle-kit/src/dialects/mssql/introspect.ts
new file mode 100644
index 0000000000..43f1e3c154
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/introspect.ts
@@ -0,0 +1,741 @@
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import type { DB } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import { filterMigrationsSchema } from '../utils';
+import type {
+	CheckConstraint,
+	DefaultConstraint,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimSchema,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import { parseDefault, parseFkAction, parseViewMetadataFlag, parseViewSQL } from './grammar';
+
+export const fromDatabase = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+): Promise<InterimSchema> => {
+	const schemas: Schema[] = [];
+	const tables: MssqlEntities['tables'][] = [];
+	const columns: InterimColumn[] = [];
+	const indexes: Index[] = [];
+	const pks: PrimaryKey[] = [];
+	const fks: ForeignKey[] = [];
+	const uniques: UniqueConstraint[] = [];
+	const checks: CheckConstraint[] = [];
+	const defaults: DefaultConstraint[] = [];
+	const views: View[] = [];
+	const viewColumns: ViewColumn[] = [];
+
+	// schema_id is needed for not joining tables by schema name but just to pass where schema_id = id
+	const introspectedSchemas = await db.query<{ schema_name: string; schema_id: number }>(`
+	SELECT s.name as schema_name, s.schema_id as schema_id
+	FROM sys.schemas s
+	JOIN sys.database_principals p ON s.principal_id = p.principal_id
+	WHERE p.type IN ('S', 'U')  -- Only SQL users and Windows users
+	  AND s.name NOT IN ('guest', 'INFORMATION_SCHEMA', 'sys')
+	ORDER BY lower(s.name);
+	`).then((rows) => {
+		queryCallback('schemas', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('schemas', [], error);
+		throw error;
+	});
+
+	const filteredSchemas = introspectedSchemas.filter((it) => filter({ type: 'schema', name: it.schema_name }));
+
+	schemas.push(
+		...filteredSchemas.filter((it) => it.schema_name !== 'dbo').map<Schema>((it) => ({
+			entityType: 'schemas',
+			name: it.schema_name,
+		})),
+	);
+
+	const filteredSchemaIds = filteredSchemas.map((it) => it.schema_id);
+
+	const tablesList = await db
+		.query<{
+			object_id: number;
+			schema_id: number;
+			name: string;
+		}>(`
+			SELECT 
+	object_id as object_id,
+	schema_id AS schema_id,
+    name AS name
+FROM 
+    sys.tables
+WHERE 
+	schema_id IN (${filteredSchemaIds.join(', ')})
+	AND sys.tables.is_ms_shipped = 0
+ORDER BY lower(name);
+`).then((rows) => {
+			queryCallback('tables', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('tables', [], error);
+			throw error;
+		});
+
+	const viewsList = await db.query<{
+		name: string;
+		object_id: number;
+		schema_id: number;
+		with_check_option: boolean;
+		definition: string;
+		schema_binding: boolean;
+	}>(`
+SELECT 
+views.name as name,
+views.object_id as object_id,
+views.schema_id as schema_id,
+views.with_check_option as with_check_option,
+modules.definition as definition,
+modules.is_schema_bound as schema_binding
+FROM 
+sys.views views
+LEFT JOIN sys.sql_modules modules on modules.object_id = views.object_id
+WHERE views.schema_id IN (${filteredSchemaIds.join(', ')})
+	  AND views.is_ms_shipped = 0
+ORDER BY lower(views.name);
+`).then((rows) => {
+			queryCallback('views', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('views', [], error);
+			throw error;
+		});
+
+	const filteredTables = tablesList.filter((it) => {
+		const schema = filteredSchemas.find((schema) => schema.schema_id === it.schema_id)!;
+
+		if (!filter({ type: 'table', schema: schema.schema_name, name: it.name })) return false;
+		return true;
+	})
+		.map((it) => {
+			const schema = filteredSchemas.find((schema) => schema.schema_id === it.schema_id)!;
+
+			return {
+				...it,
+				schema: schema.schema_name,
+			};
+		});
+
+	const filteredTableIds = filteredTables.map((it) => it.object_id);
+	const filteredViewIds = viewsList.map((it) => it.object_id);
+	const filteredViewsAndTableIds = [...filteredTableIds, ...filteredViewIds];
+
+	if (filteredViewIds.length === 0 && filteredTableIds.length === 0) {
+		return {
+			schemas,
+			tables: [],
+			columns: [],
+			pks: [],
+			fks: [],
+			indexes: [],
+			uniques: [],
+			defaults: [],
+			checks: [],
+			views: [],
+			viewColumns: [],
+		};
+	}
+
+	const filterByTableIds = filteredTableIds.length > 0 ? `(${filteredTableIds.join(',')})` : '';
+	const filterByTableAndViewIds = filteredViewsAndTableIds.length > 0 ? `(${filteredViewsAndTableIds.join(',')})` : '';
+
+	for (const table of filteredTables) {
+		tables.push({
+			entityType: 'tables',
+			schema: table.schema,
+			name: table.name,
+		});
+	}
+
+	const checkConstraintQuery = await db.query<{
+		name: string;
+		schema_id: number;
+		parent_table_id: number;
+		definition: string;
+		is_system_named: boolean;
+	}>(`
+SELECT 
+	name as name, 
+	schema_id as schema_id, 
+	parent_object_id as parent_table_id, 
+	definition as definition, 
+	is_system_named as is_system_named 
+FROM sys.check_constraints
+${filterByTableIds ? 'WHERE parent_object_id in ' + filterByTableIds : ''}
+ORDER BY lower(name)
+;`).then((rows) => {
+		queryCallback('checks', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('checks', [], error);
+		throw error;
+	});
+
+	const defaultsConstraintQuery = await db.query<{
+		name: string;
+		schema_id: number;
+		parent_table_id: number;
+		parent_column_id: number;
+		definition: string;
+		is_system_named: boolean;
+	}>(`
+SELECT 
+	name as name, 
+	schema_id as schema_id, 
+	parent_object_id as parent_table_id, 
+	parent_column_id as parent_column_id, 
+	definition as definition, 
+	is_system_named as is_system_named 
+FROM sys.default_constraints
+${filterByTableIds ? 'WHERE parent_object_id in ' + filterByTableIds : ''}
+ORDER BY lower(name)
+;`).then((rows) => {
+		queryCallback('defaults', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('defaults', [], error);
+		throw error;
+	});
+
+	type ForeignKeyRow = {
+		name: string;
+		schema_id: number;
+		parent_table_id: number;
+		parent_column_id: number;
+		on_delete: string;
+		on_update: string;
+		is_system_named: boolean;
+		reference_table_id: number;
+		reference_column_id: number;
+	};
+
+	const fkCostraintQuery = await db.query<ForeignKeyRow>(`
+SELECT 
+	fk.name as name,
+	fk.schema_id as schema_id, 
+	fkc.parent_object_id as parent_table_id, 
+	fkc.parent_column_id as parent_column_id, 
+	fk.delete_referential_action_desc as on_delete,
+	fk.update_referential_action_desc as on_update,
+	fk.is_system_named as is_system_named,
+	fkc.referenced_object_id as reference_table_id,
+	fkc.referenced_column_id as reference_column_id
+ FROM 
+sys.foreign_keys fk
+LEFT JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
+WHERE fk.schema_id IN (${filteredSchemaIds.join(', ')})
+ORDER BY lower(fk.name);
+ 	`).then((rows) => {
+		queryCallback('fks', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('fks', [], error);
+		throw error;
+	});
+
+	type RawIdxsAndConstraints = {
+		table_id: number;
+		index_id: number;
+		name: string;
+		is_unique: boolean;
+		is_primary_key: boolean;
+		is_unique_constraint: boolean;
+		has_filter: boolean;
+		filter_definition: string;
+		column_id: number;
+	};
+
+	const pksUniquesAndIdxsQuery = await db.query<RawIdxsAndConstraints>(`
+		SELECT 
+			i.object_id as table_id,
+			i.index_id as index_id,
+			i.name AS name,
+			i.is_unique as is_unique,
+			i.is_primary_key as is_primary_key,
+			i.is_unique_constraint as is_unique_constraint,
+			i.has_filter as has_filter,
+			i.filter_definition as filter_definition,
+			ic.column_id as column_id
+		FROM sys.indexes i
+		INNER JOIN sys.index_columns ic 
+			ON i.object_id = ic.object_id
+			AND i.index_id = ic.index_id
+		${filterByTableIds ? 'WHERE i.object_id in ' + filterByTableIds : ''}
+		ORDER BY lower(i.name);`)
+		.then((rows) => {
+			queryCallback('indexes', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('indexes', [], error);
+			throw error;
+		});
+
+	const columnsQuery = await db.query<{
+		column_id: number;
+		table_object_id: number;
+		name: string;
+		system_type_id: number;
+		max_length_bytes: number;
+		precision: number;
+		scale: number;
+		is_nullable: boolean;
+		is_identity: boolean;
+		is_computed: boolean;
+		default_object_id: number;
+		seed_value: number;
+		increment_value: number;
+		type: string;
+		generated_always_definition: string | null;
+		generated_is_persisted: boolean;
+		rel_kind: 'U' | 'V';
+	}>(`
+SELECT 
+  col.column_id as column_id,
+  col.object_id as table_object_id,
+  col.name as name,
+  col.system_type_id as system_type_id,
+  col.max_length as max_length_bytes,
+  col.precision as precision,
+  col.scale as scale,
+  col.is_nullable as is_nullable,
+  col.is_identity as is_identity,
+  col.is_computed as is_computed,
+  col.default_object_id as default_object_id,
+  col.generated_always_type as generated_always_type,
+  CAST(idc.seed_value AS INT) AS seed_value,
+  CAST(idc.increment_value AS INT) AS increment_value,
+  types.name as type,
+  computed.definition as generated_always_definition,
+  computed.is_persisted as generated_is_persisted,
+  obj.type as rel_kind
+FROM sys.columns col
+LEFT JOIN sys.types types 
+  ON types.system_type_id = col.system_type_id AND types.user_type_id = col.user_type_id
+LEFT JOIN sys.identity_columns idc 
+  ON idc.object_id = col.object_id AND idc.column_id = col.column_id
+LEFT JOIN sys.computed_columns computed 
+  ON computed.object_id = col.object_id AND computed.column_id = col.column_id
+LEFT JOIN sys.objects obj 
+  ON obj.object_id = col.object_id
+WHERE obj.type in ('U', 'V')
+	AND col.object_id IN ${filterByTableAndViewIds};
+`).then((rows) => {
+			queryCallback('columns', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('columns', [], error);
+			throw error;
+		});
+
+	// TODO add counting
+	let columnsCount = 0;
+	let indexesCount = 0;
+	let foreignKeysCount = 0;
+	let tableCount = 0;
+	let checksCount = 0;
+	let viewsCount = 0;
+
+	const [
+		checkConstraintList,
+		defaultsConstraintList,
+		fkCostraintList,
+		pksUniquesAndIdxsList,
+		columnsList,
+	] = await Promise
+		.all([
+			checkConstraintQuery,
+			defaultsConstraintQuery,
+			fkCostraintQuery,
+			pksUniquesAndIdxsQuery,
+			columnsQuery,
+		]);
+
+	columnsCount = columnsList.length;
+	tableCount = filteredTables.length;
+
+	for (const column of columnsList.filter((it) => it.rel_kind.trim() === 'U')) {
+		const table = filteredTables.find((it) => it.object_id === column.table_object_id);
+		if (!table) continue; // skip if no table found
+
+		const schema = filteredSchemas.find((it) => it.schema_id === table.schema_id)!;
+		const precision = column.precision;
+		const scale = column.scale;
+		const bytesLength = column.max_length_bytes;
+
+		const formatLength = (length: number | null, divisor: number = 1) => {
+			if (length === null) return '';
+			if (length === -1) return 'max';
+			return `${length / divisor}`;
+		};
+
+		const parseOptions = (type: string) => {
+			if (type === 'nchar' || type === 'nvarchar') {
+				return formatLength(bytesLength, 2);
+			}
+
+			if (type === 'char' || type === 'varchar' || type === 'binary' || type === 'varbinary') {
+				return formatLength(bytesLength);
+			}
+
+			if (type === 'float') {
+				return String(precision);
+			}
+
+			if (type === 'datetimeoffset' || type === 'datetime2' || type === 'time') {
+				return String(scale);
+			}
+
+			if (type === 'decimal' || type === 'numeric') {
+				return `${precision},${scale}`;
+			}
+
+			return null;
+		};
+		const options = parseOptions(column.type);
+
+		const columnType = column.type + (options ? `(${options})` : '');
+
+		const unique = pksUniquesAndIdxsList.filter((it) => it.is_unique_constraint).find((it) => {
+			return it.table_id === table.object_id && it.column_id === column.column_id;
+		}) ?? null;
+
+		const pk = pksUniquesAndIdxsList.filter((it) => it.is_primary_key).find((it) => {
+			return it.table_id === table.object_id && it.column_id === column.column_id;
+		}) ?? null;
+
+		columns.push({
+			entityType: 'columns',
+			schema: schema.schema_name,
+			table: table.name,
+			name: column.name,
+			type: columnType,
+			isUnique: unique ? true : false,
+			uniqueName: unique ? unique.name : null,
+			pkName: pk ? pk.name : null,
+			notNull: !column.is_nullable && !column.is_identity,
+			isPK: pk ? true : false,
+			generated: column.is_computed
+				? {
+					as: column.generated_always_definition!,
+					type: column.generated_is_persisted ? 'persisted' : 'virtual',
+				}
+				: null,
+			identity: column.is_identity
+				? {
+					increment: column.increment_value,
+					seed: column.seed_value,
+				}
+				: null,
+		});
+	}
+
+	type GroupedIdxsAndContraints = Omit<RawIdxsAndConstraints, 'column_id'> & {
+		column_ids: number[];
+	};
+	const groupedIdxsAndContraints: GroupedIdxsAndContraints[] = Object.values(
+		pksUniquesAndIdxsList.reduce((acc: Record<string, GroupedIdxsAndContraints>, row: RawIdxsAndConstraints) => {
+			const table = filteredTables.find((it) => it.object_id === row.table_id);
+			if (!table) return acc;
+
+			const key = `${row.table_id}_${row.index_id}`;
+			if (!acc[key]) {
+				const { column_id: _, ...rest } = row;
+				acc[key] = { ...rest, column_ids: [] };
+			}
+			acc[key].column_ids.push(row.column_id);
+			return acc;
+		}, {}),
+	);
+
+	const groupedPrimaryKeys: GroupedIdxsAndContraints[] = [];
+	const groupedUniqueConstraints: GroupedIdxsAndContraints[] = [];
+	const groupedIndexes: GroupedIdxsAndContraints[] = [];
+
+	indexesCount = groupedIndexes.length;
+
+	groupedIdxsAndContraints.forEach((it) => {
+		if (it.is_primary_key) groupedPrimaryKeys.push(it);
+		else if (it.is_unique_constraint) groupedUniqueConstraints.push(it);
+		else groupedIndexes.push(it);
+	});
+
+	for (const unique of groupedUniqueConstraints) {
+		const table = filteredTables.find((it) => it.object_id === unique.table_id);
+		if (!table) continue;
+
+		const schema = filteredSchemas.find((it) => it.schema_id === table.schema_id)!;
+
+		const columns = unique.column_ids.map((it) => {
+			const column = columnsList.find((column) =>
+				column.table_object_id === unique.table_id && column.column_id === it
+			)!;
+			return column.name;
+		});
+
+		uniques.push({
+			entityType: 'uniques',
+			schema: schema.schema_name,
+			table: table.name,
+			name: unique.name,
+			nameExplicit: true,
+			columns,
+		});
+	}
+
+	for (const pk of groupedPrimaryKeys) {
+		const table = filteredTables.find((it) => it.object_id === pk.table_id);
+		if (!table) continue;
+
+		const schema = filteredSchemas.find((it) => it.schema_id === table.schema_id)!;
+
+		const columns = pk.column_ids.map((it) => {
+			const column = columnsList.find((column) => column.table_object_id === pk.table_id && column.column_id === it)!;
+			return column.name;
+		});
+
+		pks.push({
+			entityType: 'pks',
+			schema: schema.schema_name,
+			table: table.name,
+			name: pk.name,
+			nameExplicit: true,
+			columns,
+		});
+	}
+
+	for (const index of groupedIndexes) {
+		const table = filteredTables.find((it) => it.object_id === index.table_id);
+		if (!table) continue;
+
+		const schema = filteredSchemas.find((it) => it.schema_id === table.schema_id)!;
+
+		const columns = index.column_ids.map((it) => {
+			const column = columnsList.find((column) =>
+				column.table_object_id === index.table_id && column.column_id === it
+			)!;
+			return { value: column.name, isExpression: false };
+		});
+
+		indexes.push({
+			entityType: 'indexes',
+			schema: schema.schema_name,
+			table: table.name,
+			name: index.name,
+			columns,
+			where: index.has_filter ? index.filter_definition : null,
+			isUnique: index.is_unique,
+		});
+	}
+
+	type GroupedForeignKey = {
+		name: string;
+		schema_id: number;
+		parent_table_id: number;
+		on_delete: string;
+		on_update: string;
+		is_system_named: boolean;
+		reference_table_id: number;
+		columns: { parent_column_ids: number[]; reference_column_ids: number[] };
+	};
+	const groupedFkCostraints = Object.values(
+		fkCostraintList.reduce((acc: Record<string, GroupedForeignKey>, row: ForeignKeyRow) => {
+			const key = `${row.name}_${row.schema_id}`;
+
+			if (acc[key]) {
+				acc[key].columns.parent_column_ids.push(row.parent_column_id);
+				acc[key].columns.reference_column_ids.push(row.reference_column_id);
+			} else {
+				acc[key] = {
+					...row,
+					columns: { parent_column_ids: [row.parent_column_id], reference_column_ids: [row.reference_column_id] },
+				};
+			}
+
+			return acc;
+		}, {}),
+	);
+
+	foreignKeysCount = groupedFkCostraints.length;
+	for (const fk of groupedFkCostraints) {
+		const tableFrom = filteredTables.find((it) => it.object_id === fk.parent_table_id);
+		if (!tableFrom) continue;
+		const schemaFrom = filteredSchemas.find((it) => it.schema_id === fk.schema_id)!;
+
+		const tableTo = filteredTables.find((it) => it.object_id === fk.reference_table_id)!;
+		const schemaTo = filteredSchemas.find((it) => it.schema_id === tableTo.schema_id)!;
+
+		const columns = fk.columns.parent_column_ids.map((it) => {
+			const column = columnsList.find((column) =>
+				column.table_object_id === fk.parent_table_id && column.column_id === it
+			)!;
+			return column.name;
+		});
+
+		const columnsTo = fk.columns.reference_column_ids.map((it) => {
+			const column = columnsList.find((column) =>
+				column.table_object_id === fk.reference_table_id && column.column_id === it
+			)!;
+			return column.name;
+		});
+
+		fks.push({
+			entityType: 'fks',
+			schema: schemaFrom.schema_name,
+			table: tableFrom.name,
+			name: fk.name,
+			nameExplicit: true,
+			columns,
+			tableTo: tableTo.name,
+			schemaTo: schemaTo.schema_name,
+			columnsTo,
+			onUpdate: parseFkAction(fk.on_update),
+			onDelete: parseFkAction(fk.on_delete),
+		});
+	}
+
+	checksCount = checkConstraintList.length;
+	for (const check of checkConstraintList) {
+		const table = filteredTables.find((it) => it.object_id === check.parent_table_id);
+		if (!table) continue;
+
+		const schema = filteredSchemas.find((it) => it.schema_id === check.schema_id)!;
+
+		checks.push({
+			entityType: 'checks',
+			schema: schema.schema_name,
+			table: table.name,
+			name: check.name,
+			value: check.definition,
+		});
+	}
+
+	for (const defaultConstraint of defaultsConstraintList) {
+		const table = filteredTables.find((it) => it.object_id === defaultConstraint.parent_table_id);
+		if (!table) continue;
+
+		const schema = filteredSchemas.find((it) => it.schema_id === defaultConstraint.schema_id)!;
+		const column = columnsList.find((it) =>
+			it.column_id === defaultConstraint.parent_column_id && it.table_object_id === defaultConstraint.parent_table_id
+		)!;
+
+		defaults.push({
+			entityType: 'defaults',
+			schema: schema.schema_name,
+			table: table.name,
+			default: parseDefault(column.type, defaultConstraint.definition),
+			nameExplicit: true,
+			column: column.name,
+			name: defaultConstraint.name,
+		});
+	}
+
+	progressCallback('columns', columnsCount, 'fetching');
+	progressCallback('checks', checksCount, 'fetching');
+	progressCallback('indexes', indexesCount, 'fetching');
+	progressCallback('tables', tableCount, 'done');
+
+	viewsCount = viewsList.length;
+	for (const view of viewsList) {
+		const viewName = view.name;
+		const viewSchema = filteredSchemas.find((it) => it.schema_id === view.schema_id);
+		if (!viewSchema) continue;
+
+		if (!filter({ type: 'table', schema: viewSchema.schema_name, name: viewName })) continue;
+		tableCount += 1;
+
+		const encryption = view.definition === null;
+		const definition = parseViewSQL(view.definition);
+		if (definition === null) {
+			throw new Error(`Could not process view ${view.name}:\n${view.definition}`);
+		}
+		const withMetadata = parseViewMetadataFlag(view.definition);
+		const checkOption = view.with_check_option;
+		const schemaBinding = view.schema_binding;
+
+		views.push({
+			entityType: 'views',
+			schema: viewSchema.schema_name,
+			name: view.name,
+			definition,
+			checkOption,
+			encryption,
+			schemaBinding,
+			viewMetadata: withMetadata,
+		});
+
+		const columns = columnsList.filter((it) => it.table_object_id === view.object_id && it.rel_kind.trim() === 'V');
+
+		for (const viewColumn of columns) {
+			viewColumns.push({
+				notNull: !viewColumn.is_nullable,
+				name: viewColumn.name,
+				type: viewColumn.type,
+				schema: viewSchema.schema_name,
+				view: view.name,
+			});
+		}
+	}
+
+	progressCallback('columns', columnsCount, 'done');
+	progressCallback('indexes', indexesCount, 'done');
+	progressCallback('fks', foreignKeysCount, 'done');
+	progressCallback('checks', checksCount, 'done');
+	progressCallback('views', viewsCount, 'done');
+
+	return {
+		schemas,
+		tables,
+		columns,
+		defaults,
+		indexes,
+		pks,
+		fks,
+		uniques,
+		checks,
+		views,
+		viewColumns,
+	} satisfies InterimSchema;
+};
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const res = await fromDatabase(db, filter, progressCallback, () => {});
+
+	filterMigrationsSchema(res, migrations);
+
+	return res;
+};
diff --git a/drizzle-kit/src/dialects/mssql/serializer.ts b/drizzle-kit/src/dialects/mssql/serializer.ts
new file mode 100644
index 0000000000..b0a0ae2a5a
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/serializer.ts
@@ -0,0 +1,75 @@
+import { humanLog, mssqlSchemaError } from '../../cli/views';
+import { findLeafSnapshotIds } from '../../utils/utils-node';
+import type { MssqlDDL } from './ddl';
+import { createDDL, interimToDDL } from './ddl';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from './drizzle';
+import type { MssqlSnapshot } from './snapshot';
+import { drySnapshot, snapshotValidator } from './snapshot';
+
+export const prepareSnapshot = async (
+	snapshots: string[],
+	filenames: string[],
+): Promise<{
+	ddlPrev: MssqlDDL;
+	ddlCur: MssqlDDL;
+	snapshot: MssqlSnapshot;
+	snapshotPrev: MssqlSnapshot;
+	custom: MssqlSnapshot;
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const prevSnapshot = snapshots.length === 0
+		? drySnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+
+	const res = await prepareFromSchemaFiles(filenames);
+
+	// DO we wanna respect entity filter here?
+	const { schema, errors } = fromDrizzleSchema(res, () => true);
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => mssqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const { ddl: ddlCur, errors: errors2 } = interimToDDL(schema);
+
+	if (errors2.length > 0) {
+		humanLog(errors2.map((it) => mssqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const id = randomUUID();
+	const prevIds = snapshots.length === 0 ? [prevSnapshot.id] : findLeafSnapshotIds(snapshots);
+
+	const snapshot = {
+		version: '2',
+		dialect: 'mssql',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies MssqlSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	// that's for custom migrations, when we need new IDs, but old snapshot
+	const custom: MssqlSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return { ddlPrev, ddlCur, snapshot, snapshotPrev: prevSnapshot, custom };
+};
diff --git a/drizzle-kit/src/dialects/mssql/snapshot.ts b/drizzle-kit/src/dialects/mssql/snapshot.ts
new file mode 100644
index 0000000000..5643802984
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/snapshot.ts
@@ -0,0 +1,45 @@
+import { randomUUID } from 'crypto';
+import { originUUID } from '../../utils';
+import { array, validator } from '../simpleValidator';
+import type { MssqlDDL, MssqlEntity, MssqlEntityV1 } from './ddl';
+import { createDDL, createDDLV1 } from './ddl';
+
+// v1
+// old
+const ddlV1 = createDDLV1();
+export const snapshotValidatorV1 = validator({
+	version: ['1'],
+	dialect: ['mssql'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<MssqlEntityV1>((it) => ddlV1.entities.validate(it)),
+	renames: array<string>((_) => true),
+});
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['2'],
+	dialect: ['mssql'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<MssqlEntity>((it) => ddl.entities.validate(it)),
+	renames: array<string>((_) => true),
+});
+
+export type MssqlSnapshotV1 = typeof snapshotValidatorV1.shape;
+export type MssqlSnapshot = typeof snapshotValidator.shape;
+
+export const toJsonSnapshot = (ddl: MssqlDDL, prevIds: string[], renames: string[]): MssqlSnapshot => {
+	return { dialect: 'mssql', id: randomUUID(), prevIds, version: '2', ddl: ddl.entities.list(), renames };
+};
+
+export const drySnapshot = snapshotValidator.strict(
+	{
+		version: '2',
+		dialect: 'mssql',
+		id: originUUID,
+		prevIds: [],
+		ddl: [],
+		renames: [],
+	} satisfies MssqlSnapshot,
+);
diff --git a/drizzle-kit/src/dialects/mssql/statements.ts b/drizzle-kit/src/dialects/mssql/statements.ts
new file mode 100644
index 0000000000..5a4894b57f
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/statements.ts
@@ -0,0 +1,277 @@
+import type { Simplify } from '../../utils';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	DiffEntities,
+	ForeignKey,
+	Index,
+	PrimaryKey,
+	Schema,
+	TableFull,
+	UniqueConstraint,
+	View,
+} from './ddl';
+
+export interface CreateSchema {
+	type: 'create_schema';
+	name: string;
+}
+
+export interface DropSchema {
+	type: 'drop_schema';
+	name: string;
+}
+
+export interface RenameSchema {
+	type: 'rename_schema';
+	from: Schema;
+	to: Schema;
+}
+
+export interface CreateTable {
+	type: 'create_table';
+	table: TableFull;
+}
+
+export interface DropTable {
+	type: 'drop_table';
+	table: TableFull;
+}
+export interface RenameTable {
+	type: 'rename_table';
+	from: string;
+	to: string;
+	schema: string;
+}
+
+export interface AddColumn {
+	type: 'add_column';
+	column: Column;
+	defaults: DefaultConstraint[];
+	isPK: boolean;
+}
+
+export interface DropColumn {
+	type: 'drop_column';
+	column: Column;
+}
+
+export interface RenameColumn {
+	type: 'rename_column';
+	from: Column;
+	to: Column;
+}
+
+export interface AlterColumn {
+	type: 'alter_column';
+	diff: DiffEntities['columns'];
+}
+
+export interface RecreateIdentityColumn {
+	type: 'recreate_identity_column';
+	column: DiffEntities['columns'];
+	defaults: DefaultConstraint[];
+	constraintsToDelete: (UniqueConstraint | CheckConstraint | Index | PrimaryKey | ForeignKey | DefaultConstraint)[];
+	constraintsToCreate: (UniqueConstraint | CheckConstraint | Index | PrimaryKey | ForeignKey | DefaultConstraint)[];
+}
+export interface RecreateColumn {
+	type: 'recreate_column';
+	diff: DiffEntities['columns'];
+}
+
+export interface CreateIndex {
+	type: 'create_index';
+	index: Index;
+}
+
+export interface DropIndex {
+	type: 'drop_index';
+	index: Index;
+}
+
+export interface CreateFK {
+	type: 'create_fk';
+	fk: ForeignKey;
+}
+export interface DropFK {
+	type: 'drop_fk';
+	fk: ForeignKey;
+}
+
+export interface CreatePK {
+	type: 'create_pk';
+	pk: PrimaryKey;
+}
+
+export interface DropPK {
+	type: 'drop_pk';
+	pk: PrimaryKey;
+}
+
+export interface DropConstraint {
+	type: 'drop_constraint';
+	table: string;
+	schema: string;
+	constraint: string;
+}
+
+export interface CreateView {
+	type: 'create_view';
+	view: View;
+}
+
+export interface DropView {
+	type: 'drop_view';
+	view: View;
+}
+
+export interface RenameView {
+	type: 'rename_view';
+	from: View;
+	to: View;
+}
+
+export interface AlterView {
+	type: 'alter_view';
+	diff: DiffEntities['views'];
+	view: View;
+}
+
+export interface CreateCheck {
+	type: 'create_check';
+	check: CheckConstraint;
+}
+
+export interface CreateUnique {
+	type: 'add_unique';
+	unique: UniqueConstraint;
+}
+
+export interface DeleteUnique {
+	type: 'drop_unique';
+	unique: UniqueConstraint;
+}
+
+export interface MoveTable {
+	type: 'move_table';
+	name: string;
+	from: string;
+	to: string;
+}
+
+export interface AddCheck {
+	type: 'add_check';
+	check: CheckConstraint;
+}
+
+export interface DropCheck {
+	type: 'drop_check';
+	check: CheckConstraint;
+}
+
+export interface MoveView {
+	type: 'move_view';
+	fromSchema: string;
+	toSchema: string;
+	view: View;
+}
+
+export interface RenamePrimaryKey {
+	type: 'rename_pk';
+	from: PrimaryKey;
+	to: PrimaryKey;
+}
+
+export interface RenameCheck {
+	type: 'rename_check';
+	from: CheckConstraint;
+	to: CheckConstraint;
+}
+
+export interface RenameIndex {
+	type: 'rename_index';
+	from: Index;
+	to: Index;
+}
+
+export interface RenameForeignKey {
+	type: 'rename_fk';
+	from: ForeignKey;
+	to: ForeignKey;
+}
+
+export interface RenameUnique {
+	type: 'rename_unique';
+	from: UniqueConstraint;
+	to: UniqueConstraint;
+}
+
+export interface CreateDefault {
+	type: 'create_default';
+	default: DefaultConstraint;
+}
+
+export interface DropDefault {
+	type: 'drop_default';
+	default: DefaultConstraint;
+}
+
+export interface RecreateDefault {
+	type: 'recreate_default';
+	from: DefaultConstraint;
+	to: DefaultConstraint;
+}
+
+export type JsonStatement =
+	| CreateSchema
+	| DropSchema
+	| RenameSchema
+	| MoveView
+	| AddCheck
+	| DropCheck
+	| MoveTable
+	| CreateUnique
+	| DeleteUnique
+	| CreateTable
+	| DropTable
+	| RenameTable
+	| AddColumn
+	| DropColumn
+	| RenameColumn
+	| AlterColumn
+	| RecreateColumn
+	| RecreateIdentityColumn
+	| CreateIndex
+	| DropIndex
+	| CreateFK
+	| DropFK
+	| CreatePK
+	| DropPK
+	| CreateView
+	| DropView
+	| RenameView
+	| AlterView
+	| DropConstraint
+	| CreateCheck
+	| RenamePrimaryKey
+	| RenameCheck
+	| RenameIndex
+	| RenameForeignKey
+	| RenameUnique
+	| CreateDefault
+	| DropDefault
+	| RecreateDefault;
+
+export const prepareStatement = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	args: Omit<TStatement, 'type'>,
+): Simplify<TStatement> => {
+	return {
+		type,
+		...args,
+	} as TStatement;
+};
diff --git a/drizzle-kit/src/dialects/mssql/typescript.ts b/drizzle-kit/src/dialects/mssql/typescript.ts
new file mode 100644
index 0000000000..bb6eed27dd
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/typescript.ts
@@ -0,0 +1,530 @@
+import '../../@types/utils';
+import { toCamelCase } from 'drizzle-orm/casing';
+import type { Casing } from '../../cli/validations/common';
+import { assertUnreachable } from '../../utils';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	ForeignKey,
+	Index,
+	MssqlDDL,
+	PrimaryKey,
+	UniqueConstraint,
+	ViewColumn,
+} from './ddl';
+import { fullTableFromDDL } from './ddl';
+import { typeFor } from './grammar';
+
+const imports = [
+	'bigint',
+	'binary',
+	'bit',
+	'char',
+	'nchar',
+	'varchar',
+	'nvarchar',
+	'date',
+	'datetime',
+	'datetime2',
+	'datetimeoffset',
+	'decimal',
+	'float',
+	'int',
+	'numeric',
+	'real',
+	'smallint',
+	'text',
+	'ntext',
+	'json',
+	'time',
+	'tinyint',
+	'varbinary',
+	'tinyint',
+	'customType',
+] as const;
+export type Import = (typeof imports)[number];
+
+const mssqlImportsList = new Set([
+	'mssqlTable',
+	...imports,
+]);
+
+function inspect(it: any): string {
+	if (!it) return '';
+
+	const keys = Object.keys(it);
+	if (keys.length === 0) return '{}';
+
+	const pairs = keys.map((key) => {
+		const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)
+			? key
+			: `'${key}'`;
+
+		const value = it[key];
+		const formattedValue = typeof value === 'string' ? `'${value}'` : String(value);
+
+		return `${formattedKey}: ${formattedValue}`;
+	});
+
+	return `{ ${pairs.join(', ')} }`;
+}
+
+const objToStatement2 = (json: { [s: string]: unknown }, mode: 'string' | 'number' = 'string') => {
+	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
+
+	const keys = Object.keys(json);
+	if (keys.length === 0) return;
+
+	let statement = '{ ';
+	statement += keys.map((it) => `${it}: ${mode === 'string' ? `"${json[it]}"` : json[it]}`).join(', '); // no "" for keys
+	statement += ' }';
+	return statement;
+};
+
+const escapeColumnKey = (value: string) => {
+	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
+		return `"${value}"`;
+	}
+	return value;
+};
+
+const withCasing = (value: string, casing: Casing) => {
+	if (casing === 'preserve') {
+		return escapeColumnKey(value);
+	}
+	if (casing === 'camel') {
+		return escapeColumnKey(toCamelCase(value));
+	}
+
+	assertUnreachable(casing);
+};
+
+const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
+	if (casing === 'preserve') {
+		return '';
+	}
+	if (casing === 'camel') {
+		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
+	}
+
+	assertUnreachable(casing);
+};
+
+function generateIdentityParams(column: Column) {
+	if (column.identity === null) return '';
+	const identity = column.identity;
+
+	const tuples = [];
+	if (identity.seed) {
+		tuples.push(['seed', identity.seed]);
+	}
+	if (identity.increment) {
+		tuples.push(['increment', identity.increment]);
+	}
+
+	const params = tuples.length > 0 ? `{ ${tuples.map((x) => `${x[0]}: ${x[1]}`).join(' ,')} }` : '';
+
+	return `.identity(${params})`;
+}
+
+export const paramNameFor = (name: string, schema: string | null) => {
+	const schemaSuffix = schema && schema !== 'dbo' ? `In${schema.capitalise()}` : '';
+	return `${name}${schemaSuffix}`;
+};
+
+// prev: schemaToTypeScript
+export const ddlToTypeScript = (
+	ddl: MssqlDDL,
+	columnsForViews: ViewColumn[],
+	casing: Casing,
+) => {
+	const tableFn = `mssqlTable`;
+
+	const schemas = Object.fromEntries(
+		ddl.schemas.list().filter((it) => it.name !== 'dbo').map((it) => {
+			return [it.name, withCasing(it.name, casing)];
+		}),
+	);
+
+	const imports = new Set<string>();
+	const vcs = columnsForViews.map((it) => ({ entityType: 'viewColumns' as const, ...it }));
+	const entities = [...ddl.entities.list(), ...vcs];
+	for (const x of entities) {
+		if (x.entityType === 'schemas' && x.name !== 'dbo') imports.add('mssqlSchema');
+		if (x.entityType === 'tables') imports.add(tableFn);
+
+		if (x.entityType === 'indexes') {
+			if (x.isUnique) imports.add('uniqueIndex');
+			else imports.add('index');
+		}
+
+		if (x.entityType === 'fks') imports.add('foreignKey');
+
+		if (x.entityType === 'pks') imports.add('primaryKey');
+		if (x.entityType === 'uniques') imports.add('unique');
+		if (x.entityType === 'checks') imports.add('check');
+		if (x.entityType === 'views' && x.schema === 'dbo') imports.add('mssqlView');
+
+		if (x.entityType === 'columns' || x.entityType === 'viewColumns') {
+			const grammarType = typeFor(x.type);
+			imports.add(grammarType.drizzleImport());
+			if (mssqlImportsList.has(x.type)) imports.add(x.type);
+		}
+	}
+
+	const schemaStatements = Object.entries(schemas).map((it) => {
+		return `export const ${it[1]} = mssqlSchema("${it[0]}");\n`;
+	}).join('');
+
+	const tableStatements = ddl.tables.list().map((it) => {
+		const tableSchema = schemas[it.schema];
+		const paramName = paramNameFor(it.name, tableSchema);
+		const table = fullTableFromDDL(it, ddl);
+		const columns = ddl.columns.list({ schema: table.schema, table: table.name });
+		const fks = ddl.fks.list({ schema: table.schema, table: table.name });
+
+		const func = tableSchema ? `${tableSchema}.table` : tableFn;
+		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${table.name}", {\n`;
+		statement += createTableColumns(
+			columns,
+			table.pk,
+			fks,
+			schemas,
+			ddl.defaults.list({ schema: table.schema, table: table.name }),
+			casing,
+		);
+		statement += '}';
+
+		// more than 2 fields or self reference or cyclic
+		// Andrii: I switched this one off until we will get custom names in .references()
+		const filteredFKs = table.fks.filter((it) => {
+			return it.columns.length > 1 || isSelf(it);
+		});
+
+		const hasCallback = table.indexes.length > 0
+			|| filteredFKs.length > 0
+			|| table.pk
+			|| table.uniques.length > 0
+			|| table.checks.length > 0;
+
+		if (hasCallback) {
+			statement += ', ';
+			statement += '(table) => [\n';
+			statement += table.pk ? createTablePK(table.pk, casing) : '';
+			statement += createTableFKs(filteredFKs, schemas, casing);
+			statement += createTableIndexes(table.name, table.indexes, casing);
+			statement += createTableUniques(table.uniques, casing);
+			statement += createTableChecks(table.checks);
+			statement += ']';
+		}
+
+		statement += ');';
+		return statement;
+	});
+
+	const viewsStatements = Object.values(ddl.views.list())
+		.map((it) => {
+			const viewSchema = schemas[it.schema];
+			const paramName = paramNameFor(it.name, viewSchema);
+
+			const func = it.schema !== 'dbo'
+				? `${viewSchema}.view`
+				: 'mssqlView';
+
+			const as = `sql\`${it.definition}\``;
+
+			const viewColumns = columnsForViews.filter((x) => x.schema === it.schema && x.view === it.name);
+
+			const columns = createViewColumns(
+				viewColumns,
+				casing,
+			);
+
+			const viewOptions = {
+				encryption: it.encryption,
+				schemaBinding: it.schemaBinding,
+				viewMetadata: it.viewMetadata,
+				checkOption: it.checkOption,
+			};
+
+			let statement = `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", {${columns}})`;
+			statement += Object.keys(viewOptions).length > 0 ? `.with(${JSON.stringify(viewOptions)})` : '';
+			statement += `.as(${as});`;
+
+			return statement;
+		})
+		.join('\n\n');
+
+	const uniqueMssqlImports = [...imports];
+
+	const importsTs = `import { ${
+		uniqueMssqlImports.join(
+			', ',
+		)
+	} } from "drizzle-orm/mssql-core"
+import { sql } from "drizzle-orm"\n\n`;
+
+	let decalrations = schemaStatements;
+	decalrations += '\n';
+	decalrations += tableStatements.join('\n\n');
+	decalrations += '\n';
+	decalrations += viewsStatements;
+
+	const file = importsTs + decalrations;
+
+	// for drizzle studio query runner
+	const schemaEntry = `
+    {
+      ${
+		Object.values(ddl.tables)
+			.map((it) => withCasing(it.name, casing))
+			.join(',\n')
+	}
+    }
+  `;
+
+	return { file, imports: importsTs, decalrations, schemaEntry };
+};
+
+// const isCyclic = (fk: ForeignKey) => {
+// 	const key = `${fk.table}-${fk.tableTo}`;
+// 	const reverse = `${fk.tableTo}-${fk.table}`;
+// 	return relations.has(key) && relations.has(reverse);
+// };
+
+const isSelf = (fk: ForeignKey) => {
+	return fk.table === fk.tableTo;
+};
+
+const column = (
+	type: string,
+	name: string,
+	casing: Casing,
+	def: DefaultConstraint['default'],
+) => {
+	const lowered = type.toLowerCase();
+
+	const grammarType = typeFor(lowered);
+	const key = withCasing(name, casing);
+	const { default: defToSet, options: optionsToSet, customType } = grammarType.toTs(type, def);
+	const columnName = dbColumnName({ name, casing, withMode: Boolean(optionsToSet) });
+	const drizzleType = grammarType.drizzleImport();
+
+	let res = `${key}: ${drizzleType}${customType ? `({ dataType: () => '${customType}' })` : ''}(${columnName}${
+		inspect(optionsToSet)
+	})`;
+	res += defToSet ? defToSet.startsWith('.') ? defToSet : `.default(${defToSet})` : '';
+	return res;
+};
+
+const createViewColumns = (
+	columns: ViewColumn[],
+	casing: Casing,
+) => {
+	let statement = '';
+
+	columns.forEach((it) => {
+		const columnStatement = column(
+			it.type,
+			it.name,
+			casing,
+			null,
+		);
+		statement += '\t';
+		statement += columnStatement;
+		// Provide just this in column function
+		statement += it.notNull ? '.notNull()' : '';
+		statement += ',\n';
+	});
+	return statement;
+};
+
+const createTableColumns = (
+	columns: Column[],
+	primaryKey: PrimaryKey | null,
+	fks: ForeignKey[],
+	schemas: Record<string, string>,
+	defaults: DefaultConstraint[],
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	// no self refs and no cyclic
+	const oneColumnsFKs = Object.values(fks)
+		.filter((it) => {
+			return !isSelf(it);
+		})
+		.filter((it) => it.columns.length === 1);
+
+	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
+		const arr = res[it.columns[0]] || [];
+		arr.push(it);
+		res[it.columns[0]] = arr;
+		return res;
+	}, {} as Record<string, ForeignKey[]>);
+
+	columns.forEach((it) => {
+		const def = defaults.find((def) => def.column === it.name && def.schema === it.schema);
+
+		const columnStatement = column(
+			it.type,
+			it.name,
+			casing,
+			def ? def.default : null,
+		);
+		const pk = primaryKey && primaryKey.columns.length === 1 && primaryKey.columns[0] === it.name
+			? primaryKey
+			: null;
+
+		statement += '\t';
+		statement += columnStatement;
+		statement += it.notNull && !it.identity && !pk ? '.notNull()' : '';
+		statement += it.identity ? generateIdentityParams(it) : '';
+		statement += it.generated ? `.generatedAlwaysAs(sql\`${it.generated.as}\`)` : '';
+
+		const fks = fkByColumnName[it.name];
+		// Andrii: I switched it off until we will get a custom naem setting in references
+		if (fks) {
+			const fksStatement = fks
+				.map((it) => {
+					const onDelete = it.onDelete && it.onDelete !== 'NO ACTION' ? it.onDelete : null;
+					const onUpdate = it.onUpdate && it.onUpdate !== 'NO ACTION' ? it.onUpdate : null;
+					const params = { onDelete: onDelete?.toLowerCase(), onUpdate: onUpdate?.toLowerCase() };
+
+					const paramsStr = objToStatement2(params);
+					const tableSchema = schemas[it.schemaTo || ''];
+					const paramName = paramNameFor(it.tableTo, tableSchema);
+					if (paramsStr) {
+						return `.references(() => ${
+							withCasing(
+								paramName,
+								casing,
+							)
+						}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
+					}
+					return `.references(() => ${
+						withCasing(
+							paramName,
+							casing,
+						)
+					}.${withCasing(it.columnsTo[0], casing)})`;
+				})
+				.join('');
+			statement += fksStatement;
+		}
+
+		statement += ',\n';
+	});
+
+	return statement;
+};
+
+const createTableIndexes = (tableName: string, idxs: Index[], casing: Casing): string => {
+	let statement = '';
+
+	idxs.forEach((it) => {
+		// TODO: cc: @AndriiSherman we have issue when index is called as table called
+		// let idxKey = it.name.startsWith(tableName) && it.name !== tableName ? it.name.slice(tableName.length + 1) : it.name;
+		// idxKey = idxKey.endsWith('_index') ? idxKey.slice(0, -'_index'.length) + '_idx' : idxKey;
+		// idxKey = withCasing(idxKey, casing);
+		// const indexGeneratedName = indexName(
+		// 	tableName,
+		// 	it.columns.map((it) => it.value),
+		// );
+
+		const name = it.name;
+		// const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
+
+		statement += it.isUnique ? '\tuniqueIndex(' : '\tindex(';
+		statement += name ? `"${name}")` : ')';
+
+		statement += `.on(${
+			it.columns
+				.map((it) => {
+					if (it.isExpression) {
+						return `sql\`${it.value}\``;
+					} else {
+						return `table.${withCasing(it.value, casing)}`;
+					}
+				})
+				.join(', ')
+		})`;
+		statement += it.where ? `.where(sql\`${it.where}\`)` : '';
+
+		statement += `,\n`;
+	});
+
+	return statement;
+};
+
+const createTablePK = (it: PrimaryKey, casing: Casing): string => {
+	let statement = '\tprimaryKey({ columns: [';
+	statement += `${
+		it.columns
+			.map((c) => {
+				return `table.${withCasing(c, casing)}`;
+			})
+			.join(', ')
+	}`;
+	statement += `]${it.nameExplicit ? `, name: "${it.name}"` : ''}}),\n`;
+	return statement;
+};
+
+// get a map of db role name to ts key
+// if to by key is in this map - no quotes, otherwise - quotes
+
+const createTableUniques = (
+	unqs: UniqueConstraint[],
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	unqs.forEach((it, index) => {
+		statement += '\tunique(';
+		statement += it.nameExplicit ? `"${it.name}")` : ')';
+		statement += `.on(${it.columns.map((it) => `table.${withCasing(it, casing)}`).join(', ')})`;
+		statement += index === unqs.length - 1 ? `\n` : ',\n';
+	});
+
+	return statement;
+};
+
+const createTableChecks = (
+	checkConstraints: CheckConstraint[],
+) => {
+	let statement = '';
+
+	checkConstraints.forEach((it) => {
+		statement += 'check(';
+		statement += `"${it.name}", `;
+		statement += `sql\`${it.value}\`)`;
+		statement += `,`;
+	});
+
+	return statement;
+};
+
+const createTableFKs = (fks: ForeignKey[], schemas: Record<string, string>, casing: Casing): string => {
+	let statement = '';
+
+	fks.forEach((it) => {
+		const tableSchema = it.schemaTo === 'public' ? '' : schemas[it.schemaTo];
+		const paramName = paramNameFor(it.tableTo, tableSchema);
+
+		const isSelf = it.tableTo === it.table;
+		const tableTo = isSelf ? 'table' : `${withCasing(paramName, casing)}`;
+		statement += `\tforeignKey({\n`;
+		statement += `\t\tcolumns: [${it.columns.map((i) => `table.${withCasing(i, casing)}`).join(', ')}],\n`;
+		statement += `\t\tforeignColumns: [${
+			it.columnsTo.map((i) => `${tableTo}.${withCasing(i, casing)}`).join(', ')
+		}],\n`;
+		statement += it.nameExplicit ? `\t\tname: "${it.name}"\n` : '';
+		statement += `\t})`;
+
+		statement += it.onUpdate && it.onUpdate !== 'NO ACTION' ? `.onUpdate("${it.onUpdate}")` : '';
+		statement += it.onDelete && it.onDelete !== 'NO ACTION' ? `.onDelete("${it.onDelete}")` : '';
+		statement += `,\n`;
+	});
+	return statement;
+};
diff --git a/drizzle-kit/src/dialects/mssql/versions.ts b/drizzle-kit/src/dialects/mssql/versions.ts
new file mode 100644
index 0000000000..7c07ef857a
--- /dev/null
+++ b/drizzle-kit/src/dialects/mssql/versions.ts
@@ -0,0 +1,49 @@
+import { assertUnreachable } from '../../utils';
+import { createDDL } from './ddl';
+import type { MssqlSnapshot, MssqlSnapshotV1 } from './snapshot';
+
+export const upToV2 = (it: Record<string, any>): { snapshot: MssqlSnapshot; hints: string[] } => {
+	const snapshot = it as MssqlSnapshotV1;
+	const ddlV1 = snapshot.ddl;
+
+	const hints = [] as string[];
+
+	const ddl = createDDL();
+	for (const entry of ddlV1) {
+		if (entry.entityType === 'checks') ddl.checks.push(entry);
+		else if (entry.entityType === 'columns') ddl.columns.push(entry);
+		else if (entry.entityType === 'defaults') ddl.defaults.push(entry);
+		else if (entry.entityType === 'fks') ddl.fks.push(entry);
+		else if (entry.entityType === 'pks') ddl.pks.push(entry);
+		else if (entry.entityType === 'schemas') ddl.schemas.push(entry);
+		else if (entry.entityType === 'tables') ddl.tables.push(entry);
+		else if (entry.entityType === 'uniques') ddl.uniques.push(entry);
+		else if (entry.entityType === 'views') ddl.views.push(entry);
+		else if (entry.entityType === 'indexes') {
+			const newColumns = entry.columns.map((it) => ({ isExpression: false, value: it }));
+			const newIndex = { ...entry, columns: newColumns };
+			ddl.indexes.push(newIndex);
+		} else {
+			assertUnreachable(entry);
+		}
+	}
+
+	return {
+		snapshot: {
+			id: snapshot.id,
+			prevIds: snapshot.prevIds,
+			version: '2',
+			dialect: 'mssql',
+			ddl: ddl.entities.list(),
+			renames: snapshot.renames,
+		},
+		hints,
+	};
+};
+
+export const extractBaseTypeAndDimensions = (it: string): [string, number] => {
+	const dimensionRegex = /\[[^\]]*\]/g; // matches any [something], including []
+	const count = (it.match(dimensionRegex) || []).length;
+	const baseType = it.replace(dimensionRegex, '');
+	return [baseType, count];
+};
diff --git a/drizzle-kit/src/dialects/mysql/commutativity.ts b/drizzle-kit/src/dialects/mysql/commutativity.ts
new file mode 100644
index 0000000000..054144e9d8
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/commutativity.ts
@@ -0,0 +1,336 @@
+import {
+	AbstractCommutativity,
+	type CommutativityStatementDefinitions,
+	type CommutativityStatementInfo,
+} from '../../commutativity/engine';
+import type { ConflictTarget } from '../../commutativity/types';
+import { createDDL, type MysqlDDL } from './ddl';
+import { ddlDiffDry } from './diff';
+import { drySnapshot, type MysqlSnapshot } from './snapshot';
+import type { JsonStatement } from './statements';
+
+type FootprintTarget = {
+	objectName: string;
+	columnName: string;
+};
+
+type StatementInfo = CommutativityStatementInfo<JsonStatement, FootprintTarget>;
+
+type StatementDefinitions = CommutativityStatementDefinitions<
+	JsonStatement,
+	FootprintTarget
+>;
+
+function makeTarget(objectName: string, columnName = ''): FootprintTarget {
+	return { objectName, columnName };
+}
+
+/**
+ * MySQL-specific commutativity rules.
+ *
+ * How to read this file:
+ * - `getStatementDefinitions()` is the main source of truth.
+ * - Each statement definition answers two questions:
+ *   1. `conflicts`: which other statement types are incompatible with this one.
+ *   2. `buildInfo`: which resource footprints this statement occupies.
+ * - `buildInfo().primary` is the exact resource touched by the statement.
+ * - `buildInfo().ancestors` are explicit parent resources, usually the owning table.
+ * - Unlike Postgres, MySQL has no extra schema-level ancestry here, so matching is
+ *   driven by exact targets plus table ancestors.
+ *
+ * Practical guide for fixes:
+ * - False positive or missed conflict for same-level objects like column->column,
+ *   index->index, table->table, or view->view:
+ *   change the `conflicts` array for the relevant statements in
+ *   `getStatementDefinitions()`.
+ * - False positive or missed conflict for parent/child relations like
+ *   table->column or table->index:
+ *   adjust the child's `ancestors` in `buildInfo()` and/or the parent's
+ *   `conflicts` array.
+ * - Wrong human-readable conflict message only:
+ *   change `describeStatement()` or `schemaLevelActions`. Those affect reporting,
+ *   not matching semantics.
+ *
+ * Rule of thumb:
+ * - If the problem is "these two statement types should or should not conflict",
+ *   edit `conflicts`.
+ * - If the problem is "this statement is matched at the wrong scope",
+ *   edit `primary` or `ancestors`.
+ */
+class MysqlCommutativity extends AbstractCommutativity<
+	JsonStatement,
+	MysqlSnapshot,
+	FootprintTarget
+> {
+	private schemaLevelActions = new Set([
+		'create_table',
+		'drop_table',
+		'rename_table',
+		'create_view',
+		'drop_view',
+		'alter_view',
+		'rename_view',
+	]);
+
+	protected override getStatementDefinitions(): StatementDefinitions {
+		return {
+			// Table operations
+			create_table: {
+				conflicts: ['create_table', 'drop_table', 'rename_table'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table.name),
+					ancestors: [],
+				}),
+			},
+			drop_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'recreate_column',
+					'rename_column',
+					'create_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table),
+					ancestors: [],
+				}),
+			},
+			rename_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'create_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from),
+					ancestors: [],
+				}),
+			},
+
+			// Column operations
+			add_column: {
+				conflicts: [
+					'add_column',
+					'alter_column',
+					'drop_column',
+					'rename_column',
+					'recreate_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			drop_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'rename_column',
+					'recreate_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			alter_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'rename_column',
+					'recreate_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.diff.table, statement.column.name),
+					ancestors: [makeTarget(statement.diff.table)],
+				}),
+			},
+			recreate_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			rename_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table, statement.from),
+					ancestors: [makeTarget(statement.table)],
+				}),
+			},
+
+			// Index operations
+			create_index: {
+				conflicts: ['create_index', 'drop_index', 'drop_table'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.table, statement.index.name),
+					ancestors: [makeTarget(statement.index.table)],
+				}),
+			},
+			drop_index: {
+				conflicts: ['create_index', 'drop_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.table, statement.index.name),
+					ancestors: [makeTarget(statement.index.table)],
+				}),
+			},
+
+			// Primary key operations
+			drop_pk: {
+				conflicts: ['drop_pk', 'create_pk'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.pk.table),
+					ancestors: [],
+				}),
+			},
+			create_pk: {
+				conflicts: ['drop_pk', 'create_pk'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.pk.table),
+					ancestors: [],
+				}),
+			},
+
+			// Foreign key operations
+			create_fk: {
+				conflicts: ['create_fk', 'drop_constraint'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.fk.table),
+					ancestors: [],
+				}),
+			},
+
+			// Constraint operations (FK drops / check drops)
+			drop_constraint: {
+				conflicts: ['drop_constraint', 'create_fk', 'create_check'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table),
+					ancestors: [],
+				}),
+			},
+
+			// Check constraint operations
+			create_check: {
+				conflicts: ['create_check', 'drop_constraint'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.check.table),
+					ancestors: [],
+				}),
+			},
+
+			// View operations
+			create_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.name),
+					ancestors: [],
+				}),
+			},
+			drop_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.name),
+					ancestors: [],
+				}),
+			},
+			rename_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from),
+					ancestors: [],
+				}),
+			},
+			alter_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.name),
+					ancestors: [],
+				}),
+			},
+		};
+	}
+
+	protected override formatFootprintTarget(
+		action: JsonStatement['type'],
+		target: FootprintTarget,
+	): string {
+		return `${action};${target.objectName};${target.columnName}`;
+	}
+
+	protected override describeStatement(
+		_statement: JsonStatement,
+		info: StatementInfo,
+	): string {
+		if (this.schemaLevelActions.has(info.action)) {
+			return `${info.action}: ${info.primary.objectName} in database`;
+		}
+
+		if (info.primary.columnName) {
+			return `${info.action}: ${info.primary.columnName} on ${info.primary.objectName} table`;
+		}
+
+		return `${info.action} on ${info.primary.objectName} table`;
+	}
+
+	private viewLevelActions = new Set([
+		'create_view',
+		'drop_view',
+		'alter_view',
+		'rename_view',
+	]);
+
+	protected override describeStatementTarget(
+		_statement: JsonStatement,
+		info: StatementInfo,
+	): ConflictTarget {
+		if (this.viewLevelActions.has(info.action)) {
+			return { kind: 'view', name: info.primary.objectName };
+		}
+
+		if (info.primary.columnName) {
+			return { kind: 'column', name: info.primary.columnName, table: info.primary.objectName };
+		}
+
+		return { kind: 'table', name: info.primary.objectName };
+	}
+
+	protected override getDrySnapshot(): MysqlSnapshot {
+		return drySnapshot;
+	}
+
+	protected override async diffSnapshots(
+		fromSnapshot: MysqlSnapshot,
+		toSnapshot: MysqlSnapshot,
+	): Promise<{ statements: JsonStatement[] }> {
+		const fromDDL: MysqlDDL = createDDL();
+		const toDDL: MysqlDDL = createDDL();
+
+		fromDDL.entities.pushAll(fromSnapshot.ddl);
+		toDDL.entities.pushAll(toSnapshot.ddl);
+
+		const { statements } = await ddlDiffDry(fromDDL, toDDL, 'default');
+		return { statements };
+	}
+}
+
+export const mysqlCommutativity = new MysqlCommutativity();
diff --git a/drizzle-kit/src/dialects/mysql/convertor.ts b/drizzle-kit/src/dialects/mysql/convertor.ts
new file mode 100644
index 0000000000..129b1763ef
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/convertor.ts
@@ -0,0 +1,303 @@
+import type { Simplify } from '../../utils';
+import type { JsonStatement } from './statements';
+
+export const convertor = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	convertor: (statement: Simplify<Omit<TStatement, 'type'>>) => string | string[],
+) => {
+	return {
+		type,
+		can: (st: JsonStatement) => {
+			return st.type === type;
+		},
+		convert: convertor,
+	};
+};
+
+const createTable = convertor('create_table', (st) => {
+	const { name, columns, pk, checks, indexes, fks } = st.table;
+
+	const uniqueIndexes = indexes.filter((it) => it.isUnique);
+
+	let statement = '';
+	statement += `CREATE TABLE \`${name}\` (\n`;
+
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === column.name;
+		const primaryKeyStatement = isPK ? ' PRIMARY KEY' : '';
+		const notNullStatement = column.notNull && !isPK ? ' NOT NULL' : '';
+		const defaultStatement = column.default !== null ? ` DEFAULT ${column.default}` : '';
+
+		const onUpdateStatement = column.onUpdateNow
+			? ` ON UPDATE CURRENT_TIMESTAMP` + `${column.onUpdateNowFsp ? '(' + column.onUpdateNowFsp + ')' : ''}`
+			: '';
+
+		const autoincrementStatement = column.autoIncrement && column.type !== 'serial'
+			? ' AUTO_INCREMENT'
+			: '';
+
+		const generatedStatement = column.generated
+			? ` GENERATED ALWAYS AS (${column.generated?.as}) ${column.generated?.type.toUpperCase()}`
+			: '';
+
+		const charSetStatement = column.charSet ? ` CHARACTER SET ${column.charSet}` : '';
+		const collationStatement = column.collation ? ` COLLATE ${column.collation}` : '';
+
+		statement += '\t'
+			+ `\`${column.name}\` ${column.type}${charSetStatement}${collationStatement}${autoincrementStatement}${primaryKeyStatement}${generatedStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`;
+		statement += i === columns.length - 1 ? '' : ',\n';
+	}
+
+	if (pk && (pk.columns.length > 1)) {
+		statement += ',\n';
+		// TIDB does not allow naming primary key constraints
+		// under the hood mysql always names it `PRIMARY`
+		statement += `\tCONSTRAINT PRIMARY KEY(\`${pk.columns.join(`\`,\``)}\`)`;
+	}
+
+	for (const unique of uniqueIndexes) {
+		statement += ',\n';
+		const uniqueString = unique.columns
+			.map((it) => it.isExpression ? `${it.value}` : `\`${it.value}\``)
+			.join(',');
+
+		statement += `\tCONSTRAINT \`${unique.name}\` UNIQUE INDEX(${uniqueString})`;
+	}
+
+	// TODO remove from create_table
+	for (const fk of fks) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT \`${fk.name}\` FOREIGN KEY (\`${
+			fk.columns.join('`,`')
+		}\`) REFERENCES \`${fk.tableTo}\`(\`${fk.columnsTo.join('`,`')}\`)`;
+	}
+
+	for (const check of checks) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT \`${check.name}\` CHECK(${check.value})`;
+	}
+
+	statement += `\n);`;
+	statement += `\n`;
+	return statement;
+});
+
+const dropTable = convertor('drop_table', (st) => {
+	return `DROP TABLE \`${st.table}\`;`;
+});
+
+const renameTable = convertor('rename_table', (st) => {
+	return `RENAME TABLE \`${st.from}\` TO \`${st.to}\`;`;
+});
+
+const addColumn = convertor('add_column', (st) => {
+	const { column, isPK } = st;
+	const {
+		name,
+		type,
+		notNull,
+		table,
+		onUpdateNow,
+		autoIncrement,
+		generated,
+		onUpdateNowFsp,
+	} = column;
+
+	const defaultStatement = column.default !== null ? ` DEFAULT ${column.default}` : '';
+
+	const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+	const primaryKeyStatement = `${isPK ? ' PRIMARY KEY' : ''}`;
+	const autoincrementStatement = `${autoIncrement ? ' AUTO_INCREMENT' : ''}`;
+	const onUpdateStatement = `${
+		onUpdateNow ? ' ON UPDATE CURRENT_TIMESTAMP' + `${onUpdateNowFsp ? '(' + onUpdateNowFsp + ')' : ''}` : ''
+	}`;
+
+	const generatedStatement = generated
+		? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
+		: '';
+
+	const charSetStatement = column.charSet ? ` CHARACTER SET ${column.charSet}` : '';
+	const collationStatement = column.collation ? ` COLLATE ${column.collation}` : '';
+
+	return `ALTER TABLE \`${table}\` ADD \`${name}\` ${type}${charSetStatement}${collationStatement}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${onUpdateStatement};`;
+});
+
+const dropColumn = convertor('drop_column', (st) => {
+	return `ALTER TABLE \`${st.column.table}\` DROP COLUMN \`${st.column.name}\`;`;
+});
+
+const renameColumn = convertor('rename_column', (st) => {
+	return `ALTER TABLE \`${st.table}\` RENAME COLUMN \`${st.from}\` TO \`${st.to}\`;`;
+});
+
+const alterColumn = convertor('alter_column', (st) => {
+	const { column, isPK, wasPK } = st;
+
+	const defaultStatement = column.default !== null ? ` DEFAULT ${column.default}` : '';
+
+	const notNullStatement = `${column.notNull ? ' NOT NULL' : ''}`;
+	const primaryKeyStatement = `${isPK && !wasPK ? ' PRIMARY KEY' : ''}`;
+	const autoincrementStatement = `${column.autoIncrement ? ' AUTO_INCREMENT' : ''}`;
+	const onUpdateStatement = `${
+		column.onUpdateNow
+			? ' ON UPDATE CURRENT_TIMESTAMP' + `${column.onUpdateNowFsp ? '(' + column.onUpdateNowFsp + ')' : ''}`
+			: ''
+	}`;
+
+	const generatedStatement = column.generated
+		? ` GENERATED ALWAYS AS (${column.generated.as}) ${column.generated.type.toUpperCase()}`
+		: '';
+
+	const charSetStatement = column.charSet ? ` CHARACTER SET ${column.charSet}` : '';
+	const collationStatement = column.collation ? ` COLLATE ${column.collation}` : '';
+
+	return `ALTER TABLE \`${column.table}\` MODIFY COLUMN \`${column.name}\` ${column.type}${charSetStatement}${collationStatement}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${onUpdateStatement};`;
+});
+
+const recreateColumn = convertor('recreate_column', (st) => {
+	return [dropColumn.convert(st) as string, addColumn.convert(st) as string];
+});
+
+const createIndex = convertor('create_index', (st) => {
+	// TODO: handle everything?
+	const { name, table, columns, isUnique } = st.index;
+	const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+
+	const uniqueString = columns
+		.map((it) => it.isExpression ? `${it.value}` : `\`${it.value}\``)
+		.join(',');
+
+	return `CREATE ${indexPart} \`${name}\` ON \`${table}\` (${uniqueString});`;
+});
+
+const dropIndex = convertor('drop_index', (st) => {
+	return `DROP INDEX \`${st.index.name}\` ON \`${st.index.table}\`;`;
+});
+
+const createFK = convertor('create_fk', (st) => {
+	const {
+		name,
+		table,
+		columns,
+		tableTo,
+		columnsTo,
+		onDelete,
+		onUpdate,
+	} = st.fk;
+	const onDeleteStatement = onDelete !== 'NO ACTION' ? ` ON DELETE ${onDelete}` : '';
+	const onUpdateStatement = onUpdate !== 'NO ACTION' ? ` ON UPDATE ${onUpdate}` : '';
+	const fromColumnsString = columns.map((it) => `\`${it}\``).join(',');
+	const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
+
+	return `ALTER TABLE \`${table}\` ADD CONSTRAINT \`${name}\` FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+});
+
+{
+	// alter generated for column -> recreate
+}
+
+const createPK = convertor('create_pk', (st) => {
+	return `ALTER TABLE \`${st.pk.table}\` ADD PRIMARY KEY (\`${st.pk.columns.join('`,`')}\`);`;
+});
+
+const dropPK = convertor('drop_pk', (st) => {
+	return `ALTER TABLE \`${st.pk.table}\` DROP PRIMARY KEY;`;
+});
+
+const createCheck = convertor('create_check', (st) => {
+	return `ALTER TABLE \`${st.check.table}\` ADD CONSTRAINT \`${st.check.name}\` CHECK (${st.check.value});`;
+});
+
+const dropConstraint = convertor('drop_constraint', (st) => {
+	const statements = [`ALTER TABLE \`${st.table}\` DROP CONSTRAINT \`${st.constraint}\`;`];
+	if (st.dropAutoIndex) statements.push(`DROP INDEX \`${st.constraint}\` ON \`${st.table}\``);
+	return statements;
+});
+
+const createView = convertor('create_view', (st) => {
+	const { definition, name, algorithm, sqlSecurity, withCheckOption } = st.view;
+
+	let statement = `CREATE `;
+	statement += st.replace ? `OR REPLACE ` : ''; // NO replace was in the code
+	statement += algorithm ? `ALGORITHM = ${algorithm} ` : '';
+	statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity} ` : '';
+	statement += `VIEW \`${name}\` AS (${definition})`;
+	statement += withCheckOption ? ` WITH ${withCheckOption} CHECK OPTION` : '';
+
+	statement += ';';
+
+	return statement;
+});
+
+const dropView = convertor('drop_view', (st) => {
+	return `DROP VIEW \`${st.name}\`;`;
+});
+
+const renameView = convertor('rename_view', (st) => {
+	return `RENAME TABLE \`${st.from}\` TO \`${st.to}\`;`;
+});
+
+const alterView = convertor('alter_view', (st) => {
+	const { name, definition, withCheckOption, algorithm, sqlSecurity } = st.view;
+
+	let statement = `ALTER `;
+	statement += `ALGORITHM = ${algorithm} `;
+	statement += `SQL SECURITY ${sqlSecurity} `;
+	statement += `VIEW \`${name}\` AS ${definition}`;
+	statement += withCheckOption ? ` WITH ${withCheckOption} CHECK OPTION` : '';
+	statement += ';';
+
+	return statement;
+});
+
+const convertors = [
+	createTable,
+	dropTable,
+	renameTable,
+	addColumn,
+	dropColumn,
+	renameColumn,
+	alterColumn,
+	recreateColumn,
+	createIndex,
+	dropIndex,
+	createFK,
+	createPK,
+	dropPK,
+	createCheck,
+	dropConstraint,
+	createView,
+	dropView,
+	renameView,
+	alterView,
+];
+
+export function fromJson(
+	statements: JsonStatement[],
+) {
+	const grouped = statements
+		.map((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+			if (!convertor) throw new Error(`No convertor for: ${statement.type} statement`);
+
+			const sqlStatements = convertor.convert(statement as any);
+			const statements = typeof sqlStatements === 'string' ? [sqlStatements] : sqlStatements;
+			return { jsonStatement: statement, sqlStatements: statements };
+		})
+		.filter((it) => it !== null);
+
+	const result = {
+		sqlStatements: grouped.map((it) => it.sqlStatements).flat(),
+		groupedStatements: grouped,
+	};
+	return result;
+}
diff --git a/drizzle-kit/src/dialects/mysql/ddl.ts b/drizzle-kit/src/dialects/mysql/ddl.ts
new file mode 100644
index 0000000000..42a2fd026e
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/ddl.ts
@@ -0,0 +1,306 @@
+import type { SchemaForPull } from '../../cli/commands/pull-common';
+import { create } from '../dialect';
+import { nameForUnique } from './grammar';
+
+export const createDDL = () => {
+	return create({
+		tables: {},
+		columns: {
+			table: 'required',
+			type: 'string',
+			notNull: 'boolean',
+			autoIncrement: 'boolean',
+			default: 'string?',
+			onUpdateNow: 'boolean',
+			onUpdateNowFsp: 'number?',
+			charSet: 'string?',
+			collation: 'string?',
+			generated: {
+				type: ['stored', 'virtual'],
+				as: 'string',
+			},
+		},
+		pks: {
+			table: 'required',
+			columns: 'string[]',
+		},
+		fks: {
+			table: 'required',
+			columns: 'string[]',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+			onDelete: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+			nameExplicit: 'boolean',
+		},
+		indexes: {
+			table: 'required',
+			columns: [{
+				value: 'string',
+				isExpression: 'boolean',
+			}],
+			isUnique: 'boolean',
+			using: ['btree', 'hash', null],
+			algorithm: ['default', 'inplace', 'copy', null],
+			lock: ['default', 'none', 'shared', 'exclusive', null],
+			nameExplicit: 'boolean', // needed because uniques name can be not specified
+		},
+		checks: {
+			table: 'required',
+			value: 'string',
+		},
+		views: {
+			definition: 'string',
+			algorithm: ['undefined', 'merge', 'temptable'],
+			sqlSecurity: ['definer', 'invoker'],
+			withCheckOption: ['local', 'cascaded', null],
+		},
+	});
+};
+
+export type MysqlDDL = ReturnType<typeof createDDL>;
+
+export type MysqlEntities = MysqlDDL['_']['types'];
+export type MysqlEntity = MysqlEntities[keyof MysqlEntities];
+export type DiffEntities = MysqlDDL['_']['diffs']['alter'];
+
+export type Table = MysqlEntities['tables'];
+export type Column = MysqlEntities['columns'];
+export type Index = MysqlEntities['indexes'];
+export type ForeignKey = MysqlEntities['fks'];
+export type PrimaryKey = MysqlEntities['pks'];
+export type CheckConstraint = MysqlEntities['checks'];
+export type View = MysqlEntities['views'];
+
+export type InterimColumn = Column & { isPK: boolean; isUnique: boolean; uniqueName: string | null };
+export type ViewColumn = {
+	view: string;
+	name: string;
+	type: string;
+	notNull: boolean;
+};
+
+export type InterimSchema = {
+	tables: Table[];
+	columns: InterimColumn[];
+	pks: PrimaryKey[];
+	fks: ForeignKey[];
+	indexes: Index[];
+	checks: CheckConstraint[];
+	views: View[];
+	viewColumns: ViewColumn[];
+};
+
+export type TableFull = {
+	name: string;
+	columns: Column[];
+	pk: PrimaryKey | null;
+	fks: ForeignKey[];
+	checks: CheckConstraint[];
+	indexes: Index[];
+};
+
+export const fullTableFromDDL = (table: Table, ddl: MysqlDDL): TableFull => {
+	const filter = { table: table.name };
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+	return {
+		name: table.name,
+		columns,
+		pk,
+		fks,
+		checks,
+		indexes,
+	};
+};
+
+export type SchemaError = {
+	type: 'table_name_conflict';
+	name: string;
+} | {
+	type: 'column_name_conflict';
+	table: string;
+	name: string;
+} | {
+	type: 'column_unsupported_unique';
+	table: string;
+	columns: string[];
+} | {
+	type: 'column_unsupported_default_on_autoincrement';
+	table: string;
+	column: string;
+};
+
+export const interimToDDL = (interim: InterimSchema): { ddl: MysqlDDL; errors: SchemaError[] } => {
+	const errors = [] as SchemaError[];
+	const ddl = createDDL();
+	const resrtictedUniqueFor = [
+		'blob',
+		'tinyblob',
+		'mediumblob',
+		'longblob',
+		'text',
+		'tinytext',
+		'mediumtext',
+		'longtext',
+	];
+
+	for (const table of interim.tables) {
+		const res = ddl.tables.push(table);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'table_name_conflict', name: table.name });
+		}
+	}
+
+	for (const column of interim.columns) {
+		const { isPK: _1, isUnique: _2, uniqueName: _3, ...rest } = column;
+		const res = ddl.columns.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'column_name_conflict', table: column.table, name: column.name });
+		}
+
+		if ((column.type.startsWith('serial') || column.autoIncrement) && column.default !== null) {
+			errors.push({ type: 'column_unsupported_default_on_autoincrement', table: column.table, column: column.name });
+		}
+	}
+
+	for (const pk of interim.pks) {
+		const res = ddl.pks.push({ table: pk.table, name: 'PRIMARY', columns: pk.columns });
+		if (res.status === 'CONFLICT') {
+			throw new Error(`PK conflict: ${JSON.stringify(pk)}`);
+		}
+	}
+
+	for (const column of interim.columns.filter((it) => it.isPK)) {
+		const exists = ddl.pks.one({
+			table: column.table,
+			name: 'PRIMARY', // database default
+		}) !== null;
+		if (exists) continue;
+
+		ddl.pks.push({
+			table: column.table,
+			name: 'PRIMARY', // database default
+			columns: [column.name],
+		});
+	}
+
+	for (const column of interim.columns.filter((it) => it.isUnique)) {
+		if (resrtictedUniqueFor.some((rc) => column.type.startsWith(rc))) {
+			errors.push({ type: 'column_unsupported_unique', columns: [column.name], table: column.table });
+		}
+
+		const name = column.uniqueName ?? nameForUnique(column.table, [column.name]);
+		const res = ddl.indexes.push({
+			table: column.table,
+			name,
+			columns: [{ value: column.name, isExpression: false }],
+			isUnique: true,
+			using: null,
+			algorithm: null,
+			lock: null,
+			nameExplicit: !!column.uniqueName,
+		});
+
+		if (res.status === 'CONFLICT') {
+			throw new Error(`Index unique conflict: ${name}`);
+		}
+	}
+
+	for (const index of interim.indexes) {
+		const res = ddl.indexes.push(index);
+		if (res.status === 'CONFLICT') {
+			throw new Error(`Index conflict: ${JSON.stringify(index)}`);
+		}
+	}
+	for (const index of interim.indexes.filter((i) => i.isUnique)) {
+		const conflictColumns = index.columns.filter((col) => {
+			if (col.isExpression) return false;
+
+			const column = ddl.columns.one({ table: index.table, name: col.value });
+
+			return resrtictedUniqueFor.some(
+				(restrictedType) => column?.type.startsWith(restrictedType),
+			);
+		});
+
+		if (conflictColumns.length > 0) {
+			errors.push({
+				type: 'column_unsupported_unique',
+				columns: conflictColumns.map((it) => it.value),
+				table: index.table,
+			});
+		}
+	}
+
+	for (const fk of interim.fks) {
+		const res = ddl.fks.push(fk);
+		if (res.status === 'CONFLICT') {
+			throw new Error(`FK conflict: ${JSON.stringify(fk)}`);
+		}
+	}
+
+	for (const check of interim.checks) {
+		const res = ddl.checks.push(check);
+		if (res.status === 'CONFLICT') {
+			throw new Error(`Check constraint conflict: ${JSON.stringify(check)}`);
+		}
+	}
+
+	for (const view of interim.views) {
+		const res = ddl.views.push(view);
+		if (res.status === 'CONFLICT') {
+			throw new Error(`View conflict: ${JSON.stringify(view)}`);
+		}
+	}
+
+	// TODO: add to other dialects, though potentially we should check on push
+	for (const it of ddl.entities.list()) {
+		if (!ddl.entities.validate(it)) {
+			throw new Error(`Invalid entity: ${JSON.stringify(it)}`);
+		}
+	}
+
+	return { ddl, errors };
+};
+
+export const tableFromDDL = (
+	table: MysqlEntities['tables'],
+	ddl: MysqlDDL,
+) => {
+	const filter = { table: table.name } as const;
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+
+	return {
+		...table,
+		columns,
+		pk,
+		fks,
+		checks,
+		indexes,
+	};
+};
+
+export function mysqlToRelationsPull(schema: MysqlDDL): SchemaForPull {
+	return Object.values(schema.tables.list()).map((table) => {
+		const rawTable = tableFromDDL(table, schema);
+		return {
+			foreignKeys: rawTable.fks,
+			columns: rawTable.columns.map((it) => ({ name: it.name })),
+			uniques: Object.values(rawTable.indexes).map((idx) => ({
+				columns: idx.columns.map((idxc) => {
+					if (!idxc.isExpression && idx.isUnique) {
+						return idxc.value;
+					}
+				}).filter((item) => item !== undefined),
+			})),
+		};
+	});
+}
diff --git a/drizzle-kit/src/dialects/mysql/diff.ts b/drizzle-kit/src/dialects/mysql/diff.ts
new file mode 100644
index 0000000000..c88a6cb153
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/diff.ts
@@ -0,0 +1,511 @@
+import { trimChar } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import type { Resolver } from '../common';
+import { diff } from '../dialect';
+import { groupDiffs, preserveEntityNames } from '../utils';
+import { fromJson } from './convertor';
+import type { Column, DiffEntities, Index, MysqlDDL, Table, View } from './ddl';
+import { fullTableFromDDL } from './ddl';
+import { charSetAndCollationCommutative, commutative, defaultNameForFK } from './grammar';
+import { prepareStatement } from './statements';
+import type { JsonStatement } from './statements';
+
+export const ddlDiffDry = async (from: MysqlDDL, to: MysqlDDL, mode: 'default' | 'push' = 'default') => {
+	const s = new Set<string>();
+	return ddlDiff(from, to, mockResolver(s), mockResolver(s), mockResolver(s), mode);
+};
+
+export const ddlDiff = async (
+	ddl1: MysqlDDL,
+	ddl2: MysqlDDL,
+	tablesResolver: Resolver<Table>,
+	columnsResolver: Resolver<Column>,
+	viewsResolver: Resolver<View>,
+	mode: 'default' | 'push',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: { jsonStatement: JsonStatement; sqlStatements: string[] }[];
+	renames: string[];
+}> => {
+	const tablesDiff = diff(ddl1, ddl2, 'tables');
+
+	const { created: createdTables, deleted: deletedTables, renamedOrMoved: renamedTables } = await tablesResolver({
+		created: tablesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: tablesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const renamed of renamedTables) {
+		ddl1.tables.update({
+			set: {
+				name: renamed.to.name,
+			},
+			where: {
+				name: renamed.from.name,
+			},
+		});
+
+		const selfRefs = ddl1.fks.update({
+			set: {
+				table: renamed.to.name,
+				tableTo: renamed.to.name,
+			},
+			where: {
+				table: renamed.from.name,
+				tableTo: renamed.from.name,
+			},
+		});
+
+		const froms = ddl1.fks.update({
+			set: {
+				table: renamed.to.name,
+			},
+			where: {
+				table: renamed.from.name,
+			},
+		});
+
+		const tos = ddl1.fks.update({
+			set: {
+				tableTo: renamed.to.name,
+			},
+			where: {
+				tableTo: renamed.from.name,
+			},
+		});
+
+		// preserve name for foreign keys
+		const renamedFKs = [...selfRefs.data, ...froms.data, ...tos.data];
+		for (const fk of renamedFKs) {
+			const name = defaultNameForFK(fk);
+			ddl2.fks.update({
+				set: {
+					name: fk.name,
+				},
+				where: {
+					name: name,
+				},
+			});
+		}
+
+		ddl1.entities.update({
+			set: {
+				table: renamed.to.name,
+			},
+			where: {
+				table: renamed.from.name,
+			},
+		});
+	}
+
+	const columnsDiff = diff(ddl1, ddl2, 'columns').filter((it) =>
+		!createdTables.some((table) => table.name === it.table)
+	); // filter out columns for newly created tables
+
+	const groupedByTable = groupDiffs(columnsDiff);
+
+	const columnRenames = [] as { from: Column; to: Column }[];
+	const columnCreates = [] as Column[];
+	const columnDeletes = [] as Column[];
+
+	for (let it of groupedByTable) {
+		const { renamedOrMoved: renamed, created, deleted } = await columnsResolver({
+			deleted: it.deleted,
+			created: it.inserted,
+		});
+
+		columnCreates.push(...created);
+		columnDeletes.push(...deleted);
+		columnRenames.push(...renamed);
+	}
+
+	for (const rename of columnRenames) {
+		ddl1.columns.update({
+			set: {
+				name: rename.to.name,
+			},
+			where: {
+				table: rename.from.table,
+				name: rename.from.name,
+			},
+		});
+
+		// DDL2 updates are needed for Drizzle Studio
+		const update1 = {
+			set: {
+				columns: (it: Index['columns'][number]) => {
+					if (!it.isExpression && it.value === rename.from.name) {
+						it.value = rename.to.name;
+					}
+					return it;
+				},
+			},
+			where: {
+				table: rename.from.table,
+			},
+		} as const;
+
+		ddl1.indexes.update(update1);
+		ddl2.indexes.update(update1);
+
+		const update2 = {
+			set: {
+				columns: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update2);
+		ddl2.fks.update(update2);
+
+		const update3 = {
+			set: {
+				columnsTo: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				tableTo: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update3);
+		ddl2.fks.update(update3);
+
+		const update4 = {
+			set: {
+				columns: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				table: rename.from.table,
+			},
+		};
+		ddl1.pks.update(update4);
+		ddl2.pks.update(update4);
+	}
+
+	preserveEntityNames(ddl1.fks, ddl2.fks, mode);
+	preserveEntityNames(ddl1.indexes, ddl2.indexes, mode);
+
+	const viewsDiff = diff(ddl1, ddl2, 'views');
+
+	const { created: createdViews, deleted: deletedViews, renamedOrMoved: renamedViews } = await viewsResolver({
+		created: viewsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: viewsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const rename of renamedViews) {
+		ddl1.views.update({
+			set: {
+				name: rename.to.name,
+			},
+			where: {
+				name: rename.from.name,
+			},
+		});
+	}
+
+	const checksDiff = diff(ddl1, ddl2, 'checks');
+	const indexesDiff = diff(ddl1, ddl2, 'indexes');
+	const fksDiff = diff(ddl1, ddl2, 'fks');
+	const pksDiff = diff(ddl1, ddl2, 'pks');
+
+	const alters = diff.alters(ddl1, ddl2);
+
+	const createTableStatements = createdTables.map((it) => {
+		const full = fullTableFromDDL(it, ddl2);
+		if (createdTables.length > 1) full.fks = []; // fks have to be created after all tables created
+		return prepareStatement('create_table', { table: full });
+	});
+
+	const dropTableStatements = deletedTables.map((it) => {
+		return prepareStatement('drop_table', { table: it.name });
+	});
+
+	const renameTableStatements = renamedTables.map((it) => {
+		return prepareStatement('rename_table', { from: it.from.name, to: it.to.name });
+	});
+
+	const renameColumnsStatement = columnRenames.map((it) => {
+		return prepareStatement('rename_column', {
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		});
+	});
+
+	const createViewStatements = createdViews.map((it) => prepareStatement('create_view', { view: it, replace: false }));
+
+	const dropViewStatements = deletedViews.map((it) => {
+		return prepareStatement('drop_view', { name: it.name });
+	});
+
+	const renameViewStatements = renamedViews.map((it) => {
+		return prepareStatement('rename_view', {
+			from: it.from.name,
+			to: it.to.name,
+		});
+	});
+
+	const alterViewStatements = alters.filter((it) => it.entityType === 'views')
+		.map((it) => {
+			// TODO: We should probably print a CLI hint for the user too
+			if (it.definition && mode === 'push') delete it.definition;
+
+			/*
+				UNDEFINED lets the server pick at execution time (often it still runs as a merge if the query is “mergeable”).
+				Specifying MERGE when it’s not possible causes MySQL to store UNDEFINED with a warning,
+				but the reverse (forcing UNDEFINED to overwrite MERGE) doesn’t happen via ALTER.
+
+				https://dev.mysql.com/doc/refman/8.4/en/view-algorithms.html
+
+				TODO: We should probably print a hint in CLI for the user
+			*/
+			if (it.algorithm && it.algorithm.to === 'undefined') delete it.algorithm;
+			return it;
+		})
+		.filter((it) => ddl2.views.hasDiff(it))
+		.map((it) => {
+			const view = ddl2.views.one({ name: it.name })!;
+			if (it.definition) return prepareStatement('create_view', { view, replace: true });
+			return prepareStatement('alter_view', { diff: it, view });
+		});
+
+	const dropCheckStatements = checksDiff.filter((it) => it.$diffType === 'drop')
+		.filter((it) => !deletedTables.some((x) => x.name === it.table))
+		.map((it) => prepareStatement('drop_constraint', { constraint: it.name, table: it.table, dropAutoIndex: false }));
+
+	const dropIndexeStatements = indexesDiff.filter((it) => it.$diffType === 'drop').filter((it) =>
+		!deletedTables.some((x) => x.name === it.table)
+	).map((it) => prepareStatement('drop_index', { index: it }));
+
+	const dropFKStatements = fksDiff.filter((it) => it.$diffType === 'drop')
+		.filter((it) => {
+			const tableDeteled = deletedTables.some((x) => x.name === it.table);
+			const tableToDeleted = deletedTables.some((x) => x.name === it.tableTo);
+			return !(tableDeteled && !tableToDeleted);
+		})
+		.map((it) => {
+			let dropAutoIndex = ddl2.indexes.one({ table: it.table, name: it.name }) === null;
+			dropAutoIndex &&= !deletedTables.some((x) => x.name === it.table);
+			return prepareStatement('drop_constraint', { table: it.table, constraint: it.name, dropAutoIndex });
+		});
+
+	const dropPKStatements = pksDiff.filter((it) => it.$diffType === 'drop')
+		.filter((it) => !deletedTables.some((x) => x.name === it.table))
+		/*
+			we can't do `create table a(id int auto_increment);`
+			but we can do `ALTER TABLE `table1` MODIFY COLUMN `column1` int AUTO_INCREMENT`
+			and database implicitly makes column a Primary Key
+		 */
+		.filter((it) => {
+			if (it.columns.length === 1 && ddl2.columns.one({ table: it.table, name: it.columns[0] })?.autoIncrement) {
+				return false;
+			}
+			return true;
+		})
+		.map((it) => prepareStatement('drop_pk', { pk: it }));
+
+	const createCheckStatements = checksDiff.filter((it) => it.$diffType === 'create')
+		.filter((it) => !createdTables.some((x) => x.name === it.table))
+		.map((it) => prepareStatement('create_check', { check: it }));
+
+	const createIndexesStatements = indexesDiff.filter((it) => it.$diffType === 'create')
+		.filter((it) => !it.isUnique || !createdTables.some((x) => x.name === it.table))
+		.map((it) => prepareStatement('create_index', { index: it }));
+
+	const createFKsStatements = fksDiff.filter((it) => it.$diffType === 'create')
+		.filter((x) => createdTables.length >= 2 || !createdTables.some((it) => it.name === x.table))
+		.map((it) => prepareStatement('create_fk', { fk: it }));
+
+	const createPKStatements = pksDiff.filter((it) => it.$diffType === 'create')
+		.filter((it) => !createdTables.some((x) => x.name === it.table))
+		.map((it) => prepareStatement('create_pk', { pk: it }));
+
+	const addColumnsStatemets = columnCreates.filter((it) => it.entityType === 'columns').map((it) => {
+		const pk = ddl2.pks.one({ table: it.table });
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === it.name;
+		return prepareStatement('add_column', { column: it, isPK: isPK ?? false });
+	});
+
+	const dropColumnStatements = columnDeletes
+		.filter((it) => !deletedTables.some((x) => x.name === it.table))
+		.filter((it) => it.entityType === 'columns').map((it) => {
+			return prepareStatement('drop_column', { column: it });
+		});
+
+	const alterColumnPredicate: (it: DiffEntities['columns']) => boolean = (it) => {
+		if (it.generated) {
+			if (it.generated.from && it.generated.to) return false;
+			if (it.generated.from && it.generated.from.type === 'virtual') return false;
+			if (it.generated.to && it.generated.to.type === 'virtual') return false;
+		}
+		return true;
+	};
+
+	const columnAlterStatements = alters.filter((it) => it.entityType === 'columns')
+		.filter((it) => {
+			if (it.type && commutative(it.type.from, it.type.to, mode)) {
+				delete it.type;
+			}
+
+			if (it.default && it.default.from && it.default.to && commutative(it.default.from, it.default.to, mode)) {
+				delete it.default;
+			}
+
+			if (it.autoIncrement && it.autoIncrement.to && it.$right.type === 'serial') delete it.autoIncrement;
+			if (it.notNull && it.notNull.from && (it.$right.type === 'serial' || it.$right.autoIncrement)) delete it.notNull;
+
+			if (it.default) {
+				let deleteDefault = false;
+				deleteDefault ||= it.default.from === it.default.to;
+				deleteDefault ||= it.default.from === `(${it.default.to})`;
+				deleteDefault ||= it.default.to === `(${it.default.from})`;
+
+				// varbinary
+				deleteDefault ||= it.default.from === `(${it.default.to?.toLowerCase()})`;
+				deleteDefault ||= it.default.to === `(${it.default.from?.toLowerCase()})`;
+
+				if (deleteDefault) {
+					delete it.default;
+				}
+			}
+
+			if (
+				mode === 'push' && it.generated && it.generated.from && it.generated.to
+				&& it.generated.from.as !== it.generated.to.as
+			) {
+				delete it.generated;
+			}
+
+			if (
+				it.notNull
+			) {
+				const isPk = !!ddl2.pks.one({ table: it.table, columns: { CONTAINS: it.name } });
+				const wasPk = !!ddl1.pks.one({ table: it.table, columns: { CONTAINS: it.name } });
+
+				// only if column is no longer pk, but new declaration is not not null, we need to set column not null
+				if (!isPk && wasPk) {}
+				else if (isPk || wasPk) delete it.notNull; // if there's a change in notnull but column is a part of a pk - we don't care
+			}
+
+			if (
+				mode === 'push' && (it.charSet || it.collation)
+				&& charSetAndCollationCommutative(
+					{ charSet: it.$left.charSet ?? null, collation: it.$left.collation ?? null },
+					{ charSet: it.$right.charSet ?? null, collation: it.$right.collation ?? null },
+				)
+			) {
+				delete it.charSet;
+				delete it.collation;
+			}
+
+			if (
+				mode === 'push' && !it.type && it.default && it.default.from && it.default.to
+				&& (it.$right.type === 'datetime' || it.$right.type === 'timestamp')
+			) {
+				const c1 = Date.parse(trimChar(it.default.from, "'"));
+				const c2 = Date.parse(trimChar(it.default.to, "'"));
+				if (c1 === c2) delete it.default;
+			}
+
+			return ddl2.columns.hasDiff(it) && alterColumnPredicate(it);
+		}).map((it) => {
+			// const { $diffType: _1, $left: _2, $right: _3, entityType: _4, table: _5, ...rest } = it;
+			const isPK = !!ddl2.pks.one({ table: it.table, columns: [it.name] });
+			const wasPK = !!ddl1.pks.one({ table: it.table, columns: [it.name] });
+
+			const potentialTableRename = renamedTables.find((x) => x.to.name === it.$left.table);
+			const originTableName = potentialTableRename?.from.name ?? it.$left.table;
+
+			const potentialRename = columnRenames.find((x) => x.from.table === it.$left.table && x.to.name === it.$left.name);
+			const originColumnName = potentialRename?.from.name ?? it.$left.name;
+
+			return prepareStatement('alter_column', {
+				diff: it,
+				column: it.$right,
+				isPK: isPK,
+				wasPK,
+				origin: {
+					table: originTableName,
+					column: originColumnName,
+				},
+			});
+		});
+
+	const columnRecreateStatatements = alters.filter((it) => it.entityType === 'columns').filter((it) =>
+		!alterColumnPredicate(it)
+	).map((it) => {
+		const column = ddl2.columns.one({ name: it.name, table: it.table })!;
+		const pk = ddl2.pks.one({ table: it.table });
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === column.name;
+		return prepareStatement('recreate_column', { column, isPK: isPK ?? false, diff: it });
+	});
+
+	for (const pk of alters.filter((x) => x.entityType === 'pks')) {
+		if (pk.columns) {
+			const fks = ddl2.fks.list({ tableTo: pk.table });
+			const fksFound = fks.filter((fk) => {
+				if (fk.columnsTo.length !== pk.$left.columns.length) return false;
+
+				return fk.columnsTo.every((fkCol) => pk.$left.columns.includes(fkCol));
+			});
+
+			for (const fk of fksFound) {
+				dropFKStatements.push({ type: 'drop_constraint', table: fk.table, constraint: fk.name, dropAutoIndex: false });
+				createFKsStatements.push({ type: 'create_fk', fk: fk, cause: 'alter_pk' });
+			}
+
+			dropPKStatements.push({ type: 'drop_pk', pk: pk.$left });
+			createPKStatements.push({ type: 'create_pk', pk: pk.$right });
+		}
+	}
+
+	for (const fk of alters.filter((x) => x.entityType === 'fks')) {
+		if (fk.onDelete || fk.onUpdate) {
+			const dropAutoIndex = false;
+			dropFKStatements.push({ type: 'drop_constraint', table: fk.table, constraint: fk.name, dropAutoIndex });
+			createFKsStatements.push({ type: 'create_fk', fk: fk.$right });
+		}
+	}
+
+	const statements = [
+		...new Set([
+			...createTableStatements,
+			...dropFKStatements,
+			...dropTableStatements,
+			...renameTableStatements,
+
+			...renameColumnsStatement,
+
+			...dropViewStatements,
+			...renameViewStatements,
+			...alterViewStatements,
+
+			...dropCheckStatements,
+
+			...dropIndexeStatements,
+			...dropPKStatements,
+
+			...columnAlterStatements,
+			...columnRecreateStatatements,
+
+			...addColumnsStatemets,
+			...createPKStatements,
+
+			...createIndexesStatements,
+			...createFKsStatements,
+			...createCheckStatements,
+
+			...dropColumnStatements,
+			...createViewStatements,
+		]),
+	];
+
+	const res = fromJson(statements);
+
+	return {
+		statements: statements,
+		sqlStatements: res.sqlStatements,
+		groupedStatements: res.groupedStatements,
+		renames: [],
+	};
+};
diff --git a/drizzle-kit/src/dialects/mysql/drizzle.ts b/drizzle-kit/src/dialects/mysql/drizzle.ts
new file mode 100644
index 0000000000..07e102ef93
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/drizzle.ts
@@ -0,0 +1,342 @@
+import { getTableName, is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { AnyMySqlColumn, AnyMySqlTable } from 'drizzle-orm/mysql-core';
+import {
+	getTableConfig,
+	getViewConfig,
+	MySqlChar,
+	MySqlColumn,
+	MySqlCustomColumn,
+	MySqlDateTime,
+	MySqlDialect,
+	MySqlEnumColumn,
+	MySqlTable,
+	MySqlText,
+	MySqlTimestamp,
+	MySqlVarChar,
+	MySqlView,
+} from 'drizzle-orm/mysql-core';
+import { loadModule } from '../../utils/utils-node';
+import { sqlToStr } from '../drizzle';
+import type { Column, InterimSchema } from './ddl';
+import { defaultNameForFK, nameForUnique, typeFor } from './grammar';
+
+export const defaultFromColumn = (
+	column: AnyMySqlColumn,
+): Column['default'] => {
+	if (typeof column.default === 'undefined') return null;
+	let value = column.default;
+
+	if (is(column.default, SQL)) {
+		let str = sqlToStr(column.default);
+		// we need to wrap unknown statements in () otherwise there's not enough info in Type.toSQL
+		if (!str.startsWith('(')) return `(${str})`;
+		return str;
+	}
+
+	if (is(column, MySqlCustomColumn)) {
+		const res = column.mapToDriverValue(column.default);
+		if (typeof res === 'string') value = res;
+		value = String(res);
+	}
+
+	const grammarType = typeFor(column.getSQLType().toLowerCase());
+	if (grammarType) return grammarType.defaultFromDrizzle(value);
+
+	throw new Error(`unexpected default: ${column.getSQLType().toLowerCase()} ${column.default}`);
+};
+
+export const upper = <T extends string>(value: T | undefined): Uppercase<T> | null => {
+	if (!value) return null;
+	return value.toUpperCase() as Uppercase<T>;
+};
+
+export const fromDrizzleSchema = (
+	tables: AnyMySqlTable[],
+	views: MySqlView[],
+): InterimSchema => {
+	const dialect = new MySqlDialect();
+	const result: InterimSchema = {
+		tables: [],
+		columns: [],
+		pks: [],
+		fks: [],
+		indexes: [],
+		checks: [],
+		views: [],
+		viewColumns: [],
+	};
+
+	for (const table of tables) {
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			foreignKeys,
+			schema,
+			checks,
+			primaryKeys,
+			uniqueConstraints,
+		} = getTableConfig(table);
+
+		if (schema) continue;
+
+		result.tables.push({
+			entityType: 'tables',
+			name: tableName,
+		});
+
+		for (const column of columns) {
+			const { name } = column;
+			const notNull: boolean = column.notNull;
+
+			const sqlType = column.getSQLType().replace(', ', ','); // TODO: remove, should be redundant real(6, 3)->real(6,3)
+
+			const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
+				? false
+				: (column as any).autoIncrement;
+
+			const generated: Column['generated'] = column.generated
+				? {
+					as: is(column.generated.as, SQL)
+						? dialect.sqlToQuery(column.generated.as as SQL).sql
+						: typeof column.generated.as === 'function'
+						? dialect.sqlToQuery(column.generated.as() as SQL).sql
+						: (column.generated.as as any),
+					type: column.generated.mode === 'virtual' ? 'virtual' : 'stored',
+				}
+				: null;
+
+			const defaultValue = defaultFromColumn(column);
+			const type = is(column, MySqlEnumColumn)
+				? `enum(${column.enumValues?.map((it) => `'${it.replaceAll("'", "''")}'`).join(',')})`
+				: sqlType;
+
+			let onUpdateNow: boolean = false;
+			let onUpdateNowFsp: number | null = null;
+			if (is(column, MySqlTimestamp) || is(column, MySqlDateTime)) {
+				onUpdateNow = column.hasOnUpdateNow ?? false;
+				onUpdateNowFsp = column.onUpdateNowFsp ?? null;
+			}
+
+			let charSet: string | null = null;
+			let collation: string | null = null;
+			if (is(column, MySqlChar) || is(column, MySqlVarChar) || is(column, MySqlText) || is(column, MySqlEnumColumn)) {
+				charSet = column.charSet;
+				collation = column.collation ?? null;
+			}
+
+			result.columns.push({
+				entityType: 'columns',
+				table: tableName,
+				name,
+				type,
+				notNull,
+				autoIncrement,
+				onUpdateNow,
+				onUpdateNowFsp,
+				charSet,
+				collation,
+				generated,
+				isPK: column.primary,
+				isUnique: column.isUnique,
+				uniqueName: column.uniqueName ?? null,
+				default: defaultValue,
+			});
+		}
+
+		for (const pk of primaryKeys) {
+			const columnNames = pk.columns.map((c: any) => c.name);
+
+			result.pks.push({
+				entityType: 'pks',
+				table: tableName,
+				name: 'PRIMARY',
+				columns: columnNames,
+			});
+		}
+
+		for (const unique of uniqueConstraints) {
+			const columns = unique.columns.map((c) => {
+				if (is(c, SQL)) {
+					const sql = dialect.sqlToQuery(c).sql;
+					return { value: sql, isExpression: true };
+				}
+				return { value: c.name, isExpression: false };
+			});
+
+			const name = unique.isNameExplicit
+				? unique.name
+				: nameForUnique(tableName, unique.columns.filter((c) => !is(c, SQL)).map((c) => c.name));
+
+			result.indexes.push({
+				entityType: 'indexes',
+				table: tableName,
+				name: name,
+				columns: columns,
+				isUnique: true,
+				algorithm: null,
+				lock: null,
+				using: null,
+				nameExplicit: unique.isNameExplicit,
+			});
+		}
+
+		for (const fk of foreignKeys) {
+			const reference = fk.reference();
+			const referenceFT = reference.foreignTable;
+
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			const tableTo = getTableName(referenceFT);
+
+			const columnsFrom = reference.columns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => it.name);
+
+			let name = fk.isNameExplicit()
+				? fk.getName()
+				: defaultNameForFK({ table: tableName, columns: columnsFrom, tableTo, columnsTo });
+
+			result.fks.push({
+				entityType: 'fks',
+				table: tableName,
+				name,
+				columns: columnsFrom,
+				tableTo,
+				columnsTo,
+				onUpdate: upper(fk.onUpdate) ?? 'NO ACTION',
+				onDelete: upper(fk.onDelete) ?? 'NO ACTION',
+				nameExplicit: fk.isNameExplicit(),
+			});
+		}
+
+		for (const index of indexes) {
+			const columns = index.config.columns;
+			const name = index.config.name;
+
+			result.indexes.push({
+				entityType: 'indexes',
+				table: tableName,
+				name,
+				columns: columns.map((it) => {
+					if (is(it, SQL)) {
+						const sql = dialect.sqlToQuery(it, 'indexes').sql;
+						return { value: sql, isExpression: true };
+					} else {
+						return { value: `${it.name}`, isExpression: false };
+					}
+				}),
+				algorithm: index.config.algorithm ?? null,
+				lock: index.config.lock ?? null,
+				isUnique: index.config.unique ?? false,
+				using: index.config.using ?? null,
+				nameExplicit: index.isNameExplicit,
+			});
+		}
+
+		for (const check of checks) {
+			const name = check.name;
+			const value = check.value;
+
+			result.checks.push({
+				entityType: 'checks',
+				table: tableName,
+				name,
+				value: dialect.sqlToQuery(value).sql,
+			});
+		}
+	}
+
+	for (
+		// see in "./dialects/postgres/drizzle.ts" for more
+		const view of views.sort((a, b) => {
+			const aConfig = getViewConfig(a);
+			const bConfig = getViewConfig(b);
+
+			// If a's fields include b, a depends on b → b comes first
+			if (aConfig.query?.queryChunks.includes(b)) return 1;
+
+			// If b's fields include a, b depends on a → a comes first
+			if (bConfig.query?.queryChunks.includes(a)) return -1;
+
+			return 0;
+		})
+	) {
+		const cfg = getViewConfig(view);
+		const {
+			isExisting,
+			name,
+			query,
+			selectedFields,
+			algorithm,
+			sqlSecurity,
+			withCheckOption,
+		} = cfg;
+
+		if (isExisting) continue;
+
+		for (const key in selectedFields) {
+			if (is(selectedFields[key], MySqlColumn)) {
+				const column = selectedFields[key];
+				const notNull: boolean = column.notNull;
+
+				result.viewColumns.push({
+					view: name,
+					name: column.name,
+					type: column.getSQLType(),
+					notNull: notNull,
+				});
+			}
+		}
+
+		result.views.push({
+			entityType: 'views',
+			name,
+			definition: query ? dialect.sqlToQuery(query).sql : '',
+			withCheckOption: withCheckOption ?? null,
+			algorithm: algorithm ?? 'undefined', // set default values
+			sqlSecurity: sqlSecurity ?? 'definer', // set default values
+		});
+	}
+
+	return result;
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnyMySqlTable[] = [];
+	const views: MySqlView[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = prepareFromExports(i0);
+
+		tables.push(...prepared.tables);
+		views.push(...prepared.views);
+		relations.push(...prepared.relations);
+	}
+	return { tables: Array.from(new Set(tables)), views, relations };
+};
+
+export const prepareFromExports = (exports: Record<string, unknown>) => {
+	const tables: AnyMySqlTable[] = [];
+	const views: MySqlView[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (is(t, MySqlTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, MySqlView)) {
+			views.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return { tables, views, relations };
+};
diff --git a/drizzle-kit/src/dialects/mysql/grammar.ts b/drizzle-kit/src/dialects/mysql/grammar.ts
new file mode 100644
index 0000000000..733e253f77
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/grammar.ts
@@ -0,0 +1,1069 @@
+import { assertUnreachable, trimChar } from '../../utils';
+import { parse, stringify } from '../../utils/when-json-met-bigint';
+import { hash } from '../common';
+import { escapeForSqlDefault, escapeForTsLiteral, parseParams, unescapeFromSqlDefault } from '../utils';
+import type { Column, ForeignKey } from './ddl';
+import type { Import } from './typescript';
+
+/*
+	TODO: revise handling of float/double in both orm and kit
+	in orm we can limit 0-23 precision for float and 24-53 in float/double types
+	in kit we can trim default values based on scale param with .toFixed(scale ?? defaultScale)
+
+	MySQL also supports this optional precision specification,
+	but the precision value in FLOAT(p) is used only to determine storage size.
+	A precision from 0 to 23 results in a 4-byte single-precision FLOAT column.
+	A precision from 24 to 53 results in an 8-byte double-precision DOUBLE column.
+
+	MySQL performs rounding when storing values, so if you insert 999.00009 into a FLOAT(7,4) column, the approximate result is 999.0001.
+*/
+
+/*
+	TODO:
+	Drizzle ORM allows real/double({ precision: 6 }) which is only allowed with scale
+*/
+
+const checkNumber = (it: string) => {
+	const check = Number(it);
+
+	if (Number.isNaN(check)) return 'NaN';
+	if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) return 'number';
+	return 'bigint';
+};
+
+export interface SqlType<MODE = unknown> {
+	is(type: string): boolean;
+	drizzleImport(vendor?: 'singlestore' | 'mysql'): Import;
+	defaultFromDrizzle(value: unknown, mode?: MODE): Column['default'];
+	defaultFromIntrospect(value: string): Column['default'];
+	toTs(
+		type: string,
+		value: Column['default'],
+	): { options?: Record<string, unknown>; default: string; customType?: string }; // customType for Custom
+}
+
+const IntOps: Pick<SqlType, 'defaultFromDrizzle' | 'defaultFromIntrospect'> = {
+	defaultFromDrizzle: function(value: unknown): Column['default'] {
+		if (typeof value === 'number') {
+			return String(value);
+		}
+		return String(value);
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		return value;
+	},
+};
+
+export const Int: SqlType = {
+	is: (type: string) => /^(?:int)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'int',
+	defaultFromDrizzle: IntOps.defaultFromDrizzle,
+	defaultFromIntrospect: IntOps.defaultFromIntrospect,
+	toTs: (type, value) => {
+		const options = type.includes('unsigned') ? { unsigned: true } : undefined;
+		const check = Number(value);
+		if (Number.isNaN(check)) return { options, default: `sql\`${value}\`` };
+		return { options, default: value ?? '' };
+	},
+};
+
+export const Boolean: SqlType = {
+	is: (type) => type === 'tinyint(1)' || type === 'boolean',
+	drizzleImport: () => 'boolean',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value === '1' || value === 'true' ? 'true' : 'false';
+	},
+	toTs: (_, value) => {
+		return { default: value ?? '' };
+	},
+};
+
+export const TinyInt: SqlType = {
+	is: (type: string) => /^(?:tinyint)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'tinyint',
+	defaultFromDrizzle: IntOps.defaultFromDrizzle,
+	defaultFromIntrospect: IntOps.defaultFromIntrospect,
+	toTs: Int.toTs,
+};
+
+export const SmallInt: SqlType = {
+	is: (type: string) => /^(?:smallint)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'smallint',
+	defaultFromDrizzle: IntOps.defaultFromDrizzle,
+	defaultFromIntrospect: IntOps.defaultFromIntrospect,
+	toTs: Int.toTs,
+};
+
+export const MediumInt: SqlType = {
+	is: (type: string) => /^(?:mediumint)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'mediumint',
+	defaultFromDrizzle: IntOps.defaultFromDrizzle,
+	defaultFromIntrospect: IntOps.defaultFromIntrospect,
+	toTs: Int.toTs,
+};
+
+export const BigInt: SqlType = {
+	is: (type: string) => /^(?:bigint)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'bigint',
+	defaultFromDrizzle: (value) => {
+		if (typeof value === 'bigint') {
+			return `${value}`;
+		}
+		if (typeof value === 'number') {
+			return value.toString();
+		}
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options = type.includes('unsigned') ? { unsigned: true } : {};
+		if (value === null) return { options: { ...options, mode: 'number' }, default: '' };
+
+		const trimmed = trimChar(value, "'");
+		const numType = checkNumber(trimmed);
+		if (numType === 'NaN') return { options: { ...options, mode: 'number' }, default: `sql\`${value}\`` };
+		if (numType === 'number') return { options: { ...options, mode: 'number' }, default: trimmed };
+		if (numType === 'bigint') return { options: { ...options, mode: 'bigint' }, default: `${trimmed}n` };
+		assertUnreachable(numType);
+	},
+};
+
+export const Serial: SqlType = {
+	is: (type: string) => /^(?:serial)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'serial',
+	defaultFromDrizzle: (_value) => {
+		return ''; // handled in interim to ddl
+	},
+	defaultFromIntrospect: (value) => value,
+	toTs: (_type, _value) => {
+		return { default: '' };
+	},
+};
+
+export const Decimal: SqlType = {
+	// NUMERIC|DECIMAL[(1,1)] [UNSIGNED] [ZEROFILL]
+	is: (type) => /^(?:numeric|decimal)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'decimal',
+	defaultFromDrizzle: (value) => {
+		return `(${String(value)})`;
+	},
+	defaultFromIntrospect: (value) => value,
+	toTs: (type, value) => {
+		const options: any = type.includes('unsigned') || type.includes('UNSIGNED') ? { unsigned: true } : {};
+		const [precision, scale] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+
+		const numType = checkNumber(value);
+		if (numType === 'NaN') return { options: options, default: `sql\`${value}\`` };
+		if (numType === 'number') return { options: { ...options, mode: 'number' }, default: value };
+		if (numType === 'bigint') return { options: { ...options, mode: 'bigint' }, default: `${value}n` };
+		assertUnreachable(numType);
+	},
+};
+
+export const Real: SqlType = {
+	// REAL[(1,1)] [UNSIGNED] [ZEROFILL]
+	is: (type) => /^(?:real)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'real',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		const trimmed = trimChar(trimChar(trimChar(value, '('), ')'), "'");
+		return trimmed;
+	},
+	toTs: (type, value) => {
+		const options: any = type.includes('unsigned') || type.includes('UNSIGNED') ? { unsigned: true } : {};
+		const [precision, scale] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+
+		const numType = checkNumber(value);
+		if (numType === 'NaN') return { options, default: `sql\`${value}\`` };
+		if (numType === 'number') return { options, default: value };
+		if (numType === 'bigint') return { options, default: `${value}n` };
+		assertUnreachable(numType);
+	},
+};
+
+export const Double: SqlType = {
+	// DOUBLE [PRECISION][(1,1)] [UNSIGNED] [ZEROFILL]
+	is: (type) => /^(?:double)(?:[\s(].*)?$/i.test(type) || /^(?:double precision)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'double',
+	defaultFromDrizzle: Real.defaultFromDrizzle,
+	defaultFromIntrospect: Real.defaultFromIntrospect,
+	toTs: Real.toTs,
+};
+
+export const Float: SqlType = {
+	// FLOAT[(1,1)] [UNSIGNED] [ZEROFILL]
+	is: (type) => /^(?:float)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'float',
+	defaultFromDrizzle: Real.defaultFromDrizzle,
+	defaultFromIntrospect: Real.defaultFromIntrospect,
+	toTs: Real.toTs,
+};
+
+export const Char: SqlType = {
+	is: (type) => /^(?:char)(?:[\s(].*)?$/i.test(type) || /^(?:character)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'char',
+	defaultFromDrizzle: (value) => {
+		return `'${escapeForSqlDefault(String(value))}'`;
+	},
+	// 'text''text' -> text'text, we need to make match on introspect
+	defaultFromIntrospect: (value) => {
+		if (value.startsWith('(')) return value;
+
+		const trimmed = trimChar(value, "'");
+		return `'${escapeForSqlDefault(trimmed)}'`;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+		if (value.startsWith('(')) return { options, default: `sql\`${value}\`` };
+
+		const escaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(value, "'")));
+		return { options, default: escaped };
+	},
+};
+
+export const Varchar: SqlType = {
+	is: (type) => {
+		return /^(?:varchar)(?:[\s(].*)?$/i.test(type)
+			|| /^(?:nvarchar)(?:[\s(].*)?$/i.test(type)
+			|| /^(?:character varying)(?:[\s(].*)?$/i.test(type);
+	},
+	drizzleImport: () => 'varchar',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	toTs: Char.toTs,
+};
+
+export const TinyText: SqlType = {
+	is: (type) => /^\s*tinytext\s*$/i.test(type),
+	drizzleImport: () => 'tinytext',
+	defaultFromDrizzle: (value) => {
+		return `('${escapeForSqlDefault(value as string)}')`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+		if (value.startsWith('(') || !value.startsWith("'")) return { options, default: `sql\`${value}\`` };
+
+		const trimmed = trimChar(value, "'");
+		const escaped = value ? escapeForTsLiteral(unescapeFromSqlDefault(trimmed)) : '';
+		return { options, default: escaped };
+	},
+};
+
+export const MediumText: SqlType = {
+	is: (type) => /^\s*mediumtext\s*$/i.test(type),
+	drizzleImport: () => 'mediumtext',
+	defaultFromDrizzle: TinyText.defaultFromDrizzle,
+	defaultFromIntrospect: TinyText.defaultFromIntrospect,
+	toTs: TinyText.toTs,
+};
+
+export const Text: SqlType = {
+	is: (type) => /^\s*text\s*$/i.test(type),
+	drizzleImport: () => 'text',
+	defaultFromDrizzle: TinyText.defaultFromDrizzle,
+	defaultFromIntrospect: TinyText.defaultFromIntrospect,
+	toTs: TinyText.toTs,
+};
+
+export const LongText: SqlType = {
+	is: (type) => /^\s*longtext\s*$/i.test(type),
+	drizzleImport: () => 'longtext',
+	defaultFromDrizzle: TinyText.defaultFromDrizzle,
+	defaultFromIntrospect: TinyText.defaultFromIntrospect,
+	toTs: TinyText.toTs,
+};
+
+export const TinyBlob: SqlType = {
+	is: (type) => /^\s*tinyblob\s*$/i.test(type),
+	drizzleImport: () => 'tinyblob',
+	defaultFromDrizzle: (value) => {
+		if (typeof Buffer !== 'undefined' && typeof Buffer.isBuffer === 'function' && Buffer.isBuffer(value)) {
+			return `(0x${value.toString('hex').toLowerCase()})`;
+		}
+		if (Array.isArray(value) || typeof value === 'object' || typeof value === 'string') {
+			return Text.defaultFromDrizzle(value);
+		}
+		throw new Error('unexpected');
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		if (value === null) return { default: '' };
+
+		if (typeof Buffer !== 'undefined' && value.startsWith('0x')) {
+			const parsed = Buffer.from(value.slice(2, value.length), 'hex').toString('utf-8');
+			const escaped = parsed.replaceAll('\\', '\\\\').replace('"', '\\"');
+			return { options: { mode: 'buffer' }, default: `Buffer.from("${escaped}")` };
+		}
+
+		const { default: stringDef } = Text.toTs(type, value);
+
+		return { default: stringDef, options: { mode: 'string' } };
+	},
+};
+
+export const MediumBlob: SqlType = {
+	is: (type) => /^\s*mediumblob\s*$/i.test(type),
+	drizzleImport: () => 'mediumblob',
+	defaultFromDrizzle: TinyBlob.defaultFromDrizzle,
+	defaultFromIntrospect: TinyBlob.defaultFromIntrospect,
+	toTs: TinyBlob.toTs,
+};
+
+export const LongBlob: SqlType = {
+	is: (type) => /^\s*longblob\s*$/i.test(type),
+	drizzleImport: () => 'longblob',
+	defaultFromDrizzle: TinyBlob.defaultFromDrizzle,
+	defaultFromIntrospect: TinyBlob.defaultFromIntrospect,
+	toTs: TinyBlob.toTs,
+};
+
+export const Blob: SqlType = {
+	is: (type) => /^\s*blob\s*$/i.test(type),
+	drizzleImport: () => 'blob',
+	defaultFromDrizzle: TinyBlob.defaultFromDrizzle,
+	defaultFromIntrospect: TinyBlob.defaultFromIntrospect,
+	toTs: TinyBlob.toTs,
+};
+
+export const Binary: SqlType = {
+	is: (type) => /^(?:binary)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'binary',
+	defaultFromDrizzle: TinyText.defaultFromDrizzle,
+	defaultFromIntrospect: (value) => {
+		// when you do `binary default 'text'` instead of `default ('text')`
+		if (value.startsWith('0x')) {
+			if (typeof Buffer !== 'undefined') {
+				return `'${Buffer.from(value.slice(2), 'hex').toString('utf-8')}'`;
+			}
+			const hex = value.slice(2);
+			const matches = hex.match(/.{1,2}/g) ?? [];
+			const bytes = new Uint8Array(matches.map((b) => parseInt(b, 16)));
+			const decoded = new TextDecoder().decode(bytes);
+			return `'${decoded}'`;
+		}
+		return value;
+	},
+	toTs: TinyText.toTs,
+};
+
+export const Varbinary: SqlType = {
+	is: (type) => /^(?:varbinary)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'varbinary',
+	defaultFromDrizzle: (value) => {
+		if (typeof Buffer !== 'undefined') {
+			return `(0x${Buffer.from(value as string).toString('hex').toLowerCase()})`;
+		}
+		const bytes = new TextEncoder().encode(value as string);
+		const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
+		return `(0x${hex})`;
+	},
+	defaultFromIntrospect: (value) => value,
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+
+		if (!value) return { default: '', options };
+
+		let trimmed = value.startsWith('(') ? value.substring(1, value.length - 1) : value;
+		trimmed = trimChar(value, "'");
+		if (trimmed.startsWith('0x')) {
+			if (typeof Buffer !== 'undefined') {
+				trimmed = Buffer.from(trimmed.slice(2), 'hex').toString('utf-8');
+			} else {
+				const hex = trimmed.slice(2);
+				const matches = hex.match(/.{1,2}/g) ?? [];
+				const bytes = new Uint8Array(matches.map((b) => parseInt(b, 16)));
+				trimmed = new TextDecoder().decode(bytes);
+			}
+			return { options, default: `"${trimmed.replaceAll('"', '\\"')}"` };
+		} else {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Json: SqlType = {
+	is: (type) => /^\s*json\s*$/i.test(type),
+	drizzleImport: () => 'json',
+	defaultFromDrizzle: (value) => {
+		const stringified = stringify(value, (key, value) => {
+			if (typeof value !== 'string') return value;
+			return value.replaceAll("'", "''");
+		});
+		return `('${stringified}')`;
+	},
+	defaultFromIntrospect: (value) => value,
+	toTs: (_, def) => {
+		if (!def) return { default: '' };
+		const trimmed = trimChar(def, "'");
+		try {
+			const parsed = parse(trimmed);
+			const stringified = stringify(
+				parsed,
+				(_, value) => {
+					if (typeof value !== 'string') return value;
+					return value.replaceAll("''", "'");
+				},
+				undefined,
+				true,
+			)!;
+			return { default: stringified };
+		} catch {}
+		return { default: `sql\`${def}\`` };
+	},
+};
+
+export const Timestamp: SqlType = {
+	is: (type) => /^(?:timestamp)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'timestamp',
+	defaultFromDrizzle: (value) => {
+		if (value instanceof Date) {
+			const converted = value.toISOString().replace('T', ' ').slice(0, 23);
+			return `'${converted}'`;
+		}
+		// TODO: we can handle fsp 6 here too
+		return `'${value}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		if (!isNaN(Date.parse(value))) {
+			return `'${value}'`;
+		}
+		return value;
+	},
+	toTs: (type, def) => {
+		const options: any = {};
+		const [fsp] = parseParams(type);
+		if (fsp) options['fsp'] = Number(fsp);
+
+		if (!def) return { options, default: '' };
+		const trimmed = trimChar(def, "'");
+		if (
+			trimmed === 'now()' || trimmed === '(now())' || trimmed === '(CURRENT_TIMESTAMP)'
+			|| trimmed === 'CURRENT_TIMESTAMP'
+		) {
+			return { options, default: '.defaultNow()' };
+		}
+
+		if (trimmed.includes('now(') || trimmed.includes('CURRENT_TIMESTAMP(')) {
+			return { options, default: `sql\`${trimmed}\`` };
+		}
+
+		if (fsp && Number(fsp) > 3) return { options, default: `sql\`'${trimmed}'\`` };
+		// TODO: we can handle fsp 6 here too, using sql``
+		return { options, default: `new Date("${trimmed}Z")` };
+	},
+};
+
+export const DateTime: SqlType = {
+	is: (type) => /^(?:datetime)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'datetime',
+	defaultFromDrizzle: Timestamp.defaultFromDrizzle,
+	defaultFromIntrospect: Timestamp.defaultFromIntrospect,
+	toTs: (type, def) => {
+		const options: any = {};
+		const [fsp] = parseParams(type);
+		if (fsp) options['fsp'] = Number(fsp);
+
+		if (!def) return { options, default: '' };
+		const trimmed = trimChar(def, "'");
+
+		if (trimmed.includes('now') || trimmed.includes('CURRENT_TIMESTAMP')) {
+			return { options, default: `sql\`${trimmed}\`` };
+		}
+
+		if (fsp && Number(fsp) > 3) return { options, default: `sql\`'${trimmed}'\`` };
+		// TODO: we can handle fsp 6 here too, using sql``
+		return { options, default: `new Date("${trimmed}Z")` };
+	},
+};
+
+export const Time: SqlType = {
+	is: (type) => /^(?:time)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: (value) => {
+		return `'${String(value)}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		if (!value.startsWith("'")) return `'${value}'`;
+		return value;
+	},
+	toTs: (type, def) => {
+		const options: any = {};
+		const [fsp] = parseParams(type);
+		if (fsp) options['fsp'] = Number(fsp);
+
+		if (!def) return { options, default: '' };
+
+		const trimmed = trimChar(def, "'");
+		return { options, default: `"${trimmed}"` };
+	},
+};
+
+export const Date_: SqlType = {
+	is: (type) => /^\s*date\s*$/i.test(type),
+	drizzleImport: () => 'date',
+	defaultFromDrizzle: (value) => {
+		if (value instanceof Date) {
+			const converted = value.toISOString().split('T')[0];
+			return `'${converted}'`;
+		}
+		return `'${value}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		if (!value.startsWith("'")) return `'${value}'`;
+		return value;
+	},
+	toTs: (type, def) => {
+		const options: any = {};
+		const [fsp] = parseParams(type);
+		if (fsp) options['fsp'] = Number(fsp);
+		if (!def) return { options, default: '' };
+		return { options, default: `new Date("${trimChar(def, "'")}")` };
+	},
+};
+
+export const Year: SqlType = {
+	is: (type) => /^\s*year\s*$/i.test(type),
+	drizzleImport: () => 'year',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, def) => {
+		const options: any = {};
+		const [fsp] = parseParams(type);
+		if (fsp) options['fsp'] = Number(fsp);
+
+		if (!def) return { options, default: '' };
+		return { options, default: `${def}` };
+	},
+};
+
+export const Enum: SqlType = {
+	is: (type) => /^(?:enum)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: (vendor) => vendor === 'mysql' ? 'mysqlEnum' : 'singlestoreEnum',
+	defaultFromDrizzle: (value) => {
+		return `'${escapeForSqlDefault(value as string)}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return `'${escapeForSqlDefault(value)}'`;
+	},
+	toTs: (_, def) => {
+		if (!def) return { default: '' };
+		const unescaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(def, "'")));
+		return { default: unescaped };
+	},
+};
+
+export const Custom: SqlType = {
+	is: () => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'customType',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, def) => {
+		if (!def) return { default: '', customType: type };
+		const unescaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(def, "'")));
+		return { default: unescaped, customType: type };
+	},
+};
+
+export const typeFor = (sqlType: string): SqlType => {
+	if (Boolean.is(sqlType)) return Boolean;
+	if (TinyInt.is(sqlType)) return TinyInt;
+	if (SmallInt.is(sqlType)) return SmallInt;
+	if (MediumInt.is(sqlType)) return MediumInt;
+	if (Int.is(sqlType)) return Int;
+	if (BigInt.is(sqlType)) return BigInt;
+	if (Serial.is(sqlType)) return Serial;
+	if (Decimal.is(sqlType)) return Decimal;
+	if (Real.is(sqlType)) return Real;
+	if (Double.is(sqlType)) return Double;
+	if (Float.is(sqlType)) return Float;
+	if (Char.is(sqlType)) return Char;
+	if (Varchar.is(sqlType)) return Varchar;
+	if (TinyText.is(sqlType)) return TinyText;
+	if (MediumText.is(sqlType)) return MediumText;
+	if (Text.is(sqlType)) return Text;
+	if (LongText.is(sqlType)) return LongText;
+	if (Binary.is(sqlType)) return Binary;
+	if (Varbinary.is(sqlType)) return Varbinary;
+	if (Json.is(sqlType)) return Json;
+	if (Timestamp.is(sqlType)) return Timestamp;
+	if (DateTime.is(sqlType)) return DateTime;
+	if (Date_.is(sqlType)) return Date_;
+	if (Time.is(sqlType)) return Time;
+	if (Year.is(sqlType)) return Year;
+	if (Enum.is(sqlType)) return Enum;
+	if (TinyBlob.is(sqlType)) return TinyBlob;
+	if (MediumBlob.is(sqlType)) return MediumBlob;
+	if (LongBlob.is(sqlType)) return LongBlob;
+	if (Blob.is(sqlType)) return Blob;
+	return Custom;
+};
+
+type InvalidDefault = 'text_no_parentecies';
+export const checkDefault = (value: string, type: string): InvalidDefault | null => {
+	if (
+		(type === 'tinytext' || type === 'mediumtext' || type === 'text' || type === 'longtext'
+			|| type === 'binary' || type === 'varbinary'
+			|| type === 'json') && !value.startsWith('(') && !value.endsWith(')')
+	) {
+		return 'text_no_parentecies';
+	}
+
+	if (type === 'binary' || type === 'varbinary') {
+	}
+
+	return null;
+};
+
+export const defaultNameForFK = (fk: Pick<ForeignKey, 'table' | 'columns' | 'tableTo' | 'columnsTo'>) => {
+	const desired = `${fk.table}_${fk.columns.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fkey`;
+	const res = desired.length > 63
+		? fk.table.length < 63 - 18 // _{hash(12)}_fkey
+			? `${fk.table}_${hash(desired)}_fkey`
+			: `${hash(desired)}_fkey` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const nameForUnique = (tableName: string, columns: string[]) => {
+	return `${columns.join('_')}_unique`;
+};
+
+const stripCollation = (defaultValue: string): string => {
+	const coll = 'utf8mb4';
+	const escaped = coll.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+	const regex = new RegExp(`_${escaped}(?=(?:\\\\['"]|['"]))`, 'g');
+	const res = defaultValue.replace(regex, '').replaceAll("\\'", "'").replaceAll("\\\\'", "''");
+	return res;
+};
+
+export const parseEnum = (it: string) => {
+	return Array.from(it.matchAll(/'((?:[^']|'')*)'/g), (m) => m[1]);
+};
+
+export const parseDefaultValue = (
+	columnType: string,
+	value: string | undefined,
+): Column['default'] => {
+	if (value === null || typeof value === 'undefined') return null;
+
+	value = stripCollation(value);
+
+	const grammarType = typeFor(columnType);
+	if (grammarType) return grammarType.defaultFromIntrospect(value);
+
+	console.error(`unknown default: ${columnType} ${value}`);
+	return null;
+};
+
+const commutativeTypes = [
+	['tinyint(1)', 'boolean'],
+	['binary(1)', 'binary'],
+	['char(1)', 'char'],
+];
+export const commutative = (left: string, right: string, mode: 'push' | 'default' = 'default') => {
+	for (const it of commutativeTypes) {
+		const leftIn = it.some((x) => x === left);
+		const rightIn = it.some((x) => x === right);
+
+		if (leftIn && rightIn) return true;
+	}
+
+	// commutativity for:
+	// - now(4) and CURRENT_TIMESTAMP(4)
+	// - (now()) and (CURRENT_TIMESTAMP
+	// ...etc
+	const timeDefaultValueRegex = /^\(?(?:now|CURRENT_TIMESTAMP)(?:\((\d*)\))?\)?$/;
+	const leftMatch = left.match(timeDefaultValueRegex);
+	const rightMatch = right.match(timeDefaultValueRegex);
+	if (leftMatch && rightMatch) {
+		const leftValue = leftMatch[1] ?? ''; // undefined becomes '' for comparison
+		const rightValue = rightMatch[1] ?? '';
+		if (leftValue === rightValue) return true;
+	}
+
+	const leftPatched = left.replace(', ', ',');
+	const rightPatched = right.replace(', ', ',');
+	if (leftPatched === rightPatched) return true;
+
+	if (mode === 'push') {
+		if (left === 'double' && right === 'real') return true;
+		if (left.startsWith('double(') && right.startsWith('real(') && right.replace('real', 'double') === left) {
+			return true;
+		}
+		if (left.startsWith('real(') && right.startsWith('double(') && right.replace('double', 'real') === left) {
+			return true;
+		}
+		if (left.replace(',0)', ')') === right.replace(',0)', ')')) return true; // { from: 'decimal(19,0)', to: 'decimal(19)' }
+	}
+
+	if (
+		(left.startsWith('float(') && right === 'float')
+		|| (right.startsWith('float(') && left === 'float')
+	) {
+		return true; // column type is float regardless of float(M,D), always stored as 7 digits precision
+	}
+	return false;
+};
+
+const commutativeCharSetAndCollation: { charSet: string; collation: string; isDefault: boolean }[] = [
+	{ collation: 'armscii8_bin', charSet: 'armscii8', isDefault: false },
+	{ collation: 'armscii8_general_ci', charSet: 'armscii8', isDefault: true },
+	{ collation: 'ascii_bin', charSet: 'ascii', isDefault: false },
+	{ collation: 'ascii_general_ci', charSet: 'ascii', isDefault: true },
+	{ collation: 'big5_bin', charSet: 'big5', isDefault: false },
+	{ collation: 'big5_chinese_ci', charSet: 'big5', isDefault: true },
+	{ collation: 'binary', charSet: 'binary', isDefault: true },
+	{ collation: 'cp1250_bin', charSet: 'cp1250', isDefault: false },
+	{ collation: 'cp1250_croatian_ci', charSet: 'cp1250', isDefault: false },
+	{ collation: 'cp1250_czech_cs', charSet: 'cp1250', isDefault: false },
+	{ collation: 'cp1250_general_ci', charSet: 'cp1250', isDefault: true },
+	{ collation: 'cp1250_polish_ci', charSet: 'cp1250', isDefault: false },
+	{ collation: 'cp1251_bin', charSet: 'cp1251', isDefault: false },
+	{ collation: 'cp1251_bulgarian_ci', charSet: 'cp1251', isDefault: false },
+	{ collation: 'cp1251_general_ci', charSet: 'cp1251', isDefault: true },
+	{ collation: 'cp1251_general_cs', charSet: 'cp1251', isDefault: false },
+	{ collation: 'cp1251_ukrainian_ci', charSet: 'cp1251', isDefault: false },
+	{ collation: 'cp1256_bin', charSet: 'cp1256', isDefault: false },
+	{ collation: 'cp1256_general_ci', charSet: 'cp1256', isDefault: true },
+	{ collation: 'cp1257_bin', charSet: 'cp1257', isDefault: false },
+	{ collation: 'cp1257_general_ci', charSet: 'cp1257', isDefault: true },
+	{ collation: 'cp1257_lithuanian_ci', charSet: 'cp1257', isDefault: false },
+	{ collation: 'cp850_bin', charSet: 'cp850', isDefault: false },
+	{ collation: 'cp850_general_ci', charSet: 'cp850', isDefault: true },
+	{ collation: 'cp852_bin', charSet: 'cp852', isDefault: false },
+	{ collation: 'cp852_general_ci', charSet: 'cp852', isDefault: true },
+	{ collation: 'cp866_bin', charSet: 'cp866', isDefault: false },
+	{ collation: 'cp866_general_ci', charSet: 'cp866', isDefault: true },
+	{ collation: 'cp932_bin', charSet: 'cp932', isDefault: false },
+	{ collation: 'cp932_japanese_ci', charSet: 'cp932', isDefault: true },
+	{ collation: 'dec8_bin', charSet: 'dec8', isDefault: false },
+	{ collation: 'dec8_swedish_ci', charSet: 'dec8', isDefault: true },
+	{ collation: 'eucjpms_bin', charSet: 'eucjpms', isDefault: false },
+	{ collation: 'eucjpms_japanese_ci', charSet: 'eucjpms', isDefault: true },
+	{ collation: 'euckr_bin', charSet: 'euckr', isDefault: false },
+	{ collation: 'euckr_korean_ci', charSet: 'euckr', isDefault: true },
+	{ collation: 'gb18030_bin', charSet: 'gb18030', isDefault: false },
+	{ collation: 'gb18030_chinese_ci', charSet: 'gb18030', isDefault: true },
+	{ collation: 'gb18030_unicode_520_ci', charSet: 'gb18030', isDefault: false },
+	{ collation: 'gb2312_bin', charSet: 'gb2312', isDefault: false },
+	{ collation: 'gb2312_chinese_ci', charSet: 'gb2312', isDefault: true },
+	{ collation: 'gbk_bin', charSet: 'gbk', isDefault: false },
+	{ collation: 'gbk_chinese_ci', charSet: 'gbk', isDefault: true },
+	{ collation: 'geostd8_bin', charSet: 'geostd8', isDefault: false },
+	{ collation: 'geostd8_general_ci', charSet: 'geostd8', isDefault: true },
+	{ collation: 'greek_bin', charSet: 'greek', isDefault: false },
+	{ collation: 'greek_general_ci', charSet: 'greek', isDefault: true },
+	{ collation: 'hebrew_bin', charSet: 'hebrew', isDefault: false },
+	{ collation: 'hebrew_general_ci', charSet: 'hebrew', isDefault: true },
+	{ collation: 'hp8_bin', charSet: 'hp8', isDefault: false },
+	{ collation: 'hp8_english_ci', charSet: 'hp8', isDefault: true },
+	{ collation: 'keybcs2_bin', charSet: 'keybcs2', isDefault: false },
+	{ collation: 'keybcs2_general_ci', charSet: 'keybcs2', isDefault: true },
+	{ collation: 'koi8r_bin', charSet: 'koi8r', isDefault: false },
+	{ collation: 'koi8r_general_ci', charSet: 'koi8r', isDefault: true },
+	{ collation: 'koi8u_bin', charSet: 'koi8u', isDefault: false },
+	{ collation: 'koi8u_general_ci', charSet: 'koi8u', isDefault: true },
+	{ collation: 'latin1_bin', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_danish_ci', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_general_ci', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_general_cs', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_german1_ci', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_german2_ci', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_spanish_ci', charSet: 'latin1', isDefault: false },
+	{ collation: 'latin1_swedish_ci', charSet: 'latin1', isDefault: true },
+	{ collation: 'latin2_bin', charSet: 'latin2', isDefault: false },
+	{ collation: 'latin2_croatian_ci', charSet: 'latin2', isDefault: false },
+	{ collation: 'latin2_czech_cs', charSet: 'latin2', isDefault: false },
+	{ collation: 'latin2_general_ci', charSet: 'latin2', isDefault: true },
+	{ collation: 'latin2_hungarian_ci', charSet: 'latin2', isDefault: false },
+	{ collation: 'latin5_bin', charSet: 'latin5', isDefault: false },
+	{ collation: 'latin5_turkish_ci', charSet: 'latin5', isDefault: true },
+	{ collation: 'latin7_bin', charSet: 'latin7', isDefault: false },
+	{ collation: 'latin7_estonian_cs', charSet: 'latin7', isDefault: false },
+	{ collation: 'latin7_general_ci', charSet: 'latin7', isDefault: true },
+	{ collation: 'latin7_general_cs', charSet: 'latin7', isDefault: false },
+	{ collation: 'macce_bin', charSet: 'macce', isDefault: false },
+	{ collation: 'macce_general_ci', charSet: 'macce', isDefault: true },
+	{ collation: 'macroman_bin', charSet: 'macroman', isDefault: false },
+	{ collation: 'macroman_general_ci', charSet: 'macroman', isDefault: true },
+	{ collation: 'sjis_bin', charSet: 'sjis', isDefault: false },
+	{ collation: 'sjis_japanese_ci', charSet: 'sjis', isDefault: true },
+	{ collation: 'swe7_bin', charSet: 'swe7', isDefault: false },
+	{ collation: 'swe7_swedish_ci', charSet: 'swe7', isDefault: true },
+	{ collation: 'tis620_bin', charSet: 'tis620', isDefault: false },
+	{ collation: 'tis620_thai_ci', charSet: 'tis620', isDefault: true },
+	{ collation: 'ucs2_bin', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_croatian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_czech_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_danish_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_esperanto_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_estonian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_general_ci', charSet: 'ucs2', isDefault: true },
+	{ collation: 'ucs2_general_mysql500_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_german2_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_hungarian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_icelandic_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_latvian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_lithuanian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_persian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_polish_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_romanian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_roman_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_sinhala_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_slovak_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_slovenian_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_spanish2_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_spanish_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_swedish_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_turkish_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_unicode_520_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_unicode_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ucs2_vietnamese_ci', charSet: 'ucs2', isDefault: false },
+	{ collation: 'ujis_bin', charSet: 'ujis', isDefault: false },
+	{ collation: 'ujis_japanese_ci', charSet: 'ujis', isDefault: true },
+	{ collation: 'utf16_bin', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_croatian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_czech_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_danish_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_esperanto_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_estonian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_general_ci', charSet: 'utf16', isDefault: true },
+	{ collation: 'utf16_german2_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_hungarian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_icelandic_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_latvian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_lithuanian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_persian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_polish_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_romanian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_roman_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_sinhala_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_slovak_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_slovenian_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_spanish2_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_spanish_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_swedish_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_turkish_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_unicode_520_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_unicode_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16_vietnamese_ci', charSet: 'utf16', isDefault: false },
+	{ collation: 'utf16le_bin', charSet: 'utf16le', isDefault: false },
+	{ collation: 'utf16le_general_ci', charSet: 'utf16le', isDefault: true },
+	{ collation: 'utf32_bin', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_croatian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_czech_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_danish_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_esperanto_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_estonian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_general_ci', charSet: 'utf32', isDefault: true },
+	{ collation: 'utf32_german2_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_hungarian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_icelandic_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_latvian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_lithuanian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_persian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_polish_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_romanian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_roman_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_sinhala_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_slovak_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_slovenian_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_spanish2_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_spanish_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_swedish_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_turkish_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_unicode_520_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_unicode_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf32_vietnamese_ci', charSet: 'utf32', isDefault: false },
+	{ collation: 'utf8mb3_bin', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_croatian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_czech_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_danish_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_esperanto_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_estonian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_general_ci', charSet: 'utf8mb3', isDefault: true },
+	{ collation: 'utf8mb3_general_mysql500_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_german2_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_hungarian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_icelandic_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_latvian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_lithuanian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_persian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_polish_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_romanian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_roman_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_sinhala_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_slovak_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_slovenian_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_spanish2_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_spanish_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_swedish_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_tolower_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_turkish_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_unicode_520_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_unicode_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb3_vietnamese_ci', charSet: 'utf8mb3', isDefault: false },
+	{ collation: 'utf8mb4_0900_ai_ci', charSet: 'utf8mb4', isDefault: true },
+	{ collation: 'utf8mb4_0900_as_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_0900_bin', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_bg_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_bg_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_bin', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_bs_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_bs_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_croatian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_cs_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_cs_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_czech_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_danish_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_da_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_da_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_de_pb_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_de_pb_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_eo_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_eo_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_esperanto_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_estonian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_es_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_es_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_es_trad_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_es_trad_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_et_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_et_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_general_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_german2_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_gl_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_gl_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_hr_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_hr_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_hungarian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_hu_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_hu_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_icelandic_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_is_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_is_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ja_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ja_0900_as_cs_ks', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_latvian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_la_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_la_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_lithuanian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_lt_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_lt_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_lv_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_lv_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_mn_cyrl_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_mn_cyrl_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_nb_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_nb_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_nn_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_nn_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_persian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_pl_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_pl_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_polish_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_romanian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_roman_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ro_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ro_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ru_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_ru_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sinhala_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sk_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sk_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_slovak_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_slovenian_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sl_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sl_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_spanish2_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_spanish_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sr_latn_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sr_latn_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sv_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_sv_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_swedish_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_tr_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_tr_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_turkish_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_unicode_520_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_unicode_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_vietnamese_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_vi_0900_ai_ci', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_vi_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+	{ collation: 'utf8mb4_zh_0900_as_cs', charSet: 'utf8mb4', isDefault: false },
+];
+export const charSetAndCollationCommutative = (
+	left: { charSet: string | null; collation: string | null },
+	right: { collation: string | null; charSet: string | null },
+): boolean => {
+	if (!left.charSet && !left.collation && !right.charSet && !right.collation) return true;
+
+	const normalize = (input: { charSet: string | null; collation: string | null }) => {
+		let { charSet, collation } = input;
+
+		if (!charSet && collation) {
+			const match = commutativeCharSetAndCollation.find((x) => x.collation === collation);
+			if (!match) return null;
+			charSet = match.charSet;
+		}
+
+		if (charSet && !collation) {
+			const match = commutativeCharSetAndCollation.find((x) => x.charSet === charSet && x.isDefault);
+			if (!match) return null;
+			collation = match.collation;
+		}
+
+		if (charSet && collation) {
+			const match = commutativeCharSetAndCollation.find((x) => x.charSet === charSet && x.collation === collation);
+			if (!match) return null; // invalid combination
+		}
+
+		return { charSet, collation };
+	};
+
+	const leftNorm = normalize(left);
+	const rightNorm = normalize(right);
+
+	if (!leftNorm || !rightNorm) return false;
+
+	return leftNorm.charSet === rightNorm.charSet && leftNorm.collation === rightNorm.collation;
+};
diff --git a/drizzle-kit/src/dialects/mysql/introspect.ts b/drizzle-kit/src/dialects/mysql/introspect.ts
new file mode 100644
index 0000000000..9e61c8a5a5
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/introspect.ts
@@ -0,0 +1,566 @@
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import type { DB } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import { batchQuery, filterMigrationsSchema } from '../utils';
+import type { ForeignKey, Index, InterimSchema, PrimaryKey } from './ddl';
+import { parseDefaultValue } from './grammar';
+
+// ! Important note about column names in SELECT queries:
+// * For consistency with MariaDB, we need to use uppercase for column names in SELECT queries,
+// * because MySQL returns them in uppercase, and MariaDB in the same case as defined (usually lowercase).
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	schema: string,
+	filter: EntityFilter = () => true,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+): Promise<InterimSchema> => {
+	const res = await fromDatabase(db, schema, filter, progressCallback);
+	res.indexes = res.indexes.filter((x) => {
+		let skip = x.isUnique === true && x.columns.length === 1 && x.columns[0].isExpression === false;
+		skip &&= res.columns.some((c) => c.type === 'serial' && c.table === x.table && c.name === x.columns[0].value);
+		skip ||= res.fks.some((fk) => x.table === fk.table && x.name === fk.name);
+		return !skip;
+	});
+
+	filterMigrationsSchema(res, migrations);
+
+	return res;
+};
+
+export const fromDatabase = async (
+	db: DB,
+	schema: string,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+): Promise<InterimSchema> => {
+	const res: InterimSchema = {
+		tables: [],
+		columns: [],
+		pks: [],
+		fks: [],
+		checks: [],
+		indexes: [],
+		views: [],
+		viewColumns: [],
+	};
+
+	// TABLES
+
+	// TODO revise: perfomance_schema contains 'users' table
+	progressCallback('tables', 0, 'fetching');
+	const tablesAndViews = await batchQuery<
+		{ TABLE_NAME: string; TABLE_TYPE: 'BASE TABLE' | 'VIEW'; CREATE_TIME: string }
+	>(
+		db,
+		({ limit, cursor }) => `
+			SELECT
+				TABLE_NAME, 
+				TABLE_TYPE,
+				CREATE_TIME
+			FROM INFORMATION_SCHEMA.TABLES
+			WHERE TABLE_SCHEMA = '${schema}'
+				AND CREATE_TIME IS NOT NULL
+				${
+			cursor
+				? `AND (CREATE_TIME > '${cursor.CREATE_TIME}' OR (CREATE_TIME = '${cursor.CREATE_TIME}' AND lower(TABLE_NAME) > '${cursor.TABLE_NAME}'))`
+				: ''
+		}
+			ORDER BY CREATE_TIME, lower(TABLE_NAME)
+			LIMIT ${limit}
+		`,
+		(count) => {
+			progressCallback('tables', count, 'fetching');
+		},
+	).then((rows) => {
+		queryCallback('tables', rows, null);
+		return rows.filter((it) => {
+			return filter({ type: 'table', schema: false, name: it.TABLE_NAME });
+		});
+	}).catch((err) => {
+		queryCallback('tables', [], err);
+		throw err;
+	});
+
+	const tableNames = new Set(
+		tablesAndViews
+			.filter((it) => it.TABLE_TYPE === 'BASE TABLE')
+			.map((it) => it.TABLE_NAME),
+	);
+	for (const table of tableNames) {
+		res.tables.push({
+			entityType: 'tables',
+			name: table,
+		});
+	}
+	progressCallback('tables', res.tables.length, 'done');
+
+	// INDEXES
+
+	progressCallback('indexes', 0, 'fetching');
+	const idxs = await db.query<{
+		TABLE_NAME: string;
+		INDEX_NAME: string;
+		COLUMN_NAME: string;
+		NON_UNIQUE: number;
+		EXPRESSION: string | null | undefined; // MariaDB doesn't have this column, so we use * in query and handle it in code
+	}>(`
+		SELECT
+			*
+		FROM INFORMATION_SCHEMA.STATISTICS
+		WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${schema}' 
+			AND INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY'
+		ORDER BY SEQ_IN_INDEX ASC;
+	`).then((rows) => {
+		const filtered = rows.filter((it) => tableNames.has(it.TABLE_NAME));
+		queryCallback('indexes', filtered, null);
+		return filtered;
+	}).catch((err) => {
+		queryCallback('indexes', [], err);
+		throw err;
+	});
+
+	const groupedIndexes = idxs.reduce<Record<string, Index>>((acc, it) => {
+		const name = it.INDEX_NAME;
+		const table = it.TABLE_NAME;
+		const column = it.COLUMN_NAME;
+		const isUnique = it.NON_UNIQUE === 0;
+		const expression = it.EXPRESSION;
+
+		const key = `${table}:${name}`;
+
+		if (key in acc) {
+			const entry = acc[key];
+			entry.columns.push({
+				value: expression ? expression : column,
+				isExpression: !!expression,
+			});
+		} else {
+			acc[key] = {
+				entityType: 'indexes',
+				table,
+				name,
+				columns: [{
+					value: expression ? expression : column,
+					isExpression: !!expression,
+				}],
+				isUnique,
+				algorithm: null,
+				lock: null,
+				using: null,
+				nameExplicit: true,
+			} satisfies Index;
+		}
+		return acc;
+	}, {} as Record<string, Index>);
+
+	for (const index of Object.values(groupedIndexes)) {
+		res.indexes.push(index);
+	}
+	progressCallback('indexes', res.indexes.length, 'done');
+
+	// COLUMNS
+
+	const tableNamesSQL = tablesAndViews.map((t) => `'${t.TABLE_NAME}'`).join(',');
+	progressCallback('columns', 0, 'fetching');
+	const columns = tableNamesSQL
+		? await batchQuery<{
+			TABLE_NAME: string;
+			COLUMN_NAME: string;
+			IS_NULLABLE: string;
+			COLUMN_TYPE: string;
+			DATA_TYPE: string;
+			COLUMN_DEFAULT: string | null;
+			COLLATION_NAME: string;
+			CHARACTER_SET_NAME: string;
+			GENERATION_EXPRESSION: string;
+			EXTRA: string;
+			ORDINAL_POSITION: number;
+		}>(
+			db,
+			({ limit, cursor }) => `
+			SELECT
+				TABLE_NAME,
+				COLUMN_NAME,
+				IS_NULLABLE,
+				COLUMN_TYPE,
+				DATA_TYPE,
+				COLUMN_DEFAULT,
+				COLLATION_NAME,
+				CHARACTER_SET_NAME,
+				GENERATION_EXPRESSION,
+				EXTRA,
+				ORDINAL_POSITION
+			FROM INFORMATION_SCHEMA.COLUMNS
+			WHERE TABLE_SCHEMA = '${schema}'
+				AND TABLE_NAME IN (${tableNamesSQL})
+				${
+				cursor
+					? `AND (TABLE_NAME > '${cursor.TABLE_NAME}' OR (TABLE_NAME = '${cursor.TABLE_NAME}' AND ORDINAL_POSITION > ${cursor.ORDINAL_POSITION}))`
+					: ''
+			}
+			ORDER BY TABLE_NAME, ORDINAL_POSITION
+			LIMIT ${limit}
+		`,
+			(count) => {
+				progressCallback('columns', count, 'fetching');
+			},
+		).then((rows) => {
+			queryCallback('columns', rows, null);
+			return rows;
+		}).catch((err) => {
+			queryCallback('columns', [], err);
+			throw err;
+		})
+		: [];
+
+	const defaultCharSetAndCollation = await db.query<
+		{ DEFAULT_CHARACTER_SET_NAME: string; DEFAULT_COLLATION_NAME: string }
+	>(`
+		SELECT
+			DEFAULT_CHARACTER_SET_NAME,
+			DEFAULT_COLLATION_NAME
+		FROM INFORMATION_SCHEMA.SCHEMATA
+		WHERE SCHEMA_NAME = '${schema}';
+		`);
+
+	for (const column of columns) {
+		if (!tableNames.has(column.TABLE_NAME)) continue;
+
+		const table = column.TABLE_NAME;
+		const name: string = column.COLUMN_NAME;
+		const isNullable = column.IS_NULLABLE === 'YES'; // 'YES', 'NO'
+		const columnType = column.COLUMN_TYPE; // varchar(256)
+		const columnDefault: string | undefined = column.COLUMN_DEFAULT ?? undefined;
+		const dbCollation: string = column.COLLATION_NAME;
+		const dbCharSet: string = column.CHARACTER_SET_NAME;
+		const geenratedExpression: string = column.GENERATION_EXPRESSION;
+
+		const extra = column.EXTRA ?? '';
+		// const isDefaultAnExpression = extra.includes('DEFAULT_GENERATED'); // 'auto_increment', ''
+		// const dataType = column.DATA_TYPE; // varchar
+		// const isPrimary = column.COLUMN_KEY === 'PRI'; // 'PRI', ''
+		// const numericPrecision = column.NUMERIC_PRECISION;
+		// const numericScale = column.NUMERIC_SCALE;
+		const isAutoincrement = extra === 'auto_increment';
+		const onUpdateNow: boolean = extra.includes('on update CURRENT_TIMESTAMP');
+
+		const onUpdateNowFspMatch = typeof extra === 'string'
+			? extra.match(/\bON\s+UPDATE\s+CURRENT_TIMESTAMP(?:\((\d+)\))?/i)
+			: null;
+		const onUpdateNowFsp = onUpdateNow && onUpdateNowFspMatch && onUpdateNowFspMatch[1]
+			? Number(onUpdateNowFspMatch[1])
+			: null;
+
+		let changedType = columnType.replace('decimal(10,0)', 'decimal');
+
+		if (columnType === 'bigint unsigned' && !isNullable && isAutoincrement) {
+			const uniqueIdx = idxs.filter(
+				(it) =>
+					it.COLUMN_NAME === name
+					&& it.TABLE_NAME === table
+					&& it.NON_UNIQUE === 0,
+			);
+			if (uniqueIdx && uniqueIdx.length === 1) {
+				changedType = columnType.replace('bigint unsigned', 'serial');
+			}
+		}
+
+		const def = parseDefaultValue(changedType, columnDefault);
+
+		const { DEFAULT_CHARACTER_SET_NAME: defDbCharSet, DEFAULT_COLLATION_NAME: defDbCollation } =
+			defaultCharSetAndCollation[0];
+		let charSet: string | null = dbCharSet;
+		let collation: string | null = dbCollation;
+		if (defDbCharSet === dbCharSet && defDbCollation === dbCollation) {
+			charSet = null;
+			collation = null;
+		}
+
+		res.columns.push({
+			entityType: 'columns',
+			table: table,
+			name: name,
+			type: changedType,
+			notNull: !isNullable,
+			autoIncrement: isAutoincrement,
+			collation: collation,
+			charSet: charSet,
+			onUpdateNow,
+			onUpdateNowFsp,
+			default: def,
+			generated: geenratedExpression
+				? {
+					as: geenratedExpression,
+					type: extra === 'VIRTUAL GENERATED' ? 'virtual' : 'stored',
+				}
+				: null,
+			isUnique: false,
+			// If to create "unique + not null" column, mysql shows it as "PRI"
+			// need to check by constraints only
+			isPK: false,
+			uniqueName: null,
+		});
+	}
+	progressCallback('columns', res.columns.length, 'done');
+
+	// PRIMARY KEYS
+
+	// progressCallback('pks', 0, 'fetching');
+	const pks = await db.query<{
+		CONSTRAINT_NAME: string;
+		TABLE_NAME: string;
+		COLUMN_NAME: string;
+		ORDINAL_POSITION: number;
+	}>(`
+		SELECT
+			CONSTRAINT_NAME,
+			TABLE_NAME,
+			COLUMN_NAME,
+			ORDINAL_POSITION
+		FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS t
+		LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE k USING(CONSTRAINT_NAME, TABLE_SCHEMA, TABLE_NAME)
+		WHERE t.CONSTRAINT_TYPE='PRIMARY KEY'
+			AND t.TABLE_SCHEMA = '${schema}'
+		ORDER BY ORDINAL_POSITION
+	`).then((rows) => {
+		queryCallback('pks', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('pks', [], err);
+		throw err;
+	});
+
+	const tableToPKs = pks.filter((it) => tableNames.has(it.TABLE_NAME)).reduce<Record<string, PrimaryKey>>(
+		(acc, it) => {
+			const table: string = it.TABLE_NAME;
+			const column: string = it.COLUMN_NAME;
+			// const position: string = it.ORDINAL_POSITION;
+
+			if (table in acc) {
+				acc[table].columns.push(column);
+			} else {
+				acc[table] = {
+					entityType: 'pks',
+					table,
+					name: it.CONSTRAINT_NAME,
+					columns: [column],
+				};
+			}
+			return acc;
+		},
+		{} as Record<string, PrimaryKey>,
+	);
+
+	for (const pk of Object.values(tableToPKs)) {
+		res.pks.push(pk);
+	}
+	// progressCallback('pks', res.pks.length, 'done');
+
+	// FOREIGN KEYS
+
+	progressCallback('fks', 0, 'fetching');
+	const fks = await db.query<{
+		TABLE_SCHEMA: string;
+		TABLE_NAME: string;
+		CONSTRAINT_NAME: string;
+		COLUMN_NAME: string;
+		REFERENCED_TABLE_SCHEMA: string;
+		REFERENCED_TABLE_NAME: string;
+		REFERENCED_COLUMN_NAME: string;
+		UPDATE_RULE: string;
+		DELETE_RULE: string;
+	}>(`
+		SELECT
+			kcu.TABLE_SCHEMA,
+			kcu.TABLE_NAME,
+			kcu.CONSTRAINT_NAME,
+			kcu.COLUMN_NAME,
+			kcu.REFERENCED_TABLE_SCHEMA,
+			kcu.REFERENCED_TABLE_NAME,
+			kcu.REFERENCED_COLUMN_NAME,
+			rc.UPDATE_RULE,
+			rc.DELETE_RULE
+		FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+		LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+		WHERE kcu.TABLE_SCHEMA = '${schema}' 
+			AND kcu.CONSTRAINT_NAME != 'PRIMARY' 
+			AND kcu.REFERENCED_TABLE_NAME IS NOT NULL;
+	`).then((rows) => {
+		queryCallback('fks', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('fks', [], err);
+		throw err;
+	});
+
+	const filteredFKs = fks.filter((it) => tableNames.has(it.TABLE_NAME));
+	const groupedFKs = filteredFKs.reduce<Record<string, ForeignKey>>(
+		(acc, it) => {
+			const name = it.CONSTRAINT_NAME;
+			const table: string = it.TABLE_NAME;
+			const column: string = it.COLUMN_NAME;
+			const refTable: string = it.REFERENCED_TABLE_NAME;
+			const refColumn: string = it.REFERENCED_COLUMN_NAME;
+			const updateRule: string = it.UPDATE_RULE;
+			const deleteRule: string = it.DELETE_RULE;
+
+			const key = `${table}:${name}`;
+
+			if (key in acc) {
+				const entry = acc[key];
+				entry.columns.push(column);
+				entry.columnsTo.push(refColumn);
+			} else {
+				acc[key] = {
+					entityType: 'fks',
+					name,
+					table,
+					tableTo: refTable,
+					columns: [column],
+					columnsTo: [refColumn],
+					onDelete: deleteRule?.toUpperCase() as ForeignKey['onUpdate'] ?? 'NO ACTION',
+					onUpdate: updateRule?.toUpperCase() as ForeignKey['onUpdate'] ?? 'NO ACTION',
+					nameExplicit: true,
+				} satisfies ForeignKey;
+			}
+			return acc;
+		},
+		{} as Record<string, ForeignKey>,
+	);
+
+	for (const fk of Object.values(groupedFKs)) {
+		res.fks.push(fk);
+	}
+	progressCallback('fks', res.fks.length, 'done');
+
+	// CHECKS
+
+	progressCallback('checks', 0, 'fetching');
+	const checks = await db.query<{
+		TABLE_NAME: string;
+		CONSTRAINT_NAME: string;
+		CHECK_CLAUSE: string;
+	}>(`
+		SELECT
+			tc.TABLE_NAME, 
+			tc.CONSTRAINT_NAME, 
+			cc.CHECK_CLAUSE
+		FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+		JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc ON tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+		WHERE tc.CONSTRAINT_SCHEMA = '${schema}'
+			AND tc.CONSTRAINT_TYPE = 'CHECK';
+	`).then((rows) => {
+		queryCallback('checks', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('checks', [], err);
+		throw err;
+	});
+
+	for (const check of checks.filter((it) => tableNames.has(it.TABLE_NAME))) {
+		const table = check.TABLE_NAME;
+		const name = check.CONSTRAINT_NAME;
+		const value = check.CHECK_CLAUSE;
+
+		res.checks.push({
+			entityType: 'checks',
+			table,
+			name,
+			value,
+		});
+	}
+	progressCallback('checks', res.checks.length, 'done');
+
+	// VIEWS
+
+	progressCallback('views', 0, 'fetching');
+	const views = await batchQuery<{
+		TABLE_NAME: string;
+		VIEW_DEFINITION: string;
+		CHECK_OPTION: string | null;
+		SECURITY_TYPE: string;
+	}>(
+		db,
+		({ limit, cursor }) =>
+			`SELECT
+				TABLE_NAME,
+				VIEW_DEFINITION,
+				CHECK_OPTION,
+				SECURITY_TYPE
+			FROM INFORMATION_SCHEMA.VIEWS
+			WHERE TABLE_SCHEMA = '${schema}'
+				${cursor ? `AND TABLE_NAME > '${cursor.TABLE_NAME}'` : ''}
+			ORDER BY TABLE_NAME
+			LIMIT ${limit}`,
+		(count) => {
+			progressCallback('views', count, 'fetching');
+		},
+	).then((rows) => {
+		queryCallback('views', rows, null);
+		return rows.filter((it) => {
+			return filter({ type: 'table', schema: false, name: it.TABLE_NAME });
+		});
+	}).catch((err) => {
+		queryCallback('views', [], err);
+		throw err;
+	});
+
+	for await (const view of views) {
+		const name = view.TABLE_NAME;
+		const definition = view.VIEW_DEFINITION;
+		const checkOption = view.CHECK_OPTION;
+
+		const withCheckOption = !checkOption || checkOption === 'NONE'
+			? null
+			: checkOption.toLowerCase();
+
+		const sqlSecurity = view.SECURITY_TYPE.toLowerCase() as 'definer' | 'invoker';
+
+		const [createSqlStatement] = await db.query(`SHOW CREATE VIEW \`${name}\`;`);
+		const algorithmMatch = createSqlStatement['Create View'].match(/ALGORITHM=([^ ]+)/);
+		const algorithm = algorithmMatch ? algorithmMatch[1].toLowerCase() : null;
+
+		const viewColumns = columns.filter((it) => it.TABLE_NAME === name);
+
+		for (const column of viewColumns) {
+			const columnType = column['COLUMN_TYPE'].replace('decimal(10,0)', 'decimal');
+
+			res.viewColumns.push({
+				view: name,
+				name: column['COLUMN_NAME'],
+				notNull: column['IS_NULLABLE'] === 'NO',
+				type: columnType,
+			});
+		}
+
+		res.views.push({
+			entityType: 'views',
+			name,
+			definition,
+			algorithm: algorithm,
+			sqlSecurity,
+			withCheckOption: withCheckOption as 'local' | 'cascaded' | null,
+		});
+	}
+	progressCallback('views', res.views.length, 'done');
+
+	return res;
+};
diff --git a/drizzle-kit/src/dialects/mysql/serializer.ts b/drizzle-kit/src/dialects/mysql/serializer.ts
new file mode 100644
index 0000000000..0b5d02d029
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/serializer.ts
@@ -0,0 +1,307 @@
+import type { CheckHandlerResult } from '../../cli/commands/check';
+import { humanLog, mysqlSchemaError } from '../../cli/views';
+import { assertUnreachable } from '../../utils';
+import { findLeafSnapshotIds } from '../../utils/utils-node';
+import type { MysqlDDL, SchemaError } from './ddl';
+import { createDDL, interimToDDL } from './ddl';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from './drizzle';
+import type { MysqlSnapshot } from './snapshot';
+import { drySnapshot, snapshotValidator } from './snapshot';
+import type { JsonStatement } from './statements';
+
+export const prepareSnapshot = async (
+	snapshots: string[],
+	filenames: string[],
+	checkResult?: CheckHandlerResult,
+): Promise<{
+	ddlPrev: MysqlDDL;
+	ddlCur: MysqlDDL;
+	snapshot: MysqlSnapshot;
+	snapshotPrev: MysqlSnapshot;
+	custom: MysqlSnapshot;
+	errors2: SchemaError[];
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const latestSnapshot = snapshots.length === 0
+		? drySnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const branchParentSnapshot = checkResult?.parentSnapshot
+		? snapshotValidator.strict(
+			checkResult.parentSnapshot as Record<string, unknown>,
+		)
+		: null;
+	const branchStatements = (checkResult?.statements ?? []) as JsonStatement[];
+	const useBranchParent = branchParentSnapshot !== null && branchStatements.length > 0;
+	const mergeLeafIds = (checkResult?.leafIds?.length ?? 0) > 1 ? checkResult?.leafIds : undefined;
+
+	const prevSnapshot = useBranchParent
+		? generateLatestSnapshot(branchParentSnapshot, branchStatements)
+		: latestSnapshot;
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+	const res = await prepareFromSchemaFiles(filenames);
+
+	const interim = fromDrizzleSchema(res.tables, res.views);
+
+	const { ddl: ddlCur, errors: errors2 } = interimToDDL(interim);
+
+	if (errors2.length > 0) {
+		humanLog(errors2.map((it) => mysqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const id = randomUUID();
+	const prevIds = mergeLeafIds
+		? mergeLeafIds
+		: snapshots.length === 0
+		? [prevSnapshot.id]
+		: findLeafSnapshotIds(snapshots);
+
+	const snapshot = {
+		version: '6',
+		dialect: 'mysql',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies MysqlSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	const custom: MysqlSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return {
+		ddlPrev,
+		ddlCur,
+		snapshot,
+		snapshotPrev: prevSnapshot,
+		custom,
+		errors2,
+	};
+};
+
+export function generateLatestSnapshot(
+	snapshot: MysqlSnapshot,
+	statements: JsonStatement[],
+): MysqlSnapshot {
+	const ddl = createDDL();
+	for (const entry of snapshot.ddl) {
+		ddl.entities.push(entry);
+	}
+
+	const clearMetaFields = <T>(value: T): T => {
+		if (!value || typeof value !== 'object') {
+			return value;
+		}
+
+		return Object.fromEntries(
+			Object.entries(value as Record<string, unknown>).filter(
+				([key]) => !key.startsWith('$'),
+			),
+		) as T;
+	};
+
+	const push = (entity: { push: (row: unknown) => unknown }, row: unknown) => {
+		entity.push(clearMetaFields(row));
+	};
+	const del = (
+		entity: { delete: (where?: unknown) => unknown },
+		where: unknown,
+	) => {
+		entity.delete(clearMetaFields(where));
+	};
+	const replace = (
+		entity: {
+			delete: (where?: unknown) => unknown;
+			push: (row: unknown) => unknown;
+		},
+		left: unknown,
+		right: unknown,
+	) => {
+		del(entity, left);
+		push(entity, right);
+	};
+
+	for (const statement of statements) {
+		switch (statement.type) {
+			case 'create_table': {
+				const table = statement.table;
+				ddl.tables.push({ name: table.name });
+				for (const column of table.columns) {
+					ddl.columns.push(column);
+				}
+				for (const index of table.indexes) {
+					ddl.indexes.push(index);
+				}
+				if (table.pk) {
+					ddl.pks.push(table.pk);
+				}
+				for (const fk of table.fks) {
+					ddl.fks.push(fk);
+				}
+				for (const check of table.checks) {
+					ddl.checks.push(check);
+				}
+				break;
+			}
+			case 'drop_table':
+				ddl.tables.delete({ name: statement.table });
+				ddl.columns.delete({ table: statement.table });
+				ddl.indexes.delete({ table: statement.table });
+				ddl.pks.delete({ table: statement.table });
+				ddl.fks.delete({ table: statement.table });
+				ddl.fks.delete({ tableTo: statement.table });
+				ddl.checks.delete({ table: statement.table });
+				break;
+			case 'rename_table':
+				ddl.tables.update({
+					where: { name: statement.from },
+					set: { name: statement.to },
+				});
+				ddl.columns.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.indexes.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.pks.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.fks.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.fks.update({
+					where: { tableTo: statement.from },
+					set: { tableTo: statement.to },
+				});
+				ddl.checks.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				break;
+
+			case 'add_column':
+				push(ddl.columns, statement.column);
+				break;
+			case 'drop_column':
+				del(ddl.columns, statement.column);
+				break;
+			case 'rename_column':
+				ddl.columns.update({
+					where: { table: statement.table, name: statement.from },
+					set: { name: statement.to },
+				});
+				ddl.indexes.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) =>
+							column.value === statement.from
+								? { ...column, value: statement.to }
+								: column,
+					},
+				});
+				ddl.pks.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				ddl.fks.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				ddl.fks.update({
+					where: { tableTo: statement.table },
+					set: {
+						columnsTo: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				break;
+			case 'alter_column':
+				replace(ddl.columns, statement.diff.$left, statement.column);
+				break;
+			case 'recreate_column':
+				replace(ddl.columns, statement.diff.$left, statement.diff.$right);
+				break;
+
+			case 'create_index':
+				push(ddl.indexes, statement.index);
+				break;
+			case 'drop_index':
+				del(ddl.indexes, statement.index);
+				break;
+
+			case 'create_fk':
+				push(ddl.fks, statement.fk);
+				break;
+			case 'create_pk':
+				push(ddl.pks, statement.pk);
+				break;
+			case 'drop_pk':
+				del(ddl.pks, statement.pk);
+				break;
+			case 'drop_constraint':
+				ddl.fks.delete({ table: statement.table, name: statement.constraint });
+				ddl.checks.delete({
+					table: statement.table,
+					name: statement.constraint,
+				});
+				if (statement.constraint === 'PRIMARY') {
+					ddl.pks.delete({
+						table: statement.table,
+						name: statement.constraint,
+					});
+				}
+				break;
+
+			case 'create_view':
+				push(ddl.views, statement.view);
+				break;
+			case 'drop_view':
+				del(ddl.views, { name: statement.name });
+				break;
+			case 'rename_view':
+				ddl.views.update({
+					where: { name: statement.from },
+					set: { name: statement.to },
+				});
+				break;
+			case 'alter_view':
+				replace(ddl.views, statement.diff.$left, statement.view);
+				break;
+
+			case 'create_check':
+				push(ddl.checks, statement.check);
+				break;
+
+			default:
+				assertUnreachable(statement);
+		}
+	}
+
+	return {
+		...snapshot,
+		ddl: ddl.entities.list(),
+	};
+}
diff --git a/drizzle-kit/src/dialects/mysql/snapshot.ts b/drizzle-kit/src/dialects/mysql/snapshot.ts
new file mode 100644
index 0000000000..83c6edf22f
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/snapshot.ts
@@ -0,0 +1,253 @@
+import { randomUUID } from 'crypto';
+import { any, array as zArray, boolean, enum as enumType, literal, object, record, string, type TypeOf } from 'zod';
+import { originUUID } from '../../utils';
+import { array, validator } from '../simpleValidator';
+import type { MysqlDDL, MysqlEntity } from './ddl';
+import { createDDL } from './ddl';
+
+// ------- V3 --------
+const index = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	using: enumType(['btree', 'hash']).optional(),
+	algorithm: enumType(['default', 'inplace', 'copy']).optional(),
+	lock: enumType(['default', 'none', 'shared', 'exclusive']).optional(),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	autoincrement: boolean().optional(),
+	default: any().optional(),
+	onUpdate: any().optional(),
+	generated: object({
+		type: enumType(['stored', 'virtual']),
+		as: string(),
+	}).optional(),
+}).strict();
+
+const tableV3 = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const tableV4 = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const table = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	checkConstraint: record(string(), checkConstraint).default({}),
+}).strict();
+
+const viewMeta = object({
+	algorithm: enumType(['undefined', 'merge', 'temptable']),
+	sqlSecurity: enumType(['definer', 'invoker']),
+	withCheckOption: enumType(['local', 'cascaded']).optional(),
+}).strict();
+
+export const view = object({
+	name: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	isExisting: boolean(),
+}).strict().merge(viewMeta);
+// type SquasherViewMeta = Omit<TypeOf<typeof viewMeta>, 'definer'>;
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isDefaultAnExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+	indexes: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+}).optional();
+
+// use main dialect
+const dialect = literal('mysql');
+
+const schemaHash = object({
+	id: string(),
+	prevIds: zArray(string()),
+});
+
+const schemaHashV6 = object({
+	id: string(),
+	prevId: string(),
+});
+
+export const schemaInternalV3 = object({
+	version: literal('3'),
+	dialect: dialect,
+	tables: record(string(), tableV3),
+}).strict();
+
+export const schemaInternalV4 = object({
+	version: literal('4'),
+	dialect: dialect,
+	tables: record(string(), tableV4),
+	schemas: record(string(), string()),
+}).strict();
+
+export const schemaInternalV5 = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaInternal = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	views: record(string(), view).default({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaV3 = schemaInternalV3.merge(schemaHash);
+export const schemaV4 = schemaInternalV4.merge(schemaHash);
+export const schemaV5 = schemaInternalV5.merge(schemaHash);
+export const schemaV6 = schemaInternal.merge(schemaHashV6);
+export const schema = schemaInternal.merge(schemaHash);
+
+export type Table = TypeOf<typeof table>;
+export type Column = TypeOf<typeof column>;
+export type SchemaV4 = TypeOf<typeof schemaV4>;
+export type SchemaV5 = TypeOf<typeof schemaV5>;
+export type SchemaV6 = TypeOf<typeof schemaV6>;
+export type Schema = TypeOf<typeof schema>;
+
+const tableSquashedV4 = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+}).strict();
+
+const tableSquashed = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()).default({}),
+	checkConstraints: record(string(), string()).default({}),
+}).strict();
+
+const viewSquashed = view.omit({
+	algorithm: true,
+	sqlSecurity: true,
+	withCheckOption: true,
+}).extend({ meta: string() });
+
+export const schemaSquashed = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), tableSquashed),
+	views: record(string(), viewSquashed),
+}).strict();
+
+export const schemaSquashedV4 = object({
+	version: literal('4'),
+	dialect: dialect,
+	tables: record(string(), tableSquashedV4),
+	schemas: record(string(), string()),
+}).strict();
+
+export const mysqlSchema = schema;
+export const mysqlSchemaV3 = schemaV3;
+export const mysqlSchemaV4 = schemaV4;
+export const mysqlSchemaV5 = schemaV5;
+export const mysqlSchemaSquashed = schemaSquashed;
+export type MysqlSchemaV6 = SchemaV6;
+export type MysqlSchema = Schema;
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['6'],
+	dialect: ['mysql'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<MysqlEntity>((it) => ddl.entities.validate(it)),
+	renames: array<string>((_) => true),
+});
+
+export type MysqlSnapshot = typeof snapshotValidator.shape;
+
+export const toJsonSnapshot = (ddl: MysqlDDL, prevIds: string[], renames: string[]): MysqlSnapshot => {
+	return { dialect: 'mysql', id: randomUUID(), prevIds, version: '6', ddl: ddl.entities.list(), renames };
+};
+
+export const drySnapshot = snapshotValidator.strict(
+	{
+		version: '6',
+		dialect: 'mysql',
+		id: originUUID,
+		prevIds: [],
+		ddl: [],
+		renames: [],
+	} satisfies MysqlSnapshot,
+);
diff --git a/drizzle-kit/src/dialects/mysql/statements.ts b/drizzle-kit/src/dialects/mysql/statements.ts
new file mode 100644
index 0000000000..4174350f43
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/statements.ts
@@ -0,0 +1,154 @@
+import type { Simplify } from '../../utils';
+import type { CheckConstraint, Column, DiffEntities, ForeignKey, Index, PrimaryKey, TableFull, View } from './ddl';
+
+export interface CreateTable {
+	type: 'create_table';
+	table: TableFull;
+}
+
+export interface DropTable {
+	type: 'drop_table';
+	table: string;
+}
+export interface RenameTable {
+	type: 'rename_table';
+	from: string;
+	to: string;
+}
+
+export interface AddColumn {
+	type: 'add_column';
+	column: Column;
+	isPK: boolean;
+}
+
+export interface DropColumn {
+	type: 'drop_column';
+	column: Column;
+}
+
+export interface RenameColumn {
+	type: 'rename_column';
+	table: string;
+	from: string;
+	to: string;
+}
+
+export interface AlterColumn {
+	type: 'alter_column';
+	diff: DiffEntities['columns'];
+	column: Column;
+	isPK: boolean;
+	wasPK: boolean;
+	origin: {
+		column: string;
+		table: string;
+	};
+}
+
+export interface RecreateColumn {
+	type: 'recreate_column';
+	column: Column;
+	isPK: boolean;
+	diff: DiffEntities['columns'];
+}
+
+export interface CreateIndex {
+	type: 'create_index';
+	index: Index;
+}
+
+export interface DropIndex {
+	type: 'drop_index';
+	index: Index;
+}
+
+export interface CreateFK {
+	type: 'create_fk';
+	fk: ForeignKey;
+	cause?: 'alter_pk';
+}
+
+export interface CreatePK {
+	type: 'create_pk';
+	pk: PrimaryKey;
+}
+
+export interface CreatePK {
+	type: 'create_pk';
+	pk: PrimaryKey;
+}
+
+export interface DropPK {
+	type: 'drop_pk';
+	pk: PrimaryKey;
+}
+
+export interface DropConstraint {
+	type: 'drop_constraint';
+	table: string;
+	constraint: string;
+	dropAutoIndex: boolean;
+}
+
+export interface CreateView {
+	type: 'create_view';
+	view: View;
+	replace: boolean;
+}
+
+export interface DropView {
+	type: 'drop_view';
+	name: string;
+}
+
+export interface RenameView {
+	type: 'rename_view';
+	from: string;
+	to: string;
+}
+
+export interface AlterView {
+	type: 'alter_view';
+	diff: DiffEntities['views'];
+	view: View;
+}
+
+export interface CreateCheck {
+	type: 'create_check';
+	check: CheckConstraint;
+}
+
+export type JsonStatement =
+	| CreateTable
+	| DropTable
+	| RenameTable
+	| AddColumn
+	| DropColumn
+	| RenameColumn
+	| AlterColumn
+	| RecreateColumn
+	| CreateIndex
+	| DropIndex
+	| CreateFK
+	| CreatePK
+	| DropPK
+	| CreateView
+	| DropView
+	| RenameView
+	| AlterView
+	| DropConstraint
+	| CreateCheck;
+
+export const prepareStatement = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	args: Omit<TStatement, 'type'>,
+): Simplify<TStatement> => {
+	return {
+		type,
+		...args,
+	} as TStatement;
+};
diff --git a/drizzle-kit/src/dialects/mysql/typescript.ts b/drizzle-kit/src/dialects/mysql/typescript.ts
new file mode 100644
index 0000000000..f09b31156e
--- /dev/null
+++ b/drizzle-kit/src/dialects/mysql/typescript.ts
@@ -0,0 +1,435 @@
+import { toCamelCase } from 'drizzle-orm/casing';
+import type { Casing } from '../../cli/validations/common';
+import { assertUnreachable } from '../../utils';
+import { inspect } from '../utils';
+import type { CheckConstraint, Column, ForeignKey, Index, MysqlDDL, PrimaryKey, ViewColumn } from './ddl';
+import { Enum, parseEnum, typeFor } from './grammar';
+
+export const imports = [
+	'boolean',
+	'tinyint',
+	'smallint',
+	'mediumint',
+	'int',
+	'bigint',
+	'binary',
+	'char',
+	'date',
+	'datetime',
+	'decimal',
+	'double',
+	'float',
+	'json',
+	'real',
+	'serial',
+	'text',
+	'tinytext',
+	'mediumtext',
+	'longtext',
+	'time',
+	'timestamp',
+	'varbinary',
+	'varchar',
+	'year',
+	'mysqlEnum',
+	'singlestoreEnum',
+	'customType',
+	'mediumblob',
+	'blob',
+	'tinyblob',
+	'longblob',
+	// TODO: add new type BSON
+	// TODO: add new type UUID
+	// TODO: add new type GUID
+	// TODO: add new type Vector
+	// TODO: add new type GeoPoint
+] as const;
+export type Import = typeof imports[number];
+
+const mysqlImportsList = new Set([
+	'mysqlTable',
+	'singlestoreTable',
+	...imports,
+]);
+
+const objToStatement2 = (json: any) => {
+	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
+	const keys = Object.keys(json);
+	if (keys.length === 0) return;
+
+	let statement = '{ ';
+	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
+	statement += ' }';
+	return statement;
+};
+
+const relations = new Set<string>();
+
+const escapeColumnKey = (value: string) => {
+	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
+		return `"${value}"`;
+	}
+	return value;
+};
+
+const prepareCasing = (casing?: Casing) => (value: string) => {
+	if (casing === 'preserve') {
+		return escapeColumnKey(value);
+	}
+	if (casing === 'camel') {
+		return escapeColumnKey(toCamelCase(value));
+	}
+
+	assertUnreachable(casing);
+};
+
+const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
+	if (casing === 'preserve') {
+		return '';
+	}
+	if (casing === 'camel') {
+		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
+	}
+
+	assertUnreachable(casing);
+};
+
+export const ddlToTypeScript = (
+	ddl: MysqlDDL,
+	viewColumns: ViewColumn[],
+	casing: Casing,
+	vendor: 'mysql' | 'singlestore',
+) => {
+	const withCasing = prepareCasing(casing);
+
+	for (const fk of ddl.fks.list()) {
+		const relation = `${fk.table}-${fk.tableTo}`;
+		relations.add(relation);
+	}
+
+	const imports = new Set<string>([
+		vendor === 'mysql' ? 'mysqlTable' : 'signlestoreTable',
+		vendor === 'mysql' ? 'mysqlSchema' : 'singlestoreSchema',
+		vendor === 'mysql' ? 'AnyMySqlColumn' : 'AnySinsgleStoreColumn',
+	]);
+
+	const viewEntities = viewColumns.map((it) => {
+		return {
+			entityType: 'viewColumn',
+			...it,
+		} as const;
+	});
+
+	for (const it of [...ddl.entities.list(), ...viewEntities]) {
+		if (it.entityType === 'indexes') imports.add(it.isUnique ? 'uniqueIndex' : 'index');
+		if (it.entityType === 'fks') imports.add('foreignKey');
+		if (it.entityType === 'pks' && (it.columns.length > 1)) imports.add('primaryKey');
+		if (it.entityType === 'checks') imports.add('check');
+		if (it.entityType === 'views') imports.add(vendor === 'mysql' ? 'mysqlView' : 'singlestoreView');
+
+		if (it.entityType === 'columns' || it.entityType === 'viewColumn') {
+			const grammarType = typeFor(it.type);
+			imports.add(grammarType.drizzleImport(vendor));
+			if (mysqlImportsList.has(it.type)) imports.add(it.type);
+		}
+	}
+
+	const tableStatements = [] as string[];
+	for (const table of ddl.tables.list()) {
+		let statement = `export const ${withCasing(table.name)} = ${vendor}Table("${table.name}", {\n`;
+		statement += createTableColumns(
+			ddl.columns.list({ table: table.name }),
+			ddl.pks.one({ table: table.name }),
+			ddl.fks.list({ table: table.name }),
+			withCasing,
+			casing,
+			vendor,
+		);
+		statement += '}';
+
+		const fks = ddl.fks.list({ table: table.name });
+		const indexes = ddl.indexes.list({ table: table.name });
+		const checks = ddl.checks.list({ table: table.name });
+		const pk = ddl.pks.one({ table: table.name });
+
+		// more than 2 fields or self reference or cyclic
+		const filteredFKs = fks.filter((it) => {
+			return it.columns.length > 1 || isSelf(it);
+		});
+
+		const hasIndexes = indexes.length > 0;
+		const hasFKs = filteredFKs.length > 0;
+		const hasPK = pk && pk.columns.length > 1;
+		const hasChecks = checks.length > 0;
+		const hasCallbackParams = hasIndexes || hasFKs || hasPK || hasChecks;
+
+		if (hasCallbackParams) {
+			statement += ',\n';
+			statement += '(table) => [\n';
+			statement += hasPK ? createTablePK(pk, withCasing) : '';
+			statement += createTableIndexes(indexes, withCasing);
+			statement += createTableFKs(filteredFKs, withCasing);
+			statement += createTableChecks(checks);
+			statement += ']';
+		}
+
+		statement += ');';
+
+		tableStatements.push(statement);
+	}
+
+	const viewsStatements = [] as string[];
+	for (const view of ddl.views.list()) {
+		const { name, algorithm, definition, sqlSecurity, withCheckOption } = view;
+		const columns = viewColumns.filter((x) => x.view === view.name);
+
+		let statement = '';
+		statement += `export const ${withCasing(name)} = ${vendor}View("${name}", {\n`;
+		statement += createViewColumns(columns, withCasing, casing, vendor);
+		statement += '})';
+
+		statement += algorithm ? `.algorithm("${algorithm}")` : '';
+		statement += sqlSecurity ? `.sqlSecurity("${sqlSecurity}")` : '';
+		statement += withCheckOption ? `.withCheckOption("${withCheckOption}")` : '';
+		statement += `.as(sql\`${definition?.replaceAll('`', '\\`')}\`);`;
+
+		viewsStatements.push(statement);
+	}
+
+	const importsTs = `import { ${
+		[...imports].join(
+			', ',
+		)
+	} } from "drizzle-orm/${vendor}-core"\nimport { sql } from "drizzle-orm"\n\n`;
+
+	let decalrations = '';
+	decalrations += tableStatements.join('\n\n');
+	decalrations += '\n';
+	decalrations += viewsStatements.join('\n\n');
+
+	const file = importsTs + decalrations;
+
+	const schemaEntry = `
+    {
+      ${
+		Object.values(ddl.tables)
+			.map((it) => withCasing(it.name))
+			.join(',')
+	}
+    }
+  `;
+
+	return {
+		file, // backward compatible, print to file
+		imports: importsTs,
+		decalrations,
+		schemaEntry,
+	};
+};
+
+const isCyclic = (fk: ForeignKey) => {
+	const key = `${fk.table}-${fk.tableTo}`;
+	const reverse = `${fk.tableTo}-${fk.table}`;
+	return relations.has(key) && relations.has(reverse);
+};
+
+const isSelf = (fk: ForeignKey) => {
+	return fk.table === fk.tableTo;
+};
+
+const column = (
+	type: string,
+	name: string,
+	casing: (value: string) => string,
+	rawCasing: Casing,
+	defaultValue: Column['default'],
+	autoincrement: boolean,
+	onUpdateNow: Column['onUpdateNow'],
+	onUpdateNowFsp: Column['onUpdateNowFsp'],
+	collation: Column['collation'],
+	charSet: Column['charSet'],
+	vendor: 'mysql' | 'singlestore',
+) => {
+	let lowered = type.startsWith('enum(') ? type : type.toLowerCase();
+	if (lowered.startsWith('enum')) {
+		const values = parseEnum(lowered).map((it) => `"${it.replaceAll("''", "'").replaceAll('"', '\\"')}"`).join(',');
+		let out = `${casing(name)}: ${vendor}Enum(${dbColumnName({ name, casing: rawCasing, withMode: true })}[${values}])`;
+
+		const { default: def } = Enum.toTs('', defaultValue) as any;
+		out += def ? `.default(${def})` : '';
+		out += charSet ? `.charSet("${charSet}")` : '';
+		out += collation ? `.collate("${collation}")` : '';
+
+		return out;
+	}
+
+	if (lowered === 'serial') {
+		return `${casing(name)}: serial(${dbColumnName({ name, casing: rawCasing })})`;
+	}
+
+	const grammarType = typeFor(lowered);
+	const key = casing(name);
+	const columnName = dbColumnName({ name, casing: rawCasing });
+	const ts = grammarType.toTs(lowered, defaultValue);
+	const { default: def, options, customType } = typeof ts === 'string' ? { default: ts, options: {} } : ts;
+
+	const drizzleType = grammarType.drizzleImport();
+	const defaultStatement = def ? def.startsWith('.') ? def : `.default(${def})` : '';
+	const paramsString = inspect(options);
+	const comma = columnName && paramsString ? ', ' : '';
+
+	let res = `${key}: ${drizzleType}${
+		customType ? `({ dataType: () => '${customType}' })` : ''
+	}(${columnName}${comma}${paramsString})`;
+	res += autoincrement ? `.autoincrement()` : '';
+	res += defaultStatement;
+	res += onUpdateNow ? `.onUpdateNow(${onUpdateNowFsp ? '{ fsp: ' + onUpdateNowFsp + ' }' : ''})` : '';
+	res += charSet ? `.charSet("${charSet}")` : '';
+	res += collation ? `.collate("${collation}")` : '';
+
+	return res;
+};
+
+const createTableColumns = (
+	columns: Column[],
+	pk: PrimaryKey | null,
+	fks: ForeignKey[],
+	casing: (val: string) => string,
+	rawCasing: Casing,
+	vendor: 'mysql' | 'singlestore',
+): string => {
+	let statement = '';
+
+	for (const it of columns) {
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === it.name;
+
+		statement += '\t';
+		statement += column(
+			it.type,
+			it.name,
+			casing,
+			rawCasing,
+			it.default,
+			it.autoIncrement,
+			it.onUpdateNow,
+			it.onUpdateNowFsp,
+			it.collation,
+			it.charSet,
+			vendor,
+		);
+
+		statement += isPK ? '.primaryKey()' : '';
+		statement += it.notNull && !isPK ? '.notNull()' : '';
+
+		statement += it.generated
+			? `.generatedAlwaysAs(sql\`${
+				it.generated.as.replace(
+					/`/g,
+					'\\`',
+				)
+			}\`, { mode: "${it.generated.type}" })`
+			: '';
+
+		const columnFKs = fks.filter((x) => x.columns.length === 1 && x.columns[0] === it.name && !isSelf(x));
+
+		for (const fk of columnFKs) {
+			const onDelete = fk.onDelete !== 'NO ACTION' ? fk.onDelete?.toLowerCase() : null;
+			const onUpdate = fk.onUpdate !== 'NO ACTION' ? fk.onUpdate?.toLowerCase() : null;
+			const params = { onDelete, onUpdate };
+
+			const typeSuffix = isCyclic(fk) ? vendor === 'mysql' ? ': AnyMySqlColumn' : ': AnySinsgleStoreColumn' : '';
+
+			const paramsStr = objToStatement2(params);
+			if (paramsStr) {
+				statement += `.references(()${typeSuffix} => ${
+					casing(
+						fk.tableTo,
+					)
+				}.${casing(fk.columnsTo[0])}, ${paramsStr} )`;
+			} else {
+				statement += `.references(()${typeSuffix} => ${casing(fk.tableTo)}.${
+					casing(
+						fk.columnsTo[0],
+					)
+				})`;
+			}
+		}
+		statement += ',\n';
+	}
+
+	return statement;
+};
+
+const createViewColumns = (
+	columns: ViewColumn[],
+	casing: (value: string) => string,
+	rawCasing: Casing,
+	vendor: 'mysql' | 'singlestore',
+) => {
+	let statement = '';
+
+	for (const it of columns) {
+		statement += '\n';
+		statement += column(it.type, it.name, casing, rawCasing, null, false, false, null, null, null, vendor);
+		statement += it.notNull ? '.notNull()' : '';
+		statement += ',\n';
+	}
+	return statement;
+};
+
+const createTableIndexes = (
+	idxs: Index[],
+	casing: (value: string) => string,
+): string => {
+	let statement = '';
+	for (const it of idxs) {
+		const columns = it.columns.map((x) =>
+			x.isExpression ? `sql\`${x.value.replaceAll('`', '\\`')}\`` : `table.${casing(x.value)}`
+		).join(', ');
+		statement += it.isUnique ? '\tuniqueIndex(' : '\tindex(';
+		statement += `"${it.name}")`;
+		statement += `.on(${columns}),\n`;
+	}
+	return statement;
+};
+
+const createTableChecks = (
+	checks: CheckConstraint[],
+): string => {
+	let statement = '';
+
+	for (const it of checks) {
+		statement += `\tcheck("${it.name}", sql\`${it.value.replace(/`/g, '\\`')}\`),\n`;
+	}
+
+	return statement;
+};
+
+const createTablePK = (pk: PrimaryKey, casing: (value: string) => string): string => {
+	const columns = pk.columns.map((x) => `table.${casing(x)}`).join(', ');
+	let statement = `\tprimaryKey({ columns: [${columns}] }),`;
+	return statement;
+};
+
+const createTableFKs = (
+	fks: ForeignKey[],
+	casing: (value: string) => string,
+): string => {
+	let statement = '';
+
+	for (const it of fks) {
+		const tableTo = isSelf(it) ? 'table' : `${casing(it.tableTo)}`;
+		const columnsFrom = it.columns.map((x) => `table.${casing(x)}`).join(', ');
+		const columnsTo = it.columnsTo.map((x) => `${tableTo}.${casing(x)}`).join(', ');
+		statement += `\tforeignKey({\n`;
+		statement += `\t\tcolumns: [${columnsFrom}],\n`;
+		statement += `\t\tforeignColumns: [${columnsTo}],\n`;
+		statement += `\t\tname: "${it.name}"\n`;
+		statement += `\t})`;
+		statement += it.onUpdate !== 'NO ACTION' ? `.onUpdate("${it.onUpdate?.toLowerCase()}")` : '';
+		statement += it.onDelete !== 'NO ACTION' ? `.onDelete("${it.onDelete?.toLowerCase()}")` : '';
+		statement += `,\n`;
+	}
+
+	return statement;
+};
diff --git a/drizzle-kit/src/dialects/postgres/aws-introspect.ts b/drizzle-kit/src/dialects/postgres/aws-introspect.ts
new file mode 100644
index 0000000000..6462039b5b
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/aws-introspect.ts
@@ -0,0 +1,1189 @@
+import camelcase from 'camelcase';
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import { type DB, splitExpressions, trimChar } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import type {
+	CheckConstraint,
+	Enum,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import {
+	defaultForColumn,
+	isSerialExpression,
+	isSystemNamespace,
+	parseOnType,
+	parseViewDefinition,
+	stringFromDatabaseIdentityProperty as parseIdentityProperty,
+	wrapRecord,
+} from './grammar';
+
+export const fromDatabase = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+): Promise<InterimSchema> => {
+	const schemas: Schema[] = [];
+	const enums: Enum[] = [];
+	const tables: PostgresEntities['tables'][] = [];
+	const columns: InterimColumn[] = [];
+	const indexes: InterimIndex[] = [];
+	const pks: PrimaryKey[] = [];
+	const fks: ForeignKey[] = [];
+	const uniques: UniqueConstraint[] = [];
+	const checks: CheckConstraint[] = [];
+	const sequences: Sequence[] = [];
+	const roles: Role[] = [];
+	const privileges: Privilege[] = [];
+	const policies: Policy[] = [];
+	const views: View[] = [];
+	const viewColumns: ViewColumn[] = [];
+
+	// type OP = {
+	// 	oid: string;
+	// 	name: string;
+	// 	default: boolean;
+	// };
+
+	type Namespace = {
+		oid: string;
+		name: string;
+	};
+
+	// ! Use `pg_catalog` for system functions
+
+	// TODO: potential improvements
+	// use pg_catalog.has_table_privilege(pg_class.oid, 'SELECT') for tables
+	// --- default access method
+	// SHOW default_table_access_method;
+	// SELECT current_setting('default_table_access_method') AS default_am;
+
+	const accessMethodsQuery = db.query<{ oid: string; name: string }>(
+		`SELECT oid, amname as name FROM pg_catalog.pg_am WHERE amtype OPERATOR(pg_catalog.=) 't' ORDER BY pg_catalog.lower(amname);`,
+	).then((rows) => {
+		queryCallback('accessMethods', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('accessMethods', [], error);
+		throw error;
+	});
+
+	const tablespacesQuery = db.query<{
+		oid: string;
+		name: string;
+	}>(
+		`SELECT oid, spcname as "name" FROM pg_catalog.pg_tablespace ORDER BY pg_catalog.lower(spcname)`,
+	).then((rows) => {
+		queryCallback('tablespaces', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('tablespaces', [], error);
+		throw error;
+	});
+
+	const namespacesQuery = db.query<Namespace>(
+		`SELECT oid, nspname as name FROM pg_catalog.pg_namespace WHERE pg_catalog.has_schema_privilege(oid, 'USAGE') ORDER BY pg_catalog.lower(nspname)`,
+	)
+		.then((rows) => {
+			queryCallback('namespaces', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('namespaces', [], error);
+			throw error;
+		});
+
+	const defaultsQuery = db.query<{
+		tableId: string;
+		ordinality: number;
+		expression: string;
+	}>(`
+        SELECT
+            adrelid AS "tableId",
+            adnum AS "ordinality",
+            pg_catalog.pg_get_expr(adbin, adrelid) AS "expression"
+        FROM
+            pg_catalog.pg_attrdef;
+    `).then((rows) => {
+		queryCallback('defaults', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('defaults', [], error);
+		throw error;
+	});
+
+	const [ams, tablespaces, namespaces, defaultsList] = await Promise.all([
+		accessMethodsQuery,
+		tablespacesQuery,
+		namespacesQuery,
+		defaultsQuery,
+	]);
+
+	const { other } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
+		(acc, it) => {
+			if (isSystemNamespace(it.name)) {
+				acc.system.push(it);
+			} else {
+				acc.other.push(it);
+			}
+			return acc;
+		},
+		{ system: [], other: [] },
+	);
+
+	const filteredNamespaces = other.filter((it) => filter({ type: 'schema', name: it.name }));
+	const filteredNamespacesStringForSQL = filteredNamespaces.map((ns) => `'${ns.name}'`).join(',');
+
+	schemas.push(...filteredNamespaces.map<Schema>((it) => ({ entityType: 'schemas', name: it.name })));
+
+	type TableListItem = {
+		oid: string;
+		schema: string;
+		name: string;
+		/* r - table, p - partitioned table, v - view, m - materialized view */
+		kind: 'r' | 'p' | 'v' | 'm';
+		accessMethod: string;
+		options: string[] | null;
+		rlsEnabled: boolean;
+		tablespaceid: string;
+		definition: string | null;
+	};
+	const tablesList = filteredNamespacesStringForSQL
+		? await db
+			.query<TableListItem>(`
+                SELECT
+                    pg_class.oid,
+                    nspname as "schema",
+                    relname AS "name",
+                    relkind::text AS "kind",
+                    relam as "accessMethod",
+                    reloptions::text[] as "options",
+                    reltablespace as "tablespaceid",
+                    relrowsecurity AS "rlsEnabled",
+                    CASE
+                        WHEN relkind OPERATOR(pg_catalog.=) 'v' OR relkind OPERATOR(pg_catalog.=) 'm'
+                            THEN pg_catalog.pg_get_viewdef(pg_class.oid, true)
+                        ELSE null
+                    END AS "definition"
+                FROM
+                    pg_catalog.pg_class
+				JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) relnamespace
+                WHERE
+                    relkind IN ('r', 'p', 'v', 'm')
+                    AND nspname IN (${filteredNamespacesStringForSQL})
+                ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+	`).then((rows) => {
+				queryCallback('tables', rows, null);
+				return rows;
+			}).catch((error) => {
+				queryCallback('tables', [], error);
+				throw error;
+			})
+		: [] as TableListItem[];
+
+	const viewsList = tablesList.filter((it) => it.kind === 'v' || it.kind === 'm');
+
+	const filteredTables = tablesList.filter((it) => {
+		if (!((it.kind === 'r' || it.kind === 'p') && filter({ type: 'table', schema: it.schema, name: it.name }))) {
+			return false;
+		}
+		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+		return true;
+	});
+
+	const filteredTableIds = filteredTables.map((it) => it.oid);
+	const viewsIds = viewsList.map((it) => it.oid);
+	const filteredViewsAndTableIds = [...filteredTableIds, ...viewsIds];
+
+	const filterByTableIds = filteredTableIds.length > 0 ? `(${filteredTableIds.join(',')})` : '';
+	const filterByTableAndViewIds = filteredViewsAndTableIds.length > 0 ? `(${filteredViewsAndTableIds.join(',')})` : '';
+
+	for (const table of filteredTables) {
+		tables.push({
+			entityType: 'tables',
+			schema: trimChar(table.schema, "'"),
+			name: table.name,
+			isRlsEnabled: table.rlsEnabled,
+		});
+	}
+
+	const dependQuery = db.query<{
+		oid: string;
+		tableId: string;
+		ordinality: number;
+
+		/*
+            a - An “auto” dependency means the dependent object can be dropped separately,
+                    and will be automatically removed if the referenced object is dropped—regardless of CASCADE or RESTRICT.
+                    Example: A named constraint on a table is auto-dependent on the table, so it vanishes when the table is dropped
+
+                    i - An “internal” dependency marks objects that were created as part of building another object.
+                    Directly dropping the dependent is disallowed—you must drop the referenced object instead.
+                    Dropping the referenced object always cascades to the dependent
+                    Example: A trigger enforcing a foreign-key constraint is internally dependent on its pg_constraint entry
+         */
+		deptype: 'a' | 'i';
+	}>(
+		`SELECT
+            objid as oid,
+            refobjid as "tableId",
+            refobjsubid as "ordinality",
+            deptype::text
+        FROM
+            pg_catalog.pg_depend
+        where ${filterByTableIds ? ` refobjid IN ${filterByTableIds}` : 'false'};`,
+	).then((rows) => {
+		queryCallback('depend', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('depend', [], error);
+		throw error;
+	});
+
+	type EnumListItem = {
+		oid: string;
+		name: string;
+		schema: string;
+		arrayTypeId: number;
+		ordinality: number;
+		value: string;
+	};
+	const enumsQuery = filteredNamespacesStringForSQL
+		? db
+			.query<EnumListItem>(`SELECT
+                    pg_type.oid as "oid",
+                    typname as "name",
+                    nspname as "schema",
+                    pg_type.typarray as "arrayTypeId",
+                    pg_enum.enumsortorder AS "ordinality",
+                    pg_enum.enumlabel AS "value"
+                FROM
+                    pg_catalog.pg_type
+                JOIN pg_catalog.pg_enum ON pg_enum.enumtypid OPERATOR(pg_catalog.=) pg_type.oid
+				JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_type.typnamespace
+                WHERE
+                    pg_type.typtype OPERATOR(pg_catalog.=) 'e'
+                    AND nspname IN (${filteredNamespacesStringForSQL})
+                ORDER BY pg_type.oid, pg_enum.enumsortorder
+		`).then((rows) => {
+				queryCallback('enums', rows, null);
+				return rows;
+			}).catch((error) => {
+				queryCallback('enums', [], error);
+				throw error;
+			})
+		: [] as EnumListItem[];
+
+	// fetch for serials, adrelid = tableid
+	const serialsQuery = db
+		.query<{
+			oid: string;
+			tableId: string;
+			ordinality: number;
+			expression: string;
+		}>(`SELECT
+                oid,
+                adrelid as "tableId",
+                adnum as "ordinality",
+                pg_catalog.pg_get_expr(adbin, adrelid) as "expression"
+            FROM
+                pg_catalog.pg_attrdef
+            WHERE ${filterByTableIds ? ` adrelid IN ${filterByTableIds}` : 'false'}
+	`).then((rows) => {
+			queryCallback('serials', rows, null);
+			return rows;
+		}).catch((error) => {
+			queryCallback('serials', [], error);
+			throw error;
+		});
+
+	type SequenceListItem = {
+		schema: string;
+		oid: string;
+		name: string;
+		startWith: string;
+		minValue: string;
+		maxValue: string;
+		incrementBy: string;
+		cycle: boolean;
+		cacheSize: number;
+	};
+	const sequencesQuery = filteredNamespacesStringForSQL
+		? db.query<SequenceListItem>(`SELECT 
+            nspname as "schema",
+            relname as "name",
+            seqrelid as "oid",
+            seqstart as "startWith", 
+            seqmin as "minValue", 
+            seqmax as "maxValue", 
+            seqincrement as "incrementBy", 
+            seqcycle as "cycle", 
+            seqcache as "cacheSize" 
+        FROM pg_catalog.pg_sequence
+        JOIN pg_catalog.pg_class ON pg_sequence.seqrelid OPERATOR(pg_catalog.=) pg_class.oid
+		JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_class.relnamespace
+        WHERE nspname IN (${filteredNamespacesStringForSQL})
+        ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+	`).then((rows) => {
+				queryCallback('sequences', rows, null);
+				return rows;
+			}).catch((error) => {
+				queryCallback('sequences', [], error);
+				throw error;
+			})
+		: [] as SequenceListItem[];
+
+	// I'm not yet aware of how we handle policies down the pipeline for push,
+	// and since postgres does not have any default policies, we can safely fetch all of them for now
+	// and filter them out in runtime, simplifying filterings
+	const policiesQuery = db.query<
+		{
+			schema: string;
+			table: string;
+			name: string;
+			as: Policy['as'];
+			to: string | string[];
+			for: Policy['for'];
+			using: string | undefined | null;
+			withCheck: string | undefined | null;
+		}
+	>(`SELECT 
+            schemaname as "schema", 
+            tablename as "table", 
+            policyname as "name", 
+            permissive as "as", 
+            roles as "to", 
+            cmd as "for", 
+            qual as "using", 
+            with_check as "withCheck" 
+        FROM pg_catalog.pg_policies
+        ORDER BY
+			pg_catalog.lower(schemaname),
+			pg_catalog.lower(tablename),
+			pg_catalog.lower(policyname);
+	`).then((rows) => {
+		queryCallback('policies', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('policies', [], error);
+		throw error;
+	});
+
+	const rolesQuery = db.query<
+		{
+			rolname: string;
+			rolsuper: boolean;
+			rolinherit: boolean;
+			rolcreaterole: boolean;
+			rolcreatedb: boolean;
+			rolcanlogin: boolean;
+			rolreplication: boolean;
+			rolconnlimit: number;
+			rolvaliduntil: string | null;
+			rolbypassrls: boolean;
+		}
+	>(
+		`SELECT
+			rolname,
+			rolsuper,
+			rolinherit,
+			rolcreaterole,
+			rolcreatedb,
+			rolcanlogin,
+			rolreplication,
+			rolconnlimit,
+			rolvaliduntil::text,
+			rolbypassrls
+		FROM pg_catalog.pg_roles
+		ORDER BY pg_catalog.lower(rolname);`,
+	).then((rows) => {
+		queryCallback('roles', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('roles', [], error);
+		throw error;
+	});
+
+	type PrivilegeListItem = {
+		grantor: string;
+		grantee: string;
+		schema: string;
+		table: string;
+		type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'TRUNCATE' | 'REFERENCES' | 'TRIGGER';
+		isGrantable: boolean;
+	};
+	const privilegesQuery = filteredNamespacesStringForSQL
+		? db.query<PrivilegeListItem>(`
+		SELECT
+			grantor,
+			grantee,
+			table_schema AS "schema",
+			table_name AS "table",
+			privilege_type AS "type",
+			CASE is_grantable WHEN 'YES' THEN true ELSE false END AS "isGrantable"
+		FROM information_schema.role_table_grants
+		WHERE table_schema IN (${filteredNamespacesStringForSQL})
+		ORDER BY
+			pg_catalog.lower(table_schema),
+			pg_catalog.lower(table_name),
+			pg_catalog.lower(grantee);
+	`).then((rows) => {
+				queryCallback('privileges', rows, null);
+				return rows;
+			}).catch((error) => {
+				queryCallback('privileges', [], error);
+				throw error;
+			})
+		: [] as PrivilegeListItem[];
+
+	const constraintsQuery = db.query<{
+		oid: string;
+		schemaId: string;
+		tableId: string;
+		name: string;
+		type: 'p' | 'u' | 'f' | 'c'; // p - primary key, u - unique, f - foreign key, c - check
+		definition: string;
+		indexId: number;
+		columnsOrdinals: number[];
+		tableToId: string;
+		columnsToOrdinals: number[];
+		onUpdate: 'a' | 'd' | 'r' | 'c' | 'n';
+		onDelete: 'a' | 'd' | 'r' | 'c' | 'n';
+	}>(`
+    SELECT
+      oid,
+      connamespace AS "schemaId",
+      conrelid AS "tableId",
+      conname AS "name",
+      contype::text AS "type", 
+      pg_catalog.pg_get_constraintdef(oid) AS "definition",
+      conindid AS "indexId",
+      conkey AS "columnsOrdinals",
+      confrelid AS "tableToId",
+      confkey AS "columnsToOrdinals",
+      confupdtype::text AS "onUpdate",
+      confdeltype::text AS "onDelete"
+    FROM
+      pg_catalog.pg_constraint
+    WHERE ${filterByTableIds ? ` conrelid IN ${filterByTableIds}` : 'false'}
+    ORDER BY conrelid, contype, pg_catalog.lower(conname);
+  `).then((rows) => {
+		queryCallback('constraints', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('constraints', [], error);
+		throw error;
+	});
+
+	// for serials match with pg_attrdef via attrelid(tableid)+adnum(ordinal position), for enums with pg_enum above
+	const columnsQuery = db.query<{
+		tableId: string;
+		kind: 'r' | 'p' | 'v' | 'm';
+		name: string;
+		ordinality: number;
+		notNull: boolean;
+		type: string;
+		dimensions: number;
+		typeId: string;
+		/* s - stored */
+		generatedType: 's' | '';
+		/*
+        'a' for GENERATED ALWAYS
+        'd' for GENERATED BY DEFAULT
+        */
+		identityType: 'a' | 'd' | '';
+		seqId: number | string | null;
+	}>(`SELECT
+                attrelid AS "tableId",
+                relkind::text AS "kind",
+                attname AS "name",
+                attnum AS "ordinality",
+                attnotnull AS "notNull",
+                attndims as "dimensions",
+                atttypid as "typeId",
+                attgenerated::text as "generatedType", 
+                attidentity::text as "identityType",
+                pg_catalog.format_type(atttypid, atttypmod) as "type",
+                pg_catalog.pg_get_serial_sequence('"' OPERATOR(pg_catalog.||) "nspname" OPERATOR(pg_catalog.||) '"."' OPERATOR(pg_catalog.||) "relname" OPERATOR(pg_catalog.||) '"', "attname")::regclass::oid as "seqId"
+            FROM
+                pg_catalog.pg_attribute attr
+            JOIN pg_catalog.pg_class cls ON cls.oid OPERATOR(pg_catalog.=) attr.attrelid
+            JOIN pg_catalog.pg_namespace nsp ON nsp.oid OPERATOR(pg_catalog.=) cls.relnamespace
+            WHERE
+            ${filterByTableAndViewIds ? ` attrelid IN ${filterByTableAndViewIds}` : 'false'}
+                AND attnum OPERATOR(pg_catalog.>) 0
+                AND attisdropped OPERATOR(pg_catalog.=) FALSE
+            ORDER BY attnum;
+	`).then((rows) => {
+		queryCallback('columns', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('columns', [], error);
+		throw error;
+	});
+
+	const [
+		dependList,
+		enumsList,
+		serialsList,
+		sequencesList,
+		policiesList,
+		rolesList,
+		privilegesList,
+		constraintsList,
+		columnsList,
+	] = await Promise
+		.all([
+			dependQuery,
+			enumsQuery,
+			serialsQuery,
+			sequencesQuery,
+			policiesQuery,
+			rolesQuery,
+			privilegesQuery,
+			constraintsQuery,
+			columnsQuery,
+		]);
+
+	const groupedEnums = enumsList.reduce((acc, it) => {
+		if (!(it.oid in acc)) {
+			acc[it.oid] = {
+				oid: it.oid,
+				schema: it.schema,
+				name: it.name,
+				values: [it.value],
+			};
+		} else {
+			acc[it.oid].values.push(it.value);
+		}
+		return acc;
+	}, {} as Record<string, { oid: string; schema: string; name: string; values: string[] }>);
+
+	const groupedArrEnums = enumsList.reduce((acc, it) => {
+		if (!(it.arrayTypeId in acc)) {
+			acc[it.arrayTypeId] = {
+				oid: it.oid,
+				schema: it.schema,
+				name: it.name,
+				values: [it.value],
+			};
+		} else {
+			acc[it.arrayTypeId].values.push(it.value);
+		}
+		return acc;
+	}, {} as Record<string, { oid: string; schema: string; name: string; values: string[] }>);
+
+	for (const it of Object.values(groupedEnums)) {
+		enums.push({
+			entityType: 'enums',
+			schema: it.schema,
+			name: it.name,
+			values: it.values,
+		});
+	}
+
+	let columnsCount = 0;
+	let indexesCount = 0;
+	let foreignKeysCount = 0;
+	let tableCount = 0;
+	let checksCount = 0;
+	let viewsCount = 0;
+
+	for (const seq of sequencesList) {
+		const depend = dependList.find((it) => it.oid === seq.oid);
+
+		if (depend && (depend.deptype === 'a' || depend.deptype === 'i')) {
+			// TODO: add type field to sequence in DDL
+			// skip fo sequences or identity columns
+			// console.log('skip for auto created', seq.name);
+			continue;
+		}
+
+		sequences.push({
+			entityType: 'sequences',
+			schema: seq.schema,
+			name: seq.name,
+			startWith: parseIdentityProperty(seq.startWith),
+			minValue: parseIdentityProperty(seq.minValue),
+			maxValue: parseIdentityProperty(seq.maxValue),
+			incrementBy: parseIdentityProperty(seq.incrementBy),
+			cycle: seq.cycle,
+			cacheSize: Number(parseIdentityProperty(seq.cacheSize) ?? 1),
+		});
+	}
+
+	progressCallback('enums', Object.keys(groupedEnums).length, 'done');
+
+	// TODO: drizzle link
+	const filteredRoles = rolesList.filter((x) => filter({ type: 'role', name: x.rolname }));
+	for (const dbRole of filteredRoles) {
+		roles.push({
+			entityType: 'roles',
+			name: dbRole.rolname,
+			superuser: dbRole.rolsuper,
+			inherit: dbRole.rolinherit,
+			createRole: dbRole.rolcreatedb,
+			createDb: dbRole.rolcreatedb,
+			canLogin: dbRole.rolcanlogin,
+			replication: dbRole.rolreplication,
+			connLimit: dbRole.rolconnlimit,
+			password: null,
+			validUntil: dbRole.rolvaliduntil,
+			bypassRls: dbRole.rolbypassrls,
+		});
+	}
+
+	for (const privilege of privilegesList) {
+		privileges.push({
+			entityType: 'privileges',
+			// TODO: remove name and implement custom pk
+			name: `${privilege.grantor}_${privilege.grantee}_${privilege.schema}_${privilege.table}_${privilege.type}`,
+			grantor: privilege.grantor,
+			grantee: privilege.grantee,
+			schema: privilege.schema,
+			table: privilege.table,
+			type: privilege.type,
+			isGrantable: privilege.isGrantable,
+		});
+	}
+
+	for (const it of policiesList) {
+		policies.push({
+			entityType: 'policies',
+			schema: it.schema,
+			table: it.table,
+			name: it.name,
+			as: it.as,
+			for: it.for,
+			roles: typeof it.to === 'string' ? it.to.slice(1, -1).split(',') : it.to,
+			using: it.using ?? null,
+			withCheck: it.withCheck ?? null,
+		});
+	}
+
+	progressCallback('policies', policiesList.length, 'done');
+
+	type DBColumn = (typeof columnsList)[number];
+
+	// supply serials
+	for (const column of columnsList.filter((x) => x.kind === 'r' || x.kind === 'p')) {
+		const type = column.type;
+
+		if (!(type === 'smallint' || type === 'bigint' || type === 'integer')) {
+			continue;
+		}
+
+		const expr = serialsList.find(
+			(it) => it.tableId === column.tableId && it.ordinality === column.ordinality,
+		);
+
+		if (expr) {
+			const table = tablesList.find((it) => it.oid === column.tableId)!;
+
+			const isSerial = isSerialExpression(expr.expression, table.schema);
+			column.type = isSerial ? type === 'bigint' ? 'bigserial' : type === 'integer' ? 'serial' : 'smallserial' : type;
+		}
+	}
+
+	for (const column of columnsList.filter((x) => x.kind === 'r' || x.kind === 'p')) {
+		const table = tablesList.find((it) => it.oid === column.tableId)!;
+
+		// supply enums
+		const enumType = column.typeId in groupedEnums
+			? groupedEnums[column.typeId]
+			: column.typeId in groupedArrEnums
+			? groupedArrEnums[column.typeId]
+			: null;
+
+		let columnTypeMapped = enumType ? enumType.name : column.type.replace('[]', '');
+
+		if (columnTypeMapped.startsWith('numeric(')) {
+			columnTypeMapped = columnTypeMapped.replace(',', ', ');
+		}
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace(' with time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char');
+
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+
+		const columnDefault = defaultsList.find(
+			(it) => it.tableId === column.tableId && it.ordinality === column.ordinality,
+		);
+
+		const defaultValue = defaultForColumn(
+			columnTypeMapped,
+			columnDefault?.expression,
+			column.dimensions,
+			Boolean(enumType),
+		);
+
+		const unique = constraintsList.find((it) => {
+			return it.type === 'u' && it.tableId === column.tableId && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const pk = constraintsList.find((it) => {
+			return it.type === 'p' && it.tableId === column.tableId && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const sequence = column.seqId
+			? sequencesList.find((it) => Number(it.oid) === Number(column.seqId))
+			: null;
+
+		columnTypeMapped += '[]'.repeat(column.dimensions);
+
+		columns.push({
+			entityType: 'columns',
+			schema: table.schema,
+			table: table.name,
+			name: column.name,
+			type: columnTypeMapped,
+			typeSchema: enumType ? enumType.schema ?? 'public' : null,
+			dimensions: column.dimensions,
+			default: column.generatedType === 's' ? null : defaultValue,
+			unique: !!unique,
+			uniqueName: unique ? unique.name : null,
+			uniqueNullsNotDistinct: unique?.definition.includes('NULLS NOT DISTINCT') ?? false,
+			notNull: column.notNull,
+			pk: pk !== null,
+			pkName: pk !== null ? pk.name : null,
+			generated: column.generatedType === 's' && columnDefault?.expression
+				? { type: 'stored', as: columnDefault.expression }
+				: null,
+			identity: column.identityType !== '' && sequence
+				? {
+					type: column.identityType === 'a' ? 'always' : 'byDefault',
+					name: sequence.name,
+					increment: parseIdentityProperty(sequence.incrementBy),
+					minValue: parseIdentityProperty(sequence.minValue),
+					maxValue: parseIdentityProperty(sequence.maxValue),
+					startWith: parseIdentityProperty(sequence.startWith),
+					cycle: sequence.cycle,
+					cache: Number(parseIdentityProperty(sequence.cacheSize)),
+				}
+				: null,
+		});
+	}
+
+	for (const unique of constraintsList.filter((it) => it.type === 'u')) {
+		const table = tablesList.find((it) => it.oid === unique.tableId)!;
+		const schema = namespaces.find((it) => it.oid === unique.schemaId)!;
+
+		const columns = unique.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === unique.tableId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		uniques.push({
+			entityType: 'uniques',
+			schema: schema.name,
+			table: table.name,
+			name: unique.name,
+			nameExplicit: true,
+			columns,
+			nullsNotDistinct: unique.definition.includes('NULLS NOT DISTINCT'),
+		});
+	}
+
+	for (const pk of constraintsList.filter((it) => it.type === 'p')) {
+		const table = tablesList.find((it) => it.oid === pk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === pk.schemaId)!;
+
+		const columns = pk.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === pk.tableId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		pks.push({
+			entityType: 'pks',
+			schema: schema.name,
+			table: table.name,
+			name: pk.name,
+			columns,
+			nameExplicit: true,
+		});
+	}
+
+	for (const fk of constraintsList.filter((it) => it.type === 'f')) {
+		const table = tablesList.find((it) => it.oid === fk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === fk.schemaId)!;
+		const tableTo = tablesList.find((it) => it.oid === fk.tableToId)!;
+
+		const columns = fk.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === fk.tableId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		const columnsTo = fk.columnsToOrdinals.map((it) => {
+			const column = columnsList.find((column) => column.tableId === fk.tableToId && column.ordinality === it)!;
+			return column.name;
+		});
+
+		fks.push({
+			entityType: 'fks',
+			schema: schema.name,
+			table: table.name,
+			name: fk.name,
+			nameExplicit: true,
+			columns,
+			tableTo: tableTo.name,
+			schemaTo: tableTo.schema,
+			columnsTo,
+			onUpdate: parseOnType(fk.onUpdate),
+			onDelete: parseOnType(fk.onDelete),
+		});
+	}
+
+	for (const check of constraintsList.filter((it) => it.type === 'c')) {
+		const table = tablesList.find((it) => it.oid === check.tableId)!;
+		const schema = namespaces.find((it) => it.oid === check.schemaId)!;
+
+		checks.push({
+			entityType: 'checks',
+			schema: schema.name,
+			table: table.name,
+			name: check.name,
+			value: check.definition,
+		});
+	}
+
+	type IndexMetadata = {
+		tableId: number;
+		expression: string | null;
+		where: string;
+		columnOrdinals: number[];
+		opclasses: { oid: number; name: string; default: boolean }[];
+		options: number[];
+		isUnique: boolean;
+		isPrimary: boolean;
+	};
+
+	const idxs = await db.query<{
+		oid: number;
+		schema: string;
+		name: string;
+		accessMethod: string;
+		with?: string[];
+		metadata: string;
+	}>(`
+      SELECT
+        pg_class.oid,
+        nspname as "schema",
+        relname AS "name",
+        am.amname AS "accessMethod",
+        reloptions AS "with",
+        pg_catalog.row_to_json(metadata.*) as "metadata"
+      FROM
+        pg_catalog.pg_class
+      JOIN pg_catalog.pg_am am ON am.oid OPERATOR(pg_catalog.=) pg_class.relam
+	  JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) relnamespace
+      JOIN LATERAL (
+        SELECT
+          pg_catalog.pg_get_expr(indexprs, indrelid) AS "expression",
+          pg_catalog.pg_get_expr(indpred, indrelid) AS "where",
+          indrelid::int AS "tableId",
+          indkey::int[] as "columnOrdinals",
+          indoption::int[] as "options",
+          indisunique as "isUnique",
+          indisprimary as "isPrimary",
+		  array(
+			SELECT
+			  pg_catalog.json_build_object(
+				'oid', opclass.oid,
+				'name', pg_am.amname,
+				'default', pg_opclass.opcdefault
+			  )
+			FROM
+			  pg_catalog.unnest(indclass) WITH ORDINALITY AS opclass(oid, ordinality)
+			JOIN pg_catalog.pg_opclass ON opclass.oid OPERATOR(pg_catalog.=) pg_opclass.oid
+			JOIN pg_catalog.pg_am ON pg_opclass.opcmethod OPERATOR(pg_catalog.=) pg_am.oid
+			ORDER BY opclass.ordinality
+		  ) as "opclasses"
+        FROM
+          pg_catalog.pg_index
+        WHERE
+          pg_index.indexrelid OPERATOR(pg_catalog.=) pg_class.oid
+      ) metadata ON TRUE
+      WHERE
+        relkind OPERATOR(pg_catalog.=) 'i'
+		AND ${filterByTableIds ? `metadata."tableId" IN ${filterByTableIds}` : 'false'}
+	  ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+    `).then((rows) => {
+		queryCallback('indexes', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('indexes', [], error);
+		throw error;
+	});
+
+	for (const idx of idxs) {
+		const metadata = JSON.parse(idx.metadata) as IndexMetadata;
+
+		// filter for drizzle only?
+		const forUnique = metadata.isUnique && constraintsList.some((x) => x.type === 'u' && x.indexId === idx.oid);
+		const forPK = metadata.isPrimary && constraintsList.some((x) => x.type === 'p' && x.indexId === idx.oid);
+
+		const expr = splitExpressions(metadata.expression);
+
+		const table = tablesList.find((it) => it.oid === String(metadata.tableId))!;
+
+		const nonColumnsCount = metadata.columnOrdinals.reduce((acc, it) => {
+			if (it === 0) acc += 1;
+			return acc;
+		}, 0);
+
+		if (expr.length !== nonColumnsCount) {
+			throw new Error(
+				`expression split doesn't match non-columns count: [${
+					metadata.columnOrdinals.join(
+						', ',
+					)
+				}] '${metadata.expression}':${expr.length}:${nonColumnsCount}`,
+			);
+		}
+
+		const opts = metadata.options.map((it) => {
+			return {
+				descending: (it & 1) === 1,
+				nullsFirst: (it & 2) === 2,
+			};
+		});
+
+		const res = [] as (
+			& (
+				| { type: 'expression'; value: string }
+				| { type: 'column'; value: DBColumn }
+			)
+			& { options: (typeof opts)[number]; opclass: { name: string; default: boolean } }
+		)[];
+
+		let k = 0;
+		for (let i = 0; i < metadata.columnOrdinals.length; i++) {
+			const ordinal = metadata.columnOrdinals[i];
+			if (ordinal === 0) {
+				res.push({
+					type: 'expression',
+					value: expr[k],
+					options: opts[i],
+					opclass: metadata.opclasses[i],
+				});
+				k += 1;
+			} else {
+				const column = columnsList.find((column) => {
+					return column.tableId === String(metadata.tableId) && column.ordinality === ordinal;
+				});
+				if (!column) throw new Error(`missing column: ${metadata.tableId}:${ordinal}`);
+
+				// ! options and opclass can be undefined when index have "INCLUDE" columns (columns from "INCLUDE" don't have options and opclass)
+				const options = opts[i] as typeof opts[number] | undefined;
+				const opclass = metadata.opclasses[i] as { name: string; default: boolean } | undefined;
+				if (options && opclass) {
+					res.push({
+						type: 'column',
+						value: column,
+						options: opts[i],
+						opclass: metadata.opclasses[i],
+					});
+				}
+			}
+		}
+
+		const columns = res.map((it) => {
+			return {
+				asc: !it.options.descending,
+				nullsFirst: it.options.nullsFirst,
+				opclass: it.opclass.default ? null : {
+					name: it.opclass.name,
+					default: it.opclass.default,
+				},
+				isExpression: it.type === 'expression',
+				value: it.type === 'expression' ? it.value : it.value.name, // column name
+			} satisfies Index['columns'][number];
+		});
+
+		indexes.push({
+			entityType: 'indexes',
+			schema: idx.schema,
+			table: table.name,
+			name: idx.name,
+			nameExplicit: true,
+			method: idx.accessMethod,
+			isUnique: metadata.isUnique,
+			with: idx.with?.join(', ') ?? '',
+			where: metadata.where,
+			columns: columns,
+			concurrently: false,
+			forUnique,
+			forPK,
+		});
+	}
+
+	progressCallback('columns', columnsCount, 'fetching');
+	progressCallback('checks', checksCount, 'fetching');
+	progressCallback('indexes', indexesCount, 'fetching');
+	progressCallback('tables', tableCount, 'done');
+
+	for (const it of columnsList.filter((x) => x.kind === 'm' || x.kind === 'v')) {
+		const view = viewsList.find((x) => x.oid === it.tableId)!;
+
+		const enumType = it.typeId in groupedEnums
+			? groupedEnums[it.typeId]
+			: it.typeId in groupedArrEnums
+			? groupedArrEnums[it.typeId]
+			: null;
+
+		let columnTypeMapped = enumType ? enumType.name : it.type.replace('[]', '');
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+		if (columnTypeMapped.startsWith('numeric(')) {
+			columnTypeMapped = columnTypeMapped.replace(',', ', ');
+		}
+
+		columnTypeMapped += '[]'.repeat(it.dimensions);
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char');
+
+		const typeDimensions = it.type.split('[]').length - 1;
+
+		viewColumns.push({
+			schema: view.schema,
+			view: view.name,
+			name: it.name,
+			type: columnTypeMapped,
+			notNull: it.notNull,
+			dimensions: it.dimensions,
+			typeDimensions,
+			typeSchema: enumType ? enumType.schema : null,
+		});
+	}
+
+	for (const view of viewsList) {
+		if (!filter({ type: 'table', schema: view.schema, name: view.name })) continue;
+		tableCount += 1;
+
+		const accessMethod = view.accessMethod === '0' ? null : ams.find((it) => it.oid === view.accessMethod);
+		const tablespace = view.tablespaceid === '0' ? null : tablespaces.find((it) => it.oid === view.tablespaceid)!.name;
+
+		const definition = parseViewDefinition(view.definition);
+		const withOpts = wrapRecord(
+			view.options?.reduce((acc, it) => {
+				const opt = it.split('=');
+				if (opt.length !== 2) {
+					throw new Error(`Unexpected view option: ${it}`);
+				}
+
+				const key = camelcase(opt[0].trim());
+				const value = opt[1].trim();
+				acc[key] = value;
+				return acc;
+			}, {} as Record<string, string>) ?? {},
+		);
+
+		const opts = {
+			checkOption: withOpts.literal('checkOption', ['local', 'cascaded']),
+			securityBarrier: withOpts.bool('securityBarrier'),
+			securityInvoker: withOpts.bool('securityInvoker'),
+			fillfactor: withOpts.num('fillfactor'),
+			toastTupleTarget: withOpts.num('toastTupleTarget'),
+			parallelWorkers: withOpts.num('parallelWorkers'),
+			autovacuumEnabled: withOpts.bool('autovacuumEnabled'),
+			vacuumIndexCleanup: withOpts.literal('vacuumIndexCleanup', ['auto', 'on', 'off']),
+			vacuumTruncate: withOpts.bool('vacuumTruncate'),
+			autovacuumVacuumThreshold: withOpts.num('autovacuumVacuumThreshold'),
+			autovacuumVacuumScaleFactor: withOpts.num('autovacuumVacuumScaleFactor'),
+			autovacuumVacuumCostDelay: withOpts.num('autovacuumVacuumCostDelay'),
+			autovacuumVacuumCostLimit: withOpts.num('autovacuumVacuumCostLimit'),
+			autovacuumFreezeMinAge: withOpts.num('autovacuumFreezeMinAge'),
+			autovacuumFreezeMaxAge: withOpts.num('autovacuumFreezeMaxAge'),
+			autovacuumFreezeTableAge: withOpts.num('autovacuumFreezeTableAge'),
+			autovacuumMultixactFreezeMinAge: withOpts.num('autovacuumMultixactFreezeMinAge'),
+			autovacuumMultixactFreezeMaxAge: withOpts.num('autovacuumMultixactFreezeMaxAge'),
+			autovacuumMultixactFreezeTableAge: withOpts.num('autovacuumMultixactFreezeTableAge'),
+			logAutovacuumMinDuration: withOpts.num('logAutovacuumMinDuration'),
+			userCatalogTable: withOpts.bool('userCatalogTable'),
+		};
+
+		const hasNonNullOpt = Object.values(opts).some((x) => x !== null);
+		views.push({
+			entityType: 'views',
+			schema: view.schema,
+			name: view.name,
+			definition,
+			with: hasNonNullOpt ? opts : null,
+			materialized: view.kind === 'm',
+			tablespace,
+			using: accessMethod?.name ?? null,
+			withNoData: null,
+		});
+	}
+
+	// TODO: update counts!
+	progressCallback('columns', columnsCount, 'done');
+	progressCallback('indexes', indexesCount, 'done');
+	progressCallback('fks', foreignKeysCount, 'done');
+	progressCallback('checks', checksCount, 'done');
+	progressCallback('views', viewsCount, 'done');
+
+	return {
+		schemas,
+		tables,
+		enums,
+		columns,
+		indexes,
+		pks,
+		fks,
+		uniques,
+		checks,
+		sequences,
+		roles,
+		privileges,
+		policies,
+		views,
+		viewColumns,
+	} satisfies InterimSchema;
+};
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+) => {
+	const res = await fromDatabase(db, filter, progressCallback);
+	res.schemas = res.schemas.filter((it) => it.name !== 'public');
+	res.indexes = res.indexes.filter((it) => !it.forPK && !it.forUnique);
+
+	return res;
+};
diff --git a/drizzle-kit/src/dialects/postgres/commutativity.ts b/drizzle-kit/src/dialects/postgres/commutativity.ts
new file mode 100644
index 0000000000..204bafcda2
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/commutativity.ts
@@ -0,0 +1,810 @@
+import {
+	AbstractCommutativity,
+	type CommutativityStatementDefinitions,
+	type CommutativityStatementInfo,
+} from '../../commutativity/engine';
+import type { ConflictTarget } from '../../commutativity/types';
+import { createDDL, type PostgresDDL } from './ddl';
+import { ddlDiffDry } from './diff';
+import { drySnapshot, type PostgresSnapshot } from './snapshot';
+import type { JsonStatement } from './statements';
+
+type FootprintTarget = {
+	schema: string;
+	objectName: string;
+	columnName: string;
+};
+
+type StatementInfo = CommutativityStatementInfo<JsonStatement, FootprintTarget>;
+
+type StatementDefinitions = CommutativityStatementDefinitions<
+	JsonStatement,
+	FootprintTarget
+>;
+
+function makeTarget(
+	schema: string,
+	objectName: string,
+	columnName = '',
+): FootprintTarget {
+	return { schema, objectName, columnName };
+}
+
+function makeTableTarget(schema: string, tableName: string): FootprintTarget {
+	return makeTarget(schema, tableName);
+}
+
+function makeSchemaTarget(schemaName: string): FootprintTarget {
+	return makeTarget(schemaName, '');
+}
+
+/**
+ * Postgres-specific commutativity rules.
+ *
+ * How to read this file:
+ * - `getStatementDefinitions()` is the main source of truth.
+ * - Each statement definition answers two questions:
+ *   1. `conflicts`: which other statement types are incompatible with this one.
+ *   2. `buildInfo`: which resource footprints this statement occupies.
+ * - `buildInfo().primary` is the exact resource touched by the statement.
+ * - `buildInfo().ancestors` are explicit parent resources, usually the owning table.
+ * - `getImplicitAncestors()` adds the schema-level footprint for every schema-bound
+ *   target, so schema operations can conflict with tables, columns, indexes, enums,
+ *   views, and sequences inside that schema.
+ *
+ * Practical guide for fixes:
+ * - False positive or missed conflict for same-level objects like column->column,
+ *   index->index, table->table, enum->enum:
+ *   change the `conflicts` array for the relevant statements in
+ *   `getStatementDefinitions()`.
+ * - False positive or missed conflict for parent/child relations like
+ *   table->column or table->index:
+ *   adjust the child's `ancestors` in `buildInfo()` and/or the parent's
+ *   `conflicts` array.
+ * - False positive or missed conflict for schema->table, schema->column,
+ *   schema->index, schema->enum, schema->view, or schema->sequence:
+ *   first check `schemaConflictTypes`, because that defines what schema
+ *   operations conflict with. If schema ancestry itself is wrong, adjust
+ *   `getImplicitAncestors()`.
+ * - Wrong human-readable conflict message only:
+ *   change `describeStatement()` or `schemaLevelActions`. Those affect reporting,
+ *   not matching semantics.
+ *
+ * Rule of thumb:
+ * - If the problem is "these two statement types should or should not conflict",
+ *   edit `conflicts`.
+ * - If the problem is "this statement is matched at the wrong scope",
+ *   edit `primary`, `ancestors`, or `getImplicitAncestors()`.
+ */
+class PostgresCommutativity extends AbstractCommutativity<
+	JsonStatement,
+	PostgresSnapshot,
+	FootprintTarget
+> {
+	private schemaLevelActions = new Set([
+		'create_table',
+		'drop_table',
+		'rename_table',
+		'move_table',
+		'remove_from_schema',
+		'set_new_schema',
+		'create_view',
+		'drop_view',
+		'alter_view',
+		'rename_view',
+		'move_view',
+		'create_enum',
+		'drop_enum',
+		'alter_enum',
+		'recreate_enum',
+		'rename_enum',
+		'move_enum',
+		'alter_type_drop_value',
+		'create_sequence',
+		'drop_sequence',
+		'alter_sequence',
+		'rename_sequence',
+		'move_sequence',
+		'create_schema',
+		'drop_schema',
+		'rename_schema',
+		'create_role',
+		'drop_role',
+		'alter_role',
+		'rename_role',
+	]);
+	private schemaConflictTypes: JsonStatement['type'][] = [
+		'create_schema',
+		'drop_schema',
+		'rename_schema',
+		'create_table',
+		'drop_table',
+		'rename_table',
+		'move_table',
+		'add_column',
+		'drop_column',
+		'alter_column',
+		'recreate_column',
+		'rename_column',
+		'create_index',
+		'drop_index',
+		'rename_index',
+		'recreate_index',
+		'add_pk',
+		'drop_pk',
+		'alter_pk',
+		'create_fk',
+		'drop_fk',
+		'recreate_fk',
+		'add_unique',
+		'drop_unique',
+		'alter_unique',
+		'add_check',
+		'drop_check',
+		'alter_check',
+		'rename_constraint',
+		'create_enum',
+		'drop_enum',
+		'rename_enum',
+		'alter_enum',
+		'recreate_enum',
+		'move_enum',
+		'alter_type_drop_value',
+		'create_sequence',
+		'drop_sequence',
+		'rename_sequence',
+		'alter_sequence',
+		'move_sequence',
+		'create_view',
+		'drop_view',
+		'rename_view',
+		'alter_view',
+		'move_view',
+		'create_policy',
+		'drop_policy',
+		'rename_policy',
+		'alter_policy',
+		'recreate_policy',
+		'alter_rls',
+		'grant_privilege',
+		'revoke_privilege',
+		'regrant_privilege',
+	];
+
+	protected override getStatementDefinitions(): StatementDefinitions {
+		return {
+			// Table operations
+			create_table: {
+				conflicts: ['create_table', 'drop_table', 'rename_table', 'move_table'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.table.schema, statement.table.name),
+					ancestors: [],
+				}),
+			},
+			drop_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'move_table',
+					'add_column',
+					'drop_column',
+					'alter_column',
+					'recreate_column',
+					'rename_column',
+					'alter_rls',
+					'create_index',
+					'recreate_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.table.schema, statement.table.name),
+					ancestors: [],
+				}),
+			},
+			rename_table: {
+				conflicts: ['create_table', 'drop_table', 'rename_table', 'move_table', 'create_index'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.schema, statement.from),
+					ancestors: [],
+				}),
+			},
+			move_table: {
+				conflicts: ['create_table', 'drop_table', 'rename_table', 'move_table'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.from, statement.name),
+					ancestors: [],
+				}),
+			},
+
+			// Column operations
+			add_column: {
+				conflicts: ['add_column', 'alter_column', 'drop_column', 'rename_column', 'recreate_column'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.schema, statement.column.table, statement.column.name),
+					ancestors: [makeTableTarget(statement.column.schema, statement.column.table)],
+				}),
+			},
+			drop_column: {
+				conflicts: ['add_column', 'drop_column', 'alter_column', 'rename_column', 'recreate_column'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.schema, statement.column.table, statement.column.name),
+					ancestors: [makeTableTarget(statement.column.schema, statement.column.table)],
+				}),
+			},
+			alter_column: {
+				conflicts: ['add_column', 'drop_column', 'alter_column', 'rename_column', 'recreate_column'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.to.schema, statement.to.table, statement.to.name),
+					ancestors: [makeTableTarget(statement.to.schema, statement.to.table)],
+				}),
+			},
+			recreate_column: {
+				conflicts: ['add_column', 'drop_column', 'alter_column', 'recreate_column', 'rename_column'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.diff.schema, statement.diff.table, statement.diff.name),
+					ancestors: [makeTableTarget(statement.diff.schema, statement.diff.table)],
+				}),
+			},
+			rename_column: {
+				conflicts: ['add_column', 'drop_column', 'alter_column', 'recreate_column', 'rename_column'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.schema, statement.from.table, statement.from.name),
+					ancestors: [makeTableTarget(statement.from.schema, statement.from.table)],
+				}),
+			},
+
+			// Index operations
+			create_index: {
+				conflicts: ['create_index', 'drop_index', 'rename_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.schema, statement.index.name),
+					ancestors: [makeTableTarget(statement.index.schema, statement.index.table)],
+				}),
+			},
+			drop_index: {
+				conflicts: ['create_index', 'drop_index', 'rename_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.schema, statement.index.name),
+					ancestors: [makeTableTarget(statement.index.schema, statement.index.table)],
+				}),
+			},
+			rename_index: {
+				conflicts: ['create_index', 'drop_index', 'rename_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.schema, statement.from),
+					ancestors: [],
+				}),
+			},
+			recreate_index: {
+				conflicts: ['create_index', 'drop_index', 'rename_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.diff.schema, statement.diff.name),
+					ancestors: [makeTableTarget(statement.index.schema, statement.index.table)],
+				}),
+			},
+
+			// Primary key operations
+			add_pk: {
+				conflicts: ['add_pk', 'drop_pk', 'alter_pk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.pk.schema, statement.pk.table),
+					ancestors: [],
+				}),
+			},
+			drop_pk: {
+				conflicts: ['add_pk', 'drop_pk', 'alter_pk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.pk.schema, statement.pk.table),
+					ancestors: [],
+				}),
+			},
+			alter_pk: {
+				conflicts: ['add_pk', 'drop_pk', 'alter_pk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.pk.schema, statement.pk.table),
+					ancestors: [],
+				}),
+			},
+
+			// Foreign key operations
+			create_fk: {
+				conflicts: ['create_fk', 'drop_fk', 'recreate_fk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.fk.schema, statement.fk.table),
+					ancestors: [],
+				}),
+			},
+			drop_fk: {
+				conflicts: ['create_fk', 'drop_fk', 'recreate_fk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.fk.schema, statement.fk.table),
+					ancestors: [],
+				}),
+			},
+			recreate_fk: {
+				conflicts: ['create_fk', 'drop_fk', 'recreate_fk'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.fk.schema, statement.fk.table),
+					ancestors: [],
+				}),
+			},
+
+			// Unique constraint operations
+			add_unique: {
+				conflicts: ['add_unique', 'drop_unique', 'alter_unique'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.unique.schema, statement.unique.table),
+					ancestors: [],
+				}),
+			},
+			drop_unique: {
+				conflicts: ['add_unique', 'drop_unique', 'alter_unique'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.unique.schema, statement.unique.table),
+					ancestors: [],
+				}),
+			},
+			alter_unique: {
+				conflicts: ['add_unique', 'drop_unique', 'alter_unique'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget((statement as any).diff.schema, (statement as any).diff.table),
+					ancestors: [],
+				}),
+			},
+
+			// Check constraint operations
+			add_check: {
+				conflicts: ['add_check', 'drop_check', 'alter_check'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.check.schema, statement.check.table),
+					ancestors: [],
+				}),
+			},
+			drop_check: {
+				conflicts: ['add_check', 'drop_check', 'alter_check'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.check.schema, statement.check.table),
+					ancestors: [],
+				}),
+			},
+			alter_check: {
+				conflicts: ['add_check', 'drop_check', 'alter_check'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.diff.schema, statement.diff.table),
+					ancestors: [],
+				}),
+			},
+
+			// Constraint operations
+			rename_constraint: {
+				conflicts: [
+					'rename_constraint',
+					'add_pk',
+					'drop_pk',
+					'alter_pk',
+					'add_unique',
+					'drop_unique',
+					'alter_unique',
+					'add_check',
+					'drop_check',
+					'alter_check',
+					'create_fk',
+					'drop_fk',
+					'recreate_fk',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.schema, statement.table),
+					ancestors: [],
+				}),
+			},
+
+			// Enum operations
+			create_enum: {
+				conflicts: ['create_enum', 'drop_enum', 'rename_enum', 'alter_enum', 'recreate_enum', 'move_enum'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.enum.schema, statement.enum.name),
+					ancestors: [],
+				}),
+			},
+			drop_enum: {
+				conflicts: [
+					'create_enum',
+					'drop_enum',
+					'rename_enum',
+					'alter_enum',
+					'recreate_enum',
+					'move_enum',
+					'alter_type_drop_value',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.enum.schema, statement.enum.name),
+					ancestors: [],
+				}),
+			},
+			rename_enum: {
+				conflicts: ['create_enum', 'drop_enum', 'rename_enum', 'alter_enum', 'recreate_enum', 'move_enum'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.schema, statement.from),
+					ancestors: [],
+				}),
+			},
+			alter_enum: {
+				conflicts: [
+					'create_enum',
+					'drop_enum',
+					'rename_enum',
+					'alter_enum',
+					'recreate_enum',
+					'move_enum',
+					'alter_type_drop_value',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.to.schema, statement.to.name),
+					ancestors: [],
+				}),
+			},
+			recreate_enum: {
+				conflicts: ['create_enum', 'drop_enum', 'rename_enum', 'alter_enum', 'recreate_enum', 'move_enum'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.to.schema, statement.to.name),
+					ancestors: [],
+				}),
+			},
+			move_enum: {
+				conflicts: ['create_enum', 'drop_enum', 'rename_enum', 'alter_enum', 'recreate_enum', 'move_enum'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.schema || 'public', statement.from.name),
+					ancestors: [],
+				}),
+			},
+			alter_type_drop_value: {
+				conflicts: ['drop_enum', 'alter_enum', 'alter_type_drop_value'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.enum.schema, statement.enum.name),
+					ancestors: [],
+				}),
+			},
+
+			// Sequence operations
+			create_sequence: {
+				conflicts: ['create_sequence', 'drop_sequence', 'rename_sequence', 'alter_sequence', 'move_sequence'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.sequence.schema, statement.sequence.name),
+					ancestors: [],
+				}),
+			},
+			drop_sequence: {
+				conflicts: ['create_sequence', 'drop_sequence', 'rename_sequence', 'alter_sequence', 'move_sequence'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.sequence.schema, statement.sequence.name),
+					ancestors: [],
+				}),
+			},
+			rename_sequence: {
+				conflicts: ['create_sequence', 'drop_sequence', 'rename_sequence', 'alter_sequence', 'move_sequence'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.schema, statement.from.name),
+					ancestors: [],
+				}),
+			},
+			alter_sequence: {
+				conflicts: ['create_sequence', 'drop_sequence', 'rename_sequence', 'alter_sequence', 'move_sequence'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.sequence.schema, statement.sequence.name),
+					ancestors: [],
+				}),
+			},
+			move_sequence: {
+				conflicts: ['create_sequence', 'drop_sequence', 'rename_sequence', 'alter_sequence', 'move_sequence'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.schema || 'public', statement.from.name),
+					ancestors: [],
+				}),
+			},
+
+			// View operations
+			create_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view', 'move_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.schema, statement.view.name),
+					ancestors: [],
+				}),
+			},
+			drop_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view', 'move_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.schema, statement.view.name),
+					ancestors: [],
+				}),
+			},
+			rename_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view', 'move_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.schema, statement.from.name),
+					ancestors: [],
+				}),
+			},
+			alter_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view', 'move_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.schema, statement.view.name),
+					ancestors: [],
+				}),
+			},
+			move_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view', 'alter_view', 'move_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.fromSchema, statement.view.name),
+					ancestors: [],
+				}),
+			},
+
+			// Schema operations
+			create_schema: {
+				conflicts: this.schemaConflictTypes,
+				buildInfo: (statement) => ({
+					primary: makeSchemaTarget(statement.name),
+					ancestors: [],
+				}),
+			},
+			drop_schema: {
+				conflicts: this.schemaConflictTypes,
+				buildInfo: (statement) => ({
+					primary: makeSchemaTarget(statement.name),
+					ancestors: [],
+				}),
+			},
+			rename_schema: {
+				conflicts: this.schemaConflictTypes,
+				buildInfo: (statement) => ({
+					primary: makeSchemaTarget(statement.from.name),
+					ancestors: [],
+				}),
+			},
+
+			// Policy operations
+			create_policy: {
+				conflicts: ['create_policy', 'drop_policy', 'rename_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.policy.schema, statement.policy.table),
+					ancestors: [],
+				}),
+			},
+			drop_policy: {
+				conflicts: ['create_policy', 'drop_policy', 'rename_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.policy.schema, statement.policy.table),
+					ancestors: [],
+				}),
+			},
+			rename_policy: {
+				conflicts: ['create_policy', 'drop_policy', 'rename_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.from.schema, statement.from.table),
+					ancestors: [],
+				}),
+			},
+			alter_policy: {
+				conflicts: ['create_policy', 'drop_policy', 'rename_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.policy.schema, statement.policy.table),
+					ancestors: [],
+				}),
+			},
+			recreate_policy: {
+				conflicts: ['create_policy', 'drop_policy', 'rename_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget(statement.policy.schema, statement.policy.table),
+					ancestors: [],
+				}),
+			},
+
+			// RLS operations
+			alter_rls: {
+				conflicts: ['alter_rls', 'create_policy', 'drop_policy', 'alter_policy', 'recreate_policy'],
+				buildInfo: (statement) => ({
+					primary: makeTableTarget((statement as any).schema, (statement as any).name),
+					ancestors: [],
+				}),
+			},
+
+			// Role operations
+			create_role: {
+				conflicts: ['create_role', 'drop_role', 'rename_role', 'alter_role'],
+				buildInfo: (statement) => ({
+					primary: makeTarget('', statement.role.name),
+					ancestors: [],
+				}),
+			},
+			drop_role: {
+				conflicts: [
+					'create_role',
+					'drop_role',
+					'rename_role',
+					'alter_role',
+					'grant_privilege',
+					'revoke_privilege',
+					'regrant_privilege',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget('', statement.role.name),
+					ancestors: [],
+				}),
+			},
+			rename_role: {
+				conflicts: ['create_role', 'drop_role', 'rename_role', 'alter_role'],
+				buildInfo: (statement) => ({
+					primary: makeTarget('', statement.from.name),
+					ancestors: [],
+				}),
+			},
+			alter_role: {
+				conflicts: ['create_role', 'drop_role', 'rename_role', 'alter_role'],
+				buildInfo: (statement) => ({
+					primary: makeTarget('', statement.role.name),
+					ancestors: [],
+				}),
+			},
+
+			// Privilege operations
+			grant_privilege: {
+				conflicts: ['grant_privilege', 'revoke_privilege', 'regrant_privilege'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.privilege.schema || '', statement.privilege.table || ''),
+					ancestors: [],
+				}),
+			},
+			revoke_privilege: {
+				conflicts: ['grant_privilege', 'revoke_privilege', 'regrant_privilege'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.privilege.schema || '', statement.privilege.table || ''),
+					ancestors: [],
+				}),
+			},
+			regrant_privilege: {
+				conflicts: ['grant_privilege', 'revoke_privilege', 'regrant_privilege'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.privilege.schema || '', statement.privilege.table || ''),
+					ancestors: [],
+				}),
+			},
+		};
+	}
+
+	protected override formatFootprintTarget(
+		action: JsonStatement['type'],
+		target: FootprintTarget,
+	): string {
+		return `${action};${target.schema};${target.objectName};${target.columnName}`;
+	}
+
+	protected override describeStatement(
+		statement: JsonStatement,
+		info: StatementInfo,
+	): string {
+		if (statement.type === 'create_index' || statement.type === 'drop_index') {
+			return `${statement.type}: ${statement.index.name} on ${statement.index.table} table`;
+		}
+
+		if (statement.type === 'recreate_index') {
+			return `${statement.type}: ${statement.index.name} on ${statement.index.table} table`;
+		}
+
+		if (
+			info.action === 'create_schema'
+			|| info.action === 'drop_schema'
+			|| info.action === 'rename_schema'
+		) {
+			return `${info.action}: ${info.primary.schema} schema`;
+		}
+
+		if (this.schemaLevelActions.has(info.action)) {
+			const container = info.primary.schema || 'schema';
+			return `${info.action}: ${info.primary.objectName} in ${container} schema`;
+		}
+
+		if (info.primary.columnName) {
+			return `${info.action}: ${info.primary.columnName} on ${info.primary.objectName} table`;
+		}
+
+		return `${info.action} on ${info.primary.objectName} table`;
+	}
+
+	private enumLevelActions = new Set([
+		'create_enum',
+		'drop_enum',
+		'alter_enum',
+		'recreate_enum',
+		'rename_enum',
+		'move_enum',
+		'alter_type_drop_value',
+	]);
+
+	private viewLevelActions = new Set([
+		'create_view',
+		'drop_view',
+		'alter_view',
+		'rename_view',
+		'move_view',
+	]);
+
+	private sequenceLevelActions = new Set([
+		'create_sequence',
+		'drop_sequence',
+		'alter_sequence',
+		'rename_sequence',
+		'move_sequence',
+	]);
+
+	protected override describeStatementTarget(
+		statement: JsonStatement,
+		info: StatementInfo,
+	): ConflictTarget {
+		if (
+			statement.type === 'create_index'
+			|| statement.type === 'drop_index'
+			|| statement.type === 'recreate_index'
+		) {
+			return { kind: 'index', name: statement.index.name, table: statement.index.table };
+		}
+
+		if (
+			info.action === 'create_schema'
+			|| info.action === 'drop_schema'
+			|| info.action === 'rename_schema'
+		) {
+			return { kind: 'schema', name: info.primary.schema };
+		}
+
+		if (this.enumLevelActions.has(info.action)) {
+			return { kind: 'enum', name: info.primary.objectName, schema: info.primary.schema };
+		}
+
+		if (this.viewLevelActions.has(info.action)) {
+			return { kind: 'view', name: info.primary.objectName, schema: info.primary.schema };
+		}
+
+		if (this.sequenceLevelActions.has(info.action)) {
+			return { kind: 'sequence', name: info.primary.objectName, schema: info.primary.schema };
+		}
+
+		if (info.primary.columnName) {
+			return {
+				kind: 'column',
+				name: info.primary.columnName,
+				table: info.primary.objectName,
+				schema: info.primary.schema,
+			};
+		}
+
+		return { kind: 'table', name: info.primary.objectName, schema: info.primary.schema };
+	}
+
+	protected override getImplicitAncestors(target: FootprintTarget): FootprintTarget[] {
+		if (target.schema === '' || (target.objectName === '' && target.columnName === '')) {
+			return [];
+		}
+
+		return [makeSchemaTarget(target.schema)];
+	}
+
+	protected override getDrySnapshot(): PostgresSnapshot {
+		return drySnapshot;
+	}
+
+	protected override async diffSnapshots(
+		fromSnapshot: PostgresSnapshot,
+		toSnapshot: PostgresSnapshot,
+	): Promise<{ statements: JsonStatement[] }> {
+		const fromDDL: PostgresDDL = createDDL();
+		const toDDL: PostgresDDL = createDDL();
+
+		fromDDL.entities.pushAll(fromSnapshot.ddl);
+		toDDL.entities.pushAll(toSnapshot.ddl);
+
+		const { statements } = await ddlDiffDry(fromDDL, toDDL, 'default');
+		return { statements };
+	}
+}
+
+export const postgresCommutativity = new PostgresCommutativity();
diff --git a/drizzle-kit/src/dialects/postgres/convertor.ts b/drizzle-kit/src/dialects/postgres/convertor.ts
new file mode 100644
index 0000000000..85cf5a7829
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/convertor.ts
@@ -0,0 +1,1152 @@
+import { escapeSingleQuotes, type Simplify, wrapWith } from '../../utils';
+import { defaultNameForPK, defaults, defaultToSQL, isDefaultAction, isSerialType, mapSerialToInt } from './grammar';
+import type { JsonStatement } from './statements';
+
+export const convertor = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	convertor: (statement: Simplify<Omit<TStatement, 'type'>>) => string | string[],
+) => {
+	return {
+		type,
+		can: (st: JsonStatement) => {
+			return st.type === type;
+		},
+		convert: convertor,
+	};
+};
+
+const createSchemaConvertor = convertor('create_schema', (st) => {
+	return `CREATE SCHEMA "${st.name}";\n`;
+});
+
+const dropSchemaConvertor = convertor('drop_schema', (st) => {
+	return `DROP SCHEMA "${st.name}";\n`;
+});
+
+const renameSchemaConvertor = convertor('rename_schema', (st) => {
+	return `ALTER SCHEMA "${st.from.name}" RENAME TO "${st.to.name}";\n`;
+});
+
+const createViewConvertor = convertor('create_view', (st) => {
+	const { definition, name: viewName, schema, with: withOption, materialized, withNoData, tablespace, using } = st.view;
+
+	const name = schema !== 'public' ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+	let statement = materialized ? `CREATE MATERIALIZED VIEW ${name}` : `CREATE VIEW ${name}`;
+	if (using) statement += ` USING "${using}"`;
+
+	const options: string[] = [];
+	if (withOption) {
+		statement += ` WITH (`;
+		for (const [key, value] of Object.entries(withOption)) {
+			if (value === null) continue;
+			options.push(`${key.snake_case()} = ${value}`);
+		}
+		statement += options.join(', ');
+		statement += `)`;
+	}
+
+	if (tablespace) statement += ` TABLESPACE ${tablespace}`;
+	statement += ` AS (${definition})`;
+	if (withNoData) statement += ` WITH NO DATA`;
+	statement += `;`;
+
+	return statement;
+});
+
+const dropViewConvertor = convertor('drop_view', (st) => {
+	const { name: viewName, schema, materialized } = st.view;
+	const name = schema !== 'public' ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+	return `DROP${materialized ? ' MATERIALIZED' : ''} VIEW ${name};`;
+});
+
+const renameViewConvertor = convertor('rename_view', (st) => {
+	const materialized = st.from.materialized;
+	const nameFrom = st.from.schema !== 'public' ? `"${st.from.schema}"."${st.from.name}"` : `"${st.from.name}"`;
+
+	return `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW ${nameFrom} RENAME TO "${st.to.name}";`;
+});
+
+const moveViewConvertor = convertor('move_view', (st) => {
+	const { fromSchema, toSchema, view } = st;
+	const from = fromSchema === 'public' ? `"${view.name}"` : `"${fromSchema}"."${view.name}"`;
+	return `ALTER${view.materialized ? ' MATERIALIZED' : ''} VIEW ${from} SET SCHEMA "${toSchema}";`;
+});
+
+const alterViewConvertor = convertor('alter_view', (st) => {
+	const diff = st.diff;
+
+	const statements = [] as string[];
+	const key = st.view.schema !== 'public' ? `"${st.view.schema}"."${st.view.name}"` : `"${st.view.name}"`;
+	const viewClause = st.view.materialized ? `MATERIALIZED VIEW ${key}` : `VIEW ${key}`;
+
+	const withFrom = diff.with?.from || {};
+	const withTo = diff.with?.to || {};
+
+	const resetOptions = Object.entries(withFrom).filter(([key, val]) => {
+		return val !== null && (key in withTo ? withTo[key as keyof typeof withTo] === null : true);
+	}).map((it) => it[0].snake_case());
+
+	const setOptions = Object.entries(withTo).filter(([key, val]) => {
+		const from = key in withFrom ? withFrom[key as keyof typeof withFrom] : null;
+		return val !== null && from !== val;
+	}).map((it) => `${it[0].snake_case()} = ${it[1]}`).join(', ');
+
+	if (setOptions.length > 0) statements.push(`ALTER ${viewClause} SET (${setOptions});`);
+	if (resetOptions.length > 0) statements.push(`ALTER ${viewClause} RESET (${resetOptions.join(', ')});`);
+	// TODO: reset missing options, set changed options and new options?
+
+	if (diff.tablespace) {
+		const to = diff.tablespace.to || defaults.tablespace;
+		statements.push(`ALTER ${viewClause} SET TABLESPACE "${to}";`);
+	}
+
+	if (diff.using) {
+		const toUsing = diff.using.to ?? defaults.accessMethod;
+		statements.push(`ALTER ${viewClause} SET ACCESS METHOD "${toUsing}";`);
+	}
+
+	return statements;
+});
+
+const createTableConvertor = convertor('create_table', (st) => {
+	const { schema, name, columns, pk, uniques, checks, policies, isRlsEnabled } = st.table;
+
+	const statements = [] as string[];
+	let statement = '';
+	const key = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	statement += `CREATE TABLE ${key} (\n`;
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+
+		const isPK = pk && pk.columns.length === 1 && pk.columns[0] === column.name
+			&& pk.name === defaultNameForPK(column.table);
+		const isSerial = isSerialType(column.type);
+
+		const primaryKeyStatement = isPK ? ' PRIMARY KEY' : '';
+		const notNullStatement = pk?.columns.includes(column.name) || isSerial
+			? ''
+			: column.notNull && !column.identity
+			? ' NOT NULL'
+			: '';
+		const defaultStatement = column.default ? ` DEFAULT ${defaultToSQL(column)}` : '';
+
+		const unique = uniques.find((u) => u.columns.length === 1 && u.columns[0] === column.name);
+
+		const unqiueConstraintPrefix = unique
+			? unique.nameExplicit ? `CONSTRAINT "${unique.name}" UNIQUE` : 'UNIQUE'
+			: '';
+
+		const uniqueConstraintStatement = unique
+			? ` ${unqiueConstraintPrefix}${unique.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''}`
+			: '';
+
+		const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+			? `"${column.typeSchema}".`
+			: '';
+
+		const colType = column.typeSchema
+			? `"${column.type}"`
+			: column.type;
+		const type = `${schemaPrefix}${colType}${'[]'.repeat(column.dimensions)}`;
+
+		const generated = column.generated;
+
+		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+		const identityWithSchema = schema !== 'public'
+			? `"${schema}"."${column.identity?.name}"`
+			: `"${column.identity?.name}"`;
+
+		const identity = column.identity
+			? ` GENERATED ${
+				column.identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+			} AS IDENTITY (sequence name ${identityWithSchema}${
+				column.identity.increment
+					? ` INCREMENT BY ${column.identity.increment}`
+					: ''
+			}${
+				column.identity.minValue
+					? ` MINVALUE ${column.identity.minValue}`
+					: ''
+			}${
+				column.identity.maxValue
+					? ` MAXVALUE ${column.identity.maxValue}`
+					: ''
+			}${
+				column.identity.startWith
+					? ` START WITH ${column.identity.startWith}`
+					: ''
+			}${column.identity.cache ? ` CACHE ${column.identity.cache}` : ''}${column.identity.cycle ? ` CYCLE` : ''})`
+			: '';
+
+		statement += '\t'
+			+ `"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${uniqueConstraintStatement}${identity}`;
+		statement += i === columns.length - 1 ? '' : ',\n';
+	}
+
+	if (pk && (pk.columns.length > 1 || pk.name !== defaultNameForPK(st.table.name))) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT "${pk.name}" PRIMARY KEY("${pk.columns.join(`","`)}")`;
+	}
+
+	for (const it of uniques.filter((u) => u.columns.length > 1)) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT "${it.name}" UNIQUE${it.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''}("${
+			it.columns.join(`","`)
+		}")`;
+	}
+
+	for (const check of checks) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT "${check.name}" CHECK (${check.value})`;
+	}
+
+	statement += `\n);`;
+	statement += `\n`;
+	statements.push(statement);
+
+	if (policies && policies.length > 0 || isRlsEnabled) {
+		statements.push(toggleRlsConvertor.convert({
+			isRlsEnabled: true,
+			name: st.table.name,
+			schema: st.table.schema,
+		}) as string);
+	}
+
+	return statements;
+});
+
+const dropTableConvertor = convertor('drop_table', (st) => {
+	const { name, schema, policies } = st.table;
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${name}"`
+		: `"${name}"`;
+
+	const droppedPolicies = policies.map((policy) => dropPolicyConvertor.convert({ policy }) as string);
+
+	return [
+		...droppedPolicies,
+		`DROP TABLE ${tableNameWithSchema};`,
+	];
+});
+
+const renameTableConvertor = convertor('rename_table', (st) => {
+	const schemaPrefix = st.schema !== 'public'
+		? `"${st.schema}".`
+		: '';
+
+	return `ALTER TABLE ${schemaPrefix}"${st.from}" RENAME TO "${st.to}";`;
+});
+
+const moveTableConvertor = convertor('move_table', (st) => {
+	const from = st.from !== 'public' ? `"${st.from}"."${st.name}"` : `"${st.name}"`;
+
+	return `ALTER TABLE ${from} SET SCHEMA "${st.to}";\n`;
+});
+
+const addColumnConvertor = convertor('add_column', (st) => {
+	const { schema, table, name, identity, generated } = st.column;
+	const column = st.column;
+
+	const primaryKeyStatement = st.isPK ? ' PRIMARY KEY' : '';
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	const defaultStatement = column.default ? ` DEFAULT ${defaultToSQL(column)}` : '';
+
+	const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+		? `"${column.typeSchema}".`
+		: '';
+
+	const type = column.typeSchema
+		? `"${column.type}"`
+		: column.type;
+	let fixedType = `${schemaPrefix}${type}${'[]'.repeat(column.dimensions)}`;
+
+	const isSerial = isSerialType(column.type);
+
+	const notNullStatement = column.notNull && !identity && !generated && !isSerial && !st.isCompositePK
+		? ' NOT NULL'
+		: '';
+
+	const identityWithSchema = schema !== 'public'
+		? `"${schema}"."${identity?.name}"`
+		: `"${identity?.name}"`;
+
+	const identityStatement = identity
+		? ` GENERATED ${
+			identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+		} AS IDENTITY (sequence name ${identityWithSchema}${
+			identity.increment
+				? ` INCREMENT BY ${identity.increment}`
+				: ''
+		}${
+			identity.minValue
+				? ` MINVALUE ${identity.minValue}`
+				: ''
+		}${
+			identity.maxValue
+				? ` MAXVALUE ${identity.maxValue}`
+				: ''
+		}${
+			identity.startWith
+				? ` START WITH ${identity.startWith}`
+				: ''
+		}${identity.cache ? ` CACHE ${identity.cache}` : ''}${identity.cycle ? ` CYCLE` : ''})`
+		: '';
+
+	const generatedStatement = column.generated ? ` GENERATED ALWAYS AS (${column.generated.as}) STORED` : '';
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
+});
+
+const dropColumnConvertor = convertor('drop_column', (st) => {
+	const { schema, table, name } = st.column;
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${name}";`;
+});
+
+const renameColumnConvertor = convertor('rename_column', (st) => {
+	const { table, schema } = st.from;
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${st.from.name}" TO "${st.to.name}";`;
+});
+
+const recreateColumnConvertor = convertor('recreate_column', (st) => {
+	// AlterTableAlterColumnSetExpressionConvertor
+	// AlterTableAlterColumnAlterGeneratedConvertor
+
+	const r = st.diff.$right;
+	const drop = dropColumnConvertor.convert({ column: r }) as string;
+	const add = addColumnConvertor.convert({ column: r, isPK: st.isPK, isCompositePK: false }) as string;
+
+	return [drop, add];
+});
+
+const recreateIndexConvertor = convertor('recreate_index', (st) => {
+	// AlterTableAlterColumnSetExpressionConvertor
+	// AlterTableAlterColumnAlterGeneratedConvertor
+
+	const drop = dropIndexConvertor.convert({ index: st.index }) as string;
+	const add = createIndexConvertor.convert({ index: st.index }) as string;
+
+	return [drop, add];
+});
+
+const alterColumnConvertor = convertor('alter_column', (st) => {
+	const { diff, to: column, isEnum, wasEnum, wasSerial, toSerial } = st;
+	const statements = [] as string[];
+
+	const key = column.schema !== 'public'
+		? `"${column.schema}"."${column.table}"`
+		: `"${column.table}"`;
+
+	const recreateDefault = diff.type && (isEnum || wasEnum) && (diff.$left.default);
+	if (recreateDefault) {
+		statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+	}
+
+	if (diff.type) {
+		const typeSchema = column.typeSchema && column.typeSchema !== 'public' ? `"${column.typeSchema}".` : '';
+		const textProxy = wasEnum && isEnum ? 'text::' : ''; // using enum1::text::enum2
+		const suffix = isEnum
+			? ` USING "${column.name}"::${textProxy}${typeSchema}"${column.type}"${'[]'.repeat(column.dimensions)}`
+			: ` USING "${column.name}"::${toSerial ? mapSerialToInt(column.type) : column.type}${
+				'[]'.repeat(column.dimensions)
+			}`;
+
+		const type = diff.typeSchema?.to && diff.typeSchema.to !== 'public'
+			? `"${diff.typeSchema.to}"."${diff.type.to}"`
+			: isEnum
+			? `"${diff.type.to}"`
+			: toSerial
+			? mapSerialToInt(diff.type.to)
+			: diff.type.to;
+
+		if (wasSerial) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+			const sequenceKey = column.schema !== 'public'
+				? `"${column.schema}"."${column.table}_${column.name}_seq"`
+				: `"${column.table}_${column.name}_seq"`;
+			statements.push(`DROP SEQUENCE ${sequenceKey};`);
+		}
+
+		if (toSerial) {
+			const sequenceKey = column.schema !== 'public'
+				? `"${column.schema}"."${column.table}_${column.name}_seq"`
+				: `"${column.table}_${column.name}_seq"`;
+			const sequenceName = column.schema !== 'public'
+				? `${column.schema}.${column.table}_${column.name}_seq`
+				: `${column.table}_${column.name}_seq`;
+
+			statements.push(`CREATE SEQUENCE ${sequenceKey};`);
+			statements.push(
+				`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT nextval('${sequenceName}')`,
+			);
+			statements.push(`ALTER SEQUENCE ${sequenceKey} OWNED BY "${column.schema}"."${column.table}"."${column.name}";`);
+		}
+
+		statements.push(
+			`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE ${type}${
+				'[]'.repeat(column.dimensions)
+			}${suffix};`,
+		);
+
+		if (recreateDefault && column.default) {
+			statements.push(
+				`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${defaultToSQL(column)};`,
+			);
+		}
+	}
+
+	if (diff.default && !recreateDefault) {
+		if (diff.default.to) {
+			statements.push(
+				`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${defaultToSQL(diff.$right)};`,
+			);
+		} else {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+		}
+	}
+
+	if (diff.generated && diff.generated.to === null) {
+		statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP EXPRESSION;`);
+	}
+
+	if (diff.identity) {
+		if (diff.identity.from === null) {
+			const identity = column.identity!;
+			const identityWithSchema = column.schema !== 'public'
+				? `"${column.schema}"."${identity.name}"`
+				: `"${identity.name}"`;
+			const typeClause = identity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+			const incrementClause = identity.increment ? ` INCREMENT BY ${identity.increment}` : '';
+			const minClause = identity.minValue ? ` MINVALUE ${identity.minValue}` : '';
+			const maxClause = identity.maxValue ? ` MAXVALUE ${identity.maxValue}` : '';
+			const startWith = identity.startWith ? ` START WITH ${identity.startWith}` : '';
+			const cache = identity.cache ? ` CACHE ${identity.cache}` : '';
+			const cycle = identity.cycle ? ` CYCLE` : '';
+			const identityStatement =
+				`GENERATED ${typeClause} AS IDENTITY (sequence name ${identityWithSchema}${incrementClause}${minClause}${maxClause}${startWith}${cache}${cycle})`;
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" ADD ${identityStatement};`);
+
+			if (wasSerial && column.identity) {
+				statements.push(
+					`SELECT setval('${column.identity.name}'::regclass, (SELECT COALESCE(MAX(id), 1) FROM ${key}), false);`,
+				);
+			}
+		} else if (diff.identity.to === null) {
+			statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP IDENTITY;`);
+		} else {
+			const { from, to } = diff.identity;
+
+			if (from.type !== to.type) {
+				const typeClause = to.type === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET GENERATED ${typeClause};`);
+			}
+			if (from.minValue !== to.minValue) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET MINVALUE ${to.minValue};`);
+			}
+
+			if (from.maxValue !== to.maxValue) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET MAXVALUE ${to.maxValue};`);
+			}
+
+			if (from.increment !== to.increment) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET INCREMENT BY ${to.increment};`);
+			}
+
+			if (from.startWith !== to.startWith) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET START WITH ${to.startWith};`);
+			}
+
+			if (from.cache !== to.cache) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET CACHE ${to.cache};`);
+			}
+
+			if (from.cycle !== to.cycle) {
+				statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET ${to.cycle ? `CYCLE` : 'NO CYCLE'};`);
+			}
+		}
+	}
+
+	if (diff.notNull && !(diff.notNull.to && diff.identity && diff.identity.to)) {
+		const clause = diff.notNull.to ? 'SET NOT NULL' : 'DROP NOT NULL';
+		statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" ${clause};`);
+	}
+
+	return statements;
+});
+
+const createIndexConvertor = convertor('create_index', (st) => {
+	const {
+		schema,
+		table,
+		name,
+		columns,
+		isUnique,
+		concurrently,
+		with: w,
+		method,
+		where,
+	} = st.index;
+	const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+	const value = columns
+		.map((it) => {
+			const expr = it.isExpression ? it.value : `"${it.value}"`;
+			const opcl = it.opclass && !it.opclass.default ? ` ${it.opclass.name}` : '';
+
+			// ASC - default
+			const ord = it.asc ? '' : ' DESC';
+
+			// skip if asc+nulls last or desc+nulls first
+			const nulls = (it.asc && !it.nullsFirst) || (!it.asc && it.nullsFirst)
+				? ''
+				: it.nullsFirst
+				? ' NULLS FIRST'
+				: ' NULLS LAST';
+
+			return `${expr}${opcl}${ord}${nulls}`;
+		}).join(',');
+
+	const key = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	const concur = concurrently ? ' CONCURRENTLY' : '';
+	const withClause = w ? ` WITH (${w})` : '';
+	const whereClause = where ? ` WHERE ${where}` : '';
+	const using = method !== defaults.index.method ? ` USING ${method}` : '';
+	return `CREATE ${indexPart}${concur} "${name}" ON ${key}${using} (${value})${withClause}${whereClause};`;
+});
+
+const dropIndexConvertor = convertor('drop_index', (st) => {
+	const { schema } = st.index;
+
+	const key = schema !== 'public'
+		? `"${schema}".`
+		: '';
+
+	return `DROP INDEX ${key}"${st.index.name}";`;
+});
+
+const renameIndexConvertor = convertor('rename_index', (st) => {
+	const key = st.schema !== 'public' ? `"${st.schema}"."${st.from}"` : `"${st.from}"`;
+
+	return `ALTER INDEX ${key} RENAME TO "${st.to}";`;
+});
+
+const addPrimaryKeyConvertor = convertor('add_pk', (st) => {
+	const { pk } = st;
+	const key = pk.schema !== 'public'
+		? `"${pk.schema}"."${pk.table}"`
+		: `"${pk.table}"`;
+
+	if (!pk.nameExplicit) {
+		return `ALTER TABLE ${key} ADD PRIMARY KEY ("${pk.columns.join('","')}");`;
+	}
+	return `ALTER TABLE ${key} ADD CONSTRAINT "${pk.name}" PRIMARY KEY("${pk.columns.join('","')}");`;
+});
+
+const dropPrimaryKeyConvertor = convertor('drop_pk', (st) => {
+	const pk = st.pk;
+	const key = pk.schema !== 'public'
+		? `"${pk.schema}"."${pk.table}"`
+		: `"${pk.table}"`;
+
+	return `ALTER TABLE ${key} DROP CONSTRAINT "${pk.name}";`;
+});
+
+const recreatePrimaryKeyConvertor = convertor('alter_pk', (it) => {
+	const st: string[] = [];
+	if (!it.deleted) st.push(dropPrimaryKeyConvertor.convert({ pk: it.pk }) as string);
+	st.push(addPrimaryKeyConvertor.convert({ pk: it.pk }) as string);
+	return st;
+});
+
+const renameConstraintConvertor = convertor('rename_constraint', (st) => {
+	const key = st.schema !== 'public'
+		? `"${st.schema}"."${st.table}"`
+		: `"${st.table}"`;
+
+	return `ALTER TABLE ${key} RENAME CONSTRAINT "${st.from}" TO "${st.to}";`;
+});
+
+const createForeignKeyConvertor = convertor('create_fk', (st) => {
+	const { schema, table, name, tableTo, columns, columnsTo, onDelete, onUpdate, schemaTo } = st.fk;
+
+	const onDeleteStatement = onDelete && !isDefaultAction(onDelete) ? ` ON DELETE ${onDelete}` : '';
+	const onUpdateStatement = onUpdate && !isDefaultAction(onUpdate) ? ` ON UPDATE ${onUpdate}` : '';
+	const fromColumnsString = columns.map((it) => `"${it}"`).join(',');
+	const toColumnsString = columnsTo.map((it) => `"${it}"`).join(',');
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	const tableToNameWithSchema = schemaTo !== 'public'
+		? `"${schemaTo}"."${tableTo}"`
+		: `"${tableTo}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+});
+
+const recreateFKConvertor = convertor('recreate_fk', (st) => {
+	const { fk } = st;
+
+	const key = fk.schema !== 'public'
+		? `"${fk.schema}"."${fk.table}"`
+		: `"${fk.table}"`;
+
+	const onDeleteStatement = fk.onDelete !== 'NO ACTION'
+		? ` ON DELETE ${fk.onDelete}`
+		: '';
+	const onUpdateStatement = fk.onUpdate !== 'NO ACTION'
+		? ` ON UPDATE ${fk.onUpdate}`
+		: '';
+
+	const fromColumnsString = fk.columns
+		.map((it) => `"${it}"`)
+		.join(',');
+	const toColumnsString = fk.columnsTo.map((it) => `"${it}"`).join(',');
+
+	const tableToNameWithSchema = fk.schemaTo !== 'public'
+		? `"${fk.schemaTo}"."${fk.tableTo}"`
+		: `"${fk.tableTo}"`;
+
+	let sql = `ALTER TABLE ${key} DROP CONSTRAINT "${fk.name}", `;
+	sql += `ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${fromColumnsString}) `;
+	sql += `REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+	return sql;
+});
+
+const dropForeignKeyConvertor = convertor('drop_fk', (st) => {
+	const { schema, table, name } = st.fk;
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name}";`;
+});
+
+const addCheckConvertor = convertor('add_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'public'
+		? `"${check.schema}"."${check.table}"`
+		: `"${check.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${check.name}" CHECK (${check.value});`;
+});
+
+const dropCheckConvertor = convertor('drop_check', (st) => {
+	const { check } = st;
+	const tableNameWithSchema = check.schema !== 'public'
+		? `"${check.schema}"."${check.table}"`
+		: `"${check.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${check.name}";`;
+});
+
+const recreateCheckConvertor = convertor('alter_check', (st) => {
+	const { diff } = st;
+
+	const check = diff.$right;
+
+	const key = check.schema !== 'public'
+		? `"${check.schema}"."${check.table}"`
+		: `"${check.table}"`;
+
+	let sql = `ALTER TABLE ${key} DROP CONSTRAINT "${check.name}", `;
+	sql += `ADD CONSTRAINT "${check.name}" CHECK (${check.value});`;
+
+	return sql;
+});
+
+const addUniqueConvertor = convertor('add_unique', (st) => {
+	const { unique } = st;
+	const tableNameWithSchema = unique.schema !== 'public'
+		? `"${unique.schema}"."${unique.table}"`
+		: `"${unique.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unique.name}" UNIQUE${
+		unique.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
+	}("${unique.columns.join('","')}");`;
+});
+
+const dropUniqueConvertor = convertor('drop_unique', (st) => {
+	const { unique } = st;
+	const tableNameWithSchema = unique.schema !== 'public'
+		? `"${unique.schema}"."${unique.table}"`
+		: `"${unique.table}"`;
+	return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unique.name}";`;
+});
+
+const alterUniqueConvertor = convertor('alter_unique', (st) => {
+	const statements: string[] = [];
+
+	statements.push(dropUniqueConvertor.convert({ unique: st.diff.$left }) as string);
+	statements.push(addUniqueConvertor.convert({ unique: st.diff.$right }) as string);
+
+	return statements;
+});
+
+const createEnumConvertor = convertor('create_enum', (st) => {
+	const { name, schema, values } = st.enum;
+	const enumNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	let valuesStatement = '(';
+	valuesStatement += values.map((it) => wrapWith(it.replaceAll("'", "''"), "'")).join(', ');
+	valuesStatement += ')';
+
+	return `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+});
+
+const dropEnumConvertor = convertor('drop_enum', (st) => {
+	const { name, schema } = st.enum;
+	const enumNameWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+	return `DROP TYPE ${enumNameWithSchema};`;
+});
+
+const renameEnumConvertor = convertor('rename_enum', (st) => {
+	const from = st.schema !== 'public' ? `"${st.schema}"."${st.from}"` : `"${st.from}"`;
+	return `ALTER TYPE ${from} RENAME TO "${st.to}";`;
+});
+
+const moveEnumConvertor = convertor('move_enum', (st) => {
+	const { from, to } = st;
+
+	const enumNameWithSchema = from.schema !== 'public' ? `"${from.schema}"."${from.name}"` : `"${from.name}"`;
+	return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${to.schema || 'public'}";`;
+});
+
+const alterEnumConvertor = convertor('alter_enum', (st) => {
+	const { diff, to: e } = st;
+	const key = e.schema !== 'public' ? `"${e.schema}"."${e.name}"` : `"${e.name}"`;
+
+	const statements = [] as string[];
+	for (const d of diff.filter((it) => it.type === 'added')) {
+		if (d.beforeValue) {
+			statements.push(`ALTER TYPE ${key} ADD VALUE '${d.value}' BEFORE '${d.beforeValue}';`);
+		} else {
+			statements.push(`ALTER TYPE ${key} ADD VALUE '${d.value}';`);
+		}
+	}
+	return statements;
+});
+
+const recreateEnumConvertor = convertor('recreate_enum', (st) => {
+	const { to, columns } = st;
+	const statements: string[] = [];
+	for (const column of columns) {
+		const key = column.schema !== 'public' ? `"${column.schema}"."${column.table}"` : `"${column.table}"`;
+		statements.push(
+			`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE text${'[]'.repeat(column.dimensions)};`,
+		);
+		if (column.default.left) statements.push(`ALTER TABLE ${key} ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+	}
+	statements.push(dropEnumConvertor.convert({ enum: to }) as string);
+	statements.push(createEnumConvertor.convert({ enum: to }) as string);
+
+	for (const column of columns) {
+		const key = column.schema !== 'public' ? `"${column.schema}"."${column.table}"` : `"${column.table}"`;
+		const enumType = to.schema !== 'public' ? `"${to.schema}"."${to.name}"` : `"${to.name}"`;
+		statements.push(
+			`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DATA TYPE ${enumType}${
+				'[]'.repeat(column.dimensions)
+			} USING "${column.name}"::${enumType}${'[]'.repeat(column.dimensions)};`,
+		);
+		if (column.default.right) {
+			statements.push(
+				`ALTER TABLE ${key} ALTER COLUMN "${column.name}" SET DEFAULT ${
+					defaultToSQL({
+						default: column.default.right,
+						dimensions: column.dimensions,
+						type: column.type,
+						typeSchema: column.typeSchema,
+					})
+				};`,
+			);
+		}
+	}
+
+	return statements;
+});
+
+const createSequenceConvertor = convertor('create_sequence', (st) => {
+	const { name, schema, minValue, maxValue, incrementBy, startWith, cacheSize, cycle } = st.sequence;
+	const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+	return `CREATE SEQUENCE ${sequenceWithSchema}${incrementBy ? ` INCREMENT BY ${incrementBy}` : ''}${
+		minValue ? ` MINVALUE ${minValue}` : ''
+	}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+		cacheSize ? ` CACHE ${cacheSize}` : ''
+	}${cycle ? ` CYCLE` : ''};`;
+});
+
+const dropSequenceConvertor = convertor('drop_sequence', (st) => {
+	const { name, schema } = st.sequence;
+	const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+	return `DROP SEQUENCE ${sequenceWithSchema};`;
+});
+
+const renameSequenceConvertor = convertor('rename_sequence', (st) => {
+	const sequenceWithSchemaFrom = st.from.schema !== 'public'
+		? `"${st.from.schema}"."${st.from.name}"`
+		: `"${st.from.name}"`;
+	return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${st.to.name}";`;
+});
+
+const moveSequenceConvertor = convertor('move_sequence', (st) => {
+	const { from, to } = st;
+	const sequenceWithSchema = from.schema !== 'public'
+		? `"${from.schema}"."${from.name}"`
+		: `"${from.name}"`;
+	const seqSchemaTo = `"${to.schema}"`;
+	return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
+});
+
+const alterSequenceConvertor = convertor('alter_sequence', (st) => {
+	const { schema, name, incrementBy, minValue, maxValue, startWith, cacheSize, cycle } = st.sequence;
+
+	const sequenceWithSchema = schema !== 'public' ? `"${schema}"."${name}"` : `"${name}"`;
+
+	return `ALTER SEQUENCE ${sequenceWithSchema}${incrementBy ? ` INCREMENT BY ${incrementBy}` : ''}${
+		minValue ? ` MINVALUE ${minValue}` : ''
+	}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+		cacheSize ? ` CACHE ${cacheSize}` : ''
+	}${cycle ? ` CYCLE` : ''};`;
+});
+
+const createRoleConvertor = convertor('create_role', (st) => {
+	const {
+		name,
+		superuser,
+		createDb,
+		createRole,
+		inherit,
+		canLogin,
+		replication,
+		bypassRls,
+		connLimit,
+		password,
+		validUntil,
+	} = st.role;
+	const withClause =
+		superuser || createDb || createRole || !inherit || canLogin || replication || bypassRls || validUntil
+			|| (typeof connLimit === 'number' && connLimit !== -1) || password
+			? ` WITH${superuser ? ' SUPERUSER' : ''}${createDb ? ' CREATEDB' : ''}${createRole ? ' CREATEROLE' : ''}${
+				inherit ? '' : ' NOINHERIT'
+			}${canLogin ? ' LOGIN' : ''}${replication ? ' REPLICATION' : ''}${bypassRls ? ' BYPASSRLS' : ''}${
+				typeof connLimit === 'number' && connLimit !== -1 ? ` CONNECTION LIMIT ${connLimit}` : ''
+			}${password ? ` PASSWORD '${escapeSingleQuotes(password)}'` : ''}${
+				validUntil ? ` VALID UNTIL '${validUntil}'` : ''
+			}`
+			: '';
+
+	return `CREATE ROLE "${name}"${withClause};`;
+});
+
+const dropRoleConvertor = convertor('drop_role', (st) => {
+	return `DROP ROLE "${st.role.name}";`;
+});
+
+const renameRoleConvertor = convertor('rename_role', (st) => {
+	return `ALTER ROLE "${st.from.name}" RENAME TO "${st.to.name}";`;
+});
+
+const alterRoleConvertor = convertor('alter_role', ({ diff, role }) => {
+	const {
+		name,
+	} = role;
+	const st1 = diff.superuser
+		? diff.superuser.to
+			? ' SUPERUSER'
+			: ' NOSUPERUSER'
+		: '';
+	const st2 = diff.createDb
+		? diff.createDb.to
+			? ' CREATEDB'
+			: ' NOCREATEDB'
+		: '';
+	const st3 = diff.createRole
+		? diff.createRole.to
+			? ' CREATEROLE'
+			: ' NOCREATEROLE'
+		: '';
+	const st4 = diff.inherit
+		? diff.inherit.to
+			? ' INHERIT'
+			: ' NOINHERIT'
+		: '';
+	const st5 = diff.canLogin
+		? diff.canLogin.to
+			? ' LOGIN'
+			: ' NOLOGIN'
+		: '';
+	const st6 = diff.replication
+		? diff.replication.to
+			? ' REPLICATION'
+			: ' NOREPLICATION'
+		: '';
+	const st7 = diff.bypassRls
+		? diff.bypassRls.to
+			? ' BYPASSRLS'
+			: ' NOBYPASSRLS'
+		: '';
+	const st8 = diff.connLimit
+		? typeof diff.connLimit.to === 'number'
+			? ` CONNECTION LIMIT ${diff.connLimit.to}`
+			: ' CONNECTION LIMIT -1'
+		: '';
+	const st9 = diff.password
+		? diff.password.to
+			? ` PASSWORD '${escapeSingleQuotes(diff.password.to)}'`
+			: ' PASSWORD NULL'
+		: '';
+	const st10 = diff.validUntil
+		? diff.validUntil.to
+			? ` VALID UNTIL '${diff.validUntil.to}'`
+			: ` VALID UNTIL 'infinity'`
+		: '';
+
+	return `ALTER ROLE "${name}" WITH${st1}${st2}${st3}${st4}${st5}${st6}${st7}${st8}${st9}${st10};`;
+
+	// return `ALTER ROLE "${name}"${` WITH${diff.superuser ? ' SUPERUSER' : ' NOSUPERUSER'}${
+	// 	createDb ? ' CREATEDB' : ' NOCREATEDB'
+	// }${createRole ? ' CREATEROLE' : ' NOCREATEROLE'}${inherit ? ' INHERIT' : ' NOINHERIT'}${
+	// 	canLogin ? ' LOGIN' : ' NOLOGIN'
+	// }${replication ? ' REPLICATION' : ' NOREPLICATION'}${bypassRls ? ' BYPASSRLS' : ' NOBYPASSRLS'}${
+	// 	typeof connLimit === 'number' ? ` CONNECTION LIMIT ${connLimit}` : ' CONNECTION LIMIT -1'
+	// }${password ? ` PASSWORD '${escapeSingleQuotes(password)}'` : ' PASSWORD NULL'}${
+	// 	validUntil ? ` VALID UNTIL '${validUntil}'` : ` VALID UNTIL 'infinity'`
+	// }`};`;
+});
+
+const grantPrivilegeConvertor = convertor('grant_privilege', (st) => {
+	const { schema, table } = st.privilege;
+	const privilege = st.privilege;
+
+	return `GRANT ${privilege.type} ON ${
+		schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`
+	} TO "${privilege.grantee}"${privilege.isGrantable ? ' WITH GRANT OPTION' : ''} GRANTED BY "${privilege.grantor}";`;
+});
+
+const revokePrivilegeConvertor = convertor('revoke_privilege', (st) => {
+	const { schema, table } = st.privilege;
+	const privilege = st.privilege;
+
+	return `REVOKE ${privilege.type} ON ${
+		schema !== 'public' ? `"${schema}"."${table}"` : `"${table}"`
+	} FROM "${privilege.grantee}";`;
+});
+
+const regrantPrivilegeConvertor = convertor('regrant_privilege', (st) => {
+	const privilege = st.privilege;
+	const revokeStatement = revokePrivilegeConvertor.convert({ privilege }) as string;
+	const grantStatement = grantPrivilegeConvertor.convert({ privilege }) as string;
+	return [revokeStatement, grantStatement];
+});
+
+const createPolicyConvertor = convertor('create_policy', (st) => {
+	const { schema, table } = st.policy;
+	const policy = st.policy;
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${table}"`
+		: `"${table}"`;
+
+	const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+	const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+	const policyToPart = policy.roles?.map((v) =>
+		['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+	).join(', ');
+
+	return `CREATE POLICY "${policy.name}" ON ${tableNameWithSchema} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+});
+
+const dropPolicyConvertor = convertor('drop_policy', (st) => {
+	const policy = st.policy;
+
+	const tableNameWithSchema = policy.schema !== 'public'
+		? `"${policy.schema}"."${policy.table}"`
+		: `"${policy.table}"`;
+
+	return `DROP POLICY "${policy.name}" ON ${tableNameWithSchema};`;
+});
+
+const renamePolicyConvertor = convertor('rename_policy', (st) => {
+	const { from, to } = st;
+
+	const tableNameWithSchema = to.schema !== 'public'
+		? `"${to.schema}"."${to.table}"`
+		: `"${to.table}"`;
+
+	return `ALTER POLICY "${from.name}" ON ${tableNameWithSchema} RENAME TO "${to.name}";`;
+});
+
+const alterPolicyConvertor = convertor('alter_policy', (st) => {
+	const { policy } = st;
+
+	const tableNameWithSchema = policy.schema !== 'public'
+		? `"${policy.schema}"."${policy.table}"`
+		: `"${policy.table}"`;
+
+	const usingPart = policy.using
+		? ` USING (${policy.using})`
+		: '';
+
+	const withCheckPart = policy.withCheck
+		? ` WITH CHECK (${policy.withCheck})`
+		: '';
+
+	const toClause = policy.roles?.map((v) =>
+		['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+	).join(', ');
+
+	return `ALTER POLICY "${policy.name}" ON ${tableNameWithSchema} TO ${toClause}${usingPart}${withCheckPart};`;
+});
+
+const recreatePolicy = convertor('recreate_policy', (st) => {
+	return [
+		dropPolicyConvertor.convert({ policy: st.policy }) as string,
+		createPolicyConvertor.convert({ policy: st.policy }) as string,
+	];
+});
+
+const toggleRlsConvertor = convertor('alter_rls', (st) => {
+	const { schema, name, isRlsEnabled } = st;
+
+	const tableNameWithSchema = schema !== 'public'
+		? `"${schema}"."${name}"`
+		: `"${name}"`;
+
+	return `ALTER TABLE ${tableNameWithSchema} ${isRlsEnabled ? 'ENABLE' : 'DISABLE'} ROW LEVEL SECURITY;`;
+});
+
+const convertors = [
+	createSchemaConvertor,
+	dropSchemaConvertor,
+	renameSchemaConvertor,
+	createViewConvertor,
+	dropViewConvertor,
+	renameViewConvertor,
+	moveViewConvertor,
+	alterViewConvertor,
+	createTableConvertor,
+	dropTableConvertor,
+	renameTableConvertor,
+	moveTableConvertor,
+	addColumnConvertor,
+	dropColumnConvertor,
+	renameColumnConvertor,
+	recreateColumnConvertor,
+	alterColumnConvertor,
+	createIndexConvertor,
+	dropIndexConvertor,
+	recreateIndexConvertor,
+	renameIndexConvertor,
+	addPrimaryKeyConvertor,
+	dropPrimaryKeyConvertor,
+	recreatePrimaryKeyConvertor,
+	createForeignKeyConvertor,
+	recreateFKConvertor,
+	dropForeignKeyConvertor,
+	addCheckConvertor,
+	dropCheckConvertor,
+	recreateCheckConvertor,
+	addUniqueConvertor,
+	dropUniqueConvertor,
+	alterUniqueConvertor,
+	renameConstraintConvertor,
+	createEnumConvertor,
+	dropEnumConvertor,
+	renameEnumConvertor,
+	moveEnumConvertor,
+	alterEnumConvertor,
+	recreateEnumConvertor,
+	createSequenceConvertor,
+	dropSequenceConvertor,
+	renameSequenceConvertor,
+	moveSequenceConvertor,
+	alterSequenceConvertor,
+	createRoleConvertor,
+	dropRoleConvertor,
+	renameRoleConvertor,
+	alterRoleConvertor,
+	grantPrivilegeConvertor,
+	revokePrivilegeConvertor,
+	regrantPrivilegeConvertor,
+	createPolicyConvertor,
+	dropPolicyConvertor,
+	renamePolicyConvertor,
+	alterPolicyConvertor,
+	recreatePolicy,
+	toggleRlsConvertor,
+];
+
+export function fromJson(
+	statements: JsonStatement[],
+) {
+	const grouped = statements
+		.map((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+			if (!convertor) throw new Error(`No convertor for: ${statement.type} statement`);
+
+			const sqlStatements = convertor.convert(statement as any);
+			const statements = typeof sqlStatements === 'string' ? [sqlStatements] : sqlStatements;
+			return { jsonStatement: statement, sqlStatements: statements };
+		})
+		.filter((it) => it !== null);
+
+	const result = {
+		sqlStatements: grouped.map((it) => it.sqlStatements).flat(),
+		groupedStatements: grouped,
+	};
+	return result;
+}
+
+// blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
+// test case for enum altering
+// oxlint-disable-next-line no-unused-expressions
+`
+create table users (
+	id int,
+    name character varying(128)
+);
+
+create type venum as enum('one', 'two', 'three');
+alter table users add column typed venum;
+
+insert into users(id, name, typed) values (1, 'name1', 'one');
+insert into users(id, name, typed) values (2, 'name2', 'two');
+insert into users(id, name, typed) values (3, 'name3', 'three');
+
+alter type venum rename to __venum;
+create type venum as enum ('one', 'two', 'three', 'four', 'five');
+
+ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;
+
+insert into users(id, name, typed) values (4, 'name4', 'four');
+insert into users(id, name, typed) values (5, 'name5', 'five');
+
+drop type __venum;
+`;
diff --git a/drizzle-kit/src/dialects/postgres/ddl.ts b/drizzle-kit/src/dialects/postgres/ddl.ts
new file mode 100644
index 0000000000..c95adb1ad0
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/ddl.ts
@@ -0,0 +1,609 @@
+import type { SchemaForPull } from '../../cli/commands/pull-common';
+import { create } from '../dialect';
+import { defaultNameForPK, defaultNameForUnique } from './grammar';
+
+export const createDDL = () => {
+	return create({
+		schemas: {},
+		tables: { schema: 'required', isRlsEnabled: 'boolean' },
+		enums: {
+			schema: 'required',
+			values: 'string[]',
+		},
+		columns: {
+			schema: 'required',
+			table: 'required',
+			type: 'string',
+			typeSchema: 'string?',
+			notNull: 'boolean',
+			dimensions: 'number',
+			default: 'string?',
+			generated: {
+				type: ['stored'],
+				as: 'string',
+			},
+			identity: {
+				name: 'string',
+				type: ['always', 'byDefault'],
+				increment: 'string?',
+				minValue: 'string?',
+				maxValue: 'string?',
+				startWith: 'string?',
+				cache: 'number?',
+				cycle: 'boolean?',
+			},
+		},
+		indexes: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: [
+				{
+					value: 'string',
+					isExpression: 'boolean',
+					asc: 'boolean',
+					nullsFirst: 'boolean',
+					opclass: {
+						name: 'string',
+						default: 'boolean',
+					},
+				},
+			],
+			isUnique: 'boolean',
+			where: 'string?',
+			with: 'string',
+			method: 'string',
+			concurrently: 'boolean',
+		},
+		fks: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+			schemaTo: 'string',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+			onDelete: ['NO ACTION', 'RESTRICT', 'SET NULL', 'CASCADE', 'SET DEFAULT', null],
+		},
+		pks: {
+			schema: 'required',
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+		},
+		uniques: {
+			schema: 'required',
+			table: 'required',
+			nameExplicit: 'boolean',
+			columns: 'string[]',
+			nullsNotDistinct: 'boolean',
+		},
+		checks: {
+			schema: 'required',
+			table: 'required',
+			value: 'string',
+		},
+		sequences: {
+			schema: 'required',
+			incrementBy: 'string?',
+			minValue: 'string?',
+			maxValue: 'string?',
+			startWith: 'string?',
+			cacheSize: 'number?',
+			cycle: 'boolean?',
+		},
+		roles: {
+			superuser: 'boolean?',
+			createDb: 'boolean?',
+			createRole: 'boolean?',
+			inherit: 'boolean?',
+			canLogin: 'boolean?',
+			replication: 'boolean?',
+			bypassRls: 'boolean?',
+			connLimit: 'number?',
+			password: 'string?',
+			validUntil: 'string?',
+		},
+		privileges: {
+			grantor: 'string',
+			grantee: 'string',
+			schema: 'required',
+			table: 'required',
+			type: ['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE', 'TRUNCATE', 'REFERENCES', 'TRIGGER'],
+			isGrantable: 'boolean',
+		},
+		policies: {
+			schema: 'required',
+			table: 'required',
+			as: ['PERMISSIVE', 'RESTRICTIVE'],
+			for: ['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE'],
+			roles: 'string[]', // TO { role_name | PUBLIC | CURRENT_ROLE | SESSION_USER }
+			using: 'string?',
+			withCheck: 'string?',
+		},
+		views: {
+			schema: 'required',
+			definition: 'string?',
+			with: {
+				checkOption: ['local', 'cascaded', null],
+				securityBarrier: 'boolean?',
+				securityInvoker: 'boolean?',
+				fillfactor: 'number?',
+				toastTupleTarget: 'number?',
+				parallelWorkers: 'number?',
+				autovacuumEnabled: 'boolean?',
+				vacuumIndexCleanup: ['auto', 'off', 'on', null],
+				vacuumTruncate: 'boolean?',
+				autovacuumVacuumThreshold: 'number?',
+				autovacuumVacuumScaleFactor: 'number?',
+				autovacuumVacuumCostDelay: 'number?',
+				autovacuumVacuumCostLimit: 'number?',
+				autovacuumFreezeMinAge: 'number?',
+				autovacuumFreezeMaxAge: 'number?',
+				autovacuumFreezeTableAge: 'number?',
+				autovacuumMultixactFreezeMinAge: 'number?',
+				autovacuumMultixactFreezeMaxAge: 'number?',
+				autovacuumMultixactFreezeTableAge: 'number?',
+				logAutovacuumMinDuration: 'number?',
+				userCatalogTable: 'boolean?',
+			},
+			withNoData: 'boolean?',
+			using: 'string?',
+			tablespace: 'string?',
+			materialized: 'boolean',
+		},
+	});
+};
+
+export type PostgresDDL = ReturnType<typeof createDDL>;
+
+export type PostgresEntities = PostgresDDL['_']['types'];
+export type PostgresEntity = PostgresEntities[keyof PostgresEntities];
+
+export type DiffEntities = PostgresDDL['_']['diffs']['alter'];
+
+export type Schema = PostgresEntities['schemas'];
+export type Enum = PostgresEntities['enums'];
+export type Sequence = PostgresEntities['sequences'];
+export type Column = PostgresEntities['columns'];
+export type Identity = Column['identity'];
+export type Role = PostgresEntities['roles'];
+export type Privilege = PostgresEntities['privileges'];
+export type Index = PostgresEntities['indexes'];
+export type IndexColumn = Index['columns'][number];
+export type ForeignKey = PostgresEntities['fks'];
+export type PrimaryKey = PostgresEntities['pks'];
+export type UniqueConstraint = PostgresEntities['uniques'];
+export type CheckConstraint = PostgresEntities['checks'];
+export type Policy = PostgresEntities['policies'];
+export type View = PostgresEntities['views'];
+
+export type ViewColumn = {
+	schema: string;
+	view: string;
+	type: string;
+	typeDimensions: number;
+	typeSchema: string | null;
+	notNull: boolean;
+	dimensions: number;
+	name: string;
+};
+
+export type Table = {
+	schema: string;
+	name: string;
+	columns: Column[];
+	indexes: Index[];
+	pk: PrimaryKey | null;
+	fks: ForeignKey[];
+	uniques: UniqueConstraint[];
+	checks: CheckConstraint[];
+	policies: Policy[];
+	isRlsEnabled: boolean;
+};
+
+export type InterimColumn = Omit<Column, 'primaryKey'> & {
+	pk: boolean;
+	pkName: string | null;
+} & {
+	unique: boolean;
+	uniqueName: string | null;
+	uniqueNullsNotDistinct: boolean;
+};
+
+export type InterimIndex = Index & {
+	forPK: boolean;
+	forUnique: boolean;
+};
+
+export interface InterimSchema {
+	schemas: Schema[];
+	enums: Enum[];
+	tables: PostgresEntities['tables'][];
+	columns: InterimColumn[];
+	indexes: InterimIndex[];
+	pks: PrimaryKey[];
+	fks: ForeignKey[];
+	uniques: UniqueConstraint[];
+	checks: CheckConstraint[];
+	sequences: Sequence[];
+	roles: Role[];
+	privileges: Privilege[];
+	policies: Policy[];
+	views: View[];
+	viewColumns: ViewColumn[];
+}
+
+export function postgresToRelationsPull(schema: PostgresDDL): SchemaForPull {
+	return Object.values(schema.tables.list()).map((table) => {
+		const rawTable = tableFromDDL(table, schema);
+		return {
+			schema: rawTable.schema,
+			foreignKeys: rawTable.fks,
+			columns: rawTable.columns.map((it) => ({ name: it.name })),
+			uniques: [
+				...Object.values(rawTable.uniques).map((unq) => ({
+					columns: unq.columns,
+				})),
+				...Object.values(rawTable.indexes).map((idx) => ({
+					columns: idx.columns.map((idxc) => {
+						if (!idxc.isExpression && idx.isUnique) {
+							return idxc.value;
+						}
+					}).filter((item) => item !== undefined),
+				})),
+			],
+		};
+	});
+}
+
+export const tableFromDDL = (
+	table: PostgresEntities['tables'],
+	ddl: PostgresDDL,
+): Table => {
+	const filter = { schema: table.schema, table: table.name } as const;
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const uniques = ddl.uniques.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+	const policies = ddl.policies.list(filter);
+	return {
+		...table,
+		columns,
+		pk,
+		fks,
+		uniques,
+		checks,
+		indexes,
+		policies,
+	};
+};
+
+interface SchemaDuplicate {
+	type: 'schema_name_duplicate';
+	name: string;
+}
+
+interface EnumDuplicate {
+	type: 'enum_name_duplicate';
+	name: string;
+	schema: string;
+}
+
+interface TableDuplicate {
+	type: 'table_name_duplicate';
+	name: string;
+	schema: string;
+}
+interface ColumnDuplicate {
+	type: 'column_name_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+
+interface ConstraintDuplicate {
+	type: 'constraint_name_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+interface SequenceDuplicate {
+	type: 'sequence_name_duplicate';
+	schema: string;
+	name: string;
+}
+
+interface ViewDuplicate {
+	type: 'view_name_duplicate';
+	schema: string;
+	name: string;
+}
+
+interface IndexWithoutName {
+	type: 'index_no_name';
+	schema: string;
+	table: string;
+	sql: string;
+}
+
+interface IndexDuplicate {
+	type: 'index_duplicate';
+	schema: string;
+	table: string;
+	name: string;
+}
+
+interface PgVectorIndexNoOp {
+	type: 'pgvector_index_noop';
+	table: string;
+	column: string;
+	indexName: string;
+	method: string;
+}
+
+interface PolicyDuplicate {
+	type: 'policy_duplicate';
+	schema: string;
+	table: string;
+	policy: string;
+}
+
+interface RoleDuplicate {
+	type: 'role_duplicate';
+	name: string;
+}
+
+interface PrivilegeDuplicate {
+	type: 'privilege_duplicate';
+	name: string;
+}
+
+interface EnumValuesDuplicate {
+	type: 'enum_values_duplicate';
+	schema: string;
+	name: string;
+}
+
+export type SchemaError =
+	| EnumValuesDuplicate
+	| SchemaDuplicate
+	| EnumDuplicate
+	| TableDuplicate
+	| ColumnDuplicate
+	| ViewDuplicate
+	| ConstraintDuplicate
+	| SequenceDuplicate
+	| IndexWithoutName
+	| IndexDuplicate
+	| PgVectorIndexNoOp
+	| RoleDuplicate
+	| PolicyDuplicate
+	| PrivilegeDuplicate;
+
+interface PolicyNotLinked {
+	type: 'policy_not_linked';
+	policy: string;
+}
+export type SchemaWarning = PolicyNotLinked;
+
+export const fromEntities = (entities: PostgresEntity[]) => {
+	const ddl = createDDL();
+	for (const it of entities) {
+		ddl.entities.push(it);
+	}
+
+	return ddl;
+};
+
+export const interimToDDL = (
+	schema: InterimSchema,
+): { ddl: PostgresDDL; errors: SchemaError[] } => {
+	const ddl = createDDL();
+	const errors: SchemaError[] = [];
+
+	for (const it of schema.schemas) {
+		const res = ddl.schemas.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'schema_name_duplicate', name: it.name });
+		}
+	}
+
+	for (const it of schema.enums) {
+		const res = ddl.enums.push(it);
+
+		const uniqueElements = new Set(it.values);
+		if (uniqueElements.size !== it.values.length) {
+			errors.push({
+				type: 'enum_values_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'enum_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.tables) {
+		const res = ddl.tables.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'table_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const column of schema.columns) {
+		const { pk: _1, pkName: _2, unique: _3, uniqueName: _4, uniqueNullsNotDistinct: _5, ...rest } = column;
+
+		const res = ddl.columns.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'column_name_duplicate',
+				schema: column.schema,
+				table: column.table,
+				name: column.name,
+			});
+		}
+	}
+
+	for (const it of schema.indexes) {
+		const { forPK: _1, forUnique: _2, ...rest } = it;
+		// TODO: check within schema, pk =[schema, table, name], we need only [schema, table]
+		const res = ddl.indexes.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'index_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.fks) {
+		const res = ddl.fks.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.pks) {
+		const res = ddl.pks.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const column of schema.columns.filter((it) => it.pk)) {
+		const name = column.pkName !== null ? column.pkName : defaultNameForPK(column.table);
+		const exists = ddl.pks.one({ schema: column.schema, table: column.table }) !== null;
+		if (exists) continue;
+
+		ddl.pks.push({
+			schema: column.schema,
+			table: column.table,
+			name,
+			nameExplicit: column.pkName !== null,
+			columns: [column.name],
+		});
+	}
+
+	for (const it of schema.uniques) {
+		const res = ddl.uniques.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const column of schema.columns.filter((it) => it.unique)) {
+		const name = column.uniqueName !== null ? column.uniqueName : defaultNameForUnique(column.table, column.name);
+		const exists = ddl.uniques.one({ schema: column.schema, table: column.table, columns: [column.name] }) !== null;
+		if (exists) continue;
+
+		ddl.uniques.push({
+			schema: column.schema,
+			table: column.table,
+			name,
+			nameExplicit: column.uniqueName !== null,
+			nullsNotDistinct: column.uniqueNullsNotDistinct,
+			columns: [column.name],
+		});
+	}
+
+	for (const it of schema.checks) {
+		const res = ddl.checks.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'constraint_name_duplicate',
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.sequences) {
+		const res = ddl.sequences.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'sequence_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.roles) {
+		const res = ddl.roles.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'role_duplicate', name: it.name });
+		}
+	}
+
+	for (const it of schema.privileges) {
+		const res = ddl.privileges.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'privilege_duplicate',
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of schema.policies) {
+		const res = ddl.policies.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'policy_duplicate',
+				schema: it.schema,
+				table: it.table,
+				policy: it.name,
+			});
+		}
+	}
+	for (const it of schema.views) {
+		const res = ddl.views.push(it);
+		if (res.status === 'CONFLICT') {
+			errors.push({
+				type: 'view_name_duplicate',
+				schema: it.schema,
+				name: it.name,
+			});
+		}
+	}
+
+	for (const it of ddl.entities.list()) {
+		if (!ddl.entities.validate(it)) {
+			throw new Error(`Invalid entity: ${JSON.stringify(it)}`);
+		}
+	}
+
+	return { ddl, errors };
+};
diff --git a/drizzle-kit/src/dialects/postgres/diff.ts b/drizzle-kit/src/dialects/postgres/diff.ts
new file mode 100644
index 0000000000..682a90da78
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/diff.ts
@@ -0,0 +1,1311 @@
+import { prepareMigrationRenames, trimChar } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import { deepStrictEqual } from '../../utils/node-assert/deep-strict-equal';
+import { diffStringArrays } from '../../utils/sequence-matcher';
+import { parse } from '../../utils/when-json-met-bigint';
+import type { Resolver } from '../common';
+import { diff } from '../dialect';
+import { groupDiffs, preserveEntityNames } from '../utils';
+import { fromJson } from './convertor';
+import type {
+	CheckConstraint,
+	Column,
+	DiffEntities,
+	Enum,
+	ForeignKey,
+	Index,
+	IndexColumn,
+	Policy,
+	PostgresDDL,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+} from './ddl';
+import { createDDL, tableFromDDL } from './ddl';
+import { defaults, defaultsCommutative, isSerialType } from './grammar';
+import type { JsonAlterPrimaryKey, JsonRecreateIndex, JsonStatement } from './statements';
+import { prepareStatement } from './statements';
+
+export const ddlDiffDry = async (ddlFrom: PostgresDDL, ddlTo: PostgresDDL, mode: 'default' | 'push') => {
+	const mocks = new Set<string>();
+	return ddlDiff(
+		ddlFrom,
+		ddlTo,
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mockResolver(mocks),
+		mode,
+	);
+};
+
+export const ddlDiff = async (
+	ddl1: PostgresDDL,
+	ddl2: PostgresDDL,
+	schemasResolver: Resolver<Schema>,
+	enumsResolver: Resolver<Enum>,
+	sequencesResolver: Resolver<Sequence>,
+	policyResolver: Resolver<Policy>,
+	roleResolver: Resolver<Role>,
+	privilegesResolver: Resolver<Privilege>,
+	tablesResolver: Resolver<PostgresEntities['tables']>,
+	columnsResolver: Resolver<Column>,
+	viewsResolver: Resolver<View>,
+	uniquesResolver: Resolver<UniqueConstraint>,
+	indexesResolver: Resolver<Index>,
+	checksResolver: Resolver<CheckConstraint>,
+	pksResolver: Resolver<PrimaryKey>,
+	fksResolver: Resolver<ForeignKey>,
+	mode: 'default' | 'push',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: { jsonStatement: JsonStatement; sqlStatements: string[] }[];
+	renames: string[];
+}> => {
+	const ddl1Copy = createDDL();
+	for (const entity of ddl1.entities.list()) {
+		ddl1Copy.entities.push(entity);
+	}
+
+	const schemasDiff = diff(ddl1, ddl2, 'schemas');
+	const {
+		created: createdSchemas,
+		deleted: deletedSchemas,
+		renamedOrMoved: renamedSchemas,
+	} = await schemasResolver({
+		created: schemasDiff.filter((it) => it.$diffType === 'create'),
+		deleted: schemasDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const rename of renamedSchemas) {
+		ddl1.entities.update({
+			set: {
+				schema: rename.to.name,
+			},
+			where: {
+				schema: rename.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.name,
+			},
+		});
+	}
+
+	const enumsDiff = diff(ddl1, ddl2, 'enums');
+	const {
+		created: createdEnums,
+		deleted: deletedEnums,
+		renamedOrMoved: renamedOrMovedEnums,
+	} = await enumsResolver({
+		created: enumsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: enumsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedEnums = renamedOrMovedEnums.filter((it) => it.from.name !== it.to.name);
+	const movedEnums = renamedOrMovedEnums.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedEnums) {
+		ddl1.enums.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+		ddl1.columns.update({
+			set: {
+				type: rename.to.name,
+				typeSchema: rename.to.schema,
+			},
+			where: {
+				type: rename.from.name,
+				typeSchema: rename.from.schema,
+			},
+		});
+	}
+	for (const move of movedEnums) {
+		ddl1.enums.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+		ddl1.columns.update({
+			set: {
+				typeSchema: move.to.schema,
+			},
+			where: {
+				type: move.from.name,
+				typeSchema: move.from.schema,
+			},
+		});
+	}
+
+	const sequencesDiff = diff(ddl1, ddl2, 'sequences');
+	const {
+		created: createdSequences,
+		deleted: deletedSequences,
+		renamedOrMoved: renamedOrMovedSequences,
+	} = await sequencesResolver({
+		created: sequencesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: sequencesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedSequences = renamedOrMovedSequences.filter((it) => it.from.schema === it.to.schema);
+	const movedSequences = renamedOrMovedSequences.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedSequences) {
+		ddl1.sequences.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	for (const move of movedSequences) {
+		ddl1.sequences.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+	}
+
+	const rolesDiff = diff(ddl1, ddl2, 'roles');
+	const {
+		created: createdRoles,
+		deleted: deletedRoles,
+		renamedOrMoved: renamedRoles,
+	} = await roleResolver({
+		created: rolesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: rolesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+	for (const rename of renamedRoles) {
+		ddl1.roles.update({
+			set: {
+				name: rename.to.name,
+			},
+			where: {
+				name: rename.from.name,
+			},
+		});
+	}
+
+	const privilegesDiff = diff(ddl1, ddl2, 'privileges');
+	const {
+		created: createdPrivileges,
+		deleted: deletedPrivileges,
+	} = await privilegesResolver({
+		created: privilegesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: privilegesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const tablesDiff = diff(ddl1, ddl2, 'tables');
+	const {
+		created: createdTables,
+		deleted: deletedTables,
+		renamedOrMoved: renamedOrMovedTables,
+	} = await tablesResolver({
+		created: tablesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: tablesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedTables = renamedOrMovedTables.filter((it) => it.from.name !== it.to.name);
+	const movedTables = renamedOrMovedTables.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedOrMovedTables) {
+		ddl1.tables.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schemaTo: rename.to.schema,
+				tableTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.name,
+			},
+		});
+		ddl2.fks.update({
+			set: {
+				schemaTo: rename.to.schema,
+				tableTo: rename.to.name,
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				schema: rename.to.schema,
+				table: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.name,
+			},
+		});
+
+		ddl1.entities.update({
+			set: {
+				table: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				table: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		ddl2.entities.update({
+			set: {
+				table: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				table: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const columnsDiff = diff(ddl1, ddl2, 'columns');
+	const columnRenames = [] as { from: Column; to: Column }[];
+	const columnsToCreate = [] as Column[];
+	const columnsToDelete = [] as Column[];
+
+	const groupedByTable = groupDiffs(columnsDiff);
+
+	for (let it of groupedByTable) {
+		const { created, deleted, renamedOrMoved } = await columnsResolver({
+			created: it.inserted,
+			deleted: it.deleted,
+		});
+
+		columnsToCreate.push(...created);
+		columnsToDelete.push(...deleted);
+		columnRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of columnRenames) {
+		ddl1.columns.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+
+		// DDL2 updates are needed for Drizzle Studio
+		const update1 = {
+			set: {
+				columns: (it: IndexColumn) => {
+					if (!it.isExpression && it.value === rename.from.name) {
+						return { ...it, value: rename.to.name };
+					}
+					return it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.indexes.update(update1);
+		ddl2.indexes.update(update1);
+
+		const update2 = {
+			set: {
+				columns: (it: string) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.pks.update(update2);
+		ddl2.pks.update(update2);
+
+		const update3 = {
+			set: {
+				columns: (it: string) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update3);
+		ddl2.fks.update(update3);
+
+		const update4 = {
+			set: {
+				columnsTo: (it: string) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schemaTo: rename.from.schema,
+				tableTo: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update4);
+		ddl2.fks.update(update4);
+
+		const update5 = {
+			set: {
+				columns: (it: string) => {
+					return it === rename.from.name ? rename.to.name : it;
+				},
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.uniques.update(update5);
+		ddl2.uniques.update(update5);
+
+		const update6 = {
+			set: {
+				value: rename.to.name,
+			},
+			where: {
+				schema: rename.from.schema,
+				table: rename.from.table,
+				value: rename.from.name,
+			},
+		} as const;
+		ddl1.checks.update(update6);
+		ddl2.checks.update(update6);
+	}
+
+	preserveEntityNames(ddl1.uniques, ddl2.uniques, mode);
+	preserveEntityNames(ddl1.fks, ddl2.fks, mode);
+	preserveEntityNames(ddl1.pks, ddl2.pks, mode);
+	preserveEntityNames(ddl1.indexes, ddl2.indexes, mode);
+
+	const uniquesDiff = diff(ddl1, ddl2, 'uniques');
+	const groupedUniquesDiff = groupDiffs(uniquesDiff);
+
+	const uniqueRenames = [] as { from: UniqueConstraint; to: UniqueConstraint }[];
+	const uniqueCreates = [] as UniqueConstraint[];
+	const uniqueDeletes = [] as UniqueConstraint[];
+
+	for (const entry of groupedUniquesDiff) {
+		const { renamedOrMoved: renamed, created, deleted } = await uniquesResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		uniqueCreates.push(...created);
+		uniqueDeletes.push(...deleted);
+		uniqueRenames.push(...renamed);
+	}
+
+	for (const rename of uniqueRenames) {
+		ddl1.uniques.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffChecks = diff(ddl1, ddl2, 'checks');
+	const groupedChecksDiff = groupDiffs(diffChecks);
+	const checkRenames = [] as { from: CheckConstraint; to: CheckConstraint }[];
+	const checkCreates = [] as CheckConstraint[];
+	const checkDeletes = [] as CheckConstraint[];
+
+	for (const entry of groupedChecksDiff) {
+		const { renamedOrMoved, created, deleted } = await checksResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		checkCreates.push(...created);
+		checkDeletes.push(...deleted);
+		checkRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of checkRenames) {
+		ddl1.checks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffIndexes = diff(ddl1, ddl2, 'indexes');
+	const groupedIndexesDiff = groupDiffs(diffIndexes);
+	const indexesRenames = [] as { from: Index; to: Index }[];
+	const indexesCreates = [] as Index[];
+	const indexesDeletes = [] as Index[];
+
+	for (const entry of groupedIndexesDiff) {
+		const { renamedOrMoved, created, deleted } = await indexesResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		indexesCreates.push(...created);
+		indexesDeletes.push(...deleted);
+		indexesRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of indexesRenames) {
+		ddl1.indexes.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffPKs = diff(ddl1, ddl2, 'pks');
+	const groupedPKsDiff = groupDiffs(diffPKs);
+	const pksRenames = [] as { from: PrimaryKey; to: PrimaryKey }[];
+	const pksCreates = [] as PrimaryKey[];
+	const pksDeletes = [] as PrimaryKey[];
+
+	for (const entry of groupedPKsDiff) {
+		const { renamedOrMoved, created, deleted } = await pksResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		pksCreates.push(...created);
+		pksDeletes.push(...deleted);
+		pksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of pksRenames) {
+		ddl1.pks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const diffFKs = diff(ddl1, ddl2, 'fks');
+	const groupedFKsDiff = groupDiffs(diffFKs);
+	const fksRenames = [] as { from: ForeignKey; to: ForeignKey }[];
+	const fksCreates = [] as ForeignKey[];
+	const fksDeletes = [] as ForeignKey[];
+
+	for (const entry of groupedFKsDiff) {
+		const { renamedOrMoved, created, deleted } = await fksResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		fksCreates.push(...created);
+		fksDeletes.push(...deleted);
+		fksRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of fksRenames) {
+		ddl1.fks.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const policiesDiff = diff(ddl1, ddl2, 'policies');
+	const policiesDiffGrouped = groupDiffs(policiesDiff);
+
+	const policyRenames = [] as { from: Policy; to: Policy }[];
+	const policyCreates = [] as Policy[];
+	const policyDeletes = [] as Policy[];
+
+	for (const entry of policiesDiffGrouped) {
+		const { renamedOrMoved, created, deleted } = await policyResolver({
+			created: entry.inserted,
+			deleted: entry.deleted,
+		});
+
+		policyCreates.push(...created);
+		policyDeletes.push(...deleted);
+		policyRenames.push(...renamedOrMoved);
+	}
+
+	for (const rename of policyRenames) {
+		ddl1.policies.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+
+	const viewsDiff = diff(ddl1, ddl2, 'views');
+
+	const { created: createdViews, deleted: deletedViews, renamedOrMoved: renamedOrMovedViews } = await viewsResolver({
+		created: viewsDiff.filter((it) => it.$diffType === 'create'),
+		deleted: viewsDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	const renamedViews = renamedOrMovedViews.filter((it) => it.from.schema === it.to.schema);
+	const movedViews = renamedOrMovedViews.filter((it) => it.from.schema !== it.to.schema);
+
+	for (const rename of renamedViews) {
+		ddl1.views.update({
+			set: {
+				name: rename.to.name,
+				schema: rename.to.schema,
+			},
+			where: {
+				name: rename.from.name,
+				schema: rename.from.schema,
+			},
+		});
+	}
+	for (const move of movedViews) {
+		ddl1.views.update({
+			set: {
+				schema: move.to.schema,
+			},
+			where: {
+				name: move.from.name,
+				schema: move.from.schema,
+			},
+		});
+	}
+
+	const alters = diff.alters(ddl1, ddl2);
+
+	const jsonStatements: JsonStatement[] = [];
+
+	/*
+		with new DDL when table gets created with constraints, etc.
+		or existing table with constraints and indexes gets deleted,
+		those entites are treated by diff as newly created or deleted
+
+		we filter them out, because we either create them on table creation
+		or they get automatically deleted when table is deleted
+	*/
+	const tablesFilter = (type: 'deleted' | 'created') => {
+		return (it: { schema: string; table: string }) => {
+			if (type === 'created') {
+				return !createdTables.some((t) => t.schema === it.schema && t.name === it.table);
+			} else {
+				return !deletedTables.some((t) => t.schema === it.schema && t.name === it.table);
+			}
+		};
+	};
+
+	const jsonCreateIndexes = indexesCreates.map((index) => prepareStatement('create_index', { index }));
+	const jsonDropIndexes = indexesDeletes.filter(tablesFilter('deleted')).map((index) =>
+		prepareStatement('drop_index', { index })
+	);
+
+	const jsonRenameIndexes = indexesRenames.map((r) => {
+		return prepareStatement('rename_index', { schema: r.to.schema, from: r.from.name, to: r.to.name });
+	});
+
+	const indexesAlters = alters.filter((it): it is DiffEntities['indexes'] => {
+		if (it.entityType !== 'indexes') return false;
+
+		delete it.concurrently;
+
+		return ddl2.indexes.hasDiff(it);
+	});
+
+	const jsonRecreateIndex: JsonRecreateIndex[] = [];
+	for (const idx of indexesAlters) {
+		const forWhere = !!idx.where && (idx.where.from !== null && idx.where.to !== null ? mode !== 'push' : true);
+		const forColumns = !!idx.columns && (idx.columns.from.length === idx.columns.to.length ? mode !== 'push' : true);
+
+		if (idx.isUnique || idx.concurrently || idx.method || idx.with || forColumns || forWhere) {
+			const index = ddl2.indexes.one({ schema: idx.schema, table: idx.table, name: idx.name })!;
+			jsonRecreateIndex.push(prepareStatement('recreate_index', { index, diff: idx }));
+		}
+	}
+
+	const jsonDropTables = deletedTables.map((it) => {
+		const oldSchema = renamedSchemas.find((x) => x.to.name === it.schema);
+		const key = oldSchema ? `"${oldSchema.from.name}"."${it.name}"` : `"${it.schema}"."${it.name}"`;
+		return prepareStatement('drop_table', { table: tableFromDDL(it, ddl2), key });
+	});
+	const jsonRenameTables = renamedTables.map((it) =>
+		prepareStatement('rename_table', {
+			schema: it.from.schema,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonRenameColumnsStatements = columnRenames.map((it) => prepareStatement('rename_column', it));
+	const jsonDropColumnsStatemets = columnsToDelete.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_column', { column: it })
+	);
+	const jsonAddColumnsStatemets = columnsToCreate.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_column', {
+			column: it,
+			// if pk existed before and new column now has pk, this will trigger alter_pk, that will automatically add pk
+			// this flag is needed for column recreation (generated)
+			// see tests: "drizzle-kit/tests/postgres/pg-constraints.test.ts" => "remove/add pk" and below
+			isPK: false, // ddl2.pks.one({ schema: it.schema, table: it.table, columns: [it.name] }) !== null,
+			isCompositePK: ddl2.pks.one({ schema: it.schema, table: it.table, columns: { CONTAINS: it.name } }) !== null,
+		})
+	);
+
+	const columnAlters = alters.filter((it) => it.entityType === 'columns').filter((it) => {
+		if (
+			it.default
+			&& ((it.$left.type === 'json' && it.$right.type === 'json')
+				|| (it.$left.type === 'jsonb' && it.$right.type === 'jsonb'))
+		) {
+			if (it.default.from !== null && it.default.to !== null) {
+				const parsedLeft = parse(trimChar(it.default.from, "'"));
+				const parsedRight = parse(trimChar(it.default.to, "'"));
+
+				try {
+					deepStrictEqual(parsedLeft, parsedRight);
+					delete it.default;
+				} catch {}
+
+				// const left = stringify(parsedLeft);
+				// const right = stringify(parsedRight);
+
+				// if (left === right) {
+				// 	delete it.default;
+				// }
+			}
+		}
+
+		if (!it.type && it.default && defaultsCommutative(it.default, it.$right.type, it.$right.dimensions)) {
+			delete it.default;
+		}
+
+		// commutative types
+		if (it.type) {
+			if (
+				it.type.from === it.type.to.replace('numeric', 'decimal')
+				|| it.type.to === it.type.from.replace('numeric', 'decimal')
+			) {
+				delete it.type;
+			}
+		}
+
+		// geometry
+		if (it.type && it.$right.type.startsWith('geometry(point') && it.$left.type.startsWith('geometry(point')) {
+			// geometry(point,0)
+			const leftSrid = it.$left.type.split(',')[1]?.replace(')', '');
+			const rightSrid = it.$right.type.split(',')[1]?.replace(')', '');
+
+			// undefined or 0 are defaults srids
+			if (typeof leftSrid === 'undefined' && rightSrid === '0') delete it.type;
+			if (typeof rightSrid === 'undefined' && leftSrid === '0') delete it.type;
+		}
+
+		// numeric(19) === numeric(19,0)
+		if (it.type && it.type.from.replace(',0)', ')') === it.type.to) {
+			delete it.type;
+		}
+
+		return ddl2.columns.hasDiff(it);
+	});
+
+	const alteredUniques = alters.filter((it) => it.entityType === 'uniques').filter((it) => {
+		if (it.nameExplicit) {
+			delete it.nameExplicit;
+		}
+
+		return ddl2.uniques.hasDiff(it);
+	});
+
+	const jsonAlteredUniqueConstraints = alteredUniques.map((it) => prepareStatement('alter_unique', { diff: it }));
+
+	const jsonAddedUniqueConstraints = uniqueCreates.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_unique', { unique: it })
+	);
+
+	const jsonDropUniqueConstraints = uniqueDeletes.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_unique', { unique: it })
+	);
+	const jsonRenamedUniqueConstraints = uniqueRenames.map((it) =>
+		prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonAddPrimaryKeys = pksCreates.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_pk', { pk: it })
+	);
+
+	const jsonDropPrimaryKeys = pksDeletes.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_pk', { pk: it })
+	);
+
+	const jsonRenamePrimaryKey = pksRenames.map((it) => {
+		return prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		});
+	});
+
+	const jsonSetTableSchemas = movedTables.map((it) =>
+		prepareStatement('move_table', {
+			name: it.to.name, // rename of table comes first
+			from: it.from.schema,
+			to: it.to.schema,
+		})
+	);
+
+	const jsonCreatedCheckConstraints = checkCreates.filter(tablesFilter('created')).map((it) =>
+		prepareStatement('add_check', { check: it })
+	);
+	const jsonDropCheckConstraints = checkDeletes.filter(tablesFilter('deleted')).map((it) =>
+		prepareStatement('drop_check', { check: it })
+	);
+	const jsonRenamedCheckConstraints = checkRenames.map((it) =>
+		prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	// group by tables?
+	const alteredPKs = alters.filter((it) => it.entityType === 'pks').filter((it) => {
+		return !!it.columns; // ignore explicit name change
+	});
+
+	const alteredChecks = alters.filter((it) => it.entityType === 'checks');
+	const jsonAlteredPKs: JsonAlterPrimaryKey[] = alteredPKs.map((it) => {
+		const deleted = columnsToDelete.some((x) => it.columns?.from.includes(x.name));
+
+		return prepareStatement('alter_pk', { diff: it, pk: it.$right, deleted });
+	});
+
+	const jsonRecreateFKs = alters.filter((it) => it.entityType === 'fks').filter((x) => {
+		if (x.nameExplicit) delete x.nameExplicit;
+
+		return ddl2.fks.hasDiff(x);
+	}).map((it) => prepareStatement('recreate_fk', { fk: it.$right, diff: it }));
+
+	const jsonCreateFKs = fksCreates.map((it) => prepareStatement('create_fk', { fk: it }));
+
+	const jsonDropFKs = fksDeletes.filter((fk) => {
+		const fromDeletedTable = deletedTables.some((x) => x.schema === fk.schema && x.name === fk.table);
+		const toDeletedTable = fk.table !== fk.tableTo
+			&& deletedTables.some((x) => x.schema === fk.schemaTo && x.name === fk.tableTo);
+		if (fromDeletedTable && !toDeletedTable) return false;
+		return true;
+	}).map((it) => prepareStatement('drop_fk', { fk: it }));
+
+	const jsonRenameReferences = fksRenames.map((it) =>
+		prepareStatement('rename_constraint', {
+			schema: it.to.schema,
+			table: it.to.table,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+
+	const jsonAlterCheckConstraints = alteredChecks.filter((it) => it.value && mode !== 'push').map((it) =>
+		prepareStatement('alter_check', { diff: it })
+	);
+	const jsonCreatePoliciesStatements = policyCreates.map((it) => prepareStatement('create_policy', { policy: it }));
+	const jsonDropPoliciesStatements = policyDeletes.map((it) => prepareStatement('drop_policy', { policy: it }));
+	const jsonRenamePoliciesStatements = policyRenames.map((it) => prepareStatement('rename_policy', it));
+
+	const alteredPolicies = alters.filter((it) => it.entityType === 'policies').filter((it) => {
+		if (it.withCheck && it.withCheck.from && it.withCheck.to) {
+			if (it.withCheck.from === `(${it.withCheck.to})` || it.withCheck.to === `(${it.withCheck.from})`) {
+				delete it.withCheck;
+			}
+		}
+		return ddl1.policies.hasDiff(it);
+	});
+
+	// if I drop policy/ies, I should check if table only had this policy/ies and turn off
+	// for non explicit rls =
+
+	// using/withcheck in policy is a SQL expression which can be formatted by database in a different way,
+	// thus triggering recreations/alternations on push
+	const jsonAlterOrRecreatePoliciesStatements = alteredPolicies.filter((it) => {
+		return it.as || it.for || it.roles || !((it.using || it.withCheck) && mode === 'push');
+	}).map(
+		(it) => {
+			const to = ddl2.policies.one({
+				schema: it.schema,
+				table: it.table,
+				name: it.name,
+			})!;
+			if (it.for || it.as) {
+				return prepareStatement('recreate_policy', {
+					diff: it,
+					policy: to,
+				});
+			} else {
+				return prepareStatement('alter_policy', {
+					diff: it,
+					policy: to,
+				});
+			}
+		},
+	);
+
+	// explicit rls alters
+	const rlsAlters = alters.filter((it) => it.entityType === 'tables').filter((it) => it.isRlsEnabled);
+
+	const jsonAlterRlsStatements = rlsAlters.map((it) =>
+		prepareStatement('alter_rls', {
+			schema: it.schema,
+			name: it.name,
+			isRlsEnabled: it.isRlsEnabled?.to || false,
+		})
+	);
+
+	for (const it of policyDeletes) {
+		if (rlsAlters.some((alter) => alter.schema === it.schema && alter.name === it.table)) continue; // skip for explicit
+
+		const had = ddl1.policies.list({ schema: it.schema, table: it.table }).length;
+		const has = ddl2.policies.list({ schema: it.schema, table: it.table }).length;
+
+		const prevTable = ddl1.tables.one({ schema: it.schema, name: it.table });
+		const table = ddl2.tables.one({ schema: it.schema, name: it.table });
+
+		// I don't want dedup here, not a valuable optimisation
+		if (
+			table !== null // not external table
+			&& (had > 0 && has === 0 && prevTable && prevTable.isRlsEnabled === false)
+			&& !jsonAlterRlsStatements.some((st) => st.schema === it.schema && st.name === it.table)
+		) {
+			jsonAlterRlsStatements.push(prepareStatement('alter_rls', {
+				schema: it.schema,
+				name: it.table,
+				isRlsEnabled: false,
+			}));
+		}
+	}
+
+	for (const it of policyCreates) {
+		if (rlsAlters.some((alter) => alter.schema === it.schema && alter.name === it.table)) continue; // skip for explicit
+		if (createdTables.some((t) => t.schema === it.schema && t.name === it.table)) continue; // skip for created tables
+		if (jsonAlterRlsStatements.some((st) => st.schema === it.schema && st.name === it.table)) continue; // skip for existing rls toggles
+
+		const had = ddl1.policies.list({ schema: it.schema, table: it.table }).length;
+		const has = ddl2.policies.list({ schema: it.schema, table: it.table }).length;
+
+		const table = ddl2.tables.one({ schema: it.schema, name: it.table });
+
+		if (
+			table !== null // not external table
+			&& (had === 0 && has > 0 && !table.isRlsEnabled)
+		) {
+			jsonAlterRlsStatements.push(prepareStatement('alter_rls', {
+				schema: it.schema,
+				name: it.table,
+				isRlsEnabled: true,
+			}));
+		}
+	}
+
+	const jsonCreateEnums = createdEnums.map((it) => prepareStatement('create_enum', { enum: it }));
+	const jsonDropEnums = deletedEnums.map((it) => prepareStatement('drop_enum', { enum: it }));
+	const jsonMoveEnums = movedEnums.map((it) => prepareStatement('move_enum', it));
+	const jsonRenameEnums = renamedEnums.map((it) =>
+		prepareStatement('rename_enum', {
+			schema: it.to.schema,
+			from: it.from.name,
+			to: it.to.name,
+		})
+	);
+	const enumsAlters = alters.filter((it) => it.entityType === 'enums');
+
+	const recreateEnums = [] as Extract<JsonStatement, { type: 'recreate_enum' }>[];
+	const jsonAlterEnums = [] as Extract<JsonStatement, { type: 'alter_enum' }>[];
+
+	for (const alter of enumsAlters) {
+		const values = alter.values!;
+		const res = diffStringArrays(values.from, values.to);
+		const e = { ...alter, values: values.to };
+
+		if (res.some((it) => it.type === 'removed')) {
+			// recreate enum
+			const columns = ddl1.columns.list({ typeSchema: alter.schema, type: alter.name })
+				.map((it) => {
+					const c2 = ddl2.columns.one({ schema: it.schema, table: it.table, name: it.name });
+					if (c2 === null) return null;
+
+					const def = {
+						right: c2.default,
+						left: it.default,
+					};
+					return { ...it, default: def };
+				})
+				.filter((x) => x !== null);
+			recreateEnums.push(prepareStatement('recreate_enum', { to: e, columns, from: alter.$left }));
+		} else {
+			jsonAlterEnums.push(prepareStatement('alter_enum', { diff: res, to: e, from: alter.$left }));
+		}
+	}
+
+	const jsonAlterColumns = columnAlters.filter((it) => !(it.generated && it.generated.to !== null))
+		.filter((it) => {
+			// if column is of type enum we're about to recreate - we will reset default anyway
+			if (
+				it.default
+				&& recreateEnums.some((x) =>
+					x.columns.some((c) => it.schema === c.schema && it.table === c.table && it.name === c.name)
+				)
+			) {
+				delete it.default;
+			}
+
+			if (it.notNull && it.notNull.to && (it.$right.generated || it.$right.identity)) {
+				delete it.notNull;
+			}
+
+			const pkIn2 = ddl2.pks.one({ schema: it.schema, table: it.table, columns: { CONTAINS: it.name } });
+			if (it.notNull && pkIn2) {
+				delete it.notNull;
+			}
+
+			return ddl2.columns.hasDiff(it);
+		})
+		.map((it) => {
+			const column = it.$right;
+			const wasSerial = isSerialType(it.$left.type);
+			const toSerial: boolean = !isSerialType(it.$left.type) && isSerialType(it.$right.type);
+			const isEnum = ddl2.enums.one({ schema: column.typeSchema ?? 'public', name: column.type }) !== null;
+			const wasEnum =
+				(it.type && ddl1.enums.one({ schema: column.typeSchema ?? 'public', name: it.type.from }) !== null)
+					?? false;
+
+			return prepareStatement('alter_column', {
+				diff: it,
+				to: column,
+				isEnum,
+				wasEnum,
+				wasSerial,
+				toSerial,
+			});
+		});
+
+	const createSequences = createdSequences.map((it) => prepareStatement('create_sequence', { sequence: it }));
+	const dropSequences = deletedSequences.map((it) => prepareStatement('drop_sequence', { sequence: it }));
+	const moveSequences = movedSequences.map((it) => prepareStatement('move_sequence', it));
+	const renameSequences = renamedSequences.map((it) => prepareStatement('rename_sequence', it));
+	const sequencesAlter = alters.filter((it) => it.entityType === 'sequences');
+	const jsonAlterSequences = sequencesAlter.map((it) =>
+		prepareStatement('alter_sequence', { diff: it, sequence: it.$right })
+	);
+
+	const jsonCreateRoles = createdRoles.map((it) => prepareStatement('create_role', { role: it }));
+	const jsonDropRoles = deletedRoles.map((it) => prepareStatement('drop_role', { role: it }));
+	const jsonRenameRoles = renamedRoles.map((it) => prepareStatement('rename_role', it));
+	const jsonAlterRoles = alters.filter((it) => it.entityType === 'roles').map((it) =>
+		prepareStatement('alter_role', { diff: it, role: it.$right })
+	);
+
+	const jsonGrantPrivileges = createdPrivileges.map((it) => prepareStatement('grant_privilege', { privilege: it }));
+	const jsonRevokePrivileges = deletedPrivileges.map((it) => prepareStatement('revoke_privilege', { privilege: it }));
+	const jsonAlterPrivileges = alters.filter((it) => it.entityType === 'privileges').map((it) =>
+		prepareStatement('regrant_privilege', { privilege: it.$right, diff: it })
+	);
+
+	const createSchemas = createdSchemas.map((it) => prepareStatement('create_schema', it));
+	const dropSchemas = deletedSchemas.map((it) => prepareStatement('drop_schema', it));
+	const renameSchemas = renamedSchemas.map((it) => prepareStatement('rename_schema', it));
+
+	const createTables = createdTables.map((it) => prepareStatement('create_table', { table: tableFromDDL(it, ddl2) }));
+
+	const createViews = createdViews.map((it) => prepareStatement('create_view', { view: it }));
+
+	const jsonDropViews = deletedViews.map((it) => prepareStatement('drop_view', { view: it, cause: null }));
+
+	const jsonRenameViews = renamedViews.map((it) => prepareStatement('rename_view', it));
+
+	const jsonMoveViews = movedViews.map((it) =>
+		prepareStatement('move_view', { fromSchema: it.from.schema, toSchema: it.to.schema, view: it.to })
+	);
+
+	const filteredViewAlters = alters.filter((it): it is DiffEntities['views'] => {
+		if (it.entityType !== 'views') return false;
+
+		if (it.definition && mode === 'push') {
+			delete it.definition;
+		}
+
+		// default access method
+		// from db -> heap,
+		// drizzle schema -> null
+		//
+		// should work for push and generate since that is commutative
+		// + when we introspect we recieve heap,
+		if (it.using && !it.using.to && it.using.from === defaults.accessMethod) {
+			delete it.using;
+		}
+
+		if (mode === 'push' && it.tablespace && it.tablespace.from === null && it.tablespace.to === defaults.tablespace) {
+			delete it.tablespace;
+		}
+
+		return ddl2.views.hasDiff(it);
+	});
+
+	const viewsAlters = filteredViewAlters.map((it) => ({ diff: it, view: it.$right }));
+
+	const jsonAlterViews = viewsAlters.filter((it) => !it.diff.definition).map((it) => {
+		return prepareStatement('alter_view', {
+			diff: it.diff,
+			view: it.view,
+		});
+	});
+
+	// recreate views
+	viewsAlters.filter((it) => it.diff.definition).forEach((entry) => {
+		const it = entry.view;
+		const schemaRename = renamedSchemas.find((r) => r.to.name === it.schema);
+		const schema = schemaRename ? schemaRename.from.name : it.schema;
+		const viewRename = renamedViews.find((r) => r.to.schema === it.schema && r.to.name === it.name);
+		const name = viewRename ? viewRename.from.name : it.name;
+		const from = ddl1Copy.views.one({ schema, name });
+
+		if (!from) {
+			throw new Error(`
+				Missing view in original ddl:
+				${it.schema}:${it.name}
+				${schema}:${name}
+				`);
+		}
+
+		jsonDropViews.push(prepareStatement('drop_view', { view: it, cause: from }));
+		createViews.push(prepareStatement('create_view', { view: it }));
+	});
+
+	const columnsToRecreate = columnAlters.filter((it) => it.generated && it.generated.to !== null).filter((it) => {
+		// if push and definition changed
+		return !(it.generated?.to && it.generated.from && mode === 'push');
+	});
+
+	const jsonRecreateColumns = columnsToRecreate.map((it) => {
+		const indexes = ddl2.indexes.list({ table: it.table, schema: it.schema }).filter((index) =>
+			index.columns.some((column) => trimChar(column.value, '`') === it.name)
+		);
+		for (const index of indexes) {
+			jsonCreateIndexes.push({ type: 'create_index', index });
+		}
+
+		const uniques = ddl2.uniques.list({ table: it.table, schema: it.schema, columns: { CONTAINS: it.name } });
+		for (const unique of uniques) {
+			jsonAddedUniqueConstraints.push({ type: 'add_unique', unique });
+		}
+
+		// Not sure if anyone tries to add fk on generated column or from it, but still...
+		const fksFrom = ddl2.fks.list({ table: it.table, schema: it.schema, columns: { CONTAINS: it.name } });
+		const fksTo = ddl2.fks.list({ tableTo: it.table, schemaTo: it.schema, columnsTo: { CONTAINS: it.name } });
+		for (const fkFrom of fksFrom) {
+			jsonDropFKs.push({ type: 'drop_fk', fk: fkFrom });
+		}
+		for (const fkTo of fksTo) {
+			jsonDropFKs.push({ type: 'drop_fk', fk: fkTo });
+			jsonCreateFKs.push({ type: 'create_fk', fk: fkTo });
+		}
+
+		return prepareStatement('recreate_column', {
+			diff: it,
+			isPK: ddl2.pks.one({ schema: it.schema, table: it.table, columns: [it.name] }) !== null,
+		});
+	});
+
+	jsonStatements.push(...createSchemas);
+	jsonStatements.push(...renameSchemas);
+	jsonStatements.push(...jsonCreateEnums);
+	jsonStatements.push(...jsonMoveEnums);
+	jsonStatements.push(...jsonRenameEnums);
+	jsonStatements.push(...jsonAlterEnums);
+
+	jsonStatements.push(...createSequences);
+	jsonStatements.push(...moveSequences);
+	jsonStatements.push(...renameSequences);
+	jsonStatements.push(...jsonAlterSequences);
+
+	jsonStatements.push(...jsonRenameRoles);
+	jsonStatements.push(...jsonDropRoles);
+	jsonStatements.push(...jsonCreateRoles);
+	jsonStatements.push(...jsonAlterRoles);
+
+	jsonStatements.push(...jsonRevokePrivileges);
+	jsonStatements.push(...jsonGrantPrivileges);
+	jsonStatements.push(...jsonAlterPrivileges);
+
+	jsonStatements.push(...createTables);
+
+	jsonStatements.push(...jsonDropViews);
+	jsonStatements.push(...jsonRenameViews);
+	jsonStatements.push(...jsonMoveViews);
+	jsonStatements.push(...jsonAlterViews);
+
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonDropPoliciesStatements); // before drop tables
+	jsonStatements.push(...jsonDropFKs);
+
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonAlterRlsStatements);
+	jsonStatements.push(...jsonSetTableSchemas);
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...jsonDropUniqueConstraints);
+	jsonStatements.push(...jsonDropCheckConstraints);
+	jsonStatements.push(...jsonRenamedCheckConstraints);
+
+	// TODO: ? will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonRenameIndexes);
+	jsonStatements.push(...jsonDropIndexes);
+	jsonStatements.push(...jsonDropPrimaryKeys);
+
+	jsonStatements.push(...jsonRenameReferences);
+	jsonStatements.push(...jsonAddColumnsStatemets);
+	jsonStatements.push(...jsonAddPrimaryKeys);
+	jsonStatements.push(...jsonRenamePrimaryKey);
+	jsonStatements.push(...recreateEnums);
+	jsonStatements.push(...jsonRecreateColumns);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+	jsonStatements.push(...jsonAlteredPKs);
+	jsonStatements.push(...jsonAlterColumns);
+
+	jsonStatements.push(...jsonRecreateIndex);
+
+	jsonStatements.push(...jsonRenamedUniqueConstraints);
+	jsonStatements.push(...jsonAddedUniqueConstraints);
+	jsonStatements.push(...jsonAlteredUniqueConstraints);
+	jsonStatements.push(...jsonCreateIndexes); // above fks for uniqueness constraint to come first
+
+	jsonStatements.push(...jsonCreateFKs);
+	jsonStatements.push(...jsonRecreateFKs);
+
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+
+	jsonStatements.push(...jsonAlterCheckConstraints);
+
+	jsonStatements.push(...createViews);
+
+	jsonStatements.push(...jsonRenamePoliciesStatements);
+	jsonStatements.push(...jsonCreatePoliciesStatements);
+	jsonStatements.push(...jsonAlterOrRecreatePoliciesStatements);
+
+	jsonStatements.push(...jsonDropEnums);
+	jsonStatements.push(...dropSequences);
+	jsonStatements.push(...dropSchemas);
+
+	const { groupedStatements, sqlStatements } = fromJson(jsonStatements);
+
+	const renames = prepareMigrationRenames([
+		...renameSchemas,
+		...renamedEnums,
+		...renamedOrMovedTables,
+		...columnRenames,
+		...uniqueRenames,
+		...checkRenames,
+		...indexesRenames,
+		...pksRenames,
+		...fksRenames,
+		...policyRenames,
+		...renamedOrMovedViews,
+		...renamedRoles,
+		...renamedOrMovedSequences,
+	]);
+
+	return {
+		statements: jsonStatements,
+		sqlStatements,
+		groupedStatements: groupedStatements,
+		renames: renames,
+	};
+};
diff --git a/drizzle-kit/src/dialects/postgres/drizzle.ts b/drizzle-kit/src/dialects/postgres/drizzle.ts
new file mode 100644
index 0000000000..b7751833a6
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/drizzle.ts
@@ -0,0 +1,903 @@
+import { getTableName, is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type {
+	AnyPgColumn,
+	AnyPgTable,
+	PgEnum,
+	PgMaterializedView,
+	PgMaterializedViewWithConfig,
+	PgSequence,
+	UpdateDeleteAction,
+	ViewWithConfig,
+} from 'drizzle-orm/pg-core';
+import {
+	getMaterializedViewConfig,
+	getTableConfig,
+	getViewConfig,
+	IndexedColumn,
+	isPgEnum,
+	isPgMaterializedView,
+	isPgSequence,
+	isPgView,
+	PgDialect,
+	PgEnumColumn,
+	PgEnumObjectColumn,
+	PgGeometry,
+	PgGeometryObject,
+	PgLineABC,
+	PgLineTuple,
+	PgPointObject,
+	PgPointTuple,
+	PgPolicy,
+	PgRole,
+	PgSchema,
+	PgTable,
+	PgView,
+	uniqueKeyName,
+} from 'drizzle-orm/pg-core';
+import { assertUnreachable } from '../../utils';
+import { loadModule } from '../../utils/utils-node';
+import type { EntityFilter } from '../pull-utils';
+import { getOrNull } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Schema,
+	SchemaError,
+	SchemaWarning,
+	UniqueConstraint,
+} from './ddl';
+import {
+	defaultNameForFK,
+	defaultNameForPK,
+	GeometryPoint,
+	indexName,
+	Line,
+	maxRangeForIdentityBasedOn,
+	minRangeForIdentityBasedOn,
+	Point,
+	splitSqlType,
+	stringFromIdentityProperty,
+	trimDefaultValueSuffix,
+	typeFor,
+} from './grammar';
+
+export const policyFrom = (policy: PgPolicy, dialect: PgDialect) => {
+	const mappedTo = !policy.to
+		? ['public']
+		: typeof policy.to === 'string'
+		? [policy.to]
+		: is(policy.to, PgRole)
+		? [(policy.to as PgRole).name]
+		: Array.isArray(policy.to)
+		? policy.to.map((it) => {
+			if (typeof it === 'string') {
+				return it;
+			} else if (is(it, PgRole)) {
+				return it.name;
+			}
+			return '' as never; // unreachable unless error in types
+		})
+		: ('' as never); // unreachable unless error in types
+
+	const policyAs = (policy.as?.toUpperCase() as Policy['as']) ?? 'PERMISSIVE';
+	const policyFor = (policy.for?.toUpperCase() as Policy['for']) ?? 'ALL';
+	const policyTo = mappedTo.sort();
+	const policyUsing = is(policy.using, SQL)
+		? dialect.sqlToQuery(policy.using).sql
+		: null;
+	const withCheck = is(policy.withCheck, SQL)
+		? dialect.sqlToQuery(policy.withCheck).sql
+		: null;
+
+	return {
+		name: policy.name,
+		as: policyAs,
+		for: policyFor,
+		roles: policyTo,
+		using: policyUsing,
+		withCheck,
+	};
+};
+
+export const unwrapColumn = (column: AnyPgColumn) => {
+	// In the new architecture, columns have a dimensions property directly
+	const dimensions = (column as any).dimensions ?? 0;
+	const baseColumn = column;
+
+	const isEnum = is(baseColumn, PgEnumColumn) || is(baseColumn, PgEnumObjectColumn);
+	const typeSchema = isEnum
+		? baseColumn.enum.schema || 'public'
+		: null;
+
+	let sqlBaseType = baseColumn.getSQLType();
+	// numeric(6, 2) -> numeric(6,2)
+	sqlBaseType = sqlBaseType.replace(', ', ',');
+
+	/* legacy, for not to patch orm and don't up snapshot */
+	sqlBaseType = sqlBaseType.startsWith('timestamp (') ? sqlBaseType.replace('timestamp (', 'timestamp(') : sqlBaseType;
+
+	const { type, options } = splitSqlType(sqlBaseType);
+	const sqlType = dimensions > 0 ? `${sqlBaseType}${'[]'.repeat(dimensions)}` : sqlBaseType;
+	return {
+		baseColumn,
+		dimensions,
+		isEnum,
+		typeSchema,
+		sqlType,
+		baseType: type,
+		options,
+	};
+};
+
+export const transformOnUpdateDelete = (on: UpdateDeleteAction): ForeignKey['onUpdate'] => {
+	if (on === 'no action') return 'NO ACTION';
+	if (on === 'cascade') return 'CASCADE';
+	if (on === 'restrict') return 'RESTRICT';
+	if (on === 'set default') return 'SET DEFAULT';
+	if (on === 'set null') return 'SET NULL';
+
+	assertUnreachable(on);
+};
+
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type JsonObject = { [key: string]: JsonValue };
+type JsonArray = JsonValue[];
+
+export const defaultFromColumn = (
+	base: AnyPgColumn,
+	def: unknown,
+	dimensions: number,
+	dialect: PgDialect,
+): Column['default'] => {
+	if (typeof def === 'undefined') return null;
+
+	if (is(def, SQL)) {
+		let sql = dialect.sqlToQuery(def).sql;
+		sql = trimDefaultValueSuffix(sql);
+
+		// TODO: check if needed
+		// const isText = /^'(?:[^']|'')*'$/.test(sql);
+		// sql = isText ? trimChar(sql, "'") : sql;
+
+		return sql;
+	}
+
+	const { baseColumn, isEnum } = unwrapColumn(base);
+	const grammarType = typeFor(base.getSQLType(), isEnum);
+	if (is(baseColumn, PgPointTuple) || is(baseColumn, PgPointObject)) {
+		return dimensions > 0 && Array.isArray(def)
+			? def.flat(5).length === 0
+				? "'{}'"
+				: Point.defaultArrayFromDrizzle(def, dimensions, baseColumn.mode)
+			: Point.defaultFromDrizzle(def, baseColumn.mode);
+	}
+	if (is(baseColumn, PgLineABC) || is(baseColumn, PgLineTuple)) {
+		return dimensions > 0 && Array.isArray(def)
+			? def.flat(5).length === 0
+				? "'{}'"
+				: Line.defaultArrayFromDrizzle(def, dimensions, baseColumn.mode)
+			: Line.defaultFromDrizzle(def, baseColumn.mode);
+	}
+	if (is(baseColumn, PgGeometry) || is(baseColumn, PgGeometryObject)) {
+		return dimensions > 0 && Array.isArray(def)
+			? def.flat(5).length === 0
+				? "'{}'"
+				: GeometryPoint.defaultArrayFromDrizzle(def, dimensions, baseColumn.mode, baseColumn.srid)
+			: GeometryPoint.defaultFromDrizzle(def, baseColumn.mode, baseColumn.srid);
+	}
+	if (dimensions > 0 && Array.isArray(def)) {
+		if (def.flat(5).length === 0) return "'{}'";
+
+		return grammarType.defaultArrayFromDrizzle(def, dimensions);
+	}
+
+	return grammarType.defaultFromDrizzle(def);
+};
+
+/*
+	We map drizzle entities into interim schema entities,
+	so that both Drizzle Kit and Drizzle Studio are able to share
+	common business logic of composing and diffing InternalSchema
+
+	By having interim schemas based on arrays instead of records - we can postpone
+	collissions(duplicate indexes, columns, etc.) checking/or printing via extra `errors` field upwards,
+	while trimming serializer.ts of Hanji & Chalk dependencies
+*/
+export const fromDrizzleSchema = (
+	schema: {
+		schemas: PgSchema[];
+		tables: AnyPgTable[];
+		enums: PgEnum<any>[];
+		sequences: PgSequence[];
+		roles: PgRole[];
+		policies: PgPolicy[];
+		views: PgView[];
+		matViews: PgMaterializedView[];
+	},
+	filter: EntityFilter,
+): {
+	schema: InterimSchema;
+	errors: SchemaError[];
+	warnings: SchemaWarning[];
+} => {
+	const dialect = new PgDialect();
+	const errors: SchemaError[] = [];
+	const warnings: SchemaWarning[] = [];
+
+	const res: InterimSchema = {
+		indexes: [],
+		pks: [],
+		fks: [],
+		uniques: [],
+		checks: [],
+		columns: [],
+		policies: [],
+		enums: [],
+		roles: [],
+		privileges: [],
+		schemas: [],
+		sequences: [],
+		tables: [],
+		viewColumns: [],
+		views: [],
+	};
+
+	res.schemas = schema.schemas
+		.filter((it) => {
+			return !it.isExisting && it.schemaName !== 'public' && filter({ type: 'schema', name: it.schemaName });
+		})
+		.map<Schema>((it) => ({
+			entityType: 'schemas',
+			name: it.schemaName,
+		}));
+
+	const tableConfigPairs = schema.tables.map((it) => {
+		return { config: getTableConfig(it), table: it };
+	}).filter((x) => {
+		return filter({ type: 'table', schema: x.config.schema ?? 'public', name: x.config.name });
+	});
+
+	for (const policy of schema.policies) {
+		if (
+			!('_linkedTable' in policy)
+			|| typeof policy._linkedTable === 'undefined'
+		) {
+			warnings.push({ type: 'policy_not_linked', policy: policy.name });
+			continue;
+		}
+
+		// @ts-ignore
+		const { schema: configSchema, name: tableName } = getTableConfig(policy._linkedTable);
+
+		// filter policies by linked table
+		if (!filter({ type: 'table', schema: configSchema ?? 'public', name: tableName })) continue;
+
+		const p = policyFrom(policy, dialect);
+		res.policies.push({
+			entityType: 'policies',
+			schema: configSchema ?? 'public',
+			table: tableName,
+			name: p.name,
+			as: p.as,
+			for: p.for,
+			roles: p.roles,
+			using: p.using,
+			withCheck: p.withCheck,
+		});
+	}
+
+	res.tables = tableConfigPairs.map((it) => {
+		const config = it.config;
+		const schema = config.schema ?? 'public';
+		const isRlsEnabled = config.enableRLS || config.policies.length > 0
+			|| res.policies.some((x) => x.schema === schema && x.table === config.name);
+
+		return {
+			entityType: 'tables',
+			schema,
+			name: config.name,
+			isRlsEnabled,
+		} satisfies PostgresEntities['tables'];
+	});
+
+	for (const { table, config } of tableConfigPairs) {
+		const {
+			name: tableName,
+			columns: drizzleColumns,
+			indexes: drizzleIndexes,
+			foreignKeys: drizzleFKs,
+			checks: drizzleChecks,
+			schema: drizzleSchema,
+			primaryKeys: drizzlePKs,
+			uniqueConstraints: drizzleUniques,
+			policies: drizzlePolicies,
+		} = config;
+
+		const schema = drizzleSchema || 'public';
+
+		res.columns.push(
+			...drizzleColumns.map<InterimColumn>((column) => {
+				const { name } = column;
+
+				const isPk = column.primary
+					|| config.primaryKeys.find((pk) =>
+							pk.columns.some((col) => col.name ? col.name === column.name : col.keyAsName === column.keyAsName)
+						) !== undefined;
+
+				const notNull = column.notNull || isPk;
+
+				const generated = column.generated;
+				const identity = column.generatedIdentity;
+
+				const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment)
+					?? '1';
+				const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
+					?? (parseFloat(increment) < 0
+						? minRangeForIdentityBasedOn(column.columnType)
+						: '1');
+				const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
+					?? (parseFloat(increment) < 0
+						? '-1'
+						: maxRangeForIdentityBasedOn(column.getSQLType()));
+				const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
+					?? (parseFloat(increment) < 0 ? maxValue : minValue);
+				const cache = Number(stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? 1);
+
+				const generatedValue: Column['generated'] = generated
+					? {
+						as: is(generated.as, SQL)
+							? dialect.sqlToQuery(generated.as as SQL).sql
+							: typeof generated.as === 'function'
+							? dialect.sqlToQuery(generated.as() as SQL).sql
+							: String(generated.as),
+
+						type: 'stored',
+					}
+					: null;
+
+				const identityValue = identity
+					? {
+						type: identity.type,
+						name: identity.sequenceName ?? `${tableName}_${name}_seq`,
+						increment,
+						startWith,
+						minValue,
+						maxValue,
+						cache,
+						cycle: identity?.sequenceOptions?.cycle ?? false,
+					}
+					: null;
+
+				const { baseColumn, dimensions, typeSchema, sqlType } = unwrapColumn(column);
+				const columnDefault = defaultFromColumn(baseColumn, column.default, dimensions, dialect);
+
+				return {
+					entityType: 'columns',
+					schema: schema,
+					table: tableName,
+					name,
+					type: sqlType.replaceAll('[]', ''),
+					typeSchema: typeSchema ?? null,
+					dimensions: dimensions,
+					pk: column.primary,
+					pkName: null,
+					notNull: notNull,
+					default: columnDefault,
+					generated: generatedValue,
+					unique: column.isUnique,
+					uniqueName: column.uniqueName ?? null,
+					uniqueNullsNotDistinct: column.uniqueType === 'not distinct',
+					identity: identityValue,
+				} satisfies InterimColumn;
+			}),
+		);
+
+		res.pks.push(
+			...drizzlePKs.map<PrimaryKey>((pk) => {
+				const columnNames = pk.columns.map((c) => c.name);
+
+				const name = pk.name || defaultNameForPK(tableName);
+
+				return {
+					entityType: 'pks',
+					schema: schema,
+					table: tableName,
+					name: name,
+					columns: columnNames,
+					nameExplicit: pk.isNameExplicit,
+				};
+			}),
+		);
+
+		res.uniques.push(
+			...drizzleUniques.map<UniqueConstraint>((unq) => {
+				const columnNames = unq.columns.map((c) => c.name);
+				const name = unq.isNameExplicit ? unq.name! : uniqueKeyName(table, columnNames);
+				return {
+					entityType: 'uniques',
+					schema: schema,
+					table: tableName,
+					name,
+					nameExplicit: unq.isNameExplicit,
+					nullsNotDistinct: unq.nullsNotDistinct,
+					columns: columnNames,
+				} satisfies UniqueConstraint;
+			}),
+		);
+
+		res.fks.push(
+			...drizzleFKs.map<ForeignKey>((fk) => {
+				const onDelete = fk.onDelete;
+				const onUpdate = fk.onUpdate;
+				const reference = fk.reference();
+
+				const tableTo = getTableName(reference.foreignTable);
+				const schemaTo = getTableConfig(reference.foreignTable).schema || 'public';
+				const columnsFrom = reference.columns.map((it) => it.name);
+				const columnsTo = reference.foreignColumns.map((it) => it.name);
+
+				const name = fk.isNameExplicit() ? fk.getName() : defaultNameForFK(tableName, columnsFrom, tableTo, columnsTo);
+
+				return {
+					entityType: 'fks',
+					schema: schema,
+					table: tableName,
+					name,
+					nameExplicit: fk.isNameExplicit(),
+					tableTo,
+					schemaTo,
+					columns: columnsFrom,
+					columnsTo,
+					onDelete: onDelete ? transformOnUpdateDelete(onDelete) : null,
+					onUpdate: onUpdate ? transformOnUpdateDelete(onUpdate) : null,
+				} satisfies ForeignKey;
+			}),
+		);
+
+		for (const index of drizzleIndexes) {
+			const columns = index.config.columns;
+			for (const column of columns) {
+				if (is(column, IndexedColumn) && column.type !== 'PgVector') continue;
+
+				if (is(column, SQL) && !index.config.name) {
+					errors.push({
+						type: 'index_no_name',
+						schema: schema,
+						table: getTableName(index.config.table),
+						sql: dialect.sqlToQuery(column).sql,
+					});
+					continue;
+				}
+
+				if (
+					is(column, IndexedColumn)
+					&& column.type === 'PgVector'
+					&& !column.indexConfig.opClass
+				) {
+					const columnName = column.name;
+					errors.push({
+						type: 'pgvector_index_noop',
+						table: tableName,
+						column: columnName,
+						indexName: index.config.name!,
+						method: index.config.method!,
+					});
+				}
+			}
+		}
+
+		res.indexes.push(
+			...drizzleIndexes.map<InterimIndex>((value) => {
+				const columns = value.config.columns;
+
+				let indexColumnNames = columns.map((it) => {
+					const name = (it as IndexedColumn).name;
+					return name;
+				});
+
+				const name = value.config.name ?? indexName(tableName, indexColumnNames);
+
+				let indexColumns = columns.map((it) => {
+					if (is(it, SQL)) {
+						return {
+							value: dialect.sqlToQuery(it, 'indexes').sql,
+							isExpression: true,
+							asc: true,
+							nullsFirst: false,
+							opclass: null,
+						} satisfies Index['columns'][number];
+					} else {
+						it = it as IndexedColumn;
+
+						let nullsFirst = false;
+						let asc = it.indexConfig?.order ? it.indexConfig.order === 'asc' : true;
+						if (!asc && !it.indexConfig?.nulls) nullsFirst = true;
+						else nullsFirst = it.indexConfig?.nulls ? it.indexConfig.nulls === 'first' : nullsFirst;
+
+						return {
+							value: (it as IndexedColumn).name,
+							isExpression: false,
+							asc: asc,
+							nullsFirst: nullsFirst,
+							opclass: it.indexConfig?.opClass
+								? {
+									name: it.indexConfig.opClass,
+									default: false,
+								}
+								: null,
+						} satisfies Index['columns'][number];
+					}
+				});
+
+				const withOpt = Object.entries(value.config.with || {})
+					.map((it) => `${it[0]}=${it[1]}`)
+					.join(', ');
+
+				let where = value.config.where ? dialect.sqlToQuery(value.config.where.inlineParams(), 'indexes').sql : '';
+				where = where === 'true' ? '' : where;
+
+				return {
+					entityType: 'indexes',
+					schema,
+					table: tableName,
+					name,
+					nameExplicit: value.isNameExplicit,
+					columns: indexColumns,
+					isUnique: value.config.unique,
+					where: where ? where : null,
+					concurrently: value.config.concurrently ?? false,
+					method: value.config.method ?? 'btree',
+					with: withOpt,
+					forPK: false,
+					forUnique: false,
+				} satisfies InterimIndex;
+			}),
+		);
+
+		res.policies.push(
+			...drizzlePolicies.map<Policy>((policy) => {
+				const p = policyFrom(policy, dialect);
+				return {
+					entityType: 'policies',
+					schema: schema,
+					table: tableName,
+					name: p.name,
+					as: p.as,
+					for: p.for,
+					roles: p.roles,
+					using: p.using,
+					withCheck: p.withCheck,
+				};
+			}),
+		);
+
+		res.checks.push(
+			...drizzleChecks.map<CheckConstraint>((check) => {
+				const value = dialect.sqlToQuery(check.value.inlineParams(), 'indexes').sql;
+
+				const checkName = check.name;
+				return {
+					entityType: 'checks',
+					schema,
+					table: tableName,
+					name: checkName,
+					value,
+				};
+			}),
+		);
+	}
+
+	for (const sequence of schema.sequences) {
+		const name = sequence.seqName!;
+		const increment = stringFromIdentityProperty(sequence.seqOptions?.increment) ?? '1';
+		const minValue = stringFromIdentityProperty(sequence.seqOptions?.minValue)
+			?? (parseFloat(increment) < 0 ? '-9223372036854775808' : '1');
+		const maxValue = stringFromIdentityProperty(sequence.seqOptions?.maxValue)
+			?? (parseFloat(increment) < 0 ? '-1' : '9223372036854775807');
+		const startWith = stringFromIdentityProperty(sequence.seqOptions?.startWith)
+			?? (parseFloat(increment) < 0 ? maxValue : minValue);
+		const cache = Number(stringFromIdentityProperty(sequence.seqOptions?.cache) ?? 1);
+		res.sequences.push({
+			entityType: 'sequences',
+			name,
+			schema: sequence.schema ?? 'public',
+			incrementBy: increment,
+			startWith,
+			minValue,
+			maxValue,
+			cacheSize: cache,
+			cycle: sequence.seqOptions?.cycle ?? false,
+		});
+	}
+
+	for (const _role of schema.roles) {
+		const role = _role as any;
+		if (role._existing) continue;
+
+		res.roles.push({
+			entityType: 'roles',
+			name: role.name,
+			superuser: role.superuser ?? false,
+			inherit: role.inherit ?? true,
+			createRole: role.createRole ?? false,
+			createDb: role.createDb ?? false,
+			canLogin: role.canLogin ?? false,
+			replication: role.replication ?? false,
+			bypassRls: role.bypassRls ?? false,
+			connLimit: role.connLimit ?? -1,
+			password: role.password ?? null,
+			validUntil: role.validUntil ?? null,
+		});
+	}
+
+	const combinedViews = [...schema.views, ...schema.matViews].sort((a, b) => {
+		// this sort fixes this issue: https://github.com/drizzle-team/drizzle-orm/issues/4520
+		// When using `prepareFromSchemaFiles` to read schema files, views were returned in an unpredictable order
+		// (not in order that is was declared in schema.ts).
+		// This caused dependent views to appear before their dependencies,
+		// which breaks migration
+		const aConfig = is(a, PgView) ? getViewConfig(a) : getMaterializedViewConfig(a);
+		const bConfig = is(b, PgView) ? getViewConfig(b) : getMaterializedViewConfig(b);
+
+		// If a's fields include b, a depends on b -> b comes first
+		if (aConfig.query?.queryChunks.includes(b)) return 1;
+
+		// If b's fields include a, b depends on a -> a comes first
+		if (bConfig.query?.queryChunks.includes(a)) return -1;
+
+		return 0;
+	}).map((it) => {
+		if (is(it, PgView)) {
+			return {
+				...getViewConfig(it),
+				materialized: false,
+				tablespace: undefined,
+				using: undefined,
+				withNoData: undefined,
+			};
+		} else {
+			return { ...getMaterializedViewConfig(it), materialized: true };
+		}
+	});
+
+	for (const view of combinedViews) {
+		if (view.isExisting || !filter({ type: 'table', schema: view.schema ?? 'public', name: view.name })) continue;
+
+		const {
+			name: viewName,
+			schema,
+			query,
+			tablespace,
+			using,
+			withNoData,
+			materialized,
+		} = view;
+
+		const viewSchema = schema ?? 'public';
+
+		type MergerWithConfig = keyof (
+			& ViewWithConfig
+			& PgMaterializedViewWithConfig
+		);
+		const opt = view.with as
+			| {
+				[K in MergerWithConfig]: (
+					& ViewWithConfig
+					& PgMaterializedViewWithConfig
+				)[K];
+			}
+			| null;
+
+		const withOpt = opt
+			? {
+				checkOption: getOrNull(opt, 'checkOption'),
+				securityBarrier: getOrNull(opt, 'securityBarrier'),
+				securityInvoker: getOrNull(opt, 'securityInvoker'),
+				autovacuumEnabled: getOrNull(opt, 'autovacuumEnabled'),
+				autovacuumFreezeMaxAge: getOrNull(opt, 'autovacuumFreezeMaxAge'),
+				autovacuumFreezeMinAge: getOrNull(opt, 'autovacuumFreezeMinAge'),
+				autovacuumFreezeTableAge: getOrNull(
+					opt,
+					'autovacuumFreezeTableAge',
+				),
+				autovacuumMultixactFreezeMaxAge: getOrNull(
+					opt,
+					'autovacuumMultixactFreezeMaxAge',
+				),
+				autovacuumMultixactFreezeMinAge: getOrNull(
+					opt,
+					'autovacuumMultixactFreezeMinAge',
+				),
+				autovacuumMultixactFreezeTableAge: getOrNull(
+					opt,
+					'autovacuumMultixactFreezeTableAge',
+				),
+				autovacuumVacuumCostDelay: getOrNull(
+					opt,
+					'autovacuumVacuumCostDelay',
+				),
+				autovacuumVacuumCostLimit: getOrNull(
+					opt,
+					'autovacuumVacuumCostLimit',
+				),
+				autovacuumVacuumScaleFactor: getOrNull(
+					opt,
+					'autovacuumVacuumScaleFactor',
+				),
+				autovacuumVacuumThreshold: getOrNull(
+					opt,
+					'autovacuumVacuumThreshold',
+				),
+				fillfactor: getOrNull(opt, 'fillfactor'),
+				logAutovacuumMinDuration: getOrNull(
+					opt,
+					'logAutovacuumMinDuration',
+				),
+				parallelWorkers: getOrNull(opt, 'parallelWorkers'),
+				toastTupleTarget: getOrNull(opt, 'toastTupleTarget'),
+				userCatalogTable: getOrNull(opt, 'userCatalogTable'),
+				vacuumIndexCleanup: getOrNull(opt, 'vacuumIndexCleanup'),
+				vacuumTruncate: getOrNull(opt, 'vacuumTruncate'),
+			}
+			: null;
+
+		const hasNonNullOpts = Object.values(withOpt ?? {}).filter((x) => x !== null).length > 0;
+
+		res.views.push({
+			entityType: 'views',
+			definition: dialect.sqlToQuery(query!).sql,
+			name: viewName,
+			schema: viewSchema,
+			with: hasNonNullOpts ? withOpt : null,
+			withNoData: withNoData ?? null,
+			materialized,
+			tablespace: tablespace ?? null,
+			using: using ?? null,
+		});
+	}
+
+	res.enums = schema.enums.map<Enum>((e) => {
+		return {
+			entityType: 'enums',
+			name: e.enumName,
+			schema: e.schema || 'public',
+			values: e.enumValues,
+		};
+	});
+
+	return {
+		schema: res,
+		errors,
+		warnings,
+	};
+};
+
+export const fromExports = (exports: Record<string, unknown>) => {
+	const tables: AnyPgTable[] = [];
+	const enums: PgEnum<any>[] = [];
+	const schemas: PgSchema[] = [];
+	const sequences: PgSequence[] = [];
+	const roles: PgRole[] = [];
+	const policies: PgPolicy[] = [];
+	const views: PgView[] = [];
+	const matViews: PgMaterializedView[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (isPgEnum(t)) {
+			enums.push(t);
+			return;
+		}
+		if (is(t, PgTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, PgSchema)) {
+			schemas.push(t);
+		}
+
+		if (isPgView(t)) {
+			views.push(t);
+		}
+
+		if (isPgMaterializedView(t)) {
+			matViews.push(t);
+		}
+
+		if (isPgSequence(t)) {
+			sequences.push(t);
+		}
+
+		if (is(t, PgRole)) {
+			roles.push(t);
+		}
+
+		if (is(t, PgPolicy)) {
+			policies.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return {
+		tables,
+		enums,
+		schemas,
+		sequences,
+		views,
+		matViews,
+		roles,
+		policies,
+		relations,
+	};
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnyPgTable[] = [];
+	const enums: PgEnum<any>[] = [];
+	const schemas: PgSchema[] = [];
+	const sequences: PgSequence[] = [];
+	const views: PgView[] = [];
+	const roles: PgRole[] = [];
+	const policies: PgPolicy[] = [];
+	const matViews: PgMaterializedView[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = fromExports(i0);
+
+		tables.push(...prepared.tables);
+		enums.push(...prepared.enums);
+		schemas.push(...prepared.schemas);
+		sequences.push(...prepared.sequences);
+		views.push(...prepared.views);
+		matViews.push(...prepared.matViews);
+		roles.push(...prepared.roles);
+		policies.push(...prepared.policies);
+		relations.push(...prepared.relations);
+	}
+
+	return {
+		tables,
+		enums,
+		schemas,
+		sequences,
+		views,
+		matViews,
+		roles,
+		policies,
+		relations,
+	};
+};
+
+export type PreparedPostgresSchema = Awaited<ReturnType<typeof prepareFromSchemaFiles>>;
+
+// Decouples the schema's origin (compiled `.ts` files vs. a supplied prebuilt schema) from its consumers.
+export interface SchemaSource {
+	load(): Promise<PreparedPostgresSchema>;
+}
+
+export const SchemaSource = {
+	fromFilenames(filenames: string[]): SchemaSource {
+		return { load: () => prepareFromSchemaFiles(filenames) };
+	},
+	fromSchema(schema: PreparedPostgresSchema): SchemaSource {
+		return { load: async () => schema };
+	},
+};
diff --git a/drizzle-kit/src/dialects/postgres/duckdb-introspect.ts b/drizzle-kit/src/dialects/postgres/duckdb-introspect.ts
new file mode 100644
index 0000000000..f2da726de6
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/duckdb-introspect.ts
@@ -0,0 +1,878 @@
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import { type DB, trimChar } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import type {
+	CheckConstraint,
+	Enum,
+	ForeignKey,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import { defaultForColumn, isSystemNamespace, parseViewDefinition } from './grammar';
+
+// TODO: tables/schema/entities -> filter: (entity: {type: ... , metadata: ... }) => boolean;
+// TODO: since we by default only introspect public
+export const fromDatabase = async (
+	db: DB,
+	database: string,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+): Promise<InterimSchema> => {
+	const schemas: Schema[] = [];
+	const enums: Enum[] = [];
+	const tables: PostgresEntities['tables'][] = [];
+	const columns: InterimColumn[] = [];
+	const indexes: InterimIndex[] = [];
+	const pks: PrimaryKey[] = [];
+	const fks: ForeignKey[] = [];
+	const uniques: UniqueConstraint[] = [];
+	const checks: CheckConstraint[] = [];
+	const sequences: Sequence[] = [];
+	const roles: Role[] = [];
+	const privileges: Privilege[] = [];
+	const policies: Policy[] = [];
+	const views: View[] = [];
+	const viewColumns: ViewColumn[] = [];
+
+	// type OP = {
+	// 	oid: number;
+	// 	name: string;
+	// 	default: boolean;
+	// };
+
+	type Namespace = {
+		oid: number;
+		name: string;
+	};
+
+	// TODO: potential improvements
+	// --- default access method
+	// SHOW default_table_access_method;
+	// SELECT current_setting('default_table_access_method') AS default_am;
+
+	const namespacesQuery = db.query<Namespace>(
+		`SELECT oid, schema_name as name FROM duckdb_schemas() WHERE database_name = '${database}' ORDER BY lower(schema_name)`,
+	)
+		.then((rows) => {
+			queryCallback('namespaces', rows, null);
+			return rows;
+		}).catch((err) => {
+			queryCallback('namespaces', [], err);
+			throw err;
+		});
+
+	const namespaces = await namespacesQuery;
+
+	const { other } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
+		(acc, it) => {
+			if (isSystemNamespace(it.name)) {
+				acc.system.push(it);
+			} else {
+				acc.other.push(it);
+			}
+			return acc;
+		},
+		{ system: [], other: [] },
+	);
+
+	const filteredNamespaces = other.filter((it) => filter({ type: 'schema', name: it.name }));
+
+	if (filteredNamespaces.length === 0) {
+		return {
+			schemas,
+			tables,
+			enums,
+			columns,
+			indexes,
+			pks,
+			fks,
+			uniques,
+			checks,
+			sequences,
+			roles,
+			privileges,
+			policies,
+			views,
+			viewColumns,
+		} satisfies InterimSchema;
+	}
+
+	const filteredNamespacesIds = filteredNamespaces.map((it) => it.oid);
+
+	schemas.push(...filteredNamespaces.map<Schema>((it) => ({ entityType: 'schemas', name: it.name })));
+
+	const tablesList = await db
+		.query<{
+			oid: number;
+			schema: string;
+			name: string;
+			definition: string | null;
+			type: 'table' | 'view';
+		}>(`
+            SELECT
+                table_oid AS "oid",
+                schema_name AS "schema",
+                table_name AS "name",
+                NULL AS "definition",
+                'table' AS "type"
+            FROM
+                duckdb_tables()
+            WHERE database_name = '${database}'
+                AND schema_oid IN (${filteredNamespacesIds.join(', ')})
+
+            UNION ALL
+
+            SELECT
+                view_oid AS "oid",
+                schema_name AS "schema",
+                view_name AS "name",
+                sql AS "definition",
+                'view' AS "type"
+            FROM
+                duckdb_views()
+            WHERE database_name = '${database}'
+                AND schema_oid IN (${filteredNamespacesIds.join(', ')})
+            ORDER BY schema_name, name
+        `).then((rows) => {
+			queryCallback('tables', rows, null);
+			return rows;
+		}).catch((err) => {
+			queryCallback('tables', [], err);
+			throw err;
+		});
+
+	const viewsList = tablesList.filter((it) => it.type === 'view');
+
+	const filteredTables = tablesList.filter((it) => {
+		if (!(it.type === 'table' && filter({ type: 'table', schema: it.schema, name: it.name }))) return false;
+		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+		return true;
+	});
+
+	const filteredTableIds = filteredTables.map((it) => it.oid);
+	const viewsIds = viewsList.map((it) => it.oid);
+	const filteredViewsAndTableIds = [...filteredTableIds, ...viewsIds];
+
+	const filterByTableIds = filteredTableIds.length > 0 ? `(${filteredTableIds.join(',')})` : '';
+	const filterByTableAndViewIds = filteredViewsAndTableIds.length > 0 ? `(${filteredViewsAndTableIds.join(',')})` : '';
+
+	for (const table of filteredTables) {
+		tables.push({
+			entityType: 'tables',
+			schema: trimChar(table.schema, "'"),
+			name: table.name,
+			isRlsEnabled: false,
+		});
+	}
+
+	// const dependQuery = db.query<{
+	// 	oid: number;
+	// 	tableId: number;
+	// 	ordinality: number;
+
+	// 	/*
+	//         a - An “auto” dependency means the dependent object can be dropped separately,
+	//                 and will be automatically removed if the referenced object is dropped—regardless of CASCADE or RESTRICT.
+	//                 Example: A named constraint on a table is auto-dependent on the table, so it vanishes when the table is dropped
+
+	//                 i - An “internal” dependency marks objects that were created as part of building another object.
+	//                 Directly dropping the dependent is disallowed—you must drop the referenced object instead.
+	//                 Dropping the referenced object always cascades to the dependent
+	//                 Example: A trigger enforcing a foreign-key constraint is internally dependent on its pg_constraint entry
+	//      */
+	// 	deptype: 'a' | 'i';
+	// }>(
+	// 	`SELECT
+	//         -- sequence id
+	//         objid as oid,
+	//         refobjid as "tableId",
+	//         refobjsubid as "ordinality",
+
+	//         -- a = auto
+	//         deptype
+	//     FROM
+	//         duckdb_dependencies()
+	//     where ${filterByTableIds ? ` refobjid in ${filterByTableIds}` : 'false'}`,
+	// ).then((rows) => {
+	// 	queryCallback('depend', rows, null);
+	// 	return rows;
+	// }).catch((err) => {
+	// 	queryCallback('depend', [], err);
+	// 	throw err;
+	// });
+
+	// const enumsQuery = db
+	// 	.query<{
+	// 		oid: number;
+	// 		name: string;
+	// 		schemaId: number;
+	// 		arrayTypeId: number;
+	// 		ordinality: number;
+	// 		value: string;
+	// 	}>(`SELECT
+	//             pg_type.oid as "oid",
+	//             typname as "name",
+	//             typnamespace as "schemaId",
+	//             pg_type.typarray as "arrayTypeId",
+	//             pg_enum.enumsortorder AS "ordinality",
+	//             pg_enum.enumlabel AS "value"
+	//         FROM
+	//             pg_type
+	//         JOIN pg_enum on pg_enum.enumtypid=pg_type.oid
+	//         WHERE
+	//             pg_type.typtype = 'e'
+	//             AND typnamespace IN (${filteredNamespacesIds.join(',')})
+	//         ORDER BY pg_type.oid, pg_enum.enumsortorder
+	//     `).then((rows) => {
+	// 		queryCallback('enums', rows, null);
+	// 		return rows;
+	// 	}).catch((err) => {
+	// 		queryCallback('enums', [], err);
+	// 		throw err;
+	// 	});
+
+	// fetch for serials, adrelid = tableid
+	// const serialsQuery = db
+	// 	.query<{
+	// 		oid: number;
+	// 		tableId: number;
+	// 		ordinality: number;
+	// 		expression: string;
+	// 	}>(`SELECT
+	//             oid,
+	//             adrelid as "tableId",
+	//             adnum as "ordinality",
+	//             pg_get_expr(adbin, adrelid) as "expression"
+	//         FROM
+	//             pg_attrdef
+	//         WHERE ${filterByTableIds ? ` adrelid in ${filterByTableIds}` : 'false'}
+	//     `).then((rows) => {
+	// 		queryCallback('serials', rows, null);
+	// 		return rows;
+	// 	}).catch((err) => {
+	// 		queryCallback('serials', [], err);
+	// 		throw err;
+	// 	});
+
+	// const sequencesQuery = db.query<{
+	// 	schema: string;
+	// 	oid: number;
+	// 	name: string;
+	// 	startWith: string;
+	// 	minValue: string;
+	// 	maxValue: string;
+	// 	incrementBy: string;
+	// 	cycle: boolean;
+	// 	cacheSize: number;
+	// }>(`SELECT
+	//         n.nspname as "schema",
+	//         c.relname as "name",
+	//         seqrelid as "oid",
+	//         seqstart as "startWith",
+	//         seqmin as "minValue",
+	//         seqmax as "maxValue",
+	//         seqincrement as "incrementBy",
+	//         seqcycle as "cycle",
+	//         seqcache as "cacheSize"
+	//     FROM pg_sequence
+	//     LEFT JOIN pg_class c ON pg_sequence.seqrelid=c.oid
+	//     LEFT JOIN pg_namespace n ON c.relnamespace=n.oid
+	//     WHERE relnamespace IN (${filteredNamespacesIds.join(',')})
+	//     ORDER BY relnamespace, lower(relname);
+	// `).then((rows) => {
+	// 	queryCallback('sequences', rows, null);
+	// 	return rows;
+	// }).catch((err) => {
+	// 	queryCallback('sequences', [], err);
+	// 	throw err;
+	// });
+
+	const constraintsQuery = db.query<{
+		schemaId: number;
+		tableId: number;
+		name: string;
+		type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK'; // p - primary key, u - unique, f - foreign key, c - check
+		definition: string;
+		tableToName: string;
+		columnsNames: string[];
+		columnsToNames: string[];
+	}>(`
+        SELECT
+            schema_oid AS "schemaId",
+            table_oid AS "tableId",
+            constraint_name AS "name",
+            constraint_type AS "type",
+            constraint_text AS "definition",
+            referenced_table AS "tableToName",
+            constraint_column_names AS "columnsNames",
+            referenced_column_names AS "columnsToNames"
+        FROM
+            duckdb_constraints()
+        WHERE database_name = '${database}'
+			AND ${filterByTableIds ? `table_oid in ${filterByTableIds}` : 'false'}
+        ORDER BY constraint_type, lower(constraint_name);
+  `).then((rows) => {
+		queryCallback('constraints', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('constraints', [], err);
+		throw err;
+	});
+
+	// for serials match with pg_attrdef via attrelid(tableid)+adnum(ordinal position), for enums with pg_enum above
+	const columnsQuery = db.query<{
+		tableId: number;
+		name: string;
+		ordinality: number;
+		notNull: boolean;
+		typeId: number;
+		type: string;
+		default: string | null;
+	}>(`SELECT
+            table_oid AS "tableId",
+            column_name AS "name",
+            column_index AS "ordinality",
+            is_nullable = false AS "notNull",
+            data_type_id AS "typeId",
+            lower(data_type) AS "type",
+            column_default AS "default"
+        FROM
+            duckdb_columns()
+        WHERE
+        ${filterByTableAndViewIds ? ` table_oid in ${filterByTableAndViewIds}` : 'false'}
+            AND database_name = '${database}'
+        ORDER BY column_index;
+    `).then((rows) => {
+		queryCallback('columns', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('columns', [], err);
+		throw err;
+	});
+
+	const [
+		// dependList,
+		// enumsList,
+		// serialsList,
+		// sequencesList,
+		constraintsList,
+		columnsList,
+	] = await Promise
+		.all([
+			// dependQuery,
+			// enumsQuery,
+			// serialsQuery,
+			// sequencesQuery,
+			constraintsQuery,
+			columnsQuery,
+		]);
+
+	// const groupedEnums = enumsList.reduce((acc, it) => {
+	// 	if (!(it.oid in acc)) {
+	// 		const schemaName = filteredNamespaces.find((sch) => sch.oid === it.schemaId)!.name;
+	// 		acc[it.oid] = {
+	// 			oid: it.oid,
+	// 			schema: schemaName,
+	// 			name: it.name,
+	// 			values: [it.value],
+	// 		};
+	// 	} else {
+	// 		acc[it.oid].values.push(it.value);
+	// 	}
+	// 	return acc;
+	// }, {} as Record<number, { oid: number; schema: string; name: string; values: string[] }>);
+
+	// const groupedArrEnums = enumsList.reduce((acc, it) => {
+	// 	if (!(it.arrayTypeId in acc)) {
+	// 		const schemaName = filteredNamespaces.find((sch) => sch.oid === it.schemaId)!.name;
+	// 		acc[it.arrayTypeId] = {
+	// 			oid: it.oid,
+	// 			schema: schemaName,
+	// 			name: it.name,
+	// 			values: [it.value],
+	// 		};
+	// 	} else {
+	// 		acc[it.arrayTypeId].values.push(it.value);
+	// 	}
+	// 	return acc;
+	// }, {} as Record<number, { oid: number; schema: string; name: string; values: string[] }>);
+
+	// for (const it of Object.values(groupedEnums)) {
+	// 	enums.push({
+	// 		entityType: 'enums',
+	// 		schema: it.schema,
+	// 		name: it.name,
+	// 		values: it.values,
+	// 	});
+	// }
+
+	let columnsCount = 0;
+	let indexesCount = 0;
+	let foreignKeysCount = 0;
+	let tableCount = 0;
+	let checksCount = 0;
+	let viewsCount = 0;
+
+	// for (const seq of sequencesList) {
+	// 	const depend = dependList.find((it) => it.oid === seq.oid);
+
+	// 	if (depend && (depend.deptype === 'a' || depend.deptype === 'i')) {
+	// 		// TODO: add type field to sequence in DDL
+	// 		// skip fo sequences or identity columns
+	// 		// console.log('skip for auto created', seq.name);
+	// 		continue;
+	// 	}
+
+	// 	sequences.push({
+	// 		entityType: 'sequences',
+	// 		schema: seq.schema,
+	// 		name: seq.name,
+	// 		startWith: parseIdentityProperty(seq.startWith),
+	// 		minValue: parseIdentityProperty(seq.minValue),
+	// 		maxValue: parseIdentityProperty(seq.maxValue),
+	// 		incrementBy: parseIdentityProperty(seq.incrementBy),
+	// 		cycle: seq.cycle,
+	// 		cacheSize: Number(parseIdentityProperty(seq.cacheSize) ?? 1),
+	// 	});
+	// }
+
+	// progressCallback('enums', Object.keys(groupedEnums).length, 'done');
+
+	// type DBColumn = (typeof columnsList)[number];
+
+	const tableColumns = columnsList.filter((it) => {
+		const table = tablesList.find((tbl) => tbl.oid === it.tableId);
+		return !!table;
+	});
+
+	// supply serials
+	for (const column of tableColumns) {
+		const type = column.type;
+
+		if (!(type === 'smallint' || type === 'bigint' || type === 'integer')) {
+			continue;
+		}
+
+		// const expr = serialsList.find(
+		// 	(it) => it.tableId === column.tableId && it.ordinality === column.ordinality,
+		// );
+
+		// if (expr) {
+		// 	const table = tablesList.find((it) => it.oid === column.tableId)!;
+
+		// 	const isSerial = isSerialExpression(expr.expression, table.schema);
+		// 	column.type = isSerial ? type === 'bigint' ? 'bigserial' : type === 'integer' ? 'serial' : 'smallserial' : type;
+		// }
+	}
+
+	for (const column of tableColumns) {
+		const table = tablesList.find((it) => it.oid === column.tableId)!;
+
+		// supply enums
+		// const enumType = column.typeId in groupedEnums
+		// 	? groupedEnums[column.typeId]
+		// 	: column.typeId in groupedArrEnums
+		// 	? groupedArrEnums[column.typeId]
+		// 	: null;
+
+		// let columnTypeMapped = enumType ? enumType.name : column.type.replace('[]', '');
+		let columnTypeMapped = column.type;
+		let dimensions = 0;
+
+		// check if column is array
+		const arrayRegex = /\[(\d+)?\]$/;
+		if (arrayRegex.test(columnTypeMapped)) {
+			columnTypeMapped = columnTypeMapped.replace(arrayRegex, '');
+			dimensions = 1;
+		}
+
+		if (columnTypeMapped.startsWith('numeric(')) {
+			columnTypeMapped = columnTypeMapped.replace(',', ', ');
+		}
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace(' with time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char');
+
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+
+		const columnDefault = column.default;
+
+		const defaultValue = defaultForColumn(
+			columnTypeMapped,
+			columnDefault,
+			0,
+			false, // TODO
+		);
+
+		const unique = constraintsList.find((it) => {
+			return it.type === 'UNIQUE' && it.tableId === column.tableId && it.columnsNames.length === 1
+				&& it.columnsNames.includes(column.name);
+		}) ?? null;
+
+		const pk = constraintsList.find((it) => {
+			return it.type === 'PRIMARY KEY' && it.tableId === column.tableId && it.columnsNames.length === 1
+				&& it.columnsNames.includes(column.name);
+		}) ?? null;
+
+		columns.push({
+			entityType: 'columns',
+			schema: table.schema,
+			table: table.name,
+			name: column.name,
+			type: columnTypeMapped,
+			// typeSchema: enumType ? enumType.schema ?? 'public' : null,
+			typeSchema: null,
+			dimensions,
+			default: defaultValue,
+			unique: !!unique,
+			uniqueName: unique ? unique.name : null,
+			uniqueNullsNotDistinct: unique?.definition.includes('NULLS NOT DISTINCT') ?? false,
+			notNull: column.notNull,
+			pk: pk !== null,
+			pkName: pk !== null ? pk.name : null,
+			generated: null,
+			identity: null,
+		});
+	}
+
+	for (const unique of constraintsList.filter((it) => it.type === 'UNIQUE')) {
+		const table = tablesList.find((it) => it.oid === unique.tableId)!;
+		const schema = namespaces.find((it) => it.oid === unique.schemaId)!;
+
+		const columns = unique.columnsNames.map((it) => {
+			const column = columnsList.find((column) => column.tableId === unique.tableId && column.name === it)!;
+			return column.name;
+		});
+
+		uniques.push({
+			entityType: 'uniques',
+			schema: schema.name,
+			table: table.name,
+			name: unique.name,
+			nameExplicit: true,
+			columns,
+			nullsNotDistinct: unique.definition.includes('NULLS NOT DISTINCT'),
+		});
+	}
+
+	for (const pk of constraintsList.filter((it) => it.type === 'PRIMARY KEY')) {
+		const table = tablesList.find((it) => it.oid === pk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === pk.schemaId)!;
+
+		const columns = pk.columnsNames.map((it) => {
+			const column = columnsList.find((column) => column.tableId === pk.tableId && column.name === it)!;
+			return column.name;
+		});
+
+		pks.push({
+			entityType: 'pks',
+			schema: schema.name,
+			table: table.name,
+			name: pk.name,
+			columns,
+			nameExplicit: true,
+		});
+	}
+
+	for (const fk of constraintsList.filter((it) => it.type === 'FOREIGN KEY')) {
+		const table = tablesList.find((it) => it.oid === fk.tableId)!;
+		const schema = namespaces.find((it) => it.oid === fk.schemaId)!;
+		const tableTo = tablesList.find((it) => it.schema === schema.name && it.name === fk.tableToName)!;
+
+		const columns = fk.columnsNames.map((it) => {
+			const column = columnsList.find((column) => column.tableId === fk.tableId && column.name === it)!;
+			return column.name;
+		});
+
+		const columnsTo = fk.columnsToNames.map((it) => {
+			const column = columnsList.find((column) => column.tableId === tableTo.oid && column.name === it)!;
+			return column.name;
+		});
+
+		fks.push({
+			entityType: 'fks',
+			schema: schema.name,
+			table: table.name,
+			name: fk.name,
+			nameExplicit: true,
+			columns,
+			tableTo: tableTo.name,
+			schemaTo: schema.name,
+			columnsTo,
+			onUpdate: 'NO ACTION',
+			onDelete: 'NO ACTION',
+		});
+	}
+
+	for (const check of constraintsList.filter((it) => it.type === 'CHECK')) {
+		const table = tablesList.find((it) => it.oid === check.tableId)!;
+		const schema = namespaces.find((it) => it.oid === check.schemaId)!;
+
+		checks.push({
+			entityType: 'checks',
+			schema: schema.name,
+			table: table.name,
+			name: check.name,
+			value: check.definition,
+		});
+	}
+
+	// const idxs = await db.query<{
+	// 	oid: number;
+	// 	schema: string;
+	// 	name: string;
+	// 	accessMethod: string;
+	// 	with?: string[];
+	// 	metadata: {
+	// 		tableId: number;
+	// 		expression: string | null;
+	// 		where: string;
+	// 		columnOrdinals: number[];
+	// 		options: number[];
+	// 		isUnique: boolean;
+	// 		isPrimary: boolean;
+	// 	};
+	// }>(`
+	//   SELECT
+	//     pg_class.oid,
+	//     n.nspname as "schema",
+	//     relname AS "name",
+	//     am.amname AS "accessMethod",
+	//     reloptions AS "with",
+	//     row_to_json(metadata) as "metadata"
+	//   FROM
+	//     pg_class
+	//   JOIN pg_am am ON am.oid = pg_class.relam
+	//   JOIN pg_namespace n ON relnamespace = n.oid
+	//   LEFT JOIN LATERAL (
+	//     SELECT
+	//       pg_get_expr(indexprs, indrelid) AS "expression",
+	//       pg_get_expr(indpred, indrelid) AS "where",
+	//       indrelid::int AS "tableId",
+	//       indkey::int[] as "columnOrdinals",
+	//       indoption::int[] as "options",
+	//       indisunique as "isUnique",
+	//       indisprimary as "isPrimary"
+	//     FROM
+	//       pg_index
+	//     WHERE
+	//       pg_index.indexrelid = pg_class.oid
+	//   ) metadata ON TRUE
+	//   WHERE
+	//     relkind = 'i' and ${filterByTableIds ? `metadata."tableId" in ${filterByTableIds}` : 'false'}
+	//   ORDER BY relnamespace, lower(relname);
+	// `).then((rows) => {
+	// 	queryCallback('indexes', rows, null);
+	// 	return rows;
+	// }).catch((err) => {
+	// 	queryCallback('indexes', [], err);
+	// 	throw err;
+	// });
+
+	// for (const idx of idxs) {
+	// 	const { metadata } = idx;
+
+	// 	const expr = splitExpressions(metadata.expression);
+
+	// 	const table = tablesList.find((it) => it.oid === idx.metadata.tableId)!;
+
+	// 	const nonColumnsCount = metadata.columnOrdinals.reduce((acc, it) => {
+	// 		if (it === 0) acc += 1;
+	// 		return acc;
+	// 	}, 0);
+
+	// 	if (expr.length !== nonColumnsCount) {
+	// 		throw new Error(
+	// 			`expression split doesn't match non-columns count: [${
+	// 				metadata.columnOrdinals.join(
+	// 					', ',
+	// 				)
+	// 			}] '${metadata.expression}':${expr.length}:${nonColumnsCount}`,
+	// 		);
+	// 	}
+
+	// 	const opts = metadata.options.map((it) => {
+	// 		return {
+	// 			descending: (it & 1) === 1,
+	// 			nullsFirst: (it & 2) === 2,
+	// 		};
+	// 	});
+
+	// 	const res = [] as (
+	// 		& (
+	// 			| { type: 'expression'; value: string }
+	// 			| { type: 'column'; value: DBColumn }
+	// 		)
+	// 		& { options: (typeof opts)[number] }
+	// 	)[];
+
+	// 	let k = 0;
+	// 	for (let i = 0; i < metadata.columnOrdinals.length; i++) {
+	// 		const ordinal = metadata.columnOrdinals[i];
+	// 		if (ordinal === 0) {
+	// 			res.push({
+	// 				type: 'expression',
+	// 				value: expr[k],
+	// 				options: opts[i],
+	// 			});
+	// 			k += 1;
+	// 		} else {
+	// 			const column = columnsList.find((column) => {
+	// 				return column.tableId === metadata.tableId && column.ordinality === ordinal;
+	// 			});
+	// 			if (!column) throw new Error(`missing column: ${metadata.tableId}:${ordinal}`);
+
+	// 			// ! options and opclass can be undefined when index have "INCLUDE" columns (columns from "INCLUDE" don't have options and opclass)
+	// 			const options = opts[i] as typeof opts[number] | undefined;
+	// 			if (options) {
+	// 				res.push({
+	// 					type: 'column',
+	// 					value: column,
+	// 					options: opts[i],
+	// 				});
+	// 			}
+	// 		}
+	// 	}
+
+	// 	const columns = res.map((it) => {
+	// 		return {
+	// 			asc: !it.options.descending,
+	// 			nullsFirst: it.options.nullsFirst,
+	// 			opclass: null,
+	// 			isExpression: it.type === 'expression',
+	// 			value: it.type === 'expression' ? it.value : it.value.name, // column name
+	// 		} satisfies Index['columns'][number];
+	// 	});
+
+	// 	indexes.push({
+	// 		entityType: 'indexes',
+	// 		schema: idx.schema,
+	// 		table: table.name,
+	// 		name: idx.name,
+	// 		nameExplicit: true,
+	// 		method: idx.accessMethod,
+	// 		isUnique: metadata.isUnique,
+	// 		with: idx.with?.join(', ') ?? '',
+	// 		where: idx.metadata.where,
+	// 		columns: columns,
+	// 		concurrently: false,
+	// 		forUnique: false,
+	// 		forPK: false,
+	// 	});
+	// }
+
+	progressCallback('columns', columnsCount, 'fetching');
+	progressCallback('checks', checksCount, 'fetching');
+	progressCallback('indexes', indexesCount, 'fetching');
+	progressCallback('tables', tableCount, 'done');
+
+	for (
+		const it of columnsList.filter((it) => {
+			const view = viewsList.find((x) => x.oid === it.tableId);
+			return !!view;
+		})
+	) {
+		const view = viewsList.find((x) => x.oid === it.tableId)!;
+
+		// const enumType = it.typeId in groupedEnums
+		// 	? groupedEnums[it.typeId]
+		// 	: it.typeId in groupedArrEnums
+		// 	? groupedArrEnums[it.typeId]
+		// 	: null;
+
+		// let columnTypeMapped = enumType ? enumType.name : it.type.replace('[]', '');
+		let columnTypeMapped = it.type.replace('[]', '');
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+		if (columnTypeMapped.startsWith('numeric(')) {
+			columnTypeMapped = columnTypeMapped.replace(',', ', ');
+		}
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char');
+
+		const typeDimensions = it.type.split('[]').length - 1;
+
+		viewColumns.push({
+			schema: view.schema,
+			view: view.name,
+			name: it.name,
+			type: columnTypeMapped,
+			notNull: it.notNull,
+			dimensions: 0,
+			// typeSchema: enumType ? enumType.schema : null,
+			typeSchema: null,
+			typeDimensions,
+		});
+	}
+
+	for (const view of viewsList) {
+		if (!filter({ type: 'table', schema: view.schema, name: view.name })) continue;
+		tableCount += 1;
+
+		const definition = parseViewDefinition(view.definition);
+
+		views.push({
+			entityType: 'views',
+			schema: view.schema,
+			name: view.name,
+			definition,
+			with: null,
+			materialized: false,
+			tablespace: null,
+			using: null,
+			withNoData: null,
+		});
+	}
+
+	// TODO: update counts!
+	progressCallback('columns', columnsCount, 'done');
+	progressCallback('indexes', indexesCount, 'done');
+	progressCallback('fks', foreignKeysCount, 'done');
+	progressCallback('checks', checksCount, 'done');
+	progressCallback('views', viewsCount, 'done');
+
+	return {
+		schemas,
+		tables,
+		enums,
+		columns,
+		indexes,
+		pks,
+		fks,
+		uniques,
+		checks,
+		sequences,
+		roles,
+		privileges,
+		policies,
+		views,
+		viewColumns,
+	} satisfies InterimSchema;
+};
diff --git a/drizzle-kit/src/dialects/postgres/grammar.ts b/drizzle-kit/src/dialects/postgres/grammar.ts
new file mode 100644
index 0000000000..db273f1a6f
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/grammar.ts
@@ -0,0 +1,2226 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type { possibleIntervals } from '../../utils';
+import {
+	hasTimeZoneSuffix,
+	isDate,
+	isTime,
+	isTimestamp,
+	parseEWKB,
+	parseIntervalFields,
+	stringifyArray,
+	stringifyTuplesArray,
+	trimChar,
+	wrapWith,
+} from '../../utils';
+import { parseArray, parseExpressionArray } from '../../utils/parse-pgarray';
+import { parse, stringify } from '../../utils/when-json-met-bigint';
+import { hash } from '../common';
+import { escapeForSqlDefault, escapeForTsLiteral, numberForTs, parseParams, unescapeFromSqlDefault } from '../utils';
+import type { Column, DiffEntities, PostgresEntities } from './ddl';
+import type { Import } from './typescript';
+
+export interface SqlType {
+	is(type: string): boolean;
+	drizzleImport(): Import;
+	defaultFromDrizzle<MODE = unknown>(value: unknown, mode?: MODE, config?: unknown): Column['default'];
+	defaultArrayFromDrizzle<MODE = unknown>(
+		value: any[],
+		dimensions: number,
+		mode?: MODE,
+		config?: unknown,
+	): Column['default'];
+	defaultFromIntrospect(value: string): Column['default'];
+	defaultArrayFromIntrospect(value: string): Column['default']; // todo: remove?
+	toTs(type: string, value: string | null): { options?: Record<string, unknown>; default: string; customType?: string }; // customType for Custom
+	toArrayTs(
+		type: string,
+		value: string | null,
+	): { options?: Record<string, unknown>; default: string; customType?: string };
+}
+
+export const SmallInt: SqlType = {
+	is: (type: string) => /^\s*smallint(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'smallint',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return trimChar(value, "'"); // 10, but '-10'
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `${v}`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Int: SqlType = {
+	is: (type: string) => /^\s*integer(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'integer',
+	defaultFromDrizzle: SmallInt.defaultFromDrizzle,
+	defaultArrayFromDrizzle: SmallInt.defaultArrayFromDrizzle,
+	defaultFromIntrospect: SmallInt.defaultFromIntrospect,
+	defaultArrayFromIntrospect: SmallInt.defaultArrayFromIntrospect,
+	toTs: SmallInt.toTs,
+	toArrayTs: SmallInt.toArrayTs,
+};
+
+export const BigInt: SqlType = {
+	is: (type: string) => /^\s*bigint(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'bigint',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return trimChar(value, "'"); // 10, but '-10'
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (_, value) => {
+		if (!value) return { options: { mode: 'number' }, default: '' };
+		const { mode, value: def } = numberForTs(value);
+		return { options: { mode }, default: def };
+	},
+	toArrayTs: (_, value) => {
+		if (!value) return { options: { mode: 'number' }, default: '' };
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+			return {
+				options: { mode: 'bigint' },
+				default: stringifyArray(res, 'ts', (v) => `${v}n`),
+			};
+		} catch {
+			return { options: { mode: 'bigint' }, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Numeric: SqlType = {
+	is: (type: string) => /^\s*numeric|decimal(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'numeric',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		// 10.123, but '9223372036854775807'
+		return `'${trimChar(value, "'")}'`;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const [precision, scale] = parseParams(type);
+		const options = {} as any;
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+
+		const trimmed = trimChar(value, "'");
+
+		const { mode, value: def } = numberForTs(trimmed);
+		return { options: { mode, ...options }, default: def };
+	},
+	toArrayTs: (type, value) => {
+		const [precision, scale] = parseParams(type);
+		const options = {} as any;
+		if (precision) options['precision'] = Number(precision);
+		if (scale) options['scale'] = Number(scale);
+
+		if (!value) return { options, default: '' };
+		/*
+			If we'd want it to be smart - we need to check if numeric array has
+			any bigints recuresively, it's waaaaay easier to just do sql``
+		 */
+		// try {
+		// 	const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+		// 	const res = parseArray(trimmed);
+
+		// 	return {
+		// 		options: { mode: 'bigint', ...options },
+		// 		default: stringifyArray(res, 'ts', (v) => {
+
+		// 			return `${v}`;
+		// 		}),
+		// 	};
+		// } catch {
+		return { options, default: `sql\`${value}\`` };
+		// }
+	},
+};
+
+export const Real: SqlType = {
+	is: (type: string) => /^\s*real(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'real',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return trimChar(value, "'"); // 10, but '-10'
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `${v}`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Double: SqlType = {
+	is: (type: string) => /^\s*(?:double|double precision)(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'doublePrecision',
+	defaultFromDrizzle: Real.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Real.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Real.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Real.defaultArrayFromIntrospect,
+	toTs: Real.toTs,
+	toArrayTs: Real.toArrayTs,
+};
+
+export const Boolean: SqlType = {
+	is: (type: string) => /^\s*boolean(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'boolean',
+	defaultFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return `'${stringifyArray(value, 'sql', (v) => (v === true ? 't' : 'f'))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return trimChar(value, "'");
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => ({ default: value ?? '' }),
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return v === 't' ? 'true' : 'false';
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Char: SqlType = {
+	is: (type: string) => /^\s*char|character(?:\(\d+\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'char',
+	defaultFromDrizzle: (value) => {
+		const escaped = escapeForSqlDefault(value as string);
+		return `'${escaped}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			const escaped = v
+				.replaceAll("'", "''")
+				.replaceAll('\\', '\\\\')
+				.replaceAll('"', '\\"');
+			if (v.includes('\\') || v.includes('"') || v.includes(',') || v.length === 0) {
+				return `"${escaped}"`;
+			}
+			return escaped;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+		if (!value.startsWith("'") && !value.endsWith("'")) return { options, default: `sql\`${value}\`` };
+		const escaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(value, "'")));
+		return { options, default: escaped };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(unescapeFromSqlDefault(trimChar(v, "'"), 'arr'));
+					return escaped;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Varchar: SqlType = {
+	is: (type: string) => /^\s*varchar|character varying(?:\(\d+\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'varchar',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Char.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Char.defaultArrayFromIntrospect,
+	toTs: Char.toTs,
+	toArrayTs: Char.toArrayTs,
+};
+
+export const Text: SqlType = {
+	is: (type: string) => /^\s*text(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'text',
+	defaultFromDrizzle: Char.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Char.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Char.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Char.defaultArrayFromIntrospect,
+	toTs: Char.toTs,
+	toArrayTs: Char.toArrayTs,
+};
+
+export const toDefaultArray = (
+	value: any[],
+	dimensions: number,
+	cb: (it: unknown) => string,
+	depth: number = 0,
+): string => {
+	if (depth === dimensions) {
+		const res = cb(value);
+		if (res.includes('"')) return `"${res.replaceAll('"', '\\"')}"`;
+		return `"${res}"`;
+	}
+
+	if (Array.isArray(value)) {
+		const inner = value.map((v) => {
+			return toDefaultArray(v, dimensions, cb, depth + 1);
+		}).join(',');
+		if (depth === 0) return `{${inner}}`;
+		return `${inner}`;
+	}
+
+	return cb(value);
+};
+
+export const Json: SqlType = {
+	is: (type: string) => /^\s*json(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'json',
+	defaultFromDrizzle: (value) => {
+		const stringified = stringify(value, (_, value) => {
+			if (typeof value !== 'string') return value;
+			return value.replaceAll("'", "''");
+		});
+		return `'${stringified}'`;
+	},
+	defaultArrayFromDrizzle: (def, dimensions) => {
+		const value = toDefaultArray(def, dimensions, (it) =>
+			stringify(it, (_, value) => {
+				if (typeof value !== 'string') return value;
+				return value.replaceAll("'", "''");
+			}));
+		return `'${value}'`;
+	},
+	defaultFromIntrospect: (value) => value,
+	defaultArrayFromIntrospect: (value) => value,
+	toTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		const trimmed = trimChar(value, "'");
+		try {
+			const parsed = parse(trimmed);
+			const stringified = stringify(
+				parsed,
+				(_, value) => {
+					if (typeof value !== 'string') return value;
+					return value.replaceAll("''", "'");
+				},
+				undefined,
+				true,
+			)!;
+			return { default: stringified };
+		} catch {}
+		return { default: `sql\`${value}\`` };
+	},
+	toArrayTs: (_, def) => {
+		if (!def) return { default: '' };
+		return { default: `sql\`${def.replaceAll('\\"', '\\\\"')}\`` };
+	},
+};
+
+export const Jsonb: SqlType = {
+	is: (type: string) => /^\s*jsonb(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'jsonb',
+	defaultFromDrizzle: (value) => {
+		const stringified = stringify(value, (_, value) => {
+			if (typeof value !== 'string') return value;
+			return value.replaceAll("'", "''");
+		});
+		return `'${stringified}'`;
+	},
+	defaultArrayFromDrizzle: (def, dimensions) => {
+		const value = toDefaultArray(def, dimensions, (it) =>
+			stringify(it, (_, value) => {
+				if (typeof value !== 'string') return value;
+				return value.replaceAll("'", "''");
+			}));
+		return `'${value}'`;
+	},
+	/*
+ 		TODO: make less hacky,
+ 		from: `'{"key": "value"}'`,
+ 		to:   `'{"key":"value"}'`
+ 	 */
+	defaultFromIntrospect: (value) => value.replaceAll(`": "`, `":"`),
+	defaultArrayFromIntrospect: (value) => value,
+	toTs: Json.toTs,
+	toArrayTs: Json.toArrayTs,
+};
+
+export const Time: SqlType = {
+	is: (type: string) => /^\s*time(?:\(\d+\))?(?:\[\])*?\s*$/i.test(type),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: (value) => {
+		return wrapWith(String(value), "'");
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return wrapWith(
+			stringifyArray(value, 'sql', (v) => String(v)),
+			"'",
+		);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+
+		if (!value) return { options, default: '' };
+		const trimmed = trimChar(value, "'");
+		if (!isTime(trimmed)) return { options, default: `sql\`${value}\`` };
+
+		return { options, default: value };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					const trimmed = trimChar(v, "'");
+
+					if (!isTime(trimmed)) return `sql\`${trimmed}\``;
+					return wrapWith(v, "'");
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const TimeTz: SqlType = {
+	is: (type: string) => /^\s*time(?:\(\d+\))?\s+with time zone(?:\[\])*?\s*$/i.test(type),
+	drizzleImport: () => 'time',
+	defaultFromDrizzle: (value) => {
+		const v = String(value);
+		const def = hasTimeZoneSuffix(v) ? v : v + '+00';
+		return wrapWith(def, "'");
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return wrapWith(
+			stringifyArray(value, 'sql', (v) => {
+				return hasTimeZoneSuffix(v) ? v : v + '+00';
+			}),
+			"'",
+		);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		options['withTimezone'] = true;
+
+		if (!value) return { options, default: '' };
+		const trimmed = trimChar(value, "'");
+		if (!isTime(trimmed)) return { options, default: `sql\`${value}\`` };
+
+		return { options, default: value };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		options['withTimezone'] = true;
+
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			let isDrizzleSql: boolean = false;
+			const def = stringifyArray(res, 'ts', (v) => {
+				const trimmed = trimChar(v, "'");
+
+				if (!isTime(trimmed)) isDrizzleSql = true;
+				return wrapWith(v, "'");
+			});
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const DateType: SqlType = {
+	is: (type: string) => /^\s*date(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'date',
+	defaultFromDrizzle: (value) => {
+		if (typeof value === 'string') return wrapWith(value, "'");
+		if (!(value instanceof Date)) {
+			throw new Error(
+				'"date" default value must be instance of Date or String',
+			);
+		}
+
+		const mapped = value.toISOString().split('T')[0];
+		return wrapWith(mapped, "'");
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v === 'string') return v;
+			if (v instanceof Date) {
+				return v.toISOString().split('T')[0];
+			}
+			throw new Error(
+				'Unexpected default value for "date", must be String or Date',
+			);
+		});
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		if (!value) return { default: '' };
+		const trimmed = trimChar(value, "'");
+		if (!isDate(trimmed)) return { default: `sql\`${value}\`` };
+
+		return { default: value };
+	},
+	toArrayTs: (type, value) => {
+		if (!value) return { default: '' };
+
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+			const mapped = stringifyArray(res, 'ts', (v) => {
+				const trimmed = trimChar(v, "'");
+
+				if (!isDate(trimmed)) isDrizzleSql = true;
+				return wrapWith(v, "'");
+			});
+			return {
+				default: isDrizzleSql ? mapped : `sql\`${value}\``,
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Timestamp: SqlType = {
+	// TODO
+	// ORM returns precision with space before type, why?
+	// timestamp or timestamp[] or timestamp (3) or timestamp (3)[]
+	is: (type: string) => /^\s*timestamp(?:\s)?(?:\(\d+\))?(?:\[\])*?\s*$/i.test(type),
+	drizzleImport: () => 'timestamp',
+	defaultFromDrizzle: (value, _type) => {
+		if (typeof value === 'string') return wrapWith(value, "'");
+		if (!(value instanceof Date)) {
+			throw new Error(
+				'Timestamp default value must be instance of Date or String',
+			);
+		}
+
+		const mapped = value
+			.toISOString()
+			.replace('T', ' ')
+			.replace('Z', ' ')
+			.slice(0, 23);
+		return wrapWith(mapped, "'");
+	},
+	defaultArrayFromDrizzle: (value, _type) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v === 'string') return wrapWith(v, '"');
+
+			if (v instanceof Date) {
+				return wrapWith(
+					v.toISOString().replace('T', ' ').replace('Z', ' ').slice(0, 23),
+					'"',
+				);
+			}
+			throw new Error(
+				'Unexpected default value for Timestamp, must be String or Date',
+			);
+		});
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+
+		if (!value) return { options, default: '' };
+		let patched = trimChar(value, "'");
+		patched = patched.includes('T') ? patched : patched.replace(' ', 'T') + 'Z';
+
+		const test = new Date(patched);
+
+		if (isNaN(test.getTime())) return { options, default: `sql\`${value}\`` };
+
+		return { options, default: `new Date('${patched}')` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+
+		if (!value) return { options, default: '' };
+
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				const patched = v.includes('T') ? v : v.replace(' ', 'T') + 'Z';
+				const check = new Date(patched);
+				if (isNaN(check.getTime())) isDrizzleSql = true;
+				return `new Date("${patched}")`;
+			});
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const TimestampTz: SqlType = {
+	// TODO
+	// ORM returns precision with space before type, why?
+	// timestamp with time zone or timestamp with time zone[] or timestamp (3) with time zone or timestamp (3) with time zone[]
+	is: (type: string) =>
+		/^\s*timestamp(?:\s)?(?:\(\d+\))?\s+with time zone(?:\[\])*?\s*$/i.test(
+			type,
+		),
+	drizzleImport: () => 'timestamp',
+	defaultFromDrizzle: (value, _type) => {
+		if (typeof value === 'string') {
+			const mapped = hasTimeZoneSuffix(value) ? value : value + '+00';
+			return wrapWith(mapped, "'");
+		}
+
+		if (!(value instanceof Date)) {
+			throw new Error(
+				'Timestamp default value must be instance of Date or String',
+			);
+		}
+
+		const mapped = value.toISOString().replace('T', ' ').replace('Z', '+00');
+
+		return wrapWith(mapped, "'");
+	},
+	defaultArrayFromDrizzle: (value, _type) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v === 'string') {
+				const mapped = hasTimeZoneSuffix(v) ? v : v + '+00';
+				return wrapWith(mapped, '"');
+			}
+
+			if (v instanceof Date) {
+				return wrapWith(
+					v.toISOString().replace('T', ' ').replace('Z', '+00'),
+					'"',
+				);
+			}
+			throw new Error(
+				'Unexpected default value for Timestamp, must be String or Date',
+			);
+		});
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		options['withTimezone'] = true;
+
+		if (!value) return { options, default: '' };
+		let patched = trimChar(value, "'");
+
+		const test = new Date(patched);
+
+		if (isNaN(test.getTime())) return { options, default: `sql\`${value}\`` };
+
+		return { options, default: `new Date('${patched}')` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		options['withTimezone'] = true;
+
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			let isDrizzleSql: boolean = false;
+			const def = stringifyArray(res, 'ts', (v) => {
+				const trimmed = trimChar(v, "'");
+				const check = new Date(trimmed);
+
+				if (isNaN(check.getTime())) isDrizzleSql = true;
+				return `new Date("${trimmed}")`;
+			});
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Uuid: SqlType = {
+	is: (type: string) => /^\s*uuid(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'uuid',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		value = trimChar(value, "'");
+		if (value === 'gen_random_uuid()') return { options, default: '.defaultRandom()' };
+		if (!value.startsWith("'") && !value.endsWith("'") && value.endsWith('()')) {
+			return { options, default: `sql\`${value}\`` };
+		}
+		return { options, default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Interval: SqlType = {
+	is: (type: string) =>
+		/^interval(\s+(year|month|day|hour|minute|second)(\s+to\s+(month|day|hour|minute|second))?)?(?:\((\d+)\))?(?:\s*\[\s*\])*\s*$/i
+			.test(type),
+	drizzleImport: () => 'interval',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return `"${v}"`;
+		});
+
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: { precision?: number; fields?: typeof possibleIntervals[number] } = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		const fields = parseIntervalFields(type);
+		if (fields.fields) options['fields'] = fields.fields;
+
+		if (!value) return { options, default: '' };
+
+		return { options, default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (type, value) => {
+		const options: any = {};
+		const [precision] = parseParams(type);
+		if (precision) options['precision'] = Number(precision);
+		const fields = parseIntervalFields(type);
+		if (fields.fields) options['fields'] = fields.fields;
+
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Inet: SqlType = {
+	is: (type: string) =>
+		/^inet(?:\((\d+)\))?(\[\])?$/i
+			.test(type),
+	drizzleImport: () => 'inet',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => {
+		if (!value) return { default: '' };
+		return { default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Cidr: SqlType = {
+	is: (type: string) =>
+		/^cidr(?:\((\d+)\))?(\[\])?$/i
+			.test(type),
+	drizzleImport: () => 'cidr',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => {
+		if (!value) return { default: '' };
+		return { default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const MacAddr: SqlType = {
+	is: (type: string) => /^macaddr(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'macaddr',
+	defaultFromDrizzle: (value) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			return v;
+		});
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (_, value) => {
+		if (!value) return { default: '' };
+		return { default: `"${trimChar(value, "'")}"` };
+	},
+	toArrayTs: (_, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					return `"${v}"`;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+export const MacAddr8: SqlType = {
+	is: (type: string) => /^macaddr8(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'macaddr8',
+	defaultFromDrizzle: MacAddr.defaultFromDrizzle,
+	defaultArrayFromDrizzle: MacAddr.defaultArrayFromDrizzle,
+	defaultFromIntrospect: MacAddr.defaultFromIntrospect,
+	defaultArrayFromIntrospect: MacAddr.defaultArrayFromIntrospect,
+	toTs: MacAddr.toTs,
+	toArrayTs: MacAddr.toArrayTs,
+};
+
+export const Vector: SqlType = {
+	is: (type: string) => /^\s*vector(?:\(\d+\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'vector',
+	defaultFromDrizzle: (value) => {
+		return `'[${String(value).replaceAll(' ', '')}]'`;
+	},
+	defaultArrayFromDrizzle: (value, _dimensions) => {
+		const res = stringifyTuplesArray(value, 'sql', (v: number[]) => {
+			const res = v.length > 0 ? `"[${String(v).replaceAll(' ', '')}]"` : '"[]"';
+			return res;
+		});
+
+		return wrapWith(res.replaceAll(' ', ''), "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: { dimensions?: number } = {};
+		const [dimensions] = parseParams(type);
+		if (dimensions) options['dimensions'] = Number(dimensions);
+
+		if (!value) return { options, default: '' };
+
+		return { options, default: trimChar(value, "'") };
+	},
+	toArrayTs: (type, value) => {
+		const options: { dimensions?: number } = {};
+		const [dimensions] = parseParams(type);
+		if (dimensions) options['dimensions'] = Number(dimensions);
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return v;
+				}, Number(dimensions)),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+export const HalfVec: SqlType = {
+	is: (type: string) => /^\s*halfvec(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'halfvec',
+	defaultFromDrizzle: Vector.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Vector.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Vector.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Vector.defaultArrayFromIntrospect,
+	toTs: Vector.toTs,
+	toArrayTs: Vector.toArrayTs,
+};
+export const SparseVec: SqlType = {
+	is: (type: string) => /^\s*sparsevec(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'sparsevec',
+	defaultFromDrizzle: (value) => {
+		return wrapWith(String(value), "'");
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			return `"${String(v).replaceAll(' ', '')}"`;
+		});
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: (type, value) => {
+		const options: { dimensions?: number } = {};
+		const [dimensions] = parseParams(type);
+		if (dimensions) options['dimensions'] = Number(dimensions);
+
+		if (!value) return { options, default: '' };
+
+		return { options, default: value };
+	},
+	toArrayTs: (type, value) => {
+		const options: { dimensions?: number } = {};
+		const [dimensions] = parseParams(type);
+		if (dimensions) options['dimensions'] = Number(dimensions);
+		if (!value) return { options, default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				options,
+				default: stringifyArray(res, 'ts', (v) => {
+					return wrapWith(v, "'");
+				}),
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Bit: SqlType = {
+	is: (type: string) => /^\s*bit(?:\(\d+(?:,\d+)?\))?(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'bit',
+	defaultFromDrizzle: (value, _) => {
+		return `'${value}'`;
+	},
+	defaultArrayFromDrizzle: (value, _type) => {
+		return `'${stringifyArray(value, 'sql', (v) => String(v))}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const [dimensions] = parseParams(type);
+		const options = dimensions ? { dimensions: Number(dimensions) } : {};
+
+		if (!value) return { options, default: '' };
+
+		if (/^'[01]+'$/.test(value)) {
+			return { options, default: value };
+		}
+
+		return { options, default: `sql\`${value}\`` };
+	},
+	toArrayTs: (type, value) => {
+		const [dimensions] = parseParams(type);
+		const options = dimensions ? { dimensions: Number(dimensions) } : {};
+
+		if (!value) return { default: '' };
+
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (!/^[01]+$/.test(v)) isDrizzleSql = true;
+				return `"${v}"`;
+			});
+
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Point: SqlType = {
+	is: (type: string) => /^\s*point(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'point',
+	defaultFromDrizzle: (value, mode) => {
+		if (!value) return '';
+
+		if (mode === 'xy') {
+			const v: { x: number; y: number } = value as { x: number; y: number };
+			return Object.values(v).length > 0 ? `'(${v.x},${v.y})'` : '';
+		}
+		if (mode === 'tuple') {
+			const v: number[] = value as number[];
+			return v.length > 0 ? `'(${v[0]},${v[1]})'` : '';
+		}
+
+		throw new Error('unknown point type');
+	},
+	defaultArrayFromDrizzle: function(value: any[], dimensions: number, mode): Column['default'] {
+		let res;
+
+		if (mode === 'tuple') {
+			res = stringifyTuplesArray(value, 'sql', (x: number[]) => {
+				const res = x.length > 0 ? `(${x[0]},${x[1]})` : '{}';
+				return `"${res}"`;
+			});
+		} else if (mode === 'xy') {
+			res = stringifyArray(value, 'sql', (x: { x: number; y: number }, _depth: number) => {
+				const res = Object.values(x).length > 0 ? `(${x.x},${x.y})` : '{}';
+				return `"${res}"`;
+			});
+		} else throw new Error('unknown point type');
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: function(value: string): string {
+		return value;
+	},
+	defaultArrayFromIntrospect: function(value: string): string {
+		return value;
+	},
+	toTs: function(
+		type: string,
+		value: string | null,
+	): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		if (/^'\(\d+,\d+\)'$/.test(value)) {
+			return { default: trimChar(value, "'").replace('(', '[').replace(')', ']'), options: {} };
+		}
+
+		return { default: `sql\`${value}\``, options: {} };
+	},
+	toArrayTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (!/^\(\d+,\d+\)$/.test(v)) isDrizzleSql = true;
+				return v.replace('(', '[').replace(')', ']');
+			});
+
+			return {
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Line: SqlType = {
+	is: (type: string) => /^\s*line(?:\s*\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'line',
+	defaultFromDrizzle: (value, mode) => {
+		if (!value) return '';
+
+		if (mode === 'tuple') {
+			const v: number[] = value as number[];
+			return v.length > 0 ? `'{${v[0]},${v[1]},${v[2]}}'` : '';
+		}
+
+		if (mode === 'abc') {
+			const v: { a: number; b: number; c: number } = value as {
+				a: number;
+				b: number;
+				c: number;
+			};
+			return Object.values(v).length > 0 ? `'{${v.a},${v.b},${v.c}}'` : '';
+		}
+
+		throw new Error('unknown line type');
+	},
+	defaultArrayFromDrizzle: function(value: any[], dimensions: number, mode): Column['default'] {
+		let res;
+
+		if (mode === 'tuple') {
+			res = stringifyTuplesArray(value, 'sql', (x: number[]) => {
+				const res = x.length > 0 ? `{${x[0]},${x[1]},${x[2]}}` : '{}';
+				return `"${res}"`;
+			});
+		} else if (mode === 'abc') {
+			res = stringifyArray(value, 'sql', (x: { a: number; b: number; c: number }, _depth: number) => {
+				const res = Object.values(x).length > 0 ? `{${x.a},${x.b},${x.c}}` : '{}';
+				return `"${res}"`;
+			});
+		} else throw new Error('unknown line type');
+
+		return wrapWith(res, "'");
+	},
+	defaultFromIntrospect: function(value: string): string {
+		return value;
+	},
+	defaultArrayFromIntrospect: function(value: string): string {
+		return value;
+	},
+	toTs: function(
+		type: string,
+		value: string | null,
+	): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		if (/^'\{\d+,\d+,\d+\}'$/.test(value)) {
+			return { default: trimChar(value, "'").replace('{', '[').replace('}', ']'), options: {} };
+		}
+
+		return { default: `sql\`${value}\``, options: {} };
+	},
+	toArrayTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		let isDrizzleSql: boolean = false;
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (!/^\{\d+,\d+,\d+\}$/.test(v)) isDrizzleSql = true;
+				return v.replace('{', '[').replace('}', ']');
+			});
+
+			return {
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const GeometryPoint: SqlType = {
+	is: (type: string) => /^\s*geometry\(point(?:,\d+)?\)(?:\[\s*\])*\s*$/i.test(type),
+	drizzleImport: () => 'geometry',
+	defaultFromDrizzle: (value, mode, config) => {
+		if (!value) return '';
+
+		const srid: number | undefined = config ? Number(config) : undefined;
+		let sridPrefix = srid ? `SRID=${srid};` : '';
+		if (mode === 'tuple') {
+			const v: number[] = value as number[];
+			return v.length > 0 ? `'${sridPrefix}POINT(${v[0]} ${v[1]})'` : '';
+		}
+
+		if (mode === 'object') {
+			const v: { x: number; y: number } = value as { x: number; y: number };
+			return Object.values(v).length > 0
+				? `'${sridPrefix}POINT(${v.x} ${v.y})'`
+				: '';
+		}
+
+		throw new Error('unknown geometry type');
+	},
+	defaultArrayFromDrizzle: function(
+		value: any[],
+		dimensions: number,
+		mode,
+		config,
+	): string {
+		// Parse to ARRAY[]
+		let res;
+		const srid: number | undefined = config ? Number(config) : undefined;
+		let sridPrefix = srid ? `SRID=${srid};` : '';
+		if (mode === 'tuple') {
+			res = stringifyTuplesArray(value, 'geometry-sql', (x: number[]) => {
+				const res = `${sridPrefix}POINT(${x[0]} ${x[1]})`;
+				return `'${res}'`;
+			});
+		} else if (mode === 'object') {
+			res = stringifyArray(value, 'geometry-sql', (x: { x: number; y: number }, _depth: number) => {
+				const res = `${sridPrefix}POINT(${x.x} ${x.y})`;
+				return `'${res}'`;
+			});
+		} else throw new Error('unknown geometry type');
+
+		return res;
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		let def: string;
+
+		try {
+			const { srid, point } = parseEWKB(trimChar(value, "'"));
+			let sridPrefix = srid ? `SRID=${srid};` : '';
+			def = `'${sridPrefix}POINT(${point[0]} ${point[1]})'`;
+		} catch {
+			def = value;
+		}
+
+		return def;
+	},
+	defaultArrayFromIntrospect: function(value: string): Column['default'] {
+		// If {} array - parse to ARRAY[]
+
+		/**
+		 * Potential values here are:
+		 * DEFAULT {'POINT(10 10)'} -> '{010100000000000000000024400000000000002440}'::geometry(Point,435)[]
+		 * DEFAULT ARRAY['POINT(10 10)'] -> ARRAY['POINT(10 10)'::text]
+		 * DEFAULT ARRAY['POINT(10 10)']::geometry(point) -> ARRAY['010100000000000000000024400000000000002440'::geometry(Point)]
+		 * DEFAULT ARRAY['POINT(10 10)'::text]::geometry(point) -> ARRAY[('POINT(10 10)'::text)::geometry(Point)]
+		 */
+		let def = value;
+
+		if (def === "'{}'") return def;
+
+		try {
+			if (value.startsWith("'{") && value.endsWith("}'")) {
+				const parsed = parseArray(trimChar(value, "'"));
+
+				def = stringifyArray(parsed, 'geometry-sql', (v) => {
+					try {
+						const { srid, point } = parseEWKB(v);
+						let sridPrefix = srid ? `SRID=${srid};` : '';
+						return `'${sridPrefix}POINT(${point[0]} ${point[1]})'`;
+					} catch {
+						return v;
+					}
+				});
+			} else {
+				const parsed = parseExpressionArray(value);
+				def = stringifyArray(parsed, 'geometry-sql', (v) => {
+					v = trimDefaultValueSuffix(trimDefaultValueSuffix(v).replace(/^\((.*)\)$/, '$1'));
+					try {
+						const { srid, point } = parseEWKB(trimChar(v, "'"));
+						let sridPrefix = srid ? `SRID=${srid};` : '';
+						return `'${sridPrefix}POINT(${point[0]} ${point[1]})'`;
+					} catch {
+						return v;
+					}
+				});
+			}
+		} catch {}
+
+		return def;
+	},
+	toTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		const options: { srid?: number; type: 'point' } = { type: 'point' };
+
+		const sridOption = splitSqlType(type).options?.split(',')[1];
+		if (sridOption) options.srid = Number(sridOption);
+
+		if (!value.includes('POINT(')) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		const sridInDef = value.startsWith("'SRID=") ? Number(value.split('SRID=')[1].split(';')[0]) : undefined;
+		if (!sridOption && sridInDef) {
+			return { default: `sql\`${value}\``, options };
+		}
+
+		const [res1, res2] = value.split('POINT(')[1].split(')')[0].split(' ');
+
+		return { default: `[${res1},${res2}]`, options };
+	},
+	toArrayTs: function(type: string, value: string | null): { options?: Record<string, unknown>; default: string } {
+		if (!value) return { default: '' };
+
+		const options: { srid?: number; type: 'point' } = { type: 'point' };
+		const sridOption = splitSqlType(type).options?.split(',')[1];
+		if (sridOption) options.srid = Number(sridOption);
+
+		if (!value) return { default: '', options };
+
+		if (value === "'{}'") return { default: '[]', options };
+
+		let isDrizzleSql;
+		const srids: number[] = [];
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseExpressionArray(trimmed);
+
+			const def = stringifyArray(res, 'ts', (v) => {
+				if (v.includes('SRID=')) {
+					srids.push(Number(v.split('SRID=')[1].split(';')[0]));
+				}
+				const [res1, res2] = value.split('POINT(')[1].split(')')[0].split(' ');
+				if (!value.includes('POINT(')) isDrizzleSql = true;
+
+				return `[${res1}, ${res2}]`;
+			});
+
+			if (!isDrizzleSql) isDrizzleSql = srids.some((it) => it !== srids[0]);
+			// if there is no srid in type and user defines srids in default
+			// we need to return point with srids
+			if (!isDrizzleSql && !sridOption && srids.length > 0) isDrizzleSql = true;
+
+			return {
+				options,
+				default: isDrizzleSql ? `sql\`${value}\`` : def,
+			};
+		} catch {
+			return { options, default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Enum: SqlType = {
+	is: (_type: string) => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'pgEnum',
+	defaultFromDrizzle: (value) => {
+		if (!value) return '';
+		const escaped = (value as string).replaceAll("'", "''");
+		return `'${escaped}'`;
+	},
+	defaultArrayFromDrizzle: (value) => {
+		const res = stringifyArray(value, 'sql', (v) => {
+			if (typeof v !== 'string') throw new Error();
+			const escaped = escapeForSqlDefault(v, 'pg-arr');
+			if (v.includes('\\') || v.includes('"') || v.includes(',')) {
+				return `"${escaped}"`;
+			}
+			return escaped;
+		});
+		return `'${res}'`;
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		const [length] = parseParams(type);
+		if (length) options['length'] = Number(length);
+		if (!value) return { options, default: '' };
+		const escaped = escapeForTsLiteral(
+			trimChar(value, "'").replaceAll("''", "'"),
+		);
+		return { options, default: escaped };
+	},
+	toArrayTs: (type, value) => {
+		if (!value) return { default: '' };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(
+						unescapeFromSqlDefault(trimChar(v, "'")),
+					);
+					return escaped;
+				}),
+			};
+		} catch {
+			return { default: `sql\`${value}\`` };
+		}
+	},
+};
+
+export const Serial: SqlType = {
+	is: (type: string) => /^(?:serial)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'serial',
+	defaultFromDrizzle: (value) => {
+		throw new Error(`Unexpected default for serial type: ${value}`);
+	},
+	defaultArrayFromDrizzle: (v) => {
+		throw new Error(`Unexpected default for serial type: ${v}`);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: function(value: string): string {
+		return value;
+	},
+	toTs: () => {
+		return { default: '' };
+	},
+	toArrayTs: () => {
+		return { default: '' };
+	},
+};
+
+export const BigSerial: SqlType = {
+	is: (type: string) => /^(?:bigserial)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'bigserial',
+	defaultFromDrizzle: Serial.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Serial.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Serial.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Serial.defaultArrayFromIntrospect,
+	toTs: () => {
+		return { options: { mode: 'number' }, default: '' };
+	},
+	toArrayTs: () => {
+		return { options: { mode: 'number' }, default: '' };
+	},
+};
+export const SmallSerial: SqlType = {
+	is: (type: string) => /^(?:smallserial)(?:[\s(].*)?$/i.test(type),
+	drizzleImport: () => 'smallserial',
+	defaultFromDrizzle: Serial.defaultFromDrizzle,
+	defaultArrayFromDrizzle: Serial.defaultArrayFromDrizzle,
+	defaultFromIntrospect: Serial.defaultFromIntrospect,
+	defaultArrayFromIntrospect: Serial.defaultArrayFromIntrospect,
+	toTs: Serial.toTs,
+	toArrayTs: Serial.toArrayTs,
+};
+
+export const Custom: SqlType = {
+	is: (_type: string) => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'customType',
+	defaultFromDrizzle: (value) => {
+		if (!value) return '';
+		return String(value);
+	},
+	defaultArrayFromDrizzle: (value) => {
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	defaultArrayFromIntrospect: (value) => {
+		return value as string;
+	},
+	toTs: (type, value) => {
+		const options: any = {};
+		if (!value) return { options, default: '', customType: type };
+		const escaped = escapeForTsLiteral(value);
+		return { default: escaped, customType: type };
+	},
+	toArrayTs: (type, value) => {
+		if (!value) return { default: '', customType: type };
+
+		try {
+			const trimmed = trimChar(trimChar(value, ['(', ')']), "'");
+			const res = parseArray(trimmed);
+
+			return {
+				default: stringifyArray(res, 'ts', (v) => {
+					const escaped = escapeForTsLiteral(v);
+					return escaped;
+				}),
+				customType: type,
+			};
+		} catch {
+			return { default: `sql\`${value}\``, customType: type };
+		}
+	},
+};
+
+export const typeFor = (type: string, isEnum: boolean): SqlType => {
+	if (isEnum) return Enum;
+	if (SmallInt.is(type)) return SmallInt;
+	if (Int.is(type)) return Int;
+	if (BigInt.is(type)) return BigInt;
+	if (Numeric.is(type)) return Numeric;
+	if (Real.is(type)) return Real;
+	if (Double.is(type)) return Double;
+	if (Boolean.is(type)) return Boolean;
+	if (Char.is(type)) return Char;
+	if (Varchar.is(type)) return Varchar;
+	if (Text.is(type)) return Text;
+	if (Json.is(type)) return Json;
+	if (Jsonb.is(type)) return Jsonb;
+	if (Time.is(type)) return Time;
+	if (TimeTz.is(type)) return TimeTz;
+	if (Timestamp.is(type)) return Timestamp;
+	if (TimestampTz.is(type)) return TimestampTz;
+	if (Uuid.is(type)) return Uuid;
+	if (Interval.is(type)) return Interval;
+	if (Inet.is(type)) return Inet;
+	if (Cidr.is(type)) return Cidr;
+	if (MacAddr.is(type)) return MacAddr;
+	if (MacAddr8.is(type)) return MacAddr8;
+	if (Vector.is(type)) return Vector;
+	if (HalfVec.is(type)) return HalfVec;
+	if (SparseVec.is(type)) return SparseVec;
+	if (Bit.is(type)) return Bit;
+	if (Point.is(type)) return Point;
+	if (Line.is(type)) return Line;
+	if (DateType.is(type)) return DateType;
+	if (GeometryPoint.is(type)) return GeometryPoint;
+	if (Serial.is(type)) return Serial;
+	if (SmallSerial.is(type)) return SmallSerial;
+	if (BigSerial.is(type)) return BigSerial;
+	return Custom;
+};
+
+export const splitSqlType = (sqlType: string) => {
+	// timestamp(6) with time zone -> [timestamp, 6, with time zone]
+	const toMatch = sqlType.replaceAll('[]', '');
+	const match = toMatch.match(/^(\w+(?:\s+\w+)*)\(([^)]*)\)(?:\s+with time zone)?$/i);
+	let type = match ? (match[1] + (match[3] ?? '')) : toMatch;
+	let options = match ? match[2].replaceAll(', ', ',') : null;
+
+	return { type, options };
+};
+
+export const vectorOps = [
+	'vector_l2_ops',
+	'vector_ip_ops',
+	'vector_cosine_ops',
+	'vector_l1_ops',
+	'bit_hamming_ops',
+	'bit_jaccard_ops',
+	'halfvec_l2_ops',
+	'sparsevec_l2_ops',
+];
+
+export const indexName = (tableName: string, columns: string[]) => {
+	return `${tableName}_${columns.join('_')}_index`;
+};
+
+export function stringFromIdentityProperty(field: string | number | undefined): string | undefined {
+	return typeof field === 'string' ? (field as string) : typeof field === 'undefined' ? undefined : String(field);
+}
+
+export function maxRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'integer' ? '2147483647' : columnType === 'bigint' ? '9223372036854775807' : '32767';
+}
+
+export function minRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'integer' ? '-2147483648' : columnType === 'bigint' ? '-9223372036854775808' : '-32768';
+}
+
+/*
+	we can't check for `nextval('${schemaPrefix}${table}_${column}_seq'::regclass)` perfect match
+	since table or column might be renamed, while sequence preserve name and it will trigger
+	subsequent ddl diffs
+ */
+export const isSerialExpression = (expr: string, schema: string) => {
+	const schemaPrefix = schema === 'public' ? '' : `${schema}`;
+	return (expr.startsWith(`nextval('${schemaPrefix}`)
+		|| expr.startsWith(`nextval('"${schemaPrefix}"${schemaPrefix ? '.' : ''}`))
+		&& (expr.endsWith(`_seq'::regclass)`) || expr.endsWith(`_seq"'::regclass)`));
+};
+
+export function stringFromDatabaseIdentityProperty(field: any): string | null {
+	return typeof field === 'string'
+		? (field as string)
+		: typeof field === 'undefined' || field === null
+		? null
+		: typeof field === 'bigint'
+		? field.toString()
+		: String(field);
+}
+
+export function buildArrayString(array: any[], sqlType: string): string {
+	// we check if array consists only of empty arrays down to 5th dimension
+	if (array.flat(5).length === 0) {
+		return '{}';
+	}
+
+	const values = array
+		.map((value) => {
+			if (typeof value === 'number' || typeof value === 'bigint') {
+				return value.toString();
+			}
+
+			if (typeof value === 'boolean') {
+				return value ? 't' : 'f';
+			}
+
+			if (Array.isArray(value)) {
+				return buildArrayString(value, sqlType);
+			}
+
+			if (sqlType.startsWith('numeric')) {
+				return String(value);
+			}
+
+			if (value instanceof Date) {
+				if (sqlType === 'date') {
+					return `${value.toISOString().split('T')[0]}`;
+				} else if (sqlType === 'timestamp') {
+					return `"${value.toISOString().replace('T', ' ').replace('Z', ' ').slice(0, 23)}"`;
+				} else {
+					return `"${value.toISOString().replace('T', ' ').replace('Z', '')}"`;
+				}
+			}
+
+			if (typeof value === 'object') {
+				return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
+			}
+
+			if (typeof value === 'string') {
+				if (/^[a-zA-Z0-9./_':-]+$/.test(value)) return value.replaceAll("'", "''");
+				return `"${value.replaceAll("'", "''").replaceAll('"', '\\"')}"`;
+			}
+
+			return `"${value}"`;
+		})
+		.join(',');
+
+	return `{${values}}`;
+}
+
+export type OnAction = PostgresEntities['fks']['onUpdate'];
+export const parseOnType = (type: string): OnAction => {
+	switch (type) {
+		case 'a':
+			return 'NO ACTION';
+		case 'r':
+			return 'RESTRICT';
+		case 'n':
+			return 'SET NULL';
+		case 'c':
+			return 'CASCADE';
+		case 'd':
+			return 'SET DEFAULT';
+		default:
+			throw new Error(`Unknown foreign key type: ${type}`);
+	}
+};
+
+export const planetscaleNamespaces = ['pscale_extensions'];
+export const systemNamespaceNames = ['pg_toast', 'pg_catalog', 'information_schema', ...planetscaleNamespaces];
+export const isSystemNamespace = (name: string) => {
+	return name.startsWith('pg_toast') || name === 'pg_default' || name === 'pg_global' || name.startsWith('pg_temp_')
+		|| systemNamespaceNames.indexOf(name) >= 0;
+};
+
+export const isSystemRole = (name: string) => {
+	return name === 'postgres' || name.startsWith('pg_');
+};
+
+type DefaultMapper<IN> = (value: IN | IN[]) => Column['default'];
+
+export const defaultForVector: DefaultMapper<[number, number, number]> = (
+	value,
+) => {
+	const res = stringifyTuplesArray(
+		value,
+		'sql',
+		(x: number[], depth: number) => {
+			const res = x.length > 0 ? `[${x[0]},${x[1]},${x[2]}]` : '{}';
+			return depth === 0 ? res : `"${res}"`;
+		},
+	);
+	return `'${res}'`;
+};
+
+// TODO: check
+// export const splitExpressions = (input: string | null): string[] => {
+// 	if (!input) return [];
+
+// 	const wrapped = input.startsWith('(') && input.endsWith(')');
+// 	input = wrapped ? input.slice(1, input.length - 1) : input;
+
+// 	// This regex uses three alternatives:
+// 	// 1. Quoted strings that allow escaped quotes: '([^']*(?:''[^']*)*)'
+// 	// 2. Parenthesized expressions that support one level of nesting:
+// 	//      \((?:[^()]+|\([^()]*\))*\)
+// 	// 3. Any character that is not a comma, quote, or parenthesis: [^,'()]
+// 	//
+// 	// It also trims optional whitespace before and after each token,
+// 	// requiring that tokens are followed by a comma or the end of the string.
+// 	// const regex = /\s*((?:'[^']*(?:''[^']*)*'|\((?:[^()]+|\([^()]*\))*\)|[^,'()])+)\s*(?:,|$)/g;
+// 	const regex = /\s*((?:'(?:[^']|'')*'|\((?:[^()]+|\([^()]*\))*\)|[^,'()])+)\s*(?:,|$)/g;
+// 	const result: string[] = [];
+// 	let match: RegExpExecArray | null;
+
+// 	while ((match = regex.exec(input)) !== null) {
+// 		result.push(match[1].trim());
+// 	}
+
+// 	return result;
+// };
+
+// TODO: write a test for view in postgres security_invoker = on ???
+export const wrapRecord = (it: Record<string, string>) => {
+	return {
+		bool: (key: string) => {
+			if (key in it) {
+				const value = it[key];
+				if (value === 'true' || value === '1' || value === 'on' || value === 'yes') {
+					return true;
+				}
+				if (value === 'false' || value === '0' || value === 'off' || value === 'no') {
+					return false;
+				}
+
+				throw new Error(`Invalid options boolean value for ${key}: ${it[key]}`);
+			}
+			return null;
+		},
+		num: (key: string) => {
+			if (key in it) {
+				const value = Number(it[key]);
+				if (isNaN(value)) {
+					throw new Error(`Invalid options number value for ${key}: ${it[key]}`);
+				}
+				return value;
+			}
+			return null;
+		},
+		str: (key: string) => {
+			if (key in it) {
+				return it[key];
+			}
+			return null;
+		},
+		literal: <T extends string>(key: string, allowed: T[]): T | null => {
+			if (!(key in it)) return null;
+			const value = it[key];
+
+			if (allowed.includes(value as T)) {
+				return value as T;
+			}
+			throw new Error(`Invalid options literal value for ${key}: ${it[key]}`);
+		},
+	};
+};
+
+/*
+	CHECK (((email)::text <> 'test@gmail.com'::text))
+	Where (email) is column in table
+*/
+export const parseCheckDefinition = (value: string): string => {
+	return value.replace(/^CHECK\s*\(\(/, '').replace(/\)\)\s*$/, '');
+};
+
+export const parseViewDefinition = (value: string | null | undefined): string | null => {
+	if (!value) return null;
+	return value.replace(/\s+/g, ' ').replace(';', '').trim();
+};
+
+export const defaultNameForIdentitySequence = (table: string, column: string) => {
+	return `${table}_${column}_seq`;
+};
+
+export const defaultNameForPK = (table: string) => {
+	return `${table}_pkey`;
+};
+
+export const defaultNameForFK = (table: string, columns: string[], tableTo: string, columnsTo: string[]) => {
+	const desired = `${table}_${columns.join('_')}_${tableTo}_${columnsTo.join('_')}_fkey`;
+	const res = desired.length > 63
+		? table.length < 63 - 18 // _{hash(12)}_fkey
+			? `${table}_${hash(desired)}_fkey`
+			: `${hash(desired)}_fkey` // 1/~3e21 collision chance within single schema, it's fine
+		: desired;
+	return res;
+};
+
+export const defaultNameForUnique = (table: string, ...columns: string[]) => {
+	return `${table}_${columns.join('_')}_key`;
+};
+
+export const defaultNameForIndex = (table: string, columns: string[]) => {
+	return `${table}_${columns.join('_')}_idx`;
+};
+
+export const trimDefaultValueSuffix = (value: string) => {
+	let res = value.endsWith('[]') ? value.slice(0, -2) : value;
+	res = res.replace(/(::["\w.\s]+(?:\([^)]*\))?(?:\swith(?:out)?\stime\szone)?(?:\[\])?)+$/gi, '');
+	return res;
+};
+
+export const defaultForColumn = (
+	type: string,
+	def: string | boolean | number | null | undefined,
+	dimensions: number,
+	isEnum: boolean,
+): Column['default'] => {
+	if (
+		def === null
+		|| def === undefined
+		|| type === 'serial'
+		|| type === 'smallserial'
+		|| type === 'bigserial'
+	) {
+		return null;
+	}
+
+	if (typeof def === 'boolean') {
+		return String(def);
+	}
+
+	if (typeof def === 'number') {
+		return String(def);
+	}
+
+	let value = trimDefaultValueSuffix(def);
+	const grammarType = typeFor(type, isEnum);
+	if (dimensions > 0) return grammarType.defaultArrayFromIntrospect(value);
+	return grammarType.defaultFromIntrospect(String(value));
+};
+
+export const defaultToSQL = (
+	it: Pick<Column, 'default' | 'dimensions' | 'type' | 'typeSchema'>,
+) => {
+	if (!it.default) return '';
+
+	const { type: columnType, dimensions, typeSchema } = it;
+	const value = it.default;
+
+	if (typeSchema) {
+		const schemaPrefix = typeSchema && typeSchema !== 'public' ? `"${typeSchema}".` : '';
+		return `${value}::${schemaPrefix}"${columnType}"${dimensions > 0 ? '[]' : ''}`;
+	}
+
+	const suffix = dimensions > 0 ? `::${columnType}[]` : '';
+
+	const defaultValue = it.default ?? '';
+	return `${defaultValue}${suffix}`;
+};
+
+export const isDefaultAction = (action: string) => {
+	return action.toLowerCase() === 'no action';
+};
+
+export const isSerialType = (type: string) => {
+	return /^(?:serial|bigserial|smallserial)$/i.test(type);
+};
+
+export const mapSerialToInt = (type: string) => {
+	switch (type) {
+		case 'smallserial':
+			return 'smallint';
+		case 'serial':
+			return 'int';
+		case 'bigserial':
+			return 'bigint';
+		default:
+			throw new Error(`Unsupported type: ${type}`);
+	}
+};
+
+// map all to utc with saving precision
+function formatTimestampTz(date: string) {
+	if (!isTimestamp(date)) return date;
+
+	// Convert to Temporal.Instant
+	const instant = Temporal.Instant.from(date);
+
+	const iso = instant.toString({ timeZone: 'UTC' });
+
+	// const fractionalDigits = iso.split('.')[1]!.length;
+
+	// // decide whether to limit precision
+	// const formattedPrecision = fractionalDigits > precision
+	// 	// @ts-expect-error
+	// 	? instant.toString({ fractionalSecondDigits: precision })
+	// 	: iso;
+
+	return iso;
+}
+function formatTime(date: string) {
+	if (!isTime(date)) return date;
+
+	// Convert to Temporal.Instant
+	const instant = Temporal.Instant.from(`1970-01-01 ${date}`);
+
+	const iso = instant.toString({ timeZone: 'UTC' });
+
+	// const fractionalDigits = iso.split('.')[1]!.length;
+
+	// // decide whether to limit precision
+	// const formattedPrecision = fractionalDigits > precision
+	// 	// @ts-expect-error
+	// 	? instant.toString({ fractionalSecondDigits: precision })
+	// 	: iso;
+
+	return iso;
+}
+export const defaultsCommutative = (
+	diffDef: DiffEntities['columns']['default'],
+	type: string,
+	dimensions: number,
+): boolean => {
+	if (!diffDef) return false;
+
+	let from = diffDef.from;
+	let to = diffDef.to;
+
+	if (from === to) return true;
+	if (from === `(${to})`) return true;
+	if (to === `(${from})`) return true;
+
+	if (type.startsWith('timestamp') && type.includes('with time zone')) {
+		if (from && to) {
+			from = trimChar(from, "'");
+			to = trimChar(to, "'");
+
+			if (dimensions > 0) {
+				try {
+					const fromArray = stringifyArray(parseArray(from), 'sql', (v) => {
+						return `"${formatTimestampTz(v)}"`;
+					});
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => {
+						return `"${formatTimestampTz(v)}"`;
+					});
+
+					if (toArray === fromArray) return true;
+				} catch {}
+
+				return false;
+			}
+
+			if (formatTimestampTz(to) === formatTimestampTz(from)) return true;
+		}
+
+		return false;
+	}
+
+	if (type.startsWith('time') && type.includes('with time zone')) {
+		if (from && to) {
+			from = trimChar(from, "'");
+			to = trimChar(to, "'");
+
+			if (dimensions > 0) {
+				try {
+					const fromArray = stringifyArray(parseArray(from), 'sql', (v) => {
+						return `"${formatTime(v)}"`;
+					});
+					const toArray = stringifyArray(parseArray(to), 'sql', (v) => {
+						return `"${formatTime(v)}"`;
+					});
+
+					if (toArray === fromArray) return true;
+				} catch {}
+
+				return false;
+			}
+
+			if (formatTime(to) === formatTime(from)) return true;
+		}
+
+		return false;
+	}
+
+	// if define '[4.0]', psql will store it as '[4]'
+	if (type.startsWith('vector')) {
+		if (from?.replaceAll('.0', '') === to) return true;
+	}
+
+	return false;
+};
+
+export const defaults = {
+	/*
+			By default, PostgreSQL uses the cluster’s default tablespace (which is named 'pg_default')
+
+			This operation requires an exclusive lock on the materialized view (it rewrites the data file),
+			and you must have CREATE privilege on the target tablespace.
+			If you have indexes on the materialized view, note that moving the base table does not automatically move its indexes.
+			Each index is a separate object and retains its original tablespace​.
+
+			You should move indexes individually, for example:
+			sql`ALTER INDEX my_matview_idx1 SET TABLESPACE pg_default`;
+			sql`ALTER INDEX my_matview_idx2 SET TABLESPACE pg_default`;
+		*/
+	tablespace: 'pg_default',
+
+	/*
+		The table access method (the storage engine format) is chosen when the materialized view is created,
+		 using the optional USING <method> clause.
+		 If no method is specified, it uses the default access method (typically the regular heap storage)​
+
+		sql`
+			CREATE MATERIALIZED VIEW my_matview
+			USING heap  -- storage access method; "heap" is the default
+			AS SELECT ...;
+		`
+
+		Starting with PostgreSQL 15, you can alter a materialized view’s access method in-place.
+		PostgreSQL 15 introduced support for ALTER MATERIALIZED VIEW ... SET ACCESS METHOD new_method
+		*/
+	accessMethod: 'heap',
+
+	/*
+		By default, NULL values are treated as distinct entries.
+		Specifying NULLS NOT DISTINCT on unique indexes / constraints will cause NULL to be treated as not distinct,
+		or in other words, equivalently.
+
+		https://www.postgresql.org/about/featurematrix/detail/392/
+	*/
+	nullsNotDistinct: false,
+
+	identity: {
+		startWith: '1',
+		increment: '1',
+		min: '1',
+		maxFor: (type: string) => {
+			if (type === 'smallint') return '32767';
+			if (type === 'integer') return '2147483647';
+			if (type === 'bigint') return '9223372036854775807';
+			throw new Error(`Unknow identity column type: ${type}`);
+		},
+		cache: 1,
+		cycle: false,
+	},
+
+	index: {
+		method: 'btree',
+	},
+
+	types: {
+		geometry: {
+			defSrid: 0,
+		},
+	},
+} as const;
diff --git a/drizzle-kit/src/dialects/postgres/introspect.ts b/drizzle-kit/src/dialects/postgres/introspect.ts
new file mode 100644
index 0000000000..bf375d9bff
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/introspect.ts
@@ -0,0 +1,1224 @@
+import camelcase from 'camelcase';
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import { type DB, splitExpressions, trimChar } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import { filterMigrationsSchema } from '../utils';
+import type {
+	CheckConstraint,
+	Enum,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import {
+	defaultForColumn,
+	isSerialExpression,
+	isSystemNamespace,
+	parseOnType,
+	parseViewDefinition,
+	stringFromDatabaseIdentityProperty as parseIdentityProperty,
+	wrapRecord,
+} from './grammar';
+
+// TODO: tables/schema/entities -> filter: (entity: {type: ... , metadata: ... }) => boolean;
+// TODO: since we by default only introspect public
+
+// * convert oid into number in comparisons to prevent issues with different types (string vs number) (pg converts oid to number automatically - pgsql cli returns as string)
+
+export const fromDatabase = async (
+	db: DB,
+	filter: EntityFilter = () => true,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+): Promise<InterimSchema> => {
+	const schemas: Schema[] = [];
+	const enums: Enum[] = [];
+	const tables: PostgresEntities['tables'][] = [];
+	const columns: InterimColumn[] = [];
+	const indexes: InterimIndex[] = [];
+	const pks: PrimaryKey[] = [];
+	const fks: ForeignKey[] = [];
+	const uniques: UniqueConstraint[] = [];
+	const checks: CheckConstraint[] = [];
+	const sequences: Sequence[] = [];
+	const roles: Role[] = [];
+	const policies: Policy[] = [];
+	const privileges: Privilege[] = [];
+	const views: View[] = [];
+	const viewColumns: ViewColumn[] = [];
+
+	// type OP = {
+	// 	oid: number | string;
+	// 	name: string;
+	// 	default: boolean;
+	// };
+
+	type Namespace = {
+		oid: number | string;
+		name: string;
+	};
+
+	// ! Use `pg_catalog` for system tables, functions and operators (Prevent security vulnerabilities - overwriting system tables, functions and operators)
+	// ! Do not use `::regnamespace::text` to get schema name, because it does not work with schemas that have uppercase letters (e.g. MySchema -> "MySchema")
+
+	// TODO: potential improvements
+	// use pg_catalog.has_table_privilege(pg_class.oid, 'SELECT') for tables
+	// --- default access method
+	// SHOW default_table_access_method;
+	// SELECT current_setting('default_table_access_method') AS default_am;
+
+	const accessMethodsQuery = db.query<{ oid: number | string; name: string }>(
+		`SELECT oid, amname as name FROM pg_catalog.pg_am WHERE amtype OPERATOR(pg_catalog.=) 't' ORDER BY pg_catalog.lower(amname);`,
+	).then((rows) => {
+		queryCallback('accessMethods', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('accessMethods', [], err);
+		throw err;
+	});
+
+	const tablespacesQuery = db.query<{
+		oid: number | string;
+		name: string;
+	}>(
+		`SELECT oid, spcname as "name" FROM pg_catalog.pg_tablespace ORDER BY pg_catalog.lower(spcname)`,
+	).then((rows) => {
+		queryCallback('tablespaces', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('tablespaces', [], err);
+		throw err;
+	});
+
+	const namespacesQuery = db.query<Namespace>(
+		`SELECT oid, nspname as name FROM pg_catalog.pg_namespace WHERE pg_catalog.has_schema_privilege(oid, 'USAGE') ORDER BY pg_catalog.lower(nspname)`,
+	)
+		.then((rows) => {
+			queryCallback('namespaces', rows, null);
+			return rows;
+		}).catch((err) => {
+			queryCallback('namespaces', [], err);
+			throw err;
+		});
+
+	const defaultsQuery = db.query<{
+		tableId: number | string;
+		ordinality: number;
+		expression: string;
+	}>(`
+		SELECT
+			adrelid AS "tableId",
+			adnum AS "ordinality",
+			pg_catalog.pg_get_expr(adbin, adrelid) AS "expression"
+		FROM
+			pg_catalog.pg_attrdef;
+	`).then((rows) => {
+		queryCallback('defaults', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('defaults', [], err);
+		throw err;
+	});
+
+	const [ams, tablespaces, namespaces, defaultsList] = await Promise.all([
+		accessMethodsQuery,
+		tablespacesQuery,
+		namespacesQuery,
+		defaultsQuery,
+	]);
+
+	const { other: filteredNamespaces } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
+		(acc, it) => {
+			if (isSystemNamespace(it.name)) {
+				acc.system.push(it);
+			} else {
+				acc.other.push(it);
+			}
+			return acc;
+		},
+		{ system: [], other: [] },
+	);
+
+	const filteredNamespacesStringForSQL = filteredNamespaces.map((ns) => `'${ns.name}'`).join(',');
+
+	schemas.push(...filteredNamespaces.map<Schema>((it) => ({ entityType: 'schemas', name: it.name })));
+
+	// TABLES
+
+	type TableListItem = {
+		oid: number | string;
+		schema: string;
+		name: string;
+		/* r - table, p - partitioned table, v - view, m - materialized view */
+		kind: 'r' | 'p' | 'v' | 'm';
+		accessMethod: number | string;
+		options: string[] | null;
+		rlsEnabled: boolean;
+		tablespaceid: number | string;
+		definition: string | null;
+	};
+	progressCallback('tables', 0, 'fetching');
+	const tablesList = filteredNamespacesStringForSQL
+		? await db
+			.query<TableListItem>(`
+			SELECT
+				pg_class.oid,
+				nspname as "schema",
+				relname AS "name",
+				relkind::text AS "kind",
+				relam as "accessMethod",
+				reloptions::text[] as "options",
+				reltablespace as "tablespaceid",
+				relrowsecurity AS "rlsEnabled",
+				CASE
+					WHEN relkind OPERATOR(pg_catalog.=) 'v' OR relkind OPERATOR(pg_catalog.=) 'm'
+						THEN pg_catalog.pg_get_viewdef(pg_class.oid, true)
+					ELSE null
+				END as "definition"
+			FROM
+				pg_catalog.pg_class
+			JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) relnamespace
+			WHERE
+				relkind IN ('r', 'p', 'v', 'm')
+				AND nspname IN (${filteredNamespacesStringForSQL})
+			ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+		`).then((rows) => {
+				queryCallback('tables', rows, null);
+				return rows;
+			}).catch((err) => {
+				queryCallback('tables', [], err);
+				throw err;
+			})
+		: [] as TableListItem[];
+
+	const viewsList = tablesList.filter((it) => {
+		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+		return it.kind === 'v' || it.kind === 'm';
+	});
+
+	const filteredTables = tablesList.filter((it) => {
+		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+		return it.kind === 'r' || it.kind === 'p';
+	});
+
+	const filteredTableIds = filteredTables.map((it) => it.oid);
+	const viewsIds = viewsList.map((it) => it.oid);
+	const filteredViewsAndTableIds = [...filteredTableIds, ...viewsIds];
+
+	const filterByTableIds = filteredTableIds.length > 0 ? `(${filteredTableIds.join(',')})` : '';
+	const filterByTableAndViewIds = filteredViewsAndTableIds.length > 0 ? `(${filteredViewsAndTableIds.join(',')})` : '';
+
+	for (const table of filteredTables) {
+		tables.push({
+			entityType: 'tables',
+			schema: trimChar(table.schema, "'"),
+			name: table.name,
+			isRlsEnabled: table.rlsEnabled,
+		});
+	}
+	progressCallback('tables', tables.length, 'done');
+
+	const dependQuery = db.query<{
+		oid: number | string;
+		tableId: number | string;
+		ordinality: number | string;
+
+		/*
+			a - An “auto” dependency means the dependent object can be dropped separately,
+					and will be automatically removed if the referenced object is dropped—regardless of CASCADE or RESTRICT.
+					Example: A named constraint on a table is auto-dependent on the table, so it vanishes when the table is dropped
+
+					i - An “internal” dependency marks objects that were created as part of building another object.
+					Directly dropping the dependent is disallowed—you must drop the referenced object instead.
+					Dropping the referenced object always cascades to the dependent
+					Example: A trigger enforcing a foreign-key constraint is internally dependent on its pg_constraint entry
+		 */
+		deptype: 'a' | 'i';
+	}>(
+		`SELECT
+			objid as oid,
+			refobjid as "tableId",
+			refobjsubid as "ordinality",
+			deptype::text
+		FROM
+			pg_catalog.pg_depend
+		WHERE ${filterByTableIds ? ` refobjid IN ${filterByTableIds}` : 'false'};`,
+	).then((rows) => {
+		queryCallback('depend', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('depend', [], err);
+		throw err;
+	});
+
+	type EnumListItem = {
+		oid: number | string;
+		name: string;
+		schema: string;
+		arrayTypeId: number | string;
+		ordinality: number;
+		value: string;
+	};
+	progressCallback('enums', 0, 'fetching');
+	const enumsQuery = filteredNamespacesStringForSQL
+		? db
+			.query<EnumListItem>(`SELECT
+				pg_type.oid as "oid",
+				typname as "name",
+				nspname as "schema",
+				pg_type.typarray as "arrayTypeId",
+				pg_enum.enumsortorder AS "ordinality",
+				pg_enum.enumlabel AS "value"
+			FROM
+				pg_catalog.pg_type
+			JOIN pg_catalog.pg_enum ON pg_enum.enumtypid OPERATOR(pg_catalog.=) pg_type.oid
+			JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_type.typnamespace
+			WHERE
+				pg_type.typtype OPERATOR(pg_catalog.=) 'e'
+				AND nspname IN (${filteredNamespacesStringForSQL})
+			ORDER BY pg_type.oid, pg_enum.enumsortorder
+		`).then((rows) => {
+				queryCallback('enums', rows, null);
+				return rows;
+			}).catch((err) => {
+				queryCallback('enums', [], err);
+				throw err;
+			})
+		: [] as EnumListItem[];
+
+	// fetch for serials, adrelid = tableid
+	const serialsQuery = db
+		.query<{
+			oid: number | string;
+			tableId: number | string;
+			ordinality: number;
+			expression: string;
+		}>(`SELECT
+				oid,
+				adrelid as "tableId",
+				adnum as "ordinality",
+				pg_catalog.pg_get_expr(adbin, adrelid) as "expression"
+			FROM
+				pg_catalog.pg_attrdef
+			WHERE ${filterByTableIds ? ` adrelid IN ${filterByTableIds}` : 'false'}
+		`).then((rows) => {
+			queryCallback('serials', rows, null);
+			return rows;
+		}).catch((err) => {
+			queryCallback('serials', [], err);
+			throw err;
+		});
+
+	type SequenceListItem = {
+		schema: string;
+		oid: number | string;
+		name: string;
+		startWith: string;
+		minValue: string;
+		maxValue: string;
+		incrementBy: string;
+		cycle: boolean;
+		cacheSize: number;
+	};
+	const sequencesQuery = filteredNamespacesStringForSQL
+		? db.query<SequenceListItem>(`SELECT 
+			nspname as "schema",
+			relname as "name",
+			seqrelid as "oid",
+			seqstart as "startWith", 
+			seqmin as "minValue", 
+			seqmax as "maxValue", 
+			seqincrement as "incrementBy", 
+			seqcycle as "cycle", 
+			seqcache as "cacheSize" 
+		FROM pg_catalog.pg_sequence
+		JOIN pg_catalog.pg_class ON pg_sequence.seqrelid OPERATOR(pg_catalog.=) pg_class.oid
+		JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_class.relnamespace
+		WHERE nspname IN (${filteredNamespacesStringForSQL})
+		ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+	`).then((rows) => {
+				queryCallback('sequences', rows, null);
+				return rows;
+			}).catch((err) => {
+				queryCallback('sequences', [], err);
+				throw err;
+			})
+		: [] as SequenceListItem[];
+
+	// I'm not yet aware of how we handle policies down the pipeline for push,
+	// and since postgres does not have any default policies, we can safely fetch all of them for now
+	// and filter them out in runtime, simplifying filterings
+	progressCallback('policies', 0, 'fetching');
+	const policiesQuery = db.query<
+		{
+			schema: string;
+			table: string;
+			name: string;
+			as: Policy['as'];
+			to: string | string[];
+			for: Policy['for'];
+			using: string | undefined | null;
+			withCheck: string | undefined | null;
+		}
+	>(`SELECT 
+			schemaname as "schema", 
+			tablename as "table", 
+			policyname as "name", 
+			permissive as "as", 
+			roles as "to", 
+			cmd as "for", 
+			qual as "using", 
+			with_check as "withCheck" 
+		FROM pg_catalog.pg_policies
+		ORDER BY
+			pg_catalog.lower(schemaname),
+			pg_catalog.lower(tablename),
+			pg_catalog.lower(policyname);
+	`).then((rows) => {
+		queryCallback('policies', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('policies', [], err);
+		throw err;
+	});
+
+	const rolesQuery = db.query<
+		{
+			rolname: string;
+			rolsuper: boolean;
+			rolinherit: boolean;
+			rolcreaterole: boolean;
+			rolcreatedb: boolean;
+			rolcanlogin: boolean;
+			rolreplication: boolean;
+			rolconnlimit: number;
+			rolvaliduntil: string | null;
+			rolbypassrls: boolean;
+		}
+	>(
+		`SELECT
+			rolname,
+			rolsuper,
+			rolinherit,
+			rolcreaterole,
+			rolcreatedb,
+			rolcanlogin,
+			rolreplication,
+			rolconnlimit,
+			rolvaliduntil::text,
+			rolbypassrls
+		FROM pg_catalog.pg_roles
+		ORDER BY pg_catalog.lower(rolname);`,
+	).then((rows) => {
+		queryCallback('roles', rows, null);
+		return rows;
+	}).catch((error) => {
+		queryCallback('roles', [], error);
+		throw error;
+	});
+
+	type PrivilegeListItem = {
+		grantor: string;
+		grantee: string;
+		schema: string;
+		table: string;
+		type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'TRUNCATE' | 'REFERENCES' | 'TRIGGER';
+		isGrantable: boolean;
+	};
+	const privilegesQuery = filteredNamespacesStringForSQL
+		? db.query<PrivilegeListItem>(`
+		SELECT
+			grantor,
+			grantee,
+			table_schema AS "schema",
+			table_name AS "table",
+			privilege_type AS "type",
+			CASE is_grantable WHEN 'YES' THEN true ELSE false END AS "isGrantable"
+		FROM information_schema.role_table_grants
+		WHERE table_schema IN (${filteredNamespacesStringForSQL})
+		ORDER BY
+			pg_catalog.lower(table_schema),
+			pg_catalog.lower(table_name),
+			pg_catalog.lower(grantee);
+	`).then((rows) => {
+				queryCallback('privileges', rows, null);
+				return rows;
+			}).catch((error) => {
+				queryCallback('privileges', [], error);
+				throw error;
+			})
+		: [] as PrivilegeListItem[];
+
+	progressCallback('fks', 0, 'fetching');
+	progressCallback('checks', 0, 'fetching');
+	const constraintsQuery = db.query<{
+		oid: number | string;
+		schemaId: number | string;
+		tableId: number | string;
+		name: string;
+		type: 'p' | 'u' | 'f' | 'c'; // p - primary key, u - unique, f - foreign key, c - check
+		definition: string;
+		indexId: number | string;
+		columnsOrdinals: number[];
+		tableToId: number | string;
+		columnsToOrdinals: number[];
+		onUpdate: 'a' | 'd' | 'r' | 'c' | 'n';
+		onDelete: 'a' | 'd' | 'r' | 'c' | 'n';
+	}>(`
+		SELECT
+			oid,
+			connamespace AS "schemaId",
+			conrelid AS "tableId",
+			conname AS "name",
+			contype::text AS "type", 
+			pg_catalog.pg_get_constraintdef(oid) AS "definition",
+			conindid AS "indexId",
+			conkey AS "columnsOrdinals",
+			confrelid AS "tableToId",
+			confkey AS "columnsToOrdinals",
+			confupdtype::text AS "onUpdate",
+			confdeltype::text AS "onDelete"
+		FROM
+			pg_catalog.pg_constraint
+		WHERE ${filterByTableIds ? ` conrelid IN ${filterByTableIds}` : 'false'}
+		ORDER BY conrelid, contype, pg_catalog.lower(conname);
+  `).then((rows) => {
+		queryCallback('constraints', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('constraints', [], err);
+		throw err;
+	});
+
+	// for serials match with pg_attrdef via attrelid(tableid)+adnum(ordinal position), for enums with pg_enum above
+	progressCallback('columns', 0, 'fetching');
+
+	const columnsQuery = db.query<{
+		tableId: number | string;
+		kind: 'r' | 'p' | 'v' | 'm';
+		name: string;
+		ordinality: number;
+		notNull: boolean;
+		type: string;
+		dimensions: number;
+		typeId: number | string;
+		/* s - stored */
+		generatedType: 's' | '';
+		/*
+		'a' for GENERATED ALWAYS
+		'd' for GENERATED BY DEFAULT
+		*/
+		identityType: 'a' | 'd' | '';
+		seqId: number | string | null;
+	}>(`SELECT
+			attrelid AS "tableId",
+			relkind::text AS "kind",
+			attname AS "name",
+			attnum AS "ordinality",
+			attnotnull AS "notNull",
+			CASE 
+        		WHEN attndims > 0 THEN attndims
+        		WHEN t.typcategory = 'A' THEN 1  -- If it's an array type, default to 1 dimension
+        		ELSE 0
+    		END as "dimensions",
+			atttypid as "typeId",
+			attgenerated::text as "generatedType", 
+			attidentity::text as "identityType",
+			pg_catalog.format_type(atttypid, atttypmod) as "type",
+			pg_catalog.pg_get_serial_sequence('"' OPERATOR(pg_catalog.||) "nspname" OPERATOR(pg_catalog.||) '"."' OPERATOR(pg_catalog.||) "relname" OPERATOR(pg_catalog.||) '"', "attname")::regclass::oid as "seqId"
+		FROM
+			pg_catalog.pg_attribute attr
+			JOIN pg_catalog.pg_class cls ON cls.oid OPERATOR(pg_catalog.=) attr.attrelid
+			JOIN pg_catalog.pg_namespace nsp ON nsp.oid OPERATOR(pg_catalog.=) cls.relnamespace
+			JOIN pg_catalog.pg_type t ON t.oid OPERATOR(pg_catalog.=) attr.atttypid
+		WHERE
+		${filterByTableAndViewIds ? ` attrelid IN ${filterByTableAndViewIds}` : 'false'}
+			AND attnum OPERATOR(pg_catalog.>) 0
+			AND attisdropped OPERATOR(pg_catalog.=) FALSE
+		ORDER BY attnum;
+	`).then((rows) => {
+		queryCallback('columns', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('columns', [], err);
+		throw err;
+	});
+
+	const [
+		dependList,
+		enumsList,
+		serialsList,
+		sequencesList,
+		policiesList,
+		rolesList,
+		privilegesList,
+		constraintsList,
+		columnsList,
+	] = await Promise
+		.all([
+			dependQuery,
+			enumsQuery,
+			serialsQuery,
+			sequencesQuery,
+			policiesQuery,
+			rolesQuery,
+			privilegesQuery,
+			constraintsQuery,
+			columnsQuery,
+		]);
+
+	const groupedEnums = enumsList.reduce((acc, it) => {
+		if (!(it.oid in acc)) {
+			acc[it.oid] = {
+				oid: it.oid,
+				schema: it.schema,
+				name: it.name,
+				values: [it.value],
+			};
+		} else {
+			acc[it.oid].values.push(it.value);
+		}
+		return acc;
+	}, {} as Record<number | string, { oid: number | string; schema: string; name: string; values: string[] }>);
+
+	const groupedArrEnums = enumsList.reduce((acc, it) => {
+		if (!(it.arrayTypeId in acc)) {
+			acc[it.arrayTypeId] = {
+				oid: it.oid,
+				schema: it.schema,
+				name: it.name,
+				values: [it.value],
+			};
+		} else {
+			acc[it.arrayTypeId].values.push(it.value);
+		}
+		return acc;
+	}, {} as Record<number | string, { oid: number | string; schema: string; name: string; values: string[] }>);
+
+	for (const it of Object.values(groupedEnums)) {
+		enums.push({
+			entityType: 'enums',
+			schema: it.schema,
+			name: it.name,
+			values: it.values,
+		});
+	}
+	progressCallback('enums', enums.length, 'done');
+
+	for (const seq of sequencesList) {
+		const depend = dependList.find((it) => Number(it.oid) === Number(seq.oid));
+
+		if (depend && (depend.deptype === 'a' || depend.deptype === 'i')) {
+			// TODO: add type field to sequence in DDL
+			// skip fo sequences or identity columns
+			// console.log('skip for auto created', seq.name, depend.deptype);
+			continue;
+		}
+
+		sequences.push({
+			entityType: 'sequences',
+			schema: seq.schema,
+			name: seq.name,
+			startWith: parseIdentityProperty(seq.startWith),
+			minValue: parseIdentityProperty(seq.minValue),
+			maxValue: parseIdentityProperty(seq.maxValue),
+			incrementBy: parseIdentityProperty(seq.incrementBy),
+			cycle: seq.cycle,
+			cacheSize: Number(parseIdentityProperty(seq.cacheSize) ?? 1),
+		});
+	}
+
+	for (const dbRole of rolesList) {
+		roles.push({
+			entityType: 'roles',
+			name: dbRole.rolname,
+			superuser: dbRole.rolsuper,
+			inherit: dbRole.rolinherit,
+			createRole: dbRole.rolcreaterole,
+			createDb: dbRole.rolcreatedb,
+			canLogin: dbRole.rolcanlogin,
+			replication: dbRole.rolreplication,
+			connLimit: dbRole.rolconnlimit,
+			password: null,
+			validUntil: dbRole.rolvaliduntil,
+			bypassRls: dbRole.rolbypassrls,
+		});
+	}
+
+	for (const privilege of privilegesList) {
+		privileges.push({
+			entityType: 'privileges',
+			// TODO: remove name and implement custom pk
+			name: `${privilege.grantor}_${privilege.grantee}_${privilege.schema}_${privilege.table}_${privilege.type}`,
+			grantor: privilege.grantor,
+			grantee: privilege.grantee,
+			schema: privilege.schema,
+			table: privilege.table,
+			type: privilege.type,
+			isGrantable: privilege.isGrantable,
+		});
+	}
+
+	for (const it of policiesList) {
+		policies.push({
+			entityType: 'policies',
+			schema: it.schema,
+			table: it.table,
+			name: it.name,
+			as: it.as,
+			for: it.for,
+			roles: typeof it.to === 'string' ? it.to.slice(1, -1).split(',') : it.to,
+			using: it.using ?? null,
+			withCheck: it.withCheck ?? null,
+		});
+	}
+	progressCallback('policies', policies.length, 'done');
+
+	type DBColumn = (typeof columnsList)[number];
+
+	// supply serials
+	for (const column of columnsList.filter((x) => x.kind === 'r' || x.kind === 'p')) {
+		const type = column.type;
+
+		if (!(type === 'smallint' || type === 'bigint' || type === 'integer')) {
+			continue;
+		}
+
+		const expr = serialsList.find(
+			(it) => Number(it.tableId) === Number(column.tableId) && it.ordinality === column.ordinality,
+		);
+
+		if (expr) {
+			const table = tablesList.find((it) => Number(it.oid) === Number(column.tableId))!;
+			const isSerial = isSerialExpression(expr.expression, table.schema);
+			column.type = isSerial ? type === 'bigint' ? 'bigserial' : type === 'integer' ? 'serial' : 'smallserial' : type;
+		}
+	}
+
+	for (const column of columnsList.filter((x) => x.kind === 'r' || x.kind === 'p')) {
+		const table = tablesList.find((it) => Number(it.oid) === Number(column.tableId))!;
+
+		// supply enums
+		const enumType = column.typeId in groupedEnums
+			? groupedEnums[column.typeId]
+			: column.typeId in groupedArrEnums
+			? groupedArrEnums[column.typeId]
+			: null;
+
+		let columnTypeMapped = enumType ? enumType.name : column.type.replaceAll('[]', '');
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace(' with time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char')
+			.replace('geometry(Point', 'geometry(point');
+
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+
+		const columnDefault = defaultsList.find(
+			(it) => Number(it.tableId) === Number(column.tableId) && it.ordinality === column.ordinality,
+		);
+
+		const defaultValue = defaultForColumn(
+			columnTypeMapped,
+			columnDefault?.expression,
+			column.dimensions,
+			Boolean(enumType),
+		);
+
+		const unique = constraintsList.find((it) => {
+			return it.type === 'u' && Number(it.tableId) === Number(column.tableId) && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const pk = constraintsList.find((it) => {
+			return it.type === 'p' && Number(it.tableId) === Number(column.tableId) && it.columnsOrdinals.length === 1
+				&& it.columnsOrdinals.includes(column.ordinality);
+		}) ?? null;
+
+		const sequence = column.seqId
+			? sequencesList.find((it) => Number(it.oid) === Number(column.seqId))
+			: null;
+
+		columns.push({
+			entityType: 'columns',
+			schema: table.schema,
+			table: table.name,
+			name: column.name,
+			type: columnTypeMapped,
+			typeSchema: enumType ? enumType.schema ?? 'public' : null,
+			dimensions: column.dimensions,
+			default: column.generatedType === 's' ? null : defaultValue,
+			unique: !!unique,
+			uniqueName: unique ? unique.name : null,
+			uniqueNullsNotDistinct: unique?.definition.includes('NULLS NOT DISTINCT') ?? false,
+			notNull: column.notNull,
+			pk: pk !== null,
+			pkName: pk !== null ? pk.name : null,
+			generated: column.generatedType === 's' && columnDefault?.expression
+				? { type: 'stored', as: columnDefault.expression }
+				: null,
+			identity: column.identityType !== '' && sequence
+				? {
+					type: column.identityType === 'a' ? 'always' : 'byDefault',
+					name: sequence.name,
+					increment: parseIdentityProperty(sequence.incrementBy),
+					minValue: parseIdentityProperty(sequence.minValue),
+					maxValue: parseIdentityProperty(sequence.maxValue),
+					startWith: parseIdentityProperty(sequence.startWith),
+					cycle: sequence.cycle,
+					cache: Number(parseIdentityProperty(sequence.cacheSize)),
+				}
+				: null,
+		});
+	}
+	progressCallback('columns', columns.length, 'done');
+
+	for (const unique of constraintsList.filter((it) => it.type === 'u')) {
+		const table = tablesList.find((it) => Number(it.oid) === Number(unique.tableId))!;
+		const schema = namespaces.find((it) => Number(it.oid) === Number(unique.schemaId))!;
+
+		const columns = unique.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) =>
+				Number(column.tableId) === Number(unique.tableId) && column.ordinality === it
+			)!;
+			return column.name;
+		});
+
+		uniques.push({
+			entityType: 'uniques',
+			schema: schema.name,
+			table: table.name,
+			name: unique.name,
+			nameExplicit: true,
+			columns,
+			nullsNotDistinct: unique.definition.includes('NULLS NOT DISTINCT'),
+		});
+	}
+
+	for (const pk of constraintsList.filter((it) => it.type === 'p')) {
+		const table = tablesList.find((it) => Number(it.oid) === Number(pk.tableId))!;
+		const schema = namespaces.find((it) => Number(it.oid) === Number(pk.schemaId))!;
+
+		const columns = pk.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) =>
+				Number(column.tableId) === Number(pk.tableId) && column.ordinality === it
+			)!;
+			return column.name;
+		});
+
+		pks.push({
+			entityType: 'pks',
+			schema: schema.name,
+			table: table.name,
+			name: pk.name,
+			columns,
+			nameExplicit: true,
+		});
+	}
+
+	for (const fk of constraintsList.filter((it) => it.type === 'f')) {
+		const table = tablesList.find((it) => Number(it.oid) === Number(fk.tableId))!;
+		const schema = namespaces.find((it) => Number(it.oid) === Number(fk.schemaId))!;
+		const tableTo = tablesList.find((it) => Number(it.oid) === Number(fk.tableToId))!;
+
+		const columns = fk.columnsOrdinals.map((it) => {
+			const column = columnsList.find((column) =>
+				Number(column.tableId) === Number(fk.tableId) && column.ordinality === it
+			)!;
+			return column.name;
+		});
+
+		const columnsTo = fk.columnsToOrdinals.map((it) => {
+			const column = columnsList.find((column) =>
+				Number(column.tableId) === Number(fk.tableToId) && column.ordinality === it
+			)!;
+			return column.name;
+		});
+
+		fks.push({
+			entityType: 'fks',
+			schema: schema.name,
+			table: table.name,
+			name: fk.name,
+			nameExplicit: true,
+			columns,
+			tableTo: tableTo.name,
+			schemaTo: tableTo.schema,
+			columnsTo,
+			onUpdate: parseOnType(fk.onUpdate),
+			onDelete: parseOnType(fk.onDelete),
+		});
+	}
+	progressCallback('fks', fks.length, 'done');
+
+	for (const check of constraintsList.filter((it) => it.type === 'c')) {
+		const table = tablesList.find((it) => Number(it.oid) === Number(check.tableId))!;
+		const schema = namespaces.find((it) => Number(it.oid) === Number(check.schemaId))!;
+
+		checks.push({
+			entityType: 'checks',
+			schema: schema.name,
+			table: table.name,
+			name: check.name,
+			value: check.definition.startsWith('CHECK (') ? check.definition.slice(7, -1) : check.definition,
+		});
+	}
+	progressCallback('checks', checks.length, 'done');
+
+	type IndexMetadata = {
+		tableId: number;
+		expression: string | null;
+		where: string;
+		columnOrdinals: number[];
+		opclasses: { oid: number | string; access_method_name: string; op_class_name: string; default: boolean }[];
+		options: number[];
+		isUnique: boolean;
+		isPrimary: boolean;
+	};
+
+	const idxs = await db.query<{
+		oid: number | string;
+		schema: string;
+		name: string;
+		accessMethod: string;
+		with?: string[];
+		// string - aws-data-api
+		// object - regular pg
+		metadata: IndexMetadata | string;
+	}>(`
+      SELECT
+        pg_class.oid,
+        nspname as "schema",
+        relname AS "name",
+        am.amname AS "accessMethod",
+        reloptions AS "with",
+        pg_catalog.row_to_json(metadata.*) as "metadata"
+      FROM
+        pg_catalog.pg_class
+      JOIN pg_catalog.pg_am am ON am.oid OPERATOR(pg_catalog.=) pg_class.relam
+	  JOIN pg_catalog.pg_namespace nsp ON nsp.oid OPERATOR(pg_catalog.=) pg_class.relnamespace
+      JOIN LATERAL (
+        SELECT
+          pg_catalog.pg_get_expr(indexprs, indrelid) AS "expression",
+          pg_catalog.pg_get_expr(indpred, indrelid) AS "where",
+          indrelid::int AS "tableId",
+          indkey::int[] as "columnOrdinals",
+          indoption::int[] as "options",
+          indisunique as "isUnique",
+          indisprimary as "isPrimary",
+		  array(
+			SELECT
+			  pg_catalog.json_build_object(
+				'oid', opclass.oid,
+				'access_method_name', pg_am.amname,
+				'op_class_name', pg_opclass.opcname,
+				'default', pg_opclass.opcdefault
+			  )
+			FROM
+			  pg_catalog.unnest(indclass) WITH ORDINALITY AS opclass(oid, ordinality)
+			JOIN pg_catalog.pg_opclass ON opclass.oid OPERATOR(pg_catalog.=) pg_opclass.oid
+			JOIN pg_catalog.pg_am ON pg_opclass.opcmethod OPERATOR(pg_catalog.=) pg_am.oid
+			ORDER BY opclass.ordinality
+		  ) as "opclasses"
+        FROM
+          pg_catalog.pg_index
+        WHERE
+          pg_index.indexrelid OPERATOR(pg_catalog.=) pg_class.oid
+      ) metadata ON TRUE
+      WHERE
+        relkind OPERATOR(pg_catalog.=) 'i'
+		AND ${filterByTableIds ? `metadata."tableId" IN ${filterByTableIds}` : 'false'}
+	  ORDER BY pg_catalog.lower(nspname), pg_catalog.lower(relname);
+    `).then((rows) => {
+		queryCallback('indexes', rows, null);
+		return rows;
+	}).catch((err) => {
+		queryCallback('indexes', [], err);
+		throw err;
+	});
+
+	for (const idx of idxs) {
+		const metadata: IndexMetadata = typeof idx.metadata === 'string' ? JSON.parse(idx.metadata) : idx.metadata;
+
+		// filter for drizzle only?
+		const forUnique = metadata.isUnique
+			&& constraintsList.some((x) => x.type === 'u' && Number(x.indexId) === Number(idx.oid));
+		const forPK = metadata.isPrimary
+			&& constraintsList.some((x) => x.type === 'p' && Number(x.indexId) === Number(idx.oid));
+
+		const expr = splitExpressions(metadata.expression);
+
+		const table = tablesList.find((it) => Number(it.oid) === Number(metadata.tableId))!;
+		const nonColumnsCount = metadata.columnOrdinals.reduce((acc, it) => {
+			if (it === 0) acc += 1;
+			return acc;
+		}, 0);
+
+		if (expr.length !== nonColumnsCount) {
+			throw new Error(
+				`expression split doesn't match non-columns count: [${
+					metadata.columnOrdinals.join(
+						', ',
+					)
+				}] '${metadata.expression}':${expr.length}:${nonColumnsCount}`,
+			);
+		}
+
+		const opts = metadata.options.map((it) => {
+			return {
+				descending: (it & 1) === 1,
+				nullsFirst: (it & 2) === 2,
+			};
+		});
+
+		const res = [] as (
+			& (
+				| { type: 'expression'; value: string }
+				| { type: 'column'; value: DBColumn }
+			)
+			& { options: (typeof opts)[number]; opclass: { op_class_name: string; default: boolean } }
+		)[];
+
+		let k = 0;
+		for (let i = 0; i < metadata.columnOrdinals.length; i++) {
+			const ordinal = metadata.columnOrdinals[i];
+			if (ordinal === 0) {
+				res.push({
+					type: 'expression',
+					value: expr[k],
+					options: opts[i],
+					opclass: metadata.opclasses[i],
+				});
+				k += 1;
+			} else {
+				const column = columnsList.find((column) => {
+					return Number(column.tableId) === Number(metadata.tableId) && column.ordinality === ordinal;
+				});
+				if (!column) throw new Error(`missing column: ${metadata.tableId}:${ordinal}`);
+
+				// ! options and opclass can be undefined when index have "INCLUDE" columns (columns from "INCLUDE" don't have options and opclass)
+				const options = opts[i] as typeof opts[number] | undefined;
+				const opclass = metadata.opclasses[i] as { op_class_name: string; default: boolean } | undefined;
+				if (options && opclass) {
+					res.push({
+						type: 'column',
+						value: column,
+						options: opts[i],
+						opclass: metadata.opclasses[i],
+					});
+				}
+			}
+		}
+
+		const columns = res.map((it) => {
+			return {
+				asc: !it.options.descending,
+				nullsFirst: it.options.nullsFirst,
+				opclass: it.opclass.default ? null : {
+					name: it.opclass.op_class_name,
+					default: it.opclass.default,
+				},
+				isExpression: it.type === 'expression',
+				value: it.type === 'expression' ? it.value : it.value.name, // column name
+			} satisfies Index['columns'][number];
+		});
+
+		indexes.push({
+			entityType: 'indexes',
+			schema: idx.schema,
+			table: table.name,
+			name: idx.name,
+			nameExplicit: true,
+			method: idx.accessMethod,
+			isUnique: metadata.isUnique,
+			with: idx.with?.join(', ') ?? '',
+			where: metadata.where,
+			columns: columns,
+			concurrently: false,
+			forUnique,
+			forPK,
+		});
+	}
+	progressCallback('indexes', indexes.length, 'done');
+
+	for (const it of columnsList.filter((x) => x.kind === 'm' || x.kind === 'v')) {
+		const view = viewsList.find((x) => Number(x.oid) === Number(it.tableId))!;
+
+		const typeDimensions = it.type.split('[]').length - 1;
+		const enumType = it.typeId in groupedEnums
+			? groupedEnums[it.typeId]
+			: it.typeId in groupedArrEnums
+			? groupedArrEnums[it.typeId]
+			: null;
+
+		let columnTypeMapped = enumType ? enumType.name : it.type.replace('[]', '');
+		columnTypeMapped = trimChar(columnTypeMapped, '"');
+		if (columnTypeMapped.startsWith('numeric(')) {
+			columnTypeMapped = columnTypeMapped.replace(',', ', ');
+		}
+
+		columnTypeMapped = columnTypeMapped
+			.replace('character varying', 'varchar')
+			.replace(' without time zone', '')
+			// .replace("timestamp without time zone", "timestamp")
+			.replace('character', 'char')
+			.replace('geometry(Point)', 'geometry(point)');
+
+		columnTypeMapped += '[]'.repeat(it.dimensions);
+
+		viewColumns.push({
+			schema: view.schema,
+			view: view.name,
+			name: it.name,
+			type: columnTypeMapped,
+			typeDimensions,
+			notNull: it.notNull,
+			dimensions: it.dimensions,
+			typeSchema: enumType ? enumType.schema : null,
+		});
+	}
+
+	for (const view of viewsList) {
+		const accessMethod = Number(view.accessMethod) === 0
+			? null
+			: ams.find((it) => Number(it.oid) === Number(view.accessMethod));
+		const tablespace = Number(view.tablespaceid) === 0
+			? null
+			: tablespaces.find((it) => Number(it.oid) === Number(view.tablespaceid))!.name;
+
+		const definition = parseViewDefinition(view.definition);
+		const withOpts = wrapRecord(
+			view.options?.reduce((acc, it) => {
+				const opt = it.split('=');
+				if (opt.length !== 2) {
+					throw new Error(`Unexpected view option: ${it}`);
+				}
+
+				const key = camelcase(opt[0].trim());
+				const value = opt[1].trim();
+				acc[key] = value;
+				return acc;
+			}, {} as Record<string, string>) ?? {},
+		);
+
+		const opts = {
+			checkOption: withOpts.literal('checkOption', ['local', 'cascaded']),
+			securityBarrier: withOpts.bool('securityBarrier'),
+			securityInvoker: withOpts.bool('securityInvoker'),
+			fillfactor: withOpts.num('fillfactor'),
+			toastTupleTarget: withOpts.num('toastTupleTarget'),
+			parallelWorkers: withOpts.num('parallelWorkers'),
+			autovacuumEnabled: withOpts.bool('autovacuumEnabled'),
+			vacuumIndexCleanup: withOpts.literal('vacuumIndexCleanup', ['auto', 'on', 'off']),
+			vacuumTruncate: withOpts.bool('vacuumTruncate'),
+			autovacuumVacuumThreshold: withOpts.num('autovacuumVacuumThreshold'),
+			autovacuumVacuumScaleFactor: withOpts.num('autovacuumVacuumScaleFactor'),
+			autovacuumVacuumCostDelay: withOpts.num('autovacuumVacuumCostDelay'),
+			autovacuumVacuumCostLimit: withOpts.num('autovacuumVacuumCostLimit'),
+			autovacuumFreezeMinAge: withOpts.num('autovacuumFreezeMinAge'),
+			autovacuumFreezeMaxAge: withOpts.num('autovacuumFreezeMaxAge'),
+			autovacuumFreezeTableAge: withOpts.num('autovacuumFreezeTableAge'),
+			autovacuumMultixactFreezeMinAge: withOpts.num('autovacuumMultixactFreezeMinAge'),
+			autovacuumMultixactFreezeMaxAge: withOpts.num('autovacuumMultixactFreezeMaxAge'),
+			autovacuumMultixactFreezeTableAge: withOpts.num('autovacuumMultixactFreezeTableAge'),
+			logAutovacuumMinDuration: withOpts.num('logAutovacuumMinDuration'),
+			userCatalogTable: withOpts.bool('userCatalogTable'),
+		};
+
+		const hasNonNullOpt = Object.values(opts).some((x) => x !== null);
+		views.push({
+			entityType: 'views',
+			schema: view.schema,
+			name: view.name,
+			definition,
+			with: hasNonNullOpt ? opts : null,
+			materialized: view.kind === 'm',
+			tablespace,
+			using: accessMethod?.name ?? null,
+			withNoData: null,
+		});
+	}
+	progressCallback('views', views.length, 'done');
+
+	const resultSchemas = schemas.filter((x) => filter({ type: 'schema', name: x.name }));
+	const resultTables = tables.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultEnums = enums.filter((x) => resultSchemas.some((s) => s.name === x.schema));
+	const resultColumns = columns.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultIndexes = indexes.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultPKs = pks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultFKs = fks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultUniques = uniques.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultChecks = checks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultSequences = sequences.filter((x) => resultSchemas.some((t) => t.name === x.schema));
+	// TODO: drizzle link
+	const resultRoles = roles.filter((x) => filter({ type: 'role', name: x.name }));
+	const resultViews = views.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultPolicies = policies.filter((p) => resultTables.some((t) => t.schema === p.schema && t.name === p.table));
+	const resultViewColumns = viewColumns.filter((x) =>
+		resultViews.some((v) => v.schema === x.schema && v.name === x.view)
+	);
+
+	return {
+		schemas: resultSchemas,
+		tables: resultTables,
+		enums: resultEnums,
+		columns: resultColumns,
+		indexes: resultIndexes,
+		pks: resultPKs,
+		fks: resultFKs,
+		uniques: resultUniques,
+		checks: resultChecks,
+		sequences: resultSequences,
+		roles: resultRoles,
+		privileges,
+		policies: resultPolicies,
+		views: resultViews,
+		viewColumns: resultViewColumns,
+	} satisfies InterimSchema;
+};
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	migrations: {
+		schema: string;
+		table: string;
+	},
+) => {
+	const res = await fromDatabase(db, filter, progressCallback);
+	res.schemas = res.schemas.filter((it) => it.name !== 'public');
+	res.indexes = res.indexes.filter((it) => !it.forPK && !it.forUnique);
+	res.privileges = [];
+
+	filterMigrationsSchema(res, migrations);
+
+	return res;
+};
diff --git a/drizzle-kit/src/dialects/postgres/serializer.ts b/drizzle-kit/src/dialects/postgres/serializer.ts
new file mode 100644
index 0000000000..2926dee705
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/serializer.ts
@@ -0,0 +1,723 @@
+import type { CheckHandlerResult } from '../../cli/commands/check';
+import { humanLog, postgresSchemaError, postgresSchemaWarning } from '../../cli/views';
+import { assertUnreachable } from '../../utils';
+import type { PostgresDDL } from './ddl';
+import { createDDL, fromEntities, interimToDDL } from './ddl';
+import { fromDrizzleSchema } from './drizzle';
+import type { PreparedPostgresSchema } from './drizzle';
+import type { PostgresSnapshot } from './snapshot';
+import { drySnapshot, snapshotValidator } from './snapshot';
+import type { JsonStatement } from './statements';
+
+export const prepareSnapshot = async (
+	snapshots: string[],
+	prepared: PreparedPostgresSchema,
+	checkResult?: CheckHandlerResult,
+): Promise<{
+	ddlPrev: PostgresDDL;
+	ddlCur: PostgresDDL;
+	snapshot: PostgresSnapshot;
+	snapshotPrev: PostgresSnapshot;
+	custom: PostgresSnapshot;
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const latestSnapshot = snapshots.length === 0
+		? drySnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const branchParentSnapshot = checkResult?.parentSnapshot
+		? snapshotValidator.strict(
+			checkResult.parentSnapshot as Record<string, unknown>,
+		)
+		: null;
+	const branchStatements = (checkResult?.statements ?? []) as JsonStatement[];
+	const useBranchParent = branchParentSnapshot !== null && branchStatements.length > 0;
+	const mergeLeafIds = (checkResult?.leafIds?.length ?? 0) > 1 ? checkResult?.leafIds : undefined;
+
+	const prevSnapshot = useBranchParent
+		? generateLatestSnapshot(branchParentSnapshot, branchStatements)
+		: latestSnapshot;
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+	const res = prepared;
+
+	// TODO: do we wan't to export everything or ignore .existing and respect entity filters in config
+	const { schema, errors, warnings } = fromDrizzleSchema(
+		res,
+		() => true,
+	);
+
+	if (warnings.length > 0) {
+		humanLog(warnings.map((it) => postgresSchemaWarning(it)).join('\n\n'));
+	}
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => postgresSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const { ddl: ddlCur, errors: errors2 } = interimToDDL(schema);
+
+	if (errors2.length > 0) {
+		humanLog(errors2.map((it) => postgresSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	const id = randomUUID();
+	const prevIds = mergeLeafIds ?? [prevSnapshot.id];
+
+	const snapshot = {
+		version: '8',
+		dialect: 'postgres',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies PostgresSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	// that's for custom migrations, when we need new IDs, but old snapshot
+	const custom: PostgresSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return { ddlPrev, ddlCur, snapshot, snapshotPrev: prevSnapshot, custom };
+};
+
+// takes parent snapshot and statements
+// applies statements to the snapshot and returns new snapshot
+export function generateLatestSnapshot(
+	snapshot: PostgresSnapshot,
+	statements: JsonStatement[],
+): PostgresSnapshot {
+	const ddl = fromEntities(snapshot.ddl);
+
+	/**
+	 * Ex.:
+	 * statement: {
+		type: 'add_column',
+		column: {
+			'$diffType': 'create',
+			entityType: 'columns',
+			...
+		},
+		isPK: false,
+		isCompositePK: false
+	}
+	 */
+	const clearMetaFields = <T>(value: T): T => {
+		if (!value || typeof value !== 'object') {
+			return value;
+		}
+
+		return Object.fromEntries(
+			Object.entries(value as Record<string, unknown>).filter(
+				([key]) => !key.startsWith('$'),
+			),
+		) as T;
+	};
+
+	const push = (entity: { push: (row: unknown) => unknown }, row: unknown) => {
+		entity.push(clearMetaFields(row));
+	};
+	const del = (
+		entity: { delete: (where?: unknown) => unknown },
+		where: unknown,
+	) => {
+		entity.delete(clearMetaFields(where));
+	};
+	const replace = (
+		entity: {
+			delete: (where?: unknown) => unknown;
+			push: (row: unknown) => unknown;
+		},
+		left: unknown,
+		right: unknown,
+	) => {
+		del(entity, left);
+		push(entity, right);
+	};
+
+	for (const statement of statements) {
+		switch (statement.type) {
+			case 'create_table':
+				const table = statement.table;
+
+				ddl.tables.push({
+					name: table.name,
+					schema: table.schema,
+					isRlsEnabled: table.isRlsEnabled,
+				});
+				for (const column of table.columns) {
+					ddl.columns.push(column);
+				}
+				for (const index of table.indexes) {
+					ddl.indexes.push(index);
+				}
+				if (table.pk) {
+					ddl.pks.push(table.pk);
+				}
+				for (const fk of table.fks) {
+					ddl.fks.push(fk);
+				}
+				for (const unique of table.uniques) {
+					ddl.uniques.push(unique);
+				}
+				for (const check of table.checks) {
+					ddl.checks.push(check);
+				}
+				for (const policy of table.policies) {
+					ddl.policies.push(policy);
+				}
+
+				break;
+			case 'drop_table': {
+				const table = statement.table;
+
+				const where = { schema: table.schema, table: table.name } as const;
+				ddl.tables.delete({ schema: table.schema, name: table.name });
+				ddl.columns.delete(where);
+				ddl.indexes.delete(where);
+				ddl.pks.delete(where);
+				ddl.fks.delete(where);
+				ddl.uniques.delete(where);
+				ddl.checks.delete(where);
+				ddl.policies.delete(where);
+				ddl.privileges.delete(where);
+				break;
+			}
+			case 'rename_table':
+				/**
+				 * prepareStatement('rename_table', {
+							schema: it.from.schema,
+							from: it.from.name,
+							to: it.to.name,
+						})
+				 */
+				ddl.tables.update({
+					set: {
+						name: statement.to,
+					},
+					where: {
+						name: statement.from,
+						schema: statement.schema,
+					},
+				});
+
+				ddl.fks.update({
+					where: { schema: statement.schema, table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.fks.update({
+					where: { schemaTo: statement.schema, tableTo: statement.from },
+					set: { tableTo: statement.to },
+				});
+
+				ddl.entities.update({
+					where: { schema: statement.schema, table: statement.from },
+					set: { table: statement.to },
+				});
+
+				break;
+			case 'move_table':
+				// rename of table comes first
+				/**
+				 * prepareStatement('move_table', {
+							name: it.to.name, // rename of table comes first
+							from: it.from.schema,
+							to: it.to.schema,
+						})
+				 */
+				ddl.tables.update({
+					set: {
+						schema: statement.to,
+					},
+					where: {
+						schema: statement.from,
+						name: statement.name,
+					},
+				});
+
+				ddl.fks.update({
+					where: { schema: statement.from, table: statement.name },
+					set: { table: statement.to },
+				});
+				ddl.fks.update({
+					where: { schemaTo: statement.from, tableTo: statement.name },
+					set: { tableTo: statement.to },
+				});
+
+				ddl.entities.update({
+					where: { schema: statement.from, table: statement.name },
+					set: { table: statement.to },
+				});
+
+				break;
+			case 'add_column':
+				push(ddl.columns, statement.column);
+				break;
+			case 'drop_column':
+				del(ddl.columns, statement.column);
+				break;
+			case 'rename_column':
+				ddl.columns.update({
+					where: {
+						schema: statement.from.schema,
+						table: statement.from.table,
+						name: statement.from.name,
+					},
+					set: { name: statement.to.name },
+				});
+				ddl.indexes.update({
+					where: { schema: statement.from.schema, table: statement.from.table },
+					set: {
+						columns: (column) => {
+							if (
+								!column.isExpression
+								&& column.value === statement.from.name
+							) {
+								return { ...column, value: statement.to.name };
+							}
+							return column;
+						},
+					},
+				});
+				ddl.pks.update({
+					where: { schema: statement.from.schema, table: statement.from.table },
+					set: {
+						columns: (column) => column === statement.from.name ? statement.to.name : column,
+					},
+				});
+				ddl.fks.update({
+					where: { schema: statement.from.schema, table: statement.from.table },
+					set: {
+						columns: (column) => column === statement.from.name ? statement.to.name : column,
+						columnsTo: (column) => column === statement.from.name ? statement.to.name : column,
+					},
+				});
+				ddl.uniques.update({
+					where: { schema: statement.from.schema, table: statement.from.table },
+					set: {
+						columns: (column) => column === statement.from.name ? statement.to.name : column,
+					},
+				});
+				break;
+			case 'alter_column':
+				replace(ddl.columns, statement.diff.$left, statement.to);
+				break;
+			case 'recreate_column':
+				replace(ddl.columns, statement.diff.$left, statement.diff.$right);
+				break;
+
+			case 'create_index':
+				push(ddl.indexes, statement.index);
+				break;
+			case 'drop_index':
+				del(ddl.indexes, statement.index);
+				break;
+			case 'rename_index':
+				ddl.indexes.update({
+					where: { schema: statement.schema, name: statement.from },
+					set: { name: statement.to },
+				});
+				break;
+			case 'recreate_index':
+				replace(ddl.indexes, statement.diff.$left, statement.index);
+				break;
+
+			case 'add_pk':
+				push(ddl.pks, statement.pk);
+				for (const columnName of statement.pk.columns) {
+					ddl.columns.update({
+						where: {
+							name: columnName,
+						},
+						set: { notNull: true },
+					});
+				}
+
+				break;
+			case 'drop_pk':
+				del(ddl.pks, statement.pk);
+				break;
+			case 'alter_pk':
+				ddl.pks.delete(statement.diff.$left);
+				if (!statement.deleted) {
+					ddl.pks.push(statement.pk);
+				}
+				break;
+
+			case 'create_fk':
+				push(ddl.fks, statement.fk);
+				break;
+			case 'drop_fk':
+				del(ddl.fks, statement.fk);
+				break;
+			case 'recreate_fk':
+				replace(ddl.fks, statement.diff.$left, statement.fk);
+				break;
+
+			case 'add_unique':
+				push(ddl.uniques, statement.unique);
+				break;
+			case 'drop_unique':
+				del(ddl.uniques, statement.unique);
+				break;
+			case 'alter_unique':
+				replace(ddl.uniques, statement.diff.$left, statement.diff.$right);
+				break;
+
+			case 'add_check':
+				push(ddl.checks, statement.check);
+				break;
+			case 'drop_check':
+				del(ddl.checks, statement.check);
+				break;
+			case 'alter_check':
+				replace(ddl.checks, statement.diff.$left, statement.diff.$right);
+				break;
+
+			case 'rename_constraint':
+				ddl.pks.update({
+					where: {
+						schema: statement.schema,
+						table: statement.table,
+						name: statement.from,
+					},
+					set: { name: statement.to },
+				});
+				ddl.fks.update({
+					where: {
+						schema: statement.schema,
+						table: statement.table,
+						name: statement.from,
+					},
+					set: { name: statement.to },
+				});
+				ddl.uniques.update({
+					where: {
+						schema: statement.schema,
+						table: statement.table,
+						name: statement.from,
+					},
+					set: { name: statement.to },
+				});
+				ddl.checks.update({
+					where: {
+						schema: statement.schema,
+						table: statement.table,
+						name: statement.from,
+					},
+					set: { name: statement.to },
+				});
+				break;
+
+			case 'create_schema':
+				ddl.schemas.push({ name: statement.name });
+				break;
+			case 'drop_schema':
+				ddl.schemas.delete({ name: statement.name });
+				ddl.tables.delete({ schema: statement.name });
+				ddl.enums.delete({ schema: statement.name });
+				ddl.columns.delete({ schema: statement.name });
+				ddl.indexes.delete({ schema: statement.name });
+				ddl.fks.delete({ schema: statement.name });
+				ddl.pks.delete({ schema: statement.name });
+				ddl.uniques.delete({ schema: statement.name });
+				ddl.checks.delete({ schema: statement.name });
+				ddl.sequences.delete({ schema: statement.name });
+				ddl.policies.delete({ schema: statement.name });
+				ddl.privileges.delete({ schema: statement.name });
+				ddl.views.delete({ schema: statement.name });
+				break;
+			case 'rename_schema':
+				ddl.schemas.update({
+					where: { name: statement.from.name },
+					set: { name: statement.to.name },
+				});
+				ddl.tables.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.enums.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.columns.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.indexes.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.fks.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.fks.update({
+					where: { schemaTo: statement.from.name },
+					set: { schemaTo: statement.to.name },
+				});
+				ddl.pks.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.uniques.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.checks.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.sequences.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.policies.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.privileges.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				ddl.views.update({
+					where: { schema: statement.from.name },
+					set: { schema: statement.to.name },
+				});
+				break;
+
+			case 'create_enum':
+				push(ddl.enums, statement.enum);
+				break;
+			case 'drop_enum':
+				del(ddl.enums, statement.enum);
+				break;
+			case 'rename_enum':
+				ddl.enums.update({
+					where: { schema: statement.schema, name: statement.from },
+					set: { name: statement.to },
+				});
+				ddl.columns.update({
+					where: {
+						schema: statement.schema,
+						type: statement.from,
+						typeSchema: statement.schema,
+					},
+					set: { type: statement.to },
+				});
+				break;
+			case 'move_enum':
+				ddl.enums.update({
+					where: {
+						schema: statement.from.schema ?? 'public',
+						name: statement.from.name,
+					},
+					set: {
+						schema: statement.to.schema ?? 'public',
+						name: statement.to.name,
+					},
+				});
+				ddl.columns.update({
+					where: {
+						typeSchema: statement.from.schema ?? 'public',
+						name: statement.from.name,
+					},
+					set: {
+						typeSchema: statement.to.schema ?? 'public',
+					},
+				});
+				break;
+			case 'alter_enum': {
+				// When merging commutative branches, multiple alter_enum statements
+				// for the same enum may be applied sequentially. Each statement's
+				// `from`/`to` reflects the diff from the common parent, so the 2nd
+				// statement's `to` wouldn't include values added by the 1st branch.
+				// Instead of replacing the whole enum, we apply the diff incrementally:
+				// find the current enum by identity (name + schema) and merge in the
+				// added values from this statement's diff.
+				const identity = {
+					name: statement.from.name,
+					schema: statement.from.schema,
+				};
+				const existing = ddl.enums.one(identity);
+				if (!existing) {
+					push(ddl.enums, statement.to);
+					break;
+				}
+
+				const values = [...existing.values];
+				for (const d of statement.diff) {
+					if (d.type !== 'added' || values.includes(d.value)) continue;
+
+					const insertAt = d.beforeValue !== undefined ? values.indexOf(d.beforeValue) : -1;
+					if (insertAt !== -1) {
+						values.splice(insertAt, 0, d.value);
+					} else {
+						values.push(d.value);
+					}
+				}
+				ddl.enums.update({ where: identity, set: { values } });
+				break;
+			}
+			case 'recreate_enum':
+				// recreate_enum is used when values are removed, which requires a full
+				// replacement. Delete by identity to handle the case where a prior
+				// commutative branch may have already modified the enum values.
+				ddl.enums.delete({
+					name: statement.from.name,
+					schema: statement.from.schema,
+				});
+				push(ddl.enums, statement.to);
+				break;
+			case 'alter_type_drop_value':
+				ddl.enums.update({
+					where: { schema: statement.enum.schema, name: statement.enum.name },
+					set: { values: statement.enum.values },
+				});
+				break;
+
+			case 'create_sequence':
+				push(ddl.sequences, statement.sequence);
+				break;
+			case 'drop_sequence':
+				del(ddl.sequences, statement.sequence);
+				break;
+			case 'rename_sequence':
+				ddl.sequences.update({
+					where: { schema: statement.from.schema, name: statement.from.name },
+					set: { name: statement.to.name },
+				});
+				break;
+			case 'move_sequence':
+				ddl.sequences.update({
+					where: {
+						schema: statement.from.schema ?? 'public',
+						name: statement.from.name,
+					},
+					set: {
+						schema: statement.to.schema ?? 'public',
+						name: statement.to.name,
+					},
+				});
+				break;
+			case 'alter_sequence':
+				replace(ddl.sequences, statement.diff.$left, statement.sequence);
+				break;
+
+			case 'create_policy':
+				push(ddl.policies, statement.policy);
+				break;
+			case 'drop_policy':
+				del(ddl.policies, statement.policy);
+				break;
+			case 'rename_policy':
+				ddl.policies.update({
+					where: {
+						schema: statement.from.schema,
+						table: statement.from.table,
+						name: statement.from.name,
+					},
+					set: { name: statement.to.name },
+				});
+				break;
+			case 'alter_policy':
+				replace(ddl.policies, statement.diff.$left, statement.policy);
+				break;
+			case 'recreate_policy':
+				replace(ddl.policies, statement.diff.$left, statement.policy);
+				break;
+			case 'alter_rls':
+				ddl.tables.update({
+					where: { schema: statement.schema, name: statement.name },
+					set: { isRlsEnabled: statement.isRlsEnabled },
+				});
+				break;
+
+			case 'create_role':
+				push(ddl.roles, statement.role);
+				break;
+			case 'drop_role':
+				del(ddl.roles, statement.role);
+				break;
+			case 'rename_role':
+				ddl.roles.update({
+					where: { name: statement.from.name },
+					set: { name: statement.to.name },
+				});
+				ddl.privileges.update({
+					where: { grantor: statement.from.name },
+					set: { grantor: statement.to.name },
+				});
+				ddl.privileges.update({
+					where: { grantee: statement.from.name },
+					set: { grantee: statement.to.name },
+				});
+				ddl.policies.update({
+					where: {},
+					set: {
+						roles: (role) => role === statement.from.name ? statement.to.name : role,
+					},
+				});
+				break;
+			case 'alter_role':
+				replace(ddl.roles, statement.diff.$left, statement.role);
+				break;
+
+			case 'grant_privilege':
+				push(ddl.privileges, statement.privilege);
+				break;
+			case 'revoke_privilege':
+				del(ddl.privileges, statement.privilege);
+				break;
+			case 'regrant_privilege':
+				replace(ddl.privileges, statement.diff.$left, statement.privilege);
+				break;
+
+			case 'create_view':
+				push(ddl.views, statement.view);
+				break;
+			case 'drop_view':
+				del(ddl.views, statement.view);
+				break;
+			case 'rename_view':
+				ddl.views.update({
+					where: { schema: statement.from.schema, name: statement.from.name },
+					set: { name: statement.to.name },
+				});
+				break;
+			case 'move_view':
+				ddl.views.update({
+					where: { schema: statement.fromSchema, name: statement.view.name },
+					set: { schema: statement.toSchema, name: statement.view.name },
+				});
+				break;
+			case 'alter_view':
+				replace(ddl.views, statement.diff.$left, statement.view);
+				break;
+
+			default:
+				assertUnreachable(statement);
+		}
+	}
+
+	return {
+		...snapshot,
+		ddl: ddl.entities.list(),
+	};
+}
diff --git a/drizzle-kit/src/dialects/postgres/snapshot.ts b/drizzle-kit/src/dialects/postgres/snapshot.ts
new file mode 100644
index 0000000000..9da9deb37c
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/snapshot.ts
@@ -0,0 +1,563 @@
+import { randomUUID } from 'crypto';
+import type { TypeOf } from 'zod';
+import { any, array as zodArray, boolean, enum as enumType, literal, number, object, record, string } from 'zod';
+import { originUUID } from '../../utils';
+import { array, validator } from '../simpleValidator';
+import type { PostgresDDL, PostgresEntity } from './ddl';
+import { createDDL } from './ddl';
+
+const indexV2 = object({
+	name: string(),
+	columns: record(
+		string(),
+		object({
+			name: string(),
+		}),
+	),
+	isUnique: boolean(),
+}).strict();
+
+const columnV2 = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	references: string().optional(),
+}).strict();
+
+const tableV2 = object({
+	name: string(),
+	columns: record(string(), columnV2),
+	indexes: record(string(), indexV2),
+}).strict();
+
+const enumSchemaV1 = object({
+	name: string(),
+	values: record(string(), string()),
+}).strict();
+
+const enumSchema = object({
+	name: string(),
+	schema: string(),
+	values: string().array(),
+}).strict();
+
+export const pgSchemaV2 = object({
+	version: literal('2'),
+	tables: record(string(), tableV2),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+// ------- V1 --------
+const references = object({
+	foreignKeyName: string(),
+	table: string(),
+	column: string(),
+	onDelete: string().optional(),
+	onUpdate: string().optional(),
+}).strict();
+
+const columnV1 = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	references: references.optional(),
+}).strict();
+
+const tableV1 = object({
+	name: string(),
+	columns: record(string(), columnV1),
+	indexes: record(string(), indexV2),
+}).strict();
+
+export const pgSchemaV1 = object({
+	version: literal('1'),
+	tables: record(string(), tableV1),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+const indexColumn = object({
+	expression: string(),
+	isExpression: boolean(),
+	asc: boolean(),
+	nulls: string().optional(),
+	opclass: string().optional(),
+});
+
+export type IndexColumnType = TypeOf<typeof indexColumn>;
+
+const index = object({
+	name: string(),
+	columns: indexColumn.array(),
+	isUnique: boolean(),
+	with: record(string(), any()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV4 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV5 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV6 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	schemaTo: string().optional(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+export const sequenceSchema = object({
+	name: string(),
+	increment: string().optional(),
+	minValue: string().optional(),
+	maxValue: string().optional(),
+	startWith: string().optional(),
+	cache: string().optional(),
+	cycle: boolean().optional(),
+	schema: string(),
+}).strict();
+
+export const identitySchema = sequenceSchema.omit({ schema: true }).merge(
+	object({ type: enumType(['always', 'byDefault']) }),
+);
+
+export const roleSchema = object({
+	name: string(),
+	createDb: boolean().optional(),
+	createRole: boolean().optional(),
+	inherit: boolean().optional(),
+}).strict();
+
+export const sequenceSquashed = object({
+	name: string(),
+	schema: string(),
+	values: string(),
+}).strict();
+
+const columnV7 = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	generated: object({
+		type: literal('stored'),
+		as: string(),
+	}).optional(),
+	identity: identitySchema.optional(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const columnSquashed = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+	generated: object({
+		type: literal('stored'),
+		as: string(),
+	}).optional(),
+	identity: string().optional(),
+}).strict();
+
+const tableV3 = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+	nullsNotDistinct: boolean(),
+}).strict();
+
+export const policy = object({
+	name: string(),
+	as: enumType(['PERMISSIVE', 'RESTRICTIVE']).optional(),
+	for: enumType(['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE']).optional(),
+	to: string().array().optional(),
+	using: string().optional(),
+	withCheck: string().optional(),
+	on: string().optional(),
+	schema: string().optional(),
+}).strict();
+
+export const policySquashed = object({
+	name: string(),
+	values: string(),
+}).strict();
+
+const viewWithOption = object({
+	checkOption: enumType(['local', 'cascaded']).optional(),
+	securityBarrier: boolean().optional(),
+	securityInvoker: boolean().optional(),
+}).strict();
+
+const matViewWithOption = object({
+	fillfactor: number().optional(),
+	toastTupleTarget: number().optional(),
+	parallelWorkers: number().optional(),
+	autovacuumEnabled: boolean().optional(),
+	vacuumIndexCleanup: enumType(['auto', 'off', 'on']).optional(),
+	vacuumTruncate: boolean().optional(),
+	autovacuumVacuumThreshold: number().optional(),
+	autovacuumVacuumScaleFactor: number().optional(),
+	autovacuumVacuumCostDelay: number().optional(),
+	autovacuumVacuumCostLimit: number().optional(),
+	autovacuumFreezeMinAge: number().optional(),
+	autovacuumFreezeMaxAge: number().optional(),
+	autovacuumFreezeTableAge: number().optional(),
+	autovacuumMultixactFreezeMinAge: number().optional(),
+	autovacuumMultixactFreezeMaxAge: number().optional(),
+	autovacuumMultixactFreezeTableAge: number().optional(),
+	logAutovacuumMinDuration: number().optional(),
+	userCatalogTable: boolean().optional(),
+}).strict();
+
+export const mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
+
+export const view = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	materialized: boolean(),
+	with: mergedViewWithOption.optional(),
+	isExisting: boolean(),
+	withNoData: boolean().optional(),
+	using: string().optional(),
+	tablespace: string().optional(),
+}).strict();
+
+const tableV4 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV4),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const tableV5 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV5),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const tableV6 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV6),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const tableV7 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), columnV7),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const table = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	policies: record(string(), policy).default({}),
+	checkConstraints: record(string(), checkConstraint).default({}),
+	isRLSEnabled: boolean().default(false).optional(),
+}).strict();
+
+const schemaHash = object({
+	id: string(),
+	prevIds: zodArray(string()),
+});
+
+const schemaHashV7 = object({
+	id: string(),
+	prevId: string(),
+});
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({
+					isArray: boolean().optional(),
+					dimensions: number().optional(),
+					rawType: string().optional(),
+					isDefaultAnExpression: boolean().optional(),
+				}).optional(),
+			),
+		}).optional(),
+	),
+}).optional();
+
+export const pgSchemaInternalV3 = object({
+	version: literal('3'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV3),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+export const pgSchemaInternalV4 = object({
+	version: literal('4'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV4),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+}).strict();
+
+// "table" -> "schema.table" for schema proper support
+export const pgSchemaInternalV5 = object({
+	version: literal('5'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV5),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaInternalV6 = object({
+	version: literal('6'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableV6),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaExternal = object({
+	version: literal('5'),
+	dialect: literal('pg'),
+	tables: zodArray(table),
+	enums: zodArray(enumSchemaV1),
+	schemas: zodArray(object({ name: string() })),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+}).strict();
+
+export const pgSchemaInternalV7 = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableV7),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	sequences: record(string(), sequenceSchema),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaInternal = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), table),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	views: record(string(), view).default({}),
+	sequences: record(string(), sequenceSchema).default({}),
+	roles: record(string(), roleSchema).default({}),
+	policies: record(string(), policy).default({}),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+const tableSquashed = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), columnSquashed),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()),
+	policies: record(string(), string()),
+	checkConstraints: record(string(), string()),
+	isRLSEnabled: boolean().default(false),
+}).strict();
+
+const tableSquashedV4 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashedV4 = object({
+	version: literal('4'),
+	dialect: literal('pg'),
+	tables: record(string(), tableSquashedV4),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashedV6 = object({
+	version: literal('6'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableSquashed),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashed = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableSquashed),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	views: record(string(), view),
+	sequences: record(string(), sequenceSquashed),
+	roles: record(string(), roleSchema).default({}),
+	policies: record(string(), policySquashed).default({}),
+}).strict();
+
+export const pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash);
+export const pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash);
+export const pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash);
+export const pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash);
+export const pgSchemaV7 = pgSchemaInternal.merge(schemaHashV7);
+export const pgSchema = pgSchemaInternal.merge(schemaHash);
+
+export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
+export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
+export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
+export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
+export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
+export type PgSchemaV6 = TypeOf<typeof pgSchemaV6>;
+export type PgSchemaV7 = TypeOf<typeof pgSchemaV7>;
+export type PgSchema = TypeOf<typeof pgSchema>;
+
+export type Index = TypeOf<typeof index>;
+export type TableV5 = TypeOf<typeof tableV5>;
+export type Column = TypeOf<typeof column>;
+
+export const toJsonSnapshot = (ddl: PostgresDDL, prevIds: string[], renames: string[]): PostgresSnapshot => {
+	return { dialect: 'postgres', id: randomUUID(), prevIds, version: '8', ddl: ddl.entities.list(), renames };
+};
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['8'],
+	dialect: ['postgres'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<PostgresEntity>((it) => {
+		const res = ddl.entities.validate(it);
+		if (!res) {
+			console.error(JSON.stringify(it));
+		}
+		return res;
+	}),
+	renames: array<string>((_) => true),
+});
+
+export type PostgresSnapshot = typeof snapshotValidator.shape;
+
+export const drySnapshot = snapshotValidator.strict(
+	{
+		version: '8',
+		dialect: 'postgres',
+		id: originUUID,
+		prevIds: [],
+		ddl: [],
+		renames: [],
+	} satisfies PostgresSnapshot,
+);
diff --git a/drizzle-kit/src/dialects/postgres/statements.ts b/drizzle-kit/src/dialects/postgres/statements.ts
new file mode 100644
index 0000000000..12bb6badf5
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/statements.ts
@@ -0,0 +1,459 @@
+import type { Simplify } from '../../utils';
+import type {
+	CheckConstraint,
+	Column,
+	DiffEntities,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	Table,
+	UniqueConstraint,
+	View,
+} from './ddl';
+
+export interface JsonCreateTable {
+	type: 'create_table';
+	table: Table;
+}
+
+export interface JsonDropTable {
+	type: 'drop_table';
+	table: Table;
+	key: string;
+}
+
+export interface JsonRenameTable {
+	type: 'rename_table';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonCreateEnum {
+	type: 'create_enum';
+	enum: Enum;
+}
+
+export interface JsonDropEnum {
+	type: 'drop_enum';
+	enum: Enum;
+}
+
+export interface JsonMoveEnum {
+	type: 'move_enum';
+	from: { name: string; schema: string | null };
+	to: { name: string; schema: string | null };
+}
+
+export interface JsonRenameEnum {
+	type: 'rename_enum';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonRecreateEnum {
+	type: 'recreate_enum';
+	to: Enum;
+	columns: (Omit<Column, 'default'> & {
+		default: {
+			left: Column['default'];
+			right: Column['default'];
+		};
+	})[];
+	from: Enum;
+}
+
+export interface JsonAlterEnum {
+	type: 'alter_enum';
+	to: Enum;
+	from: Enum;
+	diff: {
+		type: 'same' | 'removed' | 'added';
+		value: string;
+		beforeValue?: string;
+	}[];
+}
+
+export interface JsonCreateRole {
+	type: 'create_role';
+	role: Role;
+}
+
+export interface JsonDropRole {
+	type: 'drop_role';
+	role: Role;
+}
+export interface JsonRenameRole {
+	type: 'rename_role';
+	from: Role;
+	to: Role;
+}
+
+export interface JsonAlterRole {
+	type: 'alter_role';
+	diff: DiffEntities['roles'];
+	role: Role;
+}
+
+export interface JsonGrantPrivilege {
+	type: 'grant_privilege';
+	privilege: Privilege;
+}
+
+export interface JsonRevokePrivilege {
+	type: 'revoke_privilege';
+	privilege: Privilege;
+}
+
+export interface JsonRegrantPrivilege {
+	type: 'regrant_privilege';
+	privilege: Privilege;
+	diff: DiffEntities['privileges'];
+}
+
+export interface JsonDropValueFromEnum {
+	type: 'alter_type_drop_value';
+	deletedValues: string[];
+	enum: Enum;
+	columns: Column[];
+}
+
+export interface JsonCreateSequence {
+	type: 'create_sequence';
+	sequence: Sequence;
+}
+
+export interface JsonDropSequence {
+	type: 'drop_sequence';
+	sequence: Sequence;
+}
+
+export interface JsonMoveSequence {
+	type: 'move_sequence';
+	from: { name: string; schema: string | null };
+	to: { name: string; schema: string | null };
+}
+
+export interface JsonRenameSequence {
+	type: 'rename_sequence';
+	from: Sequence;
+	to: Sequence;
+}
+
+export interface JsonAlterSequence {
+	type: 'alter_sequence';
+	diff: DiffEntities['sequences'];
+	sequence: Sequence;
+}
+
+export interface JsonDropColumn {
+	type: 'drop_column';
+	column: Column;
+}
+
+export interface JsonAddColumn {
+	type: 'add_column';
+	column: Column;
+	isPK: boolean;
+	isCompositePK: boolean;
+}
+
+export interface JsonCreatePolicy {
+	type: 'create_policy';
+	policy: Policy;
+}
+
+export interface JsonDropPolicy {
+	type: 'drop_policy';
+	policy: Policy;
+}
+
+export interface JsonRenamePolicy {
+	type: 'rename_policy';
+	from: Policy;
+	to: Policy;
+}
+
+export interface JsonAlterRLS {
+	type: 'alter_rls';
+	schema: string;
+	name: string;
+	isRlsEnabled: boolean;
+}
+
+export interface JsonAlterPolicy {
+	type: 'alter_policy';
+	diff: DiffEntities['policies'];
+	policy: Policy;
+}
+export interface JsonRecreatePolicy {
+	type: 'recreate_policy';
+	policy: Policy;
+	diff: DiffEntities['policies'];
+}
+
+export interface JsonCreateIndex {
+	type: 'create_index';
+	index: Index;
+}
+
+export interface JsonRecreateIndex {
+	type: 'recreate_index';
+	index: Index;
+	diff: DiffEntities['indexes'];
+}
+
+export interface JsonCreateFK {
+	type: 'create_fk';
+	fk: ForeignKey;
+}
+
+export interface JsonDropFK {
+	type: 'drop_fk';
+	fk: ForeignKey;
+}
+
+export interface JsonRecreateFK {
+	type: 'recreate_fk';
+	fk: ForeignKey;
+	diff: DiffEntities['fks'];
+}
+
+export interface JsonCreateUnique {
+	type: 'add_unique';
+	unique: UniqueConstraint;
+}
+
+export interface JsonDeleteUnique {
+	type: 'drop_unique';
+	unique: UniqueConstraint;
+}
+
+export interface JsonAlterUnique {
+	type: 'alter_unique';
+	diff: DiffEntities['uniques'];
+}
+
+export interface JsonAddCheck {
+	type: 'add_check';
+	check: CheckConstraint;
+}
+
+export interface JsonDropCheck {
+	type: 'drop_check';
+	check: CheckConstraint;
+}
+
+export interface JsonAlterCheck {
+	type: 'alter_check';
+	diff: DiffEntities['checks'];
+}
+
+export interface JsonAddPrimaryKey {
+	type: 'add_pk';
+	pk: PrimaryKey;
+}
+
+export interface JsonDropPrimaryKey {
+	type: 'drop_pk';
+	pk: PrimaryKey;
+}
+
+export interface JsonRenameConstraint {
+	type: 'rename_constraint';
+	schema: string;
+	table: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonAlterPrimaryKey {
+	type: 'alter_pk';
+	pk: PrimaryKey;
+	diff: DiffEntities['pks'];
+	deleted?: boolean;
+}
+
+export interface JsonMoveTable {
+	type: 'move_table';
+	name: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonDropIndex {
+	type: 'drop_index';
+	index: Index;
+}
+
+export interface JsonRenameIndex {
+	type: 'rename_index';
+	schema: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonRenameColumn {
+	type: 'rename_column';
+	from: Column;
+	to: Column;
+}
+
+export interface JsonAlterColumn {
+	type: 'alter_column';
+	to: Column;
+	wasEnum: boolean;
+	isEnum: boolean;
+	wasSerial: boolean;
+	toSerial: boolean;
+	diff: DiffEntities['columns'];
+}
+
+export interface JsonRecreateColumn {
+	type: 'recreate_column';
+	diff: DiffEntities['columns'];
+	isPK: boolean;
+}
+
+export interface JsonAlterColumnSetPrimaryKey {
+	type: 'alter_column_set_pk';
+	table: string;
+	schema: string;
+	column: string;
+}
+
+export interface JsonAlterColumnChangeGenerated {
+	type: 'alter_column_change_generated';
+	column: Column;
+}
+export interface JsonAlterColumnChangeIdentity {
+	type: 'alter_column_change_identity';
+	column: Column;
+}
+
+export interface JsonCreateSchema {
+	type: 'create_schema';
+	name: string;
+}
+
+export interface JsonDropSchema {
+	type: 'drop_schema';
+	name: string;
+}
+
+export interface JsonRenameSchema {
+	type: 'rename_schema';
+	from: Schema;
+	to: Schema;
+}
+
+export interface JsonCreateView {
+	type: 'create_view';
+	view: View;
+}
+
+export interface JsonDropView {
+	type: 'drop_view';
+	view: View;
+	cause: View | null;
+}
+
+export interface JsonRenameView {
+	type: 'rename_view';
+	from: View;
+	to: View;
+}
+
+export interface JsonMoveView {
+	type: 'move_view';
+	fromSchema: string;
+	toSchema: string;
+	view: View;
+}
+
+export interface JsonAlterView {
+	type: 'alter_view';
+	diff: DiffEntities['views'];
+	view: View;
+}
+
+export type JsonStatement =
+	| JsonCreateTable
+	| JsonDropTable
+	| JsonRenameTable
+	| JsonRenameColumn
+	| JsonAlterColumn
+	| JsonRecreateColumn
+	| JsonMoveView
+	| JsonAlterView
+	| JsonCreateEnum
+	| JsonDropEnum
+	| JsonMoveEnum
+	| JsonRenameEnum
+	| JsonRecreateEnum
+	| JsonAlterEnum
+	| JsonDropColumn
+	| JsonAddColumn
+	| JsonCreateIndex
+	| JsonDropIndex
+	| JsonRenameIndex
+	| JsonAddPrimaryKey
+	| JsonDropPrimaryKey
+	| JsonRenameConstraint
+	| JsonAlterPrimaryKey
+	| JsonCreateFK
+	| JsonDropFK
+	| JsonRecreateFK
+	| JsonCreateUnique
+	| JsonDeleteUnique
+	| JsonAlterUnique
+	| JsonDropCheck
+	| JsonAddCheck
+	| JsonCreateSchema
+	| JsonDropSchema
+	| JsonRenameSchema
+	| JsonMoveTable
+	| JsonAlterSequence
+	| JsonDropSequence
+	| JsonCreateSequence
+	| JsonMoveSequence
+	| JsonRenameSequence
+	| JsonDropPolicy
+	| JsonCreatePolicy
+	| JsonAlterPolicy
+	| JsonRecreatePolicy
+	| JsonRenamePolicy
+	| JsonAlterRLS
+	| JsonRenameRole
+	| JsonCreateRole
+	| JsonDropRole
+	| JsonAlterRole
+	| JsonGrantPrivilege
+	| JsonRevokePrivilege
+	| JsonRegrantPrivilege
+	| JsonCreateView
+	| JsonDropView
+	| JsonRenameView
+	| JsonDropValueFromEnum
+	| JsonAlterCheck
+	| JsonRecreateIndex;
+
+export const prepareStatement = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	args: Omit<TStatement, 'type'>,
+): Simplify<TStatement> => {
+	return {
+		type,
+		...args,
+	} as TStatement;
+};
diff --git a/drizzle-kit/src/dialects/postgres/typescript.ts b/drizzle-kit/src/dialects/postgres/typescript.ts
new file mode 100644
index 0000000000..543d017635
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/typescript.ts
@@ -0,0 +1,795 @@
+import type { AnyTable } from 'drizzle-orm';
+import { getTableName, is } from 'drizzle-orm';
+import type { Relation, Relations } from 'drizzle-orm/_relations';
+import { createTableRelationsHelpers, extractTablesRelationalConfig, Many, One } from 'drizzle-orm/_relations';
+import type { AnyPgTable } from 'drizzle-orm/pg-core';
+import '../../@types/utils';
+import { toCamelCase } from 'drizzle-orm/casing';
+import type { Casing } from '../../cli/validations/common';
+import { assertUnreachable, trimChar } from '../../utils';
+import { escapeForTsLiteral, inspect } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	Policy,
+	PostgresDDL,
+	PrimaryKey,
+	UniqueConstraint,
+	ViewColumn,
+} from './ddl';
+import { tableFromDDL } from './ddl';
+import { defaultNameForIdentitySequence, defaults, typeFor } from './grammar';
+
+// TODO: omit defaults opclass... improvement
+const imports = [
+	'smallint',
+	'integer',
+	'bigint',
+	'numeric',
+	'decimal',
+	'real',
+	'doublePrecision',
+	'boolean',
+	'char',
+	'varchar',
+	'text',
+	'json',
+	'jsonb',
+
+	'serial',
+	'smallserial',
+	'bigserial',
+
+	'time',
+	'timestamp',
+	'date',
+	'interval',
+	'cidr',
+	'inet',
+	'macaddr',
+	'macaddr8',
+	'bigint',
+	'uuid',
+	'vector',
+	'halfvec',
+	'sparsevec',
+	'point',
+	'line',
+	'geometry',
+	'bit',
+	'pgEnum',
+	'customType',
+] as const;
+export type Import = typeof imports[number];
+
+const pgImportsList = new Set([
+	'pgTable',
+	...imports,
+]);
+
+const objToStatement2 = (json: { [s: string]: unknown }) => {
+	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
+
+	const keys = Object.keys(json);
+	if (keys.length === 0) return;
+
+	let statement = '{ ';
+	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
+	statement += ' }';
+	return statement;
+};
+
+const relations = new Set<string>();
+
+const escapeColumnKey = (value: string) => {
+	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
+		return `"${value}"`;
+	}
+	return value;
+};
+
+const withCasing = (value: string, casing: Casing) => {
+	if (casing === 'preserve') {
+		return escapeColumnKey(value);
+	}
+	if (casing === 'camel') {
+		return escapeColumnKey(toCamelCase(value));
+	}
+
+	assertUnreachable(casing);
+};
+
+const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
+	if (casing === 'preserve') {
+		return '';
+	}
+	if (casing === 'camel') {
+		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
+	}
+
+	assertUnreachable(casing);
+};
+
+export const relationsToTypeScriptForStudio = (
+	schema: Record<string, Record<string, AnyPgTable<{}>>>,
+	relations: Record<string, Relations<string, Record<string, Relation<string>>>>,
+) => {
+	const relationalSchema: Record<string, unknown> = {
+		...Object.fromEntries(
+			Object.entries(schema)
+				.map(([key, val]) => {
+					// have unique keys across schemas
+					const mappedTableEntries = Object.entries(val).map((tableEntry) => {
+						return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
+					});
+
+					return mappedTableEntries;
+				})
+				.flat(),
+		),
+		...relations,
+	};
+
+	const relationsConfig = extractTablesRelationalConfig(relationalSchema, createTableRelationsHelpers);
+
+	let result = '';
+
+	function findColumnKey(table: AnyTable<{ name: string }>, columnName: string) {
+		for (const tableEntry of Object.entries(table)) {
+			const key = tableEntry[0];
+			const value = tableEntry[1] as { name?: string };
+
+			if (value.name === columnName) {
+				return key;
+			}
+		}
+	}
+
+	Object.values(relationsConfig.tables).forEach((table) => {
+		const tableName = table.tsName.split('.')[1];
+		const relations = table.relations;
+		let hasRelations = false;
+		let relationsObjAsStr = '';
+		let hasOne = false;
+		let hasMany = false;
+
+		Object.values(relations).forEach((relation) => {
+			hasRelations = true;
+
+			if (is(relation, Many)) {
+				hasMany = true;
+				relationsObjAsStr += `\t\t${relation.fieldName}: many(${
+					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
+				}${typeof relation.relationName !== 'undefined' ? `, { relationName: "${relation.relationName}"}` : ''}),`;
+			}
+
+			if (is(relation, One)) {
+				hasOne = true;
+				relationsObjAsStr += `\t\t${relation.fieldName}: one(${
+					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
+				}, { fields: [${
+					relation.config?.fields.map(
+						(c) =>
+							`${relationsConfig.tableNamesMap[getTableName(relation.sourceTable)].split('.')[1]}.${
+								findColumnKey(relation.sourceTable, c.name)
+							}`,
+					)
+				}], references: [${
+					relation.config?.references.map(
+						(c) =>
+							`${relationsConfig.tableNamesMap[getTableName(relation.referencedTable)].split('.')[1]}.${
+								findColumnKey(relation.referencedTable, c.name)
+							}`,
+					)
+				}]${typeof relation.relationName !== 'undefined' ? `, relationName: "${relation.relationName}"` : ''}}),`;
+			}
+		});
+
+		if (hasRelations) {
+			result += `export const ${tableName}Relation = relations(${tableName}, ({${hasOne ? 'one' : ''}${
+				hasOne && hasMany ? ', ' : ''
+			}${hasMany ? 'many' : ''}}) => ({
+        ${relationsObjAsStr}
+      }));\n`;
+		}
+	});
+
+	return result;
+};
+
+function generateIdentityParams(column: Column) {
+	if (column.identity === null) return '';
+	const identity = column.identity;
+
+	const tuples = [];
+	if (identity.name !== defaultNameForIdentitySequence(column.table, column.name)) {
+		tuples.push(['name', `"${identity.name}"`]);
+	}
+
+	if (identity.startWith && defaults.identity.startWith !== identity.startWith) {
+		tuples.push(['startWith', identity.startWith]);
+	}
+	if (identity.increment && defaults.identity.increment !== identity.increment) {
+		tuples.push(['increment', identity.increment]);
+	}
+	if (identity.minValue && defaults.identity.min !== identity.minValue) tuples.push(['minValue', identity.minValue]);
+	if (identity.maxValue && defaults.identity.maxFor(column.type) !== identity.maxValue) {
+		tuples.push(['maxValue', identity.maxValue]);
+	}
+	if (identity.cache && defaults.identity.cache !== identity.cache) tuples.push(['cache', identity.cache]);
+	if (identity.cycle) tuples.push(['cycle', identity.cycle]);
+
+	const params = tuples.length > 0 ? `{ ${tuples.map((x) => `${x[0]}: ${x[1]}`).join(' ,')} }` : '';
+
+	if (identity?.type === 'always') {
+		return `.generatedAlwaysAsIdentity(${params})`;
+	}
+	return `.generatedByDefaultAsIdentity(${params})`;
+}
+
+export const paramNameFor = (name: string, schema?: string | null) => {
+	const schemaSuffix = schema && schema !== 'public' ? `In${schema.capitalise()}` : '';
+	return `${name}${schemaSuffix}`;
+};
+
+// prev: schemaToTypeScript
+export const ddlToTypeScript = (
+	ddl: PostgresDDL,
+	columnsForViews: ViewColumn[],
+	casing: Casing,
+) => {
+	const tableFn = `pgTable`;
+	for (const fk of ddl.fks.list()) {
+		relations.add(`${fk.table}-${fk.tableTo}`);
+	}
+
+	const schemas = Object.fromEntries(
+		ddl.schemas.list().filter((it) => it.name !== 'public').map((it) => {
+			return [it.name, withCasing(it.name, casing)];
+		}),
+	);
+
+	const enumTypes = new Set(ddl.enums.list().map((x) => `${x.schema}.${x.name}`));
+
+	const imports = new Set<string>();
+	const vcs = columnsForViews.map((it) => ({ entityType: 'viewColumns' as const, ...it }));
+	const entities = [...ddl.entities.list(), ...vcs];
+	for (const x of entities) {
+		if (x.entityType === 'schemas' && x.name !== 'public') imports.add('pgSchema');
+		if (x.entityType === 'enums' && x.schema === 'public') imports.add('pgEnum');
+		if (x.entityType === 'tables') imports.add(tableFn);
+
+		if (x.entityType === 'indexes') {
+			if (x.isUnique) imports.add('uniqueIndex');
+			else imports.add('index');
+		}
+
+		if (x.entityType === 'fks') {
+			imports.add('foreignKey');
+
+			if (isCyclic(x) && !isSelf(x)) imports.add('type AnyPgColumn');
+		}
+		if (x.entityType === 'pks') imports.add('primaryKey');
+		if (x.entityType === 'uniques') imports.add('unique');
+		if (x.entityType === 'checks') imports.add('check');
+		if (x.entityType === 'views' && x.schema === 'public') {
+			if (x.materialized) imports.add('pgMaterializedView');
+			else imports.add('pgView');
+		}
+
+		if (x.entityType === 'columns' || x.entityType === 'viewColumns') {
+			let patched = x.type.replace('[]', '');
+			const isEnum = Boolean(x.typeSchema);
+			const grammarType = typeFor(patched, isEnum);
+			imports.add(grammarType.drizzleImport());
+			if (pgImportsList.has(patched)) imports.add(patched);
+		}
+
+		if (x.entityType === 'sequences' && x.schema === 'public') imports.add('pgSequence');
+		if (x.entityType === 'enums' && x.schema === 'public') imports.add('pgEnum');
+		if (x.entityType === 'policies') imports.add('pgPolicy');
+		if (x.entityType === 'roles') imports.add('pgRole');
+	}
+
+	const enumStatements = ddl.enums.list().map((it) => {
+		const enumSchema = schemas[it.schema];
+		// const func = schema || schema === "public" ? "pgTable" : schema;
+		const paramName = paramNameFor(it.name, enumSchema);
+
+		const func = enumSchema ? `${enumSchema}.enum` : 'pgEnum';
+
+		const values = Object.values(it.values)
+			.map((it) => escapeForTsLiteral(it))
+			.join(', ');
+		return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", [${values}])\n`;
+	})
+		.join('')
+		.concat('\n');
+
+	const sequencesStatements = ddl.sequences.list().map((it) => {
+		const seqSchema = schemas[it.schema];
+		const paramName = paramNameFor(it.name, seqSchema);
+
+		const func = seqSchema ? `${seqSchema}.sequence` : 'pgSequence';
+
+		let params = '';
+		if (it.startWith) params += `startWith: "${it.startWith}", `;
+		if (it.incrementBy) params += `increment: "${it.incrementBy}", `;
+		if (it.minValue) params += `minValue: "${it.minValue}", `;
+		if (it.maxValue) params += `maxValue: "${it.maxValue}", `;
+		if (it.cacheSize) params += `cache: "${it.cacheSize}", `;
+
+		if (it.cycle) params += `cycle: true, `;
+		else params += `cycle: false, `;
+
+		params = params ? `, { ${trimChar(params.trim(), ',')} }` : '';
+
+		return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}"${params})\n`;
+	})
+		.join('')
+		.concat('');
+
+	const schemaStatements = Object.entries(schemas).map((it) => {
+		return `export const ${it[1]} = pgSchema("${it[0]}");\n`;
+	}).join('');
+
+	const rolesNameToTsKey: Record<string, string> = {};
+	const rolesStatements = ddl.roles.list().map((it) => {
+		const identifier = withCasing(it.name, casing);
+		rolesNameToTsKey[it.name] = identifier;
+		const params = {
+			...(it.createDb ? { createDb: true } : {}),
+			...(it.createRole ? { createRole: true } : {}),
+			...(it.inherit ? {} : { inherit: false }),
+		};
+		const paramsString = inspect(params);
+		const comma = paramsString ? ', ' : '';
+
+		return `export const ${identifier} = pgRole("${it.name}"${comma}${paramsString});\n`;
+	})
+		.join('');
+
+	const tableStatements = ddl.tables.list().map((it) => {
+		const tableSchema = schemas[it.schema];
+		const paramName = paramNameFor(it.name, tableSchema);
+		const table = tableFromDDL(it, ddl);
+		const columns = ddl.columns.list({ schema: table.schema, table: table.name });
+		const fks = ddl.fks.list({ schema: table.schema, table: table.name });
+
+		let func = tableSchema ? `${tableSchema}.table` : tableFn;
+		func += table.isRlsEnabled ? '.withRLS' : '';
+
+		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${table.name}", {\n`;
+		statement += createTableColumns(
+			columns,
+			table.pk,
+			fks,
+			schemas,
+			casing,
+		);
+		statement += '}';
+
+		// more than 2 fields or self reference or cyclic
+		// Andrii: I switched this one off until we will get custom names in .references()
+		const filteredFKs = table.fks.filter((it) => {
+			return it.columns.length > 1 || isSelf(it);
+		});
+
+		const hasCallback = table.indexes.length > 0
+			|| filteredFKs.length > 0
+			|| table.policies.length > 0
+			|| (table.pk && table.pk.columns.length > 1)
+			|| table.uniques.length > 0
+			|| table.checks.length > 0;
+
+		if (hasCallback) {
+			statement += ', ';
+			statement += '(table) => [\n';
+			// TODO: or pk has non-default name
+			statement += table.pk && table.pk.columns.length > 1 ? createTablePK(table.pk, casing) : '';
+			statement += createTableFKs(filteredFKs, schemas, casing);
+			statement += createTableIndexes(table.name, table.indexes, casing);
+			statement += createTableUniques(table.uniques, casing);
+			statement += createTablePolicies(table.policies, casing, rolesNameToTsKey);
+			statement += createTableChecks(table.checks, casing);
+			statement += ']';
+		}
+		statement += ');';
+		return statement;
+	});
+
+	const viewsStatements = Object.values(ddl.views.list())
+		.map((it) => {
+			const viewSchema = schemas[it.schema];
+			const paramName = paramNameFor(it.name, viewSchema);
+
+			// TODO: casing?
+			const func = it.schema !== 'public'
+				? (it.materialized ? `${viewSchema}.materializedView` : `${viewSchema}.view`)
+				: it.materialized
+				? 'pgMaterializedView'
+				: 'pgView';
+
+			const withOption = Object.fromEntries(Object.entries(it.with ?? {}).filter((x) => x[1] !== null));
+			const as = `sql\`${it.definition}\``;
+			const tablespace = it.tablespace ?? '';
+
+			const viewColumns = columnsForViews.filter((x) => x.schema === it.schema && x.view === it.name);
+			const columns = createViewColumns(
+				viewColumns,
+				enumTypes,
+				casing,
+			);
+
+			let statement = `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", {${columns}})`;
+			statement += tablespace ? `.tablespace("${tablespace}")` : '';
+			statement += Object.keys(withOption).length > 0 ? `.with(${JSON.stringify(withOption)})` : '';
+			statement += `.as(${as});`;
+
+			return statement;
+		})
+		.join('\n\n');
+
+	const uniquePgImports = [...imports];
+
+	const importsTs = `import { ${
+		uniquePgImports.join(
+			', ',
+		)
+	} } from "drizzle-orm/pg-core"
+import { sql } from "drizzle-orm"\n\n`;
+
+	let decalrations = schemaStatements;
+	decalrations += rolesStatements;
+	decalrations += enumStatements;
+	decalrations += sequencesStatements;
+	decalrations += '\n';
+	decalrations += tableStatements.join('\n\n');
+	decalrations += '\n';
+	decalrations += viewsStatements;
+
+	const file = importsTs + decalrations;
+
+	// for drizzle studio query runner
+	const schemaEntry = `
+    {
+      ${
+		Object.values(ddl.tables)
+			.map((it) => withCasing(it.name, casing))
+			.join(',\n')
+	}
+    }
+  `;
+
+	return { file, imports: importsTs, decalrations, schemaEntry };
+};
+
+const isCyclic = (fk: ForeignKey) => {
+	const key = `${fk.table}-${fk.tableTo}`;
+	const reverse = `${fk.tableTo}-${fk.table}`;
+	return relations.has(key) && relations.has(reverse);
+};
+
+const isSelf = (fk: ForeignKey) => {
+	return fk.table === fk.tableTo;
+};
+
+const column = (
+	type: string,
+	dimensions: number,
+	name: string,
+	enumTypes: Set<string>,
+	typeSchema: string | null,
+	casing: Casing,
+	def: Column['default'],
+) => {
+	const isEnum = Boolean(typeSchema);
+	const grammarType = typeFor(type, isEnum);
+
+	const { options, default: defaultValue, customType } = dimensions > 0
+		? grammarType.toArrayTs(type, def ?? null)
+		: grammarType.toTs(type, def ?? null);
+
+	const dbName = dbColumnName({ name, casing });
+	const opts = inspect(options);
+	const comma = (dbName && opts) ? ', ' : '';
+
+	let columnStatement = `${withCasing(name, casing)}: ${
+		isEnum ? withCasing(paramNameFor(type, typeSchema), casing) : grammarType.drizzleImport()
+	}${customType ? `({ dataType: () => '${customType}' })` : ''}(${dbName}${comma}${opts})`;
+
+	if (dimensions > 0) {
+		const suffix = '[]'.repeat(dimensions);
+		columnStatement += dimensions === 1 ? '.array()' : `.array("${suffix}")`;
+	}
+
+	if (defaultValue) columnStatement += `.default(${defaultValue})`;
+	return columnStatement;
+};
+
+const createViewColumns = (
+	columns: ViewColumn[],
+	enumTypes: Set<string>,
+	casing: Casing,
+) => {
+	let statement = '';
+
+	columns.forEach((it) => {
+		const columnStatement = column(
+			it.type,
+			it.dimensions,
+			it.name,
+			enumTypes,
+			it.typeSchema,
+			casing,
+			null,
+		);
+		statement += '\t';
+		statement += columnStatement;
+		if (it.dimensions > 0 || it.typeDimensions > 0) {
+			const c = it.dimensions + it.typeDimensions;
+			const suffix = '[]'.repeat(it.dimensions + it.typeDimensions);
+			statement += c === 1 ? '.array()' : `.array("${suffix}")`;
+		}
+		statement += it.notNull ? '.notNull()' : '';
+		statement += ',\n';
+	});
+	return statement;
+};
+
+const createTableColumns = (
+	columns: Column[],
+	primaryKey: PrimaryKey | null,
+	fks: ForeignKey[],
+	schemas: Record<string, string>,
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	// no self refs and no cyclic
+	const oneColumnsFKs = Object.values(fks)
+		.filter((it) => {
+			return !isSelf(it);
+		})
+		.filter((it) => it.columns.length === 1);
+
+	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
+		const arr = res[it.columns[0]] || [];
+		arr.push(it);
+		res[it.columns[0]] = arr;
+		return res;
+	}, {} as Record<string, ForeignKey[]>);
+
+	for (const it of columns) {
+		const { name, type, dimensions, default: def, identity, generated, typeSchema } = it;
+		const stripped = type.replaceAll('[]', '');
+		const isEnum = Boolean(typeSchema);
+		const grammarType = typeFor(stripped, isEnum);
+
+		const { options, default: defaultValue, customType } = dimensions > 0
+			? grammarType.toArrayTs(type, def ?? null)
+			: grammarType.toTs(type, def ?? null);
+
+		const dbName = dbColumnName({ name, casing });
+		const opts = inspect(options);
+		const comma = (dbName && opts) ? ', ' : '';
+
+		const pk = primaryKey && primaryKey.columns.length === 1 && primaryKey.columns[0] === it.name
+			? primaryKey
+			: null;
+
+		let columnStatement = `${withCasing(name, casing)}: ${
+			isEnum ? withCasing(paramNameFor(type, typeSchema), casing) : grammarType.drizzleImport()
+		}${customType ? `({ dataType: () => '${customType}' })` : ''}(${dbName}${comma}${opts})`;
+
+		if (it.dimensions > 0) {
+			const suffix = '[]'.repeat(it.dimensions);
+			columnStatement += it.dimensions === 1 ? '.array()' : `.array("${suffix}")`;
+		}
+
+		if (defaultValue) columnStatement += defaultValue.startsWith('.') ? defaultValue : `.default(${defaultValue})`;
+		if (pk) columnStatement += '.primaryKey()';
+		if (it.notNull && !it.identity && !pk) columnStatement += '.notNull()';
+		if (identity) columnStatement += generateIdentityParams(it);
+		if (generated) columnStatement += `.generatedAlwaysAs(sql\`${generated.as}\`)`;
+
+		statement += '\t';
+		statement += columnStatement;
+		// Provide just this in column function
+
+		const fks = fkByColumnName[it.name];
+		// Andrii: I switched it off until we will get a custom naem setting in references
+		if (fks) {
+			const fksStatement = fks
+				.map((it) => {
+					const onDelete = it.onDelete && it.onDelete !== 'NO ACTION' ? it.onDelete.toLowerCase() : null;
+					const onUpdate = it.onUpdate && it.onUpdate !== 'NO ACTION' ? it.onUpdate.toLowerCase() : null;
+					const params = { onDelete, onUpdate };
+
+					const typeSuffix = isCyclic(it) ? ': AnyPgColumn' : '';
+
+					const paramsStr = objToStatement2(params);
+					const tableSchema = schemas[it.schemaTo || ''];
+					const paramName = paramNameFor(it.tableTo, tableSchema);
+					if (paramsStr) {
+						return `.references(()${typeSuffix} => ${
+							withCasing(
+								paramName,
+								casing,
+							)
+						}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
+					}
+					return `.references(()${typeSuffix} => ${
+						withCasing(
+							paramName,
+							casing,
+						)
+					}.${withCasing(it.columnsTo[0], casing)})`;
+				})
+				.join('');
+			statement += fksStatement;
+		}
+
+		statement += ',\n';
+	}
+
+	return statement;
+};
+
+const createTableIndexes = (tableName: string, idxs: Index[], casing: Casing): string => {
+	let statement = '';
+
+	idxs.forEach((it) => {
+		// TODO: cc: @AndriiSherman we have issue when index is called as table called
+		// let idxKey = it.name.startsWith(tableName) && it.name !== tableName ? it.name.slice(tableName.length + 1) : it.name;
+		// idxKey = idxKey.endsWith('_index') ? idxKey.slice(0, -'_index'.length) + '_idx' : idxKey;
+		// idxKey = withCasing(idxKey, casing);
+		// const indexGeneratedName = indexName(
+		// 	tableName,
+		// 	it.columns.map((it) => it.value),
+		// );
+
+		const name = it.nameExplicit ? it.name : '';
+		// const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
+
+		statement += it.isUnique ? '\tuniqueIndex(' : '\tindex(';
+		statement += name ? `"${name}")` : ')';
+		statement += `${it.concurrently ? `.concurrently()` : ''}`;
+
+		statement += `.using("${it.method}", ${
+			it.columns
+				.map((it) => {
+					if (it.isExpression) {
+						return `sql\`${it.value}\``;
+					} else {
+						return `table.${withCasing(it.value, casing)}${it.asc ? '.asc()' : '.desc()'}${
+							it.nullsFirst ? '.nullsFirst()' : '.nullsLast()'
+						}${
+							it.opclass && !it.opclass.default
+								? `.op("${it.opclass.name}")`
+								: ''
+						}`;
+					}
+				})
+				.join(', ')
+		})`;
+		statement += it.where ? `.where(sql\`${it.where}\`)` : '';
+
+		statement += it.with
+			? `.with({ ${
+				it.with.split(',').map((it) => {
+					const [key, value] = it.split('=');
+					return `"${key.trim()}": ${value.trim()}`;
+				}).join(', ')
+			} })`
+			: '';
+		statement += `,\n`;
+	});
+
+	return statement;
+};
+
+const createTablePK = (it: PrimaryKey, casing: Casing): string => {
+	let statement = '\tprimaryKey({ columns: [';
+	statement += `${
+		it.columns
+			.map((c) => {
+				return `table.${withCasing(c, casing)}`;
+			})
+			.join(', ')
+	}`;
+	statement += `]${it.nameExplicit ? `, name: "${it.name}"` : ''}}),\n`;
+	return statement;
+};
+
+// get a map of db role name to ts key
+// if to by key is in this map - no quotes, otherwise - quotes
+
+const createTablePolicies = (
+	policies: Policy[],
+	casing: Casing,
+	rolesNameToTsKey: Record<string, string> = {},
+): string => {
+	let statement = '';
+
+	policies.forEach((it) => {
+		const mappedItTo = it.roles.map((v) => {
+			return rolesNameToTsKey[v] ? withCasing(rolesNameToTsKey[v], casing) : `"${v}"`;
+		});
+
+		const tuples = [];
+		if (it.as === 'RESTRICTIVE') tuples.push(['as', `"${it.as.toLowerCase()}"`]);
+		if (it.for !== 'ALL') tuples.push(['for', `"${it.for.toLowerCase()}"`]);
+		if (!(mappedItTo.length === 1 && mappedItTo[0] === '"public"')) {
+			tuples.push([
+				'to',
+				`[${mappedItTo.map((x) => `${x}`).join(', ')}]`,
+			]);
+		}
+		if (it.using !== null) tuples.push(['using', `sql\`${it.using}\``]);
+		if (it.withCheck !== null) tuples.push(['withCheck', `sql\`${it.withCheck}\``]);
+		const opts = tuples.length > 0 ? `, { ${tuples.map((x) => `${x[0]}: ${x[1]}`).join(', ')} }` : '';
+		statement += `\n\tpgPolicy("${it.name}"${opts}),\n`;
+	});
+
+	return statement;
+};
+
+const createTableUniques = (
+	unqs: UniqueConstraint[],
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	unqs.forEach((it) => {
+		statement += '\tunique(';
+		statement += it.nameExplicit ? `"${it.name}")` : ')';
+		statement += `.on(${it.columns.map((it) => `table.${withCasing(it, casing)}`).join(', ')})`;
+		statement += it.nullsNotDistinct ? `.nullsNotDistinct()` : '';
+		statement += `,`;
+	});
+
+	return statement;
+};
+
+const createTableChecks = (
+	checkConstraints: CheckConstraint[],
+	_casing: Casing,
+) => {
+	let statement = '';
+
+	checkConstraints.forEach((it) => {
+		statement += 'check(';
+		statement += `"${it.name}", `;
+		statement += `sql\`${it.value.replaceAll('`', '\\`')}\`)`;
+		statement += `,`;
+	});
+
+	return statement;
+};
+
+const createTableFKs = (fks: ForeignKey[], schemas: Record<string, string>, casing: Casing): string => {
+	let statement = '';
+
+	fks.forEach((it) => {
+		const tableSchema = it.schemaTo === 'public' ? '' : schemas[it.schemaTo];
+		const paramName = paramNameFor(it.tableTo, tableSchema);
+
+		const isSelf = it.tableTo === it.table;
+		const tableTo = isSelf ? 'table' : `${withCasing(paramName, casing)}`;
+		statement += `\tforeignKey({\n`;
+		statement += `\t\tcolumns: [${it.columns.map((i) => `table.${withCasing(i, casing)}`).join(', ')}],\n`;
+		statement += `\t\tforeignColumns: [${
+			it.columnsTo.map((i) => `${tableTo}.${withCasing(i, casing)}`).join(', ')
+		}],\n`;
+		statement += it.nameExplicit ? `\t\tname: "${it.name}"\n` : '';
+		statement += `\t})`;
+
+		statement += it.onUpdate && it.onUpdate !== 'NO ACTION' ? `.onUpdate("${it.onUpdate.toLowerCase()}")` : '';
+		statement += it.onDelete && it.onDelete !== 'NO ACTION' ? `.onDelete("${it.onDelete.toLowerCase()}")` : '';
+		statement += `,\n`;
+	});
+	return statement;
+};
diff --git a/drizzle-kit/src/dialects/postgres/versions.ts b/drizzle-kit/src/dialects/postgres/versions.ts
new file mode 100644
index 0000000000..ab59090865
--- /dev/null
+++ b/drizzle-kit/src/dialects/postgres/versions.ts
@@ -0,0 +1,520 @@
+import { createDDL, type Index } from '../../dialects/postgres/ddl';
+import {
+	defaultNameForIndex,
+	defaultNameForPK,
+	defaultNameForUnique,
+	defaults,
+	trimDefaultValueSuffix,
+} from '../../dialects/postgres/grammar';
+import type {
+	Column,
+	Index as LegacyIndex,
+	PgSchema,
+	PgSchemaV4,
+	PgSchemaV5,
+	PgSchemaV6,
+	PgSchemaV7,
+	PostgresSnapshot,
+	TableV5,
+} from '../../dialects/postgres/snapshot';
+import { getOrNull } from '../../dialects/utils';
+
+export const upToV8 = (
+	it: Record<string, any>,
+): { snapshot: PostgresSnapshot; hints: string[] } => {
+	if (Number(it.version) < 7) return upToV8(updateUpToV7(it));
+	const json = it as PgSchemaV7;
+
+	const hints = [] as string[];
+
+	const ddl = createDDL();
+
+	for (const schema of Object.values(json.schemas)) {
+		ddl.schemas.push({ name: schema });
+	}
+
+	if (json.sequences) {
+		for (const seq of Object.values(json.sequences)) {
+			ddl.sequences.push({
+				schema: seq.schema!,
+				name: seq.name,
+				startWith: seq.startWith ?? null,
+				incrementBy: seq.increment ?? null,
+				minValue: seq.minValue ?? null,
+				maxValue: seq.maxValue ?? null,
+				cacheSize: seq.cache ? Number(seq.cache) : null,
+				cycle: seq.cycle ?? null,
+			});
+		}
+	}
+
+	for (const table of Object.values(json.tables)) {
+		const schema = table.schema || 'public';
+
+		const isRlsEnabled = table.isRLSEnabled
+			|| Object.keys(table.policies ?? {}).length > 0
+			|| Object.values(json.policies ?? {}).some(
+				(it) => it.on === table.name && (it.schema ?? 'public') === schema,
+			);
+
+		ddl.tables.push({
+			schema,
+			name: table.name,
+			isRlsEnabled: isRlsEnabled,
+		});
+
+		for (const column of Object.values(table.columns)) {
+			if (column.primaryKey) {
+				ddl.pks.push({
+					schema,
+					table: table.name,
+					columns: [column.name],
+					name: defaultNameForPK(table.name),
+					nameExplicit: false,
+				});
+			}
+
+			const [baseType, dimensions] = extractBaseTypeAndDimensions(column.type);
+
+			let fixedType = baseType.startsWith('numeric(')
+				? baseType.replace(', ', ',')
+				: baseType;
+
+			ddl.columns.push({
+				schema,
+				table: table.name,
+				name: column.name,
+				type: fixedType,
+				notNull: column.notNull,
+				typeSchema: column.typeSchema ?? null, // TODO: if public - empty or missing?
+				dimensions,
+				generated: column.generated ?? null,
+				identity: column.identity
+					? {
+						name: column.identity.name,
+						type: column.identity.type,
+						startWith: column.identity.startWith ?? null,
+						minValue: column.identity.minValue ?? null,
+						maxValue: column.identity.maxValue ?? null,
+						increment: column.identity.increment ?? null,
+						cache: column.identity.cache
+							? Number(column.identity.cache)
+							: null,
+						cycle: column.identity.cycle ?? null,
+					}
+					: null,
+				default: typeof column.default === 'undefined'
+					? null
+					: trimDefaultValueSuffix(String(column.default)),
+			});
+		}
+
+		if (table.compositePrimaryKeys) {
+			for (const pk of Object.values(table.compositePrimaryKeys)) {
+				const nameExplicit = `${table.name}_${pk.columns.join('_')}_pk` !== pk.name;
+				if (!nameExplicit) {
+					hints.push(
+						`update pk name: ${pk.name} -> ${defaultNameForPK(table.name)}`,
+					);
+				}
+				ddl.pks.push({
+					schema: schema,
+					table: table.name,
+					name: pk.name,
+					columns: pk.columns,
+					nameExplicit, // TODO: ??
+				});
+			}
+		}
+
+		if (table.uniqueConstraints) {
+			for (const unique of Object.values(table.uniqueConstraints)) {
+				const nameExplicit = `${table.name}_${unique.columns.join('_')}_unique` !== unique.name;
+				if (!nameExplicit) {
+					hints.push(
+						`update unique name: ${unique.name} -> ${defaultNameForUnique(table.name, ...unique.columns)}`,
+					);
+				}
+
+				ddl.uniques.push({
+					schema,
+					table: table.name,
+					columns: unique.columns,
+					name: unique.name,
+					nameExplicit: nameExplicit,
+					nullsNotDistinct: unique.nullsNotDistinct ?? defaults.nullsNotDistinct,
+				});
+			}
+		}
+
+		for (const check of Object.values(table.checkConstraints ?? {})) {
+			ddl.checks.push({
+				schema,
+				table: table.name,
+				name: check.name,
+				value: check.value,
+			});
+		}
+
+		for (const idx of Object.values(table.indexes)) {
+			const columns: Index['columns'][number][] = idx.columns.map<
+				Index['columns'][number]
+			>((it) => {
+				return {
+					value: it.expression,
+					isExpression: it.isExpression,
+					asc: it.asc,
+					nullsFirst: it.nulls ? it.nulls !== 'last' : false,
+					opclass: it.opclass
+						? {
+							name: it.opclass,
+							default: false,
+						}
+						: null,
+				};
+			});
+
+			const nameExplicit = columns.some((it) => it.isExpression === true)
+				|| `${table.name}_${columns.map((it) => it.value).join('_')}_index`
+					!== idx.name;
+
+			if (!nameExplicit) {
+				hints.push(
+					`rename index name: ${idx.name} -> ${
+						defaultNameForIndex(
+							table.name,
+							idx.columns.map((x) => x.expression),
+						)
+					}`,
+				);
+			}
+
+			ddl.indexes.push({
+				schema,
+				table: table.name,
+				name: idx.name,
+				columns,
+				isUnique: idx.isUnique,
+				method: idx.method,
+				concurrently: idx.concurrently,
+				where: idx.where ?? null,
+				with: idx.with && Object.keys(idx.with).length > 0
+					? Object.entries(idx.with)
+						.map((it) => `${it[0]}=${it[1]}`)
+						.join(',')
+					: '',
+				nameExplicit,
+			});
+		}
+
+		for (const fk of Object.values(table.foreignKeys)) {
+			const nameExplicit = `${fk.tableFrom}_${fk.columnsFrom.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fk`
+				!== fk.name;
+			const name = fk.name.length < 63 ? fk.name : fk.name.slice(0, 63);
+			ddl.fks.push({
+				schema,
+				name,
+				nameExplicit,
+				table: fk.tableFrom,
+				columns: fk.columnsFrom,
+				schemaTo: fk.schemaTo || 'public',
+				tableTo: fk.tableTo,
+				columnsTo: fk.columnsTo,
+				onDelete: (fk.onDelete?.toUpperCase() as any) ?? 'NO ACTION',
+				onUpdate: (fk.onUpdate?.toUpperCase() as any) ?? 'NO ACTION',
+			});
+		}
+
+		for (const policy of Object.values(table.policies ?? {})) {
+			ddl.policies.push({
+				schema,
+				table: table.name,
+				name: policy.name,
+				as: policy.as ?? 'PERMISSIVE',
+				for: policy.for ?? 'ALL',
+				roles: policy.to ?? [],
+				using: policy.using ?? null,
+				withCheck: policy.withCheck ?? null,
+			});
+		}
+	}
+
+	for (const en of Object.values(json.enums)) {
+		ddl.enums.push({ schema: en.schema, name: en.name, values: en.values });
+	}
+
+	for (const role of Object.values(json.roles ?? {})) {
+		ddl.roles.push({
+			name: role.name,
+			createRole: role.createRole,
+			createDb: role.createDb,
+			inherit: role.inherit,
+			bypassRls: null,
+			canLogin: null,
+			connLimit: null,
+			password: null,
+			replication: null,
+			superuser: null,
+			validUntil: null,
+		});
+	}
+
+	for (const policy of Object.values(json.policies ?? {})) {
+		ddl.policies.push({
+			schema: policy.schema ?? 'public',
+			table: policy.on!,
+			name: policy.name,
+			as: policy.as ?? 'PERMISSIVE',
+			roles: policy.to ?? [],
+			for: policy.for ?? 'ALL',
+			using: policy.using ?? null,
+			withCheck: policy.withCheck ?? null,
+		});
+	}
+
+	for (const v of Object.values(json.views ?? {})) {
+		if (v.isExisting) continue;
+
+		const opt = v.with;
+		ddl.views.push({
+			schema: v.schema,
+			name: v.name,
+			definition: v.definition ?? null,
+			tablespace: v.tablespace ?? null,
+			withNoData: v.withNoData ?? null,
+			using: v.using ?? null,
+			with: opt
+				? {
+					checkOption: getOrNull(opt, 'checkOption'),
+					securityBarrier: getOrNull(opt, 'securityBarrier'),
+					securityInvoker: getOrNull(opt, 'securityInvoker'),
+					autovacuumEnabled: getOrNull(opt, 'autovacuumEnabled'),
+					autovacuumFreezeMaxAge: getOrNull(opt, 'autovacuumFreezeMaxAge'),
+					autovacuumFreezeMinAge: getOrNull(opt, 'autovacuumFreezeMinAge'),
+					autovacuumFreezeTableAge: getOrNull(
+						opt,
+						'autovacuumFreezeTableAge',
+					),
+					autovacuumMultixactFreezeMaxAge: getOrNull(
+						opt,
+						'autovacuumMultixactFreezeMaxAge',
+					),
+					autovacuumMultixactFreezeMinAge: getOrNull(
+						opt,
+						'autovacuumMultixactFreezeMinAge',
+					),
+					autovacuumMultixactFreezeTableAge: getOrNull(
+						opt,
+						'autovacuumMultixactFreezeTableAge',
+					),
+					autovacuumVacuumCostDelay: getOrNull(
+						opt,
+						'autovacuumVacuumCostDelay',
+					),
+					autovacuumVacuumCostLimit: getOrNull(
+						opt,
+						'autovacuumVacuumCostLimit',
+					),
+					autovacuumVacuumScaleFactor: getOrNull(
+						opt,
+						'autovacuumVacuumScaleFactor',
+					),
+					autovacuumVacuumThreshold: getOrNull(
+						opt,
+						'autovacuumVacuumThreshold',
+					),
+					fillfactor: getOrNull(opt, 'fillfactor'),
+					logAutovacuumMinDuration: getOrNull(
+						opt,
+						'logAutovacuumMinDuration',
+					),
+					parallelWorkers: getOrNull(opt, 'parallelWorkers'),
+					toastTupleTarget: getOrNull(opt, 'toastTupleTarget'),
+					userCatalogTable: getOrNull(opt, 'userCatalogTable'),
+					vacuumIndexCleanup: getOrNull(opt, 'vacuumIndexCleanup'),
+					vacuumTruncate: getOrNull(opt, 'vacuumTruncate'),
+				}
+				: null,
+			materialized: v.materialized,
+		});
+	}
+
+	const renames = [
+		...Object.entries(json._meta.tables).map(([k, v]) => `${v}->${k}`),
+		...Object.entries(json._meta.schemas).map(([k, v]) => `${v}->${k}`),
+		...Object.entries(json._meta.columns).map(([k, v]) => `${v}->${k}`),
+	];
+
+	return {
+		snapshot: {
+			id: json.id,
+			prevIds: [json.prevId],
+			version: '8',
+			dialect: 'postgres',
+			ddl: ddl.entities.list(),
+			renames,
+		},
+		hints,
+	};
+};
+
+export const extractBaseTypeAndDimensions = (it: string): [string, number] => {
+	const dimensionRegex = /\[[^\]]*\]/g; // matches any [something], including []
+	const count = (it.match(dimensionRegex) || []).length;
+	const baseType = it.replace(dimensionRegex, '');
+	return [baseType, count];
+};
+
+// Changed index format stored in snapshot for PostgreSQL in 0.22.0
+export const updateUpToV7 = (it: Record<string, any>): PgSchema => {
+	if (Number(it.version) < 6) return updateUpToV7(updateUpToV6(it));
+	const schema = it as PgSchemaV6;
+
+	const tables = Object.fromEntries(
+		Object.entries(schema.tables).map((it) => {
+			const table = it[1];
+			const mappedIndexes = Object.fromEntries(
+				Object.entries(table.indexes).map((idx) => {
+					const { columns, ...rest } = idx[1];
+					const mappedColumns = columns.map<LegacyIndex['columns'][number]>(
+						(it) => {
+							return {
+								expression: it,
+								isExpression: false,
+								asc: true,
+								nulls: 'last',
+								opClass: undefined,
+							};
+						},
+					);
+					return [idx[0], { columns: mappedColumns, with: {}, ...rest }];
+				}),
+			);
+			return [
+				it[0],
+				{
+					...table,
+					indexes: mappedIndexes,
+					policies: {},
+					isRLSEnabled: false,
+					checkConstraints: {},
+				},
+			];
+		}),
+	);
+
+	return {
+		...schema,
+		version: '7',
+		dialect: 'postgresql',
+		sequences: {},
+		tables: tables,
+		policies: {},
+		views: {},
+		roles: {},
+	};
+};
+
+export const updateUpToV6 = (it: Record<string, any>): PgSchemaV6 => {
+	if (Number(it.version) < 5) return updateUpToV6(updateToV5(it));
+	const schema = it as PgSchemaV5;
+
+	const tables = Object.fromEntries(
+		Object.entries(schema.tables).map((it) => {
+			const table = it[1];
+			const schema = table.schema || 'public';
+			return [`${schema}.${table.name}`, table];
+		}),
+	);
+	const enums = Object.fromEntries(
+		Object.entries(schema.enums).map((it) => {
+			const en = it[1];
+			return [
+				`public.${en.name}`,
+				{
+					name: en.name,
+					schema: 'public',
+					values: Object.values(en.values),
+				},
+			];
+		}),
+	);
+	return {
+		...schema,
+		version: '6',
+		dialect: 'postgresql',
+		tables: tables,
+		enums,
+	};
+};
+
+// major migration with of folder structure, etc...
+export const updateToV5 = (it: Record<string, any>): PgSchemaV5 => {
+	if (Number(it.version) < 4) throw new Error('Snapshot version <4');
+	const obj = it as PgSchemaV4;
+
+	const mappedTables: Record<string, TableV5> = {};
+	for (const [key, table] of Object.entries(obj.tables)) {
+		const mappedColumns: Record<string, Column> = {};
+		for (const [ckey, column] of Object.entries(table.columns)) {
+			let newDefault: any = column.default;
+			let newType: string = column.type;
+			if (column.type.toLowerCase() === 'date') {
+				if (typeof column.default !== 'undefined') {
+					if (column.default.startsWith("'") && column.default.endsWith("'")) {
+						newDefault = `'${
+							column.default
+								.substring(1, column.default.length - 1)
+								.split('T')[0]
+						}'`;
+					} else {
+						newDefault = column.default.split('T')[0];
+					}
+				}
+			} else if (column.type.toLowerCase().startsWith('timestamp')) {
+				if (typeof column.default !== 'undefined') {
+					if (column.default.startsWith("'") && column.default.endsWith("'")) {
+						newDefault = `'${
+							column.default
+								.substring(1, column.default.length - 1)
+								.replace('T', ' ')
+								.slice(0, 23)
+						}'`;
+					} else {
+						newDefault = column.default.replace('T', ' ').slice(0, 23);
+					}
+				}
+				newType = column.type
+					.toLowerCase()
+					.replace('timestamp (', 'timestamp(');
+			} else if (column.type.toLowerCase().startsWith('time')) {
+				newType = column.type.toLowerCase().replace('time (', 'time(');
+			} else if (column.type.toLowerCase().startsWith('interval')) {
+				newType = column.type.toLowerCase().replace(' (', '(');
+			}
+			mappedColumns[ckey] = { ...column, default: newDefault, type: newType };
+		}
+
+		mappedTables[key] = {
+			...table,
+			columns: mappedColumns,
+			compositePrimaryKeys: {},
+			uniqueConstraints: {},
+		};
+	}
+
+	return {
+		version: '5',
+		dialect: obj.dialect,
+		id: obj.id,
+		prevIds: obj.prevIds,
+		tables: mappedTables,
+		enums: obj.enums,
+		schemas: obj.schemas,
+		_meta: {
+			schemas: {} as Record<string, string>,
+			tables: {} as Record<string, string>,
+			columns: {} as Record<string, string>,
+		},
+	};
+};
diff --git a/drizzle-kit/src/dialects/pull-utils.ts b/drizzle-kit/src/dialects/pull-utils.ts
new file mode 100644
index 0000000000..3d9c0c2ce4
--- /dev/null
+++ b/drizzle-kit/src/dialects/pull-utils.ts
@@ -0,0 +1,186 @@
+import { Minimatch } from 'minimatch';
+import type { EntitiesFilter, ExtensionsFilter, SchemasFilter, TablesFilter } from '../cli/validations/common';
+import { assertUnreachable } from '../utils';
+import type { Dialect } from '../utils/schemaValidator';
+
+export type Schema = { type: 'schema'; name: string };
+export type Table = { type: 'table'; schema: string | false; name: string };
+export type Role = { type: 'role'; name: string };
+
+/*
+	there's a double edge sword with having narrow list here
+	on one hand we can filter other entities through these 3 types
+
+	on the other hand when debugged - you see schema/table filter invocation
+	for all other types like enums, sequences, etc.
+
+	I will leave this as is and in introspect I will rely on introspected schemas and tables
+	to filter list of dependent entities, that'd probably be the go to
+*/
+export type KitEntity = Schema | Table | Role;
+
+export type EntityFilter = (it: KitEntity) => boolean;
+
+export const prepareEntityFilter = (
+	dialect: Dialect,
+	params: {
+		tables: TablesFilter;
+		schemas: SchemasFilter;
+		entities: EntitiesFilter;
+		extensions: ExtensionsFilter;
+	},
+	/* .existing() in drizzle schema */
+	existingEntities: (Schema | Table)[],
+): EntityFilter => {
+	const tablesConfig = typeof params.tables === 'undefined'
+		? []
+		: typeof params.tables === 'string'
+		? [params.tables]
+		: params.tables;
+
+	const schemasConfig = typeof params.schemas === 'undefined'
+		? []
+		: typeof params.schemas === 'string'
+		? [params.schemas]
+		: params.schemas;
+
+	const existingSchemas = existingEntities.filter((x) => x.type === 'schema').map((x) => x.name);
+
+	const schemasFilter = prepareSchemasFitler(schemasConfig, existingSchemas);
+
+	const postgisTablesGlobs = ['!geography_columns', '!geometry_columns', '!spatial_ref_sys'];
+	for (const ext of params.extensions ?? []) {
+		if (ext === 'postgis') tablesConfig.push(...postgisTablesGlobs);
+		else assertUnreachable(ext);
+	}
+
+	const existingViews = existingEntities.filter((x) => x.type === 'table').map((x) => ({
+		schema: x.schema,
+		name: x.name,
+	}));
+	const tablesFilter = prepareTablesFilter(tablesConfig, existingViews);
+
+	const rolesFilter = prepareRolesFilter(params.entities);
+
+	const filter = (it: KitEntity) => {
+		if (it.type === 'schema') return schemasFilter(it);
+		if (it.type === 'table') {
+			if (it.schema === false) return tablesFilter(it);
+			return schemasFilter({ type: 'schema', name: it.schema }) && tablesFilter(it);
+		}
+		if (it.type === 'role') return rolesFilter(it);
+
+		assertUnreachable(it);
+	};
+
+	return (it) => {
+		const res = filter(it);
+		// console.log(res, it);
+		return res;
+	};
+};
+
+const prepareSchemasFitler = (globs: string[], schemasExisting: string[]) => {
+	const filterForExisting = (it: Schema) => {
+		return !schemasExisting.some((x) => it.name === x);
+	};
+
+	const matchers = globs.map((it) => {
+		return new Minimatch(it);
+	});
+
+	if (matchers.length === 0 && schemasExisting.length === 0) return () => true;
+	if (matchers.length === 0) return filterForExisting;
+
+	return (it: Schema) => {
+		if (!filterForExisting(it)) return false;
+
+		const flags: boolean[] = [];
+		for (let matcher of matchers) {
+			if (matcher.negate && !matcher.match(it.name)) {
+				flags.push(false);
+			} else if (matcher.match(it.name)) {
+				flags.push(true);
+			}
+		}
+
+		if (flags.length > 0) {
+			return flags.every(Boolean);
+		}
+
+		return false;
+	};
+};
+
+const prepareTablesFilter = (globs: string[], existingViews: { schema: string | false; name: string }[]) => {
+	const existingFilter = (it: Table) => {
+		if (it.schema === false) return !existingViews.some((x) => x.name === it.name);
+		return !existingViews.some((x) => x.schema === it.schema && x.name === it.name);
+	};
+
+	const matchers = globs.map((it) => {
+		return new Minimatch(it);
+	});
+	if (matchers.length === 0 && existingViews.length === 0) return () => true;
+	if (matchers.length === 0) return existingFilter;
+
+	const filter = (it: Table) => {
+		if (!existingFilter(it)) return false;
+
+		let flags: boolean[] = [];
+
+		for (let matcher of matchers) {
+			if (matcher.negate && !matcher.match(it.name)) {
+				flags.push(false);
+			} else if (matcher.match(it.name)) {
+				flags.push(true);
+			}
+		}
+
+		if (flags.length > 0) {
+			return flags.every(Boolean);
+		}
+		return false;
+	};
+	return filter;
+};
+
+const prepareRolesFilter = (entities: EntitiesFilter) => {
+	if (!entities || !entities.roles) return () => false;
+
+	const roles = entities.roles;
+	const include: string[] = typeof roles === 'object' ? roles.include ?? [] : [];
+	const exclude: string[] = typeof roles === 'object' ? roles.exclude ?? [] : [];
+	const provider = typeof roles === 'object' ? roles.provider : undefined;
+
+	if (provider === 'supabase') {
+		exclude.push(
+			'anon',
+			'authenticator',
+			'authenticated',
+			'service_role',
+			'supabase_auth_admin',
+			'supabase_storage_admin',
+			'dashboard_user',
+			'supabase_admin',
+		);
+	}
+
+	if (provider === 'neon') {
+		exclude.push('authenticated', 'anonymous');
+	}
+
+	const useRoles: boolean = typeof roles === 'boolean' ? roles : include.length > 0 || exclude.length > 0;
+
+	if (!useRoles) return () => false;
+	if (!include.length && !exclude.length) return () => true;
+
+	const rolesFilter: (it: { type: 'role'; name: string }) => boolean = (it) => {
+		const notExcluded = !exclude.length || !exclude.includes(it.name);
+		const included = !include.length || include.includes(it.name);
+
+		return notExcluded && included;
+	};
+
+	return rolesFilter;
+};
diff --git a/drizzle-kit/src/dialects/simpleValidator.ts b/drizzle-kit/src/dialects/simpleValidator.ts
new file mode 100644
index 0000000000..1cf157e50e
--- /dev/null
+++ b/drizzle-kit/src/dialects/simpleValidator.ts
@@ -0,0 +1,154 @@
+import type { Simplify } from '../utils';
+
+export const array = <T>(validate: (it: unknown) => boolean) => {
+	return {
+		type: {} as T,
+		validate,
+	};
+};
+
+type StringLiteral<T> = T extends string[] ? (string extends T[number] ? never : T[number]) : never;
+
+type SchemaType =
+	| 'string'
+	| 'string[]'
+	| 'number'
+	| 'boolean'
+	| 'array'
+	| 'record'
+	| number
+	| string[]
+	| ReturnType<typeof array>
+	| { [key: string]: SchemaType };
+
+type InferType<T> = T extends 'string' ? string
+	: T extends 'number' ? number
+	: T extends 'boolean' ? boolean
+	: T extends 'array' ? Array<any>
+	: T extends 'record' ? Record<string, string>
+	: T extends Array<string> ? StringLiteral<T>
+	: T extends string ? T
+	: T extends number ? T
+	: T extends boolean ? T
+	: T extends ReturnType<typeof array<infer I>> ? I[]
+	: T extends Record<string, SchemaType> ? { [K in keyof T]: InferType<T[K]> } | null
+	: never;
+
+type ResultShape<S extends Record<string, SchemaType>> = Simplify<
+	{
+		[K in keyof S]: InferType<S[K]>;
+	}
+>;
+
+type ValidationResult<T> = {
+	success: boolean;
+	data: T | null;
+	errors?: string[];
+};
+
+const validatorFor = (schema: Record<string, any>, path: string | undefined) => {
+	const validators = {} as Record<string, (it: unknown, path: string | undefined) => string | string[] | null>;
+	for (const [key, value] of Object.entries(schema)) {
+		if (value === 'string') {
+			validators[key] = (it: unknown) => {
+				return typeof it === 'string' ? null : `Field '${path}${key}' must be a string`;
+			};
+		} else if (value === 'number') {
+			validators[key] = (it: unknown) => {
+				return typeof it === 'number' ? null : `Field '${path}${key}' must be a number`;
+			};
+		} else if (value === 'boolean') {
+			validators[key] = (it: unknown) => {
+				return typeof it === 'boolean' ? null : `Field '${path}${key}' must be a boolean`;
+			};
+		} else if (value === 'array') {
+			validators[key] = (it: unknown) => {
+				return Array.isArray(it) ? null : `Field '${path}${key}' must be an array`;
+			};
+		} else if (value === 'record') {
+			validators[key] = (it: unknown) => {
+				return typeof it === 'object' ? null : `Field '${path}${key}' must be an object`;
+			};
+		} else if (Array.isArray(value)) {
+			// literal ["v1", "v2"] or [10, 20]
+			validators[key] = (it: unknown) => {
+				const msg = value.length === 1
+					? `Field '${key}' must be exactly '${path}${value[0]}'`
+					: `Field '${key}' must be exactly either of ['${value.join(', ')}']`;
+				return value.some((entry) => entry === it) ? null : msg;
+			};
+		} else if (typeof value === 'object') {
+			if ('type' in value && typeof value['type'] === 'object' && Object.keys(value['type']).length === 0) {
+				validators[key] = (it: unknown) => {
+					if (!Array.isArray(it)) return `Field '${path}${key}' must be an array`;
+
+					for (let item of it) {
+						const res = value['validate'](item);
+						if (!res) return `${path}${key} array contains invalid value:\n${JSON.stringify(item, null, 2)}`;
+					}
+
+					return null;
+				};
+			} else {
+				const validateRecord = validatorFor(value as Record<string, any>, `${key}.`);
+				validators[key] = (it: unknown) => {
+					if (it === null) return null;
+					return validateRecord(it as any);
+				};
+			}
+		}
+	}
+
+	const validate = (input: Record<string, unknown>): string[] => {
+		const errors: string[] = [];
+		for (const [key, validate] of Object.entries(validators)) {
+			const value = input[key];
+			if (value === undefined) {
+				errors.push(`Missing required field: ${path}${key}`);
+				continue;
+			}
+
+			const res = validate(value, path);
+			if (!res) continue;
+
+			if (typeof res === 'string') {
+				errors.push(res);
+			} else {
+				errors.push(...res);
+			}
+		}
+		return errors;
+	};
+
+	return validate;
+};
+
+export function validator<S extends Record<string, SchemaType>>(
+	schema: S,
+): {
+	shape: ResultShape<S>;
+	parse: (obj: unknown) => Simplify<ValidationResult<ResultShape<S>>>;
+	strict: (obj: unknown) => Simplify<ResultShape<S>>;
+} {
+	const validate = validatorFor(schema, '');
+
+	return {
+		shape: {} as any,
+		strict: (input: unknown) => {
+			const errors = validate(input as any);
+			if (errors.length > 0) {
+				throw new Error('Validation failed');
+			}
+			return input as any;
+		},
+		parse: (input: unknown) => {
+			const errors = validate(input as any);
+			const success = errors.length === 0;
+			return {
+				success,
+				data: success ? input as any : null,
+				errors: errors.length > 0 ? errors : undefined,
+			};
+		},
+	};
+}
diff --git a/drizzle-kit/src/dialects/singlestore/diff.ts b/drizzle-kit/src/dialects/singlestore/diff.ts
new file mode 100644
index 0000000000..6cfa065c7e
--- /dev/null
+++ b/drizzle-kit/src/dialects/singlestore/diff.ts
@@ -0,0 +1,51 @@
+import { mockResolver } from '../../utils/mocks';
+import type { Resolver } from '../common';
+import type { Column, MysqlDDL, Table, View } from '../mysql/ddl';
+import { ddlDiff as mysqlDdlDiff } from '../mysql/diff';
+import type { JsonStatement } from '../mysql/statements';
+
+export const ddlDiffDry = async (from: MysqlDDL, to: MysqlDDL) => {
+	const s = new Set<string>();
+	return ddlDiff(from, to, mockResolver(s), mockResolver(s), mockResolver(s), 'default');
+};
+
+export const ddlDiff = async (
+	ddl1: MysqlDDL,
+	ddl2: MysqlDDL,
+	tablesResolver: Resolver<Table>,
+	columnsResolver: Resolver<Column>,
+	viewsResolver: Resolver<View>,
+	mode: 'default' | 'push',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: { jsonStatement: JsonStatement; sqlStatements: string[] }[];
+	renames: string[];
+}> => {
+	const res = await mysqlDdlDiff(ddl1, ddl2, tablesResolver, columnsResolver, viewsResolver, mode);
+
+	const statements: JsonStatement[] = [];
+	const sqlStatements: string[] = [];
+
+	for (const it of res.groupedStatements) {
+		const st = it.jsonStatement;
+		if (st.type === 'create_index' && st.index.isUnique) continue;
+		if (st.type === 'alter_column') {
+			if (st.diff.type) continue;
+			if (st.diff.autoIncrement) continue;
+			if (st.diff.default && st.column.notNull) continue;
+			if (st.diff.notNull) continue;
+		}
+		if (st.type === 'create_pk' || st.type === 'drop_pk') continue;
+
+		statements.push(it.jsonStatement);
+		sqlStatements.push(...it.sqlStatements);
+	}
+
+	return {
+		statements,
+		sqlStatements,
+		groupedStatements: res.groupedStatements,
+		renames: res.renames,
+	};
+};
diff --git a/drizzle-kit/src/dialects/singlestore/drizzle.ts b/drizzle-kit/src/dialects/singlestore/drizzle.ts
new file mode 100644
index 0000000000..e730cbc7ee
--- /dev/null
+++ b/drizzle-kit/src/dialects/singlestore/drizzle.ts
@@ -0,0 +1,204 @@
+import { is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { AnySingleStoreColumn, AnySingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { getTableConfig, SingleStoreDialect, SingleStoreTable, uniqueKeyName } from 'drizzle-orm/singlestore-core';
+import { escapeSingleQuotes } from '../../utils';
+import { loadModule } from '../../utils/utils-node';
+import { sqlToStr } from '../drizzle';
+import type { Column, InterimSchema } from '../mysql/ddl';
+import { typeFor } from '../mysql/grammar';
+
+const handleEnumType = (type: string) => {
+	let str = type.split('(')[1];
+	str = str.substring(0, str.length - 1);
+	const values = str.split(',').map((v) => `'${escapeSingleQuotes(v.substring(1, v.length - 1))}'`);
+	return `enum(${values.join(',')})`;
+};
+
+export const defaultFromColumn = (column: AnySingleStoreColumn): Column['default'] => {
+	if (typeof column.default === 'undefined') return null;
+
+	if (is(column.default, SQL)) {
+		return sqlToStr(column.default);
+	}
+
+	const grammarType = typeFor(column.getSQLType().toLocaleLowerCase());
+	return grammarType.defaultFromDrizzle(column.default);
+};
+
+export const upper = <T extends string>(value: T | undefined): Uppercase<T> | null => {
+	if (!value) return null;
+	return value.toUpperCase() as Uppercase<T>;
+};
+
+export const fromDrizzleSchema = (
+	tables: AnySingleStoreTable[],
+): InterimSchema => {
+	const dialect = new SingleStoreDialect();
+	const result: InterimSchema = {
+		tables: [],
+		columns: [],
+		pks: [],
+		fks: [],
+		indexes: [],
+		checks: [],
+		views: [],
+		viewColumns: [],
+	};
+
+	for (const table of tables) {
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			schema,
+			primaryKeys,
+			uniqueConstraints,
+		} = getTableConfig(table);
+
+		if (schema) continue;
+
+		result.tables.push({
+			entityType: 'tables',
+			name: tableName,
+		});
+
+		for (const column of columns) {
+			const { name } = column;
+			const notNull: boolean = column.notNull;
+			const sqlType = column.getSQLType();
+			const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
+				? false
+				: (column as any).autoIncrement;
+
+			const generated = column.generated
+				? {
+					as: is(column.generated.as, SQL)
+						? dialect.sqlToQuery(column.generated.as as SQL).sql
+						: typeof column.generated.as === 'function'
+						? dialect.sqlToQuery(column.generated.as() as SQL).sql
+						: (column.generated.as as any),
+					type: column.generated.mode ?? 'stored',
+				}
+				: null;
+
+			result.columns.push({
+				entityType: 'columns',
+				table: tableName,
+				name,
+				type: sqlType.startsWith('enum') ? handleEnumType(sqlType) : sqlType,
+				notNull,
+				autoIncrement,
+				onUpdateNow: (column as any).hasOnUpdateNow ?? false, // TODO: ??
+				// @ts-expect-error
+				// TODO update description
+				// 'virtual' | 'stored' for all dialects
+				// 'virtual' | 'persisted' for mssql
+				// We should remove this option from common Column and store it per dialect common
+				// Was discussed with Andrew
+				// Type erorr because of common in drizzle orm for all dialects (includes virtual' | 'stored' | 'persisted')
+				generated,
+				isPK: column.primary,
+				isUnique: column.isUnique,
+				default: defaultFromColumn(column),
+			});
+		}
+
+		for (const pk of primaryKeys) {
+			const columnNames = pk.columns.map((c: any) => c.name);
+
+			let name = pk.getName();
+
+			result.pks.push({
+				entityType: 'pks',
+				table: tableName,
+				name: name,
+				columns: columnNames,
+			});
+		}
+
+		for (const unique of uniqueConstraints) {
+			const columns = unique.columns.map((c) => {
+				if (is(c, SQL)) {
+					const sql = dialect.sqlToQuery(c).sql;
+					return { value: sql, isExpression: true };
+				}
+				return { value: c.name, isExpression: false };
+			});
+
+			const name = unique.name ?? uniqueKeyName(table, unique.columns.filter((c) => !is(c, SQL)).map((c) => c.name));
+
+			result.indexes.push({
+				entityType: 'indexes',
+				table: tableName,
+				name: name,
+				columns: columns,
+				isUnique: true,
+				algorithm: null,
+				lock: null,
+				using: null,
+				nameExplicit: !!unique.name,
+			});
+		}
+
+		for (const index of indexes) {
+			const columns = index.config.columns;
+			const name = index.config.name;
+
+			result.indexes.push({
+				entityType: 'indexes',
+				table: tableName,
+				name,
+				columns: columns.map((it) => {
+					if (is(it, SQL)) {
+						const sql = dialect.sqlToQuery(it, 'indexes').sql;
+						return { value: sql, isExpression: true };
+					} else {
+						return { value: it.name, isExpression: false };
+					}
+				}),
+				algorithm: index.config.algorithm ?? null,
+				lock: index.config.lock ?? null,
+				isUnique: index.config.unique ?? false,
+				using: index.config.using ?? null,
+				nameExplicit: true,
+			});
+		}
+	}
+
+	return result;
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnySingleStoreTable[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = prepareFromExports(i0);
+
+		tables.push(...prepared.tables);
+		relations.push(...prepared.relations);
+	}
+
+	return { tables: Array.from(new Set(tables)), relations };
+};
+
+export const prepareFromExports = (exports: Record<string, unknown>) => {
+	const tables: AnySingleStoreTable[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (is(t, SingleStoreTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return { tables, relations };
+};
diff --git a/drizzle-kit/src/dialects/singlestore/serializer.ts b/drizzle-kit/src/dialects/singlestore/serializer.ts
new file mode 100644
index 0000000000..4bbd4e7fd3
--- /dev/null
+++ b/drizzle-kit/src/dialects/singlestore/serializer.ts
@@ -0,0 +1,77 @@
+import { findLeafSnapshotIds } from '../../utils/utils-node';
+import { createDDL, interimToDDL, type MysqlDDL } from '../mysql/ddl';
+import { drySnapshot, type SingleStoreSnapshot, snapshotValidator } from '../singlestore/snapshot';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from './drizzle';
+
+export const prepareSnapshot = async (
+	snapshots: string[],
+	filenames: string[],
+): Promise<{
+	ddlPrev: MysqlDDL;
+	ddlCur: MysqlDDL;
+	snapshot: SingleStoreSnapshot;
+	snapshotPrev: SingleStoreSnapshot;
+	custom: SingleStoreSnapshot;
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const prevSnapshot = snapshots.length === 0
+		? drySnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+
+	const res = await prepareFromSchemaFiles(filenames);
+
+	const interim = fromDrizzleSchema(res.tables);
+
+	// TODO: errors
+	// if (warnings.length > 0) {
+	// 	console.log(warnings.map((it) => schemaWarning(it)).join('\n\n'));
+	// }
+
+	// if (errors.length > 0) {
+	// 	console.log(errors.map((it) => schemaError(it)).join('\n'));
+	// 	process.exit(1);
+	// }
+
+	const { ddl: ddlCur, errors: _errors2 } = interimToDDL(interim);
+
+	// TODO: handle errors
+	// if (errors2.length > 0) {
+	// 	console.log(errors2.map((it) => schemaError(it)).join('\n'));
+	// 	process.exit(1);
+	// }
+
+	const id = randomUUID();
+	const prevIds = snapshots.length === 0 ? [prevSnapshot.id] : findLeafSnapshotIds(snapshots);
+
+	const snapshot = {
+		version: '2',
+		dialect: 'singlestore',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies SingleStoreSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	// that's for custom migrations, when we need new IDs, but old snapshot
+	const custom: SingleStoreSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return { ddlPrev, ddlCur, snapshot, snapshotPrev: prevSnapshot, custom };
+};
diff --git a/drizzle-kit/src/dialects/singlestore/snapshot.ts b/drizzle-kit/src/dialects/singlestore/snapshot.ts
new file mode 100644
index 0000000000..2c2bbf3c54
--- /dev/null
+++ b/drizzle-kit/src/dialects/singlestore/snapshot.ts
@@ -0,0 +1,174 @@
+import { randomUUID } from 'crypto';
+import { any, array as zArray, boolean, enum as enumType, literal, object, record, string, type TypeOf } from 'zod';
+import { originUUID } from '../../utils';
+import type { MysqlDDL, MysqlEntity } from '../mysql/ddl';
+import { createDDL } from '../mysql/ddl';
+import { array, validator } from '../simpleValidator';
+
+// ------- V3 --------
+const index = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	using: enumType(['btree', 'hash']).optional(),
+	algorithm: enumType(['default', 'inplace', 'copy']).optional(),
+	lock: enumType(['default', 'none', 'shared', 'exclusive']).optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(), // compatibility with postgres schema?
+	primaryKey: boolean(),
+	notNull: boolean(),
+	autoincrement: boolean().optional(),
+	default: any().optional(),
+	onUpdate: any().optional(),
+	generated: object({
+		type: enumType(['stored', 'virtual']),
+		as: string(),
+	}).optional(),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const table = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+// const viewMeta = object({
+// 	algorithm: enumType(['undefined', 'merge', 'temptable']),
+// 	sqlSecurity: enumType(['definer', 'invoker']),
+// 	withCheckOption: enumType(['local', 'cascaded']).optional(),
+// }).strict();
+
+/* export const view = object({
+	name: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	isExisting: boolean(),
+}).strict().merge(viewMeta);
+type SquasherViewMeta = Omit<TypeOf<typeof viewMeta>, 'definer'>; */
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isDefaultAnExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+	indexes: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+}).optional();
+
+// use main dialect
+const dialect = literal('singlestore');
+
+const schemaHashV1 = object({
+	id: string(),
+	prevId: string(),
+});
+
+const schemaHash = object({
+	id: string(),
+	prevIds: zArray(string()),
+});
+
+export const schemaInternal = object({
+	version: literal('1'),
+	dialect: dialect,
+	tables: record(string(), table),
+	/* views: record(string(), view).default({}), */
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaV1 = schemaInternal.merge(schemaHashV1);
+export const schema = schemaInternal.merge(schemaHash);
+
+const tableSquashed = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()).default({}),
+}).strict();
+
+/* const viewSquashed = view.omit({
+	algorithm: true,
+	sqlSecurity: true,
+	withCheckOption: true,
+}).extend({ meta: string() }); */
+
+export const schemaSquashed = object({
+	version: literal('1'),
+	dialect: dialect,
+	tables: record(string(), tableSquashed),
+	/* views: record(string(), viewSquashed), */
+}).strict();
+
+export type Dialect = TypeOf<typeof dialect>;
+export type Column = TypeOf<typeof column>;
+export type Table = TypeOf<typeof table>;
+export type SingleStoreSchema = TypeOf<typeof schema>;
+export type SingleStoreSchemaInternal = TypeOf<typeof schemaInternal>;
+export type SingleStoreKitInternals = TypeOf<typeof kitInternals>;
+export type SingleStoreSchemaSquashed = TypeOf<typeof schemaSquashed>;
+export type Index = TypeOf<typeof index>;
+export type PrimaryKey = TypeOf<typeof compositePK>;
+export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
+
+export type SchemaV1 = TypeOf<typeof schemaV1>;
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['2'],
+	dialect: ['singlestore'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<MysqlEntity>((it) => ddl.entities.validate(it)),
+	renames: array<string>((_) => true),
+});
+
+export type SingleStoreSnapshot = typeof snapshotValidator.shape;
+
+export const toJsonSnapshot = (ddl: MysqlDDL, prevIds: string[], renames: string[]): SingleStoreSnapshot => {
+	return { dialect: 'singlestore', id: randomUUID(), prevIds, version: '2', ddl: ddl.entities.list(), renames };
+};
+
+export const drySnapshot = snapshotValidator.strict(
+	{
+		version: '2',
+		dialect: 'singlestore',
+		id: originUUID,
+		prevIds: [],
+		ddl: [],
+		renames: [],
+	} satisfies SingleStoreSnapshot,
+);
diff --git a/drizzle-kit/src/dialects/sqlite/commutativity.ts b/drizzle-kit/src/dialects/sqlite/commutativity.ts
new file mode 100644
index 0000000000..80df66ff39
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/commutativity.ts
@@ -0,0 +1,289 @@
+import {
+	AbstractCommutativity,
+	type CommutativityStatementDefinitions,
+	type CommutativityStatementInfo,
+} from '../../commutativity/engine';
+import type { ConflictTarget } from '../../commutativity/types';
+import { createDDL, type SQLiteDDL } from './ddl';
+import { ddlDiffDry } from './diff';
+import { drySqliteSnapshot, type SqliteSnapshot } from './snapshot';
+import type { JsonStatement } from './statements';
+
+type FootprintTarget = {
+	objectName: string;
+	columnName: string;
+};
+
+type StatementInfo = CommutativityStatementInfo<JsonStatement, FootprintTarget>;
+
+type StatementDefinitions = CommutativityStatementDefinitions<
+	JsonStatement,
+	FootprintTarget
+>;
+
+function makeTarget(objectName: string, columnName = ''): FootprintTarget {
+	return { objectName, columnName };
+}
+
+/**
+ * SQLite-specific commutativity rules.
+ *
+ * How to read this file:
+ * - `getStatementDefinitions()` is the main source of truth.
+ * - Each statement definition answers two questions:
+ *   1. `conflicts`: which other statement types are incompatible with this one.
+ *   2. `buildInfo`: which resource footprints this statement occupies.
+ * - `buildInfo().primary` is the exact resource touched by the statement.
+ * - `buildInfo().ancestors` are explicit parent resources, usually the owning table.
+ * - SQLite has no schemas, so matching is driven by exact targets plus table ancestors.
+ *
+ * Notes specific to SQLite:
+ * - `recreate_table` is a compound statement produced by the diff engine when a
+ *   table needs to be rebuilt (constraint changes, type changes, etc.). It
+ *   broadly conflicts with anything that touches the table.
+ * - `recreate_column` is used for column changes that require recreation
+ *   (e.g. switching to/from a generated expression).
+ *
+ * Practical guide for fixes:
+ * - False positive or missed conflict for same-level objects (column->column,
+ *   index->index, table->table, view->view): edit the `conflicts` array.
+ * - False positive or missed conflict for parent/child relations
+ *   (table->column, table->index): adjust the child's `ancestors` and/or the
+ *   parent's `conflicts` array.
+ * - Wrong human-readable message only: change `describeStatement()` or
+ *   `schemaLevelActions`. Those affect reporting, not matching semantics.
+ */
+class SqliteCommutativity extends AbstractCommutativity<
+	JsonStatement,
+	SqliteSnapshot,
+	FootprintTarget
+> {
+	private schemaLevelActions = new Set<JsonStatement['type']>([
+		'create_table',
+		'drop_table',
+		'rename_table',
+		'recreate_table',
+		'create_view',
+		'drop_view',
+		'rename_view',
+	]);
+
+	protected override getStatementDefinitions(): StatementDefinitions {
+		return {
+			// Table operations
+			create_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'recreate_table',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table.name),
+					ancestors: [],
+				}),
+			},
+			drop_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'recreate_table',
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+					'create_index',
+					'drop_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.tableName),
+					ancestors: [],
+				}),
+			},
+			rename_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'recreate_table',
+					'create_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from),
+					ancestors: [],
+				}),
+			},
+			recreate_table: {
+				conflicts: [
+					'create_table',
+					'drop_table',
+					'rename_table',
+					'recreate_table',
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+					'create_index',
+					'drop_index',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.to.name),
+					ancestors: [],
+				}),
+			},
+
+			// Column operations
+			add_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			drop_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			recreate_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.column.table, statement.column.name),
+					ancestors: [makeTarget(statement.column.table)],
+				}),
+			},
+			rename_column: {
+				conflicts: [
+					'add_column',
+					'drop_column',
+					'recreate_column',
+					'rename_column',
+				],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.table, statement.from),
+					ancestors: [makeTarget(statement.table)],
+				}),
+			},
+
+			// Index operations
+			create_index: {
+				conflicts: ['create_index', 'drop_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.table, statement.index.name),
+					ancestors: [makeTarget(statement.index.table)],
+				}),
+			},
+			drop_index: {
+				conflicts: ['create_index', 'drop_index'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.index.table, statement.index.name),
+					ancestors: [makeTarget(statement.index.table)],
+				}),
+			},
+
+			// View operations
+			create_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.name),
+					ancestors: [],
+				}),
+			},
+			drop_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.view.name),
+					ancestors: [],
+				}),
+			},
+			rename_view: {
+				conflicts: ['create_view', 'drop_view', 'rename_view'],
+				buildInfo: (statement) => ({
+					primary: makeTarget(statement.from.name),
+					ancestors: [],
+				}),
+			},
+		};
+	}
+
+	protected override formatFootprintTarget(
+		action: JsonStatement['type'],
+		target: FootprintTarget,
+	): string {
+		return `${action};${target.objectName};${target.columnName}`;
+	}
+
+	protected override describeStatement(
+		_statement: JsonStatement,
+		info: StatementInfo,
+	): string {
+		if (this.schemaLevelActions.has(info.action)) {
+			return `${info.action}: ${info.primary.objectName} in database`;
+		}
+
+		if (info.primary.columnName) {
+			return `${info.action}: ${info.primary.columnName} on ${info.primary.objectName} table`;
+		}
+
+		return `${info.action} on ${info.primary.objectName} table`;
+	}
+
+	private viewLevelActions = new Set<JsonStatement['type']>([
+		'create_view',
+		'drop_view',
+		'rename_view',
+	]);
+
+	protected override describeStatementTarget(
+		_statement: JsonStatement,
+		info: StatementInfo,
+	): ConflictTarget {
+		if (this.viewLevelActions.has(info.action)) {
+			return { kind: 'view', name: info.primary.objectName };
+		}
+
+		if (info.primary.columnName) {
+			return { kind: 'column', name: info.primary.columnName, table: info.primary.objectName };
+		}
+
+		return { kind: 'table', name: info.primary.objectName };
+	}
+
+	protected override getDrySnapshot(): SqliteSnapshot {
+		return drySqliteSnapshot;
+	}
+
+	protected override async diffSnapshots(
+		fromSnapshot: SqliteSnapshot,
+		toSnapshot: SqliteSnapshot,
+	): Promise<{ statements: JsonStatement[] }> {
+		const fromDDL: SQLiteDDL = createDDL();
+		const toDDL: SQLiteDDL = createDDL();
+
+		fromDDL.entities.pushAll(fromSnapshot.ddl);
+		toDDL.entities.pushAll(toSnapshot.ddl);
+
+		const { statements } = await ddlDiffDry(fromDDL, toDDL, 'default');
+		return { statements };
+	}
+}
+
+export const sqliteCommutativity = new SqliteCommutativity();
diff --git a/drizzle-kit/src/dialects/sqlite/convertor.ts b/drizzle-kit/src/dialects/sqlite/convertor.ts
new file mode 100644
index 0000000000..a69fbeb1c3
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/convertor.ts
@@ -0,0 +1,267 @@
+import type { Simplify } from '../../utils';
+import type { JsonStatement } from './statements';
+
+export const convertor = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	convertor: (statement: Simplify<Omit<TStatement, 'type'>>) => string | string[],
+) => {
+	return {
+		type,
+		can: (st: JsonStatement) => {
+			return st.type === type;
+		},
+		convert: convertor,
+	};
+};
+
+const createTable = convertor('create_table', (st) => {
+	const {
+		name: tableName,
+		columns,
+		fks: referenceData,
+		pk,
+		uniques: uniqueConstraints,
+		checks: checkConstraints,
+	} = st.table;
+
+	let statement = '';
+	statement += `CREATE TABLE \`${tableName}\` (\n`;
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+
+		/*
+			https://www.sqlite.org/lang_createtable.html#the_generated_always_as_clause
+
+			According to the SQL standard, PRIMARY KEY should always imply NOT NULL.
+			Unfortunately, due to a bug in some early versions, this is not the case in SQLite.
+			Unless the column is an INTEGER PRIMARY KEY or the table is a WITHOUT ROWID table
+			or a STRICT table or the column is declared NOT NULL,
+			SQLite allows NULL values in a PRIMARY KEY column.
+			SQLite could be fixed to conform to the standard, but doing so
+			might break legacy applications. Hence, it has been decided to merely document the fact
+			that SQLite allows NULLs in most PRIMARY KEY columns.
+		 */
+		const isColumnPk = pk && pk.columns.length === 1 && pk.columns[0] === column.name && pk.table === column.table;
+		const omitNotNull = isColumnPk && column.type.toLowerCase().startsWith('int');
+
+		const primaryKeyStatement = isColumnPk && !pk.nameExplicit
+			? ' PRIMARY KEY'
+			: '';
+		const notNullStatement = column.notNull && !omitNotNull ? ' NOT NULL' : '';
+
+		const unique = uniqueConstraints.find((u) =>
+			u.columns.length === 1 && u.columns[0] === column.name && u.table === column.table
+		);
+		const unqiueConstraintPrefix = unique
+			? unique.nameExplicit ? ` CONSTRAINT \`${unique.name}\` UNIQUE` : ' UNIQUE'
+			: '';
+
+		// in SQLite we escape single quote by doubling it, `'`->`''`, but we don't do it here
+		// because it is handled by drizzle orm serialization or on drizzle studio side
+		const defaultStatement = column.default ? ` DEFAULT ${column.default ?? ''}` : '';
+
+		const autoincrementStatement = column.autoincrement ? ' AUTOINCREMENT' : '';
+
+		const generatedStatement = column.generated
+			? ` GENERATED ALWAYS AS ${column.generated.as} ${column.generated.type.toUpperCase()}`
+			: '';
+
+		statement += '\t';
+		statement +=
+			`\`${column.name}\` ${column.type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${unqiueConstraintPrefix}`;
+
+		statement += i === columns.length - 1 ? '' : ',\n';
+	}
+
+	if (pk && (pk.columns.length > 1 || pk.nameExplicit)) {
+		statement += ',\n\t';
+		statement += `CONSTRAINT \`${pk.name}\` PRIMARY KEY(${pk.columns.map((it) => `\`${it}\``).join(', ')})`;
+	}
+
+	for (let i = 0; i < referenceData.length; i++) {
+		const {
+			name,
+			tableTo,
+			columns,
+			columnsTo,
+			onDelete,
+			onUpdate,
+		} = referenceData[i];
+
+		const onDeleteStatement = (onDelete && onDelete !== 'NO ACTION') ? ` ON DELETE ${onDelete}` : '';
+		const onUpdateStatement = (onUpdate && onUpdate !== 'NO ACTION') ? ` ON UPDATE ${onUpdate}` : '';
+		const fromColumnsString = columns.map((it) => `\`${it}\``).join(',');
+		const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
+
+		statement += ',';
+		statement += '\n\t';
+		statement +=
+			`CONSTRAINT \`${name}\` FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onUpdateStatement}${onDeleteStatement}`;
+	}
+
+	for (const uniqueConstraint of uniqueConstraints.filter((u) => u.columns.length > 1)) {
+		statement += ',\n';
+		statement += `\tCONSTRAINT \`${uniqueConstraint.name}\` UNIQUE(\`${uniqueConstraint.columns.join(`\`,\``)}\`)`;
+	}
+
+	if (
+		typeof checkConstraints !== 'undefined'
+		&& checkConstraints.length > 0
+	) {
+		for (const check of checkConstraints) {
+			statement += ',\n';
+			statement += `\tCONSTRAINT "${check.name}" CHECK(${check.value})`;
+		}
+	}
+
+	statement += `\n`;
+	statement += `);`;
+	statement += `\n`;
+	return statement;
+});
+
+const dropTable = convertor('drop_table', (st) => {
+	return `DROP TABLE \`${st.tableName}\`;`;
+});
+
+const renameTable = convertor('rename_table', (st) => {
+	return `ALTER TABLE \`${st.from}\` RENAME TO \`${st.to}\`;`;
+});
+
+const createView = convertor('create_view', (st) => {
+	const { definition, name } = st.view;
+	return `CREATE VIEW \`${name}\` AS ${definition};`;
+});
+
+const dropView = convertor('drop_view', (st) => {
+	return `DROP VIEW \`${st.view.name}\`;`;
+});
+
+const alterTableAddColumn = convertor('add_column', (st) => {
+	const { fk, column } = st;
+	const { table: tableName, name, type, notNull, generated } = st.column;
+
+	const defaultStatement = column.default !== null ? ` DEFAULT ${column.default ?? ''}` : '';
+
+	const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+
+	let referenceStatement = '';
+	if (fk) {
+		const onDeleteStatement = (fk.onDelete && fk.onDelete !== 'NO ACTION') ? ` ON DELETE ${fk.onDelete}` : '';
+		const onUpdateStatement = (fk.onUpdate && fk.onUpdate !== 'NO ACTION') ? ` ON UPDATE ${fk.onUpdate}` : '';
+
+		referenceStatement = !fk.nameExplicit
+			? ` REFERENCES ${fk.tableTo}(${fk.columnsTo})${onUpdateStatement}${onDeleteStatement}`
+			: ` CONSTRAINT \`${fk.name}\` REFERENCES ${fk.tableTo}(${fk.columnsTo})${onUpdateStatement}${onDeleteStatement}`;
+	}
+
+	const generatedStatement = generated
+		? ` GENERATED ALWAYS AS ${generated.as} ${generated.type.toUpperCase()}`
+		: '';
+
+	return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${defaultStatement}${generatedStatement}${notNullStatement}${referenceStatement};`;
+});
+
+const alterTableRenameColumn = convertor('rename_column', (st) => {
+	return `ALTER TABLE \`${st.table}\` RENAME COLUMN \`${st.from}\` TO \`${st.to}\`;`;
+});
+
+const alterTableDropColumn = convertor('drop_column', (st) => {
+	return `ALTER TABLE \`${st.column.table}\` DROP COLUMN \`${st.column.name}\`;`;
+});
+
+const alterTableRecreateColumn = convertor('recreate_column', (st) => {
+	const drop = alterTableDropColumn.convert(st) as string;
+	const add = alterTableAddColumn.convert(st) as string;
+
+	return [drop, add];
+});
+
+const createIndex = convertor('create_index', (st) => {
+	const { columns, isUnique, where, name, table } = st.index;
+
+	const idx = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+	const onStatement = columns.map((it) => it.isExpression ? it.value : `\`${it.value}\``).join(',');
+	const whereStatement = where ? ` WHERE ${where}` : '';
+
+	return `CREATE ${idx} \`${name}\` ON \`${table}\` (${onStatement})${whereStatement};`;
+});
+
+const dropIndex = convertor('drop_index', (st) => {
+	return `DROP INDEX IF EXISTS \`${st.index.name}\`;`;
+});
+
+const recreateTable = convertor('recreate_table', (st) => {
+	const { name } = st.to;
+	const { columns: columnsFrom } = st.from;
+
+	const columnNames = columnsFrom.filter((it) => {
+		const newColumn = st.to.columns.find((col) => col.name === it.name);
+		return !it.generated && newColumn && !newColumn.generated;
+	}).map((it) => `\`${it.name}\``).join(', ');
+	const newTableName = `__new_${name}`;
+
+	const sqlStatements: string[] = [];
+
+	sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
+
+	const tmpTable = {
+		...st.to,
+		name: newTableName,
+		checks: st.to.checks.map((it) => ({ ...it, table: newTableName })),
+	};
+	sqlStatements.push(createTable.convert({ table: tmpTable }) as string);
+
+	sqlStatements.push(
+		`INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${st.to.name}\`;`,
+	);
+	sqlStatements.push(dropTable.convert({ tableName: name }) as string);
+	sqlStatements.push(renameTable.convert({ from: newTableName, to: name }) as string);
+
+	sqlStatements.push(`PRAGMA foreign_keys=ON;`);
+
+	return sqlStatements;
+});
+
+const convertors = [
+	createTable,
+	dropTable,
+	renameTable,
+	createView,
+	dropView,
+	alterTableAddColumn,
+	alterTableRenameColumn,
+	alterTableDropColumn,
+	alterTableRecreateColumn,
+	createIndex,
+	dropIndex,
+	recreateTable,
+];
+
+export function fromJson(statements: JsonStatement[]) {
+	const grouped = statements
+		.map((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+			if (!convertor) {
+				return null;
+			}
+
+			const sqlStatements = convertor.convert(statement as any);
+			const statements = typeof sqlStatements === 'string' ? [sqlStatements] : sqlStatements;
+			return { jsonStatement: statement, sqlStatements: statements };
+		})
+		.filter((it) => it !== null);
+
+	const result = {
+		sqlStatements: grouped.map((it) => it.sqlStatements).flat(),
+		groupedStatements: grouped,
+	};
+	return result;
+}
diff --git a/drizzle-kit/src/dialects/sqlite/ddl.ts b/drizzle-kit/src/dialects/sqlite/ddl.ts
new file mode 100644
index 0000000000..7dec7668c7
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/ddl.ts
@@ -0,0 +1,329 @@
+import type { SchemaForPull } from '../../cli/commands/pull-common';
+import { create } from '../dialect';
+import { nameForPk, nameForUnique } from './grammar';
+
+export const createDDL = () => {
+	return create({
+		tables: {},
+		columns: {
+			table: 'required',
+			type: 'string',
+			notNull: 'boolean',
+			autoincrement: 'boolean?',
+			default: 'string?',
+			generated: {
+				type: ['stored', 'virtual'],
+				as: 'string',
+			},
+		},
+		indexes: {
+			table: 'required',
+			columns: [{
+				value: 'string',
+				isExpression: 'boolean',
+			}],
+			isUnique: 'boolean',
+			where: 'string?',
+			origin: [
+				'manual', // ='c' CREATE INDEX
+				'auto', // ='u' UNIQUE auto created
+			], // https://www.sqlite.org/pragma.html#pragma_index_list
+		},
+		// Names for fk was decided to leave as is after discussion with @AlexBlokh
+		// Discussion was about removing "name" from ts schema
+		//
+		// introspect will parse ddl and find names. Old kit (before beta v1) did not add names to fk in sql migrations
+		// after upping to beta v1 there would be recreate table to correct name for push if name was explicitly set by user
+		//
+		// We already have tests on preserving names after renaming tables/columns
+		// It was important that newcomers would not experience any issues
+		fks: {
+			table: 'required',
+			columns: 'string[]',
+			tableTo: 'string',
+			columnsTo: 'string[]',
+			onUpdate: 'string',
+			onDelete: 'string',
+			nameExplicit: 'boolean',
+		},
+		pks: {
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+		},
+		/**
+		 * Unique constraints and unique indexes are functionally identical in terms of behavior
+		 * We decided to keep both constraints and indexes because when a unique constraint is created
+		 * it cannot be removed, whereas an index can be dropped
+		 * Removing unique constraints would require recreating the table
+		 * Before the beta v1 all unique constraints were created and stored in snapshots as indexes
+		 * We do not have sufficient information for upping snapshots to beta v1
+		 */
+		uniques: {
+			table: 'required',
+			columns: 'string[]',
+			nameExplicit: 'boolean',
+		},
+		checks: {
+			table: 'required',
+			value: 'string',
+		},
+		views: {
+			definition: 'string?',
+			isExisting: 'boolean',
+			error: 'string?',
+		},
+	});
+};
+
+export type SQLiteDDL = ReturnType<typeof createDDL>;
+
+export type SqliteEntities = SQLiteDDL['_']['types'];
+export type SqliteEntity = SqliteEntities[keyof SqliteEntities];
+export type SqliteDefinition = SQLiteDDL['_']['definition'];
+export type SqliteDiffEntities = SQLiteDDL['_']['diffs'];
+
+export type DiffColumn = SqliteDiffEntities['alter']['columns'];
+export type DiffEntities = SQLiteDDL['_']['diffs']['alter'];
+
+export type Table = SqliteEntities['tables'];
+export type Column = SqliteEntities['columns'];
+export type CheckConstraint = SqliteEntities['checks'];
+export type Index = SqliteEntities['indexes'];
+export type IndexColumn = Index['columns'][number];
+export type ForeignKey = SqliteEntities['fks'];
+export type PrimaryKey = SqliteEntities['pks'];
+export type UniqueConstraint = SqliteEntities['uniques'];
+export type View = SqliteEntities['views'];
+export type ViewColumn = { view: string; name: string; type: string; notNull: boolean };
+
+export type TableFull = {
+	name: string;
+	columns: Column[];
+	indexes: Index[];
+	checks: CheckConstraint[];
+	uniques: UniqueConstraint[];
+	pk: PrimaryKey | null;
+	fks: ForeignKey[];
+};
+
+export const tableFromDDL = (name: string, ddl: SQLiteDDL): TableFull => {
+	const filter = { table: name } as const;
+	const columns = ddl.columns.list(filter);
+	const pk = ddl.pks.one(filter);
+	const fks = ddl.fks.list(filter);
+	const uniques = ddl.uniques.list(filter);
+	const checks = ddl.checks.list(filter);
+	const indexes = ddl.indexes.list(filter);
+	return {
+		name,
+		columns,
+		pk,
+		fks,
+		uniques,
+		checks,
+		indexes,
+	};
+};
+
+export type ConflictTable = {
+	type: 'conflict_table';
+	table: string;
+};
+
+export type TableNoColumns = {
+	type: 'table_no_columns';
+	table: string;
+};
+
+export type ConflictView = {
+	type: 'conflict_view';
+	view: string;
+};
+
+export type ConflictColumn = {
+	type: 'conflict_column';
+	table: string;
+	column: string;
+};
+export type ConflictIndex = {
+	type: 'conflict_index';
+	name: string;
+};
+
+export type ConflictFK = {
+	type: 'conflict_fk';
+	name: string;
+};
+export type ConflictPK = {
+	type: 'conflict_pk';
+	name: string;
+};
+export type ConflictUnique = {
+	type: 'conflict_unique';
+	name: string;
+};
+
+export type ConflictCheck = {
+	type: 'conflict_check';
+	name: string;
+};
+
+export type SchemaError =
+	| ConflictTable
+	| ConflictView
+	| ConflictColumn
+	| ConflictPK
+	| ConflictFK
+	| ConflictUnique
+	| ConflictCheck
+	| ConflictIndex
+	| TableNoColumns;
+
+const count = <T>(arr: T[], predicate: (it: T) => boolean) => {
+	let count = 0;
+	for (const it of arr) {
+		if (predicate(it)) count += 1;
+	}
+	return count;
+};
+
+export type InterimColumn = Column & {
+	pk: boolean;
+	pkName: string | null;
+} & { isUnique: boolean; uniqueName: string | null };
+export type InterimSchema = {
+	tables: Table[];
+	columns: InterimColumn[];
+	indexes: Index[];
+	checks: CheckConstraint[];
+	uniques: UniqueConstraint[];
+	pks: PrimaryKey[];
+	fks: ForeignKey[];
+	views: View[];
+};
+
+export const fromEntities = (entities: SqliteEntity[]) => {
+	const ddl = createDDL();
+	for (const it of entities) {
+		ddl.entities.push(it);
+	}
+
+	return ddl;
+};
+
+export const interimToDDL = (schema: InterimSchema): { ddl: SQLiteDDL; errors: SchemaError[] } => {
+	const ddl = createDDL();
+	const errors: SchemaError[] = [];
+
+	for (const table of schema.tables) {
+		if (count(schema.columns, (it) => it.table === table.name) === 0) {
+			errors.push({ type: 'table_no_columns', table: table.name });
+			continue;
+		}
+		const res = ddl.tables.push(table);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_table', table: res.data.name });
+		}
+	}
+
+	for (const column of schema.columns) {
+		const { isUnique: _1, uniqueName: _2, pk: _3, pkName: _4, ...rest } = column;
+		const res = ddl.columns.push(rest);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_column', table: column.table, column: column.name });
+		}
+	}
+
+	for (const fk of schema.fks) {
+		const res = ddl.fks.push(fk);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_fk', name: fk.name });
+		}
+	}
+	for (const pk of schema.pks) {
+		const res = ddl.pks.push(pk);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_pk', name: pk.name });
+		}
+	}
+
+	for (const column of schema.columns.filter((it) => it.pk)) {
+		const name = column.pkName !== null ? column.pkName : nameForPk(column.table);
+		const exists = ddl.pks.one({ table: column.table }) !== null;
+		if (exists) continue;
+
+		ddl.pks.push({
+			table: column.table,
+			name,
+			nameExplicit: column.pkName !== null,
+			columns: [column.name],
+		});
+	}
+
+	for (const index of schema.indexes) {
+		const { status } = ddl.indexes.push(index, ['name']); // indexes have to have unique names across all schema
+		if (status === 'CONFLICT') {
+			errors.push({ type: 'conflict_index', name: index.name });
+		}
+	}
+
+	for (const unique of schema.uniques) {
+		const res = ddl.uniques.push(unique);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_unique', name: unique.name });
+		}
+	}
+
+	for (const it of schema.columns.filter((it) => it.isUnique)) {
+		const u = {
+			entityType: 'uniques',
+			name: it.uniqueName ?? nameForUnique(it.table, [it.name]),
+			columns: [it.name],
+			table: it.table,
+			nameExplicit: !!it.uniqueName,
+		} satisfies UniqueConstraint;
+
+		const res = ddl.uniques.push(u);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_unique', name: u.name });
+		}
+	}
+
+	for (const check of schema.checks) {
+		const res = ddl.checks.push(check);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_check', name: res.data.name });
+		}
+	}
+
+	for (const view of schema.views) {
+		const res = ddl.views.push(view);
+		if (res.status === 'CONFLICT') {
+			errors.push({ type: 'conflict_view', view: view.name });
+		}
+	}
+
+	return { ddl, errors };
+};
+
+export function sqliteToRelationsPull(schema: SQLiteDDL): SchemaForPull {
+	return Object.values(schema.tables.list()).map((table) => {
+		const rawTable = tableFromDDL(table.name, schema);
+		return {
+			foreignKeys: rawTable.fks,
+			uniques: [
+				...Object.values(rawTable.uniques).map((unq) => ({
+					columns: unq.columns,
+				})),
+				...Object.values(rawTable.indexes).map((idx) => ({
+					columns: idx.columns.map((idxc) => {
+						if (!idxc.isExpression && idx.isUnique) {
+							return idxc.value;
+						}
+					}).filter((item) => item !== undefined),
+				})),
+			],
+		};
+	});
+}
diff --git a/drizzle-kit/src/dialects/sqlite/diff.ts b/drizzle-kit/src/dialects/sqlite/diff.ts
new file mode 100644
index 0000000000..ebfd30fc41
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/diff.ts
@@ -0,0 +1,440 @@
+import { prepareMigrationRenames } from '../../utils';
+import { mockResolver } from '../../utils/mocks';
+import type { Resolver } from '../common';
+import { diff } from '../dialect';
+import { groupDiffs, preserveEntityNames } from '../utils';
+import { fromJson } from './convertor';
+import type { Column, IndexColumn, SQLiteDDL, SqliteEntities } from './ddl';
+import { tableFromDDL } from './ddl';
+import { defaultsCommutative } from './grammar';
+import type { JsonCreateViewStatement, JsonDropViewStatement, JsonStatement } from './statements';
+import { prepareAddColumns, prepareRecreateColumn, prepareStatement } from './statements';
+
+export const ddlDiffDry = async (left: SQLiteDDL, right: SQLiteDDL, mode: 'push' | 'default') => {
+	const empty = new Set<string>();
+	return ddlDiff(left, right, mockResolver(empty), mockResolver(empty), mode);
+};
+
+export const ddlDiff = async (
+	ddl1: SQLiteDDL,
+	ddl2: SQLiteDDL,
+	tablesResolver: Resolver<SqliteEntities['tables']>,
+	columnsResolver: Resolver<Column>,
+	mode: 'push' | 'default',
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	groupedStatements: {
+		jsonStatement: JsonStatement;
+		sqlStatements: string[];
+	}[];
+	renames: string[];
+	warnings: string[];
+}> => {
+	const tablesDiff = diff(ddl1, ddl2, 'tables');
+
+	const { created: createdTables, deleted: deletedTables, renamedOrMoved: renamedTables } = await tablesResolver({
+		created: tablesDiff.filter((it) => it.$diffType === 'create'),
+		deleted: tablesDiff.filter((it) => it.$diffType === 'drop'),
+	});
+
+	for (const renamed of renamedTables) {
+		ddl1.tables.update({
+			set: {
+				name: renamed.to.name,
+			},
+			where: {
+				name: renamed.from.name,
+			},
+		});
+
+		ddl1.fks.update({
+			set: {
+				tableTo: renamed.to.name,
+			},
+			where: {
+				tableTo: renamed.from.name,
+			},
+		});
+		ddl2.fks.update({
+			set: {
+				tableTo: renamed.to.name,
+			},
+			where: {
+				tableTo: renamed.from.name,
+			},
+		});
+		ddl1.fks.update({
+			set: {
+				table: renamed.to.name,
+			},
+			where: {
+				table: renamed.from.name,
+			},
+		});
+
+		ddl1.entities.update({
+			set: {
+				table: renamed.to.name,
+			},
+			where: {
+				table: renamed.from.name,
+			},
+		});
+	}
+
+	const columnsDiff = diff(ddl1, ddl2, 'columns').filter((it) =>
+		!createdTables.some((table) => table.name === it.table)
+	); // filter out columns for newly created tables
+
+	const groupedByTable = groupDiffs(columnsDiff);
+
+	const columnRenames = [] as { from: Column; to: Column }[];
+	const columnsToCreate = [] as Column[];
+	const columnsToDelete = [] as Column[];
+
+	for (let it of groupedByTable) {
+		const { renamedOrMoved: renamed, created, deleted } = await columnsResolver({
+			deleted: it.deleted,
+			created: it.inserted,
+		});
+
+		columnsToCreate.push(...created);
+		columnsToDelete.push(...deleted);
+		columnRenames.push(...renamed);
+	}
+
+	for (const rename of columnRenames) {
+		ddl1.columns.update({
+			set: {
+				name: rename.to.name,
+			},
+			where: {
+				table: rename.from.table,
+				name: rename.from.name,
+			},
+		});
+
+		// DDL2 updates are needed for Drizzle Studio
+		const update1 = {
+			set: {
+				columns: (it: IndexColumn) => {
+					if (!it.isExpression && it.value === rename.from.name) {
+						it.value = rename.to.name;
+					}
+					return it;
+				},
+			},
+			where: {
+				table: rename.from.table,
+			},
+		} as const;
+
+		ddl1.indexes.update(update1);
+		ddl2.indexes.update(update1);
+
+		const update2 = {
+			set: {
+				columns: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				table: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update2);
+		ddl2.fks.update(update2);
+
+		const update3 = {
+			set: {
+				columnsTo: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				tableTo: rename.from.table,
+			},
+		} as const;
+		ddl1.fks.update(update3);
+		ddl2.fks.update(update3);
+
+		const update4 = {
+			set: {
+				columns: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				table: rename.from.table,
+			},
+		};
+		ddl1.pks.update(update4);
+		ddl2.pks.update(update4);
+
+		const update5 = {
+			set: {
+				columns: (it: string) => it === rename.from.name ? rename.to.name : it,
+			},
+			where: {
+				table: rename.from.table,
+			},
+		};
+		ddl1.uniques.update(update5);
+		ddl2.uniques.update(update5);
+
+		const update6 = {
+			set: {
+				value: rename.to.name,
+			},
+			where: {
+				table: rename.from.table,
+				value: rename.from.name,
+			},
+		} as const;
+		ddl1.checks.update(update6);
+		ddl2.checks.update(update6);
+	}
+
+	const createdFilteredColumns = columnsToCreate.filter((it) => !it.generated || it.generated.type === 'virtual');
+
+	preserveEntityNames(ddl1.uniques, ddl2.uniques, mode);
+	preserveEntityNames(ddl1.pks, ddl2.pks, mode);
+	preserveEntityNames(ddl1.fks, ddl2.fks, mode);
+
+	const pksDiff = diff(ddl1, ddl2, 'pks').filter((it) => !deletedTables.some((table) => table.name === it.table));
+	const uniquesDiff = diff(ddl1, ddl2, 'uniques').filter((it) =>
+		!deletedTables.some((table) => table.name === it.table)
+	);
+	const indexesDiff = diff(ddl1, ddl2, 'indexes');
+	const checksDiff = diff(ddl1, ddl2, 'checks');
+	const fksDiff = diff(ddl1, ddl2, 'fks')
+		// it is possible to `ADD COLUMN t integer REFERENCE ...`
+		.filter((it) =>
+			it.columns.length > 0
+			&& !createdFilteredColumns.some((column) => column.table === it.table && column.name === it.columns[0])
+		)
+		// filter deleted tables
+		.filter((it) => !deletedTables.some((table) => table.name === it.table));
+
+	const indexesByTable = groupDiffs(indexesDiff);
+
+	// ignore created/dropped views with isExisting, we can't rename views in SQLite
+	const viewsDiff = diff(ddl1, ddl2, 'views').filter((it) => !it.isExisting);
+
+	const createdViews = viewsDiff.filter((it) => it.$diffType === 'create');
+	const deletedViews = viewsDiff.filter((it) => it.$diffType === 'drop');
+
+	const updates = diff.alters(ddl1, ddl2);
+
+	const uniquesAlters = updates.filter((it) => it.entityType === 'uniques').filter((it) => {
+		if (it.nameExplicit) {
+			delete it.nameExplicit;
+		}
+
+		return ddl2.uniques.hasDiff(it);
+	});
+
+	const pksAlters = updates.filter((it) => it.entityType === 'pks').filter((it) => {
+		if (it.nameExplicit) {
+			delete it.nameExplicit;
+		}
+
+		if (
+			it.columns && it.columns.to && it.columns.from && it.columns.from.length === it.columns.to.length
+		) {
+			const unique = new Set(it.columns.to);
+
+			if (it.columns.from.every((col) => unique.has(col))) delete it.columns;
+		}
+
+		return ddl2.pks.hasDiff(it);
+	});
+
+	const fksAlters = updates.filter((it) => it.entityType === 'fks').filter((it) => {
+		if (it.nameExplicit) {
+			delete it.nameExplicit;
+		}
+
+		return ddl2.fks.hasDiff(it);
+	});
+
+	const checksAlters = updates.filter((it) => it.entityType === 'checks');
+
+	const alteredColumns = updates.filter((it) => it.entityType === 'columns').filter((it) => {
+		if (it.notNull && ddl2.pks.one({ table: it.table, columns: [it.name] })) {
+			delete it.notNull;
+		}
+
+		if (it.default && defaultsCommutative(it.default, it.$right.type)) {
+			delete it.default;
+		}
+
+		return ddl2.columns.hasDiff(it);
+	});
+	const alteredColumnsBecameGenerated = alteredColumns.filter((it) => it.generated?.to?.type === 'stored');
+	const newStoredColumns = columnsToCreate.filter((it) => it.generated && it.generated.type === 'stored');
+
+	const setOfTablesToRecereate = new Set(
+		[
+			...checksDiff,
+			...uniquesDiff,
+			...pksDiff,
+			...fksDiff,
+			...indexesDiff.filter((it) => it.isUnique && it.origin === 'auto'), // we can't drop/create auto generated unique indexes;,
+			...alteredColumnsBecameGenerated, // "It is not possible to ALTER TABLE ADD COLUMN a STORED column. https://www.sqlite.org/gencol.html"
+			...newStoredColumns, // "It is not possible to ALTER TABLE ADD COLUMN a STORED column. https://www.sqlite.org/gencol.html"
+		].map((it) => it.table),
+	);
+
+	for (const it of createdTables) {
+		setOfTablesToRecereate.delete(it.name);
+	}
+	for (const it of deletedTables) {
+		setOfTablesToRecereate.delete(it.name);
+	}
+
+	for (const it of [...alteredColumns, ...pksAlters, ...fksAlters, ...uniquesAlters, ...checksAlters]) {
+		if (it.entityType === 'columns' && (it.type || it.default || it.autoincrement || it.notNull)) {
+			setOfTablesToRecereate.add(it.table);
+		}
+		if (pksAlters.length > 0 && it.entityType === 'pks') setOfTablesToRecereate.add(it.table);
+		if (fksAlters.length > 0 && it.entityType === 'fks') setOfTablesToRecereate.add(it.table);
+		if (uniquesAlters.length > 0 && it.entityType === 'uniques') setOfTablesToRecereate.add(it.table);
+		if (checksAlters.length > 0 && it.entityType === 'checks') setOfTablesToRecereate.add(it.table);
+	}
+
+	const tablesToRecreate = Array.from(setOfTablesToRecereate);
+
+	// TODO: handle
+	// const viewsToRecreateBecauseOfTables = tablesToRecreate.map((it) => {
+	// 	return ddl2.views.one({});
+	// });
+
+	const jsonRecreateTables = tablesToRecreate.map((it) => {
+		return prepareStatement('recreate_table', {
+			to: tableFromDDL(it, ddl2),
+			from: tableFromDDL(it, ddl1),
+			alteredColumnsBecameGenerated: alteredColumnsBecameGenerated.filter((acbg) => acbg.table === it),
+			newStoredColumns: newStoredColumns.filter((column) => column.table === it),
+			checkDiffs: checksDiff.filter((checkDiff) => checkDiff.table === it),
+			checksAlters: checksAlters.filter((checkAlter) => checkAlter.table === it),
+			columnAlters: alteredColumns.filter((column) => column.table === it),
+			fksAlters: fksAlters.filter((fkAlters) => fkAlters.table === it),
+			fksDiff: fksDiff.filter((fkDiff) => fkDiff.table === it),
+			indexesDiff: indexesDiff.filter((indexDiff) => indexDiff.table === it),
+			pksAlters: pksAlters.filter((pkAlters) => pkAlters.table === it),
+			pksDiff: pksDiff.filter((pkDiff) => pkDiff.table === it),
+			uniquesAlters: uniquesAlters.filter((uniqueAlters) => uniqueAlters.table === it),
+			uniquesDiff: uniquesDiff.filter((uniqueDiff) => uniqueDiff.table === it),
+		});
+	});
+
+	const jsonTableAlternations = alteredColumns
+		.filter((it) => !setOfTablesToRecereate.has(it.table)).map((it) =>
+			prepareRecreateColumn(
+				it,
+				ddl2.columns.one({ table: it.table, name: it.name })!,
+				ddl2.fks.one({ table: it.table }),
+			)
+		);
+
+	const jsonCreateTables = createdTables.map((it) => {
+		return prepareStatement('create_table', { table: tableFromDDL(it.name, ddl2) });
+	});
+
+	// create indexes for created and recreated tables too
+	const jsonCreateIndexes = [...jsonRecreateTables]
+		.map((it) => it.to.indexes)
+		.concat(indexesByTable.filter((it) => !setOfTablesToRecereate.has(it.table)).map((it) => it.inserted))
+		.map((it) => it.map((index) => prepareStatement('create_index', { index })))
+		.flat();
+
+	const jsonDropIndexes = indexesByTable.map((it) =>
+		it.deleted.map((index) => prepareStatement('drop_index', { index }))
+	).flat();
+	const jsonDropTables = deletedTables.map((it) => prepareStatement('drop_table', { tableName: it.name }));
+	const jsonRenameTables = renamedTables.map((it) =>
+		prepareStatement('rename_table', { from: it.from.name, to: it.to.name })
+	);
+
+	const jsonRenameColumnsStatements = columnRenames.map((it) =>
+		prepareStatement('rename_column', { table: it.from.table, from: it.from.name, to: it.to.name })
+	);
+
+	// we need to add column for table, which is going to be recreated to match columns during recreation
+	const columnDeletes = columnsToDelete.filter((it) => !setOfTablesToRecereate.has(it.table));
+
+	const jsonDropColumnsStatemets = columnDeletes.filter((x) => {
+		return !jsonDropTables.some((t) => t.tableName === x.table);
+	}).map((it) => prepareStatement('drop_column', { column: it }));
+
+	const warnings: string[] = [];
+	for (const _ of newStoredColumns) {
+		warnings.push(
+			`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
+		);
+	}
+
+	const groupedNewColumns = Object.values(createdFilteredColumns.reduce((acc, prev) => {
+		const entry = prev.table in acc ? acc[prev.table] : { table: prev.table, columns: [] };
+		acc[prev.table] = entry;
+		entry.columns.push(prev);
+		return acc;
+	}, {} as Record<string, { table: string; columns: Column[] }>));
+
+	const jsonAddColumnsStatemets = groupedNewColumns
+		.map((it) => prepareAddColumns(it.columns, ddl2.fks.list({ table: it.table })))
+		.flat();
+
+	const createViews: JsonCreateViewStatement[] = [];
+	const dropViews: JsonDropViewStatement[] = [];
+
+	createViews.push(...createdViews.map((it) => prepareStatement('create_view', { view: it })));
+	dropViews.push(...deletedViews.map((it) => prepareStatement('drop_view', { view: it })));
+
+	for (const view of updates.filter((it) => it.entityType === 'views')) {
+		if (view.isExisting || (view.definition && mode !== 'push')) {
+			const entity = ddl2.views.one({ name: view.name })!;
+			dropViews.push(prepareStatement('drop_view', { view: entity }));
+			createViews.push(prepareStatement('create_view', { view: entity }));
+		}
+	}
+
+	// TODO:
+	// [x] create table with unique column
+	// [ ] create table with unique column unique index (will create 2 indexes)
+	// [ ] create table with non-unique column and unique index
+	// [x] drop 'c' unique index ok
+	// [x] drop 'u' unique index ok, recreate table
+	// [x] drizzle generate does not have 'u' unique indexes and should not create ones never
+	// [ ] drizzle push should respect 'u' indexes(commutativity), never auto create indexes from 'unique' of a column
+
+	const jsonStatements: JsonStatement[] = [];
+	jsonStatements.push(...jsonCreateTables);
+	jsonStatements.push(...jsonRenameTables); // rename tables before tables recreate
+	jsonStatements.push(...jsonRenameColumnsStatements); // rename columns before tables recreate
+	jsonStatements.push(...jsonAddColumnsStatemets);
+
+	jsonStatements.push(...jsonTableAlternations);
+
+	jsonStatements.push(...jsonRecreateTables);
+	jsonStatements.push(...jsonDropIndexes);
+	jsonStatements.push(...jsonCreateIndexes);
+
+	jsonStatements.push(...jsonDropTables);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+
+	jsonStatements.push(...dropViews);
+	jsonStatements.push(...createViews);
+
+	const { sqlStatements, groupedStatements } = fromJson(jsonStatements);
+
+	const renames = prepareMigrationRenames([
+		...renamedTables,
+		...columnRenames,
+	]);
+
+	return {
+		statements: jsonStatements,
+		sqlStatements,
+		groupedStatements,
+		renames,
+		warnings,
+	};
+};
diff --git a/drizzle-kit/src/dialects/sqlite/drizzle.ts b/drizzle-kit/src/dialects/sqlite/drizzle.ts
new file mode 100644
index 0000000000..f97cd7bd06
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/drizzle.ts
@@ -0,0 +1,290 @@
+import { getTableName, is, SQL } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { AnySQLiteColumn, AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+import {
+	getTableConfig,
+	getViewConfig,
+	SQLiteBaseInteger,
+	SQLiteDialect,
+	SQLiteTable,
+	SQLiteTimestamp,
+	SQLiteView,
+} from 'drizzle-orm/sqlite-core';
+import { loadModule } from '../../utils/utils-node';
+import { sqlToStr } from '../drizzle';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimSchema,
+	PrimaryKey,
+	Table,
+	UniqueConstraint,
+	View,
+} from './ddl';
+import { Int, nameForForeignKey, nameForPk, nameForUnique, transformOnUpdateDelete, typeFor } from './grammar';
+
+export const fromDrizzleSchema = (
+	dTables: AnySQLiteTable[],
+	dViews: SQLiteView[],
+): InterimSchema => {
+	const dialect = new SQLiteDialect();
+	const tableConfigs = dTables.map((it) => ({ table: it, config: getTableConfig(it) }));
+	const tables: Table[] = tableConfigs.map((it) => {
+		return {
+			entityType: 'tables',
+			name: it.config.name,
+		} satisfies Table;
+	});
+
+	const columns = tableConfigs.map((it) => {
+		return it.config.columns.map((column) => {
+			const { name } = column;
+			const primaryKey: boolean = column.primary;
+			const generated = column.generated;
+
+			const generatedObj: {
+				as: string;
+				type: 'virtual' | 'stored';
+			} | null = generated
+				? {
+					as: is(generated.as, SQL)
+						? `(${dialect.sqlToQuery(generated.as as SQL, 'indexes').sql})`
+						: typeof generated.as === 'function'
+						? `(${dialect.sqlToQuery(generated.as() as SQL, 'indexes').sql})`
+						: `(${generated.as as any})`,
+
+					// 'virtual' | 'stored' for for all dialects
+					// 'virtual' | 'persisted' for mssql
+					// We should remove this option from common Column and store it per dialect common
+					// Was discussed with Andrew
+					// Type error because of common in drizzle orm for all dialects (includes virtual' | 'stored' | 'persisted')
+					type: generated.mode === 'stored' ? 'stored' : 'virtual',
+				}
+				: null;
+
+			const defalutValue = defaultFromColumn(column);
+
+			const hasUniqueIndex = Boolean(it.config.indexes.find((item) => {
+				const i = item.config;
+				const column = i.columns.length === 1 ? i.columns[0] : null;
+				return column && !is(column, SQL) && column.name === name;
+			}));
+
+			return {
+				entityType: 'columns',
+				table: it.config.name,
+				name,
+				type: column.getSQLType(),
+				default: defalutValue,
+				notNull: column.notNull && !primaryKey,
+				pk: primaryKey,
+				pkName: null,
+				autoincrement: is(column, SQLiteBaseInteger)
+					? column.autoIncrement
+					: false,
+				generated: generatedObj,
+				isUnique: !hasUniqueIndex && column.isUnique,
+				uniqueName: column.uniqueName ?? null,
+			} satisfies InterimColumn;
+		});
+	}).flat();
+
+	const pks = tableConfigs.map((it) => {
+		return it.config.primaryKeys.map((pk) => {
+			const columnNames = pk.columns.map((c) => c.name);
+			return {
+				entityType: 'pks',
+				name: pk.name ?? nameForPk(getTableConfig(pk.table).name),
+				table: it.config.name,
+				columns: columnNames,
+				nameExplicit: pk.isNameExplicit,
+			} satisfies PrimaryKey;
+		});
+	}).flat();
+
+	const fks = tableConfigs.map((it) => {
+		return it.config.foreignKeys.map((fk) => {
+			const tableFrom = it.config.name;
+			const onDelete = fk.onDelete;
+			const onUpdate = fk.onUpdate;
+			const reference = fk.reference();
+
+			const referenceFT = reference.foreignTable;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			const tableTo = getTableName(referenceFT);
+
+			const columnsFrom = reference.columns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => it.name);
+
+			const name = fk.isNameExplicit()
+				? fk.getName()
+				: nameForForeignKey({ table: tableFrom, columns: columnsFrom, tableTo, columnsTo });
+			return {
+				entityType: 'fks',
+				table: it.config.name,
+				name,
+				tableTo,
+				columns: columnsFrom,
+				columnsTo,
+				onDelete: transformOnUpdateDelete(onDelete ?? 'no action'),
+				onUpdate: transformOnUpdateDelete(onUpdate ?? 'no action'),
+				nameExplicit: fk.isNameExplicit(),
+			} satisfies ForeignKey;
+		});
+	}).flat();
+
+	const indexes = tableConfigs.map((it) => {
+		return it.config.indexes.map((index) => {
+			const columns = index.config.columns;
+			const name = index.config.name;
+
+			let indexColumns = columns.map((it) => {
+				if (is(it, SQL)) {
+					const sql = dialect.sqlToQuery(it, 'indexes').sql;
+					return { value: sql, isExpression: true };
+				}
+				return { value: it.name, isExpression: false };
+			});
+
+			let where: string | undefined;
+			if (index.config.where !== undefined) {
+				if (is(index.config.where, SQL)) {
+					where = dialect.sqlToQuery(index.config.where).sql;
+				}
+			}
+			return {
+				entityType: 'indexes',
+				table: it.config.name,
+				name,
+				columns: indexColumns,
+				isUnique: index.config.unique ?? false,
+				where: where ?? null,
+				origin: 'manual', // created by user https://www.sqlite.org/pragma.html#pragma_index_list
+			} satisfies Index;
+		});
+	}).flat();
+
+	const uniques = tableConfigs.map((it) => {
+		return it.config.uniqueConstraints.map((unique) => {
+			const columnNames = unique.columns.map((c) => c.name);
+			const name = unique.isNameExplicit ? unique.name : nameForUnique(it.config.name, columnNames);
+			return {
+				entityType: 'uniques',
+				table: it.config.name,
+				name: name,
+				columns: columnNames,
+				nameExplicit: unique.isNameExplicit,
+			} satisfies UniqueConstraint;
+		});
+	}).flat();
+
+	const checks = tableConfigs.map((it) => {
+		return it.config.checks.map((check) => {
+			// TODO: dialect.sqlToQuery(check.value).sql returns "users"."age" > 21, as opposed to "age" > 21 for checks, which is wrong
+			const value = dialect.sqlToQuery(check.value, /* should fix */ 'indexes').sql.replace(`"${it.config.name}".`, '');
+			return {
+				entityType: 'checks',
+				table: it.config.name,
+				name: check.name,
+				value: value,
+			} satisfies CheckConstraint;
+		});
+	}).flat();
+
+	const views = dViews.sort((a, b) => {
+		// see in "./dialects/postgres/drizzle.ts" for more
+		const aConfig = getViewConfig(a);
+		const bConfig = getViewConfig(b);
+
+		// If a's fields include b, a depends on b → b comes first
+		if (aConfig.query?.queryChunks.includes(b)) return 1;
+
+		// If b's fields include a, b depends on a → a comes first
+		if (bConfig.query?.queryChunks.includes(a)) return -1;
+
+		return 0;
+	}).map((it) => {
+		const { name: viewName, isExisting, query } = getViewConfig(it);
+
+		return {
+			entityType: 'views',
+			name: viewName,
+			isExisting,
+			definition: isExisting ? null : dialect.sqlToQuery(query!).sql,
+			error: null,
+		} satisfies View;
+	});
+
+	return { tables, columns, indexes, uniques, fks, pks, checks, views };
+};
+
+export const fromExports = (exports: Record<string, unknown>) => {
+	const tables: AnySQLiteTable[] = [];
+	const views: SQLiteView[] = [];
+	const relations: Relations[] = [];
+
+	const i0values = Object.values(exports);
+	i0values.forEach((t) => {
+		if (is(t, SQLiteTable)) {
+			tables.push(t);
+		}
+
+		if (is(t, SQLiteView)) {
+			views.push(t);
+		}
+
+		if (is(t, Relations)) {
+			relations.push(t);
+		}
+	});
+
+	return { tables, views, relations };
+};
+
+export const prepareFromSchemaFiles = async (imports: string[]) => {
+	const tables: AnySQLiteTable[] = [];
+	const views: SQLiteView[] = [];
+	const relations: Relations[] = [];
+
+	for (let i = 0; i < imports.length; i++) {
+		const it = imports[i];
+
+		const i0: Record<string, unknown> = await loadModule(it);
+		const prepared = fromExports(i0);
+
+		tables.push(...prepared.tables);
+		views.push(...prepared.views);
+		relations.push(...prepared.relations);
+	}
+
+	return { tables: Array.from(new Set(tables)), views, relations };
+};
+
+export type PreparedSqliteSchema = Awaited<ReturnType<typeof prepareFromSchemaFiles>>;
+
+// Decouples the schema's origin (compiled `.ts` files vs. a supplied prebuilt schema) from its consumers.
+export interface SchemaSource {
+	load(): Promise<PreparedSqliteSchema>;
+}
+
+export const SchemaSource = {
+	fromFilenames(filenames: string[]): SchemaSource {
+		return { load: () => prepareFromSchemaFiles(filenames) };
+	},
+	fromSchema(schema: PreparedSqliteSchema): SchemaSource {
+		return { load: async () => schema };
+	},
+};
+
+export const defaultFromColumn = (
+	column: AnySQLiteColumn,
+): Column['default'] => {
+	const def = column.default;
+	if (typeof def === 'undefined') return null; // '', 0, false, etc.
+	if (is(def, SQL)) return sqlToStr(def);
+	if (is(column, SQLiteTimestamp)) return Int.defaultFromDrizzle(def, column.mode);
+	return typeFor(column.getSQLType()).defaultFromDrizzle(def);
+};
diff --git a/drizzle-kit/src/dialects/sqlite/grammar.ts b/drizzle-kit/src/dialects/sqlite/grammar.ts
new file mode 100644
index 0000000000..f0b123e287
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/grammar.ts
@@ -0,0 +1,690 @@
+import { assertUnreachable, trimChar } from '../../utils';
+import { parse, stringify } from '../../utils/when-json-met-bigint';
+import { escapeForTsLiteral } from '../utils';
+import type { Column, DiffEntities, ForeignKey } from './ddl';
+import type { Import } from './typescript';
+
+const namedCheckPattern = /CONSTRAINT\s+["'`[]?(\w+)["'`\]]?\s+CHECK\s*\((.*)\)/gi;
+const unnamedCheckPattern = /CHECK\s+\((.*)\)/gi;
+const viewAsStatementRegex = new RegExp(`\\bAS\\b\\s+(WITH.+|SELECT.+)$`, 'is'); // 'i' for case-insensitive, 's' for dotall mode
+
+export const nameForForeignKey = (fk: Pick<ForeignKey, 'table' | 'columns' | 'tableTo' | 'columnsTo'>) => {
+	return `fk_${fk.table}_${fk.columns.join('_')}_${fk.tableTo}_${fk.columnsTo.join('_')}_fk`;
+};
+
+export const nameForUnique = (table: string, columns: string[]) => {
+	return `${table}_${columns.join('_')}_unique`;
+};
+
+export const nameForPk = (table: string) => {
+	return `${table}_pk`;
+};
+
+export interface SqlType<MODE = unknown> {
+	is(type: string): boolean;
+	drizzleImport(): Import;
+	defaultFromDrizzle(value: unknown, mode?: MODE): Column['default'];
+	defaultFromIntrospect(value: string): Column['default'];
+	toTs(
+		value: Column['default'],
+		type: string,
+	): { def: string; options?: Record<string, string | number | boolean>; customType?: string } | string;
+}
+
+const intAffinities = [
+	'int',
+	'integer',
+	'tiniint',
+	'smallint',
+	'mediumint',
+	'bigint',
+	'unsigned big int',
+	'int2',
+	'int8',
+];
+
+export const Int: SqlType<'timestamp' | 'timestamp_ms'> = {
+	is(type) {
+		return intAffinities.indexOf(type.toLowerCase()) >= 0;
+	},
+	drizzleImport: () => 'integer',
+	defaultFromDrizzle: (value, mode) => {
+		// if (typeof value === 'boolean') {
+		// 	return value ? '1' : '0';
+		// }
+
+		if (typeof value === 'bigint') {
+			return `'${value.toString()}'`;
+		}
+
+		if (value instanceof Date) {
+			const v = mode === 'timestamp' ? value.getTime() / 1000 : value.getTime();
+			return v.toFixed(0);
+		}
+
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		const it = trimChar(value, "'");
+		const check = Number(it);
+		if (Number.isNaN(check)) return value; // unknown
+		if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) return it;
+		return it; // bigint
+	},
+	toTs: (value) => {
+		if (!value) return '';
+
+		if (value === 'true' || value === 'false') {
+			return { def: value, options: { mode: 'boolean' } };
+		}
+
+		const check = Number(value);
+		if (Number.isNaN(check)) return `sql\`${value}\``; // unknown
+		if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) return value;
+		return `${value}n`; // bigint
+	},
+};
+
+const realAffinities = [
+	'real',
+	'double',
+	'double precision',
+	'float',
+];
+
+export const Real: SqlType = {
+	is: function(type: string): boolean {
+		return realAffinities.indexOf(type.toLowerCase()) >= 0;
+	},
+	drizzleImport: function(): Import {
+		return 'real';
+	},
+	defaultFromDrizzle: function(value: unknown): Column['default'] {
+		return String(value);
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		return value;
+	},
+	toTs: function(value: Column['default']): string {
+		return value ?? '';
+	},
+};
+
+const numericAffinities = [
+	'numeric',
+	'decimal',
+	'boolean',
+	'date',
+	'datetime',
+];
+export const Numeric: SqlType = {
+	is: function(type: string): boolean {
+		const lowered = type.toLowerCase();
+
+		return numericAffinities.indexOf(lowered) >= 0
+			|| lowered.startsWith('numeric(')
+			|| lowered.startsWith('decimal(');
+	},
+	drizzleImport: function(): Import {
+		return 'numeric';
+	},
+	defaultFromDrizzle: function(value: unknown, _mode?: unknown): Column['default'] {
+		if (typeof value === 'string') return `'${value}'`;
+		if (typeof value === 'bigint') return `'${value.toString()}'`;
+		if (typeof value === 'number') return `${value.toString()}`;
+		throw new Error(`unexpected: ${value} ${typeof value}`);
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		return value;
+	},
+	toTs: function(value: Column['default']) {
+		if (!value) return '';
+		const check = Number(value);
+
+		if (Number.isNaN(check)) return value; // unknown
+		if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) {
+			return { def: value, options: { mode: 'number' } };
+		}
+		return { def: `${value}n`, options: { mode: 'bigint' } }; // bigint
+	},
+};
+
+const textAffinities = [
+	'text',
+	'character',
+	'varchar',
+	'varying character',
+	'nchar',
+	'native character',
+	'nvarchar',
+	'clob',
+];
+
+export const Text: SqlType = {
+	is: function(type: string): boolean {
+		const lowered = type.toLowerCase();
+		return textAffinities.indexOf(lowered) >= 0
+			|| lowered.startsWith('text(')
+			|| lowered.startsWith('character(')
+			|| lowered.startsWith('varchar(')
+			|| lowered.startsWith('varying character(')
+			|| lowered.startsWith('nchar(')
+			|| lowered.startsWith('native character(')
+			|| lowered.startsWith('nvarchar(')
+			|| lowered.startsWith('clob(');
+	},
+	drizzleImport: function(): Import {
+		return 'text';
+	},
+	defaultFromDrizzle: function(value: unknown, _mode?: unknown): Column['default'] {
+		let result: string;
+		if (typeof value === 'string') result = value.replaceAll('\\', '\\\\').replaceAll("'", "''");
+		else if (typeof value === 'object' || Array.isArray(value)) {
+			result = stringify(value, (_, value) => {
+				if (typeof value !== 'string') return value;
+				return value.replaceAll("'", "''");
+			});
+		} else {
+			throw new Error(`unexpected default: ${value}`);
+		}
+		return `'${result}'`;
+	},
+	defaultFromIntrospect: function(value: string): Column['default'] {
+		return value;
+	},
+	toTs: function(value: Column['default']) {
+		if (value === null) return '';
+		if (!value.startsWith("'")) return `sql\`${value}\``; // CURRENT_TIMESTAMP
+
+		try {
+			const parsed = parse(trimChar(value, "'"), (_, v) => {
+				if (typeof v === 'string') {
+					return v.replaceAll("''", "'");
+				}
+				return v;
+			});
+
+			return {
+				def: stringify(parsed, undefined, undefined, true)!,
+				options: { mode: 'json' },
+			};
+		} catch {}
+
+		const escaped = trimChar(value, "'").replaceAll("''", "'").replaceAll('"', '\\"');
+		return `"${escaped}"`;
+	},
+};
+
+export const Blob: SqlType = {
+	is: function(type: string): boolean {
+		const lowered = type.toLowerCase();
+		return lowered === 'blob' || lowered.startsWith('blob');
+	},
+	drizzleImport: function(): Import {
+		return 'blob';
+	},
+	defaultFromDrizzle: function(value: unknown): Column['default'] {
+		if (typeof value === 'bigint') return `'${value.toString()}'`;
+		if (typeof Buffer !== 'undefined' && typeof Buffer.isBuffer === 'function' && Buffer.isBuffer(value)) {
+			return `X'${value.toString('hex').toUpperCase()}'`;
+		}
+		if (Array.isArray(value) || typeof value === 'object') {
+			return Text.defaultFromDrizzle(value);
+		}
+		throw new Error('unexpected');
+	},
+	defaultFromIntrospect: function(value: string) {
+		return value;
+	},
+	toTs: function(value, type) {
+		if (value === null) return '';
+
+		if (typeof Buffer !== 'undefined' && value.startsWith("X'")) {
+			const parsed = Buffer.from(value.slice(2, value.length - 1), 'hex').toString('utf-8');
+			const escaped = parsed.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+			return `Buffer.from("${escaped}")`;
+		}
+
+		try {
+			const trimmed = trimChar(value, "'");
+			const num = Number(trimmed);
+			if (!Number.isNaN(num)) {
+				if (num >= Number.MIN_SAFE_INTEGER && num <= Number.MAX_SAFE_INTEGER) {
+					return String(num);
+				} else {
+					return `${trimmed}n`;
+				}
+			}
+		} catch {}
+
+		return Text.toTs(value, type);
+	},
+};
+
+export const Custom: SqlType = {
+	is: (_type: string) => {
+		throw Error('Mocked');
+	},
+	drizzleImport: () => 'customType',
+	defaultFromDrizzle: (value) => {
+		if (!value) return '';
+		return String(value);
+	},
+	defaultFromIntrospect: (value) => {
+		return value;
+	},
+	toTs: function(value, type) {
+		if (!value) return { def: '', customType: type };
+		const escaped = escapeForTsLiteral(value);
+		return { def: escaped, customType: type };
+	},
+};
+
+export const typeFor = (sqlType: string): SqlType => {
+	if (Int.is(sqlType)) return Int;
+	if (Real.is(sqlType)) return Real;
+	if (Numeric.is(sqlType)) return Numeric;
+	if (Text.is(sqlType)) return Text;
+	if (Blob.is(sqlType)) return Blob;
+	if (Numeric.is(sqlType)) return Numeric;
+
+	// If no specific type matches, default to Custom
+	return Custom;
+};
+
+// https://www.sqlite.org/datatype3.html
+export function sqlTypeFrom(sqlType: string): string {
+	const lowered = sqlType.toLowerCase();
+	if (
+		[
+			'int',
+			// 'integer', redundant
+			// 'integer auto_increment', redundant
+			'tinyint',
+			'smallint',
+			'mediumint',
+			'bigint',
+			'unsigned big int',
+			// 'int2', redundant
+			// 'int8', redundant
+		].some((it) => lowered.startsWith(it))
+	) {
+		return 'integer';
+	}
+
+	if (
+		[
+			'character',
+			'varchar',
+			'varying character',
+			'national varying character',
+			'nchar',
+			'native character',
+			'nvarchar',
+			'text',
+			'clob',
+		].some((it) => lowered.startsWith(it))
+	) {
+		const match = lowered.match(/\d+/);
+
+		if (match) {
+			return `text(${match[0]})`;
+		}
+
+		return 'text';
+	}
+
+	if (lowered.startsWith('blob')) {
+		return 'blob';
+	}
+
+	if (
+		['real', 'double', 'double precision', 'float'].some((it) => lowered.startsWith(it))
+	) {
+		return 'real';
+	}
+
+	// https://www.sqlite.org/datatype3.html -> 3.1.1. Affinity Name Examples
+	if (
+		['numeric', 'decimal', 'boolean', 'date', 'datetime'].some((it) => lowered.startsWith(it))
+	) {
+		return 'numeric';
+	}
+
+	return sqlType;
+}
+
+export const parseDefault = (type: string, it: string): Column['default'] => {
+	if (it === null) return null;
+	const grammarType = typeFor(type);
+
+	if (grammarType) return grammarType.defaultFromIntrospect(it);
+
+	const trimmed = trimChar(it, "'");
+
+	if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+		const n = Number(it);
+
+		if (n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER) {
+			return trimmed;
+		}
+		return `'${trimmed}'`;
+	}
+
+	// TODO: handle where and need tests??
+	if (['CURRENT_TIME', 'CURRENT_DATE', 'CURRENT_TIMESTAMP'].includes(it)) {
+		return `(${it})`;
+	}
+	return `(${it})`;
+};
+
+export const parseTableSQL = (sql: string) => {
+	const namedChecks = [...sql.matchAll(namedCheckPattern)].map((it) => {
+		const [_, name, value] = it;
+		return { name, value: value.trim() };
+	});
+	const unnamedChecks = [...sql.matchAll(unnamedCheckPattern)].map((it) => {
+		const [_, value] = it;
+		return { name: null, value: value.trim() };
+	}).filter((it) => !namedChecks.some((x) => x.value === it.value));
+
+	return {
+		checks: [...namedChecks, ...unnamedChecks],
+	};
+};
+
+export const parseViewSQL = (sql: string) => {
+	const match = sql.match(viewAsStatementRegex);
+	return match ? match[1] : null;
+};
+
+export interface Generated {
+	as: string;
+	type: 'stored' | 'virtual';
+}
+
+export function extractGeneratedColumns(input: string): Record<string, Generated> {
+	const columns: Record<string, Generated> = {};
+	const regex = /["'`[]?(\w+)["'`\]]?\s+(\w+)\s+GENERATED\s+ALWAYS\s+AS\s*\(/gi;
+
+	let match: RegExpExecArray | null;
+	while ((match = regex.exec(input)) !== null) {
+		const columnName = match[1];
+		let startIndex = regex.lastIndex - 1; // position of '('
+		let depth = 1;
+		let endIndex = startIndex + 1;
+
+		// Find matching closing parenthesis
+		while (endIndex < input.length && depth > 0) {
+			const char = input[endIndex];
+			if (char === '(') depth++;
+			else if (char === ')') depth--;
+			endIndex++;
+		}
+
+		const expression = input.slice(startIndex, endIndex).trim();
+
+		// Find STORED/VIRTUAL type after the expression
+		const afterExpr = input.slice(endIndex);
+		const typeMatch = afterExpr.match(/\b(STORED|VIRTUAL)\b/i);
+		const type = typeMatch ? typeMatch[1].toLowerCase() as Generated['type'] : 'virtual';
+
+		columns[columnName] = {
+			as: expression,
+			type,
+		};
+	}
+	return columns;
+}
+
+export const omitSystemTables = () => {
+	// ['__drizzle_migrations', `'\\_cf\\_%'`, `'\\_litestream\\_%'`, `'libsql\\_%'`, `'sqlite\\_%'`];
+	return true;
+};
+
+interface IParseResult {
+	uniques: { name: string | null; columns: string[] }[];
+	pk: { name: string | null; columns: string[] };
+}
+
+/**
+ * Parses a SQLite DDL string to find primary key and unique constraints
+ * Handles quoted with [], ``, "", or no quotes
+ */
+export function parseSqliteDdl(ddl: string): IParseResult {
+	const result: IParseResult = {
+		pk: { name: null, columns: [] },
+		uniques: [],
+	};
+
+	const cleanIdentifier = (identifier: string): string => {
+		return identifier.trim().replace(/^(?:\[|`|")/, '').replace(/(?:\]|`|")$/, '');
+	};
+
+	const parseColumns = (columnsStr: string): string[] => {
+		return columnsStr.split(',').map((c) => cleanIdentifier(c));
+	};
+
+	const normalizedDdl = ddl.replace(/(\r\n|\n|\r)/gm, ' ').replace(/\s+/g, ' ');
+	const bodyMatch = normalizedDdl.match(/CREATE\s+TABLE.*?\((.*)\)/i);
+	if (!bodyMatch) {
+		return result; // Not a valid CREATE TABLE statement
+	}
+	let tableBody = bodyMatch[1];
+
+	const ident = '(?:\\[[^\\]]+\\]|`[^`]+`|"[^"]+"|[\\w_]+)';
+
+	// find table level UNIQUE constraints
+	const uniqueConstraintRegex = new RegExp(`CONSTRAINT\\s+(${ident})\\s+UNIQUE\\s*\\(([^)]+)\\)`, 'gi');
+	tableBody = tableBody.replace(uniqueConstraintRegex, (match, name, columns) => {
+		result.uniques.push({ name: cleanIdentifier(name), columns: parseColumns(columns) });
+		return ''; // remove the matched constraint from the string
+	});
+
+	// find table level PRIMARY KEY constraint
+	const pkConstraintRegex = new RegExp(`CONSTRAINT\\s+(${ident})\\s+PRIMARY\\s+KEY\\s*\\(([^)]+)\\)`, 'i');
+	tableBody = tableBody.replace(pkConstraintRegex, (match, name, columns) => {
+		result.pk = { name: cleanIdentifier(name), columns: parseColumns(columns) };
+		return ''; // remove the matched constraint from the string
+	});
+
+	// split the remaining body into individual definition parts
+	const definitions = tableBody.split(',').filter((def) => def.trim() !== '');
+
+	const inlineConstraintNameRegex = new RegExp(`CONSTRAINT\\s+(${ident})`, 'i');
+	for (const def of definitions) {
+		const trimmedDef = def.trim();
+
+		// find inline PRIMARY KEY
+		const inlinePkRegex = new RegExp(`^(${ident})\\s+.*\\bPRIMARY\\s+KEY\\b`, 'i');
+		const pkMatch = trimmedDef.match(inlinePkRegex);
+		if (pkMatch) {
+			const pkColumn = cleanIdentifier(pkMatch[1]);
+			// check for an inline constraint name -> `id INT CONSTRAINT pk_id PRIMARY KEY`
+			const pkNameMatch = trimmedDef.match(inlineConstraintNameRegex);
+			result.pk = { name: pkNameMatch ? cleanIdentifier(pkNameMatch[1]) : null, columns: [pkColumn] };
+		}
+
+		// find inline UNIQUE
+		const inlineUniqueRegex = new RegExp(`^(${ident})\\s+.*\\bUNIQUE\\b`, 'i');
+		const uniqueMatch = trimmedDef.match(inlineUniqueRegex);
+		if (uniqueMatch) {
+			const uqColumn = cleanIdentifier(uniqueMatch[1]);
+			const alreadyExists = result.uniques.some((u) => u.columns.length === 1 && u.columns[0] === uqColumn);
+			const uqNameMatch = trimmedDef.match(inlineConstraintNameRegex);
+			const uqName = uqNameMatch ? cleanIdentifier(uqNameMatch[1]) : null;
+			if (!alreadyExists) {
+				result.uniques.push({ name: uqName, columns: [uqColumn] });
+			}
+		}
+	}
+
+	return result;
+}
+
+interface IFkConstraint {
+	name: string | null;
+	fromTable: string; // The table where the FK is defined
+	toTable: string; // The table being referenced
+	fromColumns: string[]; // Columns in the current table
+	toColumns: string[]; // Columns in the referenced table
+}
+/**
+ * Parses a SQLite DDL string to find all foreign key constraints
+ */
+export function parseSqliteFks(ddl: string): IFkConstraint[] {
+	const results: IFkConstraint[] = [];
+
+	const cleanIdentifier = (identifier: string): string => {
+		return identifier.trim().replace(/^(?:\[|`|")/, '').replace(/(?:\]|`|")$/, '');
+	};
+
+	const parseColumns = (columnsStr: string): string[] => {
+		return columnsStr.split(',').map((c) => cleanIdentifier(c));
+	};
+
+	const normalizedDdl = ddl.replace(/(\r\n|\n|\r)/gm, ' ').replace(/\s+/g, ' ');
+
+	// find the name of the table being created (the "from" table)
+	const ident = '(?:\\[[^\\]]+\\]|`[^`]+`|"[^"]+"|[\\w_]+)';
+	const fromTableMatch = normalizedDdl.match(
+		new RegExp(`CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${ident})`, 'i'),
+	);
+	if (!fromTableMatch) {
+		return results; // Not a valid CREATE TABLE statement
+	}
+	const fromTable = cleanIdentifier(fromTableMatch[1]);
+
+	const bodyMatch = normalizedDdl.match(/\((.*)\)/i);
+	if (!bodyMatch) {
+		return results;
+	}
+	let tableBody = bodyMatch[1];
+
+	// find and remove all table level FOREIGN KEY constraints
+	const tableFkRegex = new RegExp(
+		`(?:CONSTRAINT\\s+(${ident})\\s+)?FOREIGN\\s+KEY\\s*\\(([^)]+)\\)\\s+REFERENCES\\s+(${ident})(?:\\s*\\(([^)]+)\\))?`,
+		'gi',
+	);
+
+	tableBody = tableBody.replace(tableFkRegex, (match, name, fromCols, refTable, toCols) => {
+		results.push({
+			name: name ? cleanIdentifier(name) : null,
+			fromTable: fromTable,
+			toTable: cleanIdentifier(refTable),
+			fromColumns: parseColumns(fromCols),
+			toColumns: toCols ? parseColumns(toCols) : [],
+		});
+		return ''; // Remove from DDL body
+	});
+
+	// find inline REFERENCES on the cleaned string
+	const definitions = tableBody.split(',').filter((def) => def.trim() !== '');
+
+	for (const def of definitions) {
+		const trimmedDef = def.trim();
+
+		const inlineFkRegex = new RegExp(
+			`^(${ident}).*?\\s+REFERENCES\\s+(${ident})(?:\\s*\\(([^)]+)\\))?`,
+			'i',
+		);
+		const inlineMatch = trimmedDef.match(inlineFkRegex);
+
+		if (inlineMatch) {
+			const fromColumn = cleanIdentifier(inlineMatch[1]);
+			const toTable = cleanIdentifier(inlineMatch[2]);
+			const toColumn = inlineMatch[3] ? cleanIdentifier(inlineMatch[3]) : null;
+
+			const nameMatch = trimmedDef.match(new RegExp(`CONSTRAINT\\s+(${ident})`, 'i'));
+
+			results.push({
+				name: nameMatch ? cleanIdentifier(nameMatch[1]) : null,
+				fromTable: fromTable,
+				toTable: toTable,
+				fromColumns: [fromColumn],
+				toColumns: toColumn ? [toColumn] : [],
+			});
+		}
+	}
+
+	return results;
+}
+
+// for integer mode timestamp | timestamp_ms
+function compareIntegerTimestamps(from: string, to: string): boolean {
+	from = trimChar(trimChar(from, "'"), '"');
+	to = trimChar(trimChar(to, "'"), '"');
+
+	const mappedFrom: number | string = /^\d+$/.test(from) ? Number(from) : from;
+	const mappedTo: number | string = /^\d+$/.test(to) ? Number(to) : to;
+
+	let timestampFrom = new Date(mappedFrom).getTime();
+	let timestampTo = new Date(mappedTo).getTime();
+	if (timestampFrom === timestampTo) return true;
+
+	if (typeof mappedFrom === 'number') {
+		timestampFrom = new Date(Number(from) * 1000).getTime();
+
+		return timestampFrom === timestampTo;
+	}
+
+	if (typeof mappedTo === 'number') {
+		timestampTo = new Date(Number(to) * 1000).getTime();
+
+		return timestampFrom === timestampTo;
+	}
+
+	return false;
+}
+// for legacy blobs
+function parseToHex(value: string | null) {
+	if (!value) return null;
+
+	try {
+		const parsed: any = JSON.parse(trimChar(value, "'"));
+		if (parsed.type === 'Buffer' && Array.isArray(parsed.data)) {
+			value = Blob.defaultFromDrizzle(Buffer.from(parsed.data));
+		}
+	} catch {}
+
+	return value;
+}
+export const defaultsCommutative = (
+	diffDef: DiffEntities['columns']['default'],
+	type: string,
+): boolean => {
+	if (!diffDef) return false;
+
+	let from = diffDef.from;
+	let to = diffDef.to;
+
+	if (from === to) return true;
+	if (from === `(${to})`) return true;
+	if (to === `(${from})`) return true;
+
+	if (type.startsWith('integer')) {
+		if (from && to) {
+			// old snapshot has '"<iso_date>"'
+
+			return compareIntegerTimestamps(from, to);
+		}
+
+		return false;
+	}
+
+	if (type.startsWith('blob')) {
+		return parseToHex(from) === parseToHex(to);
+	}
+
+	return false;
+};
+
+export const transformOnUpdateDelete = (on: 'no action' | 'cascade' | 'restrict' | 'set default' | 'set null') => {
+	if (on === 'no action') return 'NO ACTION';
+	if (on === 'cascade') return 'CASCADE';
+	if (on === 'restrict') return 'RESTRICT';
+	if (on === 'set default') return 'SET DEFAULT';
+	if (on === 'set null') return 'SET NULL';
+
+	assertUnreachable(on);
+};
diff --git a/drizzle-kit/src/dialects/sqlite/introspect.ts b/drizzle-kit/src/dialects/sqlite/introspect.ts
new file mode 100644
index 0000000000..9042701137
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/introspect.ts
@@ -0,0 +1,653 @@
+import type { IntrospectStage, IntrospectStatus } from '../../cli/views';
+import { areStringArraysEqual, type DB } from '../../utils';
+import type { EntityFilter } from '../pull-utils';
+import { filterMigrationsSchema } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	PrimaryKey,
+	SqliteEntities,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import type { Generated } from './grammar';
+import {
+	extractGeneratedColumns,
+	nameForForeignKey,
+	nameForPk,
+	nameForUnique,
+	parseDefault,
+	parseSqliteDdl,
+	parseSqliteFks,
+	parseTableSQL,
+	parseViewSQL,
+	sqlTypeFrom,
+} from './grammar';
+
+export const fromDatabaseForDrizzle = async (
+	db: DB,
+	filter: EntityFilter = () => true,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	migrations: {
+		table: string;
+		schema: string;
+	},
+) => {
+	const res = await fromDatabase(db, filter, progressCallback);
+	res.indexes = res.indexes.filter((it) => it.origin !== 'auto');
+
+	filterMigrationsSchema(res, migrations);
+
+	return res;
+};
+
+export const fromDatabase = async (
+	db: DB,
+	filter: EntityFilter,
+	progressCallback: (
+		stage: IntrospectStage,
+		count: number,
+		status: IntrospectStatus,
+	) => void = () => {},
+	queryCallback: (
+		id: string,
+		rows: Record<string, unknown>[],
+		error: Error | null,
+	) => void = () => {},
+) => {
+	// TODO: fetch tables and views list with system filter from grammar
+	const dbTableColumns = await db.query<{
+		table: string;
+		name: string;
+		columnType: string;
+		notNull: number;
+		defaultValue: string;
+		pk: number;
+		hidden: number;
+		sql: string;
+		type: 'table' | 'view';
+	}>(
+		`SELECT 
+			m.name as "table", 
+			p.name as "name", 
+			p.type as "columnType",
+			p."notnull" as "notNull", 
+			p.dflt_value as "defaultValue",
+			p.pk as pk,
+			p.hidden as hidden,
+			m.sql,
+			m.type as type
+		FROM sqlite_master AS m 
+			JOIN pragma_table_xinfo(m.name) AS p
+		WHERE 
+			m.type = 'table'
+			and m.tbl_name NOT LIKE '\\_cf\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'libsql\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'd1\\_%' ESCAPE '\\'
+		ORDER BY p.cid;
+    `,
+	).then((columns) => {
+		queryCallback('columns', columns, null);
+		return columns.filter((it) => filter({ type: 'table', schema: false, name: it.table }));
+	}).catch((error) => {
+		queryCallback('columns', [], error);
+		throw error;
+	});
+
+	const views = await db.query<{
+		name: string;
+		sql: string;
+	}>(
+		`SELECT
+			m.name as "name",
+			m.sql
+		FROM sqlite_master AS m
+			WHERE
+			m.type = 'view'
+			and m.tbl_name NOT LIKE '\\_cf\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'libsql\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+			and m.tbl_name NOT LIKE 'd1\\_%' ESCAPE '\\'
+		ORDER BY m.name COLLATE NOCASE
+		;`,
+	).then((views) => {
+		queryCallback('views', views, null);
+		return views.filter((it) => filter({ type: 'table', schema: false, name: it.name })).map((it): View => {
+			const definition = parseViewSQL(it.sql);
+
+			if (!definition) {
+				throw new Error(`Could not process view ${it.name}:\n${it.sql}`);
+			}
+
+			return {
+				entityType: 'views',
+				name: it.name,
+				definition,
+				isExisting: false,
+				error: null,
+			};
+		});
+	}).catch((error) => {
+		queryCallback('views', [], error);
+		throw error;
+	});
+
+	let dbViewColumns: {
+		table: string;
+		name: string;
+		columnType: string;
+		notNull: number;
+		defaultValue: string;
+		pk: number;
+		hidden: number;
+	}[] = [];
+	try {
+		dbViewColumns = await db.query<{
+			table: string;
+			name: string;
+			columnType: string;
+			notNull: number;
+			defaultValue: string;
+			pk: number;
+			hidden: number;
+			sql: string;
+			type: 'view';
+		}>(
+			`SELECT 
+				m.name as "table", 
+				p.name as "name", 
+				p.type as "columnType",
+				p."notnull" as "notNull", 
+				p.dflt_value as "defaultValue",
+				p.pk as pk,
+				p.hidden as hidden,
+				m.sql,
+				m.type as type
+			FROM sqlite_master AS m 
+				JOIN pragma_table_xinfo(m.name) AS p
+			WHERE 
+				m.type = 'view'
+				and m.tbl_name NOT LIKE '\\_cf\\_%' ESCAPE '\\'
+				and m.tbl_name NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
+				and m.tbl_name NOT LIKE 'libsql\\_%' ESCAPE '\\'
+				and m.tbl_name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+				and m.tbl_name NOT LIKE 'd1\\_%' ESCAPE '\\'
+			ORDER BY m.name COLLATE NOCASE, p.cid;
+		`,
+		).then((columns) => {
+			queryCallback('viewColumns', columns, null);
+			return columns.filter((it) => filter({ type: 'table', schema: false, name: it.table }));
+		}).catch((error) => {
+			queryCallback('viewColumns', [], error);
+			throw error;
+		});
+	} catch {
+		for (const view of views) {
+			try {
+				const viewColumns = await db.query<{
+					table: string;
+					name: string;
+					columnType: string;
+					notNull: number;
+					defaultValue: string;
+					pk: number;
+					hidden: number;
+				}>(
+					`SELECT 
+						'${view.name}' as "table",
+						p.name as "name", 
+						p.type as "columnType",
+						p."notnull" as "notNull", 
+						p.dflt_value as "defaultValue",
+						p.pk as pk,
+						p.hidden as hidden
+					FROM pragma_table_xinfo(${view.name}) AS p
+					ORDER BY p.name COLLATE NOCASE, p.cid
+					;
+					`,
+				).then((columns) => {
+					queryCallback(`viewColumns:${view.name}`, columns, null);
+					return columns;
+				}).catch((error) => {
+					queryCallback(`viewColumns:${view.name}`, [], error);
+					throw error;
+				});
+				dbViewColumns.push(...viewColumns);
+			} catch (error) {
+				const errorMessage = (error as Error).message;
+				const viewIndex = views.findIndex((v) => v.name === view.name);
+				views[viewIndex] = {
+					...views[viewIndex],
+					error: errorMessage,
+				};
+			}
+		}
+	}
+
+	const dbTablesWithSequences = await db.query<{
+		name: string;
+	}>(
+		`SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' 
+    and name != 'sqlite_stat1' 
+    and name != '_litestream_seq' 
+    and name != '_litestream_lock' 
+    and tbl_name != '_cf_KV' 
+    and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`,
+	).then((tables) => {
+		queryCallback('tablesWithSequences', tables, null);
+		return tables.filter((it) => filter({ type: 'table', schema: false, name: it.name }));
+	}).catch((error) => {
+		queryCallback('tablesWithSequences', [], error);
+		throw error;
+	});
+
+	const dbIndexes = await db.query<{
+		table: string;
+		sql: string;
+		name: string;
+		column: string;
+		isUnique: number;
+		origin: string; // u=auto c=manual pk
+		seq: string;
+		cid: number;
+	}>(`
+		SELECT 
+			m.tbl_name as "table",
+			m.sql,
+			il.name as "name",
+			ii.name as "column",
+			il.[unique] as "isUnique",
+			il.origin,
+			il.seq,
+			ii.cid
+		FROM sqlite_master AS m,
+			pragma_index_list(m.name) AS il,
+			pragma_index_info(il.name) AS ii
+		WHERE 
+			m.type = 'table' 
+			and m.tbl_name != '_cf_KV'
+		ORDER BY m.name COLLATE NOCASE;
+	`).then((indexes) => {
+		queryCallback('indexes', indexes, null);
+		return indexes.filter((it) => filter({ type: 'table', schema: false, name: it.table }));
+	}).catch((error) => {
+		queryCallback('indexes', [], error);
+		throw error;
+	});
+
+	let columnsCount = 0;
+	let tablesCount = new Set();
+	let indexesCount = 0;
+	let foreignKeysCount = 0;
+	let checksCount = 0;
+	let viewsCount = 0;
+
+	type DBIndex = typeof dbIndexes[number];
+	// append primaryKeys by table
+
+	const tableToParsedFks = dbTableColumns.reduce((acc, it) => {
+		if (!acc[it.table]) {
+			acc[it.table] = parseSqliteFks(it.sql);
+		}
+		return acc;
+	}, {} as {
+		[tname: string]: {
+			name: string | null;
+			toTable: string;
+			fromTable: string;
+			fromColumns: string[];
+			toColumns: string[];
+		}[];
+	});
+
+	const tableToPk = dbTableColumns.reduce((acc, it) => {
+		const isPrimary = it.pk !== 0;
+		if (isPrimary) {
+			if (it.table in acc) {
+				acc[it.table].push(it.name);
+			} else {
+				acc[it.table] = [it.name];
+			}
+		}
+		return acc;
+	}, {} as { [tname: string]: string[] });
+
+	const tableToGenerated = dbTableColumns.reduce((acc, it) => {
+		if (it.hidden !== 2 && it.hidden !== 3) return acc;
+		acc[it.table] = extractGeneratedColumns(it.sql);
+		return acc;
+	}, {} as Record<string, Record<string, Generated>>);
+
+	const tableToIndexColumns = dbIndexes.reduce(
+		(acc, it) => {
+			const whereIdx = it.sql.toLowerCase().indexOf(' where ');
+			const where = whereIdx < 0 ? null : it.sql.slice(whereIdx + 7);
+			const column = { value: it.column, isExpression: it.cid === -2 };
+			if (it.table in acc) {
+				if (it.name in acc[it.table]) {
+					const idx = acc[it.table][it.name];
+					idx.columns.push(column);
+				} else {
+					const idx = { index: it, columns: [column], where };
+					acc[it.table][it.name] = idx;
+				}
+			} else {
+				const idx = { index: it, columns: [column], where };
+				acc[it.table] = { [it.name]: idx };
+			}
+			return acc;
+		},
+		{} as Record<
+			string,
+			Record<string, { index: DBIndex; columns: { value: string; isExpression: boolean }[]; where: string | null }>
+		>,
+	);
+
+	const tablesToSQL = dbTableColumns.reduce((acc, it) => {
+		if (it.table in acc) return acc;
+
+		acc[it.table] = it.sql;
+		return acc;
+	}, {} as Record<string, string>) || {};
+
+	const tables: SqliteEntities['tables'][] = [
+		...new Set(dbTableColumns.filter((it) => it.type === 'table').map((it) => it.table)),
+	].map((it) => ({
+		entityType: 'tables',
+		name: it,
+	}));
+
+	const pks: PrimaryKey[] = [];
+	for (const [key, value] of Object.entries(tableToPk)) {
+		const tableSql = tablesToSQL[key];
+		const parsed = parseSqliteDdl(tableSql);
+
+		if (value.length === 1) continue;
+
+		pks.push({
+			entityType: 'pks',
+			table: key,
+			name: parsed.pk.name ?? nameForPk(key),
+			columns: value,
+			nameExplicit: false,
+		});
+	}
+
+	const columns: InterimColumn[] = [];
+	for (const column of dbTableColumns.filter((it) => it.type === 'table')) {
+		columnsCount += 1;
+
+		progressCallback('columns', columnsCount, 'fetching');
+
+		tablesCount.add(column.table);
+
+		progressCallback('tables', tablesCount.size, 'fetching');
+
+		const name = column.name;
+		const notNull = column.notNull === 1; // 'YES', 'NO'
+		const type = sqlTypeFrom(column.columnType); // varchar(256)
+		const isPrimary = column.pk !== 0;
+
+		const columnDefault: Column['default'] = parseDefault(column.columnType, column.defaultValue);
+		const autoincrement = isPrimary && dbTablesWithSequences.some((it) => it.name === column.table);
+		const pk = tableToPk[column.table];
+		const primaryKey = isPrimary && pk && pk.length === 1;
+		const generated = tableToGenerated[column.table]?.[column.name] || null;
+
+		const tableIndexes = Object.values(tableToIndexColumns[column.table] || {});
+
+		const unique = primaryKey
+			? null // if pk, no UNIQUE
+			: tableIndexes.filter((it) => {
+				const idx = it.index;
+
+				// we can only safely define UNIQUE column when there is automatically(origin=u) created unique index on the column(only 1)
+				return idx.origin === 'u' && idx.isUnique && it.columns.length === 1 && idx.table === column.table
+					&& idx.column === column.name;
+			}).map((it) => {
+				const parsed = parseSqliteDdl(it.index.sql);
+
+				const constraint = parsed.uniques.find((parsedUnique) =>
+					areStringArraysEqual(it.columns.map((indexCol) => indexCol.value), parsedUnique.columns)
+				);
+				if (!constraint) return null;
+
+				return { name: constraint.name };
+			})[0] || null;
+
+		const pkName = !primaryKey
+			? null // if pk, no UNIQUE
+			: tableIndexes.filter((it) => {
+				const idx = it.index;
+
+				// we can only safely define PRIMARY KEY column when there is automatically(origin=pk) created unique index on the column(only 1)
+				return idx.origin === 'pk' && idx.isUnique && it.columns.length === 1 && idx.table === column.table
+					&& idx.column === column.name;
+			}).map((it) => {
+				const parsed = parseSqliteDdl(it.index.sql);
+				if (parsed.pk.columns.length > 1) return;
+
+				const constraint = areStringArraysEqual(parsed.pk.columns, [name]) ? parsed.pk : null;
+				if (!constraint) return { name: null };
+
+				return { name: constraint.name };
+			})[0] || null;
+
+		columns.push({
+			entityType: 'columns',
+			table: column.table,
+			default: columnDefault,
+			autoincrement,
+			name,
+			pk: primaryKey,
+			pkName: pkName?.name ?? nameForPk(column.table),
+			type,
+			notNull,
+			generated,
+			isUnique: !!unique,
+			uniqueName: unique?.name ?? null,
+		});
+	}
+
+	progressCallback('columns', columnsCount, 'done');
+	progressCallback('tables', tablesCount.size, 'done');
+
+	const dbFKs = await db.query<{
+		tableFrom: string;
+		tableTo: string;
+		from: string;
+		to: string;
+		onUpdate: string;
+		sql: string;
+		onDelete: string;
+		seq: number;
+		id: number;
+	}>(
+		`SELECT 
+			m.name as "tableFrom",
+			f.id as "id", 
+			f."table" as "tableTo", 
+			f."from", 
+			f."to",
+			m."sql" as sql,
+		  f."on_update" as "onUpdate", 
+			f."on_delete" as "onDelete", 
+			f.seq as "seq"
+		FROM sqlite_master m, pragma_foreign_key_list(m.name) as f 
+		WHERE m.tbl_name != '_cf_KV';`,
+	).then((fks) => {
+		queryCallback('fks', fks, null);
+		return fks.filter((it) => filter({ type: 'table', schema: false, name: it.tableFrom }));
+	}).catch((error) => {
+		queryCallback('fks', [], error);
+		throw error;
+	});
+	type DBFK = typeof dbFKs[number];
+
+	const fksToColumns = dbFKs.reduce((acc, it) => {
+		const key = `${it.tableFrom}:${it.id}`;
+		if (key in acc) {
+			acc[key].columnsFrom.push(it.from);
+			acc[key].columnsTo.push(it.to);
+		} else {
+			acc[key] = {
+				fk: it,
+				columnsFrom: [it.from],
+				columnsTo: [it.to],
+			};
+		}
+		return acc;
+	}, {} as Record<string, { fk: DBFK; columnsFrom: string[]; columnsTo: string[] }>);
+
+	const fks: ForeignKey[] = [];
+
+	for (const entity of Object.values(fksToColumns)) {
+		foreignKeysCount += 1;
+		progressCallback('fks', foreignKeysCount, 'fetching');
+
+		const { columnsFrom, columnsTo, fk } = entity;
+
+		const parsedFks = tableToParsedFks[fk.tableFrom] as typeof tableToParsedFks[string] | undefined;
+
+		const constraint = parsedFks?.find((it) =>
+			areStringArraysEqual(it.fromColumns, columnsFrom) && areStringArraysEqual(it.toColumns, columnsTo)
+			&& (it.toTable === fk.tableTo) && (it.fromTable === fk.tableFrom)
+		);
+
+		let name: string;
+		if (!constraint) {
+			name = nameForForeignKey({ table: fk.tableFrom, columns: columnsFrom, tableTo: fk.tableTo, columnsTo });
+		} else {
+			name = constraint.name
+				?? nameForForeignKey({ table: fk.tableFrom, columns: columnsFrom, tableTo: fk.tableTo, columnsTo });
+		}
+
+		fks.push({
+			entityType: 'fks',
+			table: fk.tableFrom,
+			name: name,
+			tableTo: fk.tableTo,
+			columns: columnsFrom,
+			columnsTo: columnsTo,
+			nameExplicit: true,
+			onDelete: fk.onDelete ?? 'NO ACTION',
+			onUpdate: fk.onUpdate ?? 'NO ACTION',
+		});
+	}
+
+	progressCallback('fks', foreignKeysCount, 'done');
+
+	const indexes: Index[] = [];
+	for (const [table, index] of Object.entries(tableToIndexColumns)) {
+		const values = Object.values(index);
+		for (const { index, columns, where } of values) {
+			indexesCount += 1;
+			progressCallback('indexes', indexesCount, 'fetching');
+
+			const origin = index.origin === 'u' || index.origin === 'pk' ? 'auto' : index.origin === 'c' ? 'manual' : null;
+			if (!origin) throw new Error(`Index with unexpected origin: ${index.origin}`);
+
+			indexes.push({
+				entityType: 'indexes',
+				table,
+				name: index.name,
+				isUnique: index.isUnique === 1,
+				origin,
+				where,
+				columns,
+			});
+		}
+	}
+	progressCallback('indexes', indexesCount, 'done');
+	progressCallback('enums', 0, 'done');
+
+	const viewsToColumns = dbViewColumns.reduce((acc, it) => {
+		const column: ViewColumn = {
+			view: it.table,
+			name: it.name,
+			type: sqlTypeFrom(it.columnType),
+			notNull: it.notNull === 1,
+		};
+		if (it.table in acc) {
+			acc[it.table].push(column);
+		} else {
+			acc[it.table] = [column];
+		}
+		return acc;
+	}, {} as Record<string, ViewColumn[]>);
+
+	viewsCount = Object.keys(viewsToColumns).length;
+	progressCallback('views', viewsCount, 'fetching');
+
+	progressCallback('views', viewsCount, 'done');
+
+	let checkCounter = 0;
+	const checkConstraints: Record<string, CheckConstraint> = {};
+
+	const checks: CheckConstraint[] = [];
+	for (const [table, sql] of Object.entries(tablesToSQL)) {
+		const res = parseTableSQL(sql);
+		for (const it of res.checks) {
+			const { name, value } = it;
+
+			let checkName = name ? name : `${table}_check_${++checkCounter}`;
+			checks.push({ entityType: 'checks', table, name: checkName, value: value.trim() });
+		}
+
+		checksCount += Object.values(checkConstraints).length;
+		progressCallback('checks', checksCount, 'fetching');
+	}
+
+	progressCallback('checks', checksCount, 'done');
+
+	const uniques: UniqueConstraint[] = [];
+	for (const [table, item] of Object.entries(tableToIndexColumns)) {
+		for (const { columns, index } of Object.values(item).filter((it) => it.index.isUnique)) {
+			if (columns.length === 1) continue;
+			if (columns.some((it) => it.isExpression)) {
+				throw new Error(`unexpected unique index '${index.name}' with expression value: ${index.sql}`);
+			}
+
+			const origin = index.origin === 'u' || index.origin === 'pk' ? 'auto' : index.origin === 'c' ? 'manual' : null;
+			if (!origin) throw new Error(`Index with unexpected origin: ${index.origin}`);
+
+			const parsed = parseSqliteDdl(index.sql);
+
+			const constraint = parsed.uniques.find((parsedUnique) =>
+				areStringArraysEqual(columns.map((it) => it.value), parsedUnique.columns)
+			);
+			if (!constraint) continue;
+
+			uniques.push({
+				entityType: 'uniques',
+				table,
+				name: constraint.name ?? nameForUnique(table, columns.map((it) => it.value)),
+				nameExplicit: true,
+				columns: columns.map((it) => it.value),
+			});
+		}
+	}
+
+	return {
+		tables,
+		columns,
+		pks,
+		fks,
+		indexes,
+		checks,
+		uniques,
+		views,
+		viewsToColumns,
+	};
+};
diff --git a/drizzle-kit/src/dialects/sqlite/serializer.ts b/drizzle-kit/src/dialects/sqlite/serializer.ts
new file mode 100644
index 0000000000..a9ad40fe2a
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/serializer.ts
@@ -0,0 +1,278 @@
+import type { CheckHandlerResult } from '../../cli/commands/check';
+import { humanLog, sqliteSchemaError } from '../../cli/views';
+import { assertUnreachable } from '../../utils';
+import { findLeafSnapshotIds } from '../../utils/utils-node';
+import type { Column, ForeignKey, Index, PrimaryKey, SQLiteDDL, UniqueConstraint } from './ddl';
+import { createDDL, fromEntities, interimToDDL } from './ddl';
+import { fromDrizzleSchema } from './drizzle';
+import type { PreparedSqliteSchema } from './drizzle';
+import type { SqliteSnapshot } from './snapshot';
+import { drySqliteSnapshot, snapshotValidator } from './snapshot';
+import type { JsonStatement } from './statements';
+
+export const prepareSqliteSnapshot = async (
+	snapshots: string[],
+	prepared: PreparedSqliteSchema,
+	checkResult?: CheckHandlerResult,
+): Promise<{
+	ddlPrev: SQLiteDDL;
+	ddlCur: SQLiteDDL;
+	snapshot: SqliteSnapshot;
+	snapshotPrev: SqliteSnapshot;
+	custom: SqliteSnapshot;
+}> => {
+	const { readFileSync } = await import('fs');
+	const { randomUUID } = await import('crypto');
+	const latestSnapshot = snapshots.length === 0
+		? drySqliteSnapshot
+		: snapshotValidator.strict(
+			JSON.parse(readFileSync(snapshots[snapshots.length - 1]).toString()),
+		);
+
+	const branchParentSnapshot = checkResult?.parentSnapshot
+		? snapshotValidator.strict(
+			checkResult.parentSnapshot as Record<string, unknown>,
+		)
+		: null;
+	const branchStatements = (checkResult?.statements ?? []) as JsonStatement[];
+	const useBranchParent = branchParentSnapshot !== null && branchStatements.length > 0;
+	const mergeLeafIds = (checkResult?.leafIds?.length ?? 0) > 1 ? checkResult?.leafIds : undefined;
+
+	const prevSnapshot = useBranchParent
+		? generateLatestSnapshot(branchParentSnapshot!, branchStatements)
+		: latestSnapshot;
+
+	const ddlPrev = createDDL();
+	for (const entry of prevSnapshot.ddl) {
+		ddlPrev.entities.push(entry);
+	}
+
+	const { tables, views } = prepared;
+	const interim = fromDrizzleSchema(tables, views);
+
+	const { ddl: ddlCur, errors } = interimToDDL(interim);
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => sqliteSchemaError(it)).join('\n\n'));
+		process.exit();
+	}
+
+	const id = randomUUID();
+	const prevIds = mergeLeafIds
+		? mergeLeafIds
+		: snapshots.length === 0
+		? [prevSnapshot.id]
+		: findLeafSnapshotIds(snapshots);
+
+	const snapshot = {
+		version: '7',
+		dialect: 'sqlite',
+		id,
+		prevIds,
+		ddl: ddlCur.entities.list(),
+		renames: [],
+	} satisfies SqliteSnapshot;
+
+	const {
+		id: _ignoredId,
+		prevIds: _ignoredPrevIds,
+		...prevRest
+	} = prevSnapshot;
+
+	// that's for custom migrations, when we need new IDs, but old snapshot
+	const custom: SqliteSnapshot = {
+		id,
+		prevIds,
+		...prevRest,
+	};
+
+	return { ddlPrev, ddlCur, snapshot, snapshotPrev: prevSnapshot, custom };
+};
+
+/**
+ * Apply a list of JSON statements to a parent snapshot to derive the equivalent
+ * "latest" snapshot. Used to materialize the prev snapshot when generating a
+ * migration on top of a fork: the parent snapshot plus the merged statements
+ * from each open leaf form the effective parent for diffing the schema.
+ */
+export function generateLatestSnapshot(
+	snapshot: SqliteSnapshot,
+	statements: JsonStatement[],
+): SqliteSnapshot {
+	const ddl = fromEntities(snapshot.ddl.map((it) => ({ ...it })));
+
+	const clearMetaFields = <T>(value: T): T => {
+		if (!value || typeof value !== 'object') {
+			return value;
+		}
+
+		return Object.fromEntries(
+			Object.entries(value as Record<string, unknown>).filter(
+				([key]) => !key.startsWith('$'),
+			),
+		) as T;
+	};
+
+	const push = (entity: { push: (row: unknown) => unknown }, row: unknown) => {
+		entity.push(clearMetaFields(row));
+	};
+	const del = (
+		entity: { delete: (where?: unknown) => unknown },
+		where: unknown,
+	) => {
+		entity.delete(clearMetaFields(where));
+	};
+	const replace = (
+		entity: {
+			delete: (where?: unknown) => unknown;
+			push: (row: unknown) => unknown;
+		},
+		left: unknown,
+		right: unknown,
+	) => {
+		del(entity, left);
+		push(entity, right);
+	};
+
+	const dropTable = (name: string) => {
+		ddl.tables.delete({ name });
+		ddl.columns.delete({ table: name });
+		ddl.indexes.delete({ table: name });
+		ddl.pks.delete({ table: name });
+		ddl.fks.delete({ table: name });
+		ddl.fks.delete({ tableTo: name });
+		ddl.uniques.delete({ table: name });
+		ddl.checks.delete({ table: name });
+	};
+
+	const insertTableFull = (table: {
+		name: string;
+		columns: Column[];
+		indexes: Index[];
+		pk: PrimaryKey | null;
+		fks: ForeignKey[];
+		uniques: UniqueConstraint[];
+		checks: { table: string; value: string; name?: string }[];
+	}) => {
+		ddl.tables.push({ name: table.name });
+		for (const column of table.columns) push(ddl.columns, column);
+		for (const index of table.indexes) push(ddl.indexes, index);
+		if (table.pk) push(ddl.pks, table.pk);
+		for (const fk of table.fks) push(ddl.fks, fk);
+		for (const unique of table.uniques) push(ddl.uniques, unique);
+		for (const check of table.checks) push(ddl.checks, check);
+	};
+
+	for (const statement of statements) {
+		switch (statement.type) {
+			case 'create_table':
+				insertTableFull(statement.table);
+				break;
+			case 'drop_table':
+				dropTable(statement.tableName);
+				break;
+			case 'rename_table':
+				ddl.tables.update({
+					where: { name: statement.from },
+					set: { name: statement.to },
+				});
+				ddl.entities.update({
+					where: { table: statement.from },
+					set: { table: statement.to },
+				});
+				ddl.fks.update({
+					where: { tableTo: statement.from },
+					set: { tableTo: statement.to },
+				});
+				break;
+			case 'recreate_table': {
+				dropTable(statement.from.name);
+				insertTableFull(statement.to);
+				break;
+			}
+
+			case 'add_column':
+				push(ddl.columns, statement.column);
+				if (statement.fk) push(ddl.fks, statement.fk);
+				break;
+			case 'drop_column':
+				del(ddl.columns, statement.column);
+				break;
+			case 'rename_column':
+				ddl.columns.update({
+					where: { table: statement.table, name: statement.from },
+					set: { name: statement.to },
+				});
+				ddl.indexes.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) =>
+							!column.isExpression && column.value === statement.from
+								? { ...column, value: statement.to }
+								: column,
+					},
+				});
+				ddl.pks.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				ddl.fks.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				ddl.fks.update({
+					where: { tableTo: statement.table },
+					set: {
+						columnsTo: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				ddl.uniques.update({
+					where: { table: statement.table },
+					set: {
+						columns: (column) => column === statement.from ? statement.to : column,
+					},
+				});
+				break;
+			case 'recreate_column':
+				replace(
+					ddl.columns,
+					{ table: statement.column.table, name: statement.column.name },
+					statement.column,
+				);
+				if (statement.fk) push(ddl.fks, statement.fk);
+				break;
+
+			case 'create_index':
+				push(ddl.indexes, statement.index);
+				break;
+			case 'drop_index':
+				del(ddl.indexes, statement.index);
+				break;
+
+			case 'create_view':
+				push(ddl.views, statement.view);
+				break;
+			case 'drop_view':
+				del(ddl.views, { name: statement.view.name });
+				break;
+			case 'rename_view':
+				ddl.views.update({
+					where: { name: statement.from.name },
+					set: { name: statement.to.name },
+				});
+				break;
+
+			default:
+				assertUnreachable(statement);
+		}
+	}
+
+	return {
+		...snapshot,
+		ddl: ddl.entities.list(),
+	};
+}
diff --git a/drizzle-kit/src/dialects/sqlite/snapshot.ts b/drizzle-kit/src/dialects/sqlite/snapshot.ts
new file mode 100644
index 0000000000..9c60101c9b
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/snapshot.ts
@@ -0,0 +1,191 @@
+import {
+	any,
+	array as zArray,
+	boolean,
+	coerce,
+	enum as enumType,
+	literal,
+	object,
+	record,
+	string,
+	type TypeOf,
+} from 'zod';
+import { originUUID } from '../../utils';
+import { array, validator } from '../simpleValidator';
+import type { SQLiteDDL, SqliteEntity } from './ddl';
+import { createDDL } from './ddl';
+
+// ------- V3 --------
+const index = object({
+	name: string(),
+	columns: string().array(),
+	where: string().optional(),
+	isUnique: boolean(),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+const compositePK = object({
+	columns: string().array(),
+	name: string().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(), // compatibility with Postgres schema?
+	primaryKey: boolean(),
+	notNull: boolean(),
+	autoincrement: boolean().optional(),
+	default: coerce.string().optional(),
+	generated: object({
+		type: enumType(['stored', 'virtual']),
+		as: string(),
+	}).optional(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const table = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	checkConstraints: record(string(), checkConstraint).default({}),
+}).strict();
+
+export const view = object({
+	name: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	isExisting: boolean(),
+}).strict();
+
+// use main dialect
+const dialect = enumType(['sqlite']);
+
+const schemaHash = object({
+	id: string(),
+	prevIds: zArray(string()),
+}).strict();
+
+const schemaHashV5 = object({
+	id: string(),
+	prevId: string(),
+}).strict();
+
+export const schemaInternalV5 = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	enums: object({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+}).strict();
+
+const latestVersion = literal('7');
+export const schemaInternalV6 = object({
+	version: literal('6'),
+	dialect: dialect,
+	tables: record(string(), table),
+	views: record(string(), view).default({}),
+	enums: object({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: any(),
+}).strict();
+
+export const schemaV5 = schemaInternalV5.merge(schemaHashV5).strict();
+export const schemaV6 = schemaInternalV6.merge(schemaHashV5).strict();
+export const schema = schemaInternalV6.merge(schemaHash).strict();
+export type SQLiteSchemaV6 = TypeOf<typeof schemaV6>;
+export type SQLiteSchema = TypeOf<typeof schema>;
+
+export type Dialect = TypeOf<typeof dialect>;
+
+const tableSquashed = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()).default({}),
+	checkConstraints: record(string(), string()).default({}),
+}).strict();
+
+export const schemaSquashed = object({
+	version: latestVersion,
+	dialect: dialect,
+	tables: record(string(), tableSquashed),
+	views: record(string(), view),
+	enums: record(
+		string(),
+		object({
+			name: string(),
+			schema: string(),
+			values: string().array(),
+		}).strict(),
+	),
+}).strict();
+
+export const sqliteSchemaV5 = schemaV5;
+export const sqliteSchemaV6 = schemaV6;
+
+export const toJsonSnapshot = (
+	ddl: SQLiteDDL,
+	id: string,
+	prevIds: string[],
+	renames: string[],
+): SqliteSnapshot => {
+	return {
+		dialect: 'sqlite',
+		id,
+		prevIds,
+		version: '7',
+		ddl: ddl.entities.list(),
+		renames,
+	};
+};
+
+const ddl = createDDL();
+export const snapshotValidator = validator({
+	version: ['7'],
+	dialect: ['sqlite'],
+	id: 'string',
+	prevIds: array<string>((_) => true),
+	ddl: array<SqliteEntity>((it) => ddl.entities.validate(it)),
+	renames: array<string>((_) => true),
+});
+
+export type SqliteSnapshot = typeof snapshotValidator.shape;
+export const drySqliteSnapshot = snapshotValidator.strict({
+	version: '7',
+	dialect: 'sqlite',
+	id: originUUID,
+	prevIds: [],
+	ddl: [],
+	renames: [],
+});
diff --git a/drizzle-kit/src/dialects/sqlite/statements.ts b/drizzle-kit/src/dialects/sqlite/statements.ts
new file mode 100644
index 0000000000..754ade5a65
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/statements.ts
@@ -0,0 +1,151 @@
+import type { DiffEntities } from '../cockroach/ddl';
+import type { Column, DiffColumn, ForeignKey, Index, SQLiteDDL, TableFull, View } from './ddl';
+
+export interface JsonCreateTableStatement {
+	type: 'create_table';
+	table: TableFull;
+}
+
+export interface JsonRecreateTableStatement {
+	type: 'recreate_table';
+	to: TableFull;
+	from: TableFull;
+	checkDiffs: SQLiteDDL['_']['diffs']['createdrop']['checks'][];
+	uniquesDiff: SQLiteDDL['_']['diffs']['createdrop']['uniques'][];
+	pksDiff: SQLiteDDL['_']['diffs']['createdrop']['pks'][];
+	fksDiff: SQLiteDDL['_']['diffs']['createdrop']['fks'][];
+	indexesDiff: SQLiteDDL['_']['diffs']['createdrop']['indexes'][];
+
+	alteredColumnsBecameGenerated: SQLiteDDL['_']['diffs']['alter']['columns'][];
+	newStoredColumns: Column[];
+
+	columnAlters: SQLiteDDL['_']['diffs']['alter']['columns'][];
+	pksAlters: SQLiteDDL['_']['diffs']['alter']['pks'][];
+	fksAlters: SQLiteDDL['_']['diffs']['alter']['fks'][];
+	uniquesAlters: SQLiteDDL['_']['diffs']['alter']['uniques'][];
+	checksAlters: SQLiteDDL['_']['diffs']['alter']['checks'][];
+}
+
+export interface JsonDropTableStatement {
+	type: 'drop_table';
+	tableName: string;
+}
+
+export interface JsonRenameTableStatement {
+	type: 'rename_table';
+	from: string;
+	to: string;
+}
+
+export interface JsonDropColumnStatement {
+	type: 'drop_column';
+	column: Column;
+}
+
+export interface JsonAddColumnStatement {
+	type: 'add_column';
+	column: Column;
+	fk: ForeignKey | null;
+}
+
+export interface JsonCreateIndexStatement {
+	type: 'create_index';
+	index: Index;
+}
+
+export interface JsonDropIndexStatement {
+	type: 'drop_index';
+	index: Index;
+}
+
+export interface JsonRenameColumnStatement {
+	type: 'rename_column';
+	table: string;
+	from: string;
+	to: string;
+}
+
+export interface JsonRecreateColumnStatement {
+	type: 'recreate_column';
+	column: Column;
+	diffGenerated: DiffEntities['columns']['generated'];
+	fk: ForeignKey | null;
+}
+
+export type JsonCreateViewStatement = {
+	type: 'create_view';
+	view: View;
+};
+
+export interface JsonDropViewStatement {
+	type: 'drop_view';
+	view: View;
+}
+
+export interface JsonRenameViewStatement {
+	type: 'rename_view';
+	from: View;
+	to: View;
+}
+
+export type JsonStatement =
+	| JsonRecreateTableStatement
+	| JsonRecreateColumnStatement
+	| JsonRenameColumnStatement
+	| JsonRecreateColumnStatement
+	| JsonDropTableStatement
+	| JsonRenameTableStatement
+	| JsonDropColumnStatement
+	| JsonCreateIndexStatement
+	| JsonDropIndexStatement
+	| JsonCreateTableStatement
+	| JsonAddColumnStatement
+	| JsonDropViewStatement
+	| JsonRenameViewStatement
+	| JsonCreateViewStatement;
+
+export const prepareStatement = <
+	TType extends JsonStatement['type'],
+	TStatement extends Extract<JsonStatement, { type: TType }>,
+>(
+	type: TType,
+	args: Omit<TStatement, 'type'>,
+): TStatement => {
+	return {
+		type,
+		...args,
+	} as TStatement;
+};
+
+export const prepareAddColumns = (
+	columns: Column[],
+	fks: ForeignKey[],
+): JsonAddColumnStatement[] => {
+	return columns.map((it) => {
+		const fk = fks.find((t) => t.columns.length === 1 && t.columns[0] === it.name && t.table === it.table) || null;
+		return {
+			type: 'add_column',
+			column: it,
+			fk,
+		} satisfies JsonAddColumnStatement;
+	});
+};
+
+export const prepareRecreateColumn = (
+	diffColumn: DiffColumn,
+	column: Column,
+	fk: ForeignKey | null,
+): JsonRecreateColumnStatement => {
+	// there're no other updates of entities, apart from name changes/some deletions+creations
+	// which doesn't trigger recreate
+	if (diffColumn.generated) {
+		return {
+			type: 'recreate_column',
+			diffGenerated: diffColumn.generated,
+			column: column,
+			fk: fk,
+		};
+	}
+
+	throw new Error('unexpected');
+};
diff --git a/drizzle-kit/src/dialects/sqlite/typescript.ts b/drizzle-kit/src/dialects/sqlite/typescript.ts
new file mode 100644
index 0000000000..2f5dfdcf4c
--- /dev/null
+++ b/drizzle-kit/src/dialects/sqlite/typescript.ts
@@ -0,0 +1,436 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { toCamelCase } from 'drizzle-orm/casing';
+import '../../@types/utils';
+import type { Casing } from '../../cli/validations/common';
+import { assertUnreachable } from '../../utils';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	PrimaryKey,
+	SQLiteDDL,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from './ddl';
+import { typeFor } from './grammar';
+
+export const imports = ['integer', 'real', 'text', 'numeric', 'blob', 'customType'] as const;
+export type Import = typeof imports[number];
+const sqliteImports = new Set([
+	'sqliteTable',
+	...imports,
+]);
+
+const objToStatement2 = (json: any) => {
+	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
+
+	const keys = Object.keys(json);
+	if (keys.length === 0) return;
+
+	let statement = '{ ';
+	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
+	statement += ' }';
+	return statement;
+};
+
+const relations = new Set<string>();
+
+const escapeColumnKey = (value: string) => {
+	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
+		return `"${value}"`;
+	}
+	return value;
+};
+
+const withCasing = (value: string, casing?: Casing) => {
+	if (casing === 'preserve') {
+		return escapeColumnKey(value);
+	}
+	if (casing === 'camel') {
+		return escapeColumnKey(value.camelCase());
+	}
+
+	return value;
+};
+
+const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
+	if (casing === 'preserve') {
+		return '';
+	}
+	if (casing === 'camel') {
+		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
+	}
+
+	assertUnreachable(casing);
+};
+
+export const ddlToTypeScript = (
+	schema: SQLiteDDL,
+	casing: Casing,
+	viewColumns: Record<string, ViewColumn[]>,
+	_type: 'sqlite' | 'libsql',
+) => {
+	for (const fk of schema.fks.list()) {
+		const relation = `${fk.table}-${fk.tableTo}`;
+		relations.add(relation);
+	}
+
+	const imports = new Set<string>();
+
+	const columnTypes = new Set<string>([]);
+	for (const it of schema.entities.list()) {
+		if (it.entityType === 'indexes') imports.add(it.isUnique ? 'uniqueIndex' : 'index');
+		if (it.entityType === 'pks' && it.columns.length > 1) imports.add('primaryKey');
+		if (it.entityType === 'uniques') imports.add('unique');
+		if (it.entityType === 'checks') imports.add('check');
+		if (it.entityType === 'columns') columnTypes.add(it.type);
+		if (it.entityType === 'views') imports.add('sqliteView');
+		if (it.entityType === 'tables') imports.add('sqliteTable');
+		if (it.entityType === 'fks') {
+			imports.add('foreignKey');
+			if (it.columns.length > 1 || isCyclic(it) || isSelf(it)) imports.add('type AnySQLiteColumn');
+		}
+	}
+
+	for (const it of Array.from(columnTypes.values())) {
+		imports.add(typeFor(it).drizzleImport());
+	}
+
+	for (const it of Object.values(viewColumns).flat()) {
+		const drizzleImport = typeFor(it.type).drizzleImport();
+		if (sqliteImports.has(drizzleImport)) imports.add(drizzleImport);
+	}
+
+	const tableStatements = [] as string[];
+	for (const table of schema.tables.list()) {
+		const columns = schema.columns.list({ table: table.name });
+		const fks = schema.fks.list({ table: table.name });
+		const pk = schema.pks.one({ table: table.name });
+		const indexes = schema.indexes.list({ table: table.name });
+		const uniqies = schema.uniques.list({ table: table.name });
+		const checks = schema.checks.list({ table: table.name });
+
+		let statement = `export const ${withCasing(table.name, casing)} = sqliteTable("${table.name}", {\n`;
+
+		statement += createTableColumns(columns, fks, pk, casing);
+		statement += '}';
+
+		// more than 2 fields
+		const filteredFKs = fks.filter((it) => {
+			return it.columns.length > 1;
+		});
+
+		if (
+			indexes.length > 0
+			|| filteredFKs.length > 0
+			|| pk && pk.columns.length > 1
+			|| uniqies.length > 0
+			|| checks.length > 0
+		) {
+			statement += ',\n(table) => [';
+			statement += createTableIndexes(table.name, indexes, casing);
+			statement += createTableFKs(Object.values(filteredFKs), casing);
+			statement += pk && pk.columns.length > 1 ? createTablePK(pk, casing) : '';
+			statement += createTableUniques(uniqies, casing);
+			statement += createTableChecks(checks, casing);
+			statement += ']';
+		}
+		statement += ');';
+
+		tableStatements.push(statement);
+	}
+
+	const viewsStatements = schema.views.list().map((view) => {
+		let statement = `export const ${withCasing(view.name, casing)} = sqliteView("${view.name}", {\n`;
+		const columns = viewColumns[view.name] || [];
+		statement += createViewColumns(view, columns, casing);
+		statement += '})';
+		statement += `.as(sql\`${view.definition?.replaceAll('`', '\\`')}\`);`;
+
+		return statement;
+	});
+
+	const importsTs = `import { ${
+		[...imports].join(', ')
+	} } from "drizzle-orm/sqlite-core"\nimport { sql } from "drizzle-orm"\n\n`;
+
+	let decalrations = tableStatements.join('\n\n');
+	decalrations += '\n\n';
+	decalrations += viewsStatements.join('\n\n');
+
+	const file = importsTs + decalrations;
+
+	// for drizzle studio query runner
+	const schemaEntry = `
+    {
+      ${
+		Object.values(schema.tables)
+			.map((it) => withCasing(it.name, casing))
+			.join(',')
+	}
+    }
+  `;
+
+	return { file, imports: importsTs, decalrations, schemaEntry };
+};
+
+const isCyclic = (fk: ForeignKey) => {
+	const key = `${fk.table}-${fk.tableTo}`;
+	const reverse = `${fk.tableTo}-${fk.table}`;
+	return relations.has(key) && relations.has(reverse);
+};
+
+const isSelf = (fk: ForeignKey) => {
+	return fk.table === fk.tableTo;
+};
+
+const tryJson = (it: string) => {
+	try {
+		return JSON.parse(it);
+	} catch {
+		return null;
+	}
+};
+
+const mapColumnDefault = (it: NonNullable<Column['default']>) => {
+	if (
+		typeof it === 'string'
+		&& it.startsWith('(')
+		&& it.endsWith(')')
+	) {
+		return `sql\`${it}\``;
+	}
+	// If default value is NULL as string it will come back from db as "'NULL'" and not just "NULL"
+	if (it === 'NULL') {
+		return `sql\`NULL\``;
+	}
+
+	if (typeof it === 'string') {
+		const json = tryJson(it);
+		if (json) {
+			return objToStatement2(json);
+		}
+
+		return it.replaceAll('"', '\\"').replaceAll("''", "'");
+	}
+
+	return it;
+};
+
+const column = (
+	type: string,
+	name: string,
+	defaultValue: Column['default'],
+	casing: Casing,
+) => {
+	let lowered = type;
+
+	const grammarType = typeFor(type);
+	if (grammarType) {
+		const drizzleType = grammarType.drizzleImport();
+		const res = grammarType.toTs(defaultValue, type);
+		const { def, options, customType } = typeof res === 'string' ? { def: res } : res;
+
+		const defaultStatement = def ? `.default(${def})` : '';
+		const opts = options ? `${JSON.stringify(options)}` : '';
+		return `${withCasing(name, casing)}: ${drizzleType}${customType ? `({ dataType: () => '${customType}' })` : ''}(${
+			dbColumnName({ name, casing, withMode: Boolean(opts) })
+		}${opts})${defaultStatement}`;
+	}
+
+	// TODO: ??
+	if (lowered.startsWith('text')) {
+		const match = lowered.match(/\d+/);
+		let out: string;
+		if (match) {
+			out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing, withMode: true })}{ length: ${
+				match[0]
+			} })`;
+		} else {
+			out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing })})`;
+		}
+
+		out += defaultValue ? `.default("${mapColumnDefault(defaultValue)}")` : '';
+		return out;
+	}
+
+	return `// Warning: Can't parse ${type} from database\n\t// ${type}Type: ${type}("${name}")`;
+};
+
+const createTableColumns = (
+	columns: Column[],
+	fks: ForeignKey[],
+	pk: PrimaryKey | null,
+	casing: Casing,
+): string => {
+	let statement = '';
+	for (const it of columns) {
+		const isPrimary = pk && pk.columns.length === 1 && pk.columns[0] === it.name && pk.table === it.table;
+
+		statement += '\t';
+		statement += column(it.type, it.name, it.default, casing);
+		statement += isPrimary ? `.primaryKey(${it.autoincrement ? '{ autoIncrement: true }' : ''})` : '';
+		statement += it.notNull && !isPrimary ? '.notNull()' : '';
+		statement += it.generated
+			? `.generatedAlwaysAs(sql\`${
+				it.generated.as.replace(/`/g, '\\`').slice(1, -1)
+			}\`, { mode: "${it.generated.type}" })`
+			: '';
+
+		const references = fks.filter((fk) => fk.columns.length === 1 && fk.columns[0] === it.name);
+
+		for (const fk of references) {
+			const typeSuffix = isCyclic(fk) ? ': AnySQLiteColumn' : '';
+
+			statement += `.references(()${typeSuffix} => ${withCasing(fk.tableTo, casing)}.${
+				withCasing(fk.columnsTo[0], casing)
+			}`;
+
+			const onDelete = (fk.onDelete && fk.onDelete !== 'NO ACTION') ? fk.onDelete.toLowerCase() : null;
+			const onUpdate = (fk.onUpdate && fk.onUpdate !== 'NO ACTION') ? fk.onUpdate.toLowerCase() : null;
+			const params = { onDelete, onUpdate };
+
+			const paramsStr = objToStatement2(params);
+			if (paramsStr) {
+				statement += `, ${paramsStr} )`;
+			} else {
+				statement += `)`;
+			}
+		}
+		statement += ',\n';
+	}
+
+	return statement;
+};
+
+const createViewColumns = (view: View, columns: ViewColumn[], casing: Casing) => {
+	let statement = '';
+
+	for (const it of columns) {
+		const key = withCasing(it.name, casing);
+
+		const grammarType = typeFor(it.type);
+		const drizzleType = grammarType.drizzleImport();
+		const res = grammarType.toTs(null, it.type);
+		const { def: _def, customType } = typeof res === 'string' ? { def: res } : res;
+
+		statement += `${key}: ${drizzleType}${
+			drizzleType === 'customType' ? `({ dataType: () => '${!customType ? 'unknown' : customType}' })` : ''
+		}()`;
+		statement += it.notNull ? '.notNull()' : '';
+		statement += ',\n';
+	}
+
+	return statement;
+};
+
+const createTableIndexes = (
+	tableName: string,
+	idxs: Index[],
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	for (const it of idxs) {
+		const columnNames = it.columns.filter((c) => !c.isExpression).map((c) => c.value);
+		const indexGeneratedName = `${tableName}_${columnNames.join('_')}_index`;
+		const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
+
+		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
+		statement += `${escapedIndexName})`;
+		statement += `.on(${
+			it.columns
+				.map((it) => `table.${withCasing(it.value, casing)}`)
+				.join(', ')
+		}),`;
+		statement += `\n`;
+	}
+
+	return statement;
+};
+
+const createTableUniques = (
+	unqs: UniqueConstraint[],
+	casing: Casing,
+): string => {
+	let statement = '';
+
+	unqs.forEach((it) => {
+		statement += 'unique(';
+		statement += `"${it.name}")`;
+		statement += `.on(${
+			it.columns
+				.map((it) => `table.${withCasing(it, casing)}`)
+				.join(', ')
+		}),`;
+		statement += `\n`;
+	});
+
+	return statement;
+};
+
+const createTableChecks = (
+	checks: CheckConstraint[],
+	_casing: Casing,
+): string => {
+	let statement = '';
+
+	checks.forEach((it) => {
+		statement += 'check(';
+		statement += `"${it.name}", `;
+		statement += `sql\`${it.value}\`)`;
+		statement += `,\n`;
+	});
+
+	return statement;
+};
+
+const createTablePK = (pk: PrimaryKey, casing: Casing): string => {
+	let statement = 'primaryKey({ columns: [';
+	statement += `${
+		pk.columns.map((c) => {
+			return `table.${withCasing(c, casing)}`;
+		}).join(', ')
+	}]`;
+
+	statement += `${pk.name ? `, name: "${pk.name}"` : ''}}`;
+	statement += ')';
+	statement += `,\n`;
+	return statement;
+};
+
+const createTableFKs = (fks: ForeignKey[], casing: Casing): string => {
+	let statement = '';
+
+	fks.forEach((it) => {
+		const isSelf = it.tableTo === it.table;
+		const tableTo = isSelf ? 'table' : `${withCasing(it.tableTo, casing)}`;
+		statement += `\n\t\tforeignKey({\n`;
+		statement += `\t\t\tcolumns: [${
+			it.columns
+				.map((i) => `table.${withCasing(i, casing)}`)
+				.join(', ')
+		}],\n`;
+		statement += `\t\t\tforeignColumns: [${
+			it.columnsTo
+				.map((i) => `${tableTo}.${withCasing(i, casing)}`)
+				.join(', ')
+		}],\n`;
+		statement += `\t\t\tname: "${it.name}"\n`;
+		statement += `\t\t})`;
+
+		statement += it.onUpdate && it.onUpdate !== 'no action'
+			? `.onUpdate("${it.onUpdate.toLowerCase()}")`
+			: '';
+
+		statement += it.onDelete && it.onDelete !== 'no action'
+			? `.onDelete("${it.onDelete.toLowerCase()}")`
+			: '';
+
+		statement += `,\n`;
+	});
+
+	return statement;
+};
diff --git a/drizzle-kit/src/dialects/utils.ts b/drizzle-kit/src/dialects/utils.ts
new file mode 100644
index 0000000000..aca69889da
--- /dev/null
+++ b/drizzle-kit/src/dialects/utils.ts
@@ -0,0 +1,244 @@
+import { type DB, type Simplify, trimChar } from '../utils';
+import type { CockroachDDL } from './cockroach/ddl';
+import type { MssqlDDL } from './mssql/ddl';
+import type { MysqlDDL } from './mysql/ddl';
+import type { PostgresDDL } from './postgres/ddl';
+import type { SQLiteDDL } from './sqlite/ddl';
+
+export type Named = {
+	name: string;
+};
+
+export type NamedWithSchema = {
+	name: string;
+	schema: string;
+};
+
+export type ModifiedItems<T> = {
+	schema?: string;
+	table: string;
+	items: T[];
+};
+
+export type RenamedItems<T> = {
+	schema?: string;
+	table: string;
+	renames: { from: T; to: T }[];
+};
+
+type NullIfUndefined<T> = T extends undefined ? null : T;
+
+export const getOrNull = <T extends Record<string, unknown>, TKey extends keyof T>(
+	it: T | null,
+	key: TKey,
+): NullIfUndefined<T[TKey]> | null => {
+	if (it === null) return null;
+	return (it?.[key] ?? null) as any;
+};
+
+export type GroupedRow<
+	TStatement extends { $diffType: 'create' | 'drop' | 'alter'; schema?: string | null; table?: string | null },
+> =
+	& {
+		inserted: TStatement[];
+		deleted: TStatement[];
+		updated: TStatement[];
+	}
+	& {
+		[K in 'schema' | 'table' as null extends TStatement[K] ? never : K]: TStatement[K];
+	};
+
+export const groupDiffs = <
+	T extends { $diffType: 'create' | 'drop' | 'alter'; schema?: string | null; table?: string | null },
+>(
+	arr: T[],
+): Simplify<GroupedRow<T>>[] => {
+	if (arr.length === 0) return [];
+	if (!arr[0].table && !arr[0].schema) throw new Error('No schema or table in item');
+
+	const res: GroupedRow<T>[] = [];
+	for (let i = 0; i < arr.length; i++) {
+		const stmnt = arr[i];
+
+		const idx = res.findIndex((it) =>
+			('schema' in it ? stmnt.schema === it['schema'] : true) && ('table' in it ? stmnt.table === it.table : true)
+		);
+
+		let item: GroupedRow<T>;
+
+		if (idx < 0) {
+			const sch = 'schema' in stmnt ? { schema: stmnt.schema } : {};
+			const tbl = 'table' in stmnt ? { table: stmnt.table } : {};
+			item = {
+				...sch,
+				...tbl,
+				deleted: [],
+				inserted: [],
+				updated: [],
+			} as any;
+			res.push(item);
+		} else {
+			item = res[idx];
+		}
+
+		if (stmnt.$diffType === 'drop') {
+			item.deleted.push(stmnt);
+		} else if (stmnt.$diffType === 'create') {
+			item.inserted.push(stmnt);
+		} else {
+			item.updated.push(stmnt);
+		}
+	}
+	return res;
+};
+
+export const numberForTs = (value: string): { mode: 'number' | 'bigint'; value: string } => {
+	const check = Number(value);
+	if (Number.isNaN(check)) return { mode: 'number', value: `sql\`${trimChar(escapeForTsLiteral(value), '"')}\`` };
+
+	if (check >= Number.MIN_SAFE_INTEGER && check <= Number.MAX_SAFE_INTEGER) return { mode: 'number', value: value };
+	return { mode: 'bigint', value: `${value}n` };
+};
+
+// numeric precision can be bigger than 9 as it was before here
+export const parseParams = (type: string) => {
+	return type.match(/\(((?:\d+(?:\s*,\s*\d+)*)|max)\)/i)?.[1].split(',').map((x) => x.trim()) ?? [];
+};
+
+export const escapeForSqlDefault = (input: string, mode: 'default' | 'pg-arr' = 'default') => {
+	let value = input.replace(/\\/g, '\\\\').replace(/'/g, "''");
+	if (mode === 'pg-arr') value = value.replaceAll('"', '\\"');
+	return value;
+};
+
+export const unescapeFromSqlDefault = (input: string, mode: 'default' | 'arr' = 'default') => {
+	let res = input.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+
+	if (mode === 'arr') return res;
+	return res.replace(/''/g, "'");
+};
+
+export const escapeForTsLiteral = (input: string) => {
+	return JSON.stringify(input);
+};
+
+export function inspect(it: any): string {
+	if (!it) return '';
+
+	const keys = Object.keys(it);
+	if (keys.length === 0) return '';
+
+	const pairs = keys.map((key) => {
+		const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)
+			? key
+			: `'${key}'`;
+
+		const value = it[key];
+		const formattedValue = typeof value === 'string' ? `'${value}'` : String(value);
+
+		return `${formattedKey}: ${formattedValue}`;
+	});
+
+	return `{ ${pairs.join(', ')} }`;
+}
+
+export const preserveEntityNames = <
+	C extends
+		| PostgresDDL['uniques' | 'fks' | 'pks' | 'indexes']
+		| MysqlDDL['indexes' | 'fks']
+		| MssqlDDL['uniques' | 'fks' | 'pks' | 'defaults']
+		| CockroachDDL['fks' | 'pks' | 'indexes']
+		| SQLiteDDL['uniques' | 'pks' | 'fks'],
+>(
+	collection1: C,
+	collection2: C,
+	mode: 'push' | 'default',
+) => {
+	const items = collection1.list().filter((x) => mode === 'push' || !x.nameExplicit);
+	for (const left of items) {
+		const { entityType: _1, name: _2, nameExplicit: _3, ...filter } = left;
+
+		const match = collection2.list({ ...filter, nameExplicit: false } as any);
+
+		if (match.length !== 1 || match[0].name === left.name) continue;
+
+		collection2.update({
+			set: { name: left.name },
+			where: {
+				...filter,
+				nameExplicit: false,
+			} as any,
+		});
+	}
+};
+
+export const filterMigrationsSchema = (
+	interim: {
+		schemas?: { name: string }[];
+		columns: { table: string; schema?: string }[];
+		pks: { table: string; schema?: string }[];
+		tables: { name: string; schema?: string }[];
+		defaults?: { table: string; schema?: string }[]; // for mssql only
+	},
+	migrations: {
+		schema: string;
+		table: string;
+	},
+) => {
+	const migrationsSchema = migrations.schema;
+	const migrationsTable = migrations.table;
+
+	interim.tables = interim.tables.filter((table) =>
+		!(table.name === migrationsTable && (table.schema ? table.schema === migrationsSchema : true))
+	);
+	interim.columns = interim.columns.filter((column) =>
+		!(column.table === migrationsTable && (column.schema ? column.schema === migrationsSchema : true))
+	);
+	interim.pks = interim.pks.filter((pk) =>
+		!(pk.table === migrationsTable && (pk.schema ? pk.schema === migrationsSchema : true))
+	);
+
+	// mssql only
+	if (interim.defaults) {
+		interim.defaults = interim.defaults.filter((def) =>
+			!(def.table === migrationsTable && (def.schema ? def.schema === migrationsSchema : true))
+		);
+	}
+
+	if (interim.schemas) {
+		let tablesInMigrationSchema = interim.tables.filter((table) => table.schema === migrationsSchema);
+		if (!tablesInMigrationSchema.length) {
+			interim.schemas = interim.schemas.filter((schema) => schema.name !== migrationsSchema);
+		}
+	}
+
+	return interim;
+};
+
+export const batchQuery = async <T>(
+	db: DB,
+	getSQL: (params: { limit: number; cursor: T | undefined }) => string,
+	callback: (count: number) => void,
+	batchSize: number = 100_000,
+): Promise<T[]> => {
+	let results: T[] = [];
+	let cursor: T | undefined;
+
+	while (true) {
+		const batch = await db.query(getSQL({ limit: batchSize, cursor }).trim());
+
+		if (batch.length === 0) {
+			break;
+		}
+
+		results.push(...batch);
+		callback(results.length);
+
+		if (batch.length < batchSize) {
+			break;
+		}
+
+		cursor = batch[batch.length - 1];
+	}
+	return results;
+};
diff --git a/drizzle-kit/src/ext/api-mysql.ts b/drizzle-kit/src/ext/api-mysql.ts
new file mode 100644
index 0000000000..eb344aed0a
--- /dev/null
+++ b/drizzle-kit/src/ext/api-mysql.ts
@@ -0,0 +1,54 @@
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnyMySqlTable } from 'drizzle-orm/mysql-core';
+import type { MysqlCredentials } from '../cli/validations/mysql';
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: MysqlCredentials,
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { MySqlTable, getTableConfig } = await import('drizzle-orm/mysql-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForMySQL, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog } = await import('../cli/views');
+
+	const mysqlSchema: Record<string, Record<string, AnyMySqlTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, MySqlTable)) {
+			const schema = getTableConfig(t).schema || 'public';
+			mysqlSchema[schema] = mysqlSchema[schema] || {};
+			mysqlSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForMySQL(credentials, mysqlSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				humanLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
diff --git a/drizzle-kit/src/ext/api-postgres.ts b/drizzle-kit/src/ext/api-postgres.ts
new file mode 100644
index 0000000000..c437625f49
--- /dev/null
+++ b/drizzle-kit/src/ext/api-postgres.ts
@@ -0,0 +1,253 @@
+import type { PGlite } from '@electric-sql/pglite';
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnyPgTable } from 'drizzle-orm/pg-core';
+import type { PgAsyncDatabase } from 'drizzle-orm/pg-core/async';
+import type { EntitiesFilterConfig } from '../cli/validations/common';
+import type { PostgresCredentials } from '../cli/validations/postgres';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+} from '../dialects/postgres/ddl';
+import { createDDL, interimToDDL } from '../dialects/postgres/ddl';
+import type { PostgresSnapshot } from '../dialects/postgres/snapshot';
+import { upToV8 } from '../dialects/postgres/versions';
+import { originUUID } from '../utils';
+import type { DB } from '../utils';
+
+export const generateDrizzleJson = async (
+	imports: Record<string, unknown>,
+	prevId?: string,
+	schemaFilters?: string[],
+): Promise<PostgresSnapshot> => {
+	const { prepareEntityFilter } = await import('src/dialects/pull-utils');
+	const { humanLog, postgresSchemaError, postgresSchemaWarning } = await import('../cli/views');
+	const { toJsonSnapshot } = await import('../dialects/postgres/snapshot');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/postgres/drizzle');
+	const { extractPostgresExisting } = await import('../dialects/drizzle');
+	const prepared = fromExports(imports);
+
+	const existing = extractPostgresExisting(prepared.schemas, prepared.views, prepared.matViews);
+
+	const filter = prepareEntityFilter('postgresql', {
+		schemas: schemaFilters ?? [],
+		tables: [],
+		entities: undefined,
+		extensions: [],
+	}, existing);
+
+	// TODO: do we wan't to export everything or ignore .existing and respect entity filters in config
+	const { schema: interim, errors, warnings } = fromDrizzleSchema(prepared, filter);
+
+	const { ddl, errors: err2 } = interimToDDL(interim);
+	if (warnings.length > 0) {
+		humanLog(warnings.map((it) => postgresSchemaWarning(it)).join('\n\n'));
+	}
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => postgresSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	if (err2.length > 0) {
+		humanLog(err2.map((it) => postgresSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	return toJsonSnapshot(ddl, prevId ? [prevId] : [originUUID], []);
+};
+
+export const generateMigration = async (
+	prev: PostgresSnapshot,
+	cur: PostgresSnapshot,
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { ddlDiff } = await import('../dialects/postgres/diff');
+	const from = createDDL();
+	const to = createDDL();
+
+	for (const it of prev.ddl) {
+		from.entities.push(it);
+	}
+	for (const it of cur.ddl) {
+		to.entities.push(it);
+	}
+
+	const { sqlStatements } = await ddlDiff(
+		from,
+		to,
+		resolver<Schema>('schema'),
+		resolver<Enum>('enum'),
+		resolver<Sequence>('sequence'),
+		resolver<Policy>('policy'),
+		resolver<Role>('role'),
+		resolver<Privilege>('privilege'),
+		resolver<PostgresEntities['tables']>('table'),
+		resolver<Column>('column'),
+		resolver<View>('view'),
+		resolver<UniqueConstraint>('unique'),
+		resolver<Index>('index'),
+		resolver<CheckConstraint>('check'),
+		resolver<PrimaryKey>('primary_key'),
+		resolver<ForeignKey>('foreign key'),
+		'default',
+	);
+
+	return sqlStatements;
+};
+
+export const pushSchema = async (
+	imports: Record<string, unknown>,
+	drizzleInstance: PgAsyncDatabase<any>,
+	entitiesConfig?: EntitiesFilterConfig,
+	migrationsConfig?: {
+		table?: string;
+		schema?: string;
+	},
+) => {
+	const { prepareEntityFilter } = await import('src/dialects/pull-utils');
+	const { resolver } = await import('../cli/prompts');
+	const { fromDatabaseForDrizzle } = await import('src/dialects/postgres/introspect');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/postgres/drizzle');
+	const { suggestions } = await import('../cli/commands/push-postgres');
+	const { extractPostgresExisting } = await import('../dialects/drizzle');
+	const { ddlDiff } = await import('../dialects/postgres/diff');
+	const { sql } = await import('drizzle-orm');
+
+	const migrations = {
+		schema: migrationsConfig?.schema || 'drizzle',
+		table: migrationsConfig?.table || '__drizzle_migrations',
+	};
+
+	const db: DB = {
+		query: async (query: string, _params?: any[]) => {
+			const res = await drizzleInstance.execute(sql.raw(query));
+			return res.rows;
+		},
+	};
+	const prepared = fromExports(imports);
+
+	const filterConfig = entitiesConfig ?? {
+		tables: [],
+		schemas: [],
+		extensions: [],
+		entities: undefined,
+	} satisfies EntitiesFilterConfig;
+	const existing = extractPostgresExisting(prepared.schemas, prepared.views, prepared.matViews);
+	const filter = prepareEntityFilter('postgresql', filterConfig, existing);
+
+	const prev = await fromDatabaseForDrizzle(db, filter, () => {}, migrations);
+
+	// TODO: filter?
+	// TODO: do we wan't to export everything or ignore .existing and respect entity filters in config
+	const { schema: cur } = fromDrizzleSchema(prepared, filter);
+
+	const { ddl: from, errors: _err1 } = interimToDDL(prev);
+	const { ddl: to, errors: _err2 } = interimToDDL(cur);
+
+	// TODO: handle errors, for now don't throw
+
+	const { sqlStatements, statements } = await ddlDiff(
+		from,
+		to,
+		resolver<Schema>('schema'),
+		resolver<Enum>('enum'),
+		resolver<Sequence>('sequence'),
+		resolver<Policy>('policy'),
+		resolver<Role>('role'),
+		resolver<Privilege>('privilege'),
+		resolver<PostgresEntities['tables']>('table'),
+		resolver<Column>('column'),
+		resolver<View>('view'),
+		resolver<UniqueConstraint>('unique'),
+		resolver<Index>('index'),
+		resolver<CheckConstraint>('check'),
+		resolver<PrimaryKey>('primary_key'),
+		resolver<ForeignKey>('foreign key'),
+		'push',
+	);
+
+	const { HintsHandler } = await import('../cli/hints');
+	const hints = await suggestions(db, statements, new HintsHandler());
+
+	return {
+		sqlStatements,
+		hints,
+		apply: async () => {
+			const losses = hints.map((x) => x.statement).filter((x) => typeof x !== 'undefined');
+			for (const st of losses) {
+				await db.query(st);
+			}
+			for (const st of sqlStatements) {
+				await db.query(st);
+			}
+		},
+	};
+};
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: PostgresCredentials | {
+		driver: 'pglite';
+		client: PGlite;
+	},
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { PgTable, getTableConfig } = await import('drizzle-orm/pg-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForPostgres, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog: studioLog } = await import('../cli/views');
+
+	const pgSchema: Record<string, Record<string, AnyPgTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, PgTable)) {
+			const schema = getTableConfig(t).schema || 'public';
+			pgSchema[schema] = pgSchema[schema] || {};
+			pgSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForPostgres(credentials, pgSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				studioLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
+
+export const up = upToV8;
diff --git a/drizzle-kit/src/ext/api-singlestore.ts b/drizzle-kit/src/ext/api-singlestore.ts
new file mode 100644
index 0000000000..9a6bb19c67
--- /dev/null
+++ b/drizzle-kit/src/ext/api-singlestore.ts
@@ -0,0 +1,54 @@
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnySingleStoreTable } from 'drizzle-orm/singlestore-core';
+import type { SingleStoreCredentials } from '../cli/validations/singlestore';
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: SingleStoreCredentials,
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { SingleStoreTable, getTableConfig } = await import('drizzle-orm/singlestore-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForSingleStore, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog } = await import('../cli/views');
+
+	const singleStoreSchema: Record<string, Record<string, AnySingleStoreTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, SingleStoreTable)) {
+			const schema = getTableConfig(t).schema || 'public';
+			singleStoreSchema[schema] = singleStoreSchema[schema] || {};
+			singleStoreSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForSingleStore(credentials, singleStoreSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				humanLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
diff --git a/drizzle-kit/src/ext/api-sqlite.ts b/drizzle-kit/src/ext/api-sqlite.ts
new file mode 100644
index 0000000000..1e06407162
--- /dev/null
+++ b/drizzle-kit/src/ext/api-sqlite.ts
@@ -0,0 +1,58 @@
+/// <reference types="@cloudflare/workers-types" />
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SqliteCredentials } from '../cli/validations/sqlite';
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: SqliteCredentials | {
+		driver: 'd1';
+		binding: D1Database;
+	},
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { SQLiteTable } = await import('drizzle-orm/sqlite-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForSQLite, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog } = await import('../cli/views');
+
+	const sqliteSchema: Record<string, Record<string, AnySQLiteTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, SQLiteTable)) {
+			const schema = 'public'; // sqlite does not have schemas
+			sqliteSchema[schema] = sqliteSchema[schema] || {};
+			sqliteSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForSQLite(credentials, sqliteSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				humanLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
diff --git a/drizzle-kit/src/ext/api.ts b/drizzle-kit/src/ext/api.ts
new file mode 100644
index 0000000000..52dfb8dfb1
--- /dev/null
+++ b/drizzle-kit/src/ext/api.ts
@@ -0,0 +1,345 @@
+// import { LibSQLDatabase } from 'drizzle-orm/libsql';
+// import type { MySql2Database } from 'drizzle-orm/mysql2';
+// import { PgDatabase } from 'drizzle-orm/pg-core';
+// import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
+// import { introspect as postgresIntrospect } from '../cli/commands/pull-postgres';
+// import { sqliteIntrospect } from '../cli/commands/pull-sqlite';
+// import { suggestions } from '../cli/commands/push-postgres';
+// import { updateUpToV6 as upPgV6, updateUpToV7 as upPgV7 } from '../cli/commands/up-postgres';
+// import { resolver } from '../cli/prompts';
+// import type { CasingType } from '../cli/validations/common';
+// import { ProgressView, schemaError, schemaWarning } from '../cli/views';
+// import { fromDrizzleSchema, fromExports } from '../dialects/postgres/drizzle';
+// import { PostgresSnapshot, toJsonSnapshot } from '../dialects/postgres/snapshot';
+// import type { Config } from '../index';
+// import { originUUID } from '../utils';
+// import type { DB, SQLiteDB } from '../utils';
+// import { getTablesFilterByExtensions } from './extensions/getTablesFilterByExtensions';
+
+// import * as postgres from './api-postgres';
+
+// SQLite
+
+// TODO commented this because of build error
+// export const generateSQLiteDrizzleJson = async (
+// 	imports: Record<string, unknown>,
+// 	prevId?: string,
+// 	casing?: CasingType,
+// ): Promise<SQLiteSchemaKit> => {
+// 	const { prepareFromExports } = await import('./dialects/sqlite/imports');
+
+// 	const prepared = prepareFromExports(imports);
+
+// 	const id = randomUUID();
+
+// 	const snapshot = fromDrizzleSchema(prepared.tables, prepared.views, casing);
+
+// 	return {
+// 		...snapshot,
+// 		id,
+// 		prevId: prevId ?? originUUID,
+// 	};
+// };
+
+// export const generateSQLiteMigration = async (
+// 	prev: DrizzleSQLiteSnapshotJSON,
+// 	cur: DrizzleSQLiteSnapshotJSON,
+// ) => {
+// 	const { applySqliteSnapshotsDiff } = await import('./dialects/sqlite/diff');
+
+// 	const validatedPrev = sqliteSchema.parse(prev);
+// 	const validatedCur = sqliteSchema.parse(cur);
+
+// 	const squashedPrev = squashSqliteScheme(validatedPrev);
+// 	const squashedCur = squashSqliteScheme(validatedCur);
+
+// 	const { sqlStatements } = await applySqliteSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		sqliteViewsResolver,
+// 		validatedPrev,
+// 		validatedCur,
+// 	);
+
+// 	return sqlStatements;
+// };
+
+// export const pushSQLiteSchema = async (
+// 	imports: Record<string, unknown>,
+// 	drizzleInstance: LibSQLDatabase<any>,
+// ) => {
+// 	const { applySqliteSnapshotsDiff } = await import('./dialects/sqlite/diff');
+// 	const { sql } = await import('drizzle-orm');
+
+// 	const db: SQLiteDB = {
+// 		query: async (query: string, params?: any[]) => {
+// 			const res = drizzleInstance.all<any>(sql.raw(query));
+// 			return res;
+// 		},
+// 		run: async (query: string) => {
+// 			return Promise.resolve(drizzleInstance.run(sql.raw(query))).then(
+// 				() => {},
+// 			);
+// 		},
+// 	};
+
+// 	const cur = await generateSQLiteDrizzleJson(imports);
+// 	const progress = new ProgressView(
+// 		'Pulling schema from database...',
+// 		'Pulling schema from database...',
+// 	);
+
+// 	const { schema: prev } = await sqliteIntrospect(db, [], progress);
+
+// 	const validatedPrev = sqliteSchema.parse(prev);
+// 	const validatedCur = sqliteSchema.parse(cur);
+
+// 	const squashedPrev = squashSqliteScheme(validatedPrev, 'push');
+// 	const squashedCur = squashSqliteScheme(validatedCur, 'push');
+
+// 	const { statements, _meta } = await applySqliteSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		sqliteViewsResolver,
+// 		validatedPrev,
+// 		validatedCur,
+// 		'push',
+// 	);
+
+// 	const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn(
+// 		db,
+// 		statements,
+// 		squashedPrev,
+// 		squashedCur,
+// 		_meta!,
+// 	);
+
+// 	return {
+// 		hasDataLoss: shouldAskForApprove,
+// 		warnings: infoToPrint,
+// 		statementsToExecute,
+// 		apply: async () => {
+// 			for (const dStmnt of statementsToExecute) {
+// 				await db.query(dStmnt);
+// 			}
+// 		},
+// 	};
+// };
+
+// MySQL
+// TODO commented this because of build error
+// export const generateMySQLDrizzleJson = async (
+// 	imports: Record<string, unknown>,
+// 	prevId?: string,
+// 	casing?: CasingType,
+// ): Promise<MySQLSchemaKit> => {
+// 	const { prepareFromExports } = await import('./serializer/mysqlImports');
+
+// 	const prepared = prepareFromExports(imports);
+
+// 	const id = randomUUID();
+
+// 	const snapshot = generateMySqlSnapshot(prepared.tables, prepared.views, casing);
+
+// 	return {
+// 		...snapshot,
+// 		id,
+// 		prevId: prevId ?? originUUID,
+// 	};
+// };
+
+// export const generateMySQLMigration = async (
+// 	prev: DrizzleMySQLSnapshotJSON,
+// 	cur: DrizzleMySQLSnapshotJSON,
+// ) => {
+// 	const { ddlDiff: applyMysqlSnapshotsDiff } = await import('./dialects/mysql/mysql');
+
+// 	const validatedPrev = mysqlSchema.parse(prev);
+// 	const validatedCur = mysqlSchema.parse(cur);
+
+// 	const squashedPrev = squashMysqlScheme(validatedPrev);
+// 	const squashedCur = squashMysqlScheme(validatedCur);
+
+// 	const { sqlStatements } = await applyMysqlSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		mySqlViewsResolver,
+// 		uniqueResolver,
+// 		validatedPrev,
+// 		validatedCur,
+// 	);
+
+// 	return sqlStatements;
+// };
+
+// export const pushMySQLSchema = async (
+// 	imports: Record<string, unknown>,
+// 	drizzleInstance: MySql2Database<any>,
+// 	databaseName: string,
+// ) => {
+// 	const { ddlDiff: applyMysqlSnapshotsDiff } = await import('./dialects/mysql/mysql');
+// 	const { logSuggestionsAndReturn } = await import(
+// 		'./cli/commands/mysqlPushUtils'
+// 	);
+// 	const { mysqlPushIntrospect } = await import(
+// 		'./cli/commands/pull-mysql'
+// 	);
+// 	const { sql } = await import('drizzle-orm');
+
+// 	const db: DB = {
+// 		query: async (query: string, params?: any[]) => {
+// 			const res = await drizzleInstance.execute(sql.raw(query));
+// 			return res[0] as unknown as any[];
+// 		},
+// 	};
+// 	const cur = await generateMySQLDrizzleJson(imports);
+// 	const { schema: prev } = await mysqlPushIntrospect(db, databaseName, []);
+
+// 	const validatedPrev = mysqlSchema.parse(prev);
+// 	const validatedCur = mysqlSchema.parse(cur);
+
+// 	const squashedPrev = squashMysqlScheme(validatedPrev);
+// 	const squashedCur = squashMysqlScheme(validatedCur);
+
+// 	const { statements } = await applyMysqlSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		mySqlViewsResolver,
+// 		uniqueResolver,
+// 		validatedPrev,
+// 		validatedCur,
+// 		'push',
+// 	);
+
+// 	const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn(
+// 		db,
+// 		statements,
+// 		validatedCur,
+// 	);
+
+// 	return {
+// 		hasDataLoss: shouldAskForApprove,
+// 		warnings: infoToPrint,
+// 		statementsToExecute,
+// 		apply: async () => {
+// 			for (const dStmnt of statementsToExecute) {
+// 				await db.query(dStmnt);
+// 			}
+// 		},
+// 	};
+// };
+
+// SingleStore
+// TODO commented this because of build error
+// export const generateSingleStoreDrizzleJson = async (
+// 	imports: Record<string, unknown>,
+// 	prevId?: string,
+// 	casing?: CasingType,
+// ): Promise<SingleStoreSchemaKit> => {
+// 	const { prepareFromExports } = await import('./serializer/singlestoreImports');
+
+// 	const prepared = prepareFromExports(imports);
+
+// 	const id = randomUUID();
+
+// 	const snapshot = generateSingleStoreSnapshot(prepared.tables, /* prepared.views, */ casing);
+
+// 	return {
+// 		...snapshot,
+// 		id,
+// 		prevId: prevId ?? originUUID,
+// 	};
+// };
+
+// export const generateSingleStoreMigration = async (
+// 	prev: DrizzleSingleStoreSnapshotJSON,
+// 	cur: DrizzleSingleStoreSnapshotJSON,
+// ) => {
+// 	const { applySingleStoreSnapshotsDiff } = await import('./snapshot-differ/singlestore');
+
+// 	const validatedPrev = singlestoreSchema.parse(prev);
+// 	const validatedCur = singlestoreSchema.parse(cur);
+
+// 	const squashedPrev = squashSingleStoreScheme(validatedPrev);
+// 	const squashedCur = squashSingleStoreScheme(validatedCur);
+
+// 	const { sqlStatements } = await applySingleStoreSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		/* singleStoreViewsResolver, */
+// 		validatedPrev,
+// 		validatedCur,
+// 		'push',
+// 	);
+
+// 	return sqlStatements;
+// };
+
+// export const pushSingleStoreSchema = async (
+// 	imports: Record<string, unknown>,
+// 	drizzleInstance: SingleStoreDriverDatabase<any>,
+// 	databaseName: string,
+// ) => {
+// 	const { applySingleStoreSnapshotsDiff } = await import('./snapshot-differ/singlestore');
+// 	const { logSuggestionsAndReturn } = await import(
+// 		'./cli/commands/singlestorePushUtils'
+// 	);
+// 	const { singlestorePushIntrospect } = await import(
+// 		'./cli/commands/pull-singlestore'
+// 	);
+// 	const { sql } = await import('drizzle-orm');
+
+// 	const db: DB = {
+// 		query: async (query: string) => {
+// 			const res = await drizzleInstance.execute(sql.raw(query));
+// 			return res[0] as unknown as any[];
+// 		},
+// 	};
+// 	const cur = await generateSingleStoreDrizzleJson(imports);
+// 	const { schema: prev } = await singlestorePushIntrospect(db, databaseName, []);
+
+// 	const validatedPrev = singlestoreSchema.parse(prev);
+// 	const validatedCur = singlestoreSchema.parse(cur);
+
+// 	const squashedPrev = squashSingleStoreScheme(validatedPrev);
+// 	const squashedCur = squashSingleStoreScheme(validatedCur);
+
+// 	const { statements } = await applySingleStoreSnapshotsDiff(
+// 		squashedPrev,
+// 		squashedCur,
+// 		tablesResolver,
+// 		columnsResolver,
+// 		/* singleStoreViewsResolver, */
+// 		validatedPrev,
+// 		validatedCur,
+// 		'push',
+// 	);
+
+// 	const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn(
+// 		db,
+// 		statements,
+// 		validatedCur,
+// 		validatedPrev,
+// 	);
+
+// 	return {
+// 		hasDataLoss: shouldAskForApprove,
+// 		warnings: infoToPrint,
+// 		statementsToExecute,
+// 		apply: async () => {
+// 			for (const dStmnt of statementsToExecute) {
+// 				await db.query(dStmnt);
+// 			}
+// 		},
+// 	};
+// };
diff --git a/drizzle-kit/src/ext/mover-mysql.ts b/drizzle-kit/src/ext/mover-mysql.ts
new file mode 100644
index 0000000000..3185f85a84
--- /dev/null
+++ b/drizzle-kit/src/ext/mover-mysql.ts
@@ -0,0 +1,18 @@
+export {
+	type CheckConstraint,
+	type Column,
+	createDDL,
+	type ForeignKey,
+	type Index,
+	type InterimColumn,
+	type MysqlDDL,
+	type PrimaryKey,
+	type Table,
+	type View,
+} from '../dialects/mysql/ddl';
+
+import { ddlDiffDry as ddd } from '../dialects/mysql/diff';
+import { fromDatabase as fd } from '../dialects/mysql/introspect';
+
+export const ddlDiffDry = ddd;
+export const fromDatabase = fd;
diff --git a/drizzle-kit/src/ext/mover-postgres.ts b/drizzle-kit/src/ext/mover-postgres.ts
new file mode 100644
index 0000000000..2fe1e2aba4
--- /dev/null
+++ b/drizzle-kit/src/ext/mover-postgres.ts
@@ -0,0 +1,29 @@
+export {
+	type CheckConstraint,
+	type Column,
+	createDDL,
+	type Enum,
+	type ForeignKey,
+	type Identity,
+	type Index,
+	type InterimSchema,
+	type Policy,
+	type PostgresDDL,
+	type PostgresEntity,
+	type PrimaryKey,
+	type Role,
+	type Schema,
+	type Sequence,
+	type UniqueConstraint,
+	type View,
+} from '../dialects/postgres/ddl';
+
+import { ddlDiffDry as ddd } from '../dialects/postgres/diff';
+import { fromDatabase as fd, fromDatabaseForDrizzle as fdfd } from '../dialects/postgres/introspect';
+
+export const ddlDiffDry = ddd;
+export const fromDatabase = fd;
+export const fromDatabaseForDrizzle = fdfd;
+
+import type { PostgresEntities } from '../dialects/postgres/ddl';
+export type Table = PostgresEntities['tables'];
diff --git a/drizzle-kit/src/ext/studio-mysql.ts b/drizzle-kit/src/ext/studio-mysql.ts
new file mode 100644
index 0000000000..d9b6d30324
--- /dev/null
+++ b/drizzle-kit/src/ext/studio-mysql.ts
@@ -0,0 +1,143 @@
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimSchema,
+	MysqlEntities,
+	PrimaryKey,
+	View,
+	ViewColumn,
+} from '../dialects/mysql/ddl';
+import { interimToDDL } from '../dialects/mysql/ddl';
+import { ddlDiff } from '../dialects/mysql/diff';
+import { fromDatabase as fd } from '../dialects/mysql/introspect';
+import { mockResolver } from '../utils/mocks';
+
+export type Interim<T> = Omit<T, 'entityType'>;
+
+export type InterimTable = {
+	name: string;
+	columns: Interim<InterimColumn>[];
+	indexes: Interim<Index>[];
+	checks: Interim<CheckConstraint>[];
+	pks: Interim<PrimaryKey>[];
+	fks: Interim<ForeignKey>[];
+};
+
+export type InterimView = {
+	name: string;
+	columns: Interim<Column>[];
+	definition: string;
+	algorithm: 'undefined' | 'merge' | 'temptable';
+	sqlSecurity: 'definer' | 'invoker';
+	withCheckOption: 'local' | 'cascaded' | null;
+};
+
+export type InterimStudioSchema = {
+	tables: InterimTable[];
+	views: InterimView[];
+};
+
+const fromInterims = ({
+	tables,
+	views,
+}: InterimStudioSchema): InterimSchema => {
+	const tbls: MysqlEntities['tables'][] = tables.map((it) => ({
+		entityType: 'tables',
+		name: it.name,
+	}));
+	const columns: InterimColumn[] = tables
+		.map((table) => {
+			return table.columns.map((it) => {
+				return {
+					entityType: 'columns',
+					...it,
+				} satisfies InterimColumn;
+			});
+		})
+		.flat(1);
+
+	const indexes: Index[] = tables
+		.map((table) => {
+			return table.indexes.map((it) => {
+				return { entityType: 'indexes', ...it } satisfies Index;
+			});
+		})
+		.flat(1);
+
+	const checks: CheckConstraint[] = tables
+		.map((table) => {
+			return table.checks.map((it) => {
+				return { entityType: 'checks', ...it } satisfies CheckConstraint;
+			});
+		})
+		.flat(1);
+	const fks: ForeignKey[] = tables
+		.map((table) => {
+			return table.fks.map((it) => {
+				return { entityType: 'fks', ...it } satisfies ForeignKey;
+			});
+		})
+		.flat(1);
+	const pks: PrimaryKey[] = tables
+		.map((table) => {
+			return table.pks.map((it) => {
+				return { entityType: 'pks', ...it } satisfies PrimaryKey;
+			});
+		})
+		.flat(1);
+
+	const vws: View[] = views.map(({ columns: _, ...it }) => {
+		return {
+			entityType: 'views',
+			algorithm: it.algorithm,
+			definition: it.definition,
+			name: it.name,
+			sqlSecurity: it.sqlSecurity,
+			withCheckOption: it.withCheckOption,
+		};
+	});
+	const viewColumns: ViewColumn[] = views
+		.map((table) => {
+			return table.columns.map((it) => {
+				return {
+					view: table.name,
+					...it,
+				} satisfies ViewColumn;
+			});
+		})
+		.flat(1);
+
+	return {
+		tables: tbls,
+		columns: columns,
+		pks,
+		fks,
+		checks,
+		indexes,
+		views: vws,
+		viewColumns,
+	};
+};
+
+export const diffMySql = async (from: InterimStudioSchema, to: InterimStudioSchema, renamesArr: string[]) => {
+	const { ddl: ddl1 } = interimToDDL(fromInterims(from));
+	const { ddl: ddl2 } = interimToDDL(fromInterims(to));
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, groupedStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+
+	return { sqlStatements, groupedStatements, statements };
+};
+
+export const fromDatabase = fd;
diff --git a/drizzle-kit/src/ext/studio-postgres.ts b/drizzle-kit/src/ext/studio-postgres.ts
new file mode 100644
index 0000000000..4e478ac7b3
--- /dev/null
+++ b/drizzle-kit/src/ext/studio-postgres.ts
@@ -0,0 +1,199 @@
+import { fromDatabase as afd } from '../dialects/postgres/aws-introspect';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	InterimColumn,
+	InterimIndex,
+	InterimSchema,
+	Policy,
+	PostgresEntities,
+	PrimaryKey,
+	Privilege,
+	Role,
+	Schema,
+	Sequence,
+	UniqueConstraint,
+	View,
+	ViewColumn,
+} from '../dialects/postgres/ddl';
+import { interimToDDL } from '../dialects/postgres/ddl';
+import { ddlDiff } from '../dialects/postgres/diff';
+import { fromDatabase as dfd } from '../dialects/postgres/duckdb-introspect';
+import { fromDatabase as fd } from '../dialects/postgres/introspect';
+import { mockResolver } from '../utils/mocks';
+
+export type Interim<T> = Omit<T, 'entityType'>;
+
+export type InterimTable = {
+	schema: string;
+	name: string;
+	columns: Interim<InterimColumn>[];
+	indexes: Interim<InterimIndex>[];
+	checks: Interim<CheckConstraint>[];
+	uniques: Interim<UniqueConstraint>[];
+	pks: Interim<PrimaryKey>[];
+	fks: Interim<ForeignKey>[];
+	isRlsEnabled: boolean;
+};
+
+export type InterimView = {
+	schema: string;
+	name: string;
+	materialized: boolean;
+	columns: Interim<Column>[];
+	definition: string | null;
+};
+
+export type InterimStudioSchema = {
+	schemas: Schema[];
+	tables: InterimTable[];
+	views: InterimView[];
+	enums: Enum[];
+	sequences: Sequence[];
+	roles: Role[];
+	privileges: Privilege[];
+	policies: Policy[];
+};
+
+const fromInterims = ({
+	schemas,
+	tables,
+	enums,
+	policies,
+	roles,
+	privileges,
+	sequences,
+	views,
+}: InterimStudioSchema): InterimSchema => {
+	const tbls: PostgresEntities['tables'][] = tables.map((it) => ({
+		entityType: 'tables',
+		name: it.name,
+		schema: it.schema,
+		isRlsEnabled: it.isRlsEnabled,
+	}));
+	const columns: InterimColumn[] = tables
+		.map((table) => {
+			return table.columns.map((it) => {
+				return {
+					entityType: 'columns',
+					...it,
+				} satisfies InterimColumn;
+			});
+		})
+		.flat(1);
+
+	const indexes: InterimIndex[] = tables
+		.map((table) => {
+			return table.indexes.map((it) => {
+				return { entityType: 'indexes', ...it } satisfies InterimIndex;
+			});
+		})
+		.flat(1);
+
+	const checks: CheckConstraint[] = tables
+		.map((table) => {
+			return table.checks.map((it) => {
+				return { entityType: 'checks', ...it } satisfies CheckConstraint;
+			});
+		})
+		.flat(1);
+	const uniques: UniqueConstraint[] = tables
+		.map((table) => {
+			return table.uniques.map((it) => {
+				return { entityType: 'uniques', ...it } satisfies UniqueConstraint;
+			});
+		})
+		.flat(1);
+	const fks: ForeignKey[] = tables
+		.map((table) => {
+			return table.fks.map((it) => {
+				return { entityType: 'fks', ...it } satisfies ForeignKey;
+			});
+		})
+		.flat(1);
+	const pks: PrimaryKey[] = tables
+		.map((table) => {
+			return table.pks.map((it) => {
+				return { entityType: 'pks', ...it } satisfies PrimaryKey;
+			});
+		})
+		.flat(1);
+
+	const vws: View[] = views.map(({ columns: _, ...it }) => {
+		return {
+			entityType: 'views',
+			tablespace: it.schema,
+			using: null,
+			with: null,
+			withNoData: null,
+			definition: it.definition,
+			materialized: it.materialized,
+			name: it.name,
+			schema: it.schema,
+		};
+	});
+	const viewColumns: ViewColumn[] = views
+		.map((table) => {
+			return table.columns.map((it) => {
+				return {
+					view: table.name,
+					typeDimensions: 0, // never user in studio
+					...it,
+				} satisfies ViewColumn;
+			});
+		})
+		.flat(1);
+
+	return {
+		schemas,
+		tables: tbls,
+		columns: columns,
+		pks,
+		fks,
+		checks,
+		uniques,
+		indexes,
+		views: vws,
+		viewColumns,
+		enums,
+		sequences,
+		roles,
+		privileges,
+		policies,
+	};
+};
+
+export const diffPostgresql = async (from: InterimStudioSchema, to: InterimStudioSchema, renamesArr: string[]) => {
+	const { ddl: ddl1 } = interimToDDL(fromInterims(from));
+	const { ddl: ddl2 } = interimToDDL(fromInterims(to));
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, groupedStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames), // views
+		mockResolver(renames), // uniques
+		mockResolver(renames), // indexes
+		mockResolver(renames), // checks
+		mockResolver(renames), // pks
+		'default',
+	);
+
+	return { sqlStatements, groupedStatements, statements };
+};
+
+export const fromDatabase = fd;
+export const fromAwsDatabase = afd;
+export const fromDuckDbDatabase = dfd;
diff --git a/drizzle-kit/src/ext/studio-sqlite.ts b/drizzle-kit/src/ext/studio-sqlite.ts
new file mode 100644
index 0000000000..9d81599dee
--- /dev/null
+++ b/drizzle-kit/src/ext/studio-sqlite.ts
@@ -0,0 +1,118 @@
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	InterimColumn,
+	InterimSchema,
+	PrimaryKey,
+	SqliteEntities,
+	UniqueConstraint,
+	View,
+} from '../dialects/sqlite/ddl';
+import { interimToDDL } from '../dialects/sqlite/ddl';
+import { ddlDiff } from '../dialects/sqlite/diff';
+import { fromDatabase as fd } from '../dialects/sqlite/introspect';
+import { mockResolver } from '../utils/mocks';
+
+export type Interim<T> = Omit<T, 'entityType'>;
+
+export type InterimTable = {
+	name: string;
+	columns: Interim<InterimColumn>[];
+	indexes: Interim<Index>[];
+	checks: Interim<CheckConstraint>[];
+	uniques: Interim<UniqueConstraint>[];
+	pks: Interim<PrimaryKey>[];
+	fks: Interim<ForeignKey>[];
+};
+
+export type InterimView = {
+	name: string;
+	columns: Interim<Column>[];
+	definition: string | null;
+};
+
+export type InterimStudioSchema = {
+	tables: InterimTable[];
+	views: InterimView[];
+};
+
+const fromInterims = (tables: InterimTable[], views: InterimView[]): InterimSchema => {
+	const tbls: SqliteEntities['tables'][] = tables.map((it) => ({
+		entityType: 'tables',
+		name: it.name,
+	}));
+	const columns: InterimColumn[] = tables.map((table) => {
+		return table.columns.map((it) => {
+			return {
+				entityType: 'columns',
+				...it,
+			} satisfies InterimColumn;
+		});
+	}).flat(1);
+
+	const indexes: Index[] = tables.map((table) => {
+		return table.indexes.filter((it) => it.origin === 'manual').map((it) => {
+			return { entityType: 'indexes', ...it } satisfies Index;
+		});
+	}).flat(1);
+
+	const checks: CheckConstraint[] = tables.map((table) => {
+		return table.checks.map((it) => {
+			return { entityType: 'checks', ...it } satisfies CheckConstraint;
+		});
+	}).flat(1);
+	const uniques: UniqueConstraint[] = tables.map((table) => {
+		return table.uniques.map((it) => {
+			return { entityType: 'uniques', ...it } satisfies UniqueConstraint;
+		});
+	}).flat(1);
+	const fks: ForeignKey[] = tables.map((table) => {
+		return table.fks.map((it) => {
+			return { entityType: 'fks', ...it } satisfies ForeignKey;
+		});
+	}).flat(1);
+	const pks: PrimaryKey[] = tables.map((table) => {
+		return table.pks.map((it) => {
+			return { entityType: 'pks', ...it } satisfies PrimaryKey;
+		});
+	}).flat(1);
+
+	const vws: View[] = views.map((it) => {
+		return { entityType: 'views', isExisting: false, error: null, definition: it.definition, name: it.name };
+	});
+
+	return {
+		tables: tbls,
+		columns: columns,
+		pks,
+		fks,
+		checks,
+		uniques,
+		indexes,
+		views: vws,
+	};
+};
+
+export const diffSqlite = async (
+	from: InterimStudioSchema,
+	to: InterimStudioSchema,
+	renamesArr: string[],
+) => {
+	const renames = new Set(renamesArr);
+	const { ddl: ddl1 } = interimToDDL(fromInterims(from.tables, from.views));
+	const { ddl: ddl2 } = interimToDDL(fromInterims(to.tables, to.views));
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+
+	return { sqlStatements, statements, groupedStatements };
+};
+
+export const fromDatabase = fd;
diff --git a/drizzle-kit/src/extensions/getTablesFilterByExtensions.ts b/drizzle-kit/src/extensions/getTablesFilterByExtensions.ts
deleted file mode 100644
index 80321fc6a4..0000000000
--- a/drizzle-kit/src/extensions/getTablesFilterByExtensions.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import type { Config } from '../index';
-
-export const getTablesFilterByExtensions = ({
-	extensionsFilters,
-	dialect,
-}: Pick<Config, 'extensionsFilters' | 'dialect'>): string[] => {
-	if (extensionsFilters) {
-		if (
-			extensionsFilters.includes('postgis')
-			&& dialect === 'postgresql'
-		) {
-			return ['!geography_columns', '!geometry_columns', '!spatial_ref_sys'];
-		}
-	}
-	return [];
-};
diff --git a/drizzle-kit/src/index.ts b/drizzle-kit/src/index.ts
index e3d3d33134..b2bcbbe30e 100644
--- a/drizzle-kit/src/index.ts
+++ b/drizzle-kit/src/index.ts
@@ -1,6 +1,6 @@
-import { ConnectionOptions } from 'tls';
-import type { Driver, Prefix } from './cli/validations/common';
-import type { Dialect } from './schemaValidator';
+import type { ConnectionOptions } from 'tls';
+import type { Driver } from './cli/validations/common';
+import type { Dialect } from './utils/schemaValidator';
 
 // import {SslOptions} from 'mysql2'
 type SslOptions = {
@@ -117,11 +117,9 @@ export type Config =
 		schema?: string | string[];
 		verbose?: boolean;
 		strict?: boolean;
-		casing?: 'camelCase' | 'snake_case';
 		migrations?: {
 			table?: string;
 			schema?: string;
-			prefix?: Prefix;
 		};
 		introspect?: {
 			casing: 'camel' | 'preserve';
@@ -213,6 +211,10 @@ export type Config =
 			dialect: Verify<Dialect, 'sqlite'>;
 			driver: Verify<Driver, 'durable-sqlite'>;
 		}
+		| {
+			dialect: Verify<Dialect, 'sqlite'>;
+			driver: Verify<Driver, 'sqlite-cloud'>;
+		}
 		| {}
 		| {
 			dialect: Verify<Dialect, 'singlestore'>;
@@ -229,28 +231,51 @@ export type Config =
 					url: string;
 				};
 		}
+		// TODO update?
 		| {
-			dialect: Verify<Dialect, 'gel'>;
-			dbCredentials?:
-				& {
-					tlsSecurity?:
-						| 'insecure'
-						| 'no_host_verification'
-						| 'strict'
-						| 'default';
+			dialect: Verify<Dialect, 'mssql'>;
+			dbCredentials:
+				| {
+					port: number;
+					user: string;
+					password: string;
+					database: string;
+					server: string;
+					options?: {
+						encrypt?: boolean;
+						trustServerCertificate?: boolean;
+					};
 				}
-				& (
-					| {
-						url: string;
-					}
-					| ({
-						host: string;
-						port?: number;
-						user?: string;
-						password?: string;
-						database: string;
-					})
-				);
+				| {
+					url: string;
+				};
+		}
+		| {
+			dialect: Verify<Dialect, 'cockroach'>;
+			dbCredentials:
+				| ({
+					host: string;
+					port?: number;
+					user?: string;
+					password?: string;
+					database: string;
+					ssl?:
+						| boolean
+						| 'require'
+						| 'allow'
+						| 'prefer'
+						| 'verify-full'
+						| ConnectionOptions;
+				} & {})
+				| {
+					url: string;
+				};
+		}
+		| {
+			dialect: Verify<Dialect, 'duckdb'>;
+			dbCredentials: {
+				url: string;
+			};
 		}
 	);
 
diff --git a/drizzle-kit/src/introspect-gel.ts b/drizzle-kit/src/introspect-gel.ts
deleted file mode 100644
index 6573889b1b..0000000000
--- a/drizzle-kit/src/introspect-gel.ts
+++ /dev/null
@@ -1,1091 +0,0 @@
-import { getTableName, is } from 'drizzle-orm';
-import { AnyGelTable } from 'drizzle-orm/gel-core';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	Many,
-	One,
-	Relation,
-	Relations,
-} from 'drizzle-orm/relations';
-import './@types/utils';
-import { toCamelCase } from 'drizzle-orm/casing';
-import { Casing } from './cli/validations/common';
-import { assertUnreachable } from './global';
-import {
-	CheckConstraint,
-	Column,
-	ForeignKey,
-	GelKitInternals,
-	GelSchemaInternal,
-	Index,
-	Policy,
-	PrimaryKey,
-	UniqueConstraint,
-} from './serializer/gelSchema';
-import { indexName } from './serializer/gelSerializer';
-import { unescapeSingleQuotes } from './utils';
-
-const gelImportsList = new Set([
-	'gelTable',
-	'smallint',
-	'integer',
-	'bigint',
-	'bigintT',
-	'boolean',
-	'bytes',
-	'dateDuration',
-	'decimal',
-	'doublePrecision',
-	'duration',
-	'json',
-	'localDate',
-	'localTime',
-	'real',
-	'relDuration',
-	'text',
-	'timestamp',
-	'timestamptz',
-	'uuid',
-	'time',
-]);
-
-const mapColumnDefault = (defaultValue: any, isExpression?: boolean) => {
-	if (isExpression) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	return defaultValue;
-};
-
-const relations = new Set<string>();
-
-const escapeColumnKey = (value: string) => {
-	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
-		return `"${value}"`;
-	}
-	return value;
-};
-
-const withCasing = (value: string, casing: Casing) => {
-	if (casing === 'preserve') {
-		return escapeColumnKey(value);
-	}
-	if (casing === 'camel') {
-		return escapeColumnKey(value.camelCase());
-	}
-
-	assertUnreachable(casing);
-};
-
-const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
-	if (casing === 'preserve') {
-		return '';
-	}
-	if (casing === 'camel') {
-		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
-	}
-
-	assertUnreachable(casing);
-};
-
-// export const relationsToTypeScriptForStudio = (
-// 	schema: Record<string, Record<string, AnyGelTable<{}>>>,
-// 	relations: Record<string, Relations<string, Record<string, Relation<string>>>>,
-// ) => {
-// 	const relationalSchema: Record<string, unknown> = {
-// 		...Object.fromEntries(
-// 			Object.entries(schema)
-// 				.map(([key, val]) => {
-// 					// have unique keys across schemas
-// 					const mappedTableEntries = Object.entries(val).map((tableEntry) => {
-// 						return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
-// 					});
-
-// 					return mappedTableEntries;
-// 				})
-// 				.flat(),
-// 		),
-// 		...relations,
-// 	};
-
-// 	const relationsConfig = extractTablesRelationalConfig(relationalSchema, createTableRelationsHelpers);
-
-// 	let result = '';
-
-// 	function findColumnKey(table: AnyGelTable, columnName: string) {
-// 		for (const tableEntry of Object.entries(table)) {
-// 			const key = tableEntry[0];
-// 			const value = tableEntry[1];
-
-// 			if (value.name === columnName) {
-// 				return key;
-// 			}
-// 		}
-// 	}
-
-// 	Object.values(relationsConfig.tables).forEach((table) => {
-// 		const tableName = table.tsName.split('.')[1];
-// 		const relations = table.relations;
-// 		let hasRelations = false;
-// 		let relationsObjAsStr = '';
-// 		let hasOne = false;
-// 		let hasMany = false;
-
-// 		Object.values(relations).forEach((relation) => {
-// 			hasRelations = true;
-
-// 			if (is(relation, Many)) {
-// 				hasMany = true;
-// 				relationsObjAsStr += `\t\t${relation.fieldName}: many(${
-// 					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
-// 				}${typeof relation.relationName !== 'undefined' ? `, { relationName: "${relation.relationName}"}` : ''}),`;
-// 			}
-
-// 			if (is(relation, One)) {
-// 				hasOne = true;
-// 				relationsObjAsStr += `\t\t${relation.fieldName}: one(${
-// 					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
-// 				}, { fields: [${
-// 					relation.config?.fields.map(
-// 						(c) =>
-// 							`${relationsConfig.tableNamesMap[getTableName(relation.sourceTable)].split('.')[1]}.${
-// 								findColumnKey(relation.sourceTable, c.name)
-// 							}`,
-// 					)
-// 				}], references: [${
-// 					relation.config?.references.map(
-// 						(c) =>
-// 							`${relationsConfig.tableNamesMap[getTableName(relation.referencedTable)].split('.')[1]}.${
-// 								findColumnKey(relation.referencedTable, c.name)
-// 							}`,
-// 					)
-// 				}]${typeof relation.relationName !== 'undefined' ? `, relationName: "${relation.relationName}"` : ''}}),`;
-// 			}
-// 		});
-
-// 		if (hasRelations) {
-// 			result += `export const ${tableName}Relation = relations(${tableName}, ({${hasOne ? 'one' : ''}${
-// 				hasOne && hasMany ? ', ' : ''
-// 			}${hasMany ? 'many' : ''}}) => ({
-//         ${relationsObjAsStr}
-//       }));\n`;
-// 		}
-// 	});
-
-// 	return result;
-// };
-
-function generateIdentityParams(identity: Column['identity']) {
-	let paramsObj = `{ name: "${identity!.name}"`;
-	if (identity?.startWith) {
-		paramsObj += `, startWith: ${identity.startWith}`;
-	}
-	if (identity?.increment) {
-		paramsObj += `, increment: ${identity.increment}`;
-	}
-	if (identity?.minValue) {
-		paramsObj += `, minValue: ${identity.minValue}`;
-	}
-	if (identity?.maxValue) {
-		paramsObj += `, maxValue: ${identity.maxValue}`;
-	}
-	if (identity?.cache) {
-		paramsObj += `, cache: ${identity.cache}`;
-	}
-	if (identity?.cycle) {
-		paramsObj += `, cycle: true`;
-	}
-	paramsObj += ' }';
-	if (identity?.type === 'always') {
-		return `.generatedAlwaysAsIdentity(${paramsObj})`;
-	}
-	return `.generatedByDefaultAsIdentity(${paramsObj})`;
-}
-
-export const paramNameFor = (name: string, schema?: string) => {
-	const schemaSuffix = schema && schema !== 'public' ? `In${schema.capitalise()}` : '';
-	return `${name}${schemaSuffix}`;
-};
-
-export const schemaToTypeScript = (schema: GelSchemaInternal, casing: Casing) => {
-	// collectFKs
-	Object.values(schema.tables).forEach((table) => {
-		Object.values(table.foreignKeys).forEach((fk) => {
-			const relation = `${fk.tableFrom}-${fk.tableTo}`;
-			relations.add(relation);
-		});
-	});
-
-	const schemas = Object.fromEntries(
-		Object.entries(schema.schemas).map((it) => {
-			return [it[0], withCasing(it[1].replace('::', ''), casing)];
-		}),
-	);
-
-	// const enumTypes = Object.values(schema.enums).reduce((acc, cur) => {
-	// 	acc.add(`${cur.schema}.${cur.name}`);
-	// 	return acc;
-	// }, new Set<string>());
-
-	const imports = Object.values(schema.tables).reduce(
-		(res, it) => {
-			const idxImports = Object.values(it.indexes).map((idx) => (idx.isUnique ? 'uniqueIndex' : 'index'));
-			const fkImpots = Object.values(it.foreignKeys).map((it) => 'foreignKey');
-			if (Object.values(it.foreignKeys).some((it) => isCyclic(it) && !isSelf(it))) {
-				res.gel.push('type AnyGelColumn');
-			}
-			const pkImports = Object.values(it.compositePrimaryKeys).map((it) => 'primaryKey');
-			const uniqueImports = Object.values(it.uniqueConstraints).map((it) => 'unique');
-
-			const checkImports = Object.values(it.checkConstraints).map(
-				(it) => 'check',
-			);
-
-			const policiesImports = Object.values(it.policies).map(
-				(it) => 'gelPolicy',
-			);
-
-			if (it.schema && it.schema !== 'public' && it.schema !== '') {
-				res.gel.push('gelSchema');
-			}
-
-			res.gel.push(...idxImports);
-			res.gel.push(...fkImpots);
-			res.gel.push(...pkImports);
-			res.gel.push(...uniqueImports);
-			res.gel.push(...policiesImports);
-			res.gel.push(...checkImports);
-
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					let patched: string = col.type?.replace('[]', '') ?? '';
-					patched = patched.startsWith('time without time zone') ? 'localTime' : patched;
-
-					patched = patched === 'double precision' ? 'doublePrecision' : patched;
-					patched = patched.startsWith('edgedbt.bigint_t') ? 'bigintT' : patched;
-
-					patched = patched.startsWith('jsonb') ? 'json' : patched;
-					patched = patched.startsWith('edgedbt.timestamptz_t') ? 'timestamptz' : patched;
-					patched = patched.startsWith('edgedbt.timestamp_t') ? 'timestamp' : patched;
-
-					patched = patched.startsWith('edgedbt.relative_duration_t') ? 'relDuration' : patched;
-					patched = patched.startsWith('bytea') ? 'bytes' : patched;
-
-					patched = patched.startsWith('numeric') ? 'decimal' : patched;
-
-					patched = patched.startsWith('edgedbt.duration_t') ? 'duration' : patched;
-					patched = patched.startsWith('edgedbt.date_t') ? 'localDate' : patched;
-					patched = patched.startsWith('edgedbt.date_duration_t') ? 'dateDuration' : patched;
-
-					return patched;
-				})
-				.filter((type) => {
-					return gelImportsList.has(type);
-				});
-
-			res.gel.push(...columnImports);
-			return res;
-		},
-		{ gel: [] as string[] },
-	);
-
-	// Object.values(schema.sequences).forEach((it) => {
-	// 	if (it.schema && it.schema !== 'public' && it.schema !== '') {
-	// 		imports.gel.push('gelSchema');
-	// 	} else if (it.schema === 'public') {
-	// 		imports.gel.push('gelSequence');
-	// 	}
-	// });
-
-	// Object.values(schema.enums).forEach((it) => {
-	// 	if (it.schema && it.schema !== 'public' && it.schema !== '') {
-	// 		imports.gel.push('gelSchema');
-	// 	} else if (it.schema === 'public') {
-	// 		imports.gel.push('gelEnum');
-	// 	}
-	// });
-
-	if (Object.keys(schema.roles).length > 0) {
-		imports.gel.push('gelRole');
-	}
-
-	// const enumStatements = Object.values(schema.enums)
-	// 	.map((it) => {
-	// 		const enumSchema = schemas[it.schema];
-	// 		// const func = schema || schema === "public" ? "gelTable" : schema;
-	// 		const paramName = paramNameFor(it.name, enumSchema);
-
-	// 		const func = enumSchema ? `${enumSchema}.enum` : 'gelEnum';
-
-	// 		const values = Object.values(it.values)
-	// 			.map((it) => `'${unescapeSingleQuotes(it, false)}'`)
-	// 			.join(', ');
-	// 		return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", [${values}])\n`;
-	// 	})
-	// 	.join('')
-	// 	.concat('\n');
-
-	// const sequencesStatements = Object.values(schema.sequences)
-	// 	.map((it) => {
-	// 		const seqSchema = schemas[it.schema];
-	// 		const paramName = paramNameFor(it.name, seqSchema);
-
-	// 		const func = seqSchema ? `${seqSchema}.sequence` : 'gelSequence';
-
-	// 		let params = '';
-
-	// 		if (it.startWith) {
-	// 			params += `, startWith: "${it.startWith}"`;
-	// 		}
-	// 		if (it.increment) {
-	// 			params += `, increment: "${it.increment}"`;
-	// 		}
-	// 		if (it.minValue) {
-	// 			params += `, minValue: "${it.minValue}"`;
-	// 		}
-	// 		if (it.maxValue) {
-	// 			params += `, maxValue: "${it.maxValue}"`;
-	// 		}
-	// 		if (it.cache) {
-	// 			params += `, cache: "${it.cache}"`;
-	// 		}
-	// 		if (it.cycle) {
-	// 			params += `, cycle: true`;
-	// 		} else {
-	// 			params += `, cycle: false`;
-	// 		}
-
-	// 		return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}"${
-	// 			params ? `, { ${params.trimChar(',')} }` : ''
-	// 		})\n`;
-	// 	})
-	// 	.join('')
-	// 	.concat('');
-
-	const schemaStatements = Object.entries(schemas)
-		.filter((it) => it[0] !== 'public')
-		.map((it) => {
-			return `export const ${it[1].replace('::', '').camelCase()} = gelSchema("${it[0]}");\n`;
-		})
-		.join('');
-
-	const rolesNameToTsKey: Record<string, string> = {};
-
-	const rolesStatements = Object.entries(schema.roles)
-		.map((it) => {
-			const fields = it[1];
-			rolesNameToTsKey[fields.name] = it[0];
-			return `export const ${withCasing(it[0], casing)} = gelRole("${fields.name}", ${
-				!fields.createDb && !fields.createRole && fields.inherit
-					? ''
-					: `${
-						`, { ${fields.createDb ? `createDb: true,` : ''}${fields.createRole ? ` createRole: true,` : ''}${
-							!fields.inherit ? ` inherit: false ` : ''
-						}`.trimChar(',')
-					}}`
-			} );\n`;
-		})
-		.join('');
-
-	const tableStatements = Object.values(schema.tables).map((table) => {
-		const tableSchema = schemas[table.schema];
-		const paramName = paramNameFor(table.name, tableSchema);
-
-		const func = tableSchema ? `${tableSchema}.table` : 'gelTable';
-		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${table.name}", {\n`;
-		statement += createTableColumns(
-			table.name,
-			Object.values(table.columns),
-			Object.values(table.foreignKeys),
-			// enumTypes,
-			new Set(),
-			schemas,
-			casing,
-			schema.internal,
-		);
-		statement += '}';
-
-		// more than 2 fields or self reference or cyclic
-		// Andrii: I switched this one off until we will get custom names in .references()
-		// const filteredFKs = Object.values(table.foreignKeys).filter((it) => {
-		// 	return it.columnsFrom.length > 1 || isSelf(it);
-		// });
-
-		if (
-			Object.keys(table.indexes).length > 0
-			|| Object.values(table.foreignKeys).length > 0
-			|| Object.values(table.policies).length > 0
-			|| Object.keys(table.compositePrimaryKeys).length > 0
-			|| Object.keys(table.uniqueConstraints).length > 0
-			|| Object.keys(table.checkConstraints).length > 0
-		) {
-			statement += ', ';
-			statement += '(table) => [';
-			statement += createTableIndexes(table.name, Object.values(table.indexes), casing);
-			statement += createTableFKs(Object.values(table.foreignKeys), schemas, casing);
-			statement += createTablePKs(
-				Object.values(table.compositePrimaryKeys),
-				casing,
-			);
-			statement += createTableUniques(
-				Object.values(table.uniqueConstraints),
-				casing,
-			);
-			statement += createTablePolicies(
-				Object.values(table.policies),
-				casing,
-				rolesNameToTsKey,
-			);
-			statement += createTableChecks(
-				Object.values(table.checkConstraints),
-				casing,
-			);
-			statement += '\n]';
-		}
-
-		statement += ');';
-		return statement;
-	});
-
-	// const viewsStatements = Object.values(schema.views)
-	// 	.map((it) => {
-	// 		const viewSchema = schemas[it.schema];
-
-	// 		const paramName = paramNameFor(it.name, viewSchema);
-
-	// 		const func = viewSchema
-	// 			? (it.materialized ? `${viewSchema}.materializedView` : `${viewSchema}.view`)
-	// 			: it.materialized
-	// 			? 'gelMaterializedView'
-	// 			: 'gelView';
-
-	// 		const withOption = it.with ?? '';
-
-	// 		const as = `sql\`${it.definition}\``;
-
-	// 		const tablespace = it.tablespace ?? '';
-
-	// 		const columns = createTableColumns(
-	// 			'',
-	// 			Object.values(it.columns),
-	// 			[],
-	// 			enumTypes,
-	// 			schemas,
-	// 			casing,
-	// 			schema.internal,
-	// 		);
-
-	// 		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", {${columns}})`;
-	// 		statement += tablespace ? `.tablespace("${tablespace}")` : '';
-	// 		statement += withOption ? `.with(${JSON.stringify(withOption)})` : '';
-	// 		statement += `.as(${as});`;
-
-	// 		return statement;
-	// 	})
-	// 	.join('\n\n');
-
-	const uniqueGelImports = ['gelTable', ...new Set(imports.gel)];
-
-	const importsTs = `import { ${
-		uniqueGelImports.join(
-			', ',
-		)
-	} } from "drizzle-orm/gel-core"
-import { sql } from "drizzle-orm"\n\n`;
-
-	let decalrations = schemaStatements;
-	decalrations += rolesStatements;
-	// decalrations += enumStatements;
-	// decalrations += sequencesStatements;
-	decalrations += '\n';
-	decalrations += tableStatements.join('\n\n');
-	decalrations += '\n';
-	// decalrations += viewsStatements;
-
-	const file = importsTs + decalrations;
-
-	// for drizzle studio query runner
-	const schemaEntry = `
-    {
-      ${
-		Object.values(schema.tables)
-			.map((it) => withCasing(it.name, casing))
-			.join(',\n')
-	}
-    }
-  `;
-
-	return { file, imports: importsTs, decalrations, schemaEntry };
-};
-
-const isCyclic = (fk: ForeignKey) => {
-	const key = `${fk.tableFrom}-${fk.tableTo}`;
-	const reverse = `${fk.tableTo}-${fk.tableFrom}`;
-	return relations.has(key) && relations.has(reverse);
-};
-
-const isSelf = (fk: ForeignKey) => {
-	return fk.tableFrom === fk.tableTo;
-};
-
-const buildArrayDefault = (defaultValue: string, typeName: string): string => {
-	if (
-		typeof defaultValue === 'string'
-		&& !(defaultValue.startsWith('_nullif_array_nulls(ARRAY[') || defaultValue.startsWith('ARRAY['))
-	) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	const regex = /ARRAY\[(.*)\]/;
-	const match = defaultValue.match(regex);
-
-	if (!match) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	defaultValue = match[1];
-	return `sql\`[${defaultValue}]\``;
-};
-
-const mapDefault = (
-	tableName: string,
-	type: string,
-	name: string,
-	enumTypes: Set<string>,
-	typeSchema: string,
-	defaultValue?: any,
-	internals?: GelKitInternals,
-) => {
-	const isExpression = internals?.tables[tableName]?.columns[name]?.isDefaultAnExpression ?? false;
-	const isArray = internals?.tables[tableName]?.columns[name]?.isArray ?? false;
-	const lowered = type.toLowerCase().replace('[]', '');
-
-	if (name === 'id') {
-		return `.default(sql\`uuid_generate_v4()\`)`;
-	}
-
-	if (isArray) {
-		return typeof defaultValue !== 'undefined' ? `.default(${buildArrayDefault(defaultValue, lowered)})` : '';
-	}
-
-	if (enumTypes.has(`${typeSchema}.${type.replace('[]', '')}`)) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('integer')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue.replaceAll('(', '').replaceAll(')', ''), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('smallint')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue.replaceAll('(', '').replaceAll(')', ''), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('bigint')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue.replaceAll('(', '').replaceAll(')', ''), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('edgedbt.bigint_t')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(BigInt(${mapColumnDefault(defaultValue.replaceAll('(', '').replaceAll(')', ''), isExpression)}))`
-			: '';
-	}
-
-	if (lowered.startsWith('boolean')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('double precision')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('edgedbt.date_duration_t')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, true)})` : '';
-	}
-
-	if (lowered.startsWith('real')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('uuid')) {
-		const res = defaultValue === 'gen_random_uuid()'
-			? '.defaultRandom()'
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-
-		return res;
-	}
-
-	if (lowered.startsWith('numeric')) {
-		defaultValue = defaultValue
-			? (defaultValue.startsWith(`'`) && defaultValue.endsWith(`'`)
-				? defaultValue.substring(1, defaultValue.length - 1)
-				: defaultValue)
-			: undefined;
-		return defaultValue ? `.default(sql\`${defaultValue}\`)` : '';
-	}
-
-	if (lowered.startsWith('edgedbt.timestamptz_t')) {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}(:\d{2})?)?'$/.test(defaultValue) // Matches 'YYYY-MM-DD HH:MI:SS', 'YYYY-MM-DD HH:MI:SS.FFFFFF', 'YYYY-MM-DD HH:MI:SS+TZ', 'YYYY-MM-DD HH:MI:SS.FFFFFF+TZ' and 'YYYY-MM-DD HH:MI:SS+HH:MI'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('time without time zone')) {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{2}:\d{2}(:\d{2})?(\.\d+)?'$/.test(defaultValue) // Matches 'HH:MI', 'HH:MI:SS' and 'HH:MI:SS.FFFFFF'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('edgedbt.duration_t')) {
-		return defaultValue ? `.default(${mapColumnDefault(defaultValue, true)})` : '';
-	}
-
-	if (lowered === 'edgedbt.date_t') {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{4}-\d{2}-\d{2}'$/.test(defaultValue) // Matches 'YYYY-MM-DD'
-			? `.default(${defaultValue})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('edgedbt.relative_duration_t')) {
-		return defaultValue ? `.default(${mapColumnDefault(defaultValue, true)})` : '';
-	}
-
-	if (lowered.startsWith('text')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('json')) {
-		const def = typeof defaultValue !== 'undefined'
-			? defaultValue
-			: null;
-
-		return defaultValue ? `.default(sql\`${def}\`)` : '';
-	}
-
-	if (lowered.startsWith('bytea')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, true)})`
-			: '';
-	}
-
-	return '';
-};
-
-const column = (
-	tableName: string,
-	type: string,
-	name: string,
-	enumTypes: Set<string>,
-	typeSchema: string,
-	casing: Casing,
-	defaultValue?: any,
-	internals?: GelKitInternals,
-) => {
-	const isExpression = internals?.tables[tableName]?.columns[name]?.isDefaultAnExpression ?? false;
-	const lowered = type.toLowerCase().replace('[]', '');
-
-	if (enumTypes.has(`${typeSchema}.${type.replace('[]', '')}`)) {
-		let out = `${withCasing(name, casing)}: ${withCasing(paramNameFor(type.replace('[]', ''), typeSchema), casing)}(${
-			dbColumnName({ name, casing })
-		})`;
-		return out;
-	}
-
-	if (lowered.startsWith('integer')) {
-		let out = `${withCasing(name, casing)}: integer(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('smallint')) {
-		let out = `${withCasing(name, casing)}: smallint(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('bigint')) {
-		let out = `${withCasing(name, casing)}: bigint(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.bigint_t')) {
-		let out = `${withCasing(name, casing)}: bigintT(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('boolean')) {
-		let out = `${withCasing(name, casing)}: boolean(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('double precision')) {
-		let out = `${withCasing(name, casing)}: doublePrecision(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.date_duration_t')) {
-		let out = `${withCasing(name, casing)}: dateDuration(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('real')) {
-		let out = `${withCasing(name, casing)}: real(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('uuid')) {
-		let out = `${withCasing(name, casing)}: uuid(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('numeric')) {
-		let out = `${withCasing(name, casing)}: decimal(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.timestamptz_t')) {
-		let out = `${withCasing(name, casing)}: timestamptz(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.timestamp_t')) {
-		let out = `${withCasing(name, casing)}: timestamp(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.date_t')) {
-		let out = `${withCasing(name, casing)}: localDate(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.duration_t')) {
-		let out = `${withCasing(name, casing)}: duration(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('edgedbt.relative_duration_t')) {
-		let out = `${withCasing(name, casing)}: relDuration(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('text')) {
-		let out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('jsonb')) {
-		let out = `${withCasing(name, casing)}: json(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('time without time zone')) {
-		let out = `${withCasing(name, casing)}: localTime(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('bytea')) {
-		let out = `${withCasing(name, casing)}: bytes(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	let unknown = `// TODO: failed to parse database type '${type}'\n`;
-	unknown += `\t${withCasing(name, casing)}: unknown("${name}")`;
-	return unknown;
-};
-
-const dimensionsInArray = (size?: number): string => {
-	let res = '';
-	if (typeof size === 'undefined') return res;
-	for (let i = 0; i < size; i++) {
-		res += '.array()';
-	}
-	return res;
-};
-
-const createTableColumns = (
-	tableName: string,
-	columns: Column[],
-	fks: ForeignKey[],
-	enumTypes: Set<string>,
-	schemas: Record<string, string>,
-	casing: Casing,
-	internals: GelKitInternals,
-): string => {
-	let statement = '';
-
-	// no self refs and no cyclic
-	const oneColumnsFKs = Object.values(fks)
-		.filter((it) => {
-			return !isSelf(it);
-		})
-		.filter((it) => it.columnsFrom.length === 1);
-
-	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
-		const arr = res[it.columnsFrom[0]] || [];
-		arr.push(it);
-		res[it.columnsFrom[0]] = arr;
-		return res;
-	}, {} as Record<string, ForeignKey[]>);
-
-	columns.forEach((it) => {
-		const columnStatement = column(
-			tableName,
-			it.type,
-			it.name,
-			enumTypes,
-			it.typeSchema ?? 'public',
-			casing,
-			it.default,
-			internals,
-		);
-		statement += '\t';
-		statement += columnStatement;
-		// Provide just this in column function
-		if (internals?.tables[tableName]?.columns[it.name]?.isArray) {
-			statement += dimensionsInArray(internals?.tables[tableName]?.columns[it.name]?.dimensions);
-		}
-		statement += mapDefault(tableName, it.type, it.name, enumTypes, it.typeSchema ?? 'public', it.default, internals);
-		statement += it.primaryKey ? '.primaryKey()' : '';
-		statement += it.notNull && !it.identity ? '.notNull()' : '';
-
-		statement += it.identity ? generateIdentityParams(it.identity) : '';
-
-		statement += it.generated ? `.generatedAlwaysAs(sql\`${it.generated.as}\`)` : '';
-
-		// const fks = fkByColumnName[it.name];
-		// Andrii: I switched it off until we will get a custom naem setting in references
-		// if (fks) {
-		// 	const fksStatement = fks
-		// 		.map((it) => {
-		// 			const onDelete = it.onDelete && it.onDelete !== 'no action' ? it.onDelete : null;
-		// 			const onUpdate = it.onUpdate && it.onUpdate !== 'no action' ? it.onUpdate : null;
-		// 			const params = { onDelete, onUpdate };
-
-		// 			const typeSuffix = isCyclic(it) ? ': AnyGelColumn' : '';
-
-		// 			const paramsStr = objToStatement2(params);
-		// 			const tableSchema = schemas[it.schemaTo || ''];
-		// 			const paramName = paramNameFor(it.tableTo, tableSchema);
-		// 			if (paramsStr) {
-		// 				return `.references(()${typeSuffix} => ${
-		// 					withCasing(
-		// 						paramName,
-		// 						casing,
-		// 					)
-		// 				}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
-		// 			}
-		// 			return `.references(()${typeSuffix} => ${
-		// 				withCasing(
-		// 					paramName,
-		// 					casing,
-		// 				)
-		// 			}.${withCasing(it.columnsTo[0], casing)})`;
-		// 		})
-		// 		.join('');
-		// 	statement += fksStatement;
-		// }
-
-		statement += ',\n';
-	});
-
-	return statement;
-};
-
-const createTableIndexes = (tableName: string, idxs: Index[], casing: Casing): string => {
-	let statement = '';
-
-	idxs.forEach((it) => {
-		// we have issue when index is called as table called
-		let idxKey = it.name.startsWith(tableName) && it.name !== tableName ? it.name.slice(tableName.length + 1) : it.name;
-		idxKey = idxKey.endsWith('_index') ? idxKey.slice(0, -'_index'.length) + '_idx' : idxKey;
-
-		idxKey = withCasing(idxKey, casing);
-
-		const indexGeneratedName = indexName(
-			tableName,
-			it.columns.map((it) => it.expression),
-		);
-		const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
-
-		statement += `\n\t`;
-		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
-		statement += `${escapedIndexName})`;
-		statement += `${it.concurrently ? `.concurrently()` : ''}`;
-
-		statement += `.using("${it.method}", ${
-			it.columns
-				.map((it) => {
-					if (it.isExpression) {
-						return `sql\`${it.expression}\``;
-					} else {
-						return `table.${withCasing(it.expression, casing)}${it.asc ? '.asc()' : '.desc()'}${
-							it.nulls === 'first' ? '.nullsFirst()' : '.nullsLast()'
-						}${
-							it.opclass
-								? `.op("${it.opclass}")`
-								: ''
-						}`;
-					}
-				})
-				.join(', ')
-		})`;
-		statement += it.where ? `.where(sql\`${it.where}\`)` : '';
-
-		function reverseLogic(mappedWith: Record<string, string>): string {
-			let reversedString = '{';
-			for (const key in mappedWith) {
-				if (mappedWith.hasOwnProperty(key)) {
-					reversedString += `${key}: "${mappedWith[key]}",`;
-				}
-			}
-			reversedString = reversedString.length > 1 ? reversedString.slice(0, reversedString.length - 1) : reversedString;
-			return `${reversedString}}`;
-		}
-
-		statement += it.with && Object.keys(it.with).length > 0 ? `.with(${reverseLogic(it.with)})` : '';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTablePKs = (pks: PrimaryKey[], casing: Casing): string => {
-	let statement = '';
-
-	pks.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'primaryKey({ columns: [';
-		statement += `${
-			it.columns
-				.map((c) => {
-					return `table.${withCasing(c, casing)}`;
-				})
-				.join(', ')
-		}]${it.name ? `, name: "${it.name}"` : ''}}`;
-		statement += ')';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-// get a map of db role name to ts key
-// if to by key is in this map - no quotes, otherwise - quotes
-
-const createTablePolicies = (
-	policies: Policy[],
-	casing: Casing,
-	rolesNameToTsKey: Record<string, string> = {},
-): string => {
-	let statement = '';
-
-	policies.forEach((it) => {
-		const idxKey = withCasing(it.name, casing);
-
-		const mappedItTo = it.to?.map((v) => {
-			return rolesNameToTsKey[v] ? withCasing(rolesNameToTsKey[v], casing) : `"${v}"`;
-		});
-
-		statement += `\n\t`;
-		statement += 'gelPolicy(';
-		statement += `"${it.name}", { `;
-		statement += `as: "${it.as?.toLowerCase()}", for: "${it.for?.toLowerCase()}", to: [${mappedItTo?.join(', ')}]${
-			it.using ? `, using: sql\`${it.using}\`` : ''
-		}${it.withCheck ? `, withCheck: sql\`${it.withCheck}\` ` : ''}`;
-		statement += ` }),`;
-	});
-
-	return statement;
-};
-
-const createTableUniques = (
-	unqs: UniqueConstraint[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	unqs.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'unique(';
-		statement += `"${it.name}")`;
-		statement += `.on(${it.columns.map((it) => `table.${withCasing(it, casing)}`).join(', ')})`;
-		statement += it.nullsNotDistinct ? `.nullsNotDistinct()` : '';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTableChecks = (
-	checkConstraints: CheckConstraint[],
-	casing: Casing,
-) => {
-	let statement = '';
-
-	checkConstraints.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'check(';
-		statement += `"${it.name}", `;
-		statement += `sql\`${it.value}\`)`;
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTableFKs = (fks: ForeignKey[], schemas: Record<string, string>, casing: Casing): string => {
-	let statement = '';
-
-	fks.forEach((it) => {
-		const tableSchema = schemas[it.schemaTo || ''];
-		const paramName = paramNameFor(it.tableTo, tableSchema);
-
-		const isSelf = it.tableTo === it.tableFrom;
-		const tableTo = isSelf ? 'table' : `${withCasing(paramName, casing)}`;
-		statement += `\n\t`;
-		statement += `foreignKey({\n`;
-		statement += `\t\t\tcolumns: [${it.columnsFrom.map((i) => `table.${withCasing(i, casing)}`).join(', ')}],\n`;
-		statement += `\t\t\tforeignColumns: [${
-			it.columnsTo.map((i) => `${tableTo}.${withCasing(i, casing)}`).join(', ')
-		}],\n`;
-		statement += `\t\t\tname: "${it.name}"\n`;
-		statement += `\t\t})`;
-
-		statement += it.onUpdate && it.onUpdate !== 'no action' ? `.onUpdate("${it.onUpdate}")` : '';
-
-		statement += it.onDelete && it.onDelete !== 'no action' ? `.onDelete("${it.onDelete}")` : '';
-
-		statement += `,`;
-	});
-
-	return statement;
-};
diff --git a/drizzle-kit/src/introspect-mysql.ts b/drizzle-kit/src/introspect-mysql.ts
deleted file mode 100644
index 8f1ddfd065..0000000000
--- a/drizzle-kit/src/introspect-mysql.ts
+++ /dev/null
@@ -1,1030 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { toCamelCase } from 'drizzle-orm/casing';
-import './@types/utils';
-import type { Casing } from './cli/validations/common';
-import { assertUnreachable } from './global';
-import {
-	CheckConstraint,
-	Column,
-	ForeignKey,
-	Index,
-	MySqlSchema,
-	MySqlSchemaInternal,
-	PrimaryKey,
-	UniqueConstraint,
-} from './serializer/mysqlSchema';
-import { unescapeSingleQuotes } from './utils';
-
-const mysqlImportsList = new Set([
-	'mysqlTable',
-	'mysqlEnum',
-	'bigint',
-	'binary',
-	'boolean',
-	'char',
-	'date',
-	'datetime',
-	'decimal',
-	'double',
-	'float',
-	'int',
-	'json',
-	'mediumint',
-	'real',
-	'serial',
-	'smallint',
-	'text',
-	'tinytext',
-	'mediumtext',
-	'longtext',
-	'time',
-	'timestamp',
-	'tinyint',
-	'varbinary',
-	'varchar',
-	'year',
-	'enum',
-]);
-
-const objToStatement = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `"${it}": "${json[it]}"`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const objToStatement2 = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
-	statement += ' }';
-	return statement;
-};
-
-const timeConfig = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const binaryConfig = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const importsPatch = {
-	'double precision': 'doublePrecision',
-	'timestamp without time zone': 'timestamp',
-} as Record<string, string>;
-
-const relations = new Set<string>();
-
-const escapeColumnKey = (value: string) => {
-	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
-		return `"${value}"`;
-	}
-	return value;
-};
-
-const prepareCasing = (casing?: Casing) => (value: string) => {
-	if (casing === 'preserve') {
-		return escapeColumnKey(value);
-	}
-	if (casing === 'camel') {
-		return escapeColumnKey(value.camelCase());
-	}
-
-	assertUnreachable(casing);
-};
-
-const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
-	if (casing === 'preserve') {
-		return '';
-	}
-	if (casing === 'camel') {
-		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
-	}
-
-	assertUnreachable(casing);
-};
-
-export const schemaToTypeScript = (
-	schema: MySqlSchemaInternal,
-	casing: Casing,
-) => {
-	const withCasing = prepareCasing(casing);
-	// collectFKs
-	Object.values(schema.tables).forEach((table) => {
-		Object.values(table.foreignKeys).forEach((fk) => {
-			const relation = `${fk.tableFrom}-${fk.tableTo}`;
-			relations.add(relation);
-		});
-	});
-
-	const imports = Object.values(schema.tables).reduce(
-		(res, it) => {
-			const idxImports = Object.values(it.indexes).map((idx) => idx.isUnique ? 'uniqueIndex' : 'index');
-			const fkImpots = Object.values(it.foreignKeys).map((it) => 'foreignKey');
-			const pkImports = Object.values(it.compositePrimaryKeys).map(
-				(it) => 'primaryKey',
-			);
-			const uniqueImports = Object.values(it.uniqueConstraints).map(
-				(it) => 'unique',
-			);
-			const checkImports = Object.values(it.checkConstraint).map(
-				(it) => 'check',
-			);
-
-			res.mysql.push(...idxImports);
-			res.mysql.push(...fkImpots);
-			res.mysql.push(...pkImports);
-			res.mysql.push(...uniqueImports);
-			res.mysql.push(...checkImports);
-
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					let patched = importsPatch[col.type] ?? col.type;
-					patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-					patched = patched.startsWith('char(') ? 'char' : patched;
-					patched = patched.startsWith('binary(') ? 'binary' : patched;
-					patched = patched.startsWith('decimal(') ? 'decimal' : patched;
-					patched = patched.startsWith('smallint(') ? 'smallint' : patched;
-					patched = patched.startsWith('enum(') ? 'mysqlEnum' : patched;
-					patched = patched.startsWith('datetime(') ? 'datetime' : patched;
-					patched = patched.startsWith('varbinary(') ? 'varbinary' : patched;
-					patched = patched.startsWith('int(') ? 'int' : patched;
-					patched = patched.startsWith('double(') ? 'double' : patched;
-					patched = patched.startsWith('float(') ? 'float' : patched;
-					patched = patched.startsWith('int unsigned') ? 'int' : patched;
-					patched = patched.startsWith('tinyint unsigned') ? 'tinyint' : patched;
-					patched = patched.startsWith('smallint unsigned') ? 'smallint' : patched;
-					patched = patched.startsWith('mediumint unsigned') ? 'mediumint' : patched;
-					patched = patched.startsWith('bigint unsigned') ? 'bigint' : patched;
-					return patched;
-				})
-				.filter((type) => {
-					return mysqlImportsList.has(type);
-				});
-
-			res.mysql.push(...columnImports);
-			return res;
-		},
-		{ mysql: [] as string[] },
-	);
-
-	Object.values(schema.views).forEach((it) => {
-		imports.mysql.push('mysqlView');
-
-		const columnImports = Object.values(it.columns)
-			.map((col) => {
-				let patched = importsPatch[col.type] ?? col.type;
-				patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-				patched = patched.startsWith('char(') ? 'char' : patched;
-				patched = patched.startsWith('binary(') ? 'binary' : patched;
-				patched = patched.startsWith('decimal(') ? 'decimal' : patched;
-				patched = patched.startsWith('smallint(') ? 'smallint' : patched;
-				patched = patched.startsWith('enum(') ? 'mysqlEnum' : patched;
-				patched = patched.startsWith('datetime(') ? 'datetime' : patched;
-				patched = patched.startsWith('varbinary(') ? 'varbinary' : patched;
-				patched = patched.startsWith('int(') ? 'int' : patched;
-				patched = patched.startsWith('double(') ? 'double' : patched;
-				patched = patched.startsWith('float(') ? 'float' : patched;
-				patched = patched.startsWith('int unsigned') ? 'int' : patched;
-				patched = patched.startsWith('tinyint unsigned') ? 'tinyint' : patched;
-				patched = patched.startsWith('smallint unsigned') ? 'smallint' : patched;
-				patched = patched.startsWith('mediumint unsigned') ? 'mediumint' : patched;
-				patched = patched.startsWith('bigint unsigned') ? 'bigint' : patched;
-				return patched;
-			})
-			.filter((type) => {
-				return mysqlImportsList.has(type);
-			});
-
-		imports.mysql.push(...columnImports);
-	});
-
-	const tableStatements = Object.values(schema.tables).map((table) => {
-		const func = 'mysqlTable';
-		let statement = '';
-		if (imports.mysql.includes(withCasing(table.name))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					table.name,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(table.name)} = ${func}("${table.name}", {\n`;
-		statement += createTableColumns(
-			Object.values(table.columns),
-			Object.values(table.foreignKeys),
-			withCasing,
-			casing,
-			table.name,
-			schema,
-		);
-		statement += '}';
-
-		// more than 2 fields or self reference or cyclic
-		const filteredFKs = Object.values(table.foreignKeys).filter((it) => {
-			return it.columnsFrom.length > 1 || isSelf(it);
-		});
-
-		if (
-			Object.keys(table.indexes).length > 0
-			|| filteredFKs.length > 0
-			|| Object.keys(table.compositePrimaryKeys).length > 0
-			|| Object.keys(table.uniqueConstraints).length > 0
-			|| Object.keys(table.checkConstraint).length > 0
-		) {
-			statement += ',\n';
-			statement += '(table) => [';
-			statement += createTableIndexes(
-				table.name,
-				Object.values(table.indexes),
-				withCasing,
-			);
-			statement += createTableFKs(Object.values(filteredFKs), withCasing);
-			statement += createTablePKs(
-				Object.values(table.compositePrimaryKeys),
-				withCasing,
-			);
-			statement += createTableUniques(
-				Object.values(table.uniqueConstraints),
-				withCasing,
-			);
-			statement += createTableChecks(
-				Object.values(table.checkConstraint),
-				withCasing,
-			);
-			statement += '\n]';
-		}
-
-		statement += ');';
-		return statement;
-	});
-
-	const viewsStatements = Object.values(schema.views).map((view) => {
-		const { columns, name, algorithm, definition, sqlSecurity, withCheckOption } = view;
-		const func = 'mysqlView';
-		let statement = '';
-
-		if (imports.mysql.includes(withCasing(name))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					view.name,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(name)} = ${func}("${name}", {\n`;
-		statement += createTableColumns(
-			Object.values(columns),
-			[],
-			withCasing,
-			casing,
-			name,
-			schema,
-		);
-		statement += '})';
-
-		statement += algorithm ? `.algorithm("${algorithm}")` : '';
-		statement += sqlSecurity ? `.sqlSecurity("${sqlSecurity}")` : '';
-		statement += withCheckOption ? `.withCheckOption("${withCheckOption}")` : '';
-		statement += `.as(sql\`${definition?.replaceAll('`', '\\`')}\`);`;
-
-		return statement;
-	});
-
-	const uniqueMySqlImports = [
-		'mysqlTable',
-		'mysqlSchema',
-		'AnyMySqlColumn',
-		...new Set(imports.mysql),
-	];
-	const importsTs = `import { ${
-		uniqueMySqlImports.join(
-			', ',
-		)
-	} } from "drizzle-orm/mysql-core"\nimport { sql } from "drizzle-orm"\n\n`;
-
-	let decalrations = '';
-	decalrations += tableStatements.join('\n\n');
-	decalrations += '\n';
-	decalrations += viewsStatements.join('\n\n');
-
-	const file = importsTs + decalrations;
-
-	const schemaEntry = `
-    {
-      ${
-		Object.values(schema.tables)
-			.map((it) => withCasing(it.name))
-			.join(',')
-	}
-    }
-  `;
-
-	return {
-		file, // backward compatible, print to file
-		imports: importsTs,
-		decalrations,
-		schemaEntry,
-	};
-};
-
-const isCyclic = (fk: ForeignKey) => {
-	const key = `${fk.tableFrom}-${fk.tableTo}`;
-	const reverse = `${fk.tableTo}-${fk.tableFrom}`;
-	return relations.has(key) && relations.has(reverse);
-};
-
-const isSelf = (fk: ForeignKey) => {
-	return fk.tableFrom === fk.tableTo;
-};
-
-const mapColumnDefault = (defaultValue: any, isExpression?: boolean) => {
-	if (isExpression) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	return defaultValue;
-};
-
-const mapColumnDefaultForJson = (defaultValue: any) => {
-	if (
-		typeof defaultValue === 'string'
-		&& defaultValue.startsWith("('")
-		&& defaultValue.endsWith("')")
-	) {
-		return defaultValue.substring(2, defaultValue.length - 2);
-	}
-
-	return defaultValue;
-};
-
-const column = (
-	type: string,
-	name: string,
-	casing: (value: string) => string,
-	rawCasing: Casing,
-	defaultValue?: any,
-	autoincrement?: boolean,
-	onUpdate?: boolean,
-	isExpression?: boolean,
-) => {
-	let lowered = type;
-	if (!type.startsWith('enum(')) {
-		lowered = type.toLowerCase();
-	}
-
-	if (lowered === 'serial') {
-		return `${casing(name)}: serial(${dbColumnName({ name, casing: rawCasing })})`;
-	}
-
-	if (lowered.startsWith('int')) {
-		const isUnsigned = lowered.startsWith('int unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: int(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('tinyint')) {
-		const isUnsigned = lowered.startsWith('tinyint unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		// let out = `${name.camelCase()}: tinyint("${name}")`;
-		let out: string = `${casing(name)}: tinyint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('smallint')) {
-		const isUnsigned = lowered.startsWith('smallint unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: smallint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('mediumint')) {
-		const isUnsigned = lowered.startsWith('mediumint unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: mediumint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('bigint')) {
-		const isUnsigned = lowered.startsWith('bigint unsigned');
-		let out = `${casing(name)}: bigint(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: "number"${
-			isUnsigned ? ', unsigned: true' : ''
-		} })`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'boolean') {
-		let out = `${casing(name)}: boolean(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('double')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 15 : 6)) {
-			const [precision, scale] = lowered
-				.slice(7, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		const timeConfigParams = params ? timeConfig(params) : undefined;
-
-		let out = params
-			? `${casing(name)}: double(${
-				dbColumnName({ name, casing: rawCasing, withMode: timeConfigParams !== undefined })
-			}${timeConfig(params)})`
-			: `${casing(name)}: double(${dbColumnName({ name, casing: rawCasing })})`;
-
-		// let out = `${name.camelCase()}: double("${name}")`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('float')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 14 : 5)) {
-			const [precision, scale] = lowered
-				.slice(6, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		let out = `${casing(name)}: float(${dbColumnName({ name, casing: rawCasing })}${params ? timeConfig(params) : ''})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'real') {
-		let out = `${casing(name)}: real(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('timestamp')) {
-		const keyLength = 'timestamp'.length + 1;
-		let fsp = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		fsp = fsp ? fsp : null;
-
-		const params = timeConfig({ fsp, mode: "'string'" });
-
-		let out = params
-			? `${casing(name)}: timestamp(${
-				dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })
-			}${params})`
-			: `${casing(name)}: timestamp(${dbColumnName({ name, casing: rawCasing })})`;
-
-		// mysql has only CURRENT_TIMESTAMP, as I found from docs. But will leave now() for just a case
-		defaultValue = defaultValue === 'now()' || defaultValue === '(CURRENT_TIMESTAMP)'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-
-		let onUpdateNow = onUpdate ? '.onUpdateNow()' : '';
-		out += onUpdateNow;
-
-		return out;
-	}
-
-	if (lowered.startsWith('time')) {
-		const keyLength = 'time'.length + 1;
-		let fsp = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		fsp = fsp ? fsp : null;
-
-		const params = timeConfig({ fsp });
-
-		let out = params
-			? `${casing(name)}: time(${dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })}${params})`
-			: `${casing(name)}: time(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered === 'date') {
-		let out = `// you can use { mode: 'date' }, if you want to have Date as type for this column\n\t${
-			casing(
-				name,
-			)
-		}: date(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string' })`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	// in mysql text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'text') {
-		let out = `${casing(name)}: text(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in mysql text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'tinytext') {
-		let out = `${casing(name)}: tinytext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in mysql text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'mediumtext') {
-		let out = `${casing(name)}: mediumtext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in mysql text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'longtext') {
-		let out = `${casing(name)}: longtext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'year') {
-		let out = `${casing(name)}: year(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in mysql json can't have default value. Will leave it in case smth ;)
-	if (lowered === 'json') {
-		let out = `${casing(name)}: json(${dbColumnName({ name, casing: rawCasing })})`;
-
-		out += defaultValue
-			? `.default(${mapColumnDefaultForJson(defaultValue)})`
-			: '';
-
-		return out;
-	}
-
-	if (lowered.startsWith('varchar')) {
-		let out: string = `${
-			casing(
-				name,
-			)
-		}: varchar(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ length: ${
-			lowered.substring(
-				'varchar'.length + 1,
-				lowered.length - 1,
-			)
-		} })`;
-
-		const mappedDefaultValue = mapColumnDefault(defaultValue, isExpression);
-		out += defaultValue
-			? `.default(${isExpression ? mappedDefaultValue : unescapeSingleQuotes(mappedDefaultValue, true)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('char')) {
-		let out: string = `${
-			casing(
-				name,
-			)
-		}: char(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ length: ${
-			lowered.substring(
-				'char'.length + 1,
-				lowered.length - 1,
-			)
-		} })`;
-
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('datetime')) {
-		let out = `// you can use { mode: 'date' }, if you want to have Date as type for this column\n\t`;
-
-		const fsp = lowered.startsWith('datetime(')
-			? lowered.substring('datetime'.length + 1, lowered.length - 1)
-			: undefined;
-
-		out = fsp
-			? `${
-				casing(
-					name,
-				)
-			}: datetime(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string', fsp: ${
-				lowered.substring(
-					'datetime'.length + 1,
-					lowered.length - 1,
-				)
-			} })`
-			: `${casing(name)}: datetime(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string'})`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('decimal')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 16 : 7)) {
-			const [precision, scale] = lowered
-				.slice(8, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		const timeConfigParams = params ? timeConfig(params) : undefined;
-
-		let out = params
-			? `${casing(name)}: decimal(${
-				dbColumnName({ name, casing: rawCasing, withMode: timeConfigParams !== undefined })
-			}${timeConfigParams})`
-			: `${casing(name)}: decimal(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('binary')) {
-		const keyLength = 'binary'.length + 1;
-		let length = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		length = length ? length : null;
-
-		const params = binaryConfig({ length });
-
-		let out = params
-			? `${casing(name)}: binary(${dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })}${params})`
-			: `${casing(name)}: binary(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('enum')) {
-		const values = lowered
-			.substring('enum'.length + 1, lowered.length - 1)
-			.split(',')
-			.map((v) => unescapeSingleQuotes(v, true))
-			.join(',');
-		let out = `${casing(name)}: mysqlEnum(${dbColumnName({ name, casing: rawCasing, withMode: true })}[${values}])`;
-		const mappedDefaultValue = mapColumnDefault(defaultValue, isExpression);
-		out += defaultValue
-			? `.default(${isExpression ? mappedDefaultValue : unescapeSingleQuotes(mappedDefaultValue, true)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('varbinary')) {
-		const keyLength = 'varbinary'.length + 1;
-		let length = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		length = length ? length : null;
-
-		const params = binaryConfig({ length });
-
-		let out = params
-			? `${casing(name)}: varbinary(${
-				dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })
-			}${params})`
-			: `${casing(name)}: varbinary(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	console.log('uknown', type);
-	return `// Warning: Can't parse ${type} from database\n\t// ${type}Type: ${type}("${name}")`;
-};
-
-const createTableColumns = (
-	columns: Column[],
-	fks: ForeignKey[],
-	casing: (val: string) => string,
-	rawCasing: Casing,
-	tableName: string,
-	schema: MySqlSchemaInternal,
-): string => {
-	let statement = '';
-
-	// no self refs and no cyclic
-	const oneColumnsFKs = Object.values(fks)
-		.filter((it) => {
-			return !isSelf(it);
-		})
-		.filter((it) => it.columnsFrom.length === 1);
-
-	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
-		const arr = res[it.columnsFrom[0]] || [];
-		arr.push(it);
-		res[it.columnsFrom[0]] = arr;
-		return res;
-	}, {} as Record<string, ForeignKey[]>);
-
-	columns.forEach((it) => {
-		statement += '\t';
-		statement += column(
-			it.type,
-			it.name,
-			casing,
-			rawCasing,
-			it.default,
-			it.autoincrement,
-			it.onUpdate,
-			schema.internal?.tables![tableName]?.columns[it.name]
-				?.isDefaultAnExpression ?? false,
-		);
-		statement += it.primaryKey ? '.primaryKey()' : '';
-		statement += it.notNull ? '.notNull()' : '';
-
-		statement += it.generated
-			? `.generatedAlwaysAs(sql\`${
-				it.generated.as.replace(
-					/`/g,
-					'\\`',
-				)
-			}\`, { mode: "${it.generated.type}" })`
-			: '';
-
-		const fks = fkByColumnName[it.name];
-		if (fks) {
-			const fksStatement = fks
-				.map((it) => {
-					const onDelete = it.onDelete && it.onDelete !== 'no action' ? it.onDelete : null;
-					const onUpdate = it.onUpdate && it.onUpdate !== 'no action' ? it.onUpdate : null;
-					const params = { onDelete, onUpdate };
-
-					const typeSuffix = isCyclic(it) ? ': AnyMySqlColumn' : '';
-
-					const paramsStr = objToStatement2(params);
-					if (paramsStr) {
-						return `.references(()${typeSuffix} => ${
-							casing(
-								it.tableTo,
-							)
-						}.${casing(it.columnsTo[0])}, ${paramsStr} )`;
-					}
-					return `.references(()${typeSuffix} => ${casing(it.tableTo)}.${
-						casing(
-							it.columnsTo[0],
-						)
-					})`;
-				})
-				.join('');
-			statement += fksStatement;
-		}
-
-		statement += ',\n';
-	});
-
-	return statement;
-};
-
-const createTableIndexes = (
-	tableName: string,
-	idxs: Index[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	idxs.forEach((it) => {
-		let idxKey = it.name.startsWith(tableName) && it.name !== tableName
-			? it.name.slice(tableName.length + 1)
-			: it.name;
-		idxKey = idxKey.endsWith('_index')
-			? idxKey.slice(0, -'_index'.length) + '_idx'
-			: idxKey;
-
-		idxKey = casing(idxKey);
-
-		statement += `\n\t`;
-		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
-		statement += `"${it.name}")`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${casing(it)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-
-const createTableUniques = (
-	unqs: UniqueConstraint[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	unqs.forEach((it) => {
-		const idxKey = casing(it.name);
-
-		statement += `\n\t`;
-		statement += 'unique(';
-		statement += `"${it.name}")`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${casing(it)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-
-const createTableChecks = (
-	checks: CheckConstraint[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	checks.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'check(';
-		statement += `"${it.name}", `;
-		statement += `sql\`${it.value.replace(/`/g, '\\`')}\`)`;
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTablePKs = (
-	pks: PrimaryKey[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	pks.forEach((it) => {
-		let idxKey = casing(it.name);
-
-		statement += `\n\t`;
-		statement += 'primaryKey({ columns: [';
-		statement += `${
-			it.columns
-				.map((c) => {
-					return `table.${casing(c)}`;
-				})
-				.join(', ')
-		}]${it.name ? `, name: "${it.name}"` : ''}}`;
-		statement += '),';
-	});
-
-	return statement;
-};
-
-const createTableFKs = (
-	fks: ForeignKey[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	fks.forEach((it) => {
-		const isSelf = it.tableTo === it.tableFrom;
-		const tableTo = isSelf ? 'table' : `${casing(it.tableTo)}`;
-		statement += `\n\t`;
-		statement += `foreignKey({\n`;
-		statement += `\t\t\tcolumns: [${
-			it.columnsFrom
-				.map((i) => `table.${casing(i)}`)
-				.join(', ')
-		}],\n`;
-		statement += `\t\t\tforeignColumns: [${
-			it.columnsTo
-				.map((i) => `${tableTo}.${casing(i)}`)
-				.join(', ')
-		}],\n`;
-		statement += `\t\t\tname: "${it.name}"\n`;
-		statement += `\t\t})`;
-
-		statement += it.onUpdate && it.onUpdate !== 'no action'
-			? `.onUpdate("${it.onUpdate}")`
-			: '';
-
-		statement += it.onDelete && it.onDelete !== 'no action'
-			? `.onDelete("${it.onDelete}")`
-			: '';
-
-		statement += `,`;
-	});
-
-	return statement;
-};
diff --git a/drizzle-kit/src/introspect-pg.ts b/drizzle-kit/src/introspect-pg.ts
deleted file mode 100644
index 4bb65ee0ca..0000000000
--- a/drizzle-kit/src/introspect-pg.ts
+++ /dev/null
@@ -1,1369 +0,0 @@
-import { getTableName, is } from 'drizzle-orm';
-import { AnyPgTable } from 'drizzle-orm/pg-core';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	Many,
-	One,
-	Relation,
-	Relations,
-} from 'drizzle-orm/relations';
-import './@types/utils';
-import { toCamelCase } from 'drizzle-orm/casing';
-import { Casing } from './cli/validations/common';
-import { assertUnreachable } from './global';
-import {
-	CheckConstraint,
-	Column,
-	ForeignKey,
-	Index,
-	PgKitInternals,
-	PgSchemaInternal,
-	Policy,
-	PrimaryKey,
-	UniqueConstraint,
-} from './serializer/pgSchema';
-import { indexName } from './serializer/pgSerializer';
-import { unescapeSingleQuotes } from './utils';
-
-const pgImportsList = new Set([
-	'pgTable',
-	'pgEnum',
-	'smallint',
-	'integer',
-	'bigint',
-	'boolean',
-	'text',
-	'varchar',
-	'char',
-	'serial',
-	'smallserial',
-	'bigserial',
-	'decimal',
-	'numeric',
-	'real',
-	'json',
-	'jsonb',
-	'time',
-	'timestamp',
-	'date',
-	'interval',
-	'cidr',
-	'inet',
-	'macaddr',
-	'macaddr8',
-	'bigint',
-	'doublePrecision',
-	'uuid',
-	'vector',
-	'point',
-	'line',
-	'geometry',
-]);
-
-const objToStatement2 = (json: { [s: string]: unknown }) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
-	statement += ' }';
-	return statement;
-};
-
-const timeConfig = (json: { [s: string]: unknown }) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const possibleIntervals = [
-	'year',
-	'month',
-	'day',
-	'hour',
-	'minute',
-	'second',
-	'year to month',
-	'day to hour',
-	'day to minute',
-	'day to second',
-	'hour to minute',
-	'hour to second',
-	'minute to second',
-];
-
-const intervalStrToObj = (str: string) => {
-	if (str.startsWith('interval(')) {
-		return {
-			precision: Number(str.substring('interval('.length, str.length - 1)),
-		};
-	}
-	const splitted = str.split(' ');
-	if (splitted.length === 1) {
-		return {};
-	}
-	const rest = splitted.slice(1, splitted.length).join(' ');
-	if (possibleIntervals.includes(rest)) {
-		return { fields: `"${rest}"` };
-	}
-
-	for (const s of possibleIntervals) {
-		if (rest.startsWith(`${s}(`)) {
-			return {
-				fields: `"${s}"`,
-				precision: Number(rest.substring(s.length + 1, rest.length - 1)),
-			};
-		}
-	}
-	return {};
-};
-
-const intervalConfig = (str: string) => {
-	const json = intervalStrToObj(str);
-	// json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it: keyof typeof json) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const mapColumnDefault = (defaultValue: any, isExpression?: boolean) => {
-	if (isExpression) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	return defaultValue;
-};
-
-const importsPatch = {
-	'double precision': 'doublePrecision',
-	'timestamp without time zone': 'timestamp',
-	'timestamp with time zone': 'timestamp',
-	'time without time zone': 'time',
-	'time with time zone': 'time',
-} as Record<string, string>;
-
-const relations = new Set<string>();
-
-const escapeColumnKey = (value: string) => {
-	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
-		return `"${value}"`;
-	}
-	return value;
-};
-
-const withCasing = (value: string, casing: Casing) => {
-	if (casing === 'preserve') {
-		return escapeColumnKey(value);
-	}
-	if (casing === 'camel') {
-		return escapeColumnKey(value.camelCase());
-	}
-
-	assertUnreachable(casing);
-};
-
-const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
-	if (casing === 'preserve') {
-		return '';
-	}
-	if (casing === 'camel') {
-		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
-	}
-
-	assertUnreachable(casing);
-};
-
-export const relationsToTypeScriptForStudio = (
-	schema: Record<string, Record<string, AnyPgTable<{}>>>,
-	relations: Record<string, Relations<string, Record<string, Relation<string>>>>,
-) => {
-	const relationalSchema: Record<string, unknown> = {
-		...Object.fromEntries(
-			Object.entries(schema)
-				.map(([key, val]) => {
-					// have unique keys across schemas
-					const mappedTableEntries = Object.entries(val).map((tableEntry) => {
-						return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
-					});
-
-					return mappedTableEntries;
-				})
-				.flat(),
-		),
-		...relations,
-	};
-
-	const relationsConfig = extractTablesRelationalConfig(relationalSchema, createTableRelationsHelpers);
-
-	let result = '';
-
-	function findColumnKey(table: AnyPgTable, columnName: string) {
-		for (const tableEntry of Object.entries(table)) {
-			const key = tableEntry[0];
-			const value = tableEntry[1];
-
-			if (value.name === columnName) {
-				return key;
-			}
-		}
-	}
-
-	Object.values(relationsConfig.tables).forEach((table) => {
-		const tableName = table.tsName.split('.')[1];
-		const relations = table.relations;
-		let hasRelations = false;
-		let relationsObjAsStr = '';
-		let hasOne = false;
-		let hasMany = false;
-
-		Object.values(relations).forEach((relation) => {
-			hasRelations = true;
-
-			if (is(relation, Many)) {
-				hasMany = true;
-				relationsObjAsStr += `\t\t${relation.fieldName}: many(${
-					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
-				}${typeof relation.relationName !== 'undefined' ? `, { relationName: "${relation.relationName}"}` : ''}),`;
-			}
-
-			if (is(relation, One)) {
-				hasOne = true;
-				relationsObjAsStr += `\t\t${relation.fieldName}: one(${
-					relationsConfig.tableNamesMap[relation.referencedTableName].split('.')[1]
-				}, { fields: [${
-					relation.config?.fields.map(
-						(c) =>
-							`${relationsConfig.tableNamesMap[getTableName(relation.sourceTable)].split('.')[1]}.${
-								findColumnKey(relation.sourceTable, c.name)
-							}`,
-					)
-				}], references: [${
-					relation.config?.references.map(
-						(c) =>
-							`${relationsConfig.tableNamesMap[getTableName(relation.referencedTable)].split('.')[1]}.${
-								findColumnKey(relation.referencedTable, c.name)
-							}`,
-					)
-				}]${typeof relation.relationName !== 'undefined' ? `, relationName: "${relation.relationName}"` : ''}}),`;
-			}
-		});
-
-		if (hasRelations) {
-			result += `export const ${tableName}Relation = relations(${tableName}, ({${hasOne ? 'one' : ''}${
-				hasOne && hasMany ? ', ' : ''
-			}${hasMany ? 'many' : ''}}) => ({
-        ${relationsObjAsStr}
-      }));\n`;
-		}
-	});
-
-	return result;
-};
-
-function generateIdentityParams(identity: Column['identity']) {
-	let paramsObj = `{ name: "${identity!.name}"`;
-	if (identity?.startWith) {
-		paramsObj += `, startWith: ${identity.startWith}`;
-	}
-	if (identity?.increment) {
-		paramsObj += `, increment: ${identity.increment}`;
-	}
-	if (identity?.minValue) {
-		paramsObj += `, minValue: ${identity.minValue}`;
-	}
-	if (identity?.maxValue) {
-		paramsObj += `, maxValue: ${identity.maxValue}`;
-	}
-	if (identity?.cache) {
-		paramsObj += `, cache: ${identity.cache}`;
-	}
-	if (identity?.cycle) {
-		paramsObj += `, cycle: true`;
-	}
-	paramsObj += ' }';
-	if (identity?.type === 'always') {
-		return `.generatedAlwaysAsIdentity(${paramsObj})`;
-	}
-	return `.generatedByDefaultAsIdentity(${paramsObj})`;
-}
-
-export const paramNameFor = (name: string, schema?: string) => {
-	const schemaSuffix = schema && schema !== 'public' ? `In${schema.capitalise()}` : '';
-	return `${name}${schemaSuffix}`;
-};
-
-export const schemaToTypeScript = (schema: PgSchemaInternal, casing: Casing) => {
-	// collectFKs
-	Object.values(schema.tables).forEach((table) => {
-		Object.values(table.foreignKeys).forEach((fk) => {
-			const relation = `${fk.tableFrom}-${fk.tableTo}`;
-			relations.add(relation);
-		});
-	});
-
-	const schemas = Object.fromEntries(
-		Object.entries(schema.schemas).map((it) => {
-			return [it[0], withCasing(it[1], casing)];
-		}),
-	);
-
-	const enumTypes = Object.values(schema.enums).reduce((acc, cur) => {
-		acc.add(`${cur.schema}.${cur.name}`);
-		return acc;
-	}, new Set<string>());
-
-	const imports = Object.values(schema.tables).reduce(
-		(res, it) => {
-			const idxImports = Object.values(it.indexes).map((idx) => (idx.isUnique ? 'uniqueIndex' : 'index'));
-			const fkImpots = Object.values(it.foreignKeys).map((it) => 'foreignKey');
-			if (Object.values(it.foreignKeys).some((it) => isCyclic(it) && !isSelf(it))) {
-				res.pg.push('type AnyPgColumn');
-			}
-			const pkImports = Object.values(it.compositePrimaryKeys).map((it) => 'primaryKey');
-			const uniqueImports = Object.values(it.uniqueConstraints).map((it) => 'unique');
-
-			const checkImports = Object.values(it.checkConstraints).map(
-				(it) => 'check',
-			);
-
-			const policiesImports = Object.values(it.policies).map(
-				(it) => 'pgPolicy',
-			);
-
-			if (it.schema && it.schema !== 'public' && it.schema !== '') {
-				res.pg.push('pgSchema');
-			}
-
-			res.pg.push(...idxImports);
-			res.pg.push(...fkImpots);
-			res.pg.push(...pkImports);
-			res.pg.push(...uniqueImports);
-			res.pg.push(...policiesImports);
-			res.pg.push(...checkImports);
-
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					let patched: string = (importsPatch[col.type] || col.type).replace('[]', '');
-					patched = patched === 'double precision' ? 'doublePrecision' : patched;
-					patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-					patched = patched.startsWith('char(') ? 'char' : patched;
-					patched = patched.startsWith('numeric(') ? 'numeric' : patched;
-					patched = patched.startsWith('time(') ? 'time' : patched;
-					patched = patched.startsWith('timestamp(') ? 'timestamp' : patched;
-					patched = patched.startsWith('vector(') ? 'vector' : patched;
-					patched = patched.startsWith('geometry(') ? 'geometry' : patched;
-					return patched;
-				})
-				.filter((type) => {
-					return pgImportsList.has(type);
-				});
-
-			res.pg.push(...columnImports);
-			return res;
-		},
-		{ pg: [] as string[] },
-	);
-
-	Object.values(schema.views).forEach((it) => {
-		if (it.schema && it.schema !== 'public' && it.schema !== '') {
-			imports.pg.push('pgSchema');
-		} else if (it.schema === 'public') {
-			it.materialized ? imports.pg.push('pgMaterializedView') : imports.pg.push('pgView');
-		}
-
-		Object.values(it.columns).forEach(() => {
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					let patched: string = (importsPatch[col.type] || col.type).replace('[]', '');
-					patched = patched === 'double precision' ? 'doublePrecision' : patched;
-					patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-					patched = patched.startsWith('char(') ? 'char' : patched;
-					patched = patched.startsWith('numeric(') ? 'numeric' : patched;
-					patched = patched.startsWith('time(') ? 'time' : patched;
-					patched = patched.startsWith('timestamp(') ? 'timestamp' : patched;
-					patched = patched.startsWith('vector(') ? 'vector' : patched;
-					patched = patched.startsWith('geometry(') ? 'geometry' : patched;
-					return patched;
-				})
-				.filter((type) => {
-					return pgImportsList.has(type);
-				});
-
-			imports.pg.push(...columnImports);
-		});
-	});
-
-	Object.values(schema.sequences).forEach((it) => {
-		if (it.schema && it.schema !== 'public' && it.schema !== '') {
-			imports.pg.push('pgSchema');
-		} else if (it.schema === 'public') {
-			imports.pg.push('pgSequence');
-		}
-	});
-
-	Object.values(schema.enums).forEach((it) => {
-		if (it.schema && it.schema !== 'public' && it.schema !== '') {
-			imports.pg.push('pgSchema');
-		} else if (it.schema === 'public') {
-			imports.pg.push('pgEnum');
-		}
-	});
-
-	if (Object.keys(schema.roles).length > 0) {
-		imports.pg.push('pgRole');
-	}
-
-	const enumStatements = Object.values(schema.enums)
-		.map((it) => {
-			const enumSchema = schemas[it.schema];
-			// const func = schema || schema === "public" ? "pgTable" : schema;
-			const paramName = paramNameFor(it.name, enumSchema);
-
-			const func = enumSchema ? `${enumSchema}.enum` : 'pgEnum';
-
-			const values = Object.values(it.values)
-				.map((it) => `'${unescapeSingleQuotes(it, false)}'`)
-				.join(', ');
-			return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", [${values}])\n`;
-		})
-		.join('')
-		.concat('\n');
-
-	const sequencesStatements = Object.values(schema.sequences)
-		.map((it) => {
-			const seqSchema = schemas[it.schema];
-			const paramName = paramNameFor(it.name, seqSchema);
-
-			const func = seqSchema ? `${seqSchema}.sequence` : 'pgSequence';
-
-			let params = '';
-
-			if (it.startWith) {
-				params += `, startWith: "${it.startWith}"`;
-			}
-			if (it.increment) {
-				params += `, increment: "${it.increment}"`;
-			}
-			if (it.minValue) {
-				params += `, minValue: "${it.minValue}"`;
-			}
-			if (it.maxValue) {
-				params += `, maxValue: "${it.maxValue}"`;
-			}
-			if (it.cache) {
-				params += `, cache: "${it.cache}"`;
-			}
-			if (it.cycle) {
-				params += `, cycle: true`;
-			} else {
-				params += `, cycle: false`;
-			}
-
-			return `export const ${withCasing(paramName, casing)} = ${func}("${it.name}"${
-				params ? `, { ${params.trimChar(',')} }` : ''
-			})\n`;
-		})
-		.join('')
-		.concat('');
-
-	const schemaStatements = Object.entries(schemas)
-		// .filter((it) => it[0] !== "public")
-		.map((it) => {
-			return `export const ${it[1]} = pgSchema("${it[0]}");\n`;
-		})
-		.join('');
-
-	const rolesNameToTsKey: Record<string, string> = {};
-
-	const rolesStatements = Object.entries(schema.roles)
-		.map((it) => {
-			const fields = it[1];
-			rolesNameToTsKey[fields.name] = it[0];
-			return `export const ${withCasing(it[0], casing)} = pgRole("${fields.name}", ${
-				!fields.createDb && !fields.createRole && fields.inherit
-					? ''
-					: `${
-						`, { ${fields.createDb ? `createDb: true,` : ''}${fields.createRole ? ` createRole: true,` : ''}${
-							!fields.inherit ? ` inherit: false ` : ''
-						}`.trimChar(',')
-					}}`
-			} );\n`;
-		})
-		.join('');
-
-	const tableStatements = Object.values(schema.tables).map((table) => {
-		const tableSchema = schemas[table.schema];
-		const paramName = paramNameFor(table.name, tableSchema);
-
-		const func = tableSchema ? `${tableSchema}.table` : 'pgTable';
-		let statement = `export const ${withCasing(paramName, casing)} = ${func}("${table.name}", {\n`;
-		statement += createTableColumns(
-			table.name,
-			Object.values(table.columns),
-			Object.values(table.foreignKeys),
-			enumTypes,
-			schemas,
-			casing,
-			schema.internal,
-		);
-		statement += '}';
-
-		// more than 2 fields or self reference or cyclic
-		// Andrii: I switched this one off until we will get custom names in .references()
-		// const filteredFKs = Object.values(table.foreignKeys).filter((it) => {
-		// 	return it.columnsFrom.length > 1 || isSelf(it);
-		// });
-
-		if (
-			Object.keys(table.indexes).length > 0
-			|| Object.values(table.foreignKeys).length > 0
-			|| Object.values(table.policies).length > 0
-			|| Object.keys(table.compositePrimaryKeys).length > 0
-			|| Object.keys(table.uniqueConstraints).length > 0
-			|| Object.keys(table.checkConstraints).length > 0
-		) {
-			statement += ', ';
-			statement += '(table) => [';
-			statement += createTableIndexes(table.name, Object.values(table.indexes), casing);
-			statement += createTableFKs(Object.values(table.foreignKeys), schemas, casing);
-			statement += createTablePKs(
-				Object.values(table.compositePrimaryKeys),
-				casing,
-			);
-			statement += createTableUniques(
-				Object.values(table.uniqueConstraints),
-				casing,
-			);
-			statement += createTablePolicies(
-				Object.values(table.policies),
-				casing,
-				rolesNameToTsKey,
-			);
-			statement += createTableChecks(
-				Object.values(table.checkConstraints),
-				casing,
-			);
-			statement += '\n]';
-		}
-
-		statement += ');';
-		return statement;
-	});
-
-	const viewsStatements = Object.values(schema.views)
-		.map((it) => {
-			const viewSchema = schemas[it.schema];
-
-			const paramName = paramNameFor(it.name, viewSchema);
-
-			const func = viewSchema
-				? (it.materialized ? `${viewSchema}.materializedView` : `${viewSchema}.view`)
-				: it.materialized
-				? 'pgMaterializedView'
-				: 'pgView';
-
-			const withOption = it.with ?? '';
-
-			const as = `sql\`${it.definition}\``;
-
-			const tablespace = it.tablespace ?? '';
-
-			const columns = createTableColumns(
-				'',
-				Object.values(it.columns),
-				[],
-				enumTypes,
-				schemas,
-				casing,
-				schema.internal,
-			);
-
-			let statement = `export const ${withCasing(paramName, casing)} = ${func}("${it.name}", {${columns}})`;
-			statement += tablespace ? `.tablespace("${tablespace}")` : '';
-			statement += withOption ? `.with(${JSON.stringify(withOption)})` : '';
-			statement += `.as(${as});`;
-
-			return statement;
-		})
-		.join('\n\n');
-
-	const uniquePgImports = ['pgTable', ...new Set(imports.pg)];
-
-	const importsTs = `import { ${
-		uniquePgImports.join(
-			', ',
-		)
-	} } from "drizzle-orm/pg-core"
-import { sql } from "drizzle-orm"\n\n`;
-
-	let decalrations = schemaStatements;
-	decalrations += rolesStatements;
-	decalrations += enumStatements;
-	decalrations += sequencesStatements;
-	decalrations += '\n';
-	decalrations += tableStatements.join('\n\n');
-	decalrations += '\n';
-	decalrations += viewsStatements;
-
-	const file = importsTs + decalrations;
-
-	// for drizzle studio query runner
-	const schemaEntry = `
-    {
-      ${
-		Object.values(schema.tables)
-			.map((it) => withCasing(it.name, casing))
-			.join(',\n')
-	}
-    }
-  `;
-
-	return { file, imports: importsTs, decalrations, schemaEntry };
-};
-
-const isCyclic = (fk: ForeignKey) => {
-	const key = `${fk.tableFrom}-${fk.tableTo}`;
-	const reverse = `${fk.tableTo}-${fk.tableFrom}`;
-	return relations.has(key) && relations.has(reverse);
-};
-
-const isSelf = (fk: ForeignKey) => {
-	return fk.tableFrom === fk.tableTo;
-};
-
-const buildArrayDefault = (defaultValue: string, typeName: string): string => {
-	if (typeof defaultValue === 'string' && !(defaultValue.startsWith('{') || defaultValue.startsWith("'{"))) {
-		return `sql\`${defaultValue}\``;
-	}
-	defaultValue = defaultValue.substring(2, defaultValue.length - 2);
-	return `[${
-		defaultValue
-			.split(/\s*,\s*/g)
-			.map((value) => {
-				// 	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(typeName)) {
-				// 		return value;
-				// 	} else if (typeName === 'interval') {
-				// 		return value.replaceAll('"', "'");
-				// 	} else if (typeName === 'boolean') {
-				// 		return value === 't' ? 'true' : 'false';
-				if (typeName === 'json' || typeName === 'jsonb') {
-					return value.substring(1, value.length - 1).replaceAll('\\', '');
-				}
-				return value;
-				// 	}
-			})
-			.join(', ')
-	}]`;
-};
-
-const mapDefault = (
-	tableName: string,
-	type: string,
-	name: string,
-	enumTypes: Set<string>,
-	typeSchema: string,
-	defaultValue?: any,
-	internals?: PgKitInternals,
-) => {
-	const isExpression = internals?.tables[tableName]?.columns[name]?.isDefaultAnExpression ?? false;
-	const isArray = internals?.tables[tableName]?.columns[name]?.isArray ?? false;
-	const lowered = type.toLowerCase().replace('[]', '');
-
-	if (isArray) {
-		return typeof defaultValue !== 'undefined' ? `.default(${buildArrayDefault(defaultValue, lowered)})` : '';
-	}
-
-	if (enumTypes.has(`${typeSchema}.${type.replace('[]', '')}`)) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('integer')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('smallint')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('bigint')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('boolean')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('double precision')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('real')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('uuid')) {
-		return defaultValue === 'gen_random_uuid()'
-			? '.defaultRandom()'
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('numeric')) {
-		defaultValue = defaultValue
-			? (defaultValue.startsWith(`'`) && defaultValue.endsWith(`'`)
-				? defaultValue.substring(1, defaultValue.length - 1)
-				: defaultValue)
-			: undefined;
-		return defaultValue ? `.default('${mapColumnDefault(defaultValue, isExpression)}')` : '';
-	}
-
-	if (lowered.startsWith('timestamp')) {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}(:\d{2})?)?'$/.test(defaultValue) // Matches 'YYYY-MM-DD HH:MI:SS', 'YYYY-MM-DD HH:MI:SS.FFFFFF', 'YYYY-MM-DD HH:MI:SS+TZ', 'YYYY-MM-DD HH:MI:SS.FFFFFF+TZ' and 'YYYY-MM-DD HH:MI:SS+HH:MI'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('time')) {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{2}:\d{2}(:\d{2})?(\.\d+)?'$/.test(defaultValue) // Matches 'HH:MI', 'HH:MI:SS' and 'HH:MI:SS.FFFFFF'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('interval')) {
-		return defaultValue ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered === 'date') {
-		return defaultValue === 'now()'
-			? '.defaultNow()'
-			: /^'\d{4}-\d{2}-\d{2}'$/.test(defaultValue) // Matches 'YYYY-MM-DD'
-			? `.default(${defaultValue})`
-			: defaultValue
-			? `.default(sql\`${defaultValue}\`)`
-			: '';
-	}
-
-	if (lowered.startsWith('text')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('jsonb')) {
-		const def = typeof defaultValue !== 'undefined'
-			? defaultValue.replace(/::(.*?)(?<![^\w"])(?=$)/, '').slice(1, -1)
-			: null;
-
-		return defaultValue ? `.default(${def})` : '';
-	}
-
-	if (lowered.startsWith('json')) {
-		const def = defaultValue ? defaultValue.replace(/::(.*?)(?<![^\w"])(?=$)/, '').slice(1, -1) : null;
-
-		return typeof defaultValue !== 'undefined' ? `.default(${def})` : '';
-	}
-
-	if (lowered.startsWith('inet')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('cidr')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('macaddr8')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('macaddr')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('varchar')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	if (lowered.startsWith('point')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('line')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('geometry')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('vector')) {
-		return typeof defaultValue !== 'undefined' ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-	}
-
-	if (lowered.startsWith('char')) {
-		return typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(unescapeSingleQuotes(defaultValue, true), isExpression)})`
-			: '';
-	}
-
-	return '';
-};
-
-const column = (
-	tableName: string,
-	type: string,
-	name: string,
-	enumTypes: Set<string>,
-	typeSchema: string,
-	casing: Casing,
-	defaultValue?: any,
-	internals?: PgKitInternals,
-) => {
-	const isExpression = internals?.tables[tableName]?.columns[name]?.isDefaultAnExpression ?? false;
-	const lowered = type.toLowerCase().replace('[]', '');
-
-	if (enumTypes.has(`${typeSchema}.${type.replace('[]', '')}`)) {
-		let out = `${withCasing(name, casing)}: ${withCasing(paramNameFor(type.replace('[]', ''), typeSchema), casing)}(${
-			dbColumnName({ name, casing })
-		})`;
-		return out;
-	}
-
-	if (lowered.startsWith('serial')) {
-		return `${withCasing(name, casing)}: serial(${dbColumnName({ name, casing })})`;
-	}
-
-	if (lowered.startsWith('smallserial')) {
-		return `${withCasing(name, casing)}: smallserial(${dbColumnName({ name, casing })})`;
-	}
-
-	if (lowered.startsWith('bigserial')) {
-		return `${withCasing(name, casing)}: bigserial(${
-			dbColumnName({ name, casing, withMode: true })
-		}{ mode: "bigint" })`;
-	}
-
-	if (lowered.startsWith('integer')) {
-		let out = `${withCasing(name, casing)}: integer(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('smallint')) {
-		let out = `${withCasing(name, casing)}: smallint(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('bigint')) {
-		let out = `// You can use { mode: "bigint" } if numbers are exceeding js number limitations\n\t`;
-		out += `${withCasing(name, casing)}: bigint(${dbColumnName({ name, casing, withMode: true })}{ mode: "number" })`;
-		return out;
-	}
-
-	if (lowered.startsWith('boolean')) {
-		let out = `${withCasing(name, casing)}: boolean(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('double precision')) {
-		let out = `${withCasing(name, casing)}: doublePrecision(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('real')) {
-		let out = `${withCasing(name, casing)}: real(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('uuid')) {
-		let out = `${withCasing(name, casing)}: uuid(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('numeric')) {
-		let params: { precision: string | undefined; scale: string | undefined } | undefined;
-
-		if (lowered.length > 7) {
-			const [precision, scale] = lowered.slice(8, lowered.length - 1).split(',');
-			params = { precision, scale };
-		}
-
-		let out = params
-			? `${withCasing(name, casing)}: numeric(${dbColumnName({ name, casing, withMode: true })}${timeConfig(params)})`
-			: `${withCasing(name, casing)}: numeric(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('timestamp')) {
-		const withTimezone = lowered.includes('with time zone');
-		// const split = lowered.split(" ");
-		let precision = lowered.startsWith('timestamp(')
-			? Number(lowered.split(' ')[0].substring('timestamp('.length, lowered.split(' ')[0].length - 1))
-			: null;
-		precision = precision ? precision : null;
-
-		const params = timeConfig({
-			precision,
-			withTimezone,
-			mode: "'string'",
-		});
-
-		let out = params
-			? `${withCasing(name, casing)}: timestamp(${dbColumnName({ name, casing, withMode: true })}${params})`
-			: `${withCasing(name, casing)}: timestamp(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('time')) {
-		const withTimezone = lowered.includes('with time zone');
-
-		let precision = lowered.startsWith('time(')
-			? Number(lowered.split(' ')[0].substring('time('.length, lowered.split(' ')[0].length - 1))
-			: null;
-		precision = precision ? precision : null;
-
-		const params = timeConfig({ precision, withTimezone });
-
-		let out = params
-			? `${withCasing(name, casing)}: time(${dbColumnName({ name, casing, withMode: true })}${params})`
-			: `${withCasing(name, casing)}: time(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('interval')) {
-		// const withTimezone = lowered.includes("with time zone");
-		// const split = lowered.split(" ");
-		// let precision = split.length >= 2 ? Number(split[1].substring(1, 2)) : null;
-		// precision = precision ? precision : null;
-
-		const params = intervalConfig(lowered);
-
-		let out = params
-			? `${withCasing(name, casing)}: interval(${dbColumnName({ name, casing, withMode: true })}${params})`
-			: `${withCasing(name, casing)}: interval(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered === 'date') {
-		let out = `${withCasing(name, casing)}: date(${dbColumnName({ name, casing })})`;
-
-		return out;
-	}
-
-	if (lowered.startsWith('text')) {
-		let out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('jsonb')) {
-		let out = `${withCasing(name, casing)}: jsonb(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('json')) {
-		let out = `${withCasing(name, casing)}: json(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('inet')) {
-		let out = `${withCasing(name, casing)}: inet(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('cidr')) {
-		let out = `${withCasing(name, casing)}: cidr(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('macaddr8')) {
-		let out = `${withCasing(name, casing)}: macaddr8(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('macaddr')) {
-		let out = `${withCasing(name, casing)}: macaddr(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('varchar')) {
-		let out: string;
-		if (lowered.length !== 7) {
-			out = `${withCasing(name, casing)}: varchar(${dbColumnName({ name, casing, withMode: true })}{ length: ${
-				lowered.substring(8, lowered.length - 1)
-			} })`;
-		} else {
-			out = `${withCasing(name, casing)}: varchar(${dbColumnName({ name, casing })})`;
-		}
-
-		return out;
-	}
-
-	if (lowered.startsWith('point')) {
-		let out: string = `${withCasing(name, casing)}: point(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('line')) {
-		let out: string = `${withCasing(name, casing)}: point(${dbColumnName({ name, casing })})`;
-		return out;
-	}
-
-	if (lowered.startsWith('geometry')) {
-		let out: string = '';
-
-		let isGeoUnknown = false;
-
-		if (lowered.length !== 8) {
-			const geometryOptions = lowered.slice(9, -1).split(',');
-			if (geometryOptions.length === 1 && geometryOptions[0] !== '') {
-				out = `${withCasing(name, casing)}: geometry(${dbColumnName({ name, casing, withMode: true })}{ type: "${
-					geometryOptions[0]
-				}" })`;
-			} else if (geometryOptions.length === 2) {
-				out = `${withCasing(name, casing)}: geometry(${dbColumnName({ name, casing, withMode: true })}{ type: "${
-					geometryOptions[0]
-				}", srid: ${geometryOptions[1]} })`;
-			} else {
-				isGeoUnknown = true;
-			}
-		} else {
-			out = `${withCasing(name, casing)}: geometry(${dbColumnName({ name, casing })})`;
-		}
-
-		if (isGeoUnknown) {
-			let unknown =
-				`// TODO: failed to parse geometry type because found more than 2 options inside geometry function '${type}'\n// Introspect is currently supporting only type and srid options\n`;
-			unknown += `\t${withCasing(name, casing)}: unknown("${name}")`;
-			return unknown;
-		}
-		return out;
-	}
-
-	if (lowered.startsWith('vector')) {
-		let out: string;
-		if (lowered.length !== 6) {
-			out = `${withCasing(name, casing)}: vector(${dbColumnName({ name, casing, withMode: true })}{ dimensions: ${
-				lowered.substring(7, lowered.length - 1)
-			} })`;
-		} else {
-			out = `${withCasing(name, casing)}: vector(${dbColumnName({ name, casing })})`;
-		}
-
-		return out;
-	}
-
-	if (lowered.startsWith('char')) {
-		let out: string;
-		if (lowered.length !== 4) {
-			out = `${withCasing(name, casing)}: char(${dbColumnName({ name, casing, withMode: true })}{ length: ${
-				lowered.substring(5, lowered.length - 1)
-			} })`;
-		} else {
-			out = `${withCasing(name, casing)}: char(${dbColumnName({ name, casing })})`;
-		}
-
-		return out;
-	}
-
-	let unknown = `// TODO: failed to parse database type '${type}'\n`;
-	unknown += `\t${withCasing(name, casing)}: unknown("${name}")`;
-	return unknown;
-};
-
-const dimensionsInArray = (size?: number): string => {
-	let res = '';
-	if (typeof size === 'undefined') return res;
-	for (let i = 0; i < size; i++) {
-		res += '.array()';
-	}
-	return res;
-};
-
-const createTableColumns = (
-	tableName: string,
-	columns: Column[],
-	fks: ForeignKey[],
-	enumTypes: Set<string>,
-	schemas: Record<string, string>,
-	casing: Casing,
-	internals: PgKitInternals,
-): string => {
-	let statement = '';
-
-	// no self refs and no cyclic
-	const oneColumnsFKs = Object.values(fks)
-		.filter((it) => {
-			return !isSelf(it);
-		})
-		.filter((it) => it.columnsFrom.length === 1);
-
-	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
-		const arr = res[it.columnsFrom[0]] || [];
-		arr.push(it);
-		res[it.columnsFrom[0]] = arr;
-		return res;
-	}, {} as Record<string, ForeignKey[]>);
-
-	columns.forEach((it) => {
-		const columnStatement = column(
-			tableName,
-			it.type,
-			it.name,
-			enumTypes,
-			it.typeSchema ?? 'public',
-			casing,
-			it.default,
-			internals,
-		);
-		statement += '\t';
-		statement += columnStatement;
-		// Provide just this in column function
-		if (internals?.tables[tableName]?.columns[it.name]?.isArray) {
-			statement += dimensionsInArray(internals?.tables[tableName]?.columns[it.name]?.dimensions);
-		}
-		statement += mapDefault(tableName, it.type, it.name, enumTypes, it.typeSchema ?? 'public', it.default, internals);
-		statement += it.primaryKey ? '.primaryKey()' : '';
-		statement += it.notNull && !it.identity ? '.notNull()' : '';
-
-		statement += it.identity ? generateIdentityParams(it.identity) : '';
-
-		statement += it.generated ? `.generatedAlwaysAs(sql\`${it.generated.as}\`)` : '';
-
-		// const fks = fkByColumnName[it.name];
-		// Andrii: I switched it off until we will get a custom naem setting in references
-		// if (fks) {
-		// 	const fksStatement = fks
-		// 		.map((it) => {
-		// 			const onDelete = it.onDelete && it.onDelete !== 'no action' ? it.onDelete : null;
-		// 			const onUpdate = it.onUpdate && it.onUpdate !== 'no action' ? it.onUpdate : null;
-		// 			const params = { onDelete, onUpdate };
-
-		// 			const typeSuffix = isCyclic(it) ? ': AnyPgColumn' : '';
-
-		// 			const paramsStr = objToStatement2(params);
-		// 			const tableSchema = schemas[it.schemaTo || ''];
-		// 			const paramName = paramNameFor(it.tableTo, tableSchema);
-		// 			if (paramsStr) {
-		// 				return `.references(()${typeSuffix} => ${
-		// 					withCasing(
-		// 						paramName,
-		// 						casing,
-		// 					)
-		// 				}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
-		// 			}
-		// 			return `.references(()${typeSuffix} => ${
-		// 				withCasing(
-		// 					paramName,
-		// 					casing,
-		// 				)
-		// 			}.${withCasing(it.columnsTo[0], casing)})`;
-		// 		})
-		// 		.join('');
-		// 	statement += fksStatement;
-		// }
-
-		statement += ',\n';
-	});
-
-	return statement;
-};
-
-const createTableIndexes = (tableName: string, idxs: Index[], casing: Casing): string => {
-	let statement = '';
-
-	idxs.forEach((it) => {
-		// we have issue when index is called as table called
-		let idxKey = it.name.startsWith(tableName) && it.name !== tableName ? it.name.slice(tableName.length + 1) : it.name;
-		idxKey = idxKey.endsWith('_index') ? idxKey.slice(0, -'_index'.length) + '_idx' : idxKey;
-
-		idxKey = withCasing(idxKey, casing);
-
-		const indexGeneratedName = indexName(
-			tableName,
-			it.columns.map((it) => it.expression),
-		);
-		const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
-
-		statement += `\n\t`;
-		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
-		statement += `${escapedIndexName})`;
-		statement += `${it.concurrently ? `.concurrently()` : ''}`;
-
-		statement += `.using("${it.method}", ${
-			it.columns
-				.map((it) => {
-					if (it.isExpression) {
-						return `sql\`${it.expression}\``;
-					} else {
-						return `table.${withCasing(it.expression, casing)}${it.asc ? '.asc()' : '.desc()'}${
-							it.nulls === 'first' ? '.nullsFirst()' : '.nullsLast()'
-						}${
-							it.opclass
-								? `.op("${it.opclass}")`
-								: ''
-						}`;
-					}
-				})
-				.join(', ')
-		})`;
-		statement += it.where ? `.where(sql\`${it.where}\`)` : '';
-
-		function reverseLogic(mappedWith: Record<string, string>): string {
-			let reversedString = '{';
-			for (const key in mappedWith) {
-				if (mappedWith.hasOwnProperty(key)) {
-					reversedString += `${key}: "${mappedWith[key]}",`;
-				}
-			}
-			reversedString = reversedString.length > 1 ? reversedString.slice(0, reversedString.length - 1) : reversedString;
-			return `${reversedString}}`;
-		}
-
-		statement += it.with && Object.keys(it.with).length > 0 ? `.with(${reverseLogic(it.with)})` : '';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTablePKs = (pks: PrimaryKey[], casing: Casing): string => {
-	let statement = '';
-
-	pks.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'primaryKey({ columns: [';
-		statement += `${
-			it.columns
-				.map((c) => {
-					return `table.${withCasing(c, casing)}`;
-				})
-				.join(', ')
-		}]${it.name ? `, name: "${it.name}"` : ''}}`;
-		statement += ')';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-// get a map of db role name to ts key
-// if to by key is in this map - no quotes, otherwise - quotes
-
-const createTablePolicies = (
-	policies: Policy[],
-	casing: Casing,
-	rolesNameToTsKey: Record<string, string> = {},
-): string => {
-	let statement = '';
-
-	policies.forEach((it) => {
-		const idxKey = withCasing(it.name, casing);
-
-		const mappedItTo = it.to?.map((v) => {
-			return rolesNameToTsKey[v] ? withCasing(rolesNameToTsKey[v], casing) : `"${v}"`;
-		});
-
-		statement += `\n\t`;
-		statement += 'pgPolicy(';
-		statement += `"${it.name}", { `;
-		statement += `as: "${it.as?.toLowerCase()}", for: "${it.for?.toLowerCase()}", to: [${mappedItTo?.join(', ')}]${
-			it.using ? `, using: sql\`${it.using}\`` : ''
-		}${it.withCheck ? `, withCheck: sql\`${it.withCheck}\` ` : ''}`;
-		statement += ` }),`;
-	});
-
-	return statement;
-};
-
-const createTableUniques = (
-	unqs: UniqueConstraint[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	unqs.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'unique(';
-		statement += `"${it.name}")`;
-		statement += `.on(${it.columns.map((it) => `table.${withCasing(it, casing)}`).join(', ')})`;
-		statement += it.nullsNotDistinct ? `.nullsNotDistinct()` : '';
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTableChecks = (
-	checkConstraints: CheckConstraint[],
-	casing: Casing,
-) => {
-	let statement = '';
-
-	checkConstraints.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'check(';
-		statement += `"${it.name}", `;
-		statement += `sql\`${it.value}\`)`;
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTableFKs = (fks: ForeignKey[], schemas: Record<string, string>, casing: Casing): string => {
-	let statement = '';
-
-	fks.forEach((it) => {
-		const tableSchema = schemas[it.schemaTo || ''];
-		const paramName = paramNameFor(it.tableTo, tableSchema);
-
-		const isSelf = it.tableTo === it.tableFrom;
-		const tableTo = isSelf ? 'table' : `${withCasing(paramName, casing)}`;
-		statement += `\n\t`;
-		statement += `foreignKey({\n`;
-		statement += `\t\t\tcolumns: [${it.columnsFrom.map((i) => `table.${withCasing(i, casing)}`).join(', ')}],\n`;
-		statement += `\t\t\tforeignColumns: [${
-			it.columnsTo.map((i) => `${tableTo}.${withCasing(i, casing)}`).join(', ')
-		}],\n`;
-		statement += `\t\t\tname: "${it.name}"\n`;
-		statement += `\t\t})`;
-
-		statement += it.onUpdate && it.onUpdate !== 'no action' ? `.onUpdate("${it.onUpdate}")` : '';
-
-		statement += it.onDelete && it.onDelete !== 'no action' ? `.onDelete("${it.onDelete}")` : '';
-
-		statement += `,`;
-	});
-
-	return statement;
-};
diff --git a/drizzle-kit/src/introspect-singlestore.ts b/drizzle-kit/src/introspect-singlestore.ts
deleted file mode 100644
index e39c0fe194..0000000000
--- a/drizzle-kit/src/introspect-singlestore.ts
+++ /dev/null
@@ -1,913 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { toCamelCase } from 'drizzle-orm/casing';
-import './@types/utils';
-import type { Casing } from './cli/validations/common';
-import { assertUnreachable } from './global';
-import {
-	Column,
-	Index,
-	PrimaryKey,
-	SingleStoreSchema,
-	SingleStoreSchemaInternal,
-	UniqueConstraint,
-} from './serializer/singlestoreSchema';
-import { indexName } from './serializer/singlestoreSerializer';
-
-// time precision to fsp
-// {mode: "string"} for timestamp by default
-
-const singlestoreImportsList = new Set([
-	'singlestoreTable',
-	'singlestoreEnum',
-	'bigint',
-	'binary',
-	'boolean',
-	'char',
-	'date',
-	'datetime',
-	'decimal',
-	'double',
-	'float',
-	'int',
-	'json',
-	// TODO: add new type BSON
-	// TODO: add new type Blob
-	// TODO: add new type UUID
-	// TODO: add new type GUID
-	// TODO: add new type Vector
-	// TODO: add new type GeoPoint
-	'mediumint',
-	'real',
-	'serial',
-	'smallint',
-	'text',
-	'tinytext',
-	'mediumtext',
-	'longtext',
-	'time',
-	'timestamp',
-	'tinyint',
-	'varbinary',
-	'varchar',
-	'vector',
-	'year',
-	'enum',
-]);
-
-const objToStatement = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `"${it}": "${json[it]}"`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const objToStatement2 = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
-	statement += ' }';
-	return statement;
-};
-
-const timeConfig = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const binaryConfig = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: ${json[it]}`).join(', ');
-	statement += ' }';
-	return statement;
-};
-
-const importsPatch = {
-	'double precision': 'doublePrecision',
-	'timestamp without time zone': 'timestamp',
-} as Record<string, string>;
-
-const escapeColumnKey = (value: string) => {
-	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
-		return `"${value}"`;
-	}
-	return value;
-};
-
-const prepareCasing = (casing?: Casing) => (value: string) => {
-	if (casing === 'preserve') {
-		return escapeColumnKey(value);
-	}
-	if (casing === 'camel') {
-		return escapeColumnKey(value.camelCase());
-	}
-
-	assertUnreachable(casing);
-};
-
-const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
-	if (casing === 'preserve') {
-		return '';
-	}
-	if (casing === 'camel') {
-		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
-	}
-
-	assertUnreachable(casing);
-};
-
-export const schemaToTypeScript = (
-	schema: SingleStoreSchemaInternal,
-	casing: Casing,
-) => {
-	const withCasing = prepareCasing(casing);
-
-	const imports = Object.values(schema.tables).reduce(
-		(res, it) => {
-			const idxImports = Object.values(it.indexes).map((idx) => idx.isUnique ? 'uniqueIndex' : 'index');
-			const pkImports = Object.values(it.compositePrimaryKeys).map(
-				(it) => 'primaryKey',
-			);
-			const uniqueImports = Object.values(it.uniqueConstraints).map(
-				(it) => 'unique',
-			);
-
-			res.singlestore.push(...idxImports);
-			res.singlestore.push(...pkImports);
-			res.singlestore.push(...uniqueImports);
-
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					let patched = importsPatch[col.type] ?? col.type;
-					patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-					patched = patched.startsWith('char(') ? 'char' : patched;
-					patched = patched.startsWith('binary(') ? 'binary' : patched;
-					patched = patched.startsWith('decimal(') ? 'decimal' : patched;
-					patched = patched.startsWith('smallint(') ? 'smallint' : patched;
-					patched = patched.startsWith('enum(') ? 'singlestoreEnum' : patched;
-					patched = patched.startsWith('datetime(') ? 'datetime' : patched;
-					patched = patched.startsWith('varbinary(') ? 'varbinary' : patched;
-					patched = patched.startsWith('int(') ? 'int' : patched;
-					patched = patched.startsWith('double(') ? 'double' : patched;
-					patched = patched.startsWith('float(') ? 'float' : patched;
-					patched = patched.startsWith('int unsigned') ? 'int' : patched;
-					patched = patched.startsWith('tinyint(') ? 'tinyint' : patched;
-					patched = patched.startsWith('mediumint(') ? 'mediumint' : patched;
-					patched = patched.startsWith('bigint(') ? 'bigint' : patched;
-					patched = patched.startsWith('tinyint unsigned') ? 'tinyint' : patched;
-					patched = patched.startsWith('smallint unsigned') ? 'smallint' : patched;
-					patched = patched.startsWith('mediumint unsigned') ? 'mediumint' : patched;
-					patched = patched.startsWith('bigint unsigned') ? 'bigint' : patched;
-					return patched;
-				})
-				.filter((type) => {
-					return singlestoreImportsList.has(type);
-				});
-
-			res.singlestore.push(...columnImports);
-			return res;
-		},
-		{ singlestore: [] as string[] },
-	);
-
-	/* Object.values(schema.views).forEach((it) => {
-		imports.singlestore.push('singlestoreView');
-
-		const columnImports = Object.values(it.columns)
-			.map((col) => {
-				let patched = importsPatch[col.type] ?? col.type;
-				patched = patched.startsWith('varchar(') ? 'varchar' : patched;
-				patched = patched.startsWith('char(') ? 'char' : patched;
-				patched = patched.startsWith('binary(') ? 'binary' : patched;
-				patched = patched.startsWith('decimal(') ? 'decimal' : patched;
-				patched = patched.startsWith('smallint(') ? 'smallint' : patched;
-				patched = patched.startsWith('enum(') ? 'singlestoreEnum' : patched;
-				patched = patched.startsWith('datetime(') ? 'datetime' : patched;
-				patched = patched.startsWith('varbinary(') ? 'varbinary' : patched;
-				patched = patched.startsWith('int(') ? 'int' : patched;
-				patched = patched.startsWith('double(') ? 'double' : patched;
-				patched = patched.startsWith('float(') ? 'float' : patched;
-				patched = patched.startsWith('int unsigned') ? 'int' : patched;
-				patched = patched.startsWith('tinyint(') ? 'tinyint' : patched;
-				patched = patched.startsWith('mediumint(') ? 'mediumint' : patched;
-				patched = patched.startsWith('bigint(') ? 'bigint' : patched;
-				patched = patched.startsWith('tinyint unsigned') ? 'tinyint' : patched;
-				patched = patched.startsWith('smallint unsigned') ? 'smallint' : patched;
-				patched = patched.startsWith('mediumint unsigned') ? 'mediumint' : patched;
-				patched = patched.startsWith('bigint unsigned') ? 'bigint' : patched;
-				return patched;
-			})
-			.filter((type) => {
-				return singlestoreImportsList.has(type);
-			});
-
-		imports.singlestore.push(...columnImports);
-	}); */
-
-	const tableStatements = Object.values(schema.tables).map((table) => {
-		const func = 'singlestoreTable';
-		let statement = '';
-		if (imports.singlestore.includes(withCasing(table.name))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					table.name,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(table.name)} = ${func}("${table.name}", {\n`;
-		statement += createTableColumns(
-			Object.values(table.columns),
-			withCasing,
-			casing,
-			table.name,
-			schema,
-		);
-		statement += '}';
-
-		if (
-			Object.keys(table.indexes).length > 0
-			|| Object.keys(table.compositePrimaryKeys).length > 0
-			|| Object.keys(table.uniqueConstraints).length > 0
-		) {
-			statement += ',\n';
-			statement += '(table) => [';
-			statement += createTableIndexes(
-				table.name,
-				Object.values(table.indexes),
-				withCasing,
-			);
-			statement += createTablePKs(
-				Object.values(table.compositePrimaryKeys),
-				withCasing,
-			);
-			statement += createTableUniques(
-				Object.values(table.uniqueConstraints),
-				withCasing,
-			);
-			statement += '\n]';
-		}
-
-		statement += ');';
-		return statement;
-	});
-
-	/* const viewsStatements = Object.values(schema.views).map((view) => {
-		const { columns, name, algorithm, definition, sqlSecurity, withCheckOption } = view;
-		const func = 'singlestoreView';
-		let statement = '';
-
-		if (imports.singlestore.includes(withCasing(name))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					view.name,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(name)} = ${func}("${name}", {\n`;
-		statement += createTableColumns(
-			Object.values(columns),
-			withCasing,
-			casing,
-			name,
-			schema,
-		);
-		statement += '})';
-
-		statement += algorithm ? `.algorithm("${algorithm}")` : '';
-		statement += sqlSecurity ? `.sqlSecurity("${sqlSecurity}")` : '';
-		statement += withCheckOption ? `.withCheckOption("${withCheckOption}")` : '';
-		statement += `.as(sql\`${definition?.replaceAll('`', '\\`')}\`);`;
-
-		return statement;
-	}); */
-
-	const uniqueSingleStoreImports = [
-		'singlestoreTable',
-		'singlestoreSchema',
-		'AnySingleStoreColumn',
-		...new Set(imports.singlestore),
-	];
-	const importsTs = `import { ${
-		uniqueSingleStoreImports.join(
-			', ',
-		)
-	} } from "drizzle-orm/singlestore-core"\nimport { sql } from "drizzle-orm"\n\n`;
-
-	let decalrations = '';
-	decalrations += tableStatements.join('\n\n');
-	decalrations += '\n';
-	/* decalrations += viewsStatements.join('\n\n'); */
-
-	const file = importsTs + decalrations;
-
-	const schemaEntry = `
-    {
-      ${
-		Object.values(schema.tables)
-			.map((it) => withCasing(it.name))
-			.join(',')
-	}
-    }
-  `;
-
-	return {
-		file, // backward compatible, print to file
-		imports: importsTs,
-		decalrations,
-		schemaEntry,
-	};
-};
-
-const mapColumnDefault = (defaultValue: any, isExpression?: boolean) => {
-	if (isExpression) {
-		return `sql\`${defaultValue}\``;
-	}
-
-	return defaultValue;
-};
-
-const mapColumnDefaultForJson = (defaultValue: any) => {
-	if (
-		typeof defaultValue === 'string'
-		&& defaultValue.startsWith("('")
-		&& defaultValue.endsWith("')")
-	) {
-		return defaultValue.substring(2, defaultValue.length - 2);
-	}
-
-	return defaultValue;
-};
-
-const column = (
-	type: string,
-	name: string,
-	casing: (value: string) => string,
-	rawCasing: Casing,
-	defaultValue?: any,
-	autoincrement?: boolean,
-	onUpdate?: boolean,
-	isExpression?: boolean,
-) => {
-	let lowered = type;
-	if (!type.startsWith('enum(')) {
-		lowered = type.toLowerCase();
-	}
-
-	if (lowered === 'serial') {
-		return `${casing(name)}: serial(${dbColumnName({ name, casing: rawCasing })})`;
-	}
-
-	if (lowered.startsWith('int')) {
-		const isUnsigned = lowered.includes('unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: int(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('tinyint')) {
-		const isUnsigned = lowered.includes('unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out: string = `${casing(name)}: tinyint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('smallint')) {
-		const isUnsigned = lowered.includes('unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: smallint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('mediumint')) {
-		const isUnsigned = lowered.includes('unsigned');
-		const columnName = dbColumnName({ name, casing: rawCasing, withMode: isUnsigned });
-		let out = `${casing(name)}: mediumint(${columnName}${isUnsigned ? '{ unsigned: true }' : ''})`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('bigint')) {
-		const isUnsigned = lowered.includes('unsigned');
-		let out = `${casing(name)}: bigint(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: "number"${
-			isUnsigned ? ', unsigned: true' : ''
-		} })`;
-		out += autoincrement ? `.autoincrement()` : '';
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'boolean') {
-		let out = `${casing(name)}: boolean(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('double')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 15 : 6)) {
-			const [precision, scale] = lowered
-				.slice(7, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		const timeConfigParams = params ? timeConfig(params) : undefined;
-
-		let out = params
-			? `${casing(name)}: double(${
-				dbColumnName({ name, casing: rawCasing, withMode: timeConfigParams !== undefined })
-			}${timeConfig(params)})`
-			: `${casing(name)}: double(${dbColumnName({ name, casing: rawCasing })})`;
-
-		// let out = `${name.camelCase()}: double("${name}")`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('float')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 14 : 5)) {
-			const [precision, scale] = lowered
-				.slice(6, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		let out = `${casing(name)}: float(${dbColumnName({ name, casing: rawCasing })}${params ? timeConfig(params) : ''})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'real') {
-		let out = `${casing(name)}: real(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('timestamp')) {
-		const keyLength = 'timestamp'.length + 1;
-		let fsp = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		fsp = fsp ? fsp : null;
-
-		const params = timeConfig({ fsp, mode: "'string'" });
-
-		let out = params
-			? `${casing(name)}: timestamp(${
-				dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })
-			}${params})`
-			: `${casing(name)}: timestamp(${dbColumnName({ name, casing: rawCasing })})`;
-
-		// singlestore has only CURRENT_TIMESTAMP, as I found from docs. But will leave now() for just a case
-		defaultValue = defaultValue === 'now()' || defaultValue === 'CURRENT_TIMESTAMP'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-
-		let onUpdateNow = onUpdate ? '.onUpdateNow()' : '';
-		out += onUpdateNow;
-
-		return out;
-	}
-
-	if (lowered.startsWith('time')) {
-		const keyLength = 'time'.length + 1;
-		let fsp = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		fsp = fsp ? fsp : null;
-
-		const params = timeConfig({ fsp });
-
-		let out = params
-			? `${casing(name)}: time(${dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })}${params})`
-			: `${casing(name)}: time(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered === 'date') {
-		let out = `// you can use { mode: 'date' }, if you want to have Date as type for this column\n\t${
-			casing(
-				name,
-			)
-		}: date(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string' })`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	// in singlestore text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'text') {
-		let out = `${casing(name)}: text(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in singlestore text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'tinytext') {
-		let out = `${casing(name)}: tinytext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in singlestore text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'mediumtext') {
-		let out = `${casing(name)}: mediumtext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in singlestore text can't have default value. Will leave it in case smth ;)
-	if (lowered === 'longtext') {
-		let out = `${casing(name)}: longtext(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'year') {
-		let out = `${casing(name)}: year(${dbColumnName({ name, casing: rawCasing })})`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	// in singlestore json can't have default value. Will leave it in case smth ;)
-	if (lowered === 'json') {
-		let out = `${casing(name)}: json(${dbColumnName({ name, casing: rawCasing })})`;
-
-		out += defaultValue
-			? `.default(${mapColumnDefaultForJson(defaultValue)})`
-			: '';
-
-		return out;
-	}
-
-	if (lowered.startsWith('varchar')) {
-		let out: string = `${
-			casing(
-				name,
-			)
-		}: varchar(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ length: ${
-			lowered.substring(
-				'varchar'.length + 1,
-				lowered.length - 1,
-			)
-		} })`;
-
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('char')) {
-		let out: string = `${
-			casing(
-				name,
-			)
-		}: char(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ length: ${
-			lowered.substring(
-				'char'.length + 1,
-				lowered.length - 1,
-			)
-		} })`;
-
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('datetime')) {
-		let out = `// you can use { mode: 'date' }, if you want to have Date as type for this column\n\t`;
-
-		const fsp = lowered.startsWith('datetime(')
-			? lowered.substring('datetime'.length + 1, lowered.length - 1)
-			: undefined;
-
-		out = fsp
-			? `${
-				casing(
-					name,
-				)
-			}: datetime(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string', fsp: ${
-				lowered.substring(
-					'datetime'.length + 1,
-					lowered.length - 1,
-				)
-			} })`
-			: `${casing(name)}: datetime(${dbColumnName({ name, casing: rawCasing, withMode: true })}{ mode: 'string'})`;
-
-		defaultValue = defaultValue === 'now()'
-			? '.defaultNow()'
-			: defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('decimal')) {
-		let params:
-			| { precision?: string; scale?: string; unsigned?: boolean }
-			| undefined;
-
-		if (lowered.length > (lowered.includes('unsigned') ? 16 : 7)) {
-			const [precision, scale] = lowered
-				.slice(8, lowered.length - (1 + (lowered.includes('unsigned') ? 9 : 0)))
-				.split(',');
-			params = { precision, scale };
-		}
-
-		if (lowered.includes('unsigned')) {
-			params = { ...(params ?? {}), unsigned: true };
-		}
-
-		const timeConfigParams = params ? timeConfig(params) : undefined;
-
-		let out = params
-			? `${casing(name)}: decimal(${
-				dbColumnName({ name, casing: rawCasing, withMode: timeConfigParams !== undefined })
-			}${timeConfigParams})`
-			: `${casing(name)}: decimal(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('binary')) {
-		const keyLength = 'binary'.length + 1;
-		let length = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		length = length ? length : null;
-
-		const params = binaryConfig({ length });
-
-		let out = params
-			? `${casing(name)}: binary(${dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })}${params})`
-			: `${casing(name)}: binary(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('enum')) {
-		const values = lowered.substring('enum'.length + 1, lowered.length - 1);
-		let out = `${casing(name)}: singlestoreEnum(${
-			dbColumnName({ name, casing: rawCasing, withMode: true })
-		}[${values}])`;
-		out += defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-		return out;
-	}
-
-	if (lowered.startsWith('varbinary')) {
-		const keyLength = 'varbinary'.length + 1;
-		let length = lowered.length > keyLength
-			? Number(lowered.substring(keyLength, lowered.length - 1))
-			: null;
-		length = length ? length : null;
-
-		const params = binaryConfig({ length });
-
-		let out = params
-			? `${casing(name)}: varbinary(${
-				dbColumnName({ name, casing: rawCasing, withMode: params !== undefined })
-			}${params})`
-			: `${casing(name)}: varbinary(${dbColumnName({ name, casing: rawCasing })})`;
-
-		defaultValue = defaultValue
-			? `.default(${mapColumnDefault(defaultValue, isExpression)})`
-			: '';
-
-		out += defaultValue;
-		return out;
-	}
-
-	if (lowered.startsWith('vector')) {
-		const [dimensions, elementType] = lowered.substring('vector'.length + 1, lowered.length - 1).split(',');
-		let out = `${casing(name)}: vector(${
-			dbColumnName({ name, casing: rawCasing, withMode: true })
-		}{ dimensions: ${dimensions}, elementType: ${elementType} })`;
-
-		out += defaultValue ? `.default(${mapColumnDefault(defaultValue, isExpression)})` : '';
-		return out;
-	}
-
-	console.log('uknown', type);
-	return `// Warning: Can't parse ${type} from database\n\t// ${type}Type: ${type}("${name}")`;
-};
-
-const createTableColumns = (
-	columns: Column[],
-	casing: (val: string) => string,
-	rawCasing: Casing,
-	tableName: string,
-	schema: SingleStoreSchemaInternal,
-): string => {
-	let statement = '';
-
-	columns.forEach((it) => {
-		statement += '\t';
-		statement += column(
-			it.type,
-			it.name,
-			casing,
-			rawCasing,
-			it.default,
-			it.autoincrement,
-			it.onUpdate,
-			schema.internal?.tables![tableName]?.columns[it.name]
-				?.isDefaultAnExpression ?? false,
-		);
-		statement += it.primaryKey ? '.primaryKey()' : '';
-		statement += it.notNull ? '.notNull()' : '';
-
-		statement += it.generated
-			? `.generatedAlwaysAs(sql\`${
-				it.generated.as.replace(
-					/`/g,
-					'\\`',
-				)
-			}\`, { mode: "${it.generated.type}" })`
-			: '';
-
-		statement += ',\n';
-	});
-
-	return statement;
-};
-
-const createTableIndexes = (
-	tableName: string,
-	idxs: Index[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	idxs.forEach((it) => {
-		let idxKey = it.name.startsWith(tableName) && it.name !== tableName
-			? it.name.slice(tableName.length + 1)
-			: it.name;
-		idxKey = idxKey.endsWith('_index')
-			? idxKey.slice(0, -'_index'.length) + '_idx'
-			: idxKey;
-
-		idxKey = casing(idxKey);
-
-		const indexGeneratedName = indexName(tableName, it.columns);
-		const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
-
-		statement += `\n\t`;
-		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
-		statement += `${escapedIndexName})`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${casing(it)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-
-const createTableUniques = (
-	unqs: UniqueConstraint[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	unqs.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'unique(';
-		statement += `"${it.name}")`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${casing(it)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-
-const createTablePKs = (
-	pks: PrimaryKey[],
-	casing: (value: string) => string,
-): string => {
-	let statement = '';
-
-	pks.forEach((it) => {
-		let idxKey = casing(it.name);
-
-		statement += `\n\t`;
-		statement += 'primaryKey({ columns: [';
-		statement += `${
-			it.columns
-				.map((c) => {
-					return `table.${casing(c)}`;
-				})
-				.join(', ')
-		}]${it.name ? `, name: "${it.name}"` : ''}}`;
-		statement += '),';
-	});
-
-	return statement;
-};
diff --git a/drizzle-kit/src/introspect-sqlite.ts b/drizzle-kit/src/introspect-sqlite.ts
deleted file mode 100644
index d3aac6f04f..0000000000
--- a/drizzle-kit/src/introspect-sqlite.ts
+++ /dev/null
@@ -1,533 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { toCamelCase } from 'drizzle-orm/casing';
-import './@types/utils';
-import type { Casing } from './cli/validations/common';
-import { assertUnreachable } from './global';
-import { CheckConstraint } from './serializer/mysqlSchema';
-import type {
-	Column,
-	ForeignKey,
-	Index,
-	PrimaryKey,
-	SQLiteSchema,
-	SQLiteSchemaInternal,
-	UniqueConstraint,
-} from './serializer/sqliteSchema';
-
-const sqliteImportsList = new Set([
-	'sqliteTable',
-	'integer',
-	'real',
-	'text',
-	'numeric',
-	'blob',
-]);
-
-export const indexName = (tableName: string, columns: string[]) => {
-	return `${tableName}_${columns.join('_')}_index`;
-};
-
-const objToStatement2 = (json: any) => {
-	json = Object.fromEntries(Object.entries(json).filter((it) => it[1]));
-
-	const keys = Object.keys(json);
-	if (keys.length === 0) return;
-
-	let statement = '{ ';
-	statement += keys.map((it) => `${it}: "${json[it]}"`).join(', '); // no "" for keys
-	statement += ' }';
-	return statement;
-};
-
-const relations = new Set<string>();
-
-const escapeColumnKey = (value: string) => {
-	if (/^(?![a-zA-Z_$][a-zA-Z0-9_$]*$).+$/.test(value)) {
-		return `"${value}"`;
-	}
-	return value;
-};
-
-const withCasing = (value: string, casing?: Casing) => {
-	if (casing === 'preserve') {
-		return escapeColumnKey(value);
-	}
-	if (casing === 'camel') {
-		return escapeColumnKey(value.camelCase());
-	}
-
-	return value;
-};
-
-const dbColumnName = ({ name, casing, withMode = false }: { name: string; casing: Casing; withMode?: boolean }) => {
-	if (casing === 'preserve') {
-		return '';
-	}
-	if (casing === 'camel') {
-		return toCamelCase(name) === name ? '' : withMode ? `"${name}", ` : `"${name}"`;
-	}
-
-	assertUnreachable(casing);
-};
-
-export const schemaToTypeScript = (
-	schema: SQLiteSchemaInternal,
-	casing: Casing,
-) => {
-	// collectFKs
-	Object.values(schema.tables).forEach((table) => {
-		Object.values(table.foreignKeys).forEach((fk) => {
-			const relation = `${fk.tableFrom}-${fk.tableTo}`;
-			relations.add(relation);
-		});
-	});
-
-	const imports = Object.values(schema.tables).reduce(
-		(res, it) => {
-			const idxImports = Object.values(it.indexes).map((idx) => idx.isUnique ? 'uniqueIndex' : 'index');
-			const fkImpots = Object.values(it.foreignKeys).map((it) => 'foreignKey');
-			const pkImports = Object.values(it.compositePrimaryKeys).map(
-				(it) => 'primaryKey',
-			);
-			const uniqueImports = Object.values(it.uniqueConstraints).map(
-				(it) => 'unique',
-			);
-			const checkImports = Object.values(it.checkConstraints).map(
-				(it) => 'check',
-			);
-
-			res.sqlite.push(...idxImports);
-			res.sqlite.push(...fkImpots);
-			res.sqlite.push(...pkImports);
-			res.sqlite.push(...uniqueImports);
-			res.sqlite.push(...checkImports);
-
-			const columnImports = Object.values(it.columns)
-				.map((col) => {
-					return col.type;
-				})
-				.filter((type) => {
-					return sqliteImportsList.has(type);
-				});
-
-			res.sqlite.push(...columnImports);
-			return res;
-		},
-		{ sqlite: [] as string[] },
-	);
-
-	Object.values(schema.views).forEach((it) => {
-		imports.sqlite.push('sqliteView');
-
-		const columnImports = Object.values(it.columns)
-			.map((col) => {
-				return col.type;
-			})
-			.filter((type) => {
-				return sqliteImportsList.has(type);
-			});
-
-		imports.sqlite.push(...columnImports);
-	});
-
-	const tableStatements = Object.values(schema.tables).map((table) => {
-		const func = 'sqliteTable';
-		let statement = '';
-		if (imports.sqlite.includes(withCasing(table.name, casing))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					table.name,
-					casing,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(table.name, casing)} = ${func}("${table.name}", {\n`;
-		statement += createTableColumns(
-			Object.values(table.columns),
-			Object.values(table.foreignKeys),
-			casing,
-		);
-		statement += '}';
-
-		// more than 2 fields or self reference or cyclic
-		const filteredFKs = Object.values(table.foreignKeys).filter((it) => {
-			return it.columnsFrom.length > 1 || isSelf(it);
-		});
-
-		if (
-			Object.keys(table.indexes).length > 0
-			|| filteredFKs.length > 0
-			|| Object.keys(table.compositePrimaryKeys).length > 0
-			|| Object.keys(table.uniqueConstraints).length > 0
-			|| Object.keys(table.checkConstraints).length > 0
-		) {
-			statement += ',\n';
-			statement += '(table) => [';
-			statement += createTableIndexes(
-				table.name,
-				Object.values(table.indexes),
-				casing,
-			);
-			statement += createTableFKs(Object.values(filteredFKs), casing);
-			statement += createTablePKs(
-				Object.values(table.compositePrimaryKeys),
-				casing,
-			);
-			statement += createTableUniques(
-				Object.values(table.uniqueConstraints),
-				casing,
-			);
-			statement += createTableChecks(
-				Object.values(table.checkConstraints),
-				casing,
-			);
-			statement += '\n]';
-		}
-
-		statement += ');';
-		return statement;
-	});
-
-	const viewsStatements = Object.values(schema.views).map((view) => {
-		const func = 'sqliteView';
-
-		let statement = '';
-		if (imports.sqlite.includes(withCasing(view.name, casing))) {
-			statement = `// Table name is in conflict with ${
-				withCasing(
-					view.name,
-					casing,
-				)
-			} import.\n// Please change to any other name, that is not in imports list\n`;
-		}
-		statement += `export const ${withCasing(view.name, casing)} = ${func}("${view.name}", {\n`;
-		statement += createTableColumns(
-			Object.values(view.columns),
-			[],
-			casing,
-		);
-		statement += '})';
-		statement += `.as(sql\`${view.definition?.replaceAll('`', '\\`')}\`);`;
-
-		return statement;
-	});
-
-	const uniqueSqliteImports = [
-		'sqliteTable',
-		'AnySQLiteColumn',
-		...new Set(imports.sqlite),
-	];
-
-	const importsTs = `import { ${
-		uniqueSqliteImports.join(
-			', ',
-		)
-	} } from "drizzle-orm/sqlite-core"
-  import { sql } from "drizzle-orm"\n\n`;
-
-	let decalrations = tableStatements.join('\n\n');
-	decalrations += '\n\n';
-	decalrations += viewsStatements.join('\n\n');
-
-	const file = importsTs + decalrations;
-
-	// for drizzle studio query runner
-	const schemaEntry = `
-    {
-      ${
-		Object.values(schema.tables)
-			.map((it) => withCasing(it.name, casing))
-			.join(',')
-	}
-    }
-  `;
-
-	return { file, imports: importsTs, decalrations, schemaEntry };
-};
-
-const isCyclic = (fk: ForeignKey) => {
-	const key = `${fk.tableFrom}-${fk.tableTo}`;
-	const reverse = `${fk.tableTo}-${fk.tableFrom}`;
-	return relations.has(key) && relations.has(reverse);
-};
-
-const isSelf = (fk: ForeignKey) => {
-	return fk.tableFrom === fk.tableTo;
-};
-
-const mapColumnDefault = (defaultValue: any) => {
-	if (
-		typeof defaultValue === 'string'
-		&& defaultValue.startsWith('(')
-		&& defaultValue.endsWith(')')
-	) {
-		return `sql\`${defaultValue}\``;
-	}
-	// If default value is NULL as string it will come back from db as "'NULL'" and not just "NULL"
-	if (defaultValue === 'NULL') {
-		return `sql\`NULL\``;
-	}
-
-	if (
-		typeof defaultValue === 'string'
-	) {
-		return defaultValue.substring(1, defaultValue.length - 1).replaceAll('"', '\\"').replaceAll("''", "'");
-	}
-
-	return defaultValue;
-};
-
-const column = (
-	type: string,
-	name: string,
-	defaultValue?: any,
-	autoincrement?: boolean,
-	casing?: Casing,
-) => {
-	let lowered = type;
-	casing = casing!;
-
-	if (lowered === 'integer') {
-		let out = `${withCasing(name, casing)}: integer(${dbColumnName({ name, casing })})`;
-		// out += autoincrement ? `.autoincrement()` : "";
-		out += typeof defaultValue !== 'undefined'
-			? `.default(${mapColumnDefault(defaultValue)})`
-			: '';
-		return out;
-	}
-
-	if (lowered === 'real') {
-		let out = `${withCasing(name, casing)}: real(${dbColumnName({ name, casing })})`;
-		out += defaultValue ? `.default(${mapColumnDefault(defaultValue)})` : '';
-		return out;
-	}
-
-	if (lowered.startsWith('text')) {
-		const match = lowered.match(/\d+/);
-		let out: string;
-
-		if (match) {
-			out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing, withMode: true })}{ length: ${
-				match[0]
-			} })`;
-		} else {
-			out = `${withCasing(name, casing)}: text(${dbColumnName({ name, casing })})`;
-		}
-
-		out += defaultValue ? `.default("${mapColumnDefault(defaultValue)}")` : '';
-		return out;
-	}
-
-	if (lowered === 'blob') {
-		let out = `${withCasing(name, casing)}: blob(${dbColumnName({ name, casing })})`;
-		out += defaultValue ? `.default(${mapColumnDefault(defaultValue)})` : '';
-		return out;
-	}
-
-	if (lowered === 'numeric') {
-		let out = `${withCasing(name, casing)}: numeric(${dbColumnName({ name, casing })})`;
-		out += defaultValue ? `.default(${mapColumnDefault(defaultValue)})` : '';
-		return out;
-	}
-
-	//   console.log("uknown", type);
-	return `// Warning: Can't parse ${type} from database\n\t// ${type}Type: ${type}("${name}")`;
-};
-
-const createTableColumns = (
-	columns: Column[],
-	fks: ForeignKey[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	// no self refs and no cyclic
-	const oneColumnsFKs = Object.values(fks)
-		.filter((it) => {
-			return !isSelf(it);
-		})
-		.filter((it) => it.columnsFrom.length === 1);
-
-	const fkByColumnName = oneColumnsFKs.reduce((res, it) => {
-		const arr = res[it.columnsFrom[0]] || [];
-		arr.push(it);
-		res[it.columnsFrom[0]] = arr;
-		return res;
-	}, {} as Record<string, ForeignKey[]>);
-
-	columns.forEach((it) => {
-		statement += '\t';
-		statement += column(it.type, it.name, it.default, it.autoincrement, casing);
-		statement += it.primaryKey
-			? `.primaryKey(${it.autoincrement ? '{ autoIncrement: true }' : ''})`
-			: '';
-		statement += it.notNull ? '.notNull()' : '';
-
-		statement += it.generated
-			? `.generatedAlwaysAs(sql\`${
-				it.generated.as
-					.replace(/`/g, '\\`')
-					.slice(1, -1)
-			}\`, { mode: "${it.generated.type}" })`
-			: '';
-
-		const fks = fkByColumnName[it.name];
-		if (fks) {
-			const fksStatement = fks
-				.map((it) => {
-					const onDelete = it.onDelete && it.onDelete !== 'no action' ? it.onDelete : null;
-					const onUpdate = it.onUpdate && it.onUpdate !== 'no action' ? it.onUpdate : null;
-					const params = { onDelete, onUpdate };
-
-					const typeSuffix = isCyclic(it) ? ': AnySQLiteColumn' : '';
-
-					const paramsStr = objToStatement2(params);
-					if (paramsStr) {
-						return `.references(()${typeSuffix} => ${
-							withCasing(
-								it.tableTo,
-								casing,
-							)
-						}.${withCasing(it.columnsTo[0], casing)}, ${paramsStr} )`;
-					}
-					return `.references(()${typeSuffix} => ${
-						withCasing(
-							it.tableTo,
-							casing,
-						)
-					}.${withCasing(it.columnsTo[0], casing)})`;
-				})
-				.join('');
-			statement += fksStatement;
-		}
-
-		statement += ',\n';
-	});
-
-	return statement;
-};
-
-const createTableIndexes = (
-	tableName: string,
-	idxs: Index[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	idxs.forEach((it) => {
-		let idxKey = it.name.startsWith(tableName) && it.name !== tableName
-			? it.name.slice(tableName.length + 1)
-			: it.name;
-		idxKey = idxKey.endsWith('_index')
-			? idxKey.slice(0, -'_index'.length) + '_idx'
-			: idxKey;
-
-		idxKey = withCasing(idxKey, casing);
-
-		const indexGeneratedName = indexName(tableName, it.columns);
-		const escapedIndexName = indexGeneratedName === it.name ? '' : `"${it.name}"`;
-
-		statement += `\n\t`;
-		statement += it.isUnique ? 'uniqueIndex(' : 'index(';
-		statement += `${escapedIndexName})`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${withCasing(it, casing)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-
-const createTableUniques = (
-	unqs: UniqueConstraint[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	unqs.forEach((it) => {
-		const idxKey = withCasing(it.name, casing);
-
-		statement += `\n\t`;
-		statement += 'unique(';
-		statement += `"${it.name}")`;
-		statement += `.on(${
-			it.columns
-				.map((it) => `table.${withCasing(it, casing)}`)
-				.join(', ')
-		}),`;
-	});
-
-	return statement;
-};
-const createTableChecks = (
-	checks: CheckConstraint[],
-	casing: Casing,
-): string => {
-	let statement = '';
-
-	checks.forEach((it) => {
-		statement += `\n\t`;
-		statement += 'check(';
-		statement += `"${it.name}", `;
-		statement += `sql\`${it.value}\`)`;
-		statement += `,`;
-	});
-
-	return statement;
-};
-
-const createTablePKs = (pks: PrimaryKey[], casing: Casing): string => {
-	let statement = '';
-
-	pks.forEach((it, i) => {
-		statement += `\n\t`;
-		statement += 'primaryKey({ columns: [';
-		statement += `${
-			it.columns
-				.map((c) => {
-					return `table.${withCasing(c, casing)}`;
-				})
-				.join(', ')
-		}]${it.name ? `, name: "${it.name}"` : ''}}`;
-		statement += ')';
-	});
-
-	return statement;
-};
-
-const createTableFKs = (fks: ForeignKey[], casing: Casing): string => {
-	let statement = '';
-
-	fks.forEach((it) => {
-		const isSelf = it.tableTo === it.tableFrom;
-		const tableTo = isSelf ? 'table' : `${withCasing(it.tableTo, casing)}`;
-		statement += `\n\t`;
-		statement += `foreignKey(() => ({\n`;
-		statement += `\t\t\tcolumns: [${
-			it.columnsFrom
-				.map((i) => `table.${withCasing(i, casing)}`)
-				.join(', ')
-		}],\n`;
-		statement += `\t\t\tforeignColumns: [${
-			it.columnsTo
-				.map((i) => `${tableTo}.${withCasing(i, casing)}`)
-				.join(', ')
-		}],\n`;
-		statement += `\t\t\tname: "${it.name}"\n`;
-		statement += `\t\t}))`;
-
-		statement += it.onUpdate && it.onUpdate !== 'no action'
-			? `.onUpdate("${it.onUpdate}")`
-			: '';
-
-		statement += it.onDelete && it.onDelete !== 'no action'
-			? `.onDelete("${it.onDelete}")`
-			: '';
-
-		statement += `,`;
-	});
-
-	return statement;
-};
diff --git a/drizzle-kit/src/jsonStatements.ts b/drizzle-kit/src/jsonStatements.ts
deleted file mode 100644
index 4929519758..0000000000
--- a/drizzle-kit/src/jsonStatements.ts
+++ /dev/null
@@ -1,3554 +0,0 @@
-import chalk from 'chalk';
-import { getNewTableName } from './cli/commands/sqlitePushUtils';
-import { warning } from './cli/views';
-import { CommonSquashedSchema } from './schemaValidator';
-import { MySqlKitInternals, MySqlSchema, MySqlSquasher, View as MySqlView } from './serializer/mysqlSchema';
-import {
-	Index,
-	MatViewWithOption,
-	PgSchema,
-	PgSchemaSquashed,
-	PgSquasher,
-	Policy,
-	Role,
-	View as PgView,
-	ViewWithOption,
-} from './serializer/pgSchema';
-import { SingleStoreKitInternals, SingleStoreSchema, SingleStoreSquasher } from './serializer/singlestoreSchema';
-import {
-	SQLiteKitInternals,
-	SQLiteSchemaInternal,
-	SQLiteSchemaSquashed,
-	SQLiteSquasher,
-	View as SqliteView,
-} from './serializer/sqliteSchema';
-import { AlteredColumn, Column, Sequence, Table } from './snapshotsDiffer';
-
-export interface JsonSqliteCreateTableStatement {
-	type: 'sqlite_create_table';
-	tableName: string;
-	columns: Column[];
-	referenceData: {
-		name: string;
-		tableFrom: string;
-		columnsFrom: string[];
-		tableTo: string;
-		columnsTo: string[];
-		onUpdate?: string | undefined;
-		onDelete?: string | undefined;
-	}[];
-	compositePKs: string[][];
-	uniqueConstraints?: string[];
-	checkConstraints?: string[];
-}
-
-export interface JsonCreateTableStatement {
-	type: 'create_table';
-	tableName: string;
-	schema: string;
-	columns: Column[];
-	compositePKs: string[];
-	compositePkName?: string;
-	uniqueConstraints?: string[];
-	policies?: string[];
-	checkConstraints?: string[];
-	internals?: MySqlKitInternals | SingleStoreKitInternals;
-	isRLSEnabled?: boolean;
-}
-
-export interface JsonRecreateTableStatement {
-	type: 'recreate_table';
-	tableName: string;
-	columns: Column[];
-	referenceData: {
-		name: string;
-		tableFrom: string;
-		columnsFrom: string[];
-		tableTo: string;
-		columnsTo: string[];
-		onUpdate?: string | undefined;
-		onDelete?: string | undefined;
-	}[];
-	compositePKs: string[][];
-	uniqueConstraints?: string[];
-	checkConstraints: string[];
-}
-
-export interface JsonRecreateSingleStoreTableStatement {
-	type: 'singlestore_recreate_table';
-	tableName: string;
-	columns: Column[];
-	compositePKs: string[];
-	uniqueConstraints?: string[];
-}
-
-export interface JsonDropTableStatement {
-	type: 'drop_table';
-	tableName: string;
-	schema: string;
-	policies?: string[];
-}
-
-export interface JsonRenameTableStatement {
-	type: 'rename_table';
-	fromSchema: string;
-	toSchema: string;
-	tableNameFrom: string;
-	tableNameTo: string;
-}
-
-export interface JsonCreateEnumStatement {
-	type: 'create_type_enum';
-	name: string;
-	schema: string;
-	values: string[];
-}
-
-export interface JsonDropEnumStatement {
-	type: 'drop_type_enum';
-	name: string;
-	schema: string;
-}
-
-export interface JsonMoveEnumStatement {
-	type: 'move_type_enum';
-	name: string;
-	schemaFrom: string;
-	schemaTo: string;
-}
-
-export interface JsonRenameEnumStatement {
-	type: 'rename_type_enum';
-	nameFrom: string;
-	nameTo: string;
-	schema: string;
-}
-
-export interface JsonAddValueToEnumStatement {
-	type: 'alter_type_add_value';
-	name: string;
-	schema: string;
-	value: string;
-	before: string;
-}
-
-//////
-
-export interface JsonCreateRoleStatement {
-	type: 'create_role';
-	name: string;
-	values: {
-		inherit?: boolean;
-		createDb?: boolean;
-		createRole?: boolean;
-	};
-}
-
-export interface JsonDropRoleStatement {
-	type: 'drop_role';
-	name: string;
-}
-export interface JsonRenameRoleStatement {
-	type: 'rename_role';
-	nameFrom: string;
-	nameTo: string;
-}
-
-export interface JsonAlterRoleStatement {
-	type: 'alter_role';
-	name: string;
-	values: {
-		inherit?: boolean;
-		createDb?: boolean;
-		createRole?: boolean;
-	};
-}
-
-//////
-
-export interface JsonDropValueFromEnumStatement {
-	type: 'alter_type_drop_value';
-	name: string;
-	enumSchema: string;
-	deletedValues: string[];
-	newValues: string[];
-	columnsWithEnum: { tableSchema: string; table: string; column: string; default?: string; columnType: string }[];
-}
-
-export interface JsonCreateSequenceStatement {
-	type: 'create_sequence';
-	name: string;
-	schema: string;
-	values: {
-		increment?: string | undefined;
-		minValue?: string | undefined;
-		maxValue?: string | undefined;
-		startWith?: string | undefined;
-		cache?: string | undefined;
-		cycle?: boolean | undefined;
-	};
-}
-
-export interface JsonDropSequenceStatement {
-	type: 'drop_sequence';
-	name: string;
-	schema: string;
-}
-
-export interface JsonMoveSequenceStatement {
-	type: 'move_sequence';
-	name: string;
-	schemaFrom: string;
-	schemaTo: string;
-}
-
-export interface JsonRenameSequenceStatement {
-	type: 'rename_sequence';
-	nameFrom: string;
-	nameTo: string;
-	schema: string;
-}
-
-export interface JsonAlterSequenceStatement {
-	type: 'alter_sequence';
-	name: string;
-	schema: string;
-	values: {
-		increment?: string | undefined;
-		minValue?: string | undefined;
-		maxValue?: string | undefined;
-		startWith?: string | undefined;
-		cache?: string | undefined;
-		cycle?: boolean | undefined;
-	};
-}
-
-export interface JsonDropColumnStatement {
-	type: 'alter_table_drop_column';
-	tableName: string;
-	columnName: string;
-	schema: string;
-}
-
-export interface JsonAddColumnStatement {
-	type: 'alter_table_add_column';
-	tableName: string;
-	column: Column;
-	schema: string;
-}
-
-export interface JsonSqliteAddColumnStatement {
-	type: 'sqlite_alter_table_add_column';
-	tableName: string;
-	column: Column;
-	referenceData?: string;
-}
-
-export interface JsonCreatePolicyStatement {
-	type: 'create_policy';
-	tableName: string;
-	data: Policy;
-	schema: string;
-}
-
-export interface JsonCreateIndPolicyStatement {
-	type: 'create_ind_policy';
-	tableName: string;
-	data: Policy;
-}
-
-export interface JsonDropPolicyStatement {
-	type: 'drop_policy';
-	tableName: string;
-	data: Policy;
-	schema: string;
-}
-
-export interface JsonDropIndPolicyStatement {
-	type: 'drop_ind_policy';
-	tableName: string;
-	data: Policy;
-}
-
-export interface JsonRenamePolicyStatement {
-	type: 'rename_policy';
-	tableName: string;
-	oldName: string;
-	newName: string;
-	schema: string;
-}
-
-export interface JsonIndRenamePolicyStatement {
-	type: 'rename_ind_policy';
-	tableKey: string;
-	oldName: string;
-	newName: string;
-}
-
-export interface JsonEnableRLSStatement {
-	type: 'enable_rls';
-	tableName: string;
-	schema: string;
-}
-
-export interface JsonDisableRLSStatement {
-	type: 'disable_rls';
-	tableName: string;
-	schema: string;
-}
-
-export interface JsonAlterPolicyStatement {
-	type: 'alter_policy';
-	tableName: string;
-	oldData: string;
-	newData: string;
-	schema: string;
-}
-
-export interface JsonAlterIndPolicyStatement {
-	type: 'alter_ind_policy';
-	oldData: Policy;
-	newData: Policy;
-}
-
-export interface JsonCreateIndexStatement {
-	type: 'create_index';
-	tableName: string;
-	data: string;
-	schema: string;
-	internal?: MySqlKitInternals | SQLiteKitInternals | SingleStoreKitInternals;
-}
-
-export interface JsonPgCreateIndexStatement {
-	type: 'create_index_pg';
-	tableName: string;
-	data: Index;
-	schema: string;
-}
-
-export interface JsonReferenceStatement {
-	type: 'create_reference' | 'alter_reference' | 'delete_reference';
-	data: string;
-	schema: string;
-	tableName: string;
-	isMulticolumn?: boolean;
-	columnNotNull?: boolean;
-	columnDefault?: string;
-	columnType?: string;
-	//   fromTable: string;
-	//   fromColumns: string[];
-	//   toTable: string;
-	//   toColumns: string[];
-	//   foreignKeyName: string;
-	//   onDelete?: string;
-	//   onUpdate?: string;
-}
-
-export interface JsonCreateUniqueConstraint {
-	type: 'create_unique_constraint';
-	tableName: string;
-	data: string;
-	schema?: string;
-	constraintName?: string;
-}
-
-export interface JsonDeleteUniqueConstraint {
-	type: 'delete_unique_constraint';
-	tableName: string;
-	data: string;
-	schema?: string;
-	constraintName?: string;
-}
-
-export interface JsonAlterUniqueConstraint {
-	type: 'alter_unique_constraint';
-	tableName: string;
-	old: string;
-	new: string;
-	schema?: string;
-	oldConstraintName?: string;
-	newConstraintName?: string;
-}
-
-export interface JsonCreateCheckConstraint {
-	type: 'create_check_constraint';
-	tableName: string;
-	data: string;
-	schema?: string;
-}
-
-export interface JsonDeleteCheckConstraint {
-	type: 'delete_check_constraint';
-	tableName: string;
-	constraintName: string;
-	schema?: string;
-}
-
-export interface JsonCreateCompositePK {
-	type: 'create_composite_pk';
-	tableName: string;
-	data: string;
-	schema?: string;
-	constraintName?: string;
-}
-
-export interface JsonDeleteCompositePK {
-	type: 'delete_composite_pk';
-	tableName: string;
-	data: string;
-	schema?: string;
-	constraintName?: string;
-}
-
-export interface JsonAlterCompositePK {
-	type: 'alter_composite_pk';
-	tableName: string;
-	old: string;
-	new: string;
-	schema?: string;
-	oldConstraintName?: string;
-	newConstraintName?: string;
-}
-
-export interface JsonAlterTableSetSchema {
-	type: 'alter_table_set_schema';
-	tableName: string;
-	schemaFrom: string;
-	schemaTo: string;
-}
-
-export interface JsonAlterTableRemoveFromSchema {
-	type: 'alter_table_remove_from_schema';
-	tableName: string;
-	schema: string;
-}
-
-export interface JsonAlterTableSetNewSchema {
-	type: 'alter_table_set_new_schema';
-	tableName: string;
-	from: string;
-	to: string;
-}
-
-export interface JsonCreateReferenceStatement extends JsonReferenceStatement {
-	type: 'create_reference';
-}
-
-export interface JsonAlterReferenceStatement extends JsonReferenceStatement {
-	type: 'alter_reference';
-	oldFkey: string;
-}
-
-export interface JsonDeleteReferenceStatement extends JsonReferenceStatement {
-	type: 'delete_reference';
-}
-
-export interface JsonDropIndexStatement {
-	type: 'drop_index';
-	tableName: string;
-	data: string;
-	schema: string;
-}
-
-export interface JsonRenameColumnStatement {
-	type: 'alter_table_rename_column';
-	tableName: string;
-	oldColumnName: string;
-	newColumnName: string;
-	schema: string;
-}
-
-export interface JsonAlterColumnTypeStatement {
-	type: 'alter_table_alter_column_set_type';
-	tableName: string;
-	columnName: string;
-	newDataType: string;
-	oldDataType: string;
-	schema: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
-}
-
-export interface JsonAlterColumnPgTypeStatement {
-	type: 'pg_alter_table_alter_column_set_type';
-	tableName: string;
-	columnName: string;
-	typeSchema: string | undefined;
-	newDataType: { name: string; isEnum: boolean };
-	oldDataType: { name: string; isEnum: boolean };
-	schema: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
-}
-
-export interface JsonAlterColumnSetPrimaryKeyStatement {
-	type: 'alter_table_alter_column_set_pk';
-	tableName: string;
-	schema: string;
-	columnName: string;
-}
-
-export interface JsonAlterColumnDropPrimaryKeyStatement {
-	type: 'alter_table_alter_column_drop_pk';
-	tableName: string;
-	columnName: string;
-	schema: string;
-}
-
-export interface JsonAlterColumnSetDefaultStatement {
-	type: 'alter_table_alter_column_set_default';
-	tableName: string;
-	columnName: string;
-	newDefaultValue: any;
-	oldDefaultValue?: any;
-	schema: string;
-	newDataType: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnDropDefaultStatement {
-	type: 'alter_table_alter_column_drop_default';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnSetNotNullStatement {
-	type: 'alter_table_alter_column_set_notnull';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnDropNotNullStatement {
-	type: 'alter_table_alter_column_drop_notnull';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnSetGeneratedStatement {
-	type: 'alter_table_alter_column_set_generated';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
-}
-export interface JsonAlterColumnSetIdentityStatement {
-	type: 'alter_table_alter_column_set_identity';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	identity: string;
-}
-
-export interface JsonAlterColumnDropIdentityStatement {
-	type: 'alter_table_alter_column_drop_identity';
-	tableName: string;
-	columnName: string;
-	schema: string;
-}
-
-export interface JsonAlterColumnAlterIdentityStatement {
-	type: 'alter_table_alter_column_change_identity';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	identity: string;
-	oldIdentity: string;
-}
-
-export interface JsonAlterColumnDropGeneratedStatement {
-	type: 'alter_table_alter_column_drop_generated';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
-	oldColumn?: Column;
-}
-
-export interface JsonAlterColumnAlterGeneratedStatement {
-	type: 'alter_table_alter_column_alter_generated';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
-}
-
-export interface JsonAlterColumnSetOnUpdateStatement {
-	type: 'alter_table_alter_column_set_on_update';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnDropOnUpdateStatement {
-	type: 'alter_table_alter_column_drop_on_update';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnSetAutoincrementStatement {
-	type: 'alter_table_alter_column_set_autoincrement';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonAlterColumnDropAutoincrementStatement {
-	type: 'alter_table_alter_column_drop_autoincrement';
-	tableName: string;
-	columnName: string;
-	schema: string;
-	newDataType: string;
-	columnDefault: string;
-	columnOnUpdate: boolean;
-	columnNotNull: boolean;
-	columnAutoIncrement: boolean;
-	columnPk: boolean;
-}
-
-export interface JsonCreateSchema {
-	type: 'create_schema';
-	name: string;
-}
-
-export interface JsonDropSchema {
-	type: 'drop_schema';
-	name: string;
-}
-
-export interface JsonRenameSchema {
-	type: 'rename_schema';
-	from: string;
-	to: string;
-}
-
-export type JsonCreatePgViewStatement = {
-	type: 'create_view';
-} & Omit<PgView, 'columns' | 'isExisting'>;
-
-export type JsonCreateMySqlViewStatement = {
-	type: 'mysql_create_view';
-	replace: boolean;
-} & Omit<MySqlView, 'columns' | 'isExisting'>;
-
-/* export type JsonCreateSingleStoreViewStatement = {
-	type: 'singlestore_create_view';
-	replace: boolean;
-} & Omit<SingleStoreView, 'columns' | 'isExisting'>; */
-
-export type JsonCreateSqliteViewStatement = {
-	type: 'sqlite_create_view';
-} & Omit<SqliteView, 'columns' | 'isExisting'>;
-
-export interface JsonDropViewStatement {
-	type: 'drop_view';
-	name: string;
-	schema?: string;
-	materialized?: boolean;
-}
-
-export interface JsonRenameViewStatement {
-	type: 'rename_view';
-	nameTo: string;
-	nameFrom: string;
-	schema: string;
-	materialized?: boolean;
-}
-
-export interface JsonRenameMySqlViewStatement {
-	type: 'rename_view';
-	nameTo: string;
-	nameFrom: string;
-	schema: string;
-	materialized?: boolean;
-}
-
-export interface JsonAlterViewAlterSchemaStatement {
-	type: 'alter_view_alter_schema';
-	fromSchema: string;
-	toSchema: string;
-	name: string;
-	materialized?: boolean;
-}
-
-export type JsonAlterViewAddWithOptionStatement =
-	& {
-		type: 'alter_view_add_with_option';
-		schema: string;
-		name: string;
-	}
-	& ({
-		materialized: true;
-		with: MatViewWithOption;
-	} | {
-		materialized: false;
-		with: ViewWithOption;
-	});
-
-export type JsonAlterViewDropWithOptionStatement =
-	& {
-		type: 'alter_view_drop_with_option';
-		schema: string;
-		name: string;
-	}
-	& ({
-		materialized: true;
-		with: MatViewWithOption;
-	} | {
-		materialized: false;
-		with: ViewWithOption;
-	});
-
-export interface JsonAlterViewAlterTablespaceStatement {
-	type: 'alter_view_alter_tablespace';
-	toTablespace: string;
-	name: string;
-	schema: string;
-	materialized: true;
-}
-
-export interface JsonAlterViewAlterUsingStatement {
-	type: 'alter_view_alter_using';
-	toUsing: string;
-	name: string;
-	schema: string;
-	materialized: true;
-}
-
-export type JsonAlterMySqlViewStatement = {
-	type: 'alter_mysql_view';
-} & Omit<MySqlView, 'isExisting'>;
-
-/* export type JsonAlterSingleStoreViewStatement = {
-	type: 'alter_singlestore_view';
-} & Omit<SingleStoreView, 'isExisting'>; */
-
-export type JsonAlterViewStatement =
-	| JsonAlterViewAlterSchemaStatement
-	| JsonAlterViewAddWithOptionStatement
-	| JsonAlterViewDropWithOptionStatement
-	| JsonAlterViewAlterTablespaceStatement
-	| JsonAlterViewAlterUsingStatement;
-
-export type JsonAlterColumnStatement =
-	| JsonRenameColumnStatement
-	| JsonAlterColumnTypeStatement
-	| JsonAlterColumnPgTypeStatement
-	| JsonAlterColumnSetDefaultStatement
-	| JsonAlterColumnDropDefaultStatement
-	| JsonAlterColumnSetNotNullStatement
-	| JsonAlterColumnDropNotNullStatement
-	| JsonAlterColumnDropOnUpdateStatement
-	| JsonAlterColumnSetOnUpdateStatement
-	| JsonAlterColumnDropAutoincrementStatement
-	| JsonAlterColumnSetAutoincrementStatement
-	| JsonAlterColumnSetPrimaryKeyStatement
-	| JsonAlterColumnDropPrimaryKeyStatement
-	| JsonAlterColumnSetGeneratedStatement
-	| JsonAlterColumnDropGeneratedStatement
-	| JsonAlterColumnAlterGeneratedStatement
-	| JsonAlterColumnSetIdentityStatement
-	| JsonAlterColumnAlterIdentityStatement
-	| JsonAlterColumnDropIdentityStatement;
-
-export type JsonStatement =
-	| JsonRecreateSingleStoreTableStatement
-	| JsonRecreateTableStatement
-	| JsonAlterColumnStatement
-	| JsonCreateTableStatement
-	| JsonDropTableStatement
-	| JsonRenameTableStatement
-	| JsonCreateEnumStatement
-	| JsonDropEnumStatement
-	| JsonMoveEnumStatement
-	| JsonRenameEnumStatement
-	| JsonAddValueToEnumStatement
-	| JsonDropColumnStatement
-	| JsonAddColumnStatement
-	| JsonCreateIndexStatement
-	| JsonCreateReferenceStatement
-	| JsonAlterReferenceStatement
-	| JsonDeleteReferenceStatement
-	| JsonDropIndexStatement
-	| JsonReferenceStatement
-	| JsonSqliteCreateTableStatement
-	| JsonSqliteAddColumnStatement
-	| JsonCreateCompositePK
-	| JsonDeleteCompositePK
-	| JsonAlterCompositePK
-	| JsonCreateUniqueConstraint
-	| JsonDeleteUniqueConstraint
-	| JsonAlterUniqueConstraint
-	| JsonCreateSchema
-	| JsonDropSchema
-	| JsonRenameSchema
-	| JsonAlterTableSetSchema
-	| JsonAlterTableRemoveFromSchema
-	| JsonAlterTableSetNewSchema
-	| JsonPgCreateIndexStatement
-	| JsonAlterSequenceStatement
-	| JsonDropSequenceStatement
-	| JsonCreateSequenceStatement
-	| JsonMoveSequenceStatement
-	| JsonRenameSequenceStatement
-	| JsonDropPolicyStatement
-	| JsonCreatePolicyStatement
-	| JsonAlterPolicyStatement
-	| JsonRenamePolicyStatement
-	| JsonEnableRLSStatement
-	| JsonDisableRLSStatement
-	| JsonRenameRoleStatement
-	| JsonCreateRoleStatement
-	| JsonDropRoleStatement
-	| JsonAlterRoleStatement
-	| JsonCreatePgViewStatement
-	| JsonDropViewStatement
-	| JsonRenameViewStatement
-	| JsonAlterViewStatement
-	| JsonCreateMySqlViewStatement
-	| JsonAlterMySqlViewStatement
-	/* | JsonCreateSingleStoreViewStatement
-	| JsonAlterSingleStoreViewStatement */
-	| JsonCreateSqliteViewStatement
-	| JsonCreateCheckConstraint
-	| JsonDeleteCheckConstraint
-	| JsonDropValueFromEnumStatement
-	| JsonIndRenamePolicyStatement
-	| JsonDropIndPolicyStatement
-	| JsonCreateIndPolicyStatement
-	| JsonAlterIndPolicyStatement;
-
-export const preparePgCreateTableJson = (
-	table: Table,
-	// TODO: remove?
-	json2: PgSchema,
-): JsonCreateTableStatement => {
-	const { name, schema, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints, policies, isRLSEnabled } =
-		table;
-	const tableKey = `${schema || 'public'}.${name}`;
-
-	// TODO: @AndriiSherman. We need this, will add test cases
-	const compositePkName = Object.values(compositePrimaryKeys).length > 0
-		? json2.tables[tableKey].compositePrimaryKeys[
-			`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`
-		].name
-		: '';
-
-	return {
-		type: 'create_table',
-		tableName: name,
-		schema,
-		columns: Object.values(columns),
-		compositePKs: Object.values(compositePrimaryKeys),
-		compositePkName: compositePkName,
-		uniqueConstraints: Object.values(uniqueConstraints),
-		policies: Object.values(policies),
-		checkConstraints: Object.values(checkConstraints),
-		isRLSEnabled: isRLSEnabled ?? false,
-	};
-};
-
-export const prepareMySqlCreateTableJson = (
-	table: Table,
-	// TODO: remove?
-	json2: MySqlSchema,
-	// we need it to know if some of the indexes(and in future other parts) are expressions or columns
-	// didn't change mysqlserialaizer, because it will break snapshots and diffs and it's hard to detect
-	// if previously it was an expression or column
-	internals: MySqlKitInternals,
-): JsonCreateTableStatement => {
-	const { name, schema, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints } = table;
-
-	return {
-		type: 'create_table',
-		tableName: name,
-		schema,
-		columns: Object.values(columns),
-		compositePKs: Object.values(compositePrimaryKeys),
-		compositePkName: Object.values(compositePrimaryKeys).length > 0
-			? json2.tables[name].compositePrimaryKeys[
-				MySqlSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0])
-					.name
-			].name
-			: '',
-		uniqueConstraints: Object.values(uniqueConstraints),
-		internals,
-		checkConstraints: Object.values(checkConstraints),
-	};
-};
-
-export const prepareSingleStoreCreateTableJson = (
-	table: Table,
-	// TODO: remove?
-	json2: SingleStoreSchema,
-	// we need it to know if some of the indexes(and in future other parts) are expressions or columns
-	// didn't change singlestoreserialaizer, because it will break snapshots and diffs and it's hard to detect
-	// if previously it was an expression or column
-	internals: SingleStoreKitInternals,
-): JsonCreateTableStatement => {
-	const { name, schema, columns, compositePrimaryKeys, uniqueConstraints } = table;
-
-	return {
-		type: 'create_table',
-		tableName: name,
-		schema,
-		columns: Object.values(columns),
-		compositePKs: Object.values(compositePrimaryKeys),
-		compositePkName: Object.values(compositePrimaryKeys).length > 0
-			? json2.tables[name].compositePrimaryKeys[
-				SingleStoreSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0])
-					.name
-			].name
-			: '',
-		uniqueConstraints: Object.values(uniqueConstraints),
-		internals,
-	};
-};
-
-export const prepareSQLiteCreateTable = (
-	table: Table,
-	action?: 'push' | undefined,
-): JsonSqliteCreateTableStatement => {
-	const { name, columns, uniqueConstraints, checkConstraints } = table;
-
-	const references: string[] = Object.values(table.foreignKeys);
-
-	const composites: string[][] = Object.values(table.compositePrimaryKeys).map(
-		(it) => SQLiteSquasher.unsquashPK(it),
-	);
-
-	const fks = references.map((it) =>
-		action === 'push'
-			? SQLiteSquasher.unsquashPushFK(it)
-			: SQLiteSquasher.unsquashFK(it)
-	);
-
-	return {
-		type: 'sqlite_create_table',
-		tableName: name,
-		columns: Object.values(columns),
-		referenceData: fks,
-		compositePKs: composites,
-		uniqueConstraints: Object.values(uniqueConstraints),
-		checkConstraints: Object.values(checkConstraints),
-	};
-};
-
-export const prepareDropTableJson = (table: Table): JsonDropTableStatement => {
-	return {
-		type: 'drop_table',
-		tableName: table.name,
-		schema: table.schema,
-		policies: table.policies ? Object.values(table.policies) : [],
-	};
-};
-
-export const prepareRenameTableJson = (
-	tableFrom: Table,
-	tableTo: Table,
-): JsonRenameTableStatement => {
-	return {
-		type: 'rename_table',
-		fromSchema: tableTo.schema,
-		toSchema: tableTo.schema,
-		tableNameFrom: tableFrom.name,
-		tableNameTo: tableTo.name,
-	};
-};
-
-export const prepareCreateEnumJson = (
-	name: string,
-	schema: string,
-	values: string[],
-): JsonCreateEnumStatement => {
-	return {
-		type: 'create_type_enum',
-		name: name,
-		schema: schema,
-		values,
-	};
-};
-
-// https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
-export const prepareAddValuesToEnumJson = (
-	name: string,
-	schema: string,
-	values: { value: string; before: string }[],
-): JsonAddValueToEnumStatement[] => {
-	return values.map((it) => {
-		return {
-			type: 'alter_type_add_value',
-			name: name,
-			schema: schema,
-			value: it.value,
-			before: it.before,
-		};
-	});
-};
-
-export const prepareDropEnumValues = (
-	name: string,
-	schema: string,
-	removedValues: string[],
-	json2: PgSchema,
-): JsonDropValueFromEnumStatement[] => {
-	if (!removedValues.length) return [];
-
-	const affectedColumns: JsonDropValueFromEnumStatement['columnsWithEnum'] = [];
-
-	for (const tableKey in json2.tables) {
-		const table = json2.tables[tableKey];
-		for (const columnKey in table.columns) {
-			const column = table.columns[columnKey];
-
-			const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
-			const parsedColumnType = column.type.replace(arrayDefinitionRegex, '');
-
-			if (parsedColumnType === name && column.typeSchema === schema) {
-				affectedColumns.push({
-					tableSchema: table.schema,
-					table: table.name,
-					column: column.name,
-					columnType: column.type,
-					default: column.default,
-				});
-			}
-		}
-	}
-
-	return [{
-		type: 'alter_type_drop_value',
-		name: name,
-		enumSchema: schema,
-		deletedValues: removedValues,
-		newValues: json2.enums[`${schema}.${name}`].values,
-		columnsWithEnum: affectedColumns,
-	}];
-};
-
-export const prepareDropEnumJson = (
-	name: string,
-	schema: string,
-): JsonDropEnumStatement => {
-	return {
-		type: 'drop_type_enum',
-		name: name,
-		schema: schema,
-	};
-};
-
-export const prepareMoveEnumJson = (
-	name: string,
-	schemaFrom: string,
-	schemaTo: string,
-): JsonMoveEnumStatement => {
-	return {
-		type: 'move_type_enum',
-		name: name,
-		schemaFrom,
-		schemaTo,
-	};
-};
-
-export const prepareRenameEnumJson = (
-	nameFrom: string,
-	nameTo: string,
-	schema: string,
-): JsonRenameEnumStatement => {
-	return {
-		type: 'rename_type_enum',
-		nameFrom,
-		nameTo,
-		schema,
-	};
-};
-
-////////////
-
-export const prepareCreateSequenceJson = (
-	seq: Sequence,
-): JsonCreateSequenceStatement => {
-	const values = PgSquasher.unsquashSequence(seq.values);
-	return {
-		type: 'create_sequence',
-		name: seq.name,
-		schema: seq.schema,
-		values,
-	};
-};
-
-export const prepareAlterSequenceJson = (
-	seq: Sequence,
-): JsonAlterSequenceStatement[] => {
-	const values = PgSquasher.unsquashSequence(seq.values);
-	return [
-		{
-			type: 'alter_sequence',
-			schema: seq.schema,
-			name: seq.name,
-			values,
-		},
-	];
-};
-
-export const prepareDropSequenceJson = (
-	name: string,
-	schema: string,
-): JsonDropSequenceStatement => {
-	return {
-		type: 'drop_sequence',
-		name: name,
-		schema: schema,
-	};
-};
-
-export const prepareMoveSequenceJson = (
-	name: string,
-	schemaFrom: string,
-	schemaTo: string,
-): JsonMoveSequenceStatement => {
-	return {
-		type: 'move_sequence',
-		name: name,
-		schemaFrom,
-		schemaTo,
-	};
-};
-
-export const prepareRenameSequenceJson = (
-	nameFrom: string,
-	nameTo: string,
-	schema: string,
-): JsonRenameSequenceStatement => {
-	return {
-		type: 'rename_sequence',
-		nameFrom,
-		nameTo,
-		schema,
-	};
-};
-
-////////////
-
-export const prepareCreateRoleJson = (
-	role: Role,
-): JsonCreateRoleStatement => {
-	return {
-		type: 'create_role',
-		name: role.name,
-		values: {
-			createDb: role.createDb,
-			createRole: role.createRole,
-			inherit: role.inherit,
-		},
-	};
-};
-
-export const prepareAlterRoleJson = (
-	role: Role,
-): JsonAlterRoleStatement => {
-	return {
-		type: 'alter_role',
-		name: role.name,
-		values: {
-			createDb: role.createDb,
-			createRole: role.createRole,
-			inherit: role.inherit,
-		},
-	};
-};
-
-export const prepareDropRoleJson = (
-	name: string,
-): JsonDropRoleStatement => {
-	return {
-		type: 'drop_role',
-		name: name,
-	};
-};
-
-export const prepareRenameRoleJson = (
-	nameFrom: string,
-	nameTo: string,
-): JsonRenameRoleStatement => {
-	return {
-		type: 'rename_role',
-		nameFrom,
-		nameTo,
-	};
-};
-
-//////////
-
-export const prepareCreateSchemasJson = (
-	values: string[],
-): JsonCreateSchema[] => {
-	return values.map((it) => {
-		return {
-			type: 'create_schema',
-			name: it,
-		} as JsonCreateSchema;
-	});
-};
-
-export const prepareRenameSchemasJson = (
-	values: { from: string; to: string }[],
-): JsonRenameSchema[] => {
-	return values.map((it) => {
-		return {
-			type: 'rename_schema',
-			from: it.from,
-			to: it.to,
-		} as JsonRenameSchema;
-	});
-};
-
-export const prepareDeleteSchemasJson = (
-	values: string[],
-): JsonDropSchema[] => {
-	return values.map((it) => {
-		return {
-			type: 'drop_schema',
-			name: it,
-		} as JsonDropSchema;
-	});
-};
-
-export const prepareRenameColumns = (
-	tableName: string,
-	// TODO: split for pg and mysql+sqlite and singlestore without schema
-	schema: string,
-	pairs: { from: Column; to: Column }[],
-): JsonRenameColumnStatement[] => {
-	return pairs.map((it) => {
-		return {
-			type: 'alter_table_rename_column',
-			tableName: tableName,
-			oldColumnName: it.from.name,
-			newColumnName: it.to.name,
-			schema,
-		};
-	});
-};
-
-export const _prepareDropColumns = (
-	taleName: string,
-	schema: string,
-	columns: Column[],
-): JsonDropColumnStatement[] => {
-	return columns.map((it) => {
-		return {
-			type: 'alter_table_drop_column',
-			tableName: taleName,
-			columnName: it.name,
-			schema,
-		};
-	});
-};
-
-export const _prepareAddColumns = (
-	tableName: string,
-	schema: string,
-	columns: Column[],
-): JsonAddColumnStatement[] => {
-	return columns.map((it) => {
-		return {
-			type: 'alter_table_add_column',
-			tableName: tableName,
-			column: it,
-			schema,
-		};
-	});
-};
-
-export const _prepareSqliteAddColumns = (
-	tableName: string,
-	columns: Column[],
-	referenceData: string[],
-): JsonSqliteAddColumnStatement[] => {
-	const unsquashed = referenceData.map((addedFkValue) => SQLiteSquasher.unsquashFK(addedFkValue));
-
-	return columns
-		.map((it) => {
-			const columnsWithReference = unsquashed.find((t) => t.columnsFrom.includes(it.name));
-
-			if (it.generated?.type === 'stored') {
-				warning(
-					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
-				);
-				return undefined;
-			}
-
-			return {
-				type: 'sqlite_alter_table_add_column',
-				tableName: tableName,
-				column: it,
-				referenceData: columnsWithReference
-					? SQLiteSquasher.squashFK(columnsWithReference)
-					: undefined,
-			};
-		})
-		.filter(Boolean) as JsonSqliteAddColumnStatement[];
-};
-
-export const prepareAlterColumnsMysql = (
-	tableName: string,
-	schema: string,
-	columns: AlteredColumn[],
-	// TODO: remove?
-	json1: CommonSquashedSchema,
-	json2: CommonSquashedSchema,
-	action?: 'push' | undefined,
-): JsonAlterColumnStatement[] => {
-	let statements: JsonAlterColumnStatement[] = [];
-	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
-	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		const table = json2.tables[tableName];
-		const snapshotColumn = table.columns[columnName];
-
-		const columnType = snapshotColumn.type;
-		const columnDefault = snapshotColumn.default;
-		const columnOnUpdate = 'onUpdate' in snapshotColumn ? snapshotColumn.onUpdate : undefined;
-		const columnNotNull = table.columns[columnName].notNull;
-
-		const columnAutoIncrement = 'autoincrement' in snapshotColumn
-			? snapshotColumn.autoincrement ?? false
-			: false;
-
-		const columnPk = table.columns[columnName].primaryKey;
-
-		if (column.autoincrement?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'changed') {
-			const type = column.autoincrement.new
-				? 'alter_table_alter_column_set_autoincrement'
-				: 'alter_table_alter_column_drop_autoincrement';
-
-			statements.push({
-				type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		// I used any, because those fields are available only for mysql dialect
-		// For other dialects it will become undefined, that is fine for json statements
-		const columnType = json2.tables[tableName].columns[columnName].type;
-		const columnDefault = json2.tables[tableName].columns[columnName].default;
-		const columnGenerated = json2.tables[tableName].columns[columnName].generated;
-		const columnOnUpdate = (json2.tables[tableName].columns[columnName] as any)
-			.onUpdate;
-		const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
-		const columnAutoIncrement = (
-			json2.tables[tableName].columns[columnName] as any
-		).autoincrement;
-		const columnPk = (json2.tables[tableName].columns[columnName] as any)
-			.primaryKey;
-
-		const compositePk = json2.tables[tableName].compositePrimaryKeys[
-			`${tableName}_${columnName}`
-		];
-
-		if (typeof column.name !== 'string') {
-			statements.push({
-				type: 'alter_table_rename_column',
-				tableName,
-				oldColumnName: column.name.old,
-				newColumnName: column.name.new,
-				schema,
-			});
-		}
-
-		if (column.type?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_type',
-				tableName,
-				columnName,
-				newDataType: column.type.new,
-				oldDataType: column.type.old,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'deleted'
-			|| (column.primaryKey?.type === 'changed'
-				&& !column.primaryKey.new
-				&& typeof compositePk === 'undefined')
-		) {
-			dropPkStatements.push({
-				////
-				type: 'alter_table_alter_column_drop_pk',
-				tableName,
-				columnName,
-				schema,
-			});
-		}
-
-		if (column.default?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.value,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.new,
-				oldDefaultValue: column.default.old,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_default',
-				tableName,
-				columnName,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'changed') {
-			const type = column.notNull.new
-				? 'alter_table_alter_column_set_notnull'
-				: 'alter_table_alter_column_drop_notnull';
-			statements.push({
-				type: type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.generated?.type === 'added') {
-			if (columnGenerated?.type === 'virtual') {
-				warning(
-					`You are trying to add virtual generated constraint to ${
-						chalk.blue(
-							columnName,
-						)
-					} column. As MySQL docs mention: "Nongenerated columns can be altered to stored but not virtual generated columns". We will drop an existing column and add it with a virtual generated statement. This means that the data previously stored in this column will be wiped, and new data will be generated on each read for this column\n`,
-				);
-			}
-			statements.push({
-				type: 'alter_table_alter_column_set_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'changed' && action !== 'push') {
-			statements.push({
-				type: 'alter_table_alter_column_alter_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'deleted') {
-			if (columnGenerated?.type === 'virtual') {
-				warning(
-					`You are trying to remove virtual generated constraint from ${
-						chalk.blue(
-							columnName,
-						)
-					} column. As MySQL docs mention: "Stored but not virtual generated columns can be altered to nongenerated columns. The stored generated values become the values of the nongenerated column". We will drop an existing column and add it without a virtual generated statement. This means that this column will have no data after migration\n`,
-				);
-			}
-			statements.push({
-				type: 'alter_table_alter_column_drop_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-				oldColumn: json1.tables[tableName].columns[columnName],
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'added'
-			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
-		) {
-			const wasAutoincrement = statements.filter(
-				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
-			);
-			if (wasAutoincrement.length === 0) {
-				setPkStatements.push({
-					type: 'alter_table_alter_column_set_pk',
-					tableName,
-					schema,
-					columnName,
-				});
-			}
-		}
-
-		if (column.onUpdate?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.onUpdate?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	return [...dropPkStatements, ...setPkStatements, ...statements];
-};
-
-export const prepareAlterColumnsSingleStore = (
-	tableName: string,
-	schema: string,
-	columns: AlteredColumn[],
-	// TODO: remove?
-	json1: CommonSquashedSchema,
-	json2: CommonSquashedSchema,
-	action?: 'push' | undefined,
-): JsonAlterColumnStatement[] => {
-	let statements: JsonAlterColumnStatement[] = [];
-	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
-	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		const table = json2.tables[tableName];
-		const snapshotColumn = table.columns[columnName];
-
-		const columnType = snapshotColumn.type;
-		const columnDefault = snapshotColumn.default;
-		const columnOnUpdate = 'onUpdate' in snapshotColumn ? snapshotColumn.onUpdate : undefined;
-		const columnNotNull = table.columns[columnName].notNull;
-
-		const columnAutoIncrement = 'autoincrement' in snapshotColumn
-			? snapshotColumn.autoincrement ?? false
-			: false;
-
-		const columnPk = table.columns[columnName].primaryKey;
-
-		if (column.autoincrement?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'changed') {
-			const type = column.autoincrement.new
-				? 'alter_table_alter_column_set_autoincrement'
-				: 'alter_table_alter_column_drop_autoincrement';
-
-			statements.push({
-				type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		// I used any, because those fields are available only for mysql and singlestore dialect
-		// For other dialects it will become undefined, that is fine for json statements
-		const columnType = json2.tables[tableName].columns[columnName].type;
-		const columnDefault = json2.tables[tableName].columns[columnName].default;
-		const columnGenerated = json2.tables[tableName].columns[columnName].generated;
-		const columnOnUpdate = (json2.tables[tableName].columns[columnName] as any)
-			.onUpdate;
-		const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
-		const columnAutoIncrement = (
-			json2.tables[tableName].columns[columnName] as any
-		).autoincrement;
-		const columnPk = (json2.tables[tableName].columns[columnName] as any)
-			.primaryKey;
-
-		const compositePk = json2.tables[tableName].compositePrimaryKeys[
-			`${tableName}_${columnName}`
-		];
-
-		if (typeof column.name !== 'string') {
-			statements.push({
-				type: 'alter_table_rename_column',
-				tableName,
-				oldColumnName: column.name.old,
-				newColumnName: column.name.new,
-				schema,
-			});
-		}
-
-		if (column.type?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_type',
-				tableName,
-				columnName,
-				newDataType: column.type.new,
-				oldDataType: column.type.old,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'deleted'
-			|| (column.primaryKey?.type === 'changed'
-				&& !column.primaryKey.new
-				&& typeof compositePk === 'undefined')
-		) {
-			dropPkStatements.push({
-				////
-				type: 'alter_table_alter_column_drop_pk',
-				tableName,
-				columnName,
-				schema,
-			});
-		}
-
-		if (column.default?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.value,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.new,
-				oldDefaultValue: column.default.old,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_default',
-				tableName,
-				columnName,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'changed') {
-			const type = column.notNull.new
-				? 'alter_table_alter_column_set_notnull'
-				: 'alter_table_alter_column_drop_notnull';
-			statements.push({
-				type: type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.generated?.type === 'added') {
-			if (columnGenerated?.type === 'virtual') {
-				// TODO: Change warning message according to SingleStore docs
-				warning(
-					`You are trying to add virtual generated constraint to ${
-						chalk.blue(
-							columnName,
-						)
-					} column. As MySQL docs mention: "Nongenerated columns can be altered to stored but not virtual generated columns". We will drop an existing column and add it with a virtual generated statement. This means that the data previously stored in this column will be wiped, and new data will be generated on each read for this column\n`,
-				);
-			}
-			statements.push({
-				type: 'alter_table_alter_column_set_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'changed' && action !== 'push') {
-			statements.push({
-				type: 'alter_table_alter_column_alter_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'deleted') {
-			if (columnGenerated?.type === 'virtual') {
-				// TODO: Change warning message according to SingleStore docs
-				warning(
-					`You are trying to remove virtual generated constraint from ${
-						chalk.blue(
-							columnName,
-						)
-					} column. As MySQL docs mention: "Stored but not virtual generated columns can be altered to nongenerated columns. The stored generated values become the values of the nongenerated column". We will drop an existing column and add it without a virtual generated statement. This means that this column will have no data after migration\n`,
-				);
-			}
-			statements.push({
-				type: 'alter_table_alter_column_drop_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-				oldColumn: json1.tables[tableName].columns[columnName],
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'added'
-			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
-		) {
-			const wasAutoincrement = statements.filter(
-				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
-			);
-			if (wasAutoincrement.length === 0) {
-				setPkStatements.push({
-					type: 'alter_table_alter_column_set_pk',
-					tableName,
-					schema,
-					columnName,
-				});
-			}
-		}
-
-		if (column.onUpdate?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.onUpdate?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	return [...dropPkStatements, ...setPkStatements, ...statements];
-};
-
-export const preparePgAlterColumns = (
-	_tableName: string,
-	schema: string,
-	columns: AlteredColumn[],
-	// TODO: remove?
-	json2: PgSchemaSquashed,
-	json1: PgSchemaSquashed,
-	action?: 'push' | undefined,
-): JsonAlterColumnStatement[] => {
-	const tableKey = `${schema || 'public'}.${_tableName}`;
-	let statements: JsonAlterColumnStatement[] = [];
-	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
-	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		const tableName = json2.tables[tableKey].name;
-
-		// I used any, because those fields are available only for mysql dialect
-		// For other dialects it will become undefined, that is fine for json statements
-		const columnType = json2.tables[tableKey].columns[columnName].type;
-		const columnDefault = json2.tables[tableKey].columns[columnName].default;
-		const columnGenerated = json2.tables[tableKey].columns[columnName].generated;
-		const columnOnUpdate = (json2.tables[tableKey].columns[columnName] as any)
-			.onUpdate;
-		const columnNotNull = json2.tables[tableKey].columns[columnName].notNull;
-		const columnAutoIncrement = (
-			json2.tables[tableKey].columns[columnName] as any
-		).autoincrement;
-		const columnPk = (json2.tables[tableKey].columns[columnName] as any)
-			.primaryKey;
-		const typeSchema = json2.tables[tableKey].columns[columnName].typeSchema;
-		const json1ColumnTypeSchema = json1.tables[tableKey].columns[columnName].typeSchema;
-
-		const compositePk = json2.tables[tableKey].compositePrimaryKeys[`${tableName}_${columnName}`];
-
-		if (typeof column.name !== 'string') {
-			statements.push({
-				type: 'alter_table_rename_column',
-				tableName,
-				oldColumnName: column.name.old,
-				newColumnName: column.name.new,
-				schema,
-			});
-		}
-
-		if (column.type?.type === 'changed') {
-			const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
-			const parsedNewColumnType = column.type.new.replace(arrayDefinitionRegex, '');
-			const parsedOldColumnType = column.type.old.replace(arrayDefinitionRegex, '');
-
-			const isNewTypeIsEnum = json2.enums[`${typeSchema}.${parsedNewColumnType}`];
-			const isOldTypeIsEnum = json1.enums[`${json1ColumnTypeSchema}.${parsedOldColumnType}`];
-
-			statements.push({
-				type: 'pg_alter_table_alter_column_set_type',
-				tableName,
-				columnName,
-				typeSchema: typeSchema,
-				newDataType: {
-					name: column.type.new,
-					isEnum: isNewTypeIsEnum ? true : false,
-				},
-				oldDataType: {
-					name: column.type.old,
-					isEnum: isOldTypeIsEnum ? true : false,
-				},
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'deleted'
-			|| (column.primaryKey?.type === 'changed'
-				&& !column.primaryKey.new
-				&& typeof compositePk === 'undefined')
-		) {
-			dropPkStatements.push({
-				////
-				type: 'alter_table_alter_column_drop_pk',
-				tableName,
-				columnName,
-				schema,
-			});
-		}
-
-		if (column.default?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.value,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.new,
-				oldDefaultValue: column.default.old,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_default',
-				tableName,
-				columnName,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'changed') {
-			const type = column.notNull.new
-				? 'alter_table_alter_column_set_notnull'
-				: 'alter_table_alter_column_drop_notnull';
-			statements.push({
-				type: type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.identity?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_identity',
-				tableName,
-				columnName,
-				schema,
-				identity: column.identity.value,
-			});
-		}
-
-		if (column.identity?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_change_identity',
-				tableName,
-				columnName,
-				schema,
-				identity: column.identity.new,
-				oldIdentity: column.identity.old,
-			});
-		}
-
-		if (column.identity?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_identity',
-				tableName,
-				columnName,
-				schema,
-			});
-		}
-
-		if (column.generated?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'changed' && action !== 'push') {
-			statements.push({
-				type: 'alter_table_alter_column_alter_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (column.generated?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'added'
-			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
-		) {
-			const wasAutoincrement = statements.filter(
-				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
-			);
-			if (wasAutoincrement.length === 0) {
-				setPkStatements.push({
-					type: 'alter_table_alter_column_set_pk',
-					tableName,
-					schema,
-					columnName,
-				});
-			}
-		}
-
-		// if (column.primaryKey?.type === "added") {
-		//   statements.push({
-		//     type: "alter_table_alter_column_set_primarykey",
-		//     tableName,
-		//     columnName,
-		//     schema,
-		//     newDataType: columnType,
-		//     columnDefault,
-		//     columnOnUpdate,
-		//     columnNotNull,
-		//     columnAutoIncrement,
-		//   });
-		// }
-
-		// if (column.primaryKey?.type === "changed") {
-		//   const type = column.primaryKey.new
-		//     ? "alter_table_alter_column_set_primarykey"
-		//     : "alter_table_alter_column_drop_primarykey";
-
-		//   statements.push({
-		//     type,
-		//     tableName,
-		//     columnName,
-		//     schema,
-		//     newDataType: columnType,
-		//     columnDefault,
-		//     columnOnUpdate,
-		//     columnNotNull,
-		//     columnAutoIncrement,
-		//   });
-		// }
-
-		// if (column.primaryKey?.type === "deleted") {
-		//   statements.push({
-		//     type: "alter_table_alter_column_drop_primarykey",
-		//     tableName,
-		//     columnName,
-		//     schema,
-		//     newDataType: columnType,
-		//     columnDefault,
-		//     columnOnUpdate,
-		//     columnNotNull,
-		//     columnAutoIncrement,
-		//   });
-		// }
-
-		if (column.onUpdate?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.onUpdate?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	return [...dropPkStatements, ...setPkStatements, ...statements];
-};
-
-export const prepareSqliteAlterColumns = (
-	tableName: string,
-	schema: string,
-	columns: AlteredColumn[],
-	// TODO: remove?
-	json2: CommonSquashedSchema,
-): JsonAlterColumnStatement[] => {
-	let statements: JsonAlterColumnStatement[] = [];
-	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
-	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
-
-	for (const column of columns) {
-		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
-
-		// I used any, because those fields are available only for mysql dialect
-		// For other dialects it will become undefined, that is fine for json statements
-		const columnType = json2.tables[tableName].columns[columnName].type;
-		const columnDefault = json2.tables[tableName].columns[columnName].default;
-		const columnOnUpdate = (json2.tables[tableName].columns[columnName] as any)
-			.onUpdate;
-		const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
-		const columnAutoIncrement = (
-			json2.tables[tableName].columns[columnName] as any
-		).autoincrement;
-		const columnPk = (json2.tables[tableName].columns[columnName] as any)
-			.primaryKey;
-
-		const columnGenerated = json2.tables[tableName].columns[columnName].generated;
-
-		const compositePk = json2.tables[tableName].compositePrimaryKeys[
-			`${tableName}_${columnName}`
-		];
-
-		if (column.autoincrement?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'changed') {
-			const type = column.autoincrement.new
-				? 'alter_table_alter_column_set_autoincrement'
-				: 'alter_table_alter_column_drop_autoincrement';
-
-			statements.push({
-				type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.autoincrement?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_autoincrement',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (typeof column.name !== 'string') {
-			statements.push({
-				type: 'alter_table_rename_column',
-				tableName,
-				oldColumnName: column.name.old,
-				newColumnName: column.name.new,
-				schema,
-			});
-		}
-
-		if (column.type?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_type',
-				tableName,
-				columnName,
-				newDataType: column.type.new,
-				oldDataType: column.type.old,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'deleted'
-			|| (column.primaryKey?.type === 'changed'
-				&& !column.primaryKey.new
-				&& typeof compositePk === 'undefined')
-		) {
-			dropPkStatements.push({
-				////
-				type: 'alter_table_alter_column_drop_pk',
-				tableName,
-				columnName,
-				schema,
-			});
-		}
-
-		if (column.default?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.value,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'changed') {
-			statements.push({
-				type: 'alter_table_alter_column_set_default',
-				tableName,
-				columnName,
-				newDefaultValue: column.default.new,
-				oldDefaultValue: column.default.old,
-				schema,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.default?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_default',
-				tableName,
-				columnName,
-				schema,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				newDataType: columnType,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'changed') {
-			const type = column.notNull.new
-				? 'alter_table_alter_column_set_notnull'
-				: 'alter_table_alter_column_drop_notnull';
-			statements.push({
-				type: type,
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.notNull?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_notnull',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.generated?.type === 'added') {
-			if (columnGenerated?.type === 'virtual') {
-				statements.push({
-					type: 'alter_table_alter_column_set_generated',
-					tableName,
-					columnName,
-					schema,
-					newDataType: columnType,
-					columnDefault,
-					columnOnUpdate,
-					columnNotNull,
-					columnAutoIncrement,
-					columnPk,
-					columnGenerated,
-				});
-			} else {
-				warning(
-					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
-				);
-			}
-		}
-
-		if (column.generated?.type === 'changed') {
-			if (columnGenerated?.type === 'virtual') {
-				statements.push({
-					type: 'alter_table_alter_column_alter_generated',
-					tableName,
-					columnName,
-					schema,
-					newDataType: columnType,
-					columnDefault,
-					columnOnUpdate,
-					columnNotNull,
-					columnAutoIncrement,
-					columnPk,
-					columnGenerated,
-				});
-			} else {
-				warning(
-					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
-				);
-			}
-		}
-
-		if (column.generated?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_generated',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-				columnGenerated,
-			});
-		}
-
-		if (
-			column.primaryKey?.type === 'added'
-			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
-		) {
-			const wasAutoincrement = statements.filter(
-				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
-			);
-			if (wasAutoincrement.length === 0) {
-				setPkStatements.push({
-					type: 'alter_table_alter_column_set_pk',
-					tableName,
-					schema,
-					columnName,
-				});
-			}
-		}
-
-		if (column.onUpdate?.type === 'added') {
-			statements.push({
-				type: 'alter_table_alter_column_set_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-
-		if (column.onUpdate?.type === 'deleted') {
-			statements.push({
-				type: 'alter_table_alter_column_drop_on_update',
-				tableName,
-				columnName,
-				schema,
-				newDataType: columnType,
-				columnDefault,
-				columnOnUpdate,
-				columnNotNull,
-				columnAutoIncrement,
-				columnPk,
-			});
-		}
-	}
-
-	return [...dropPkStatements, ...setPkStatements, ...statements];
-};
-
-export const prepareRenamePolicyJsons = (
-	tableName: string,
-	schema: string,
-	renames: {
-		from: Policy;
-		to: Policy;
-	}[],
-): JsonRenamePolicyStatement[] => {
-	return renames.map((it) => {
-		return {
-			type: 'rename_policy',
-			tableName: tableName,
-			oldName: it.from.name,
-			newName: it.to.name,
-			schema,
-		};
-	});
-};
-
-export const prepareRenameIndPolicyJsons = (
-	renames: {
-		from: Policy;
-		to: Policy;
-	}[],
-): JsonIndRenamePolicyStatement[] => {
-	return renames.map((it) => {
-		return {
-			type: 'rename_ind_policy',
-			tableKey: it.from.on!,
-			oldName: it.from.name,
-			newName: it.to.name,
-		};
-	});
-};
-
-export const prepareCreatePolicyJsons = (
-	tableName: string,
-	schema: string,
-	policies: Policy[],
-): JsonCreatePolicyStatement[] => {
-	return policies.map((it) => {
-		return {
-			type: 'create_policy',
-			tableName,
-			data: it,
-			schema,
-		};
-	});
-};
-
-export const prepareCreateIndPolicyJsons = (
-	policies: Policy[],
-): JsonCreateIndPolicyStatement[] => {
-	return policies.map((it) => {
-		return {
-			type: 'create_ind_policy',
-			tableName: it.on!,
-			data: it,
-		};
-	});
-};
-
-export const prepareDropPolicyJsons = (
-	tableName: string,
-	schema: string,
-	policies: Policy[],
-): JsonDropPolicyStatement[] => {
-	return policies.map((it) => {
-		return {
-			type: 'drop_policy',
-			tableName,
-			data: it,
-			schema,
-		};
-	});
-};
-
-export const prepareDropIndPolicyJsons = (
-	policies: Policy[],
-): JsonDropIndPolicyStatement[] => {
-	return policies.map((it) => {
-		return {
-			type: 'drop_ind_policy',
-			tableName: it.on!,
-			data: it,
-		};
-	});
-};
-
-export const prepareAlterPolicyJson = (
-	tableName: string,
-	schema: string,
-	oldPolicy: string,
-	newPolicy: string,
-): JsonAlterPolicyStatement => {
-	return {
-		type: 'alter_policy',
-		tableName,
-		oldData: oldPolicy,
-		newData: newPolicy,
-		schema,
-	};
-};
-
-export const prepareAlterIndPolicyJson = (
-	oldPolicy: Policy,
-	newPolicy: Policy,
-): JsonAlterIndPolicyStatement => {
-	return {
-		type: 'alter_ind_policy',
-		oldData: oldPolicy,
-		newData: newPolicy,
-	};
-};
-
-export const preparePgCreateIndexesJson = (
-	tableName: string,
-	schema: string,
-	indexes: Record<string, string>,
-	fullSchema: PgSchema,
-	action?: 'push' | undefined,
-): JsonPgCreateIndexStatement[] => {
-	if (action === 'push') {
-		return Object.values(indexes).map((indexData) => {
-			const unsquashedIndex = PgSquasher.unsquashIdxPush(indexData);
-			const data = fullSchema.tables[`${schema === '' ? 'public' : schema}.${tableName}`]
-				.indexes[unsquashedIndex.name];
-			return {
-				type: 'create_index_pg',
-				tableName,
-				data,
-				schema,
-			};
-		});
-	}
-	return Object.values(indexes).map((indexData) => {
-		return {
-			type: 'create_index_pg',
-			tableName,
-			data: PgSquasher.unsquashIdx(indexData),
-			schema,
-		};
-	});
-};
-
-export const prepareCreateIndexesJson = (
-	tableName: string,
-	schema: string,
-	indexes: Record<string, string>,
-	internal?: MySqlKitInternals | SQLiteKitInternals,
-): JsonCreateIndexStatement[] => {
-	return Object.values(indexes).map((indexData) => {
-		return {
-			type: 'create_index',
-			tableName,
-			data: indexData,
-			schema,
-			internal,
-		};
-	});
-};
-
-export const prepareCreateReferencesJson = (
-	tableName: string,
-	schema: string,
-	foreignKeys: Record<string, string>,
-): JsonCreateReferenceStatement[] => {
-	return Object.values(foreignKeys).map((fkData) => {
-		return {
-			type: 'create_reference',
-			tableName,
-			data: fkData,
-			schema,
-		};
-	});
-};
-export const prepareLibSQLCreateReferencesJson = (
-	tableName: string,
-	schema: string,
-	foreignKeys: Record<string, string>,
-	json2: SQLiteSchemaSquashed,
-	action?: 'push',
-): JsonCreateReferenceStatement[] => {
-	return Object.values(foreignKeys).map((fkData) => {
-		const { columnsFrom, tableFrom, columnsTo } = action === 'push'
-			? SQLiteSquasher.unsquashPushFK(fkData)
-			: SQLiteSquasher.unsquashFK(fkData);
-
-		// When trying to alter table in lib sql it is necessary to pass all config for column like "NOT NULL", "DEFAULT", etc.
-		// If it is multicolumn reference it is not possible to pass this data for all columns
-		// Pass multicolumn flag for sql statements to not generate migration
-		let isMulticolumn = false;
-
-		if (columnsFrom.length > 1 || columnsTo.length > 1) {
-			isMulticolumn = true;
-
-			return {
-				type: 'create_reference',
-				tableName,
-				data: fkData,
-				schema,
-				isMulticolumn,
-			};
-		}
-
-		const columnFrom = columnsFrom[0];
-
-		const {
-			notNull: columnNotNull,
-			default: columnDefault,
-			type: columnType,
-		} = json2.tables[tableFrom].columns[columnFrom];
-
-		return {
-			type: 'create_reference',
-			tableName,
-			data: fkData,
-			schema,
-			columnNotNull,
-			columnDefault,
-			columnType,
-		};
-	});
-};
-
-export const prepareDropReferencesJson = (
-	tableName: string,
-	schema: string,
-	foreignKeys: Record<string, string>,
-): JsonDeleteReferenceStatement[] => {
-	return Object.values(foreignKeys).map((fkData) => {
-		return {
-			type: 'delete_reference',
-			tableName,
-			data: fkData,
-			schema,
-		};
-	});
-};
-export const prepareLibSQLDropReferencesJson = (
-	tableName: string,
-	schema: string,
-	foreignKeys: Record<string, string>,
-	json2: SQLiteSchemaSquashed,
-	meta: SQLiteSchemaInternal['_meta'],
-	action?: 'push',
-): JsonDeleteReferenceStatement[] => {
-	const statements = Object.values(foreignKeys).map((fkData) => {
-		const { columnsFrom, tableFrom, columnsTo, name, tableTo, onDelete, onUpdate } = action === 'push'
-			? SQLiteSquasher.unsquashPushFK(fkData)
-			: SQLiteSquasher.unsquashFK(fkData);
-
-		// If all columns from where were references were deleted -> skip this logic
-		// Drop columns will cover this scenario
-		const keys = Object.keys(json2.tables[tableName].columns);
-		const filtered = columnsFrom.filter((it) => keys.includes(it));
-		const fullDrop = filtered.length === 0;
-		if (fullDrop) return;
-
-		// When trying to alter table in lib sql it is necessary to pass all config for column like "NOT NULL", "DEFAULT", etc.
-		// If it is multicolumn reference it is not possible to pass this data for all columns
-		// Pass multicolumn flag for sql statements to not generate migration
-		let isMulticolumn = false;
-
-		if (columnsFrom.length > 1 || columnsTo.length > 1) {
-			isMulticolumn = true;
-
-			return {
-				type: 'delete_reference',
-				tableName,
-				data: fkData,
-				schema,
-				isMulticolumn,
-			};
-		}
-
-		const columnFrom = columnsFrom[0];
-		const newTableName = getNewTableName(tableFrom, meta);
-
-		const {
-			notNull: columnNotNull,
-			default: columnDefault,
-			type: columnType,
-		} = json2.tables[newTableName].columns[columnFrom];
-
-		const fkToSquash = {
-			columnsFrom,
-			columnsTo,
-			name,
-			tableFrom: newTableName,
-			tableTo,
-			onDelete,
-			onUpdate,
-		};
-		const foreignKey = action === 'push'
-			? SQLiteSquasher.squashPushFK(fkToSquash)
-			: SQLiteSquasher.squashFK(fkToSquash);
-		return {
-			type: 'delete_reference',
-			tableName,
-			data: foreignKey,
-			schema,
-			columnNotNull,
-			columnDefault,
-			columnType,
-		};
-	});
-
-	return statements.filter((it) => it) as JsonDeleteReferenceStatement[];
-};
-
-// alter should create 2 statements. It's important to make only 1 sql per statement(for breakpoints)
-export const prepareAlterReferencesJson = (
-	tableName: string,
-	schema: string,
-	foreignKeys: Record<string, { __old: string; __new: string }>,
-): JsonReferenceStatement[] => {
-	const stmts: JsonReferenceStatement[] = [];
-	Object.values(foreignKeys).map((val) => {
-		stmts.push({
-			type: 'delete_reference',
-			tableName,
-			schema,
-			data: val.__old,
-		});
-
-		stmts.push({
-			type: 'create_reference',
-			tableName,
-			schema,
-			data: val.__new,
-		});
-	});
-	return stmts;
-};
-
-export const prepareDropIndexesJson = (
-	tableName: string,
-	schema: string,
-	indexes: Record<string, string>,
-): JsonDropIndexStatement[] => {
-	return Object.values(indexes).map((indexData) => {
-		return {
-			type: 'drop_index',
-			tableName,
-			data: indexData,
-			schema,
-		};
-	});
-};
-
-export const prepareAddCompositePrimaryKeySqlite = (
-	tableName: string,
-	pks: Record<string, string>,
-): JsonCreateCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'create_composite_pk',
-			tableName,
-			data: it,
-		} as JsonCreateCompositePK;
-	});
-};
-
-export const prepareDeleteCompositePrimaryKeySqlite = (
-	tableName: string,
-	pks: Record<string, string>,
-): JsonDeleteCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'delete_composite_pk',
-			tableName,
-			data: it,
-		} as JsonDeleteCompositePK;
-	});
-};
-
-export const prepareAlterCompositePrimaryKeySqlite = (
-	tableName: string,
-	pks: Record<string, { __old: string; __new: string }>,
-): JsonAlterCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'alter_composite_pk',
-			tableName,
-			old: it.__old,
-			new: it.__new,
-		} as JsonAlterCompositePK;
-	});
-};
-
-export const prepareAddCompositePrimaryKeyPg = (
-	tableName: string,
-	schema: string,
-	pks: Record<string, string>,
-	// TODO: remove?
-	json2: PgSchema,
-): JsonCreateCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		const unsquashed = PgSquasher.unsquashPK(it);
-		return {
-			type: 'create_composite_pk',
-			tableName,
-			data: it,
-			schema,
-			constraintName: PgSquasher.unsquashPK(it).name,
-		} as JsonCreateCompositePK;
-	});
-};
-
-export const prepareDeleteCompositePrimaryKeyPg = (
-	tableName: string,
-	schema: string,
-	pks: Record<string, string>,
-	// TODO: remove?
-	json1: PgSchema,
-): JsonDeleteCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'delete_composite_pk',
-			tableName,
-			data: it,
-			schema,
-			constraintName: PgSquasher.unsquashPK(it).name,
-		} as JsonDeleteCompositePK;
-	});
-};
-
-export const prepareAlterCompositePrimaryKeyPg = (
-	tableName: string,
-	schema: string,
-	pks: Record<string, { __old: string; __new: string }>,
-	// TODO: remove?
-	json1: PgSchema,
-	json2: PgSchema,
-): JsonAlterCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'alter_composite_pk',
-			tableName,
-			old: it.__old,
-			new: it.__new,
-			schema,
-			oldConstraintName: PgSquasher.unsquashPK(it.__old).name,
-			newConstraintName: PgSquasher.unsquashPK(it.__new).name,
-		} as JsonAlterCompositePK;
-	});
-};
-
-export const prepareAddUniqueConstraintPg = (
-	tableName: string,
-	schema: string,
-	unqs: Record<string, string>,
-): JsonCreateUniqueConstraint[] => {
-	return Object.values(unqs).map((it) => {
-		return {
-			type: 'create_unique_constraint',
-			tableName,
-			data: it,
-			schema,
-		} as JsonCreateUniqueConstraint;
-	});
-};
-
-export const prepareDeleteUniqueConstraintPg = (
-	tableName: string,
-	schema: string,
-	unqs: Record<string, string>,
-): JsonDeleteUniqueConstraint[] => {
-	return Object.values(unqs).map((it) => {
-		return {
-			type: 'delete_unique_constraint',
-			tableName,
-			data: it,
-			schema,
-		} as JsonDeleteUniqueConstraint;
-	});
-};
-
-export const prepareAddCheckConstraint = (
-	tableName: string,
-	schema: string,
-	check: Record<string, string>,
-): JsonCreateCheckConstraint[] => {
-	return Object.values(check).map((it) => {
-		return {
-			type: 'create_check_constraint',
-			tableName,
-			data: it,
-			schema,
-		} as JsonCreateCheckConstraint;
-	});
-};
-
-export const prepareDeleteCheckConstraint = (
-	tableName: string,
-	schema: string,
-	check: Record<string, string>,
-): JsonDeleteCheckConstraint[] => {
-	return Object.values(check).map((it) => {
-		return {
-			type: 'delete_check_constraint',
-			tableName,
-			constraintName: PgSquasher.unsquashCheck(it).name,
-			schema,
-		} as JsonDeleteCheckConstraint;
-	});
-};
-
-// add create table changes
-// add handler to make drop and add and not alter(looking at __old and __new)
-// add serializer for mysql and sqlite + types
-// add introspect serializer for pg+sqlite+mysql
-// add introspect actual code
-// add push sqlite handler
-// add push mysql warning if data exists and may have unique conflict
-// add release notes
-// add docs changes
-
-export const prepareAlterUniqueConstraintPg = (
-	tableName: string,
-	schema: string,
-	unqs: Record<string, { __old: string; __new: string }>,
-): JsonAlterUniqueConstraint[] => {
-	return Object.values(unqs).map((it) => {
-		return {
-			type: 'alter_unique_constraint',
-			tableName,
-			old: it.__old,
-			new: it.__new,
-			schema,
-		} as JsonAlterUniqueConstraint;
-	});
-};
-
-export const prepareAddCompositePrimaryKeyMySql = (
-	tableName: string,
-	pks: Record<string, string>,
-	// TODO: remove?
-	json1: MySqlSchema,
-	json2: MySqlSchema,
-): JsonCreateCompositePK[] => {
-	const res: JsonCreateCompositePK[] = [];
-	for (const it of Object.values(pks)) {
-		const unsquashed = MySqlSquasher.unsquashPK(it);
-
-		if (
-			unsquashed.columns.length === 1
-			&& json1.tables[tableName]?.columns[unsquashed.columns[0]]?.primaryKey
-		) {
-			continue;
-		}
-
-		res.push({
-			type: 'create_composite_pk',
-			tableName,
-			data: it,
-			constraintName: unsquashed.name,
-		} as JsonCreateCompositePK);
-	}
-	return res;
-};
-
-export const prepareDeleteCompositePrimaryKeyMySql = (
-	tableName: string,
-	pks: Record<string, string>,
-	// TODO: remove?
-	json1: MySqlSchema,
-): JsonDeleteCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		const unsquashed = MySqlSquasher.unsquashPK(it);
-		return {
-			type: 'delete_composite_pk',
-			tableName,
-			data: it,
-		} as JsonDeleteCompositePK;
-	});
-};
-
-export const prepareAlterCompositePrimaryKeyMySql = (
-	tableName: string,
-	pks: Record<string, { __old: string; __new: string }>,
-	// TODO: remove?
-	json1: MySqlSchema,
-	json2: MySqlSchema,
-): JsonAlterCompositePK[] => {
-	return Object.values(pks).map((it) => {
-		return {
-			type: 'alter_composite_pk',
-			tableName,
-			old: it.__old,
-			new: it.__new,
-			oldConstraintName: json1.tables[tableName].compositePrimaryKeys[
-				MySqlSquasher.unsquashPK(it.__old).name
-			].name,
-			newConstraintName: json2.tables[tableName].compositePrimaryKeys[
-				MySqlSquasher.unsquashPK(it.__new).name
-			].name,
-		} as JsonAlterCompositePK;
-	});
-};
-
-export const preparePgCreateViewJson = (
-	name: string,
-	schema: string,
-	definition: string,
-	materialized: boolean,
-	withNoData: boolean = false,
-	withOption?: any,
-	using?: string,
-	tablespace?: string,
-): JsonCreatePgViewStatement => {
-	return {
-		type: 'create_view',
-		name: name,
-		schema: schema,
-		definition: definition,
-		with: withOption,
-		materialized: materialized,
-		withNoData,
-		using,
-		tablespace,
-	};
-};
-
-export const prepareMySqlCreateViewJson = (
-	name: string,
-	definition: string,
-	meta: string,
-	replace: boolean = false,
-): JsonCreateMySqlViewStatement => {
-	const { algorithm, sqlSecurity, withCheckOption } = MySqlSquasher.unsquashView(meta);
-	return {
-		type: 'mysql_create_view',
-		name: name,
-		definition: definition,
-		algorithm,
-		sqlSecurity,
-		withCheckOption,
-		replace,
-	};
-};
-
-/* export const prepareSingleStoreCreateViewJson = (
-	name: string,
-	definition: string,
-	meta: string,
-	replace: boolean = false,
-): JsonCreateSingleStoreViewStatement => {
-	const { algorithm, sqlSecurity, withCheckOption } = SingleStoreSquasher.unsquashView(meta);
-	return {
-		type: 'singlestore_create_view',
-		name: name,
-		definition: definition,
-		algorithm,
-		sqlSecurity,
-		withCheckOption,
-		replace,
-	};
-}; */
-
-export const prepareSqliteCreateViewJson = (
-	name: string,
-	definition: string,
-): JsonCreateSqliteViewStatement => {
-	return {
-		type: 'sqlite_create_view',
-		name: name,
-		definition: definition,
-	};
-};
-
-export const prepareDropViewJson = (
-	name: string,
-	schema?: string,
-	materialized?: boolean,
-): JsonDropViewStatement => {
-	const resObject: JsonDropViewStatement = <JsonDropViewStatement> { name, type: 'drop_view' };
-
-	if (schema) resObject['schema'] = schema;
-
-	if (materialized) resObject['materialized'] = materialized;
-
-	return resObject;
-};
-
-export const prepareRenameViewJson = (
-	to: string,
-	from: string,
-	schema?: string,
-	materialized?: boolean,
-): JsonRenameViewStatement => {
-	const resObject: JsonRenameViewStatement = <JsonRenameViewStatement> {
-		type: 'rename_view',
-		nameTo: to,
-		nameFrom: from,
-	};
-
-	if (schema) resObject['schema'] = schema;
-	if (materialized) resObject['materialized'] = materialized;
-
-	return resObject;
-};
-
-export const preparePgAlterViewAlterSchemaJson = (
-	to: string,
-	from: string,
-	name: string,
-	materialized?: boolean,
-): JsonAlterViewAlterSchemaStatement => {
-	const returnObject: JsonAlterViewAlterSchemaStatement = {
-		type: 'alter_view_alter_schema',
-		fromSchema: from,
-		toSchema: to,
-		name,
-	};
-
-	if (materialized) returnObject['materialized'] = materialized;
-	return returnObject;
-};
-
-export const preparePgAlterViewAddWithOptionJson = (
-	name: string,
-	schema: string,
-	materialized: boolean,
-	withOption: MatViewWithOption | ViewWithOption,
-): JsonAlterViewAddWithOptionStatement => {
-	return {
-		type: 'alter_view_add_with_option',
-		name,
-		schema,
-		materialized: materialized,
-		with: withOption,
-	} as JsonAlterViewAddWithOptionStatement;
-};
-
-export const preparePgAlterViewDropWithOptionJson = (
-	name: string,
-	schema: string,
-	materialized: boolean,
-	withOption: MatViewWithOption | ViewWithOption,
-): JsonAlterViewDropWithOptionStatement => {
-	return {
-		type: 'alter_view_drop_with_option',
-		name,
-		schema,
-		materialized: materialized,
-		with: withOption,
-	} as JsonAlterViewDropWithOptionStatement;
-};
-
-export const preparePgAlterViewAlterTablespaceJson = (
-	name: string,
-	schema: string,
-	materialized: boolean,
-	to: string,
-): JsonAlterViewAlterTablespaceStatement => {
-	return {
-		type: 'alter_view_alter_tablespace',
-		name,
-		schema,
-		materialized: materialized,
-		toTablespace: to,
-	} as JsonAlterViewAlterTablespaceStatement;
-};
-
-export const preparePgAlterViewAlterUsingJson = (
-	name: string,
-	schema: string,
-	materialized: boolean,
-	to: string,
-): JsonAlterViewAlterUsingStatement => {
-	return {
-		type: 'alter_view_alter_using',
-		name,
-		schema,
-		materialized: materialized,
-		toUsing: to,
-	} as JsonAlterViewAlterUsingStatement;
-};
-
-export const prepareMySqlAlterView = (
-	view: Omit<MySqlView, 'isExisting'>,
-): JsonAlterMySqlViewStatement => {
-	return { type: 'alter_mysql_view', ...view };
-};
-
-/* export const prepareSingleStoreAlterView = (
-	view: Omit<SingleStoreView, 'isExisting'>,
-): JsonAlterSingleStoreViewStatement => {
-	return { type: 'alter_singlestore_view', ...view };
-}; */
diff --git a/drizzle-kit/src/legacy/common.ts b/drizzle-kit/src/legacy/common.ts
new file mode 100644
index 0000000000..0aa87d9e08
--- /dev/null
+++ b/drizzle-kit/src/legacy/common.ts
@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import type { UnionToIntersection } from 'hono/utils/types';
+import type { TypeOf } from 'zod';
+import { any, boolean, enum as enum_, literal, object, string, union } from 'zod';
+import { outputs } from './outputs';
+import { dialect } from './schemaValidator';
+
+export type Commands =
+	| 'introspect'
+	| 'generate'
+	| 'check'
+	| 'up'
+	| 'drop'
+	| 'push'
+	| 'export';
+
+// type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+type LastTupleElement<TArr extends any[]> = TArr extends [
+	...start: infer _,
+	end: infer Last,
+] ? Last
+	: never;
+
+export type UniqueArrayOfUnion<TUnion, TArray extends TUnion[]> = Exclude<
+	TUnion,
+	TArray[number]
+> extends never ? [TUnion]
+	: [...TArray, Exclude<TUnion, TArray[number]>];
+
+export const assertCollisions = <
+	T extends Record<string, unknown>,
+	TKeys extends (keyof T)[],
+	TRemainingKeys extends Exclude<keyof T, TKeys[number] | 'config'>[],
+	Exhaustive extends TRemainingKeys,
+	UNIQ extends UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
+>(
+	command: Commands,
+	options: T,
+	whitelist: Exclude<TKeys, 'config'>,
+	_remainingKeys: UniqueArrayOfUnion<TRemainingKeys[number], Exhaustive>,
+): IsUnion<LastTupleElement<UNIQ>> extends false ? 'cli' | 'config' : TKeys => {
+	const { config, ...rest } = options;
+
+	let atLeastOneParam = false;
+	for (const key of Object.keys(rest)) {
+		if (whitelist.includes(key)) continue;
+
+		atLeastOneParam = atLeastOneParam || rest[key] !== undefined;
+	}
+
+	if (!config && atLeastOneParam) {
+		return 'cli' as any;
+	}
+
+	if (!atLeastOneParam) {
+		return 'config' as any;
+	}
+
+	// if config and cli - return error - write a reason
+	console.log(outputs.common.ambiguousParams(command));
+	process.exit(1);
+};
+
+export const sqliteDriversLiterals = [
+	literal('d1-http'),
+	literal('expo'),
+	literal('durable-sqlite'),
+] as const;
+
+export const postgresqlDriversLiterals = [
+	literal('aws-data-api'),
+	literal('pglite'),
+] as const;
+
+export const prefixes = [
+	'index',
+	'timestamp',
+	'supabase',
+	'unix',
+	'none',
+] as const;
+export const prefix = enum_(prefixes);
+export type Prefix = (typeof prefixes)[number];
+
+{
+	const _: Prefix = '' as TypeOf<typeof prefix>;
+}
+
+export const casingTypes = ['snake_case', 'camelCase'] as const;
+export const casingType = enum_(casingTypes);
+export type CasingType = (typeof casingTypes)[number];
+
+export const sqliteDriver = union(sqliteDriversLiterals);
+export const postgresDriver = union(postgresqlDriversLiterals);
+export const driver = union([sqliteDriver, postgresDriver]);
+
+export const configMigrations = object({
+	table: string().optional(),
+	schema: string().optional(),
+	prefix: prefix.optional().default('index'),
+}).optional();
+
+export const configCommonSchema = object({
+	dialect: dialect,
+	schema: union([string(), string().array()]).optional(),
+	out: string().optional(),
+	breakpoints: boolean().optional().default(true),
+	verbose: boolean().optional().default(false),
+	driver: driver.optional(),
+	tablesFilter: union([string(), string().array()]).optional(),
+	schemaFilter: union([string(), string().array()]).default(['public']),
+	migrations: configMigrations,
+	dbCredentials: any().optional(),
+	casing: casingType.optional(),
+	sql: boolean().default(true),
+}).passthrough();
+
+export const casing = union([literal('camel'), literal('preserve')]).default(
+	'camel',
+);
+
+export const introspectParams = object({
+	schema: union([string(), string().array()]).optional(),
+	out: string().optional().default('./drizzle'),
+	breakpoints: boolean().default(true),
+	tablesFilter: union([string(), string().array()]).optional(),
+	schemaFilter: union([string(), string().array()]).default(['public']),
+	introspect: object({
+		casing,
+	}).default({ casing: 'camel' }),
+});
+
+export type IntrospectParams = TypeOf<typeof introspectParams>;
+export type Casing = TypeOf<typeof casing>;
+
+export const configIntrospectCliSchema = object({
+	schema: union([string(), string().array()]).optional(),
+	out: string().optional().default('./drizzle'),
+	breakpoints: boolean().default(true),
+	tablesFilter: union([string(), string().array()]).optional(),
+	schemaFilter: union([string(), string().array()]).default(['public']),
+	introspectCasing: union([literal('camel'), literal('preserve')]).default(
+		'camel',
+	),
+});
+
+export const configGenerateSchema = object({
+	schema: union([string(), string().array()]),
+	out: string().optional().default('./drizzle'),
+	breakpoints: boolean().default(true),
+});
+
+export type GenerateSchema = TypeOf<typeof configGenerateSchema>;
+
+export const configPushSchema = object({
+	dialect: dialect,
+	schema: union([string(), string().array()]),
+	tablesFilter: union([string(), string().array()]).optional(),
+	schemaFilter: union([string(), string().array()]).default(['public']),
+	verbose: boolean().default(false),
+	strict: boolean().default(false),
+	out: string().optional(),
+});
+
+export type CliConfig = TypeOf<typeof configCommonSchema>;
+export const drivers = ['d1-http', 'expo', 'aws-data-api', 'pglite', 'durable-sqlite'] as const;
+export type Driver = (typeof drivers)[number];
+const _: Driver = '' as TypeOf<typeof driver>;
+
+export const wrapParam = (
+	name: string,
+	param: any | undefined,
+	optional: boolean = false,
+	type?: 'url' | 'secret',
+) => {
+	const check = `[${chalk.green('✓')}]`;
+	const cross = `[${chalk.red('x')}]`;
+	if (typeof param === 'string') {
+		if (param.length === 0) {
+			return `    ${cross} ${name}: ''`;
+		}
+		if (type === 'secret') {
+			return `    ${check} ${name}: '*****'`;
+		} else if (type === 'url') {
+			return `    ${check} ${name}: '${param.replace(/(?<=:\/\/[^:\n]*:)([^@]*)/, '****')}'`;
+		}
+		return `    ${check} ${name}: '${param}'`;
+	}
+	if (optional) {
+		return chalk.gray(`        ${name}?: `);
+	}
+	return `    ${cross} ${name}: ${chalk.gray('undefined')}`;
+};
diff --git a/drizzle-kit/src/global.ts b/drizzle-kit/src/legacy/global.ts
similarity index 92%
rename from drizzle-kit/src/global.ts
rename to drizzle-kit/src/legacy/global.ts
index 4cea3d15ea..d7b6f1d5af 100644
--- a/drizzle-kit/src/global.ts
+++ b/drizzle-kit/src/legacy/global.ts
@@ -1,12 +1,12 @@
 export const originUUID = '00000000-0000-0000-0000-000000000000';
 export const snapshotVersion = '7';
 
-export function assertUnreachable(x: never | undefined): never {
+export function assertUnreachable(_x: never | undefined): never {
 	throw new Error("Didn't expect to get here");
 }
 
 // don't fail in runtime, types only
-export function softAssertUnreachable(x: never) {
+export function softAssertUnreachable(_x: never) {
 	return null as never;
 }
 
diff --git a/drizzle-kit/src/jsonDiffer.js b/drizzle-kit/src/legacy/jsonDiffer.js
similarity index 100%
rename from drizzle-kit/src/jsonDiffer.js
rename to drizzle-kit/src/legacy/jsonDiffer.js
diff --git a/drizzle-kit/src/legacy/jsonStatements.ts b/drizzle-kit/src/legacy/jsonStatements.ts
new file mode 100644
index 0000000000..9a3af0d1b0
--- /dev/null
+++ b/drizzle-kit/src/legacy/jsonStatements.ts
@@ -0,0 +1,2702 @@
+import type { MySqlView } from 'drizzle-orm/mysql-core/view';
+import { warning } from '../cli/views';
+import type { MySqlSchema } from './mysql-v5/mysqlSchema';
+import { MySqlSquasher } from './mysql-v5/mysqlSchema';
+import type {
+	Index,
+	MatViewWithOption,
+	PgSchema,
+	PgSchemaSquashed,
+	Policy,
+	Role,
+	View as PgView,
+	ViewWithOption,
+} from './postgres-v7/pgSchema';
+import { PgSquasher } from './postgres-v7/pgSchema';
+import type { CommonSquashedSchema } from './schemaValidator';
+import type { AlteredColumn, Column, Sequence, Table } from './snapshotsDiffer';
+import {
+	type SQLiteKitInternals,
+	type SQLiteSchemaSquashed,
+	SQLiteSquasher,
+	type View as SqliteView,
+} from './sqlite-v6/sqliteSchema';
+
+export interface JsonCreateTableStatement {
+	type: 'create_table';
+	tableName: string;
+	schema: string;
+	columns: Column[];
+	compositePKs: string[];
+	compositePkName?: string;
+	uniqueConstraints?: string[];
+	policies?: string[];
+	checkConstraints?: string[];
+	isRLSEnabled?: boolean;
+}
+
+export interface JsonRecreateTableStatement {
+	type: 'recreate_table';
+	tableName: string;
+	columns: Column[];
+	referenceData: {
+		name: string;
+		tableFrom: string;
+		columnsFrom: string[];
+		tableTo: string;
+		columnsTo: string[];
+		onUpdate?: string | undefined;
+		onDelete?: string | undefined;
+	}[];
+	compositePKs: string[][];
+	uniqueConstraints?: string[];
+	checkConstraints: string[];
+}
+
+export interface JsonDropTableStatement {
+	type: 'drop_table';
+	tableName: string;
+	schema: string;
+	policies?: string[];
+}
+
+export interface JsonRenameTableStatement {
+	type: 'rename_table';
+	fromSchema: string;
+	toSchema: string;
+	tableNameFrom: string;
+	tableNameTo: string;
+}
+
+export interface JsonCreateEnumStatement {
+	type: 'create_type_enum';
+	name: string;
+	schema: string;
+	values: string[];
+}
+
+export interface JsonDropEnumStatement {
+	type: 'drop_type_enum';
+	name: string;
+	schema: string;
+}
+
+export interface JsonMoveEnumStatement {
+	type: 'move_type_enum';
+	name: string;
+	schemaFrom: string;
+	schemaTo: string;
+}
+
+export interface JsonRenameEnumStatement {
+	type: 'rename_type_enum';
+	nameFrom: string;
+	nameTo: string;
+	schema: string;
+}
+
+export interface JsonAddValueToEnumStatement {
+	type: 'alter_type_add_value';
+	name: string;
+	schema: string;
+	value: string;
+	before: string;
+}
+
+//////
+
+export interface JsonCreateRoleStatement {
+	type: 'create_role';
+	name: string;
+	values: {
+		inherit?: boolean;
+		createDb?: boolean;
+		createRole?: boolean;
+	};
+}
+
+export interface JsonDropRoleStatement {
+	type: 'drop_role';
+	name: string;
+}
+export interface JsonRenameRoleStatement {
+	type: 'rename_role';
+	nameFrom: string;
+	nameTo: string;
+}
+
+export interface JsonAlterRoleStatement {
+	type: 'alter_role';
+	name: string;
+	values: {
+		inherit?: boolean;
+		createDb?: boolean;
+		createRole?: boolean;
+	};
+}
+
+//////
+
+export interface JsonDropValueFromEnumStatement {
+	type: 'alter_type_drop_value';
+	name: string;
+	enumSchema: string;
+	deletedValues: string[];
+	newValues: string[];
+	columnsWithEnum: { tableSchema: string; table: string; column: string; default?: string; columnType: string }[];
+}
+
+export interface JsonCreateSequenceStatement {
+	type: 'create_sequence';
+	name: string;
+	schema: string;
+	values: {
+		increment?: string | undefined;
+		minValue?: string | undefined;
+		maxValue?: string | undefined;
+		startWith?: string | undefined;
+		cache?: string | undefined;
+		cycle?: boolean | undefined;
+	};
+}
+
+export interface JsonDropSequenceStatement {
+	type: 'drop_sequence';
+	name: string;
+	schema: string;
+}
+
+export interface JsonMoveSequenceStatement {
+	type: 'move_sequence';
+	name: string;
+	schemaFrom: string;
+	schemaTo: string;
+}
+
+export interface JsonRenameSequenceStatement {
+	type: 'rename_sequence';
+	nameFrom: string;
+	nameTo: string;
+	schema: string;
+}
+
+export interface JsonAlterSequenceStatement {
+	type: 'alter_sequence';
+	name: string;
+	schema: string;
+	values: {
+		increment?: string | undefined;
+		minValue?: string | undefined;
+		maxValue?: string | undefined;
+		startWith?: string | undefined;
+		cache?: string | undefined;
+		cycle?: boolean | undefined;
+	};
+}
+
+export interface JsonDropColumnStatement {
+	type: 'alter_table_drop_column';
+	tableName: string;
+	columnName: string;
+	schema: string;
+}
+
+export interface JsonAddColumnStatement {
+	type: 'alter_table_add_column';
+	tableName: string;
+	column: Column;
+	schema: string;
+}
+
+export interface JsonCreatePolicyStatement {
+	type: 'create_policy';
+	tableName: string;
+	data: Policy;
+	schema: string;
+}
+
+export interface JsonCreateIndPolicyStatement {
+	type: 'create_ind_policy';
+	tableName: string;
+	data: Policy;
+}
+
+export interface JsonDropPolicyStatement {
+	type: 'drop_policy';
+	tableName: string;
+	data: Policy;
+	schema: string;
+}
+
+export interface JsonDropIndPolicyStatement {
+	type: 'drop_ind_policy';
+	tableName: string;
+	data: Policy;
+}
+
+export interface JsonRenamePolicyStatement {
+	type: 'rename_policy';
+	tableName: string;
+	oldName: string;
+	newName: string;
+	schema: string;
+}
+
+export interface JsonIndRenamePolicyStatement {
+	type: 'rename_ind_policy';
+	tableKey: string;
+	oldName: string;
+	newName: string;
+}
+
+export interface JsonEnableRLSStatement {
+	type: 'enable_rls';
+	tableName: string;
+	schema: string;
+}
+
+export interface JsonDisableRLSStatement {
+	type: 'disable_rls';
+	tableName: string;
+	schema: string;
+}
+
+export interface JsonAlterPolicyStatement {
+	type: 'alter_policy';
+	tableName: string;
+	oldData: string;
+	newData: string;
+	schema: string;
+}
+
+export interface JsonAlterIndPolicyStatement {
+	type: 'alter_ind_policy';
+	oldData: Policy;
+	newData: Policy;
+}
+
+export interface JsonCreateIndexStatement {
+	type: 'create_index';
+	tableName: string;
+	data: string;
+	schema: string;
+	internal?: SQLiteKitInternals;
+}
+
+export interface JsonPgCreateIndexStatement {
+	type: 'create_index_pg';
+	tableName: string;
+	data: Index;
+	schema: string;
+}
+
+export interface JsonReferenceStatement {
+	type: 'create_reference' | 'alter_reference' | 'delete_reference';
+	data: string;
+	schema: string;
+	tableName: string;
+	isMulticolumn?: boolean;
+	columnNotNull?: boolean;
+	columnDefault?: string;
+	columnType?: string;
+	//   fromTable: string;
+	//   fromColumns: string[];
+	//   toTable: string;
+	//   toColumns: string[];
+	//   foreignKeyName: string;
+	//   onDelete?: string;
+	//   onUpdate?: string;
+}
+
+export interface JsonCreateUniqueConstraint {
+	type: 'create_unique_constraint';
+	tableName: string;
+	data: string;
+	schema?: string;
+	constraintName?: string;
+}
+
+export interface JsonDeleteUniqueConstraint {
+	type: 'delete_unique_constraint';
+	tableName: string;
+	data: string;
+	schema?: string;
+	constraintName?: string;
+}
+
+export type JsonAlterMySqlViewStatement = {
+	type: 'alter_mysql_view';
+} & Omit<MySqlView, 'isExisting'>;
+
+export interface JsonAlterUniqueConstraint {
+	type: 'alter_unique_constraint';
+	tableName: string;
+	old: string;
+	new: string;
+	schema?: string;
+	oldConstraintName?: string;
+	newConstraintName?: string;
+}
+
+export interface JsonCreateCheckConstraint {
+	type: 'create_check_constraint';
+	tableName: string;
+	data: string;
+	schema?: string;
+}
+
+export interface JsonDeleteCheckConstraint {
+	type: 'delete_check_constraint';
+	tableName: string;
+	constraintName: string;
+	schema?: string;
+}
+
+export interface JsonCreateCompositePK {
+	type: 'create_composite_pk';
+	tableName: string;
+	data: string;
+	schema?: string;
+	constraintName?: string;
+}
+
+export interface JsonDeleteCompositePK {
+	type: 'delete_composite_pk';
+	tableName: string;
+	data: string;
+	schema?: string;
+	constraintName?: string;
+}
+
+export interface JsonAlterCompositePK {
+	type: 'alter_composite_pk';
+	tableName: string;
+	old: string;
+	new: string;
+	schema?: string;
+	oldConstraintName?: string;
+	newConstraintName?: string;
+}
+
+export interface JsonAlterTableSetSchema {
+	type: 'alter_table_set_schema';
+	tableName: string;
+	schemaFrom: string;
+	schemaTo: string;
+}
+
+export interface JsonAlterTableRemoveFromSchema {
+	type: 'alter_table_remove_from_schema';
+	tableName: string;
+	schema: string;
+}
+
+export interface JsonAlterTableSetNewSchema {
+	type: 'alter_table_set_new_schema';
+	tableName: string;
+	from: string;
+	to: string;
+}
+
+export type JsonCreateMySqlViewStatement = {
+	type: 'mysql_create_view';
+	replace: boolean;
+	name: string;
+	definition: string;
+	algorithm: 'undefined' | 'merge' | 'temptable';
+	sqlSecurity: 'definer' | 'invoker';
+	withCheckOption: 'local' | 'cascaded' | undefined;
+};
+
+export interface JsonCreateReferenceStatement extends JsonReferenceStatement {
+	type: 'create_reference';
+}
+
+export interface JsonAlterReferenceStatement extends JsonReferenceStatement {
+	type: 'alter_reference';
+	oldFkey: string;
+}
+
+export interface JsonDeleteReferenceStatement extends JsonReferenceStatement {
+	type: 'delete_reference';
+}
+
+export interface JsonDropIndexStatement {
+	type: 'drop_index';
+	tableName: string;
+	data: string;
+	schema: string;
+}
+
+export interface JsonRenameColumnStatement {
+	type: 'alter_table_rename_column';
+	tableName: string;
+	oldColumnName: string;
+	newColumnName: string;
+	schema: string;
+}
+
+export interface JsonAlterColumnTypeStatement {
+	type: 'alter_table_alter_column_set_type';
+	tableName: string;
+	columnName: string;
+	newDataType: string;
+	oldDataType: string;
+	schema: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
+}
+
+export interface JsonAlterColumnPgTypeStatement {
+	type: 'pg_alter_table_alter_column_set_type';
+	tableName: string;
+	columnName: string;
+	typeSchema: string | undefined;
+	newDataType: { name: string; isEnum: boolean };
+	oldDataType: { name: string; isEnum: boolean };
+	schema: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
+}
+
+export interface JsonAlterColumnSetPrimaryKeyStatement {
+	type: 'alter_table_alter_column_set_pk';
+	tableName: string;
+	schema: string;
+	columnName: string;
+}
+
+export interface JsonAlterColumnDropPrimaryKeyStatement {
+	type: 'alter_table_alter_column_drop_pk';
+	tableName: string;
+	columnName: string;
+	schema: string;
+}
+
+export interface JsonAlterColumnSetDefaultStatement {
+	type: 'alter_table_alter_column_set_default';
+	tableName: string;
+	columnName: string;
+	newDefaultValue: any;
+	oldDefaultValue?: any;
+	schema: string;
+	newDataType: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnDropDefaultStatement {
+	type: 'alter_table_alter_column_drop_default';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnSetNotNullStatement {
+	type: 'alter_table_alter_column_set_notnull';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnDropNotNullStatement {
+	type: 'alter_table_alter_column_drop_notnull';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnSetGeneratedStatement {
+	type: 'alter_table_alter_column_set_generated';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
+}
+export interface JsonAlterColumnSetIdentityStatement {
+	type: 'alter_table_alter_column_set_identity';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	identity: string;
+}
+
+export interface JsonAlterColumnDropIdentityStatement {
+	type: 'alter_table_alter_column_drop_identity';
+	tableName: string;
+	columnName: string;
+	schema: string;
+}
+
+export interface JsonAlterColumnAlterIdentityStatement {
+	type: 'alter_table_alter_column_change_identity';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	identity: string;
+	oldIdentity: string;
+}
+
+export interface JsonAlterColumnDropGeneratedStatement {
+	type: 'alter_table_alter_column_drop_generated';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
+	oldColumn?: Column;
+}
+
+export interface JsonAlterColumnAlterGeneratedStatement {
+	type: 'alter_table_alter_column_alter_generated';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+	columnGenerated?: { as: string; type: 'stored' | 'virtual' };
+}
+
+export interface JsonAlterColumnSetOnUpdateStatement {
+	type: 'alter_table_alter_column_set_on_update';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnDropOnUpdateStatement {
+	type: 'alter_table_alter_column_drop_on_update';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnSetAutoincrementStatement {
+	type: 'alter_table_alter_column_set_autoincrement';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonAlterColumnDropAutoincrementStatement {
+	type: 'alter_table_alter_column_drop_autoincrement';
+	tableName: string;
+	columnName: string;
+	schema: string;
+	newDataType: string;
+	columnDefault: string;
+	columnOnUpdate: boolean;
+	columnNotNull: boolean;
+	columnAutoIncrement: boolean;
+	columnPk: boolean;
+}
+
+export interface JsonCreateSchema {
+	type: 'create_schema';
+	name: string;
+}
+
+export interface JsonDropSchema {
+	type: 'drop_schema';
+	name: string;
+}
+
+export interface JsonRenameSchema {
+	type: 'rename_schema';
+	from: string;
+	to: string;
+}
+
+export type JsonCreatePgViewStatement = {
+	type: 'create_view';
+} & Omit<PgView, 'columns' | 'isExisting'>;
+
+/* export type JsonCreateSingleStoreViewStatement = {
+	type: 'singlestore_create_view';
+	replace: boolean;
+} & Omit<SingleStoreView, 'columns' | 'isExisting'>; */
+
+export interface JsonDropViewStatement {
+	type: 'drop_view';
+	name: string;
+	schema?: string;
+	materialized?: boolean;
+}
+
+export interface JsonRenameViewStatement {
+	type: 'rename_view';
+	nameTo: string;
+	nameFrom: string;
+	schema: string;
+	materialized?: boolean;
+}
+
+export interface JsonRenameMySqlViewStatement {
+	type: 'rename_view';
+	nameTo: string;
+	nameFrom: string;
+	schema: string;
+	materialized?: boolean;
+}
+
+export interface JsonAlterViewAlterSchemaStatement {
+	type: 'alter_view_alter_schema';
+	fromSchema: string;
+	toSchema: string;
+	name: string;
+	materialized?: boolean;
+}
+
+export type JsonAlterViewAddWithOptionStatement =
+	& {
+		type: 'alter_view_add_with_option';
+		schema: string;
+		name: string;
+	}
+	& ({
+		materialized: true;
+		with: MatViewWithOption;
+	} | {
+		materialized: false;
+		with: ViewWithOption;
+	});
+
+export type JsonAlterViewDropWithOptionStatement =
+	& {
+		type: 'alter_view_drop_with_option';
+		schema: string;
+		name: string;
+	}
+	& ({
+		materialized: true;
+		with: MatViewWithOption;
+	} | {
+		materialized: false;
+		with: ViewWithOption;
+	});
+
+export interface JsonAlterViewAlterTablespaceStatement {
+	type: 'alter_view_alter_tablespace';
+	toTablespace: string;
+	name: string;
+	schema: string;
+	materialized: true;
+}
+
+export interface JsonAlterViewAlterUsingStatement {
+	type: 'alter_view_alter_using';
+	toUsing: string;
+	name: string;
+	schema: string;
+	materialized: true;
+}
+
+/* export type JsonAlterSingleStoreViewStatement = {
+	type: 'alter_singlestore_view';
+} & Omit<SingleStoreView, 'isExisting'>; */
+
+export type JsonCreateSqliteViewStatement = {
+	type: 'sqlite_create_view';
+} & Omit<SqliteView, 'columns' | 'isExisting'>;
+
+export interface JsonSqliteCreateTableStatement {
+	type: 'sqlite_create_table';
+	tableName: string;
+	columns: Column[];
+	referenceData: {
+		name: string;
+		tableFrom: string;
+		columnsFrom: string[];
+		tableTo: string;
+		columnsTo: string[];
+		onUpdate?: string | undefined;
+		onDelete?: string | undefined;
+	}[];
+	compositePKs: string[][];
+	uniqueConstraints?: string[];
+	checkConstraints?: string[];
+}
+
+export interface JsonSqliteAddColumnStatement {
+	type: 'sqlite_alter_table_add_column';
+	tableName: string;
+	column: Column;
+	referenceData?: string;
+}
+
+export type JsonAlterViewStatement =
+	| JsonAlterViewAlterSchemaStatement
+	| JsonAlterViewAddWithOptionStatement
+	| JsonAlterViewDropWithOptionStatement
+	| JsonAlterViewAlterTablespaceStatement
+	| JsonAlterViewAlterUsingStatement;
+
+export type JsonAlterColumnStatement =
+	| JsonRenameColumnStatement
+	| JsonAlterColumnTypeStatement
+	| JsonAlterColumnPgTypeStatement
+	| JsonAlterColumnSetDefaultStatement
+	| JsonAlterColumnDropDefaultStatement
+	| JsonAlterColumnSetNotNullStatement
+	| JsonAlterColumnDropNotNullStatement
+	| JsonAlterColumnDropOnUpdateStatement
+	| JsonAlterColumnSetOnUpdateStatement
+	| JsonAlterColumnDropAutoincrementStatement
+	| JsonAlterColumnSetAutoincrementStatement
+	| JsonAlterColumnSetPrimaryKeyStatement
+	| JsonAlterColumnDropPrimaryKeyStatement
+	| JsonAlterColumnSetGeneratedStatement
+	| JsonAlterColumnDropGeneratedStatement
+	| JsonAlterColumnAlterGeneratedStatement
+	| JsonAlterColumnSetIdentityStatement
+	| JsonAlterColumnAlterIdentityStatement
+	| JsonAlterColumnDropIdentityStatement;
+
+export type JsonStatement =
+	| JsonRecreateTableStatement
+	| JsonAlterColumnStatement
+	| JsonCreateTableStatement
+	| JsonDropTableStatement
+	| JsonRenameTableStatement
+	| JsonCreateEnumStatement
+	| JsonDropEnumStatement
+	| JsonMoveEnumStatement
+	| JsonRenameEnumStatement
+	| JsonAddValueToEnumStatement
+	| JsonDropColumnStatement
+	| JsonAddColumnStatement
+	| JsonCreateIndexStatement
+	| JsonCreateReferenceStatement
+	| JsonAlterReferenceStatement
+	| JsonDeleteReferenceStatement
+	| JsonDropIndexStatement
+	| JsonReferenceStatement
+	| JsonSqliteCreateTableStatement
+	| JsonSqliteAddColumnStatement
+	| JsonCreateCompositePK
+	| JsonDeleteCompositePK
+	| JsonAlterCompositePK
+	| JsonCreateUniqueConstraint
+	| JsonDeleteUniqueConstraint
+	| JsonAlterUniqueConstraint
+	| JsonCreateSchema
+	| JsonDropSchema
+	| JsonRenameSchema
+	| JsonAlterTableSetSchema
+	| JsonAlterTableRemoveFromSchema
+	| JsonAlterTableSetNewSchema
+	| JsonPgCreateIndexStatement
+	| JsonAlterSequenceStatement
+	| JsonDropSequenceStatement
+	| JsonCreateSequenceStatement
+	| JsonMoveSequenceStatement
+	| JsonRenameSequenceStatement
+	| JsonDropPolicyStatement
+	| JsonCreatePolicyStatement
+	| JsonAlterPolicyStatement
+	| JsonRenamePolicyStatement
+	| JsonEnableRLSStatement
+	| JsonDisableRLSStatement
+	| JsonRenameRoleStatement
+	| JsonCreateRoleStatement
+	| JsonDropRoleStatement
+	| JsonAlterRoleStatement
+	| JsonCreatePgViewStatement
+	| JsonDropViewStatement
+	| JsonRenameViewStatement
+	| JsonAlterViewStatement
+	| JsonCreateMySqlViewStatement
+	| JsonAlterMySqlViewStatement
+	/* | JsonCreateSingleStoreViewStatement
+	| JsonAlterSingleStoreViewStatement */
+	| JsonCreateSqliteViewStatement
+	| JsonCreateCheckConstraint
+	| JsonDeleteCheckConstraint
+	| JsonDropValueFromEnumStatement
+	| JsonIndRenamePolicyStatement
+	| JsonDropIndPolicyStatement
+	| JsonCreateIndPolicyStatement
+	| JsonAlterIndPolicyStatement;
+
+export const preparePgCreateTableJson = (
+	table: Table,
+	json2: PgSchema,
+): JsonCreateTableStatement => {
+	const { name, schema, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints, policies, isRLSEnabled } =
+		table;
+	const tableKey = `${schema || 'public'}.${name}`;
+
+	const compositePkName = Object.values(compositePrimaryKeys).length > 0
+		? json2.tables[tableKey].compositePrimaryKeys[
+			`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`
+		].name
+		: '';
+
+	return {
+		type: 'create_table',
+		tableName: name,
+		schema,
+		columns: Object.values(columns),
+		compositePKs: Object.values(compositePrimaryKeys),
+		compositePkName: compositePkName,
+		uniqueConstraints: Object.values(uniqueConstraints),
+		policies: Object.values(policies),
+		checkConstraints: Object.values(checkConstraints),
+		isRLSEnabled: isRLSEnabled ?? false,
+	};
+};
+
+export const prepareDropTableJson = (table: Table): JsonDropTableStatement => {
+	return {
+		type: 'drop_table',
+		tableName: table.name,
+		schema: table.schema,
+		policies: table.policies ? Object.values(table.policies) : [],
+	};
+};
+
+export const prepareRenameTableJson = (
+	tableFrom: Table,
+	tableTo: Table,
+): JsonRenameTableStatement => {
+	return {
+		type: 'rename_table',
+		fromSchema: tableTo.schema,
+		toSchema: tableTo.schema,
+		tableNameFrom: tableFrom.name,
+		tableNameTo: tableTo.name,
+	};
+};
+
+export const prepareCreateEnumJson = (
+	name: string,
+	schema: string,
+	values: string[],
+): JsonCreateEnumStatement => {
+	return {
+		type: 'create_type_enum',
+		name: name,
+		schema: schema,
+		values,
+	};
+};
+
+// https://blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
+export const prepareAddValuesToEnumJson = (
+	name: string,
+	schema: string,
+	values: { value: string; before: string }[],
+): JsonAddValueToEnumStatement[] => {
+	return values.map((it) => {
+		return {
+			type: 'alter_type_add_value',
+			name: name,
+			schema: schema,
+			value: it.value,
+			before: it.before,
+		};
+	});
+};
+
+export const prepareDropEnumValues = (
+	name: string,
+	schema: string,
+	removedValues: string[],
+	json2: PgSchema,
+): JsonDropValueFromEnumStatement[] => {
+	if (!removedValues.length) return [];
+
+	const affectedColumns: JsonDropValueFromEnumStatement['columnsWithEnum'] = [];
+
+	for (const tableKey in json2.tables) {
+		const table = json2.tables[tableKey];
+		for (const columnKey in table.columns) {
+			const column = table.columns[columnKey];
+
+			const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+			const parsedColumnType = column.type.replace(arrayDefinitionRegex, '');
+
+			if (parsedColumnType === name && column.typeSchema === schema) {
+				affectedColumns.push({
+					tableSchema: table.schema,
+					table: table.name,
+					column: column.name,
+					columnType: column.type,
+					default: column.default,
+				});
+			}
+		}
+	}
+
+	return [{
+		type: 'alter_type_drop_value',
+		name: name,
+		enumSchema: schema,
+		deletedValues: removedValues,
+		newValues: json2.enums[`${schema}.${name}`].values,
+		columnsWithEnum: affectedColumns,
+	}];
+};
+
+export const prepareDropEnumJson = (
+	name: string,
+	schema: string,
+): JsonDropEnumStatement => {
+	return {
+		type: 'drop_type_enum',
+		name: name,
+		schema: schema,
+	};
+};
+
+export const prepareMoveEnumJson = (
+	name: string,
+	schemaFrom: string,
+	schemaTo: string,
+): JsonMoveEnumStatement => {
+	return {
+		type: 'move_type_enum',
+		name: name,
+		schemaFrom,
+		schemaTo,
+	};
+};
+
+export const prepareRenameEnumJson = (
+	nameFrom: string,
+	nameTo: string,
+	schema: string,
+): JsonRenameEnumStatement => {
+	return {
+		type: 'rename_type_enum',
+		nameFrom,
+		nameTo,
+		schema,
+	};
+};
+
+////////////
+
+export const prepareCreateSequenceJson = (
+	seq: Sequence,
+): JsonCreateSequenceStatement => {
+	const values = PgSquasher.unsquashSequence(seq.values);
+	return {
+		type: 'create_sequence',
+		name: seq.name,
+		schema: seq.schema,
+		values,
+	};
+};
+
+export const prepareAlterSequenceJson = (
+	seq: Sequence,
+): JsonAlterSequenceStatement[] => {
+	const values = PgSquasher.unsquashSequence(seq.values);
+	return [
+		{
+			type: 'alter_sequence',
+			schema: seq.schema,
+			name: seq.name,
+			values,
+		},
+	];
+};
+
+export const prepareDropSequenceJson = (
+	name: string,
+	schema: string,
+): JsonDropSequenceStatement => {
+	return {
+		type: 'drop_sequence',
+		name: name,
+		schema: schema,
+	};
+};
+
+export const prepareMoveSequenceJson = (
+	name: string,
+	schemaFrom: string,
+	schemaTo: string,
+): JsonMoveSequenceStatement => {
+	return {
+		type: 'move_sequence',
+		name: name,
+		schemaFrom,
+		schemaTo,
+	};
+};
+
+export const prepareRenameSequenceJson = (
+	nameFrom: string,
+	nameTo: string,
+	schema: string,
+): JsonRenameSequenceStatement => {
+	return {
+		type: 'rename_sequence',
+		nameFrom,
+		nameTo,
+		schema,
+	};
+};
+
+////////////
+
+export const prepareCreateRoleJson = (
+	role: Role,
+): JsonCreateRoleStatement => {
+	return {
+		type: 'create_role',
+		name: role.name,
+		values: {
+			createDb: role.createDb,
+			createRole: role.createRole,
+			inherit: role.inherit,
+		},
+	};
+};
+
+export const prepareAlterRoleJson = (
+	role: Role,
+): JsonAlterRoleStatement => {
+	return {
+		type: 'alter_role',
+		name: role.name,
+		values: {
+			createDb: role.createDb,
+			createRole: role.createRole,
+			inherit: role.inherit,
+		},
+	};
+};
+
+export const prepareDropRoleJson = (
+	name: string,
+): JsonDropRoleStatement => {
+	return {
+		type: 'drop_role',
+		name: name,
+	};
+};
+
+export const prepareRenameRoleJson = (
+	nameFrom: string,
+	nameTo: string,
+): JsonRenameRoleStatement => {
+	return {
+		type: 'rename_role',
+		nameFrom,
+		nameTo,
+	};
+};
+
+//////////
+
+export const prepareCreateSchemasJson = (
+	values: string[],
+): JsonCreateSchema[] => {
+	return values.map((it) => {
+		return {
+			type: 'create_schema',
+			name: it,
+		} as JsonCreateSchema;
+	});
+};
+
+export const prepareRenameSchemasJson = (
+	values: { from: string; to: string }[],
+): JsonRenameSchema[] => {
+	return values.map((it) => {
+		return {
+			type: 'rename_schema',
+			from: it.from,
+			to: it.to,
+		} as JsonRenameSchema;
+	});
+};
+
+export const prepareDeleteSchemasJson = (
+	values: string[],
+): JsonDropSchema[] => {
+	return values.map((it) => {
+		return {
+			type: 'drop_schema',
+			name: it,
+		} as JsonDropSchema;
+	});
+};
+
+export const prepareRenameColumns = (
+	tableName: string,
+	schema: string,
+	pairs: { from: Column; to: Column }[],
+): JsonRenameColumnStatement[] => {
+	return pairs.map((it) => {
+		return {
+			type: 'alter_table_rename_column',
+			tableName: tableName,
+			oldColumnName: it.from.name,
+			newColumnName: it.to.name,
+			schema,
+		};
+	});
+};
+
+export const _prepareDropColumns = (
+	taleName: string,
+	schema: string,
+	columns: Column[],
+): JsonDropColumnStatement[] => {
+	return columns.map((it) => {
+		return {
+			type: 'alter_table_drop_column',
+			tableName: taleName,
+			columnName: it.name,
+			schema,
+		};
+	});
+};
+
+export const _prepareAddColumns = (
+	tableName: string,
+	schema: string,
+	columns: Column[],
+): JsonAddColumnStatement[] => {
+	return columns.map((it) => {
+		return {
+			type: 'alter_table_add_column',
+			tableName: tableName,
+			column: it,
+			schema,
+		};
+	});
+};
+
+export const preparePgAlterColumns = (
+	_tableName: string,
+	schema: string,
+	columns: AlteredColumn[],
+	json2: PgSchemaSquashed,
+	json1: PgSchemaSquashed,
+	action?: 'push' | undefined,
+): JsonAlterColumnStatement[] => {
+	const tableKey = `${schema || 'public'}.${_tableName}`;
+	let statements: JsonAlterColumnStatement[] = [];
+	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
+	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
+
+	for (const column of columns) {
+		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
+
+		const tableName = json2.tables[tableKey].name;
+
+		// I used any, because those fields are available only for mysql dialect
+		// For other dialects it will become undefined, that is fine for json statements
+		const columnType = json2.tables[tableKey].columns[columnName].type;
+		const columnDefault = json2.tables[tableKey].columns[columnName].default;
+		const columnGenerated = json2.tables[tableKey].columns[columnName].generated;
+		const columnOnUpdate = (json2.tables[tableKey].columns[columnName] as any)
+			.onUpdate;
+		const columnNotNull = json2.tables[tableKey].columns[columnName].notNull;
+		const columnAutoIncrement = (
+			json2.tables[tableKey].columns[columnName] as any
+		).autoincrement;
+		const columnPk = (json2.tables[tableKey].columns[columnName] as any)
+			.primaryKey;
+		const typeSchema = json2.tables[tableKey].columns[columnName].typeSchema;
+		const json1ColumnTypeSchema = json1.tables[tableKey].columns[columnName].typeSchema;
+
+		const compositePk = json2.tables[tableKey].compositePrimaryKeys[`${tableName}_${columnName}`];
+
+		if (typeof column.name !== 'string') {
+			statements.push({
+				type: 'alter_table_rename_column',
+				tableName,
+				oldColumnName: column.name.old,
+				newColumnName: column.name.new,
+				schema,
+			});
+		}
+
+		if (column.type?.type === 'changed') {
+			const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+			const parsedNewColumnType = column.type.new.replace(arrayDefinitionRegex, '');
+			const parsedOldColumnType = column.type.old.replace(arrayDefinitionRegex, '');
+
+			const isNewTypeIsEnum = json2.enums[`${typeSchema}.${parsedNewColumnType}`];
+			const isOldTypeIsEnum = json1.enums[`${json1ColumnTypeSchema}.${parsedOldColumnType}`];
+
+			statements.push({
+				type: 'pg_alter_table_alter_column_set_type',
+				tableName,
+				columnName,
+				typeSchema: typeSchema,
+				newDataType: {
+					name: column.type.new,
+					isEnum: isNewTypeIsEnum ? true : false,
+				},
+				oldDataType: {
+					name: column.type.old,
+					isEnum: isOldTypeIsEnum ? true : false,
+				},
+				schema,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (
+			column.primaryKey?.type === 'deleted'
+			|| (column.primaryKey?.type === 'changed'
+				&& !column.primaryKey.new
+				&& typeof compositePk === 'undefined')
+		) {
+			dropPkStatements.push({
+				////
+				type: 'alter_table_alter_column_drop_pk',
+				tableName,
+				columnName,
+				schema,
+			});
+		}
+
+		if (column.default?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_default',
+				tableName,
+				columnName,
+				newDefaultValue: column.default.value,
+				schema,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.default?.type === 'changed') {
+			statements.push({
+				type: 'alter_table_alter_column_set_default',
+				tableName,
+				columnName,
+				newDefaultValue: column.default.new,
+				oldDefaultValue: column.default.old,
+				schema,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.default?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_default',
+				tableName,
+				columnName,
+				schema,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_notnull',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'changed') {
+			const type = column.notNull.new
+				? 'alter_table_alter_column_set_notnull'
+				: 'alter_table_alter_column_drop_notnull';
+			statements.push({
+				type: type,
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_notnull',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.identity?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_identity',
+				tableName,
+				columnName,
+				schema,
+				identity: column.identity.value,
+			});
+		}
+
+		if (column.identity?.type === 'changed') {
+			statements.push({
+				type: 'alter_table_alter_column_change_identity',
+				tableName,
+				columnName,
+				schema,
+				identity: column.identity.new,
+				oldIdentity: column.identity.old,
+			});
+		}
+
+		if (column.identity?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_identity',
+				tableName,
+				columnName,
+				schema,
+			});
+		}
+
+		if (column.generated?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_generated',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+				columnGenerated,
+			});
+		}
+
+		if (column.generated?.type === 'changed' && action !== 'push') {
+			statements.push({
+				type: 'alter_table_alter_column_alter_generated',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+				columnGenerated,
+			});
+		}
+
+		if (column.generated?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_generated',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+				columnGenerated,
+			});
+		}
+
+		if (
+			column.primaryKey?.type === 'added'
+			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
+		) {
+			const wasAutoincrement = statements.filter(
+				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
+			);
+			if (wasAutoincrement.length === 0) {
+				setPkStatements.push({
+					type: 'alter_table_alter_column_set_pk',
+					tableName,
+					schema,
+					columnName,
+				});
+			}
+		}
+
+		// if (column.primaryKey?.type === "added") {
+		//   statements.push({
+		//     type: "alter_table_alter_column_set_primarykey",
+		//     tableName,
+		//     columnName,
+		//     schema,
+		//     newDataType: columnType,
+		//     columnDefault,
+		//     columnOnUpdate,
+		//     columnNotNull,
+		//     columnAutoIncrement,
+		//   });
+		// }
+
+		// if (column.primaryKey?.type === "changed") {
+		//   const type = column.primaryKey.new
+		//     ? "alter_table_alter_column_set_primarykey"
+		//     : "alter_table_alter_column_drop_primarykey";
+
+		//   statements.push({
+		//     type,
+		//     tableName,
+		//     columnName,
+		//     schema,
+		//     newDataType: columnType,
+		//     columnDefault,
+		//     columnOnUpdate,
+		//     columnNotNull,
+		//     columnAutoIncrement,
+		//   });
+		// }
+
+		// if (column.primaryKey?.type === "deleted") {
+		//   statements.push({
+		//     type: "alter_table_alter_column_drop_primarykey",
+		//     tableName,
+		//     columnName,
+		//     schema,
+		//     newDataType: columnType,
+		//     columnDefault,
+		//     columnOnUpdate,
+		//     columnNotNull,
+		//     columnAutoIncrement,
+		//   });
+		// }
+
+		if (column.onUpdate?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_on_update',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.onUpdate?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_on_update',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+	}
+
+	return [...dropPkStatements, ...setPkStatements, ...statements];
+};
+
+export const prepareRenamePolicyJsons = (
+	tableName: string,
+	schema: string,
+	renames: {
+		from: Policy;
+		to: Policy;
+	}[],
+): JsonRenamePolicyStatement[] => {
+	return renames.map((it) => {
+		return {
+			type: 'rename_policy',
+			tableName: tableName,
+			oldName: it.from.name,
+			newName: it.to.name,
+			schema,
+		};
+	});
+};
+
+export const prepareRenameIndPolicyJsons = (
+	renames: {
+		from: Policy;
+		to: Policy;
+	}[],
+): JsonIndRenamePolicyStatement[] => {
+	return renames.map((it) => {
+		return {
+			type: 'rename_ind_policy',
+			tableKey: it.from.on!,
+			oldName: it.from.name,
+			newName: it.to.name,
+		};
+	});
+};
+
+export const prepareCreatePolicyJsons = (
+	tableName: string,
+	schema: string,
+	policies: Policy[],
+): JsonCreatePolicyStatement[] => {
+	return policies.map((it) => {
+		return {
+			type: 'create_policy',
+			tableName,
+			data: it,
+			schema,
+		};
+	});
+};
+
+export const prepareCreateIndPolicyJsons = (
+	policies: Policy[],
+): JsonCreateIndPolicyStatement[] => {
+	return policies.map((it) => {
+		return {
+			type: 'create_ind_policy',
+			tableName: it.on!,
+			data: it,
+		};
+	});
+};
+
+export const prepareDropPolicyJsons = (
+	tableName: string,
+	schema: string,
+	policies: Policy[],
+): JsonDropPolicyStatement[] => {
+	return policies.map((it) => {
+		return {
+			type: 'drop_policy',
+			tableName,
+			data: it,
+			schema,
+		};
+	});
+};
+
+export const prepareDropIndPolicyJsons = (
+	policies: Policy[],
+): JsonDropIndPolicyStatement[] => {
+	return policies.map((it) => {
+		return {
+			type: 'drop_ind_policy',
+			tableName: it.on!,
+			data: it,
+		};
+	});
+};
+
+export const prepareAlterPolicyJson = (
+	tableName: string,
+	schema: string,
+	oldPolicy: string,
+	newPolicy: string,
+): JsonAlterPolicyStatement => {
+	return {
+		type: 'alter_policy',
+		tableName,
+		oldData: oldPolicy,
+		newData: newPolicy,
+		schema,
+	};
+};
+
+export const prepareAlterIndPolicyJson = (
+	oldPolicy: Policy,
+	newPolicy: Policy,
+): JsonAlterIndPolicyStatement => {
+	return {
+		type: 'alter_ind_policy',
+		oldData: oldPolicy,
+		newData: newPolicy,
+	};
+};
+
+export const preparePgCreateIndexesJson = (
+	tableName: string,
+	schema: string,
+	indexes: Record<string, string>,
+	fullSchema: PgSchema,
+	action?: 'push' | undefined,
+): JsonPgCreateIndexStatement[] => {
+	if (action === 'push') {
+		return Object.values(indexes).map((indexData) => {
+			const unsquashedIndex = PgSquasher.unsquashIdxPush(indexData);
+			const data = fullSchema.tables[`${schema === '' ? 'public' : schema}.${tableName}`]
+				.indexes[unsquashedIndex.name];
+			return {
+				type: 'create_index_pg',
+				tableName,
+				data,
+				schema,
+			};
+		});
+	}
+	return Object.values(indexes).map((indexData) => {
+		return {
+			type: 'create_index_pg',
+			tableName,
+			data: PgSquasher.unsquashIdx(indexData),
+			schema,
+		};
+	});
+};
+
+export const prepareCreateIndexesJson = (
+	tableName: string,
+	schema: string,
+	indexes: Record<string, string>,
+	internals?: SQLiteKitInternals,
+): JsonCreateIndexStatement[] => {
+	return Object.values(indexes).map((indexData) => {
+		return {
+			type: 'create_index',
+			tableName,
+			data: indexData,
+			schema,
+			internals,
+		};
+	});
+};
+
+export const prepareCreateReferencesJson = (
+	tableName: string,
+	schema: string,
+	foreignKeys: Record<string, string>,
+): JsonCreateReferenceStatement[] => {
+	return Object.values(foreignKeys).map((fkData) => {
+		return {
+			type: 'create_reference',
+			tableName,
+			data: fkData,
+			schema,
+		};
+	});
+};
+
+export const prepareDropReferencesJson = (
+	tableName: string,
+	schema: string,
+	foreignKeys: Record<string, string>,
+): JsonDeleteReferenceStatement[] => {
+	return Object.values(foreignKeys).map((fkData) => {
+		return {
+			type: 'delete_reference',
+			tableName,
+			data: fkData,
+			schema,
+		};
+	});
+};
+
+// alter should create 2 statements. It's important to make only 1 sql per statement(for breakpoints)
+export const prepareAlterReferencesJson = (
+	tableName: string,
+	schema: string,
+	foreignKeys: Record<string, { __old: string; __new: string }>,
+): JsonReferenceStatement[] => {
+	const stmts: JsonReferenceStatement[] = [];
+	Object.values(foreignKeys).map((val) => {
+		stmts.push({
+			type: 'delete_reference',
+			tableName,
+			schema,
+			data: val.__old,
+		});
+
+		stmts.push({
+			type: 'create_reference',
+			tableName,
+			schema,
+			data: val.__new,
+		});
+	});
+	return stmts;
+};
+
+export const prepareDropIndexesJson = (
+	tableName: string,
+	schema: string,
+	indexes: Record<string, string>,
+): JsonDropIndexStatement[] => {
+	return Object.values(indexes).map((indexData) => {
+		return {
+			type: 'drop_index',
+			tableName,
+			data: indexData,
+			schema,
+		};
+	});
+};
+
+export const prepareAddCompositePrimaryKeySqlite = (
+	tableName: string,
+	pks: Record<string, string>,
+): JsonCreateCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'create_composite_pk',
+			tableName,
+			data: it,
+		} as JsonCreateCompositePK;
+	});
+};
+
+export const prepareDeleteCompositePrimaryKeySqlite = (
+	tableName: string,
+	pks: Record<string, string>,
+): JsonDeleteCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'delete_composite_pk',
+			tableName,
+			data: it,
+		} as JsonDeleteCompositePK;
+	});
+};
+
+export const prepareAlterCompositePrimaryKeySqlite = (
+	tableName: string,
+	pks: Record<string, { __old: string; __new: string }>,
+): JsonAlterCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'alter_composite_pk',
+			tableName,
+			old: it.__old,
+			new: it.__new,
+		} as JsonAlterCompositePK;
+	});
+};
+
+export const prepareAddCompositePrimaryKeyPg = (
+	tableName: string,
+	schema: string,
+	pks: Record<string, string>,
+): JsonCreateCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'create_composite_pk',
+			tableName,
+			data: it,
+			schema,
+			constraintName: PgSquasher.unsquashPK(it).name,
+		} as JsonCreateCompositePK;
+	});
+};
+
+export const prepareDeleteCompositePrimaryKeyPg = (
+	tableName: string,
+	schema: string,
+	pks: Record<string, string>,
+): JsonDeleteCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'delete_composite_pk',
+			tableName,
+			data: it,
+			schema,
+			constraintName: PgSquasher.unsquashPK(it).name,
+		} as JsonDeleteCompositePK;
+	});
+};
+
+export const prepareAlterCompositePrimaryKeyPg = (
+	tableName: string,
+	schema: string,
+	pks: Record<string, { __old: string; __new: string }>,
+): JsonAlterCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'alter_composite_pk',
+			tableName,
+			old: it.__old,
+			new: it.__new,
+			schema,
+			oldConstraintName: PgSquasher.unsquashPK(it.__old).name,
+			newConstraintName: PgSquasher.unsquashPK(it.__new).name,
+		} as JsonAlterCompositePK;
+	});
+};
+
+export const prepareAddUniqueConstraintPg = (
+	tableName: string,
+	schema: string,
+	unqs: Record<string, string>,
+): JsonCreateUniqueConstraint[] => {
+	return Object.values(unqs).map((it) => {
+		return {
+			type: 'create_unique_constraint',
+			tableName,
+			data: it,
+			schema,
+		} as JsonCreateUniqueConstraint;
+	});
+};
+
+export const prepareDeleteUniqueConstraintPg = (
+	tableName: string,
+	schema: string,
+	unqs: Record<string, string>,
+): JsonDeleteUniqueConstraint[] => {
+	return Object.values(unqs).map((it) => {
+		return {
+			type: 'delete_unique_constraint',
+			tableName,
+			data: it,
+			schema,
+		} as JsonDeleteUniqueConstraint;
+	});
+};
+
+export const prepareAddCompositePrimaryKeyMySql = (
+	tableName: string,
+	pks: Record<string, string>,
+	// TODO: remove?
+	json1: MySqlSchema,
+	_json2: MySqlSchema,
+): JsonCreateCompositePK[] => {
+	const res: JsonCreateCompositePK[] = [];
+	for (const it of Object.values(pks)) {
+		const unsquashed = MySqlSquasher.unsquashPK(it);
+
+		if (
+			unsquashed.columns.length === 1
+			&& json1.tables[tableName]?.columns[unsquashed.columns[0]]?.primaryKey
+		) {
+			continue;
+		}
+
+		res.push({
+			type: 'create_composite_pk',
+			tableName,
+			data: it,
+			constraintName: unsquashed.name,
+		} as JsonCreateCompositePK);
+	}
+	return res;
+};
+
+export const prepareDeleteCompositePrimaryKeyMySql = (
+	tableName: string,
+	pks: Record<string, string>,
+): JsonDeleteCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'delete_composite_pk',
+			tableName,
+			data: it,
+		} as JsonDeleteCompositePK;
+	});
+};
+
+export const prepareAlterCompositePrimaryKeyMySql = (
+	tableName: string,
+	pks: Record<string, { __old: string; __new: string }>,
+	// TODO: remove?
+	json1: MySqlSchema,
+	json2: MySqlSchema,
+): JsonAlterCompositePK[] => {
+	return Object.values(pks).map((it) => {
+		return {
+			type: 'alter_composite_pk',
+			tableName,
+			old: it.__old,
+			new: it.__new,
+			oldConstraintName: json1.tables[tableName].compositePrimaryKeys[
+				MySqlSquasher.unsquashPK(it.__old).name
+			].name,
+			newConstraintName: json2.tables[tableName].compositePrimaryKeys[
+				MySqlSquasher.unsquashPK(it.__new).name
+			].name,
+		} as JsonAlterCompositePK;
+	});
+};
+
+export const prepareAddCheckConstraint = (
+	tableName: string,
+	schema: string,
+	check: Record<string, string>,
+): JsonCreateCheckConstraint[] => {
+	return Object.values(check).map((it) => {
+		return {
+			type: 'create_check_constraint',
+			tableName,
+			data: it,
+			schema,
+		} as JsonCreateCheckConstraint;
+	});
+};
+
+export const prepareDeleteCheckConstraint = (
+	tableName: string,
+	schema: string,
+	check: Record<string, string>,
+): JsonDeleteCheckConstraint[] => {
+	return Object.values(check).map((it) => {
+		return {
+			type: 'delete_check_constraint',
+			tableName,
+			constraintName: PgSquasher.unsquashCheck(it).name,
+			schema,
+		} as JsonDeleteCheckConstraint;
+	});
+};
+
+// add create table changes
+// add handler to make drop and add and not alter(looking at __old and __new)
+// add serializer for mysql and sqlite + types
+// add introspect serializer for pg+sqlite+mysql
+// add introspect actual code
+// add push sqlite handler
+// add push mysql warning if data exists and may have unique conflict
+// add release notes
+// add docs changes
+
+export const prepareAlterUniqueConstraintPg = (
+	tableName: string,
+	schema: string,
+	unqs: Record<string, { __old: string; __new: string }>,
+): JsonAlterUniqueConstraint[] => {
+	return Object.values(unqs).map((it) => {
+		return {
+			type: 'alter_unique_constraint',
+			tableName,
+			old: it.__old,
+			new: it.__new,
+			schema,
+		} as JsonAlterUniqueConstraint;
+	});
+};
+
+export const preparePgCreateViewJson = (
+	name: string,
+	schema: string,
+	definition: string,
+	materialized: boolean,
+	withNoData: boolean = false,
+	withOption?: any,
+	using?: string,
+	tablespace?: string,
+): JsonCreatePgViewStatement => {
+	return {
+		type: 'create_view',
+		name: name,
+		schema: schema,
+		definition: definition,
+		with: withOption,
+		materialized: materialized,
+		withNoData,
+		using,
+		tablespace,
+	};
+};
+
+/* export const prepareSingleStoreCreateViewJson = (
+	name: string,
+	definition: string,
+	meta: string,
+	replace: boolean = false,
+): JsonCreateSingleStoreViewStatement => {
+	const { algorithm, sqlSecurity, withCheckOption } = SingleStoreSquasher.unsquashView(meta);
+	return {
+		type: 'singlestore_create_view',
+		name: name,
+		definition: definition,
+		algorithm,
+		sqlSecurity,
+		withCheckOption,
+		replace,
+	};
+}; */
+
+export const prepareDropViewJson = (
+	name: string,
+	schema?: string,
+	materialized?: boolean,
+): JsonDropViewStatement => {
+	const resObject: JsonDropViewStatement = <JsonDropViewStatement> { name, type: 'drop_view' };
+
+	if (schema) resObject['schema'] = schema;
+
+	if (materialized) resObject['materialized'] = materialized;
+
+	return resObject;
+};
+
+export const prepareRenameViewJson = (
+	to: string,
+	from: string,
+	schema?: string,
+	materialized?: boolean,
+): JsonRenameViewStatement => {
+	const resObject: JsonRenameViewStatement = <JsonRenameViewStatement> {
+		type: 'rename_view',
+		nameTo: to,
+		nameFrom: from,
+	};
+
+	if (schema) resObject['schema'] = schema;
+	if (materialized) resObject['materialized'] = materialized;
+
+	return resObject;
+};
+
+export const prepareMySqlCreateTableJson = (
+	table: Table,
+	json2: MySqlSchema,
+): JsonCreateTableStatement => {
+	const { name, schema, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints } = table;
+
+	return {
+		type: 'create_table',
+		tableName: name,
+		schema,
+		columns: Object.values(columns),
+		compositePKs: Object.values(compositePrimaryKeys),
+		compositePkName: Object.values(compositePrimaryKeys).length > 0
+			? json2.tables[name].compositePrimaryKeys[
+				MySqlSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0])
+					.name
+			].name
+			: '',
+		uniqueConstraints: Object.values(uniqueConstraints),
+		checkConstraints: Object.values(checkConstraints),
+	};
+};
+
+export const prepareMySqlCreateViewJson = (
+	name: string,
+	definition: string,
+	meta: string,
+	replace: boolean = false,
+): JsonCreateMySqlViewStatement => {
+	const { algorithm, sqlSecurity, withCheckOption } = MySqlSquasher.unsquashView(meta);
+	return {
+		type: 'mysql_create_view',
+		name: name,
+		definition: definition,
+		algorithm,
+		sqlSecurity,
+		withCheckOption,
+		replace,
+	};
+};
+
+export const preparePgAlterViewAlterSchemaJson = (
+	to: string,
+	from: string,
+	name: string,
+	materialized?: boolean,
+): JsonAlterViewAlterSchemaStatement => {
+	const returnObject: JsonAlterViewAlterSchemaStatement = {
+		type: 'alter_view_alter_schema',
+		fromSchema: from,
+		toSchema: to,
+		name,
+	};
+
+	if (materialized) returnObject['materialized'] = materialized;
+	return returnObject;
+};
+
+export const preparePgAlterViewAddWithOptionJson = (
+	name: string,
+	schema: string,
+	materialized: boolean,
+	withOption: MatViewWithOption | ViewWithOption,
+): JsonAlterViewAddWithOptionStatement => {
+	return {
+		type: 'alter_view_add_with_option',
+		name,
+		schema,
+		materialized: materialized,
+		with: withOption,
+	} as JsonAlterViewAddWithOptionStatement;
+};
+
+export const preparePgAlterViewDropWithOptionJson = (
+	name: string,
+	schema: string,
+	materialized: boolean,
+	withOption: MatViewWithOption | ViewWithOption,
+): JsonAlterViewDropWithOptionStatement => {
+	return {
+		type: 'alter_view_drop_with_option',
+		name,
+		schema,
+		materialized: materialized,
+		with: withOption,
+	} as JsonAlterViewDropWithOptionStatement;
+};
+
+export const preparePgAlterViewAlterTablespaceJson = (
+	name: string,
+	schema: string,
+	materialized: boolean,
+	to: string,
+): JsonAlterViewAlterTablespaceStatement => {
+	return {
+		type: 'alter_view_alter_tablespace',
+		name,
+		schema,
+		materialized: materialized,
+		toTablespace: to,
+	} as JsonAlterViewAlterTablespaceStatement;
+};
+
+export const preparePgAlterViewAlterUsingJson = (
+	name: string,
+	schema: string,
+	materialized: boolean,
+	to: string,
+): JsonAlterViewAlterUsingStatement => {
+	return {
+		type: 'alter_view_alter_using',
+		name,
+		schema,
+		materialized: materialized,
+		toUsing: to,
+	} as JsonAlterViewAlterUsingStatement;
+};
+
+/* export const prepareSingleStoreAlterView = (
+	view: Omit<SingleStoreView, 'isExisting'>,
+): JsonAlterSingleStoreViewStatement => {
+	return { type: 'alter_singlestore_view', ...view };
+}; */
+
+export const prepareSQLiteRecreateTable = (
+	table: SQLiteSchemaSquashed['tables'][keyof SQLiteSchemaSquashed['tables']],
+	action?: 'push',
+): JsonStatement[] => {
+	const { name, columns, uniqueConstraints, indexes, checkConstraints } = table;
+
+	const composites: string[][] = Object.values(table.compositePrimaryKeys).map(
+		(it) => SQLiteSquasher.unsquashPK(it),
+	);
+
+	const references: string[] = Object.values(table.foreignKeys);
+	const fks = references.map((it) =>
+		action === 'push' ? SQLiteSquasher.unsquashPushFK(it) : SQLiteSquasher.unsquashFK(it)
+	);
+
+	const statements: JsonStatement[] = [
+		{
+			type: 'recreate_table',
+			tableName: name,
+			columns: Object.values(columns),
+			compositePKs: composites,
+			referenceData: fks,
+			uniqueConstraints: Object.values(uniqueConstraints),
+			checkConstraints: Object.values(checkConstraints),
+		},
+	];
+
+	if (Object.keys(indexes).length) {
+		statements.push(...prepareCreateIndexesJson(name, '', indexes));
+	}
+	return statements;
+};
+
+export const prepareSQLiteCreateTable = (
+	table: Table,
+	action?: 'push' | undefined,
+): JsonSqliteCreateTableStatement => {
+	const { name, columns, uniqueConstraints, checkConstraints } = table;
+
+	const references: string[] = Object.values(table.foreignKeys);
+
+	const composites: string[][] = Object.values(table.compositePrimaryKeys).map(
+		(it) => SQLiteSquasher.unsquashPK(it),
+	);
+
+	const fks = references.map((it) =>
+		action === 'push'
+			? SQLiteSquasher.unsquashPushFK(it)
+			: SQLiteSquasher.unsquashFK(it)
+	);
+
+	return {
+		type: 'sqlite_create_table',
+		tableName: name,
+		columns: Object.values(columns),
+		referenceData: fks,
+		compositePKs: composites,
+		uniqueConstraints: Object.values(uniqueConstraints),
+		checkConstraints: Object.values(checkConstraints),
+	};
+};
+
+export const _prepareSqliteAddColumns = (
+	tableName: string,
+	columns: Column[],
+	referenceData: string[],
+): JsonSqliteAddColumnStatement[] => {
+	const unsquashed = referenceData.map((addedFkValue) => SQLiteSquasher.unsquashFK(addedFkValue));
+
+	return columns
+		.map((it) => {
+			const columnsWithReference = unsquashed.find((t) => t.columnsFrom.includes(it.name));
+
+			if (it.generated?.type === 'stored') {
+				warning(
+					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
+				);
+				return null;
+			}
+
+			return {
+				type: 'sqlite_alter_table_add_column',
+				tableName: tableName,
+				column: it,
+				referenceData: columnsWithReference
+					? SQLiteSquasher.squashFK(columnsWithReference)
+					: undefined,
+			};
+		})
+		.filter(Boolean) as JsonSqliteAddColumnStatement[];
+};
+export const prepareSqliteAlterColumns = (
+	tableName: string,
+	schema: string,
+	columns: AlteredColumn[],
+	// TODO: remove?
+	json2: CommonSquashedSchema,
+): JsonAlterColumnStatement[] => {
+	let statements: JsonAlterColumnStatement[] = [];
+	let dropPkStatements: JsonAlterColumnDropPrimaryKeyStatement[] = [];
+	let setPkStatements: JsonAlterColumnSetPrimaryKeyStatement[] = [];
+
+	for (const column of columns) {
+		const columnName = typeof column.name !== 'string' ? column.name.new : column.name;
+
+		// I used any, because those fields are available only for mysql dialect
+		// For other dialects it will become undefined, that is fine for json statements
+		const columnType = json2.tables[tableName].columns[columnName].type;
+		const columnDefault = json2.tables[tableName].columns[columnName].default;
+		const columnOnUpdate = (json2.tables[tableName].columns[columnName] as any)
+			.onUpdate;
+		const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
+		const columnAutoIncrement = (
+			json2.tables[tableName].columns[columnName] as any
+		).autoincrement;
+		const columnPk = (json2.tables[tableName].columns[columnName] as any)
+			.primaryKey;
+
+		const columnGenerated = json2.tables[tableName].columns[columnName].generated;
+
+		const compositePk = json2.tables[tableName].compositePrimaryKeys[
+			`${tableName}_${columnName}`
+		];
+
+		if (column.autoincrement?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_autoincrement',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.autoincrement?.type === 'changed') {
+			const type = column.autoincrement.new
+				? 'alter_table_alter_column_set_autoincrement'
+				: 'alter_table_alter_column_drop_autoincrement';
+
+			statements.push({
+				type,
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.autoincrement?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_autoincrement',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (typeof column.name !== 'string') {
+			statements.push({
+				type: 'alter_table_rename_column',
+				tableName,
+				oldColumnName: column.name.old,
+				newColumnName: column.name.new,
+				schema,
+			});
+		}
+
+		if (column.type?.type === 'changed') {
+			statements.push({
+				type: 'alter_table_alter_column_set_type',
+				tableName,
+				columnName,
+				newDataType: column.type.new,
+				oldDataType: column.type.old,
+				schema,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (
+			column.primaryKey?.type === 'deleted'
+			|| (column.primaryKey?.type === 'changed'
+				&& !column.primaryKey.new
+				&& typeof compositePk === 'undefined')
+		) {
+			dropPkStatements.push({
+				////
+				type: 'alter_table_alter_column_drop_pk',
+				tableName,
+				columnName,
+				schema,
+			});
+		}
+
+		if (column.default?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_default',
+				tableName,
+				columnName,
+				newDefaultValue: column.default.value,
+				schema,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.default?.type === 'changed') {
+			statements.push({
+				type: 'alter_table_alter_column_set_default',
+				tableName,
+				columnName,
+				newDefaultValue: column.default.new,
+				oldDefaultValue: column.default.old,
+				schema,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.default?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_default',
+				tableName,
+				columnName,
+				schema,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				newDataType: columnType,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_notnull',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'changed') {
+			const type = column.notNull.new
+				? 'alter_table_alter_column_set_notnull'
+				: 'alter_table_alter_column_drop_notnull';
+			statements.push({
+				type: type,
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.notNull?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_notnull',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.generated?.type === 'added') {
+			if (columnGenerated?.type === 'virtual') {
+				statements.push({
+					type: 'alter_table_alter_column_set_generated',
+					tableName,
+					columnName,
+					schema,
+					newDataType: columnType,
+					columnDefault,
+					columnOnUpdate,
+					columnNotNull,
+					columnAutoIncrement,
+					columnPk,
+					columnGenerated: columnGenerated as {
+						type: 'stored' | 'virtual';
+						as: string;
+					},
+				});
+			} else {
+				warning(
+					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
+				);
+			}
+		}
+
+		if (column.generated?.type === 'changed') {
+			if (columnGenerated?.type === 'virtual') {
+				statements.push({
+					type: 'alter_table_alter_column_alter_generated',
+					tableName,
+					columnName,
+					schema,
+					newDataType: columnType,
+					columnDefault,
+					columnOnUpdate,
+					columnNotNull,
+					columnAutoIncrement,
+					columnPk,
+					columnGenerated: columnGenerated as {
+						type: 'stored' | 'virtual';
+						as: string;
+					},
+				});
+			} else {
+				warning(
+					`As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`,
+				);
+			}
+		}
+
+		if (column.generated?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_generated',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+				columnGenerated: columnGenerated as {
+					type: 'stored' | 'virtual';
+					as: string;
+				},
+			});
+		}
+
+		if (
+			column.primaryKey?.type === 'added'
+			|| (column.primaryKey?.type === 'changed' && column.primaryKey.new)
+		) {
+			const wasAutoincrement = statements.filter(
+				(it) => it.type === 'alter_table_alter_column_set_autoincrement',
+			);
+			if (wasAutoincrement.length === 0) {
+				setPkStatements.push({
+					type: 'alter_table_alter_column_set_pk',
+					tableName,
+					schema,
+					columnName,
+				});
+			}
+		}
+
+		if (column.onUpdate?.type === 'added') {
+			statements.push({
+				type: 'alter_table_alter_column_set_on_update',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+
+		if (column.onUpdate?.type === 'deleted') {
+			statements.push({
+				type: 'alter_table_alter_column_drop_on_update',
+				tableName,
+				columnName,
+				schema,
+				newDataType: columnType,
+				columnDefault,
+				columnOnUpdate,
+				columnNotNull,
+				columnAutoIncrement,
+				columnPk,
+			});
+		}
+	}
+
+	return [...dropPkStatements, ...setPkStatements, ...statements];
+};
+
+export const prepareSqliteCreateViewJson = (
+	name: string,
+	definition: string,
+): JsonCreateSqliteViewStatement => {
+	return {
+		type: 'sqlite_create_view',
+		name: name,
+		definition: definition,
+	};
+};
diff --git a/drizzle-kit/src/legacy/mysql-v5/mysqlDiff.ts b/drizzle-kit/src/legacy/mysql-v5/mysqlDiff.ts
new file mode 100644
index 0000000000..a297502fc1
--- /dev/null
+++ b/drizzle-kit/src/legacy/mysql-v5/mysqlDiff.ts
@@ -0,0 +1,656 @@
+import { applyJsonDiff, diffColumns, diffSchemasOrTables } from '../jsonDiffer';
+import { fromJson } from '../sqlgenerator2';
+
+import type {
+	JsonAddColumnStatement,
+	JsonAlterCompositePK,
+	JsonAlterUniqueConstraint,
+	JsonCreateCheckConstraint,
+	JsonCreateCompositePK,
+	JsonCreateMySqlViewStatement,
+	JsonCreateReferenceStatement,
+	JsonCreateUniqueConstraint,
+	JsonDeleteCheckConstraint,
+	JsonDeleteCompositePK,
+	JsonDeleteUniqueConstraint,
+	JsonDropColumnStatement,
+	JsonDropViewStatement,
+	JsonReferenceStatement,
+	JsonRenameColumnStatement,
+	JsonRenameViewStatement,
+	JsonStatement,
+} from '../jsonStatements';
+import {
+	_prepareAddColumns,
+	_prepareDropColumns,
+	prepareAddCheckConstraint,
+	prepareAddCompositePrimaryKeyMySql,
+	prepareAddUniqueConstraintPg as prepareAddUniqueConstraint,
+	prepareAlterCompositePrimaryKeyMySql,
+	prepareAlterReferencesJson,
+	prepareCreateIndexesJson,
+	prepareCreateReferencesJson,
+	prepareDeleteCheckConstraint,
+	prepareDeleteCompositePrimaryKeyMySql,
+	prepareDeleteUniqueConstraintPg as prepareDeleteUniqueConstraint,
+	prepareDropIndexesJson,
+	prepareDropReferencesJson,
+	prepareDropTableJson,
+	prepareDropViewJson,
+	prepareMySqlCreateTableJson,
+	prepareMySqlCreateViewJson,
+	prepareRenameColumns,
+	prepareRenameTableJson,
+	prepareRenameViewJson,
+} from '../jsonStatements';
+
+import { mapEntries, mapKeys } from '../global';
+import type {
+	Column,
+	ColumnsResolverInput,
+	ColumnsResolverOutput,
+	DiffResultMysql,
+	Named,
+	ResolverInput,
+	ResolverOutputWithMoved,
+	Table,
+} from '../snapshotsDiffer';
+import {
+	columnChangeFor,
+	columnsResolver,
+	diffResultSchemeMysql,
+	mySqlViewsResolver,
+	nameChangeFor,
+	tablesResolver,
+} from '../snapshotsDiffer';
+import { copy } from '../utils';
+import type { MySqlSchema, MySqlSchemaSquashed, ViewSquashed } from './mysqlSchema';
+import { dryMySql, MySqlSquasher, squashMysqlScheme } from './mysqlSchema';
+
+export const diff = async (opts: {
+	left?: MySqlSchema;
+	right: MySqlSchema;
+	mode?: 'push';
+}) => {
+	const left = opts.left ?? dryMySql;
+	const json1 = squashMysqlScheme(left);
+	const json2 = squashMysqlScheme(opts.right);
+	return _diff(
+		json1,
+		json2,
+		tablesResolver,
+		columnsResolver,
+		mySqlViewsResolver,
+		left,
+		opts.right,
+		opts.mode,
+	);
+};
+
+export const _diff = async (
+	json1: MySqlSchemaSquashed,
+	json2: MySqlSchemaSquashed,
+	tablesResolver: (
+		input: ResolverInput<Table>,
+	) => Promise<ResolverOutputWithMoved<Table>>,
+	columnsResolver: (
+		input: ColumnsResolverInput<Column>,
+	) => Promise<ColumnsResolverOutput<Column>>,
+	viewsResolver: (
+		input: ResolverInput<ViewSquashed & { schema: '' }>,
+	) => Promise<ResolverOutputWithMoved<ViewSquashed>>,
+	prevFull: MySqlSchema,
+	curFull: MySqlSchema,
+	action?: 'push' | undefined,
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	_meta:
+		| {
+			schemas: {};
+			tables: {};
+			columns: {};
+		}
+		| undefined;
+}> => {
+	// squash indexes and fks
+
+	// squash uniqueIndexes and uniqueConstraint into constraints object
+	// it should be done for mysql only because it has no diffs for it
+
+	// TODO: @AndriiSherman
+	// Add an upgrade to v6 and move all snaphosts to this strcutre
+	// After that we can generate mysql in 1 object directly(same as sqlite)
+	for (const tableName in json1.tables) {
+		const table = json1.tables[tableName];
+		for (const indexName in table.indexes) {
+			const index = MySqlSquasher.unsquashIdx(table.indexes[indexName]);
+			if (index.isUnique) {
+				table.uniqueConstraints[indexName] = MySqlSquasher.squashUnique({
+					name: index.name,
+					columns: index.columns,
+				});
+				delete json1.tables[tableName].indexes[index.name];
+			}
+		}
+	}
+
+	for (const tableName in json2.tables) {
+		const table = json2.tables[tableName];
+		for (const indexName in table.indexes) {
+			const index = MySqlSquasher.unsquashIdx(table.indexes[indexName]);
+			if (index.isUnique) {
+				table.uniqueConstraints[indexName] = MySqlSquasher.squashUnique({
+					name: index.name,
+					columns: index.columns,
+				});
+				delete json2.tables[tableName].indexes[index.name];
+			}
+		}
+	}
+
+	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
+
+	const {
+		created: createdTables,
+		deleted: deletedTables,
+		renamed: renamedTables, // renamed or moved
+	} = await tablesResolver({
+		created: tablesDiff.added,
+		deleted: tablesDiff.deleted,
+	});
+
+	const tablesPatchedSnap1 = copy(json1);
+	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
+		const { name } = nameChangeFor(it, renamedTables);
+		it.name = name;
+		return [name, it];
+	});
+
+	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
+	const columnRenames = [] as {
+		table: string;
+		renames: { from: Column; to: Column }[];
+	}[];
+
+	const columnCreates = [] as {
+		table: string;
+		columns: Column[];
+	}[];
+
+	const columnDeletes = [] as {
+		table: string;
+		columns: Column[];
+	}[];
+
+	for (let entry of Object.values(res)) {
+		const { renamed, created, deleted } = await columnsResolver({
+			tableName: entry.name,
+			schema: entry.schema,
+			deleted: entry.columns.deleted,
+			created: entry.columns.added,
+		});
+
+		if (created.length > 0) {
+			columnCreates.push({
+				table: entry.name,
+				columns: created,
+			});
+		}
+
+		if (deleted.length > 0) {
+			columnDeletes.push({
+				table: entry.name,
+				columns: deleted,
+			});
+		}
+
+		if (renamed.length > 0) {
+			columnRenames.push({
+				table: entry.name,
+				renames: renamed,
+			});
+		}
+	}
+
+	const columnRenamesDict = columnRenames.reduce(
+		(acc, it) => {
+			acc[it.table] = it.renames;
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				from: Named;
+				to: Named;
+			}[]
+		>,
+	);
+
+	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
+	columnsPatchedSnap1.tables = mapEntries(
+		columnsPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedColumns = mapKeys(
+				tableValue.columns,
+				(columnKey, column) => {
+					const rens = columnRenamesDict[tableValue.name] || [];
+					const newName = columnChangeFor(columnKey, rens);
+					column.name = newName;
+					return newName;
+				},
+			);
+
+			tableValue.columns = patchedColumns;
+			return [tableKey, tableValue];
+		},
+	);
+
+	const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
+
+	const {
+		created: createdViews,
+		deleted: deletedViews,
+		renamed: renamedViews, // renamed or moved
+	} = await viewsResolver({
+		created: viewsDiff.added,
+		deleted: viewsDiff.deleted,
+	});
+
+	const renamesViewDic: Record<string, { to: string; from: string }> = {};
+	renamedViews.forEach((it) => {
+		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
+	});
+
+	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
+	viewsPatchedSnap1.views = mapEntries(
+		viewsPatchedSnap1.views,
+		(viewKey, viewValue) => {
+			const rename = renamesViewDic[viewValue.name];
+
+			if (rename) {
+				viewValue.name = rename.to;
+				viewKey = rename.to;
+			}
+
+			return [viewKey, viewValue];
+		},
+	);
+
+	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
+
+	const typedResult: DiffResultMysql = diffResultSchemeMysql.parse(diffResult);
+
+	const jsonStatements: JsonStatement[] = [];
+
+	const jsonCreateIndexesForCreatedTables = createdTables
+		.map((it) => {
+			return prepareCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.indexes,
+			);
+		})
+		.flat();
+
+	const jsonDropTables = deletedTables.map((it) => {
+		return prepareDropTableJson(it);
+	});
+
+	const jsonRenameTables = renamedTables.map((it) => {
+		return prepareRenameTableJson(it.from, it.to);
+	});
+
+	const alteredTables = typedResult.alteredTablesWithColumns;
+
+	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
+	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
+	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
+
+	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+
+	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
+	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
+
+	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
+		.map((it) => prepareRenameColumns(it.table, '', it.renames))
+		.flat();
+
+	const jsonAddColumnsStatemets: JsonAddColumnStatement[] = columnCreates
+		.map((it) => _prepareAddColumns(it.table, '', it.columns))
+		.flat();
+
+	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
+		.map((it) => _prepareDropColumns(it.table, '', it.columns))
+		.flat();
+
+	alteredTables.forEach((it) => {
+		// This part is needed to make sure that same columns in a table are not triggered for change
+		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
+		// We double-check that pk with same set of columns are both in added and deleted diffs
+		// let addedColumns: string[] = [];
+		// for (const addedPkName of Object.keys(it.addedCompositePKs)) {
+		// 	const addedPkColumns = it.addedCompositePKs[addedPkName];
+		// 	addedColumns = MySqlSquasher.unsquashPK(addedPkColumns).columns;
+		// }
+
+		// let deletedColumns: string[] = [];
+		// for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
+		// 	const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
+		// 	deletedColumns = MySqlSquasher.unsquashPK(deletedPkColumns).columns;
+		// }
+
+		// Don't need to sort, but need to add tests for it
+		// addedColumns.sort();
+		// deletedColumns.sort();
+		// const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
+
+		let addedCompositePKs: JsonCreateCompositePK[] = [];
+		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
+		let alteredCompositePKs: JsonAlterCompositePK[] = [];
+
+		addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
+			it.name,
+			it.addedCompositePKs,
+			prevFull,
+			curFull,
+		);
+		deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
+			it.name,
+			it.deletedCompositePKs,
+		);
+		// }
+		alteredCompositePKs = prepareAlterCompositePrimaryKeyMySql(
+			it.name,
+			it.alteredCompositePKs,
+			prevFull,
+			curFull,
+		);
+
+		// add logic for unique constraints
+		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+
+		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
+		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
+
+		addedUniqueConstraints = prepareAddUniqueConstraint(
+			it.name,
+			it.schema,
+			it.addedUniqueConstraints,
+		);
+		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
+			it.name,
+			it.schema,
+			it.deletedUniqueConstraints,
+		);
+		if (it.alteredUniqueConstraints) {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+			for (const k of Object.keys(it.alteredUniqueConstraints)) {
+				added[k] = it.alteredUniqueConstraints[k].__new;
+				deleted[k] = it.alteredUniqueConstraints[k].__old;
+			}
+			addedUniqueConstraints.push(
+				...prepareAddUniqueConstraint(it.name, it.schema, added),
+			);
+			deletedUniqueConstraints.push(
+				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
+			);
+		}
+
+		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
+		deletedCheckConstraints = prepareDeleteCheckConstraint(
+			it.name,
+			it.schema,
+			it.deletedCheckConstraints,
+		);
+
+		// skip for push
+		if (it.alteredCheckConstraints && action !== 'push') {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+
+			for (const k of Object.keys(it.alteredCheckConstraints)) {
+				added[k] = it.alteredCheckConstraints[k].__new;
+				deleted[k] = it.alteredCheckConstraints[k].__old;
+			}
+			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
+			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
+		}
+
+		jsonAddedCompositePKs.push(...addedCompositePKs);
+		jsonDeletedCompositePKs.push(...deletedCompositePKs);
+		jsonAlteredCompositePKs.push(...alteredCompositePKs);
+
+		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
+		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
+		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
+
+		jsonCreatedCheckConstraints.push(...createdCheckConstraints);
+		jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
+	});
+
+	// const rColumns = jsonRenameColumnsStatements.map((it) => {
+	// 	const tableName = it.tableName;
+	// 	const schema = it.schema;
+	// 	return {
+	// 		from: { schema, table: tableName, column: it.oldColumnName },
+	// 		to: { schema, table: tableName, column: it.newColumnName },
+	// 	};
+	// });
+
+	const jsonTableAlternations = alteredTables
+		.map(() => {
+			throw new Error('unexpected');
+		})
+		.flat();
+
+	const jsonCreateIndexesForAllAlteredTables = alteredTables
+		.map((it) => {
+			return prepareCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.addedIndexes || {},
+			);
+		})
+		.flat();
+
+	const jsonDropIndexesForAllAlteredTables = alteredTables
+		.map((it) => {
+			return prepareDropIndexesJson(
+				it.name,
+				it.schema,
+				it.deletedIndexes || {},
+			);
+		})
+		.flat();
+
+	alteredTables.forEach((it) => {
+		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__old;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__new;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+
+		jsonCreateIndexesForAllAlteredTables.push(
+			...prepareCreateIndexesJson(it.name, it.schema, createdIndexes || {}),
+		);
+		jsonDropIndexesForAllAlteredTables.push(
+			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
+		);
+	});
+
+	const jsonCreateReferencesForCreatedTables: JsonCreateReferenceStatement[] = createdTables
+		.map((it) => {
+			return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
+		})
+		.flat();
+
+	const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = alteredTables
+		.map((it) => {
+			const forAdded = prepareCreateReferencesJson(
+				it.name,
+				it.schema,
+				it.addedForeignKeys,
+			);
+
+			const forAltered = prepareDropReferencesJson(
+				it.name,
+				it.schema,
+				it.deletedForeignKeys,
+			);
+
+			const alteredFKs = prepareAlterReferencesJson(
+				it.name,
+				it.schema,
+				it.alteredForeignKeys,
+			);
+
+			return [...forAdded, ...forAltered, ...alteredFKs];
+		})
+		.flat();
+
+	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
+		(t) => t.type === 'create_reference',
+	);
+	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
+		(t) => t.type === 'delete_reference',
+	);
+
+	const jsonMySqlCreateTables = createdTables.map((it) => {
+		return prepareMySqlCreateTableJson(
+			it,
+			curFull as MySqlSchema,
+		);
+	});
+
+	const createViews: JsonCreateMySqlViewStatement[] = [];
+	const dropViews: JsonDropViewStatement[] = [];
+	const renameViews: JsonRenameViewStatement[] = [];
+
+	createViews.push(
+		...createdViews.filter((it) => !it.isExisting).map((it) => {
+			return prepareMySqlCreateViewJson(
+				it.name,
+				it.definition!,
+				it.meta,
+			);
+		}),
+	);
+
+	dropViews.push(
+		...deletedViews.filter((it) => !it.isExisting).map((it) => {
+			return prepareDropViewJson(it.name);
+		}),
+	);
+
+	renameViews.push(
+		...renamedViews.filter((it) => !it.to.isExisting && !json1.views[it.from.name].isExisting).map((it) => {
+			return prepareRenameViewJson(it.to.name, it.from.name);
+		}),
+	);
+
+	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
+
+	for (const alteredView of alteredViews) {
+		const { definition, meta } = json2.views[alteredView.name];
+
+		if (alteredView.alteredExisting) {
+			dropViews.push(prepareDropViewJson(alteredView.name));
+
+			createViews.push(
+				prepareMySqlCreateViewJson(
+					alteredView.name,
+					definition!,
+					meta,
+				),
+			);
+
+			continue;
+		}
+
+		if (alteredView.alteredDefinition && action !== 'push') {
+			createViews.push(
+				prepareMySqlCreateViewJson(
+					alteredView.name,
+					definition!,
+					meta,
+					true,
+				),
+			);
+			continue;
+		}
+
+		if (alteredView.alteredMeta) {
+			throw new Error('unexpected');
+		}
+	}
+
+	jsonStatements.push(...jsonMySqlCreateTables);
+
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...dropViews);
+	jsonStatements.push(...renameViews);
+
+	jsonStatements.push(...jsonDeletedUniqueConstraints);
+	jsonStatements.push(...jsonDeletedCheckConstraints);
+
+	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
+
+	// Will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
+
+	jsonStatements.push(...jsonDeletedCompositePKs);
+	jsonStatements.push(...jsonTableAlternations);
+	jsonStatements.push(...jsonAddedCompositePKs);
+	jsonStatements.push(...jsonAddColumnsStatemets);
+
+	jsonStatements.push(...jsonAddedUniqueConstraints);
+	jsonStatements.push(...jsonDeletedUniqueConstraints);
+
+	jsonStatements.push(...jsonCreateReferencesForCreatedTables);
+	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+
+	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
+	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+
+	// jsonStatements.push(...jsonDeletedCompositePKs);
+	// jsonStatements.push(...jsonAddedCompositePKs);
+	jsonStatements.push(...jsonAlteredCompositePKs);
+
+	jsonStatements.push(...createViews);
+
+	jsonStatements.push(...jsonAlteredUniqueConstraints);
+
+	const sqlStatements = fromJson(jsonStatements, 'mysql');
+
+	// const rTables = renamedTables.map((it) => {
+	// 	return { from: it.from, to: it.to };
+	// });
+
+	return {
+		statements: jsonStatements,
+		sqlStatements,
+		_meta: { columns: [], schemas: [], tables: [] },
+	};
+};
diff --git a/drizzle-kit/src/legacy/mysql-v5/mysqlSchema.ts b/drizzle-kit/src/legacy/mysql-v5/mysqlSchema.ts
new file mode 100644
index 0000000000..5b0005a4ae
--- /dev/null
+++ b/drizzle-kit/src/legacy/mysql-v5/mysqlSchema.ts
@@ -0,0 +1,424 @@
+import type { TypeOf } from 'zod';
+import { any, boolean, enum as enumType, literal, object, record, string, union } from 'zod';
+import { mapValues, originUUID } from '../global';
+
+// ------- V3 --------
+const index = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	using: enumType(['btree', 'hash']).optional(),
+	algorithm: enumType(['default', 'inplace', 'copy']).optional(),
+	lock: enumType(['default', 'none', 'shared', 'exclusive']).optional(),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	autoincrement: boolean().optional(),
+	default: any().optional(),
+	onUpdate: any().optional(),
+	generated: object({
+		type: enumType(['stored', 'virtual', 'persisted']),
+		as: string(),
+	}).optional(),
+}).strict();
+
+const tableV3 = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const tableV4 = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const table = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	checkConstraint: record(string(), checkConstraint).default({}),
+}).strict();
+
+const viewMeta = object({
+	algorithm: enumType(['undefined', 'merge', 'temptable']),
+	sqlSecurity: enumType(['definer', 'invoker']),
+	withCheckOption: enumType(['local', 'cascaded']).optional(),
+}).strict();
+
+export const view = object({
+	name: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	isExisting: boolean(),
+}).strict().merge(viewMeta);
+type SquasherViewMeta = Omit<TypeOf<typeof viewMeta>, 'definer'>;
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isDefaultAnExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+	indexes: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+}).optional();
+
+// use main dialect
+const dialect = literal('mysql');
+
+const schemaHash = object({
+	id: string(),
+	prevId: string(),
+});
+
+export const schemaInternalV3 = object({
+	version: literal('3'),
+	dialect: dialect,
+	tables: record(string(), tableV3),
+}).strict();
+
+export const schemaInternalV4 = object({
+	version: literal('4'),
+	dialect: dialect,
+	tables: record(string(), tableV4),
+	schemas: record(string(), string()),
+}).strict();
+
+export const schemaInternalV5 = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaInternal = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	views: record(string(), view).default({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaV3 = schemaInternalV3.merge(schemaHash);
+export const schemaV4 = schemaInternalV4.merge(schemaHash);
+export const schemaV5 = schemaInternalV5.merge(schemaHash);
+export const schema = schemaInternal.merge(schemaHash);
+
+const tableSquashedV4 = object({
+	name: string(),
+	schema: string().optional(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+}).strict();
+
+const tableSquashed = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()).default({}),
+	checkConstraints: record(string(), string()).default({}),
+}).strict();
+
+const viewSquashed = view.omit({
+	algorithm: true,
+	sqlSecurity: true,
+	withCheckOption: true,
+}).extend({ meta: string() });
+
+export const schemaSquashed = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), tableSquashed),
+	views: record(string(), viewSquashed),
+}).strict();
+
+export const schemaSquashedV4 = object({
+	version: literal('4'),
+	dialect: dialect,
+	tables: record(string(), tableSquashedV4),
+	schemas: record(string(), string()),
+}).strict();
+
+export type Dialect = TypeOf<typeof dialect>;
+export type Column = TypeOf<typeof column>;
+export type Table = TypeOf<typeof table>;
+export type TableV4 = TypeOf<typeof tableV4>;
+export type MySqlSchema = TypeOf<typeof schema>;
+export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
+export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
+export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
+export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
+export type MySqlKitInternals = TypeOf<typeof kitInternals>;
+export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
+export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
+export type Index = TypeOf<typeof index>;
+export type ForeignKey = TypeOf<typeof fk>;
+export type PrimaryKey = TypeOf<typeof compositePK>;
+export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
+export type CheckConstraint = TypeOf<typeof checkConstraint>;
+export type View = TypeOf<typeof view>;
+export type ViewSquashed = TypeOf<typeof viewSquashed>;
+
+export const MySqlSquasher = {
+	squashIdx: (idx: Index) => {
+		index.parse(idx);
+		return `${idx.name};${idx.columns.join(',')};${idx.isUnique};${idx.using ?? ''};${idx.algorithm ?? ''};${
+			idx.lock ?? ''
+		}`;
+	},
+	unsquashIdx: (input: string): Index => {
+		const [name, columnsString, isUnique, using, algorithm, lock] = input.split(';');
+		const destructed = {
+			name,
+			columns: columnsString.split(','),
+			isUnique: isUnique === 'true',
+			using: using ? using : undefined,
+			algorithm: algorithm ? algorithm : undefined,
+			lock: lock ? lock : undefined,
+		};
+		return index.parse(destructed);
+	},
+	squashPK: (pk: PrimaryKey) => {
+		return `${pk.name};${pk.columns.join(',')}`;
+	},
+	unsquashPK: (pk: string): PrimaryKey => {
+		const splitted = pk.split(';');
+		return { name: splitted[0], columns: splitted[1].split(',') };
+	},
+	squashUnique: (unq: UniqueConstraint) => {
+		return `${unq.name};${unq.columns.join(',')}`;
+	},
+	unsquashUnique: (unq: string): UniqueConstraint => {
+		const [name, columns] = unq.split(';');
+		return { name, columns: columns.split(',') };
+	},
+	squashFK: (fk: ForeignKey) => {
+		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
+			fk.onUpdate ?? ''
+		};${fk.onDelete ?? ''}`;
+	},
+	unsquashFK: (input: string): ForeignKey => {
+		const [
+			name,
+			tableFrom,
+			columnsFromStr,
+			tableTo,
+			columnsToStr,
+			onUpdate,
+			onDelete,
+		] = input.split(';');
+
+		const result: ForeignKey = fk.parse({
+			name,
+			tableFrom,
+			columnsFrom: columnsFromStr.split(','),
+			tableTo,
+			columnsTo: columnsToStr.split(','),
+			onUpdate,
+			onDelete,
+		});
+		return result;
+	},
+	squashCheck: (input: CheckConstraint): string => {
+		return `${input.name};${input.value}`;
+	},
+	unsquashCheck: (input: string): CheckConstraint => {
+		const [name, value] = input.split(';');
+
+		return { name, value };
+	},
+	squashView: (view: View): string => {
+		return `${view.algorithm};${view.sqlSecurity};${view.withCheckOption}`;
+	},
+	unsquashView: (meta: string): SquasherViewMeta => {
+		const [algorithm, sqlSecurity, withCheckOption] = meta.split(';');
+		const toReturn = {
+			algorithm: algorithm,
+			sqlSecurity: sqlSecurity,
+			withCheckOption: withCheckOption !== 'undefined' ? withCheckOption : undefined,
+		};
+
+		return viewMeta.parse(toReturn);
+	},
+};
+
+export const squashMysqlSchemeV4 = (
+	json: MySqlSchemaV4,
+): MySqlSchemaSquashedV4 => {
+	const mappedTables = Object.fromEntries(
+		Object.entries(json.tables).map((it) => {
+			const squashedIndexes = mapValues(it[1].indexes, (index) => {
+				return MySqlSquasher.squashIdx(index);
+			});
+
+			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
+				return MySqlSquasher.squashFK(fk);
+			});
+
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					schema: it[1].schema,
+					columns: it[1].columns,
+					indexes: squashedIndexes,
+					foreignKeys: squashedFKs,
+				},
+			];
+		}),
+	);
+	return {
+		version: '4',
+		dialect: json.dialect,
+		tables: mappedTables,
+		schemas: json.schemas,
+	};
+};
+
+export const squashMysqlScheme = (json: MySqlSchema): MySqlSchemaSquashed => {
+	const mappedTables = Object.fromEntries(
+		Object.entries(json.tables).map((it) => {
+			const squashedIndexes = mapValues(it[1].indexes, (index) => {
+				return MySqlSquasher.squashIdx(index);
+			});
+
+			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
+				return MySqlSquasher.squashFK(fk);
+			});
+
+			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+				return MySqlSquasher.squashPK(pk);
+			});
+
+			const squashedUniqueConstraints = mapValues(
+				it[1].uniqueConstraints,
+				(unq) => {
+					return MySqlSquasher.squashUnique(unq);
+				},
+			);
+
+			const squashedCheckConstraints = mapValues(it[1].checkConstraint, (check) => {
+				return MySqlSquasher.squashCheck(check);
+			});
+
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					columns: it[1].columns,
+					indexes: squashedIndexes,
+					foreignKeys: squashedFKs,
+					compositePrimaryKeys: squashedPKs,
+					uniqueConstraints: squashedUniqueConstraints,
+					checkConstraints: squashedCheckConstraints,
+				},
+			];
+		}),
+	);
+
+	const mappedViews = Object.fromEntries(
+		Object.entries(json.views).map(([key, value]) => {
+			const meta = MySqlSquasher.squashView(value);
+
+			return [key, {
+				name: value.name,
+				isExisting: value.isExisting,
+				columns: value.columns,
+				definition: value.definition,
+				meta,
+			}];
+		}),
+	);
+
+	return {
+		version: '5',
+		dialect: json.dialect,
+		tables: mappedTables,
+		views: mappedViews,
+	};
+};
+
+export const mysqlSchema = schema;
+export const mysqlSchemaV3 = schemaV3;
+export const mysqlSchemaV4 = schemaV4;
+export const mysqlSchemaV5 = schemaV5;
+export const mysqlSchemaSquashed = schemaSquashed;
+
+// no prev version
+export const backwardCompatibleMysqlSchema = union([mysqlSchemaV5, schema]);
+
+export const dryMySql = mysqlSchema.parse({
+	version: '5',
+	dialect: 'mysql',
+	id: originUUID,
+	prevId: '',
+	tables: {},
+	schemas: {},
+	views: {},
+	_meta: {
+		schemas: {},
+		tables: {},
+		columns: {},
+	},
+});
diff --git a/drizzle-kit/src/legacy/mysql-v5/mysqlSerializer.ts b/drizzle-kit/src/legacy/mysql-v5/mysqlSerializer.ts
new file mode 100644
index 0000000000..b1a3b429cc
--- /dev/null
+++ b/drizzle-kit/src/legacy/mysql-v5/mysqlSerializer.ts
@@ -0,0 +1,558 @@
+import chalk from 'chalk';
+import { getTableName, is, SQL } from 'orm044';
+import type { AnyMySqlTable, MySqlView } from 'orm044/mysql-core';
+import {
+	getTableConfig,
+	getViewConfig,
+	MySqlColumn,
+	MySqlDialect,
+	type PrimaryKey as PrimaryKeyORM,
+	uniqueKeyName,
+} from 'orm044/mysql-core';
+import type { CasingType } from '../../cli/validations/common';
+import { withStyle } from '../outputs';
+import { escapeSingleQuotes } from '../utils';
+import { getColumnCasing, sqlToStr } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	MySqlKitInternals,
+	MySqlSchemaInternal,
+	PrimaryKey,
+	Table,
+	UniqueConstraint,
+	View,
+} from './mysqlSchema';
+
+export const indexName = (tableName: string, columns: string[]) => {
+	return `${tableName}_${columns.join('_')}_index`;
+};
+
+const handleEnumType = (type: string) => {
+	let str = type.split('(')[1];
+	str = str.substring(0, str.length - 1);
+	const values = str.split(',').map((v) => `'${escapeSingleQuotes(v.substring(1, v.length - 1))}'`);
+	return `enum(${values.join(',')})`;
+};
+
+export const generateMySqlSnapshot = (
+	tables: AnyMySqlTable[],
+	views: MySqlView[],
+	casing: CasingType | undefined,
+): MySqlSchemaInternal => {
+	const dialect = new MySqlDialect({ casing });
+	const result: Record<string, Table> = {};
+	const resultViews: Record<string, View> = {};
+	const internal: MySqlKitInternals = { tables: {}, indexes: {} };
+
+	for (const table of tables) {
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			foreignKeys,
+			schema,
+			checks,
+			primaryKeys,
+			uniqueConstraints,
+		} = getTableConfig(table);
+
+		const columnsObject: Record<string, Column> = {};
+		const indexesObject: Record<string, Index> = {};
+		const foreignKeysObject: Record<string, ForeignKey> = {};
+		const primaryKeysObject: Record<string, PrimaryKey> = {};
+		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
+		const checkConstraintObject: Record<string, CheckConstraint> = {};
+
+		// this object will help to identify same check names
+		let checksInTable: Record<string, string[]> = {};
+
+		columns.forEach((column) => {
+			const name = getColumnCasing(column, casing);
+			const notNull: boolean = column.notNull;
+			const sqlType = column.getSQLType();
+			const sqlTypeLowered = sqlType.toLowerCase();
+			const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
+				? false
+				: (column as any).autoIncrement;
+
+			const generated = column.generated;
+
+			const columnToSet: Column = {
+				name,
+				type: sqlType.startsWith('enum') ? handleEnumType(sqlType) : sqlType,
+				primaryKey: false,
+				// If field is autoincrement it's notNull by default
+				// notNull: autoIncrement ? true : notNull,
+				notNull,
+				autoincrement: autoIncrement,
+				onUpdate: (column as any).hasOnUpdateNow,
+				generated: generated
+					? {
+						as: is(generated.as, SQL)
+							? dialect.sqlToQuery(generated.as as SQL).sql
+							: typeof generated.as === 'function'
+							? dialect.sqlToQuery(generated.as() as SQL).sql
+							: (generated.as as any),
+						type: generated.mode ?? 'stored',
+					}
+					: undefined,
+			};
+
+			if (column.primary) {
+				primaryKeysObject[`${tableName}_${name}`] = {
+					name: `${tableName}_${name}`,
+					columns: [name],
+				};
+			}
+
+			if (column.isUnique) {
+				const existingUnique = uniqueConstraintObject[column.uniqueName!];
+				if (typeof existingUnique !== 'undefined') {
+					console.log(
+						`\n${
+							withStyle.errorWarning(`We've found duplicated unique constraint names in ${
+								chalk.underline.blue(
+									tableName,
+								)
+							} table. 
+          The unique constraint ${
+								chalk.underline.blue(
+									column.uniqueName,
+								)
+							} on the ${
+								chalk.underline.blue(
+									name,
+								)
+							} column is confilcting with a unique constraint name already defined for ${
+								chalk.underline.blue(
+									existingUnique.columns.join(','),
+								)
+							} columns\n`)
+						}`,
+					);
+					process.exit(1);
+				}
+				uniqueConstraintObject[column.uniqueName!] = {
+					name: column.uniqueName!,
+					columns: [columnToSet.name],
+				};
+			}
+
+			if (column.default !== undefined) {
+				if (is(column.default, SQL)) {
+					columnToSet.default = sqlToStr(column.default, casing);
+				} else {
+					if (typeof column.default === 'string') {
+						columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
+					} else {
+						if (sqlTypeLowered === 'json') {
+							columnToSet.default = `'${JSON.stringify(column.default)}'`;
+						} else if (column.default instanceof Date) {
+							if (sqlTypeLowered === 'date') {
+								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
+							} else if (
+								sqlTypeLowered.startsWith('datetime')
+								|| sqlTypeLowered.startsWith('timestamp')
+							) {
+								columnToSet.default = `'${
+									column.default
+										.toISOString()
+										.replace('T', ' ')
+										.slice(0, 23)
+								}'`;
+							}
+						} else {
+							columnToSet.default = column.default;
+						}
+					}
+					if (['blob', 'text', 'json'].includes(column.getSQLType())) {
+						columnToSet.default = `(${columnToSet.default})`;
+					}
+				}
+			}
+			columnsObject[name] = columnToSet;
+		});
+
+		primaryKeys.map((pk: PrimaryKeyORM) => {
+			const originalColumnNames = pk.columns.map((c) => c.name);
+			const columnNames = pk.columns.map((c: any) => getColumnCasing(c, casing));
+
+			let name = pk.getName();
+			if (casing !== undefined) {
+				for (let i = 0; i < originalColumnNames.length; i++) {
+					name = name.replace(originalColumnNames[i], columnNames[i]);
+				}
+			}
+
+			primaryKeysObject[name] = {
+				name,
+				columns: columnNames,
+			};
+
+			// all composite pk's should be treated as notNull
+			for (const column of pk.columns) {
+				columnsObject[getColumnCasing(column, casing)].notNull = true;
+			}
+		});
+
+		uniqueConstraints?.map((unq) => {
+			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
+
+			const name = unq.name ?? uniqueKeyName(table, columnNames);
+
+			const existingUnique = uniqueConstraintObject[name];
+			if (typeof existingUnique !== 'undefined') {
+				console.log(
+					`\n${
+						withStyle.errorWarning(
+							`We've found duplicated unique constraint names in ${
+								chalk.underline.blue(
+									tableName,
+								)
+							} table. \nThe unique constraint ${
+								chalk.underline.blue(
+									name,
+								)
+							} on the ${
+								chalk.underline.blue(
+									columnNames.join(','),
+								)
+							} columns is confilcting with a unique constraint name already defined for ${
+								chalk.underline.blue(
+									existingUnique.columns.join(','),
+								)
+							} columns\n`,
+						)
+					}`,
+				);
+				process.exit(1);
+			}
+
+			uniqueConstraintObject[name] = {
+				name: unq.name!,
+				columns: columnNames,
+			};
+		});
+
+		const fks: ForeignKey[] = foreignKeys.map((fk) => {
+			const tableFrom = tableName;
+			const onDelete = fk.onDelete ?? 'no action';
+			const onUpdate = fk.onUpdate ?? 'no action';
+			const reference = fk.reference();
+
+			const referenceFT = reference.foreignTable;
+
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			const tableTo = getTableName(referenceFT);
+
+			const originalColumnsFrom = reference.columns.map((it) => it.name);
+			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
+			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
+
+			let name = fk.getName();
+			if (casing !== undefined) {
+				for (let i = 0; i < originalColumnsFrom.length; i++) {
+					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
+				}
+				for (let i = 0; i < originalColumnsTo.length; i++) {
+					name = name.replace(originalColumnsTo[i], columnsTo[i]);
+				}
+			}
+
+			return {
+				name,
+				tableFrom,
+				tableTo,
+				columnsFrom,
+				columnsTo,
+				onDelete,
+				onUpdate,
+			} as ForeignKey;
+		});
+
+		fks.forEach((it) => {
+			foreignKeysObject[it.name] = it;
+		});
+
+		indexes.forEach((value) => {
+			const columns = value.config.columns;
+			const name = value.config.name;
+
+			let indexColumns = columns.map((it) => {
+				if (is(it, SQL)) {
+					const sql = dialect.sqlToQuery(it, 'indexes').sql;
+					if (typeof internal!.indexes![name] === 'undefined') {
+						internal!.indexes![name] = {
+							columns: {
+								[sql]: {
+									isExpression: true,
+								},
+							},
+						};
+					} else {
+						if (typeof internal!.indexes![name]?.columns[sql] === 'undefined') {
+							internal!.indexes![name]!.columns[sql] = {
+								isExpression: true,
+							};
+						} else {
+							internal!.indexes![name]!.columns[sql]!.isExpression = true;
+						}
+					}
+					return sql;
+				} else {
+					return `${getColumnCasing(it, casing)}`;
+				}
+			});
+
+			if (value.config.unique) {
+				if (typeof uniqueConstraintObject[name] !== 'undefined') {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`We've found duplicated unique constraint names in ${
+									chalk.underline.blue(
+										tableName,
+									)
+								} table. \nThe unique index ${
+									chalk.underline.blue(
+										name,
+									)
+								} on the ${
+									chalk.underline.blue(
+										indexColumns.join(','),
+									)
+								} columns is confilcting with a unique constraint name already defined for ${
+									chalk.underline.blue(
+										uniqueConstraintObject[name].columns.join(','),
+									)
+								} columns\n`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+			} else {
+				if (typeof foreignKeysObject[name] !== 'undefined') {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`In MySQL, when creating a foreign key, an index is automatically generated with the same name as the foreign key constraint.\n\nWe have encountered a collision between the index name on columns ${
+									chalk.underline.blue(
+										indexColumns.join(','),
+									)
+								} and the foreign key on columns ${
+									chalk.underline.blue(
+										foreignKeysObject[name].columnsFrom.join(','),
+									)
+								}. Please change either the index name or the foreign key name. For more information, please refer to https://dev.mysql.com/doc/refman/8.0/en/constraint-foreign-key.html\n
+            `,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+			}
+
+			indexesObject[name] = {
+				name,
+				columns: indexColumns,
+				isUnique: value.config.unique ?? false,
+				using: value.config.using,
+				algorithm: value.config.algorythm,
+				lock: value.config.lock,
+			};
+		});
+
+		checks.forEach((check) => {
+			const checkName = check.name;
+			if (typeof checksInTable[tableName] !== 'undefined') {
+				if (checksInTable[tableName].includes(check.name)) {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`We've found duplicated check constraint name in ${
+									chalk.underline.blue(
+										tableName,
+									)
+								}. Please rename your check constraint in the ${
+									chalk.underline.blue(
+										tableName,
+									)
+								} table`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+				checksInTable[tableName].push(checkName);
+			} else {
+				checksInTable[tableName] = [check.name];
+			}
+
+			checkConstraintObject[checkName] = {
+				name: checkName,
+				value: dialect.sqlToQuery(check.value).sql,
+			};
+		});
+
+		// only handle tables without schemas
+		if (!schema) {
+			result[tableName] = {
+				name: tableName,
+				columns: columnsObject,
+				indexes: indexesObject,
+				foreignKeys: foreignKeysObject,
+				compositePrimaryKeys: primaryKeysObject,
+				uniqueConstraints: uniqueConstraintObject,
+				checkConstraint: checkConstraintObject,
+			};
+		}
+	}
+
+	for (const view of views) {
+		const {
+			isExisting,
+			name,
+			query,
+			schema,
+			selectedFields,
+			algorithm,
+			sqlSecurity,
+			withCheckOption,
+		} = getViewConfig(view);
+
+		const columnsObject: Record<string, Column> = {};
+
+		const existingView = resultViews[name];
+		if (typeof existingView !== 'undefined') {
+			console.log(
+				`\n${
+					withStyle.errorWarning(
+						`We've found duplicated view name across ${
+							chalk.underline.blue(
+								schema ?? 'public',
+							)
+						} schema. Please rename your view`,
+					)
+				}`,
+			);
+			process.exit(1);
+		}
+
+		for (const key in selectedFields) {
+			if (is(selectedFields[key], MySqlColumn)) {
+				const column = selectedFields[key];
+
+				const notNull: boolean = column.notNull;
+				const sqlTypeLowered = column.getSQLType().toLowerCase();
+				const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
+					? false
+					: (column as any).autoIncrement;
+
+				const generated = column.generated;
+
+				const columnToSet: Column = {
+					name: column.name,
+					type: column.getSQLType(),
+					primaryKey: false,
+					// If field is autoincrement it's notNull by default
+					// notNull: autoIncrement ? true : notNull,
+					notNull,
+					autoincrement: autoIncrement,
+					onUpdate: (column as any).hasOnUpdateNow,
+					generated: generated
+						? {
+							as: is(generated.as, SQL)
+								? dialect.sqlToQuery(generated.as as SQL).sql
+								: typeof generated.as === 'function'
+								? dialect.sqlToQuery(generated.as() as SQL).sql
+								: (generated.as as any),
+							type: generated.mode ?? 'stored',
+						}
+						: undefined,
+				};
+
+				if (column.default !== undefined) {
+					if (is(column.default, SQL)) {
+						columnToSet.default = sqlToStr(column.default, casing);
+					} else {
+						if (typeof column.default === 'string') {
+							columnToSet.default = `'${column.default}'`;
+						} else {
+							if (sqlTypeLowered === 'json') {
+								columnToSet.default = `'${JSON.stringify(column.default)}'`;
+							} else if (column.default instanceof Date) {
+								if (sqlTypeLowered === 'date') {
+									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
+								} else if (
+									sqlTypeLowered.startsWith('datetime')
+									|| sqlTypeLowered.startsWith('timestamp')
+								) {
+									columnToSet.default = `'${
+										column.default
+											.toISOString()
+											.replace('T', ' ')
+											.slice(0, 23)
+									}'`;
+								}
+							} else {
+								columnToSet.default = column.default;
+							}
+						}
+						if (['blob', 'text', 'json'].includes(column.getSQLType())) {
+							columnToSet.default = `(${columnToSet.default})`;
+						}
+					}
+				}
+				columnsObject[column.name] = columnToSet;
+			}
+		}
+
+		resultViews[name] = {
+			columns: columnsObject,
+			name,
+			isExisting,
+			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
+			withCheckOption,
+			algorithm: algorithm ?? 'undefined', // set default values
+			sqlSecurity: sqlSecurity ?? 'definer', // set default values
+		};
+	}
+
+	return {
+		version: '5',
+		dialect: 'mysql',
+		tables: result,
+		views: resultViews,
+		_meta: {
+			tables: {},
+			columns: {},
+		},
+		internal,
+	};
+};
+
+// function clearDefaults(defaultValue: any, collate: string) {
+// 	if (typeof collate === 'undefined' || collate === null) {
+// 		collate = `utf8mb4`;
+// 	}
+
+// 	let resultDefault = defaultValue;
+// 	collate = `_${collate}`;
+// 	if (defaultValue.startsWith(collate)) {
+// 		resultDefault = resultDefault
+// 			.substring(collate.length, defaultValue.length)
+// 			.replace(/\\/g, '');
+// 		if (resultDefault.startsWith("'") && resultDefault.endsWith("'")) {
+// 			return `('${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}')`;
+// 		} else {
+// 			return `'${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}'`;
+// 		}
+// 	} else {
+// 		return `(${resultDefault})`;
+// 	}
+// }
diff --git a/drizzle-kit/src/legacy/mysql-v5/serializer.ts b/drizzle-kit/src/legacy/mysql-v5/serializer.ts
new file mode 100644
index 0000000000..2a4a467ac7
--- /dev/null
+++ b/drizzle-kit/src/legacy/mysql-v5/serializer.ts
@@ -0,0 +1,30 @@
+import { is } from 'orm044';
+import { MySqlTable, MySqlView } from 'orm044/mysql-core';
+import type { CasingType } from '../common';
+import type { MySqlSchema as SCHEMA } from './mysqlSchema';
+import { generateMySqlSnapshot } from './mysqlSerializer';
+
+export type MysqlSchema = Record<
+	string,
+	| MySqlTable<any>
+	| MySqlView
+	| unknown
+>;
+
+export const serializeMysql = async (
+	schema: MysqlSchema,
+	casing: CasingType | undefined,
+): Promise<SCHEMA> => {
+	const tables = Object.values(schema).filter((it) => is(it, MySqlTable)) as MySqlTable[];
+	const views = Object.values(schema).filter((it) => is(it, MySqlView)) as MySqlView[];
+	const snapshot = generateMySqlSnapshot(
+		tables,
+		views,
+		casing,
+	);
+	return {
+		id: 'id',
+		prevId: 'prev_id',
+		...snapshot,
+	};
+};
diff --git a/drizzle-kit/src/legacy/outputs.ts b/drizzle-kit/src/legacy/outputs.ts
new file mode 100644
index 0000000000..6e9d520dd6
--- /dev/null
+++ b/drizzle-kit/src/legacy/outputs.ts
@@ -0,0 +1,91 @@
+import chalk from 'chalk';
+import { sqliteDriversLiterals } from './common';
+
+export const withStyle = {
+	error: (str: string) => `${chalk.red(`${chalk.white.bgRed(' Invalid input ')} ${str}`)}`,
+	warning: (str: string) => `${chalk.white.bgGray(' Warning ')} ${str}`,
+	errorWarning: (str: string) => `${chalk.red(`${chalk.white.bgRed(' Warning ')} ${str}`)}`,
+	fullWarning: (str: string) => `${chalk.black.bgYellow(' Warning ')} ${chalk.bold(str)}`,
+	suggestion: (str: string) => `${chalk.white.bgGray(' Suggestion ')} ${str}`,
+	info: (str: string) => `${chalk.grey(str)}`,
+};
+
+export const outputs = {
+	studio: {
+		drivers: (param: string) =>
+			withStyle.error(
+				`"${param}" is not a valid driver. Available drivers: "pg", "mysql2", "better-sqlite", "libsql", "turso". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+			),
+		noCredentials: () =>
+			withStyle.error(
+				`Please specify a 'dbCredentials' param in config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+			),
+		noDriver: () =>
+			withStyle.error(
+				`Please specify a 'driver' param in config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+			),
+		noDialect: () =>
+			withStyle.error(
+				`Please specify 'dialect' param in config, either of 'postgresql', 'mysql', 'sqlite', turso or singlestore`,
+			),
+	},
+	common: {
+		ambiguousParams: (command: string) =>
+			withStyle.error(
+				`You can't use both --config and other cli options for ${command} command`,
+			),
+		schema: (command: string) => withStyle.error(`"--schema" is a required field for ${command} command`),
+	},
+	postgres: {
+		connection: {
+			required: () =>
+				withStyle.error(
+					`Either "url" or "host", "database" are required for database connection`,
+				),
+			awsDataApi: () =>
+				withStyle.error(
+					"You need to provide 'database', 'secretArn' and 'resourceArn' for Drizzle Kit to connect to AWS Data API",
+				),
+		},
+	},
+	mysql: {
+		connection: {
+			driver: () => withStyle.error(`Only "mysql2" is available options for "--driver"`),
+			required: () =>
+				withStyle.error(
+					`Either "url" or "host", "database" are required for database connection`,
+				),
+		},
+	},
+	sqlite: {
+		connection: {
+			driver: () => {
+				const listOfDrivers = sqliteDriversLiterals
+					.map((it) => `'${it.value}'`)
+					.join(', ');
+				return withStyle.error(
+					`Either ${listOfDrivers} are available options for 'driver' param`,
+				);
+			},
+			url: (driver: string) =>
+				withStyle.error(
+					`"url" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+				),
+			authToken: (driver: string) =>
+				withStyle.error(
+					`"authToken" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+				),
+		},
+		introspect: {},
+		push: {},
+	},
+	singlestore: {
+		connection: {
+			driver: () => withStyle.error(`Only "mysql2" is available options for "--driver"`),
+			required: () =>
+				withStyle.error(
+					`Either "url" or "host", "database" are required for database connection`,
+				),
+		},
+	},
+};
diff --git a/drizzle-kit/src/legacy/postgres-v7/pgDiff.ts b/drizzle-kit/src/legacy/postgres-v7/pgDiff.ts
new file mode 100644
index 0000000000..e2fd6e95b5
--- /dev/null
+++ b/drizzle-kit/src/legacy/postgres-v7/pgDiff.ts
@@ -0,0 +1,1725 @@
+import { mapEntries, mapKeys, mapValues } from '../global';
+import { applyJsonDiff, diffColumns, diffIndPolicies, diffPolicies, diffSchemasOrTables } from '../jsonDiffer';
+import type {
+	JsonAddColumnStatement,
+	JsonAlterCompositePK,
+	JsonAlterIndPolicyStatement,
+	JsonAlterPolicyStatement,
+	JsonAlterTableSetSchema,
+	JsonAlterUniqueConstraint,
+	JsonAlterViewStatement,
+	JsonCreateCheckConstraint,
+	JsonCreateCompositePK,
+	JsonCreateIndPolicyStatement,
+	JsonCreatePgViewStatement,
+	JsonCreatePolicyStatement,
+	JsonCreateReferenceStatement,
+	JsonCreateUniqueConstraint,
+	JsonDeleteCheckConstraint,
+	JsonDeleteCompositePK,
+	JsonDeleteUniqueConstraint,
+	JsonDisableRLSStatement,
+	JsonDropColumnStatement,
+	JsonDropIndPolicyStatement,
+	JsonDropPolicyStatement,
+	JsonDropViewStatement,
+	JsonEnableRLSStatement,
+	JsonIndRenamePolicyStatement,
+	JsonReferenceStatement,
+	JsonRenameColumnStatement,
+	JsonRenamePolicyStatement,
+	JsonRenameViewStatement,
+	JsonStatement,
+} from '../jsonStatements';
+import {
+	_prepareAddColumns,
+	_prepareDropColumns,
+	prepareAddCheckConstraint,
+	prepareAddCompositePrimaryKeyPg,
+	prepareAddUniqueConstraintPg,
+	prepareAddValuesToEnumJson,
+	prepareAlterCompositePrimaryKeyPg,
+	prepareAlterIndPolicyJson,
+	prepareAlterPolicyJson,
+	prepareAlterReferencesJson,
+	prepareAlterRoleJson,
+	prepareAlterSequenceJson,
+	prepareCreateEnumJson,
+	prepareCreateIndPolicyJsons,
+	prepareCreatePolicyJsons,
+	prepareCreateReferencesJson,
+	prepareCreateRoleJson,
+	prepareCreateSchemasJson,
+	prepareCreateSequenceJson,
+	prepareDeleteCheckConstraint,
+	prepareDeleteCompositePrimaryKeyPg,
+	prepareDeleteSchemasJson,
+	prepareDeleteUniqueConstraintPg,
+	prepareDropEnumJson,
+	prepareDropEnumValues,
+	prepareDropIndexesJson,
+	prepareDropIndPolicyJsons,
+	prepareDropPolicyJsons,
+	prepareDropReferencesJson,
+	prepareDropRoleJson,
+	prepareDropSequenceJson,
+	prepareDropTableJson,
+	prepareDropViewJson,
+	prepareMoveEnumJson,
+	prepareMoveSequenceJson,
+	preparePgAlterColumns,
+	preparePgAlterViewAddWithOptionJson,
+	preparePgAlterViewAlterSchemaJson,
+	preparePgAlterViewAlterTablespaceJson,
+	preparePgAlterViewAlterUsingJson,
+	preparePgAlterViewDropWithOptionJson,
+	preparePgCreateIndexesJson,
+	preparePgCreateTableJson,
+	preparePgCreateViewJson,
+	prepareRenameColumns,
+	prepareRenameEnumJson,
+	prepareRenameIndPolicyJsons,
+	prepareRenamePolicyJsons,
+	prepareRenameRoleJson,
+	prepareRenameSchemasJson,
+	prepareRenameSequenceJson,
+	prepareRenameTableJson,
+	prepareRenameViewJson,
+} from '../jsonStatements';
+import { copy } from '../utils';
+
+import type {
+	Column,
+	ColumnsResolverInput,
+	ColumnsResolverOutput,
+	DiffResult,
+	Enum,
+	Named,
+	PolicyResolverInput,
+	PolicyResolverOutput,
+	ResolverInput,
+	ResolverOutput,
+	ResolverOutputWithMoved,
+	RolesResolverInput,
+	RolesResolverOutput,
+	Sequence,
+	Table,
+	TablePolicyResolverInput,
+	TablePolicyResolverOutput,
+} from '../snapshotsDiffer';
+import {
+	columnChangeFor,
+	columnsResolver,
+	diffResultScheme,
+	enumsResolver,
+	indPolicyResolver,
+	nameChangeFor,
+	nameSchemaChangeFor,
+	policyResolver,
+	roleResolver,
+	schemaChangeFor,
+	schemasResolver,
+	sequencesResolver,
+	tablesResolver,
+	viewsResolver,
+} from '../snapshotsDiffer';
+import { fromJson } from '../sqlgenerator';
+import type { PgSchema, PgSchemaSquashed, Policy, Role, View } from './pgSchema';
+import { dryPg, PgSquasher, squashPgScheme } from './pgSchema';
+
+export const diff = async (opts: {
+	left?: PgSchema;
+	right: PgSchema;
+	mode?: 'push';
+}) => {
+	const left = opts.left ?? dryPg;
+	const json1 = squashPgScheme(left);
+	const json2 = squashPgScheme(opts.right);
+	return _diff(
+		json1,
+		json2,
+		schemasResolver,
+		enumsResolver,
+		sequencesResolver,
+		policyResolver,
+		indPolicyResolver,
+		roleResolver,
+		tablesResolver,
+		columnsResolver,
+		viewsResolver,
+		left,
+		opts.right,
+		opts.mode,
+	);
+};
+
+export const _diff = async (
+	json1: PgSchemaSquashed,
+	json2: PgSchemaSquashed,
+	schemasResolver: (
+		input: ResolverInput<Named>,
+	) => Promise<ResolverOutput<Named>>,
+	enumsResolver: (
+		input: ResolverInput<Enum>,
+	) => Promise<ResolverOutputWithMoved<Enum>>,
+	sequencesResolver: (
+		input: ResolverInput<Sequence>,
+	) => Promise<ResolverOutputWithMoved<Sequence>>,
+	policyResolver: (
+		input: TablePolicyResolverInput<Policy>,
+	) => Promise<TablePolicyResolverOutput<Policy>>,
+	indPolicyResolver: (
+		input: PolicyResolverInput<Policy>,
+	) => Promise<PolicyResolverOutput<Policy>>,
+	roleResolver: (
+		input: RolesResolverInput<Role>,
+	) => Promise<RolesResolverOutput<Role>>,
+	tablesResolver: (
+		input: ResolverInput<Table>,
+	) => Promise<ResolverOutputWithMoved<Table>>,
+	columnsResolver: (
+		input: ColumnsResolverInput<Column>,
+	) => Promise<ColumnsResolverOutput<Column>>,
+	viewsResolver: (
+		input: ResolverInput<View>,
+	) => Promise<ResolverOutputWithMoved<View>>,
+	prevFull: PgSchema,
+	curFull: PgSchema,
+	action?: 'push' | undefined,
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	_meta:
+		| {
+			schemas: {};
+			tables: {};
+			columns: {};
+		}
+		| undefined;
+}> => {
+	const schemasDiff = diffSchemasOrTables(json1.schemas, json2.schemas);
+
+	const {
+		created: createdSchemas,
+		deleted: deletedSchemas,
+		renamed: renamedSchemas,
+	} = await schemasResolver({
+		created: schemasDiff.added.map((it) => ({ name: it })),
+		deleted: schemasDiff.deleted.map((it) => ({ name: it })),
+	});
+
+	const schemasPatchedSnap1 = copy(json1);
+	schemasPatchedSnap1.tables = mapEntries(
+		schemasPatchedSnap1.tables,
+		(_, it) => {
+			const { key, schema } = schemaChangeFor(it, renamedSchemas);
+			it.schema = schema;
+			return [key, it];
+		},
+	);
+
+	schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_, it) => {
+		const { key, schema } = schemaChangeFor(it, renamedSchemas);
+		it.schema = schema;
+		return [key, it];
+	});
+
+	const enumsDiff = diffSchemasOrTables(schemasPatchedSnap1.enums, json2.enums);
+
+	const {
+		created: createdEnums,
+		deleted: deletedEnums,
+		renamed: renamedEnums,
+		moved: movedEnums,
+	} = await enumsResolver({
+		created: enumsDiff.added,
+		deleted: enumsDiff.deleted,
+	});
+
+	schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_, it) => {
+		const { key, name, schema } = nameSchemaChangeFor(it, renamedEnums);
+		it.name = name;
+		it.schema = schema;
+		return [key, it];
+	});
+
+	const columnTypesChangeMap = renamedEnums.reduce(
+		(acc, it) => {
+			acc[`${it.from.schema}.${it.from.name}`] = {
+				nameFrom: it.from.name,
+				nameTo: it.to.name,
+				schemaFrom: it.from.schema,
+				schemaTo: it.to.schema,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+				schemaFrom: string;
+				schemaTo: string;
+			}
+		>,
+	);
+
+	const columnTypesMovesMap = movedEnums.reduce(
+		(acc, it) => {
+			acc[`${it.schemaFrom}.${it.name}`] = {
+				nameFrom: it.name,
+				nameTo: it.name,
+				schemaFrom: it.schemaFrom,
+				schemaTo: it.schemaTo,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+				schemaFrom: string;
+				schemaTo: string;
+			}
+		>,
+	);
+
+	schemasPatchedSnap1.tables = mapEntries(
+		schemasPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedColumns = mapValues(tableValue.columns, (column) => {
+				const key = `${column.typeSchema || 'public'}.${column.type}`;
+				const change = columnTypesChangeMap[key] || columnTypesMovesMap[key];
+
+				if (change) {
+					column.type = change.nameTo;
+					column.typeSchema = change.schemaTo;
+				}
+
+				return column;
+			});
+
+			tableValue.columns = patchedColumns;
+			return [tableKey, tableValue];
+		},
+	);
+
+	schemasPatchedSnap1.sequences = mapEntries(
+		schemasPatchedSnap1.sequences,
+		(_, it) => {
+			const { key, schema } = schemaChangeFor(it, renamedSchemas);
+			it.schema = schema;
+			return [key, it];
+		},
+	);
+
+	const sequencesDiff = diffSchemasOrTables(
+		schemasPatchedSnap1.sequences,
+		json2.sequences,
+	);
+
+	const {
+		created: createdSequences,
+		deleted: deletedSequences,
+		renamed: renamedSequences,
+		moved: movedSequences,
+	} = await sequencesResolver({
+		created: sequencesDiff.added,
+		deleted: sequencesDiff.deleted,
+	});
+
+	schemasPatchedSnap1.sequences = mapEntries(
+		schemasPatchedSnap1.sequences,
+		(_, it) => {
+			const { key, name, schema } = nameSchemaChangeFor(it, renamedSequences);
+			it.name = name;
+			it.schema = schema;
+			return [key, it];
+		},
+	);
+
+	const sequencesChangeMap = renamedSequences.reduce(
+		(acc, it) => {
+			acc[`${it.from.schema}.${it.from.name}`] = {
+				nameFrom: it.from.name,
+				nameTo: it.to.name,
+				schemaFrom: it.from.schema,
+				schemaTo: it.to.schema,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+				schemaFrom: string;
+				schemaTo: string;
+			}
+		>,
+	);
+
+	const sequencesMovesMap = movedSequences.reduce(
+		(acc, it) => {
+			acc[`${it.schemaFrom}.${it.name}`] = {
+				nameFrom: it.name,
+				nameTo: it.name,
+				schemaFrom: it.schemaFrom,
+				schemaTo: it.schemaTo,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+				schemaFrom: string;
+				schemaTo: string;
+			}
+		>,
+	);
+
+	schemasPatchedSnap1.tables = mapEntries(
+		schemasPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedColumns = mapValues(tableValue.columns, (column) => {
+				const key = `${column.typeSchema || 'public'}.${column.type}`;
+				const change = sequencesChangeMap[key] || sequencesMovesMap[key];
+
+				if (change) {
+					column.type = change.nameTo;
+					column.typeSchema = change.schemaTo;
+				}
+
+				return column;
+			});
+
+			tableValue.columns = patchedColumns;
+			return [tableKey, tableValue];
+		},
+	);
+
+	const rolesDiff = diffSchemasOrTables(
+		schemasPatchedSnap1.roles,
+		json2.roles,
+	);
+
+	const {
+		created: createdRoles,
+		deleted: deletedRoles,
+		renamed: renamedRoles,
+	} = await roleResolver({
+		created: rolesDiff.added,
+		deleted: rolesDiff.deleted,
+	});
+
+	schemasPatchedSnap1.roles = mapEntries(
+		schemasPatchedSnap1.roles,
+		(_, it) => {
+			const { name } = nameChangeFor(it, renamedRoles);
+			it.name = name;
+			return [name, it];
+		},
+	);
+
+	const rolesChangeMap = renamedRoles.reduce(
+		(acc, it) => {
+			acc[it.from.name] = {
+				nameFrom: it.from.name,
+				nameTo: it.to.name,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+			}
+		>,
+	);
+
+	schemasPatchedSnap1.roles = mapEntries(
+		schemasPatchedSnap1.roles,
+		(roleKey, roleValue) => {
+			const key = roleKey;
+			const change = rolesChangeMap[key];
+
+			if (change) {
+				roleValue.name = change.nameTo;
+			}
+
+			return [roleKey, roleValue];
+		},
+	);
+
+	const tablesDiff = diffSchemasOrTables(
+		schemasPatchedSnap1.tables as Record<string, any>,
+		json2.tables,
+	);
+
+	const {
+		created: createdTables,
+		deleted: deletedTables,
+		moved: movedTables,
+		renamed: renamedTables, // renamed or moved
+	} = await tablesResolver({
+		created: tablesDiff.added,
+		deleted: tablesDiff.deleted,
+	});
+
+	const tablesPatchedSnap1 = copy(schemasPatchedSnap1);
+	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
+		const { key, name, schema } = nameSchemaChangeFor(it, renamedTables);
+		it.name = name;
+		it.schema = schema;
+		return [key, it];
+	});
+
+	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
+
+	const columnRenames = [] as {
+		table: string;
+		schema: string;
+		renames: { from: Column; to: Column }[];
+	}[];
+
+	const columnCreates = [] as {
+		table: string;
+		schema: string;
+		columns: Column[];
+	}[];
+
+	const columnDeletes = [] as {
+		table: string;
+		schema: string;
+		columns: Column[];
+	}[];
+
+	for (let entry of Object.values(res)) {
+		const { renamed, created, deleted } = await columnsResolver({
+			tableName: entry.name,
+			schema: entry.schema,
+			deleted: entry.columns.deleted,
+			created: entry.columns.added,
+		});
+
+		if (created.length > 0) {
+			columnCreates.push({
+				table: entry.name,
+				schema: entry.schema,
+				columns: created,
+			});
+		}
+
+		if (deleted.length > 0) {
+			columnDeletes.push({
+				table: entry.name,
+				schema: entry.schema,
+				columns: deleted,
+			});
+		}
+
+		if (renamed.length > 0) {
+			columnRenames.push({
+				table: entry.name,
+				schema: entry.schema,
+				renames: renamed,
+			});
+		}
+	}
+
+	const columnRenamesDict = columnRenames.reduce(
+		(acc, it) => {
+			acc[`${it.schema || 'public'}.${it.table}`] = it.renames;
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				from: Named;
+				to: Named;
+			}[]
+		>,
+	);
+
+	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
+	columnsPatchedSnap1.tables = mapEntries(
+		columnsPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedColumns = mapKeys(
+				tableValue.columns,
+				(columnKey, column) => {
+					const rens = columnRenamesDict[
+						`${tableValue.schema || 'public'}.${tableValue.name}`
+					] || [];
+
+					const newName = columnChangeFor(columnKey, rens);
+					column.name = newName;
+					return newName;
+				},
+			);
+
+			tableValue.columns = patchedColumns;
+			return [tableKey, tableValue];
+		},
+	);
+
+	//// Policies
+
+	const policyRes = diffPolicies(tablesPatchedSnap1.tables, json2.tables);
+
+	const policyRenames = [] as {
+		table: string;
+		schema: string;
+		renames: { from: Policy; to: Policy }[];
+	}[];
+
+	const policyCreates = [] as {
+		table: string;
+		schema: string;
+		columns: Policy[];
+	}[];
+
+	const policyDeletes = [] as {
+		table: string;
+		schema: string;
+		columns: Policy[];
+	}[];
+
+	for (let entry of Object.values(policyRes)) {
+		const { renamed, created, deleted } = await policyResolver({
+			tableName: entry.name,
+			schema: entry.schema,
+			deleted: entry.policies.deleted.map(
+				action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy,
+			),
+			created: entry.policies.added.map(action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy),
+		});
+
+		if (created.length > 0) {
+			policyCreates.push({
+				table: entry.name,
+				schema: entry.schema,
+				columns: created,
+			});
+		}
+
+		if (deleted.length > 0) {
+			policyDeletes.push({
+				table: entry.name,
+				schema: entry.schema,
+				columns: deleted,
+			});
+		}
+
+		if (renamed.length > 0) {
+			policyRenames.push({
+				table: entry.name,
+				schema: entry.schema,
+				renames: renamed,
+			});
+		}
+	}
+
+	const policyRenamesDict = columnRenames.reduce(
+		(acc, it) => {
+			acc[`${it.schema || 'public'}.${it.table}`] = it.renames;
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				from: Named;
+				to: Named;
+			}[]
+		>,
+	);
+
+	const policyPatchedSnap1 = copy(tablesPatchedSnap1);
+	policyPatchedSnap1.tables = mapEntries(
+		policyPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedPolicies = mapKeys(
+				tableValue.policies,
+				(policyKey, policy) => {
+					const rens = policyRenamesDict[
+						`${tableValue.schema || 'public'}.${tableValue.name}`
+					] || [];
+
+					const newName = columnChangeFor(policyKey, rens);
+					const unsquashedPolicy = action === 'push'
+						? PgSquasher.unsquashPolicyPush(policy)
+						: PgSquasher.unsquashPolicy(policy);
+					unsquashedPolicy.name = newName;
+					policy = PgSquasher.squashPolicy(unsquashedPolicy);
+					return newName;
+				},
+			);
+
+			tableValue.policies = patchedPolicies;
+			return [tableKey, tableValue];
+		},
+	);
+
+	//// Individual policies
+
+	const indPolicyRes = diffIndPolicies(policyPatchedSnap1.policies, json2.policies);
+
+	const indPolicyCreates = [] as {
+		policies: Policy[];
+	}[];
+
+	const indPolicyDeletes = [] as {
+		policies: Policy[];
+	}[];
+
+	const { renamed: indPolicyRenames, created, deleted } = await indPolicyResolver({
+		deleted: indPolicyRes.deleted.map((t) =>
+			action === 'push' ? PgSquasher.unsquashPolicyPush(t.values) : PgSquasher.unsquashPolicy(t.values)
+		),
+		created: indPolicyRes.added.map((t) =>
+			action === 'push' ? PgSquasher.unsquashPolicyPush(t.values) : PgSquasher.unsquashPolicy(t.values)
+		),
+	});
+
+	if (created.length > 0) {
+		indPolicyCreates.push({
+			policies: created,
+		});
+	}
+
+	if (deleted.length > 0) {
+		indPolicyDeletes.push({
+			policies: deleted,
+		});
+	}
+
+	const indPolicyRenamesDict = indPolicyRenames.reduce(
+		(acc, it) => {
+			acc[it.from.name] = {
+				nameFrom: it.from.name,
+				nameTo: it.to.name,
+			};
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				nameFrom: string;
+				nameTo: string;
+			}
+		>,
+	);
+
+	const indPolicyPatchedSnap1 = copy(policyPatchedSnap1);
+	indPolicyPatchedSnap1.policies = mapEntries(
+		indPolicyPatchedSnap1.policies,
+		(policyKey, policyValue) => {
+			const key = policyKey;
+			const change = indPolicyRenamesDict[key];
+
+			if (change) {
+				policyValue.name = change.nameTo;
+			}
+
+			return [policyKey, policyValue];
+		},
+	);
+
+	////
+	const viewsDiff = diffSchemasOrTables(indPolicyPatchedSnap1.views, json2.views);
+
+	const {
+		created: createdViews,
+		deleted: deletedViews,
+		renamed: renamedViews,
+		moved: movedViews,
+	} = await viewsResolver({
+		created: viewsDiff.added,
+		deleted: viewsDiff.deleted,
+	});
+
+	const renamesViewDic: Record<string, { to: string; from: string }> = {};
+	renamedViews.forEach((it) => {
+		renamesViewDic[`${it.from.schema}.${it.from.name}`] = { to: it.to.name, from: it.from.name };
+	});
+
+	const movedViewDic: Record<string, { to: string; from: string }> = {};
+	movedViews.forEach((it) => {
+		movedViewDic[`${it.schemaFrom}.${it.name}`] = { to: it.schemaTo, from: it.schemaFrom };
+	});
+
+	const viewsPatchedSnap1 = copy(policyPatchedSnap1);
+	viewsPatchedSnap1.views = mapEntries(
+		viewsPatchedSnap1.views,
+		(viewKey, viewValue) => {
+			const rename = renamesViewDic[`${viewValue.schema}.${viewValue.name}`];
+			const moved = movedViewDic[`${viewValue.schema}.${viewValue.name}`];
+
+			if (rename) {
+				viewValue.name = rename.to;
+				viewKey = `${viewValue.schema}.${viewValue.name}`;
+			}
+
+			if (moved) viewKey = `${moved.to}.${viewValue.name}`;
+
+			return [viewKey, viewValue];
+		},
+	);
+
+	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
+
+	const typedResult: DiffResult = diffResultScheme.parse(diffResult);
+
+	const jsonStatements: JsonStatement[] = [];
+
+	const jsonCreateIndexesForCreatedTables = createdTables
+		.map((it) => {
+			return preparePgCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.indexes,
+				curFull,
+				action,
+			);
+		})
+		.flat();
+
+	const jsonDropTables = deletedTables.map((it) => {
+		return prepareDropTableJson(it);
+	});
+
+	const jsonRenameTables = renamedTables.map((it) => {
+		return prepareRenameTableJson(it.from, it.to);
+	});
+
+	const alteredTables = typedResult.alteredTablesWithColumns;
+
+	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = [];
+	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = [];
+	const jsonAddColumnsStatemets: JsonAddColumnStatement[] = [];
+
+	for (let it of columnRenames) {
+		jsonRenameColumnsStatements.push(
+			...prepareRenameColumns(it.table, it.schema, it.renames),
+		);
+	}
+
+	for (let it of columnDeletes) {
+		jsonDropColumnsStatemets.push(
+			..._prepareDropColumns(it.table, it.schema, it.columns),
+		);
+	}
+
+	for (let it of columnCreates) {
+		jsonAddColumnsStatemets.push(
+			..._prepareAddColumns(it.table, it.schema, it.columns),
+		);
+	}
+
+	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
+	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
+	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
+
+	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+
+	const jsonSetTableSchemas: JsonAlterTableSetSchema[] = [];
+
+	if (movedTables) {
+		for (let it of movedTables) {
+			jsonSetTableSchemas.push({
+				type: 'alter_table_set_schema',
+				tableName: it.name,
+				schemaFrom: it.schemaFrom || 'public',
+				schemaTo: it.schemaTo || 'public',
+			});
+		}
+	}
+
+	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
+	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
+
+	for (let it of alteredTables) {
+		// This part is needed to make sure that same columns in a table are not triggered for change
+		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
+		// We double-check that pk with same set of columns are both in added and deleted diffs
+		let addedColumns: { name: string; columns: string[] } | undefined;
+		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
+			const addedPkColumns = it.addedCompositePKs[addedPkName];
+			addedColumns = PgSquasher.unsquashPK(addedPkColumns);
+		}
+
+		let deletedColumns: { name: string; columns: string[] } | undefined;
+		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
+			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
+			deletedColumns = PgSquasher.unsquashPK(deletedPkColumns);
+		}
+
+		// Don't need to sort, but need to add tests for it
+		// addedColumns.sort();
+		// deletedColumns.sort();
+		const doPerformDeleteAndCreate = JSON.stringify(addedColumns ?? {}) !== JSON.stringify(deletedColumns ?? {});
+
+		let addedCompositePKs: JsonCreateCompositePK[] = [];
+		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
+		let alteredCompositePKs: JsonAlterCompositePK[] = [];
+		if (doPerformDeleteAndCreate) {
+			addedCompositePKs = prepareAddCompositePrimaryKeyPg(
+				it.name,
+				it.schema,
+				it.addedCompositePKs,
+			);
+			deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
+				it.name,
+				it.schema,
+				it.deletedCompositePKs,
+			);
+		}
+		alteredCompositePKs = prepareAlterCompositePrimaryKeyPg(
+			it.name,
+			it.schema,
+			it.alteredCompositePKs,
+		);
+
+		// add logic for unique constraints
+		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+		let createCheckConstraints: JsonCreateCheckConstraint[] = [];
+		let deleteCheckConstraints: JsonDeleteCheckConstraint[] = [];
+
+		addedUniqueConstraints = prepareAddUniqueConstraintPg(
+			it.name,
+			it.schema,
+			it.addedUniqueConstraints,
+		);
+		deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
+			it.name,
+			it.schema,
+			it.deletedUniqueConstraints,
+		);
+		if (it.alteredUniqueConstraints) {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+			for (const k of Object.keys(it.alteredUniqueConstraints)) {
+				added[k] = it.alteredUniqueConstraints[k].__new;
+				deleted[k] = it.alteredUniqueConstraints[k].__old;
+			}
+			addedUniqueConstraints.push(
+				...prepareAddUniqueConstraintPg(it.name, it.schema, added),
+			);
+			deletedUniqueConstraints.push(
+				...prepareDeleteUniqueConstraintPg(it.name, it.schema, deleted),
+			);
+		}
+
+		createCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
+		deleteCheckConstraints = prepareDeleteCheckConstraint(
+			it.name,
+			it.schema,
+			it.deletedCheckConstraints,
+		);
+
+		if (it.alteredCheckConstraints && action !== 'push') {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+
+			for (const k of Object.keys(it.alteredCheckConstraints)) {
+				added[k] = it.alteredCheckConstraints[k].__new;
+				deleted[k] = it.alteredCheckConstraints[k].__old;
+			}
+			createCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
+			deleteCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
+		}
+
+		jsonCreatedCheckConstraints.push(...createCheckConstraints);
+		jsonDeletedCheckConstraints.push(...deleteCheckConstraints);
+
+		jsonAddedCompositePKs.push(...addedCompositePKs);
+		jsonDeletedCompositePKs.push(...deletedCompositePKs);
+		jsonAlteredCompositePKs.push(...alteredCompositePKs);
+
+		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
+		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
+		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
+	}
+
+	// const rColumns = jsonRenameColumnsStatements.map((it) => {
+	// 	const tableName = it.tableName;
+	// 	const schema = it.schema;
+	// 	return {
+	// 		from: { schema, table: tableName, column: it.oldColumnName },
+	// 		to: { schema, table: tableName, column: it.newColumnName },
+	// 	};
+	// });
+
+	const jsonTableAlternations = alteredTables
+		.map((it) => {
+			return preparePgAlterColumns(
+				it.name,
+				it.schema,
+				it.altered,
+				json2,
+				json1,
+				action,
+			);
+		})
+		.flat();
+
+	const jsonCreateIndexesFoAlteredTables = alteredTables
+		.map((it) => {
+			return preparePgCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.addedIndexes || {},
+				curFull,
+				action,
+			);
+		})
+		.flat();
+
+	const jsonDropIndexesForAllAlteredTables = alteredTables
+		.map((it) => {
+			return prepareDropIndexesJson(
+				it.name,
+				it.schema,
+				it.deletedIndexes || {},
+			);
+		})
+		.flat();
+
+	const jsonCreatePoliciesStatements: JsonCreatePolicyStatement[] = [];
+	const jsonDropPoliciesStatements: JsonDropPolicyStatement[] = [];
+	const jsonAlterPoliciesStatements: JsonAlterPolicyStatement[] = [];
+	const jsonRenamePoliciesStatements: JsonRenamePolicyStatement[] = [];
+
+	const jsonRenameIndPoliciesStatements: JsonIndRenamePolicyStatement[] = [];
+	const jsonCreateIndPoliciesStatements: JsonCreateIndPolicyStatement[] = [];
+	const jsonDropIndPoliciesStatements: JsonDropIndPolicyStatement[] = [];
+	const jsonAlterIndPoliciesStatements: JsonAlterIndPolicyStatement[] = [];
+
+	const jsonEnableRLSStatements: JsonEnableRLSStatement[] = [];
+	const jsonDisableRLSStatements: JsonDisableRLSStatement[] = [];
+
+	for (let it of indPolicyRenames) {
+		jsonRenameIndPoliciesStatements.push(
+			...prepareRenameIndPolicyJsons([it]),
+		);
+	}
+
+	for (const it of indPolicyCreates) {
+		jsonCreateIndPoliciesStatements.push(
+			...prepareCreateIndPolicyJsons(
+				it.policies,
+			),
+		);
+	}
+
+	for (const it of indPolicyDeletes) {
+		jsonDropIndPoliciesStatements.push(
+			...prepareDropIndPolicyJsons(
+				it.policies,
+			),
+		);
+	}
+
+	typedResult.alteredPolicies.forEach(({ values }) => {
+		// return prepareAlterIndPolicyJson(json1.policies[it.name], json2.policies[it.name]);
+
+		const policy = action === 'push' ? PgSquasher.unsquashPolicyPush(values) : PgSquasher.unsquashPolicy(values);
+
+		const newPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(json2.policies[policy.name].values)
+			: PgSquasher.unsquashPolicy(json2.policies[policy.name].values);
+		const oldPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(json2.policies[policy.name].values)
+			: PgSquasher.unsquashPolicy(json1.policies[policy.name].values);
+
+		if (newPolicy.as !== oldPolicy.as) {
+			jsonDropIndPoliciesStatements.push(
+				...prepareDropIndPolicyJsons(
+					[oldPolicy],
+				),
+			);
+
+			jsonCreateIndPoliciesStatements.push(
+				...prepareCreateIndPolicyJsons(
+					[newPolicy],
+				),
+			);
+			return;
+		}
+
+		if (newPolicy.for !== oldPolicy.for) {
+			jsonDropIndPoliciesStatements.push(
+				...prepareDropIndPolicyJsons(
+					[oldPolicy],
+				),
+			);
+
+			jsonCreateIndPoliciesStatements.push(
+				...prepareCreateIndPolicyJsons(
+					[newPolicy],
+				),
+			);
+			return;
+		}
+
+		// alter
+		jsonAlterIndPoliciesStatements.push(
+			prepareAlterIndPolicyJson(
+				oldPolicy,
+				newPolicy,
+			),
+		);
+	});
+
+	for (let it of policyRenames) {
+		jsonRenamePoliciesStatements.push(
+			...prepareRenamePolicyJsons(it.table, it.schema, it.renames),
+		);
+	}
+
+	for (const it of policyCreates) {
+		jsonCreatePoliciesStatements.push(
+			...prepareCreatePolicyJsons(
+				it.table,
+				it.schema,
+				it.columns,
+			),
+		);
+	}
+
+	for (const it of policyDeletes) {
+		jsonDropPoliciesStatements.push(
+			...prepareDropPolicyJsons(
+				it.table,
+				it.schema,
+				it.columns,
+			),
+		);
+	}
+
+	alteredTables.forEach((it) => {
+		// handle policies
+		Object.keys(it.alteredPolicies).forEach((policyName: string) => {
+			const newPolicy = action === 'push'
+				? PgSquasher.unsquashPolicyPush(it.alteredPolicies[policyName].__new)
+				: PgSquasher.unsquashPolicy(it.alteredPolicies[policyName].__new);
+			const oldPolicy = action === 'push'
+				? PgSquasher.unsquashPolicyPush(it.alteredPolicies[policyName].__old)
+				: PgSquasher.unsquashPolicy(it.alteredPolicies[policyName].__old);
+
+			if (newPolicy.as !== oldPolicy.as) {
+				jsonDropPoliciesStatements.push(
+					...prepareDropPolicyJsons(
+						it.name,
+						it.schema,
+						[oldPolicy],
+					),
+				);
+
+				jsonCreatePoliciesStatements.push(
+					...prepareCreatePolicyJsons(
+						it.name,
+						it.schema,
+						[newPolicy],
+					),
+				);
+				return;
+			}
+
+			if (newPolicy.for !== oldPolicy.for) {
+				jsonDropPoliciesStatements.push(
+					...prepareDropPolicyJsons(
+						it.name,
+						it.schema,
+						[oldPolicy],
+					),
+				);
+
+				jsonCreatePoliciesStatements.push(
+					...prepareCreatePolicyJsons(
+						it.name,
+						it.schema,
+						[newPolicy],
+					),
+				);
+				return;
+			}
+
+			// alter
+			jsonAlterPoliciesStatements.push(
+				prepareAlterPolicyJson(
+					it.name,
+					it.schema,
+					it.alteredPolicies[policyName].__old,
+					it.alteredPolicies[policyName].__new,
+				),
+			);
+		});
+
+		// Handle enabling and disabling RLS
+		for (const table of Object.values(json2.tables)) {
+			const policiesInCurrentState = Object.keys(table.policies);
+			const tableInPreviousState =
+				columnsPatchedSnap1.tables[`${table.schema === '' ? 'public' : table.schema}.${table.name}`];
+			const policiesInPreviousState = tableInPreviousState ? Object.keys(tableInPreviousState.policies) : [];
+
+			// const indPoliciesInCurrentState = Object.keys(table.policies);
+			// const indPoliciesInPreviousState = Object.keys(columnsPatchedSnap1.policies);
+
+			if (
+				(policiesInPreviousState.length === 0 && policiesInCurrentState.length > 0) && !table.isRLSEnabled
+			) {
+				jsonEnableRLSStatements.push({ type: 'enable_rls', tableName: table.name, schema: table.schema });
+			}
+
+			if (
+				(policiesInPreviousState.length > 0 && policiesInCurrentState.length === 0) && !table.isRLSEnabled
+			) {
+				jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
+			}
+
+			// handle table.isRLSEnabled
+			const wasRlsEnabled = tableInPreviousState ? tableInPreviousState.isRLSEnabled : false;
+			if (table.isRLSEnabled !== wasRlsEnabled) {
+				if (table.isRLSEnabled) {
+					// was force enabled
+					jsonEnableRLSStatements.push({ type: 'enable_rls', tableName: table.name, schema: table.schema });
+				} else if (
+					!table.isRLSEnabled && policiesInCurrentState.length === 0
+				) {
+					// was force disabled
+					jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
+				}
+			}
+		}
+
+		for (const table of Object.values(columnsPatchedSnap1.tables)) {
+			const tableInCurrentState = json2.tables[`${table.schema === '' ? 'public' : table.schema}.${table.name}`];
+
+			if (tableInCurrentState === undefined && !table.isRLSEnabled) {
+				jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
+			}
+		}
+
+		// handle indexes
+		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__old;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__new;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+
+		jsonCreateIndexesFoAlteredTables.push(
+			...preparePgCreateIndexesJson(
+				it.name,
+				it.schema,
+				createdIndexes || {},
+				curFull,
+				action,
+			),
+		);
+		jsonDropIndexesForAllAlteredTables.push(
+			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
+		);
+	});
+
+	const jsonCreateReferencesForCreatedTables: JsonCreateReferenceStatement[] = createdTables
+		.map((it) => {
+			return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
+		})
+		.flat();
+
+	const jsonReferencesForAlteredTables: JsonReferenceStatement[] = alteredTables
+		.map((it) => {
+			const forAdded = prepareCreateReferencesJson(
+				it.name,
+				it.schema,
+				it.addedForeignKeys,
+			);
+
+			const forAltered = prepareDropReferencesJson(
+				it.name,
+				it.schema,
+				it.deletedForeignKeys,
+			);
+
+			const alteredFKs = prepareAlterReferencesJson(
+				it.name,
+				it.schema,
+				it.alteredForeignKeys,
+			);
+
+			return [...forAdded, ...forAltered, ...alteredFKs];
+		})
+		.flat();
+
+	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter((t) =>
+		t.type === 'create_reference'
+	);
+
+	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter((t) =>
+		t.type === 'delete_reference'
+	);
+
+	// Sequences
+	// - create sequence ✅
+	// - create sequence inside schema ✅
+	// - rename sequence ✅
+	// - change sequence schema ✅
+	// - change sequence schema + name ✅
+	// - drop sequence - check if sequence is in use. If yes - ???
+	// - change sequence values ✅
+
+	// Generated columns
+	// - add generated
+	// - drop generated
+	// - create table with generated
+	// - alter - should be not triggered, but should get warning
+
+	const createEnums = createdEnums.map((it) => {
+		return prepareCreateEnumJson(it.name, it.schema, it.values);
+	}) ?? [];
+
+	const dropEnums = deletedEnums.map((it) => {
+		return prepareDropEnumJson(it.name, it.schema);
+	});
+
+	const moveEnums = movedEnums.map((it) => {
+		return prepareMoveEnumJson(it.name, it.schemaFrom, it.schemaTo);
+	});
+
+	const renameEnums = renamedEnums.map((it) => {
+		return prepareRenameEnumJson(it.from.name, it.to.name, it.to.schema);
+	});
+
+	const jsonAlterEnumsWithAddedValues = typedResult.alteredEnums
+		.map((it) => {
+			return prepareAddValuesToEnumJson(it.name, it.schema, it.addedValues);
+		})
+		.flat() ?? [];
+
+	const jsonAlterEnumsWithDroppedValues = typedResult.alteredEnums
+		.map((it) => {
+			return prepareDropEnumValues(it.name, it.schema, it.deletedValues, curFull);
+		})
+		.flat() ?? [];
+
+	const createSequences = createdSequences.map((it) => {
+		return prepareCreateSequenceJson(it);
+	}) ?? [];
+
+	const dropSequences = deletedSequences.map((it) => {
+		return prepareDropSequenceJson(it.name, it.schema);
+	});
+
+	const moveSequences = movedSequences.map((it) => {
+		return prepareMoveSequenceJson(it.name, it.schemaFrom, it.schemaTo);
+	});
+
+	const renameSequences = renamedSequences.map((it) => {
+		return prepareRenameSequenceJson(it.from.name, it.to.name, it.to.schema);
+	});
+
+	const jsonAlterSequences = typedResult.alteredSequences
+		.map((it) => {
+			return prepareAlterSequenceJson(it);
+		})
+		.flat() ?? [];
+
+	////////////
+
+	const createRoles = createdRoles.map((it) => {
+		return prepareCreateRoleJson(it);
+	}) ?? [];
+
+	const dropRoles = deletedRoles.map((it) => {
+		return prepareDropRoleJson(it.name);
+	});
+
+	const renameRoles = renamedRoles.map((it) => {
+		return prepareRenameRoleJson(it.from.name, it.to.name);
+	});
+
+	const jsonAlterRoles = typedResult.alteredRoles
+		.map((it) => {
+			return prepareAlterRoleJson(it);
+		})
+		.flat() ?? [];
+
+	////////////
+	const createSchemas = prepareCreateSchemasJson(
+		createdSchemas.map((it) => it.name),
+	);
+
+	const renameSchemas = prepareRenameSchemasJson(
+		renamedSchemas.map((it) => ({ from: it.from.name, to: it.to.name })),
+	);
+
+	const dropSchemas = prepareDeleteSchemasJson(
+		deletedSchemas.map((it) => it.name),
+	);
+
+	const createTables = createdTables.map((it) => {
+		return preparePgCreateTableJson(it, curFull);
+	});
+
+	jsonCreatePoliciesStatements.push(...([] as JsonCreatePolicyStatement[]).concat(
+		...(createdTables.map((it) =>
+			prepareCreatePolicyJsons(
+				it.name,
+				it.schema,
+				Object.values(it.policies).map(action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy),
+			)
+		)),
+	));
+	const createViews: JsonCreatePgViewStatement[] = [];
+	const dropViews: JsonDropViewStatement[] = [];
+	const renameViews: JsonRenameViewStatement[] = [];
+	const alterViews: JsonAlterViewStatement[] = [];
+
+	createViews.push(
+		...createdViews.filter((it) => !it.isExisting).map((it) => {
+			return preparePgCreateViewJson(
+				it.name,
+				it.schema,
+				it.definition!,
+				it.materialized,
+				it.withNoData,
+				it.with,
+				it.using,
+				it.tablespace,
+			);
+		}),
+	);
+
+	dropViews.push(
+		...deletedViews.filter((it) => !it.isExisting).map((it) => {
+			return prepareDropViewJson(it.name, it.schema, it.materialized);
+		}),
+	);
+
+	renameViews.push(
+		...renamedViews.filter((it) => !it.to.isExisting && !json1.views[`${it.from.schema}.${it.from.name}`].isExisting)
+			.map((it) => {
+				return prepareRenameViewJson(it.to.name, it.from.name, it.to.schema, it.to.materialized);
+			}),
+	);
+
+	alterViews.push(
+		...movedViews.filter((it) =>
+			!json2.views[`${it.schemaTo}.${it.name}`].isExisting && !json1.views[`${it.schemaFrom}.${it.name}`].isExisting
+		).map((it) => {
+			return preparePgAlterViewAlterSchemaJson(
+				it.schemaTo,
+				it.schemaFrom,
+				it.name,
+				json2.views[`${it.schemaTo}.${it.name}`].materialized,
+			);
+		}),
+	);
+
+	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[`${it.schema}.${it.name}`].isExisting);
+
+	for (const alteredView of alteredViews) {
+		const viewKey = `${alteredView.schema}.${alteredView.name}`;
+
+		const { materialized, with: withOption, definition, withNoData, using, tablespace } = json2.views[viewKey];
+
+		if (alteredView.alteredExisting || (alteredView.alteredDefinition && action !== 'push')) {
+			dropViews.push(prepareDropViewJson(alteredView.name, alteredView.schema, materialized));
+
+			createViews.push(
+				preparePgCreateViewJson(
+					alteredView.name,
+					alteredView.schema,
+					definition!,
+					materialized,
+					withNoData,
+					withOption,
+					using,
+					tablespace,
+				),
+			);
+
+			continue;
+		}
+
+		if (alteredView.addedWithOption) {
+			alterViews.push(
+				preparePgAlterViewAddWithOptionJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.addedWithOption,
+				),
+			);
+		}
+
+		if (alteredView.deletedWithOption) {
+			alterViews.push(
+				preparePgAlterViewDropWithOptionJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.deletedWithOption,
+				),
+			);
+		}
+
+		if (alteredView.addedWith) {
+			alterViews.push(
+				preparePgAlterViewAddWithOptionJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.addedWith,
+				),
+			);
+		}
+
+		if (alteredView.deletedWith) {
+			alterViews.push(
+				preparePgAlterViewDropWithOptionJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.deletedWith,
+				),
+			);
+		}
+
+		if (alteredView.alteredWith) {
+			alterViews.push(
+				preparePgAlterViewAddWithOptionJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.alteredWith,
+				),
+			);
+		}
+
+		if (alteredView.alteredTablespace) {
+			alterViews.push(
+				preparePgAlterViewAlterTablespaceJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.alteredTablespace.__new,
+				),
+			);
+		}
+
+		if (alteredView.alteredUsing) {
+			alterViews.push(
+				preparePgAlterViewAlterUsingJson(
+					alteredView.name,
+					alteredView.schema,
+					materialized,
+					alteredView.alteredUsing.__new,
+				),
+			);
+		}
+	}
+
+	jsonStatements.push(...createSchemas);
+	jsonStatements.push(...renameSchemas);
+	jsonStatements.push(...createEnums);
+	jsonStatements.push(...moveEnums);
+	jsonStatements.push(...renameEnums);
+	jsonStatements.push(...jsonAlterEnumsWithAddedValues);
+
+	jsonStatements.push(...createSequences);
+	jsonStatements.push(...moveSequences);
+	jsonStatements.push(...renameSequences);
+	jsonStatements.push(...jsonAlterSequences);
+
+	jsonStatements.push(...renameRoles);
+	jsonStatements.push(...dropRoles);
+	jsonStatements.push(...createRoles);
+	jsonStatements.push(...jsonAlterRoles);
+
+	jsonStatements.push(...createTables);
+
+	jsonStatements.push(...jsonEnableRLSStatements);
+	jsonStatements.push(...jsonDisableRLSStatements);
+	jsonStatements.push(...dropViews);
+	jsonStatements.push(...renameViews);
+	jsonStatements.push(...alterViews);
+
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonSetTableSchemas);
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...jsonDeletedUniqueConstraints);
+	jsonStatements.push(...jsonDeletedCheckConstraints);
+
+	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
+
+	jsonStatements.push(...jsonAlterEnumsWithDroppedValues);
+
+	// Will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
+
+	jsonStatements.push(...jsonDeletedCompositePKs);
+	jsonStatements.push(...jsonTableAlternations);
+	jsonStatements.push(...jsonAddedCompositePKs);
+	jsonStatements.push(...jsonAddColumnsStatemets);
+
+	// PATCHED, need to run before fks
+	jsonStatements.push(...jsonAddedUniqueConstraints);
+	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
+	jsonStatements.push(...jsonCreateIndexesFoAlteredTables);
+	jsonStatements.push(...jsonAlteredUniqueConstraints);
+
+	// ----
+
+	jsonStatements.push(...jsonCreateReferencesForCreatedTables);
+
+	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+	jsonStatements.push(...jsonAlteredCompositePKs);
+
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+
+	jsonStatements.push(...createViews);
+
+	jsonStatements.push(...jsonRenamePoliciesStatements);
+	jsonStatements.push(...jsonDropPoliciesStatements);
+	jsonStatements.push(...jsonCreatePoliciesStatements);
+	jsonStatements.push(...jsonAlterPoliciesStatements);
+
+	jsonStatements.push(...jsonRenameIndPoliciesStatements);
+	jsonStatements.push(...jsonDropIndPoliciesStatements);
+	jsonStatements.push(...jsonCreateIndPoliciesStatements);
+	jsonStatements.push(...jsonAlterIndPoliciesStatements);
+
+	jsonStatements.push(...dropEnums);
+	jsonStatements.push(...dropSequences);
+	jsonStatements.push(...dropSchemas);
+
+	// generate filters
+	const filteredJsonStatements = jsonStatements.filter((st) => {
+		if (st.type === 'alter_table_alter_column_drop_notnull') {
+			if (
+				jsonStatements.find(
+					(it) =>
+						it.type === 'alter_table_alter_column_drop_identity'
+						&& it.tableName === st.tableName
+						&& it.schema === st.schema,
+				)
+			) {
+				return false;
+			}
+		}
+		if (st.type === 'alter_table_alter_column_set_notnull') {
+			if (
+				jsonStatements.find(
+					(it) =>
+						it.type === 'alter_table_alter_column_set_identity'
+						&& it.tableName === st.tableName
+						&& it.schema === st.schema,
+				)
+			) {
+				return false;
+			}
+		}
+		return true;
+	});
+
+	// enum filters
+	// Need to find add and drop enum values in same enum and remove add values
+	const filteredEnumsJsonStatements = filteredJsonStatements.filter((st) => {
+		if (st.type === 'alter_type_add_value') {
+			if (
+				filteredJsonStatements.find(
+					(it) =>
+						it.type === 'alter_type_drop_value'
+						&& it.name === st.name
+						&& it.enumSchema === st.schema,
+				)
+			) {
+				return false;
+			}
+		}
+		return true;
+	});
+
+	// This is needed because in sql generator on type pg_alter_table_alter_column_set_type and alter_type_drop_value
+	// drizzle kit checks whether column has defaults to cast them to new types properly
+	const filteredEnums2JsonStatements = filteredEnumsJsonStatements.filter((st) => {
+		if (st.type === 'alter_table_alter_column_set_default') {
+			if (
+				filteredEnumsJsonStatements.find(
+					(it) =>
+						it.type === 'pg_alter_table_alter_column_set_type'
+						&& it.columnDefault === st.newDefaultValue
+						&& it.columnName === st.columnName
+						&& it.tableName === st.tableName
+						&& it.schema === st.schema,
+				)
+			) {
+				return false;
+			}
+
+			if (
+				filteredEnumsJsonStatements.find(
+					(it) =>
+						it.type === 'alter_type_drop_value'
+						&& it.columnsWithEnum.find((column) =>
+							column.default === st.newDefaultValue
+							&& column.column === st.columnName
+							&& column.table === st.tableName
+							&& column.tableSchema === st.schema
+						),
+				)
+			) {
+				return false;
+			}
+		}
+		return true;
+	});
+
+	const sqlStatements = fromJson(filteredEnums2JsonStatements, 'postgresql', action);
+
+	const uniqueSqlStatements: string[] = [];
+	sqlStatements.forEach((ss) => {
+		if (!uniqueSqlStatements.includes(ss)) {
+			uniqueSqlStatements.push(ss);
+		}
+	});
+
+	// const rSchemas = renamedSchemas.map((it) => ({
+	// 	from: it.from.name,
+	// 	to: it.to.name,
+	// }));
+
+	// const rTables = renamedTables.map((it) => {
+	// 	return { from: it.from, to: it.to };
+	// });
+
+	return {
+		statements: filteredEnums2JsonStatements,
+		sqlStatements: uniqueSqlStatements,
+		_meta: { columns: [], schemas: [], tables: [] },
+	};
+};
diff --git a/drizzle-kit/src/legacy/postgres-v7/pgSchema.ts b/drizzle-kit/src/legacy/postgres-v7/pgSchema.ts
new file mode 100644
index 0000000000..0b5f2b2197
--- /dev/null
+++ b/drizzle-kit/src/legacy/postgres-v7/pgSchema.ts
@@ -0,0 +1,886 @@
+import type { TypeOf } from 'zod';
+import { any, array, boolean, enum as enumType, literal, number, object, record, string, union } from 'zod';
+import { mapValues, originUUID, snapshotVersion } from '../global';
+
+const indexV2 = object({
+	name: string(),
+	columns: record(
+		string(),
+		object({
+			name: string(),
+		}),
+	),
+	isUnique: boolean(),
+}).strict();
+
+const columnV2 = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	references: string().optional(),
+}).strict();
+
+const tableV2 = object({
+	name: string(),
+	columns: record(string(), columnV2),
+	indexes: record(string(), indexV2),
+}).strict();
+
+const enumSchemaV1 = object({
+	name: string(),
+	values: record(string(), string()),
+}).strict();
+
+const enumSchema = object({
+	name: string(),
+	schema: string(),
+	values: string().array(),
+}).strict();
+
+export const pgSchemaV2 = object({
+	version: literal('2'),
+	tables: record(string(), tableV2),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+// ------- V1 --------
+const references = object({
+	foreignKeyName: string(),
+	table: string(),
+	column: string(),
+	onDelete: string().optional(),
+	onUpdate: string().optional(),
+}).strict();
+
+const columnV1 = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	references: references.optional(),
+}).strict();
+
+const tableV1 = object({
+	name: string(),
+	columns: record(string(), columnV1),
+	indexes: record(string(), indexV2),
+}).strict();
+
+export const pgSchemaV1 = object({
+	version: literal('1'),
+	tables: record(string(), tableV1),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+const indexColumn = object({
+	expression: string(),
+	isExpression: boolean(),
+	asc: boolean(),
+	nulls: string().optional(),
+	opclass: string().optional(),
+});
+
+export type IndexColumnType = TypeOf<typeof indexColumn>;
+
+const index = object({
+	name: string(),
+	columns: indexColumn.array(),
+	isUnique: boolean(),
+	with: record(string(), any()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV4 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV5 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const indexV6 = object({
+	name: string(),
+	columns: string().array(),
+	isUnique: boolean(),
+	with: record(string(), string()).optional(),
+	method: string().default('btree'),
+	where: string().optional(),
+	concurrently: boolean().default(false),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	schemaTo: string().optional(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+export const sequenceSchema = object({
+	name: string(),
+	increment: string().optional(),
+	minValue: string().optional(),
+	maxValue: string().optional(),
+	startWith: string().optional(),
+	cache: string().optional(),
+	cycle: boolean().optional(),
+	schema: string(),
+}).strict();
+
+export const roleSchema = object({
+	name: string(),
+	createDb: boolean().optional(),
+	createRole: boolean().optional(),
+	inherit: boolean().optional(),
+}).strict();
+
+export const sequenceSquashed = object({
+	name: string(),
+	schema: string(),
+	values: string(),
+}).strict();
+
+const columnV7 = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+	generated: object({
+		type: literal('stored'),
+		as: string(),
+	}).optional(),
+	identity: sequenceSchema
+		.merge(object({ type: enumType(['always', 'byDefault']) }))
+		.optional(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const columnSquashed = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	default: any().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+	generated: object({
+		type: literal('stored'),
+		as: string(),
+	}).optional(),
+	identity: string().optional(),
+}).strict();
+
+const tableV3 = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const compositePK = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+	nullsNotDistinct: boolean(),
+}).strict();
+
+export const policy = object({
+	name: string(),
+	as: enumType(['PERMISSIVE', 'RESTRICTIVE']).optional(),
+	for: enumType(['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE']).optional(),
+	to: string().array().optional(),
+	using: string().optional(),
+	withCheck: string().optional(),
+	on: string().optional(),
+	schema: string().optional(),
+}).strict();
+
+export const policySquashed = object({
+	name: string(),
+	values: string(),
+}).strict();
+
+const viewWithOption = object({
+	checkOption: enumType(['local', 'cascaded']).optional(),
+	securityBarrier: boolean().optional(),
+	securityInvoker: boolean().optional(),
+}).strict();
+
+const matViewWithOption = object({
+	fillfactor: number().optional(),
+	toastTupleTarget: number().optional(),
+	parallelWorkers: number().optional(),
+	autovacuumEnabled: boolean().optional(),
+	vacuumIndexCleanup: enumType(['auto', 'off', 'on']).optional(),
+	vacuumTruncate: boolean().optional(),
+	autovacuumVacuumThreshold: number().optional(),
+	autovacuumVacuumScaleFactor: number().optional(),
+	autovacuumVacuumCostDelay: number().optional(),
+	autovacuumVacuumCostLimit: number().optional(),
+	autovacuumFreezeMinAge: number().optional(),
+	autovacuumFreezeMaxAge: number().optional(),
+	autovacuumFreezeTableAge: number().optional(),
+	autovacuumMultixactFreezeMinAge: number().optional(),
+	autovacuumMultixactFreezeMaxAge: number().optional(),
+	autovacuumMultixactFreezeTableAge: number().optional(),
+	logAutovacuumMinDuration: number().optional(),
+	userCatalogTable: boolean().optional(),
+}).strict();
+
+export const mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
+
+export const view = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	materialized: boolean(),
+	with: mergedViewWithOption.optional(),
+	isExisting: boolean(),
+	withNoData: boolean().optional(),
+	using: string().optional(),
+	tablespace: string().optional(),
+}).strict();
+
+const tableV4 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV4),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const tableV5 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV5),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const tableV6 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), indexV6),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const tableV7 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), columnV7),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+}).strict();
+
+const table = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	policies: record(string(), policy).default({}),
+	checkConstraints: record(string(), checkConstraint).default({}),
+	isRLSEnabled: boolean().default(false),
+}).strict();
+
+const schemaHash = object({
+	id: string(),
+	prevId: string(),
+});
+
+export const kitInternals = object({
+	tables: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({
+					isArray: boolean().optional(),
+					dimensions: number().optional(),
+					rawType: string().optional(),
+					isDefaultAnExpression: boolean().optional(),
+				}).optional(),
+			),
+		}).optional(),
+	),
+}).optional();
+
+export const pgSchemaInternalV3 = object({
+	version: literal('3'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV3),
+	enums: record(string(), enumSchemaV1),
+}).strict();
+
+export const pgSchemaInternalV4 = object({
+	version: literal('4'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV4),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+}).strict();
+
+// "table" -> "schema.table" for schema proper support
+export const pgSchemaInternalV5 = object({
+	version: literal('5'),
+	dialect: literal('pg'),
+	tables: record(string(), tableV5),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaInternalV6 = object({
+	version: literal('6'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableV6),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaExternal = object({
+	version: literal('5'),
+	dialect: literal('pg'),
+	tables: array(table),
+	enums: array(enumSchemaV1),
+	schemas: array(object({ name: string() })),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+}).strict();
+
+export const pgSchemaInternalV7 = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableV7),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	sequences: record(string(), sequenceSchema),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const pgSchemaInternal = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), table),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	views: record(string(), view).default({}),
+	sequences: record(string(), sequenceSchema).default({}),
+	roles: record(string(), roleSchema).default({}),
+	policies: record(string(), policy).default({}),
+	_meta: object({
+		schemas: record(string(), string()),
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+const tableSquashed = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), columnSquashed),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()),
+	policies: record(string(), string()),
+	checkConstraints: record(string(), string()),
+	isRLSEnabled: boolean().default(false),
+}).strict();
+
+const tableSquashedV4 = object({
+	name: string(),
+	schema: string(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashedV4 = object({
+	version: literal('4'),
+	dialect: literal('pg'),
+	tables: record(string(), tableSquashedV4),
+	enums: record(string(), enumSchemaV1),
+	schemas: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashedV6 = object({
+	version: literal('6'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableSquashed),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+}).strict();
+
+export const pgSchemaSquashed = object({
+	version: literal('7'),
+	dialect: literal('postgresql'),
+	tables: record(string(), tableSquashed),
+	enums: record(string(), enumSchema),
+	schemas: record(string(), string()),
+	views: record(string(), view),
+	sequences: record(string(), sequenceSquashed),
+	roles: record(string(), roleSchema).default({}),
+	policies: record(string(), policySquashed).default({}),
+}).strict();
+
+export const pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash);
+export const pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash);
+export const pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash);
+export const pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash);
+export const pgSchemaV7 = pgSchemaInternalV7.merge(schemaHash);
+export const pgSchema = pgSchemaInternal.merge(schemaHash);
+
+export type Enum = TypeOf<typeof enumSchema>;
+export type Sequence = TypeOf<typeof sequenceSchema>;
+export type Role = TypeOf<typeof roleSchema>;
+export type Column = TypeOf<typeof column>;
+export type TableV3 = TypeOf<typeof tableV3>;
+export type TableV4 = TypeOf<typeof tableV4>;
+export type TableV5 = TypeOf<typeof tableV5>;
+export type Table = TypeOf<typeof table>;
+export type PgSchema = TypeOf<typeof pgSchema>;
+export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
+export type PgSchemaV6Internal = TypeOf<typeof pgSchemaInternalV6>;
+export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
+export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
+export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
+export type PgSchemaSquashedV6 = TypeOf<typeof pgSchemaSquashedV6>;
+export type Index = TypeOf<typeof index>;
+export type ForeignKey = TypeOf<typeof fk>;
+export type PrimaryKey = TypeOf<typeof compositePK>;
+export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
+export type Policy = TypeOf<typeof policy>;
+export type View = TypeOf<typeof view>;
+export type MatViewWithOption = TypeOf<typeof matViewWithOption>;
+export type ViewWithOption = TypeOf<typeof viewWithOption>;
+
+export type PgKitInternals = TypeOf<typeof kitInternals>;
+export type CheckConstraint = TypeOf<typeof checkConstraint>;
+
+export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
+export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
+export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
+export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
+export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
+export type PgSchemaV6 = TypeOf<typeof pgSchemaV6>;
+
+export const backwardCompatiblePgSchema = union([
+	pgSchemaV5,
+	pgSchemaV6,
+	pgSchema,
+]);
+
+export const PgSquasher = {
+	squashIdx: (idx: Index) => {
+		index.parse(idx);
+		return `${idx.name};${
+			idx.columns
+				.map(
+					(c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass ? c.opclass : ''}`,
+				)
+				.join(',,')
+		};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
+	},
+	unsquashIdx: (input: string): Index => {
+		const [
+			name,
+			columnsString,
+			isUnique,
+			concurrently,
+			method,
+			where,
+			idxWith,
+		] = input.split(';');
+
+		const columnString = columnsString.split(',,');
+		const columns: IndexColumnType[] = [];
+
+		for (const column of columnString) {
+			const [expression, isExpression, asc, nulls, opclass] = column.split('--');
+			columns.push({
+				nulls: nulls as IndexColumnType['nulls'],
+				isExpression: isExpression === 'true',
+				asc: asc === 'true',
+				expression: expression,
+				opclass: opclass === 'undefined' ? undefined : opclass,
+			});
+		}
+
+		const result: Index = index.parse({
+			name,
+			columns: columns,
+			isUnique: isUnique === 'true',
+			concurrently: concurrently === 'true',
+			method,
+			where: where === 'undefined' ? undefined : where,
+			with: !idxWith || idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
+		});
+		return result;
+	},
+	squashIdxPush: (idx: Index) => {
+		index.parse(idx);
+		return `${idx.name};${
+			idx.columns
+				.map((c) => `${c.isExpression ? '' : c.expression}--${c.asc}--${c.nulls}`)
+				.join(',,')
+		};${idx.isUnique};${idx.method};${JSON.stringify(idx.with)}`;
+	},
+	unsquashIdxPush: (input: string): Index => {
+		const [name, columnsString, isUnique, method, idxWith] = input.split(';');
+
+		const columnString = columnsString.split('--');
+		const columns: IndexColumnType[] = [];
+
+		for (const column of columnString) {
+			const [expression, asc, nulls] = column.split(',');
+			columns.push({
+				nulls: nulls as IndexColumnType['nulls'],
+				isExpression: expression === '',
+				asc: asc === 'true',
+				expression: expression,
+			});
+		}
+
+		const result: Index = index.parse({
+			name,
+			columns: columns,
+			isUnique: isUnique === 'true',
+			concurrently: false,
+			method,
+			with: idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
+		});
+		return result;
+	},
+	squashFK: (fk: ForeignKey) => {
+		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
+			fk.onUpdate ?? ''
+		};${fk.onDelete ?? ''};${fk.schemaTo || 'public'}`;
+	},
+	squashPolicy: (policy: Policy) => {
+		return `${policy.name}--${policy.as}--${policy.for}--${
+			policy.to?.join(',')
+		}--${policy.using}--${policy.withCheck}--${policy.on}`;
+	},
+	unsquashPolicy: (policy: string): Policy => {
+		const splitted = policy.split('--');
+		return {
+			name: splitted[0],
+			as: splitted[1] as Policy['as'],
+			for: splitted[2] as Policy['for'],
+			to: splitted[3].split(','),
+			using: splitted[4] !== 'undefined' ? splitted[4] : undefined,
+			withCheck: splitted[5] !== 'undefined' ? splitted[5] : undefined,
+			on: splitted[6] !== 'undefined' ? splitted[6] : undefined,
+		};
+	},
+	squashPolicyPush: (policy: Policy) => {
+		return `${policy.name}--${policy.as}--${policy.for}--${policy.to?.join(',')}--${policy.on}`;
+	},
+	unsquashPolicyPush: (policy: string): Policy => {
+		const splitted = policy.split('--');
+		return {
+			name: splitted[0],
+			as: splitted[1] as Policy['as'],
+			for: splitted[2] as Policy['for'],
+			to: splitted[3].split(','),
+			on: splitted[4] !== 'undefined' ? splitted[4] : undefined,
+		};
+	},
+	squashPK: (pk: PrimaryKey) => {
+		return `${pk.columns.join(',')};${pk.name}`;
+	},
+	unsquashPK: (pk: string): PrimaryKey => {
+		const splitted = pk.split(';');
+		return { name: splitted[1], columns: splitted[0].split(',') };
+	},
+	squashUnique: (unq: UniqueConstraint) => {
+		return `${unq.name};${unq.columns.join(',')};${unq.nullsNotDistinct}`;
+	},
+	unsquashUnique: (unq: string): UniqueConstraint => {
+		const [name, columns, nullsNotDistinct] = unq.split(';');
+		return {
+			name,
+			columns: columns.split(','),
+			nullsNotDistinct: nullsNotDistinct === 'true',
+		};
+	},
+	unsquashFK: (input: string): ForeignKey => {
+		const [
+			name,
+			tableFrom,
+			columnsFromStr,
+			tableTo,
+			columnsToStr,
+			onUpdate,
+			onDelete,
+			schemaTo,
+		] = input.split(';');
+
+		const result: ForeignKey = fk.parse({
+			name,
+			tableFrom,
+			columnsFrom: columnsFromStr.split(','),
+			schemaTo: schemaTo,
+			tableTo,
+			columnsTo: columnsToStr.split(','),
+			onUpdate,
+			onDelete,
+		});
+		return result;
+	},
+	squashSequence: (seq: Omit<Sequence, 'name' | 'schema'>) => {
+		return `${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${seq.cycle ?? ''}`;
+	},
+	unsquashSequence: (seq: string): Omit<Sequence, 'name' | 'schema'> => {
+		const splitted = seq.split(';');
+		return {
+			minValue: splitted[0] !== 'undefined' ? splitted[0] : undefined,
+			maxValue: splitted[1] !== 'undefined' ? splitted[1] : undefined,
+			increment: splitted[2] !== 'undefined' ? splitted[2] : undefined,
+			startWith: splitted[3] !== 'undefined' ? splitted[3] : undefined,
+			cache: splitted[4] !== 'undefined' ? splitted[4] : undefined,
+			cycle: splitted[5] === 'true',
+		};
+	},
+	squashIdentity: (
+		seq: Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' },
+	) => {
+		return `${seq.name};${seq.type};${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${
+			seq.cycle ?? ''
+		}`;
+	},
+	unsquashIdentity: (
+		seq: string,
+	): Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' } => {
+		const splitted = seq.split(';');
+		return {
+			name: splitted[0],
+			type: splitted[1] as 'always' | 'byDefault',
+			minValue: splitted[2] !== 'undefined' ? splitted[2] : undefined,
+			maxValue: splitted[3] !== 'undefined' ? splitted[3] : undefined,
+			increment: splitted[4] !== 'undefined' ? splitted[4] : undefined,
+			startWith: splitted[5] !== 'undefined' ? splitted[5] : undefined,
+			cache: splitted[6] !== 'undefined' ? splitted[6] : undefined,
+			cycle: splitted[7] === 'true',
+		};
+	},
+	squashCheck: (check: CheckConstraint) => {
+		return `${check.name};${check.value}`;
+	},
+	unsquashCheck: (input: string): CheckConstraint => {
+		const [
+			name,
+			value,
+		] = input.split(';');
+
+		return { name, value };
+	},
+};
+
+export const squashPgScheme = (
+	json: PgSchema,
+	action?: 'push' | undefined,
+): PgSchemaSquashed => {
+	const mappedTables = Object.fromEntries(
+		Object.entries(json.tables).map((it) => {
+			const squashedIndexes = mapValues(it[1].indexes, (index) => {
+				return action === 'push'
+					? PgSquasher.squashIdxPush(index)
+					: PgSquasher.squashIdx(index);
+			});
+
+			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
+				return PgSquasher.squashFK(fk);
+			});
+
+			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+				return PgSquasher.squashPK(pk);
+			});
+
+			const mappedColumns = Object.fromEntries(
+				Object.entries(it[1].columns).map((it) => {
+					const mappedIdentity = it[1].identity
+						? PgSquasher.squashIdentity(it[1].identity)
+						: undefined;
+					return [
+						it[0],
+						{
+							...it[1],
+							identity: mappedIdentity,
+						},
+					];
+				}),
+			);
+
+			const squashedUniqueConstraints = mapValues(
+				it[1].uniqueConstraints,
+				(unq) => {
+					return PgSquasher.squashUnique(unq);
+				},
+			);
+
+			const squashedPolicies = mapValues(it[1].policies, (policy) => {
+				return action === 'push'
+					? PgSquasher.squashPolicyPush(policy)
+					: PgSquasher.squashPolicy(policy);
+			});
+			const squashedChecksContraints = mapValues(
+				it[1].checkConstraints,
+				(check) => {
+					return PgSquasher.squashCheck(check);
+				},
+			);
+
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					schema: it[1].schema,
+					columns: mappedColumns,
+					indexes: squashedIndexes,
+					foreignKeys: squashedFKs,
+					compositePrimaryKeys: squashedPKs,
+					uniqueConstraints: squashedUniqueConstraints,
+					policies: squashedPolicies,
+					checkConstraints: squashedChecksContraints,
+					isRLSEnabled: it[1].isRLSEnabled ?? false,
+				},
+			];
+		}),
+	);
+
+	const mappedSequences = Object.fromEntries(
+		Object.entries(json.sequences).map((it) => {
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					schema: it[1].schema,
+					values: PgSquasher.squashSequence(it[1]),
+				},
+			];
+		}),
+	);
+
+	const mappedPolicies = Object.fromEntries(
+		Object.entries(json.policies).map((it) => {
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					values: action === 'push'
+						? PgSquasher.squashPolicyPush(it[1])
+						: PgSquasher.squashPolicy(it[1]),
+				},
+			];
+		}),
+	);
+
+	return {
+		version: '7',
+		dialect: json.dialect,
+		tables: mappedTables,
+		enums: json.enums,
+		schemas: json.schemas,
+		views: json.views,
+		policies: mappedPolicies,
+		sequences: mappedSequences,
+		roles: json.roles,
+	};
+};
+
+export const dryPg = pgSchema.parse({
+	version: snapshotVersion,
+	dialect: 'postgresql',
+	id: originUUID,
+	prevId: '',
+	tables: {},
+	enums: {},
+	schemas: {},
+	policies: {},
+	roles: {},
+	sequences: {},
+	_meta: {
+		schemas: {},
+		tables: {},
+		columns: {},
+	},
+});
diff --git a/drizzle-kit/src/legacy/postgres-v7/pgSerializer.ts b/drizzle-kit/src/legacy/postgres-v7/pgSerializer.ts
new file mode 100644
index 0000000000..b52ecc10be
--- /dev/null
+++ b/drizzle-kit/src/legacy/postgres-v7/pgSerializer.ts
@@ -0,0 +1,951 @@
+import chalk from 'chalk';
+import { getTableName, is, SQL } from 'orm044';
+import { CasingCache, toCamelCase, toSnakeCase } from 'orm044/casing';
+import type {
+	AnyPgTable,
+	IndexedColumn,
+	PgEnum,
+	PgMaterializedView,
+	PgPolicy,
+	PgSchema,
+	PgSequence,
+} from 'orm044/pg-core';
+import {
+	getMaterializedViewConfig,
+	getTableConfig,
+	getViewConfig,
+	PgColumn,
+	PgDialect,
+	PgEnumColumn,
+	PgRole,
+	PgView,
+	uniqueKeyName,
+} from 'orm044/pg-core';
+import type { CasingType } from '../common';
+import { withStyle } from '../outputs';
+import { escapeSingleQuotes, isPgArrayType } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	Enum,
+	ForeignKey,
+	Index,
+	IndexColumnType,
+	PgSchemaInternal,
+	Policy,
+	PrimaryKey,
+	Role,
+	Sequence,
+	Table,
+	UniqueConstraint,
+	View,
+} from './pgSchema';
+import { vectorOps } from './vector';
+
+export function getColumnCasing(
+	column: { keyAsName: boolean; name: string | undefined },
+	casing: CasingType | undefined,
+) {
+	if (!column.name) return '';
+	return !column.keyAsName || casing === undefined
+		? column.name
+		: casing === 'camelCase'
+		? toCamelCase(column.name)
+		: toSnakeCase(column.name);
+}
+
+export const sqlToStr = (sql: SQL, casing: CasingType | undefined) => {
+	return sql.toQuery({
+		escapeName: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeParam: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeString: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		casing: new CasingCache(casing),
+	}).sql;
+};
+
+export const sqlToStrGenerated = (sql: SQL, casing: CasingType | undefined) => {
+	return sql.toQuery({
+		escapeName: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeParam: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeString: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		casing: new CasingCache(casing),
+	}).sql;
+};
+
+export const indexName = (tableName: string, columns: string[]) => {
+	return `${tableName}_${columns.join('_')}_index`;
+};
+
+function stringFromIdentityProperty(field: string | number | undefined): string | undefined {
+	return typeof field === 'string' ? (field as string) : typeof field === 'undefined' ? undefined : String(field);
+}
+
+function maxRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'integer' ? '2147483647' : columnType === 'bigint' ? '9223372036854775807' : '32767';
+}
+
+function minRangeForIdentityBasedOn(columnType: string) {
+	return columnType === 'integer' ? '-2147483648' : columnType === 'bigint' ? '-9223372036854775808' : '-32768';
+}
+
+// function stringFromDatabaseIdentityProperty(field: any): string | undefined {
+// 	return typeof field === 'string'
+// 		? (field as string)
+// 		: typeof field === 'undefined'
+// 		? undefined
+// 		: typeof field === 'bigint'
+// 		? field.toString()
+// 		: String(field);
+// }
+
+export function buildArrayString(array: any[], sqlType: string): string {
+	// patched
+	if (array.flat(5).length === 0) {
+		return '{}';
+	}
+
+	sqlType = sqlType.split('[')[0];
+	const values = array
+		.map((value) => {
+			if (typeof value === 'number' || typeof value === 'bigint') {
+				return value.toString();
+			} else if (typeof value === 'boolean') {
+				return value ? 'true' : 'false';
+			} else if (Array.isArray(value)) {
+				return buildArrayString(value, sqlType);
+			} else if (value instanceof Date) {
+				if (sqlType === 'date') {
+					return `"${value.toISOString().split('T')[0]}"`;
+				} else if (sqlType === 'timestamp') {
+					return `"${value.toISOString().replace('T', ' ').slice(0, 23)}"`;
+				} else {
+					return `"${value.toISOString()}"`;
+				}
+			} else if (typeof value === 'object') {
+				return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
+			}
+
+			return `"${value}"`;
+		})
+		.join(',');
+
+	return `{${values}}`;
+}
+
+export const generatePgSnapshot = (
+	tables: AnyPgTable[],
+	enums: PgEnum<any>[],
+	schemas: PgSchema[],
+	sequences: PgSequence[],
+	roles: PgRole[],
+	policies: PgPolicy[],
+	views: PgView[],
+	matViews: PgMaterializedView[],
+	casing: CasingType | undefined,
+	schemaFilter?: string[],
+): PgSchemaInternal => {
+	const dialect = new PgDialect({ casing });
+	const result: Record<string, Table> = {};
+	const resultViews: Record<string, View> = {};
+	const sequencesToReturn: Record<string, Sequence> = {};
+	const rolesToReturn: Record<string, Role> = {};
+	// this policies are a separate objects that were linked to a table outside of it
+	const policiesToReturn: Record<string, Policy> = {};
+
+	// This object stores unique names for indexes and will be used to detect if you have the same names for indexes
+	// within the same PostgreSQL schema
+
+	const indexesInSchema: Record<string, string[]> = {};
+
+	for (const table of tables) {
+		// This object stores unique names for checks and will be used to detect if you have the same names for checks
+		// within the same PostgreSQL table
+		const checksInTable: Record<string, string[]> = {};
+
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			foreignKeys,
+			checks,
+			schema,
+			primaryKeys,
+			uniqueConstraints,
+			policies,
+			enableRLS,
+		} = getTableConfig(table);
+
+		if (schemaFilter && !schemaFilter.includes(schema ?? 'public')) {
+			continue;
+		}
+
+		const columnsObject: Record<string, Column> = {};
+		const indexesObject: Record<string, Index> = {};
+		const checksObject: Record<string, CheckConstraint> = {};
+		const foreignKeysObject: Record<string, ForeignKey> = {};
+		const primaryKeysObject: Record<string, PrimaryKey> = {};
+		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
+		const policiesObject: Record<string, Policy> = {};
+
+		columns.forEach((column) => {
+			const name = getColumnCasing(column, casing);
+			const notNull: boolean = column.notNull;
+			const primaryKey: boolean = column.primary;
+			const sqlTypeLowered = column.getSQLType().toLowerCase();
+
+			const typeSchema: string | undefined = is(column, PgEnumColumn) ? column.enum.schema || 'public' : undefined;
+
+			const generated = column.generated;
+			const identity = column.generatedIdentity;
+
+			const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
+			const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
+				?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
+			const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
+				?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
+			const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
+				?? (parseFloat(increment) < 0 ? maxValue : minValue);
+			const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
+
+			const columnToSet: Column = {
+				name,
+				type: column.getSQLType(),
+				typeSchema: typeSchema,
+				primaryKey,
+				notNull,
+				generated: generated
+					? {
+						as: is(generated.as, SQL)
+							? dialect.sqlToQuery(generated.as as SQL).sql
+							: typeof generated.as === 'function'
+							? dialect.sqlToQuery(generated.as() as SQL).sql
+							: (generated.as as any),
+						type: 'stored',
+					}
+					: undefined,
+				identity: identity
+					? {
+						type: identity.type,
+						name: identity.sequenceName ?? `${tableName}_${name}_seq`,
+						schema: schema ?? 'public',
+						increment,
+						startWith,
+						minValue,
+						maxValue,
+						cache,
+						cycle: identity?.sequenceOptions?.cycle ?? false,
+					}
+					: undefined,
+			};
+
+			if (column.isUnique) {
+				const existingUnique = uniqueConstraintObject[column.uniqueName!];
+				if (typeof existingUnique !== 'undefined') {
+					console.log(
+						`\n${
+							withStyle.errorWarning(`We've found duplicated unique constraint names in ${
+								chalk.underline.blue(
+									tableName,
+								)
+							} table. 
+          The unique constraint ${
+								chalk.underline.blue(
+									column.uniqueName,
+								)
+							} on the ${
+								chalk.underline.blue(
+									name,
+								)
+							} column is conflicting with a unique constraint name already defined for ${
+								chalk.underline.blue(
+									existingUnique.columns.join(','),
+								)
+							} columns\n`)
+						}`,
+					);
+					process.exit(1);
+				}
+				uniqueConstraintObject[column.uniqueName!] = {
+					name: column.uniqueName!,
+					nullsNotDistinct: column.uniqueType === 'not distinct',
+					columns: [columnToSet.name],
+				};
+			}
+
+			if (column.default !== undefined) {
+				if (is(column.default, SQL)) {
+					columnToSet.default = sqlToStr(column.default, casing);
+				} else {
+					if (typeof column.default === 'string') {
+						columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
+					} else {
+						if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
+							columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+						} else if (column.default instanceof Date) {
+							if (sqlTypeLowered === 'date') {
+								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
+							} else if (sqlTypeLowered === 'timestamp') {
+								columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
+							} else {
+								columnToSet.default = `'${column.default.toISOString()}'`;
+							}
+						} else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
+							columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+						} else {
+							// Should do for all types
+							// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
+							columnToSet.default = column.default;
+						}
+					}
+				}
+			}
+			columnsObject[name] = columnToSet;
+		});
+
+		primaryKeys.map((pk) => {
+			const originalColumnNames = pk.columns.map((c) => c.name);
+			const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
+
+			let name = pk.getName();
+			if (casing !== undefined) {
+				for (let i = 0; i < originalColumnNames.length; i++) {
+					name = name.replace(originalColumnNames[i], columnNames[i]);
+				}
+			}
+
+			primaryKeysObject[name] = {
+				name,
+				columns: columnNames,
+			};
+		});
+
+		uniqueConstraints?.map((unq) => {
+			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
+
+			const name = unq.name ?? uniqueKeyName(table, columnNames);
+
+			const existingUnique = uniqueConstraintObject[name];
+			if (typeof existingUnique !== 'undefined') {
+				console.log(
+					`\n${
+						withStyle.errorWarning(
+							`We've found duplicated unique constraint names in ${chalk.underline.blue(tableName)} table. 
+        The unique constraint ${chalk.underline.blue(name)} on the ${
+								chalk.underline.blue(
+									columnNames.join(','),
+								)
+							} columns is confilcting with a unique constraint name already defined for ${
+								chalk.underline.blue(existingUnique.columns.join(','))
+							} columns\n`,
+						)
+					}`,
+				);
+				process.exit(1);
+			}
+
+			uniqueConstraintObject[name] = {
+				name: unq.name!,
+				nullsNotDistinct: unq.nullsNotDistinct,
+				columns: columnNames,
+			};
+		});
+
+		const fks: ForeignKey[] = foreignKeys.map((fk) => {
+			const tableFrom = tableName;
+			const onDelete = fk.onDelete;
+			const onUpdate = fk.onUpdate;
+			const reference = fk.reference();
+			const tableTo = getTableName(reference.foreignTable);
+			// getTableConfig(reference.foreignTable).schema || "public";
+			const schemaTo = getTableConfig(reference.foreignTable).schema;
+
+			const originalColumnsFrom = reference.columns.map((it) => it.name);
+			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
+			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
+
+			let name = fk.getName();
+			if (casing !== undefined) {
+				for (let i = 0; i < originalColumnsFrom.length; i++) {
+					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
+				}
+				for (let i = 0; i < originalColumnsTo.length; i++) {
+					name = name.replace(originalColumnsTo[i], columnsTo[i]);
+				}
+			}
+
+			return {
+				name,
+				tableFrom,
+				tableTo,
+				schemaTo,
+				columnsFrom,
+				columnsTo,
+				onDelete,
+				onUpdate,
+			} as ForeignKey;
+		});
+
+		fks.forEach((it) => {
+			foreignKeysObject[it.name] = it;
+		});
+
+		indexes.forEach((value) => {
+			const columns = value.config.columns;
+
+			let indexColumnNames: string[] = [];
+			columns.forEach((it) => {
+				if (is(it, SQL)) {
+					if (typeof value.config.name === 'undefined') {
+						console.log(
+							`\n${
+								withStyle.errorWarning(
+									`Please specify an index name in ${getTableName(value.config.table)} table that has "${
+										dialect.sqlToQuery(it).sql
+									}" expression. We can generate index names for indexes on columns only; for expressions in indexes, you need to specify the name yourself.`,
+								)
+							}`,
+						);
+						process.exit(1);
+					}
+				}
+				it = it as IndexedColumn;
+				const name = getColumnCasing(it as IndexedColumn, casing);
+				if (
+					!is(it, SQL)
+					&& it.type! === 'PgVector'
+					&& typeof it.indexConfig!.opClass === 'undefined'
+				) {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`You are specifying an index on the ${
+									chalk.blueBright(
+										name,
+									)
+								} column inside the ${
+									chalk.blueBright(
+										tableName,
+									)
+								} table with the ${
+									chalk.blueBright(
+										'vector',
+									)
+								} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${
+									vectorOps
+										.map((it) => `${chalk.underline(`${it}`)}`)
+										.join(', ')
+								}].\n\nYou can specify it using current syntax: ${
+									chalk.underline(
+										`index("${value.config.name}").using("${value.config.method}", table.${name}.op("${
+											vectorOps[0]
+										}"))`,
+									)
+								}\n\nYou can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing\n`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+				indexColumnNames.push(name);
+			});
+
+			const name = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
+
+			let indexColumns: IndexColumnType[] = columns.map(
+				(it): IndexColumnType => {
+					if (is(it, SQL)) {
+						return {
+							expression: dialect.sqlToQuery(it, 'indexes').sql,
+							asc: true,
+							isExpression: true,
+							nulls: 'last',
+						};
+					} else {
+						it = it as IndexedColumn;
+						return {
+							expression: getColumnCasing(it as IndexedColumn, casing),
+							isExpression: false,
+							asc: it.indexConfig?.order === 'asc',
+							nulls: it.indexConfig?.nulls
+								? it.indexConfig?.nulls
+								: it.indexConfig?.order === 'desc'
+								? 'first'
+								: 'last',
+							opclass: it.indexConfig?.opClass,
+						};
+					}
+				},
+			);
+
+			// check for index names duplicates
+			if (typeof indexesInSchema[schema ?? 'public'] !== 'undefined') {
+				if (indexesInSchema[schema ?? 'public'].includes(name)) {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`We've found duplicated index name across ${
+									chalk.underline.blue(schema ?? 'public')
+								} schema. Please rename your index in either the ${
+									chalk.underline.blue(
+										tableName,
+									)
+								} table or the table with the duplicated index name`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+				indexesInSchema[schema ?? 'public'].push(name);
+			} else {
+				indexesInSchema[schema ?? 'public'] = [name];
+			}
+
+			indexesObject[name] = {
+				name,
+				columns: indexColumns,
+				isUnique: value.config.unique ?? false,
+				where: value.config.where ? dialect.sqlToQuery(value.config.where).sql : undefined,
+				concurrently: value.config.concurrently ?? false,
+				method: value.config.method ?? 'btree',
+				with: value.config.with ?? {},
+			};
+		});
+
+		policies.forEach((policy) => {
+			const mappedTo = [];
+
+			if (!policy.to) {
+				mappedTo.push('public');
+			} else {
+				if (policy.to && typeof policy.to === 'string') {
+					mappedTo.push(policy.to);
+				} else if (policy.to && is(policy.to, PgRole)) {
+					mappedTo.push(policy.to.name);
+				} else if (policy.to && Array.isArray(policy.to)) {
+					policy.to.forEach((it) => {
+						if (typeof it === 'string') {
+							mappedTo.push(it);
+						} else if (is(it, PgRole)) {
+							mappedTo.push(it.name);
+						}
+					});
+				}
+			}
+
+			if (policiesObject[policy.name] !== undefined) {
+				console.log(
+					`\n${
+						withStyle.errorWarning(
+							`We've found duplicated policy name across ${
+								chalk.underline.blue(tableKey)
+							} table. Please rename one of the policies with ${
+								chalk.underline.blue(
+									policy.name,
+								)
+							} name`,
+						)
+					}`,
+				);
+				process.exit(1);
+			}
+
+			policiesObject[policy.name] = {
+				name: policy.name,
+				as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
+				for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
+				to: mappedTo.sort(),
+				using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
+				withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
+			};
+		});
+
+		checks.forEach((check) => {
+			const checkName = check.name;
+
+			if (typeof checksInTable[`"${schema ?? 'public'}"."${tableName}"`] !== 'undefined') {
+				if (checksInTable[`"${schema ?? 'public'}"."${tableName}"`].includes(check.name)) {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`We've found duplicated check constraint name across ${
+									chalk.underline.blue(
+										schema ?? 'public',
+									)
+								} schema in ${
+									chalk.underline.blue(
+										tableName,
+									)
+								}. Please rename your check constraint in either the ${
+									chalk.underline.blue(
+										tableName,
+									)
+								} table or the table with the duplicated check contraint name`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+				checksInTable[`"${schema ?? 'public'}"."${tableName}"`].push(checkName);
+			} else {
+				checksInTable[`"${schema ?? 'public'}"."${tableName}"`] = [check.name];
+			}
+
+			checksObject[checkName] = {
+				name: checkName,
+				value: dialect.sqlToQuery(check.value).sql,
+			};
+		});
+
+		const tableKey = `${schema ?? 'public'}.${tableName}`;
+
+		result[tableKey] = {
+			name: tableName,
+			schema: schema ?? '',
+			columns: columnsObject,
+			indexes: indexesObject,
+			foreignKeys: foreignKeysObject,
+			compositePrimaryKeys: primaryKeysObject,
+			uniqueConstraints: uniqueConstraintObject,
+			policies: policiesObject,
+			checkConstraints: checksObject,
+			isRLSEnabled: enableRLS,
+		};
+	}
+
+	for (const policy of policies) {
+		// @ts-ignore
+		if (!policy._linkedTable) {
+			console.log(
+				`\n${
+					withStyle.errorWarning(
+						`"Policy ${policy.name} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`,
+					)
+				}`,
+			);
+			continue;
+		}
+
+		// @ts-ignore
+		const tableConfig = getTableConfig(policy._linkedTable);
+
+		const tableKey = `${tableConfig.schema ?? 'public'}.${tableConfig.name}`;
+
+		const mappedTo = [];
+
+		if (!policy.to) {
+			mappedTo.push('public');
+		} else {
+			if (policy.to && typeof policy.to === 'string') {
+				mappedTo.push(policy.to);
+			} else if (policy.to && is(policy.to, PgRole)) {
+				mappedTo.push(policy.to.name);
+			} else if (policy.to && Array.isArray(policy.to)) {
+				policy.to.forEach((it) => {
+					if (typeof it === 'string') {
+						mappedTo.push(it);
+					} else if (is(it, PgRole)) {
+						mappedTo.push(it.name);
+					}
+				});
+			}
+		}
+
+		// add separate policies object, that will be only responsible for policy creation
+		// but we would need to track if a policy was enabled for a specific table or not
+		// enable only if jsonStatements for enable rls was not already there + filter it
+
+		if (result[tableKey]?.policies[policy.name] !== undefined || policiesToReturn[policy.name] !== undefined) {
+			console.log(
+				`\n${
+					withStyle.errorWarning(
+						`We've found duplicated policy name across ${
+							chalk.underline.blue(tableKey)
+						} table. Please rename one of the policies with ${
+							chalk.underline.blue(
+								policy.name,
+							)
+						} name`,
+					)
+				}`,
+			);
+			process.exit(1);
+		}
+
+		const mappedPolicy = {
+			name: policy.name,
+			as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
+			for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
+			to: mappedTo.sort(),
+			using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
+			withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
+		};
+
+		if (result[tableKey]) {
+			result[tableKey].policies[policy.name] = mappedPolicy;
+		} else {
+			policiesToReturn[policy.name] = {
+				...mappedPolicy,
+				schema: tableConfig.schema ?? 'public',
+				on: `"${tableConfig.schema ?? 'public'}"."${tableConfig.name}"`,
+			};
+		}
+	}
+
+	for (const sequence of sequences) {
+		const name = sequence.seqName!;
+		if (typeof sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] === 'undefined') {
+			const increment = stringFromIdentityProperty(sequence?.seqOptions?.increment) ?? '1';
+			const minValue = stringFromIdentityProperty(sequence?.seqOptions?.minValue)
+				?? (parseFloat(increment) < 0 ? '-9223372036854775808' : '1');
+			const maxValue = stringFromIdentityProperty(sequence?.seqOptions?.maxValue)
+				?? (parseFloat(increment) < 0 ? '-1' : '9223372036854775807');
+			const startWith = stringFromIdentityProperty(sequence?.seqOptions?.startWith)
+				?? (parseFloat(increment) < 0 ? maxValue : minValue);
+			const cache = stringFromIdentityProperty(sequence?.seqOptions?.cache) ?? '1';
+
+			sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] = {
+				name,
+				schema: sequence.schema ?? 'public',
+				increment,
+				startWith,
+				minValue,
+				maxValue,
+				cache,
+				cycle: sequence.seqOptions?.cycle ?? false,
+			};
+		} else {
+			// duplicate seq error
+		}
+	}
+
+	for (const role of roles) {
+		if (!(role as any)._existing) {
+			rolesToReturn[role.name] = {
+				name: role.name,
+				createDb: (role as any).createDb === undefined ? false : (role as any).createDb,
+				createRole: (role as any).createRole === undefined ? false : (role as any).createRole,
+				inherit: (role as any).inherit === undefined ? true : (role as any).inherit,
+			};
+		}
+	}
+	const combinedViews = [...views, ...matViews];
+	for (const view of combinedViews) {
+		let viewName;
+		let schema;
+		let query;
+		let selectedFields;
+		let isExisting;
+		let withOption;
+		let tablespace;
+		let using;
+		let withNoData;
+		let materialized: boolean = false;
+
+		if (is(view, PgView)) {
+			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption } = getViewConfig(view));
+		} else {
+			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption, tablespace, using, withNoData } =
+				getMaterializedViewConfig(view));
+
+			materialized = true;
+		}
+
+		const viewSchema = schema ?? 'public';
+
+		const viewKey = `${viewSchema}.${viewName}`;
+
+		const columnsObject: Record<string, Column> = {};
+		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
+
+		const existingView = resultViews[viewKey];
+		if (typeof existingView !== 'undefined') {
+			console.log(
+				`\n${
+					withStyle.errorWarning(
+						`We've found duplicated view name across ${
+							chalk.underline.blue(schema ?? 'public')
+						} schema. Please rename your view`,
+					)
+				}`,
+			);
+			process.exit(1);
+		}
+
+		for (const key in selectedFields) {
+			if (is(selectedFields[key], PgColumn)) {
+				const column = selectedFields[key];
+
+				const notNull: boolean = column.notNull;
+				const primaryKey: boolean = column.primary;
+				const sqlTypeLowered = column.getSQLType().toLowerCase();
+
+				const typeSchema = is(column, PgEnumColumn) ? column.enum.schema || 'public' : undefined;
+				const generated = column.generated;
+				const identity = column.generatedIdentity;
+
+				const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
+				const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
+					?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
+				const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
+					?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
+				const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
+					?? (parseFloat(increment) < 0 ? maxValue : minValue);
+				const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
+
+				const columnToSet: Column = {
+					name: column.name,
+					type: column.getSQLType(),
+					typeSchema: typeSchema,
+					primaryKey,
+					notNull,
+					generated: generated
+						? {
+							as: is(generated.as, SQL)
+								? dialect.sqlToQuery(generated.as as SQL).sql
+								: typeof generated.as === 'function'
+								? dialect.sqlToQuery(generated.as() as SQL).sql
+								: (generated.as as any),
+							type: 'stored',
+						}
+						: undefined,
+					identity: identity
+						? {
+							type: identity.type,
+							name: identity.sequenceName ?? `${viewName}_${column.name}_seq`,
+							schema: schema ?? 'public',
+							increment,
+							startWith,
+							minValue,
+							maxValue,
+							cache,
+							cycle: identity?.sequenceOptions?.cycle ?? false,
+						}
+						: undefined,
+				};
+
+				if (column.isUnique) {
+					const existingUnique = uniqueConstraintObject[column.uniqueName!];
+					if (typeof existingUnique !== 'undefined') {
+						console.log(
+							`\n${
+								withStyle.errorWarning(
+									`We've found duplicated unique constraint names in ${chalk.underline.blue(viewName)} table. 
+          The unique constraint ${chalk.underline.blue(column.uniqueName)} on the ${
+										chalk.underline.blue(
+											column.name,
+										)
+									} column is confilcting with a unique constraint name already defined for ${
+										chalk.underline.blue(existingUnique.columns.join(','))
+									} columns\n`,
+								)
+							}`,
+						);
+						process.exit(1);
+					}
+					uniqueConstraintObject[column.uniqueName!] = {
+						name: column.uniqueName!,
+						nullsNotDistinct: column.uniqueType === 'not distinct',
+						columns: [columnToSet.name],
+					};
+				}
+
+				if (column.default !== undefined) {
+					if (is(column.default, SQL)) {
+						columnToSet.default = sqlToStr(column.default, casing);
+					} else {
+						if (typeof column.default === 'string') {
+							columnToSet.default = `'${column.default}'`;
+						} else {
+							if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
+								columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+							} else if (column.default instanceof Date) {
+								if (sqlTypeLowered === 'date') {
+									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
+								} else if (sqlTypeLowered === 'timestamp') {
+									columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
+								} else {
+									columnToSet.default = `'${column.default.toISOString()}'`;
+								}
+							} else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
+								columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+							} else {
+								// Should do for all types
+								// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
+								columnToSet.default = column.default;
+							}
+						}
+					}
+				}
+				columnsObject[column.name] = columnToSet;
+			}
+		}
+
+		resultViews[viewKey] = {
+			columns: columnsObject,
+			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
+			name: viewName,
+			schema: viewSchema,
+			isExisting,
+			with: withOption,
+			withNoData,
+			materialized,
+			tablespace,
+			using,
+		};
+	}
+
+	const enumsToReturn: Record<string, Enum> = enums.reduce<{
+		[key: string]: Enum;
+	}>((map, obj) => {
+		const enumSchema = obj.schema || 'public';
+		const key = `${enumSchema}.${obj.enumName}`;
+		map[key] = {
+			name: obj.enumName,
+			schema: enumSchema,
+			values: obj.enumValues,
+		};
+		return map;
+	}, {});
+
+	const schemasObject = Object.fromEntries(
+		schemas
+			.filter((it) => {
+				if (schemaFilter) {
+					return schemaFilter.includes(it.schemaName) && it.schemaName !== 'public';
+				} else {
+					return it.schemaName !== 'public';
+				}
+			})
+			.map((it) => [it.schemaName, it.schemaName]),
+	);
+
+	return {
+		version: '7',
+		dialect: 'postgresql',
+		tables: result,
+		enums: enumsToReturn,
+		schemas: schemasObject,
+		sequences: sequencesToReturn,
+		roles: rolesToReturn,
+		policies: policiesToReturn,
+		views: resultViews,
+		_meta: {
+			schemas: {},
+			tables: {},
+			columns: {},
+		},
+	};
+};
diff --git a/drizzle-kit/src/legacy/postgres-v7/serializer.ts b/drizzle-kit/src/legacy/postgres-v7/serializer.ts
new file mode 100644
index 0000000000..dbe0ac083c
--- /dev/null
+++ b/drizzle-kit/src/legacy/postgres-v7/serializer.ts
@@ -0,0 +1,61 @@
+import { is } from 'orm044';
+import type { PgEnum, PgEnumObject, PgMaterializedView, PgSequence, PgView } from 'orm044/pg-core';
+import {
+	isPgEnum,
+	isPgMaterializedView,
+	isPgSequence,
+	isPgView,
+	PgPolicy,
+	PgRole,
+	PgSchema,
+	PgTable,
+} from 'orm044/pg-core';
+import type { CasingType } from '../common';
+import type { PgSchema as SCHEMA } from './pgSchema';
+import { generatePgSnapshot } from './pgSerializer';
+
+export type PostgresSchema = Record<
+	string,
+	| PgTable<any>
+	| PgEnum<any>
+	| PgEnumObject<any>
+	| PgSchema
+	| PgSequence
+	| PgView
+	| PgMaterializedView
+	| PgRole
+	| PgPolicy
+	| unknown
+>;
+
+export const serializePg = async (
+	schema: PostgresSchema,
+	casing: CasingType | undefined,
+	schemaFilter?: string[],
+): Promise<SCHEMA> => {
+	const tables = Object.values(schema).filter((it) => is(it, PgTable)) as PgTable[];
+	const schemas = Object.values(schema).filter((it) => is(it, PgSchema)) as PgSchema[];
+	const enums = Object.values(schema).filter((it) => isPgEnum(it)) as PgEnum<any>[];
+	const sequences = Object.values(schema).filter((it) => isPgSequence(it)) as PgSequence[];
+	const roles = Object.values(schema).filter((it) => is(it, PgRole)) as PgRole[];
+	const policies = Object.values(schema).filter((it) => is(it, PgPolicy)) as PgPolicy[];
+	const views = Object.values(schema).filter((it) => isPgView(it)) as PgView[];
+	const materializedViews = Object.values(schema).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
+
+	return {
+		id: 'id',
+		prevId: 'prev_id',
+		...generatePgSnapshot(
+			tables,
+			enums,
+			schemas,
+			sequences,
+			roles,
+			policies,
+			views,
+			materializedViews,
+			casing,
+			schemaFilter,
+		),
+	};
+};
diff --git a/drizzle-kit/src/extensions/vector.ts b/drizzle-kit/src/legacy/postgres-v7/vector.ts
similarity index 100%
rename from drizzle-kit/src/extensions/vector.ts
rename to drizzle-kit/src/legacy/postgres-v7/vector.ts
diff --git a/drizzle-kit/src/legacy/schemaValidator.ts b/drizzle-kit/src/legacy/schemaValidator.ts
new file mode 100644
index 0000000000..59d8965783
--- /dev/null
+++ b/drizzle-kit/src/legacy/schemaValidator.ts
@@ -0,0 +1,19 @@
+import type { TypeOf } from 'zod';
+import { enum as enumType, union } from 'zod';
+import { mysqlSchemaSquashed } from './mysql-v5/mysqlSchema';
+import { pgSchemaSquashed } from './postgres-v7/pgSchema';
+import { SQLiteSchemaSquashed } from './sqlite-v6/sqliteSchema';
+
+export const dialects = ['postgresql', 'mysql', 'sqlite', 'turso', 'singlestore'] as const;
+export const dialect = enumType(dialects);
+
+export type Dialect = (typeof dialects)[number];
+const _: Dialect = '' as TypeOf<typeof dialect>;
+
+const commonSquashedSchema = union([
+	pgSchemaSquashed,
+	mysqlSchemaSquashed,
+	SQLiteSchemaSquashed,
+]);
+
+export type CommonSquashedSchema = TypeOf<typeof commonSquashedSchema>;
diff --git a/drizzle-kit/src/legacy/snapshotsDiffer.ts b/drizzle-kit/src/legacy/snapshotsDiffer.ts
new file mode 100644
index 0000000000..f3e5506c9f
--- /dev/null
+++ b/drizzle-kit/src/legacy/snapshotsDiffer.ts
@@ -0,0 +1,922 @@
+import chalk from 'chalk';
+import { render } from 'hanji';
+import type { TypeOf, ZodTypeAny } from 'zod';
+import { any, array, boolean, enum as enumType, literal, never, object, record, string, union } from 'zod';
+import { isInteractive } from '../cli/context';
+import { ResolveColumnSelect, ResolveSchemasSelect, ResolveSelect, ResolveSelectNamed } from '../cli/views';
+import { _prepareAddColumns, _prepareDropColumns } from './jsonStatements';
+import type { ViewSquashed } from './mysql-v5/mysqlSchema';
+import type { Policy, Role, View } from './postgres-v7/pgSchema';
+import { mergedViewWithOption, policySquashed, roleSchema, sequenceSquashed } from './postgres-v7/pgSchema';
+import type { View as SQLiteView } from './sqlite-v6/sqliteSchema';
+
+export type Named = { name: string };
+export type NamedWithSchema = {
+	name: string;
+	schema: string;
+};
+
+const makeChanged = <T extends ZodTypeAny>(schema: T) => {
+	return object({
+		type: enumType(['changed']),
+		old: schema,
+		new: schema,
+	});
+};
+
+const makeSelfOrChanged = <T extends ZodTypeAny>(schema: T) => {
+	return union([
+		schema,
+		object({
+			type: enumType(['changed']),
+			old: schema,
+			new: schema,
+		}),
+	]);
+};
+
+export const makePatched = <T extends ZodTypeAny>(schema: T) => {
+	return union([
+		object({
+			type: literal('added'),
+			value: schema,
+		}),
+		object({
+			type: literal('deleted'),
+			value: schema,
+		}),
+		object({
+			type: literal('changed'),
+			old: schema,
+			new: schema,
+		}),
+	]);
+};
+
+export const makeSelfOrPatched = <T extends ZodTypeAny>(schema: T) => {
+	return union([
+		object({
+			type: literal('none'),
+			value: schema,
+		}),
+		object({
+			type: literal('added'),
+			value: schema,
+		}),
+		object({
+			type: literal('deleted'),
+			value: schema,
+		}),
+		object({
+			type: literal('changed'),
+			old: schema,
+			new: schema,
+		}),
+	]);
+};
+
+const columnSchema = object({
+	name: string(),
+	type: string(),
+	typeSchema: string().optional(),
+	primaryKey: boolean().optional(),
+	default: any().optional(),
+	notNull: boolean().optional(),
+	// should it be optional? should if be here?
+	autoincrement: boolean().optional(),
+	onUpdate: boolean().optional(),
+	isUnique: any().optional(),
+	uniqueName: string().optional(),
+	nullsNotDistinct: boolean().optional(),
+	generated: object({
+		as: string(),
+		type: enumType(['stored', 'virtual']).default('stored'),
+	}).optional(),
+	identity: string().optional(),
+}).strict();
+
+const alteredColumnSchema = object({
+	name: makeSelfOrChanged(string()),
+	type: makeChanged(string()).optional(),
+	default: makePatched(any()).optional(),
+	primaryKey: makePatched(boolean()).optional(),
+	notNull: makePatched(boolean()).optional(),
+	typeSchema: makePatched(string()).optional(),
+	onUpdate: makePatched(boolean()).optional(),
+	autoincrement: makePatched(boolean()).optional(),
+	generated: makePatched(
+		object({
+			as: string(),
+			type: enumType(['stored', 'virtual']).default('stored'),
+		}),
+	).optional(),
+
+	identity: makePatched(string()).optional(),
+}).strict();
+
+const enumSchema = object({
+	name: string(),
+	schema: string(),
+	values: array(string()),
+}).strict();
+
+const changedEnumSchema = object({
+	name: string(),
+	schema: string(),
+	addedValues: object({
+		before: string(),
+		value: string(),
+	}).array(),
+	deletedValues: array(string()),
+}).strict();
+
+const tableScheme = object({
+	name: string(),
+	schema: string().default(''),
+	columns: record(string(), columnSchema),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()).default({}),
+	uniqueConstraints: record(string(), string()).default({}),
+	policies: record(string(), string()).default({}),
+	checkConstraints: record(string(), string()).default({}),
+	isRLSEnabled: boolean().default(false),
+}).strict();
+
+export const alteredTableScheme = object({
+	name: string(),
+	schema: string(),
+	altered: alteredColumnSchema.array(),
+	addedIndexes: record(string(), string()),
+	deletedIndexes: record(string(), string()),
+	alteredIndexes: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}).strict(),
+	),
+	addedForeignKeys: record(string(), string()),
+	deletedForeignKeys: record(string(), string()),
+	alteredForeignKeys: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}).strict(),
+	),
+	addedCompositePKs: record(string(), string()),
+	deletedCompositePKs: record(string(), string()),
+	alteredCompositePKs: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}),
+	),
+	addedUniqueConstraints: record(string(), string()),
+	deletedUniqueConstraints: record(string(), string()),
+	alteredUniqueConstraints: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}),
+	),
+	addedPolicies: record(string(), string()),
+	deletedPolicies: record(string(), string()),
+	alteredPolicies: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}),
+	),
+	addedCheckConstraints: record(
+		string(),
+		string(),
+	),
+	deletedCheckConstraints: record(
+		string(),
+		string(),
+	),
+	alteredCheckConstraints: record(
+		string(),
+		object({
+			__new: string(),
+			__old: string(),
+		}),
+	),
+}).strict();
+
+export const alteredViewCommon = object({
+	name: string(),
+	alteredDefinition: object({
+		__old: string(),
+		__new: string(),
+	}).strict().optional(),
+	alteredExisting: object({
+		__old: boolean(),
+		__new: boolean(),
+	}).strict().optional(),
+});
+
+export const alteredPgViewSchema = alteredViewCommon.merge(
+	object({
+		schema: string(),
+		deletedWithOption: mergedViewWithOption.optional(),
+		addedWithOption: mergedViewWithOption.optional(),
+		addedWith: mergedViewWithOption.optional(),
+		deletedWith: mergedViewWithOption.optional(),
+		alteredWith: mergedViewWithOption.optional(),
+		alteredSchema: object({
+			__old: string(),
+			__new: string(),
+		}).strict().optional(),
+		alteredTablespace: object({
+			__old: string(),
+			__new: string(),
+		}).strict().optional(),
+		alteredUsing: object({
+			__old: string(),
+			__new: string(),
+		}).strict().optional(),
+	}).strict(),
+);
+
+const alteredMySqlViewSchema = alteredViewCommon.merge(
+	object({
+		alteredMeta: object({
+			__old: string(),
+			__new: string(),
+		}).strict().optional(),
+	}).strict(),
+);
+
+export const diffResultScheme = object({
+	alteredTablesWithColumns: alteredTableScheme.array(),
+	alteredEnums: changedEnumSchema.array(),
+	alteredSequences: sequenceSquashed.array(),
+	alteredRoles: roleSchema.array(),
+	alteredPolicies: policySquashed.array(),
+	alteredViews: alteredPgViewSchema.array(),
+}).strict();
+
+export const diffResultSchemeMysql = object({
+	alteredTablesWithColumns: alteredTableScheme.array(),
+	alteredEnums: never().array(),
+	alteredViews: alteredMySqlViewSchema.array(),
+});
+
+export type Column = TypeOf<typeof columnSchema>;
+export type AlteredColumn = TypeOf<typeof alteredColumnSchema>;
+export type Enum = TypeOf<typeof enumSchema>;
+export type Sequence = TypeOf<typeof sequenceSquashed>;
+export type Table = TypeOf<typeof tableScheme>;
+export type AlteredTable = TypeOf<typeof alteredTableScheme>;
+export type DiffResult = TypeOf<typeof diffResultScheme>;
+
+export type DiffResultMysql = TypeOf<typeof diffResultSchemeMysql>;
+
+export interface ResolverInput<T extends { name: string }> {
+	created: T[];
+	deleted: T[];
+}
+
+export interface ResolverOutput<T extends { name: string }> {
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export interface ResolverOutputWithMoved<T extends { name: string }> {
+	created: T[];
+	moved: { name: string; schemaFrom: string; schemaTo: string }[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export interface ColumnsResolverInput<T extends { name: string }> {
+	tableName: string;
+	schema: string;
+	created: T[];
+	deleted: T[];
+}
+
+export interface TablePolicyResolverInput<T extends { name: string }> {
+	tableName: string;
+	schema: string;
+	created: T[];
+	deleted: T[];
+}
+
+export interface TablePolicyResolverOutput<T extends { name: string }> {
+	tableName: string;
+	schema: string;
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export interface PolicyResolverInput<T extends { name: string }> {
+	created: T[];
+	deleted: T[];
+}
+
+export interface PolicyResolverOutput<T extends { name: string }> {
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export interface RolesResolverInput<T extends { name: string }> {
+	created: T[];
+	deleted: T[];
+}
+
+export interface RolesResolverOutput<T extends { name: string }> {
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export interface ColumnsResolverOutput<T extends { name: string }> {
+	tableName: string;
+	schema: string;
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}
+
+export const schemaChangeFor = (
+	table: NamedWithSchema,
+	renamedSchemas: { from: Named; to: Named }[],
+) => {
+	for (let ren of renamedSchemas) {
+		if (table.schema === ren.from.name) {
+			return { key: `${ren.to.name}.${table.name}`, schema: ren.to.name };
+		}
+	}
+
+	return {
+		key: `${table.schema || 'public'}.${table.name}`,
+		schema: table.schema,
+	};
+};
+
+export const nameChangeFor = (table: Named, renamed: { from: Named; to: Named }[]) => {
+	for (let ren of renamed) {
+		if (table.name === ren.from.name) {
+			return { name: ren.to.name };
+		}
+	}
+
+	return {
+		name: table.name,
+	};
+};
+
+export const nameSchemaChangeFor = (
+	table: NamedWithSchema,
+	renamedTables: { from: NamedWithSchema; to: NamedWithSchema }[],
+) => {
+	for (let ren of renamedTables) {
+		if (table.name === ren.from.name && table.schema === ren.from.schema) {
+			return {
+				key: `${ren.to.schema || 'public'}.${ren.to.name}`,
+				name: ren.to.name,
+				schema: ren.to.schema,
+			};
+		}
+	}
+
+	return {
+		key: `${table.schema || 'public'}.${table.name}`,
+		name: table.name,
+		schema: table.schema,
+	};
+};
+
+export const columnChangeFor = (
+	column: string,
+	renamedColumns: { from: Named; to: Named }[],
+) => {
+	for (let ren of renamedColumns) {
+		if (column === ren.from.name) {
+			return ren.to.name;
+		}
+	}
+
+	return column;
+};
+
+export const schemasResolver = async (
+	input: ResolverInput<Table>,
+): Promise<ResolverOutput<Table>> => {
+	try {
+		const { created, deleted, renamed } = await promptSchemasConflict(
+			input.created,
+			input.deleted,
+		);
+
+		return { created: created, deleted: deleted, renamed: renamed };
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const tablesResolver = async (
+	input: ResolverInput<Table>,
+): Promise<ResolverOutputWithMoved<Table>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'table',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const sqliteViewsResolver = async (
+	input: ResolverInput<SQLiteView & { schema: '' }>,
+): Promise<ResolverOutputWithMoved<SQLiteView>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'view',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const mySqlViewsResolver = async (
+	input: ResolverInput<ViewSquashed & { schema: '' }>,
+): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'view',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const viewsResolver = async (
+	input: ResolverInput<View>,
+): Promise<ResolverOutputWithMoved<View>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'view',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export interface RenamePropmtItem<T> {
+	from: T;
+	to: T;
+}
+
+export const isRenamePromptItem = <T extends Named>(
+	item: RenamePropmtItem<T> | T,
+): item is RenamePropmtItem<T> => {
+	return 'from' in item && 'to' in item;
+};
+
+export const sequencesResolver = async (
+	input: ResolverInput<Sequence>,
+): Promise<ResolverOutputWithMoved<Sequence>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'sequence',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const roleResolver = async (
+	input: RolesResolverInput<Role>,
+): Promise<RolesResolverOutput<Role>> => {
+	const result = await promptNamedConflict(
+		input.created,
+		input.deleted,
+		'role',
+	);
+	return {
+		created: result.created,
+		deleted: result.deleted,
+		renamed: result.renamed,
+	};
+};
+
+export const policyResolver = async (
+	input: TablePolicyResolverInput<Policy>,
+): Promise<TablePolicyResolverOutput<Policy>> => {
+	const result = await promptColumnsConflicts(
+		input.tableName,
+		input.created,
+		input.deleted,
+	);
+	return {
+		tableName: input.tableName,
+		schema: input.schema,
+		created: result.created,
+		deleted: result.deleted,
+		renamed: result.renamed,
+	};
+};
+
+export const indPolicyResolver = async (
+	input: PolicyResolverInput<Policy>,
+): Promise<PolicyResolverOutput<Policy>> => {
+	const result = await promptNamedConflict(
+		input.created,
+		input.deleted,
+		'policy',
+	);
+	return {
+		created: result.created,
+		deleted: result.deleted,
+		renamed: result.renamed,
+	};
+};
+
+export const enumsResolver = async (
+	input: ResolverInput<Enum>,
+): Promise<ResolverOutputWithMoved<Enum>> => {
+	try {
+		const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
+			input.created,
+			input.deleted,
+			'enum',
+		);
+
+		return {
+			created: created,
+			deleted: deleted,
+			moved: moved,
+			renamed: renamed,
+		};
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
+
+export const columnsResolver = async (
+	input: ColumnsResolverInput<Column>,
+): Promise<ColumnsResolverOutput<Column>> => {
+	const result = await promptColumnsConflicts(
+		input.tableName,
+		input.created,
+		input.deleted,
+	);
+	return {
+		tableName: input.tableName,
+		schema: input.schema,
+		created: result.created,
+		deleted: result.deleted,
+		renamed: result.renamed,
+	};
+};
+
+export const promptColumnsConflicts = async <T extends Named>(
+	tableName: string,
+	newColumns: T[],
+	missingColumns: T[],
+) => {
+	if (newColumns.length === 0 || missingColumns.length === 0) {
+		return { created: newColumns, renamed: [], deleted: missingColumns };
+	}
+	const result: { created: T[]; renamed: { from: T; to: T }[]; deleted: T[] } = {
+		created: [],
+		renamed: [],
+		deleted: [],
+	};
+
+	let index = 0;
+	let leftMissing = [...missingColumns];
+
+	do {
+		const created = newColumns[index];
+
+		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
+			return { from: it, to: created };
+		});
+
+		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
+
+		const { status, data } = isInteractive()
+			? await render(new ResolveColumnSelect<T>(tableName, created, promptData))
+			: { status: 'submitted' as const, data: created };
+		if (status === 'aborted') {
+			console.error('ERROR');
+			process.exit(1);
+		}
+
+		if (isRenamePromptItem(data)) {
+			console.log(
+				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
+					chalk.gray(
+						'column will be renamed',
+					)
+				}`,
+			);
+			result.renamed.push(data);
+			// this will make [item1, undefined, item2]
+			delete leftMissing[leftMissing.indexOf(data.from)];
+			// this will make [item1, item2]
+			leftMissing = leftMissing.filter(Boolean);
+		} else {
+			console.log(
+				`${chalk.green('+')} ${data.name} ${
+					chalk.gray(
+						'column will be created',
+					)
+				}`,
+			);
+			result.created.push(created);
+		}
+		index += 1;
+	} while (index < newColumns.length);
+	console.log(
+		chalk.gray(`--- all columns conflicts in ${tableName} table resolved ---\n`),
+	);
+
+	result.deleted.push(...leftMissing);
+	return result;
+};
+
+export const promptNamedConflict = async <T extends Named>(
+	newItems: T[],
+	missingItems: T[],
+	entity: 'role' | 'policy',
+): Promise<{
+	created: T[];
+	renamed: { from: T; to: T }[];
+	deleted: T[];
+}> => {
+	if (missingItems.length === 0 || newItems.length === 0) {
+		return {
+			created: newItems,
+			renamed: [],
+			deleted: missingItems,
+		};
+	}
+
+	const result: {
+		created: T[];
+		renamed: { from: T; to: T }[];
+		deleted: T[];
+	} = { created: [], renamed: [], deleted: [] };
+	let index = 0;
+	let leftMissing = [...missingItems];
+	do {
+		const created = newItems[index];
+		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
+			return { from: it, to: created };
+		});
+
+		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
+
+		const { status, data } = isInteractive()
+			? await render(new ResolveSelectNamed<T>(created, promptData, entity))
+			: { status: 'submitted' as const, data: created };
+		if (status === 'aborted') {
+			console.error('ERROR');
+			process.exit(1);
+		}
+
+		if (isRenamePromptItem(data)) {
+			console.log(
+				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
+					chalk.gray(
+						`${entity} will be renamed/moved`,
+					)
+				}`,
+			);
+
+			if (data.from.name !== data.to.name) {
+				result.renamed.push(data);
+			}
+
+			delete leftMissing[leftMissing.indexOf(data.from)];
+			leftMissing = leftMissing.filter(Boolean);
+		} else {
+			console.log(
+				`${chalk.green('+')} ${data.name} ${
+					chalk.gray(
+						`${entity} will be created`,
+					)
+				}`,
+			);
+			result.created.push(created);
+		}
+		index += 1;
+	} while (index < newItems.length);
+	console.log(chalk.gray(`--- all ${entity} conflicts resolved ---\n`));
+	result.deleted.push(...leftMissing);
+	return result;
+};
+
+export const promptNamedWithSchemasConflict = async <T extends NamedWithSchema>(
+	newItems: T[],
+	missingItems: T[],
+	entity: 'table' | 'enum' | 'sequence' | 'view',
+): Promise<{
+	created: T[];
+	renamed: { from: T; to: T }[];
+	moved: { name: string; schemaFrom: string; schemaTo: string }[];
+	deleted: T[];
+}> => {
+	if (missingItems.length === 0 || newItems.length === 0) {
+		return {
+			created: newItems,
+			renamed: [],
+			moved: [],
+			deleted: missingItems,
+		};
+	}
+
+	const result: {
+		created: T[];
+		renamed: { from: T; to: T }[];
+		moved: { name: string; schemaFrom: string; schemaTo: string }[];
+		deleted: T[];
+	} = { created: [], renamed: [], moved: [], deleted: [] };
+	let index = 0;
+	let leftMissing = [...missingItems];
+	do {
+		const created = newItems[index];
+		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
+			return { from: it, to: created };
+		});
+
+		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
+
+		const { status, data } = isInteractive()
+			? await render(new ResolveSelect<T>(created, promptData, entity))
+			: { status: 'submitted' as const, data: created };
+		if (status === 'aborted') {
+			console.error('ERROR');
+			process.exit(1);
+		}
+
+		if (isRenamePromptItem(data)) {
+			const schemaFromPrefix = !data.from.schema || data.from.schema === 'public'
+				? ''
+				: `${data.from.schema}.`;
+			const schemaToPrefix = !data.to.schema || data.to.schema === 'public'
+				? ''
+				: `${data.to.schema}.`;
+
+			console.log(
+				`${chalk.yellow('~')} ${schemaFromPrefix}${data.from.name} › ${schemaToPrefix}${data.to.name} ${
+					chalk.gray(
+						`${entity} will be renamed/moved`,
+					)
+				}`,
+			);
+
+			if (data.from.name !== data.to.name) {
+				result.renamed.push(data);
+			}
+
+			if (data.from.schema !== data.to.schema) {
+				result.moved.push({
+					name: data.from.name,
+					schemaFrom: data.from.schema || 'public',
+					schemaTo: data.to.schema || 'public',
+				});
+			}
+
+			delete leftMissing[leftMissing.indexOf(data.from)];
+			leftMissing = leftMissing.filter(Boolean);
+		} else {
+			console.log(
+				`${chalk.green('+')} ${data.name} ${
+					chalk.gray(
+						`${entity} will be created`,
+					)
+				}`,
+			);
+			result.created.push(created);
+		}
+		index += 1;
+	} while (index < newItems.length);
+	console.log(chalk.gray(`--- all ${entity} conflicts resolved ---\n`));
+	result.deleted.push(...leftMissing);
+	return result;
+};
+
+export const promptSchemasConflict = async <T extends Named>(
+	newSchemas: T[],
+	missingSchemas: T[],
+): Promise<{ created: T[]; renamed: { from: T; to: T }[]; deleted: T[] }> => {
+	if (missingSchemas.length === 0 || newSchemas.length === 0) {
+		return { created: newSchemas, renamed: [], deleted: missingSchemas };
+	}
+
+	const result: { created: T[]; renamed: { from: T; to: T }[]; deleted: T[] } = {
+		created: [],
+		renamed: [],
+		deleted: [],
+	};
+	let index = 0;
+	let leftMissing = [...missingSchemas];
+	do {
+		const created = newSchemas[index];
+		const renames: RenamePropmtItem<T>[] = leftMissing.map((it) => {
+			return { from: it, to: created };
+		});
+
+		const promptData: (RenamePropmtItem<T> | T)[] = [created, ...renames];
+
+		const { status, data } = isInteractive()
+			? await render(new ResolveSchemasSelect<T>(created, promptData))
+			: { status: 'submitted' as const, data: created };
+		if (status === 'aborted') {
+			console.error('ERROR');
+			process.exit(1);
+		}
+
+		if (isRenamePromptItem(data)) {
+			console.log(
+				`${chalk.yellow('~')} ${data.from.name} › ${data.to.name} ${
+					chalk.gray(
+						'schema will be renamed',
+					)
+				}`,
+			);
+			result.renamed.push(data);
+			delete leftMissing[leftMissing.indexOf(data.from)];
+			leftMissing = leftMissing.filter(Boolean);
+		} else {
+			console.log(
+				`${chalk.green('+')} ${data.name} ${
+					chalk.gray(
+						'schema will be created',
+					)
+				}`,
+			);
+			result.created.push(created);
+		}
+		index += 1;
+	} while (index < newSchemas.length);
+	console.log(chalk.gray('--- all schemas conflicts resolved ---\n'));
+	result.deleted.push(...leftMissing);
+	return result;
+};
diff --git a/drizzle-kit/src/legacy/sqlgenerator.ts b/drizzle-kit/src/legacy/sqlgenerator.ts
new file mode 100644
index 0000000000..946329fb8c
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlgenerator.ts
@@ -0,0 +1,2634 @@
+import type {
+	JsonAddColumnStatement,
+	JsonAddValueToEnumStatement,
+	JsonAlterColumnAlterGeneratedStatement,
+	JsonAlterColumnAlterIdentityStatement,
+	JsonAlterColumnDropDefaultStatement,
+	JsonAlterColumnDropGeneratedStatement,
+	JsonAlterColumnDropIdentityStatement,
+	JsonAlterColumnDropNotNullStatement,
+	JsonAlterColumnDropPrimaryKeyStatement,
+	JsonAlterColumnPgTypeStatement,
+	JsonAlterColumnSetDefaultStatement,
+	JsonAlterColumnSetGeneratedStatement,
+	JsonAlterColumnSetIdentityStatement,
+	JsonAlterColumnSetNotNullStatement,
+	JsonAlterColumnSetPrimaryKeyStatement,
+	JsonAlterCompositePK,
+	JsonAlterIndPolicyStatement,
+	JsonAlterPolicyStatement,
+	JsonAlterReferenceStatement,
+	JsonAlterRoleStatement,
+	JsonAlterSequenceStatement,
+	JsonAlterTableRemoveFromSchema,
+	JsonAlterTableSetNewSchema,
+	JsonAlterTableSetSchema,
+	JsonAlterViewAddWithOptionStatement,
+	JsonAlterViewAlterSchemaStatement,
+	JsonAlterViewAlterTablespaceStatement,
+	JsonAlterViewAlterUsingStatement,
+	JsonAlterViewDropWithOptionStatement,
+	JsonCreateCheckConstraint,
+	JsonCreateCompositePK,
+	JsonCreateEnumStatement,
+	JsonCreateIndexStatement,
+	JsonCreateIndPolicyStatement,
+	JsonCreatePgViewStatement,
+	JsonCreatePolicyStatement,
+	JsonCreateReferenceStatement,
+	JsonCreateRoleStatement,
+	JsonCreateSchema,
+	JsonCreateSequenceStatement,
+	JsonCreateSqliteViewStatement,
+	JsonCreateTableStatement,
+	JsonCreateUniqueConstraint,
+	JsonDeleteCheckConstraint,
+	JsonDeleteCompositePK,
+	JsonDeleteReferenceStatement,
+	JsonDeleteUniqueConstraint,
+	JsonDisableRLSStatement,
+	JsonDropColumnStatement,
+	JsonDropEnumStatement,
+	JsonDropIndexStatement,
+	JsonDropIndPolicyStatement,
+	JsonDropPolicyStatement,
+	JsonDropRoleStatement,
+	JsonDropSequenceStatement,
+	JsonDropTableStatement,
+	JsonDropValueFromEnumStatement,
+	JsonDropViewStatement,
+	JsonEnableRLSStatement,
+	JsonIndRenamePolicyStatement,
+	JsonMoveEnumStatement,
+	JsonMoveSequenceStatement,
+	JsonPgCreateIndexStatement,
+	JsonRecreateTableStatement,
+	JsonRenameColumnStatement,
+	JsonRenameEnumStatement,
+	JsonRenamePolicyStatement,
+	JsonRenameRoleStatement,
+	JsonRenameSchema,
+	JsonRenameSequenceStatement,
+	JsonRenameTableStatement,
+	JsonRenameViewStatement,
+	JsonSqliteAddColumnStatement,
+	JsonSqliteCreateTableStatement,
+	JsonStatement,
+} from './jsonStatements';
+import { PgSquasher } from './postgres-v7/pgSchema';
+import type { Dialect } from './schemaValidator';
+import { SQLiteSquasher } from './sqlite-v6/sqliteSchema';
+
+export const BREAKPOINT = '--> statement-breakpoint\n';
+
+import { escapeSingleQuotes } from './utils';
+
+const parseType = (schemaPrefix: string, type: string) => {
+	const pgNativeTypes = [
+		'uuid',
+		'smallint',
+		'integer',
+		'bigint',
+		'boolean',
+		'text',
+		'varchar',
+		'serial',
+		'bigserial',
+		'decimal',
+		'numeric',
+		'real',
+		'json',
+		'jsonb',
+		'time',
+		'time with time zone',
+		'time without time zone',
+		'time',
+		'timestamp',
+		'timestamp with time zone',
+		'timestamp without time zone',
+		'date',
+		'interval',
+		'bigint',
+		'bigserial',
+		'double precision',
+		'interval year',
+		'interval month',
+		'interval day',
+		'interval hour',
+		'interval minute',
+		'interval second',
+		'interval year to month',
+		'interval day to hour',
+		'interval day to minute',
+		'interval day to second',
+		'interval hour to minute',
+		'interval hour to second',
+		'interval minute to second',
+		'char',
+		'vector',
+		'geometry',
+	];
+	const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+	const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join('');
+	const withoutArrayDefinition = type.replace(arrayDefinitionRegex, '');
+	return pgNativeTypes.some((it) => type.startsWith(it))
+		? `${withoutArrayDefinition}${arrayDefinition}`
+		: `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
+};
+
+abstract class Convertor {
+	abstract can(
+		statement: JsonStatement,
+		dialect: Dialect,
+	): boolean;
+	abstract convert(
+		statement: JsonStatement,
+		action?: 'push',
+	): string | string[];
+}
+
+class PgCreateRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreateRoleStatement): string | string[] {
+		return `CREATE ROLE "${statement.name}"${
+			statement.values.createDb || statement.values.createRole || !statement.values.inherit
+				? ` WITH${statement.values.createDb ? ' CREATEDB' : ''}${statement.values.createRole ? ' CREATEROLE' : ''}${
+					statement.values.inherit ? '' : ' NOINHERIT'
+				}`
+				: ''
+		};`;
+	}
+}
+
+class PgDropRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropRoleStatement): string | string[] {
+		return `DROP ROLE "${statement.name}";`;
+	}
+}
+
+class PgRenameRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonRenameRoleStatement): string | string[] {
+		return `ALTER ROLE "${statement.nameFrom}" RENAME TO "${statement.nameTo}";`;
+	}
+}
+
+class PgAlterRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterRoleStatement): string | string[] {
+		return `ALTER ROLE "${statement.name}"${` WITH${statement.values.createDb ? ' CREATEDB' : ' NOCREATEDB'}${
+			statement.values.createRole ? ' CREATEROLE' : ' NOCREATEROLE'
+		}${statement.values.inherit ? ' INHERIT' : ' NOINHERIT'}`};`;
+	}
+}
+
+/////
+
+class PgCreatePolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreatePolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+		const policyToPart = policy.to?.map((v) =>
+			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+		).join(', ');
+
+		return `CREATE POLICY "${policy.name}" ON ${tableNameWithSchema} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+	}
+}
+
+class PgDropPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `DROP POLICY "${policy.name}" ON ${tableNameWithSchema} CASCADE;`;
+	}
+}
+
+class PgRenamePolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonRenamePolicyStatement): string | string[] {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER POLICY "${statement.oldName}" ON ${tableNameWithSchema} RENAME TO "${statement.newName}";`;
+	}
+}
+
+class PgAlterPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterPolicyStatement, _dialect: any, action?: string): string | string[] {
+		const newPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(statement.newData)
+			: PgSquasher.unsquashPolicy(statement.newData);
+		const oldPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(statement.oldData)
+			: PgSquasher.unsquashPolicy(statement.oldData);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		const usingPart = newPolicy.using
+			? ` USING (${newPolicy.using})`
+			: oldPolicy.using
+			? ` USING (${oldPolicy.using})`
+			: '';
+
+		const withCheckPart = newPolicy.withCheck
+			? ` WITH CHECK (${newPolicy.withCheck})`
+			: oldPolicy.withCheck
+			? ` WITH CHECK  (${oldPolicy.withCheck})`
+			: '';
+
+		return `ALTER POLICY "${oldPolicy.name}" ON ${tableNameWithSchema} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
+	}
+}
+
+////
+
+class PgCreateIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreateIndPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+		const policyToPart = policy.to?.map((v) =>
+			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+		).join(', ');
+
+		return `CREATE POLICY "${policy.name}" ON ${policy.on} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+	}
+}
+
+class PgDropIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropIndPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		return `DROP POLICY "${policy.name}" ON ${policy.on} CASCADE;`;
+	}
+}
+
+class PgRenameIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonIndRenamePolicyStatement): string | string[] {
+		return `ALTER POLICY "${statement.oldName}" ON ${statement.tableKey} RENAME TO "${statement.newName}";`;
+	}
+}
+
+class PgAlterIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterIndPolicyStatement): string | string[] {
+		const newPolicy = statement.newData;
+		const oldPolicy = statement.oldData;
+
+		const usingPart = newPolicy.using
+			? ` USING (${newPolicy.using})`
+			: oldPolicy.using
+			? ` USING (${oldPolicy.using})`
+			: '';
+
+		const withCheckPart = newPolicy.withCheck
+			? ` WITH CHECK (${newPolicy.withCheck})`
+			: oldPolicy.withCheck
+			? ` WITH CHECK  (${oldPolicy.withCheck})`
+			: '';
+
+		return `ALTER POLICY "${oldPolicy.name}" ON ${oldPolicy.on} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
+	}
+}
+
+////
+
+class PgEnableRlsConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'enable_rls' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonEnableRLSStatement): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ENABLE ROW LEVEL SECURITY;`;
+	}
+}
+
+class PgDisableRlsConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'disable_rls' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDisableRLSStatement): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DISABLE ROW LEVEL SECURITY;`;
+	}
+}
+
+class PgCreateTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_table' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreateTableStatement) {
+		const { tableName, schema, columns, compositePKs, uniqueConstraints, checkConstraints, policies, isRLSEnabled } =
+			st;
+
+		let statement = '';
+		const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+
+		statement += `CREATE TABLE ${name} (\n`;
+		for (let i = 0; i < columns.length; i++) {
+			const column = columns[i];
+
+			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
+			const notNullStatement = column.notNull && !column.identity ? ' NOT NULL' : '';
+			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}::${column.type}` : '';
+
+			const uniqueConstraint = column.isUnique
+				? ` CONSTRAINT "${column.uniqueName}" UNIQUE${column.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''}`
+				: '';
+
+			const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+				? `"${column.typeSchema}".`
+				: '';
+
+			const type = parseType(schemaPrefix, column.type);
+			const generated = column.generated;
+
+			const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+			const unsquashedIdentity = column.identity
+				? PgSquasher.unsquashIdentity(column.identity)
+				: undefined;
+
+			const identityWithSchema = schema
+				? `"${schema}"."${unsquashedIdentity?.name}"`
+				: `"${unsquashedIdentity?.name}"`;
+
+			const identity = unsquashedIdentity
+				? ` GENERATED ${
+					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+				} AS IDENTITY (sequence name ${identityWithSchema}${
+					unsquashedIdentity.increment
+						? ` INCREMENT BY ${unsquashedIdentity.increment}`
+						: ''
+				}${
+					unsquashedIdentity.minValue
+						? ` MINVALUE ${unsquashedIdentity.minValue}`
+						: ''
+				}${
+					unsquashedIdentity.maxValue
+						? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+						: ''
+				}${
+					unsquashedIdentity.startWith
+						? ` START WITH ${unsquashedIdentity.startWith}`
+						: ''
+				}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+					unsquashedIdentity.cycle ? ` CYCLE` : ''
+				})`
+				: '';
+
+			statement += '\t'
+				+ `"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${uniqueConstraint}${identity}`;
+			statement += i === columns.length - 1 ? '' : ',\n';
+		}
+
+		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
+			statement += ',\n';
+			const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
+			statement += `\tCONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK.columns.join(`","`)}")`;
+			// statement += `\n`;
+		}
+
+		if (
+			typeof uniqueConstraints !== 'undefined'
+			&& uniqueConstraints.length > 0
+		) {
+			for (const uniqueConstraint of uniqueConstraints) {
+				statement += ',\n';
+				const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint);
+				statement += `\tCONSTRAINT "${unsquashedUnique.name}" UNIQUE${
+					unsquashedUnique.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
+				}("${unsquashedUnique.columns.join(`","`)}")`;
+				// statement += `\n`;
+			}
+		}
+
+		if (typeof checkConstraints !== 'undefined' && checkConstraints.length > 0) {
+			for (const checkConstraint of checkConstraints) {
+				statement += ',\n';
+				const unsquashedCheck = PgSquasher.unsquashCheck(checkConstraint);
+				statement += `\tCONSTRAINT "${unsquashedCheck.name}" CHECK (${unsquashedCheck.value})`;
+			}
+		}
+
+		statement += `\n);`;
+		statement += `\n`;
+
+		const enableRls = new PgEnableRlsConvertor().convert({
+			type: 'enable_rls',
+			tableName,
+			schema,
+		});
+
+		return [statement, ...(policies && policies.length > 0 || isRLSEnabled ? [enableRls] : [])];
+	}
+}
+
+class PgCreateViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreatePgViewStatement) {
+		const { definition, name: viewName, schema, with: withOption, materialized, withNoData, tablespace, using } = st;
+
+		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+
+		let statement = materialized ? `CREATE MATERIALIZED VIEW ${name}` : `CREATE VIEW ${name}`;
+
+		if (using) statement += ` USING "${using}"`;
+
+		const options: string[] = [];
+		if (withOption) {
+			statement += ` WITH (`;
+
+			Object.entries(withOption).forEach(([key, value]) => {
+				if (typeof value === 'undefined') return;
+
+				options.push(`${key.snake_case()} = ${value}`);
+			});
+
+			statement += options.join(', ');
+
+			statement += `)`;
+		}
+
+		if (tablespace) statement += ` TABLESPACE ${tablespace}`;
+
+		statement += ` AS (${definition})`;
+
+		if (withNoData) statement += ` WITH NO DATA`;
+
+		statement += `;`;
+
+		return statement;
+	}
+}
+
+class PgDropViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonDropViewStatement) {
+		const { name: viewName, schema, materialized } = st;
+
+		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+
+		return `DROP${materialized ? ' MATERIALIZED' : ''} VIEW ${name};`;
+	}
+}
+
+class PgRenameViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonRenameViewStatement) {
+		const { nameFrom: from, nameTo: to, schema, materialized } = st;
+
+		const nameFrom = `"${schema}"."${from}"`;
+
+		return `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW ${nameFrom} RENAME TO "${to}";`;
+	}
+}
+
+class PgAlterViewSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_schema' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterSchemaStatement) {
+		const { fromSchema, toSchema, name, materialized } = st;
+
+		const statement = `ALTER${
+			materialized ? ' MATERIALIZED' : ''
+		} VIEW "${fromSchema}"."${name}" SET SCHEMA "${toSchema}";`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewAddWithOptionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_add_with_option' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAddWithOptionStatement) {
+		const { schema, with: withOption, name, materialized } = st;
+
+		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" SET (`;
+
+		const options: string[] = [];
+
+		Object.entries(withOption).forEach(([key, value]) => {
+			options.push(`${key.snake_case()} = ${value}`);
+		});
+
+		statement += options.join(', ');
+
+		statement += `);`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewDropWithOptionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_drop_with_option' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewDropWithOptionStatement) {
+		const { schema, name, materialized, with: withOptions } = st;
+
+		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" RESET (`;
+
+		const options: string[] = [];
+
+		Object.entries(withOptions).forEach(([key]) => {
+			options.push(`${key.snake_case()}`);
+		});
+
+		statement += options.join(', ');
+
+		statement += ');';
+
+		return statement;
+	}
+}
+
+class PgAlterViewAlterTablespaceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_tablespace' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterTablespaceStatement) {
+		const { schema, name, toTablespace } = st;
+
+		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET TABLESPACE ${toTablespace};`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewAlterUsingConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_using' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterUsingStatement) {
+		const { schema, name, toUsing } = st;
+
+		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET ACCESS METHOD "${toUsing}";`;
+
+		return statement;
+	}
+}
+
+class PgAlterTableAlterColumnSetGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnSetIdentityStatement,
+	): string | string[] {
+		const { identity, tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
+
+		const identityWithSchema = schema
+			? `"${schema}"."${unsquashedIdentity?.name}"`
+			: `"${unsquashedIdentity?.name}"`;
+
+		const identityStatement = unsquashedIdentity
+			? ` GENERATED ${
+				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+			} AS IDENTITY (sequence name ${identityWithSchema}${
+				unsquashedIdentity.increment
+					? ` INCREMENT BY ${unsquashedIdentity.increment}`
+					: ''
+			}${
+				unsquashedIdentity.minValue
+					? ` MINVALUE ${unsquashedIdentity.minValue}`
+					: ''
+			}${
+				unsquashedIdentity.maxValue
+					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+					: ''
+			}${
+				unsquashedIdentity.startWith
+					? ` START WITH ${unsquashedIdentity.startWith}`
+					: ''
+			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+				unsquashedIdentity.cycle ? ` CYCLE` : ''
+			})`
+			: '';
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" ADD${identityStatement};`;
+	}
+}
+
+class PgAlterTableAlterColumnDropGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnDropIdentityStatement,
+	): string | string[] {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP IDENTITY;`;
+	}
+}
+
+class PgAlterTableAlterColumnAlterGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_change_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnAlterIdentityStatement,
+	): string | string[] {
+		const { identity, oldIdentity, tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
+		const unsquashedOldIdentity = PgSquasher.unsquashIdentity(oldIdentity);
+
+		const statementsToReturn: string[] = [];
+
+		if (unsquashedOldIdentity.type !== unsquashedIdentity.type) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET GENERATED ${
+					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+				};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.minValue !== unsquashedIdentity.minValue) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MINVALUE ${unsquashedIdentity.minValue};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.maxValue !== unsquashedIdentity.maxValue) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MAXVALUE ${unsquashedIdentity.maxValue};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.increment !== unsquashedIdentity.increment) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET INCREMENT BY ${unsquashedIdentity.increment};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.startWith !== unsquashedIdentity.startWith) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET START WITH ${unsquashedIdentity.startWith};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.cache !== unsquashedIdentity.cache) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET CACHE ${unsquashedIdentity.cache};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.cycle !== unsquashedIdentity.cycle) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET ${
+					unsquashedIdentity.cycle ? `CYCLE` : 'NO CYCLE'
+				};`,
+			);
+		}
+
+		return statementsToReturn;
+	}
+}
+
+class PgAlterTableAddUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'create_unique_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonCreateUniqueConstraint): string {
+		const unsquashed = PgSquasher.unsquashUnique(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" UNIQUE${
+			unsquashed.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
+		}("${unsquashed.columns.join('","')}");`;
+	}
+}
+
+class PgAlterTableDropUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'delete_unique_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonDeleteUniqueConstraint): string {
+		const unsquashed = PgSquasher.unsquashUnique(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unsquashed.name}";`;
+	}
+}
+
+class PgAlterTableAddCheckConstraintConvertor extends Convertor {
+	can(statement: JsonCreateCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'create_check_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonCreateCheckConstraint): string {
+		const unsquashed = PgSquasher.unsquashCheck(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" CHECK (${unsquashed.value});`;
+	}
+}
+
+class PgAlterTableDeleteCheckConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'delete_check_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonDeleteCheckConstraint): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
+	}
+}
+
+class CreatePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreateSequenceStatement) {
+		const { name, values, schema } = st;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `CREATE SEQUENCE ${sequenceWithSchema}${values.increment ? ` INCREMENT BY ${values.increment}` : ''}${
+			values.minValue ? ` MINVALUE ${values.minValue}` : ''
+		}${values.maxValue ? ` MAXVALUE ${values.maxValue}` : ''}${
+			values.startWith ? ` START WITH ${values.startWith}` : ''
+		}${values.cache ? ` CACHE ${values.cache}` : ''}${values.cycle ? ` CYCLE` : ''};`;
+	}
+}
+
+class DropPgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonDropSequenceStatement) {
+		const { name, schema } = st;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `DROP SEQUENCE ${sequenceWithSchema};`;
+	}
+}
+
+class RenamePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonRenameSequenceStatement) {
+		const { nameFrom, nameTo, schema } = st;
+
+		const sequenceWithSchemaFrom = schema
+			? `"${schema}"."${nameFrom}"`
+			: `"${nameFrom}"`;
+		// const sequenceWithSchemaTo = schema
+		// 	? `"${schema}"."${nameTo}"`
+		// 	: `"${nameTo}"`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${nameTo}";`;
+	}
+}
+
+class MovePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'move_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonMoveSequenceStatement) {
+		const { schemaFrom, schemaTo, name } = st;
+
+		const sequenceWithSchema = schemaFrom
+			? `"${schemaFrom}"."${name}"`
+			: `"${name}"`;
+
+		const seqSchemaTo = schemaTo ? `"${schemaTo}"` : `public`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
+	}
+}
+
+class AlterPgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterSequenceStatement) {
+		const { name, schema, values } = st;
+
+		const { increment, minValue, maxValue, startWith, cache, cycle } = values;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchema}${increment ? ` INCREMENT BY ${increment}` : ''}${
+			minValue ? ` MINVALUE ${minValue}` : ''
+		}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+			cache ? ` CACHE ${cache}` : ''
+		}${cycle ? ` CYCLE` : ''};`;
+	}
+}
+
+class CreateTypeEnumConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'create_type_enum';
+	}
+
+	convert(st: JsonCreateEnumStatement) {
+		const { name, values, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		let valuesStatement = '(';
+		valuesStatement += values.map((it) => `'${escapeSingleQuotes(it)}'`).join(', ');
+		valuesStatement += ')';
+
+		// let statement = 'DO $$ BEGIN';
+		// statement += '\n';
+		let statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+		// statement += '\n';
+		// statement += 'EXCEPTION';
+		// statement += '\n';
+		// statement += ' WHEN duplicate_object THEN null;';
+		// statement += '\n';
+		// statement += 'END $$;';
+		// statement += '\n';
+		return statement;
+	}
+}
+
+class DropTypeEnumConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'drop_type_enum';
+	}
+
+	convert(st: JsonDropEnumStatement) {
+		const { name, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		let statement = `DROP TYPE ${enumNameWithSchema};`;
+
+		return statement;
+	}
+}
+
+class AlterTypeAddValueConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'alter_type_add_value';
+	}
+
+	convert(st: JsonAddValueToEnumStatement) {
+		const { name, schema, value, before } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} ADD VALUE '${value}'${before.length ? ` BEFORE '${before}'` : ''};`;
+	}
+}
+
+class AlterTypeSetSchemaConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'move_type_enum';
+	}
+
+	convert(st: JsonMoveEnumStatement) {
+		const { name, schemaFrom, schemaTo } = st;
+
+		const enumNameWithSchema = schemaFrom ? `"${schemaFrom}"."${name}"` : `"${name}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${schemaTo}";`;
+	}
+}
+
+class AlterRenameTypeConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'rename_type_enum';
+	}
+
+	convert(st: JsonRenameEnumStatement) {
+		const { nameTo, nameFrom, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${nameFrom}"` : `"${nameFrom}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} RENAME TO "${nameTo}";`;
+	}
+}
+
+class AlterTypeDropValueConvertor extends Convertor {
+	can(statement: JsonDropValueFromEnumStatement): boolean {
+		return statement.type === 'alter_type_drop_value';
+	}
+
+	convert(st: JsonDropValueFromEnumStatement) {
+		const { columnsWithEnum, name, newValues, enumSchema } = st;
+
+		const statements: string[] = [];
+
+		for (const withEnum of columnsWithEnum) {
+			const tableNameWithSchema = withEnum.tableSchema
+				? `"${withEnum.tableSchema}"."${withEnum.table}"`
+				: `"${withEnum.table}"`;
+
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE text;`,
+			);
+			if (withEnum.default) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::text;`,
+				);
+			}
+		}
+
+		statements.push(new DropTypeEnumConvertor().convert({ name: name, schema: enumSchema, type: 'drop_type_enum' }));
+
+		statements.push(new CreateTypeEnumConvertor().convert({
+			name: name,
+			schema: enumSchema,
+			values: newValues,
+			type: 'create_type_enum',
+		}));
+
+		for (const withEnum of columnsWithEnum) {
+			const tableNameWithSchema = withEnum.tableSchema
+				? `"${withEnum.tableSchema}"."${withEnum.table}"`
+				: `"${withEnum.table}"`;
+
+			const parsedType = parseType(`"${enumSchema}".`, withEnum.columnType);
+			if (withEnum.default) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::${parsedType};`,
+				);
+			}
+
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE ${parsedType} USING "${withEnum.column}"::${parsedType};`,
+			);
+		}
+
+		return statements;
+	}
+}
+
+class PgDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDropTableStatement, _d: any, action?: string) {
+		const { tableName, schema, policies } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const dropPolicyConvertor = new PgDropPolicyConvertor();
+		const droppedPolicies = policies?.map((p) => {
+			return dropPolicyConvertor.convert({
+				type: 'drop_policy',
+				tableName,
+				data: action === 'push'
+					? PgSquasher.unsquashPolicyPush(p)
+					: PgSquasher.unsquashPolicy(p),
+				schema,
+			}) as string;
+		}) ?? [];
+
+		return [
+			...droppedPolicies,
+			`DROP TABLE ${tableNameWithSchema} CASCADE;`,
+		];
+	}
+}
+
+class MySQLDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+export class SingleStoreDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+export class SQLiteDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+class PgRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo, fromSchema } = statement;
+		const from = fromSchema
+			? `"${fromSchema}"."${tableNameFrom}"`
+			: `"${tableNameFrom}"`;
+		const to = `"${tableNameTo}"`;
+		return `ALTER TABLE ${from} RENAME TO ${to};`;
+	}
+}
+
+export class SqliteRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
+	}
+}
+
+class MySqlRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `RENAME TABLE \`${tableNameFrom}\` TO \`${tableNameTo}\`;`;
+	}
+}
+
+export class SingleStoreRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
+	}
+}
+
+class PgAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
+	}
+}
+
+class MySqlAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'mysql'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` RENAME COLUMN \`${oldColumnName}\` TO \`${newColumnName}\`;`;
+	}
+}
+
+class SingleStoreAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'singlestore'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` CHANGE \`${oldColumnName}\` \`${newColumnName}\`;`;
+	}
+}
+
+class SQLiteAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
+	}
+}
+
+class PgAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_drop_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${columnName}";`;
+	}
+}
+
+class MySqlAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class SingleStoreAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class SQLiteAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class PgAlterTableAddColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_add_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAddColumnStatement) {
+		const { tableName, column, schema } = statement;
+		const { name, notNull, generated, primaryKey, identity } = column;
+
+		const primaryKeyStatement = primaryKey ? ' PRIMARY KEY' : '';
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
+
+		const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+			? `"${column.typeSchema}".`
+			: '';
+
+		const fixedType = parseType(schemaPrefix, column.type);
+
+		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+
+		const unsquashedIdentity = identity
+			? PgSquasher.unsquashIdentity(identity)
+			: undefined;
+
+		const identityWithSchema = schema
+			? `"${schema}"."${unsquashedIdentity?.name}"`
+			: `"${unsquashedIdentity?.name}"`;
+
+		const identityStatement = unsquashedIdentity
+			? ` GENERATED ${
+				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+			} AS IDENTITY (sequence name ${identityWithSchema}${
+				unsquashedIdentity.increment
+					? ` INCREMENT BY ${unsquashedIdentity.increment}`
+					: ''
+			}${
+				unsquashedIdentity.minValue
+					? ` MINVALUE ${unsquashedIdentity.minValue}`
+					: ''
+			}${
+				unsquashedIdentity.maxValue
+					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+					: ''
+			}${
+				unsquashedIdentity.startWith
+					? ` START WITH ${unsquashedIdentity.startWith}`
+					: ''
+			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+				unsquashedIdentity.cycle ? ` CYCLE` : ''
+			})`
+			: '';
+
+		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
+	}
+}
+
+class PgAlterTableAlterColumnSetTypeConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'pg_alter_table_alter_column_set_type'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnPgTypeStatement) {
+		const { tableName, columnName, newDataType, schema, oldDataType, columnDefault, typeSchema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const statements: string[] = [];
+
+		const type = parseType(`"${typeSchema}".`, newDataType.name);
+
+		if (!oldDataType.isEnum && !newDataType.isEnum) {
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
+			);
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			}
+		}
+
+		if (oldDataType.isEnum && !newDataType.isEnum) {
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
+			);
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			}
+		}
+
+		if (!oldDataType.isEnum && newDataType.isEnum) {
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault}::${type};`,
+				);
+			}
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::${type};`,
+			);
+		}
+
+		if (oldDataType.isEnum && newDataType.isEnum) {
+			const alterType =
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::text::${type};`;
+
+			if (newDataType.name !== oldDataType.name && columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`,
+					alterType,
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			} else {
+				statements.push(alterType);
+			}
+		}
+
+		return statements;
+	}
+}
+
+class PgAlterTableAlterColumnSetDefaultConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_default'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetDefaultStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${statement.newDefaultValue};`;
+	}
+}
+
+class PgAlterTableAlterColumnDropDefaultConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_default'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropDefaultStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`;
+	}
+}
+
+class PgAlterTableAlterColumnDropGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropGeneratedStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP EXPRESSION;`;
+	}
+}
+
+class PgAlterTableAlterColumnSetExpressionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
+			schema,
+			tableName,
+			column: {
+				name: columnName,
+				type: statement.newDataType,
+				notNull,
+				default: columnDefault,
+				onUpdate: columnOnUpdate,
+				autoincrement: columnAutoIncrement,
+				primaryKey: columnPk,
+				generated: columnGenerated,
+			},
+			type: 'alter_table_add_column',
+		});
+
+		return [
+			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
+			addColumnStatement,
+		];
+	}
+}
+
+class PgAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_alter_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
+			schema,
+			tableName,
+			column: {
+				name: columnName,
+				type: statement.newDataType,
+				notNull,
+				default: columnDefault,
+				onUpdate: columnOnUpdate,
+				autoincrement: columnAutoIncrement,
+				primaryKey: columnPk,
+				generated: columnGenerated,
+			},
+			type: 'alter_table_add_column',
+		});
+
+		return [
+			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
+			addColumnStatement,
+		];
+	}
+}
+
+////
+
+class PgAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateCompositePK) {
+		const { columns } = PgSquasher.unsquashPK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.constraintName}" PRIMARY KEY("${
+			columns.join('","')
+		}");`;
+	}
+}
+class PgAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDeleteCompositePK) {
+		// const { name, columns } = PgSquasher.unsquashPK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
+	}
+}
+
+class PgAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonAlterCompositePK) {
+		// const { name, columns } = PgSquasher.unsquashPK(statement.old);
+		const { columns: newColumns } = PgSquasher.unsquashPK(
+			statement.new,
+		);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.oldConstraintName}";\n${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.newConstraintName}" PRIMARY KEY("${
+			newColumns.join('","')
+		}");`;
+	}
+}
+
+class PgAlterTableAlterColumnSetPrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_pk'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetPrimaryKeyStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD PRIMARY KEY ("${columnName}");`;
+	}
+}
+
+class PgAlterTableAlterColumnDropPrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_pk'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropPrimaryKeyStatement) {
+		const { tableName, schema } = statement;
+		return `/* 
+    Unfortunately in current drizzle-kit version we can't automatically get name for primary key.
+    We are working on making it available!
+
+    Meanwhile you can:
+        1. Check pk name in your database, by running
+            SELECT constraint_name FROM information_schema.table_constraints
+            WHERE table_schema = '${typeof schema === 'undefined' || schema === '' ? 'public' : schema}'
+                AND table_name = '${tableName}'
+                AND constraint_type = 'PRIMARY KEY';
+        2. Uncomment code below and paste pk name manually
+        
+    Hope to release this update as soon as possible
+*/
+
+-- ALTER TABLE "${tableName}" DROP CONSTRAINT "<constraint_name>";`;
+	}
+}
+
+class PgAlterTableAlterColumnSetNotNullConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_notnull'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetNotNullStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET NOT NULL;`;
+	}
+}
+
+class PgAlterTableAlterColumnDropNotNullConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_notnull'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropNotNullStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP NOT NULL;`;
+	}
+}
+
+// FK
+class PgCreateForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateReferenceStatement): string {
+		const {
+			name,
+			tableFrom,
+			tableTo,
+			columnsFrom,
+			columnsTo,
+			onDelete,
+			onUpdate,
+			schemaTo,
+		} = PgSquasher.unsquashFK(statement.data);
+		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
+		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
+		const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(',');
+		const toColumnsString = columnsTo.map((it) => `"${it}"`).join(',');
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${tableFrom}"`
+			: `"${tableFrom}"`;
+
+		const tableToNameWithSchema = schemaTo
+			? `"${schemaTo}"."${tableTo}"`
+			: `"${tableTo}"`;
+
+		const alterStatement =
+			`ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+		return alterStatement;
+	}
+}
+
+class PgAlterForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonAlterReferenceStatement): string {
+		const newFk = PgSquasher.unsquashFK(statement.data);
+		const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${oldFk.tableFrom}"`
+			: `"${oldFk.tableFrom}"`;
+
+		let sql = `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${oldFk.name}";\n`;
+
+		const onDeleteStatement = newFk.onDelete
+			? ` ON DELETE ${newFk.onDelete}`
+			: '';
+		const onUpdateStatement = newFk.onUpdate
+			? ` ON UPDATE ${newFk.onUpdate}`
+			: '';
+
+		const fromColumnsString = newFk.columnsFrom
+			.map((it) => `"${it}"`)
+			.join(',');
+		const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(',');
+
+		const tableFromNameWithSchema = oldFk.schemaTo
+			? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"`
+			: `"${oldFk.tableFrom}"`;
+
+		const tableToNameWithSchema = newFk.schemaTo
+			? `"${newFk.schemaTo}"."${newFk.tableFrom}"`
+			: `"${newFk.tableFrom}"`;
+
+		const alterStatement =
+			`ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+		sql += alterStatement;
+		return sql;
+	}
+}
+
+class PgDeleteForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDeleteReferenceStatement): string {
+		const tableFrom = statement.tableName; // delete fk from renamed table case
+		const { name } = PgSquasher.unsquashFK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${tableFrom}"`
+			: `"${tableFrom}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name}";\n`;
+	}
+}
+
+class CreatePgIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_index_pg' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonPgCreateIndexStatement): string {
+		const {
+			name,
+			columns,
+			isUnique,
+			concurrently,
+			with: withMap,
+			method,
+			where,
+		} = statement.data;
+		// // since postgresql 9.5
+		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+		const value = columns
+			.map(
+				(it) =>
+					`${it.isExpression ? it.expression : `"${it.expression}"`}${
+						it.opclass ? ` ${it.opclass}` : it.asc ? '' : ' DESC'
+					}${
+						(it.asc && it.nulls && it.nulls === 'last') || it.opclass
+							? ''
+							: ` NULLS ${it.nulls!.toUpperCase()}`
+					}`,
+			)
+			.join(',');
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		function reverseLogic(mappedWith: Record<string, string>): string {
+			let reversedString = '';
+			for (const key in mappedWith) {
+				if (mappedWith.hasOwnProperty(key)) {
+					reversedString += `${key}=${mappedWith[key]},`;
+				}
+			}
+			reversedString = reversedString.slice(0, -1);
+			return reversedString;
+		}
+
+		return `CREATE ${indexPart}${
+			concurrently ? ' CONCURRENTLY' : ''
+		} "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${
+			Object.keys(withMap!).length !== 0
+				? ` WITH (${reverseLogic(withMap!)})`
+				: ''
+		}${where ? ` WHERE ${where}` : ''};`;
+	}
+}
+
+class PgDropIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_index' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDropIndexStatement): string {
+		const { schema } = statement;
+		const { name } = PgSquasher.unsquashIdx(statement.data);
+
+		const indexNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `DROP INDEX ${indexNameWithSchema};`;
+	}
+}
+
+class PgCreateSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateSchema) {
+		const { name } = statement;
+		return `CREATE SCHEMA "${name}";\n`;
+	}
+}
+
+class PgRenameSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonRenameSchema) {
+		const { from, to } = statement;
+		return `ALTER SCHEMA "${from}" RENAME TO "${to}";\n`;
+	}
+}
+
+class PgDropSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateSchema) {
+		const { name } = statement;
+		return `DROP SCHEMA "${name}";\n`;
+	}
+}
+
+class PgAlterTableSetSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_set_schema' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableSetSchema) {
+		const { tableName, schemaFrom, schemaTo } = statement;
+
+		return `ALTER TABLE "${schemaFrom}"."${tableName}" SET SCHEMA "${schemaTo}";\n`;
+	}
+}
+
+class PgAlterTableSetNewSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_set_new_schema'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableSetNewSchema) {
+		const { tableName, to, from } = statement;
+
+		const tableNameWithSchema = from
+			? `"${from}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA "${to}";\n`;
+	}
+}
+
+class PgAlterTableRemoveFromSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_remove_from_schema'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableRemoveFromSchema) {
+		const { tableName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA public;\n`;
+	}
+}
+
+class SqliteDropIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_index' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropIndexStatement): string {
+		const { name } = PgSquasher.unsquashIdx(statement.data);
+		return `DROP INDEX \`${name}\`;`;
+	}
+}
+
+class SQLiteCreateTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'sqlite_create_table' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(st: JsonSqliteCreateTableStatement) {
+		const {
+			tableName,
+			columns,
+			referenceData,
+			compositePKs,
+			uniqueConstraints,
+			checkConstraints,
+		} = st;
+
+		let statement = '';
+		statement += `CREATE TABLE \`${tableName}\` (\n`;
+		for (let i = 0; i < columns.length; i++) {
+			const column = columns[i];
+
+			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
+			const notNullStatement = column.notNull ? ' NOT NULL' : '';
+			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
+
+			const autoincrementStatement = column.autoincrement
+				? ' AUTOINCREMENT'
+				: '';
+
+			const generatedStatement = column.generated
+				? ` GENERATED ALWAYS AS ${column.generated.as} ${column.generated.type.toUpperCase()}`
+				: '';
+
+			statement += '\t';
+			statement +=
+				`\`${column.name}\` ${column.type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}`;
+
+			statement += i === columns.length - 1 ? '' : ',\n';
+		}
+
+		compositePKs.forEach((it) => {
+			statement += ',\n\t';
+			statement += `PRIMARY KEY(${it.map((it) => `\`${it}\``).join(', ')})`;
+		});
+
+		for (let i = 0; i < referenceData.length; i++) {
+			const {
+				tableTo,
+				columnsFrom,
+				columnsTo,
+				onDelete,
+				onUpdate,
+			} = referenceData[i];
+
+			const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
+			const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
+			const fromColumnsString = columnsFrom.map((it) => `\`${it}\``).join(',');
+			const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
+
+			statement += ',';
+			statement += '\n\t';
+			statement +=
+				`FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onUpdateStatement}${onDeleteStatement}`;
+		}
+
+		if (
+			typeof uniqueConstraints !== 'undefined'
+			&& uniqueConstraints.length > 0
+		) {
+			for (const uniqueConstraint of uniqueConstraints) {
+				statement += ',\n';
+				const unsquashedUnique = SQLiteSquasher.unsquashUnique(uniqueConstraint);
+				statement += `\tCONSTRAINT ${unsquashedUnique.name} UNIQUE(\`${unsquashedUnique.columns.join(`\`,\``)}\`)`;
+			}
+		}
+
+		if (
+			typeof checkConstraints !== 'undefined'
+			&& checkConstraints.length > 0
+		) {
+			for (const check of checkConstraints) {
+				statement += ',\n';
+				const { value, name } = SQLiteSquasher.unsquashCheck(check);
+				statement += `\tCONSTRAINT "${name}" CHECK(${value})`;
+			}
+		}
+
+		statement += `\n`;
+		statement += `);`;
+		statement += `\n`;
+		return statement;
+	}
+}
+
+class SqliteCreateViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'sqlite_create_view' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(st: JsonCreateSqliteViewStatement) {
+		const { definition, name } = st;
+
+		return `CREATE VIEW \`${name}\` AS ${definition};`;
+	}
+}
+
+class SqliteDropViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_view' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(st: JsonDropViewStatement) {
+		const { name } = st;
+
+		return `DROP VIEW \`${name}\`;`;
+	}
+}
+
+class SQLiteAlterTableAddColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'sqlite_alter_table_add_column' && (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonSqliteAddColumnStatement) {
+		const { tableName, column, referenceData } = statement;
+		const { name, type, notNull, primaryKey, generated } = column;
+
+		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
+		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
+		const referenceAsObject = referenceData
+			? SQLiteSquasher.unsquashFK(referenceData)
+			: undefined;
+		const referenceStatement = `${
+			referenceAsObject
+				? ` REFERENCES ${referenceAsObject.tableTo}(${referenceAsObject.columnsTo})`
+				: ''
+		}`;
+		// const autoincrementStatement = `${autoincrement ? 'AUTO_INCREMENT' : ''}`
+		const generatedStatement = generated
+			? ` GENERATED ALWAYS AS ${generated.as} ${generated.type.toUpperCase()}`
+			: '';
+
+		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${referenceStatement};`;
+	}
+}
+
+class SqliteAlterTableAlterColumnDropGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_generated'
+			&& (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+			columnNotNull,
+		} = statement;
+
+		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
+			{
+				tableName,
+				column: {
+					name: columnName,
+					type: statement.newDataType,
+					notNull: columnNotNull,
+					default: columnDefault,
+					onUpdate: columnOnUpdate,
+					autoincrement: columnAutoIncrement,
+					primaryKey: columnPk,
+					generated: columnGenerated,
+				},
+				type: 'sqlite_alter_table_add_column',
+			},
+		);
+
+		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
+			tableName,
+			columnName,
+			schema,
+			type: 'alter_table_drop_column',
+		});
+
+		return [dropColumnStatement, addColumnStatement];
+	}
+}
+
+class SqliteAlterTableAlterColumnSetExpressionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_generated'
+			&& (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
+			{
+				tableName,
+				column: {
+					name: columnName,
+					type: statement.newDataType,
+					notNull,
+					default: columnDefault,
+					onUpdate: columnOnUpdate,
+					autoincrement: columnAutoIncrement,
+					primaryKey: columnPk,
+					generated: columnGenerated,
+				},
+				type: 'sqlite_alter_table_add_column',
+			},
+		);
+
+		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
+			tableName,
+			columnName,
+			schema,
+			type: 'alter_table_drop_column',
+		});
+
+		return [dropColumnStatement, addColumnStatement];
+	}
+}
+
+class SqliteAlterTableAlterColumnAlterGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_alter_generated'
+			&& (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
+			{
+				tableName,
+				column: {
+					name: columnName,
+					type: statement.newDataType,
+					notNull: columnNotNull,
+					default: columnDefault,
+					onUpdate: columnOnUpdate,
+					autoincrement: columnAutoIncrement,
+					primaryKey: columnPk,
+					generated: columnGenerated,
+				},
+				type: 'sqlite_alter_table_add_column',
+			},
+		);
+
+		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
+			tableName,
+			columnName,
+			schema,
+			type: 'alter_table_drop_column',
+		});
+
+		return [dropColumnStatement, addColumnStatement];
+	}
+}
+
+class SqliteAlterTableAlterColumnDropDefaultConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_default'
+			&& dialect === 'sqlite'
+		);
+	}
+
+	convert(_statement: JsonAlterColumnDropDefaultStatement) {
+		return (
+			'/*\n SQLite does not support "Drop default from column" out of the box, we do not generate automatic migration for that, so it has to be done manually'
+			+ '\n Please refer to: https://www.techonthenet.com/sqlite/tables/alter_table.php'
+			+ '\n                  https://www.sqlite.org/lang_altertable.html'
+			+ '\n                  https://stackoverflow.com/questions/2083543/modify-a-columns-type-in-sqlite3'
+			+ "\n\n Due to that we don't generate migration automatically and it has to be done manually"
+			+ '\n*/'
+		);
+	}
+}
+
+class SqliteAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_composite_pk' && dialect === 'sqlite';
+	}
+
+	convert(statement: JsonCreateCompositePK) {
+		let msg = '/*\n';
+		msg += `You're trying to add PRIMARY KEY(${statement.data}) to '${statement.tableName}' table\n`;
+		msg += 'SQLite does not support adding primary key to an already created table\n';
+		msg += 'You can do it in 3 steps with drizzle orm:\n';
+		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
+		msg += ' - migrate old data from one table to another\n';
+		msg += ' - delete old_table in schema, generate sql\n\n';
+		msg += 'or create manual migration like below:\n\n';
+		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+		msg += 'CREATE TABLE table_name (\n';
+		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+		msg += '\t...\n';
+		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+		msg += ' );\n';
+		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+		msg += '*/\n';
+		return msg;
+	}
+}
+
+class SqliteAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_composite_pk' && dialect === 'sqlite';
+	}
+
+	convert(statement: JsonDeleteCompositePK) {
+		let msg = '/*\n';
+		msg += `You're trying to delete PRIMARY KEY(${statement.data}) from '${statement.tableName}' table\n`;
+		msg += 'SQLite does not supportprimary key deletion from existing table\n';
+		msg += 'You can do it in 3 steps with drizzle orm:\n';
+		msg += ' - create new mirror table table without pk, rename current table to old_table, generate SQL\n';
+		msg += ' - migrate old data from one table to another\n';
+		msg += ' - delete old_table in schema, generate sql\n\n';
+		msg += 'or create manual migration like below:\n\n';
+		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+		msg += 'CREATE TABLE table_name (\n';
+		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+		msg += '\t...\n';
+		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+		msg += ' );\n';
+		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+		msg += '*/\n';
+		return msg;
+	}
+}
+
+class SqliteAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_composite_pk' && dialect === 'sqlite';
+	}
+
+	convert(_statement: JsonAlterCompositePK) {
+		let msg = '/*\n';
+		msg += 'SQLite does not support altering primary key\n';
+		msg += 'You can do it in 3 steps with drizzle orm:\n';
+		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
+		msg += ' - migrate old data from one table to another\n';
+		msg += ' - delete old_table in schema, generate sql\n\n';
+		msg += 'or create manual migration like below:\n\n';
+		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+		msg += 'CREATE TABLE table_name (\n';
+		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+		msg += '\t...\n';
+		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+		msg += ' );\n';
+		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+		msg += '*/\n';
+
+		return msg;
+	}
+}
+class CreateSqliteIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_index' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonCreateIndexStatement): string {
+		// should be changed
+		const { name, columns, isUnique, where } = SQLiteSquasher.unsquashIdx(
+			statement.data,
+		);
+		// // since postgresql 9.5
+		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+		const whereStatement = where ? ` WHERE ${where}` : '';
+		const uniqueString = columns
+			.map((it) => {
+				return statement.internal?.indexes
+					? statement.internal?.indexes[name]?.columns[it]?.isExpression
+						? it
+						: `\`${it}\``
+					: `\`${it}\``;
+			})
+			.join(',');
+		return `CREATE ${indexPart} \`${name}\` ON \`${statement.tableName}\` (${uniqueString})${whereStatement};`;
+	}
+}
+
+class SQLiteRecreateTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'recreate_table' && dialect === 'sqlite'
+		);
+	}
+
+	convert(statement: JsonRecreateTableStatement): string | string[] {
+		const { tableName, columns, compositePKs, referenceData, checkConstraints } = statement;
+
+		const columnNames = columns.map((it) => `"${it.name}"`).join(', ');
+		const newTableName = `__new_${tableName}`;
+
+		const sqlStatements: string[] = [];
+
+		sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
+
+		// map all possible variants
+		const mappedCheckConstraints: string[] = checkConstraints.map((it) =>
+			it.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`)
+				.replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `'${newTableName}'.`)
+		);
+
+		// create new table
+		sqlStatements.push(
+			new SQLiteCreateTableConvertor().convert({
+				type: 'sqlite_create_table',
+				tableName: newTableName,
+				columns,
+				referenceData,
+				compositePKs,
+				checkConstraints: mappedCheckConstraints,
+			}),
+		);
+
+		// migrate data
+		sqlStatements.push(
+			`INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`,
+		);
+
+		// drop table
+		sqlStatements.push(
+			new SQLiteDropTableConvertor().convert({
+				type: 'drop_table',
+				tableName: tableName,
+				schema: '',
+			}),
+		);
+
+		// rename table
+		sqlStatements.push(
+			new SqliteRenameTableConvertor().convert({
+				fromSchema: '',
+				tableNameFrom: newTableName,
+				tableNameTo: tableName,
+				toSchema: '',
+				type: 'rename_table',
+			}),
+		);
+
+		sqlStatements.push(`PRAGMA foreign_keys=ON;`);
+
+		return sqlStatements;
+	}
+}
+
+const convertors: Convertor[] = [];
+convertors.push(new PgCreateTableConvertor());
+
+convertors.push(new PgCreateViewConvertor());
+convertors.push(new PgDropViewConvertor());
+convertors.push(new PgRenameViewConvertor());
+convertors.push(new PgAlterViewSchemaConvertor());
+convertors.push(new PgAlterViewAddWithOptionConvertor());
+convertors.push(new PgAlterViewDropWithOptionConvertor());
+convertors.push(new PgAlterViewAlterTablespaceConvertor());
+convertors.push(new PgAlterViewAlterUsingConvertor());
+
+convertors.push(new CreateTypeEnumConvertor());
+convertors.push(new DropTypeEnumConvertor());
+convertors.push(new AlterTypeAddValueConvertor());
+convertors.push(new AlterTypeSetSchemaConvertor());
+convertors.push(new AlterRenameTypeConvertor());
+convertors.push(new AlterTypeDropValueConvertor());
+
+convertors.push(new CreatePgSequenceConvertor());
+convertors.push(new DropPgSequenceConvertor());
+convertors.push(new RenamePgSequenceConvertor());
+convertors.push(new MovePgSequenceConvertor());
+convertors.push(new AlterPgSequenceConvertor());
+
+convertors.push(new PgDropTableConvertor());
+convertors.push(new MySQLDropTableConvertor());
+convertors.push(new SingleStoreDropTableConvertor());
+convertors.push(new SQLiteDropTableConvertor());
+
+convertors.push(new PgRenameTableConvertor());
+convertors.push(new MySqlRenameTableConvertor());
+convertors.push(new SingleStoreRenameTableConvertor());
+convertors.push(new SqliteRenameTableConvertor());
+
+convertors.push(new PgAlterTableRenameColumnConvertor());
+convertors.push(new MySqlAlterTableRenameColumnConvertor());
+convertors.push(new SingleStoreAlterTableRenameColumnConvertor());
+convertors.push(new SQLiteAlterTableRenameColumnConvertor());
+
+convertors.push(new PgAlterTableDropColumnConvertor());
+convertors.push(new MySqlAlterTableDropColumnConvertor());
+convertors.push(new SingleStoreAlterTableDropColumnConvertor());
+convertors.push(new SQLiteAlterTableDropColumnConvertor());
+
+convertors.push(new PgAlterTableAddColumnConvertor());
+
+convertors.push(new PgAlterTableAlterColumnSetTypeConvertor());
+
+convertors.push(new PgAlterTableAddUniqueConstraintConvertor());
+convertors.push(new PgAlterTableDropUniqueConstraintConvertor());
+
+convertors.push(new PgAlterTableAddCheckConstraintConvertor());
+convertors.push(new PgAlterTableDeleteCheckConstraintConvertor());
+
+convertors.push(new CreatePgIndexConvertor());
+
+convertors.push(new PgDropIndexConvertor());
+convertors.push(new SqliteDropIndexConvertor());
+
+convertors.push(new PgAlterTableAlterColumnSetPrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterColumnDropPrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
+convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
+convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
+convertors.push(new PgAlterTableAlterColumnDropDefaultConvertor());
+
+convertors.push(new PgAlterPolicyConvertor());
+convertors.push(new PgCreatePolicyConvertor());
+convertors.push(new PgDropPolicyConvertor());
+convertors.push(new PgRenamePolicyConvertor());
+
+convertors.push(new PgAlterIndPolicyConvertor());
+convertors.push(new PgCreateIndPolicyConvertor());
+convertors.push(new PgDropIndPolicyConvertor());
+convertors.push(new PgRenameIndPolicyConvertor());
+
+convertors.push(new PgEnableRlsConvertor());
+convertors.push(new PgDisableRlsConvertor());
+
+convertors.push(new PgDropRoleConvertor());
+convertors.push(new PgAlterRoleConvertor());
+convertors.push(new PgCreateRoleConvertor());
+convertors.push(new PgRenameRoleConvertor());
+
+/// generated
+convertors.push(new PgAlterTableAlterColumnSetExpressionConvertor());
+convertors.push(new PgAlterTableAlterColumnDropGeneratedConvertor());
+convertors.push(new PgAlterTableAlterColumnAlterrGeneratedConvertor());
+
+// convertors.push(new MySqlAlterTableAlterColumnSetDefaultConvertor());
+// convertors.push(new MySqlAlterTableAlterColumnDropDefaultConvertor());
+
+convertors.push(new PgCreateForeignKeyConvertor());
+
+convertors.push(new PgAlterForeignKeyConvertor());
+
+convertors.push(new PgDeleteForeignKeyConvertor());
+
+convertors.push(new PgCreateSchemaConvertor());
+convertors.push(new PgRenameSchemaConvertor());
+convertors.push(new PgDropSchemaConvertor());
+convertors.push(new PgAlterTableSetSchemaConvertor());
+convertors.push(new PgAlterTableSetNewSchemaConvertor());
+convertors.push(new PgAlterTableRemoveFromSchemaConvertor());
+
+convertors.push(new PgAlterTableAlterColumnDropGenerated());
+convertors.push(new PgAlterTableAlterColumnSetGenerated());
+convertors.push(new PgAlterTableAlterColumnAlterGenerated());
+
+convertors.push(new PgAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterCompositePrimaryKeyConvertor());
+
+convertors.push(new SqliteCreateViewConvertor());
+convertors.push(new SqliteDropViewConvertor());
+convertors.push(new SqliteAlterTableAlterColumnDropGeneratedConvertor());
+convertors.push(new SqliteAlterTableAlterColumnSetExpressionConvertor());
+convertors.push(new SqliteAlterTableAlterColumnAlterGeneratedConvertor());
+convertors.push(new SqliteAlterTableAlterColumnDropDefaultConvertor());
+convertors.push(new SqliteAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new SqliteAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new SqliteAlterTableAlterCompositePrimaryKeyConvertor());
+convertors.push(new CreateSqliteIndexConvertor());
+convertors.push(new SQLiteRecreateTableConvertor());
+convertors.push(new SQLiteCreateTableConvertor());
+
+export function fromJson(
+	statements: JsonStatement[],
+	dialect: Dialect,
+	action?: 'push',
+) {
+	const result = statements
+		.flatMap((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement, dialect);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+
+			if (!convertor) throw new Error(`Unexpected json statement: ${statement.type} ${dialect}`);
+
+			return convertor.convert(statement, action);
+		})
+		.filter((it) => it !== '');
+	return result;
+}
diff --git a/drizzle-kit/src/legacy/sqlgenerator2.ts b/drizzle-kit/src/legacy/sqlgenerator2.ts
new file mode 100644
index 0000000000..15d7d2618a
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlgenerator2.ts
@@ -0,0 +1,3209 @@
+import type {
+	JsonAddColumnStatement,
+	JsonAddValueToEnumStatement,
+	JsonAlterColumnAlterGeneratedStatement,
+	JsonAlterColumnAlterIdentityStatement,
+	JsonAlterColumnDropAutoincrementStatement,
+	JsonAlterColumnDropDefaultStatement,
+	JsonAlterColumnDropGeneratedStatement,
+	JsonAlterColumnDropIdentityStatement,
+	JsonAlterColumnDropNotNullStatement,
+	JsonAlterColumnDropOnUpdateStatement,
+	JsonAlterColumnDropPrimaryKeyStatement,
+	JsonAlterColumnPgTypeStatement,
+	JsonAlterColumnSetAutoincrementStatement,
+	JsonAlterColumnSetDefaultStatement,
+	JsonAlterColumnSetGeneratedStatement,
+	JsonAlterColumnSetIdentityStatement,
+	JsonAlterColumnSetNotNullStatement,
+	JsonAlterColumnSetOnUpdateStatement,
+	JsonAlterColumnSetPrimaryKeyStatement,
+	JsonAlterColumnTypeStatement,
+	JsonAlterCompositePK,
+	JsonAlterIndPolicyStatement,
+	JsonAlterPolicyStatement,
+	JsonAlterReferenceStatement,
+	JsonAlterRoleStatement,
+	JsonAlterSequenceStatement,
+	JsonAlterTableRemoveFromSchema,
+	JsonAlterTableSetNewSchema,
+	JsonAlterTableSetSchema,
+	JsonAlterViewAddWithOptionStatement,
+	JsonAlterViewAlterSchemaStatement,
+	JsonAlterViewAlterTablespaceStatement,
+	JsonAlterViewAlterUsingStatement,
+	JsonAlterViewDropWithOptionStatement,
+	JsonCreateCheckConstraint,
+	JsonCreateCompositePK,
+	JsonCreateEnumStatement,
+	JsonCreateIndexStatement,
+	JsonCreateIndPolicyStatement,
+	JsonCreateMySqlViewStatement,
+	JsonCreatePgViewStatement,
+	JsonCreatePolicyStatement,
+	JsonCreateReferenceStatement,
+	JsonCreateRoleStatement,
+	JsonCreateSchema,
+	JsonCreateSequenceStatement,
+	JsonCreateTableStatement,
+	JsonCreateUniqueConstraint,
+	JsonDeleteCheckConstraint,
+	JsonDeleteCompositePK,
+	JsonDeleteReferenceStatement,
+	JsonDeleteUniqueConstraint,
+	JsonDisableRLSStatement,
+	JsonDropColumnStatement,
+	JsonDropEnumStatement,
+	JsonDropIndexStatement,
+	JsonDropIndPolicyStatement,
+	JsonDropPolicyStatement,
+	JsonDropRoleStatement,
+	JsonDropSequenceStatement,
+	JsonDropTableStatement,
+	JsonDropValueFromEnumStatement,
+	JsonDropViewStatement,
+	JsonEnableRLSStatement,
+	JsonIndRenamePolicyStatement,
+	JsonMoveEnumStatement,
+	JsonMoveSequenceStatement,
+	JsonPgCreateIndexStatement,
+	JsonRenameColumnStatement,
+	JsonRenameEnumStatement,
+	JsonRenamePolicyStatement,
+	JsonRenameRoleStatement,
+	JsonRenameSchema,
+	JsonRenameSequenceStatement,
+	JsonRenameTableStatement,
+	JsonRenameViewStatement,
+	JsonStatement,
+} from './jsonStatements';
+import { MySqlSquasher } from './mysql-v5/mysqlSchema';
+import { PgSquasher } from './postgres-v7/pgSchema';
+import type { Dialect } from './schemaValidator';
+import { BREAKPOINT } from './sqlgenerator';
+
+import { escapeSingleQuotes } from './utils';
+
+const parseType = (schemaPrefix: string, type: string) => {
+	const pgNativeTypes = [
+		'uuid',
+		'smallint',
+		'integer',
+		'bigint',
+		'boolean',
+		'text',
+		'varchar',
+		'serial',
+		'bigserial',
+		'decimal',
+		'numeric',
+		'real',
+		'json',
+		'jsonb',
+		'time',
+		'time with time zone',
+		'time without time zone',
+		'time',
+		'timestamp',
+		'timestamp with time zone',
+		'timestamp without time zone',
+		'date',
+		'interval',
+		'bigint',
+		'bigserial',
+		'double precision',
+		'interval year',
+		'interval month',
+		'interval day',
+		'interval hour',
+		'interval minute',
+		'interval second',
+		'interval year to month',
+		'interval day to hour',
+		'interval day to minute',
+		'interval day to second',
+		'interval hour to minute',
+		'interval hour to second',
+		'interval minute to second',
+		'char',
+		'vector',
+		'geometry',
+		'halfvec',
+		'sparsevec',
+		'bit',
+	];
+	const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
+	const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join('');
+	const withoutArrayDefinition = type.replace(arrayDefinitionRegex, '');
+	return pgNativeTypes.some((it) => type.startsWith(it))
+		? `${withoutArrayDefinition}${arrayDefinition}`
+		: `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
+};
+
+abstract class Convertor {
+	abstract can(
+		statement: JsonStatement,
+		dialect: Dialect,
+	): boolean;
+	abstract convert(
+		statement: JsonStatement,
+		action?: 'push',
+	): string | string[];
+}
+
+class PgCreateRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreateRoleStatement): string | string[] {
+		return `CREATE ROLE "${statement.name}"${
+			statement.values.createDb || statement.values.createRole || !statement.values.inherit
+				? ` WITH${statement.values.createDb ? ' CREATEDB' : ''}${statement.values.createRole ? ' CREATEROLE' : ''}${
+					statement.values.inherit ? '' : ' NOINHERIT'
+				}`
+				: ''
+		};`;
+	}
+}
+
+class PgDropRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropRoleStatement): string | string[] {
+		return `DROP ROLE "${statement.name}";`;
+	}
+}
+
+class PgRenameRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonRenameRoleStatement): string | string[] {
+		return `ALTER ROLE "${statement.nameFrom}" RENAME TO "${statement.nameTo}";`;
+	}
+}
+
+class PgAlterRoleConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_role' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterRoleStatement): string | string[] {
+		return `ALTER ROLE "${statement.name}"${` WITH${statement.values.createDb ? ' CREATEDB' : ' NOCREATEDB'}${
+			statement.values.createRole ? ' CREATEROLE' : ' NOCREATEROLE'
+		}${statement.values.inherit ? ' INHERIT' : ' NOINHERIT'}`};`;
+	}
+}
+
+/////
+
+class PgCreatePolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreatePolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+		const policyToPart = policy.to?.map((v) =>
+			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+		).join(', ');
+
+		return `CREATE POLICY "${policy.name}" ON ${tableNameWithSchema} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+	}
+}
+
+class PgDropPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `DROP POLICY "${policy.name}" ON ${tableNameWithSchema} CASCADE;`;
+	}
+}
+
+class PgRenamePolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonRenamePolicyStatement): string | string[] {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER POLICY "${statement.oldName}" ON ${tableNameWithSchema} RENAME TO "${statement.newName}";`;
+	}
+}
+
+class PgAlterPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterPolicyStatement, _dialect: any, action?: string): string | string[] {
+		const newPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(statement.newData)
+			: PgSquasher.unsquashPolicy(statement.newData);
+		const oldPolicy = action === 'push'
+			? PgSquasher.unsquashPolicyPush(statement.oldData)
+			: PgSquasher.unsquashPolicy(statement.oldData);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		const usingPart = newPolicy.using
+			? ` USING (${newPolicy.using})`
+			: oldPolicy.using
+			? ` USING (${oldPolicy.using})`
+			: '';
+
+		const withCheckPart = newPolicy.withCheck
+			? ` WITH CHECK (${newPolicy.withCheck})`
+			: oldPolicy.withCheck
+			? ` WITH CHECK  (${oldPolicy.withCheck})`
+			: '';
+
+		return `ALTER POLICY "${oldPolicy.name}" ON ${tableNameWithSchema} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
+	}
+}
+
+////
+
+class PgCreateIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonCreateIndPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		const usingPart = policy.using ? ` USING (${policy.using})` : '';
+
+		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
+
+		const policyToPart = policy.to?.map((v) =>
+			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
+		).join(', ');
+
+		return `CREATE POLICY "${policy.name}" ON ${policy.on} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
+	}
+}
+
+class PgDropIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDropIndPolicyStatement): string | string[] {
+		const policy = statement.data;
+
+		return `DROP POLICY "${policy.name}" ON ${policy.on} CASCADE;`;
+	}
+}
+
+class PgRenameIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonIndRenamePolicyStatement): string | string[] {
+		return `ALTER POLICY "${statement.oldName}" ON ${statement.tableKey} RENAME TO "${statement.newName}";`;
+	}
+}
+
+class PgAlterIndPolicyConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_ind_policy' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonAlterIndPolicyStatement): string | string[] {
+		const newPolicy = statement.newData;
+		const oldPolicy = statement.oldData;
+
+		const usingPart = newPolicy.using
+			? ` USING (${newPolicy.using})`
+			: oldPolicy.using
+			? ` USING (${oldPolicy.using})`
+			: '';
+
+		const withCheckPart = newPolicy.withCheck
+			? ` WITH CHECK (${newPolicy.withCheck})`
+			: oldPolicy.withCheck
+			? ` WITH CHECK  (${oldPolicy.withCheck})`
+			: '';
+
+		return `ALTER POLICY "${oldPolicy.name}" ON ${oldPolicy.on} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
+	}
+}
+
+////
+
+class PgEnableRlsConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'enable_rls' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonEnableRLSStatement): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ENABLE ROW LEVEL SECURITY;`;
+	}
+}
+
+class PgDisableRlsConvertor extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'disable_rls' && dialect === 'postgresql';
+	}
+	override convert(statement: JsonDisableRLSStatement): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DISABLE ROW LEVEL SECURITY;`;
+	}
+}
+
+class PgCreateTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_table' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreateTableStatement) {
+		const { tableName, schema, columns, compositePKs, uniqueConstraints, checkConstraints, policies, isRLSEnabled } =
+			st;
+
+		let statement = '';
+		const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+
+		statement += `CREATE TABLE ${name} (\n`;
+		for (let i = 0; i < columns.length; i++) {
+			const column = columns[i];
+
+			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
+			const notNullStatement = column.notNull && !column.identity ? ' NOT NULL' : '';
+			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
+
+			const uniqueConstraint = column.isUnique
+				? ` CONSTRAINT "${column.uniqueName}" UNIQUE${column.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''}`
+				: '';
+
+			const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+				? `"${column.typeSchema}".`
+				: '';
+
+			const type = parseType(schemaPrefix, column.type);
+			const generated = column.generated;
+
+			const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+			const unsquashedIdentity = column.identity
+				? PgSquasher.unsquashIdentity(column.identity)
+				: undefined;
+
+			const identityWithSchema = schema
+				? `"${schema}"."${unsquashedIdentity?.name}"`
+				: `"${unsquashedIdentity?.name}"`;
+
+			const identity = unsquashedIdentity
+				? ` GENERATED ${
+					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+				} AS IDENTITY (sequence name ${identityWithSchema}${
+					unsquashedIdentity.increment
+						? ` INCREMENT BY ${unsquashedIdentity.increment}`
+						: ''
+				}${
+					unsquashedIdentity.minValue
+						? ` MINVALUE ${unsquashedIdentity.minValue}`
+						: ''
+				}${
+					unsquashedIdentity.maxValue
+						? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+						: ''
+				}${
+					unsquashedIdentity.startWith
+						? ` START WITH ${unsquashedIdentity.startWith}`
+						: ''
+				}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+					unsquashedIdentity.cycle ? ` CYCLE` : ''
+				})`
+				: '';
+
+			statement += '\t'
+				+ `"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${uniqueConstraint}${identity}`;
+			statement += i === columns.length - 1 ? '' : ',\n';
+		}
+
+		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
+			statement += ',\n';
+			const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
+			statement += `\tCONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK.columns.join(`","`)}")`;
+			// statement += `\n`;
+		}
+
+		if (
+			typeof uniqueConstraints !== 'undefined'
+			&& uniqueConstraints.length > 0
+		) {
+			for (const uniqueConstraint of uniqueConstraints) {
+				statement += ',\n';
+				const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint);
+				statement += `\tCONSTRAINT "${unsquashedUnique.name}" UNIQUE${
+					unsquashedUnique.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
+				}("${unsquashedUnique.columns.join(`","`)}")`;
+				// statement += `\n`;
+			}
+		}
+
+		if (typeof checkConstraints !== 'undefined' && checkConstraints.length > 0) {
+			for (const checkConstraint of checkConstraints) {
+				statement += ',\n';
+				const unsquashedCheck = PgSquasher.unsquashCheck(checkConstraint);
+				statement += `\tCONSTRAINT "${unsquashedCheck.name}" CHECK (${unsquashedCheck.value})`;
+			}
+		}
+
+		statement += `\n);`;
+		statement += `\n`;
+
+		const enableRls = new PgEnableRlsConvertor().convert({
+			type: 'enable_rls',
+			tableName,
+			schema,
+		});
+
+		return [statement, ...(policies && policies.length > 0 || isRLSEnabled ? [enableRls] : [])];
+	}
+}
+
+class MySqlCreateTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_table' && dialect === 'mysql';
+	}
+
+	convert(st: JsonCreateTableStatement) {
+		const {
+			tableName,
+			columns,
+			checkConstraints,
+			compositePKs,
+			uniqueConstraints,
+		} = st;
+
+		let statement = '';
+		statement += `CREATE TABLE \`${tableName}\` (\n`;
+		for (let i = 0; i < columns.length; i++) {
+			const column = columns[i];
+
+			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
+			const notNullStatement = column.notNull ? ' NOT NULL' : '';
+			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
+
+			const onUpdateStatement = column.onUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+
+			const autoincrementStatement = column.autoincrement
+				? ' AUTO_INCREMENT'
+				: '';
+
+			const generatedStatement = column.generated
+				? ` GENERATED ALWAYS AS (${column.generated?.as}) ${column.generated?.type.toUpperCase()}`
+				: '';
+
+			statement += '\t'
+				+ `\`${column.name}\` ${column.type}${autoincrementStatement}${primaryKeyStatement}${generatedStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`;
+			statement += i === columns.length - 1 ? '' : ',\n';
+		}
+
+		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
+			statement += ',\n';
+			const compositePK = MySqlSquasher.unsquashPK(compositePKs[0]);
+			statement += `\tCONSTRAINT \`${st.compositePkName}\` PRIMARY KEY(\`${compositePK.columns.join(`\`,\``)}\`)`;
+		}
+
+		if (
+			typeof uniqueConstraints !== 'undefined'
+			&& uniqueConstraints.length > 0
+		) {
+			for (const uniqueConstraint of uniqueConstraints) {
+				statement += ',\n';
+				const unsquashedUnique = MySqlSquasher.unsquashUnique(uniqueConstraint);
+
+				const uniqueString = unsquashedUnique.columns.join(',');
+
+				statement += `\tCONSTRAINT \`${unsquashedUnique.name}\` UNIQUE(${uniqueString})`;
+			}
+		}
+
+		if (typeof checkConstraints !== 'undefined' && checkConstraints.length > 0) {
+			for (const checkConstraint of checkConstraints) {
+				statement += ',\n';
+				const unsquashedCheck = MySqlSquasher.unsquashCheck(checkConstraint);
+
+				statement += `\tCONSTRAINT \`${unsquashedCheck.name}\` CHECK(${unsquashedCheck.value})`;
+			}
+		}
+
+		statement += `\n);`;
+		statement += `\n`;
+		return statement;
+	}
+}
+
+class PgCreateViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreatePgViewStatement) {
+		const { definition, name: viewName, schema, with: withOption, materialized, withNoData, tablespace, using } = st;
+
+		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+
+		let statement = materialized ? `CREATE MATERIALIZED VIEW ${name}` : `CREATE VIEW ${name}`;
+
+		if (using) statement += ` USING "${using}"`;
+
+		const options: string[] = [];
+		if (withOption) {
+			statement += ` WITH (`;
+
+			Object.entries(withOption).forEach(([key, value]) => {
+				if (typeof value === 'undefined') return;
+
+				options.push(`${key.snake_case()} = ${value}`);
+			});
+
+			statement += options.join(', ');
+
+			statement += `)`;
+		}
+
+		if (tablespace) statement += ` TABLESPACE ${tablespace}`;
+
+		statement += ` AS (${definition})`;
+
+		if (withNoData) statement += ` WITH NO DATA`;
+
+		statement += `;`;
+
+		return statement;
+	}
+}
+
+class MySqlCreateViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'mysql_create_view' && dialect === 'mysql';
+	}
+
+	convert(st: JsonCreateMySqlViewStatement) {
+		const { definition, name, algorithm, sqlSecurity, withCheckOption, replace } = st;
+
+		let statement = `CREATE `;
+		statement += replace ? `OR REPLACE ` : '';
+		statement += algorithm ? `ALGORITHM = ${algorithm}\n` : '';
+		statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity}\n` : '';
+		statement += `VIEW \`${name}\` AS (${definition})`;
+		statement += withCheckOption ? `\nWITH ${withCheckOption} CHECK OPTION` : '';
+
+		statement += ';';
+
+		return statement;
+	}
+}
+
+class PgDropViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonDropViewStatement) {
+		const { name: viewName, schema, materialized } = st;
+
+		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
+
+		return `DROP${materialized ? ' MATERIALIZED' : ''} VIEW ${name};`;
+	}
+}
+
+class MySqlDropViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_view' && dialect === 'mysql';
+	}
+
+	convert(st: JsonDropViewStatement) {
+		const { name } = st;
+
+		return `DROP VIEW \`${name}\`;`;
+	}
+}
+
+class SqliteDropViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_view' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(st: JsonDropViewStatement) {
+		const { name } = st;
+
+		return `DROP VIEW \`${name}\`;`;
+	}
+}
+
+class PgRenameViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_view' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonRenameViewStatement) {
+		const { nameFrom: from, nameTo: to, schema, materialized } = st;
+
+		const nameFrom = `"${schema}"."${from}"`;
+
+		return `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW ${nameFrom} RENAME TO "${to}";`;
+	}
+}
+
+class MySqlRenameViewConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_view' && dialect === 'mysql';
+	}
+
+	convert(st: JsonRenameViewStatement) {
+		const { nameFrom: from, nameTo: to } = st;
+
+		return `RENAME TABLE \`${from}\` TO \`${to}\`;`;
+	}
+}
+
+class PgAlterViewSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_schema' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterSchemaStatement) {
+		const { fromSchema, toSchema, name, materialized } = st;
+
+		const statement = `ALTER${
+			materialized ? ' MATERIALIZED' : ''
+		} VIEW "${fromSchema}"."${name}" SET SCHEMA "${toSchema}";`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewAddWithOptionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_add_with_option' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAddWithOptionStatement) {
+		const { schema, with: withOption, name, materialized } = st;
+
+		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" SET (`;
+
+		const options: string[] = [];
+
+		Object.entries(withOption).forEach(([key, value]) => {
+			options.push(`${key.snake_case()} = ${value}`);
+		});
+
+		statement += options.join(', ');
+
+		statement += `);`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewDropWithOptionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_drop_with_option' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewDropWithOptionStatement) {
+		const { schema, name, materialized, with: withOptions } = st;
+
+		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" RESET (`;
+
+		const options: string[] = [];
+
+		Object.entries(withOptions).forEach(([key]) => {
+			options.push(`${key.snake_case()}`);
+		});
+
+		statement += options.join(', ');
+
+		statement += ');';
+
+		return statement;
+	}
+}
+
+class PgAlterViewAlterTablespaceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_tablespace' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterTablespaceStatement) {
+		const { schema, name, toTablespace } = st;
+
+		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET TABLESPACE ${toTablespace};`;
+
+		return statement;
+	}
+}
+
+class PgAlterViewAlterUsingConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_view_alter_using' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterViewAlterUsingStatement) {
+		const { schema, name, toUsing } = st;
+
+		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET ACCESS METHOD "${toUsing}";`;
+
+		return statement;
+	}
+}
+
+class PgAlterTableAlterColumnSetGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnSetIdentityStatement,
+	): string | string[] {
+		const { identity, tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
+
+		const identityWithSchema = schema
+			? `"${schema}"."${unsquashedIdentity?.name}"`
+			: `"${unsquashedIdentity?.name}"`;
+
+		const identityStatement = unsquashedIdentity
+			? ` GENERATED ${
+				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+			} AS IDENTITY (sequence name ${identityWithSchema}${
+				unsquashedIdentity.increment
+					? ` INCREMENT BY ${unsquashedIdentity.increment}`
+					: ''
+			}${
+				unsquashedIdentity.minValue
+					? ` MINVALUE ${unsquashedIdentity.minValue}`
+					: ''
+			}${
+				unsquashedIdentity.maxValue
+					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+					: ''
+			}${
+				unsquashedIdentity.startWith
+					? ` START WITH ${unsquashedIdentity.startWith}`
+					: ''
+			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+				unsquashedIdentity.cycle ? ` CYCLE` : ''
+			})`
+			: '';
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" ADD${identityStatement};`;
+	}
+}
+
+class PgAlterTableAlterColumnDropGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnDropIdentityStatement,
+	): string | string[] {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP IDENTITY;`;
+	}
+}
+
+class PgAlterTableAlterColumnAlterGenerated extends Convertor {
+	override can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_change_identity'
+			&& dialect === 'postgresql'
+		);
+	}
+	override convert(
+		statement: JsonAlterColumnAlterIdentityStatement,
+	): string | string[] {
+		const { identity, oldIdentity, tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
+		const unsquashedOldIdentity = PgSquasher.unsquashIdentity(oldIdentity);
+
+		const statementsToReturn: string[] = [];
+
+		if (unsquashedOldIdentity.type !== unsquashedIdentity.type) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET GENERATED ${
+					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+				};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.minValue !== unsquashedIdentity.minValue) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MINVALUE ${unsquashedIdentity.minValue};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.maxValue !== unsquashedIdentity.maxValue) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MAXVALUE ${unsquashedIdentity.maxValue};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.increment !== unsquashedIdentity.increment) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET INCREMENT BY ${unsquashedIdentity.increment};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.startWith !== unsquashedIdentity.startWith) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET START WITH ${unsquashedIdentity.startWith};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.cache !== unsquashedIdentity.cache) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET CACHE ${unsquashedIdentity.cache};`,
+			);
+		}
+
+		if (unsquashedOldIdentity.cycle !== unsquashedIdentity.cycle) {
+			statementsToReturn.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET ${
+					unsquashedIdentity.cycle ? `CYCLE` : 'NO CYCLE'
+				};`,
+			);
+		}
+
+		return statementsToReturn;
+	}
+}
+
+class PgAlterTableAddUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'create_unique_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonCreateUniqueConstraint): string {
+		const unsquashed = PgSquasher.unsquashUnique(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" UNIQUE${
+			unsquashed.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
+		}("${unsquashed.columns.join('","')}");`;
+	}
+}
+
+class PgAlterTableDropUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'delete_unique_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonDeleteUniqueConstraint): string {
+		const unsquashed = PgSquasher.unsquashUnique(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unsquashed.name}";`;
+	}
+}
+
+class PgAlterTableAddCheckConstraintConvertor extends Convertor {
+	can(statement: JsonCreateCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'create_check_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonCreateCheckConstraint): string {
+		const unsquashed = PgSquasher.unsquashCheck(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" CHECK (${unsquashed.value});`;
+	}
+}
+
+class PgAlterTableDeleteCheckConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'delete_check_constraint' && dialect === 'postgresql'
+		);
+	}
+	convert(statement: JsonDeleteCheckConstraint): string {
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
+	}
+}
+
+class MySQLAlterTableAddUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
+		return statement.type === 'create_unique_constraint' && dialect === 'mysql';
+	}
+	convert(statement: JsonCreateUniqueConstraint): string {
+		const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+
+		return `ALTER TABLE \`${statement.tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${
+			unsquashed.columns.join('`,`')
+		}\`);`;
+	}
+}
+
+class MySQLAlterTableDropUniqueConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
+		return statement.type === 'delete_unique_constraint' && dialect === 'mysql';
+	}
+	convert(statement: JsonDeleteUniqueConstraint): string {
+		const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+
+		return `ALTER TABLE \`${statement.tableName}\` DROP INDEX \`${unsquashed.name}\`;`;
+	}
+}
+
+class MySqlAlterTableAddCheckConstraintConvertor extends Convertor {
+	can(statement: JsonCreateCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'create_check_constraint' && dialect === 'mysql'
+		);
+	}
+	convert(statement: JsonCreateCheckConstraint): string {
+		const unsquashed = MySqlSquasher.unsquashCheck(statement.data);
+		const { tableName } = statement;
+
+		return `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` CHECK (${unsquashed.value});`;
+	}
+}
+
+class MySqlAlterTableDeleteCheckConstraintConvertor extends Convertor {
+	can(statement: JsonDeleteCheckConstraint, dialect: Dialect): boolean {
+		return (
+			statement.type === 'delete_check_constraint' && dialect === 'mysql'
+		);
+	}
+	convert(statement: JsonDeleteCheckConstraint): string {
+		const { tableName } = statement;
+
+		return `ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${statement.constraintName}\`;`;
+	}
+}
+
+class CreatePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonCreateSequenceStatement) {
+		const { name, values, schema } = st;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `CREATE SEQUENCE ${sequenceWithSchema}${values.increment ? ` INCREMENT BY ${values.increment}` : ''}${
+			values.minValue ? ` MINVALUE ${values.minValue}` : ''
+		}${values.maxValue ? ` MAXVALUE ${values.maxValue}` : ''}${
+			values.startWith ? ` START WITH ${values.startWith}` : ''
+		}${values.cache ? ` CACHE ${values.cache}` : ''}${values.cycle ? ` CYCLE` : ''};`;
+	}
+}
+
+class DropPgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonDropSequenceStatement) {
+		const { name, schema } = st;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `DROP SEQUENCE ${sequenceWithSchema};`;
+	}
+}
+
+class RenamePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonRenameSequenceStatement) {
+		const { nameFrom, nameTo, schema } = st;
+
+		const sequenceWithSchemaFrom = schema
+			? `"${schema}"."${nameFrom}"`
+			: `"${nameFrom}"`;
+		// const sequenceWithSchemaTo = schema
+		// 	? `"${schema}"."${nameTo}"`
+		// 	: `"${nameTo}"`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${nameTo}";`;
+	}
+}
+
+class MovePgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'move_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonMoveSequenceStatement) {
+		const { schemaFrom, schemaTo, name } = st;
+
+		const sequenceWithSchema = schemaFrom
+			? `"${schemaFrom}"."${name}"`
+			: `"${name}"`;
+
+		const seqSchemaTo = schemaTo ? `"${schemaTo}"` : `public`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
+	}
+}
+
+class AlterPgSequenceConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_sequence' && dialect === 'postgresql';
+	}
+
+	convert(st: JsonAlterSequenceStatement) {
+		const { name, schema, values } = st;
+
+		const { increment, minValue, maxValue, startWith, cache, cycle } = values;
+
+		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `ALTER SEQUENCE ${sequenceWithSchema}${increment ? ` INCREMENT BY ${increment}` : ''}${
+			minValue ? ` MINVALUE ${minValue}` : ''
+		}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
+			cache ? ` CACHE ${cache}` : ''
+		}${cycle ? ` CYCLE` : ''};`;
+	}
+}
+
+class CreateTypeEnumConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'create_type_enum';
+	}
+
+	convert(st: JsonCreateEnumStatement) {
+		const { name, values, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		let valuesStatement = '(';
+		valuesStatement += values.map((it) => `'${escapeSingleQuotes(it)}'`).join(', ');
+		valuesStatement += ')';
+
+		// TODO do we need this?
+		// let statement = 'DO $$ BEGIN';
+		// statement += '\n';
+		let statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
+		// statement += '\n';
+		// statement += 'EXCEPTION';
+		// statement += '\n';
+		// statement += ' WHEN duplicate_object THEN null;';
+		// statement += '\n';
+		// statement += 'END $$;';
+		// statement += '\n';
+		return statement;
+	}
+}
+
+class DropTypeEnumConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'drop_type_enum';
+	}
+
+	convert(st: JsonDropEnumStatement) {
+		const { name, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		let statement = `DROP TYPE ${enumNameWithSchema};`;
+
+		return statement;
+	}
+}
+
+class AlterTypeAddValueConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'alter_type_add_value';
+	}
+
+	convert(st: JsonAddValueToEnumStatement) {
+		const { name, schema, value, before } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} ADD VALUE '${value}'${before.length ? ` BEFORE '${before}'` : ''};`;
+	}
+}
+
+class AlterTypeSetSchemaConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'move_type_enum';
+	}
+
+	convert(st: JsonMoveEnumStatement) {
+		const { name, schemaFrom, schemaTo } = st;
+
+		const enumNameWithSchema = schemaFrom ? `"${schemaFrom}"."${name}"` : `"${name}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${schemaTo}";`;
+	}
+}
+
+class AlterRenameTypeConvertor extends Convertor {
+	can(statement: JsonStatement): boolean {
+		return statement.type === 'rename_type_enum';
+	}
+
+	convert(st: JsonRenameEnumStatement) {
+		const { nameTo, nameFrom, schema } = st;
+
+		const enumNameWithSchema = schema ? `"${schema}"."${nameFrom}"` : `"${nameFrom}"`;
+
+		return `ALTER TYPE ${enumNameWithSchema} RENAME TO "${nameTo}";`;
+	}
+}
+
+class AlterTypeDropValueConvertor extends Convertor {
+	can(statement: JsonDropValueFromEnumStatement): boolean {
+		return statement.type === 'alter_type_drop_value';
+	}
+
+	convert(st: JsonDropValueFromEnumStatement) {
+		const { columnsWithEnum, name, newValues, enumSchema } = st;
+
+		const statements: string[] = [];
+
+		for (const withEnum of columnsWithEnum) {
+			const tableNameWithSchema = withEnum.tableSchema
+				? `"${withEnum.tableSchema}"."${withEnum.table}"`
+				: `"${withEnum.table}"`;
+
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE text;`,
+			);
+			if (withEnum.default) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::text;`,
+				);
+			}
+		}
+
+		statements.push(new DropTypeEnumConvertor().convert({ name: name, schema: enumSchema, type: 'drop_type_enum' }));
+
+		statements.push(new CreateTypeEnumConvertor().convert({
+			name: name,
+			schema: enumSchema,
+			values: newValues,
+			type: 'create_type_enum',
+		}));
+
+		for (const withEnum of columnsWithEnum) {
+			const tableNameWithSchema = withEnum.tableSchema
+				? `"${withEnum.tableSchema}"."${withEnum.table}"`
+				: `"${withEnum.table}"`;
+
+			const parsedType = parseType(`"${enumSchema}".`, withEnum.columnType);
+			if (withEnum.default) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::${parsedType};`,
+				);
+			}
+
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE ${parsedType} USING "${withEnum.column}"::${parsedType};`,
+			);
+		}
+
+		return statements;
+	}
+}
+
+class PgDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDropTableStatement, _d: any, action?: string) {
+		const { tableName, schema, policies } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const dropPolicyConvertor = new PgDropPolicyConvertor();
+		const droppedPolicies = policies?.map((p) => {
+			return dropPolicyConvertor.convert({
+				type: 'drop_policy',
+				tableName,
+				data: action === 'push'
+					? PgSquasher.unsquashPolicyPush(p)
+					: PgSquasher.unsquashPolicy(p),
+				schema,
+			}) as string;
+		}) ?? [];
+
+		return [
+			...droppedPolicies,
+			`DROP TABLE ${tableNameWithSchema} CASCADE;`,
+		];
+	}
+}
+
+class MySQLDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+export class SingleStoreDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+export class SQLiteDropTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_table' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropTableStatement) {
+		const { tableName } = statement;
+		return `DROP TABLE \`${tableName}\`;`;
+	}
+}
+
+class PgRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo, fromSchema } = statement;
+		const from = fromSchema
+			? `"${fromSchema}"."${tableNameFrom}"`
+			: `"${tableNameFrom}"`;
+		const to = `"${tableNameTo}"`;
+		return `ALTER TABLE ${from} RENAME TO ${to};`;
+	}
+}
+
+export class SqliteRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
+	}
+}
+
+class MySqlRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `RENAME TABLE \`${tableNameFrom}\` TO \`${tableNameTo}\`;`;
+	}
+}
+
+export class SingleStoreRenameTableConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_table' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonRenameTableStatement) {
+		const { tableNameFrom, tableNameTo } = statement;
+		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
+	}
+}
+
+class PgAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
+	}
+}
+
+class MySqlAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'mysql'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` RENAME COLUMN \`${oldColumnName}\` TO \`${newColumnName}\`;`;
+	}
+}
+
+class SingleStoreAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && dialect === 'singlestore'
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` CHANGE \`${oldColumnName}\` \`${newColumnName}\`;`;
+	}
+}
+
+class SQLiteAlterTableRenameColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_rename_column' && (dialect === 'sqlite' || dialect === 'turso')
+		);
+	}
+
+	convert(statement: JsonRenameColumnStatement) {
+		const { tableName, oldColumnName, newColumnName } = statement;
+		return `ALTER TABLE \`${tableName}\` RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
+	}
+}
+
+class PgAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_drop_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${columnName}";`;
+	}
+}
+
+class MySqlAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class SingleStoreAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class SQLiteAlterTableDropColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_drop_column' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropColumnStatement) {
+		const { tableName, columnName } = statement;
+		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
+	}
+}
+
+class PgAlterTableAddColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_add_column' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAddColumnStatement) {
+		const { tableName, column, schema } = statement;
+		const { name, notNull, generated, primaryKey, identity } = column;
+
+		const primaryKeyStatement = primaryKey ? ' PRIMARY KEY' : '';
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
+
+		const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
+			? `"${column.typeSchema}".`
+			: '';
+
+		const fixedType = parseType(schemaPrefix, column.type);
+
+		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+
+		const unsquashedIdentity = identity
+			? PgSquasher.unsquashIdentity(identity)
+			: undefined;
+
+		const identityWithSchema = schema
+			? `"${schema}"."${unsquashedIdentity?.name}"`
+			: `"${unsquashedIdentity?.name}"`;
+
+		const identityStatement = unsquashedIdentity
+			? ` GENERATED ${
+				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
+			} AS IDENTITY (sequence name ${identityWithSchema}${
+				unsquashedIdentity.increment
+					? ` INCREMENT BY ${unsquashedIdentity.increment}`
+					: ''
+			}${
+				unsquashedIdentity.minValue
+					? ` MINVALUE ${unsquashedIdentity.minValue}`
+					: ''
+			}${
+				unsquashedIdentity.maxValue
+					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
+					: ''
+			}${
+				unsquashedIdentity.startWith
+					? ` START WITH ${unsquashedIdentity.startWith}`
+					: ''
+			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
+				unsquashedIdentity.cycle ? ` CYCLE` : ''
+			})`
+			: '';
+
+		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
+	}
+}
+
+class MySqlAlterTableAddColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_add_column' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonAddColumnStatement) {
+		const { tableName, column } = statement;
+		const {
+			name,
+			type,
+			notNull,
+			primaryKey,
+			autoincrement,
+			onUpdate,
+			generated,
+		} = column;
+
+		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
+		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
+		const autoincrementStatement = `${autoincrement ? ' AUTO_INCREMENT' : ''}`;
+		const onUpdateStatement = `${onUpdate ? ' ON UPDATE CURRENT_TIMESTAMP' : ''}`;
+
+		const generatedStatement = generated
+			? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
+			: '';
+
+		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${onUpdateStatement};`;
+	}
+}
+
+class SingleStoreAlterTableAddColumnConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_table_add_column' && dialect === 'singlestore';
+	}
+
+	convert(statement: JsonAddColumnStatement) {
+		const { tableName, column } = statement;
+		const {
+			name,
+			type,
+			notNull,
+			primaryKey,
+			autoincrement,
+			onUpdate,
+			generated,
+		} = column;
+
+		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
+		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
+		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
+		const autoincrementStatement = `${autoincrement ? ' AUTO_INCREMENT' : ''}`;
+		const onUpdateStatement = `${onUpdate ? ' ON UPDATE CURRENT_TIMESTAMP' : ''}`;
+
+		const generatedStatement = generated
+			? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
+			: '';
+
+		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${notNullStatement}${onUpdateStatement}${generatedStatement};`;
+	}
+}
+
+class PgAlterTableAlterColumnSetTypeConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'pg_alter_table_alter_column_set_type'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnPgTypeStatement) {
+		const { tableName, columnName, newDataType, schema, oldDataType, columnDefault, typeSchema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const statements: string[] = [];
+
+		const type = parseType(`"${typeSchema}".`, newDataType.name);
+
+		if (!oldDataType.isEnum && !newDataType.isEnum) {
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
+			);
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			}
+		}
+
+		if (oldDataType.isEnum && !newDataType.isEnum) {
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
+			);
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			}
+		}
+
+		if (!oldDataType.isEnum && newDataType.isEnum) {
+			if (columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault}::${type};`,
+				);
+			}
+			statements.push(
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::${type};`,
+			);
+		}
+
+		if (oldDataType.isEnum && newDataType.isEnum) {
+			const alterType =
+				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::text::${type};`;
+
+			if (newDataType.name !== oldDataType.name && columnDefault) {
+				statements.push(
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`,
+					alterType,
+					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
+				);
+			} else {
+				statements.push(alterType);
+			}
+		}
+
+		return statements;
+	}
+}
+
+class PgAlterTableAlterColumnSetDefaultConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_default'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetDefaultStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${statement.newDefaultValue};`;
+	}
+}
+
+class PgAlterTableAlterColumnDropDefaultConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_default'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropDefaultStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`;
+	}
+}
+
+class PgAlterTableAlterColumnDropGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropGeneratedStatement) {
+		const { tableName, columnName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP EXPRESSION;`;
+	}
+}
+
+class PgAlterTableAlterColumnSetExpressionConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
+			schema,
+			tableName,
+			column: {
+				name: columnName,
+				type: statement.newDataType,
+				notNull,
+				default: columnDefault,
+				onUpdate: columnOnUpdate,
+				autoincrement: columnAutoIncrement,
+				primaryKey: columnPk,
+				generated: columnGenerated,
+			},
+			type: 'alter_table_add_column',
+		});
+
+		return [
+			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
+			addColumnStatement,
+		];
+	}
+}
+
+class PgAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_alter_generated'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
+			schema,
+			tableName,
+			column: {
+				name: columnName,
+				type: statement.newDataType,
+				notNull,
+				default: columnDefault,
+				onUpdate: columnOnUpdate,
+				autoincrement: columnAutoIncrement,
+				primaryKey: columnPk,
+				generated: columnGenerated,
+			},
+			type: 'alter_table_add_column',
+		});
+
+		return [
+			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
+			addColumnStatement,
+		];
+	}
+}
+
+////
+
+type MySqlModifyColumnStatement =
+	| JsonAlterColumnDropNotNullStatement
+	| JsonAlterColumnSetNotNullStatement
+	| JsonAlterColumnTypeStatement
+	| JsonAlterColumnDropOnUpdateStatement
+	| JsonAlterColumnSetOnUpdateStatement
+	| JsonAlterColumnDropAutoincrementStatement
+	| JsonAlterColumnSetAutoincrementStatement
+	| JsonAlterColumnSetDefaultStatement
+	| JsonAlterColumnDropDefaultStatement
+	| JsonAlterColumnSetGeneratedStatement
+	| JsonAlterColumnDropGeneratedStatement;
+
+class MySqlModifyColumn extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			(statement.type === 'alter_table_alter_column_set_type'
+				|| statement.type === 'alter_table_alter_column_set_notnull'
+				|| statement.type === 'alter_table_alter_column_drop_notnull'
+				|| statement.type === 'alter_table_alter_column_drop_on_update'
+				|| statement.type === 'alter_table_alter_column_set_on_update'
+				|| statement.type === 'alter_table_alter_column_set_autoincrement'
+				|| statement.type === 'alter_table_alter_column_drop_autoincrement'
+				|| statement.type === 'alter_table_alter_column_set_default'
+				|| statement.type === 'alter_table_alter_column_drop_default'
+				|| statement.type === 'alter_table_alter_column_set_generated'
+				|| statement.type === 'alter_table_alter_column_drop_generated')
+			&& dialect === 'mysql'
+		);
+	}
+
+	convert(statement: MySqlModifyColumnStatement) {
+		const { tableName, columnName } = statement;
+		let columnType = ``;
+		let columnDefault: any = '';
+		let columnNotNull = '';
+		let columnOnUpdate = '';
+		let columnAutoincrement = '';
+		// let primaryKey = statement.columnPk ? ' PRIMARY KEY' : '';
+		let columnGenerated = '';
+
+		if (statement.type === 'alter_table_alter_column_drop_notnull') {
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
+			columnNotNull = ` NOT NULL`;
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_drop_on_update') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnOnUpdate = '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_on_update') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (
+			statement.type === 'alter_table_alter_column_set_autoincrement'
+		) {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = ' AUTO_INCREMENT';
+		} else if (
+			statement.type === 'alter_table_alter_column_drop_autoincrement'
+		) {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = '';
+		} else if (statement.type === 'alter_table_alter_column_set_default') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_drop_default') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_generated') {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+
+			if (statement.columnGenerated?.type === 'virtual') {
+				return [
+					new MySqlAlterTableDropColumnConvertor().convert({
+						type: 'alter_table_drop_column',
+						tableName: statement.tableName,
+						columnName: statement.columnName,
+						schema: statement.schema,
+					}),
+					new MySqlAlterTableAddColumnConvertor().convert({
+						tableName,
+						column: {
+							name: columnName,
+							type: statement.newDataType,
+							notNull: statement.columnNotNull,
+							default: statement.columnDefault,
+							onUpdate: statement.columnOnUpdate,
+							autoincrement: statement.columnAutoIncrement,
+							primaryKey: statement.columnPk,
+							generated: statement.columnGenerated,
+						},
+						schema: statement.schema,
+						type: 'alter_table_add_column',
+					}),
+				];
+			} else {
+				columnGenerated = statement.columnGenerated
+					? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
+					: '';
+			}
+		} else if (statement.type === 'alter_table_alter_column_drop_generated') {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+
+			if (statement.oldColumn?.generated?.type === 'virtual') {
+				return [
+					new MySqlAlterTableDropColumnConvertor().convert({
+						type: 'alter_table_drop_column',
+						tableName: statement.tableName,
+						columnName: statement.columnName,
+						schema: statement.schema,
+					}),
+					new MySqlAlterTableAddColumnConvertor().convert({
+						tableName,
+						column: {
+							name: columnName,
+							type: statement.newDataType,
+							notNull: statement.columnNotNull,
+							default: statement.columnDefault,
+							onUpdate: statement.columnOnUpdate,
+							autoincrement: statement.columnAutoIncrement,
+							primaryKey: statement.columnPk,
+							generated: statement.columnGenerated,
+						},
+						schema: statement.schema,
+						type: 'alter_table_add_column',
+					}),
+				];
+			}
+		} else {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+			columnGenerated = statement.columnGenerated
+				? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
+				: '';
+		}
+
+		// Seems like getting value from simple json2 shanpshot makes dates be dates
+		columnDefault = columnDefault instanceof Date
+			? columnDefault.toISOString()
+			: columnDefault;
+
+		return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnGenerated}${columnNotNull}${columnDefault}${columnOnUpdate};`;
+	}
+}
+
+class SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_alter_generated'
+			&& dialect === 'singlestore'
+		);
+	}
+
+	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
+		const {
+			tableName,
+			columnName,
+			schema,
+			columnNotNull: notNull,
+			columnDefault,
+			columnOnUpdate,
+			columnAutoIncrement,
+			columnPk,
+			columnGenerated,
+		} = statement;
+
+		const tableNameWithSchema = schema
+			? `\`${schema}\`.\`${tableName}\``
+			: `\`${tableName}\``;
+
+		const addColumnStatement = new SingleStoreAlterTableAddColumnConvertor().convert({
+			schema,
+			tableName,
+			column: {
+				name: columnName,
+				type: statement.newDataType,
+				notNull,
+				default: columnDefault,
+				onUpdate: columnOnUpdate,
+				autoincrement: columnAutoIncrement,
+				primaryKey: columnPk,
+				generated: columnGenerated,
+			},
+			type: 'alter_table_add_column',
+		});
+
+		return [
+			`ALTER TABLE ${tableNameWithSchema} drop column \`${columnName}\`;`,
+			addColumnStatement,
+		];
+	}
+}
+
+// class SingleStoreAlterTableAlterColumnSetDefaultConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return (
+// 			statement.type === 'alter_table_alter_column_set_default'
+// 			&& dialect === 'singlestore'
+// 		);
+// 	}
+
+// 	convert(statement: JsonAlterColumnSetDefaultStatement) {
+// 		const { tableName, columnName } = statement;
+// 		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` SET DEFAULT ${statement.newDefaultValue};`;
+// 	}
+// }
+
+// class SingleStoreAlterTableAlterColumnDropDefaultConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return (
+// 			statement.type === 'alter_table_alter_column_drop_default'
+// 			&& dialect === 'singlestore'
+// 		);
+// 	}
+
+// 	convert(statement: JsonAlterColumnDropDefaultStatement) {
+// 		const { tableName, columnName } = statement;
+// 		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` DROP DEFAULT;`;
+// 	}
+// }
+
+class SingleStoreAlterTableAddPk extends Convertor {
+	can(statement: JsonStatement, dialect: string): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_pk'
+			&& dialect === 'singlestore'
+		);
+	}
+	convert(statement: JsonAlterColumnSetPrimaryKeyStatement): string {
+		return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY (\`${statement.columnName}\`);`;
+	}
+}
+
+class SingleStoreAlterTableDropPk extends Convertor {
+	can(statement: JsonStatement, dialect: string): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_pk'
+			&& dialect === 'singlestore'
+		);
+	}
+	convert(statement: JsonAlterColumnDropPrimaryKeyStatement): string {
+		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY`;
+	}
+}
+
+type SingleStoreModifyColumnStatement =
+	| JsonAlterColumnDropNotNullStatement
+	| JsonAlterColumnSetNotNullStatement
+	| JsonAlterColumnTypeStatement
+	| JsonAlterColumnDropOnUpdateStatement
+	| JsonAlterColumnSetOnUpdateStatement
+	| JsonAlterColumnDropAutoincrementStatement
+	| JsonAlterColumnSetAutoincrementStatement
+	| JsonAlterColumnSetDefaultStatement
+	| JsonAlterColumnDropDefaultStatement
+	| JsonAlterColumnSetGeneratedStatement
+	| JsonAlterColumnDropGeneratedStatement;
+
+class SingleStoreModifyColumn extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			(statement.type === 'alter_table_alter_column_set_type'
+				|| statement.type === 'alter_table_alter_column_set_notnull'
+				|| statement.type === 'alter_table_alter_column_drop_notnull'
+				|| statement.type === 'alter_table_alter_column_drop_on_update'
+				|| statement.type === 'alter_table_alter_column_set_on_update'
+				|| statement.type === 'alter_table_alter_column_set_autoincrement'
+				|| statement.type === 'alter_table_alter_column_drop_autoincrement'
+				|| statement.type === 'alter_table_alter_column_set_default'
+				|| statement.type === 'alter_table_alter_column_drop_default'
+				|| statement.type === 'alter_table_alter_column_set_generated'
+				|| statement.type === 'alter_table_alter_column_drop_generated')
+			&& dialect === 'singlestore'
+		);
+	}
+
+	convert(statement: SingleStoreModifyColumnStatement) {
+		const { tableName, columnName } = statement;
+		let columnType = ``;
+		let columnDefault: any = '';
+		let columnNotNull = '';
+		let columnOnUpdate = '';
+		let columnAutoincrement = '';
+		// let primaryKey = statement.columnPk ? ' PRIMARY KEY' : '';
+		let columnGenerated = '';
+
+		if (statement.type === 'alter_table_alter_column_drop_notnull') {
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
+			columnNotNull = ` NOT NULL`;
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_drop_on_update') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnOnUpdate = '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_on_update') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (
+			statement.type === 'alter_table_alter_column_set_autoincrement'
+		) {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = ' AUTO_INCREMENT';
+		} else if (
+			statement.type === 'alter_table_alter_column_drop_autoincrement'
+		) {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = '';
+		} else if (statement.type === 'alter_table_alter_column_set_default') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_drop_default') {
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnType = ` ${statement.newDataType}`;
+			columnDefault = '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+		} else if (statement.type === 'alter_table_alter_column_set_generated') {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+
+			if (statement.columnGenerated?.type === 'virtual') {
+				return [
+					new SingleStoreAlterTableDropColumnConvertor().convert({
+						type: 'alter_table_drop_column',
+						tableName: statement.tableName,
+						columnName: statement.columnName,
+						schema: statement.schema,
+					}),
+					new SingleStoreAlterTableAddColumnConvertor().convert({
+						tableName,
+						column: {
+							name: columnName,
+							type: statement.newDataType,
+							notNull: statement.columnNotNull,
+							default: statement.columnDefault,
+							onUpdate: statement.columnOnUpdate,
+							autoincrement: statement.columnAutoIncrement,
+							primaryKey: statement.columnPk,
+							generated: statement.columnGenerated,
+						},
+						schema: statement.schema,
+						type: 'alter_table_add_column',
+					}),
+				];
+			} else {
+				columnGenerated = statement.columnGenerated
+					? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
+					: '';
+			}
+		} else if (statement.type === 'alter_table_alter_column_drop_generated') {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+
+			if (statement.oldColumn?.generated?.type === 'virtual') {
+				return [
+					new SingleStoreAlterTableDropColumnConvertor().convert({
+						type: 'alter_table_drop_column',
+						tableName: statement.tableName,
+						columnName: statement.columnName,
+						schema: statement.schema,
+					}),
+					new SingleStoreAlterTableAddColumnConvertor().convert({
+						tableName,
+						column: {
+							name: columnName,
+							type: statement.newDataType,
+							notNull: statement.columnNotNull,
+							default: statement.columnDefault,
+							onUpdate: statement.columnOnUpdate,
+							autoincrement: statement.columnAutoIncrement,
+							primaryKey: statement.columnPk,
+							generated: statement.columnGenerated,
+						},
+						schema: statement.schema,
+						type: 'alter_table_add_column',
+					}),
+				];
+			}
+		} else {
+			columnType = ` ${statement.newDataType}`;
+			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
+			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
+				? ` ON UPDATE CURRENT_TIMESTAMP`
+				: '';
+			columnDefault = statement.columnDefault
+				? ` DEFAULT ${statement.columnDefault}`
+				: '';
+			columnAutoincrement = statement.columnAutoIncrement
+				? ' AUTO_INCREMENT'
+				: '';
+			columnGenerated = statement.columnGenerated
+				? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
+				: '';
+		}
+
+		// Seems like getting value from simple json2 shanpshot makes dates be dates
+		columnDefault = columnDefault instanceof Date
+			? columnDefault.toISOString()
+			: columnDefault;
+
+		return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnNotNull}${columnDefault}${columnOnUpdate}${columnGenerated};`;
+	}
+}
+// class SqliteAlterTableAlterColumnDropDefaultConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return (
+// 			statement.type === 'alter_table_alter_column_drop_default'
+// 			&& dialect === 'sqlite'
+// 		);
+// 	}
+
+// 	convert(statement: JsonAlterColumnDropDefaultStatement) {
+// 		return (
+// 			'/*\n SQLite does not support "Drop default from column" out of the box, we do not generate automatic migration for that, so it has to be done manually'
+// 			+ '\n Please refer to: https://www.techonthenet.com/sqlite/tables/alter_table.php'
+// 			+ '\n                  https://www.sqlite.org/lang_altertable.html'
+// 			+ '\n                  https://stackoverflow.com/questions/2083543/modify-a-columns-type-in-sqlite3'
+// 			+ "\n\n Due to that we don't generate migration automatically and it has to be done manually"
+// 			+ '\n*/'
+// 		);
+// 	}
+// }
+
+class PgAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateCompositePK) {
+		const { columns } = PgSquasher.unsquashPK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.constraintName}" PRIMARY KEY("${
+			columns.join('","')
+		}");`;
+	}
+}
+class PgAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDeleteCompositePK) {
+		// const { name, columns } = PgSquasher.unsquashPK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
+	}
+}
+
+class PgAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_composite_pk' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonAlterCompositePK) {
+		// const { name, columns } = PgSquasher.unsquashPK(statement.old);
+		const { columns: newColumns } = PgSquasher.unsquashPK(
+			statement.new,
+		);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.oldConstraintName}";\n${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.newConstraintName}" PRIMARY KEY("${
+			newColumns.join('","')
+		}");`;
+	}
+}
+
+class MySqlAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_composite_pk' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonCreateCompositePK) {
+		const { columns } = MySqlSquasher.unsquashPK(statement.data);
+		return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY(\`${columns.join('`,`')}\`);`;
+	}
+}
+
+class MySqlAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_composite_pk' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDeleteCompositePK) {
+		// const { name, columns } = MySqlSquasher.unsquashPK(statement.data);
+		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY;`;
+	}
+}
+
+class MySqlAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_composite_pk' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonAlterCompositePK) {
+		// const { name, columns } = MySqlSquasher.unsquashPK(statement.old);
+		const { columns: newColumns } = MySqlSquasher.unsquashPK(
+			statement.new,
+		);
+		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY, ADD PRIMARY KEY(\`${newColumns.join('`,`')}\`);`;
+	}
+}
+
+// class SqliteAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return statement.type === 'create_composite_pk' && dialect === 'sqlite';
+// 	}
+
+// 	convert(statement: JsonCreateCompositePK) {
+// 		let msg = '/*\n';
+// 		msg += `You're trying to add PRIMARY KEY(${statement.data}) to '${statement.tableName}' table\n`;
+// 		msg += 'SQLite does not support adding primary key to an already created table\n';
+// 		msg += 'You can do it in 3 steps with drizzle orm:\n';
+// 		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
+// 		msg += ' - migrate old data from one table to another\n';
+// 		msg += ' - delete old_table in schema, generate sql\n\n';
+// 		msg += 'or create manual migration like below:\n\n';
+// 		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+// 		msg += 'CREATE TABLE table_name (\n';
+// 		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\t...\n';
+// 		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+// 		msg += ' );\n';
+// 		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+// 		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+// 		msg += '*/\n';
+// 		return msg;
+// 	}
+// }
+// class SqliteAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return statement.type === 'delete_composite_pk' && dialect === 'sqlite';
+// 	}
+
+// 	convert(statement: JsonDeleteCompositePK) {
+// 		let msg = '/*\n';
+// 		msg += `You're trying to delete PRIMARY KEY(${statement.data}) from '${statement.tableName}' table\n`;
+// 		msg += 'SQLite does not supportprimary key deletion from existing table\n';
+// 		msg += 'You can do it in 3 steps with drizzle orm:\n';
+// 		msg += ' - create new mirror table table without pk, rename current table to old_table, generate SQL\n';
+// 		msg += ' - migrate old data from one table to another\n';
+// 		msg += ' - delete old_table in schema, generate sql\n\n';
+// 		msg += 'or create manual migration like below:\n\n';
+// 		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+// 		msg += 'CREATE TABLE table_name (\n';
+// 		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\t...\n';
+// 		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+// 		msg += ' );\n';
+// 		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+// 		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+// 		msg += '*/\n';
+// 		return msg;
+// 	}
+// }
+
+// class SqliteAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
+// 	can(statement: JsonStatement, dialect: Dialect): boolean {
+// 		return statement.type === 'alter_composite_pk' && dialect === 'sqlite';
+// 	}
+
+// 	convert(statement: JsonAlterCompositePK) {
+// 		let msg = '/*\n';
+// 		msg += 'SQLite does not support altering primary key\n';
+// 		msg += 'You can do it in 3 steps with drizzle orm:\n';
+// 		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
+// 		msg += ' - migrate old data from one table to another\n';
+// 		msg += ' - delete old_table in schema, generate sql\n\n';
+// 		msg += 'or create manual migration like below:\n\n';
+// 		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
+// 		msg += 'CREATE TABLE table_name (\n';
+// 		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
+// 		msg += '\t...\n';
+// 		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
+// 		msg += ' );\n';
+// 		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
+// 		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
+// 		msg += '*/\n';
+
+// 		return msg;
+// 	}
+// }
+
+class PgAlterTableAlterColumnSetPrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_pk'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetPrimaryKeyStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ADD PRIMARY KEY ("${columnName}");`;
+	}
+}
+
+class PgAlterTableAlterColumnDropPrimaryKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_pk'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropPrimaryKeyStatement) {
+		const { tableName, schema } = statement;
+		return `/* 
+    Unfortunately in current drizzle-kit version we can't automatically get name for primary key.
+    We are working on making it available!
+
+    Meanwhile you can:
+        1. Check pk name in your database, by running
+            SELECT constraint_name FROM information_schema.table_constraints
+            WHERE table_schema = '${typeof schema === 'undefined' || schema === '' ? 'public' : schema}'
+                AND table_name = '${tableName}'
+                AND constraint_type = 'PRIMARY KEY';
+        2. Uncomment code below and paste pk name manually
+        
+    Hope to release this update as soon as possible
+*/
+
+-- ALTER TABLE "${tableName}" DROP CONSTRAINT "<constraint_name>";`;
+	}
+}
+
+class PgAlterTableAlterColumnSetNotNullConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_set_notnull'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnSetNotNullStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET NOT NULL;`;
+	}
+}
+
+class PgAlterTableAlterColumnDropNotNullConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_alter_column_drop_notnull'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterColumnDropNotNullStatement) {
+		const { columnName } = statement;
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP NOT NULL;`;
+	}
+}
+
+// FK
+class PgCreateForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateReferenceStatement): string {
+		const {
+			name,
+			tableFrom,
+			tableTo,
+			columnsFrom,
+			columnsTo,
+			onDelete,
+			onUpdate,
+			schemaTo,
+		} = PgSquasher.unsquashFK(statement.data);
+		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
+		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
+		const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(',');
+		const toColumnsString = columnsTo.map((it) => `"${it}"`).join(',');
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${tableFrom}"`
+			: `"${tableFrom}"`;
+
+		const tableToNameWithSchema = schemaTo
+			? `"${schemaTo}"."${tableTo}"`
+			: `"${tableTo}"`;
+
+		const alterStatement =
+			`ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+		return alterStatement;
+	}
+}
+
+class MySqlCreateForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_reference' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonCreateReferenceStatement): string {
+		const {
+			name,
+			tableFrom,
+			tableTo,
+			columnsFrom,
+			columnsTo,
+			onDelete,
+			onUpdate,
+		} = MySqlSquasher.unsquashFK(statement.data);
+		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
+		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
+		const fromColumnsString = columnsFrom.map((it) => `\`${it}\``).join(',');
+		const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
+
+		return `ALTER TABLE \`${tableFrom}\` ADD CONSTRAINT \`${name}\` FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+	}
+}
+
+class PgAlterForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'alter_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonAlterReferenceStatement): string {
+		const newFk = PgSquasher.unsquashFK(statement.data);
+		const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${oldFk.tableFrom}"`
+			: `"${oldFk.tableFrom}"`;
+
+		let sql = `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${oldFk.name}";\n`;
+
+		const onDeleteStatement = newFk.onDelete
+			? ` ON DELETE ${newFk.onDelete}`
+			: '';
+		const onUpdateStatement = newFk.onUpdate
+			? ` ON UPDATE ${newFk.onUpdate}`
+			: '';
+
+		const fromColumnsString = newFk.columnsFrom
+			.map((it) => `"${it}"`)
+			.join(',');
+		const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(',');
+
+		const tableFromNameWithSchema = oldFk.schemaTo
+			? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"`
+			: `"${oldFk.tableFrom}"`;
+
+		const tableToNameWithSchema = newFk.schemaTo
+			? `"${newFk.schemaTo}"."${newFk.tableFrom}"`
+			: `"${newFk.tableFrom}"`;
+
+		const alterStatement =
+			`ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
+
+		sql += alterStatement;
+		return sql;
+	}
+}
+
+class PgDeleteForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_reference' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDeleteReferenceStatement): string {
+		const tableFrom = statement.tableName; // delete fk from renamed table case
+		const { name } = PgSquasher.unsquashFK(statement.data);
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${tableFrom}"`
+			: `"${tableFrom}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name}";\n`;
+	}
+}
+
+class MySqlDeleteForeignKeyConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'delete_reference' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDeleteReferenceStatement): string {
+		const tableFrom = statement.tableName; // delete fk from renamed table case
+		const { name } = MySqlSquasher.unsquashFK(statement.data);
+		return `ALTER TABLE \`${tableFrom}\` DROP FOREIGN KEY \`${name}\`;\n`;
+	}
+}
+
+class CreatePgIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_index_pg' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonPgCreateIndexStatement): string {
+		const {
+			name,
+			columns,
+			isUnique,
+			concurrently,
+			with: withMap,
+			method,
+			where,
+		} = statement.data;
+		// // since postgresql 9.5
+		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+		const value = columns
+			.map(
+				(it) =>
+					`${it.isExpression ? it.expression : `"${it.expression}"`}${
+						it.opclass ? ` ${it.opclass}` : it.asc ? '' : ' DESC'
+					}${
+						(it.asc && it.nulls && it.nulls === 'last') || it.opclass
+							? ''
+							: ` NULLS ${it.nulls!.toUpperCase()}`
+					}`,
+			)
+			.join(',');
+
+		const tableNameWithSchema = statement.schema
+			? `"${statement.schema}"."${statement.tableName}"`
+			: `"${statement.tableName}"`;
+
+		function reverseLogic(mappedWith: Record<string, string>): string {
+			let reversedString = '';
+			for (const key in mappedWith) {
+				if (mappedWith.hasOwnProperty(key)) {
+					reversedString += `${key}=${mappedWith[key]},`;
+				}
+			}
+			reversedString = reversedString.slice(0, -1);
+			return reversedString;
+		}
+
+		return `CREATE ${indexPart}${
+			concurrently ? ' CONCURRENTLY' : ''
+		} "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${
+			Object.keys(withMap!).length !== 0
+				? ` WITH (${reverseLogic(withMap!)})`
+				: ''
+		}${where ? ` WHERE ${where}` : ''};`;
+	}
+}
+
+class PgDropIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_index' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonDropIndexStatement): string {
+		const { schema } = statement;
+		const { name } = PgSquasher.unsquashIdx(statement.data);
+
+		const indexNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
+
+		return `DROP INDEX ${indexNameWithSchema};`;
+	}
+}
+
+class PgCreateSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateSchema) {
+		const { name } = statement;
+		return `CREATE SCHEMA "${name}";\n`;
+	}
+}
+
+class PgRenameSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'rename_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonRenameSchema) {
+		const { from, to } = statement;
+		return `ALTER SCHEMA "${from}" RENAME TO "${to}";\n`;
+	}
+}
+
+class PgDropSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_schema' && dialect === 'postgresql';
+	}
+
+	convert(statement: JsonCreateSchema) {
+		const { name } = statement;
+		return `DROP SCHEMA "${name}";\n`;
+	}
+}
+
+class PgAlterTableSetSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_set_schema' && dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableSetSchema) {
+		const { tableName, schemaFrom, schemaTo } = statement;
+
+		return `ALTER TABLE "${schemaFrom}"."${tableName}" SET SCHEMA "${schemaTo}";\n`;
+	}
+}
+
+class PgAlterTableSetNewSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_set_new_schema'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableSetNewSchema) {
+		const { tableName, to, from } = statement;
+
+		const tableNameWithSchema = from
+			? `"${from}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA "${to}";\n`;
+	}
+}
+
+class PgAlterTableRemoveFromSchemaConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return (
+			statement.type === 'alter_table_remove_from_schema'
+			&& dialect === 'postgresql'
+		);
+	}
+
+	convert(statement: JsonAlterTableRemoveFromSchema) {
+		const { tableName, schema } = statement;
+
+		const tableNameWithSchema = schema
+			? `"${schema}"."${tableName}"`
+			: `"${tableName}"`;
+
+		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA public;\n`;
+	}
+}
+
+export class SqliteDropIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_index' && (dialect === 'sqlite' || dialect === 'turso');
+	}
+
+	convert(statement: JsonDropIndexStatement): string {
+		const { name } = PgSquasher.unsquashIdx(statement.data);
+		return `DROP INDEX \`${name}\`;`;
+	}
+}
+
+class MySqlDropIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'drop_index' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonDropIndexStatement): string {
+		const { name } = MySqlSquasher.unsquashIdx(statement.data);
+		return `DROP INDEX \`${name}\` ON \`${statement.tableName}\`;`;
+	}
+}
+
+class CreateMySqlIndexConvertor extends Convertor {
+	can(statement: JsonStatement, dialect: Dialect): boolean {
+		return statement.type === 'create_index' && dialect === 'mysql';
+	}
+
+	convert(statement: JsonCreateIndexStatement): string {
+		// should be changed
+		const { name, columns, isUnique } = MySqlSquasher.unsquashIdx(
+			statement.data,
+		);
+		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
+		const uniqueString = columns.join(',');
+
+		return `CREATE ${indexPart} \`${name}\` ON \`${statement.tableName}\` (${uniqueString});`;
+	}
+}
+
+const convertors: Convertor[] = [];
+convertors.push(new PgCreateTableConvertor());
+convertors.push(new MySqlCreateTableConvertor());
+
+convertors.push(new PgCreateViewConvertor());
+convertors.push(new PgDropViewConvertor());
+convertors.push(new PgRenameViewConvertor());
+convertors.push(new PgAlterViewSchemaConvertor());
+convertors.push(new PgAlterViewAddWithOptionConvertor());
+convertors.push(new PgAlterViewDropWithOptionConvertor());
+convertors.push(new PgAlterViewAlterTablespaceConvertor());
+convertors.push(new PgAlterViewAlterUsingConvertor());
+
+convertors.push(new MySqlCreateViewConvertor());
+convertors.push(new MySqlDropViewConvertor());
+convertors.push(new MySqlRenameViewConvertor());
+
+convertors.push(new SqliteDropViewConvertor());
+
+convertors.push(new CreateTypeEnumConvertor());
+convertors.push(new DropTypeEnumConvertor());
+convertors.push(new AlterTypeAddValueConvertor());
+convertors.push(new AlterTypeSetSchemaConvertor());
+convertors.push(new AlterRenameTypeConvertor());
+convertors.push(new AlterTypeDropValueConvertor());
+
+convertors.push(new CreatePgSequenceConvertor());
+convertors.push(new DropPgSequenceConvertor());
+convertors.push(new RenamePgSequenceConvertor());
+convertors.push(new MovePgSequenceConvertor());
+convertors.push(new AlterPgSequenceConvertor());
+
+convertors.push(new PgDropTableConvertor());
+convertors.push(new MySQLDropTableConvertor());
+convertors.push(new SingleStoreDropTableConvertor());
+convertors.push(new SQLiteDropTableConvertor());
+
+convertors.push(new PgRenameTableConvertor());
+convertors.push(new MySqlRenameTableConvertor());
+convertors.push(new SingleStoreRenameTableConvertor());
+convertors.push(new SqliteRenameTableConvertor());
+
+convertors.push(new PgAlterTableRenameColumnConvertor());
+convertors.push(new MySqlAlterTableRenameColumnConvertor());
+convertors.push(new SingleStoreAlterTableRenameColumnConvertor());
+convertors.push(new SQLiteAlterTableRenameColumnConvertor());
+
+convertors.push(new PgAlterTableDropColumnConvertor());
+convertors.push(new MySqlAlterTableDropColumnConvertor());
+convertors.push(new SingleStoreAlterTableDropColumnConvertor());
+convertors.push(new SQLiteAlterTableDropColumnConvertor());
+
+convertors.push(new PgAlterTableAddColumnConvertor());
+convertors.push(new MySqlAlterTableAddColumnConvertor());
+convertors.push(new SingleStoreAlterTableAddColumnConvertor());
+
+convertors.push(new PgAlterTableAlterColumnSetTypeConvertor());
+
+convertors.push(new PgAlterTableAddUniqueConstraintConvertor());
+convertors.push(new PgAlterTableDropUniqueConstraintConvertor());
+
+convertors.push(new PgAlterTableAddCheckConstraintConvertor());
+convertors.push(new PgAlterTableDeleteCheckConstraintConvertor());
+convertors.push(new MySqlAlterTableAddCheckConstraintConvertor());
+convertors.push(new MySqlAlterTableDeleteCheckConstraintConvertor());
+
+convertors.push(new MySQLAlterTableAddUniqueConstraintConvertor());
+convertors.push(new MySQLAlterTableDropUniqueConstraintConvertor());
+
+convertors.push(new CreatePgIndexConvertor());
+convertors.push(new CreateMySqlIndexConvertor());
+
+convertors.push(new PgDropIndexConvertor());
+convertors.push(new SqliteDropIndexConvertor());
+convertors.push(new MySqlDropIndexConvertor());
+
+convertors.push(new PgAlterTableAlterColumnSetPrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterColumnDropPrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
+convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
+convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
+convertors.push(new PgAlterTableAlterColumnDropDefaultConvertor());
+
+convertors.push(new PgAlterPolicyConvertor());
+convertors.push(new PgCreatePolicyConvertor());
+convertors.push(new PgDropPolicyConvertor());
+convertors.push(new PgRenamePolicyConvertor());
+
+convertors.push(new PgAlterIndPolicyConvertor());
+convertors.push(new PgCreateIndPolicyConvertor());
+convertors.push(new PgDropIndPolicyConvertor());
+convertors.push(new PgRenameIndPolicyConvertor());
+
+convertors.push(new PgEnableRlsConvertor());
+convertors.push(new PgDisableRlsConvertor());
+
+convertors.push(new PgDropRoleConvertor());
+convertors.push(new PgAlterRoleConvertor());
+convertors.push(new PgCreateRoleConvertor());
+convertors.push(new PgRenameRoleConvertor());
+
+/// generated
+convertors.push(new PgAlterTableAlterColumnSetExpressionConvertor());
+convertors.push(new PgAlterTableAlterColumnDropGeneratedConvertor());
+convertors.push(new PgAlterTableAlterColumnAlterrGeneratedConvertor());
+
+convertors.push(new SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor());
+convertors.push(new MySqlModifyColumn());
+// convertors.push(new MySqlAlterTableAlterColumnSetDefaultConvertor());
+// convertors.push(new MySqlAlterTableAlterColumnDropDefaultConvertor());
+
+convertors.push(new SingleStoreModifyColumn());
+
+convertors.push(new PgCreateForeignKeyConvertor());
+convertors.push(new MySqlCreateForeignKeyConvertor());
+
+convertors.push(new PgAlterForeignKeyConvertor());
+
+convertors.push(new PgDeleteForeignKeyConvertor());
+convertors.push(new MySqlDeleteForeignKeyConvertor());
+
+convertors.push(new PgCreateSchemaConvertor());
+convertors.push(new PgRenameSchemaConvertor());
+convertors.push(new PgDropSchemaConvertor());
+convertors.push(new PgAlterTableSetSchemaConvertor());
+convertors.push(new PgAlterTableSetNewSchemaConvertor());
+convertors.push(new PgAlterTableRemoveFromSchemaConvertor());
+
+convertors.push(new PgAlterTableAlterColumnDropGenerated());
+convertors.push(new PgAlterTableAlterColumnSetGenerated());
+convertors.push(new PgAlterTableAlterColumnAlterGenerated());
+
+convertors.push(new PgAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterCompositePrimaryKeyConvertor());
+
+convertors.push(new MySqlAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new MySqlAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new MySqlAlterTableAlterCompositePrimaryKeyConvertor());
+
+convertors.push(new SingleStoreAlterTableDropPk());
+convertors.push(new SingleStoreAlterTableAddPk());
+
+export function fromJson(
+	statements: JsonStatement[],
+	dialect: Dialect,
+	action?: 'push',
+) {
+	const result = statements
+		.flatMap((statement) => {
+			const filtered = convertors.filter((it) => {
+				return it.can(statement, dialect);
+			});
+
+			const convertor = filtered.length === 1 ? filtered[0] : undefined;
+
+			if (!convertor) throw new Error(`Unexpected statement: ${dialect}:${statement.type}`);
+
+			return convertor.convert(statement, action);
+		})
+		.filter((it) => it !== '');
+	return result;
+}
+
+// blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
+// test case for enum altering
+// oxlint-disable-next-line no-unused-expressions
+`
+create table users (
+	id int,
+    name character varying(128)
+);
+
+create type venum as enum('one', 'two', 'three');
+alter table users add column typed venum;
+
+insert into users(id, name, typed) values (1, 'name1', 'one');
+insert into users(id, name, typed) values (2, 'name2', 'two');
+insert into users(id, name, typed) values (3, 'name3', 'three');
+
+alter type venum rename to __venum;
+create type venum as enum ('one', 'two', 'three', 'four', 'five');
+
+ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;
+
+insert into users(id, name, typed) values (4, 'name4', 'four');
+insert into users(id, name, typed) values (5, 'name5', 'five');
+
+drop type __venum;
+`;
diff --git a/drizzle-kit/src/legacy/sqlite-v6/serializer.ts b/drizzle-kit/src/legacy/sqlite-v6/serializer.ts
new file mode 100644
index 0000000000..95d262bf72
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlite-v6/serializer.ts
@@ -0,0 +1,28 @@
+import { is } from 'orm044';
+import { SQLiteTable, SQLiteView } from 'orm044/sqlite-core';
+import type { SQLiteSchemaV6 } from '../../dialects/sqlite/snapshot';
+import type { CasingType } from '../common';
+import { generateSqliteSnapshot } from './sqliteSerializer';
+
+export type SQLiteSchema = Record<
+	string,
+	| SQLiteTable<any>
+	| SQLiteView
+	| unknown
+>;
+
+export const serializeSQLite = async (
+	schema: SQLiteSchema,
+	casing: CasingType | undefined,
+): Promise<SQLiteSchemaV6> => {
+	const tables = Object.values(schema).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
+	const views = Object.values(schema).filter((it) => is(it, SQLiteView)) as SQLiteView[];
+
+	const a = generateSqliteSnapshot(
+		tables,
+		views,
+		casing,
+	);
+
+	return ({ id: 'id', prevId: 'prev_id', ...a } as SQLiteSchemaV6);
+};
diff --git a/drizzle-kit/src/legacy/sqlite-v6/sqliteDiff.ts b/drizzle-kit/src/legacy/sqlite-v6/sqliteDiff.ts
new file mode 100644
index 0000000000..6cddb67b1c
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlite-v6/sqliteDiff.ts
@@ -0,0 +1,799 @@
+import { mapEntries, mapKeys } from '../global';
+import { applyJsonDiff, diffColumns, diffSchemasOrTables } from '../jsonDiffer';
+import type {
+	JsonAlterCompositePK,
+	JsonAlterUniqueConstraint,
+	JsonCreateCheckConstraint,
+	JsonCreateCompositePK,
+	JsonCreateSqliteViewStatement,
+	JsonCreateUniqueConstraint,
+	JsonDeleteCheckConstraint,
+	JsonDeleteCompositePK,
+	JsonDeleteUniqueConstraint,
+	JsonDropColumnStatement,
+	JsonDropViewStatement,
+	JsonReferenceStatement,
+	JsonRenameColumnStatement,
+	JsonSqliteAddColumnStatement,
+	JsonStatement,
+} from '../jsonStatements';
+import {
+	_prepareAddColumns,
+	_prepareDropColumns,
+	_prepareSqliteAddColumns,
+	prepareAddCheckConstraint,
+	prepareAddCompositePrimaryKeySqlite,
+	prepareAddUniqueConstraintPg as prepareAddUniqueConstraint,
+	prepareAlterCompositePrimaryKeySqlite,
+	prepareAlterReferencesJson,
+	prepareCreateIndexesJson,
+	prepareCreateReferencesJson,
+	prepareDeleteCheckConstraint,
+	prepareDeleteCompositePrimaryKeySqlite,
+	prepareDeleteUniqueConstraintPg as prepareDeleteUniqueConstraint,
+	prepareDropIndexesJson,
+	prepareDropReferencesJson,
+	prepareDropTableJson,
+	prepareDropViewJson,
+	prepareRenameColumns,
+	prepareRenameTableJson,
+	prepareSqliteAlterColumns,
+	prepareSQLiteCreateTable,
+	prepareSqliteCreateViewJson,
+	prepareSQLiteRecreateTable,
+} from '../jsonStatements';
+import { copy } from '../utils';
+
+import { never, object } from 'zod';
+import type {
+	Column,
+	ColumnsResolverInput,
+	ColumnsResolverOutput,
+	Named,
+	ResolverInput,
+	ResolverOutputWithMoved,
+	Table,
+} from '../snapshotsDiffer';
+import {
+	alteredTableScheme,
+	alteredViewCommon,
+	columnChangeFor,
+	columnsResolver,
+	nameChangeFor,
+	sqliteViewsResolver,
+	tablesResolver,
+} from '../snapshotsDiffer';
+import { fromJson } from '../sqlgenerator';
+import {
+	drySQLite,
+	type SQLiteSchema,
+	type SQLiteSchemaSquashed,
+	SQLiteSquasher,
+	squashSqliteScheme,
+	type View as SqliteView,
+} from './sqliteSchema';
+
+export const diffResultSchemeSQLite = object({
+	alteredTablesWithColumns: alteredTableScheme.array(),
+	alteredEnums: never().array(),
+	alteredViews: alteredViewCommon.array(),
+});
+
+export const sqliteCombineStatements = (
+	statements: JsonStatement[],
+	json2: SQLiteSchemaSquashed,
+	action?: 'push',
+) => {
+	// const tablesContext: Record<string, string[]> = {};
+	const newStatements: Record<string, JsonStatement[]> = {};
+	for (const statement of statements) {
+		if (
+			statement.type === 'alter_table_alter_column_set_type'
+			|| statement.type === 'alter_table_alter_column_set_default'
+			|| statement.type === 'alter_table_alter_column_drop_default'
+			|| statement.type === 'alter_table_alter_column_set_notnull'
+			|| statement.type === 'alter_table_alter_column_drop_notnull'
+			|| statement.type === 'alter_table_alter_column_drop_autoincrement'
+			|| statement.type === 'alter_table_alter_column_set_autoincrement'
+			|| statement.type === 'alter_table_alter_column_drop_pk'
+			|| statement.type === 'alter_table_alter_column_set_pk'
+			|| statement.type === 'delete_reference'
+			|| statement.type === 'alter_reference'
+			|| statement.type === 'create_composite_pk'
+			|| statement.type === 'alter_composite_pk'
+			|| statement.type === 'delete_composite_pk'
+			|| statement.type === 'create_unique_constraint'
+			|| statement.type === 'delete_unique_constraint'
+			|| statement.type === 'create_check_constraint'
+			|| statement.type === 'delete_check_constraint'
+		) {
+			const tableName = statement.tableName;
+
+			const statementsForTable = newStatements[tableName];
+
+			if (!statementsForTable) {
+				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+				continue;
+			}
+
+			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
+				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
+				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+
+				if (wasRename) {
+					newStatements[tableName].push(...preparedStatements);
+				} else {
+					newStatements[tableName] = preparedStatements;
+				}
+
+				continue;
+			}
+
+			continue;
+		}
+
+		if (statement.type === 'sqlite_alter_table_add_column' && statement.column.primaryKey) {
+			const tableName = statement.tableName;
+
+			const statementsForTable = newStatements[tableName];
+
+			if (!statementsForTable) {
+				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+				continue;
+			}
+
+			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
+				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
+				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+
+				if (wasRename) {
+					newStatements[tableName].push(...preparedStatements);
+				} else {
+					newStatements[tableName] = preparedStatements;
+				}
+
+				continue;
+			}
+
+			continue;
+		}
+
+		if (statement.type === 'create_reference') {
+			const tableName = statement.tableName;
+
+			const data = action === 'push'
+				? SQLiteSquasher.unsquashPushFK(statement.data)
+				: SQLiteSquasher.unsquashFK(statement.data);
+			const statementsForTable = newStatements[tableName];
+
+			if (!statementsForTable) {
+				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+				continue;
+			}
+
+			// if add column with reference -> skip create_reference statement
+			if (
+				data.columnsFrom.length === 1
+				&& statementsForTable.some((st) =>
+					st.type === 'sqlite_alter_table_add_column' && st.column.name === data.columnsFrom[0]
+				)
+			) {
+				continue;
+			}
+
+			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
+				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
+				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
+
+				if (wasRename) {
+					newStatements[tableName].push(...preparedStatements);
+				} else {
+					newStatements[tableName] = preparedStatements;
+				}
+
+				continue;
+			}
+
+			continue;
+		}
+
+		const tableName = statement.type === 'rename_table'
+			? statement.tableNameTo
+			: (statement as { tableName: string }).tableName;
+
+		const statementsForTable = newStatements[tableName];
+
+		if (!statementsForTable) {
+			newStatements[tableName] = [statement];
+			continue;
+		}
+
+		if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
+			newStatements[tableName].push(statement);
+		}
+	}
+
+	const combinedStatements = Object.values(newStatements).flat();
+
+	const renamedTables = combinedStatements.filter((it) => it.type === 'rename_table');
+	const renamedColumns = combinedStatements.filter((it) => it.type === 'alter_table_rename_column');
+
+	const rest = combinedStatements.filter((it) => it.type !== 'rename_table' && it.type !== 'alter_table_rename_column');
+
+	return [...renamedTables, ...renamedColumns, ...rest];
+};
+
+export const diff = async (opts: {
+	left?: SQLiteSchema;
+	right: SQLiteSchema;
+	mode?: 'push';
+}) => {
+	const left = opts.left ?? drySQLite;
+	const json1 = squashSqliteScheme(left);
+	const json2 = squashSqliteScheme(opts.right);
+	return _diff(
+		json1,
+		json2,
+		tablesResolver,
+		columnsResolver,
+		sqliteViewsResolver,
+		left,
+		opts.right,
+		opts.mode,
+	);
+};
+
+export const _diff = async (
+	json1: SQLiteSchemaSquashed,
+	json2: SQLiteSchemaSquashed,
+	tablesResolver: (
+		input: ResolverInput<Table>,
+	) => Promise<ResolverOutputWithMoved<Table>>,
+	columnsResolver: (
+		input: ColumnsResolverInput<Column>,
+	) => Promise<ColumnsResolverOutput<Column>>,
+	viewsResolver: (
+		input: ResolverInput<SqliteView & { schema: '' }>,
+	) => Promise<ResolverOutputWithMoved<SqliteView>>,
+	prevFull: SQLiteSchema,
+	curFull: SQLiteSchema,
+	action?: 'push' | undefined,
+): Promise<{
+	statements: JsonStatement[];
+	sqlStatements: string[];
+	_meta:
+		| {
+			schemas: {};
+			tables: {};
+			columns: {};
+		}
+		| undefined;
+}> => {
+	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
+
+	const {
+		created: createdTables,
+		deleted: deletedTables,
+		renamed: renamedTables,
+	} = await tablesResolver({
+		created: tablesDiff.added,
+		deleted: tablesDiff.deleted,
+	});
+
+	const tablesPatchedSnap1 = copy(json1);
+	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
+		const { name } = nameChangeFor(it, renamedTables);
+		it.name = name;
+		return [name, it];
+	});
+
+	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
+
+	const columnRenames = [] as {
+		table: string;
+		renames: { from: Column; to: Column }[];
+	}[];
+
+	const columnCreates = [] as {
+		table: string;
+		columns: Column[];
+	}[];
+
+	const columnDeletes = [] as {
+		table: string;
+		columns: Column[];
+	}[];
+
+	for (let entry of Object.values(res)) {
+		const { renamed, created, deleted } = await columnsResolver({
+			tableName: entry.name,
+			schema: entry.schema,
+			deleted: entry.columns.deleted,
+			created: entry.columns.added,
+		});
+
+		if (created.length > 0) {
+			columnCreates.push({
+				table: entry.name,
+				columns: created,
+			});
+		}
+
+		if (deleted.length > 0) {
+			columnDeletes.push({
+				table: entry.name,
+				columns: deleted,
+			});
+		}
+
+		if (renamed.length > 0) {
+			columnRenames.push({
+				table: entry.name,
+				renames: renamed,
+			});
+		}
+	}
+
+	const columnRenamesDict = columnRenames.reduce(
+		(acc, it) => {
+			acc[it.table] = it.renames;
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				from: Named;
+				to: Named;
+			}[]
+		>,
+	);
+
+	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
+	columnsPatchedSnap1.tables = mapEntries(
+		columnsPatchedSnap1.tables,
+		(tableKey, tableValue) => {
+			const patchedColumns = mapKeys(
+				tableValue.columns,
+				(columnKey, column) => {
+					const rens = columnRenamesDict[tableValue.name] || [];
+					const newName = columnChangeFor(columnKey, rens);
+					column.name = newName;
+					return newName;
+				},
+			);
+
+			tableValue.columns = patchedColumns;
+			return [tableKey, tableValue];
+		},
+	);
+
+	const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
+
+	const {
+		created: createdViews,
+		deleted: deletedViews,
+		renamed: renamedViews, // renamed or moved
+	} = await viewsResolver({
+		created: viewsDiff.added,
+		deleted: viewsDiff.deleted,
+	});
+
+	const renamesViewDic: Record<string, { to: string; from: string }> = {};
+	renamedViews.forEach((it) => {
+		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
+	});
+
+	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
+	viewsPatchedSnap1.views = mapEntries(
+		viewsPatchedSnap1.views,
+		(viewKey, viewValue) => {
+			const rename = renamesViewDic[viewValue.name];
+
+			if (rename) {
+				viewValue.name = rename.to;
+			}
+
+			return [viewKey, viewValue];
+		},
+	);
+
+	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
+
+	const typedResult = diffResultSchemeSQLite.parse(diffResult);
+
+	// Map array of objects to map
+	const tablesMap: {
+		[key: string]: (typeof typedResult.alteredTablesWithColumns)[number];
+	} = {};
+
+	typedResult.alteredTablesWithColumns.forEach((obj) => {
+		tablesMap[obj.name] = obj;
+	});
+
+	const jsonCreateTables = createdTables.map((it) => {
+		return prepareSQLiteCreateTable(it, action);
+	});
+
+	const jsonCreateIndexesForCreatedTables = createdTables
+		.map((it) => {
+			return prepareCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.indexes,
+				curFull.internal,
+			);
+		})
+		.flat();
+
+	const jsonDropTables = deletedTables.map((it) => {
+		return prepareDropTableJson(it);
+	});
+
+	const jsonRenameTables = renamedTables.map((it) => {
+		return prepareRenameTableJson(it.from, it.to);
+	});
+
+	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
+		.map((it) => prepareRenameColumns(it.table, '', it.renames))
+		.flat();
+
+	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
+		.map((it) => _prepareDropColumns(it.table, '', it.columns))
+		.flat();
+
+	const jsonAddColumnsStatemets: JsonSqliteAddColumnStatement[] = columnCreates
+		.map((it) => {
+			return _prepareSqliteAddColumns(
+				it.table,
+				it.columns,
+				tablesMap[it.table] && tablesMap[it.table].addedForeignKeys
+					? Object.values(tablesMap[it.table].addedForeignKeys)
+					: [],
+			);
+		})
+		.flat();
+
+	const allAltered = typedResult.alteredTablesWithColumns;
+
+	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
+	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
+	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
+
+	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+
+	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
+	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
+
+	allAltered.forEach((it) => {
+		// This part is needed to make sure that same columns in a table are not triggered for change
+		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
+		// We double-check that pk with same set of columns are both in added and deleted diffs
+		let addedColumns: string[] = [];
+		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
+			const addedPkColumns = it.addedCompositePKs[addedPkName];
+			addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
+		}
+
+		let deletedColumns: string[] = [];
+		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
+			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
+			deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
+		}
+
+		// Don't need to sort, but need to add tests for it
+		// addedColumns.sort();
+		// deletedColumns.sort();
+
+		const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
+
+		let addedCompositePKs: JsonCreateCompositePK[] = [];
+		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
+		let alteredCompositePKs: JsonAlterCompositePK[] = [];
+		if (doPerformDeleteAndCreate) {
+			addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
+				it.name,
+				it.addedCompositePKs,
+			);
+			deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
+				it.name,
+				it.deletedCompositePKs,
+			);
+		}
+		alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
+			it.name,
+			it.alteredCompositePKs,
+		);
+
+		// add logic for unique constraints
+		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
+		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
+		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
+
+		addedUniqueConstraints = prepareAddUniqueConstraint(
+			it.name,
+			it.schema,
+			it.addedUniqueConstraints,
+		);
+		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
+			it.name,
+			it.schema,
+			it.deletedUniqueConstraints,
+		);
+		if (it.alteredUniqueConstraints) {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+			for (const k of Object.keys(it.alteredUniqueConstraints)) {
+				added[k] = it.alteredUniqueConstraints[k].__new;
+				deleted[k] = it.alteredUniqueConstraints[k].__old;
+			}
+			addedUniqueConstraints.push(
+				...prepareAddUniqueConstraint(it.name, it.schema, added),
+			);
+			deletedUniqueConstraints.push(
+				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
+			);
+		}
+
+		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
+		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
+
+		addedUniqueConstraints = prepareAddUniqueConstraint(
+			it.name,
+			it.schema,
+			it.addedUniqueConstraints,
+		);
+		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
+			it.name,
+			it.schema,
+			it.deletedUniqueConstraints,
+		);
+		if (it.alteredUniqueConstraints) {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+			for (const k of Object.keys(it.alteredUniqueConstraints)) {
+				added[k] = it.alteredUniqueConstraints[k].__new;
+				deleted[k] = it.alteredUniqueConstraints[k].__old;
+			}
+			addedUniqueConstraints.push(
+				...prepareAddUniqueConstraint(it.name, it.schema, added),
+			);
+			deletedUniqueConstraints.push(
+				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
+			);
+		}
+
+		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
+		deletedCheckConstraints = prepareDeleteCheckConstraint(
+			it.name,
+			it.schema,
+			it.deletedCheckConstraints,
+		);
+
+		// skip for push
+		if (it.alteredCheckConstraints && action !== 'push') {
+			const added: Record<string, string> = {};
+			const deleted: Record<string, string> = {};
+
+			for (const k of Object.keys(it.alteredCheckConstraints)) {
+				added[k] = it.alteredCheckConstraints[k].__new;
+				deleted[k] = it.alteredCheckConstraints[k].__old;
+			}
+			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
+			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
+		}
+
+		jsonAddedCompositePKs.push(...addedCompositePKs);
+		jsonDeletedCompositePKs.push(...deletedCompositePKs);
+		jsonAlteredCompositePKs.push(...alteredCompositePKs);
+
+		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
+		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
+		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
+
+		jsonCreatedCheckConstraints.push(...createdCheckConstraints);
+		jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
+	});
+
+	// const rColumns = jsonRenameColumnsStatements.map((it) => {
+	// 	const tableName = it.tableName;
+	// 	const schema = it.schema;
+	// 	return {
+	// 		from: { schema, table: tableName, column: it.oldColumnName },
+	// 		to: { schema, table: tableName, column: it.newColumnName },
+	// 	};
+	// });
+
+	const jsonTableAlternations = allAltered
+		.map((it) => {
+			return prepareSqliteAlterColumns(it.name, it.schema, it.altered, json2);
+		})
+		.flat();
+
+	const jsonCreateIndexesForAllAlteredTables = allAltered
+		.map((it) => {
+			return prepareCreateIndexesJson(
+				it.name,
+				it.schema,
+				it.addedIndexes || {},
+				curFull.internal,
+			);
+		})
+		.flat();
+
+	const jsonDropIndexesForAllAlteredTables = allAltered
+		.map((it) => {
+			return prepareDropIndexesJson(
+				it.name,
+				it.schema,
+				it.deletedIndexes || {},
+			);
+		})
+		.flat();
+
+	allAltered.forEach((it) => {
+		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__old;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
+			(current, item: string) => {
+				current[item] = it.alteredIndexes[item].__new;
+				return current;
+			},
+			{} as Record<string, string>,
+		);
+
+		jsonCreateIndexesForAllAlteredTables.push(
+			...prepareCreateIndexesJson(
+				it.name,
+				it.schema,
+				createdIndexes || {},
+				curFull.internal,
+			),
+		);
+		jsonDropIndexesForAllAlteredTables.push(
+			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
+		);
+	});
+
+	const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = allAltered
+		.map((it) => {
+			const forAdded = prepareCreateReferencesJson(
+				it.name,
+				it.schema,
+				it.addedForeignKeys,
+			);
+
+			const forAltered = prepareDropReferencesJson(
+				it.name,
+				it.schema,
+				it.deletedForeignKeys,
+			);
+
+			const alteredFKs = prepareAlterReferencesJson(
+				it.name,
+				it.schema,
+				it.alteredForeignKeys,
+			);
+
+			return [...forAdded, ...forAltered, ...alteredFKs];
+		})
+		.flat();
+
+	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
+		(t) => t.type === 'create_reference',
+	);
+	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
+		(t) => t.type === 'delete_reference',
+	);
+
+	const createViews: JsonCreateSqliteViewStatement[] = [];
+	const dropViews: JsonDropViewStatement[] = [];
+
+	createViews.push(
+		...createdViews.filter((it) => !it.isExisting).map((it) => {
+			return prepareSqliteCreateViewJson(
+				it.name,
+				it.definition!,
+			);
+		}),
+	);
+
+	dropViews.push(
+		...deletedViews.filter((it) => !it.isExisting).map((it) => {
+			return prepareDropViewJson(it.name);
+		}),
+	);
+
+	dropViews.push(
+		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
+			return prepareDropViewJson(it.from.name);
+		}),
+	);
+	createViews.push(
+		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
+			return prepareSqliteCreateViewJson(it.to.name, it.to.definition!);
+		}),
+	);
+
+	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
+
+	for (const alteredView of alteredViews) {
+		const { definition } = json2.views[alteredView.name];
+
+		if (alteredView.alteredExisting || (alteredView.alteredDefinition && action !== 'push')) {
+			dropViews.push(prepareDropViewJson(alteredView.name));
+
+			createViews.push(
+				prepareSqliteCreateViewJson(
+					alteredView.name,
+					definition!,
+				),
+			);
+		}
+	}
+
+	const jsonStatements: JsonStatement[] = [];
+	jsonStatements.push(...jsonCreateTables);
+
+	jsonStatements.push(...jsonDropTables);
+	jsonStatements.push(...jsonRenameTables);
+	jsonStatements.push(...jsonRenameColumnsStatements);
+
+	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
+	jsonStatements.push(...jsonDeletedCheckConstraints);
+
+	// Will need to drop indexes before changing any columns in table
+	// Then should go column alternations and then index creation
+	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
+
+	jsonStatements.push(...jsonDeletedCompositePKs);
+	jsonStatements.push(...jsonTableAlternations);
+	jsonStatements.push(...jsonAddedCompositePKs);
+	jsonStatements.push(...jsonAddColumnsStatemets);
+
+	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
+	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
+
+	jsonStatements.push(...jsonCreatedCheckConstraints);
+
+	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
+
+	jsonStatements.push(...jsonDropColumnsStatemets);
+
+	// jsonStatements.push(...jsonDeletedCompositePKs);
+	// jsonStatements.push(...jsonAddedCompositePKs);
+	jsonStatements.push(...jsonAlteredCompositePKs);
+
+	jsonStatements.push(...jsonAlteredUniqueConstraints);
+
+	jsonStatements.push(...dropViews);
+	jsonStatements.push(...createViews);
+
+	const combinedJsonStatements = sqliteCombineStatements(jsonStatements, json2, action);
+	const sqlStatements = fromJson(combinedJsonStatements, 'sqlite');
+
+	const uniqueSqlStatements: string[] = [];
+	sqlStatements.forEach((ss) => {
+		if (!uniqueSqlStatements.includes(ss)) {
+			uniqueSqlStatements.push(ss);
+		}
+	});
+
+	// const rTables = renamedTables.map((it) => {
+	// 	return { from: it.from, to: it.to };
+	// });
+
+	// const _meta = prepareMigrationMeta([], rTables, rColumns);
+
+	return {
+		statements: combinedJsonStatements,
+		sqlStatements: uniqueSqlStatements,
+		_meta: { columns: [], schemas: [], tables: [] },
+	};
+};
diff --git a/drizzle-kit/src/legacy/sqlite-v6/sqliteSchema.ts b/drizzle-kit/src/legacy/sqlite-v6/sqliteSchema.ts
new file mode 100644
index 0000000000..6d349cbfe0
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlite-v6/sqliteSchema.ts
@@ -0,0 +1,353 @@
+import type { TypeOf } from 'zod';
+import { any, boolean, enum as enumType, literal, object, record, string, union } from 'zod';
+import { customMapEntries, mapValues, originUUID } from '../global';
+
+// ------- V3 --------
+const index = object({
+	name: string(),
+	columns: string().array(),
+	where: string().optional(),
+	isUnique: boolean(),
+}).strict();
+
+const fk = object({
+	name: string(),
+	tableFrom: string(),
+	columnsFrom: string().array(),
+	tableTo: string(),
+	columnsTo: string().array(),
+	onUpdate: string().optional(),
+	onDelete: string().optional(),
+}).strict();
+
+const compositePK = object({
+	columns: string().array(),
+	name: string().optional(),
+}).strict();
+
+const column = object({
+	name: string(),
+	type: string(),
+	primaryKey: boolean(),
+	notNull: boolean(),
+	autoincrement: boolean().optional(),
+	default: any().optional(),
+	generated: object({
+		type: enumType(['stored', 'virtual']),
+		as: string(),
+	}).optional(),
+}).strict();
+
+const tableV3 = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+}).strict();
+
+const uniqueConstraint = object({
+	name: string(),
+	columns: string().array(),
+}).strict();
+
+const checkConstraint = object({
+	name: string(),
+	value: string(),
+}).strict();
+
+const table = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), index),
+	foreignKeys: record(string(), fk),
+	compositePrimaryKeys: record(string(), compositePK),
+	uniqueConstraints: record(string(), uniqueConstraint).default({}),
+	checkConstraints: record(string(), checkConstraint).default({}),
+}).strict();
+
+export const view = object({
+	name: string(),
+	columns: record(string(), column),
+	definition: string().optional(),
+	isExisting: boolean(),
+}).strict();
+
+// use main dialect
+const dialect = enumType(['sqlite']);
+
+const schemaHash = object({
+	id: string(),
+	prevId: string(),
+}).strict();
+
+export const schemaInternalV3 = object({
+	version: literal('3'),
+	dialect: dialect,
+	tables: record(string(), tableV3),
+	enums: object({}),
+}).strict();
+
+export const schemaInternalV4 = object({
+	version: literal('4'),
+	dialect: dialect,
+	tables: record(string(), table),
+	views: record(string(), view).default({}),
+	enums: object({}),
+}).strict();
+
+export const schemaInternalV5 = object({
+	version: literal('5'),
+	dialect: dialect,
+	tables: record(string(), table),
+	enums: object({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+}).strict();
+
+export const kitInternals = object({
+	indexes: record(
+		string(),
+		object({
+			columns: record(
+				string(),
+				object({ isExpression: boolean().optional() }).optional(),
+			),
+		}).optional(),
+	).optional(),
+}).optional();
+
+const latestVersion = literal('6');
+export const schemaInternal = object({
+	version: latestVersion,
+	dialect: dialect,
+	tables: record(string(), table),
+	views: record(string(), view).default({}),
+	enums: object({}),
+	_meta: object({
+		tables: record(string(), string()),
+		columns: record(string(), string()),
+	}),
+	internal: kitInternals,
+}).strict();
+
+export const schemaV3 = schemaInternalV3.merge(schemaHash).strict();
+export const schemaV4 = schemaInternalV4.merge(schemaHash).strict();
+export const schemaV5 = schemaInternalV5.merge(schemaHash).strict();
+export const schema = schemaInternal.merge(schemaHash).strict();
+
+const tableSquashed = object({
+	name: string(),
+	columns: record(string(), column),
+	indexes: record(string(), string()),
+	foreignKeys: record(string(), string()),
+	compositePrimaryKeys: record(string(), string()),
+	uniqueConstraints: record(string(), string()).default({}),
+	checkConstraints: record(string(), string()).default({}),
+}).strict();
+
+export const schemaSquashed = object({
+	version: latestVersion,
+	dialect: dialect,
+	tables: record(string(), tableSquashed),
+	views: record(string(), view),
+	enums: any(),
+}).strict();
+
+export type Dialect = TypeOf<typeof dialect>;
+export type Column = TypeOf<typeof column>;
+export type Table = TypeOf<typeof table>;
+export type SQLiteSchema = TypeOf<typeof schema>;
+export type SQLiteSchemaV3 = TypeOf<typeof schemaV3>;
+export type SQLiteSchemaV4 = TypeOf<typeof schemaV4>;
+export type SQLiteSchemaInternal = TypeOf<typeof schemaInternal>;
+export type SQLiteSchemaSquashed = TypeOf<typeof schemaSquashed>;
+export type SQLiteKitInternals = TypeOf<typeof kitInternals>;
+export type Index = TypeOf<typeof index>;
+export type ForeignKey = TypeOf<typeof fk>;
+export type PrimaryKey = TypeOf<typeof compositePK>;
+export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
+export type CheckConstraint = TypeOf<typeof checkConstraint>;
+export type View = TypeOf<typeof view>;
+
+export const SQLiteSquasher = {
+	squashIdx: (idx: Index) => {
+		index.parse(idx);
+		return `${idx.name};${idx.columns.join(',')};${idx.isUnique};${idx.where ?? ''}`;
+	},
+	unsquashIdx: (input: string): Index => {
+		const [name, columnsString, isUnique, where] = input.split(';');
+
+		const result: Index = index.parse({
+			name,
+			columns: columnsString.split(','),
+			isUnique: isUnique === 'true',
+			where: where ?? undefined,
+		});
+		return result;
+	},
+	squashUnique: (unq: UniqueConstraint) => {
+		return `${unq.name};${unq.columns.join(',')}`;
+	},
+	unsquashUnique: (unq: string): UniqueConstraint => {
+		const [name, columns] = unq.split(';');
+		return { name, columns: columns.split(',') };
+	},
+	squashFK: (fk: ForeignKey) => {
+		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
+			fk.onUpdate ?? ''
+		};${fk.onDelete ?? ''}`;
+	},
+	unsquashFK: (input: string): ForeignKey => {
+		const [
+			name,
+			tableFrom,
+			columnsFromStr,
+			tableTo,
+			columnsToStr,
+			onUpdate,
+			onDelete,
+		] = input.split(';');
+
+		const result: ForeignKey = fk.parse({
+			name,
+			tableFrom,
+			columnsFrom: columnsFromStr.split(','),
+			tableTo,
+			columnsTo: columnsToStr.split(','),
+			onUpdate,
+			onDelete,
+		});
+		return result;
+	},
+	squashPushFK: (fk: ForeignKey) => {
+		return `${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${fk.onUpdate ?? ''};${
+			fk.onDelete ?? ''
+		}`;
+	},
+	unsquashPushFK: (input: string): ForeignKey => {
+		const [
+			tableFrom,
+			columnsFromStr,
+			tableTo,
+			columnsToStr,
+			onUpdate,
+			onDelete,
+		] = input.split(';');
+
+		const result: ForeignKey = fk.parse({
+			name: '',
+			tableFrom,
+			columnsFrom: columnsFromStr.split(','),
+			tableTo,
+			columnsTo: columnsToStr.split(','),
+			onUpdate,
+			onDelete,
+		});
+		return result;
+	},
+	squashPK: (pk: PrimaryKey) => {
+		return pk.columns.join(',');
+	},
+	unsquashPK: (pk: string) => {
+		return pk.split(',');
+	},
+	squashCheck: (check: CheckConstraint) => {
+		return `${check.name};${check.value}`;
+	},
+	unsquashCheck: (input: string): CheckConstraint => {
+		const [
+			name,
+			value,
+		] = input.split(';');
+
+		return { name, value };
+	},
+};
+
+export const squashSqliteScheme = (
+	json: SQLiteSchema | SQLiteSchemaV4,
+	action?: 'push' | undefined,
+): SQLiteSchemaSquashed => {
+	const mappedTables = Object.fromEntries(
+		Object.entries(json.tables).map((it) => {
+			const squashedIndexes = mapValues(it[1].indexes, (index: Index) => {
+				return SQLiteSquasher.squashIdx(index);
+			});
+
+			const squashedFKs = customMapEntries<string, ForeignKey>(
+				it[1].foreignKeys,
+				(key, value) => {
+					return action === 'push'
+						? [
+							SQLiteSquasher.squashPushFK(value),
+							SQLiteSquasher.squashPushFK(value),
+						]
+						: [key, SQLiteSquasher.squashFK(value)];
+				},
+			);
+
+			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+				return SQLiteSquasher.squashPK(pk);
+			});
+
+			const squashedUniqueConstraints = mapValues(
+				it[1].uniqueConstraints,
+				(unq) => {
+					return SQLiteSquasher.squashUnique(unq);
+				},
+			);
+
+			const squashedCheckConstraints = mapValues(
+				it[1].checkConstraints,
+				(check) => {
+					return SQLiteSquasher.squashCheck(check);
+				},
+			);
+
+			return [
+				it[0],
+				{
+					name: it[1].name,
+					columns: it[1].columns,
+					indexes: squashedIndexes,
+					foreignKeys: squashedFKs,
+					compositePrimaryKeys: squashedPKs,
+					uniqueConstraints: squashedUniqueConstraints,
+					checkConstraints: squashedCheckConstraints,
+				},
+			];
+		}),
+	);
+
+	return {
+		version: '6',
+		dialect: json.dialect,
+		tables: mappedTables,
+		views: json.views,
+		enums: json.enums,
+	};
+};
+
+export const drySQLite = schema.parse({
+	version: '6',
+	dialect: 'sqlite',
+	id: originUUID,
+	prevId: '',
+	tables: {},
+	views: {},
+	enums: {},
+	_meta: {
+		tables: {},
+		columns: {},
+	},
+});
+
+export const sqliteSchemaV3 = schemaV3;
+export const sqliteSchemaV4 = schemaV4;
+export const sqliteSchemaV5 = schemaV5;
+export const sqliteSchema = schema;
+export const SQLiteSchemaSquashed = schemaSquashed;
+
+export const backwardCompatibleSqliteSchema = union([sqliteSchemaV5, schema]);
diff --git a/drizzle-kit/src/legacy/sqlite-v6/sqliteSerializer.ts b/drizzle-kit/src/legacy/sqlite-v6/sqliteSerializer.ts
new file mode 100644
index 0000000000..224226d8f1
--- /dev/null
+++ b/drizzle-kit/src/legacy/sqlite-v6/sqliteSerializer.ts
@@ -0,0 +1,953 @@
+import chalk from 'chalk';
+import { getTableName, is, SQL } from 'orm044';
+import type { AnySQLiteTable, SQLiteView } from 'orm044/sqlite-core';
+import {
+	getTableConfig,
+	getViewConfig,
+	SQLiteBaseInteger,
+	SQLiteColumn,
+	SQLiteSyncDialect,
+	uniqueKeyName,
+} from 'orm044/sqlite-core';
+import type { CasingType } from '../common';
+import { withStyle } from '../outputs';
+import { escapeSingleQuotes } from '../utils';
+import { getColumnCasing, sqlToStr } from '../utils';
+import type {
+	CheckConstraint,
+	Column,
+	ForeignKey,
+	Index,
+	PrimaryKey,
+	SQLiteKitInternals,
+	SQLiteSchemaInternal,
+	Table,
+	UniqueConstraint,
+	View,
+} from './sqliteSchema';
+
+export const generateSqliteSnapshot = (
+	tables: AnySQLiteTable[],
+	views: SQLiteView[],
+	casing: CasingType | undefined,
+): SQLiteSchemaInternal => {
+	const dialect = new SQLiteSyncDialect({ casing });
+	const result: Record<string, Table> = {};
+	const resultViews: Record<string, View> = {};
+
+	const internal: SQLiteKitInternals = { indexes: {} };
+	for (const table of tables) {
+		// const tableName = getTableName(table);
+		const columnsObject: Record<string, Column> = {};
+		const indexesObject: Record<string, Index> = {};
+		const foreignKeysObject: Record<string, ForeignKey> = {};
+		const primaryKeysObject: Record<string, PrimaryKey> = {};
+		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
+		const checkConstraintObject: Record<string, CheckConstraint> = {};
+
+		const checksInTable: Record<string, string[]> = {};
+
+		const {
+			name: tableName,
+			columns,
+			indexes,
+			checks,
+			foreignKeys: tableForeignKeys,
+			primaryKeys,
+			uniqueConstraints,
+		} = getTableConfig(table);
+
+		columns.forEach((column) => {
+			const name = getColumnCasing(column, casing);
+			const notNull: boolean = column.notNull;
+			const primaryKey: boolean = column.primary;
+			const generated = column.generated;
+
+			const columnToSet: Column = {
+				name,
+				type: column.getSQLType(),
+				primaryKey,
+				notNull,
+				autoincrement: is(column, SQLiteBaseInteger)
+					? column.autoIncrement
+					: false,
+				generated: generated
+					? {
+						as: is(generated.as, SQL)
+							? `(${dialect.sqlToQuery(generated.as as SQL, 'indexes').sql})`
+							: typeof generated.as === 'function'
+							? `(${dialect.sqlToQuery(generated.as() as SQL, 'indexes').sql})`
+							: `(${generated.as as any})`,
+						type: generated.mode ?? 'virtual',
+					}
+					: undefined,
+			};
+
+			if (column.default !== undefined) {
+				if (is(column.default, SQL)) {
+					columnToSet.default = sqlToStr(column.default, casing);
+				} else {
+					columnToSet.default = typeof column.default === 'string'
+						? `'${escapeSingleQuotes(column.default)}'`
+						: typeof column.default === 'object'
+								|| Array.isArray(column.default)
+						? `'${JSON.stringify(column.default)}'`
+						: column.default;
+				}
+			}
+			columnsObject[name] = columnToSet;
+
+			if (column.isUnique) {
+				const existingUnique = indexesObject[column.uniqueName!];
+				if (typeof existingUnique !== 'undefined') {
+					console.log(
+						`\n${
+							withStyle.errorWarning(`We've found duplicated unique constraint names in ${
+								chalk.underline.blue(
+									tableName,
+								)
+							} table. 
+          The unique constraint ${
+								chalk.underline.blue(
+									column.uniqueName,
+								)
+							} on the ${
+								chalk.underline.blue(
+									name,
+								)
+							} column is confilcting with a unique constraint name already defined for ${
+								chalk.underline.blue(
+									existingUnique.columns.join(','),
+								)
+							} columns\n`)
+						}`,
+					);
+					process.exit(1);
+				}
+				indexesObject[column.uniqueName!] = {
+					name: column.uniqueName!,
+					columns: [columnToSet.name],
+					isUnique: true,
+				};
+			}
+		});
+
+		const foreignKeys: ForeignKey[] = tableForeignKeys.map((fk) => {
+			const tableFrom = tableName;
+			const onDelete = fk.onDelete ?? 'no action';
+			const onUpdate = fk.onUpdate ?? 'no action';
+			const reference = fk.reference();
+
+			const referenceFT = reference.foreignTable;
+
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			const tableTo = getTableName(referenceFT);
+
+			const originalColumnsFrom = reference.columns.map((it) => it.name);
+			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
+			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
+			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
+
+			let name = fk.getName();
+			if (casing !== undefined) {
+				for (let i = 0; i < originalColumnsFrom.length; i++) {
+					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
+				}
+				for (let i = 0; i < originalColumnsTo.length; i++) {
+					name = name.replace(originalColumnsTo[i], columnsTo[i]);
+				}
+			}
+
+			return {
+				name,
+				tableFrom,
+				tableTo,
+				columnsFrom,
+				columnsTo,
+				onDelete,
+				onUpdate,
+			} as ForeignKey;
+		});
+
+		foreignKeys.forEach((it) => {
+			foreignKeysObject[it.name] = it;
+		});
+
+		indexes.forEach((value) => {
+			const columns = value.config.columns;
+			const name = value.config.name;
+
+			let indexColumns = columns.map((it) => {
+				if (is(it, SQL)) {
+					const sql = dialect.sqlToQuery(it, 'indexes').sql;
+					if (typeof internal!.indexes![name] === 'undefined') {
+						internal!.indexes![name] = {
+							columns: {
+								[sql]: {
+									isExpression: true,
+								},
+							},
+						};
+					} else {
+						if (typeof internal!.indexes![name]?.columns[sql] === 'undefined') {
+							internal!.indexes![name]!.columns[sql] = {
+								isExpression: true,
+							};
+						} else {
+							internal!.indexes![name]!.columns[sql]!.isExpression = true;
+						}
+					}
+					return sql;
+				} else {
+					return getColumnCasing(it, casing);
+				}
+			});
+
+			// oxlint-disable-next-line no-useless-undefined
+			let where: string | undefined = undefined;
+			if (value.config.where !== undefined) {
+				if (is(value.config.where, SQL)) {
+					where = dialect.sqlToQuery(value.config.where).sql;
+				}
+			}
+
+			indexesObject[name] = {
+				name,
+				columns: indexColumns,
+				isUnique: value.config.unique ?? false,
+				where,
+			};
+		});
+
+		uniqueConstraints?.map((unq) => {
+			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
+
+			const name = unq.name ?? uniqueKeyName(table, columnNames);
+
+			const existingUnique = indexesObject[name];
+			if (typeof existingUnique !== 'undefined') {
+				console.log(
+					`\n${
+						withStyle.errorWarning(
+							`We've found duplicated unique constraint names in ${
+								chalk.underline.blue(
+									tableName,
+								)
+							} table. \nThe unique constraint ${
+								chalk.underline.blue(
+									name,
+								)
+							} on the ${
+								chalk.underline.blue(
+									columnNames.join(','),
+								)
+							} columns is confilcting with a unique constraint name already defined for ${
+								chalk.underline.blue(
+									existingUnique.columns.join(','),
+								)
+							} columns\n`,
+						)
+					}`,
+				);
+				process.exit(1);
+			}
+
+			indexesObject[name] = {
+				name: unq.name!,
+				columns: columnNames,
+				isUnique: true,
+			};
+		});
+
+		primaryKeys.forEach((it) => {
+			if (it.columns.length > 1) {
+				const originalColumnNames = it.columns.map((c) => c.name);
+				const columnNames = it.columns.map((c) => getColumnCasing(c, casing));
+
+				let name = it.getName();
+				if (casing !== undefined) {
+					for (let i = 0; i < originalColumnNames.length; i++) {
+						name = name.replace(originalColumnNames[i], columnNames[i]);
+					}
+				}
+
+				primaryKeysObject[name] = {
+					columns: columnNames,
+					name,
+				};
+			} else {
+				columnsObject[getColumnCasing(it.columns[0], casing)].primaryKey = true;
+			}
+		});
+
+		checks.forEach((check) => {
+			const checkName = check.name;
+			if (typeof checksInTable[tableName] !== 'undefined') {
+				if (checksInTable[tableName].includes(check.name)) {
+					console.log(
+						`\n${
+							withStyle.errorWarning(
+								`We've found duplicated check constraint name in ${
+									chalk.underline.blue(
+										tableName,
+									)
+								}. Please rename your check constraint in the ${
+									chalk.underline.blue(
+										tableName,
+									)
+								} table`,
+							)
+						}`,
+					);
+					process.exit(1);
+				}
+				checksInTable[tableName].push(checkName);
+			} else {
+				checksInTable[tableName] = [check.name];
+			}
+
+			checkConstraintObject[checkName] = {
+				name: checkName,
+				value: dialect.sqlToQuery(check.value).sql,
+			};
+		});
+
+		result[tableName] = {
+			name: tableName,
+			columns: columnsObject,
+			indexes: indexesObject,
+			foreignKeys: foreignKeysObject,
+			compositePrimaryKeys: primaryKeysObject,
+			uniqueConstraints: uniqueConstraintObject,
+			checkConstraints: checkConstraintObject,
+		};
+	}
+
+	for (const view of views) {
+		const { name, isExisting, selectedFields, query, schema } = getViewConfig(view);
+
+		const columnsObject: Record<string, Column> = {};
+
+		const existingView = resultViews[name];
+		if (typeof existingView !== 'undefined') {
+			console.log(
+				`\n${
+					withStyle.errorWarning(
+						`We've found duplicated view name across ${
+							chalk.underline.blue(
+								schema ?? 'public',
+							)
+						} schema. Please rename your view`,
+					)
+				}`,
+			);
+			process.exit(1);
+		}
+
+		for (const key in selectedFields) {
+			if (is(selectedFields[key], SQLiteColumn)) {
+				const column = selectedFields[key];
+				const notNull: boolean = column.notNull;
+				const primaryKey: boolean = column.primary;
+				const generated = column.generated;
+
+				const columnToSet: Column = {
+					name: column.name,
+					type: column.getSQLType(),
+					primaryKey,
+					notNull,
+					autoincrement: is(column, SQLiteBaseInteger)
+						? column.autoIncrement
+						: false,
+					generated: generated
+						? {
+							as: is(generated.as, SQL)
+								? `(${dialect.sqlToQuery(generated.as as SQL, 'indexes').sql})`
+								: typeof generated.as === 'function'
+								? `(${dialect.sqlToQuery(generated.as() as SQL, 'indexes').sql})`
+								: `(${generated.as as any})`,
+							type: generated.mode ?? 'virtual',
+						}
+						: undefined,
+				};
+
+				if (column.default !== undefined) {
+					if (is(column.default, SQL)) {
+						columnToSet.default = sqlToStr(column.default, casing);
+					} else {
+						columnToSet.default = typeof column.default === 'string'
+							? `'${column.default}'`
+							: typeof column.default === 'object'
+									|| Array.isArray(column.default)
+							? `'${JSON.stringify(column.default)}'`
+							: column.default;
+					}
+				}
+				columnsObject[column.name] = columnToSet;
+			}
+		}
+
+		resultViews[name] = {
+			columns: columnsObject,
+			name,
+			isExisting,
+			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
+		};
+	}
+
+	return {
+		version: '6',
+		dialect: 'sqlite',
+		tables: result,
+		views: resultViews,
+		enums: {},
+		_meta: {
+			tables: {},
+			columns: {},
+		},
+		internal,
+	};
+};
+
+// function mapSqlToSqliteType(sqlType: string): string {
+// 	const lowered = sqlType.toLowerCase();
+// 	if (
+// 		[
+// 			'int',
+// 			'integer',
+// 			'integer auto_increment',
+// 			'tinyint',
+// 			'smallint',
+// 			'mediumint',
+// 			'bigint',
+// 			'unsigned big int',
+// 			'int2',
+// 			'int8',
+// 		].some((it) => lowered.startsWith(it))
+// 	) {
+// 		return 'integer';
+// 	} else if (
+// 		[
+// 			'character',
+// 			'varchar',
+// 			'varying character',
+// 			'national varying character',
+// 			'nchar',
+// 			'native character',
+// 			'nvarchar',
+// 			'text',
+// 			'clob',
+// 		].some((it) => lowered.startsWith(it))
+// 	) {
+// 		const match = lowered.match(/\d+/);
+
+// 		if (match) {
+// 			return `text(${match[0]})`;
+// 		}
+
+// 		return 'text';
+// 	} else if (lowered.startsWith('blob')) {
+// 		return 'blob';
+// 	} else if (
+// 		['real', 'double', 'double precision', 'float'].some((it) => lowered.startsWith(it))
+// 	) {
+// 		return 'real';
+// 	} else {
+// 		return 'numeric';
+// 	}
+// }
+
+// interface ColumnInfo {
+// 	columnName: string;
+// 	expression: string;
+// 	type: 'stored' | 'virtual';
+// }
+
+// function extractGeneratedColumns(input: string): Record<string, ColumnInfo> {
+// 	const columns: Record<string, ColumnInfo> = {};
+// 	const lines = input.split(/,\s*(?![^()]*\))/); // Split by commas outside parentheses
+
+// 	for (const line of lines) {
+// 		if (line.includes('GENERATED ALWAYS AS')) {
+// 			const parts = line.trim().split(/\s+/);
+// 			const columnName = parts[0].replace(/[`'"]/g, ''); // Remove quotes around the column name
+// 			const expression = line
+// 				.substring(line.indexOf('('), line.indexOf(')') + 1)
+// 				.trim();
+
+// 			// Extract type ensuring to remove any trailing characters like ')'
+// 			const typeIndex = parts.findIndex((part) => part.match(/(stored|virtual)/i));
+// 			let type: ColumnInfo['type'] = 'virtual';
+// 			if (typeIndex !== -1) {
+// 				type = parts[typeIndex]
+// 					.replace(/[^a-z]/gi, '')
+// 					.toLowerCase() as ColumnInfo['type'];
+// 			}
+
+// 			columns[columnName] = {
+// 				columnName: columnName,
+// 				expression: expression,
+// 				type,
+// 			};
+// 		}
+// 	}
+// 	return columns;
+// }
+
+// function filterIgnoredTablesByField(fieldName: string) {
+// 	// _cf_ is a prefix for internal Cloudflare D1 tables (e.g. _cf_KV, _cf_METADATA)
+// 	// _litestream_ is a prefix for internal Litestream tables (e.g. _litestream_seq, _litestream_lock)
+// 	// libsql_ is a prefix for internal libSQL tables (e.g. libsql_wasm_func_table)
+// 	// sqlite_ is a prefix for internal SQLite tables (e.g. sqlite_sequence, sqlite_stat1)
+// 	return `${fieldName} != '__drizzle_migrations'
+// 			AND ${fieldName} NOT LIKE '\\_cf\\_%' ESCAPE '\\'
+// 			AND ${fieldName} NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
+// 			AND ${fieldName} NOT LIKE 'libsql\\_%' ESCAPE '\\'
+// 			AND ${fieldName} NOT LIKE 'sqlite\\_%' ESCAPE '\\'`;
+// }
+
+// export const fromDatabase = async (
+// 	db: SQLiteDB,
+// 	// oxlint-disable-next-line no-unused-vars
+// 	tablesFilter: (table: string) => boolean = (table) => true,
+// 	progressCallback?: (
+// 		stage: IntrospectStage,
+// 		count: number,
+// 		status: IntrospectStatus,
+// 	) => void,
+// ): Promise<SQLiteSchemaInternal> => {
+// 	const result: Record<string, Table> = {};
+// 	const resultViews: Record<string, View> = {};
+
+// 	const columns = await db.query<{
+// 		tableName: string;
+// 		columnName: string;
+// 		columnType: string;
+// 		notNull: number;
+// 		defaultValue: string;
+// 		pk: number;
+// 		seq: number;
+// 		hidden: number;
+// 		sql: string;
+// 		type: 'view' | 'table';
+// 	}>(`SELECT
+// 		  m.name as "tableName",
+// 		  p.name as "columnName",
+// 		  p.type as "columnType",
+// 		  p."notnull" as "notNull",
+// 		  p.dflt_value as "defaultValue",
+// 		  p.pk as pk,
+// 		  p.hidden as hidden,
+// 		  m.sql,
+// 		  m.type as type
+// 		FROM sqlite_master AS m
+// 		JOIN pragma_table_xinfo(m.name) AS p
+// 		WHERE (m.type = 'table' OR m.type = 'view')
+// 		  AND ${filterIgnoredTablesByField('m.tbl_name')};`);
+
+// 	const tablesWithSeq: string[] = [];
+
+// 	const seq = await db.query<{
+// 		name: string;
+// 	}>(`SELECT
+// 		  *
+// 		FROM sqlite_master
+// 		WHERE sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*'
+//     	  AND ${filterIgnoredTablesByField('tbl_name')};`);
+
+// 	for (const s of seq) {
+// 		tablesWithSeq.push(s.name);
+// 	}
+
+// 	let columnsCount = 0;
+// 	let tablesCount = new Set();
+// 	let indexesCount = 0;
+// 	let foreignKeysCount = 0;
+// 	let checksCount = 0;
+// 	let viewsCount = 0;
+
+// 	// append primaryKeys by table
+// 	const tableToPk: { [tname: string]: string[] } = {};
+
+// 	let tableToGeneratedColumnsInfo: Record<
+// 		string,
+// 		Record<string, ColumnInfo>
+// 	> = {};
+
+// 	for (const column of columns) {
+// 		if (!tablesFilter(column.tableName)) continue;
+
+// 		// TODO
+// 		if (column.type !== 'view') {
+// 			columnsCount += 1;
+// 		}
+// 		if (progressCallback) {
+// 			progressCallback('columns', columnsCount, 'fetching');
+// 		}
+// 		const tableName = column.tableName;
+
+// 		tablesCount.add(tableName);
+// 		if (progressCallback) {
+// 			progressCallback('tables', tablesCount.size, 'fetching');
+// 		}
+// 		const columnName = column.columnName;
+// 		const isNotNull = column.notNull === 1; // 'YES', 'NO'
+// 		const columnType = column.columnType; // varchar(256)
+// 		const isPrimary = column.pk !== 0; // 'PRI', ''
+// 		const columnDefault: string = column.defaultValue;
+
+// 		const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
+
+// 		if (isPrimary) {
+// 			if (typeof tableToPk[tableName] === 'undefined') {
+// 				tableToPk[tableName] = [columnName];
+// 			} else {
+// 				tableToPk[tableName].push(columnName);
+// 			}
+// 		}
+
+// 		const table = result[tableName];
+
+// 		if (column.hidden === 2 || column.hidden === 3) {
+// 			if (
+// 				typeof tableToGeneratedColumnsInfo[column.tableName] === 'undefined'
+// 			) {
+// 				tableToGeneratedColumnsInfo[column.tableName] = extractGeneratedColumns(
+// 					column.sql,
+// 				);
+// 			}
+// 		}
+
+// 		const newColumn: Column = {
+// 			default: columnDefault === null
+// 				? undefined
+// 				: /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault)
+// 				? Number(columnDefault)
+// 				: ['CURRENT_TIME', 'CURRENT_DATE', 'CURRENT_TIMESTAMP'].includes(
+// 						columnDefault,
+// 					)
+// 				? `(${columnDefault})`
+// 				: columnDefault === 'false'
+// 				? false
+// 				: columnDefault === 'true'
+// 				? true
+// 				: columnDefault.startsWith("'") && columnDefault.endsWith("'")
+// 				? columnDefault
+// 				// ? columnDefault.substring(1, columnDefault.length - 1)
+// 				: `(${columnDefault})`,
+// 			autoincrement: isAutoincrement,
+// 			name: columnName,
+// 			type: mapSqlToSqliteType(columnType),
+// 			primaryKey: false,
+// 			notNull: isNotNull,
+// 			generated: tableToGeneratedColumnsInfo[tableName]
+// 					&& tableToGeneratedColumnsInfo[tableName][columnName]
+// 				? {
+// 					type: tableToGeneratedColumnsInfo[tableName][columnName].type,
+// 					as: tableToGeneratedColumnsInfo[tableName][columnName].expression,
+// 				}
+// 				: undefined,
+// 		};
+
+// 		if (!table) {
+// 			result[tableName] = {
+// 				name: tableName,
+// 				columns: {
+// 					[columnName]: newColumn,
+// 				},
+// 				compositePrimaryKeys: {},
+// 				indexes: {},
+// 				foreignKeys: {},
+// 				uniqueConstraints: {},
+// 				checkConstraints: {},
+// 			};
+// 		} else {
+// 			result[tableName]!.columns[columnName] = newColumn;
+// 		}
+// 	}
+
+// 	for (const [key, value] of Object.entries(tableToPk)) {
+// 		if (value.length > 1) {
+// 			result[key].compositePrimaryKeys = {
+// 				[`${key}_${value.join('_')}_pk`]: {
+// 					columns: value,
+// 					name: `${key}_${value.join('_')}_pk`,
+// 				},
+// 			};
+// 		} else if (value.length === 1) {
+// 			result[key].columns[value[0]].primaryKey = true;
+// 		} else {
+// 		}
+// 	}
+
+// 	if (progressCallback) {
+// 		progressCallback('columns', columnsCount, 'done');
+// 		progressCallback('tables', tablesCount.size, 'done');
+// 	}
+// 	try {
+// 		const fks = await db.query<{
+// 			tableFrom: string;
+// 			tableTo: string;
+// 			from: string;
+// 			to: string;
+// 			onUpdate: string;
+// 			onDelete: string;
+// 			seq: number;
+// 			id: number;
+// 		}>(`SELECT
+// 			  m.name as "tableFrom",
+// 			  f.id as "id",
+// 			  f."table" as "tableTo",
+// 			  f."from",
+// 			  f."to",
+// 			  f."on_update" as "onUpdate",
+// 			  f."on_delete" as "onDelete",
+// 			  f.seq as "seq"
+//       		FROM
+// 			  sqlite_master m,
+// 			  pragma_foreign_key_list(m.name) as f
+//       		WHERE ${filterIgnoredTablesByField('m.tbl_name')};`);
+
+// 		const fkByTableName: Record<string, ForeignKey> = {};
+
+// 		for (const fkRow of fks) {
+// 			foreignKeysCount += 1;
+// 			if (progressCallback) {
+// 				progressCallback('fks', foreignKeysCount, 'fetching');
+// 			}
+// 			const tableName: string = fkRow.tableFrom;
+// 			const columnName: string = fkRow.from;
+// 			const refTableName = fkRow.tableTo;
+// 			const refColumnName: string = fkRow.to;
+// 			const updateRule: string = fkRow.onUpdate;
+// 			const deleteRule = fkRow.onDelete;
+// 			const sequence = fkRow.seq;
+// 			const id = fkRow.id;
+
+// 			const tableInResult = result[tableName];
+// 			if (typeof tableInResult === 'undefined') continue;
+
+// 			if (typeof fkByTableName[`${tableName}_${id}`] !== 'undefined') {
+// 				fkByTableName[`${tableName}_${id}`]!.columnsFrom.push(columnName);
+// 				fkByTableName[`${tableName}_${id}`]!.columnsTo.push(refColumnName);
+// 			} else {
+// 				fkByTableName[`${tableName}_${id}`] = {
+// 					name: '',
+// 					tableFrom: tableName,
+// 					tableTo: refTableName,
+// 					columnsFrom: [columnName],
+// 					columnsTo: [refColumnName],
+// 					onDelete: deleteRule?.toLowerCase(),
+// 					onUpdate: updateRule?.toLowerCase(),
+// 				};
+// 			}
+
+// 			const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
+// 			const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
+// 			fkByTableName[
+// 				`${tableName}_${id}`
+// 			].name = `${tableName}_${
+// 				columnsFrom.join(
+// 					'_',
+// 				)
+// 			}_${refTableName}_${columnsTo.join('_')}_fk`;
+// 		}
+
+// 		for (const idx of Object.keys(fkByTableName)) {
+// 			const value = fkByTableName[idx];
+// 			result[value.tableFrom].foreignKeys[value.name] = value;
+// 		}
+// 	} catch (e) {
+// 		// console.log(`Can't proccess foreign keys`);
+// 	}
+// 	if (progressCallback) {
+// 		progressCallback('fks', foreignKeysCount, 'done');
+// 	}
+// 	const idxs = await db.query<{
+// 		tableName: string;
+// 		indexName: string;
+// 		columnName: string;
+// 		isUnique: number;
+// 		seq: string;
+// 	}>(`SELECT
+//     	  m.tbl_name as tableName,
+//     	  il.name as indexName,
+//     	  ii.name as columnName,
+//     	  il.[unique] as isUnique,
+//     	  il.seq as seq
+// 		FROM
+// 		  sqlite_master AS m,
+//     	  pragma_index_list(m.name) AS il,
+//     	  pragma_index_info(il.name) AS ii
+// 		WHERE
+// 		  m.type = 'table'
+//     	  AND il.name NOT LIKE 'sqlite\\_autoindex\\_%' ESCAPE '\\'
+//     	  AND ${filterIgnoredTablesByField('m.tbl_name')};`);
+
+// 	for (const idxRow of idxs) {
+// 		const tableName = idxRow.tableName;
+// 		const constraintName = idxRow.indexName;
+// 		const columnName: string = idxRow.columnName;
+// 		const isUnique = idxRow.isUnique === 1;
+
+// 		const tableInResult = result[tableName];
+// 		if (typeof tableInResult === 'undefined') continue;
+
+// 		indexesCount += 1;
+// 		if (progressCallback) {
+// 			progressCallback('indexes', indexesCount, 'fetching');
+// 		}
+
+// 		if (
+// 			typeof tableInResult.indexes[constraintName] !== 'undefined'
+// 			&& columnName
+// 		) {
+// 			tableInResult.indexes[constraintName]!.columns.push(columnName);
+// 		} else {
+// 			tableInResult.indexes[constraintName] = {
+// 				name: constraintName,
+// 				columns: columnName ? [columnName] : [],
+// 				isUnique: isUnique,
+// 			};
+// 		}
+// 		// if (isUnique) {
+// 		//   if (typeof tableInResult.uniqueConstraints[constraintName] !== "undefined") {
+// 		//     tableInResult.uniqueConstraints[constraintName]!.columns.push(columnName);
+// 		//   } else {
+// 		//     tableInResult.uniqueConstraints[constraintName] = {
+// 		//       name: constraintName,
+// 		//       columns: [columnName],
+// 		//     };
+// 		//   }
+// 		// } else {
+// 		//   if (typeof tableInResult.indexes[constraintName] !== "undefined") {
+// 		//     tableInResult.indexes[constraintName]!.columns.push(columnName);
+// 		//   } else {
+// 		//     tableInResult.indexes[constraintName] = {
+// 		//       name: constraintName,
+// 		//       columns: [columnName],
+// 		//       isUnique: isUnique,
+// 		//     };
+// 		//   }
+// 		// }
+// 	}
+// 	if (progressCallback) {
+// 		progressCallback('indexes', indexesCount, 'done');
+// 		// progressCallback("enums", 0, "fetching");
+// 		progressCallback('enums', 0, 'done');
+// 	}
+
+// 	const views = await db.query(
+// 		`SELECT name AS view_name, sql AS sql FROM sqlite_master WHERE type = 'view';`,
+// 	);
+
+// 	viewsCount = views.length;
+
+// 	if (progressCallback) {
+// 		progressCallback('views', viewsCount, 'fetching');
+// 	}
+// 	for (const view of views) {
+// 		const viewName = view['view_name'];
+// 		const sql = view['sql'];
+
+// 		const regex = new RegExp(`\\bAS\\b\\s+(SELECT.+)$`, 'i');
+// 		const match = sql.match(regex);
+
+// 		if (!match) {
+// 			console.log('Could not process view');
+// 			process.exit(1);
+// 		}
+
+// 		const viewDefinition = match[1] as string;
+
+// 		const columns = result[viewName].columns;
+// 		delete result[viewName];
+
+// 		resultViews[viewName] = {
+// 			columns: columns,
+// 			isExisting: false,
+// 			name: viewName,
+// 			definition: viewDefinition,
+// 		};
+// 	}
+// 	if (progressCallback) {
+// 		progressCallback('views', viewsCount, 'done');
+// 	}
+
+// 	const namedCheckPattern = /CONSTRAINT\s*["']?(\w+)["']?\s*CHECK\s*\((.*?)\)/gi;
+// 	const unnamedCheckPattern = /CHECK\s*\((.*?)\)/gi;
+// 	let checkCounter = 0;
+// 	const checkConstraints: Record<string, CheckConstraint> = {};
+// 	const checks = await db.query<{
+// 		tableName: string;
+// 		sql: string;
+// 	}>(`SELECT
+// 		  name as "tableName",
+// 		  sql as "sql"
+// 		FROM sqlite_master
+// 		WHERE type = 'table'
+// 		  AND ${filterIgnoredTablesByField('tbl_name')};`);
+// 	for (const check of checks) {
+// 		if (!tablesFilter(check.tableName)) continue;
+
+// 		const { tableName, sql } = check;
+
+// 		// Find named CHECK constraints
+// 		let namedChecks = [...sql.matchAll(namedCheckPattern)];
+// 		if (namedChecks.length > 0) {
+// 			namedChecks.forEach(([_, checkName, checkValue]) => {
+// 				checkConstraints[checkName] = {
+// 					name: checkName,
+// 					value: checkValue.trim(),
+// 				};
+// 			});
+// 		} else {
+// 			// If no named constraints, find unnamed CHECK constraints and assign names
+// 			let unnamedChecks = [...sql.matchAll(unnamedCheckPattern)];
+// 			unnamedChecks.forEach(([_, checkValue]) => {
+// 				let checkName = `${tableName}_check_${++checkCounter}`;
+// 				checkConstraints[checkName] = {
+// 					name: checkName,
+// 					value: checkValue.trim(),
+// 				};
+// 			});
+// 		}
+
+// 		checksCount += Object.values(checkConstraints).length;
+// 		if (progressCallback) {
+// 			progressCallback('checks', checksCount, 'fetching');
+// 		}
+
+// 		const table = result[tableName];
+
+// 		if (!table) {
+// 			result[tableName] = {
+// 				name: tableName,
+// 				columns: {},
+// 				compositePrimaryKeys: {},
+// 				indexes: {},
+// 				foreignKeys: {},
+// 				uniqueConstraints: {},
+// 				checkConstraints: checkConstraints,
+// 			};
+// 		} else {
+// 			result[tableName]!.checkConstraints = checkConstraints;
+// 		}
+// 	}
+
+// 	if (progressCallback) {
+// 		progressCallback('checks', checksCount, 'done');
+// 	}
+
+// 	return {
+// 		version: '6',
+// 		dialect: 'sqlite',
+// 		tables: result,
+// 		views: resultViews,
+// 		enums: {},
+// 		_meta: {
+// 			tables: {},
+// 			columns: {},
+// 		},
+// 	};
+// };
diff --git a/drizzle-kit/src/legacy/utils.ts b/drizzle-kit/src/legacy/utils.ts
new file mode 100644
index 0000000000..d5c644f58a
--- /dev/null
+++ b/drizzle-kit/src/legacy/utils.ts
@@ -0,0 +1,212 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import type { SQL } from 'orm044';
+import { CasingCache, toCamelCase, toSnakeCase } from 'orm044/casing';
+import { join } from 'path';
+import { parse } from 'url';
+import type { CasingType } from './common';
+import { assertUnreachable, snapshotVersion } from './global';
+import type { Dialect } from './schemaValidator';
+
+export type DB = {
+	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
+};
+
+export type SQLiteDB = {
+	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
+	run(query: string): Promise<void>;
+};
+
+export type LibSQLDB = {
+	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
+	run(query: string): Promise<void>;
+	batchWithPragma?(queries: string[]): Promise<void>;
+};
+
+export const copy = <T>(it: T): T => {
+	return JSON.parse(JSON.stringify(it));
+};
+
+export const objectValues = <T extends object>(obj: T): Array<T[keyof T]> => {
+	return Object.values(obj);
+};
+
+export const assertV1OutFolder = (out: string) => {
+	if (!existsSync(out)) return;
+
+	const oldMigrationFolders = readdirSync(out).filter(
+		(it) => it.length === 14 && /^\d+$/.test(it),
+	);
+
+	if (oldMigrationFolders.length > 0) {
+		console.log(
+			`Your migrations folder format is outdated, please run ${
+				chalk.green.bold(
+					`drizzle-kit up`,
+				)
+			}`,
+		);
+		process.exit(1);
+	}
+};
+
+export type Journal = {
+	version: string;
+	dialect: Dialect;
+	entries: {
+		idx: number;
+		version: string;
+		when: number;
+		tag: string;
+		breakpoints: boolean;
+	}[];
+};
+
+export const dryJournal = (dialect: Dialect): Journal => {
+	return {
+		version: snapshotVersion,
+		dialect,
+		entries: [],
+	};
+};
+
+// export const preparePushFolder = (dialect: Dialect) => {
+//   const out = ".drizzle";
+//   let snapshot: string = "";
+//   if (!existsSync(join(out))) {
+//     mkdirSync(out);
+//     snapshot = JSON.stringify(dryJournal(dialect));
+//   } else {
+//     snapshot = readdirSync(out)[0];
+//   }
+
+//   return { snapshot };
+// };
+
+export const prepareOutFolder = (out: string, dialect: Dialect) => {
+	const meta = join(out, 'meta');
+	const journalPath = join(meta, '_journal.json');
+
+	if (!existsSync(join(out, 'meta'))) {
+		mkdirSync(meta, { recursive: true });
+		writeFileSync(journalPath, JSON.stringify(dryJournal(dialect)));
+	}
+
+	const journal = JSON.parse(readFileSync(journalPath).toString());
+
+	const snapshots = readdirSync(meta)
+		.filter((it) => !it.startsWith('_'))
+		.map((it) => join(meta, it));
+
+	snapshots.sort();
+	return { meta, snapshots, journal };
+};
+
+export const columnRenameKey = (
+	table: string,
+	schema: string,
+	column: string,
+) => {
+	const out = schema
+		? `"${schema}"."${table}"."${column}"`
+		: `"${table}"."${column}"`;
+	return out;
+};
+
+export const kloudMeta = () => {
+	return {
+		pg: [5],
+		mysql: [] as number[],
+		sqlite: [] as number[],
+	};
+};
+
+export const normaliseSQLiteUrl = (
+	it: string,
+	type: 'libsql' | 'better-sqlite',
+) => {
+	if (type === 'libsql') {
+		if (it.startsWith('file:')) {
+			return it;
+		}
+		try {
+			const url = parse(it);
+			if (url.protocol === null) {
+				return `file:${it}`;
+			}
+			return it;
+		} catch {
+			return `file:${it}`;
+		}
+	}
+
+	if (type === 'better-sqlite') {
+		if (it.startsWith('file:')) {
+			return it.substring(5);
+		}
+
+		return it;
+	}
+
+	assertUnreachable(type);
+};
+
+export const normalisePGliteUrl = (
+	it: string,
+) => {
+	if (it.startsWith('file:')) {
+		return it.substring(5);
+	}
+
+	return it;
+};
+
+export function isPgArrayType(sqlType: string) {
+	return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
+}
+
+export function findAddedAndRemoved(columnNames1: string[], columnNames2: string[]) {
+	const set1 = new Set(columnNames1);
+	const set2 = new Set(columnNames2);
+
+	const addedColumns = columnNames2.filter((it) => !set1.has(it));
+	const removedColumns = columnNames1.filter((it) => !set2.has(it));
+
+	return { addedColumns, removedColumns };
+}
+
+export function escapeSingleQuotes(str: string) {
+	return str.replace(/'/g, "''");
+}
+
+export function unescapeSingleQuotes(str: string, ignoreFirstAndLastChar: boolean) {
+	const regex = ignoreFirstAndLastChar ? /(?<!^)'(?!$)/g : /'/g;
+	return str.replace(/''/g, "'").replace(regex, "\\'");
+}
+
+export function getColumnCasing(
+	column: { keyAsName: boolean; name: string | undefined },
+	casing: CasingType | undefined,
+) {
+	if (!column.name) return '';
+	return !column.keyAsName || casing === undefined
+		? column.name
+		: casing === 'camelCase'
+		? toCamelCase(column.name)
+		: toSnakeCase(column.name);
+}
+
+export const sqlToStr = (sql: SQL, casing: CasingType | undefined) => {
+	return sql.toQuery({
+		escapeName: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeParam: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		escapeString: () => {
+			throw new Error("we don't support params for `sql` default values");
+		},
+		casing: new CasingCache(casing),
+	}).sql;
+};
diff --git a/drizzle-kit/src/loader.mjs b/drizzle-kit/src/loader.mjs
deleted file mode 100644
index 488f5712c8..0000000000
--- a/drizzle-kit/src/loader.mjs
+++ /dev/null
@@ -1,57 +0,0 @@
-import esbuild from 'esbuild';
-import { readFileSync } from 'fs';
-import * as path from 'path';
-
-const parse = (it) => {
-	if (!it) return { drizzle: false };
-
-	if (it.endsWith('__drizzle__')) {
-		const offset = it.startsWith('file://') ? 'file://'.length : 0;
-		const clean = it.slice(offset, -'__drizzle__'.length);
-		return { drizzle: true, clean, original: it };
-	}
-	return { drizzle: false, clean: it };
-};
-
-export function resolve(specifier, context, nextResolve) {
-	const { drizzle, clean } = parse(specifier);
-	if (drizzle && !clean.endsWith('.ts') && !clean.endsWith('.mts')) {
-		return nextResolve(clean);
-	}
-
-	if (drizzle) {
-		return {
-			shortCircuit: true,
-			url: `file://${specifier}`,
-		};
-	}
-
-	const parsedParent = parse(context.parentURL);
-	const parentURL = parsedParent.drizzle
-		? new URL(`file://${path.resolve(parsedParent.clean)}`)
-		: context.parentURL;
-
-	// Let Node.js handle all other specifiers.
-	return nextResolve(specifier, { ...context, parentURL });
-}
-
-export async function load(url, context, defaultLoad) {
-	const { drizzle, clean } = parse(url);
-	if (drizzle) {
-		const file = readFileSync(clean, 'utf-8');
-		if (clean.endsWith('.ts') || clean.endsWith('.mts')) {
-			const source = esbuild.transformSync(file, {
-				loader: 'ts',
-				format: 'esm',
-			});
-			return {
-				format: 'module',
-				shortCircuit: true,
-				source: source.code,
-			};
-		}
-	}
-
-	// let Node.js handle all other URLs
-	return defaultLoad(url, context, defaultLoad);
-}
diff --git a/drizzle-kit/src/mcp/server.ts b/drizzle-kit/src/mcp/server.ts
new file mode 100644
index 0000000000..6bc2e8a169
--- /dev/null
+++ b/drizzle-kit/src/mcp/server.ts
@@ -0,0 +1,274 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { check, exportSql, generate, pull, push, up } from '../cli-sdk/index.js';
+import type { Hint } from '../cli-sdk/index.js';
+
+// Under moduleResolution:"node", the MCP SDK's registerTool generic — which resolves
+// both zod/v3 and zod/v4/core as distinct module paths and unifies them against the
+// caller's zod schema — causes tsc to exhaust heap (TS2589 / SIGABRT).  Cast the
+// server to a non-generic internal interface that matches the runtime API exactly
+// but avoids the deep ShapeOutput<ZodObject<...>> instantiation.
+interface McpServerCompat {
+	registerTool(
+		name: string,
+		config: {
+			title?: string;
+			description?: string;
+			inputSchema?: z.ZodTypeAny;
+			outputSchema?: z.ZodTypeAny;
+			annotations?: Record<string, unknown>;
+		},
+		handler: (args: Record<string, unknown>) => Promise<CallToolResult>,
+	): void;
+	connect(transport: unknown): Promise<void>;
+}
+
+// Advertised as a free-form array so malformed hints reach the SDK and come back as an
+// `invalid_hints` envelope, rather than being rejected as an MCP protocol error before the
+// handler runs. The hint vocabulary is documented in the per-tool `hints` description.
+const hintsInput = z.array(z.record(z.unknown()));
+
+const looseEnvelopeSchema = z.object({
+	status: z.enum(['ok', 'no_changes', 'missing_hints', 'error']),
+	dialect: z.string().optional(),
+	error: z.record(z.unknown()).optional(),
+	unresolved: z.array(z.unknown()).optional(),
+}).passthrough();
+
+type SdkEnvelope = { status: string } & Record<string, unknown>;
+
+function toToolResult(envelope: SdkEnvelope): CallToolResult {
+	const isError = envelope.status === 'error' || envelope.status === 'missing_hints';
+	return {
+		content: [{ type: 'text', text: JSON.stringify(envelope) }],
+		structuredContent: envelope,
+		isError,
+	};
+}
+
+// The SDK functions catch their own errors and resolve with an envelope, so this only fires if a
+// rejection unexpectedly escapes — convert it to an envelope rather than let the MCP SDK surface a
+// raw error. The detail is omitted deliberately — a raw driver message can carry connection
+// credentials, which must never reach any client channel.
+const unexpectedErrorEnvelope = (): SdkEnvelope => ({
+	status: 'error',
+	error: { code: 'internal_error', message: 'unexpected error in MCP tool handler' },
+});
+
+export function createDrizzleMcpServer(): McpServer {
+	const server = new McpServer({
+		name: 'drizzle',
+		version: process.env.DRIZZLE_KIT_VERSION ?? '0.0.0',
+	}) as unknown as McpServerCompat;
+
+	// Serialize tool calls: concurrent generate/push against the same out dir would
+	// interleave snapshot reads/writes (each CLI invocation used to be its own process).
+	let chain: Promise<unknown> = Promise.resolve();
+	const serialize = <T>(fn: () => Promise<T>): Promise<T> => {
+		const next = chain.then(fn, fn);
+		chain = next.catch(() => {});
+		return next;
+	};
+
+	server.registerTool(
+		'generate',
+		{
+			description: 'Generate a new migration file by diffing the current schema against the latest snapshot. '
+				+ 'If the response has status "missing_hints", re-call with a "hints" array resolving each '
+				+ 'unresolved item (rename or create).',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+				hints: hintsInput.optional().describe(
+					'Resolutions for missing_hints items. Each entry is an object with a "type" discriminator '
+						+ '("rename" | "create" | "confirm_data_loss") echoing the unresolved item to resolve.',
+				),
+				name: z.string().optional().describe('Custom migration name'),
+				custom: z.boolean().optional().describe('Generate a blank custom migration'),
+				ignoreConflicts: z.boolean().optional().describe('Ignore existing snapshot conflicts'),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			annotations: { destructiveHint: false },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					generate({
+						config: args.config as string | undefined,
+						hints: args.hints as Hint[] | undefined,
+						name: args.name as string | undefined,
+						custom: args.custom as boolean | undefined,
+						ignoreConflicts: args.ignoreConflicts as boolean | undefined,
+					})
+				) as unknown as SdkEnvelope;
+				return toToolResult(envelope);
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	server.registerTool(
+		'push',
+		{
+			description: 'Apply the current schema directly to a live database without writing a migration file. '
+				+ 'This is a destructive operation. If the response has status "missing_hints", re-call '
+				+ 'with a "hints" array resolving each unresolved item.',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+				hints: hintsInput.optional().describe(
+					'Resolutions for missing_hints items. Each entry is an object with a "type" discriminator '
+						+ '("rename" | "create" | "confirm_data_loss") echoing the unresolved item to resolve.',
+				),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			annotations: { destructiveHint: true },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					push({
+						config: args.config as string | undefined,
+						hints: args.hints as Hint[] | undefined,
+					})
+				) as unknown as SdkEnvelope;
+				return toToolResult(envelope);
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	server.registerTool(
+		'check',
+		{
+			description: 'Check for migration conflicts in the snapshot history. '
+				+ 'Read-only and idempotent — no changes are written to the database or snapshot.',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+				ignoreConflicts: z.boolean().optional().describe('Skip conflict checks'),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			annotations: { readOnlyHint: true, idempotentHint: true },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					check({
+						config: args.config as string | undefined,
+						ignoreConflicts: args.ignoreConflicts as boolean | undefined,
+					})
+				) as unknown as SdkEnvelope;
+				return toToolResult(envelope);
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	server.registerTool(
+		'export',
+		{
+			description: 'Export the full schema as a SQL dump by diffing against empty state. '
+				+ 'Read-only and idempotent — no DB connection, no files written.',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			annotations: { readOnlyHint: true, idempotentHint: true },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					exportSql({ config: args.config as string | undefined })
+				) as unknown as SdkEnvelope;
+				return toToolResult(envelope);
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	server.registerTool(
+		'up',
+		{
+			description: 'Upgrade on-disk migration snapshots to the latest format. '
+				+ 'Rewrites meta/*_snapshot.json files in place; idempotent (re-running on already-latest snapshots is a no-op).',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			annotations: { idempotentHint: true },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					up({ config: args.config as string | undefined })
+				) as unknown as SdkEnvelope;
+				return toToolResult(envelope);
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	server.registerTool(
+		'pull',
+		{
+			description: 'Introspect a live database and write schema.ts/relations.ts/snapshot to the out directory. '
+				+ 'Reads credentials from the drizzle config file only. When "init" is true, runs the initial '
+				+ 'migration against the live database (a destructive operation) and reports destructiveHint:true '
+				+ 'via the result _meta key "com.drizzle.team/pull.destructiveHint".',
+			inputSchema: z.object({
+				config: z.string().optional().describe(
+					'Custom config file path — relative to the drizzle-kit working directory, or absolute.',
+				),
+				init: z.boolean().optional().describe(
+					'Create migration metadata for the pulled schema in the database. '
+						+ 'This runs the initial migration against the LIVE database — a destructive operation.',
+				),
+			}),
+			outputSchema: looseEnvelopeSchema,
+			// Static listTools annotation — cannot flip per call; the init:true escalation rides result._meta.
+			annotations: { destructiveHint: false },
+		},
+		async (args) => {
+			try {
+				const envelope = await serialize(() =>
+					pull({
+						config: args.config as string | undefined,
+						init: args.init as boolean | undefined,
+					})
+				) as unknown as SdkEnvelope;
+				const result = toToolResult(envelope);
+				// Per-call escalation derived from the input only — never the envelope (keeps it CLI≡SDK identical)
+				// and independent of isError, so a failed init call still warns the client.
+				if (args.init === true) {
+					result._meta = { 'com.drizzle.team/pull.destructiveHint': true };
+				}
+				return result;
+			} catch {
+				return toToolResult(unexpectedErrorEnvelope());
+			}
+		},
+	);
+
+	return server as unknown as McpServer;
+}
+
+export async function startMcpServer(): Promise<void> {
+	const server = createDrizzleMcpServer();
+	process.stderr.write(`drizzle-kit mcp v${process.env.DRIZZLE_KIT_VERSION ?? '0.0.0'}\n`);
+	await server.connect(new StdioServerTransport());
+}
diff --git a/drizzle-kit/src/migrationPreparator.ts b/drizzle-kit/src/migrationPreparator.ts
deleted file mode 100644
index 4e67e8174b..0000000000
--- a/drizzle-kit/src/migrationPreparator.ts
+++ /dev/null
@@ -1,217 +0,0 @@
-import { randomUUID } from 'crypto';
-import fs from 'fs';
-import { CasingType } from './cli/validations/common';
-import { serializeMySql, serializePg, serializeSingleStore, serializeSQLite } from './serializer';
-import { dryMySql, MySqlSchema, mysqlSchema } from './serializer/mysqlSchema';
-import { dryPg, PgSchema, pgSchema, PgSchemaInternal } from './serializer/pgSchema';
-import { drySingleStore, SingleStoreSchema, singlestoreSchema } from './serializer/singlestoreSchema';
-import { drySQLite, SQLiteSchema, sqliteSchema } from './serializer/sqliteSchema';
-
-export const prepareMySqlDbPushSnapshot = async (
-	prev: MySqlSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: MySqlSchema; cur: MySqlSchema }> => {
-	const serialized = await serializeMySql(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: MySqlSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareSingleStoreDbPushSnapshot = async (
-	prev: SingleStoreSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SingleStoreSchema; cur: SingleStoreSchema }> => {
-	const serialized = await serializeSingleStore(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SingleStoreSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareSQLiteDbPushSnapshot = async (
-	prev: SQLiteSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SQLiteSchema; cur: SQLiteSchema }> => {
-	const serialized = await serializeSQLite(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SQLiteSchema = {
-		version,
-		dialect,
-		id,
-		prevId: idPrev,
-		...rest,
-	};
-
-	return { prev, cur: result };
-};
-
-export const preparePgDbPushSnapshot = async (
-	prev: PgSchema,
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-	schemaFilter: string[] = ['public'],
-): Promise<{ prev: PgSchema; cur: PgSchema }> => {
-	const serialized = await serializePg(schemaPath, casing, schemaFilter);
-
-	const id = randomUUID();
-	const idPrev = prev.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: PgSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	return { prev, cur: result };
-};
-
-export const prepareMySqlMigrationSnapshot = async (
-	migrationFolders: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: MySqlSchema; cur: MySqlSchema; custom: MySqlSchema }> => {
-	const prevSnapshot = mysqlSchema.parse(
-		preparePrevSnapshot(migrationFolders, dryMySql),
-	);
-	const serialized = await serializeMySql(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: MySqlSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: MySqlSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const prepareSingleStoreMigrationSnapshot = async (
-	migrationFolders: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SingleStoreSchema; cur: SingleStoreSchema; custom: SingleStoreSchema }> => {
-	const prevSnapshot = singlestoreSchema.parse(
-		preparePrevSnapshot(migrationFolders, drySingleStore),
-	);
-	const serialized = await serializeSingleStore(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SingleStoreSchema = { version, dialect, id, prevId: idPrev, ...rest };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: SingleStoreSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const prepareSqliteMigrationSnapshot = async (
-	snapshots: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: SQLiteSchema; cur: SQLiteSchema; custom: SQLiteSchema }> => {
-	const prevSnapshot = sqliteSchema.parse(
-		preparePrevSnapshot(snapshots, drySQLite),
-	);
-	const serialized = await serializeSQLite(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	const { version, dialect, ...rest } = serialized;
-	const result: SQLiteSchema = {
-		version,
-		dialect,
-		id,
-		prevId: idPrev,
-		...rest,
-	};
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: SQLiteSchema = {
-		id,
-		prevId: idPrev,
-		...prevRest,
-	};
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-export const fillPgSnapshot = ({
-	serialized,
-	id,
-	idPrev,
-}: {
-	serialized: PgSchemaInternal;
-	id: string;
-	idPrev: string;
-}): PgSchema => {
-	// const id = randomUUID();
-	return { id, prevId: idPrev, ...serialized };
-};
-
-export const preparePgMigrationSnapshot = async (
-	snapshots: string[],
-	schemaPath: string | string[],
-	casing: CasingType | undefined,
-): Promise<{ prev: PgSchema; cur: PgSchema; custom: PgSchema }> => {
-	const prevSnapshot = pgSchema.parse(preparePrevSnapshot(snapshots, dryPg));
-	const serialized = await serializePg(schemaPath, casing);
-
-	const id = randomUUID();
-	const idPrev = prevSnapshot.id;
-
-	// const { version, dialect, ...rest } = serialized;
-
-	const result: PgSchema = { id, prevId: idPrev, ...serialized };
-
-	const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
-
-	// that's for custom migrations, when we need new IDs, but old snapshot
-	const custom: PgSchema = fillPgSnapshot({ serialized: prevRest, id, idPrev });
-
-	return { prev: prevSnapshot, cur: result, custom };
-};
-
-const preparePrevSnapshot = (snapshots: string[], defaultPrev: any) => {
-	let prevSnapshot: any;
-
-	if (snapshots.length === 0) {
-		prevSnapshot = defaultPrev;
-	} else {
-		const lastSnapshot = snapshots[snapshots.length - 1];
-		prevSnapshot = JSON.parse(fs.readFileSync(lastSnapshot).toString());
-	}
-	return prevSnapshot;
-};
diff --git a/drizzle-kit/src/payload/mssql.ts b/drizzle-kit/src/payload/mssql.ts
new file mode 100644
index 0000000000..0a7baf8468
--- /dev/null
+++ b/drizzle-kit/src/payload/mssql.ts
@@ -0,0 +1,188 @@
+import type { MsSqlDatabase } from 'drizzle-orm/mssql-core';
+import type { EntitiesFilterConfig } from '../cli/validations/common';
+import type { MssqlCredentials } from '../cli/validations/mssql';
+import type {
+	CheckConstraint,
+	Column,
+	DefaultConstraint,
+	ForeignKey,
+	Index,
+	MssqlEntities,
+	PrimaryKey,
+	Schema,
+	UniqueConstraint,
+	View,
+} from '../dialects/mssql/ddl';
+import { createDDL, interimToDDL } from '../dialects/mssql/ddl';
+import type { MssqlSnapshot } from '../dialects/mssql/snapshot';
+import { originUUID } from '../utils';
+import type { DB } from '../utils';
+
+export const generateDrizzleJson = async (
+	imports: Record<string, unknown>,
+	prevId?: string,
+	schemaFilters?: string[],
+): Promise<MssqlSnapshot> => {
+	const { prepareEntityFilter } = await import('src/dialects/pull-utils');
+	const { humanLog, mssqlSchemaError } = await import('../cli/views');
+	const { toJsonSnapshot } = await import('../dialects/mssql/snapshot');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/mssql/drizzle');
+	const { extractMssqlExisting } = await import('../dialects/drizzle');
+	const prepared = fromExports(imports);
+
+	const existing = extractMssqlExisting(prepared.schemas, prepared.views);
+
+	const filter = prepareEntityFilter('mssql', {
+		schemas: schemaFilters ?? [],
+		tables: [],
+		entities: undefined,
+		extensions: [],
+	}, existing);
+
+	const { schema: interim, errors } = fromDrizzleSchema(prepared, filter);
+
+	const { ddl, errors: err2 } = interimToDDL(interim);
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => mssqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	if (err2.length > 0) {
+		humanLog(err2.map((it) => mssqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	return toJsonSnapshot(ddl, prevId ? [prevId] : [originUUID], []);
+};
+
+export const generateMigration = async (
+	prev: MssqlSnapshot,
+	cur: MssqlSnapshot,
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { ddlDiff } = await import('../dialects/mssql/diff');
+	const from = createDDL();
+	const to = createDDL();
+
+	for (const it of prev.ddl) {
+		from.entities.push(it);
+	}
+	for (const it of cur.ddl) {
+		to.entities.push(it);
+	}
+
+	const { sqlStatements } = await ddlDiff(
+		from,
+		to,
+		resolver<Schema>('schema', undefined, 'dbo'),
+		resolver<MssqlEntities['tables']>('table', undefined, 'dbo'),
+		resolver<Column>('column', undefined, 'dbo'),
+		resolver<View>('view', undefined, 'dbo'),
+		resolver<UniqueConstraint>('unique', undefined, 'dbo'),
+		resolver<Index>('index', undefined, 'dbo'),
+		resolver<CheckConstraint>('check', undefined, 'dbo'),
+		resolver<PrimaryKey>('primary_key', undefined, 'dbo'),
+		resolver<ForeignKey>('foreign key', undefined, 'dbo'),
+		resolver<DefaultConstraint>('default', undefined, 'dbo'),
+		'default',
+	);
+
+	return sqlStatements;
+};
+
+export const pushSchema = async (
+	imports: Record<string, unknown>,
+	drizzleInstance: MsSqlDatabase<any, any>,
+	entitiesConfig?: EntitiesFilterConfig,
+	migrationsConfig?: {
+		table?: string;
+		schema?: string;
+	},
+) => {
+	const { prepareEntityFilter } = await import('src/dialects/pull-utils');
+	const { resolver } = await import('../cli/prompts');
+	const { fromDatabaseForDrizzle } = await import('src/dialects/mssql/introspect');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/mssql/drizzle');
+	const { suggestions } = await import('../cli/commands/push-mssql');
+	const { extractMssqlExisting } = await import('../dialects/drizzle');
+	const { ddlDiff } = await import('../dialects/mssql/diff');
+	const { HintsHandler } = await import('../cli/hints');
+	const { sql } = await import('drizzle-orm');
+
+	const migrations = {
+		schema: migrationsConfig?.schema || 'dbo',
+		table: migrationsConfig?.table || '__drizzle_migrations',
+	};
+
+	const db: DB = {
+		query: async (query: string, _params?: any[]) => {
+			const res = await drizzleInstance.execute(sql.raw(query));
+			return (res as any).recordset ?? res;
+		},
+	};
+	const prepared = fromExports(imports);
+
+	const filterConfig = entitiesConfig ?? {
+		tables: [],
+		schemas: [],
+		extensions: [],
+		entities: undefined,
+	} satisfies EntitiesFilterConfig;
+	const existing = extractMssqlExisting(prepared.schemas, prepared.views);
+	const filter = prepareEntityFilter('mssql', filterConfig, existing);
+
+	const prev = await fromDatabaseForDrizzle(db, filter, () => {}, migrations);
+
+	const { schema: cur } = fromDrizzleSchema(prepared, filter);
+
+	const { ddl: from } = interimToDDL(prev);
+	const { ddl: to } = interimToDDL(cur);
+
+	const { sqlStatements, statements } = await ddlDiff(
+		from,
+		to,
+		resolver<Schema>('schema', undefined, 'dbo'),
+		resolver<MssqlEntities['tables']>('table', undefined, 'dbo'),
+		resolver<Column>('column', undefined, 'dbo'),
+		resolver<View>('view', undefined, 'dbo'),
+		resolver<UniqueConstraint>('unique', undefined, 'dbo'),
+		resolver<Index>('index', undefined, 'dbo'),
+		resolver<CheckConstraint>('check', undefined, 'dbo'),
+		resolver<PrimaryKey>('primary_key', undefined, 'dbo'),
+		resolver<ForeignKey>('foreign key', undefined, 'dbo'),
+		resolver<DefaultConstraint>('default', undefined, 'dbo'),
+		'push',
+	);
+
+	const hints = await suggestions(db, statements, to, new HintsHandler());
+
+	return {
+		sqlStatements,
+		hints,
+		apply: async () => {
+			const losses = hints.map((x) => x.statement).filter((x): x is string => typeof x !== 'undefined');
+			for (const st of losses) {
+				await db.query(st);
+			}
+			for (const st of sqlStatements) {
+				await db.query(st);
+			}
+		},
+	};
+};
+
+export const startStudioServer = async (
+	_imports: Record<string, unknown>,
+	_credentials: MssqlCredentials,
+	_options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	throw new Error('Studio for MSSQL is not yet supported');
+};
+
+export { upToV2 as up } from '../dialects/mssql/versions';
diff --git a/drizzle-kit/src/payload/mysql.ts b/drizzle-kit/src/payload/mysql.ts
new file mode 100644
index 0000000000..694edbf21b
--- /dev/null
+++ b/drizzle-kit/src/payload/mysql.ts
@@ -0,0 +1,165 @@
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnyMySqlTable } from 'drizzle-orm/mysql-core';
+import type { MysqlCredentials } from '../cli/validations/mysql';
+import type { Column, Table, View } from '../dialects/mysql/ddl';
+import { createDDL, interimToDDL } from '../dialects/mysql/ddl';
+import type { MysqlSnapshot } from '../dialects/mysql/snapshot';
+import { originUUID } from '../utils';
+import type { DB } from '../utils';
+
+export const generateDrizzleJson = async (
+	imports: Record<string, unknown>,
+	prevId?: string,
+): Promise<MysqlSnapshot> => {
+	const { humanLog, mysqlSchemaError } = await import('../cli/views');
+	const { toJsonSnapshot } = await import('../dialects/mysql/snapshot');
+	const { fromDrizzleSchema, prepareFromExports } = await import('../dialects/mysql/drizzle');
+	const prepared = prepareFromExports(imports);
+
+	const interim = fromDrizzleSchema(prepared.tables, prepared.views);
+
+	const { ddl, errors } = interimToDDL(interim);
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => mysqlSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	return toJsonSnapshot(ddl, prevId ? [prevId] : [originUUID], []);
+};
+
+export const generateMigration = async (
+	prev: MysqlSnapshot,
+	cur: MysqlSnapshot,
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { ddlDiff } = await import('../dialects/mysql/diff');
+	const from = createDDL();
+	const to = createDDL();
+
+	for (const it of prev.ddl) {
+		from.entities.push(it);
+	}
+	for (const it of cur.ddl) {
+		to.entities.push(it);
+	}
+
+	const { sqlStatements } = await ddlDiff(
+		from,
+		to,
+		resolver<Table>('table'),
+		resolver<Column>('column'),
+		resolver<View>('view'),
+		'default',
+	);
+
+	return sqlStatements;
+};
+
+export const pushSchema = async (
+	imports: Record<string, unknown>,
+	db: DB,
+	database: string,
+	migrationsConfig?: {
+		table?: string;
+		schema?: string;
+	},
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { fromDatabaseForDrizzle } = await import('src/dialects/mysql/introspect');
+	const { fromDrizzleSchema, prepareFromExports } = await import('../dialects/mysql/drizzle');
+	const { suggestions } = await import('../cli/commands/push-mysql');
+	const { ddlDiff } = await import('../dialects/mysql/diff');
+	const { HintsHandler } = await import('../cli/hints');
+
+	const migrations = {
+		schema: migrationsConfig?.schema || '',
+		table: migrationsConfig?.table || '__drizzle_migrations',
+	};
+
+	const prepared = prepareFromExports(imports);
+
+	const prev = await fromDatabaseForDrizzle(db, database, () => true, () => {}, migrations);
+	const cur = fromDrizzleSchema(prepared.tables, prepared.views);
+
+	const { ddl: from } = interimToDDL(prev);
+	const { ddl: to } = interimToDDL(cur);
+
+	const { sqlStatements, statements } = await ddlDiff(
+		from,
+		to,
+		resolver<Table>('table'),
+		resolver<Column>('column'),
+		resolver<View>('view'),
+		'push',
+	);
+
+	const hints = await suggestions(db, statements, to, new HintsHandler());
+
+	return {
+		sqlStatements,
+		hints,
+		apply: async () => {
+			const losses = hints.map((x) => x.statement).filter((x): x is string => typeof x !== 'undefined');
+			for (const st of losses) {
+				await db.query(st);
+			}
+			for (const st of sqlStatements) {
+				await db.query(st);
+			}
+		},
+	};
+};
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: MysqlCredentials,
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { MySqlTable, getTableConfig } = await import('drizzle-orm/mysql-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForMySQL, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog } = await import('../cli/views');
+
+	const mysqlSchema: Record<string, Record<string, AnyMySqlTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, MySqlTable)) {
+			const schema = getTableConfig(t).schema || 'public';
+			mysqlSchema[schema] = mysqlSchema[schema] || {};
+			mysqlSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForMySQL(credentials, mysqlSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				humanLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
+
+export { upToV6 as up } from '../cli/commands/up-mysql';
diff --git a/drizzle-kit/src/payload/postgres.ts b/drizzle-kit/src/payload/postgres.ts
new file mode 100644
index 0000000000..49ca5d072a
--- /dev/null
+++ b/drizzle-kit/src/payload/postgres.ts
@@ -0,0 +1 @@
+export * from '../ext/api-postgres';
diff --git a/drizzle-kit/src/payload/sqlite.ts b/drizzle-kit/src/payload/sqlite.ts
new file mode 100644
index 0000000000..fe3d7f4929
--- /dev/null
+++ b/drizzle-kit/src/payload/sqlite.ts
@@ -0,0 +1,162 @@
+/// <reference types="@cloudflare/workers-types" />
+import type { Relations } from 'drizzle-orm/_relations';
+import type { AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SqliteCredentials } from '../cli/validations/sqlite';
+import type { Column, Table } from '../dialects/sqlite/ddl';
+import { createDDL, interimToDDL } from '../dialects/sqlite/ddl';
+import type { SqliteSnapshot } from '../dialects/sqlite/snapshot';
+import { originUUID } from '../utils';
+import type { SQLiteClient } from '../utils';
+
+export const generateDrizzleJson = async (
+	imports: Record<string, unknown>,
+	prevId?: string,
+): Promise<SqliteSnapshot> => {
+	const { randomUUID } = await import('crypto');
+	const { humanLog, sqliteSchemaError } = await import('../cli/views');
+	const { toJsonSnapshot } = await import('../dialects/sqlite/snapshot');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/sqlite/drizzle');
+	const prepared = fromExports(imports);
+
+	const interim = fromDrizzleSchema(prepared.tables, prepared.views);
+
+	const { ddl, errors } = interimToDDL(interim);
+
+	if (errors.length > 0) {
+		humanLog(errors.map((it) => sqliteSchemaError(it)).join('\n'));
+		process.exit(1);
+	}
+
+	return toJsonSnapshot(ddl, randomUUID(), prevId ? [prevId] : [originUUID], []);
+};
+
+export const generateMigration = async (
+	prev: SqliteSnapshot,
+	cur: SqliteSnapshot,
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { ddlDiff } = await import('../dialects/sqlite/diff');
+	const from = createDDL();
+	const to = createDDL();
+
+	for (const it of prev.ddl) {
+		from.entities.push(it);
+	}
+	for (const it of cur.ddl) {
+		to.entities.push(it);
+	}
+
+	const { sqlStatements } = await ddlDiff(
+		from,
+		to,
+		resolver<Table>('table'),
+		resolver<Column>('column'),
+		'default',
+	);
+
+	return sqlStatements;
+};
+
+export const pushSchema = async (
+	imports: Record<string, unknown>,
+	db: SQLiteClient,
+	migrationsConfig?: {
+		table?: string;
+		schema?: string;
+	},
+) => {
+	const { resolver } = await import('../cli/prompts');
+	const { fromDatabaseForDrizzle } = await import('src/dialects/sqlite/introspect');
+	const { fromDrizzleSchema, fromExports } = await import('../dialects/sqlite/drizzle');
+	const { suggestions } = await import('../cli/commands/push-sqlite');
+	const { ddlDiff } = await import('../dialects/sqlite/diff');
+	const { HintsHandler } = await import('../cli/hints');
+
+	const migrations = {
+		schema: migrationsConfig?.schema || '',
+		table: migrationsConfig?.table || '__drizzle_migrations',
+	};
+
+	const prepared = fromExports(imports);
+
+	const prev = await fromDatabaseForDrizzle(db, () => true, () => {}, migrations);
+	const cur = fromDrizzleSchema(prepared.tables, prepared.views);
+
+	const { ddl: from } = interimToDDL(prev);
+	const { ddl: to } = interimToDDL(cur);
+
+	const { sqlStatements, statements } = await ddlDiff(
+		from,
+		to,
+		resolver<Table>('table'),
+		resolver<Column>('column'),
+		'push',
+	);
+
+	const hints = await suggestions(db, statements, new HintsHandler());
+
+	return {
+		sqlStatements,
+		hints,
+		apply: async () => {
+			const losses = hints.map((x) => x.statement).filter((x): x is string => typeof x !== 'undefined');
+			await db.batch([...losses, ...sqlStatements]);
+		},
+	};
+};
+
+export const startStudioServer = async (
+	imports: Record<string, unknown>,
+	credentials: SqliteCredentials | {
+		driver: 'd1';
+		binding: D1Database;
+	},
+	options?: {
+		host?: string;
+		port?: number;
+		key?: string;
+		cert?: string;
+	},
+) => {
+	const { is } = await import('drizzle-orm');
+	const { SQLiteTable } = await import('drizzle-orm/sqlite-core');
+	const { Relations } = await import('drizzle-orm/_relations');
+	const { drizzleForSQLite, prepareServer } = await import('../cli/commands/studio');
+	const { humanLog } = await import('../cli/views');
+
+	const sqliteSchema: Record<string, Record<string, AnySQLiteTable>> = {};
+	const relations: Record<string, Relations> = {};
+
+	Object.entries(imports).forEach(([k, t]) => {
+		if (is(t, SQLiteTable)) {
+			const schema = 'public'; // sqlite does not have schemas
+			sqliteSchema[schema] = sqliteSchema[schema] || {};
+			sqliteSchema[schema][k] = t;
+		}
+
+		if (is(t, Relations)) {
+			relations[k] = t;
+		}
+	});
+
+	const setup = await drizzleForSQLite(credentials, sqliteSchema, relations, []);
+	const server = await prepareServer(setup);
+
+	const host = options?.host || '127.0.0.1';
+	const port = options?.port || 4983;
+	server.start({
+		host,
+		port,
+		key: options?.key,
+		cert: options?.cert,
+		cb: (err) => {
+			if (err) {
+				console.error(err);
+			} else {
+				humanLog(`Studio is running at ${options?.key ? 'https' : 'http'}://${host}:${port}`);
+			}
+		},
+	});
+};
+
+export { updateToV7 as up } from '../cli/commands/up-sqlite';
diff --git a/drizzle-kit/src/schemaValidator.ts b/drizzle-kit/src/schemaValidator.ts
deleted file mode 100644
index ce4b2e59c4..0000000000
--- a/drizzle-kit/src/schemaValidator.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { enum as enumType, TypeOf, union } from 'zod';
-import { mysqlSchema, mysqlSchemaSquashed } from './serializer/mysqlSchema';
-import { pgSchema, pgSchemaSquashed } from './serializer/pgSchema';
-import { singlestoreSchema, singlestoreSchemaSquashed } from './serializer/singlestoreSchema';
-import { sqliteSchema, SQLiteSchemaSquashed } from './serializer/sqliteSchema';
-
-export const dialects = ['postgresql', 'mysql', 'sqlite', 'turso', 'singlestore', 'gel'] as const;
-export const dialect = enumType(dialects);
-
-export type Dialect = (typeof dialects)[number];
-const _: Dialect = '' as TypeOf<typeof dialect>;
-
-const commonSquashedSchema = union([
-	pgSchemaSquashed,
-	mysqlSchemaSquashed,
-	SQLiteSchemaSquashed,
-	singlestoreSchemaSquashed,
-]);
-
-const commonSchema = union([pgSchema, mysqlSchema, sqliteSchema, singlestoreSchema]);
-
-export type CommonSquashedSchema = TypeOf<typeof commonSquashedSchema>;
-export type CommonSchema = TypeOf<typeof commonSchema>;
diff --git a/drizzle-kit/src/serializer/gelSchema.ts b/drizzle-kit/src/serializer/gelSchema.ts
deleted file mode 100644
index f7bf8b4bf2..0000000000
--- a/drizzle-kit/src/serializer/gelSchema.ts
+++ /dev/null
@@ -1,633 +0,0 @@
-import { mapValues, originUUID, snapshotVersion } from '../global';
-
-import { any, array, boolean, enum as enumType, literal, number, object, record, string, TypeOf, union } from 'zod';
-
-const enumSchema = object({
-	name: string(),
-	schema: string(),
-	values: string().array(),
-}).strict();
-
-const enumSchemaV1 = object({
-	name: string(),
-	values: record(string(), string()),
-}).strict();
-
-const indexColumn = object({
-	expression: string(),
-	isExpression: boolean(),
-	asc: boolean(),
-	nulls: string().optional(),
-	opclass: string().optional(),
-});
-
-export type IndexColumnType = TypeOf<typeof indexColumn>;
-
-const index = object({
-	name: string(),
-	columns: indexColumn.array(),
-	isUnique: boolean(),
-	with: record(string(), any()).optional(),
-	method: string().default('btree'),
-	where: string().optional(),
-	concurrently: boolean().default(false),
-}).strict();
-
-const fk = object({
-	name: string(),
-	tableFrom: string(),
-	columnsFrom: string().array(),
-	tableTo: string(),
-	schemaTo: string().optional(),
-	columnsTo: string().array(),
-	onUpdate: string().optional(),
-	onDelete: string().optional(),
-}).strict();
-
-export const sequenceSchema = object({
-	name: string(),
-	increment: string().optional(),
-	minValue: string().optional(),
-	maxValue: string().optional(),
-	startWith: string().optional(),
-	cache: string().optional(),
-	cycle: boolean().optional(),
-	schema: string(),
-}).strict();
-
-export const roleSchema = object({
-	name: string(),
-	createDb: boolean().optional(),
-	createRole: boolean().optional(),
-	inherit: boolean().optional(),
-}).strict();
-
-export const sequenceSquashed = object({
-	name: string(),
-	schema: string(),
-	values: string(),
-}).strict();
-
-const column = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-	generated: object({
-		type: literal('stored'),
-		as: string(),
-	}).optional(),
-	identity: sequenceSchema
-		.merge(object({ type: enumType(['always', 'byDefault']) }))
-		.optional(),
-}).strict();
-
-const checkConstraint = object({
-	name: string(),
-	value: string(),
-}).strict();
-
-const columnSquashed = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-	generated: object({
-		type: literal('stored'),
-		as: string(),
-	}).optional(),
-	identity: string().optional(),
-}).strict();
-
-const compositePK = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const uniqueConstraint = object({
-	name: string(),
-	columns: string().array(),
-	nullsNotDistinct: boolean(),
-}).strict();
-
-export const policy = object({
-	name: string(),
-	as: enumType(['PERMISSIVE', 'RESTRICTIVE']).optional(),
-	for: enumType(['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE']).optional(),
-	to: string().array().optional(),
-	using: string().optional(),
-	withCheck: string().optional(),
-	on: string().optional(),
-	schema: string().optional(),
-}).strict();
-
-export const policySquashed = object({
-	name: string(),
-	values: string(),
-}).strict();
-
-const viewWithOption = object({
-	checkOption: enumType(['local', 'cascaded']).optional(),
-	securityBarrier: boolean().optional(),
-	securityInvoker: boolean().optional(),
-}).strict();
-
-const matViewWithOption = object({
-	fillfactor: number().optional(),
-	toastTupleTarget: number().optional(),
-	parallelWorkers: number().optional(),
-	autovacuumEnabled: boolean().optional(),
-	vacuumIndexCleanup: enumType(['auto', 'off', 'on']).optional(),
-	vacuumTruncate: boolean().optional(),
-	autovacuumVacuumThreshold: number().optional(),
-	autovacuumVacuumScaleFactor: number().optional(),
-	autovacuumVacuumCostDelay: number().optional(),
-	autovacuumVacuumCostLimit: number().optional(),
-	autovacuumFreezeMinAge: number().optional(),
-	autovacuumFreezeMaxAge: number().optional(),
-	autovacuumFreezeTableAge: number().optional(),
-	autovacuumMultixactFreezeMinAge: number().optional(),
-	autovacuumMultixactFreezeMaxAge: number().optional(),
-	autovacuumMultixactFreezeTableAge: number().optional(),
-	logAutovacuumMinDuration: number().optional(),
-	userCatalogTable: boolean().optional(),
-}).strict();
-
-export const mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
-
-export const view = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	definition: string().optional(),
-	materialized: boolean(),
-	with: mergedViewWithOption.optional(),
-	isExisting: boolean(),
-	withNoData: boolean().optional(),
-	using: string().optional(),
-	tablespace: string().optional(),
-}).strict();
-
-const table = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-	policies: record(string(), policy).default({}),
-	checkConstraints: record(string(), checkConstraint).default({}),
-	isRLSEnabled: boolean().default(false),
-}).strict();
-
-const schemaHash = object({
-	id: string(),
-	prevId: string(),
-});
-
-export const kitInternals = object({
-	tables: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({
-					isArray: boolean().optional(),
-					dimensions: number().optional(),
-					rawType: string().optional(),
-					isDefaultAnExpression: boolean().optional(),
-				}).optional(),
-			),
-		}).optional(),
-	),
-}).optional();
-
-export const gelSchemaExternal = object({
-	version: literal('1'),
-	dialect: literal('gel'),
-	tables: array(table),
-	enums: array(enumSchemaV1),
-	schemas: array(object({ name: string() })),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-}).strict();
-
-export const gelSchemaInternal = object({
-	version: literal('1'),
-	dialect: literal('gel'),
-	tables: record(string(), table),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	views: record(string(), view).default({}),
-	sequences: record(string(), sequenceSchema).default({}),
-	roles: record(string(), roleSchema).default({}),
-	policies: record(string(), policy).default({}),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-const tableSquashed = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), columnSquashed),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()),
-	uniqueConstraints: record(string(), string()),
-	policies: record(string(), string()),
-	checkConstraints: record(string(), string()),
-	isRLSEnabled: boolean().default(false),
-}).strict();
-
-export const gelSchemaSquashed = object({
-	version: literal('1'),
-	dialect: literal('gel'),
-	tables: record(string(), tableSquashed),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	views: record(string(), view),
-	sequences: record(string(), sequenceSquashed),
-	roles: record(string(), roleSchema).default({}),
-	policies: record(string(), policySquashed).default({}),
-}).strict();
-
-export const gelSchema = gelSchemaInternal.merge(schemaHash);
-
-export type Enum = TypeOf<typeof enumSchema>;
-export type Sequence = TypeOf<typeof sequenceSchema>;
-export type Role = TypeOf<typeof roleSchema>;
-export type Column = TypeOf<typeof column>;
-export type Table = TypeOf<typeof table>;
-export type GelSchema = TypeOf<typeof gelSchema>;
-export type GelSchemaInternal = TypeOf<typeof gelSchemaInternal>;
-export type GelSchemaExternal = TypeOf<typeof gelSchemaExternal>;
-export type GelSchemaSquashed = TypeOf<typeof gelSchemaSquashed>;
-export type Index = TypeOf<typeof index>;
-export type ForeignKey = TypeOf<typeof fk>;
-export type PrimaryKey = TypeOf<typeof compositePK>;
-export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
-export type Policy = TypeOf<typeof policy>;
-export type View = TypeOf<typeof view>;
-export type MatViewWithOption = TypeOf<typeof matViewWithOption>;
-export type ViewWithOption = TypeOf<typeof viewWithOption>;
-
-export type GelKitInternals = TypeOf<typeof kitInternals>;
-export type CheckConstraint = TypeOf<typeof checkConstraint>;
-
-// no prev version
-export const backwardCompatibleGelSchema = gelSchema;
-
-export const GelSquasher = {
-	squashIdx: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${
-			idx.columns
-				.map(
-					(c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass ? c.opclass : ''}`,
-				)
-				.join(',,')
-		};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
-	},
-	unsquashIdx: (input: string): Index => {
-		const [
-			name,
-			columnsString,
-			isUnique,
-			concurrently,
-			method,
-			where,
-			idxWith,
-		] = input.split(';');
-
-		const columnString = columnsString.split(',,');
-		const columns: IndexColumnType[] = [];
-
-		for (const column of columnString) {
-			const [expression, isExpression, asc, nulls, opclass] = column.split('--');
-			columns.push({
-				nulls: nulls as IndexColumnType['nulls'],
-				isExpression: isExpression === 'true',
-				asc: asc === 'true',
-				expression: expression,
-				opclass: opclass === 'undefined' ? undefined : opclass,
-			});
-		}
-
-		const result: Index = index.parse({
-			name,
-			columns: columns,
-			isUnique: isUnique === 'true',
-			concurrently: concurrently === 'true',
-			method,
-			where: where === 'undefined' ? undefined : where,
-			with: !idxWith || idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
-		});
-		return result;
-	},
-	squashIdxPush: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${
-			idx.columns
-				.map((c) => `${c.isExpression ? '' : c.expression}--${c.asc}--${c.nulls}`)
-				.join(',,')
-		};${idx.isUnique};${idx.method};${JSON.stringify(idx.with)}`;
-	},
-	unsquashIdxPush: (input: string): Index => {
-		const [name, columnsString, isUnique, method, idxWith] = input.split(';');
-
-		const columnString = columnsString.split('--');
-		const columns: IndexColumnType[] = [];
-
-		for (const column of columnString) {
-			const [expression, asc, nulls, opclass] = column.split(',');
-			columns.push({
-				nulls: nulls as IndexColumnType['nulls'],
-				isExpression: expression === '',
-				asc: asc === 'true',
-				expression: expression,
-			});
-		}
-
-		const result: Index = index.parse({
-			name,
-			columns: columns,
-			isUnique: isUnique === 'true',
-			concurrently: false,
-			method,
-			with: idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
-		});
-		return result;
-	},
-	squashFK: (fk: ForeignKey) => {
-		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
-			fk.onUpdate ?? ''
-		};${fk.onDelete ?? ''};${fk.schemaTo || 'public'}`;
-	},
-	squashPolicy: (policy: Policy) => {
-		return `${policy.name}--${policy.as}--${policy.for}--${
-			policy.to?.join(',')
-		}--${policy.using}--${policy.withCheck}--${policy.on}`;
-	},
-	unsquashPolicy: (policy: string): Policy => {
-		const splitted = policy.split('--');
-		return {
-			name: splitted[0],
-			as: splitted[1] as Policy['as'],
-			for: splitted[2] as Policy['for'],
-			to: splitted[3].split(','),
-			using: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			withCheck: splitted[5] !== 'undefined' ? splitted[5] : undefined,
-			on: splitted[6] !== 'undefined' ? splitted[6] : undefined,
-		};
-	},
-	squashPolicyPush: (policy: Policy) => {
-		return `${policy.name}--${policy.as}--${policy.for}--${policy.to?.join(',')}--${policy.on}`;
-	},
-	unsquashPolicyPush: (policy: string): Policy => {
-		const splitted = policy.split('--');
-		return {
-			name: splitted[0],
-			as: splitted[1] as Policy['as'],
-			for: splitted[2] as Policy['for'],
-			to: splitted[3].split(','),
-			on: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-		};
-	},
-	squashPK: (pk: PrimaryKey) => {
-		return `${pk.columns.join(',')};${pk.name}`;
-	},
-	unsquashPK: (pk: string): PrimaryKey => {
-		const splitted = pk.split(';');
-		return { name: splitted[1], columns: splitted[0].split(',') };
-	},
-	squashUnique: (unq: UniqueConstraint) => {
-		return `${unq.name};${unq.columns.join(',')};${unq.nullsNotDistinct}`;
-	},
-	unsquashUnique: (unq: string): UniqueConstraint => {
-		const [name, columns, nullsNotDistinct] = unq.split(';');
-		return {
-			name,
-			columns: columns.split(','),
-			nullsNotDistinct: nullsNotDistinct === 'true',
-		};
-	},
-	unsquashFK: (input: string): ForeignKey => {
-		const [
-			name,
-			tableFrom,
-			columnsFromStr,
-			tableTo,
-			columnsToStr,
-			onUpdate,
-			onDelete,
-			schemaTo,
-		] = input.split(';');
-
-		const result: ForeignKey = fk.parse({
-			name,
-			tableFrom,
-			columnsFrom: columnsFromStr.split(','),
-			schemaTo: schemaTo,
-			tableTo,
-			columnsTo: columnsToStr.split(','),
-			onUpdate,
-			onDelete,
-		});
-		return result;
-	},
-	squashSequence: (seq: Omit<Sequence, 'name' | 'schema'>) => {
-		return `${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${seq.cycle ?? ''}`;
-	},
-	unsquashSequence: (seq: string): Omit<Sequence, 'name' | 'schema'> => {
-		const splitted = seq.split(';');
-		return {
-			minValue: splitted[0] !== 'undefined' ? splitted[0] : undefined,
-			maxValue: splitted[1] !== 'undefined' ? splitted[1] : undefined,
-			increment: splitted[2] !== 'undefined' ? splitted[2] : undefined,
-			startWith: splitted[3] !== 'undefined' ? splitted[3] : undefined,
-			cache: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			cycle: splitted[5] === 'true',
-		};
-	},
-	squashIdentity: (
-		seq: Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' },
-	) => {
-		return `${seq.name};${seq.type};${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${
-			seq.cycle ?? ''
-		}`;
-	},
-	unsquashIdentity: (
-		seq: string,
-	): Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' } => {
-		const splitted = seq.split(';');
-		return {
-			name: splitted[0],
-			type: splitted[1] as 'always' | 'byDefault',
-			minValue: splitted[2] !== 'undefined' ? splitted[2] : undefined,
-			maxValue: splitted[3] !== 'undefined' ? splitted[3] : undefined,
-			increment: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			startWith: splitted[5] !== 'undefined' ? splitted[5] : undefined,
-			cache: splitted[6] !== 'undefined' ? splitted[6] : undefined,
-			cycle: splitted[7] === 'true',
-		};
-	},
-	squashCheck: (check: CheckConstraint) => {
-		return `${check.name};${check.value}`;
-	},
-	unsquashCheck: (input: string): CheckConstraint => {
-		const [
-			name,
-			value,
-		] = input.split(';');
-
-		return { name, value };
-	},
-};
-
-export const squashGelScheme = (
-	json: GelSchema,
-	action?: 'push' | undefined,
-): GelSchemaSquashed => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index) => {
-				return action === 'push'
-					? GelSquasher.squashIdxPush(index)
-					: GelSquasher.squashIdx(index);
-			});
-
-			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
-				return GelSquasher.squashFK(fk);
-			});
-
-			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-				return GelSquasher.squashPK(pk);
-			});
-
-			const mappedColumns = Object.fromEntries(
-				Object.entries(it[1].columns).map((it) => {
-					const mappedIdentity = it[1].identity
-						? GelSquasher.squashIdentity(it[1].identity)
-						: undefined;
-					return [
-						it[0],
-						{
-							...it[1],
-							identity: mappedIdentity,
-						},
-					];
-				}),
-			);
-
-			const squashedUniqueConstraints = mapValues(
-				it[1].uniqueConstraints,
-				(unq) => {
-					return GelSquasher.squashUnique(unq);
-				},
-			);
-
-			const squashedPolicies = mapValues(it[1].policies, (policy) => {
-				return action === 'push'
-					? GelSquasher.squashPolicyPush(policy)
-					: GelSquasher.squashPolicy(policy);
-			});
-			const squashedChecksContraints = mapValues(
-				it[1].checkConstraints,
-				(check) => {
-					return GelSquasher.squashCheck(check);
-				},
-			);
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					schema: it[1].schema,
-					columns: mappedColumns,
-					indexes: squashedIndexes,
-					foreignKeys: squashedFKs,
-					compositePrimaryKeys: squashedPKs,
-					uniqueConstraints: squashedUniqueConstraints,
-					policies: squashedPolicies,
-					checkConstraints: squashedChecksContraints,
-					isRLSEnabled: it[1].isRLSEnabled ?? false,
-				},
-			];
-		}),
-	);
-
-	const mappedSequences = Object.fromEntries(
-		Object.entries(json.sequences).map((it) => {
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					schema: it[1].schema,
-					values: GelSquasher.squashSequence(it[1]),
-				},
-			];
-		}),
-	);
-
-	const mappedPolicies = Object.fromEntries(
-		Object.entries(json.policies).map((it) => {
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					values: action === 'push'
-						? GelSquasher.squashPolicyPush(it[1])
-						: GelSquasher.squashPolicy(it[1]),
-				},
-			];
-		}),
-	);
-
-	return {
-		version: '1',
-		dialect: json.dialect,
-		tables: mappedTables,
-		enums: json.enums,
-		schemas: json.schemas,
-		views: json.views,
-		policies: mappedPolicies,
-		sequences: mappedSequences,
-		roles: json.roles,
-	};
-};
-
-export const dryGel = gelSchema.parse({
-	version: '1',
-	dialect: 'gel',
-	id: originUUID,
-	prevId: '',
-	tables: {},
-	enums: {},
-	schemas: {},
-	policies: {},
-	roles: {},
-	sequences: {},
-	_meta: {
-		schemas: {},
-		tables: {},
-		columns: {},
-	},
-});
diff --git a/drizzle-kit/src/serializer/gelSerializer.ts b/drizzle-kit/src/serializer/gelSerializer.ts
deleted file mode 100644
index c3adf05f0e..0000000000
--- a/drizzle-kit/src/serializer/gelSerializer.ts
+++ /dev/null
@@ -1,1661 +0,0 @@
-import chalk from 'chalk';
-import { getTableName, is, SQL } from 'drizzle-orm';
-import {
-	AnyGelTable,
-	GelColumn,
-	GelDialect,
-	GelMaterializedView,
-	GelPolicy,
-	GelRole,
-	GelSchema,
-	GelSequence,
-	GelView,
-	getMaterializedViewConfig,
-	getTableConfig,
-	getViewConfig,
-	IndexedColumn,
-} from 'drizzle-orm/gel-core';
-import { CasingType } from 'src/cli/validations/common';
-import { IntrospectStage, IntrospectStatus } from 'src/cli/views';
-import { vectorOps } from 'src/extensions/vector';
-import { withStyle } from '../cli/validations/outputs';
-import { type DB, escapeSingleQuotes } from '../utils';
-import { GelSchemaInternal } from './gelSchema';
-import type {
-	Column,
-	ForeignKey,
-	GelKitInternals,
-	Index,
-	IndexColumnType,
-	Policy,
-	PrimaryKey,
-	Role,
-	Sequence,
-	Table,
-	UniqueConstraint,
-	View,
-} from './gelSchema';
-import { getColumnCasing, sqlToStr } from './utils';
-
-export const indexName = (tableName: string, columns: string[]) => {
-	return `${tableName}_${columns.join('_')}_index`;
-};
-
-function stringFromIdentityProperty(field: string | number | undefined): string | undefined {
-	return typeof field === 'string' ? (field as string) : typeof field === 'undefined' ? undefined : String(field);
-}
-
-function maxRangeForIdentityBasedOn(columnType: string) {
-	return columnType === 'integer' ? '2147483647' : columnType === 'bigint' ? '9223372036854775807' : '32767';
-}
-
-function minRangeForIdentityBasedOn(columnType: string) {
-	return columnType === 'integer' ? '-2147483648' : columnType === 'bigint' ? '-9223372036854775808' : '-32768';
-}
-
-function stringFromDatabaseIdentityProperty(field: any): string | undefined {
-	return typeof field === 'string'
-		? (field as string)
-		: typeof field === 'undefined'
-		? undefined
-		: typeof field === 'bigint'
-		? field.toString()
-		: String(field);
-}
-
-export function buildArrayString(array: any[], sqlType: string): string {
-	sqlType = sqlType.split('[')[0];
-	const values = array
-		.map((value) => {
-			if (typeof value === 'number' || typeof value === 'bigint') {
-				return value.toString();
-			} else if (typeof value === 'boolean') {
-				return value ? 'true' : 'false';
-			} else if (Array.isArray(value)) {
-				return buildArrayString(value, sqlType);
-			} else if (value instanceof Date) {
-				if (sqlType === 'date') {
-					return `"${value.toISOString().split('T')[0]}"`;
-				} else if (sqlType === 'timestamp') {
-					return `"${value.toISOString().replace('T', ' ').slice(0, 23)}"`;
-				} else {
-					return `"${value.toISOString()}"`;
-				}
-			} else if (typeof value === 'object') {
-				return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
-			}
-
-			return `"${value}"`;
-		})
-		.join(',');
-
-	return `{${values}}`;
-}
-
-const generateGelSnapshot = (
-	tables: AnyGelTable[],
-	// enums: GelEnum<any>[],
-	schemas: GelSchema[],
-	sequences: GelSequence[],
-	roles: GelRole[],
-	policies: GelPolicy[],
-	views: GelView[],
-	matViews: GelMaterializedView[],
-	casing: CasingType | undefined,
-	schemaFilter?: string[],
-): GelSchemaInternal => {
-	const dialect = new GelDialect({ casing });
-	const result: Record<string, Table> = {};
-	const resultViews: Record<string, View> = {};
-	const sequencesToReturn: Record<string, Sequence> = {};
-	const rolesToReturn: Record<string, Role> = {};
-	// this policies are a separate objects that were linked to a table outside of it
-	const policiesToReturn: Record<string, Policy> = {};
-
-	// This object stores unique names for indexes and will be used to detect if you have the same names for indexes
-	// within the same PostgreSQL schema
-
-	const indexesInSchema: Record<string, string[]> = {};
-
-	for (const table of tables) {
-		// This object stores unique names for checks and will be used to detect if you have the same names for checks
-		// within the same PostgreSQL table
-		const checksInTable: Record<string, string[]> = {};
-
-		const {
-			name: tableName,
-			columns,
-			indexes,
-			foreignKeys,
-			checks,
-			schema,
-			primaryKeys,
-			uniqueConstraints,
-			policies,
-			enableRLS,
-		} = getTableConfig(table);
-
-		if (schemaFilter && !schemaFilter.includes(schema ?? 'public')) {
-			continue;
-		}
-
-		const columnsObject: Record<string, Column> = {};
-		const indexesObject: Record<string, Index> = {};
-		// const checksObject: Record<string, CheckConstraint> = {};
-		const foreignKeysObject: Record<string, ForeignKey> = {};
-		const primaryKeysObject: Record<string, PrimaryKey> = {};
-		// const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-		const policiesObject: Record<string, Policy> = {};
-
-		columns.forEach((column) => {
-			const name = getColumnCasing(column, casing);
-			const notNull: boolean = column.notNull;
-			const primaryKey: boolean = column.primary;
-			const sqlTypeLowered = column.getSQLType().toLowerCase();
-
-			// const typeSchema = is(column, GelEnumColumn) ? column.enum.schema || 'public' : undefined;
-			const generated = column.generated;
-			const identity = column.generatedIdentity;
-
-			const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
-			const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
-				?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
-			const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
-				?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
-			const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
-				?? (parseFloat(increment) < 0 ? maxValue : minValue);
-			const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
-
-			const columnToSet: Column = {
-				name,
-				type: column.getSQLType(),
-				typeSchema: undefined,
-				primaryKey,
-				notNull,
-				generated: generated
-					? {
-						as: is(generated.as, SQL)
-							? dialect.sqlToQuery(generated.as as SQL).sql
-							: typeof generated.as === 'function'
-							? dialect.sqlToQuery(generated.as() as SQL).sql
-							: (generated.as as any),
-						type: 'stored',
-					}
-					: undefined,
-				identity: identity
-					? {
-						type: identity.type,
-						name: identity.sequenceName ?? `${tableName}_${name}_seq`,
-						schema: schema ?? 'public',
-						increment,
-						startWith,
-						minValue,
-						maxValue,
-						cache,
-						cycle: identity?.sequenceOptions?.cycle ?? false,
-					}
-					: undefined,
-			};
-
-			// 	if (column.isUnique) {
-			// 		const existingUnique = uniqueConstraintObject[column.uniqueName!];
-			// 		if (typeof existingUnique !== 'undefined') {
-			// 			console.log(
-			// 				`\n${
-			// 					withStyle.errorWarning(`We\'ve found duplicated unique constraint names in ${
-			// 						chalk.underline.blue(
-			// 							tableName,
-			// 						)
-			// 					} table.
-			//   The unique constraint ${
-			// 						chalk.underline.blue(
-			// 							column.uniqueName,
-			// 						)
-			// 					} on the ${
-			// 						chalk.underline.blue(
-			// 							name,
-			// 						)
-			// 					} column is conflicting with a unique constraint name already defined for ${
-			// 						chalk.underline.blue(
-			// 							existingUnique.columns.join(','),
-			// 						)
-			// 					} columns\n`)
-			// 				}`,
-			// 			);
-			// 			process.exit(1);
-			// 		}
-			// 		uniqueConstraintObject[column.uniqueName!] = {
-			// 			name: column.uniqueName!,
-			// 			nullsNotDistinct: column.uniqueType === 'not distinct',
-			// 			columns: [columnToSet.name],
-			// 		};
-			// 	}
-
-			if (column.default !== undefined) {
-				if (is(column.default, SQL)) {
-					columnToSet.default = sqlToStr(column.default, casing);
-				} else {
-					if (typeof column.default === 'string') {
-						columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
-					} else {
-						if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
-							columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-						} else if (column.default instanceof Date) {
-							if (sqlTypeLowered === 'date') {
-								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-							} else if (sqlTypeLowered === 'timestamp') {
-								columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
-							} else {
-								columnToSet.default = `'${column.default.toISOString()}'`;
-							}
-						} else if (Array.isArray(column.default)) {
-							columnToSet.default = columnToSet.default;
-						} else {
-							// Should do for all types
-							// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
-							columnToSet.default = column.default;
-						}
-					}
-				}
-			}
-			columnsObject[name] = columnToSet;
-		});
-
-		primaryKeys.map((pk) => {
-			const originalColumnNames = pk.columns.map((c) => c.name);
-			const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
-
-			let name = pk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnNames.length; i++) {
-					name = name.replace(originalColumnNames[i], columnNames[i]);
-				}
-			}
-
-			primaryKeysObject[name] = {
-				name,
-				columns: columnNames,
-			};
-		});
-
-		// uniqueConstraints?.map((unq) => {
-		// 	const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
-
-		// 	const name = unq.name ?? uniqueKeyName(table, columnNames);
-
-		// 	// const existingUnique = uniqueConstraintObject[name];
-		// // 	if (typeof existingUnique !== 'undefined') {
-		// // 		console.log(
-		// // 			`\n${
-		// // 				withStyle.errorWarning(
-		// // 					`We\'ve found duplicated unique constraint names in ${chalk.underline.blue(tableName)} table.
-		// // The unique constraint ${chalk.underline.blue(name)} on the ${
-		// // 						chalk.underline.blue(
-		// // 							columnNames.join(','),
-		// // 						)
-		// // 					} columns is confilcting with a unique constraint name already defined for ${
-		// // 						chalk.underline.blue(existingUnique.columns.join(','))
-		// // 					} columns\n`,
-		// // 				)
-		// // 			}`,
-		// // 		);
-		// // 		process.exit(1);
-		// // 	}
-
-		// 	// uniqueConstraintObject[name] = {
-		// 	// 	name: unq.name!,
-		// 	// 	nullsNotDistinct: unq.nullsNotDistinct,
-		// 	// 	columns: columnNames,
-		// 	// };
-		// });
-
-		const fks: ForeignKey[] = foreignKeys.map((fk) => {
-			const tableFrom = tableName;
-			const onDelete = fk.onDelete;
-			const onUpdate = fk.onUpdate;
-			const reference = fk.reference();
-
-			const tableTo = getTableName(reference.foreignTable);
-			// TODO: resolve issue with schema undefined/public for db push(or squasher)
-			// getTableConfig(reference.foreignTable).schema || "public";
-			const schemaTo = getTableConfig(reference.foreignTable).schema;
-
-			const originalColumnsFrom = reference.columns.map((it) => it.name);
-			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
-			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
-			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
-
-			let name = fk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnsFrom.length; i++) {
-					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
-				}
-				for (let i = 0; i < originalColumnsTo.length; i++) {
-					name = name.replace(originalColumnsTo[i], columnsTo[i]);
-				}
-			}
-
-			return {
-				name,
-				tableFrom,
-				tableTo,
-				schemaTo,
-				columnsFrom,
-				columnsTo,
-				onDelete,
-				onUpdate,
-			} as ForeignKey;
-		});
-
-		fks.forEach((it) => {
-			foreignKeysObject[it.name] = it;
-		});
-
-		indexes.forEach((value) => {
-			const columns = value.config.columns;
-
-			let indexColumnNames: string[] = [];
-			columns.forEach((it) => {
-				if (is(it, SQL)) {
-					if (typeof value.config.name === 'undefined') {
-						console.log(
-							`\n${
-								withStyle.errorWarning(
-									`Please specify an index name in ${getTableName(value.config.table)} table that has "${
-										dialect.sqlToQuery(it).sql
-									}" expression. We can generate index names for indexes on columns only; for expressions in indexes, you need to specify the name yourself.`,
-								)
-							}`,
-						);
-						process.exit(1);
-					}
-				}
-				it = it as IndexedColumn;
-				const name = getColumnCasing(it as IndexedColumn, casing);
-				if (
-					!is(it, SQL)
-					&& typeof it.indexConfig!.opClass === 'undefined'
-				) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`You are specifying an index on the ${
-									chalk.blueBright(
-										name,
-									)
-								} column inside the ${
-									chalk.blueBright(
-										tableName,
-									)
-								} table with the ${
-									chalk.blueBright(
-										'vector',
-									)
-								} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${
-									vectorOps
-										.map((it) => `${chalk.underline(`${it}`)}`)
-										.join(', ')
-								}].\n\nYou can specify it using current syntax: ${
-									chalk.underline(
-										`index("${value.config.name}").using("${value.config.method}", table.${name}.op("${
-											vectorOps[0]
-										}"))`,
-									)
-								}\n\nYou can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing\n`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				indexColumnNames.push(name);
-			});
-
-			const name = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
-
-			let indexColumns: IndexColumnType[] = columns.map(
-				(it): IndexColumnType => {
-					if (is(it, SQL)) {
-						return {
-							expression: dialect.sqlToQuery(it, 'indexes').sql,
-							asc: true,
-							isExpression: true,
-							nulls: 'last',
-						};
-					} else {
-						it = it as IndexedColumn;
-						return {
-							expression: getColumnCasing(it as IndexedColumn, casing),
-							isExpression: false,
-							asc: it.indexConfig?.order === 'asc',
-							nulls: it.indexConfig?.nulls
-								? it.indexConfig?.nulls
-								: it.indexConfig?.order === 'desc'
-								? 'first'
-								: 'last',
-							opclass: it.indexConfig?.opClass,
-						};
-					}
-				},
-			);
-
-			// check for index names duplicates
-			if (typeof indexesInSchema[schema ?? 'public'] !== 'undefined') {
-				if (indexesInSchema[schema ?? 'public'].includes(name)) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated index name across ${
-									chalk.underline.blue(schema ?? 'public')
-								} schema. Please rename your index in either the ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table or the table with the duplicated index name`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				indexesInSchema[schema ?? 'public'].push(name);
-			} else {
-				indexesInSchema[schema ?? 'public'] = [name];
-			}
-
-			indexesObject[name] = {
-				name,
-				columns: indexColumns,
-				isUnique: value.config.unique ?? false,
-				where: value.config.where ? dialect.sqlToQuery(value.config.where).sql : undefined,
-				concurrently: value.config.concurrently ?? false,
-				method: value.config.method ?? 'btree',
-				with: value.config.with ?? {},
-			};
-		});
-
-		policies.forEach((policy) => {
-			const mappedTo = [];
-
-			if (!policy.to) {
-				mappedTo.push('public');
-			} else {
-				if (policy.to && typeof policy.to === 'string') {
-					mappedTo.push(policy.to);
-				} else if (policy.to && is(policy.to, GelRole)) {
-					mappedTo.push(policy.to.name);
-				} else if (policy.to && Array.isArray(policy.to)) {
-					policy.to.forEach((it) => {
-						if (typeof it === 'string') {
-							mappedTo.push(it);
-						} else if (is(it, GelRole)) {
-							mappedTo.push(it.name);
-						}
-					});
-				}
-			}
-
-			if (policiesObject[policy.name] !== undefined) {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated policy name across ${
-								chalk.underline.blue(tableKey)
-							} table. Please rename one of the policies with ${
-								chalk.underline.blue(
-									policy.name,
-								)
-							} name`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			policiesObject[policy.name] = {
-				name: policy.name,
-				as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
-				for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
-				to: mappedTo.sort(),
-				using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
-				withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
-			};
-		});
-
-		// checks.forEach((check) => {
-		// 	const checkName = check.name;
-
-		// 	if (typeof checksInTable[`"${schema ?? 'public'}"."${tableName}"`] !== 'undefined') {
-		// 		if (checksInTable[`"${schema ?? 'public'}"."${tableName}"`].includes(check.name)) {
-		// 			console.log(
-		// 				`\n${
-		// 					withStyle.errorWarning(
-		// 						`We\'ve found duplicated check constraint name across ${
-		// 							chalk.underline.blue(
-		// 								schema ?? 'public',
-		// 							)
-		// 						} schema in ${
-		// 							chalk.underline.blue(
-		// 								tableName,
-		// 							)
-		// 						}. Please rename your check constraint in either the ${
-		// 							chalk.underline.blue(
-		// 								tableName,
-		// 							)
-		// 						} table or the table with the duplicated check contraint name`,
-		// 					)
-		// 				}`,
-		// 			);
-		// 			process.exit(1);
-		// 		}
-		// 		checksInTable[`"${schema ?? 'public'}"."${tableName}"`].push(checkName);
-		// 	} else {
-		// 		checksInTable[`"${schema ?? 'public'}"."${tableName}"`] = [check.name];
-		// 	}
-
-		// 	checksObject[checkName] = {
-		// 		name: checkName,
-		// 		value: dialect.sqlToQuery(check.value).sql,
-		// 	};
-		// });
-
-		const tableKey = `${schema ?? 'public'}.${tableName}`;
-
-		result[tableKey] = {
-			name: tableName,
-			schema: schema ?? '',
-			columns: columnsObject,
-			indexes: indexesObject,
-			foreignKeys: foreignKeysObject,
-			compositePrimaryKeys: primaryKeysObject,
-			uniqueConstraints: {}, // uniqueConstraintObject,
-			policies: policiesObject,
-			checkConstraints: {}, // checksObject,
-			isRLSEnabled: enableRLS,
-		};
-	}
-
-	for (const policy of policies) {
-		// @ts-ignore
-		if (!policy._linkedTable) {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`"Policy ${policy.name} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`,
-					)
-				}`,
-			);
-			continue;
-		}
-
-		// @ts-ignore
-		const tableConfig = getTableConfig(policy._linkedTable);
-
-		const tableKey = `${tableConfig.schema ?? 'public'}.${tableConfig.name}`;
-
-		const mappedTo = [];
-
-		if (!policy.to) {
-			mappedTo.push('public');
-		} else {
-			if (policy.to && typeof policy.to === 'string') {
-				mappedTo.push(policy.to);
-			} else if (policy.to && is(policy.to, GelRole)) {
-				mappedTo.push(policy.to.name);
-			} else if (policy.to && Array.isArray(policy.to)) {
-				policy.to.forEach((it) => {
-					if (typeof it === 'string') {
-						mappedTo.push(it);
-					} else if (is(it, GelRole)) {
-						mappedTo.push(it.name);
-					}
-				});
-			}
-		}
-
-		// add separate policies object, that will be only responsible for policy creation
-		// but we would need to track if a policy was enabled for a specific table or not
-		// enable only if jsonStatements for enable rls was not already there + filter it
-
-		if (result[tableKey]?.policies[policy.name] !== undefined || policiesToReturn[policy.name] !== undefined) {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated policy name across ${
-							chalk.underline.blue(tableKey)
-						} table. Please rename one of the policies with ${
-							chalk.underline.blue(
-								policy.name,
-							)
-						} name`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		const mappedPolicy = {
-			name: policy.name,
-			as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
-			for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
-			to: mappedTo.sort(),
-			using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
-			withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
-		};
-
-		if (result[tableKey]) {
-			result[tableKey].policies[policy.name] = mappedPolicy;
-		} else {
-			policiesToReturn[policy.name] = {
-				...mappedPolicy,
-				schema: tableConfig.schema ?? 'public',
-				on: `"${tableConfig.schema ?? 'public'}"."${tableConfig.name}"`,
-			};
-		}
-	}
-
-	for (const sequence of sequences) {
-		const name = sequence.seqName!;
-		if (typeof sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] === 'undefined') {
-			const increment = stringFromIdentityProperty(sequence?.seqOptions?.increment) ?? '1';
-			const minValue = stringFromIdentityProperty(sequence?.seqOptions?.minValue)
-				?? (parseFloat(increment) < 0 ? '-9223372036854775808' : '1');
-			const maxValue = stringFromIdentityProperty(sequence?.seqOptions?.maxValue)
-				?? (parseFloat(increment) < 0 ? '-1' : '9223372036854775807');
-			const startWith = stringFromIdentityProperty(sequence?.seqOptions?.startWith)
-				?? (parseFloat(increment) < 0 ? maxValue : minValue);
-			const cache = stringFromIdentityProperty(sequence?.seqOptions?.cache) ?? '1';
-
-			sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] = {
-				name,
-				schema: sequence.schema ?? 'public',
-				increment,
-				startWith,
-				minValue,
-				maxValue,
-				cache,
-				cycle: sequence.seqOptions?.cycle ?? false,
-			};
-		} else {
-			// duplicate seq error
-		}
-	}
-
-	for (const role of roles) {
-		if (!(role as any)._existing) {
-			rolesToReturn[role.name] = {
-				name: role.name,
-				createDb: (role as any).createDb === undefined ? false : (role as any).createDb,
-				createRole: (role as any).createRole === undefined ? false : (role as any).createRole,
-				inherit: (role as any).inherit === undefined ? true : (role as any).inherit,
-			};
-		}
-	}
-	const combinedViews = [...views, ...matViews];
-	for (const view of combinedViews) {
-		let viewName;
-		let schema;
-		let query;
-		let selectedFields;
-		let isExisting;
-		let withOption;
-		let tablespace;
-		let using;
-		let withNoData;
-		let materialized: boolean = false;
-
-		if (is(view, GelView)) {
-			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption } = getViewConfig(view));
-		} else {
-			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption, tablespace, using, withNoData } =
-				getMaterializedViewConfig(view));
-
-			materialized = true;
-		}
-
-		const viewSchema = schema ?? 'public';
-
-		const viewKey = `${viewSchema}.${viewName}`;
-
-		const columnsObject: Record<string, Column> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-
-		const existingView = resultViews[viewKey];
-		if (typeof existingView !== 'undefined') {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated view name across ${
-							chalk.underline.blue(schema ?? 'public')
-						} schema. Please rename your view`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		for (const key in selectedFields) {
-			if (is(selectedFields[key], GelColumn)) {
-				const column = selectedFields[key];
-
-				const notNull: boolean = column.notNull;
-				const primaryKey: boolean = column.primary;
-				const sqlTypeLowered = column.getSQLType().toLowerCase();
-
-				// const typeSchema = is(column, GelEnumColumn) ? column.enum.schema || 'public' : undefined;
-				const generated = column.generated;
-				const identity = column.generatedIdentity;
-
-				const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
-				const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
-					?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
-				const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
-					?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
-				const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
-					?? (parseFloat(increment) < 0 ? maxValue : minValue);
-				const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
-
-				const columnToSet: Column = {
-					name: column.name,
-					type: column.getSQLType(),
-					typeSchema: undefined,
-					primaryKey,
-					notNull,
-					generated: generated
-						? {
-							as: is(generated.as, SQL)
-								? dialect.sqlToQuery(generated.as as SQL).sql
-								: typeof generated.as === 'function'
-								? dialect.sqlToQuery(generated.as() as SQL).sql
-								: (generated.as as any),
-							type: 'stored',
-						}
-						: undefined,
-					identity: identity
-						? {
-							type: identity.type,
-							name: identity.sequenceName ?? `${viewName}_${column.name}_seq`,
-							schema: schema ?? 'public',
-							increment,
-							startWith,
-							minValue,
-							maxValue,
-							cache,
-							cycle: identity?.sequenceOptions?.cycle ?? false,
-						}
-						: undefined,
-				};
-
-				if (column.isUnique) {
-					const existingUnique = uniqueConstraintObject[column.uniqueName!];
-					if (typeof existingUnique !== 'undefined') {
-						console.log(
-							`\n${
-								withStyle.errorWarning(
-									`We\'ve found duplicated unique constraint names in ${chalk.underline.blue(viewName)} table. 
-          The unique constraint ${chalk.underline.blue(column.uniqueName)} on the ${
-										chalk.underline.blue(
-											column.name,
-										)
-									} column is confilcting with a unique constraint name already defined for ${
-										chalk.underline.blue(existingUnique.columns.join(','))
-									} columns\n`,
-								)
-							}`,
-						);
-						process.exit(1);
-					}
-					uniqueConstraintObject[column.uniqueName!] = {
-						name: column.uniqueName!,
-						nullsNotDistinct: column.uniqueType === 'not distinct',
-						columns: [columnToSet.name],
-					};
-				}
-
-				if (column.default !== undefined) {
-					if (is(column.default, SQL)) {
-						columnToSet.default = sqlToStr(column.default, casing);
-					} else {
-						if (typeof column.default === 'string') {
-							columnToSet.default = `'${column.default}'`;
-						} else {
-							if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
-								columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-							} else if (column.default instanceof Date) {
-								if (sqlTypeLowered === 'date') {
-									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-								} else if (sqlTypeLowered === 'timestamp') {
-									columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
-								} else {
-									columnToSet.default = `'${column.default.toISOString()}'`;
-								}
-							} else if (Array.isArray(column.default)) {
-								columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
-							} else {
-								// Should do for all types
-								// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
-								columnToSet.default = column.default;
-							}
-						}
-					}
-				}
-				columnsObject[column.name] = columnToSet;
-			}
-		}
-
-		resultViews[viewKey] = {
-			columns: columnsObject,
-			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
-			name: viewName,
-			schema: viewSchema,
-			isExisting,
-			with: withOption,
-			withNoData,
-			materialized,
-			tablespace,
-			using,
-		};
-	}
-
-	// const enumsToReturn: Record<string, Enum> = enums.reduce<{
-	// 	[key: string]: Enum;
-	// }>((map, obj) => {
-	// 	const enumSchema = obj.schema || 'public';
-	// 	const key = `${enumSchema}.${obj.enumName}`;
-	// 	map[key] = {
-	// 		name: obj.enumName,
-	// 		schema: enumSchema,
-	// 		values: obj.enumValues,
-	// 	};
-	// 	return map;
-	// }, {});
-
-	const schemasObject = Object.fromEntries(
-		schemas
-			.filter((it) => {
-				if (schemaFilter) {
-					return schemaFilter.includes(it.schemaName) && it.schemaName !== 'public';
-				} else {
-					return it.schemaName !== 'public';
-				}
-			})
-			.map((it) => [it.schemaName, it.schemaName]),
-	);
-
-	return {
-		version: '1',
-		dialect: 'gel',
-		tables: result,
-		enums: {},
-		schemas: schemasObject,
-		sequences: sequencesToReturn,
-		roles: rolesToReturn,
-		policies: policiesToReturn,
-		views: resultViews,
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	};
-};
-
-const trimChar = (str: string, char: string) => {
-	let start = 0;
-	let end = str.length;
-
-	while (start < end && str[start] === char) ++start;
-	while (end > start && str[end - 1] === char) --end;
-
-	// this.toString() due to ava deep equal issue with String { "value" }
-	return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
-};
-
-function prepareRoles(entities?: {
-	roles: boolean | {
-		provider?: string | undefined;
-		include?: string[] | undefined;
-		exclude?: string[] | undefined;
-	};
-}) {
-	let useRoles: boolean = false;
-	const includeRoles: string[] = [];
-	const excludeRoles: string[] = [];
-
-	if (entities && entities.roles) {
-		if (typeof entities.roles === 'object') {
-			if (entities.roles.provider) {
-				if (entities.roles.provider === 'supabase') {
-					excludeRoles.push(...[
-						'anon',
-						'authenticator',
-						'authenticated',
-						'service_role',
-						'supabase_auth_admin',
-						'supabase_storage_admin',
-						'dashboard_user',
-						'supabase_admin',
-					]);
-				} else if (entities.roles.provider === 'neon') {
-					excludeRoles.push(...['authenticated', 'anonymous']);
-				}
-			}
-			if (entities.roles.include) {
-				includeRoles.push(...entities.roles.include);
-			}
-			if (entities.roles.exclude) {
-				excludeRoles.push(...entities.roles.exclude);
-			}
-		} else {
-			useRoles = entities.roles;
-		}
-	}
-	return { useRoles, includeRoles, excludeRoles };
-}
-
-export const fromDatabase = async (
-	db: DB,
-	tablesFilter: (table: string) => boolean = () => true,
-	schemaFilters: string[],
-	entities?: {
-		roles: boolean | {
-			provider?: string | undefined;
-			include?: string[] | undefined;
-			exclude?: string[] | undefined;
-		};
-	},
-	progressCallback?: (
-		stage: IntrospectStage,
-		count: number,
-		status: IntrospectStatus,
-	) => void,
-	tsSchema?: GelSchemaInternal,
-): Promise<GelSchemaInternal> => {
-	const result: Record<string, Table> = {};
-	// const views: Record<string, View> = {};
-	const policies: Record<string, Policy> = {};
-	const internals: GelKitInternals = { tables: {} };
-
-	const where = schemaFilters.map((t) => `n.nspname = '${t}'`).join(' or ');
-
-	const allTables = await db.query<{ table_schema: string; table_name: string; type: string; rls_enabled: boolean }>(
-		`SELECT 
-    n.nspname::text AS table_schema, 
-    c.relname::text AS table_name, 
-    CASE 
-        WHEN c.relkind = 'r' THEN 'table'
-        WHEN c.relkind = 'v' THEN 'view'
-        WHEN c.relkind = 'm' THEN 'materialized_view'
-    END AS type,
-	c.relrowsecurity AS rls_enabled
-FROM 
-    pg_catalog.pg_class c
-JOIN 
-    pg_catalog.pg_namespace n ON n.oid::text = c.relnamespace::text
-WHERE 
-	c.relkind IN ('r', 'v', 'm') 
-    ${where === '' ? '' : ` AND ${where}`};`,
-	);
-
-	const schemas = new Set(allTables.map((it) => it.table_schema));
-
-	const allSchemas = await db.query<{
-		table_schema: string;
-	}>(`select s.nspname::text as table_schema
-  from pg_catalog.pg_namespace s
-  join pg_catalog.pg_user u on u.usesysid::text = s.nspowner::text
-  where nspname not in ('information_schema', 'pg_catalog', 'public')
-        and nspname::text not like 'pg_toast%'
-        and nspname::text not like 'pg_temp_%'
-  order by 1;`);
-
-	allSchemas.forEach((item) => {
-		if (schemaFilters.includes(item.table_schema)) {
-			schemas.add(item.table_schema);
-		}
-	});
-
-	let columnsCount = 0;
-	let indexesCount = 0;
-	let foreignKeysCount = 0;
-	let tableCount = 0;
-
-	const sequencesToReturn: Record<string, Sequence> = {};
-
-	const all = allTables
-		.filter((it) => it.type === 'table')
-		.map((row) => {
-			return new Promise(async (res, rej) => {
-				const tableName = row.table_name as string;
-				if (!tablesFilter(tableName)) return res('');
-				tableCount += 1;
-				const tableSchema = row.table_schema;
-
-				try {
-					const columnToReturn: Record<string, Column> = {};
-					const indexToReturn: Record<string, Index> = {};
-					const foreignKeysToReturn: Record<string, ForeignKey> = {};
-					const primaryKeys: Record<string, PrimaryKey> = {};
-					// const uniqueConstrains: Record<string, UniqueConstraint> = {};
-					// const checkConstraints: Record<string, CheckConstraint> = {};
-
-					const tableResponse = await getColumnsInfoQuery({ schema: tableSchema, table: tableName, db });
-
-					// 				const tableConstraints = await db.query(
-					// 					`SELECT c.column_name::text, c.data_type::text, constraint_type::text, constraint_name::text, constraint_schema::text
-					//   FROM information_schema.table_constraints tc
-					//   JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
-					//   JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
-					//     AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
-					//   WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`,
-					// 				);
-
-					// const tableChecks = await db.query(`SELECT
-					// 	tc.constraint_name::text,
-					// 	tc.constraint_type::text,
-					// 	pg_get_constraintdef(con.oid) AS constraint_definition
-					// FROM
-					// 	information_schema.table_constraints AS tc
-					// 	JOIN pg_constraint AS con
-					// 		ON tc.constraint_name = con.conname
-					// 		AND con.conrelid = (
-					// 			SELECT oid
-					// 			FROM pg_class
-					// 			WHERE relname = tc.table_name
-					// 			AND relnamespace = (
-					// 				SELECT oid
-					// 				FROM pg_namespace
-					// 				WHERE nspname = tc.constraint_schema
-					// 			)
-					// 		)
-					// WHERE
-					// 	tc.table_name = '${tableName}'
-					// 	AND tc.constraint_schema = '${tableSchema}'
-					// 	AND tc.constraint_type = 'CHECK';`);
-
-					columnsCount += tableResponse.length;
-					if (progressCallback) {
-						progressCallback('columns', columnsCount, 'fetching');
-					}
-
-					const tableForeignKeys = await db.query(
-						`SELECT
-					    con.contype::text AS constraint_type,
-					    nsp.nspname::text AS constraint_schema,
-					    con.conname::text AS constraint_name,
-					    rel.relname::text AS table_name,
-					    att.attname::text AS column_name,
-					    fnsp.nspname::text AS foreign_table_schema,
-					    frel.relname::text AS foreign_table_name,
-					    fatt.attname::text AS foreign_column_name,
-					    CASE con.confupdtype
-					      WHEN 'a' THEN 'NO ACTION'
-					      WHEN 'r' THEN 'RESTRICT'
-					      WHEN 'n' THEN 'SET NULL'
-					      WHEN 'c' THEN 'CASCADE'
-					      WHEN 'd' THEN 'SET DEFAULT'
-					    END AS update_rule,
-					    CASE con.confdeltype
-					      WHEN 'a' THEN 'NO ACTION'
-					      WHEN 'r' THEN 'RESTRICT'
-					      WHEN 'n' THEN 'SET NULL'
-					      WHEN 'c' THEN 'CASCADE'
-					      WHEN 'd' THEN 'SET DEFAULT'
-					    END AS delete_rule
-					  FROM
-					    pg_catalog.pg_constraint con
-					    JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
-					    JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
-					    LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
-					      AND att.attrelid = con.conrelid
-					    LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
-					    LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
-					    LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
-					      AND fatt.attrelid = con.confrelid
-					  WHERE
-					    nsp.nspname = '${tableSchema}'
-					    AND rel.relname = '${tableName}'
-					    AND con.contype IN ('f');`,
-					);
-
-					foreignKeysCount += tableForeignKeys.length;
-					if (progressCallback) {
-						progressCallback('fks', foreignKeysCount, 'fetching');
-					}
-					for (const fk of tableForeignKeys) {
-						// const tableFrom = fk.table_name;
-						const columnFrom: string = fk.column_name;
-						const tableTo = fk.foreign_table_name;
-						const columnTo: string = fk.foreign_column_name;
-						const schemaTo: string = fk.foreign_table_schema;
-						const foreignKeyName = fk.constraint_name;
-						const onUpdate = fk.update_rule?.toLowerCase();
-						const onDelete = fk.delete_rule?.toLowerCase();
-
-						if (typeof foreignKeysToReturn[foreignKeyName] !== 'undefined') {
-							foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
-							foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
-						} else {
-							foreignKeysToReturn[foreignKeyName] = {
-								name: foreignKeyName,
-								tableFrom: tableName,
-								tableTo,
-								schemaTo,
-								columnsFrom: [columnFrom],
-								columnsTo: [columnTo],
-								onDelete,
-								onUpdate,
-							};
-						}
-
-						foreignKeysToReturn[foreignKeyName].columnsFrom = [
-							...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom),
-						];
-
-						foreignKeysToReturn[foreignKeyName].columnsTo = [...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)];
-					}
-
-					// const uniqueConstrainsRows = tableConstraints.filter((mapRow) => mapRow.constraint_type === 'UNIQUE');
-
-					// for (const unqs of uniqueConstrainsRows) {
-					// 	// const tableFrom = fk.table_name;
-					// 	const columnName: string = unqs.column_name;
-					// 	const constraintName: string = unqs.constraint_name;
-
-					// 	if (typeof uniqueConstrains[constraintName] !== 'undefined') {
-					// 		uniqueConstrains[constraintName].columns.push(columnName);
-					// 	} else {
-					// 		uniqueConstrains[constraintName] = {
-					// 			columns: [columnName],
-					// 			nullsNotDistinct: false,
-					// 			name: constraintName,
-					// 		};
-					// 	}
-					// }
-
-					// checksCount += tableChecks.length;
-					// if (progressCallback) {
-					// 	progressCallback('checks', checksCount, 'fetching');
-					// }
-					// for (const checks of tableChecks) {
-					// 	// CHECK (((email)::text <> 'test@gmail.com'::text))
-					// 	// Where (email) is column in table
-					// 	let checkValue: string = checks.constraint_definition;
-					// 	const constraintName: string = checks.constraint_name;
-
-					// 	checkValue = checkValue.replace(/^CHECK\s*\(\(/, '').replace(/\)\)\s*$/, '');
-
-					// 	checkConstraints[constraintName] = {
-					// 		name: constraintName,
-					// 		value: checkValue,
-					// 	};
-					// }
-
-					for (const columnResponse of tableResponse) {
-						const columnName = columnResponse.column_name;
-						if (columnName === '__type__') continue;
-
-						const columnAdditionalDT = columnResponse.additional_dt;
-						const columnDimensions = columnResponse.array_dimensions;
-						const enumType: string = columnResponse.enum_name;
-						let columnType: string = columnResponse.data_type;
-						// const typeSchema = columnResponse.type_schema;
-						const defaultValueRes: string = columnResponse.column_default;
-
-						const isGenerated = columnResponse.is_generated === 'ALWAYS';
-						const generationExpression = columnResponse.generation_expression;
-						const isIdentity = columnResponse.is_identity === 'YES';
-						const identityGeneration = columnResponse.identity_generation === 'ALWAYS' ? 'always' : 'byDefault';
-						const identityStart = columnResponse.identity_start;
-						const identityIncrement = columnResponse.identity_increment;
-						const identityMaximum = columnResponse.identity_maximum;
-						const identityMinimum = columnResponse.identity_minimum;
-						const identityCycle = columnResponse.identity_cycle === 'YES';
-						const identityName = columnResponse.seq_name;
-
-						// const primaryKey = tableConstraints.filter((mapRow) =>
-						// 	columnName === mapRow.column_name && mapRow.constraint_type === 'PRIMARY KEY'
-						// );
-
-						// const cprimaryKey = tableConstraints.filter((mapRow) => mapRow.constraint_type === 'PRIMARY KEY');
-
-						// 			if (cprimaryKey.length > 1) {
-						// 				const tableCompositePkName = await db.query(
-						// 					`SELECT conname::text AS primary_key
-						// FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
-						// WHERE  contype = 'p'
-						// AND    connamespace = $1::regnamespace
-						// AND    pg_class.relname = $2;`,
-						// 					[tableSchema, tableName],
-						// 				);
-						// 				primaryKeys[tableCompositePkName[0].primary_key] = {
-						// 					name: tableCompositePkName[0].primary_key,
-						// 					columns: cprimaryKey.map((c: any) => c.column_name),
-						// 				};
-						// 			}
-
-						let columnTypeMapped = columnType;
-
-						// Set default to internal object
-						if (columnAdditionalDT === 'ARRAY') {
-							if (typeof internals.tables[tableName] === 'undefined') {
-								internals.tables[tableName] = {
-									columns: {
-										[columnName]: {
-											isArray: true,
-											dimensions: columnDimensions,
-											rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-										},
-									},
-								};
-							} else {
-								if (typeof internals.tables[tableName]!.columns[columnName] === 'undefined') {
-									internals.tables[tableName]!.columns[columnName] = {
-										isArray: true,
-										dimensions: columnDimensions,
-										rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-									};
-								}
-							}
-						}
-
-						const defaultValue = defaultForColumn(columnResponse, internals, tableName);
-						if (
-							defaultValue === 'NULL'
-							|| (defaultValueRes && defaultValueRes.startsWith('(') && defaultValueRes.endsWith(')'))
-						) {
-							if (typeof internals!.tables![tableName] === 'undefined') {
-								internals!.tables![tableName] = {
-									columns: {
-										[columnName]: {
-											isDefaultAnExpression: true,
-										},
-									},
-								};
-							} else {
-								if (typeof internals!.tables![tableName]!.columns[columnName] === 'undefined') {
-									internals!.tables![tableName]!.columns[columnName] = {
-										isDefaultAnExpression: true,
-									};
-								} else {
-									internals!.tables![tableName]!.columns[columnName]!.isDefaultAnExpression = true;
-								}
-							}
-						}
-
-						if (columnTypeMapped.startsWith('numeric(')) {
-							columnTypeMapped = columnTypeMapped.replace(',', ', ');
-						}
-
-						if (columnAdditionalDT === 'ARRAY') {
-							for (let i = 1; i < Number(columnDimensions); i++) {
-								columnTypeMapped += '[]';
-							}
-						}
-
-						// TODO check if correct
-						// skip range and tuples
-						if (columnTypeMapped.includes('tuple<') || columnTypeMapped.includes('range')) continue;
-
-						columnTypeMapped = trimChar(columnTypeMapped, '"');
-						columnTypeMapped = columnTypeMapped.replace('pg_catalog.', '');
-
-						// patching array types
-						columnTypeMapped = columnTypeMapped.replace('float4[]', 'real[]').replace('float8[]', 'double precision[]')
-							.replace('"numeric"[]', 'numeric[]').replace('"time"[]', 'time without time zone[]').replace(
-								'int2[]',
-								'smallint[]',
-							).replace(
-								'int4[]',
-								'integer[]',
-							).replace(
-								'int8[]',
-								'bigint[]',
-							).replace(
-								'bool[]',
-								'boolean[]',
-							);
-
-						columnToReturn[columnName] = {
-							name: columnName,
-							type:
-								// filter vectors, but in future we should filter any extension that was installed by user
-								columnAdditionalDT === 'USER-DEFINED'
-									&& !['vector', 'geometry'].includes(enumType)
-									? enumType
-									: columnTypeMapped,
-							typeSchema: undefined,
-							// typeSchema: enumsToReturn[`${typeSchema}.${enumType}`] !== undefined
-							// 	? enumsToReturn[`${typeSchema}.${enumType}`].schema
-							// 	: undefined,
-							primaryKey: columnName === 'id',
-							default: defaultValue,
-							notNull: columnResponse.is_nullable === 'NO',
-							generated: isGenerated
-								? { as: generationExpression, type: 'stored' }
-								: undefined,
-							identity: isIdentity
-								? {
-									type: identityGeneration,
-									name: identityName,
-									increment: stringFromDatabaseIdentityProperty(identityIncrement),
-									minValue: stringFromDatabaseIdentityProperty(identityMinimum),
-									maxValue: stringFromDatabaseIdentityProperty(identityMaximum),
-									startWith: stringFromDatabaseIdentityProperty(identityStart),
-									cache: sequencesToReturn[identityName]?.cache
-										? sequencesToReturn[identityName]?.cache
-										: sequencesToReturn[`${tableSchema}.${identityName}`]?.cache
-										? sequencesToReturn[`${tableSchema}.${identityName}`]?.cache
-										: undefined,
-									cycle: identityCycle,
-									schema: tableSchema,
-								}
-								: undefined,
-						};
-
-						if (identityName && typeof identityName === 'string') {
-							// remove "" from sequence name
-							delete sequencesToReturn[
-								`${tableSchema}.${
-									identityName.startsWith('"') && identityName.endsWith('"') ? identityName.slice(1, -1) : identityName
-								}`
-							];
-							delete sequencesToReturn[identityName];
-						}
-					}
-
-					const dbIndexes = await db.query(
-						`SELECT  DISTINCT ON (t.relname, ic.relname, k.i) t.relname::text as table_name, ic.relname::text AS indexname,
-        k.i AS index_order,
-        i.indisunique as is_unique,
-        am.amname::text as method,
-        ic.reloptions as with,
-        coalesce(a.attname,
-                  (('{' || pg_get_expr(
-                              i.indexprs,
-                              i.indrelid
-                          )
-                        || '}')::text[]
-                  )[k.i]
-                )::text AS column_name,
-          CASE
-        WHEN pg_get_expr(i.indexprs, i.indrelid) IS NOT NULL THEN 1
-        ELSE 0
-    END AS is_expression,
-        i.indoption[k.i-1] & 1 = 1 AS descending,
-        i.indoption[k.i-1] & 2 = 2 AS nulls_first,
-        pg_get_expr(
-                              i.indpred,
-                              i.indrelid
-                          ) as where,
-         opc.opcname::text
-      FROM pg_class t
-          LEFT JOIN pg_index i ON t.oid = i.indrelid
-          LEFT JOIN pg_class ic ON ic.oid = i.indexrelid
-		  CROSS JOIN LATERAL (SELECT unnest(i.indkey), generate_subscripts(i.indkey, 1) + 1) AS k(attnum, i)
-          LEFT JOIN pg_attribute AS a
-            ON i.indrelid = a.attrelid AND k.attnum = a.attnum
-          JOIN pg_namespace c on c.oid = t.relnamespace
-        LEFT JOIN pg_am AS am ON ic.relam = am.oid
-        JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
-      WHERE
-      c.nspname = '${tableSchema}' AND
-      t.relname = '${tableName}';`,
-					);
-
-					const dbIndexFromConstraint = await db.query(
-						`SELECT
-          idx.indexrelname::text AS index_name,
-          idx.relname::text AS table_name,
-          schemaname::text,
-          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
-        FROM
-          pg_stat_user_indexes idx
-        LEFT JOIN
-          pg_constraint con ON con.conindid = idx.indexrelid
-        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
-        group by index_name, table_name,schemaname, generated_by_constraint;`,
-					);
-
-					const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) =>
-						it.index_name
-					);
-
-					for (const dbIndex of dbIndexes) {
-						const indexName: string = dbIndex.indexname;
-						const indexColumnName: string = dbIndex.column_name;
-						const indexIsUnique = dbIndex.is_unique;
-						const indexMethod = dbIndex.method;
-						const indexWith: string[] = dbIndex.with;
-						const indexWhere: string = dbIndex.where;
-						const opclass: string = dbIndex.opcname;
-						const isExpression = dbIndex.is_expression === 1;
-
-						const desc: boolean = dbIndex.descending;
-						const nullsFirst: boolean = dbIndex.nulls_first;
-
-						const mappedWith: Record<string, string> = {};
-
-						if (indexWith !== null) {
-							indexWith
-								// .slice(1, indexWith.length - 1)
-								// .split(",")
-								.forEach((it) => {
-									const splitted = it.split('=');
-									mappedWith[splitted[0]] = splitted[1];
-								});
-						}
-
-						if (idxsInConsteraint.includes(indexName)) continue;
-
-						if (typeof indexToReturn[indexName] !== 'undefined') {
-							indexToReturn[indexName].columns.push({
-								expression: indexColumnName,
-								asc: !desc,
-								nulls: nullsFirst ? 'first' : 'last',
-								opclass,
-								isExpression,
-							});
-						} else {
-							indexToReturn[indexName] = {
-								name: indexName,
-								columns: [
-									{
-										expression: indexColumnName,
-										asc: !desc,
-										nulls: nullsFirst ? 'first' : 'last',
-										opclass,
-										isExpression,
-									},
-								],
-								isUnique: indexIsUnique,
-								// should not be a part of diff detects
-								concurrently: false,
-								method: indexMethod,
-								where: indexWhere === null ? undefined : indexWhere,
-								with: mappedWith,
-							};
-						}
-					}
-
-					indexesCount += Object.keys(indexToReturn).length;
-					if (progressCallback) {
-						progressCallback('indexes', indexesCount, 'fetching');
-					}
-					result[`${tableSchema}.${tableName}`] = {
-						name: tableName,
-						schema: tableSchema !== 'public' ? tableSchema : '',
-						columns: columnToReturn,
-						indexes: indexToReturn,
-						foreignKeys: foreignKeysToReturn,
-						compositePrimaryKeys: primaryKeys,
-						uniqueConstraints: {}, // uniqueConstrains,
-						checkConstraints: {}, // checkConstraints,
-						policies: {}, // policiesByTable[`${tableSchema}.${tableName}`] ?? {},
-						isRLSEnabled: row.rls_enabled,
-					};
-				} catch (e) {
-					rej(e);
-					return;
-				}
-				res('');
-			});
-		});
-
-	if (progressCallback) {
-		progressCallback('tables', tableCount, 'done');
-	}
-
-	for await (const _ of all) {
-	}
-
-	if (progressCallback) {
-		progressCallback('columns', columnsCount, 'done');
-		progressCallback('indexes', indexesCount, 'done');
-		progressCallback('fks', foreignKeysCount, 'done');
-	}
-
-	const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
-
-	return {
-		version: '1',
-		dialect: 'gel',
-		tables: result,
-		enums: {},
-		schemas: schemasObject,
-		sequences: sequencesToReturn,
-		roles: {}, // rolesToReturn,
-		policies,
-		views: {}, // views,
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-		internal: internals,
-	};
-};
-
-const defaultForColumn = (column: any, internals: GelKitInternals, tableName: string) => {
-	const columnName = column.column_name;
-	const isArray = internals?.tables[tableName]?.columns[columnName]?.isArray ?? false;
-
-	if (column.column_default === null || column.column_default === undefined) return undefined;
-
-	if (column.column_default.endsWith('[]')) {
-		column.column_default = column.column_default.slice(0, -2);
-	}
-
-	column.column_default = column.column_default.replace(/::(.*?)(?<![^\w"])(?=$)/, '');
-
-	const columnDefaultAsString: string = column.column_default.toString();
-
-	if (isArray) {
-		return columnDefaultAsString;
-	}
-
-	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(column.data_type)) {
-		if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString)) {
-			return Number(columnDefaultAsString);
-		} else {
-			if (typeof internals!.tables![tableName] === 'undefined') {
-				internals!.tables![tableName] = {
-					columns: {
-						[columnName]: {
-							isDefaultAnExpression: true,
-						},
-					},
-				};
-			} else {
-				if (typeof internals!.tables![tableName]!.columns[columnName] === 'undefined') {
-					internals!.tables![tableName]!.columns[columnName] = {
-						isDefaultAnExpression: true,
-					};
-				} else {
-					internals!.tables![tableName]!.columns[columnName]!.isDefaultAnExpression = true;
-				}
-			}
-			return columnDefaultAsString;
-		}
-	} else if (column.data_type.includes('numeric')) {
-		// if numeric(1,1) and used '99' -> psql stores like '99'::numeric
-		return columnDefaultAsString.includes("'") ? columnDefaultAsString : `'${columnDefaultAsString}'`;
-	} else if (column.data_type === 'json' || column.data_type === 'jsonb') {
-		return `'${columnDefaultAsString}'`;
-	} else if (column.data_type === 'boolean') {
-		return column.column_default === 'true';
-	} else if (columnDefaultAsString === 'NULL') {
-		return `NULL`;
-	} else if (columnDefaultAsString.startsWith("'") && columnDefaultAsString.endsWith("'")) {
-		return columnDefaultAsString;
-	} else {
-		return `${columnDefaultAsString.replace(/\\/g, '`\\')}`;
-	}
-};
-
-const getColumnsInfoQuery = ({ schema, table, db }: { schema: string; table: string; db: DB }) => {
-	return db.query(
-		`SELECT 
-    a.attrelid::regclass::text AS table_name,  -- Table, view, or materialized view name
-    a.attname::text AS column_name,   -- Column name
-    CASE 
-        WHEN NOT a.attisdropped THEN 
-            CASE 
-                WHEN a.attnotnull THEN 'NO'
-                ELSE 'YES'
-            END 
-        ELSE NULL 
-    END AS is_nullable,  -- NULL or NOT NULL constraint
-    a.attndims AS array_dimensions,  -- Array dimensions
-    CASE 
-        WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
-        AND EXISTS (
-            SELECT FROM pg_attrdef ad
-            WHERE ad.adrelid = a.attrelid 
-            AND ad.adnum = a.attnum 
-            AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
-                || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
-        )
-        THEN CASE a.atttypid
-            WHEN 'int'::regtype THEN 'serial'
-            WHEN 'int8'::regtype THEN 'bigserial'
-            WHEN 'int2'::regtype THEN 'smallserial'
-        END
-        ELSE format_type(a.atttypid, a.atttypmod)
-    END AS data_type,  -- Column data type
---    ns.nspname AS type_schema,  -- Schema name
-    c.column_default::text,  -- Column default value
-    c.data_type::text AS additional_dt,  -- Data type from information_schema
-    c.udt_name::text AS enum_name,  -- Enum type (if applicable)
-    c.is_generated::text,  -- Is it a generated column?
-    c.generation_expression::text,  -- Generation expression (if generated)
-    c.is_identity::text,  -- Is it an identity column?
-    c.identity_generation::text,  -- Identity generation strategy (ALWAYS or BY DEFAULT)
-    c.identity_start::text,  -- Start value of identity column
-    c.identity_increment::text,  -- Increment for identity column
-    c.identity_maximum::text,  -- Maximum value for identity column
-    c.identity_minimum::text,  -- Minimum value for identity column
-    c.identity_cycle::text,  -- Does the identity column cycle?
-    ns.nspname::text AS type_schema  -- Schema of the enum type
-FROM 
-    pg_attribute a
-JOIN 
-    pg_class cls ON cls.oid = a.attrelid  -- Join pg_class to get table/view/materialized view info
-JOIN 
-    pg_namespace ns ON ns.oid = cls.relnamespace  -- Join namespace to get schema info
-LEFT JOIN 
-    information_schema.columns c ON c.column_name = a.attname 
-        AND c.table_schema = ns.nspname 
-        AND c.table_name = cls.relname  -- Match schema and table/view name
-LEFT JOIN 
-    pg_type enum_t ON enum_t.oid = a.atttypid  -- Join to get the type info
-LEFT JOIN 
-    pg_namespace enum_ns ON enum_ns.oid = enum_t.typnamespace  -- Join to get the enum schema
-WHERE 
-    a.attnum > 0  -- Valid column numbers only
-    AND NOT a.attisdropped  -- Skip dropped columns
-    AND cls.relkind IN ('r', 'v', 'm')  -- Include regular tables ('r'), views ('v'), and materialized views ('m')
-    AND ns.nspname::text = '${schema}'  -- Filter by schema
-    AND cls.relname::text = '${table}'  -- Filter by table name
-ORDER BY 
-    a.attnum;  -- Order by column number`,
-	);
-};
diff --git a/drizzle-kit/src/serializer/index.ts b/drizzle-kit/src/serializer/index.ts
deleted file mode 100644
index d24afbab08..0000000000
--- a/drizzle-kit/src/serializer/index.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs';
-import * as glob from 'glob';
-import Path from 'path';
-import { CasingType } from 'src/cli/validations/common';
-import { error } from '../cli/views';
-import type { MySqlSchemaInternal } from './mysqlSchema';
-import type { PgSchemaInternal } from './pgSchema';
-import { SingleStoreSchemaInternal } from './singlestoreSchema';
-import type { SQLiteSchemaInternal } from './sqliteSchema';
-
-export const serializeMySql = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<MySqlSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	console.log(chalk.gray(`Reading schema files:\n${filenames.join('\n')}\n`));
-
-	const { prepareFromMySqlImports } = await import('./mysqlImports');
-	const { generateMySqlSnapshot } = await import('./mysqlSerializer');
-
-	const { tables, views } = await prepareFromMySqlImports(filenames);
-
-	return generateMySqlSnapshot(tables, views, casing);
-};
-
-export const serializePg = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-	schemaFilter?: string[],
-): Promise<PgSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	const { prepareFromPgImports } = await import('./pgImports');
-	const { generatePgSnapshot } = await import('./pgSerializer');
-
-	const { tables, enums, schemas, sequences, views, matViews, roles, policies } = await prepareFromPgImports(
-		filenames,
-	);
-
-	return generatePgSnapshot(tables, enums, schemas, sequences, roles, policies, views, matViews, casing, schemaFilter);
-};
-
-export const serializeSQLite = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<SQLiteSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	const { prepareFromSqliteImports } = await import('./sqliteImports');
-	const { generateSqliteSnapshot } = await import('./sqliteSerializer');
-	const { tables, views } = await prepareFromSqliteImports(filenames);
-	return generateSqliteSnapshot(tables, views, casing);
-};
-
-export const serializeSingleStore = async (
-	path: string | string[],
-	casing: CasingType | undefined,
-): Promise<SingleStoreSchemaInternal> => {
-	const filenames = prepareFilenames(path);
-
-	console.log(chalk.gray(`Reading schema files:\n${filenames.join('\n')}\n`));
-
-	const { prepareFromSingleStoreImports } = await import('./singlestoreImports');
-	const { generateSingleStoreSnapshot } = await import('./singlestoreSerializer');
-
-	const { tables /* views */ } = await prepareFromSingleStoreImports(filenames);
-
-	return generateSingleStoreSnapshot(tables, /* views, */ casing);
-};
-
-export const prepareFilenames = (path: string | string[]) => {
-	if (typeof path === 'string') {
-		path = [path];
-	}
-	const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
-
-	const result = path.reduce((result, cur) => {
-		const globbed = glob.sync(`${prefix}${cur}`);
-
-		globbed.forEach((it) => {
-			const fileName = fs.lstatSync(it).isDirectory() ? null : Path.resolve(it);
-
-			const filenames = fileName
-				? [fileName!]
-				: fs.readdirSync(it).map((file) => Path.join(Path.resolve(it), file));
-
-			filenames
-				.filter((file) => !fs.lstatSync(file).isDirectory())
-				.forEach((file) => result.add(file));
-		});
-
-		return result;
-	}, new Set<string>());
-	const res = [...result];
-
-	// TODO: properly handle and test
-	const errors = res.filter((it) => {
-		return !(
-			it.endsWith('.ts')
-			|| it.endsWith('.js')
-			|| it.endsWith('.cjs')
-			|| it.endsWith('.mjs')
-			|| it.endsWith('.mts')
-			|| it.endsWith('.cts')
-		);
-	});
-
-	// when schema: "./schema" and not "./schema.ts"
-	if (res.length === 0) {
-		console.log(
-			error(
-				`No schema files found for path config [${
-					path
-						.map((it) => `'${it}'`)
-						.join(', ')
-				}]`,
-			),
-		);
-		console.log(
-			error(
-				`If path represents a file - please make sure to use .ts or other extension in the path`,
-			),
-		);
-		process.exit(1);
-	}
-
-	return res;
-};
diff --git a/drizzle-kit/src/serializer/mysqlImports.ts b/drizzle-kit/src/serializer/mysqlImports.ts
deleted file mode 100644
index a8e8ead39d..0000000000
--- a/drizzle-kit/src/serializer/mysqlImports.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { is } from 'drizzle-orm';
-import { AnyMySqlTable, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
-import { safeRegister } from '../cli/commands/utils';
-
-export const prepareFromExports = (exports: Record<string, unknown>) => {
-	const tables: AnyMySqlTable[] = [];
-	const views: MySqlView[] = [];
-
-	const i0values = Object.values(exports);
-	i0values.forEach((t) => {
-		if (is(t, MySqlTable)) {
-			tables.push(t);
-		}
-
-		if (is(t, MySqlView)) {
-			views.push(t);
-		}
-	});
-
-	return { tables, views };
-};
-
-export const prepareFromMySqlImports = async (imports: string[]) => {
-	const tables: AnyMySqlTable[] = [];
-	const views: MySqlView[] = [];
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-		const i0: Record<string, unknown> = require(`${it}`);
-		const prepared = prepareFromExports(i0);
-
-		tables.push(...prepared.tables);
-		views.push(...prepared.views);
-	}
-	unregister();
-	return { tables: Array.from(new Set(tables)), views };
-};
diff --git a/drizzle-kit/src/serializer/mysqlSchema.ts b/drizzle-kit/src/serializer/mysqlSchema.ts
deleted file mode 100644
index 3a6fb91799..0000000000
--- a/drizzle-kit/src/serializer/mysqlSchema.ts
+++ /dev/null
@@ -1,423 +0,0 @@
-import { any, boolean, enum as enumType, literal, object, record, string, TypeOf, union } from 'zod';
-import { mapValues, originUUID } from '../global';
-
-// ------- V3 --------
-const index = object({
-	name: string(),
-	columns: string().array(),
-	isUnique: boolean(),
-	using: enumType(['btree', 'hash']).optional(),
-	algorithm: enumType(['default', 'inplace', 'copy']).optional(),
-	lock: enumType(['default', 'none', 'shared', 'exclusive']).optional(),
-}).strict();
-
-const fk = object({
-	name: string(),
-	tableFrom: string(),
-	columnsFrom: string().array(),
-	tableTo: string(),
-	columnsTo: string().array(),
-	onUpdate: string().optional(),
-	onDelete: string().optional(),
-}).strict();
-
-const column = object({
-	name: string(),
-	type: string(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	autoincrement: boolean().optional(),
-	default: any().optional(),
-	onUpdate: any().optional(),
-	generated: object({
-		type: enumType(['stored', 'virtual']),
-		as: string(),
-	}).optional(),
-}).strict();
-
-const tableV3 = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-}).strict();
-
-const compositePK = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const uniqueConstraint = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const checkConstraint = object({
-	name: string(),
-	value: string(),
-}).strict();
-
-const tableV4 = object({
-	name: string(),
-	schema: string().optional(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-}).strict();
-
-const table = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-	checkConstraint: record(string(), checkConstraint).default({}),
-}).strict();
-
-const viewMeta = object({
-	algorithm: enumType(['undefined', 'merge', 'temptable']),
-	sqlSecurity: enumType(['definer', 'invoker']),
-	withCheckOption: enumType(['local', 'cascaded']).optional(),
-}).strict();
-
-export const view = object({
-	name: string(),
-	columns: record(string(), column),
-	definition: string().optional(),
-	isExisting: boolean(),
-}).strict().merge(viewMeta);
-type SquasherViewMeta = Omit<TypeOf<typeof viewMeta>, 'definer'>;
-
-export const kitInternals = object({
-	tables: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({ isDefaultAnExpression: boolean().optional() }).optional(),
-			),
-		}).optional(),
-	).optional(),
-	indexes: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({ isExpression: boolean().optional() }).optional(),
-			),
-		}).optional(),
-	).optional(),
-}).optional();
-
-// use main dialect
-const dialect = literal('mysql');
-
-const schemaHash = object({
-	id: string(),
-	prevId: string(),
-});
-
-export const schemaInternalV3 = object({
-	version: literal('3'),
-	dialect: dialect,
-	tables: record(string(), tableV3),
-}).strict();
-
-export const schemaInternalV4 = object({
-	version: literal('4'),
-	dialect: dialect,
-	tables: record(string(), tableV4),
-	schemas: record(string(), string()),
-}).strict();
-
-export const schemaInternalV5 = object({
-	version: literal('5'),
-	dialect: dialect,
-	tables: record(string(), table),
-	schemas: record(string(), string()),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const schemaInternal = object({
-	version: literal('5'),
-	dialect: dialect,
-	tables: record(string(), table),
-	views: record(string(), view).default({}),
-	_meta: object({
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const schemaV3 = schemaInternalV3.merge(schemaHash);
-export const schemaV4 = schemaInternalV4.merge(schemaHash);
-export const schemaV5 = schemaInternalV5.merge(schemaHash);
-export const schema = schemaInternal.merge(schemaHash);
-
-const tableSquashedV4 = object({
-	name: string(),
-	schema: string().optional(),
-	columns: record(string(), column),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-}).strict();
-
-const tableSquashed = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()),
-	uniqueConstraints: record(string(), string()).default({}),
-	checkConstraints: record(string(), string()).default({}),
-}).strict();
-
-const viewSquashed = view.omit({
-	algorithm: true,
-	sqlSecurity: true,
-	withCheckOption: true,
-}).extend({ meta: string() });
-
-export const schemaSquashed = object({
-	version: literal('5'),
-	dialect: dialect,
-	tables: record(string(), tableSquashed),
-	views: record(string(), viewSquashed),
-}).strict();
-
-export const schemaSquashedV4 = object({
-	version: literal('4'),
-	dialect: dialect,
-	tables: record(string(), tableSquashedV4),
-	schemas: record(string(), string()),
-}).strict();
-
-export type Dialect = TypeOf<typeof dialect>;
-export type Column = TypeOf<typeof column>;
-export type Table = TypeOf<typeof table>;
-export type TableV4 = TypeOf<typeof tableV4>;
-export type MySqlSchema = TypeOf<typeof schema>;
-export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
-export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
-export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
-export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
-export type MySqlKitInternals = TypeOf<typeof kitInternals>;
-export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
-export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
-export type Index = TypeOf<typeof index>;
-export type ForeignKey = TypeOf<typeof fk>;
-export type PrimaryKey = TypeOf<typeof compositePK>;
-export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
-export type CheckConstraint = TypeOf<typeof checkConstraint>;
-export type View = TypeOf<typeof view>;
-export type ViewSquashed = TypeOf<typeof viewSquashed>;
-
-export const MySqlSquasher = {
-	squashIdx: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${idx.columns.join(',')};${idx.isUnique};${idx.using ?? ''};${idx.algorithm ?? ''};${
-			idx.lock ?? ''
-		}`;
-	},
-	unsquashIdx: (input: string): Index => {
-		const [name, columnsString, isUnique, using, algorithm, lock] = input.split(';');
-		const destructed = {
-			name,
-			columns: columnsString.split(','),
-			isUnique: isUnique === 'true',
-			using: using ? using : undefined,
-			algorithm: algorithm ? algorithm : undefined,
-			lock: lock ? lock : undefined,
-		};
-		return index.parse(destructed);
-	},
-	squashPK: (pk: PrimaryKey) => {
-		return `${pk.name};${pk.columns.join(',')}`;
-	},
-	unsquashPK: (pk: string): PrimaryKey => {
-		const splitted = pk.split(';');
-		return { name: splitted[0], columns: splitted[1].split(',') };
-	},
-	squashUnique: (unq: UniqueConstraint) => {
-		return `${unq.name};${unq.columns.join(',')}`;
-	},
-	unsquashUnique: (unq: string): UniqueConstraint => {
-		const [name, columns] = unq.split(';');
-		return { name, columns: columns.split(',') };
-	},
-	squashFK: (fk: ForeignKey) => {
-		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
-			fk.onUpdate ?? ''
-		};${fk.onDelete ?? ''}`;
-	},
-	unsquashFK: (input: string): ForeignKey => {
-		const [
-			name,
-			tableFrom,
-			columnsFromStr,
-			tableTo,
-			columnsToStr,
-			onUpdate,
-			onDelete,
-		] = input.split(';');
-
-		const result: ForeignKey = fk.parse({
-			name,
-			tableFrom,
-			columnsFrom: columnsFromStr.split(','),
-			tableTo,
-			columnsTo: columnsToStr.split(','),
-			onUpdate,
-			onDelete,
-		});
-		return result;
-	},
-	squashCheck: (input: CheckConstraint): string => {
-		return `${input.name};${input.value}`;
-	},
-	unsquashCheck: (input: string): CheckConstraint => {
-		const [name, value] = input.split(';');
-
-		return { name, value };
-	},
-	squashView: (view: View): string => {
-		return `${view.algorithm};${view.sqlSecurity};${view.withCheckOption}`;
-	},
-	unsquashView: (meta: string): SquasherViewMeta => {
-		const [algorithm, sqlSecurity, withCheckOption] = meta.split(';');
-		const toReturn = {
-			algorithm: algorithm,
-			sqlSecurity: sqlSecurity,
-			withCheckOption: withCheckOption !== 'undefined' ? withCheckOption : undefined,
-		};
-
-		return viewMeta.parse(toReturn);
-	},
-};
-
-export const squashMysqlSchemeV4 = (
-	json: MySqlSchemaV4,
-): MySqlSchemaSquashedV4 => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index) => {
-				return MySqlSquasher.squashIdx(index);
-			});
-
-			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
-				return MySqlSquasher.squashFK(fk);
-			});
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					schema: it[1].schema,
-					columns: it[1].columns,
-					indexes: squashedIndexes,
-					foreignKeys: squashedFKs,
-				},
-			];
-		}),
-	);
-	return {
-		version: '4',
-		dialect: json.dialect,
-		tables: mappedTables,
-		schemas: json.schemas,
-	};
-};
-
-export const squashMysqlScheme = (json: MySqlSchema): MySqlSchemaSquashed => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index) => {
-				return MySqlSquasher.squashIdx(index);
-			});
-
-			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
-				return MySqlSquasher.squashFK(fk);
-			});
-
-			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-				return MySqlSquasher.squashPK(pk);
-			});
-
-			const squashedUniqueConstraints = mapValues(
-				it[1].uniqueConstraints,
-				(unq) => {
-					return MySqlSquasher.squashUnique(unq);
-				},
-			);
-
-			const squashedCheckConstraints = mapValues(it[1].checkConstraint, (check) => {
-				return MySqlSquasher.squashCheck(check);
-			});
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					columns: it[1].columns,
-					indexes: squashedIndexes,
-					foreignKeys: squashedFKs,
-					compositePrimaryKeys: squashedPKs,
-					uniqueConstraints: squashedUniqueConstraints,
-					checkConstraints: squashedCheckConstraints,
-				},
-			];
-		}),
-	);
-
-	const mappedViews = Object.fromEntries(
-		Object.entries(json.views).map(([key, value]) => {
-			const meta = MySqlSquasher.squashView(value);
-
-			return [key, {
-				name: value.name,
-				isExisting: value.isExisting,
-				columns: value.columns,
-				definition: value.definition,
-				meta,
-			}];
-		}),
-	);
-
-	return {
-		version: '5',
-		dialect: json.dialect,
-		tables: mappedTables,
-		views: mappedViews,
-	};
-};
-
-export const mysqlSchema = schema;
-export const mysqlSchemaV3 = schemaV3;
-export const mysqlSchemaV4 = schemaV4;
-export const mysqlSchemaV5 = schemaV5;
-export const mysqlSchemaSquashed = schemaSquashed;
-
-// no prev version
-export const backwardCompatibleMysqlSchema = union([mysqlSchemaV5, schema]);
-
-export const dryMySql = mysqlSchema.parse({
-	version: '5',
-	dialect: 'mysql',
-	id: originUUID,
-	prevId: '',
-	tables: {},
-	schemas: {},
-	views: {},
-	_meta: {
-		schemas: {},
-		tables: {},
-		columns: {},
-	},
-});
diff --git a/drizzle-kit/src/serializer/mysqlSerializer.ts b/drizzle-kit/src/serializer/mysqlSerializer.ts
deleted file mode 100644
index aaa1acb823..0000000000
--- a/drizzle-kit/src/serializer/mysqlSerializer.ts
+++ /dev/null
@@ -1,999 +0,0 @@
-import chalk from 'chalk';
-import { getTableName, is, SQL } from 'drizzle-orm';
-import {
-	AnyMySqlTable,
-	getTableConfig,
-	getViewConfig,
-	MySqlColumn,
-	MySqlDialect,
-	MySqlView,
-	type PrimaryKey as PrimaryKeyORM,
-	uniqueKeyName,
-} from 'drizzle-orm/mysql-core';
-import { RowDataPacket } from 'mysql2/promise';
-import { CasingType } from 'src/cli/validations/common';
-import { withStyle } from '../cli/validations/outputs';
-import { IntrospectStage, IntrospectStatus } from '../cli/views';
-import {
-	CheckConstraint,
-	Column,
-	ForeignKey,
-	Index,
-	MySqlKitInternals,
-	MySqlSchemaInternal,
-	PrimaryKey,
-	Table,
-	UniqueConstraint,
-	View,
-} from '../serializer/mysqlSchema';
-import { type DB, escapeSingleQuotes } from '../utils';
-import { getColumnCasing, sqlToStr } from './utils';
-
-export const indexName = (tableName: string, columns: string[]) => {
-	return `${tableName}_${columns.join('_')}_index`;
-};
-
-const handleEnumType = (type: string) => {
-	let str = type.split('(')[1];
-	str = str.substring(0, str.length - 1);
-	const values = str.split(',').map((v) => `'${escapeSingleQuotes(v.substring(1, v.length - 1))}'`);
-	return `enum(${values.join(',')})`;
-};
-
-export const generateMySqlSnapshot = (
-	tables: AnyMySqlTable[],
-	views: MySqlView[],
-	casing: CasingType | undefined,
-): MySqlSchemaInternal => {
-	const dialect = new MySqlDialect({ casing });
-	const result: Record<string, Table> = {};
-	const resultViews: Record<string, View> = {};
-	const internal: MySqlKitInternals = { tables: {}, indexes: {} };
-
-	for (const table of tables) {
-		const {
-			name: tableName,
-			columns,
-			indexes,
-			foreignKeys,
-			schema,
-			checks,
-			primaryKeys,
-			uniqueConstraints,
-		} = getTableConfig(table);
-
-		const columnsObject: Record<string, Column> = {};
-		const indexesObject: Record<string, Index> = {};
-		const foreignKeysObject: Record<string, ForeignKey> = {};
-		const primaryKeysObject: Record<string, PrimaryKey> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-		const checkConstraintObject: Record<string, CheckConstraint> = {};
-
-		// this object will help to identify same check names
-		let checksInTable: Record<string, string[]> = {};
-
-		columns.forEach((column) => {
-			const name = getColumnCasing(column, casing);
-			const notNull: boolean = column.notNull;
-			const sqlType = column.getSQLType();
-			const sqlTypeLowered = sqlType.toLowerCase();
-			const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
-				? false
-				: (column as any).autoIncrement;
-
-			const generated = column.generated;
-
-			const columnToSet: Column = {
-				name,
-				type: sqlType.startsWith('enum') ? handleEnumType(sqlType) : sqlType,
-				primaryKey: false,
-				// If field is autoincrement it's notNull by default
-				// notNull: autoIncrement ? true : notNull,
-				notNull,
-				autoincrement: autoIncrement,
-				onUpdate: (column as any).hasOnUpdateNow,
-				generated: generated
-					? {
-						as: is(generated.as, SQL)
-							? dialect.sqlToQuery(generated.as as SQL).sql
-							: typeof generated.as === 'function'
-							? dialect.sqlToQuery(generated.as() as SQL).sql
-							: (generated.as as any),
-						type: generated.mode ?? 'stored',
-					}
-					: undefined,
-			};
-
-			if (column.primary) {
-				primaryKeysObject[`${tableName}_${name}`] = {
-					name: `${tableName}_${name}`,
-					columns: [name],
-				};
-			}
-
-			if (column.isUnique) {
-				const existingUnique = uniqueConstraintObject[column.uniqueName!];
-				if (typeof existingUnique !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. 
-          The unique constraint ${
-								chalk.underline.blue(
-									column.uniqueName,
-								)
-							} on the ${
-								chalk.underline.blue(
-									name,
-								)
-							} column is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`)
-						}`,
-					);
-					process.exit(1);
-				}
-				uniqueConstraintObject[column.uniqueName!] = {
-					name: column.uniqueName!,
-					columns: [columnToSet.name],
-				};
-			}
-
-			if (column.default !== undefined) {
-				if (is(column.default, SQL)) {
-					columnToSet.default = sqlToStr(column.default, casing);
-				} else {
-					if (typeof column.default === 'string') {
-						columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
-					} else {
-						if (sqlTypeLowered === 'json') {
-							columnToSet.default = `'${JSON.stringify(column.default)}'`;
-						} else if (column.default instanceof Date) {
-							if (sqlTypeLowered === 'date') {
-								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-							} else if (
-								sqlTypeLowered.startsWith('datetime')
-								|| sqlTypeLowered.startsWith('timestamp')
-							) {
-								columnToSet.default = `'${
-									column.default
-										.toISOString()
-										.replace('T', ' ')
-										.slice(0, 23)
-								}'`;
-							}
-						} else {
-							columnToSet.default = column.default;
-						}
-					}
-					if (['blob', 'text', 'json'].includes(column.getSQLType())) {
-						columnToSet.default = `(${columnToSet.default})`;
-					}
-				}
-			}
-			columnsObject[name] = columnToSet;
-		});
-
-		primaryKeys.map((pk: PrimaryKeyORM) => {
-			const originalColumnNames = pk.columns.map((c) => c.name);
-			const columnNames = pk.columns.map((c: any) => getColumnCasing(c, casing));
-
-			let name = pk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnNames.length; i++) {
-					name = name.replace(originalColumnNames[i], columnNames[i]);
-				}
-			}
-
-			primaryKeysObject[name] = {
-				name,
-				columns: columnNames,
-			};
-
-			// all composite pk's should be treated as notNull
-			for (const column of pk.columns) {
-				columnsObject[getColumnCasing(column, casing)].notNull = true;
-			}
-		});
-
-		uniqueConstraints?.map((unq) => {
-			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
-
-			const name = unq.name ?? uniqueKeyName(table, columnNames);
-
-			const existingUnique = uniqueConstraintObject[name];
-			if (typeof existingUnique !== 'undefined') {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. \nThe unique constraint ${
-								chalk.underline.blue(
-									name,
-								)
-							} on the ${
-								chalk.underline.blue(
-									columnNames.join(','),
-								)
-							} columns is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			uniqueConstraintObject[name] = {
-				name: unq.name!,
-				columns: columnNames,
-			};
-		});
-
-		const fks: ForeignKey[] = foreignKeys.map((fk) => {
-			const tableFrom = tableName;
-			const onDelete = fk.onDelete ?? 'no action';
-			const onUpdate = fk.onUpdate ?? 'no action';
-			const reference = fk.reference();
-
-			const referenceFT = reference.foreignTable;
-
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-			const tableTo = getTableName(referenceFT);
-
-			const originalColumnsFrom = reference.columns.map((it) => it.name);
-			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
-			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
-			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
-
-			let name = fk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnsFrom.length; i++) {
-					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
-				}
-				for (let i = 0; i < originalColumnsTo.length; i++) {
-					name = name.replace(originalColumnsTo[i], columnsTo[i]);
-				}
-			}
-
-			return {
-				name,
-				tableFrom,
-				tableTo,
-				columnsFrom,
-				columnsTo,
-				onDelete,
-				onUpdate,
-			} as ForeignKey;
-		});
-
-		fks.forEach((it) => {
-			foreignKeysObject[it.name] = it;
-		});
-
-		indexes.forEach((value) => {
-			const columns = value.config.columns;
-			const name = value.config.name;
-
-			let indexColumns = columns.map((it) => {
-				if (is(it, SQL)) {
-					const sql = dialect.sqlToQuery(it, 'indexes').sql;
-					if (typeof internal!.indexes![name] === 'undefined') {
-						internal!.indexes![name] = {
-							columns: {
-								[sql]: {
-									isExpression: true,
-								},
-							},
-						};
-					} else {
-						if (typeof internal!.indexes![name]?.columns[sql] === 'undefined') {
-							internal!.indexes![name]!.columns[sql] = {
-								isExpression: true,
-							};
-						} else {
-							internal!.indexes![name]!.columns[sql]!.isExpression = true;
-						}
-					}
-					return sql;
-				} else {
-					return `${getColumnCasing(it, casing)}`;
-				}
-			});
-
-			if (value.config.unique) {
-				if (typeof uniqueConstraintObject[name] !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated unique constraint names in ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table. \nThe unique index ${
-									chalk.underline.blue(
-										name,
-									)
-								} on the ${
-									chalk.underline.blue(
-										indexColumns.join(','),
-									)
-								} columns is confilcting with a unique constraint name already defined for ${
-									chalk.underline.blue(
-										uniqueConstraintObject[name].columns.join(','),
-									)
-								} columns\n`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-			} else {
-				if (typeof foreignKeysObject[name] !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`In MySQL, when creating a foreign key, an index is automatically generated with the same name as the foreign key constraint.\n\nWe have encountered a collision between the index name on columns ${
-									chalk.underline.blue(
-										indexColumns.join(','),
-									)
-								} and the foreign key on columns ${
-									chalk.underline.blue(
-										foreignKeysObject[name].columnsFrom.join(','),
-									)
-								}. Please change either the index name or the foreign key name. For more information, please refer to https://dev.mysql.com/doc/refman/8.0/en/constraint-foreign-key.html\n
-            `,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-			}
-
-			indexesObject[name] = {
-				name,
-				columns: indexColumns,
-				isUnique: value.config.unique ?? false,
-				using: value.config.using,
-				algorithm: value.config.algorythm,
-				lock: value.config.lock,
-			};
-		});
-
-		checks.forEach((check) => {
-			check;
-			const checkName = check.name;
-			if (typeof checksInTable[tableName] !== 'undefined') {
-				if (checksInTable[tableName].includes(check.name)) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated check constraint name in ${
-									chalk.underline.blue(
-										tableName,
-									)
-								}. Please rename your check constraint in the ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				checksInTable[tableName].push(checkName);
-			} else {
-				checksInTable[tableName] = [check.name];
-			}
-
-			checkConstraintObject[checkName] = {
-				name: checkName,
-				value: dialect.sqlToQuery(check.value).sql,
-			};
-		});
-
-		// only handle tables without schemas
-		if (!schema) {
-			result[tableName] = {
-				name: tableName,
-				columns: columnsObject,
-				indexes: indexesObject,
-				foreignKeys: foreignKeysObject,
-				compositePrimaryKeys: primaryKeysObject,
-				uniqueConstraints: uniqueConstraintObject,
-				checkConstraint: checkConstraintObject,
-			};
-		}
-	}
-
-	for (const view of views) {
-		const {
-			isExisting,
-			name,
-			query,
-			schema,
-			selectedFields,
-			algorithm,
-			sqlSecurity,
-			withCheckOption,
-		} = getViewConfig(view);
-
-		const columnsObject: Record<string, Column> = {};
-
-		const existingView = resultViews[name];
-		if (typeof existingView !== 'undefined') {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated view name across ${
-							chalk.underline.blue(
-								schema ?? 'public',
-							)
-						} schema. Please rename your view`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		for (const key in selectedFields) {
-			if (is(selectedFields[key], MySqlColumn)) {
-				const column = selectedFields[key];
-
-				const notNull: boolean = column.notNull;
-				const sqlTypeLowered = column.getSQLType().toLowerCase();
-				const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
-					? false
-					: (column as any).autoIncrement;
-
-				const generated = column.generated;
-
-				const columnToSet: Column = {
-					name: column.name,
-					type: column.getSQLType(),
-					primaryKey: false,
-					// If field is autoincrement it's notNull by default
-					// notNull: autoIncrement ? true : notNull,
-					notNull,
-					autoincrement: autoIncrement,
-					onUpdate: (column as any).hasOnUpdateNow,
-					generated: generated
-						? {
-							as: is(generated.as, SQL)
-								? dialect.sqlToQuery(generated.as as SQL).sql
-								: typeof generated.as === 'function'
-								? dialect.sqlToQuery(generated.as() as SQL).sql
-								: (generated.as as any),
-							type: generated.mode ?? 'stored',
-						}
-						: undefined,
-				};
-
-				if (column.default !== undefined) {
-					if (is(column.default, SQL)) {
-						columnToSet.default = sqlToStr(column.default, casing);
-					} else {
-						if (typeof column.default === 'string') {
-							columnToSet.default = `'${column.default}'`;
-						} else {
-							if (sqlTypeLowered === 'json') {
-								columnToSet.default = `'${JSON.stringify(column.default)}'`;
-							} else if (column.default instanceof Date) {
-								if (sqlTypeLowered === 'date') {
-									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-								} else if (
-									sqlTypeLowered.startsWith('datetime')
-									|| sqlTypeLowered.startsWith('timestamp')
-								) {
-									columnToSet.default = `'${
-										column.default
-											.toISOString()
-											.replace('T', ' ')
-											.slice(0, 23)
-									}'`;
-								}
-							} else {
-								columnToSet.default = column.default;
-							}
-						}
-						if (['blob', 'text', 'json'].includes(column.getSQLType())) {
-							columnToSet.default = `(${columnToSet.default})`;
-						}
-					}
-				}
-				columnsObject[column.name] = columnToSet;
-			}
-		}
-
-		resultViews[name] = {
-			columns: columnsObject,
-			name,
-			isExisting,
-			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
-			withCheckOption,
-			algorithm: algorithm ?? 'undefined', // set default values
-			sqlSecurity: sqlSecurity ?? 'definer', // set default values
-		};
-	}
-
-	return {
-		version: '5',
-		dialect: 'mysql',
-		tables: result,
-		views: resultViews,
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-		internal,
-	};
-};
-
-function clearDefaults(defaultValue: any, collate: string) {
-	if (typeof collate === 'undefined' || collate === null) {
-		collate = `utf8mb4`;
-	}
-
-	let resultDefault = defaultValue;
-	collate = `_${collate}`;
-	if (defaultValue.startsWith(collate)) {
-		resultDefault = resultDefault
-			.substring(collate.length, defaultValue.length)
-			.replace(/\\/g, '');
-		if (resultDefault.startsWith("'") && resultDefault.endsWith("'")) {
-			return `('${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}')`;
-		} else {
-			return `'${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}'`;
-		}
-	} else {
-		return `(${resultDefault})`;
-	}
-}
-
-export const fromDatabase = async (
-	db: DB,
-	inputSchema: string,
-	tablesFilter: (table: string) => boolean = (table) => true,
-	progressCallback?: (
-		stage: IntrospectStage,
-		count: number,
-		status: IntrospectStatus,
-	) => void,
-): Promise<MySqlSchemaInternal> => {
-	const result: Record<string, Table> = {};
-	const internals: MySqlKitInternals = { tables: {}, indexes: {} };
-
-	const columns = await db.query(`select * from information_schema.columns
-	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
-	order by table_name, ordinal_position;`);
-
-	const response = columns as RowDataPacket[];
-
-	const schemas: string[] = [];
-
-	let columnsCount = 0;
-	let tablesCount = new Set();
-	let indexesCount = 0;
-	let foreignKeysCount = 0;
-	let checksCount = 0;
-	let viewsCount = 0;
-
-	const idxs = await db.query(
-		`select * from INFORMATION_SCHEMA.STATISTICS
-	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${inputSchema}' and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`,
-	);
-
-	const idxRows = idxs as RowDataPacket[];
-
-	for (const column of response) {
-		if (!tablesFilter(column['TABLE_NAME'] as string)) continue;
-
-		columnsCount += 1;
-		if (progressCallback) {
-			progressCallback('columns', columnsCount, 'fetching');
-		}
-		const schema: string = column['TABLE_SCHEMA'];
-		const tableName = column['TABLE_NAME'];
-
-		tablesCount.add(`${schema}.${tableName}`);
-		if (progressCallback) {
-			progressCallback('columns', tablesCount.size, 'fetching');
-		}
-		const columnName: string = column['COLUMN_NAME'];
-		const isNullable = column['IS_NULLABLE'] === 'YES'; // 'YES', 'NO'
-		const dataType = column['DATA_TYPE']; // varchar
-		const columnType = column['COLUMN_TYPE']; // varchar(256)
-		const isPrimary = column['COLUMN_KEY'] === 'PRI'; // 'PRI', ''
-		const columnDefault: string = column['COLUMN_DEFAULT'];
-		const collation: string = column['CHARACTER_SET_NAME'];
-		const geenratedExpression: string = column['GENERATION_EXPRESSION'];
-
-		let columnExtra = column['EXTRA'];
-		let isAutoincrement = false; // 'auto_increment', ''
-		let isDefaultAnExpression = false; // 'auto_increment', ''
-
-		if (typeof column['EXTRA'] !== 'undefined') {
-			columnExtra = column['EXTRA'];
-			isAutoincrement = column['EXTRA'] === 'auto_increment'; // 'auto_increment', ''
-			isDefaultAnExpression = column['EXTRA'].includes('DEFAULT_GENERATED'); // 'auto_increment', ''
-		}
-
-		// if (isPrimary) {
-		//   if (typeof tableToPk[tableName] === "undefined") {
-		//     tableToPk[tableName] = [columnName];
-		//   } else {
-		//     tableToPk[tableName].push(columnName);
-		//   }
-		// }
-
-		if (schema !== inputSchema) {
-			schemas.push(schema);
-		}
-
-		const table = result[tableName];
-
-		// let changedType = columnType.replace("bigint unsigned", "serial")
-		let changedType = columnType;
-
-		if (columnType === 'bigint unsigned' && !isNullable && isAutoincrement) {
-			// check unique here
-			const uniqueIdx = idxRows.filter(
-				(it) =>
-					it['COLUMN_NAME'] === columnName
-					&& it['TABLE_NAME'] === tableName
-					&& it['NON_UNIQUE'] === 0,
-			);
-			if (uniqueIdx && uniqueIdx.length === 1) {
-				changedType = columnType.replace('bigint unsigned', 'serial');
-			}
-		}
-
-		if (columnType.includes('decimal(10,0)')) {
-			changedType = columnType.replace('decimal(10,0)', 'decimal');
-		}
-
-		let onUpdate: boolean | undefined = undefined;
-		if (
-			columnType.startsWith('timestamp')
-			&& typeof columnExtra !== 'undefined'
-			&& columnExtra.includes('on update CURRENT_TIMESTAMP')
-		) {
-			onUpdate = true;
-		}
-
-		const newColumn: Column = {
-			default: columnDefault === null || columnDefault === undefined
-				? undefined
-				: /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault)
-						&& !['decimal', 'char', 'varchar'].some((type) => columnType.startsWith(type))
-				? Number(columnDefault)
-				: isDefaultAnExpression
-				? clearDefaults(columnDefault, collation)
-				: `'${escapeSingleQuotes(columnDefault)}'`,
-			autoincrement: isAutoincrement,
-			name: columnName,
-			type: changedType,
-			primaryKey: false,
-			notNull: !isNullable,
-			onUpdate,
-			generated: geenratedExpression
-				? {
-					as: geenratedExpression,
-					type: columnExtra === 'VIRTUAL GENERATED' ? 'virtual' : 'stored',
-				}
-				: undefined,
-		};
-
-		// Set default to internal object
-		if (isDefaultAnExpression) {
-			if (typeof internals!.tables![tableName] === 'undefined') {
-				internals!.tables![tableName] = {
-					columns: {
-						[columnName]: {
-							isDefaultAnExpression: true,
-						},
-					},
-				};
-			} else {
-				if (
-					typeof internals!.tables![tableName]!.columns[columnName]
-						=== 'undefined'
-				) {
-					internals!.tables![tableName]!.columns[columnName] = {
-						isDefaultAnExpression: true,
-					};
-				} else {
-					internals!.tables![tableName]!.columns[
-						columnName
-					]!.isDefaultAnExpression = true;
-				}
-			}
-		}
-
-		if (!table) {
-			result[tableName] = {
-				name: tableName,
-				columns: {
-					[columnName]: newColumn,
-				},
-				compositePrimaryKeys: {},
-				indexes: {},
-				foreignKeys: {},
-				uniqueConstraints: {},
-				checkConstraint: {},
-			};
-		} else {
-			result[tableName]!.columns[columnName] = newColumn;
-		}
-	}
-
-	const tablePks = await db.query(
-		`SELECT table_name, column_name, ordinal_position
-  FROM information_schema.table_constraints t
-  LEFT JOIN information_schema.key_column_usage k
-  USING(constraint_name,table_schema,table_name)
-  WHERE t.constraint_type='PRIMARY KEY'
-      and table_name != '__drizzle_migrations'
-      AND t.table_schema = '${inputSchema}'
-      ORDER BY ordinal_position`,
-	);
-
-	const tableToPk: { [tname: string]: string[] } = {};
-
-	const tableToPkRows = tablePks as RowDataPacket[];
-	for (const tableToPkRow of tableToPkRows) {
-		const tableName: string = tableToPkRow['TABLE_NAME'];
-		const columnName: string = tableToPkRow['COLUMN_NAME'];
-		const position: string = tableToPkRow['ordinal_position'];
-
-		if (typeof result[tableName] === 'undefined') {
-			continue;
-		}
-
-		if (typeof tableToPk[tableName] === 'undefined') {
-			tableToPk[tableName] = [columnName];
-		} else {
-			tableToPk[tableName].push(columnName);
-		}
-	}
-
-	for (const [key, value] of Object.entries(tableToPk)) {
-		// if (value.length > 1) {
-		result[key].compositePrimaryKeys = {
-			[`${key}_${value.join('_')}`]: {
-				name: `${key}_${value.join('_')}`,
-				columns: value,
-			},
-		};
-		// } else if (value.length === 1) {
-		// result[key].columns[value[0]].primaryKey = true;
-		// } else {
-		// }
-	}
-	if (progressCallback) {
-		progressCallback('columns', columnsCount, 'done');
-		progressCallback('tables', tablesCount.size, 'done');
-	}
-	try {
-		const fks = await db.query(
-			`SELECT 
-      kcu.TABLE_SCHEMA,
-      kcu.TABLE_NAME,
-      kcu.CONSTRAINT_NAME,
-      kcu.COLUMN_NAME,
-      kcu.REFERENCED_TABLE_SCHEMA,
-      kcu.REFERENCED_TABLE_NAME,
-      kcu.REFERENCED_COLUMN_NAME,
-      rc.UPDATE_RULE,
-      rc.DELETE_RULE
-  FROM 
-      INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
-  LEFT JOIN 
-      information_schema.referential_constraints rc 
-      ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-  WHERE kcu.TABLE_SCHEMA = '${inputSchema}' AND kcu.CONSTRAINT_NAME != 'PRIMARY' 
-      AND kcu.REFERENCED_TABLE_NAME IS NOT NULL;`,
-		);
-
-		const fkRows = fks as RowDataPacket[];
-
-		for (const fkRow of fkRows) {
-			foreignKeysCount += 1;
-			if (progressCallback) {
-				progressCallback('fks', foreignKeysCount, 'fetching');
-			}
-			const tableSchema = fkRow['TABLE_SCHEMA'];
-			const tableName: string = fkRow['TABLE_NAME'];
-			const constraintName = fkRow['CONSTRAINT_NAME'];
-			const columnName: string = fkRow['COLUMN_NAME'];
-			const refTableSchema = fkRow['REFERENCED_TABLE_SCHEMA'];
-			const refTableName = fkRow['REFERENCED_TABLE_NAME'];
-			const refColumnName: string = fkRow['REFERENCED_COLUMN_NAME'];
-			const updateRule: string = fkRow['UPDATE_RULE'];
-			const deleteRule = fkRow['DELETE_RULE'];
-
-			const tableInResult = result[tableName];
-			if (typeof tableInResult === 'undefined') continue;
-
-			if (typeof tableInResult.foreignKeys[constraintName] !== 'undefined') {
-				tableInResult.foreignKeys[constraintName]!.columnsFrom.push(columnName);
-				tableInResult.foreignKeys[constraintName]!.columnsTo.push(
-					refColumnName,
-				);
-			} else {
-				tableInResult.foreignKeys[constraintName] = {
-					name: constraintName,
-					tableFrom: tableName,
-					tableTo: refTableName,
-					columnsFrom: [columnName],
-					columnsTo: [refColumnName],
-					onDelete: deleteRule?.toLowerCase(),
-					onUpdate: updateRule?.toLowerCase(),
-				};
-			}
-
-			tableInResult.foreignKeys[constraintName]!.columnsFrom = [
-				...new Set(tableInResult.foreignKeys[constraintName]!.columnsFrom),
-			];
-
-			tableInResult.foreignKeys[constraintName]!.columnsTo = [
-				...new Set(tableInResult.foreignKeys[constraintName]!.columnsTo),
-			];
-		}
-	} catch (e) {
-		// console.log(`Can't proccess foreign keys`);
-	}
-	if (progressCallback) {
-		progressCallback('fks', foreignKeysCount, 'done');
-	}
-
-	for (const idxRow of idxRows) {
-		const tableSchema = idxRow['TABLE_SCHEMA'];
-		const tableName = idxRow['TABLE_NAME'];
-		const constraintName = idxRow['INDEX_NAME'];
-		const columnName: string = idxRow['COLUMN_NAME'];
-		const isUnique = idxRow['NON_UNIQUE'] === 0;
-
-		const tableInResult = result[tableName];
-		if (typeof tableInResult === 'undefined') continue;
-
-		// if (tableInResult.columns[columnName].type === "serial") continue;
-
-		indexesCount += 1;
-		if (progressCallback) {
-			progressCallback('indexes', indexesCount, 'fetching');
-		}
-
-		if (isUnique) {
-			if (
-				typeof tableInResult.uniqueConstraints[constraintName] !== 'undefined'
-			) {
-				tableInResult.uniqueConstraints[constraintName]!.columns.push(
-					columnName,
-				);
-			} else {
-				tableInResult.uniqueConstraints[constraintName] = {
-					name: constraintName,
-					columns: [columnName],
-				};
-			}
-		} else {
-			// in MySQL FK creates index by default. Name of index is the same as fk constraint name
-			// so for introspect we will just skip it
-			if (typeof tableInResult.foreignKeys[constraintName] === 'undefined') {
-				if (typeof tableInResult.indexes[constraintName] !== 'undefined') {
-					tableInResult.indexes[constraintName]!.columns.push(columnName);
-				} else {
-					tableInResult.indexes[constraintName] = {
-						name: constraintName,
-						columns: [columnName],
-						isUnique: isUnique,
-					};
-				}
-			}
-		}
-	}
-
-	const views = await db.query(
-		`select * from INFORMATION_SCHEMA.VIEWS WHERE table_schema = '${inputSchema}';`,
-	);
-
-	const resultViews: Record<string, View> = {};
-
-	viewsCount = views.length;
-	if (progressCallback) {
-		progressCallback('views', viewsCount, 'fetching');
-	}
-	for await (const view of views) {
-		const viewName = view['TABLE_NAME'];
-		const definition = view['VIEW_DEFINITION'];
-
-		const withCheckOption = view['CHECK_OPTION'] === 'NONE' ? undefined : view['CHECK_OPTION'].toLowerCase();
-		const sqlSecurity = view['SECURITY_TYPE'].toLowerCase();
-
-		const [createSqlStatement] = await db.query(`SHOW CREATE VIEW \`${viewName}\`;`);
-		const algorithmMatch = createSqlStatement['Create View'].match(/ALGORITHM=([^ ]+)/);
-		const algorithm = algorithmMatch ? algorithmMatch[1].toLowerCase() : undefined;
-
-		const columns = result[viewName].columns;
-		delete result[viewName];
-
-		resultViews[viewName] = {
-			columns: columns,
-			isExisting: false,
-			name: viewName,
-			algorithm,
-			definition,
-			sqlSecurity,
-			withCheckOption,
-		};
-	}
-
-	if (progressCallback) {
-		progressCallback('indexes', indexesCount, 'done');
-		// progressCallback("enums", 0, "fetching");
-		progressCallback('enums', 0, 'done');
-		progressCallback('views', viewsCount, 'done');
-	}
-
-	const checkConstraints = await db.query(
-		`SELECT 
-    tc.table_name, 
-    tc.constraint_name, 
-    cc.check_clause
-FROM 
-    information_schema.table_constraints tc
-JOIN 
-    information_schema.check_constraints cc 
-    ON tc.constraint_name = cc.constraint_name
-WHERE 
-    tc.constraint_schema = '${inputSchema}'
-AND 
-    tc.constraint_type = 'CHECK';`,
-	);
-
-	checksCount += checkConstraints.length;
-	if (progressCallback) {
-		progressCallback('checks', checksCount, 'fetching');
-	}
-	for (const checkConstraintRow of checkConstraints) {
-		const constraintName = checkConstraintRow['CONSTRAINT_NAME'];
-		const constraintValue = checkConstraintRow['CHECK_CLAUSE'];
-		const tableName = checkConstraintRow['TABLE_NAME'];
-
-		const tableInResult = result[tableName];
-		// if (typeof tableInResult === 'undefined') continue;
-
-		tableInResult.checkConstraint[constraintName] = {
-			name: constraintName,
-			value: constraintValue,
-		};
-	}
-
-	if (progressCallback) {
-		progressCallback('checks', checksCount, 'done');
-	}
-
-	return {
-		version: '5',
-		dialect: 'mysql',
-		tables: result,
-		views: resultViews,
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-		internal: internals,
-	};
-};
diff --git a/drizzle-kit/src/serializer/pgImports.ts b/drizzle-kit/src/serializer/pgImports.ts
deleted file mode 100644
index 40e54616a1..0000000000
--- a/drizzle-kit/src/serializer/pgImports.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { is } from 'drizzle-orm';
-import {
-	AnyPgTable,
-	isPgEnum,
-	isPgMaterializedView,
-	isPgSequence,
-	isPgView,
-	PgEnum,
-	PgMaterializedView,
-	PgPolicy,
-	PgRole,
-	PgSchema,
-	PgSequence,
-	PgTable,
-	PgView,
-} from 'drizzle-orm/pg-core';
-import { safeRegister } from '../cli/commands/utils';
-
-export const prepareFromExports = (exports: Record<string, unknown>) => {
-	const tables: AnyPgTable[] = [];
-	const enums: PgEnum<any>[] = [];
-	const schemas: PgSchema[] = [];
-	const sequences: PgSequence[] = [];
-	const roles: PgRole[] = [];
-	const policies: PgPolicy[] = [];
-	const views: PgView[] = [];
-	const matViews: PgMaterializedView[] = [];
-
-	const i0values = Object.values(exports);
-	i0values.forEach((t) => {
-		if (isPgEnum(t)) {
-			enums.push(t);
-			return;
-		}
-		if (is(t, PgTable)) {
-			tables.push(t);
-		}
-
-		if (is(t, PgSchema)) {
-			schemas.push(t);
-		}
-
-		if (isPgView(t)) {
-			views.push(t);
-		}
-
-		if (isPgMaterializedView(t)) {
-			matViews.push(t);
-		}
-
-		if (isPgSequence(t)) {
-			sequences.push(t);
-		}
-
-		if (is(t, PgRole)) {
-			roles.push(t);
-		}
-
-		if (is(t, PgPolicy)) {
-			policies.push(t);
-		}
-	});
-
-	return { tables, enums, schemas, sequences, views, matViews, roles, policies };
-};
-
-export const prepareFromPgImports = async (imports: string[]) => {
-	const tables: AnyPgTable[] = [];
-	const enums: PgEnum<any>[] = [];
-	const schemas: PgSchema[] = [];
-	const sequences: PgSequence[] = [];
-	const views: PgView[] = [];
-	const roles: PgRole[] = [];
-	const policies: PgPolicy[] = [];
-	const matViews: PgMaterializedView[] = [];
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const prepared = prepareFromExports(i0);
-
-		tables.push(...prepared.tables);
-		enums.push(...prepared.enums);
-		schemas.push(...prepared.schemas);
-		sequences.push(...prepared.sequences);
-		views.push(...prepared.views);
-		matViews.push(...prepared.matViews);
-		roles.push(...prepared.roles);
-		policies.push(...prepared.policies);
-	}
-	unregister();
-
-	return { tables: Array.from(new Set(tables)), enums, schemas, sequences, views, matViews, roles, policies };
-};
diff --git a/drizzle-kit/src/serializer/pgSchema.ts b/drizzle-kit/src/serializer/pgSchema.ts
deleted file mode 100644
index d7604d645c..0000000000
--- a/drizzle-kit/src/serializer/pgSchema.ts
+++ /dev/null
@@ -1,886 +0,0 @@
-import { mapValues, originUUID, snapshotVersion } from '../global';
-
-import { any, array, boolean, enum as enumType, literal, number, object, record, string, TypeOf, union } from 'zod';
-
-const indexV2 = object({
-	name: string(),
-	columns: record(
-		string(),
-		object({
-			name: string(),
-		}),
-	),
-	isUnique: boolean(),
-}).strict();
-
-const columnV2 = object({
-	name: string(),
-	type: string(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	references: string().optional(),
-}).strict();
-
-const tableV2 = object({
-	name: string(),
-	columns: record(string(), columnV2),
-	indexes: record(string(), indexV2),
-}).strict();
-
-const enumSchemaV1 = object({
-	name: string(),
-	values: record(string(), string()),
-}).strict();
-
-const enumSchema = object({
-	name: string(),
-	schema: string(),
-	values: string().array(),
-}).strict();
-
-export const pgSchemaV2 = object({
-	version: literal('2'),
-	tables: record(string(), tableV2),
-	enums: record(string(), enumSchemaV1),
-}).strict();
-
-// ------- V1 --------
-const references = object({
-	foreignKeyName: string(),
-	table: string(),
-	column: string(),
-	onDelete: string().optional(),
-	onUpdate: string().optional(),
-}).strict();
-
-const columnV1 = object({
-	name: string(),
-	type: string(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	references: references.optional(),
-}).strict();
-
-const tableV1 = object({
-	name: string(),
-	columns: record(string(), columnV1),
-	indexes: record(string(), indexV2),
-}).strict();
-
-export const pgSchemaV1 = object({
-	version: literal('1'),
-	tables: record(string(), tableV1),
-	enums: record(string(), enumSchemaV1),
-}).strict();
-
-const indexColumn = object({
-	expression: string(),
-	isExpression: boolean(),
-	asc: boolean(),
-	nulls: string().optional(),
-	opclass: string().optional(),
-});
-
-export type IndexColumnType = TypeOf<typeof indexColumn>;
-
-const index = object({
-	name: string(),
-	columns: indexColumn.array(),
-	isUnique: boolean(),
-	with: record(string(), any()).optional(),
-	method: string().default('btree'),
-	where: string().optional(),
-	concurrently: boolean().default(false),
-}).strict();
-
-const indexV4 = object({
-	name: string(),
-	columns: string().array(),
-	isUnique: boolean(),
-	with: record(string(), string()).optional(),
-	method: string().default('btree'),
-	where: string().optional(),
-	concurrently: boolean().default(false),
-}).strict();
-
-const indexV5 = object({
-	name: string(),
-	columns: string().array(),
-	isUnique: boolean(),
-	with: record(string(), string()).optional(),
-	method: string().default('btree'),
-	where: string().optional(),
-	concurrently: boolean().default(false),
-}).strict();
-
-const indexV6 = object({
-	name: string(),
-	columns: string().array(),
-	isUnique: boolean(),
-	with: record(string(), string()).optional(),
-	method: string().default('btree'),
-	where: string().optional(),
-	concurrently: boolean().default(false),
-}).strict();
-
-const fk = object({
-	name: string(),
-	tableFrom: string(),
-	columnsFrom: string().array(),
-	tableTo: string(),
-	schemaTo: string().optional(),
-	columnsTo: string().array(),
-	onUpdate: string().optional(),
-	onDelete: string().optional(),
-}).strict();
-
-export const sequenceSchema = object({
-	name: string(),
-	increment: string().optional(),
-	minValue: string().optional(),
-	maxValue: string().optional(),
-	startWith: string().optional(),
-	cache: string().optional(),
-	cycle: boolean().optional(),
-	schema: string(),
-}).strict();
-
-export const roleSchema = object({
-	name: string(),
-	createDb: boolean().optional(),
-	createRole: boolean().optional(),
-	inherit: boolean().optional(),
-}).strict();
-
-export const sequenceSquashed = object({
-	name: string(),
-	schema: string(),
-	values: string(),
-}).strict();
-
-const columnV7 = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-}).strict();
-
-const column = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-	generated: object({
-		type: literal('stored'),
-		as: string(),
-	}).optional(),
-	identity: sequenceSchema
-		.merge(object({ type: enumType(['always', 'byDefault']) }))
-		.optional(),
-}).strict();
-
-const checkConstraint = object({
-	name: string(),
-	value: string(),
-}).strict();
-
-const columnSquashed = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	default: any().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-	generated: object({
-		type: literal('stored'),
-		as: string(),
-	}).optional(),
-	identity: string().optional(),
-}).strict();
-
-const tableV3 = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-}).strict();
-
-const compositePK = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const uniqueConstraint = object({
-	name: string(),
-	columns: string().array(),
-	nullsNotDistinct: boolean(),
-}).strict();
-
-export const policy = object({
-	name: string(),
-	as: enumType(['PERMISSIVE', 'RESTRICTIVE']).optional(),
-	for: enumType(['ALL', 'SELECT', 'INSERT', 'UPDATE', 'DELETE']).optional(),
-	to: string().array().optional(),
-	using: string().optional(),
-	withCheck: string().optional(),
-	on: string().optional(),
-	schema: string().optional(),
-}).strict();
-
-export const policySquashed = object({
-	name: string(),
-	values: string(),
-}).strict();
-
-const viewWithOption = object({
-	checkOption: enumType(['local', 'cascaded']).optional(),
-	securityBarrier: boolean().optional(),
-	securityInvoker: boolean().optional(),
-}).strict();
-
-const matViewWithOption = object({
-	fillfactor: number().optional(),
-	toastTupleTarget: number().optional(),
-	parallelWorkers: number().optional(),
-	autovacuumEnabled: boolean().optional(),
-	vacuumIndexCleanup: enumType(['auto', 'off', 'on']).optional(),
-	vacuumTruncate: boolean().optional(),
-	autovacuumVacuumThreshold: number().optional(),
-	autovacuumVacuumScaleFactor: number().optional(),
-	autovacuumVacuumCostDelay: number().optional(),
-	autovacuumVacuumCostLimit: number().optional(),
-	autovacuumFreezeMinAge: number().optional(),
-	autovacuumFreezeMaxAge: number().optional(),
-	autovacuumFreezeTableAge: number().optional(),
-	autovacuumMultixactFreezeMinAge: number().optional(),
-	autovacuumMultixactFreezeMaxAge: number().optional(),
-	autovacuumMultixactFreezeTableAge: number().optional(),
-	logAutovacuumMinDuration: number().optional(),
-	userCatalogTable: boolean().optional(),
-}).strict();
-
-export const mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
-
-export const view = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	definition: string().optional(),
-	materialized: boolean(),
-	with: mergedViewWithOption.optional(),
-	isExisting: boolean(),
-	withNoData: boolean().optional(),
-	using: string().optional(),
-	tablespace: string().optional(),
-}).strict();
-
-const tableV4 = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), indexV4),
-	foreignKeys: record(string(), fk),
-}).strict();
-
-const tableV5 = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), indexV5),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-}).strict();
-
-const tableV6 = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), indexV6),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-}).strict();
-
-const tableV7 = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), columnV7),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-}).strict();
-
-const table = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-	policies: record(string(), policy).default({}),
-	checkConstraints: record(string(), checkConstraint).default({}),
-	isRLSEnabled: boolean().default(false),
-}).strict();
-
-const schemaHash = object({
-	id: string(),
-	prevId: string(),
-});
-
-export const kitInternals = object({
-	tables: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({
-					isArray: boolean().optional(),
-					dimensions: number().optional(),
-					rawType: string().optional(),
-					isDefaultAnExpression: boolean().optional(),
-				}).optional(),
-			),
-		}).optional(),
-	),
-}).optional();
-
-export const pgSchemaInternalV3 = object({
-	version: literal('3'),
-	dialect: literal('pg'),
-	tables: record(string(), tableV3),
-	enums: record(string(), enumSchemaV1),
-}).strict();
-
-export const pgSchemaInternalV4 = object({
-	version: literal('4'),
-	dialect: literal('pg'),
-	tables: record(string(), tableV4),
-	enums: record(string(), enumSchemaV1),
-	schemas: record(string(), string()),
-}).strict();
-
-// "table" -> "schema.table" for schema proper support
-export const pgSchemaInternalV5 = object({
-	version: literal('5'),
-	dialect: literal('pg'),
-	tables: record(string(), tableV5),
-	enums: record(string(), enumSchemaV1),
-	schemas: record(string(), string()),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const pgSchemaInternalV6 = object({
-	version: literal('6'),
-	dialect: literal('postgresql'),
-	tables: record(string(), tableV6),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const pgSchemaExternal = object({
-	version: literal('5'),
-	dialect: literal('pg'),
-	tables: array(table),
-	enums: array(enumSchemaV1),
-	schemas: array(object({ name: string() })),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-}).strict();
-
-export const pgSchemaInternalV7 = object({
-	version: literal('7'),
-	dialect: literal('postgresql'),
-	tables: record(string(), tableV7),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	sequences: record(string(), sequenceSchema),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const pgSchemaInternal = object({
-	version: literal('7'),
-	dialect: literal('postgresql'),
-	tables: record(string(), table),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	views: record(string(), view).default({}),
-	sequences: record(string(), sequenceSchema).default({}),
-	roles: record(string(), roleSchema).default({}),
-	policies: record(string(), policy).default({}),
-	_meta: object({
-		schemas: record(string(), string()),
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-const tableSquashed = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), columnSquashed),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()),
-	uniqueConstraints: record(string(), string()),
-	policies: record(string(), string()),
-	checkConstraints: record(string(), string()),
-	isRLSEnabled: boolean().default(false),
-}).strict();
-
-const tableSquashedV4 = object({
-	name: string(),
-	schema: string(),
-	columns: record(string(), column),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-}).strict();
-
-export const pgSchemaSquashedV4 = object({
-	version: literal('4'),
-	dialect: literal('pg'),
-	tables: record(string(), tableSquashedV4),
-	enums: record(string(), enumSchemaV1),
-	schemas: record(string(), string()),
-}).strict();
-
-export const pgSchemaSquashedV6 = object({
-	version: literal('6'),
-	dialect: literal('postgresql'),
-	tables: record(string(), tableSquashed),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-}).strict();
-
-export const pgSchemaSquashed = object({
-	version: literal('7'),
-	dialect: literal('postgresql'),
-	tables: record(string(), tableSquashed),
-	enums: record(string(), enumSchema),
-	schemas: record(string(), string()),
-	views: record(string(), view),
-	sequences: record(string(), sequenceSquashed),
-	roles: record(string(), roleSchema).default({}),
-	policies: record(string(), policySquashed).default({}),
-}).strict();
-
-export const pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash);
-export const pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash);
-export const pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash);
-export const pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash);
-export const pgSchemaV7 = pgSchemaInternalV7.merge(schemaHash);
-export const pgSchema = pgSchemaInternal.merge(schemaHash);
-
-export type Enum = TypeOf<typeof enumSchema>;
-export type Sequence = TypeOf<typeof sequenceSchema>;
-export type Role = TypeOf<typeof roleSchema>;
-export type Column = TypeOf<typeof column>;
-export type TableV3 = TypeOf<typeof tableV3>;
-export type TableV4 = TypeOf<typeof tableV4>;
-export type TableV5 = TypeOf<typeof tableV5>;
-export type Table = TypeOf<typeof table>;
-export type PgSchema = TypeOf<typeof pgSchema>;
-export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
-export type PgSchemaV6Internal = TypeOf<typeof pgSchemaInternalV6>;
-export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
-export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
-export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
-export type PgSchemaSquashedV6 = TypeOf<typeof pgSchemaSquashedV6>;
-export type Index = TypeOf<typeof index>;
-export type ForeignKey = TypeOf<typeof fk>;
-export type PrimaryKey = TypeOf<typeof compositePK>;
-export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
-export type Policy = TypeOf<typeof policy>;
-export type View = TypeOf<typeof view>;
-export type MatViewWithOption = TypeOf<typeof matViewWithOption>;
-export type ViewWithOption = TypeOf<typeof viewWithOption>;
-
-export type PgKitInternals = TypeOf<typeof kitInternals>;
-export type CheckConstraint = TypeOf<typeof checkConstraint>;
-
-export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
-export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
-export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
-export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
-export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
-export type PgSchemaV6 = TypeOf<typeof pgSchemaV6>;
-
-export const backwardCompatiblePgSchema = union([
-	pgSchemaV5,
-	pgSchemaV6,
-	pgSchema,
-]);
-
-export const PgSquasher = {
-	squashIdx: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${
-			idx.columns
-				.map(
-					(c) => `${c.expression}--${c.isExpression}--${c.asc}--${c.nulls}--${c.opclass ? c.opclass : ''}`,
-				)
-				.join(',,')
-		};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
-	},
-	unsquashIdx: (input: string): Index => {
-		const [
-			name,
-			columnsString,
-			isUnique,
-			concurrently,
-			method,
-			where,
-			idxWith,
-		] = input.split(';');
-
-		const columnString = columnsString.split(',,');
-		const columns: IndexColumnType[] = [];
-
-		for (const column of columnString) {
-			const [expression, isExpression, asc, nulls, opclass] = column.split('--');
-			columns.push({
-				nulls: nulls as IndexColumnType['nulls'],
-				isExpression: isExpression === 'true',
-				asc: asc === 'true',
-				expression: expression,
-				opclass: opclass === 'undefined' ? undefined : opclass,
-			});
-		}
-
-		const result: Index = index.parse({
-			name,
-			columns: columns,
-			isUnique: isUnique === 'true',
-			concurrently: concurrently === 'true',
-			method,
-			where: where === 'undefined' ? undefined : where,
-			with: !idxWith || idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
-		});
-		return result;
-	},
-	squashIdxPush: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${
-			idx.columns
-				.map((c) => `${c.isExpression ? '' : c.expression}--${c.asc}--${c.nulls}`)
-				.join(',,')
-		};${idx.isUnique};${idx.method};${JSON.stringify(idx.with)}`;
-	},
-	unsquashIdxPush: (input: string): Index => {
-		const [name, columnsString, isUnique, method, idxWith] = input.split(';');
-
-		const columnString = columnsString.split('--');
-		const columns: IndexColumnType[] = [];
-
-		for (const column of columnString) {
-			const [expression, asc, nulls, opclass] = column.split(',');
-			columns.push({
-				nulls: nulls as IndexColumnType['nulls'],
-				isExpression: expression === '',
-				asc: asc === 'true',
-				expression: expression,
-			});
-		}
-
-		const result: Index = index.parse({
-			name,
-			columns: columns,
-			isUnique: isUnique === 'true',
-			concurrently: false,
-			method,
-			with: idxWith === 'undefined' ? undefined : JSON.parse(idxWith),
-		});
-		return result;
-	},
-	squashFK: (fk: ForeignKey) => {
-		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
-			fk.onUpdate ?? ''
-		};${fk.onDelete ?? ''};${fk.schemaTo || 'public'}`;
-	},
-	squashPolicy: (policy: Policy) => {
-		return `${policy.name}--${policy.as}--${policy.for}--${
-			policy.to?.join(',')
-		}--${policy.using}--${policy.withCheck}--${policy.on}`;
-	},
-	unsquashPolicy: (policy: string): Policy => {
-		const splitted = policy.split('--');
-		return {
-			name: splitted[0],
-			as: splitted[1] as Policy['as'],
-			for: splitted[2] as Policy['for'],
-			to: splitted[3].split(','),
-			using: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			withCheck: splitted[5] !== 'undefined' ? splitted[5] : undefined,
-			on: splitted[6] !== 'undefined' ? splitted[6] : undefined,
-		};
-	},
-	squashPolicyPush: (policy: Policy) => {
-		return `${policy.name}--${policy.as}--${policy.for}--${policy.to?.join(',')}--${policy.on}`;
-	},
-	unsquashPolicyPush: (policy: string): Policy => {
-		const splitted = policy.split('--');
-		return {
-			name: splitted[0],
-			as: splitted[1] as Policy['as'],
-			for: splitted[2] as Policy['for'],
-			to: splitted[3].split(','),
-			on: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-		};
-	},
-	squashPK: (pk: PrimaryKey) => {
-		return `${pk.columns.join(',')};${pk.name}`;
-	},
-	unsquashPK: (pk: string): PrimaryKey => {
-		const splitted = pk.split(';');
-		return { name: splitted[1], columns: splitted[0].split(',') };
-	},
-	squashUnique: (unq: UniqueConstraint) => {
-		return `${unq.name};${unq.columns.join(',')};${unq.nullsNotDistinct}`;
-	},
-	unsquashUnique: (unq: string): UniqueConstraint => {
-		const [name, columns, nullsNotDistinct] = unq.split(';');
-		return {
-			name,
-			columns: columns.split(','),
-			nullsNotDistinct: nullsNotDistinct === 'true',
-		};
-	},
-	unsquashFK: (input: string): ForeignKey => {
-		const [
-			name,
-			tableFrom,
-			columnsFromStr,
-			tableTo,
-			columnsToStr,
-			onUpdate,
-			onDelete,
-			schemaTo,
-		] = input.split(';');
-
-		const result: ForeignKey = fk.parse({
-			name,
-			tableFrom,
-			columnsFrom: columnsFromStr.split(','),
-			schemaTo: schemaTo,
-			tableTo,
-			columnsTo: columnsToStr.split(','),
-			onUpdate,
-			onDelete,
-		});
-		return result;
-	},
-	squashSequence: (seq: Omit<Sequence, 'name' | 'schema'>) => {
-		return `${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${seq.cycle ?? ''}`;
-	},
-	unsquashSequence: (seq: string): Omit<Sequence, 'name' | 'schema'> => {
-		const splitted = seq.split(';');
-		return {
-			minValue: splitted[0] !== 'undefined' ? splitted[0] : undefined,
-			maxValue: splitted[1] !== 'undefined' ? splitted[1] : undefined,
-			increment: splitted[2] !== 'undefined' ? splitted[2] : undefined,
-			startWith: splitted[3] !== 'undefined' ? splitted[3] : undefined,
-			cache: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			cycle: splitted[5] === 'true',
-		};
-	},
-	squashIdentity: (
-		seq: Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' },
-	) => {
-		return `${seq.name};${seq.type};${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${
-			seq.cycle ?? ''
-		}`;
-	},
-	unsquashIdentity: (
-		seq: string,
-	): Omit<Sequence, 'schema'> & { type: 'always' | 'byDefault' } => {
-		const splitted = seq.split(';');
-		return {
-			name: splitted[0],
-			type: splitted[1] as 'always' | 'byDefault',
-			minValue: splitted[2] !== 'undefined' ? splitted[2] : undefined,
-			maxValue: splitted[3] !== 'undefined' ? splitted[3] : undefined,
-			increment: splitted[4] !== 'undefined' ? splitted[4] : undefined,
-			startWith: splitted[5] !== 'undefined' ? splitted[5] : undefined,
-			cache: splitted[6] !== 'undefined' ? splitted[6] : undefined,
-			cycle: splitted[7] === 'true',
-		};
-	},
-	squashCheck: (check: CheckConstraint) => {
-		return `${check.name};${check.value}`;
-	},
-	unsquashCheck: (input: string): CheckConstraint => {
-		const [
-			name,
-			value,
-		] = input.split(';');
-
-		return { name, value };
-	},
-};
-
-export const squashPgScheme = (
-	json: PgSchema,
-	action?: 'push' | undefined,
-): PgSchemaSquashed => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index) => {
-				return action === 'push'
-					? PgSquasher.squashIdxPush(index)
-					: PgSquasher.squashIdx(index);
-			});
-
-			const squashedFKs = mapValues(it[1].foreignKeys, (fk) => {
-				return PgSquasher.squashFK(fk);
-			});
-
-			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-				return PgSquasher.squashPK(pk);
-			});
-
-			const mappedColumns = Object.fromEntries(
-				Object.entries(it[1].columns).map((it) => {
-					const mappedIdentity = it[1].identity
-						? PgSquasher.squashIdentity(it[1].identity)
-						: undefined;
-					return [
-						it[0],
-						{
-							...it[1],
-							identity: mappedIdentity,
-						},
-					];
-				}),
-			);
-
-			const squashedUniqueConstraints = mapValues(
-				it[1].uniqueConstraints,
-				(unq) => {
-					return PgSquasher.squashUnique(unq);
-				},
-			);
-
-			const squashedPolicies = mapValues(it[1].policies, (policy) => {
-				return action === 'push'
-					? PgSquasher.squashPolicyPush(policy)
-					: PgSquasher.squashPolicy(policy);
-			});
-			const squashedChecksContraints = mapValues(
-				it[1].checkConstraints,
-				(check) => {
-					return PgSquasher.squashCheck(check);
-				},
-			);
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					schema: it[1].schema,
-					columns: mappedColumns,
-					indexes: squashedIndexes,
-					foreignKeys: squashedFKs,
-					compositePrimaryKeys: squashedPKs,
-					uniqueConstraints: squashedUniqueConstraints,
-					policies: squashedPolicies,
-					checkConstraints: squashedChecksContraints,
-					isRLSEnabled: it[1].isRLSEnabled ?? false,
-				},
-			];
-		}),
-	);
-
-	const mappedSequences = Object.fromEntries(
-		Object.entries(json.sequences).map((it) => {
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					schema: it[1].schema,
-					values: PgSquasher.squashSequence(it[1]),
-				},
-			];
-		}),
-	);
-
-	const mappedPolicies = Object.fromEntries(
-		Object.entries(json.policies).map((it) => {
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					values: action === 'push'
-						? PgSquasher.squashPolicyPush(it[1])
-						: PgSquasher.squashPolicy(it[1]),
-				},
-			];
-		}),
-	);
-
-	return {
-		version: '7',
-		dialect: json.dialect,
-		tables: mappedTables,
-		enums: json.enums,
-		schemas: json.schemas,
-		views: json.views,
-		policies: mappedPolicies,
-		sequences: mappedSequences,
-		roles: json.roles,
-	};
-};
-
-export const dryPg = pgSchema.parse({
-	version: snapshotVersion,
-	dialect: 'postgresql',
-	id: originUUID,
-	prevId: '',
-	tables: {},
-	enums: {},
-	schemas: {},
-	policies: {},
-	roles: {},
-	sequences: {},
-	_meta: {
-		schemas: {},
-		tables: {},
-		columns: {},
-	},
-});
diff --git a/drizzle-kit/src/serializer/pgSerializer.ts b/drizzle-kit/src/serializer/pgSerializer.ts
deleted file mode 100644
index 88a74ab409..0000000000
--- a/drizzle-kit/src/serializer/pgSerializer.ts
+++ /dev/null
@@ -1,2166 +0,0 @@
-import chalk from 'chalk';
-import { getTableName, is, SQL } from 'drizzle-orm';
-import {
-	AnyPgTable,
-	getMaterializedViewConfig,
-	getTableConfig,
-	getViewConfig,
-	IndexedColumn,
-	PgArray,
-	PgColumn,
-	PgDialect,
-	PgEnum,
-	PgEnumColumn,
-	PgMaterializedView,
-	PgPolicy,
-	PgRole,
-	PgSchema,
-	PgSequence,
-	PgView,
-	uniqueKeyName,
-} from 'drizzle-orm/pg-core';
-import { parse as parsePostgresArray } from 'postgres-array';
-import { CasingType } from 'src/cli/validations/common';
-import { vectorOps } from 'src/extensions/vector';
-import { withStyle } from '../cli/validations/outputs';
-import type { IntrospectStage, IntrospectStatus } from '../cli/views';
-import type {
-	CheckConstraint,
-	Column,
-	Enum,
-	ForeignKey,
-	Index,
-	IndexColumnType,
-	PgKitInternals,
-	PgSchemaInternal,
-	Policy,
-	PrimaryKey,
-	Role,
-	Sequence,
-	Table,
-	UniqueConstraint,
-	View,
-} from '../serializer/pgSchema';
-import { type DB, escapeSingleQuotes, isPgArrayType } from '../utils';
-import { getColumnCasing, sqlToStr } from './utils';
-
-export const indexName = (tableName: string, columns: string[]) => {
-	return `${tableName}_${columns.join('_')}_index`;
-};
-
-function stringFromIdentityProperty(field: string | number | undefined): string | undefined {
-	return typeof field === 'string' ? (field as string) : typeof field === 'undefined' ? undefined : String(field);
-}
-
-function maxRangeForIdentityBasedOn(columnType: string) {
-	return columnType === 'integer' ? '2147483647' : columnType === 'bigint' ? '9223372036854775807' : '32767';
-}
-
-function minRangeForIdentityBasedOn(columnType: string) {
-	return columnType === 'integer' ? '-2147483648' : columnType === 'bigint' ? '-9223372036854775808' : '-32768';
-}
-
-function stringFromDatabaseIdentityProperty(field: any): string | undefined {
-	return typeof field === 'string'
-		? (field as string)
-		: typeof field === 'undefined'
-		? undefined
-		: typeof field === 'bigint'
-		? field.toString()
-		: String(field);
-}
-
-export function buildArrayString(array: any[], sqlType: string): string {
-	sqlType = sqlType.split('[')[0];
-	const values = array
-		.map((value) => {
-			if (typeof value === 'number' || typeof value === 'bigint') {
-				return value.toString();
-			} else if (typeof value === 'boolean') {
-				return value ? 'true' : 'false';
-			} else if (Array.isArray(value)) {
-				return buildArrayString(value, sqlType);
-			} else if (value instanceof Date) {
-				if (sqlType === 'date') {
-					return `"${value.toISOString().split('T')[0]}"`;
-				} else if (sqlType === 'timestamp') {
-					return `"${value.toISOString().replace('T', ' ').slice(0, 23)}"`;
-				} else {
-					return `"${value.toISOString()}"`;
-				}
-			} else if (typeof value === 'object') {
-				return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
-			}
-
-			return `"${value}"`;
-		})
-		.join(',');
-
-	return `{${values}}`;
-}
-
-export const generatePgSnapshot = (
-	tables: AnyPgTable[],
-	enums: PgEnum<any>[],
-	schemas: PgSchema[],
-	sequences: PgSequence[],
-	roles: PgRole[],
-	policies: PgPolicy[],
-	views: PgView[],
-	matViews: PgMaterializedView[],
-	casing: CasingType | undefined,
-	schemaFilter?: string[],
-): PgSchemaInternal => {
-	const dialect = new PgDialect({ casing });
-	const result: Record<string, Table> = {};
-	const resultViews: Record<string, View> = {};
-	const sequencesToReturn: Record<string, Sequence> = {};
-	const rolesToReturn: Record<string, Role> = {};
-	// this policies are a separate objects that were linked to a table outside of it
-	const policiesToReturn: Record<string, Policy> = {};
-
-	// This object stores unique names for indexes and will be used to detect if you have the same names for indexes
-	// within the same PostgreSQL schema
-
-	const indexesInSchema: Record<string, string[]> = {};
-
-	for (const table of tables) {
-		// This object stores unique names for checks and will be used to detect if you have the same names for checks
-		// within the same PostgreSQL table
-		const checksInTable: Record<string, string[]> = {};
-
-		const {
-			name: tableName,
-			columns,
-			indexes,
-			foreignKeys,
-			checks,
-			schema,
-			primaryKeys,
-			uniqueConstraints,
-			policies,
-			enableRLS,
-		} = getTableConfig(table);
-
-		if (schemaFilter && !schemaFilter.includes(schema ?? 'public')) {
-			continue;
-		}
-
-		const columnsObject: Record<string, Column> = {};
-		const indexesObject: Record<string, Index> = {};
-		const checksObject: Record<string, CheckConstraint> = {};
-		const foreignKeysObject: Record<string, ForeignKey> = {};
-		const primaryKeysObject: Record<string, PrimaryKey> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-		const policiesObject: Record<string, Policy> = {};
-
-		columns.forEach((column) => {
-			const name = getColumnCasing(column, casing);
-			const notNull: boolean = column.notNull;
-			const primaryKey: boolean = column.primary;
-			const sqlTypeLowered = column.getSQLType().toLowerCase();
-
-			const getEnumSchema = (column: PgColumn) => {
-				while (is(column, PgArray)) {
-					column = column.baseColumn;
-				}
-				return is(column, PgEnumColumn) ? column.enum.schema || 'public' : undefined;
-			};
-			const typeSchema: string | undefined = getEnumSchema(column);
-
-			const generated = column.generated;
-			const identity = column.generatedIdentity;
-
-			const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
-			const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
-				?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
-			const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
-				?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
-			const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
-				?? (parseFloat(increment) < 0 ? maxValue : minValue);
-			const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
-
-			const columnToSet: Column = {
-				name,
-				type: column.getSQLType(),
-				typeSchema: typeSchema,
-				primaryKey,
-				notNull,
-				generated: generated
-					? {
-						as: is(generated.as, SQL)
-							? dialect.sqlToQuery(generated.as as SQL).sql
-							: typeof generated.as === 'function'
-							? dialect.sqlToQuery(generated.as() as SQL).sql
-							: (generated.as as any),
-						type: 'stored',
-					}
-					: undefined,
-				identity: identity
-					? {
-						type: identity.type,
-						name: identity.sequenceName ?? `${tableName}_${name}_seq`,
-						schema: schema ?? 'public',
-						increment,
-						startWith,
-						minValue,
-						maxValue,
-						cache,
-						cycle: identity?.sequenceOptions?.cycle ?? false,
-					}
-					: undefined,
-			};
-
-			if (column.isUnique) {
-				const existingUnique = uniqueConstraintObject[column.uniqueName!];
-				if (typeof existingUnique !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. 
-          The unique constraint ${
-								chalk.underline.blue(
-									column.uniqueName,
-								)
-							} on the ${
-								chalk.underline.blue(
-									name,
-								)
-							} column is conflicting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`)
-						}`,
-					);
-					process.exit(1);
-				}
-				uniqueConstraintObject[column.uniqueName!] = {
-					name: column.uniqueName!,
-					nullsNotDistinct: column.uniqueType === 'not distinct',
-					columns: [columnToSet.name],
-				};
-			}
-
-			if (column.default !== undefined) {
-				if (is(column.default, SQL)) {
-					columnToSet.default = sqlToStr(column.default, casing);
-				} else {
-					if (typeof column.default === 'string') {
-						columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
-					} else {
-						if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
-							columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-						} else if (column.default instanceof Date) {
-							if (sqlTypeLowered === 'date') {
-								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-							} else if (sqlTypeLowered === 'timestamp') {
-								columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
-							} else {
-								columnToSet.default = `'${column.default.toISOString()}'`;
-							}
-						} else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
-							columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
-						} else {
-							// Should do for all types
-							// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
-							columnToSet.default = column.default;
-						}
-					}
-				}
-			}
-			columnsObject[name] = columnToSet;
-		});
-
-		primaryKeys.map((pk) => {
-			const originalColumnNames = pk.columns.map((c) => c.name);
-			const columnNames = pk.columns.map((c) => getColumnCasing(c, casing));
-
-			let name = pk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnNames.length; i++) {
-					name = name.replace(originalColumnNames[i], columnNames[i]);
-				}
-			}
-
-			primaryKeysObject[name] = {
-				name,
-				columns: columnNames,
-			};
-		});
-
-		uniqueConstraints?.map((unq) => {
-			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
-
-			const name = unq.name ?? uniqueKeyName(table, columnNames);
-
-			const existingUnique = uniqueConstraintObject[name];
-			if (typeof existingUnique !== 'undefined') {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated unique constraint names in ${chalk.underline.blue(tableName)} table. 
-        The unique constraint ${chalk.underline.blue(name)} on the ${
-								chalk.underline.blue(
-									columnNames.join(','),
-								)
-							} columns is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(existingUnique.columns.join(','))
-							} columns\n`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			uniqueConstraintObject[name] = {
-				name: unq.name!,
-				nullsNotDistinct: unq.nullsNotDistinct,
-				columns: columnNames,
-			};
-		});
-
-		const fks: ForeignKey[] = foreignKeys.map((fk) => {
-			const tableFrom = tableName;
-			const onDelete = fk.onDelete;
-			const onUpdate = fk.onUpdate;
-			const reference = fk.reference();
-
-			const tableTo = getTableName(reference.foreignTable);
-			// TODO: resolve issue with schema undefined/public for db push(or squasher)
-			// getTableConfig(reference.foreignTable).schema || "public";
-			const schemaTo = getTableConfig(reference.foreignTable).schema;
-
-			const originalColumnsFrom = reference.columns.map((it) => it.name);
-			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
-			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
-			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
-
-			let name = fk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnsFrom.length; i++) {
-					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
-				}
-				for (let i = 0; i < originalColumnsTo.length; i++) {
-					name = name.replace(originalColumnsTo[i], columnsTo[i]);
-				}
-			}
-
-			return {
-				name,
-				tableFrom,
-				tableTo,
-				schemaTo,
-				columnsFrom,
-				columnsTo,
-				onDelete,
-				onUpdate,
-			} as ForeignKey;
-		});
-
-		fks.forEach((it) => {
-			foreignKeysObject[it.name] = it;
-		});
-
-		indexes.forEach((value) => {
-			const columns = value.config.columns;
-
-			let indexColumnNames: string[] = [];
-			columns.forEach((it) => {
-				if (is(it, SQL)) {
-					if (typeof value.config.name === 'undefined') {
-						console.log(
-							`\n${
-								withStyle.errorWarning(
-									`Please specify an index name in ${getTableName(value.config.table)} table that has "${
-										dialect.sqlToQuery(it).sql
-									}" expression. We can generate index names for indexes on columns only; for expressions in indexes, you need to specify the name yourself.`,
-								)
-							}`,
-						);
-						process.exit(1);
-					}
-				}
-				it = it as IndexedColumn;
-				const name = getColumnCasing(it as IndexedColumn, casing);
-				if (
-					!is(it, SQL)
-					&& it.type! === 'PgVector'
-					&& typeof it.indexConfig!.opClass === 'undefined'
-				) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`You are specifying an index on the ${
-									chalk.blueBright(
-										name,
-									)
-								} column inside the ${
-									chalk.blueBright(
-										tableName,
-									)
-								} table with the ${
-									chalk.blueBright(
-										'vector',
-									)
-								} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${
-									vectorOps
-										.map((it) => `${chalk.underline(`${it}`)}`)
-										.join(', ')
-								}].\n\nYou can specify it using current syntax: ${
-									chalk.underline(
-										`index("${value.config.name}").using("${value.config.method}", table.${name}.op("${
-											vectorOps[0]
-										}"))`,
-									)
-								}\n\nYou can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing\n`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				indexColumnNames.push(name);
-			});
-
-			const name = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
-
-			let indexColumns: IndexColumnType[] = columns.map(
-				(it): IndexColumnType => {
-					if (is(it, SQL)) {
-						return {
-							expression: dialect.sqlToQuery(it, 'indexes').sql,
-							asc: true,
-							isExpression: true,
-							nulls: 'last',
-						};
-					} else {
-						it = it as IndexedColumn;
-						return {
-							expression: getColumnCasing(it as IndexedColumn, casing),
-							isExpression: false,
-							asc: it.indexConfig?.order === 'asc',
-							nulls: it.indexConfig?.nulls
-								? it.indexConfig?.nulls
-								: it.indexConfig?.order === 'desc'
-								? 'first'
-								: 'last',
-							opclass: it.indexConfig?.opClass,
-						};
-					}
-				},
-			);
-
-			// check for index names duplicates
-			if (typeof indexesInSchema[schema ?? 'public'] !== 'undefined') {
-				if (indexesInSchema[schema ?? 'public'].includes(name)) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated index name across ${
-									chalk.underline.blue(schema ?? 'public')
-								} schema. Please rename your index in either the ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table or the table with the duplicated index name`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				indexesInSchema[schema ?? 'public'].push(name);
-			} else {
-				indexesInSchema[schema ?? 'public'] = [name];
-			}
-
-			indexesObject[name] = {
-				name,
-				columns: indexColumns,
-				isUnique: value.config.unique ?? false,
-				where: value.config.where ? dialect.sqlToQuery(value.config.where).sql : undefined,
-				concurrently: value.config.concurrently ?? false,
-				method: value.config.method ?? 'btree',
-				with: value.config.with ?? {},
-			};
-		});
-
-		policies.forEach((policy) => {
-			const mappedTo = [];
-
-			if (!policy.to) {
-				mappedTo.push('public');
-			} else {
-				if (policy.to && typeof policy.to === 'string') {
-					mappedTo.push(policy.to);
-				} else if (policy.to && is(policy.to, PgRole)) {
-					mappedTo.push(policy.to.name);
-				} else if (policy.to && Array.isArray(policy.to)) {
-					policy.to.forEach((it) => {
-						if (typeof it === 'string') {
-							mappedTo.push(it);
-						} else if (is(it, PgRole)) {
-							mappedTo.push(it.name);
-						}
-					});
-				}
-			}
-
-			if (policiesObject[policy.name] !== undefined) {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated policy name across ${
-								chalk.underline.blue(tableKey)
-							} table. Please rename one of the policies with ${
-								chalk.underline.blue(
-									policy.name,
-								)
-							} name`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			policiesObject[policy.name] = {
-				name: policy.name,
-				as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
-				for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
-				to: mappedTo.sort(),
-				using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
-				withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
-			};
-		});
-
-		checks.forEach((check) => {
-			const checkName = check.name;
-
-			if (typeof checksInTable[`"${schema ?? 'public'}"."${tableName}"`] !== 'undefined') {
-				if (checksInTable[`"${schema ?? 'public'}"."${tableName}"`].includes(check.name)) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated check constraint name across ${
-									chalk.underline.blue(
-										schema ?? 'public',
-									)
-								} schema in ${
-									chalk.underline.blue(
-										tableName,
-									)
-								}. Please rename your check constraint in either the ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table or the table with the duplicated check contraint name`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				checksInTable[`"${schema ?? 'public'}"."${tableName}"`].push(checkName);
-			} else {
-				checksInTable[`"${schema ?? 'public'}"."${tableName}"`] = [check.name];
-			}
-
-			checksObject[checkName] = {
-				name: checkName,
-				value: dialect.sqlToQuery(check.value).sql,
-			};
-		});
-
-		const tableKey = `${schema ?? 'public'}.${tableName}`;
-
-		result[tableKey] = {
-			name: tableName,
-			schema: schema ?? '',
-			columns: columnsObject,
-			indexes: indexesObject,
-			foreignKeys: foreignKeysObject,
-			compositePrimaryKeys: primaryKeysObject,
-			uniqueConstraints: uniqueConstraintObject,
-			policies: policiesObject,
-			checkConstraints: checksObject,
-			isRLSEnabled: enableRLS,
-		};
-	}
-
-	for (const policy of policies) {
-		// @ts-ignore
-		if (!policy._linkedTable) {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`"Policy ${policy.name} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`,
-					)
-				}`,
-			);
-			continue;
-		}
-
-		// @ts-ignore
-		const tableConfig = getTableConfig(policy._linkedTable);
-
-		const tableKey = `${tableConfig.schema ?? 'public'}.${tableConfig.name}`;
-
-		const mappedTo = [];
-
-		if (!policy.to) {
-			mappedTo.push('public');
-		} else {
-			if (policy.to && typeof policy.to === 'string') {
-				mappedTo.push(policy.to);
-			} else if (policy.to && is(policy.to, PgRole)) {
-				mappedTo.push(policy.to.name);
-			} else if (policy.to && Array.isArray(policy.to)) {
-				policy.to.forEach((it) => {
-					if (typeof it === 'string') {
-						mappedTo.push(it);
-					} else if (is(it, PgRole)) {
-						mappedTo.push(it.name);
-					}
-				});
-			}
-		}
-
-		// add separate policies object, that will be only responsible for policy creation
-		// but we would need to track if a policy was enabled for a specific table or not
-		// enable only if jsonStatements for enable rls was not already there + filter it
-
-		if (result[tableKey]?.policies[policy.name] !== undefined || policiesToReturn[policy.name] !== undefined) {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated policy name across ${
-							chalk.underline.blue(tableKey)
-						} table. Please rename one of the policies with ${
-							chalk.underline.blue(
-								policy.name,
-							)
-						} name`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		const mappedPolicy = {
-			name: policy.name,
-			as: policy.as?.toUpperCase() as Policy['as'] ?? 'PERMISSIVE',
-			for: policy.for?.toUpperCase() as Policy['for'] ?? 'ALL',
-			to: mappedTo.sort(),
-			using: is(policy.using, SQL) ? dialect.sqlToQuery(policy.using).sql : undefined,
-			withCheck: is(policy.withCheck, SQL) ? dialect.sqlToQuery(policy.withCheck).sql : undefined,
-		};
-
-		if (result[tableKey]) {
-			result[tableKey].policies[policy.name] = mappedPolicy;
-		} else {
-			policiesToReturn[policy.name] = {
-				...mappedPolicy,
-				schema: tableConfig.schema ?? 'public',
-				on: `"${tableConfig.schema ?? 'public'}"."${tableConfig.name}"`,
-			};
-		}
-	}
-
-	for (const sequence of sequences) {
-		const name = sequence.seqName!;
-		if (typeof sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] === 'undefined') {
-			const increment = stringFromIdentityProperty(sequence?.seqOptions?.increment) ?? '1';
-			const minValue = stringFromIdentityProperty(sequence?.seqOptions?.minValue)
-				?? (parseFloat(increment) < 0 ? '-9223372036854775808' : '1');
-			const maxValue = stringFromIdentityProperty(sequence?.seqOptions?.maxValue)
-				?? (parseFloat(increment) < 0 ? '-1' : '9223372036854775807');
-			const startWith = stringFromIdentityProperty(sequence?.seqOptions?.startWith)
-				?? (parseFloat(increment) < 0 ? maxValue : minValue);
-			const cache = stringFromIdentityProperty(sequence?.seqOptions?.cache) ?? '1';
-
-			sequencesToReturn[`${sequence.schema ?? 'public'}.${name}`] = {
-				name,
-				schema: sequence.schema ?? 'public',
-				increment,
-				startWith,
-				minValue,
-				maxValue,
-				cache,
-				cycle: sequence.seqOptions?.cycle ?? false,
-			};
-		} else {
-			// duplicate seq error
-		}
-	}
-
-	for (const role of roles) {
-		if (!(role as any)._existing) {
-			rolesToReturn[role.name] = {
-				name: role.name,
-				createDb: (role as any).createDb === undefined ? false : (role as any).createDb,
-				createRole: (role as any).createRole === undefined ? false : (role as any).createRole,
-				inherit: (role as any).inherit === undefined ? true : (role as any).inherit,
-			};
-		}
-	}
-	const combinedViews = [...views, ...matViews];
-	for (const view of combinedViews) {
-		let viewName;
-		let schema;
-		let query;
-		let selectedFields;
-		let isExisting;
-		let withOption;
-		let tablespace;
-		let using;
-		let withNoData;
-		let materialized: boolean = false;
-
-		if (is(view, PgView)) {
-			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption } = getViewConfig(view));
-		} else {
-			({ name: viewName, schema, query, selectedFields, isExisting, with: withOption, tablespace, using, withNoData } =
-				getMaterializedViewConfig(view));
-
-			materialized = true;
-		}
-
-		const viewSchema = schema ?? 'public';
-
-		const viewKey = `${viewSchema}.${viewName}`;
-
-		const columnsObject: Record<string, Column> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-
-		const existingView = resultViews[viewKey];
-		if (typeof existingView !== 'undefined') {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated view name across ${
-							chalk.underline.blue(schema ?? 'public')
-						} schema. Please rename your view`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		for (const key in selectedFields) {
-			if (is(selectedFields[key], PgColumn)) {
-				const column = selectedFields[key];
-
-				const notNull: boolean = column.notNull;
-				const primaryKey: boolean = column.primary;
-				const sqlTypeLowered = column.getSQLType().toLowerCase();
-
-				const typeSchema = is(column, PgEnumColumn) ? column.enum.schema || 'public' : undefined;
-				const generated = column.generated;
-				const identity = column.generatedIdentity;
-
-				const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? '1';
-				const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue)
-					?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column.columnType) : '1');
-				const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue)
-					?? (parseFloat(increment) < 0 ? '-1' : maxRangeForIdentityBasedOn(column.getSQLType()));
-				const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith)
-					?? (parseFloat(increment) < 0 ? maxValue : minValue);
-				const cache = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? '1';
-
-				const columnToSet: Column = {
-					name: column.name,
-					type: column.getSQLType(),
-					typeSchema: typeSchema,
-					primaryKey,
-					notNull,
-					generated: generated
-						? {
-							as: is(generated.as, SQL)
-								? dialect.sqlToQuery(generated.as as SQL).sql
-								: typeof generated.as === 'function'
-								? dialect.sqlToQuery(generated.as() as SQL).sql
-								: (generated.as as any),
-							type: 'stored',
-						}
-						: undefined,
-					identity: identity
-						? {
-							type: identity.type,
-							name: identity.sequenceName ?? `${viewName}_${column.name}_seq`,
-							schema: schema ?? 'public',
-							increment,
-							startWith,
-							minValue,
-							maxValue,
-							cache,
-							cycle: identity?.sequenceOptions?.cycle ?? false,
-						}
-						: undefined,
-				};
-
-				if (column.isUnique) {
-					const existingUnique = uniqueConstraintObject[column.uniqueName!];
-					if (typeof existingUnique !== 'undefined') {
-						console.log(
-							`\n${
-								withStyle.errorWarning(
-									`We\'ve found duplicated unique constraint names in ${chalk.underline.blue(viewName)} table. 
-          The unique constraint ${chalk.underline.blue(column.uniqueName)} on the ${
-										chalk.underline.blue(
-											column.name,
-										)
-									} column is confilcting with a unique constraint name already defined for ${
-										chalk.underline.blue(existingUnique.columns.join(','))
-									} columns\n`,
-								)
-							}`,
-						);
-						process.exit(1);
-					}
-					uniqueConstraintObject[column.uniqueName!] = {
-						name: column.uniqueName!,
-						nullsNotDistinct: column.uniqueType === 'not distinct',
-						columns: [columnToSet.name],
-					};
-				}
-
-				if (column.default !== undefined) {
-					if (is(column.default, SQL)) {
-						columnToSet.default = sqlToStr(column.default, casing);
-					} else {
-						if (typeof column.default === 'string') {
-							columnToSet.default = `'${column.default}'`;
-						} else {
-							if (sqlTypeLowered === 'jsonb' || sqlTypeLowered === 'json') {
-								columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-							} else if (column.default instanceof Date) {
-								if (sqlTypeLowered === 'date') {
-									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-								} else if (sqlTypeLowered === 'timestamp') {
-									columnToSet.default = `'${column.default.toISOString().replace('T', ' ').slice(0, 23)}'`;
-								} else {
-									columnToSet.default = `'${column.default.toISOString()}'`;
-								}
-							} else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
-								columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
-							} else {
-								// Should do for all types
-								// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
-								columnToSet.default = column.default;
-							}
-						}
-					}
-				}
-				columnsObject[column.name] = columnToSet;
-			}
-		}
-
-		resultViews[viewKey] = {
-			columns: columnsObject,
-			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
-			name: viewName,
-			schema: viewSchema,
-			isExisting,
-			with: withOption,
-			withNoData,
-			materialized,
-			tablespace,
-			using,
-		};
-	}
-
-	const enumsToReturn: Record<string, Enum> = enums.reduce<{
-		[key: string]: Enum;
-	}>((map, obj) => {
-		const enumSchema = obj.schema || 'public';
-		const key = `${enumSchema}.${obj.enumName}`;
-		map[key] = {
-			name: obj.enumName,
-			schema: enumSchema,
-			values: obj.enumValues,
-		};
-		return map;
-	}, {});
-
-	const schemasObject = Object.fromEntries(
-		schemas
-			.filter((it) => {
-				if (schemaFilter) {
-					return schemaFilter.includes(it.schemaName) && it.schemaName !== 'public';
-				} else {
-					return it.schemaName !== 'public';
-				}
-			})
-			.map((it) => [it.schemaName, it.schemaName]),
-	);
-
-	return {
-		version: '7',
-		dialect: 'postgresql',
-		tables: result,
-		enums: enumsToReturn,
-		schemas: schemasObject,
-		sequences: sequencesToReturn,
-		roles: rolesToReturn,
-		policies: policiesToReturn,
-		views: resultViews,
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	};
-};
-
-const trimChar = (str: string, char: string) => {
-	let start = 0;
-	let end = str.length;
-
-	while (start < end && str[start] === char) ++start;
-	while (end > start && str[end - 1] === char) --end;
-
-	// this.toString() due to ava deep equal issue with String { "value" }
-	return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
-};
-
-function prepareRoles(entities?: {
-	roles: boolean | {
-		provider?: string | undefined;
-		include?: string[] | undefined;
-		exclude?: string[] | undefined;
-	};
-}) {
-	let useRoles: boolean = false;
-	const includeRoles: string[] = [];
-	const excludeRoles: string[] = [];
-
-	if (entities && entities.roles) {
-		if (typeof entities.roles === 'object') {
-			if (entities.roles.provider) {
-				if (entities.roles.provider === 'supabase') {
-					excludeRoles.push(...[
-						'anon',
-						'authenticator',
-						'authenticated',
-						'service_role',
-						'supabase_auth_admin',
-						'supabase_storage_admin',
-						'dashboard_user',
-						'supabase_admin',
-					]);
-				} else if (entities.roles.provider === 'neon') {
-					excludeRoles.push(...['authenticated', 'anonymous']);
-				}
-			}
-			if (entities.roles.include) {
-				includeRoles.push(...entities.roles.include);
-			}
-			if (entities.roles.exclude) {
-				excludeRoles.push(...entities.roles.exclude);
-			}
-		} else {
-			useRoles = entities.roles;
-		}
-	}
-	return { useRoles, includeRoles, excludeRoles };
-}
-
-export const fromDatabase = async (
-	db: DB,
-	tablesFilter: (table: string) => boolean = () => true,
-	schemaFilters: string[],
-	entities?: {
-		roles: boolean | {
-			provider?: string | undefined;
-			include?: string[] | undefined;
-			exclude?: string[] | undefined;
-		};
-	},
-	progressCallback?: (
-		stage: IntrospectStage,
-		count: number,
-		status: IntrospectStatus,
-	) => void,
-	tsSchema?: PgSchemaInternal,
-): Promise<PgSchemaInternal> => {
-	const result: Record<string, Table> = {};
-	const views: Record<string, View> = {};
-	const policies: Record<string, Policy> = {};
-	const internals: PgKitInternals = { tables: {} };
-
-	const where = schemaFilters.map((t) => `n.nspname = '${t}'`).join(' or ');
-
-	const allTables = await db.query<{ table_schema: string; table_name: string; type: string; rls_enabled: boolean }>(
-		`SELECT 
-    n.nspname AS table_schema, 
-    c.relname AS table_name, 
-    CASE 
-        WHEN c.relkind = 'r' THEN 'table'
-        WHEN c.relkind = 'v' THEN 'view'
-        WHEN c.relkind = 'm' THEN 'materialized_view'
-    END AS type,
-	c.relrowsecurity AS rls_enabled
-FROM 
-    pg_catalog.pg_class c
-JOIN 
-    pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-WHERE 
-	c.relkind IN ('r', 'v', 'm') 
-    ${where === '' ? '' : ` AND ${where}`};`,
-	);
-
-	const schemas = new Set(allTables.map((it) => it.table_schema));
-	schemas.delete('public');
-
-	const allSchemas = await db.query<{
-		table_schema: string;
-	}>(`select s.nspname as table_schema
-  from pg_catalog.pg_namespace s
-  join pg_catalog.pg_user u on u.usesysid = s.nspowner
-  where nspname not in ('information_schema', 'pg_catalog', 'public')
-        and nspname not like 'pg_toast%'
-        and nspname not like 'pg_temp_%'
-  order by table_schema;`);
-
-	allSchemas.forEach((item) => {
-		if (schemaFilters.includes(item.table_schema)) {
-			schemas.add(item.table_schema);
-		}
-	});
-
-	let columnsCount = 0;
-	let indexesCount = 0;
-	let foreignKeysCount = 0;
-	let tableCount = 0;
-	let checksCount = 0;
-	let viewsCount = 0;
-
-	const sequencesToReturn: Record<string, Sequence> = {};
-
-	const seqWhere = schemaFilters.map((t) => `schemaname = '${t}'`).join(' or ');
-
-	const allSequences = await db.query(
-		`select schemaname, sequencename, start_value, min_value, max_value, increment_by, cycle, cache_size from pg_sequences as seq${
-			seqWhere === '' ? '' : ` WHERE ${seqWhere}`
-		};`,
-	);
-
-	for (const dbSeq of allSequences) {
-		const schemaName = dbSeq.schemaname;
-		const sequenceName = dbSeq.sequencename;
-		const startValue = stringFromDatabaseIdentityProperty(dbSeq.start_value);
-		const minValue = stringFromDatabaseIdentityProperty(dbSeq.min_value);
-		const maxValue = stringFromDatabaseIdentityProperty(dbSeq.max_value);
-		const incrementBy = stringFromDatabaseIdentityProperty(dbSeq.increment_by);
-		const cycle = dbSeq.cycle;
-		const cacheSize = stringFromDatabaseIdentityProperty(dbSeq.cache_size);
-		const key = `${schemaName}.${sequenceName}`;
-
-		sequencesToReturn[key] = {
-			name: sequenceName,
-			schema: schemaName,
-			startWith: startValue,
-			minValue,
-			maxValue,
-			increment: incrementBy,
-			cycle,
-			cache: cacheSize,
-		};
-	}
-
-	const whereEnums = schemaFilters.map((t) => `n.nspname = '${t}'`).join(' or ');
-
-	const allEnums = await db.query(
-		`select n.nspname as enum_schema,
-  t.typname as enum_name,
-  e.enumlabel as enum_value,
-  e.enumsortorder as sort_order
-  from pg_type t
-  join pg_enum e on t.oid = e.enumtypid
-  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  ${whereEnums === '' ? '' : ` WHERE ${whereEnums}`}
-  order by enum_schema, enum_name, sort_order;`,
-	);
-
-	const enumsToReturn: Record<string, Enum> = {};
-
-	for (const dbEnum of allEnums) {
-		const enumName = dbEnum.enum_name;
-		const enumValue = dbEnum.enum_value as string;
-		const enumSchema: string = dbEnum.enum_schema || 'public';
-		const key = `${enumSchema}.${enumName}`;
-
-		if (enumsToReturn[key] !== undefined && enumsToReturn[key] !== null) {
-			enumsToReturn[key].values.push(enumValue);
-		} else {
-			enumsToReturn[key] = {
-				name: enumName,
-				values: [enumValue],
-				schema: enumSchema,
-			};
-		}
-	}
-	if (progressCallback) {
-		progressCallback('enums', Object.keys(enumsToReturn).length, 'done');
-	}
-
-	const allRoles = await db.query<
-		{ rolname: string; rolinherit: boolean; rolcreatedb: boolean; rolcreaterole: boolean }
-	>(
-		`SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`,
-	);
-
-	const rolesToReturn: Record<string, Role> = {};
-
-	const preparedRoles = prepareRoles(entities);
-
-	if (
-		preparedRoles.useRoles || !(preparedRoles.includeRoles.length === 0 && preparedRoles.excludeRoles.length === 0)
-	) {
-		for (const dbRole of allRoles) {
-			if (
-				preparedRoles.useRoles
-			) {
-				rolesToReturn[dbRole.rolname] = {
-					createDb: dbRole.rolcreatedb,
-					createRole: dbRole.rolcreatedb,
-					inherit: dbRole.rolinherit,
-					name: dbRole.rolname,
-				};
-			} else {
-				if (preparedRoles.includeRoles.length === 0 && preparedRoles.excludeRoles.length === 0) continue;
-				if (
-					preparedRoles.includeRoles.includes(dbRole.rolname) && preparedRoles.excludeRoles.includes(dbRole.rolname)
-				) continue;
-				if (preparedRoles.excludeRoles.includes(dbRole.rolname)) continue;
-				if (!preparedRoles.includeRoles.includes(dbRole.rolname)) continue;
-
-				rolesToReturn[dbRole.rolname] = {
-					createDb: dbRole.rolcreatedb,
-					createRole: dbRole.rolcreaterole,
-					inherit: dbRole.rolinherit,
-					name: dbRole.rolname,
-				};
-			}
-		}
-	}
-
-	const schemasForLinkedPoliciesInSchema = Object.values(tsSchema?.policies ?? {}).map((it) => it.schema!);
-
-	const wherePolicies = [...schemaFilters, ...schemasForLinkedPoliciesInSchema]
-		.map((t) => `schemaname = '${t}'`)
-		.join(' or ');
-
-	const policiesByTable: Record<string, Record<string, Policy>> = {};
-
-	const allPolicies = await db.query<
-		{
-			schemaname: string;
-			tablename: string;
-			name: string;
-			as: string;
-			to: string;
-			for: string;
-			using: string;
-			withCheck: string;
-		}
-	>(`SELECT schemaname, tablename, policyname as name, permissive as "as", roles as to, cmd as for, qual as using, with_check as "withCheck" FROM pg_policies${
-		wherePolicies === '' ? '' : ` WHERE ${wherePolicies}`
-	};`);
-
-	for (const dbPolicy of allPolicies) {
-		const { tablename, schemaname, to, withCheck, using, ...rest } = dbPolicy;
-		const tableForPolicy = policiesByTable[`${schemaname}.${tablename}`];
-
-		const parsedTo = typeof to === 'string' ? to.slice(1, -1).split(',') : to;
-
-		const parsedWithCheck = withCheck === null ? undefined : withCheck;
-		const parsedUsing = using === null ? undefined : using;
-
-		if (tableForPolicy) {
-			tableForPolicy[dbPolicy.name] = { ...rest, to: parsedTo } as Policy;
-		} else {
-			policiesByTable[`${schemaname}.${tablename}`] = {
-				[dbPolicy.name]: { ...rest, to: parsedTo, withCheck: parsedWithCheck, using: parsedUsing } as Policy,
-			};
-		}
-
-		if (tsSchema?.policies[dbPolicy.name]) {
-			policies[dbPolicy.name] = {
-				...rest,
-				to: parsedTo,
-				withCheck: parsedWithCheck,
-				using: parsedUsing,
-				on: tsSchema?.policies[dbPolicy.name].on,
-			} as Policy;
-		}
-	}
-
-	if (progressCallback) {
-		progressCallback(
-			'policies',
-			Object.values(policiesByTable).reduce((total, innerRecord) => {
-				return total + Object.keys(innerRecord).length;
-			}, 0),
-			'done',
-		);
-	}
-
-	const sequencesInColumns: string[] = [];
-
-	const all = allTables
-		.filter((it) => it.type === 'table')
-		.map((row) => {
-			return new Promise(async (res, rej) => {
-				const tableName = row.table_name as string;
-				if (!tablesFilter(tableName)) return res('');
-				tableCount += 1;
-				const tableSchema = row.table_schema;
-
-				try {
-					const columnToReturn: Record<string, Column> = {};
-					const indexToReturn: Record<string, Index> = {};
-					const foreignKeysToReturn: Record<string, ForeignKey> = {};
-					const primaryKeys: Record<string, PrimaryKey> = {};
-					const uniqueConstrains: Record<string, UniqueConstraint> = {};
-					const checkConstraints: Record<string, CheckConstraint> = {};
-
-					const tableResponse = await getColumnsInfoQuery({ schema: tableSchema, table: tableName, db });
-
-					const tableConstraints = await db.query(
-						`SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
-      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
-        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
-      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`,
-					);
-
-					const tableChecks = await db.query(`SELECT 
-						tc.constraint_name,
-						tc.constraint_type,
-						pg_get_constraintdef(con.oid) AS constraint_definition
-					FROM 
-						information_schema.table_constraints AS tc
-						JOIN pg_constraint AS con 
-							ON tc.constraint_name = con.conname
-							AND con.conrelid = (
-								SELECT oid 
-								FROM pg_class 
-								WHERE relname = tc.table_name 
-								AND relnamespace = (
-									SELECT oid 
-									FROM pg_namespace 
-									WHERE nspname = tc.constraint_schema
-								)
-							)
-					WHERE 
-						tc.table_name = '${tableName}'
-						AND tc.constraint_schema = '${tableSchema}'
-						AND tc.constraint_type = 'CHECK';`);
-
-					columnsCount += tableResponse.length;
-					if (progressCallback) {
-						progressCallback('columns', columnsCount, 'fetching');
-					}
-
-					const tableForeignKeys = await db.query(
-						`SELECT
-            con.contype AS constraint_type,
-            nsp.nspname AS constraint_schema,
-            con.conname AS constraint_name,
-            rel.relname AS table_name,
-            att.attname AS column_name,
-            fnsp.nspname AS foreign_table_schema,
-            frel.relname AS foreign_table_name,
-            fatt.attname AS foreign_column_name,
-            CASE con.confupdtype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS update_rule,
-            CASE con.confdeltype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS delete_rule
-          FROM
-            pg_catalog.pg_constraint con
-            JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
-            JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
-            LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
-              AND att.attrelid = con.conrelid
-            LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
-            LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
-            LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
-              AND fatt.attrelid = con.confrelid
-          WHERE
-            nsp.nspname = '${tableSchema}'
-            AND rel.relname = '${tableName}'
-            AND con.contype IN ('f');`,
-					);
-
-					foreignKeysCount += tableForeignKeys.length;
-					if (progressCallback) {
-						progressCallback('fks', foreignKeysCount, 'fetching');
-					}
-					for (const fk of tableForeignKeys) {
-						// const tableFrom = fk.table_name;
-						const columnFrom: string = fk.column_name;
-						const tableTo = fk.foreign_table_name;
-						const columnTo: string = fk.foreign_column_name;
-						const schemaTo: string = fk.foreign_table_schema;
-						const foreignKeyName = fk.constraint_name;
-						const onUpdate = fk.update_rule?.toLowerCase();
-						const onDelete = fk.delete_rule?.toLowerCase();
-
-						if (typeof foreignKeysToReturn[foreignKeyName] !== 'undefined') {
-							foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
-							foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
-						} else {
-							foreignKeysToReturn[foreignKeyName] = {
-								name: foreignKeyName,
-								tableFrom: tableName,
-								tableTo,
-								schemaTo,
-								columnsFrom: [columnFrom],
-								columnsTo: [columnTo],
-								onDelete,
-								onUpdate,
-							};
-						}
-
-						foreignKeysToReturn[foreignKeyName].columnsFrom = [
-							...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom),
-						];
-
-						foreignKeysToReturn[foreignKeyName].columnsTo = [...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)];
-					}
-
-					const uniqueConstrainsRows = tableConstraints.filter((mapRow) => mapRow.constraint_type === 'UNIQUE');
-
-					for (const unqs of uniqueConstrainsRows) {
-						// const tableFrom = fk.table_name;
-						const columnName: string = unqs.column_name;
-						const constraintName: string = unqs.constraint_name;
-
-						if (typeof uniqueConstrains[constraintName] !== 'undefined') {
-							uniqueConstrains[constraintName].columns.push(columnName);
-						} else {
-							uniqueConstrains[constraintName] = {
-								columns: [columnName],
-								nullsNotDistinct: false,
-								name: constraintName,
-							};
-						}
-					}
-
-					checksCount += tableChecks.length;
-					if (progressCallback) {
-						progressCallback('checks', checksCount, 'fetching');
-					}
-					for (const checks of tableChecks) {
-						// CHECK (((email)::text <> 'test@gmail.com'::text))
-						// Where (email) is column in table
-						let checkValue: string = checks.constraint_definition;
-						const constraintName: string = checks.constraint_name;
-
-						checkValue = checkValue.replace(/^CHECK\s*\(\(/, '').replace(/\)\)\s*$/, '');
-
-						checkConstraints[constraintName] = {
-							name: constraintName,
-							value: checkValue,
-						};
-					}
-
-					for (const columnResponse of tableResponse) {
-						const columnName = columnResponse.column_name;
-						const columnAdditionalDT = columnResponse.additional_dt;
-						const columnDimensions = columnResponse.array_dimensions;
-						const enumType: string = columnResponse.enum_name;
-						let columnType: string = columnResponse.data_type;
-						const typeSchema = columnResponse.type_schema;
-						const defaultValueRes: string = columnResponse.column_default;
-
-						const isGenerated = columnResponse.is_generated === 'ALWAYS';
-						const generationExpression = columnResponse.generation_expression;
-						const isIdentity = columnResponse.is_identity === 'YES';
-						const identityGeneration = columnResponse.identity_generation === 'ALWAYS' ? 'always' : 'byDefault';
-						const identityStart = columnResponse.identity_start;
-						const identityIncrement = columnResponse.identity_increment;
-						const identityMaximum = columnResponse.identity_maximum;
-						const identityMinimum = columnResponse.identity_minimum;
-						const identityCycle = columnResponse.identity_cycle === 'YES';
-						const identityName = columnResponse.seq_name;
-
-						const primaryKey = tableConstraints.filter((mapRow) =>
-							columnName === mapRow.column_name && mapRow.constraint_type === 'PRIMARY KEY'
-						);
-
-						const cprimaryKey = tableConstraints.filter((mapRow) => mapRow.constraint_type === 'PRIMARY KEY');
-
-						if (cprimaryKey.length > 1) {
-							const tableCompositePkName = await db.query(
-								`SELECT conname AS primary_key
-            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
-            WHERE  contype = 'p' 
-            AND    connamespace = $1::regnamespace  
-            AND    pg_class.relname = $2;`,
-								[tableSchema, tableName],
-							);
-							primaryKeys[tableCompositePkName[0].primary_key] = {
-								name: tableCompositePkName[0].primary_key,
-								columns: cprimaryKey.map((c: any) => c.column_name),
-							};
-						}
-
-						let columnTypeMapped = columnType;
-
-						// Set default to internal object
-						if (columnAdditionalDT === 'ARRAY') {
-							if (typeof internals.tables[tableName] === 'undefined') {
-								internals.tables[tableName] = {
-									columns: {
-										[columnName]: {
-											isArray: true,
-											dimensions: columnDimensions,
-											rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-										},
-									},
-								};
-							} else {
-								if (typeof internals.tables[tableName]!.columns[columnName] === 'undefined') {
-									internals.tables[tableName]!.columns[columnName] = {
-										isArray: true,
-										dimensions: columnDimensions,
-										rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-									};
-								}
-							}
-						}
-
-						const defaultValue = defaultForColumn(columnResponse, internals, tableName);
-						if (
-							defaultValue === 'NULL'
-							|| (defaultValueRes && defaultValueRes.startsWith('(') && defaultValueRes.endsWith(')'))
-						) {
-							if (typeof internals!.tables![tableName] === 'undefined') {
-								internals!.tables![tableName] = {
-									columns: {
-										[columnName]: {
-											isDefaultAnExpression: true,
-										},
-									},
-								};
-							} else {
-								if (typeof internals!.tables![tableName]!.columns[columnName] === 'undefined') {
-									internals!.tables![tableName]!.columns[columnName] = {
-										isDefaultAnExpression: true,
-									};
-								} else {
-									internals!.tables![tableName]!.columns[columnName]!.isDefaultAnExpression = true;
-								}
-							}
-						}
-
-						const isSerial = columnType === 'serial';
-
-						if (columnTypeMapped.startsWith('numeric(')) {
-							columnTypeMapped = columnTypeMapped.replace(',', ', ');
-						}
-
-						if (columnAdditionalDT === 'ARRAY') {
-							for (let i = 1; i < Number(columnDimensions); i++) {
-								columnTypeMapped += '[]';
-							}
-						}
-
-						columnTypeMapped = columnTypeMapped
-							.replace('character varying', 'varchar')
-							.replace(' without time zone', '')
-							// .replace("timestamp without time zone", "timestamp")
-							.replace('character', 'char');
-
-						columnTypeMapped = trimChar(columnTypeMapped, '"');
-
-						columnToReturn[columnName] = {
-							name: columnName,
-							type:
-								// filter vectors, but in future we should filter any extension that was installed by user
-								columnAdditionalDT === 'USER-DEFINED'
-									&& !['vector', 'geometry'].includes(enumType)
-									? enumType
-									: columnTypeMapped,
-							typeSchema: enumsToReturn[`${typeSchema}.${enumType}`] !== undefined
-								? enumsToReturn[`${typeSchema}.${enumType}`].schema
-								: undefined,
-							primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
-							// default: isSerial ? undefined : defaultValue,
-							notNull: columnResponse.is_nullable === 'NO',
-							generated: isGenerated
-								? { as: generationExpression, type: 'stored' }
-								: undefined,
-							identity: isIdentity
-								? {
-									type: identityGeneration,
-									name: identityName,
-									increment: stringFromDatabaseIdentityProperty(identityIncrement),
-									minValue: stringFromDatabaseIdentityProperty(identityMinimum),
-									maxValue: stringFromDatabaseIdentityProperty(identityMaximum),
-									startWith: stringFromDatabaseIdentityProperty(identityStart),
-									cache: sequencesToReturn[identityName]?.cache
-										? sequencesToReturn[identityName]?.cache
-										: sequencesToReturn[`${tableSchema}.${identityName}`]?.cache
-										? sequencesToReturn[`${tableSchema}.${identityName}`]?.cache
-										: undefined,
-									cycle: identityCycle,
-									schema: tableSchema,
-								}
-								: undefined,
-						};
-
-						if (identityName && typeof identityName === 'string') {
-							// remove "" from sequence name
-							delete sequencesToReturn[
-								`${tableSchema}.${
-									identityName.startsWith('"') && identityName.endsWith('"') ? identityName.slice(1, -1) : identityName
-								}`
-							];
-							delete sequencesToReturn[identityName];
-						}
-
-						if (!isSerial && typeof defaultValue !== 'undefined') {
-							columnToReturn[columnName].default = defaultValue;
-						}
-					}
-
-					const dbIndexes = await db.query(
-						`SELECT  DISTINCT ON (t.relname, ic.relname, k.i) t.relname as table_name, ic.relname AS indexname,
-        k.i AS index_order,
-        i.indisunique as is_unique,
-        am.amname as method,
-        ic.reloptions as with,
-        coalesce(a.attname, pg_get_indexdef(i.indexrelid, k.i, false)) AS column_name,
-          CASE
-        WHEN pg_get_expr(i.indexprs, i.indrelid) IS NOT NULL THEN 1
-        ELSE 0
-    END AS is_expression,
-        i.indoption[k.i-1] & 1 = 1 AS descending,
-        i.indoption[k.i-1] & 2 = 2 AS nulls_first,
-        pg_get_expr(
-                              i.indpred,
-                              i.indrelid
-                          ) as where,
-         opc.opcname
-      FROM pg_class t
-          LEFT JOIN pg_index i ON t.oid = i.indrelid
-          LEFT JOIN pg_class ic ON ic.oid = i.indexrelid
-		  CROSS JOIN LATERAL (SELECT unnest(i.indkey), generate_subscripts(i.indkey, 1) + 1) AS k(attnum, i)
-          LEFT JOIN pg_attribute AS a
-            ON i.indrelid = a.attrelid AND k.attnum = a.attnum
-          JOIN pg_namespace c on c.oid = t.relnamespace
-        LEFT JOIN pg_am AS am ON ic.relam = am.oid
-        JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
-      WHERE
-      c.nspname = '${tableSchema}' AND
-      t.relname = '${tableName}';`,
-					);
-
-					const dbIndexFromConstraint = await db.query(
-						`SELECT
-          idx.indexrelname AS index_name,
-          idx.relname AS table_name,
-          schemaname,
-          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
-        FROM
-          pg_stat_user_indexes idx
-        LEFT JOIN
-          pg_constraint con ON con.conindid = idx.indexrelid
-        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
-        group by index_name, table_name,schemaname, generated_by_constraint;`,
-					);
-
-					const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) =>
-						it.index_name
-					);
-
-					for (const dbIndex of dbIndexes) {
-						const indexName: string = dbIndex.indexname;
-						const indexColumnName: string = dbIndex.column_name;
-						const indexIsUnique = dbIndex.is_unique;
-						const indexMethod = dbIndex.method;
-						const indexWith: string[] = dbIndex.with;
-						const indexWhere: string = dbIndex.where;
-						const opclass: string = dbIndex.opcname;
-						const isExpression = dbIndex.is_expression === 1;
-
-						const desc: boolean = dbIndex.descending;
-						const nullsFirst: boolean = dbIndex.nulls_first;
-
-						const mappedWith: Record<string, string> = {};
-
-						if (indexWith !== null) {
-							indexWith
-								// .slice(1, indexWith.length - 1)
-								// .split(",")
-								.forEach((it) => {
-									const splitted = it.split('=');
-									mappedWith[splitted[0]] = splitted[1];
-								});
-						}
-
-						if (idxsInConsteraint.includes(indexName)) continue;
-
-						if (typeof indexToReturn[indexName] !== 'undefined') {
-							indexToReturn[indexName].columns.push({
-								expression: indexColumnName,
-								asc: !desc,
-								nulls: nullsFirst ? 'first' : 'last',
-								opclass,
-								isExpression,
-							});
-						} else {
-							indexToReturn[indexName] = {
-								name: indexName,
-								columns: [
-									{
-										expression: indexColumnName,
-										asc: !desc,
-										nulls: nullsFirst ? 'first' : 'last',
-										opclass,
-										isExpression,
-									},
-								],
-								isUnique: indexIsUnique,
-								// should not be a part of diff detects
-								concurrently: false,
-								method: indexMethod,
-								where: indexWhere === null ? undefined : indexWhere,
-								with: mappedWith,
-							};
-						}
-					}
-
-					indexesCount += Object.keys(indexToReturn).length;
-					if (progressCallback) {
-						progressCallback('indexes', indexesCount, 'fetching');
-					}
-					result[`${tableSchema}.${tableName}`] = {
-						name: tableName,
-						schema: tableSchema !== 'public' ? tableSchema : '',
-						columns: columnToReturn,
-						indexes: indexToReturn,
-						foreignKeys: foreignKeysToReturn,
-						compositePrimaryKeys: primaryKeys,
-						uniqueConstraints: uniqueConstrains,
-						checkConstraints: checkConstraints,
-						policies: policiesByTable[`${tableSchema}.${tableName}`] ?? {},
-						isRLSEnabled: row.rls_enabled,
-					};
-				} catch (e) {
-					rej(e);
-					return;
-				}
-				res('');
-			});
-		});
-
-	if (progressCallback) {
-		progressCallback('tables', tableCount, 'done');
-	}
-
-	for await (const _ of all) {
-	}
-
-	const allViews = allTables
-		.filter((it) => it.type === 'view' || it.type === 'materialized_view')
-		.map((row) => {
-			return new Promise(async (res, rej) => {
-				const viewName = row.table_name as string;
-				if (!tablesFilter(viewName)) return res('');
-				tableCount += 1;
-				const viewSchema = row.table_schema;
-
-				try {
-					const columnToReturn: Record<string, Column> = {};
-
-					const viewResponses = await getColumnsInfoQuery({ schema: viewSchema, table: viewName, db });
-
-					for (const viewResponse of viewResponses) {
-						const columnName = viewResponse.column_name;
-						const columnAdditionalDT = viewResponse.additional_dt;
-						const columnDimensions = viewResponse.array_dimensions;
-						const enumType: string = viewResponse.enum_name;
-						let columnType: string = viewResponse.data_type;
-						const typeSchema = viewResponse.type_schema;
-						// const defaultValueRes: string = viewResponse.column_default;
-
-						const isGenerated = viewResponse.is_generated === 'ALWAYS';
-						const generationExpression = viewResponse.generation_expression;
-						const isIdentity = viewResponse.is_identity === 'YES';
-						const identityGeneration = viewResponse.identity_generation === 'ALWAYS' ? 'always' : 'byDefault';
-						const identityStart = viewResponse.identity_start;
-						const identityIncrement = viewResponse.identity_increment;
-						const identityMaximum = viewResponse.identity_maximum;
-						const identityMinimum = viewResponse.identity_minimum;
-						const identityCycle = viewResponse.identity_cycle === 'YES';
-						const identityName = viewResponse.seq_name;
-						const defaultValueRes = viewResponse.column_default;
-
-						const primaryKey = viewResponse.constraint_type === 'PRIMARY KEY';
-
-						let columnTypeMapped = columnType;
-
-						// Set default to internal object
-						if (columnAdditionalDT === 'ARRAY') {
-							if (typeof internals.tables[viewName] === 'undefined') {
-								internals.tables[viewName] = {
-									columns: {
-										[columnName]: {
-											isArray: true,
-											dimensions: columnDimensions,
-											rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-										},
-									},
-								};
-							} else {
-								if (typeof internals.tables[viewName]!.columns[columnName] === 'undefined') {
-									internals.tables[viewName]!.columns[columnName] = {
-										isArray: true,
-										dimensions: columnDimensions,
-										rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2),
-									};
-								}
-							}
-						}
-
-						const defaultValue = defaultForColumn(viewResponse, internals, viewName);
-						if (
-							defaultValue === 'NULL'
-							|| (defaultValueRes && defaultValueRes.startsWith('(') && defaultValueRes.endsWith(')'))
-						) {
-							if (typeof internals!.tables![viewName] === 'undefined') {
-								internals!.tables![viewName] = {
-									columns: {
-										[columnName]: {
-											isDefaultAnExpression: true,
-										},
-									},
-								};
-							} else {
-								if (typeof internals!.tables![viewName]!.columns[columnName] === 'undefined') {
-									internals!.tables![viewName]!.columns[columnName] = {
-										isDefaultAnExpression: true,
-									};
-								} else {
-									internals!.tables![viewName]!.columns[columnName]!.isDefaultAnExpression = true;
-								}
-							}
-						}
-
-						const isSerial = columnType === 'serial';
-
-						if (columnTypeMapped.startsWith('numeric(')) {
-							columnTypeMapped = columnTypeMapped.replace(',', ', ');
-						}
-
-						if (columnAdditionalDT === 'ARRAY') {
-							for (let i = 1; i < Number(columnDimensions); i++) {
-								columnTypeMapped += '[]';
-							}
-						}
-
-						columnTypeMapped = columnTypeMapped
-							.replace('character varying', 'varchar')
-							.replace(' without time zone', '')
-							// .replace("timestamp without time zone", "timestamp")
-							.replace('character', 'char');
-
-						columnTypeMapped = trimChar(columnTypeMapped, '"');
-
-						columnToReturn[columnName] = {
-							name: columnName,
-							type:
-								// filter vectors, but in future we should filter any extension that was installed by user
-								columnAdditionalDT === 'USER-DEFINED' && !['vector', 'geometry'].includes(enumType)
-									? enumType
-									: columnTypeMapped,
-							typeSchema: enumsToReturn[`${typeSchema}.${enumType}`] !== undefined
-								? enumsToReturn[`${typeSchema}.${enumType}`].schema
-								: undefined,
-							primaryKey: primaryKey,
-							notNull: viewResponse.is_nullable === 'NO',
-							generated: isGenerated ? { as: generationExpression, type: 'stored' } : undefined,
-							identity: isIdentity
-								? {
-									type: identityGeneration,
-									name: identityName,
-									increment: stringFromDatabaseIdentityProperty(identityIncrement),
-									minValue: stringFromDatabaseIdentityProperty(identityMinimum),
-									maxValue: stringFromDatabaseIdentityProperty(identityMaximum),
-									startWith: stringFromDatabaseIdentityProperty(identityStart),
-									cache: sequencesToReturn[identityName]?.cache
-										? sequencesToReturn[identityName]?.cache
-										: sequencesToReturn[`${viewSchema}.${identityName}`]?.cache
-										? sequencesToReturn[`${viewSchema}.${identityName}`]?.cache
-										: undefined,
-									cycle: identityCycle,
-									schema: viewSchema,
-								}
-								: undefined,
-						};
-
-						if (identityName) {
-							// remove "" from sequence name
-							delete sequencesToReturn[
-								`${viewSchema}.${
-									identityName.startsWith('"') && identityName.endsWith('"') ? identityName.slice(1, -1) : identityName
-								}`
-							];
-							delete sequencesToReturn[identityName];
-						}
-
-						if (!isSerial && typeof defaultValue !== 'undefined') {
-							columnToReturn[columnName].default = defaultValue;
-						}
-					}
-
-					const [viewInfo] = await db.query<{
-						view_name: string;
-						schema_name: string;
-						definition: string;
-						tablespace_name: string | null;
-						options: string[] | null;
-						location: string | null;
-					}>(`
-					SELECT
-    c.relname AS view_name,
-    n.nspname AS schema_name,
-    pg_get_viewdef(c.oid, true) AS definition,
-    ts.spcname AS tablespace_name,
-    c.reloptions AS options,
-    pg_tablespace_location(ts.oid) AS location
-FROM
-    pg_class c
-JOIN
-    pg_namespace n ON c.relnamespace = n.oid
-LEFT JOIN
-    pg_tablespace ts ON c.reltablespace = ts.oid 
-WHERE
-    (c.relkind = 'm' OR c.relkind = 'v')
-    AND n.nspname = '${viewSchema}'
-    AND c.relname = '${viewName}';`);
-
-					const resultWith: { [key: string]: string | boolean | number } = {};
-					if (viewInfo.options) {
-						viewInfo.options.forEach((pair) => {
-							const splitted = pair.split('=');
-							const key = splitted[0];
-							const value = splitted[1];
-
-							if (value === 'true') {
-								resultWith[key] = true;
-							} else if (value === 'false') {
-								resultWith[key] = false;
-							} else if (!isNaN(Number(value))) {
-								resultWith[key] = Number(value);
-							} else {
-								resultWith[key] = value;
-							}
-						});
-					}
-
-					const definition = viewInfo.definition.replace(/\s+/g, ' ').replace(';', '').trim();
-					// { "check_option":"cascaded","security_barrier":true} -> // { "checkOption":"cascaded","securityBarrier":true}
-					const withOption = Object.values(resultWith).length
-						? Object.fromEntries(Object.entries(resultWith).map(([key, value]) => [key.camelCase(), value]))
-						: undefined;
-
-					const materialized = row.type === 'materialized_view';
-
-					views[`${viewSchema}.${viewName}`] = {
-						name: viewName,
-						schema: viewSchema,
-						columns: columnToReturn,
-						isExisting: false,
-						definition: definition,
-						materialized: materialized,
-						with: withOption,
-						tablespace: viewInfo.tablespace_name ?? undefined,
-					};
-				} catch (e) {
-					rej(e);
-					return;
-				}
-				res('');
-			});
-		});
-
-	viewsCount = allViews.length;
-
-	for await (const _ of allViews) {
-	}
-
-	if (progressCallback) {
-		progressCallback('columns', columnsCount, 'done');
-		progressCallback('indexes', indexesCount, 'done');
-		progressCallback('fks', foreignKeysCount, 'done');
-		progressCallback('checks', checksCount, 'done');
-		progressCallback('views', viewsCount, 'done');
-	}
-
-	const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
-
-	return {
-		version: '7',
-		dialect: 'postgresql',
-		tables: result,
-		enums: enumsToReturn,
-		schemas: schemasObject,
-		sequences: sequencesToReturn,
-		roles: rolesToReturn,
-		policies,
-		views: views,
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-		internal: internals,
-	};
-};
-
-/**
- * Formats a single array element based on the PostgreSQL column data type.
- * Handles cleaning up quotes and spaces from postgres-array parsed elements,
- * and applies appropriate formatting for different data types.
- */
-const formatArrayElement = (element: any, dataType: string): string | null => {
-	if (element === null) return element;
-
-	// Remove outer quotes from postgres-array parsed elements if present
-	// First trim spaces since postgres-array includes leading spaces in array elements
-	let cleanElement = typeof element === 'string' ? element.trim() : element;
-	if (
-		typeof cleanElement === 'string'
-		&& ((cleanElement.startsWith("'") && cleanElement.endsWith("'"))
-			|| (cleanElement.startsWith('"') && cleanElement.endsWith('"')))
-	) {
-		cleanElement = cleanElement.slice(1, -1);
-	}
-
-	// remove [] from dataType if it exists
-	if (!dataType.endsWith('[]')) {
-		throw new Error(`array dataType ${dataType} does not end with '[]'`);
-	}
-
-	const baseDataType = dataType.slice(0, -'[]'.length);
-
-	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(baseDataType)) {
-		return cleanElement;
-	} else if (dataType.startsWith('timestamp')) {
-		return `"${cleanElement}"`;
-	} else if (baseDataType === 'interval') {
-		return `"${cleanElement.replaceAll('"', `\"`)}"`;
-	} else if (baseDataType === 'boolean') {
-		return cleanElement === 't' || cleanElement === 'true' ? 'true' : 'false';
-	} else if (['json', 'jsonb'].includes(baseDataType)) {
-		// For JSON/JSONB arrays, cleanElement is already a JSON string
-		// We just need to ensure it's properly quoted
-
-		// First, try to parse it to validate it's valid JSON
-		const parsed = JSON.parse(cleanElement);
-		// Then stringify it back to ensure consistent formatting
-		return `"${JSON.stringify(parsed).replaceAll('"', '\\"')}"`;
-	} else {
-		return `"${cleanElement}"`;
-	}
-};
-
-/**
- * Handles the default value formatting for array columns.
- * Converts various array formats to PostgreSQL array notation and formats elements.
- */
-const handleArrayDefault = (columnDefaultAsString: string, dataType: string): string => {
-	// Handle common simple cases
-	if (columnDefaultAsString === '{}' || columnDefaultAsString === "'{}'") {
-		return "'{}'";
-	} else if (columnDefaultAsString === '{""}' || columnDefaultAsString === '\'{""}\'') {
-		return '\'{""}\'';
-	}
-
-	// Convert ARRAY constructor syntax to PostgreSQL bracket notation that postgres-array can parse
-	let normalizedArrayString = columnDefaultAsString;
-
-	if (columnDefaultAsString.startsWith('ARRAY[') && columnDefaultAsString.endsWith(']')) {
-		// Convert ARRAY['a'::text, 'b', 'c'::varchar] -> {'a', 'b', 'c'}
-		const content = columnDefaultAsString.slice(6, -1); // Remove 'ARRAY[' and ']'
-
-		// Remove type casting from individual elements (::text, ::varchar, etc.)
-		const cleanContent = content.replace(/::\w+/g, '');
-		normalizedArrayString = `{${cleanContent}}`;
-	}
-
-	// Handle various bracket notation formats to ensure compatibility with postgres-array
-	if (normalizedArrayString.startsWith("'{") && normalizedArrayString.endsWith("}'")) {
-		normalizedArrayString = normalizedArrayString.slice(1, -1); // Remove outer quotes
-	} else if (
-		!normalizedArrayString.startsWith('{') && !normalizedArrayString.startsWith("'") && normalizedArrayString !== '{}'
-	) {
-		// Handle cases where array string doesn't have proper brackets
-		normalizedArrayString = `{${normalizedArrayString}}`;
-	}
-
-	// Use postgres-array library to parse the normalized string
-	const parsedArray = [...parsePostgresArray(normalizedArrayString)];
-
-	// Format elements according to data type
-	const formattedElements = parsedArray.map((element) => formatArrayElement(element, dataType));
-
-	return `'{${formattedElements.join(',')}}'`;
-};
-
-export const defaultForColumn = (column: any, internals: PgKitInternals, tableName: string) => {
-	const columnName = column.column_name;
-	const isArray = internals?.tables[tableName]?.columns[columnName]?.isArray ?? false;
-
-	if (
-		column.column_default === null
-		|| column.column_default === undefined
-		|| column.data_type === 'serial'
-		|| column.data_type === 'smallserial'
-		|| column.data_type === 'bigserial'
-	) {
-		return undefined;
-	}
-
-	if (column.column_default.endsWith('[]')) {
-		column.column_default = column.column_default.slice(0, -2);
-	}
-
-	// if (
-	// 	!['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(column.data_type)
-	// ) {
-	column.column_default = column.column_default.replace(/::(.*?)(?<![^\w"])(?=$)/, '');
-	// }
-
-	const columnDefaultAsString: string = column.column_default.toString();
-
-	if (isArray) {
-		return handleArrayDefault(columnDefaultAsString, column.data_type);
-	}
-
-	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(column.data_type)) {
-		if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString)) {
-			return Number(columnDefaultAsString);
-		} else {
-			if (typeof internals!.tables![tableName] === 'undefined') {
-				internals!.tables![tableName] = {
-					columns: {
-						[columnName]: {
-							isDefaultAnExpression: true,
-						},
-					},
-				};
-			} else {
-				if (typeof internals!.tables![tableName]!.columns[columnName] === 'undefined') {
-					internals!.tables![tableName]!.columns[columnName] = {
-						isDefaultAnExpression: true,
-					};
-				} else {
-					internals!.tables![tableName]!.columns[columnName]!.isDefaultAnExpression = true;
-				}
-			}
-			return columnDefaultAsString;
-		}
-	} else if (column.data_type.includes('numeric')) {
-		// if numeric(1,1) and used '99' -> psql stores like '99'::numeric
-		return columnDefaultAsString.includes("'") ? columnDefaultAsString : `'${columnDefaultAsString}'`;
-	} else if (column.data_type === 'json' || column.data_type === 'jsonb') {
-		const jsonWithoutSpaces = JSON.stringify(JSON.parse(columnDefaultAsString.slice(1, -1)));
-		return `'${jsonWithoutSpaces}'::${column.data_type}`;
-	} else if (column.data_type === 'boolean') {
-		return column.column_default === 'true';
-	} else if (columnDefaultAsString === 'NULL') {
-		return `NULL`;
-	} else if (columnDefaultAsString.startsWith("'") && columnDefaultAsString.endsWith("'")) {
-		return columnDefaultAsString;
-	} else {
-		return `${columnDefaultAsString.replace(/\\/g, '`\\')}`;
-	}
-};
-
-const getColumnsInfoQuery = ({ schema, table, db }: { schema: string; table: string; db: DB }) => {
-	return db.query(
-		`SELECT 
-    a.attrelid::regclass::text AS table_name,  -- Table, view, or materialized view name
-    a.attname AS column_name,   -- Column name
-    CASE 
-        WHEN NOT a.attisdropped THEN 
-            CASE 
-                WHEN a.attnotnull THEN 'NO'
-                ELSE 'YES'
-            END 
-        ELSE NULL 
-    END AS is_nullable,  -- NULL or NOT NULL constraint
-    a.attndims AS array_dimensions,  -- Array dimensions
-    CASE 
-        WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
-        AND EXISTS (
-            SELECT FROM pg_attrdef ad
-            WHERE ad.adrelid = a.attrelid 
-            AND ad.adnum = a.attnum 
-            AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
-                || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
-        )
-        THEN CASE a.atttypid
-            WHEN 'int'::regtype THEN 'serial'
-            WHEN 'int8'::regtype THEN 'bigserial'
-            WHEN 'int2'::regtype THEN 'smallserial'
-        END
-        ELSE format_type(a.atttypid, a.atttypmod)
-    END AS data_type,  -- Column data type
---    ns.nspname AS type_schema,  -- Schema name
-    pg_get_serial_sequence('"${schema}"."${table}"', a.attname)::regclass AS seq_name,  -- Serial sequence (if any)
-    c.column_default,  -- Column default value
-    c.data_type AS additional_dt,  -- Data type from information_schema
-    c.udt_name AS enum_name,  -- Enum type (if applicable)
-    c.is_generated,  -- Is it a generated column?
-    c.generation_expression,  -- Generation expression (if generated)
-    c.is_identity,  -- Is it an identity column?
-    c.identity_generation,  -- Identity generation strategy (ALWAYS or BY DEFAULT)
-    c.identity_start,  -- Start value of identity column
-    c.identity_increment,  -- Increment for identity column
-    c.identity_maximum,  -- Maximum value for identity column
-    c.identity_minimum,  -- Minimum value for identity column
-    c.identity_cycle,  -- Does the identity column cycle?
-    enum_ns.nspname AS type_schema  -- Schema of the enum type
-FROM 
-    pg_attribute a
-JOIN 
-    pg_class cls ON cls.oid = a.attrelid  -- Join pg_class to get table/view/materialized view info
-JOIN 
-    pg_namespace ns ON ns.oid = cls.relnamespace  -- Join namespace to get schema info
-LEFT JOIN 
-    information_schema.columns c ON c.column_name = a.attname 
-        AND c.table_schema = ns.nspname 
-        AND c.table_name = cls.relname  -- Match schema and table/view name
-LEFT JOIN 
-    pg_type enum_t ON enum_t.oid = a.atttypid  -- Join to get the type info
-LEFT JOIN 
-    pg_namespace enum_ns ON enum_ns.oid = enum_t.typnamespace  -- Join to get the enum schema
-WHERE 
-    a.attnum > 0  -- Valid column numbers only
-    AND NOT a.attisdropped  -- Skip dropped columns
-    AND cls.relkind IN ('r', 'v', 'm')  -- Include regular tables ('r'), views ('v'), and materialized views ('m')
-    AND ns.nspname = '${schema}'  -- Filter by schema
-    AND cls.relname = '${table}'  -- Filter by table name
-ORDER BY 
-    a.attnum;  -- Order by column number`,
-	);
-};
diff --git a/drizzle-kit/src/serializer/singlestoreImports.ts b/drizzle-kit/src/serializer/singlestoreImports.ts
deleted file mode 100644
index 23c2d66a95..0000000000
--- a/drizzle-kit/src/serializer/singlestoreImports.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { is } from 'drizzle-orm';
-import { AnySingleStoreTable, SingleStoreTable } from 'drizzle-orm/singlestore-core';
-import { safeRegister } from '../cli/commands/utils';
-
-export const prepareFromExports = (exports: Record<string, unknown>) => {
-	const tables: AnySingleStoreTable[] = [];
-	/* const views: SingleStoreView[] = []; */
-
-	const i0values = Object.values(exports);
-	i0values.forEach((t) => {
-		if (is(t, SingleStoreTable)) {
-			tables.push(t);
-		}
-
-		/* if (is(t, SingleStoreView)) {
-			views.push(t);
-		} */
-	});
-
-	return { tables /* views  */ };
-};
-
-export const prepareFromSingleStoreImports = async (imports: string[]) => {
-	const tables: AnySingleStoreTable[] = [];
-	/* const views: SingleStoreView[] = []; */
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-		const i0: Record<string, unknown> = require(`${it}`);
-		const prepared = prepareFromExports(i0);
-
-		tables.push(...prepared.tables);
-		/* views.push(...prepared.views); */
-	}
-	unregister();
-	return { tables: Array.from(new Set(tables)) /* , views */ };
-};
diff --git a/drizzle-kit/src/serializer/singlestoreSchema.ts b/drizzle-kit/src/serializer/singlestoreSchema.ts
deleted file mode 100644
index 9ff45ef5a7..0000000000
--- a/drizzle-kit/src/serializer/singlestoreSchema.ts
+++ /dev/null
@@ -1,257 +0,0 @@
-import { any, boolean, enum as enumType, literal, object, record, string, TypeOf, union } from 'zod';
-import { mapValues, originUUID, snapshotVersion } from '../global';
-
-// ------- V3 --------
-const index = object({
-	name: string(),
-	columns: string().array(),
-	isUnique: boolean(),
-	using: enumType(['btree', 'hash']).optional(),
-	algorithm: enumType(['default', 'inplace', 'copy']).optional(),
-	lock: enumType(['default', 'none', 'shared', 'exclusive']).optional(),
-}).strict();
-
-const column = object({
-	name: string(),
-	type: string(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	autoincrement: boolean().optional(),
-	default: any().optional(),
-	onUpdate: any().optional(),
-	generated: object({
-		type: enumType(['stored', 'virtual']),
-		as: string(),
-	}).optional(),
-}).strict();
-
-const compositePK = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const uniqueConstraint = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const table = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-}).strict();
-
-const viewMeta = object({
-	algorithm: enumType(['undefined', 'merge', 'temptable']),
-	sqlSecurity: enumType(['definer', 'invoker']),
-	withCheckOption: enumType(['local', 'cascaded']).optional(),
-}).strict();
-
-/* export const view = object({
-	name: string(),
-	columns: record(string(), column),
-	definition: string().optional(),
-	isExisting: boolean(),
-}).strict().merge(viewMeta);
-type SquasherViewMeta = Omit<TypeOf<typeof viewMeta>, 'definer'>; */
-
-export const kitInternals = object({
-	tables: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({ isDefaultAnExpression: boolean().optional() }).optional(),
-			),
-		}).optional(),
-	).optional(),
-	indexes: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({ isExpression: boolean().optional() }).optional(),
-			),
-		}).optional(),
-	).optional(),
-}).optional();
-
-// use main dialect
-const dialect = literal('singlestore');
-
-const schemaHash = object({
-	id: string(),
-	prevId: string(),
-});
-
-export const schemaInternal = object({
-	version: literal('1'),
-	dialect: dialect,
-	tables: record(string(), table),
-	/* views: record(string(), view).default({}), */
-	_meta: object({
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const schema = schemaInternal.merge(schemaHash);
-
-const tableSquashed = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()),
-	uniqueConstraints: record(string(), string()).default({}),
-}).strict();
-
-/* const viewSquashed = view.omit({
-	algorithm: true,
-	sqlSecurity: true,
-	withCheckOption: true,
-}).extend({ meta: string() }); */
-
-export const schemaSquashed = object({
-	version: literal('1'),
-	dialect: dialect,
-	tables: record(string(), tableSquashed),
-	/* views: record(string(), viewSquashed), */
-}).strict();
-
-export type Dialect = TypeOf<typeof dialect>;
-export type Column = TypeOf<typeof column>;
-export type Table = TypeOf<typeof table>;
-export type SingleStoreSchema = TypeOf<typeof schema>;
-export type SingleStoreSchemaInternal = TypeOf<typeof schemaInternal>;
-export type SingleStoreKitInternals = TypeOf<typeof kitInternals>;
-export type SingleStoreSchemaSquashed = TypeOf<typeof schemaSquashed>;
-export type Index = TypeOf<typeof index>;
-export type PrimaryKey = TypeOf<typeof compositePK>;
-export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
-/* export type View = TypeOf<typeof view>; */
-/* export type ViewSquashed = TypeOf<typeof viewSquashed>; */
-
-export const SingleStoreSquasher = {
-	squashIdx: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${idx.columns.join(',')};${idx.isUnique};${idx.using ?? ''};${idx.algorithm ?? ''};${
-			idx.lock ?? ''
-		}`;
-	},
-	unsquashIdx: (input: string): Index => {
-		const [name, columnsString, isUnique, using, algorithm, lock] = input.split(';');
-		const destructed = {
-			name,
-			columns: columnsString.split(','),
-			isUnique: isUnique === 'true',
-			using: using ? using : undefined,
-			algorithm: algorithm ? algorithm : undefined,
-			lock: lock ? lock : undefined,
-		};
-		return index.parse(destructed);
-	},
-	squashPK: (pk: PrimaryKey) => {
-		return `${pk.name};${pk.columns.join(',')}`;
-	},
-	unsquashPK: (pk: string): PrimaryKey => {
-		const splitted = pk.split(';');
-		return { name: splitted[0], columns: splitted[1].split(',') };
-	},
-	squashUnique: (unq: UniqueConstraint) => {
-		return `${unq.name};${unq.columns.join(',')}`;
-	},
-	unsquashUnique: (unq: string): UniqueConstraint => {
-		const [name, columns] = unq.split(';');
-		return { name, columns: columns.split(',') };
-	},
-	/* squashView: (view: View): string => {
-		return `${view.algorithm};${view.sqlSecurity};${view.withCheckOption}`;
-	},
-	unsquashView: (meta: string): SquasherViewMeta => {
-		const [algorithm, sqlSecurity, withCheckOption] = meta.split(';');
-		const toReturn = {
-			algorithm: algorithm,
-			sqlSecurity: sqlSecurity,
-			withCheckOption: withCheckOption !== 'undefined' ? withCheckOption : undefined,
-		};
-
-		return viewMeta.parse(toReturn);
-	}, */
-};
-
-export const squashSingleStoreScheme = (json: SingleStoreSchema): SingleStoreSchemaSquashed => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index) => {
-				return SingleStoreSquasher.squashIdx(index);
-			});
-
-			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-				return SingleStoreSquasher.squashPK(pk);
-			});
-
-			const squashedUniqueConstraints = mapValues(
-				it[1].uniqueConstraints,
-				(unq) => {
-					return SingleStoreSquasher.squashUnique(unq);
-				},
-			);
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					columns: it[1].columns,
-					indexes: squashedIndexes,
-					compositePrimaryKeys: squashedPKs,
-					uniqueConstraints: squashedUniqueConstraints,
-				},
-			];
-		}),
-	);
-
-	/* const mappedViews = Object.fromEntries(
-		Object.entries(json.views).map(([key, value]) => {
-			const meta = SingleStoreSquasher.squashView(value);
-
-			return [key, {
-				name: value.name,
-				isExisting: value.isExisting,
-				columns: value.columns,
-				definition: value.definition,
-				meta,
-			}];
-		}),
-	); */
-
-	return {
-		version: '1',
-		dialect: json.dialect,
-		tables: mappedTables,
-		/* views: mappedViews, */
-	};
-};
-
-export const singlestoreSchema = schema;
-export const singlestoreSchemaSquashed = schemaSquashed;
-
-// no prev version
-export const backwardCompatibleSingleStoreSchema = union([singlestoreSchema, schema]);
-
-export const drySingleStore = singlestoreSchema.parse({
-	version: '1',
-	dialect: 'singlestore',
-	id: originUUID,
-	prevId: '',
-	tables: {},
-	schemas: {},
-	/* views: {}, */
-	_meta: {
-		schemas: {},
-		tables: {},
-		columns: {},
-	},
-});
diff --git a/drizzle-kit/src/serializer/singlestoreSerializer.ts b/drizzle-kit/src/serializer/singlestoreSerializer.ts
deleted file mode 100644
index e65f53d258..0000000000
--- a/drizzle-kit/src/serializer/singlestoreSerializer.ts
+++ /dev/null
@@ -1,767 +0,0 @@
-import chalk from 'chalk';
-import { is, SQL } from 'drizzle-orm';
-import {
-	AnySingleStoreTable,
-	getTableConfig,
-	type PrimaryKey as PrimaryKeyORM,
-	SingleStoreDialect,
-	uniqueKeyName,
-} from 'drizzle-orm/singlestore-core';
-import { RowDataPacket } from 'mysql2/promise';
-import { withStyle } from '../cli/validations/outputs';
-import { IntrospectStage, IntrospectStatus } from '../cli/views';
-
-import { CasingType } from 'src/cli/validations/common';
-import type { DB } from '../utils';
-import {
-	Column,
-	Index,
-	PrimaryKey,
-	SingleStoreKitInternals,
-	SingleStoreSchemaInternal,
-	Table,
-	UniqueConstraint,
-} from './singlestoreSchema';
-import { sqlToStr } from './utils';
-
-const dialect = new SingleStoreDialect();
-
-export const indexName = (tableName: string, columns: string[]) => {
-	return `${tableName}_${columns.join('_')}_index`;
-};
-
-export const generateSingleStoreSnapshot = (
-	tables: AnySingleStoreTable[],
-	/* views: SingleStoreView[], */
-	casing: CasingType | undefined,
-): SingleStoreSchemaInternal => {
-	const dialect = new SingleStoreDialect({ casing });
-	const result: Record<string, Table> = {};
-	/* const resultViews: Record<string, View> = {}; */
-	const internal: SingleStoreKitInternals = { tables: {}, indexes: {} };
-	for (const table of tables) {
-		const {
-			name: tableName,
-			columns,
-			indexes,
-			schema,
-			primaryKeys,
-			uniqueConstraints,
-		} = getTableConfig(table);
-		const columnsObject: Record<string, Column> = {};
-		const indexesObject: Record<string, Index> = {};
-		const primaryKeysObject: Record<string, PrimaryKey> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-
-		columns.forEach((column) => {
-			const notNull: boolean = column.notNull;
-			const sqlTypeLowered = column.getSQLType().toLowerCase();
-			const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
-				? false
-				: (column as any).autoIncrement;
-
-			const generated = column.generated;
-
-			const columnToSet: Column = {
-				name: column.name,
-				type: column.getSQLType(),
-				primaryKey: false,
-				// If field is autoincrement it's notNull by default
-				// notNull: autoIncrement ? true : notNull,
-				notNull,
-				autoincrement: autoIncrement,
-				onUpdate: (column as any).hasOnUpdateNow,
-				generated: generated
-					? {
-						as: is(generated.as, SQL)
-							? dialect.sqlToQuery(generated.as as SQL).sql
-							: typeof generated.as === 'function'
-							? dialect.sqlToQuery(generated.as() as SQL).sql
-							: (generated.as as any),
-						type: generated.mode ?? 'stored',
-					}
-					: undefined,
-			};
-
-			if (column.primary) {
-				primaryKeysObject[`${tableName}_${column.name}`] = {
-					name: `${tableName}_${column.name}`,
-					columns: [column.name],
-				};
-			}
-
-			if (column.isUnique) {
-				const existingUnique = uniqueConstraintObject[column.uniqueName!];
-				if (typeof existingUnique !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. 
-          The unique constraint ${
-								chalk.underline.blue(
-									column.uniqueName,
-								)
-							} on the ${
-								chalk.underline.blue(
-									column.name,
-								)
-							} column is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`)
-						}`,
-					);
-					process.exit(1);
-				}
-				uniqueConstraintObject[column.uniqueName!] = {
-					name: column.uniqueName!,
-					columns: [columnToSet.name],
-				};
-			}
-
-			if (column.default !== undefined) {
-				if (is(column.default, SQL)) {
-					columnToSet.default = sqlToStr(column.default, casing);
-				} else {
-					if (typeof column.default === 'string') {
-						columnToSet.default = `'${column.default}'`;
-					} else {
-						if (sqlTypeLowered === 'json' || Array.isArray(column.default)) {
-							columnToSet.default = `'${JSON.stringify(column.default)}'`;
-						} else if (column.default instanceof Date) {
-							if (sqlTypeLowered === 'date') {
-								columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-							} else if (
-								sqlTypeLowered.startsWith('datetime')
-								|| sqlTypeLowered.startsWith('timestamp')
-							) {
-								columnToSet.default = `'${
-									column.default
-										.toISOString()
-										.replace('T', ' ')
-										.slice(0, 23)
-								}'`;
-							}
-						} else {
-							columnToSet.default = column.default;
-						}
-					}
-					// if (['blob', 'text', 'json'].includes(column.getSQLType())) {
-					// 	columnToSet.default = `(${columnToSet.default})`;
-					// }
-				}
-			}
-			columnsObject[column.name] = columnToSet;
-		});
-
-		primaryKeys.map((pk: PrimaryKeyORM) => {
-			const columnNames = pk.columns.map((c: any) => c.name);
-			primaryKeysObject[pk.getName()] = {
-				name: pk.getName(),
-				columns: columnNames,
-			};
-
-			// all composite pk's should be treated as notNull
-			for (const column of pk.columns) {
-				columnsObject[column.name].notNull = true;
-			}
-		});
-
-		uniqueConstraints?.map((unq) => {
-			const columnNames = unq.columns.map((c) => c.name);
-
-			const name = unq.name ?? uniqueKeyName(table, columnNames);
-
-			const existingUnique = uniqueConstraintObject[name];
-			if (typeof existingUnique !== 'undefined') {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. \nThe unique constraint ${
-								chalk.underline.blue(
-									name,
-								)
-							} on the ${
-								chalk.underline.blue(
-									columnNames.join(','),
-								)
-							} columns is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			uniqueConstraintObject[name] = {
-				name: unq.name!,
-				columns: columnNames,
-			};
-		});
-
-		indexes.forEach((value) => {
-			const columns = value.config.columns;
-			const name = value.config.name;
-
-			let indexColumns = columns.map((it) => {
-				if (is(it, SQL)) {
-					const sql = dialect.sqlToQuery(it, 'indexes').sql;
-					if (typeof internal!.indexes![name] === 'undefined') {
-						internal!.indexes![name] = {
-							columns: {
-								[sql]: {
-									isExpression: true,
-								},
-							},
-						};
-					} else {
-						if (typeof internal!.indexes![name]?.columns[sql] === 'undefined') {
-							internal!.indexes![name]!.columns[sql] = {
-								isExpression: true,
-							};
-						} else {
-							internal!.indexes![name]!.columns[sql]!.isExpression = true;
-						}
-					}
-					return sql;
-				} else {
-					return `${it.name}`;
-				}
-			});
-
-			if (value.config.unique) {
-				if (typeof uniqueConstraintObject[name] !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated unique constraint names in ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table. \nThe unique index ${
-									chalk.underline.blue(
-										name,
-									)
-								} on the ${
-									chalk.underline.blue(
-										indexColumns.join(','),
-									)
-								} columns is confilcting with a unique constraint name already defined for ${
-									chalk.underline.blue(
-										uniqueConstraintObject[name].columns.join(','),
-									)
-								} columns\n`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-			}
-
-			indexesObject[name] = {
-				name,
-				columns: indexColumns,
-				isUnique: value.config.unique ?? false,
-				using: value.config.using,
-				algorithm: value.config.algorythm,
-				lock: value.config.lock,
-			};
-		});
-
-		// only handle tables without schemas
-		if (!schema) {
-			result[tableName] = {
-				name: tableName,
-				columns: columnsObject,
-				indexes: indexesObject,
-				compositePrimaryKeys: primaryKeysObject,
-				uniqueConstraints: uniqueConstraintObject,
-			};
-		}
-	}
-
-	/* for (const view of views) {
-		const {
-			isExisting,
-			name,
-			query,
-			schema,
-			selectedFields,
-			algorithm,
-			sqlSecurity,
-			withCheckOption,
-		} = getViewConfig(view);
-
-		const columnsObject: Record<string, Column> = {};
-
-		const existingView = resultViews[name];
-		if (typeof existingView !== 'undefined') {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated view name across ${
-							chalk.underline.blue(
-								schema ?? 'public',
-							)
-						} schema. Please rename your view`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-		for (const key in selectedFields) {
-			if (is(selectedFields[key], SingleStoreColumn)) {
-				const column = selectedFields[key];
-
-				const notNull: boolean = column.notNull;
-				const sqlTypeLowered = column.getSQLType().toLowerCase();
-				const autoIncrement = typeof (column as any).autoIncrement === 'undefined'
-					? false
-					: (column as any).autoIncrement;
-
-				const generated = column.generated;
-
-				const columnToSet: Column = {
-					name: column.name,
-					type: column.getSQLType(),
-					primaryKey: false,
-					// If field is autoincrement it's notNull by default
-					// notNull: autoIncrement ? true : notNull,
-					notNull,
-					autoincrement: autoIncrement,
-					onUpdate: (column as any).hasOnUpdateNow,
-					generated: generated
-						? {
-							as: is(generated.as, SQL)
-								? dialect.sqlToQuery(generated.as as SQL).sql
-								: typeof generated.as === 'function'
-								? dialect.sqlToQuery(generated.as() as SQL).sql
-								: (generated.as as any),
-							type: generated.mode ?? 'stored',
-						}
-						: undefined,
-				};
-
-				if (column.default !== undefined) {
-					if (is(column.default, SQL)) {
-						columnToSet.default = sqlToStr(column.default, casing);
-					} else {
-						if (typeof column.default === 'string') {
-							columnToSet.default = `'${column.default}'`;
-						} else {
-							if (sqlTypeLowered === 'json') {
-								columnToSet.default = `'${JSON.stringify(column.default)}'`;
-							} else if (column.default instanceof Date) {
-								if (sqlTypeLowered === 'date') {
-									columnToSet.default = `'${column.default.toISOString().split('T')[0]}'`;
-								} else if (
-									sqlTypeLowered.startsWith('datetime')
-									|| sqlTypeLowered.startsWith('timestamp')
-								) {
-									columnToSet.default = `'${
-										column.default
-											.toISOString()
-											.replace('T', ' ')
-											.slice(0, 23)
-									}'`;
-								}
-							} else {
-								columnToSet.default = column.default;
-							}
-						}
-					}
-				}
-				columnsObject[column.name] = columnToSet;
-			}
-		}
-
-		resultViews[name] = {
-			columns: columnsObject,
-			name,
-			isExisting,
-			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
-			withCheckOption,
-			algorithm: algorithm ?? 'undefined', // set default values
-			sqlSecurity: sqlSecurity ?? 'definer', // set default values
-		};
-	} */
-
-	return {
-		version: '1',
-		dialect: 'singlestore',
-		tables: result,
-		/* views: resultViews, */
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-		internal,
-	};
-};
-
-function clearDefaults(defaultValue: any, collate: string) {
-	if (typeof collate === 'undefined' || collate === null) {
-		collate = `utf8mb4`;
-	}
-
-	let resultDefault = defaultValue;
-	collate = `_${collate}`;
-	if (defaultValue.startsWith(collate)) {
-		resultDefault = resultDefault
-			.substring(collate.length, defaultValue.length)
-			.replace(/\\/g, '');
-		if (resultDefault.startsWith("'") && resultDefault.endsWith("'")) {
-			return `('${resultDefault.substring(1, resultDefault.length - 1)}')`;
-		} else {
-			return `'${resultDefault}'`;
-		}
-	} else {
-		return `(${resultDefault})`;
-	}
-}
-
-export const fromDatabase = async (
-	db: DB,
-	inputSchema: string,
-	tablesFilter: (table: string) => boolean = (table) => true,
-	progressCallback?: (
-		stage: IntrospectStage,
-		count: number,
-		status: IntrospectStatus,
-	) => void,
-): Promise<SingleStoreSchemaInternal> => {
-	const result: Record<string, Table> = {};
-	const internals: SingleStoreKitInternals = { tables: {}, indexes: {} };
-
-	const columns = await db.query(`select * from information_schema.columns
-	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
-	order by table_name, ordinal_position;`);
-
-	const response = columns as RowDataPacket[];
-
-	const schemas: string[] = [];
-
-	let columnsCount = 0;
-	let tablesCount = new Set();
-	let indexesCount = 0;
-	/* let viewsCount = 0; */
-
-	const idxs = await db.query(
-		`select * from INFORMATION_SCHEMA.STATISTICS
-	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${inputSchema}' and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`,
-	);
-
-	const idxRows = idxs as RowDataPacket[];
-
-	for (const column of response) {
-		if (!tablesFilter(column['TABLE_NAME'] as string)) continue;
-
-		columnsCount += 1;
-		if (progressCallback) {
-			progressCallback('columns', columnsCount, 'fetching');
-		}
-		const schema: string = column['TABLE_SCHEMA'];
-		const tableName = column['TABLE_NAME'];
-
-		tablesCount.add(`${schema}.${tableName}`);
-		if (progressCallback) {
-			progressCallback('columns', tablesCount.size, 'fetching');
-		}
-		const columnName: string = column['COLUMN_NAME'];
-		const isNullable = column['IS_NULLABLE'] === 'YES'; // 'YES', 'NO'
-		const dataType = column['DATA_TYPE']; // varchar
-		const columnType = column['COLUMN_TYPE']; // varchar(256)
-		// const columnType = column["DATA_TYPE"];
-		const isPrimary = column['COLUMN_KEY'] === 'PRI'; // 'PRI', ''
-		let columnDefault: string | null = column['COLUMN_DEFAULT'];
-		const collation: string = column['CHARACTER_SET_NAME'];
-		const geenratedExpression: string = column['GENERATION_EXPRESSION'];
-
-		let columnExtra = column['EXTRA'];
-		let isAutoincrement = false; // 'auto_increment', ''
-		let isDefaultAnExpression = false; // 'auto_increment', ''
-
-		if (typeof column['EXTRA'] !== 'undefined') {
-			columnExtra = column['EXTRA'];
-			isAutoincrement = column['EXTRA'] === 'auto_increment'; // 'auto_increment', ''
-			isDefaultAnExpression = column['EXTRA'].includes('DEFAULT_GENERATED'); // 'auto_increment', ''
-		}
-
-		// if (isPrimary) {
-		//   if (typeof tableToPk[tableName] === "undefined") {
-		//     tableToPk[tableName] = [columnName];
-		//   } else {
-		//     tableToPk[tableName].push(columnName);
-		//   }
-		// }
-
-		if (schema !== inputSchema) {
-			schemas.push(schema);
-		}
-
-		const table = result[tableName];
-
-		// let changedType = columnType.replace("bigint unsigned", "serial")
-		let changedType = columnType;
-
-		if (columnType === 'bigint unsigned' && !isNullable && isAutoincrement) {
-			// check unique here
-			const uniqueIdx = idxRows.filter(
-				(it) =>
-					it['COLUMN_NAME'] === columnName
-					&& it['TABLE_NAME'] === tableName
-					&& it['NON_UNIQUE'] === 0,
-			);
-			if (uniqueIdx && uniqueIdx.length === 1) {
-				changedType = columnType.replace('bigint unsigned', 'serial');
-			}
-		}
-
-		if (
-			columnType.startsWith('bigint(')
-			|| columnType.startsWith('tinyint(')
-			|| columnType.startsWith('date(')
-			|| columnType.startsWith('int(')
-			|| columnType.startsWith('mediumint(')
-			|| columnType.startsWith('smallint(')
-			|| columnType.startsWith('text(')
-			|| columnType.startsWith('time(')
-			|| columnType.startsWith('year(')
-		) {
-			changedType = columnType.replace(/\(\s*[^)]*\)$/, '');
-		}
-
-		if (columnType.includes('decimal(10,0)')) {
-			changedType = columnType.replace('decimal(10,0)', 'decimal');
-		}
-
-		if (columnDefault?.endsWith('.')) {
-			columnDefault = columnDefault.slice(0, -1);
-		}
-
-		let onUpdate: boolean | undefined = undefined;
-		if (
-			columnType.startsWith('timestamp')
-			&& typeof columnExtra !== 'undefined'
-			&& columnExtra.includes('on update CURRENT_TIMESTAMP')
-		) {
-			onUpdate = true;
-		}
-
-		const newColumn: Column = {
-			default: columnDefault === null
-				? undefined
-				: /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault)
-						&& !['decimal', 'char', 'varchar'].some((type) => columnType.startsWith(type))
-				? Number(columnDefault)
-				: isDefaultAnExpression
-				? clearDefaults(columnDefault, collation)
-				: columnDefault.startsWith('CURRENT_TIMESTAMP')
-				? 'CURRENT_TIMESTAMP'
-				: `'${columnDefault}'`,
-			autoincrement: isAutoincrement,
-			name: columnName,
-			type: changedType,
-			primaryKey: false,
-			notNull: !isNullable,
-			onUpdate,
-			generated: geenratedExpression
-				? {
-					as: geenratedExpression,
-					type: columnExtra === 'VIRTUAL GENERATED' ? 'virtual' : 'stored',
-				}
-				: undefined,
-		};
-
-		// Set default to internal object
-		if (isDefaultAnExpression) {
-			if (typeof internals!.tables![tableName] === 'undefined') {
-				internals!.tables![tableName] = {
-					columns: {
-						[columnName]: {
-							isDefaultAnExpression: true,
-						},
-					},
-				};
-			} else {
-				if (
-					typeof internals!.tables![tableName]!.columns[columnName]
-						=== 'undefined'
-				) {
-					internals!.tables![tableName]!.columns[columnName] = {
-						isDefaultAnExpression: true,
-					};
-				} else {
-					internals!.tables![tableName]!.columns[
-						columnName
-					]!.isDefaultAnExpression = true;
-				}
-			}
-		}
-
-		if (!table) {
-			result[tableName] = {
-				name: tableName,
-				columns: {
-					[columnName]: newColumn,
-				},
-				compositePrimaryKeys: {},
-				indexes: {},
-				uniqueConstraints: {},
-			};
-		} else {
-			result[tableName]!.columns[columnName] = newColumn;
-		}
-	}
-
-	const tablePks = await db.query(
-		`SELECT table_name, column_name, ordinal_position
-  FROM information_schema.table_constraints t
-  LEFT JOIN information_schema.key_column_usage k
-  USING(constraint_name,table_schema,table_name)
-  WHERE t.constraint_type='UNIQUE'
-      and table_name != '__drizzle_migrations'
-      AND t.table_schema = '${inputSchema}'
-      ORDER BY ordinal_position`,
-	);
-
-	const tableToPk: { [tname: string]: string[] } = {};
-
-	const tableToPkRows = tablePks as RowDataPacket[];
-	for (const tableToPkRow of tableToPkRows) {
-		const tableName: string = tableToPkRow['table_name'];
-		const columnName: string = tableToPkRow['column_name'];
-		const position: string = tableToPkRow['ordinal_position'];
-
-		if (typeof result[tableName] === 'undefined') {
-			continue;
-		}
-
-		if (typeof tableToPk[tableName] === 'undefined') {
-			tableToPk[tableName] = [columnName];
-		} else {
-			tableToPk[tableName].push(columnName);
-		}
-	}
-
-	for (const [key, value] of Object.entries(tableToPk)) {
-		// if (value.length > 1) {
-		result[key].compositePrimaryKeys = {
-			[`${key}_${value.join('_')}`]: {
-				name: `${key}_${value.join('_')}`,
-				columns: value,
-			},
-		};
-		// } else if (value.length === 1) {
-		// result[key].columns[value[0]].primaryKey = true;
-		// } else {
-		// }
-	}
-	if (progressCallback) {
-		progressCallback('columns', columnsCount, 'done');
-		progressCallback('tables', tablesCount.size, 'done');
-	}
-
-	for (const idxRow of idxRows) {
-		const tableSchema = idxRow['TABLE_SCHEMA'];
-		const tableName = idxRow['TABLE_NAME'];
-		const constraintName = idxRow['INDEX_NAME'];
-		const columnName: string = idxRow['COLUMN_NAME'];
-		const isUnique = idxRow['NON_UNIQUE'] === 0;
-
-		const tableInResult = result[tableName];
-		if (typeof tableInResult === 'undefined') continue;
-
-		// if (tableInResult.columns[columnName].type === "serial") continue;
-
-		indexesCount += 1;
-		if (progressCallback) {
-			progressCallback('indexes', indexesCount, 'fetching');
-		}
-
-		if (isUnique) {
-			if (
-				typeof tableInResult.uniqueConstraints[constraintName] !== 'undefined'
-			) {
-				tableInResult.uniqueConstraints[constraintName]!.columns.push(
-					columnName,
-				);
-			} else {
-				tableInResult.uniqueConstraints[constraintName] = {
-					name: constraintName,
-					columns: [columnName],
-				};
-			}
-		}
-	}
-
-	/* const views = await db.query(
-		`select * from INFORMATION_SCHEMA.VIEWS WHERE table_schema = '${inputSchema}';`,
-	); */
-
-	/* const resultViews: Record<string, View> = {}; */
-
-	/* viewsCount = views.length;
-	if (progressCallback) {
-		progressCallback('views', viewsCount, 'fetching');
-	}
-	for await (const view of views) {
-		const viewName = view['TABLE_NAME'];
-		const definition = view['VIEW_DEFINITION'];
-
-		const withCheckOption = view['CHECK_OPTION'] === 'NONE'
-			? undefined
-			: view['CHECK_OPTION'].toLowerCase();
-		const sqlSecurity = view['SECURITY_TYPE'].toLowerCase();
-
-		const [createSqlStatement] = await db.query(
-			`SHOW CREATE VIEW \`${viewName}\`;`,
-		);
-		const algorithmMatch = createSqlStatement['Create View'].match(/ALGORITHM=([^ ]+)/);
-		const algorithm = algorithmMatch
-			? algorithmMatch[1].toLowerCase()
-			: undefined;
-
-		const columns = result[viewName].columns;
-		delete result[viewName];
-
-		resultViews[viewName] = {
-			columns: columns,
-			isExisting: false,
-			name: viewName,
-			algorithm,
-			definition,
-			sqlSecurity,
-			withCheckOption,
-		};
-	} */
-
-	if (progressCallback) {
-		progressCallback('indexes', indexesCount, 'done');
-		// progressCallback("enums", 0, "fetching");
-		progressCallback('enums', 0, 'done');
-	}
-
-	return {
-		version: '1',
-		dialect: 'singlestore',
-		tables: result,
-		/* views: resultViews, */
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-		internal: internals,
-	};
-};
diff --git a/drizzle-kit/src/serializer/sqliteImports.ts b/drizzle-kit/src/serializer/sqliteImports.ts
deleted file mode 100644
index 0164604d11..0000000000
--- a/drizzle-kit/src/serializer/sqliteImports.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { is } from 'drizzle-orm';
-import { AnySQLiteTable, SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
-import { safeRegister } from '../cli/commands/utils';
-
-export const prepareFromExports = (exports: Record<string, unknown>) => {
-	const tables: AnySQLiteTable[] = [];
-	const views: SQLiteView[] = [];
-
-	const i0values = Object.values(exports);
-	i0values.forEach((t) => {
-		if (is(t, SQLiteTable)) {
-			tables.push(t);
-		}
-
-		if (is(t, SQLiteView)) {
-			views.push(t);
-		}
-	});
-
-	return { tables, views };
-};
-
-export const prepareFromSqliteImports = async (imports: string[]) => {
-	const tables: AnySQLiteTable[] = [];
-	const views: SQLiteView[] = [];
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const prepared = prepareFromExports(i0);
-
-		tables.push(...prepared.tables);
-		views.push(...prepared.views);
-	}
-
-	unregister();
-
-	return { tables: Array.from(new Set(tables)), views };
-};
diff --git a/drizzle-kit/src/serializer/sqliteSchema.ts b/drizzle-kit/src/serializer/sqliteSchema.ts
deleted file mode 100644
index 8fd98d99d5..0000000000
--- a/drizzle-kit/src/serializer/sqliteSchema.ts
+++ /dev/null
@@ -1,352 +0,0 @@
-import { any, boolean, enum as enumType, literal, object, record, string, TypeOf, union } from 'zod';
-import { customMapEntries, mapValues, originUUID } from '../global';
-
-// ------- V3 --------
-const index = object({
-	name: string(),
-	columns: string().array(),
-	where: string().optional(),
-	isUnique: boolean(),
-}).strict();
-
-const fk = object({
-	name: string(),
-	tableFrom: string(),
-	columnsFrom: string().array(),
-	tableTo: string(),
-	columnsTo: string().array(),
-	onUpdate: string().optional(),
-	onDelete: string().optional(),
-}).strict();
-
-const compositePK = object({
-	columns: string().array(),
-	name: string().optional(),
-}).strict();
-
-const column = object({
-	name: string(),
-	type: string(),
-	primaryKey: boolean(),
-	notNull: boolean(),
-	autoincrement: boolean().optional(),
-	default: any().optional(),
-	generated: object({
-		type: enumType(['stored', 'virtual']),
-		as: string(),
-	}).optional(),
-}).strict();
-
-const tableV3 = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-}).strict();
-
-const uniqueConstraint = object({
-	name: string(),
-	columns: string().array(),
-}).strict();
-
-const checkConstraint = object({
-	name: string(),
-	value: string(),
-}).strict();
-
-const table = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), index),
-	foreignKeys: record(string(), fk),
-	compositePrimaryKeys: record(string(), compositePK),
-	uniqueConstraints: record(string(), uniqueConstraint).default({}),
-	checkConstraints: record(string(), checkConstraint).default({}),
-}).strict();
-
-export const view = object({
-	name: string(),
-	columns: record(string(), column),
-	definition: string().optional(),
-	isExisting: boolean(),
-}).strict();
-
-// use main dialect
-const dialect = enumType(['sqlite']);
-
-const schemaHash = object({
-	id: string(),
-	prevId: string(),
-}).strict();
-
-export const schemaInternalV3 = object({
-	version: literal('3'),
-	dialect: dialect,
-	tables: record(string(), tableV3),
-	enums: object({}),
-}).strict();
-
-export const schemaInternalV4 = object({
-	version: literal('4'),
-	dialect: dialect,
-	tables: record(string(), table),
-	views: record(string(), view).default({}),
-	enums: object({}),
-}).strict();
-
-export const schemaInternalV5 = object({
-	version: literal('5'),
-	dialect: dialect,
-	tables: record(string(), table),
-	enums: object({}),
-	_meta: object({
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-}).strict();
-
-export const kitInternals = object({
-	indexes: record(
-		string(),
-		object({
-			columns: record(
-				string(),
-				object({ isExpression: boolean().optional() }).optional(),
-			),
-		}).optional(),
-	).optional(),
-}).optional();
-
-const latestVersion = literal('6');
-export const schemaInternal = object({
-	version: latestVersion,
-	dialect: dialect,
-	tables: record(string(), table),
-	views: record(string(), view).default({}),
-	enums: object({}),
-	_meta: object({
-		tables: record(string(), string()),
-		columns: record(string(), string()),
-	}),
-	internal: kitInternals,
-}).strict();
-
-export const schemaV3 = schemaInternalV3.merge(schemaHash).strict();
-export const schemaV4 = schemaInternalV4.merge(schemaHash).strict();
-export const schemaV5 = schemaInternalV5.merge(schemaHash).strict();
-export const schema = schemaInternal.merge(schemaHash).strict();
-
-const tableSquashed = object({
-	name: string(),
-	columns: record(string(), column),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()),
-	uniqueConstraints: record(string(), string()).default({}),
-	checkConstraints: record(string(), string()).default({}),
-}).strict();
-
-export const schemaSquashed = object({
-	version: latestVersion,
-	dialect: dialect,
-	tables: record(string(), tableSquashed),
-	views: record(string(), view),
-	enums: any(),
-}).strict();
-
-export type Dialect = TypeOf<typeof dialect>;
-export type Column = TypeOf<typeof column>;
-export type Table = TypeOf<typeof table>;
-export type SQLiteSchema = TypeOf<typeof schema>;
-export type SQLiteSchemaV3 = TypeOf<typeof schemaV3>;
-export type SQLiteSchemaV4 = TypeOf<typeof schemaV4>;
-export type SQLiteSchemaInternal = TypeOf<typeof schemaInternal>;
-export type SQLiteSchemaSquashed = TypeOf<typeof schemaSquashed>;
-export type SQLiteKitInternals = TypeOf<typeof kitInternals>;
-export type Index = TypeOf<typeof index>;
-export type ForeignKey = TypeOf<typeof fk>;
-export type PrimaryKey = TypeOf<typeof compositePK>;
-export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
-export type CheckConstraint = TypeOf<typeof checkConstraint>;
-export type View = TypeOf<typeof view>;
-
-export const SQLiteSquasher = {
-	squashIdx: (idx: Index) => {
-		index.parse(idx);
-		return `${idx.name};${idx.columns.join(',')};${idx.isUnique};${idx.where ?? ''}`;
-	},
-	unsquashIdx: (input: string): Index => {
-		const [name, columnsString, isUnique, where] = input.split(';');
-
-		const result: Index = index.parse({
-			name,
-			columns: columnsString.split(','),
-			isUnique: isUnique === 'true',
-			where: where ?? undefined,
-		});
-		return result;
-	},
-	squashUnique: (unq: UniqueConstraint) => {
-		return `${unq.name};${unq.columns.join(',')}`;
-	},
-	unsquashUnique: (unq: string): UniqueConstraint => {
-		const [name, columns] = unq.split(';');
-		return { name, columns: columns.split(',') };
-	},
-	squashFK: (fk: ForeignKey) => {
-		return `${fk.name};${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${
-			fk.onUpdate ?? ''
-		};${fk.onDelete ?? ''}`;
-	},
-	unsquashFK: (input: string): ForeignKey => {
-		const [
-			name,
-			tableFrom,
-			columnsFromStr,
-			tableTo,
-			columnsToStr,
-			onUpdate,
-			onDelete,
-		] = input.split(';');
-
-		const result: ForeignKey = fk.parse({
-			name,
-			tableFrom,
-			columnsFrom: columnsFromStr.split(','),
-			tableTo,
-			columnsTo: columnsToStr.split(','),
-			onUpdate,
-			onDelete,
-		});
-		return result;
-	},
-	squashPushFK: (fk: ForeignKey) => {
-		return `${fk.tableFrom};${fk.columnsFrom.join(',')};${fk.tableTo};${fk.columnsTo.join(',')};${fk.onUpdate ?? ''};${
-			fk.onDelete ?? ''
-		}`;
-	},
-	unsquashPushFK: (input: string): ForeignKey => {
-		const [
-			tableFrom,
-			columnsFromStr,
-			tableTo,
-			columnsToStr,
-			onUpdate,
-			onDelete,
-		] = input.split(';');
-
-		const result: ForeignKey = fk.parse({
-			name: '',
-			tableFrom,
-			columnsFrom: columnsFromStr.split(','),
-			tableTo,
-			columnsTo: columnsToStr.split(','),
-			onUpdate,
-			onDelete,
-		});
-		return result;
-	},
-	squashPK: (pk: PrimaryKey) => {
-		return pk.columns.join(',');
-	},
-	unsquashPK: (pk: string) => {
-		return pk.split(',');
-	},
-	squashCheck: (check: CheckConstraint) => {
-		return `${check.name};${check.value}`;
-	},
-	unsquashCheck: (input: string): CheckConstraint => {
-		const [
-			name,
-			value,
-		] = input.split(';');
-
-		return { name, value };
-	},
-};
-
-export const squashSqliteScheme = (
-	json: SQLiteSchema | SQLiteSchemaV4,
-	action?: 'push' | undefined,
-): SQLiteSchemaSquashed => {
-	const mappedTables = Object.fromEntries(
-		Object.entries(json.tables).map((it) => {
-			const squashedIndexes = mapValues(it[1].indexes, (index: Index) => {
-				return SQLiteSquasher.squashIdx(index);
-			});
-
-			const squashedFKs = customMapEntries<string, ForeignKey>(
-				it[1].foreignKeys,
-				(key, value) => {
-					return action === 'push'
-						? [
-							SQLiteSquasher.squashPushFK(value),
-							SQLiteSquasher.squashPushFK(value),
-						]
-						: [key, SQLiteSquasher.squashFK(value)];
-				},
-			);
-
-			const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-				return SQLiteSquasher.squashPK(pk);
-			});
-
-			const squashedUniqueConstraints = mapValues(
-				it[1].uniqueConstraints,
-				(unq) => {
-					return SQLiteSquasher.squashUnique(unq);
-				},
-			);
-
-			const squashedCheckConstraints = mapValues(
-				it[1].checkConstraints,
-				(check) => {
-					return SQLiteSquasher.squashCheck(check);
-				},
-			);
-
-			return [
-				it[0],
-				{
-					name: it[1].name,
-					columns: it[1].columns,
-					indexes: squashedIndexes,
-					foreignKeys: squashedFKs,
-					compositePrimaryKeys: squashedPKs,
-					uniqueConstraints: squashedUniqueConstraints,
-					checkConstraints: squashedCheckConstraints,
-				},
-			];
-		}),
-	);
-
-	return {
-		version: '6',
-		dialect: json.dialect,
-		tables: mappedTables,
-		views: json.views,
-		enums: json.enums,
-	};
-};
-
-export const drySQLite = schema.parse({
-	version: '6',
-	dialect: 'sqlite',
-	id: originUUID,
-	prevId: '',
-	tables: {},
-	views: {},
-	enums: {},
-	_meta: {
-		tables: {},
-		columns: {},
-	},
-});
-
-export const sqliteSchemaV3 = schemaV3;
-export const sqliteSchemaV4 = schemaV4;
-export const sqliteSchemaV5 = schemaV5;
-export const sqliteSchema = schema;
-export const SQLiteSchemaSquashed = schemaSquashed;
-
-export const backwardCompatibleSqliteSchema = union([sqliteSchemaV5, schema]);
diff --git a/drizzle-kit/src/serializer/sqliteSerializer.ts b/drizzle-kit/src/serializer/sqliteSerializer.ts
deleted file mode 100644
index 87b44fa1b4..0000000000
--- a/drizzle-kit/src/serializer/sqliteSerializer.ts
+++ /dev/null
@@ -1,953 +0,0 @@
-import chalk from 'chalk';
-import { getTableName, is, SQL } from 'drizzle-orm';
-import {
-	AnySQLiteTable,
-	getTableConfig,
-	getViewConfig,
-	SQLiteBaseInteger,
-	SQLiteColumn,
-	SQLiteSyncDialect,
-	SQLiteView,
-	uniqueKeyName,
-} from 'drizzle-orm/sqlite-core';
-import { CasingType } from 'src/cli/validations/common';
-import { withStyle } from '../cli/validations/outputs';
-import type { IntrospectStage, IntrospectStatus } from '../cli/views';
-import type {
-	CheckConstraint,
-	Column,
-	ForeignKey,
-	Index,
-	PrimaryKey,
-	SQLiteKitInternals,
-	SQLiteSchemaInternal,
-	Table,
-	UniqueConstraint,
-	View,
-} from '../serializer/sqliteSchema';
-import { escapeSingleQuotes, type SQLiteDB } from '../utils';
-import { getColumnCasing, sqlToStr } from './utils';
-
-export const generateSqliteSnapshot = (
-	tables: AnySQLiteTable[],
-	views: SQLiteView[],
-	casing: CasingType | undefined,
-): SQLiteSchemaInternal => {
-	const dialect = new SQLiteSyncDialect({ casing });
-	const result: Record<string, Table> = {};
-	const resultViews: Record<string, View> = {};
-
-	const internal: SQLiteKitInternals = { indexes: {} };
-	for (const table of tables) {
-		// const tableName = getTableName(table);
-		const columnsObject: Record<string, Column> = {};
-		const indexesObject: Record<string, Index> = {};
-		const foreignKeysObject: Record<string, ForeignKey> = {};
-		const primaryKeysObject: Record<string, PrimaryKey> = {};
-		const uniqueConstraintObject: Record<string, UniqueConstraint> = {};
-		const checkConstraintObject: Record<string, CheckConstraint> = {};
-
-		const checksInTable: Record<string, string[]> = {};
-
-		const {
-			name: tableName,
-			columns,
-			indexes,
-			checks,
-			foreignKeys: tableForeignKeys,
-			primaryKeys,
-			uniqueConstraints,
-		} = getTableConfig(table);
-
-		columns.forEach((column) => {
-			const name = getColumnCasing(column, casing);
-			const notNull: boolean = column.notNull;
-			const primaryKey: boolean = column.primary;
-			const generated = column.generated;
-
-			const columnToSet: Column = {
-				name,
-				type: column.getSQLType(),
-				primaryKey,
-				notNull,
-				autoincrement: is(column, SQLiteBaseInteger)
-					? column.autoIncrement
-					: false,
-				generated: generated
-					? {
-						as: is(generated.as, SQL)
-							? `(${dialect.sqlToQuery(generated.as as SQL, 'indexes').sql})`
-							: typeof generated.as === 'function'
-							? `(${dialect.sqlToQuery(generated.as() as SQL, 'indexes').sql})`
-							: `(${generated.as as any})`,
-						type: generated.mode ?? 'virtual',
-					}
-					: undefined,
-			};
-
-			if (column.default !== undefined) {
-				if (is(column.default, SQL)) {
-					columnToSet.default = sqlToStr(column.default, casing);
-				} else {
-					columnToSet.default = typeof column.default === 'string'
-						? `'${escapeSingleQuotes(column.default)}'`
-						: typeof column.default === 'object'
-								|| Array.isArray(column.default)
-						? `'${JSON.stringify(column.default)}'`
-						: column.default;
-				}
-			}
-			columnsObject[name] = columnToSet;
-
-			if (column.isUnique) {
-				const existingUnique = indexesObject[column.uniqueName!];
-				if (typeof existingUnique !== 'undefined') {
-					console.log(
-						`\n${
-							withStyle.errorWarning(`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. 
-          The unique constraint ${
-								chalk.underline.blue(
-									column.uniqueName,
-								)
-							} on the ${
-								chalk.underline.blue(
-									name,
-								)
-							} column is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`)
-						}`,
-					);
-					process.exit(1);
-				}
-				indexesObject[column.uniqueName!] = {
-					name: column.uniqueName!,
-					columns: [columnToSet.name],
-					isUnique: true,
-				};
-			}
-		});
-
-		const foreignKeys: ForeignKey[] = tableForeignKeys.map((fk) => {
-			const tableFrom = tableName;
-			const onDelete = fk.onDelete ?? 'no action';
-			const onUpdate = fk.onUpdate ?? 'no action';
-			const reference = fk.reference();
-
-			const referenceFT = reference.foreignTable;
-
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-			const tableTo = getTableName(referenceFT);
-
-			const originalColumnsFrom = reference.columns.map((it) => it.name);
-			const columnsFrom = reference.columns.map((it) => getColumnCasing(it, casing));
-			const originalColumnsTo = reference.foreignColumns.map((it) => it.name);
-			const columnsTo = reference.foreignColumns.map((it) => getColumnCasing(it, casing));
-
-			let name = fk.getName();
-			if (casing !== undefined) {
-				for (let i = 0; i < originalColumnsFrom.length; i++) {
-					name = name.replace(originalColumnsFrom[i], columnsFrom[i]);
-				}
-				for (let i = 0; i < originalColumnsTo.length; i++) {
-					name = name.replace(originalColumnsTo[i], columnsTo[i]);
-				}
-			}
-
-			return {
-				name,
-				tableFrom,
-				tableTo,
-				columnsFrom,
-				columnsTo,
-				onDelete,
-				onUpdate,
-			} as ForeignKey;
-		});
-
-		foreignKeys.forEach((it) => {
-			foreignKeysObject[it.name] = it;
-		});
-
-		indexes.forEach((value) => {
-			const columns = value.config.columns;
-			const name = value.config.name;
-
-			let indexColumns = columns.map((it) => {
-				if (is(it, SQL)) {
-					const sql = dialect.sqlToQuery(it, 'indexes').sql;
-					if (typeof internal!.indexes![name] === 'undefined') {
-						internal!.indexes![name] = {
-							columns: {
-								[sql]: {
-									isExpression: true,
-								},
-							},
-						};
-					} else {
-						if (typeof internal!.indexes![name]?.columns[sql] === 'undefined') {
-							internal!.indexes![name]!.columns[sql] = {
-								isExpression: true,
-							};
-						} else {
-							internal!.indexes![name]!.columns[sql]!.isExpression = true;
-						}
-					}
-					return sql;
-				} else {
-					return getColumnCasing(it, casing);
-				}
-			});
-
-			let where: string | undefined = undefined;
-			if (value.config.where !== undefined) {
-				if (is(value.config.where, SQL)) {
-					where = dialect.sqlToQuery(value.config.where).sql;
-				}
-			}
-
-			indexesObject[name] = {
-				name,
-				columns: indexColumns,
-				isUnique: value.config.unique ?? false,
-				where,
-			};
-		});
-
-		uniqueConstraints?.map((unq) => {
-			const columnNames = unq.columns.map((c) => getColumnCasing(c, casing));
-
-			const name = unq.name ?? uniqueKeyName(table, columnNames);
-
-			const existingUnique = indexesObject[name];
-			if (typeof existingUnique !== 'undefined') {
-				console.log(
-					`\n${
-						withStyle.errorWarning(
-							`We\'ve found duplicated unique constraint names in ${
-								chalk.underline.blue(
-									tableName,
-								)
-							} table. \nThe unique constraint ${
-								chalk.underline.blue(
-									name,
-								)
-							} on the ${
-								chalk.underline.blue(
-									columnNames.join(','),
-								)
-							} columns is confilcting with a unique constraint name already defined for ${
-								chalk.underline.blue(
-									existingUnique.columns.join(','),
-								)
-							} columns\n`,
-						)
-					}`,
-				);
-				process.exit(1);
-			}
-
-			indexesObject[name] = {
-				name: unq.name!,
-				columns: columnNames,
-				isUnique: true,
-			};
-		});
-
-		primaryKeys.forEach((it) => {
-			if (it.columns.length > 1) {
-				const originalColumnNames = it.columns.map((c) => c.name);
-				const columnNames = it.columns.map((c) => getColumnCasing(c, casing));
-
-				let name = it.getName();
-				if (casing !== undefined) {
-					for (let i = 0; i < originalColumnNames.length; i++) {
-						name = name.replace(originalColumnNames[i], columnNames[i]);
-					}
-				}
-
-				primaryKeysObject[name] = {
-					columns: columnNames,
-					name,
-				};
-			} else {
-				columnsObject[getColumnCasing(it.columns[0], casing)].primaryKey = true;
-			}
-		});
-
-		checks.forEach((check) => {
-			const checkName = check.name;
-			if (typeof checksInTable[tableName] !== 'undefined') {
-				if (checksInTable[tableName].includes(check.name)) {
-					console.log(
-						`\n${
-							withStyle.errorWarning(
-								`We\'ve found duplicated check constraint name in ${
-									chalk.underline.blue(
-										tableName,
-									)
-								}. Please rename your check constraint in the ${
-									chalk.underline.blue(
-										tableName,
-									)
-								} table`,
-							)
-						}`,
-					);
-					process.exit(1);
-				}
-				checksInTable[tableName].push(checkName);
-			} else {
-				checksInTable[tableName] = [check.name];
-			}
-
-			checkConstraintObject[checkName] = {
-				name: checkName,
-				value: dialect.sqlToQuery(check.value).sql,
-			};
-		});
-
-		result[tableName] = {
-			name: tableName,
-			columns: columnsObject,
-			indexes: indexesObject,
-			foreignKeys: foreignKeysObject,
-			compositePrimaryKeys: primaryKeysObject,
-			uniqueConstraints: uniqueConstraintObject,
-			checkConstraints: checkConstraintObject,
-		};
-	}
-
-	for (const view of views) {
-		const { name, isExisting, selectedFields, query, schema } = getViewConfig(view);
-
-		const columnsObject: Record<string, Column> = {};
-
-		const existingView = resultViews[name];
-		if (typeof existingView !== 'undefined') {
-			console.log(
-				`\n${
-					withStyle.errorWarning(
-						`We\'ve found duplicated view name across ${
-							chalk.underline.blue(
-								schema ?? 'public',
-							)
-						} schema. Please rename your view`,
-					)
-				}`,
-			);
-			process.exit(1);
-		}
-
-		for (const key in selectedFields) {
-			if (is(selectedFields[key], SQLiteColumn)) {
-				const column = selectedFields[key];
-				const notNull: boolean = column.notNull;
-				const primaryKey: boolean = column.primary;
-				const generated = column.generated;
-
-				const columnToSet: Column = {
-					name: column.name,
-					type: column.getSQLType(),
-					primaryKey,
-					notNull,
-					autoincrement: is(column, SQLiteBaseInteger)
-						? column.autoIncrement
-						: false,
-					generated: generated
-						? {
-							as: is(generated.as, SQL)
-								? `(${dialect.sqlToQuery(generated.as as SQL, 'indexes').sql})`
-								: typeof generated.as === 'function'
-								? `(${dialect.sqlToQuery(generated.as() as SQL, 'indexes').sql})`
-								: `(${generated.as as any})`,
-							type: generated.mode ?? 'virtual',
-						}
-						: undefined,
-				};
-
-				if (column.default !== undefined) {
-					if (is(column.default, SQL)) {
-						columnToSet.default = sqlToStr(column.default, casing);
-					} else {
-						columnToSet.default = typeof column.default === 'string'
-							? `'${column.default}'`
-							: typeof column.default === 'object'
-									|| Array.isArray(column.default)
-							? `'${JSON.stringify(column.default)}'`
-							: column.default;
-					}
-				}
-				columnsObject[column.name] = columnToSet;
-			}
-		}
-
-		resultViews[name] = {
-			columns: columnsObject,
-			name,
-			isExisting,
-			definition: isExisting ? undefined : dialect.sqlToQuery(query!).sql,
-		};
-	}
-
-	return {
-		version: '6',
-		dialect: 'sqlite',
-		tables: result,
-		views: resultViews,
-		enums: {},
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-		internal,
-	};
-};
-
-function mapSqlToSqliteType(sqlType: string): string {
-	const lowered = sqlType.toLowerCase();
-	if (
-		[
-			'int',
-			'integer',
-			'integer auto_increment',
-			'tinyint',
-			'smallint',
-			'mediumint',
-			'bigint',
-			'unsigned big int',
-			'int2',
-			'int8',
-		].some((it) => lowered.startsWith(it))
-	) {
-		return 'integer';
-	} else if (
-		[
-			'character',
-			'varchar',
-			'varying character',
-			'national varying character',
-			'nchar',
-			'native character',
-			'nvarchar',
-			'text',
-			'clob',
-		].some((it) => lowered.startsWith(it))
-	) {
-		const match = lowered.match(/\d+/);
-
-		if (match) {
-			return `text(${match[0]})`;
-		}
-
-		return 'text';
-	} else if (lowered.startsWith('blob')) {
-		return 'blob';
-	} else if (
-		['real', 'double', 'double precision', 'float'].some((it) => lowered.startsWith(it))
-	) {
-		return 'real';
-	} else {
-		return 'numeric';
-	}
-}
-
-interface ColumnInfo {
-	columnName: string;
-	expression: string;
-	type: 'stored' | 'virtual';
-}
-
-function extractGeneratedColumns(input: string): Record<string, ColumnInfo> {
-	const columns: Record<string, ColumnInfo> = {};
-	const lines = input.split(/,\s*(?![^()]*\))/); // Split by commas outside parentheses
-
-	for (const line of lines) {
-		if (line.includes('GENERATED ALWAYS AS')) {
-			const parts = line.trim().split(/\s+/);
-			const columnName = parts[0].replace(/[`'"]/g, ''); // Remove quotes around the column name
-			const expression = line
-				.substring(line.indexOf('('), line.indexOf(')') + 1)
-				.trim();
-
-			// Extract type ensuring to remove any trailing characters like ')'
-			const typeIndex = parts.findIndex((part) => part.match(/(stored|virtual)/i));
-			let type: ColumnInfo['type'] = 'virtual';
-			if (typeIndex !== -1) {
-				type = parts[typeIndex]
-					.replace(/[^a-z]/gi, '')
-					.toLowerCase() as ColumnInfo['type'];
-			}
-
-			columns[columnName] = {
-				columnName: columnName,
-				expression: expression,
-				type,
-			};
-		}
-	}
-	return columns;
-}
-
-function filterIgnoredTablesByField(fieldName: string) {
-	// _cf_ is a prefix for internal Cloudflare D1 tables (e.g. _cf_KV, _cf_METADATA)
-	// _litestream_ is a prefix for internal Litestream tables (e.g. _litestream_seq, _litestream_lock)
-	// libsql_ is a prefix for internal libSQL tables (e.g. libsql_wasm_func_table)
-	// sqlite_ is a prefix for internal SQLite tables (e.g. sqlite_sequence, sqlite_stat1)
-	return `${fieldName} != '__drizzle_migrations'
-			AND ${fieldName} NOT LIKE '\\_cf\\_%' ESCAPE '\\'
-			AND ${fieldName} NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
-			AND ${fieldName} NOT LIKE 'libsql\\_%' ESCAPE '\\'
-			AND ${fieldName} NOT LIKE 'sqlite\\_%' ESCAPE '\\'`;
-}
-
-export const fromDatabase = async (
-	db: SQLiteDB,
-	tablesFilter: (table: string) => boolean = (table) => true,
-	progressCallback?: (
-		stage: IntrospectStage,
-		count: number,
-		status: IntrospectStatus,
-	) => void,
-): Promise<SQLiteSchemaInternal> => {
-	const result: Record<string, Table> = {};
-	const resultViews: Record<string, View> = {};
-
-	const columns = await db.query<{
-		tableName: string;
-		columnName: string;
-		columnType: string;
-		notNull: number;
-		defaultValue: string;
-		pk: number;
-		seq: number;
-		hidden: number;
-		sql: string;
-		type: 'view' | 'table';
-	}>(`SELECT 
-		  m.name as "tableName",
-		  p.name as "columnName",
-		  p.type as "columnType",
-		  p."notnull" as "notNull",
-		  p.dflt_value as "defaultValue",
-		  p.pk as pk,
-		  p.hidden as hidden,
-		  m.sql,
-		  m.type as type
-		FROM sqlite_master AS m
-		JOIN pragma_table_xinfo(m.name) AS p
-		WHERE (m.type = 'table' OR m.type = 'view') 
-		  AND ${filterIgnoredTablesByField('m.tbl_name')};`);
-
-	const tablesWithSeq: string[] = [];
-
-	const seq = await db.query<{
-		name: string;
-	}>(`SELECT
-		  *
-		FROM sqlite_master
-		WHERE sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*'
-    	  AND ${filterIgnoredTablesByField('tbl_name')};`);
-
-	for (const s of seq) {
-		tablesWithSeq.push(s.name);
-	}
-
-	let columnsCount = 0;
-	let tablesCount = new Set();
-	let indexesCount = 0;
-	let foreignKeysCount = 0;
-	let checksCount = 0;
-	let viewsCount = 0;
-
-	// append primaryKeys by table
-	const tableToPk: { [tname: string]: string[] } = {};
-
-	let tableToGeneratedColumnsInfo: Record<
-		string,
-		Record<string, ColumnInfo>
-	> = {};
-
-	for (const column of columns) {
-		if (!tablesFilter(column.tableName)) continue;
-
-		// TODO
-		if (column.type !== 'view') {
-			columnsCount += 1;
-		}
-		if (progressCallback) {
-			progressCallback('columns', columnsCount, 'fetching');
-		}
-		const tableName = column.tableName;
-
-		tablesCount.add(tableName);
-		if (progressCallback) {
-			progressCallback('tables', tablesCount.size, 'fetching');
-		}
-		const columnName = column.columnName;
-		const isNotNull = column.notNull === 1; // 'YES', 'NO'
-		const columnType = column.columnType; // varchar(256)
-		const isPrimary = column.pk !== 0; // 'PRI', ''
-		const columnDefault: string = column.defaultValue;
-
-		const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
-
-		if (isPrimary) {
-			if (typeof tableToPk[tableName] === 'undefined') {
-				tableToPk[tableName] = [columnName];
-			} else {
-				tableToPk[tableName].push(columnName);
-			}
-		}
-
-		const table = result[tableName];
-
-		if (column.hidden === 2 || column.hidden === 3) {
-			if (
-				typeof tableToGeneratedColumnsInfo[column.tableName] === 'undefined'
-			) {
-				tableToGeneratedColumnsInfo[column.tableName] = extractGeneratedColumns(
-					column.sql,
-				);
-			}
-		}
-
-		const newColumn: Column = {
-			default: columnDefault === null
-				? undefined
-				: /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault)
-				? Number(columnDefault)
-				: ['CURRENT_TIME', 'CURRENT_DATE', 'CURRENT_TIMESTAMP'].includes(
-						columnDefault,
-					)
-				? `(${columnDefault})`
-				: columnDefault === 'false'
-				? false
-				: columnDefault === 'true'
-				? true
-				: columnDefault.startsWith("'") && columnDefault.endsWith("'")
-				? columnDefault
-				// ? columnDefault.substring(1, columnDefault.length - 1)
-				: `(${columnDefault})`,
-			autoincrement: isAutoincrement,
-			name: columnName,
-			type: mapSqlToSqliteType(columnType),
-			primaryKey: false,
-			notNull: isNotNull,
-			generated: tableToGeneratedColumnsInfo[tableName]
-					&& tableToGeneratedColumnsInfo[tableName][columnName]
-				? {
-					type: tableToGeneratedColumnsInfo[tableName][columnName].type,
-					as: tableToGeneratedColumnsInfo[tableName][columnName].expression,
-				}
-				: undefined,
-		};
-
-		if (!table) {
-			result[tableName] = {
-				name: tableName,
-				columns: {
-					[columnName]: newColumn,
-				},
-				compositePrimaryKeys: {},
-				indexes: {},
-				foreignKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			};
-		} else {
-			result[tableName]!.columns[columnName] = newColumn;
-		}
-	}
-
-	for (const [key, value] of Object.entries(tableToPk)) {
-		if (value.length > 1) {
-			result[key].compositePrimaryKeys = {
-				[`${key}_${value.join('_')}_pk`]: {
-					columns: value,
-					name: `${key}_${value.join('_')}_pk`,
-				},
-			};
-		} else if (value.length === 1) {
-			result[key].columns[value[0]].primaryKey = true;
-		} else {
-		}
-	}
-
-	if (progressCallback) {
-		progressCallback('columns', columnsCount, 'done');
-		progressCallback('tables', tablesCount.size, 'done');
-	}
-	try {
-		const fks = await db.query<{
-			tableFrom: string;
-			tableTo: string;
-			from: string;
-			to: string;
-			onUpdate: string;
-			onDelete: string;
-			seq: number;
-			id: number;
-		}>(`SELECT
-			  m.name as "tableFrom",
-			  f.id as "id",
-			  f."table" as "tableTo",
-			  f."from",
-			  f."to",
-			  f."on_update" as "onUpdate",
-			  f."on_delete" as "onDelete",
-			  f.seq as "seq"
-      		FROM
-			  sqlite_master m,
-			  pragma_foreign_key_list(m.name) as f
-      		WHERE ${filterIgnoredTablesByField('m.tbl_name')};`);
-
-		const fkByTableName: Record<string, ForeignKey> = {};
-
-		for (const fkRow of fks) {
-			foreignKeysCount += 1;
-			if (progressCallback) {
-				progressCallback('fks', foreignKeysCount, 'fetching');
-			}
-			const tableName: string = fkRow.tableFrom;
-			const columnName: string = fkRow.from;
-			const refTableName = fkRow.tableTo;
-			const refColumnName: string = fkRow.to;
-			const updateRule: string = fkRow.onUpdate;
-			const deleteRule = fkRow.onDelete;
-			const sequence = fkRow.seq;
-			const id = fkRow.id;
-
-			const tableInResult = result[tableName];
-			if (typeof tableInResult === 'undefined') continue;
-
-			if (typeof fkByTableName[`${tableName}_${id}`] !== 'undefined') {
-				fkByTableName[`${tableName}_${id}`]!.columnsFrom.push(columnName);
-				fkByTableName[`${tableName}_${id}`]!.columnsTo.push(refColumnName);
-			} else {
-				fkByTableName[`${tableName}_${id}`] = {
-					name: '',
-					tableFrom: tableName,
-					tableTo: refTableName,
-					columnsFrom: [columnName],
-					columnsTo: [refColumnName],
-					onDelete: deleteRule?.toLowerCase(),
-					onUpdate: updateRule?.toLowerCase(),
-				};
-			}
-
-			const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
-			const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
-			fkByTableName[
-				`${tableName}_${id}`
-			].name = `${tableName}_${
-				columnsFrom.join(
-					'_',
-				)
-			}_${refTableName}_${columnsTo.join('_')}_fk`;
-		}
-
-		for (const idx of Object.keys(fkByTableName)) {
-			const value = fkByTableName[idx];
-			result[value.tableFrom].foreignKeys[value.name] = value;
-		}
-	} catch (e) {
-		// console.log(`Can't proccess foreign keys`);
-	}
-	if (progressCallback) {
-		progressCallback('fks', foreignKeysCount, 'done');
-	}
-	const idxs = await db.query<{
-		tableName: string;
-		indexName: string;
-		columnName: string;
-		isUnique: number;
-		seq: string;
-	}>(`SELECT 
-    	  m.tbl_name as tableName,
-    	  il.name as indexName,
-    	  ii.name as columnName,
-    	  il.[unique] as isUnique,
-    	  il.seq as seq
-		FROM 
-		  sqlite_master AS m,
-    	  pragma_index_list(m.name) AS il,
-    	  pragma_index_info(il.name) AS ii
-		WHERE 
-		  m.type = 'table' 
-    	  AND il.name NOT LIKE 'sqlite\\_autoindex\\_%' ESCAPE '\\'
-    	  AND ${filterIgnoredTablesByField('m.tbl_name')};`);
-
-	for (const idxRow of idxs) {
-		const tableName = idxRow.tableName;
-		const constraintName = idxRow.indexName;
-		const columnName: string = idxRow.columnName;
-		const isUnique = idxRow.isUnique === 1;
-
-		const tableInResult = result[tableName];
-		if (typeof tableInResult === 'undefined') continue;
-
-		indexesCount += 1;
-		if (progressCallback) {
-			progressCallback('indexes', indexesCount, 'fetching');
-		}
-
-		if (
-			typeof tableInResult.indexes[constraintName] !== 'undefined'
-			&& columnName
-		) {
-			tableInResult.indexes[constraintName]!.columns.push(columnName);
-		} else {
-			tableInResult.indexes[constraintName] = {
-				name: constraintName,
-				columns: columnName ? [columnName] : [],
-				isUnique: isUnique,
-			};
-		}
-		// if (isUnique) {
-		//   if (typeof tableInResult.uniqueConstraints[constraintName] !== "undefined") {
-		//     tableInResult.uniqueConstraints[constraintName]!.columns.push(columnName);
-		//   } else {
-		//     tableInResult.uniqueConstraints[constraintName] = {
-		//       name: constraintName,
-		//       columns: [columnName],
-		//     };
-		//   }
-		// } else {
-		//   if (typeof tableInResult.indexes[constraintName] !== "undefined") {
-		//     tableInResult.indexes[constraintName]!.columns.push(columnName);
-		//   } else {
-		//     tableInResult.indexes[constraintName] = {
-		//       name: constraintName,
-		//       columns: [columnName],
-		//       isUnique: isUnique,
-		//     };
-		//   }
-		// }
-	}
-	if (progressCallback) {
-		progressCallback('indexes', indexesCount, 'done');
-		// progressCallback("enums", 0, "fetching");
-		progressCallback('enums', 0, 'done');
-	}
-
-	const views = await db.query(
-		`SELECT name AS view_name, sql AS sql FROM sqlite_master WHERE type = 'view';`,
-	);
-
-	viewsCount = views.length;
-
-	if (progressCallback) {
-		progressCallback('views', viewsCount, 'fetching');
-	}
-	for (const view of views) {
-		const viewName = view['view_name'];
-		const sql = view['sql'];
-
-		const regex = new RegExp(`\\bAS\\b\\s+(SELECT.+)$`, 'i');
-		const match = sql.match(regex);
-
-		if (!match) {
-			console.log('Could not process view');
-			process.exit(1);
-		}
-
-		const viewDefinition = match[1] as string;
-
-		const columns = result[viewName].columns;
-		delete result[viewName];
-
-		resultViews[viewName] = {
-			columns: columns,
-			isExisting: false,
-			name: viewName,
-			definition: viewDefinition,
-		};
-	}
-	if (progressCallback) {
-		progressCallback('views', viewsCount, 'done');
-	}
-
-	const namedCheckPattern = /CONSTRAINT\s*["']?(\w+)["']?\s*CHECK\s*\((.*?)\)/gi;
-	const unnamedCheckPattern = /CHECK\s*\((.*?)\)/gi;
-	let checkCounter = 0;
-	const checkConstraints: Record<string, CheckConstraint> = {};
-	const checks = await db.query<{
-		tableName: string;
-		sql: string;
-	}>(`SELECT
-		  name as "tableName",
-		  sql as "sql"
-		FROM sqlite_master 
-		WHERE type = 'table'
-		  AND ${filterIgnoredTablesByField('tbl_name')};`);
-	for (const check of checks) {
-		if (!tablesFilter(check.tableName)) continue;
-
-		const { tableName, sql } = check;
-
-		// Find named CHECK constraints
-		let namedChecks = [...sql.matchAll(namedCheckPattern)];
-		if (namedChecks.length > 0) {
-			namedChecks.forEach(([_, checkName, checkValue]) => {
-				checkConstraints[checkName] = {
-					name: checkName,
-					value: checkValue.trim(),
-				};
-			});
-		} else {
-			// If no named constraints, find unnamed CHECK constraints and assign names
-			let unnamedChecks = [...sql.matchAll(unnamedCheckPattern)];
-			unnamedChecks.forEach(([_, checkValue]) => {
-				let checkName = `${tableName}_check_${++checkCounter}`;
-				checkConstraints[checkName] = {
-					name: checkName,
-					value: checkValue.trim(),
-				};
-			});
-		}
-
-		checksCount += Object.values(checkConstraints).length;
-		if (progressCallback) {
-			progressCallback('checks', checksCount, 'fetching');
-		}
-
-		const table = result[tableName];
-
-		if (!table) {
-			result[tableName] = {
-				name: tableName,
-				columns: {},
-				compositePrimaryKeys: {},
-				indexes: {},
-				foreignKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: checkConstraints,
-			};
-		} else {
-			result[tableName]!.checkConstraints = checkConstraints;
-		}
-	}
-
-	if (progressCallback) {
-		progressCallback('checks', checksCount, 'done');
-	}
-
-	return {
-		version: '6',
-		dialect: 'sqlite',
-		tables: result,
-		views: resultViews,
-		enums: {},
-		_meta: {
-			tables: {},
-			columns: {},
-		},
-	};
-};
diff --git a/drizzle-kit/src/serializer/studio.ts b/drizzle-kit/src/serializer/studio.ts
deleted file mode 100644
index bbd811627f..0000000000
--- a/drizzle-kit/src/serializer/studio.ts
+++ /dev/null
@@ -1,694 +0,0 @@
-import { serve } from '@hono/node-server';
-import { zValidator } from '@hono/zod-validator';
-import { createHash } from 'crypto';
-import {
-	AnyColumn,
-	AnyTable,
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	is,
-	Many,
-	normalizeRelation,
-	One,
-	Relations,
-	TablesRelationalConfig,
-} from 'drizzle-orm';
-import { AnyMySqlTable, getTableConfig as mysqlTableConfig, MySqlTable } from 'drizzle-orm/mysql-core';
-import { AnyPgTable, getTableConfig as pgTableConfig, PgTable } from 'drizzle-orm/pg-core';
-import {
-	AnySingleStoreTable,
-	getTableConfig as singlestoreTableConfig,
-	SingleStoreTable,
-} from 'drizzle-orm/singlestore-core';
-import { AnySQLiteTable, getTableConfig as sqliteTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
-import fs from 'fs';
-import { Hono } from 'hono';
-import { compress } from 'hono/compress';
-import { cors } from 'hono/cors';
-import { createServer } from 'node:https';
-import { LibSQLCredentials } from 'src/cli/validations/libsql';
-import { assertUnreachable } from 'src/global';
-import superjson from 'superjson';
-import { z } from 'zod';
-import { safeRegister } from '../cli/commands/utils';
-import type { MysqlCredentials } from '../cli/validations/mysql';
-import type { PostgresCredentials } from '../cli/validations/postgres';
-import type { SingleStoreCredentials } from '../cli/validations/singlestore';
-import type { SqliteCredentials } from '../cli/validations/sqlite';
-import { prepareFilenames } from '.';
-
-type CustomDefault = {
-	schema: string;
-	table: string;
-	column: string;
-	func: () => unknown;
-};
-
-type SchemaFile = {
-	name: string;
-	content: string;
-};
-
-export type Setup = {
-	dbHash: string;
-	dialect: 'postgresql' | 'mysql' | 'sqlite' | 'singlestore';
-	driver?: 'aws-data-api' | 'd1-http' | 'turso' | 'pglite';
-	proxy: (params: ProxyParams) => Promise<any[] | any>;
-	customDefaults: CustomDefault[];
-	schema: Record<string, Record<string, AnyTable<any>>>;
-	relations: Record<string, Relations>;
-	schemaFiles?: SchemaFile[];
-};
-
-export type ProxyParams = {
-	sql: string;
-	params: any[];
-	typings?: any[];
-	mode: 'array' | 'object';
-	method: 'values' | 'get' | 'all' | 'run' | 'execute';
-};
-
-export const preparePgSchema = async (path: string | string[]) => {
-	const imports = prepareFilenames(path);
-	const pgSchema: Record<string, Record<string, AnyPgTable>> = {};
-	const relations: Record<string, Relations> = {};
-
-	// files content as string
-	const files = imports.map((it, index) => ({
-		// get the file name from the path
-		name: it.split('/').pop() || `schema${index}.ts`,
-		content: fs.readFileSync(it, 'utf-8'),
-	}));
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const i0values = Object.entries(i0);
-
-		i0values.forEach(([k, t]) => {
-			if (is(t, PgTable)) {
-				const schema = pgTableConfig(t).schema || 'public';
-				pgSchema[schema] = pgSchema[schema] || {};
-				pgSchema[schema][k] = t;
-			}
-
-			if (is(t, Relations)) {
-				relations[k] = t;
-			}
-		});
-	}
-	unregister();
-
-	return { schema: pgSchema, relations, files };
-};
-
-export const prepareMySqlSchema = async (path: string | string[]) => {
-	const imports = prepareFilenames(path);
-	const mysqlSchema: Record<string, Record<string, AnyMySqlTable>> = {
-		public: {},
-	};
-	const relations: Record<string, Relations> = {};
-
-	// files content as string
-	const files = imports.map((it, index) => ({
-		// get the file name from the path
-		name: it.split('/').pop() || `schema${index}.ts`,
-		content: fs.readFileSync(it, 'utf-8'),
-	}));
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const i0values = Object.entries(i0);
-
-		i0values.forEach(([k, t]) => {
-			if (is(t, MySqlTable)) {
-				const schema = mysqlTableConfig(t).schema || 'public';
-				mysqlSchema[schema][k] = t;
-			}
-
-			if (is(t, Relations)) {
-				relations[k] = t;
-			}
-		});
-	}
-	unregister();
-
-	return { schema: mysqlSchema, relations, files };
-};
-
-export const prepareSQLiteSchema = async (path: string | string[]) => {
-	const imports = prepareFilenames(path);
-	const sqliteSchema: Record<string, Record<string, AnySQLiteTable>> = {
-		public: {},
-	};
-	const relations: Record<string, Relations> = {};
-
-	// files content as string
-	const files = imports.map((it, index) => ({
-		// get the file name from the path
-		name: it.split('/').pop() || `schema${index}.ts`,
-		content: fs.readFileSync(it, 'utf-8'),
-	}));
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const i0values = Object.entries(i0);
-
-		i0values.forEach(([k, t]) => {
-			if (is(t, SQLiteTable)) {
-				const schema = 'public'; // sqlite does not have schemas
-				sqliteSchema[schema][k] = t;
-			}
-
-			if (is(t, Relations)) {
-				relations[k] = t;
-			}
-		});
-	}
-	unregister();
-
-	return { schema: sqliteSchema, relations, files };
-};
-
-export const prepareSingleStoreSchema = async (path: string | string[]) => {
-	const imports = prepareFilenames(path);
-	const singlestoreSchema: Record<string, Record<string, AnySingleStoreTable>> = {
-		public: {},
-	};
-	const relations: Record<string, Relations> = {};
-
-	// files content as string
-	const files = imports.map((it, index) => ({
-		// get the file name from the path
-		name: it.split('/').pop() || `schema${index}.ts`,
-		content: fs.readFileSync(it, 'utf-8'),
-	}));
-
-	const { unregister } = await safeRegister();
-	for (let i = 0; i < imports.length; i++) {
-		const it = imports[i];
-
-		const i0: Record<string, unknown> = require(`${it}`);
-		const i0values = Object.entries(i0);
-
-		i0values.forEach(([k, t]) => {
-			if (is(t, SingleStoreTable)) {
-				const schema = singlestoreTableConfig(t).schema || 'public';
-				singlestoreSchema[schema][k] = t;
-			}
-
-			if (is(t, Relations)) {
-				relations[k] = t;
-			}
-		});
-	}
-	unregister();
-
-	return { schema: singlestoreSchema, relations, files };
-};
-
-const getCustomDefaults = <T extends AnyTable<{}>>(
-	schema: Record<string, Record<string, T>>,
-): CustomDefault[] => {
-	const customDefaults: CustomDefault[] = [];
-
-	Object.entries(schema).map(([schema, tables]) => {
-		Object.entries(tables).map(([, table]) => {
-			let tableConfig: {
-				name: string;
-				columns: AnyColumn[];
-			};
-			if (is(table, PgTable)) {
-				tableConfig = pgTableConfig(table);
-			} else if (is(table, MySqlTable)) {
-				tableConfig = mysqlTableConfig(table);
-			} else if (is(table, SQLiteTable)) {
-				tableConfig = sqliteTableConfig(table);
-			} else {
-				tableConfig = singlestoreTableConfig(table);
-			}
-
-			tableConfig.columns.map((column) => {
-				if (column.defaultFn) {
-					customDefaults.push({
-						schema,
-						table: tableConfig.name,
-						column: column.name,
-						func: column.defaultFn,
-					});
-				}
-			});
-		});
-	});
-
-	return customDefaults;
-};
-
-export const drizzleForPostgres = async (
-	credentials: PostgresCredentials,
-	pgSchema: Record<string, Record<string, AnyPgTable>>,
-	relations: Record<string, Relations>,
-	schemaFiles?: SchemaFile[],
-): Promise<Setup> => {
-	const { preparePostgresDB } = await import('../cli/connections');
-	const db = await preparePostgresDB(credentials);
-	const customDefaults = getCustomDefaults(pgSchema);
-
-	let dbUrl: string;
-
-	if ('driver' in credentials) {
-		const { driver } = credentials;
-		if (driver === 'aws-data-api') {
-			dbUrl = `aws-data-api://${credentials.database}/${credentials.secretArn}/${credentials.resourceArn}`;
-		} else if (driver === 'pglite') {
-			dbUrl = credentials.url;
-		} else {
-			assertUnreachable(driver);
-		}
-	} else if ('url' in credentials) {
-		dbUrl = credentials.url;
-	} else {
-		dbUrl =
-			`postgresql://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
-	}
-
-	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
-
-	return {
-		dbHash,
-		dialect: 'postgresql',
-		driver: 'driver' in credentials ? credentials.driver : undefined,
-		proxy: db.proxy,
-		customDefaults,
-		schema: pgSchema,
-		relations,
-		schemaFiles,
-	};
-};
-
-export const drizzleForMySQL = async (
-	credentials: MysqlCredentials,
-	mysqlSchema: Record<string, Record<string, AnyMySqlTable>>,
-	relations: Record<string, Relations>,
-	schemaFiles?: SchemaFile[],
-): Promise<Setup> => {
-	const { connectToMySQL } = await import('../cli/connections');
-	const { proxy } = await connectToMySQL(credentials);
-
-	const customDefaults = getCustomDefaults(mysqlSchema);
-
-	let dbUrl: string;
-
-	if ('url' in credentials) {
-		dbUrl = credentials.url;
-	} else {
-		dbUrl =
-			`mysql://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
-	}
-
-	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
-
-	return {
-		dbHash,
-		dialect: 'mysql',
-		proxy,
-		customDefaults,
-		schema: mysqlSchema,
-		relations,
-		schemaFiles,
-	};
-};
-
-export const drizzleForSQLite = async (
-	credentials: SqliteCredentials,
-	sqliteSchema: Record<string, Record<string, AnySQLiteTable>>,
-	relations: Record<string, Relations>,
-	schemaFiles?: SchemaFile[],
-): Promise<Setup> => {
-	const { connectToSQLite } = await import('../cli/connections');
-
-	const sqliteDB = await connectToSQLite(credentials);
-	const customDefaults = getCustomDefaults(sqliteSchema);
-
-	let dbUrl: string;
-
-	if ('driver' in credentials) {
-		const { driver } = credentials;
-		if (driver === 'd1-http') {
-			dbUrl = `d1-http://${credentials.accountId}/${credentials.databaseId}/${credentials.token}`;
-		} else {
-			assertUnreachable(driver);
-		}
-	} else {
-		dbUrl = credentials.url;
-	}
-
-	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
-
-	return {
-		dbHash,
-		dialect: 'sqlite',
-		driver: 'driver' in credentials ? credentials.driver : undefined,
-		proxy: sqliteDB.proxy,
-		customDefaults,
-		schema: sqliteSchema,
-		relations,
-		schemaFiles,
-	};
-};
-export const drizzleForLibSQL = async (
-	credentials: LibSQLCredentials,
-	sqliteSchema: Record<string, Record<string, AnySQLiteTable>>,
-	relations: Record<string, Relations>,
-	schemaFiles?: SchemaFile[],
-): Promise<Setup> => {
-	const { connectToLibSQL } = await import('../cli/connections');
-
-	const sqliteDB = await connectToLibSQL(credentials);
-	const customDefaults = getCustomDefaults(sqliteSchema);
-
-	let dbUrl: string = `turso://${credentials.url}/${credentials.authToken}`;
-
-	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
-
-	return {
-		dbHash,
-		dialect: 'sqlite',
-		driver: undefined,
-		proxy: sqliteDB.proxy,
-		customDefaults,
-		schema: sqliteSchema,
-		relations,
-		schemaFiles,
-	};
-};
-
-export const drizzleForSingleStore = async (
-	credentials: SingleStoreCredentials,
-	singlestoreSchema: Record<string, Record<string, AnySingleStoreTable>>,
-	relations: Record<string, Relations>,
-	schemaFiles?: SchemaFile[],
-): Promise<Setup> => {
-	const { connectToSingleStore } = await import('../cli/connections');
-	const { proxy } = await connectToSingleStore(credentials);
-
-	const customDefaults = getCustomDefaults(singlestoreSchema);
-
-	let dbUrl: string;
-
-	if ('url' in credentials) {
-		dbUrl = credentials.url;
-	} else {
-		dbUrl =
-			`singlestore://${credentials.user}:${credentials.password}@${credentials.host}:${credentials.port}/${credentials.database}`;
-	}
-
-	const dbHash = createHash('sha256').update(dbUrl).digest('hex');
-
-	return {
-		dbHash,
-		dialect: 'singlestore',
-		proxy,
-		customDefaults,
-		schema: singlestoreSchema,
-		relations,
-		schemaFiles,
-	};
-};
-
-export const extractRelations = (tablesConfig: {
-	tables: TablesRelationalConfig;
-	tableNamesMap: Record<string, string>;
-}) => {
-	const relations = Object.values(tablesConfig.tables)
-		.map((it) =>
-			Object.entries(it.relations).map(([name, relation]) => {
-				const normalized = normalizeRelation(
-					tablesConfig.tables,
-					tablesConfig.tableNamesMap,
-					relation,
-				);
-				const rel = relation;
-				const refTableName = rel.referencedTableName;
-				const refTable = rel.referencedTable;
-				const fields = normalized.fields.map((it) => it.name).flat();
-				const refColumns = normalized.references.map((it) => it.name).flat();
-
-				let refSchema: string | undefined;
-				if (is(refTable, PgTable)) {
-					refSchema = pgTableConfig(refTable).schema;
-				} else if (is(refTable, MySqlTable)) {
-					refSchema = mysqlTableConfig(refTable).schema;
-				} else if (is(refTable, SQLiteTable)) {
-					refSchema = undefined;
-				} else if (is(refTable, SingleStoreTable)) {
-					refSchema = singlestoreTableConfig(refTable).schema;
-				} else {
-					throw new Error('unsupported dialect');
-				}
-
-				let type: 'one' | 'many';
-				if (is(rel, One)) {
-					type = 'one';
-				} else if (is(rel, Many)) {
-					type = 'many';
-				} else {
-					throw new Error('unsupported relation type');
-				}
-
-				return {
-					name,
-					type,
-					table: it.dbName,
-					schema: it.schema || 'public',
-					columns: fields,
-					refTable: refTableName,
-					refSchema: refSchema || 'public',
-					refColumns: refColumns,
-				};
-			})
-		)
-		.flat();
-	return relations;
-};
-
-const init = z.object({
-	type: z.literal('init'),
-});
-
-const proxySchema = z.object({
-	type: z.literal('proxy'),
-	data: z.object({
-		sql: z.string(),
-		params: z.array(z.any()).optional(),
-		typings: z.string().array().optional(),
-		mode: z.enum(['array', 'object']).default('object'),
-		method: z.union([
-			z.literal('values'),
-			z.literal('get'),
-			z.literal('all'),
-			z.literal('run'),
-			z.literal('execute'),
-		]),
-	}),
-});
-
-const defaultsSchema = z.object({
-	type: z.literal('defaults'),
-	data: z
-		.array(
-			z.object({
-				schema: z.string(),
-				table: z.string(),
-				column: z.string(),
-			}),
-		)
-		.min(1),
-});
-
-const schema = z.union([init, proxySchema, defaultsSchema]);
-
-superjson.registerCustom<Buffer, number[]>(
-	{
-		isApplicable: (v): v is Buffer => v instanceof Buffer,
-		serialize: (v) => [...v],
-		deserialize: (v) => Buffer.from(v),
-	},
-	'buffer',
-);
-
-const jsonStringify = (data: any) => {
-	return JSON.stringify(data, (_key, value) => {
-		if (typeof value === 'bigint') {
-			return value.toString();
-		}
-
-		// Convert Buffer and ArrayBuffer to base64
-		if (
-			(value
-				&& typeof value === 'object'
-				&& 'type' in value
-				&& 'data' in value
-				&& value.type === 'Buffer')
-			|| value instanceof ArrayBuffer
-			|| value instanceof Buffer
-		) {
-			return Buffer.from(value).toString('base64');
-		}
-
-		return value;
-	});
-};
-
-export type Server = {
-	start: (params: {
-		host: string;
-		port: number;
-		key?: string;
-		cert?: string;
-		cb: (err: Error | null, address: string) => void;
-	}) => void;
-};
-
-export const prepareServer = async (
-	{
-		dialect,
-		driver,
-		proxy,
-		customDefaults,
-		schema: drizzleSchema,
-		relations,
-		dbHash,
-		schemaFiles,
-	}: Setup,
-	app?: Hono,
-): Promise<Server> => {
-	app = app !== undefined ? app : new Hono();
-
-	app.use(compress());
-	app.use(async (ctx, next) => {
-		await next();
-		// * https://wicg.github.io/private-network-access/#headers
-		// * https://github.com/drizzle-team/drizzle-orm/issues/1857#issuecomment-2395724232
-		ctx.header('Access-Control-Allow-Private-Network', 'true');
-	});
-	app.use(cors());
-	app.onError((err, ctx) => {
-		console.error(err);
-		return ctx.json({
-			status: 'error',
-			error: err.message,
-		});
-	});
-
-	const relationalSchema: Record<string, unknown> = {
-		...Object.fromEntries(
-			Object.entries(drizzleSchema)
-				.map(([schemaName, schema]) => {
-					// have unique keys across schemas
-					const mappedTableEntries = Object.entries(schema).map(
-						([tableName, table]) => {
-							return [`__${schemaName}__.${tableName}`, table];
-						},
-					);
-
-					return mappedTableEntries;
-				})
-				.flat(),
-		),
-		...relations,
-	};
-
-	const relationsConfig = extractTablesRelationalConfig(
-		relationalSchema,
-		createTableRelationsHelpers,
-	);
-
-	app.post('/', zValidator('json', schema), async (c) => {
-		const body = c.req.valid('json');
-		const { type } = body;
-
-		if (type === 'init') {
-			const preparedDefaults = customDefaults.map((d) => ({
-				schema: d.schema,
-				table: d.table,
-				column: d.column,
-			}));
-
-			return c.json({
-				version: '6',
-				dialect,
-				driver,
-				schemaFiles,
-				customDefaults: preparedDefaults,
-				relations: extractRelations(relationsConfig),
-				dbHash,
-			});
-		}
-
-		if (type === 'proxy') {
-			const result = await proxy({
-				...body.data,
-				params: body.data.params || [],
-			});
-			return c.json(JSON.parse(jsonStringify(result)));
-		}
-
-		if (type === 'defaults') {
-			const columns = body.data;
-
-			const result = columns.map((column) => {
-				const found = customDefaults.find((d) => {
-					return (
-						d.schema === column.schema
-						&& d.table === column.table
-						&& d.column === column.column
-					);
-				});
-
-				if (!found) {
-					throw new Error(
-						`Custom default not found for ${column.schema}.${column.table}.${column.column}`,
-					);
-				}
-
-				const value = found.func();
-
-				return {
-					...column,
-					value,
-				};
-			});
-
-			return c.json(JSON.parse(jsonStringify(result)));
-		}
-
-		throw new Error(`Unknown type: ${type}`);
-	});
-
-	return {
-		start: (params: Parameters<Server['start']>[0]) => {
-			serve(
-				{
-					fetch: app!.fetch,
-					createServer: params.key ? createServer : undefined,
-					hostname: params.host,
-					port: params.port,
-					serverOptions: {
-						key: params.key,
-						cert: params.cert,
-					},
-				},
-				() => params.cb(null, `${params.host}:${params.port}`),
-			);
-		},
-	};
-};
diff --git a/drizzle-kit/src/serializer/utils.ts b/drizzle-kit/src/serializer/utils.ts
deleted file mode 100644
index 18d5bb9ad8..0000000000
--- a/drizzle-kit/src/serializer/utils.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { SQL } from 'drizzle-orm';
-import { CasingCache, toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
-import { CasingType } from '../cli/validations/common';
-
-export function getColumnCasing(
-	column: { keyAsName: boolean; name: string | undefined },
-	casing: CasingType | undefined,
-) {
-	if (!column.name) return '';
-	return !column.keyAsName || casing === undefined
-		? column.name
-		: casing === 'camelCase'
-		? toCamelCase(column.name)
-		: toSnakeCase(column.name);
-}
-
-export const sqlToStr = (sql: SQL, casing: CasingType | undefined) => {
-	return sql.toQuery({
-		escapeName: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		escapeParam: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		escapeString: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		casing: new CasingCache(casing),
-	}).sql;
-};
-
-export const sqlToStrGenerated = (sql: SQL, casing: CasingType | undefined) => {
-	return sql.toQuery({
-		escapeName: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		escapeParam: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		escapeString: () => {
-			throw new Error("we don't support params for `sql` default values");
-		},
-		casing: new CasingCache(casing),
-	}).sql;
-};
diff --git a/drizzle-kit/src/simulator.ts b/drizzle-kit/src/simulator.ts
deleted file mode 100644
index 71dbac1aad..0000000000
--- a/drizzle-kit/src/simulator.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-declare global {
-	interface Array<T> {
-		exactlyOne(): T;
-	}
-}
-
-Array.prototype.exactlyOne = function() {
-	if (this.length !== 1) {
-		return undefined;
-	}
-	return this[0];
-};
-
-interface TablesHandler<T extends Named> {
-	can(added: T[], removed: T[]): boolean;
-	handle(added: T[], removed: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T }[] };
-}
-
-interface ColumnsHandler<T extends Named> {
-	can(tableName: string, added: T[], removed: T[]): boolean;
-	handle(
-		tableName: string,
-		added: T[],
-		removed: T[],
-	): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] };
-}
-
-class DryRun<T extends Named> implements TablesHandler<T> {
-	can(added: T[], removed: T[]): boolean {
-		return added.length === 0 && removed.length === 0;
-	}
-	handle(added: T[], _: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		return { created: added, deleted: [], renamed: [] };
-	}
-}
-
-// class Fallback implements Handler {
-//     can(_: Table[], __: Table[]): boolean {
-//         return true
-//     }
-//     handle(added: Table[], _: Table[]): { created: Table[]; deleted: Table[]; renamed: { from: Table; to: Table; }[]; } {
-//         return { created: added, deleted: , renamed: [] }
-//     }
-// }
-
-class Case1<T extends Named> implements TablesHandler<T> {
-	can(_: T[], removed: T[]): boolean {
-		return removed.length === 1 && removed[0].name === 'citiess';
-	}
-
-	handle(added: T[], removed: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		return { created: added, deleted: removed, renamed: [] };
-	}
-}
-class Case2<T extends Named> implements TablesHandler<T> {
-	// authOtp, deleted, users -> authOtp renamed, cities added, deleted deleted
-	can(_: T[], removed: T[]): boolean {
-		return removed.length === 3 && removed[0].name === 'auth_otp';
-	}
-
-	handle(added: T[], removed: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		return { created: added.slice(1), deleted: removed.slice(1), renamed: [{ from: removed[0], to: added[0] }] };
-	}
-}
-
-type Named = { name: string };
-
-const handlers: TablesHandler<any>[] = [];
-handlers.push(new Case1());
-handlers.push(new Case2());
-handlers.push(new DryRun());
-
-export const resolveTables = <T extends Named>(added: T[], removed: T[]) => {
-	const handler = handlers.filter((it) => {
-		return it.can(added, removed);
-	}).exactlyOne();
-
-	if (!handler) {
-		console.log('added', added.map((it) => it.name).join());
-		console.log('removed', removed.map((it) => it.name).join());
-		throw new Error('No handler');
-	}
-
-	console.log(`Simluated by ${handler.constructor.name}`);
-	return handler.handle(added, removed);
-};
-class LehaColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-	can(tableName: string, _: T[], __: T[]): boolean {
-		return tableName === 'users';
-	}
-
-	handle(
-		tableName: string,
-		added: T[],
-		removed: T[],
-	): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		return { tableName, created: [], deleted: [], renamed: [{ from: removed[0], to: added[0] }] };
-	}
-}
-
-class DryRunColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-	can(tableName: string, _: T[], __: T[]): boolean {
-		return true;
-	}
-
-	handle(
-		tableName: string,
-		added: T[],
-		removed: T[],
-	): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		return { tableName, created: added, deleted: removed, renamed: [] };
-	}
-}
-
-class V1V2AuthOtpColumnsHandler<T extends Named> implements ColumnsHandler<T> {
-	can(tableName: string, _: T[], __: T[]): boolean {
-		return tableName === 'auth_otp';
-	}
-
-	handle(
-		tableName: string,
-		added: T[],
-		removed: T[],
-	): { tableName: string; created: T[]; deleted: T[]; renamed: { from: T; to: T }[] } {
-		const phonePrev = removed.filter((it) => it.name === 'phone')[0];
-		const phoneNew = added.filter((it) => it.name === 'phone1')[0];
-
-		const newAdded = added.filter((it) => it.name !== 'phone1');
-		const newRemoved = removed.filter((it) => it.name !== 'phone');
-
-		return { tableName, created: newAdded, deleted: newRemoved, renamed: [{ from: phonePrev, to: phoneNew }] };
-	}
-
-	// handle(tableName:string, added: T[], _: T[]): { created: T[]; deleted: T[]; renamed: { from: T; to: T; }[]; } {
-	//     return { created: added, deleted: [], renamed: [] }
-	// }
-}
-
-const columnsHandlers: ColumnsHandler<any>[] = [];
-columnsHandlers.push(new V1V2AuthOtpColumnsHandler());
-columnsHandlers.push(new LehaColumnsHandler());
-columnsHandlers.push(new DryRunColumnsHandler());
-
-export const resolveColumns = <T extends Named>(tableName: string, added: T[], removed: T[]) => {
-	const handler = columnsHandlers.filter((it) => {
-		return it.can(tableName, added, removed);
-	})[0];
-
-	if (!handler) {
-		console.log('added', added.map((it) => it.name).join());
-		console.log('removed', removed.map((it) => it.name).join());
-		throw new Error('No columns handler for table: ' + tableName);
-	}
-
-	console.log(`${tableName} columns simluated by ${handler.constructor.name}`);
-	return handler.handle(tableName, added, removed);
-};
diff --git a/drizzle-kit/src/snapshotsDiffer.ts b/drizzle-kit/src/snapshotsDiffer.ts
deleted file mode 100644
index 3a77c97623..0000000000
--- a/drizzle-kit/src/snapshotsDiffer.ts
+++ /dev/null
@@ -1,4331 +0,0 @@
-import {
-	any,
-	array,
-	boolean,
-	enum as enumType,
-	literal,
-	never,
-	object,
-	record,
-	string,
-	TypeOf,
-	union,
-	ZodTypeAny,
-} from 'zod';
-import { applyJsonDiff, diffColumns, diffIndPolicies, diffPolicies, diffSchemasOrTables } from './jsonDiffer';
-import { fromJson } from './sqlgenerator';
-
-import {
-	_prepareAddColumns,
-	_prepareDropColumns,
-	_prepareSqliteAddColumns,
-	JsonAddColumnStatement,
-	JsonAlterCompositePK,
-	JsonAlterIndPolicyStatement,
-	JsonAlterMySqlViewStatement,
-	JsonAlterPolicyStatement,
-	JsonAlterTableSetSchema,
-	JsonAlterUniqueConstraint,
-	JsonAlterViewStatement,
-	JsonCreateCheckConstraint,
-	JsonCreateCompositePK,
-	JsonCreateIndPolicyStatement,
-	JsonCreateMySqlViewStatement,
-	JsonCreatePgViewStatement,
-	JsonCreatePolicyStatement,
-	JsonCreateReferenceStatement,
-	JsonCreateSqliteViewStatement,
-	JsonCreateUniqueConstraint,
-	JsonDeleteCheckConstraint,
-	JsonDeleteCompositePK,
-	JsonDeleteUniqueConstraint,
-	JsonDisableRLSStatement,
-	JsonDropColumnStatement,
-	JsonDropIndPolicyStatement,
-	JsonDropPolicyStatement,
-	JsonDropViewStatement,
-	JsonEnableRLSStatement,
-	JsonIndRenamePolicyStatement,
-	JsonReferenceStatement,
-	JsonRenameColumnStatement,
-	JsonRenamePolicyStatement,
-	JsonRenameRoleStatement,
-	JsonRenameViewStatement,
-	JsonSqliteAddColumnStatement,
-	JsonStatement,
-	prepareAddCheckConstraint,
-	prepareAddCompositePrimaryKeyMySql,
-	prepareAddCompositePrimaryKeyPg,
-	prepareAddCompositePrimaryKeySqlite,
-	prepareAddUniqueConstraintPg as prepareAddUniqueConstraint,
-	prepareAddValuesToEnumJson,
-	prepareAlterColumnsMysql,
-	prepareAlterCompositePrimaryKeyMySql,
-	prepareAlterCompositePrimaryKeyPg,
-	prepareAlterCompositePrimaryKeySqlite,
-	prepareAlterIndPolicyJson,
-	prepareAlterPolicyJson,
-	prepareAlterReferencesJson,
-	prepareAlterRoleJson,
-	prepareAlterSequenceJson,
-	prepareCreateEnumJson,
-	prepareCreateIndexesJson,
-	prepareCreateIndPolicyJsons,
-	prepareCreatePolicyJsons,
-	prepareCreateReferencesJson,
-	prepareCreateRoleJson,
-	prepareCreateSchemasJson,
-	prepareCreateSequenceJson,
-	prepareDeleteCheckConstraint,
-	prepareDeleteCompositePrimaryKeyMySql,
-	prepareDeleteCompositePrimaryKeyPg,
-	prepareDeleteCompositePrimaryKeySqlite,
-	prepareDeleteSchemasJson as prepareDropSchemasJson,
-	prepareDeleteUniqueConstraintPg as prepareDeleteUniqueConstraint,
-	prepareDropEnumJson,
-	prepareDropEnumValues,
-	prepareDropIndexesJson,
-	prepareDropIndPolicyJsons,
-	prepareDropPolicyJsons,
-	prepareDropReferencesJson,
-	prepareDropRoleJson,
-	prepareDropSequenceJson,
-	prepareDropTableJson,
-	prepareDropViewJson,
-	prepareLibSQLCreateReferencesJson,
-	prepareLibSQLDropReferencesJson,
-	prepareMoveEnumJson,
-	prepareMoveSequenceJson,
-	prepareMySqlAlterView,
-	prepareMySqlCreateTableJson,
-	prepareMySqlCreateViewJson,
-	preparePgAlterColumns,
-	preparePgAlterViewAddWithOptionJson,
-	preparePgAlterViewAlterSchemaJson,
-	preparePgAlterViewAlterTablespaceJson,
-	preparePgAlterViewAlterUsingJson,
-	preparePgAlterViewDropWithOptionJson,
-	preparePgCreateIndexesJson,
-	preparePgCreateTableJson,
-	preparePgCreateViewJson,
-	prepareRenameColumns,
-	prepareRenameEnumJson,
-	prepareRenameIndPolicyJsons,
-	prepareRenamePolicyJsons,
-	prepareRenameRoleJson,
-	prepareRenameSchemasJson,
-	prepareRenameSequenceJson,
-	prepareRenameTableJson,
-	prepareRenameViewJson,
-	prepareSingleStoreCreateTableJson,
-	prepareSqliteAlterColumns,
-	prepareSQLiteCreateTable,
-	prepareSqliteCreateViewJson,
-} from './jsonStatements';
-
-import { Named, NamedWithSchema } from './cli/commands/migrate';
-import { mapEntries, mapKeys, mapValues } from './global';
-import { MySqlSchema, MySqlSchemaSquashed, MySqlSquasher, ViewSquashed } from './serializer/mysqlSchema';
-import {
-	mergedViewWithOption,
-	PgSchema,
-	PgSchemaSquashed,
-	PgSquasher,
-	Policy,
-	policy,
-	policySquashed,
-	Role,
-	roleSchema,
-	sequenceSquashed,
-	View,
-} from './serializer/pgSchema';
-import { SingleStoreSchema, SingleStoreSchemaSquashed, SingleStoreSquasher } from './serializer/singlestoreSchema';
-import { SQLiteSchema, SQLiteSchemaSquashed, SQLiteSquasher, View as SqliteView } from './serializer/sqliteSchema';
-import { libSQLCombineStatements, singleStoreCombineStatements, sqliteCombineStatements } from './statementCombiner';
-import { copy, prepareMigrationMeta } from './utils';
-
-const makeChanged = <T extends ZodTypeAny>(schema: T) => {
-	return object({
-		type: enumType(['changed']),
-		old: schema,
-		new: schema,
-	});
-};
-
-const makeSelfOrChanged = <T extends ZodTypeAny>(schema: T) => {
-	return union([
-		schema,
-		object({
-			type: enumType(['changed']),
-			old: schema,
-			new: schema,
-		}),
-	]);
-};
-
-export const makePatched = <T extends ZodTypeAny>(schema: T) => {
-	return union([
-		object({
-			type: literal('added'),
-			value: schema,
-		}),
-		object({
-			type: literal('deleted'),
-			value: schema,
-		}),
-		object({
-			type: literal('changed'),
-			old: schema,
-			new: schema,
-		}),
-	]);
-};
-
-export const makeSelfOrPatched = <T extends ZodTypeAny>(schema: T) => {
-	return union([
-		object({
-			type: literal('none'),
-			value: schema,
-		}),
-		object({
-			type: literal('added'),
-			value: schema,
-		}),
-		object({
-			type: literal('deleted'),
-			value: schema,
-		}),
-		object({
-			type: literal('changed'),
-			old: schema,
-			new: schema,
-		}),
-	]);
-};
-
-const columnSchema = object({
-	name: string(),
-	type: string(),
-	typeSchema: string().optional(),
-	primaryKey: boolean().optional(),
-	default: any().optional(),
-	notNull: boolean().optional(),
-	// should it be optional? should if be here?
-	autoincrement: boolean().optional(),
-	onUpdate: boolean().optional(),
-	isUnique: any().optional(),
-	uniqueName: string().optional(),
-	nullsNotDistinct: boolean().optional(),
-	generated: object({
-		as: string(),
-		type: enumType(['stored', 'virtual']).default('stored'),
-	}).optional(),
-	identity: string().optional(),
-}).strict();
-
-const alteredColumnSchema = object({
-	name: makeSelfOrChanged(string()),
-	type: makeChanged(string()).optional(),
-	default: makePatched(any()).optional(),
-	primaryKey: makePatched(boolean()).optional(),
-	notNull: makePatched(boolean()).optional(),
-	typeSchema: makePatched(string()).optional(),
-	onUpdate: makePatched(boolean()).optional(),
-	autoincrement: makePatched(boolean()).optional(),
-	generated: makePatched(
-		object({
-			as: string(),
-			type: enumType(['stored', 'virtual']).default('stored'),
-		}),
-	).optional(),
-
-	identity: makePatched(string()).optional(),
-}).strict();
-
-const enumSchema = object({
-	name: string(),
-	schema: string(),
-	values: array(string()),
-}).strict();
-
-const changedEnumSchema = object({
-	name: string(),
-	schema: string(),
-	addedValues: object({
-		before: string(),
-		value: string(),
-	}).array(),
-	deletedValues: array(string()),
-}).strict();
-
-const tableScheme = object({
-	name: string(),
-	schema: string().default(''),
-	columns: record(string(), columnSchema),
-	indexes: record(string(), string()),
-	foreignKeys: record(string(), string()),
-	compositePrimaryKeys: record(string(), string()).default({}),
-	uniqueConstraints: record(string(), string()).default({}),
-	policies: record(string(), string()).default({}),
-	checkConstraints: record(string(), string()).default({}),
-	isRLSEnabled: boolean().default(false),
-}).strict();
-
-export const alteredTableScheme = object({
-	name: string(),
-	schema: string(),
-	altered: alteredColumnSchema.array(),
-	addedIndexes: record(string(), string()),
-	deletedIndexes: record(string(), string()),
-	alteredIndexes: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}).strict(),
-	),
-	addedForeignKeys: record(string(), string()),
-	deletedForeignKeys: record(string(), string()),
-	alteredForeignKeys: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}).strict(),
-	),
-	addedCompositePKs: record(string(), string()),
-	deletedCompositePKs: record(string(), string()),
-	alteredCompositePKs: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}),
-	),
-	addedUniqueConstraints: record(string(), string()),
-	deletedUniqueConstraints: record(string(), string()),
-	alteredUniqueConstraints: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}),
-	),
-	addedPolicies: record(string(), string()),
-	deletedPolicies: record(string(), string()),
-	alteredPolicies: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}),
-	),
-	addedCheckConstraints: record(
-		string(),
-		string(),
-	),
-	deletedCheckConstraints: record(
-		string(),
-		string(),
-	),
-	alteredCheckConstraints: record(
-		string(),
-		object({
-			__new: string(),
-			__old: string(),
-		}),
-	),
-}).strict();
-
-const alteredViewCommon = object({
-	name: string(),
-	alteredDefinition: object({
-		__old: string(),
-		__new: string(),
-	}).strict().optional(),
-	alteredExisting: object({
-		__old: boolean(),
-		__new: boolean(),
-	}).strict().optional(),
-});
-
-export const alteredPgViewSchema = alteredViewCommon.merge(
-	object({
-		schema: string(),
-		deletedWithOption: mergedViewWithOption.optional(),
-		addedWithOption: mergedViewWithOption.optional(),
-		addedWith: mergedViewWithOption.optional(),
-		deletedWith: mergedViewWithOption.optional(),
-		alteredWith: mergedViewWithOption.optional(),
-		alteredSchema: object({
-			__old: string(),
-			__new: string(),
-		}).strict().optional(),
-		alteredTablespace: object({
-			__old: string(),
-			__new: string(),
-		}).strict().optional(),
-		alteredUsing: object({
-			__old: string(),
-			__new: string(),
-		}).strict().optional(),
-	}).strict(),
-);
-
-const alteredMySqlViewSchema = alteredViewCommon.merge(
-	object({
-		alteredMeta: object({
-			__old: string(),
-			__new: string(),
-		}).strict().optional(),
-	}).strict(),
-);
-
-export const diffResultScheme = object({
-	alteredTablesWithColumns: alteredTableScheme.array(),
-	alteredEnums: changedEnumSchema.array(),
-	alteredSequences: sequenceSquashed.array(),
-	alteredRoles: roleSchema.array(),
-	alteredPolicies: policySquashed.array(),
-	alteredViews: alteredPgViewSchema.array(),
-}).strict();
-
-export const diffResultSchemeMysql = object({
-	alteredTablesWithColumns: alteredTableScheme.array(),
-	alteredEnums: never().array(),
-	alteredViews: alteredMySqlViewSchema.array(),
-});
-
-export const diffResultSchemeSingleStore = object({
-	alteredTablesWithColumns: alteredTableScheme.array(),
-	alteredEnums: never().array(),
-});
-
-export const diffResultSchemeSQLite = object({
-	alteredTablesWithColumns: alteredTableScheme.array(),
-	alteredEnums: never().array(),
-	alteredViews: alteredViewCommon.array(),
-});
-
-export type Column = TypeOf<typeof columnSchema>;
-export type AlteredColumn = TypeOf<typeof alteredColumnSchema>;
-export type Enum = TypeOf<typeof enumSchema>;
-export type Sequence = TypeOf<typeof sequenceSquashed>;
-export type Table = TypeOf<typeof tableScheme>;
-export type AlteredTable = TypeOf<typeof alteredTableScheme>;
-export type DiffResult = TypeOf<typeof diffResultScheme>;
-export type DiffResultMysql = TypeOf<typeof diffResultSchemeMysql>;
-export type DiffResultSingleStore = TypeOf<typeof diffResultSchemeSingleStore>;
-export type DiffResultSQLite = TypeOf<typeof diffResultSchemeSQLite>;
-
-export interface ResolverInput<T extends { name: string }> {
-	created: T[];
-	deleted: T[];
-}
-
-export interface ResolverOutput<T extends { name: string }> {
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-export interface ResolverOutputWithMoved<T extends { name: string }> {
-	created: T[];
-	moved: { name: string; schemaFrom: string; schemaTo: string }[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-export interface ColumnsResolverInput<T extends { name: string }> {
-	tableName: string;
-	schema: string;
-	created: T[];
-	deleted: T[];
-}
-
-export interface TablePolicyResolverInput<T extends { name: string }> {
-	tableName: string;
-	schema: string;
-	created: T[];
-	deleted: T[];
-}
-
-export interface TablePolicyResolverOutput<T extends { name: string }> {
-	tableName: string;
-	schema: string;
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-export interface PolicyResolverInput<T extends { name: string }> {
-	created: T[];
-	deleted: T[];
-}
-
-export interface PolicyResolverOutput<T extends { name: string }> {
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-export interface RolesResolverInput<T extends { name: string }> {
-	created: T[];
-	deleted: T[];
-}
-
-export interface RolesResolverOutput<T extends { name: string }> {
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-export interface ColumnsResolverOutput<T extends { name: string }> {
-	tableName: string;
-	schema: string;
-	created: T[];
-	renamed: { from: T; to: T }[];
-	deleted: T[];
-}
-
-const schemaChangeFor = (
-	table: NamedWithSchema,
-	renamedSchemas: { from: Named; to: Named }[],
-) => {
-	for (let ren of renamedSchemas) {
-		if (table.schema === ren.from.name) {
-			return { key: `${ren.to.name}.${table.name}`, schema: ren.to.name };
-		}
-	}
-
-	return {
-		key: `${table.schema || 'public'}.${table.name}`,
-		schema: table.schema,
-	};
-};
-
-const nameChangeFor = (table: Named, renamed: { from: Named; to: Named }[]) => {
-	for (let ren of renamed) {
-		if (table.name === ren.from.name) {
-			return { name: ren.to.name };
-		}
-	}
-
-	return {
-		name: table.name,
-	};
-};
-
-const nameSchemaChangeFor = (
-	table: NamedWithSchema,
-	renamedTables: { from: NamedWithSchema; to: NamedWithSchema }[],
-) => {
-	for (let ren of renamedTables) {
-		if (table.name === ren.from.name && table.schema === ren.from.schema) {
-			return {
-				key: `${ren.to.schema || 'public'}.${ren.to.name}`,
-				name: ren.to.name,
-				schema: ren.to.schema,
-			};
-		}
-	}
-
-	return {
-		key: `${table.schema || 'public'}.${table.name}`,
-		name: table.name,
-		schema: table.schema,
-	};
-};
-
-const columnChangeFor = (
-	column: string,
-	renamedColumns: { from: Named; to: Named }[],
-) => {
-	for (let ren of renamedColumns) {
-		if (column === ren.from.name) {
-			return ren.to.name;
-		}
-	}
-
-	return column;
-};
-
-// resolve roles same as enums
-// create new json statements
-// sql generators
-
-// tests everything!
-
-export const applyPgSnapshotsDiff = async (
-	json1: PgSchemaSquashed,
-	json2: PgSchemaSquashed,
-	schemasResolver: (
-		input: ResolverInput<Named>,
-	) => Promise<ResolverOutput<Named>>,
-	enumsResolver: (
-		input: ResolverInput<Enum>,
-	) => Promise<ResolverOutputWithMoved<Enum>>,
-	sequencesResolver: (
-		input: ResolverInput<Sequence>,
-	) => Promise<ResolverOutputWithMoved<Sequence>>,
-	policyResolver: (
-		input: TablePolicyResolverInput<Policy>,
-	) => Promise<TablePolicyResolverOutput<Policy>>,
-	indPolicyResolver: (
-		input: PolicyResolverInput<Policy>,
-	) => Promise<PolicyResolverOutput<Policy>>,
-	roleResolver: (
-		input: RolesResolverInput<Role>,
-	) => Promise<RolesResolverOutput<Role>>,
-	tablesResolver: (
-		input: ResolverInput<Table>,
-	) => Promise<ResolverOutputWithMoved<Table>>,
-	columnsResolver: (
-		input: ColumnsResolverInput<Column>,
-	) => Promise<ColumnsResolverOutput<Column>>,
-	viewsResolver: (
-		input: ResolverInput<View>,
-	) => Promise<ResolverOutputWithMoved<View>>,
-	prevFull: PgSchema,
-	curFull: PgSchema,
-	action?: 'push' | undefined,
-): Promise<{
-	statements: JsonStatement[];
-	sqlStatements: string[];
-	_meta:
-		| {
-			schemas: {};
-			tables: {};
-			columns: {};
-		}
-		| undefined;
-}> => {
-	const schemasDiff = diffSchemasOrTables(json1.schemas, json2.schemas);
-
-	const {
-		created: createdSchemas,
-		deleted: deletedSchemas,
-		renamed: renamedSchemas,
-	} = await schemasResolver({
-		created: schemasDiff.added.map((it) => ({ name: it })),
-		deleted: schemasDiff.deleted.map((it) => ({ name: it })),
-	});
-
-	const schemasPatchedSnap1 = copy(json1);
-	schemasPatchedSnap1.tables = mapEntries(
-		schemasPatchedSnap1.tables,
-		(_, it) => {
-			const { key, schema } = schemaChangeFor(it, renamedSchemas);
-			it.schema = schema;
-			return [key, it];
-		},
-	);
-
-	schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_, it) => {
-		const { key, schema } = schemaChangeFor(it, renamedSchemas);
-		it.schema = schema;
-		return [key, it];
-	});
-
-	const enumsDiff = diffSchemasOrTables(schemasPatchedSnap1.enums, json2.enums);
-
-	const {
-		created: createdEnums,
-		deleted: deletedEnums,
-		renamed: renamedEnums,
-		moved: movedEnums,
-	} = await enumsResolver({
-		created: enumsDiff.added,
-		deleted: enumsDiff.deleted,
-	});
-
-	schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_, it) => {
-		const { key, name, schema } = nameSchemaChangeFor(it, renamedEnums);
-		it.name = name;
-		it.schema = schema;
-		return [key, it];
-	});
-
-	const columnTypesChangeMap = renamedEnums.reduce(
-		(acc, it) => {
-			acc[`${it.from.schema}.${it.from.name}`] = {
-				nameFrom: it.from.name,
-				nameTo: it.to.name,
-				schemaFrom: it.from.schema,
-				schemaTo: it.to.schema,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-				schemaFrom: string;
-				schemaTo: string;
-			}
-		>,
-	);
-
-	const columnTypesMovesMap = movedEnums.reduce(
-		(acc, it) => {
-			acc[`${it.schemaFrom}.${it.name}`] = {
-				nameFrom: it.name,
-				nameTo: it.name,
-				schemaFrom: it.schemaFrom,
-				schemaTo: it.schemaTo,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-				schemaFrom: string;
-				schemaTo: string;
-			}
-		>,
-	);
-
-	schemasPatchedSnap1.tables = mapEntries(
-		schemasPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapValues(tableValue.columns, (column) => {
-				const key = `${column.typeSchema || 'public'}.${column.type}`;
-				const change = columnTypesChangeMap[key] || columnTypesMovesMap[key];
-
-				if (change) {
-					column.type = change.nameTo;
-					column.typeSchema = change.schemaTo;
-				}
-
-				return column;
-			});
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	schemasPatchedSnap1.sequences = mapEntries(
-		schemasPatchedSnap1.sequences,
-		(_, it) => {
-			const { key, schema } = schemaChangeFor(it, renamedSchemas);
-			it.schema = schema;
-			return [key, it];
-		},
-	);
-
-	const sequencesDiff = diffSchemasOrTables(
-		schemasPatchedSnap1.sequences,
-		json2.sequences,
-	);
-
-	const {
-		created: createdSequences,
-		deleted: deletedSequences,
-		renamed: renamedSequences,
-		moved: movedSequences,
-	} = await sequencesResolver({
-		created: sequencesDiff.added,
-		deleted: sequencesDiff.deleted,
-	});
-
-	schemasPatchedSnap1.sequences = mapEntries(
-		schemasPatchedSnap1.sequences,
-		(_, it) => {
-			const { key, name, schema } = nameSchemaChangeFor(it, renamedSequences);
-			it.name = name;
-			it.schema = schema;
-			return [key, it];
-		},
-	);
-
-	const sequencesChangeMap = renamedSequences.reduce(
-		(acc, it) => {
-			acc[`${it.from.schema}.${it.from.name}`] = {
-				nameFrom: it.from.name,
-				nameTo: it.to.name,
-				schemaFrom: it.from.schema,
-				schemaTo: it.to.schema,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-				schemaFrom: string;
-				schemaTo: string;
-			}
-		>,
-	);
-
-	const sequencesMovesMap = movedSequences.reduce(
-		(acc, it) => {
-			acc[`${it.schemaFrom}.${it.name}`] = {
-				nameFrom: it.name,
-				nameTo: it.name,
-				schemaFrom: it.schemaFrom,
-				schemaTo: it.schemaTo,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-				schemaFrom: string;
-				schemaTo: string;
-			}
-		>,
-	);
-
-	schemasPatchedSnap1.tables = mapEntries(
-		schemasPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapValues(tableValue.columns, (column) => {
-				const key = `${column.typeSchema || 'public'}.${column.type}`;
-				const change = sequencesChangeMap[key] || sequencesMovesMap[key];
-
-				if (change) {
-					column.type = change.nameTo;
-					column.typeSchema = change.schemaTo;
-				}
-
-				return column;
-			});
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	const rolesDiff = diffSchemasOrTables(
-		schemasPatchedSnap1.roles,
-		json2.roles,
-	);
-
-	const {
-		created: createdRoles,
-		deleted: deletedRoles,
-		renamed: renamedRoles,
-	} = await roleResolver({
-		created: rolesDiff.added,
-		deleted: rolesDiff.deleted,
-	});
-
-	schemasPatchedSnap1.roles = mapEntries(
-		schemasPatchedSnap1.roles,
-		(_, it) => {
-			const { name } = nameChangeFor(it, renamedRoles);
-			it.name = name;
-			return [name, it];
-		},
-	);
-
-	const rolesChangeMap = renamedRoles.reduce(
-		(acc, it) => {
-			acc[it.from.name] = {
-				nameFrom: it.from.name,
-				nameTo: it.to.name,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-			}
-		>,
-	);
-
-	schemasPatchedSnap1.roles = mapEntries(
-		schemasPatchedSnap1.roles,
-		(roleKey, roleValue) => {
-			const key = roleKey;
-			const change = rolesChangeMap[key];
-
-			if (change) {
-				roleValue.name = change.nameTo;
-			}
-
-			return [roleKey, roleValue];
-		},
-	);
-
-	const tablesDiff = diffSchemasOrTables(
-		schemasPatchedSnap1.tables as Record<string, any>,
-		json2.tables,
-	);
-
-	const {
-		created: createdTables,
-		deleted: deletedTables,
-		moved: movedTables,
-		renamed: renamedTables, // renamed or moved
-	} = await tablesResolver({
-		created: tablesDiff.added,
-		deleted: tablesDiff.deleted,
-	});
-
-	const tablesPatchedSnap1 = copy(schemasPatchedSnap1);
-	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
-		const { key, name, schema } = nameSchemaChangeFor(it, renamedTables);
-		it.name = name;
-		it.schema = schema;
-		return [key, it];
-	});
-
-	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
-
-	const columnRenames = [] as {
-		table: string;
-		schema: string;
-		renames: { from: Column; to: Column }[];
-	}[];
-
-	const columnCreates = [] as {
-		table: string;
-		schema: string;
-		columns: Column[];
-	}[];
-
-	const columnDeletes = [] as {
-		table: string;
-		schema: string;
-		columns: Column[];
-	}[];
-
-	for (let entry of Object.values(res)) {
-		const { renamed, created, deleted } = await columnsResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.columns.deleted,
-			created: entry.columns.added,
-		});
-
-		if (created.length > 0) {
-			columnCreates.push({
-				table: entry.name,
-				schema: entry.schema,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			columnDeletes.push({
-				table: entry.name,
-				schema: entry.schema,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			columnRenames.push({
-				table: entry.name,
-				schema: entry.schema,
-				renames: renamed,
-			});
-		}
-	}
-
-	const columnRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[`${it.schema || 'public'}.${it.table}`] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
-	columnsPatchedSnap1.tables = mapEntries(
-		columnsPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapKeys(
-				tableValue.columns,
-				(columnKey, column) => {
-					const rens = columnRenamesDict[
-						`${tableValue.schema || 'public'}.${tableValue.name}`
-					] || [];
-
-					const newName = columnChangeFor(columnKey, rens);
-					column.name = newName;
-					return newName;
-				},
-			);
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	//// Policies
-
-	const policyRes = diffPolicies(tablesPatchedSnap1.tables, json2.tables);
-
-	const policyRenames = [] as {
-		table: string;
-		schema: string;
-		renames: { from: Policy; to: Policy }[];
-	}[];
-
-	const policyCreates = [] as {
-		table: string;
-		schema: string;
-		columns: Policy[];
-	}[];
-
-	const policyDeletes = [] as {
-		table: string;
-		schema: string;
-		columns: Policy[];
-	}[];
-
-	for (let entry of Object.values(policyRes)) {
-		const { renamed, created, deleted } = await policyResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.policies.deleted.map(
-				action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy,
-			),
-			created: entry.policies.added.map(action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy),
-		});
-
-		if (created.length > 0) {
-			policyCreates.push({
-				table: entry.name,
-				schema: entry.schema,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			policyDeletes.push({
-				table: entry.name,
-				schema: entry.schema,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			policyRenames.push({
-				table: entry.name,
-				schema: entry.schema,
-				renames: renamed,
-			});
-		}
-	}
-
-	const policyRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[`${it.schema || 'public'}.${it.table}`] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const policyPatchedSnap1 = copy(tablesPatchedSnap1);
-	policyPatchedSnap1.tables = mapEntries(
-		policyPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedPolicies = mapKeys(
-				tableValue.policies,
-				(policyKey, policy) => {
-					const rens = policyRenamesDict[
-						`${tableValue.schema || 'public'}.${tableValue.name}`
-					] || [];
-
-					const newName = columnChangeFor(policyKey, rens);
-					const unsquashedPolicy = action === 'push'
-						? PgSquasher.unsquashPolicyPush(policy)
-						: PgSquasher.unsquashPolicy(policy);
-					unsquashedPolicy.name = newName;
-					policy = PgSquasher.squashPolicy(unsquashedPolicy);
-					return newName;
-				},
-			);
-
-			tableValue.policies = patchedPolicies;
-			return [tableKey, tableValue];
-		},
-	);
-
-	//// Individual policies
-
-	const indPolicyRes = diffIndPolicies(policyPatchedSnap1.policies, json2.policies);
-
-	const indPolicyCreates = [] as {
-		policies: Policy[];
-	}[];
-
-	const indPolicyDeletes = [] as {
-		policies: Policy[];
-	}[];
-
-	const { renamed: indPolicyRenames, created, deleted } = await indPolicyResolver({
-		deleted: indPolicyRes.deleted.map((t) =>
-			action === 'push' ? PgSquasher.unsquashPolicyPush(t.values) : PgSquasher.unsquashPolicy(t.values)
-		),
-		created: indPolicyRes.added.map((t) =>
-			action === 'push' ? PgSquasher.unsquashPolicyPush(t.values) : PgSquasher.unsquashPolicy(t.values)
-		),
-	});
-
-	if (created.length > 0) {
-		indPolicyCreates.push({
-			policies: created,
-		});
-	}
-
-	if (deleted.length > 0) {
-		indPolicyDeletes.push({
-			policies: deleted,
-		});
-	}
-
-	const indPolicyRenamesDict = indPolicyRenames.reduce(
-		(acc, it) => {
-			acc[it.from.name] = {
-				nameFrom: it.from.name,
-				nameTo: it.to.name,
-			};
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				nameFrom: string;
-				nameTo: string;
-			}
-		>,
-	);
-
-	const indPolicyPatchedSnap1 = copy(policyPatchedSnap1);
-	indPolicyPatchedSnap1.policies = mapEntries(
-		indPolicyPatchedSnap1.policies,
-		(policyKey, policyValue) => {
-			const key = policyKey;
-			const change = indPolicyRenamesDict[key];
-
-			if (change) {
-				policyValue.name = change.nameTo;
-			}
-
-			return [policyKey, policyValue];
-		},
-	);
-
-	////
-	const viewsDiff = diffSchemasOrTables(indPolicyPatchedSnap1.views, json2.views);
-
-	const {
-		created: createdViews,
-		deleted: deletedViews,
-		renamed: renamedViews,
-		moved: movedViews,
-	} = await viewsResolver({
-		created: viewsDiff.added,
-		deleted: viewsDiff.deleted,
-	});
-
-	const renamesViewDic: Record<string, { to: string; from: string }> = {};
-	renamedViews.forEach((it) => {
-		renamesViewDic[`${it.from.schema}.${it.from.name}`] = { to: it.to.name, from: it.from.name };
-	});
-
-	const movedViewDic: Record<string, { to: string; from: string }> = {};
-	movedViews.forEach((it) => {
-		movedViewDic[`${it.schemaFrom}.${it.name}`] = { to: it.schemaTo, from: it.schemaFrom };
-	});
-
-	const viewsPatchedSnap1 = copy(policyPatchedSnap1);
-	viewsPatchedSnap1.views = mapEntries(
-		viewsPatchedSnap1.views,
-		(viewKey, viewValue) => {
-			const rename = renamesViewDic[`${viewValue.schema}.${viewValue.name}`];
-			const moved = movedViewDic[`${viewValue.schema}.${viewValue.name}`];
-
-			if (rename) {
-				viewValue.name = rename.to;
-				viewKey = `${viewValue.schema}.${viewValue.name}`;
-			}
-
-			if (moved) viewKey = `${moved.to}.${viewValue.name}`;
-
-			return [viewKey, viewValue];
-		},
-	);
-
-	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
-
-	const typedResult: DiffResult = diffResultScheme.parse(diffResult);
-
-	const jsonStatements: JsonStatement[] = [];
-
-	const jsonCreateIndexesForCreatedTables = createdTables
-		.map((it) => {
-			return preparePgCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.indexes,
-				curFull,
-				action,
-			);
-		})
-		.flat();
-
-	const jsonDropTables = deletedTables.map((it) => {
-		return prepareDropTableJson(it);
-	});
-
-	const jsonRenameTables = renamedTables.map((it) => {
-		return prepareRenameTableJson(it.from, it.to);
-	});
-
-	const alteredTables = typedResult.alteredTablesWithColumns;
-
-	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = [];
-	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = [];
-	const jsonAddColumnsStatemets: JsonAddColumnStatement[] = [];
-
-	for (let it of columnRenames) {
-		jsonRenameColumnsStatements.push(
-			...prepareRenameColumns(it.table, it.schema, it.renames),
-		);
-	}
-
-	for (let it of columnDeletes) {
-		jsonDropColumnsStatemets.push(
-			..._prepareDropColumns(it.table, it.schema, it.columns),
-		);
-	}
-
-	for (let it of columnCreates) {
-		jsonAddColumnsStatemets.push(
-			..._prepareAddColumns(it.table, it.schema, it.columns),
-		);
-	}
-
-	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
-	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
-	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
-
-	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-	const jsonSetTableSchemas: JsonAlterTableSetSchema[] = [];
-
-	if (movedTables) {
-		for (let it of movedTables) {
-			jsonSetTableSchemas.push({
-				type: 'alter_table_set_schema',
-				tableName: it.name,
-				schemaFrom: it.schemaFrom || 'public',
-				schemaTo: it.schemaTo || 'public',
-			});
-		}
-	}
-
-	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
-
-	for (let it of alteredTables) {
-		// This part is needed to make sure that same columns in a table are not triggered for change
-		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
-		// We double-check that pk with same set of columns are both in added and deleted diffs
-		let addedColumns: { name: string; columns: string[] } | undefined;
-		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
-			const addedPkColumns = it.addedCompositePKs[addedPkName];
-			addedColumns = PgSquasher.unsquashPK(addedPkColumns);
-		}
-
-		let deletedColumns: { name: string; columns: string[] } | undefined;
-		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
-			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
-			deletedColumns = PgSquasher.unsquashPK(deletedPkColumns);
-		}
-
-		// Don't need to sort, but need to add tests for it
-		// addedColumns.sort();
-		// deletedColumns.sort();
-		const doPerformDeleteAndCreate = JSON.stringify(addedColumns ?? {}) !== JSON.stringify(deletedColumns ?? {});
-
-		let addedCompositePKs: JsonCreateCompositePK[] = [];
-		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
-		let alteredCompositePKs: JsonAlterCompositePK[] = [];
-		if (doPerformDeleteAndCreate) {
-			addedCompositePKs = prepareAddCompositePrimaryKeyPg(
-				it.name,
-				it.schema,
-				it.addedCompositePKs,
-				curFull as PgSchema,
-			);
-			deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
-				it.name,
-				it.schema,
-				it.deletedCompositePKs,
-				prevFull as PgSchema,
-			);
-		}
-		alteredCompositePKs = prepareAlterCompositePrimaryKeyPg(
-			it.name,
-			it.schema,
-			it.alteredCompositePKs,
-			prevFull as PgSchema,
-			curFull as PgSchema,
-		);
-
-		// add logic for unique constraints
-		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-		let createCheckConstraints: JsonCreateCheckConstraint[] = [];
-		let deleteCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		createCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
-		deleteCheckConstraints = prepareDeleteCheckConstraint(
-			it.name,
-			it.schema,
-			it.deletedCheckConstraints,
-		);
-
-		if (it.alteredCheckConstraints && action !== 'push') {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-
-			for (const k of Object.keys(it.alteredCheckConstraints)) {
-				added[k] = it.alteredCheckConstraints[k].__new;
-				deleted[k] = it.alteredCheckConstraints[k].__old;
-			}
-			createCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
-			deleteCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
-		}
-
-		jsonCreatedCheckConstraints.push(...createCheckConstraints);
-		jsonDeletedCheckConstraints.push(...deleteCheckConstraints);
-
-		jsonAddedCompositePKs.push(...addedCompositePKs);
-		jsonDeletedCompositePKs.push(...deletedCompositePKs);
-		jsonAlteredCompositePKs.push(...alteredCompositePKs);
-
-		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
-		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
-		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
-	}
-
-	const rColumns = jsonRenameColumnsStatements.map((it) => {
-		const tableName = it.tableName;
-		const schema = it.schema;
-		return {
-			from: { schema, table: tableName, column: it.oldColumnName },
-			to: { schema, table: tableName, column: it.newColumnName },
-		};
-	});
-
-	const jsonTableAlternations = alteredTables
-		.map((it) => {
-			return preparePgAlterColumns(
-				it.name,
-				it.schema,
-				it.altered,
-				json2,
-				json1,
-				action,
-			);
-		})
-		.flat();
-
-	const jsonCreateIndexesFoAlteredTables = alteredTables
-		.map((it) => {
-			return preparePgCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.addedIndexes || {},
-				curFull,
-				action,
-			);
-		})
-		.flat();
-
-	const jsonDropIndexesForAllAlteredTables = alteredTables
-		.map((it) => {
-			return prepareDropIndexesJson(
-				it.name,
-				it.schema,
-				it.deletedIndexes || {},
-			);
-		})
-		.flat();
-
-	const jsonCreatePoliciesStatements: JsonCreatePolicyStatement[] = [];
-	const jsonDropPoliciesStatements: JsonDropPolicyStatement[] = [];
-	const jsonAlterPoliciesStatements: JsonAlterPolicyStatement[] = [];
-	const jsonRenamePoliciesStatements: JsonRenamePolicyStatement[] = [];
-
-	const jsonRenameIndPoliciesStatements: JsonIndRenamePolicyStatement[] = [];
-	const jsonCreateIndPoliciesStatements: JsonCreateIndPolicyStatement[] = [];
-	const jsonDropIndPoliciesStatements: JsonDropIndPolicyStatement[] = [];
-	const jsonAlterIndPoliciesStatements: JsonAlterIndPolicyStatement[] = [];
-
-	const jsonEnableRLSStatements: JsonEnableRLSStatement[] = [];
-	const jsonDisableRLSStatements: JsonDisableRLSStatement[] = [];
-
-	for (let it of indPolicyRenames) {
-		jsonRenameIndPoliciesStatements.push(
-			...prepareRenameIndPolicyJsons([it]),
-		);
-	}
-
-	for (const it of indPolicyCreates) {
-		jsonCreateIndPoliciesStatements.push(
-			...prepareCreateIndPolicyJsons(
-				it.policies,
-			),
-		);
-	}
-
-	for (const it of indPolicyDeletes) {
-		jsonDropIndPoliciesStatements.push(
-			...prepareDropIndPolicyJsons(
-				it.policies,
-			),
-		);
-	}
-
-	typedResult.alteredPolicies.forEach(({ values }) => {
-		// return prepareAlterIndPolicyJson(json1.policies[it.name], json2.policies[it.name]);
-
-		const policy = action === 'push' ? PgSquasher.unsquashPolicyPush(values) : PgSquasher.unsquashPolicy(values);
-
-		const newPolicy = action === 'push'
-			? PgSquasher.unsquashPolicyPush(json2.policies[policy.name].values)
-			: PgSquasher.unsquashPolicy(json2.policies[policy.name].values);
-		const oldPolicy = action === 'push'
-			? PgSquasher.unsquashPolicyPush(json2.policies[policy.name].values)
-			: PgSquasher.unsquashPolicy(json1.policies[policy.name].values);
-
-		if (newPolicy.as !== oldPolicy.as) {
-			jsonDropIndPoliciesStatements.push(
-				...prepareDropIndPolicyJsons(
-					[oldPolicy],
-				),
-			);
-
-			jsonCreateIndPoliciesStatements.push(
-				...prepareCreateIndPolicyJsons(
-					[newPolicy],
-				),
-			);
-			return;
-		}
-
-		if (newPolicy.for !== oldPolicy.for) {
-			jsonDropIndPoliciesStatements.push(
-				...prepareDropIndPolicyJsons(
-					[oldPolicy],
-				),
-			);
-
-			jsonCreateIndPoliciesStatements.push(
-				...prepareCreateIndPolicyJsons(
-					[newPolicy],
-				),
-			);
-			return;
-		}
-
-		// alter
-		jsonAlterIndPoliciesStatements.push(
-			prepareAlterIndPolicyJson(
-				oldPolicy,
-				newPolicy,
-			),
-		);
-	});
-
-	for (let it of policyRenames) {
-		jsonRenamePoliciesStatements.push(
-			...prepareRenamePolicyJsons(it.table, it.schema, it.renames),
-		);
-	}
-
-	for (const it of policyCreates) {
-		jsonCreatePoliciesStatements.push(
-			...prepareCreatePolicyJsons(
-				it.table,
-				it.schema,
-				it.columns,
-			),
-		);
-	}
-
-	for (const it of policyDeletes) {
-		jsonDropPoliciesStatements.push(
-			...prepareDropPolicyJsons(
-				it.table,
-				it.schema,
-				it.columns,
-			),
-		);
-	}
-
-	alteredTables.forEach((it) => {
-		// handle policies
-		Object.keys(it.alteredPolicies).forEach((policyName: string) => {
-			const newPolicy = action === 'push'
-				? PgSquasher.unsquashPolicyPush(it.alteredPolicies[policyName].__new)
-				: PgSquasher.unsquashPolicy(it.alteredPolicies[policyName].__new);
-			const oldPolicy = action === 'push'
-				? PgSquasher.unsquashPolicyPush(it.alteredPolicies[policyName].__old)
-				: PgSquasher.unsquashPolicy(it.alteredPolicies[policyName].__old);
-
-			if (newPolicy.as !== oldPolicy.as) {
-				jsonDropPoliciesStatements.push(
-					...prepareDropPolicyJsons(
-						it.name,
-						it.schema,
-						[oldPolicy],
-					),
-				);
-
-				jsonCreatePoliciesStatements.push(
-					...prepareCreatePolicyJsons(
-						it.name,
-						it.schema,
-						[newPolicy],
-					),
-				);
-				return;
-			}
-
-			if (newPolicy.for !== oldPolicy.for) {
-				jsonDropPoliciesStatements.push(
-					...prepareDropPolicyJsons(
-						it.name,
-						it.schema,
-						[oldPolicy],
-					),
-				);
-
-				jsonCreatePoliciesStatements.push(
-					...prepareCreatePolicyJsons(
-						it.name,
-						it.schema,
-						[newPolicy],
-					),
-				);
-				return;
-			}
-
-			// alter
-			jsonAlterPoliciesStatements.push(
-				prepareAlterPolicyJson(
-					it.name,
-					it.schema,
-					it.alteredPolicies[policyName].__old,
-					it.alteredPolicies[policyName].__new,
-				),
-			);
-		});
-
-		// Handle enabling and disabling RLS
-		for (const table of Object.values(json2.tables)) {
-			const policiesInCurrentState = Object.keys(table.policies);
-			const tableInPreviousState =
-				columnsPatchedSnap1.tables[`${table.schema === '' ? 'public' : table.schema}.${table.name}`];
-			const policiesInPreviousState = tableInPreviousState ? Object.keys(tableInPreviousState.policies) : [];
-
-			// const indPoliciesInCurrentState = Object.keys(table.policies);
-			// const indPoliciesInPreviousState = Object.keys(columnsPatchedSnap1.policies);
-
-			if (
-				(policiesInPreviousState.length === 0 && policiesInCurrentState.length > 0) && !table.isRLSEnabled
-			) {
-				jsonEnableRLSStatements.push({ type: 'enable_rls', tableName: table.name, schema: table.schema });
-			}
-
-			if (
-				(policiesInPreviousState.length > 0 && policiesInCurrentState.length === 0) && !table.isRLSEnabled
-			) {
-				jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
-			}
-
-			// handle table.isRLSEnabled
-			const wasRlsEnabled = tableInPreviousState ? tableInPreviousState.isRLSEnabled : false;
-			if (table.isRLSEnabled !== wasRlsEnabled) {
-				if (table.isRLSEnabled) {
-					// was force enabled
-					jsonEnableRLSStatements.push({ type: 'enable_rls', tableName: table.name, schema: table.schema });
-				} else if (
-					!table.isRLSEnabled && policiesInCurrentState.length === 0
-				) {
-					// was force disabled
-					jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
-				}
-			}
-		}
-
-		for (const table of Object.values(columnsPatchedSnap1.tables)) {
-			const tableInCurrentState = json2.tables[`${table.schema === '' ? 'public' : table.schema}.${table.name}`];
-
-			if (tableInCurrentState === undefined && !table.isRLSEnabled) {
-				jsonDisableRLSStatements.push({ type: 'disable_rls', tableName: table.name, schema: table.schema });
-			}
-		}
-
-		// handle indexes
-		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__old;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__new;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-
-		jsonCreateIndexesFoAlteredTables.push(
-			...preparePgCreateIndexesJson(
-				it.name,
-				it.schema,
-				createdIndexes || {},
-				curFull,
-				action,
-			),
-		);
-		jsonDropIndexesForAllAlteredTables.push(
-			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
-		);
-	});
-
-	const jsonCreateReferencesForCreatedTables: JsonCreateReferenceStatement[] = createdTables
-		.map((it) => {
-			return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
-		})
-		.flat();
-
-	const jsonReferencesForAlteredTables: JsonReferenceStatement[] = alteredTables
-		.map((it) => {
-			const forAdded = prepareCreateReferencesJson(
-				it.name,
-				it.schema,
-				it.addedForeignKeys,
-			);
-
-			const forAltered = prepareDropReferencesJson(
-				it.name,
-				it.schema,
-				it.deletedForeignKeys,
-			);
-
-			const alteredFKs = prepareAlterReferencesJson(
-				it.name,
-				it.schema,
-				it.alteredForeignKeys,
-			);
-
-			return [...forAdded, ...forAltered, ...alteredFKs];
-		})
-		.flat();
-
-	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter((t) =>
-		t.type === 'create_reference'
-	);
-
-	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter((t) =>
-		t.type === 'delete_reference'
-	);
-
-	// Sequences
-	// - create sequence ✅
-	// - create sequence inside schema ✅
-	// - rename sequence ✅
-	// - change sequence schema ✅
-	// - change sequence schema + name ✅
-	// - drop sequence - check if sequence is in use. If yes - ???
-	// - change sequence values ✅
-
-	// Generated columns
-	// - add generated
-	// - drop generated
-	// - create table with generated
-	// - alter - should be not triggered, but should get warning
-
-	const createEnums = createdEnums.map((it) => {
-		return prepareCreateEnumJson(it.name, it.schema, it.values);
-	}) ?? [];
-
-	const dropEnums = deletedEnums.map((it) => {
-		return prepareDropEnumJson(it.name, it.schema);
-	});
-
-	const moveEnums = movedEnums.map((it) => {
-		return prepareMoveEnumJson(it.name, it.schemaFrom, it.schemaTo);
-	});
-
-	const renameEnums = renamedEnums.map((it) => {
-		return prepareRenameEnumJson(it.from.name, it.to.name, it.to.schema);
-	});
-
-	const jsonAlterEnumsWithAddedValues = typedResult.alteredEnums
-		.map((it) => {
-			return prepareAddValuesToEnumJson(it.name, it.schema, it.addedValues);
-		})
-		.flat() ?? [];
-
-	const jsonAlterEnumsWithDroppedValues = typedResult.alteredEnums
-		.map((it) => {
-			return prepareDropEnumValues(it.name, it.schema, it.deletedValues, curFull);
-		})
-		.flat() ?? [];
-
-	const createSequences = createdSequences.map((it) => {
-		return prepareCreateSequenceJson(it);
-	}) ?? [];
-
-	const dropSequences = deletedSequences.map((it) => {
-		return prepareDropSequenceJson(it.name, it.schema);
-	});
-
-	const moveSequences = movedSequences.map((it) => {
-		return prepareMoveSequenceJson(it.name, it.schemaFrom, it.schemaTo);
-	});
-
-	const renameSequences = renamedSequences.map((it) => {
-		return prepareRenameSequenceJson(it.from.name, it.to.name, it.to.schema);
-	});
-
-	const jsonAlterSequences = typedResult.alteredSequences
-		.map((it) => {
-			return prepareAlterSequenceJson(it);
-		})
-		.flat() ?? [];
-
-	////////////
-
-	const createRoles = createdRoles.map((it) => {
-		return prepareCreateRoleJson(it);
-	}) ?? [];
-
-	const dropRoles = deletedRoles.map((it) => {
-		return prepareDropRoleJson(it.name);
-	});
-
-	const renameRoles = renamedRoles.map((it) => {
-		return prepareRenameRoleJson(it.from.name, it.to.name);
-	});
-
-	const jsonAlterRoles = typedResult.alteredRoles
-		.map((it) => {
-			return prepareAlterRoleJson(it);
-		})
-		.flat() ?? [];
-
-	////////////
-	const createSchemas = prepareCreateSchemasJson(
-		createdSchemas.map((it) => it.name),
-	);
-
-	const renameSchemas = prepareRenameSchemasJson(
-		renamedSchemas.map((it) => ({ from: it.from.name, to: it.to.name })),
-	);
-
-	const dropSchemas = prepareDropSchemasJson(
-		deletedSchemas.map((it) => it.name),
-	);
-
-	const createTables = createdTables.map((it) => {
-		return preparePgCreateTableJson(it, curFull);
-	});
-
-	jsonCreatePoliciesStatements.push(...([] as JsonCreatePolicyStatement[]).concat(
-		...(createdTables.map((it) =>
-			prepareCreatePolicyJsons(
-				it.name,
-				it.schema,
-				Object.values(it.policies).map(action === 'push' ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy),
-			)
-		)),
-	));
-	const createViews: JsonCreatePgViewStatement[] = [];
-	const dropViews: JsonDropViewStatement[] = [];
-	const renameViews: JsonRenameViewStatement[] = [];
-	const alterViews: JsonAlterViewStatement[] = [];
-
-	createViews.push(
-		...createdViews.filter((it) => !it.isExisting).map((it) => {
-			return preparePgCreateViewJson(
-				it.name,
-				it.schema,
-				it.definition!,
-				it.materialized,
-				it.withNoData,
-				it.with,
-				it.using,
-				it.tablespace,
-			);
-		}),
-	);
-
-	dropViews.push(
-		...deletedViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareDropViewJson(it.name, it.schema, it.materialized);
-		}),
-	);
-
-	renameViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting && !json1.views[`${it.from.schema}.${it.from.name}`].isExisting)
-			.map((it) => {
-				return prepareRenameViewJson(it.to.name, it.from.name, it.to.schema, it.to.materialized);
-			}),
-	);
-
-	alterViews.push(
-		...movedViews.filter((it) =>
-			!json2.views[`${it.schemaTo}.${it.name}`].isExisting && !json1.views[`${it.schemaFrom}.${it.name}`].isExisting
-		).map((it) => {
-			return preparePgAlterViewAlterSchemaJson(
-				it.schemaTo,
-				it.schemaFrom,
-				it.name,
-				json2.views[`${it.schemaTo}.${it.name}`].materialized,
-			);
-		}),
-	);
-
-	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[`${it.schema}.${it.name}`].isExisting);
-
-	for (const alteredView of alteredViews) {
-		const viewKey = `${alteredView.schema}.${alteredView.name}`;
-
-		const { materialized, with: withOption, definition, withNoData, using, tablespace } = json2.views[viewKey];
-
-		if (alteredView.alteredExisting || (alteredView.alteredDefinition && action !== 'push')) {
-			dropViews.push(prepareDropViewJson(alteredView.name, alteredView.schema, materialized));
-
-			createViews.push(
-				preparePgCreateViewJson(
-					alteredView.name,
-					alteredView.schema,
-					definition!,
-					materialized,
-					withNoData,
-					withOption,
-					using,
-					tablespace,
-				),
-			);
-
-			continue;
-		}
-
-		if (alteredView.addedWithOption) {
-			alterViews.push(
-				preparePgAlterViewAddWithOptionJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.addedWithOption,
-				),
-			);
-		}
-
-		if (alteredView.deletedWithOption) {
-			alterViews.push(
-				preparePgAlterViewDropWithOptionJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.deletedWithOption,
-				),
-			);
-		}
-
-		if (alteredView.addedWith) {
-			alterViews.push(
-				preparePgAlterViewAddWithOptionJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.addedWith,
-				),
-			);
-		}
-
-		if (alteredView.deletedWith) {
-			alterViews.push(
-				preparePgAlterViewDropWithOptionJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.deletedWith,
-				),
-			);
-		}
-
-		if (alteredView.alteredWith) {
-			alterViews.push(
-				preparePgAlterViewAddWithOptionJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.alteredWith,
-				),
-			);
-		}
-
-		if (alteredView.alteredTablespace) {
-			alterViews.push(
-				preparePgAlterViewAlterTablespaceJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.alteredTablespace.__new,
-				),
-			);
-		}
-
-		if (alteredView.alteredUsing) {
-			alterViews.push(
-				preparePgAlterViewAlterUsingJson(
-					alteredView.name,
-					alteredView.schema,
-					materialized,
-					alteredView.alteredUsing.__new,
-				),
-			);
-		}
-	}
-
-	jsonStatements.push(...createSchemas);
-	jsonStatements.push(...renameSchemas);
-	jsonStatements.push(...createEnums);
-	jsonStatements.push(...moveEnums);
-	jsonStatements.push(...renameEnums);
-	jsonStatements.push(...jsonAlterEnumsWithAddedValues);
-
-	jsonStatements.push(...createSequences);
-	jsonStatements.push(...moveSequences);
-	jsonStatements.push(...renameSequences);
-	jsonStatements.push(...jsonAlterSequences);
-
-	jsonStatements.push(...renameRoles);
-	jsonStatements.push(...dropRoles);
-	jsonStatements.push(...createRoles);
-	jsonStatements.push(...jsonAlterRoles);
-
-	jsonStatements.push(...createTables);
-
-	jsonStatements.push(...jsonEnableRLSStatements);
-	jsonStatements.push(...jsonDisableRLSStatements);
-	jsonStatements.push(...dropViews);
-	jsonStatements.push(...renameViews);
-	jsonStatements.push(...alterViews);
-
-	jsonStatements.push(...jsonDropTables);
-	jsonStatements.push(...jsonSetTableSchemas);
-	jsonStatements.push(...jsonRenameTables);
-	jsonStatements.push(...jsonRenameColumnsStatements);
-
-	jsonStatements.push(...jsonDeletedUniqueConstraints);
-	jsonStatements.push(...jsonDeletedCheckConstraints);
-
-	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
-
-	jsonStatements.push(...jsonAlterEnumsWithDroppedValues);
-
-	// Will need to drop indexes before changing any columns in table
-	// Then should go column alternations and then index creation
-	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDeletedCompositePKs);
-	jsonStatements.push(...jsonTableAlternations);
-	jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAddColumnsStatemets);
-
-	jsonStatements.push(...jsonCreateReferencesForCreatedTables);
-	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
-
-	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
-	jsonStatements.push(...jsonCreateIndexesFoAlteredTables);
-
-	jsonStatements.push(...jsonDropColumnsStatemets);
-	jsonStatements.push(...jsonAlteredCompositePKs);
-
-	jsonStatements.push(...jsonAddedUniqueConstraints);
-	jsonStatements.push(...jsonCreatedCheckConstraints);
-
-	jsonStatements.push(...jsonAlteredUniqueConstraints);
-
-	jsonStatements.push(...createViews);
-
-	jsonStatements.push(...jsonRenamePoliciesStatements);
-	jsonStatements.push(...jsonDropPoliciesStatements);
-	jsonStatements.push(...jsonCreatePoliciesStatements);
-	jsonStatements.push(...jsonAlterPoliciesStatements);
-
-	jsonStatements.push(...jsonRenameIndPoliciesStatements);
-	jsonStatements.push(...jsonDropIndPoliciesStatements);
-	jsonStatements.push(...jsonCreateIndPoliciesStatements);
-	jsonStatements.push(...jsonAlterIndPoliciesStatements);
-
-	jsonStatements.push(...dropEnums);
-	jsonStatements.push(...dropSequences);
-	jsonStatements.push(...dropSchemas);
-
-	// generate filters
-	const filteredJsonStatements = jsonStatements.filter((st) => {
-		if (st.type === 'alter_table_alter_column_drop_notnull') {
-			if (
-				jsonStatements.find(
-					(it) =>
-						it.type === 'alter_table_alter_column_drop_identity'
-						&& it.tableName === st.tableName
-						&& it.schema === st.schema,
-				)
-			) {
-				return false;
-			}
-		}
-		if (st.type === 'alter_table_alter_column_set_notnull') {
-			if (
-				jsonStatements.find(
-					(it) =>
-						it.type === 'alter_table_alter_column_set_identity'
-						&& it.tableName === st.tableName
-						&& it.schema === st.schema,
-				)
-			) {
-				return false;
-			}
-		}
-		return true;
-	});
-
-	// enum filters
-	// Need to find add and drop enum values in same enum and remove add values
-	const filteredEnumsJsonStatements = filteredJsonStatements.filter((st) => {
-		if (st.type === 'alter_type_add_value') {
-			if (
-				filteredJsonStatements.find(
-					(it) =>
-						it.type === 'alter_type_drop_value'
-						&& it.name === st.name
-						&& it.enumSchema === st.schema,
-				)
-			) {
-				return false;
-			}
-		}
-		return true;
-	});
-
-	// This is needed because in sql generator on type pg_alter_table_alter_column_set_type and alter_type_drop_value
-	// drizzle kit checks whether column has defaults to cast them to new types properly
-	const filteredEnums2JsonStatements = filteredEnumsJsonStatements.filter((st) => {
-		if (st.type === 'alter_table_alter_column_set_default') {
-			if (
-				filteredEnumsJsonStatements.find(
-					(it) =>
-						it.type === 'pg_alter_table_alter_column_set_type'
-						&& it.columnDefault === st.newDefaultValue
-						&& it.columnName === st.columnName
-						&& it.tableName === st.tableName
-						&& it.schema === st.schema,
-				)
-			) {
-				return false;
-			}
-
-			if (
-				filteredEnumsJsonStatements.find(
-					(it) =>
-						it.type === 'alter_type_drop_value'
-						&& it.columnsWithEnum.find((column) =>
-							column.default === st.newDefaultValue
-							&& column.column === st.columnName
-							&& column.table === st.tableName
-							&& column.tableSchema === st.schema
-						),
-				)
-			) {
-				return false;
-			}
-		}
-		return true;
-	});
-
-	const sqlStatements = fromJson(filteredEnums2JsonStatements, 'postgresql', action);
-
-	const uniqueSqlStatements: string[] = [];
-	sqlStatements.forEach((ss) => {
-		if (!uniqueSqlStatements.includes(ss)) {
-			uniqueSqlStatements.push(ss);
-		}
-	});
-
-	const rSchemas = renamedSchemas.map((it) => ({
-		from: it.from.name,
-		to: it.to.name,
-	}));
-
-	const rTables = renamedTables.map((it) => {
-		return { from: it.from, to: it.to };
-	});
-
-	const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
-
-	return {
-		statements: filteredEnums2JsonStatements,
-		sqlStatements: uniqueSqlStatements,
-		_meta,
-	};
-};
-
-export const applyMysqlSnapshotsDiff = async (
-	json1: MySqlSchemaSquashed,
-	json2: MySqlSchemaSquashed,
-	tablesResolver: (
-		input: ResolverInput<Table>,
-	) => Promise<ResolverOutputWithMoved<Table>>,
-	columnsResolver: (
-		input: ColumnsResolverInput<Column>,
-	) => Promise<ColumnsResolverOutput<Column>>,
-	viewsResolver: (
-		input: ResolverInput<ViewSquashed & { schema: '' }>,
-	) => Promise<ResolverOutputWithMoved<ViewSquashed>>,
-	prevFull: MySqlSchema,
-	curFull: MySqlSchema,
-	action?: 'push' | undefined,
-): Promise<{
-	statements: JsonStatement[];
-	sqlStatements: string[];
-	_meta:
-		| {
-			schemas: {};
-			tables: {};
-			columns: {};
-		}
-		| undefined;
-}> => {
-	// squash indexes and fks
-
-	// squash uniqueIndexes and uniqueConstraint into constraints object
-	// it should be done for mysql only because it has no diffs for it
-
-	// TODO: @AndriiSherman
-	// Add an upgrade to v6 and move all snaphosts to this strcutre
-	// After that we can generate mysql in 1 object directly(same as sqlite)
-	for (const tableName in json1.tables) {
-		const table = json1.tables[tableName];
-		for (const indexName in table.indexes) {
-			const index = MySqlSquasher.unsquashIdx(table.indexes[indexName]);
-			if (index.isUnique) {
-				table.uniqueConstraints[indexName] = MySqlSquasher.squashUnique({
-					name: index.name,
-					columns: index.columns,
-				});
-				delete json1.tables[tableName].indexes[index.name];
-			}
-		}
-	}
-
-	for (const tableName in json2.tables) {
-		const table = json2.tables[tableName];
-		for (const indexName in table.indexes) {
-			const index = MySqlSquasher.unsquashIdx(table.indexes[indexName]);
-			if (index.isUnique) {
-				table.uniqueConstraints[indexName] = MySqlSquasher.squashUnique({
-					name: index.name,
-					columns: index.columns,
-				});
-				delete json2.tables[tableName].indexes[index.name];
-			}
-		}
-	}
-
-	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
-
-	const {
-		created: createdTables,
-		deleted: deletedTables,
-		renamed: renamedTables, // renamed or moved
-	} = await tablesResolver({
-		created: tablesDiff.added,
-		deleted: tablesDiff.deleted,
-	});
-
-	const tablesPatchedSnap1 = copy(json1);
-	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
-		const { name } = nameChangeFor(it, renamedTables);
-		it.name = name;
-		return [name, it];
-	});
-
-	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
-	const columnRenames = [] as {
-		table: string;
-		renames: { from: Column; to: Column }[];
-	}[];
-
-	const columnCreates = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	const columnDeletes = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	for (let entry of Object.values(res)) {
-		const { renamed, created, deleted } = await columnsResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.columns.deleted,
-			created: entry.columns.added,
-		});
-
-		if (created.length > 0) {
-			columnCreates.push({
-				table: entry.name,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			columnDeletes.push({
-				table: entry.name,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			columnRenames.push({
-				table: entry.name,
-				renames: renamed,
-			});
-		}
-	}
-
-	const columnRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[it.table] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
-	columnsPatchedSnap1.tables = mapEntries(
-		columnsPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapKeys(
-				tableValue.columns,
-				(columnKey, column) => {
-					const rens = columnRenamesDict[tableValue.name] || [];
-					const newName = columnChangeFor(columnKey, rens);
-					column.name = newName;
-					return newName;
-				},
-			);
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
-
-	const {
-		created: createdViews,
-		deleted: deletedViews,
-		renamed: renamedViews, // renamed or moved
-	} = await viewsResolver({
-		created: viewsDiff.added,
-		deleted: viewsDiff.deleted,
-	});
-
-	const renamesViewDic: Record<string, { to: string; from: string }> = {};
-	renamedViews.forEach((it) => {
-		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
-	});
-
-	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
-	viewsPatchedSnap1.views = mapEntries(
-		viewsPatchedSnap1.views,
-		(viewKey, viewValue) => {
-			const rename = renamesViewDic[viewValue.name];
-
-			if (rename) {
-				viewValue.name = rename.to;
-				viewKey = rename.to;
-			}
-
-			return [viewKey, viewValue];
-		},
-	);
-
-	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
-
-	const typedResult: DiffResultMysql = diffResultSchemeMysql.parse(diffResult);
-
-	const jsonStatements: JsonStatement[] = [];
-
-	const jsonCreateIndexesForCreatedTables = createdTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.indexes,
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropTables = deletedTables.map((it) => {
-		return prepareDropTableJson(it);
-	});
-
-	const jsonRenameTables = renamedTables.map((it) => {
-		return prepareRenameTableJson(it.from, it.to);
-	});
-
-	const alteredTables = typedResult.alteredTablesWithColumns;
-
-	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
-	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
-	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
-
-	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
-	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
-		.map((it) => prepareRenameColumns(it.table, '', it.renames))
-		.flat();
-
-	const jsonAddColumnsStatemets: JsonAddColumnStatement[] = columnCreates
-		.map((it) => _prepareAddColumns(it.table, '', it.columns))
-		.flat();
-
-	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
-		.map((it) => _prepareDropColumns(it.table, '', it.columns))
-		.flat();
-
-	alteredTables.forEach((it) => {
-		// This part is needed to make sure that same columns in a table are not triggered for change
-		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
-		// We double-check that pk with same set of columns are both in added and deleted diffs
-		let addedColumns: string[] = [];
-		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
-			const addedPkColumns = it.addedCompositePKs[addedPkName];
-			addedColumns = MySqlSquasher.unsquashPK(addedPkColumns).columns;
-		}
-
-		let deletedColumns: string[] = [];
-		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
-			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
-			deletedColumns = MySqlSquasher.unsquashPK(deletedPkColumns).columns;
-		}
-
-		// Don't need to sort, but need to add tests for it
-		// addedColumns.sort();
-		// deletedColumns.sort();
-		const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
-
-		let addedCompositePKs: JsonCreateCompositePK[] = [];
-		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
-		let alteredCompositePKs: JsonAlterCompositePK[] = [];
-
-		addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
-			it.name,
-			it.addedCompositePKs,
-			prevFull,
-			curFull,
-		);
-		deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
-			it.name,
-			it.deletedCompositePKs,
-			prevFull,
-		);
-		// }
-		alteredCompositePKs = prepareAlterCompositePrimaryKeyMySql(
-			it.name,
-			it.alteredCompositePKs,
-			prevFull,
-			curFull,
-		);
-
-		// add logic for unique constraints
-		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
-		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
-		deletedCheckConstraints = prepareDeleteCheckConstraint(
-			it.name,
-			it.schema,
-			it.deletedCheckConstraints,
-		);
-
-		// skip for push
-		if (it.alteredCheckConstraints && action !== 'push') {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-
-			for (const k of Object.keys(it.alteredCheckConstraints)) {
-				added[k] = it.alteredCheckConstraints[k].__new;
-				deleted[k] = it.alteredCheckConstraints[k].__old;
-			}
-			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
-			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
-		}
-
-		jsonAddedCompositePKs.push(...addedCompositePKs);
-		jsonDeletedCompositePKs.push(...deletedCompositePKs);
-		jsonAlteredCompositePKs.push(...alteredCompositePKs);
-
-		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
-		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
-		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
-
-		jsonCreatedCheckConstraints.push(...createdCheckConstraints);
-		jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
-	});
-
-	const rColumns = jsonRenameColumnsStatements.map((it) => {
-		const tableName = it.tableName;
-		const schema = it.schema;
-		return {
-			from: { schema, table: tableName, column: it.oldColumnName },
-			to: { schema, table: tableName, column: it.newColumnName },
-		};
-	});
-
-	const jsonTableAlternations = alteredTables
-		.map((it) => {
-			return prepareAlterColumnsMysql(
-				it.name,
-				it.schema,
-				it.altered,
-				json1,
-				json2,
-				action,
-			);
-		})
-		.flat();
-
-	const jsonCreateIndexesForAllAlteredTables = alteredTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.addedIndexes || {},
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropIndexesForAllAlteredTables = alteredTables
-		.map((it) => {
-			return prepareDropIndexesJson(
-				it.name,
-				it.schema,
-				it.deletedIndexes || {},
-			);
-		})
-		.flat();
-
-	alteredTables.forEach((it) => {
-		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__old;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__new;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-
-		jsonCreateIndexesForAllAlteredTables.push(
-			...prepareCreateIndexesJson(it.name, it.schema, createdIndexes || {}),
-		);
-		jsonDropIndexesForAllAlteredTables.push(
-			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
-		);
-	});
-
-	const jsonCreateReferencesForCreatedTables: JsonCreateReferenceStatement[] = createdTables
-		.map((it) => {
-			return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
-		})
-		.flat();
-
-	const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = alteredTables
-		.map((it) => {
-			const forAdded = prepareCreateReferencesJson(
-				it.name,
-				it.schema,
-				it.addedForeignKeys,
-			);
-
-			const forAltered = prepareDropReferencesJson(
-				it.name,
-				it.schema,
-				it.deletedForeignKeys,
-			);
-
-			const alteredFKs = prepareAlterReferencesJson(
-				it.name,
-				it.schema,
-				it.alteredForeignKeys,
-			);
-
-			return [...forAdded, ...forAltered, ...alteredFKs];
-		})
-		.flat();
-
-	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'create_reference',
-	);
-	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'delete_reference',
-	);
-
-	const jsonMySqlCreateTables = createdTables.map((it) => {
-		return prepareMySqlCreateTableJson(
-			it,
-			curFull as MySqlSchema,
-			curFull.internal,
-		);
-	});
-
-	const createViews: JsonCreateMySqlViewStatement[] = [];
-	const dropViews: JsonDropViewStatement[] = [];
-	const renameViews: JsonRenameViewStatement[] = [];
-	const alterViews: JsonAlterMySqlViewStatement[] = [];
-
-	createViews.push(
-		...createdViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareMySqlCreateViewJson(
-				it.name,
-				it.definition!,
-				it.meta,
-			);
-		}),
-	);
-
-	dropViews.push(
-		...deletedViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareDropViewJson(it.name);
-		}),
-	);
-
-	renameViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting && !json1.views[it.from.name].isExisting).map((it) => {
-			return prepareRenameViewJson(it.to.name, it.from.name);
-		}),
-	);
-
-	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
-
-	for (const alteredView of alteredViews) {
-		const { definition, meta } = json2.views[alteredView.name];
-
-		if (alteredView.alteredExisting) {
-			dropViews.push(prepareDropViewJson(alteredView.name));
-
-			createViews.push(
-				prepareMySqlCreateViewJson(
-					alteredView.name,
-					definition!,
-					meta,
-				),
-			);
-
-			continue;
-		}
-
-		if (alteredView.alteredDefinition && action !== 'push') {
-			createViews.push(
-				prepareMySqlCreateViewJson(
-					alteredView.name,
-					definition!,
-					meta,
-					true,
-				),
-			);
-			continue;
-		}
-
-		if (alteredView.alteredMeta) {
-			const view = curFull['views'][alteredView.name];
-			alterViews.push(
-				prepareMySqlAlterView(view),
-			);
-		}
-	}
-
-	jsonStatements.push(...jsonMySqlCreateTables);
-
-	jsonStatements.push(...jsonDropTables);
-	jsonStatements.push(...jsonRenameTables);
-	jsonStatements.push(...jsonRenameColumnsStatements);
-
-	jsonStatements.push(...dropViews);
-	jsonStatements.push(...renameViews);
-	jsonStatements.push(...alterViews);
-
-	jsonStatements.push(...jsonDeletedUniqueConstraints);
-	jsonStatements.push(...jsonDeletedCheckConstraints);
-
-	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
-
-	// Will need to drop indexes before changing any columns in table
-	// Then should go column alternations and then index creation
-	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDeletedCompositePKs);
-	jsonStatements.push(...jsonTableAlternations);
-	jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAddColumnsStatemets);
-
-	jsonStatements.push(...jsonAddedUniqueConstraints);
-	jsonStatements.push(...jsonDeletedUniqueConstraints);
-
-	jsonStatements.push(...jsonCreateReferencesForCreatedTables);
-	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
-	jsonStatements.push(...jsonCreatedCheckConstraints);
-
-	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
-	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDropColumnsStatemets);
-
-	// jsonStatements.push(...jsonDeletedCompositePKs);
-	// jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAlteredCompositePKs);
-
-	jsonStatements.push(...createViews);
-
-	jsonStatements.push(...jsonAlteredUniqueConstraints);
-
-	const sqlStatements = fromJson(jsonStatements, 'mysql');
-
-	const uniqueSqlStatements: string[] = [];
-	sqlStatements.forEach((ss) => {
-		if (!uniqueSqlStatements.includes(ss)) {
-			uniqueSqlStatements.push(ss);
-		}
-	});
-
-	const rTables = renamedTables.map((it) => {
-		return { from: it.from, to: it.to };
-	});
-
-	const _meta = prepareMigrationMeta([], rTables, rColumns);
-
-	return {
-		statements: jsonStatements,
-		sqlStatements: uniqueSqlStatements,
-		_meta,
-	};
-};
-
-export const applySingleStoreSnapshotsDiff = async (
-	json1: SingleStoreSchemaSquashed,
-	json2: SingleStoreSchemaSquashed,
-	tablesResolver: (
-		input: ResolverInput<Table>,
-	) => Promise<ResolverOutputWithMoved<Table>>,
-	columnsResolver: (
-		input: ColumnsResolverInput<Column>,
-	) => Promise<ColumnsResolverOutput<Column>>,
-	/* viewsResolver: (
-		input: ResolverInput<ViewSquashed & { schema: '' }>,
-	) => Promise<ResolverOutputWithMoved<ViewSquashed>>, */
-	prevFull: SingleStoreSchema,
-	curFull: SingleStoreSchema,
-	action?: 'push' | undefined,
-): Promise<{
-	statements: JsonStatement[];
-	sqlStatements: string[];
-	_meta:
-		| {
-			schemas: {};
-			tables: {};
-			columns: {};
-		}
-		| undefined;
-}> => {
-	// squash indexes and fks
-
-	// squash uniqueIndexes and uniqueConstraint into constraints object
-	// it should be done for singlestore only because it has no diffs for it
-
-	// TODO: @AndriiSherman
-	// Add an upgrade to v6 and move all snaphosts to this strcutre
-	// After that we can generate singlestore in 1 object directly(same as sqlite)
-	for (const tableName in json1.tables) {
-		const table = json1.tables[tableName];
-		for (const indexName in table.indexes) {
-			const index = SingleStoreSquasher.unsquashIdx(table.indexes[indexName]);
-			if (index.isUnique) {
-				table.uniqueConstraints[indexName] = SingleStoreSquasher.squashUnique({
-					name: index.name,
-					columns: index.columns,
-				});
-				delete json1.tables[tableName].indexes[index.name];
-			}
-		}
-	}
-
-	for (const tableName in json2.tables) {
-		const table = json2.tables[tableName];
-		for (const indexName in table.indexes) {
-			const index = SingleStoreSquasher.unsquashIdx(table.indexes[indexName]);
-			if (index.isUnique) {
-				table.uniqueConstraints[indexName] = SingleStoreSquasher.squashUnique({
-					name: index.name,
-					columns: index.columns,
-				});
-				delete json2.tables[tableName].indexes[index.name];
-			}
-		}
-	}
-
-	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
-
-	const {
-		created: createdTables,
-		deleted: deletedTables,
-		renamed: renamedTables, // renamed or moved
-	} = await tablesResolver({
-		created: tablesDiff.added,
-		deleted: tablesDiff.deleted,
-	});
-
-	const tablesPatchedSnap1 = copy(json1);
-	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
-		const { name } = nameChangeFor(it, renamedTables);
-		it.name = name;
-		return [name, it];
-	});
-
-	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
-	const columnRenames = [] as {
-		table: string;
-		renames: { from: Column; to: Column }[];
-	}[];
-
-	const columnCreates = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	const columnDeletes = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	for (let entry of Object.values(res)) {
-		const { renamed, created, deleted } = await columnsResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.columns.deleted,
-			created: entry.columns.added,
-		});
-
-		if (created.length > 0) {
-			columnCreates.push({
-				table: entry.name,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			columnDeletes.push({
-				table: entry.name,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			columnRenames.push({
-				table: entry.name,
-				renames: renamed,
-			});
-		}
-	}
-
-	const columnRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[it.table] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
-	columnsPatchedSnap1.tables = mapEntries(
-		columnsPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapKeys(
-				tableValue.columns,
-				(columnKey, column) => {
-					const rens = columnRenamesDict[tableValue.name] || [];
-					const newName = columnChangeFor(columnKey, rens);
-					column.name = newName;
-					return newName;
-				},
-			);
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	/* const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
-
-	const {
-		created: createdViews,
-		deleted: deletedViews,
-		renamed: renamedViews, // renamed or moved
-	} = await viewsResolver({
-		created: viewsDiff.added,
-		deleted: viewsDiff.deleted,
-	});
-
-	const renamesViewDic: Record<string, { to: string; from: string }> = {};
-	renamedViews.forEach((it) => {
-		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
-	});
-
-	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
-	viewsPatchedSnap1.views = mapEntries(
-		viewsPatchedSnap1.views,
-		(viewKey, viewValue) => {
-			const rename = renamesViewDic[viewValue.name];
-
-			if (rename) {
-				viewValue.name = rename.to;
-				viewKey = rename.to;
-			}
-
-			return [viewKey, viewValue];
-		},
-	);
-	*/
-	const diffResult = applyJsonDiff(columnsPatchedSnap1, json2); // replace columnsPatchedSnap1 with viewsPatchedSnap1
-
-	const typedResult: DiffResultSingleStore = diffResultSchemeSingleStore.parse(diffResult);
-
-	const jsonStatements: JsonStatement[] = [];
-
-	const jsonCreateIndexesForCreatedTables = createdTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.indexes,
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropTables = deletedTables.map((it) => {
-		return prepareDropTableJson(it);
-	});
-
-	const jsonRenameTables = renamedTables.map((it) => {
-		return prepareRenameTableJson(it.from, it.to);
-	});
-
-	const alteredTables = typedResult.alteredTablesWithColumns;
-
-	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
-
-	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
-		.map((it) => prepareRenameColumns(it.table, '', it.renames))
-		.flat();
-
-	const jsonAddColumnsStatemets: JsonAddColumnStatement[] = columnCreates
-		.map((it) => _prepareAddColumns(it.table, '', it.columns))
-		.flat();
-
-	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
-		.map((it) => _prepareDropColumns(it.table, '', it.columns))
-		.flat();
-
-	alteredTables.forEach((it) => {
-		// This part is needed to make sure that same columns in a table are not triggered for change
-		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
-		// We double-check that pk with same set of columns are both in added and deleted diffs
-		let addedColumns: string[] = [];
-		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
-			const addedPkColumns = it.addedCompositePKs[addedPkName];
-			addedColumns = SingleStoreSquasher.unsquashPK(addedPkColumns).columns;
-		}
-
-		let deletedColumns: string[] = [];
-		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
-			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
-			deletedColumns = SingleStoreSquasher.unsquashPK(deletedPkColumns).columns;
-		}
-
-		// Don't need to sort, but need to add tests for it
-		// addedColumns.sort();
-		// deletedColumns.sort();
-		const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
-
-		// add logic for unique constraints
-		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
-		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
-		deletedCheckConstraints = prepareDeleteCheckConstraint(
-			it.name,
-			it.schema,
-			it.deletedCheckConstraints,
-		);
-
-		// skip for push
-		if (it.alteredCheckConstraints && action !== 'push') {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-
-			for (const k of Object.keys(it.alteredCheckConstraints)) {
-				added[k] = it.alteredCheckConstraints[k].__new;
-				deleted[k] = it.alteredCheckConstraints[k].__old;
-			}
-			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
-			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
-		}
-
-		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
-		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
-		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
-	});
-
-	const rColumns = jsonRenameColumnsStatements.map((it) => {
-		const tableName = it.tableName;
-		const schema = it.schema;
-		return {
-			from: { schema, table: tableName, column: it.oldColumnName },
-			to: { schema, table: tableName, column: it.newColumnName },
-		};
-	});
-
-	const jsonTableAlternations = alteredTables
-		.map((it) => {
-			return prepareAlterColumnsMysql(
-				it.name,
-				it.schema,
-				it.altered,
-				json1,
-				json2,
-				action,
-			);
-		})
-		.flat();
-
-	const jsonCreateIndexesForAllAlteredTables = alteredTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.addedIndexes || {},
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropIndexesForAllAlteredTables = alteredTables
-		.map((it) => {
-			return prepareDropIndexesJson(
-				it.name,
-				it.schema,
-				it.deletedIndexes || {},
-			);
-		})
-		.flat();
-
-	alteredTables.forEach((it) => {
-		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__old;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__new;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-
-		jsonCreateIndexesForAllAlteredTables.push(
-			...prepareCreateIndexesJson(it.name, it.schema, createdIndexes || {}),
-		);
-		jsonDropIndexesForAllAlteredTables.push(
-			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
-		);
-	});
-
-	const jsonSingleStoreCreateTables = createdTables.map((it) => {
-		return prepareSingleStoreCreateTableJson(
-			it,
-			curFull as SingleStoreSchema,
-			curFull.internal,
-		);
-	});
-
-	/* const createViews: JsonCreateSingleStoreViewStatement[] = [];
-	const dropViews: JsonDropViewStatement[] = [];
-	const renameViews: JsonRenameViewStatement[] = [];
-	const alterViews: JsonAlterSingleStoreViewStatement[] = [];
-
-	createViews.push(
-		...createdViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareSingleStoreCreateViewJson(
-				it.name,
-				it.definition!,
-				it.meta,
-			);
-		}),
-	);
-
-	dropViews.push(
-		...deletedViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareDropViewJson(it.name);
-		}),
-	);
-
-	renameViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting && !json1.views[it.from.name].isExisting).map((it) => {
-			return prepareRenameViewJson(it.to.name, it.from.name);
-		}),
-	);
-
-	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
-
-	for (const alteredView of alteredViews) {
-		const { definition, meta } = json2.views[alteredView.name];
-
-		if (alteredView.alteredExisting) {
-			dropViews.push(prepareDropViewJson(alteredView.name));
-
-			createViews.push(
-				prepareSingleStoreCreateViewJson(
-					alteredView.name,
-					definition!,
-					meta,
-				),
-			);
-
-			continue;
-		}
-
-		if (alteredView.alteredDefinition && action !== 'push') {
-			createViews.push(
-				prepareSingleStoreCreateViewJson(
-					alteredView.name,
-					definition!,
-					meta,
-					true,
-				),
-			);
-			continue;
-		}
-
-		if (alteredView.alteredMeta) {
-			const view = curFull['views'][alteredView.name];
-			alterViews.push(
-				prepareSingleStoreAlterView(view),
-			);
-		}
-	} */
-
-	jsonStatements.push(...jsonSingleStoreCreateTables);
-
-	jsonStatements.push(...jsonDropTables);
-	jsonStatements.push(...jsonRenameTables);
-	jsonStatements.push(...jsonRenameColumnsStatements);
-
-	/*jsonStatements.push(...createViews);
-	jsonStatements.push(...dropViews);
-	jsonStatements.push(...renameViews);
-	jsonStatements.push(...alterViews);
- */
-	jsonStatements.push(...jsonDeletedUniqueConstraints);
-
-	// Will need to drop indexes before changing any columns in table
-	// Then should go column alternations and then index creation
-	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonTableAlternations);
-	jsonStatements.push(...jsonAddedCompositePKs);
-
-	jsonStatements.push(...jsonAddedUniqueConstraints);
-	jsonStatements.push(...jsonDeletedUniqueConstraints);
-
-	jsonStatements.push(...jsonAddColumnsStatemets);
-
-	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
-
-	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDropColumnsStatemets);
-
-	jsonStatements.push(...jsonAddedCompositePKs);
-
-	jsonStatements.push(...jsonAlteredUniqueConstraints);
-
-	const combinedJsonStatements = singleStoreCombineStatements(jsonStatements, json2);
-	const sqlStatements = fromJson(combinedJsonStatements, 'singlestore');
-
-	const uniqueSqlStatements: string[] = [];
-	sqlStatements.forEach((ss) => {
-		if (!uniqueSqlStatements.includes(ss)) {
-			uniqueSqlStatements.push(ss);
-		}
-	});
-
-	const rTables = renamedTables.map((it) => {
-		return { from: it.from, to: it.to };
-	});
-
-	const _meta = prepareMigrationMeta([], rTables, rColumns);
-
-	return {
-		statements: combinedJsonStatements,
-		sqlStatements: uniqueSqlStatements,
-		_meta,
-	};
-};
-
-export const applySqliteSnapshotsDiff = async (
-	json1: SQLiteSchemaSquashed,
-	json2: SQLiteSchemaSquashed,
-	tablesResolver: (
-		input: ResolverInput<Table>,
-	) => Promise<ResolverOutputWithMoved<Table>>,
-	columnsResolver: (
-		input: ColumnsResolverInput<Column>,
-	) => Promise<ColumnsResolverOutput<Column>>,
-	viewsResolver: (
-		input: ResolverInput<SqliteView & { schema: '' }>,
-	) => Promise<ResolverOutputWithMoved<SqliteView>>,
-	prevFull: SQLiteSchema,
-	curFull: SQLiteSchema,
-	action?: 'push' | undefined,
-): Promise<{
-	statements: JsonStatement[];
-	sqlStatements: string[];
-	_meta:
-		| {
-			schemas: {};
-			tables: {};
-			columns: {};
-		}
-		| undefined;
-}> => {
-	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
-
-	const {
-		created: createdTables,
-		deleted: deletedTables,
-		renamed: renamedTables,
-	} = await tablesResolver({
-		created: tablesDiff.added,
-		deleted: tablesDiff.deleted,
-	});
-
-	const tablesPatchedSnap1 = copy(json1);
-	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
-		const { name } = nameChangeFor(it, renamedTables);
-		it.name = name;
-		return [name, it];
-	});
-
-	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
-
-	const columnRenames = [] as {
-		table: string;
-		renames: { from: Column; to: Column }[];
-	}[];
-
-	const columnCreates = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	const columnDeletes = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	for (let entry of Object.values(res)) {
-		const { renamed, created, deleted } = await columnsResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.columns.deleted,
-			created: entry.columns.added,
-		});
-
-		if (created.length > 0) {
-			columnCreates.push({
-				table: entry.name,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			columnDeletes.push({
-				table: entry.name,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			columnRenames.push({
-				table: entry.name,
-				renames: renamed,
-			});
-		}
-	}
-
-	const columnRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[it.table] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
-	columnsPatchedSnap1.tables = mapEntries(
-		columnsPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapKeys(
-				tableValue.columns,
-				(columnKey, column) => {
-					const rens = columnRenamesDict[tableValue.name] || [];
-					const newName = columnChangeFor(columnKey, rens);
-					column.name = newName;
-					return newName;
-				},
-			);
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
-
-	const {
-		created: createdViews,
-		deleted: deletedViews,
-		renamed: renamedViews, // renamed or moved
-	} = await viewsResolver({
-		created: viewsDiff.added,
-		deleted: viewsDiff.deleted,
-	});
-
-	const renamesViewDic: Record<string, { to: string; from: string }> = {};
-	renamedViews.forEach((it) => {
-		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
-	});
-
-	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
-	viewsPatchedSnap1.views = mapEntries(
-		viewsPatchedSnap1.views,
-		(viewKey, viewValue) => {
-			const rename = renamesViewDic[viewValue.name];
-
-			if (rename) {
-				viewValue.name = rename.to;
-			}
-
-			return [viewKey, viewValue];
-		},
-	);
-
-	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
-
-	const typedResult = diffResultSchemeSQLite.parse(diffResult);
-
-	// Map array of objects to map
-	const tablesMap: {
-		[key: string]: (typeof typedResult.alteredTablesWithColumns)[number];
-	} = {};
-
-	typedResult.alteredTablesWithColumns.forEach((obj) => {
-		tablesMap[obj.name] = obj;
-	});
-
-	const jsonCreateTables = createdTables.map((it) => {
-		return prepareSQLiteCreateTable(it, action);
-	});
-
-	const jsonCreateIndexesForCreatedTables = createdTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.indexes,
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropTables = deletedTables.map((it) => {
-		return prepareDropTableJson(it);
-	});
-
-	const jsonRenameTables = renamedTables.map((it) => {
-		return prepareRenameTableJson(it.from, it.to);
-	});
-
-	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
-		.map((it) => prepareRenameColumns(it.table, '', it.renames))
-		.flat();
-
-	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
-		.map((it) => _prepareDropColumns(it.table, '', it.columns))
-		.flat();
-
-	const jsonAddColumnsStatemets: JsonSqliteAddColumnStatement[] = columnCreates
-		.map((it) => {
-			return _prepareSqliteAddColumns(
-				it.table,
-				it.columns,
-				tablesMap[it.table] && tablesMap[it.table].addedForeignKeys
-					? Object.values(tablesMap[it.table].addedForeignKeys)
-					: [],
-			);
-		})
-		.flat();
-
-	const allAltered = typedResult.alteredTablesWithColumns;
-
-	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
-	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
-	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
-
-	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
-
-	allAltered.forEach((it) => {
-		// This part is needed to make sure that same columns in a table are not triggered for change
-		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
-		// We double-check that pk with same set of columns are both in added and deleted diffs
-		let addedColumns: string[] = [];
-		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
-			const addedPkColumns = it.addedCompositePKs[addedPkName];
-			addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
-		}
-
-		let deletedColumns: string[] = [];
-		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
-			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
-			deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
-		}
-
-		// Don't need to sort, but need to add tests for it
-		// addedColumns.sort();
-		// deletedColumns.sort();
-
-		const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
-
-		let addedCompositePKs: JsonCreateCompositePK[] = [];
-		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
-		let alteredCompositePKs: JsonAlterCompositePK[] = [];
-		if (doPerformDeleteAndCreate) {
-			addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
-				it.name,
-				it.addedCompositePKs,
-			);
-			deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
-				it.name,
-				it.deletedCompositePKs,
-			);
-		}
-		alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
-			it.name,
-			it.alteredCompositePKs,
-		);
-
-		// add logic for unique constraints
-		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
-		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
-		deletedCheckConstraints = prepareDeleteCheckConstraint(
-			it.name,
-			it.schema,
-			it.deletedCheckConstraints,
-		);
-
-		// skip for push
-		if (it.alteredCheckConstraints && action !== 'push') {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-
-			for (const k of Object.keys(it.alteredCheckConstraints)) {
-				added[k] = it.alteredCheckConstraints[k].__new;
-				deleted[k] = it.alteredCheckConstraints[k].__old;
-			}
-			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
-			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
-		}
-
-		jsonAddedCompositePKs.push(...addedCompositePKs);
-		jsonDeletedCompositePKs.push(...deletedCompositePKs);
-		jsonAlteredCompositePKs.push(...alteredCompositePKs);
-
-		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
-		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
-		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
-
-		jsonCreatedCheckConstraints.push(...createdCheckConstraints);
-		jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
-	});
-
-	const rColumns = jsonRenameColumnsStatements.map((it) => {
-		const tableName = it.tableName;
-		const schema = it.schema;
-		return {
-			from: { schema, table: tableName, column: it.oldColumnName },
-			to: { schema, table: tableName, column: it.newColumnName },
-		};
-	});
-
-	const jsonTableAlternations = allAltered
-		.map((it) => {
-			return prepareSqliteAlterColumns(it.name, it.schema, it.altered, json2);
-		})
-		.flat();
-
-	const jsonCreateIndexesForAllAlteredTables = allAltered
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.addedIndexes || {},
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropIndexesForAllAlteredTables = allAltered
-		.map((it) => {
-			return prepareDropIndexesJson(
-				it.name,
-				it.schema,
-				it.deletedIndexes || {},
-			);
-		})
-		.flat();
-
-	allAltered.forEach((it) => {
-		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__old;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__new;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-
-		jsonCreateIndexesForAllAlteredTables.push(
-			...prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				createdIndexes || {},
-				curFull.internal,
-			),
-		);
-		jsonDropIndexesForAllAlteredTables.push(
-			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
-		);
-	});
-
-	const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = allAltered
-		.map((it) => {
-			const forAdded = prepareCreateReferencesJson(
-				it.name,
-				it.schema,
-				it.addedForeignKeys,
-			);
-
-			const forAltered = prepareDropReferencesJson(
-				it.name,
-				it.schema,
-				it.deletedForeignKeys,
-			);
-
-			const alteredFKs = prepareAlterReferencesJson(
-				it.name,
-				it.schema,
-				it.alteredForeignKeys,
-			);
-
-			return [...forAdded, ...forAltered, ...alteredFKs];
-		})
-		.flat();
-
-	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'create_reference',
-	);
-	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'delete_reference',
-	);
-
-	const createViews: JsonCreateSqliteViewStatement[] = [];
-	const dropViews: JsonDropViewStatement[] = [];
-
-	createViews.push(
-		...createdViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareSqliteCreateViewJson(
-				it.name,
-				it.definition!,
-			);
-		}),
-	);
-
-	dropViews.push(
-		...deletedViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareDropViewJson(it.name);
-		}),
-	);
-
-	dropViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
-			return prepareDropViewJson(it.from.name);
-		}),
-	);
-	createViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
-			return prepareSqliteCreateViewJson(it.to.name, it.to.definition!);
-		}),
-	);
-
-	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
-
-	for (const alteredView of alteredViews) {
-		const { definition } = json2.views[alteredView.name];
-
-		if (alteredView.alteredExisting || (alteredView.alteredDefinition && action !== 'push')) {
-			dropViews.push(prepareDropViewJson(alteredView.name));
-
-			createViews.push(
-				prepareSqliteCreateViewJson(
-					alteredView.name,
-					definition!,
-				),
-			);
-		}
-	}
-
-	const jsonStatements: JsonStatement[] = [];
-	jsonStatements.push(...jsonCreateTables);
-
-	jsonStatements.push(...jsonDropTables);
-	jsonStatements.push(...jsonRenameTables);
-	jsonStatements.push(...jsonRenameColumnsStatements);
-
-	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
-	jsonStatements.push(...jsonDeletedCheckConstraints);
-
-	// Will need to drop indexes before changing any columns in table
-	// Then should go column alternations and then index creation
-	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDeletedCompositePKs);
-	jsonStatements.push(...jsonTableAlternations);
-	jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAddColumnsStatemets);
-
-	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
-	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonCreatedCheckConstraints);
-
-	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
-
-	jsonStatements.push(...jsonDropColumnsStatemets);
-
-	// jsonStatements.push(...jsonDeletedCompositePKs);
-	// jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAlteredCompositePKs);
-
-	jsonStatements.push(...jsonAlteredUniqueConstraints);
-
-	jsonStatements.push(...dropViews);
-	jsonStatements.push(...createViews);
-
-	const combinedJsonStatements = sqliteCombineStatements(jsonStatements, json2, action);
-	const sqlStatements = fromJson(combinedJsonStatements, 'sqlite');
-
-	const uniqueSqlStatements: string[] = [];
-	sqlStatements.forEach((ss) => {
-		if (!uniqueSqlStatements.includes(ss)) {
-			uniqueSqlStatements.push(ss);
-		}
-	});
-
-	const rTables = renamedTables.map((it) => {
-		return { from: it.from, to: it.to };
-	});
-
-	const _meta = prepareMigrationMeta([], rTables, rColumns);
-
-	return {
-		statements: combinedJsonStatements,
-		sqlStatements: uniqueSqlStatements,
-		_meta,
-	};
-};
-
-export const applyLibSQLSnapshotsDiff = async (
-	json1: SQLiteSchemaSquashed,
-	json2: SQLiteSchemaSquashed,
-	tablesResolver: (
-		input: ResolverInput<Table>,
-	) => Promise<ResolverOutputWithMoved<Table>>,
-	columnsResolver: (
-		input: ColumnsResolverInput<Column>,
-	) => Promise<ColumnsResolverOutput<Column>>,
-	viewsResolver: (
-		input: ResolverInput<SqliteView & { schema: '' }>,
-	) => Promise<ResolverOutputWithMoved<SqliteView>>,
-	prevFull: SQLiteSchema,
-	curFull: SQLiteSchema,
-	action?: 'push',
-): Promise<{
-	statements: JsonStatement[];
-	sqlStatements: string[];
-	_meta:
-		| {
-			schemas: {};
-			tables: {};
-			columns: {};
-		}
-		| undefined;
-}> => {
-	const tablesDiff = diffSchemasOrTables(json1.tables, json2.tables);
-	const {
-		created: createdTables,
-		deleted: deletedTables,
-		renamed: renamedTables,
-	} = await tablesResolver({
-		created: tablesDiff.added,
-		deleted: tablesDiff.deleted,
-	});
-
-	const tablesPatchedSnap1 = copy(json1);
-	tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_, it) => {
-		const { name } = nameChangeFor(it, renamedTables);
-		it.name = name;
-		return [name, it];
-	});
-
-	const res = diffColumns(tablesPatchedSnap1.tables, json2.tables);
-
-	const columnRenames = [] as {
-		table: string;
-		renames: { from: Column; to: Column }[];
-	}[];
-
-	const columnCreates = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	const columnDeletes = [] as {
-		table: string;
-		columns: Column[];
-	}[];
-
-	for (let entry of Object.values(res)) {
-		const { renamed, created, deleted } = await columnsResolver({
-			tableName: entry.name,
-			schema: entry.schema,
-			deleted: entry.columns.deleted,
-			created: entry.columns.added,
-		});
-
-		if (created.length > 0) {
-			columnCreates.push({
-				table: entry.name,
-				columns: created,
-			});
-		}
-
-		if (deleted.length > 0) {
-			columnDeletes.push({
-				table: entry.name,
-				columns: deleted,
-			});
-		}
-
-		if (renamed.length > 0) {
-			columnRenames.push({
-				table: entry.name,
-				renames: renamed,
-			});
-		}
-	}
-
-	const columnRenamesDict = columnRenames.reduce(
-		(acc, it) => {
-			acc[it.table] = it.renames;
-			return acc;
-		},
-		{} as Record<
-			string,
-			{
-				from: Named;
-				to: Named;
-			}[]
-		>,
-	);
-
-	const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
-	columnsPatchedSnap1.tables = mapEntries(
-		columnsPatchedSnap1.tables,
-		(tableKey, tableValue) => {
-			const patchedColumns = mapKeys(
-				tableValue.columns,
-				(columnKey, column) => {
-					const rens = columnRenamesDict[tableValue.name] || [];
-					const newName = columnChangeFor(columnKey, rens);
-					column.name = newName;
-					return newName;
-				},
-			);
-
-			tableValue.columns = patchedColumns;
-			return [tableKey, tableValue];
-		},
-	);
-
-	const viewsDiff = diffSchemasOrTables(json1.views, json2.views);
-
-	const {
-		created: createdViews,
-		deleted: deletedViews,
-		renamed: renamedViews, // renamed or moved
-	} = await viewsResolver({
-		created: viewsDiff.added,
-		deleted: viewsDiff.deleted,
-	});
-
-	const renamesViewDic: Record<string, { to: string; from: string }> = {};
-	renamedViews.forEach((it) => {
-		renamesViewDic[it.from.name] = { to: it.to.name, from: it.from.name };
-	});
-
-	const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
-	viewsPatchedSnap1.views = mapEntries(
-		viewsPatchedSnap1.views,
-		(viewKey, viewValue) => {
-			const rename = renamesViewDic[viewValue.name];
-
-			if (rename) {
-				viewValue.name = rename.to;
-			}
-
-			return [viewKey, viewValue];
-		},
-	);
-
-	const diffResult = applyJsonDiff(viewsPatchedSnap1, json2);
-
-	const typedResult = diffResultSchemeSQLite.parse(diffResult);
-
-	// Map array of objects to map
-	const tablesMap: {
-		[key: string]: (typeof typedResult.alteredTablesWithColumns)[number];
-	} = {};
-
-	typedResult.alteredTablesWithColumns.forEach((obj) => {
-		tablesMap[obj.name] = obj;
-	});
-
-	const jsonCreateTables = createdTables.map((it) => {
-		return prepareSQLiteCreateTable(it, action);
-	});
-
-	const jsonCreateIndexesForCreatedTables = createdTables
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.indexes,
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropTables = deletedTables.map((it) => {
-		return prepareDropTableJson(it);
-	});
-
-	const jsonRenameTables = renamedTables.map((it) => {
-		return prepareRenameTableJson(it.from, it.to);
-	});
-
-	const jsonRenameColumnsStatements: JsonRenameColumnStatement[] = columnRenames
-		.map((it) => prepareRenameColumns(it.table, '', it.renames))
-		.flat();
-
-	const jsonDropColumnsStatemets: JsonDropColumnStatement[] = columnDeletes
-		.map((it) => _prepareDropColumns(it.table, '', it.columns))
-		.flat();
-
-	const jsonAddColumnsStatemets: JsonSqliteAddColumnStatement[] = columnCreates
-		.map((it) => {
-			return _prepareSqliteAddColumns(
-				it.table,
-				it.columns,
-				tablesMap[it.table] && tablesMap[it.table].addedForeignKeys
-					? Object.values(tablesMap[it.table].addedForeignKeys)
-					: [],
-			);
-		})
-		.flat();
-
-	const rColumns = jsonRenameColumnsStatements.map((it) => {
-		const tableName = it.tableName;
-		const schema = it.schema;
-		return {
-			from: { schema, table: tableName, column: it.oldColumnName },
-			to: { schema, table: tableName, column: it.newColumnName },
-		};
-	});
-
-	const rTables = renamedTables.map((it) => {
-		return { from: it.from, to: it.to };
-	});
-
-	const _meta = prepareMigrationMeta([], rTables, rColumns);
-
-	const allAltered = typedResult.alteredTablesWithColumns;
-
-	const jsonAddedCompositePKs: JsonCreateCompositePK[] = [];
-	const jsonDeletedCompositePKs: JsonDeleteCompositePK[] = [];
-	const jsonAlteredCompositePKs: JsonAlterCompositePK[] = [];
-
-	const jsonAddedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-	const jsonDeletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-	const jsonAlteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-	const jsonDeletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-	const jsonCreatedCheckConstraints: JsonCreateCheckConstraint[] = [];
-
-	allAltered.forEach((it) => {
-		// This part is needed to make sure that same columns in a table are not triggered for change
-		// there is a case where orm and kit are responsible for pk name generation and one of them is not sorting name
-		// We double-check that pk with same set of columns are both in added and deleted diffs
-		let addedColumns: string[] = [];
-		for (const addedPkName of Object.keys(it.addedCompositePKs)) {
-			const addedPkColumns = it.addedCompositePKs[addedPkName];
-			addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
-		}
-
-		let deletedColumns: string[] = [];
-		for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
-			const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
-			deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
-		}
-
-		// Don't need to sort, but need to add tests for it
-		// addedColumns.sort();
-		// deletedColumns.sort();
-
-		const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
-
-		let addedCompositePKs: JsonCreateCompositePK[] = [];
-		let deletedCompositePKs: JsonDeleteCompositePK[] = [];
-		let alteredCompositePKs: JsonAlterCompositePK[] = [];
-		if (doPerformDeleteAndCreate) {
-			addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
-				it.name,
-				it.addedCompositePKs,
-			);
-			deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
-				it.name,
-				it.deletedCompositePKs,
-			);
-		}
-		alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
-			it.name,
-			it.alteredCompositePKs,
-		);
-
-		// add logic for unique constraints
-		let addedUniqueConstraints: JsonCreateUniqueConstraint[] = [];
-		let deletedUniqueConstraints: JsonDeleteUniqueConstraint[] = [];
-		let alteredUniqueConstraints: JsonAlterUniqueConstraint[] = [];
-
-		let createdCheckConstraints: JsonCreateCheckConstraint[] = [];
-		let deletedCheckConstraints: JsonDeleteCheckConstraint[] = [];
-
-		addedUniqueConstraints = prepareAddUniqueConstraint(
-			it.name,
-			it.schema,
-			it.addedUniqueConstraints,
-		);
-
-		deletedUniqueConstraints = prepareDeleteUniqueConstraint(
-			it.name,
-			it.schema,
-			it.deletedUniqueConstraints,
-		);
-		if (it.alteredUniqueConstraints) {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-			for (const k of Object.keys(it.alteredUniqueConstraints)) {
-				added[k] = it.alteredUniqueConstraints[k].__new;
-				deleted[k] = it.alteredUniqueConstraints[k].__old;
-			}
-			addedUniqueConstraints.push(
-				...prepareAddUniqueConstraint(it.name, it.schema, added),
-			);
-			deletedUniqueConstraints.push(
-				...prepareDeleteUniqueConstraint(it.name, it.schema, deleted),
-			);
-		}
-
-		createdCheckConstraints = prepareAddCheckConstraint(it.name, it.schema, it.addedCheckConstraints);
-		deletedCheckConstraints = prepareDeleteCheckConstraint(
-			it.name,
-			it.schema,
-			it.deletedCheckConstraints,
-		);
-
-		// skip for push
-		if (it.alteredCheckConstraints && action !== 'push') {
-			const added: Record<string, string> = {};
-			const deleted: Record<string, string> = {};
-
-			for (const k of Object.keys(it.alteredCheckConstraints)) {
-				added[k] = it.alteredCheckConstraints[k].__new;
-				deleted[k] = it.alteredCheckConstraints[k].__old;
-			}
-			createdCheckConstraints.push(...prepareAddCheckConstraint(it.name, it.schema, added));
-			deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it.name, it.schema, deleted));
-		}
-
-		jsonAddedCompositePKs.push(...addedCompositePKs);
-		jsonDeletedCompositePKs.push(...deletedCompositePKs);
-		jsonAlteredCompositePKs.push(...alteredCompositePKs);
-
-		jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
-		jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
-		jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
-
-		jsonCreatedCheckConstraints.push(...createdCheckConstraints);
-		jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
-	});
-
-	const jsonTableAlternations = allAltered
-		.map((it) => {
-			return prepareSqliteAlterColumns(it.name, it.schema, it.altered, json2);
-		})
-		.flat();
-
-	const jsonCreateIndexesForAllAlteredTables = allAltered
-		.map((it) => {
-			return prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				it.addedIndexes || {},
-				curFull.internal,
-			);
-		})
-		.flat();
-
-	const jsonDropIndexesForAllAlteredTables = allAltered
-		.map((it) => {
-			return prepareDropIndexesJson(
-				it.name,
-				it.schema,
-				it.deletedIndexes || {},
-			);
-		})
-		.flat();
-
-	allAltered.forEach((it) => {
-		const droppedIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__old;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-		const createdIndexes = Object.keys(it.alteredIndexes).reduce(
-			(current, item: string) => {
-				current[item] = it.alteredIndexes[item].__new;
-				return current;
-			},
-			{} as Record<string, string>,
-		);
-
-		jsonCreateIndexesForAllAlteredTables.push(
-			...prepareCreateIndexesJson(
-				it.name,
-				it.schema,
-				createdIndexes || {},
-				curFull.internal,
-			),
-		);
-		jsonDropIndexesForAllAlteredTables.push(
-			...prepareDropIndexesJson(it.name, it.schema, droppedIndexes || {}),
-		);
-	});
-
-	const jsonReferencesForAllAlteredTables: JsonReferenceStatement[] = allAltered
-		.map((it) => {
-			const forAdded = prepareLibSQLCreateReferencesJson(
-				it.name,
-				it.schema,
-				it.addedForeignKeys,
-				json2,
-				action,
-			);
-
-			const forAltered = prepareLibSQLDropReferencesJson(
-				it.name,
-				it.schema,
-				it.deletedForeignKeys,
-				json2,
-				_meta,
-				action,
-			);
-
-			const alteredFKs = prepareAlterReferencesJson(it.name, it.schema, it.alteredForeignKeys);
-
-			return [...forAdded, ...forAltered, ...alteredFKs];
-		})
-		.flat();
-
-	const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'create_reference',
-	);
-	const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
-		(t) => t.type === 'delete_reference',
-	);
-
-	const createViews: JsonCreateSqliteViewStatement[] = [];
-	const dropViews: JsonDropViewStatement[] = [];
-
-	createViews.push(
-		...createdViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareSqliteCreateViewJson(
-				it.name,
-				it.definition!,
-			);
-		}),
-	);
-
-	dropViews.push(
-		...deletedViews.filter((it) => !it.isExisting).map((it) => {
-			return prepareDropViewJson(it.name);
-		}),
-	);
-
-	// renames
-	dropViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
-			return prepareDropViewJson(it.from.name);
-		}),
-	);
-	createViews.push(
-		...renamedViews.filter((it) => !it.to.isExisting).map((it) => {
-			return prepareSqliteCreateViewJson(it.to.name, it.to.definition!);
-		}),
-	);
-
-	const alteredViews = typedResult.alteredViews.filter((it) => !json2.views[it.name].isExisting);
-
-	for (const alteredView of alteredViews) {
-		const { definition } = json2.views[alteredView.name];
-
-		if (alteredView.alteredExisting || (alteredView.alteredDefinition && action !== 'push')) {
-			dropViews.push(prepareDropViewJson(alteredView.name));
-
-			createViews.push(
-				prepareSqliteCreateViewJson(
-					alteredView.name,
-					definition!,
-				),
-			);
-		}
-	}
-
-	const jsonStatements: JsonStatement[] = [];
-	jsonStatements.push(...jsonCreateTables);
-
-	jsonStatements.push(...jsonDropTables);
-	jsonStatements.push(...jsonRenameTables);
-	jsonStatements.push(...jsonRenameColumnsStatements);
-
-	jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
-
-	jsonStatements.push(...jsonDeletedCheckConstraints);
-
-	// Will need to drop indexes before changing any columns in table
-	// Then should go column alternations and then index creation
-	jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
-
-	jsonStatements.push(...jsonDeletedCompositePKs);
-	jsonStatements.push(...jsonTableAlternations);
-	jsonStatements.push(...jsonAddedCompositePKs);
-	jsonStatements.push(...jsonAddColumnsStatemets);
-
-	jsonStatements.push(...jsonCreateIndexesForCreatedTables);
-	jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
-	jsonStatements.push(...jsonCreatedCheckConstraints);
-
-	jsonStatements.push(...dropViews);
-	jsonStatements.push(...createViews);
-
-	jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
-
-	jsonStatements.push(...jsonDropColumnsStatemets);
-
-	jsonStatements.push(...jsonAlteredCompositePKs);
-
-	jsonStatements.push(...jsonAlteredUniqueConstraints);
-
-	const combinedJsonStatements = libSQLCombineStatements(jsonStatements, json2, action);
-
-	const sqlStatements = fromJson(
-		combinedJsonStatements,
-		'turso',
-		action,
-		json2,
-	);
-
-	const uniqueSqlStatements: string[] = [];
-	sqlStatements.forEach((ss) => {
-		if (!uniqueSqlStatements.includes(ss)) {
-			uniqueSqlStatements.push(ss);
-		}
-	});
-
-	return {
-		statements: combinedJsonStatements,
-		sqlStatements: uniqueSqlStatements,
-		_meta,
-	};
-};
-
-// explicitely ask if tables were renamed, if yes - add those to altered tables, otherwise - deleted
-// double check if user wants to delete particular table and warn him on data loss
diff --git a/drizzle-kit/src/sqlgenerator.ts b/drizzle-kit/src/sqlgenerator.ts
deleted file mode 100644
index 3b88cde67a..0000000000
--- a/drizzle-kit/src/sqlgenerator.ts
+++ /dev/null
@@ -1,4167 +0,0 @@
-import { BREAKPOINT } from './cli/commands/migrate';
-import {
-	JsonAddColumnStatement,
-	JsonAddValueToEnumStatement,
-	JsonAlterColumnAlterGeneratedStatement,
-	JsonAlterColumnAlterIdentityStatement,
-	JsonAlterColumnDropAutoincrementStatement,
-	JsonAlterColumnDropDefaultStatement,
-	JsonAlterColumnDropGeneratedStatement,
-	JsonAlterColumnDropIdentityStatement,
-	JsonAlterColumnDropNotNullStatement,
-	JsonAlterColumnDropOnUpdateStatement,
-	JsonAlterColumnDropPrimaryKeyStatement,
-	JsonAlterColumnPgTypeStatement,
-	JsonAlterColumnSetAutoincrementStatement,
-	JsonAlterColumnSetDefaultStatement,
-	JsonAlterColumnSetGeneratedStatement,
-	JsonAlterColumnSetIdentityStatement,
-	JsonAlterColumnSetNotNullStatement,
-	JsonAlterColumnSetOnUpdateStatement,
-	JsonAlterColumnSetPrimaryKeyStatement,
-	JsonAlterColumnTypeStatement,
-	JsonAlterCompositePK,
-	JsonAlterIndPolicyStatement,
-	JsonAlterMySqlViewStatement,
-	JsonAlterPolicyStatement,
-	JsonAlterReferenceStatement,
-	JsonAlterRoleStatement,
-	JsonAlterSequenceStatement,
-	JsonAlterTableRemoveFromSchema,
-	JsonAlterTableSetNewSchema,
-	JsonAlterTableSetSchema,
-	JsonAlterViewAddWithOptionStatement,
-	JsonAlterViewAlterSchemaStatement,
-	JsonAlterViewAlterTablespaceStatement,
-	JsonAlterViewAlterUsingStatement,
-	JsonAlterViewDropWithOptionStatement,
-	JsonCreateCheckConstraint,
-	JsonCreateCompositePK,
-	JsonCreateEnumStatement,
-	JsonCreateIndexStatement,
-	JsonCreateIndPolicyStatement,
-	JsonCreateMySqlViewStatement,
-	JsonCreatePgViewStatement,
-	JsonCreatePolicyStatement,
-	JsonCreateReferenceStatement,
-	JsonCreateRoleStatement,
-	JsonCreateSchema,
-	JsonCreateSequenceStatement,
-	JsonCreateSqliteViewStatement,
-	JsonCreateTableStatement,
-	JsonCreateUniqueConstraint,
-	JsonDeleteCheckConstraint,
-	JsonDeleteCompositePK,
-	JsonDeleteReferenceStatement,
-	JsonDeleteUniqueConstraint,
-	JsonDisableRLSStatement,
-	JsonDropColumnStatement,
-	JsonDropEnumStatement,
-	JsonDropIndexStatement,
-	JsonDropIndPolicyStatement,
-	JsonDropPolicyStatement,
-	JsonDropRoleStatement,
-	JsonDropSequenceStatement,
-	JsonDropTableStatement,
-	JsonDropValueFromEnumStatement,
-	JsonDropViewStatement,
-	JsonEnableRLSStatement,
-	JsonIndRenamePolicyStatement,
-	JsonMoveEnumStatement,
-	JsonMoveSequenceStatement,
-	JsonPgCreateIndexStatement,
-	JsonRecreateSingleStoreTableStatement,
-	JsonRecreateTableStatement,
-	JsonRenameColumnStatement,
-	JsonRenameEnumStatement,
-	JsonRenamePolicyStatement,
-	JsonRenameRoleStatement,
-	JsonRenameSchema,
-	JsonRenameSequenceStatement,
-	JsonRenameTableStatement,
-	JsonRenameViewStatement,
-	JsonSqliteAddColumnStatement,
-	JsonSqliteCreateTableStatement,
-	JsonStatement,
-} from './jsonStatements';
-import { Dialect } from './schemaValidator';
-import { MySqlSquasher } from './serializer/mysqlSchema';
-import { PgSquasher, policy } from './serializer/pgSchema';
-import { SingleStoreSquasher } from './serializer/singlestoreSchema';
-import { SQLiteSchemaSquashed, SQLiteSquasher } from './serializer/sqliteSchema';
-
-import { escapeSingleQuotes } from './utils';
-
-const parseType = (schemaPrefix: string, type: string) => {
-	const pgNativeTypes = [
-		'uuid',
-		'smallint',
-		'integer',
-		'bigint',
-		'boolean',
-		'text',
-		'varchar',
-		'serial',
-		'bigserial',
-		'decimal',
-		'numeric',
-		'real',
-		'json',
-		'jsonb',
-		'time',
-		'time with time zone',
-		'time without time zone',
-		'time',
-		'timestamp',
-		'timestamp with time zone',
-		'timestamp without time zone',
-		'date',
-		'interval',
-		'bigint',
-		'bigserial',
-		'double precision',
-		'interval year',
-		'interval month',
-		'interval day',
-		'interval hour',
-		'interval minute',
-		'interval second',
-		'interval year to month',
-		'interval day to hour',
-		'interval day to minute',
-		'interval day to second',
-		'interval hour to minute',
-		'interval hour to second',
-		'interval minute to second',
-		'char',
-		'vector',
-		'geometry',
-	];
-	const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
-	const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join('');
-	const withoutArrayDefinition = type.replace(arrayDefinitionRegex, '');
-	return pgNativeTypes.some((it) => type.startsWith(it))
-		? `${withoutArrayDefinition}${arrayDefinition}`
-		: `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
-};
-
-abstract class Convertor {
-	abstract can(
-		statement: JsonStatement,
-		dialect: Dialect,
-	): boolean;
-	abstract convert(
-		statement: JsonStatement,
-		json2?: SQLiteSchemaSquashed,
-		action?: 'push',
-	): string | string[];
-}
-
-class PgCreateRoleConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_role' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonCreateRoleStatement): string | string[] {
-		return `CREATE ROLE "${statement.name}"${
-			statement.values.createDb || statement.values.createRole || !statement.values.inherit
-				? ` WITH${statement.values.createDb ? ' CREATEDB' : ''}${statement.values.createRole ? ' CREATEROLE' : ''}${
-					statement.values.inherit ? '' : ' NOINHERIT'
-				}`
-				: ''
-		};`;
-	}
-}
-
-class PgDropRoleConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_role' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonDropRoleStatement): string | string[] {
-		return `DROP ROLE "${statement.name}";`;
-	}
-}
-
-class PgRenameRoleConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_role' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonRenameRoleStatement): string | string[] {
-		return `ALTER ROLE "${statement.nameFrom}" RENAME TO "${statement.nameTo}";`;
-	}
-}
-
-class PgAlterRoleConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_role' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonAlterRoleStatement): string | string[] {
-		return `ALTER ROLE "${statement.name}"${` WITH${statement.values.createDb ? ' CREATEDB' : ' NOCREATEDB'}${
-			statement.values.createRole ? ' CREATEROLE' : ' NOCREATEROLE'
-		}${statement.values.inherit ? ' INHERIT' : ' NOINHERIT'}`};`;
-	}
-}
-
-/////
-
-class PgCreatePolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonCreatePolicyStatement): string | string[] {
-		const policy = statement.data;
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		const usingPart = policy.using ? ` USING (${policy.using})` : '';
-
-		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
-
-		const policyToPart = policy.to?.map((v) =>
-			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
-		).join(', ');
-
-		return `CREATE POLICY "${policy.name}" ON ${tableNameWithSchema} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
-	}
-}
-
-class PgDropPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonDropPolicyStatement): string | string[] {
-		const policy = statement.data;
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `DROP POLICY "${policy.name}" ON ${tableNameWithSchema} CASCADE;`;
-	}
-}
-
-class PgRenamePolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonRenamePolicyStatement): string | string[] {
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER POLICY "${statement.oldName}" ON ${tableNameWithSchema} RENAME TO "${statement.newName}";`;
-	}
-}
-
-class PgAlterPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonAlterPolicyStatement, _dialect: any, action?: string): string | string[] {
-		const newPolicy = action === 'push'
-			? PgSquasher.unsquashPolicyPush(statement.newData)
-			: PgSquasher.unsquashPolicy(statement.newData);
-		const oldPolicy = action === 'push'
-			? PgSquasher.unsquashPolicyPush(statement.oldData)
-			: PgSquasher.unsquashPolicy(statement.oldData);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		const usingPart = newPolicy.using
-			? ` USING (${newPolicy.using})`
-			: oldPolicy.using
-			? ` USING (${oldPolicy.using})`
-			: '';
-
-		const withCheckPart = newPolicy.withCheck
-			? ` WITH CHECK (${newPolicy.withCheck})`
-			: oldPolicy.withCheck
-			? ` WITH CHECK  (${oldPolicy.withCheck})`
-			: '';
-
-		return `ALTER POLICY "${oldPolicy.name}" ON ${tableNameWithSchema} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
-	}
-}
-
-////
-
-class PgCreateIndPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_ind_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonCreateIndPolicyStatement): string | string[] {
-		const policy = statement.data;
-
-		const usingPart = policy.using ? ` USING (${policy.using})` : '';
-
-		const withCheckPart = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : '';
-
-		const policyToPart = policy.to?.map((v) =>
-			['current_user', 'current_role', 'session_user', 'public'].includes(v) ? v : `"${v}"`
-		).join(', ');
-
-		return `CREATE POLICY "${policy.name}" ON ${policy.on} AS ${policy.as?.toUpperCase()} FOR ${policy.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
-	}
-}
-
-class PgDropIndPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_ind_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonDropIndPolicyStatement): string | string[] {
-		const policy = statement.data;
-
-		return `DROP POLICY "${policy.name}" ON ${policy.on} CASCADE;`;
-	}
-}
-
-class PgRenameIndPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_ind_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonIndRenamePolicyStatement): string | string[] {
-		return `ALTER POLICY "${statement.oldName}" ON ${statement.tableKey} RENAME TO "${statement.newName}";`;
-	}
-}
-
-class PgAlterIndPolicyConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_ind_policy' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonAlterIndPolicyStatement): string | string[] {
-		const newPolicy = statement.newData;
-		const oldPolicy = statement.oldData;
-
-		const usingPart = newPolicy.using
-			? ` USING (${newPolicy.using})`
-			: oldPolicy.using
-			? ` USING (${oldPolicy.using})`
-			: '';
-
-		const withCheckPart = newPolicy.withCheck
-			? ` WITH CHECK (${newPolicy.withCheck})`
-			: oldPolicy.withCheck
-			? ` WITH CHECK  (${oldPolicy.withCheck})`
-			: '';
-
-		return `ALTER POLICY "${oldPolicy.name}" ON ${oldPolicy.on} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
-	}
-}
-
-////
-
-class PgEnableRlsConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'enable_rls' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonEnableRLSStatement): string {
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ENABLE ROW LEVEL SECURITY;`;
-	}
-}
-
-class PgDisableRlsConvertor extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'disable_rls' && dialect === 'postgresql';
-	}
-	override convert(statement: JsonDisableRLSStatement): string {
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DISABLE ROW LEVEL SECURITY;`;
-	}
-}
-
-class PgCreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_table' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonCreateTableStatement) {
-		const { tableName, schema, columns, compositePKs, uniqueConstraints, checkConstraints, policies, isRLSEnabled } =
-			st;
-
-		let statement = '';
-		const name = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
-
-		statement += `CREATE TABLE ${name} (\n`;
-		for (let i = 0; i < columns.length; i++) {
-			const column = columns[i];
-
-			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
-			const notNullStatement = column.notNull && !column.identity ? ' NOT NULL' : '';
-			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
-
-			const uniqueConstraint = column.isUnique
-				? ` CONSTRAINT "${column.uniqueName}" UNIQUE${column.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''}`
-				: '';
-
-			const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
-				? `"${column.typeSchema}".`
-				: '';
-
-			const type = parseType(schemaPrefix, column.type);
-			const generated = column.generated;
-
-			const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
-
-			const unsquashedIdentity = column.identity
-				? PgSquasher.unsquashIdentity(column.identity)
-				: undefined;
-
-			const identityWithSchema = schema
-				? `"${schema}"."${unsquashedIdentity?.name}"`
-				: `"${unsquashedIdentity?.name}"`;
-
-			const identity = unsquashedIdentity
-				? ` GENERATED ${
-					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
-				} AS IDENTITY (sequence name ${identityWithSchema}${
-					unsquashedIdentity.increment
-						? ` INCREMENT BY ${unsquashedIdentity.increment}`
-						: ''
-				}${
-					unsquashedIdentity.minValue
-						? ` MINVALUE ${unsquashedIdentity.minValue}`
-						: ''
-				}${
-					unsquashedIdentity.maxValue
-						? ` MAXVALUE ${unsquashedIdentity.maxValue}`
-						: ''
-				}${
-					unsquashedIdentity.startWith
-						? ` START WITH ${unsquashedIdentity.startWith}`
-						: ''
-				}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
-					unsquashedIdentity.cycle ? ` CYCLE` : ''
-				})`
-				: '';
-
-			statement += '\t'
-				+ `"${column.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${uniqueConstraint}${identity}`;
-			statement += i === columns.length - 1 ? '' : ',\n';
-		}
-
-		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
-			statement += ',\n';
-			const compositePK = PgSquasher.unsquashPK(compositePKs[0]);
-			statement += `\tCONSTRAINT "${st.compositePkName}" PRIMARY KEY(\"${compositePK.columns.join(`","`)}\")`;
-			// statement += `\n`;
-		}
-
-		if (
-			typeof uniqueConstraints !== 'undefined'
-			&& uniqueConstraints.length > 0
-		) {
-			for (const uniqueConstraint of uniqueConstraints) {
-				statement += ',\n';
-				const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint);
-				statement += `\tCONSTRAINT "${unsquashedUnique.name}" UNIQUE${
-					unsquashedUnique.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
-				}(\"${unsquashedUnique.columns.join(`","`)}\")`;
-				// statement += `\n`;
-			}
-		}
-
-		if (typeof checkConstraints !== 'undefined' && checkConstraints.length > 0) {
-			for (const checkConstraint of checkConstraints) {
-				statement += ',\n';
-				const unsquashedCheck = PgSquasher.unsquashCheck(checkConstraint);
-				statement += `\tCONSTRAINT "${unsquashedCheck.name}" CHECK (${unsquashedCheck.value})`;
-			}
-		}
-
-		statement += `\n);`;
-		statement += `\n`;
-
-		const enableRls = new PgEnableRlsConvertor().convert({
-			type: 'enable_rls',
-			tableName,
-			schema,
-		});
-
-		return [statement, ...(policies && policies.length > 0 || isRLSEnabled ? [enableRls] : [])];
-	}
-}
-
-class MySqlCreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_table' && dialect === 'mysql';
-	}
-
-	convert(st: JsonCreateTableStatement) {
-		const {
-			tableName,
-			columns,
-			schema,
-			checkConstraints,
-			compositePKs,
-			uniqueConstraints,
-			internals,
-		} = st;
-
-		let statement = '';
-		statement += `CREATE TABLE \`${tableName}\` (\n`;
-		for (let i = 0; i < columns.length; i++) {
-			const column = columns[i];
-
-			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
-			const notNullStatement = column.notNull ? ' NOT NULL' : '';
-			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
-
-			const onUpdateStatement = column.onUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-
-			const autoincrementStatement = column.autoincrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			const generatedStatement = column.generated
-				? ` GENERATED ALWAYS AS (${column.generated?.as}) ${column.generated?.type.toUpperCase()}`
-				: '';
-
-			statement += '\t'
-				+ `\`${column.name}\` ${column.type}${autoincrementStatement}${primaryKeyStatement}${generatedStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`;
-			statement += i === columns.length - 1 ? '' : ',\n';
-		}
-
-		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
-			statement += ',\n';
-			const compositePK = MySqlSquasher.unsquashPK(compositePKs[0]);
-			statement += `\tCONSTRAINT \`${st.compositePkName}\` PRIMARY KEY(\`${compositePK.columns.join(`\`,\``)}\`)`;
-		}
-
-		if (
-			typeof uniqueConstraints !== 'undefined'
-			&& uniqueConstraints.length > 0
-		) {
-			for (const uniqueConstraint of uniqueConstraints) {
-				statement += ',\n';
-				const unsquashedUnique = MySqlSquasher.unsquashUnique(uniqueConstraint);
-
-				const uniqueString = unsquashedUnique.columns
-					.map((it) => {
-						return internals?.indexes
-							? internals?.indexes[unsquashedUnique.name]?.columns[it]
-									?.isExpression
-								? it
-								: `\`${it}\``
-							: `\`${it}\``;
-					})
-					.join(',');
-
-				statement += `\tCONSTRAINT \`${unsquashedUnique.name}\` UNIQUE(${uniqueString})`;
-			}
-		}
-
-		if (typeof checkConstraints !== 'undefined' && checkConstraints.length > 0) {
-			for (const checkConstraint of checkConstraints) {
-				statement += ',\n';
-				const unsquashedCheck = MySqlSquasher.unsquashCheck(checkConstraint);
-
-				statement += `\tCONSTRAINT \`${unsquashedCheck.name}\` CHECK(${unsquashedCheck.value})`;
-			}
-		}
-
-		statement += `\n);`;
-		statement += `\n`;
-		return statement;
-	}
-}
-export class SingleStoreCreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_table' && dialect === 'singlestore';
-	}
-
-	convert(st: JsonCreateTableStatement) {
-		const {
-			tableName,
-			columns,
-			schema,
-			compositePKs,
-			uniqueConstraints,
-			internals,
-		} = st;
-
-		let statement = '';
-		statement += `CREATE TABLE \`${tableName}\` (\n`;
-		for (let i = 0; i < columns.length; i++) {
-			const column = columns[i];
-
-			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
-			const notNullStatement = column.notNull ? ' NOT NULL' : '';
-			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
-
-			const onUpdateStatement = column.onUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-
-			const autoincrementStatement = column.autoincrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			const generatedStatement = column.generated
-				? ` GENERATED ALWAYS AS (${column.generated?.as}) ${column.generated?.type.toUpperCase()}`
-				: '';
-
-			statement += '\t'
-				+ `\`${column.name}\` ${column.type}${autoincrementStatement}${primaryKeyStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}${generatedStatement}`;
-			statement += i === columns.length - 1 ? '' : ',\n';
-		}
-
-		if (typeof compositePKs !== 'undefined' && compositePKs.length > 0) {
-			statement += ',\n';
-			const compositePK = SingleStoreSquasher.unsquashPK(compositePKs[0]);
-			statement += `\tCONSTRAINT \`${compositePK.name}\` PRIMARY KEY(\`${compositePK.columns.join(`\`,\``)}\`)`;
-		}
-
-		if (
-			typeof uniqueConstraints !== 'undefined'
-			&& uniqueConstraints.length > 0
-		) {
-			for (const uniqueConstraint of uniqueConstraints) {
-				statement += ',\n';
-				const unsquashedUnique = SingleStoreSquasher.unsquashUnique(uniqueConstraint);
-
-				const uniqueString = unsquashedUnique.columns
-					.map((it) => {
-						return internals?.indexes
-							? internals?.indexes[unsquashedUnique.name]?.columns[it]
-									?.isExpression
-								? it
-								: `\`${it}\``
-							: `\`${it}\``;
-					})
-					.join(',');
-
-				statement += `\tCONSTRAINT \`${unsquashedUnique.name}\` UNIQUE(${uniqueString})`;
-			}
-		}
-
-		statement += `\n);`;
-		statement += `\n`;
-		return statement;
-	}
-}
-
-export class SQLiteCreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'sqlite_create_table' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(st: JsonSqliteCreateTableStatement) {
-		const {
-			tableName,
-			columns,
-			referenceData,
-			compositePKs,
-			uniqueConstraints,
-			checkConstraints,
-		} = st;
-
-		let statement = '';
-		statement += `CREATE TABLE \`${tableName}\` (\n`;
-		for (let i = 0; i < columns.length; i++) {
-			const column = columns[i];
-
-			const primaryKeyStatement = column.primaryKey ? ' PRIMARY KEY' : '';
-			const notNullStatement = column.notNull ? ' NOT NULL' : '';
-			const defaultStatement = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
-
-			const autoincrementStatement = column.autoincrement
-				? ' AUTOINCREMENT'
-				: '';
-
-			const generatedStatement = column.generated
-				? ` GENERATED ALWAYS AS ${column.generated.as} ${column.generated.type.toUpperCase()}`
-				: '';
-
-			statement += '\t';
-			statement +=
-				`\`${column.name}\` ${column.type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}`;
-
-			statement += i === columns.length - 1 ? '' : ',\n';
-		}
-
-		compositePKs.forEach((it) => {
-			statement += ',\n\t';
-			statement += `PRIMARY KEY(${it.map((it) => `\`${it}\``).join(', ')})`;
-		});
-
-		for (let i = 0; i < referenceData.length; i++) {
-			const {
-				name,
-				tableFrom,
-				tableTo,
-				columnsFrom,
-				columnsTo,
-				onDelete,
-				onUpdate,
-			} = referenceData[i];
-
-			const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
-			const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
-			const fromColumnsString = columnsFrom.map((it) => `\`${it}\``).join(',');
-			const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
-
-			statement += ',';
-			statement += '\n\t';
-			statement +=
-				`FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onUpdateStatement}${onDeleteStatement}`;
-		}
-
-		if (
-			typeof uniqueConstraints !== 'undefined'
-			&& uniqueConstraints.length > 0
-		) {
-			for (const uniqueConstraint of uniqueConstraints) {
-				statement += ',\n';
-				const unsquashedUnique = SQLiteSquasher.unsquashUnique(uniqueConstraint);
-				statement += `\tCONSTRAINT ${unsquashedUnique.name} UNIQUE(\`${unsquashedUnique.columns.join(`\`,\``)}\`)`;
-			}
-		}
-
-		if (
-			typeof checkConstraints !== 'undefined'
-			&& checkConstraints.length > 0
-		) {
-			for (const check of checkConstraints) {
-				statement += ',\n';
-				const { value, name } = SQLiteSquasher.unsquashCheck(check);
-				statement += `\tCONSTRAINT "${name}" CHECK(${value})`;
-			}
-		}
-
-		statement += `\n`;
-		statement += `);`;
-		statement += `\n`;
-		return statement;
-	}
-}
-
-class PgCreateViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_view' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonCreatePgViewStatement) {
-		const { definition, name: viewName, schema, with: withOption, materialized, withNoData, tablespace, using } = st;
-
-		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
-
-		let statement = materialized ? `CREATE MATERIALIZED VIEW ${name}` : `CREATE VIEW ${name}`;
-
-		if (using) statement += ` USING "${using}"`;
-
-		const options: string[] = [];
-		if (withOption) {
-			statement += ` WITH (`;
-
-			Object.entries(withOption).forEach(([key, value]) => {
-				if (typeof value === 'undefined') return;
-
-				options.push(`${key.snake_case()} = ${value}`);
-			});
-
-			statement += options.join(', ');
-
-			statement += `)`;
-		}
-
-		if (tablespace) statement += ` TABLESPACE ${tablespace}`;
-
-		statement += ` AS (${definition})`;
-
-		if (withNoData) statement += ` WITH NO DATA`;
-
-		statement += `;`;
-
-		return statement;
-	}
-}
-
-class MySqlCreateViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'mysql_create_view' && dialect === 'mysql';
-	}
-
-	convert(st: JsonCreateMySqlViewStatement) {
-		const { definition, name, algorithm, sqlSecurity, withCheckOption, replace } = st;
-
-		let statement = `CREATE `;
-		statement += replace ? `OR REPLACE ` : '';
-		statement += algorithm ? `ALGORITHM = ${algorithm}\n` : '';
-		statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity}\n` : '';
-		statement += `VIEW \`${name}\` AS (${definition})`;
-		statement += withCheckOption ? `\nWITH ${withCheckOption} CHECK OPTION` : '';
-
-		statement += ';';
-
-		return statement;
-	}
-}
-
-class SqliteCreateViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'sqlite_create_view' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(st: JsonCreateSqliteViewStatement) {
-		const { definition, name } = st;
-
-		return `CREATE VIEW \`${name}\` AS ${definition};`;
-	}
-}
-
-class PgDropViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_view' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonDropViewStatement) {
-		const { name: viewName, schema, materialized } = st;
-
-		const name = schema ? `"${schema}"."${viewName}"` : `"${viewName}"`;
-
-		return `DROP${materialized ? ' MATERIALIZED' : ''} VIEW ${name};`;
-	}
-}
-
-class MySqlDropViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_view' && dialect === 'mysql';
-	}
-
-	convert(st: JsonDropViewStatement) {
-		const { name } = st;
-
-		return `DROP VIEW \`${name}\`;`;
-	}
-}
-
-class SqliteDropViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_view' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(st: JsonDropViewStatement) {
-		const { name } = st;
-
-		return `DROP VIEW \`${name}\`;`;
-	}
-}
-
-class MySqlAlterViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_mysql_view' && dialect === 'mysql';
-	}
-
-	convert(st: JsonAlterMySqlViewStatement) {
-		const { name, algorithm, definition, sqlSecurity, withCheckOption } = st;
-
-		let statement = `ALTER `;
-		statement += algorithm ? `ALGORITHM = ${algorithm}\n` : '';
-		statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity}\n` : '';
-		statement += `VIEW \`${name}\` AS ${definition}`;
-		statement += withCheckOption ? `\nWITH ${withCheckOption} CHECK OPTION` : '';
-
-		statement += ';';
-
-		return statement;
-	}
-}
-
-class PgRenameViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_view' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonRenameViewStatement) {
-		const { nameFrom: from, nameTo: to, schema, materialized } = st;
-
-		const nameFrom = `"${schema}"."${from}"`;
-
-		return `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW ${nameFrom} RENAME TO "${to}";`;
-	}
-}
-
-class MySqlRenameViewConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_view' && dialect === 'mysql';
-	}
-
-	convert(st: JsonRenameViewStatement) {
-		const { nameFrom: from, nameTo: to } = st;
-
-		return `RENAME TABLE \`${from}\` TO \`${to}\`;`;
-	}
-}
-
-class PgAlterViewSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_view_alter_schema' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterViewAlterSchemaStatement) {
-		const { fromSchema, toSchema, name, materialized } = st;
-
-		const statement = `ALTER${
-			materialized ? ' MATERIALIZED' : ''
-		} VIEW "${fromSchema}"."${name}" SET SCHEMA "${toSchema}";`;
-
-		return statement;
-	}
-}
-
-class PgAlterViewAddWithOptionConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_view_add_with_option' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterViewAddWithOptionStatement) {
-		const { schema, with: withOption, name, materialized } = st;
-
-		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" SET (`;
-
-		const options: string[] = [];
-
-		Object.entries(withOption).forEach(([key, value]) => {
-			options.push(`${key.snake_case()} = ${value}`);
-		});
-
-		statement += options.join(', ');
-
-		statement += `);`;
-
-		return statement;
-	}
-}
-
-class PgAlterViewDropWithOptionConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_view_drop_with_option' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterViewDropWithOptionStatement) {
-		const { schema, name, materialized, with: withOptions } = st;
-
-		let statement = `ALTER${materialized ? ' MATERIALIZED' : ''} VIEW "${schema}"."${name}" RESET (`;
-
-		const options: string[] = [];
-
-		Object.entries(withOptions).forEach(([key, value]) => {
-			options.push(`${key.snake_case()}`);
-		});
-
-		statement += options.join(', ');
-
-		statement += ');';
-
-		return statement;
-	}
-}
-
-class PgAlterViewAlterTablespaceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_view_alter_tablespace' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterViewAlterTablespaceStatement) {
-		const { schema, name, toTablespace } = st;
-
-		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET TABLESPACE ${toTablespace};`;
-
-		return statement;
-	}
-}
-
-class PgAlterViewAlterUsingConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_view_alter_using' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterViewAlterUsingStatement) {
-		const { schema, name, toUsing } = st;
-
-		const statement = `ALTER MATERIALIZED VIEW "${schema}"."${name}" SET ACCESS METHOD "${toUsing}";`;
-
-		return statement;
-	}
-}
-
-class PgAlterTableAlterColumnSetGenerated extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_identity'
-			&& dialect === 'postgresql'
-		);
-	}
-	override convert(
-		statement: JsonAlterColumnSetIdentityStatement,
-	): string | string[] {
-		const { identity, tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
-
-		const identityWithSchema = schema
-			? `"${schema}"."${unsquashedIdentity?.name}"`
-			: `"${unsquashedIdentity?.name}"`;
-
-		const identityStatement = unsquashedIdentity
-			? ` GENERATED ${
-				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
-			} AS IDENTITY (sequence name ${identityWithSchema}${
-				unsquashedIdentity.increment
-					? ` INCREMENT BY ${unsquashedIdentity.increment}`
-					: ''
-			}${
-				unsquashedIdentity.minValue
-					? ` MINVALUE ${unsquashedIdentity.minValue}`
-					: ''
-			}${
-				unsquashedIdentity.maxValue
-					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
-					: ''
-			}${
-				unsquashedIdentity.startWith
-					? ` START WITH ${unsquashedIdentity.startWith}`
-					: ''
-			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
-				unsquashedIdentity.cycle ? ` CYCLE` : ''
-			})`
-			: '';
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" ADD${identityStatement};`;
-	}
-}
-
-class PgAlterTableAlterColumnDropGenerated extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_identity'
-			&& dialect === 'postgresql'
-		);
-	}
-	override convert(
-		statement: JsonAlterColumnDropIdentityStatement,
-	): string | string[] {
-		const { tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP IDENTITY;`;
-	}
-}
-
-class PgAlterTableAlterColumnAlterGenerated extends Convertor {
-	override can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_change_identity'
-			&& dialect === 'postgresql'
-		);
-	}
-	override convert(
-		statement: JsonAlterColumnAlterIdentityStatement,
-	): string | string[] {
-		const { identity, oldIdentity, tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
-		const unsquashedOldIdentity = PgSquasher.unsquashIdentity(oldIdentity);
-
-		const statementsToReturn: string[] = [];
-
-		if (unsquashedOldIdentity.type !== unsquashedIdentity.type) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET GENERATED ${
-					unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
-				};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.minValue !== unsquashedIdentity.minValue) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MINVALUE ${unsquashedIdentity.minValue};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.maxValue !== unsquashedIdentity.maxValue) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MAXVALUE ${unsquashedIdentity.maxValue};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.increment !== unsquashedIdentity.increment) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET INCREMENT BY ${unsquashedIdentity.increment};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.startWith !== unsquashedIdentity.startWith) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET START WITH ${unsquashedIdentity.startWith};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.cache !== unsquashedIdentity.cache) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET CACHE ${unsquashedIdentity.cache};`,
-			);
-		}
-
-		if (unsquashedOldIdentity.cycle !== unsquashedIdentity.cycle) {
-			statementsToReturn.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET ${
-					unsquashedIdentity.cycle ? `CYCLE` : 'NO CYCLE'
-				};`,
-			);
-		}
-
-		return statementsToReturn;
-	}
-}
-
-class PgAlterTableAddUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'create_unique_constraint' && dialect === 'postgresql'
-		);
-	}
-	convert(statement: JsonCreateUniqueConstraint): string {
-		const unsquashed = PgSquasher.unsquashUnique(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" UNIQUE${
-			unsquashed.nullsNotDistinct ? ' NULLS NOT DISTINCT' : ''
-		}("${unsquashed.columns.join('","')}");`;
-	}
-}
-
-class PgAlterTableDropUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'delete_unique_constraint' && dialect === 'postgresql'
-		);
-	}
-	convert(statement: JsonDeleteUniqueConstraint): string {
-		const unsquashed = PgSquasher.unsquashUnique(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unsquashed.name}";`;
-	}
-}
-
-class PgAlterTableAddCheckConstraintConvertor extends Convertor {
-	can(statement: JsonCreateCheckConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'create_check_constraint' && dialect === 'postgresql'
-		);
-	}
-	convert(statement: JsonCreateCheckConstraint): string {
-		const unsquashed = PgSquasher.unsquashCheck(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" CHECK (${unsquashed.value});`;
-	}
-}
-
-class PgAlterTableDeleteCheckConstraintConvertor extends Convertor {
-	can(statement: JsonDeleteCheckConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'delete_check_constraint' && dialect === 'postgresql'
-		);
-	}
-	convert(statement: JsonDeleteCheckConstraint): string {
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
-	}
-}
-
-class MySQLAlterTableAddUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
-		return statement.type === 'create_unique_constraint' && dialect === 'mysql';
-	}
-	convert(statement: JsonCreateUniqueConstraint): string {
-		const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
-
-		return `ALTER TABLE \`${statement.tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${
-			unsquashed.columns.join('`,`')
-		}\`);`;
-	}
-}
-
-class MySQLAlterTableDropUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
-		return statement.type === 'delete_unique_constraint' && dialect === 'mysql';
-	}
-	convert(statement: JsonDeleteUniqueConstraint): string {
-		const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
-
-		return `ALTER TABLE \`${statement.tableName}\` DROP INDEX \`${unsquashed.name}\`;`;
-	}
-}
-
-class MySqlAlterTableAddCheckConstraintConvertor extends Convertor {
-	can(statement: JsonCreateCheckConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'create_check_constraint' && dialect === 'mysql'
-		);
-	}
-	convert(statement: JsonCreateCheckConstraint): string {
-		const unsquashed = MySqlSquasher.unsquashCheck(statement.data);
-		const { tableName } = statement;
-
-		return `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` CHECK (${unsquashed.value});`;
-	}
-}
-
-class SingleStoreAlterTableAddUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonCreateUniqueConstraint, dialect: Dialect): boolean {
-		return statement.type === 'create_unique_constraint' && dialect === 'singlestore';
-	}
-	convert(statement: JsonCreateUniqueConstraint): string {
-		const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
-
-		return `ALTER TABLE \`${statement.tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${
-			unsquashed.columns.join('`,`')
-		}\`);`;
-	}
-}
-class SingleStoreAlterTableDropUniqueConstraintConvertor extends Convertor {
-	can(statement: JsonDeleteUniqueConstraint, dialect: Dialect): boolean {
-		return statement.type === 'delete_unique_constraint' && dialect === 'singlestore';
-	}
-	convert(statement: JsonDeleteUniqueConstraint): string {
-		const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
-
-		return `ALTER TABLE \`${statement.tableName}\` DROP INDEX \`${unsquashed.name}\`;`;
-	}
-}
-
-class MySqlAlterTableDeleteCheckConstraintConvertor extends Convertor {
-	can(statement: JsonDeleteCheckConstraint, dialect: Dialect): boolean {
-		return (
-			statement.type === 'delete_check_constraint' && dialect === 'mysql'
-		);
-	}
-	convert(statement: JsonDeleteCheckConstraint): string {
-		const { tableName } = statement;
-
-		return `ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${statement.constraintName}\`;`;
-	}
-}
-
-class CreatePgSequenceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_sequence' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonCreateSequenceStatement) {
-		const { name, values, schema } = st;
-
-		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		return `CREATE SEQUENCE ${sequenceWithSchema}${values.increment ? ` INCREMENT BY ${values.increment}` : ''}${
-			values.minValue ? ` MINVALUE ${values.minValue}` : ''
-		}${values.maxValue ? ` MAXVALUE ${values.maxValue}` : ''}${
-			values.startWith ? ` START WITH ${values.startWith}` : ''
-		}${values.cache ? ` CACHE ${values.cache}` : ''}${values.cycle ? ` CYCLE` : ''};`;
-	}
-}
-
-class DropPgSequenceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_sequence' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonDropSequenceStatement) {
-		const { name, schema } = st;
-
-		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		return `DROP SEQUENCE ${sequenceWithSchema};`;
-	}
-}
-
-class RenamePgSequenceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_sequence' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonRenameSequenceStatement) {
-		const { nameFrom, nameTo, schema } = st;
-
-		const sequenceWithSchemaFrom = schema
-			? `"${schema}"."${nameFrom}"`
-			: `"${nameFrom}"`;
-		const sequenceWithSchemaTo = schema
-			? `"${schema}"."${nameTo}"`
-			: `"${nameTo}"`;
-
-		return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${nameTo}";`;
-	}
-}
-
-class MovePgSequenceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'move_sequence' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonMoveSequenceStatement) {
-		const { schemaFrom, schemaTo, name } = st;
-
-		const sequenceWithSchema = schemaFrom
-			? `"${schemaFrom}"."${name}"`
-			: `"${name}"`;
-
-		const seqSchemaTo = schemaTo ? `"${schemaTo}"` : `public`;
-
-		return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
-	}
-}
-
-class AlterPgSequenceConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_sequence' && dialect === 'postgresql';
-	}
-
-	convert(st: JsonAlterSequenceStatement) {
-		const { name, schema, values } = st;
-
-		const { increment, minValue, maxValue, startWith, cache, cycle } = values;
-
-		const sequenceWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		return `ALTER SEQUENCE ${sequenceWithSchema}${increment ? ` INCREMENT BY ${increment}` : ''}${
-			minValue ? ` MINVALUE ${minValue}` : ''
-		}${maxValue ? ` MAXVALUE ${maxValue}` : ''}${startWith ? ` START WITH ${startWith}` : ''}${
-			cache ? ` CACHE ${cache}` : ''
-		}${cycle ? ` CYCLE` : ''};`;
-	}
-}
-
-class CreateTypeEnumConvertor extends Convertor {
-	can(statement: JsonStatement): boolean {
-		return statement.type === 'create_type_enum';
-	}
-
-	convert(st: JsonCreateEnumStatement) {
-		const { name, values, schema } = st;
-
-		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		let valuesStatement = '(';
-		valuesStatement += values.map((it) => `'${escapeSingleQuotes(it)}'`).join(', ');
-		valuesStatement += ')';
-
-		// TODO do we need this?
-		// let statement = 'DO $$ BEGIN';
-		// statement += '\n';
-		let statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
-		// statement += '\n';
-		// statement += 'EXCEPTION';
-		// statement += '\n';
-		// statement += ' WHEN duplicate_object THEN null;';
-		// statement += '\n';
-		// statement += 'END $$;';
-		// statement += '\n';
-		return statement;
-	}
-}
-
-class DropTypeEnumConvertor extends Convertor {
-	can(statement: JsonStatement): boolean {
-		return statement.type === 'drop_type_enum';
-	}
-
-	convert(st: JsonDropEnumStatement) {
-		const { name, schema } = st;
-
-		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		let statement = `DROP TYPE ${enumNameWithSchema};`;
-
-		return statement;
-	}
-}
-
-class AlterTypeAddValueConvertor extends Convertor {
-	can(statement: JsonStatement): boolean {
-		return statement.type === 'alter_type_add_value';
-	}
-
-	convert(st: JsonAddValueToEnumStatement) {
-		const { name, schema, value, before } = st;
-
-		const enumNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		return `ALTER TYPE ${enumNameWithSchema} ADD VALUE '${value}'${before.length ? ` BEFORE '${before}'` : ''};`;
-	}
-}
-
-class AlterTypeSetSchemaConvertor extends Convertor {
-	can(statement: JsonStatement): boolean {
-		return statement.type === 'move_type_enum';
-	}
-
-	convert(st: JsonMoveEnumStatement) {
-		const { name, schemaFrom, schemaTo } = st;
-
-		const enumNameWithSchema = schemaFrom ? `"${schemaFrom}"."${name}"` : `"${name}"`;
-
-		return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${schemaTo}";`;
-	}
-}
-
-class AlterRenameTypeConvertor extends Convertor {
-	can(statement: JsonStatement): boolean {
-		return statement.type === 'rename_type_enum';
-	}
-
-	convert(st: JsonRenameEnumStatement) {
-		const { nameTo, nameFrom, schema } = st;
-
-		const enumNameWithSchema = schema ? `"${schema}"."${nameFrom}"` : `"${nameFrom}"`;
-
-		return `ALTER TYPE ${enumNameWithSchema} RENAME TO "${nameTo}";`;
-	}
-}
-
-class AlterTypeDropValueConvertor extends Convertor {
-	can(statement: JsonDropValueFromEnumStatement): boolean {
-		return statement.type === 'alter_type_drop_value';
-	}
-
-	convert(st: JsonDropValueFromEnumStatement) {
-		const { columnsWithEnum, name, newValues, enumSchema } = st;
-
-		const statements: string[] = [];
-
-		for (const withEnum of columnsWithEnum) {
-			const tableNameWithSchema = withEnum.tableSchema
-				? `"${withEnum.tableSchema}"."${withEnum.table}"`
-				: `"${withEnum.table}"`;
-
-			statements.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE text;`,
-			);
-			if (withEnum.default) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::text;`,
-				);
-			}
-		}
-
-		statements.push(new DropTypeEnumConvertor().convert({ name: name, schema: enumSchema, type: 'drop_type_enum' }));
-
-		statements.push(new CreateTypeEnumConvertor().convert({
-			name: name,
-			schema: enumSchema,
-			values: newValues,
-			type: 'create_type_enum',
-		}));
-
-		for (const withEnum of columnsWithEnum) {
-			const tableNameWithSchema = withEnum.tableSchema
-				? `"${withEnum.tableSchema}"."${withEnum.table}"`
-				: `"${withEnum.table}"`;
-
-			const parsedType = parseType(`"${enumSchema}".`, withEnum.columnType);
-			if (withEnum.default) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::${parsedType};`,
-				);
-			}
-
-			statements.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE ${parsedType} USING "${withEnum.column}"::${parsedType};`,
-			);
-		}
-
-		return statements;
-	}
-}
-
-class PgDropTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_table' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonDropTableStatement, _d: any, action?: string) {
-		const { tableName, schema, policies } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const dropPolicyConvertor = new PgDropPolicyConvertor();
-		const droppedPolicies = policies?.map((p) => {
-			return dropPolicyConvertor.convert({
-				type: 'drop_policy',
-				tableName,
-				data: action === 'push'
-					? PgSquasher.unsquashPolicyPush(p)
-					: PgSquasher.unsquashPolicy(p),
-				schema,
-			}) as string;
-		}) ?? [];
-
-		return [
-			...droppedPolicies,
-			`DROP TABLE ${tableNameWithSchema} CASCADE;`,
-		];
-	}
-}
-
-class MySQLDropTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_table' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonDropTableStatement) {
-		const { tableName } = statement;
-		return `DROP TABLE \`${tableName}\`;`;
-	}
-}
-
-export class SingleStoreDropTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_table' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonDropTableStatement) {
-		const { tableName } = statement;
-		return `DROP TABLE \`${tableName}\`;`;
-	}
-}
-
-export class SQLiteDropTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_table' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(statement: JsonDropTableStatement) {
-		const { tableName } = statement;
-		return `DROP TABLE \`${tableName}\`;`;
-	}
-}
-
-class PgRenameTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_table' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonRenameTableStatement) {
-		const { tableNameFrom, tableNameTo, toSchema, fromSchema } = statement;
-		const from = fromSchema
-			? `"${fromSchema}"."${tableNameFrom}"`
-			: `"${tableNameFrom}"`;
-		const to = `"${tableNameTo}"`;
-		return `ALTER TABLE ${from} RENAME TO ${to};`;
-	}
-}
-
-export class SqliteRenameTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_table' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(statement: JsonRenameTableStatement) {
-		const { tableNameFrom, tableNameTo } = statement;
-		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
-	}
-}
-
-class MySqlRenameTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_table' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonRenameTableStatement) {
-		const { tableNameFrom, tableNameTo } = statement;
-		return `RENAME TABLE \`${tableNameFrom}\` TO \`${tableNameTo}\`;`;
-	}
-}
-
-export class SingleStoreRenameTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_table' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonRenameTableStatement) {
-		const { tableNameFrom, tableNameTo } = statement;
-		return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
-	}
-}
-
-class PgAlterTableRenameColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_rename_column' && dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonRenameColumnStatement) {
-		const { tableName, oldColumnName, newColumnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
-	}
-}
-
-class MySqlAlterTableRenameColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_rename_column' && dialect === 'mysql'
-		);
-	}
-
-	convert(statement: JsonRenameColumnStatement) {
-		const { tableName, oldColumnName, newColumnName } = statement;
-		return `ALTER TABLE \`${tableName}\` RENAME COLUMN \`${oldColumnName}\` TO \`${newColumnName}\`;`;
-	}
-}
-
-class SingleStoreAlterTableRenameColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_rename_column' && dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: JsonRenameColumnStatement) {
-		const { tableName, oldColumnName, newColumnName } = statement;
-		return `ALTER TABLE \`${tableName}\` CHANGE \`${oldColumnName}\` \`${newColumnName}\`;`;
-	}
-}
-
-class SQLiteAlterTableRenameColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_rename_column' && (dialect === 'sqlite' || dialect === 'turso')
-		);
-	}
-
-	convert(statement: JsonRenameColumnStatement) {
-		const { tableName, oldColumnName, newColumnName } = statement;
-		return `ALTER TABLE \`${tableName}\` RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
-	}
-}
-
-class PgAlterTableDropColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_drop_column' && dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonDropColumnStatement) {
-		const { tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${columnName}";`;
-	}
-}
-
-class MySqlAlterTableDropColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_table_drop_column' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonDropColumnStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
-	}
-}
-
-class SingleStoreAlterTableDropColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_table_drop_column' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonDropColumnStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
-	}
-}
-
-class SQLiteAlterTableDropColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_table_drop_column' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(statement: JsonDropColumnStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
-	}
-}
-
-class PgAlterTableAddColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_add_column' && dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAddColumnStatement) {
-		const { tableName, column, schema } = statement;
-		const { name, type, notNull, generated, primaryKey, identity } = column;
-
-		const primaryKeyStatement = primaryKey ? ' PRIMARY KEY' : '';
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
-
-		const schemaPrefix = column.typeSchema && column.typeSchema !== 'public'
-			? `"${column.typeSchema}".`
-			: '';
-
-		const fixedType = parseType(schemaPrefix, column.type);
-
-		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
-
-		const unsquashedIdentity = identity
-			? PgSquasher.unsquashIdentity(identity)
-			: undefined;
-
-		const identityWithSchema = schema
-			? `"${schema}"."${unsquashedIdentity?.name}"`
-			: `"${unsquashedIdentity?.name}"`;
-
-		const identityStatement = unsquashedIdentity
-			? ` GENERATED ${
-				unsquashedIdentity.type === 'always' ? 'ALWAYS' : 'BY DEFAULT'
-			} AS IDENTITY (sequence name ${identityWithSchema}${
-				unsquashedIdentity.increment
-					? ` INCREMENT BY ${unsquashedIdentity.increment}`
-					: ''
-			}${
-				unsquashedIdentity.minValue
-					? ` MINVALUE ${unsquashedIdentity.minValue}`
-					: ''
-			}${
-				unsquashedIdentity.maxValue
-					? ` MAXVALUE ${unsquashedIdentity.maxValue}`
-					: ''
-			}${
-				unsquashedIdentity.startWith
-					? ` START WITH ${unsquashedIdentity.startWith}`
-					: ''
-			}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ''}${
-				unsquashedIdentity.cycle ? ` CYCLE` : ''
-			})`
-			: '';
-
-		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
-
-		return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
-	}
-}
-
-class MySqlAlterTableAddColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_table_add_column' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonAddColumnStatement) {
-		const { tableName, column } = statement;
-		const {
-			name,
-			type,
-			notNull,
-			primaryKey,
-			autoincrement,
-			onUpdate,
-			generated,
-		} = column;
-
-		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
-		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
-		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
-		const autoincrementStatement = `${autoincrement ? ' AUTO_INCREMENT' : ''}`;
-		const onUpdateStatement = `${onUpdate ? ' ON UPDATE CURRENT_TIMESTAMP' : ''}`;
-
-		const generatedStatement = generated
-			? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
-			: '';
-
-		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${onUpdateStatement};`;
-	}
-}
-
-class SingleStoreAlterTableAddColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_table_add_column' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonAddColumnStatement) {
-		const { tableName, column } = statement;
-		const {
-			name,
-			type,
-			notNull,
-			primaryKey,
-			autoincrement,
-			onUpdate,
-			generated,
-		} = column;
-
-		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
-		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
-		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
-		const autoincrementStatement = `${autoincrement ? ' AUTO_INCREMENT' : ''}`;
-		const onUpdateStatement = `${onUpdate ? ' ON UPDATE CURRENT_TIMESTAMP' : ''}`;
-
-		const generatedStatement = generated
-			? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
-			: '';
-
-		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${notNullStatement}${onUpdateStatement}${generatedStatement};`;
-	}
-}
-
-export class SQLiteAlterTableAddColumnConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'sqlite_alter_table_add_column' && (dialect === 'sqlite' || dialect === 'turso')
-		);
-	}
-
-	convert(statement: JsonSqliteAddColumnStatement) {
-		const { tableName, column, referenceData } = statement;
-		const { name, type, notNull, primaryKey, generated } = column;
-
-		const defaultStatement = `${column.default !== undefined ? ` DEFAULT ${column.default}` : ''}`;
-		const notNullStatement = `${notNull ? ' NOT NULL' : ''}`;
-		const primaryKeyStatement = `${primaryKey ? ' PRIMARY KEY' : ''}`;
-		const referenceAsObject = referenceData
-			? SQLiteSquasher.unsquashFK(referenceData)
-			: undefined;
-		const referenceStatement = `${
-			referenceAsObject
-				? ` REFERENCES ${referenceAsObject.tableTo}(${referenceAsObject.columnsTo})`
-				: ''
-		}`;
-		// const autoincrementStatement = `${autoincrement ? 'AUTO_INCREMENT' : ''}`
-		const generatedStatement = generated
-			? ` GENERATED ALWAYS AS ${generated.as} ${generated.type.toUpperCase()}`
-			: '';
-
-		return `ALTER TABLE \`${tableName}\` ADD \`${name}\` ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${referenceStatement};`;
-	}
-}
-
-class PgAlterTableAlterColumnSetTypeConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'pg_alter_table_alter_column_set_type'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnPgTypeStatement) {
-		const { tableName, columnName, newDataType, schema, oldDataType, columnDefault, typeSchema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const statements: string[] = [];
-
-		const type = parseType(`"${typeSchema}".`, newDataType.name);
-
-		if (!oldDataType.isEnum && !newDataType.isEnum) {
-			statements.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
-			);
-			if (columnDefault) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
-				);
-			}
-		}
-
-		if (oldDataType.isEnum && !newDataType.isEnum) {
-			statements.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`,
-			);
-			if (columnDefault) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
-				);
-			}
-		}
-
-		if (!oldDataType.isEnum && newDataType.isEnum) {
-			if (columnDefault) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault}::${type};`,
-				);
-			}
-			statements.push(
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::${type};`,
-			);
-		}
-
-		if (oldDataType.isEnum && newDataType.isEnum) {
-			const alterType =
-				`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::text::${type};`;
-
-			if (newDataType.name !== oldDataType.name && columnDefault) {
-				statements.push(
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`,
-					alterType,
-					`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`,
-				);
-			} else {
-				statements.push(alterType);
-			}
-		}
-
-		return statements;
-	}
-}
-
-class PgAlterTableAlterColumnSetDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_default'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetDefaultStatement) {
-		const { tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${statement.newDefaultValue};`;
-	}
-}
-
-class PgAlterTableAlterColumnDropDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_default'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropDefaultStatement) {
-		const { tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`;
-	}
-}
-
-class PgAlterTableAlterColumnDropGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_generated'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropGeneratedStatement) {
-		const { tableName, columnName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP EXPRESSION;`;
-	}
-}
-
-class PgAlterTableAlterColumnSetExpressionConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_generated'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull: notNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
-			schema,
-			tableName,
-			column: {
-				name: columnName,
-				type: statement.newDataType,
-				notNull,
-				default: columnDefault,
-				onUpdate: columnOnUpdate,
-				autoincrement: columnAutoIncrement,
-				primaryKey: columnPk,
-				generated: columnGenerated,
-			},
-			type: 'alter_table_add_column',
-		});
-
-		return [
-			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
-			addColumnStatement,
-		];
-	}
-}
-
-class PgAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_alter_generated'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull: notNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
-			schema,
-			tableName,
-			column: {
-				name: columnName,
-				type: statement.newDataType,
-				notNull,
-				default: columnDefault,
-				onUpdate: columnOnUpdate,
-				autoincrement: columnAutoIncrement,
-				primaryKey: columnPk,
-				generated: columnGenerated,
-			},
-			type: 'alter_table_add_column',
-		});
-
-		return [
-			`ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
-			addColumnStatement,
-		];
-	}
-}
-
-////
-class SqliteAlterTableAlterColumnDropGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_generated'
-			&& (dialect === 'sqlite' || dialect === 'turso')
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-			columnNotNull,
-		} = statement;
-
-		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
-			{
-				tableName,
-				column: {
-					name: columnName,
-					type: statement.newDataType,
-					notNull: columnNotNull,
-					default: columnDefault,
-					onUpdate: columnOnUpdate,
-					autoincrement: columnAutoIncrement,
-					primaryKey: columnPk,
-					generated: columnGenerated,
-				},
-				type: 'sqlite_alter_table_add_column',
-			},
-		);
-
-		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
-			tableName,
-			columnName,
-			schema,
-			type: 'alter_table_drop_column',
-		});
-
-		return [dropColumnStatement, addColumnStatement];
-	}
-}
-
-class SqliteAlterTableAlterColumnSetExpressionConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_generated'
-			&& (dialect === 'sqlite' || dialect === 'turso')
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull: notNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
-			{
-				tableName,
-				column: {
-					name: columnName,
-					type: statement.newDataType,
-					notNull,
-					default: columnDefault,
-					onUpdate: columnOnUpdate,
-					autoincrement: columnAutoIncrement,
-					primaryKey: columnPk,
-					generated: columnGenerated,
-				},
-				type: 'sqlite_alter_table_add_column',
-			},
-		);
-
-		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
-			tableName,
-			columnName,
-			schema,
-			type: 'alter_table_drop_column',
-		});
-
-		return [dropColumnStatement, addColumnStatement];
-	}
-}
-
-class SqliteAlterTableAlterColumnAlterGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_alter_generated'
-			&& (dialect === 'sqlite' || dialect === 'turso')
-		);
-	}
-
-	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
-			{
-				tableName,
-				column: {
-					name: columnName,
-					type: statement.newDataType,
-					notNull: columnNotNull,
-					default: columnDefault,
-					onUpdate: columnOnUpdate,
-					autoincrement: columnAutoIncrement,
-					primaryKey: columnPk,
-					generated: columnGenerated,
-				},
-				type: 'sqlite_alter_table_add_column',
-			},
-		);
-
-		const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
-			tableName,
-			columnName,
-			schema,
-			type: 'alter_table_drop_column',
-		});
-
-		return [dropColumnStatement, addColumnStatement];
-	}
-}
-
-////
-
-class MySqlAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_alter_generated'
-			&& dialect === 'mysql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull: notNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const tableNameWithSchema = schema
-			? `\`${schema}\`.\`${tableName}\``
-			: `\`${tableName}\``;
-
-		const addColumnStatement = new MySqlAlterTableAddColumnConvertor().convert({
-			schema,
-			tableName,
-			column: {
-				name: columnName,
-				type: statement.newDataType,
-				notNull,
-				default: columnDefault,
-				onUpdate: columnOnUpdate,
-				autoincrement: columnAutoIncrement,
-				primaryKey: columnPk,
-				generated: columnGenerated,
-			},
-			type: 'alter_table_add_column',
-		});
-
-		return [
-			`ALTER TABLE ${tableNameWithSchema} drop column \`${columnName}\`;`,
-			addColumnStatement,
-		];
-	}
-}
-
-class MySqlAlterTableAlterColumnSetDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_default'
-			&& dialect === 'mysql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetDefaultStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` SET DEFAULT ${statement.newDefaultValue};`;
-	}
-}
-
-class MySqlAlterTableAlterColumnDropDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_default'
-			&& dialect === 'mysql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropDefaultStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` DROP DEFAULT;`;
-	}
-}
-
-class MySqlAlterTableAddPk extends Convertor {
-	can(statement: JsonStatement, dialect: string): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_pk'
-			&& dialect === 'mysql'
-		);
-	}
-	convert(statement: JsonAlterColumnSetPrimaryKeyStatement): string {
-		return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY (\`${statement.columnName}\`);`;
-	}
-}
-
-class MySqlAlterTableDropPk extends Convertor {
-	can(statement: JsonStatement, dialect: string): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_pk'
-			&& dialect === 'mysql'
-		);
-	}
-	convert(statement: JsonAlterColumnDropPrimaryKeyStatement): string {
-		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY`;
-	}
-}
-
-type LibSQLModifyColumnStatement =
-	| JsonAlterColumnTypeStatement
-	| JsonAlterColumnDropNotNullStatement
-	| JsonAlterColumnSetNotNullStatement
-	| JsonAlterColumnSetDefaultStatement
-	| JsonAlterColumnDropDefaultStatement;
-
-export class LibSQLModifyColumn extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			(statement.type === 'alter_table_alter_column_set_type'
-				|| statement.type === 'alter_table_alter_column_drop_notnull'
-				|| statement.type === 'alter_table_alter_column_set_notnull'
-				|| statement.type === 'alter_table_alter_column_set_default'
-				|| statement.type === 'alter_table_alter_column_drop_default'
-				|| statement.type === 'create_check_constraint'
-				|| statement.type === 'delete_check_constraint')
-			&& dialect === 'turso'
-		);
-	}
-
-	convert(statement: LibSQLModifyColumnStatement, json2: SQLiteSchemaSquashed) {
-		const { tableName, columnName } = statement;
-
-		let columnType = ``;
-		let columnDefault: any = '';
-		let columnNotNull = '';
-
-		const sqlStatements: string[] = [];
-
-		// collect index info
-		const indexes: {
-			name: string;
-			tableName: string;
-			columns: string[];
-			isUnique: boolean;
-			where?: string | undefined;
-		}[] = [];
-		for (const table of Object.values(json2.tables)) {
-			for (const index of Object.values(table.indexes)) {
-				const unsquashed = SQLiteSquasher.unsquashIdx(index);
-				sqlStatements.push(`DROP INDEX "${unsquashed.name}";`);
-				indexes.push({ ...unsquashed, tableName: table.name });
-			}
-		}
-
-		switch (statement.type) {
-			case 'alter_table_alter_column_set_type':
-				columnType = ` ${statement.newDataType}`;
-
-				columnDefault = statement.columnDefault
-					? ` DEFAULT ${statement.columnDefault}`
-					: '';
-
-				columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-
-				break;
-			case 'alter_table_alter_column_drop_notnull':
-				columnType = ` ${statement.newDataType}`;
-
-				columnDefault = statement.columnDefault
-					? ` DEFAULT ${statement.columnDefault}`
-					: '';
-
-				columnNotNull = '';
-				break;
-			case 'alter_table_alter_column_set_notnull':
-				columnType = ` ${statement.newDataType}`;
-
-				columnDefault = statement.columnDefault
-					? ` DEFAULT ${statement.columnDefault}`
-					: '';
-
-				columnNotNull = ` NOT NULL`;
-				break;
-			case 'alter_table_alter_column_set_default':
-				columnType = ` ${statement.newDataType}`;
-
-				columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
-
-				columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-				break;
-			case 'alter_table_alter_column_drop_default':
-				columnType = ` ${statement.newDataType}`;
-
-				columnDefault = '';
-
-				columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-				break;
-		}
-
-		// Seems like getting value from simple json2 shanpshot makes dates be dates
-		columnDefault = columnDefault instanceof Date
-			? columnDefault.toISOString()
-			: columnDefault;
-
-		sqlStatements.push(
-			`ALTER TABLE \`${tableName}\` ALTER COLUMN "${columnName}" TO "${columnName}"${columnType}${columnNotNull}${columnDefault};`,
-		);
-
-		for (const index of indexes) {
-			const indexPart = index.isUnique ? 'UNIQUE INDEX' : 'INDEX';
-			const whereStatement = index.where ? ` WHERE ${index.where}` : '';
-			const uniqueString = index.columns.map((it) => `\`${it}\``).join(',');
-			const tableName = index.tableName;
-
-			sqlStatements.push(
-				`CREATE ${indexPart} \`${index.name}\` ON \`${tableName}\` (${uniqueString})${whereStatement};`,
-			);
-		}
-
-		return sqlStatements;
-	}
-}
-
-type MySqlModifyColumnStatement =
-	| JsonAlterColumnDropNotNullStatement
-	| JsonAlterColumnSetNotNullStatement
-	| JsonAlterColumnTypeStatement
-	| JsonAlterColumnDropOnUpdateStatement
-	| JsonAlterColumnSetOnUpdateStatement
-	| JsonAlterColumnDropAutoincrementStatement
-	| JsonAlterColumnSetAutoincrementStatement
-	| JsonAlterColumnSetDefaultStatement
-	| JsonAlterColumnDropDefaultStatement
-	| JsonAlterColumnSetGeneratedStatement
-	| JsonAlterColumnDropGeneratedStatement;
-
-class MySqlModifyColumn extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			(statement.type === 'alter_table_alter_column_set_type'
-				|| statement.type === 'alter_table_alter_column_set_notnull'
-				|| statement.type === 'alter_table_alter_column_drop_notnull'
-				|| statement.type === 'alter_table_alter_column_drop_on_update'
-				|| statement.type === 'alter_table_alter_column_set_on_update'
-				|| statement.type === 'alter_table_alter_column_set_autoincrement'
-				|| statement.type === 'alter_table_alter_column_drop_autoincrement'
-				|| statement.type === 'alter_table_alter_column_set_default'
-				|| statement.type === 'alter_table_alter_column_drop_default'
-				|| statement.type === 'alter_table_alter_column_set_generated'
-				|| statement.type === 'alter_table_alter_column_drop_generated')
-			&& dialect === 'mysql'
-		);
-	}
-
-	convert(statement: MySqlModifyColumnStatement) {
-		const { tableName, columnName } = statement;
-		let columnType = ``;
-		let columnDefault: any = '';
-		let columnNotNull = '';
-		let columnOnUpdate = '';
-		let columnAutoincrement = '';
-		let primaryKey = statement.columnPk ? ' PRIMARY KEY' : '';
-		let columnGenerated = '';
-
-		if (statement.type === 'alter_table_alter_column_drop_notnull') {
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
-			columnNotNull = ` NOT NULL`;
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_drop_on_update') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnOnUpdate = '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_on_update') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (
-			statement.type === 'alter_table_alter_column_set_autoincrement'
-		) {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = ' AUTO_INCREMENT';
-		} else if (
-			statement.type === 'alter_table_alter_column_drop_autoincrement'
-		) {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = '';
-		} else if (statement.type === 'alter_table_alter_column_set_default') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_drop_default') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_generated') {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			if (statement.columnGenerated?.type === 'virtual') {
-				return [
-					new MySqlAlterTableDropColumnConvertor().convert({
-						type: 'alter_table_drop_column',
-						tableName: statement.tableName,
-						columnName: statement.columnName,
-						schema: statement.schema,
-					}),
-					new MySqlAlterTableAddColumnConvertor().convert({
-						tableName,
-						column: {
-							name: columnName,
-							type: statement.newDataType,
-							notNull: statement.columnNotNull,
-							default: statement.columnDefault,
-							onUpdate: statement.columnOnUpdate,
-							autoincrement: statement.columnAutoIncrement,
-							primaryKey: statement.columnPk,
-							generated: statement.columnGenerated,
-						},
-						schema: statement.schema,
-						type: 'alter_table_add_column',
-					}),
-				];
-			} else {
-				columnGenerated = statement.columnGenerated
-					? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
-					: '';
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_generated') {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			if (statement.oldColumn?.generated?.type === 'virtual') {
-				return [
-					new MySqlAlterTableDropColumnConvertor().convert({
-						type: 'alter_table_drop_column',
-						tableName: statement.tableName,
-						columnName: statement.columnName,
-						schema: statement.schema,
-					}),
-					new MySqlAlterTableAddColumnConvertor().convert({
-						tableName,
-						column: {
-							name: columnName,
-							type: statement.newDataType,
-							notNull: statement.columnNotNull,
-							default: statement.columnDefault,
-							onUpdate: statement.columnOnUpdate,
-							autoincrement: statement.columnAutoIncrement,
-							primaryKey: statement.columnPk,
-							generated: statement.columnGenerated,
-						},
-						schema: statement.schema,
-						type: 'alter_table_add_column',
-					}),
-				];
-			}
-		} else {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-			columnGenerated = statement.columnGenerated
-				? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
-				: '';
-		}
-
-		// Seems like getting value from simple json2 shanpshot makes dates be dates
-		columnDefault = columnDefault instanceof Date
-			? columnDefault.toISOString()
-			: columnDefault;
-
-		return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnGenerated}${columnNotNull}${columnDefault}${columnOnUpdate};`;
-	}
-}
-
-class SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_alter_generated'
-			&& dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: JsonAlterColumnAlterGeneratedStatement) {
-		const {
-			tableName,
-			columnName,
-			schema,
-			columnNotNull: notNull,
-			columnDefault,
-			columnOnUpdate,
-			columnAutoIncrement,
-			columnPk,
-			columnGenerated,
-		} = statement;
-
-		const tableNameWithSchema = schema
-			? `\`${schema}\`.\`${tableName}\``
-			: `\`${tableName}\``;
-
-		const addColumnStatement = new SingleStoreAlterTableAddColumnConvertor().convert({
-			schema,
-			tableName,
-			column: {
-				name: columnName,
-				type: statement.newDataType,
-				notNull,
-				default: columnDefault,
-				onUpdate: columnOnUpdate,
-				autoincrement: columnAutoIncrement,
-				primaryKey: columnPk,
-				generated: columnGenerated,
-			},
-			type: 'alter_table_add_column',
-		});
-
-		return [
-			`ALTER TABLE ${tableNameWithSchema} drop column \`${columnName}\`;`,
-			addColumnStatement,
-		];
-	}
-}
-
-class SingleStoreAlterTableAlterColumnSetDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_default'
-			&& dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetDefaultStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` SET DEFAULT ${statement.newDefaultValue};`;
-	}
-}
-
-class SingleStoreAlterTableAlterColumnDropDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_default'
-			&& dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropDefaultStatement) {
-		const { tableName, columnName } = statement;
-		return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${columnName}\` DROP DEFAULT;`;
-	}
-}
-
-class SingleStoreAlterTableAddPk extends Convertor {
-	can(statement: JsonStatement, dialect: string): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_pk'
-			&& dialect === 'singlestore'
-		);
-	}
-	convert(statement: JsonAlterColumnSetPrimaryKeyStatement): string {
-		return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY (\`${statement.columnName}\`);`;
-	}
-}
-
-class SingleStoreAlterTableDropPk extends Convertor {
-	can(statement: JsonStatement, dialect: string): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_pk'
-			&& dialect === 'singlestore'
-		);
-	}
-	convert(statement: JsonAlterColumnDropPrimaryKeyStatement): string {
-		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY`;
-	}
-}
-
-type SingleStoreModifyColumnStatement =
-	| JsonAlterColumnDropNotNullStatement
-	| JsonAlterColumnSetNotNullStatement
-	| JsonAlterColumnTypeStatement
-	| JsonAlterColumnDropOnUpdateStatement
-	| JsonAlterColumnSetOnUpdateStatement
-	| JsonAlterColumnDropAutoincrementStatement
-	| JsonAlterColumnSetAutoincrementStatement
-	| JsonAlterColumnSetDefaultStatement
-	| JsonAlterColumnDropDefaultStatement
-	| JsonAlterColumnSetGeneratedStatement
-	| JsonAlterColumnDropGeneratedStatement;
-
-class SingleStoreModifyColumn extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			(statement.type === 'alter_table_alter_column_set_type'
-				|| statement.type === 'alter_table_alter_column_set_notnull'
-				|| statement.type === 'alter_table_alter_column_drop_notnull'
-				|| statement.type === 'alter_table_alter_column_drop_on_update'
-				|| statement.type === 'alter_table_alter_column_set_on_update'
-				|| statement.type === 'alter_table_alter_column_set_autoincrement'
-				|| statement.type === 'alter_table_alter_column_drop_autoincrement'
-				|| statement.type === 'alter_table_alter_column_set_default'
-				|| statement.type === 'alter_table_alter_column_drop_default'
-				|| statement.type === 'alter_table_alter_column_set_generated'
-				|| statement.type === 'alter_table_alter_column_drop_generated')
-			&& dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: SingleStoreModifyColumnStatement) {
-		const { tableName, columnName } = statement;
-		let columnType = ``;
-		let columnDefault: any = '';
-		let columnNotNull = '';
-		let columnOnUpdate = '';
-		let columnAutoincrement = '';
-		let primaryKey = statement.columnPk ? ' PRIMARY KEY' : '';
-		let columnGenerated = '';
-
-		if (statement.type === 'alter_table_alter_column_drop_notnull') {
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_notnull') {
-			columnNotNull = ` NOT NULL`;
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_drop_on_update') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnOnUpdate = '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_on_update') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (
-			statement.type === 'alter_table_alter_column_set_autoincrement'
-		) {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = ' AUTO_INCREMENT';
-		} else if (
-			statement.type === 'alter_table_alter_column_drop_autoincrement'
-		) {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = '';
-		} else if (statement.type === 'alter_table_alter_column_set_default') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_drop_default') {
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnType = ` ${statement.newDataType}`;
-			columnDefault = '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-		} else if (statement.type === 'alter_table_alter_column_set_generated') {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			if (statement.columnGenerated?.type === 'virtual') {
-				return [
-					new SingleStoreAlterTableDropColumnConvertor().convert({
-						type: 'alter_table_drop_column',
-						tableName: statement.tableName,
-						columnName: statement.columnName,
-						schema: statement.schema,
-					}),
-					new SingleStoreAlterTableAddColumnConvertor().convert({
-						tableName,
-						column: {
-							name: columnName,
-							type: statement.newDataType,
-							notNull: statement.columnNotNull,
-							default: statement.columnDefault,
-							onUpdate: statement.columnOnUpdate,
-							autoincrement: statement.columnAutoIncrement,
-							primaryKey: statement.columnPk,
-							generated: statement.columnGenerated,
-						},
-						schema: statement.schema,
-						type: 'alter_table_add_column',
-					}),
-				];
-			} else {
-				columnGenerated = statement.columnGenerated
-					? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
-					: '';
-			}
-		} else if (statement.type === 'alter_table_alter_column_drop_generated') {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-
-			if (statement.oldColumn?.generated?.type === 'virtual') {
-				return [
-					new SingleStoreAlterTableDropColumnConvertor().convert({
-						type: 'alter_table_drop_column',
-						tableName: statement.tableName,
-						columnName: statement.columnName,
-						schema: statement.schema,
-					}),
-					new SingleStoreAlterTableAddColumnConvertor().convert({
-						tableName,
-						column: {
-							name: columnName,
-							type: statement.newDataType,
-							notNull: statement.columnNotNull,
-							default: statement.columnDefault,
-							onUpdate: statement.columnOnUpdate,
-							autoincrement: statement.columnAutoIncrement,
-							primaryKey: statement.columnPk,
-							generated: statement.columnGenerated,
-						},
-						schema: statement.schema,
-						type: 'alter_table_add_column',
-					}),
-				];
-			}
-		} else {
-			columnType = ` ${statement.newDataType}`;
-			columnNotNull = statement.columnNotNull ? ` NOT NULL` : '';
-			columnOnUpdate = columnOnUpdate = statement.columnOnUpdate
-				? ` ON UPDATE CURRENT_TIMESTAMP`
-				: '';
-			columnDefault = statement.columnDefault
-				? ` DEFAULT ${statement.columnDefault}`
-				: '';
-			columnAutoincrement = statement.columnAutoIncrement
-				? ' AUTO_INCREMENT'
-				: '';
-			columnGenerated = statement.columnGenerated
-				? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}`
-				: '';
-		}
-
-		// Seems like getting value from simple json2 shanpshot makes dates be dates
-		columnDefault = columnDefault instanceof Date
-			? columnDefault.toISOString()
-			: columnDefault;
-
-		return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnNotNull}${columnDefault}${columnOnUpdate}${columnGenerated};`;
-	}
-}
-class SqliteAlterTableAlterColumnDropDefaultConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_default'
-			&& dialect === 'sqlite'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropDefaultStatement) {
-		return (
-			'/*\n SQLite does not support "Drop default from column" out of the box, we do not generate automatic migration for that, so it has to be done manually'
-			+ '\n Please refer to: https://www.techonthenet.com/sqlite/tables/alter_table.php'
-			+ '\n                  https://www.sqlite.org/lang_altertable.html'
-			+ '\n                  https://stackoverflow.com/questions/2083543/modify-a-columns-type-in-sqlite3'
-			+ "\n\n Due to that we don't generate migration automatically and it has to be done manually"
-			+ '\n*/'
-		);
-	}
-}
-
-class PgAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_composite_pk' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonCreateCompositePK) {
-		const { name, columns } = PgSquasher.unsquashPK(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.constraintName}" PRIMARY KEY("${
-			columns.join('","')
-		}");`;
-	}
-}
-class PgAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'delete_composite_pk' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonDeleteCompositePK) {
-		const { name, columns } = PgSquasher.unsquashPK(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
-	}
-}
-
-class PgAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_composite_pk' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonAlterCompositePK) {
-		const { name, columns } = PgSquasher.unsquashPK(statement.old);
-		const { name: newName, columns: newColumns } = PgSquasher.unsquashPK(
-			statement.new,
-		);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.oldConstraintName}";\n${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.newConstraintName}" PRIMARY KEY("${
-			newColumns.join('","')
-		}");`;
-	}
-}
-
-class MySqlAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_composite_pk' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonCreateCompositePK) {
-		const { name, columns } = MySqlSquasher.unsquashPK(statement.data);
-		return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY(\`${columns.join('`,`')}\`);`;
-	}
-}
-
-class MySqlAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'delete_composite_pk' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonDeleteCompositePK) {
-		const { name, columns } = MySqlSquasher.unsquashPK(statement.data);
-		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY;`;
-	}
-}
-
-class MySqlAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_composite_pk' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonAlterCompositePK) {
-		const { name, columns } = MySqlSquasher.unsquashPK(statement.old);
-		const { name: newName, columns: newColumns } = MySqlSquasher.unsquashPK(
-			statement.new,
-		);
-		return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY, ADD PRIMARY KEY(\`${newColumns.join('`,`')}\`);`;
-	}
-}
-
-class SqliteAlterTableCreateCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_composite_pk' && dialect === 'sqlite';
-	}
-
-	convert(statement: JsonCreateCompositePK) {
-		let msg = '/*\n';
-		msg += `You're trying to add PRIMARY KEY(${statement.data}) to '${statement.tableName}' table\n`;
-		msg += 'SQLite does not support adding primary key to an already created table\n';
-		msg += 'You can do it in 3 steps with drizzle orm:\n';
-		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
-		msg += ' - migrate old data from one table to another\n';
-		msg += ' - delete old_table in schema, generate sql\n\n';
-		msg += 'or create manual migration like below:\n\n';
-		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
-		msg += 'CREATE TABLE table_name (\n';
-		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
-		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
-		msg += '\t...\n';
-		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
-		msg += ' );\n';
-		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
-		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
-		msg += '*/\n';
-		return msg;
-	}
-}
-class SqliteAlterTableDeleteCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'delete_composite_pk' && dialect === 'sqlite';
-	}
-
-	convert(statement: JsonDeleteCompositePK) {
-		let msg = '/*\n';
-		msg += `You're trying to delete PRIMARY KEY(${statement.data}) from '${statement.tableName}' table\n`;
-		msg += 'SQLite does not supportprimary key deletion from existing table\n';
-		msg += 'You can do it in 3 steps with drizzle orm:\n';
-		msg += ' - create new mirror table table without pk, rename current table to old_table, generate SQL\n';
-		msg += ' - migrate old data from one table to another\n';
-		msg += ' - delete old_table in schema, generate sql\n\n';
-		msg += 'or create manual migration like below:\n\n';
-		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
-		msg += 'CREATE TABLE table_name (\n';
-		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
-		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
-		msg += '\t...\n';
-		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
-		msg += ' );\n';
-		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
-		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
-		msg += '*/\n';
-		return msg;
-	}
-}
-
-class SqliteAlterTableAlterCompositePrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_composite_pk' && dialect === 'sqlite';
-	}
-
-	convert(statement: JsonAlterCompositePK) {
-		let msg = '/*\n';
-		msg += 'SQLite does not support altering primary key\n';
-		msg += 'You can do it in 3 steps with drizzle orm:\n';
-		msg += ' - create new mirror table with needed pk, rename current table to old_table, generate SQL\n';
-		msg += ' - migrate old data from one table to another\n';
-		msg += ' - delete old_table in schema, generate sql\n\n';
-		msg += 'or create manual migration like below:\n\n';
-		msg += 'ALTER TABLE table_name RENAME TO old_table;\n';
-		msg += 'CREATE TABLE table_name (\n';
-		msg += '\tcolumn1 datatype [ NULL | NOT NULL ],\n';
-		msg += '\tcolumn2 datatype [ NULL | NOT NULL ],\n';
-		msg += '\t...\n';
-		msg += '\tPRIMARY KEY (pk_col1, pk_col2, ... pk_col_n)\n';
-		msg += ' );\n';
-		msg += 'INSERT INTO table_name SELECT * FROM old_table;\n\n';
-		msg += "Due to that we don't generate migration automatically and it has to be done manually\n";
-		msg += '*/\n';
-
-		return msg;
-	}
-}
-
-class PgAlterTableAlterColumnSetPrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_pk'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetPrimaryKeyStatement) {
-		const { tableName, columnName } = statement;
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ADD PRIMARY KEY ("${columnName}");`;
-	}
-}
-
-class PgAlterTableAlterColumnDropPrimaryKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_pk'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropPrimaryKeyStatement) {
-		const { tableName, columnName, schema } = statement;
-		return `/* 
-    Unfortunately in current drizzle-kit version we can't automatically get name for primary key.
-    We are working on making it available!
-
-    Meanwhile you can:
-        1. Check pk name in your database, by running
-            SELECT constraint_name FROM information_schema.table_constraints
-            WHERE table_schema = '${typeof schema === 'undefined' || schema === '' ? 'public' : schema}'
-                AND table_name = '${tableName}'
-                AND constraint_type = 'PRIMARY KEY';
-        2. Uncomment code below and paste pk name manually
-        
-    Hope to release this update as soon as possible
-*/
-
--- ALTER TABLE "${tableName}" DROP CONSTRAINT "<constraint_name>";`;
-	}
-}
-
-class PgAlterTableAlterColumnSetNotNullConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_set_notnull'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnSetNotNullStatement) {
-		const { tableName, columnName } = statement;
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET NOT NULL;`;
-	}
-}
-
-class PgAlterTableAlterColumnDropNotNullConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_alter_column_drop_notnull'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterColumnDropNotNullStatement) {
-		const { tableName, columnName } = statement;
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP NOT NULL;`;
-	}
-}
-
-// FK
-class PgCreateForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_reference' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonCreateReferenceStatement): string {
-		const {
-			name,
-			tableFrom,
-			tableTo,
-			columnsFrom,
-			columnsTo,
-			onDelete,
-			onUpdate,
-			schemaTo,
-		} = PgSquasher.unsquashFK(statement.data);
-		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
-		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
-		const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(',');
-		const toColumnsString = columnsTo.map((it) => `"${it}"`).join(',');
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${tableFrom}"`
-			: `"${tableFrom}"`;
-
-		const tableToNameWithSchema = schemaTo
-			? `"${schemaTo}"."${tableTo}"`
-			: `"${tableTo}"`;
-
-		const alterStatement =
-			`ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
-
-		return alterStatement;
-	}
-}
-
-class LibSQLCreateForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'create_reference'
-			&& dialect === 'turso'
-		);
-	}
-
-	convert(
-		statement: JsonCreateReferenceStatement,
-		json2?: SQLiteSchemaSquashed,
-		action?: 'push',
-	): string {
-		const { columnsFrom, columnsTo, tableFrom, onDelete, onUpdate, tableTo } = action === 'push'
-			? SQLiteSquasher.unsquashPushFK(statement.data)
-			: SQLiteSquasher.unsquashFK(statement.data);
-		const { columnDefault, columnNotNull, columnType } = statement;
-
-		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
-		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
-		const columnsDefaultValue = columnDefault
-			? ` DEFAULT ${columnDefault}`
-			: '';
-		const columnNotNullValue = columnNotNull ? ` NOT NULL` : '';
-		const columnTypeValue = columnType ? ` ${columnType}` : '';
-
-		const columnFrom = columnsFrom[0];
-		const columnTo = columnsTo[0];
-
-		return `ALTER TABLE \`${tableFrom}\` ALTER COLUMN "${columnFrom}" TO "${columnFrom}"${columnTypeValue}${columnNotNullValue}${columnsDefaultValue} REFERENCES ${tableTo}(${columnTo})${onDeleteStatement}${onUpdateStatement};`;
-	}
-}
-
-class MySqlCreateForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_reference' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonCreateReferenceStatement): string {
-		const {
-			name,
-			tableFrom,
-			tableTo,
-			columnsFrom,
-			columnsTo,
-			onDelete,
-			onUpdate,
-		} = MySqlSquasher.unsquashFK(statement.data);
-		const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : '';
-		const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : '';
-		const fromColumnsString = columnsFrom.map((it) => `\`${it}\``).join(',');
-		const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(',');
-
-		return `ALTER TABLE \`${tableFrom}\` ADD CONSTRAINT \`${name}\` FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
-	}
-}
-
-class PgAlterForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'alter_reference' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonAlterReferenceStatement): string {
-		const newFk = PgSquasher.unsquashFK(statement.data);
-		const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${oldFk.tableFrom}"`
-			: `"${oldFk.tableFrom}"`;
-
-		let sql = `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${oldFk.name}";\n`;
-
-		const onDeleteStatement = newFk.onDelete
-			? ` ON DELETE ${newFk.onDelete}`
-			: '';
-		const onUpdateStatement = newFk.onUpdate
-			? ` ON UPDATE ${newFk.onUpdate}`
-			: '';
-
-		const fromColumnsString = newFk.columnsFrom
-			.map((it) => `"${it}"`)
-			.join(',');
-		const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(',');
-
-		const tableFromNameWithSchema = oldFk.schemaTo
-			? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"`
-			: `"${oldFk.tableFrom}"`;
-
-		const tableToNameWithSchema = newFk.schemaTo
-			? `"${newFk.schemaTo}"."${newFk.tableFrom}"`
-			: `"${newFk.tableFrom}"`;
-
-		const alterStatement =
-			`ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
-
-		sql += alterStatement;
-		return sql;
-	}
-}
-
-class PgDeleteForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'delete_reference' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonDeleteReferenceStatement): string {
-		const tableFrom = statement.tableName; // delete fk from renamed table case
-		const { name } = PgSquasher.unsquashFK(statement.data);
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${tableFrom}"`
-			: `"${tableFrom}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name}";\n`;
-	}
-}
-
-class MySqlDeleteForeignKeyConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'delete_reference' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonDeleteReferenceStatement): string {
-		const tableFrom = statement.tableName; // delete fk from renamed table case
-		const { name } = MySqlSquasher.unsquashFK(statement.data);
-		return `ALTER TABLE \`${tableFrom}\` DROP FOREIGN KEY \`${name}\`;\n`;
-	}
-}
-
-class CreatePgIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_index_pg' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonPgCreateIndexStatement): string {
-		const {
-			name,
-			columns,
-			isUnique,
-			concurrently,
-			with: withMap,
-			method,
-			where,
-		} = statement.data;
-		// // since postgresql 9.5
-		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
-		const value = columns
-			.map(
-				(it) =>
-					`${it.isExpression ? it.expression : `"${it.expression}"`}${
-						it.opclass ? ` ${it.opclass}` : it.asc ? '' : ' DESC'
-					}${
-						(it.asc && it.nulls && it.nulls === 'last') || it.opclass
-							? ''
-							: ` NULLS ${it.nulls!.toUpperCase()}`
-					}`,
-			)
-			.join(',');
-
-		const tableNameWithSchema = statement.schema
-			? `"${statement.schema}"."${statement.tableName}"`
-			: `"${statement.tableName}"`;
-
-		function reverseLogic(mappedWith: Record<string, string>): string {
-			let reversedString = '';
-			for (const key in mappedWith) {
-				if (mappedWith.hasOwnProperty(key)) {
-					reversedString += `${key}=${mappedWith[key]},`;
-				}
-			}
-			reversedString = reversedString.slice(0, -1);
-			return reversedString;
-		}
-
-		return `CREATE ${indexPart}${
-			concurrently ? ' CONCURRENTLY' : ''
-		} "${name}" ON ${tableNameWithSchema} USING ${method} (${value})${
-			Object.keys(withMap!).length !== 0
-				? ` WITH (${reverseLogic(withMap!)})`
-				: ''
-		}${where ? ` WHERE ${where}` : ''};`;
-	}
-}
-
-class CreateMySqlIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_index' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonCreateIndexStatement): string {
-		// should be changed
-		const { name, columns, isUnique } = MySqlSquasher.unsquashIdx(
-			statement.data,
-		);
-		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
-
-		const uniqueString = columns
-			.map((it) => {
-				return statement.internal?.indexes
-					? statement.internal?.indexes[name]?.columns[it]?.isExpression
-						? it
-						: `\`${it}\``
-					: `\`${it}\``;
-			})
-			.join(',');
-
-		return `CREATE ${indexPart} \`${name}\` ON \`${statement.tableName}\` (${uniqueString});`;
-	}
-}
-
-export class CreateSingleStoreIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_index' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonCreateIndexStatement): string {
-		// should be changed
-		const { name, columns, isUnique } = SingleStoreSquasher.unsquashIdx(
-			statement.data,
-		);
-		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
-
-		const uniqueString = columns
-			.map((it) => {
-				return statement.internal?.indexes
-					? statement.internal?.indexes[name]?.columns[it]?.isExpression
-						? it
-						: `\`${it}\``
-					: `\`${it}\``;
-			})
-			.join(',');
-
-		return `CREATE ${indexPart} \`${name}\` ON \`${statement.tableName}\` (${uniqueString});`;
-	}
-}
-
-export class CreateSqliteIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_index' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(statement: JsonCreateIndexStatement): string {
-		// should be changed
-		const { name, columns, isUnique, where } = SQLiteSquasher.unsquashIdx(
-			statement.data,
-		);
-		// // since postgresql 9.5
-		const indexPart = isUnique ? 'UNIQUE INDEX' : 'INDEX';
-		const whereStatement = where ? ` WHERE ${where}` : '';
-		const uniqueString = columns
-			.map((it) => {
-				return statement.internal?.indexes
-					? statement.internal?.indexes[name]?.columns[it]?.isExpression
-						? it
-						: `\`${it}\``
-					: `\`${it}\``;
-			})
-			.join(',');
-		return `CREATE ${indexPart} \`${name}\` ON \`${statement.tableName}\` (${uniqueString})${whereStatement};`;
-	}
-}
-
-class PgDropIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_index' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonDropIndexStatement): string {
-		const { schema } = statement;
-		const { name } = PgSquasher.unsquashIdx(statement.data);
-
-		const indexNameWithSchema = schema ? `"${schema}"."${name}"` : `"${name}"`;
-
-		return `DROP INDEX ${indexNameWithSchema};`;
-	}
-}
-
-class PgCreateSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'create_schema' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonCreateSchema) {
-		const { name } = statement;
-		return `CREATE SCHEMA "${name}";\n`;
-	}
-}
-
-class PgRenameSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'rename_schema' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonRenameSchema) {
-		const { from, to } = statement;
-		return `ALTER SCHEMA "${from}" RENAME TO "${to}";\n`;
-	}
-}
-
-class PgDropSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_schema' && dialect === 'postgresql';
-	}
-
-	convert(statement: JsonCreateSchema) {
-		const { name } = statement;
-		return `DROP SCHEMA "${name}";\n`;
-	}
-}
-
-class PgAlterTableSetSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_set_schema' && dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterTableSetSchema) {
-		const { tableName, schemaFrom, schemaTo } = statement;
-
-		return `ALTER TABLE "${schemaFrom}"."${tableName}" SET SCHEMA "${schemaTo}";\n`;
-	}
-}
-
-class PgAlterTableSetNewSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_set_new_schema'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterTableSetNewSchema) {
-		const { tableName, to, from } = statement;
-
-		const tableNameWithSchema = from
-			? `"${from}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA "${to}";\n`;
-	}
-}
-
-class PgAlterTableRemoveFromSchemaConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'alter_table_remove_from_schema'
-			&& dialect === 'postgresql'
-		);
-	}
-
-	convert(statement: JsonAlterTableRemoveFromSchema) {
-		const { tableName, schema } = statement;
-
-		const tableNameWithSchema = schema
-			? `"${schema}"."${tableName}"`
-			: `"${tableName}"`;
-
-		return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA public;\n`;
-	}
-}
-
-export class SqliteDropIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_index' && (dialect === 'sqlite' || dialect === 'turso');
-	}
-
-	convert(statement: JsonDropIndexStatement): string {
-		const { name } = PgSquasher.unsquashIdx(statement.data);
-		return `DROP INDEX \`${name}\`;`;
-	}
-}
-
-class MySqlDropIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_index' && dialect === 'mysql';
-	}
-
-	convert(statement: JsonDropIndexStatement): string {
-		const { name } = MySqlSquasher.unsquashIdx(statement.data);
-		return `DROP INDEX \`${name}\` ON \`${statement.tableName}\`;`;
-	}
-}
-
-class SingleStoreDropIndexConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return statement.type === 'drop_index' && dialect === 'singlestore';
-	}
-
-	convert(statement: JsonDropIndexStatement): string {
-		const { name } = SingleStoreSquasher.unsquashIdx(statement.data);
-		return `DROP INDEX \`${name}\` ON \`${statement.tableName}\`;`;
-	}
-}
-
-class SQLiteRecreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'recreate_table' && dialect === 'sqlite'
-		);
-	}
-
-	convert(statement: JsonRecreateTableStatement): string | string[] {
-		const { tableName, columns, compositePKs, referenceData, checkConstraints } = statement;
-
-		const columnNames = columns.map((it) => `"${it.name}"`).join(', ');
-		const newTableName = `__new_${tableName}`;
-
-		const sqlStatements: string[] = [];
-
-		sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
-
-		// map all possible variants
-		const mappedCheckConstraints: string[] = checkConstraints.map((it) =>
-			it.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`)
-				.replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `'${newTableName}'.`)
-		);
-
-		// create new table
-		sqlStatements.push(
-			new SQLiteCreateTableConvertor().convert({
-				type: 'sqlite_create_table',
-				tableName: newTableName,
-				columns,
-				referenceData,
-				compositePKs,
-				checkConstraints: mappedCheckConstraints,
-			}),
-		);
-
-		// migrate data
-		sqlStatements.push(
-			`INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`,
-		);
-
-		// drop table
-		sqlStatements.push(
-			new SQLiteDropTableConvertor().convert({
-				type: 'drop_table',
-				tableName: tableName,
-				schema: '',
-			}),
-		);
-
-		// rename table
-		sqlStatements.push(
-			new SqliteRenameTableConvertor().convert({
-				fromSchema: '',
-				tableNameFrom: newTableName,
-				tableNameTo: tableName,
-				toSchema: '',
-				type: 'rename_table',
-			}),
-		);
-
-		sqlStatements.push(`PRAGMA foreign_keys=ON;`);
-
-		return sqlStatements;
-	}
-}
-
-class LibSQLRecreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'recreate_table'
-			&& dialect === 'turso'
-		);
-	}
-
-	convert(statement: JsonRecreateTableStatement): string[] {
-		const { tableName, columns, compositePKs, referenceData, checkConstraints } = statement;
-
-		const columnNames = columns.map((it) => `"${it.name}"`).join(', ');
-		const newTableName = `__new_${tableName}`;
-
-		const sqlStatements: string[] = [];
-
-		const mappedCheckConstraints: string[] = checkConstraints.map((it) =>
-			it.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`)
-				.replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `\`${newTableName}\`.`)
-		);
-
-		sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
-
-		// create new table
-		sqlStatements.push(
-			new SQLiteCreateTableConvertor().convert({
-				type: 'sqlite_create_table',
-				tableName: newTableName,
-				columns,
-				referenceData,
-				compositePKs,
-				checkConstraints: mappedCheckConstraints,
-			}),
-		);
-
-		// migrate data
-		sqlStatements.push(
-			`INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`,
-		);
-
-		// drop table
-		sqlStatements.push(
-			new SQLiteDropTableConvertor().convert({
-				type: 'drop_table',
-				tableName: tableName,
-				schema: '',
-			}),
-		);
-
-		// rename table
-		sqlStatements.push(
-			new SqliteRenameTableConvertor().convert({
-				fromSchema: '',
-				tableNameFrom: newTableName,
-				tableNameTo: tableName,
-				toSchema: '',
-				type: 'rename_table',
-			}),
-		);
-
-		sqlStatements.push(`PRAGMA foreign_keys=ON;`);
-
-		return sqlStatements;
-	}
-}
-
-class SingleStoreRecreateTableConvertor extends Convertor {
-	can(statement: JsonStatement, dialect: Dialect): boolean {
-		return (
-			statement.type === 'singlestore_recreate_table'
-			&& dialect === 'singlestore'
-		);
-	}
-
-	convert(statement: JsonRecreateSingleStoreTableStatement): string[] {
-		const { tableName, columns, compositePKs, uniqueConstraints } = statement;
-
-		const columnNames = columns.map((it) => `\`${it.name}\``).join(', ');
-		const newTableName = `__new_${tableName}`;
-
-		const sqlStatements: string[] = [];
-
-		// create new table
-		sqlStatements.push(
-			new SingleStoreCreateTableConvertor().convert({
-				type: 'create_table',
-				tableName: newTableName,
-				columns,
-				compositePKs,
-				uniqueConstraints,
-				schema: '',
-			}),
-		);
-
-		// migrate data
-		sqlStatements.push(
-			`INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`,
-		);
-
-		// drop table
-		sqlStatements.push(
-			new SingleStoreDropTableConvertor().convert({
-				type: 'drop_table',
-				tableName: tableName,
-				schema: '',
-			}),
-		);
-
-		// rename table
-		sqlStatements.push(
-			new SingleStoreRenameTableConvertor().convert({
-				fromSchema: '',
-				tableNameFrom: newTableName,
-				tableNameTo: tableName,
-				toSchema: '',
-				type: 'rename_table',
-			}),
-		);
-
-		return sqlStatements;
-	}
-}
-
-const convertors: Convertor[] = [];
-convertors.push(new PgCreateTableConvertor());
-convertors.push(new MySqlCreateTableConvertor());
-convertors.push(new SingleStoreCreateTableConvertor());
-convertors.push(new SingleStoreRecreateTableConvertor());
-convertors.push(new SQLiteCreateTableConvertor());
-convertors.push(new SQLiteRecreateTableConvertor());
-convertors.push(new LibSQLRecreateTableConvertor());
-
-convertors.push(new PgCreateViewConvertor());
-convertors.push(new PgDropViewConvertor());
-convertors.push(new PgRenameViewConvertor());
-convertors.push(new PgAlterViewSchemaConvertor());
-convertors.push(new PgAlterViewAddWithOptionConvertor());
-convertors.push(new PgAlterViewDropWithOptionConvertor());
-convertors.push(new PgAlterViewAlterTablespaceConvertor());
-convertors.push(new PgAlterViewAlterUsingConvertor());
-
-convertors.push(new MySqlCreateViewConvertor());
-convertors.push(new MySqlDropViewConvertor());
-convertors.push(new MySqlRenameViewConvertor());
-convertors.push(new MySqlAlterViewConvertor());
-
-convertors.push(new SqliteCreateViewConvertor());
-convertors.push(new SqliteDropViewConvertor());
-
-convertors.push(new CreateTypeEnumConvertor());
-convertors.push(new DropTypeEnumConvertor());
-convertors.push(new AlterTypeAddValueConvertor());
-convertors.push(new AlterTypeSetSchemaConvertor());
-convertors.push(new AlterRenameTypeConvertor());
-convertors.push(new AlterTypeDropValueConvertor());
-
-convertors.push(new CreatePgSequenceConvertor());
-convertors.push(new DropPgSequenceConvertor());
-convertors.push(new RenamePgSequenceConvertor());
-convertors.push(new MovePgSequenceConvertor());
-convertors.push(new AlterPgSequenceConvertor());
-
-convertors.push(new PgDropTableConvertor());
-convertors.push(new MySQLDropTableConvertor());
-convertors.push(new SingleStoreDropTableConvertor());
-convertors.push(new SQLiteDropTableConvertor());
-
-convertors.push(new PgRenameTableConvertor());
-convertors.push(new MySqlRenameTableConvertor());
-convertors.push(new SingleStoreRenameTableConvertor());
-convertors.push(new SqliteRenameTableConvertor());
-
-convertors.push(new PgAlterTableRenameColumnConvertor());
-convertors.push(new MySqlAlterTableRenameColumnConvertor());
-convertors.push(new SingleStoreAlterTableRenameColumnConvertor());
-convertors.push(new SQLiteAlterTableRenameColumnConvertor());
-
-convertors.push(new PgAlterTableDropColumnConvertor());
-convertors.push(new MySqlAlterTableDropColumnConvertor());
-convertors.push(new SingleStoreAlterTableDropColumnConvertor());
-convertors.push(new SQLiteAlterTableDropColumnConvertor());
-
-convertors.push(new PgAlterTableAddColumnConvertor());
-convertors.push(new MySqlAlterTableAddColumnConvertor());
-convertors.push(new SingleStoreAlterTableAddColumnConvertor());
-convertors.push(new SQLiteAlterTableAddColumnConvertor());
-
-convertors.push(new PgAlterTableAlterColumnSetTypeConvertor());
-
-convertors.push(new PgAlterTableAddUniqueConstraintConvertor());
-convertors.push(new PgAlterTableDropUniqueConstraintConvertor());
-
-convertors.push(new PgAlterTableAddCheckConstraintConvertor());
-convertors.push(new PgAlterTableDeleteCheckConstraintConvertor());
-convertors.push(new MySqlAlterTableAddCheckConstraintConvertor());
-convertors.push(new MySqlAlterTableDeleteCheckConstraintConvertor());
-
-convertors.push(new MySQLAlterTableAddUniqueConstraintConvertor());
-convertors.push(new MySQLAlterTableDropUniqueConstraintConvertor());
-
-convertors.push(new SingleStoreAlterTableAddUniqueConstraintConvertor());
-convertors.push(new SingleStoreAlterTableDropUniqueConstraintConvertor());
-
-convertors.push(new CreatePgIndexConvertor());
-convertors.push(new CreateMySqlIndexConvertor());
-convertors.push(new CreateSingleStoreIndexConvertor());
-convertors.push(new CreateSqliteIndexConvertor());
-
-convertors.push(new PgDropIndexConvertor());
-convertors.push(new SqliteDropIndexConvertor());
-convertors.push(new MySqlDropIndexConvertor());
-convertors.push(new SingleStoreDropIndexConvertor());
-
-convertors.push(new PgAlterTableAlterColumnSetPrimaryKeyConvertor());
-convertors.push(new PgAlterTableAlterColumnDropPrimaryKeyConvertor());
-convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
-convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
-convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
-convertors.push(new PgAlterTableAlterColumnDropDefaultConvertor());
-
-convertors.push(new PgAlterPolicyConvertor());
-convertors.push(new PgCreatePolicyConvertor());
-convertors.push(new PgDropPolicyConvertor());
-convertors.push(new PgRenamePolicyConvertor());
-
-convertors.push(new PgAlterIndPolicyConvertor());
-convertors.push(new PgCreateIndPolicyConvertor());
-convertors.push(new PgDropIndPolicyConvertor());
-convertors.push(new PgRenameIndPolicyConvertor());
-
-convertors.push(new PgEnableRlsConvertor());
-convertors.push(new PgDisableRlsConvertor());
-
-convertors.push(new PgDropRoleConvertor());
-convertors.push(new PgAlterRoleConvertor());
-convertors.push(new PgCreateRoleConvertor());
-convertors.push(new PgRenameRoleConvertor());
-
-/// generated
-convertors.push(new PgAlterTableAlterColumnSetExpressionConvertor());
-convertors.push(new PgAlterTableAlterColumnDropGeneratedConvertor());
-convertors.push(new PgAlterTableAlterColumnAlterrGeneratedConvertor());
-
-convertors.push(new MySqlAlterTableAlterColumnAlterrGeneratedConvertor());
-
-convertors.push(new SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor());
-
-convertors.push(new SqliteAlterTableAlterColumnDropGeneratedConvertor());
-convertors.push(new SqliteAlterTableAlterColumnAlterGeneratedConvertor());
-convertors.push(new SqliteAlterTableAlterColumnSetExpressionConvertor());
-
-convertors.push(new MySqlModifyColumn());
-convertors.push(new LibSQLModifyColumn());
-// convertors.push(new MySqlAlterTableAlterColumnSetDefaultConvertor());
-// convertors.push(new MySqlAlterTableAlterColumnDropDefaultConvertor());
-
-convertors.push(new SingleStoreModifyColumn());
-
-convertors.push(new PgCreateForeignKeyConvertor());
-convertors.push(new MySqlCreateForeignKeyConvertor());
-
-convertors.push(new PgAlterForeignKeyConvertor());
-
-convertors.push(new PgDeleteForeignKeyConvertor());
-convertors.push(new MySqlDeleteForeignKeyConvertor());
-
-convertors.push(new PgCreateSchemaConvertor());
-convertors.push(new PgRenameSchemaConvertor());
-convertors.push(new PgDropSchemaConvertor());
-convertors.push(new PgAlterTableSetSchemaConvertor());
-convertors.push(new PgAlterTableSetNewSchemaConvertor());
-convertors.push(new PgAlterTableRemoveFromSchemaConvertor());
-
-convertors.push(new LibSQLCreateForeignKeyConvertor());
-
-convertors.push(new PgAlterTableAlterColumnDropGenerated());
-convertors.push(new PgAlterTableAlterColumnSetGenerated());
-convertors.push(new PgAlterTableAlterColumnAlterGenerated());
-
-convertors.push(new PgAlterTableCreateCompositePrimaryKeyConvertor());
-convertors.push(new PgAlterTableDeleteCompositePrimaryKeyConvertor());
-convertors.push(new PgAlterTableAlterCompositePrimaryKeyConvertor());
-
-convertors.push(new MySqlAlterTableDeleteCompositePrimaryKeyConvertor());
-convertors.push(new MySqlAlterTableDropPk());
-convertors.push(new MySqlAlterTableCreateCompositePrimaryKeyConvertor());
-convertors.push(new MySqlAlterTableAddPk());
-convertors.push(new MySqlAlterTableAlterCompositePrimaryKeyConvertor());
-
-convertors.push(new SingleStoreAlterTableDropPk());
-convertors.push(new SingleStoreAlterTableAddPk());
-
-export function fromJson(
-	statements: JsonStatement[],
-	dialect: Dialect,
-	action?: 'push',
-	json2?: SQLiteSchemaSquashed,
-) {
-	const result = statements
-		.flatMap((statement) => {
-			const filtered = convertors.filter((it) => {
-				return it.can(statement, dialect);
-			});
-
-			const convertor = filtered.length === 1 ? filtered[0] : undefined;
-
-			if (!convertor) {
-				return '';
-			}
-
-			return convertor.convert(statement, json2, action);
-		})
-		.filter((it) => it !== '');
-	return result;
-}
-
-// blog.yo1.dog/updating-enum-values-in-postgresql-the-safe-and-easy-way/
-// test case for enum altering
-https: `
-create table users (
-	id int,
-    name character varying(128)
-);
-
-create type venum as enum('one', 'two', 'three');
-alter table users add column typed venum;
-
-insert into users(id, name, typed) values (1, 'name1', 'one');
-insert into users(id, name, typed) values (2, 'name2', 'two');
-insert into users(id, name, typed) values (3, 'name3', 'three');
-
-alter type venum rename to __venum;
-create type venum as enum ('one', 'two', 'three', 'four', 'five');
-
-ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;
-
-insert into users(id, name, typed) values (4, 'name4', 'four');
-insert into users(id, name, typed) values (5, 'name5', 'five');
-
-drop type __venum;
-`;
diff --git a/drizzle-kit/src/statementCombiner.ts b/drizzle-kit/src/statementCombiner.ts
deleted file mode 100644
index 7d84a2aa84..0000000000
--- a/drizzle-kit/src/statementCombiner.ts
+++ /dev/null
@@ -1,597 +0,0 @@
-import {
-	JsonCreateIndexStatement,
-	JsonRecreateTableStatement,
-	JsonStatement,
-	prepareCreateIndexesJson,
-} from './jsonStatements';
-import { SingleStoreSchemaSquashed } from './serializer/singlestoreSchema';
-import { SQLiteSchemaSquashed, SQLiteSquasher } from './serializer/sqliteSchema';
-
-export const prepareLibSQLRecreateTable = (
-	table: SQLiteSchemaSquashed['tables'][keyof SQLiteSchemaSquashed['tables']],
-	action?: 'push',
-): (JsonRecreateTableStatement | JsonCreateIndexStatement)[] => {
-	const { name, columns, uniqueConstraints, indexes, checkConstraints } = table;
-
-	const composites: string[][] = Object.values(table.compositePrimaryKeys).map(
-		(it) => SQLiteSquasher.unsquashPK(it),
-	);
-
-	const references: string[] = Object.values(table.foreignKeys);
-	const fks = references.map((it) =>
-		action === 'push' ? SQLiteSquasher.unsquashPushFK(it) : SQLiteSquasher.unsquashFK(it)
-	);
-
-	const statements: (JsonRecreateTableStatement | JsonCreateIndexStatement)[] = [
-		{
-			type: 'recreate_table',
-			tableName: name,
-			columns: Object.values(columns),
-			compositePKs: composites,
-			referenceData: fks,
-			uniqueConstraints: Object.values(uniqueConstraints),
-			checkConstraints: Object.values(checkConstraints),
-		},
-	];
-
-	if (Object.keys(indexes).length) {
-		statements.push(...prepareCreateIndexesJson(name, '', indexes));
-	}
-	return statements;
-};
-
-export const prepareSQLiteRecreateTable = (
-	table: SQLiteSchemaSquashed['tables'][keyof SQLiteSchemaSquashed['tables']],
-	action?: 'push',
-): JsonStatement[] => {
-	const { name, columns, uniqueConstraints, indexes, checkConstraints } = table;
-
-	const composites: string[][] = Object.values(table.compositePrimaryKeys).map(
-		(it) => SQLiteSquasher.unsquashPK(it),
-	);
-
-	const references: string[] = Object.values(table.foreignKeys);
-	const fks = references.map((it) =>
-		action === 'push' ? SQLiteSquasher.unsquashPushFK(it) : SQLiteSquasher.unsquashFK(it)
-	);
-
-	const statements: JsonStatement[] = [
-		{
-			type: 'recreate_table',
-			tableName: name,
-			columns: Object.values(columns),
-			compositePKs: composites,
-			referenceData: fks,
-			uniqueConstraints: Object.values(uniqueConstraints),
-			checkConstraints: Object.values(checkConstraints),
-		},
-	];
-
-	if (Object.keys(indexes).length) {
-		statements.push(...prepareCreateIndexesJson(name, '', indexes));
-	}
-	return statements;
-};
-
-export const libSQLCombineStatements = (
-	statements: JsonStatement[],
-	json2: SQLiteSchemaSquashed,
-	action?: 'push',
-) => {
-	// const tablesContext: Record<string, string[]> = {};
-	const newStatements: Record<string, JsonStatement[]> = {};
-	for (const statement of statements) {
-		if (
-			statement.type === 'alter_table_alter_column_drop_autoincrement'
-			|| statement.type === 'alter_table_alter_column_set_autoincrement'
-			|| statement.type === 'alter_table_alter_column_drop_pk'
-			|| statement.type === 'alter_table_alter_column_set_pk'
-			|| statement.type === 'create_composite_pk'
-			|| statement.type === 'alter_composite_pk'
-			|| statement.type === 'delete_composite_pk'
-			|| statement.type === 'create_check_constraint'
-			|| statement.type === 'delete_check_constraint'
-		) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (
-			statement.type === 'alter_table_alter_column_set_type'
-			|| statement.type === 'alter_table_alter_column_drop_notnull'
-			|| statement.type === 'alter_table_alter_column_set_notnull'
-			|| statement.type === 'alter_table_alter_column_set_default'
-			|| statement.type === 'alter_table_alter_column_drop_default'
-		) {
-			const { tableName, columnName, columnPk } = statement;
-
-			const columnIsPartOfForeignKey = Object.values(
-				json2.tables[tableName].foreignKeys,
-			).some((it) => {
-				const unsquashFk = action === 'push' ? SQLiteSquasher.unsquashPushFK(it) : SQLiteSquasher.unsquashFK(it);
-
-				return (
-					unsquashFk.columnsFrom.includes(columnName)
-				);
-			});
-
-			const statementsForTable = newStatements[tableName];
-
-			if (
-				!statementsForTable && (columnIsPartOfForeignKey || columnPk)
-			) {
-				newStatements[tableName] = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			if (
-				statementsForTable && (columnIsPartOfForeignKey || columnPk)
-			) {
-				if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-					const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-					const preparedStatements = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-					if (wasRename) {
-						newStatements[tableName].push(...preparedStatements);
-					} else {
-						newStatements[tableName] = preparedStatements;
-					}
-				}
-				continue;
-			}
-			if (
-				statementsForTable && !(columnIsPartOfForeignKey || columnPk)
-			) {
-				if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-					newStatements[tableName].push(statement);
-				}
-				continue;
-			}
-
-			newStatements[tableName] = [statement];
-
-			continue;
-		}
-
-		if (statement.type === 'create_reference') {
-			const tableName = statement.tableName;
-
-			const data = action === 'push'
-				? SQLiteSquasher.unsquashPushFK(statement.data)
-				: SQLiteSquasher.unsquashFK(statement.data);
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = statement.isMulticolumn
-					? prepareLibSQLRecreateTable(json2.tables[tableName], action)
-					: [statement];
-
-				continue;
-			}
-
-			// if add column with reference -> skip create_reference statement
-			if (
-				!statement.isMulticolumn
-				&& statementsForTable.some((st) =>
-					st.type === 'sqlite_alter_table_add_column' && st.column.name === data.columnsFrom[0]
-				)
-			) {
-				continue;
-			}
-
-			if (statement.isMulticolumn) {
-				if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-					const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-					const preparedStatements = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-					if (wasRename) {
-						newStatements[tableName].push(...preparedStatements);
-					} else {
-						newStatements[tableName] = preparedStatements;
-					}
-
-					continue;
-				}
-
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				newStatements[tableName].push(statement);
-			}
-
-			continue;
-		}
-
-		if (statement.type === 'delete_reference') {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (statement.type === 'sqlite_alter_table_add_column' && statement.column.primaryKey) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareLibSQLRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		const tableName = statement.type === 'rename_table'
-			? statement.tableNameTo
-			: (statement as { tableName: string }).tableName;
-		const statementsForTable = newStatements[tableName];
-
-		if (!statementsForTable) {
-			newStatements[tableName] = [statement];
-			continue;
-		}
-
-		if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-			newStatements[tableName].push(statement);
-		}
-	}
-
-	const combinedStatements = Object.values(newStatements).flat();
-	const renamedTables = combinedStatements.filter((it) => it.type === 'rename_table');
-	const renamedColumns = combinedStatements.filter((it) => it.type === 'alter_table_rename_column');
-
-	const rest = combinedStatements.filter((it) => it.type !== 'rename_table' && it.type !== 'alter_table_rename_column');
-
-	return [...renamedTables, ...renamedColumns, ...rest];
-};
-
-export const sqliteCombineStatements = (
-	statements: JsonStatement[],
-	json2: SQLiteSchemaSquashed,
-	action?: 'push',
-) => {
-	// const tablesContext: Record<string, string[]> = {};
-	const newStatements: Record<string, JsonStatement[]> = {};
-	for (const statement of statements) {
-		if (
-			statement.type === 'alter_table_alter_column_set_type'
-			|| statement.type === 'alter_table_alter_column_set_default'
-			|| statement.type === 'alter_table_alter_column_drop_default'
-			|| statement.type === 'alter_table_alter_column_set_notnull'
-			|| statement.type === 'alter_table_alter_column_drop_notnull'
-			|| statement.type === 'alter_table_alter_column_drop_autoincrement'
-			|| statement.type === 'alter_table_alter_column_set_autoincrement'
-			|| statement.type === 'alter_table_alter_column_drop_pk'
-			|| statement.type === 'alter_table_alter_column_set_pk'
-			|| statement.type === 'delete_reference'
-			|| statement.type === 'alter_reference'
-			|| statement.type === 'create_composite_pk'
-			|| statement.type === 'alter_composite_pk'
-			|| statement.type === 'delete_composite_pk'
-			|| statement.type === 'create_unique_constraint'
-			|| statement.type === 'delete_unique_constraint'
-			|| statement.type === 'create_check_constraint'
-			|| statement.type === 'delete_check_constraint'
-		) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (statement.type === 'sqlite_alter_table_add_column' && statement.column.primaryKey) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (statement.type === 'create_reference') {
-			const tableName = statement.tableName;
-
-			const data = action === 'push'
-				? SQLiteSquasher.unsquashPushFK(statement.data)
-				: SQLiteSquasher.unsquashFK(statement.data);
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-				continue;
-			}
-
-			// if add column with reference -> skip create_reference statement
-			if (
-				data.columnsFrom.length === 1
-				&& statementsForTable.some((st) =>
-					st.type === 'sqlite_alter_table_add_column' && st.column.name === data.columnsFrom[0]
-				)
-			) {
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareSQLiteRecreateTable(json2.tables[tableName], action);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		const tableName = statement.type === 'rename_table'
-			? statement.tableNameTo
-			: (statement as { tableName: string }).tableName;
-
-		const statementsForTable = newStatements[tableName];
-
-		if (!statementsForTable) {
-			newStatements[tableName] = [statement];
-			continue;
-		}
-
-		if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-			newStatements[tableName].push(statement);
-		}
-	}
-
-	const combinedStatements = Object.values(newStatements).flat();
-
-	const renamedTables = combinedStatements.filter((it) => it.type === 'rename_table');
-	const renamedColumns = combinedStatements.filter((it) => it.type === 'alter_table_rename_column');
-
-	const rest = combinedStatements.filter((it) => it.type !== 'rename_table' && it.type !== 'alter_table_rename_column');
-
-	return [...renamedTables, ...renamedColumns, ...rest];
-};
-
-export const prepareSingleStoreRecreateTable = (
-	table: SingleStoreSchemaSquashed['tables'][keyof SingleStoreSchemaSquashed['tables']],
-): JsonStatement[] => {
-	const { name, columns, uniqueConstraints, indexes, compositePrimaryKeys } = table;
-
-	const composites: string[] = Object.values(compositePrimaryKeys);
-
-	const statements: JsonStatement[] = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: name,
-			columns: Object.values(columns),
-			compositePKs: composites,
-			uniqueConstraints: Object.values(uniqueConstraints),
-		},
-	];
-
-	if (Object.keys(indexes).length) {
-		statements.push(...prepareCreateIndexesJson(name, '', indexes));
-	}
-	return statements;
-};
-
-export const singleStoreCombineStatements = (
-	statements: JsonStatement[],
-	json2: SingleStoreSchemaSquashed,
-) => {
-	const newStatements: Record<string, JsonStatement[]> = {};
-
-	for (const statement of statements) {
-		if (
-			statement.type === 'alter_table_alter_column_set_type'
-			|| statement.type === 'alter_table_alter_column_set_notnull'
-			|| statement.type === 'alter_table_alter_column_drop_notnull'
-			|| statement.type === 'alter_table_alter_column_drop_autoincrement'
-			|| statement.type === 'alter_table_alter_column_set_autoincrement'
-			|| statement.type === 'alter_table_alter_column_drop_pk'
-			|| statement.type === 'alter_table_alter_column_set_pk'
-			|| statement.type === 'create_composite_pk'
-			|| statement.type === 'alter_composite_pk'
-			|| statement.type === 'delete_composite_pk'
-		) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) =>
-					type === 'rename_table' || type === 'alter_table_rename_column'
-				);
-				const preparedStatements = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (
-			(statement.type === 'alter_table_alter_column_drop_default'
-				|| statement.type === 'alter_table_alter_column_set_default') && statement.columnNotNull
-		) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		if (statement.type === 'alter_table_add_column' && statement.column.primaryKey) {
-			const tableName = statement.tableName;
-
-			const statementsForTable = newStatements[tableName];
-
-			if (!statementsForTable) {
-				newStatements[tableName] = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-				continue;
-			}
-
-			if (!statementsForTable.some(({ type }) => type === 'recreate_table')) {
-				const wasRename = statementsForTable.some(({ type }) => type === 'rename_table');
-				const preparedStatements = prepareSingleStoreRecreateTable(json2.tables[tableName]);
-
-				if (wasRename) {
-					newStatements[tableName].push(...preparedStatements);
-				} else {
-					newStatements[tableName] = preparedStatements;
-				}
-
-				continue;
-			}
-
-			continue;
-		}
-
-		const tableName = statement.type === 'rename_table'
-			? statement.tableNameTo
-			: (statement as { tableName: string }).tableName;
-
-		const statementsForTable = newStatements[tableName];
-
-		if (!statementsForTable) {
-			newStatements[tableName] = [statement];
-			continue;
-		}
-
-		if (!statementsForTable.some(({ type }) => type === 'singlestore_recreate_table')) {
-			newStatements[tableName].push(statement);
-		}
-	}
-
-	const combinedStatements = Object.values(newStatements).flat();
-
-	const renamedTables = combinedStatements.filter((it) => it.type === 'rename_table');
-	const renamedColumns = combinedStatements.filter((it) => it.type === 'alter_table_rename_column');
-
-	const rest = combinedStatements.filter((it) => it.type !== 'rename_table' && it.type !== 'alter_table_rename_column');
-
-	return [...renamedTables, ...renamedColumns, ...rest];
-};
diff --git a/drizzle-kit/src/utils.ts b/drizzle-kit/src/utils.ts
deleted file mode 100644
index 1ee5f9d9a4..0000000000
--- a/drizzle-kit/src/utils.ts
+++ /dev/null
@@ -1,373 +0,0 @@
-import type { RunResult } from 'better-sqlite3';
-import chalk from 'chalk';
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { parse } from 'url';
-import type { NamedWithSchema } from './cli/commands/migrate';
-import { info } from './cli/views';
-import { assertUnreachable, snapshotVersion } from './global';
-import type { Dialect } from './schemaValidator';
-import { backwardCompatibleGelSchema } from './serializer/gelSchema';
-import { backwardCompatibleMysqlSchema } from './serializer/mysqlSchema';
-import { backwardCompatiblePgSchema } from './serializer/pgSchema';
-import { backwardCompatibleSingleStoreSchema } from './serializer/singlestoreSchema';
-import { backwardCompatibleSqliteSchema } from './serializer/sqliteSchema';
-import type { ProxyParams } from './serializer/studio';
-
-export type Proxy = (params: ProxyParams) => Promise<any[]>;
-
-export type SqliteProxy = {
-	proxy: (params: ProxyParams) => Promise<any[] | RunResult>;
-};
-
-export type DB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-};
-
-export type SQLiteDB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-	run(query: string): Promise<void>;
-};
-
-export type LibSQLDB = {
-	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
-	run(query: string): Promise<void>;
-	batchWithPragma?(queries: string[]): Promise<void>;
-};
-
-export const copy = <T>(it: T): T => {
-	return JSON.parse(JSON.stringify(it));
-};
-
-export const objectValues = <T extends object>(obj: T): Array<T[keyof T]> => {
-	return Object.values(obj);
-};
-
-export const assertV1OutFolder = (out: string) => {
-	if (!existsSync(out)) return;
-
-	const oldMigrationFolders = readdirSync(out).filter(
-		(it) => it.length === 14 && /^\d+$/.test(it),
-	);
-
-	if (oldMigrationFolders.length > 0) {
-		console.log(
-			`Your migrations folder format is outdated, please run ${
-				chalk.green.bold(
-					`drizzle-kit up`,
-				)
-			}`,
-		);
-		process.exit(1);
-	}
-};
-
-export type Journal = {
-	version: string;
-	dialect: Dialect;
-	entries: {
-		idx: number;
-		version: string;
-		when: number;
-		tag: string;
-		breakpoints: boolean;
-	}[];
-};
-
-export const dryJournal = (dialect: Dialect): Journal => {
-	return {
-		version: snapshotVersion,
-		dialect,
-		entries: [],
-	};
-};
-
-// export const preparePushFolder = (dialect: Dialect) => {
-//   const out = ".drizzle";
-//   let snapshot: string = "";
-//   if (!existsSync(join(out))) {
-//     mkdirSync(out);
-//     snapshot = JSON.stringify(dryJournal(dialect));
-//   } else {
-//     snapshot = readdirSync(out)[0];
-//   }
-
-//   return { snapshot };
-// };
-
-export const prepareOutFolder = (out: string, dialect: Dialect) => {
-	const meta = join(out, 'meta');
-	const journalPath = join(meta, '_journal.json');
-
-	if (!existsSync(join(out, 'meta'))) {
-		mkdirSync(meta, { recursive: true });
-		writeFileSync(journalPath, JSON.stringify(dryJournal(dialect)));
-	}
-
-	const journal = JSON.parse(readFileSync(journalPath).toString());
-
-	const snapshots = readdirSync(meta)
-		.filter((it) => !it.startsWith('_'))
-		.map((it) => join(meta, it));
-
-	snapshots.sort();
-	return { meta, snapshots, journal };
-};
-
-const validatorForDialect = (dialect: Dialect) => {
-	switch (dialect) {
-		case 'postgresql':
-			return { validator: backwardCompatiblePgSchema, version: 7 };
-		case 'sqlite':
-			return { validator: backwardCompatibleSqliteSchema, version: 6 };
-		case 'turso':
-			return { validator: backwardCompatibleSqliteSchema, version: 6 };
-		case 'mysql':
-			return { validator: backwardCompatibleMysqlSchema, version: 5 };
-		case 'singlestore':
-			return { validator: backwardCompatibleSingleStoreSchema, version: 1 };
-		case 'gel':
-			return { validator: backwardCompatibleGelSchema, version: 1 };
-	}
-};
-
-export const validateWithReport = (snapshots: string[], dialect: Dialect) => {
-	// ✅ check if drizzle-kit can handle snapshot version
-	// ✅ check if snapshot is of the last version
-	// ✅ check if id of the snapshot is valid
-	// ✅ collect {} of prev id -> snapshotName[], if there's more than one - tell about collision
-	const { validator, version } = validatorForDialect(dialect);
-
-	const result = snapshots.reduce(
-		(accum, it) => {
-			const raw = JSON.parse(readFileSync(`./${it}`).toString());
-
-			accum.rawMap[it] = raw;
-
-			if (raw['version'] && Number(raw['version']) > version) {
-				console.log(
-					info(
-						`${it} snapshot is of unsupported version, please update drizzle-kit`,
-					),
-				);
-				process.exit(0);
-			}
-
-			const result = validator.safeParse(raw);
-			if (!result.success) {
-				accum.malformed.push(it);
-				return accum;
-			}
-
-			const snapshot = result.data;
-			if (snapshot.version !== String(version)) {
-				accum.nonLatest.push(it);
-				return accum;
-			}
-
-			// only if latest version here
-			const idEntry = accum.idsMap[snapshot['prevId']] ?? {
-				parent: it,
-				snapshots: [],
-			};
-			idEntry.snapshots.push(it);
-			accum.idsMap[snapshot['prevId']] = idEntry;
-
-			return accum;
-		},
-		{
-			malformed: [],
-			nonLatest: [],
-			idToNameMap: {},
-			idsMap: {},
-			rawMap: {},
-		} as {
-			malformed: string[];
-			nonLatest: string[];
-			idsMap: Record<string, { parent: string; snapshots: string[] }>;
-			rawMap: Record<string, any>;
-		},
-	);
-
-	return result;
-};
-
-export const prepareMigrationFolder = (
-	outFolder: string = 'drizzle',
-	dialect: Dialect,
-) => {
-	const { snapshots, journal } = prepareOutFolder(outFolder, dialect);
-	const report = validateWithReport(snapshots, dialect);
-	if (report.nonLatest.length > 0) {
-		console.log(
-			report.nonLatest
-				.map((it) => {
-					return `${it}/snapshot.json is not of the latest version`;
-				})
-				.concat(`Run ${chalk.green.bold(`drizzle-kit up`)}`)
-				.join('\n'),
-		);
-		process.exit(0);
-	}
-
-	if (report.malformed.length) {
-		const message = report.malformed
-			.map((it) => {
-				return `${it} data is malformed`;
-			})
-			.join('\n');
-		console.log(message);
-	}
-
-	const collisionEntries = Object.entries(report.idsMap).filter(
-		(it) => it[1].snapshots.length > 1,
-	);
-
-	const message = collisionEntries
-		.map((it) => {
-			const data = it[1];
-			return `[${
-				data.snapshots.join(
-					', ',
-				)
-			}] are pointing to a parent snapshot: ${data.parent}/snapshot.json which is a collision.`;
-		})
-		.join('\n')
-		.trim();
-	if (message) {
-		console.log(chalk.red.bold('Error:'), message);
-	}
-
-	const abort = report.malformed.length!! || collisionEntries.length > 0;
-
-	if (abort) {
-		process.exit(0);
-	}
-
-	return { snapshots, journal };
-};
-
-export const prepareMigrationMeta = (
-	schemas: { from: string; to: string }[],
-	tables: { from: NamedWithSchema; to: NamedWithSchema }[],
-	columns: {
-		from: { table: string; schema: string; column: string };
-		to: { table: string; schema: string; column: string };
-	}[],
-) => {
-	const _meta = {
-		schemas: {} as Record<string, string>,
-		tables: {} as Record<string, string>,
-		columns: {} as Record<string, string>,
-	};
-
-	schemas.forEach((it) => {
-		const from = schemaRenameKey(it.from);
-		const to = schemaRenameKey(it.to);
-		_meta.schemas[from] = to;
-	});
-	tables.forEach((it) => {
-		const from = tableRenameKey(it.from);
-		const to = tableRenameKey(it.to);
-		_meta.tables[from] = to;
-	});
-
-	columns.forEach((it) => {
-		const from = columnRenameKey(it.from.table, it.from.schema, it.from.column);
-		const to = columnRenameKey(it.to.table, it.to.schema, it.to.column);
-		_meta.columns[from] = to;
-	});
-
-	return _meta;
-};
-
-export const schemaRenameKey = (it: string) => {
-	return it;
-};
-
-export const tableRenameKey = (it: NamedWithSchema) => {
-	const out = it.schema ? `"${it.schema}"."${it.name}"` : `"${it.name}"`;
-	return out;
-};
-
-export const columnRenameKey = (
-	table: string,
-	schema: string,
-	column: string,
-) => {
-	const out = schema
-		? `"${schema}"."${table}"."${column}"`
-		: `"${table}"."${column}"`;
-	return out;
-};
-
-export const kloudMeta = () => {
-	return {
-		pg: [5],
-		mysql: [] as number[],
-		sqlite: [] as number[],
-	};
-};
-
-export const normaliseSQLiteUrl = (
-	it: string,
-	type: 'libsql' | 'better-sqlite',
-) => {
-	if (type === 'libsql') {
-		if (it.startsWith('file:')) {
-			return it;
-		}
-		try {
-			const url = parse(it);
-			if (url.protocol === null) {
-				return `file:${it}`;
-			}
-			return it;
-		} catch (e) {
-			return `file:${it}`;
-		}
-	}
-
-	if (type === 'better-sqlite') {
-		if (it.startsWith('file:')) {
-			return it.substring(5);
-		}
-
-		return it;
-	}
-
-	assertUnreachable(type);
-};
-
-export const normalisePGliteUrl = (
-	it: string,
-) => {
-	if (it.startsWith('file:')) {
-		return it.substring(5);
-	}
-
-	return it;
-};
-
-export function isPgArrayType(sqlType: string) {
-	return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
-}
-
-export function findAddedAndRemoved(columnNames1: string[], columnNames2: string[]) {
-	const set1 = new Set(columnNames1);
-	const set2 = new Set(columnNames2);
-
-	const addedColumns = columnNames2.filter((it) => !set1.has(it));
-	const removedColumns = columnNames1.filter((it) => !set2.has(it));
-
-	return { addedColumns, removedColumns };
-}
-
-export function escapeSingleQuotes(str: string) {
-	return str.replace(/'/g, "''");
-}
-
-export function unescapeSingleQuotes(str: string, ignoreFirstAndLastChar: boolean) {
-	const regex = ignoreFirstAndLastChar ? /(?<!^)'(?!$)/g : /'/g;
-	return str.replace(/''/g, "'").replace(regex, "\\'");
-}
diff --git a/drizzle-kit/src/utils/certs.ts b/drizzle-kit/src/utils/certs.ts
index 873b4e6656..3450ed1655 100644
--- a/drizzle-kit/src/utils/certs.ts
+++ b/drizzle-kit/src/utils/certs.ts
@@ -1,10 +1,12 @@
 import envPaths from 'env-paths';
 import { mkdirSync } from 'fs';
 import { access, readFile } from 'fs/promises';
-import { exec, ExecOptions } from 'node:child_process';
+import type { ExecOptions } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { X509Certificate } from 'node:crypto';
 import { join } from 'path';
 
-export function runCommand(command: string, options: ExecOptions = {}) {
+function runCommand(command: string, options: ExecOptions = {}) {
 	return new Promise<{ exitCode: number }>((resolve) => {
 		exec(command, options, (error) => {
 			return resolve({ exitCode: error?.code ?? 0 });
@@ -12,6 +14,16 @@ export function runCommand(command: string, options: ExecOptions = {}) {
 	});
 }
 
+function isCertValid(certPem: string): boolean {
+	try {
+		const cert = new X509Certificate(certPem);
+		const now = new Date();
+		return now >= new Date(cert.validFrom) && now <= new Date(cert.validTo);
+	} catch {
+		return false;
+	}
+}
+
 export const certs = async () => {
 	const res = await runCommand('mkcert --help');
 
@@ -20,20 +32,32 @@ export const certs = async () => {
 			suffix: '',
 		});
 
-		// create ~/.local/share/drizzle-studio
+		// create the directory if it doesn't exist
+		// linux: ~/.local/share/drizzle-studio
+		// macos: ~/Library/Application\ Support/drizzle-studio
+		// windows: %LOCALAPPDATA%\drizzle-studio\Data
 		mkdirSync(p.data, { recursive: true });
 
-		// ~/.local/share/drizzle-studio
 		const keyPath = join(p.data, 'localhost-key.pem');
 		const certPath = join(p.data, 'localhost.pem');
 
+		let needsCreate = false;
 		try {
 			// check if the files exist
 			await Promise.all([access(keyPath), access(certPath)]);
-		} catch (e) {
-			// if not create them
+			// check if the cert is still valid
+			const certPem = await readFile(certPath, { encoding: 'utf-8' });
+			if (!isCertValid(certPem)) {
+				needsCreate = true;
+			}
+		} catch {
+			needsCreate = true;
+		}
+
+		if (needsCreate) {
 			await runCommand(`mkcert localhost`, { cwd: p.data });
 		}
+
 		const [key, cert] = await Promise.all([
 			readFile(keyPath, { encoding: 'utf-8' }),
 			readFile(certPath, { encoding: 'utf-8' }),
diff --git a/drizzle-kit/src/utils/index.ts b/drizzle-kit/src/utils/index.ts
new file mode 100644
index 0000000000..f7670edf02
--- /dev/null
+++ b/drizzle-kit/src/utils/index.ts
@@ -0,0 +1,343 @@
+import type { ProxyParams } from '../cli/commands/studio';
+import type { Dialect } from './schemaValidator';
+
+export const originUUID = '00000000-0000-0000-0000-000000000000';
+export const BREAKPOINT = '--> statement-breakpoint\n';
+
+export function assertUnreachable(_x: never | undefined): never {
+	throw new Error("Didn't expect to get here");
+}
+
+// don't fail in runtime, types only
+export function softAssertUnreachable(_x: never) {
+	return null as never;
+}
+
+export const mapEntries = <T>(
+	obj: Record<string, T>,
+	map: (key: string, value: T) => [string, T],
+): Record<string, T> => {
+	const result = Object.fromEntries(
+		Object.entries(obj).map(([key, val]) => {
+			const [newKey, newVal] = map(key, val);
+			return [newKey, newVal];
+		}),
+	);
+	return result;
+};
+
+export type Proxy = (params: ProxyParams) => Promise<any[]>;
+export type TransactionProxy = (queries: { sql: string; method?: ProxyParams['method'] }[]) => Promise<any[]>;
+export type QueriesTimings = {
+	tcpHandshake: number;
+	tlsHandshake: number | null;
+	dbHandshake: number | null;
+	queries: {
+		networkLatencyBefore: number;
+		planning: number | null;
+		execution: number;
+		networkLatencyAfter: number;
+		dataDownload: number;
+		dataParse: number;
+		total: number;
+		errorMargin: number;
+		dataSize: number;
+	}[];
+};
+export type BenchmarkProxy = (
+	query: { sql: string; params?: any[]; method?: ProxyParams['method'] },
+	repeats: number,
+) => Promise<QueriesTimings>;
+
+export type DB = {
+	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
+};
+
+export interface SQLiteClient {
+	query: <T extends any = any>(sql: string, params?: any[]) => Promise<T[]>;
+	run(query: string): Promise<void>;
+	batch(statements: string[]): Promise<void>;
+}
+export interface SQLiteDB extends SQLiteClient {}
+export interface LibSQLDB extends SQLiteClient {}
+
+export type Simplify<T> =
+	& {
+		[K in keyof T]: T[K];
+	}
+	& {};
+
+export type Journal = {
+	version: string;
+	dialect: Dialect;
+	entries: {
+		idx: number;
+		version: string;
+		when: number;
+		tag: string;
+		breakpoints: boolean;
+	}[];
+};
+
+export const kloudMeta = () => {
+	return {
+		pg: [5],
+		mysql: [] as number[],
+		sqlite: [] as number[],
+	};
+};
+
+export function convertBigIntToMilliseconds(bigInt: bigint): number {
+	return Number(bigInt / BigInt(1_000_000));
+}
+
+export function escapeSingleQuotes(str: string) {
+	return str.replace(/'/g, "''");
+}
+
+export function unescapeSingleQuotes(str: string, ignoreFirstAndLastChar: boolean) {
+	const regex = ignoreFirstAndLastChar ? /(?<!^)'(?!$)/g : /'/g;
+	return str.replace(/''/g, "'").replace(regex, "\\'");
+}
+
+export const prepareMigrationRenames = (
+	renames: {
+		from: { schema?: string; table?: string; name: string };
+		to: { schema?: string; table?: string; name: string };
+	}[],
+) => {
+	return renames.map((it) => {
+		const schema1 = it.from.schema ? `${it.from.schema}.` : '';
+		const schema2 = it.to.schema ? `${it.to.schema}.` : '';
+
+		const table1 = it.from.table ? `${it.from.table}.` : '';
+		const table2 = it.to.table ? `${it.to.table}.` : '';
+
+		return `${schema1}${table1}${it.from.name}->${schema2}${table2}${it.to.name}`;
+	});
+};
+
+export type ArrayValue = unknown | null | ArrayValue[];
+
+export function stringifyArray(
+	value: ArrayValue,
+	mode: 'sql' | 'ts' | 'geometry-sql',
+	mapCallback: (v: any | null, depth: number) => string,
+	depth: number = 0,
+): string {
+	if (!Array.isArray(value)) return mapCallback(value, depth);
+	depth += 1;
+	const res = value.map((e) => {
+		if (Array.isArray(e)) return stringifyArray(e, mode, mapCallback, depth);
+		return mapCallback(e, depth);
+	}).join(',');
+	return mode === 'ts' ? `[${res}]` : mode === 'geometry-sql' ? `ARRAY[${res}]` : `{${res}}`;
+}
+
+export function stringifyTuplesArray(
+	array: ArrayValue[],
+	mode: 'sql' | 'ts' | 'geometry-sql',
+	mapCallback: (v: ArrayValue, depth: number) => string,
+	depth: number = 0,
+): string {
+	if (!array.find((n) => Array.isArray(n))) return mapCallback(array, depth);
+
+	depth += 1;
+	const res = array.map((e) => {
+		if (Array.isArray(e) && e.find((n) => Array.isArray(n))) {
+			return stringifyTuplesArray(e, mode, mapCallback, depth);
+		}
+		return mapCallback(e, depth);
+	}).join(',');
+	return mode === 'ts' ? `[${res}]` : mode === 'geometry-sql' ? `ARRAY[${res}]` : `{${res}}`;
+}
+
+export const trimChar = (str: string, char: string | [string, string]) => {
+	if (str.length < 2) return str;
+	if (typeof char === 'string' && str.startsWith(char) && str.endsWith(char)) return str.substring(1, str.length - 1);
+	if (Array.isArray(char) && str.startsWith(char[0]) && str.endsWith(char[1])) return str.substring(1, str.length - 1);
+
+	return str;
+};
+
+export const splitExpressions = (input: string | null): string[] => {
+	if (!input) return [];
+
+	const expressions: string[] = [];
+	let parenDepth = 0;
+	let inSingleQuotes = false;
+	let inDoubleQuotes = false;
+	let currentExpressionStart = 0;
+
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+
+		if (char === "'" && input[i + 1] === "'") {
+			i++;
+			continue;
+		}
+
+		if (char === '"' && input[i + 1] === '"') {
+			i++;
+			continue;
+		}
+
+		if (char === "'") {
+			if (!inDoubleQuotes) {
+				inSingleQuotes = !inSingleQuotes;
+			}
+			continue;
+		}
+		if (char === '"') {
+			if (!inSingleQuotes) {
+				inDoubleQuotes = !inDoubleQuotes;
+			}
+			continue;
+		}
+
+		if (!inSingleQuotes && !inDoubleQuotes) {
+			if (char === '(') {
+				parenDepth++;
+			} else if (char === ')') {
+				parenDepth = Math.max(0, parenDepth - 1);
+			} else if (char === ',' && parenDepth === 0) {
+				expressions.push(input.substring(currentExpressionStart, i).trim());
+				currentExpressionStart = i + 1;
+			}
+		}
+	}
+
+	if (currentExpressionStart < input.length) {
+		expressions.push(input.substring(currentExpressionStart).trim());
+	}
+
+	return expressions.filter((s) => s.length > 0);
+};
+
+export const wrapWith = (it: string, char: string) => {
+	if (!it.startsWith(char) || !it.endsWith(char)) return `${char}${it}${char}`;
+	return it;
+};
+
+export const timeTzRegex = /\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?/;
+export const isTime = (it: string) => {
+	return timeTzRegex.test(it);
+};
+
+export const dateExtractRegex = /^\d{4}-\d{2}-\d{2}/;
+export const isDate = (it: string) => {
+	return dateExtractRegex.test(it);
+};
+
+const timestampRegexp =
+	/^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?|\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::?\d{2})?)?)$/;
+export const isTimestamp = (it: string) => {
+	return timestampRegexp.test(it);
+};
+
+export const timezoneSuffixRegexp = /([+-]\d{2}(:\d{2})?|Z)$/i;
+export function hasTimeZoneSuffix(s: string): boolean {
+	return timezoneSuffixRegexp.test(s);
+}
+
+export const possibleIntervals = [
+	'year',
+	'month',
+	'day',
+	'hour',
+	'minute',
+	'second',
+	'year to month',
+	'day to hour',
+	'day to minute',
+	'day to second',
+	'hour to minute',
+	'hour to second',
+	'minute to second',
+];
+export function parseIntervalFields(type: string): { fields?: typeof possibleIntervals[number]; precision?: number } {
+	const options: { precision?: number; fields?: typeof possibleIntervals[number] } = {};
+	// incoming: interval day to second(3)
+
+	// [interval, day, to, second(3)]
+	const splitted = type.split(' ');
+	if (splitted.length === 1) {
+		return options;
+	}
+
+	// [day, to, second(3)]
+	// day to second(3)
+	const rest = splitted.slice(1, splitted.length).join(' ');
+	if (possibleIntervals.includes(rest)) return { ...options, fields: rest };
+
+	// day to second(3)
+	for (const s of possibleIntervals) {
+		if (rest.startsWith(`${s}(`)) return { ...options, fields: s };
+	}
+
+	return options;
+}
+
+export function parseEWKB(hex: string): { srid: number | undefined; point: [number, number] } {
+	const hexToBytes = (hex: string): Uint8Array => {
+		const bytes: number[] = [];
+		for (let c = 0; c < hex.length; c += 2) {
+			bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+		}
+		return new Uint8Array(bytes);
+	};
+	const bytesToFloat64 = (bytes: Uint8Array, offset: number): number => {
+		const buffer = new ArrayBuffer(8);
+		const view = new DataView(buffer);
+		for (let i = 0; i < 8; i++) {
+			view.setUint8(i, bytes[offset + i]!);
+		}
+		return view.getFloat64(0, true);
+	};
+
+	const bytes = hexToBytes(hex);
+
+	let offset = 0;
+
+	// Byte order: 1 is little-endian, 0 is big-endian
+	const byteOrder = bytes[offset];
+	offset += 1;
+
+	const view = new DataView(bytes.buffer);
+	const geomType = view.getUint32(offset, byteOrder === 1);
+	offset += 4;
+
+	let srid: number | undefined;
+	if (geomType & 0x20000000) { // SRID flag
+		srid = view.getUint32(offset, byteOrder === 1);
+		offset += 4;
+	}
+
+	if ((geomType & 0xFFFF) === 1) {
+		const x = bytesToFloat64(bytes, offset);
+		offset += 8;
+		const y = bytesToFloat64(bytes, offset);
+		offset += 8;
+
+		return { srid, point: [x, y] };
+	}
+
+	throw new Error('Unsupported geometry type');
+}
+
+export function areStringArraysEqual(arr1: string[], arr2: string[]) {
+	if (arr1.length !== arr2.length) {
+		return false;
+	}
+
+	const sorted1 = [...arr1].sort();
+	const sorted2 = [...arr2].sort();
+
+	for (let i = 0; i < sorted1.length; i++) {
+		if (sorted1[i] !== sorted2[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
diff --git a/drizzle-kit/src/utils/mocks.ts b/drizzle-kit/src/utils/mocks.ts
new file mode 100644
index 0000000000..0ed92d9f43
--- /dev/null
+++ b/drizzle-kit/src/utils/mocks.ts
@@ -0,0 +1,48 @@
+import type { Resolver } from '../dialects/common';
+
+export const mockResolver =
+	<T extends { name: string; table?: string; schema?: string }>(renames: Set<string>): Resolver<T> => async (it) => {
+		const { created, deleted } = it;
+
+		if (created.length === 0 || deleted.length === 0 || renames.size === 0) {
+			return { created, deleted, renamedOrMoved: [] };
+		}
+
+		let createdItems = [...created];
+		let deletedItems = [...deleted];
+
+		const renamedOrMoved: { from: T; to: T }[] = [];
+		for (let rename of renames) {
+			const [from, to] = rename.split('->');
+
+			const idxFrom = deletedItems.findIndex((it) => {
+				const schema = it.schema ? `${it.schema}.` : '';
+				const table = it.table ? `${it.table}.` : '';
+				const key = `${schema}${table}${it.name}`;
+				return key === from;
+			});
+
+			if (idxFrom >= 0) {
+				const idxTo = createdItems.findIndex((it) => {
+					const schema = it.schema ? `${it.schema}.` : '';
+					const table = it.table ? `${it.table}.` : '';
+					const key = `${schema}${table}${it.name}`;
+					return key === to;
+				});
+
+				if (idxTo < 0) throw new Error(`unexpected`);
+
+				renamedOrMoved.push({
+					from: deletedItems[idxFrom],
+					to: createdItems[idxTo],
+				});
+
+				delete createdItems[idxTo];
+				delete deletedItems[idxFrom];
+
+				createdItems = createdItems.filter(Boolean);
+				deletedItems = deletedItems.filter(Boolean);
+			}
+		}
+		return { created: createdItems, deleted: deletedItems, renamedOrMoved };
+	};
diff --git a/drizzle-kit/src/utils/node-assert/deep-strict-equal.ts b/drizzle-kit/src/utils/node-assert/deep-strict-equal.ts
new file mode 100644
index 0000000000..f98ffa994a
--- /dev/null
+++ b/drizzle-kit/src/utils/node-assert/deep-strict-equal.ts
@@ -0,0 +1,106 @@
+class AssertionError extends Error {
+	actual: unknown;
+	expected: unknown;
+	operator: string;
+
+	constructor(options: { message?: string; actual: unknown; expected: unknown; operator: string }) {
+		super(
+			options.message || `${JSON.stringify(options.actual)} ${options.operator} ${JSON.stringify(options.expected)}`,
+		);
+		this.name = 'AssertionError';
+		this.actual = options.actual;
+		this.expected = options.expected;
+		this.operator = options.operator;
+	}
+}
+
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+type JSONObject = { [key: string]: JSONValue };
+type JSONArray = JSONValue[];
+
+function deepStrictEqualInternal(actual: JSONValue, expected: JSONValue): boolean {
+	// Strict equality for primitives (string, number, boolean, null)
+	if (actual === expected) {
+		return true;
+	}
+
+	// If either is null or not an object, they're not equal (already checked ===)
+	if (actual === null || expected === null) {
+		return false;
+	}
+
+	if (typeof actual !== 'object' || typeof expected !== 'object') {
+		return false;
+	}
+
+	// Handle Arrays
+	if (Array.isArray(actual) && Array.isArray(expected)) {
+		if (actual.length !== expected.length) {
+			return false;
+		}
+		for (let i = 0; i < actual.length; i++) {
+			if (!deepStrictEqualInternal(actual[i], expected[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// One is array, other is not
+	if (Array.isArray(actual) !== Array.isArray(expected)) {
+		return false;
+	}
+
+	// Handle plain objects
+	const actualObj = actual as JSONObject;
+	const expectedObj = expected as JSONObject;
+
+	const actualKeys = Object.keys(actualObj);
+	const expectedKeys = Object.keys(expectedObj);
+
+	if (actualKeys.length !== expectedKeys.length) {
+		return false;
+	}
+
+	for (const key of actualKeys) {
+		if (!Object.prototype.hasOwnProperty.call(expectedObj, key)) {
+			return false;
+		}
+		if (!deepStrictEqualInternal(actualObj[key], expectedObj[key])) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Tests for deep strict equality between two JSON-compatible values.
+ * Supports: objects, arrays, strings, numbers, booleans, null.
+ *
+ * @param actual - The actual value to test
+ * @param expected - The expected value
+ * @param message - Optional message for the assertion error
+ * @throws {AssertionError} If actual and expected are not deeply strictly equal
+ */
+export function deepStrictEqual<T extends JSONValue>(
+	actual: JSONValue,
+	expected: T,
+	message?: string | Error,
+): asserts actual is T {
+	if (!deepStrictEqualInternal(actual, expected)) {
+		if (message instanceof Error) {
+			throw message;
+		}
+		throw new AssertionError({
+			message: message || `Expected values to be strictly deep-equal`,
+			actual,
+			expected,
+			operator: 'deepStrictEqual',
+		});
+	}
+}
+
+export { AssertionError };
+export type { JSONArray, JSONObject, JSONValue };
+export default { deepStrictEqual, AssertionError };
diff --git a/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm
new file mode 100644
index 0000000000..9e0eed3511
--- /dev/null
+++ b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm
@@ -0,0 +1,31 @@
+PGArrayExpression {    
+    Array = "ARRAY[" ListOf<ArrayItem, ","> "]"
+
+    ArrayItem = stringLiteral | Array | quotelessString  | nullLiteral
+
+    stringLiteral = "\"" ((~("\"" | escapedSymbol) any) | escapedSymbol)* "\""
+    
+    quotelessString = (~forbiddenSymbolForQuoteless any)+
+
+	escapedSymbol = "\\" any
+
+    nullLiteral = "NULL"
+
+	forbiddenSymbolForQuoteless = "[" | "]" | " , " | "\""  | nullLiteral
+}
+
+PGArrayLiteral {    
+    Array = "{" ListOf<ArrayItem, ","> "}"
+
+    ArrayItem = stringLiteral | quotelessString | nullLiteral | Array
+
+    stringLiteral = "\"" ((~("\"" | escapedSymbol) any) | escapedSymbol)* "\""
+    
+    quotelessString = (~forbiddenSymbolForQuoteless any)+
+
+	escapedSymbol = "\\" any 
+
+    nullLiteral = "NULL"
+
+	forbiddenSymbolForQuoteless = "{" | "}" | "," | "\""  | nullLiteral
+}
\ No newline at end of file
diff --git a/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.d.ts b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.d.ts
new file mode 100644
index 0000000000..41ce7ff617
--- /dev/null
+++ b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.d.ts
@@ -0,0 +1,63 @@
+// AUTOGENERATED FILE
+// This file was generated from grammar.ohm by `ohm generateBundles`.
+
+import {
+	BaseActionDict,
+	Grammar,
+	IterationNode,
+	Namespace,
+	Node,
+	NonterminalNode,
+	Semantics,
+	TerminalNode,
+} from 'ohm-js';
+
+export interface PGArrayExpressionActionDict<T> extends BaseActionDict<T> {
+	Array?: (this: NonterminalNode, arg0: TerminalNode, arg1: NonterminalNode, arg2: TerminalNode) => T;
+	ArrayItem?: (this: NonterminalNode, arg0: NonterminalNode) => T;
+	stringLiteral?: (this: NonterminalNode, arg0: TerminalNode, arg1: IterationNode, arg2: TerminalNode) => T;
+	quotelessString?: (this: NonterminalNode, arg0: IterationNode) => T;
+	escapedSymbol?: (this: NonterminalNode, arg0: TerminalNode, arg1: NonterminalNode) => T;
+	nullLiteral?: (this: NonterminalNode, arg0: TerminalNode) => T;
+	forbiddenSymbolForQuoteless?: (this: NonterminalNode, arg0: NonterminalNode | TerminalNode) => T;
+}
+
+export interface PGArrayExpressionSemantics extends Semantics {
+	addOperation<T>(name: string, actionDict: PGArrayExpressionActionDict<T>): this;
+	extendOperation<T>(name: string, actionDict: PGArrayExpressionActionDict<T>): this;
+	addAttribute<T>(name: string, actionDict: PGArrayExpressionActionDict<T>): this;
+	extendAttribute<T>(name: string, actionDict: PGArrayExpressionActionDict<T>): this;
+}
+
+export interface PGArrayExpressionGrammar extends Grammar {
+	createSemantics(): PGArrayExpressionSemantics;
+	extendSemantics(superSemantics: PGArrayExpressionSemantics): PGArrayExpressionSemantics;
+}
+
+export interface PGArrayLiteralActionDict<T> extends BaseActionDict<T> {
+	Array?: (this: NonterminalNode, arg0: TerminalNode, arg1: NonterminalNode, arg2: TerminalNode) => T;
+	ArrayItem?: (this: NonterminalNode, arg0: NonterminalNode) => T;
+	stringLiteral?: (this: NonterminalNode, arg0: TerminalNode, arg1: IterationNode, arg2: TerminalNode) => T;
+	quotelessString?: (this: NonterminalNode, arg0: IterationNode) => T;
+	escapedSymbol?: (this: NonterminalNode, arg0: TerminalNode, arg1: NonterminalNode) => T;
+	nullLiteral?: (this: NonterminalNode, arg0: TerminalNode) => T;
+	forbiddenSymbolForQuoteless?: (this: NonterminalNode, arg0: NonterminalNode | TerminalNode) => T;
+}
+
+export interface PGArrayLiteralSemantics extends Semantics {
+	addOperation<T>(name: string, actionDict: PGArrayLiteralActionDict<T>): this;
+	extendOperation<T>(name: string, actionDict: PGArrayLiteralActionDict<T>): this;
+	addAttribute<T>(name: string, actionDict: PGArrayLiteralActionDict<T>): this;
+	extendAttribute<T>(name: string, actionDict: PGArrayLiteralActionDict<T>): this;
+}
+
+export interface PGArrayLiteralGrammar extends Grammar {
+	createSemantics(): PGArrayLiteralSemantics;
+	extendSemantics(superSemantics: PGArrayLiteralSemantics): PGArrayLiteralSemantics;
+}
+
+declare const ns: {
+	PGArrayExpression: PGArrayExpressionGrammar;
+	PGArrayLiteral: PGArrayLiteralGrammar;
+};
+export default ns;
diff --git a/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.js b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.js
new file mode 100644
index 0000000000..04f8ef5773
--- /dev/null
+++ b/drizzle-kit/src/utils/parse-pgarray/grammar/grammar.ohm-bundle.js
@@ -0,0 +1,276 @@
+import { makeRecipe } from 'ohm-js';
+
+const result = {};
+result.PGArrayExpression = makeRecipe([
+	'grammar',
+	{
+		source:
+			'PGArrayExpression {    \n    Array = "ARRAY[" ListOf<ArrayItem, ","> "]"\n\n    ArrayItem = stringLiteral | Array | quotelessString  | nullLiteral\n\n    stringLiteral = "\\"" ((~("\\"" | escapedSymbol) any) | escapedSymbol)* "\\""\n    \n    quotelessString = (~forbiddenSymbolForQuoteless any)+\n\n\tescapedSymbol = "\\\\" any\n\n    nullLiteral = "NULL"\n\n\tforbiddenSymbolForQuoteless = "[" | "]" | " , " | "\\""  | nullLiteral\n}',
+	},
+	'PGArrayExpression',
+	null,
+	'Array',
+	{
+		Array: [
+			'define',
+			{ sourceInterval: [28, 71] },
+			null,
+			[],
+			[
+				'seq',
+				{ sourceInterval: [36, 71] },
+				['terminal', { sourceInterval: [36, 44] }, 'ARRAY['],
+				[
+					'app',
+					{ sourceInterval: [45, 67] },
+					'ListOf',
+					[
+						['app', { sourceInterval: [52, 61] }, 'ArrayItem', []],
+						['terminal', { sourceInterval: [63, 66] }, ','],
+					],
+				],
+				['terminal', { sourceInterval: [68, 71] }, ']'],
+			],
+		],
+		ArrayItem: [
+			'define',
+			{ sourceInterval: [77, 143] },
+			null,
+			[],
+			[
+				'alt',
+				{ sourceInterval: [89, 143] },
+				['app', { sourceInterval: [89, 102] }, 'stringLiteral', []],
+				['app', { sourceInterval: [105, 110] }, 'Array', []],
+				['app', { sourceInterval: [113, 128] }, 'quotelessString', []],
+				['app', { sourceInterval: [132, 143] }, 'nullLiteral', []],
+			],
+		],
+		stringLiteral: [
+			'define',
+			{ sourceInterval: [149, 223] },
+			null,
+			[],
+			[
+				'seq',
+				{ sourceInterval: [165, 223] },
+				['terminal', { sourceInterval: [165, 169] }, '"'],
+				[
+					'star',
+					{ sourceInterval: [170, 218] },
+					[
+						'alt',
+						{ sourceInterval: [171, 216] },
+						[
+							'seq',
+							{ sourceInterval: [171, 200] },
+							[
+								'not',
+								{ sourceInterval: [172, 195] },
+								['alt', { sourceInterval: [174, 194] }, ['terminal', { sourceInterval: [174, 178] }, '"'], [
+									'app',
+									{ sourceInterval: [181, 194] },
+									'escapedSymbol',
+									[],
+								]],
+							],
+							['app', { sourceInterval: [196, 199] }, 'any', []],
+						],
+						['app', { sourceInterval: [203, 216] }, 'escapedSymbol', []],
+					],
+				],
+				['terminal', { sourceInterval: [219, 223] }, '"'],
+			],
+		],
+		quotelessString: [
+			'define',
+			{ sourceInterval: [233, 286] },
+			null,
+			[],
+			[
+				'plus',
+				{ sourceInterval: [251, 286] },
+				[
+					'seq',
+					{ sourceInterval: [252, 284] },
+					['not', { sourceInterval: [252, 280] }, [
+						'app',
+						{ sourceInterval: [253, 280] },
+						'forbiddenSymbolForQuoteless',
+						[],
+					]],
+					['app', { sourceInterval: [281, 284] }, 'any', []],
+				],
+			],
+		],
+		escapedSymbol: [
+			'define',
+			{ sourceInterval: [289, 313] },
+			null,
+			[],
+			['seq', { sourceInterval: [305, 313] }, ['terminal', { sourceInterval: [305, 309] }, '\\'], [
+				'app',
+				{ sourceInterval: [310, 313] },
+				'any',
+				[],
+			]],
+		],
+		nullLiteral: ['define', { sourceInterval: [319, 339] }, null, [], [
+			'terminal',
+			{ sourceInterval: [333, 339] },
+			'NULL',
+		]],
+		forbiddenSymbolForQuoteless: [
+			'define',
+			{ sourceInterval: [342, 411] },
+			null,
+			[],
+			[
+				'alt',
+				{ sourceInterval: [372, 411] },
+				['terminal', { sourceInterval: [372, 375] }, '['],
+				['terminal', { sourceInterval: [378, 381] }, ']'],
+				['terminal', { sourceInterval: [384, 389] }, ' , '],
+				['terminal', { sourceInterval: [392, 396] }, '"'],
+				['app', { sourceInterval: [400, 411] }, 'nullLiteral', []],
+			],
+		],
+	},
+]);
+result.PGArrayLiteral = makeRecipe([
+	'grammar',
+	{
+		source:
+			'PGArrayLiteral {    \n    Array = "{" ListOf<ArrayItem, ","> "}"\n\n    ArrayItem = stringLiteral | quotelessString | nullLiteral | Array\n\n    stringLiteral = "\\"" ((~("\\"" | escapedSymbol) any) | escapedSymbol)* "\\""\n    \n    quotelessString = (~forbiddenSymbolForQuoteless any)+\n\n\tescapedSymbol = "\\\\" any \n\n    nullLiteral = "NULL"\n\n\tforbiddenSymbolForQuoteless = "{" | "}" | "," | "\\""  | nullLiteral\n}',
+	},
+	'PGArrayLiteral',
+	null,
+	'Array',
+	{
+		Array: [
+			'define',
+			{ sourceInterval: [25, 63] },
+			null,
+			[],
+			[
+				'seq',
+				{ sourceInterval: [33, 63] },
+				['terminal', { sourceInterval: [33, 36] }, '{'],
+				[
+					'app',
+					{ sourceInterval: [37, 59] },
+					'ListOf',
+					[
+						['app', { sourceInterval: [44, 53] }, 'ArrayItem', []],
+						['terminal', { sourceInterval: [55, 58] }, ','],
+					],
+				],
+				['terminal', { sourceInterval: [60, 63] }, '}'],
+			],
+		],
+		ArrayItem: [
+			'define',
+			{ sourceInterval: [69, 134] },
+			null,
+			[],
+			[
+				'alt',
+				{ sourceInterval: [81, 134] },
+				['app', { sourceInterval: [81, 94] }, 'stringLiteral', []],
+				['app', { sourceInterval: [97, 112] }, 'quotelessString', []],
+				['app', { sourceInterval: [115, 126] }, 'nullLiteral', []],
+				['app', { sourceInterval: [129, 134] }, 'Array', []],
+			],
+		],
+		stringLiteral: [
+			'define',
+			{ sourceInterval: [140, 214] },
+			null,
+			[],
+			[
+				'seq',
+				{ sourceInterval: [156, 214] },
+				['terminal', { sourceInterval: [156, 160] }, '"'],
+				[
+					'star',
+					{ sourceInterval: [161, 209] },
+					[
+						'alt',
+						{ sourceInterval: [162, 207] },
+						[
+							'seq',
+							{ sourceInterval: [162, 191] },
+							[
+								'not',
+								{ sourceInterval: [163, 186] },
+								['alt', { sourceInterval: [165, 185] }, ['terminal', { sourceInterval: [165, 169] }, '"'], [
+									'app',
+									{ sourceInterval: [172, 185] },
+									'escapedSymbol',
+									[],
+								]],
+							],
+							['app', { sourceInterval: [187, 190] }, 'any', []],
+						],
+						['app', { sourceInterval: [194, 207] }, 'escapedSymbol', []],
+					],
+				],
+				['terminal', { sourceInterval: [210, 214] }, '"'],
+			],
+		],
+		quotelessString: [
+			'define',
+			{ sourceInterval: [224, 277] },
+			null,
+			[],
+			[
+				'plus',
+				{ sourceInterval: [242, 277] },
+				[
+					'seq',
+					{ sourceInterval: [243, 275] },
+					['not', { sourceInterval: [243, 271] }, [
+						'app',
+						{ sourceInterval: [244, 271] },
+						'forbiddenSymbolForQuoteless',
+						[],
+					]],
+					['app', { sourceInterval: [272, 275] }, 'any', []],
+				],
+			],
+		],
+		escapedSymbol: [
+			'define',
+			{ sourceInterval: [280, 304] },
+			null,
+			[],
+			['seq', { sourceInterval: [296, 304] }, ['terminal', { sourceInterval: [296, 300] }, '\\'], [
+				'app',
+				{ sourceInterval: [301, 304] },
+				'any',
+				[],
+			]],
+		],
+		nullLiteral: ['define', { sourceInterval: [311, 331] }, null, [], [
+			'terminal',
+			{ sourceInterval: [325, 331] },
+			'NULL',
+		]],
+		forbiddenSymbolForQuoteless: [
+			'define',
+			{ sourceInterval: [334, 401] },
+			null,
+			[],
+			[
+				'alt',
+				{ sourceInterval: [364, 401] },
+				['terminal', { sourceInterval: [364, 367] }, '{'],
+				['terminal', { sourceInterval: [370, 373] }, '}'],
+				['terminal', { sourceInterval: [376, 379] }, ','],
+				['terminal', { sourceInterval: [382, 386] }, '"'],
+				['app', { sourceInterval: [390, 401] }, 'nullLiteral', []],
+			],
+		],
+	},
+]);
+export default result;
diff --git a/drizzle-kit/src/utils/parse-pgarray/index.ts b/drizzle-kit/src/utils/parse-pgarray/index.ts
new file mode 100644
index 0000000000..8cf346eb24
--- /dev/null
+++ b/drizzle-kit/src/utils/parse-pgarray/index.ts
@@ -0,0 +1,103 @@
+import PGArray from './grammar/grammar.ohm-bundle';
+
+const literalArraySemantics = PGArray.PGArrayLiteral.createSemantics();
+literalArraySemantics.addOperation('parseArray', {
+	Array(_lBracket, argList, _rBracket) {
+		return argList['parseArray']();
+	},
+
+	ArrayItem(arg0) {
+		return arg0['parseArray']();
+	},
+
+	NonemptyListOf(arg0, arg1, arg2) {
+		return [arg0['parseArray'](), ...arg1['parseArray'](), ...arg2['parseArray']()];
+	},
+
+	EmptyListOf() {
+		return [];
+	},
+
+	_iter(...children) {
+		return children.map((c) => c['parseArray']()).filter((e) => e !== undefined);
+	},
+
+	_terminal() {
+		return;
+	},
+
+	stringLiteral(_lQuote, string, _rQuote) {
+		return JSON.parse('"' + string.sourceString.replaceAll("''", "'") + '"');
+	},
+
+	quotelessString(string) {
+		return string.sourceString.replaceAll("''", "'");
+	},
+
+	nullLiteral(_) {
+		return null;
+	},
+});
+
+const expressionArraySemantics = PGArray.PGArrayExpression.createSemantics();
+expressionArraySemantics.addOperation('parseExpressionArray', {
+	Array(_lBracket, argList, _rBracket) {
+		return argList['parseExpressionArray']();
+	},
+
+	ArrayItem(arg0) {
+		return arg0['parseExpressionArray']();
+	},
+
+	NonemptyListOf(arg0, arg1, arg2) {
+		return [arg0['parseExpressionArray'](), ...arg1['parseExpressionArray'](), ...arg2['parseExpressionArray']()];
+	},
+
+	EmptyListOf() {
+		return [];
+	},
+
+	_iter(...children) {
+		return children.map((c) => c['parseExpressionArray']()).filter((e) => e !== undefined);
+	},
+
+	_terminal() {
+		return;
+	},
+
+	stringLiteral(_lQuote, string, _rQuote) {
+		return JSON.parse('"' + string.sourceString.replaceAll("''", "'") + '"');
+	},
+
+	quotelessString(string) {
+		return string.sourceString.replaceAll("''", "'");
+	},
+
+	nullLiteral(_) {
+		return null;
+	},
+});
+
+export type ArrayValue = string | null | ArrayValue[];
+
+// '{}'
+// every value will be a string
+export function parseArray(array: string) {
+	const match = PGArray.PGArrayLiteral.match(array, 'Array');
+
+	if (match.failed()) throw new Error(`Failed to parse array: '${array}'`);
+
+	const res = literalArraySemantics(match)['parseArray']();
+	return res as ArrayValue[];
+}
+
+// ARRAY[]
+// every value will be a string
+export function parseExpressionArray(array: string) {
+	const match = PGArray.PGArrayExpression.match(array, 'Array');
+
+	if (match.failed()) throw new Error(`Failed to parse array: '${array}'`);
+
+	const res = expressionArraySemantics(match)['parseExpressionArray']();
+	return res as ArrayValue[];
+}
diff --git a/drizzle-kit/src/utils/readme.md b/drizzle-kit/src/utils/readme.md
new file mode 100644
index 0000000000..68fe2a0c83
--- /dev/null
+++ b/drizzle-kit/src/utils/readme.md
@@ -0,0 +1,186 @@
+# How commutativity works
+
+`detectNonCommutative` function accepts an array of snapshots paths from a drizzle folder and a dialect we should use it for. Dialect is a param to dicsus, maybe we will have just different commutative function
+
+It outputs an array of conflicts with a full info about each conflict
+
+Hot this function works:
+
+Input we will go through, 3 migrations, where 2 and 3 where creating the same table in different branches, which will cause a conflict
+
+First migration
+```json
+{
+  version: "8",
+  dialect: "postgres",
+  id: "p1",
+  prevId: "00000000-0000-0000-0000-000000000000",
+  ddl: [],
+  renames: []
+}
+```
+
+Second migration(done in branch1)
+```json
+{
+  version: "8",
+  dialect: "postgres",
+  id: "a1",
+  prevId: "p1",
+  ddl: [
+    {
+      isRlsEnabled: false,
+      name: "users",
+      schema: "public",
+      entityType: "tables"
+    },
+    {
+      type: "varchar",
+      options: null,
+      typeSchema: "pg_catalog",
+      notNull: false,
+      dimensions: 0,
+      default: null,
+      generated: null,
+      identity: null,
+      name: "email",
+      schema: "public",
+      table: "users",
+      entityType: "columns"
+    }
+  ],
+  renames: []
+}
+```
+
+Third migration(done in branch2)
+```json
+{
+  version: "8",
+  dialect: "postgres",
+  id: "a1",
+  prevId: "p1",
+  ddl: [
+    {
+      isRlsEnabled: false,
+      name: "users",
+      schema: "public",
+      entityType: "tables"
+    },
+    {
+      type: "varchar",
+      options: null,
+      typeSchema: "pg_catalog",
+      notNull: false,
+      dimensions: 0,
+      default: null,
+      generated: null,
+      identity: null,
+      name: "email",
+      schema: "public",
+      table: "users",
+      entityType: "columns"
+    }
+  ],
+  renames: []
+}
+```
+
+
+
+1. We are building a snapshots grapgh possible multi-child node in our migration tree
+
+`buildSnapshotGraph` accepts all the snapshots as array and transform them to a Map and references between nodes:
+
+```ts
+nodes {
+  p1: {
+    id: 'p1',
+    prevId: '00000000-0000-0000-0000-000000000000',
+    path: '...',
+    folderPath: '...',
+    raw: {...} // raw snapshot json
+  },
+  a1: {
+    id: 'a1',
+    prevId: 'p1',
+    path: '...',
+    folderPath: '...',
+    raw: {...} // raw snapshot json
+  },
+  b1: {
+    id: 'b1',
+    prevId: 'p1',
+    path: '...',
+    folderPath: '...',
+    raw: {...} // raw snapshot json
+  }
+}
+```
+
+2. Next we need to actually map those nodes to a map of parent id to child ids to find if we have an array of >1 childs for each branch
+
+`prevToChildren` is the exact map logic for it, it will output this:
+
+```ts
+prevToChildren {
+  '00000000-0000-0000-0000-000000000000': [ 'p1' ],
+  // Conflict!
+  p1: [ 'a1', 'b1' ]
+}
+```
+
+3. For each case where a key has >1 childs we need to check collisions
+
+- We need to collect all the leaves for each branch child, so we can find a head and check each of branch node for collisions, if at least one is found - add a conflict with explanation
+
+For our case we have both childs as a head, so we will have 
+```ts
+{ a1: [ 'a1' ], b1: [ 'b1' ] }
+```
+
+4. Conflicts cases are separated into several steps steps
+
+- Firstly we identify same resources changes and same changes, then we identify same resources with different actions(create, drop, etc.)
+- Then we identify conflicts when table drops and anything that is realted to this table was changed
+- The same then will be done foe schemas(for dialects that supports schemas)
+- Finally we will respond with an array of condlicts
+
+Example, 
+```ts
+[
+  {
+    parentId: 'p1',
+    parentPath: '...', // path to parent
+    branchA: {
+      headId: 'a1', // snapshot id
+      path: '...', // path to snapshot json
+      statements: [Array] // raw json statements
+    },
+    branchB: {
+      headId: 'b1',
+      path: '...',
+      statements: [Array] 
+    },
+    reasons: [
+      'Two identical operations on the same resource conflict (e.g., duplicate changes): table:public.users (create) vs table:public.users (create)'
+    ]
+  }
+]
+```
+
+extra cases handled
+```
+--- case 1 ---
+P1 - empty
+
+A1 - create.users        B1 - create posts
+A2 - create.posts        B2 - alter posts
+                         B3 - create media
+--- case 2 ---
+P1 - users table
+
+A1 - alter.users        B1 - create posts
+A2 - alter.users        B2 - alter posts
+                        B3 - drop users
+```
diff --git a/drizzle-kit/src/utils/schemaValidator.ts b/drizzle-kit/src/utils/schemaValidator.ts
new file mode 100644
index 0000000000..22b8930912
--- /dev/null
+++ b/drizzle-kit/src/utils/schemaValidator.ts
@@ -0,0 +1,17 @@
+import type { TypeOf } from 'zod';
+import { enum as enumType } from 'zod';
+
+export const dialects = [
+	'postgresql',
+	'mysql',
+	'sqlite',
+	'turso',
+	'singlestore',
+	'mssql',
+	'cockroach',
+	'duckdb',
+] as const;
+export const dialect = enumType(dialects);
+
+export type Dialect = (typeof dialects)[number];
+const _: Dialect = '' as TypeOf<typeof dialect>;
diff --git a/drizzle-kit/src/utils/sequence-matcher.ts b/drizzle-kit/src/utils/sequence-matcher.ts
new file mode 100644
index 0000000000..28022271b8
--- /dev/null
+++ b/drizzle-kit/src/utils/sequence-matcher.ts
@@ -0,0 +1,261 @@
+/**
+ * A sequence matcher for string arrays that finds differences
+ * and tracks positions of added elements.
+ */
+export function diffStringArrays(oldArr: string[], newArr: string[]): {
+	type: 'same' | 'removed' | 'added';
+	value: string;
+	beforeValue?: string;
+}[] {
+	// Get edit operations
+	const opcodes = getOpcodes(oldArr, newArr);
+
+	// Convert to the requested format
+	return formatResult(opcodes, oldArr, newArr);
+}
+
+/**
+ * Get edit operations between two arrays
+ */
+function getOpcodes(
+	oldArray: string[],
+	newArray: string[],
+): Array<['equal' | 'delete' | 'insert' | 'replace', number, number, number, number]> {
+	// Get matching blocks
+	const matchingBlocks = getMatchingBlocks(oldArray, newArray);
+
+	// Convert to opcodes
+	const opcodes: Array<['equal' | 'delete' | 'insert' | 'replace', number, number, number, number]> = [];
+	let oldIndex = 0;
+	let newIndex = 0;
+
+	for (const [oldBlockStart, newBlockStart, matchLength] of matchingBlocks) {
+		// Handle differences before this match
+		if (oldIndex < oldBlockStart || newIndex < newBlockStart) {
+			const tag: 'delete' | 'insert' | 'replace' = oldIndex < oldBlockStart && newIndex < newBlockStart
+				? 'replace'
+				: oldIndex < oldBlockStart
+				? 'delete'
+				: 'insert';
+			opcodes.push([tag, oldIndex, oldBlockStart, newIndex, newBlockStart]);
+		}
+
+		// Handle the match itself
+		if (matchLength > 0) {
+			opcodes.push(['equal', oldBlockStart, oldBlockStart + matchLength, newBlockStart, newBlockStart + matchLength]);
+		}
+
+		// Update positions
+		oldIndex = oldBlockStart + matchLength;
+		newIndex = newBlockStart + matchLength;
+	}
+
+	return opcodes;
+}
+
+/**
+ * Get matching blocks between two arrays
+ */
+function getMatchingBlocks(oldArray: string[], newArray: string[]): Array<[number, number, number]> {
+	// Special case for empty arrays
+	if (oldArray.length === 0 && newArray.length === 0) {
+		return [[0, 0, 0]];
+	}
+
+	// Find matching blocks recursively
+	const matchQueue: Array<[number, number, number, number]> = [[0, oldArray.length, 0, newArray.length]];
+	const matches: Array<[number, number, number]> = [];
+
+	while (matchQueue.length > 0) {
+		const [oldStart, oldEnd, newStart, newEnd] = matchQueue.pop()!;
+
+		// Find longest match in this range
+		const [oldMatchStart, newMatchStart, matchLength] = findLongestMatch(
+			oldArray,
+			newArray,
+			oldStart,
+			oldEnd,
+			newStart,
+			newEnd,
+		);
+
+		if (matchLength > 0) {
+			matches.push([oldMatchStart, newMatchStart, matchLength]);
+
+			// Add regions before the match to the queue
+			if (oldStart < oldMatchStart && newStart < newMatchStart) {
+				matchQueue.push([oldStart, oldMatchStart, newStart, newMatchStart]);
+			}
+
+			// Add regions after the match to the queue
+			if (oldMatchStart + matchLength < oldEnd && newMatchStart + matchLength < newEnd) {
+				matchQueue.push([oldMatchStart + matchLength, oldEnd, newMatchStart + matchLength, newEnd]);
+			}
+		}
+	}
+
+	// Sort matches and add sentinel
+	matches.sort((a, b) => a[0] - b[0]);
+	matches.push([oldArray.length, newArray.length, 0]);
+
+	return matches;
+}
+
+/**
+ * Find the longest matching block in oldArray[oldStart:oldEnd] and newArray[newStart:newEnd]
+ */
+function findLongestMatch(
+	oldArray: string[],
+	newArray: string[],
+	oldStart: number,
+	oldEnd: number,
+	newStart: number,
+	newEnd: number,
+): [number, number, number] {
+	let bestOldStart = oldStart;
+	let bestNewStart = newStart;
+	let bestMatchLength = 0;
+
+	// Create a map of elements in newArray to their positions
+	const newElementPositions: Map<string, number[]> = new Map();
+	for (let newIndex = newStart; newIndex < newEnd; newIndex++) {
+		const element = newArray[newIndex];
+		if (!newElementPositions.has(element)) {
+			newElementPositions.set(element, []);
+		}
+		newElementPositions.get(element)!.push(newIndex);
+	}
+
+	// For each element in oldArray, check for matches in newArray
+	for (let oldIndex = oldStart; oldIndex < oldEnd; oldIndex++) {
+		const element = oldArray[oldIndex];
+		if (!newElementPositions.has(element)) continue;
+
+		for (const newIndex of newElementPositions.get(element)!) {
+			// Skip if we're past the end
+			if (newIndex >= newEnd) continue;
+
+			// Count how many consecutive elements match
+			let currentMatchLength = 1;
+			while (
+				oldIndex + currentMatchLength < oldEnd
+				&& newIndex + currentMatchLength < newEnd
+				&& oldArray[oldIndex + currentMatchLength] === newArray[newIndex + currentMatchLength]
+			) {
+				currentMatchLength++;
+			}
+
+			if (currentMatchLength > bestMatchLength) {
+				bestOldStart = oldIndex;
+				bestNewStart = newIndex;
+				bestMatchLength = currentMatchLength;
+			}
+		}
+	}
+
+	return [bestOldStart, bestNewStart, bestMatchLength];
+}
+
+/**
+ * Format the opcodes into the requested result format
+ */
+function formatResult(
+	opcodes: Array<['equal' | 'delete' | 'insert' | 'replace', number, number, number, number]>,
+	oldArray: string[],
+	newArray: string[],
+): {
+	type: 'same' | 'removed' | 'added';
+	value: string;
+	beforeValue?: string;
+	isAtEnd?: boolean;
+}[] {
+	const result: {
+		type: 'same' | 'removed' | 'added';
+		value: string;
+		beforeValue?: string;
+		isAtEnd?: boolean;
+	}[] = [];
+
+	for (const [tag, oldStart, oldEnd, newStart, newEnd] of opcodes) {
+		if (tag === 'equal') {
+			// Same elements in both arrays
+			for (let oldIndex = oldStart; oldIndex < oldEnd; oldIndex++) {
+				result.push({
+					type: 'same',
+					value: oldArray[oldIndex],
+				});
+			}
+			continue;
+		}
+
+		if (tag === 'delete') {
+			// Elements removed from oldArray
+			for (let oldIndex = oldStart; oldIndex < oldEnd; oldIndex++) {
+				result.push({
+					type: 'removed',
+					value: oldArray[oldIndex],
+				});
+			}
+			continue;
+		}
+
+		if (tag === 'insert') {
+			// Elements added in newArray
+			for (let newIndex = newStart; newIndex < newEnd; newIndex++) {
+				addWithPosition(newArray[newIndex], newIndex, newArray, oldArray, result);
+			}
+			continue;
+		}
+
+		if (tag === 'replace') {
+			// Both removal and addition
+			// First, handle removals
+			for (let oldIndex = oldStart; oldIndex < oldEnd; oldIndex++) {
+				result.push({
+					type: 'removed',
+					value: oldArray[oldIndex],
+				});
+			}
+
+			// Then, handle additions
+			for (let newIndex = newStart; newIndex < newEnd; newIndex++) {
+				addWithPosition(newArray[newIndex], newIndex, newArray, oldArray, result);
+			}
+			continue;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Helper function to add an element with position information
+ */
+function addWithPosition(
+	value: string,
+	currentIndex: number,
+	newArray: string[],
+	oldElementSet: string[],
+	result: {
+		type: 'same' | 'removed' | 'added';
+		value: string;
+		beforeValue?: string;
+	}[],
+): void {
+	// Find what this added element comes before
+	let beforeValue: string | undefined = undefined;
+
+	// Look ahead to find the next element that exists in oldArray
+	for (let lookAheadIndex = currentIndex + 1; lookAheadIndex < newArray.length; lookAheadIndex++) {
+		if (oldElementSet.indexOf(newArray[lookAheadIndex]) >= 0) {
+			beforeValue = newArray[lookAheadIndex];
+			break;
+		}
+	}
+
+	result.push({
+		type: 'added',
+		value,
+		beforeValue,
+	});
+}
diff --git a/drizzle-kit/src/utils/utils-node.ts b/drizzle-kit/src/utils/utils-node.ts
new file mode 100644
index 0000000000..4d217c0dc6
--- /dev/null
+++ b/drizzle-kit/src/utils/utils-node.ts
@@ -0,0 +1,475 @@
+import chalk from 'chalk';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync } from 'fs';
+import { getTsconfig } from 'get-tsconfig';
+import { sync as globSync } from 'glob';
+import { dirname, join, resolve } from 'path';
+import { parse, pathToFileURL } from 'url';
+import {
+	MigrationsOutdatedCliError,
+	SchemaFilesNotFoundCliError,
+	UnsupportedSnapshotVersionCliError,
+} from '../cli/errors';
+import { snapshotValidator as cockroachValidator } from '../dialects/cockroach/snapshot';
+import { snapshotValidator as mssqlValidatorSnapshot } from '../dialects/mssql/snapshot';
+import { snapshotValidator as mysqlSnapshotValidator } from '../dialects/mysql/snapshot';
+import { snapshotValidator as pgSnapshotValidator } from '../dialects/postgres/snapshot';
+import { snapshotValidator as singlestoreSnapshotValidator } from '../dialects/singlestore/snapshot';
+import { snapshotValidator as sqliteStapshotValidator } from '../dialects/sqlite/snapshot';
+import { assertUnreachable } from '.';
+import type { Journal } from '.';
+import type { Dialect } from './schemaValidator';
+
+export const prepareFilenames = (path: string | string[]) => {
+	if (typeof path === 'string') {
+		path = [path];
+	}
+
+	const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+
+	const skippedFiles: string[] = [];
+
+	const result = path.reduce((result, cur) => {
+		const globbed = globSync(`${prefix}${cur}`);
+
+		for (const it of globbed) {
+			const stats = lstatSync(it);
+
+			const fileName = stats.isDirectory() ? null : resolve(it);
+
+			const filenames = fileName
+				? [{ path: fileName, stat: stats }]
+				: readdirSync(it).map((file) => {
+					const fullPath = join(resolve(it), file);
+					return { path: fullPath, stat: lstatSync(fullPath) };
+				});
+
+			for (const { path: file, stat } of filenames) {
+				if (stat.isDirectory()) continue;
+
+				if (
+					file.endsWith('.js')
+					|| file.endsWith('.mjs')
+					|| file.endsWith('.cjs')
+					|| file.endsWith('.jsx')
+					|| file.endsWith('.ts')
+					|| file.endsWith('.mts')
+					|| file.endsWith('.cts')
+					|| file.endsWith('.tsx')
+				) {
+					result.add(file);
+				} else {
+					skippedFiles.push(file);
+				}
+			}
+		}
+
+		return result;
+	}, new Set<string>());
+	const res = [...result];
+
+	// TODO can be added. Need approve on this
+	// if (skippedFiles.length > 0) {
+	// 	console.log(info(` ⚠ Skipped ${chalk.blue(skippedFiles.join(', '))} file(s)`));
+	// }
+
+	// when schema: "./schema" and not "./schema.ts"
+	if (res.length === 0) {
+		throw new SchemaFilesNotFoundCliError(path);
+	}
+
+	return res;
+};
+
+export const assertV1OutFolder = (out: string) => {
+	if (!existsSync(out)) return;
+
+	const oldMigrationFolders = readdirSync(out).filter(
+		(it) => it.length === 14 && /^\d+$/.test(it),
+	);
+
+	if (oldMigrationFolders.length > 0) {
+		throw new MigrationsOutdatedCliError(out);
+	}
+};
+
+export const assertV3OutFolder = (out: string) => {
+	if (!existsSync(out)) return;
+
+	if (existsSync(join(out, 'meta/_journal.json'))) {
+		throw new MigrationsOutdatedCliError(out);
+	}
+};
+
+export const dryJournal = (dialect: Dialect): Journal => {
+	return {
+		version: '7',
+		dialect,
+		entries: [],
+	};
+};
+
+export const prepareOutFolder = (out: string) => {
+	if (!existsSync(out)) {
+		mkdirSync(out, { recursive: true });
+	}
+
+	const snapshots = readdirSync(out)
+		.map((subdir) => join(out, subdir, 'snapshot.json'))
+		.filter((filePath) => existsSync(filePath));
+
+	snapshots.sort();
+
+	return { snapshots };
+};
+
+const tsconfigAliasCache = new Map<string, Record<string, string> | undefined>();
+
+const getAliasesForTsconfig = (baseDir: string): Record<string, string> | undefined => {
+	const cached = tsconfigAliasCache.get(baseDir);
+	if (cached !== undefined || tsconfigAliasCache.has(baseDir)) {
+		return cached;
+	}
+
+	const tsconfig = getTsconfig(baseDir);
+	const tsconfigPaths = tsconfig?.config?.compilerOptions?.paths as Record<string, string[]> | undefined;
+	if (!tsconfigPaths || !tsconfig?.path) {
+		tsconfigAliasCache.set(baseDir, undefined);
+		return undefined;
+	}
+
+	const tsconfigBaseUrl = tsconfig.config.compilerOptions?.baseUrl ?? '.';
+	const tsconfigDir = dirname(tsconfig.path);
+
+	const aliases = Object.fromEntries(
+		Object.entries(tsconfigPaths).flatMap(([key, values]) => {
+			const targets = (values ?? []).filter((value): value is string => Boolean(value));
+			if (targets.length === 0) return [];
+
+			const hasWildcard = key.includes('*') || targets.some((target) => target.includes('*'));
+			const supportsTrailingWildcard = key.endsWith('/*') && targets.every((target) => target.endsWith('/*'));
+			if (hasWildcard && !supportsTrailingWildcard) {
+				console.warn(
+					chalk.yellow(
+						`[drizzle-kit] Unsupported tsconfig "paths" mapping "${key}": [${
+							targets
+								.map((target) => `"${target}"`)
+								.join(', ')
+						}]. Only trailing "/*" patterns are supported; this mapping will be ignored.`,
+					),
+				);
+				return [];
+			}
+
+			const aliasKey = key.endsWith('/*') ? key.slice(0, -1) : key;
+			const resolvedTargets = targets.map((target) => {
+				if (supportsTrailingWildcard) {
+					const targetPrefix = target.slice(0, -1);
+					return resolve(tsconfigDir, tsconfigBaseUrl, targetPrefix);
+				}
+				return resolve(tsconfigDir, tsconfigBaseUrl, target);
+			});
+
+			const selectedTarget = resolvedTargets.find((candidate) => existsSync(candidate)) ?? resolvedTargets[0]!;
+			return [[aliasKey, selectedTarget]];
+		}),
+	);
+
+	tsconfigAliasCache.set(baseDir, aliases);
+	return aliases;
+};
+
+/**
+ * Reads all snapshot files and returns the IDs of leaf nodes (nodes that are
+ * not referenced as a parent by any other node). When generating a new migration,
+ * these leaf IDs should be used as `prevIds` to merge all open branches.
+ */
+export const findLeafSnapshotIds = (snapshots: string[]): string[] => {
+	if (snapshots.length === 0) return [];
+
+	const allIds = new Set<string>();
+	const referencedAsParent = new Set<string>();
+
+	for (const file of snapshots) {
+		const raw = JSON.parse(readFileSync(file, 'utf8')) as {
+			id: string;
+			prevIds: string[];
+		};
+		allIds.add(raw.id);
+		for (const pid of raw.prevIds) {
+			referencedAsParent.add(pid);
+		}
+	}
+
+	const leafIds = [...allIds].filter((id) => !referencedAsParent.has(id));
+	return leafIds.length > 0 ? leafIds : [Array.from(allIds).pop()!];
+};
+
+type ValidationResult =
+	| { status: 'valid' | 'unsupported' | 'nonLatest' }
+	| { status: 'malformed'; errors: string[] };
+
+const assertVersion = (
+	obj: object,
+	current: number,
+): 'unsupported' | 'nonLatest' | null => {
+	const version = 'version' in obj ? Number(obj['version']) : undefined;
+	if (!version) return 'unsupported';
+	if (version > current) return 'unsupported';
+	if (version < current) return 'nonLatest';
+
+	return null;
+};
+
+const postgresValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 8);
+	if (versionError) return { status: versionError };
+
+	const res = pgSnapshotValidator.parse(snapshot);
+	if (!res.success) {
+		return { status: 'malformed', errors: res.errors ?? [] };
+	}
+
+	return { status: 'valid' };
+};
+
+const cockroachSnapshotValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 1);
+	if (versionError) return { status: versionError };
+
+	const res = cockroachValidator.parse(snapshot);
+	if (!res.success) {
+		return { status: 'malformed', errors: res.errors ?? [] };
+	}
+
+	return { status: 'valid' };
+};
+
+const mysqlValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 6);
+	if (versionError) return { status: versionError };
+
+	const { success } = mysqlSnapshotValidator.parse(snapshot);
+	if (!success) return { status: 'malformed', errors: [] };
+
+	return { status: 'valid' };
+};
+
+const mssqlSnapshotValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 2);
+	if (versionError) return { status: versionError };
+
+	const res = mssqlValidatorSnapshot.parse(snapshot);
+	if (!res.success) return { status: 'malformed', errors: res.errors ?? [] };
+
+	return { status: 'valid' };
+};
+
+const sqliteValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 7);
+	if (versionError) return { status: versionError };
+
+	const { success } = sqliteStapshotValidator.parse(snapshot);
+	if (!success) {
+		return { status: 'malformed', errors: [] };
+	}
+
+	return { status: 'valid' };
+};
+
+const singlestoreValidator = (snapshot: object): ValidationResult => {
+	const versionError = assertVersion(snapshot, 2);
+	if (versionError) return { status: versionError };
+
+	const { success } = singlestoreSnapshotValidator.parse(snapshot);
+	if (!success) {
+		return { status: 'malformed', errors: [] };
+	}
+	return { status: 'valid' };
+};
+
+export const validatorForDialect = (
+	dialect: Dialect,
+): (snapshot: object) => ValidationResult => {
+	switch (dialect) {
+		case 'postgresql':
+			return postgresValidator;
+		case 'sqlite':
+			return sqliteValidator;
+		case 'turso':
+			return sqliteValidator;
+		case 'mysql':
+			return mysqlValidator;
+		case 'singlestore':
+			return singlestoreValidator;
+		case 'mssql':
+			return mssqlSnapshotValidator;
+		case 'cockroach':
+			return cockroachSnapshotValidator;
+		case 'duckdb':
+			throw Error('duckdb validator is not implemented yet'); // TODO
+		default:
+			assertUnreachable(dialect);
+	}
+};
+
+export const validateWithReport = (snapshots: string[], dialect: Dialect) => {
+	// ✅ check if drizzle-kit can handle snapshot version
+	// ✅ check if snapshot is of the last version
+	// ✅ check if id of the snapshot is valid
+	// ✅ collect {} of prev id -> snapshotName[], if there's more than one - tell about collision
+	const validator = validatorForDialect(dialect);
+
+	const result = snapshots.reduce(
+		(accum, it) => {
+			const raw = JSON.parse(readFileSync(`./${it}`).toString());
+
+			accum.rawMap[it] = raw;
+
+			const res = validator(raw);
+			if (res.status === 'unsupported') {
+				throw new UnsupportedSnapshotVersionCliError(it);
+			}
+			if (res.status === 'malformed') {
+				accum.malformed.push(it);
+				return accum;
+			}
+
+			if (res.status === 'nonLatest') {
+				accum.nonLatest.push(it);
+				return accum;
+			}
+
+			// only if latest version here
+			const idEntry = accum.idsMap[raw['prevId']] ?? {
+				parent: it,
+				snapshots: [],
+			};
+
+			idEntry.snapshots.push(it);
+			accum.idsMap[raw['prevId']] = idEntry;
+			return accum;
+		},
+		{
+			malformed: [],
+			nonLatest: [],
+			idToNameMap: {},
+			idsMap: {},
+			rawMap: {},
+		} as {
+			malformed: string[];
+			nonLatest: string[];
+			idsMap: Record<string, { parent: string; snapshots: string[] }>;
+			rawMap: Record<string, any>;
+		},
+	);
+
+	return result;
+};
+
+export const normaliseSQLiteUrl = (
+	it: string,
+	type: 'libsql' | 'better-sqlite' | '@tursodatabase/database' | 'bun',
+) => {
+	if (type === 'libsql') {
+		if (it.startsWith('file:')) {
+			return it;
+		}
+		try {
+			const url = parse(it);
+			if (url.protocol === null) {
+				return `file:${it}`;
+			}
+			return it;
+		} catch {
+			return `file:${it}`;
+		}
+	}
+
+	if (
+		type === 'better-sqlite'
+		|| type === '@tursodatabase/database'
+		|| type === 'bun'
+	) {
+		if (it.startsWith('file:')) {
+			return it.substring(5);
+		}
+
+		return it;
+	}
+
+	assertUnreachable(type);
+};
+
+export class InMemoryMutex {
+	private lockPromise: Promise<void> | null = null;
+
+	async withLock<T>(fn: () => Promise<T>): Promise<T> {
+		// Wait for any existing lock
+		while (this.lockPromise) {
+			await this.lockPromise;
+		}
+
+		let resolveLock: (() => void) | undefined;
+		this.lockPromise = new Promise<void>((resolve) => {
+			resolveLock = resolve;
+		});
+
+		try {
+			return await fn();
+		} finally {
+			this.lockPromise = null;
+			resolveLock!(); // non-null assertion: TS now knows it's definitely assigned
+		}
+	}
+}
+
+const isBun = typeof (globalThis as any).Bun !== 'undefined';
+const isDeno = typeof (globalThis as any).Deno !== 'undefined';
+
+export const loadModule = async <T = unknown>(
+	modulePath: string,
+	{ defaultExport = false }: { defaultExport?: boolean } = {},
+): Promise<T> => {
+	if (isBun || isDeno) {
+		const fileUrl = pathToFileURL(modulePath).href;
+		const mod = await import(fileUrl);
+		return defaultExport ? (mod?.default ?? mod) : mod;
+	}
+
+	const [major, minor] = process.versions.node.split('.').map(Number);
+	const supportsModuleRegister = (major === 18 && minor >= 19)
+		|| (major === 20 && minor >= 6)
+		|| major >= 21;
+
+	if (!supportsModuleRegister) {
+		console.error(
+			`Node.js ${process.version} does not support the required module.register() API.`,
+		);
+		console.error(`Please upgrade to Node.js v18.19+, v20.6+, or v21+.`);
+		process.exit(1);
+	}
+
+	const path = require('path');
+	const absoluteModulePath = path.isAbsolute(modulePath)
+		? modulePath
+		: path.resolve(modulePath);
+	const ext = path.extname(modulePath);
+	const isTS = ext === '.ts' || ext === '.mts' || ext === '.cts';
+
+	if (isTS) {
+		const baseDir = path.dirname(absoluteModulePath);
+		const aliases = getAliasesForTsconfig(baseDir);
+		// oxlint-disable-next-line consistent-type-imports
+		const { createJiti } = require('jiti') as typeof import('jiti');
+		const jiti = createJiti(baseDir, {
+			interopDefault: true,
+			alias: aliases,
+			requireCache: false,
+		});
+		const mod = await jiti.import<any>(absoluteModulePath);
+		return defaultExport ? (mod?.default ?? mod) : mod;
+	}
+	const fileUrl = pathToFileURL(absoluteModulePath).href;
+	const mod = await import(fileUrl);
+	return defaultExport ? (mod?.default ?? mod) : mod;
+};
diff --git a/drizzle-kit/src/utils/when-json-met-bigint/index.ts b/drizzle-kit/src/utils/when-json-met-bigint/index.ts
new file mode 100644
index 0000000000..8d043e45b9
--- /dev/null
+++ b/drizzle-kit/src/utils/when-json-met-bigint/index.ts
@@ -0,0 +1,19 @@
+// Copied from https://github.com/haoadoreorange/when-json-met-bigint
+// Author: @haoadoresorange
+
+import type { JsonBigIntOptions } from './lib';
+import { newParse } from './parse';
+import { stringify } from './stringify';
+
+const parse = newParse();
+export const JSONB = Object.assign(
+	(options?: JsonBigIntOptions) => {
+		return {
+			parse: newParse(options),
+			stringify,
+		};
+	},
+	// default options
+	{ parse, stringify },
+);
+export { parse, stringify };
diff --git a/drizzle-kit/src/utils/when-json-met-bigint/lib.ts b/drizzle-kit/src/utils/when-json-met-bigint/lib.ts
new file mode 100644
index 0000000000..b382cdc8af
--- /dev/null
+++ b/drizzle-kit/src/utils/when-json-met-bigint/lib.ts
@@ -0,0 +1,73 @@
+export const error = `error`;
+export const ignore = `ignore`;
+export const preserve = `preserve`;
+export const CONSTRUCTOR_ACTIONS = [error, ignore, preserve] as const;
+export const PROTO_ACTIONS = CONSTRUCTOR_ACTIONS;
+export type JsonBigIntOptions = {
+	/**
+	 * @default false
+	 */
+	errorOnBigIntDecimalOrScientific?: boolean;
+	/**
+	 * @default false
+	 */
+	errorOnDuplicatedKeys?: boolean;
+	/**
+	 * @default false
+	 */
+	strict?: boolean;
+	/**
+	 * @default false
+	 */
+	parseBigIntAsString?: boolean;
+	/**
+	 * @default false
+	 */
+	alwaysParseAsBigInt?: boolean;
+	/**
+	 * @default 'preserve'
+	 */
+	protoAction?: (typeof PROTO_ACTIONS)[number];
+	/**
+	 * @default 'preserve'
+	 */
+	constructorAction?: (typeof CONSTRUCTOR_ACTIONS)[number];
+};
+
+export const isNonNullObject = (
+	o: unknown,
+): o is Record<string, unknown> | unknown[] => {
+	return o !== null && typeof o === `object`;
+};
+
+export class Cache<K extends string | number | symbol, V> {
+	private _cache = {} as Record<K, V>;
+	private _size = 0;
+	private _old = {} as Record<K, V>;
+
+	constructor(private readonly _max = 1e6 / 2) {}
+
+	get(key: K): V | undefined {
+		return this.has(key) ? this._cache[key] : undefined;
+	}
+
+	set(key: K, value: V): V {
+		if (this._size >= this._max) {
+			this._old = this._cache;
+			this._cache = {} as Record<K, V>;
+			this._size = 0;
+		}
+		this._cache[key] = value;
+		this._size++;
+		return value;
+	}
+
+	has(key: K): boolean {
+		if (Object.prototype.hasOwnProperty.call(this._cache, key)) return true;
+		if (Object.prototype.hasOwnProperty.call(this._old, key)) {
+			this._cache[key] = this._old[key];
+			return true;
+		}
+		return false;
+	}
+}
diff --git a/drizzle-kit/src/utils/when-json-met-bigint/parse.ts b/drizzle-kit/src/utils/when-json-met-bigint/parse.ts
new file mode 100644
index 0000000000..fef3500061
--- /dev/null
+++ b/drizzle-kit/src/utils/when-json-met-bigint/parse.ts
@@ -0,0 +1,536 @@
+import type { JsonBigIntOptions } from './lib';
+import { Cache, CONSTRUCTOR_ACTIONS, error, ignore, isNonNullObject, preserve, PROTO_ACTIONS } from './lib';
+
+const bigint = `bigint`;
+const number = `number`;
+
+// regexpxs extracted from
+// (c) BSD-3-Clause
+// https://github.com/fastify/secure-json-parse/graphs/contributors and https://github.com/hapijs/bourne/graphs/contributors
+const SUSPECT_PROTO_RX =
+	/(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
+const SUSPECT_CONSTRUCTOR_RX =
+	/(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
+
+const ESCAPEE = {
+	'"': `"`,
+	'\\': `\\`,
+	'/': `/`,
+	b: `\b`,
+	f: `\f`,
+	n: `\n`,
+	r: `\r`,
+	t: `\t`,
+} as const;
+
+type StringOrNumberOrSymbol = string | number | symbol;
+type SimpleSchema =
+	| `number`
+	| `bigint`
+	| ((n: number | bigint) => `number` | `bigint`);
+type InternalSchema =
+	| SimpleSchema
+	| (InternalSchema | null)[]
+	| { [key: StringOrNumberOrSymbol]: InternalSchema | undefined };
+export type Schema<T = unknown> = unknown extends T ? InternalSchema
+	: T extends number | number | bigint ? SimpleSchema
+	: T extends (infer E)[] ? (Schema<E> | null)[]
+	// unknown wouldn't work for interface, have to be any, see https://github.com/microsoft/TypeScript/issues/42825
+	: T extends Record<StringOrNumberOrSymbol, any> ? {
+			[
+				K in keyof T as K extends symbol ? never
+					// This is originally to filter out the keys that don't need
+					// schema, but somehow mysteriously make the compiler always omit
+					// keys that have generic type itself, for example:
+					// const f = <T>() => {
+					//     const sch: Schema<{ a: T, b: string }>
+					// }
+					// gives sch type {}
+					// It is not the type of sch extends Record<StringOrNumberOrSymbol, never>.
+					// When trying something like this
+					//   : Schema<T[K]> extends Record<StringOrNumberOrSymbol, never>
+					//   ? K | symbol
+					//   K | symbol]?: Schema<T[K]>;
+					// the type of sch is still { b?: undefined } only.
+					// Meaning the key 'a' is always removed for some reason.
+
+					//   : Schema<T[K]> extends Record<StringOrNumberOrSymbol, never>
+					//   ? never
+					: K | symbol
+			]?: Schema<T[K]>;
+		}
+	: never;
+
+// TODO: Infer parsed type when schema generic parameter is known
+// type Parsed<S> = S extends SchemaNumberOrBigIntOrFn
+//     ? number | bigint | string
+//     : S extends (infer E | null)[]
+//     ? Parsed<E>[]
+//     : S extends Record<string | number | symbol, infer E>
+//     ? { [K in keyof S as K extends symbol ? string : K]: Parsed<E> } & Record<
+//           string | number | symbol,
+//           unknown
+//       >
+//     : any;
+type JsonValue =
+	| { [key: string]: JsonValue }
+	| JsonValue[]
+	| string
+	| number
+	| bigint
+	| boolean
+	| null;
+// Closure for internal state variables.
+// Parser's internal state variables are prefixed with p_, methods are prefixed with p
+export const newParse = (
+	p_user_options?: JsonBigIntOptions,
+): <T>(
+	text: string,
+	reviver?: Parameters<typeof JSON.parse>[1] | null,
+	schema?: Schema<T>,
+) => ReturnType<typeof JSON.parse> => {
+	// This returns a function that can parse a JSON text, producing a JavaScript
+	// data structure. It is a simple, recursive descent parser. It does not use
+	// eval or regular expressions, so it can be used as a model for implementing
+	// a JSON parser in other languages.
+
+	let p_current_char_index: number, // Index of current character
+		p_current_char: string, // Current character
+		p_text: string; // Text being parsed
+
+	// Default options.
+	const p_options: JsonBigIntOptions = {
+		errorOnBigIntDecimalOrScientific: false,
+		errorOnDuplicatedKeys: false,
+		parseBigIntAsString: false,
+		alwaysParseAsBigInt: false, // Toggles whether all numbers should be BigInt
+		protoAction: preserve,
+		constructorAction: preserve,
+	};
+
+	// If there are options, then use them to override the default options.
+	// These checks are for JS users with no type checking.
+	if (p_user_options) {
+		if (
+			p_user_options.strict === true
+			|| p_user_options.errorOnBigIntDecimalOrScientific === true
+		) {
+			p_options.errorOnBigIntDecimalOrScientific = true;
+		}
+		if (
+			p_user_options.strict === true
+			|| p_user_options.errorOnDuplicatedKeys === true
+		) {
+			p_options.errorOnDuplicatedKeys = true;
+		}
+		if (p_user_options.parseBigIntAsString === true) {
+			p_options.parseBigIntAsString = true;
+		}
+		if (p_user_options.alwaysParseAsBigInt === true) {
+			p_options.alwaysParseAsBigInt = true;
+		}
+
+		if (p_user_options.protoAction) {
+			if (PROTO_ACTIONS.includes(p_user_options.protoAction)) {
+				p_options.protoAction = p_user_options.protoAction;
+			} else {
+				throw new Error(
+					// This case is possible in JS but not TS.
+					`Incorrect value for protoAction option, must be ${
+						PROTO_ACTIONS.map(
+							(a) => `"${a}"`,
+						).join(` or `)
+					} but passed ${p_user_options.protoAction}`,
+				);
+			}
+		}
+		if (p_user_options.constructorAction) {
+			if (CONSTRUCTOR_ACTIONS.includes(p_user_options.constructorAction)) {
+				p_options.constructorAction = p_user_options.constructorAction;
+			} else {
+				throw new Error(
+					// This case is possible in JS but not TS.
+					`Incorrect value for constructorAction option, must be ${
+						CONSTRUCTOR_ACTIONS.map(
+							(a) => `"${a}"`,
+						).join(` or `)
+					} but passed ${p_user_options.constructorAction}`,
+				);
+			}
+		}
+	}
+
+	const pError = (m: string) => {
+		// Call error when something is wrong.
+		throw {
+			name: `SyntaxError`,
+			message: m,
+			at: p_current_char_index,
+			text: p_text,
+		};
+	};
+	const pCurrentCharIs = (c: string) => {
+		// Verify that it matches the current character.
+		if (c !== p_current_char) {
+			return pError(`Expected '` + c + `' instead of '` + p_current_char + `'`);
+		}
+	};
+	const pNext = (c?: string) => {
+		// Get the next character. When there are no more characters,
+		// return the empty string.
+		p_current_char = p_text.charAt(++p_current_char_index);
+		// If a c parameter is provided, verify that it matches the next character.
+		if (c) pCurrentCharIs(c);
+		return p_current_char;
+	};
+	const pSkipWhite = () => {
+		// Skip whitespace.
+		while (p_current_char && p_current_char <= ` `) {
+			pNext();
+		}
+	};
+
+	const pObject = (schema?: InternalSchema) => {
+		// Parse an object value.
+
+		const result = (
+			p_options.protoAction === preserve ? Object.create(null) : {}
+		) as Record<string, JsonValue>;
+
+		if (p_current_char === `{`) {
+			pNext();
+			pSkipWhite();
+			// @ts-expect-error next() change ch
+			if (p_current_char === `}`) {
+				pNext();
+				return result; // empty object
+			}
+			while (p_current_char) {
+				const key = pString();
+				const sub_schema = isNonNullObject(schema) && !Array.isArray(schema)
+					? schema[key] || schema[Symbol.for(`any`)]
+					: undefined;
+				pSkipWhite();
+				pCurrentCharIs(`:`);
+				pNext();
+				if (
+					p_options.errorOnDuplicatedKeys === true
+					&& Object.hasOwnProperty.call(result, key)
+				) {
+					pError(`Duplicate key "${key}"`);
+				}
+
+				if (SUSPECT_PROTO_RX.test(key) === true) {
+					if (p_options.protoAction === error) {
+						pError(`Object contains forbidden prototype property`);
+					} else if (p_options.protoAction === ignore) {
+						pJsonValue();
+					} else {
+						result[key] = pJsonValue(sub_schema);
+					}
+				} else if (SUSPECT_CONSTRUCTOR_RX.test(key) === true) {
+					if (p_options.constructorAction === error) {
+						pError(`Object contains forbidden constructor property`);
+					} else if (p_options.constructorAction === ignore) {
+						pJsonValue();
+					} else {
+						result[key] = pJsonValue(sub_schema);
+					}
+				} else {
+					result[key] = pJsonValue(sub_schema);
+				}
+
+				pSkipWhite();
+				// @ts-expect-error next() change ch
+				if (p_current_char === `}`) {
+					pNext();
+					if (p_options.protoAction === preserve) {
+						Object.setPrototypeOf(result, Object.prototype);
+					}
+					return result;
+				}
+				pCurrentCharIs(`,`);
+				pNext();
+				pSkipWhite();
+			}
+		}
+		return pError(`Bad object`);
+	};
+
+	const pArray = (schema?: InternalSchema) => {
+		// Parse an array value.
+
+		const result: JsonValue[] = [];
+
+		if (p_current_char === `[`) {
+			pNext();
+			pSkipWhite();
+			// @ts-expect-error next() change ch.
+			if (p_current_char === `]`) {
+				pNext();
+				return result; // empty array
+			}
+			const is_array = Array.isArray(schema);
+			const is_tuple_like = is_array && schema.length > 1;
+			while (p_current_char) {
+				result.push(
+					pJsonValue(
+						(is_tuple_like
+							? schema[result.length]
+							: is_array
+							? schema[0]
+							: undefined) as undefined, // It's ok to cast null to undefined
+					),
+				);
+				pSkipWhite();
+				// @ts-expect-error next() change ch
+				if (p_current_char === `]`) {
+					pNext();
+					return result;
+				}
+				pCurrentCharIs(`,`);
+				pNext();
+				pSkipWhite();
+			}
+		}
+		return pError(`Bad array`);
+	};
+
+	const pString = () => {
+		// Parse a string value.
+
+		let result = ``;
+
+		// When parsing for string values, we must look for " and \ characters.
+
+		if (p_current_char === `"`) {
+			let start_at = p_current_char_index + 1;
+			while (pNext()) {
+				if (p_current_char === `"`) {
+					if (p_current_char_index > start_at) {
+						result += p_text.substring(start_at, p_current_char_index);
+					}
+					pNext();
+					return result;
+				}
+				if (p_current_char === `\\`) {
+					if (p_current_char_index > start_at) {
+						result += p_text.substring(start_at, p_current_char_index);
+					}
+					pNext();
+					if (p_current_char === `u`) {
+						let uffff = 0;
+						for (let i = 0; i < 4; i += 1) {
+							const hex = parseInt(pNext(), 16);
+							if (!isFinite(hex)) {
+								break;
+							}
+							uffff = uffff * 16 + hex;
+						}
+						result += String.fromCharCode(uffff);
+					} else if (typeof ESCAPEE[p_current_char] === `string`) {
+						result += ESCAPEE[p_current_char];
+					} else {
+						break;
+					}
+					start_at = p_current_char_index + 1;
+				}
+			}
+		}
+		return pError(`Bad string`);
+	};
+
+	const pNumber = (() => {
+		// TODO: Add test
+		const cache = new Cache<
+			string,
+			Map<SimpleSchema | undefined | null, number | bigint | string>
+		>();
+		return (schema?: SimpleSchema | null) => {
+			// Parse a number value.
+
+			let result_string = ``;
+			let is_positive = true; // for Infinity
+
+			if (p_current_char === `-`) {
+				result_string = p_current_char;
+				is_positive = false;
+				pNext();
+			}
+			if (p_current_char === `0`) {
+				result_string += p_current_char;
+				pNext();
+				if (p_current_char >= `0` && p_current_char <= `9`) {
+					pError(`Bad number`);
+				}
+			}
+			while (p_current_char >= `0` && p_current_char <= `9`) {
+				result_string += p_current_char;
+				pNext();
+			}
+			if (p_current_char === `.`) {
+				result_string += p_current_char;
+				while (pNext() && p_current_char >= `0` && p_current_char <= `9`) {
+					result_string += p_current_char;
+				}
+			}
+			if (p_current_char === `e` || p_current_char === `E`) {
+				result_string += p_current_char;
+				pNext();
+				// @ts-expect-error next() change ch
+				if (p_current_char === `-` || p_current_char === `+`) {
+					result_string += p_current_char;
+					pNext();
+				}
+				while (p_current_char >= `0` && p_current_char <= `9`) {
+					result_string += p_current_char;
+					pNext();
+				}
+			}
+			const raw_schema = schema;
+			const cache_string = cache.get(result_string);
+			if (!cache_string || !cache_string.has(raw_schema)) {
+				const cache_schema = cache_string || cache.set(result_string, new Map());
+				const result_number = Number(result_string);
+				if (Number.isNaN(result_number)) {
+					cache_schema.set(raw_schema, NaN);
+				} else if (!Number.isFinite(result_number)) {
+					cache_schema.set(raw_schema, is_positive ? Infinity : -Infinity);
+				} else {
+					// Decimal or scientific notation
+					// cannot be BigInt, aka BigInt("1.79e+308") will throw.
+					const is_decimal_or_scientific = /[.eE]/.test(result_string);
+					if (Number.isSafeInteger(result_number) || is_decimal_or_scientific) {
+						if (typeof schema === `function`) schema = schema(result_number);
+						cache_schema.set(
+							raw_schema,
+							schema === number
+								|| (!p_options.alwaysParseAsBigInt && schema !== bigint)
+								|| (is_decimal_or_scientific
+									&& !p_options.errorOnBigIntDecimalOrScientific)
+								? result_number
+								: is_decimal_or_scientific
+								? pError(`Decimal and scientific notation cannot be bigint`)
+								: BigInt(result_string),
+						);
+					} else {
+						let result_bigint;
+						if (typeof schema === `function`) {
+							result_bigint = BigInt(result_string);
+							schema = schema(result_bigint);
+						}
+						if (schema === number) cache_schema.set(raw_schema, result_number);
+						else {
+							cache_schema.set(
+								raw_schema,
+								p_options.parseBigIntAsString
+									? result_string
+									: result_bigint || BigInt(result_string),
+							);
+						}
+					}
+				}
+			}
+			const result = cache.get(result_string)!.get(raw_schema)!; // Cannot be undefined
+			return Number.isNaN(result) ? pError(`Bad number`) : result;
+		};
+	})();
+
+	const pBooleanOrNull = () => {
+		// true, false, or null.
+		switch (p_current_char) {
+			case `t`:
+				pNext(`r`);
+				pNext(`u`);
+				pNext(`e`);
+				pNext();
+				return true;
+			case `f`:
+				pNext(`a`);
+				pNext(`l`);
+				pNext(`s`);
+				pNext(`e`);
+				pNext();
+				return false;
+			case `n`:
+				pNext(`u`);
+				pNext(`l`);
+				pNext(`l`);
+				pNext();
+				return null;
+		}
+		return pError(`Unexpected '${p_current_char}'`);
+	};
+
+	const pJsonValue = (schema?: InternalSchema): JsonValue => {
+		// Parse a JSON value. It could be an object, an array, a string, a number,
+		// or boolean or null.
+
+		pSkipWhite();
+		switch (p_current_char) {
+			case `{`:
+				return pObject(schema);
+			case `[`:
+				return pArray(schema);
+			case `"`:
+				return pString();
+			case `-`:
+				return pNumber(schema as SimpleSchema);
+			default:
+				return p_current_char >= `0` && p_current_char <= `9`
+					? pNumber(schema as SimpleSchema)
+					: pBooleanOrNull();
+		}
+	};
+
+	// Return the parse function.
+	return (text, reviver, schema) => {
+		// Reset state.
+		p_current_char_index = -1; // next char will begin at 0
+		p_current_char = ` `;
+		p_text = String(text);
+
+		const result = pJsonValue(schema);
+		pSkipWhite();
+		if (p_current_char) {
+			pError(`Syntax error`);
+		}
+
+		// If there is a reviver function, we recursively walk the new structure,
+		// passing each name/value pair to the reviver function for possible
+		// transformation, starting with a temporary root object that holds the result
+		// in an empty key. If there is not a reviver function, we simply return the
+		// result.
+
+		if (typeof reviver === `function`) {
+			return (function walk(
+				object_or_array: Record<string, JsonValue> | JsonValue[],
+				key: string,
+			) {
+				// @ts-expect-error index array with string
+				const value = object_or_array[key] as JsonValue;
+				if (isNonNullObject(value)) {
+					const revived_keys = new Set<string>();
+					for (const reviving_key in value) {
+						const next_object_or_array = !Array.isArray(value)
+							? { ...value }
+							: [...value];
+						// @ts-expect-error index array with string
+						revived_keys.forEach((rk) => delete next_object_or_array[rk]);
+						const v = walk(next_object_or_array, reviving_key);
+						revived_keys.add(reviving_key);
+						if (v !== undefined) {
+							// @ts-expect-error index array with string
+							value[reviving_key] = v;
+						} else {
+							// @ts-expect-error index array with string
+							delete value[reviving_key];
+						}
+					}
+				}
+				return reviver.call(object_or_array, key, value);
+			})({ '': result }, ``) as JsonValue;
+		}
+		return result;
+	};
+};
diff --git a/drizzle-kit/src/utils/when-json-met-bigint/stringify.ts b/drizzle-kit/src/utils/when-json-met-bigint/stringify.ts
new file mode 100644
index 0000000000..bf875c69dc
--- /dev/null
+++ b/drizzle-kit/src/utils/when-json-met-bigint/stringify.ts
@@ -0,0 +1,216 @@
+import { Cache, isNonNullObject } from './lib';
+
+const isNonNullObjectWithToJSOnImplemented = <T>(
+	o: T,
+): o is T & { toJSON: (key?: string) => unknown } => isNonNullObject(o) && typeof (o as any).toJSON === `function`;
+
+// Number -> number & String -> string
+const toPrimitive = <T>(o: number | string | T) =>
+	o instanceof Number ? Number(o) : o instanceof String ? String(o) : o; // oxlint-disable-line no-instanceof-builtins drizzle-internal/no-instanceof
+
+const quote = (() => {
+	const ESCAPABLE =
+		// eslint-disable-next-line no-control-regex, no-misleading-character-class
+		/[\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+	const META = {
+		// Table of character substitutions.
+		'\b': `\\b`,
+		'\t': `\\t`,
+		'\n': `\\n`,
+		'\f': `\\f`,
+		'\r': `\\r`,
+		'"': `\\"`,
+		'\\': `\\\\`,
+	} as const;
+
+	const cache = new Cache<string, string>();
+	return (s: string) => {
+		if (!cache.has(s)) {
+			// If the string contains no control characters, no quote characters, and no
+			// backslash characters, then we can safely slap some quotes around it.
+			// Otherwise we must also replace the offending characters with safe escape
+			// sequences.
+			ESCAPABLE.lastIndex = 0;
+			cache.set(
+				s,
+				ESCAPABLE.test(s)
+					? `"`
+						+ s.replace(ESCAPABLE, function(a) {
+							const c = META[a as keyof typeof META];
+							return typeof c === `string`
+								? c
+								: `\\u` + (`0000` + a.charCodeAt(0).toString(16)).slice(-4);
+						})
+						+ `"`
+					: `"` + s + `"`,
+			);
+		}
+		return cache.get(s)!; // Cannot be undefined
+	};
+})();
+
+type ReplacerFn = (this: any, key: string, value: any) => any;
+type Stringified<V> = V extends symbol | Function ? undefined
+	: ReturnType<typeof JSON.stringify>;
+type Stringify = <V>(
+	value: V,
+	replacer?: (number | number | string | string)[] | ReplacerFn | null,
+	space?: Parameters<typeof JSON.stringify>[2] | number | string,
+	n?: boolean,
+) => Stringified<V>;
+// Closure for internal state variables.
+// Serializer's internal state variables are prefixed with s_, methods are prefixed with s.
+export const stringify = ((): Stringify => {
+	// This immediately invoked function returns a function that stringify JS
+	// data structure.
+
+	// Original spec use stack, but stack is slow and not necessary in this case
+	// use Set instead
+	const stack = new Set();
+	let indent: string; // current indentation
+	let gap: string; // JSON indentation string
+	let sReplacer: ReplacerFn | null | undefined;
+	const s_replacer = new Set<string>();
+
+	const sStringify = <T extends Record<string, unknown> | unknown[]>(
+		object_or_array: T,
+		key_or_index: T extends Record<string, unknown> ? keyof T : number,
+		delim: string,
+		n?: boolean,
+	): string | undefined => {
+		// Produce a string from object_or_array[key_or_index].
+
+		// @ts-expect-error index array with string
+		let value = object_or_array[key_or_index] as unknown;
+
+		// If the value has toJSON method, call it.
+		if (isNonNullObjectWithToJSOnImplemented(value)) {
+			value = value.toJSON();
+		}
+
+		// If we were called with a replacer function, then call the replacer to
+		// obtain a replacement value.
+		if (typeof sReplacer === `function`) {
+			value = sReplacer.call(object_or_array, key_or_index.toString(), value);
+		}
+
+		// What happens next depends on the value's type.
+		switch (typeof value) {
+			case `string`:
+				return quote(value);
+			case `number`:
+				// JSON numbers must be finite. Encode non-finite numbers as null.
+				return Number.isFinite(value) ? value.toString() : `null`;
+			case `boolean`:
+				return value.toString();
+			case `bigint`:
+				return n ? `${value.toString()}n` : value.toString();
+			case `object`: {
+				// If the type is 'object', we might be dealing with an object
+				// or an array or null.
+				// Due to a specification blunder in ECMAScript, typeof null is 'object',
+				// so watch out for that case.
+
+				if (!value) {
+					return `null`;
+				}
+
+				if (stack.has(value)) throw new TypeError(`cyclic object value`);
+				stack.add(value);
+				const last_gap = indent; // stepback
+				indent += gap;
+
+				if (Array.isArray(value)) {
+					// Make an array to hold the partial results of stringifying this object value.
+					// The value is an array. Stringify every element. Use null as a placeholder
+					// for non-JSON values.
+					const partial = value.map(
+						(_v_, i) => sStringify(value as unknown[], i, delim, n) || `null`,
+					);
+
+					// Join all of the elements together, separated with commas, and wrap them in
+					// brackets.
+					const result = partial.length === 0
+						? `[]`
+						: indent
+						? `[\n`
+							+ indent
+							+ partial.join(`${delim}\n` + indent)
+							+ `\n`
+							+ last_gap
+							+ `]`
+						: `[` + partial.join(delim) + `]`;
+					stack.delete(value);
+					indent = last_gap;
+					return result;
+				}
+
+				const partial: string[] = [];
+				(s_replacer.size > 0 ? s_replacer : Object.keys(value)).forEach(
+					(key) => {
+						const v = sStringify(value as Record<string, unknown>, key, delim, n);
+						if (v) {
+							partial.push(quote(key) + (gap ? `: ` : `:`) + v);
+						}
+					},
+				);
+
+				// Join all of the member texts together, separated with commas,
+				// and wrap them in braces.
+				const result = partial.length === 0
+					? `{}`
+					: indent
+					? `{\n`
+						+ indent
+						+ partial.join(`${delim}\n` + indent)
+						+ `\n`
+						+ last_gap
+						+ `}`
+					: `{` + partial.join(delim) + `}`;
+				stack.delete(value);
+				indent = last_gap;
+				return result;
+			}
+		}
+	};
+
+	// Return the stringify function.
+	return (value, replacer, space, n) => {
+		value = toPrimitive(value) as typeof value;
+		// Reset state.
+		stack.clear();
+
+		indent = ``;
+		// If the space parameter is a number, make an indent string containing that
+		// many spaces.
+		// If the space parameter is a string, it will be used as the indent string.
+		const primitive_space = toPrimitive(space);
+		gap = typeof primitive_space === `number` && primitive_space > 0
+			? Array.from({ length: primitive_space + 1 }).join(` `)
+			: typeof primitive_space !== `string`
+			? ``
+			: primitive_space.length > 10
+			? primitive_space.slice(0, 10)
+			: primitive_space;
+
+		s_replacer.clear();
+		if (Array.isArray(replacer)) {
+			sReplacer = null;
+			if (isNonNullObject(value)) {
+				replacer.forEach((e) => {
+					const key = toPrimitive(e);
+					if (typeof key === `string` || typeof key === `number`) {
+						const key_string = key.toString();
+						if (!s_replacer.has(key_string)) s_replacer.add(key_string);
+					}
+				});
+			}
+		} else sReplacer = replacer;
+
+		// Make a fake root object containing our value under the key of ''.
+		// Return the result of stringifying the value.
+		// Cheating here, JSON.stringify can return undefined but overloaded types
+		// are not seen here so we cast to string to satisfy tsc
+		return sStringify({ '': value }, ``, ',', n) as Stringified<typeof value>;
+	};
+})();
diff --git a/drizzle-kit/src/utils/words.ts b/drizzle-kit/src/utils/words.ts
index b0c686659d..7853b42b4a 100644
--- a/drizzle-kit/src/utils/words.ts
+++ b/drizzle-kit/src/utils/words.ts
@@ -1,23 +1,9 @@
-import type { Prefix } from '../cli/validations/common';
+import { prepareSnapshotFolderName } from '../cli/commands/generate-common';
 
 export const prepareMigrationMetadata = (
-	idx: number,
-	prefixMode: Prefix,
 	name?: string,
 ) => {
-	const prefix = prefixMode === 'index'
-		? idx.toFixed(0).padStart(4, '0')
-		: prefixMode === 'timestamp' || prefixMode === 'supabase'
-		? new Date()
-			.toISOString()
-			.replace('T', '')
-			.replaceAll('-', '')
-			.replaceAll(':', '')
-			.slice(0, 14)
-		: prefixMode === 'unix'
-		? Math.floor(Date.now() / 1000)
-		: '';
-
+	const prefix = prepareSnapshotFolderName();
 	const suffix = name || `${adjectives.random()}_${heroes.random()}`;
 	const tag = `${prefix}_${suffix}`;
 	return { prefix, suffix, tag };
diff --git a/drizzle-kit/tests/api.test.ts b/drizzle-kit/tests/api.test.ts
deleted file mode 100644
index 1afcfca057..0000000000
--- a/drizzle-kit/tests/api.test.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { preparePgDB } from '../src/api';
-
-vi.mock('pg', () => ({
-	default: {
-		types: {
-			builtins: {
-				DATE: 1082,
-				INTERVAL: 1186,
-				TIMESTAMP: 1114,
-				TIMESTAMPTZ: 1184,
-			},
-			getTypeParser: vi.fn(() => (value: unknown) => value),
-		},
-	},
-}));
-
-vi.mock('drizzle-orm/node-postgres', () => ({
-	drizzle: vi.fn().mockReturnValue({}),
-}));
-
-vi.mock('drizzle-orm/node-postgres/migrator', () => ({
-	migrate: vi.fn(),
-}));
-
-function createObservedPool() {
-	let activeQueries = 0;
-	let maxActiveQueries = 0;
-
-	const query = vi.fn(async (input: { text: string }) => {
-		activeQueries += 1;
-		maxActiveQueries = Math.max(maxActiveQueries, activeQueries);
-
-		await new Promise((resolve) => setTimeout(resolve, 10));
-
-		activeQueries -= 1;
-		return { rows: [input.text] };
-	});
-
-	return {
-		pool: { query },
-		query,
-		getMaxActiveQueries: () => maxActiveQueries,
-	};
-}
-
-describe('preparePgDB', () => {
-	test('does not limit query concurrency by default', async () => {
-		const observed = createObservedPool();
-		const db = await preparePgDB(observed.pool as any);
-
-		await Promise.all([
-			db.query('select 1'),
-			db.query('select 2'),
-			db.query('select 3'),
-			db.query('select 4'),
-		]);
-
-		expect(observed.query).toHaveBeenCalledTimes(4);
-		expect(observed.getMaxActiveQueries()).toBe(4);
-	});
-
-	test('limits query and proxy calls with queryConcurrency', async () => {
-		const observed = createObservedPool();
-		const db = await preparePgDB(observed.pool as any, {
-			queryConcurrency: 2,
-		});
-
-		await Promise.all([
-			db.query('select 1'),
-			db.query('select 2'),
-			db.query('select 3'),
-			db.proxy({ mode: 'array', params: [], sql: 'select 4' }),
-			db.proxy({ mode: 'object', params: [], sql: 'select 5' }),
-		]);
-
-		expect(observed.query).toHaveBeenCalledTimes(5);
-		expect(observed.getMaxActiveQueries()).toBe(2);
-	});
-
-	test('rejects invalid queryConcurrency values', async () => {
-		const observed = createObservedPool();
-
-		await expect(
-			preparePgDB(observed.pool as any, { queryConcurrency: 0 }),
-		).rejects.toThrow('queryConcurrency must be a positive integer');
-		await expect(
-			preparePgDB(observed.pool as any, { queryConcurrency: -1 }),
-		).rejects.toThrow('queryConcurrency must be a positive integer');
-		await expect(
-			preparePgDB(observed.pool as any, { queryConcurrency: 1.5 }),
-		).rejects.toThrow('queryConcurrency must be a positive integer');
-	});
-});
diff --git a/drizzle-kit/tests/bin.test.ts b/drizzle-kit/tests/bin.test.ts
deleted file mode 100644
index 8264966767..0000000000
--- a/drizzle-kit/tests/bin.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import chalk from 'chalk';
-import { assert, test } from 'vitest';
-import { analyzeImports, ChainLink } from '../imports-checker/checker';
-
-test('imports-issues', () => {
-	const issues = analyzeImports({
-		basePath: '.',
-		localPaths: ['src'],
-		whiteList: [
-			'@drizzle-team/brocli',
-			'json-diff',
-			'path',
-			'fs',
-			'fs/*',
-			'url',
-			'zod',
-			'node:*',
-			'hono',
-			'glob',
-			'hono/*',
-			'hono/**/*',
-			'@hono/*',
-			'crypto',
-			'hanji',
-			'chalk',
-			'dotenv/config',
-			'camelcase',
-			'semver',
-			'env-paths',
-		],
-		entry: 'src/cli/index.ts',
-		logger: true,
-		ignoreTypes: true,
-	}).issues;
-
-	const chainToString = (chains: ChainLink[]) => {
-		if (chains.length === 0) throw new Error();
-
-		let out = chains[0]!.file + '\n';
-		let indentation = 0;
-		for (let chain of chains) {
-			out += ' '.repeat(indentation)
-				+ '└'
-				+ chain.import
-				+ ` ${chalk.gray(chain.file)}\n`;
-			indentation += 1;
-		}
-		return out;
-	};
-
-	console.log();
-	for (const issue of issues) {
-		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
-		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
-	}
-
-	assert.equal(issues.length, 0);
-});
diff --git a/drizzle-kit/tests/cli-export.test.ts b/drizzle-kit/tests/cli-export.test.ts
deleted file mode 100644
index 8719ddd6a7..0000000000
--- a/drizzle-kit/tests/cli-export.test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { test as brotest } from '@drizzle-team/brocli';
-import { assert, expect, test } from 'vitest';
-import { exportRaw } from '../src/cli/schema';
-
-// good:
-// #1 drizzle-kit export --dialect=postgresql --schema=schema.ts
-// #3 drizzle-kit export
-// #3 drizzle-kit export --config=drizzle1.config.ts
-
-// errors:
-// #1 drizzle-kit export --schema=src/schema.ts
-// #2 drizzle-kit export --dialect=postgresql
-// #3 drizzle-kit export --dialect=postgresql2
-// #4 drizzle-kit export --config=drizzle.config.ts --schema=schema.ts
-// #5 drizzle-kit export --config=drizzle.config.ts --dialect=postgresql
-
-test('export #1', async (t) => {
-	const res = await brotest(
-		exportRaw,
-		'--dialect=postgresql --schema=schema.ts',
-	);
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		schema: 'schema.ts',
-		sql: true,
-	});
-});
-
-test('export #2', async (t) => {
-	const res = await brotest(exportRaw, '');
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		schema: './schema.ts',
-		sql: true,
-	});
-});
-
-// custom config path
-test('export #3', async (t) => {
-	const res = await brotest(exportRaw, '--config=expo.config.ts');
-	assert.equal(res.type, 'handler');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		schema: './schema.ts',
-		sql: true,
-	});
-});
-
-// --- errors ---
-test('err #1', async (t) => {
-	const res = await brotest(exportRaw, '--schema=src/schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #2', async (t) => {
-	const res = await brotest(exportRaw, '--dialect=postgresql');
-	assert.equal(res.type, 'error');
-});
-
-test('err #3', async (t) => {
-	const res = await brotest(exportRaw, '--dialect=postgresql2');
-	assert.equal(res.type, 'error');
-});
-
-test('err #4', async (t) => {
-	const res = await brotest(exportRaw, '--config=drizzle.config.ts --schema=schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #5', async (t) => {
-	const res = await brotest(exportRaw, '--config=drizzle.config.ts --dialect=postgresql');
-	assert.equal(res.type, 'error');
-});
diff --git a/drizzle-kit/tests/cli-generate.test.ts b/drizzle-kit/tests/cli-generate.test.ts
deleted file mode 100644
index a4adf979f2..0000000000
--- a/drizzle-kit/tests/cli-generate.test.ts
+++ /dev/null
@@ -1,259 +0,0 @@
-import { test as brotest } from '@drizzle-team/brocli';
-import { assert, expect, test } from 'vitest';
-import { generate } from '../src/cli/schema';
-
-// good:
-// #1 drizzle-kit generate --dialect=postgresql --schema=schema.ts
-// #2 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out
-// #3 drizzle-kit generate
-// #4 drizzle-kit generate --custom
-// #5 drizzle-kit generate --name=custom
-// #6 drizzle-kit generate --prefix=timestamp
-// #7 drizzle-kit generate --prefix=timestamp --name=custom --custom
-// #8 drizzle-kit generate --config=drizzle1.config.ts
-// #9 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out --prefix=timestamp --name=custom --custom
-
-// errors:
-// #1 drizzle-kit generate --schema=src/schema.ts
-// #2 drizzle-kit generate --dialect=postgresql
-// #3 drizzle-kit generate --dialect=postgresql2
-// #4 drizzle-kit generate --driver=expo
-// #5 drizzle-kit generate --dialect=postgresql --out=out
-// #6 drizzle-kit generate --config=drizzle.config.ts --out=out
-// #7 drizzle-kit generate --config=drizzle.config.ts --schema=schema.ts
-// #8 drizzle-kit generate --config=drizzle.config.ts --dialect=postgresql
-
-test('generate #1', async (t) => {
-	const res = await brotest(
-		generate,
-		'--dialect=postgresql --schema=schema.ts',
-	);
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: undefined,
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: 'schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-test('generate #2', async (t) => {
-	const res = await brotest(
-		generate,
-		'--dialect=postgresql --schema=schema.ts --out=out',
-	);
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: undefined,
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: 'schema.ts',
-		out: 'out',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-test('generate #3', async (t) => {
-	const res = await brotest(generate, '');
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: undefined,
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// config | pass through custom
-test('generate #4', async (t) => {
-	const res = await brotest(generate, '--custom');
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: undefined,
-		custom: true,
-		prefix: 'index',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// config | pass through name
-test('generate #5', async (t) => {
-	const res = await brotest(generate, '--name=custom');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: 'custom',
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// config | pass through prefix
-test('generate #6', async (t) => {
-	const res = await brotest(generate, '--prefix=timestamp');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: undefined,
-		custom: false,
-		prefix: 'timestamp',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// config | pass through name, prefix and custom
-test('generate #7', async (t) => {
-	const res = await brotest(
-		generate,
-		'--prefix=timestamp --name=custom --custom',
-	);
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: 'custom',
-		custom: true,
-		prefix: 'timestamp',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// custom config path
-test('generate #8', async (t) => {
-	const res = await brotest(generate, '--config=expo.config.ts');
-	assert.equal(res.type, 'handler');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		name: undefined,
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: true, // expo driver
-		casing: undefined,
-		driver: 'expo',
-	});
-});
-
-test('generate #9', async (t) => {
-	const res = await brotest(generate, '--config=durable-sqlite.config.ts');
-	assert.equal(res.type, 'handler');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		name: undefined,
-		custom: false,
-		prefix: 'index',
-		breakpoints: true,
-		schema: './schema.ts',
-		out: 'drizzle',
-		bundle: true, // expo driver
-		casing: undefined,
-		driver: 'durable-sqlite',
-	});
-});
-
-// cli | pass through name, prefix and custom
-test('generate #9', async (t) => {
-	const res = await brotest(
-		generate,
-		'--dialect=postgresql --schema=schema.ts --out=out --prefix=timestamp --name=custom --custom',
-	);
-
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		name: 'custom',
-		custom: true,
-		prefix: 'timestamp',
-		breakpoints: true,
-		schema: 'schema.ts',
-		out: 'out',
-		bundle: false,
-		casing: undefined,
-		driver: undefined,
-	});
-});
-
-// --- errors ---
-test('err #1', async (t) => {
-	const res = await brotest(generate, '--schema=src/schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #2', async (t) => {
-	const res = await brotest(generate, '--dialect=postgresql');
-	assert.equal(res.type, 'error');
-});
-
-test('err #3', async (t) => {
-	const res = await brotest(generate, '--dialect=postgresql2');
-	assert.equal(res.type, 'error');
-});
-
-test('err #4', async (t) => {
-	const res = await brotest(generate, '--driver=expo');
-	assert.equal(res.type, 'error');
-});
-
-test('err #5', async (t) => {
-	const res = await brotest(generate, '--dialect=postgresql --out=out');
-	assert.equal(res.type, 'error');
-});
-
-test('err #6', async (t) => {
-	const res = await brotest(generate, '--config=drizzle.config.ts --out=out');
-	assert.equal(res.type, 'error');
-});
-
-test('err #7', async (t) => {
-	const res = await brotest(generate, '--config=drizzle.config.ts --schema=schema.ts');
-	assert.equal(res.type, 'error');
-});
-
-test('err #8', async (t) => {
-	const res = await brotest(generate, '--config=drizzle.config.ts --dialect=postgresql');
-	assert.equal(res.type, 'error');
-});
diff --git a/drizzle-kit/tests/cli-migrate.test.ts b/drizzle-kit/tests/cli-migrate.test.ts
deleted file mode 100644
index 1425691f0b..0000000000
--- a/drizzle-kit/tests/cli-migrate.test.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import { test as brotest } from '@drizzle-team/brocli';
-import { assert, expect, test } from 'vitest';
-import { migrate } from '../src/cli/schema';
-
-// good:
-// #1 drizzle-kit generate
-// #2 drizzle-kit generate --config=turso.config.ts
-// #3 drizzle-kit generate --config=d1http.config.ts
-// #4 drizzle-kit generate --config=postgres.config.ts ## spread connection params
-// #5 drizzle-kit generate --config=drizzle2.config.ts ## custom schema and table for migrations journal
-
-// errors:
-// #1 drizzle-kit generate --config=expo.config.ts
-// TODO: missing required params in config?
-
-test('migrate #1', async (t) => {
-	const res = await brotest(migrate, '');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		out: 'drizzle',
-		credentials: {
-			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
-		},
-		schema: undefined, // drizzle migrations table schema
-		table: undefined, // drizzle migrations table name
-	});
-});
-
-test('migrate #2', async (t) => {
-	const res = await brotest(migrate, '--config=turso.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'turso',
-		out: 'drizzle',
-		credentials: {
-			authToken: 'token',
-			url: 'turso.dev',
-		},
-		schema: undefined, // drizzle migrations table schema
-		table: undefined, // drizzle migrations table name
-	});
-});
-
-test('migrate #3', async (t) => {
-	const res = await brotest(migrate, '--config=d1http.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		out: 'drizzle',
-		credentials: {
-			driver: 'd1-http',
-			accountId: 'accid',
-			databaseId: 'dbid',
-			token: 'token',
-		},
-		schema: undefined, // drizzle migrations table schema
-		table: undefined, // drizzle migrations table name
-	});
-});
-
-test('migrate #4', async (t) => {
-	const res = await brotest(migrate, '--config=postgres.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		out: 'drizzle',
-		credentials: {
-			database: 'db',
-			host: '127.0.0.1',
-			password: 'postgres',
-			port: 5432,
-			user: 'postgresql',
-		},
-		schema: undefined, // drizzle migrations table schema
-		table: undefined, // drizzle migrations table name
-	});
-});
-
-// catched a bug
-test('migrate #5', async (t) => {
-	const res = await brotest(migrate, '--config=postgres2.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		out: 'drizzle',
-		credentials: {
-			database: 'db',
-			host: '127.0.0.1',
-			password: 'postgres',
-			port: 5432,
-			user: 'postgresql',
-		},
-		schema: 'custom', // drizzle migrations table schema
-		table: 'custom', // drizzle migrations table name
-	});
-});
-
-// --- errors ---
-test('err #1', async (t) => {
-	const res = await brotest(migrate, '--config=expo.config.ts');
-	assert.equal(res.type, 'error');
-});
diff --git a/drizzle-kit/tests/cli-push.test.ts b/drizzle-kit/tests/cli-push.test.ts
deleted file mode 100644
index f5daf2bd05..0000000000
--- a/drizzle-kit/tests/cli-push.test.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { test as brotest } from '@drizzle-team/brocli';
-import { assert, expect, test } from 'vitest';
-import { push } from '../src/cli/schema';
-
-// good:
-// #1 drizzle-kit push
-// #2 drizzle-kit push --config=turso.config.ts
-// #3 drizzle-kit push --config=d1http.config.ts
-// #4 drizzle-kit push --config=postgres.config.ts ## spread connection params
-// #5 drizzle-kit push --config=drizzle2.config.ts ## custom schema and table for migrations journal
-
-// errors:
-// #1 drizzle-kit push --config=expo.config.ts
-// TODO: missing required params in config?
-
-test('push #1', async (t) => {
-	const res = await brotest(push, '');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		credentials: {
-			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
-		},
-		force: false,
-		schemaPath: './schema.ts',
-		schemasFilter: ['public'],
-		tablesFilter: [],
-		entities: undefined,
-		strict: false,
-		verbose: false,
-		casing: undefined,
-	});
-});
-
-test('push #2', async (t) => {
-	const res = await brotest(push, '--config=turso.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'turso',
-		credentials: {
-			authToken: 'token',
-			url: 'turso.dev',
-		},
-		force: false,
-		schemaPath: './schema.ts',
-		schemasFilter: ['public'],
-		tablesFilter: [],
-		strict: false,
-		verbose: false,
-		casing: undefined,
-	});
-});
-
-test('push #3', async (t) => {
-	const res = await brotest(push, '--config=d1http.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'sqlite',
-		credentials: {
-			driver: 'd1-http',
-			accountId: 'accid',
-			databaseId: 'dbid',
-			token: 'token',
-		},
-		force: false,
-		schemaPath: './schema.ts',
-		schemasFilter: ['public'],
-		tablesFilter: [],
-		strict: false,
-		verbose: false,
-		casing: undefined,
-	});
-});
-
-test('push #4', async (t) => {
-	const res = await brotest(push, '--config=postgres.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		credentials: {
-			database: 'db',
-			host: '127.0.0.1',
-			password: 'postgres',
-			port: 5432,
-			user: 'postgresql',
-		},
-		force: false,
-		schemaPath: './schema.ts',
-		schemasFilter: ['public'],
-		tablesFilter: [],
-		entities: undefined,
-		strict: false,
-		verbose: false,
-		casing: undefined,
-	});
-});
-
-// catched a bug
-test('push #5', async (t) => {
-	const res = await brotest(push, '--config=postgres2.config.ts');
-	if (res.type !== 'handler') assert.fail(res.type, 'handler');
-	expect(res.options).toStrictEqual({
-		dialect: 'postgresql',
-		credentials: {
-			database: 'db',
-			host: '127.0.0.1',
-			password: 'postgres',
-			port: 5432,
-			user: 'postgresql',
-		},
-		schemaPath: './schema.ts',
-		schemasFilter: ['public'],
-		tablesFilter: [],
-		strict: false,
-		entities: undefined,
-		force: false,
-		verbose: false,
-		casing: undefined,
-	});
-});
-
-// --- errors ---
-test('err #1', async (t) => {
-	const res = await brotest(push, '--config=expo.config.ts');
-	assert.equal(res.type, 'error');
-});
diff --git a/drizzle-kit/tests/cockroach/array.test.ts b/drizzle-kit/tests/cockroach/array.test.ts
new file mode 100644
index 0000000000..0f75469637
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/array.test.ts
@@ -0,0 +1,264 @@
+import {
+	bigint,
+	boolean,
+	cockroachEnum,
+	cockroachTable,
+	date,
+	int4,
+	text,
+	timestamp,
+	uuid,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('array #1: empty array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: int4('values').array().default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['public'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+
+	const st0 = [`ALTER TABLE "test" ADD COLUMN "values" int4[] DEFAULT '{}'::int4[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #2: int4 array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: int4('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE \"test\" ADD COLUMN \"values\" int4[] DEFAULT '{1,2,3}'::int4[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #3: bigint array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: bigint('values', { mode: 'bigint' }).array().default([BigInt(1), BigInt(2), BigInt(3)]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE \"test\" ADD COLUMN \"values\" int8[] DEFAULT '{1,2,3}'::int8[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #4: boolean array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: boolean('values').array().default([true, false, true]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE \"test\" ADD COLUMN \"values\" bool[] DEFAULT '{true,false,true}'::bool[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #6: date array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: date('values').array().default(['2024-08-06', '2024-08-07']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" date[] DEFAULT \'{2024-08-06,2024-08-07}\'::date[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #7: timestamp array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: timestamp('values').array().default([new Date('2024-08-06'), new Date('2024-08-07')]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" timestamp[] DEFAULT \'{"2024-08-06 00:00:00.000","2024-08-07 00:00:00.000"}\'::timestamp[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #9: text array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: text('values').array().default(['abc', 'def']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['ALTER TABLE "test" ADD COLUMN "values" string[] DEFAULT \'{abc,def}\'::string[];'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #10: uuid array default', async ({ dbc: db }) => {
+	const from = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: uuid('values').array().default([
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+				'b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11',
+			]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" uuid[] DEFAULT \'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11}\'::uuid[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #11: enum array default', async ({ dbc: db }) => {
+	const testEnum = cockroachEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: testEnum('values').array().default(['a', 'b', 'c']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" "test_enum"[] DEFAULT \'{a,b,c}\'::"test_enum"[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('array #12: enum empty array default', async ({ dbc: db }) => {
+	const testEnum = cockroachEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: cockroachTable('test', {
+			id: int4('id'),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: cockroachTable('test', {
+			id: int4('id'),
+			values: testEnum('values').array().default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['ALTER TABLE "test" ADD COLUMN "values" "test_enum"[] DEFAULT \'{}\'::"test_enum"[];'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/checks.test.ts b/drizzle-kit/tests/cockroach/checks.test.ts
new file mode 100644
index 0000000000..28581bff2e
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/checks.test.ts
@@ -0,0 +1,219 @@
+import { sql } from 'drizzle-orm';
+import { check, cockroachTable, int4, varchar } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('create table with check', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"age" int4,\n\tCONSTRAINT "some_check_name" CHECK ("users"."age" > 21)\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add check contraint to existing table', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE "users" ADD CONSTRAINT "some_check_name" CHECK ("users"."age" > 21);`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop check contraint in existing table', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename check constraint', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("users"."age" > 21);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter check constraint', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			age: int4('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP CONSTRAINT "some_check_name";',
+		'ALTER TABLE "users" ADD CONSTRAINT "some_check_name" CHECK ("users"."age" > 10);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test.concurrent('alter multiple check constraints', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				age: int4('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_1', sql`${table.age} > 21`),
+				check('some_check_name_2', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const to = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				age: int4('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_3', sql`${table.age} > 21`),
+				check('some_check_name_4', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_1";`,
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_2";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_3" CHECK ("users"."age" > 21);`,
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_4" CHECK ("users"."name" != \'Alex\');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create checks with same names', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				age: int4('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [check('some_check_name', sql`${table.age} > 21`), check('some_check_name', sql`${table.name} != 'Alex'`)],
+		),
+	};
+
+	// 'constraint_name_duplicate'
+	await expect(diff({}, to, [])).rejects.toThrow();
+	// adding only CONSTRAINT "some_check_name" CHECK ("users"."age" > 21), not throwing error
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test.concurrent('db has checks. Push with same names', async ({ dbc: db }) => {
+	const schema1 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+			values: int4('values').default(1),
+		}, (table) => [check('some_check', sql`${table.values} < 100`)]),
+	};
+	const schema2 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+			values: int4('values').default(1),
+		}, (table) => [check('some_check', sql`${table.values} > 100`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "test" DROP CONSTRAINT "some_check";',
+		'ALTER TABLE "test" ADD CONSTRAINT "some_check" CHECK ("test"."values" > 100);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/cockroach/columns-without-tx.test.ts b/drizzle-kit/tests/cockroach/columns-without-tx.test.ts
new file mode 100644
index 0000000000..bc9853feb2
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/columns-without-tx.test.ts
@@ -0,0 +1,35 @@
+import { cockroachTable, int4, primaryKey } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('with composite pks #2', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id1: int4('id1'),
+			id2: int4('id2'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id1: int4('id1').notNull(),
+			id2: int4('id2').notNull(),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id1" SET NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" SET NOT NULL;',
+		'ALTER TABLE "users" ADD CONSTRAINT "compositePK" PRIMARY KEY("id1","id2");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/columns.test.ts b/drizzle-kit/tests/cockroach/columns.test.ts
new file mode 100644
index 0000000000..025d27ad92
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/columns.test.ts
@@ -0,0 +1,1004 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	bigint,
+	bit,
+	bool,
+	boolean,
+	char,
+	cockroachEnum,
+	cockroachSchema,
+	cockroachTable,
+	date,
+	decimal,
+	doublePrecision,
+	float,
+	index,
+	int2,
+	int4,
+	int8,
+	interval,
+	jsonb,
+	numeric,
+	primaryKey,
+	real,
+	smallint,
+	string,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varbit,
+	varchar,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('add columns #1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = ['ALTER TABLE "users" ADD COLUMN "name" string;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add columns #2', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "users" ADD COLUMN "name" string;',
+		'ALTER TABLE "users" ADD COLUMN "email" string;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column conflict duplicate name #1', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			name: varchar('name', { length: 100 }).primaryKey(),
+			email: text('name'),
+		}),
+	};
+
+	await push({ to: schema1, db });
+
+	await expect(diff(schema1, schema2, [])).rejects.toThrowError(); // duplicate names in columns
+	await expect(push({ to: schema2, db })).rejects.toThrowError(); // duplicate names in columns
+});
+
+test.concurrent('alter column change name #1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users.name->public.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users.name->public.users.name1',
+		],
+	});
+
+	const st0 = ['ALTER TABLE "users" RENAME COLUMN "name" TO "name1";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter column change name #2', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name1'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users.name->public.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users.name->public.users.name1',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME COLUMN "name" TO "name1";',
+		'ALTER TABLE "users" ADD COLUMN "email" string;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter table add composite pk', async ({ dbc: db }) => {
+	const schema1 = {
+		table: cockroachTable('table', {
+			id1: int4('id1').notNull(),
+			id2: int4('id2').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		table: cockroachTable('table', {
+			id1: int4('id1').notNull(),
+			id2: int4('id2').notNull(),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(
+		schema1,
+		schema2,
+		[],
+	);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = ['ALTER TABLE "table" ADD PRIMARY KEY ("id1","id2");'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename table rename column #1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users1', {
+			id: int4('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users->public.users1',
+		'public.users1.id->public.users1.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users->public.users1',
+			'public.users1.id->public.users1.id1',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users1";',
+		'ALTER TABLE "users1" RENAME COLUMN "id" TO "id1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('with composite pks #1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id1: int4('id1'),
+			id2: int4('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id1: int4('id1'),
+			id2: int4('id2'),
+			text: text('text'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = ['ALTER TABLE "users" ADD COLUMN "text" string;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('with composite pks #3', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable(
+			'users',
+			{
+				id1: int4('id1'),
+				id2: int4('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id1: int4('id1'),
+			id3: int4('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3], name: 'compositePK' })]),
+	};
+
+	const renames = ['public.users.id2->public.users.id3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0 = ['ALTER TABLE "users" RENAME COLUMN "id2" TO "id3";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create composite primary key', async ({ dbc: db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		table: cockroachTable('table', {
+			col1: int4('col1').notNull(),
+			col2: int4('col2').notNull(),
+		}, (t) => [primaryKey({
+			columns: [t.col1, t.col2],
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE "table" (\n\t"col1" int4,\n\t"col2" int4,\n\tCONSTRAINT "table_pkey" PRIMARY KEY("col1","col2")\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add multiple constraints #1', async ({ dbc: db }) => {
+	const t1 = cockroachTable('t1', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const t2 = cockroachTable('t2', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const t3 = cockroachTable('t3', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const schema1 = {
+		t1,
+		t2,
+		t3,
+		ref1: cockroachTable('ref1', {
+			id1: uuid('id1').references(() => t1.id),
+			id2: uuid('id2').references(() => t2.id),
+			id3: uuid('id3').references(() => t3.id),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		t2,
+		t3,
+		ref1: cockroachTable('ref1', {
+			id1: uuid('id1').references(() => t1.id, { onDelete: 'cascade' }),
+			id2: uuid('id2').references(() => t2.id, { onDelete: 'set null' }),
+			id3: uuid('id3').references(() => t3.id, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id1_t1_id_fkey", ADD CONSTRAINT "ref1_id1_t1_id_fkey" FOREIGN KEY ("id1") REFERENCES "t1"("id") ON DELETE CASCADE;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id2_t2_id_fkey", ADD CONSTRAINT "ref1_id2_t2_id_fkey" FOREIGN KEY ("id2") REFERENCES "t2"("id") ON DELETE SET NULL;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id3_t3_id_fkey", ADD CONSTRAINT "ref1_id3_t3_id_fkey" FOREIGN KEY ("id3") REFERENCES "t3"("id") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add multiple constraints #2', async ({ dbc: db }) => {
+	const t1 = cockroachTable('t1', {
+		id1: uuid('id1').unique(),
+		id2: uuid('id2').unique(),
+		id3: uuid('id3').unique(),
+	});
+
+	const schema1 = {
+		t1,
+		ref1: cockroachTable('ref1', {
+			id1: uuid('id1').references(() => t1.id1),
+			id2: uuid('id2').references(() => t1.id2),
+			id3: uuid('id3').references(() => t1.id3),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		ref1: cockroachTable('ref1', {
+			id1: uuid('id1').references(() => t1.id1, { onDelete: 'cascade' }),
+			id2: uuid('id2').references(() => t1.id2, { onDelete: 'set null' }),
+			id3: uuid('id3').references(() => t1.id3, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id1_t1_id1_fkey", ADD CONSTRAINT "ref1_id1_t1_id1_fkey" FOREIGN KEY ("id1") REFERENCES "t1"("id1") ON DELETE CASCADE;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id2_t1_id2_fkey", ADD CONSTRAINT "ref1_id2_t1_id2_fkey" FOREIGN KEY ("id2") REFERENCES "t1"("id2") ON DELETE SET NULL;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id3_t1_id3_fkey", ADD CONSTRAINT "ref1_id3_t1_id3_fkey" FOREIGN KEY ("id3") REFERENCES "t1"("id3") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add multiple constraints #3', async ({ dbc: db }) => {
+	const t1 = cockroachTable('t1', {
+		id1: uuid('id1').unique(),
+		id2: uuid('id2').unique(),
+		id3: uuid('id3').unique(),
+	});
+
+	const schema1 = {
+		t1,
+		ref1: cockroachTable('ref1', {
+			id: uuid('id').references(() => t1.id1),
+		}),
+		ref2: cockroachTable('ref2', {
+			id: uuid('id').references(() => t1.id2),
+		}),
+		ref3: cockroachTable('ref3', {
+			id: uuid('id').references(() => t1.id3),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		ref1: cockroachTable('ref1', {
+			id: uuid('id').references(() => t1.id1, { onDelete: 'cascade' }),
+		}),
+		ref2: cockroachTable('ref2', {
+			id: uuid('id').references(() => t1.id2, { onDelete: 'set null' }),
+		}),
+		ref3: cockroachTable('ref3', {
+			id: uuid('id').references(() => t1.id3, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id_t1_id1_fkey", ADD CONSTRAINT "ref1_id_t1_id1_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id1") ON DELETE CASCADE;',
+		'ALTER TABLE "ref2" DROP CONSTRAINT "ref2_id_t1_id2_fkey", ADD CONSTRAINT "ref2_id_t1_id2_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id2") ON DELETE SET NULL;',
+		'ALTER TABLE "ref3" DROP CONSTRAINT "ref3_id_t1_id3_fkey", ADD CONSTRAINT "ref3_id_t1_id3_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id3") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('varchar and text default values escape single quotes', async ({ dbc: db }) => {
+	const schema1 = {
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+			text: text('text').default("escape's quotes"),
+			varchar: varchar('varchar').default("escape's quotes"),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ADD COLUMN "text" string DEFAULT e'escape\\'s quotes';`,
+		`ALTER TABLE "table" ADD COLUMN "varchar" varchar DEFAULT e'escape\\'s quotes';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add columns with defaults', async ({ dbc: db }) => {
+	const schema1 = {
+		table: cockroachTable('table', {
+			id: int4().primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: cockroachTable('table', {
+			id: int4().primaryKey(),
+			text1: text().default(''),
+			text2: string({ length: 100 }).default('text'),
+			int1: int4().default(10),
+			int2: int4().default(0),
+			int3: int4().default(-10),
+			bool1: bool().default(true),
+			bool2: bool().default(false),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "text1" string DEFAULT \'\';',
+		'ALTER TABLE "table" ADD COLUMN "text2" string(100) DEFAULT \'text\';',
+		'ALTER TABLE "table" ADD COLUMN "int1" int4 DEFAULT 10;',
+		'ALTER TABLE "table" ADD COLUMN "int2" int4 DEFAULT 0;',
+		'ALTER TABLE "table" ADD COLUMN "int3" int4 DEFAULT -10;',
+		'ALTER TABLE "table" ADD COLUMN "bool1" bool DEFAULT true;',
+		'ALTER TABLE "table" ADD COLUMN "bool2" bool DEFAULT false;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// TODO: check for created tables, etc
+});
+
+test.concurrent('add array column - empty array default', async ({ dbc: db }) => {
+	const schema1 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+			values: int4('values').array().default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE "test" ADD COLUMN "values" int4[] DEFAULT \'{}\'::int4[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add array column - default', async ({ dbc: db }) => {
+	const schema1 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: cockroachTable('test', {
+			id: int4('id').primaryKey(),
+			values: int4('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE "test" ADD COLUMN "values" int4[] DEFAULT \'{1,2,3}\'::int4[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add not null to a column', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable(
+			'User',
+			{
+				id: text('id').primaryKey().notNull(),
+				name: text('name'),
+				username: text('username'),
+				gh_username: text('gh_username'),
+				email: text('email'),
+				emailVerified: timestamp('emailVerified', {
+					precision: 3,
+					mode: 'date',
+				}),
+				image: text('image'),
+				createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
+					.defaultNow()
+					.notNull(),
+				updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
+					.notNull()
+					.$onUpdate(() => new Date()),
+			},
+			(table) => [uniqueIndex('User_email_key').on(table.email)],
+		),
+	};
+
+	const schema2 = {
+		users: cockroachTable(
+			'User',
+			{
+				id: text('id').primaryKey().notNull(),
+				name: text('name'),
+				username: text('username'),
+				gh_username: text('gh_username'),
+				email: text('email').notNull(),
+				emailVerified: timestamp('emailVerified', {
+					precision: 3,
+					mode: 'date',
+				}),
+				image: text('image'),
+				createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
+					.defaultNow()
+					.notNull(),
+				updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
+					.notNull()
+					.$onUpdate(() => new Date()),
+			},
+			(table) => [uniqueIndex('User_email_key').on(table.email)],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// TODO: revise should I use suggestion func?
+	// const { losses, hints } = await suggestions(db, statements);
+});
+
+test.concurrent('add not null to a column with null data. Should rollback', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('User', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+			username: text('username'),
+			gh_username: text('gh_username'),
+			email: text('email'),
+			emailVerified: timestamp('emailVerified', { precision: 3, mode: 'date' }),
+			image: text('image'),
+			createdAt: timestamp('createdAt', { precision: 3, mode: 'date' }).defaultNow().notNull(),
+			updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' }).notNull().$onUpdate(() => new Date()),
+		}, (table) => [uniqueIndex('User_email_key').on(table.email)]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('User', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+			username: text('username'),
+			gh_username: text('gh_username'),
+			email: text('email').notNull(),
+			emailVerified: timestamp('emailVerified', { precision: 3, mode: 'date' }),
+			image: text('image'),
+			createdAt: timestamp('createdAt', { precision: 3, mode: 'date' }).defaultNow().notNull(),
+			updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' }).notNull().$onUpdate(() => new Date()),
+		}, (table) => [uniqueIndex('User_email_key').on(table.email)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.query(`INSERT INTO "User" (id, email, "updatedAt") values ('str', 'email@gmail', '2025-04-29 09:20:39');`);
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(hints).toStrictEqual([]);
+});
+
+test.concurrent('add generated column', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+		}),
+	};
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name") STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add generated constraint to an existing column', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+		}),
+	};
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name") STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop generated constraint from a column', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
+		}),
+	};
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('no diffs for all database types', async ({ dbc: db }) => {
+	const customSchema = cockroachSchema('schemass');
+
+	const transactionStatusEnum = customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']);
+
+	const enumname = cockroachEnum('enumname', ['three', 'two', 'one']);
+
+	const schema1 = {
+		test: cockroachEnum('test', ['ds']),
+		testHello: cockroachEnum('test_hello', ['ds']),
+		enumname: cockroachEnum('enumname', ['three', 'two', 'one']),
+
+		customSchema: customSchema,
+		transactionStatusEnum: customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']),
+
+		allSmallSerials: cockroachTable('schema_test', {
+			columnAll: uuid('column_all').defaultRandom(),
+			column: transactionStatusEnum('column').notNull(),
+		}),
+
+		allSmallInts: customSchema.table(
+			'schema_test2',
+			{
+				columnAll: smallint('column_all').default(124).notNull(),
+				column: smallint('columns').array(),
+				column2: smallint('column2').array(),
+			},
+			(t: any) => [uniqueIndex('testdfds').on(t.column)],
+		),
+
+		allInt2: customSchema.table(
+			'all_int2',
+			{
+				columnAll: int2('column_all').default(124).notNull(),
+				column: int2('columns').array(),
+				column2: int2('column2').array(),
+			},
+		),
+
+		allEnums: customSchema.table(
+			'all_enums',
+			{
+				columnAll: enumname('column_all').default('three').notNull(),
+				column: enumname('columns'),
+			},
+			(t: any) => [index('ds').on(t.column)],
+		),
+
+		allTimestamps: customSchema.table('all_timestamps', {
+			columnDateNow: timestamp('column_date_now', {
+				precision: 1,
+				withTimezone: true,
+				mode: 'string',
+			}).defaultNow(),
+			columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
+			column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
+			column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
+		}),
+
+		allUuids: customSchema.table('all_uuids', {
+			columnAll: uuid('column_all').defaultRandom().notNull(),
+			column: uuid('column'),
+		}),
+
+		allDates: customSchema.table('all_dates', {
+			column_date_now: date('column_date_now').defaultNow(),
+			column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
+			column: date('column'),
+		}),
+
+		allReals: customSchema.table('all_reals', {
+			columnAll: real('column_all').default(32).notNull(),
+			column: real('column'),
+			columnPrimary: real('column_primary').primaryKey().notNull(),
+		}),
+		allBigints: cockroachTable('all_bigints', {
+			columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
+			column: bigint('column', { mode: 'number' }),
+			column1: int8('column1', { mode: 'number' }),
+			column2: int8('column2', { mode: 'bigint' }),
+		}),
+
+		allIntervals: customSchema.table('all_intervals', {
+			columnAllConstrains: interval('column_all_constrains', {
+				fields: 'month',
+			})
+				.default('1 mon')
+				.notNull(),
+			columnMinToSec: interval('column_min_to_sec', {
+				fields: 'minute to second',
+			}),
+			columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
+			column: interval('column'),
+			column5: interval('column5', {
+				fields: 'minute to second',
+				precision: 3,
+			}),
+			column6: interval('column6'),
+		}),
+
+		allTexts: customSchema.table(
+			'all_texts',
+			{
+				columnAll: text('column_all').default('text').notNull(),
+				column: text('columns').primaryKey(),
+			},
+			(t: any) => [index('test').on(t.column)],
+		),
+
+		allStrings: customSchema.table(
+			'all_strings',
+			{
+				columnAll: string('column_all').default('text').notNull(),
+				column: string('columns').primaryKey(),
+				column2: string('column2', { length: 200 }),
+			},
+		),
+		allBools: customSchema.table('all_bools', {
+			column1: bool('column1').default(true).notNull(),
+			column2: bool('column2'),
+			column3: boolean('column3').default(true).notNull(),
+			column4: boolean('column4'),
+			column5: bool('column5').default(true).notNull().array(),
+			column6: bool('column6').array(),
+			column7: boolean('column7').default(true).notNull().array(),
+			column8: boolean('column8').array(),
+		}),
+
+		allVarchars: customSchema.table('all_varchars', {
+			columnAll: varchar('column_all').default('text').notNull(),
+			column: varchar('column', { length: 200 }),
+		}),
+
+		allTimes: customSchema.table('all_times', {
+			columnAll: time('column_all').default('22:12:12').notNull(),
+			column: time('column'),
+		}),
+
+		allChars: customSchema.table('all_chars', {
+			columnAll: char('column_all', { length: 1 }).default('text').notNull(),
+			column: char('column', { length: 1 }),
+			columnArr: char('column_arr', { length: 1 }).array(),
+		}),
+		allDoublePrecision: customSchema.table('all_double_precision', {
+			columnAll: doublePrecision('column_all').default(33.2).notNull(),
+			column: doublePrecision('column'),
+		}),
+
+		allFloat: customSchema.table('all_float', {
+			columnAll: float('column_all').default(33).notNull(),
+			column: float('column'),
+		}),
+		allJsonb: customSchema.table('all_jsonb', {
+			columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
+			columnDefaultArray: jsonb('column_default_array').default({
+				hello: { 'world world': ['foo', 'bar'] },
+			}),
+			column: jsonb('column'),
+		}),
+
+		allIntegers: customSchema.table('all_integers', {
+			columnAll: int4('column_all').primaryKey(),
+			column: int4('column'),
+			columnPrimary: int4('column_primary'),
+		}),
+
+		allNumerics: customSchema.table('all_numerics', {
+			columnAll: numeric('column_all').default('32').notNull(),
+			column: numeric('column', { precision: 1, scale: 1 }),
+			columnPrimary: numeric('column_primary').primaryKey().notNull(),
+		}),
+
+		allDecimals: customSchema.table('all_decimals', {
+			columnAll: decimal('column_all').default('32').notNull(),
+			column: decimal('column', { precision: 1, scale: 1 }),
+			columnPrimary: decimal('column_primary').primaryKey().notNull(),
+		}),
+
+		allBits: customSchema.table('all_bits', {
+			column1: bit('column1').default('1').notNull(),
+			column2: bit('column2', { length: 10 }),
+			column3: bit('column3').default('1').notNull().array(),
+			column4: bit('column4', { length: 10 }).array(),
+			column5: varbit('column5').notNull(),
+			column6: varbit('column6', { length: 10 }),
+			column7: varbit('column7').notNull().array(),
+			column8: varbit('column8', { length: 10 }).array(),
+		}),
+	};
+
+	const schemas = ['public', 'schemass'];
+	const { sqlStatements: st } = await diff(schema1, schema1, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema1, schemas });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/constraints-without-tx.test.ts b/drizzle-kit/tests/cockroach/constraints-without-tx.test.ts
new file mode 100644
index 0000000000..0001859f8a
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/constraints-without-tx.test.ts
@@ -0,0 +1,82 @@
+import { desc } from 'drizzle-orm';
+import { cockroachTable, index, int4, primaryKey, text } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('alter table add composite pk', async ({ dbc: db }) => {
+	const schema1 = {
+		table: cockroachTable('table', {
+			id1: int4('id1').notNull(),
+			id2: int4('id2').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		table: cockroachTable('table', {
+			id1: int4('id1').notNull(),
+			id2: int4('id2').notNull(),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(
+		schema1,
+		schema2,
+		[],
+	);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = ['ALTER TABLE "table" ADD PRIMARY KEY ("id1","id2");'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('pk #5', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text().notNull(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+
+	expect(sqlStatements).toStrictEqual(['ALTER TABLE "users" DROP CONSTRAINT "users_pkey";']);
+	await expect(push({ db, to })).rejects.toThrow(); // can not drop pk without adding new one
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test.concurrent('issue No4704. Composite index with sort outputs', async ({ db }) => {
+	const schema1 = {
+		table: cockroachTable(
+			'table',
+			{ col1: int4(), col2: int4(), col3: int4() },
+			(table) => [
+				index('table_composite_idx').on(
+					table.col1,
+					table.col2,
+					desc(table.col3), // Attempting to sort by col3 DESC
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table" (\n\t"col1" int4,\n\t"col2" int4,\n\t"col3" int4\n);\n',
+		'CREATE INDEX "table_composite_idx" ON "table" ("col1","col2","col3" desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
diff --git a/drizzle-kit/tests/cockroach/constraints.test.ts b/drizzle-kit/tests/cockroach/constraints.test.ts
new file mode 100644
index 0000000000..cc8ae96d43
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/constraints.test.ts
@@ -0,0 +1,1954 @@
+import { sql } from 'drizzle-orm';
+import {
+	AnyCockroachColumn,
+	bigint,
+	cockroachSchema,
+	cockroachTable,
+	foreignKey,
+	index,
+	int4,
+	primaryKey,
+	text,
+	unique,
+	varchar,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('unique #1', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE UNIQUE INDEX "users_name_key" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #2', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique('unique_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE UNIQUE INDEX "unique_name" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #3', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique('unique_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE UNIQUE INDEX "unique_name" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #6', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE UNIQUE INDEX "unique_name" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #7', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE UNIQUE INDEX "unique_name" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #8', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP INDEX "unique_name" CASCADE;`,
+		'CREATE UNIQUE INDEX "unique_name2" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #9', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`ALTER INDEX "unique_name" RENAME TO "unique_name2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #10', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			email: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+			email2: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.email->public.users.email2',
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.email->public.users.email2',
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" RENAME COLUMN "email" TO "email2";`,
+		`ALTER INDEX "unique_name" RENAME TO "unique_name2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #11', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			email: text(),
+		}, (t) => [
+			unique('unique_name').on(t.name),
+			unique('unique_email').on(t.email),
+		]),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+			email: text(),
+		}, (t) => [
+			unique('unique_name2').on(t.name),
+			unique('unique_email2').on(t.email),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		'ALTER INDEX "unique_name" RENAME TO "unique_name2";',
+		`DROP INDEX "unique_email" CASCADE;`,
+		`CREATE UNIQUE INDEX "unique_email2" ON "users" ("email");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #12', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users2', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users->public.users2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users->public.users2',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('unique #13', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text(),
+			email2: text().unique('users_email_key'),
+		}),
+	};
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text(),
+			email2: text(),
+		}),
+	};
+
+	// sch1 -> sch2
+	const { sqlStatements: st1, next: n1 } = await diff(sch1, sch2, [
+		'public.users->public.users2',
+		'public.users2.email->public.users2.email2',
+	]);
+
+	await push({ db, to: sch1 });
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: sch2,
+		renames: [
+			'public.users->public.users2',
+			'public.users2.email->public.users2.email2',
+		],
+	});
+
+	const st10 = [
+		`ALTER TABLE "users" RENAME TO "users2";`,
+		`ALTER TABLE "users2" RENAME COLUMN "email" TO "email2";`,
+	];
+	expect(st1).toStrictEqual(st10);
+	expect(pst1).toStrictEqual(st10);
+
+	// sch2 -> sch3
+	const { sqlStatements: st2 } = await diff(n1, sch3, []);
+
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: sch3,
+	});
+
+	const st20 = [
+		'DROP INDEX "users_email_key" CASCADE;',
+	];
+	expect(st2).toStrictEqual(st20);
+	expect(pst2).toStrictEqual(st20);
+});
+
+test.concurrent('unique multistep #1', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = ['CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.name->public.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e3 = ['DROP INDEX "users_name_key" CASCADE;'];
+
+	expect(pst4).toStrictEqual(e3);
+	expect(st4).toStrictEqual(e3);
+});
+
+test.concurrent('unique multistep #2', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const r1 = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, r1);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames: r1 });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(pst2).toStrictEqual(e2);
+	expect(st2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['DROP INDEX "users_name_key" CASCADE;']);
+	expect(pst5).toStrictEqual(['DROP INDEX "users_name_key" CASCADE;']);
+});
+
+test.concurrent('unique multistep #3', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.name->public.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'DROP INDEX "users_name_key" CASCADE;',
+		'CREATE UNIQUE INDEX "name_unique" ON "users2" ("name2");',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['DROP INDEX "name_unique" CASCADE;']);
+	expect(pst5).toStrictEqual(['DROP INDEX "name_unique" CASCADE;']);
+});
+
+test.concurrent('unique multistep #4', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n',
+	]);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, renames });
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const renames2 = ['public.users2.users_name_key->public.users2.name_unique'];
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, renames2);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st4).toStrictEqual(['ALTER INDEX "users_name_key" RENAME TO "name_unique";']);
+	expect(pst4).toStrictEqual(['ALTER INDEX "users_name_key" RENAME TO "name_unique";']);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['DROP INDEX "name_unique" CASCADE;']);
+	expect(pst5).toStrictEqual(['DROP INDEX "name_unique" CASCADE;']);
+});
+
+test.concurrent('index multistep #1', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" string\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	expect(st4).toStrictEqual(['DROP INDEX "users_name_index";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "users_name_index";']);
+});
+
+test.concurrent('index multistep #2', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" string\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'DROP INDEX "users_name_index";',
+		'CREATE INDEX "name2_idx" ON "users2" ("name2");',
+	];
+	expect(st3).toStrictEqual(e3);
+	expect(pst3).toStrictEqual(e3);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test.concurrent('index multistep #3', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" string\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const renames2 = [
+		'public.users2.users_name_index->public.users2.name2_idx',
+	];
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, renames2);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st3).toStrictEqual(['ALTER INDEX "users_name_index" RENAME TO "name2_idx";']);
+	expect(pst3).toStrictEqual(['ALTER INDEX "users_name_index" RENAME TO "name2_idx";']);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test.concurrent('index multistep #3', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" string\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'DROP INDEX "users_name_index";',
+		'CREATE INDEX "name2_idx" ON "users2" ("name2");',
+	];
+	expect(st3).toStrictEqual(e3);
+	expect(pst3).toStrictEqual(e3);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test.concurrent('pk #1', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text().notNull(),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(st).toStrictEqual(['ALTER TABLE "users" ADD PRIMARY KEY ("name");']);
+	expect(pst).toStrictEqual(['ALTER TABLE "users" ADD PRIMARY KEY ("name");']);
+});
+
+test.concurrent('pk #2', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text().notNull().primaryKey(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test.concurrent('pk #3', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text().notNull().primaryKey(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test.concurrent('pk #4', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test.concurrent('pk multistep #1', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().primaryKey(),
+			id: int4().notNull(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4 NOT NULL\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4 NOT NULL\n);\n']);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').primaryKey(),
+			id: int4().notNull(),
+		}),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+			id: int4().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const st04 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_pkey", ADD CONSTRAINT "users2_pkey" PRIMARY KEY("id");',
+		'ALTER TABLE "users2" ALTER COLUMN "name2" DROP NOT NULL;',
+	];
+	expect(st4).toStrictEqual(st04);
+	expect(pst4).toStrictEqual(st04);
+});
+
+test.concurrent('pk multistep #2', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().primaryKey().notNull(),
+			id: int4().notNull(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4 NOT NULL\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4 NOT NULL\n);\n']);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2').notNull(),
+			id: int4().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2').notNull(),
+			id: int4().notNull(),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const renames2 = ['public.users2.users_pkey->public.users2.users2_pk'];
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, renames2);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_pkey" TO "users2_pk";']);
+	expect(pst4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_pkey" TO "users2_pk";']);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2').notNull(),
+			id: int4().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+
+	expect(st5).toStrictEqual([
+		'ALTER TABLE "users2" DROP CONSTRAINT "users2_pk", ADD CONSTRAINT "users2_pkey" PRIMARY KEY("id");',
+	]);
+	expect(pst5).toStrictEqual([
+		'ALTER TABLE "users2" DROP CONSTRAINT "users2_pk", ADD CONSTRAINT "users2_pkey" PRIMARY KEY("id");',
+	]);
+});
+
+test.concurrent('pk multistep #3', async ({ db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().primaryKey(),
+			id: int4(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" string PRIMARY KEY,\n\t"id" int4\n);\n']);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+			id: int4(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+			id: int4(),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_pkey", ADD CONSTRAINT "users2_pk" PRIMARY KEY("name2");',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: cockroachTable('users2', {
+			name: text('name2'),
+			id: int4().notNull().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+
+	const st05 = [
+		'ALTER TABLE "users2" ALTER COLUMN "id" SET NOT NULL;',
+		'ALTER TABLE "users2" DROP CONSTRAINT "users2_pk", ADD CONSTRAINT "users2_pkey" PRIMARY KEY("id");',
+		'ALTER TABLE "users2" ALTER COLUMN "name2" DROP NOT NULL;',
+	];
+	expect(st5).toStrictEqual(st05);
+	expect(pst5).toStrictEqual(st05);
+});
+
+test.concurrent('pk multistep #4', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [
+			primaryKey({ name: 'users_pk', columns: [t.name] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_pk" PRIMARY KEY("name")\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_pk" PRIMARY KEY("name")\n);\n',
+	]);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text(),
+		}, (t) => [
+			primaryKey({ name: 'users_pk', columns: [t.name] }),
+		]),
+	};
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+test.concurrent('pk multistep #5', async ({ dbc: db }) => {
+	const sch1 = {
+		users: cockroachTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string PRIMARY KEY\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" string PRIMARY KEY\n);\n',
+	]);
+
+	const sch2 = {
+		users: cockroachTable('users2', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+test.concurrent('fk #1', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+	});
+	const posts = cockroachTable('posts', {
+		id: int4().primaryKey(),
+		authorId: int4().references(() => users.id),
+	});
+
+	const to = {
+		posts,
+		users,
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \"posts\" (\n\t"id" int4 PRIMARY KEY,\n\t"authorId" int4\n);\n`,
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`ALTER TABLE "posts" ADD CONSTRAINT "posts_authorId_users_id_fkey" FOREIGN KEY ("authorId") REFERENCES "users"("id");`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// exactly 63 symbols fkey, fkey name explicit
+test.concurrent('fk #2', async ({ dbc: db }) => {
+	const users = cockroachTable('123456789_123456789_users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "123456789_123456789_users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n`,
+		'ALTER TABLE "123456789_123456789_users" ADD CONSTRAINT "123456789_123456789_users_id2_123456789_123456789_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "123456789_123456789_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// 65 symbols fkey, fkey = table_hash_fkey
+test.concurrent('fk #3', async ({ dbc: db }) => {
+	const users = cockroachTable('1234567890_1234567890_users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "1234567890_1234567890_users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n`,
+		'ALTER TABLE "1234567890_1234567890_users" ADD CONSTRAINT "1234567890_1234567890_users_2Ge3281eRCJ5_fkey" FOREIGN KEY ("id2") REFERENCES "1234567890_1234567890_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// >=45 length table name, fkey = hash_fkey
+test.concurrent('fk #4', async ({ dbc: db }) => {
+	const users = cockroachTable('1234567890_1234567890_1234567890_123456_users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "1234567890_1234567890_1234567890_123456_users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n`,
+		'ALTER TABLE "1234567890_1234567890_1234567890_123456_users" ADD CONSTRAINT "ydU6odH887YL_fkey" FOREIGN KEY ("id2") REFERENCES "1234567890_1234567890_1234567890_123456_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #5', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n`,
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #6', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const users2 = cockroachTable('users2', {
+		id: int4('id3').primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users2.id),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2', 'public.users2.id->public.users2.id3'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "id" TO "id3";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #7', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id1),
+	});
+
+	const users2 = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4(),
+	}, (t) => [foreignKey({ name: 'id2_id1_fk', columns: [t.id2], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users.users_id2_users_id1_fkey->public.users.id2_id1_fk'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME CONSTRAINT "users_id2_users_id1_fkey" TO "id2_id1_fk";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #8', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().unique(),
+		id3: int4().references((): AnyCockroachColumn => users.id1),
+	});
+
+	const users2 = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().unique(),
+		id3: int4().references((): AnyCockroachColumn => users.id2),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		'ALTER TABLE "users" DROP CONSTRAINT "users_id3_users_id1_fkey";',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id3_users_id2_fkey" FOREIGN KEY ("id3") REFERENCES "users"("id2");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #9', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().unique(),
+		id3: int4(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const users2 = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().unique(),
+		id3: int4(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id2] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		'ALTER TABLE "users" DROP CONSTRAINT "fk1", ADD CONSTRAINT "fk1" FOREIGN KEY ("id3") REFERENCES "users"("id2");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #10', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id1: int4().primaryKey(),
+	});
+
+	const users2 = cockroachTable('users2', {
+		id1: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users2.id1),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" ADD COLUMN "id2" int4;',
+		'ALTER TABLE "users2" ADD CONSTRAINT "users2_id2_users2_id1_fkey" FOREIGN KEY ("id2") REFERENCES "users2"("id1");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk #11', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id1: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id1),
+	});
+
+	const users2 = cockroachTable('users2', {
+		id1: int4().primaryKey(),
+		id2: int4(),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id1_fkey";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test.concurrent('fk multistep #1', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const users2 = cockroachTable('users2', {
+		id: int4('id3').primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const renames = ['public.users->public.users2', 'public.users2.id->public.users2.id3'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "id" TO "id3";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const users3 = cockroachTable('users2', {
+		id: int4('id3').primaryKey(),
+		id2: int4(),
+	});
+	const sch3 = { users: users3 };
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id_fkey";']);
+	expect(pst4).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id_fkey";']);
+});
+
+test.concurrent('fk multistep #2', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users.id),
+	});
+
+	const users2 = cockroachTable('users2', {
+		id: int4('id3').primaryKey(),
+		id2: int4().references((): AnyCockroachColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY,\n\t"id2" int4\n);\n',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2 });
+
+	const e2 = [
+		'CREATE TABLE "users2" (\n\t"id3" int4 PRIMARY KEY,\n\t"id2" int4\n);\n',
+		'DROP TABLE "users";',
+		'ALTER TABLE "users2" ADD CONSTRAINT "users2_id2_users2_id3_fkey" FOREIGN KEY ("id2") REFERENCES "users2"("id3");',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456#issuecomment-3076042688
+test('fk multistep #4', async ({ dbc: db }) => {
+	const foo = cockroachTable('foo', {
+		id: int4().primaryKey(),
+	});
+
+	const bar = cockroachTable('bar', {
+		id: int4().primaryKey(),
+		fooId: int4().references(() => foo.id),
+	});
+
+	const schema1 = { foo, bar };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "foo" (\n\t"id" int4 PRIMARY KEY\n);\n',
+		'CREATE TABLE "bar" (\n\t"id" int4 PRIMARY KEY,\n\t"fooId" int4\n);\n',
+		'ALTER TABLE "bar" ADD CONSTRAINT "bar_fooId_foo_id_fkey" FOREIGN KEY ("fooId") REFERENCES "foo"("id");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		bar: cockroachTable('bar', {
+			id: int4().primaryKey(),
+			fooId: int4(),
+		}),
+	};
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE "bar" DROP CONSTRAINT "bar_fooId_foo_id_fkey";',
+		'DROP TABLE "foo";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test.concurrent('unique duplicate name', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}),
+		users2: cockroachTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}, (t) => [unique('test').on(t.name)]),
+		users2: cockroachTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}, (t) => [unique('test').on(t.name)]),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test.concurrent('pk duplicate name', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}),
+		users2: cockroachTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}, (t) => [primaryKey({ name: 'test', columns: [t.name] })]),
+		users2: cockroachTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}, (t) => [primaryKey({ name: 'test', columns: [t.name] })]),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test.concurrent('fk duplicate name', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		name: varchar({ length: 255 }).primaryKey(),
+		age: int4().unique(),
+	});
+	const from = {
+		users,
+		users2: cockroachTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int4(),
+		}),
+	};
+	const to = {
+		users,
+		users2: cockroachTable(
+			'users2',
+			{
+				name: varchar({ length: 255 }),
+				age: int4(),
+			},
+			(
+				t,
+			) => [
+				foreignKey({ name: 'test', columns: [t.age], foreignColumns: [users.age] }),
+				foreignKey({ name: 'test', columns: [t.name], foreignColumns: [users.name] }),
+			],
+		),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test.concurrent('index duplicate name', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+			age: int4().unique(),
+		}, (t) => [index('test').on(t.age), index('test').on(t.name)]),
+	};
+
+	await expect(diff({}, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test.concurrent('index with no name', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+			age: int4().unique(),
+		}, (t) => [index().on(sql`${t.age}`)]),
+	};
+
+	await expect(diff({}, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test.concurrent('alter pk test #1', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: int4().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: int4().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE \"users\" DROP CONSTRAINT \"users_pkey\", ADD CONSTRAINT \"users_pkey\" PRIMARY KEY(\"id\");`,
+		'ALTER TABLE "users" ALTER COLUMN "name" DROP NOT NULL;',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter pk test #2', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: int4().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: bigint('id3', { mode: 'number' }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, ['public.users.id->public.users.id3']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: ['public.users.id->public.users.id3'],
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" RENAME COLUMN \"id\" TO \"id3\";`,
+		'ALTER TABLE "users" ALTER COLUMN "id3" SET DATA TYPE int8;',
+		`ALTER TABLE \"users\" DROP CONSTRAINT \"users_pkey\", ADD CONSTRAINT \"users_pkey\" PRIMARY KEY(\"id3\");`,
+		'ALTER TABLE "users" ALTER COLUMN "name" DROP NOT NULL;',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter pk test #3', async ({ dbc: db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: int4().notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+			id: bigint('id3', { mode: 'number' }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" ADD COLUMN "id3" int8 NOT NULL;',
+		`ALTER TABLE \"users\" DROP CONSTRAINT \"users_pkey\", ADD CONSTRAINT \"users_pkey\" PRIMARY KEY(\"id3\");`,
+		'ALTER TABLE "users" ALTER COLUMN "name" DROP NOT NULL;',
+		'ALTER TABLE "users" DROP COLUMN "id";',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456
+test('drop column with pk and add pk to another column #1', async ({ dbc: db }) => {
+	const schema1 = {
+		authors: cockroachTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "authors" (\n\t"publication_id" varchar(64),\n\t"author_id" varchar(10),'
+		+ '\n\tCONSTRAINT "authors_pkey" PRIMARY KEY("publication_id","author_id")\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authors: cockroachTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+			orcidId: varchar('orcid_id', { length: 64 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID, table.orcidId] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE "authors" ADD COLUMN "orcid_id" varchar(64) NOT NULL;',
+		'ALTER TABLE "authors" DROP CONSTRAINT "authors_pkey", ADD CONSTRAINT "authors_pkey" PRIMARY KEY("publication_id","author_id","orcid_id");',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5467
+test('index in other schema', async ({ dbc: db }) => {
+	const commonSchema = cockroachSchema('common');
+
+	const schema1 = {
+		commonSchema,
+		directoriesTable: commonSchema.table(
+			'filesystems_directories',
+			{
+				filesystemId: text(),
+			},
+			(table) => [index().on(table.filesystemId)],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE SCHEMA "common";\n',
+		'CREATE TABLE "common"."filesystems_directories" (\n\t"filesystemId" string\n);\n',
+		`CREATE INDEX "filesystems_directories_filesystemId_index" ON "common"."filesystems_directories" ("filesystemId");`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		commonSchema,
+		directoriesTable: commonSchema.table(
+			'filesystems_directories',
+			{
+				filesystemId: text(),
+			},
+		),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		`DROP INDEX "common"."filesystems_directories_filesystemId_index";`,
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
diff --git a/drizzle-kit/tests/cockroach/defaults-without-tx.test.ts b/drizzle-kit/tests/cockroach/defaults-without-tx.test.ts
new file mode 100644
index 0000000000..8940da3e1b
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/defaults-without-tx.test.ts
@@ -0,0 +1,26 @@
+import { char, string, varchar } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diffDefault, test } from './mocks';
+
+test.concurrent('char + char arrays', async ({ db }) => {
+	const res1_0 = await diffDefault(db, char().default('text'), `'text'`, { expectError: true });
+	// char is less than default
+	const res10 = await diffDefault(db, char({ length: 2 }).default('text'), `'text'`, { expectError: true });
+
+	expect(res1_0).toStrictEqual([`Insert default failed`]);
+	expect(res10).toStrictEqual([`Insert default failed`]);
+});
+
+test.concurrent('varchar + varchar arrays', async ({ db }) => {
+	// varchar length is less than default
+	const res10 = await diffDefault(db, varchar({ length: 2 }).default('text'), `'text'`, { expectError: true });
+
+	expect(res10).toStrictEqual([`Insert default failed`]);
+});
+
+test.concurrent('string + string arrays', async ({ db }) => {
+	// varchar length is less than default
+	const res10 = await diffDefault(db, string({ length: 2 }).default('text'), `'text'`, { expectError: true });
+
+	expect(res10).toStrictEqual([`Insert default failed`]);
+});
diff --git a/drizzle-kit/tests/cockroach/defaults.test.ts b/drizzle-kit/tests/cockroach/defaults.test.ts
new file mode 100644
index 0000000000..856b979f50
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/defaults.test.ts
@@ -0,0 +1,3521 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	bit,
+	bool,
+	char,
+	cockroachEnum,
+	date,
+	decimal,
+	doublePrecision,
+	float,
+	geometry,
+	inet,
+	int4,
+	int8,
+	interval,
+	jsonb,
+	numeric,
+	real,
+	smallint,
+	string,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varbit,
+	varchar,
+	vector,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diffDefault, test } from './mocks';
+
+test.concurrent('int4', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, int4().default(10), '10');
+	const res2 = await diffDefault(db, int4().default(0), '0');
+	const res3 = await diffDefault(db, int4().default(-10), '-10');
+	const res4 = await diffDefault(db, int4().default(1e4), '10000');
+	const res5 = await diffDefault(db, int4().default(-1e4), '-10000');
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+});
+
+test.concurrent('int4 arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		int4().array().default([]),
+		"'{}'::int4[]",
+	);
+	const res2 = await diffDefault(
+		db,
+		int4().array().default([10]),
+		"'{10}'::int4[]",
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+});
+
+test.concurrent('smallint', async ({ dbc: db }) => {
+	// 2^15 - 1
+	const res1 = await diffDefault(db, smallint().default(32767), '32767');
+	// -2^15
+	const res2 = await diffDefault(db, smallint().default(-32768), '-32768');
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+});
+
+test.concurrent('smallint arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		smallint().array().default([]),
+		"'{}'::int2[]",
+	);
+	const res2 = await diffDefault(
+		db,
+		smallint().array().default([32767]),
+		"'{32767}'::int2[]",
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+});
+
+test.concurrent('bigint', async ({ dbc: db }) => {
+	// 2^53
+	const res1 = await diffDefault(
+		db,
+		int8({ mode: 'number' }).default(9007199254740991),
+		'9007199254740991',
+	);
+	const res2 = await diffDefault(
+		db,
+		int8({ mode: 'number' }).default(-9007199254740991),
+		'-9007199254740991',
+	);
+	// 2^63 - 1
+	const res3 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' }).default(9223372036854775807n),
+		'9223372036854775807',
+	);
+	// -2^63
+	const res4 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' }).default(-9223372036854775808n),
+		'-9223372036854775808',
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('bigint arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		bigint({ mode: 'number' }).array().default([]),
+		"'{}'::int8[]",
+	);
+	const res2 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' }).array().default([]),
+		"'{}'::int8[]",
+	);
+
+	const res3 = await diffDefault(
+		db,
+		bigint({ mode: 'number' }).array().default([9007199254740991]),
+		"'{9007199254740991}'::int8[]",
+	);
+	const res4 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' }).array().default([9223372036854775807n]),
+		"'{9223372036854775807}'::int8[]",
+	);
+
+	const res9 = await diffDefault(
+		db,
+		bigint({ mode: 'number' }).array().default([1, 2]),
+		"'{1,2}'::int8[]",
+	);
+	const res10 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' }).array().default([1n, 2n]),
+		"'{1,2}'::int8[]",
+	);
+
+	const res13 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' })
+			.array()
+			.default(sql`'{}'`),
+		"'{}'::int8[]",
+	);
+	const res14 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' })
+			.array()
+			.default(sql`'{}'::int8[]`),
+		"'{}'::int8[]",
+	);
+	const res15 = await diffDefault(
+		db,
+		bigint({ mode: 'bigint' })
+			.array()
+			.default(sql`'{9223372036854775807}'::int8[]`),
+		"'{9223372036854775807}'::int8[]",
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res10).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+});
+
+test.concurrent('numeric', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, numeric().default('10.123'), '10.123');
+
+	const res4 = await diffDefault(
+		db,
+		numeric({ mode: 'string' }).default('10.123'),
+		'10.123',
+	);
+	const res2 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint' }).default(9223372036854775807n),
+		'9223372036854775807',
+	);
+	const res3 = await diffDefault(
+		db,
+		numeric({ mode: 'number' }).default(9007199254740991),
+		'9007199254740991',
+	);
+
+	const res5 = await diffDefault(
+		db,
+		numeric({ precision: 6 }).default('10.123'),
+		'10.123',
+	);
+	const res6 = await diffDefault(
+		db,
+		numeric({ precision: 6, scale: 2 }).default('10.123'),
+		'10.123',
+	);
+
+	const res7 = await diffDefault(
+		db,
+		numeric({ precision: 6 }).default('10'),
+		'10',
+	);
+	const res8 = await diffDefault(
+		db,
+		numeric({ precision: 6, scale: 2 }).default('10'),
+		'10',
+	);
+
+	const res7_1 = await diffDefault(
+		db,
+		numeric({ precision: 6 }).default('10.100'),
+		'10.100',
+	);
+	const res8_1 = await diffDefault(
+		db,
+		numeric({ precision: 6, scale: 2 }).default('10.100'),
+		'10.100',
+	);
+	const res7_2 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6 }).default(10.1),
+		'10.1',
+	);
+	const res8_2 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6, scale: 2 }).default(10.1),
+		'10.1',
+	);
+
+	const res9 = await diffDefault(
+		db,
+		numeric({ mode: 'string', scale: 2 }).default('10.123'),
+		'10.123',
+	);
+	const res10 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6 }).default('10.123'),
+		'10.123',
+	);
+	const res11 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6, scale: 2 }).default('10.123'),
+		'10.123',
+	);
+
+	const res12 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'9223372036854775807',
+	);
+	const res13 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6, scale: 2 }).default(10.123),
+		'10.123',
+	);
+	const res14 = await diffDefault(
+		db,
+		numeric({ mode: 'number', scale: 2 }).default(10.123),
+		'10.123',
+	);
+	const res15 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6 }).default(10.123),
+		'10.123',
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res7_1).toStrictEqual([]);
+	expect(res8_1).toStrictEqual([]);
+	expect(res7_2).toStrictEqual([]);
+	expect(res8_2).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res10).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+});
+
+test.concurrent('numeric arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		numeric({ mode: 'number' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res2 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::decimal(4,2)[]",
+	);
+	const res3 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res4 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint', precision: 4 }).array().default([]),
+		"'{}'::decimal(4)[]",
+	);
+	const res5 = await diffDefault(
+		db,
+		numeric({ mode: 'string' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res6 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::decimal(4,2)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res7_1 = await diffDefault(
+		db,
+		numeric({ mode: 'number' }).array().default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal[]",
+	);
+	// scale exists and less then decimal part
+	// default will be trimmed by scale
+	const res7_2 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6, scale: 2 })
+			.array()
+			.default([10.123, 123.153]),
+		"'{10.123,123.153}'::decimal(6,2)[]",
+	);
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res7_3 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6 }).array().default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal(6)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res7_4 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6, scale: 3 })
+			.array()
+			.default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal(6,3)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res7_5 = await diffDefault(
+		db,
+		numeric({ mode: 'number', precision: 6, scale: 3 })
+			.array()
+			.default([10, 123]),
+		"'{10,123}'::decimal(6,3)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res8_1 = await diffDefault(
+		db,
+		numeric({ mode: 'string' }).array().default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal[]",
+	);
+	// scale exists and less then decimal part
+	// default will be trimmed by scale
+	const res8_2 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6, scale: 2 })
+			.array()
+			.default(['10.123', '123.153']),
+		"'{10.123,123.153}'::decimal(6,2)[]",
+	);
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res8_3 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6 })
+			.array()
+			.default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal(6)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res8_4 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6, scale: 3 })
+			.array()
+			.default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal(6,3)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res8_5 = await diffDefault(
+		db,
+		numeric({ mode: 'string', precision: 6, scale: 3 })
+			.array()
+			.default(['10', '123']),
+		"'{10,123}'::decimal(6,3)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res9_1 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint' })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal[]",
+	);
+
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res9_2 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint', precision: 19 })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal(19)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res9_3 = await diffDefault(
+		db,
+		numeric({ mode: 'bigint', precision: 23, scale: 3 })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal(23,3)[]",
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+
+	expect(res7_1).toStrictEqual([]);
+	expect(res7_2).toStrictEqual([]);
+	expect(res7_3).toStrictEqual([]);
+	expect(res7_4).toStrictEqual([]);
+	expect(res7_5).toStrictEqual([]);
+
+	expect(res8_1).toStrictEqual([]);
+	expect(res8_2).toStrictEqual([]);
+	expect(res8_3).toStrictEqual([]);
+	expect(res8_4).toStrictEqual([]);
+	expect(res8_5).toStrictEqual([]);
+
+	expect(res9_1).toStrictEqual([]);
+	expect(res9_2).toStrictEqual([]);
+	expect(res9_3).toStrictEqual([]);
+});
+
+test.concurrent('decimal', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, decimal().default('10.123'), '10.123');
+
+	const res4 = await diffDefault(
+		db,
+		decimal({ mode: 'string' }).default('10.123'),
+		'10.123',
+	);
+	const res2 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint' }).default(9223372036854775807n),
+		'9223372036854775807',
+	);
+	const res3 = await diffDefault(
+		db,
+		decimal({ mode: 'number' }).default(9007199254740991),
+		'9007199254740991',
+	);
+
+	const res5 = await diffDefault(
+		db,
+		decimal({ precision: 6 }).default('10.123'),
+		'10.123',
+	);
+	const res6 = await diffDefault(
+		db,
+		decimal({ precision: 6, scale: 2 }).default('10.123'),
+		'10.123',
+	);
+
+	const res7 = await diffDefault(
+		db,
+		decimal({ precision: 6 }).default('10'),
+		'10',
+	);
+	const res8 = await diffDefault(
+		db,
+		decimal({ precision: 6, scale: 2 }).default('10'),
+		'10',
+	);
+
+	const res7_1 = await diffDefault(
+		db,
+		decimal({ precision: 6 }).default('10.100'),
+		'10.100',
+	);
+	const res8_1 = await diffDefault(
+		db,
+		decimal({ precision: 6, scale: 2 }).default('10.100'),
+		'10.100',
+	);
+	const res7_2 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6 }).default(10.1),
+		'10.1',
+	); // js trims .100 to 0.1
+	const res8_2 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6, scale: 2 }).default(10.1),
+		'10.1',
+	); // js trims .100 to 0.1
+
+	const res9 = await diffDefault(
+		db,
+		decimal({ mode: 'string', scale: 2 }).default('10.123'),
+		'10.123',
+	);
+	const res10 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6 }).default('10.123'),
+		'10.123',
+	);
+	const res11 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6, scale: 2 }).default('10.123'),
+		'10.123',
+	);
+
+	const res12 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'9223372036854775807',
+	);
+	const res13 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6, scale: 2 }).default(10.123),
+		'10.123',
+	);
+	const res14 = await diffDefault(
+		db,
+		decimal({ mode: 'number', scale: 2 }).default(10.123),
+		'10.123',
+	);
+	const res15 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6 }).default(10.123),
+		'10.123',
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res7_1).toStrictEqual([]);
+	expect(res8_1).toStrictEqual([]);
+	expect(res7_2).toStrictEqual([]);
+	expect(res8_2).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res10).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+});
+
+test.concurrent('decimals arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		decimal({ mode: 'number' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res2 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::decimal(4,2)[]",
+	);
+	const res3 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res4 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint', precision: 4 }).array().default([]),
+		"'{}'::decimal(4)[]",
+	);
+	const res5 = await diffDefault(
+		db,
+		decimal({ mode: 'string' }).array().default([]),
+		"'{}'::decimal[]",
+	);
+	const res6 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::decimal(4,2)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res7_1 = await diffDefault(
+		db,
+		decimal({ mode: 'number' }).array().default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal[]",
+	);
+	// scale exists and less then decimal part
+	// default will be trimmed by scale
+	const res7_2 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6, scale: 2 })
+			.array()
+			.default([10.123, 123.153]),
+		"'{10.123,123.153}'::decimal(6,2)[]",
+	);
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res7_3 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6 }).array().default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal(6)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res7_4 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6, scale: 3 })
+			.array()
+			.default([10.123, 123.1]),
+		"'{10.123,123.1}'::decimal(6,3)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res7_5 = await diffDefault(
+		db,
+		decimal({ mode: 'number', precision: 6, scale: 3 })
+			.array()
+			.default([10, 123]),
+		"'{10,123}'::decimal(6,3)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res8_1 = await diffDefault(
+		db,
+		decimal({ mode: 'string' }).array().default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal[]",
+	);
+	// scale exists and less then decimal part
+	// default will be trimmed by scale
+	const res8_2 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6, scale: 2 })
+			.array()
+			.default(['10.123', '123.153']),
+		"'{10.123,123.153}'::decimal(6,2)[]",
+	);
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res8_3 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6 })
+			.array()
+			.default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal(6)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res8_4 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6, scale: 3 })
+			.array()
+			.default(['10.123', '123.1']),
+		"'{10.123,123.1}'::decimal(6,3)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res8_5 = await diffDefault(
+		db,
+		decimal({ mode: 'string', precision: 6, scale: 3 })
+			.array()
+			.default(['10', '123']),
+		"'{10,123}'::decimal(6,3)[]",
+	);
+
+	// no precision and scale
+	// default will be created same as passed
+	const res9_1 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint' })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal[]",
+	);
+
+	// scale will be 0
+	// default will be trimmed to integer part
+	const res9_2 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint', precision: 19 })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal(19)[]",
+	);
+	// scale exists and is bigger then decimal part
+	// default will be padded by scale
+	const res9_3 = await diffDefault(
+		db,
+		decimal({ mode: 'bigint', precision: 23, scale: 3 })
+			.array()
+			.default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::decimal(23,3)[]",
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7_1).toStrictEqual([]);
+	expect(res7_2).toStrictEqual([]);
+	expect(res7_3).toStrictEqual([]);
+	expect(res7_4).toStrictEqual([]);
+	expect(res7_5).toStrictEqual([]);
+	expect(res8_1).toStrictEqual([]);
+	expect(res8_2).toStrictEqual([]);
+	expect(res8_3).toStrictEqual([]);
+	expect(res8_4).toStrictEqual([]);
+	expect(res8_5).toStrictEqual([]);
+	expect(res9_1).toStrictEqual([]);
+	expect(res9_2).toStrictEqual([]);
+	expect(res9_3).toStrictEqual([]);
+});
+
+test.concurrent('real', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, real().default(1000.123), '1000.123');
+	const res2 = await diffDefault(db, real().default(1000), '1000');
+	const res3 = await diffDefault(db, real().default(1000.3), '1000.3');
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+});
+
+test.concurrent('real arrays', async ({ dbc: db }) => {
+	const res2 = await diffDefault(
+		db,
+		real().array().default([]),
+		`'{}'::real[]`,
+	);
+	const res3 = await diffDefault(
+		db,
+		real().array().default([1000.123, 10.2]),
+		`'{1000.123,10.2}'::real[]`,
+	);
+	const res4 = await diffDefault(
+		db,
+		real().array().default([1000.2]),
+		`'{1000.2}'::real[]`,
+	);
+	const res5 = await diffDefault(
+		db,
+		real().array().default([1000.123, 10]),
+		`'{1000.123,10}'::real[]`,
+	);
+
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+});
+
+test.concurrent('float', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		float().default(10000.123),
+		'10000.123',
+	);
+	const res2 = await diffDefault(db, float().default(10000), '10000');
+	const res3 = await diffDefault(db, float().default(1000.3), '1000.3');
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+});
+
+test.concurrent('float arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		float().array().default([]),
+		`'{}'::float[]`,
+	);
+	const res2 = await diffDefault(
+		db,
+		float().array().default([10000.123]),
+		`'{10000.123}'::float[]`,
+	);
+	const res3 = await diffDefault(
+		db,
+		float().array().default([10000, 14]),
+		`'{10000,14}'::float[]`,
+	);
+	const res4 = await diffDefault(
+		db,
+		float().array().default([1000.2]),
+		`'{1000.2}'::float[]`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('doublePrecision', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		doublePrecision().default(10000.123),
+		'10000.123',
+	);
+	const res2 = await diffDefault(
+		db,
+		doublePrecision().default(10000),
+		'10000',
+	);
+	const res3 = await diffDefault(
+		db,
+		doublePrecision().default(1000.3),
+		'1000.3',
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+});
+
+test.concurrent('doublePrecision arrays', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		doublePrecision().array().default([]),
+		`'{}'::float[]`,
+	);
+	const res2 = await diffDefault(
+		db,
+		doublePrecision().array().default([10000.123]),
+		`'{10000.123}'::float[]`,
+	);
+	const res3 = await diffDefault(
+		db,
+		doublePrecision().array().default([10000, 14]),
+		`'{10000,14}'::float[]`,
+	);
+	const res4 = await diffDefault(
+		db,
+		doublePrecision().array().default([1000.2]),
+		`'{1000.2}'::float[]`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('bool', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, bool().default(true), 'true');
+	const res2 = await diffDefault(db, bool().default(false), 'false');
+	const res3 = await diffDefault(db, bool().default(sql`true`), 'true');
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+});
+
+test.concurrent('bool arrays', async ({ dbc: db }) => {
+	const res4 = await diffDefault(
+		db,
+		bool().array().default([]),
+		`'{}'::bool[]`,
+	);
+	const res5 = await diffDefault(
+		db,
+		bool().array().default([true]),
+		`'{true}'::bool[]`,
+	);
+	const res6 = await diffDefault(
+		db,
+		bool()
+			.array()
+			.default(sql`'{true}'::bool[]`),
+		`'{true}'::bool[]`,
+	);
+
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+});
+
+test.concurrent('char', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		char({ length: 15 }).default('text'),
+		`'text'`,
+	);
+	const res2 = await diffDefault(
+		db,
+		char({ length: 15 }).default("text'text"),
+		`e'text\\'text'`,
+	);
+	const res3 = await diffDefault(
+		db,
+		char({ length: 15 }).default('text\'text"'),
+		`e'text\\'text"'`,
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(
+		db,
+		char({ length: 15 }).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+	const res5 = await diffDefault(
+		db,
+		char({ length: 15, enum: ['one', 'two', 'three'] }).default('one'),
+		"'one'",
+	);
+	const res6 = await diffDefault(
+		db,
+		char({ length: 15 }).default('hello, world'),
+		"'hello, world'",
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res7 = await diffDefault(
+		db,
+		char({
+			length: 15,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'],
+		}).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+
+	const res9 = await diffDefault(
+		db,
+		char({ length: 15 }).default('text'),
+		`'text'`,
+	);
+	const res11 = await diffDefault(
+		db,
+		char({ length: 2 }).default('12'),
+		`'12'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+});
+
+test.concurrent('char arrays', async ({ dbc: db }) => {
+	const res7 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default([]),
+		`'{}'::char(15)[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default(['text']),
+		`'{text}'::char(15)[]`,
+	);
+	const res9 = await diffDefault(
+		db,
+		char().array().default(['text']),
+		`'{text}'::char[]`,
+	);
+	const res12 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default(['\\']),
+		`'{"\\\\"}'::char(15)[]`,
+	);
+	const res13 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default(["'"]),
+		`'{''}'::char(15)[]`,
+	);
+	const res14 = await diffDefault(
+		db,
+		char({ length: 15, enum: ['one', 'two', 'three'] })
+			.array()
+			.default(['one']),
+		`'{one}'::char(15)[]`,
+	);
+	const res15 = await diffDefault(
+		db,
+		char({
+			length: 15,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'],
+		})
+			.array()
+			.default([`mo''",\`}{od`]),
+		`'{"mo''''\\\",\`}{od"}'::char(15)[]`,
+	);
+
+	const res16 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default([]),
+		`'{}'::char(15)[]`,
+	);
+
+	// char is bigger than default
+	const res17 = await diffDefault(
+		db,
+		char({ length: 15 }).array().default(['text']),
+		`'{text}'::char(15)[]`,
+	);
+	// char is less than default
+	const res18 = await diffDefault(
+		db,
+		char({ length: 2 }).array().default(['text']),
+		`'{text}'::char(2)[]`,
+	);
+	const res18_1 = await diffDefault(
+		db,
+		char({ length: 2 }).array().default(["t'"]),
+		`'{t''}'::char(2)[]`,
+	);
+
+	const res18_2 = await diffDefault(
+		db,
+		char({ length: 2 }).array().default(['t\\']),
+		`'{"t\\\\"}'::char(2)[]`,
+	);
+	// char is same as default
+	const res19 = await diffDefault(
+		db,
+		char({ length: 2 }).array().default(['12']),
+		`'{12}'::char(2)[]`,
+	);
+
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res17).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res18_2).toStrictEqual([]);
+	expect(res19).toStrictEqual([]);
+});
+
+test.concurrent('varchar', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		varchar({ length: 255 }).default('text'),
+		`'text'`,
+	);
+	const res1_0 = await diffDefault(db, varchar().default('text'), `'text'`);
+	const res2 = await diffDefault(
+		db,
+		varchar({ length: 255 }).default("text'text"),
+		`e'text\\'text'`,
+	);
+	const res3 = await diffDefault(
+		db,
+		varchar({ length: 255 }).default('text\'text"'),
+		`e'text\\'text"'`,
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(
+		db,
+		varchar({ length: 255 }).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+	const res5 = await diffDefault(
+		db,
+		varchar({ length: 255, enum: ['one', 'two', 'three'] }).default('one'),
+		"'one'",
+	);
+	const res5_1 = await diffDefault(
+		db,
+		varchar({ length: 255 }).default('hello, world'),
+		"'hello, world'",
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		db,
+		varchar({
+			length: 255,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'],
+		}).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+
+	// varchar length is bigger than default
+	const res9 = await diffDefault(
+		db,
+		varchar({ length: 15 }).default('text'),
+		`'text'`,
+	);
+	// varchar length is same as default
+	const res11 = await diffDefault(
+		db,
+		varchar({ length: 2 }).default('12'),
+		`'12'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res1_0).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res5_1).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+});
+
+test.concurrent('varchar arrays', async ({ dbc: db }) => {
+	const res7 = await diffDefault(
+		db,
+		varchar({ length: 255 }).array().default([]),
+		`'{}'::varchar(255)[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		varchar({ length: 255 }).array().default(['text']),
+		`'{text}'::varchar(255)[]`,
+	);
+	const res8_0 = await diffDefault(
+		db,
+		varchar().array().default(['text']),
+		`'{text}'::varchar[]`,
+	);
+	const res12 = await diffDefault(
+		db,
+		varchar({ length: 15 }).array().default(['\\']),
+		`'{"\\\\"}'::varchar(15)[]`,
+	);
+	const res13 = await diffDefault(
+		db,
+		varchar({ length: 15 }).array().default(["'"]),
+		`'{''}'::varchar(15)[]`,
+	);
+	const res14 = await diffDefault(
+		db,
+		varchar({ length: 15, enum: ['one', 'two', 'three'] })
+			.array()
+			.default(['one']),
+		`'{one}'::varchar(15)[]`,
+	);
+	const res15 = await diffDefault(
+		db,
+		varchar({
+			length: 255,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'],
+		})
+			.array()
+			.default([`mo''",\`}{od`]),
+		`'{"mo''''\\\",\`}{od"}'::varchar(255)[]`,
+	);
+
+	const res16 = await diffDefault(
+		db,
+		varchar({ length: 255 }).array().default([]),
+		`'{}'::varchar(255)[]`,
+	);
+
+	// char is bigger than default
+	const res17 = await diffDefault(
+		db,
+		varchar({ length: 255 }).array().default(['text']),
+		`'{text}'::varchar(255)[]`,
+	);
+	// char is less than default
+	const res18 = await diffDefault(
+		db,
+		varchar({ length: 2 }).array().default(['text']),
+		`'{text}'::varchar(2)[]`,
+	);
+	const res18_1 = await diffDefault(
+		db,
+		varchar({ length: 2 }).array().default(["t'"]),
+		`'{t''}'::varchar(2)[]`,
+	);
+
+	const res18_2 = await diffDefault(
+		db,
+		varchar({ length: 2 }).array().default(['t\\']),
+		`'{"t\\\\"}'::varchar(2)[]`,
+	);
+	// char is same as default
+	const res19 = await diffDefault(
+		db,
+		varchar({ length: 2 }).array().default(['12']),
+		`'{12}'::varchar(2)[]`,
+	);
+
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res8_0).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res17).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res18_2).toStrictEqual([]);
+	expect(res19).toStrictEqual([]);
+});
+
+test.concurrent('text', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, text().default('text'), `'text'`);
+	const res2 = await diffDefault(
+		db,
+		text().default("text'text"),
+		`e'text\\'text'`,
+	);
+	const res3 = await diffDefault(
+		db,
+		text().default('text\'text"'),
+		`e'text\\'text"'`,
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(
+		db,
+		text().default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+	const res5 = await diffDefault(db, text().default('one'), "'one'");
+	const res5_1 = await diffDefault(
+		db,
+		text().default('hello, world'),
+		"'hello, world'",
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		db,
+		text({
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'],
+		}).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res5_1).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+});
+
+test.concurrent('text arrays', async ({ dbc: db }) => {
+	const res7 = await diffDefault(
+		db,
+		text().array().default([]),
+		`'{}'::string[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		text().array().default(['text']),
+		`'{text}'::string[]`,
+	);
+	const res12 = await diffDefault(
+		db,
+		text().array().default(['\\']),
+		`'{"\\\\"}'::string[]`,
+	);
+	const res13 = await diffDefault(
+		db,
+		text().array().default(["'"]),
+		`'{''}'::string[]`,
+	);
+	const res14 = await diffDefault(
+		db,
+		text({ enum: ['one', 'two', 'three'] })
+			.array()
+			.default(['one']),
+		`'{one}'::string[]`,
+	);
+	const res15 = await diffDefault(
+		db,
+		text({
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'],
+		})
+			.array()
+			.default([`mo''",\`}{od`]),
+		`'{"mo''''\\\",\`}{od"}'::string[]`,
+	);
+
+	const res16 = await diffDefault(
+		db,
+		text().array().default([]),
+		`'{}'::string[]`,
+	);
+
+	const res18 = await diffDefault(
+		db,
+		text().array().default(['text']),
+		`'{text}'::string[]`,
+	);
+	const res18_1 = await diffDefault(
+		db,
+		text().array().default(["t'"]),
+		`'{t''}'::string[]`,
+	);
+
+	const res18_2 = await diffDefault(
+		db,
+		text().array().default(['t\\']),
+		`'{"t\\\\"}'::string[]`,
+	);
+
+	const res20 = await diffDefault(
+		db,
+		text().array().default(["1234'4"]),
+		`'{1234''4}'::string[]`,
+	);
+	const res21 = await diffDefault(
+		db,
+		text().array().default(['1234\\1']),
+		`'{"1234\\\\1"}'::string[]`,
+	);
+
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res18_2).toStrictEqual([]);
+	expect(res20).toStrictEqual([]);
+	expect(res21).toStrictEqual([]);
+});
+
+test.concurrent('string', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		string({ length: 255 }).default('text'),
+		`'text'`,
+	);
+	const res1_0 = await diffDefault(db, string().default('text'), `'text'`);
+	const res2 = await diffDefault(
+		db,
+		string({ length: 255 }).default("text'text"),
+		`e'text\\'text'`,
+	);
+	const res3 = await diffDefault(
+		db,
+		string({ length: 255 }).default('text\'text"'),
+		`e'text\\'text"'`,
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(
+		db,
+		string({ length: 255 }).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+	const res5 = await diffDefault(
+		db,
+		string({ length: 255, enum: ['one', 'two', 'three'] }).default('one'),
+		"'one'",
+	);
+	const res5_1 = await diffDefault(
+		db,
+		string({ length: 255 }).default('hello, world'),
+		"'hello, world'",
+	);
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		db,
+		string({
+			length: 255,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'],
+		}).default(`mo''",\\\`}{od`),
+		`e'mo\\'\\'",\\\\\`}{od'`,
+	);
+
+	// varchar length is bigger than default
+	const res9 = await diffDefault(
+		db,
+		string({ length: 15 }).default('text'),
+		`'text'`,
+	);
+	// varchar length is same as default
+	const res11 = await diffDefault(
+		db,
+		string({ length: 2 }).default('12'),
+		`'12'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res1_0).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res5_1).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+});
+
+test.concurrent('string arrays', async ({ dbc: db }) => {
+	const res7 = await diffDefault(
+		db,
+		string({ length: 255 }).array().default([]),
+		`'{}'::string(255)[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		string({ length: 255 }).array().default(['text']),
+		`'{text}'::string(255)[]`,
+	);
+	const res8_0 = await diffDefault(
+		db,
+		string().array().default(['text']),
+		`'{text}'::string[]`,
+	);
+	const res12 = await diffDefault(
+		db,
+		string({ length: 15 }).array().default(['\\']),
+		`'{"\\\\"}'::string(15)[]`,
+	);
+	const res13 = await diffDefault(
+		db,
+		string({ length: 15 }).array().default(["'"]),
+		`'{''}'::string(15)[]`,
+	);
+	const res14 = await diffDefault(
+		db,
+		string({ length: 15, enum: ['one', 'two', 'three'] })
+			.array()
+			.default(['one']),
+		`'{one}'::string(15)[]`,
+	);
+	const res15 = await diffDefault(
+		db,
+		string({
+			length: 255,
+			enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'],
+		})
+			.array()
+			.default([`mo''",\`}{od`]),
+		`'{"mo''''\\\",\`}{od"}'::string(255)[]`,
+	);
+
+	// char is bigger than default
+	const res17 = await diffDefault(
+		db,
+		string({ length: 255 }).array().default(['text']),
+		`'{text}'::string(255)[]`,
+	);
+	// char is less than default
+	const res18 = await diffDefault(
+		db,
+		string({ length: 2 }).array().default(['text']),
+		`'{text}'::string(2)[]`,
+	);
+	const res18_1 = await diffDefault(
+		db,
+		string({ length: 2 }).array().default(["t'"]),
+		`'{t''}'::string(2)[]`,
+	);
+	const res18_2 = await diffDefault(
+		db,
+		string({ length: 2 }).array().default(['t\\']),
+		`'{"t\\\\"}'::string(2)[]`,
+	);
+	// char is same as default
+	const res19 = await diffDefault(
+		db,
+		string({ length: 2 }).array().default(['12']),
+		`'{12}'::string(2)[]`,
+	);
+	const res22 = await diffDefault(
+		db,
+		string({ length: 3 }).array().default(['"1234545"']),
+		`'{"\\"1234545\\""}'::string(3)[]`,
+	);
+
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+	expect(res8_0).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res14).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+	expect(res17).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res18_2).toStrictEqual([]);
+	expect(res19).toStrictEqual([]);
+	expect(res22).toStrictEqual([]);
+});
+
+test.concurrent('jsonb', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, jsonb().default({}), `'{}'`);
+	const res2 = await diffDefault(db, jsonb().default([]), `'[]'`);
+	const res3 = await diffDefault(
+		db,
+		jsonb().default([1, 2, 3]),
+		`'[1,2,3]'`,
+	);
+	const res4 = await diffDefault(
+		db,
+		jsonb().default({ key: 'value' }),
+		`'{"key":"value"}'`,
+	);
+	const res5 = await diffDefault(
+		db,
+		jsonb().default({ key: "val'ue" }),
+		`e'{"key":"val\\'ue"}'`,
+	);
+	const res6 = await diffDefault(
+		db,
+		jsonb().default({ key: `mo''",\`}{od` }),
+		`e'{"key":"mo\\'\\'\\\\",\`}{od"}'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	// await expect().rejects
+	// 	.toThrowError();
+});
+
+// tests were commented since there are too many of them
+test.concurrent('timestamp', async ({ dbc: db }) => {
+	// normal without timezone
+	const res1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	// precision same as in default
+	const res2 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 3 }).default(
+			new Date('2025-05-23T12:53:53.115Z'),
+		),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	// precision is less than in default
+	// cockroach will store this value trimmed
+	// this should pass since in diff we handle it
+	const res3 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 1 }).default(
+			new Date('2025-05-23T12:53:53.115Z'),
+		),
+		`'2025-05-23 12:53:53.115'`,
+	);
+
+	// all string variations
+	// normal: without timezone
+	const res9 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).default('2025-05-23T12:53:53.115'),
+		`'2025-05-23T12:53:53.115'`,
+	);
+
+	const res9_2 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).default('2025-05-23T12:53:53'),
+		`'2025-05-23T12:53:53'`,
+	);
+	// normal: timezone with "zero UTC offset" in the end
+	const res10 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).default('2025-05-23T12:53:53.115Z'),
+		`'2025-05-23T12:53:53.115Z'`,
+	);
+
+	// normal: timezone with custom timezone
+	const res12 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).default('2025-05-23T12:53:53.115+03'),
+		`'2025-05-23T12:53:53.115+03'`,
+	);
+
+	// precision is less than in default
+	// cockroach will store this value trimmed
+	// this should pass since in diff we handle it
+	// without UTC
+	const res13 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1 }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+
+	// custom timezone
+	const res16 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1 }).default(
+			'2025-05-23T12:53:53.116+04:30',
+		),
+		`'2025-05-23T12:53:53.116+04:30'`,
+	);
+
+	// precision same
+	// No timezone
+	const res17 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+	// precision same
+	// zero timezone
+	const res18 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 }).default(
+			'2025-05-23T12:53:53.115Z',
+		),
+		`'2025-05-23T12:53:53.115Z'`,
+	);
+
+	// custom timezone
+	const res20 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+
+	// precision is bigget than in default
+	// No timezone
+	const res21 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+	// precision is bigget than in default
+	// zero timezone
+	const res22 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 }).default(
+			'2025-05-23T12:53:53.115Z',
+		),
+		`'2025-05-23T12:53:53.115Z'`,
+	);
+
+	const res24 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+
+	const res25 = await diffDefault(
+		db,
+		timestamp({
+			mode: 'string',
+			precision: 1,
+			withTimezone: true,
+		}).defaultNow(),
+		`now()`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res9_2).toStrictEqual([]);
+	expect(res10).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res17).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res20).toStrictEqual([]);
+	expect(res21).toStrictEqual([]);
+	expect(res22).toStrictEqual([]);
+	expect(res24).toStrictEqual([]);
+	expect(res25).toStrictEqual([]);
+});
+
+test.concurrent('timestamp arrays', async ({ dbc: db }) => {
+	const res1_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date' })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115"}'::timestamp[]`,
+	);
+
+	const res2_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 3 })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115"}'::timestamp(3)[]`,
+	);
+
+	const res3_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 1 })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115"}'::timestamp(1)[]`,
+	);
+
+	const res9_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).array().default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamp[]`,
+	);
+	const res9_3 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).array().default(['2025-05-23T12:53:53.0']),
+		`'{"2025-05-23T12:53:53.0"}'::timestamp[]`,
+	);
+
+	const res10_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' }).array().default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamp[]`,
+	);
+
+	const res12_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string' })
+			.array()
+			.default(['2025-05-23T12:53:53.115+03']),
+		`'{"2025-05-23T12:53:53.115+03"}'::timestamp[]`,
+	);
+
+	const res13_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1 })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamp(1)[]`,
+	);
+
+	const res16_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1 })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamp(1)[]`,
+	);
+
+	const res17_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamp(3)[]`,
+	);
+
+	const res18_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 })
+			.array()
+			.default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamp(3)[]`,
+	);
+
+	const res20_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3 })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamp(3)[]`,
+	);
+
+	const res21_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamp(5)[]`,
+	);
+
+	const res22_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 })
+			.array()
+			.default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamp(5)[]`,
+	);
+
+	const res24_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5 })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamp(5)[]`,
+	);
+
+	expect(res1_1).toStrictEqual([]);
+	expect(res2_1).toStrictEqual([]);
+	expect(res3_1).toStrictEqual([]);
+	expect(res9_1).toStrictEqual([]);
+	expect(res9_3).toStrictEqual([]);
+	expect(res10_1).toStrictEqual([]);
+	expect(res12_1).toStrictEqual([]);
+	expect(res13_1).toStrictEqual([]);
+	expect(res16_1).toStrictEqual([]);
+	expect(res17_1).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res20_1).toStrictEqual([]);
+	expect(res21_1).toStrictEqual([]);
+	expect(res22_1).toStrictEqual([]);
+	expect(res24_1).toStrictEqual([]);
+});
+
+test.concurrent('timestamptz', async ({ dbc: db }) => {
+	// all dates variations
+
+	// normal with timezone
+	const res5 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', withTimezone: true }).default(
+			new Date('2025-05-23T12:53:53.115Z'),
+		),
+		`'2025-05-23 12:53:53.115+00'`,
+	);
+
+	// precision same as in default
+	const res6 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).default(
+			new Date('2025-05-23T12:53:53.115Z'),
+		),
+		`'2025-05-23 12:53:53.115+00'`,
+	);
+	// precision is less than in default
+	// cockroach will store this value trimmed
+	// this should pass since in diff we handle it
+	const res7 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 1, withTimezone: true }).default(
+			new Date('2025-05-23T12:53:53.115Z'),
+		),
+		`'2025-05-23 12:53:53.115+00'`,
+	);
+
+	// all string variations
+	// normal: without timezone
+	const res9 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+	const res9_2 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true }).default(
+			'2025-05-23T12:53:53',
+		),
+		`'2025-05-23T12:53:53'`,
+	);
+	const res9_3 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true }).default(
+			'2025-05-23T12:53:53.0',
+		),
+		`'2025-05-23T12:53:53.0'`,
+	);
+	// normal: timezone with custom timezone
+	const res12 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true }).default(
+			'2025-05-23T12:53:53.115+03',
+		),
+		`'2025-05-23T12:53:53.115+03'`,
+	);
+
+	// precision is bigger than in default
+	// cockroach will not pad this
+	// without UTC
+	const res13 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+
+	// custom timezone
+	const res16 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+
+	// precision is less than in default
+	// cockroach will not trim this
+	// without UTC
+	const res17 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+
+	// precision is less than in default
+	// cockroach will store this value trimmed
+	// this should pass since in diff we handle it
+	// zero UTC
+	const res18 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115Z',
+		),
+		`'2025-05-23T12:53:53.115Z'`,
+	);
+
+	const res20 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+
+	// precision same
+	// without UTC
+	const res21 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115',
+		),
+		`'2025-05-23T12:53:53.115'`,
+	);
+
+	// precision same
+	// zero UTC
+	const res22 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115Z',
+		),
+		`'2025-05-23T12:53:53.115Z'`,
+	);
+
+	// precision same
+	// custom timezone
+	const res24 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+
+	const res25 = await diffDefault(
+		db,
+		timestamp({
+			mode: 'string',
+			precision: 1,
+			withTimezone: true,
+		}).defaultNow(),
+		`now()`,
+	);
+
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res9).toStrictEqual([]);
+	expect(res9_2).toStrictEqual([]);
+	expect(res9_3).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res17).toStrictEqual([]);
+	expect(res18).toStrictEqual([]);
+	expect(res20).toStrictEqual([]);
+	expect(res21).toStrictEqual([]);
+	expect(res22).toStrictEqual([]);
+	expect(res24).toStrictEqual([]);
+	expect(res25).toStrictEqual([]);
+});
+
+test.concurrent('timestamptz arrays', async ({ dbc: db }) => {
+	const res5_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', withTimezone: true })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115+00"}'::timestamptz[]`,
+	);
+
+	const res6_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115+00"}'::timestamptz(3)[]`,
+	);
+	// precision is less than in default
+	// cockroach will store this value trimmed
+	// this should pass since in diff we handle it
+
+	const res7_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'date', precision: 1, withTimezone: true })
+			.array()
+			.default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115+00"}'::timestamptz(1)[]`,
+	);
+
+	// all string variations
+	// normal: without timezone
+	const res9_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamptz[]`,
+	);
+
+	const res10_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamptz[]`,
+	);
+
+	const res12_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115+03']),
+		`'{"2025-05-23T12:53:53.115+03"}'::timestamptz[]`,
+	);
+
+	const res13_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamptz(5)[]`,
+	);
+	const res16 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5, withTimezone: true }).default(
+			'2025-05-23T12:53:53.115+04:30',
+		),
+		`'2025-05-23T12:53:53.115+04:30'`,
+	);
+	const res16_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 5, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamptz(5)[]`,
+	);
+
+	const res17_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamptz(1)[]`,
+	);
+
+	const res18_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamptz(1)[]`,
+	);
+
+	// precision is less than in default, cockroach will store this value trimmed, this should pass since in diff we handle it
+	const res20_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamptz(1)[]`,
+	);
+
+	// precision same, without UTC
+	const res21_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115']),
+		`'{"2025-05-23T12:53:53.115"}'::timestamptz(3)[]`,
+	);
+
+	// precision same, zero UTC
+	const res22_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115Z']),
+		`'{"2025-05-23T12:53:53.115Z"}'::timestamptz(3)[]`,
+	);
+
+	// precision same
+	// custom timezone
+	const res24_1 = await diffDefault(
+		db,
+		timestamp({ mode: 'string', precision: 1, withTimezone: true })
+			.array()
+			.default(['2025-05-23T12:53:53.115+04:30']),
+		`'{"2025-05-23T12:53:53.115+04:30"}'::timestamptz(1)[]`,
+	);
+
+	expect(res5_1).toStrictEqual([]);
+	expect(res6_1).toStrictEqual([]);
+	expect(res7_1).toStrictEqual([]);
+	expect(res9_1).toStrictEqual([]);
+	expect(res10_1).toStrictEqual([]);
+	expect(res12_1).toStrictEqual([]);
+	expect(res13_1).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+	expect(res16_1).toStrictEqual([]);
+	expect(res17_1).toStrictEqual([]);
+	expect(res18_1).toStrictEqual([]);
+	expect(res20_1).toStrictEqual([]);
+	expect(res21_1).toStrictEqual([]);
+	expect(res22_1).toStrictEqual([]);
+	expect(res24_1).toStrictEqual([]);
+});
+
+// tests were commented since there are too many of them
+test.concurrent('time', async ({ dbc: db }) => {
+	// normal time without precision
+	const res1 = await diffDefault(
+		db,
+		time().default('15:50:33'),
+		`'15:50:33'`,
+	);
+	// const res1_1 = await diffDefault(db, time().default('15:50:33Z'), `'15:50:33Z'`);
+	// const res1_2 = await diffDefault(db, time().default('15:50:33+00'), `'15:50:33+00'`);
+	// const res1_3 = await diffDefault(db, time().default('15:50:33+03'), `'15:50:33+03'`);
+	// const res1_4 = await diffDefault(db, time().default('2025-05-23 15:50:33'), `'2025-05-23 15:50:33'`);
+	// const res1_5 = await diffDefault(db, time().default('2025-05-23 15:50:33Z'), `'2025-05-23 15:50:33Z'`);
+	// const res1_6 = await diffDefault(db, time().default('2025-05-23T15:50:33+00'), `'2025-05-23T15:50:33+00'`);
+	// const res1_7 = await diffDefault(db, time().default('2025-05-23 15:50:33+03'), `'2025-05-23 15:50:33+03'`);
+	// const res1_16 = await diffDefault(db, time().default('15:50:33.123'), `'15:50:33.123'`);
+	const res1_17 = await diffDefault(
+		db,
+		time().default('15:50:33.123Z'),
+		`'15:50:33.123Z'`,
+	);
+
+	const res1_8 = await diffDefault(
+		db,
+		time({ withTimezone: true }).default('15:50:33'),
+		`'15:50:33'`,
+	);
+	// const res1_9 = await diffDefault(db, time({ withTimezone: true }).default('15:50:33Z'), `'15:50:33Z'`);
+	// const res1_10 = await diffDefault(db, time({ withTimezone: true }).default('15:50:33+00'), `'15:50:33+00'`);
+	// const res1_11 = await diffDefault(db, time({ withTimezone: true }).default('15:50:33+03'), `'15:50:33+03'`);
+	// const res1_12 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).default('2025-05-23 15:50:33'),
+	// 	`'2025-05-23 15:50:33'`,
+	// );
+	// const res1_13 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).default('2025-05-23 15:50:33Z'),
+	// 	`'2025-05-23 15:50:33Z'`,
+	// );
+	// const res1_14 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).default('2025-05-23T15:50:33+00'),
+	// 	`'2025-05-23T15:50:33+00'`,
+	// );
+	const res1_20 = await diffDefault(
+		db,
+		time({ withTimezone: true, precision: 1 }).default('15:50:33.123+03'),
+		`'15:50:33.123+03'`,
+	);
+
+	// normal time with precision that is same as in default
+	const res2 = await diffDefault(
+		db,
+		time({ precision: 3 }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res2_1 = await diffDefault(db, time({ precision: 3 }).default('15:50:33.123Z'), `'15:50:33.123Z'`);
+	// const res2_2 = await diffDefault(db, time({ precision: 3 }).default('15:50:33.123+00'), `'15:50:33.123+00'`);
+	// const res2_3 = await diffDefault(db, time({ precision: 3 }).default('15:50:33.123+03'), `'15:50:33.123+03'`);
+	// const res2_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res2_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res2_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res2_7 = await diffDefault(
+		db,
+		time({ precision: 3 }).default('2025-05-23 15:50:33.123+03'),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	const res2_8 = await diffDefault(
+		db,
+		time({ precision: 3, withTimezone: true }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res2_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('15:50:33.123Z'),
+	// 	`'15:50:33.123Z'`,
+	// );
+	// const res2_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('15:50:33.123+00'),
+	// 	`'15:50:33.123+00'`,
+	// );
+	// const res2_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('15:50:33.123+03'),
+	// 	`'15:50:33.123+03'`,
+	// );
+	// const res2_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res2_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res2_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res2_15 = await diffDefault(
+		db,
+		time({ precision: 3, withTimezone: true }).default(
+			'2025-05-23 15:50:33.123+03',
+		),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	// normal time with precision that is less than in default
+	const res3 = await diffDefault(
+		db,
+		time({ precision: 1 }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res3_1 = await diffDefault(db, time({ precision: 1 }).default('15:50:33.123Z'), `'15:50:33.123Z'`);
+	// const res3_2 = await diffDefault(db, time({ precision: 1 }).default('15:50:33.123+00'), `'15:50:33.123+00'`);
+	// const res3_3 = await diffDefault(db, time({ precision: 1 }).default('15:50:33.123+03'), `'15:50:33.123+03'`);
+	// const res3_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res3_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res3_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res3_7 = await diffDefault(
+		db,
+		time({ precision: 1 }).default('2025-05-23 15:50:33.123+03'),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	const res3_8 = await diffDefault(
+		db,
+		time({ precision: 1, withTimezone: true }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res3_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('15:50:33.123Z'),
+	// 	`'15:50:33.123Z'`,
+	// );
+	// const res3_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('15:50:33.123+00'),
+	// 	`'15:50:33.123+00'`,
+	// );
+	// const res3_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('15:50:33.123+03'),
+	// 	`'15:50:33.123+03'`,
+	// );
+	// const res3_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res3_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res3_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res3_15 = await diffDefault(
+		db,
+		time({ precision: 1, withTimezone: true }).default(
+			'2025-05-23 15:50:33.123+03',
+		),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	// normal time with precision that is bigger than in default
+	const res4 = await diffDefault(
+		db,
+		time({ precision: 5 }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res4_1 = await diffDefault(db, time({ precision: 5 }).default('15:50:33.123Z'), `'15:50:33.123Z'`);
+	// const res4_2 = await diffDefault(db, time({ precision: 5 }).default('15:50:33.123+00'), `'15:50:33.123+00'`);
+	// const res4_3 = await diffDefault(db, time({ precision: 5 }).default('15:50:33.123+03'), `'15:50:33.123+03'`);
+	// const res4_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res4_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res4_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res4_7 = await diffDefault(
+		db,
+		time({ precision: 5 }).default('2025-05-23 15:50:33.123+03'),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	const res4_8 = await diffDefault(
+		db,
+		time({ precision: 5, withTimezone: true }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+	// const res4_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('15:50:33.123Z'),
+	// 	`'15:50:33.123Z'`,
+	// );
+	// const res4_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('15:50:33.123+00'),
+	// 	`'15:50:33.123+00'`,
+	// );
+	// const res4_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('15:50:33.123+03'),
+	// 	`'15:50:33.123+03'`,
+	// );
+	// const res4_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('2025-05-23 15:50:33.123'),
+	// 	`'2025-05-23 15:50:33.123'`,
+	// );
+	// const res4_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('2025-05-23 15:50:33.123Z'),
+	// 	`'2025-05-23 15:50:33.123Z'`,
+	// );
+	// const res4_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).default('2025-05-23T15:50:33.123+00'),
+	// 	`'2025-05-23T15:50:33.123+00'`,
+	// );
+	const res4_15 = await diffDefault(
+		db,
+		time({ precision: 5, withTimezone: true }).default(
+			'2025-05-23 15:50:33.123+03',
+		),
+		`'2025-05-23 15:50:33.123+03'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	// expect(res1_1).toStrictEqual([]);
+	// expect(res1_2).toStrictEqual([]);
+	// expect(res1_3).toStrictEqual([]);
+	// expect(res1_4).toStrictEqual([]);
+	// expect(res1_5).toStrictEqual([]);
+	// expect(res1_6).toStrictEqual([]);
+	// expect(res1_7).toStrictEqual([]);
+	expect(res1_8).toStrictEqual([]);
+	// expect(res1_9).toStrictEqual([]);
+	// expect(res1_10).toStrictEqual([]);
+	// expect(res1_11).toStrictEqual([]);
+	// expect(res1_12).toStrictEqual([]);
+	// expect(res1_13).toStrictEqual([]);
+	// expect(res1_14).toStrictEqual([]);
+	// expect(res1_16).toStrictEqual([]);
+	expect(res1_17).toStrictEqual([]);
+	expect(res1_20).toStrictEqual([]);
+
+	expect(res2).toStrictEqual([]);
+	// expect(res2_1).toStrictEqual([]);
+	// expect(res2_2).toStrictEqual([]);
+	// expect(res2_3).toStrictEqual([]);
+	// expect(res2_4).toStrictEqual([]);
+	// expect(res2_5).toStrictEqual([]);
+	// expect(res2_6).toStrictEqual([]);
+	expect(res2_7).toStrictEqual([]);
+	expect(res2_8).toStrictEqual([]);
+	// expect(res2_9).toStrictEqual([]);
+	// expect(res2_10).toStrictEqual([]);
+	// expect(res2_11).toStrictEqual([]);
+	// expect(res2_12).toStrictEqual([]);
+	// expect(res2_13).toStrictEqual([]);
+	// expect(res2_14).toStrictEqual([]);
+	expect(res2_15).toStrictEqual([]);
+
+	expect(res3).toStrictEqual([]);
+	// expect(res3_1).toStrictEqual([]);
+	// expect(res3_2).toStrictEqual([]);
+	// expect(res3_3).toStrictEqual([]);
+	// expect(res3_4).toStrictEqual([]);
+	// expect(res3_5).toStrictEqual([]);
+	// expect(res3_6).toStrictEqual([]);
+	expect(res3_7).toStrictEqual([]);
+	expect(res3_8).toStrictEqual([]);
+	// expect(res3_9).toStrictEqual([]);
+	// expect(res3_10).toStrictEqual([]);
+	// expect(res3_11).toStrictEqual([]);
+	// expect(res3_12).toStrictEqual([]);
+	// expect(res3_13).toStrictEqual([]);
+	// expect(res3_14).toStrictEqual([]);
+	expect(res3_15).toStrictEqual([]);
+
+	expect(res4).toStrictEqual([]);
+	// expect(res4_1).toStrictEqual([]);
+	// expect(res4_2).toStrictEqual([]);
+	// expect(res4_3).toStrictEqual([]);
+	// expect(res4_4).toStrictEqual([]);
+	// expect(res4_5).toStrictEqual([]);
+	// expect(res4_6).toStrictEqual([]);
+	expect(res4_7).toStrictEqual([]);
+	expect(res4_8).toStrictEqual([]);
+	// expect(res4_9).toStrictEqual([]);
+	// expect(res4_10).toStrictEqual([]);
+	// expect(res4_11).toStrictEqual([]);
+	// expect(res4_12).toStrictEqual([]);
+	// expect(res4_13).toStrictEqual([]);
+	// expect(res4_14).toStrictEqual([]);
+	expect(res4_15).toStrictEqual([]);
+});
+
+test.concurrent('time arrays', async ({ dbc: db }) => {
+	// normal array time without precision
+	const res5 = await diffDefault(
+		db,
+		time().array().default(['15:50:33']),
+		`'{15:50:33}'::time[]`,
+	);
+	// const res5_1 = await diffDefault(db, time().array().default(['15:50:33Z']), `'{15:50:33Z}'::time[]`);
+	// const res5_2 = await diffDefault(db, time().array().default(['15:50:33+00']), `'{15:50:33+00}'::time[]`);
+	// const res5_3 = await diffDefault(db, time().array().default(['15:50:33+03']), `'{15:50:33+03}'::time[]`);
+	// const res5_4 = await diffDefault(
+	// 	db,
+	// 	time().array().default(['2025-05-23 15:50:33']),
+	// 	`'{2025-05-23 15:50:33}'::time[]`,
+	// );
+	// const res5_5 = await diffDefault(
+	// 	db,
+	// 	time().array().default(['2025-05-23 15:50:33Z']),
+	// 	`'{2025-05-23 15:50:33Z}'::time[]`,
+	// );
+	// const res5_6 = await diffDefault(
+	// 	db,
+	// 	time().array().default(['2025-05-23T15:50:33+00']),
+	// 	`'{2025-05-23T15:50:33+00}'::time[]`,
+	// );
+	const res5_7 = await diffDefault(
+		db,
+		time().array().default(['2025-05-23 15:50:33+03']),
+		`'{2025-05-23 15:50:33+03}'::time[]`,
+	);
+
+	const res5_8 = await diffDefault(
+		db,
+		time({ withTimezone: true }).array().default(['15:50:33']),
+		`'{15:50:33}'::timetz[]`,
+	);
+	// const res5_9 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['15:50:33Z']),
+	// 	`'{15:50:33Z}'::timetz[]`,
+	// );
+	// const res5_10 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['15:50:33+00']),
+	// 	`'{15:50:33+00}'::timetz[]`,
+	// );
+	// const res5_11 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['15:50:33+03']),
+	// 	`'{15:50:33+03}'::timetz[]`,
+	// );
+	// const res5_12 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['2025-05-23 15:50:33']),
+	// 	`'{2025-05-23 15:50:33}'::timetz[]`,
+	// );
+	// const res5_13 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['2025-05-23 15:50:33Z']),
+	// 	`'{2025-05-23 15:50:33Z}'::timetz[]`,
+	// );
+	// const res5_14 = await diffDefault(
+	// 	db,
+	// 	time({ withTimezone: true }).array().default(['2025-05-23T15:50:33+00']),
+	// 	`'{2025-05-23T15:50:33+00}'::timetz[]`,
+	// );
+	const res5_15 = await diffDefault(
+		db,
+		time({ withTimezone: true }).array().default(['2025-05-23 15:50:33+03']),
+		`'{2025-05-23 15:50:33+03}'::timetz[]`,
+	);
+
+	// normal array time with precision that is same as in default
+	const res6 = await diffDefault(
+		db,
+		time({ precision: 3 }).array().default(['15:50:33.123']),
+		`'{15:50:33.123}'::time(3)[]`,
+	);
+	// const res6_1 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::time(3)[]`,
+	// );
+	// const res6_2 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::time(3)[]`,
+	// );
+	// const res6_3 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::time(3)[]`,
+	// );
+	// const res6_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::time(3)[]`,
+	// );
+	// const res6_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::time(3)[]`,
+	// );
+	// const res6_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3 }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::time(3)[]`,
+	// );
+	const res6_7 = await diffDefault(
+		db,
+		time({ precision: 3 }).array().default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::time(3)[]`,
+	);
+
+	const res6_8 = await diffDefault(
+		db,
+		time({ precision: 3, withTimezone: true })
+			.array()
+			.default(['15:50:33.123']),
+		`'{15:50:33.123}'::timetz(3)[]`,
+	);
+	// const res6_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::timetz(3)[]`,
+	// );
+	// const res6_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::timetz(3)[]`,
+	// );
+	// const res6_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::timetz(3)[]`,
+	// );
+	// const res6_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::timetz(3)[]`,
+	// );
+	// const res6_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::timetz(3)[]`,
+	// );
+	// const res6_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 3, withTimezone: true }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::timetz(3)[]`,
+	// );
+	const res6_15 = await diffDefault(
+		db,
+		time({ precision: 3, withTimezone: true })
+			.array()
+			.default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::timetz(3)[]`,
+	);
+
+	// normal array time with precision that is less than in default
+	const res7 = await diffDefault(
+		db,
+		time({ precision: 1 }).array().default(['15:50:33.123']),
+		`'{15:50:33.123}'::time(1)[]`,
+	);
+	// const res7_1 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::time(1)[]`,
+	// );
+	// const res7_2 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::time(1)[]`,
+	// );
+	// const res7_3 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::time(1)[]`,
+	// );
+	// const res7_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::time(1)[]`,
+	// );
+	// const res7_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::time(1)[]`,
+	// );
+	// const res7_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1 }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::time(1)[]`,
+	// );
+	const res7_7 = await diffDefault(
+		db,
+		time({ precision: 1 }).array().default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::time(1)[]`,
+	);
+
+	const res7_8 = await diffDefault(
+		db,
+		time({ precision: 1, withTimezone: true })
+			.array()
+			.default(['15:50:33.123']),
+		`'{15:50:33.123}'::timetz(1)[]`,
+	);
+	// const res7_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::timetz(1)[]`,
+	// );
+	// const res7_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::timetz(1)[]`,
+	// );
+	// const res7_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::timetz(1)[]`,
+	// );
+	// const res7_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::timetz(1)[]`,
+	// );
+	// const res7_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::timetz(1)[]`,
+	// );
+	// const res7_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 1, withTimezone: true }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::timetz(1)[]`,
+	// );
+	const res7_15 = await diffDefault(
+		db,
+		time({ precision: 1, withTimezone: true })
+			.array()
+			.default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::timetz(1)[]`,
+	);
+
+	// normal array time with precision that is bigger than in default
+	const res8 = await diffDefault(
+		db,
+		time({ precision: 5 }).array().default(['15:50:33.123']),
+		`'{15:50:33.123}'::time(5)[]`,
+	);
+	// const res8_1 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::time(5)[]`,
+	// );
+	// const res8_2 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::time(5)[]`,
+	// );
+	// const res8_3 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::time(5)[]`,
+	// );
+	// const res8_4 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::time(5)[]`,
+	// );
+	// const res8_5 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::time(5)[]`,
+	// );
+	// const res8_6 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5 }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::time(5)[]`,
+	// );
+	const res8_7 = await diffDefault(
+		db,
+		time({ precision: 5 }).array().default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::time(5)[]`,
+	);
+
+	const res8_8 = await diffDefault(
+		db,
+		time({ precision: 5, withTimezone: true })
+			.array()
+			.default(['15:50:33.123']),
+		`'{15:50:33.123}'::timetz(5)[]`,
+	);
+	// const res8_9 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['15:50:33.123Z']),
+	// 	`'{15:50:33.123Z}'::timetz(5)[]`,
+	// );
+	// const res8_10 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['15:50:33.123+00']),
+	// 	`'{15:50:33.123+00}'::timetz(5)[]`,
+	// );
+	// const res8_11 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['15:50:33.123+03']),
+	// 	`'{15:50:33.123+03}'::timetz(5)[]`,
+	// );
+	// const res8_12 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['2025-05-23 15:50:33.123']),
+	// 	`'{2025-05-23 15:50:33.123}'::timetz(5)[]`,
+	// );
+	// const res8_13 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['2025-05-23 15:50:33.123Z']),
+	// 	`'{2025-05-23 15:50:33.123Z}'::timetz(5)[]`,
+	// );
+	// const res8_14 = await diffDefault(
+	// 	db,
+	// 	time({ precision: 5, withTimezone: true }).array().default(['2025-05-23T15:50:33.123+00']),
+	// 	`'{2025-05-23T15:50:33.123+00}'::timetz(5)[]`,
+	// );
+	const res8_15 = await diffDefault(
+		db,
+		time({ precision: 5, withTimezone: true })
+			.array()
+			.default(['2025-05-23 15:50:33.123+03']),
+		`'{2025-05-23 15:50:33.123+03}'::timetz(5)[]`,
+	);
+
+	expect(res5).toStrictEqual([]);
+	// expect(res5_1).toStrictEqual([]);
+	// expect(res5_2).toStrictEqual([]);
+	// expect(res5_3).toStrictEqual([]);
+	// expect(res5_4).toStrictEqual([]);
+	// expect(res5_5).toStrictEqual([]);
+	// expect(res5_6).toStrictEqual([]);
+	expect(res5_7).toStrictEqual([]);
+	expect(res5_8).toStrictEqual([]);
+	// expect(res5_9).toStrictEqual([]);
+	// expect(res5_10).toStrictEqual([]);
+	// expect(res5_11).toStrictEqual([]);
+	// expect(res5_12).toStrictEqual([]);
+	// expect(res5_13).toStrictEqual([]);
+	// expect(res5_14).toStrictEqual([]);
+	expect(res5_15).toStrictEqual([]);
+
+	expect(res6).toStrictEqual([]);
+	// expect(res6_1).toStrictEqual([]);
+	// expect(res6_2).toStrictEqual([]);
+	// expect(res6_3).toStrictEqual([]);
+	// expect(res6_4).toStrictEqual([]);
+	// expect(res6_5).toStrictEqual([]);
+	// expect(res6_6).toStrictEqual([]);
+	expect(res6_7).toStrictEqual([]);
+	expect(res6_8).toStrictEqual([]);
+	// expect(res6_9).toStrictEqual([]);
+	// expect(res6_10).toStrictEqual([]);
+	// expect(res6_11).toStrictEqual([]);
+	// expect(res6_12).toStrictEqual([]);
+	// expect(res6_13).toStrictEqual([]);
+	// expect(res6_14).toStrictEqual([]);
+	expect(res6_15).toStrictEqual([]);
+
+	expect(res7).toStrictEqual([]);
+	// expect(res7_1).toStrictEqual([]);
+	// expect(res7_2).toStrictEqual([]);
+	// expect(res7_3).toStrictEqual([]);
+	// expect(res7_4).toStrictEqual([]);
+	// expect(res7_5).toStrictEqual([]);
+	// expect(res7_6).toStrictEqual([]);
+	expect(res7_7).toStrictEqual([]);
+	expect(res7_8).toStrictEqual([]);
+	// expect(res7_9).toStrictEqual([]);
+	// expect(res7_10).toStrictEqual([]);
+	// expect(res7_11).toStrictEqual([]);
+	// expect(res7_12).toStrictEqual([]);
+	// expect(res7_13).toStrictEqual([]);
+	// expect(res7_14).toStrictEqual([]);
+	expect(res7_15).toStrictEqual([]);
+
+	expect(res8).toStrictEqual([]);
+	// expect(res8_1).toStrictEqual([]);
+	// expect(res8_2).toStrictEqual([]);
+	// expect(res8_3).toStrictEqual([]);
+	// expect(res8_4).toStrictEqual([]);
+	// expect(res8_5).toStrictEqual([]);
+	// expect(res8_6).toStrictEqual([]);
+	expect(res8_7).toStrictEqual([]);
+	expect(res8_8).toStrictEqual([]);
+	// expect(res8_9).toStrictEqual([]);
+	// expect(res8_10).toStrictEqual([]);
+	// expect(res8_11).toStrictEqual([]);
+	// expect(res8_12).toStrictEqual([]);
+	// expect(res8_13).toStrictEqual([]);
+	// expect(res8_14).toStrictEqual([]);
+	expect(res8_15).toStrictEqual([]);
+});
+
+test.concurrent('date', async ({ dbc: db }) => {
+	// dates
+	const res1 = await diffDefault(
+		db,
+		date({ mode: 'date' }).default(new Date('2025-05-23')),
+		`'2025-05-23'`,
+	);
+	const res1_1 = await diffDefault(
+		db,
+		date({ mode: 'date' }).default(new Date('2025-05-23T12:12:31.213')),
+		`'2025-05-23'`,
+	);
+	const res1_2 = await diffDefault(
+		db,
+		date({ mode: 'date' }).defaultNow(),
+		`now()`,
+	);
+
+	const res2_1 = await diffDefault(
+		db,
+		date({ mode: 'date' }).default(new Date('2025-05-23')),
+		`'2025-05-23'`,
+	);
+	const res2_2 = await diffDefault(
+		db,
+		date({ mode: 'date' }).default(new Date('2025-05-23T12:12:31.213')),
+		`'2025-05-23'`,
+	);
+	const res2_3 = await diffDefault(
+		db,
+		date({ mode: 'date' }).defaultNow(),
+		`now()`,
+	);
+
+	// strings
+	const res3 = await diffDefault(
+		db,
+		date({ mode: 'string' }).default('2025-05-23'),
+		`'2025-05-23'`,
+	);
+	const res3_1 = await diffDefault(
+		db,
+		date({ mode: 'string' }).default('2025-05-23T12:12:31.213'),
+		`'2025-05-23T12:12:31.213'`,
+	);
+	const res3_2 = await diffDefault(
+		db,
+		date({ mode: 'string' }).defaultNow(),
+		`now()`,
+	);
+	const res3_3 = await diffDefault(
+		db,
+		date({ mode: 'string' }).default('2025-05-23 12:12:31.213+01:00'),
+		`'2025-05-23 12:12:31.213+01:00'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res1_1).toStrictEqual([]);
+	expect(res1_2).toStrictEqual([]);
+
+	expect(res2_1).toStrictEqual([]);
+	expect(res2_2).toStrictEqual([]);
+	expect(res2_3).toStrictEqual([]);
+
+	expect(res3).toStrictEqual([]);
+	expect(res3_1).toStrictEqual([]);
+	expect(res3_2).toStrictEqual([]);
+	expect(res3_3).toStrictEqual([]);
+});
+
+test.concurrent('date arrays', async ({ dbc: db }) => {
+	const res2 = await diffDefault(
+		db,
+		date({ mode: 'date' }).array().default([]),
+		`'{}'::date[]`,
+	);
+
+	const res4 = await diffDefault(
+		db,
+		date({ mode: 'string' }).array().default(['2025-05-23']),
+		`'{2025-05-23}'::date[]`,
+	);
+	const res4_1 = await diffDefault(
+		db,
+		date({ mode: 'string' }).array().default(['2025-05-23T12:12:31.213']),
+		`'{2025-05-23T12:12:31.213}'::date[]`,
+	);
+	const res4_2 = await diffDefault(
+		db,
+		date({ mode: 'string' }).array().default(['2025-05-23 12:12:31.213+01:00']),
+		`'{2025-05-23 12:12:31.213+01:00}'::date[]`,
+	);
+
+	expect(res2).toStrictEqual([]);
+
+	expect(res4).toStrictEqual([]);
+	expect(res4_1).toStrictEqual([]);
+	expect(res4_2).toStrictEqual([]);
+});
+
+// This is not handled the way cockroach stores it
+// since user can pass `1 2:3:4` and it will be stored as `1 day 02:03:04`
+// so we just compare row values
+// | This text is a duplicate from cockroach/grammar.ts |
+test.concurrent('interval', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		interval().default('1 day'),
+		`'1 day'`,
+	);
+	const res10 = await diffDefault(
+		db,
+		interval({ fields: 'day to second', precision: 3 }).default(
+			'1 day 3 second',
+		),
+		`'1 day 3 second'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	// it's ok, that's due to '1 day 3 second' vs '1 day 00:00:03'
+	expect(res10.length).toBe(1);
+});
+
+test.concurrent('interval arrays', async ({ dbc: db }) => {
+	const res2 = await diffDefault(
+		db,
+		interval().array().default([]),
+		`'{}'::interval[]`,
+	);
+	const res20 = await diffDefault(
+		db,
+		interval({ fields: 'day to second', precision: 3 }).array().default([]),
+		`'{}'::interval day to second(3)[]`,
+	);
+
+	const res3 = await diffDefault(
+		db,
+		interval().array().default(['1 day']),
+		`'{"1 day"}'::interval[]`,
+	);
+	const res30 = await diffDefault(
+		db,
+		interval({ fields: 'day to second', precision: 3 })
+			.array()
+			.default(['1 day 3 second']),
+		`'{"1 day 3 second"}'::interval day to second(3)[]`,
+	);
+
+	expect(res2).toStrictEqual([]);
+	expect(res20).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	// it's ok, that's due to '1 day 3 second' vs '1 day 00:00:03'
+	expect(res30.length).toBe(1);
+});
+
+test.concurrent('enum', async ({ dbc: db }) => {
+	const moodEnum = cockroachEnum('mood_enum', [
+		'sad',
+		'ok',
+		'happy',
+		`text'text`,
+		`text"text`,
+		`text\\text`,
+		`text,text`,
+		`no,''"\`rm`,
+		`mo''",\\\`}{od`,
+		`mo''"\\\\\\\`}{od`,
+		'mo,\`od',
+	]);
+	const pre = { moodEnum };
+
+	const res1 = await diffDefault(
+		db,
+		moodEnum().default('ok'),
+		`'ok'::"mood_enum"`,
+		{ pre },
+	);
+	const res2 = await diffDefault(
+		db,
+		moodEnum().default(`text'text`),
+		`e'text\\'text'::"mood_enum"`,
+		{ pre },
+	);
+	const res3 = await diffDefault(
+		db,
+		moodEnum().default('text"text'),
+		`'text"text'::"mood_enum"`,
+		{ pre },
+	);
+	const res4 = await diffDefault(
+		db,
+		moodEnum().default('text\\text'),
+		`e'text\\\\text'::"mood_enum"`,
+		{ pre },
+	);
+	const res5 = await diffDefault(
+		db,
+		moodEnum().default('text,text'),
+		`'text,text'::"mood_enum"`,
+		{ pre },
+	);
+	const res6 = await diffDefault(
+		db,
+		moodEnum().default(`mo''"\\\\\\\`}{od`),
+		`e'mo\\'\\'"\\\\\\\\\\\\\`}{od'::"mood_enum"`,
+		{ pre },
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+});
+
+test.concurrent('enum arrays', async ({ dbc: db }) => {
+	const moodEnum = cockroachEnum('mood_enum', [
+		'sad',
+		'ok',
+		'happy',
+		`text'text`,
+		`text"text`,
+		`text\\text`,
+		`text,text`,
+		`no,''"\`rm`,
+		`mo''",\\\`}{od`,
+		`mo''"\\\\\\\`}{od`,
+		'mo,\`od',
+	]);
+	const pre = { moodEnum };
+
+	const res1_1 = await diffDefault(
+		db,
+		moodEnum().array().default(['ok']),
+		`'{ok}'::"mood_enum"[]`,
+		{ pre },
+	);
+	const res1_2 = await diffDefault(
+		db,
+		moodEnum().array().default(['sad']),
+		`'{sad}'::"mood_enum"[]`,
+		{ pre },
+	);
+	const res2_1 = await diffDefault(
+		db,
+		moodEnum().array().default([`text'text`]),
+		`'{"text''text"}'::"mood_enum"[]`,
+		{ pre },
+	);
+	const res3_1 = await diffDefault(
+		db,
+		moodEnum().array().default(['text"text']),
+		`'{"text\\"text"}'::"mood_enum"[]`,
+		{ pre },
+	);
+	const res4_1 = await diffDefault(
+		db,
+		moodEnum().array().default(['text\\text']),
+		`'{"text\\\\text"}'::"mood_enum"[]`,
+		{ pre },
+	);
+	const res6_1 = await diffDefault(
+		db,
+		moodEnum().array().default([`mo''"\\\\\\\`}{od`]),
+		`'{"mo''''\\"\\\\\\\\\\\\\`}{od"}'::"mood_enum"[]`,
+		{ pre },
+	);
+
+	expect(res1_1).toStrictEqual([]);
+	expect(res1_2).toStrictEqual([]);
+	expect(res2_1).toStrictEqual([]);
+	expect(res3_1).toStrictEqual([]);
+	expect(res4_1).toStrictEqual([]);
+	expect(res6_1).toStrictEqual([]);
+});
+
+test.concurrent('uuid', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		uuid().default('550e8400-e29b-41d4-a716-446655440000'),
+		`'550e8400-e29b-41d4-a716-446655440000'`,
+	);
+
+	const res5 = await diffDefault(
+		db,
+		uuid().defaultRandom(),
+		`gen_random_uuid()`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+});
+
+test.concurrent('uuid arrays', async ({ dbc: db }) => {
+	const res2 = await diffDefault(
+		db,
+		uuid().array().default([]),
+		`'{}'::uuid[]`,
+	);
+
+	const res4 = await diffDefault(
+		db,
+		uuid().array().default(['550e8400-e29b-41d4-a716-446655440000']),
+		`'{550e8400-e29b-41d4-a716-446655440000}'::uuid[]`,
+	);
+
+	const res6 = await diffDefault(
+		db,
+		uuid()
+			.array()
+			.default(sql`'{550e8400-e29b-41d4-a716-446655440001}'`),
+		`'{550e8400-e29b-41d4-a716-446655440001}'::uuid[]`,
+	);
+
+	const res7 = await diffDefault(
+		db,
+		uuid()
+			.array()
+			.default(sql`'{550e8400-e29b-41d4-a716-446655440002}'::uuid[]`),
+		`'{550e8400-e29b-41d4-a716-446655440002}'::uuid[]`,
+	);
+
+	expect(res2).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+});
+
+test.concurrent('bit', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, bit().default(`101`), `'101'`);
+	const res2 = await diffDefault(
+		db,
+		bit().default(`1010010010`),
+		`'1010010010'`,
+	);
+
+	const res3 = await diffDefault(
+		db,
+		bit({ length: 4 }).default(`101`),
+		`'101'`,
+	);
+	const res4 = await diffDefault(
+		db,
+		bit({ length: 4 }).default(`1010010010`),
+		`'1010010010'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('bit arrays', async ({ dbc: db }) => {
+	const res5 = await diffDefault(
+		db,
+		bit().array().default([]),
+		`'{}'::bit[]`,
+	);
+	const res6 = await diffDefault(
+		db,
+		bit().array().default([`101`]),
+		`'{101}'::bit[]`,
+	);
+
+	const res7 = await diffDefault(
+		db,
+		bit({ length: 3 }).array().default([]),
+		`'{}'::bit(3)[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		bit({ length: 3 }).array().default([`10110`]),
+		`'{10110}'::bit(3)[]`,
+	);
+
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+});
+
+test.concurrent('varbit', async ({ dbc: db }) => {
+	const res1 = await diffDefault(db, varbit().default(`101`), `'101'`);
+	const res2 = await diffDefault(
+		db,
+		varbit().default(`1010010010`),
+		`'1010010010'`,
+	);
+
+	const res3 = await diffDefault(
+		db,
+		varbit({ length: 4 }).default(`101`),
+		`'101'`,
+	);
+	const res4 = await diffDefault(
+		db,
+		varbit({ length: 4 }).default(`1010010010`),
+		`'1010010010'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('varbit arrays', async ({ dbc: db }) => {
+	const res5 = await diffDefault(
+		db,
+		varbit().array().default([]),
+		`'{}'::varbit[]`,
+	);
+	const res6 = await diffDefault(
+		db,
+		varbit().array().default([`101`]),
+		`'{101}'::varbit[]`,
+	);
+
+	const res7 = await diffDefault(
+		db,
+		varbit({ length: 3 }).array().default([]),
+		`'{}'::varbit(3)[]`,
+	);
+	const res8 = await diffDefault(
+		db,
+		varbit({ length: 3 }).array().default([`10110`]),
+		`'{10110}'::varbit(3)[]`,
+	);
+
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res7).toStrictEqual([]);
+	expect(res8).toStrictEqual([]);
+});
+
+test.concurrent('vector', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		vector({ dimensions: 3 }).default([0, -2, 3]),
+		`'[0,-2,3]'`,
+	);
+	const res2 = await diffDefault(
+		db,
+		vector({ dimensions: 1 }).default([0.0]),
+		`'[0]'`,
+	);
+	const res3 = await diffDefault(
+		db,
+		vector({ dimensions: 5 }).default([0.0, 1.321, 5.21, 521.4, 4.0]),
+		`'[0,1.321,5.21,521.4,4]'`,
+	);
+	const res4 = await diffDefault(
+		db,
+		vector({ dimensions: 3 }).default([0, -2.12345, 3.123456]),
+		`'[0,-2.12345,3.123456]'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+});
+
+test.concurrent('inet', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		inet().default('127.0.0.1'),
+		`'127.0.0.1'`,
+	);
+	const res2 = await diffDefault(
+		db,
+		inet().default('::ffff:192.168.0.1/96'),
+		`'::ffff:192.168.0.1/96'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+});
+
+test.concurrent('inet arrays', async ({ dbc: db }) => {
+	const res1_1 = await diffDefault(
+		db,
+		inet().array().default(['127.0.0.1']),
+		`'{127.0.0.1}'::inet[]`,
+	);
+	const res2_1 = await diffDefault(
+		db,
+		inet().array().default(['::ffff:192.168.0.1/96']),
+		`'{::ffff:192.168.0.1/96}'::inet[]`,
+	);
+
+	expect(res1_1).toStrictEqual([]);
+	expect(res2_1).toStrictEqual([]);
+});
+
+// postgis extension
+// SRID=4326 -> these coordinates are longitude/latitude values
+test.concurrent('geometry', async ({ dbc: db }) => {
+	const res1 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).default([
+			30.5234,
+			50.4501,
+		]),
+		`'SRID=4326;POINT(30.5234 50.4501)'`,
+	);
+
+	const res2 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).default({
+			x: 30.5234,
+			y: 50.4501,
+		}),
+		`'SRID=4326;POINT(30.5234 50.4501)'`,
+	);
+
+	const res11 = await diffDefault(
+		db,
+		geometry({ mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }),
+		`'POINT(30.5234 50.4501)'`,
+	);
+
+	const res12 = await diffDefault(
+		db,
+		geometry({ mode: 'xy', type: 'point' }).default(
+			sql`'SRID=4326;POINT(10 10)'`,
+		),
+		`'SRID=4326;POINT(10 10)'`,
+	);
+
+	expect(res1).toStrictEqual([]);
+	expect(res2).toStrictEqual([]);
+	expect(res11).toStrictEqual([]);
+	expect(res12).toStrictEqual([]);
+});
+
+test.concurrent('geometry arrays', async ({ dbc: db }) => {
+	const res3 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).array().default([]),
+		`'{}'::geometry(point,4326)[]`,
+	);
+	const res4 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' })
+			.array()
+			.default([[30.5234, 50.4501]]),
+		`'{SRID=4326;POINT(30.5234 50.4501)}'::geometry(point,4326)[]`,
+	);
+
+	const res5 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).array().default([]),
+		`'{}'::geometry(point,4326)[]`,
+	);
+	const res6 = await diffDefault(
+		db,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' })
+			.array()
+			.default([{ x: 30.5234, y: 50.4501 }]),
+		`'{SRID=4326;POINT(30.5234 50.4501)}'::geometry(point,4326)[]`,
+	);
+
+	const res13 = await diffDefault(
+		db,
+		geometry({ mode: 'xy', type: 'point' })
+			.array()
+			.default([{ x: 13, y: 13 }]),
+		`'{POINT(13 13)}'::geometry(point)[]`,
+	);
+
+	const res15 = await diffDefault(
+		db,
+		geometry({ mode: 'xy', type: 'point' })
+			.array()
+			.default(sql`'{SRID=4326;POINT(15 15)}'::geometry(point)[]`),
+		`'{SRID=4326;POINT(15 15)}'::geometry(point)[]`,
+	);
+
+	const res16 = await diffDefault(
+		db,
+		geometry({ mode: 'xy', type: 'point' })
+			.array()
+			.default(sql`'{POINT(15 15)}'::geometry(point)[]`),
+		`'{POINT(15 15)}'::geometry(point)[]`,
+	);
+
+	expect(res3).toStrictEqual([]);
+	expect(res4).toStrictEqual([]);
+	expect(res5).toStrictEqual([]);
+	expect(res6).toStrictEqual([]);
+	expect(res13).toStrictEqual([]);
+	expect(res15).toStrictEqual([]);
+	expect(res16).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/cockroach/entity-filter.test.ts b/drizzle-kit/tests/cockroach/entity-filter.test.ts
new file mode 100644
index 0000000000..847b5d7b8f
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/entity-filter.test.ts
@@ -0,0 +1,341 @@
+import { sql } from 'drizzle-orm';
+import { cockroachSchema, cockroachView, int4 as int } from 'drizzle-orm/cockroach-core';
+import { afterAll, beforeAll, beforeEach, expect } from 'vitest';
+import { push, test } from './mocks';
+
+test('push schema #1', async ({ db }) => {
+	const to = { dev: cockroachSchema('dev') };
+	const st0 = ['CREATE SCHEMA "dev";\n'];
+
+	{
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+});
+
+test('push schema #2', async ({ db }) => {
+	const to = { dev: cockroachSchema('dev'), dev2: cockroachSchema('dev2') };
+	const st0 = ['CREATE SCHEMA "dev";\n', 'CREATE SCHEMA "dev2";\n'];
+
+	{
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+		expect(pst).toStrictEqual(['CREATE SCHEMA "dev";\n']);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+		expect(pst).toStrictEqual(['CREATE SCHEMA "dev2";\n']);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+});
+
+test('push schema #3', async ({ db }) => {
+	const to = { dev: cockroachSchema('dev').existing(), dev2: cockroachSchema('dev2') };
+	const st0 = ['CREATE SCHEMA "dev2";\n'];
+
+	{
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+});
+
+test('push schema #4', async ({ db }) => {
+	const dev = cockroachSchema('dev');
+	const table1 = dev.table('table1', { id: int() });
+	const table2 = dev.table('table2', { id: int() });
+	const to = { dev, table1, table2, dev2: cockroachSchema('dev2') };
+
+	const st0 = [
+		'CREATE SCHEMA "dev";\n',
+		'CREATE SCHEMA "dev2";\n',
+		'CREATE TABLE "dev"."table1" (\n\t"id" int4\n);\n',
+		'CREATE TABLE "dev"."table2" (\n\t"id" int4\n);\n',
+	];
+
+	{
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+		expect(pst).toStrictEqual([
+			'CREATE SCHEMA "dev";\n',
+			'CREATE TABLE "dev"."table1" (\n\t"id" int4\n);\n',
+			'CREATE TABLE "dev"."table2" (\n\t"id" int4\n);\n',
+		]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+		expect(pst).toStrictEqual(['CREATE SCHEMA "dev2";\n']);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+});
+
+test('push schema #5', async ({ db }) => {
+	const dev = cockroachSchema('dev').existing();
+	const table1 = dev.table('table1', { id: int() });
+	const table2 = dev.table('table2', { id: int() });
+	const to = { dev, table1, table2, dev2: cockroachSchema('dev2') };
+	const st0 = ['CREATE SCHEMA "dev2";\n'];
+
+	{
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+		expect(pst).toStrictEqual([]);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+
+	{
+		const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+		expect(pst).toStrictEqual(st0);
+		await db.clear();
+	}
+});
+
+test('push schema #6', async ({ db }) => {
+	await db.query('create schema dev');
+
+	const to = { dev: cockroachSchema('dev').existing() };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual([]);
+});
+
+test('push schema #6', async ({ db }) => {
+	await db.query('create schema dev;');
+	await db.query('create table dev.users (id int);');
+
+	const to = { dev: cockroachSchema('dev').existing() };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual([]);
+});
+
+test('push schema #7', async ({ db }) => {
+	await db.query('create schema dev;');
+	await db.query('create table dev.users (id int);');
+
+	const to = { dev: cockroachSchema('dev') };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual(['DROP TABLE "dev"."users";']);
+});
+
+test('push schema #8', async ({ db }) => {
+	await db.query('create schema dev;');
+	await db.query('create table dev.users (id int);');
+	await db.query('create view v as (select * from dev.users);');
+
+	const to = { dev: cockroachSchema('dev') };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual([
+		'DROP VIEW "v";',
+		'DROP TABLE "dev"."users";',
+	]);
+});
+
+test('push schema #9', async ({ db }) => {
+	await db.query('create schema dev;');
+	await db.query('create table dev.users (id int);');
+	await db.query('create view dev.v as (select * from dev.users);');
+
+	const to = { dev: cockroachSchema('dev') };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual([
+		'DROP VIEW "dev"."v";',
+		'DROP TABLE "dev"."users";',
+	]);
+});
+
+test('push schema #10', async ({ db }) => {
+	await db.query('create schema dev;');
+	await db.query('create table dev.users (id int);');
+	await db.query('create view v as (select * from dev.users);');
+
+	const to = { dev: cockroachSchema('dev').existing(), v: cockroachView('v', {}).existing() };
+	const { sqlStatements: pst } = await push({ db, to });
+	expect(pst).toStrictEqual([]);
+});
+
+test('push schema #11', async ({ db }) => {
+	const schema = await import('./schemas/schema0');
+
+	await push({ db, to: schema });
+
+	const res1 = await push({ db, to: { ...schema, core: cockroachSchema('core').existing() } });
+	expect(res1.sqlStatements).toStrictEqual([]);
+
+	const res2 = await push({ db, to: schema });
+	expect(res2.sqlStatements).toStrictEqual([]);
+});
+
+test('huge schema #1', async ({ db }) => {
+	const schema = await import('./schemas/schema1');
+
+	await push({ db, to: schema });
+
+	const res1 = await push({ db, to: { ...schema, core: cockroachSchema('core').existing() } });
+	expect(res1.sqlStatements).toStrictEqual([]);
+
+	const res2 = await push({ db, to: schema });
+	expect(res2.sqlStatements).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/cockroach/enums.test.ts b/drizzle-kit/tests/cockroach/enums.test.ts
new file mode 100644
index 0000000000..eaa70980b9
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/enums.test.ts
@@ -0,0 +1,2283 @@
+import { cockroachEnum, cockroachSchema, cockroachTable, int4, text, varchar } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('enums #1', async ({ db }) => {
+	const to = {
+		enum: cockroachEnum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #2', async ({ db }) => {
+	const folder = cockroachSchema('folder');
+	const to = {
+		folder,
+		enum: folder.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff({ folder }, to, []);
+	await push({ db, to: { folder } });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TYPE "folder"."enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #3', async ({ db }) => {
+	const from = {
+		enum: cockroachEnum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		`DROP TYPE "enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #4', async ({ db }) => {
+	const folder = cockroachSchema('folder');
+
+	const from = {
+		folder,
+		enum: folder.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, { folder }, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: { folder } });
+
+	const st0 = [
+		`DROP TYPE "folder"."enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #5', async ({ db }) => {
+	const folder1 = cockroachSchema('folder1');
+	const folder2 = cockroachSchema('folder2');
+
+	const from = {
+		folder1,
+		enum: folder1.enum('enum', ['value']),
+	};
+
+	const to = {
+		folder2,
+		enum: folder2.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['folder1->folder2']);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: ['folder1->folder2'],
+	});
+
+	const st0 = [
+		`ALTER SCHEMA "folder1" RENAME TO "folder2";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #6', async ({ db }) => {
+	const folder1 = cockroachSchema('folder1');
+	const folder2 = cockroachSchema('folder2');
+
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum', ['value']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.enum->folder2.enum',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: ['folder1.enum->folder2.enum'],
+	});
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum" SET SCHEMA "folder2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #7', async ({ db }) => {
+	const from = {
+		enum: cockroachEnum('enum', ['value1']),
+	};
+
+	const to = {
+		enum: cockroachEnum('enum', ['value1', 'value2']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TYPE "enum" ADD VALUE 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #8', async ({ db }) => {
+	const from = {
+		enum: cockroachEnum('enum', ['value1']),
+	};
+
+	const to = {
+		enum: cockroachEnum('enum', ['value1', 'value2', 'value3']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TYPE "enum" ADD VALUE 'value2';`,
+		`ALTER TYPE "enum" ADD VALUE 'value3';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #9', async ({ db }) => {
+	const from = {
+		enum: cockroachEnum('enum', ['value1', 'value3']),
+	};
+
+	const to = {
+		enum: cockroachEnum('enum', ['value1', 'value2', 'value3']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [`ALTER TYPE "enum" ADD VALUE 'value2' BEFORE 'value3';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #10', async ({ db }) => {
+	const schema = cockroachSchema('folder');
+	const from = {
+		schema,
+		enum: schema.enum('enum', ['value1']),
+	};
+
+	const to = {
+		schema,
+		enum: schema.enum('enum', ['value1', 'value2']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [`ALTER TYPE "folder"."enum" ADD VALUE 'value2';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #11', async ({ db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const from = {
+		schema1,
+		enum: schema1.enum('enum', ['value1']),
+	};
+
+	const to = {
+		schema1,
+		enum: cockroachEnum('enum', ['value1']),
+	};
+
+	const renames = [
+		'folder1.enum->public.enum',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "folder1"."enum" SET SCHEMA "public";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #12', async ({ db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const from = {
+		schema1,
+		enum: cockroachEnum('enum', ['value1']),
+	};
+
+	const to = {
+		schema1,
+		enum: schema1.enum('enum', ['value1']),
+	};
+
+	const renames = [
+		'public.enum->folder1.enum',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum" SET SCHEMA "folder1";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #13', async ({ db }) => {
+	const from = {
+		enum: cockroachEnum('enum1', ['value1']),
+	};
+
+	const to = {
+		enum: cockroachEnum('enum2', ['value1']),
+	};
+
+	const renames = [
+		'public.enum1->public.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" RENAME TO "enum2";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #14', async ({ db }) => {
+	const folder1 = cockroachSchema('folder1');
+	const folder2 = cockroachSchema('folder2');
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum1', ['value1']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum2', ['value1']),
+	};
+
+	const renames = [
+		'folder1.enum1->folder2.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`,
+		`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #15', async ({ db }) => {
+	const folder1 = cockroachSchema('folder1');
+	const folder2 = cockroachSchema('folder2');
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum1', ['value1', 'value4']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum2', ['value1', 'value2', 'value3', 'value4']),
+	};
+
+	const renames = ['folder1.enum1->folder2.enum2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`,
+		`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`,
+		`ALTER TYPE "folder2"."enum2" ADD VALUE 'value2' BEFORE 'value4';`,
+		`ALTER TYPE "folder2"."enum2" ADD VALUE 'value3' BEFORE 'value4';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #16', async ({ db }) => {
+	const enum1 = cockroachEnum('enum1', ['value1']);
+	const enum2 = cockroachEnum('enum2', ['value1']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column'),
+		}),
+	};
+
+	const renames = [
+		'public.enum1->public.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" RENAME TO "enum2";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #17', async ({ db }) => {
+	const schema = cockroachSchema('schema');
+	const enum1 = cockroachEnum('enum1', ['value1']);
+	const enum2 = schema.enum('enum1', ['value1']);
+
+	const from = {
+		schema,
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const to = {
+		schema,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column'),
+		}),
+	};
+
+	const renames = [
+		'public.enum1->schema.enum1',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" SET SCHEMA "schema";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #18', async ({ db }) => {
+	const schema1 = cockroachSchema('schema1');
+	const schema2 = cockroachSchema('schema2');
+
+	const enum1 = schema1.enum('enum1', ['value1']);
+	const enum2 = schema2.enum('enum2', ['value1']);
+
+	const from = {
+		schema1,
+		schema2,
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const to = {
+		schema1,
+		schema2,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column'),
+		}),
+	};
+
+	const renames = [
+		'schema1.enum1->schema2.enum2',
+	];
+	// change name and schema of the enum, no table changes
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "schema1"."enum1" SET SCHEMA "schema2";`,
+		`ALTER TYPE "schema2"."enum1" RENAME TO "enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #19', async ({ db }) => {
+	const myEnum = cockroachEnum('my_enum', ["escape's quotes"]);
+
+	const from = {};
+
+	const to = { myEnum };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = ["CREATE TYPE \"my_enum\" AS ENUM('escape''s quotes');"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #20', async ({ db }) => {
+	const myEnum = cockroachEnum('my_enum', ['one', 'two', 'three']);
+
+	const from = {
+		myEnum,
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const to = {
+		myEnum,
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+			col1: myEnum('col1'),
+			col2: int4('col2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum";',
+		'ALTER TABLE "table" ADD COLUMN "col2" int4;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #21', async ({ db }) => {
+	const myEnum = cockroachEnum('my_enum', ['one', 'two', 'three']);
+
+	const from = {
+		myEnum,
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const to = {
+		myEnum,
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+			col1: myEnum('col1').array(),
+			col2: int4('col2').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum"[];',
+		'ALTER TABLE "table" ADD COLUMN "col2" int4[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #22', async ({ db }) => {
+	const schema = cockroachSchema('schema');
+	const en = schema.enum('e', ['a', 'b']);
+
+	const from = {
+		schema,
+		en,
+	};
+
+	const to = {
+		schema,
+		en,
+		table: cockroachTable('table', {
+			en: en(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['CREATE TABLE "table" (\n\t"en" "schema"."e"\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums #23', async ({ db }) => {
+	const schema = cockroachSchema('schema');
+	const en = schema.enum('e', ['a', 'b']);
+
+	const from = {
+		schema,
+		en,
+	};
+
+	const to = {
+		schema,
+		en,
+		table: cockroachTable('table', {
+			en1: en().array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE TABLE "table" (\n\t"en1" "schema"."e"[]\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop enum value', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop enum values', async ({ db }) => {
+	const newSchema = cockroachSchema('mySchema');
+	const enum3 = cockroachEnum('enum_users_customer_and_ship_to_settings_roles', [
+		'addedToTop',
+		'custAll',
+		'custAdmin',
+		'custClerk',
+		'custInvoiceManager',
+		'addedToMiddle',
+		'custMgf',
+		'custApprover',
+		'custOrderWriter',
+		'custBuyer',
+	]);
+	const schema1 = {
+		enum3,
+		table: cockroachTable('enum_table', {
+			id: enum3(),
+		}),
+		newSchema,
+		table1: newSchema.table('enum_table', {
+			id: enum3(),
+		}),
+	};
+
+	const enum4 = cockroachEnum('enum_users_customer_and_ship_to_settings_roles', [
+		'addedToTop',
+		'custAll',
+		'custAdmin',
+		'custClerk',
+		'custInvoiceManager',
+		'custApprover',
+		'custOrderWriter',
+		'custBuyer',
+	]);
+	const schema2 = {
+		enum4,
+		table: cockroachTable('enum_table', {
+			id: enum4(),
+		}),
+		newSchema,
+		table1: newSchema.table('enum_table', {
+			id: enum4(),
+		}),
+	};
+
+	const schemas = ['public', 'mySchema'];
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas });
+
+	const st0 = [
+		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
+		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
+		`DROP TYPE "enum_users_customer_and_ship_to_settings_roles";`,
+		`CREATE TYPE "enum_users_customer_and_ship_to_settings_roles" AS ENUM('addedToTop', 'custAll', 'custAdmin', 'custClerk', 'custInvoiceManager', 'custApprover', 'custOrderWriter', 'custBuyer');`,
+		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE "enum_users_customer_and_ship_to_settings_roles" USING "id"::"enum_users_customer_and_ship_to_settings_roles";`,
+		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE "enum_users_customer_and_ship_to_settings_roles" USING "id"::"enum_users_customer_and_ship_to_settings_roles";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		users: cockroachTable('users', {
+			col: enum1().default('value1'),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			col: text().default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "col" DROP DEFAULT;',
+		'ALTER TABLE "users" ALTER COLUMN "col" SET DATA TYPE string;',
+		'ALTER TABLE "users" ALTER COLUMN "col" SET DEFAULT \'value1\';',
+		`DROP TYPE "enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop enum value. enum is columns data type', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		schema,
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3']);
+	const to = {
+		schema,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop enum value. column of enum type; drop default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column1: enum1().default('value2'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column1: enum2(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column1" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column1" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		'ALTER TABLE "table" ALTER COLUMN "column1" SET DATA TYPE "enum" USING "column1"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4295
+test.concurrent('drop enum value. column of enum type with default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column1: enum1().default('value1'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column1: enum2().default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column1" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column1" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		'ALTER TABLE "table" ALTER COLUMN "column1" SET DATA TYPE "enum" USING "column1"::"enum";',
+		`ALTER TABLE \"table\" ALTER COLUMN \"column1\" SET DEFAULT 'value1'::\"enum\";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('shuffle enum values', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		schema,
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is enum type with default value. shuffle enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value2'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		'ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";',
+		'ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT \'value2\'::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums as ts enum', async ({ db }) => {
+	enum Test {
+		value = 'value',
+	}
+
+	const to = {
+		enum: cockroachEnum('enum', Test),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is enum type with default value. shuffle enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value2'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value2'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum type with default value. shuffle enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').array().default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum with custom size type with default value. shuffle enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value2}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum with custom size type. shuffle enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(3),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').array(3),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is enum type with default value. custom schema. shuffle enum', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		schema,
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value2'),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "new_schema"."enum" USING "test_column"::"new_schema"."enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value2'::"new_schema"."enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum type with default value. custom schema. shuffle enum', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('test_column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('test_column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE "new_schema"."enum"[] USING "test_column"::"new_schema"."enum"[];`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DEFAULT '{value2}'::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum type with custom size with default value. custom schema. shuffle enum', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		'ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE "new_schema"."enum"[] USING "test_column"::"new_schema"."enum"[];`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DEFAULT '{value2}'::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is array enum type with custom size. custom schema. shuffle enum', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('test_column').array(3),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('test_column').array(3),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE text;`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "test_column" SET DATA TYPE "new_schema"."enum"[] USING "test_column"::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('column is enum type without default value. add default to column', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value3'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to enum', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to enum. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').default('value2'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum" USING "test_column"::"enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value3'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array standart type to array enum. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array().default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array standart type to array enum. column without default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array standart type with custom size to array enum with custom size. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(3).default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array standart type with custom size to array enum with custom size. column without default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(2),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(2),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum"[] USING "test_column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from enum type to standart type', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array enum type to standart type', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from enum type to standart type. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array enum type to array standart type', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array enum with custom size type to array standart type with custom size', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(2),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(2),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+//
+test.concurrent('change data type from array enum type to array standart type. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value2}'::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from array enum type with custom size to array standart type with custom size. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value2']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(3).default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE varchar[];`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{value2}'::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to standart type', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			column: varchar('test_column'),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			column: text('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to standart type. column has default', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			column: varchar('test_column').default('value3'),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			column: text('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// TODO if leave "column" as name - strange error occurres. Could be bug in cockroachdb
+test.concurrent('change data type from standart type to standart type. columns are arrays', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			test_column: varchar('test_column').array(),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			test_column: text('test_column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to standart type. columns are arrays with custom sizes', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			test_column: varchar('test_column').array(2),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			test_column: text('test_column').array(2),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to standart type. columns are arrays. column has default', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			test_column: varchar('test_column').array().default(['hello']),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			test_column: text('test_column').array().default(['hello']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string[];`,
+		// TODO: discuss with @AndriiSherman, redundand statement
+		// `ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT '{"hello"}';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to standart type. columns are arrays with custom sizes.column has default', async ({ db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			column: varchar('test_column').array(2).default(['hello']),
+		}),
+	};
+
+	const to = {
+		table: cockroachTable('table', {
+			column: text('test_column').array(2).default(['hello']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE string[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from one enum to other', async ({ db }) => {
+	const enum1 = cockroachEnum('enum1', ['value1', 'value3']);
+	const enum2 = cockroachEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum1('test_column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum2" USING "test_column"::text::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from one enum to other. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum1', ['value1', 'value3']);
+	const enum2 = cockroachEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum2" USING "test_column"::text::"enum2";`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value3'::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from one enum to other. changed defaults', async ({ db }) => {
+	const enum1 = cockroachEnum('enum1', ['value1', 'value3']);
+	const enum2 = cockroachEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum1('test_column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum2" USING "test_column"::text::"enum2";`,
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value1'::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('check filtering json statements. here we have recreate enum + set new type + alter default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum1', ['value1', 'value3']);
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('test_column').default('value3'),
+		}),
+	};
+
+	const enum2 = cockroachEnum('enum1', ['value3', 'value1', 'value2']);
+	const to = {
+		enum2,
+		table: cockroachTable('table', {
+			column: enum2('test_column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'DROP TYPE "enum1";',
+		`CREATE TYPE "enum1" AS ENUM('value3', 'value1', 'value2');`,
+		'ALTER TABLE "table" ALTER COLUMN "test_column" DROP DEFAULT;',
+		'ALTER TABLE "table" ALTER COLUMN "test_column" SET DATA TYPE "enum1" USING "test_column"::"enum1";',
+		`ALTER TABLE "table" ALTER COLUMN "test_column" SET DEFAULT 'value2'::"enum1";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add column with same name as enum', async ({ db }) => {
+	const statusEnum = cockroachEnum('status', ['inactive', 'active', 'banned']);
+
+	const schema1 = {
+		statusEnum,
+		table1: cockroachTable('table1', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		statusEnum,
+		table1: cockroachTable('table1', {
+			id: int4('id').primaryKey(),
+			status: statusEnum('status').default('inactive'),
+		}),
+		table2: cockroachTable('table2', {
+			id: int4('id').primaryKey(),
+			status: statusEnum('status').default('inactive'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE TABLE "table2" (\n\t"id" int4 PRIMARY KEY,\n\t"status" "status" DEFAULT \'inactive\'::"status"\n);\n',
+		'ALTER TABLE "table1" ADD COLUMN "status" "status" DEFAULT \'inactive\'::"status";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('enums ordering', async ({ db }) => {
+	const schema1 = {
+		enum: cockroachEnum('settings', ['all', 'admin']),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema3 = {
+		enum: cockroachEnum('settings', ['new', 'all', 'admin']),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema3, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema3 });
+
+	expect(st2).toStrictEqual(["ALTER TYPE \"settings\" ADD VALUE 'new' BEFORE 'all';"]);
+	expect(pst2).toStrictEqual(["ALTER TYPE \"settings\" ADD VALUE 'new' BEFORE 'all';"]);
+
+	const schema4 = {
+		enum3: cockroachEnum('settings', ['new', 'all', 'new2', 'admin']),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, schema4, []);
+	const { sqlStatements: pst3 } = await push({ db, to: schema4 });
+
+	const st0 = [
+		`ALTER TYPE "settings" ADD VALUE 'new2' BEFORE 'admin';`,
+	];
+
+	expect(st3).toStrictEqual(st0);
+	expect(pst3).toStrictEqual(st0);
+
+	const { sqlStatements: st4 } = await diff(n3, schema4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: schema4 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+});
+
+test.concurrent('change data type from standart type to enum. column has default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('column').default('value2'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to enum. set default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('column').default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+		`ALTER TABLE \"table\" ALTER COLUMN \"column\" SET DEFAULT 'value1'::"enum";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to enum. altered column has no default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('column').default('value2'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change data type from standart type to enum. column has no default', async ({ db }) => {
+	const enum1 = cockroachEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: cockroachTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: cockroachTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/generated.test.ts b/drizzle-kit/tests/cockroach/generated.test.ts
new file mode 100644
index 0000000000..cd050519a9
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/generated.test.ts
@@ -0,0 +1,465 @@
+import { SQL, sql } from 'drizzle-orm';
+import { cockroachTable, int4, text } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('generated as callback: add column with generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as callback: add generated constraint to an exisiting column', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as callback: drop generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" DROP COLUMN \"gen_name\";`,
+		`ALTER TABLE \"users\" ADD COLUMN \"gen_name\" string;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as callback: change generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+test.concurrent('generated as sql: add column with generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as sql: add generated constraint to an exisiting column', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\"users\".\"name\" || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as sql: drop generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" DROP COLUMN \"gen_name\";`,
+		`ALTER TABLE \"users\" ADD COLUMN \"gen_name\" string;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as sql: change generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\"`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+test.concurrent('generated as string: add column with generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as string: add generated constraint to an exisiting column', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\"users\".\"name\" || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as string: drop generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" DROP COLUMN \"gen_name\";`,
+		`ALTER TABLE \"users\" ADD COLUMN \"gen_name\" string;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('generated as string: change generated constraint', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+test.concurrent('alter generated constraint', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
+		}),
+	};
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" string GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignores definition changes
+});
diff --git a/drizzle-kit/tests/cockroach/grammar.test.ts b/drizzle-kit/tests/cockroach/grammar.test.ts
new file mode 100644
index 0000000000..1ac6d974e3
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/grammar.test.ts
@@ -0,0 +1,76 @@
+import { splitSqlType, trimDefaultValueSuffix } from 'src/dialects/cockroach/grammar';
+import { expect, test } from 'vitest';
+
+test.each([
+	["'a'::my_enum", "'a'"],
+	["'abc'::text", "'abc'"],
+	["'abc'::character varying", "'abc'"],
+	["'abc'::bpchar", "'abc'"],
+	[`'{"attr":"value"}'::json`, `'{"attr":"value"}'`],
+	[`'{"attr": "value"}'::jsonb`, `'{"attr": "value"}'`],
+	[`'00:00:00'::time without time zone`, `'00:00:00'`],
+	[`'2025-04-24 08:30:45.08+00'::timestamp with time zone`, `'2025-04-24 08:30:45.08+00'`],
+	[`'2024-01-01'::date`, `'2024-01-01'`],
+	[`'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::uuid`, `'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'`],
+	[`now()`, `now()`],
+	[`CURRENT_TIMESTAMP`, `CURRENT_TIMESTAMP`],
+	[`timezone('utc'::text, now())`, `timezone('utc'::text, now())`],
+	[`'{a,b}'::my_enum[]`, `'{a,b}'`],
+	[`'{10,20}'::smallint[]`, `'{10,20}'`],
+	[`'{10,20}'::integer[]`, `'{10,20}'`],
+	[`'{99.9,88.8}'::some::string[]`, `'{99.9,88.8}'`],
+	[`'{99.9,88.8}'::some::string(3)[]`, `'{99.9,88.8}'`],
+	[`'{99.9,88.8}'::numeric[]`, `'{99.9,88.8}'`],
+	[`'{100,200}'::bigint[]`, `'{100,200}'`],
+	[`'{t,f}'::boolean[]`, `'{t,f}'`],
+	[`'{abc,def}'::text[]`, `'{abc,def}'`],
+	[`'{abc,def}'::character varying[]`, `'{abc,def}'`],
+	[`'{abc,def}'::bpchar[]`, `'{abc,def}'`],
+	[`'{100,200}'::double precision[]`, `'{100,200}'`],
+	[`'{100,200}'::real[]`, `'{100,200}'`],
+	[
+		`'{"{\"attr\":\"value1\"}","{\"attr\":\"value2\"}"}'::json[]`,
+		`'{"{\"attr\":\"value1\"}","{\"attr\":\"value2\"}"}'`,
+	],
+	[
+		`'{"{\"attr\": \"value1\"}","{\"attr\": \"value2\"}"}'::jsonb[]`,
+		`'{"{\"attr\": \"value1\"}","{\"attr\": \"value2\"}"}'`,
+	],
+	[`'{00:00:00,01:00:00}'::time without time zone[]`, `'{00:00:00,01:00:00}'`],
+	[
+		`'{"2025-04-24 10:41:36.623+00","2025-04-24 10:41:36.623+00"}'::timestamp with time zone[]`,
+		`'{"2025-04-24 10:41:36.623+00","2025-04-24 10:41:36.623+00"}'`,
+	],
+	[`'{2024-01-01,2024-01-02}'::date[]`, `'{2024-01-01,2024-01-02}'`],
+	[
+		`'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12}'::uuid[]`,
+		`'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12}'`,
+	],
+	[`'{127.0.0.1,127.0.0.2}'::inet[]`, `'{127.0.0.1,127.0.0.2}'`],
+	[`'{127.0.0.1/32,127.0.0.2/32}'::cidr[]`, `'{127.0.0.1/32,127.0.0.2/32}'`],
+	[`'{00:00:00:00:00:00,00:00:00:00:00:01}'::macaddr[]`, `'{00:00:00:00:00:00,00:00:00:00:00:01}'`],
+	[
+		`'{00:00:00:ff:fe:00:00:00,00:00:00:ff:fe:00:00:01}'::macaddr8[]`,
+		`'{00:00:00:ff:fe:00:00:00,00:00:00:ff:fe:00:00:01}'`,
+	],
+	[`'{"1 day 01:00:00","1 day 02:00:00"}'::interval[]`, `'{"1 day 01:00:00","1 day 02:00:00"}'`],
+])('trim default suffix %#: %s', (it, expected) => {
+	expect(trimDefaultValueSuffix(it)).toBe(expected);
+});
+
+test('split sql type', () => {
+	expect.soft(splitSqlType('numeric')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)')).toStrictEqual({ type: 'numeric', options: '10,2' });
+
+	expect.soft(splitSqlType('numeric[]')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)[]')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)[]')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)[]')).toStrictEqual({ type: 'numeric', options: '10,2' });
+
+	expect.soft(splitSqlType('numeric[][]')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)[][]')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)[][]')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)[][]')).toStrictEqual({ type: 'numeric', options: '10,2' });
+});
diff --git a/drizzle-kit/tests/cockroach/identity.test.ts b/drizzle-kit/tests/cockroach/identity.test.ts
new file mode 100644
index 0000000000..b282b95705
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/identity.test.ts
@@ -0,0 +1,527 @@
+import { bigint, cockroachTable, int2, int4, int8, text } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('create table: identity always/by default - no params', async ({ db }) => {
+	const from = {};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity(),
+			id1: int8('id1', { mode: 'number' }).generatedByDefaultAsIdentity(),
+			id2: int2('id2').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const { sqlStatements: st, next } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" int8 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 1 CACHE 1),\n\t"id2" int2 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table: identity always/by default - few params', async ({ db }) => {
+	const from = {};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+			}),
+			id1: int8('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
+				startWith: 120,
+				maxValue: 17000,
+			}),
+			id2: int2('id2').generatedByDefaultAsIdentity({ cache: 1 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" int8 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 1),\n\t"id2" int2 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table: identity always/by default - all params', async ({ db }) => {
+	// TODO revise: added id1, id2 columns to users table, like in same test from push.test.ts
+	const from = {};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+			}),
+			id1: int8('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
+				startWith: 120,
+				maxValue: 17000,
+				increment: 3,
+				cache: 100,
+			}),
+			id2: int2('id2').generatedByDefaultAsIdentity({ minValue: 1 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 4 MINVALUE 3 MAXVALUE 1000 START WITH 3 CACHE 200),\n\t"id1" int8 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 3 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 100),\n\t"id2" int2 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('no diff: identity always/by default - no params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity(),
+			id2: int4('id2').generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity(),
+			id2: int4('id2').generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('no diff: identity always/by default - few params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				increment: 1,
+				startWith: 3,
+			}),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				increment: 1,
+				startWith: 3,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('no diff: identity always/by default - all params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop identity from a column - no params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop identity from a column - few params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				increment: 3,
+			}),
+			id1: int4('id1').generatedByDefaultAsIdentity({
+				increment: 4,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				increment: 4,
+			}),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id1: int4('id1'),
+			id2: int4('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP IDENTITY;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP IDENTITY;',
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop identity from a column - all params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				increment: 3,
+				cache: 100,
+			}),
+			id1: int4('id1').generatedByDefaultAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cache: 10,
+				increment: 2,
+			}),
+			id2: int4('id2').generatedAlwaysAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id1: int4('id1'),
+			id2: int4('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		`ALTER TABLE \"users\" ALTER COLUMN \"id1\" DROP IDENTITY;`,
+		`ALTER TABLE \"users\" ALTER COLUMN \"id2\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter identity from a column - no params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedByDefaultAsIdentity({ startWith: 100 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter identity from a column - few params', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedByDefaultAsIdentity({ startWith: 100 }),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedByDefaultAsIdentity({
+				startWith: 100,
+				cache: 10,
+				increment: 4,
+				maxValue: 10000,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET MAXVALUE 10000;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET INCREMENT BY 4;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter identity from a column - by default to always', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: bigint('id', { mode: 'number' }).generatedAlwaysAsIdentity({
+				startWith: 100,
+				cache: 10,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED ALWAYS;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter identity from a column - always to by default', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedAlwaysAsIdentity({ maxValue: 10000 }),
+		}),
+	};
+
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				maxValue: 10000,
+				startWith: 100,
+				cache: 10,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add column with identity - few params', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			email: text('email'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			email: text('email'),
+			id: int4('id').generatedByDefaultAsIdentity({}),
+			id1: int4('id1').generatedAlwaysAsIdentity({
+				increment: 4,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ADD COLUMN "id" int4 GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+		'ALTER TABLE "users" ADD COLUMN "id1" int4 GENERATED ALWAYS AS IDENTITY (INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add identity to column - few params', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').notNull(),
+			id1: int4('id1').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({}),
+			id1: int4('id1').generatedAlwaysAsIdentity({
+				increment: 4,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ALTER COLUMN "id" ADD GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+		'ALTER TABLE "users" ALTER COLUMN "id1" ADD GENERATED ALWAYS AS IDENTITY (INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/indexes-without-tx.test.ts b/drizzle-kit/tests/cockroach/indexes-without-tx.test.ts
new file mode 100644
index 0000000000..ae6c822b06
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/indexes-without-tx.test.ts
@@ -0,0 +1,33 @@
+import { cockroachTable, index, int4, vector } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test('vector index', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: vector('name', { dimensions: 3 }),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			embedding: vector('name', { dimensions: 3 }),
+		}, (t) => [
+			index('vector_embedding_idx')
+				.using('cspann', t.embedding),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "vector_embedding_idx" ON "users" USING cspann ("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/indexes.test.ts b/drizzle-kit/tests/cockroach/indexes.test.ts
new file mode 100644
index 0000000000..537156a5d4
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/indexes.test.ts
@@ -0,0 +1,467 @@
+import { isNotNull, sql } from 'drizzle-orm';
+import {
+	boolean,
+	cockroachSchema,
+	cockroachTable,
+	index,
+	IndexBuilder,
+	int4,
+	text,
+	uniqueIndex,
+	uuid,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('adding basic indexes', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				name: text('name'),
+			},
+			(t) => [
+				index()
+					.on(t.name, t.id.desc())
+					.where(sql`name != 'alef'`),
+				index('indx1').using('hash', t.name),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "users_name_id_index" ON "users" ("name","id" DESC) WHERE name != 'alef';`,
+		`CREATE INDEX "indx1" ON "users" ("name") USING hash;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('dropping basic index', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				name: text('name'),
+			},
+			(t) => [index().on(t.name.desc(), t.id.asc())],
+		),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [`DROP INDEX "users_name_id_index";`];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('altering indexes', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('removeColumn').on(t.name, t.id),
+			index('addColumn').on(t.name.desc()),
+			index('removeExpression').on(t.name.desc(), sql`id`),
+			index('addExpression').on(t.id.desc()),
+			index('changeExpression').on(t.id.desc(), sql`name`),
+			index('changeName').on(t.name.desc(), t.id.asc()),
+			index('changeUsing').on(t.name),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('removeColumn').on(t.name),
+			index('addColumn').on(t.name.desc(), t.id.asc()),
+			index('removeExpression').on(t.name.desc()),
+			index('addExpression').on(t.id.desc()),
+			index('changeExpression').on(t.id.desc(), sql`name desc`),
+			index('newName').on(t.name.desc(), sql`id`),
+			index('changeUsing').using('hash', t.name),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC,"id");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX "removeExpression" ON "users" ("name" DESC);',
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC,name desc);',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" ("name") USING hash;',
+		'CREATE INDEX "newName" ON "users" ("name" DESC,id);',
+	]);
+
+	// for push we ignore change of index expressions
+	expect(pst).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC,"id");',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" ("name") USING hash;',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX "removeExpression" ON "users" ("name" DESC);',
+		// 'DROP INDEX "changeExpression";',
+		'CREATE INDEX "newName" ON "users" ("name" DESC,id);',
+		// 'CREATE INDEX "changeExpression" ON "users" ("id" DESC,name desc);',
+	]);
+});
+
+test.concurrent('indexes test case #1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: uuid('id').defaultRandom().primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: boolean('in_stock').default(true),
+			},
+			(t) => [
+				index().on(t.id.desc()),
+				index('indx1').on(t.id, t.imageUrl),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: uuid('id').defaultRandom().primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: boolean('in_stock').default(true),
+			},
+			(t) => [
+				index().on(t.id.desc()),
+				index('indx1').on(t.id, t.imageUrl),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('Indexes properties that should not trigger push changes', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('changeExpression').on(t.id.desc(), sql`name`),
+			index('indx1').on(t.name.desc()),
+			index('indx2').on(t.name.desc()).where(sql`true`),
+			index('indx4').on(sql`lower(name)`).where(sql`true`),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('changeExpression').on(t.id.desc(), sql`name desc`),
+			index('indx1').on(t.name.desc()),
+			index('indx2').on(t.name.desc()).where(sql`false`),
+			index('indx4').on(sql`lower(id)`).where(sql`true`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC,name desc);',
+		'DROP INDEX "indx2";',
+		'CREATE INDEX "indx2" ON "users" ("name" DESC) WHERE false;',
+		'DROP INDEX "indx4";',
+		'CREATE INDEX "indx4" ON "users" (lower(id));',
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX "indx2";',
+		'CREATE INDEX "indx2" ON "users" ("name" DESC) WHERE false;',
+	]);
+});
+
+test.concurrent('indexes #0', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				name: text('name'),
+			},
+			(
+				t,
+			) => [
+				index('removeColumn').on(t.name, t.id),
+				index('addColumn').on(t.name.desc()),
+				index('removeExpression').on(t.name.desc(), sql`id`),
+				index('addExpression').on(t.id.desc()),
+				index('changeExpression').on(t.id.desc(), sql`name`),
+				index('changeName').on(t.name.desc(), t.id.asc()),
+				index('changeUsing').on(t.name),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+				name: text('name'),
+			},
+			(t) => [
+				index('removeColumn').on(t.name),
+				index('addColumn').on(t.name.desc(), t.id),
+				index('removeExpression').on(t.name.desc()),
+				index('addExpression').on(t.id.desc()),
+				index('changeExpression').on(t.id.desc(), sql`name desc`),
+				index('newName').on(t.name.desc(), sql`id`),
+				index('changeUsing').using('hash', t.name),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC,"id");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX "removeExpression" ON "users" ("name" DESC);',
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC,name desc);',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" ("name") USING hash;',
+		'CREATE INDEX "newName" ON "users" ("name" DESC,id);',
+	]);
+
+	// for push we ignore change of index expressions
+	expect(pst).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC,"id");',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" ("name") USING hash;',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX "removeExpression" ON "users" ("name" DESC);',
+		// 'DROP INDEX "changeExpression";',
+		'CREATE INDEX "newName" ON "users" ("name" DESC,id);',
+		// 'CREATE INDEX "changeExpression" ON "users" ("id" DESC,name desc);',
+	]);
+});
+
+test.concurrent('index #2', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('indx').on(t.name.desc()),
+			index('indx1').on(t.name.desc()),
+			index('indx3').on(sql`lower(name)`),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('indx').on(t.name.desc()),
+			index('indx1').on(t.name.desc()).where(sql`false`),
+			index('indx3').on(sql`lower(${t.name})`),
+			index('indx4').on(sql`lower(name)`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "indx1";',
+		'CREATE INDEX "indx1" ON "users" ("name" DESC) WHERE false;',
+		'DROP INDEX "indx3";',
+		'CREATE INDEX "indx3" ON "users" (lower("name"));',
+		'CREATE INDEX "indx4" ON "users" (lower(name));',
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX "indx1";',
+		// TODO: we ignore columns changes during 'push', we should probably tell user about it in CLI?
+		// 'DROP INDEX "indx3";',
+		'CREATE INDEX "indx1" ON "users" ("name" DESC) WHERE false;',
+		'CREATE INDEX "indx4" ON "users" (lower(name));',
+		// 'CREATE INDEX "indx3" ON "users" (lower("name"));',
+	]);
+});
+
+/**
+There are two similar tests shown here
+When creating an index with the sql`name != 'alex'`, Cockroach automatically adds 'alex'::STRING
+Since this behavior comes directly from the sql`` we can't handle it
+
+The second test passes because it explicitly add ::STRING
+We should provide some kind of hint or suggestion to inform the user about this
+ */
+test.concurrent('index #3', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index().on(t.name.desc(), t.id.asc()).where(sql`name != 'alex'`),
+			index('indx1').using('hash', sql`${t.name}`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, ignoreSubsequent: true });
+
+	const st0 = [
+		`CREATE INDEX "users_name_id_index" ON "users" ("name" DESC,"id") WHERE name != 'alex';`,
+		`CREATE INDEX "indx1" ON "users" ("name") USING hash;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test.concurrent('index #3_1', async ({ dbc: db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index().on(t.name.desc(), t.id.asc()).where(sql`name != 'alex'::STRING`),
+			index('indx1').using('hash', sql`${t.name}`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "users_name_id_index" ON "users" ("name" DESC,"id") WHERE name != 'alex'::STRING;`,
+		`CREATE INDEX "indx1" ON "users" ("name") USING hash;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5593
+test('indexes #5', async ({ dbc: db }) => {
+	const schema = cockroachSchema('my_schema');
+	const table1 = schema.table('table1', {
+		col1: int4(),
+		col2: int4(),
+	}, (t) => [
+		uniqueIndex('index1').on(t.col1).where(isNotNull(t.col1)),
+		index('index2').on(t.col1).where(isNotNull(t.col1)),
+	]);
+
+	const schema1 = { schema, table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE SCHEMA "my_schema";\n',
+		'CREATE TABLE "my_schema"."table1" (\n'
+		+ '\t"col1" int4,\n'
+		+ '\t"col2" int4\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX "index1" ON "my_schema"."table1" ("col1") WHERE ("my_schema"."table1"."col1" is not null);',
+		'CREATE INDEX "index2" ON "my_schema"."table1" ("col1") WHERE ("my_schema"."table1"."col1" is not null);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
diff --git a/drizzle-kit/tests/cockroach/mocks.ts b/drizzle-kit/tests/cockroach/mocks.ts
new file mode 100644
index 0000000000..7f9111d480
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/mocks.ts
@@ -0,0 +1,664 @@
+import { is } from 'drizzle-orm';
+import {
+	AnyCockroachColumn,
+	CockroachColumnBuilder,
+	CockroachDialect,
+	CockroachEnum,
+	CockroachEnumObject,
+	CockroachMaterializedView,
+	CockroachPolicy,
+	CockroachRole,
+	CockroachSchema,
+	CockroachSequence,
+	CockroachTable,
+	cockroachTable,
+	CockroachView,
+	int4,
+	isCockroachEnum,
+	isCockroachMaterializedView,
+	isCockroachSequence,
+	isCockroachView,
+} from 'drizzle-orm/cockroach-core';
+import { configMigrations } from 'src/cli/validations/common';
+import { CockroachDDL, Column, createDDL, interimToDDL, SchemaError } from 'src/dialects/cockroach/ddl';
+import { ddlDiff, ddlDiffDry } from 'src/dialects/cockroach/diff';
+import {
+	defaultFromColumn,
+	fromDrizzleSchema,
+	prepareFromSchemaFiles,
+	unwrapColumn,
+} from 'src/dialects/cockroach/drizzle';
+import { mockResolver } from 'src/utils/mocks';
+import '../../src/@types/utils';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { Pool, PoolClient } from 'pg';
+import { introspect } from 'src/cli/commands/pull-cockroach';
+import { suggestions } from 'src/cli/commands/push-cockroach';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { EmptyProgressView, explain } from 'src/cli/views';
+import { defaultToSQL, isSystemRole } from 'src/dialects/cockroach/grammar';
+import { fromDatabaseForDrizzle } from 'src/dialects/cockroach/introspect';
+import { ddlToTypeScript } from 'src/dialects/cockroach/typescript';
+import { DB } from 'src/utils';
+import 'zx/globals';
+import { randomUUID } from 'crypto';
+import { EntitiesFilter, EntitiesFilterConfig } from 'src/cli/validations/common';
+import { hash } from 'src/dialects/common';
+import { extractCrdbExisting } from 'src/dialects/drizzle';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { measure, tsc } from 'tests/utils';
+import { expect, test as base } from 'vitest';
+
+mkdirSync('tests/cockroach/tmp', { recursive: true });
+
+export type CockroachDBSchema = Record<
+	string,
+	| CockroachTable<any>
+	| CockroachEnum<any>
+	| CockroachEnumObject<any>
+	| CockroachSchema
+	| CockroachSequence
+	| CockroachView
+	| CockroachMaterializedView
+	| CockroachRole
+	| CockroachPolicy
+>;
+
+class MockError extends Error {
+	constructor(readonly errors: SchemaError[]) {
+		super();
+	}
+}
+
+export const drizzleToDDL = (
+	schema: CockroachDBSchema,
+	filterConfig: EntitiesFilterConfig = {
+		schemas: undefined,
+		tables: undefined,
+		entities: undefined,
+		extensions: undefined,
+	},
+) => {
+	const tables = Object.values(schema).filter((it) => is(it, CockroachTable)) as CockroachTable[];
+	const schemas = Object.values(schema).filter((it) => is(it, CockroachSchema)) as CockroachSchema[];
+	const enums = Object.values(schema).filter((it) => isCockroachEnum(it)) as CockroachEnum<any>[];
+	const sequences = Object.values(schema).filter((it) => isCockroachSequence(it)) as CockroachSequence[];
+	const roles = Object.values(schema).filter((it) => is(it, CockroachRole)) as CockroachRole[];
+	const policies = Object.values(schema).filter((it) => is(it, CockroachPolicy)) as CockroachPolicy[];
+	const views = Object.values(schema).filter((it) => isCockroachView(it)) as CockroachView[];
+	const materializedViews = Object.values(schema).filter((it) =>
+		isCockroachMaterializedView(it)
+	) as CockroachMaterializedView[];
+
+	const existing = extractCrdbExisting(schemas, views, materializedViews);
+	const filter = prepareEntityFilter('cockroach', filterConfig, existing);
+	const { schema: res, errors, warnings } = fromDrizzleSchema(
+		{
+			schemas,
+			tables,
+			enums,
+			sequences,
+			roles,
+			policies,
+			views,
+			matViews: materializedViews,
+		},
+		filter,
+	);
+
+	if (errors.length > 0) {
+		throw new Error();
+	}
+
+	return { ...interimToDDL(res), existing };
+};
+
+// 2 schemas -> 2 ddls -> diff
+export const diff = async (
+	left: CockroachDBSchema | CockroachDDL,
+	right: CockroachDBSchema | CockroachDDL,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as CockroachDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = 'entities' in right && '_' in right
+		? { ddl: right as CockroachDDL, errors: [] }
+		: drizzleToDDL(right);
+
+	if (err1.length > 0 || err2.length > 0) {
+		throw new MockError([...err1, ...err2]);
+	}
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+	return { sqlStatements, statements, groupedStatements, next: ddl2 };
+};
+
+export const pushM = async (config: {
+	db: DB;
+	to: CockroachDBSchema | CockroachDDL;
+	renames?: string[];
+	schemas?: string[];
+	log?: 'statements' | 'none';
+	entities?: EntitiesFilter;
+}) => {
+	return measure(push(config), 'push');
+};
+// init schema flush to db -> introspect db to ddl -> compare ddl with destination schema
+export const push = async (
+	config: {
+		db: DB;
+		to: CockroachDBSchema | CockroachDDL;
+		renames?: string[];
+		schemas?: string[];
+		log?: 'statements' | 'none';
+		entities?: EntitiesFilter;
+		ignoreSubsequent?: boolean;
+		explain?: true;
+		migrationsConfig?: {
+			schema?: string;
+			table?: string;
+		};
+	},
+) => {
+	const { db, to } = config;
+	const log = config.log ?? 'none';
+
+	const filterConfig: EntitiesFilterConfig = {
+		schemas: config.schemas,
+		tables: undefined,
+		entities: config.entities,
+		extensions: [],
+	};
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+
+	const { ddl: ddl2, errors: err3, existing } = 'entities' in to && '_' in to
+		? { ddl: to as CockroachDDL, errors: [], existing: [] }
+		: drizzleToDDL(to, filterConfig);
+
+	const filter = prepareEntityFilter('cockroach', filterConfig, existing);
+
+	const { schema } = await introspect(
+		db,
+		filter,
+		new EmptyProgressView(),
+		() => {},
+		migrations,
+	);
+
+	const { ddl: ddl1, errors: err2 } = interimToDDL(schema);
+
+	if (err2.length > 0) {
+		throw new MockError(err2);
+	}
+
+	if (err3.length > 0) {
+		throw new MockError(err3);
+	}
+
+	// TODO: handle errors
+
+	const renames = new Set(config.renames ?? []);
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const hints = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, new HintsHandler()),
+	);
+
+	if (config.explain) {
+		const explainMessage = explain('cockroach', groupedStatements, []);
+		console.log(explainMessage);
+		return { sqlStatements, statements, hints };
+	}
+
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		await db.query(sql);
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		{
+			const { schema } = await introspect(
+				db,
+				filter,
+				new EmptyProgressView(),
+				() => {},
+				migrations,
+			);
+			const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+
+			const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+				ddl1,
+				ddl2,
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				'push',
+			);
+			if (sqlStatements.length > 0) {
+				// const msg = groupedStatements.map((x) => psqlExplain(x.jsonStatement, x.sqlStatements)).join('\n');
+				console.error('---- subsequent push is not empty ----');
+				// console.error(msg);
+				expect(sqlStatements.join('\n')).toBe('');
+			}
+		}
+	}
+
+	return { sqlStatements, statements, hints };
+};
+
+// init schema to db -> pull from db to file -> ddl from files -> compare ddl from db with ddl from file
+export const diffIntrospect = async (
+	db: DB,
+	initSchema: CockroachDBSchema,
+	testName: string,
+	schemas: string[] = [],
+	entities?: EntitiesFilter,
+) => {
+	const filterConfig: EntitiesFilterConfig = {
+		schemas,
+		entities,
+		tables: [],
+		extensions: [],
+	};
+	const { ddl: initDDL, existing } = drizzleToDDL(initSchema, filterConfig);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL, 'default');
+
+	for (const st of init) await db.query(st);
+	const filter = prepareEntityFilter('cockroach', filterConfig, existing);
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, filter, () => {}, { table: 'drizzle_migrations', schema: 'drizzle' });
+
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const filePath = `tests/cockroach/tmp/${testName}.ts`;
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+	writeFileSync(filePath, file.file);
+
+	await tsc(file.file);
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([filePath]);
+
+	const { schema: schema2, errors: e2, warnings } = fromDrizzleSchema(response, filter);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(schema2);
+
+	const { sqlStatements: afterFileSqlStatements, statements: afterFileStatements } = await ddlDiffDry(
+		ddl1,
+		ddl2,
+		'push',
+	);
+
+	rmSync(`tests/cockroach/tmp/${testName}.ts`);
+
+	return {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+		schema2,
+	};
+};
+
+export const diffDefault = async <T extends CockroachColumnBuilder>(
+	db: TestDatabase,
+	builder: T,
+	expectedDefault: string,
+	override?: {
+		expectError?: boolean;
+		ignoreSubsequent?: boolean;
+		pre?: CockroachDBSchema;
+	},
+) => {
+	await db.clear();
+
+	const config = (builder as any).config;
+
+	const expectError = override?.expectError ?? false;
+	const ignoreSubsequent = typeof override?.ignoreSubsequent === 'undefined' ? true : override.ignoreSubsequent;
+	const pre: CockroachDBSchema | null = override?.pre ?? null;
+	const def = config['default'];
+
+	const column = cockroachTable('table', { column: builder }).column;
+	const { dimensions, typeSchema, sqlType: sqlt } = unwrapColumn(column);
+	const type = sqlt.replaceAll('[]', '');
+
+	const columnDefault = defaultFromColumn(column, column.default, dimensions, new CockroachDialect());
+
+	const defaultSql = defaultToSQL({
+		default: columnDefault,
+		type,
+		dimensions,
+		typeSchema: typeSchema,
+	});
+
+	const res = [] as string[];
+	if (defaultSql !== expectedDefault) {
+		res.push(`Unexpected sql: \n${defaultSql}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: cockroachTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	const { sqlStatements: st1 } = await push({ db, to: init, ignoreSubsequent });
+	const { sqlStatements: st2 } = await push({ db, to: init, ignoreSubsequent });
+
+	const typeSchemaPrefix = typeSchema && typeSchema !== 'public' ? `"${typeSchema}".` : '';
+	const typeValue = typeSchema ? `"${type}"` : type;
+	const sqlType = `${typeSchemaPrefix}${typeValue}${'[]'.repeat(dimensions)}`;
+	const expectedInit = `CREATE TABLE "table" (\n\t"column" ${sqlType} DEFAULT ${expectedDefault}\n);\n`;
+
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2}`);
+
+	try {
+		await db.query('INSERT INTO "table" ("column") VALUES (default);');
+	} catch (error) {
+		if (!expectError) throw error;
+		res.push(`Insert default failed`);
+	}
+
+	const filter = () => true;
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, filter, () => {}, { table: 'drizzle_migrations', schema: 'drizzle' });
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+	const path = `tests/cockroach/tmp/temp-${randomUUID()}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+
+	const { schema: sch } = fromDrizzleSchema(response, () => true);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+		res.push(`Default type mismatch after diff:\n${`./${path}`}`);
+	}
+
+	await db.clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: cockroachTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: cockroachTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema1, ignoreSubsequent });
+	const { sqlStatements: st3 } = await push({ db, to: schema2, ignoreSubsequent });
+	const expectedAlter = `ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT ${expectedDefault};`;
+	if (st3.length !== 1 || st3[0] !== expectedAlter) res.push(`Unexpected default alter:\n${st3}\n\n${expectedAlter}`);
+
+	await db.clear();
+
+	const schema3 = {
+		...pre,
+		table: cockroachTable('table', { id: int4() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: cockroachTable('table', { id: int4(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema3, ignoreSubsequent });
+	const { sqlStatements: st4 } = await push({ db, to: schema4, ignoreSubsequent });
+
+	const expectedAddColumn = `ALTER TABLE "table" ADD COLUMN "column" ${sqlType} DEFAULT ${expectedDefault};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export type TestDatabase = DB & {
+	batch: (sql: string[]) => Promise<void>;
+	close: () => void;
+	clear: () => Promise<void>;
+	client: PoolClient;
+};
+
+export type TestDatabaseKit = {
+	acquire: () => Promise<{ db: TestDatabase; release: () => void }>;
+	acquireTx: () => Promise<{ db: TestDatabase; release: () => void }>;
+	close: () => Promise<void>;
+};
+
+const prepareClient = async (url: string, n: string, tx: boolean) => {
+	const name = `${n}${hash(String(Math.random()), 10)}`;
+
+	const client = await new Pool({ connectionString: url, max: 1 }).connect();
+
+	await client.query(`DROP DATABASE IF EXISTS ${name};`);
+	await client.query(`CREATE DATABASE IF NOT EXISTS ${name};`);
+	await client.query(`USE ${name}`);
+
+	await client.query('SET autocommit_before_ddl = OFF;'); // for transactions to work
+	await client.query(`SET CLUSTER SETTING feature.vector_index.enabled = true;`);
+
+	// await client.query(`SET TIME ZONE '+01';`);
+
+	if (tx) {
+		await client.query('BEGIN');
+	}
+
+	const clear = async () => {
+		if (tx) {
+			await client.query('ROLLBACK');
+			await client.query('BEGIN');
+		} else {
+			await client.query(`DROP DATABASE IF EXISTS ${name};`);
+			await client.query(`CREATE DATABASE ${name};`);
+			await client.query(`USE ${name};`);
+			const roles = await client.query<{ rolname: string }>(
+				`SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`,
+			).then((it) => it.rows.filter((it) => !isSystemRole(it.rolname)));
+
+			for (const role of roles) {
+				await client.query(`DROP ROLE "${role.rolname}"`);
+			}
+		}
+	};
+
+	const db: TestDatabase = {
+		query: async (sql, params) => {
+			return client
+				.query(sql, params)
+				.then((it) => it.rows as any[])
+				.catch((e: Error) => {
+					const error = new Error(`query error: ${sql}\n\n${e.message}`);
+					throw error;
+				});
+		},
+		batch: async (sqls) => {
+			for (const sql of sqls) {
+				await client.query(sql);
+			}
+		},
+		clear: clear,
+		close: async () => {
+			client.release();
+		},
+		client,
+	};
+	return db;
+};
+
+export const prepareTestDatabase = async (): Promise<TestDatabaseKit> => {
+	const envUrl = process.env.COCKROACH_CONNECTION_STRING;
+	if (!envUrl) {
+		throw new Error(
+			'COCKROACH_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up cockroach` and export the connection string before running tests.',
+		);
+	}
+
+	let url: string;
+	// Support multiple connection strings separated by ';'
+	const urls = envUrl.split(';').filter(Boolean);
+	if (urls.length > 1) {
+		// Use VITEST_POOL_ID to distribute workers across containers
+		const poolId = parseInt(process.env.VITEST_POOL_ID || '1', 10);
+		url = urls[poolId % urls.length]!;
+	} else {
+		url = urls[0]!;
+	}
+
+	const clients = [
+		await prepareClient(url, 'db0', false),
+		await prepareClient(url, 'db1', false),
+		await prepareClient(url, 'db2', false),
+		await prepareClient(url, 'db3', false),
+		await prepareClient(url, 'db4', false),
+	];
+
+	const clientsTxs = [
+		await prepareClient(url, 'dbc0', true),
+		await prepareClient(url, 'dbc1', true),
+		await prepareClient(url, 'dbc2', true),
+		await prepareClient(url, 'dbc3', true),
+		await prepareClient(url, 'dbc4', true),
+	];
+
+	const closureTxs = async () => {
+		while (true) {
+			const c = clientsTxs.shift();
+			if (!c) {
+				await sleep(50);
+				continue;
+			}
+			return {
+				db: c,
+				release: () => {
+					clientsTxs.push(c);
+				},
+			};
+		}
+	};
+
+	const closure = async () => {
+		while (true) {
+			const c = clients.shift();
+			if (!c) {
+				await sleep(50);
+				continue;
+			}
+			return {
+				db: c,
+				release: () => {
+					clients.push(c);
+				},
+			};
+		}
+	};
+
+	return {
+		acquire: closure,
+		acquireTx: closureTxs,
+		close: async () => {
+			for (const c of clients) {
+				c.close();
+			}
+		},
+	};
+};
+
+export const test = base.extend<{ kit: TestDatabaseKit; db: TestDatabase; dbc: TestDatabase }>({
+	kit: [
+		async ({}, use) => { // oxlint-disable-line no-empty-pattern
+			const kit = await prepareTestDatabase();
+			try {
+				await use(kit);
+			} finally {
+				await kit.close();
+			}
+		},
+		{ scope: 'worker' },
+	],
+	// concurrent no transactions
+	db: [
+		async ({ kit }, use) => {
+			const { db, release } = await kit.acquire();
+			await use(db);
+			await db.clear();
+			release();
+		},
+		{ scope: 'test' },
+	],
+
+	// concurrent with transactions
+	dbc: [
+		async ({ kit }, use) => {
+			const { db, release } = await kit.acquireTx();
+			await use(db);
+			await db.clear();
+			release();
+		},
+		{ scope: 'test' },
+	],
+});
diff --git a/drizzle-kit/tests/cockroach/policy.test.ts b/drizzle-kit/tests/cockroach/policy.test.ts
new file mode 100644
index 0000000000..762ec3f4ac
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/policy.test.ts
@@ -0,0 +1,1526 @@
+import { sql } from 'drizzle-orm';
+import { cockroachPolicy, cockroachRole, cockroachSchema, cockroachTable, int4 } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+const systemRoles = ['admin', 'root'];
+test('full policy: no changes', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + enable rls', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy + disable rls', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy without enable rls', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' }), cockroachPolicy('newRls')]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'CREATE POLICY "newRls" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy without disable rls', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' }), cockroachPolicy('oldRls')]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "oldRls" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/**
+ * Subsequent push is disabled for the first test (currest_user, session_user treated as corner cases)
+ * Subsequent push is enabled for the first test
+ */
+test('alter policy without recreation: changing roles', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', to: 'session_user' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO session_user;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy without recreation: changing roles #2', async ({ db }) => {
+	const role = cockroachRole('owner');
+	const schema1 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', to: role })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { exclude: systemRoles } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { exclude: systemRoles } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy without recreation: changing using', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', using: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy without recreation: changing with check', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+///
+
+test('alter policy with recreation: changing as', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'restrictive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing for', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', for: 'delete' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing both "as" and "for"', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'restrictive', for: 'insert' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR INSERT TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing all fields', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', for: 'select', using: sql`true` })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'restrictive', to: 'current_user', withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO current_user WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing all fields #2', async ({ db }) => {
+	const root = cockroachRole('root');
+	const admin = cockroachRole('admin');
+	const owner = cockroachRole('owner');
+	const schema1 = {
+		root,
+		admin,
+		owner,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', for: 'select', using: sql`true` })]),
+	};
+
+	const schema2 = {
+		root,
+		admin,
+		owner,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'restrictive', to: owner, withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: true } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: true },
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO "owner" WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename policy', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('newName', { as: 'permissive' })]),
+	};
+
+	const renames = [
+		'public.users.test->public.users.newName',
+	];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename policy in renamed table', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [
+			cockroachPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users2', {
+			id: int4('id').primaryKey(),
+		}, (t) => [cockroachPolicy('newName', { as: 'permissive' })]),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.test->public.users2.newName'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER POLICY "test" ON "users2" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with a policy', async ({ db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: cockroachTable('users2', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users2" (\n\t"id" int4 PRIMARY KEY\n);\n',
+		'ALTER TABLE "users2" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users2" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop table with a policy', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users2', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users2";',
+		'DROP TABLE "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with multiple "to" roles', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const role = cockroachRole('manager');
+
+	const schema2 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: ['current_user', role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_user, "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with multiple "to" roles #2', async ({ db }) => {
+	const role2 = cockroachRole('owner');
+	const schema1 = {
+		role2,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const role = cockroachRole('manager');
+
+	const schema2 = {
+		role2,
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: [role2, role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { exclude: systemRoles } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { exclude: systemRoles } },
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO "manager", "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with rls enabled', async ({ db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enable rls force', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('disable rls force', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy with enabled rls', async ({ db }) => {
+	const role = cockroachRole('manager');
+
+	const schema1 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: ['current_user', role] })]).enableRLS(),
+	};
+
+	const schema2 = {
+		role,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, ignoreSubsequent: true });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('drop policy with enabled rls #2', async ({ db }) => {
+	const role = cockroachRole('manager');
+
+	const schema1 = {
+		role,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: [role] })]),
+	};
+
+	const schema2 = {
+		role,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with enabled rls', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const role = cockroachRole('manager');
+
+	const schema2 = {
+		role,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: ['current_user', role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_user, "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with enabled rls #2', async ({ db }) => {
+	const role2 = cockroachRole('owner');
+	const schema1 = {
+		role2,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const role = cockroachRole('manager');
+
+	const schema2 = {
+		role2,
+		role,
+		users: cockroachTable.withRLS('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: [role2, role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['owner'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { exclude: systemRoles } },
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO "manager", "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link table', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('link table', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+		rls: cockroachPolicy('test', { as: 'permissive' }),
+	};
+
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unlink table', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy with link', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy in table and with link table', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	}, () => [
+		cockroachPolicy('test1', { to: 'current_user' }),
+	]);
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test1" ON "users" AS PERMISSIVE FOR ALL TO current_user;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy in table and with link table #2', async ({ db }) => {
+	const role = cockroachRole('owner');
+	const schema1 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	}, () => [
+		cockroachPolicy('test1', { to: role }),
+	]);
+
+	const schema2 = {
+		role,
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['owner'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['owner'] } },
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test1" ON "users" AS PERMISSIVE FOR ALL TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('link non-schema table', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = { users };
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unlink non-schema table', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link non-schema table', async ({ db }) => {
+	const cities = cockroachTable.withRLS('cities', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		cities,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		cities,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test2'),
+		]),
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(cities),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link non-schema table from auth schema', async ({ db }) => {
+	const authSchema = cockroachSchema('auth');
+	const cities = authSchema.table('cities', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		authSchema,
+		cities,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		authSchema,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test2'),
+		]),
+		cities,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(cities),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'ALTER TABLE "auth"."cities" ENABLE ROW LEVEL SECURITY;',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "auth"."cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	]);
+	expect(pst).toStrictEqual([
+		'ALTER TABLE "auth"."cities" ENABLE ROW LEVEL SECURITY;',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "auth"."cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	]);
+});
+
+test('rename policy that is linked', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('newName', { as: 'permissive' }).link(users),
+	};
+
+	const renames = [
+		'public.users.test->public.users.newName',
+	];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy that is linked', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', to: 'current_user' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO current_user;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy that is linked #2', async ({ db }) => {
+	const role = cockroachRole('owner');
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		role,
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		role,
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', to: role }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['owner'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['owner'] } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy that is linked: withCheck', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', withCheck: sql`true` }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', withCheck: sql`false` }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy that is linked: using', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', using: sql`true` }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { as: 'permissive', using: sql`false` }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy that is linked: using', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: cockroachPolicy('test', { for: 'insert' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: cockroachPolicy('test', { for: 'delete' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+////
+
+test('alter policy in the table', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', to: 'current_user' }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO current_user;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy in the table #2', async ({ db }) => {
+	const role = cockroachRole('owner');
+	const schema1 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		role,
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', to: role }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { exclude: systemRoles } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { exclude: systemRoles } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy in the table: withCheck', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', withCheck: sql`true` }),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', withCheck: sql`false` }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy in the table: using', async ({ db }) => {
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', using: sql`true` }),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { as: 'permissive', using: sql`false` }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy in the table: using', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { for: 'insert' }),
+		]),
+	};
+
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, (t) => [
+			cockroachPolicy('test', { for: 'delete' }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/pull-without-tx.test.ts b/drizzle-kit/tests/cockroach/pull-without-tx.test.ts
new file mode 100644
index 0000000000..6973a48c72
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/pull-without-tx.test.ts
@@ -0,0 +1,161 @@
+import { sql } from 'drizzle-orm';
+import { cockroachPolicy, cockroachRole, cockroachTable, int4 } from 'drizzle-orm/cockroach-core';
+import { diffIntrospect, test } from 'tests/cockroach/mocks';
+import { expect } from 'vitest';
+
+test('basic policy', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test')]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-policy',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic policy with "as"', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-policy-as',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic policy with CURRENT_USER role', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { to: 'current_user' })]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-policy-with-current-user-role',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic policy with all fields except "using" and "with"', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { as: 'permissive', for: 'all', to: ['root'] })]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-policy-all-fields',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic policy with "using" and "with"', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { using: sql`true`, withCheck: sql`true` })]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-policy-using-withcheck',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('multiple policies', async ({ db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}, () => [cockroachPolicy('test', { using: sql`true`, withCheck: sql`true` }), cockroachPolicy('newRls')]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'multiple-policies',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('multiple policies with roles', async ({ db }) => {
+	await db.query(`CREATE ROLE new_manager;`);
+
+	const schema = {
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+			},
+			() => [
+				cockroachPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				cockroachPolicy('newRls', { to: ['root', 'new_manager'] }),
+			],
+		),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'multiple-policies-with-roles',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('multiple policies with roles from schema', async ({ db }) => {
+	const usersRole = cockroachRole('user_role', { createRole: true });
+
+	const schema = {
+		usersRole,
+		users: cockroachTable(
+			'users',
+			{
+				id: int4('id').primaryKey(),
+			},
+			() => [
+				cockroachPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				cockroachPolicy('newRls', { to: ['root', usersRole] }),
+			],
+		),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'multiple-policies-with-roles-from-schema',
+		['public'],
+		{ roles: { include: ['user_role'] } },
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
diff --git a/drizzle-kit/tests/cockroach/pull.test.ts b/drizzle-kit/tests/cockroach/pull.test.ts
new file mode 100644
index 0000000000..dbba4f65d3
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/pull.test.ts
@@ -0,0 +1,972 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	AnyCockroachColumn,
+	bigint,
+	bit,
+	bool,
+	char,
+	check,
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachRole,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	date,
+	decimal,
+	doublePrecision,
+	float,
+	geometry,
+	index,
+	inet,
+	int4,
+	interval,
+	jsonb,
+	numeric,
+	real,
+	smallint,
+	string,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varbit,
+	varchar,
+} from 'drizzle-orm/cockroach-core';
+import { fromDatabaseForDrizzle } from 'src/dialects/cockroach/introspect';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { diffIntrospect, push, test } from 'tests/cockroach/mocks';
+import { expect } from 'vitest';
+
+test.concurrent('basic introspect test', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').notNull(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'basic-introspect');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('basic identity always test', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'basic-identity-always-introspect');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('basic identity by default test', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-identity-default-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('basic index test', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			firstName: text('first_name'),
+			lastName: text('last_name'),
+			data: jsonb('data'),
+		}, (table) => [
+			index('single_column').on(table.firstName),
+			index('multi_column').on(table.firstName, table.lastName),
+			index('single_expression').on(sql`lower(${table.firstName})`),
+			index('multi_expression').on(sql`lower(${table.firstName})`, sql`lower(${table.lastName})`),
+			index('expression_with_comma').on(
+				sql`(lower(${table.firstName}) || ', '::text || lower(${table.lastName}))`,
+			),
+			index('expression_with_double_quote').on(sql`('"'::text || ${table.firstName})`),
+			index('expression_with_jsonb_operator').on(
+				sql`(${table.data} #>> '{a,b,1}'::text[])`,
+			),
+		]),
+	};
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-index-introspect',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test.concurrent('identity always test: few params', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedAlwaysAsIdentity({
+				startWith: 100,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-always-few-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('identity by default test: few params', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				maxValue: 10000,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-few-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('identity always test: all params', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedAlwaysAsIdentity({
+				startWith: 10,
+				increment: 4,
+				minValue: 10,
+				maxValue: 10000,
+				cache: 100,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-always-all-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('identity by default test: all params', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedByDefaultAsIdentity({
+				startWith: 10,
+				increment: 4,
+				minValue: 10,
+				maxValue: 10000,
+				cache: 100,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-all-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('generated column: link to another column', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`email`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'generated-link-column',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect all column types', async ({ dbc: db }) => {
+	const myEnum = cockroachEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		columns: cockroachTable('columns', {
+			bigint: bigint('bigint', { mode: 'number' }).default(100),
+			bool: bool('bool').default(true),
+			geometry: geometry({ srid: 213, mode: 'tuple' }),
+			char: char('char', { length: 3 }).default('abc'),
+			date1: date('date1').default('2024-01-01'),
+			date2: date('date2').defaultNow(),
+			date3: date('date3').default(sql`current_timestamp`),
+			numeric: numeric('numeric', { precision: 3, scale: 1 }).default('99.9'),
+			numeric2: numeric('numeric2', { precision: 1, scale: 1 }).default('0.9'),
+			numeric3: numeric('numeric3').default('99.9'),
+			decimal: decimal('decimal', { precision: 3, scale: 1 }).default('99.9'),
+			decimal2: decimal('decimal2', { precision: 1, scale: 1 }).default('0.9'),
+			decimal3: decimal('decimal3').default('99.9'),
+			enum: myEnum('my_enum').default('a'),
+			bit: bit('bit').default('1'),
+			varit: varbit('varbit').default('1'),
+			float: float('float').default(100),
+			doublePrecision: doublePrecision('doublePrecision').default(100),
+			inet: inet('inet').default('127.0.0.1'),
+			int4: int4('int4').default(10),
+			interval: interval('interval').default('1 day 01:00:00'),
+			jsonb: jsonb('jsonb').$type<{ attr: string }>().default({ attr: 'value' }),
+			real: real('real').default(100),
+			smallint: smallint('smallint').default(10),
+			string: string('string').default('value'),
+			text: text('test').default('abc'),
+			time1: time('time1').default('00:00:00'),
+			timestamp1: timestamp('timestamp1', { withTimezone: true, precision: 6 }).default(new Date()),
+			timestamp2: timestamp('timestamp2', { withTimezone: true, precision: 6 }).defaultNow(),
+			timestamp3: timestamp('timestamp3', { withTimezone: true, precision: 6 }).default(
+				sql`timezone('utc'::text, now())`,
+			),
+			uuid1: uuid('uuid1').default('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'),
+			uuid2: uuid('uuid2').defaultRandom(),
+			varchar: varchar('varchar', { length: 25 }).default('abc'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-all-columns-types',
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test.concurrent('introspect all column array types', async ({ dbc: db }) => {
+	const myEnum = cockroachEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		columns: cockroachTable('columns', {
+			bigint: bigint('bigint', { mode: 'number' }).default(100).array(),
+			bit: bit().array(),
+			varbit: varbit().array(),
+			geometry: geometry().array(),
+			bool: bool('bool').default(true).array(),
+			char: char('char', { length: 3 }).default('abc').array(),
+			date1: date('date1').default('2024-01-01').array(),
+			date2: date('date2').defaultNow().array(),
+			date3: date('date3').default(sql`current_timestamp`).array(),
+			numeric: numeric('numeric', { precision: 3, scale: 1 }).default('99.9').array(),
+			numeric2: numeric('numeric2', { precision: 1, scale: 1 }).default('0.9').array(),
+			numeric3: numeric('numeric3').default('99.9').array(),
+			decimal: decimal('decimal', { precision: 3, scale: 1 }).default('99.9').array(),
+			decimal2: decimal('decimal2', { precision: 1, scale: 1 }).default('0.9').array(),
+			decimal3: decimal('decimal3').default('99.9').array(),
+			enum: myEnum('my_enum').default('a').array(),
+			float: float('float').default(100).array(),
+			doublePrecision: doublePrecision('doublePrecision').default(100).array(),
+			inet: inet('inet').default('127.0.0.1').array(),
+			int4: int4('int4').default(10).array(),
+			interval: interval('interval').default('1 day 01:00:00').array(),
+			real: real('real').default(100).array(),
+			smallint: smallint('smallint').default(10).array(),
+			string: string('string').default('value').array(),
+			text: text('test').default('abc').array(),
+			time1: time('time1').default('00:00:00').array(),
+			timestamp1: timestamp('timestamp1', { withTimezone: true, precision: 6 }).default(new Date()).array(),
+			timestamp2: timestamp('timestamp2', { withTimezone: true, precision: 6 }).defaultNow().array(),
+			timestamp3: timestamp('timestamp3', { withTimezone: true, precision: 6 }).default(
+				sql`timezone('utc'::text, now())`,
+			).array(),
+			uuid1: uuid('uuid1').default('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11').array(),
+			uuid2: uuid('uuid2').defaultRandom().array(),
+			varchar: varchar('varchar', { length: 25 }).default('abc').array(),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-all-columns-array-types',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect columns with name with non-alphanumeric characters', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			'not:allowed': int4('not:allowed'),
+			'nuh--uh': int4('nuh-uh'),
+			'1_nope': int4('1_nope'),
+			valid: int4('valid'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-column-with-name-with-non-alphanumeric-characters',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect enum from different schema', async ({ dbc: db }) => {
+	const schema2 = cockroachSchema('schema2');
+	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		schema2,
+		myEnumInSchema2,
+		users: cockroachTable('users', {
+			col: myEnumInSchema2('col'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-from-different-schema',
+		['public', 'schema2'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect enum with same names across different schema', async ({ dbc: db }) => {
+	const schema2 = cockroachSchema('schema2');
+	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
+	const myEnum = cockroachEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		schema2,
+		myEnumInSchema2,
+		myEnum,
+		users: cockroachTable('users', {
+			col1: myEnumInSchema2('col1'),
+			col2: myEnum('col2'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-with-same-names-across-different-schema',
+		['public', 'schema2'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect enum with similar name to native type', async ({ dbc: db }) => {
+	const timeLeft = cockroachEnum('time_left', ['short', 'medium', 'long']);
+	const schema = {
+		timeLeft,
+		auction: cockroachTable('auction', {
+			col: timeLeft('col1'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-with-similar-name-to-native-type',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect strings with single quotes', async ({ dbc: db }) => {
+	const myEnum = cockroachEnum('my_enum', ['escape\'s quotes " ']);
+	const schema = {
+		enum_: myEnum,
+		columns: cockroachTable('columns', {
+			enum: myEnum('my_enum').default('escape\'s quotes " '),
+			text: text('text').default('escape\'s quotes " '),
+			varchar: varchar('varchar').default('escape\'s quotes " '),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-strings-with-single-quotes',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect checks', async ({ dbc: db }) => {
+	const schema = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			name: varchar('name'),
+			age: int4('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-checks',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect checks from different schemas with same names', async ({ dbc: db }) => {
+	const mySchema = cockroachSchema('schema2');
+	const schema = {
+		mySchema,
+		users: cockroachTable('users', {
+			id: int4('id'),
+			age: int4('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+		usersInMySchema: mySchema.table('users', {
+			id: int4('id'),
+			age: int4('age'),
+		}, (table) => [check('some_check', sql`${table.age} < 1`)]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-checks-diff-schema-same-names',
+		['public', 'schema2'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect view #1', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = cockroachView('some_view').as((qb) => qb.select().from(users));
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect view #2', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = cockroachView('some_view', { id: int4('asd') }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view-2',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect view in other schema', async ({ dbc: db }) => {
+	const newSchema = cockroachSchema('new_schema');
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = newSchema.view('some_view', { id: int4('asd') }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+	const schema = {
+		view,
+		users,
+		newSchema,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view-in-other-schema',
+		['new_schema', 'public'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect materialized view in other schema', async ({ db }) => {
+	const newSchema = cockroachSchema('new_schema');
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		name: varchar(),
+	});
+
+	const view = newSchema.materializedView('some_view', { id: int4() }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+	const schema = {
+		view,
+		users,
+		newSchema,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-mat-view-in-other-schema',
+		['new_schema', 'public'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect materialized view #1', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = cockroachMaterializedView('some_view').withNoData().as((qb) => qb.select().from(users));
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-materialized-view',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect materialized view #2', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = cockroachMaterializedView('some_view', { id: int4('asd') }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-materialized-view-2',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('basic roles', async ({ dbc: db }) => {
+	const schema = {
+		usersRole: cockroachRole('user'),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-roles',
+		['public'],
+		{ roles: { include: ['user'] } },
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('role with properties', async ({ dbc: db }) => {
+	const schema = {
+		usersRole: cockroachRole('user', { createDb: true, createRole: true }),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'roles-with-properties',
+		['public'],
+		{ roles: { include: ['user'] } },
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('role with a few properties', async ({ dbc: db }) => {
+	const schema = {
+		usersRole: cockroachRole('user', { createRole: true }),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'roles-with-few-properties',
+		['public'],
+		{ roles: { include: ['user'] } },
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('case sensitive schema name + identity column', async ({ dbc: db }) => {
+	const mySchema = cockroachSchema('CaseSensitiveSchema');
+	const schema = {
+		mySchema,
+		users: mySchema.table('users', {
+			id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+			name: text('name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'case-sensitive-schema-name',
+		['CaseSensitiveSchema'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect foreign keys', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey(),
+		name: text('name'),
+	});
+	const schema = {
+		users,
+		posts: cockroachTable('posts', {
+			id: int4('id').primaryKey(),
+			userId: int4('user_id').references(() => users.id, { onDelete: 'set null', onUpdate: 'cascade' }),
+		}),
+	};
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-foreign-keys');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test.concurrent('introspect table with self reference', async ({ dbc: db }) => {
+	const users = cockroachTable('users', {
+		id: int4().primaryKey(),
+		name: text(),
+		invited_id: int4().references((): AnyCockroachColumn => users.id),
+	});
+	const schema = { users };
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-self-ref');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test.concurrent('single quote default', async ({ dbc: db }) => {
+	const group = cockroachTable('group', {
+		id: text().notNull(),
+		fk_organizaton_group: text().notNull(),
+		saml_identifier: text().default('').notNull(),
+		display_name: text().default('').notNull(),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ group },
+		'single_quote_default',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5193
+test('check definition', async ({ db }) => {
+	const table1 = cockroachTable('table1', {
+		column1: int4().primaryKey(),
+	}, (t) => [check('check_positive', sql`${t.column1} > 0`)]);
+	const schema = { table1 };
+	await push({ db, to: schema });
+
+	const filter = prepareEntityFilter('cockroach', {
+		tables: undefined,
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+
+	const { checks } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect(checks).toStrictEqual([
+		{
+			entityType: 'checks',
+			schema: 'public',
+			name: 'check_positive',
+			table: 'table1',
+			value: '(column1 > 0)',
+		},
+	]);
+});
+
+// other tables in migration schema
+test('pull after migrate with custom migrations table #1', async ({ db }) => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter('cockroach', {
+		tables: undefined,
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+	const { pks, columns, tables, schemas } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'drizzle',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'drizzle',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'drizzle',
+			table: 'users',
+		},
+	]);
+});
+
+// no tables in migration schema
+test('pull after migrate with custom migrations table #2', async ({ db }) => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS public.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter('cockroach', {
+		tables: undefined,
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'public',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'users',
+		},
+	]);
+});
+
+// other tables in custom migration schema
+test('pull after migrate with custom migrations table #3', async ({ db }) => {
+	await db.query(`CREATE SCHEMA custom;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS custom.custom_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS custom.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS public.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter('cockroach', {
+		tables: undefined,
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: 'custom_migrations',
+			schema: 'custom',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'custom',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'custom',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'public',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'users',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'custom',
+			table: 'users',
+		},
+	]);
+});
diff --git a/drizzle-kit/tests/cockroach/role.test.ts b/drizzle-kit/tests/cockroach/role.test.ts
new file mode 100644
index 0000000000..288d9dc0c6
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/role.test.ts
@@ -0,0 +1,197 @@
+import { cockroachRole } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test('create role', async ({ db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create role with properties', async ({ db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: cockroachRole('manager', { createDb: true, createRole: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'CREATE ROLE "manager" WITH CREATEDB CREATEROLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create role with some properties', async ({ db }) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: cockroachRole('manager', { createDb: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager" WITH CREATEDB;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop role', async ({ db }) => {
+	const schema1 = { manager: cockroachRole('manager') };
+
+	const schema2 = {};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'DROP ROLE "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create and drop role', async ({ db }) => {
+	const schema1 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const schema2 = {
+		superuser: cockroachRole('superuser'),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager', 'superuser'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager', 'superuser'] } },
+	});
+
+	const st0 = [
+		'DROP ROLE "manager";',
+		'CREATE ROLE "superuser";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename role - recreate', async ({ db }) => {
+	const schema1 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const schema2 = {
+		superuser: cockroachRole('superuser'),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager', 'superuser'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager', 'superuser'] } },
+	});
+
+	const st0 = [
+		`DROP ROLE "manager";`,
+		`CREATE ROLE "superuser";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter all role field', async ({ db }) => {
+	const schema1 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const schema2 = {
+		manager: cockroachRole('manager', { createDb: true, createRole: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH CREATEDB CREATEROLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter createdb in role', async ({ db }) => {
+	const schema1 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const schema2 = {
+		manager: cockroachRole('manager', { createDb: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH CREATEDB NOCREATEROLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter createrole in role', async ({ db }) => {
+	const schema1 = {
+		manager: cockroachRole('manager'),
+	};
+
+	const schema2 = {
+		manager: cockroachRole('manager', { createRole: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH NOCREATEDB CREATEROLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/schemas.test.ts b/drizzle-kit/tests/cockroach/schemas.test.ts
new file mode 100644
index 0000000000..83eb9857ae
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/schemas.test.ts
@@ -0,0 +1,143 @@
+import { cockroachSchema } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('add schema #1', async ({ db }) => {
+	const to = {
+		devSchema: cockroachSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "dev";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add schema #2', async ({ db }) => {
+	const from = {
+		devSchema: cockroachSchema('dev'),
+	};
+	const to = {
+		devSchema: cockroachSchema('dev'),
+		devSchema2: cockroachSchema('dev2'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('delete schema #1', async ({ db }) => {
+	const from = {
+		devSchema: cockroachSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		'DROP SCHEMA "dev";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('delete schema #2', async ({ db }) => {
+	const from = {
+		devSchema: cockroachSchema('dev'),
+		devSchema2: cockroachSchema('dev2'),
+	};
+	const to = {
+		devSchema: cockroachSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SCHEMA "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename schema #1', async ({ db }) => {
+	const from = {
+		devSchema: cockroachSchema('dev'),
+	};
+
+	const to = {
+		devSchema2: cockroachSchema('dev2'),
+	};
+
+	const renames = ['dev->dev2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "dev" RENAME TO "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename schema #2', async ({ db }) => {
+	const from = {
+		devSchema: cockroachSchema('dev'),
+		devSchema1: cockroachSchema('dev1'),
+	};
+	const to = {
+		devSchema: cockroachSchema('dev'),
+		devSchema2: cockroachSchema('dev2'),
+	};
+
+	const renames = ['dev1->dev2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "dev1" RENAME TO "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/schemas/schema0.ts b/drizzle-kit/tests/cockroach/schemas/schema0.ts
new file mode 100644
index 0000000000..5a3355a628
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/schemas/schema0.ts
@@ -0,0 +1,61 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	boolean,
+	check,
+	cockroachEnum,
+	cockroachSchema,
+	cockroachSequence,
+	index,
+	jsonb,
+	smallint,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+} from 'drizzle-orm/cockroach-core';
+
+// generated with AI and updated manually in some places
+
+export const core = cockroachSchema('core');
+export const currencyCode = cockroachEnum('currency_code', ['USD', 'EUR', 'GBP', 'UAH', 'JPY']);
+
+export const seqOrgCode = cockroachSequence('seq_org_code', {
+	startWith: '1000',
+	increment: '1',
+	minValue: '1',
+	maxValue: '9223372036854775807',
+	cache: '1',
+});
+
+export const organizationsInCore = core.table('organizations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: bigint({ mode: 'number' }).default(sql`nextval('public.seq_org_code'::REGCLASS)`).notNull(),
+	name: text().notNull(),
+	domain: text(),
+	currency: currencyCode().default('EUR').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_org_name_idx').using('btree', table.name.asc()),
+	index('organizations_code_idx').using('btree', table.code.asc()),
+	unique('organizations_domain_key').on(table.domain),
+	check('organizations_name_check', sql`char_length(name) > 1`),
+]);
+
+export const taskQueueInAnalytics = core.table('task_queue', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	queueName: text('queue_name').default('default').notNull(),
+	payload: jsonb().notNull(),
+	priority: smallint().default(100).notNull(),
+	reserved: boolean().default(false).notNull(),
+	reservedUntil: timestamp('reserved_until', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (t) => [
+	uniqueIndex('analytics_task_queue_unique_unreserved').using(
+		'btree',
+		sql`queue_name`,
+		sql`((${t.payload} ->> 'task_type'::text))`,
+	).where(sql`(reserved = false)`),
+]);
diff --git a/drizzle-kit/tests/cockroach/schemas/schema1.ts b/drizzle-kit/tests/cockroach/schemas/schema1.ts
new file mode 100644
index 0000000000..a9e008e104
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/schemas/schema1.ts
@@ -0,0 +1,1134 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	AnyCockroachColumn,
+	bigint,
+	boolean,
+	char,
+	check,
+	cockroachEnum,
+	cockroachPolicy,
+	cockroachSchema,
+	cockroachSequence,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	index,
+	inet,
+	int4 as integer,
+	interval,
+	jsonb,
+	numeric,
+	primaryKey,
+	smallint,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+} from 'drizzle-orm/cockroach-core';
+
+// generated with AI and updated manually in some places
+
+export const core = cockroachSchema('core');
+export const analytics = cockroachSchema('analytics');
+export const billing = cockroachSchema('billing');
+export const monitoring = cockroachSchema('monitoring');
+export const alertAction = cockroachEnum('alert_action', ['email', 'pagerd/ut"\'y', 'slack', 'webhook']);
+export const currencyCode = cockroachEnum('currency_code', ['USD', 'EUR', 'GBP', 'UAH', 'JPY']);
+export const datasetVisibility = cockroachEnum('dataset_visibility', ['priv"ate', 'team', 'public']);
+export const env = cockroachEnum('env', ['dev', 'staging', 'prod']);
+export const featureState = cockroachEnum('feature_state', ['enabled', 'disabled', 'gradual']);
+export const invoiceStatus = cockroachEnum('invoice_status', ['draft', "iss'ued", 'paid', 'voided', 'failed']);
+export const jobState = cockroachEnum('job_state', ['queued', 'running', 'success', 'failed', 'cancelled']);
+export const notificationChannel = cockroachEnum('notification_channel', ['email', 'sms', 'in_app', 'webhook']);
+export const paymentMethod = cockroachEnum('payment_method', ['card', 'bank_transfer', 'paypal', 'crypto']);
+export const pipelineStatus = cockroachEnum('pipeline_status', [
+	'created',
+	'running',
+	'paused',
+	'completed',
+	'errored',
+]);
+export const roleKind = cockroachEnum('role_kind', ['system', 'custom']);
+export const ruleConditionOperator = cockroachEnum('rule_condition_operator', [
+	'eq',
+	'neq',
+	'gt',
+	'lt',
+	'gte',
+	'lte',
+	'in',
+	'nin',
+]);
+export const severityLevel = cockroachEnum('severity_level', ['low', 'medium', 'high', 'critical']);
+export const userStatus = cockroachEnum('user_status', ['active', 'inactive', 'suspended', 'pending']);
+
+export const seqOrgCode = cockroachSequence('seq_org_code', {
+	startWith: '1000',
+	increment: '1',
+	minValue: '1',
+	maxValue: '9223372036854775807',
+	cache: '1',
+});
+
+export const organizationsInCore = core.table('organizations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: bigint({ mode: 'number' }).default(sql`nextval('public.seq_org_code'::REGCLASS)`).notNull(),
+	name: text().notNull(),
+	domain: text(),
+	currency: currencyCode().default('EUR').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_org_name_idx').using('btree', table.name.asc()),
+	index('organizations_code_idx').using('btree', table.code.asc()),
+	unique('organizations_domain_key').on(table.domain),
+	check('organizations_name_check', sql`char_length(name) > 1`),
+]);
+
+export const usersInCore = core.table('users', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	username: text().notNull(),
+	status: userStatus().default('pending').notNull(),
+	locale: text().default('en-US').notNull(),
+	lastLogin: timestamp('last_login', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	bio: text().$onUpdate(() => sql`bio || 'some test'`),
+	profile: jsonb(),
+}, (table) => [
+	index('core_users_username_idx').using(
+		'btree',
+		table.organizationId.asc(),
+		table.username.asc(),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'users_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('users_org_username_unique').on(table.organizationId, table.username),
+]);
+
+export const rolesInCore = core.table('roles', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull().references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+	name: text().notNull(),
+	kind: roleKind().default('custom').notNull(),
+	builtin: boolean().default(false).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	unique('roles_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const permissionsInCore = core.table('permissions', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	code: text().notNull().unique(),
+	description: text(),
+});
+
+export const membershipsInCore = core.table('memberships', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	roleId: integer('role_id').notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	joinedAt: timestamp('joined_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'memberships_user_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'memberships_role_id_fkey',
+	}),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'memberships_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('unique_membership').on(table.userId, table.organizationId),
+]);
+
+export const apiKeysInCore = core.table('api_keys', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	userId: uuid('user_id'),
+	name: text().notNull(),
+	keyHash: text('key_hash').notNull(),
+	revoked: boolean().default(false).notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb().generatedAlwaysAs(sql`'{"some":"test"}'`),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_apikey_org_idx').using('btree', table.organizationId.asc()).where(
+		sql`(revoked = false)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'api_keys_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'api_keys_user_id_fkey',
+	}).onDelete('set null'),
+	unique('api_keys_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const sessionsInCore = core.table('sessions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	ip: inet(),
+	userAgent: text('user_agent'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }).notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	index('core_sessions_user_expires').using(
+		'btree',
+		table.userId.asc(),
+		table.expiresAt.asc(),
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'sessions_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const oauthProvidersInCore = core.table('oauth_providers', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	provider: text().notNull(),
+	clientId: text('client_id').notNull(),
+	clientSecret: text('client_secret').notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'oauth_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('oauth_providers_organization_id_provider_key').on(table.organizationId, table.provider),
+]);
+
+export const featureFlagsInCore = core.table('feature_flags', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	state: featureState().default('disabled').notNull(),
+	rolloutPercent: smallint('rollout_percent').default(0),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'feature_flags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('feature_flags_organization_id_key_key').on(table.organizationId, table.key),
+	check('feature_flags_rollout_percent_check', sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`),
+]);
+
+export const projectsInCore = core.table('projects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	slug: text().notNull(),
+	description: text(),
+	visibility: datasetVisibility().default('priv"ate').notNull(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_projects_org_name_idx').using(
+		'btree',
+		table.organizationId.asc(),
+		table.name.asc(),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'projects_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'projects_created_by_fkey',
+	}),
+	unique('projects_org_slug_unique').on(table.organizationId, table.slug),
+]);
+
+export const repositoriesInCore = core.table('repositories', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	provider: text().notNull(),
+	repoOwner: text('repo_owner').notNull(),
+	repoName: text('repo_name').notNull(),
+	defaultBranch: text('default_branch').default('main').notNull(),
+	cloneUrl: text('clone_url'),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'repositories_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('repositories_project_id_provider_repo_owner_repo_name_key').on(
+		table.projectId,
+		table.provider,
+		table.repoOwner,
+		table.repoName,
+	),
+]);
+
+export const buildsInCore = core.table('builds', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	triggeredBy: uuid('triggered_by'),
+	commitSha: char('commit_sha', { length: 40 }).notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	index('core_builds_project_status_idx').using(
+		'btree',
+		table.projectId.asc(),
+		table.status.asc(),
+	),
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'builds_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.triggeredBy],
+		foreignColumns: [usersInCore.id],
+		name: 'builds_triggered_by_fkey',
+	}),
+	unique('builds_project_id_commit_sha_key').on(table.projectId, table.commitSha),
+]);
+
+export const pipelinesInCore = core.table('pipelines', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	name: text().notNull(),
+	spec: jsonb().notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'pipelines_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipelines_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const pipelineRunsInAnalytics = analytics.table('pipeline_runs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineId: uuid('pipeline_id').notNull(),
+
+	runNumber: bigint('run_number', { mode: 'number' }).notNull(),
+	state: jobState().default('queued').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	logs: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_pipeline_runs_state_idx').using('btree', table.state.asc()),
+	foreignKey({
+		columns: [table.pipelineId],
+		foreignColumns: [pipelinesInCore.id],
+		name: 'pipeline_runs_pipeline_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipeline_runs_unique_run').on(table.pipelineId, table.runNumber),
+]);
+
+export const jobsInAnalytics = analytics.table('jobs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineRunId: uuid('pipeline_run_id'),
+	name: text().notNull(),
+	state: jobState().default('queued').notNull(),
+	attempts: integer().default(0).notNull(),
+	lastError: text('last_error'),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_jobs_state_attempts_idx').using(
+		'btree',
+		table.state.asc(),
+		table.attempts.asc(),
+	),
+	foreignKey({
+		columns: [table.pipelineRunId],
+		foreignColumns: [pipelineRunsInAnalytics.id],
+		name: 'jobs_pipeline_run_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const storageBucketsInCore = core.table('storage_buckets', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	region: text().notNull(),
+	config: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'storage_buckets_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('storage_buckets_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const objectsInCore = core.table('objects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	bucketId: uuid('bucket_id').notNull(),
+	path: text().notNull(),
+
+	size: bigint({ mode: 'number' }).default(0).notNull(),
+	contentType: text('content_type'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_objects_bucket_path_gin').using('gin', table.metadata.asc()),
+	foreignKey({
+		columns: [table.bucketId],
+		foreignColumns: [storageBucketsInCore.id],
+		name: 'objects_bucket_id_fkey',
+	}).onDelete('cascade'),
+	unique('objects_bucket_id_path_key').on(table.bucketId, table.path),
+]);
+
+export const filesInCore = core.table('files', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	name: text().notNull(),
+	latestObjectId: uuid('latest_object_id'),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'files_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.latestObjectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'files_latest_object_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'files_created_by_fkey',
+	}),
+	unique('files_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const fileVersionsInCore = core.table('file_versions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	fileId: uuid('file_id').notNull(),
+	objectId: uuid('object_id').notNull(),
+	versionNumber: integer('version_number').notNull(),
+	checksum: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.fileId],
+		foreignColumns: [filesInCore.id],
+		name: 'file_versions_file_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.objectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'file_versions_object_id_fkey',
+	}).onDelete('cascade'),
+	unique('file_versions_file_id_version_number_key').on(table.fileId, table.versionNumber),
+]);
+
+export const tagsInCore = core.table('tags', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	value: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'tags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('tags_organization_id_key_value_key').on(table.organizationId, table.key, table.value),
+]);
+
+export const conversationsInCore = core.table('conversations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	title: text(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'conversations_project_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'conversations_created_by_fkey',
+	}),
+]);
+
+export const chatMessagesInCore = core.table('chat_messages', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	conversationId: uuid('conversation_id').notNull(),
+	senderId: uuid('sender_id'),
+	body: text().notNull(),
+	attachments: jsonb(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	editedAt: timestamp('edited_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	index('core_chat_conv_sent_at_idx').using(
+		'btree',
+		table.conversationId.asc(),
+		table.sentAt.desc(),
+	),
+	foreignKey({
+		columns: [table.conversationId],
+		foreignColumns: [conversationsInCore.id],
+		name: 'chat_messages_conversation_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.senderId],
+		foreignColumns: [usersInCore.id],
+		name: 'chat_messages_sender_id_fkey',
+	}).onDelete('set null'),
+]);
+
+export const notificationsInCore = core.table('notifications', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	channel: notificationChannel().default('in_app').notNull(),
+	payload: jsonb().notNull(),
+	seen: boolean().default(false).notNull(),
+	deliveredAt: timestamp('delivered_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_notifications_unseen_idx').using('btree', table.userId.asc()).where(
+		sql`(seen = false)`,
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'notifications_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const customersInBilling = billing.table('customers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	name: text().notNull(),
+	address: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'customers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('customers_organization_id_key').on(table.organizationId),
+	unique('idnameunique').on(table.id, table.name),
+]);
+
+export const subscriptionsInBilling = billing.table('subscriptions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	plan: text().notNull(),
+	status: text().default('active').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	endedAt: timestamp('ended_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'subscriptions_customer_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const paymentsInBilling = billing.table('payments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	invoiceId: uuid('invoice_id').notNull(),
+	paidAt: timestamp('paid_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	amount: numeric({ precision: 12, scale: 2 }).notNull(),
+	amount2: decimal({ precision: 12, scale: 2 }).notNull(),
+	method: paymentMethod().notNull(),
+	transactionRef: text('transaction_ref'),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.invoiceId],
+		foreignColumns: [invoicesInBilling.id],
+		name: 'payments_invoice_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const couponsInBilling = billing.table('coupons', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+	discountPercent: smallint('discount_percent'),
+	redeemableFrom: timestamp('redeemable_from', { withTimezone: true, mode: 'string' }),
+	redeemableTo: timestamp('redeemable_to', { withTimezone: true, mode: 'string' }),
+	maxRedemptions: integer('max_redemptions').generatedAlwaysAsIdentity(),
+	metadata: jsonb(),
+}, (table) => [
+	unique('coupons_code_key').on(table.code),
+	check('coupons_discount_percent_check', sql`(discount_percent >= 0) AND (discount_percent <= 100)`),
+]);
+
+export const webhooksInCore = core.table('webhooks', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	url: text().notNull(),
+	secret: text(),
+	events: text().array().notNull(),
+	active: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_webhooks_org_active_idx').using('btree', table.organizationId.asc()).where(
+		sql`(active = true)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'webhooks_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const metricSourcesInAnalytics = analytics.table('metric_sources', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'metric_sources_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('metric_sources_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const metricsInAnalytics = analytics.table('metrics', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	sourceId: uuid('source_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	ts: timestamp({ withTimezone: true, mode: 'string' }).notNull(),
+	value: doublePrecision().notNull(),
+	tags: jsonb(),
+}, (table) => [
+	index('analytics_metrics_key_ts_idx').using(
+		'btree',
+		table.metricKey.asc(),
+		table.ts.desc(),
+	),
+	foreignKey({
+		columns: [table.sourceId],
+		foreignColumns: [metricSourcesInAnalytics.id],
+		name: 'metrics_source_id_fkey',
+	}).onDelete('cascade'),
+	unique('metrics_source_id_metric_key_ts_key').on(table.sourceId, table.metricKey, table.ts),
+]);
+
+export const alertRulesInMonitoring = monitoring.table('alert_rules', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	description: text(),
+	severity: severityLevel().default('medium').notNull(),
+	enabled: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'alert_rules_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('alert_rules_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const ruleConditionsInMonitoring = monitoring.table('rule_conditions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	operator: ruleConditionOperator().notNull().unique('some_name'),
+	threshold: doublePrecision().notNull(),
+	window: interval().default('00:05:00').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'rule_conditions_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const alertsInMonitoring = monitoring.table('alerts', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	triggeredAt: timestamp('triggered_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	resolvedAt: timestamp('resolved_at', { withTimezone: true, mode: 'string' }),
+	payload: jsonb(),
+	state: text().default('firing').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'alerts_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const escalationsInMonitoring = monitoring.table('escalations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	alertId: uuid('alert_id').notNull(),
+	action: alertAction().notNull(),
+	target: text().notNull(),
+	executedAt: timestamp('executed_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	foreignKey({
+		columns: [table.alertId],
+		foreignColumns: [alertsInMonitoring.id],
+		name: 'escalations_alert_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const ssoProvidersInCore = core.table('sso_providers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	config: jsonb().notNull(),
+	enabled: boolean().default(false).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'sso_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const auditLogsInCore = core.table('audit_logs', {
+	id: bigint({ mode: 'number' }).generatedAlwaysAsIdentity().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	actorId: uuid('actor_id'),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').array(),
+	action: text().notNull(),
+	beforeState: jsonb('before_state'),
+	afterState: jsonb('after_state'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_audit_org_idx').using(
+		'btree',
+		table.organizationId.asc(),
+		table.createdAt.desc(),
+	),
+]);
+
+export const rateLimitsInCore = core.table('rate_limits', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	apiKeyId: uuid('api_key_id').notNull(),
+	windowStart: timestamp('window_start', { withTimezone: true, mode: 'string' }).notNull(),
+	requests: integer().generatedByDefaultAsIdentity().notNull().array(),
+	limit: integer().generatedAlwaysAs(() => sql`1`).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.apiKeyId],
+		foreignColumns: [apiKeysInCore.id],
+		name: 'rate_limits_api_key_id_fkey',
+	}).onDelete('cascade'),
+	unique('rate_limits_api_key_id_window_start_key').on(table.apiKeyId, table.windowStart),
+]);
+
+export const experimentsInCore = core.table('experiments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'experiments_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiments_organization_id_key_key').on(table.organizationId, table.key),
+]);
+
+export const experimentVariantsInCore = core.table('experiment_variants', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	name: text().notNull(),
+	allocationPercent: smallint('allocation_percent').default(0).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_variants_experiment_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_variants_experiment_id_name_key').on(table.experimentId, table.name),
+	check('experiment_variants_allocation_percent_check', sql`(allocation_percent >= 0) AND (allocation_percent <= 100)`),
+]);
+
+export const experimentAssignmentsInCore = core.table('experiment_assignments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	variantId: uuid('variant_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_assignments_experiment_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.variantId],
+		foreignColumns: [experimentVariantsInCore.id],
+		name: 'experiment_assignments_variant_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'experiment_assignments_user_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_assignments_experiment_id_user_id_key').on(table.experimentId, table.userId),
+]);
+
+export const deploymentsInCore = core.table('deployments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	environment: env().default('dev').notNull(),
+	version: text().notNull(),
+	deployedBy: uuid('deployed_by'),
+	deployedAt: timestamp('deployed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	notes: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'deployments_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.deployedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'deployments_deployed_by_fkey',
+	}),
+	unique('deployments_project_id_environment_version_key').on(table.projectId, table.environment, table.version),
+]);
+
+export const servicesInCore = core.table('services', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	kind: text(),
+	ownerId: uuid('owner_id'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string', precision: 6 }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'services_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.ownerId],
+		foreignColumns: [usersInCore.id],
+		name: 'services_owner_id_fkey',
+	}),
+	unique('services_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const locksInCore = core.table('locks', {
+	name: text().primaryKey().notNull(),
+	owner: text(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string', precision: 2 }),
+});
+
+export const entitiesInCore = core.table('entities', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	data: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'entities_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const taskQueueInAnalytics = analytics.table('task_queue', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	queueName: text('queue_name').default('default').notNull(),
+	payload: jsonb().notNull(),
+	priority: smallint().default(100).notNull(),
+	reserved: boolean().default(false).notNull(),
+	reservedUntil: timestamp('reserved_until', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex('analytics_task_queue_unique_unreserved').using(
+		'btree',
+		sql`queue_name`,
+		sql`((payload ->> 'task_type'::text))`,
+	).where(sql`(reserved = false)`),
+]);
+
+export const invoicesInBilling = billing.table('invoices', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	number: text().notNull(),
+	issuedAt: timestamp('issued_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	dueAt: timestamp('due_at', { withTimezone: true, mode: 'string' }),
+	totalAmount: numeric('total_amount', { precision: 12, scale: 2 }).default('0.0').notNull(),
+	currency: currencyCode().default('USD').notNull(),
+	status: invoiceStatus().default('draft').notNull(),
+	notes: text(),
+}, (table) => [
+	index('billing_invoices_status_idx').using('btree', table.status.asc()),
+	foreignKey({
+		columns: [table.customerId, table.number],
+		foreignColumns: [customersInBilling.id, customersInBilling.name],
+		name: 'invoices_customer_id_fkey',
+	}).onDelete('cascade'),
+	unique('invoices_customer_id_number_key').on(table.customerId, table.number),
+	check('invoices_total_nonnegative', sql`total_amount >= (0)::numeric`),
+]);
+
+export const aliasesInCore = core.table('aliases', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	alias: text().notNull().unique('unique_with_name'),
+	organizationId: uuid('organization_id'),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'aliases_organization_id_fkey',
+	}).onUpdate('cascade'),
+	unique('aliases_object_type_object_id_alias_key').on(table.objectType, table.objectId, table.alias),
+]);
+
+export const selfRef = core.table('self_ref', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull().unique().references((): AnyCockroachColumn => selfRef.organizationId),
+	organizationId: text('organization_id').notNull().unique(),
+});
+
+export const couponRedemptionsInBilling = billing.table('coupon_redemptions', {
+	couponId: uuid('coupon_id').notNull(),
+	customerId: uuid('customer_id').notNull(),
+	redeemedAt: timestamp('redeemed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.couponId],
+		foreignColumns: [couponsInBilling.id],
+		name: 'coupon_redemptions_coupon_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'coupon_redemptions_customer_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.couponId, table.customerId], name: 'coupon_redemptions_pkey' }),
+]);
+
+export const entityLinksInCore = core.table('entity_links', {
+	parentEntityId: uuid('parent_entity_id').notNull(),
+	childEntityId: uuid('child_entity_id').notNull(),
+	relationship: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.parentEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_parent_entity_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.childEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_child_entity_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.parentEntityId, table.childEntityId, table.relationship], name: 'entity_links_pkey' }),
+]);
+
+export const rolePermissionsInCore = core.table('role_permissions', {
+	roleId: integer('role_id').notNull(),
+	permissionId: integer('permission_id').notNull(),
+	assignedBy: uuid('assigned_by'),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'role_permissions_role_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.permissionId],
+		foreignColumns: [permissionsInCore.id],
+		name: 'role_permissions_permission_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.assignedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'role_permissions_assigned_by_fkey',
+	}),
+	primaryKey({ columns: [table.roleId, table.permissionId], name: 'role_permissions_pkey' }),
+]);
+
+export const taggingsInCore = core.table('taggings', {
+	tagId: integer('tag_id').notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.tagId],
+		foreignColumns: [tagsInCore.id],
+		name: 'taggings_tag_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.tagId, table.objectType, table.objectId], name: 'taggings_pkey' }),
+]);
+
+export const reactionsInCore = core.table('reactions', {
+	messageId: uuid('message_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	reaction: text().notNull().array(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.messageId],
+		foreignColumns: [chatMessagesInCore.id],
+		name: 'reactions_message_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'reactions_user_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.messageId, table.userId, table.reaction], name: 'reactions_pkey' }),
+]);
+
+// views
+export const projectSearchInAnalytics = analytics.materializedView('project_search', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).withNoData().as(
+	sql`SELECT id, name, slug, description FROM core.projects p`,
+);
+
+export const projectSearchInAnalytics2 = analytics.materializedView('project_search2', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).withNoData().existing();
+
+export const vActiveUsersInCore = core.view('v_active_users').as((qb) =>
+	qb.select({
+		id: usersInCore.id,
+		username: usersInCore.username,
+		organization_id: usersInCore.organizationId,
+	}).from(usersInCore).where(eq(usersInCore.status, 'active'))
+);
+export const vActiveUsersInCore2 = core.view('v_active_users2', {}).existing();
+
+// polices
+export const rls = cockroachSchema('rls');
+export const documentsInRls = rls.table('documents', {
+	docId: uuid('doc_id').defaultRandom().primaryKey().notNull(),
+	ownerId: uuid('owner_id').notNull(),
+	title: text().notNull(),
+	content: text().notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	cockroachPolicy('documents_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(owner_id = (CURRENT_USER)::uuid)`,
+	}),
+	cockroachPolicy('documents_update_own', { as: 'permissive', for: 'update', to: ['public'] }),
+	cockroachPolicy('documents_select_own', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const messagesInRls = rls.table.withRLS('messages', {
+	msgId: uuid('msg_id').defaultRandom().primaryKey().notNull(),
+	senderId: uuid('sender_id').notNull(),
+	recipientId: uuid('recipient_id').notNull(),
+	message: text().notNull(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	cockroachPolicy('messages_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(sender_id = (CURRENT_USER)::uuid)`,
+	}),
+	cockroachPolicy('messages_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const projectsInRls = rls.table('projects', {
+	projectId: uuid('project_id').defaultRandom().primaryKey().notNull(),
+	name: text().notNull(),
+	description: text(),
+	ownerId: uuid('owner_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	cockroachPolicy('projects_visibility', {
+		as: 'permissive',
+		for: 'select',
+		to: ['public'],
+		using: sql`(owner_id = (CURRENT_USER)::uuid)`,
+	}),
+]);
+
+export const projectMembersInRls = rls.table.withRLS('project_members', {
+	projectId: uuid('project_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	role: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInRls.projectId],
+		name: 'project_members_project_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.projectId, table.userId], name: 'project_members_pkey' }),
+	cockroachPolicy('project_members_manage', {
+		as: 'permissive',
+		for: 'all',
+		to: ['public'],
+		using: sql`(user_id = CURRENT_USER::uuid)`,
+	}),
+	cockroachPolicy('project_members_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+	check('project_members_role_check', sql`role = ANY (ARRAY['member'::text, 'admin'::text])`),
+]);
+
+export const policy = cockroachPolicy('new_policy', {
+	as: 'restrictive',
+	to: 'root',
+	withCheck: sql`1 = 1`,
+	for: 'all',
+}).link(organizationsInCore);
diff --git a/drizzle-kit/tests/cockroach/sequences.test.ts b/drizzle-kit/tests/cockroach/sequences.test.ts
new file mode 100644
index 0000000000..8bc4673253
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/sequences.test.ts
@@ -0,0 +1,410 @@
+import { cockroachSchema, cockroachSequence } from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('create sequence', async ({ db }) => {
+	const to = {
+		seq: cockroachSequence('name', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SEQUENCE "public"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create sequence: all fields', async ({ db }) => {
+	const from = {};
+	const to = {
+		seq: cockroachSequence('name', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SEQUENCE "public"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create sequence: custom schema', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+	const from = { customSchema };
+	const to = {
+		customSchema,
+		seq: customSchema.sequence('name', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE SEQUENCE "custom"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create sequence: custom schema + all fields', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+	const from = { customSchema };
+	const to = {
+		customSchema,
+		seq: customSchema.sequence('name', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE SEQUENCE "custom"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop sequence', async ({ db }) => {
+	const from = { seq: cockroachSequence('name', { startWith: 100 }) };
+	const to = {};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SEQUENCE "public"."name";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop sequence: custom schema', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SEQUENCE "custom"."name";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename sequence', async ({ db }) => {
+	const from = { seq: cockroachSequence('name', { startWith: 100 }) };
+	const to = { seq: cockroachSequence('name_new', { startWith: 100 }) };
+
+	const renames = [
+		'public.name->public.name_new',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" RENAME TO "name_new";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename sequence in custom schema', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: customSchema.sequence('name_new', { startWith: 100 }) };
+
+	const renames = [
+		'custom.name->custom.name_new',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "custom"."name" RENAME TO "name_new";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('move sequence between schemas #1', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+	const from = { customSchema, seq: cockroachSequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+
+	const renames = [
+		'public.name->custom.name',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" SET SCHEMA "custom";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('move sequence between schemas #2', async ({ db }) => {
+	const customSchema = cockroachSchema('custom');
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: cockroachSequence('name', { startWith: 100 }) };
+
+	const renames = [
+		'custom.name->public.name',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "custom"."name" SET SCHEMA "public";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter sequence', async ({ db }) => {
+	const from = { seq: cockroachSequence('name', { startWith: 100 }) };
+	const to = { seq: cockroachSequence('name', { startWith: 105 }) };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 105 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('full sequence: no changes', async ({ db }) => {
+	const schema1 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('basic sequence: change fields', async ({ db }) => {
+	const schema1 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 100000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 4,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" INCREMENT BY 4 MINVALUE 100 MAXVALUE 100000 START WITH 100 CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('basic sequence: change name', async ({ db }) => {
+	const schema1 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: cockroachSequence('my_seq2', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const renames = ['public.my_seq->public.my_seq2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" RENAME TO "my_seq2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('basic sequence: change name and fields', async ({ db }) => {
+	const schema1 = {
+		seq: cockroachSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: cockroachSequence('my_seq2', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+
+			cache: 10,
+			increment: 4,
+		}),
+	};
+
+	const renames = ['public.my_seq->public.my_seq2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" RENAME TO "my_seq2";',
+		'ALTER SEQUENCE "my_seq2" INCREMENT BY 4 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('Add basic sequences', async ({ db }) => {
+	const schema1 = {
+		seq: cockroachSequence('my_seq', { startWith: 100 }),
+	};
+
+	const schema2 = {
+		seq: cockroachSequence('my_seq', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/cockroach/tables.test.ts b/drizzle-kit/tests/cockroach/tables.test.ts
new file mode 100644
index 0000000000..fc5c320da2
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/tables.test.ts
@@ -0,0 +1,1239 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	camelCase,
+	cockroachSchema,
+	cockroachTable,
+	cockroachTableCreator,
+	foreignKey,
+	geometry,
+	index,
+	int4,
+	primaryKey,
+	snakeCase,
+	text,
+	unique,
+	uniqueIndex,
+	vector,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+fs.mkdirSync('./tests/cockroach/migrations', { recursive: true });
+
+test.concurrent('add table #1', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #2', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #3', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+		}, (t) => [primaryKey({ name: 'users_pk', columns: [t.id] })]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n'
+		+ '\t"id" int4,\n'
+		+ '\tCONSTRAINT "users_pk" PRIMARY KEY("id")\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #4', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', { id: int4() }),
+		posts: cockroachTable('posts', { id: int4() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4\n);\n',
+		'CREATE TABLE "posts" (\n\t"id" int4\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #5', async ({ dbc: db }) => {
+	const schema = cockroachSchema('folder');
+	const from = {
+		schema,
+	};
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: int4(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "folder"."users" (\n\t"id" int4\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #6', async ({ dbc: db }) => {
+	const from = {
+		users1: cockroachTable('users1', { id: int4() }),
+	};
+
+	const to = {
+		users2: cockroachTable('users2', { id: int4() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users2" (\n\t"id" int4\n);\n',
+		'DROP TABLE "users1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #7', async ({ dbc: db }) => {
+	const from = {
+		users1: cockroachTable('users1', { id: int4() }),
+	};
+
+	const to = {
+		users: cockroachTable('users', { id: int4() }),
+		users2: cockroachTable('users2', { id: int4() }),
+	};
+
+	const renames = ['public.users1->public.users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" int4\n);\n',
+		'ALTER TABLE "users1" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #8: geometry types', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			geom: geometry('geom', { type: 'point' }).notNull(),
+			geom1: geometry('geom1').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"geom" geometry(point) NOT NULL,\n\t"geom1" geometry(point) NOT NULL\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline */
+test.concurrent('add table #9', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n'
+		+ '\t"name" string,\n'
+		+ '\tCONSTRAINT "users_name_key" UNIQUE("name")\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline named */
+test.concurrent('add table #10', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique('name_unique'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "name_unique" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #11', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique('name_unique'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "name_unique" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #12', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('users', {
+			name: text().unique('users_name_key'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique default-named */
+test.concurrent('add table #13', async ({ dbc: db }) => {
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('users_name_key').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #14', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('users_name_key').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "users_name_key" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique */
+test.concurrent('add table #15', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('users', {
+			name: text(),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" string,\n\tCONSTRAINT "name_unique" UNIQUE("name")\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('multiproject schema add table #1', async ({ dbc: db }) => {
+	const table = cockroachTableCreator((name) => `prefix_${name}`);
+
+	const to = {
+		users: table('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "prefix_users" (\n\t"id" int4 PRIMARY KEY\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('multiproject schema drop table #1', async ({ dbc: db }) => {
+	const table = cockroachTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		'DROP TABLE "prefix_users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('multiproject schema alter table name #1', async ({ dbc: db }) => {
+	const table = cockroachTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+	const to = {
+		users1: table('users1', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+
+	const renames = [
+		'public.prefix_users->public.prefix_users1',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "prefix_users" RENAME TO "prefix_users1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add table #8: column with vector', async ({ dbc: db }) => {
+	const to = {
+		users2: cockroachTable('users2', {
+			id: int4('id').primaryKey(),
+			name: vector('name', { dimensions: 3 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users2" (\n\t"id" int4 PRIMARY KEY,\n\t"name" vector(3)\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add schema + table #1', async ({ dbc: db }) => {
+	const schema = cockroachSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: int4(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder";\n',
+		'CREATE TABLE "folder"."users" (\n\t"id" int4\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change schema with tables #1', async ({ dbc: db }) => {
+	const schema = cockroachSchema('folder');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = ['folder->folder2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "folder" RENAME TO "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #1', async ({ dbc: db }) => {
+	const schema = cockroachSchema('folder');
+	const from = {
+		schema,
+		users: cockroachTable('users', {}),
+	};
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const renames = [
+		'public.users->folder.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" SET SCHEMA "folder";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #2', async ({ dbc: db }) => {
+	const schema = cockroachSchema('folder');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema,
+		users: cockroachTable('users', {}),
+	};
+
+	const renames = [
+		'folder.users->public.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "folder"."users" SET SCHEMA "public";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #3', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #4', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder2";\n',
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #5', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1, // remove schema
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder2";\n',
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+		'DROP SCHEMA "folder1";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #5', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users2', {}), // rename and move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		'ALTER TABLE "folder1"."users" RENAME TO "users2";',
+		'ALTER TABLE "folder1"."users2" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('change table schema #6', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // rename schema
+		users: schema2.table('users2', {}), // rename table
+	};
+
+	const renames = [
+		'folder1->folder2',
+		'folder2.users->folder2.users2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "folder1" RENAME TO "folder2";\n',
+		'ALTER TABLE "folder2"."users" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop table + rename schema #1', async ({ dbc: db }) => {
+	const schema1 = cockroachSchema('folder1');
+	const schema2 = cockroachSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // rename schema
+		// drop table
+	};
+
+	const renames = ['folder1->folder2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		'ALTER SCHEMA "folder1" RENAME TO "folder2";\n',
+		'DROP TABLE "folder2"."users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop tables with fk constraint', async ({ dbc: db }) => {
+	const table1 = cockroachTable('table1', {
+		column1: int4().primaryKey(),
+	});
+	const table2 = cockroachTable('table2', {
+		column1: int4().primaryKey(),
+		column2: int4().references(() => table1.column1),
+	});
+	const schema1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"column1" int4 PRIMARY KEY\n);\n',
+		'CREATE TABLE "table2" (\n\t"column1" int4 PRIMARY KEY,\n\t"column2" int4\n);\n',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_column2_table1_column1_fkey" FOREIGN KEY ("column2") REFERENCES "table1"("column1");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, {}, []);
+	const { sqlStatements: pst2 } = await push({ db, to: {} });
+
+	const expectedSt2 = [
+		'ALTER TABLE "table2" DROP CONSTRAINT "table2_column2_table1_column1_fkey";',
+		'DROP TABLE "table1";',
+		'DROP TABLE "table2";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test.concurrent('create table with tsvector', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		users: cockroachTable('posts', {
+			id: int4('id').primaryKey(),
+			title: text('title').notNull(),
+			description: text('description').notNull(),
+		}, (table) => [
+			index('title_search_index').using('gin', sql`to_tsvector('english', ${table.title})`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "posts" (\n\t"id" int4 PRIMARY KEY,\n\t"title" string NOT NULL,\n\t"description" string NOT NULL\n);\n',
+		`CREATE INDEX "title_search_index" ON "posts" USING gin (to_tsvector('english', "title"));`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('composite primary key', async ({ dbc: db }) => {
+	const from = {};
+	const to = {
+		table: cockroachTable('works_to_creators', {
+			workId: int4('work_id').notNull(),
+			creatorId: int4('creator_id').notNull(),
+			classification: text('classification').notNull(),
+		}, (t) => [
+			primaryKey({ columns: [t.workId, t.creatorId, t.classification] }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "works_to_creators" (\n\t"work_id" int4,\n\t"creator_id" int4,\n\t"classification" string,\n\tCONSTRAINT "works_to_creators_pkey" PRIMARY KEY("work_id","creator_id","classification")\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('add column before creating unique constraint', async ({ dbc: db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+		}),
+	};
+	const to = {
+		table: cockroachTable('table', {
+			id: int4('id').primaryKey(),
+			name: text('name').notNull(),
+		}, (t) => [unique('uq').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "name" string NOT NULL;',
+		'CREATE UNIQUE INDEX "uq" ON "table" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter composite primary key', async ({ dbc: db }) => {
+	const from = {
+		table: cockroachTable('table', {
+			col1: int4('col1').notNull(),
+			col2: int4('col2').notNull(),
+			col3: text('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col1, t.col2],
+			}),
+		]),
+	};
+	const to = {
+		table: cockroachTable('table', {
+			col1: int4('col1').notNull(),
+			col2: int4('col2').notNull(),
+			col3: text('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col2, t.col3],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" DROP CONSTRAINT "table_pk", ADD CONSTRAINT "table_pk" PRIMARY KEY("col2","col3");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('optional db aliases (snake case)', async ({ dbc: db }) => {
+	const from = {};
+
+	const t1 = snakeCase.table(
+		't1',
+		{
+			t1Id1: int4().notNull().primaryKey(),
+			t1Col2: int4().notNull(),
+			t1Col3: int4().notNull(),
+			t2Ref: int4().notNull().references(() => t2.t2Id),
+			t1Uni: int4().notNull(),
+			t1UniIdx: int4().notNull(),
+			t1Idx: int4().notNull(),
+		},
+		(table) => [
+			unique('t1_uni').on(table.t1Uni),
+			uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
+			index('t1_idx').on(table.t1Idx).where(sql`${table.t1Idx} > 0`),
+			foreignKey({
+				columns: [table.t1Col2, table.t1Col3],
+				foreignColumns: [t3.t3Id1, t3.t3Id2],
+			}),
+		],
+	);
+
+	const t2 = snakeCase.table(
+		't2',
+		{
+			t2Id: int4().primaryKey(),
+		},
+	);
+
+	const t3 = snakeCase.table(
+		't3',
+		{
+			t3Id1: int4(),
+			t3Id2: int4(),
+		},
+		(table) => [primaryKey({ columns: [table.t3Id1, table.t3Id2] })],
+	);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st1 = `CREATE TABLE "t1" (
+	"t1_id1" int4 PRIMARY KEY,
+	"t1_col2" int4 NOT NULL,
+	"t1_col3" int4 NOT NULL,
+	"t2_ref" int4 NOT NULL,
+	"t1_uni" int4 NOT NULL,
+	"t1_uni_idx" int4 NOT NULL,
+	"t1_idx" int4 NOT NULL,
+	CONSTRAINT "t1_uni" UNIQUE("t1_uni"),
+	CONSTRAINT "t1_uni_idx" UNIQUE("t1_uni_idx")
+);
+`;
+
+	const st2 = `CREATE TABLE "t2" (
+	"t2_id" int4 PRIMARY KEY
+);
+`;
+
+	const st3 = `CREATE TABLE "t3" (
+	"t3_id1" int4,
+	"t3_id2" int4,
+	CONSTRAINT "t3_pkey" PRIMARY KEY("t3_id1","t3_id2")
+);
+`;
+
+	const st4 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t2_ref_t2_t2_id_fkey" FOREIGN KEY ("t2_ref") REFERENCES "t2"("t2_id");`;
+	const st5 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fkey" FOREIGN KEY ("t1_col2","t1_col3") REFERENCES "t3"("t3_id1","t3_id2");`;
+
+	const st6 = `CREATE INDEX "t1_idx" ON "t1" ("t1_idx") WHERE "t1"."t1_idx" > 0;`;
+
+	const st0 = [st1, st2, st3, st4, st5, st6];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('optional db aliases (camel case)', async ({ dbc: db }) => {
+	const from = {};
+
+	const t1 = camelCase.table('t1', {
+		t1_id1: int4().notNull().primaryKey(),
+		t1_col2: int4().notNull(),
+		t1_col3: int4().notNull(),
+		t2_ref: int4().notNull().references(() => t2.t2_id),
+		t1_uni: int4().notNull(),
+		t1_uni_idx: int4().notNull(),
+		t1_idx: int4().notNull(),
+	}, (table) => [
+		unique('t1Uni').on(table.t1_uni),
+		uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
+		index('t1Idx').on(table.t1_idx).where(sql`${table.t1_idx} > 0`),
+		foreignKey({
+			columns: [table.t1_col2, table.t1_col3],
+			foreignColumns: [t3.t3_id1, t3.t3_id2],
+		}),
+	]);
+
+	const t2 = camelCase.table('t2', {
+		t2_id: int4().primaryKey(),
+	});
+
+	const t3 = camelCase.table('t3', {
+		t3_id1: int4(),
+		t3_id2: int4(),
+	}, (table) => [primaryKey({ columns: [table.t3_id1, table.t3_id2] })]);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st1 = `CREATE TABLE "t1" (
+	"t1Id1" int4 PRIMARY KEY,
+	"t1Col2" int4 NOT NULL,
+	"t1Col3" int4 NOT NULL,
+	"t2Ref" int4 NOT NULL,
+	"t1Uni" int4 NOT NULL,
+	"t1UniIdx" int4 NOT NULL,
+	"t1Idx" int4 NOT NULL,
+	CONSTRAINT "t1Uni" UNIQUE("t1Uni"),
+	CONSTRAINT "t1UniIdx" UNIQUE("t1UniIdx")
+);
+`;
+
+	const st2 = `CREATE TABLE "t2" (
+	"t2Id" int4 PRIMARY KEY
+);
+`;
+
+	const st3 = `CREATE TABLE "t3" (
+	"t3Id1" int4,
+	"t3Id2" int4,
+	CONSTRAINT "t3_pkey" PRIMARY KEY("t3Id1","t3Id2")
+);
+`;
+
+	const st4 = `ALTER TABLE "t1" ADD CONSTRAINT "t1_t2Ref_t2_t2Id_fkey" FOREIGN KEY ("t2Ref") REFERENCES "t2"("t2Id");`;
+	const st5 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fkey" FOREIGN KEY ("t1Col2","t1Col3") REFERENCES "t3"("t3Id1","t3Id2");`;
+
+	const st6 = `CREATE INDEX "t1Idx" ON "t1" ("t1Idx") WHERE "t1"."t1Idx" > 0;`;
+
+	const st0 = [st1, st2, st3, st4, st5, st6];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table with generated column', async ({ dbc: db }) => {
+	const schema1 = {};
+	const schema2 = {
+		users: cockroachTable('users', {
+			id: int4('id'),
+			id2: int4('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE "users" (\n\t"id" int4,\n\t"id2" int4,\n\t"name" string,\n\t"gen_name" string GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename table with composite primary key', async ({ dbc: db }) => {
+	const schema1 = {
+		table: cockroachTable('table1', {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => [primaryKey({ columns: [t.productId, t.categoryId] })]),
+	};
+	const schema2 = {
+		test: cockroachTable('table2', {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => [primaryKey({ columns: [t.productId, t.categoryId] })]),
+	};
+
+	const renames = ['public.table1->public.table2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = ['ALTER TABLE "table1" RENAME TO "table2";'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('push after migrate with custom migrations table #1', async ({ db }) => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/cockroach/migrator');
+	const { drizzle } = await import('drizzle-orm/cockroach');
+	await migrate(drizzle({ client: db.client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/cockroach/migrations',
+	});
+
+	const to = {
+		table: cockroachTable('table1', { col1: int4() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig, log: 'statements' });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" int4\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test.concurrent('push after migrate with custom migrations table #2', async ({ db }) => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/cockroach/migrator');
+	const { drizzle } = await import('drizzle-orm/cockroach');
+	await migrate(drizzle({ client: db.client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/cockroach/migrations',
+	});
+
+	const to = {
+		table: cockroachTable('table1', { col1: int4() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" int4\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test.concurrent('push after migrate with custom migrations table #3', async ({ db }) => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/cockroach/migrator');
+	const { drizzle } = await import('drizzle-orm/cockroach');
+	await migrate(drizzle({ client: db.client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/cockroach/migrations',
+	});
+
+	const to = {
+		table: cockroachTable('table1', { col1: int4() }),
+	};
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" int4\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test.concurrent('push after migrate with custom migrations table #4', async ({ db }) => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: 'migrations',
+	};
+	const { migrate } = await import('drizzle-orm/cockroach/migrator');
+	const { drizzle } = await import('drizzle-orm/cockroach');
+	await migrate(drizzle({ client: db.client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/cockroach/migrations',
+	});
+
+	const to = {
+		table: cockroachTable('table1', { col1: int4() }),
+	};
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" int4\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
diff --git a/drizzle-kit/tests/cockroach/views.test.ts b/drizzle-kit/tests/cockroach/views.test.ts
new file mode 100644
index 0000000000..14a406eaa6
--- /dev/null
+++ b/drizzle-kit/tests/cockroach/views.test.ts
@@ -0,0 +1,1157 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	int4,
+} from 'drizzle-orm/cockroach-core';
+import { expect } from 'vitest';
+import { diff, push, test } from './mocks';
+
+test.concurrent('create view', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: cockroachView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE VIEW "view" AS (select distinct "id" from "test");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and view #1', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: cockroachView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view" AS (select "id" from "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and view #2', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view" AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and view #5', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	// view_name_duplicate
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test.concurrent('create view with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+	};
+
+	const to = {
+		users: users,
+		view1: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create materialized view', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: cockroachMaterializedView('view')
+			.withNoData()
+			.as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE MATERIALIZED VIEW "view" AS (select distinct "id" from "test") WITH NO DATA;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and materialized view #1', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: cockroachMaterializedView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view" AS (select "id" from "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and materialized view #2', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view" AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and materialized view #3', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: cockroachMaterializedView('some_view1', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: cockroachMaterializedView('some_view2')
+			.withNoData().as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" int4 PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view1" AS (SELECT * FROM "users");`,
+		`CREATE MATERIALIZED VIEW "some_view2" AS (select "id" from "users") WITH NO DATA;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('create table and materialized view #4', async ({ db }) => {
+	// same names
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	// view_name_duplicate
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test.concurrent('create materialized view with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+	};
+
+	const to = {
+		users: users,
+		view1: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop view #1', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP VIEW "some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop view #2', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'DROP VIEW "view";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop view with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop view with data', async ({ db }) => {
+	const table = cockroachTable('table', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const seedStatements = [`INSERT INTO "table" ("id") VALUES (1), (2), (3)`];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({
+		db,
+		to: schema2,
+	});
+
+	// seeding
+	for (const seedSt of seedStatements) {
+		await db.query(seedSt);
+	}
+
+	const st0: string[] = [
+		`DROP VIEW "view";`,
+	];
+	const hints0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual(hints0);
+});
+
+test.concurrent('drop materialized view #1', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP MATERIALIZED VIEW "some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop materialized view #2', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'DROP MATERIALIZED VIEW "view";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop materialized view with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop materialized view with data', async ({ db }) => {
+	const table = cockroachTable('table', {
+		id: int4('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: cockroachMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.query(`INSERT INTO "table" ("id") VALUES (1), (2), (3)`);
+
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		`DROP MATERIALIZED VIEW "view";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(hints).toStrictEqual([]);
+});
+
+test.concurrent('drop materialized view without data', async ({ db }) => {
+	const table = cockroachTable('table', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		`DROP MATERIALIZED VIEW "view";`,
+	];
+	const hints0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual(hints0);
+});
+
+test.concurrent('rename view #1', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachView('new_some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER VIEW "some_view" RENAME TO "new_some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename view with existing flag', async ({ db }) => {
+	const from = {
+		view: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		view: cockroachView('new_some_view', { id: int4('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename materialized view #1', async ({ db }) => {
+	const from = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachMaterializedView('new_some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER MATERIALIZED VIEW "some_view" RENAME TO "new_some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('rename materialized view with existing flag', async ({ db }) => {
+	const from = {
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		view: cockroachMaterializedView('new_some_view', { id: int4('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('view alter schema', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: cockroachTable('users', { id: int4() }),
+		view: schema.view('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+		`ALTER VIEW "some_view" SET SCHEMA "new_schema";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('view alter schema with existing flag', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		view: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		schema,
+		view: schema.view('some_view', { id: int4('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('view alter schema for materialized', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: cockroachTable('users', { id: int4() }),
+		view: schema.materializedView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+		`ALTER MATERIALIZED VIEW "some_view" SET SCHEMA "new_schema";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('view alter schema for materialized with existing flag', async ({ db }) => {
+	const schema = cockroachSchema('new_schema');
+
+	const from = {
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		schema,
+		view: schema.materializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter view ".as" value', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`select * from users where id > 100`),
+	};
+
+	const to = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`select * from users where id > 101`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		'DROP VIEW "some_view";',
+		`CREATE VIEW "some_view" AS (select * from users where id > 101);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignored definition change
+});
+
+test.concurrent('alter view ".as" value with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('alter materialized view ".as" value', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT '123'`),
+	};
+
+	const to = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT '1234'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		'DROP MATERIALIZED VIEW "some_view";',
+		`CREATE MATERIALIZED VIEW "some_view" AS (SELECT '1234');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore definition changes for push
+});
+
+test.concurrent('alter materialized view ".as" value with existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop existing flag', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`CREATE MATERIALIZED VIEW "some_view" AS (SELECT 'asd');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('set existing - materialized', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('some_view', { id: int4('id') }).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: cockroachMaterializedView('new_some_view', { id: int4('id') }).withNoData().existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = ['DROP MATERIALIZED VIEW "some_view";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('drop existing - materialized', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachMaterializedView('view', { id: int4('id') }).existing(),
+	};
+
+	const to = {
+		users,
+		view: cockroachMaterializedView('view', { id: int4('id') }).withNoData().as(
+			sql`SELECT * FROM users WHERE id > 100`,
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE MATERIALIZED VIEW "view" AS (SELECT * FROM users WHERE id > 100) WITH NO DATA;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('set existing', async ({ db }) => {
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * from users where id > 100`),
+	};
+
+	const to = {
+		users,
+		view: cockroachView('new_some_view', { id: int4('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['DROP VIEW "some_view";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('moved schema', async ({ db }) => {
+	const schema = cockroachSchema('my_schema');
+	const from = {
+		schema,
+		users: cockroachTable('users', { id: int4() }),
+		view: cockroachView('some_view', { id: int4('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: cockroachTable('users', { id: int4() }),
+		view: schema.view('some_view', { id: int4('id') }).as(
+			sql`SELECT * FROM "users"`,
+		),
+	};
+
+	const renames = ['public.some_view->my_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		`ALTER VIEW "some_view" SET SCHEMA "my_schema";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test.concurrent('push view with same name', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: cockroachView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP VIEW "view";',
+		'CREATE VIEW "view" AS (select distinct "id" from "test" where "test"."id" = 1);',
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test.concurrent('push materialized view with same name', async ({ db }) => {
+	const table = cockroachTable('test', {
+		id: int4('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: cockroachMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: cockroachMaterializedView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP MATERIALIZED VIEW "view";',
+		'CREATE MATERIALIZED VIEW "view" AS (select distinct "id" from "test" where "test"."id" = 1);',
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4520
+test.concurrent(
+	'create 2 dependent materialized views',
+	async ({ db }) => {
+		const table1 = cockroachTable('table1', {
+			col1: int4(),
+			col2: int4(),
+			col3: int4(),
+		});
+		const accountBalancesPMMV = cockroachMaterializedView('accountBalancesPM').as(
+			(qb) => {
+				return qb
+					.select({
+						col1: table1.col1,
+						col2: table1.col2,
+						col3: table1.col3,
+					})
+					.from(table1);
+			},
+		);
+
+		const accountBalancesMV = cockroachMaterializedView('accountBalances').as(
+			(qb) =>
+				qb
+					.select({
+						accountId: accountBalancesPMMV.col1,
+					})
+					.from(accountBalancesPMMV),
+		);
+
+		const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+		const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+		const { sqlStatements: pst1 } = await push({ db, to: schema });
+		const expectedSt1 = [
+			'CREATE TABLE "table1" (\n\t"col1" int4,\n\t"col2" int4,\n\t"col3" int4\n);\n',
+			'CREATE MATERIALIZED VIEW "accountBalancesPM" AS (select "col1", "col2", "col3" from "table1");',
+			'CREATE MATERIALIZED VIEW "accountBalances" AS (select "col1" from "accountBalancesPM");',
+		];
+		expect(st1).toStrictEqual(expectedSt1);
+		expect(pst1).toStrictEqual(expectedSt1);
+
+		const { sqlStatements: st2 } = await diff(n1, schema, []);
+		const { sqlStatements: pst2 } = await push({ db, to: schema });
+		expect(st2).toStrictEqual([]);
+		expect(pst2).toStrictEqual([]);
+	},
+);
+
+test.concurrent('create 2 dependent views', async ({ db }) => {
+	const table1 = cockroachTable('table1', {
+		col1: int4(),
+		col2: int4(),
+		col3: int4(),
+	});
+	const accountBalancesPMMV = cockroachView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = cockroachView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"col1" int4,\n\t"col2" int4,\n\t"col3" int4\n);\n',
+		'CREATE VIEW "accountBalancesPM" AS (select "col1", "col2", "col3" from "table1");',
+		'CREATE VIEW "accountBalances" AS (select "col1" from "accountBalancesPM");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/common.ts b/drizzle-kit/tests/common.ts
deleted file mode 100644
index 631614218b..0000000000
--- a/drizzle-kit/tests/common.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { test } from 'vitest';
-
-export interface DialectSuite {
-	/**
-	 * 1 statement | create column:
-	 *
-	 * id int primary key autoincrement
-	 */
-	columns1(): Promise<void>;
-}
-
-export const run = (suite: DialectSuite) => {
-	test('add columns #1', suite.columns1);
-};
-// test("add columns #1", suite.columns1)
diff --git a/drizzle-kit/tests/fixtures/tsconfig-paths/drizzle.config.ts b/drizzle-kit/tests/fixtures/tsconfig-paths/drizzle.config.ts
new file mode 100644
index 0000000000..e235722dbc
--- /dev/null
+++ b/drizzle-kit/tests/fixtures/tsconfig-paths/drizzle.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from '../../../src';
+
+export default defineConfig({
+	schema: './entry.ts',
+	dialect: 'postgresql',
+	dbCredentials: {
+		url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+	},
+});
diff --git a/drizzle-kit/tests/fixtures/tsconfig-paths/entry.ts b/drizzle-kit/tests/fixtures/tsconfig-paths/entry.ts
new file mode 100644
index 0000000000..a5a6cc3b15
--- /dev/null
+++ b/drizzle-kit/tests/fixtures/tsconfig-paths/entry.ts
@@ -0,0 +1,2 @@
+export * from './src/profile/schema';
+export * from './src/user/schema';
diff --git a/drizzle-kit/tests/fixtures/tsconfig-paths/src/profile/schema.ts b/drizzle-kit/tests/fixtures/tsconfig-paths/src/profile/schema.ts
new file mode 100644
index 0000000000..5351859d91
--- /dev/null
+++ b/drizzle-kit/tests/fixtures/tsconfig-paths/src/profile/schema.ts
@@ -0,0 +1,5 @@
+import { pgTable } from 'drizzle-orm/pg-core';
+
+export const profile = pgTable('profile', (t) => ({
+	id: t.integer().primaryKey().generatedAlwaysAsIdentity(),
+}));
diff --git a/drizzle-kit/tests/fixtures/tsconfig-paths/src/user/schema.ts b/drizzle-kit/tests/fixtures/tsconfig-paths/src/user/schema.ts
new file mode 100644
index 0000000000..7b75588ca2
--- /dev/null
+++ b/drizzle-kit/tests/fixtures/tsconfig-paths/src/user/schema.ts
@@ -0,0 +1,15 @@
+import { profile } from '@/profile/schema';
+import { profile as profileAlias } from '@profile';
+import { pgTable } from 'drizzle-orm/pg-core';
+
+export const user = pgTable('user', (t) => ({
+	id: t.integer().primaryKey().generatedAlwaysAsIdentity(),
+	profileId: t
+		.integer()
+		.unique()
+		.references(() => profile.id)
+		.notNull(),
+	profileAliasId: t
+		.integer()
+		.references(() => profileAlias.id),
+}));
diff --git a/drizzle-kit/tests/fixtures/tsconfig-paths/tsconfig.json b/drizzle-kit/tests/fixtures/tsconfig-paths/tsconfig.json
new file mode 100644
index 0000000000..aad9cace19
--- /dev/null
+++ b/drizzle-kit/tests/fixtures/tsconfig-paths/tsconfig.json
@@ -0,0 +1,9 @@
+{
+	"compilerOptions": {
+		"baseUrl": ".",
+		"paths": {
+			"@/*": ["src/*"],
+			"@profile": ["src/profile/schema.ts"]
+		}
+	}
+}
diff --git a/drizzle-kit/tests/indexes/common.ts b/drizzle-kit/tests/indexes/common.ts
deleted file mode 100644
index 5bdc244465..0000000000
--- a/drizzle-kit/tests/indexes/common.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { afterAll, beforeAll, test } from 'vitest';
-
-export interface DialectSuite {
-	simpleIndex(context?: any): Promise<void>;
-	vectorIndex(context?: any): Promise<void>;
-	indexesToBeTriggered(context?: any): Promise<void>;
-}
-
-export const run = (
-	suite: DialectSuite,
-	beforeAllFn?: (context: any) => Promise<void>,
-	afterAllFn?: (context: any) => Promise<void>,
-) => {
-	let context: any = {};
-	beforeAll(beforeAllFn ? () => beforeAllFn(context) : () => {});
-	test('index #1: simple index', () => suite.simpleIndex(context));
-	test('index #2: vector index', () => suite.vectorIndex(context));
-	test('index #3: fields that should be triggered on generate and not triggered on push', () =>
-		suite.indexesToBeTriggered(context));
-	afterAll(afterAllFn ? () => afterAllFn(context) : () => {});
-};
diff --git a/drizzle-kit/tests/indexes/pg.test.ts b/drizzle-kit/tests/indexes/pg.test.ts
deleted file mode 100644
index 57f77c103a..0000000000
--- a/drizzle-kit/tests/indexes/pg.test.ts
+++ /dev/null
@@ -1,245 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { index, pgTable, serial, text, vector } from 'drizzle-orm/pg-core';
-import { JsonCreateIndexStatement } from 'src/jsonStatements';
-import { PgSquasher } from 'src/serializer/pgSchema';
-import { diffTestSchemas } from 'tests/schemaDiffer';
-import { expect } from 'vitest';
-import { DialectSuite, run } from './common';
-
-const pgSuite: DialectSuite = {
-	async vectorIndex() {
-		const schema1 = {
-			users: pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: vector('name', { dimensions: 3 }),
-			}),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					embedding: vector('name', { dimensions: 3 }),
-				},
-				(t) => ({
-					indx2: index('vector_embedding_idx')
-						.using('hnsw', t.embedding.op('vector_ip_ops'))
-						.with({ m: 16, ef_construction: 64 }),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemas(
-			schema1,
-			schema2,
-			[],
-		);
-
-		expect(statements.length).toBe(1);
-		expect(statements[0]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'create_index_pg',
-			data: {
-				columns: [
-					{
-						asc: true,
-						expression: 'name',
-						isExpression: false,
-						nulls: 'last',
-						opclass: 'vector_ip_ops',
-					},
-				],
-				concurrently: false,
-				isUnique: false,
-				method: 'hnsw',
-				name: 'vector_embedding_idx',
-				where: undefined,
-				with: {
-					ef_construction: 64,
-					m: 16,
-				},
-			},
-		});
-		expect(sqlStatements.length).toBe(1);
-		expect(sqlStatements[0]).toBe(
-			`CREATE INDEX "vector_embedding_idx" ON "users" USING hnsw ("name" vector_ip_ops) WITH (m=16,ef_construction=64);`,
-		);
-	},
-
-	async indexesToBeTriggered() {
-		const schema1 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index('indx').on(t.name.desc()).concurrently(),
-					indx1: index('indx1')
-						.on(t.name.desc())
-						.where(sql`true`),
-					indx2: index('indx2')
-						.on(t.name.op('text_ops'))
-						.where(sql`true`),
-					indx3: index('indx3')
-						.on(sql`lower(name)`)
-						.where(sql`true`),
-				}),
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index('indx').on(t.name.desc()),
-					indx1: index('indx1')
-						.on(t.name.desc())
-						.where(sql`false`),
-					indx2: index('indx2')
-						.on(t.name.op('test'))
-						.where(sql`true`),
-					indx3: index('indx3')
-						.on(sql`lower(${t.id})`)
-						.where(sql`true`),
-					indx4: index('indx4')
-						.on(sql`lower(id)`)
-						.where(sql`true`),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemas(
-			schema1,
-			schema2,
-			[],
-		);
-
-		expect(sqlStatements).toStrictEqual([
-			'DROP INDEX "indx";',
-			'DROP INDEX "indx1";',
-			'DROP INDEX "indx2";',
-			'DROP INDEX "indx3";',
-			'CREATE INDEX "indx4" ON "users" USING btree (lower(id)) WHERE true;',
-			'CREATE INDEX "indx" ON "users" USING btree ("name" DESC NULLS LAST);',
-			'CREATE INDEX "indx1" ON "users" USING btree ("name" DESC NULLS LAST) WHERE false;',
-			'CREATE INDEX "indx2" ON "users" USING btree ("name" test) WHERE true;',
-			'CREATE INDEX "indx3" ON "users" USING btree (lower("id")) WHERE true;',
-		]);
-	},
-
-	async simpleIndex() {
-		const schema1 = {
-			users: pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			}),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index()
-						.on(t.name.desc(), t.id.asc().nullsLast())
-						.with({ fillfactor: 70 })
-						.where(sql`select 1`),
-					indx1: index('indx1')
-						.using('hash', t.name.desc(), sql`${t.name}`)
-						.with({ fillfactor: 70 }),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemas(
-			schema1,
-			schema2,
-			[],
-		);
-
-		expect(statements.length).toBe(2);
-		expect(statements[0]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'create_index_pg',
-			data: {
-				columns: [
-					{
-						asc: false,
-						expression: 'name',
-						isExpression: false,
-						nulls: 'last',
-						opclass: '',
-					},
-					{
-						asc: true,
-						expression: 'id',
-						isExpression: false,
-						nulls: 'last',
-						opclass: '',
-					},
-				],
-				concurrently: false,
-				isUnique: false,
-				method: 'btree',
-				name: 'users_name_id_index',
-				where: 'select 1',
-				with: {
-					fillfactor: 70,
-				},
-			},
-			// data: 'users_name_id_index;name,false,last,undefined,,id,true,last,undefined;false;false;btree;select 1;{"fillfactor":70}',
-		});
-		expect(statements[1]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'create_index_pg',
-			data: {
-				columns: [
-					{
-						asc: false,
-						expression: 'name',
-						isExpression: false,
-						nulls: 'last',
-						opclass: '',
-					},
-					{
-						asc: true,
-						expression: '"name"',
-						isExpression: true,
-						nulls: 'last',
-						opclass: '',
-					},
-				],
-				concurrently: false,
-				isUnique: false,
-				method: 'hash',
-				name: 'indx1',
-				where: undefined,
-				with: {
-					fillfactor: 70,
-				},
-			},
-		});
-		expect(sqlStatements.length).toBe(2);
-		expect(sqlStatements[0]).toBe(
-			`CREATE INDEX "users_name_id_index" ON "users" USING btree ("name" DESC NULLS LAST,"id") WITH (fillfactor=70) WHERE select 1;`,
-		);
-		expect(sqlStatements[1]).toBe(
-			`CREATE INDEX "indx1" ON "users" USING hash ("name" DESC NULLS LAST,"name") WITH (fillfactor=70);`,
-		);
-	},
-};
-
-run(pgSuite);
diff --git a/drizzle-kit/tests/introspect/gel.ext.test.ts b/drizzle-kit/tests/introspect/gel.ext.test.ts
deleted file mode 100644
index 894064f9de..0000000000
--- a/drizzle-kit/tests/introspect/gel.ext.test.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import Docker from 'dockerode';
-import { drizzle, GelJsDatabase } from 'drizzle-orm/gel';
-import fs from 'fs';
-import createClient, { type Client } from 'gel';
-import getPort from 'get-port';
-import { introspectGelToFile } from 'tests/schemaDiffer';
-import { v4 as uuidV4 } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
-import 'zx/globals';
-
-if (!fs.existsSync('tests/introspect/gel')) {
-	fs.mkdirSync('tests/introspect/gel');
-}
-
-$.quiet = true;
-
-const ENABLE_LOGGING = false;
-
-let client: Client;
-let db: GelJsDatabase;
-const tlsSecurity: string = 'insecure';
-let dsn: string;
-let container: Docker.Container | undefined;
-
-async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5656 });
-	const image = 'geldata/gel:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	const gelContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'GEL_CLIENT_SECURITY=insecure_dev_mode',
-			'GEL_SERVER_SECURITY=insecure_dev_mode',
-			'GEL_CLIENT_TLS_SECURITY=no_host_verification',
-			'GEL_SERVER_PASSWORD=password',
-		],
-		name: `drizzle-integration-tests-${uuidV4()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5656/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await gelContainer.start();
-
-	return { connectionString: `gel://admin:password@localhost:${port}/main`, container: gelContainer };
-}
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['GEL_CONNECTION_STRING']) {
-		connectionString = process.env['GEL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-
-	await sleep(15 * 1000);
-	client = createClient({ dsn: connectionString, tlsSecurity: 'insecure' });
-
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-
-	dsn = connectionString;
-});
-
-afterAll(async () => {
-	await client?.close().catch(console.error);
-	await container?.stop().catch(console.error);
-});
-
-test('basic introspect test', async () => {
-	await $`pnpm gel query 'CREATE EXTENSION pgcrypto VERSION "1.3";
-  CREATE EXTENSION auth VERSION "1.0";
-  CREATE TYPE default::User {
-      CREATE REQUIRED LINK identity: ext::auth::Identity;
-      CREATE REQUIRED PROPERTY email: std::str;
-      CREATE REQUIRED PROPERTY username: std::str;
-  };
-  CREATE GLOBAL default::current_user := (std::assert_single((SELECT
-      default::User {
-          id,
-          username,
-          email
-      }
-  FILTER
-      (.identity = GLOBAL ext::auth::ClientTokenIdentity)
-  )));' --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-	const path = await introspectGelToFile(
-		client,
-		'basic-ext-introspect',
-		['ext::auth', 'public'],
-	);
-
-	const result = await $`pnpm exec tsc --noEmit --skipLibCheck ${path}`.nothrow(true);
-	expect(result.exitCode).toBe(0);
-	fs.rmSync(path);
-});
diff --git a/drizzle-kit/tests/introspect/gel.test.ts b/drizzle-kit/tests/introspect/gel.test.ts
deleted file mode 100644
index 9c9d95fc56..0000000000
--- a/drizzle-kit/tests/introspect/gel.test.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-import Docker from 'dockerode';
-import { drizzle, GelJsDatabase } from 'drizzle-orm/gel';
-import fs from 'fs';
-import createClient, { type Client } from 'gel';
-import getPort from 'get-port';
-import { introspectGelToFile } from 'tests/schemaDiffer';
-import { v4 as uuidV4 } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
-import 'zx/globals';
-
-if (!fs.existsSync('tests/introspect/gel')) {
-	fs.mkdirSync('tests/introspect/gel');
-}
-
-$.quiet = true;
-
-const ENABLE_LOGGING = false;
-
-let client: Client;
-let db: GelJsDatabase;
-const tlsSecurity: string = 'insecure';
-let dsn: string;
-let container: Docker.Container | undefined;
-
-async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5656 });
-	const image = 'geldata/gel:6.0';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	const gelContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'GEL_CLIENT_SECURITY=insecure_dev_mode',
-			'GEL_SERVER_SECURITY=insecure_dev_mode',
-			'GEL_CLIENT_TLS_SECURITY=no_host_verification',
-			'GEL_SERVER_PASSWORD=password',
-		],
-		name: `drizzle-integration-tests-${uuidV4()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5656/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await gelContainer.start();
-
-	return { connectionString: `gel://admin:password@localhost:${port}/main`, container: gelContainer };
-}
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['GEL_CONNECTION_STRING']) {
-		connectionString = process.env['GEL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-
-	await sleep(15 * 1000);
-	client = createClient({ dsn: connectionString, tlsSecurity: 'insecure' });
-
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-
-	dsn = connectionString;
-});
-
-afterAll(async () => {
-	await client?.close().catch(console.error);
-	await container?.stop().catch(console.error);
-});
-
-test('basic introspect test', async () => {
-	await $`pnpm gel query 'CREATE TYPE default::all_columns {
-
-		create property stringColumn: str;
-		create required property requiredStringColumn: str;
-		create required property arrayRequiredStringColumn: array<str>;
-		create property defaultStringColumn: str {
-			SET DEFAULT := "name";
-		};
-
-		create property boolColumn:bool;
-		create required property requiredBoolColumn: bool;
-		create required property arrayRequiredBoolColumn: array<bool>;
-		create property defaultBoolColumn: bool {
-			SET DEFAULT := true;
-		};
-
-		create property int16Column:int16;
-		create required property requiredint16Column: int16;
-		create required property arrayRequiredint16Column: array<int16>;
-		create property defaultint16Column: int16 {
-			SET DEFAULT := 123;
-		};
-
-		create property int32Column:int32;
-		create required property requiredint32Column: int32;
-		create required property arrayRequiredint32Column: array<int32>;
-		create property defaultint32Column: int32 {
-			SET DEFAULT := 123;
-		};
-
-		create property int64Column:int64;
-		create required property requiredint64Column: int64;
-		create required property arrayRequiredint64Column: array<int64>;
-		create property defaultint64Column: int64 {
-			SET DEFAULT := 123;
-		};
-
-		create property float32Column:float32;
-		create required property requiredfloat32Column: float32;
-		create required property arrayRequiredfloat32Column: array<float32>;
-		create property defaultfloat32Column: float32 {
-			SET DEFAULT := 123.123;
-		};
-
-		create property float64Column:float64;
-		create required property requiredfloat64Column: float64;
-		create required property arrayRequiredfloat64Column: array<float64>;
-		create property defaultfloat64Column: float64 {
-			SET DEFAULT := 123.123;
-		};
-
-		create property bigintColumn:bigint;
-		create required property requiredbigintColumn: bigint;
-		create required property arrayRequiredbigintColumn: array<bigint>;
-		create property defaultbigintColumn: bigint {
-			SET DEFAULT := 123n;
-		};
-
-		create property decimalColumn:decimal;
-		create required property requireddecimalColumn: decimal;
-		create required property arrayRequireddecimalColumn: array<decimal>;
-		create property defaultdecimalColumn: decimal {
-			SET DEFAULT := 1.23n;
-		};
-
-		create property uuidColumn:uuid;
-		create required property requireduuidColumn: uuid;
-		create required property arrayRequireduuidColumn: array<uuid>;
-		create property defaultuuidColumn: uuid {
-			SET DEFAULT := uuid_generate_v4();
-		};
-
-		create property jsonColumn:json;
-		create required property requiredjsonColumn: json;
-		create required property arrayRequiredjsonColumn: array<json>;
-		create property defaultjsonColumn: json {
-			SET DEFAULT := <json>[1, 2];
-		};
-
-		create property datetimeColumn:datetime;
-		create required property requireddatetimeColumn: datetime;
-		create required property arrayRequireddatetimeColumn: array<datetime>;
-		create property defaultdatetimeColumn: datetime {
-			SET DEFAULT := <std::datetime>"2018-05-07T15:01:22.306916+00";
-		};
-
-		create property local_datetimeColumn:cal::local_datetime;
-		create required property requiredlocal_datetimeColumn: cal::local_datetime;
-		create required property arrayRequiredlocal_datetimeColumn: array<cal::local_datetime>;
-		create property defaultlocal_datetimeColumn: cal::local_datetime {
-			SET DEFAULT := <cal::local_datetime>"2018-05-07T15:01:22.306916";
-		};
-
-		create property local_dateColumn:cal::local_date;
-		create required property requiredlocal_dateColumn: cal::local_date;
-		create required property arrayRequiredlocal_dateColumn: array<cal::local_date>;
-		create property defaultlocal_dateColumn: cal::local_date {
-			SET DEFAULT := <cal::local_date>"2018-05-07";
-		};
-
-		create property local_timeColumn:cal::local_time;
-		create required property requiredlocal_timeColumn: cal::local_time;
-		create required property arrayRequiredlocal_timeColumn: array<cal::local_time>;
-		create property defaultlocal_timeColumn: cal::local_time {
-			SET DEFAULT := <cal::local_time>"15:01:22.306916";
-		};
-
-		create property durationColumn:duration;
-		create required property requireddurationColumn: duration;
-		create required property arrayRequireddurationColumn: array<duration>;
-		create property defaultdurationColumn: duration {
-			SET DEFAULT := <duration>"45.6 seconds";
-		};
-
-		create property relative_durationColumn:cal::relative_duration;
-		create required property requiredrelative_durationColumn: cal::relative_duration;
-		create required property arrayRequiredrelative_durationColumn: array<cal::relative_duration>;
-		create property defaultrelative_durationColumn: cal::relative_duration {
-			SET DEFAULT := <cal::relative_duration>"1 year";
-		};
-
-		create property dateDurationColumn:cal::date_duration;
-		create required property requireddate_durationColumn: cal::date_duration;
-		create required property arrayRequireddate_durationColumn: array<cal::date_duration>;
-		create property defaultdate_durationColumn: cal::date_duration {
-			SET DEFAULT := <cal::date_duration>"5 days";
-		};
-
-		create property bytesColumn:bytes;
-		create required property requiredbytesColumn:bytes;
-		create required property arrayRequiredbytesColumn: array<bytes>;
-		create property defaultbytesColumn: bytes {
-			SET DEFAULT := b"Hello, world";
-		};
-	}' --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-	const path = await introspectGelToFile(
-		client,
-		'basic-introspect',
-	);
-
-	const result = await $`pnpm exec tsc --noEmit --skipLibCheck ${path}`.nothrow(true);
-	expect(result.exitCode).toBe(0);
-	fs.rmSync(path);
-});
diff --git a/drizzle-kit/tests/introspect/libsql.test.ts b/drizzle-kit/tests/introspect/libsql.test.ts
deleted file mode 100644
index 9211989cae..0000000000
--- a/drizzle-kit/tests/introspect/libsql.test.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { createClient } from '@libsql/client';
-import { sql } from 'drizzle-orm';
-import { int, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
-import fs from 'fs';
-import { introspectLibSQLToFile, introspectMySQLToFile, introspectSQLiteToFile } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-if (!fs.existsSync('tests/introspect/libsql')) {
-	fs.mkdirSync('tests/introspect/libsql');
-}
-
-test('view #1', async () => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const users = sqliteTable('users', { id: int('id') });
-	const testView = sqliteView('some_view', { id: int('id') }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectLibSQLToFile(
-		turso,
-		schema,
-		'view-1',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/introspect/mysql.test.ts b/drizzle-kit/tests/introspect/mysql.test.ts
deleted file mode 100644
index 2db33416ba..0000000000
--- a/drizzle-kit/tests/introspect/mysql.test.ts
+++ /dev/null
@@ -1,319 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { SQL, sql } from 'drizzle-orm';
-import {
-	bigint,
-	char,
-	check,
-	decimal,
-	double,
-	float,
-	int,
-	mediumint,
-	mysqlEnum,
-	mysqlTable,
-	mysqlView,
-	serial,
-	smallint,
-	text,
-	tinyint,
-	varchar,
-} from 'drizzle-orm/mysql-core';
-import * as fs from 'fs';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { introspectMySQLToFile } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-
-let client: Connection;
-let mysqlContainer: Docker.Container;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env.MYSQL_CONNECTION_STRING ?? await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
-});
-
-beforeEach(async () => {
-	await client.query(`drop database if exists \`drizzle\`;`);
-	await client.query(`create database \`drizzle\`;`);
-	await client.query(`use \`drizzle\`;`);
-});
-
-if (!fs.existsSync('tests/introspect/mysql')) {
-	fs.mkdirSync('tests/introspect/mysql');
-}
-
-test('generated always column: link to another column', async () => {
-	const schema = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'generated-link-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('generated always column virtual: link to another column', async () => {
-	const schema = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'generated-link-column-virtual',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('Default value of character type column: char', async () => {
-	const schema = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			sortKey: char('sortKey', { length: 255 }).default('0'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'default-value-char-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('Default value of character type column: varchar', async () => {
-	const schema = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			sortKey: varchar('sortKey', { length: 255 }).default('0'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'default-value-varchar-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect checks', async () => {
-	const schema = {
-		users: mysqlTable('users', {
-			id: serial('id'),
-			name: varchar('name', { length: 255 }),
-			age: int('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'introspect-checks',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('view #1', async () => {
-	const users = mysqlTable('users', { id: int('id') });
-	const testView = mysqlView('some_view', { id: int('id') }).as(
-		sql`select \`drizzle\`.\`users\`.\`id\` AS \`id\` from \`drizzle\`.\`users\``,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'view-1',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('view #2', async () => {
-	const users = mysqlTable('some_users', { id: int('id') });
-	const testView = mysqlView('some_view', { id: int('id') }).algorithm('temptable').sqlSecurity('definer').as(
-		sql`SELECT * FROM ${users}`,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'view-2',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('handle float type', async () => {
-	const schema = {
-		table: mysqlTable('table', {
-			col1: float(),
-			col2: float({ precision: 2 }),
-			col3: float({ precision: 2, scale: 1 }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'handle-float-type',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('handle unsigned numerical types', async () => {
-	const schema = {
-		table: mysqlTable('table', {
-			col1: int({ unsigned: true }),
-			col2: tinyint({ unsigned: true }),
-			col3: smallint({ unsigned: true }),
-			col4: mediumint({ unsigned: true }),
-			col5: bigint({ mode: 'number', unsigned: true }),
-			col6: float({ unsigned: true }),
-			col7: float({ precision: 2, scale: 1, unsigned: true }),
-			col8: double({ unsigned: true }),
-			col9: double({ precision: 2, scale: 1, unsigned: true }),
-			col10: decimal({ unsigned: true }),
-			col11: decimal({ precision: 2, scale: 1, unsigned: true }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'handle-unsigned-numerical-types',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('instrospect strings with single quotes', async () => {
-	const schema = {
-		columns: mysqlTable('columns', {
-			enum: mysqlEnum('my_enum', ['escape\'s quotes "', 'escape\'s quotes 2 "']).default('escape\'s quotes "'),
-			text: text('text').default('escape\'s quotes " '),
-			varchar: varchar('varchar', { length: 255 }).default('escape\'s quotes " '),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectMySQLToFile(
-		client,
-		schema,
-		'introspect-strings-with-single-quotes',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-
-	await client.query(`drop table columns;`);
-});
diff --git a/drizzle-kit/tests/introspect/pg.test.ts b/drizzle-kit/tests/introspect/pg.test.ts
deleted file mode 100644
index e89b212aec..0000000000
--- a/drizzle-kit/tests/introspect/pg.test.ts
+++ /dev/null
@@ -1,928 +0,0 @@
-import { PGlite } from '@electric-sql/pglite';
-import { SQL, sql } from 'drizzle-orm';
-import {
-	bigint,
-	bigserial,
-	boolean,
-	char,
-	check,
-	cidr,
-	date,
-	doublePrecision,
-	index,
-	inet,
-	integer,
-	interval,
-	json,
-	jsonb,
-	macaddr,
-	macaddr8,
-	numeric,
-	pgEnum,
-	pgMaterializedView,
-	pgPolicy,
-	pgRole,
-	pgSchema,
-	pgTable,
-	pgView,
-	real,
-	serial,
-	smallint,
-	smallserial,
-	text,
-	time,
-	timestamp,
-	uuid,
-	varchar,
-} from 'drizzle-orm/pg-core';
-import fs from 'fs';
-import { introspectPgToFile } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-if (!fs.existsSync('tests/introspect/postgres')) {
-	fs.mkdirSync('tests/introspect/postgres');
-}
-
-test('basic introspect test', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').notNull(),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic identity always test', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity(),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-identity-always-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic identity by default test', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-identity-default-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic index test', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			firstName: text('first_name'),
-			lastName: text('last_name'),
-			data: jsonb('data'),
-		}, (table) => ({
-			singleColumn: index('single_column').on(table.firstName),
-			multiColumn: index('multi_column').on(table.firstName, table.lastName),
-			singleExpression: index('single_expression').on(sql`lower(${table.firstName})`),
-			multiExpression: index('multi_expression').on(sql`lower(${table.firstName})`, sql`lower(${table.lastName})`),
-			expressionWithComma: index('expression_with_comma').on(
-				sql`(lower(${table.firstName}) || ', '::text || lower(${table.lastName}))`,
-			),
-			expressionWithDoubleQuote: index('expression_with_double_quote').on(sql`('"'::text || ${table.firstName})`),
-			expressionWithJsonbOperator: index('expression_with_jsonb_operator').on(
-				sql`(${table.data} #>> '{a,b,1}'::text[])`,
-			),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-index-introspect',
-	);
-
-	expect(statements.length).toBe(10);
-	expect(sqlStatements.length).toBe(10);
-});
-
-test('identity always test: few params', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity({
-				startWith: 100,
-				name: 'custom_name',
-			}),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'identity-always-few-params-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('identity by default test: few params', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				maxValue: 10000,
-				name: 'custom_name',
-			}),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'identity-default-few-params-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('identity always test: all params', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity({
-				startWith: 10,
-				increment: 4,
-				minValue: 10,
-				maxValue: 10000,
-				cache: 100,
-				cycle: true,
-			}),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'identity-always-all-params-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('identity by default test: all params', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 10,
-				increment: 4,
-				minValue: 10,
-				maxValue: 10000,
-				cache: 100,
-				cycle: true,
-			}),
-			email: text('email'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'identity-default-all-params-introspect',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('generated column: link to another column', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity(),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`email`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'generated-link-column',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('instrospect all column types', async () => {
-	const client = new PGlite();
-
-	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
-	const schema = {
-		enum_: myEnum,
-		// NOTE: Types from extensions aren't tested due to PGlite not supporting at the moment
-		columns: pgTable('columns', {
-			enum: myEnum('my_enum').default('a'),
-			smallint: smallint('smallint').default(10),
-			integer: integer('integer').default(10),
-			numeric: numeric('numeric', { precision: 3, scale: 1 }).default('99.9'),
-			numeric2: numeric('numeric2', { precision: 1, scale: 1 }).default('99.9'),
-			numeric3: numeric('numeric3').default('99.9'),
-			bigint: bigint('bigint', { mode: 'number' }).default(100),
-			boolean: boolean('boolean').default(true),
-			text: text('test').default('abc'),
-			varchar: varchar('varchar', { length: 25 }).default('abc'),
-			char: char('char', { length: 3 }).default('abc'),
-			serial: serial('serial'),
-			bigserial: bigserial('bigserial', { mode: 'number' }),
-			smallserial: smallserial('smallserial'),
-			doublePrecision: doublePrecision('doublePrecision').default(100),
-			real: real('real').default(100),
-			json: json('json').$type<{ attr: string }>().default({ attr: 'value' }),
-			jsonb: jsonb('jsonb').$type<{ attr: string }>().default({ attr: 'value' }),
-			time1: time('time1').default('00:00:00'),
-			time2: time('time2').defaultNow(),
-			timestamp1: timestamp('timestamp1', { withTimezone: true, precision: 6 }).default(new Date()),
-			timestamp2: timestamp('timestamp2', { withTimezone: true, precision: 6 }).defaultNow(),
-			timestamp3: timestamp('timestamp3', { withTimezone: true, precision: 6 }).default(
-				sql`timezone('utc'::text, now())`,
-			),
-			date1: date('date1').default('2024-01-01'),
-			date2: date('date2').defaultNow(),
-			date3: date('date3').default(sql`CURRENT_TIMESTAMP`),
-			uuid1: uuid('uuid1').default('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'),
-			uuid2: uuid('uuid2').defaultRandom(),
-			inet: inet('inet').default('127.0.0.1'),
-			cidr: cidr('cidr').default('127.0.0.1/32'),
-			macaddr: macaddr('macaddr').default('00:00:00:00:00:00'),
-			macaddr8: macaddr8('macaddr8').default('00:00:00:ff:fe:00:00:00'),
-			interval: interval('interval').default('1 day 01:00:00'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-all-columns-types',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('instrospect all column array types', async () => {
-	const client = new PGlite();
-
-	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
-	const schema = {
-		enum_: myEnum,
-		// NOTE: Types from extensions aren't tested due to PGlite not supporting at the moment
-		columns: pgTable('columns', {
-			enum: myEnum('my_enum').array().default(['a', 'b']),
-			smallint: smallint('smallint').array().default([10, 20]),
-			integer: integer('integer').array().default([10, 20]),
-			numeric: numeric('numeric', { precision: 3, scale: 1 }).array().default(['99.9', '88.8']),
-			bigint: bigint('bigint', { mode: 'number' }).array().default([100, 200]),
-			boolean: boolean('boolean').array().default([true, false]),
-			text: text('test').array().default(['abc', 'def']),
-			varchar: varchar('varchar', { length: 25 }).array().default(['abc', 'def']),
-			char: char('char', { length: 3 }).array().default(['abc', 'def']),
-			doublePrecision: doublePrecision('doublePrecision').array().default([100, 200]),
-			real: real('real').array().default([100, 200]),
-			json: json('json').$type<{ attr: string }>().array().default([{ attr: 'value1' }, { attr: 'value2' }]),
-			jsonb: jsonb('jsonb').$type<{ attr: string }>().array().default([{ attr: 'value1' }, { attr: 'value2' }]),
-			time: time('time').array().default(['00:00:00', '01:00:00']),
-			timestamp: timestamp('timestamp', { withTimezone: true, precision: 6 })
-				.array()
-				.default([new Date(), new Date()]),
-			date: date('date').array().default(['2024-01-01', '2024-01-02']),
-			uuid: uuid('uuid').array().default([
-				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
-				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12',
-			]),
-			inet: inet('inet').array().default(['127.0.0.1', '127.0.0.2']),
-			cidr: cidr('cidr').array().default(['127.0.0.1/32', '127.0.0.2/32']),
-			macaddr: macaddr('macaddr').array().default(['00:00:00:00:00:00', '00:00:00:00:00:01']),
-			macaddr8: macaddr8('macaddr8').array().default(['00:00:00:ff:fe:00:00:00', '00:00:00:ff:fe:00:00:01']),
-			interval: interval('interval').array().default(['1 day 01:00:00', '1 day 02:00:00']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-all-columns-array-types',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect columns with name with non-alphanumeric characters', async () => {
-	const client = new PGlite();
-	const schema = {
-		users: pgTable('users', {
-			'not:allowed': integer('not:allowed'),
-			'nuh--uh': integer('nuh-uh'),
-			'1_nope': integer('1_nope'),
-			valid: integer('valid'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-column-with-name-with-non-alphanumeric-characters',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect enum from different schema', async () => {
-	const client = new PGlite();
-
-	const schema2 = pgSchema('schema2');
-	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
-	const schema = {
-		schema2,
-		myEnumInSchema2,
-		users: pgTable('users', {
-			col: myEnumInSchema2('col'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-enum-from-different-schema',
-		['public', 'schema2'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect enum with same names across different schema', async () => {
-	const client = new PGlite();
-
-	const schema2 = pgSchema('schema2');
-	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
-	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
-	const schema = {
-		schema2,
-		myEnumInSchema2,
-		myEnum,
-		users: pgTable('users', {
-			col1: myEnumInSchema2('col1'),
-			col2: myEnum('col2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-enum-with-same-names-across-different-schema',
-		['public', 'schema2'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect enum with similar name to native type', async () => {
-	const client = new PGlite();
-
-	const timeLeft = pgEnum('time_left', ['short', 'medium', 'long']);
-	const schema = {
-		timeLeft,
-		auction: pgTable('auction', {
-			col: timeLeft('col1'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-enum-with-similar-name-to-native-type',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('instrospect strings with single quotes', async () => {
-	const client = new PGlite();
-
-	const myEnum = pgEnum('my_enum', ['escape\'s quotes " ']);
-	const schema = {
-		enum_: myEnum,
-		columns: pgTable('columns', {
-			enum: myEnum('my_enum').default('escape\'s quotes " '),
-			text: text('text').default('escape\'s quotes " '),
-			varchar: varchar('varchar').default('escape\'s quotes " '),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-strings-with-single-quotes',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect checks', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: serial('id'),
-			name: varchar('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-checks',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect checks from different schemas with same names', async () => {
-	const client = new PGlite();
-
-	const mySchema = pgSchema('schema2');
-	const schema = {
-		mySchema,
-		users: pgTable('users', {
-			id: serial('id'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-		usersInMySchema: mySchema.table('users', {
-			id: serial('id'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} < 1`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-checks-diff-schema-same-names',
-		['public', 'schema2'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect view #1', async () => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = pgView('some_view').as((qb) => qb.select().from(users));
-	const schema = {
-		view,
-		users,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-view',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect view #2', async () => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = pgView('some_view', { id: integer('asd') }).with({ checkOption: 'cascaded' }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-	const schema = {
-		view,
-		users,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-view-2',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect view in other schema', async () => {
-	const client = new PGlite();
-
-	const newSchema = pgSchema('new_schema');
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = newSchema.view('some_view', { id: integer('asd') }).with({ checkOption: 'cascaded' }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-	const schema = {
-		view,
-		users,
-		newSchema,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-view-in-other-schema',
-		['new_schema'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect materialized view in other schema', async () => {
-	const client = new PGlite();
-
-	const newSchema = pgSchema('new_schema');
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = newSchema.materializedView('some_view', { id: integer('asd') }).with({ autovacuumEnabled: true }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-	const schema = {
-		view,
-		users,
-		newSchema,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-mat-view-in-other-schema',
-		['new_schema'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect materialized view #1', async () => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = pgMaterializedView('some_view').using('heap').withNoData().as((qb) => qb.select().from(users));
-	const schema = {
-		view,
-		users,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-materialized-view',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect materialized view #2', async () => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: serial('id').primaryKey().notNull(),
-		name: varchar('users'),
-	});
-
-	const view = pgMaterializedView('some_view', { id: integer('asd') }).with({ autovacuumFreezeMinAge: 1 }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-	const schema = {
-		view,
-		users,
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'introspect-materialized-view-2',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic policy', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test'),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-policy',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic policy with "as"', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-policy-as',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test.todo('basic policy with CURRENT_USER role', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { to: 'current_user' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-policy',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic policy with all fields except "using" and "with"', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', for: 'all', to: ['postgres'] }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-policy-all-fields',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic policy with "using" and "with"', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-policy-using-withcheck',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('multiple policies', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
-			rlsPolicy: pgPolicy('newRls'),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'multiple-policies',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('multiple policies with roles', async () => {
-	const client = new PGlite();
-
-	client.query(`CREATE ROLE manager;`);
-
-	const schema = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
-			rlsPolicy: pgPolicy('newRls', { to: ['postgres', 'manager'] }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'multiple-policies-with-roles',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('basic roles', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		usersRole: pgRole('user'),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'basic-roles',
-		['public'],
-		{ roles: { include: ['user'] } },
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('role with properties', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		usersRole: pgRole('user', { inherit: false, createDb: true, createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'roles-with-properties',
-		['public'],
-		{ roles: { include: ['user'] } },
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('role with a few properties', async () => {
-	const client = new PGlite();
-
-	const schema = {
-		usersRole: pgRole('user', { inherit: false, createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'roles-with-few-properties',
-		['public'],
-		{ roles: { include: ['user'] } },
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('multiple policies with roles from schema', async () => {
-	const client = new PGlite();
-
-	const usersRole = pgRole('user_role', { inherit: false, createRole: true });
-
-	const schema = {
-		usersRole,
-
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
-			rlsPolicy: pgPolicy('newRls', { to: ['postgres', usersRole] }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectPgToFile(
-		client,
-		schema,
-		'multiple-policies-with-roles-from-schema',
-		['public'],
-		{ roles: { include: ['user_role'] } },
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/introspect/singlestore.test.ts b/drizzle-kit/tests/introspect/singlestore.test.ts
deleted file mode 100644
index 71960c3f75..0000000000
--- a/drizzle-kit/tests/introspect/singlestore.test.ts
+++ /dev/null
@@ -1,275 +0,0 @@
-import Docker from 'dockerode';
-import 'dotenv/config';
-import { SQL, sql } from 'drizzle-orm';
-import {
-	bigint,
-	char,
-	decimal,
-	double,
-	float,
-	int,
-	mediumint,
-	singlestoreTable,
-	smallint,
-	text,
-	tinyint,
-	varchar,
-} from 'drizzle-orm/singlestore-core';
-import * as fs from 'fs';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { introspectSingleStoreToFile } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-
-let client: Connection;
-let singlestoreContainer: Docker.Container;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'ghcr.io/singlestore-labs/singlestoredb-dev:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	singlestoreContainer = await docker.createContainer({
-		Image: image,
-		Env: ['ROOT_PASSWORD=singlestore'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await singlestoreContainer.start();
-	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-	return `singlestore://root:singlestore@localhost:${port}/`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env.SINGLESTORE_CONNECTION_STRING ?? await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to SingleStore');
-		await client?.end().catch(console.error);
-		await singlestoreContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await singlestoreContainer?.stop().catch(console.error);
-});
-
-beforeEach(async () => {
-	await client.query(`drop database if exists \`drizzle\`;`);
-	await client.query(`create database \`drizzle\`;`);
-	await client.query(`use \`drizzle\`;`);
-});
-
-if (!fs.existsSync('tests/introspect/singlestore')) {
-	fs.mkdirSync('tests/introspect/singlestore');
-}
-
-// TODO: Unskip this test when generated column is implemented
-/* test.skip('generated always column: link to another column', async () => {
-	const schema = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'generated-link-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-}); */
-
-// TODO: Unskip this test when generated column is implemented
-/* test.skip('generated always column virtual: link to another column', async () => {
-	const schema = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'generated-link-column-virtual',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-}); */
-
-test('Default value of character type column: char', async () => {
-	const schema = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			sortKey: char('sortKey', { length: 255 }).default('0'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'default-value-char-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('Default value of character type column: varchar', async () => {
-	const schema = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			sortKey: varchar('sortKey', { length: 255 }).default('0'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'default-value-varchar-column',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-// TODO: Unskip this test when views are implemented
-/* test('view #1', async () => {
-	const users = singlestoreTable('users', { id: int('id') });
-	const testView = singlestoreView('some_view', { id: int('id') }).as(
-		sql`select \`drizzle\`.\`users\`.\`id\` AS \`id\` from \`drizzle\`.\`users\``,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'view-1',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-}); */
-
-// TODO: Unskip this test when views are implemented
-/* test('view #2', async () => {
-	const users = singlestoreTable('some_users', { id: int('id') });
-	const testView = singlestoreView('some_view', { id: int('id') }).algorithm('temptable').sqlSecurity('definer').as(
-		sql`SELECT * FROM ${users}`,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'view-2',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-}); */
-
-test('handle float type', async () => {
-	const schema = {
-		table: singlestoreTable('table', {
-			col1: float(),
-			col2: float({ precision: 2 }),
-			col3: float({ precision: 2, scale: 1 }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'handle-float-type',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('handle unsigned numerical types', async () => {
-	const schema = {
-		table: singlestoreTable('table', {
-			col1: int({ unsigned: true }),
-			col2: tinyint({ unsigned: true }),
-			col3: smallint({ unsigned: true }),
-			col4: mediumint({ unsigned: true }),
-			col5: bigint({ mode: 'number', unsigned: true }),
-			col6: float({ unsigned: true }),
-			col7: float({ precision: 2, scale: 1, unsigned: true }),
-			col8: double({ unsigned: true }),
-			col9: double({ precision: 2, scale: 1, unsigned: true }),
-			col10: decimal({ unsigned: true }),
-			col11: decimal({ precision: 2, scale: 1, unsigned: true }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSingleStoreToFile(
-		client,
-		schema,
-		'handle-unsigned-numerical-types',
-		'drizzle',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/introspect/sqlite.test.ts b/drizzle-kit/tests/introspect/sqlite.test.ts
deleted file mode 100644
index de13d4e81b..0000000000
--- a/drizzle-kit/tests/introspect/sqlite.test.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import Database from 'better-sqlite3';
-import { SQL, sql } from 'drizzle-orm';
-import { check, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
-import * as fs from 'fs';
-import { introspectSQLiteToFile } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-if (!fs.existsSync('tests/introspect/sqlite')) {
-	fs.mkdirSync('tests/introspect/sqlite');
-}
-
-test('generated always column: link to another column', async () => {
-	const sqlite = new Database(':memory:');
-
-	const schema = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSQLiteToFile(
-		sqlite,
-		schema,
-		'generated-link-column',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('generated always column virtual: link to another column', async () => {
-	const sqlite = new Database(':memory:');
-
-	const schema = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			email: text('email'),
-			generatedEmail: text('generatedEmail').generatedAlwaysAs(
-				(): SQL => sql`\`email\``,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSQLiteToFile(
-		sqlite,
-		schema,
-		'generated-link-column-virtual',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('instrospect strings with single quotes', async () => {
-	const sqlite = new Database(':memory:');
-
-	const schema = {
-		columns: sqliteTable('columns', {
-			text: text('text').default('escape\'s quotes " '),
-		}),
-	};
-
-	const { statements, sqlStatements } = await introspectSQLiteToFile(
-		sqlite,
-		schema,
-		'introspect-strings-with-single-quotes',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('introspect checks', async () => {
-	const sqlite = new Database(':memory:');
-
-	const schema = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			name: text('name'),
-			age: int('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await introspectSQLiteToFile(
-		sqlite,
-		schema,
-		'introspect-checks',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('view #1', async () => {
-	const sqlite = new Database(':memory:');
-
-	const users = sqliteTable('users', { id: int('id') });
-	const testView = sqliteView('some_view', { id: int('id') }).as(
-		sql`SELECT * FROM ${users}`,
-	);
-
-	const schema = {
-		users: users,
-		testView,
-	};
-
-	const { statements, sqlStatements } = await introspectSQLiteToFile(
-		sqlite,
-		schema,
-		'view-1',
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/libsql-checks.test.ts b/drizzle-kit/tests/libsql-checks.test.ts
deleted file mode 100644
index 2a3abf2dc4..0000000000
--- a/drizzle-kit/tests/libsql-checks.test.ts
+++ /dev/null
@@ -1,308 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { check, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasLibSQL } from './schemaDiffer';
-
-test('create table with check', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasLibSQL({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				notNull: true,
-				primaryKey: true,
-				autoincrement: false,
-			},
-			{
-				name: 'age',
-				type: 'integer',
-				notNull: false,
-				primaryKey: false,
-				autoincrement: false,
-			},
-		],
-		compositePKs: [],
-		checkConstraints: ['some_check_name;"users"."age" > 21'],
-		referenceData: [],
-		uniqueConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("users"."age" > 21)
-);\n`);
-});
-
-test('add check contraint to existing table', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: ['some_check_name;"users"."age" > 21'],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('drop check contraint to existing table', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('new_some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [`new_some_check_name;"users"."age" > 21`],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "new_some_check_name" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 10`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [`some_check_name;"users"."age" > 10`],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("__new_users"."age" > 10)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('create checks with same names', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-			name: text('name'),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	await expect(diffTestSchemasLibSQL({}, to, [])).rejects.toThrowError();
-});
diff --git a/drizzle-kit/tests/libsql-statements.test.ts b/drizzle-kit/tests/libsql-statements.test.ts
deleted file mode 100644
index 636496c458..0000000000
--- a/drizzle-kit/tests/libsql-statements.test.ts
+++ /dev/null
@@ -1,989 +0,0 @@
-import { foreignKey, index, int, integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
-import { JsonRecreateTableStatement } from 'src/jsonStatements';
-import { expect, test } from 'vitest';
-import { diffTestSchemasLibSQL } from './schemaDiffer';
-
-test('drop autoincrement', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasLibSQL(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('set autoincrement', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasLibSQL(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [{
-			autoincrement: true,
-			generated: undefined,
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('set not null', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_set_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: true,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text NOT NULL;`,
-	);
-});
-
-test('drop not null', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_drop_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text;`,
-	);
-});
-
-test('set default. set not null. add column', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull().default('name'),
-			age: int('age').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(3);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_set_default',
-		tableName: 'users',
-		columnName: 'name',
-		newDefaultValue: "'name'",
-		schema: '',
-		newDataType: 'text',
-		columnOnUpdate: undefined,
-		columnNotNull: true,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_alter_column_set_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: "'name'",
-		columnOnUpdate: undefined,
-		columnNotNull: true,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'age',
-			type: 'integer',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text NOT NULL DEFAULT 'name';`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` ADD \`age\` integer NOT NULL;`,
-	);
-});
-
-test('drop default. drop not null', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull().default('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_drop_default',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_alter_column_drop_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text;`,
-	);
-});
-
-test('set data type. set default', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: int('name').default(123),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_set_type',
-		tableName: 'users',
-		columnName: 'name',
-		newDataType: 'integer',
-		oldDataType: 'text',
-		schema: '',
-		columnDefault: 123,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_alter_column_set_default',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'integer',
-		newDefaultValue: 123,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" integer DEFAULT 123;`,
-	);
-});
-
-test('add foriegn key', async (t) => {
-	const schema = {
-		table: sqliteTable('table', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id').references(() => schema.table.id),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_reference',
-		tableName: 'users',
-		data: 'users_table_id_table_id_fk;users;table_id;table;id;no action;no action',
-		schema: '',
-		columnNotNull: false,
-		columnDefault: undefined,
-		columnType: 'integer',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "table_id" TO "table_id" integer REFERENCES table(id) ON DELETE no action ON UPDATE no action;`,
-	);
-});
-
-test('drop foriegn key', async (t) => {
-	const schema = {
-		table: sqliteTable('table', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id').references(() => schema.table.id, {
-				onDelete: 'cascade',
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'table_id',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`table_id\` integer
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "table_id") SELECT "id", "table_id" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('alter foriegn key', async (t) => {
-	const tableRef = sqliteTable('table', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-	});
-	const tableRef2 = sqliteTable('table2', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id').references(() => tableRef.id, {
-				onDelete: 'cascade',
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			tableId: int('table_id').references(() => tableRef2.id),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'table_id',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [
-			{
-				columnsFrom: ['table_id'],
-				columnsTo: ['id'],
-				name: 'users_table_id_table2_id_fk',
-				onDelete: 'no action',
-				onUpdate: 'no action',
-				tableFrom: 'users',
-				tableTo: 'table2',
-			},
-		],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`table_id\` integer,
-\tFOREIGN KEY (\`table_id\`) REFERENCES \`table2\`(\`id\`) ON UPDATE no action ON DELETE no action
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "table_id") SELECT "id", "table_id" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(
-		'DROP TABLE `users`;',
-	);
-	expect(sqlStatements[4]).toBe(
-		'ALTER TABLE `__new_users` RENAME TO `users`;',
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('add foriegn key for multiple columns', async (t) => {
-	const tableRef = sqliteTable('table', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		age: int('age'),
-		age1: int('age_1'),
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			column: int('column'),
-			column1: int('column_1'),
-		}),
-		tableRef,
-	};
-
-	const schema2 = {
-		tableRef,
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				column: int('column'),
-				column1: int('column_1'),
-			},
-			(table) => ({
-				foreignKey: foreignKey({
-					columns: [table.column, table.column1],
-					foreignColumns: [tableRef.age, tableRef.age1],
-				}),
-			}),
-		),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'column',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'column_1',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [
-			{
-				columnsFrom: ['column', 'column_1'],
-				columnsTo: ['age', 'age_1'],
-				name: 'users_column_column_1_table_age_age_1_fk',
-				onDelete: 'no action',
-				onUpdate: 'no action',
-				tableFrom: 'users',
-				tableTo: 'table',
-			},
-		],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	} as JsonRecreateTableStatement);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`column\` integer,
-\t\`column_1\` integer,
-\tFOREIGN KEY (\`column\`,\`column_1\`) REFERENCES \`table\`(\`age\`,\`age_1\`) ON UPDATE no action ON DELETE no action
-);\n`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "column", "column_1") SELECT "id", "column", "column_1" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('drop foriegn key for multiple columns', async (t) => {
-	const tableRef = sqliteTable('table', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		age: int('age'),
-		age1: int('age_1'),
-	});
-
-	const schema1 = {
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				column: int('column'),
-				column1: int('column_1'),
-			},
-			(table) => ({
-				foreignKey: foreignKey({
-					columns: [table.column, table.column1],
-					foreignColumns: [tableRef.age, tableRef.age1],
-				}),
-			}),
-		),
-		tableRef,
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			column: int('column'),
-			column1: int('column_1'),
-		}),
-		tableRef,
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'column',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'column_1',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`column\` integer,
-\t\`column_1\` integer
-);\n`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "column", "column_1") SELECT "id", "column", "column_1" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('alter column drop generated', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			id: int('id').primaryKey().notNull(),
-			name: text('name').generatedAlwaysAs('drizzle is the best').notNull(),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			id: int('id').primaryKey().notNull(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnDefault: undefined,
-		columnGenerated: undefined,
-		columnName: 'name',
-		columnNotNull: true,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		schema: '',
-		tableName: 'table',
-		type: 'alter_table_alter_column_drop_generated',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE \`table\` DROP COLUMN \`name\`;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`table\` ADD \`name\` text NOT NULL;`,
-	);
-});
-
-test('recreate table with nested references', async (t) => {
-	let users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	let subscriptions = sqliteTable('subscriptions', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		userId: integer('user_id').references(() => users.id),
-		customerId: text('customer_id'),
-	});
-	const schema1 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: false }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	const schema2 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "name", "age") SELECT "id", "name", "age" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('set not null with index', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}, (table) => ({
-			someIndex: index('users_name_index').on(table.name),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}, (table) => ({
-			someIndex: index('users_name_index').on(table.name),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_set_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: true,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX "users_name_index";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text NOT NULL;`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`CREATE INDEX \`users_name_index\` ON \`users\` (\`name\`);`,
-	);
-});
-
-test('drop not null with two indexes', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-			age: int('age').notNull(),
-		}, (table) => ({
-			someUniqeIndex: uniqueIndex('users_name_unique').on(table.name),
-			someIndex: index('users_age_index').on(table.age),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			age: int('age').notNull(),
-		}, (table) => ({
-			someUniqeIndex: uniqueIndex('users_name_unique').on(table.name),
-			someIndex: index('users_age_index').on(table.age),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_drop_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(5);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX "users_name_unique";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`DROP INDEX "users_age_index";`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text;`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`CREATE UNIQUE INDEX \`users_name_unique\` ON \`users\` (\`name\`);`,
-	);
-	expect(sqlStatements[4]).toBe(
-		`CREATE INDEX \`users_age_index\` ON \`users\` (\`age\`);`,
-	);
-});
diff --git a/drizzle-kit/tests/libsql-views.test.ts b/drizzle-kit/tests/libsql-views.test.ts
deleted file mode 100644
index bf5cdb04ec..0000000000
--- a/drizzle-kit/tests/libsql-views.test.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { int, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasLibSQL } from './schemaDiffer';
-
-test('create view', async () => {
-	const users = sqliteTable('users', { id: int('id').default(1) });
-	const view = sqliteView('view').as((qb) => qb.select().from(users));
-	const to = {
-		users: users,
-		testView: view,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [{
-			autoincrement: false,
-			default: 1,
-			name: 'id',
-			type: 'integer',
-			primaryKey: false,
-			notNull: false,
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'view',
-		definition: 'select "id" from "users"',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
-\t\`id\` integer DEFAULT 1
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`view\` AS select "id" from "users";`);
-});
-
-test('drop view', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`DROP VIEW \`view\`;`,
-	);
-});
-
-test('alter view', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users WHERE users.id = 1`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		name: 'view',
-		type: 'sqlite_create_view',
-		definition: 'SELECT * FROM users WHERE users.id = 1',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`DROP VIEW \`view\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE VIEW \`view\` AS SELECT * FROM users WHERE users.id = 1;`,
-	);
-});
-
-test('create view with existing flag', async () => {
-	const view = sqliteView('view', {}).existing();
-	const to = {
-		testView: view,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL({}, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop view with existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view with existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).existing(),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view and drop existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'new_view',
-		definition: 'SELECT * FROM users',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe('DROP VIEW `view`;');
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users;`);
-});
-
-test('rename view and alter ".as"', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users WHERE 1=1`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasLibSQL(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'new_view',
-		definition: 'SELECT * FROM users WHERE 1=1',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe('DROP VIEW `view`;');
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users WHERE 1=1;`);
-});
diff --git a/drizzle-kit/tests/mariadb/mocks.ts b/drizzle-kit/tests/mariadb/mocks.ts
new file mode 100644
index 0000000000..ddcbd52586
--- /dev/null
+++ b/drizzle-kit/tests/mariadb/mocks.ts
@@ -0,0 +1,455 @@
+import { is } from 'drizzle-orm';
+import { int, MySqlColumnBuilder, MySqlSchema, MySqlTable, mysqlTable, MySqlView } from 'drizzle-orm/mysql-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { Connection, createConnection } from 'mysql2/promise';
+import {
+	MySqlSchema as MySqlSchemaOld,
+	MySqlTable as MysqlTableOld,
+	MySqlView as MysqlViewOld,
+} from 'orm044/mysql-core';
+import { suggestions as diffSuggestions } from '../../src/cli/commands/generate-mysql';
+import { introspect } from '../../src/cli/commands/pull-mysql';
+import { suggestions } from '../../src/cli/commands/push-mysql';
+import { upToV6 } from '../../src/cli/commands/up-mysql';
+import { runWithCliContext } from '../../src/cli/context';
+import { HintsHandler } from '../../src/cli/hints';
+import { CasingType, configMigrations } from '../../src/cli/validations/common';
+import { mysqlSchemaError as schemaError } from '../../src/cli/views';
+import { EmptyProgressView } from '../../src/cli/views';
+import { hash } from '../../src/dialects/common';
+import { MysqlDDL, MysqlEntity, mysqlToRelationsPull } from '../../src/dialects/mysql/ddl';
+import { createDDL, interimToDDL } from '../../src/dialects/mysql/ddl';
+import { ddlDiff, ddlDiffDry } from '../../src/dialects/mysql/diff';
+import { defaultFromColumn } from '../../src/dialects/mysql/drizzle';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../src/dialects/mysql/drizzle';
+import { fromDatabaseForDrizzle } from '../../src/dialects/mysql/introspect';
+import { ddlToTypeScript } from '../../src/dialects/mysql/typescript';
+import { diff as legacyDiff } from '../../src/legacy/mysql-v5/mysqlDiff';
+import { serializeMysql } from '../../src/legacy/mysql-v5/serializer';
+import { DB } from '../../src/utils';
+import { mockResolver } from '../../src/utils/mocks';
+import { tsc } from '../utils';
+import 'zx/globals';
+import { relationsToTypeScript } from 'src/cli/commands/pull-common';
+import { mysqlCommutativity } from 'src/dialects/mysql/commutativity';
+import type { MysqlSnapshot } from 'src/dialects/mysql/snapshot';
+import { expect } from 'vitest';
+
+mkdirSync('tests/mariadb/tmp', { recursive: true });
+
+export type MysqlSchema = Record<
+	string,
+	MySqlTable<any> | MySqlSchema | MySqlView
+>;
+
+export type MysqlSchemaOld = Record<
+	string,
+	MysqlTableOld<any> | MySqlSchemaOld | MysqlViewOld
+>;
+
+export const fromEntities = (entities: MysqlEntity[]) => {
+	const ddl = createDDL();
+	for (const it of entities) {
+		ddl.entities.push(it);
+	}
+	return ddl;
+};
+
+export const drizzleToDDL = (sch: MysqlSchema) => {
+	const tables = Object.values(sch).filter((it) => is(it, MySqlTable)) as MySqlTable[];
+	const views = Object.values(sch).filter((it) => is(it, MySqlView)) as MySqlView[];
+	return interimToDDL(fromDrizzleSchema(tables, views));
+};
+
+export const diff = async (
+	left: MysqlSchema | MysqlDDL,
+	right: MysqlSchema | MysqlDDL,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as MysqlDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = 'entities' in right && '_' in right
+		? { ddl: right as MysqlDDL, errors: [] }
+		: drizzleToDDL(right);
+
+	const renames = new Set(renamesArr);
+
+	const mappedErrors1 = err1.map((it: any) => schemaError(it));
+	const mappedErrors2 = err2.map((it: any) => schemaError(it));
+
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+
+	const { errors } = diffSuggestions(statements, ddl2);
+
+	return {
+		sqlStatements,
+		statements,
+		next: ddl2,
+		ddl1Err: err1,
+		ddl2Err: err2,
+		mappedErrors1,
+		mappedErrors2,
+		suggestion: { errors },
+	};
+};
+
+export const diffIntrospect = async (
+	db: DB,
+	initSchema: MysqlSchema,
+	testName: string,
+	casing?: CasingType | undefined,
+) => {
+	const { ddl: initDDL } = drizzleToDDL(initSchema);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL);
+	for (const st of init) await db.query(st);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, 'drizzle', () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const filePath = `tests/mariadb/tmp/${testName}.ts`;
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel', 'mysql');
+	const filePathRelations = `tests/mariadb/tmp/${testName}-relations.ts`;
+	// path
+	const relations = relationsToTypeScript(mysqlToRelationsPull(ddl1), 'camel', `./tests/mariadb/tmp/${testName}`);
+
+	writeFileSync(filePath, file.file);
+	writeFileSync(filePathRelations, relations.file);
+	await tsc(file.file);
+	await tsc(relations.file);
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([
+		filePath,
+	]);
+
+	const interim = fromDrizzleSchema(
+		response.tables,
+		response.views,
+	);
+
+	const { ddl: ddl2, errors: e3 } = interimToDDL(interim);
+
+	// TODO: handle errors
+	const renames = new Set<string>();
+
+	const {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	} = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	rmSync(`tests/mariadb/tmp/${testName}.ts`);
+	rmSync(`tests/mariadb/tmp/${testName}-relations.ts`);
+
+	return {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+		ddlAfterPull: ddl1,
+	};
+};
+
+export const push = async (config: {
+	db: DB;
+	to: MysqlSchema | MysqlDDL;
+	renames?: string[];
+	casing?: CasingType;
+	log?: 'statements';
+	ignoreSubsequent?: boolean;
+	expectError?: boolean;
+	migrationsConfig?: {
+		table?: string;
+	};
+}) => {
+	const { db, to, log, expectError } = config;
+	const casing = config.casing ?? 'camelCase';
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+	const { schema } = await introspect({
+		db,
+		database: 'drizzle',
+		filter: () => true,
+		progress: new EmptyProgressView(),
+		migrations,
+	});
+	const { ddl: ddl1, errors: err1 } = interimToDDL(schema);
+	const { ddl: ddl2, errors: err2 } = 'entities' in to && '_' in to
+		? { ddl: to as MysqlDDL, errors: [] }
+		: drizzleToDDL(to);
+
+	if (err2.length > 0) {
+		for (const e of err2) {
+			console.error(`err2: ${JSON.stringify(e)}`);
+		}
+		throw new Error('Schema2 Interim Error');
+	}
+
+	if (err1.length > 0) {
+		for (const e of err1) {
+			console.error(`err: ${JSON.stringify(e)}`);
+		}
+		throw new Error('Schema1 Interim Error');
+	}
+
+	const renames = new Set(config.renames ?? []);
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const res = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, ddl2, new HintsHandler()),
+	);
+
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		await db.query(sql).catch((err) => {
+			if (!expectError) throw err;
+		});
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		{
+			const { schema } = await introspect({
+				db,
+				database: 'drizzle',
+				filter: () => true,
+				progress: new EmptyProgressView(),
+				migrations,
+			});
+			const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+			const { sqlStatements, statements } = await ddlDiff(
+				ddl1,
+				ddl2,
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				'push',
+			);
+			if (sqlStatements.length > 0) {
+				console.error('---- subsequent push is not empty ----');
+				expect(sqlStatements.join('\n')).toBe('');
+			}
+		}
+	}
+
+	return { sqlStatements, statements, hints: res };
+};
+
+export const diffDefault = async <T extends MySqlColumnBuilder>(
+	kit: TestDatabase,
+	builder: T,
+	expectedDefault: string,
+	pre: MysqlSchema | null = null,
+	override?: {
+		type?: string;
+		default?: string;
+		ignoreSubsequent?: boolean;
+	},
+) => {
+	await kit.clear();
+
+	const config = (builder as any).config;
+	const def = config['default'];
+	const column = mysqlTable('table', { column: builder }).column;
+	const type = override?.type ?? column.getSQLType().replace(', ', ','); // real(6, 3)->real(6,3)
+	const ignoreSubsequent = override?.ignoreSubsequent ?? false;
+
+	const columnDefault = defaultFromColumn(column);
+	const defaultSql = override?.default ?? columnDefault;
+
+	const res = [] as string[];
+	if (defaultSql !== expectedDefault) {
+		res.push(`Unexpected sql: \n${defaultSql}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	const { db, clear } = kit;
+	if (pre) await push({ db, to: pre });
+	const { sqlStatements: st1 } = await push({ db, to: init, ignoreSubsequent });
+	const { sqlStatements: st2 } = await push({ db, to: init, ignoreSubsequent });
+
+	const expectedInit = `CREATE TABLE \`table\` (\n\t\`column\` ${type} DEFAULT ${expectedDefault}\n);\n`;
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2}`);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, 'drizzle', () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel', 'mysql');
+	const path = `tests/mariadb/tmp/temp-${hash(String(Math.random()))}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+	const sch = fromDrizzleSchema(response.tables, response.views);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+	}
+
+	await clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema1, ignoreSubsequent });
+	const { sqlStatements: st3 } = await push({ db, to: schema2, ignoreSubsequent });
+	const expectedAlter = `ALTER TABLE \`table\` MODIFY COLUMN \`column\` ${type} DEFAULT ${expectedDefault};`;
+	if (st3.length !== 1 || st3[0] !== expectedAlter) res.push(`Unexpected default alter:\n${st3}\n\n${expectedAlter}`);
+
+	await clear();
+
+	const schema3 = {
+		...pre,
+		table: mysqlTable('table', { id: int() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: mysqlTable('table', { id: int(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema3, ignoreSubsequent });
+	const { sqlStatements: st4 } = await push({ db, to: schema4, ignoreSubsequent });
+
+	const expectedAddColumn = `ALTER TABLE \`table\` ADD \`column\` ${type} DEFAULT ${expectedDefault};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export type TestDatabase = {
+	db: DB;
+	client: Connection;
+	db_url: string;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+};
+
+export const prepareTestDatabase = async (): Promise<TestDatabase> => {
+	const url = process.env['MARIADB_CONNECTION_STRING'];
+	if (!url) {
+		throw new Error(
+			'MARIADB_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mariadb` (or your own mariadb container) and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 1000;
+	let timeLeft = 20000;
+	do {
+		try {
+			const client: Connection = await createConnection(url);
+			await client.connect();
+
+			const db = {
+				query: async (sql: string, params: any[]) => {
+					const [res] = await client.query(sql).catch((e: Error) => {
+						const error = new Error(`query error: ${sql}\n\n${e.message}`);
+						throw error;
+					});
+					return res as any[];
+				},
+			};
+			const close = async () => {
+				await client?.end().catch(console.error);
+			};
+			const clear = async () => {
+				await client.query(`drop database if exists \`drizzle\`;`);
+				await client.query(`create database \`drizzle\`;`);
+				await client.query(`use \`drizzle\`;`);
+			};
+			return { db, close, clear, db_url: url, client };
+		} catch (e) {
+			console.error(e);
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+
+	throw new Error();
+};
+
+export const diffSnapshotV5 = async (db: DB, schema: MysqlSchema, oldSchema: MysqlSchemaOld) => {
+	const res = await serializeMysql(oldSchema, 'camelCase');
+	const { sqlStatements } = await legacyDiff({ right: res });
+
+	for (const st of sqlStatements) {
+		await db.query(st);
+	}
+
+	const snapshot = upToV6(res);
+	const ddl = fromEntities(snapshot.ddl);
+
+	const { sqlStatements: st, next } = await diff(ddl, schema, []);
+	const { sqlStatements: pst } = await push({ db, to: schema });
+	const { sqlStatements: st1 } = await diff(next, ddl, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	return {
+		step1: st,
+		step2: pst,
+		step3: st1,
+		step4: pst1,
+		all: [...st, ...pst, ...st1, ...pst1],
+	};
+};
+
+type SchemaShape = {
+	id: string;
+	prevId?: string;
+	schema: Record<string, MySqlTable>;
+};
diff --git a/drizzle-kit/tests/mariadb/pull.test.ts b/drizzle-kit/tests/mariadb/pull.test.ts
new file mode 100644
index 0000000000..60af3c70ca
--- /dev/null
+++ b/drizzle-kit/tests/mariadb/pull.test.ts
@@ -0,0 +1,47 @@
+import 'dotenv/config';
+import { int, mysqlTable, serial, varchar } from 'drizzle-orm/mysql-core';
+import * as fs from 'fs';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffIntrospect, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+if (!fs.existsSync('tests/mariadb/tmp')) {
+	fs.mkdirSync('tests/mariadb/tmp', { recursive: true });
+}
+
+test('introspect primary keys', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 255 }),
+			age: int('age'),
+		}),
+	};
+
+	const { ddlAfterPull } = await diffIntrospect(db, schema, 'primary-keys');
+
+	expect(ddlAfterPull.pks.list()).toStrictEqual([{
+		entityType: 'pks',
+		table: 'users',
+		name: 'PRIMARY',
+		columns: ['id'],
+	}]);
+});
diff --git a/drizzle-kit/tests/migrate/libsq-schema.ts b/drizzle-kit/tests/migrate/libsq-schema.ts
deleted file mode 100644
index 5cb344d518..0000000000
--- a/drizzle-kit/tests/migrate/libsq-schema.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-export const users = sqliteTable('users', {
-	id: integer('id').primaryKey().notNull(),
-	name: text('name').notNull(),
-});
diff --git a/drizzle-kit/tests/migrate/libsql-migrate.test.ts b/drizzle-kit/tests/migrate/libsql-migrate.test.ts
deleted file mode 100644
index b937b644fd..0000000000
--- a/drizzle-kit/tests/migrate/libsql-migrate.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { createClient } from '@libsql/client';
-import { connectToLibSQL } from 'src/cli/connections';
-import { expect, test } from 'vitest';
-
-test('validate migrate function', async () => {
-	const credentials = {
-		url: ':memory:',
-	};
-	const { migrate, query } = await connectToLibSQL(credentials);
-
-	await migrate({ migrationsFolder: 'tests/migrate/migrations' });
-
-	const res = await query(`PRAGMA table_info("users");`);
-
-	expect(res).toStrictEqual([{
-		cid: 0,
-		name: 'id',
-		type: 'INTEGER',
-		notnull: 0,
-		dflt_value: null,
-		pk: 0,
-	}, {
-		cid: 1,
-		name: 'name',
-		type: 'INTEGER',
-		notnull: 1,
-		dflt_value: null,
-		pk: 0,
-	}]);
-});
-
-// test('validate migrate function', async () => {
-// 	const credentials = {
-// 		url: '',
-// 		authToken: '',
-// 	};
-// 	const { migrate, query } = await connectToLibSQL(credentials);
-
-// 	await migrate({ migrationsFolder: 'tests/migrate/migrations' });
-
-// 	const res = await query(`PRAGMA table_info("users");`);
-
-// 	expect(res).toStrictEqual([{
-// 		cid: 0,
-// 		name: 'id',
-// 		type: 'INTEGER',
-// 		notnull: 0,
-// 		dflt_value: null,
-// 		pk: 0,
-// 	}, {
-// 		cid: 1,
-// 		name: 'name',
-// 		type: 'INTEGER',
-// 		notnull: 1,
-// 		dflt_value: null,
-// 		pk: 0,
-// 	}]);
-// });
diff --git a/drizzle-kit/tests/migrate/migrations/0000_little_blizzard.sql b/drizzle-kit/tests/migrate/migrations/0000_little_blizzard.sql
deleted file mode 100644
index 9de0a139df..0000000000
--- a/drizzle-kit/tests/migrate/migrations/0000_little_blizzard.sql
+++ /dev/null
@@ -1,4 +0,0 @@
-CREATE TABLE `users` (
-	`id` integer PRIMARY KEY NOT NULL,
-	`name` text NOT NULL
-);
diff --git a/drizzle-kit/tests/migrate/migrations/0001_nebulous_storm.sql b/drizzle-kit/tests/migrate/migrations/0001_nebulous_storm.sql
deleted file mode 100644
index 4309a05c2f..0000000000
--- a/drizzle-kit/tests/migrate/migrations/0001_nebulous_storm.sql
+++ /dev/null
@@ -1,10 +0,0 @@
-PRAGMA foreign_keys=OFF;--> statement-breakpoint
-CREATE TABLE `__new_users` (
-	`id` integer,
-	`name` integer NOT NULL
-);
---> statement-breakpoint
-INSERT INTO `__new_users`("id", "name") SELECT "id", "name" FROM `users`;--> statement-breakpoint
-DROP TABLE `users`;--> statement-breakpoint
-ALTER TABLE `__new_users` RENAME TO `users`;--> statement-breakpoint
-PRAGMA foreign_keys=ON;
\ No newline at end of file
diff --git a/drizzle-kit/tests/migrate/migrations/meta/0000_snapshot.json b/drizzle-kit/tests/migrate/migrations/meta/0000_snapshot.json
deleted file mode 100644
index 599d02b915..0000000000
--- a/drizzle-kit/tests/migrate/migrations/meta/0000_snapshot.json
+++ /dev/null
@@ -1,40 +0,0 @@
-{
-  "version": "6",
-  "dialect": "sqlite",
-  "id": "2bd46776-9e41-4a6c-b617-5c600bb176f2",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "users": {
-      "name": "users",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {}
-    }
-  },
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  },
-  "internal": {
-    "indexes": {}
-  }
-}
\ No newline at end of file
diff --git a/drizzle-kit/tests/migrate/migrations/meta/0001_snapshot.json b/drizzle-kit/tests/migrate/migrations/meta/0001_snapshot.json
deleted file mode 100644
index e3b26ba140..0000000000
--- a/drizzle-kit/tests/migrate/migrations/meta/0001_snapshot.json
+++ /dev/null
@@ -1,40 +0,0 @@
-{
-  "version": "6",
-  "dialect": "sqlite",
-  "id": "6c0ec455-42fd-47fd-a22c-4bb4551e1358",
-  "prevId": "2bd46776-9e41-4a6c-b617-5c600bb176f2",
-  "tables": {
-    "users": {
-      "name": "users",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "name": {
-          "name": "name",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {}
-    }
-  },
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  },
-  "internal": {
-    "indexes": {}
-  }
-}
\ No newline at end of file
diff --git a/drizzle-kit/tests/migrate/migrations/meta/_journal.json b/drizzle-kit/tests/migrate/migrations/meta/_journal.json
deleted file mode 100644
index c836eb194b..0000000000
--- a/drizzle-kit/tests/migrate/migrations/meta/_journal.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "version": "7",
-  "dialect": "sqlite",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "6",
-      "when": 1725358702427,
-      "tag": "0000_little_blizzard",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "6",
-      "when": 1725358713033,
-      "tag": "0001_nebulous_storm",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/drizzle-kit/tests/mssql/columns.test.ts b/drizzle-kit/tests/mssql/columns.test.ts
new file mode 100644
index 0000000000..37b98e4d1f
--- /dev/null
+++ b/drizzle-kit/tests/mssql/columns.test.ts
@@ -0,0 +1,2629 @@
+import { sql } from 'drizzle-orm';
+import {
+	bit,
+	check,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	primaryKey,
+	snakeCase,
+	text,
+	unique,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { defaultNameForPK } from 'src/dialects/mssql/grammar';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add columns #1', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull().default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st0 } = await diff({}, schema1, []);
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const expected2 = [
+		`ALTER TABLE [users] ADD [name] text NOT NULL CONSTRAINT [users_name_default] DEFAULT ('hey');`,
+	];
+
+	// expect(st0).toStrictEqual([]);
+	expect(st).toStrictEqual(expected2);
+	expect(pst).toStrictEqual(expected2);
+});
+
+test('add columns #2', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [users] ADD [name] text;',
+		'ALTER TABLE [users] ADD [email] text;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #3', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar('name', { length: 100 }).primaryKey(),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [users] ADD [name] varchar(100) NOT NULL;',
+		'ALTER TABLE [users] ADD [email] text;',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #4. With default', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar('name', { length: 100 }).primaryKey(),
+			email: text('email').default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [users] ADD [name] varchar(100) NOT NULL;',
+		`ALTER TABLE [users] ADD [email] text CONSTRAINT [users_email_default] DEFAULT ('hey');`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #5. With not null and with default', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar('name', { length: 100 }).primaryKey(),
+			email: text('email').notNull().default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [users] ADD [name] varchar(100) NOT NULL;',
+		`ALTER TABLE [users] ADD [email] text NOT NULL CONSTRAINT [users_email_default] DEFAULT ('hey');`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column: change data type, add not null with default', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id]) VALUES (1), (2);`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).notNull().default('1'),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(200) NOT NULL;`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_default] DEFAULT ('1') FOR [name];`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).not.toBeNull();
+});
+
+test('column conflict duplicate name #1', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar('name', { length: 100 }).primaryKey(),
+			email: text('name'),
+		}),
+	};
+
+	await push({ to: schema1, db, schemas: ['dbo'] });
+
+	await expect(diff(schema1, schema2, [])).rejects.toThrowError(); // duplicate names in columns
+	await expect(push({ to: schema2, db, schemas: ['dbo'] })).rejects.toThrowError(); // duplicate names in columns
+});
+
+test('alter column change name #1', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users.name->dbo.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames: ['dbo.users.name->dbo.users.name1'] });
+
+	const st0 = [`EXEC sp_rename 'users.name', [name1], 'COLUMN';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change name #2', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name1'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users.name->dbo.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames: ['dbo.users.name->dbo.users.name1'] });
+
+	const st0 = [
+		`EXEC sp_rename 'users.name', [name1], 'COLUMN';`,
+		'ALTER TABLE [users] ADD [email] text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table rename column #1', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users1', {
+			id: int('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'new_schema.users->new_schema.users1',
+		'new_schema.users1.id->new_schema.users1.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'new_schema.users->new_schema.users1',
+			'new_schema.users1.id->new_schema.users1.id1',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'new_schema.users', [users1];`,
+		`EXEC sp_rename 'new_schema.users1.id', [id1], 'COLUMN';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column #1', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+		}),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'new_schema.users.id->new_schema.users.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'new_schema.users.id->new_schema.users.id1',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'new_schema.users.id', [id1], 'COLUMN';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column #2. Part of unique constraint', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id').unique(),
+		}),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id1').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'new_schema.users.id->new_schema.users.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'new_schema.users.id->new_schema.users.id1',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'new_schema.users.id', [id1], 'COLUMN';`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column #3. Part of check constraint', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+		}, (t) => [check('hey', sql`${t.id} != 2`)]),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id1'),
+		}, (t) => [check('hey', sql`${t.id} != 2`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'new_schema.users.id->new_schema.users.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints, error } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'new_schema.users.id->new_schema.users.id1',
+		],
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE [new_schema].[users] DROP CONSTRAINT [hey];`,
+		`EXEC sp_rename 'new_schema.users.id', [id1], 'COLUMN';`,
+		`ALTER TABLE [new_schema].[users] ADD CONSTRAINT [hey] CHECK ([users].[id1] != 2);`,
+	]);
+	// error expected
+	// since there will be changes in defintion
+	// push will skip alter definition and tries to rename column
+	expect(pst).toStrictEqual([
+		`EXEC sp_rename 'new_schema.users.id', [id1], 'COLUMN';`,
+	]);
+	expect(error).not.toBeNull();
+	expect(phints).toStrictEqual([{
+		hint:
+			'You are trying to rename column from id to id1, but it is not possible to rename a column if it is used in a check constraint on the table.'
+			+ '\n'
+			+ 'To rename the column, first drop the check constraint, then rename the column, and finally recreate the check constraint',
+	}]);
+});
+
+test('drop column #1. Part of check constraint', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			name: varchar('name'),
+		}, (t) => [check('hey', sql`${t.id} != 2`)]),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [new_schema].[users] DROP CONSTRAINT [hey];`,
+		`ALTER TABLE [new_schema].[users] DROP COLUMN [id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop column #2. Part of unique constraint', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			name: varchar('name'),
+		}, (t) => [unique('hey').on(t.id)]),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [new_schema].[users] DROP CONSTRAINT [hey];`,
+		`ALTER TABLE [new_schema].[users] DROP COLUMN [id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop column #3. Part of pk', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			name: varchar('name'),
+		}, (t) => [primaryKey({ name: 'hey', columns: [t.id] })]),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [new_schema].[users] DROP CONSTRAINT [hey];`,
+		`ALTER TABLE [new_schema].[users] DROP COLUMN [id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop column #4. Has default', async (t) => {
+	const newSchema = mssqlSchema('new_schema');
+	const schema1 = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			name: varchar('name'),
+		}, (t) => [primaryKey({ name: 'hey', columns: [t.id] })]),
+	};
+
+	const schema2 = {
+		newSchema,
+		users: newSchema.table('users', {
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [new_schema].[users] DROP CONSTRAINT [hey];`,
+		`ALTER TABLE [new_schema].[users] DROP COLUMN [id];`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('with composite pks #1', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id2: int('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id2: int('id2'),
+			text: text('text'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = ['ALTER TABLE [users] ADD [text] text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column that is part of the pk. Name explicit', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id3: int('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users.id2->dbo.users.id3',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: ['dbo.users.id2->dbo.users.id3'],
+	});
+
+	const st0 = [`EXEC sp_rename 'users.id2', [id3], 'COLUMN';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column and pk #2', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id3: int('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id2->dbo.users.id3`,
+		`dbo.users.compositePK->dbo.users.${defaultNameForPK('users')}`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			`dbo.users.id2->dbo.users.id3`,
+			`dbo.users.compositePK->dbo.users.${defaultNameForPK('users')}`,
+		],
+	});
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		`EXEC sp_rename 'users.id2', [id3], 'COLUMN';`,
+		`EXEC sp_rename 'compositePK', [users_pkey], 'OBJECT';`,
+	]);
+	expect(pst).toStrictEqual([`EXEC sp_rename 'users.id2', [id3], 'COLUMN';`]); // pk name is preserved
+	expect(pst2).toStrictEqual([]);
+});
+
+test('rename column and pk #3', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id3: int('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3], name: 'compositePK1' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id2->dbo.users.id3`,
+		`dbo.users.compositePK->dbo.users.compositePK1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id2->dbo.users.id3`, `dbo.users.compositePK->dbo.users.compositePK1`],
+	});
+
+	const { sqlStatements: pst1 } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`EXEC sp_rename 'users.id2', [id3], 'COLUMN';`,
+		`EXEC sp_rename 'compositePK', [compositePK1], 'OBJECT';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(pst1).toStrictEqual([]);
+});
+
+test('rename column that is part of pk', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id3: int('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id2->dbo.users.id3`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id2->dbo.users.id3`],
+	});
+
+	const { sqlStatements: pst1 } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`EXEC sp_rename 'users.id2', [id3], 'COLUMN';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(pst1).toStrictEqual([]);
+});
+
+test('rename table should not cause rename pk. Name is not explicit', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2] })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id1: int('id1'),
+			id2: int('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`],
+	});
+
+	const st0 = [`EXEC sp_rename 'users', [users2];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table should not cause rename pk. Name explicit', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePk' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id1: int('id1'),
+			id2: int('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePk' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+	]);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('move table to other schema + rename table. Should not cause rename pk. Name is not explicit', async (t) => {
+	const mySchema = mssqlSchema('my_schema');
+	const schema1 = {
+		mySchema,
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2] })],
+		),
+	};
+
+	const schema2 = {
+		mySchema,
+		users: mySchema.table('users2', {
+			id1: int('id1'),
+			id2: int('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->my_schema.users2`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->my_schema.users2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`ALTER SCHEMA [my_schema] TRANSFER [dbo].[users2];\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table should not cause rename fk. Name is not explicit. #1', async (t) => {
+	const company = mssqlTable(
+		'company',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema1 = {
+		company,
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id'),
+				companyId: int('company_id').references(() => company.id),
+			},
+		),
+	};
+
+	const renamedCompany = mssqlTable(
+		'company2',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema2 = {
+		company: renamedCompany,
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id'),
+				companyId: int('company_id').references(() => renamedCompany.id),
+			},
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.company->dbo.company2`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.company->dbo.company2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'company', [company2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table should not cause rename fk. Name is not explicit. #2', async (t) => {
+	const company = mssqlTable(
+		'company',
+		{
+			id: int('id').references(() => users.id),
+		},
+	);
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema1 = {
+		company,
+		users,
+	};
+
+	const renamedCompany = mssqlTable(
+		'company2',
+		{
+			id: int('id').references(() => users.id),
+		},
+	);
+	const schema2 = {
+		company: renamedCompany,
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.company->dbo.company2`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.company->dbo.company2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'company', [company2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('move table to other schema + rename table. Should not cause rename fk', async (t) => {
+	const mySchema = mssqlSchema('my_schema');
+
+	const company = mssqlTable(
+		'company',
+		{
+			id: int('id').references(() => users.id),
+		},
+	);
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema1 = {
+		mySchema,
+		company,
+		users,
+	};
+
+	const renamedCompany = mySchema.table(
+		'company2',
+		{
+			id: int('id').references(() => users.id),
+		},
+	);
+	const schema2 = {
+		mySchema,
+		company: renamedCompany,
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.company->my_schema.company2`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.company->my_schema.company2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'company', [company2];`,
+		`ALTER SCHEMA [my_schema] TRANSFER [dbo].[company2];\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('varchar and text default values escape single quotes', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int('id').primaryKey(),
+			text: text('text').default("escape's quotes"),
+			varchar: varchar('varchar', { length: 100 }).default("escape's quotes"),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [table] ADD [text] text CONSTRAINT [table_text_default] DEFAULT ('escape''s quotes');`,
+		`ALTER TABLE [table] ADD [varchar] varchar(100) CONSTRAINT [table_varchar_default] DEFAULT ('escape''s quotes');`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns with defaults', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int().primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int().primaryKey(),
+			text1: text().default(''),
+			text2: text().default('text'),
+			int1: int().default(10),
+			int2: int().default(0),
+			int3: int().default(-10),
+			bool1: bit().default(true),
+			bool2: bit().default(false),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE [table] ADD [text1] text CONSTRAINT [table_text1_default] DEFAULT ('');`,
+		`ALTER TABLE [table] ADD [text2] text CONSTRAINT [table_text2_default] DEFAULT ('text');`,
+		`ALTER TABLE [table] ADD [int1] int CONSTRAINT [table_int1_default] DEFAULT ((10));`,
+		`ALTER TABLE [table] ADD [int2] int CONSTRAINT [table_int2_default] DEFAULT ((0));`,
+		`ALTER TABLE [table] ADD [int3] int CONSTRAINT [table_int3_default] DEFAULT ((-10));`,
+		`ALTER TABLE [table] ADD [bool1] bit CONSTRAINT [table_bool1_default] DEFAULT ((1));`,
+		`ALTER TABLE [table] ADD [bool2] bit CONSTRAINT [table_bool2_default] DEFAULT ((0));`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column should not cause rename unique. Name is not explicit', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [unique().on(t.id1)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id3: int('id3'), // renamed
+			id2: int('id2'),
+		}, (t) => [unique().on(t.id3)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id1->dbo.users.id3`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id1->dbo.users.id3`],
+	});
+
+	const st0 = [`EXEC sp_rename 'users.id1', [id3], 'COLUMN';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column should not cause rename default. Name is not explicit', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1').default(1),
+				id2: int('id2'),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id3: int('id3').default(1), // renamed
+			id2: int('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id1->dbo.users.id3`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id1->dbo.users.id3`],
+	});
+
+	const st0 = [`EXEC sp_rename 'users.id1', [id3], 'COLUMN';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column should not cause rename fk. Name is not explicit #1', async (t) => {
+	const table = mssqlTable('table', {
+		id: int().primaryKey(),
+	});
+	const schema1 = {
+		table,
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1').references(() => table.id),
+				id2: int('id2'),
+			},
+		),
+	};
+
+	const schema2 = {
+		table,
+		users: mssqlTable('users', {
+			id3: int('id3').references(() => table.id), // renamed
+			id2: int('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id1->dbo.users.id3`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id1->dbo.users.id3`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users.id1', [id3], 'COLUMN';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column should not cause rename unique. Name is explicit #1', async (t) => {
+	const table = mssqlTable('table', {
+		id: int(),
+	});
+	const schema1 = {
+		table,
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1').unique('unique_name'),
+				id2: int('id2'),
+			},
+		),
+	};
+
+	const schema2 = {
+		table,
+		users: mssqlTable('users', {
+			id3: int('id3').unique('unique_name'), // renamed
+			id2: int('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.id1->dbo.users.id3`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.id1->dbo.users.id3`],
+	});
+
+	const st0 = [`EXEC sp_rename 'users.id1', [id3], 'COLUMN';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #1. Rename table + rename column. Add default', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1').default(1),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users->dbo.users2',
+		'dbo.users2.id->dbo.users2.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: ['dbo.users->dbo.users2', 'dbo.users2.id->dbo.users2.id1'],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int CONSTRAINT [users2_id1_default] DEFAULT ((1));`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #6. Part of unique constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').unique().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_id_key];',
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_id_key] UNIQUE([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #7. Rename table. Part of unique constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').unique().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [`dbo.users->dbo.users2`]);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_id_key];',
+		`EXEC sp_rename 'users2.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id] int;`,
+		`INSERT INTO [users2] ([id]) SELECT [__old_id] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users_id_key] UNIQUE([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #8. Rename table + rename column. Part of unique constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').unique().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_id_key];',
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users_id_key] UNIQUE([id1]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #9. Rename table + rename column. Add unique', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users2_id1_key] UNIQUE([id1]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #9. Rename table + rename column. Drop unique', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').unique().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_id_key];',
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #10. Table has checks', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+			},
+			(t) => [check('hello_world', sql`${t.id} != 1`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}, (t) => [check('hello_world', sql`${t.id} != 1`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [hello_world];',
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+		'ALTER TABLE [users] ADD CONSTRAINT [hello_world] CHECK ([users].[id] != 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// Still expect recreate here. We could not know if the column is in check definition
+test('drop identity from existing column #11. Table has checks. Column is not in check', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar(),
+			},
+			(t) => [check('hello_world', sql`${t.name} != 'Alex'`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar(),
+		}, (t) => [check('hello_world', sql`${t.name} != 'Alex'`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [hello_world];',
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+		"ALTER TABLE [users] ADD CONSTRAINT [hello_world] CHECK ([users].[name] != 'Alex');",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #12. Rename table. Table has checks', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar(),
+			},
+			(t) => [check('hello_world', sql`${t.name} != 'Alex'`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id'),
+			name: varchar(),
+		}, (t) => [check('hello_world', sql`${t.name} != 'Alex'`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [`dbo.users->dbo.users2`]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [hello_world];',
+		`EXEC sp_rename 'users2.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id] int;`,
+		`INSERT INTO [users2] ([id]) SELECT [__old_id] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id];`,
+		"ALTER TABLE [users2] ADD CONSTRAINT [hello_world] CHECK ([users2].[name] != 'Alex');",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #13. Rename table + Rename column. Add check', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1'),
+			name: varchar(),
+		}, (t) => [check('hello_world', sql`${t.name} != 'Alex'`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		"ALTER TABLE [users2] ADD CONSTRAINT [hello_world] CHECK ([users2].[name] != 'Alex');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #14. Rename table + Rename column. Drop check', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar(),
+			},
+			(t) => [check('hello_world', sql`${t.name} != 'Alex'`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1'),
+			name: varchar(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`ALTER TABLE [users2] DROP CONSTRAINT [hello_world];`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #15. Rename table + Rename column. Table has checks', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar(),
+			},
+			(t) => [check('hello_world', sql`${t.name} != 'Alex'`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1'),
+			name: varchar(),
+		}, (t) => [check('hello_world', sql`${t.name} != 'Alex'`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`ALTER TABLE [users2] DROP CONSTRAINT [hello_world];`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		"ALTER TABLE [users2] ADD CONSTRAINT [hello_world] CHECK ([users2].[name] != 'Alex');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #16. Part of fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+	const schema1 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => users.id),
+		}),
+		users,
+	};
+
+	const droppedIdentity = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema2 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => droppedIdentity.id),
+		}),
+		users: droppedIdentity,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [ref] DROP CONSTRAINT [ref_age_users_id_fk];\n',
+		`ALTER TABLE [users] DROP CONSTRAINT [users_pkey];`,
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int NOT NULL;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id]);`,
+		`ALTER TABLE [ref] ADD CONSTRAINT [ref_age_users_id_fk] FOREIGN KEY ([age]) REFERENCES [users]([id]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// This is really strange case. Do not think this is a real business case
+// But this could be created in mssql so i checked that
+// (column with identity references to other column)
+test('drop identity from existing column #17. Part of fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey(),
+			name: varchar(),
+		},
+	);
+	const schema1 = {
+		users2: mssqlTable('users2', {
+			id: int('id').identity().references(() => users.id),
+			name: varchar(),
+		}),
+		users,
+	};
+
+	const schema2 = {
+		users2: mssqlTable('users2', {
+			id: int('id').references(() => users.id), // dropped identity
+			name: varchar(),
+		}),
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users2_id_users_id_fk];\n',
+		`EXEC sp_rename 'users2.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id] int;`,
+		`INSERT INTO [users2] ([id]) SELECT [__old_id] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id];`,
+		`ALTER TABLE [users2] ADD CONSTRAINT [users2_id_users_id_fk] FOREIGN KEY ([id]) REFERENCES [users]([id]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #18. Rename Table. Part of fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+	const schema1 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => users.id),
+		}),
+		users,
+	};
+
+	const droppedIdentity = mssqlTable(
+		'new_users',
+		{
+			id: int('id').primaryKey(),
+		},
+	);
+	const schema2 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => droppedIdentity.id),
+		}),
+		users: droppedIdentity,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, ['dbo.users->dbo.new_users']);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: ['dbo.users->dbo.new_users'],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [new_users];`,
+		'ALTER TABLE [ref] DROP CONSTRAINT [ref_age_users_id_fk];\n',
+		`ALTER TABLE [new_users] DROP CONSTRAINT [users_pkey];`,
+		`EXEC sp_rename 'new_users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [new_users] ADD [id] int NOT NULL;`,
+		`INSERT INTO [new_users] ([id]) SELECT [__old_id] FROM [new_users];`,
+		`ALTER TABLE [new_users] DROP COLUMN [__old_id];`,
+		`ALTER TABLE [new_users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id]);`,
+		`ALTER TABLE [ref] ADD CONSTRAINT [ref_age_users_id_fk] FOREIGN KEY ([age]) REFERENCES [new_users]([id]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #19. Rename Table + Rename column. Part of fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+	const schema1 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => users.id),
+		}),
+		users,
+	};
+
+	const droppedIdentity = mssqlTable(
+		'new_users',
+		{
+			id: int('id1').primaryKey(),
+		},
+	);
+	const schema2 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => droppedIdentity.id),
+		}),
+		users: droppedIdentity,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.new_users`,
+		`dbo.new_users.id->dbo.new_users.id1`,
+	]);
+
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.new_users`, `dbo.new_users.id->dbo.new_users.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [new_users];`,
+		`EXEC sp_rename 'new_users.id', [id1], 'COLUMN';`,
+		'ALTER TABLE [ref] DROP CONSTRAINT [ref_age_users_id_fk];\n',
+		`ALTER TABLE [new_users] DROP CONSTRAINT [users_pkey];`,
+		`EXEC sp_rename 'new_users.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [new_users] ADD [id1] int NOT NULL;`,
+		`INSERT INTO [new_users] ([id1]) SELECT [__old_id1] FROM [new_users];`,
+		`ALTER TABLE [new_users] DROP COLUMN [__old_id1];`,
+		`ALTER TABLE [new_users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id1]);`,
+		`ALTER TABLE [ref] ADD CONSTRAINT [ref_age_users_id_fk] FOREIGN KEY ([age]) REFERENCES [new_users]([id1]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #20. Rename Table + Rename column. Add fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+	const schema1 = {
+		ref: mssqlTable('ref', {
+			age: int().unique(),
+		}),
+		users,
+	};
+
+	const droppedIdentity = mssqlTable(
+		'new_users',
+		{
+			id: int('id1').primaryKey(),
+		},
+	);
+	const schema2 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => droppedIdentity.id),
+		}),
+		users: droppedIdentity,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users->dbo.new_users',
+		'dbo.new_users.id->dbo.new_users.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: ['dbo.users->dbo.new_users', 'dbo.new_users.id->dbo.new_users.id1'],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [new_users];`,
+		`EXEC sp_rename 'new_users.id', [id1], 'COLUMN';`,
+		`ALTER TABLE [new_users] DROP CONSTRAINT [users_pkey];`,
+		`EXEC sp_rename 'new_users.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [new_users] ADD [id1] int NOT NULL;`,
+		`INSERT INTO [new_users] ([id1]) SELECT [__old_id1] FROM [new_users];`,
+		`ALTER TABLE [new_users] DROP COLUMN [__old_id1];`,
+		`ALTER TABLE [new_users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id1]);`,
+		`ALTER TABLE [ref] ADD CONSTRAINT [ref_age_new_users_id1_fk] FOREIGN KEY ([age]) REFERENCES [new_users]([id1]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #21. Rename Table + Rename column. Drop fk', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+	const schema1 = {
+		ref: mssqlTable('ref', {
+			age: int().unique().references(() => users.id),
+		}),
+		users,
+	};
+
+	const droppedIdentity = mssqlTable(
+		'new_users',
+		{
+			id: int('id1').primaryKey(),
+		},
+	);
+	const schema2 = {
+		ref: mssqlTable('ref', {
+			age: int().unique(),
+		}),
+		users: droppedIdentity,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'dbo.users->dbo.new_users',
+		'dbo.new_users.id->dbo.new_users.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: ['dbo.users->dbo.new_users', 'dbo.new_users.id->dbo.new_users.id1'],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [new_users];`,
+		`EXEC sp_rename 'new_users.id', [id1], 'COLUMN';`,
+		`ALTER TABLE [ref] DROP CONSTRAINT [ref_age_users_id_fk];\n`,
+		`ALTER TABLE [new_users] DROP CONSTRAINT [users_pkey];`,
+		`EXEC sp_rename 'new_users.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [new_users] ADD [id1] int NOT NULL;`,
+		`INSERT INTO [new_users] ([id1]) SELECT [__old_id1] FROM [new_users];`,
+		`ALTER TABLE [new_users] DROP COLUMN [__old_id1];`,
+		`ALTER TABLE [new_users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id1]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #22. Part of pk constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int NOT NULL;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #23. Rename table. Part of pk constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [`dbo.users->dbo.users2`]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_pkey];',
+		`EXEC sp_rename 'users2.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id] int NOT NULL;`,
+		`INSERT INTO [users2] ([id]) SELECT [__old_id] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #24. Rename table + rename column. Part of pk constraint', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_pkey];',
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int NOT NULL;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([id1]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #25. Rename table + rename column. Add pk', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int NOT NULL;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+		'ALTER TABLE [users2] ADD CONSTRAINT [users2_pkey] PRIMARY KEY ([id1]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #26. Rename table + rename column. Drop pk', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey().identity(),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users->dbo.users2`,
+		`dbo.users2.id->dbo.users2.id1`,
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users->dbo.users2`, `dbo.users2.id->dbo.users2.id1`],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id1], 'COLUMN';`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_pkey];',
+		`EXEC sp_rename 'users2.id1', [__old_id1], 'COLUMN';`,
+		`ALTER TABLE [users2] ADD [id1] int;`,
+		`INSERT INTO [users2] ([id1]) SELECT [__old_id1] FROM [users2];`,
+		`ALTER TABLE [users2] DROP COLUMN [__old_id1];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from existing column #27. Add not null and add default', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').identity(),
+				name: varchar({ length: 100 }),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').default(1).notNull(),
+			name: varchar({ length: 100 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+
+	await db.query(`INSERT INTO [users] ([name]) VALUES ('Alex');`);
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int NOT NULL CONSTRAINT [users_id_default] DEFAULT ((1));`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// TODO add more 'create identity' tests
+test('add identity to existing column', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id'),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int IDENTITY(1, 1);`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change data type', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [`ALTER TABLE [users] ALTER COLUMN [name] varchar;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change data type + add not null', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [`ALTER TABLE [users] ALTER COLUMN [name] varchar NOT NULL;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change data type + drop not null', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [`ALTER TABLE [users] ALTER COLUMN [name] varchar;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('same column names in two tables. Check for correct not null creation. Explicit column names', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int('id').primaryKey().identity(),
+			departmentId: int('department_id').references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = mssqlTable(
+		'user_has_department_filter',
+		{
+			userId: int('user_id').references(() => users.id),
+			departmentId: int('department_id').references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = mssqlTable(
+		'departments',
+		{
+			id: int('id').primaryKey().identity(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE [departments] (
+\t[id] int IDENTITY(1, 1),
+\tCONSTRAINT [departments_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [user_has_department_filter] (
+\t[user_id] int,
+\t[department_id] int,
+\tCONSTRAINT [user_has_department_filter_pkey] PRIMARY KEY([user_id],[department_id])
+);\n`,
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(1, 1),
+\t[department_id] int,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id])
+);\n`,
+
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_user_id_users_id_fk] FOREIGN KEY ([user_id]) REFERENCES [users]([id]);`,
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_department_id_departments_id_fk] FOREIGN KEY ([department_id]) REFERENCES [departments]([id]);`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_department_id_departments_id_fk] FOREIGN KEY ([department_id]) REFERENCES [departments]([id]) ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #2. no casing', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int().primaryKey().identity(),
+			departmentId: int().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = mssqlTable(
+		'user_has_department_filter',
+		{
+			userId: int().references(() => users.id),
+			departmentId: int().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = mssqlTable(
+		'departments',
+		{
+			id: int().primaryKey().identity(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE [departments] (
+\t[id] int IDENTITY(1, 1),
+\tCONSTRAINT [departments_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [user_has_department_filter] (
+\t[userId] int,
+\t[departmentId] int,
+\tCONSTRAINT [user_has_department_filter_pkey] PRIMARY KEY([userId],[departmentId])
+);\n`,
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(1, 1),
+\t[departmentId] int,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id])
+);\n`,
+
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_userId_users_id_fk] FOREIGN KEY ([userId]) REFERENCES [users]([id]);`,
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_departmentId_departments_id_fk] FOREIGN KEY ([departmentId]) REFERENCES [departments]([id]);`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_departmentId_departments_id_fk] FOREIGN KEY ([departmentId]) REFERENCES [departments]([id]) ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #3. camelCase', async (t) => {
+	const users = mssqlTable(
+		'users',
+		{
+			id: int().primaryKey().identity(),
+			departmentId: int().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = mssqlTable(
+		'user_has_department_filter',
+		{
+			userId: int().references(() => users.id),
+			departmentId: int().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = mssqlTable(
+		'departments',
+		{
+			id: int().primaryKey().identity(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE [departments] (
+\t[id] int IDENTITY(1, 1),
+\tCONSTRAINT [departments_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [user_has_department_filter] (
+\t[userId] int,
+\t[departmentId] int,
+\tCONSTRAINT [user_has_department_filter_pkey] PRIMARY KEY([userId],[departmentId])
+);\n`,
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(1, 1),
+\t[departmentId] int,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id])
+);\n`,
+
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_userId_users_id_fk] FOREIGN KEY ([userId]) REFERENCES [users]([id]);`,
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_departmentId_departments_id_fk] FOREIGN KEY ([departmentId]) REFERENCES [departments]([id]);`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_departmentId_departments_id_fk] FOREIGN KEY ([departmentId]) REFERENCES [departments]([id]) ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #4. snake_case', async (t) => {
+	const users = snakeCase.table(
+		'users',
+		{
+			id: int().primaryKey().identity(),
+			departmentId: int().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = snakeCase.table(
+		'user_has_department_filter',
+		{
+			userId: int().references(() => users.id),
+			departmentId: int().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = snakeCase.table(
+		'departments',
+		{
+			id: int().primaryKey().identity(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE [departments] (
+\t[id] int IDENTITY(1, 1),
+\tCONSTRAINT [departments_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [user_has_department_filter] (
+\t[user_id] int,
+\t[department_id] int,
+\tCONSTRAINT [user_has_department_filter_pkey] PRIMARY KEY([user_id],[department_id])
+);\n`,
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(1, 1),
+\t[department_id] int,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id])
+);\n`,
+
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_user_id_users_id_fk] FOREIGN KEY ([user_id]) REFERENCES [users]([id]);`,
+		`ALTER TABLE [user_has_department_filter] ADD CONSTRAINT [user_has_department_filter_department_id_departments_id_fk] FOREIGN KEY ([department_id]) REFERENCES [departments]([id]);`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_department_id_departments_id_fk] FOREIGN KEY ([department_id]) REFERENCES [departments]([id]) ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mssql/constraints.test.ts b/drizzle-kit/tests/mssql/constraints.test.ts
new file mode 100644
index 0000000000..47deea0824
--- /dev/null
+++ b/drizzle-kit/tests/mssql/constraints.test.ts
@@ -0,0 +1,2578 @@
+import { desc, sql } from 'drizzle-orm';
+import {
+	AnyMsSqlColumn,
+	bit,
+	check,
+	foreignKey,
+	index,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	nvarchar,
+	primaryKey,
+	unique,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { defaultNameForPK } from 'src/dialects/mssql/grammar';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('drop primary key', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int().primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st1 } = await diff(schema1, schema2, []);
+
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [table] DROP CONSTRAINT [table_pkey];',
+		'ALTER TABLE [table] ALTER COLUMN [id] int;',
+	];
+
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop primary key with not null', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int().primaryKey().notNull(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int().notNull(),
+		}),
+	};
+
+	const { sqlStatements: st1 } = await diff(schema1, schema2, []);
+
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [table] DROP CONSTRAINT [table_pkey];',
+	];
+
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop unique', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int().unique(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expSt0 = [
+		`CREATE TABLE [table] (
+\t[id] int,
+\tCONSTRAINT [table_id_key] UNIQUE([id])
+);\n`,
+	];
+	expect(st1).toStrictEqual(expSt0);
+	expect(pst1).toStrictEqual(expSt0);
+
+	const { sqlStatements: st2 } = await diff(schema1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expSt1 = [
+		'ALTER TABLE [table] DROP CONSTRAINT [table_id_key];',
+	];
+	expect(st2).toStrictEqual(expSt1);
+	expect(pst2).toStrictEqual(expSt1);
+});
+
+test('add fk', async () => {
+	const table = mssqlTable('table', {
+		id: int().primaryKey(),
+	});
+	const table1 = mssqlTable('table1', {
+		id: int(),
+	});
+	const schema1 = {
+		table,
+		table1,
+	};
+
+	const table1WithReference = mssqlTable('table1', {
+		id: int().references(() => table.id),
+	});
+	const schema2 = {
+		table,
+		table1: table1WithReference,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [table1] ADD CONSTRAINT [table1_id_table_id_fk] FOREIGN KEY ([id]) REFERENCES [table]([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop fk', async () => {
+	const table = mssqlTable('table', {
+		id: int().primaryKey(),
+	});
+	const table1WithReference = mssqlTable('table1', {
+		id: int().references(() => table.id),
+	});
+
+	const schema1 = {
+		table,
+		table1: table1WithReference,
+	};
+
+	const table1 = mssqlTable('table1', {
+		id: int(),
+	});
+	const schema2 = {
+		table,
+		table1,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [table1] DROP CONSTRAINT [table1_id_table_id_fk];\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename pk #1', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id1: int('id1'),
+				id2: int('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1'),
+			id2: int('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.users.compositePK->dbo.users.${defaultNameForPK('users')}`,
+	]);
+
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.users.compositePK->dbo.users.${defaultNameForPK('users')}`],
+	});
+
+	const st0 = [`EXEC sp_rename 'compositePK', [users_pkey], 'OBJECT';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push will not change name if changed to !explicit
+});
+
+test('add unique', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE [table] ADD CONSTRAINT [table_id_key] UNIQUE([id]);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename unique', async (t) => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int().unique('old_name'),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int().unique('new_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		`dbo.table.old_name->dbo.table.new_name`,
+	]);
+	await push({
+		db,
+		to: schema1,
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [`dbo.table.old_name->dbo.table.new_name`],
+	});
+
+	const st0 = [`EXEC sp_rename 'old_name', [new_name], 'OBJECT';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #1', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_key] UNIQUE([name]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #2', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).unique('unique_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [unique_name] UNIQUE([name]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #3', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [unique_name] UNIQUE([name]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #4', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		`ALTER TABLE [users] DROP CONSTRAINT [unique_name];`,
+		`ALTER TABLE [users] ADD CONSTRAINT [unique_name2] UNIQUE([name]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #5', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users.unique_name->dbo.users.unique_name2',
+	]);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+		renames: [
+			'dbo.users.unique_name->dbo.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		"EXEC sp_rename 'unique_name', [unique_name2], 'OBJECT';",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #6', async () => {
+	const mySchema = mssqlSchema('my_schema');
+	const from = {
+		mySchema,
+		users: mySchema.table('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		mySchema,
+		users: mySchema.table('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'my_schema.users.unique_name->my_schema.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'my_schema.users.unique_name->my_schema.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		"EXEC sp_rename 'my_schema.unique_name', [unique_name2], 'OBJECT';",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #7', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			email2: varchar({ length: 255 }).unique(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users.email->dbo.users.email2',
+		'dbo.users.unique_name->dbo.users.unique_name2',
+	]);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+		renames: [
+			'dbo.users.email->dbo.users.email2',
+			'dbo.users.unique_name->dbo.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users.email', [email2], 'COLUMN';`,
+		`EXEC sp_rename 'unique_name', [unique_name2], 'OBJECT';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* rename table */
+test('unique #8', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users->dbo.users2',
+	]);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+		renames: [
+			'dbo.users->dbo.users2',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #9', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}),
+	};
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			email2: varchar({ length: 255 }).unique('users_email_key'),
+		}),
+	};
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			email2: varchar({ length: 255 }),
+		}),
+	};
+
+	// sch1 -> sch2
+	const { sqlStatements: st1, next: n1 } = await diff(sch1, sch2, [
+		'dbo.users->dbo.users2',
+		'dbo.users2.email->dbo.users2.email2',
+	]);
+
+	await push({ db, to: sch1, schemas: ['dbo'] });
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: sch2,
+		schemas: ['dbo'],
+		renames: [
+			'dbo.users->dbo.users2',
+			'dbo.users2.email->dbo.users2.email2',
+		],
+	});
+
+	const st10 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.email', [email2], 'COLUMN';`,
+	];
+	expect(st1).toStrictEqual(st10);
+	expect(pst1).toStrictEqual(st10);
+
+	// sch2 -> sch3
+	const { sqlStatements: st2 } = await diff(n1, sch3, []);
+
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: sch3,
+		schemas: ['dbo'],
+	});
+
+	const st20 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_email_key];',
+	];
+	expect(st2).toStrictEqual(st20);
+	expect(pst2).toStrictEqual(st20);
+});
+
+test('unique multistep #1', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const e1 = ['CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).unique(),
+		}),
+	};
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.name->dbo.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const e3 = ['ALTER TABLE [users2] DROP CONSTRAINT [users_name_key];'];
+
+	expect(pst4).toStrictEqual(e3);
+	expect(st4).toStrictEqual(e3);
+});
+
+test('unique multistep #2', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+	expect(st1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+	]);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).unique(),
+		}),
+	};
+
+	const r1 = [
+		'dbo.users->dbo.users2',
+		'dbo.users2.name->dbo.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, r1);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames: r1, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(pst2).toStrictEqual(e2);
+	expect(st2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+
+	const sch4 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4, schemas: ['dbo'] });
+	expect(st5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users_name_key];']);
+	expect(pst5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users_name_key];']);
+});
+
+test('unique multistep #3', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+	]);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).unique(),
+		}),
+	};
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.name->dbo.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const e4 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_name_key];',
+		'ALTER TABLE [users2] ADD CONSTRAINT [name_unique] UNIQUE([name2]);',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4, schemas: ['dbo'] });
+	expect(st5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [name_unique];']);
+	expect(pst5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [name_unique];']);
+});
+
+test('pk #1', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).notNull(),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey().notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	expect(st).toStrictEqual(['ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);']);
+	expect(pst).toStrictEqual(['ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);']);
+});
+
+test('pk #2', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #3', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #4', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #5', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+		'ALTER TABLE [users] ALTER COLUMN [name] varchar(255);',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #6', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255) NOT NULL;`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk extra #1', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255) NOT NULL;`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// drop pk
+	// expect to drop not null because current state is without not null
+	// expect to drop pk
+	const to2 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: to2 });
+
+	const st01 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255);`,
+	];
+	expect(st2).toStrictEqual(st01);
+	expect(pst2).toStrictEqual(st01);
+});
+
+test('pk extra #2', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255) NOT NULL;`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// drop pk but left not nutt
+	// expect to drop pk only
+	const to2 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).notNull(),
+		}),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: to2 });
+
+	const st01 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+	];
+	expect(st2).toStrictEqual(st01);
+	expect(pst2).toStrictEqual(st01);
+});
+
+test('pk extra #3', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255) NOT NULL;`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// drop pk
+	// expect to drop not null because current state is without not null
+	// expect to drop pk
+	const to2 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: to2 });
+
+	const st01 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255);`,
+	];
+	expect(st2).toStrictEqual(st01);
+	expect(pst2).toStrictEqual(st01);
+});
+
+test('pk extra #4', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(255) NOT NULL;`,
+		'ALTER TABLE [users] ADD CONSTRAINT [users_pkey] PRIMARY KEY ([name]);',
+	];
+	expect(st1).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// drop pk but left not nutt
+	// expect to drop pk only
+	const to2 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).notNull(),
+		}),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: to2 });
+
+	const st01 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_pkey];',
+	];
+	expect(st2).toStrictEqual(st01);
+	expect(pst2).toStrictEqual(st01);
+});
+
+test('pk multistep #1', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const res1 = ['CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_pkey] PRIMARY KEY([name])\n);\n'];
+	expect(st1).toStrictEqual(res1);
+	expect(pst1).toStrictEqual(res1);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).primaryKey(),
+		}),
+	};
+
+	const renames = [
+		'dbo.users->dbo.users2',
+		'dbo.users2.name->dbo.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const st04 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_pkey];',
+		`ALTER TABLE [users2] ALTER COLUMN [name2] varchar(255);`,
+	];
+	expect(st4).toStrictEqual(st04);
+	expect(pst4).toStrictEqual(st04);
+});
+
+test('pk multistep #2', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const res1 = ['CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_pkey] PRIMARY KEY([name])\n);\n'];
+	expect(st1).toStrictEqual(res1);
+	expect(pst1).toStrictEqual(res1);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'dbo.users->dbo.users2',
+		'dbo.users2.name->dbo.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const renames2 = ['dbo.users2.users_pkey->dbo.users2.users2_pk'];
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, renames2);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, renames: renames2, schemas: ['dbo'] });
+
+	expect(st4).toStrictEqual([`EXEC sp_rename 'users_pkey', [users2_pk], 'OBJECT';`]);
+	expect(pst4).toStrictEqual([`EXEC sp_rename 'users_pkey', [users2_pk], 'OBJECT';`]);
+
+	const sch4 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4, schemas: ['dbo'] });
+
+	const st05 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users2_pk];',
+		`ALTER TABLE [users2] ALTER COLUMN [name2] varchar(255);`,
+	];
+	expect(st5).toStrictEqual(st05);
+	expect(pst5).toStrictEqual(st05);
+});
+
+test('pk multistep #3', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_pkey] PRIMARY KEY([name])\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE [users] (\n\t[name] varchar(255),\n\tCONSTRAINT [users_pkey] PRIMARY KEY([name])\n);\n',
+	]);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'dbo.users->dbo.users2',
+		'dbo.users2.name->dbo.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const e4 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_pkey];',
+		'ALTER TABLE [users2] ADD CONSTRAINT [users2_pk] PRIMARY KEY ([name2]);',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4, schemas: ['dbo'] });
+
+	const st05 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users2_pk];',
+		`ALTER TABLE [users2] ALTER COLUMN [name2] varchar(255);`,
+	];
+	expect(st5).toStrictEqual(st05);
+	expect(pst5).toStrictEqual(st05);
+});
+
+test('pk multistep #4', async () => {
+	const users = mssqlTable('users', {
+		id: int().primaryKey(),
+		id2: int(),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int(),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const e1 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[id2] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	const e2 = [
+		'CREATE TABLE [users2] (\n\t[id3] int,\n\t[id2] int,\n\tCONSTRAINT [users2_pkey] PRIMARY KEY([id3])\n);\n',
+		'DROP TABLE [users];',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+test('fk #1', async () => {
+	const users = mssqlTable('users', {
+		id: int().primaryKey(),
+	});
+	const posts = mssqlTable('posts', {
+		id: int().primaryKey(),
+		authorId: int().references(() => users.id),
+	});
+
+	const to = {
+		posts,
+		users,
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		`CREATE TABLE [posts] (\n\t[id] int,\n\t[authorId] int,\n\tCONSTRAINT [posts_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`ALTER TABLE [posts] ADD CONSTRAINT [posts_authorId_users_id_fk] FOREIGN KEY ([authorId]) REFERENCES [users]([id]);`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// exactly 128 symbols fk, fk name explicit
+test('fk #2', async () => {
+	const users = mssqlTable('123456789_123456789_123456789_123456789_123456789_12_users', {
+		id3: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id3),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		`CREATE TABLE [123456789_123456789_123456789_123456789_123456789_12_users] (\n\t[id3] int,\n\t[id2] int,\n\tCONSTRAINT [123456789_123456789_123456789_123456789_123456789_12_users_pkey] PRIMARY KEY([id3])\n);\n`,
+		'ALTER TABLE [123456789_123456789_123456789_123456789_123456789_12_users] ADD CONSTRAINT [123456789_123456789_123456789_123456789_123456789_12_users_id2_123456789_123456789_123456789_123456789_123456789_12_users_id3_fk] FOREIGN KEY ([id2]) REFERENCES [123456789_123456789_123456789_123456789_123456789_12_users]([id3]);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// 130 symbols fkey, fkey = table_hash_fkey
+test('fk #3', async () => {
+	const users = mssqlTable('123456789_123456789_123456789_123456789_123456789_123_users', {
+		id3: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id3),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		`CREATE TABLE [123456789_123456789_123456789_123456789_123456789_123_users] (\n\t[id3] int,\n\t[id2] int,\n\tCONSTRAINT [123456789_123456789_123456789_123456789_123456789_123_users_pkey] PRIMARY KEY([id3])\n);\n`,
+		'ALTER TABLE [123456789_123456789_123456789_123456789_123456789_123_users] ADD CONSTRAINT [123456789_123456789_123456789_123456789_123456789_123_users_RqTNlAl1EEx0_fk] FOREIGN KEY ([id2]) REFERENCES [123456789_123456789_123456789_123456789_123456789_123_users]([id3]);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// >=110 length table name, fkey = hash_fkey
+test('fk #4', async () => {
+	const users = mssqlTable(
+		'1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_123456_users',
+		{
+			id: int().primaryKey(),
+			id2: int().references((): AnyMsSqlColumn => users.id),
+		},
+	);
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		`CREATE TABLE [1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_123456_users] (\n\t[id] int,\n\t[id2] int,\n\tCONSTRAINT [1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_123456_users_pkey] PRIMARY KEY([id])\n);\n`,
+		'ALTER TABLE [1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_123456_users] ADD CONSTRAINT [1roIIPOipLA5_fk] FOREIGN KEY ([id2]) REFERENCES [1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_1234567890_123456_users]([id]);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #5', async () => {
+	const users = mssqlTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users2.id),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.id->dbo.users2.id3'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, renames, schemas: ['dbo'] });
+
+	const e = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id3], 'COLUMN';`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #7', async () => {
+	const users = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id1),
+	});
+
+	const users2 = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({ name: 'id2_id1_fk', columns: [t.id2], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['dbo.users.users_id2_users_id1_fk->dbo.users.id2_id1_fk'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, renames, schemas: ['dbo'] });
+
+	const e = [
+		`EXEC sp_rename 'users_id2_users_id1_fk', [id2_id1_fk], 'OBJECT';`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #8', async () => {
+	const users = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int().references((): AnyMsSqlColumn => users.id1),
+	});
+
+	const users2 = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int().references((): AnyMsSqlColumn => users.id2),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_id3_users_id1_fk];\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_id3_users_id2_fk] FOREIGN KEY ([id3]) REFERENCES [users]([id2]);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #9', async () => {
+	const users = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const users2 = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id2] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, schemas: ['dbo'] });
+
+	const e = [
+		`ALTER TABLE [users] DROP CONSTRAINT [fk1];\n`,
+		`ALTER TABLE [users] ADD CONSTRAINT [fk1] FOREIGN KEY ([id3]) REFERENCES [users]([id2]);`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #10', async () => {
+	const users = mssqlTable('users', {
+		id1: int().primaryKey(),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id1: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users2.id1),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['dbo.users->dbo.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, renames, schemas: ['dbo'] });
+
+	const e = [
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] ADD [id2] int;',
+		'ALTER TABLE [users2] ADD CONSTRAINT [users2_id2_users2_id1_fk] FOREIGN KEY ([id2]) REFERENCES [users2]([id1]);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #11', async () => {
+	const users = mssqlTable('users', {
+		id1: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id1),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id1: int().primaryKey(),
+		id2: int(),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['dbo.users->dbo.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to, renames, schemas: ['dbo'] });
+
+	const e = [
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_id2_users_id1_fk];\n',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk multistep #1', async () => {
+	const users = mssqlTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const e1 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[id2] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_id2_users_id_fk] FOREIGN KEY ([id2]) REFERENCES [users]([id]);',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.id->dbo.users2.id3'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.id', [id3], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const users3 = mssqlTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int(),
+	});
+	const sch3 = { users: users3 };
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+	expect(st4).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users_id2_users_id_fk];\n']);
+	expect(pst4).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users_id2_users_id_fk];\n']);
+});
+
+test('fk multistep #2', async () => {
+	const users = mssqlTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users.id),
+	});
+
+	const users2 = mssqlTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnyMsSqlColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const e1 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[id2] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_id2_users_id_fk] FOREIGN KEY ([id2]) REFERENCES [users]([id]);',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	const e2 = [
+		'CREATE TABLE [users2] (\n\t[id3] int,\n\t[id2] int,\n\tCONSTRAINT [users2_pkey] PRIMARY KEY([id3])\n);\n',
+		'DROP TABLE [users];',
+		'ALTER TABLE [users2] ADD CONSTRAINT [users2_id2_users2_id3_fk] FOREIGN KEY ([id2]) REFERENCES [users2]([id3]);',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456#issuecomment-3076042688
+test('fk multistep #3', async () => {
+	const foo = mssqlTable('foo', {
+		id: int().primaryKey(),
+	});
+
+	const bar = mssqlTable('bar', {
+		id: int().primaryKey(),
+		fooId: int().references(() => foo.id),
+	});
+
+	const schema1 = { foo, bar };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE [foo] (\n\t[id] int,\n\tCONSTRAINT [foo_pkey] PRIMARY KEY([id])\n);\n',
+		'CREATE TABLE [bar] (\n\t[id] int,\n\t[fooId] int,\n\tCONSTRAINT [bar_pkey] PRIMARY KEY([id])\n);\n',
+		'ALTER TABLE [bar] ADD CONSTRAINT [bar_fooId_foo_id_fk] FOREIGN KEY ([fooId]) REFERENCES [foo]([id]);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		bar: mssqlTable('bar', {
+			id: int().primaryKey(),
+			fooId: int(),
+		}),
+	};
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE [bar] DROP CONSTRAINT [bar_fooId_foo_id_fk];\n',
+		'DROP TABLE [foo];',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('add check', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}, (t) => [check('new_check', sql`${t.id} != 10`), check('new_check2', sql`${t.id} != 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [table] ADD CONSTRAINT [new_check] CHECK ([table].[id] != 10);',
+		'ALTER TABLE [table] ADD CONSTRAINT [new_check2] CHECK ([table].[id] != 10);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check', async () => {
+	const schema1 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}, (t) => [check('new_check', sql`${t.id} != 10`)]),
+	};
+
+	const schema2 = {
+		table: mssqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		'ALTER TABLE [table] DROP CONSTRAINT [new_check];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with check', async (t) => {
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, schemas: ['dbo'] });
+
+	const st0 = [`CREATE TABLE [users] (
+\t[id] int,
+\t[age] int,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id]),
+\tCONSTRAINT [some_check_name] CHECK ([users].[age] > 21)
+);\n`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check contraint to existing table', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [some_check_name] CHECK ([users].[age] > 21);`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check contraint in existing table', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] DROP CONSTRAINT [some_check_name];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('recreate check constraint (renamed)', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE [users] DROP CONSTRAINT [some_check_name];`,
+		`ALTER TABLE [users] ADD CONSTRAINT [new_check_name] CHECK ([users].[age] > 21);`,
+	]);
+});
+
+test('rename check constraint', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.users.some_check_name->dbo.users.new_check_name']);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: to,
+		schemas: ['dbo'],
+		renames: ['dbo.users.some_check_name->dbo.users.new_check_name'],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'some_check_name', [new_check_name], 'OBJECT';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter check constraint (definition)', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: to, schemas: ['dbo'] });
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE [users] DROP CONSTRAINT [some_check_name];`,
+		`ALTER TABLE [users] ADD CONSTRAINT [some_check_name] CHECK ([users].[age] > 10);`,
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('alter multiple check constraints (rename)', async (t) => {
+	const from = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				age: int('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_1', sql`${table.age} > 21`),
+				check('some_check_name_2', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const to = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				age: int('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_3', sql`${table.age} > 21`),
+				check('some_check_name_4', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: to, schemas: ['dbo'] });
+
+	const st0 = [
+		`ALTER TABLE [users] DROP CONSTRAINT [some_check_name_1];`,
+		`ALTER TABLE [users] DROP CONSTRAINT [some_check_name_2];`,
+		`ALTER TABLE [users] ADD CONSTRAINT [some_check_name_3] CHECK ([users].[age] > 21);`,
+		`ALTER TABLE [users] ADD CONSTRAINT [some_check_name_4] CHECK ([users].[name] != 'Alex');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create checks with same names', async (t) => {
+	const to = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				age: int('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [check('some_check_name', sql`${table.age} > 21`), check('some_check_name', sql`${table.name} != 'Alex'`)],
+		),
+	};
+
+	// 'constraint_name_duplicate'
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to: to, schemas: ['dbo'] })).rejects.toThrow();
+});
+
+test('rename table. Table has checks', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id'),
+				name: varchar(),
+			},
+			(t) => [check('hello_world', sql`${t.name} != 'Alex'`)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users2', {
+			id: int('id'),
+			name: varchar(),
+		}, (t) => [check('hello_world', sql`${t.name} != 'Alex'`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [`dbo.users->dbo.users2`]);
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'], renames: [`dbo.users->dbo.users2`] });
+
+	expect(st).toStrictEqual([
+		`EXEC sp_rename 'users', [users2];`,
+		'ALTER TABLE [users2] DROP CONSTRAINT [hello_world];',
+		"ALTER TABLE [users2] ADD CONSTRAINT [hello_world] CHECK ([users2].[name] != 'Alex');",
+	]);
+	expect(pst).toStrictEqual([`EXEC sp_rename 'users', [users2];`]); // do not trigger on definition change when using push
+});
+
+test('add composite pks on existing table', async (t) => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id1: int('id1').notNull(),
+			id2: int('id2').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id1: int('id1').notNull(),
+			id2: int('id2').notNull(),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = ['ALTER TABLE [users] ADD CONSTRAINT [compositePK] PRIMARY KEY ([id1],[id2]);'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default #1', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_default] DEFAULT ('hey') FOR [name];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default #2', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default #3', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+		renames: [],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP CONSTRAINT [users_name_default];',
+		"ALTER TABLE [users] ADD CONSTRAINT [users_name_default] DEFAULT ('hey1') FOR [name];",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default #4', async () => {
+	const mySchema = mssqlSchema('my_schema');
+	const from = {
+		mySchema,
+		users: mySchema.table('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+	const to = {
+		mySchema,
+		users: mySchema.table('users', {
+			name: varchar('name2', { length: 255 }).default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'my_schema.users.name->my_schema.users.name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'my_schema.users.name->my_schema.users.name2',
+		],
+	});
+
+	const st0 = [
+		"EXEC sp_rename 'my_schema.users.name', [name2], 'COLUMN';",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* rename table */
+test('default #5', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			email: varchar({ length: 255 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users->dbo.users2',
+	]);
+
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+		renames: [
+			'dbo.users->dbo.users2',
+		],
+	});
+
+	const st0 = [
+		`EXEC sp_rename 'users', [users2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default multistep #1', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const e1 = [
+		"CREATE TABLE [users] (\n\t[name] varchar(255) CONSTRAINT [users_name_default] DEFAULT ('hey')\n);\n",
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).default('hey'),
+		}),
+	};
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.name->dbo.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const e3 = ['ALTER TABLE [users2] DROP CONSTRAINT [users_name_default];'];
+
+	expect(pst4).toStrictEqual(e3);
+	expect(st4).toStrictEqual(e3);
+});
+
+test('default multistep #2', async () => {
+	const sch1 = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).default('hey'),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	expect(st1).toStrictEqual([
+		"CREATE TABLE [users] (\n\t[name] varchar(255) CONSTRAINT [users_name_default] DEFAULT ('hey')\n);\n",
+	]);
+	expect(pst1).toStrictEqual([
+		"CREATE TABLE [users] (\n\t[name] varchar(255) CONSTRAINT [users_name_default] DEFAULT ('hey')\n);\n",
+	]);
+
+	const sch2 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).default('hey'),
+		}),
+	};
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.name->dbo.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames, schemas: ['dbo'] });
+
+	const e2 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }).default('hey1'),
+		}),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const e4 = [
+		'ALTER TABLE [users2] DROP CONSTRAINT [users_name_default];',
+		"ALTER TABLE [users2] ADD CONSTRAINT [users2_name2_default] DEFAULT ('hey1') FOR [name2];",
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: mssqlTable('users2', {
+			name: varchar('name2', { length: 255 }),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4, schemas: ['dbo'] });
+	expect(st5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users2_name2_default];']);
+	expect(pst5).toStrictEqual(['ALTER TABLE [users2] DROP CONSTRAINT [users2_name2_default];']);
+});
+
+test('unique duplicate name', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}),
+		users2: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}, (t) => [unique('test').on(t.name)]),
+		users2: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}, (t) => [unique('test').on(t.name)]),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('pk duplicate name', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}),
+		users2: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}, (t) => [primaryKey({ name: 'test', columns: [t.name] })]),
+		users2: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}, (t) => [primaryKey({ name: 'test', columns: [t.name] })]),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('fk duplicate name', async (t) => {
+	const users = mssqlTable('users', {
+		name: varchar({ length: 255 }).primaryKey(),
+		age: int().unique(),
+	});
+	const from = {
+		users,
+		users2: mssqlTable('users2', {
+			name: varchar({ length: 255 }),
+			age: int(),
+		}),
+	};
+	const to = {
+		users,
+		users2: mssqlTable(
+			'users2',
+			{
+				name: varchar({ length: 255 }),
+				age: int(),
+			},
+			(
+				t,
+			) => [
+				foreignKey({ name: 'test', columns: [t.age], foreignColumns: [users.age] }),
+				foreignKey({ name: 'test', columns: [t.name], foreignColumns: [users.name] }),
+			],
+		),
+	};
+
+	await push({ db, to: from });
+
+	await expect(diff(from, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('index duplicate name', async (t) => {
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar({ length: 255 }).primaryKey(),
+			age: int().unique(),
+		}, (t) => [index('test').on(t.age), index('test').on(t.name)]),
+	};
+
+	await expect(diff({}, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456
+test('drop column with pk and add pk to another column #1', async () => {
+	const schema1 = {
+		authors: mssqlTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE [authors] (\n\t[publication_id] varchar(64),\n\t[author_id] varchar(10),'
+		+ '\n\tCONSTRAINT [authors_pkey] PRIMARY KEY([publication_id],[author_id])\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authors: mssqlTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+			orcidId: varchar('orcid_id', { length: 64 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID, table.orcidId] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE [authors] DROP CONSTRAINT [authors_pkey];',
+		/*
+			HAS TO BE NOT NULL, othervise:
+
+			ALTER TABLE [authors] ADD CONSTRAINT [authors_pkey] PRIMARY KEY ([publication_id],[author_id],[orcid_id]);
+			Error: Could not create constraint or index. See previous errors.
+		*/
+		'ALTER TABLE [authors] ADD [orcid_id] varchar(64) NOT NULL;',
+		'ALTER TABLE [authors] ADD CONSTRAINT [authors_pkey] PRIMARY KEY ([publication_id],[author_id],[orcid_id]);',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5182
+test('constraints in different schemas', async () => {
+	const userSchema = mssqlSchema('user_schema');
+
+	const users = userSchema.table('users', {
+		id: int().identity().primaryKey(),
+		name: nvarchar({ length: 255 }).notNull(),
+		email: nvarchar({ length: 255 }).notNull().unique(),
+	});
+
+	const orgSchema = mssqlSchema('org_schema');
+
+	const orgRoleAssignments = orgSchema.table('org_role_assignments', {
+		id: int().identity().notNull().primaryKey(),
+		idUser: int('id_user')
+			.notNull()
+			.references(() => users.id, { onDelete: 'cascade' }),
+		canApply: bit('can_apply').default(false).notNull(),
+		canApprove: bit('can_approve').default(false).notNull(),
+	});
+
+	const schema1 = { userSchema, users, orgSchema, orgRoleAssignments };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt2: string[] = [
+		'CREATE SCHEMA [user_schema];\n',
+		'CREATE SCHEMA [org_schema];\n',
+		`CREATE TABLE [user_schema].[users] (
+\t[id] int IDENTITY(1, 1),
+\t[name] nvarchar(255) NOT NULL,
+\t[email] nvarchar(255) NOT NULL,
+\tCONSTRAINT [users_pkey] PRIMARY KEY([id]),
+\tCONSTRAINT [users_email_key] UNIQUE([email])
+);\n`,
+		`CREATE TABLE [org_schema].[org_role_assignments] (
+\t[id] int IDENTITY(1, 1),
+\t[id_user] int NOT NULL,
+\t[can_apply] bit NOT NULL CONSTRAINT [org_role_assignments_can_apply_default] DEFAULT ((0)),
+\t[can_approve] bit NOT NULL CONSTRAINT [org_role_assignments_can_approve_default] DEFAULT ((0)),
+\tCONSTRAINT [org_role_assignments_pkey] PRIMARY KEY([id])
+);\n`,
+		`ALTER TABLE [org_schema].[org_role_assignments] ADD CONSTRAINT [org_role_assignments_id_user_users_id_fk] FOREIGN KEY ([id_user]) REFERENCES [user_schema].[users]([id]) ON DELETE CASCADE;`,
+	];
+	expect(st1).toStrictEqual(expectedSt2);
+	expect(pst1).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test('issue No4704. Composite index with sort outputs', async () => {
+	const schema1 = {
+		table: mssqlTable(
+			'table',
+			{ col1: int(), col2: int(), col3: int() },
+			(table) => [
+				index('table_composite_idx').on(
+					table.col1,
+					table.col2,
+					desc(table.col3), // Attempting to sort by col3 DESC
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE [table] (\n\t[col1] int,\n\t[col2] int,\n\t[col3] int\n);\n',
+		'CREATE INDEX [table_composite_idx] ON [table] ([col1],[col2],[col3] desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
diff --git a/drizzle-kit/tests/mssql/defaults.test.ts b/drizzle-kit/tests/mssql/defaults.test.ts
new file mode 100644
index 0000000000..fac89fdfaf
--- /dev/null
+++ b/drizzle-kit/tests/mssql/defaults.test.ts
@@ -0,0 +1,1006 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	binary,
+	bit,
+	char,
+	date,
+	datetime,
+	datetime2,
+	datetimeoffset,
+	decimal,
+	float,
+	int,
+	nchar,
+	ntext,
+	numeric,
+	nvarchar,
+	real,
+	smallint,
+	text,
+	time,
+	tinyint,
+	varbinary,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { diffDefault, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+test('int', async () => {
+	const res1 = await diffDefault(_, int().default(10), '((10))');
+	const res2 = await diffDefault(_, int().default(0), '((0))');
+	const res3 = await diffDefault(_, int().default(-10), '((-10))');
+	const res4 = await diffDefault(_, int().default(1e4), '((10000))');
+	const res5 = await diffDefault(_, int().default(-1e4), '((-10000))');
+
+	const res6 = await diffDefault(_, int().default(sql`10`), '(10)');
+	const res7 = await diffDefault(_, int().default(sql`((10))`), '((10))');
+	const res8 = await diffDefault(_, int().default(sql`'10'`), "('10')");
+	const res9 = await diffDefault(_, int().default(sql`('10')`), "('10')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+});
+
+test('smallint', async () => {
+	// 2^15 - 1
+	const res1 = await diffDefault(_, smallint().default(32767), '((32767))');
+	// -2^15
+	const res2 = await diffDefault(_, smallint().default(-32768), '((-32768))');
+
+	const res3 = await diffDefault(_, smallint().default(sql`10`), '(10)');
+	const res4 = await diffDefault(_, smallint().default(sql`(10)`), '(10)');
+	const res5 = await diffDefault(_, smallint().default(sql`'10'`), "('10')");
+	const res6 = await diffDefault(_, smallint().default(sql`('10')`), "('10')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('tinyint', async () => {
+	const res1 = await diffDefault(_, tinyint().default(123), '((123))');
+	const res2 = await diffDefault(_, tinyint().default(0), '((0))');
+	const res3 = await diffDefault(_, tinyint().default(1), '((1))');
+	const res4 = await diffDefault(_, tinyint().default(sql`10`), '(10)');
+	const res5 = await diffDefault(_, tinyint().default(sql`(10)`), '(10)');
+	const res6 = await diffDefault(_, tinyint().default(sql`'10'`), "('10')");
+	const res7 = await diffDefault(_, tinyint().default(sql`('10')`), "('10')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('bigint', async () => {
+	const res0 = await diffDefault(_, bigint({ mode: 'number' }).default(2147483647), '((2147483647))');
+	// 2^53
+	const res1 = await diffDefault(_, bigint({ mode: 'number' }).default(9007199254740991), '((9007199254740991))');
+	const res2 = await diffDefault(_, bigint({ mode: 'number' }).default(-9007199254740991), '((-9007199254740991))');
+	// 2^63 - 1;
+	const res3 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).default(9223372036854775807n),
+		'((9223372036854775807))',
+	);
+	// -2^63
+	const res4 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).default(-9223372036854775808n),
+		'((-9223372036854775808))',
+	);
+
+	const res5 = await diffDefault(_, bigint({ mode: 'number' }).default(sql`9007199254740991`), '(9007199254740991)');
+	const res6 = await diffDefault(_, bigint({ mode: 'number' }).default(sql`-9007199254740991`), '(-9007199254740991)');
+
+	const res9 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).default(sql`-9223372036854775808`),
+		'(-9223372036854775808)',
+	);
+
+	expect.soft(res0).toStrictEqual([]);
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+});
+
+test('numeric', async () => {
+	const res1 = await diffDefault(_, numeric().default('10.123'), '((10.123))');
+
+	const res2 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'((9223372036854775807))',
+	);
+	const res3 = await diffDefault(_, numeric({ mode: 'number' }).default(9007199254740991), '((9007199254740991))');
+	const res4 = await diffDefault(_, numeric({ mode: 'string' }).default('10.123'), '((10.123))');
+
+	const res5 = await diffDefault(_, numeric({ precision: 6 }).default('10.123'), '((10.123))');
+	const res6 = await diffDefault(_, numeric({ precision: 6, scale: 2 }).default('10.123'), '((10.123))');
+	const res7 = await diffDefault(_, numeric({ precision: 6, scale: 3 }).default('10.12'), '((10.12))');
+
+	const res8 = await diffDefault(_, numeric({ mode: 'string', scale: 2 }).default('10.123'), '((10.123))');
+	const res9 = await diffDefault(_, numeric({ mode: 'string', precision: 6 }).default('10.123'), '((10.123))');
+	const res10 = await diffDefault(
+		_,
+		numeric({ mode: 'string', precision: 6, scale: 2 }).default('10.123'),
+		'((10.123))',
+	);
+	const res11 = await diffDefault(_, numeric({ mode: 'string', precision: 6, scale: 3 }).default('10.12'), '((10.12))');
+
+	const res12 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'((9223372036854775807))',
+	);
+	const res13 = await diffDefault(_, numeric({ mode: 'number', precision: 6, scale: 2 }).default(10.123), '((10.123))');
+	const res14 = await diffDefault(_, numeric({ mode: 'number', scale: 2 }).default(10.123), '((10.123))');
+	const res15 = await diffDefault(_, numeric({ mode: 'number', precision: 6 }).default(10.123), '((10.123))');
+
+	const res16 = await diffDefault(_, numeric().default(sql`10.123`), '(10.123)');
+	const res17 = await diffDefault(_, numeric().default(sql`(10.123)`), '(10.123)');
+	const res18 = await diffDefault(_, numeric().default(sql`'10.123'`), "('10.123')");
+	const res19 = await diffDefault(_, numeric().default(sql`('10.123')`), "('10.123')");
+	const res20 = await diffDefault(_, numeric().default(sql`('9007199254740991')`), "('9007199254740991')");
+	const res21 = await diffDefault(_, numeric().default(sql`9007199254740991`), '(9007199254740991)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+	expect.soft(res18).toStrictEqual([]);
+	expect.soft(res19).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+	expect.soft(res21).toStrictEqual([]);
+});
+
+test('decimal', async () => {
+	const res1 = await diffDefault(_, decimal().default('10.123'), '((10.123))');
+
+	const res2 = await diffDefault(
+		_,
+		decimal({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'((9223372036854775807))',
+	);
+	const res3 = await diffDefault(_, decimal({ mode: 'number' }).default(9007199254740991), '((9007199254740991))');
+	const res4 = await diffDefault(_, decimal({ mode: 'string' }).default('10.123'), '((10.123))');
+
+	const res5 = await diffDefault(_, decimal({ precision: 6 }).default('10.123'), '((10.123))');
+	const res6 = await diffDefault(_, decimal({ precision: 6, scale: 2 }).default('10.123'), '((10.123))');
+	const res7 = await diffDefault(_, decimal({ precision: 6, scale: 3 }).default('10.12'), '((10.12))');
+
+	const res8 = await diffDefault(_, decimal({ mode: 'string', scale: 2 }).default('10.123'), '((10.123))');
+	const res9 = await diffDefault(_, decimal({ mode: 'string', precision: 6 }).default('10.123'), '((10.123))');
+	const res10 = await diffDefault(
+		_,
+		decimal({ mode: 'string', precision: 6, scale: 2 }).default('10.123'),
+		'((10.123))',
+	);
+	const res11 = await diffDefault(_, decimal({ mode: 'string', precision: 6, scale: 3 }).default('10.12'), '((10.12))');
+
+	const res12 = await diffDefault(
+		_,
+		decimal({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'((9223372036854775807))',
+	);
+	const res13 = await diffDefault(_, decimal({ mode: 'number', precision: 6, scale: 2 }).default(10.123), '((10.123))');
+	const res14 = await diffDefault(_, decimal({ mode: 'number', scale: 2 }).default(10.123), '((10.123))');
+	const res15 = await diffDefault(_, decimal({ mode: 'number', precision: 6 }).default(10.123), '((10.123))');
+
+	const res16 = await diffDefault(_, decimal().default(sql`10.123`), '(10.123)');
+	const res17 = await diffDefault(_, decimal().default(sql`(10.123)`), '(10.123)');
+	const res18 = await diffDefault(_, decimal().default(sql`'10.123'`), "('10.123')");
+	const res19 = await diffDefault(_, decimal().default(sql`('10.123')`), "('10.123')");
+	const res20 = await diffDefault(_, decimal().default(sql`('9007199254740991')`), "('9007199254740991')");
+	const res21 = await diffDefault(_, decimal().default(sql`9007199254740991`), '(9007199254740991)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+	expect.soft(res18).toStrictEqual([]);
+	expect.soft(res19).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+	expect.soft(res21).toStrictEqual([]);
+});
+
+test('real', async () => {
+	const res1 = await diffDefault(_, real().default(1000.123), '((1000.123))');
+	const res2 = await diffDefault(_, real().default(1000), '((1000))');
+	const res3 = await diffDefault(_, real().default(2147483647), '((2147483647))');
+	const res4 = await diffDefault(_, real().default(2147483648), '((2147483648))');
+	const res5 = await diffDefault(_, real().default(-2147483648), '((-2147483648))');
+	const res6 = await diffDefault(_, real().default(-2147483649), '((-2147483649))');
+	const res7 = await diffDefault(_, real().default(sql`10`), '(10)');
+	const res8 = await diffDefault(_, real().default(sql`(10)`), '(10)');
+	const res9 = await diffDefault(_, real().default(sql`'10'`), "('10')");
+	const res10 = await diffDefault(_, real().default(sql`('10')`), "('10')");
+
+	const res11 = await diffDefault(_, real().default(sql`'10.123'`), "('10.123')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+});
+
+test('float', async () => {
+	const res1 = await diffDefault(_, float().default(10000.123), '((10000.123))');
+	const res1_0 = await diffDefault(_, float().default(10000), '((10000))');
+	const res1_1 = await diffDefault(_, float().default(2147483647), '((2147483647))');
+	const res1_2 = await diffDefault(_, float().default(2147483648), '((2147483648))');
+	const res1_3 = await diffDefault(_, float().default(-2147483648), '((-2147483648))');
+	const res1_4 = await diffDefault(_, float().default(-2147483649), '((-2147483649))');
+
+	const res2 = await diffDefault(_, float({ precision: 45 }).default(10000.123), '((10000.123))');
+	const res2_0 = await diffDefault(_, float({ precision: 45 }).default(10000), '((10000))');
+	const res2_1 = await diffDefault(_, float({ precision: 45 }).default(2147483647), '((2147483647))');
+	const res2_2 = await diffDefault(_, float({ precision: 45 }).default(2147483648), '((2147483648))');
+	const res2_3 = await diffDefault(_, float({ precision: 45 }).default(-2147483648), '((-2147483648))');
+	const res2_4 = await diffDefault(_, float({ precision: 45 }).default(-2147483649), '((-2147483649))');
+
+	const res3 = await diffDefault(_, float({ precision: 10 }).default(10000.123), '((10000.123))');
+	const res3_0 = await diffDefault(_, float({ precision: 10 }).default(10000), '((10000))');
+	const res3_1 = await diffDefault(_, float({ precision: 10 }).default(2147483647), '((2147483647))');
+	const res3_2 = await diffDefault(_, float({ precision: 10 }).default(2147483648), '((2147483648))');
+	const res3_3 = await diffDefault(_, float({ precision: 10 }).default(-2147483648), '((-2147483648))');
+	const res3_4 = await diffDefault(_, float({ precision: 10 }).default(-2147483649), '((-2147483649))');
+
+	const res4 = await diffDefault(_, float({ precision: 10 }).default(sql`(10000.123)`), '(10000.123)');
+	const res4_0 = await diffDefault(_, float({ precision: 10 }).default(sql`(2147483648)`), '(2147483648)');
+	const res4_1 = await diffDefault(_, float({ precision: 10 }).default(sql`-2147483649`), '(-2147483649)');
+
+	const res5 = await diffDefault(_, float({ precision: 45 }).default(sql`'10000.123'`), "('10000.123')");
+	const res5_0 = await diffDefault(_, float({ precision: 45 }).default(sql`(2147483648)`), '(2147483648)');
+	const res5_1 = await diffDefault(_, float({ precision: 45 }).default(sql`-2147483649`), '(-2147483649)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_0).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res1_2).toStrictEqual([]);
+	expect.soft(res1_3).toStrictEqual([]);
+	expect.soft(res1_4).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_0).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res2_2).toStrictEqual([]);
+	expect.soft(res2_3).toStrictEqual([]);
+	expect.soft(res2_4).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res3_0).toStrictEqual([]);
+	expect.soft(res3_1).toStrictEqual([]);
+	expect.soft(res3_2).toStrictEqual([]);
+	expect.soft(res3_3).toStrictEqual([]);
+	expect.soft(res3_4).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res4_0).toStrictEqual([]);
+	expect.soft(res4_1).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res5_0).toStrictEqual([]);
+	expect.soft(res5_1).toStrictEqual([]);
+});
+
+test('bit', async () => {
+	const res1 = await diffDefault(_, bit().default(true), '((1))');
+	const res2 = await diffDefault(_, bit().default(false), '((0))');
+	const res3 = await diffDefault(_, bit().default(sql`1`), '(1)');
+	const res4 = await diffDefault(_, bit().default(sql`1.`), '(1.)');
+	const res5 = await diffDefault(_, bit().default(sql`'1'`), "('1')");
+
+	const res6 = await diffDefault(_, bit().default(sql`'2'`), "('2')");
+	const res7 = await diffDefault(_, bit().default(sql`2`), '(2)');
+
+	const res8 = await diffDefault(_, bit().default(sql`TRY_CAST('true' AS [bit])`), "(TRY_CAST('true' AS [bit]))");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+});
+
+test('char', async () => {
+	const res1 = await diffDefault(_, char({ length: 256 }).default('text'), `('text')`);
+	const res2 = await diffDefault(_, char({ length: 256 }).default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, char({ length: 256 }).default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, char({ length: 256, enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		char({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\`}{od`,
+		),
+		`('mo''''\",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, char({ length: 10 }).default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, char({ length: 10 }).default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, char({ length: 10 }).default(''), `('')`);
+	const res9 = await diffDefault(_, char({ length: 10 }).default('""'), `('""')`);
+	const res10 = await diffDefault(_, char({ length: 10 }).default(sql`''`), `('')`);
+
+	const res11 = await diffDefault(_, char({ length: 10 }).default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res12 = await diffDefault(_, char({ length: 10 }).default("'"), `('''')`);
+	const res13 = await diffDefault(_, char({ length: 10 }).default('"'), `('"')`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+});
+
+test('varchar', async () => {
+	const res0 = await diffDefault(_, varchar({ length: 100 }).default('text'), `('text')`);
+	const res01 = await diffDefault(_, varchar({ length: 'max' }).default('text'), `('text')`);
+	const res1 = await diffDefault(_, varchar({ length: 256 }).default('text'), `('text')`);
+	const res2 = await diffDefault(_, varchar({ length: 256 }).default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, varchar({ length: 256 }).default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, varchar({ length: 256, enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		varchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\`}{od`,
+		),
+		`('mo''''",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, varchar({ length: 10 }).default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, varchar({ length: 10 }).default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, varchar({ length: 10 }).default(''), `('')`);
+	const res9 = await diffDefault(_, varchar({ length: 10 }).default(sql`''`), `('')`);
+
+	const res10 = await diffDefault(_, varchar({ length: 10 }).default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res11 = await diffDefault(_, varchar({ length: 10 }).default("'"), `('''')`);
+	const res12 = await diffDefault(_, varchar({ length: 10 }).default('"'), `('"')`);
+
+	expect.soft(res0).toStrictEqual([]);
+	expect.soft(res01).toStrictEqual([]);
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+});
+
+test('text', async () => {
+	const res1 = await diffDefault(_, text().default('text'), `('text')`);
+	const res2 = await diffDefault(_, text().default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, text().default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, text({ enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(`mo''",\`}{od`),
+		`('mo''''",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, text().default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, text().default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, text().default(''), `('')`);
+	const res9 = await diffDefault(_, text().default(sql`''`), `('')`);
+
+	const res10 = await diffDefault(_, text().default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res11 = await diffDefault(_, text().default("'"), `('''')`);
+	const res12 = await diffDefault(_, text().default('"'), `('"')`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+});
+
+test('nchar ', async () => {
+	const res0 = await diffDefault(_, nchar({ length: 10 }).default('text'), `('text')`);
+	const res1 = await diffDefault(_, nchar({ length: 256 }).default('text'), `('text')`);
+	const res2 = await diffDefault(_, nchar({ length: 256 }).default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, nchar({ length: 256 }).default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, nchar({ length: 256, enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		nchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\`}{od`,
+		),
+		`('mo''''\",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, nchar({ length: 10 }).default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, nchar({ length: 10 }).default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, nchar({ length: 10 }).default(''), `('')`);
+	const res9 = await diffDefault(_, nchar({ length: 10 }).default(sql`''`), `('')`);
+
+	const res10 = await diffDefault(_, nchar({ length: 10 }).default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res11 = await diffDefault(_, nchar({ length: 10 }).default("'"), `('''')`);
+	const res12 = await diffDefault(_, nchar({ length: 10 }).default('"'), `('"')`);
+
+	expect.soft(res0).toStrictEqual([]);
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+});
+
+test('nvarchar', async () => {
+	const res0 = await diffDefault(_, nvarchar({ length: 10 }).default('text'), `('text')`);
+	const res1 = await diffDefault(_, nvarchar({ length: 256 }).default('text'), `('text')`);
+	const res2 = await diffDefault(_, nvarchar({ length: 256 }).default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, nvarchar({ length: 256 }).default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, nvarchar({ length: 256, enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		nvarchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\`}{od`,
+		),
+		`('mo''''",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, nvarchar({ length: 10 }).default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, nvarchar({ length: 10 }).default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, nvarchar({ length: 10 }).default(''), `('')`);
+	const res9 = await diffDefault(_, nvarchar({ length: 10 }).default(sql`''`), `('')`);
+
+	const res10 = await diffDefault(_, nvarchar({ length: 10 }).default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res11 = await diffDefault(
+		_,
+		nvarchar({ mode: 'json', length: 'max' }).default({ key: 'value' }),
+		`('{"key":"value"}')`,
+	);
+	const res12 = await diffDefault(
+		_,
+		nvarchar({ mode: 'json', length: 'max' }).default({ key: 9223372036854775807n }),
+		`('{"key":9223372036854775807}')`,
+	);
+	const res13 = await diffDefault(
+		_,
+		nvarchar({ mode: 'json', length: 'max' }).default(sql`'{"key":9223372036854775807}'`),
+		`('{"key":9223372036854775807}')`,
+	);
+	const res14 = await diffDefault(
+		_,
+		nvarchar({ mode: 'json', length: 'max' }).default([9223372036854775807n, 9223372036854775806n]),
+		`('[9223372036854775807,9223372036854775806]')`,
+	);
+	const res15 = await diffDefault(
+		_,
+		nvarchar({ mode: 'json', length: 'max' }).default({ key: 'value\\\'"' }),
+		`('{"key":"value\\\\''\\""}')`,
+	);
+
+	const res16 = await diffDefault(_, nvarchar({ length: 10 }).default("'"), `('''')`);
+	const res17 = await diffDefault(_, nvarchar({ length: 10 }).default('"'), `('"')`);
+
+	expect.soft(res0).toStrictEqual([]);
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+});
+
+test('ntext', async () => {
+	const res1 = await diffDefault(_, ntext().default('text'), `('text')`);
+	const res2 = await diffDefault(_, ntext().default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, ntext().default('text\'text"'), "('text''text\"')");
+	const res4 = await diffDefault(_, ntext({ enum: ['one', 'two', 'three'] }).default('one'), "('one')");
+	const res5 = await diffDefault(
+		_,
+		ntext({ enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).default(`mo''",\`}{od`),
+		`('mo''''",\`}{od')`,
+	);
+
+	const res6 = await diffDefault(_, ntext().default(sql`'text'`), `('text')`);
+	const res7 = await diffDefault(_, ntext().default(sql`('text')`), `('text')`);
+
+	const res8 = await diffDefault(_, ntext().default(''), `('')`);
+	const res9 = await diffDefault(_, ntext().default(sql`''`), `('')`);
+
+	const res10 = await diffDefault(_, ntext().default(sql`'text'+'text'`), `('text'+'text')`);
+
+	const res11 = await diffDefault(_, ntext().default("'"), `('''')`);
+	const res12 = await diffDefault(_, ntext().default('"'), `('"')`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+});
+
+test('datetime', async () => {
+	const res1 = await diffDefault(
+		_,
+		datetime({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.111Z')),
+		`('2025-05-23 12:53:53.111')`,
+	);
+	const res2 = await diffDefault(
+		_,
+		datetime({ mode: 'string' }).default('2025-05-23T12:53:53.112Z'),
+		`('2025-05-23T12:53:53.112Z')`,
+	);
+	const res3 = await diffDefault(
+		_,
+		datetime({ mode: 'string' }).default(sql`'2025-05-23T12:53:53.113Z'`),
+		`('2025-05-23T12:53:53.113Z')`,
+	);
+
+	const res4 = await diffDefault(_, datetime().defaultGetDate(), `(getdate())`);
+	const res5 = await diffDefault(_, datetime().default(sql`getdate()`), `(getdate())`);
+
+	const res6 = await diffDefault(
+		_,
+		datetime({ mode: 'date' }).default(sql`dateadd(day,(7),getdate())`),
+		`(dateadd(day,(7),getdate()))`,
+	);
+
+	const res7 = await diffDefault(
+		_,
+		datetime({ mode: 'string' }).default(`2025-05-23`),
+		`('2025-05-23')`,
+	);
+	const res8 = await diffDefault(
+		_,
+		datetime({ mode: 'string' }).default(`12:53:53.113`),
+		`('12:53:53.113')`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+});
+
+test('datetime2', async () => {
+	const res1 = await diffDefault(
+		_,
+		datetime2({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`('2025-05-23 12:53:53.115')`,
+	);
+	const res10 = await diffDefault(
+		_,
+		datetime2({ mode: 'date', precision: 4 }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`('2025-05-23 12:53:53.115')`,
+	);
+	const res2 = await diffDefault(
+		_,
+		datetime2({ mode: 'string' }).default('2025-05-23T12:53:53.115Z'),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res2_0 = await diffDefault(
+		_,
+		datetime2({ mode: 'string', precision: 4 }).default('2025-05-23T12:53:53.115Z'),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res2_1 = await diffDefault(
+		_,
+		datetime2({ mode: 'string', precision: 4 }).default('2025-05-23 12:53:53.115'),
+		`('2025-05-23 12:53:53.115')`,
+	);
+	const res3 = await diffDefault(
+		_,
+		datetime2({ mode: 'string', precision: 4 }).default(sql`('2025-05-23T12:53:53.115Z')`),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res4 = await diffDefault(_, datetime2().defaultGetDate(), `(getdate())`);
+	const res40 = await diffDefault(_, datetime2({ precision: 4 }).defaultGetDate(), `(getdate())`);
+	const res5 = await diffDefault(_, datetime2().default(sql`getdate()`), `(getdate())`);
+	const res50 = await diffDefault(_, datetime2({ precision: 4 }).default(sql`getdate()`), `(getdate())`);
+
+	const res6 = await diffDefault(
+		_,
+		datetime2({ mode: 'date' }).default(sql`dateadd(day,(7),getdate())`),
+		`(dateadd(day,(7),getdate()))`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res2_0).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res40).toStrictEqual([]);
+	expect.soft(res50).toStrictEqual([]);
+});
+
+test('datetimeoffset', async () => {
+	const res1 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res2 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'date', precision: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res3 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'string' }).default('2025-05-23T12:53:53.115+03:00'),
+		`('2025-05-23T12:53:53.115+03:00')`,
+	);
+	const res4 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'string', precision: 3 }).default('2025-05-23 12:53:53.115'),
+		`('2025-05-23 12:53:53.115')`,
+	);
+	const res5 = await diffDefault(_, datetimeoffset().defaultGetDate(), `(getdate())`);
+
+	const res30 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'string' }).default(sql`'2025-05-23T12:53:53.115+03:00'`),
+		`('2025-05-23T12:53:53.115+03:00')`,
+	);
+	const res40 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'string', precision: 3 }).default(sql`('2025-05-23 12:53:53.115')`),
+		`('2025-05-23 12:53:53.115')`,
+	);
+
+	const res6 = await diffDefault(
+		_,
+		datetimeoffset({ mode: 'date' }).default(sql`dateadd(day,(7),getdate())`),
+		`(dateadd(day,(7),getdate()))`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res30).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res40).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('time', async () => {
+	const res1 = await diffDefault(_, time().default(new Date('2025-05-23T12:53:53.115Z')), `('12:53:53.115')`);
+	const res10 = await diffDefault(
+		_,
+		time({ mode: 'string', precision: 2 }).default('15:50:33.12342'),
+		`('15:50:33.12342')`,
+	);
+	const res2 = await diffDefault(
+		_,
+		time({ mode: 'string', precision: 2 }).default('2025-05-23T12:53:53.115Z'),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+
+	const res3 = await diffDefault(
+		_,
+		time({ mode: 'string', precision: 2 }).default(sql`('15:50:33.12342')`),
+		`('15:50:33.12342')`,
+	);
+	const res4 = await diffDefault(
+		_,
+		time({ mode: 'string', precision: 2 }).default(sql`('2025-05-23T12:53:53.115Z')`),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+
+	const res5 = await diffDefault(
+		_,
+		time({ mode: 'date' }).default(sql`dateadd(day,(7),getdate())`),
+		`(dateadd(day,(7),getdate()))`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('date', async () => {
+	const res1 = await diffDefault(_, date({ mode: 'string' }).default('2025-05-23'), `('2025-05-23')`);
+	const res10 = await diffDefault(
+		_,
+		date({ mode: 'string' }).default('2025-05-23T12:53:53.115Z'),
+		`('2025-05-23T12:53:53.115Z')`,
+	);
+	const res2 = await diffDefault(_, date({ mode: 'date' }).default(new Date('2025-05-23')), `('2025-05-23')`);
+	const res3 = await diffDefault(_, date({ mode: 'string' }).defaultGetDate(), `(getdate())`);
+	const res30 = await diffDefault(_, date({ mode: 'date' }).defaultGetDate(), `(getdate())`);
+
+	const res4 = await diffDefault(_, date({ mode: 'date' }).default(sql`getdate()`), `(getdate())`);
+	const res6 = await diffDefault(_, date({ mode: 'string' }).default(sql`'2025-05-23'`), `('2025-05-23')`);
+	const res7 = await diffDefault(_, date({ mode: 'date' }).default(sql`'2025-05-23'`), `('2025-05-23')`);
+
+	const res8 = await diffDefault(
+		_,
+		date({ mode: 'date' }).default(sql`dateadd(day,(7),getdate())`),
+		`(dateadd(day,(7),getdate()))`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res30).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+});
+
+function toBinary(str: string) {
+	return '(' + '0x' + Buffer.from(str, 'utf8').toString('hex').toUpperCase() + ')';
+}
+test('binary + varbinary', async () => {
+	const res1 = await diffDefault(
+		_,
+		binary({ length: 100 }).default(Buffer.from('hello world')),
+		toBinary('hello world'),
+	);
+	const res1_1 = await diffDefault(
+		_,
+		varbinary({ length: 100 }).default(Buffer.from('hello world')),
+		toBinary('hello world'),
+	);
+	const res1_2 = await diffDefault(
+		_,
+		binary({ length: 100 }).default(sql`hashbytes('SHA1','password')`),
+		"(hashbytes('SHA1','password'))",
+	);
+	const res1_3 = await diffDefault(_, binary({ length: 100 }).default(sql`0xFF`), '(0xFF)');
+	const res1_4 = await diffDefault(
+		_,
+		varbinary({ length: 100 }).default(sql`hashbytes('SHA1','password')`),
+		"(hashbytes('SHA1','password'))",
+	);
+	const res1_5 = await diffDefault(_, varbinary({ length: 100 }).default(sql`0xFF`), '(0xFF)');
+
+	const res2 = await diffDefault(
+		_,
+		binary({ length: 100 }).default(Buffer.from('hello world')),
+		toBinary('hello world'),
+	);
+	const res2_1 = await diffDefault(
+		_,
+		varbinary({ length: 'max' }).default(Buffer.from('hello world')),
+		toBinary('hello world'),
+	);
+	const res2_2 = await diffDefault(
+		_,
+		varbinary({ length: 100 }).default(Buffer.from('hello world')),
+		toBinary('hello world'),
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res1_2).toStrictEqual([]);
+	expect.soft(res1_3).toStrictEqual([]);
+	expect.soft(res1_4).toStrictEqual([]);
+	expect.soft(res1_5).toStrictEqual([]);
+
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res2_2).toStrictEqual([]);
+});
+
+// Probably most of the tests should be handled in `push.test.ts`
+// User-friendly warning should be shown if there are changes in default expressions
+// This just needs to be handled right for typescript (values must be in sql``, not .default())
+test.skip('corner cases', async () => {
+	const res1 = await diffDefault(_, char().default(sql`('text' + 'text')`), `('text' + 'text')`);
+	const res2 = await diffDefault(_, char().default(sql`(CONVERT([char](2),N'A+'))`), `(CONVERT([char](2),N'A+'))`);
+	const res3 = await diffDefault(
+		_,
+		char().default(sql`IIF(DAY(GETDATE()) % 2 = 0, 'Y', 'N')`),
+		`(IIF(DAY(GETDATE()) % 2 = 0, 'Y', 'N'))`,
+	);
+	const res4 = await diffDefault(
+		_,
+		char().default(sql`CASE
+	    WHEN DATEPART(HOUR, GETDATE()) < 12 THEN 'M'
+	    ELSE 'A'
+	END`),
+		`(CASE
+	    WHEN DATEPART(HOUR, GETDATE()) < 12 THEN 'M'
+	    ELSE 'A'
+	END)`,
+	);
+
+	const res5 = await diffDefault(_, int().default(sql`10 + 10`), '10 + 10');
+	const res6 = await diffDefault(_, int().default(sql`(10) + 10`), '(10) + 10');
+	const res7 = await diffDefault(_, int().default(sql`((10) + 10)`), '((10) + 10)');
+	const res8 = await diffDefault(
+		_,
+		int().default(sql`(10) + (10 + 15) + 9007199254740992`),
+		'(10) + (10 + 15) + 9007199254740992',
+	);
+	const res9 = await diffDefault(
+		_,
+		int().default(sql`(10) + (10 + 15) / 9007199254740992 - '11'`),
+		"(10) + (10 + 15) / 9007199254740992 - '11'",
+	);
+
+	const res10 = await diffDefault(
+		_,
+		bigint({ mode: 'number' }).default(sql`'9007199254740991.'`),
+		"('9007199254740991.')",
+	);
+	const res11 = await diffDefault(_, bigint({ mode: 'number' }).default(sql`9007199254740991.`), '(9007199254740991.)');
+
+	const res12 = await diffDefault(_, numeric({ mode: 'number', precision: 6 }).default(10), '10.');
+	const res13 = await diffDefault(_, numeric({ mode: 'number' }).default(sql`'6.73' + '4.2'`), "'6.73' + '4.2'");
+	const res14 = await diffDefault(_, numeric({ mode: 'number' }).default(sql`(6.73 + 4.)`), '6.73 + 4.');
+	const res15 = await diffDefault(_, numeric({ mode: 'number' }).default(sql`'6.73' + '4.2'`), "'6.73' + '4.2'");
+
+	const res16 = await diffDefault(_, real().default(sql`('10.')`), "('10.')");
+	const res17 = await diffDefault(_, real().default(sql`(10.)`), '(10.)');
+	const res18 = await diffDefault(_, real().default(sql`10.`), '(10.)');
+	const res19 = await diffDefault(_, real().default(sql`10.123`), '(10.123)');
+
+	const res20 = await diffDefault(_, float().default(sql`10000.`), '(10000.)');
+	const res21 = await diffDefault(_, float().default(sql`'10000.'`), "('10000.')");
+	const res22 = await diffDefault(_, float({ precision: 45 }).default(sql`10000.`), '(10000.)');
+	const res23 = await diffDefault(_, float({ precision: 10 }).default(sql`(10000.)`), '(10000.)');
+
+	const res24 = await diffDefault(_, bit().default(sql`TRY_CAST('true' AS [bit])`), "(TRY_CAST('true' AS [bit]))");
+	const res25 = await diffDefault(
+		_,
+		bit().default(sql`CASE WHEN 1 + 1 - 1 + 1= 2 THEN 1 ELSE 0 END`),
+		'CASE WHEN 1 + 1 - 1 + 1= 2 THEN 1 ELSE 0 END',
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+	expect.soft(res18).toStrictEqual([]);
+	expect.soft(res19).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+	expect.soft(res21).toStrictEqual([]);
+	expect.soft(res22).toStrictEqual([]);
+	expect.soft(res23).toStrictEqual([]);
+	expect.soft(res24).toStrictEqual([]);
+	expect.soft(res25).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/mssql/generated.test.ts b/drizzle-kit/tests/mssql/generated.test.ts
new file mode 100644
index 0000000000..55d21cd686
--- /dev/null
+++ b/drizzle-kit/tests/mssql/generated.test.ts
@@ -0,0 +1,1040 @@
+import { SQL, sql } from 'drizzle-orm';
+import { int, mssqlSchema, mssqlTable, text, varchar } from 'drizzle-orm/mssql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('generated as callback: add column with generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} + 'to add'`, {
+					mode: 'persisted',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add') PERSISTED;",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} + 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} + 'to delete'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = ['ALTER TABLE [users] DROP COLUMN [gen_name];', 'ALTER TABLE [users] ADD [gen_name] text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} + 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = ['ALTER TABLE [users] DROP COLUMN [gen_name];', 'ALTER TABLE [users] ADD [gen_name] text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: change generated constraint type from virtual to PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0); // push is triggered cause mode changed
+});
+
+test('generated as callback: change generated constraint type from PERSISTED to virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} + 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0); // push will not be ignored cause type changed
+});
+
+test('generated as callback: change generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} + 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push will be ignored cause type was not changed
+});
+
+// ---
+
+test('generated as sql: add column with generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = ["ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`[users].[name] + 'to add'`, {
+					mode: 'persisted',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`[users].[name] + 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'to delete'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = ['ALTER TABLE [users] DROP COLUMN [gen_name];', 'ALTER TABLE [users] ADD [gen_name] text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		'ALTER TABLE [users] ADD [gen_name] text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint type from virtual to PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name]`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint type from PERSISTED to virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name]`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name]`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+// ---
+
+test('generated as string: add column with generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`[users].[name] + 'to add'`, {
+					mode: 'persisted',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add') PERSISTED;",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`[users].[name] + 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'to add');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'to delete'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		'ALTER TABLE [users] ADD [gen_name] text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		'ALTER TABLE [users] ADD [gen_name] text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint type from virtual to PERSISTED', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`[users].[name]`, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'persisted' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello') PERSISTED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint type from PERSISTED to virtual', async () => {
+	const newSchema = mssqlSchema('new_schema');
+	const from = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`[users].[name]`, { mode: 'persisted' }),
+		}),
+	};
+	const to = {
+		newSchema,
+		users: newSchema.table('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE [new_schema].[users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [new_schema].[users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`[users].[name]`),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: varchar('name', { length: 255 }),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`[users].[name] + 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+	await push({ db, to: from, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: ['dbo'],
+	});
+
+	const st0 = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignores definition changes
+});
+
+test('alter generated constraint', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
+		}),
+	};
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} + 'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0: string[] = [
+		'ALTER TABLE [users] DROP COLUMN [gen_name];',
+		"ALTER TABLE [users] ADD [gen_name] AS ([users].[name] + 'hello');",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignores definition changes
+});
diff --git a/drizzle-kit/tests/mssql/indexes.test.ts b/drizzle-kit/tests/mssql/indexes.test.ts
new file mode 100644
index 0000000000..5caeba7d33
--- /dev/null
+++ b/drizzle-kit/tests/mssql/indexes.test.ts
@@ -0,0 +1,274 @@
+import { isNotNull, sql } from 'drizzle-orm';
+import {
+	bit,
+	index,
+	IndexBuilder,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	text,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('indexes #0', async (t) => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				name: varchar('name', { length: 3000 }),
+			},
+			(
+				t,
+			) => [
+				index('changeName').on(t.name),
+				index('removeColumn').on(t.name, t.id),
+				index('addColumn').on(t.name),
+				index('removeWhere').on(t.name).where(sql`${t.name} != 'name'`),
+				index('addWhere').on(t.name),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				name: varchar('name', { length: 3000 }),
+			},
+			(t) => [
+				index('newName').on(t.name),
+				index('removeColumn').on(t.name),
+				index('addColumn').on(t.name, t.id),
+				index('removeWhere').on(t.name),
+				index('addWhere').on(t.name).where(sql`${t.name} != 'name'`),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX [changeName] ON [users];',
+		'DROP INDEX [removeColumn] ON [users];',
+		'DROP INDEX [addColumn] ON [users];',
+		'DROP INDEX [removeWhere] ON [users];',
+		'DROP INDEX [addWhere] ON [users];',
+		'CREATE INDEX [newName] ON [users] ([name]);',
+		'CREATE INDEX [removeColumn] ON [users] ([name]);',
+		'CREATE INDEX [addColumn] ON [users] ([name],[id]);',
+		'CREATE INDEX [removeWhere] ON [users] ([name]);',
+		"CREATE INDEX [addWhere] ON [users] ([name]) WHERE [name] != 'name';",
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX [changeName] ON [users];',
+		'DROP INDEX [addColumn] ON [users];',
+		'DROP INDEX [addWhere] ON [users];',
+		'DROP INDEX [removeColumn] ON [users];',
+		'DROP INDEX [removeWhere] ON [users];',
+		'CREATE INDEX [newName] ON [users] ([name]);',
+		'CREATE INDEX [addColumn] ON [users] ([name],[id]);',
+		"CREATE INDEX [addWhere] ON [users] ([name]) WHERE [name] != 'name';",
+		'CREATE INDEX [removeColumn] ON [users] ([name]);',
+		'CREATE INDEX [removeWhere] ON [users] ([name]);',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5593
+test('indexes #4', async () => {
+	const schema = mssqlSchema('my_schema');
+	const table1 = schema.table('table1', {
+		col1: int(),
+		col2: int(),
+	}, (t) => [
+		uniqueIndex('index1').on(t.col1).where(isNotNull(t.col1)),
+		index('index2').on(t.col2).where(isNotNull(t.col2)),
+	]);
+
+	const schema1 = { schema, table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE SCHEMA [my_schema];\n',
+		'CREATE TABLE [my_schema].[table1] (\n'
+		+ '\t[col1] int,\n'
+		+ '\t[col2] int\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX [index1] ON [my_schema].[table1] ([col1]) WHERE ([col1] is not null);',
+		'CREATE INDEX [index2] ON [my_schema].[table1] ([col2]) WHERE ([col2] is not null);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+test('adding basic indexes', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 1000 }),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				name: varchar('name', { length: 1000 }),
+			},
+			(t) => [
+				index('indx1')
+					.on(t.name)
+					.where(sql`name != 'alex'`),
+				index('indx2').on(t.id),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [
+		`CREATE INDEX [indx1] ON [users] ([name]) WHERE name != 'alex';`,
+		`CREATE INDEX [indx2] ON [users] ([id]);`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('dropping basic index', async () => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				name: varchar('name', { length: 100 }),
+			},
+			(t) => [index('indx1').on(t.name, t.id)],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 100 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0 = [`DROP INDEX [indx1] ON [users];`];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('indexes test case #1', async () => {
+	const schema1 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: varchar('id').primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: bit('in_stock').default(true),
+			},
+			(t) => [
+				index('indx').on(t.id),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: mssqlTable(
+			'users',
+			{
+				id: varchar('id').primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: bit('in_stock').default(true),
+			},
+			(t) => [
+				index('indx').on(t.id),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('Alter where property', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 1000 }),
+		}, (t) => [
+			index('indx2').on(t.name).where(sql`name != 'alex'`),
+		]),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 1000 }),
+		}, (t) => [
+			index('indx2').on(t.name).where(sql`name != 'alex2'`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas: ['dbo'] });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX [indx2] ON [users];',
+		"CREATE INDEX [indx2] ON [users] ([name]) WHERE name != 'alex2';",
+	]);
+	expect(pst).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/mssql/mocks.ts b/drizzle-kit/tests/mssql/mocks.ts
new file mode 100644
index 0000000000..4e3ff995bd
--- /dev/null
+++ b/drizzle-kit/tests/mssql/mocks.ts
@@ -0,0 +1,501 @@
+import { is } from 'drizzle-orm';
+import { int, MsSqlColumnBuilder, MsSqlSchema, MsSqlTable, mssqlTable, MsSqlView } from 'drizzle-orm/mssql-core';
+import { configMigrations } from 'src/cli/validations/common';
+import { interimToDDL, MssqlDDL, SchemaError } from 'src/dialects/mssql/ddl';
+import { ddlDiff, ddlDiffDry } from 'src/dialects/mssql/diff';
+import { defaultFromColumn, fromDrizzleSchema, prepareFromSchemaFiles } from 'src/dialects/mssql/drizzle';
+import { mockResolver } from 'src/utils/mocks';
+import '../../src/@types/utils';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import mssql from 'mssql';
+import { introspect } from 'src/cli/commands/pull-mssql';
+import { HintsHandler } from 'src/cli/hints';
+import { EmptyProgressView, explain } from 'src/cli/views';
+import { createDDL } from 'src/dialects/mssql/ddl';
+import { defaultNameForDefault } from 'src/dialects/mssql/grammar';
+import { fromDatabaseForDrizzle } from 'src/dialects/mssql/introspect';
+import { ddlToTypeScript } from 'src/dialects/mssql/typescript';
+import { DB } from 'src/utils';
+import 'zx/globals';
+import { suggestions } from 'src/cli/commands/push-mssql';
+import { runWithCliContext } from 'src/cli/context';
+import { EntitiesFilter, EntitiesFilterConfig } from 'src/cli/validations/common';
+import { hash } from 'src/dialects/common';
+import { extractMssqlExisting } from 'src/dialects/drizzle';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { tsc } from 'tests/utils';
+import { expect } from 'vitest';
+
+export type MssqlDBSchema = Record<
+	string,
+	| MsSqlTable<any>
+	| MsSqlSchema
+	| MsSqlView
+>;
+
+class MockError extends Error {
+	constructor(readonly errors: SchemaError[]) {
+		super();
+	}
+}
+
+export const drizzleToDDL = (
+	schema: MssqlDBSchema,
+	filterConfig: EntitiesFilterConfig = {
+		schemas: undefined,
+		tables: undefined,
+		entities: undefined,
+		extensions: undefined,
+	},
+) => {
+	const tables = Object.values(schema).filter((it) => is(it, MsSqlTable)) as MsSqlTable[];
+	const schemas = Object.values(schema).filter((it) => is(it, MsSqlSchema)) as MsSqlSchema[];
+	const views = Object.values(schema).filter((it) => is(it, MsSqlView)) as MsSqlView[];
+
+	const existing = extractMssqlExisting(schemas, views);
+	const filter = prepareEntityFilter('mssql', filterConfig, existing);
+	const { schema: res, errors } = fromDrizzleSchema(
+		{ schemas, tables, views },
+		filter,
+	);
+
+	if (errors.length > 0) {
+		throw new Error();
+	}
+
+	return { ...interimToDDL(res), existing };
+};
+
+// 2 schemas -> 2 ddls -> diff
+export const diff = async (
+	left: MssqlDBSchema | MssqlDDL,
+	right: MssqlDBSchema,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as MssqlDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = drizzleToDDL(right);
+
+	if (err1.length > 0 || err2.length > 0) {
+		throw new MockError([...err1, ...err2]);
+	}
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames), // uniques
+		mockResolver(renames), // indexes
+		mockResolver(renames), // checks
+		mockResolver(renames), // pks
+		mockResolver(renames), // fks
+		mockResolver(renames), // defaults
+		'default',
+	);
+
+	return { sqlStatements, statements, groupedStatements, next: ddl2 };
+};
+
+export const diffIntrospect = async (
+	db: DB,
+	initSchema: MssqlDBSchema,
+	testName: string,
+	schemas: string[] = [],
+	entities?: EntitiesFilter,
+) => {
+	const filterConfig: EntitiesFilterConfig = {
+		schemas,
+		entities,
+		tables: [],
+		extensions: [],
+	};
+
+	const { ddl: initDDL, existing } = drizzleToDDL(initSchema, filterConfig);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL, 'default');
+
+	for (const st of init) await db.query(st);
+
+	const filter = prepareEntityFilter('mssql', filterConfig, existing);
+
+	const schema = await fromDatabaseForDrizzle(db, filter, () => true, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+
+	const filePath = `tests/mssql/tmp/${testName}.ts`;
+
+	writeFileSync(filePath, file.file);
+	await tsc(file.file);
+
+	const typeCheckResult = await $`pnpm exec tsc --noEmit --skipLibCheck ${filePath}`.nothrow();
+	if (typeCheckResult.exitCode !== 0) {
+		throw new Error(typeCheckResult.stderr || typeCheckResult.stdout);
+	}
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([
+		filePath,
+	]);
+
+	const { schema: schema2, errors: e2 } = fromDrizzleSchema(response, filter);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(schema2);
+
+	const {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	} = await ddlDiffDry(ddl1, ddl2, 'push');
+
+	rmSync(`tests/mssql/tmp/${testName}.ts`);
+
+	return {
+		introspectDDL: ddl1,
+		fromFileDDL: ddl2,
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	};
+};
+
+// init schema flush to db -> introspect db to ddl -> compare ddl with destination schema
+export const push = async (config: {
+	db: DB;
+	to: MssqlDBSchema | MssqlDDL;
+	renames?: string[];
+	schemas?: string[];
+	log?: 'statements' | 'none';
+	force?: boolean;
+	expectError?: boolean;
+	ignoreSubsequent?: boolean;
+	explain?: boolean;
+	migrationsConfig?: {
+		schema?: string;
+		table?: string;
+	};
+}) => {
+	const { db, to, log } = config;
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+
+	const filterConfig: EntitiesFilterConfig = {
+		schemas: config.schemas,
+		entities: undefined,
+		tables: [],
+		extensions: [],
+	};
+	const { ddl: ddl2, errors: err2, existing } = 'entities' in to && '_' in to
+		? { ddl: to as MssqlDDL, errors: [], existing: [] }
+		: drizzleToDDL(to, filterConfig);
+
+	const filter = prepareEntityFilter('mssql', filterConfig, existing);
+
+	const { schema } = await introspect(
+		db,
+		filter,
+		new EmptyProgressView(),
+		migrations,
+	);
+
+	const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+
+	if (err2.length > 0) {
+		throw new MockError(err2);
+	}
+
+	if (err3.length > 0) {
+		throw new MockError(err3);
+	}
+
+	const renames = new Set(config.renames ?? []);
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames), // views
+		mockResolver(renames), // uniques
+		mockResolver(renames), // indexes
+		mockResolver(renames), // checks
+		mockResolver(renames), // pks
+		mockResolver(renames), // fks
+		mockResolver(renames), // defaults
+		'push',
+	);
+
+	const hints = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, ddl2, new HintsHandler()),
+	);
+
+	if (config.explain) {
+		const explainMessage = explain('mssql', groupedStatements, []);
+		console.log(explainMessage);
+		return { sqlStatements, statements, hints };
+	}
+
+	let error: Error | null = null;
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		try {
+			await db.query(sql);
+		} catch (e) {
+			if (!config.expectError) throw e;
+			error = e as Error;
+			break;
+		}
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		{
+			const { schema } = await introspect(
+				db,
+				filter,
+				new EmptyProgressView(),
+				migrations,
+			);
+			const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+
+			const { sqlStatements, statements } = await ddlDiff(
+				ddl1,
+				ddl2,
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				'push',
+			);
+			if (sqlStatements.length > 0) {
+				console.error('---- subsequent push is not empty ----');
+				expect(sqlStatements.join('\n')).toBe('');
+			}
+		}
+	}
+
+	return { sqlStatements, statements, hints, error };
+};
+
+export type TestDatabase = {
+	db: DB;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+	client: mssql.ConnectionPool;
+};
+
+export const diffDefault = async <T extends MsSqlColumnBuilder>(
+	kit: TestDatabase,
+	builder: T,
+	expectedDefault: string,
+	pre: MssqlDBSchema | null = null,
+) => {
+	await kit.clear();
+
+	const config = (builder as any).config;
+	const def = config['default'];
+	const tableName = 'table';
+	const column = mssqlTable(tableName, { column: builder }).column;
+	const sqlType = column.getSQLType();
+
+	const columnDefault = defaultFromColumn(column);
+
+	const res = [] as string[];
+	if (columnDefault !== expectedDefault) {
+		res.push(`Unexpected sql: \n${columnDefault}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: mssqlTable(tableName, { column: builder }),
+	};
+
+	const { db, clear } = kit;
+	if (pre) await push({ db, to: pre, ignoreSubsequent: true });
+	const { sqlStatements: st1 } = await push({ db, to: init, ignoreSubsequent: true });
+	const { sqlStatements: st2 } = await push({ db, to: init, ignoreSubsequent: true });
+
+	const expectedInit = `CREATE TABLE [${tableName}] (\n\t[${column.name}] ${sqlType} CONSTRAINT [${
+		defaultNameForDefault(tableName, column.name)
+	}] DEFAULT ${expectedDefault}\n);\n`;
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2}`);
+
+	await db.query('INSERT INTO [table] ([column]) VALUES (default);');
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, () => true, () => true, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+	mkdirSync(`tests/mssql/tmp`, { recursive: true });
+	const path = `tests/mssql/tmp/temp-${hash(String(Math.random()))}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+	const { schema: sch, errors: e2 } = fromDrizzleSchema(response, () => true);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+		res.push(`Default type mismatch after diff:\n${`./${path}`}`);
+	}
+
+	await clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: mssqlTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: mssqlTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent: true });
+	await push({ db, to: schema1, ignoreSubsequent: true });
+	const { sqlStatements: st3 } = await push({ db, to: schema2, ignoreSubsequent: true });
+
+	const expectedAlter = `ALTER TABLE [${tableName}] ADD CONSTRAINT [${
+		defaultNameForDefault(tableName, column.name)
+	}] DEFAULT ${expectedDefault} FOR [${column.name}];`;
+	if (st3.length !== 1 || st3[0] !== expectedAlter) res.push(`Unexpected default alter:\n${st3}\n\n${expectedAlter}`);
+
+	await clear();
+
+	const schema3 = {
+		...pre,
+		table: mssqlTable('table', { id: int().identity() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: mssqlTable('table', { id: int().identity(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent: true });
+	await push({ db, to: schema3, ignoreSubsequent: true });
+	const { sqlStatements: st4 } = await push({ db, to: schema4, ignoreSubsequent: true });
+
+	const expectedAddColumn = `ALTER TABLE [${tableName}] ADD [${column.name}] ${sqlType} CONSTRAINT [${
+		defaultNameForDefault(tableName, column.name)
+	}] DEFAULT ${expectedDefault};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export function parseMssqlUrl(urlString: string) {
+	const url = new URL(urlString);
+	return {
+		user: url.username,
+		password: url.password,
+		server: url.hostname,
+		port: parseInt(url.port, 10),
+		database: url.pathname.replace(/^\//, ''),
+		options: {
+			encrypt: url.searchParams.get('encrypt') === 'true',
+			trustServerCertificate: url.searchParams.get('trustServerCertificate') === 'true',
+		},
+	};
+}
+
+export const prepareTestDatabase = async (tx: boolean = true): Promise<TestDatabase> => {
+	const url = process.env.MSSQL_CONNECTION_STRING;
+	if (!url) {
+		throw new Error(
+			'MSSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mssql` and export the connection string (e.g. `mssql://SA:drizzle123PASSWORD!@127.0.0.1:1433?encrypt=true&trustServerCertificate=true`) before running tests.',
+		);
+	}
+	const params = parseMssqlUrl(url);
+
+	try {
+		const client = await mssql.connect({
+			...params,
+			pool: { max: 1 },
+			requestTimeout: 30_000,
+		});
+
+		await client.query(`use [master];`);
+		await client.query(`drop database if exists [drizzle];`);
+		await client.query(`create database [drizzle];`);
+		await client.query(`use [drizzle];`);
+
+		let transaction: mssql.Transaction | null = null;
+		let req: mssql.Request | null = null;
+		if (tx) {
+			transaction = client.transaction();
+			req = new mssql.Request(transaction);
+			await transaction.begin();
+		}
+
+		const db = {
+			query: async (sql: string, params: any[] = []) => {
+				const res = await (req ?? client).query(sql).catch((e) => {
+					throw new Error(e.message);
+				});
+				return res.recordset as any[];
+			},
+		};
+		const close = async () => {
+			if (transaction) {
+				await transaction.rollback().catch((e) => {});
+			}
+			await client?.close().catch(console.error);
+		};
+
+		const clear = async () => {
+			if (transaction) {
+				try {
+					await transaction.rollback();
+					await transaction.begin();
+				} catch {
+					transaction = client.transaction();
+					await transaction.begin();
+					req = new mssql.Request(transaction);
+				}
+				return;
+			}
+
+			await client.query(`use [master];`);
+			await client.query(`drop database if exists [drizzle];`);
+			await client.query(`create database [drizzle];`);
+			await client.query(`use [drizzle];`);
+		};
+		return { db, close, clear, client };
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+};
diff --git a/drizzle-kit/tests/mssql/pull.test.ts b/drizzle-kit/tests/mssql/pull.test.ts
new file mode 100644
index 0000000000..e711ac083b
--- /dev/null
+++ b/drizzle-kit/tests/mssql/pull.test.ts
@@ -0,0 +1,709 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	AnyMsSqlColumn,
+	bigint,
+	binary,
+	bit,
+	char,
+	check,
+	date,
+	datetime,
+	datetime2,
+	datetimeoffset,
+	decimal,
+	float,
+	index,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	mssqlView,
+	nchar,
+	ntext,
+	numeric,
+	nvarchar,
+	real,
+	smallint,
+	text,
+	time,
+	tinyint,
+	uniqueIndex,
+	varbinary,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import fs from 'fs';
+import { fromDatabaseForDrizzle } from 'src/dialects/mssql/introspect';
+import type { DB } from 'src/utils';
+import { diffIntrospect, prepareTestDatabase, TestDatabase } from 'tests/mssql/mocks';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+if (!fs.existsSync('tests/mssql/tmp')) {
+	fs.mkdirSync(`tests/mssql/tmp`, { recursive: true });
+}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('basic introspect test', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').notNull(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'basic-introspect');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic identity always test', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity({ increment: 1, seed: 2 }),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'basic-identity-always-introspect');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic identity by default test', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity({ increment: 1, seed: 2 }),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-identity-default-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('basic index test', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			firstName: nvarchar('first_name', { length: 244 }),
+			lastName: nvarchar('last_name', { length: 244 }),
+			data: nvarchar('data', { mode: 'json' }),
+		}, (table) => [
+			index('single_column').on(table.firstName),
+			index('multi_column').on(table.firstName, table.lastName),
+		]),
+	};
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-index-introspect',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('identity always test: few params', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity({
+				seed: 100,
+				increment: 1,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-always-few-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('identity by default test: few params', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity({
+				seed: 10000,
+				increment: 1,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-few-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('identity always test: all params', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-always-all-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('identity by default test: all params', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+			email: text('email'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-all-params-introspect',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('generated column: link to another column', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+			email: varchar({ length: 255 }),
+			generatedEmail: varchar('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`[email]`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'generated-link-column',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect all column types', async () => {
+	const schema = {
+		columns: mssqlTable('columns', {
+			bigint: bigint({ mode: 'number' }).default(1),
+			bigint1: bigint({ mode: 'bigint' }).default(BigInt(1)),
+			bigint2: bigint({ mode: 'string' }).default('1'),
+
+			binary: binary({ length: 123 }).default(Buffer.from('hello, world')),
+
+			bit: bit().default(false),
+			bit1: bit().default(true),
+
+			char: char({ length: 2 }).default('1'),
+			nChar: nchar({ length: 2 }).default('1'),
+
+			date: date({ mode: 'date' }).default(new Date()),
+			date1: date({ mode: 'string' }).default('2023-05-05'),
+			date2: date({ mode: 'string' }).defaultGetDate(),
+
+			datetime: datetime({ mode: 'date' }).default(new Date()),
+			datetime1: datetime({ mode: 'string' }).default('2023-05-05'),
+			datetime12: datetime({ mode: 'string' }).defaultGetDate(),
+
+			datetime2: datetime2({ mode: 'date' }).default(new Date()),
+			datetime21: datetime2({ mode: 'string' }).default('2023-05-05'),
+			datetime22: datetime2({ mode: 'string' }).defaultGetDate(),
+
+			datetimeoffset: datetimeoffset({ mode: 'date' }).default(new Date()),
+			datetimeoffset1: datetimeoffset({ mode: 'string' }).default('2023-05-05'),
+			datetimeoffset2: datetimeoffset({ mode: 'string' }).defaultGetDate(),
+
+			decimal: decimal({ precision: 3, scale: 1 }).default('32.1'),
+
+			float: float({ precision: 3 }).default(32.1),
+
+			int: int().default(32),
+
+			numeric: numeric({ precision: 3, scale: 1 }).default('32.1'),
+
+			real: real().default(32.4),
+
+			smallint: smallint().default(3),
+
+			text: text().default('hey'),
+			nText: ntext().default('hey'),
+
+			time: time({ mode: 'date', precision: 2 }).default(new Date()),
+			time1: time({ mode: 'string', precision: 2 }).default('14:53:00.000'),
+
+			tinyint: tinyint().default(123),
+
+			varbinary: varbinary({ length: 213 }).default(Buffer.from('hey')),
+
+			varchar: varchar({ length: 213 }).default('hey'),
+			nvarchar: nvarchar({ length: 213 }).default('hey'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-all-columns-types',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect columns with name with non-alphanumeric characters', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			'not:allowed': int('not:allowed'),
+			'nuh--uh': int('nuh-uh'),
+			'1_nope': int('1_nope'),
+			valid: int('valid'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-column-with-name-with-non-alphanumeric-characters',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect strings with single quotes', async () => {
+	const schema = {
+		columns: mssqlTable('columns', {
+			text: text('text').default('escape\'s quotes " '),
+			varchar: varchar('varchar').default('escape\'s quotes " '),
+			ntext: ntext('ntext').default('escape\'s quotes " '),
+			nvarchar: nvarchar('nvarchar').default('escape\'s quotes " '),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-strings-with-single-quotes',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect checks', async () => {
+	const schema = {
+		users: mssqlTable('users', {
+			id: int('id'),
+			name: varchar('name'),
+			age: int('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-checks',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect checks from different schemas with same names', async () => {
+	const mySchema = mssqlSchema('schema2');
+	const schema = {
+		mySchema,
+		users: mssqlTable('users', {
+			id: int('id'),
+			age: int('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+		usersInMySchema: mySchema.table('users', {
+			id: int('id'),
+			age: int('age'),
+		}, (table) => [check('some_check', sql`${table.age} < 1`)]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-checks-diff-schema-same-names',
+		['dbo', 'schema2'],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = mssqlView('some_view').as((qb) => qb.select().from(users));
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect view #2', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = mssqlView('some_view', { id: int('asd') }).with({ checkOption: true }).as(
+		sql`SELECT * FROM ${users}`,
+	);
+	const schema = {
+		view,
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view-2',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect primary key with unqiue', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: varchar('users'),
+	}, (t) => [
+		index('some_name').on(t.name),
+		uniqueIndex('some_name1').on(t.name),
+	]);
+
+	const schema = {
+		users,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-pk',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect fk with onUpdate, onDelete set', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: varchar('users'),
+	});
+
+	const schema = {
+		users,
+		posts: mssqlTable('posts', {
+			id: int(),
+			usersId: int().references(() => users.id, { onDelete: 'cascade', onUpdate: 'no action' }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-fk',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect table with self reference', async () => {
+	const table1 = mssqlTable('table1', {
+		column1: int().primaryKey(),
+		column2: int().references((): AnyMsSqlColumn => table1.column1),
+	});
+
+	const schema = { table1 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-table-with-self-ref');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect empty db', async () => {
+	const { introspectDDL } = await diffIntrospect(
+		db,
+		{},
+		'introspect-empty-db',
+	);
+
+	expect(introspectDDL.entities.list().length).toBe(0);
+});
+
+test('indexes #2', async () => {
+	const table1 = mssqlTable('table1', {
+		col1: int(),
+		col2: int(),
+	}, () => [
+		index1,
+		index2,
+		index3,
+		index4,
+		index5,
+		index6,
+	]);
+
+	const index1 = uniqueIndex('index1').on(table1.col1);
+	const index2 = uniqueIndex('index2').on(table1.col1, table1.col2);
+	const index3 = index('index3').on(table1.col1);
+	const index4 = index('index4').on(table1.col1, table1.col2);
+	const index5 = index('index5').on(sql`${table1.col1} asc`);
+	const index6 = index('index6').on(sql`${table1.col1} asc`, sql`${table1.col2} desc`);
+
+	const schema = { table1 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'sql-in-index');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test('single quote default', async () => {
+	const group = mssqlTable('group', {
+		id: text().notNull(),
+		fk_organizaton_group: text().notNull(),
+		saml_identifier: text().default('').notNull(),
+		display_name: text().default('').notNull(),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ group },
+		'single_quote_default',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// other tables in migration schema
+test('pull after migrate with custom migrations table #1', async () => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE drizzle.__drizzle_migrations (
+			id INTEGER CONSTRAINT custom_migrations_pkey PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at DATETIME
+		);
+	`);
+	await db.query(`
+		CREATE TABLE drizzle.users (
+			id INTEGER CONSTRAINT users_pkey PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { pks, columns, tables, schemas } = await fromDatabaseForDrizzle(
+		db,
+		() => true,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'drizzle',
+		},
+		{
+			entityType: 'tables',
+
+			name: 'users',
+			schema: 'drizzle',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'drizzle',
+			table: 'users',
+		},
+	]);
+});
+
+// no tables in migration schema
+test('pull after migrate with custom migrations table #2', async () => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE drizzle.__drizzle_migrations (
+			id INTEGER CONSTRAINT custom_migrations_pkey PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at DATETIME
+		);
+	`);
+	await db.query(`
+		CREATE TABLE dbo.users (
+			id INTEGER CONSTRAINT users_pkey PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		() => true,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+
+			name: 'users',
+			schema: 'dbo',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'dbo',
+			table: 'users',
+		},
+	]);
+});
+
+// other tables in custom migration schema
+test('pull after migrate with custom migrations table #3', async () => {
+	await db.query(`CREATE SCHEMA [custom];`);
+	await db.query(`
+		CREATE TABLE [custom].[custom_migrations] (
+			id INTEGER CONSTRAINT custom_migrations_pkey PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at DATETIME
+		);
+	`);
+	await db.query(`
+		CREATE TABLE [custom].[users] (
+			id INTEGER CONSTRAINT users_pkey PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.query(`
+		CREATE TABLE [users] (
+			id INTEGER CONSTRAINT users_pkey PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		() => true,
+		() => {},
+		{
+			table: 'custom_migrations',
+			schema: 'custom',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'custom',
+		},
+		{
+			entityType: 'tables',
+			name: 'users',
+			schema: 'custom',
+		},
+		{
+			entityType: 'tables',
+			name: 'users',
+			schema: 'dbo',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'custom',
+			table: 'users',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'dbo',
+			table: 'users',
+		},
+	]);
+});
diff --git a/drizzle-kit/tests/mssql/push.test.ts b/drizzle-kit/tests/mssql/push.test.ts
new file mode 100644
index 0000000000..d815f8e51c
--- /dev/null
+++ b/drizzle-kit/tests/mssql/push.test.ts
@@ -0,0 +1,1234 @@
+import {
+	bigint,
+	check,
+	foreignKey,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	mssqlView,
+	smallint,
+	text,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { eq, sql } from 'drizzle-orm/sql';
+import { suggestions } from 'src/cli/commands/push-mssql';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { DB } from 'src/utils';
+import { diff, prepareTestDatabase, push, TestDatabase } from 'tests/mssql/mocks';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// identity push tests
+test('create table: identity - no params', async () => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+			id1: bigint('id1', { mode: 'number' }),
+			id2: smallint('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(1, 1),
+\t[id1] bigint,
+\t[id2] smallint
+);\n`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view encryption', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const schema = {
+		users,
+		view: mssqlView('some_view').with({ encryption: true })
+			.as((
+				qb,
+			) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(schema, schema, []);
+
+	await push({ db, to: schema });
+	const { sqlStatements: pst } = await push({ db, to: schema });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('create table: identity always/by default - with params', async () => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').identity({
+				increment: 4,
+				seed: 3,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		`CREATE TABLE [users] (
+\t[id] int IDENTITY(3, 4)
+);\n`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('no diff: identity always/by default - no params', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('no diff: identity always/by default - all params', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').identity({
+				seed: 1,
+				increment: 1,
+			}),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id').identity({
+				seed: 1,
+				increment: 1,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from a column - no params', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			id: int('id').identity(),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		`EXEC sp_rename 'users.id', [__old_id], 'COLUMN';`,
+		`ALTER TABLE [users] ADD [id] int;`,
+		`INSERT INTO [users] ([id]) SELECT [__old_id] FROM [users];`,
+		`ALTER TABLE [users] DROP COLUMN [__old_id];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column with identity - no params', async () => {
+	const schema1 = {
+		users: mssqlTable('users', {
+			email: text('email'),
+		}),
+	};
+
+	const schema2 = {
+		users: mssqlTable('users', {
+			email: text('email'),
+			id: int('id').identity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE [users] ADD [id] int IDENTITY(1, 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view', async () => {
+	const table = mssqlTable('test', {
+		id: int('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: mssqlView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		'CREATE VIEW [view] AS select distinct [id] from [test];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check constraint to table', async () => {
+	const schema1 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(2),
+		}),
+	};
+	const schema2 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(2),
+		}, (table) => [
+			check('some_check1', sql`${table.values} < 100`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE [test] ADD CONSTRAINT [some_check1] CHECK ([test].[values] < 100);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check constraint', async () => {
+	const schema1 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [
+			check('some_check', sql`${table.values} < 100`),
+		]),
+	};
+	const schema2 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE [test] DROP CONSTRAINT [some_check];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter check constraint', async () => {
+	const schema1 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [
+			check('some_check', sql`${table.values} < 100`),
+		]),
+	};
+	const schema2 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [
+			check('some_check', sql`${table.values} < 10`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	// Only diff should find changes
+	expect(st).toStrictEqual([
+		'ALTER TABLE [test] DROP CONSTRAINT [some_check];',
+		'ALTER TABLE [test] ADD CONSTRAINT [some_check] CHECK ([test].[values] < 10);',
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('db has checks. Push with same names', async () => {
+	const schema1 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [check('some_check', sql`${table.values} < 100`)]),
+	};
+	const schema2 = {
+		test: mssqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [check('some_check', sql`1=1`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE [test] DROP CONSTRAINT [some_check];`,
+		`ALTER TABLE [test] ADD CONSTRAINT [some_check] CHECK (1=1);`,
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop view', async () => {
+	const table = mssqlTable('test', {
+		id: int('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: mssqlView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	const st0: string[] = [
+		'DROP VIEW [view];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter view definition', async () => {
+	const table = mssqlTable('test', {
+		id: int('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: mssqlView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: mssqlView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	expect(st).toStrictEqual([
+		`ALTER VIEW [view] AS select distinct [id] from [test] where [test].[id] = 1;`,
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop view with data', async () => {
+	const table = mssqlTable('table', {
+		id: int('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: mssqlView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const seedStatements = [`INSERT INTO [table] ([id]) VALUES (1), (2), (3)`];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, schemas: ['dbo'] });
+	const { sqlStatements: pst, hints: phints } = await push({
+		db,
+		to: schema2,
+		schemas: ['dbo'],
+	});
+
+	// seeding
+	for (const seedSt of seedStatements) {
+		await db.query(seedSt);
+	}
+
+	const st0: string[] = [
+		`DROP VIEW [view];`,
+	];
+	// const hints0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	// expect(phints).toStrictEqual(hints0);
+});
+
+test('fk multistep #1', async (t) => {
+	const refTable = mssqlTable('ref', {
+		id: int().identity(),
+		name: varchar().unique(),
+	});
+	const sch1 = {
+		refTable,
+		users: mssqlTable('users', {
+			name: varchar().unique().references(() => refTable.name),
+		}),
+	};
+
+	const { sqlStatements: diffSt1 } = await diff({}, sch1, []);
+	const { sqlStatements: st1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const st01 = [
+		'CREATE TABLE [ref] (\n\t[id] int IDENTITY(1, 1),\n\t[name] varchar,\n\tCONSTRAINT [ref_name_key] UNIQUE([name])\n);\n',
+		'CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_name_ref_name_fk] FOREIGN KEY ([name]) REFERENCES [ref]([name]);',
+	];
+
+	expect(st1).toStrictEqual(st01);
+	expect(diffSt1).toStrictEqual(st01);
+
+	const sch2 = {
+		refTable,
+		users: mssqlTable('users2', {
+			name: varchar('name2').unique().references(() => refTable.name),
+		}),
+	};
+
+	const renames = ['dbo.users->dbo.users2', 'dbo.users2.name->dbo.users2.name2'];
+	const { sqlStatements: diffSt2 } = await diff(sch1, sch2, renames);
+	const { sqlStatements: st2 } = await push({
+		db,
+		to: sch2,
+		renames,
+		schemas: ['dbo'],
+	});
+
+	const st02 = [
+		`EXEC sp_rename 'users', [users2];`,
+		`EXEC sp_rename 'users2.name', [name2], 'COLUMN';`,
+	];
+
+	expect(st2).toStrictEqual(st02);
+	expect(diffSt2).toStrictEqual(st02);
+
+	const { sqlStatements: diffSt3 } = await diff(sch2, sch2, []);
+	const { sqlStatements: st3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(diffSt3).toStrictEqual([]);
+
+	const sch3 = {
+		refTable,
+		users: mssqlTable('users2', {
+			name: varchar('name2').unique(),
+		}),
+	};
+
+	// TODO should we check diff here?
+	// const { sqlStatements: diffSt4 } = await diff(sch2, sch3, []);
+	const { sqlStatements: st4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const st04 = ['ALTER TABLE [users2] DROP CONSTRAINT [users_name_ref_name_fk];\n'];
+
+	expect(st4).toStrictEqual(st04);
+	// expect(diffSt4).toStrictEqual(st04);
+});
+
+test('fk multistep #2', async (t) => {
+	const refTable = mssqlTable('ref', {
+		id: int().identity(),
+		name: varchar().unique(),
+	});
+	const sch1 = {
+		refTable,
+		users: mssqlTable('users', {
+			name: varchar().unique().references(() => refTable.name),
+		}),
+	};
+
+	const { sqlStatements: diffSt1 } = await diff({}, sch1, []);
+	const { sqlStatements: st1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const st01 = [
+		'CREATE TABLE [ref] (\n\t[id] int IDENTITY(1, 1),\n\t[name] varchar,\n\tCONSTRAINT [ref_name_key] UNIQUE([name])\n);\n',
+		'CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [users_name_ref_name_fk] FOREIGN KEY ([name]) REFERENCES [ref]([name]);',
+	];
+
+	expect(st1).toStrictEqual(st01);
+	expect(diffSt1).toStrictEqual(st01);
+
+	const refTableRenamed = mssqlTable('ref2', {
+		id: int().identity(),
+		name: varchar('name2').unique(),
+	});
+	const sch2 = {
+		refTable: refTableRenamed,
+		users: mssqlTable('users', {
+			name: varchar().unique().references(() => refTableRenamed.name),
+		}),
+	};
+
+	const renames = ['dbo.ref->dbo.ref2', 'dbo.ref2.name->dbo.ref2.name2'];
+	const { sqlStatements: diffSt2 } = await diff(sch1, sch2, renames);
+	const { sqlStatements: st2 } = await push({
+		db,
+		to: sch2,
+		renames,
+		schemas: ['dbo'],
+	});
+
+	const st02 = [
+		`EXEC sp_rename 'ref', [ref2];`,
+		`EXEC sp_rename 'ref2.name', [name2], 'COLUMN';`,
+	];
+
+	expect(st2).toStrictEqual(st02);
+	expect(diffSt2).toStrictEqual(st02);
+
+	const { sqlStatements: diffSt3 } = await diff(sch2, sch2, []);
+	const { sqlStatements: st3 } = await push({ db, to: sch2, schemas: ['dbo'] });
+
+	expect(st3).toStrictEqual([]);
+	expect(diffSt3).toStrictEqual([]);
+
+	const sch3 = {
+		refTable: refTableRenamed,
+		users: mssqlTable('users', {
+			name: varchar('name').unique(),
+		}),
+	};
+
+	// TODO should we check diff here?
+	// const { sqlStatements: diffSt4 } = await diff(sch2, sch3, []);
+	const { sqlStatements: st4 } = await push({ db, to: sch3, schemas: ['dbo'] });
+
+	const st04 = ['ALTER TABLE [users] DROP CONSTRAINT [users_name_ref_name_fk];\n'];
+
+	expect(st4).toStrictEqual(st04);
+	// expect(diffSt4).toStrictEqual(st04);
+});
+
+test('rename fk', async (t) => {
+	const refTable = mssqlTable('ref', {
+		id: int().identity(),
+		name: varchar().unique(),
+	});
+
+	const sch1 = {
+		refTable,
+		users: mssqlTable('users', {
+			name: varchar().unique(),
+		}, (t) => [foreignKey({ name: 'some', columns: [t.name], foreignColumns: [refTable.name] })]),
+	};
+
+	const { sqlStatements: diffSt1 } = await diff({}, sch1, []);
+	const { sqlStatements: st1 } = await push({ db, to: sch1, schemas: ['dbo'] });
+
+	const st01 = [
+		'CREATE TABLE [ref] (\n\t[id] int IDENTITY(1, 1),\n\t[name] varchar,\n\tCONSTRAINT [ref_name_key] UNIQUE([name])\n);\n',
+		'CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n',
+		'ALTER TABLE [users] ADD CONSTRAINT [some] FOREIGN KEY ([name]) REFERENCES [ref]([name]);',
+	];
+
+	expect(st1).toStrictEqual(st01);
+	expect(diffSt1).toStrictEqual(st01);
+
+	const sch2 = {
+		refTable,
+		users: mssqlTable('users', {
+			name: varchar().unique(),
+		}, (t) => [foreignKey({ name: 'some_new', columns: [t.name], foreignColumns: [refTable.name] })]), // renamed fk
+	};
+
+	const renames = ['dbo.users.some->dbo.users.some_new'];
+	const { sqlStatements: diffSt2 } = await diff(sch1, sch2, renames);
+	const { sqlStatements: st2 } = await push({
+		db,
+		to: sch2,
+		renames,
+		schemas: ['dbo'],
+	});
+
+	const st02 = [
+		`EXEC sp_rename 'some', [some_new], 'OBJECT';`,
+	];
+
+	expect(st2).toStrictEqual(st02);
+	expect(diffSt2).toStrictEqual(st02);
+});
+
+test('hints + losses: drop table that is not empty', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, from, []);
+	const { sqlStatements: pst1 } = await push({ db, to: from });
+
+	const st_01 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[name] varchar(200)\n);\n',
+	];
+
+	expect(st1).toStrictEqual(st_01);
+	expect(pst1).toStrictEqual(st_01);
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const { sqlStatements: st2 } = await diff(n1, {}, []);
+	const { sqlStatements: pst2, hints, error } = await push({ db, to: {} });
+
+	const st_02 = [
+		'DROP TABLE [users];',
+	];
+
+	expect(st2).toStrictEqual(st_02);
+	expect(pst2).toStrictEqual(st_02);
+	expect(hints).toStrictEqual([{ hint: "You're about to delete non-empty [users] table" }]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: drop column that is not empty', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, from, []);
+	const { sqlStatements: pst1 } = await push({ db, to: from });
+
+	const st_01 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[name] varchar(200)\n);\n',
+	];
+
+	expect(st1).toStrictEqual(st_01);
+	expect(pst1).toStrictEqual(st_01);
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(from, to, []);
+	const { sqlStatements: pst2, hints, error } = await push({ db, to: to });
+
+	const st_02 = [
+		'ALTER TABLE [users] DROP COLUMN [name];',
+	];
+
+	expect(st2).toStrictEqual(st_02);
+	expect(pst2).toStrictEqual(st_02);
+	expect(hints).toStrictEqual([{ hint: "You're about to delete non-empty [name] column in [users] table" }]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: drop column that is empty', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, from, []);
+	const { sqlStatements: pst1 } = await push({ db, to: from });
+
+	const st_01 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[name] varchar(200)\n);\n',
+	];
+
+	expect(st1).toStrictEqual(st_01);
+	expect(pst1).toStrictEqual(st_01);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(from, to, []);
+	const { sqlStatements: pst2, hints, error } = await push({ db, to: to });
+
+	const st_02 = [
+		'ALTER TABLE [users] DROP COLUMN [name];',
+	];
+
+	expect(st2).toStrictEqual(st_02);
+	expect(pst2).toStrictEqual(st_02);
+	expect(hints).toStrictEqual([]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: drop schema', async (t) => {
+	const users = mssqlTable('users', {
+		id: int(),
+		name: varchar({ length: 200 }),
+	});
+	const from = {
+		mySchema: mssqlSchema('my_schema'),
+		users,
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, from, []);
+	const { sqlStatements: pst1 } = await push({ db, to: from });
+
+	const st_01 = [
+		`CREATE SCHEMA [my_schema];\n`,
+		'CREATE TABLE [users] (\n\t[id] int,\n\t[name] varchar(200)\n);\n',
+	];
+
+	expect(st1).toStrictEqual(st_01);
+	expect(pst1).toStrictEqual(st_01);
+
+	const to = {
+		users,
+	};
+
+	const { sqlStatements: st2 } = await diff(from, to, []);
+	const { sqlStatements: pst2, hints, error } = await push({ db, to: to });
+
+	const st_02 = [
+		'DROP SCHEMA [my_schema];\n',
+	];
+
+	expect(st2).toStrictEqual(st_02);
+	expect(pst2).toStrictEqual(st_02);
+	expect(hints).toStrictEqual([]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: drop schema with tables', async (t) => {
+	// user has a schema in db with table
+	await db.query(`CREATE SCHEMA test;`);
+	await db.query(`CREATE TABLE test.test(id int);`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	const { sqlStatements: pst1, hints, error } = await push({ db, to: to });
+
+	const st_01 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\t[name] varchar(200)\n);\n`,
+		'DROP TABLE [test].[test];',
+		`DROP SCHEMA [test];\n`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([{ hint: `You're about to delete [test] schema with 1 table` }]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: add column', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+			age: int(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({ db, to: to });
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD [age] int;`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: add column with not null without default', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+			age: int().notNull(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD [age] int NOT NULL;`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).not.toBeNull();
+
+	// await expect(push({ db, to: to, force: true, ignoreSubsequent: true })).resolves.not.toThrowError();
+});
+test('hints + losses: add column with not null without default #2', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+			age: int().notNull(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD [age] int NOT NULL;`,
+	];
+
+	// expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+});
+
+test('hints + losses: add column with not null with default', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+			age: int().notNull().default(1),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({ db, to: to });
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD [age] int NOT NULL CONSTRAINT [users_age_default] DEFAULT ((1));`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: alter column add not null without default', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id]) VALUES (1), (2);`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).notNull(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(200) NOT NULL;`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).not.toBeNull();
+
+	// await expect(push({ db, to: to, force: true, ignoreSubsequent: true })).resolves.toThrowError();
+});
+
+test('hints + losses: alter column add not null without default #2', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id]) VALUES (1), (2);`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).notNull(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(200) NOT NULL;`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).not.toBeNull();
+
+	await expect(push({ db, to: to, force: true, ignoreSubsequent: true })).rejects.toThrowError();
+});
+
+// TODO
+// this should definitely fail
+// MSSQL does not support altering column for adding default
+//                                                                  not possible
+// <ALTER TABLE [users] ALTER COLUMN [name] varchar(200) NOT NULL> !CONSTRAINT DEFAULT ...!;
+//
+// Even if to try change data type + add default + add not null
+// MSSQL will not update existing NULLS to defaults, so this will not work
+// Should add hints i believe for generate and push
+test('hints + losses: alter column add not null with default', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id]) VALUES (1), (2);`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).notNull().default('1'),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ALTER COLUMN [name] varchar(200) NOT NULL;`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_default] DEFAULT ('1') FOR [name];`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(hints).toStrictEqual([]);
+	expect(error).not.toBeNull();
+});
+
+test('hints + losses: add unique to column #1', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Andrew');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).unique(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({ db, to: to });
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_key] UNIQUE([name]);`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(error).toBeNull();
+});
+
+test('hints + losses: add unique to column #2', async (t) => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }),
+		}),
+	};
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO [users] ([id], [name]) VALUES (1, 'Alex'), (2, 'Alex');`);
+
+	const to = {
+		users: mssqlTable('users', {
+			id: int(),
+			name: varchar({ length: 200 }).unique(),
+		}),
+	};
+	const { sqlStatements: pst1, hints, error } = await push({
+		db,
+		to: to,
+		expectError: true,
+		ignoreSubsequent: true,
+	});
+
+	const st_01 = [
+		`ALTER TABLE [users] ADD CONSTRAINT [users_name_key] UNIQUE([name]);`,
+	];
+
+	expect(pst1).toStrictEqual(st_01);
+	expect(error).not.toBeNull();
+});
+
+// In non-interactive / json mode `suggestions` throws a structured `unsupported_schema_change`
+// instead of pushing the unsupported-rename comment, so it is exercised directly with that context.
+test('renaming a schema throws `rename_schema_unsupported`', async () => {
+	const oldSchema = mssqlSchema('old_analytics');
+	const newSchema = mssqlSchema('analytics');
+	const before = {
+		oldSchema,
+		events: oldSchema.table('events', { id: int() }),
+	};
+	const after = {
+		newSchema,
+		events: newSchema.table('events', { id: int() }),
+	};
+	const renames = ['old_analytics->analytics'];
+
+	await push({ db, to: before });
+	const { statements, next } = await diff(before, after, renames);
+
+	await expect(
+		runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => suggestions(db, statements, next, new HintsHandler()),
+		),
+	).rejects.toMatchObject({
+		code: 'unsupported_schema_change',
+		meta: {
+			kind: 'rename_schema_unsupported',
+			from: 'old_analytics',
+			to: 'analytics',
+			dialect: 'mssql',
+		},
+	});
+});
+
+test('renaming a column used in a check constraint throws `rename_blocked_by_check_constraint`', async () => {
+	const before = {
+		users: mssqlTable('users', { id: int() }, (t) => [check('hey', sql`${t.id} != 2`)]),
+	};
+	const after = {
+		users: mssqlTable('users', { id: int('id1') }, (t) => [check('hey', sql`${t.id} != 2`)]),
+	};
+	const renames = ['dbo.users.id->dbo.users.id1'];
+
+	await push({ db, to: before });
+	const { statements, next } = await diff(before, after, renames);
+
+	await expect(
+		runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => suggestions(db, statements, next, new HintsHandler()),
+		),
+	).rejects.toMatchObject({
+		code: 'unsupported_schema_change',
+		meta: {
+			kind: 'rename_blocked_by_check_constraint',
+			schema: 'dbo',
+			table: 'users',
+			from: 'id',
+			to: 'id1',
+		},
+	});
+});
diff --git a/drizzle-kit/tests/mssql/schemas.test.ts b/drizzle-kit/tests/mssql/schemas.test.ts
new file mode 100644
index 0000000000..c267961a78
--- /dev/null
+++ b/drizzle-kit/tests/mssql/schemas.test.ts
@@ -0,0 +1,137 @@
+import { mssqlSchema } from 'drizzle-orm/mssql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add schema #1', async () => {
+	const to = {
+		devSchema: mssqlSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = ['CREATE SCHEMA [dev];\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add schema #2', async () => {
+	const from = {
+		devSchema: mssqlSchema('dev'),
+	};
+	const to = {
+		devSchema: mssqlSchema('dev'),
+		devSchema2: mssqlSchema('dev2'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = ['CREATE SCHEMA [dev2];\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #1', async () => {
+	const from = {
+		devSchema: mssqlSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: {} });
+
+	const st0 = ['DROP SCHEMA [dev];\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #2', async () => {
+	const from = {
+		devSchema: mssqlSchema('dev'),
+		devSchema2: mssqlSchema('dev2'),
+	};
+	const to = {
+		devSchema: mssqlSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = ['DROP SCHEMA [dev2];\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(pst);
+});
+
+// TODO add log to console that it is not possible?
+test('rename schema #1', async () => {
+	const from = {
+		devSchema: mssqlSchema('dev'),
+	};
+
+	const to = {
+		devSchema2: mssqlSchema('dev2'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dev->dev2']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dev->dev2'], ignoreSubsequent: true });
+
+	const st0 = [`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename schema #2', async () => {
+	const from = {
+		devSchema: mssqlSchema('dev'),
+		devSchema1: mssqlSchema('dev1'),
+	};
+	const to = {
+		devSchema: mssqlSchema('dev'),
+		devSchema2: mssqlSchema('dev2'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dev1->dev2']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dev1->dev2'], ignoreSubsequent: true });
+
+	const st0 = [`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mssql/tables.test.ts b/drizzle-kit/tests/mssql/tables.test.ts
new file mode 100644
index 0000000000..c34b5649b5
--- /dev/null
+++ b/drizzle-kit/tests/mssql/tables.test.ts
@@ -0,0 +1,957 @@
+import { sql } from 'drizzle-orm';
+import {
+	camelCase,
+	foreignKey,
+	index,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	mssqlTableCreator,
+	primaryKey,
+	snakeCase,
+	text,
+	unique,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+let client: TestDatabase['client'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+	client = _.client;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add table #1', async () => {
+	const to = {
+		users: mssqlTable('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = ['CREATE TABLE [users] (\n\t[id] int\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #2', async () => {
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #3', async () => {
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id'),
+		}, (t) => [primaryKey({ name: 'users_pk', columns: [t.id] })]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [users] (\n'
+		+ '\t[id] int,\n'
+		+ '\tCONSTRAINT [users_pk] PRIMARY KEY([id])\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #4', async () => {
+	const to = {
+		users: mssqlTable('users', { id: int() }),
+		posts: mssqlTable('posts', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [users] (\n\t[id] int\n);\n',
+		'CREATE TABLE [posts] (\n\t[id] int\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #5', async () => {
+	const schema = mssqlSchema('folder');
+	const from = {
+		schema,
+	};
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [folder].[users] (\n\t[id] int\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #6', async () => {
+	const from = {
+		users1: mssqlTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users2: mssqlTable('users2', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [users2] (\n\t[id] int\n);\n',
+		'DROP TABLE [users1];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #7', async () => {
+	const from = {
+		users1: mssqlTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users: mssqlTable('users', { id: int() }),
+		users2: mssqlTable('users2', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users1->dbo.users2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.users1->dbo.users2'] });
+
+	const st0 = [
+		'CREATE TABLE [users] (\n\t[id] int\n);\n',
+		`EXEC sp_rename 'users1', [users2];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline */
+test('add table #9', async () => {
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'CREATE TABLE [users] (\n'
+		+ '\t[name] varchar,\n'
+		+ '\tCONSTRAINT [users_name_key] UNIQUE([name])\n'
+		+ ');\n',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE TABLE [users] (\n'
+		+ '\t[name] varchar,\n'
+		+ '\tCONSTRAINT [users_name_key] UNIQUE([name])\n'
+		+ ');\n',
+	]);
+});
+
+/* unique inline named */
+test('add table #10', async () => {
+	const from = {};
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar().unique('name_unique'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		`CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [name_unique] UNIQUE([name])\n);\n`,
+	]);
+	expect(pst).toStrictEqual([
+		`CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [name_unique] UNIQUE([name])\n);\n`,
+	]);
+});
+
+/* unique default-named */
+test('add table #13', async () => {
+	const to = {
+		users: mssqlTable('users', {
+			name: varchar(),
+		}, (t) => [unique('users_name_key').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		`CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n`,
+	]);
+	expect(pst).toStrictEqual([
+		`CREATE TABLE [users] (\n\t[name] varchar,\n\tCONSTRAINT [users_name_key] UNIQUE([name])\n);\n`,
+	]);
+});
+
+// reference
+test('add table #14', async () => {
+	const company = mssqlTable('company', {
+		id: int().primaryKey(),
+		name: text(),
+	});
+
+	const to = {
+		company,
+		users: mssqlTable('users', {
+			company_id: int().references(() => company.id),
+			name: text(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		`CREATE TABLE [company] (
+\t[id] int,
+\t[name] text,
+\tCONSTRAINT [company_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [users] (
+\t[company_id] int,
+\t[name] text
+);\n`,
+		`ALTER TABLE [users] ADD CONSTRAINT [users_company_id_company_id_fk] FOREIGN KEY ([company_id]) REFERENCES [company]([id]);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('multiproject schema add table #1', async () => {
+	const table = mssqlTableCreator((name) => `prefix_${name}`);
+
+	const to = {
+		users: table('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'CREATE TABLE [prefix_users] (\n\t[id] int,\n\tCONSTRAINT [prefix_users_pkey] PRIMARY KEY([id])\n);\n',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE TABLE [prefix_users] (\n\t[id] int,\n\tCONSTRAINT [prefix_users_pkey] PRIMARY KEY([id])\n);\n',
+	]);
+});
+
+test('multiproject schema drop table #1', async () => {
+	const table = mssqlTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: {} });
+
+	expect(st).toStrictEqual(['DROP TABLE [prefix_users];']);
+	expect(pst).toStrictEqual(['DROP TABLE [prefix_users];']);
+});
+
+test('multiproject schema alter table name #1', async () => {
+	const table = mssqlTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: int('id').primaryKey(),
+		}),
+	};
+	const to = {
+		users1: table('users1', {
+			id: int('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.prefix_users->dbo.prefix_users1',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.prefix_users->dbo.prefix_users1'] });
+
+	const st0 = [
+		"EXEC sp_rename 'prefix_users', [prefix_users1];",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add schema + table #1', async () => {
+	const schema = mssqlSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'CREATE SCHEMA [folder];\n',
+		'CREATE TABLE [folder].[users] (\n\t[id] int\n);\n',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE SCHEMA [folder];\n',
+		'CREATE TABLE [folder].[users] (\n\t[id] int\n);\n',
+	]);
+});
+
+test('change schema with tables #1', async () => {
+	const schema = mssqlSchema('folder');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema,
+		users: schema.table('users', { id: int() }),
+	};
+	const to = {
+		schema2,
+		users: schema2.table('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['folder->folder2']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder->folder2'], ignoreSubsequent: true });
+
+	expect(st).toStrictEqual([`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`]);
+	expect(pst).toStrictEqual([`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`]);
+});
+
+test('change table schema #1', async () => {
+	const schema = mssqlSchema('folder');
+	const from = {
+		schema,
+		users: mssqlTable('users', { id: int() }),
+	};
+	const to = {
+		schema,
+		users: schema.table('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'dbo.users->folder.users',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.users->folder.users'] });
+
+	expect(st).toStrictEqual([`ALTER SCHEMA [folder] TRANSFER [dbo].[users];\n`]);
+	expect(pst).toStrictEqual([`ALTER SCHEMA [folder] TRANSFER [dbo].[users];\n`]);
+});
+
+test('change table schema #2', async () => {
+	const schema = mssqlSchema('folder');
+	const from = {
+		schema,
+		users: schema.table('users', { id: int() }),
+	};
+	const to = {
+		schema,
+		users: mssqlTable('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder.users->dbo.users',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder.users->dbo.users'] });
+
+	expect(st).toStrictEqual(['ALTER SCHEMA [dbo] TRANSFER [folder].[users];\n']);
+	expect(pst).toStrictEqual(['ALTER SCHEMA [dbo] TRANSFER [folder].[users];\n']);
+});
+
+test('change table schema #3', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder1.users->folder2.users'] });
+
+	expect(st).toStrictEqual(['ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n']);
+	expect(pst).toStrictEqual(['ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n']);
+});
+
+test('change table schema #4', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema1,
+		schema2, // add schema
+		users: schema2.table('users', { id: int() }), // move table
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder1.users->folder2.users'] });
+
+	expect(st).toStrictEqual([
+		'CREATE SCHEMA [folder2];\n',
+		'ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE SCHEMA [folder2];\n',
+		'ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n',
+	]);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1, // remove schema
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema2, // add schema
+		users: schema2.table('users', { id: int() }), // move table
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder1.users->folder2.users'] });
+
+	expect(st).toStrictEqual([
+		'CREATE SCHEMA [folder2];\n',
+		'ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n',
+		'DROP SCHEMA [folder1];\n',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE SCHEMA [folder2];\n',
+		'ALTER SCHEMA [folder2] TRANSFER [folder1].[users];\n',
+		'DROP SCHEMA [folder1];\n',
+	]);
+});
+
+test('change table schema #6', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users2', { id: int() }), // rename and move table
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.users->folder2.users2',
+	]);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['folder1.users->folder2.users2'] });
+
+	expect(st).toStrictEqual([
+		`EXEC sp_rename 'folder1.users', [users2];`,
+		`ALTER SCHEMA [folder2] TRANSFER [folder1].[users2];\n`,
+	]);
+	expect(pst).toStrictEqual([
+		`EXEC sp_rename 'folder1.users', [users2];`,
+		`ALTER SCHEMA [folder2] TRANSFER [folder1].[users2];\n`,
+	]);
+});
+
+test('change table schema #7', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema2, // rename schema
+		users: schema2.table('users2', { id: int() }), // rename table
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1->folder2',
+		'folder2.users->folder2.users2',
+	]);
+	await push({ db, to: from });
+
+	expect(st).toStrictEqual([
+		`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`,
+		`EXEC sp_rename 'folder2.users', [users2];`,
+	]);
+	await expect(push({
+		db,
+		to: to,
+		renames: ['folder1->folder2', 'folder2.users->folder2.users2'],
+	})).rejects.toThrowError(); // no folder2.users to rename
+});
+
+test('drop table + rename schema #1', async () => {
+	const schema1 = mssqlSchema('folder1');
+	const schema2 = mssqlSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema2, // rename schema
+		// drop table
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['folder1->folder2']);
+	await push({ db, to: from });
+
+	expect(st).toStrictEqual([
+		`/**
+ * ⚠️ Renaming schemas is not supported in SQL Server (MSSQL),
+ * and therefore is not supported in Drizzle ORM at this time
+ * 
+ * SQL Server does not provide a built-in command to rename a schema directly.
+ * Workarounds involve creating a new schema and migrating objects manually
+ */`,
+		`DROP TABLE [folder2].[users];`,
+	]);
+	await expect(push({
+		db,
+		to: to,
+		renames: ['folder1->folder2', 'folder2.users->folder2.users2'],
+	})).rejects.toThrowError(); // no folder2.users to drop
+});
+
+test('drop tables with fk constraint', async () => {
+	const table1 = mssqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mssqlTable('table2', {
+		column1: int().primaryKey(),
+		column2: int().references(() => table1.column1),
+	});
+	const schema1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE [table1] (\n\t[column1] int,\n\tCONSTRAINT [table1_pkey] PRIMARY KEY([column1])\n);\n',
+		'CREATE TABLE [table2] (\n\t[column1] int,\n\t[column2] int,\n\tCONSTRAINT [table2_pkey] PRIMARY KEY([column1])\n);\n',
+		'ALTER TABLE [table2] ADD CONSTRAINT [table2_column2_table1_column1_fk] FOREIGN KEY ([column2]) REFERENCES [table1]([column1]);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, {}, []);
+	const { sqlStatements: pst2 } = await push({ db, to: {} });
+
+	const expectedSt2 = [
+		'ALTER TABLE [table2] DROP CONSTRAINT [table2_column2_table1_column1_fk];\n',
+		'DROP TABLE [table1];',
+		'DROP TABLE [table2];',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('composite primary key', async () => {
+	const from = {};
+	const to = {
+		table: mssqlTable('works_to_creators', {
+			workId: int('work_id').notNull(),
+			creatorId: int('creator_id').notNull(),
+			classification: varchar('classification').notNull(),
+		}, (t) => [
+			primaryKey({ columns: [t.workId, t.creatorId, t.classification] }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		'CREATE TABLE [works_to_creators] (\n\t[work_id] int,\n\t[creator_id] int,\n\t[classification] varchar,\n\tCONSTRAINT [works_to_creators_pkey] PRIMARY KEY([work_id],[creator_id],[classification])\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column before creating unique constraint', async () => {
+	const from = {
+		table: mssqlTable('table', {
+			id: int('id').primaryKey(),
+		}),
+	};
+	const to = {
+		table: mssqlTable('table', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+		}, (t) => [unique('uq').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'ALTER TABLE [table] ADD [name] varchar(255) NOT NULL;',
+		'ALTER TABLE [table] ADD CONSTRAINT [uq] UNIQUE([name]);',
+	]);
+
+	expect(pst).toStrictEqual([
+		'ALTER TABLE [table] ADD [name] varchar(255) NOT NULL;',
+		'ALTER TABLE [table] ADD CONSTRAINT [uq] UNIQUE([name]);',
+	]);
+});
+
+test('alter composite primary key', async () => {
+	const from = {
+		table: mssqlTable('table', {
+			col1: int('col1').notNull(),
+			col2: int('col2').notNull(),
+			col3: varchar('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col1, t.col2],
+			}),
+		]),
+	};
+	const to = {
+		table: mssqlTable('table', {
+			col1: int('col1').notNull(),
+			col2: int('col2').notNull(),
+			col3: varchar('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col2, t.col3],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'ALTER TABLE [table] DROP CONSTRAINT [table_pk];',
+		'ALTER TABLE [table] ADD CONSTRAINT [table_pk] PRIMARY KEY ([col2],[col3]);',
+	]);
+	expect(pst).toStrictEqual([
+		'ALTER TABLE [table] DROP CONSTRAINT [table_pk];',
+		'ALTER TABLE [table] ADD CONSTRAINT [table_pk] PRIMARY KEY ([col2],[col3]);',
+	]);
+});
+
+test('add index', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+		}, (t) => [index('some_index_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'CREATE INDEX [some_index_name] ON [users] ([name]);',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE INDEX [some_index_name] ON [users] ([name]);',
+	]);
+});
+
+test('add unique index', async () => {
+	const from = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+		}),
+	};
+	const to = {
+		users: mssqlTable('users', {
+			id: int('id').primaryKey(),
+			name: varchar('name', { length: 255 }).notNull(),
+		}, (t) => [uniqueIndex('some_index_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([
+		'CREATE UNIQUE INDEX [some_index_name] ON [users] ([name]);',
+	]);
+	expect(pst).toStrictEqual([
+		'CREATE UNIQUE INDEX [some_index_name] ON [users] ([name]);',
+	]);
+});
+
+test('optional db aliases (snake case)', async () => {
+	const from = {};
+
+	const t1 = snakeCase.table(
+		't1',
+		{
+			t1Id1: int().notNull().primaryKey(),
+			t1Col2: int().notNull(),
+			t1Col3: int().notNull(),
+			t2Ref: int().notNull().references(() => t2.t2Id),
+			t1Uni: int().notNull(),
+			t1UniIdx: int().notNull(),
+			t1Idx: int().notNull(),
+		},
+		(table) => [
+			unique('t1_uni').on(table.t1Uni),
+			uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
+			index('t1_idx').on(table.t1Idx).where(sql`${table.t1Idx} > 0`),
+			foreignKey({
+				columns: [table.t1Col2, table.t1Col3],
+				foreignColumns: [t3.t3Id1, t3.t3Id2],
+			}),
+		],
+	);
+
+	const t2 = snakeCase.table(
+		't2',
+		{
+			t2Id: int().primaryKey(),
+		},
+	);
+
+	const t3 = snakeCase.table(
+		't3',
+		{
+			t3Id1: int(),
+			t3Id2: int(),
+		},
+		(table) => [primaryKey({ columns: [table.t3Id1, table.t3Id2] })],
+	);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st1 = `CREATE TABLE [t1] (
+	[t1_id1] int,
+	[t1_col2] int NOT NULL,
+	[t1_col3] int NOT NULL,
+	[t2_ref] int NOT NULL,
+	[t1_uni] int NOT NULL,
+	[t1_uni_idx] int NOT NULL,
+	[t1_idx] int NOT NULL,
+	CONSTRAINT [t1_pkey] PRIMARY KEY([t1_id1]),
+	CONSTRAINT [t1_uni] UNIQUE([t1_uni])
+);
+`;
+
+	const st2 = `CREATE TABLE [t2] (
+	[t2_id] int,
+	CONSTRAINT [t2_pkey] PRIMARY KEY([t2_id])
+);
+`;
+
+	const st3 = `CREATE TABLE [t3] (
+	[t3_id1] int,
+	[t3_id2] int,
+	CONSTRAINT [t3_pkey] PRIMARY KEY([t3_id1],[t3_id2])
+);
+`;
+
+	const st4 =
+		`ALTER TABLE [t1] ADD CONSTRAINT [t1_t2_ref_t2_t2_id_fk] FOREIGN KEY ([t2_ref]) REFERENCES [t2]([t2_id]);`;
+	const st5 =
+		`ALTER TABLE [t1] ADD CONSTRAINT [t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fk] FOREIGN KEY ([t1_col2],[t1_col3]) REFERENCES [t3]([t3_id1],[t3_id2]);`;
+
+	const st6 = `CREATE UNIQUE INDEX [t1_uni_idx] ON [t1] ([t1_uni_idx]);`;
+
+	const st7 = `CREATE INDEX [t1_idx] ON [t1] ([t1_idx]) WHERE [t1_idx] > 0;`;
+
+	expect(st).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
+	expect(pst).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
+});
+
+test('optional db aliases (camel case)', async () => {
+	const from = {};
+
+	const t1 = camelCase.table('t1', {
+		t1_id1: int().notNull().primaryKey(),
+		t1_col2: int().notNull(),
+		t1_col3: int().notNull(),
+		t2_ref: int().notNull().references(() => t2.t2_id),
+		t1_uni: int().notNull(),
+		t1_uni_idx: int().notNull(),
+		t1_idx: int().notNull(),
+	}, (table) => [
+		unique('t1Uni').on(table.t1_uni),
+		uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
+		index('t1Idx').on(table.t1_idx).where(sql`${table.t1_idx} > 0`),
+		foreignKey({
+			columns: [table.t1_col2, table.t1_col3],
+			foreignColumns: [t3.t3_id1, t3.t3_id2],
+		}),
+	]);
+
+	const t2 = camelCase.table('t2', {
+		t2_id: int().primaryKey(),
+	});
+
+	const t3 = camelCase.table('t3', {
+		t3_id1: int(),
+		t3_id2: int(),
+	}, (table) => [primaryKey({ columns: [table.t3_id1, table.t3_id2] })]);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st1 = `CREATE TABLE [t1] (
+	[t1Id1] int,
+	[t1Col2] int NOT NULL,
+	[t1Col3] int NOT NULL,
+	[t2Ref] int NOT NULL,
+	[t1Uni] int NOT NULL,
+	[t1UniIdx] int NOT NULL,
+	[t1Idx] int NOT NULL,
+	CONSTRAINT [t1_pkey] PRIMARY KEY([t1Id1]),
+	CONSTRAINT [t1Uni] UNIQUE([t1Uni])
+);
+`;
+
+	const st2 = `CREATE TABLE [t2] (
+	[t2Id] int,
+	CONSTRAINT [t2_pkey] PRIMARY KEY([t2Id])
+);
+`;
+
+	const st3 = `CREATE TABLE [t3] (
+	[t3Id1] int,
+	[t3Id2] int,
+	CONSTRAINT [t3_pkey] PRIMARY KEY([t3Id1],[t3Id2])
+);
+`;
+
+	const st4 = `ALTER TABLE [t1] ADD CONSTRAINT [t1_t2Ref_t2_t2Id_fk] FOREIGN KEY ([t2Ref]) REFERENCES [t2]([t2Id]);`;
+	const st5 =
+		`ALTER TABLE [t1] ADD CONSTRAINT [t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fk] FOREIGN KEY ([t1Col2],[t1Col3]) REFERENCES [t3]([t3Id1],[t3Id2]);`;
+
+	const st6 = `CREATE UNIQUE INDEX [t1UniIdx] ON [t1] ([t1UniIdx]);`;
+
+	const st7 = `CREATE INDEX [t1Idx] ON [t1] ([t1Idx]) WHERE [t1Idx] > 0;`;
+
+	expect(st).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
+	expect(pst).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
+});
diff --git a/drizzle-kit/tests/mssql/tables2.test.ts b/drizzle-kit/tests/mssql/tables2.test.ts
new file mode 100644
index 0000000000..dbfa660a2c
--- /dev/null
+++ b/drizzle-kit/tests/mssql/tables2.test.ts
@@ -0,0 +1,145 @@
+import { sql } from 'drizzle-orm';
+import {
+	foreignKey,
+	index,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	mssqlTableCreator,
+	primaryKey,
+	text,
+	unique,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+fs.mkdirSync('./tests/mssql/migrations', { recursive: true });
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+let client: TestDatabase['client'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase(false);
+	db = _.db;
+	client = _.client;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('push after migrate with custom migrations table #1', async () => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/node-mssql/migrator');
+	const { drizzle } = await import('drizzle-orm/node-mssql');
+
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mssql/migrations',
+	});
+
+	const to = {
+		table: mssqlTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE [table1] (\n\t[col1] int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #2', async () => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/node-mssql/migrator');
+	const { drizzle } = await import('drizzle-orm/node-mssql');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mssql/migrations',
+	});
+
+	const to = {
+		table: mssqlTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE [table1] (\n\t[col1] int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #3', async () => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/node-mssql/migrator');
+	const { drizzle } = await import('drizzle-orm/node-mssql');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mssql/migrations',
+	});
+
+	const to = {
+		table: mssqlTable('table1', { col1: int() }),
+	};
+	// TODO: test is not valid, because `push` doesn't know about migrationsTable
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE [table1] (\n\t[col1] int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #4', async () => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/node-mssql/migrator');
+	const { drizzle } = await import('drizzle-orm/node-mssql');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mssql/migrations',
+	});
+	const to = {
+		table: mssqlTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE [table1] (\n\t[col1] int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
diff --git a/drizzle-kit/tests/mssql/views.test.ts b/drizzle-kit/tests/mssql/views.test.ts
new file mode 100644
index 0000000000..3750aeba14
--- /dev/null
+++ b/drizzle-kit/tests/mssql/views.test.ts
@@ -0,0 +1,1013 @@
+import { eq, sql } from 'drizzle-orm';
+import { bit, int, mssqlSchema, mssqlTable, mssqlView, varchar } from 'drizzle-orm/mssql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create table and view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [some_view] AS select [id] from [users];`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #2', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [some_view] AS SELECT * FROM [users];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #3', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: mssqlView('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			encryption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true }); // because of encryption
+
+	const st0 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [some_view1]\nWITH ENCRYPTION, SCHEMABINDING, VIEW_METADATA AS SELECT [users].[id] FROM [dbo].[users]\nWITH CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #3_1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: mssqlView('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true }); // because of encryption
+
+	const st0 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [some_view1]\nWITH SCHEMABINDING, VIEW_METADATA AS SELECT [users].[id] FROM [dbo].[users]\nWITH CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #4', async () => {
+	const schema = mssqlSchema('new_schema');
+
+	const users = schema.table('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		schema,
+		users: users,
+		view1: schema.view('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			encryption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true }); // because of encryption
+
+	const st0 = [
+		`CREATE SCHEMA [new_schema];\n`,
+		`CREATE TABLE [new_schema].[users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [new_schema].[some_view1]\nWITH ENCRYPTION, SCHEMABINDING, VIEW_METADATA AS SELECT [new_schema].[users].[id] FROM [new_schema].[users]\nWITH CHECK OPTION;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #4_1', async () => {
+	const schema = mssqlSchema('new_schema');
+
+	const users = schema.table('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		schema,
+		users: users,
+		view1: schema.view('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true }); // because of encryption
+
+	const st0 = [
+		`CREATE SCHEMA [new_schema];\n`,
+		`CREATE TABLE [new_schema].[users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [new_schema].[some_view1]\nWITH SCHEMABINDING, VIEW_METADATA AS SELECT [new_schema].[users].[id] FROM [new_schema].[users]\nWITH CHECK OPTION;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #4', async () => {
+	const schema = mssqlSchema('new_schema');
+
+	const users = schema.table('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		schema,
+		users: users,
+		view1: schema.view('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			encryption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true });
+
+	const st0 = [
+		`CREATE SCHEMA [new_schema];\n`,
+		`CREATE TABLE [new_schema].[users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [new_schema].[some_view1]\nWITH ENCRYPTION, SCHEMABINDING, VIEW_METADATA AS SELECT [new_schema].[users].[id] FROM [new_schema].[users]\nWITH CHECK OPTION;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #4_1', async () => {
+	const schema = mssqlSchema('new_schema');
+
+	const users = schema.table('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		schema,
+		users: users,
+		view1: schema.view('some_view1', { id: int('id') }).with({
+			checkOption: true,
+			schemaBinding: true,
+			viewMetadata: true,
+		}).as(sql`SELECT ${users.id} FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to, ignoreSubsequent: true });
+
+	const st0 = [
+		`CREATE SCHEMA [new_schema];\n`,
+		`CREATE TABLE [new_schema].[users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [new_schema].[some_view1]\nWITH SCHEMABINDING, VIEW_METADATA AS SELECT [new_schema].[users].[id] FROM [new_schema].[users]\nWITH CHECK OPTION;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #5', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	// view_name_duplicate
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to: to })).rejects.toThrow();
+});
+
+test('create table and view #6', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: mssqlView('some_view', { id: int('id') }).with({ checkOption: true }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [
+		`CREATE TABLE [users] (\n\t[id] int,\n\tCONSTRAINT [users_pkey] PRIMARY KEY([id])\n);\n`,
+		`CREATE VIEW [some_view] AS SELECT * FROM [users]\nWITH CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view with existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+	};
+
+	const to = {
+		users: users,
+		view1: mssqlView('some_view', { id: int('id') }).with({ checkOption: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`DROP VIEW [some_view];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view with existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).existing(),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('rename view #1', async () => {
+	const users = mssqlTable('users', { id: int() });
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('new_some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->dbo.new_some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->dbo.new_some_view'] });
+
+	const st0 = [`EXEC sp_rename 'some_view', [new_some_view];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view with existing flag', async () => {
+	const from = {
+		view: mssqlView('some_view', { id: int('id') }).existing(),
+	};
+
+	const to = {
+		view: mssqlView('new_some_view', { id: int('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->dbo.new_some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->dbo.new_some_view'] });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('view alter schema', async () => {
+	const schema = mssqlSchema('new_schema');
+	const users = mssqlTable('users', { id: int() });
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const to = {
+		users,
+		schema,
+		view: schema.view('some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->new_schema.some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->new_schema.some_view'] });
+
+	const st0 = [`CREATE SCHEMA [new_schema];\n`, `ALTER SCHEMA [new_schema] TRANSFER [some_view];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view alter schema with existing flag', async () => {
+	const schema = mssqlSchema('new_schema');
+
+	const from = {
+		view: mssqlView('some_view', { id: int('id') }).existing(),
+	};
+
+	const to = {
+		schema,
+		view: schema.view('some_view', { id: int('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->new_schema.some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->new_schema.some_view'] });
+
+	const st0 = [`CREATE SCHEMA [new_schema];\n`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').with({ encryption: true }).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view]\nWITH ENCRYPTION AS select [id] from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to view with existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', {}).existing(),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', {}).with({ schemaBinding: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop with option from view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true, schemaBinding: true }).as((
+			qb,
+		) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select [id] from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter definition', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with().as((
+			qb,
+		) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users).where(sql`1=1`)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select [id] from [users] where 1=1;`];
+	expect(st).toStrictEqual(st0);
+	// no changes on definition alter for push
+	expect(pst).toStrictEqual([]);
+});
+
+test('alter options multistep', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true, schemaBinding: true, viewMetadata: true })
+			.as((
+				qb,
+			) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select [id] from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const to2 = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true, schemaBinding: true, viewMetadata: true })
+			.as((
+				qb,
+			) => qb.select().from(users)),
+	};
+	const { sqlStatements: st_2, next: n2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst_2 } = await push({ db, to: to2 });
+
+	const st2 = [
+		`ALTER VIEW [some_view]\nWITH SCHEMABINDING, VIEW_METADATA AS select [id] from [dbo].[users]\nWITH CHECK OPTION;`,
+	];
+	expect(st_2).toStrictEqual(st2);
+	expect(pst_2).toStrictEqual(st2);
+
+	// Alter definition
+	const to3 = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true, schemaBinding: true, viewMetadata: true })
+			.as((
+				qb,
+			) => qb.select().from(users).where(sql`1=1`)),
+	};
+	const { sqlStatements: st_3 } = await diff(n2, to3, []);
+	const { sqlStatements: pst_3 } = await push({ db, to: to3 });
+
+	const st3 = [
+		`ALTER VIEW [some_view]\nWITH SCHEMABINDING, VIEW_METADATA AS select [id] from [dbo].[users] where 1=1\nWITH CHECK OPTION;`,
+	];
+	expect(st_3).toStrictEqual(st3);
+	expect(pst_3).toStrictEqual([]);
+});
+
+test('alter view_metadata', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with({ viewMetadata: true })
+			.as((
+				qb,
+			) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st, next: n1 } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select [id] from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(n1.views.list()).toStrictEqual([
+		{
+			checkOption: false,
+			definition: 'select [id] from [users]',
+			encryption: false,
+			entityType: 'views',
+			name: 'some_view',
+			schema: 'dbo',
+			schemaBinding: false,
+			viewMetadata: false,
+		},
+	]);
+
+	const to2 = {
+		users,
+		view: mssqlView('some_view').with({ viewMetadata: true })
+			.as((
+				qb,
+			) => qb.select().from(users)),
+	};
+	const { sqlStatements: st_2, next: n2 } = await diff(n1, to2, []);
+	const { sqlStatements: pst_2 } = await push({ db, to: to2 });
+
+	const st2 = [
+		`ALTER VIEW [some_view]\nWITH VIEW_METADATA AS select [id] from [users];`,
+	];
+	expect(st_2).toStrictEqual(st2);
+	expect(pst_2).toStrictEqual(st2);
+	expect(n2.views.list()).toStrictEqual([{
+		checkOption: false,
+		definition: 'select [id] from [users]',
+		encryption: false,
+		entityType: 'views',
+		name: 'some_view',
+		schema: 'dbo',
+		schemaBinding: false,
+		viewMetadata: true,
+	}]);
+});
+
+test('drop with option from view with existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', {}).with({ encryption: true })
+			.existing(),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', {}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('alter with option in view #1', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true, viewMetadata: true }).as((qb) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true }).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select [id] from [users]\nWITH CHECK OPTION;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in view with existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', {}).with({ checkOption: true, schemaBinding: true }).existing(),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', {}).with({ checkOption: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('alter with option in view #2', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: true }).as((qb) => qb.selectDistinct().from(users)),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view').with({ checkOption: false }).as((
+			qb,
+		) => qb.selectDistinct().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`ALTER VIEW [some_view] AS select distinct [id] from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter view ".as" value', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).with().as(sql`SELECT * from ${users}`),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).with().as(sql`SELECT [id] from ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = ['ALTER VIEW [some_view] AS SELECT [id] from [users];'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // do not trigger on push
+});
+
+test('existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).with().existing(),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).with().existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop existing flag', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).existing(),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * from [users]`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`CREATE VIEW [some_view] AS SELECT * from [users];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('set existing', async () => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * from [users]`),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to });
+
+	const st0 = [`DROP VIEW [some_view];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view and alter view', async () => {
+	const users = mssqlTable('users', {
+		id: int(),
+	});
+
+	const from = {
+		users,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const to = {
+		users,
+		view: mssqlView('new_some_view', { id: int('id') }).with({ checkOption: true }).as(
+			sql`SELECT * FROM [users]`,
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->dbo.new_some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->dbo.new_some_view'] });
+
+	const st0 = [
+		`EXEC sp_rename 'some_view', [new_some_view];`,
+		`ALTER VIEW [new_some_view] AS SELECT * FROM [users]\nWITH CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('moved schema and alter view', async () => {
+	const schema = mssqlSchema('my_schema');
+	const users = mssqlTable('users', {
+		id: int(),
+	});
+
+	const from = {
+		users,
+		schema,
+		view: mssqlView('some_view', { id: int('id') }).as(sql`SELECT * FROM [users]`),
+	};
+
+	const to = {
+		users,
+		schema,
+		view: schema.view('some_view', { id: int('id') }).with({ checkOption: true }).as(
+			sql`SELECT * FROM [users]`,
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['dbo.some_view->my_schema.some_view']);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['dbo.some_view->my_schema.some_view'] });
+
+	const st0 = [
+		`ALTER SCHEMA [my_schema] TRANSFER [some_view];`,
+		`ALTER VIEW [my_schema].[some_view] AS SELECT * FROM [users]\nWITH CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5113
+test('view with "with"', async () => {
+	const ebayStatus = mssqlTable('ebay_status', {
+		id: varchar()
+			.primaryKey()
+			.notNull()
+			.default(sql`newid()`),
+		text: varchar({ length: 50 }).notNull(),
+		disabled: bit().notNull().default(false),
+	});
+
+	const ebayStatusLog = mssqlTable('ebay_status_log', {
+		id: varchar()
+			.primaryKey()
+			.notNull()
+			.default(sql`newid()`),
+		ebayCaseID: varchar('ebay_case_id')
+			.notNull(),
+		statusID: varchar('status_id')
+			.notNull(),
+		created: varchar('created'),
+		createdBy: varchar('created_by'),
+	});
+
+	const test = mssqlView('ebay_status_latest').as((qb) => {
+		const latestStatus = qb.$with('statuslog_latest').as(
+			qb
+				.select({
+					ebayCaseID: ebayStatusLog.ebayCaseID,
+					statusID: ebayStatusLog.statusID,
+					created: ebayStatusLog.created,
+					createdBy: ebayStatusLog.createdBy,
+					row:
+						sql`(ROW_NUMBER() OVER (PARTITION BY ${ebayStatusLog.ebayCaseID} ORDER BY ${ebayStatusLog.created} DESC))`
+							.as(
+								'row',
+							),
+				})
+				.from(ebayStatusLog),
+		);
+
+		return qb
+			.with(latestStatus)
+			.select()
+			.from(latestStatus)
+			.where(eq(latestStatus.row, 1));
+	});
+
+	const from = { test, ebayStatus, ebayStatusLog };
+
+	const { sqlStatements: st } = await diff({}, from, []);
+	const { sqlStatements: pst } = await push({ db, to: from });
+
+	const st0 = [
+		`CREATE TABLE [ebay_status] (
+\t[id] varchar CONSTRAINT [ebay_status_id_default] DEFAULT (newid()),
+\t[text] varchar(50) NOT NULL,
+\t[disabled] bit NOT NULL CONSTRAINT [ebay_status_disabled_default] DEFAULT ((0)),
+\tCONSTRAINT [ebay_status_pkey] PRIMARY KEY([id])
+);\n`,
+		`CREATE TABLE [ebay_status_log] (
+\t[id] varchar CONSTRAINT [ebay_status_log_id_default] DEFAULT (newid()),
+\t[ebay_case_id] varchar NOT NULL,
+\t[status_id] varchar NOT NULL,
+\t[created] varchar,
+\t[created_by] varchar,
+\tCONSTRAINT [ebay_status_log_pkey] PRIMARY KEY([id])
+);\n`,
+		'CREATE VIEW [ebay_status_latest] AS with [statuslog_latest] as '
+		+ '(select [ebay_case_id], [status_id], [created], [created_by], (ROW_NUMBER() OVER (PARTITION BY [ebay_case_id] ORDER BY [created] DESC)) as [row] '
+		+ 'from [ebay_status_log]) select [ebay_case_id], [status_id], [created], [created_by], [row] from [statuslog_latest] where [statuslog_latest].[row] = 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4520
+test('create 2 dependent views', async () => {
+	const table1 = mssqlTable('table1', {
+		col1: int(),
+		col2: int(),
+		col3: int(),
+	});
+	const accountBalancesPMMV = mssqlView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = mssqlView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE [table1] (\n\t[col1] int,\n\t[col2] int,\n\t[col3] int\n);\n',
+		'CREATE VIEW [accountBalancesPM] AS select [col1], [col2], [col3] from [table1];',
+		'CREATE VIEW [accountBalances] AS select [col1] from [accountBalancesPM];',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/mysql-checks.test.ts b/drizzle-kit/tests/mysql-checks.test.ts
deleted file mode 100644
index 82e7a51047..0000000000
--- a/drizzle-kit/tests/mysql-checks.test.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { check, int, mysqlTable, serial, varchar } from 'drizzle-orm/mysql-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasMysql } from './schemaDiffer';
-
-test('create table with check', async (t) => {
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				type: 'serial',
-				notNull: true,
-				primaryKey: false,
-				autoincrement: true,
-			},
-			{
-				name: 'age',
-				type: 'int',
-				notNull: false,
-				primaryKey: false,
-				autoincrement: false,
-			},
-		],
-		compositePKs: [
-			'users_id;id',
-		],
-		checkConstraints: ['some_check_name;\`users\`.\`age\` > 21'],
-		compositePkName: 'users_id',
-		uniqueConstraints: [],
-		schema: undefined,
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
-\t\`id\` serial AUTO_INCREMENT NOT NULL,
-\t\`age\` int,
-\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`),
-\tCONSTRAINT \`some_check_name\` CHECK(\`users\`.\`age\` > 21)
-);\n`);
-});
-
-test('add check contraint to existing table', async (t) => {
-	const from = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_check_constraint',
-		tableName: 'users',
-		data: 'some_check_name;\`users\`.\`age\` > 21',
-		schema: '',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name\` CHECK (\`users\`.\`age\` > 21);`,
-	);
-});
-
-test('drop check contraint in existing table', async (t) => {
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const from = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'delete_check_constraint',
-		tableName: 'users',
-		schema: '',
-		constraintName: 'some_check_name',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
-	);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('new_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		data: 'new_check_name;\`users\`.\`age\` > 21',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` ADD CONSTRAINT \`new_check_name\` CHECK (\`users\`.\`age\` > 21);`,
-	);
-});
-
-test('alter check constraint', async (t) => {
-	const from = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('new_check_name', sql`${table.age} > 10`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		data: 'new_check_name;\`users\`.\`age\` > 10',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` ADD CONSTRAINT \`new_check_name\` CHECK (\`users\`.\`age\` > 10);`,
-	);
-});
-
-test('alter multiple check constraints', async (t) => {
-	const from = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-			name: varchar('name', { length: 255 }),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name_1', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name_2', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-			name: varchar('name', { length: 255 }),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name_3', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name_4', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasMysql(from, to, []);
-	expect(statements.length).toBe(4);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name_1',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		constraintName: 'some_check_name_2',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[2]).toStrictEqual({
-		data: 'some_check_name_3;\`users\`.\`age\` > 21',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-	expect(statements[3]).toStrictEqual({
-		data: "some_check_name_4;\`users\`.\`name\` != 'Alex'",
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name_1\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name_2\`;`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name_3\` CHECK (\`users\`.\`age\` > 21);`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name_4\` CHECK (\`users\`.\`name\` != \'Alex\');`,
-	);
-});
-
-test('create checks with same names', async (t) => {
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			age: int('age'),
-			name: varchar('name', { length: 255 }),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	await expect(diffTestSchemasMysql({}, to, [])).rejects.toThrowError();
-});
diff --git a/drizzle-kit/tests/mysql-generated.test.ts b/drizzle-kit/tests/mysql-generated.test.ts
deleted file mode 100644
index 3531582d0b..0000000000
--- a/drizzle-kit/tests/mysql-generated.test.ts
+++ /dev/null
@@ -1,1290 +0,0 @@
-import { SQL, sql } from 'drizzle-orm';
-import { int, mysqlTable, text } from 'drizzle-orm/mysql-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasMysql } from './schemaDiffer';
-
-test('generated as callback: add column with generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
-	]);
-});
-
-test('generated as callback: drop generated constraint as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as callback: drop generated constraint as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as callback: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as callback: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as callback: change generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-// ---
-
-test('generated as sql: add column with generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
-	]);
-});
-
-test('generated as sql: drop generated constraint as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as sql: drop generated constraint as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as sql: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as sql: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as sql: change generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-// ---
-
-test('generated as string: add column with generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`\`users\`.\`name\` || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`\`users\`.\`name\` || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
-	]);
-});
-
-test('generated as string: drop generated constraint as stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as string: drop generated constraint as virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as string: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``, {
-				mode: 'virtual',
-			}),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as string: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as string: change generated constraint', async () => {
-	const from = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``),
-		}),
-	};
-	const to = {
-		users: mysqlTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
diff --git a/drizzle-kit/tests/mysql-schemas.test.ts b/drizzle-kit/tests/mysql-schemas.test.ts
deleted file mode 100644
index 6776700e3e..0000000000
--- a/drizzle-kit/tests/mysql-schemas.test.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-import { mysqlSchema, mysqlTable } from 'drizzle-orm/mysql-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasMysql } from './schemaDiffer';
-
-// We don't manage databases(schemas) in MySQL with Drizzle Kit
-test('add schema #1', async () => {
-	const to = {
-		devSchema: mysqlSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add schema #2', async () => {
-	const from = {
-		devSchema: mysqlSchema('dev'),
-	};
-	const to = {
-		devSchema: mysqlSchema('dev'),
-		devSchema2: mysqlSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('delete schema #1', async () => {
-	const from = {
-		devSchema: mysqlSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, {}, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('delete schema #2', async () => {
-	const from = {
-		devSchema: mysqlSchema('dev'),
-		devSchema2: mysqlSchema('dev2'),
-	};
-	const to = {
-		devSchema: mysqlSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('rename schema #1', async () => {
-	const from = {
-		devSchema: mysqlSchema('dev'),
-	};
-	const to = {
-		devSchema2: mysqlSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('rename schema #2', async () => {
-	const from = {
-		devSchema: mysqlSchema('dev'),
-		devSchema1: mysqlSchema('dev1'),
-	};
-	const to = {
-		devSchema: mysqlSchema('dev'),
-		devSchema2: mysqlSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #1', async () => {
-	const dev = mysqlSchema('dev');
-	const from = {};
-	const to = {
-		dev,
-		users: dev.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #2', async () => {
-	const dev = mysqlSchema('dev');
-	const from = { dev };
-	const to = {
-		dev,
-		users: dev.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #3', async () => {
-	const dev = mysqlSchema('dev');
-	const from = { dev };
-	const to = {
-		dev,
-		usersInDev: dev.table('users', {}),
-		users: mysqlTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		uniqueConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePkName: '',
-		compositePKs: [],
-		checkConstraints: [],
-	});
-});
-
-test('remove table from schema #1', async () => {
-	const dev = mysqlSchema('dev');
-	const from = { dev, users: dev.table('users', {}) };
-	const to = {
-		dev,
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('remove table from schema #2', async () => {
-	const dev = mysqlSchema('dev');
-	const from = { dev, users: dev.table('users', {}) };
-	const to = {};
-
-	const { statements } = await diffTestSchemasMysql(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/mysql-views.test.ts b/drizzle-kit/tests/mysql-views.test.ts
deleted file mode 100644
index 39cd6c09e1..0000000000
--- a/drizzle-kit/tests/mysql-views.test.ts
+++ /dev/null
@@ -1,553 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { int, mysqlTable, mysqlView } from 'drizzle-orm/mysql-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasMysql } from './schemaDiffer';
-
-test('create view #1', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'mysql_create_view',
-		name: 'some_view',
-		algorithm: 'undefined',
-		replace: false,
-		definition: 'select `id` from `users`',
-		withCheckOption: undefined,
-		sqlSecurity: 'definer',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE ALGORITHM = undefined
-SQL SECURITY definer
-VIEW \`some_view\` AS (select \`id\` from \`users\`);`);
-});
-
-test('create view #2', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'mysql_create_view',
-		name: 'some_view',
-		algorithm: 'merge',
-		replace: false,
-		definition: 'SELECT * FROM \`users\`',
-		withCheckOption: 'cascaded',
-		sqlSecurity: 'definer',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE ALGORITHM = merge
-SQL SECURITY definer
-VIEW \`some_view\` AS (SELECT * FROM \`users\`)
-WITH cascaded CHECK OPTION;`);
-});
-
-test('create view with existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop view', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_view',
-		name: 'some_view',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP VIEW \`some_view\`;`);
-});
-
-test('drop view with existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_view',
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`RENAME TABLE \`some_view\` TO \`new_some_view\`;`);
-});
-
-test('rename view and alter meta options', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_view',
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		algorithm: 'undefined',
-		columns: {},
-		definition: 'SELECT * FROM `users`',
-		isExisting: false,
-		name: 'new_some_view',
-		sqlSecurity: 'definer',
-		type: 'alter_mysql_view',
-		withCheckOption: 'cascaded',
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`RENAME TABLE \`some_view\` TO \`new_some_view\`;`);
-	expect(sqlStatements[1]).toBe(`ALTER ALGORITHM = undefined
-SQL SECURITY definer
-VIEW \`new_some_view\` AS SELECT * FROM \`users\`
-WITH cascaded CHECK OPTION;`);
-});
-
-test('rename view with existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('add meta to view', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		algorithm: 'merge',
-		columns: {},
-		definition: 'SELECT * FROM `users`',
-		isExisting: false,
-		name: 'some_view',
-		sqlSecurity: 'definer',
-		type: 'alter_mysql_view',
-		withCheckOption: 'cascaded',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER ALGORITHM = merge
-SQL SECURITY definer
-VIEW \`some_view\` AS SELECT * FROM \`users\`
-WITH cascaded CHECK OPTION;`);
-});
-
-test('add meta to view with existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).existing(),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter meta to view', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		algorithm: 'merge',
-		columns: {},
-		definition: 'SELECT * FROM `users`',
-		isExisting: false,
-		name: 'some_view',
-		sqlSecurity: 'definer',
-		type: 'alter_mysql_view',
-		withCheckOption: 'cascaded',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER ALGORITHM = merge
-SQL SECURITY definer
-VIEW \`some_view\` AS SELECT * FROM \`users\`
-WITH cascaded CHECK OPTION;`);
-});
-
-test('alter meta to view with existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').existing(),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop meta from view', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		algorithm: 'undefined',
-		columns: {},
-		definition: 'SELECT * FROM `users`',
-		isExisting: false,
-		name: 'some_view',
-		sqlSecurity: 'definer',
-		type: 'alter_mysql_view',
-		withCheckOption: undefined,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER ALGORITHM = undefined
-SQL SECURITY definer
-VIEW \`some_view\` AS SELECT * FROM \`users\`;`);
-});
-
-test('drop meta from view existing flag', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-
-		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
-			.withCheckOption('cascaded').existing(),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter view ".as" value', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		algorithm: 'temptable',
-		definition: 'SELECT * FROM `users` WHERE `users`.`id` = 1',
-		name: 'some_view',
-		sqlSecurity: 'invoker',
-		type: 'mysql_create_view',
-		withCheckOption: 'cascaded',
-		replace: true,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE OR REPLACE ALGORITHM = temptable
-SQL SECURITY invoker
-VIEW \`some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1)
-WITH cascaded CHECK OPTION;`);
-});
-
-test('rename and alter view ".as" value', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-		type: 'rename_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		algorithm: 'temptable',
-		definition: 'SELECT * FROM `users` WHERE `users`.`id` = 1',
-		name: 'new_some_view',
-		sqlSecurity: 'invoker',
-		type: 'mysql_create_view',
-		withCheckOption: 'cascaded',
-		replace: true,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`RENAME TABLE \`some_view\` TO \`new_some_view\`;`);
-	expect(sqlStatements[1]).toBe(`CREATE OR REPLACE ALGORITHM = temptable
-SQL SECURITY invoker
-VIEW \`new_some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1)
-WITH cascaded CHECK OPTION;`);
-});
-
-test('set existing', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop existing', async () => {
-	const users = mysqlTable('users', {
-		id: int('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users: users,
-		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').existing(),
-	};
-	const to = {
-		users: users,
-		view: mysqlView('new_some_view', {}).algorithm('temptable').sqlSecurity('invoker')
-			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasMysql(from, to, [
-		'public.some_view->public.new_some_view',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'new_some_view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		algorithm: 'temptable',
-		definition: 'SELECT * FROM `users` WHERE `users`.`id` = 1',
-		name: 'new_some_view',
-		sqlSecurity: 'invoker',
-		type: 'mysql_create_view',
-		withCheckOption: 'cascaded',
-		replace: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`DROP VIEW \`new_some_view\`;`);
-	expect(sqlStatements[1]).toBe(`CREATE ALGORITHM = temptable
-SQL SECURITY invoker
-VIEW \`new_some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1)
-WITH cascaded CHECK OPTION;`);
-});
diff --git a/drizzle-kit/tests/mysql.test.ts b/drizzle-kit/tests/mysql.test.ts
deleted file mode 100644
index 23781f41d6..0000000000
--- a/drizzle-kit/tests/mysql.test.ts
+++ /dev/null
@@ -1,898 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-	foreignKey,
-	index,
-	int,
-	json,
-	mysqlEnum,
-	mysqlSchema,
-	mysqlTable,
-	primaryKey,
-	serial,
-	text,
-	unique,
-	uniqueIndex,
-	varchar,
-} from 'drizzle-orm/mysql-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasMysql } from './schemaDiffer';
-
-test('add table #1', async () => {
-	const to = {
-		users: mysqlTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-});
-
-test('add table #2', async () => {
-	const to = {
-		users: mysqlTable('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'serial',
-				autoincrement: true,
-			},
-		],
-		compositePKs: ['users_id;id'],
-		compositePkName: 'users_id',
-		uniqueConstraints: [],
-		checkConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('add table #3', async () => {
-	const to = {
-		users: mysqlTable(
-			'users',
-			{
-				id: serial('id'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({
-						name: 'users_pk',
-						columns: [t.id],
-					}),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'serial',
-				autoincrement: true,
-			},
-		],
-		compositePKs: ['users_pk;id'],
-		uniqueConstraints: [],
-		compositePkName: 'users_pk',
-		checkConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('add table #4', async () => {
-	const to = {
-		users: mysqlTable('users', {}),
-		posts: mysqlTable('posts', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'posts',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-});
-
-test('add table #5', async () => {
-	const schema = mysqlSchema('folder');
-	const from = {
-		schema,
-	};
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table #6', async () => {
-	const from = {
-		users1: mysqlTable('users1', {}),
-	};
-
-	const to = {
-		users2: mysqlTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users2',
-		schema: undefined,
-		columns: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'drop_table',
-		policies: [],
-		tableName: 'users1',
-		schema: undefined,
-	});
-});
-
-test('add table #7', async () => {
-	const from = {
-		users1: mysqlTable('users1', {}),
-	};
-
-	const to = {
-		users: mysqlTable('users', {}),
-		users2: mysqlTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'public.users1->public.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePkName: '',
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users1',
-		tableNameTo: 'users2',
-		fromSchema: undefined,
-		toSchema: undefined,
-	});
-});
-
-test('add schema + table #1', async () => {
-	const schema = mysqlSchema('folder');
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change schema with tables #1', async () => {
-	const schema = mysqlSchema('folder');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder->folder2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #1', async () => {
-	const schema = mysqlSchema('folder');
-	const from = {
-		schema,
-		users: mysqlTable('users', {}),
-	};
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'public.users->folder.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_table',
-		policies: [],
-		tableName: 'users',
-		schema: undefined,
-	});
-});
-
-test('change table schema #2', async () => {
-	const schema = mysqlSchema('folder');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema,
-		users: mysqlTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder.users->public.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		compositePKs: [],
-		checkConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('change table schema #3', async () => {
-	const schema1 = mysqlSchema('folder1');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #4', async () => {
-	const schema1 = mysqlSchema('folder1');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #5', async () => {
-	const schema1 = mysqlSchema('folder1');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema1, // remove schema
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #5', async () => {
-	const schema1 = mysqlSchema('folder1');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users2', {}), // rename and move table
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder1.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #6', async () => {
-	const schema1 = mysqlSchema('folder1');
-	const schema2 = mysqlSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // rename schema
-		users: schema2.table('users2', {}), // rename table
-	};
-
-	const { statements } = await diffTestSchemasMysql(from, to, [
-		'folder1->folder2',
-		'folder2.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table #10', async () => {
-	const to = {
-		users: mysqlTable('table', {
-			json: json('json').default({}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('{}')\n);\n",
-	);
-});
-
-test('add table #11', async () => {
-	const to = {
-		users: mysqlTable('table', {
-			json: json('json').default([]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('[]')\n);\n",
-	);
-});
-
-test('add table #12', async () => {
-	const to = {
-		users: mysqlTable('table', {
-			json: json('json').default([1, 2, 3]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('[1,2,3]')\n);\n",
-	);
-});
-
-test('add table #13', async () => {
-	const to = {
-		users: mysqlTable('table', {
-			json: json('json').default({ key: 'value' }),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` json DEFAULT (\'{"key":"value"}\')\n);\n',
-	);
-});
-
-test('add table #14', async () => {
-	const to = {
-		users: mysqlTable('table', {
-			json: json('json').default({
-				key: 'value',
-				arr: [1, 2, 3],
-			}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` json DEFAULT (\'{"key":"value","arr":[1,2,3]}\')\n);\n',
-	);
-});
-
-test('drop index', async () => {
-	const from = {
-		users: mysqlTable(
-			'table',
-			{
-				name: text('name'),
-			},
-			(t) => {
-				return {
-					idx: index('name_idx').on(t.name),
-				};
-			},
-		),
-	};
-
-	const to = {
-		users: mysqlTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe('DROP INDEX `name_idx` ON `table`;');
-});
-
-test('drop unique constraint', async () => {
-	const from = {
-		users: mysqlTable(
-			'table',
-			{
-				name: text('name'),
-			},
-			(t) => {
-				return {
-					uq: unique('name_uq').on(t.name),
-				};
-			},
-		),
-	};
-
-	const to = {
-		users: mysqlTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe('ALTER TABLE `table` DROP INDEX `name_uq`;');
-});
-
-test('add table with indexes', async () => {
-	const from = {};
-
-	const to = {
-		users: mysqlTable(
-			'users',
-			{
-				id: serial('id').primaryKey(),
-				name: text('name'),
-				email: text('email'),
-			},
-			(t) => ({
-				uniqueExpr: uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
-				indexExpr: index('indexExpr').on(sql`(lower(${t.email}))`),
-				indexExprMultiple: index('indexExprMultiple').on(
-					sql`(lower(${t.email}))`,
-					sql`(lower(${t.email}))`,
-				),
-
-				uniqueCol: uniqueIndex('uniqueCol').on(t.email),
-				indexCol: index('indexCol').on(t.email),
-				indexColMultiple: index('indexColMultiple').on(t.email, t.email),
-
-				indexColExpr: index('indexColExpr').on(
-					sql`(lower(${t.email}))`,
-					t.email,
-				),
-			}),
-		),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, []);
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE TABLE \`users\` (\n\t\`id\` serial AUTO_INCREMENT NOT NULL,\n\t\`name\` text,\n\t\`email\` text,\n\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`),\n\tCONSTRAINT \`uniqueExpr\` UNIQUE((lower(\`email\`))),\n\tCONSTRAINT \`uniqueCol\` UNIQUE(\`email\`)
-);
-`,
-		'CREATE INDEX `indexExpr` ON `users` ((lower(`email`)));',
-		'CREATE INDEX `indexExprMultiple` ON `users` ((lower(`email`)),(lower(`email`)));',
-		'CREATE INDEX `indexCol` ON `users` (`email`);',
-		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`email`);',
-		'CREATE INDEX `indexColExpr` ON `users` ((lower(`email`)),`email`);',
-	]);
-});
-
-test('varchar and text default values escape single quotes', async (t) => {
-	const schema1 = {
-		table: mysqlTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const schem2 = {
-		table: mysqlTable('table', {
-			id: serial('id').primaryKey(),
-			enum: mysqlEnum('enum', ["escape's quotes", "escape's quotes 2"]).default("escape's quotes"),
-			text: text('text').default("escape's quotes"),
-			varchar: varchar('varchar', { length: 255 }).default("escape's quotes"),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(schema1, schem2, []);
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toStrictEqual(
-		"ALTER TABLE `table` ADD `enum` enum('escape''s quotes','escape''s quotes 2') DEFAULT 'escape''s quotes';",
-	);
-	expect(sqlStatements[1]).toStrictEqual(
-		"ALTER TABLE `table` ADD `text` text DEFAULT ('escape''s quotes');",
-	);
-	expect(sqlStatements[2]).toStrictEqual(
-		"ALTER TABLE `table` ADD `varchar` varchar(255) DEFAULT 'escape''s quotes';",
-	);
-});
-
-test('composite primary key', async () => {
-	const from = {};
-	const to = {
-		table: mysqlTable('works_to_creators', {
-			workId: int('work_id').notNull(),
-			creatorId: int('creator_id').notNull(),
-			classification: text('classification').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				columns: [t.workId, t.creatorId, t.classification],
-			}),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `works_to_creators` (\n\t`work_id` int NOT NULL,\n\t`creator_id` int NOT NULL,\n\t`classification` text NOT NULL,\n\tCONSTRAINT `works_to_creators_work_id_creator_id_classification_pk` PRIMARY KEY(`work_id`,`creator_id`,`classification`)\n);\n',
-	]);
-});
-
-test('add column before creating unique constraint', async () => {
-	const from = {
-		table: mysqlTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		table: mysqlTable('table', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		}, (t) => ({
-			uq: unique('uq').on(t.name),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `table` ADD `name` text NOT NULL;',
-		'ALTER TABLE `table` ADD CONSTRAINT `uq` UNIQUE(`name`);',
-	]);
-});
-
-test('optional db aliases (snake case)', async () => {
-	const from = {};
-
-	const t1 = mysqlTable(
-		't1',
-		{
-			t1Id1: int().notNull().primaryKey(),
-			t1Col2: int().notNull(),
-			t1Col3: int().notNull(),
-			t2Ref: int().notNull().references(() => t2.t2Id),
-			t1Uni: int().notNull(),
-			t1UniIdx: int().notNull(),
-			t1Idx: int().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1_uni').on(table.t1Uni),
-			uniIdx: uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
-			idx: index('t1_idx').on(table.t1Idx),
-			fk: foreignKey({
-				columns: [table.t1Col2, table.t1Col3],
-				foreignColumns: [t3.t3Id1, t3.t3Id2],
-			}),
-		}),
-	);
-
-	const t2 = mysqlTable(
-		't2',
-		{
-			t2Id: serial().primaryKey(),
-		},
-	);
-
-	const t3 = mysqlTable(
-		't3',
-		{
-			t3Id1: int(),
-			t3Id2: int(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3Id1, table.t3Id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, [], false, 'snake_case');
-
-	const st1 = `CREATE TABLE \`t1\` (
-	\`t1_id1\` int NOT NULL,
-	\`t1_col2\` int NOT NULL,
-	\`t1_col3\` int NOT NULL,
-	\`t2_ref\` int NOT NULL,
-	\`t1_uni\` int NOT NULL,
-	\`t1_uni_idx\` int NOT NULL,
-	\`t1_idx\` int NOT NULL,
-	CONSTRAINT \`t1_t1_id1\` PRIMARY KEY(\`t1_id1\`),
-	CONSTRAINT \`t1_uni\` UNIQUE(\`t1_uni\`),
-	CONSTRAINT \`t1_uni_idx\` UNIQUE(\`t1_uni_idx\`)
-);
-`;
-
-	const st2 = `CREATE TABLE \`t2\` (
-	\`t2_id\` serial AUTO_INCREMENT NOT NULL,
-	CONSTRAINT \`t2_t2_id\` PRIMARY KEY(\`t2_id\`)
-);
-`;
-
-	const st3 = `CREATE TABLE \`t3\` (
-	\`t3_id1\` int NOT NULL,
-	\`t3_id2\` int NOT NULL,
-	CONSTRAINT \`t3_t3_id1_t3_id2_pk\` PRIMARY KEY(\`t3_id1\`,\`t3_id2\`)
-);
-`;
-
-	const st4 =
-		`ALTER TABLE \`t1\` ADD CONSTRAINT \`t1_t2_ref_t2_t2_id_fk\` FOREIGN KEY (\`t2_ref\`) REFERENCES \`t2\`(\`t2_id\`) ON DELETE no action ON UPDATE no action;`;
-
-	const st5 =
-		`ALTER TABLE \`t1\` ADD CONSTRAINT \`t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fk\` FOREIGN KEY (\`t1_col2\`,\`t1_col3\`) REFERENCES \`t3\`(\`t3_id1\`,\`t3_id2\`) ON DELETE no action ON UPDATE no action;`;
-
-	const st6 = `CREATE INDEX \`t1_idx\` ON \`t1\` (\`t1_idx\`);`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6]);
-});
-
-test('optional db aliases (camel case)', async () => {
-	const from = {};
-
-	const t1 = mysqlTable(
-		't1',
-		{
-			t1_id1: int().notNull().primaryKey(),
-			t1_col2: int().notNull(),
-			t1_col3: int().notNull(),
-			t2_ref: int().notNull().references(() => t2.t2_id),
-			t1_uni: int().notNull(),
-			t1_uni_idx: int().notNull(),
-			t1_idx: int().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1Uni').on(table.t1_uni),
-			uni_idx: uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
-			idx: index('t1Idx').on(table.t1_idx),
-			fk: foreignKey({
-				columns: [table.t1_col2, table.t1_col3],
-				foreignColumns: [t3.t3_id1, t3.t3_id2],
-			}),
-		}),
-	);
-
-	const t2 = mysqlTable(
-		't2',
-		{
-			t2_id: serial().primaryKey(),
-		},
-	);
-
-	const t3 = mysqlTable(
-		't3',
-		{
-			t3_id1: int(),
-			t3_id2: int(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3_id1, table.t3_id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemasMysql(from, to, [], false, 'camelCase');
-
-	const st1 = `CREATE TABLE \`t1\` (
-	\`t1Id1\` int NOT NULL,
-	\`t1Col2\` int NOT NULL,
-	\`t1Col3\` int NOT NULL,
-	\`t2Ref\` int NOT NULL,
-	\`t1Uni\` int NOT NULL,
-	\`t1UniIdx\` int NOT NULL,
-	\`t1Idx\` int NOT NULL,
-	CONSTRAINT \`t1_t1Id1\` PRIMARY KEY(\`t1Id1\`),
-	CONSTRAINT \`t1Uni\` UNIQUE(\`t1Uni\`),
-	CONSTRAINT \`t1UniIdx\` UNIQUE(\`t1UniIdx\`)
-);
-`;
-
-	const st2 = `CREATE TABLE \`t2\` (
-	\`t2Id\` serial AUTO_INCREMENT NOT NULL,
-	CONSTRAINT \`t2_t2Id\` PRIMARY KEY(\`t2Id\`)
-);
-`;
-
-	const st3 = `CREATE TABLE \`t3\` (
-	\`t3Id1\` int NOT NULL,
-	\`t3Id2\` int NOT NULL,
-	CONSTRAINT \`t3_t3Id1_t3Id2_pk\` PRIMARY KEY(\`t3Id1\`,\`t3Id2\`)
-);
-`;
-
-	const st4 =
-		`ALTER TABLE \`t1\` ADD CONSTRAINT \`t1_t2Ref_t2_t2Id_fk\` FOREIGN KEY (\`t2Ref\`) REFERENCES \`t2\`(\`t2Id\`) ON DELETE no action ON UPDATE no action;`;
-
-	const st5 =
-		`ALTER TABLE \`t1\` ADD CONSTRAINT \`t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fk\` FOREIGN KEY (\`t1Col2\`,\`t1Col3\`) REFERENCES \`t3\`(\`t3Id1\`,\`t3Id2\`) ON DELETE no action ON UPDATE no action;`;
-
-	const st6 = `CREATE INDEX \`t1Idx\` ON \`t1\` (\`t1Idx\`);`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6]);
-});
-
-test('add table with ts enum', async () => {
-	enum Test {
-		value = 'value',
-	}
-	const to = {
-		users: mysqlTable('users', {
-			enum: mysqlEnum(Test),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasMysql({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [{
-			autoincrement: false,
-			name: 'enum',
-			notNull: false,
-			primaryKey: false,
-			type: "enum('value')",
-		}],
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-});
diff --git a/drizzle-kit/tests/mysql/commutativity.integration.test.ts b/drizzle-kit/tests/mysql/commutativity.integration.test.ts
new file mode 100644
index 0000000000..7a9dedf974
--- /dev/null
+++ b/drizzle-kit/tests/mysql/commutativity.integration.test.ts
@@ -0,0 +1,335 @@
+import { sql } from 'drizzle-orm';
+import { check, index, mysqlTable, primaryKey, unique } from 'drizzle-orm/mysql-core';
+import { describe, expect, test } from 'vitest';
+import { conflictsFromSchema } from './mocks';
+
+describe('conflict rule coverage (statement pairs)', () => {
+	test('column: create vs drop (same-resource-different-op)', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+				d: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('column: alter vs alter (same-resource-same-op)', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }).notNull(),
+			})),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.int(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('table drop vs child index', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			}), (table) => [index('test_idx').on(table.c)]),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('table drop vs new column on same table', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+				d: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('index: create vs create on different tables is commutative', async () => {
+		const parent = {
+			orders: mysqlTable('orders', (t) => ({
+				customerId: t.varchar({ length: 255 }),
+			})),
+			invoices: mysqlTable('invoices', (t) => ({
+				accountId: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {
+			orders: mysqlTable('orders', (t) => ({
+				customerId: t.varchar({ length: 255 }),
+			}), (table) => [index('orders_customer_idx').on(table.customerId)]),
+			invoices: mysqlTable('invoices', (t) => ({
+				accountId: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child2 = {
+			orders: mysqlTable('orders', (t) => ({
+				customerId: t.varchar({ length: 255 }),
+			})),
+			invoices: mysqlTable('invoices', (t) => ({
+				accountId: t.varchar({ length: 255 }),
+			}), (table) => [index('invoices_account_idx').on(table.accountId)]),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('index: create vs create on same table with different names is commutative', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+				d: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+				d: t.varchar({ length: 255 }),
+			}), (table) => [index('t_c_idx').on(table.c)]),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+				d: t.varchar({ length: 255 }),
+			}), (table) => [index('t_d_idx').on(table.d)]),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('pk: alter vs drop', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				id: t.int().primaryKey(),
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				id: t.int(),
+				c: t.varchar({ length: 255 }),
+			}), (table) => [primaryKey({ columns: [table.id, table.c] })]),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				id: t.int(),
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('unique: create vs drop on different indexes is commutative', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }).unique(),
+			})),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }).unique(),
+				d: t.varchar({ length: 255 }).unique(),
+			})),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.varchar({ length: 255 }),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('fk: recreate vs drop', async () => {
+		const p = mysqlTable('p', (t) => ({
+			id: t.int().primaryKey(),
+		}));
+
+		const parent = {
+			p,
+			t: mysqlTable('t', (t) => ({
+				id: t.int().primaryKey(),
+				pId: t.int().references(() => p.id),
+			})),
+		};
+
+		const child1 = {
+			p,
+			t: mysqlTable('t', (t) => ({
+				id: t.int().primaryKey(),
+				pId: t.int().references(() => p.id, { onDelete: 'cascade' }),
+			})),
+		};
+
+		const child2 = {
+			p,
+			t: mysqlTable('t', (t) => ({
+				id: t.int().primaryKey(),
+				pId: t.int(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('check: alter vs drop', async () => {
+		const parent = {
+			t: mysqlTable('t', (t) => ({
+				c: t.int(),
+			}), (table) => [check('chk', sql`${table.c} > 0`)]),
+		};
+
+		const child1 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.int(),
+			}), (table) => [check('chk', sql`${table.c} > 5`)]),
+		};
+
+		const child2 = {
+			t: mysqlTable('t', (t) => ({
+				c: t.int(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		// The diff engine doesn't produce statements for check constraint alters
+		// (checks use createdrop mode), so no conflict is detected here.
+		// TODO: handle check alter vs drop once the diff engine supports check alters
+		expect(conflicts).toBeUndefined();
+	});
+
+	test(
+		'explainConflicts returns reason for table drop vs column alter',
+		async () => {
+			const parent = {
+				c: mysqlTable('t', (t) => ({
+					c: t.varchar({ length: 255 }),
+				})),
+			};
+
+			const child1 = {};
+			const child2 = {
+				c: mysqlTable('t', (t) => ({
+					c: t.varchar({ length: 255 }).notNull(),
+				})),
+			};
+
+			const conflicts = await conflictsFromSchema({
+				parent: { id: '1', schema: parent },
+				child1: { id: '2', prevId: '1', schema: child1 },
+				child2: { id: '3', prevId: '1', schema: child2 },
+			});
+
+			expect(conflicts).not.toBeUndefined();
+			expect(conflicts?.leftStatement.type).toBe('alter_column');
+			expect(conflicts?.rightStatement.type).toBe('drop_table');
+		},
+	);
+});
diff --git a/drizzle-kit/tests/mysql/commutativity.test.ts b/drizzle-kit/tests/mysql/commutativity.test.ts
new file mode 100644
index 0000000000..c6a8a1e6e0
--- /dev/null
+++ b/drizzle-kit/tests/mysql/commutativity.test.ts
@@ -0,0 +1,1049 @@
+import { mysqlCommutativity } from 'src/dialects/mysql/commutativity';
+import { createDDL } from 'src/dialects/mysql/ddl';
+import type { MysqlSnapshot } from 'src/dialects/mysql/snapshot';
+import { describe, expect, test } from 'vitest';
+
+const baseId = '00000000-0000-0000-0000-000000000000';
+
+function makeSnapshot(id: string, prevIds: string[], ddlEntities: any[] = []): MysqlSnapshot {
+	return {
+		version: '6',
+		dialect: 'mysql',
+		id,
+		prevIds,
+		ddl: ddlEntities,
+		renames: [],
+	} as any;
+}
+
+function writeTempSnapshot(dir: string, tag: string, snap: MysqlSnapshot) {
+	const fs = require('fs');
+	const path = require('path');
+	const folder = path.join(dir, tag);
+	fs.mkdirSync(folder, { recursive: true });
+	fs.writeFileSync(path.join(folder, 'snapshot.json'), JSON.stringify(snap, null, 2));
+	return path.join(folder, 'snapshot.json');
+}
+
+const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+function mkTmp(): { tmp: string; fs: any; path: any; os: any } {
+	const fs = require('fs');
+	const path = require('path');
+	const os = require('os');
+	const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'dk-comm-int-mysql-'));
+	return { tmp, fs, path, os } as any;
+}
+
+describe('commutativity integration (mysql)', () => {
+	test(
+		'Parent not empty: detects conflict when first migration of branch A has a conflict with the last migration of branch B',
+		async () => {
+			const parentDDL = createDDL();
+			parentDDL.tables.push({ name: 'users' });
+			parentDDL.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const parent = makeSnapshot('p1', [baseId], parentDDL.entities.list());
+
+			const A = createDDL();
+			A.tables.push({ name: 'users' });
+			A.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: true,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+			const A2 = createDDL();
+			A2.tables.push({ name: 'users' });
+			A2.columns.push({
+				table: 'users',
+				name: 'email2',
+				type: 'varchar(255)',
+				notNull: true,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafA2 = makeSnapshot('a2', ['a1'], A2.entities.list());
+
+			const B = createDDL();
+			B.tables.push({ name: 'users' });
+			B.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			B.tables.push({ name: 'posts' });
+			B.columns.push({
+				table: 'posts',
+				name: 'content',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+			const B2 = createDDL();
+			B2.tables.push({ name: 'users' });
+			B2.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			B2.tables.push({ name: 'posts' });
+			B2.columns.push({
+				table: 'posts',
+				name: 'content',
+				type: 'varchar(255)',
+				notNull: true,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafB2 = makeSnapshot('b2', ['b1'], B2.entities.list());
+
+			const B3 = createDDL();
+			B3.tables.push({ name: 'posts' });
+			B3.columns.push({
+				table: 'posts',
+				name: 'content',
+				type: 'varchar(255)',
+				notNull: true,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafB3 = makeSnapshot('b3', ['b2'], B3.entities.list());
+
+			const os = require('os');
+			const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-mysql-'));
+			const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+			const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+			const a2Path = writeTempSnapshot(tmp, '001_leafA2', leafA2);
+			const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+			const b2Path = writeTempSnapshot(tmp, '002_leafB2', leafB2);
+			const b3Path = writeTempSnapshot(tmp, '002_leafB3', leafB3);
+
+			const report = await mysqlCommutativity.detectNonCommutative([pPath, aPath, bPath, b2Path, b3Path, a2Path]);
+			expect(report.conflicts.length).toBeGreaterThan(0);
+			expect(report.conflicts[0].parentId).toBe('p1');
+		},
+	);
+
+	test('Parent empty: detects conflict when last migration of branch A has a conflict with a first migration of branch B', async () => {
+		const parent = makeSnapshot('p1', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ name: 'users' });
+		A.columns.push({
+			table: 'users',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const A2 = createDDL();
+		A2.tables.push({ name: 'posts' });
+		A2.columns.push({
+			table: 'posts',
+			name: 'description',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafA2 = makeSnapshot('a2', ['a1'], A2.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ name: 'posts' });
+		B.columns.push({
+			table: 'users',
+			name: 'content',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+		const B2 = createDDL();
+		B2.tables.push({ name: 'posts' });
+		B2.columns.push({
+			table: 'users',
+			name: 'content',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafB2 = makeSnapshot('b2', ['b1'], B2.entities.list());
+
+		const B3 = createDDL();
+		B3.tables.push({ name: 'posts' });
+		B3.columns.push({
+			table: 'users',
+			name: 'content',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		B3.tables.push({ name: 'media' });
+		B3.columns.push({
+			table: 'media',
+			name: 'url',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafB3 = makeSnapshot('b3', ['b2'], B3.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-mysql-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const a2Path = writeTempSnapshot(tmp, '002_leafA2', leafA2);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+		const b2Path = writeTempSnapshot(tmp, '003_leafB2', leafB2);
+		const b3Path = writeTempSnapshot(tmp, '004_leafB3', leafB3);
+
+		const report = await mysqlCommutativity.detectNonCommutative([pPath, aPath, a2Path, bPath, b2Path, b3Path]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test(
+		'detects conflict when drop table in one branch and add column in other',
+		async () => {
+			const parentDDL = createDDL();
+			parentDDL.tables.push({ name: 'users' });
+			parentDDL.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const parent = makeSnapshot('p1', [baseId], parentDDL.entities.list());
+
+			const A = createDDL();
+			A.tables.push({ name: 'users' });
+			A.columns.push({
+				table: 'users',
+				name: 'email',
+				type: 'varchar(255)',
+				notNull: true,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any);
+			const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+			const leafB = makeSnapshot('b1', ['p1'], createDDL().entities.list());
+
+			const os = require('os');
+			const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-mysql-'));
+			const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+			const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+			const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+			const report = await mysqlCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+			expect(report.conflicts.length).toBeGreaterThan(0);
+			expect(report.conflicts[0].parentId).toBe('p1');
+		},
+	);
+
+	test('detects conflict when both branches alter same column', async () => {
+		const parent = makeSnapshot('p1', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ name: 'users' });
+		A.columns.push({
+			table: 'users',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ name: 'users' });
+		B.columns.push({
+			table: 'users',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-mysql-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+		const report = await mysqlCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('no conflict when branches touch different tables', async () => {
+		const parent = makeSnapshot('p2', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ name: 'users' });
+		const leafA = makeSnapshot('a2', ['p2'], A.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ name: 'posts' });
+		const leafB = makeSnapshot('b2', ['p2'], B.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-mysql-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+		const report = await mysqlCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+		expect(report.conflicts.length).toBe(0);
+	});
+
+	test('column conflict: both branches change same column', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 'users' });
+		const p = makeSnapshot('p_col', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ name: 'users' });
+		a.columns.push({
+			table: 'users',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ name: 'users' });
+		b.columns.push({
+			table: 'users',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '000_p_col', p),
+			writeTempSnapshot(tmp, '001_a_col', makeSnapshot('a_col', ['p_col'], a.entities.list())),
+			writeTempSnapshot(tmp, '002_b_col', makeSnapshot('b_col', ['p_col'], b.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('table drop vs child column alter', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 't1' });
+		parent.columns.push({
+			table: 't1',
+			name: 'c1',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		const p = makeSnapshot('p_drop', [ORIGIN], parent.entities.list());
+
+		const a = createDDL(); // dropping table in branch A (no t1)
+		const b = createDDL();
+		b.tables.push({ name: 't1' });
+		b.columns.push({
+			table: 't1',
+			name: 'c1',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '010_p_drop', p),
+			writeTempSnapshot(tmp, '011_a_drop', makeSnapshot('a_drop', ['p_drop'], a.entities.list())),
+			writeTempSnapshot(tmp, '012_b_drop', makeSnapshot('b_drop', ['p_drop'], b.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBe(1);
+		expect(report.conflicts[0].branchA.chain[report.conflicts[0].branchA.chain.length - 1].id).toStrictEqual('a_drop');
+		expect(report.conflicts[0].branchB.chain[report.conflicts[0].branchB.chain.length - 1].id).toStrictEqual('b_drop');
+	});
+
+	test('create indexes on different tables do not conflict', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 'orders' });
+		parent.tables.push({ name: 'invoices' });
+		parent.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'invoices',
+				name: 'account_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		const p = makeSnapshot('p_idx', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ name: 'orders' });
+		a.tables.push({ name: 'invoices' });
+		a.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'invoices',
+				name: 'account_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		a.indexes.push({
+			table: 'orders',
+			nameExplicit: true,
+			name: 'orders_customer_id_idx',
+			columns: [{ value: 'customer_id', isExpression: false }],
+			isUnique: false,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ name: 'orders' });
+		b.tables.push({ name: 'invoices' });
+		b.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'invoices',
+				name: 'account_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		b.indexes.push({
+			table: 'invoices',
+			nameExplicit: true,
+			name: 'invoices_account_id_idx',
+			columns: [{ value: 'account_id', isExpression: false }],
+			isUnique: false,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '020_p_idx', p),
+			writeTempSnapshot(tmp, '021_a_idx', makeSnapshot('a_idx', ['p_idx'], a.entities.list())),
+			writeTempSnapshot(tmp, '022_b_idx', makeSnapshot('b_idx', ['p_idx'], b.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+	});
+
+	test('create indexes with different names on the same table do not conflict', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 'orders' });
+		parent.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'orders',
+				name: 'status',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		const p = makeSnapshot('p_idx_same_table', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ name: 'orders' });
+		a.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'orders',
+				name: 'status',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		a.indexes.push({
+			table: 'orders',
+			nameExplicit: true,
+			name: 'orders_customer_id_idx',
+			columns: [{ value: 'customer_id', isExpression: false }],
+			isUnique: false,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ name: 'orders' });
+		b.columns.push(
+			{
+				table: 'orders',
+				name: 'customer_id',
+				type: 'int',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+			{
+				table: 'orders',
+				name: 'status',
+				type: 'varchar(255)',
+				notNull: false,
+				autoIncrement: false,
+				default: null,
+				onUpdateNow: false,
+				onUpdateNowFsp: null,
+				charSet: null,
+				collation: null,
+				generated: null,
+			} as any,
+		);
+		b.indexes.push({
+			table: 'orders',
+			nameExplicit: true,
+			name: 'orders_status_idx',
+			columns: [{ value: 'status', isExpression: false }],
+			isUnique: false,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '030_p_idx_same_table', p),
+			writeTempSnapshot(
+				tmp,
+				'031_a_idx_same_table',
+				makeSnapshot('a_idx_same_table', ['p_idx_same_table'], a.entities.list()),
+			),
+			writeTempSnapshot(
+				tmp,
+				'032_b_idx_same_table',
+				makeSnapshot('b_idx_same_table', ['p_idx_same_table'], b.entities.list()),
+			),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+	});
+
+	test('unique constraint same name on same table', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 't2' });
+		const p = makeSnapshot('p_uq', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ name: 't2' });
+		a.indexes.push({
+			table: 't2',
+			nameExplicit: true,
+			name: 't2_uq',
+			columns: [{ value: 'c', isExpression: false }],
+			isUnique: true,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ name: 't2' });
+		b.indexes.push({
+			table: 't2',
+			nameExplicit: true,
+			name: 't2_uq',
+			columns: [{ value: 'c', isExpression: false }],
+			isUnique: true,
+			using: null,
+			algorithm: null,
+			lock: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '020_p_uq', p),
+			writeTempSnapshot(tmp, '021_a_uq', makeSnapshot('a_uq', ['p_uq'], a.entities.list())),
+			writeTempSnapshot(tmp, '022_b_uq', makeSnapshot('b_uq', ['p_uq'], b.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('view: same name in both branches', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const p = makeSnapshot('p_view', [ORIGIN], createDDL().entities.list());
+		const a = createDDL();
+		a.views.push({
+			name: 'v1',
+			definition: 'select 1',
+			algorithm: 'undefined',
+			sqlSecurity: 'definer',
+			withCheckOption: null,
+		} as any);
+
+		const b = createDDL();
+		b.views.push({
+			name: 'v1',
+			definition: 'select 1',
+			algorithm: 'undefined',
+			sqlSecurity: 'definer',
+			withCheckOption: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '030_p_view', p),
+			writeTempSnapshot(tmp, '031_a_view', makeSnapshot('a_view', ['p_view'], a.entities.list())),
+			writeTempSnapshot(tmp, '032_b_view', makeSnapshot('b_view', ['p_view'], b.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('three-way branch: A,B,C from same parent', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ name: 't' });
+		const p = makeSnapshot('p_three', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ name: 't' });
+		a.columns.push({
+			table: 't',
+			name: 'a',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ name: 't' });
+		b.columns.push({
+			table: 't',
+			name: 'a',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		const c = createDDL();
+		c.tables.push({ name: 't' });
+		c.columns.push({
+			table: 't',
+			name: 'b',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '100_p_three', p),
+			writeTempSnapshot(tmp, '101_a_three', makeSnapshot('a_three', ['p_three'], a.entities.list())),
+			writeTempSnapshot(tmp, '102_b_three', makeSnapshot('b_three', ['p_three'], b.entities.list())),
+			writeTempSnapshot(tmp, '103_c_three', makeSnapshot('c_three', ['p_three'], c.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		// At least A vs B should conflict; C may or may not depending on overlap
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('nested branching: parent -> A -> A1 and parent -> B', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const root = createDDL();
+		root.tables.push({ name: 't' });
+		const p = makeSnapshot('p_nested', [ORIGIN], root.entities.list());
+
+		const A = createDDL();
+		A.tables.push({ name: 't' });
+		A.columns.push({
+			table: 't',
+			name: 'c',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		const A1 = createDDL();
+		A1.tables.push({ name: 't' });
+		A1.columns.push({
+			table: 't',
+			name: 'c',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		const B = createDDL();
+		B.tables.push({ name: 't' });
+		B.columns.push({
+			table: 't',
+			name: 'd',
+			type: 'varchar(255)',
+			notNull: false,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '110_p_nested', p),
+			writeTempSnapshot(tmp, '111_A', makeSnapshot('A', ['p_nested'], A.entities.list())),
+			writeTempSnapshot(tmp, '112_A1', makeSnapshot('A1', ['A'], A1.entities.list())),
+			writeTempSnapshot(tmp, '113_B', makeSnapshot('B', ['p_nested'], B.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThanOrEqual(0);
+	});
+
+	test('complex mixed: multiple tables and views diverging', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const base = createDDL();
+		base.tables.push({ name: 'u' });
+		base.tables.push({ name: 'p' });
+		const p = makeSnapshot('p_mix', [ORIGIN], base.entities.list());
+
+		// Branch X: alter u.email, create view v_users
+		const X = createDDL();
+		X.tables.push({ name: 'u' });
+		X.columns.push({
+			table: 'u',
+			name: 'email',
+			type: 'varchar(255)',
+			notNull: true,
+			autoIncrement: false,
+			default: null,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			charSet: null,
+			collation: null,
+			generated: null,
+		} as any);
+		X.views.push({
+			name: 'v_users',
+			definition: 'select * from u',
+			algorithm: 'undefined',
+			sqlSecurity: 'definer',
+			withCheckOption: null,
+		} as any);
+
+		// Branch Y: drop table u (conflicts with X's column/view touching u)
+		const Y = createDDL();
+		Y.tables.push({ name: 'p' });
+		// no table u -> implies drop vs X touching u
+
+		files.push(
+			writeTempSnapshot(tmp, '120_p_mix', p),
+			writeTempSnapshot(tmp, '121_X', makeSnapshot('X', ['p_mix'], X.entities.list())),
+			writeTempSnapshot(tmp, '122_Y', makeSnapshot('Y', ['p_mix'], Y.entities.list())),
+		);
+
+		const report = await mysqlCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+});
diff --git a/drizzle-kit/tests/mysql/constraints.test.ts b/drizzle-kit/tests/mysql/constraints.test.ts
new file mode 100644
index 0000000000..d09292c35a
--- /dev/null
+++ b/drizzle-kit/tests/mysql/constraints.test.ts
@@ -0,0 +1,1347 @@
+import { desc, sql } from 'drizzle-orm';
+import {
+	AnyMySqlColumn,
+	bigint,
+	binary,
+	blob,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	foreignKey,
+	index,
+	int,
+	json,
+	longblob,
+	longtext,
+	mediumblob,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyblob,
+	tinyint,
+	tinytext,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { suggestions } from 'src/cli/commands/push-mysql';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// TODO: add simple .unique(), etc. To discuss with @OleksiiKH0240
+test('#1', async () => {
+	const users3 = mysqlTable('users3', {
+		c1: varchar({ length: 100 }),
+	}, (t) => [
+		unique().on(t.c1),
+	]);
+
+	const users4 = mysqlTable('users4', {
+		c1: varchar({ length: 100 }).unique().references(() => users3.c1),
+		c2: varchar({ length: 100 }).references((): AnyMySqlColumn => users4.c1),
+	});
+	const to = {
+		users3,
+		users4,
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users3` (\n\t`c1` varchar(100),\n\tCONSTRAINT `c1_unique` UNIQUE INDEX(`c1`)\n);\n',
+		'CREATE TABLE `users4` (\n\t`c1` varchar(100),\n\t`c2` varchar(100),\n\tCONSTRAINT `c1_unique` UNIQUE INDEX(`c1`)\n);\n',
+		'ALTER TABLE `users4` ADD CONSTRAINT `users4_c1_users3_c1_fkey` FOREIGN KEY (`c1`) REFERENCES `users3`(`c1`);',
+		'ALTER TABLE `users4` ADD CONSTRAINT `users4_c2_users4_c1_fkey` FOREIGN KEY (`c2`) REFERENCES `users4`(`c1`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// TODO: implement geometry types
+test('unique constraint errors #1', async () => {
+	const to = {
+		table: mysqlTable('table', {
+			column1: text().unique(),
+			column2: tinytext().unique(),
+			column3: mediumtext().unique(),
+			column4: longtext().unique(),
+			column5: blob().unique(),
+			column6: tinyblob().unique(),
+			column7: mediumblob().unique(),
+			column8: longblob().unique(),
+			column9: json().unique(),
+			column10: varchar({ length: 769 }).unique(), // 768 max depends on mysql version and engine (4 bytes per character for last version)
+			// column11: geometry().unique(),
+		}),
+	};
+
+	const { sqlStatements: st, ddl1Err, ddl2Err, mappedErrors1, mappedErrors2 } = await diff({}, to, []);
+
+	expect(ddl1Err).toStrictEqual([]);
+	expect(ddl2Err).toStrictEqual([
+		{
+			columns: ['column1'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column2'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column3'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column4'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column5'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column6'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column7'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+		{
+			columns: ['column8'],
+			table: 'table',
+			type: 'column_unsupported_unique',
+		},
+	]);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('unique constraint errors #2', async () => {
+	const to = {
+		table: mysqlTable('table', {
+			column1: text(),
+			column2: tinytext(),
+			column3: mediumtext(),
+			column4: longtext(),
+			column5: blob(),
+			column6: tinyblob(),
+			column7: mediumblob(),
+			column8: longblob(),
+			column9: json(),
+			column10: varchar({ length: 769 }), // 768 max depends on mysql version and engine (4 bytes per character for last version)
+			// column11: geometry(),
+		}, (table) => [
+			unique().on(table.column1),
+			unique().on(table.column2),
+			unique().on(table.column3),
+			unique().on(table.column4),
+			unique().on(table.column5),
+			unique().on(table.column6),
+			unique().on(table.column7),
+			unique().on(table.column8),
+			unique().on(table.column9),
+			unique().on(table.column10),
+			// unique().on(table.column11),
+		]),
+	};
+
+	const { sqlStatements: st, ddl1Err, ddl2Err, mappedErrors1, mappedErrors2 } = await diff({}, to, []);
+
+	expect(ddl1Err).toStrictEqual([]);
+	expect(ddl2Err).toStrictEqual(
+		[
+			{
+				columns: ['column1'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column2'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column3'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column4'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column5'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column6'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column7'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+			{
+				columns: ['column8'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+		],
+	);
+	expect(mappedErrors1).toStrictEqual([]);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('unique constraint errors #3', async () => {
+	const to = {
+		table: mysqlTable('table', {
+			column1: text(),
+			column2: tinytext(),
+			column3: mediumtext(),
+			column4: longtext(),
+			column5: blob(),
+			column6: tinyblob(),
+			column7: mediumblob(),
+			column8: longblob(),
+			column9: json(),
+			column10: varchar({ length: 769 }), // 768 max depends on mysql version and engine (4 bytes per character for last version)
+			// column11: geometry(),
+		}, (table) => [
+			unique().on(
+				table.column1,
+				table.column2,
+				table.column3,
+				table.column4,
+				table.column5,
+				table.column6,
+				table.column7,
+				table.column8,
+				table.column9,
+				table.column10,
+			),
+		]),
+	};
+
+	const { sqlStatements: st, ddl1Err, ddl2Err, mappedErrors1, mappedErrors2 } = await diff({}, to, []);
+	expect(ddl1Err).toStrictEqual([]);
+	expect(ddl2Err).toStrictEqual(
+		[
+			{
+				columns: ['column1', 'column2', 'column3', 'column4', 'column5', 'column6', 'column7', 'column8'],
+				table: 'table',
+				type: 'column_unsupported_unique',
+			},
+		],
+	);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('unique, fk constraints order #1', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int,\n\t`column2` varchar(256)\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\t`column2` varchar(256)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table1 = mysqlTable('table1', {
+		column1: int(),
+		column2: varchar({ length: 256 }).unique(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+		column2: varchar({ length: 256 }).references(() => table1.column2),
+	});
+	const schema2 = { table1, table2 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'CREATE UNIQUE INDEX `column2_unique` ON `table1` (`column2`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column2_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column2`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('unique, fk constraints order #2', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int,\n\t`column2` varchar(256)\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\t`column2` varchar(256)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table1 = mysqlTable('table1', {
+		column1: int(),
+		column2: varchar({ length: 256 }),
+	}, (table) => [
+		unique().on(table.column1, table.column2),
+	]);
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+		column2: varchar({ length: 256 }),
+	}, (table) => [
+		foreignKey({
+			columns: [table.column1, table.column2],
+			foreignColumns: [table1.column1, table1.column2],
+			name: 'custom_fk', // TODO: revise: should there be any migrations if user change schema to omit name of constraint?
+		}),
+	]);
+	const schema2 = { table1, table2 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'CREATE UNIQUE INDEX `column1_column2_unique` ON `table1` (`column1`,`column2`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `custom_fk` FOREIGN KEY (`column1`,`column2`) REFERENCES `table1`(`column1`,`column2`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2236
+// https://github.com/drizzle-team/drizzle-orm/issues/3329
+test('add column before creating unique constraint', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}, (table) => [
+			unique().on(table.column1, table.column2),
+		]),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: varchar({ length: 256 }).unique(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE `table1` ADD `column2` varchar(256);',
+		'ALTER TABLE `table2` ADD `column2` varchar(256);',
+		'CREATE UNIQUE INDEX `column2_unique` ON `table2` (`column2`);',
+		'CREATE UNIQUE INDEX `column1_column2_unique` ON `table1` (`column1`,`column2`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('primary key, fk constraint order #1', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: int(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\t`column2` int\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+		column2: int().references(() => table1.column1),
+	});
+	const schema2 = { table1, table2 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE `table1` ADD PRIMARY KEY (`column1`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('primary key, fk constraint order #2', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: varchar({ length: 256 }),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: int(),
+			column3: varchar({ length: 256 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int,\n\t`column2` varchar(256)\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\t`column2` int,\n\t`column3` varchar(256)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table1 = mysqlTable('table1', {
+		column1: int(),
+		column2: varchar({ length: 256 }),
+	}, (table) => [
+		primaryKey({ columns: [table.column1, table.column2] }),
+	]);
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+		column2: int(),
+		column3: varchar({ length: 256 }),
+	}, (table) => [
+		foreignKey({
+			columns: [table.column2, table.column3],
+			foreignColumns: [table1.column1, table1.column2],
+			name: 'custom_fk',
+		}),
+	]);
+	const schema2 = { table1, table2 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE `table1` ADD PRIMARY KEY (`column1`,`column2`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `custom_fk` FOREIGN KEY (`column2`,`column3`) REFERENCES `table1`(`column1`,`column2`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test('index with sort', async () => {
+	const to = {
+		table: mysqlTable('table', {
+			column1: int(),
+			column2: int(),
+			column3: int(),
+		}, (table) => ({
+			tableCompositeIdx: index('table_composite_idx').on(
+				table.column1,
+				table.column2,
+				desc(table.column3), // Attempting to sort by column3 DESC
+			),
+		})),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt = [
+		'CREATE TABLE `table` (\n\t`column1` int,\n\t`column2` int,\n\t`column3` int\n);\n',
+		'CREATE INDEX `table_composite_idx` ON `table` (`column1`,`column2`,`column3` desc);',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3255
+test('index #1', async () => {
+	const table1 = mysqlTable('table1', {
+		col1: int(),
+		col2: int(),
+	}, () => [
+		index1,
+		index2,
+		index3,
+		index4,
+		index5,
+		index6,
+	]);
+
+	const index1 = uniqueIndex('index1').on(table1.col1);
+	const index2 = uniqueIndex('index2').on(table1.col1, table1.col2);
+	const index3 = index('index3').on(table1.col1);
+	const index4 = index('index4').on(table1.col1, table1.col2);
+	const index5 = index('index5').on(sql`${table1.col1} asc`);
+	const index6 = index('index6').on(sql`${table1.col1} asc`, sql`${table1.col2} desc`);
+
+	const schema1 = { table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n'
+		+ '\t`col1` int,\n'
+		+ '\t`col2` int,\n'
+		+ '\tCONSTRAINT `index1` UNIQUE INDEX(`col1`),\n'
+		+ '\tCONSTRAINT `index2` UNIQUE INDEX(`col1`,`col2`)\n'
+		+ ');\n',
+		'CREATE INDEX `index3` ON `table1` (`col1`);',
+		'CREATE INDEX `index4` ON `table1` (`col1`,`col2`);',
+		'CREATE INDEX `index5` ON `table1` (`col1` asc);',
+		'CREATE INDEX `index6` ON `table1` (`col1` asc,`col2` desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4962
+test('functional index #1', async () => {
+	const table1 = mysqlTable('table1', {
+		id: varchar('id', { length: 21 }).primaryKey().notNull(),
+		otherId: varchar('other_id', { length: 21 }),
+		url: varchar('url', { length: 2048 }),
+	}, (table) => [
+		uniqueIndex('uniqueUrl').on(
+			table.otherId,
+			sql`${table.url}(747)`,
+		),
+	]);
+	const schema1 = { table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n'
+		+ '\t`id` varchar(21) PRIMARY KEY,\n'
+		+ '\t`other_id` varchar(21),\n'
+		+ '\t`url` varchar(2048),\n'
+		+ '\tCONSTRAINT `uniqueUrl` UNIQUE INDEX(`other_id`,`url`(747))\n'
+		+ ');\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4221
+test('fk on char column', async () => {
+	function column1() {
+		return char('column1', { length: 24 }).primaryKey().$defaultFn(() => '1');
+	}
+	const table1 = mysqlTable(
+		'table1',
+		{
+			column1: column1(),
+		},
+	);
+	const table2 = mysqlTable(
+		'table2',
+		{
+			column1: column1(),
+			column2: char('column2', { length: 24 }).references(() => table1.column1).notNull(),
+		},
+	);
+	const to = { table1, table2 };
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt: string[] = [
+		'CREATE TABLE `table1` (\n\t`column1` char(24) PRIMARY KEY\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` char(24) PRIMARY KEY,\n\t`column2` char(24) NOT NULL\n);\n',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`);',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/486
+// https://github.com/drizzle-team/drizzle-orm/issues/3244
+test('fk name is too long', async () => {
+	const table1 = mysqlTable(
+		'table1_loooooong',
+		{
+			column1: int('column1_looooong').primaryKey(),
+		},
+	);
+	const table2 = mysqlTable(
+		'table2_loooooong',
+		{
+			column1: int('column1_looooong').references(() => table1.column1).notNull(),
+		},
+	);
+	const to = { table1, table2 };
+
+	const { sqlStatements: st, next: n } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt: string[] = [
+		'CREATE TABLE `table1_loooooong` (\n\t`column1_looooong` int PRIMARY KEY\n);\n',
+		'CREATE TABLE `table2_loooooong` (\n\t`column1_looooong` int NOT NULL\n);\n',
+		'ALTER TABLE `table2_loooooong` ADD CONSTRAINT `table2_loooooong_KObGFnvgHDVg_fkey` FOREIGN KEY (`column1_looooong`) REFERENCES `table1_loooooong`(`column1_looooong`);',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+
+	const { sqlStatements: st1 } = await diff(n, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to });
+
+	const expectedSt1: string[] = [];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456#issuecomment-3076042688
+test('fk multistep #1', async () => {
+	const foo = mysqlTable('foo', {
+		id: int().primaryKey(),
+	});
+
+	const bar = mysqlTable('bar', {
+		id: int().primaryKey(),
+		fooId: int().references(() => foo.id),
+	});
+
+	const schema1 = { foo, bar };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `foo` (\n\t`id` int PRIMARY KEY\n);\n',
+		'CREATE TABLE `bar` (\n\t`id` int PRIMARY KEY,\n\t`fooId` int\n);\n',
+		'ALTER TABLE `bar` ADD CONSTRAINT `bar_fooId_foo_id_fkey` FOREIGN KEY (`fooId`) REFERENCES `foo`(`id`);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		bar: mysqlTable('bar', {
+			id: int().primaryKey(),
+			fooId: int(),
+		}),
+	};
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE `bar` DROP CONSTRAINT `bar_fooId_foo_id_fkey`;',
+		'DROP INDEX `bar_fooId_foo_id_fkey` ON `bar`',
+		'DROP TABLE `foo`;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('cyclic fk with custom names', async () => {
+	await db.query(`CREATE TABLE \`Users\` (
+	\`id\` int primary key,
+	\`inviteId\` int
+);`);
+	await db.query(`CREATE TABLE \`InviteCode\` (
+	\`id\` int primary key,
+	\`inviterUserId\` int
+);`);
+	await db.query(
+		'ALTER TABLE `Users` ADD CONSTRAINT `usersToInviteCode` FOREIGN KEY (`inviteId`) REFERENCES `InviteCode` (`id`);',
+	);
+	await db.query(
+		'ALTER TABLE `InviteCode` ADD CONSTRAINT `InviteCodeToUsers` FOREIGN KEY (`inviterUserId`) REFERENCES `Users` (`id`);',
+	);
+
+	const inviteCode = mysqlTable('InviteCode', {
+		id: int().primaryKey(),
+		inviterUserId: int().references((): AnyMySqlColumn => users.id),
+	});
+
+	const users = mysqlTable('Users', {
+		id: int().primaryKey(),
+		inviteId: int().references((): AnyMySqlColumn => inviteCode.id),
+	});
+
+	const schema1 = { inviteCode, users };
+
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	expect(pst1).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/265
+// https://github.com/drizzle-team/drizzle-orm/issues/3293
+// https://github.com/drizzle-team/drizzle-orm/issues/2018
+test('adding on delete to 2 fks', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int().primaryKey(),
+		column2: int().references(() => table1.column1).notNull(),
+		column3: int().references(() => table1.column1).notNull(),
+	});
+	const schema1 = { table1, table2 };
+
+	const { next: n1, sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1: string[] = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int PRIMARY KEY,\n\t`column2` int NOT NULL,\n\t`column3` int NOT NULL\n);\n',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column3_table1_column1_fkey` FOREIGN KEY (`column3`) REFERENCES `table1`(`column1`);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table3 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table4 = mysqlTable('table2', {
+		column1: int().primaryKey(),
+		column2: int().references(() => table1.column1, { onDelete: 'cascade' }).notNull(),
+		column3: int().references(() => table1.column1, { onDelete: 'cascade' }).notNull(),
+	});
+	const schema2 = { table3, table4 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_column2_table1_column1_fkey`;',
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_column3_table1_column1_fkey`;',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`) ON DELETE CASCADE;',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column3_table1_column1_fkey` FOREIGN KEY (`column3`) REFERENCES `table1`(`column1`) ON DELETE CASCADE;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('adding autoincrement to table with pk #1', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+		}),
+	};
+
+	const { next: n1, sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1: string[] = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table1` MODIFY COLUMN `column1` int AUTO_INCREMENT NOT NULL;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5301
+test('adding autoincrement to table with pk #2', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().notNull(),
+			column2: int(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const { next: n1, sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1: string[] = [
+		'CREATE TABLE `table1` (\n\t`column1` int NOT NULL,\n\t`column2` int,\n\tCONSTRAINT PRIMARY KEY(`column1`,`column2`)\n);\n',
+	];
+
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().notNull().autoincrement(),
+			column2: int().default(1),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table1` MODIFY COLUMN `column1` int AUTO_INCREMENT NOT NULL;',
+		'ALTER TABLE `table1` MODIFY COLUMN `column2` int DEFAULT 1;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('adding autoincrement to table with unique #1', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().unique(),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(n1, schema2, []);
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const expectedSt: string[] = [
+		'ALTER TABLE `table1` MODIFY COLUMN `column1` int AUTO_INCREMENT;',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+test('adding autoincrement to table with unique #2', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: int(),
+		}, (table) => [
+			unique().on(table.column1, table.column2),
+		]),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement(),
+			column2: int(),
+		}, (table) => [
+			unique().on(table.column1, table.column2),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(n1, schema2, []);
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const expectedSt: string[] = [
+		'ALTER TABLE `table1` MODIFY COLUMN `column1` int AUTO_INCREMENT;',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2458
+test('composite pk #1', async () => {
+	const schema = {
+		account: mysqlTable('Account', {
+			provider: varchar('provider', { length: 255 }).notNull(),
+			providerAccountId: varchar('providerAccountId', { length: 255 }).notNull(),
+		}, (table) => [
+			primaryKey({ columns: [table.provider, table.providerAccountId] }),
+		]),
+	};
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('pk multistep #1', async () => {
+	const teamStats1 = mysqlTable('team_stats', {
+		col1: int().unique().primaryKey(),
+		col2: int(),
+		col3: int(),
+	});
+
+	const schema1 = {
+		teamStats1,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats1.col1),
+		}),
+	};
+
+	const { next: n1, sqlStatements: st1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const teamStats2 = mysqlTable('team_stats', {
+		col1: int().unique(),
+		col2: int(),
+		col3: int(),
+	}, (t) => [
+		primaryKey({ columns: [t.col2, t.col3] }),
+	]);
+
+	const schema2 = {
+		teamStats2,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats2.col1),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSql2 = [
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey`;',
+		'ALTER TABLE `team_stats` DROP PRIMARY KEY;',
+		'ALTER TABLE `team_stats` MODIFY COLUMN `col1` int;',
+		'ALTER TABLE `team_stats` ADD PRIMARY KEY (`col2`,`col3`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey` FOREIGN KEY (`teamStatsCol1`) REFERENCES `team_stats`(`col1`);',
+	];
+	expect(st2).toStrictEqual(expectedSql2);
+	expect(pst2).toStrictEqual(expectedSql2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1144
+test('pk multistep #2', async () => {
+	const teamStats1 = mysqlTable('team_stats', {
+		col1: int().primaryKey(),
+		col2: int(),
+		col3: int(),
+	});
+
+	const schema1 = {
+		teamStats1,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats1.col1),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const teamStats2 = mysqlTable('team_stats', {
+		col1: int().unique(),
+		col2: int(),
+		col3: int(),
+	}, (t) => [
+		primaryKey({ columns: [t.col2, t.col3] }),
+	]);
+
+	const schema2 = {
+		teamStats2,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats2.col1),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSql2 = [
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey`;',
+		'ALTER TABLE `team_stats` DROP PRIMARY KEY;',
+		'ALTER TABLE `team_stats` MODIFY COLUMN `col1` int;',
+		'ALTER TABLE `team_stats` ADD PRIMARY KEY (`col2`,`col3`);',
+		'CREATE UNIQUE INDEX `col1_unique` ON `team_stats` (`col1`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey` FOREIGN KEY (`teamStatsCol1`) REFERENCES `team_stats`(`col1`);',
+	];
+	expect(st2).toStrictEqual(expectedSql2);
+	expect(pst2).toStrictEqual(expectedSql2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1144
+test('pk multistep #3', async () => {
+	const teamStats1 = mysqlTable('team_stats', {
+		col1: int().primaryKey(),
+		col2: int(),
+		col3: int(),
+	});
+
+	const schema1 = {
+		teamStats1,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats1.col1),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const teamStats2 = mysqlTable('team_stats', {
+		col1: int(),
+		col2: int(),
+		col3: int(),
+	}, (t) => [
+		primaryKey({ columns: [t.col2, t.col3] }),
+	]);
+
+	const schema2 = {
+		teamStats2,
+		table2: mysqlTable('table2', {
+			teamStatsCol1: int().references(() => teamStats2.col1),
+		}),
+	};
+
+	const { sqlStatements: st2, suggestion } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2, hints } = await push({ db, to: schema2, ignoreSubsequent: true, expectError: true });
+
+	expect(suggestion.errors).toStrictEqual([
+		`You are trying to drop primary key from "team_stats" ("col1"), but there is an existing reference on this column. You must either add a UNIQUE constraint to ("col1") or drop the foreign key constraint that references this column.`,
+	]);
+	expect(hints).toStrictEqual([{
+		hint:
+			'You are trying to drop primary key from "team_stats" ("col1"), but there is an existing reference on this column. You must either add a UNIQUE constraint to ("col1") or drop the foreign key constraint that references this column.',
+	}]);
+
+	const expectedSql2: string[] = [
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey`;',
+		'ALTER TABLE `team_stats` DROP PRIMARY KEY;',
+		'ALTER TABLE `team_stats` MODIFY COLUMN `col1` int;',
+		'ALTER TABLE `team_stats` ADD PRIMARY KEY (`col2`,`col3`);',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_teamStatsCol1_team_stats_col1_fkey` FOREIGN KEY (`teamStatsCol1`) REFERENCES `team_stats`(`col1`);',
+	];
+	expect(st2).toStrictEqual(expectedSql2);
+	expect(pst2).toStrictEqual(expectedSql2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3471
+test('drop column with pk and add pk to another column #1', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: varchar({ length: 256 }).primaryKey(),
+			column2: varchar({ length: 256 }).notNull(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` varchar(256) PRIMARY KEY,\n\t`column2` varchar(256) NOT NULL\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column2: varchar({ length: 256 }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table1` DROP PRIMARY KEY;',
+		'ALTER TABLE `table1` ADD PRIMARY KEY (`column2`);',
+		'ALTER TABLE `table1` DROP COLUMN `column1`;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('drop column with pk and add pk to another column #2', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: varchar({ length: 256 }),
+			column2: varchar({ length: 256 }),
+			column3: varchar({ length: 256 }).notNull(),
+			column4: varchar({ length: 256 }).notNull(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` varchar(256),\n\t`column2` varchar(256),'
+		+ '\n\t`column3` varchar(256) NOT NULL,\n\t`column4` varchar(256) NOT NULL,'
+		+ '\n\tCONSTRAINT PRIMARY KEY(`column1`,`column2`)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column3: varchar({ length: 256 }),
+			column4: varchar({ length: 256 }),
+		}, (table) => [
+			primaryKey({ columns: [table.column3, table.column4] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table1` DROP PRIMARY KEY;',
+		'ALTER TABLE `table1` ADD PRIMARY KEY (`column3`,`column4`);',
+		'ALTER TABLE `table1` DROP COLUMN `column1`;',
+		'ALTER TABLE `table1` DROP COLUMN `column2`;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456
+test('drop column with pk and add pk to another column #3', async () => {
+	const schema1 = {
+		authors: mysqlTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+		}, (table) => [primaryKey({ columns: [table.publicationId, table.authorID] })]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `authors` (\n\t`publication_id` varchar(64),\n\t`author_id` varchar(10),'
+		+ '\n\tCONSTRAINT PRIMARY KEY(`publication_id`,`author_id`)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authors: mysqlTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+			orcidId: varchar('orcid_id', { length: 64 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID, table.orcidId] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `authors` DROP PRIMARY KEY;',
+		'ALTER TABLE `authors` ADD `orcid_id` varchar(64);',
+		'ALTER TABLE `authors` ADD PRIMARY KEY (`publication_id`,`author_id`,`orcid_id`);',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test('issue No4704. Composite index with sort outputs', async () => {
+	const schema1 = {
+		table: mysqlTable(
+			'table',
+			{ col1: int(), col2: int(), col3: int() },
+			(table) => [
+				index('table_composite_idx').on(
+					table.col1,
+					table.col2,
+					desc(table.col3), // Attempting to sort by col3 DESC
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table` (\n\t`col1` int,\n\t`col2` int,\n\t`col3` int\n);\n',
+		'CREATE INDEX `table_composite_idx` ON `table` (`col1`,`col2`,`col3` desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// In non-interactive / json mode `suggestions` throws a structured `unsupported_schema_change`
+// instead of pushing a human-readable hint, so it is exercised directly with that context.
+test('dropping a primary key referenced by a foreign key throws `drop_pk_dependency`', async () => {
+	const before = {
+		users: mysqlTable('users', { id: int().primaryKey() }),
+		orders: mysqlTable('orders', {
+			id: int().primaryKey(),
+			userId: int().references((): AnyMySqlColumn => before.users.id),
+		}),
+	};
+	const after = {
+		users: mysqlTable('users', { id: int() }),
+		orders: mysqlTable('orders', {
+			id: int().primaryKey(),
+			userId: int().references((): AnyMySqlColumn => after.users.id),
+		}),
+	};
+
+	await push({ db, to: before });
+	const { statements, next } = await diff(before, after, []);
+
+	await expect(
+		runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => suggestions(db, statements, next, new HintsHandler()),
+		),
+	).rejects.toMatchObject({
+		code: 'unsupported_schema_change',
+		meta: {
+			kind: 'drop_pk_dependency',
+			table: 'users',
+			columns: ['id'],
+			blocking_fks: ['orders_userId_users_id_fkey'],
+		},
+	});
+});
+
+test('adding a foreign key to a non-unique target column throws `fk_target_not_unique`', async () => {
+	const before = {
+		users: mysqlTable('users', { id: int().primaryKey(), email: varchar({ length: 256 }) }),
+		orders: mysqlTable('orders', { id: int().primaryKey() }),
+	};
+	const usersAfter = mysqlTable('users', { id: int().primaryKey(), email: varchar({ length: 256 }) });
+	const after = {
+		users: usersAfter,
+		orders: mysqlTable('orders', {
+			id: int().primaryKey(),
+			userEmail: varchar({ length: 256 }),
+		}, (t) => [
+			foreignKey({ columns: [t.userEmail], foreignColumns: [usersAfter.email] }),
+		]),
+	};
+
+	await push({ db, to: before });
+	const { statements, next } = await diff(before, after, []);
+
+	await expect(
+		runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => suggestions(db, statements, next, new HintsHandler()),
+		),
+	).rejects.toMatchObject({
+		code: 'unsupported_schema_change',
+		meta: {
+			kind: 'fk_target_not_unique',
+			table: 'orders',
+			columns: ['userEmail'],
+			table_to: 'users',
+			columns_to: ['email'],
+		},
+	});
+});
+
+// A column type change is a non-fatal `confirm_data_loss` missing hint rather than a throw,
+// so it is read back from the handler instead of asserting on a rejection.
+test('changing a column type records a `type_change` confirm_data_loss missing hint', async () => {
+	const before = {
+		users: mysqlTable('users', { id: int().primaryKey(), age: int() }),
+	};
+	const after = {
+		users: mysqlTable('users', { id: int().primaryKey(), age: varchar({ length: 50 }) }),
+	};
+
+	await push({ db, to: before });
+	const { statements, next } = await diff(before, after, []);
+
+	const hints = new HintsHandler();
+	await runWithCliContext(
+		{ output: 'json', interactive: false },
+		() => suggestions(db, statements, next, hints),
+	);
+
+	expect(hints.missingHints).toStrictEqual([
+		{
+			type: 'confirm_data_loss',
+			kind: 'column',
+			entity: ['public', 'users', 'age'],
+			reason: 'type_change',
+			reason_details: { from: 'int', to: 'varchar(50)' },
+		},
+	]);
+});
diff --git a/drizzle-kit/tests/mysql/grammar.test.ts b/drizzle-kit/tests/mysql/grammar.test.ts
new file mode 100644
index 0000000000..3a7bdb491d
--- /dev/null
+++ b/drizzle-kit/tests/mysql/grammar.test.ts
@@ -0,0 +1,60 @@
+import { int, mysqlTable, varchar } from 'drizzle-orm/mysql-core';
+import { Decimal, parseEnum } from 'src/dialects/mysql/grammar';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffIntrospect, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+if (!fs.existsSync('tests/mysql/tmp')) {
+	fs.mkdirSync('tests/mysql/tmp', { recursive: true });
+}
+
+test('enum', () => {
+	expect(parseEnum("enum('one','two','three')")).toStrictEqual(['one', 'two', 'three']);
+});
+
+test('numeric|decimal', () => {
+	expect.soft(Decimal.is('decimal')).true;
+	expect.soft(Decimal.is('numeric')).true;
+	expect.soft(Decimal.is('decimal(7)')).true;
+	expect.soft(Decimal.is('numeric(7)')).true;
+	expect.soft(Decimal.is('decimal (7)')).true;
+	expect.soft(Decimal.is('numeric (7)')).true;
+	expect.soft(Decimal.is('decimal(7, 4)')).true;
+	expect.soft(Decimal.is('decimal(7, 0)')).true;
+	expect.soft(Decimal.is('decimal(7, 0) ZEROFILL')).true;
+	expect.soft(Decimal.is('decimal(7, 0) unsigned')).true;
+	expect.soft(Decimal.is('DECIMAL(7, 0) UNSIGNED')).true;
+	expect.soft(Decimal.is('DECIMAL(7, 0) UNSIGNED ZEROFILL')).true;
+});
+
+test('column name + options', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			sortKey: varchar('sortKey__!@#', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-value-varchar');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
diff --git a/drizzle-kit/tests/mysql/mocks.ts b/drizzle-kit/tests/mysql/mocks.ts
new file mode 100644
index 0000000000..9771fd96cb
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mocks.ts
@@ -0,0 +1,478 @@
+import { is } from 'drizzle-orm';
+import { int, MySqlColumnBuilder, MySqlSchema, MySqlTable, mysqlTable, MySqlView } from 'drizzle-orm/mysql-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { Connection, createConnection } from 'mysql2/promise';
+import {
+	MySqlSchema as MySqlSchemaOld,
+	MySqlTable as MysqlTableOld,
+	MySqlView as MysqlViewOld,
+} from 'orm044/mysql-core';
+import { suggestions as diffSuggestions } from '../../src/cli/commands/generate-mysql';
+import { introspect } from '../../src/cli/commands/pull-mysql';
+import { suggestions } from '../../src/cli/commands/push-mysql';
+import { upToV6 } from '../../src/cli/commands/up-mysql';
+import { runWithCliContext } from '../../src/cli/context';
+import { HintsHandler } from '../../src/cli/hints';
+import { configMigrations } from '../../src/cli/validations/common';
+import { mysqlSchemaError as schemaError } from '../../src/cli/views';
+import { EmptyProgressView } from '../../src/cli/views';
+import { hash } from '../../src/dialects/common';
+import { MysqlDDL, MysqlEntity, mysqlToRelationsPull } from '../../src/dialects/mysql/ddl';
+import { createDDL, interimToDDL } from '../../src/dialects/mysql/ddl';
+import { ddlDiff, ddlDiffDry } from '../../src/dialects/mysql/diff';
+import { defaultFromColumn } from '../../src/dialects/mysql/drizzle';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from '../../src/dialects/mysql/drizzle';
+import { fromDatabaseForDrizzle } from '../../src/dialects/mysql/introspect';
+import { ddlToTypeScript } from '../../src/dialects/mysql/typescript';
+import { diff as legacyDiff } from '../../src/legacy/mysql-v5/mysqlDiff';
+import { serializeMysql } from '../../src/legacy/mysql-v5/serializer';
+import { DB } from '../../src/utils';
+import { mockResolver } from '../../src/utils/mocks';
+import { tsc } from '../utils';
+import 'zx/globals';
+import { relationsToTypeScript } from 'src/cli/commands/pull-common';
+import { mysqlCommutativity } from 'src/dialects/mysql/commutativity';
+import type { MysqlSnapshot } from 'src/dialects/mysql/snapshot';
+import { expect } from 'vitest';
+
+mkdirSync('tests/mysql/tmp', { recursive: true });
+
+export type MysqlSchema = Record<
+	string,
+	MySqlTable<any> | MySqlSchema | MySqlView
+>;
+
+export type MysqlSchemaOld = Record<
+	string,
+	MysqlTableOld<any> | MySqlSchemaOld | MysqlViewOld
+>;
+
+export const fromEntities = (entities: MysqlEntity[]) => {
+	const ddl = createDDL();
+	for (const it of entities) {
+		ddl.entities.push(it);
+	}
+	return ddl;
+};
+
+export const drizzleToDDL = (sch: MysqlSchema) => {
+	const tables = Object.values(sch).filter((it) => is(it, MySqlTable)) as MySqlTable[];
+	const views = Object.values(sch).filter((it) => is(it, MySqlView)) as MySqlView[];
+	return interimToDDL(fromDrizzleSchema(tables, views));
+};
+
+export const diff = async (
+	left: MysqlSchema | MysqlDDL,
+	right: MysqlSchema | MysqlDDL,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as MysqlDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = 'entities' in right && '_' in right
+		? { ddl: right as MysqlDDL, errors: [] }
+		: drizzleToDDL(right);
+
+	const renames = new Set(renamesArr);
+
+	const mappedErrors1 = err1.map((it: any) => schemaError(it));
+	const mappedErrors2 = err2.map((it: any) => schemaError(it));
+
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+
+	const { errors } = diffSuggestions(statements, ddl2);
+
+	return {
+		sqlStatements,
+		statements,
+		next: ddl2,
+		ddl1Err: err1,
+		ddl2Err: err2,
+		mappedErrors1,
+		mappedErrors2,
+		suggestion: { errors },
+	};
+};
+
+export const diffIntrospect = async (
+	db: DB,
+	initSchema: MysqlSchema,
+	testName: string,
+) => {
+	const { ddl: initDDL } = drizzleToDDL(initSchema);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL);
+	for (const st of init) await db.query(st);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, 'drizzle', () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const filePath = `tests/mysql/tmp/${testName}.ts`;
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel', 'mysql');
+	const filePathRelations = `tests/mysql/tmp/${testName}-relations.ts`;
+	// path
+	const relations = relationsToTypeScript(mysqlToRelationsPull(ddl1), 'camel', `./tests/mysql/tmp/${testName}`);
+
+	writeFileSync(filePath, file.file);
+	writeFileSync(filePathRelations, relations.file);
+	await tsc(file.file);
+	await tsc(relations.file);
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([
+		filePath,
+	]);
+
+	const interim = fromDrizzleSchema(
+		response.tables,
+		response.views,
+	);
+
+	const { ddl: ddl2, errors: e3 } = interimToDDL(interim);
+
+	// TODO: handle errors
+	const renames = new Set<string>();
+
+	const {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	} = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	rmSync(`tests/mysql/tmp/${testName}.ts`);
+	rmSync(`tests/mysql/tmp/${testName}-relations.ts`);
+
+	return {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+		ddlAfterPull: ddl1,
+		ddlFromPulledTsSchema: ddl2,
+	};
+};
+
+export const push = async (config: {
+	db: DB;
+	to: MysqlSchema | MysqlDDL;
+	renames?: string[];
+	log?: 'statements';
+	ignoreSubsequent?: boolean;
+	expectError?: boolean;
+	migrationsConfig?: {
+		table?: string;
+	};
+}) => {
+	const { db, to, log, expectError } = config;
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+	const { schema } = await introspect({
+		db,
+		database: 'drizzle',
+		filter: () => true,
+		progress: new EmptyProgressView(),
+		migrations,
+	});
+	const { ddl: ddl1, errors: err1 } = interimToDDL(schema);
+	const { ddl: ddl2, errors: err2 } = 'entities' in to && '_' in to
+		? { ddl: to as MysqlDDL, errors: [] }
+		: drizzleToDDL(to);
+
+	if (err2.length > 0) {
+		for (const e of err2) {
+			console.error(`err2: ${JSON.stringify(e)}`);
+		}
+		throw new Error('Schema2 Interim Error');
+	}
+
+	if (err1.length > 0) {
+		for (const e of err1) {
+			console.error(`err: ${JSON.stringify(e)}`);
+		}
+		throw new Error('Schema1 Interim Error');
+	}
+
+	const renames = new Set(config.renames ?? []);
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const res = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, ddl2, new HintsHandler()),
+	);
+
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		await db.query(sql).catch((err) => {
+			if (!expectError) throw err;
+		});
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		{
+			const { schema } = await introspect({
+				db,
+				database: 'drizzle',
+				filter: () => true,
+				progress: new EmptyProgressView(),
+				migrations,
+			});
+			const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+			const { sqlStatements, statements } = await ddlDiff(
+				ddl1,
+				ddl2,
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				'push',
+			);
+			if (sqlStatements.length > 0) {
+				console.error('---- subsequent push is not empty ----');
+				expect(sqlStatements.join('\n')).toBe('');
+			}
+		}
+	}
+
+	return { sqlStatements, statements, hints: res };
+};
+
+export const diffDefault = async <T extends MySqlColumnBuilder>(
+	kit: TestDatabase,
+	builder: T,
+	expectedDefault: string,
+	pre: MysqlSchema | null = null,
+	override?: {
+		type?: string;
+		default?: string;
+		ignoreSubsequent?: boolean;
+	},
+) => {
+	await kit.clear();
+
+	const config = (builder as any).config;
+	const def = config['default'];
+	const column = mysqlTable('table', { column: builder }).column;
+	const type = override?.type ?? column.getSQLType().replace(', ', ','); // real(6, 3)->real(6,3)
+	const ignoreSubsequent = override?.ignoreSubsequent ?? false;
+
+	const columnDefault = defaultFromColumn(column);
+	const defaultSql = override?.default ?? columnDefault;
+
+	const res = [] as string[];
+	if (defaultSql !== expectedDefault) {
+		res.push(`Unexpected sql: \n${defaultSql}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	const { db, clear } = kit;
+	if (pre) await push({ db, to: pre });
+	const { sqlStatements: st1 } = await push({ db, to: init, ignoreSubsequent });
+	const { sqlStatements: st2 } = await push({ db, to: init, ignoreSubsequent });
+
+	const expectedInit = `CREATE TABLE \`table\` (\n\t\`column\` ${type} DEFAULT ${expectedDefault}\n);\n`;
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2}`);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, 'drizzle', () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel', 'mysql');
+	const path = `tests/mysql/tmp/temp-${hash(String(Math.random()))}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+	const sch = fromDrizzleSchema(response.tables, response.views);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+	}
+
+	await clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: mysqlTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema1, ignoreSubsequent });
+	const { sqlStatements: st3 } = await push({ db, to: schema2, ignoreSubsequent });
+	const expectedAlter = `ALTER TABLE \`table\` MODIFY COLUMN \`column\` ${type} DEFAULT ${expectedDefault};`;
+	if (st3.length !== 1 || st3[0] !== expectedAlter) res.push(`Unexpected default alter:\n${st3}\n\n${expectedAlter}`);
+
+	await clear();
+
+	const schema3 = {
+		...pre,
+		table: mysqlTable('table', { id: int() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: mysqlTable('table', { id: int(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, ignoreSubsequent });
+	await push({ db, to: schema3, ignoreSubsequent });
+	const { sqlStatements: st4 } = await push({ db, to: schema4, ignoreSubsequent });
+
+	const expectedAddColumn = `ALTER TABLE \`table\` ADD \`column\` ${type} DEFAULT ${expectedDefault};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export type TestDatabase = {
+	db: DB;
+	client: Connection;
+	db_url: string;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+};
+
+export const prepareTestDatabase = async (): Promise<TestDatabase> => {
+	const url = process.env['MYSQL_CONNECTION_STRING'];
+	if (!url) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mysql` and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 1000;
+	let timeLeft = 20000;
+	do {
+		try {
+			const client: Connection = await createConnection(url);
+			await client.connect();
+
+			const db = {
+				query: async (sql: string, params: any[]) => {
+					const [res] = await client.query(sql).catch((e: Error) => {
+						const error = new Error(`query error: ${sql}\n\n${e.message}`);
+						throw error;
+					});
+					return res as any[];
+				},
+			};
+			const close = async () => {
+				await client?.end().catch(console.error);
+			};
+			const clear = async () => {
+				await client.query(`drop database if exists \`drizzle\`;`);
+				await client.query(`create database \`drizzle\`;`);
+				await client.query(`use \`drizzle\`;`);
+			};
+			return { db, close, clear, db_url: url, client };
+		} catch (e) {
+			console.error(e);
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+
+	throw new Error();
+};
+
+export const diffSnapshotV5 = async (db: DB, schema: MysqlSchema, oldSchema: MysqlSchemaOld) => {
+	const res = await serializeMysql(oldSchema, 'camelCase');
+	const { sqlStatements } = await legacyDiff({ right: res });
+
+	for (const st of sqlStatements) {
+		await db.query(st);
+	}
+
+	const snapshot = upToV6(res);
+	const ddl = fromEntities(snapshot.ddl);
+
+	const { sqlStatements: st, next } = await diff(ddl, schema, []);
+	const { sqlStatements: pst } = await push({ db, to: schema });
+	const { sqlStatements: st1 } = await diff(next, ddl, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	return {
+		step1: st,
+		step2: pst,
+		step3: st1,
+		step4: pst1,
+		all: [...st, ...pst, ...st1, ...pst1],
+	};
+};
+
+type SchemaShape = {
+	id: string;
+	prevId?: string;
+	schema: Record<string, MySqlTable>;
+};
+
+export async function conflictsFromSchema(
+	{ parent, child1, child2 }: {
+		parent: SchemaShape;
+		child1: SchemaShape;
+		child2: SchemaShape;
+	},
+) {
+	const parentInterim = fromDrizzleSchema(Object.values(parent.schema), []);
+	const { ddl: parentDDL } = interimToDDL(parentInterim);
+
+	const parentSnapshot = {
+		version: '6',
+		dialect: 'mysql',
+		id: parent.id,
+		prevIds: parent.prevId ? [parent.prevId] : [],
+		ddl: parentDDL.entities.list(),
+		renames: [],
+	} satisfies MysqlSnapshot;
+
+	const { statements: st1 } = await diff(parent.schema, child1.schema, []);
+	const { statements: st2 } = await diff(parent.schema, child2.schema, []);
+
+	return await mysqlCommutativity.getReasonsFromStatements(st1, st2, parentSnapshot);
+}
diff --git a/drizzle-kit/tests/mysql/mysql-checks.test.ts b/drizzle-kit/tests/mysql/mysql-checks.test.ts
new file mode 100644
index 0000000000..3624383180
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-checks.test.ts
@@ -0,0 +1,333 @@
+import { sql } from 'drizzle-orm';
+import { check, int, mysqlTable, serial, varchar } from 'drizzle-orm/mysql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create table with check', async (t) => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`users\` (
+\t\`id\` serial PRIMARY KEY,
+\t\`age\` int,
+\tCONSTRAINT \`some_check_name\` CHECK(\`users\`.\`age\` > 21)
+);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check constraint to existing table #1', async (t) => {
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+		]),
+	};
+
+	const { sqlStatements: st, next } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name\` CHECK (\`users\`.\`age\` > 21);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check constraint to existing table #2', async () => {
+	const schema1 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values'),
+		}),
+	};
+	const schema2 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values'),
+		}, (table) => [check('some_check1', sql`${table.values} < 100`), check('some_check2', sql`'test' < 100`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE \`test\` ADD CONSTRAINT \`some_check1\` CHECK (\`test\`.\`values\` < 100);',
+		`ALTER TABLE \`test\` ADD CONSTRAINT \`some_check2\` CHECK ('test' < 100);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check constraint in existing table #1', async (t) => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check constraint in existing table #2', async () => {
+	const schema1 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values'),
+		}, (table) => [
+			check('some_check1', sql`${table.values} < 100`),
+			check('some_check2', sql`'test' < 100`),
+		]),
+	};
+	const schema2 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE \`test\` DROP CONSTRAINT \`some_check1\`;',
+		`ALTER TABLE \`test\` DROP CONSTRAINT \`some_check2\`;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename check constraint', async (t) => {
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
+		`ALTER TABLE \`users\` ADD CONSTRAINT \`new_check_name\` CHECK (\`users\`.\`age\` > 21);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter check constraint', async (t) => {
+	const from = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name\`;`,
+		`ALTER TABLE \`users\` ADD CONSTRAINT \`new_check_name\` CHECK (\`users\`.\`age\` > 10);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter multiple check constraints', async (t) => {
+	const from = {
+		users: mysqlTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				age: int('age'),
+				name: varchar('name', { length: 255 }),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_1', sql`${table.age} > 21`),
+				check('some_check_name_2', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const to = {
+		users: mysqlTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				age: int('age'),
+				name: varchar('name', { length: 255 }),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_3', sql`${table.age} > 21`),
+				check('some_check_name_4', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name_1\`;`,
+		`ALTER TABLE \`users\` DROP CONSTRAINT \`some_check_name_2\`;`,
+		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name_3\` CHECK (\`users\`.\`age\` > 21);`,
+		`ALTER TABLE \`users\` ADD CONSTRAINT \`some_check_name_4\` CHECK (\`users\`.\`name\` != \'Alex\');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create checks with same names', async (t) => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			age: int('age'),
+			name: varchar('name', { length: 255 }),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+			check('some_check_name', sql`${table.name} != 'Alex'`),
+		]),
+	};
+
+	await expect(diff({}, to, [])).rejects.toThrowError();
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+// TODO not possible to parse check definition
+test.todo('create checks on serail or autoincrement', async (t) => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: serial(),
+		}, (table) => [
+			check('some_check_name1', sql`${table.column1} > 21`),
+		]),
+	};
+
+	await expect(diff({}, schema1, [])).rejects.toThrowError();
+	await expect(push({ db, to: schema1 })).rejects.toThrowError();
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			columnй: int().autoincrement(),
+		}, (table) => [
+			check('some_check_name2', sql`${table.columnй} > 21`),
+		]),
+	};
+
+	await expect(diff({}, schema2, [])).rejects.toThrowError();
+	await expect(push({ db, to: schema2 })).rejects.toThrowError();
+});
+
+test('db has checks. Push with same names', async () => {
+	const schema1 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [
+			check('some_check', sql`${table.values} < 100`),
+		]),
+	};
+	const schema2 = {
+		test: mysqlTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}, (table) => [
+			check('some_check', sql`some new value`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mysql/mysql-defaults.test.ts b/drizzle-kit/tests/mysql/mysql-defaults.test.ts
new file mode 100644
index 0000000000..459cfd0833
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-defaults.test.ts
@@ -0,0 +1,797 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	binary,
+	blob,
+	boolean,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	int,
+	json,
+	longblob,
+	longtext,
+	mediumblob,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyblob,
+	tinyint,
+	tinytext,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffDefault, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('tinyint', async () => {
+	const res1 = await diffDefault(_, tinyint().default(-128), '-128');
+	const res2 = await diffDefault(_, tinyint().default(0), '0');
+	const res3 = await diffDefault(_, tinyint().default(127), '127');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('smallint', async () => {
+	const res1 = await diffDefault(_, smallint().default(-32768), '-32768');
+	const res2 = await diffDefault(_, smallint().default(0), '0');
+	const res3 = await diffDefault(_, smallint().default(32767), '32767');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('mediumint', async () => {
+	const res1 = await diffDefault(_, mediumint().default(-8388608), '-8388608');
+	const res2 = await diffDefault(_, mediumint().default(0), '0');
+	const res3 = await diffDefault(_, mediumint().default(8388607), '8388607');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('int', async () => {
+	const res1 = await diffDefault(_, int().default(-2147483648), '-2147483648');
+	const res2 = await diffDefault(_, int().default(0), '0');
+	const res3 = await diffDefault(_, int().default(2147483647), '2147483647');
+	const res4 = await diffDefault(_, int().default(1e4), '10000');
+	const res5 = await diffDefault(_, int().default(-1e4), '-10000');
+
+	// expressions
+	const res6 = await diffDefault(_, int().default(sql`(1 + 1)`), '(1 + 1)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('bigint', async () => {
+	const res1 = await diffDefault(_, bigint({ mode: 'number' }).default(9007199254740991), '9007199254740991'); // 2^53
+	const res2 = await diffDefault(_, bigint({ mode: 'number' }).default(-9007199254740991), '-9007199254740991');
+	const res3 = await diffDefault(_, bigint({ mode: 'bigint' }).default(9223372036854775807n), '9223372036854775807'); // 2^63 - 1
+	const res4 = await diffDefault(_, bigint({ mode: 'bigint' }).default(-9223372036854775808n), '-9223372036854775808'); // -2^63
+	const res5 = await diffDefault(
+		_,
+		bigint({ mode: 'number', unsigned: true }).default(9007199254740991),
+		'9007199254740991',
+	);
+	const res6 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint', unsigned: true }).default(18446744073709551615n),
+		'18446744073709551615', // 2^64 max in Mysql
+	);
+
+	// expressions
+	const res7 = await diffDefault(_, bigint({ mode: 'number' }).default(sql`(1 + 1)`), '(1 + 1)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('decimal', async () => {
+	const res1 = await diffDefault(_, decimal().default('10.123'), '(10.123)');
+
+	const res2 = await diffDefault(_, decimal({ precision: 6 }).default('10.123'), '(10.123)');
+	const res3 = await diffDefault(_, decimal({ precision: 6, scale: 2 }).default('10.123'), '(10.123)');
+
+	// string
+	const res4 = await diffDefault(_, decimal({ mode: 'string' }).default('10.123'), '(10.123)');
+
+	const res5 = await diffDefault(_, decimal({ mode: 'string', scale: 2 }).default('10.123'), '(10.123)');
+	const res6 = await diffDefault(_, decimal({ mode: 'string', precision: 6 }).default('10.123'), '(10.123)');
+	const res7 = await diffDefault(
+		_,
+		decimal({ mode: 'string', precision: 6, scale: 2 }).default('10.123'),
+		'(10.123)',
+	);
+
+	// number
+	// const res8 = await diffDefault(_, decimal({ mode: 'number' }).default(9007199254740991), '9007199254740991');
+	const res9 = await diffDefault(
+		_,
+		decimal({ mode: 'number', precision: 16 }).default(9007199254740991),
+		'(9007199254740991)',
+	);
+
+	const res10 = await diffDefault(_, decimal({ mode: 'number', precision: 6, scale: 2 }).default(10.123), '(10.123)');
+	const res11 = await diffDefault(_, decimal({ mode: 'number', scale: 2 }).default(10.123), '(10.123)');
+	const res12 = await diffDefault(_, decimal({ mode: 'number', precision: 6 }).default(10.123), '(10.123)');
+
+	// TODO revise: maybe bigint mode should set the precision to a value appropriate for bigint, since the default precision (10) is insufficient.
+	// the line below will fail
+	const res13 = await diffDefault(
+		_,
+		decimal({ mode: 'bigint' }).default(9223372036854775807n),
+		'(9223372036854775807)',
+	);
+	const res14 = await diffDefault(
+		_,
+		decimal({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		'(9223372036854775807)',
+	);
+
+	// expressions
+	const res15 = await diffDefault(_, decimal().default(sql`(1.10 + 1.20)`), '(1.10 + 1.20)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	// expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+});
+
+test('real', async () => {
+	const res1 = await diffDefault(_, real().default(10.123), '10.123');
+	// TODO: revise: It seems that the real type can’t be configured using only one property—precision or scale; both must be specified.
+	// The commented line below will fail
+	// const res2 = await diffDefault(_, real({ precision: 6 }).default(10.123), '10.123');
+	const res3 = await diffDefault(_, real({ precision: 6, scale: 3 }).default(10.123), '10.123');
+	const res4 = await diffDefault(_, real({ precision: 6, scale: 2 }).default(10.123), '10.123', null, {
+		ignoreSubsequent: true,
+	});
+
+	// expressions
+	const res5 = await diffDefault(_, decimal().default(sql`(1.10 + 1.20)`), '(1.10 + 1.20)');
+
+	expect.soft(res1).toStrictEqual([]);
+	// expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ 'ALTER TABLE `table` MODIFY COLUMN `column` real(6,2) DEFAULT 10.123;', // expected due to scale 2
+	]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('double', async () => {
+	const res1 = await diffDefault(_, double().default(10.123), '10.123');
+	// TODO: revise: It seems that the double type can’t be configured using only one property precision or scale; both must be specified.
+	// The commented line below will fail
+	// const res2 = await diffDefault(_, double({ precision: 6 }).default(10.123), '10.123');
+	const res3 = await diffDefault(_, double({ precision: 6, scale: 2 }).default(10.123), '10.123', null, {
+		ignoreSubsequent: true,
+	});
+	const res4 = await diffDefault(_, double({ unsigned: true }).default(10.123), '10.123');
+	const res5 = await diffDefault(
+		_,
+		double({ unsigned: true, precision: 6, scale: 2 }).default(10.123),
+		'10.123',
+		null,
+		{ ignoreSubsequent: true },
+	);
+
+	// expressions
+	const res6 = await diffDefault(_, decimal({ precision: 6, scale: 2 }).default(sql`(1.10 + 1.20)`), '(1.10 + 1.20)');
+
+	expect.soft(res1).toStrictEqual([]);
+	// expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ 'ALTER TABLE `table` MODIFY COLUMN `column` double(6,2) DEFAULT 10.123;',
+	]);
+	expect.soft(res4).toStrictEqual([]);
+
+	//
+	expect.soft(res5).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ 'ALTER TABLE `table` MODIFY COLUMN `column` double(6,2) unsigned DEFAULT 10.123;',
+	]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('float', async () => {
+	const res1 = await diffDefault(_, float().default(10.123), '10.123');
+
+	const res2 = await diffDefault(_, float({ precision: 6 }).default(10.123), '10.123');
+	const res3 = await diffDefault(_, float({ precision: 6, scale: 3 }).default(10.123), '10.123');
+
+	const res4 = await diffDefault(_, float({ unsigned: true }).default(10.123), '10.123');
+	const res5 = await diffDefault(_, float({ unsigned: true, precision: 6, scale: 3 }).default(10.123), '10.123');
+	const res6 = await diffDefault(_, float({ unsigned: true, precision: 6, scale: 2 }).default(10.123), '10.123', null, {
+		ignoreSubsequent: true,
+	});
+
+	// expressions
+	const res7 = await diffDefault(_, decimal({ precision: 6, scale: 2 }).default(sql`(1.10 + 1.20)`), '(1.10 + 1.20)');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ 'ALTER TABLE `table` MODIFY COLUMN `column` float(6,2) unsigned DEFAULT 10.123;',
+	]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('boolean', async () => {
+	// sql`null` equals no default value, while we handle it properly
+	// it breaks on expected sql statements since they always expect DEFAULT
+	const res1 = await diffDefault(_, boolean().default(sql`null`), 'null', null, { ignoreSubsequent: true });
+	const res2 = await diffDefault(_, boolean().default(true), 'true');
+	const res3 = await diffDefault(_, boolean().default(false), 'false');
+	const res4 = await diffDefault(_, boolean().default(sql`true`), '(true)');
+
+	// null vs { value: "null", type: "unknown" }
+	expect.soft(res1.length).greaterThan(0);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('char', async () => {
+	const res1 = await diffDefault(_, char({ length: 10 }).default('10'), `'10'`);
+	const res2 = await diffDefault(_, char({ length: 10 }).default("'"), `''''`);
+	const res3 = await diffDefault(_, char({ length: 10 }).default('"'), `'"'`);
+	const res4 = await diffDefault(_, char({ length: 10 }).default('text\'text"'), "'text''text\"'");
+
+	const res5 = await diffDefault(_, char({ length: 100 }).default(sql`('hello' + ' world')`), "('hello' + ' world')");
+	const res6 = await diffDefault(_, char({ length: 100 }).default(sql`'hey'`), "('hey')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('varchar', async () => {
+	const res1 = await diffDefault(_, varchar({ length: 10 }).default('text'), `'text'`);
+	const res2 = await diffDefault(_, varchar({ length: 10 }).default("text'text"), `'text''text'`);
+	const res3 = await diffDefault(_, varchar({ length: 10 }).default('text\'text"'), "'text''text\"'");
+
+	// expressions
+	const res4 = await diffDefault(
+		_,
+		varchar({ length: 100 }).default(sql`('hello' + ' world')`),
+		"('hello' + ' world')",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('tinytext', async () => {
+	const res1 = await diffDefault(_, tinytext().default('text'), `('text')`);
+	const res2 = await diffDefault(_, tinytext().default("'"), `('''')`);
+	const res3 = await diffDefault(_, tinytext().default('"'), `('"')`);
+	const res4 = await diffDefault(_, tinytext().default("text'text"), `('text''text')`);
+	const res5 = await diffDefault(_, tinytext().default('text\'text"'), `('text''text"')`);
+
+	// expressions
+	const res6 = await diffDefault(_, tinytext().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('mediumtext', async () => {
+	const res1 = await diffDefault(_, mediumtext().default('text'), `('text')`);
+	const res2 = await diffDefault(_, mediumtext().default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, mediumtext().default('text\'text"'), `('text''text"')`);
+
+	// expressions
+	const res4 = await diffDefault(_, mediumtext().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('text', async () => {
+	const res1 = await diffDefault(_, text().default('text'), `('text')`);
+	const res2 = await diffDefault(_, text().default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, text().default('text\'text"'), `('text''text"')`);
+
+	// expressions
+	const res4 = await diffDefault(_, text().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('longtext', async () => {
+	const res1 = await diffDefault(_, longtext().default('text'), `('text')`);
+	const res2 = await diffDefault(_, longtext().default("text'text"), `('text''text')`);
+	const res3 = await diffDefault(_, longtext().default('text\'text"'), `('text''text"')`);
+
+	// expressions
+	const res4 = await diffDefault(_, longtext().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('tinyblob', async () => {
+	const res1 = await diffDefault(_, tinyblob({ mode: 'string' }).default('text'), `('text')`);
+	const res1_1 = await diffDefault(
+		_,
+		tinyblob().default(Buffer.from('text')),
+		`(0x${Buffer.from('text').toString('hex')})`,
+	);
+	const res2 = await diffDefault(_, tinyblob({ mode: 'string' }).default("text'text"), `('text''text')`);
+	const res2_1 = await diffDefault(
+		_,
+		tinyblob().default(Buffer.from("text't")),
+		`(0x${Buffer.from("text't").toString('hex')})`,
+	);
+	const res3 = await diffDefault(_, tinyblob({ mode: 'string' }).default('text\'text"'), `('text''text"')`);
+	const res3_1 = await diffDefault(
+		_,
+		tinyblob().default(Buffer.from('text\'t"')),
+		`(0x${Buffer.from('text\'t"').toString('hex')})`,
+	);
+
+	// expressions
+	const res4 = await diffDefault(_, tinyblob().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res3_1).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('mediumblob', async () => {
+	const res1 = await diffDefault(_, mediumblob({ mode: 'string' }).default('text'), `('text')`);
+	const res1_1 = await diffDefault(
+		_,
+		mediumblob().default(Buffer.from('text')),
+		`(0x${Buffer.from('text').toString('hex')})`,
+	);
+	const res2 = await diffDefault(_, mediumblob({ mode: 'string' }).default("text'text"), `('text''text')`);
+	const res2_1 = await diffDefault(
+		_,
+		mediumblob().default(Buffer.from("text'text")),
+		`(0x${Buffer.from("text'text").toString('hex')})`,
+	);
+	const res3 = await diffDefault(_, mediumblob({ mode: 'string' }).default('text\'text"'), `('text''text"')`);
+	const res3_1 = await diffDefault(
+		_,
+		mediumblob().default(Buffer.from('text\'text"')),
+		`(0x${Buffer.from('text\'text"').toString('hex')})`,
+	);
+
+	// expressions
+	const res4 = await diffDefault(_, mediumblob().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res3_1).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('blob', async () => {
+	const res1 = await diffDefault(_, blob({ mode: 'string' }).default('text'), `('text')`);
+	const res1_1 = await diffDefault(
+		_,
+		blob().default(Buffer.from('text')),
+		`(0x${Buffer.from('text').toString('hex')})`,
+	);
+	const res2 = await diffDefault(_, blob({ mode: 'string' }).default("text'text"), `('text''text')`);
+	const res2_1 = await diffDefault(
+		_,
+		blob().default(Buffer.from("text'text")),
+		`(0x${Buffer.from("text'text").toString('hex')})`,
+	);
+	const res3 = await diffDefault(_, blob({ mode: 'string' }).default('text\'text"'), `('text''text"')`);
+	const res3_1 = await diffDefault(
+		_,
+		blob().default(Buffer.from('text\'text"')),
+		`(0x${Buffer.from('text\'text"').toString('hex')})`,
+	);
+
+	// expressions
+	const res4 = await diffDefault(_, blob().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res3_1).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('longblob', async () => {
+	const res1 = await diffDefault(_, longblob({ mode: 'string' }).default('text'), `('text')`);
+	const res1_1 = await diffDefault(
+		_,
+		longblob().default(Buffer.from('text')),
+		`(0x${Buffer.from('text').toString('hex')})`,
+	);
+	const res2 = await diffDefault(_, longblob({ mode: 'string' }).default("text'text"), `('text''text')`);
+	const res2_1 = await diffDefault(
+		_,
+		longblob().default(Buffer.from("text'text")),
+		`(0x${Buffer.from("text'text").toString('hex')})`,
+	);
+	const res3 = await diffDefault(_, longblob({ mode: 'string' }).default('text\'text"'), `('text''text"')`);
+	const res3_1 = await diffDefault(
+		_,
+		longblob().default(Buffer.from('text\'text"')),
+		`(0x${Buffer.from('text\'text"').toString('hex')})`,
+	);
+
+	// expressions
+	const res4 = await diffDefault(_, longblob().default(sql`('hello' + ' world')`), "('hello' + ' world')");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res3_1).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('enum', async () => {
+	const res1 = await diffDefault(
+		_,
+		mysqlEnum(['sad', 'ok', 'happy']).default('ok'),
+		`'ok'`,
+		null,
+		{
+			type: `enum('sad','ok','happy')`,
+		},
+	);
+	const res2 = await diffDefault(_, mysqlEnum(["'"]).default("'"), `''''`, null, { type: `enum('''')` });
+	const res3 = await diffDefault(_, mysqlEnum(['"']).default('"'), `'"'`, null, { type: `enum('"')` });
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('binary', async () => {
+	const res1 = await diffDefault(_, binary().default('binary'), `('binary')`);
+	const res2 = await diffDefault(_, binary({ length: 10 }).default('binary'), `('binary')`);
+	const res3 = await diffDefault(_, binary().default(sql`(lower('HELLO'))`), `(lower('HELLO'))`);
+	const res4 = await diffDefault(_, binary().default(sql`lower('HELLO')`), `(lower('HELLO'))`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('varbinary', async () => {
+	const res1 = await diffDefault(_, varbinary({ length: 10 }).default('binary'), `(0x62696e617279)`);
+	const res2 = await diffDefault(_, varbinary({ length: 16 }).default(sql`(lower('HELLO'))`), `(lower('HELLO'))`);
+	const res3 = await diffDefault(_, varbinary({ length: 16 }).default(sql`lower('HELLO')`), `(lower('HELLO'))`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('json', async () => {
+	const res1 = await diffDefault(_, json().default({}), `('{}')`);
+	const res2 = await diffDefault(_, json().default([]), `('[]')`);
+	const res3 = await diffDefault(_, json().default([1, 2, 3]), `('[1,2,3]')`);
+	const res4 = await diffDefault(_, json().default({ key: 'value' }), `('{"key":"value"}')`);
+	const res5 = await diffDefault(_, json().default({ key: "val'ue" }), `('{"key":"val''ue"}')`);
+	const res7 = await diffDefault(_, json().default({ key1: { key2: 'value' } }), `('{"key1":{"key2":"value"}}')`);
+
+	const res8 = await diffDefault(_, json().default({ key: 9223372036854775807n }), `('{"key":9223372036854775807}')`);
+	const res9 = await diffDefault(
+		_,
+		json().default(sql`'{"key":9223372036854775807}'`),
+		`('{"key":9223372036854775807}')`,
+	);
+	const res10 = await diffDefault(
+		_,
+		json().default([9223372036854775807n, 9223372036854775806n]),
+		`('[9223372036854775807,9223372036854775806]')`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2136
+test('timestamp', async () => {
+	const res1 = await diffDefault(_, timestamp({ mode: 'date' }).defaultNow(), `(now())`);
+	const res2 = await diffDefault(_, timestamp({ mode: 'string' }).defaultNow(), `(now())`);
+	const res3 = await diffDefault(
+		_,
+		timestamp({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+		null,
+		{ ignoreSubsequent: true },
+	);
+	const res4 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+	);
+
+	const res5 = await diffDefault(
+		_,
+		timestamp({ mode: 'string' }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115'`,
+		null,
+		{ ignoreSubsequent: true },
+	);
+	const res6 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', fsp: 3 }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	const res7 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', fsp: 6 }).default('2025-05-23 12:53:53.123456'),
+		`'2025-05-23 12:53:53.123456'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([
+		// without fsp timestamp column returns no .115
+		'Unexpected subsequent init:\n'
+		+ "ALTER TABLE `table` MODIFY COLUMN `column` timestamp DEFAULT '2025-05-23 12:53:53.115';",
+	]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([
+		// without fsp timestamp column returns no .115
+		'Unexpected subsequent init:\n'
+		+ "ALTER TABLE `table` MODIFY COLUMN `column` timestamp DEFAULT '2025-05-23 12:53:53.115';",
+	]);
+
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('datetime', async () => {
+	const res1 = await diffDefault(
+		_,
+		datetime({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+		null,
+		{ ignoreSubsequent: true },
+	);
+	const res2 = await diffDefault(
+		_,
+		datetime({ mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+	);
+
+	const res3 = await diffDefault(
+		_,
+		datetime({ mode: 'string' }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115'`,
+		null,
+		{ ignoreSubsequent: true },
+	);
+	const res4 = await diffDefault(
+		_,
+		datetime({ mode: 'string', fsp: 3 }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	const res5 = await diffDefault(
+		_,
+		datetime({ mode: 'string', fsp: 6 }).default('2025-05-23 12:53:53.123456'),
+		`'2025-05-23 12:53:53.123456'`,
+	);
+	const res6 = await diffDefault(
+		_,
+		datetime().default(sql`CURRENT_TIMESTAMP`),
+		`(CURRENT_TIMESTAMP)`,
+	);
+
+	// database datetime without precision does not return .115 fraction
+	expect.soft(res1).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ "ALTER TABLE `table` MODIFY COLUMN `column` datetime DEFAULT '2025-05-23 12:53:53.115';",
+	]);
+	expect.soft(res2).toStrictEqual([]);
+
+	// database datetime without precision does not return .115 fraction
+	expect.soft(res3).toStrictEqual([
+		'Unexpected subsequent init:\n'
+		+ "ALTER TABLE `table` MODIFY COLUMN `column` datetime DEFAULT '2025-05-23 12:53:53.115';",
+	]);
+
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('time', async () => {
+	const res1 = await diffDefault(_, time().default('15:50:33'), `'15:50:33'`);
+	const res2 = await diffDefault(
+		_,
+		time({ fsp: 3 }).default('15:50:33.123'),
+		`'15:50:33.123'`,
+	);
+
+	const res3 = await diffDefault(
+		_,
+		time({ fsp: 6 }).default('15:50:33.123456'),
+		`'15:50:33.123456'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('date', async () => {
+	const res1 = await diffDefault(_, date({ mode: 'string' }).default('2025-05-23'), `'2025-05-23'`);
+	const res2 = await diffDefault(_, date({ mode: 'date' }).default(new Date('2025-05-23')), `'2025-05-23'`);
+	const res3 = await diffDefault(
+		_,
+		date({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+});
+
+test('year', async () => {
+	const res1 = await diffDefault(_, year().default(2025), `2025`);
+	const res2 = await diffDefault(_, year().default(sql`2025`), `(2025)`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+});
+
+test.skip('corner cases', async () => {
+	await diffDefault(_, json().default({ key: 'mo",\\`}{od' }), `('{"key":"mo\\\\",\\\\\\\\\`}{od"}'))`);
+	await diffDefault(
+		_,
+		mysqlEnum(['sad', 'ok', 'happy', 'mo",\\`}{od']).default('mo",\\`}{od'),
+		`'mo",\\\\\`}{od'`,
+		null,
+		{ type: `enum('sad','ok','happy','mo",\\\\\`}{od')` },
+	);
+
+	await diffDefault(_, longtext().default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	await diffDefault(
+		_,
+		longtext({ enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+
+	await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+	await diffDefault(_, text().default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	await diffDefault(
+		_,
+		mediumtext({ enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+	await diffDefault(_, mediumtext().default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	await diffDefault(
+		_,
+		tinytext({ enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+	await diffDefault(_, tinytext().default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	await diffDefault(
+		_,
+		varchar({ length: 15, enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+	await diffDefault(_, varchar({ length: 15 }).default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	await diffDefault(
+		_,
+		char({ length: 15, enum: ['one', 'two', 'three', 'mo",\\`}{od'] }).default('mo",\\`}{od'),
+		`('mo",\\\`}{od')`,
+	);
+	await diffDefault(_, char({ length: 15 }).default('mo",\\`}{od'), `('mo",\\\`}{od')`);
+
+	// raw sql for the line below: create table `table` (`column` json default ('{"key1":{"key2":"mo\\\",\\\\`}{od"}}'));
+	await diffDefault(
+		_,
+		json().default({ key1: { key2: 'mo",\\`}{od' } }),
+		`('{"key1":{"key2":"mo\\\\",\\\\\\\\\`}{od"}}')`,
+	);
+});
diff --git a/drizzle-kit/tests/mysql/mysql-enum.test.ts b/drizzle-kit/tests/mysql/mysql-enum.test.ts
new file mode 100644
index 0000000000..a4b96bdacd
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-enum.test.ts
@@ -0,0 +1,79 @@
+import { int, mysqlEnum, mysqlTable, varchar } from 'drizzle-orm/mysql-core';
+import { Decimal, parseEnum } from 'src/dialects/mysql/grammar';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, diffIntrospect, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+if (!fs.existsSync('tests/mysql/tmp')) {
+	fs.mkdirSync('tests/mysql/tmp', { recursive: true });
+}
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3613
+test('enum', async () => {
+	const ORDER_STATUSES = [
+		'Ny',
+		'Bestilling sendt',
+		'Sendt til leverandør(er)',
+		'Mottatt av leverandør(er)',
+		'Behandlet av leverandør(er)',
+		'Under behandling',
+		'Noe gikk galt',
+	] as const;
+	const schema1 = {
+		table: mysqlTable('table', {
+			status: mysqlEnum('status', ORDER_STATUSES).default('Sendt til leverandør(er)'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0: string[] = [
+		"CREATE TABLE `table` (\n\t`status` enum('Ny','Bestilling sendt','Sendt til leverandør(er)','Mottatt av leverandør(er)','Behandlet av leverandør(er)','Under behandling','Noe gikk galt') DEFAULT 'Sendt til leverandør(er)'\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop enum value. column of enum type; drop default', async () => {
+	const from = {
+		table: mysqlTable('table', {
+			column: mysqlEnum('column', ['value1', 'value2', 'value3']).default('value2'),
+		}),
+	};
+
+	const to = {
+		table: mysqlTable('table', {
+			column: mysqlEnum('column', ['value1', 'value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		"ALTER TABLE `table` MODIFY COLUMN `column` enum('value1','value3');",
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mysql/mysql-generated.test.ts b/drizzle-kit/tests/mysql/mysql-generated.test.ts
new file mode 100644
index 0000000000..aa5663654f
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-generated.test.ts
@@ -0,0 +1,1116 @@
+import { SQL, sql } from 'drizzle-orm';
+import { int, mysqlTable, text } from 'drizzle-orm/mysql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2616
+test('generated as callback: create table with generated constraint #1', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			name: text('name'),
+			generatedName: text('gen_name').notNull().generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"CREATE TABLE `users` (\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED NOT NULL\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// TODO
+// why to use generated with literal?
+// Looks like invalid use case
+test.skip('generated as callback: create table with generated constraint #2', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			name: text('name'),
+			generatedName: text('gen_name').notNull().generatedAlwaysAs(sql`'Default'`, { mode: 'stored' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"CREATE TABLE `users` (\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ('Default') STORED NOT NULL\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add column with generated constraint #1', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add column with generated constraint #2', async () => {
+	const schema1 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const schema2 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+			generatedName1: text('gen_name1').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+		"ALTER TABLE `users` ADD `gen_name1` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraints to an exisiting columns', async () => {
+	const schema1 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+			generatedName1: text('gen_name1'),
+		}),
+	};
+	const schema2 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+			generatedName1: text('gen_name1').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+		'ALTER TABLE `users` DROP COLUMN `gen_name1`;',
+		"ALTER TABLE `users` ADD `gen_name1` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint', async () => {
+	const schema1 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name}`,
+				{ mode: 'stored' },
+			),
+			generatedName1: text('gen_name1').generatedAlwaysAs(
+				(): SQL => sql`${schema2.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const schema2 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+			generatedName1: text('gen_name1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
+		'ALTER TABLE `users` DROP COLUMN `gen_name1`;',
+		'ALTER TABLE `users` ADD `gen_name1` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['ALTER TABLE `users` MODIFY COLUMN `gen_name` text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as callback: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as callback: change generated constraint #1', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as callback: change generated constraint #2', async () => {
+	const schema1 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			gen1: text().generatedAlwaysAs((): SQL => sql`${schema1.users.id}`, { mode: 'stored' }),
+			gen2: text().generatedAlwaysAs((): SQL => sql`${schema1.users.id}`, { mode: 'virtual' }),
+		}),
+	};
+
+	const schema2 = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			gen1: text().generatedAlwaysAs((): SQL => sql`${schema2.users.id} || 'hello'`, { mode: 'stored' }),
+			gen2: text().generatedAlwaysAs((): SQL => sql`${schema2.users.id} || 'hello'`, { mode: 'virtual' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen1`;',
+		"ALTER TABLE `users` ADD `gen1` text GENERATED ALWAYS AS (`users`.`id` || 'hello') STORED;",
+		'ALTER TABLE `users` DROP COLUMN `gen2`;',
+		"ALTER TABLE `users` ADD `gen2` text GENERATED ALWAYS AS (`users`.`id` || 'hello') VIRTUAL;",
+	];
+	expect.soft(st).toStrictEqual(st0);
+	expect.soft(pst).toStrictEqual([]);
+});
+
+// ---
+
+test('generated as sql: add column with generated constraint', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['ALTER TABLE `users` MODIFY COLUMN `gen_name` text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as sql: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as sql: change generated constraint', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+// ---
+
+test('generated as string: add column with generated constraint', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as string: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as string: change generated constraint', async () => {
+	const from = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``),
+		}),
+	};
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('generated as string: with backslashes', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`'users\\\\hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`users\` (
+	\`id\` int,
+	\`id2\` int,
+	\`name\` text,
+	\`gen_name\` text GENERATED ALWAYS AS ('users\\\\hello') VIRTUAL
+);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mysql/mysql-schemas.test.ts b/drizzle-kit/tests/mysql/mysql-schemas.test.ts
new file mode 100644
index 0000000000..2a82b74f15
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-schemas.test.ts
@@ -0,0 +1,219 @@
+import { int, mysqlSchema, mysqlTable } from 'drizzle-orm/mysql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// We don't manage databases(schemas) in MySQL with Drizzle Kit
+test('add schema #1', async () => {
+	const to = {
+		devSchema: mysqlSchema('dev'),
+	};
+
+	const { statements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add schema #2', async () => {
+	const from = {
+		devSchema: mysqlSchema('dev'),
+	};
+	const to = {
+		devSchema: mysqlSchema('dev'),
+		devSchema2: mysqlSchema('dev2'),
+	};
+
+	const { statements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #1', async () => {
+	const from = {
+		devSchema: mysqlSchema('dev'),
+	};
+
+	const { statements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: {} });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #2', async () => {
+	const from = {
+		devSchema: mysqlSchema('dev'),
+		devSchema2: mysqlSchema('dev2'),
+	};
+	const to = {
+		devSchema: mysqlSchema('dev'),
+	};
+
+	const { statements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: {} });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename schema #1', async () => {
+	const from = {
+		devSchema: mysqlSchema('dev'),
+	};
+	const to = {
+		devSchema2: mysqlSchema('dev2'),
+	};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename schema #2', async () => {
+	const from = {
+		devSchema: mysqlSchema('dev'),
+		devSchema1: mysqlSchema('dev1'),
+	};
+	const to = {
+		devSchema: mysqlSchema('dev'),
+		devSchema2: mysqlSchema('dev2'),
+	};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table to schema #1', async () => {
+	const dev = mysqlSchema('dev');
+	const from = {};
+	const to = {
+		dev,
+		users: dev.table('users', {}),
+	};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table to schema #2', async () => {
+	const dev = mysqlSchema('dev');
+	const from = { dev };
+	const to = {
+		dev,
+		users: dev.table('users', {}),
+	};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table to schema #3', async () => {
+	const dev = mysqlSchema('dev');
+	const from = { dev };
+	const to = {
+		dev,
+		usersInDev: dev.table('users', {}),
+		users: mysqlTable('users', { id: int() }),
+	};
+
+	const renames = ['dev->dev2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['CREATE TABLE `users` (\n\t`id` int\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('remove table from schema #1', async () => {
+	const dev = mysqlSchema('dev');
+	const from = { dev, users: dev.table('users', {}) };
+	const to = {
+		dev,
+	};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('remove table from schema #2', async () => {
+	const dev = mysqlSchema('dev');
+	const from = { dev, users: dev.table('users', {}) };
+	const to = {};
+
+	const renames = ['dev->dev2'];
+	const { statements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/mysql/mysql-views.test.ts b/drizzle-kit/tests/mysql/mysql-views.test.ts
new file mode 100644
index 0000000000..cf3060038a
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql-views.test.ts
@@ -0,0 +1,725 @@
+import { eq, sql } from 'drizzle-orm';
+import { int, mysqlTable, mysqlView, text } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create view #1', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE ALGORITHM = undefined SQL SECURITY definer VIEW \`some_view\` AS (select \`id\` from \`users\`);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view #2', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE ALGORITHM = merge SQL SECURITY definer VIEW \`some_view\` AS (SELECT * FROM \`users\`) WITH cascaded CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view #3', async () => {
+	const users = mysqlTable('users', {
+		id: int().primaryKey().notNull(),
+		name: text(),
+	});
+	const posts = mysqlTable('posts', {
+		id: int().primaryKey(),
+		content: text(),
+		userId: int().references(() => users.id),
+	});
+
+	const from = { users, posts };
+	const to = {
+		users,
+		posts,
+		view: mysqlView('some_view').as((qb) => {
+			return qb.select({ userId: sql`${users.id}`.as('user'), postId: sql`${posts.id}`.as('post') }).from(users)
+				.leftJoin(
+					posts,
+					eq(posts.userId, users.id),
+				);
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+
+	await db.query(`INSERT INTO \`users\` (\`id\`, \`name\`) VALUE (1, 'Alex'), (2, 'Andrew')`);
+	await db.query(
+		`INSERT INTO \`posts\` (\`id\`, \`content\`, \`userId\`) VALUE (1, 'alex-content', 1), (3, 'andrew-content', 2)`,
+	);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE ALGORITHM = undefined SQL SECURITY definer VIEW \`some_view\` AS (select \`users\`.\`id\` as \`user\`, \`posts\`.\`id\` as \`post\` from \`users\` left join \`posts\` on \`posts\`.\`userId\` = \`users\`.\`id\`);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int(),
+	});
+
+	const from = {
+		users: users,
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #1', async () => {
+	const users = mysqlTable('users', {
+		id: int('id'),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = { users: users };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [`DROP VIEW \`some_view\`;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #2', async () => {
+	const table = mysqlTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: mysqlView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['DROP VIEW \`view\`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id'),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).existing(),
+	};
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const renames = ['some_view->new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [`RENAME TABLE \`some_view\` TO \`new_some_view\`;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view and alter meta options', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view1: mysqlView('view1', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+		view2: mysqlView('view2', {}).algorithm('undefined').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('view1new', {}).sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+		view2: mysqlView('view2new', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const renames = ['view1->view1new', 'view2->view2new'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	/*
+		UNDEFINED lets the server pick at execution time (often it still runs as a merge if the query is “mergeable”).
+		Specifying MERGE when it’s not possible causes MySQL to store UNDEFINED with a warning,
+		but the reverse (forcing UNDEFINED to overwrite MERGE) doesn’t happen via ALTER.
+
+		https://dev.mysql.com/doc/refman/8.4/en/view-algorithms.html
+	*/
+	const st0: string[] = [
+		'RENAME TABLE `view1` TO `view1new`;',
+		'RENAME TABLE `view2` TO `view2new`;',
+		`ALTER ALGORITHM = merge SQL SECURITY definer VIEW \`view2new\` AS SELECT * FROM \`users\` WITH cascaded CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+
+	const renames = ['some_view->new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add meta to view', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER ALGORITHM = merge SQL SECURITY definer VIEW \`some_view\` AS SELECT * FROM \`users\` WITH cascaded CHECK OPTION;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add meta to view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('push: alter meta to view', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER ALGORITHM = merge SQL SECURITY definer VIEW \`some_view\` AS SELECT * FROM \`users\` WITH cascaded CHECK OPTION;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('diff: alter meta to view', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const st0: string[] = [
+		'ALTER ALGORITHM = merge SQL SECURITY definer VIEW \`some_view\` AS SELECT * FROM \`users\` WITH cascaded CHECK OPTION;',
+	];
+	expect(st).toStrictEqual(st0);
+});
+
+test('diff: alter meta to view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
+			.withCheckOption('cascaded').existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+});
+
+test('push: alter meta to view with existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop meta from view', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER ALGORITHM = undefined SQL SECURITY definer VIEW \`some_view\` AS SELECT * FROM \`users\`;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop meta from view existing flag', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('definer')
+			.withCheckOption('cascaded').existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('diff: alter view ".as" value', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('temptable').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const st0: string[] = [
+		`CREATE OR REPLACE ALGORITHM = temptable SQL SECURITY invoker VIEW \`some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1) WITH cascaded CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+});
+
+test('push: alter view ".as" value', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE OR REPLACE ALGORITHM = merge SQL SECURITY invoker VIEW \`some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1) WITH cascaded CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // Do not trigger definition changes on push
+});
+
+test('alter view ".as"', async () => {
+	const table = mysqlTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: mysqlView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: mysqlView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE OR REPLACE ALGORITHM = undefined SQL SECURITY definer VIEW `view` AS (select `id` from `test`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // do not trigger definition changes on push
+});
+
+test('rename and alter view ".as" value', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users} WHERE ${users.id} = 1`),
+	};
+
+	const renames = ['some_view->new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		`RENAME TABLE \`some_view\` TO \`new_some_view\`;`,
+		`CREATE OR REPLACE ALGORITHM = merge SQL SECURITY invoker VIEW \`new_some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1) WITH cascaded CHECK OPTION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(['RENAME TABLE \`some_view\` TO \`new_some_view\`;']); // do not trigger definition chages on push
+});
+
+test('set existing', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').as(sql`SELECT * FROM ${users}`),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('invoker')
+			.withCheckOption('cascaded').existing(),
+	};
+
+	const { sqlStatements: st1 } = await diff(from, to, []);
+	const renames = [`some_view->new_some_view`];
+	const { sqlStatements: st2 } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst1 } = await push({ db, to });
+
+	// TODO: revise
+	await _.clear();
+	await push({ db, to: from });
+	const { sqlStatements: pst2 } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		`DROP VIEW \`some_view\`;`,
+	];
+	expect(st1).toStrictEqual(st0);
+	expect(st2).toStrictEqual(st0);
+	expect(pst1).toStrictEqual(st0);
+	expect(pst2).toStrictEqual(st0);
+});
+
+test('drop existing', async () => {
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users: users,
+		view: mysqlView('some_view', {}).algorithm('merge').sqlSecurity('invoker').existing(),
+	};
+	const to = {
+		users: users,
+		view: mysqlView('new_some_view', {}).algorithm('merge').sqlSecurity('invoker').as(
+			sql`SELECT * FROM ${users} WHERE ${users.id} = 1`,
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE ALGORITHM = merge SQL SECURITY invoker VIEW \`new_some_view\` AS (SELECT * FROM \`users\` WHERE \`users\`.\`id\` = 1);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4520
+test('create 2 dependent views', async () => {
+	const table1 = mysqlTable('table1', {
+		col1: int(),
+		col2: int(),
+		col3: int(),
+	});
+	const accountBalancesPMMV = mysqlView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = mysqlView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`col1` int,\n\t`col2` int,\n\t`col3` int\n);\n',
+		'CREATE ALGORITHM = undefined SQL SECURITY definer VIEW `accountBalancesPM` AS (select `col1`, `col2`, `col3` from `table1`);',
+		'CREATE ALGORITHM = undefined SQL SECURITY definer VIEW `accountBalances` AS (select `col1` from `accountBalancesPM`);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/mysql/mysql.test.ts b/drizzle-kit/tests/mysql/mysql.test.ts
new file mode 100644
index 0000000000..e38796f2d5
--- /dev/null
+++ b/drizzle-kit/tests/mysql/mysql.test.ts
@@ -0,0 +1,2263 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	binary,
+	blob,
+	boolean,
+	camelCase,
+	char,
+	customType,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	foreignKey,
+	index,
+	int,
+	json,
+	longblob,
+	longtext,
+	mediumblob,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	primaryKey,
+	serial,
+	smallint,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	tinyblob,
+	tinyint,
+	tinytext,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+fs.mkdirSync('./tests/mysql/migrations', { recursive: true });
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+let client: TestDatabase['client'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+	client = _.client;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add table #1', async () => {
+	const to = {
+		users: mysqlTable('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE TABLE `users` (\n\t`id` int\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #2', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` serial PRIMARY KEY\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #3', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			id: serial('id'),
+			test: varchar('test', { length: 1 }),
+		}, (t) => [
+			primaryKey({
+				columns: [t.id, t.test],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` serial,\n\t`test` varchar(1),\n\tCONSTRAINT PRIMARY KEY(`id`,`test`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #4', async () => {
+	const to = {
+		users: mysqlTable('users', { id: int() }),
+		posts: mysqlTable('posts', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` int\n);\n',
+		'CREATE TABLE `posts` (\n\t`id` int\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #5', async () => {
+	const schema = mysqlSchema('folder');
+	const from = {
+		schema,
+	};
+
+	const to = {
+		schema,
+		users: schema.table('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #6', async () => {
+	const from = {
+		users1: mysqlTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users2: mysqlTable('users2', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users2` (\n\t`id` int\n);\n',
+		'DROP TABLE `users1`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3539
+test('add table #7', async () => {
+	const from = {
+		users1: mysqlTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users: mysqlTable('users', { id: int() }),
+		users2: mysqlTable('users2', { id: int() }),
+	};
+
+	const renames = ['users1->users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` int\n);\n',
+		'RENAME TABLE `users1` TO `users2`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2599
+test('drop + add table', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2: int(),
+		}, (table) => [
+			index('unique-index1').on(table.column2),
+		]),
+	};
+
+	const schema2 = {
+		table2: mysqlTable('table2', {
+			column1: int().primaryKey(),
+			column2: int(),
+		}, (table) => [
+			index('unique-index2').on(table.column2),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY,\n\t`column2` int\n);\n',
+		'CREATE INDEX `unique-index1` ON `table1` (`column2`);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'CREATE TABLE `table2` (\n\t`column1` int PRIMARY KEY,\n\t`column2` int\n);\n',
+		'DROP TABLE `table1`;',
+		'CREATE INDEX `unique-index2` ON `table2` (`column2`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456
+test('drop tables with fk constraint', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int().primaryKey(),
+		column2: int().references(() => table1.column1),
+	});
+	const schema1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int PRIMARY KEY,\n\t`column2` int\n);\n',
+		'ALTER TABLE \`table2\` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, {}, []);
+	const { sqlStatements: pst2 } = await push({ db, to: {} });
+
+	const expectedSt2 = [
+		'ALTER TABLE `table2` DROP CONSTRAINT `table2_column2_table1_column1_fkey`;',
+		'DROP TABLE `table1`;',
+		'DROP TABLE `table2`;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('add schema + table #1', async () => {
+	const schema = mysqlSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change schema with tables #1', async () => {
+	const schema = mysqlSchema('folder');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = ['folder->folder2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #1', async () => {
+	const schema = mysqlSchema('folder');
+	const from = {
+		schema,
+		users: mysqlTable('users', { id: int() }),
+	};
+	const to = {
+		schema,
+		users: schema.table('users', { id: int() }),
+	};
+
+	const renames = ['users->folder.users'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['DROP TABLE `users`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #2', async () => {
+	const schema = mysqlSchema('folder');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema,
+		users: mysqlTable('users', { id: int() }),
+	};
+
+	const renames = ['folder.users->users'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['CREATE TABLE `users` (\n\t`id` int\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #3', async () => {
+	const schema1 = mysqlSchema('folder1');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = ['folder1.users->folder2.users'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #4', async () => {
+	const schema1 = mysqlSchema('folder1');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = ['folder1.users->folder2.users'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = mysqlSchema('folder1');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema1, // remove schema
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = ['folder1.users->folder2.users'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = mysqlSchema('folder1');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users2', {}), // rename and move table
+	};
+
+	const renames = ['folder1.users->folder2.users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #6', async () => {
+	const schema1 = mysqlSchema('folder1');
+	const schema2 = mysqlSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', { id: int() }),
+	};
+	const to = {
+		schema2, // rename schema
+		users: schema2.table('users2', { id: int() }), // rename table
+	};
+
+	const renames = ['folder1->folder2', 'folder2.users->folder2.users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #10', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			json: json('json').default({}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('{}')\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #11', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			json: json('json').default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('[]')\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #12', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			json: json('json').default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT ('[1,2,3]')\n);\n",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #13', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			json: json('json').default({ key: 'value' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`json` json DEFAULT (\'{"key":"value"}\')\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #14', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			json: json('json').default({
+				key: 'value',
+				arr: [1, 2, 3],
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`json` json DEFAULT (\'{"key":"value","arr":[1,2,3]}\')\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/472
+// https://github.com/drizzle-team/drizzle-orm/issues/3373
+test('add table #15. timestamp + fsp + default now + on update now + fsp', async () => {
+	// TODO: revise: maybe .onUpdateNow should be able to get fsp from timestamp config.
+	// Because fsp in timestamp config and onUpdateNow config should be the same for query to run successfully.
+	// It might also be helpfull to add fsp field to .defaultNow config,
+	// since setting now() as default without specifying fsp caused an error on PlanetScale (issue 472).
+	const to = {
+		users: mysqlTable('table', {
+			createdAt: timestamp({ fsp: 4 }).defaultNow().onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`createdAt` timestamp(4) DEFAULT (now()) ON UPDATE CURRENT_TIMESTAMP(4)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #16. timestamp + on update now + fsp', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			createdAt: timestamp().onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	// TODO: revise: shouldn't diff also throw an error?
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`createdAt` timestamp ON UPDATE CURRENT_TIMESTAMP(4)\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('add table #17. timestamp + fsp + on update now', async () => {
+	const to = {
+		users: mysqlTable('table', {
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow(),
+		}),
+	};
+
+	// TODO: revise: shouldn't diff also throw an error?
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`createdAt` timestamp(4) ON UPDATE CURRENT_TIMESTAMP\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2180
+test('add table #18. serial + primary key, timestamp + default with sql``', async () => {
+	const to = {
+		table1: mysqlTable('table1', {
+			column1: serial().primaryKey(),
+			column2: timestamp().notNull().default(sql`CURRENT_TIMESTAMP`),
+		}),
+	};
+
+	// TODO: revise: the sql`` passed to .default() may not need parentheses
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt = [
+		'CREATE TABLE `table1` (\n\t`column1` serial PRIMARY KEY,\n\t`column2` timestamp NOT NULL DEFAULT (CURRENT_TIMESTAMP)\n);\n',
+	];
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+test('add table #19. timestamp + default with sql``', async () => {
+	const to = {
+		table1: mysqlTable('table1', {
+			column1: timestamp().notNull().defaultNow().onUpdateNow(),
+			column2: timestamp().notNull().default(sql`(CURRENT_TIMESTAMP)`).onUpdateNow(),
+			// column3: timestamp().notNull().default(sql`CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP`),
+		}),
+	};
+
+	// TODO: revise: the sql`` passed to .default() may not need parentheses
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt = [
+		'CREATE TABLE `table1` (\n\t'
+		+ '`column1` timestamp NOT NULL DEFAULT (now()) ON UPDATE CURRENT_TIMESTAMP,\n\t'
+		+ '`column2` timestamp NOT NULL DEFAULT (CURRENT_TIMESTAMP) ON UPDATE CURRENT_TIMESTAMP\n);\n',
+	];
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2599
+// https://github.com/drizzle-team/drizzle-orm/issues/3359
+// https://github.com/drizzle-team/drizzle-orm/issues/1413
+// https://github.com/drizzle-team/drizzle-orm/issues/3473
+// https://github.com/drizzle-team/drizzle-orm/issues/2815
+test('add table #20. table already exists; multiple pk defined', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement().primaryKey(),
+			column2: varchar({ length: 256 }).notNull().unique(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int().autoincrement(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1] }),
+		]),
+		table3: mysqlTable('table3', {
+			column1: int(),
+			column2: int(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int AUTO_INCREMENT PRIMARY KEY,\n\t`column2` varchar(256) NOT NULL,'
+		+ '\n\tCONSTRAINT `column2_unique` UNIQUE INDEX(`column2`)\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int AUTO_INCREMENT PRIMARY KEY\n);\n',
+		'CREATE TABLE `table3` (\n\t`column1` int,\n\t`column2` int,\n\t'
+		+ 'CONSTRAINT PRIMARY KEY(`column1`,`column2`)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	const expectedSt2: string[] = [];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1742
+test('add table #21. table with hyphen in identifiers', async () => {
+	const schema1 = {
+		'table-1': mysqlTable('table-1', {
+			'column-1': int('column-1'),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table-1` (\n\t`column-1` int\n);\n',
+	];
+
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		'table-1': mysqlTable('table-1', {
+			'column-1': int('column-1').notNull(),
+		}),
+	};
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE `table-1` MODIFY COLUMN `column-1` int NOT NULL;',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/818
+test('add table #22. custom type; default', async () => {
+	interface Semver {
+		major: number;
+		minor: number;
+		patch: number;
+	}
+	const semver = customType<{
+		data: Semver;
+		driverData: string;
+		config: { length: number };
+		configRequired: true;
+	}>({
+		dataType(config) {
+			return `varchar(${config.length})`;
+		},
+		fromDriver(value: string): Semver {
+			const [major, minor, patch] = value.split('.');
+			if (!major || !minor || !patch) {
+				throw new Error(`Invalid semver: ${value}`);
+			}
+			return {
+				major: parseInt(major),
+				minor: parseInt(minor),
+				patch: parseInt(patch),
+			};
+		},
+		toDriver(value: Semver): string {
+			return `${value.major}.${value.minor}.${value.patch}`;
+		},
+	});
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: semver({ length: 12 }).default({ major: 0, minor: 0, patch: 0 }),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		"CREATE TABLE `table1` (\n\t`column1` varchar(12) DEFAULT '0.0.0'\n);\n",
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	const expectedSt2: string[] = [];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/364
+test('add column #1. timestamp + fsp + on update now + fsp', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `createdAt` timestamp(4) ON UPDATE CURRENT_TIMESTAMP(4);',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column #2. timestamp + on update now + fsp', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp().onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `createdAt` timestamp ON UPDATE CURRENT_TIMESTAMP(4);',
+	];
+
+	expect(st).toStrictEqual(st0);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('add column #3. timestamp + fsp + on update now', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `createdAt` timestamp(4) ON UPDATE CURRENT_TIMESTAMP;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	await expect(push({ db, to })).rejects.toThrowError();
+});
+
+test('modify on update now fsp #1', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow({ fsp: 4 }),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp().onUpdateNow(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await diff(from, to, []);
+
+	const st0: string[] = [
+		'ALTER TABLE `table` MODIFY COLUMN `createdAt` timestamp ON UPDATE CURRENT_TIMESTAMP;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('modify on update now fsp #2', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp().onUpdateNow(),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` MODIFY COLUMN `createdAt` timestamp(4) ON UPDATE CURRENT_TIMESTAMP(4);',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('modify on update now fsp #3', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 2 }).onUpdateNow({ fsp: 2 }),
+		}),
+	};
+	const to = {
+		users: mysqlTable('table', {
+			id: int(),
+			createdAt: timestamp({ fsp: 4 }).onUpdateNow({ fsp: 4 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` MODIFY COLUMN `createdAt` timestamp(4) ON UPDATE CURRENT_TIMESTAMP(4);',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/998
+test('drop index', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			name: varchar({ length: 10 }),
+		}, (t) => [
+			index('name_idx').on(t.name),
+		]),
+	};
+
+	const to = {
+		users: mysqlTable('table', {
+			name: varchar({ length: 10 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['DROP INDEX `name_idx` ON `table`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop unique constraint', async () => {
+	const from = {
+		users: mysqlTable('table', {
+			name: varchar({ length: 10 }),
+		}, (t) => [unique('name_uq').on(t.name)]),
+	};
+
+	const to = {
+		users: mysqlTable('table', {
+			name: varchar({ length: 10 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'DROP INDEX `name_uq` ON `table`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1888
+test('add table with indexes', async () => {
+	const from = {};
+
+	const to = {
+		users: mysqlTable('users', {
+			id: serial().primaryKey(),
+			name: varchar({ length: 100 }),
+			email: varchar({ length: 100 }),
+			column4: varchar({ length: 100 }),
+		}, (t) => [
+			uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
+			index('indexExpr').on(sql`(lower(${t.email}))`),
+			index('indexExprMultiple').on(sql`(lower(${t.email}))`, sql`(lower(${t.email}))`),
+			uniqueIndex('uniqueCol').on(t.email),
+			index('indexCol').on(t.email),
+			index('indexColMultiple').on(t.email, t.name),
+			index('indexColExpr').on(sql`(lower(${t.email}))`, t.email),
+			index('indexCol4Hash').on(sql`(lower(${t.column4}))`).using('hash'),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`users\` (\n\t\`id\` serial PRIMARY KEY,`
+		+ `\n\t\`name\` varchar(100),\n\t\`email\` varchar(100),\n\t\`column4\` varchar(100),`
+		+ `\n\tCONSTRAINT \`uniqueExpr\` UNIQUE INDEX((lower(\`email\`))),\n\tCONSTRAINT \`uniqueCol\` UNIQUE INDEX(\`email\`)\n);\n`,
+		'CREATE INDEX `indexExpr` ON `users` ((lower(`email`)));',
+		'CREATE INDEX `indexExprMultiple` ON `users` ((lower(`email`)),(lower(`email`)));',
+		'CREATE INDEX `indexCol` ON `users` (`email`);',
+		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`name`);',
+		'CREATE INDEX `indexColExpr` ON `users` ((lower(`email`)),`email`);',
+		'CREATE INDEX `indexCol4Hash` ON `users` ((lower(`column4`)));',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2122
+test('varchar and text default values escape single quotes', async (t) => {
+	const schema1 = {
+		table: mysqlTable('table', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: mysqlTable('table', {
+			id: serial('id').primaryKey(),
+			enum: mysqlEnum('enum', ["escape's quotes", "escape's quotes 2"]).default("escape's quotes"),
+			text: text('text').default("escape's quotes"),
+			varchar: varchar('varchar', { length: 255 }).default("escape's quotes"),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		"ALTER TABLE `table` ADD `enum` enum('escape''s quotes','escape''s quotes 2') DEFAULT 'escape''s quotes';",
+		"ALTER TABLE `table` ADD `text` text DEFAULT ('escape''s quotes');",
+		"ALTER TABLE `table` ADD `varchar` varchar(255) DEFAULT 'escape''s quotes';",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('default on serail', async (t) => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: serial().default(1),
+		}),
+	};
+
+	const { ddl1Err, ddl2Err, mappedErrors1, mappedErrors2 } = await diff({}, schema1, []);
+	expect(ddl1Err).toStrictEqual([]);
+	expect(ddl2Err).toStrictEqual([
+		{
+			column: 'column1',
+			table: 'table1',
+			type: 'column_unsupported_default_on_autoincrement',
+		},
+	]);
+	await expect(push({ db, to: schema1 })).rejects.toThrowError();
+});
+
+test('default on autoincrement', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement().default(1),
+		}),
+	};
+
+	const { ddl1Err, ddl2Err, mappedErrors1, mappedErrors2 } = await diff({}, schema1, []);
+	expect(ddl1Err).toStrictEqual([]);
+	expect(ddl2Err).toStrictEqual([
+		{
+			column: 'column1',
+			table: 'table1',
+			type: 'column_unsupported_default_on_autoincrement',
+		},
+	]);
+	await expect(push({ db, to: schema1 })).rejects.toThrowError();
+});
+
+test('composite primary key #1', async () => {
+	const from = {};
+	const to = {
+		table: mysqlTable('works_to_creators', {
+			workId: int().notNull(),
+			creatorId: int().notNull(),
+			classification: varchar({ length: 10 }).notNull(),
+		}, (t) => [
+			primaryKey({
+				columns: [t.workId, t.creatorId, t.classification],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `works_to_creators` (\n\t`workId` int NOT NULL,\n\t`creatorId` int NOT NULL,\n\t`classification` varchar(10) NOT NULL,\n\tCONSTRAINT PRIMARY KEY(`workId`,`creatorId`,`classification`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('composite primary key #2', async () => {
+	const schema1 = {};
+
+	const schema2 = {
+		table: mysqlTable('table', {
+			col1: int('col1').notNull(),
+			col2: int('col2').notNull(),
+		}, (t) => [
+			primaryKey({
+				columns: [t.col1, t.col2],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`col1` int NOT NULL,\n\t`col2` int NOT NULL,\n\tCONSTRAINT PRIMARY KEY(`col1`,`col2`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table with composite primary key', async () => {
+	const productsCategoriesTable = (tableName: string) => {
+		return mysqlTable(tableName, {
+			productId: varchar('product_id', { length: 10 }).notNull(),
+			categoryId: varchar('category_id', { length: 10 }).notNull(),
+		}, (t) => [
+			primaryKey({
+				columns: [t.productId, t.categoryId],
+			}),
+		]);
+	};
+
+	const schema1 = {
+		table: productsCategoriesTable('products_categories'),
+	};
+	const schema2 = {
+		test: productsCategoriesTable('products_to_categories'),
+	};
+
+	const renames = ['products_categories->products_to_categories'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'RENAME TABLE `products_categories` TO `products_to_categories`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/367
+test('optional db aliases (snake case)', async () => {
+	const from = {};
+
+	const t1 = snakeCase.table('t1', {
+		t1Id1: int().notNull().primaryKey(),
+		t1Col2: int().notNull(),
+		t1Col3: int().notNull(),
+		t2Ref: bigint({ mode: 'number', unsigned: true }).references(() => t2.t2Id),
+		t1Uni: int().notNull(),
+		t1UniIdx: int().notNull(),
+		t1Idx: int().notNull(),
+	}, (table) => [
+		unique('t1_uni').on(table.t1Uni),
+		uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
+		index('t1_idx').on(table.t1Idx),
+		foreignKey({
+			columns: [table.t1Col2, table.t1Col3],
+			foreignColumns: [t3.t3Id1, t3.t3Id2],
+		}),
+	]);
+
+	const t2 = snakeCase.table('t2', {
+		t2Id: serial().primaryKey(),
+	});
+
+	const t3 = snakeCase.table('t3', {
+		t3Id1: int(),
+		t3Id2: int(),
+	}, (table) => [primaryKey({
+		columns: [table.t3Id1, table.t3Id2],
+	})]);
+
+	const to = { t1, t2, t3 };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`t1\` (
+	\`t1_id1\` int PRIMARY KEY,
+	\`t1_col2\` int NOT NULL,
+	\`t1_col3\` int NOT NULL,
+	\`t2_ref\` bigint unsigned,
+	\`t1_uni\` int NOT NULL,
+	\`t1_uni_idx\` int NOT NULL,
+	\`t1_idx\` int NOT NULL,
+	CONSTRAINT \`t1_uni\` UNIQUE INDEX(\`t1_uni\`),
+	CONSTRAINT \`t1_uni_idx\` UNIQUE INDEX(\`t1_uni_idx\`)
+);\n`,
+		`CREATE TABLE \`t2\` (\n\t\`t2_id\` serial PRIMARY KEY\n);\n`,
+		`CREATE TABLE \`t3\` (
+	\`t3_id1\` int,
+	\`t3_id2\` int,
+	CONSTRAINT PRIMARY KEY(\`t3_id1\`,\`t3_id2\`)
+);\n`,
+		`CREATE INDEX \`t1_idx\` ON \`t1\` (\`t1_idx\`);`,
+		'ALTER TABLE `t1` ADD CONSTRAINT `t1_t2_ref_t2_t2_id_fkey` FOREIGN KEY (`t2_ref`) REFERENCES `t2`(`t2_id`);',
+		'ALTER TABLE `t1` ADD CONSTRAINT `t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fkey` FOREIGN KEY (`t1_col2`,`t1_col3`) REFERENCES `t3`(`t3_id1`,`t3_id2`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('optional db aliases (camel case)', async () => {
+	const from = {};
+
+	const t1 = camelCase.table('t1', {
+		t1_id1: int().notNull().primaryKey(),
+		t1_col2: int().notNull(),
+		t1_col3: int().notNull(),
+		t2_ref: bigint({ mode: 'number', unsigned: true }).references(() => t2.t2_id),
+		t1_uni: int().notNull(),
+		t1_uni_idx: int().notNull(),
+		t1_idx: int().notNull(),
+	}, (table) => [
+		unique('t1Uni').on(table.t1_uni),
+		uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
+		index('t1Idx').on(table.t1_idx),
+		foreignKey({
+			columns: [table.t1_col2, table.t1_col3],
+			foreignColumns: [t3.t3_id1, t3.t3_id2],
+		}),
+	]);
+
+	const t2 = camelCase.table('t2', {
+		t2_id: serial().primaryKey(),
+	});
+
+	const t3 = camelCase.table('t3', {
+		t3_id1: int(),
+		t3_id2: int(),
+	}, (table) => [primaryKey({
+		columns: [table.t3_id1, table.t3_id2],
+	})]);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`t1\` (\n\t\`t1Id1\` int PRIMARY KEY,\n\t\`t1Col2\` int NOT NULL,\n\t\`t1Col3\` int NOT NULL,\n`
+		+ `\t\`t2Ref\` bigint unsigned,\n\t\`t1Uni\` int NOT NULL,\n\t\`t1UniIdx\` int NOT NULL,\n\t\`t1Idx\` int NOT NULL,\n`
+		+ `\tCONSTRAINT \`t1Uni\` UNIQUE INDEX(\`t1Uni\`),\n`
+		+ `\tCONSTRAINT \`t1UniIdx\` UNIQUE INDEX(\`t1UniIdx\`)\n`
+		+ `);\n`,
+		`CREATE TABLE \`t2\` (\n\t\`t2Id\` serial PRIMARY KEY\n);\n`,
+		`CREATE TABLE \`t3\` (\n\t\`t3Id1\` int,\n\t\`t3Id2\` int,\n\tCONSTRAINT PRIMARY KEY(\`t3Id1\`,\`t3Id2\`)\n);\n`,
+		'CREATE INDEX `t1Idx` ON `t1` (`t1Idx`);',
+		'ALTER TABLE `t1` ADD CONSTRAINT `t1_t2Ref_t2_t2Id_fkey` FOREIGN KEY (`t2Ref`) REFERENCES `t2`(`t2Id`);',
+		'ALTER TABLE `t1` ADD CONSTRAINT `t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fkey` FOREIGN KEY (`t1Col2`,`t1Col3`) REFERENCES `t3`(`t3Id1`,`t3Id2`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add+drop unique', async () => {
+	const state0 = {};
+	const state1 = {
+		users: mysqlTable('users', {
+			id: int().unique(),
+		}),
+	};
+	const state2 = {
+		users: mysqlTable('users', {
+			id: int(),
+		}),
+	};
+
+	// TODO: should I rewrite this test as multistep test?
+	// const { sqlStatements: st1, next: n1 } = await diff(state0, state1, []);
+	const { sqlStatements: st1 } = await diff(state0, state1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: state1 });
+
+	const { sqlStatements: st2 } = await diff(state1, state2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: state2 });
+
+	const st01: string[] = [
+		'CREATE TABLE `users` (\n\t`id` int,\n\tCONSTRAINT `id_unique` UNIQUE INDEX(`id`)\n);\n',
+	];
+	expect(st1).toStrictEqual(st01);
+	expect(pst1).toStrictEqual(st01);
+
+	const st02: string[] = [
+		'DROP INDEX `id_unique` ON `users`;',
+	];
+	expect(st2).toStrictEqual(st02);
+	expect(pst2).toStrictEqual(st02);
+});
+
+test('fk #1', async () => {
+	const users = mysqlTable('users', {
+		id: int().unique(),
+	});
+	const to = {
+		users,
+		places: mysqlTable('places', {
+			id: int(),
+			ref: int().references(() => users.id),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` int,\n\tCONSTRAINT `id_unique` UNIQUE INDEX(`id`)\n);\n',
+		'CREATE TABLE `places` (\n\t`id` int,\n\t`ref` int\n);\n',
+		'ALTER TABLE `places` ADD CONSTRAINT `places_ref_users_id_fkey` FOREIGN KEY (`ref`) REFERENCES `users`(`id`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/367
+test('fk #2', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: serial().primaryKey(),
+	});
+	const to = {
+		table1,
+		table2: mysqlTable('table2', {
+			column1: serial().primaryKey(),
+			column2: bigint({ mode: 'number', unsigned: true }).references(() => table1.column1).notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `table1` (\n\t`column1` serial PRIMARY KEY\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` serial PRIMARY KEY,\n\t`column2` bigint unsigned NOT NULL\n);\n',
+		'ALTER TABLE `table2` ADD CONSTRAINT `table2_column2_table1_column1_fkey` FOREIGN KEY (`column2`) REFERENCES `table1`(`column1`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table with ts enum', async () => {
+	enum Test {
+		value = 'value',
+	}
+	const to = {
+		users: mysqlTable('users', {
+			enum: mysqlEnum(Test),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ["CREATE TABLE `users` (\n\t`enum` enum('value')\n);\n"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('all types', async () => {
+	const schema1 = {
+		allBigInts: mysqlTable('all_big_ints', {
+			simple: bigint('simple', { mode: 'number' }),
+			columnNotNull: bigint('column_not_null', { mode: 'number' }).notNull(),
+			columnDefault: bigint('column_default', { mode: 'number' }).default(12),
+			columnDefaultSql: bigint('column_default_sql', { mode: 'number' }).default(12),
+		}),
+		allBools: mysqlTable('all_bools', {
+			simple: tinyint('simple'),
+			columnNotNull: tinyint('column_not_null').notNull(),
+			columnDefault: tinyint('column_default').default(1),
+		}),
+		allChars: mysqlTable('all_chars', {
+			simple: char('simple', { length: 1 }),
+			columnNotNull: char('column_not_null', { length: 45 }).notNull(),
+			// columnDefault: char("column_default", { length: 1 }).default("h"),
+			columnDefaultSql: char('column_default_sql', { length: 1 }).default('h'),
+		}),
+		allDateTimes: mysqlTable('all_date_times', {
+			simple: datetime('simple', { mode: 'string', fsp: 1 }),
+			columnNotNull: datetime('column_not_null', { mode: 'string' }).notNull(),
+			columnDefault: datetime('column_default', { mode: 'string' }).default('2023-03-01 14:05:29'),
+		}),
+		allDates: mysqlTable('all_dates', {
+			simple: date('simple', { mode: 'string' }),
+			column_not_null: date('column_not_null', { mode: 'string' }).notNull(),
+			column_default: date('column_default', { mode: 'string' }).default('2023-03-01'),
+		}),
+		allDecimals: mysqlTable('all_decimals', {
+			simple: decimal('simple', { precision: 1, scale: 0 }),
+			columnNotNull: decimal('column_not_null', { precision: 45, scale: 3 }).notNull(),
+			columnDefault: decimal('column_default', { precision: 10, scale: 0 }).default('100'),
+			columnDefaultSql: decimal('column_default_sql', { precision: 10, scale: 0 }).default('101'),
+		}),
+
+		allDoubles: mysqlTable('all_doubles', {
+			simple: double('simple'),
+			columnNotNull: double('column_not_null').notNull(),
+			columnDefault: double('column_default').default(100),
+			columnDefaultSql: double('column_default_sql').default(101),
+		}),
+
+		allEnums: mysqlTable('all_enums', {
+			simple: mysqlEnum('simple', ['hi', 'hello']),
+		}),
+
+		allEnums1: mysqlTable('all_enums1', {
+			simple: mysqlEnum('simple', ['hi', 'hello']).default('hi'),
+		}),
+
+		allFloats: mysqlTable('all_floats', {
+			columnNotNull: float('column_not_null').notNull(),
+			columnDefault: float('column_default').default(100),
+			columnDefaultSql: float('column_default_sql').default(101),
+		}),
+
+		allInts: mysqlTable('all_ints', {
+			simple: int('simple'),
+			columnNotNull: int('column_not_null').notNull(),
+			columnDefault: int('column_default').default(100),
+			columnDefaultSql: int('column_default_sql').default(101),
+		}),
+
+		allIntsRef: mysqlTable('all_ints_ref', {
+			simple: int('simple'),
+			columnNotNull: int('column_not_null').notNull(),
+			columnDefault: int('column_default').default(100),
+			columnDefaultSql: int('column_default_sql').default(101),
+		}),
+
+		allJsons: mysqlTable('all_jsons', {
+			columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
+			columnDefaultArray: json('column_default_array').default({
+				hello: { 'world world': ['foo', 'bar'] },
+				foo: 'bar',
+				fe: 23,
+			}),
+			column: json('column'),
+		}),
+
+		allMInts: mysqlTable('all_m_ints', {
+			simple: mediumint('simple'),
+			columnNotNull: mediumint('column_not_null').notNull(),
+			columnDefault: mediumint('column_default').default(100),
+			columnDefaultSql: mediumint('column_default_sql').default(101),
+		}),
+
+		allReals: mysqlTable('all_reals', {
+			simple: double('simple', { precision: 5, scale: 2 }),
+			columnNotNull: double('column_not_null').notNull(),
+			columnDefault: double('column_default').default(100),
+			columnDefaultSql: double('column_default_sql').default(101),
+		}),
+
+		allSInts: mysqlTable('all_s_ints', {
+			simple: smallint('simple'),
+			columnNotNull: smallint('column_not_null').notNull(),
+			columnDefault: smallint('column_default').default(100),
+			columnDefaultSql: smallint('column_default_sql').default(101),
+		}),
+
+		allSmallSerials: mysqlTable('all_small_serials', {
+			columnAll: serial('column_all').primaryKey().notNull(),
+		}),
+
+		allTInts: mysqlTable('all_t_ints', {
+			simple: tinyint('simple'),
+			columnNotNull: tinyint('column_not_null').notNull(),
+			columnDefault: tinyint('column_default').default(10),
+			columnDefaultSql: tinyint('column_default_sql').default(11),
+		}),
+
+		allTexts: mysqlTable('all_texts', {
+			simple: text('simple'),
+			columnNotNull: text('column_not_null').notNull(),
+			columnDefault: text('column_default').default('hello'),
+			columnDefaultSql: text('column_default_sql').default('hello'),
+		}),
+
+		allTimes: mysqlTable('all_times', {
+			simple: time('simple', { fsp: 1 }),
+			columnNotNull: time('column_not_null').notNull(),
+			columnDefault: time('column_default').default('22:12:12'),
+		}),
+
+		allTimestamps: mysqlTable('all_timestamps', {
+			columnDateNow: timestamp('column_date_now', { fsp: 1, mode: 'string' }).default(sql`(now())`),
+			columnAll: timestamp('column_all', { mode: 'string' })
+				.default('2023-03-01 14:05:29')
+				.notNull(),
+			column: timestamp('column', { mode: 'string' }).default('2023-02-28 16:18:31'),
+		}),
+
+		allVarChars: mysqlTable('all_var_chars', {
+			simple: varchar('simple', { length: 100 }),
+			columnNotNull: varchar('column_not_null', { length: 45 }).notNull(),
+			columnDefault: varchar('column_default', { length: 100 }).default('hello'),
+			columnDefaultSql: varchar('column_default_sql', { length: 100 }).default('hello'),
+		}),
+
+		allVarbinaries: mysqlTable('all_varbinaries', {
+			simple: varbinary('simple', { length: 100 }),
+			columnNotNull: varbinary('column_not_null', { length: 100 }).notNull(),
+			columnDefault: varbinary('column_default', { length: 12 }).default(sql`(uuid_to_bin(uuid()))`),
+		}),
+
+		allYears: mysqlTable('all_years', {
+			simple: year('simple'),
+			columnNotNull: year('column_not_null').notNull(),
+			columnDefault: year('column_default').default(2022),
+		}),
+
+		binafry: mysqlTable('binary', {
+			simple: binary('simple', { length: 1 }),
+			columnNotNull: binary('column_not_null', { length: 1 }).notNull(),
+			columnDefault: binary('column_default', { length: 12 }).default(sql`(uuid_to_bin(uuid()))`),
+		}),
+
+		allTinyBlobs: mysqlTable('all_tiny_blobs', {
+			simple: tinyblob('simple'),
+			columnNotNull: tinyblob('column_not_null').notNull(),
+			columnDefault: tinyblob('column_default').default(Buffer.from('hello')),
+			columnDefaultSql: tinyblob('column_default_sql').default(sql`'hello'`),
+			stringSimple: tinyblob('string_simple', { mode: 'string' }),
+			stringColumnNotNull: tinyblob('string_column_not_null', { mode: 'string' }).notNull(),
+			stringColumnDefault: tinyblob('string_column_default', { mode: 'string' }).default('hello'),
+			stringColumnDefaultSql: tinyblob('string_column_default_sql', { mode: 'string' }).default(sql`'hello'`),
+		}),
+		allBlobs: mysqlTable('all_blobs', {
+			simple: blob('simple'),
+			columnNotNull: blob('column_not_null').notNull(),
+			columnDefault: blob('column_default').default(Buffer.from('hello')),
+			columnDefaultSql: blob('column_default_sql').default(sql`'hello'`),
+			stringSimple: blob('string_simple', { mode: 'string' }),
+			stringColumnNotNull: blob('string_column_not_null', { mode: 'string' }).notNull(),
+			stringColumnDefault: blob('string_column_default', { mode: 'string' }).default('hello'),
+			stringColumnDefaultSql: blob('string_column_default_sql', { mode: 'string' }).default(sql`('hello')`),
+		}),
+		allMediumBlobs: mysqlTable('all_medium_blobs', {
+			simple: mediumblob('simple'),
+			columnNotNull: mediumblob('column_not_null').notNull(),
+			columnDefault: mediumblob('column_default').default(Buffer.from('hello')),
+			columnDefaultSql: mediumblob('column_default_sql').default(sql`'hello'`),
+			stringSimple: mediumblob('string_simple', { mode: 'string' }),
+			stringColumnNotNull: mediumblob('string_column_not_null', { mode: 'string' }).notNull(),
+			stringColumnDefault: mediumblob('string_column_default', { mode: 'string' }).default('hello'),
+			stringColumnDefaultSql: mediumblob('string_column_default_sql', { mode: 'string' }).default(sql`'hello'`),
+		}),
+		allLongBlobs: mysqlTable('all_long_blobs', {
+			simple: longblob('simple'),
+			columnNotNull: longblob('column_not_null').notNull(),
+			columnDefault: longblob('column_default').default(Buffer.from('hello')),
+			columnDefaultSql: longblob('column_default_sql').default(sql`'hello'`),
+			stringSimple: longblob('string_simple', { mode: 'string' }),
+			stringColumnNotNull: longblob('string_column_not_null', { mode: 'string' }).notNull(),
+			stringColumnDefault: longblob('string_column_default', { mode: 'string' }).default('hello'),
+			stringColumnDefaultSql: longblob('string_column_default_sql', { mode: 'string' }).default(sql`'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema1, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: sbsqSt } = await push({ db, to: schema1 });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(sbsqSt).toStrictEqual(st0);
+});
+
+test('drop primary key', async () => {
+	const from = {
+		table: mysqlTable('table', {
+			id: int().primaryKey(),
+		}),
+	};
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` DROP PRIMARY KEY;',
+		/*
+			when we drop pk from the column - we expect implicit not null constraint
+			to be dropped, though it's not. Thus we need to not only drop pk,
+			but a not null constraint too.
+		*/
+		'ALTER TABLE `table` MODIFY COLUMN `id` int;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`create table with char set and collate`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_bin'),
+			name2: char('name2').charSet('big5').collate('big5_bin'),
+			name3: text('name3').charSet('big5').collate('big5_bin'),
+			name4: tinytext('name4').charSet('big5').collate('big5_bin'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_bin'),
+			name6: longtext('name6').charSet('big5').collate('big5_bin'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_bin'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`table\` (
+	\`id\` int,
+	\`name1\` varchar(1) CHARACTER SET big5 COLLATE big5_bin,
+	\`name2\` char CHARACTER SET big5 COLLATE big5_bin,
+	\`name3\` text CHARACTER SET big5 COLLATE big5_bin,
+	\`name4\` tinytext CHARACTER SET big5 COLLATE big5_bin,
+	\`name5\` mediumtext CHARACTER SET big5 COLLATE big5_bin,
+	\`name6\` longtext CHARACTER SET big5 COLLATE big5_bin,
+	\`test_enum\` enum('1','2') CHARACTER SET big5 COLLATE big5_bin
+);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`create table with char set and collate with default and not null`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 15 }).charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name2: char('name2', { length: 10 }).charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name3: text('name3').charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name4: tinytext('name4').charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name6: longtext('name6').charSet('big5').collate('big5_bin').notNull().default('hey'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_bin').notNull().default('1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`table\` (
+	\`id\` int,
+	\`name1\` varchar(15) CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT 'hey',
+	\`name2\` char(10) CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT 'hey',
+	\`name3\` text CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT ('hey'),
+	\`name4\` tinytext CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT ('hey'),
+	\`name5\` mediumtext CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT ('hey'),
+	\`name6\` longtext CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT ('hey'),
+	\`test_enum\` enum('1','2') CHARACTER SET big5 COLLATE big5_bin NOT NULL DEFAULT '1'
+);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`add column with char set and collate`, async () => {
+	const from = {
+		table: mysqlTable('table', {
+			id: int(),
+		}),
+	};
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_bin'),
+			name2: char('name2').charSet('big5').collate('big5_bin'),
+			name3: text('name3').charSet('big5').collate('big5_bin'),
+			name4: tinytext('name4').charSet('big5').collate('big5_bin'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_bin'),
+			name6: longtext('name6').charSet('big5').collate('big5_bin'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_bin'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `name1` varchar(1) CHARACTER SET big5 COLLATE big5_bin;',
+		'ALTER TABLE `table` ADD `name2` char CHARACTER SET big5 COLLATE big5_bin;',
+		'ALTER TABLE `table` ADD `name3` text CHARACTER SET big5 COLLATE big5_bin;',
+		'ALTER TABLE `table` ADD `name4` tinytext CHARACTER SET big5 COLLATE big5_bin;',
+		'ALTER TABLE `table` ADD `name5` mediumtext CHARACTER SET big5 COLLATE big5_bin;',
+		'ALTER TABLE `table` ADD `name6` longtext CHARACTER SET big5 COLLATE big5_bin;',
+		"ALTER TABLE `table` ADD `test_enum` enum('1','2') CHARACTER SET big5 COLLATE big5_bin;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`update char set and collate`, async () => {
+	const from = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_bin'),
+			name2: char('name2').charSet('big5').collate('big5_bin'),
+			name3: text('name3').charSet('big5').collate('big5_bin'),
+			name4: tinytext('name4').charSet('big5').collate('big5_bin'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_bin'),
+			name6: longtext('name6').charSet('big5').collate('big5_bin'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_bin'),
+		}),
+	};
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('cp1250').collate('cp1250_bin'),
+			name2: char('name2').charSet('cp1250').collate('cp1250_bin'),
+			name3: text('name3').charSet('cp1250').collate('cp1250_bin'),
+			name4: tinytext('name4').charSet('cp1250').collate('cp1250_bin'),
+			name5: mediumtext('name5').charSet('cp1250').collate('cp1250_bin'),
+			name6: longtext('name6').charSet('cp1250').collate('cp1250_bin'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('cp1250').collate('cp1250_bin'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` MODIFY COLUMN `name1` varchar(1) CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		'ALTER TABLE `table` MODIFY COLUMN `name2` char CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		'ALTER TABLE `table` MODIFY COLUMN `name3` text CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		'ALTER TABLE `table` MODIFY COLUMN `name4` tinytext CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		'ALTER TABLE `table` MODIFY COLUMN `name5` mediumtext CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		'ALTER TABLE `table` MODIFY COLUMN `name6` longtext CHARACTER SET cp1250 COLLATE cp1250_bin;',
+		"ALTER TABLE `table` MODIFY COLUMN `test_enum` enum('1','2') CHARACTER SET cp1250 COLLATE cp1250_bin;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`update collate`, async () => {
+	const from = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_bin'),
+			name2: char('name2').charSet('big5').collate('big5_bin'),
+			name3: text('name3').charSet('big5').collate('big5_bin'),
+			name4: tinytext('name4').charSet('big5').collate('big5_bin'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_bin'),
+			name6: longtext('name6').charSet('big5').collate('big5_bin'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_bin'),
+		}),
+	};
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_chinese_ci'),
+			name2: char('name2').charSet('big5').collate('big5_chinese_ci'),
+			name3: text('name3').charSet('big5').collate('big5_chinese_ci'),
+			name4: tinytext('name4').charSet('big5').collate('big5_chinese_ci'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_chinese_ci'),
+			name6: longtext('name6').charSet('big5').collate('big5_chinese_ci'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_chinese_ci'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` MODIFY COLUMN `name1` varchar(1) CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		'ALTER TABLE `table` MODIFY COLUMN `name2` char CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		'ALTER TABLE `table` MODIFY COLUMN `name3` text CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		'ALTER TABLE `table` MODIFY COLUMN `name4` tinytext CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		'ALTER TABLE `table` MODIFY COLUMN `name5` mediumtext CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		'ALTER TABLE `table` MODIFY COLUMN `name6` longtext CHARACTER SET big5 COLLATE big5_chinese_ci;',
+		"ALTER TABLE `table` MODIFY COLUMN `test_enum` enum('1','2') CHARACTER SET big5 COLLATE big5_chinese_ci;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: only char set is specified (default collation used for char set)`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5'),
+			name2: char('name2').charSet('big5'),
+			name3: text('name3').charSet('big5'),
+			name4: tinytext('name4').charSet('big5'),
+			name5: mediumtext('name5').charSet('big5'),
+			name6: longtext('name6').charSet('big5'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5'),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: only collation is specified (char set that is linked to this collation used)`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).collate('utf8mb3_slovak_ci'),
+			name2: char('name2').collate('ascii_bin'),
+			name3: text('name3').collate('cp1250_general_ci'),
+			name4: tinytext('name4').collate('cp1256_bin'),
+			name5: mediumtext('name5').collate('koi8u_bin'),
+			name6: longtext('name6').collate('utf16_danish_ci'),
+			name7: mysqlEnum('test_enum', ['1', '2']).collate('utf16_danish_ci'),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: no collation + no char set (db stores as collation: 'utf8mb4_0900_ai_ci', charSet: 'utf8mb4')`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }),
+			name2: char('name2'),
+			name3: text('name3'),
+			name4: tinytext('name4'),
+			name5: mediumtext('name5'),
+			name6: longtext('name6'),
+			name7: mysqlEnum('test_enum', ['1', '2']),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: collation char set`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_chinese_ci'),
+			name2: char('name2').charSet('big5').collate('big5_chinese_ci'),
+			name3: text('name3').charSet('big5').collate('big5_chinese_ci'),
+			name4: tinytext('name4').charSet('big5').collate('big5_chinese_ci'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_chinese_ci'),
+			name6: longtext('name6').charSet('big5').collate('big5_chinese_ci'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_chinese_ci'),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: check on update now with fsp #1`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			created_at: timestamp().onUpdateNow(),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test(`push-push: check on update now with fsp #2`, async () => {
+	const to = {
+		table: mysqlTable('table', {
+			id: int(),
+			created_at: timestamp({ fsp: 3 }).onUpdateNow({ fsp: 3 }),
+		}),
+	};
+
+	await push({ db, to });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(pst).toStrictEqual(st0);
+});
+
+test('weird serial non-pk', async () => {
+	// old kit was generating serials with autoincrements which is wrong
+	db.query('create table `table`(c1 int not null, c2 serial auto_increment, CONSTRAINT PRIMARY KEY(`c1`));');
+
+	const table = mysqlTable('table', {
+		c1: int().primaryKey(),
+		c2: serial(),
+	});
+
+	const res1 = await push({ db, to: { table } });
+	const res2 = await push({ db, to: { table } });
+
+	expect(res1.sqlStatements).toStrictEqual([]);
+	expect(res2.sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2216
+test('rename column with pk on another column', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2: int(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: int(),
+			column3: int(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY,\n\t`column2` int\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\t`column2` int,\n\t`column3` int,\n\tCONSTRAINT PRIMARY KEY(`column1`,`column2`)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2_renamed: int('column2_renamed').notNull(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int(),
+			column2: int(),
+			column3_renamed: int('column3_renamed').notNull(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+		]),
+	};
+
+	const renames = [
+		'table1.column2->table1.column2_renamed',
+		'table2.column3->table2.column3_renamed',
+	];
+	const { sqlStatements: st2 } = await diff(n1, schema2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2, renames });
+	const expectedSt2 = [
+		'ALTER TABLE `table1` RENAME COLUMN `column2` TO `column2_renamed`;',
+		'ALTER TABLE `table2` RENAME COLUMN `column3` TO `column3_renamed`;',
+		'ALTER TABLE `table1` MODIFY COLUMN `column2_renamed` int NOT NULL;',
+		'ALTER TABLE `table2` MODIFY COLUMN `column3_renamed` int NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/706
+test('add pk', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int().unique(),
+		}),
+		table3: mysqlTable('table3', {
+			column1: int().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int\n);\n',
+		'CREATE TABLE `table2` (\n\t`column1` int,\n\tCONSTRAINT `column1_unique` UNIQUE INDEX(`column1`)\n);\n',
+		'CREATE TABLE `table3` (\n\t`column1` int,\n\tCONSTRAINT `column1_unique` UNIQUE INDEX(`column1`)\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int().unique().primaryKey(),
+		}),
+		table3: mysqlTable('table3', {
+			column1: int().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'DROP INDEX `column1_unique` ON `table3`;',
+		'ALTER TABLE `table1` ADD PRIMARY KEY (`column1`);',
+		'ALTER TABLE `table2` ADD PRIMARY KEY (`column1`);',
+		'ALTER TABLE `table3` ADD PRIMARY KEY (`column1`);',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2795
+test('add not null to column with default', async () => {
+	const schema1 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2: boolean().default(true),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`column1` int PRIMARY KEY,\n\t`column2` boolean DEFAULT true\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2: boolean().default(true),
+			column3: boolean().default(false),
+		}),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE `table1` ADD `column3` boolean DEFAULT false;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+
+	const schema3 = {
+		table1: mysqlTable('table1', {
+			column1: int().primaryKey(),
+			column2: boolean().default(true).notNull(),
+			column3: boolean().default(false).notNull(),
+		}),
+	};
+
+	const { sqlStatements: st3 } = await diff(n2, schema3, []);
+	const { sqlStatements: pst3 } = await push({ db, to: schema3 });
+	const expectedSt3 = [
+		'ALTER TABLE `table1` MODIFY COLUMN `column2` boolean DEFAULT true NOT NULL;',
+		'ALTER TABLE `table1` MODIFY COLUMN `column3` boolean DEFAULT false NOT NULL;',
+	];
+	expect(st3).toStrictEqual(expectedSt3);
+	expect(pst3).toStrictEqual(expectedSt3);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5125
+test('case - #5125', async () => {
+	const students = mysqlTable('student', {
+		id: int().primaryKey().autoincrement(),
+	});
+
+	const courses = mysqlTable('course', {
+		id: int().primaryKey().autoincrement(),
+	});
+
+	const studentCourse = mysqlTable('student_course', {
+		studentId: int().notNull().references(() => students.id), // FK relies on PK index by default in MySQL
+		courseId: int().notNull().references(() => courses.id),
+	}, (table) => [
+		primaryKey({ columns: [table.studentId, table.courseId] }),
+	]);
+
+	const to = {
+		students,
+		courses,
+		studentCourse,
+	};
+
+	await push({ db, to });
+});
+
+test('push after migrate with custom migrations table #1', async () => {
+	const migrationsConfig = {
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/mysql2/migrator');
+	const { drizzle } = await import('drizzle-orm/mysql2');
+
+	await migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mysql/migrations',
+	});
+
+	const to = {
+		table: mysqlTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #2', async () => {
+	const migrationsConfig = {
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/mysql2/migrator');
+	const { drizzle } = await import('drizzle-orm/mysql2');
+
+	await migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/mysql/migrations',
+	});
+
+	const to = {
+		table: mysqlTable('table1', { col1: int() }),
+	};
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('create table with datetime .onUpdateNow() diff variations', async () => {
+	const to = {
+		users: mysqlTable('users', {
+			col1: datetime().onUpdateNow(),
+			col2: datetime({ fsp: 1 }).onUpdateNow({ fsp: 1 }),
+			col3: datetime({ fsp: 3 }).onUpdateNow({ fsp: 3 }),
+			col4: datetime({ fsp: 6 }).onUpdateNow({ fsp: 6 }),
+			col5: datetime({ mode: 'string' }).onUpdateNow(),
+			col6: datetime({ mode: 'date' }).onUpdateNow(),
+		}),
+	};
+
+	const res = await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (' + '\n'
+		+ '\t`col1` datetime ON UPDATE CURRENT_TIMESTAMP,' + '\n'
+		+ '\t`col2` datetime(1) ON UPDATE CURRENT_TIMESTAMP(1),' + '\n'
+		+ '\t`col3` datetime(3) ON UPDATE CURRENT_TIMESTAMP(3),' + '\n'
+		+ '\t`col4` datetime(6) ON UPDATE CURRENT_TIMESTAMP(6),' + '\n'
+		+ '\t`col5` datetime,' + '\n'
+		+ '\t`col6` datetime ON UPDATE CURRENT_TIMESTAMP' + '\n'
+		+ ');\n',
+	]);
+});
+
+test('create table with datetime .onUpdateNow() diff variations', async () => {
+	const orders = mysqlTable('orders', {
+		id: int({ unsigned: true }).notNull().primaryKey().autoincrement(),
+		catalog_id: int({ unsigned: true }).notNull().default(0),
+		created_at: timestamp('created_at', { mode: 'date', fsp: 3 }).notNull().default(sql`CURRENT_TIMESTAMP(3)`),
+	}, (table) => [
+		index('orders_created_at').on(table.created_at),
+		index('orders_catalog_id').on(table.catalog_id),
+	]);
+
+	const orderItems = mysqlTable('orderitems', {
+		id: int({ unsigned: true }).notNull().primaryKey().autoincrement(),
+		catalog_id: int({ unsigned: true }).notNull().default(0),
+		order_id: int({ unsigned: true }).notNull(),
+		sku: varchar({ length: 255 }).default('').notNull(),
+	}, (table) => [
+		index('orderitems_order_id').on(table.order_id),
+		index('orderitems_catalog_id').on(table.catalog_id),
+		index('orderitems_sku').on(table.sku),
+		primaryKey({ columns: [table.id] }),
+	]);
+
+	const to = {
+		orders,
+		orderItems,
+	};
+
+	await expect(push({ db, to })).resolves.not.toThrowError();
+});
diff --git a/drizzle-kit/tests/mysql/pull.test.ts b/drizzle-kit/tests/mysql/pull.test.ts
new file mode 100644
index 0000000000..448aebb13f
--- /dev/null
+++ b/drizzle-kit/tests/mysql/pull.test.ts
@@ -0,0 +1,1079 @@
+import 'dotenv/config';
+import { SQL, sql } from 'drizzle-orm';
+import {
+	AnyMySqlColumn,
+	bigint,
+	binary,
+	blob,
+	boolean,
+	char,
+	check,
+	customType,
+	datetime,
+	decimal,
+	double,
+	float,
+	foreignKey,
+	index,
+	int,
+	json,
+	longblob,
+	longtext,
+	mediumblob,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	mysqlTable,
+	mysqlView,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	timestamp,
+	tinyblob,
+	tinyint,
+	tinytext,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+} from 'drizzle-orm/mysql-core';
+import * as fs from 'fs';
+import { fromDatabaseForDrizzle } from 'src/dialects/mysql/introspect';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffIntrospect, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+if (!fs.existsSync('tests/mysql/tmp')) {
+	fs.mkdirSync('tests/mysql/tmp', { recursive: true });
+}
+
+test('generated always column: link to another column', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'generated-link');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated always column virtual: link to another column', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'generated-link-virtual');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('Default value of character type column: char', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			sortKey: char('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-value-char');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3318
+// https://github.com/drizzle-team/drizzle-orm/issues/1754
+test('Default value of character type column: varchar', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			sortKey: varchar('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-value-varchar');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4620
+// https://github.com/drizzle-team/drizzle-orm/issues/4786
+test('Default value of character type column: enum', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			status: mysqlEnum(['0', '1', '2']).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-value-enum');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3559
+// https://github.com/drizzle-team/drizzle-orm/issues/4713
+test('Default value of empty string column: enum, char, varchar, text, tinytext, mediumtext, longtext', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: mysqlEnum(['0', '1', '2', '']).default(''),
+			column2: char({ length: 50 }).default(''),
+			column3: varchar({ length: 50 }).default(''),
+			column4: text().default(''),
+			column5: tinytext().default(''),
+			column6: mediumtext().default(''),
+			column7: longtext().default(''),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-value-of-empty-string');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1402
+test('introspect default with expression', async () => {
+	const table1 = mysqlTable('table1', {
+		id: int().primaryKey(),
+		url: text().notNull(),
+		// TODO: revise: it would be nice to use .default like below
+		// hash: char({ length: 32 }).charSet('utf8mb4').collate('utf8mb4_0900_ai_ci').notNull().default(() =>sql`md5(${table1.url})`),
+		hash: char({ length: 32 }).charSet('utf8mb4').collate('utf8mb4_0900_ai_ci').notNull().default(sql`md5(\`url\`)`),
+	});
+	const schema = { table1 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'default-with-expression');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect checks', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: serial('id'),
+			name: varchar('name', { length: 255 }),
+			age: int('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'checks');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('view #1', async () => {
+	const users = mysqlTable('users', { id: int('id') });
+	const testView = mysqlView('some_view', { id: int('id') }).as(
+		sql`select \`drizzle\`.\`users\`.\`id\` AS \`id\` from \`drizzle\`.\`users\``,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'view-1');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('view #2', async () => {
+	const users = mysqlTable('some_users', { id: int('id') });
+	const testView = mysqlView('some_view', { id: int('id') }).algorithm('temptable').sqlSecurity('definer').as(
+		sql`SELECT * FROM ${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'view-2');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3285
+test('handle float type', async () => {
+	const schema = {
+		table: mysqlTable('table', {
+			col1: float(),
+			col2: float({ precision: 2 }),
+			col3: float({ precision: 2, scale: 1 }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'float-type');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/258
+// https://github.com/drizzle-team/drizzle-orm/issues/1675
+// https://github.com/drizzle-team/drizzle-orm/issues/2950
+test('handle unsigned numerical types', async () => {
+	const schema = {
+		table: mysqlTable('table', {
+			col1: int({ unsigned: true }),
+			col2: tinyint({ unsigned: true }),
+			col3: smallint({ unsigned: true }),
+			col4: mediumint({ unsigned: true }),
+			col5: bigint({ mode: 'number', unsigned: true }),
+			col6: float({ unsigned: true }),
+			col7: float({ precision: 2, scale: 1, unsigned: true }),
+			col8: double({ unsigned: true }),
+			col9: double({ precision: 2, scale: 1, unsigned: true }),
+			col10: decimal({ unsigned: true }),
+			col11: decimal({ precision: 2, scale: 1, unsigned: true }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'unsigned-numerical-types');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('instrospect strings with single quotes', async () => {
+	const schema = {
+		columns: mysqlTable('columns', {
+			enum: mysqlEnum('my_enum', ['escape\'s quotes "', 'escape\'s quotes 2 "']).default('escape\'s quotes "'),
+			text: text('text').default('escape\'s quotes " '),
+			varchar: varchar('varchar', { length: 255 }).default('escape\'s quotes " '),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'strings-with-single-quotes');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3297
+test('introspect varchar with \r\n in default, column name starts with number', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: varchar({ length: 24 }).notNull().default(' aaa\r\nbbbb'),
+			'2column_': tinyint('2column_').default(0).notNull(),
+			column3: decimal({ precision: 2, scale: 1, unsigned: true }).notNull(),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-varchar-with-breakline');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1928
+test('introspect column with colon/semicolon in its name', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			'column:1': text('column:1'),
+			'column;2': text('column;2'),
+			'column;3': text(),
+			'column;4': text(),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-column-with-colon');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('charSet and collate', async () => {
+	const schema = {
+		columns: mysqlTable('columns', {
+			name1: varchar('name1', { length: 1 }).charSet('big5').collate('big5_chinese_ci'),
+			name2: char('name2').charSet('big5').collate('big5_chinese_ci'),
+			name3: text('name3').charSet('big5').collate('big5_chinese_ci'),
+			name4: tinytext('name4').charSet('big5').collate('big5_chinese_ci'),
+			name5: mediumtext('name5').charSet('big5').collate('big5_chinese_ci'),
+			name6: longtext('name6').charSet('big5').collate('big5_chinese_ci'),
+			name7: mysqlEnum('test_enum', ['1', '2']).charSet('big5').collate('big5_chinese_ci'),
+			name8: text('name:first').charSet('utf8mb4').collate('utf8mb4_0900_ai_ci'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'charSet_and_collate');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4110
+// https://github.com/drizzle-team/drizzle-orm/issues/1020
+// https://github.com/drizzle-team/drizzle-orm/issues/3457
+// https://github.com/drizzle-team/drizzle-orm/issues/1871
+// https://github.com/drizzle-team/drizzle-orm/issues/2950
+// https://github.com/drizzle-team/drizzle-orm/issues/2988
+// https://github.com/drizzle-team/drizzle-orm/issues/4653
+test('introspect bigint, mediumint, int, smallint, tinyint', async () => {
+	const schema = {
+		columns: mysqlTable('columns', {
+			column1: tinyint(),
+			column2: smallint(),
+			column3: int(),
+			column4: mediumint(),
+			column5: bigint({ mode: 'bigint' }),
+			column6: bigint({ mode: 'number' }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-int');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3290
+// https://github.com/drizzle-team/drizzle-orm/issues/1428
+// https://github.com/drizzle-team/drizzle-orm/issues/3552
+// https://github.com/drizzle-team/drizzle-orm/issues/4602
+test('introspect table with primary key and check', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: int().autoincrement().primaryKey(),
+		}),
+		table2: mysqlTable('table2', {
+			column1: int().autoincrement(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1] }),
+		]),
+		table3: mysqlTable('table3', {
+			column1: int(),
+			column2: int(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2] }),
+			check('age_check1', sql`${table.column1} > 21`),
+		]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'table-with-primary-key-and-check');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4415
+test('introspect table with fk', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+		column2: int().references(() => table1.column1),
+	}, (table) => [
+		foreignKey({ columns: [table.column1], foreignColumns: [table1.column1], name: 'custom_fk' }),
+	]);
+	const schema = { table1, table2 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'table-with-fk');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4115
+test('introspect fk name with onDelete, onUpdate set to no action', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+	});
+	const table2 = mysqlTable('table2', {
+		column1: int(),
+	}, (table) => [
+		foreignKey({ columns: [table.column1], foreignColumns: [table1.column1], name: 'custom_fk' }),
+	]);
+	const schema = { table1, table2 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'fk-with-on-delete-and-on-update');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect table with self reference', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: int().primaryKey(),
+		column2: int().references((): AnyMySqlColumn => table1.column1),
+	});
+
+	const schema = { table1 };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'table-with-self-ref');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4885
+// https://github.com/drizzle-team/drizzle-orm/issues/4110
+test('introspect table with boolean(tinyint(1))', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: boolean(),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'table-with-boolean');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3046
+test('introspect index on json', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: json(),
+		}, (table) => [
+			index('custom_json_index').on(
+				sql`(((cast(json_unquote(json_extract(${table.column1}, _utf8mb4'$.data.nestedJsonProperty.')) as char(30) charset utf8mb4) collate utf8mb4_bin)))`,
+			),
+		]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'index-on-json');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4499
+test('introspect functional index', async () => {
+	const schema = {
+		appBadgeTag: mysqlTable('app_badge_tag', {
+			tagId: varchar('tag_id', { length: 255 }).primaryKey(),
+			badgeId: varchar('badge_id', { length: 32 }).notNull(),
+			designId: varchar('design_id', { length: 255 }),
+			colorId: varchar('color_id', { length: 255 }),
+			createdAt: datetime('created_at').default(sql`CURRENT_TIMESTAMP`).notNull(),
+		}, (table) => [
+			uniqueIndex('app_badge_tag_pk').on(
+				table.badgeId,
+				sql`(case when (\`design_id\` is null) then _utf8mb4\'\' else \`design_id\` end)`,
+				sql`(case when (\`color_id\` is null) then _utf8mb4\'\' else \`color_id\` end)`,
+			),
+			index('app_badge_tag_design_id_index').on(table.designId),
+		]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'functional-index');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1306
+// https://github.com/drizzle-team/drizzle-orm/issues/1512
+// https://github.com/drizzle-team/drizzle-orm/issues/1870
+// https://github.com/drizzle-team/drizzle-orm/issues/2525
+test('introspect index and fk with action', async () => {
+	const entity = mysqlTable('Entity', {
+		id: int('id').autoincrement().notNull(),
+		name: varchar('name', { length: 191 }).notNull(),
+	}, (table) => [
+		primaryKey({ columns: [table.id] }),
+	]);
+
+	const entityTag = mysqlTable('EntityTag', {
+		id: int('id').autoincrement().notNull(),
+		name: varchar('name', { length: 191 }).notNull(),
+	}, (table) => [
+		primaryKey({ columns: [table.id] }),
+	]);
+
+	const entityToEntityTag = mysqlTable('_EntityToEntityTag', {
+		a: int('A').notNull().references(() => entity.id, { onDelete: 'cascade', onUpdate: 'cascade' }),
+		b: int('B').notNull().references(() => entityTag.id, { onDelete: 'cascade', onUpdate: 'cascade' }),
+	}, (table) => {
+		return {
+			bIdx: index('_EntityToEntityTag_B_index').on(table.b),
+			entityToEntityTagAbUnique: uniqueIndex('_EntityToEntityTag_AB_unique').on(table.a, table.b),
+		};
+	});
+
+	const schema = { entity, entityTag, entityToEntityTag };
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-index');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('introspect hash index', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: int(),
+			column2: varchar({ length: 100 }),
+		}, (table) => [
+			index('idx_name').on(table.column2).using('hash'),
+		]),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-hash-index');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+test('introspect blob, tinyblob, mediumblob, longblob', async () => {
+	const schema = {
+		columns: mysqlTable('columns', {
+			column1: tinyblob(),
+			column2: mediumblob(),
+			column3: blob(),
+			column4: mediumblob(),
+			column5: longblob(),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-blobs');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3480
+test('introspect bit(1); custom type', async () => {
+	const schema = {
+		table1: mysqlTable('table1', {
+			column1: customType({ dataType: () => 'bit(1)' })().default("b'1'"), // this fails
+			column2: customType({ dataType: () => 'bit(1)' })().default(sql`b'1'`), // this works fine
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-bit(1)');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('generated as string: change generated constraint', async () => {
+	const schema = {
+		users: mysqlTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`'users\\\\hello'`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffIntrospect(db, schema, 'introspect-generated-with-backslashes');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4170
+test('introspect view with table filter', async () => {
+	const table1 = mysqlTable('table1', {
+		column1: serial().primaryKey(),
+	});
+	const view1 = mysqlView('view1', { column1: serial() }).as(sql`select column1 from ${table1}`);
+	const table2 = mysqlTable('table2', {
+		column1: serial().primaryKey(),
+	});
+	const view2 = mysqlView('view2', { column1: serial() }).as(sql`select column1 from ${table2}`);
+	const schema1 = { table1, view1, table2, view2 };
+	await push({ db, to: schema1 });
+
+	let filter = prepareEntityFilter('mysql', {
+		tables: ['table1'],
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+	let tables, views;
+	({ tables, views } = await fromDatabaseForDrizzle(
+		db,
+		'drizzle',
+		filter,
+		() => {},
+		{ schema: 'drizzle', table: '__drizzle_migrations' },
+	));
+	const expectedTables = [{ entityType: 'tables', name: 'table1' }];
+	expect(tables).toStrictEqual(expectedTables);
+	expect(views).toStrictEqual([]);
+
+	filter = prepareEntityFilter('mysql', {
+		tables: ['table1', 'view1'],
+		schemas: undefined,
+		entities: undefined,
+		extensions: undefined,
+	}, []);
+	({ tables, views } = await fromDatabaseForDrizzle(
+		db,
+		'drizzle',
+		filter,
+		() => {},
+		{ schema: 'drizzle', table: '__drizzle_migrations' },
+	));
+	const expectedViews = [
+		{
+			entityType: 'views',
+			name: 'view1',
+			definition: 'select `drizzle`.`table1`.`column1` AS `column1` from `drizzle`.`table1`',
+			algorithm: 'undefined',
+			sqlSecurity: 'definer',
+			withCheckOption: null,
+		},
+	];
+	expect(tables).toStrictEqual(expectedTables);
+	expect(views).toStrictEqual(expectedViews);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test('single quote default', async () => {
+	const group = mysqlTable('group', {
+		id: text().notNull(),
+		fk_organizaton_group: text().notNull(),
+		saml_identifier: text().default('').notNull(),
+		display_name: text().default('').notNull(),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ group },
+		'single_quote_default',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// filter default migration table
+test('pull after migrate with custom migrations table #1', async () => {
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS __drizzle_migrations (
+			id INT PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS users (
+			id INT PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { pks, columns, tables } = await fromDatabaseForDrizzle(
+		db,
+		'drizzle',
+		() => true,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			name: 'users',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'PRIMARY',
+			table: 'users',
+		},
+	]);
+});
+
+// filter custom migration table
+test('pull after migrate with custom migrations table #2', async () => {
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS custom_migrations (
+			id INT PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS users (
+			id INT PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		'drizzle',
+		() => true,
+		() => {},
+		{
+			table: 'custom_migrations',
+			schema: 'drizzle', // default from prepare params
+		},
+	);
+
+	expect([...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			name: 'users',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'PRIMARY',
+			table: 'users',
+		},
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5212
+test('datetime #1', async () => {
+	const table1 = mysqlTable('table1', {
+		col1: datetime().notNull().default(sql`CURRENT_TIMESTAMP`),
+		col2: datetime().notNull().default(sql`CURRENT_TIMESTAMP`).onUpdateNow(),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ table1 },
+		'datetime-1',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4499
+test('datetime #2', async () => {
+	await db.query(`CREATE TABLE \`app_badge_tag\` (
+  				\`tag_id\` varchar(255) NOT NULL,
+  				\`badge_id\` varchar(32) NOT NULL,
+  				\`design_id\` varchar(255) DEFAULT NULL,
+  				\`color_id\` varchar(255) DEFAULT NULL,
+  				\`created_at\` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  				PRIMARY KEY (\`tag_id\`),
+  				UNIQUE KEY \`app_badge_tag_pk\` (\`badge_id\`,((case when (\`design_id\` is null) then _utf8mb4'' else \`design_id\` end)),((case when (\`color_id\` is null) then _utf8mb4'' else \`color_id\` end))),
+  				KEY \`app_badge_tag_design_id_index\` (\`design_id\`)
+			) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci`);
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{},
+		'datetime-2',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect varbinary and binary', async () => {
+	const table1 = mysqlTable('table1', {
+		col1: varbinary({ length: 16 }),
+		col2: binary({ length: 16 }).default(''),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ table1 },
+		'varbinary-and-binary',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('timestamp def CURRENT_TIMESTAMP with precision', async () => {
+	const table1 = mysqlTable('table1', {
+		col1: timestamp({ fsp: 3 }).notNull().default(sql`CURRENT_TIMESTAMP(3)`),
+	});
+
+	const { sqlStatements } = await diffIntrospect(
+		db,
+		{ table1 },
+		'timestamp-def-current-timestamp-with-precision',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('fks with same names but in diff databases', async () => {
+	await db.query('DROP DATABASE if exists `fk_test`;');
+	await db.query('DROP DATABASE if exists `fk_test_2`;');
+	await db.query('CREATE DATABASE `fk_test`;');
+	await db.query('CREATE DATABASE `fk_test_2`;');
+
+	await db.query(`USE fk_test;`);
+	await db.query(`
+		CREATE TABLE parent (
+			id INT PRIMARY KEY
+		);
+	`);
+	await db.query(`
+		CREATE TABLE child (
+			id INT PRIMARY KEY,
+			parent_id INT,
+			CONSTRAINT fk_parent FOREIGN KEY (parent_id) REFERENCES parent(id)
+		);
+	`);
+
+	await db.query(`USE fk_test_2;`);
+	await db.query(`
+		CREATE TABLE parent (
+			id INT PRIMARY KEY
+		);
+	`);
+	await db.query(`
+		CREATE TABLE child (
+			id INT PRIMARY KEY,
+			parent_id INT,
+			CONSTRAINT fk_parent FOREIGN KEY (parent_id) REFERENCES parent(id)
+		);
+	`);
+
+	const { fks } = await fromDatabaseForDrizzle(db, 'fk_test', () => true, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+
+	expect(fks).toStrictEqual([{
+		columns: [
+			'parent_id',
+		],
+		columnsTo: [
+			'id',
+		],
+		entityType: 'fks',
+		name: 'fk_parent',
+		nameExplicit: true,
+		onDelete: 'NO ACTION',
+		onUpdate: 'NO ACTION',
+		table: 'child',
+		tableTo: 'parent',
+	}]);
+});
+
+test('introspect cyclic foreign key', async () => {
+	const inviteCode = mysqlTable('InviteCode', {
+		id: int().primaryKey(),
+		inviterUserId: int().references((): AnyMySqlColumn => users.id),
+	});
+
+	const users = mysqlTable('Users', {
+		id: int().primaryKey(),
+		inviteId: int().references((): AnyMySqlColumn => inviteCode.id),
+	});
+
+	const { statements, sqlStatements } = await diffIntrospect(db, { inviteCode, users }, 'cyclic-foreign-key');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('double-quote-issue', async () => {
+	const content = mysqlTable('content', {
+		id: int('id').notNull(),
+		virtualPath: varchar('virtual_path', { length: 255 }).notNull(),
+		pid: varchar('pid', { length: 750 }).notNull(),
+		pageTitle: varchar('page_title', { length: 75 }).default('Untitled Document').notNull(),
+		navTitle: varchar('nav_title', { length: 25 }).default('NULL'),
+		protected: mysqlEnum('protected', ['Y', 'N']).default('N').notNull(),
+		metaData: varchar('meta_data', { length: 750 }).default('NULL'),
+		content: longtext('content').notNull(),
+		navPlacement: longtext('navPlacement').default('NULL'),
+		weight: decimal('weight', { precision: 10, scale: 2 }).notNull(),
+		dateRecorded: datetime('date_recorded', { mode: 'string' }).notNull(),
+		lastModified: timestamp('last_modified', { mode: 'string' }).default(sql`current_timestamp()`),
+	});
+
+	const { statements, sqlStatements } = await diffIntrospect(db, { content }, 'double-quote-issue');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5546
+test('issue #5546', async () => {
+	await db.query(`CREATE TABLE my_table (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  col INT
+);`);
+	await db.query(`CREATE UNIQUE INDEX idx_functional 
+ON my_table ((CASE WHEN col = 1 THEN 1 ELSE NULL END));`);
+
+	await db.query(`CREATE TABLE base_table (
+  id INT, 
+  name VARCHAR(50)
+);
+`);
+
+	await db.query(`
+CREATE USER 'ghost_user'@'%' IDENTIFIED BY 'temp123';`);
+
+	await db.query(`CREATE DEFINER='ghost_user'@'%' VIEW broken_view AS SELECT * FROM base_table;`);
+
+	await db.query(`DROP USER 'ghost_user'@'%';`);
+
+	const { statements, sqlStatements, ddlAfterPull } = await diffIntrospect(db, {}, '#5546');
+
+	expect(ddlAfterPull.entities.list()).toStrictEqual([
+		{
+			entityType: 'tables',
+			name: 'base_table',
+		},
+		{
+			entityType: 'tables',
+			name: 'my_table',
+		},
+		{
+			autoIncrement: false,
+			charSet: null,
+			collation: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'id',
+			notNull: false,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			table: 'base_table',
+			type: 'int',
+		},
+		{
+			autoIncrement: false,
+			charSet: null,
+			collation: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'name',
+			notNull: false,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			table: 'base_table',
+			type: 'varchar(50)',
+		},
+		{
+			autoIncrement: true,
+			charSet: null,
+			collation: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'id',
+			notNull: true,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			table: 'my_table',
+			type: 'int',
+		},
+		{
+			autoIncrement: false,
+			charSet: null,
+			collation: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'col',
+			notNull: false,
+			onUpdateNow: false,
+			onUpdateNowFsp: null,
+			table: 'my_table',
+			type: 'int',
+		},
+		{
+			columns: [
+				'id',
+			],
+			entityType: 'pks',
+			name: 'PRIMARY',
+			table: 'my_table',
+		},
+		{
+			algorithm: null,
+			columns: [
+				{
+					isExpression: true,
+					value: '(case when (`col` = 1) then 1 else NULL end)',
+				},
+			],
+			entityType: 'indexes',
+			isUnique: true,
+			lock: null,
+			name: 'idx_functional',
+			nameExplicit: true,
+			table: 'my_table',
+			using: null,
+		},
+		{
+			algorithm: 'undefined',
+			definition:
+				'select `drizzle`.`base_table`.`id` AS `id`,`drizzle`.`base_table`.`name` AS `name` from `drizzle`.`base_table`',
+			entityType: 'views',
+			name: 'broken_view',
+			sqlSecurity: 'definer',
+			withCheckOption: null,
+		},
+	]);
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5911
+test('issue #5911', async () => {
+	await db.query(`CREATE TABLE products (
+  id        INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+  name      VARCHAR(255) NOT NULL,
+  rating    FLOAT         NOT NULL DEFAULT 1.3
+);`);
+
+	const { statements, sqlStatements, ddlAfterPull, ddlFromPulledTsSchema } = await diffIntrospect(db, {}, '#5546');
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+	const afterPull = ddlAfterPull.columns.one({ name: 'rating' });
+	const afterTs = ddlFromPulledTsSchema.columns.one({ name: 'rating' });
+	expect(afterPull?.default).toBe('1.3');
+	expect(afterPull?.notNull).toBe(true);
+	expect(afterTs?.default).toBe('1.3');
+	expect(afterTs?.notNull).toBe(true);
+});
diff --git a/drizzle-kit/tests/mysql/snapshot-v5.test.ts b/drizzle-kit/tests/mysql/snapshot-v5.test.ts
new file mode 100644
index 0000000000..1a78fb0be9
--- /dev/null
+++ b/drizzle-kit/tests/mysql/snapshot-v5.test.ts
@@ -0,0 +1,35 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffSnapshotV5, prepareTestDatabase, TestDatabase } from './mocks';
+import * as s01old from './snapshots/schema01';
+import * as s01 from './snapshots/schema01new';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// TODO
+// author: @AlexSherman
+// @AlexBlokh - I have added new fields in ddl. Just in case ping you
+test('s01', async (t) => {
+	const res = await diffSnapshotV5(db, s01, s01old);
+
+	// previous kit did generate `default '10.123'` for decimals which results in introspected '10' trimmed value
+	expect(res.all).toStrictEqual([
+		'ALTER TABLE `all_data_types` MODIFY COLUMN `decimal` decimal DEFAULT (10.123);',
+		'ALTER TABLE `all_data_types` MODIFY COLUMN `decimal_precision` decimal(6) DEFAULT (10.123);',
+		'ALTER TABLE `all_data_types` MODIFY COLUMN `decimal_precision_scale` decimal(6,2) DEFAULT (10.123);',
+	]);
+});
diff --git a/drizzle-kit/tests/mysql/snapshots/schema01.ts b/drizzle-kit/tests/mysql/snapshots/schema01.ts
new file mode 100644
index 0000000000..e93a76216f
--- /dev/null
+++ b/drizzle-kit/tests/mysql/snapshots/schema01.ts
@@ -0,0 +1,194 @@
+import { eq, SQL, sql } from 'orm044';
+import {
+	AnyMySqlColumn,
+	bigint,
+	binary,
+	boolean,
+	char,
+	check,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	foreignKey,
+	index,
+	int,
+	json,
+	longtext,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	mysqlView,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	tinytext,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'orm044/mysql-core';
+
+// TODO: extend massively cc: @OleksiiKH0240
+export const allDataTypes = mysqlTable('all_data_types', {
+	int: int('int').default(2147483647),
+	intScientific: int('int_scientific').default(1e4),
+	intExpression: int('int_expression').default(sql`(1 + 1)`),
+	tinyint: tinyint('tinyint').default(127),
+	smallint: smallint('smallint').default(32767),
+	mediumint: mediumint('mediumint').default(8388607),
+	bigintUnsigned: bigint('bigint_unsigned', { mode: 'bigint', unsigned: true }),
+	bigint53: bigint('bigint_53', { mode: 'number' }).default(9007199254740991),
+	bigint63: bigint('bigint_63', { mode: 'bigint' }).default(sql`9223372036854775807`),
+	real: real('real').default(10.123),
+	realPrecisionScale: real('real_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	decimal: decimal('decimal').default('10.123'),
+	decimalPrecision: decimal('decimal_precision', { precision: 6 }).default('10.123'),
+	decimalPrecisionScale: decimal('decimal_precision_scale', { precision: 6, scale: 2 }).default('10.123'),
+	decimalBigint: decimal('decimal_bigint', { precision: 19 }).default(sql`'9223372036854775807'`),
+	double: double('double').default(10.123),
+	doublePrecisionScale: double('double_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	doubleUnsigned: double('double_unsigned', { unsigned: true }).default(10.123),
+	float: float('float').default(10.123),
+	floatPrecision: float('float_precision', { precision: 6 }).default(10.123),
+	floatPrecisionScale: float('float_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	floatUnsigned: float('floatUnsigned', { unsigned: true }).default(10.123),
+	serial: serial('serial').primaryKey(),
+	binary: binary('binary', { length: 10 }).default('binary'),
+	binaryExpression: binary('binary_expression', { length: 10 }).default(sql`(lower('HELLO'))`),
+	varbinary: varbinary('varbinary', { length: 10 }).default('binary'),
+	varbinaryExpression: varbinary('varbinary_expression', { length: 10 }).default(sql`(lower('HELLO'))`),
+	char: char('char', { length: 255 }).default(`text'"\`:[]{},text`),
+	varchar: varchar('varchar', { length: 256 }).default(`text'"\`:[]{},text`),
+	text: text('text').default(`text'"\`:[]{},text`),
+	tinytext: tinytext('tinytext').default(sql`('text''"\`:[]{},text')`),
+	mediumtext: mediumtext('mediumtext').default(sql`('text''"\`:[]{},text')`),
+	longtext: longtext('longtext').default(sql`('text''"\`:[]{},text')`),
+	boolean: boolean('boolean').default(true),
+	booleanNull: boolean('boolean_null').default(sql`null`),
+	date: date('date', { mode: 'date' }),
+	datetime: datetime('datetime', { mode: 'date' }).default(new Date('2025-05-23T12:53:53.000Z')),
+	datetimeFsp: datetime('datetime_fsp', { mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+	time: time('time').default('15:50:33'),
+	timeFsp: time('time_fsp', { fsp: 3 }).default('15:50:33.123'),
+	year: year('year').default(2025),
+	timestamp: timestamp('timestamp', { mode: 'date' }).default(new Date('2025-05-23T12:53:53.000Z')),
+	timestampNow: timestamp('timestamp_now', { mode: 'date' }).defaultNow(),
+	timestampFsp: timestamp('timestamp_fsp', { mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+	jsonArray: json('json_array').default(sql`('[9223372036854775807, 9223372036854775806]')`),
+	json: json('json').default({ key: `text[]{},text` }),
+	mysqlEnum: mysqlEnum('popularity', ['unknown', 'known', 'popular']).default(
+		`popular`,
+	),
+});
+
+// constraints
+// unique
+export const uniqueTable = mysqlTable('unique_table', {
+	column1: int().primaryKey(),
+	column2: serial(),
+	column3: int().unique(),
+	column4: int().unique('column4_custom_unique_name'),
+	column5: int(),
+	column6: int(),
+}, (table) => [
+	unique().on(table.column5),
+	unique('custom_unique').on(table.column5, table.column6),
+]);
+
+// primary
+export const compositePrimaryKey = mysqlTable('composite_primary_key', {
+	column1: int(),
+	column2: varchar({ length: 10 }),
+}, (table) => [
+	primaryKey({ columns: [table.column1, table.column2] }),
+]);
+
+export const compositePrimaryKeyCustomName = mysqlTable('composite_primary_key_custom_name', {
+	column1: int(),
+	column2: varchar({ length: 10 }),
+}, (table) => [
+	primaryKey({ columns: [table.column1, table.column2], name: 'composite_primary_key_custom_name_' }),
+]);
+
+// references
+export const referencingTable = mysqlTable('referencing_table', {
+	column0: int(),
+	column1: int().unique().references(() => uniqueTable.column1, { onDelete: 'cascade', onUpdate: 'cascade' }),
+	column2: int(),
+	column3: int(),
+	column4: int(),
+	column5: varchar({ length: 10 }),
+	column6: int().references((): AnyMySqlColumn => referencingTable.column0),
+}, (table) => [
+	primaryKey({ columns: [table.column0] }),
+	foreignKey({
+		name: 'referencing_table_custom_fk1',
+		columns: [table.column2, table.column3],
+		foreignColumns: [uniqueTable.column5, uniqueTable.column6],
+	}),
+	foreignKey({
+		name: 'referencing_table_custom_fk2',
+		columns: [table.column4, table.column5],
+		foreignColumns: [compositePrimaryKey.column1, compositePrimaryKey.column2],
+	}),
+]);
+
+// generatedAlwaysAs, check, index, not null, auto increment
+export const table1 = mysqlTable('table1', {
+	column1: varchar({ length: 256 }).generatedAlwaysAs("'Default'"),
+	column2: varchar({ length: 256 }).generatedAlwaysAs((): SQL => sql`(concat(${table1.column1}, 'hello'))`, {
+		mode: 'stored',
+	}),
+	column3: varchar({ length: 256 }).generatedAlwaysAs((): SQL => sql`(concat(${table1.column1}, 'hello'))`, {
+		mode: 'virtual',
+	}),
+	column4: int().notNull().autoincrement().primaryKey(),
+	column5: int(),
+	column6: varchar({ length: 256 }),
+}, (table) => [
+	check('age_check1', sql`${table.column5} > 0`),
+	index('table1_column4_index').on(table.column4),
+	uniqueIndex('table1_column4_unique_index').on(table.column4),
+	index('table1_composite_index').on(table.column5, table.column6),
+	uniqueIndex('table1_composite_unique_index').on(table.column5, table.column6),
+]);
+
+// view
+export const table1View1 = mysqlView('table1_view1').as((qb) => qb.select().from(table1));
+export const table1View2 = mysqlView('table1_view2', {
+	column4: int().notNull().autoincrement(),
+}).as(
+	sql`select column4 from ${table1} where ${eq(table1.column4, 3)}`,
+);
+
+export const users = mysqlTable('users1', {
+	id: int().unique(),
+	id1: int(),
+	id2: int(),
+}, (t) => [
+	primaryKey({ columns: [t.id1, t.id2] }),
+]);
+
+export const analytics = mysqlSchema('analytics');
+
+export const analyticsEvents = analytics.table(
+	'events',
+	{
+		id: serial('id').primaryKey(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'set null' }),
+		type: varchar('type', { length: 64 }).notNull(),
+		payload: json('payload').default({}),
+		occurredAt: timestamp('occurred_at', { fsp: 3 }).notNull().defaultNow(),
+	},
+	(t) => [index('idx_analytics_events_user_time').on(t.userId, t.occurredAt)],
+);
diff --git a/drizzle-kit/tests/mysql/snapshots/schema01new.ts b/drizzle-kit/tests/mysql/snapshots/schema01new.ts
new file mode 100644
index 0000000000..466b94850a
--- /dev/null
+++ b/drizzle-kit/tests/mysql/snapshots/schema01new.ts
@@ -0,0 +1,194 @@
+import { eq, SQL, sql } from 'drizzle-orm';
+import {
+	AnyMySqlColumn,
+	bigint,
+	binary,
+	boolean,
+	char,
+	check,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	foreignKey,
+	index,
+	int,
+	json,
+	longtext,
+	mediumint,
+	mediumtext,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	mysqlView,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	tinytext,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+
+// TODO: extend massively cc: @OleksiiKH0240
+export const allDataTypes = mysqlTable('all_data_types', {
+	int: int('int').default(2147483647),
+	intScientific: int('int_scientific').default(1e4),
+	intExpression: int('int_expression').default(sql`(1 + 1)`),
+	tinyint: tinyint('tinyint').default(127),
+	smallint: smallint('smallint').default(32767),
+	mediumint: mediumint('mediumint').default(8388607),
+	bigintUnsigned: bigint('bigint_unsigned', { mode: 'bigint', unsigned: true }),
+	bigint53: bigint('bigint_53', { mode: 'number' }).default(9007199254740991),
+	bigint63: bigint('bigint_63', { mode: 'bigint' }).default(sql`9223372036854775807`),
+	real: real('real').default(10.123),
+	realPrecisionScale: real('real_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	decimal: decimal('decimal').default('10.123'),
+	decimalPrecision: decimal('decimal_precision', { precision: 6 }).default('10.123'),
+	decimalPrecisionScale: decimal('decimal_precision_scale', { precision: 6, scale: 2 }).default('10.123'),
+	decimalBigint: decimal('decimal_bigint', { precision: 19, mode: 'bigint' }).default(9223372036854775807n),
+	double: double('double').default(10.123),
+	doublePrecisionScale: double('double_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	doubleUnsigned: double('double_unsigned', { unsigned: true }).default(10.123),
+	float: float('float').default(10.123),
+	floatPrecision: float('float_precision', { precision: 6 }).default(10.123),
+	floatPrecisionScale: float('float_precision_scale', { precision: 6, scale: 2 }).default(10.12),
+	floatUnsigned: float('floatUnsigned', { unsigned: true }).default(10.123),
+	serial: serial('serial').primaryKey(),
+	binary: binary('binary', { length: 10 }).default('binary'),
+	binaryExpression: binary('binary_expression', { length: 10 }).default(sql`(lower('HELLO'))`),
+	varbinary: varbinary('varbinary', { length: 10 }).default('binary'),
+	varbinaryExpression: varbinary('varbinary_expression', { length: 10 }).default(sql`(lower('HELLO'))`),
+	char: char('char', { length: 255 }).default(`text'"\`:[]{},text`),
+	varchar: varchar('varchar', { length: 256 }).default(`text'"\`:[]{},text`),
+	text: text('text').default(`text'"\`:[]{},text`),
+	tinytext: tinytext('tinytext').default(sql`('text''"\`:[]{},text')`),
+	mediumtext: mediumtext('mediumtext').default(sql`('text''"\`:[]{},text')`),
+	longtext: longtext('longtext').default(sql`('text''"\`:[]{},text')`),
+	boolean: boolean('boolean').default(true),
+	booleanNull: boolean('boolean_null').default(sql`null`),
+	date: date('date', { mode: 'date' }),
+	datetime: datetime('datetime', { mode: 'date' }).default(new Date('2025-05-23T12:53:53.000Z')),
+	datetimeFsp: datetime('datetime_fsp', { mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+	time: time('time').default('15:50:33'),
+	timeFsp: time('time_fsp', { fsp: 3 }).default('15:50:33.123'),
+	year: year('year').default(2025),
+	timestamp: timestamp('timestamp', { mode: 'date' }).default(new Date('2025-05-23T12:53:53.000Z')),
+	timestampNow: timestamp('timestamp_now', { mode: 'date' }).defaultNow(),
+	timestampFsp: timestamp('timestamp_fsp', { mode: 'date', fsp: 3 }).default(new Date('2025-05-23T12:53:53.115Z')),
+	jsonArray: json('json_array').default(sql`('[9223372036854775807, 9223372036854775806]')`),
+	json: json('json').default({ key: `text[]{},text` }),
+	mysqlEnum: mysqlEnum('popularity', ['unknown', 'known', 'popular']).default(
+		`popular`,
+	),
+});
+
+// constraints
+// unique
+export const uniqueTable = mysqlTable('unique_table', {
+	column1: int().primaryKey(),
+	column2: serial(),
+	column3: int().unique(),
+	column4: int().unique('column4_custom_unique_name'),
+	column5: int(),
+	column6: int(),
+}, (table) => [
+	unique().on(table.column5),
+	unique('custom_unique').on(table.column5, table.column6),
+]);
+
+// primary
+export const compositePrimaryKey = mysqlTable('composite_primary_key', {
+	column1: int(),
+	column2: varchar({ length: 10 }),
+}, (table) => [
+	primaryKey({ columns: [table.column1, table.column2] }),
+]);
+
+export const compositePrimaryKeyCustomName = mysqlTable('composite_primary_key_custom_name', {
+	column1: int(),
+	column2: varchar({ length: 10 }),
+}, (table) => [
+	primaryKey({ columns: [table.column1, table.column2] }),
+]);
+
+// references
+export const referencingTable = mysqlTable('referencing_table', {
+	column0: int(),
+	column1: int().unique().references(() => uniqueTable.column1, { onDelete: 'cascade', onUpdate: 'cascade' }),
+	column2: int(),
+	column3: int(),
+	column4: int(),
+	column5: varchar({ length: 10 }),
+	column6: int().references((): AnyMySqlColumn => referencingTable.column0),
+}, (table) => [
+	primaryKey({ columns: [table.column0] }),
+	foreignKey({
+		name: 'referencing_table_custom_fk1',
+		columns: [table.column2, table.column3],
+		foreignColumns: [uniqueTable.column5, uniqueTable.column6],
+	}),
+	foreignKey({
+		name: 'referencing_table_custom_fk2',
+		columns: [table.column4, table.column5],
+		foreignColumns: [compositePrimaryKey.column1, compositePrimaryKey.column2],
+	}),
+]);
+
+// generatedAlwaysAs, check, index, not null, auto increment
+export const table1 = mysqlTable('table1', {
+	column1: varchar({ length: 256 }).generatedAlwaysAs(sql`'Default'`),
+	column2: varchar({ length: 256 }).generatedAlwaysAs((): SQL => sql`(concat(${table1.column1}, 'hello'))`, {
+		mode: 'stored',
+	}),
+	column3: varchar({ length: 256 }).generatedAlwaysAs((): SQL => sql`(concat(${table1.column1}, 'hello'))`, {
+		mode: 'virtual',
+	}),
+	column4: int().notNull().autoincrement().primaryKey(),
+	column5: int(),
+	column6: varchar({ length: 256 }),
+}, (table) => [
+	check('age_check1', sql`${table.column5} > 0`),
+	index('table1_column4_index').on(table.column4),
+	uniqueIndex('table1_column4_unique_index').on(table.column4),
+	index('table1_composite_index').on(table.column5, table.column6),
+	uniqueIndex('table1_composite_unique_index').on(table.column5, table.column6),
+]);
+
+// view
+export const table1View1 = mysqlView('table1_view1').as((qb) => qb.select().from(table1));
+export const table1View2 = mysqlView('table1_view2', {
+	column4: int().notNull().autoincrement(),
+}).as(
+	sql`select column4 from ${table1} where ${eq(table1.column4, 3)}`,
+);
+
+export const users = mysqlTable('users1', {
+	id: int().unique(),
+	id1: int(),
+	id2: int(),
+}, (t) => [
+	primaryKey({ columns: [t.id1, t.id2] }),
+]);
+
+export const analytics = mysqlSchema('analytics');
+
+export const analyticsEvents = analytics.table(
+	'events',
+	{
+		id: serial('id').primaryKey(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'set null' }),
+		type: varchar('type', { length: 64 }).notNull(),
+		payload: json('payload').default({}),
+		occurredAt: timestamp('occurred_at', { fsp: 3 }).notNull().defaultNow(),
+	},
+	(t) => [index('idx_analytics_events_user_time').on(t.userId, t.occurredAt)],
+);
diff --git a/drizzle-kit/tests/other/bin.test.ts b/drizzle-kit/tests/other/bin.test.ts
new file mode 100644
index 0000000000..94dedf91f0
--- /dev/null
+++ b/drizzle-kit/tests/other/bin.test.ts
@@ -0,0 +1,278 @@
+import chalk from 'chalk';
+import { assert, test } from 'vitest';
+import { analyzeImports, ChainLink } from '../../imports-checker/checker';
+
+const chainToString = (chains: ChainLink[]) => {
+	if (chains.length === 0) throw new Error();
+
+	let out = chains[0]!.file + '\n';
+	let indentation = 0;
+	for (let chain of chains) {
+		out += ' '.repeat(indentation)
+			+ '└'
+			+ chain.import
+			+ ` ${chalk.gray(chain.file)}\n`;
+		indentation += 1;
+	}
+	return out;
+};
+
+test('imports-issues', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: [
+			'@drizzle-team/brocli',
+			'get-tsconfig',
+			'path',
+			'fs',
+			'fs/*',
+			'url',
+			'zod',
+			'node:*',
+			'hono',
+			'glob',
+			'hono/*',
+			'hono/**/*',
+			'@hono/*',
+			'crypto',
+			'hanji',
+			'hanji/utils',
+			'chalk',
+			'dotenv/config',
+			'camelcase',
+			'semver',
+			'env-paths',
+			'@js-temporal/polyfill',
+			'ohm-js',
+		],
+		entry: 'src/cli/index.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+// test('imports-issues2', () => {
+// 	const issues = analyzeImports({
+// 		basePath: '.',
+// 		localPaths: ['src'],
+// 		whiteList: [
+// 			'zod',
+// 			// 'hanji',
+// 			// 'chalk',
+// 			// '@ewoudenberg/difflib',
+// 		],
+// 		entry: 'src/utils/studio.ts',
+// 		logger: true,
+// 		ignoreTypes: true,
+// 	}).issues;
+
+// 	console.log();
+// 	for (const issue of issues) {
+// 		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+// 		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+// 	}
+
+// 	assert.equal(issues.length, 0);
+// });
+
+test('check imports api-postgres', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/api-postgres.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports api-mysql', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/api-mysql.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports api-sqlite', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/api-sqlite.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports api-singlestore', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/api-singlestore.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports sqlite-studio', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/studio-sqlite.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports postgres-studio', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['camelcase', 'ohm-js', '@js-temporal/polyfill'],
+		entry: 'src/ext/studio-postgres.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports mysql-studio', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['camelcase', 'ohm-js', '@js-temporal/polyfill'],
+		entry: 'src/ext/studio-mysql.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports postgres-mover', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['camelcase', 'ohm-js', '@js-temporal/polyfill'],
+		entry: 'src/ext/mover-postgres.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+test('check imports mysql-mover', () => {
+	const issues = analyzeImports({
+		basePath: '.',
+		localPaths: ['src'],
+		whiteList: ['@js-temporal/polyfill', 'ohm-js'],
+		entry: 'src/ext/mover-mysql.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	console.log();
+	for (const issue of issues) {
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5183
+// https://github.com/drizzle-team/drizzle-orm/issues/5126
+test('check imports drizzle-orm/expo-sqlite/migrator', () => {
+	const issues = analyzeImports({
+		basePath: '../',
+		localPaths: ['../drizzle-orm/src'],
+		blackList: ['node:crypto', 'node:fs', 'node:path'],
+		entry: '../drizzle-orm/src/expo-sqlite/migrator.ts',
+		logger: true,
+		ignoreTypes: true,
+	}).issues;
+
+	for (const issue of issues) {
+		// console.log('imports', issue.imports);
+		// console.log('accessChains', issue.accessChains);
+		console.log(chalk.red(issue.imports.map((it) => it.name).join('\n')));
+		console.log(issue.accessChains.map((it) => chainToString(it)).join('\n'));
+	}
+
+	assert.equal(issues.length, 0);
+});
diff --git a/drizzle-kit/tests/other/check-fixtures.ts b/drizzle-kit/tests/other/check-fixtures.ts
new file mode 100644
index 0000000000..9a59f236b0
--- /dev/null
+++ b/drizzle-kit/tests/other/check-fixtures.ts
@@ -0,0 +1,88 @@
+import { integer as pgInteger, pgTable, varchar } from 'drizzle-orm/pg-core';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { PostgresSnapshot } from '../../src/dialects/postgres/snapshot';
+import { drizzleToDDL, type PostgresSchema } from '../postgres/mocks';
+
+export const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+export const makePgSnapshot = (id: string, prevIds: string[], schema: PostgresSchema): PostgresSnapshot => ({
+	version: '8',
+	dialect: 'postgres',
+	id,
+	prevIds,
+	ddl: drizzleToDDL(schema).ddl.entities.list(),
+	renames: [],
+});
+
+export const stageOut = (): string => {
+	// staged under tests/tmp/ (in-tree) so drizzle-kit's config-relative path resolution finds the snapshots; do not move to os.tmpdir()
+	mkdirSync('tests/tmp', { recursive: true });
+	return mkdtempSync('tests/tmp/dk-check-json-');
+};
+
+export const writeSnapshot = (out: string, tag: string, snapshot: unknown): void => {
+	const folder = join(out, tag);
+	mkdirSync(folder, { recursive: true });
+	writeFileSync(join(folder, 'snapshot.json'), JSON.stringify(snapshot, null, 2));
+};
+
+export const stageValid = (): string => {
+	const out = stageOut();
+	writeSnapshot(
+		out,
+		'0000_init',
+		makePgSnapshot('p1', [ORIGIN], { users: pgTable('users', { id: pgInteger('id') }) }),
+	);
+	return out;
+};
+
+export const stageConflict = (): string => {
+	const out = stageOut();
+	const parent = makePgSnapshot('p1', [ORIGIN], { users: pgTable('users', { email: varchar('email') }) });
+	const left = makePgSnapshot('a1', ['p1'], { users: pgTable('users', { email: varchar('email').notNull() }) });
+	const right = makePgSnapshot('b1', ['p1'], { users: pgTable('users', { email: pgInteger('email') }) });
+	writeSnapshot(out, '0000_parent', parent);
+	writeSnapshot(out, '0001_left', left);
+	writeSnapshot(out, '0002_right', right);
+	return out;
+};
+
+// Two branches each create a differently-shaped `orders` table from a shared parent
+// that lacks it — a create_table/create_table conflict whose target is the table itself
+// (kind 'table'), exercising the table path that stageConflict's column conflict does not.
+export const stageTableConflict = (): string => {
+	const out = stageOut();
+	const base = { users: pgTable('users', { id: pgInteger('id') }) };
+	const parent = makePgSnapshot('p1', [ORIGIN], base);
+	const left = makePgSnapshot('a1', ['p1'], { ...base, orders: pgTable('orders', { id: pgInteger('id') }) });
+	const right = makePgSnapshot('b1', ['p1'], { ...base, orders: pgTable('orders', { total: pgInteger('total') }) });
+	writeSnapshot(out, '0000_parent', parent);
+	writeSnapshot(out, '0001_left', left);
+	writeSnapshot(out, '0002_right', right);
+	return out;
+};
+
+export const stageUnsupported = (): string => {
+	const out = stageOut();
+	writeSnapshot(out, '0000_init', { version: '999', dialect: 'postgres', id: 'p1', prevIds: [ORIGIN], ddl: [] });
+	return out;
+};
+
+export const stageNonLatest = (): string => {
+	const out = stageOut();
+	writeSnapshot(out, '0000_init', { version: '1', dialect: 'postgres', id: 'p1', prevIds: [ORIGIN], ddl: [] });
+	return out;
+};
+
+export const stageMalformed = (): string => {
+	const out = stageOut();
+	writeSnapshot(out, '0000_init', {
+		version: '8',
+		dialect: 'postgres',
+		id: 'p1',
+		prevIds: [ORIGIN],
+		ddl: 'not-an-array',
+	});
+	return out;
+};
diff --git a/drizzle-kit/tests/other/check-handler.test.ts b/drizzle-kit/tests/other/check-handler.test.ts
new file mode 100644
index 0000000000..1f2813bd34
--- /dev/null
+++ b/drizzle-kit/tests/other/check-handler.test.ts
@@ -0,0 +1,499 @@
+import { integer, pgTable, varchar } from 'drizzle-orm/pg-core';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { checkHandler } from 'src/cli/commands/check';
+import { createDDL } from 'src/dialects/postgres/ddl';
+import { generateLatestSnapshot } from 'src/dialects/postgres/serializer';
+import type { PostgresSnapshot } from 'src/dialects/postgres/snapshot';
+import type { JsonStatement } from 'src/dialects/postgres/statements';
+import { expect, test } from 'vitest';
+import { drizzleToDDL, type PostgresSchema } from '../postgres/mocks';
+
+const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+function makeSnapshot(
+	id: string,
+	prevIds: string[],
+	schema: PostgresSchema,
+): PostgresSnapshot {
+	return {
+		version: '8',
+		dialect: 'postgres',
+		id,
+		prevIds,
+		ddl: drizzleToDDL(schema).ddl.entities.list(),
+		renames: [],
+	};
+}
+
+function snapshotPath(out: string, tag: string, snapshot: PostgresSnapshot) {
+	const folder = join(out, tag);
+	mkdirSync(folder, { recursive: true });
+	const path = join(folder, 'snapshot.json');
+	writeFileSync(path, JSON.stringify(snapshot, null, 2));
+	return path;
+}
+
+test('returns aggregated leaf statements with common parent snapshot for commutative open branches', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const parentSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+	};
+
+	const leftSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		likes: pgTable('likes', {
+			id: integer('id'),
+		}),
+	};
+
+	const rightSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+
+	const parent = makeSnapshot('p1', [ORIGIN], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+
+	snapshotPath(out, '000_parent', parent);
+	snapshotPath(out, '001_left', left);
+	snapshotPath(out, '002_right', right);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect(result.parentSnapshot).not.toBeNull();
+	expect((result.parentSnapshot as PostgresSnapshot).id).toBe('p1');
+	expect(result.leafIds).toStrictEqual(['a1', 'b1']);
+	expect(result.statements.length).toBeGreaterThan(0);
+});
+
+test('returns empty statements when branches are already merged into one leaf', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const parentSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+	};
+
+	const leftSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		likes: pgTable('likes', {
+			id: integer('id'),
+		}),
+	};
+
+	const rightSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+
+	const mergedSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		likes: pgTable('likes', {
+			id: integer('id'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+
+	const parent = makeSnapshot('p1', [ORIGIN], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+	const merged = makeSnapshot('m1', ['a1', 'b1'], mergedSchema);
+
+	snapshotPath(out, '000_parent', parent);
+	snapshotPath(out, '001_left', left);
+	snapshotPath(out, '002_right', right);
+	snapshotPath(out, '003_merged', merged);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect(result.statements).toStrictEqual([]);
+	expect(result.parentSnapshot).toBeNull();
+	expect(result.nonCommutativityMessage).toBeUndefined();
+});
+
+test('returns non-commutativity message and no statements for conflicting branches', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const parentSchema = {
+		users: pgTable('users', {
+			email: varchar('email'),
+		}),
+	};
+
+	const leftSchema = {
+		users: pgTable('users', {
+			email: varchar('email').notNull(),
+		}),
+	};
+
+	const rightSchema = {
+		users: pgTable('users', {
+			email: integer('email'),
+		}),
+	};
+
+	const parent = makeSnapshot('p1', [ORIGIN], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+
+	snapshotPath(out, '000_parent', parent);
+	snapshotPath(out, '001_left', left);
+	snapshotPath(out, '002_right', right);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect(result.statements).toStrictEqual([]);
+	expect(result.nonCommutativityMessage).toContain(
+		'Non-commutative migrations detected',
+	);
+});
+
+test('ignoreConflicts keeps all open leaf ids for conflicting branches', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const parentSchema = {
+		users: pgTable('users', {
+			email: varchar('email'),
+		}),
+	};
+
+	const leftSchema = {
+		users: pgTable('users', {
+			email: varchar('email').notNull(),
+		}),
+	};
+
+	const rightSchema = {
+		users: pgTable('users', {
+			email: integer('email'),
+		}),
+	};
+
+	const parent = makeSnapshot('p1', [ORIGIN], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+
+	snapshotPath(out, '000_parent', parent);
+	snapshotPath(out, '001_left', left);
+	snapshotPath(out, '002_right', right);
+
+	const result = await checkHandler(out, 'postgresql', true, false);
+
+	expect(result.statements).toStrictEqual([]);
+	expect(result.parentSnapshot).toBeNull();
+	expect(result.leafIds).toStrictEqual(['a1', 'b1']);
+	expect(result.nonCommutativityMessage).toBeUndefined();
+});
+
+test('does not report conflicts when sibling branches converge to the same terminal leaf', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const rootSchema = {};
+	const parentSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+	};
+	const leftSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		likes: pgTable('likes', {
+			id: integer('id'),
+		}),
+	};
+	const rightSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+	const mergedSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+		likes: pgTable('likes', {
+			id: integer('id'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+
+	const root = makeSnapshot('r1', [ORIGIN], rootSchema);
+	const parent = makeSnapshot('p1', ['r1'], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+	const merged = makeSnapshot('m1', ['a1', 'b1'], mergedSchema);
+
+	snapshotPath(out, '000_root', root);
+	snapshotPath(out, '001_parent', parent);
+	snapshotPath(out, '002_left', left);
+	snapshotPath(out, '003_right', right);
+	snapshotPath(out, '004_merged', merged);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect(result.statements).toStrictEqual([]);
+	expect(result.parentSnapshot).toBeNull();
+	expect(result.nonCommutativityMessage).toBeUndefined();
+});
+
+test('reports only active leaf conflict after branch merge and re-split', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	const rootSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+	};
+	const parentSchema = {
+		users: pgTable('users', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+		posts: pgTable('posts', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+	};
+	const leftSchema = {
+		...parentSchema,
+		likes: pgTable('likes', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+	};
+	const rightSchema = {
+		...parentSchema,
+		groups: pgTable('groups', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+	};
+	const mergedSchema = {
+		...parentSchema,
+		likes: pgTable('likes', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+	};
+	const splitOneSchema = {
+		...parentSchema,
+		likes: pgTable('likes', {
+			id: integer('id'),
+			text: varchar('text'),
+		}),
+		groups: pgTable('groups', {
+			id: integer('id'),
+		}),
+	};
+	const splitTwoSchema = {
+		...splitOneSchema,
+	};
+
+	const root = makeSnapshot('r1', [ORIGIN], rootSchema);
+	const parent = makeSnapshot('p1', ['r1'], parentSchema);
+	const left = makeSnapshot('a1', ['p1'], leftSchema);
+	const right = makeSnapshot('b1', ['p1'], rightSchema);
+	const merged = makeSnapshot('m1', ['a1', 'b1'], mergedSchema);
+	const splitOne = makeSnapshot('s1', ['m1'], splitOneSchema);
+	const splitTwo = makeSnapshot('s2', ['m1'], splitTwoSchema);
+
+	snapshotPath(out, '000_root', root);
+	snapshotPath(out, '001_parent', parent);
+	snapshotPath(out, '002_left', left);
+	snapshotPath(out, '003_right', right);
+	snapshotPath(out, '004_merged', merged);
+	snapshotPath(out, '005_split_one', splitOne);
+	snapshotPath(out, '006_split_two', splitTwo);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect(result.nonCommutativityMessage).toContain(
+		'drop_column: text on groups table',
+	);
+	expect(result.nonCommutativityMessage).not.toContain(
+		'create_table: groups in public schema',
+	);
+});
+
+test('nested open fork merges all heads at their LCA with de-duplicated statements', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	// p
+	// ├── a (leaf)
+	// └── b
+	//     ├── bx (leaf)
+	//     └── by (leaf)
+	// All three heads merge in one step based at their lowest common ancestor p.
+	// bx and by both inherit `create table b`, so the per-head diffs overlap; the
+	// merge migration must replay `create table b` exactly once.
+	const t = (...names: string[]) =>
+		Object.fromEntries(
+			['t', ...names].map((name) => [name, pgTable(name, { id: integer('id') })]),
+		);
+
+	const p = makeSnapshot('p1', [ORIGIN], t());
+	const a = makeSnapshot('a1', ['p1'], t('a'));
+	const b = makeSnapshot('b1', ['p1'], t('b'));
+	const bx = makeSnapshot('bx1', ['b1'], t('b', 'x'));
+	const by = makeSnapshot('by1', ['b1'], t('b', 'y'));
+
+	snapshotPath(out, '000_p', p);
+	snapshotPath(out, '001_a', a);
+	snapshotPath(out, '002_b', b);
+	snapshotPath(out, '003_bx', bx);
+	snapshotPath(out, '004_by', by);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	expect((result.parentSnapshot as PostgresSnapshot)?.id).toBe('p1');
+	expect(result.leafIds).toStrictEqual(['a1', 'bx1', 'by1']);
+
+	const createdTables = result.statements
+		.filter((statement) => (statement as any).type === 'create_table')
+		.map((statement) => (statement as any).table.name)
+		.sort();
+	// `t` already exists at the base p; `b` is inherited by both bx and by but
+	// appears only once after de-duplication.
+	expect(createdTables).toStrictEqual(['a', 'b', 'x', 'y']);
+});
+
+test('open merge composes alters and fk across a deep branch and a shallow branch', async () => {
+	mkdirSync('tests/tmp', { recursive: true });
+	const out = mkdtempSync('tests/tmp/dk-check-handler-');
+
+	// parent (create t1)
+	// ├── leaf1                  alter t1.a -> not null
+	// └── leaf2 (create t2)
+	//     └── leaf3              add fk t2.t1_id -> t1.id
+	//         └── leaf4          alter t1.b -> not null
+	// Open heads are leaf1 and leaf4 (leaf2/leaf3 are internal). Their lowest
+	// common ancestor is the parent, so the merge composes one alter from the
+	// shallow head and (create t2 + fk + the other alter) from the deep head.
+	const parentSchema = {
+		t1: pgTable('t1', {
+			id: integer('id').primaryKey(),
+			a: varchar('a'),
+			b: varchar('b'),
+		}),
+	};
+
+	const leaf1Schema = {
+		t1: pgTable('t1', {
+			id: integer('id').primaryKey(),
+			a: varchar('a').notNull(),
+			b: varchar('b'),
+		}),
+	};
+
+	const leaf2Schema = {
+		t1: pgTable('t1', {
+			id: integer('id').primaryKey(),
+			a: varchar('a'),
+			b: varchar('b'),
+		}),
+		t2: pgTable('t2', {
+			id: integer('id'),
+			t1Id: integer('t1_id'),
+		}),
+	};
+
+	const leaf3T1 = pgTable('t1', {
+		id: integer('id').primaryKey(),
+		a: varchar('a'),
+		b: varchar('b'),
+	});
+	const leaf3Schema = {
+		t1: leaf3T1,
+		t2: pgTable('t2', {
+			id: integer('id'),
+			t1Id: integer('t1_id').references(() => leaf3T1.id),
+		}),
+	};
+
+	const leaf4T1 = pgTable('t1', {
+		id: integer('id').primaryKey(),
+		a: varchar('a'),
+		b: varchar('b').notNull(),
+	});
+	const leaf4Schema = {
+		t1: leaf4T1,
+		t2: pgTable('t2', {
+			id: integer('id'),
+			t1Id: integer('t1_id').references(() => leaf4T1.id),
+		}),
+	};
+
+	const parent = makeSnapshot('p1', [ORIGIN], parentSchema);
+	const leaf1 = makeSnapshot('l1', ['p1'], leaf1Schema);
+	const leaf2 = makeSnapshot('l2', ['p1'], leaf2Schema);
+	const leaf3 = makeSnapshot('l3', ['l2'], leaf3Schema);
+	const leaf4 = makeSnapshot('l4', ['l3'], leaf4Schema);
+
+	snapshotPath(out, '000_parent', parent);
+	snapshotPath(out, '001_leaf1', leaf1);
+	snapshotPath(out, '002_leaf2', leaf2);
+	snapshotPath(out, '003_leaf3', leaf3);
+	snapshotPath(out, '004_leaf4', leaf4);
+
+	const result = await checkHandler(out, 'postgresql', false, false);
+
+	// Base is the LCA, and the merge parents are the open heads only — never the
+	// internal leaf2/leaf3.
+	expect((result.parentSnapshot as PostgresSnapshot)?.id).toBe('p1');
+	expect(result.leafIds).toStrictEqual(['l1', 'l4']);
+
+	// Reconstruct the merged snapshot exactly as the serializer does downstream,
+	// then assert it is the union of both heads.
+	const merged = generateLatestSnapshot(
+		result.parentSnapshot as PostgresSnapshot,
+		result.statements as JsonStatement[],
+	);
+	const ddl = createDDL();
+	ddl.entities.pushAll(merged.ddl);
+
+	// both alters landed, each coming from a different head
+	expect(ddl.columns.one({ schema: 'public', table: 't1', name: 'a' })?.notNull).toBe(true);
+	expect(ddl.columns.one({ schema: 'public', table: 't1', name: 'b' })?.notNull).toBe(true);
+	// the deep branch's table and its fk landed
+	expect(ddl.tables.one({ schema: 'public', name: 't2' })).not.toBeNull();
+	expect(ddl.fks.list({ schema: 'public', table: 't2' }).length).toBe(1);
+});
diff --git a/drizzle-kit/tests/other/cli-check.test.ts b/drizzle-kit/tests/other/cli-check.test.ts
new file mode 100644
index 0000000000..d61633c438
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-check.test.ts
@@ -0,0 +1,135 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'node:fs';
+import { afterEach, assert, expect, test } from 'vitest';
+import { CheckConfig } from '../../src/cli/commands/utils';
+import { check } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+afterEach(() => {
+	process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix ?? './tests/cli/';
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({ dialect: 'postgresql' }, prefix);
+
+	const res = await brotest(check, `--config=${name} --ignore-conflicts=false`);
+
+	unlinkSync(path);
+
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: CheckConfig & { output: 'text' | 'json' } = {
+		dialect: 'postgresql',
+		out: 'drizzle',
+		ignoreConflicts: false,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async (t) => {
+	const res = await brotest(check, `--dialect=postgresql --out=test --ignore-conflicts=true`);
+
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: CheckConfig & { output: 'text' | 'json' } = {
+		dialect: 'postgresql',
+		out: 'test',
+		ignoreConflicts: true,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig({ dialect: 'postgresql', out: 'test' }, prefix);
+
+	const res = await brotest(check, `--config=${name}`);
+
+	unlinkSync(path);
+
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: CheckConfig & { output: 'text' | 'json' } = {
+		dialect: 'postgresql',
+		out: 'test',
+		ignoreConflicts: undefined,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #4', async (t) => {
+	const { path, name } = createConfig(
+		// @ts-expect-error
+		{ out: 'test' },
+		prefix,
+	);
+
+	const res = await brotest(check, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[error('Please provide required params:'), wrapParam('dialect', undefined)].join('\n'),
+	);
+});
+
+test('validate config #5', async (t) => {
+	const res = await brotest(check, `--out=test`);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[error('Please provide required params:'), wrapParam('dialect', undefined)].join('\n'),
+	);
+});
+
+type CheckConfigWithOutput = CheckConfig & { output: 'text' | 'json' };
+
+test.each(['json', 'text'] as const)('output option parses %s mode', async (mode) => {
+	const res = await brotest(check, `--dialect=postgresql --out=test --output=${mode}`);
+
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: CheckConfigWithOutput = {
+		dialect: 'postgresql',
+		out: 'test',
+		ignoreConflicts: undefined,
+		output: mode,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('output defaults to text when omitted', async (t) => {
+	const res = await brotest(check, `--dialect=postgresql --out=test`);
+
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: CheckConfigWithOutput = {
+		dialect: 'postgresql',
+		out: 'test',
+		ignoreConflicts: undefined,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('output option rejects an invalid value', async (t) => {
+	const res = await brotest(check, `--dialect=postgresql --out=test --output=bogus`);
+
+	expect(res.type).not.toBe('handler');
+});
diff --git a/drizzle-kit/tests/other/cli-export.test.ts b/drizzle-kit/tests/other/cli-export.test.ts
new file mode 100644
index 0000000000..2dce9f1003
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-export.test.ts
@@ -0,0 +1,183 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { afterEach, assert, expect, test, vi } from 'vitest';
+import { ExportConfig } from '../../src/cli/commands/utils';
+import { exportRaw } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+
+afterEach(() => {
+	if (originalPrefix === undefined) {
+		process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+	} else {
+		process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+	}
+});
+
+// good:
+// #1 drizzle-kit export --dialect=postgresql --schema=schema.ts
+// #3 drizzle-kit export
+// #3 drizzle-kit export --config=drizzle1.config.ts
+
+// errors:
+// #1 drizzle-kit export --schema=src/schema.ts
+// #2 drizzle-kit export --dialect=postgresql
+// #3 drizzle-kit export --dialect=postgresql2
+// #4 drizzle-kit export --config=drizzle.config.ts --schema=schema.ts
+// #5 drizzle-kit export --config=drizzle.config.ts --dialect=postgresql
+
+const filename = join(process.cwd(), 'tests/cli/schema.ts');
+test('export #1', async (t) => {
+	const res = await brotest(
+		exportRaw,
+		'--dialect=postgresql --schema=schema.ts',
+	);
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		filenames: [filename],
+		sql: true,
+		output: 'text',
+	});
+});
+
+test('export #2', async (t) => {
+	const res = await brotest(exportRaw, '');
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		filenames: [filename],
+		sql: true,
+		output: 'text',
+	});
+});
+
+// custom config path
+test('export #3', async (t) => {
+	const res = await brotest(exportRaw, '--config=expo.config.ts');
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		filenames: [filename],
+		sql: true,
+		output: 'text',
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(exportRaw, '--schema=src/schema.ts');
+	assert.equal(res.type, 'error');
+});
+
+test('err #2', async (t) => {
+	const res = await brotest(exportRaw, '--dialect=postgresql');
+	assert.equal(res.type, 'error');
+});
+
+test('err #3', async (t) => {
+	const res = await brotest(exportRaw, '--dialect=postgresql2');
+	assert.equal(res.type, 'error');
+});
+
+test('err #4', async (t) => {
+	const res = await brotest(exportRaw, '--config=drizzle.config.ts --schema=schema.ts');
+	assert.equal(res.type, 'error');
+});
+
+test('err #5', async (t) => {
+	const res = await brotest(exportRaw, '--config=drizzle.config.ts --dialect=postgresql');
+	assert.equal(res.type, 'error');
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({ dialect: 'postgresql', schema: 'schema.ts' }, prefix);
+
+	const res = await brotest(exportRaw, `--config=${name} --sql=false`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: ExportConfig = {
+		dialect: 'postgresql',
+		filenames: [filename],
+		sql: false,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+test('validate config #2', async (t) => {
+	const { path, name } = createConfig(
+		{ dialect: 'postgresql', schema: 'schema.ts' },
+		prefix,
+	);
+
+	const res = await brotest(exportRaw, `--config=${name} --sql=true`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: ExportConfig = {
+		dialect: 'postgresql',
+		filenames: [filename],
+		sql: true,
+		output: 'text',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig(
+		{ dialect: 'postgresql' },
+		prefix,
+	);
+
+	const res = await brotest(exportRaw, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[
+			error('Please provide required params:'),
+			wrapParam('dialect', 'postgresql'),
+			wrapParam('schema', undefined),
+		].join('\n'),
+	);
+});
+
+test('validate config #4', async (t) => {
+	const { path, name } = createConfig(
+		// @ts-expect-error
+		{ schema: 'schema.ts' },
+		prefix,
+	);
+
+	const res = await brotest(exportRaw, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[
+			error('Please provide required params:'),
+			wrapParam('dialect', undefined),
+			wrapParam('schema', 'schema.ts'),
+		].join('\n'),
+	);
+});
diff --git a/drizzle-kit/tests/other/cli-generate.test.ts b/drizzle-kit/tests/other/cli-generate.test.ts
new file mode 100644
index 0000000000..04c6b07187
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-generate.test.ts
@@ -0,0 +1,510 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { afterEach, assert, expect, test, vi } from 'vitest';
+import { GenerateConfig } from '../../src/cli/commands/utils';
+import { HintsHandler } from '../../src/cli/hints';
+import { generate } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+
+afterEach(() => {
+	if (originalPrefix === undefined) {
+		process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+	} else {
+		process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+	}
+});
+
+// good:
+// #1 drizzle-kit generate --dialect=postgresql --schema=schema.ts
+// #2 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out
+// #3 drizzle-kit generate
+// #4 drizzle-kit generate --custom
+// #5 drizzle-kit generate --name=custom
+// #6 drizzle-kit generate
+// #7 drizzle-kit generate --name=custom --custom
+// #8 drizzle-kit generate --config=drizzle1.config.ts
+// #9 drizzle-kit generate --dialect=postgresql --schema=schema.ts --out=out --name=custom --custom
+
+// errors:
+// #1 drizzle-kit generate --schema=src/schema.ts
+// #2 drizzle-kit generate --dialect=postgresql
+// #3 drizzle-kit generate --dialect=postgresql2
+// #4 drizzle-kit generate --driver=expo
+// #5 drizzle-kit generate --dialect=postgresql --out=out
+// #6 drizzle-kit generate --config=drizzle.config.ts --out=out
+// #7 drizzle-kit generate --config=drizzle.config.ts --schema=schema.ts
+// #8 drizzle-kit generate --config=drizzle.config.ts --dialect=postgresql
+
+const filename = join(process.cwd(), 'tests/cli/schema.ts');
+
+test('generate #1', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts',
+	);
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('generate #2', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts --out=out',
+	);
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'out',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('generate #3', async (t) => {
+	const res = await brotest(generate, '');
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// config | pass through custom
+test('generate #4', async (t) => {
+	const res = await brotest(generate, '--custom');
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: true,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// config | pass through name
+test('generate #5', async (t) => {
+	const res = await brotest(generate, '--name=custom');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// config
+test('generate #6', async (t) => {
+	const res = await brotest(generate, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// config | pass through name and custom
+test('generate #7', async (t) => {
+	const res = await brotest(generate, '--name=custom --custom');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: true,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// custom config path
+test('generate #8', async (t) => {
+	const res = await brotest(generate, '--config=expo.config.ts');
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: true, // expo driver
+
+		driver: 'expo',
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('generate #9', async (t) => {
+	const res = await brotest(generate, '--config=durable-sqlite.config.ts');
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: true, // expo driver
+
+		driver: 'durable-sqlite',
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// cli | pass through name and custom
+test('generate #9', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts --out=out --name=custom --custom',
+	);
+
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: 'custom',
+		custom: true,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'out',
+		bundle: false,
+
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: false,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('generate #10 tsconfig paths', async () => {
+	const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+	process.env.TEST_CONFIG_PATH_PREFIX = './tests/fixtures/tsconfig-paths/';
+
+	const filename = join(process.cwd(), 'tests/fixtures/tsconfig-paths/entry.ts');
+	try {
+		const res = await brotest(generate, '--config=drizzle.config.ts');
+		if (res.type !== 'handler') assert.fail(res.type, 'handler');
+		expect(res.options).toStrictEqual({
+			dialect: 'postgresql',
+			ignoreConflicts: false,
+			name: undefined,
+			custom: false,
+			breakpoints: true,
+			out: 'drizzle',
+			bundle: false,
+
+			driver: undefined,
+			filenames: [filename],
+			schemaSource: expect.anything(),
+			explain: false,
+			hints: expect.any(HintsHandler),
+		});
+	} finally {
+		if (originalPrefix === undefined) {
+			delete process.env.TEST_CONFIG_PATH_PREFIX;
+		} else {
+			process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+		}
+	}
+});
+
+test('generate --explain', async (t) => {
+	const res = await brotest(
+		generate,
+		'--dialect=postgresql --schema=schema.ts --explain',
+	);
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		name: undefined,
+		custom: false,
+		breakpoints: true,
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		out: 'drizzle',
+		bundle: false,
+		driver: undefined,
+		ignoreConflicts: false,
+		explain: true,
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(generate, '--schema=src/schema.ts');
+	assert.equal(res.type, 'error');
+});
+
+test('err #2', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql');
+	assert.equal(res.type, 'error');
+});
+
+test('err #3', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql2');
+	assert.equal(res.type, 'error');
+});
+
+test('err #4', async (t) => {
+	const res = await brotest(generate, '--driver=expo');
+	assert.equal(res.type, 'error');
+});
+
+test('err #5', async (t) => {
+	const res = await brotest(generate, '--dialect=postgresql --out=out');
+	assert.equal(res.type, 'error');
+});
+
+test('err #6', async (t) => {
+	const res = await brotest(generate, '--config=drizzle.config.ts --out=out');
+	assert.equal(res.type, 'error');
+});
+
+test('err #7', async (t) => {
+	const res = await brotest(
+		generate,
+		'--config=drizzle.config.ts --schema=schema.ts',
+	);
+	assert.equal(res.type, 'error');
+});
+
+test('err #8', async (t) => {
+	const res = await brotest(
+		generate,
+		'--config=drizzle.config.ts --dialect=postgresql',
+	);
+	assert.equal(res.type, 'error');
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: '' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+	}, prefix);
+
+	const res = await brotest(generate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: GenerateConfig = {
+		dialect: 'postgresql',
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		breakpoints: false,
+		bundle: false,
+		custom: false,
+		out: 'drizzle',
+		driver: undefined,
+		ignoreConflicts: false,
+		name: undefined,
+		explain: false,
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: '' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: true,
+		driver: 'pglite',
+		out: 'test',
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(generate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: GenerateConfig = {
+		dialect: 'postgresql',
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		breakpoints: true,
+		bundle: false,
+		custom: false,
+		out: 'test',
+		driver: 'pglite',
+		ignoreConflicts: false,
+		name: undefined,
+		explain: false,
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig(
+		{ dialect: 'postgresql', driver: 'aws-data-api', out: 'test' },
+		prefix,
+	);
+
+	const res = await brotest(generate, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[
+			error('Please provide required params:'),
+			wrapParam('dialect', 'postgresql'),
+			wrapParam('schema', undefined),
+		].join('\n'),
+	);
+});
+
+test('validate config #4', async (t) => {
+	const { path, name } = createConfig(
+		// @ts-expect-error
+		{ dialect: 1, schema: 'path-to-schema' },
+		prefix,
+	);
+
+	const res = await brotest(generate, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).name).toBe('ConfigValidationCliError');
+});
+
+test('validate config #5', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'sqlite',
+		driver: 'd1-http',
+		schema: 'schema.ts',
+	}, prefix);
+
+	const res = await brotest(generate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected: GenerateConfig = {
+		dialect: 'sqlite',
+		filenames: [filename],
+		schemaSource: expect.anything(),
+		breakpoints: true,
+		bundle: false,
+		custom: false,
+		out: 'drizzle',
+		driver: 'd1-http',
+		ignoreConflicts: false,
+		name: undefined,
+		explain: false,
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
diff --git a/drizzle-kit/tests/other/cli-json.test.ts b/drizzle-kit/tests/other/cli-json.test.ts
new file mode 100644
index 0000000000..2b2a425001
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-json.test.ts
@@ -0,0 +1,1727 @@
+import { PGlite } from '@electric-sql/pglite';
+import { createClient as createLibsqlClient } from '@libsql/client';
+import BetterSqlite3 from 'better-sqlite3';
+import { spawnSync } from 'child_process';
+import { sql } from 'drizzle-orm';
+import { integer as pgInteger, pgPolicy, pgSchema, pgTable, text as pgText } from 'drizzle-orm/pg-core';
+import { check, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'fs';
+import { stripAnsi } from 'hanji/utils';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { HintsHandler } from '../../src/cli/hints';
+import {
+	fromExports as pgFromExports,
+	type PreparedPostgresSchema,
+	SchemaSource as PgSchemaSource,
+} from '../../src/dialects/postgres/drizzle';
+import {
+	fromExports as sqliteFromExports,
+	SchemaSource as SqliteSchemaSource,
+} from '../../src/dialects/sqlite/drizzle';
+import {
+	ORIGIN as _ORIGIN,
+	stageConflict as _stageConflict,
+	stageOut as _stageOut,
+	stageTableConflict as _stageTableConflict,
+	stageValid as _stageValid,
+	writeSnapshot as _writeSnapshot,
+} from './check-fixtures';
+
+const runWithCliContext = async <T>(
+	context: { output: 'text' | 'json'; interactive: boolean },
+	callback: () => Promise<T> | T,
+): Promise<T> => {
+	const ctx = await import('../../src/cli/context');
+	return ctx.runWithCliContext(context, callback);
+};
+
+const sqliteDbFrom = (client: BetterSqlite3.Database) => {
+	return {
+		query: async <T>(query: string, params: unknown[] = []) => {
+			return client.prepare(query).bind(...params).all() as T[];
+		},
+		run: async (query: string) => {
+			client.prepare(query).run();
+		},
+		batch: async (sqlStatements: string[]) => {
+			for (const stmt of sqlStatements) {
+				client.prepare(stmt).run();
+			}
+		},
+	};
+};
+
+const libsqlDbFrom = (client: ReturnType<typeof createLibsqlClient>) => {
+	return {
+		query: async <T>(query: string, params: unknown[] = []) => {
+			return client.execute({ sql: query, args: params as never }).then((it) => it.rows as unknown as T[]);
+		},
+		run: async (query: string) => {
+			await client.execute(query);
+		},
+		batch: async (sqlStatements: string[]) => {
+			await client.batch(sqlStatements, 'write');
+		},
+	};
+};
+
+const runPushPostgres = async (
+	schema: PreparedPostgresSchema,
+	hints: HintsHandler,
+	client: PGlite,
+) => {
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+	return runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			hints,
+		));
+};
+
+const runCli = (argv: string[], env: NodeJS.ProcessEnv = {}) => {
+	const script = [
+		'(async () => {',
+		`process.argv = ${JSON.stringify(['node', 'drizzle-kit', ...argv])};`,
+		"await import('./src/cli/index.ts');",
+		'})().catch((err) => {',
+		'console.error(err);',
+		'process.exit(1);',
+		'});',
+	].join(' ');
+
+	return spawnSync('pnpm', ['exec', 'tsx', '-e', script], {
+		cwd: process.cwd(),
+		encoding: 'utf8',
+		env: { ...process.env, ...env },
+	});
+};
+
+const resetMockedModules = () => {
+	for (
+		const modulePath of [
+			'../../src/cli/views',
+			'../../src/cli/utils',
+			'../../src/cli/commands/pull-postgres',
+			'../../src/cli/commands/pull-mysql',
+			'../../src/cli/commands/pull-sqlite',
+			'../../src/cli/commands/pull-cockroach',
+			'../../src/cli/connections',
+			'../../src/utils/utils-node',
+			'../../src/dialects/drizzle',
+			'../../src/dialects/pull-utils',
+			'../../src/dialects/postgres/drizzle',
+			'../../src/dialects/postgres/ddl',
+			'../../src/dialects/postgres/diff',
+			'../../src/dialects/postgres/introspect',
+			'../../src/dialects/postgres/serializer',
+			'../../src/dialects/mysql/drizzle',
+			'../../src/dialects/mysql/ddl',
+			'../../src/dialects/mysql/diff',
+			'../../src/dialects/sqlite/drizzle',
+			'../../src/dialects/sqlite/ddl',
+			'../../src/dialects/sqlite/diff',
+			'../../src/dialects/sqlite/serializer',
+			'../../src/dialects/cockroach/drizzle',
+			'../../src/dialects/cockroach/ddl',
+			'../../src/dialects/cockroach/diff',
+			'../../src/dialects/cockroach/introspect',
+			'../../src/cli/commands/pull-mssql',
+			'../../src/dialects/mssql/drizzle',
+			'../../src/dialects/mssql/ddl',
+			'../../src/dialects/mssql/diff',
+			'../../src/dialects/mssql/introspect',
+			'../../src/dialects/mysql/introspect',
+			'../../src/dialects/singlestore/drizzle',
+			'../../src/dialects/singlestore/diff',
+		]
+	) {
+		vi.doUnmock(modulePath);
+	}
+};
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	resetMockedModules();
+	vi.resetModules();
+});
+
+test('root --version prints human-readable output', () => {
+	const result = runCli(['--version']);
+
+	expect(result.status).toBe(0);
+	expect(result.stdout).toContain('drizzle-kit:');
+	expect(result.stdout).toContain('drizzle-orm:');
+	expect(result.stdout).not.toContain('skills:');
+	expect(() => JSON.parse(result.stdout.trim())).toThrow();
+});
+
+test('skills version prints the bundled revision on a single line', () => {
+	const result = runCli(['skills', 'version'], { DRIZZLE_KIT_SKILLS_REVISION: '42' });
+
+	expect(result.status).toBe(0);
+	expect(stripAnsi(result.stdout).trim()).toBe('42');
+});
+
+test('json error output includes structured cli error fields', () => {
+	const result = runCli(['generate', '--output', 'json', '--config=foo.ts', '--dialect=postgresql']);
+
+	expect(result.status).not.toBeNull();
+	expect(result.stderr).toContain("You can't use both --config and other cli options for generate command");
+	expect(result.stdout.trim().startsWith('{')).toBe(true);
+	expect(result.stdout.trim().endsWith('}')).toBe(true);
+	const parsed = JSON.parse(result.stdout.trim());
+	expect(parsed).toStrictEqual({
+		status: 'error',
+		error: {
+			code: 'ambiguous_params_error',
+			command: 'generate',
+			configOption: 'config',
+		},
+	});
+});
+
+test('generate with config emits clean json stdout in json mode', () => {
+	const result = runCli(
+		['generate', '--output', 'json', '--config=drizzle.config.ts', '--explain'],
+		{ TEST_CONFIG_PATH_PREFIX: './tests/cli/' },
+	);
+
+	expect(result.status).toBe(0);
+	expect(result.stdout).not.toContain('Reading config file');
+	expect(result.stdout).not.toContain('No config path provided');
+	expect(result.stderr).not.toContain('Reading config file');
+	expect(result.stderr).not.toContain('No config path provided');
+	expect(JSON.parse(result.stdout.trim())).toStrictEqual({
+		status: 'no_changes',
+		dialect: 'postgresql',
+	});
+});
+
+test('generate missing schema path emits structured json error', () => {
+	const result = runCli([
+		'generate',
+		'--output',
+		'json',
+		'--dialect=postgresql',
+		'--schema=tests/definitely-missing-schema.ts',
+	]);
+
+	expect(result.status).toBe(1);
+	expect(result.stdout.trim().startsWith('{')).toBe(true);
+	expect(result.stdout.trim().endsWith('}')).toBe(true);
+	const parsed = JSON.parse(result.stdout.trim());
+	expect(parsed).toMatchObject({
+		status: 'error',
+		error: {
+			code: 'schema_files_not_found_error',
+			paths: ['tests/definitely-missing-schema.ts'],
+		},
+	});
+});
+
+test('push missing schema path emits structured json error', () => {
+	const result = runCli([
+		'push',
+		'--output',
+		'json',
+		'--dialect=postgresql',
+		'--schema=tests/definitely-missing-schema.ts',
+		'--url=postgres://postgres:postgres@127.0.0.1:5432/postgres',
+	]);
+
+	expect(result.status).toBe(1);
+	expect(result.stdout.trim().startsWith('{')).toBe(true);
+	expect(result.stdout.trim().endsWith('}')).toBe(true);
+	const parsed = JSON.parse(result.stdout.trim());
+	expect(parsed).toMatchObject({
+		status: 'error',
+		error: {
+			code: 'schema_files_not_found_error',
+			paths: ['tests/definitely-missing-schema.ts'],
+		},
+	});
+});
+
+test('push throws a structured command_output_error for a duplicate-name schema in json mode', async () => {
+	const client = new PGlite();
+
+	// Two exported tables map to the same physical name, so the real ddl mapper raises a
+	// `table_name_duplicate` SchemaError that the push handler wraps as command_output_error.
+	const schema = pgFromExports({
+		a: pgTable('dup', { id: pgInteger() }),
+		b: pgTable('dup', { name: pgText() }),
+	});
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+
+	await expect(runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			new HintsHandler(),
+		))).rejects.toMatchObject({
+			code: 'command_output_error',
+			meta: {
+				command: 'push',
+				stage: 'ddl',
+				dialect: 'postgresql',
+			},
+		});
+
+	await client.close();
+});
+
+test('push postgres explain emits structured json payload in json mode', async () => {
+	const client = new PGlite();
+	await client.query('CREATE TABLE users (name text);');
+
+	const schema = pgFromExports({ users: pgTable('users', { name: pgText().notNull() }) });
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			true,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			new HintsHandler(),
+		));
+
+	if (env.status !== 'ok' || !('statements' in env)) {
+		throw new Error(`expected explain 'ok' envelope with statements, got '${env.status}'`);
+	}
+	expect(env).toMatchObject({
+		status: 'ok',
+		dialect: 'postgresql',
+		hints: [],
+	});
+	expect(env.statements).toHaveLength(1);
+	expect(env.statements[0]).toMatchObject({
+		type: 'alter_column',
+		to: { schema: 'public', table: 'users', name: 'name' },
+		diff: {
+			notNull: { from: false, to: true },
+		},
+	});
+
+	await client.close();
+});
+
+test('generate postgres explain emits structured json payload in json mode', async () => {
+	const schema = pgFromExports({ users: pgTable('users', { name: pgText().notNull() }) });
+
+	const generatePostgres = await import('../../src/cli/commands/generate-postgres');
+
+	const tempDir = mkdtempSync(join(tmpdir(), 'drizzle-kit-generate-json-'));
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		generatePostgres.handle({
+			out: tempDir,
+			filenames: ['schema.ts'],
+			schemaSource: PgSchemaSource.fromSchema(schema),
+			casing: undefined,
+			custom: false,
+			name: undefined,
+			breakpoints: false,
+			explain: true,
+			hints: new HintsHandler(),
+		} as never));
+
+	if (env.status !== 'ok' || !('statements' in env)) {
+		throw new Error(`expected explain 'ok' envelope with statements, got '${env.status}'`);
+	}
+	expect(env).toMatchObject({
+		status: 'ok',
+		dialect: 'postgresql',
+		hints: [],
+	});
+	expect(env.statements).toHaveLength(1);
+	expect(env.statements[0]).toMatchObject({
+		type: 'create_table',
+		table: { name: 'users' },
+	});
+});
+
+test('generate postgres explain emits no_changes for empty diff in json mode', async () => {
+	const schema = pgFromExports({});
+
+	const generatePostgres = await import('../../src/cli/commands/generate-postgres');
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		generatePostgres.handle({
+			out: mkdtempSync(join(tmpdir(), 'drizzle-kit-generate-noop-json-')),
+			filenames: ['schema.ts'],
+			schemaSource: PgSchemaSource.fromSchema(schema),
+			casing: undefined,
+			custom: false,
+			name: undefined,
+			breakpoints: false,
+			explain: true,
+			hints: new HintsHandler(),
+		} as never));
+
+	expect(env).toStrictEqual({
+		status: 'no_changes',
+		dialect: 'postgresql',
+	});
+});
+
+test('explainJsonOutput sanitizes hints: strips ANSI, excludes statement', async () => {
+	const chalk = await import('chalk');
+	const { explainJsonOutput } = await import('../../src/cli/views');
+
+	const hints = [
+		{
+			hint: `You're about to delete non-empty ${chalk.default.underline('users')} table`,
+			statement: 'DROP TABLE "users" CASCADE;',
+		},
+		{
+			hint: `You're about to add not-null ${
+				chalk.default.underline('email')
+			} column without default value to a non-empty ${chalk.default.underline('users')} table`,
+		},
+	];
+
+	const output = explainJsonOutput('postgres', [], hints);
+
+	expect(output.status).toBe('ok');
+	expect(output.dialect).toBe('postgres');
+	if (output.status !== 'ok') {
+		throw new Error('Expected ok explain output');
+	}
+	expect(output.hints).toHaveLength(2);
+
+	// Verify ANSI codes are stripped from JSON output
+	expect(output.hints[0]).toStrictEqual({
+		hint: "You're about to delete non-empty users table",
+	});
+	expect(output.hints[1]).toStrictEqual({
+		hint: "You're about to add not-null email column without default value to a non-empty users table",
+	});
+
+	// Verify statement field is excluded from all hints
+	for (const h of output.hints) {
+		expect(h).not.toHaveProperty('statement');
+	}
+});
+
+test('generate writeResult emits json for no-op when json mode is active', async () => {
+	const { writeResult } = await import('../../src/cli/commands/generate-common');
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		writeResult({
+			snapshot: {} as never,
+			sqlStatements: [],
+			outFolder: '',
+			breakpoints: false,
+			dialect: 'postgresql',
+			renames: [],
+			snapshots: [],
+		}));
+
+	expect(env).toStrictEqual({
+		status: 'no_changes',
+		dialect: 'postgresql',
+	});
+});
+
+test('generate writeResult emits json payload when a migration is written in json mode', async () => {
+	const { writeResult } = await import('../../src/cli/commands/generate-common');
+	const outFolder = mkdtempSync(join(tmpdir(), 'drizzle-kit-write-result-json-'));
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		writeResult({
+			snapshot: {} as never,
+			sqlStatements: ['CREATE TABLE "users" ("id" serial PRIMARY KEY);'],
+			outFolder,
+			breakpoints: false,
+			name: 'test',
+			dialect: 'postgresql',
+			renames: [],
+			snapshots: [],
+		}));
+
+	expect(env).toMatchObject({
+		status: 'ok',
+		migration_path: expect.stringContaining('migration.sql'),
+	});
+	expect(env).toMatchObject({ dialect: expect.anything() });
+	expect(env).not.toHaveProperty('message');
+	expect(env).not.toHaveProperty('path');
+});
+
+test('generate sqlite custom emits json payload in json mode', async () => {
+	const generateSqlite = await import('../../src/cli/commands/generate-sqlite');
+	const tempDir = mkdtempSync(join(tmpdir(), 'drizzle-kit-custom-json-'));
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		generateSqlite.handle({
+			out: tempDir,
+			filenames: ['schema.ts'],
+			schemaSource: SqliteSchemaSource.fromSchema(
+				sqliteFromExports({ users: sqliteTable('users', { id: integer().primaryKey() }) }),
+			),
+			casing: undefined,
+			custom: true,
+			name: 'test',
+			breakpoints: false,
+		} as never));
+
+	expect(env).toStrictEqual({
+		status: 'ok',
+		dialect: 'sqlite',
+		migration_path: expect.stringContaining('migration.sql'),
+	});
+});
+
+test('push postgres schema warnings do not leak to stdout in json mode', async () => {
+	const client = new PGlite();
+
+	// A standalone policy that is never linked to a table makes the real schema reader
+	// emit a `policy_not_linked` warning; the empty diff still resolves to no_changes.
+	const schema = pgFromExports({ orphan_policy: pgPolicy('orphan_policy') });
+
+	const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			new HintsHandler(),
+		));
+
+	expect(env).toStrictEqual({
+		status: 'no_changes',
+		dialect: 'postgresql',
+	});
+	const printed = logSpy.mock.calls.map((call) => String(call[0])).join('\n');
+	expect(printed).not.toContain('policy');
+
+	await client.close();
+});
+
+test('push postgres emits missing_hints for unresolved schema rename in json mode', async () => {
+	const client = new PGlite();
+	await client.query('CREATE SCHEMA prev_schema;');
+
+	const schema = pgFromExports({ next_schema: pgSchema('next_schema') });
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+	const hints = new HintsHandler();
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			true,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			hints,
+		));
+
+	expect(env).toStrictEqual({
+		status: 'missing_hints',
+		unresolved: [
+			{ type: 'rename_or_create', kind: 'schema', entity: ['next_schema'] },
+		],
+	});
+
+	await client.close();
+});
+
+test('push postgres orders rename hint resolves create_or_rename and applies changes in json mode', async () => {
+	const client = new PGlite();
+	await client.query('CREATE TABLE orders (id integer);');
+
+	const schema = pgFromExports({ orders1: pgTable('orders1', { id: pgInteger() }) });
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+	const hints = new HintsHandler([
+		{ type: 'rename', kind: 'table', from: ['public', 'orders'], to: ['public', 'orders1'] },
+	]);
+
+	const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(schema),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			hints,
+		));
+
+	expect(env).toMatchObject({ status: 'ok', dialect: 'postgresql' });
+
+	const tables = await client.query<{ tablename: string }>(
+		`SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename IN ('orders', 'orders1')`,
+	);
+	expect(tables.rows.map((r) => r.tablename)).toStrictEqual(['orders1']);
+
+	await client.close();
+});
+
+describe('push postgres confirm_data_loss[view] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const client = new PGlite();
+		await client.query('CREATE TABLE base (id integer);');
+		await client.query('INSERT INTO base (id) VALUES (1);');
+		await client.query('CREATE MATERIALIZED VIEW user_stats AS SELECT id FROM base;');
+
+		const schema = pgFromExports({ base: pgTable('base', { id: pgInteger() }) });
+
+		const env = await runPushPostgres(schema, new HintsHandler(), client);
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{ type: 'confirm_data_loss', kind: 'view', entity: ['public', 'user_stats'], reason: 'non_empty' },
+			],
+		});
+
+		await client.close();
+	});
+
+	test('applies matching hint and runs to ok', async () => {
+		const client = new PGlite();
+		await client.query('CREATE TABLE base (id integer);');
+		await client.query('INSERT INTO base (id) VALUES (1);');
+		await client.query('CREATE MATERIALIZED VIEW user_stats AS SELECT id FROM base;');
+
+		const schema = pgFromExports({ base: pgTable('base', { id: pgInteger() }) });
+
+		const env = await runPushPostgres(
+			schema,
+			new HintsHandler([{ type: 'confirm_data_loss', kind: 'view', entity: ['public', 'user_stats'] }]),
+			client,
+		);
+
+		expect(env).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+
+		const views = await client.query(`SELECT matviewname FROM pg_matviews WHERE matviewname = 'user_stats'`);
+		expect(views.rows).toStrictEqual([]);
+
+		await client.close();
+	});
+});
+
+describe('push postgres confirm_data_loss[schema] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const client = new PGlite();
+		await client.query('CREATE SCHEMA analytics;');
+		await client.query('CREATE TABLE analytics.events (id integer);');
+
+		const schema = pgFromExports({});
+
+		const env = await runPushPostgres(schema, new HintsHandler(), client);
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{ type: 'confirm_data_loss', kind: 'schema', entity: ['analytics'], reason: 'non_empty' },
+			],
+		});
+
+		await client.close();
+	});
+
+	test('applies matching hint and runs to ok', async () => {
+		const client = new PGlite();
+		await client.query('CREATE SCHEMA analytics;');
+		await client.query('CREATE TABLE analytics.events (id integer);');
+
+		const schema = pgFromExports({});
+
+		const env = await runPushPostgres(
+			schema,
+			new HintsHandler([{ type: 'confirm_data_loss', kind: 'schema', entity: ['analytics'] }]),
+			client,
+		);
+
+		expect(env).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+
+		const schemas = await client.query(`SELECT nspname FROM pg_namespace WHERE nspname = 'analytics'`);
+		expect(schemas.rows).toStrictEqual([]);
+
+		await client.close();
+	});
+});
+
+describe('push postgres confirm_data_loss[primary_key] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const client = new PGlite();
+		await client.query('CREATE TABLE users (id integer NOT NULL, CONSTRAINT users_pkey PRIMARY KEY (id));');
+		await client.query('INSERT INTO users (id) VALUES (1);');
+
+		const schema = pgFromExports({ users: pgTable('users', { id: pgInteger().notNull() }) });
+
+		const env = await runPushPostgres(schema, new HintsHandler(), client);
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{
+					type: 'confirm_data_loss',
+					kind: 'primary_key',
+					entity: ['public', 'users', 'users_pkey'],
+					reason: 'non_empty',
+				},
+			],
+		});
+
+		await client.close();
+	});
+
+	test('applies matching hint and runs to ok', async () => {
+		const client = new PGlite();
+		await client.query('CREATE TABLE users (id integer NOT NULL, CONSTRAINT users_pkey PRIMARY KEY (id));');
+		await client.query('INSERT INTO users (id) VALUES (1);');
+
+		const schema = pgFromExports({ users: pgTable('users', { id: pgInteger().notNull() }) });
+
+		const env = await runPushPostgres(
+			schema,
+			new HintsHandler([{ type: 'confirm_data_loss', kind: 'primary_key', entity: ['public', 'users', 'users_pkey'] }]),
+			client,
+		);
+
+		expect(env).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+
+		const pks = await client.query(
+			`SELECT conname FROM pg_constraint WHERE contype = 'p' AND conrelid = 'users'::regclass`,
+		);
+		expect(pks.rows).toStrictEqual([]);
+
+		await client.close();
+	});
+});
+
+describe('push postgres add_unique in json mode', () => {
+	test('proceeds without a confirm and applies the constraint', async () => {
+		const client = new PGlite();
+		await client.query('CREATE TABLE users (id integer, email text);');
+		await client.query("INSERT INTO users (id, email) VALUES (1, 'a@b.com');");
+
+		const schema = pgFromExports({
+			users: pgTable('users', { id: pgInteger(), email: pgText().unique() }),
+		});
+
+		const env = await runPushPostgres(schema, new HintsHandler(), client);
+
+		expect(env).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+
+		const uniques = await client.query<{ conname: string }>(
+			`SELECT conname FROM pg_constraint WHERE contype = 'u' AND conrelid = 'users'::regclass`,
+		);
+		expect(uniques.rows.map((r) => r.conname)).toStrictEqual(['users_email_key']);
+
+		await client.close();
+	});
+});
+
+describe('push sqlite confirm_data_loss[table] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY);');
+		sqlite.prepare('INSERT INTO users (id) VALUES (1)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const sqliteSchema = sqliteFromExports({});
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler();
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'users'], reason: 'non_empty' },
+			],
+		});
+
+		sqlite.close();
+	});
+
+	test('applies matching hint and runs to ok', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY);');
+		sqlite.prepare('INSERT INTO users (id) VALUES (1)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const sqliteSchema = sqliteFromExports({});
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'users'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const tables = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='users'").all();
+		expect(tables).toStrictEqual([]);
+
+		sqlite.close();
+	});
+});
+
+describe('push sqlite confirm_data_loss[column-drop] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy_id INTEGER);');
+		sqlite.prepare('INSERT INTO users (id, legacy_id) VALUES (1, 100)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable('users', { id: integer().primaryKey() });
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler();
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy_id'], reason: 'non_empty' },
+			],
+		});
+
+		sqlite.close();
+	});
+
+	test('applies matching hint and runs to ok', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy_id INTEGER);');
+		sqlite.prepare('INSERT INTO users (id, legacy_id) VALUES (1, 100)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable('users', { id: integer().primaryKey() });
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy_id'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const cols = sqlite.prepare('PRAGMA table_info(users)').all() as { name: string }[];
+		expect(cols.map((c) => c.name)).toStrictEqual(['id']);
+
+		sqlite.close();
+	});
+});
+
+describe('push sqlite confirm_data_loss[add_not_null] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY);');
+		sqlite.prepare('INSERT INTO users (id) VALUES (1)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable('users', {
+			id: integer().primaryKey(),
+			email: text().notNull(),
+		});
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler();
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{
+					type: 'confirm_data_loss',
+					kind: 'add_not_null',
+					entity: ['public', 'users', 'email'],
+					reason: 'table_recreate',
+				},
+			],
+		});
+
+		sqlite.close();
+	});
+
+	test('applies matching hint and runs to ok with truncate on non-empty table', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY);');
+		sqlite.prepare('INSERT INTO users (id) VALUES (1)').run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable('users', {
+			id: integer().primaryKey(),
+			email: text().notNull(),
+		});
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'add_not_null', entity: ['public', 'users', 'email'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const rows = sqlite.prepare('SELECT * FROM users').all();
+		expect(rows).toStrictEqual([]);
+
+		const cols = sqlite.prepare('PRAGMA table_info(users)').all() as {
+			name: string;
+			notnull: number;
+		}[];
+		const emailCol = cols.find((c) => c.name === 'email');
+		expect(emailCol).toBeDefined();
+		expect(emailCol!.notnull).toBe(1);
+
+		sqlite.close();
+	});
+
+	test('applies matching hint without truncate on empty table', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY);');
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable('users', {
+			id: integer().primaryKey(),
+			email: text().notNull(),
+		});
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'add_not_null', entity: ['public', 'users', 'email'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const cols = sqlite.prepare('PRAGMA table_info(users)').all() as {
+			name: string;
+			notnull: number;
+		}[];
+		const emailCol = cols.find((c) => c.name === 'email');
+		expect(emailCol).toBeDefined();
+		expect(emailCol!.notnull).toBe(1);
+
+		sqlite.close();
+	});
+});
+
+describe('push sqlite confirm_data_loss[recreate_table-single] in json mode', () => {
+	test('emits missing_hints when unresolved', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy TEXT, email TEXT);');
+		sqlite.prepare("INSERT INTO users (id, legacy, email) VALUES (1, 'old', 'a@b.com')").run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable(
+			'users',
+			{
+				id: integer().primaryKey(),
+				email: text(),
+			},
+			(t) => [check('ck_email_nonempty', sql`length(${t.email}) > 0`)],
+		);
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler();
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'missing_hints',
+			unresolved: [
+				{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy'], reason: 'non_empty' },
+			],
+		});
+
+		sqlite.close();
+	});
+
+	test('applies matching hint and runs to ok with check constraint', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy TEXT, email TEXT);');
+		sqlite.prepare("INSERT INTO users (id, legacy, email) VALUES (1, 'old', 'a@b.com')").run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable(
+			'users',
+			{
+				id: integer().primaryKey(),
+				email: text(),
+			},
+			(t) => [check('ck_email_nonempty', sql`length(${t.email}) > 0`)],
+		);
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const cols = sqlite.prepare('PRAGMA table_info(users)').all() as { name: string }[];
+		expect(cols.map((c) => c.name).sort()).toStrictEqual(['email', 'id']);
+
+		const surviving = sqlite.prepare('SELECT id, email FROM users').all();
+		expect(surviving).toStrictEqual([{ id: 1, email: 'a@b.com' }]);
+
+		const tableSql = sqlite.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='users'").get() as
+			| { sql: string }
+			| undefined;
+		expect(tableSql?.sql).toContain('CHECK');
+		expect(tableSql?.sql).toContain('length');
+
+		sqlite.close();
+	});
+});
+
+describe('push sqlite confirm_data_loss[recreate_table-multi] in json mode', () => {
+	test('emits missing_hints with one entry per dropped column', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy_a TEXT, legacy_b TEXT, email TEXT);');
+		sqlite.prepare("INSERT INTO users (id, legacy_a, legacy_b, email) VALUES (1, 'a', 'b', 'a@b.com')").run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable(
+			'users',
+			{
+				id: integer().primaryKey(),
+				email: text(),
+			},
+			(t) => [check('ck_email_nonempty', sql`length(${t.email}) > 0`)],
+		);
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler();
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		if (env.status !== 'missing_hints') throw new Error(`expected status 'missing_hints', got '${env.status}'`);
+		expect(env.unresolved).toHaveLength(2);
+		const entities = [...env.unresolved]
+			.map((u) => (u.entity as readonly [string, string, string])[2])
+			.sort();
+		expect(entities).toStrictEqual(['legacy_a', 'legacy_b']);
+		for (const u of env.unresolved) {
+			expect(u).toMatchObject({
+				type: 'confirm_data_loss',
+				kind: 'column',
+				reason: 'non_empty',
+			});
+			expect(u.entity[0]).toBe('public');
+			expect(u.entity[1]).toBe('users');
+		}
+
+		sqlite.close();
+	});
+
+	test('applies matching hints and preserves non-dropped column data', async () => {
+		const sqlite = new BetterSqlite3(':memory:');
+		sqlite.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, legacy_a TEXT, legacy_b TEXT, email TEXT);');
+		sqlite.prepare("INSERT INTO users (id, legacy_a, legacy_b, email) VALUES (1, 'a', 'b', 'a@b.com')").run();
+		const db = sqliteDbFrom(sqlite);
+
+		const usersTable = sqliteTable(
+			'users',
+			{
+				id: integer().primaryKey(),
+				email: text(),
+			},
+			(t) => [check('ck_email_nonempty', sql`length(${t.email}) > 0`)],
+		);
+
+		const sqliteSchema = sqliteFromExports({ usersTable });
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy_a'] },
+			{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'users', 'legacy_b'] },
+		]);
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteSchema),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'sqlite',
+				hints,
+			));
+
+		expect(env).toStrictEqual({
+			status: 'ok',
+			dialect: 'sqlite',
+		});
+
+		const cols = sqlite.prepare('PRAGMA table_info(users)').all() as { name: string }[];
+		expect(cols.map((c) => c.name).sort()).toStrictEqual(['email', 'id']);
+
+		const surviving = sqlite.prepare('SELECT id, email FROM users').all();
+		expect(surviving).toStrictEqual([{ id: 1, email: 'a@b.com' }]);
+
+		sqlite.close();
+	});
+});
+
+describe('check --output', () => {
+	const ORIGIN = _ORIGIN;
+	const stageOut = _stageOut;
+	const writeSnapshot = _writeSnapshot;
+	const stageValid = _stageValid;
+	const stageConflict = _stageConflict;
+	const stageTableConflict = _stageTableConflict;
+
+	const runCheck = (out: string, extra: string[] = []) =>
+		runCli(['check', `--out=${out}`, '--dialect=postgresql', ...extra]);
+
+	const expectNoHumanStrings = (stdout: string) => {
+		expect(stdout).not.toContain('🐶🔥');
+		expect(stdout).not.toContain('Non-commutative');
+		expect(stdout).not.toContain('\x1b[');
+	};
+
+	test('valid journal emits an ok envelope with clean json stdout in json mode', () => {
+		const result = runCheck(stageValid(), ['--output', 'json']);
+
+		expect(result.status).toBe(0);
+		expect(JSON.parse(result.stdout.trim())).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('unsupported snapshot version emits a check_error envelope in json mode', () => {
+		const out = stageOut();
+		writeSnapshot(out, '0000_init', { version: '999', dialect: 'postgres', id: 'p1', prevIds: [ORIGIN], ddl: [] });
+		const result = runCheck(out, ['--output', 'json']);
+
+		expect(result.status).toBe(1);
+		const parsed = JSON.parse(result.stdout.trim());
+		expect(parsed.status).toBe('error');
+		expect(parsed.error.code).toBe('check_error');
+		expect(parsed.error.kind).toBe('unsupported');
+		expect(typeof parsed.error.snapshot).toBe('string');
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('non-latest snapshot version emits a check_error envelope in json mode', () => {
+		const out = stageOut();
+		writeSnapshot(out, '0000_init', { version: '1', dialect: 'postgres', id: 'p1', prevIds: [ORIGIN], ddl: [] });
+		const result = runCheck(out, ['--output', 'json']);
+
+		expect(result.status).toBe(1);
+		const parsed = JSON.parse(result.stdout.trim());
+		expect(parsed.status).toBe('error');
+		expect(parsed.error.code).toBe('check_error');
+		expect(parsed.error.kind).toBe('non_latest');
+		expect(typeof parsed.error.snapshot).toBe('string');
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('malformed snapshot emits a check_error envelope in json mode', () => {
+		const out = stageOut();
+		// Correct version but a structurally invalid body trips the `malformed` validator status.
+		writeSnapshot(out, '0000_init', {
+			version: '8',
+			dialect: 'postgres',
+			id: 'p1',
+			prevIds: [ORIGIN],
+			ddl: 'not-an-array',
+		});
+		const result = runCheck(out, ['--output', 'json']);
+
+		expect(result.status).toBe(1);
+		const parsed = JSON.parse(result.stdout.trim());
+		expect(parsed.status).toBe('error');
+		expect(parsed.error.code).toBe('check_error');
+		expect(parsed.error.kind).toBe('malformed');
+		expect(typeof parsed.error.snapshot).toBe('string');
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('valid-but-non-object snapshot emits a check_error envelope in json mode', () => {
+		// Valid JSON but not an object — `JSON.parse` succeeds (no SyntaxError), so the post-parse
+		// narrowing guard is what turns these into `malformed` rather than an uncaught
+		// `'version' in <primitive>` TypeError. `null` is covered because `typeof null === 'object'`.
+		for (const body of [42, 'x', true, null]) {
+			const out = stageOut();
+			writeSnapshot(out, '0000_init', body);
+			const result = runCheck(out, ['--output', 'json']);
+
+			expect(result.status).toBe(1);
+			const parsed = JSON.parse(result.stdout.trim());
+			expect(parsed.status).toBe('error');
+			expect(parsed.error.code).toBe('check_error');
+			expect(parsed.error.kind).toBe('malformed');
+			expect(typeof parsed.error.snapshot).toBe('string');
+			expectNoHumanStrings(result.stdout);
+		}
+	});
+
+	test('conflicting branches emit an enriched conflicts envelope in json mode', () => {
+		const result = runCheck(stageConflict(), ['--output', 'json']);
+
+		expect(result.status).toBe(1);
+		const parsed = JSON.parse(result.stdout.trim());
+		expect(parsed.status).toBe('error');
+		expect(parsed.error.code).toBe('check_error');
+		expect(parsed.error.kind).toBe('conflicts');
+		expect(parsed.error.conflicts).toBeGreaterThan(0);
+
+		// the per-conflict parent/branch-leaf/statement-description data must be
+		// machine-parseable from `error` (not just the count, and not via the human tree).
+		expect(Array.isArray(parsed.error.details)).toBe(true);
+		expect(parsed.error.details.length).toBe(parsed.error.conflicts);
+		for (const detail of parsed.error.details) {
+			expect(typeof detail.parentId).toBe('string');
+			const detailKeys = Object.keys(detail).sort();
+			expect(
+				detailKeys.join(',') === 'branches,parentId'
+					|| detailKeys.join(',') === 'branches,parentId,parentPath',
+			).toBe(true);
+			expect(Array.isArray(detail.branches)).toBe(true);
+			expect(detail.branches.length).toBe(2);
+			for (const branch of detail.branches) {
+				expect(Object.keys(branch).sort()).toEqual(
+					['action', 'leafId', 'leafPath', 'statementDescription', 'target'].sort(),
+				);
+				expect(branch.leafId === null || typeof branch.leafId === 'string').toBe(true);
+				expect(branch.leafPath === null || typeof branch.leafPath === 'string').toBe(true);
+				expect(typeof branch.statementDescription).toBe('string');
+				expect(typeof branch.action).toBe('string');
+				expect(typeof branch.target).toBe('object');
+				expect(typeof branch.target.kind).toBe('string');
+				expect(typeof branch.target.name).toBe('string');
+				expect(branch.target.kind).toBe('column');
+				expect(branch.target.name).toBe('email');
+				expect(branch.target.table).toBe('users');
+			}
+		}
+
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('a table-level conflict carries a table-kind target with its schema in json mode', () => {
+		const result = runCheck(stageTableConflict(), ['--output', 'json']);
+
+		expect(result.status).toBe(1);
+		const parsed = JSON.parse(result.stdout.trim());
+		expect(parsed.error.kind).toBe('conflicts');
+		expect(parsed.error.details.length).toBeGreaterThan(0);
+		for (const detail of parsed.error.details) {
+			for (const branch of detail.branches) {
+				// The structured kind for a create_table/create_table conflict is the table
+				// itself — not 'column' and not the schema — and it carries the schema so the
+				// consumer renders "<verb> `orders` in schema `public`" without parsing strings.
+				expect(branch.target.kind).toBe('table');
+				expect(branch.target.name).toBe('orders');
+				expect(branch.target.schema).toBe('public');
+			}
+		}
+
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('ignore-conflicts emits an ok envelope despite conflicts in json mode', () => {
+		const result = runCheck(stageConflict(), ['--ignore-conflicts', '--output', 'json']);
+
+		expect(result.status).toBe(0);
+		expect(JSON.parse(result.stdout.trim())).toStrictEqual({ status: 'ok', dialect: 'postgresql' });
+		expectNoHumanStrings(result.stdout);
+	});
+
+	test('text mode prints the human success line for a valid journal', () => {
+		const result = runCheck(stageValid(), ['--output', 'text']);
+
+		expect(result.status).toBe(0);
+		expect(result.stdout).toContain("Everything's fine 🐶🔥");
+		expect(() => JSON.parse(result.stdout.trim())).toThrow();
+	});
+
+	test('text mode defaults when --output is omitted', () => {
+		const result = runCheck(stageValid());
+
+		expect(result.status).toBe(0);
+		expect(result.stdout).toContain("Everything's fine 🐶🔥");
+		expect(() => JSON.parse(result.stdout.trim())).toThrow();
+	});
+
+	test('text mode renders the conflict tree and exits non-zero', () => {
+		const result = runCheck(stageConflict(), ['--output', 'text']);
+
+		expect(result.status).not.toBe(0);
+		const combined = stripAnsi(result.stdout + result.stderr);
+		expect(combined).toContain('Non-commutative migrations detected');
+	});
+
+	test('text mode renders the typed integrity error and emits no json on stdout', () => {
+		const out = stageOut();
+		writeSnapshot(out, '0000_init', { version: '999', dialect: 'postgres', id: 'p1', prevIds: [ORIGIN], ddl: [] });
+		const result = runCheck(out, ['--output', 'text']);
+
+		expect(result.status).not.toBe(0);
+		expect(() => JSON.parse(result.stdout.trim())).toThrow();
+	});
+
+	test('ignore-conflicts emits the human success line in text mode', () => {
+		const result = runCheck(stageConflict(), ['--ignore-conflicts', '--output', 'text']);
+
+		expect(result.status).toBe(0);
+		expect(result.stdout).toContain("Everything's fine 🐶🔥");
+	});
+});
+
+describe('turso connection-layer machine-readable surface', () => {
+	const TURSO_AUTH_TOKEN = 'super-secret-turso-auth-token-value';
+	const TURSO_REMOTE_URL = 'libsql://my-secret-host.turso.io';
+
+	// checkPackage decides which turso driver branch connectToTursoRemote / connectToSQLite enters.
+	// Mocking it lets us reach a chosen branch without a live turso database or the real drivers.
+	type TursoDriver = '@libsql/client' | '@tursodatabase/serverless' | '@tursodatabase/database';
+	const mockDriverAvailability = (available: Partial<Record<TursoDriver, boolean>>) => {
+		vi.doMock('../../src/cli/utils', async () => {
+			const actual = await vi.importActual<typeof import('../../src/cli/utils')>('../../src/cli/utils');
+			return {
+				...actual,
+				checkPackage: vi.fn(async (pkg: string) => available[pkg as TursoDriver] ?? false),
+			};
+		});
+	};
+
+	test('serverless driver-info line is suppressed under --output json', async () => {
+		mockDriverAvailability({ '@libsql/client': false, '@tursodatabase/serverless': true });
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		const { connectToTursoRemote } = await import('../../src/cli/connections');
+
+		await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => connectToTursoRemote({ url: TURSO_REMOTE_URL, authToken: TURSO_AUTH_TOKEN } as never).catch(() => {}),
+		);
+
+		const printed = logSpy.mock.calls.map((call) => String(call[0])).join('\n');
+		expect(printed).not.toContain("Using '@tursodatabase/serverless' driver");
+	});
+
+	test('serverless driver-info line is present under --output text', async () => {
+		mockDriverAvailability({ '@libsql/client': false, '@tursodatabase/serverless': true });
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		const { connectToTursoRemote } = await import('../../src/cli/connections');
+
+		await runWithCliContext(
+			{ output: 'text', interactive: false },
+			() => connectToTursoRemote({ url: TURSO_REMOTE_URL, authToken: TURSO_AUTH_TOKEN } as never).catch(() => {}),
+		);
+
+		const printed = logSpy.mock.calls.map((call) => String(call[0])).join('\n');
+		expect(printed).toContain("Using '@tursodatabase/serverless' driver");
+	});
+
+	test('remote turso with only the local driver emits a database_driver_error envelope', async () => {
+		// Only @tursodatabase/database is available, but the credential carries an authToken (remote target):
+		// this reaches the mismatch block, which must route through the typed envelope rather than process.exit.
+		mockDriverAvailability({
+			'@libsql/client': false,
+			'@tursodatabase/serverless': false,
+			'@tursodatabase/database': true,
+		});
+		vi.spyOn(console, 'log').mockImplementation(() => {});
+		const exitSpy = vi.spyOn(process, 'exit').mockImplementation(
+			(() => {
+				throw new Error('process.exit called instead of throwing a typed error');
+			}) as never,
+		);
+
+		const { connectToTursoRemote } = await import('../../src/cli/connections');
+
+		const caught = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() =>
+				connectToTursoRemote({ url: TURSO_REMOTE_URL, authToken: TURSO_AUTH_TOKEN } as never).catch(
+					(err) => err,
+				),
+		);
+
+		expect(exitSpy).not.toHaveBeenCalled();
+		expect(caught).toMatchObject({ code: 'database_driver_error' });
+		expect((caught as { meta?: { database?: string } }).meta?.database).toBe('turso');
+	});
+
+	test('database_driver_error envelope carries no credential substring', async () => {
+		mockDriverAvailability({
+			'@libsql/client': false,
+			'@tursodatabase/serverless': false,
+			'@tursodatabase/database': true,
+		});
+		vi.spyOn(console, 'log').mockImplementation(() => {});
+		vi.spyOn(process, 'exit').mockImplementation(
+			(() => {
+				throw new Error('process.exit called instead of throwing a typed error');
+			}) as never,
+		);
+
+		const { connectToTursoRemote } = await import('../../src/cli/connections');
+		const { errorToEnvelope } = await import('../../src/cli/errors');
+
+		const caught = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() =>
+				connectToTursoRemote({ url: TURSO_REMOTE_URL, authToken: TURSO_AUTH_TOKEN } as never).catch(
+					(err) => err,
+				),
+		);
+
+		const serialized = JSON.stringify(errorToEnvelope(caught));
+		expect(serialized).toContain('database_driver_error');
+		expect(serialized).not.toContain(TURSO_AUTH_TOKEN);
+		expect(serialized).not.toContain('my-secret-host.turso.io');
+	});
+
+	test("turso push outcome envelope carries dialect 'turso'", async () => {
+		const client = createLibsqlClient({ url: ':memory:' });
+		const db = libsqlDbFrom(client);
+
+		const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+
+		const env = await runWithCliContext({ output: 'json', interactive: false }, () =>
+			pushSqlite.handle(
+				db as never,
+				SqliteSchemaSource.fromSchema(sqliteFromExports({})),
+				false,
+				{} as never,
+				{} as never,
+				false,
+				false,
+				{ table: '__drizzle_migrations', schema: '' },
+				'turso',
+				new HintsHandler(),
+			));
+
+		expect(env).toStrictEqual({ status: 'no_changes', dialect: 'turso' });
+
+		client.close();
+	});
+});
+
+describe('pull json envelopes', () => {
+	const importRunPull = async () => {
+		const schema = await import('../../src/cli/schema');
+		return (schema as { runPull?: (config: unknown) => Promise<unknown> }).runPull;
+	};
+
+	const stageSnapshot = (out: string, tag: string) => {
+		const meta = join(out, tag);
+		mkdirSync(meta, { recursive: true });
+		const snapshotPath = join(meta, 'snapshot.json');
+		writeFileSync(snapshotPath, JSON.stringify({ version: '8', dialect: 'postgres', id: tag, prevIds: [], ddl: [] }));
+		return snapshotPath;
+	};
+
+	const baseConfig = (out: string) => ({
+		dialect: 'postgresql' as const,
+		credentials: { url: 'postgresql://postgres:postgres@127.0.0.1:5432/db' },
+		out,
+		casing: 'camel' as const,
+		breakpoints: true,
+		filters: { entities: undefined, extensions: undefined, schemas: undefined, tables: undefined },
+		init: false,
+		migrations: { table: '__drizzle_migrations', schema: 'public' },
+		output: 'json' as const,
+	});
+
+	test('ok manifest (fresh) surfaces every path with migrationPath present', async () => {
+		const client = new PGlite();
+
+		const out = mkdtempSync(join(tmpdir(), 'drizzle-kit-pull-ok-fresh-'));
+		const runPull = await importRunPull();
+
+		const env = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => runPull!({ ...baseConfig(out), credentials: { driver: 'pglite', client } }),
+		);
+
+		expect(env).toMatchObject({
+			status: 'ok',
+			dialect: 'postgresql',
+			schemaPath: join(out, 'schema.ts'),
+			relationsPath: join(out, 'relations.ts'),
+		});
+		expect((env as { snapshotPath: string }).snapshotPath).toContain('snapshot.json');
+		expect((env as { migrationPath: string }).migrationPath).toContain('migration.sql');
+		expect(env).not.toHaveProperty('missing_hints');
+		expect((env as { status: string }).status).toBe('ok');
+
+		await client.close();
+	});
+
+	test('ok manifest (pre-existing snapshot) omits migrationPath', async () => {
+		const client = new PGlite();
+
+		const out = mkdtempSync(join(tmpdir(), 'drizzle-kit-pull-ok-existing-'));
+		const latestSnapshot = stageSnapshot(out, '0000_x');
+		const runPull = await importRunPull();
+
+		const env = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => runPull!({ ...baseConfig(out), credentials: { driver: 'pglite', client } }),
+		);
+
+		expect(env).toMatchObject({
+			status: 'ok',
+			dialect: 'postgresql',
+			snapshotPath: latestSnapshot,
+		});
+		expect(env).not.toHaveProperty('migrationPath');
+
+		await client.close();
+	});
+
+	test('a real connection failure never leaks the configured credentials into the error envelope', async () => {
+		// The CLI holds the password and host in its config; an unreachable database makes the real
+		// driver fail to connect, and the database_driver_error envelope must echo back neither.
+		const password = 'S3NT1NEL_pw_a9F2';
+		const out = mkdtempSync(join(tmpdir(), 'drizzle-kit-pull-driver-error-'));
+		const runPull = await importRunPull();
+		const { errorToEnvelope } = await import('../../src/cli/errors');
+
+		const caught = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() =>
+				runPull!({ ...baseConfig(out), credentials: { url: `postgresql://app:${password}@127.0.0.1:1/none` } })
+					.then(() => null, (err) => err),
+		);
+
+		expect(caught).toMatchObject({ code: 'database_driver_error' });
+
+		const serialized = JSON.stringify(errorToEnvelope(caught));
+		expect(serialized).toContain('database_driver_error');
+		expect(serialized).not.toContain(password);
+		expect(serialized).not.toContain('127.0.0.1');
+		expect(serialized).not.toContain('query_error');
+	});
+
+	test('json mode emits only the envelope and never constructs IntrospectProgress', async () => {
+		const client = new PGlite();
+
+		const introspectProgress = vi.fn();
+		vi.doMock('../../src/cli/views', async () => {
+			const actual = await vi.importActual<typeof import('../../src/cli/views')>('../../src/cli/views');
+			class SpyIntrospectProgress extends actual.IntrospectProgress {
+				constructor(...args: ConstructorParameters<typeof actual.IntrospectProgress>) {
+					super(...args);
+					introspectProgress(...args);
+				}
+			}
+			return { ...actual, IntrospectProgress: SpyIntrospectProgress };
+		});
+
+		const hanji = await import('hanji');
+		const renderSpy = vi.spyOn(hanji, 'render').mockImplementation((() => {}) as never);
+		const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+		const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation((() => true) as never);
+
+		const out = mkdtempSync(join(tmpdir(), 'drizzle-kit-pull-chatter-'));
+		const runPull = await importRunPull();
+
+		const env = await runWithCliContext(
+			{ output: 'json', interactive: false },
+			() => runPull!({ ...baseConfig(out), credentials: { driver: 'pglite', client } }),
+		);
+
+		expect((env as { status: string }).status).toBe('ok');
+		expect(introspectProgress).not.toHaveBeenCalled();
+		expect(renderSpy).not.toHaveBeenCalled();
+		const stdoutBytes = stdoutSpy.mock.calls.map((call) => String(call[0])).join('');
+		expect(stdoutBytes).not.toContain('[✓]');
+		expect(stdoutBytes).not.toContain('[i]');
+		expect(logSpy).not.toHaveBeenCalled();
+
+		await client.close();
+	});
+});
diff --git a/drizzle-kit/tests/other/cli-migrate.test.ts b/drizzle-kit/tests/other/cli-migrate.test.ts
new file mode 100644
index 0000000000..c0cc509790
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-migrate.test.ts
@@ -0,0 +1,241 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'fs';
+import { afterEach, assert, expect, test, vi } from 'vitest';
+import { migrate } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+
+afterEach(() => {
+	if (originalPrefix === undefined) {
+		process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+	} else {
+		process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+	}
+});
+
+// good:
+// #1 drizzle-kit generate
+// #2 drizzle-kit generate --config=turso.config.ts
+// #3 drizzle-kit generate --config=d1http.config.ts
+// #4 drizzle-kit generate --config=postgres.config.ts ## spread connection params
+// #5 drizzle-kit generate --config=drizzle2.config.ts ## custom schema and table for migrations journal
+
+// errors:
+// #1 drizzle-kit generate --config=expo.config.ts
+// TODO: missing required params in config?
+
+test('migrate #1', async (t) => {
+	const res = await brotest(migrate, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+		schema: 'drizzle', // drizzle migrations table schema
+		table: '__drizzle_migrations', // drizzle migrations table name
+	});
+});
+
+test('migrate #2', async (t) => {
+	const res = await brotest(migrate, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		out: 'drizzle',
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+		schema: 'drizzle', // drizzle migrations table schema
+		table: '__drizzle_migrations', // drizzle migrations table name
+	});
+});
+
+test('migrate #3', async (t) => {
+	const res = await brotest(migrate, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		out: 'drizzle',
+		credentials: {
+			driver: 'd1-http',
+			accountId: 'accid',
+			databaseId: 'dbid',
+			token: 'token',
+		},
+		schema: 'drizzle', // drizzle migrations table schema
+		table: '__drizzle_migrations', // drizzle migrations table name
+	});
+});
+
+test('migrate #4', async (t) => {
+	const res = await brotest(migrate, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		schema: 'drizzle', // drizzle migrations table schema
+		table: '__drizzle_migrations', // drizzle migrations table name
+	});
+});
+
+// catched a bug
+test('migrate #5', async (t) => {
+	const res = await brotest(migrate, '--config=postgres2.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		schema: 'custom', // drizzle migrations table schema
+		table: 'custom', // drizzle migrations table name
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(migrate, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+	}, prefix);
+
+	const res = await brotest(migrate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'postgresql',
+		out: 'drizzle',
+		credentials: {
+			url: 'test_url',
+		},
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'mssql',
+		schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		tablesFilter: 'test',
+		migrations: {
+			table: 'test_table',
+		},
+	}, prefix);
+
+	const res = await brotest(migrate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'mssql',
+		out: 'drizzle',
+		credentials: {
+			url: 'test_url',
+		},
+		schema: 'drizzle',
+		table: 'test_table',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'mysql',
+		// schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		tablesFilter: 'test',
+		migrations: {
+			table: 'test_table',
+		},
+	}, prefix);
+
+	const res = await brotest(migrate, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'mysql',
+		out: 'drizzle',
+		credentials: {
+			url: 'test_url',
+		},
+		schema: 'drizzle',
+		table: 'test_table',
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig(
+		// @ts-expect-error
+		{ driver: 'aws-data-api', out: 'test' },
+		prefix,
+	);
+
+	const res = await brotest(migrate, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[error('Please provide required params:'), wrapParam('dialect', undefined)].join('\n'),
+	);
+});
diff --git a/drizzle-kit/tests/other/cli-pull.test.ts b/drizzle-kit/tests/other/cli-pull.test.ts
new file mode 100644
index 0000000000..d15acf69e6
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-pull.test.ts
@@ -0,0 +1,394 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'node:fs';
+import { afterEach, assert, expect, test } from 'vitest';
+import { pull } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+afterEach(() => {
+	process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix ?? './tests/cli/';
+});
+
+test('pull #1', async () => {
+	const res = await brotest(pull, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		breakpoints: true,
+		casing: 'camel',
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	});
+});
+
+test('pull #2', async () => {
+	const res = await brotest(pull, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		out: 'drizzle',
+		breakpoints: true,
+		casing: 'camel',
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	});
+});
+
+test('pull #3', async () => {
+	const res = await brotest(pull, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		out: 'drizzle',
+		breakpoints: true,
+		casing: 'camel',
+		credentials: {
+			driver: 'd1-http',
+			accountId: 'accid',
+			databaseId: 'dbid',
+			token: 'token',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	});
+});
+
+test('pull #4', async () => {
+	const res = await brotest(pull, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		out: 'drizzle',
+		breakpoints: true,
+		casing: 'camel',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	});
+});
+
+// --- errors ---
+test('err #1', async () => {
+	const res = await brotest(pull, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async () => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		driver: 'pglite',
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		migrations: {
+			schema: 'new_schema',
+		},
+		tablesFilter: ['test'],
+		out: 'drizzle2',
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'postgresql',
+		out: 'drizzle2',
+		breakpoints: false,
+		casing: 'preserve',
+		credentials: {
+			driver: 'pglite',
+			url: 'test_url',
+		},
+		filters: {
+			entities: {
+				roles: true,
+			},
+			extensions: [
+				'postgis',
+			],
+			schemas: [
+				'public',
+			],
+			tables: [
+				'test',
+			],
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			schema: 'new_schema',
+			table: '__drizzle_migrations',
+		},
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async () => {
+	const { path, name } = createConfig({
+		dialect: 'mssql',
+		schema: 'schema.ts',
+		dbCredentials: { database: 'db', server: 'host', password: 'SA', port: 123, user: 'SA' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		// schemaFilter: ['public'],
+		// extensionsFilters: ["postgis"],
+		breakpoints: false,
+		// driver: 'pglite',
+		entities: {
+			roles: {
+				exclude: ['admin'],
+			},
+		},
+		migrations: {
+			schema: 'new_schema',
+		},
+		tablesFilter: ['test'],
+		out: 'drizzle2',
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name} --init=true`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'mssql',
+		out: 'drizzle2',
+		breakpoints: false,
+		casing: 'preserve',
+		credentials: {
+			database: 'db',
+			password: 'SA',
+			port: 123,
+			server: 'host',
+			user: 'SA',
+		},
+		filters: {
+			entities: {
+				roles: {
+					exclude: ['admin'],
+				},
+			},
+			extensions: undefined,
+			schemas: undefined,
+			tables: [
+				'test',
+			],
+		},
+		init: true,
+		output: 'text',
+		migrations: {
+			schema: 'new_schema',
+			table: '__drizzle_migrations',
+		},
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async () => {
+	const { path, name } = createConfig({
+		dialect: 'sqlite',
+		schema: 'schema.ts',
+		dbCredentials: { accountId: '1', databaseId: '2', token: '3' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		entities: {
+			roles: {
+				include: ['admin'],
+			},
+		},
+		extensionsFilters: ['postgis'],
+		tablesFilter: 'test',
+		migrations: {
+			table: 'test_table',
+		},
+		driver: 'd1-http',
+		out: 'out2',
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'sqlite',
+		out: 'out2',
+		breakpoints: false,
+		casing: 'preserve',
+		credentials: {
+			driver: 'd1-http',
+			accountId: '1',
+			databaseId: '2',
+			token: '3',
+		},
+		filters: {
+			entities: {
+				roles: {
+					include: ['admin'],
+				},
+			},
+			extensions: ['postgis'],
+			schemas: ['public'],
+			tables: 'test',
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			schema: 'drizzle',
+			table: 'test_table',
+		},
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #4', async () => {
+	const { path, name } = createConfig({
+		dialect: 'mysql',
+		dbCredentials: {
+			url: 'url',
+		},
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'mysql',
+		out: 'drizzle',
+		breakpoints: true,
+		casing: 'camel',
+		credentials: {
+			url: 'url',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		init: false,
+		output: 'text',
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #5', async () => {
+	// @ts-expect-error
+	const { path, name } = createConfig({
+		// dialect: 'mysql',
+		dbCredentials: {
+			url: 'url',
+		},
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[error('Please provide required params:'), wrapParam('dialect', undefined)].join('\n'),
+	);
+});
+
+test('validate config #6', async () => {
+	const { path, name } = createConfig({
+		dialect: 'mysql',
+		dbCredentials: {
+			url: '',
+		},
+	}, prefix);
+
+	const res = await brotest(pull, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toContain('MySQL driver');
+});
diff --git a/drizzle-kit/tests/other/cli-push.test.ts b/drizzle-kit/tests/other/cli-push.test.ts
new file mode 100644
index 0000000000..eea159cbe3
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-push.test.ts
@@ -0,0 +1,450 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { afterEach, assert, expect, test, vi } from 'vitest';
+import { HintsHandler } from '../../src/cli/hints';
+import { push } from '../../src/cli/schema';
+import { wrapParam } from '../../src/cli/validations/common';
+import { error } from '../../src/cli/views';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+
+afterEach(() => {
+	if (originalPrefix === undefined) {
+		process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+	} else {
+		process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+	}
+});
+
+// good:
+// #1 drizzle-kit push
+// #2 drizzle-kit push --config=turso.config.ts
+// #3 drizzle-kit push --config=d1http.config.ts
+// #4 drizzle-kit push --config=postgres.config.ts ## spread connection params
+// #5 drizzle-kit push --config=drizzle2.config.ts ## custom schema and table for migrations journal
+
+// errors:
+// #1 drizzle-kit push --config=expo.config.ts
+// TODO: missing required params in config?
+
+const filename = join(process.cwd(), 'tests/cli/schema.ts');
+test('push #1', async (t) => {
+	const res = await brotest(push, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+		force: false,
+		filenames: [filename],
+		explain: false,
+		filters: {
+			schemas: undefined,
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		verbose: false,
+
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('push #2', async (t) => {
+	const res = await brotest(push, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+		force: false,
+		filenames: [filename],
+		explain: false,
+		filters: {
+			schemas: undefined,
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		verbose: false,
+
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('push #3', async (t) => {
+	const res = await brotest(push, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		credentials: {
+			driver: 'd1-http',
+			accountId: 'accid',
+			databaseId: 'dbid',
+			token: 'token',
+		},
+		force: false,
+		filenames: [filename],
+		explain: false,
+		filters: {
+			schemas: undefined,
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		verbose: false,
+
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+		hints: expect.any(HintsHandler),
+	});
+});
+
+test('push #4', async (t) => {
+	const res = await brotest(push, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		force: false,
+		explain: false,
+		filters: {
+			schemas: undefined,
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		filenames: [filename],
+		verbose: false,
+
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// catched a bug
+test('push #5', async (t) => {
+	const res = await brotest(push, '--config=postgres2.config.ts');
+	if (res.type !== 'handler') {
+		assert.fail(res.type, 'handler');
+	}
+
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		credentials: {
+			database: 'db',
+			host: '127.0.0.1',
+			password: 'postgres',
+			port: 5432,
+			user: 'postgresql',
+		},
+		filenames: [filename],
+		explain: false,
+		filters: {
+			schemas: undefined,
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		force: false,
+		verbose: false,
+
+		migrations: {
+			schema: 'custom',
+			table: 'custom',
+		},
+		hints: expect.any(HintsHandler),
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(push, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});
+
+// should point to test/cli
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX || '';
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		driver: 'pglite',
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		migrations: {
+			schema: 'new_schema',
+		},
+		tablesFilter: ['test'],
+		out: 'drizzle2',
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'postgresql',
+		explain: false,
+		verbose: false,
+		force: false,
+		credentials: {
+			driver: 'pglite',
+			url: 'test_url',
+		},
+		filters: {
+			entities: {
+				roles: true,
+			},
+			extensions: [
+				'postgis',
+			],
+			schemas: [
+				'public',
+			],
+			tables: [
+				'test',
+			],
+		},
+		migrations: {
+			schema: 'new_schema',
+			table: '__drizzle_migrations',
+		},
+		filenames: [filename],
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { database: 'db', host: 'host' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		// schemaFilter: ['public'],
+		// extensionsFilters: ["postgis"],
+		breakpoints: false,
+		// driver: 'pglite',
+		entities: {
+			roles: {
+				exclude: ['admin'],
+			},
+		},
+		migrations: {
+			schema: 'new_schema',
+		},
+		tablesFilter: ['test'],
+		out: 'drizzle2',
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name} --explain=true`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'postgresql',
+		explain: true,
+		verbose: false,
+		force: false,
+		credentials: {
+			database: 'db',
+			host: 'host',
+		},
+		filters: {
+			entities: {
+				roles: {
+					exclude: ['admin'],
+				},
+			},
+			extensions: undefined,
+			schemas: undefined,
+			tables: [
+				'test',
+			],
+		},
+		migrations: {
+			schema: 'new_schema',
+			table: '__drizzle_migrations',
+		},
+		filenames: [filename],
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #3', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'sqlite',
+		schema: 'schema.ts',
+		dbCredentials: { accountId: '1', databaseId: '2', token: '3' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		tablesFilter: 'test',
+		migrations: {
+			table: 'test_table',
+		},
+		driver: 'd1-http',
+		out: 'out2',
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'sqlite',
+		explain: false,
+		verbose: false,
+		force: false,
+		credentials: {
+			driver: 'd1-http',
+			accountId: '1',
+			databaseId: '2',
+			token: '3',
+		},
+		filters: {
+			entities: {
+				roles: true,
+			},
+			extensions: ['postgis'],
+			schemas: ['public'],
+			tables: 'test',
+		},
+		migrations: {
+			schema: 'drizzle',
+			table: 'test_table',
+		},
+		filenames: [filename],
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #4', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'mysql',
+		schema: 'schema.ts',
+		dbCredentials: {
+			url: 'url',
+		},
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'mysql',
+		explain: false,
+		verbose: false,
+		force: false,
+		credentials: {
+			url: 'url',
+		},
+		filters: {
+			entities: undefined,
+			extensions: undefined,
+			schemas: undefined,
+			tables: undefined,
+		},
+		migrations: {
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+		filenames: [filename],
+		hints: expect.any(HintsHandler) as any,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #5', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'mysql',
+		// schema: 'schema.ts',
+		dbCredentials: {
+			url: 'url',
+		},
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toBe(
+		[
+			error('Please provide required params:'),
+			wrapParam('dialect', 'mysql'),
+			wrapParam('schema', undefined),
+		].join('\n'),
+	);
+});
+
+test('validate config #6', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		// dbCredentials: {
+		// 	url: 'url',
+		// },
+	}, prefix);
+
+	const res = await brotest(push, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+	if (res.type !== 'error') return;
+	expect((res.error as Error).message).toContain('PostgreSQL');
+});
diff --git a/drizzle-kit/tests/other/cli-studio.test.ts b/drizzle-kit/tests/other/cli-studio.test.ts
new file mode 100644
index 0000000000..19bddfbfd0
--- /dev/null
+++ b/drizzle-kit/tests/other/cli-studio.test.ts
@@ -0,0 +1,235 @@
+import { test as brotest } from '@drizzle-team/brocli';
+import { stripAnsi } from 'hanji/utils';
+import { unlinkSync } from 'node:fs';
+import { afterEach, assert, expect, test, vi } from 'vitest';
+import { studio } from '../../src/cli/schema';
+import { createConfig } from './utils';
+
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+afterEach(() => {
+	process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix ?? './tests/cli/';
+});
+
+test('studio #1', async (t) => {
+	const res = await brotest(studio, '');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		schema: './schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			url: 'postgresql://postgres:postgres@127.0.0.1:5432/db',
+		},
+	});
+});
+
+test('studio #2', async (t) => {
+	const res = await brotest(studio, '--config=turso.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'turso',
+		schema: './schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			authToken: 'token',
+			url: 'turso.dev',
+		},
+	});
+});
+
+test('studio #3', async (t) => {
+	const res = await brotest(studio, '--config=d1http.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'sqlite',
+		schema: './schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			accountId: 'accid',
+			databaseId: 'dbid',
+			driver: 'd1-http',
+			token: 'token',
+		},
+	});
+});
+
+test('studio #4', async (t) => {
+	const res = await brotest(studio, '--config=postgres.config.ts');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		schema: './schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			host: '127.0.0.1',
+			port: 5432,
+			user: 'postgresql',
+			password: 'postgres',
+			database: 'db',
+		},
+	});
+});
+
+// catched a bug
+test('studio #5', async (t) => {
+	const res = await brotest(studio, '--config=postgres2.config.ts');
+	if (res.type !== 'handler') {
+		assert.fail(res.type, 'handler');
+	}
+
+	expect(res.options).toStrictEqual({
+		dialect: 'postgresql',
+		schema: './schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			host: '127.0.0.1',
+			port: 5432,
+			user: 'postgresql',
+			password: 'postgres',
+			database: 'db',
+		},
+	});
+});
+
+// --- errors ---
+test('err #1', async (t) => {
+	const res = await brotest(studio, '--config=expo.config.ts');
+	assert.equal(res.type, 'error');
+});
+
+const prefix = process.env.TEST_CONFIG_PATH_PREFIX!;
+test('validate config #1', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		dbCredentials: { url: 'test_url' },
+		introspect: { casing: 'preserve' },
+		strict: true,
+		schemaFilter: ['public'],
+		breakpoints: false,
+		driver: 'pglite',
+		entities: {
+			roles: true,
+		},
+		extensionsFilters: ['postgis'],
+		migrations: {
+			schema: 'new_schema',
+		},
+		tablesFilter: ['test'],
+		out: 'drizzle2',
+		verbose: false,
+	}, prefix);
+
+	const res = await brotest(studio, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		host: '127.0.0.1',
+		port: 4983,
+		credentials: {
+			driver: 'pglite',
+			url: 'test_url',
+		},
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #2', async (t) => {
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		dbCredentials: {
+			url: 'test',
+		},
+	}, prefix);
+
+	const res = await brotest(studio, `--config=${name}`);
+
+	unlinkSync(path);
+	assert.equal(res.type, 'handler');
+	if (res.type !== 'handler') assert.fail(res.type, 'handler');
+
+	const expected = {
+		credentials: {
+			url: 'test',
+		},
+		dialect: 'postgresql',
+		host: '127.0.0.1',
+		port: 4983,
+		schema: undefined,
+	};
+	expect(res.options).toStrictEqual(expected);
+});
+
+test('validate config #5', async (t) => {
+	const spy = vi.spyOn(console, 'log');
+
+	// @ts-expect-error
+	const { path, name } = createConfig({
+		// dialect: 'mysql',
+		// schema: 'schema.ts',
+		dbCredentials: {
+			url: 'url',
+		},
+	}, prefix);
+
+	const res = await brotest(studio, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+
+	const calls = spy.mock.calls.map((c) => stripAnsi(String(c[0])));
+	expect(calls[0]).toBe(`Reading config file '${path}'`);
+	expect(calls[1]).toBe(
+		` Invalid input  Please specify 'dialect' param in config, either of 'postgresql', 'mysql', 'sqlite', turso or singlestore`,
+	);
+
+	let error: any = res.type === 'error' ? res.error : undefined;
+	expect(error).toBeDefined();
+	expect(error).toBeInstanceOf(Error);
+	expect(error.message).toBe('process.exit unexpectedly called with "1"');
+
+	spy.mockRestore();
+});
+
+test('validate config #6', async (t) => {
+	const spy = vi.spyOn(console, 'log');
+
+	const { path, name } = createConfig({
+		dialect: 'postgresql',
+		schema: 'schema.ts',
+		// dbCredentials: {
+		// 	url: 'url',
+		// },
+	}, prefix);
+
+	const res = await brotest(studio, `--config=${name}`);
+
+	unlinkSync(path);
+
+	expect(res.type).toBe('error');
+
+	const calls = spy.mock.calls.map((c) => stripAnsi(String(c[0])));
+	expect(calls[0]).toBe(`Reading config file '${path}'`);
+	expect(calls[1]).toBe(
+		` Invalid input  Please specify a 'dbCredentials' param in config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`,
+	);
+
+	let error: any = res.type === 'error' ? res.error : undefined;
+	expect(error).toBeDefined();
+	expect(error).toBeInstanceOf(Error);
+	expect(error.message).toBe('process.exit unexpectedly called with "1"');
+
+	spy.mockRestore();
+});
diff --git a/drizzle-kit/tests/other/dialect.test.ts b/drizzle-kit/tests/other/dialect.test.ts
new file mode 100644
index 0000000000..b630f13f90
--- /dev/null
+++ b/drizzle-kit/tests/other/dialect.test.ts
@@ -0,0 +1,2730 @@
+import { create, diff } from 'src/dialects/dialect';
+import { createDDL as pg } from 'src/dialects/postgres/ddl';
+import { beforeEach } from 'vitest';
+import { expect, expectTypeOf, test } from 'vitest';
+
+const db = create({
+	tables: {},
+	columns: {
+		table: 'required',
+		type: 'string',
+		primaryKey: 'boolean',
+		notNull: 'boolean',
+		autoincrement: 'boolean?',
+		default: 'string?',
+		generated: {
+			type: 'string',
+			as: 'string',
+		},
+	},
+	indexes: {
+		table: 'required',
+		columns: [{
+			value: 'string',
+			expression: 'boolean',
+		}],
+		isUnique: 'boolean',
+		where: 'string?',
+	},
+	fks: {
+		table: 'required',
+		tableFrom: 'string',
+		columnsFrom: 'string[]',
+		tableTo: 'string',
+		columnsTo: 'string[]',
+		onUpdate: 'string?',
+		onDelete: 'string?',
+	},
+	pks: {
+		table: 'required',
+		columns: 'string[]',
+	},
+	uniques: {
+		table: 'required',
+		columns: 'string[]',
+	},
+	checks: {
+		table: 'required',
+		value: 'string',
+	},
+	views: {
+		definition: 'string?',
+		isExisting: 'boolean',
+	},
+	viewColumns: {},
+});
+
+beforeEach(() => {
+	db.entities.delete();
+});
+
+test('Insert with custom conflict detection list', () => {
+	db.entities.push({
+		entityType: 'checks',
+		name: 'a',
+		table: 't',
+		value: '2',
+	}, ['name']);
+	expect(
+		db.entities.push({
+			entityType: 'checks',
+			name: 'b',
+			table: 't',
+			value: '2',
+		}, ['name']).status,
+	).toStrictEqual('OK');
+	expect(
+		db.entities.push({
+			entityType: 'checks',
+			name: 'a',
+			table: 'tt',
+			value: '2',
+		}, ['name']).status,
+	).toStrictEqual('CONFLICT');
+});
+
+test('Insert & list multiple entities', () => {
+	const inFirst = db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	const inSecond = db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	expect(inFirst).toStrictEqual({
+		status: 'OK',
+		data: {
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		},
+	});
+
+	expect(inSecond).toStrictEqual({
+		status: 'OK',
+		data: {
+			columns: [{
+				value: 'user_id',
+				expression: false,
+			}, {
+				value: 'group_id',
+				expression: false,
+			}],
+			table: 'users_to_groups',
+			isUnique: true,
+			name: 'utg_idx',
+			where: null,
+			entityType: 'indexes',
+		},
+	});
+
+	expect(db.entities.one()).toStrictEqual({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	});
+
+	expect(db.pks.one()).toStrictEqual(null);
+
+	expect(db.entities.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.columns.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(db.indexes.list()).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.views.list()).toStrictEqual([]);
+});
+
+test('Insert & list multiple entities via common function', () => {
+	const inFirst = db.entities.push({
+		entityType: 'columns',
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	const inSecond = db.entities.push({
+		entityType: 'indexes',
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	expect(inFirst).toStrictEqual({
+		status: 'OK',
+		data: {
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		},
+	});
+
+	expect(inSecond).toStrictEqual({
+		status: 'OK',
+		data: {
+			columns: [{
+				value: 'user_id',
+				expression: false,
+			}, {
+				value: 'group_id',
+				expression: false,
+			}],
+			table: 'users_to_groups',
+			isUnique: true,
+			name: 'utg_idx',
+			where: null,
+			entityType: 'indexes',
+		},
+	});
+
+	expect(db.entities.one()).toStrictEqual({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	});
+
+	expect(db.pks.one()).toStrictEqual(null);
+
+	expect(db.entities.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.columns.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(db.indexes.list()).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.views.list()).toStrictEqual([]);
+});
+
+test('Insert with common hash conflict', () => {
+	const inFirst = db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	const inSecond = db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: false,
+		primaryKey: false,
+		table: 'users',
+		type: 'text',
+	});
+
+	expect(inFirst).toStrictEqual({
+		status: 'OK',
+		data: {
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		},
+	});
+
+	expect(inSecond).toStrictEqual({
+		status: 'CONFLICT',
+		data: {
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		},
+	});
+
+	expect(db.entities.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(db.columns.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+});
+
+test('Delete specific entities', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const delFirst = db.columns.delete();
+
+	const delSecond = db.indexes.delete({
+		columns: {
+			CONTAINS: {
+				value: 'user_id',
+				expression: false,
+			},
+		},
+	});
+
+	expect(delFirst).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(delSecond).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.entities.list()).toStrictEqual([{
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.columns.list()).toStrictEqual([]);
+
+	expect(db.indexes.list()).toStrictEqual([{
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+});
+
+test('Delete specific entities via common function', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const delFirst = db.entities.delete({
+		entityType: 'columns',
+	});
+
+	const delSecond = db.entities.delete({
+		entityType: 'indexes',
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+	});
+
+	expect(delFirst).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(delSecond).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.entities.list()).toStrictEqual([{
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+
+	expect(db.columns.list()).toStrictEqual([]);
+
+	expect(db.indexes.list()).toStrictEqual([{
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+});
+
+test('Update entities', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const updFirst = db.columns.update({
+		set: {
+			type: 'bigint',
+		},
+	});
+
+	const updSecond = db.indexes.update({
+		set: {
+			where: 'whereExp',
+			columns: (c) => {
+				return {
+					...c,
+					expression: true,
+				};
+			},
+		},
+		where: {
+			columns: {
+				CONTAINS: {
+					value: 'user_id',
+					expression: false,
+				},
+			},
+		},
+	});
+
+	expect(updFirst).toStrictEqual({
+		status: 'OK',
+		data: [{
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'bigint',
+			entityType: 'columns',
+		}, {
+			name: 'name',
+			autoincrement: null,
+			default: null,
+			generated: null,
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'bigint',
+			entityType: 'columns',
+		}],
+	});
+
+	expect(updSecond).toStrictEqual({
+		status: 'OK',
+		data: [{
+			columns: [{
+				value: 'user_id',
+				expression: true,
+			}, {
+				value: 'group_id',
+				expression: true,
+			}],
+			table: 'users_to_groups',
+			isUnique: true,
+			name: 'utg_idx',
+			where: 'whereExp',
+			entityType: 'indexes',
+		}],
+	});
+
+	expect(db.entities.list()).toStrictEqual([
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: {
+				as: 'identity',
+				type: 'always',
+			},
+			name: 'id',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'bigint',
+		},
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'name',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'bigint',
+		},
+		{
+			columns: [
+				{
+					expression: true,
+					value: 'user_id',
+				},
+				{
+					expression: true,
+					value: 'group_id',
+				},
+			],
+			entityType: 'indexes',
+			isUnique: true,
+			name: 'utg_idx',
+			table: 'users_to_groups',
+			where: 'whereExp',
+		},
+		{
+			columns: [
+				{
+					expression: false,
+					value: 'group_id',
+				},
+			],
+			entityType: 'indexes',
+			isUnique: false,
+			name: 'utg_g_idx',
+			table: 'users_to_groups',
+			where: null,
+		},
+	]);
+
+	expect(db.columns.list()).toStrictEqual(
+		[
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: {
+					as: 'identity',
+					type: 'always',
+				},
+				name: 'id',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'bigint',
+			},
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: null,
+				name: 'name',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'bigint',
+			},
+		],
+	);
+
+	expect(db.indexes.list()).toStrictEqual(
+		[
+			{
+				columns: [
+					{
+						expression: true,
+						value: 'user_id',
+					},
+					{
+						expression: true,
+						value: 'group_id',
+					},
+				],
+				entityType: 'indexes',
+				isUnique: true,
+				name: 'utg_idx',
+				table: 'users_to_groups',
+				where: 'whereExp',
+			},
+			{
+				columns: [
+					{
+						expression: false,
+						value: 'group_id',
+					},
+				],
+				entityType: 'indexes',
+				isUnique: false,
+				name: 'utg_g_idx',
+				table: 'users_to_groups',
+				where: null,
+			},
+		],
+	);
+});
+
+test('Update entities conflict - with filter', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'avatar',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: false,
+		table: 'users',
+		type: 'string',
+	});
+
+	const upd = db.columns.update({
+		set: {
+			name: 'id',
+		},
+		where: {
+			name: 'name',
+		},
+	});
+
+	expect(upd).toStrictEqual({
+		status: 'CONFLICT',
+		data: [{
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		}],
+	});
+
+	expect(db.entities.list()).toStrictEqual([
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: {
+				as: 'identity',
+				type: 'always',
+			},
+			name: 'id',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+		},
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'name',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+		},
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'avatar',
+			notNull: true,
+			primaryKey: false,
+			table: 'users',
+			type: 'string',
+		},
+	]);
+
+	expect(db.columns.list()).toStrictEqual(
+		[
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: {
+					as: 'identity',
+					type: 'always',
+				},
+				name: 'id',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'string',
+			},
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: null,
+				name: 'name',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'string',
+			},
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: null,
+				name: 'avatar',
+				notNull: true,
+				primaryKey: false,
+				table: 'users',
+				type: 'string',
+			},
+		],
+	);
+
+	expect(db.indexes.list()).toStrictEqual([]);
+});
+
+test('Update entities conflict - no filter', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'avatar',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: false,
+		table: 'users',
+		type: 'string',
+	});
+
+	const upd = db.columns.update({
+		set: {
+			name: 'id',
+		},
+	});
+
+	expect(upd).toStrictEqual({
+		status: 'CONFLICT',
+		data: [{
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+			entityType: 'columns',
+		}],
+	});
+
+	expect(db.entities.list()).toStrictEqual([
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: {
+				as: 'identity',
+				type: 'always',
+			},
+			name: 'id',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+		},
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'name',
+			notNull: true,
+			primaryKey: true,
+			table: 'users',
+			type: 'string',
+		},
+		{
+			autoincrement: null,
+			default: null,
+			entityType: 'columns',
+			generated: null,
+			name: 'avatar',
+			notNull: true,
+			primaryKey: false,
+			table: 'users',
+			type: 'string',
+		},
+	]);
+
+	expect(db.columns.list()).toStrictEqual(
+		[
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: {
+					as: 'identity',
+					type: 'always',
+				},
+				name: 'id',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'string',
+			},
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: null,
+				name: 'name',
+				notNull: true,
+				primaryKey: true,
+				table: 'users',
+				type: 'string',
+			},
+			{
+				autoincrement: null,
+				default: null,
+				entityType: 'columns',
+				generated: null,
+				name: 'avatar',
+				notNull: true,
+				primaryKey: false,
+				table: 'users',
+				type: 'string',
+			},
+		],
+	);
+
+	expect(db.indexes.list()).toStrictEqual([]);
+});
+
+test('Update entities via common function', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const updFirst = db.entities.update({
+		set: {
+			table: 'upd_tbl',
+		},
+	});
+
+	const updSecond = db.entities.update({
+		set: {
+			name: (n) => `${n}_upd`,
+		},
+		where: {
+			columns: [
+				{
+					expression: false,
+					value: 'user_id',
+				},
+				{
+					expression: false,
+					value: 'group_id',
+				},
+			],
+		},
+	});
+
+	expect(updFirst).toStrictEqual({
+		status: 'OK',
+		data: [{
+			name: 'id',
+			autoincrement: null,
+			default: null,
+			generated: {
+				type: 'always',
+				as: 'identity',
+			},
+			notNull: true,
+			primaryKey: true,
+			table: 'upd_tbl',
+			type: 'string',
+			entityType: 'columns',
+		}, {
+			name: 'name',
+			autoincrement: null,
+			default: null,
+			generated: null,
+			notNull: true,
+			primaryKey: true,
+			table: 'upd_tbl',
+			type: 'string',
+			entityType: 'columns',
+		}, {
+			columns: [{
+				value: 'user_id',
+				expression: false,
+			}, {
+				value: 'group_id',
+				expression: false,
+			}],
+			table: 'upd_tbl',
+			isUnique: true,
+			name: 'utg_idx_upd',
+			where: null,
+			entityType: 'indexes',
+		}, {
+			columns: [
+				{
+					expression: false,
+					value: 'group_id',
+				},
+			],
+			entityType: 'indexes',
+			isUnique: false,
+			name: 'utg_g_idx',
+			table: 'upd_tbl',
+			where: null,
+		}],
+	});
+
+	expect(updSecond).toStrictEqual({
+		status: 'OK',
+		data: [{
+			columns: [{
+				value: 'user_id',
+				expression: false,
+			}, {
+				value: 'group_id',
+				expression: false,
+			}],
+			table: 'upd_tbl',
+			isUnique: true,
+			name: 'utg_idx_upd',
+			where: null,
+			entityType: 'indexes',
+		}],
+	});
+
+	expect(db.entities.list()).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'upd_tbl',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'upd_tbl',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'upd_tbl',
+		isUnique: true,
+		name: 'utg_idx_upd',
+		where: null,
+		entityType: 'indexes',
+	}, {
+		columns: [
+			{
+				expression: false,
+				value: 'group_id',
+			},
+		],
+		entityType: 'indexes',
+		isUnique: false,
+		name: 'utg_g_idx',
+		table: 'upd_tbl',
+		where: null,
+	}]);
+
+	expect(db.columns.list()).toStrictEqual(
+		[
+			{
+				name: 'id',
+				autoincrement: null,
+				default: null,
+				generated: {
+					type: 'always',
+					as: 'identity',
+				},
+				notNull: true,
+				primaryKey: true,
+				table: 'upd_tbl',
+				type: 'string',
+				entityType: 'columns',
+			},
+			{
+				name: 'name',
+				autoincrement: null,
+				default: null,
+				generated: null,
+				notNull: true,
+				primaryKey: true,
+				table: 'upd_tbl',
+				type: 'string',
+				entityType: 'columns',
+			},
+		],
+	);
+
+	expect(db.indexes.list()).toStrictEqual(
+		[
+			{
+				columns: [{
+					value: 'user_id',
+					expression: false,
+				}, {
+					value: 'group_id',
+					expression: false,
+				}],
+				table: 'upd_tbl',
+				isUnique: true,
+				name: 'utg_idx_upd',
+				where: null,
+				entityType: 'indexes',
+			},
+			{
+				columns: [
+					{
+						expression: false,
+						value: 'group_id',
+					},
+				],
+				entityType: 'indexes',
+				isUnique: false,
+				name: 'utg_g_idx',
+				table: 'upd_tbl',
+				where: null,
+			},
+		],
+	);
+});
+
+test('List with filters', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const listFirst = db.columns.list();
+
+	const listSecond = db.indexes.list({
+		columns: {
+			CONTAINS: {
+				value: 'user_id',
+				expression: false,
+			},
+		},
+	});
+
+	expect(listFirst).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(listSecond).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+});
+
+test('List via common function with filters', () => {
+	db.columns.push({
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.columns.push({
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+	});
+
+	db.indexes.push({
+		columns: [{
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: false,
+		name: 'utg_g_idx',
+		where: null,
+	});
+
+	const listFirst = db.entities.list({
+		entityType: 'columns',
+	});
+
+	const listSecond = db.entities.list({
+		entityType: 'indexes',
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+	});
+
+	expect(listFirst).toStrictEqual([{
+		name: 'id',
+		autoincrement: null,
+		default: null,
+		generated: {
+			type: 'always',
+			as: 'identity',
+		},
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}, {
+		name: 'name',
+		autoincrement: null,
+		default: null,
+		generated: null,
+		notNull: true,
+		primaryKey: true,
+		table: 'users',
+		type: 'string',
+		entityType: 'columns',
+	}]);
+
+	expect(listSecond).toStrictEqual([{
+		columns: [{
+			value: 'user_id',
+			expression: false,
+		}, {
+			value: 'group_id',
+			expression: false,
+		}],
+		table: 'users_to_groups',
+		isUnique: true,
+		name: 'utg_idx',
+		where: null,
+		entityType: 'indexes',
+	}]);
+});
+
+test('Validate', () => {
+	const junk = {};
+	if (db.views.validate(junk)) {
+		expectTypeOf(junk).toEqualTypeOf<Exclude<ReturnType<typeof db.views.one>, null>>();
+	}
+
+	if (db.entities.validate(junk)) {
+		expectTypeOf(junk).toEqualTypeOf<Exclude<ReturnType<typeof db.entities.one>, null>>();
+	}
+
+	const table: typeof db._.types.tables = {
+		entityType: 'tables',
+		name: 'tbl',
+	};
+
+	expect(db.entities.validate(table)).toStrictEqual(true);
+	expect(db.tables.validate(table)).toStrictEqual(true);
+	expect(db.views.validate(table)).toStrictEqual(false);
+
+	const deformedTable = {
+		entityType: 'tables',
+		name: 'tbl',
+		schema: null,
+	};
+
+	expect(db.entities.validate(deformedTable)).toStrictEqual(false);
+	expect(db.tables.validate(deformedTable)).toStrictEqual(false);
+	expect(db.views.validate(deformedTable)).toStrictEqual(false);
+
+	const deformedTable2 = {
+		entityType: 'tables',
+		name: 'tbl',
+		schema: 'sch',
+	};
+
+	expect(db.entities.validate(deformedTable2)).toStrictEqual(false);
+	expect(db.tables.validate(deformedTable2)).toStrictEqual(false);
+	expect(db.views.validate(deformedTable2)).toStrictEqual(false);
+
+	const column: typeof db._.types.columns = {
+		autoincrement: false,
+		default: null,
+		entityType: 'columns',
+		generated: { as: 'as', type: 'type' },
+		name: 'cn',
+		notNull: false,
+		primaryKey: false,
+		table: 'tt',
+		type: 'varchar',
+	};
+
+	expect(db.entities.validate(column)).toStrictEqual(true);
+	expect(db.columns.validate(column)).toStrictEqual(true);
+	expect(db.tables.validate(column)).toStrictEqual(false);
+
+	const column2: typeof db._.types.columns = {
+		autoincrement: false,
+		default: null,
+		entityType: 'columns',
+		generated: null,
+		name: 'cn',
+		notNull: false,
+		primaryKey: false,
+		table: 'tt',
+		type: 'varchar',
+	};
+
+	expect(db.entities.validate(column2)).toStrictEqual(true);
+	expect(db.columns.validate(column2)).toStrictEqual(true);
+	expect(db.tables.validate(column2)).toStrictEqual(false);
+
+	const columnDeformed = {
+		autoincrement: false,
+		default: null,
+		entityType: 'columns',
+		generated: { as: 'as', type: 'type', something: undefined },
+		name: 'cn',
+		notNull: false,
+		primaryKey: false,
+		table: 'tt',
+		type: 'varchar',
+	};
+
+	expect(db.entities.validate(columnDeformed)).toStrictEqual(false);
+	expect(db.columns.validate(columnDeformed)).toStrictEqual(false);
+	expect(db.tables.validate(columnDeformed)).toStrictEqual(false);
+
+	const columnDeformed2 = {
+		autoincrement: false,
+		default: null,
+		entityType: 'columns',
+		generated: 'wrong',
+		name: 'cn',
+		notNull: false,
+		primaryKey: false,
+		table: 'tt',
+		type: 'varchar',
+	};
+
+	expect(db.entities.validate(columnDeformed2)).toStrictEqual(false);
+	expect(db.columns.validate(columnDeformed2)).toStrictEqual(false);
+	expect(db.tables.validate(columnDeformed2)).toStrictEqual(false);
+
+	const pk: typeof db._.types.pks = {
+		columns: [],
+		entityType: 'pks',
+		name: 'pk1',
+		table: 'tt',
+	};
+
+	expect(db.entities.validate(pk)).toStrictEqual(true);
+	expect(db.pks.validate(pk)).toStrictEqual(true);
+	expect(db.views.validate(pk)).toStrictEqual(false);
+
+	const pk2: typeof db._.types.pks = {
+		columns: ['str', 'str2', 'str3'],
+		entityType: 'pks',
+		name: 'pk1',
+		table: 'tt',
+	};
+
+	expect(db.entities.validate(pk2)).toStrictEqual(true);
+	expect(db.pks.validate(pk2)).toStrictEqual(true);
+	expect(db.views.validate(pk2)).toStrictEqual(false);
+
+	const pkDeformed = {
+		columns: ['str', null, 'str3'],
+		entityType: 'pks',
+		name: 'pk1',
+		table: 'tt',
+	};
+
+	expect(db.entities.validate(pkDeformed)).toStrictEqual(false);
+	expect(db.pks.validate(pkDeformed)).toStrictEqual(false);
+	expect(db.views.validate(pkDeformed)).toStrictEqual(false);
+
+	const index: typeof db._.types.indexes = {
+		columns: [],
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(index)).toStrictEqual(true);
+	expect(db.indexes.validate(index)).toStrictEqual(true);
+	expect(db.pks.validate(index)).toStrictEqual(false);
+
+	const index2: typeof db._.types.indexes = {
+		columns: [{
+			expression: true,
+			value: 'expr',
+		}],
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(index2)).toStrictEqual(true);
+	expect(db.indexes.validate(index2)).toStrictEqual(true);
+	expect(db.pks.validate(index2)).toStrictEqual(false);
+
+	const index3: typeof db._.types.indexes = {
+		columns: [{
+			expression: true,
+			value: 'expr',
+		}, {
+			expression: false,
+			value: 'ex2',
+		}],
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(index3)).toStrictEqual(true);
+	expect(db.indexes.validate(index3)).toStrictEqual(true);
+	expect(db.pks.validate(index3)).toStrictEqual(false);
+
+	const indexDeformed = {
+		columns: 2,
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(indexDeformed)).toStrictEqual(false);
+	expect(db.indexes.validate(indexDeformed)).toStrictEqual(false);
+	expect(db.pks.validate(indexDeformed)).toStrictEqual(false);
+
+	const indexDeformed2 = {
+		columns: [{
+			expression: true,
+			value: 'expr',
+		}, {
+			expression: false,
+			value: 'ex2',
+		}, 'who?'],
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(indexDeformed2)).toStrictEqual(false);
+	expect(db.indexes.validate(indexDeformed2)).toStrictEqual(false);
+	expect(db.pks.validate(indexDeformed2)).toStrictEqual(false);
+
+	const indexDeformed3 = {
+		columns: [null, {
+			expression: true,
+			value: 'expr',
+		}, {
+			expression: false,
+			value: 'ex2',
+		}],
+		entityType: 'indexes',
+		isUnique: true,
+		name: 'idx',
+		table: 'tt',
+		where: null,
+	};
+
+	expect(db.entities.validate(indexDeformed3)).toStrictEqual(false);
+	expect(db.indexes.validate(indexDeformed3)).toStrictEqual(false);
+	expect(db.pks.validate(indexDeformed3)).toStrictEqual(false);
+});
+
+test('diff: update', () => {
+	const cfg = {
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+		},
+	} as const;
+
+	const original = create(cfg);
+	const changed = create(cfg);
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	original.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	changed.column.push({
+		name: 'name',
+		type: 'text',
+		pk: false,
+		table: 'user',
+	});
+
+	const res = diff.alters(original, changed, 'column');
+
+	expect(diff.all(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+	expect(diff.all(original, changed)).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+	expect(diff.drops(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.drops(original, changed)).toStrictEqual([]);
+	expect(diff.alters(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+	expect(diff.alters(original, changed)).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+	expect(diff.creates(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.creates(original, changed)).toStrictEqual([]);
+
+	expect(res).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+});
+
+test('diff: update object', () => {
+	const cfg = {
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+			obj: {
+				subfield: 'string',
+				subArr: 'string[]',
+			},
+		},
+	} as const;
+
+	const original = create(cfg);
+	const changed = create(cfg);
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+		obj: {
+			subArr: ['s3', 's4'],
+			subfield: 'sf_value_upd',
+		},
+	});
+	original.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+		obj: {
+			subArr: ['s1', 's2'],
+			subfield: 'sf_value',
+		},
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+		obj: null,
+	});
+	changed.column.push({
+		name: 'name',
+		type: 'text',
+		pk: false,
+		table: 'user',
+		obj: {
+			subArr: ['s3', 's4'],
+			subfield: 'sf_value',
+		},
+	});
+
+	const res = diff.alters(original, changed, 'column');
+
+	expect(res).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'id',
+		obj: {
+			from: {
+				subArr: ['s3', 's4'],
+				subfield: 'sf_value_upd',
+			},
+			to: null,
+		},
+		$left: {
+			entityType: 'column',
+			name: 'id',
+			obj: {
+				subArr: [
+					's3',
+					's4',
+				],
+				subfield: 'sf_value_upd',
+			},
+			pk: true,
+			table: 'user',
+			type: 'serial',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'id',
+			obj: null,
+			pk: true,
+			table: 'user',
+			type: 'serial',
+		},
+	}, {
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		obj: {
+			from: {
+				subArr: ['s1', 's2'],
+				subfield: 'sf_value',
+			},
+			to: {
+				subArr: ['s3', 's4'],
+				subfield: 'sf_value',
+			},
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			obj: {
+				subArr: [
+					's1',
+					's2',
+				],
+				subfield: 'sf_value',
+			},
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			obj: {
+				subArr: [
+					's3',
+					's4',
+				],
+				subfield: 'sf_value',
+			},
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+});
+
+test('diff: update object array', () => {
+	const original = create({
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+			obj: [{
+				subfield: 'string',
+				subArr: 'string[]',
+			}],
+		},
+	});
+	const changed = create({
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+			obj: [{
+				subfield: 'string',
+				subArr: 'string[]',
+			}],
+		},
+	});
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+		obj: [{
+			subArr: ['s3', 's4'],
+			subfield: 'sf_value',
+		}],
+	});
+	original.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+		obj: [{
+			subArr: ['s1', 's2'],
+			subfield: 'sf_value',
+		}],
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+		obj: [{
+			subArr: ['s3', 's4'],
+			subfield: 'sf_value',
+		}, {
+			subArr: ['s1', 's2'],
+			subfield: 'sf_value',
+		}],
+	});
+	changed.column.push({
+		name: 'name',
+		type: 'text',
+		pk: false,
+		table: 'user',
+		obj: [{
+			subArr: ['s1', 's2'],
+			subfield: 'sf_value_upd',
+		}],
+	});
+
+	const res = diff.alters(original, changed, 'column');
+
+	expect(res).toStrictEqual([{
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'id',
+		obj: {
+			from: [{
+				subArr: ['s3', 's4'],
+				subfield: 'sf_value',
+			}],
+			to: [{
+				subArr: ['s3', 's4'],
+				subfield: 'sf_value',
+			}, {
+				subArr: ['s1', 's2'],
+				subfield: 'sf_value',
+			}],
+		},
+		$left: {
+			entityType: 'column',
+			name: 'id',
+			obj: [
+				{
+					subArr: [
+						's3',
+						's4',
+					],
+					subfield: 'sf_value',
+				},
+			],
+			pk: true,
+			table: 'user',
+			type: 'serial',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'id',
+			obj: [
+				{
+					subArr: [
+						's3',
+						's4',
+					],
+					subfield: 'sf_value',
+				},
+				{
+					subArr: [
+						's1',
+						's2',
+					],
+					subfield: 'sf_value',
+				},
+			],
+			pk: true,
+			table: 'user',
+			type: 'serial',
+		},
+	}, {
+		$diffType: 'alter',
+		entityType: 'column',
+		table: 'user',
+		name: 'name',
+		type: {
+			from: 'varchar',
+			to: 'text',
+		},
+		obj: {
+			from: [{
+				subArr: ['s1', 's2'],
+				subfield: 'sf_value',
+			}],
+			to: [{
+				subArr: ['s1', 's2'],
+				subfield: 'sf_value_upd',
+			}],
+		},
+		$left: {
+			entityType: 'column',
+			name: 'name',
+			obj: [
+				{
+					subArr: [
+						's1',
+						's2',
+					],
+					subfield: 'sf_value',
+				},
+			],
+			pk: false,
+			table: 'user',
+			type: 'varchar',
+		},
+		$right: {
+			entityType: 'column',
+			name: 'name',
+			obj: [
+				{
+					subArr: [
+						's1',
+						's2',
+					],
+					subfield: 'sf_value_upd',
+				},
+			],
+			pk: false,
+			table: 'user',
+			type: 'text',
+		},
+	}]);
+});
+
+test('diff: insert', () => {
+	const cfg = {
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+		},
+	} as const;
+
+	const original = create(cfg);
+	const changed = create(cfg);
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	changed.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+	});
+
+	const res = diff(original, changed, 'column');
+
+	expect(diff.all(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'create',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.all(original, changed)).toStrictEqual([{
+		$diffType: 'create',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.drops(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.drops(original, changed)).toStrictEqual([]);
+	expect(diff.alters(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.alters(original, changed)).toStrictEqual([]);
+	expect(diff.creates(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'create',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.creates(original, changed)).toStrictEqual([{
+		$diffType: 'create',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+
+	expect(res).toStrictEqual([{
+		$diffType: 'create',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+});
+
+test('diff: delete', () => {
+	const cfg = {
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+		},
+	} as const;
+
+	const original = create(cfg);
+	const changed = create(cfg);
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	original.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	const res = diff(original, changed, 'column');
+
+	expect(diff.all(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'drop',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.all(original, changed)).toStrictEqual([{
+		$diffType: 'drop',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.drops(original, changed, 'column')).toStrictEqual([{
+		$diffType: 'drop',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.drops(original, changed)).toStrictEqual([{
+		$diffType: 'drop',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+	expect(diff.alters(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.alters(original, changed)).toStrictEqual([]);
+	expect(diff.creates(original, changed, 'column')).toStrictEqual([]);
+	expect(diff.creates(original, changed)).toStrictEqual([]);
+
+	expect(res).toStrictEqual([{
+		$diffType: 'drop',
+		entityType: 'column',
+		name: 'name',
+		table: 'user',
+		type: 'varchar',
+		pk: false,
+	}]);
+});
+
+test('indexes #1', () => {
+	const ddl1 = pg();
+	const ddl2 = pg();
+
+	ddl1.indexes.push({
+		schema: 'public',
+		table: 'users',
+		name: 'users_id_index',
+		columns: [{ value: 'id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+		isUnique: false,
+		where: null,
+		with: '',
+		concurrently: false,
+		method: 'btree',
+		nameExplicit: true,
+	});
+
+	ddl1.indexes.push({
+		schema: 'public',
+		table: 'users',
+		name: 'indx4',
+		columns: [{ value: 'id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+		isUnique: false,
+		where: null,
+		with: '',
+		concurrently: false,
+		method: 'btree',
+		nameExplicit: true,
+	});
+
+	ddl2.indexes.push({
+		schema: 'public',
+		table: 'users',
+		name: 'users_id_index',
+		columns: [{ value: 'id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+		isUnique: false,
+		where: null,
+		with: '',
+		concurrently: false,
+		method: 'btree',
+		nameExplicit: false,
+	});
+
+	ddl2.indexes.push({
+		schema: 'public',
+		table: 'users',
+		name: 'indx4',
+		columns: [{ value: 'id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+		isUnique: false,
+		where: null,
+		with: '',
+		concurrently: false,
+		method: 'btree',
+		nameExplicit: true,
+	});
+
+	const d = diff(ddl1, ddl2, 'indexes');
+	expect(d).toStrictEqual([]);
+});
+
+test('hasDiff', () => {
+	const cfg = {
+		column: {
+			type: 'string',
+			pk: 'boolean?',
+			table: 'required',
+		},
+	} as const;
+
+	const original = create(cfg);
+	const changed = create(cfg);
+
+	original.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	original.column.push({
+		name: 'name',
+		type: 'varchar',
+		pk: false,
+		table: 'user',
+	});
+
+	changed.column.push({
+		name: 'id',
+		type: 'serial',
+		pk: true,
+		table: 'user',
+	});
+	changed.column.push({
+		name: 'name',
+		type: 'text',
+		pk: false,
+		table: 'user',
+	});
+
+	const res = diff.alters(original, changed, 'column');
+
+	const exampleDiff = res[0];
+	expect(original.column.hasDiff(exampleDiff)).toStrictEqual(true);
+	expect(original.entities.hasDiff(exampleDiff)).toStrictEqual(true);
+
+	delete exampleDiff['type'];
+	expect(original.column.hasDiff(exampleDiff)).toStrictEqual(false);
+	expect(original.entities.hasDiff(exampleDiff)).toStrictEqual(false);
+});
diff --git a/drizzle-kit/tests/other/hints-parse.test.ts b/drizzle-kit/tests/other/hints-parse.test.ts
new file mode 100644
index 0000000000..4de4b8729b
--- /dev/null
+++ b/drizzle-kit/tests/other/hints-parse.test.ts
@@ -0,0 +1,314 @@
+import { InvalidHintsCliError } from 'src/cli/errors';
+import { type ConfirmDataLossHint, type CreateHint, type Hint, HintsHandler, type RenameHint } from 'src/cli/hints';
+import { expect, test } from 'vitest';
+
+const validRenameHints = [
+	{ type: 'rename', kind: 'table', from: ['public', 'orders'] as const, to: ['public', 'orders_v2'] as const },
+	{
+		type: 'rename',
+		kind: 'column',
+		from: ['public', 'orders', 'status'] as const,
+		to: ['public', 'orders', 'state'] as const,
+	},
+	{ type: 'rename', kind: 'schema', from: ['public'] as const, to: ['archive'] as const },
+	{ type: 'rename', kind: 'enum', from: ['public', 'status'] as const, to: ['public', 'order_status'] as const },
+	{
+		type: 'rename',
+		kind: 'sequence',
+		from: ['public', 'orders_id_seq'] as const,
+		to: ['public', 'orders_v2_id_seq'] as const,
+	},
+	{ type: 'rename', kind: 'view', from: ['public', 'active_orders'] as const, to: ['public', 'open_orders'] as const },
+	{
+		type: 'rename',
+		kind: 'policy',
+		from: ['public', 'orders', 'orders_policy'] as const,
+		to: ['public', 'orders', 'orders_rls'] as const,
+	},
+	{ type: 'rename', kind: 'role', from: ['app_user'] as const, to: ['app_runtime'] as const },
+	{
+		type: 'rename',
+		kind: 'privilege',
+		from: ['alice', 'bob', 'public', 'orders', 'SELECT'] as const,
+		to: ['alice', 'bob', 'public', 'orders_v2', 'SELECT'] as const,
+	},
+	{
+		type: 'rename',
+		kind: 'check',
+		from: ['public', 'orders', 'orders_check'] as const,
+		to: ['public', 'orders', 'orders_v2_check'] as const,
+	},
+	{
+		type: 'rename',
+		kind: 'index',
+		from: ['public', 'orders', 'orders_idx'] as const,
+		to: ['public', 'orders', 'orders_v2_idx'] as const,
+	},
+	{
+		type: 'rename',
+		kind: 'unique',
+		from: ['public', 'orders', 'orders_unique'] as const,
+		to: ['public', 'orders', 'orders_v2_unique'] as const,
+	},
+	{
+		type: 'rename',
+		kind: 'primary_key',
+		from: ['public', 'orders', 'orders_pkey'] as const,
+		to: ['public', 'orders', 'orders_v2_pkey'] as const,
+	},
+	{
+		type: 'rename',
+		kind: 'foreign key',
+		from: ['public', 'orders', 'orders_user_id_fkey'] as const,
+		to: ['public', 'orders', 'orders_v2_user_id_fkey'] as const,
+	},
+] satisfies readonly RenameHint[];
+
+const validCreateHints = [
+	{ type: 'create', kind: 'table', entity: ['public', 'orders'] as const },
+	{ type: 'create', kind: 'column', entity: ['public', 'orders', 'status'] as const },
+	{ type: 'create', kind: 'schema', entity: ['public'] as const },
+	{ type: 'create', kind: 'enum', entity: ['public', 'status'] as const },
+	{ type: 'create', kind: 'sequence', entity: ['public', 'orders_id_seq'] as const },
+	{ type: 'create', kind: 'view', entity: ['public', 'active_orders'] as const },
+	{ type: 'create', kind: 'policy', entity: ['public', 'orders', 'orders_policy'] as const },
+	{ type: 'create', kind: 'role', entity: ['app_user'] as const },
+	{ type: 'create', kind: 'privilege', entity: ['alice', 'bob', 'public', 'orders', 'SELECT'] as const },
+	{ type: 'create', kind: 'check', entity: ['public', 'orders', 'orders_check'] as const },
+	{ type: 'create', kind: 'index', entity: ['public', 'orders', 'orders_idx'] as const },
+	{ type: 'create', kind: 'unique', entity: ['public', 'orders', 'orders_unique'] as const },
+	{ type: 'create', kind: 'primary_key', entity: ['public', 'orders', 'orders_pkey'] as const },
+	{ type: 'create', kind: 'foreign key', entity: ['public', 'orders', 'orders_user_id_fkey'] as const },
+] satisfies readonly CreateHint[];
+
+const validConfirmHints = [
+	{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'orders'] as const },
+	{ type: 'confirm_data_loss', kind: 'column', entity: ['public', 'orders', 'status'] as const },
+	{ type: 'confirm_data_loss', kind: 'schema', entity: ['public'] as const },
+	{ type: 'confirm_data_loss', kind: 'view', entity: ['public', 'active_orders'] as const },
+	{ type: 'confirm_data_loss', kind: 'primary_key', entity: ['public', 'orders', 'orders_pkey'] as const },
+	{ type: 'confirm_data_loss', kind: 'add_not_null', entity: ['public', 'orders', 'status'] as const },
+	{ type: 'confirm_data_loss', kind: 'add_unique', entity: ['public', 'orders', 'email'] as const },
+] satisfies readonly ConfirmDataLossHint[];
+
+async function expectInvalidHints(raw: unknown): Promise<InvalidHintsCliError> {
+	try {
+		await HintsHandler.fromCli({ hints: JSON.stringify(raw) });
+	} catch (error) {
+		if (error instanceof InvalidHintsCliError) {
+			return error;
+		}
+
+		throw error;
+	}
+
+	throw new Error('Expected HintsHandler.fromCli to throw InvalidHintsCliError');
+}
+
+async function expectInvalidHintsArray(raw: unknown[]): Promise<InvalidHintsCliError> {
+	try {
+		await HintsHandler.fromCli({ hints: raw as Hint[] });
+	} catch (error) {
+		if (error instanceof InvalidHintsCliError) {
+			return error;
+		}
+
+		throw error;
+	}
+
+	throw new Error('Expected HintsHandler.fromCli to throw InvalidHintsCliError');
+}
+
+function firstIssue(error: InvalidHintsCliError): Record<string, unknown> {
+	const issues = (error.meta?.issues ?? []) as Record<string, unknown>[];
+	const [issue] = issues;
+	if (!issue) {
+		throw new Error('Expected invalid_hints error to include at least one issue');
+	}
+	return issue;
+}
+
+test('HintsHandler.fromCli accepts valid hints for every supported type and kind', async () => {
+	const raw = [...validRenameHints, ...validCreateHints, ...validConfirmHints];
+	const handler = await HintsHandler.fromCli({ hints: JSON.stringify(raw) });
+
+	for (const hint of validRenameHints) {
+		expect(handler.matchRename(hint.kind, hint.to as never)).toStrictEqual(hint);
+	}
+
+	for (const hint of validCreateHints) {
+		expect(handler.matchCreate(hint.kind, hint.entity as never)).toStrictEqual(hint);
+	}
+
+	for (const hint of validConfirmHints) {
+		expect(handler.matchConfirm(hint.kind, hint.entity as never)).toStrictEqual(hint);
+	}
+});
+
+test('HintsHandler.fromCli rejects invalid type', async () => {
+	const error = await expectInvalidHints([{ type: 'drop', kind: 'table', entity: ['public', 'orders'] }]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(error.meta?.source).toBe('inline');
+	expect(issue).toMatchObject({
+		code: 'invalid_union',
+		path: [0],
+	});
+	expect(issue.message).toContain('Invalid input');
+});
+
+test('HintsHandler.fromCli rejects invalid confirm_data_loss kind', async () => {
+	const error = await expectInvalidHints([{ type: 'confirm_data_loss', kind: 'enum', entity: ['public', 'status'] }]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue).toMatchObject({
+		code: 'invalid_union',
+		path: [0],
+	});
+	expect(issue.message).toContain('Invalid input');
+});
+
+test('HintsHandler.fromCli rejects unsupported rename/create hint kinds', async () => {
+	const error = await expectInvalidHints([{ type: 'create', kind: 'trigger', entity: ['public', 'orders', 'id'] }]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue.path).toContain(0);
+	expect(JSON.stringify(issue)).toContain('trigger');
+});
+
+test('HintsHandler.fromCli rejects tuple arity mismatches at the hint item path', async () => {
+	const error = await expectInvalidHints([{ type: 'create', kind: 'column', entity: ['public', 'orders'] }]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue).toMatchObject({
+		code: 'invalid_union',
+		path: [0],
+	});
+});
+
+test('HintsHandler.fromCli rejects non-string tuple members', async () => {
+	const error = await expectInvalidHints([
+		{ type: 'rename', kind: 'table', from: ['public', 'orders'], to: ['public', 42] },
+	]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue).toMatchObject({
+		code: 'invalid_union',
+		path: [0],
+	});
+});
+
+test('HintsHandler.fromCli rejects unknown top-level fields', async () => {
+	const error = await expectInvalidHints([
+		{ type: 'create', kind: 'table', entity: ['public', 'orders'], unexpected: true },
+	]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue).toMatchObject({
+		code: 'unrecognized_keys',
+		keys: ['unexpected'],
+		path: [0],
+	});
+});
+
+test('HintsHandler.fromCli accepts an empty hints array', async () => {
+	const handler = await HintsHandler.fromCli({ hints: '[]' });
+
+	expect(handler.missingHints).toStrictEqual([]);
+});
+
+test('HintsHandler.fromCli accepts a raw Hint[] (SDK form)', async () => {
+	const handler = await HintsHandler.fromCli({ hints: validCreateHints as Hint[] });
+
+	for (const hint of validCreateHints) {
+		expect(handler.matchCreate(hint.kind, hint.entity as never)).toStrictEqual(hint);
+	}
+});
+
+test('HintsHandler.fromCli reports a malformed raw Hint[] as invalid_hints, not internal_error', async () => {
+	const error = await expectInvalidHintsArray([{ type: 'drop', kind: 'table', entity: ['public', 'orders'] }]);
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(error.meta?.source).toBe('inline');
+	expect(issue).toMatchObject({
+		code: 'invalid_union',
+		path: [0],
+	});
+});
+
+test('HintsHandler.fromCli rejects non-array input', async () => {
+	const error = await expectInvalidHints({ type: 'create', kind: 'table', entity: ['public', 'orders'] });
+	const issue = firstIssue(error);
+
+	expect(error.code).toBe('invalid_hints');
+	expect(issue).toMatchObject({
+		code: 'invalid_type',
+		expected: 'array',
+		received: 'object',
+		path: [],
+	});
+});
+
+test('HintsHandler.matchRename returns the stored rename hint', () => {
+	const [renameHint] = validRenameHints;
+	const handler = new HintsHandler([renameHint]);
+
+	expect(handler.matchRename('table', ['public', 'orders_v2'])).toStrictEqual(renameHint);
+});
+
+test('HintsHandler.matchCreate returns the stored create hint', () => {
+	const createHint = validCreateHints[1]!;
+	const handler = new HintsHandler([createHint]);
+
+	expect(handler.matchCreate('column', ['public', 'orders', 'status'])).toStrictEqual(createHint);
+});
+
+test('HintsHandler.matchConfirm returns the stored confirm hint', () => {
+	const [confirmHint] = validConfirmHints;
+	const handler = new HintsHandler([confirmHint]);
+
+	expect(handler.matchConfirm('table', ['public', 'orders'])).toStrictEqual(confirmHint);
+});
+
+test('HintsHandler keeps tuple identities collision-free when matching hints', () => {
+	const explicitSchemaHint = {
+		type: 'create',
+		kind: 'table',
+		entity: ['public', 'orders'] as const,
+	} satisfies CreateHint;
+	const joinedStringHint = {
+		type: 'create',
+		kind: 'table',
+		entity: ['', 'public_orders'] as const,
+	} satisfies CreateHint;
+	const handler = new HintsHandler([explicitSchemaHint, joinedStringHint]);
+
+	expect(handler.matchCreate('table', ['public', 'orders'])).toStrictEqual(explicitSchemaHint);
+	expect(handler.matchCreate('table', ['', 'public_orders'])).toStrictEqual(joinedStringHint);
+});
+
+test('HintsHandler preserves missing hint insertion order', () => {
+	const hints = new HintsHandler();
+
+	hints.pushMissingHint({ type: 'rename_or_create', kind: 'table', entity: ['public', 'orders'] });
+	hints.pushMissingHint({
+		type: 'confirm_data_loss',
+		kind: 'table',
+		entity: ['public', 'customers'],
+		reason: 'non_empty',
+	});
+	hints.pushMissingHint({ type: 'rename_or_create', kind: 'column', entity: ['public', 'users', 'email'] });
+
+	expect(hints.missingHints).toStrictEqual([
+		{ type: 'rename_or_create', kind: 'table', entity: ['public', 'orders'] },
+		{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'customers'], reason: 'non_empty' },
+		{ type: 'rename_or_create', kind: 'column', entity: ['public', 'users', 'email'] },
+	]);
+});
diff --git a/drizzle-kit/tests/other/hints-probe-skip.test.ts b/drizzle-kit/tests/other/hints-probe-skip.test.ts
new file mode 100644
index 0000000000..0d3c87d9bf
--- /dev/null
+++ b/drizzle-kit/tests/other/hints-probe-skip.test.ts
@@ -0,0 +1,327 @@
+import { stripAnsi } from 'hanji/utils';
+import { suggestions } from 'src/cli/commands/push-postgres';
+import { runWithCliContext } from 'src/cli/context';
+import { type Hint, HintsHandler } from 'src/cli/hints';
+import { resolver } from 'src/cli/prompts';
+import {
+	type CheckConstraint,
+	type Column,
+	createDDL,
+	type Enum,
+	type ForeignKey,
+	type Index,
+	type Policy,
+	type PostgresEntities,
+	type PrimaryKey,
+	type Privilege,
+	type Role,
+	type Schema,
+	type Sequence,
+	type Table,
+	type UniqueConstraint,
+	type View,
+} from 'src/dialects/postgres/ddl';
+import { ddlDiff } from 'src/dialects/postgres/diff';
+import { prepareStatement } from 'src/dialects/postgres/statements';
+import type { DB } from 'src/utils';
+import { afterEach, expect, test, vi } from 'vitest';
+
+const table = (name: string, schema = 'public') =>
+	({
+		schema,
+		name,
+		columns: [],
+		indexes: [],
+		pk: null,
+		fks: [],
+		uniques: [],
+		checks: [],
+		policies: [],
+		isRlsEnabled: false,
+	}) satisfies Table;
+
+const column = (tableName: string, name: string, schema = 'public', overrides: Partial<Column> = {}) =>
+	({
+		schema,
+		table: tableName,
+		name,
+		type: 'text',
+		typeSchema: 'pg_catalog',
+		notNull: false,
+		dimensions: 0,
+		default: null,
+		generated: null,
+		identity: null,
+		entityType: 'columns' as const,
+		...overrides,
+	}) satisfies Column;
+
+const view = (name: string, schema = 'public', overrides: Partial<View> = {}) =>
+	({
+		schema,
+		name,
+		definition: null,
+		with: null,
+		withNoData: null,
+		using: null,
+		tablespace: null,
+		materialized: true,
+		entityType: 'views' as const,
+		...overrides,
+	}) satisfies View;
+
+const primaryKey = (tableName: string, name: string, schema = 'public', nameExplicit = true) =>
+	({
+		schema,
+		table: tableName,
+		name,
+		columns: ['id'],
+		nameExplicit,
+		entityType: 'pks' as const,
+	}) satisfies PrimaryKey;
+
+const unique = (tableName: string, name: string, columnName: string, schema = 'public') =>
+	({
+		schema,
+		table: tableName,
+		name,
+		nameExplicit: true,
+		columns: [columnName],
+		nullsNotDistinct: false,
+		entityType: 'uniques' as const,
+	}) satisfies UniqueConstraint;
+
+const unresolved = (hints: HintsHandler) => hints.missingHints;
+
+const createDb = (responder: (sql: string) => Promise<unknown[]> | unknown[]) => {
+	const queries: string[] = [];
+	const db: DB = {
+		query: async <T>(sql: string) => {
+			queries.push(sql);
+			const rows = await responder(sql);
+			return rows as T[];
+		},
+	};
+
+	return { db, queries };
+};
+
+const runPushDiff = async (
+	ddlFrom: ReturnType<typeof createDDL>,
+	ddlTo: ReturnType<typeof createDDL>,
+	hintsInput?: readonly Hint[],
+) => {
+	const hints = new HintsHandler(hintsInput ?? []);
+
+	const diffResult = await ddlDiff(
+		ddlFrom,
+		ddlTo,
+		resolver<Schema>('schema', hints),
+		resolver<Enum>('enum', hints),
+		resolver<Sequence>('sequence', hints),
+		resolver<Policy>('policy', hints),
+		resolver<Role>('role', hints),
+		resolver<Privilege>('privilege', hints),
+		resolver<PostgresEntities['tables']>('table', hints),
+		resolver<Column>('column', hints),
+		resolver<View>('view', hints),
+		resolver<UniqueConstraint>('unique', hints),
+		resolver<Index>('index', hints),
+		resolver<CheckConstraint>('check', hints),
+		resolver<PrimaryKey>('primary_key', hints),
+		resolver<ForeignKey>('foreign key', hints),
+		'push',
+	);
+
+	return { ...diffResult, hints };
+};
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+test('json mode skips the drop-table probe when a confirm hint already authorizes it', async () => {
+	await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const hints = new HintsHandler([
+			{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'orders'] as const },
+		]);
+
+		const { db, queries } = createDb(async (sql) => {
+			throw new Error(`probe should have been skipped: ${sql}`);
+		});
+
+		const result = await suggestions(db, [
+			prepareStatement('drop_table', { table: table('orders'), key: '"orders"' }),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual([]);
+		expect(unresolved(hints)).toStrictEqual([]);
+	});
+});
+
+test('json mode auto-authorizes an empty materialized-view probe without recording a missing confirm hint', async () => {
+	await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const hints = new HintsHandler();
+		const { db, queries } = createDb(async () => []);
+
+		const result = await suggestions(db, [
+			prepareStatement('drop_view', { view: view('orders_mv'), cause: null }),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual(['select 1 from "orders_mv" limit 1']);
+		expect(unresolved(hints)).toStrictEqual([]);
+	});
+});
+
+test('json mode neither probes nor records a confirm for an add_not_null column', async () => {
+	await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const hints = new HintsHandler();
+		const { db, queries } = createDb(async () => [{}]);
+
+		const result = await suggestions(db, [
+			prepareStatement('add_column', {
+				column: column('orders', 'status', 'public', { notNull: true }),
+				isPK: false,
+				isCompositePK: false,
+			}),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual([]);
+		expect(unresolved(hints)).toStrictEqual([]);
+	});
+});
+
+test('text mode under non-TTY records a drop-table confirm_data_loss missing hint instead of prose', async () => {
+	await runWithCliContext({ output: 'text', interactive: false }, async () => {
+		const hints = new HintsHandler();
+		const { db, queries } = createDb(async () => [{}]);
+
+		const result = await suggestions(db, [
+			prepareStatement('drop_table', { table: table('orders'), key: '"orders"' }),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual(['select 1 from "orders" limit 1']);
+		expect(unresolved(hints)).toStrictEqual([
+			{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'orders'], reason: 'non_empty' },
+		]);
+	});
+});
+
+test('text mode under non-TTY neither probes nor warns for an add_not_null column', async () => {
+	await runWithCliContext({ output: 'text', interactive: false }, async () => {
+		const hints = new HintsHandler();
+		const { db, queries } = createDb(async () => [{}]);
+
+		const result = await suggestions(db, [
+			prepareStatement('add_column', {
+				column: column('orders', 'status', 'public', { notNull: true }),
+				isPK: false,
+				isCompositePK: false,
+			}),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual([]);
+		expect(unresolved(hints)).toStrictEqual([]);
+	});
+});
+
+test('json mode records only the risky probe sites when multiple probes have mixed outcomes', async () => {
+	await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const hints = new HintsHandler();
+		const { db, queries } = createDb(async (sql) => {
+			if (sql.includes(`table_schema = 'archive'`)) {
+				return [{ count: '2' }];
+			}
+
+			if (sql === 'select 1 from "legacy_users" limit 1') {
+				return [];
+			}
+
+			throw new Error(`Unexpected SQL: ${sql}`);
+		});
+
+		const result = await suggestions(db, [
+			prepareStatement('drop_schema', { name: 'archive' }),
+			prepareStatement('drop_column', { column: column('legacy_users', 'legacy_flag') }),
+			prepareStatement('add_unique', { unique: unique('users', 'users_email_unique', 'email') }),
+		], hints);
+
+		expect(result).toStrictEqual([]);
+		expect(queries).toStrictEqual([
+			`select count(*) as count from information_schema.tables where table_schema = 'archive';`,
+			'select 1 from "legacy_users" limit 1',
+		]);
+		expect(unresolved(hints)).toStrictEqual([
+			{ type: 'confirm_data_loss', kind: 'schema', entity: ['archive'], reason: 'non_empty' },
+		]);
+	});
+});
+
+test('tty mode keeps the existing drop-pk hint path, including the constraint-name lookup statement', async () => {
+	await runWithCliContext({ output: 'text', interactive: true }, async () => {
+		const hintsHandler = new HintsHandler();
+		const { db, queries } = createDb(async (sql) => {
+			if (sql === 'select 1 from "public"."orders" limit 1') {
+				return [{}];
+			}
+
+			if (sql.includes('information_schema.table_constraints')) {
+				return [{ name: 'orders_actual_pkey' }];
+			}
+
+			throw new Error(`Unexpected SQL: ${sql}`);
+		});
+
+		const hints = await suggestions(db, [
+			prepareStatement('drop_pk', { pk: primaryKey('orders', 'orders_pkey', 'public', false) }),
+		], hintsHandler);
+
+		expect(queries).toStrictEqual([
+			'select 1 from "public"."orders" limit 1',
+			`\n        SELECT constraint_name as name \n        FROM information_schema.table_constraints\n        WHERE \n          table_schema = 'public'\n          AND table_name = 'orders'\n          AND constraint_type = 'PRIMARY KEY';`,
+		]);
+		expect(hints).toHaveLength(1);
+		expect(stripAnsi(hints[0]!.hint).replace(/^·\s*/, '')).toBe(
+			'You\'re about to drop "public"."orders" primary key, this statements may fail and your table may lose primary key',
+		);
+		expect(hints[0]!.statement).toBe('ALTER TABLE "public"."orders" DROP CONSTRAINT "orders_actual_pkey"');
+	});
+});
+
+test('rename hints resolve orders to orders1 before probes so no stale orders1 select is attempted', async () => {
+	await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const hintsInput = [
+			{ type: 'rename', kind: 'table', from: ['public', 'orders'] as const, to: ['public', 'orders1'] as const },
+		] satisfies readonly Hint[];
+
+		const ddlFrom = createDDL();
+		ddlFrom.tables.push({ schema: 'public', name: 'orders', isRlsEnabled: false });
+
+		const ddlTo = createDDL();
+		ddlTo.tables.push({ schema: 'public', name: 'orders1', isRlsEnabled: false });
+
+		const diffResult = await runPushDiff(ddlFrom, ddlTo, hintsInput);
+		const statementTypes = diffResult.statements.map((statement) => statement.type);
+
+		expect(statementTypes).toContain('rename_table');
+		expect(statementTypes).not.toContain('drop_table');
+		expect(statementTypes).not.toContain('create_table');
+		expect(unresolved(diffResult.hints)).toStrictEqual([]);
+
+		const { db, queries } = createDb(async (sql) => {
+			throw new Error(`rename-resolved diffs should not probe the database: ${sql}`);
+		});
+
+		const suggestionHints = new HintsHandler(hintsInput);
+		const hints = await suggestions(db, diffResult.statements, suggestionHints);
+
+		expect(hints).toStrictEqual([]);
+		expect(queries).toStrictEqual([]);
+		expect(unresolved(suggestionHints)).toStrictEqual([]);
+	});
+});
diff --git a/drizzle-kit/tests/other/hints-resolver.test.ts b/drizzle-kit/tests/other/hints-resolver.test.ts
new file mode 100644
index 0000000000..3a6f5aa75c
--- /dev/null
+++ b/drizzle-kit/tests/other/hints-resolver.test.ts
@@ -0,0 +1,259 @@
+import { runWithCliContext } from 'src/cli/context';
+import { type Hint, HintsHandler } from 'src/cli/hints';
+import { resolver } from 'src/cli/prompts';
+import { expect, test } from 'vitest';
+
+type Entity = {
+	name: string;
+	schema?: string;
+	table?: string;
+	grantor?: string;
+	grantee?: string;
+	type?: string;
+};
+
+const table = (name: string, schema?: string): Entity => ({ name, schema });
+const constraint = (tableName: string, name: string, schema?: string): Entity => ({
+	name,
+	table: tableName,
+	schema,
+});
+
+const runTableResolver = async (
+	hints: readonly Hint[],
+	input: { created: Entity[]; deleted: Entity[] },
+) => {
+	return runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const handler = new HintsHandler(hints);
+		const resolve = resolver<Entity>('table', handler);
+		return { handler, result: await resolve(input) };
+	});
+};
+
+test('resolver applies a matching rename hint and removes both sides from the diff', async () => {
+	const created = table('members', 'public');
+	const deleted = table('users', 'public');
+	const { handler, result } = await runTableResolver(
+		[
+			{ type: 'rename', kind: 'table', from: ['public', 'users'] as const, to: ['public', 'members'] as const },
+		],
+		{ created: [created], deleted: [deleted] },
+	);
+
+	expect(result).toStrictEqual({
+		created: [],
+		deleted: [],
+		renamedOrMoved: [{ from: deleted, to: created }],
+	});
+	expect(handler.missingHints).toStrictEqual([]);
+});
+
+test('resolver keeps an entity in created when a matching create hint exists', async () => {
+	const created = table('members', 'public');
+	const deleted = table('users', 'public');
+	const { handler, result } = await runTableResolver(
+		[
+			{ type: 'create', kind: 'table', entity: ['public', 'members'] as const },
+		],
+		{ created: [created], deleted: [deleted] },
+	);
+
+	expect(result).toStrictEqual({
+		created: [created],
+		deleted: [deleted],
+		renamedOrMoved: [],
+	});
+	expect(handler.missingHints).toStrictEqual([]);
+});
+
+test('resolver records a missing hint and keeps both entities when no hint matches an ambiguity', async () => {
+	const { hints, result } = await runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const created = table('members', 'public');
+		const deleted = table('users', 'public');
+		const hints = new HintsHandler();
+		const resolve = resolver<Entity>('table', hints);
+		const result = await resolve({ created: [created], deleted: [deleted] });
+
+		return { hints, result };
+	});
+
+	expect(result).toStrictEqual({
+		created: [table('members', 'public')],
+		deleted: [table('users', 'public')],
+		renamedOrMoved: [],
+	});
+	expect(hints.toResponse()).toStrictEqual({
+		status: 'missing_hints',
+		unresolved: [{ type: 'rename_or_create', kind: 'table', entity: ['public', 'members'] }],
+	});
+});
+
+test('resolver ignores excess hints that do not correspond to the diff', async () => {
+	const created = table('members', 'public');
+	const { handler, result } = await runTableResolver(
+		[
+			{ type: 'rename', kind: 'table', from: ['public', 'ghost_old'] as const, to: ['public', 'ghost_new'] as const },
+		],
+		{ created: [created], deleted: [] },
+	);
+
+	expect(result).toStrictEqual({
+		created: [created],
+		deleted: [],
+		renamedOrMoved: [],
+	});
+	expect(handler.missingHints).toStrictEqual([]);
+});
+
+test('resolver prefers a rename hint over a create hint for the same entity', async () => {
+	const created = table('members', 'public');
+	const deleted = table('users', 'public');
+	const { result } = await runTableResolver(
+		[
+			{ type: 'create', kind: 'table', entity: ['public', 'members'] as const },
+			{ type: 'rename', kind: 'table', from: ['public', 'users'] as const, to: ['public', 'members'] as const },
+		],
+		{ created: [created], deleted: [deleted] },
+	);
+
+	expect(result).toStrictEqual({
+		created: [],
+		deleted: [],
+		renamedOrMoved: [{ from: deleted, to: created }],
+	});
+});
+
+test('resolver matches hints against the default schema when entity schema is omitted', async () => {
+	const created = table('members');
+	const deleted = table('users');
+	const { result } = await runTableResolver(
+		[
+			{ type: 'rename', kind: 'table', from: ['public', 'users'] as const, to: ['public', 'members'] as const },
+		],
+		{ created: [created], deleted: [deleted] },
+	);
+
+	expect(result).toStrictEqual({
+		created: [],
+		deleted: [],
+		renamedOrMoved: [{ from: deleted, to: created }],
+	});
+});
+
+test('resolver matches primary key entity types against primary key hints', async () => {
+	const { created, deleted, hints, result } = await runWithCliContext(
+		{ output: 'json', interactive: false },
+		async () => {
+			const created = constraint('users', 'members_pkey', 'public');
+			const deleted = constraint('users', 'users_pkey', 'public');
+			const hints = new HintsHandler([
+				{
+					type: 'rename',
+					kind: 'primary_key',
+					from: ['public', 'users', 'users_pkey'] as const,
+					to: ['public', 'users', 'members_pkey'] as const,
+				},
+			]);
+			const resolve = resolver<Entity>('primary_key', hints);
+
+			return {
+				created,
+				deleted,
+				hints,
+				result: await resolve({ created: [created], deleted: [deleted] }),
+			};
+		},
+	);
+
+	expect(result).toStrictEqual({
+		created: [],
+		deleted: [],
+		renamedOrMoved: [{ from: deleted, to: created }],
+	});
+	expect(hints.missingHints).toStrictEqual([]);
+});
+
+test('resolver matches default entity types against default hints', async () => {
+	const { created, deleted, hints, result } = await runWithCliContext(
+		{ output: 'json', interactive: false },
+		async () => {
+			const created = constraint('users', 'members_default', 'dbo');
+			const deleted = constraint('users', 'users_default', 'dbo');
+			const hints = new HintsHandler([
+				{
+					type: 'rename',
+					kind: 'default',
+					from: ['dbo', 'users', 'users_default'] as const,
+					to: ['dbo', 'users', 'members_default'] as const,
+				},
+			]);
+			const resolve = resolver<Entity>('default', hints, 'dbo');
+
+			return {
+				created,
+				deleted,
+				hints,
+				result: await resolve({ created: [created], deleted: [deleted] }),
+			};
+		},
+	);
+
+	expect(result).toStrictEqual({
+		created: [],
+		deleted: [],
+		renamedOrMoved: [{ from: deleted, to: created }],
+	});
+	expect(hints.missingHints).toStrictEqual([]);
+});
+
+test('resolver treats missing HintsHandler in non-interactive mode as an internal invariant failure', async () => {
+	await expect(runWithCliContext({ output: 'json', interactive: false }, async () => {
+		const resolve = resolver<Entity>('table');
+
+		return resolve({
+			created: [table('members', 'public')],
+			deleted: [table('users', 'public')],
+		});
+	})).rejects.toThrow('Internal error: resolver(table) was called without a HintsHandler');
+});
+
+test('resolver returns only newly added unresolved items when reusing a HintsHandler', async () => {
+	const { hints, tableDelta, columnDelta } = await runWithCliContext(
+		{ output: 'json', interactive: false },
+		async () => {
+			const hints = new HintsHandler();
+			hints.pushMissingHint({ type: 'rename_or_create', kind: 'table', entity: ['public', 'existing'] });
+
+			const resolveTables = resolver<Entity>('table', hints);
+			const resolveColumns = resolver<Entity>('column', hints);
+
+			const beforeTable = hints.missingHints.length;
+			await resolveTables({
+				created: [table('members', 'public')],
+				deleted: [table('users', 'public')],
+			});
+			const tableDelta = hints.missingHints.slice(beforeTable);
+
+			const beforeColumn = hints.missingHints.length;
+			await resolveColumns({
+				created: [{ name: 'email', table: 'users', schema: 'public' }],
+				deleted: [{ name: 'name', table: 'users', schema: 'public' }],
+			});
+			const columnDelta = hints.missingHints.slice(beforeColumn);
+
+			return { hints, tableDelta, columnDelta };
+		},
+	);
+
+	expect(tableDelta).toStrictEqual([
+		{ type: 'rename_or_create', kind: 'table', entity: ['public', 'members'] },
+	]);
+	expect(columnDelta).toStrictEqual([
+		{ type: 'rename_or_create', kind: 'column', entity: ['public', 'users', 'email'] },
+	]);
+	expect(hints.missingHints).toStrictEqual([
+		{ type: 'rename_or_create', kind: 'table', entity: ['public', 'existing'] },
+		{ type: 'rename_or_create', kind: 'table', entity: ['public', 'members'] },
+		{ type: 'rename_or_create', kind: 'column', entity: ['public', 'users', 'email'] },
+	]);
+});
diff --git a/drizzle-kit/tests/other/load-module.test.ts b/drizzle-kit/tests/other/load-module.test.ts
new file mode 100644
index 0000000000..8eb2293e49
--- /dev/null
+++ b/drizzle-kit/tests/other/load-module.test.ts
@@ -0,0 +1,11 @@
+import { resolve } from 'path';
+import { expect, test } from 'vitest';
+import { loadModule } from '../../src/utils/utils-node';
+
+test('loadModule resolves tsconfig paths', async () => {
+	const modulePath = resolve('tests/fixtures/tsconfig-paths/entry.ts');
+	const mod = await loadModule<{ profile?: unknown; user?: unknown }>(modulePath);
+
+	expect(mod.profile).toBeDefined();
+	expect(mod.user).toBeDefined();
+});
diff --git a/drizzle-kit/tests/other/mcp-fixtures.ts b/drizzle-kit/tests/other/mcp-fixtures.ts
new file mode 100644
index 0000000000..716bf597d7
--- /dev/null
+++ b/drizzle-kit/tests/other/mcp-fixtures.ts
@@ -0,0 +1,78 @@
+import { integer, pgTable } from 'drizzle-orm/pg-core';
+import { writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { makePgSnapshot, ORIGIN, stageOut, writeSnapshot } from './check-fixtures';
+
+export { ORIGIN, stageConflict, stageOut, stageValid } from './check-fixtures';
+
+/**
+ * Stages a generate missing_hints scenario without a live database.
+ *
+ * Writes a postgres snapshot declaring table `users`, then writes a schema file
+ * declaring table `accounts`. Calling `generate({ dialect:'postgresql', schema, out })`
+ * on the returned paths causes the rename-detection logic to surface
+ * `{ type:'rename_or_create', kind:'table', entity:['public','accounts'] }` with no
+ * hints provided — purely filesystem-based, no Docker required.
+ */
+export const stageGenerateMissingHints = (): { out: string; schemaPath: string } => {
+	const out = stageOut();
+
+	writeSnapshot(
+		out,
+		'0000_init',
+		makePgSnapshot('p1', [ORIGIN], { users: pgTable('users', { id: integer('id') }) }),
+	);
+
+	const schemaPath = resolve(join(out, 'schema.ts'));
+	writeFileSync(
+		schemaPath,
+		[
+			"import { integer, pgTable } from 'drizzle-orm/pg-core';",
+			'',
+			"export const accounts = pgTable('accounts', { id: integer('id') });",
+		].join('\n'),
+	);
+
+	return { out, schemaPath };
+};
+
+/**
+ * Writes a drizzle.config.ts that targets pull at an unreachable postgres URL. Pull introspects
+ * the live DB, so no schema file is needed — it fails at the DB driver level.
+ */
+export const writeUnreachablePullConfig = (out: string): { configPath: string } => {
+	const configPath = resolve(join(out, 'drizzle-unreachable-pull.config.ts'));
+	writeFileSync(
+		configPath,
+		[
+			'export default {',
+			"  dialect: 'postgresql',",
+			`  out: ${JSON.stringify(out)},`,
+			`  dbCredentials: { url: 'postgresql://user:pw@127.0.0.1:1/none' },`,
+			'};',
+		].join('\n'),
+	);
+	return { configPath };
+};
+
+/**
+ * Writes a minimal drizzle.config.ts pointing at the staged out folder (and optionally a schema file).
+ * Uses a plain export default object (no `defineConfig` import) so jiti can load it without a built dist.
+ */
+export const writeDrizzleConfig = (out: string, schemaPath?: string): string => {
+	const configPath = resolve(join(out, 'drizzle.config.ts'));
+	const schemaLine = schemaPath
+		? `  schema: ${JSON.stringify(schemaPath)},`
+		: "  schema: './schema.ts',";
+	writeFileSync(
+		configPath,
+		[
+			'export default {',
+			"  dialect: 'postgresql',",
+			schemaLine,
+			`  out: ${JSON.stringify(out)},`,
+			'};',
+		].join('\n'),
+	);
+	return configPath;
+};
diff --git a/drizzle-kit/tests/other/mcp-server.test.ts b/drizzle-kit/tests/other/mcp-server.test.ts
new file mode 100644
index 0000000000..3ac0cf1f80
--- /dev/null
+++ b/drizzle-kit/tests/other/mcp-server.test.ts
@@ -0,0 +1,240 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { rmSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { afterAll, afterEach, describe, expect, test, vi } from 'vitest';
+import { createDrizzleMcpServer } from '../../src/mcp/server.js';
+import {
+	stageConflict,
+	stageGenerateMissingHints,
+	stageOut,
+	stageValid,
+	writeDrizzleConfig,
+	writeUnreachablePullConfig,
+} from './mcp-fixtures';
+import { stageUpNonLatest } from './up-fixtures';
+
+// The `pnpm test` script sets TEST_CONFIG_PATH_PREFIX=./tests/cli/ for the whole run.
+// Absolute schema paths in the MCP fixtures are broken by that prefix, so unset it for this file.
+const originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+delete process.env.TEST_CONFIG_PATH_PREFIX;
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+afterAll(() => {
+	if (originalPrefix !== undefined) {
+		process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+	}
+});
+
+/** Connect a fresh createDrizzleMcpServer() and Client over InMemoryTransport. Returns client and a teardown fn. */
+const connectPair = async () => {
+	const server = createDrizzleMcpServer();
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+	const client = new Client({ name: 'test-client', version: '0' });
+	await server.connect(serverTransport);
+	await client.connect(clientTransport);
+	return { client, server };
+};
+
+describe('MCP server tool registration', () => {
+	test('listTools returns exactly check, export, generate, pull, push, up', async () => {
+		const { client } = await connectPair();
+		const { tools } = await client.listTools();
+		expect(tools.map((t) => t.name).sort()).toEqual(['check', 'export', 'generate', 'pull', 'push', 'up']);
+		await client.close();
+	});
+});
+
+describe('MCP server pull tool — per-call destructive _meta escalation', () => {
+	test('init:true sets the destructive _meta signal; omitting init does not (signal derives from input)', async () => {
+		const { client } = await connectPair();
+		const out = stageOut();
+		// The signal derives from the input, so the unreachable config (no live DB) is enough.
+		const { configPath } = writeUnreachablePullConfig(out);
+		try {
+			const r1 = await client.callTool({ name: 'pull', arguments: { config: configPath } });
+			expect((r1._meta ?? {})['com.drizzle.team/pull.destructiveHint']).toBeFalsy();
+
+			const r2 = await client.callTool({ name: 'pull', arguments: { config: configPath, init: true } });
+			expect(r2._meta?.['com.drizzle.team/pull.destructiveHint']).toBe(true);
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+});
+
+describe('MCP server check tool', () => {
+	test('check against stageValid returns isError:false and status:ok in both channels', async () => {
+		const { client } = await connectPair();
+		const out = stageValid();
+		const config = writeDrizzleConfig(out);
+		try {
+			const result = await client.callTool({ name: 'check', arguments: { config } });
+			expect(result.isError).toBe(false);
+			expect(result.structuredContent).toMatchObject({ status: 'ok' });
+			const textBlock = (result.content as any[]).find((c) => c.type === 'text');
+			expect(textBlock).toBeDefined();
+			const parsed = JSON.parse(textBlock.text);
+			expect(parsed).toMatchObject({ status: 'ok' });
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+
+	test('check against stageConflict resolves to isError:true and status:error rather than rejecting', async () => {
+		const { client } = await connectPair();
+		const out = stageConflict();
+		const config = writeDrizzleConfig(out);
+		try {
+			const result = await client.callTool({ name: 'check', arguments: { config } });
+			expect(result.isError).toBe(true);
+			expect(result.structuredContent).toMatchObject({ status: 'error' });
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+});
+
+describe('MCP server export tool', () => {
+	test('export against a valid schema returns isError:false and status:ok in both channels', async () => {
+		const { client } = await connectPair();
+		const out = stageOut();
+		const schemaPath = resolve(join(out, 'schema.ts'));
+		writeFileSync(
+			schemaPath,
+			"import { integer, pgTable } from 'drizzle-orm/pg-core';\nexport const t = pgTable('t', { id: integer('id') });\n",
+		);
+		const config = writeDrizzleConfig(out, schemaPath);
+		try {
+			const result = await client.callTool({ name: 'export', arguments: { config } });
+			expect(result.isError).toBe(false);
+			expect(result.structuredContent).toMatchObject({ status: 'ok' });
+			const textBlock = (result.content as any[]).find((c) => c.type === 'text');
+			expect(textBlock).toBeDefined();
+			const parsed = JSON.parse(textBlock.text);
+			expect(parsed).toMatchObject({ status: 'ok' });
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+});
+
+describe('MCP server up tool', () => {
+	test('up against a non-latest snapshot returns isError:false and status:ok with non-empty upgraded[]', async () => {
+		const { client } = await connectPair();
+		const out = stageUpNonLatest();
+		// up reads snapshots, not the schema — the default schema line is never consulted.
+		const config = writeDrizzleConfig(out);
+		try {
+			const result = await client.callTool({ name: 'up', arguments: { config } });
+			expect(result.isError).toBe(false);
+			expect(result.structuredContent).toMatchObject({ status: 'ok' });
+			const textBlock = (result.content as any[]).find((c) => c.type === 'text');
+			expect(textBlock).toBeDefined();
+			const parsed = JSON.parse(textBlock.text);
+			expect(parsed).toMatchObject({ status: 'ok' });
+			const sc = result.structuredContent as any;
+			expect(Array.isArray(sc.upgraded)).toBe(true);
+			expect(sc.upgraded.length).toBeGreaterThan(0);
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+});
+
+describe('MCP server generate tool — missing_hints round-trip', () => {
+	test('generate without hints returns isError:true with status:missing_hints and non-empty unresolved[]', async () => {
+		const { client } = await connectPair();
+		const { out, schemaPath } = stageGenerateMissingHints();
+		const config = writeDrizzleConfig(out, schemaPath);
+		try {
+			const result = await client.callTool({ name: 'generate', arguments: { config } });
+			expect(result.isError).toBe(true);
+			expect(result.structuredContent).toMatchObject({ status: 'missing_hints' });
+			const sc = result.structuredContent as any;
+			expect(Array.isArray(sc.unresolved)).toBe(true);
+			expect(sc.unresolved.length).toBeGreaterThan(0);
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+
+	test('generate with resolving hints returns isError:false', async () => {
+		const { client } = await connectPair();
+		const { out, schemaPath } = stageGenerateMissingHints();
+		const config = writeDrizzleConfig(out, schemaPath);
+		try {
+			// First call: get unresolved items
+			const first = await client.callTool({ name: 'generate', arguments: { config } });
+			expect(first.isError).toBe(true);
+			const sc = first.structuredContent as any;
+			expect(sc.status).toBe('missing_hints');
+
+			// Resolve each rename_or_create as 'create' so no rename hint is needed
+			const hints = sc.unresolved
+				.filter((u: any) => u.type === 'rename_or_create')
+				.map((u: any) => ({ type: 'create' as const, kind: u.kind, entity: u.entity }));
+
+			const second = await client.callTool({ name: 'generate', arguments: { config, hints } });
+			expect(second.isError).toBe(false);
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+
+	test('generate with a malformed hint returns an invalid_hints envelope, not a protocol error', async () => {
+		const { client } = await connectPair();
+		const { out, schemaPath } = stageGenerateMissingHints();
+		const config = writeDrizzleConfig(out, schemaPath);
+		try {
+			// A hint with an unknown `type` fails hintSchema parsing. The loose tool input schema
+			// lets it through to the SDK, which must surface it as an `invalid_hints` envelope
+			// (isError:true) rather than the MCP layer rejecting the call as InvalidParams.
+			const result = await client.callTool({
+				name: 'generate',
+				arguments: { config, hints: [{ type: 'not_a_real_hint' }] },
+			});
+			expect(result.isError).toBe(true);
+			expect(result.structuredContent).toMatchObject({ status: 'error', error: { code: 'invalid_hints' } });
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+	});
+});
+
+describe('MCP server stdout purity (in-process)', () => {
+	test('tool call does not write to process.stdout', async () => {
+		const stdoutCalls: unknown[][] = [];
+		const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(
+			((...args: unknown[]) => {
+				stdoutCalls.push(args);
+				return true;
+			}) as unknown as typeof process.stdout.write,
+		);
+
+		const { client } = await connectPair();
+		const out = stageValid();
+		const config = writeDrizzleConfig(out);
+		try {
+			await client.callTool({ name: 'check', arguments: { config } });
+		} finally {
+			await client.close();
+			rmSync(out, { recursive: true, force: true });
+		}
+
+		// Assert captured array AFTER mockRestore (spy.calls is cleared by restore)
+		stdoutSpy.mockRestore();
+		expect(stdoutCalls.map((c) => String(c[0]).slice(0, 200))).toEqual([]);
+	});
+});
diff --git a/drizzle-kit/tests/other/mcp-stdio-smoke.test.ts b/drizzle-kit/tests/other/mcp-stdio-smoke.test.ts
new file mode 100644
index 0000000000..af978a4703
--- /dev/null
+++ b/drizzle-kit/tests/other/mcp-stdio-smoke.test.ts
@@ -0,0 +1,62 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { beforeAll, describe, expect, test } from 'vitest';
+
+const binPath = resolve(process.cwd(), 'dist', 'bin.cjs');
+const skipDistTests = process.env.DRIZZLE_KIT_SKIP_DIST_TESTS === '1';
+const missingDist = !existsSync(binPath);
+const skipForMissingDist = !skipDistTests && missingDist;
+
+if (skipForMissingDist && !process.env.CI) {
+	// eslint-disable-next-line no-console
+	console.warn(
+		`[stdio-smoke] skipping: dist/bin.cjs is not built. `
+			+ `Run \`pnpm --filter drizzle-kit build\` to enable this smoke test, `
+			+ `or set DRIZZLE_KIT_SKIP_DIST_TESTS=1 to silence this warning.`,
+	);
+}
+
+describe('drizzle-kit mcp stdio smoke', () => {
+	beforeAll(() => {
+		if (skipForMissingDist && process.env.CI) {
+			throw new Error(
+				`stdio-smoke requires a built dist/bin.cjs. Run \`pnpm --filter drizzle-kit build\` first.`,
+			);
+		}
+	});
+
+	test.skipIf(skipDistTests || skipForMissingDist)(
+		'spawned drizzle-kit mcp connects, lists check/export/generate/pull/push/up tools, and prints version to stderr',
+		async () => {
+			const stderrChunks: Buffer[] = [];
+
+			const transport = new StdioClientTransport({
+				command: 'node',
+				args: [binPath, 'mcp'],
+				stderr: 'pipe',
+			});
+
+			// Capture stderr for version banner assertion
+			transport.stderr?.on('data', (chunk: Buffer) => {
+				stderrChunks.push(chunk);
+			});
+
+			const client = new Client({ name: 'smoke-client', version: '0' });
+
+			// Any stdout corruption would throw a JSON-RPC parse error during connect
+			await client.connect(transport);
+
+			const { tools } = await client.listTools();
+			expect(tools.map((t) => t.name).sort()).toEqual(['check', 'export', 'generate', 'pull', 'push', 'up']);
+
+			await client.close();
+
+			const stderr = Buffer.concat(stderrChunks).toString('utf8');
+			// server prints a version banner to stderr at startup
+			expect(stderr).toMatch(/drizzle-kit\s+mcp\s+v\d/i);
+		},
+		30_000,
+	);
+});
diff --git a/drizzle-kit/tests/other/missing-hints-report.test.ts b/drizzle-kit/tests/other/missing-hints-report.test.ts
new file mode 100644
index 0000000000..a8f2cc6e32
--- /dev/null
+++ b/drizzle-kit/tests/other/missing-hints-report.test.ts
@@ -0,0 +1,189 @@
+import { stripAnsi } from 'hanji/utils';
+import type { MissingHint, MissingHintsResponse } from 'src/cli/hints';
+import { formatMissingHintsText } from 'src/cli/missing-hints-report';
+import { describe, expect, test } from 'vitest';
+
+const strip = (s: string) => stripAnsi(s);
+
+const responseOf = (...unresolved: MissingHint[]): MissingHintsResponse => ({
+	status: 'missing_hints',
+	unresolved,
+});
+
+describe('formatMissingHintsText', () => {
+	test('empty unresolved array — header reads `missing_hints: 0 unresolved decisions` and footer is present', () => {
+		const out = formatMissingHintsText(responseOf());
+		const stripped = strip(out);
+
+		expect(stripped).toContain('missing_hints: 0 unresolved decisions');
+		expect(stripped).toContain(`Re-run with --hints '<json-array>'. Exit code 2.`);
+		// No item lines at all
+		expect(stripped).not.toMatch(/^\s*1\./m);
+	});
+
+	test('single rename_or_create with a 2-tuple table entity emits the locked layout', () => {
+		const out = formatMissingHintsText(
+			responseOf({ type: 'rename_or_create', kind: 'table', entity: ['public', 'users_v2'] }),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toContain('missing_hints: 1 unresolved decisions');
+		expect(stripped).toMatch(/1\. Rename or create\s+—\s+table\s+public\.users_v2/);
+		expect(stripped).toContain('Add to --hints:');
+		expect(stripped).toContain(
+			`{ "type": "rename", "kind": "table", "from": ["<schema>", "<old_name>"], "to": ["public", "users_v2"] }`,
+		);
+		expect(stripped).toContain('OR');
+		expect(stripped).toContain(`{ "type": "create", "kind": "table", "entity": ["public", "users_v2"] }`);
+		expect(stripped).toContain(`Re-run with --hints '<json-array>'. Exit code 2.`);
+	});
+
+	test('single rename_or_create with a 1-tuple schema entity uses a 1-segment `from` placeholder', () => {
+		const out = formatMissingHintsText(
+			responseOf({ type: 'rename_or_create', kind: 'schema', entity: ['marketing'] }),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toMatch(/1\. Rename or create\s+—\s+schema\s+marketing/);
+		expect(stripped).toContain(`"from": ["<old_name>"]`);
+		expect(stripped).toContain(`"to": ["marketing"]`);
+		expect(stripped).toContain(`{ "type": "create", "kind": "schema", "entity": ["marketing"] }`);
+	});
+
+	test('single rename_or_create with a 3-tuple column entity uses a 3-segment `from` placeholder', () => {
+		const out = formatMissingHintsText(
+			responseOf({ type: 'rename_or_create', kind: 'column', entity: ['public', 'users', 'email_v2'] }),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toMatch(/1\. Rename or create\s+—\s+column\s+public\.users\.email_v2/);
+		expect(stripped).toContain(`"from": ["<schema>", "<table>", "<old_name>"]`);
+		expect(stripped).toContain(`"to": ["public", "users", "email_v2"]`);
+	});
+
+	test('confirm_data_loss with reason `non_empty` conveys the entity and a human non-empty reason, no rename alternative', () => {
+		const out = formatMissingHintsText(
+			responseOf({
+				type: 'confirm_data_loss',
+				kind: 'table',
+				entity: ['public', 'legacy_audit'],
+				reason: 'non_empty',
+			}),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toContain('missing_hints: 1 unresolved decisions');
+		expect(stripped).toMatch(/1\. Confirm data loss\s+—\s+table\s+public\.legacy_audit/);
+		expect(stripped).toContain('public.legacy_audit');
+		expect(stripped).toMatch(/non-empty table/);
+		expect(stripped).toContain(
+			`{ "type": "confirm_data_loss", "kind": "table", "entity": ["public", "legacy_audit"] }`,
+		);
+		// No rename alternative is rendered for confirm_data_loss
+		expect(stripped).not.toContain('"type": "rename"');
+		expect(stripped).not.toMatch(/^\s+OR\s*$/m);
+	});
+
+	test('confirm_data_loss with reason `table_recreate` conveys the entity and a human table-recreate reason', () => {
+		const out = formatMissingHintsText(
+			responseOf({
+				type: 'confirm_data_loss',
+				kind: 'add_not_null',
+				entity: ['public', 'users', 'status'],
+				reason: 'table_recreate',
+			}),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toMatch(/1\. Confirm data loss\s+—\s+add not null\s+public\.users\.status/);
+		expect(stripped).toContain('public.users.status');
+		expect(stripped).toMatch(/wipes all rows and recreates the table/i);
+		expect(stripped).toContain(
+			`{ "type": "confirm_data_loss", "kind": "add_not_null", "entity": ["public", "users", "status"] }`,
+		);
+	});
+
+	test('confirm_data_loss with reason `type_change` conveys the entity and the from/to types', () => {
+		const out = formatMissingHintsText(
+			responseOf({
+				type: 'confirm_data_loss',
+				kind: 'column',
+				entity: ['public', 'users', 'age'],
+				reason: 'type_change',
+				reason_details: { from: 'int', to: 'text' },
+			}),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toMatch(/1\. Confirm data loss\s+—\s+column\s+public\.users\.age/);
+		expect(stripped).toContain('public.users.age');
+		expect(stripped).toContain('int');
+		expect(stripped).toContain('text');
+		expect(stripped).toContain(
+			`{ "type": "confirm_data_loss", "kind": "column", "entity": ["public", "users", "age"] }`,
+		);
+	});
+
+	test('input order [confirm_data_loss, rename_or_create] still renders rename_or_create as item 1', () => {
+		const out = formatMissingHintsText(
+			responseOf(
+				{
+					type: 'confirm_data_loss',
+					kind: 'table',
+					entity: ['public', 'legacy_audit'],
+					reason: 'non_empty',
+				},
+				{ type: 'rename_or_create', kind: 'table', entity: ['public', 'users_v2'] },
+			),
+		);
+		const stripped = strip(out);
+
+		expect(stripped).toContain('missing_hints: 2 unresolved decisions');
+		const renameIdx = stripped.indexOf('1. Rename or create');
+		const confirmIdx = stripped.indexOf('2. Confirm data loss');
+		expect(renameIdx).toBeGreaterThan(-1);
+		expect(confirmIdx).toBeGreaterThan(renameIdx);
+	});
+
+	test('multiple rename_or_create entries preserve discovery order within the partition', () => {
+		const out = formatMissingHintsText(
+			responseOf(
+				{ type: 'rename_or_create', kind: 'table', entity: ['public', 'users_v2'] },
+				{ type: 'rename_or_create', kind: 'table', entity: ['public', 'orders_v2'] },
+			),
+		);
+		const stripped = strip(out);
+
+		const firstIdx = stripped.indexOf('public.users_v2');
+		const secondIdx = stripped.indexOf('public.orders_v2');
+		expect(firstIdx).toBeGreaterThan(-1);
+		expect(secondIdx).toBeGreaterThan(firstIdx);
+		expect(stripped).toMatch(/1\. Rename or create\s+—\s+table\s+public\.users_v2/);
+		expect(stripped).toMatch(/2\. Rename or create\s+—\s+table\s+public\.orders_v2/);
+	});
+
+	test('report renders header, then items in order, then footer', () => {
+		const out = formatMissingHintsText(
+			responseOf(
+				{ type: 'rename_or_create', kind: 'table', entity: ['public', 'users_v2'] },
+				{
+					type: 'confirm_data_loss',
+					kind: 'table',
+					entity: ['public', 'legacy_audit'],
+					reason: 'non_empty',
+				},
+			),
+		);
+		const stripped = strip(out);
+
+		const headerIdx = stripped.indexOf('missing_hints: 2 unresolved decisions');
+		const item1Idx = stripped.indexOf('1. Rename or create');
+		const item2Idx = stripped.indexOf('2. Confirm data loss');
+		const footerIdx = stripped.indexOf('Re-run with --hints');
+
+		expect(headerIdx).toBeGreaterThan(-1);
+		expect(item1Idx).toBeGreaterThan(headerIdx);
+		expect(item2Idx).toBeGreaterThan(item1Idx);
+		expect(footerIdx).toBeGreaterThan(item2Idx);
+	});
+});
diff --git a/drizzle-kit/tests/other/push-non-tty-guard.test.ts b/drizzle-kit/tests/other/push-non-tty-guard.test.ts
new file mode 100644
index 0000000000..84863295b9
--- /dev/null
+++ b/drizzle-kit/tests/other/push-non-tty-guard.test.ts
@@ -0,0 +1,97 @@
+import { PGlite } from '@electric-sql/pglite';
+import BetterSqlite3 from 'better-sqlite3';
+import { afterEach, expect, test, vi } from 'vitest';
+import { HintsHandler } from '../../src/cli/hints';
+import { fromExports as pgFromExports, SchemaSource as PgSchemaSource } from '../../src/dialects/postgres/drizzle';
+import {
+	fromExports as sqliteFromExports,
+	SchemaSource as SqliteSchemaSource,
+} from '../../src/dialects/sqlite/drizzle';
+
+const runWithCliContext = async <T>(
+	context: { output: 'text' | 'json'; interactive: boolean },
+	callback: () => Promise<T> | T,
+): Promise<T> => {
+	const ctx = await import('../../src/cli/context');
+	return ctx.runWithCliContext(context, callback);
+};
+
+const sqliteDbFrom = (client: BetterSqlite3.Database) => {
+	return {
+		query: async <T>(query: string, params: unknown[] = []) => {
+			return client.prepare(query).bind(...params).all() as T[];
+		},
+		run: async (query: string) => {
+			client.prepare(query).run();
+		},
+		batch: async (sqlStatements: string[]) => {
+			for (const stmt of sqlStatements) {
+				client.prepare(stmt).run();
+			}
+		},
+	};
+};
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	vi.resetModules();
+});
+
+test('push postgres under text + non-TTY resolves a non-empty drop to missing_hints instead of reaching the prompt', async () => {
+	const client = new PGlite();
+	await client.query('CREATE TABLE orders (id integer);');
+	await client.query('INSERT INTO orders (id) VALUES (1);');
+
+	const pushPostgres = await import('../../src/cli/commands/push-postgres');
+	const env = await runWithCliContext({ output: 'text', interactive: false }, () =>
+		pushPostgres.handle(
+			PgSchemaSource.fromSchema(pgFromExports({})),
+			false,
+			{ driver: 'pglite', client } as never,
+			[] as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: 'public' },
+			new HintsHandler(),
+		));
+
+	expect(env).toMatchObject({
+		status: 'missing_hints',
+		unresolved: [
+			{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'orders'], reason: 'non_empty' },
+		],
+	});
+
+	await client.close();
+});
+
+test('push sqlite under text + non-TTY resolves a non-empty drop to missing_hints instead of reaching the prompt', async () => {
+	const sqlite = new BetterSqlite3(':memory:');
+	sqlite.exec('CREATE TABLE orders (id INTEGER PRIMARY KEY);');
+	sqlite.prepare('INSERT INTO orders (id) VALUES (1)').run();
+	const db = sqliteDbFrom(sqlite);
+
+	const pushSqlite = await import('../../src/cli/commands/push-sqlite');
+	const env = await runWithCliContext({ output: 'text', interactive: false }, () =>
+		pushSqlite.handle(
+			db as never,
+			SqliteSchemaSource.fromSchema(sqliteFromExports({})),
+			false,
+			{} as never,
+			{} as never,
+			false,
+			false,
+			{ table: '__drizzle_migrations', schema: '' },
+			'sqlite',
+			new HintsHandler(),
+		));
+
+	expect(env).toMatchObject({
+		status: 'missing_hints',
+		unresolved: [
+			{ type: 'confirm_data_loss', kind: 'table', entity: ['public', 'orders'], reason: 'non_empty' },
+		],
+	});
+
+	sqlite.close();
+});
diff --git a/drizzle-kit/tests/other/sdk-md-snippets.test-d.ts b/drizzle-kit/tests/other/sdk-md-snippets.test-d.ts
new file mode 100644
index 0000000000..847fdb15e7
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-md-snippets.test-d.ts
@@ -0,0 +1,127 @@
+import { expectTypeOf, test } from 'vitest';
+import { check, exportSql, generate, pull, push, up } from '../../src/cli-sdk';
+import type { GenerateOptions, PushOptions } from '../../src/cli/contract';
+import type { Hint } from '../../src/cli/hints';
+import { defineConfig } from '../../src/index';
+import type { Config } from '../../src/index';
+
+type GenerateResponse = Awaited<ReturnType<typeof generate>>;
+type PushResponse = Awaited<ReturnType<typeof push>>;
+type CheckResponse = Awaited<ReturnType<typeof check>>;
+type PullResponse = Awaited<ReturnType<typeof pull>>;
+type UpResponse = Awaited<ReturnType<typeof up>>;
+type ExportResponse = Awaited<ReturnType<typeof exportSql>>;
+type Unresolved = Extract<GenerateResponse, { status: 'missing_hints' }>['unresolved'][number];
+
+declare const generateResponse: GenerateResponse;
+declare const pushResponse: PushResponse;
+declare const checkResponse: CheckResponse;
+declare const pullResponse: PullResponse;
+declare const upResponse: UpResponse;
+declare const exportResponse: ExportResponse;
+declare function resolveHint(item: Unresolved): Hint;
+declare const config: Config;
+
+// Compiled (so the snippets are type-checked) but never invoked at runtime, since
+// the ambient `declare`d values above have no runtime representation.
+function _generateNarrowing() {
+	if (generateResponse.status === 'ok') {
+		if ('migration_path' in generateResponse) {
+			expectTypeOf(generateResponse.migration_path).toEqualTypeOf<string>();
+		}
+	} else if (generateResponse.status === 'no_changes') {
+		expectTypeOf(generateResponse.dialect).toExtend<string | undefined>();
+	} else if (generateResponse.status === 'error') {
+		expectTypeOf(generateResponse.error.code).toBeString();
+	} else if (generateResponse.status === 'missing_hints') {
+		expectTypeOf(generateResponse.unresolved).toEqualTypeOf<readonly Unresolved[]>();
+	}
+}
+
+function _pushNarrowing() {
+	if (pushResponse.status === 'ok') {
+		expectTypeOf(pushResponse.dialect).toExtend<string | undefined>();
+	} else if (pushResponse.status === 'no_changes') {
+		expectTypeOf(pushResponse.dialect).toExtend<string | undefined>();
+	} else if (pushResponse.status === 'error') {
+		expectTypeOf(pushResponse.error.code).toBeString();
+	}
+}
+
+function _checkNarrowing() {
+	if (checkResponse.status === 'ok') {
+		expectTypeOf(checkResponse.dialect).toExtend<string | undefined>();
+	} else if (checkResponse.status === 'error') {
+		expectTypeOf(checkResponse.error.code).toBeString();
+	}
+}
+
+function _pullNarrowing() {
+	if (pullResponse.status === 'ok') {
+		expectTypeOf(pullResponse.schemaPath).toBeString();
+		expectTypeOf(pullResponse.snapshotPath).toBeString();
+	} else if (pullResponse.status === 'error') {
+		expectTypeOf(pullResponse.error.code).toBeString();
+	}
+}
+
+function _upNarrowing() {
+	if (upResponse.status === 'ok') {
+		expectTypeOf(upResponse.upgraded).toEqualTypeOf<string[]>();
+	} else if (upResponse.status === 'error') {
+		expectTypeOf(upResponse.error.code).toBeString();
+	}
+}
+
+function _exportNarrowing() {
+	if (exportResponse.status === 'ok') {
+		expectTypeOf(exportResponse.statements).toEqualTypeOf<string[]>();
+		expectTypeOf(exportResponse.warnings).toEqualTypeOf<string[]>();
+	} else if (exportResponse.status === 'error') {
+		expectTypeOf(exportResponse.error.code).toBeString();
+	}
+}
+
+async function _generateWithHints(): Promise<GenerateResponse> {
+	const baseOptions: GenerateOptions = {
+		dialect: 'postgresql',
+		schema: './src/db/schema.ts',
+		out: './drizzle',
+	};
+
+	const first: GenerateResponse = await generate(baseOptions);
+	if (first.status !== 'missing_hints') return first;
+
+	const hints = first.unresolved.map((item) => resolveHint(item));
+	expectTypeOf(hints).toEqualTypeOf<Hint[]>();
+
+	return generate({
+		...baseOptions,
+		hints,
+	});
+}
+
+function _defineConfigSnippet() {
+	const _config = defineConfig(config);
+	return _config;
+}
+
+// The narrowing snippets above are the substantive checks — they type-check at compile time.
+// Reference them so they are not flagged as unused; their bodies are what is under test.
+void [
+	_generateNarrowing,
+	_pushNarrowing,
+	_checkNarrowing,
+	_pullNarrowing,
+	_upNarrowing,
+	_exportNarrowing,
+	_defineConfigSnippet,
+];
+
+test('generateWithHints re-invokes generate with a raw Hint[]', () => {
+	expectTypeOf(_generateWithHints).returns.resolves.toEqualTypeOf<GenerateResponse>();
+});
+
+test('push options stay typed', () => {
+	expectTypeOf<PushOptions>().toExtend<{ dialect?: unknown }>();
+});
diff --git a/drizzle-kit/tests/other/sdk-no-dotenv.test.ts b/drizzle-kit/tests/other/sdk-no-dotenv.test.ts
new file mode 100644
index 0000000000..4b36757280
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-no-dotenv.test.ts
@@ -0,0 +1,63 @@
+import { spawnSync } from 'child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { resolve } from 'path';
+import { beforeAll, describe, expect, test } from 'vitest';
+
+const distMjsPath = resolve(process.cwd(), 'dist', 'index.mjs');
+const skipDistTests = process.env.DRIZZLE_KIT_SKIP_DIST_TESTS === '1';
+
+describe('Importing drizzle-kit adds zero process.env keys (no dotenv side effect)', () => {
+	beforeAll(() => {
+		// CI must always build the dist bundle before running these regressions. Local
+		// developers iterating on src/ can opt out of dist-backed tests via the env var.
+		if (!skipDistTests && !existsSync(distMjsPath)) {
+			throw new Error(
+				`no-dotenv regression requires dist/index.mjs at ${distMjsPath}. Run \`pnpm --filter drizzle-kit build\` first, `
+					+ `or set DRIZZLE_KIT_SKIP_DIST_TESTS=1 to opt out locally.`,
+			);
+		}
+	});
+
+	test.skipIf(skipDistTests)(
+		"import('drizzle-kit') from a clean child process produces zero env-key delta",
+		() => {
+			const probeDir = resolve(tmpdir(), 'drizzle-kit-no-dotenv-probe');
+			mkdirSync(probeDir, { recursive: true });
+			const envFile = resolve(probeDir, '.env');
+			writeFileSync(envFile, 'NO_DOTENV_TEST_CANARY=1\nNO_DOTENV_TEST_CANARY_2=2\n');
+
+			try {
+				// Use the ESM bundle (dist/index.mjs) — ESM is the modern public surface and
+				// satisfies this regression's intent (no env-key delta on import).
+				const probeScript = `
+const before = new Set(Object.keys(process.env));
+import(${JSON.stringify(distMjsPath)}).then(() => {
+  const after = new Set(Object.keys(process.env));
+  const added = [...after].filter(k => !before.has(k));
+  process.stdout.write(JSON.stringify({ added }));
+}).catch(e => { console.error(e); process.exit(1); });
+`;
+
+				const result = spawnSync('node', ['--input-type=module', '--eval', probeScript], {
+					cwd: probeDir,
+					encoding: 'utf8',
+					env: { ...process.env },
+				});
+
+				if (result.status !== 0) {
+					// eslint-disable-next-line no-console
+					console.error('Probe stderr:', result.stderr);
+				}
+				expect(result.status).toBe(0);
+
+				const payload = JSON.parse(result.stdout.trim());
+				expect(payload.added).toEqual([]);
+				expect(payload.added).not.toContain('NO_DOTENV_TEST_CANARY');
+				expect(payload.added).not.toContain('NO_DOTENV_TEST_CANARY_2');
+			} finally {
+				rmSync(probeDir, { recursive: true, force: true });
+			}
+		},
+	);
+});
diff --git a/drizzle-kit/tests/other/sdk-no-interactive.test.ts b/drizzle-kit/tests/other/sdk-no-interactive.test.ts
new file mode 100644
index 0000000000..73f6effcc7
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-no-interactive.test.ts
@@ -0,0 +1,77 @@
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { resolve } from 'path';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+// Mock hanji's render. Any push/pull/generate path that reaches `render(new Select(...))` hits this
+// mock; the SDK contract requires it is NEVER called. A no-op impl keeps a regression silent (the
+// real renderer would pollute CI logs) while the call-count assertion still catches it.
+vi.mock('hanji', async (importOriginal) => {
+	const actual = (await importOriginal()) as Record<string, unknown>;
+	return {
+		...actual,
+		render: vi.fn(),
+	};
+});
+
+import * as hanji from 'hanji';
+import { generate, pull, push } from '../../src/cli-sdk';
+
+let cleanups: Array<() => void> = [];
+
+const stageTmpDir = (label: string) => {
+	const dir = mkdtempSync(resolve(tmpdir(), `drizzle-kit-no-interactive-${label}-`));
+	cleanups.push(() => rmSync(dir, { recursive: true, force: true }));
+	return dir;
+};
+
+const expectNoRender = () => expect(hanji.render).toHaveBeenCalledTimes(0);
+
+describe('hanji render is never called from SDK paths', () => {
+	let originalPrefix: string | undefined;
+
+	beforeEach(() => {
+		originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+		delete process.env.TEST_CONFIG_PATH_PREFIX;
+		(hanji.render as ReturnType<typeof vi.fn>).mockClear();
+		cleanups = [];
+	});
+
+	afterEach(() => {
+		for (const fn of cleanups) fn();
+		if (originalPrefix !== undefined) {
+			process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+		}
+	});
+
+	test('push does not render when the schema file is missing', async () => {
+		const result = await push({
+			dialect: 'postgresql',
+			schema: 'tests/definitely-missing-schema.ts',
+			url: 'postgresql://invalid:invalid@127.0.0.1:1/none',
+		});
+		expect(result.status).toBe('error');
+		expectNoRender();
+	});
+
+	test('pull does not render when the database is unreachable', async () => {
+		const out = stageTmpDir('pull');
+		const result = await pull({
+			dialect: 'postgresql',
+			url: 'postgresql://invalid:invalid@127.0.0.1:1/none',
+			out,
+		});
+		expect(result.status).toBe('error');
+		expectNoRender();
+	});
+
+	test('generate does not render on a no_changes run', async () => {
+		// The empty-schema fixture lives at tests/cli/schema.ts; with the prefix the SDK resolves
+		// './schema.ts' → 'tests/cli/schema.ts' and yields no_changes, short-circuiting before render.
+		process.env.TEST_CONFIG_PATH_PREFIX = './tests/cli/';
+		const out = stageTmpDir('generate');
+		const result = await generate({ dialect: 'postgresql', schema: './schema.ts', out });
+		expect(result.status).toBe('no_changes');
+		expectNoRender();
+	});
+});
diff --git a/drizzle-kit/tests/other/sdk-no-stdout.test.ts b/drizzle-kit/tests/other/sdk-no-stdout.test.ts
new file mode 100644
index 0000000000..ea4eb1c3b5
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-no-stdout.test.ts
@@ -0,0 +1,135 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { check, exportSql, generate, pull, push, up } from '../../src/cli-sdk';
+import { stageValid } from './check-fixtures';
+import { stageUpNonLatest } from './up-fixtures';
+
+const tmpRoot = resolve(tmpdir(), 'drizzle-kit-no-stdout');
+
+let cleanups: Array<() => void> = [];
+
+const stageEmptySchema = (name: string) => {
+	const dir = resolve(tmpRoot, name);
+	mkdirSync(dir, { recursive: true });
+	const schemaPath = resolve(dir, 'schema.ts');
+	writeFileSync(schemaPath, '// empty schema — produces a no_changes envelope for the SDK smoke\n');
+	cleanups.push(() => rmSync(dir, { recursive: true, force: true }));
+	return { dir, schemaPath };
+};
+
+// Spy on process.stdout.write / process.exit, run the SDK call, then restore the spies.
+// mockRestore() clears mock.calls, so we capture into our own arrays — asserting on the restored
+// spy afterwards would be vacuous.
+const captureStdoutAndExit = async <T extends { status: string }>(run: () => Promise<T>) => {
+	const stdoutCalls: unknown[][] = [];
+	const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(
+		((...args: unknown[]) => {
+			stdoutCalls.push(args);
+			return true;
+		}) as unknown as typeof process.stdout.write,
+	);
+	const exitCalls: unknown[] = [];
+	const exitSpy = vi.spyOn(process, 'exit').mockImplementation(
+		(((code?: unknown) => {
+			exitCalls.push(code);
+		}) as unknown) as never,
+	);
+	try {
+		const result = await run();
+		return { result, stdoutCalls, exitCalls };
+	} finally {
+		stdoutSpy.mockRestore();
+		exitSpy.mockRestore();
+	}
+};
+
+const expectSilent = (stdoutCalls: unknown[][], exitCalls: unknown[]) => {
+	expect(stdoutCalls.map((c) => String(c[0]).slice(0, 200))).toEqual([]);
+	expect(exitCalls).toEqual([]);
+};
+
+describe('SDK does not invoke process.stdout.write or process.exit', () => {
+	let originalPrefix: string | undefined;
+
+	beforeEach(() => {
+		// The `pnpm test` script sets TEST_CONFIG_PATH_PREFIX=./tests/cli/ for the whole run. These
+		// tests pass absolute schema paths from tmpdir(), which the prefix would corrupt, so unset it.
+		originalPrefix = process.env.TEST_CONFIG_PATH_PREFIX;
+		delete process.env.TEST_CONFIG_PATH_PREFIX;
+		cleanups = [];
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		for (const fn of cleanups) fn();
+		if (originalPrefix !== undefined) {
+			process.env.TEST_CONFIG_PATH_PREFIX = originalPrefix;
+		}
+	});
+
+	test('generate stays silent on a no_changes run', async () => {
+		const { dir, schemaPath } = stageEmptySchema('generate-no-stdout');
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() =>
+			generate({ dialect: 'postgresql', schema: schemaPath, out: dir })
+		);
+		expect(result.status).toBe('no_changes');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+
+	test('push stays silent when the schema file is missing', async () => {
+		// Missing schema path → a schema_files_not_found_error envelope from preparePushConfig, before
+		// any DB connection. stdout must remain untouched.
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() =>
+			push({
+				dialect: 'postgresql',
+				schema: 'tests/definitely-missing-schema.ts',
+				url: 'postgresql://invalid:invalid@127.0.0.1:1/none',
+			})
+		);
+		expect(result.status).toBe('error');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+
+	test('pull stays silent when the database is unreachable', async () => {
+		// Unreachable URL → a database_driver_error at the connect span, before any introspection.
+		const { dir } = stageEmptySchema('pull-no-stdout');
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() =>
+			pull({ dialect: 'postgresql', url: 'postgresql://invalid:invalid@127.0.0.1:1/none', out: dir })
+		);
+		expect(result.status).toBe('error');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+
+	test('check stays silent on an ok run', async () => {
+		const out = stageValid();
+		cleanups.push(() => rmSync(out, { recursive: true, force: true }));
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() => check({ dialect: 'postgresql', out }));
+		expect(result.status).toBe('ok');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+
+	test('exportSql stays silent on an ok run', async () => {
+		// Empty schema diffs against empty state → ok with empty statements/warnings.
+		const { schemaPath } = stageEmptySchema('export-no-stdout');
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() =>
+			exportSql({ dialect: 'postgresql', schema: schemaPath })
+		);
+		expect(result.status).toBe('ok');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+
+	test('up stays silent while still writing the upgraded snapshot to disk', async () => {
+		const out = stageUpNonLatest();
+		cleanups.push(() => rmSync(out, { recursive: true, force: true }));
+		const { result, stdoutCalls, exitCalls } = await captureStdoutAndExit(() => up({ dialect: 'postgresql', out }));
+		expect(result.status).toBe('ok');
+		// up is the one verb whose file writes are the deliverable — the snapshot must be migrated to
+		// the latest format on disk even though nothing escapes to stdout/exit.
+		expect((result as { upgraded: string[] }).upgraded.length).toBeGreaterThan(0);
+		const mutated = JSON.parse(readFileSync(join(out, '0000_init', 'snapshot.json'), 'utf8'));
+		expect(mutated.version).toBe('8');
+		expectSilent(stdoutCalls, exitCalls);
+	});
+});
diff --git a/drizzle-kit/tests/other/sdk-public-surface.test.ts b/drizzle-kit/tests/other/sdk-public-surface.test.ts
new file mode 100644
index 0000000000..bb33ddce9e
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-public-surface.test.ts
@@ -0,0 +1,73 @@
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { beforeAll, describe, expect, test } from 'vitest';
+
+const distCjsPath = resolve(process.cwd(), 'dist', 'index.js');
+const distMjsPath = resolve(process.cwd(), 'dist', 'index.mjs');
+const skipDistTests = process.env.DRIZZLE_KIT_SKIP_DIST_TESTS === '1';
+const missingDist = [distCjsPath, distMjsPath].filter((p) => !existsSync(p));
+const skipForMissingDist = !skipDistTests && missingDist.length > 0;
+
+if (skipForMissingDist && !process.env.CI) {
+	// eslint-disable-next-line no-console
+	console.warn(
+		`[public-surface] skipping: dist is not built (missing ${missingDist.join(', ')}). `
+			+ `Run \`pnpm --filter drizzle-kit build\` to enable this regression, `
+			+ `or set DRIZZLE_KIT_SKIP_DIST_TESTS=1 to silence this warning.`,
+	);
+}
+
+describe("drizzle-kit public surface exports exactly ['defineConfig']", () => {
+	beforeAll(() => {
+		// Locally a missing dist downgrades to a loud skip; in CI the build step is guaranteed,
+		// so a missing dist is a pipeline defect and must fail.
+		if (skipForMissingDist && process.env.CI) {
+			throw new Error(
+				`public-surface regression requires a built dist (missing ${missingDist.join(', ')}). `
+					+ `Run \`pnpm --filter drizzle-kit build\` first.`,
+			);
+		}
+	});
+
+	test.skipIf(skipDistTests || skipForMissingDist)(
+		"Object.keys(require('drizzle-kit')) returns exactly ['defineConfig']",
+		() => {
+			const probeScript = `
+const m = require(${JSON.stringify(distCjsPath)});
+const keys = Object.keys(m).filter(k => !k.startsWith('__') && k !== 'default').sort();
+process.stdout.write(JSON.stringify({ keys }));
+`;
+			const result = spawnSync('node', ['--eval', probeScript], {
+				cwd: process.cwd(),
+				encoding: 'utf8',
+				env: { ...process.env },
+			});
+
+			expect(result.status).toBe(0);
+			const payload = JSON.parse(result.stdout.trim());
+			expect(payload.keys).toEqual(['defineConfig']);
+		},
+	);
+
+	test.skipIf(skipDistTests || skipForMissingDist)(
+		"ESM dist/index.mjs exports ['defineConfig']",
+		() => {
+			const probeScript = `
+import(${JSON.stringify(distMjsPath)}).then((m) => {
+  const keys = Object.keys(m).filter(k => !k.startsWith('__') && k !== 'default').sort();
+  process.stdout.write(JSON.stringify({ keys }));
+}).catch(e => { console.error(e); process.exit(1); });
+`;
+			const result = spawnSync('node', ['--input-type=module', '--eval', probeScript], {
+				cwd: process.cwd(),
+				encoding: 'utf8',
+				env: { ...process.env },
+			});
+
+			expect(result.status).toBe(0);
+			const payload = JSON.parse(result.stdout.trim());
+			expect(payload.keys).toEqual(['defineConfig']);
+		},
+	);
+});
diff --git a/drizzle-kit/tests/other/sdk-types-contract.test-d.ts b/drizzle-kit/tests/other/sdk-types-contract.test-d.ts
new file mode 100644
index 0000000000..d3fda2e8ab
--- /dev/null
+++ b/drizzle-kit/tests/other/sdk-types-contract.test-d.ts
@@ -0,0 +1,47 @@
+import { expectTypeOf, test } from 'vitest';
+import type {
+	CheckOptions,
+	ExportOptions,
+	GenerateOptions,
+	PullOptions,
+	PushOptions,
+	UpOptions,
+} from '../../src/cli/contract';
+import type { Hint } from '../../src/cli/hints';
+
+type IsKeyOf<K extends PropertyKey, T> = K extends keyof T ? true : false;
+
+test('SDK option types omit the CLI-only output/json keys', () => {
+	expectTypeOf<IsKeyOf<'output', GenerateOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'json', GenerateOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'output', PushOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'json', PushOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'output', CheckOptions>>().toEqualTypeOf<false>();
+});
+
+test('CheckOptions omits output', () => {
+	expectTypeOf<IsKeyOf<'output', CheckOptions>>().toEqualTypeOf<false>();
+});
+
+test('ExportOptions omits output and hints', () => {
+	expectTypeOf<IsKeyOf<'output', ExportOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'hints', ExportOptions>>().toEqualTypeOf<false>();
+});
+
+test('UpOptions omits output and hints', () => {
+	expectTypeOf<IsKeyOf<'output', UpOptions>>().toEqualTypeOf<false>();
+	expectTypeOf<IsKeyOf<'hints', UpOptions>>().toEqualTypeOf<false>();
+});
+
+test('PullOptions omits output', () => {
+	expectTypeOf<IsKeyOf<'output', PullOptions>>().toEqualTypeOf<false>();
+});
+
+test('PushOptions takes flat credentials, not a dbCredentials wrapper', () => {
+	expectTypeOf<IsKeyOf<'dbCredentials', PushOptions>>().toEqualTypeOf<false>();
+});
+
+test('SDK hints is a raw Hint[], never a JSON string', () => {
+	expectTypeOf<GenerateOptions['hints']>().toEqualTypeOf<Hint[] | undefined>();
+	expectTypeOf<PushOptions['hints']>().toEqualTypeOf<Hint[] | undefined>();
+});
diff --git a/drizzle-kit/tests/other/up-fixtures.ts b/drizzle-kit/tests/other/up-fixtures.ts
new file mode 100644
index 0000000000..cbf2f860fa
--- /dev/null
+++ b/drizzle-kit/tests/other/up-fixtures.ts
@@ -0,0 +1,17 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { stageOut, writeSnapshot } from './check-fixtures';
+
+// A real version:"7" postgres snapshot — upgradeable to latest by upToV8. The synthetic
+// stageNonLatest stub ({version:'1', ddl:[]}) is only classifiable; upToV8 reads
+// json.schemas/json.tables and crashes on it, so the up conformance fixture must be real.
+const V7_FIXTURE_PATH = join(__dirname, '..', 'postgres', 'snapshots', 'snapshot05-0.23.2.json');
+
+// Optional `out` lets the conformance harness re-stage a fresh non-latest copy at the SAME
+// path before each runner call — up mutates the snapshot in place, so the prior runner would
+// otherwise leave the SDK run nothing to upgrade.
+export const stageUpNonLatest = (out: string = stageOut()): string => {
+	const raw = JSON.parse(readFileSync(V7_FIXTURE_PATH, 'utf8'));
+	writeSnapshot(out, '0000_init', raw);
+	return out;
+};
diff --git a/drizzle-kit/tests/other/utils.test.ts b/drizzle-kit/tests/other/utils.test.ts
new file mode 100644
index 0000000000..bd9b09d1c3
--- /dev/null
+++ b/drizzle-kit/tests/other/utils.test.ts
@@ -0,0 +1,69 @@
+import { isTime, splitExpressions, trimChar, wrapWith } from 'src/utils';
+import { expect, test } from 'vitest';
+
+test('trim chars', () => {
+	expect.soft(trimChar("'", "'")).toBe("'");
+	expect.soft(trimChar("''", "'")).toBe('');
+	expect.soft(trimChar("('')", ['(', ')'])).toBe("''");
+	expect.soft(trimChar(trimChar("('')", ['(', ')']), "'")).toBe('');
+});
+
+test.each([
+	['lower(name)', ['lower(name)']],
+	['lower(name), upper(name)', ['lower(name)', 'upper(name)']],
+	['lower(name), lower(name)', ['lower(name)', 'lower(name)']],
+	[`((name || ','::text) || name1)`, [`((name || ','::text) || name1)`]],
+	["((name || ','::text) || name1), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"((name || ','::text) || name1)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	[`((name || ','::text) || name1), COALESCE("name", '"default", value'::text)`, [
+		`((name || ','::text) || name1)`,
+		`COALESCE("name", '"default", value'::text)`,
+	]],
+	["COALESCE(name, 'default,'' value'''::text), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"COALESCE(name, 'default,'' value'''::text)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	["COALESCE(name, 'default,value'''::text), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"COALESCE(name, 'default,value'''::text)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	["COALESCE(name, 'default,''value'::text), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"COALESCE(name, 'default,''value'::text)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	["COALESCE(name, 'default,value'::text), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"COALESCE(name, 'default,value'::text)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	["COALESCE(name, 'default, value'::text), SUBSTRING(name1 FROM 1 FOR 3)", [
+		"COALESCE(name, 'default, value'::text)",
+		'SUBSTRING(name1 FROM 1 FOR 3)',
+	]],
+	[`COALESCE("name", '"default", value'::text), SUBSTRING("name1" FROM 1 FOR 3)`, [
+		`COALESCE("name", '"default", value'::text)`,
+		`SUBSTRING("name1" FROM 1 FOR 3)`,
+	]],
+	[`COALESCE("namewithcomma,", '"default", value'::text), SUBSTRING("name1" FROM 1 FOR 3)`, [
+		`COALESCE("namewithcomma,", '"default", value'::text)`,
+		`SUBSTRING("name1" FROM 1 FOR 3)`,
+	]],
+	["((lower(first_name) || ', '::text) || lower(last_name))", [
+		"((lower(first_name) || ', '::text) || lower(last_name))",
+	]],
+])('split expression %#: %s', (it, expected) => {
+	expect(splitExpressions(it)).toStrictEqual(expected);
+});
+
+test('wrap chars', () => {
+	expect.soft(wrapWith('10:20:30', "'")).toBe("'10:20:30'");
+	expect.soft(wrapWith("10:20:30'", "'")).toBe("'10:20:30''");
+	expect.soft(wrapWith("'10:20:30", "'")).toBe("''10:20:30'");
+});
+
+test('is time', () => {
+	expect.soft(isTime('10:20:30')).toBe(true);
+	expect.soft(isTime('10:20:30+0000')).toBe(true);
+	expect.soft(isTime('now()')).toBe(false);
+});
diff --git a/drizzle-kit/tests/other/utils.ts b/drizzle-kit/tests/other/utils.ts
new file mode 100644
index 0000000000..ef2df8a966
--- /dev/null
+++ b/drizzle-kit/tests/other/utils.ts
@@ -0,0 +1,15 @@
+import { randomBytes } from 'crypto';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { Config } from 'src';
+
+export function createConfig(config: Config, pathPrefix: string): { path: string; name: string } {
+	const name = `drizzle.${randomBytes(8).toString('hex')}.config.ts`;
+	const path = join(process.cwd(), pathPrefix, name);
+	const body = `import { defineConfig } from '../../src';\n\nexport default defineConfig(${
+		JSON.stringify(config, null, 2)
+	});\n`;
+
+	writeFileSync(path, body);
+	return { path, name };
+}
diff --git a/drizzle-kit/tests/validations.test.ts b/drizzle-kit/tests/other/validations.test.ts
similarity index 100%
rename from drizzle-kit/tests/validations.test.ts
rename to drizzle-kit/tests/other/validations.test.ts
diff --git a/drizzle-kit/tests/wrap-param.test.ts b/drizzle-kit/tests/other/wrap-param.test.ts
similarity index 92%
rename from drizzle-kit/tests/wrap-param.test.ts
rename to drizzle-kit/tests/other/wrap-param.test.ts
index a27d27d450..ea189e8df7 100644
--- a/drizzle-kit/tests/wrap-param.test.ts
+++ b/drizzle-kit/tests/other/wrap-param.test.ts
@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { assert, expect, test } from 'vitest';
-import { wrapParam } from '../src/cli/validations/common';
+import { wrapParam } from '../../src/cli/validations/common';
 
 test('wrapParam', () => {
 	expect(wrapParam('password', 'password123', false, 'secret')).toBe(`    [${chalk.green('✓')}] password: '*****'`);
diff --git a/drizzle-kit/tests/pg-array-defaults.test.ts b/drizzle-kit/tests/pg-array-defaults.test.ts
deleted file mode 100644
index 6c4dbd2444..0000000000
--- a/drizzle-kit/tests/pg-array-defaults.test.ts
+++ /dev/null
@@ -1,365 +0,0 @@
-import { expect, test } from 'vitest';
-import { defaultForColumn } from '../src/serializer/pgSerializer';
-
-// Type definitions for testing
-interface ColumnMock {
-	column_name: string;
-	column_default: string;
-	data_type: string;
-}
-
-interface PgKitInternals {
-	tables: Record<string, {
-		columns: Record<string, {
-			isArray?: boolean;
-			dimensions?: number;
-			rawType?: string;
-			isDefaultAnExpression?: boolean;
-		}>;
-	}>;
-}
-
-test('PostgreSQL array defaults: ARRAY constructor syntax - single value', () => {
-	const column: ColumnMock = {
-		column_name: 'roles',
-		column_default: "ARRAY['user']",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					roles: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"user"}\'');
-});
-
-test('PostgreSQL array defaults: ARRAY constructor syntax - multiple values', () => {
-	const column: ColumnMock = {
-		column_name: 'permissions',
-		column_default: "ARRAY['read', 'write']",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					permissions: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"read","write"}\'');
-});
-
-test('PostgreSQL array defaults: ARRAY constructor with type casting', () => {
-	const column: ColumnMock = {
-		column_name: 'preferences',
-		column_default: "ARRAY['email'::text]",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					preferences: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"email"}\'');
-});
-
-test('PostgreSQL array defaults: ARRAY constructor with multiple values and type casting', () => {
-	const column: ColumnMock = {
-		column_name: 'platforms',
-		column_default: "ARRAY['both'::text, 'mobile'::text]",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					platforms: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"both","mobile"}\'');
-});
-
-test('PostgreSQL array defaults: ARRAY constructor with mixed type casting', () => {
-	const column: ColumnMock = {
-		column_name: 'mixed_array',
-		column_default: "ARRAY['first'::text, 'second', 'third'::varchar]",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					mixed_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"first","second","third"}\'');
-});
-
-test('PostgreSQL array defaults: existing bracket notation should still work', () => {
-	const column: ColumnMock = {
-		column_name: 'tags',
-		column_default: '\'{"tag1", "tag2"}\'',
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					tags: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"tag1","tag2"}\''); // postgres-array normalizes spacing
-});
-
-test('PostgreSQL array defaults: bracket notation without outer quotes', () => {
-	const column: ColumnMock = {
-		column_name: 'simple_tags',
-		column_default: '{"tag1", "tag2"}',
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					simple_tags: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"tag1","tag2"}\''); // postgres-array normalizes spacing
-});
-
-test('PostgreSQL array defaults: empty array with quotes', () => {
-	const column: ColumnMock = {
-		column_name: 'empty_array',
-		column_default: "'{}'",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					empty_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe("'{}'");
-});
-
-test('PostgreSQL array defaults: empty array without quotes', () => {
-	const column: ColumnMock = {
-		column_name: 'empty_array',
-		column_default: '{}',
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					empty_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe("'{}'");
-});
-
-test('PostgreSQL array defaults: array with empty string element', () => {
-	const column: ColumnMock = {
-		column_name: 'empty_string_array',
-		column_default: '\'{""}\'',
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					empty_string_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{""}\'');
-});
-
-test('PostgreSQL array defaults: integer array with ARRAY constructor', () => {
-	const column: ColumnMock = {
-		column_name: 'numbers',
-		column_default: 'ARRAY[1, 2, 3]',
-		data_type: 'integer[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					numbers: { isArray: true, dimensions: 1, rawType: 'integer' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe("'{1,2,3}'"); // postgres-array with trimming normalizes to compact form
-});
-
-test('PostgreSQL array defaults: boolean array with ARRAY constructor', () => {
-	const column: ColumnMock = {
-		column_name: 'flags',
-		column_default: 'ARRAY[true, false]',
-		data_type: 'boolean[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					flags: { isArray: true, dimensions: 1, rawType: 'boolean' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe("'{true,false}'");
-});
-
-test('PostgreSQL array defaults: handles escaped quotes in ARRAY constructor', () => {
-	const column: ColumnMock = {
-		column_name: 'quoted_values',
-		column_default: "ARRAY['value with ''quotes''', 'normal value']",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					quoted_values: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe("'{\"value with ''quotes''\",\"normal value\"}'");
-});
-
-test('PostgreSQL array defaults: ARRAY constructor with global type casting removal', () => {
-	const column: ColumnMock = {
-		column_name: 'casted_array',
-		column_default: "ARRAY['value1', 'value2']::text[]",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					casted_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"value1","value2"}\'');
-});
-
-test('PostgreSQL array defaults: complex ARRAY constructor with spaces', () => {
-	const column: ColumnMock = {
-		column_name: 'spaced_array',
-		column_default: "ARRAY[ 'first' , 'second'::text , 'third' ]",
-		data_type: 'text[]',
-	};
-	const internals: PgKitInternals = {
-		tables: {
-			test_table: {
-				columns: {
-					spaced_array: { isArray: true, dimensions: 1, rawType: 'text' },
-				},
-			},
-		},
-	};
-
-	const result = defaultForColumn(column, internals, 'test_table');
-	expect(result).toBe('\'{"first","second","third"}\'');
-});
-
-test('PostgreSQL array defaults: regression test for ARRAY truncation bug', () => {
-	// This test specifically verifies that "ARRAY" doesn't get truncated to "RAY"
-	const testCases = [
-		{
-			input: "ARRAY['user']",
-			expected: '\'{"user"}\'',
-			description: 'single value',
-		},
-		{
-			input: "ARRAY['admin', 'user']",
-			expected: '\'{"admin","user"}\'',
-			description: 'multiple values',
-		},
-		{
-			input: "ARRAY['email'::text]",
-			expected: '\'{"email"}\'',
-			description: 'with type casting',
-		},
-	];
-
-	for (const { input, expected } of testCases) {
-		const column: ColumnMock = {
-			column_name: 'test_column',
-			column_default: input,
-			data_type: 'text[]',
-		};
-		const internals: PgKitInternals = {
-			tables: {
-				test_table: {
-					columns: {
-						test_column: { isArray: true, dimensions: 1, rawType: 'text' },
-					},
-				},
-			},
-		};
-
-		const result = defaultForColumn(column, internals, 'test_table');
-		expect(result).toBe(expected);
-
-		// Ensure result doesn't contain the corrupted "RAY" substring
-		expect(result).not.toContain('RAY');
-		expect(result).not.toContain('::tex"');
-	}
-});
diff --git a/drizzle-kit/tests/pg-array.test.ts b/drizzle-kit/tests/pg-array.test.ts
deleted file mode 100644
index 300355ce2e..0000000000
--- a/drizzle-kit/tests/pg-array.test.ts
+++ /dev/null
@@ -1,370 +0,0 @@
-import {
-	bigint,
-	boolean,
-	date,
-	integer,
-	json,
-	pgEnum,
-	pgTable,
-	serial,
-	text,
-	timestamp,
-	uuid,
-} from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('array #1: empty array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{}'" },
-	});
-});
-
-test('array #2: integer array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([1, 2, 3]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{1,2,3}'" },
-	});
-});
-
-test('array #3: bigint array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: bigint('values', { mode: 'bigint' }).array().default([BigInt(1), BigInt(2), BigInt(3)]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: { name: 'values', type: 'bigint[]', primaryKey: false, notNull: false, default: "'{1,2,3}'" },
-	});
-});
-
-test('array #4: boolean array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: boolean('values').array().default([true, false, true]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'boolean[]',
-			primaryKey: false,
-			notNull: false,
-			default: "'{true,false,true}'",
-		},
-	});
-});
-
-test('array #5: multi-dimensional array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().array().default([[1, 2], [3, 4]]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'integer[][]',
-			primaryKey: false,
-			notNull: false,
-			default: "'{{1,2},{3,4}}'",
-		},
-	});
-});
-
-test('array #6: date array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: date('values').array().default(['2024-08-06', '2024-08-07']),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'date[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"2024-08-06","2024-08-07"}\'',
-		},
-	});
-});
-
-test('array #7: timestamp array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: timestamp('values').array().default([new Date('2024-08-06'), new Date('2024-08-07')]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'timestamp[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"2024-08-06 00:00:00.000","2024-08-07 00:00:00.000"}\'',
-		},
-	});
-});
-
-test('array #8: json array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: json('values').array().default([{ a: 1 }, { b: 2 }]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'json[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"{\\"a\\":1}","{\\"b\\":2}"}\'',
-		},
-	});
-});
-
-test('array #9: text array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: text('values').array().default(['abc', 'def']),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'text[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"abc","def"}\'',
-		},
-	});
-});
-
-test('array #10: uuid array default', async (t) => {
-	const from = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: uuid('values').array().default([
-				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
-				'b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11',
-			]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'uuid[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11","b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11"}\'',
-		},
-	});
-});
-
-test('array #11: enum array default', async (t) => {
-	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
-
-	const from = {
-		enum: testEnum,
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		enum: testEnum,
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: testEnum('values').array().default(['a', 'b', 'c']),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'test_enum[]',
-			primaryKey: false,
-			notNull: false,
-			default: '\'{"a","b","c"}\'',
-			typeSchema: 'public',
-		},
-	});
-});
-
-test('array #12: enum empty array default', async (t) => {
-	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
-
-	const from = {
-		enum: testEnum,
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		enum: testEnum,
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: testEnum('values').array().default([]),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'test',
-		schema: '',
-		column: {
-			name: 'values',
-			type: 'test_enum[]',
-			primaryKey: false,
-			notNull: false,
-			default: "'{}'",
-			typeSchema: 'public',
-		},
-	});
-});
diff --git a/drizzle-kit/tests/pg-checks.test.ts b/drizzle-kit/tests/pg-checks.test.ts
deleted file mode 100644
index 8033aacefb..0000000000
--- a/drizzle-kit/tests/pg-checks.test.ts
+++ /dev/null
@@ -1,282 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { check, integer, pgTable, serial, varchar } from 'drizzle-orm/pg-core';
-import { JsonCreateTableStatement } from 'src/jsonStatements';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('create table with check', async (t) => {
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [
-			{
-				name: 'id',
-				type: 'serial',
-				notNull: true,
-				primaryKey: true,
-			},
-			{
-				name: 'age',
-				type: 'integer',
-				notNull: false,
-				primaryKey: false,
-			},
-		],
-		compositePKs: [],
-		checkConstraints: ['some_check_name;"users"."age" > 21'],
-		compositePkName: '',
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		policies: [],
-	} as JsonCreateTableStatement);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" serial PRIMARY KEY NOT NULL,
-\t"age" integer,
-\tCONSTRAINT "some_check_name" CHECK ("users"."age" > 21)
-);\n`);
-});
-
-test('add check contraint to existing table', async (t) => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_check_constraint',
-		tableName: 'users',
-		schema: '',
-		data: 'some_check_name;"users"."age" > 21',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name" CHECK ("users"."age" > 21);`,
-	);
-});
-
-test('drop check contraint in existing table', async (t) => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'delete_check_constraint',
-		tableName: 'users',
-		schema: '',
-		constraintName: 'some_check_name',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
-	);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('new_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		data: 'new_check_name;"users"."age" > 21',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("users"."age" > 21);`,
-	);
-});
-
-test('alter check constraint', async (t) => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-		}, (table) => ({
-			checkConstraint: check('new_check_name', sql`${table.age} > 10`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		data: 'new_check_name;"users"."age" > 10',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("users"."age" > 10);`,
-	);
-});
-
-test('alter multiple check constraints', async (t) => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-			name: varchar('name'),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name_1', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name_2', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-			name: varchar('name'),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name_3', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name_4', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemas(from, to, []);
-	expect(statements.length).toBe(4);
-	expect(statements[0]).toStrictEqual({
-		constraintName: 'some_check_name_1',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[1]).toStrictEqual({
-		constraintName: 'some_check_name_2',
-		schema: '',
-		tableName: 'users',
-		type: 'delete_check_constraint',
-	});
-	expect(statements[2]).toStrictEqual({
-		data: 'some_check_name_3;"users"."age" > 21',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-	expect(statements[3]).toStrictEqual({
-		data: 'some_check_name_4;"users"."name" != \'Alex\'',
-		schema: '',
-		tableName: 'users',
-		type: 'create_check_constraint',
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_1";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_2";`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_3" CHECK ("users"."age" > 21);`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_4" CHECK ("users"."name" != \'Alex\');`,
-	);
-});
-
-test('create checks with same names', async (t) => {
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			age: integer('age'),
-			name: varchar('name'),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	await expect(diffTestSchemas({}, to, [])).rejects.toThrowError();
-});
diff --git a/drizzle-kit/tests/pg-columns.test.ts b/drizzle-kit/tests/pg-columns.test.ts
deleted file mode 100644
index ddd744a81a..0000000000
--- a/drizzle-kit/tests/pg-columns.test.ts
+++ /dev/null
@@ -1,484 +0,0 @@
-import { integer, pgTable, primaryKey, serial, text, uuid, varchar } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('add columns #1', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: { name: 'name', type: 'text', primaryKey: false, notNull: false },
-	});
-});
-
-test('add columns #2', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name'),
-			email: text('email'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: { name: 'name', type: 'text', primaryKey: false, notNull: false },
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: { name: 'email', type: 'text', primaryKey: false, notNull: false },
-	});
-});
-
-test('alter column change name #1', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name1'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, [
-		'public.users.name->public.users.name1',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		oldColumnName: 'name',
-		newColumnName: 'name1',
-	});
-});
-
-test('alter column change name #2', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name1'),
-			email: text('email'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, [
-		'public.users.name->public.users.name1',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		oldColumnName: 'name',
-		newColumnName: 'name1',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: {
-			name: 'email',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-		},
-	});
-});
-
-test('alter table add composite pk', async (t) => {
-	const schema1 = {
-		table: pgTable('table', {
-			id1: integer('id1'),
-			id2: integer('id2'),
-		}),
-	};
-
-	const schema2 = {
-		table: pgTable(
-			'table',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2] }),
-				};
-			},
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_composite_pk',
-		tableName: 'table',
-		data: 'id1,id2;table_id1_id2_pk',
-		schema: '',
-		constraintName: 'table_id1_id2_pk',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE "table" ADD CONSTRAINT "table_id1_id2_pk" PRIMARY KEY("id1","id2");',
-	);
-});
-
-test('rename table rename column #1', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users1', {
-			id: integer('id1'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, [
-		'public.users->public.users1',
-		'public.users1.id->public.users1.id1',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users',
-		tableNameTo: 'users1',
-		fromSchema: '',
-		toSchema: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		oldColumnName: 'id',
-		newColumnName: 'id1',
-		schema: '',
-		tableName: 'users1',
-	});
-});
-
-test('with composite pks #1', async (t) => {
-	const schema1 = {
-		users: pgTable(
-			'users',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' }),
-				};
-			},
-		),
-	};
-
-	const schema2 = {
-		users: pgTable(
-			'users',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-				text: text('text'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' }),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: {
-			name: 'text',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-		},
-	});
-});
-
-test('with composite pks #2', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id1: integer('id1'),
-			id2: integer('id2'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable(
-			'users',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' }),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_composite_pk',
-		tableName: 'users',
-		schema: '',
-		constraintName: 'compositePK',
-		data: 'id1,id2;compositePK',
-	});
-});
-
-test('with composite pks #3', async (t) => {
-	const schema1 = {
-		users: pgTable(
-			'users',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' }),
-				};
-			},
-		),
-	};
-
-	const schema2 = {
-		users: pgTable(
-			'users',
-			{
-				id1: integer('id1'),
-				id3: integer('id3'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id3], name: 'compositePK' }),
-				};
-			},
-		),
-	};
-
-	// TODO: remove redundand drop/create create constraint
-	const { statements } = await diffTestSchemas(schema1, schema2, [
-		'public.users.id2->public.users.id3',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		newColumnName: 'id3',
-		oldColumnName: 'id2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_composite_pk',
-		tableName: 'users',
-		schema: '',
-		new: 'id1,id3;compositePK',
-		old: 'id1,id2;compositePK',
-		newConstraintName: 'compositePK',
-		oldConstraintName: 'compositePK',
-	});
-});
-
-test('add multiple constraints #1', async (t) => {
-	const t1 = pgTable('t1', {
-		id: uuid('id').primaryKey().defaultRandom(),
-	});
-
-	const t2 = pgTable('t2', {
-		id: uuid('id').primaryKey().defaultRandom(),
-	});
-
-	const t3 = pgTable('t3', {
-		id: uuid('id').primaryKey().defaultRandom(),
-	});
-
-	const schema1 = {
-		t1,
-		t2,
-		t3,
-		ref1: pgTable('ref1', {
-			id1: uuid('id1').references(() => t1.id),
-			id2: uuid('id2').references(() => t2.id),
-			id3: uuid('id3').references(() => t3.id),
-		}),
-	};
-
-	const schema2 = {
-		t1,
-		t2,
-		t3,
-		ref1: pgTable('ref1', {
-			id1: uuid('id1').references(() => t1.id, { onDelete: 'cascade' }),
-			id2: uuid('id2').references(() => t2.id, { onDelete: 'set null' }),
-			id3: uuid('id3').references(() => t3.id, { onDelete: 'cascade' }),
-		}),
-	};
-
-	// TODO: remove redundand drop/create create constraint
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(6);
-});
-
-test('add multiple constraints #2', async (t) => {
-	const t1 = pgTable('t1', {
-		id1: uuid('id1').primaryKey().defaultRandom(),
-		id2: uuid('id2').primaryKey().defaultRandom(),
-		id3: uuid('id3').primaryKey().defaultRandom(),
-	});
-
-	const schema1 = {
-		t1,
-		ref1: pgTable('ref1', {
-			id1: uuid('id1').references(() => t1.id1),
-			id2: uuid('id2').references(() => t1.id2),
-			id3: uuid('id3').references(() => t1.id3),
-		}),
-	};
-
-	const schema2 = {
-		t1,
-		ref1: pgTable('ref1', {
-			id1: uuid('id1').references(() => t1.id1, { onDelete: 'cascade' }),
-			id2: uuid('id2').references(() => t1.id2, { onDelete: 'set null' }),
-			id3: uuid('id3').references(() => t1.id3, { onDelete: 'cascade' }),
-		}),
-	};
-
-	// TODO: remove redundand drop/create create constraint
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(6);
-});
-
-test('add multiple constraints #3', async (t) => {
-	const t1 = pgTable('t1', {
-		id1: uuid('id1').primaryKey().defaultRandom(),
-		id2: uuid('id2').primaryKey().defaultRandom(),
-		id3: uuid('id3').primaryKey().defaultRandom(),
-	});
-
-	const schema1 = {
-		t1,
-		ref1: pgTable('ref1', {
-			id: uuid('id').references(() => t1.id1),
-		}),
-		ref2: pgTable('ref2', {
-			id: uuid('id').references(() => t1.id2),
-		}),
-		ref3: pgTable('ref3', {
-			id: uuid('id').references(() => t1.id3),
-		}),
-	};
-
-	const schema2 = {
-		t1,
-		ref1: pgTable('ref1', {
-			id: uuid('id').references(() => t1.id1, { onDelete: 'cascade' }),
-		}),
-		ref2: pgTable('ref2', {
-			id: uuid('id').references(() => t1.id2, { onDelete: 'set null' }),
-		}),
-		ref3: pgTable('ref3', {
-			id: uuid('id').references(() => t1.id3, { onDelete: 'cascade' }),
-		}),
-	};
-
-	// TODO: remove redundand drop/create create constraint
-	const { statements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(statements.length).toBe(6);
-});
-
-test('varchar and text default values escape single quotes', async (t) => {
-	const schema1 = {
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const schem2 = {
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-			text: text('text').default("escape's quotes"),
-			varchar: varchar('varchar').default("escape's quotes"),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(schema1, schem2, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toStrictEqual(
-		'ALTER TABLE "table" ADD COLUMN "text" text DEFAULT \'escape\'\'s quotes\';',
-	);
-	expect(sqlStatements[1]).toStrictEqual(
-		'ALTER TABLE "table" ADD COLUMN "varchar" varchar DEFAULT \'escape\'\'s quotes\';',
-	);
-});
diff --git a/drizzle-kit/tests/pg-enums.test.ts b/drizzle-kit/tests/pg-enums.test.ts
deleted file mode 100644
index 967df2e3e4..0000000000
--- a/drizzle-kit/tests/pg-enums.test.ts
+++ /dev/null
@@ -1,2505 +0,0 @@
-import { integer, pgEnum, pgSchema, pgTable, serial, text, varchar } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('enums #1', async () => {
-	const to = {
-		enum: pgEnum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value');`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'enum',
-		schema: 'public',
-		type: 'create_type_enum',
-		values: ['value'],
-	});
-});
-
-test('enums #2', async () => {
-	const folder = pgSchema('folder');
-	const to = {
-		enum: folder.enum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TYPE "folder"."enum" AS ENUM('value');`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'enum',
-		schema: 'folder',
-		type: 'create_type_enum',
-		values: ['value'],
-	});
-});
-
-test('enums #3', async () => {
-	const from = {
-		enum: pgEnum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, {}, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP TYPE "public"."enum";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_type_enum',
-		name: 'enum',
-		schema: 'public',
-	});
-});
-
-test('enums #4', async () => {
-	const folder = pgSchema('folder');
-
-	const from = {
-		enum: folder.enum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, {}, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP TYPE "folder"."enum";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_type_enum',
-		name: 'enum',
-		schema: 'folder',
-	});
-});
-
-test('enums #5', async () => {
-	const folder1 = pgSchema('folder1');
-	const folder2 = pgSchema('folder2');
-
-	const from = {
-		folder1,
-		enum: folder1.enum('enum', ['value']),
-	};
-
-	const to = {
-		folder2,
-		enum: folder2.enum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['folder1->folder2']);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER SCHEMA "folder1" RENAME TO "folder2";\n`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'folder1',
-		to: 'folder2',
-	});
-});
-
-test('enums #6', async () => {
-	const folder1 = pgSchema('folder1');
-	const folder2 = pgSchema('folder2');
-
-	const from = {
-		folder1,
-		folder2,
-		enum: folder1.enum('enum', ['value']),
-	};
-
-	const to = {
-		folder1,
-		folder2,
-		enum: folder2.enum('enum', ['value']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'folder1.enum->folder2.enum',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "folder1"."enum" SET SCHEMA "folder2";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-});
-
-test('enums #7', async () => {
-	const from = {
-		enum: pgEnum('enum', ['value1']),
-	};
-
-	const to = {
-		enum: pgEnum('enum', ['value1', 'value2']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum" ADD VALUE 'value2';`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum',
-		schema: 'public',
-		value: 'value2',
-		before: '',
-	});
-});
-
-test('enums #8', async () => {
-	const from = {
-		enum: pgEnum('enum', ['value1']),
-	};
-
-	const to = {
-		enum: pgEnum('enum', ['value1', 'value2', 'value3']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum" ADD VALUE 'value2';`);
-	expect(sqlStatements[1]).toBe(`ALTER TYPE "public"."enum" ADD VALUE 'value3';`);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum',
-		schema: 'public',
-		value: 'value2',
-		before: '',
-	});
-
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum',
-		schema: 'public',
-		value: 'value3',
-		before: '',
-	});
-});
-
-test('enums #9', async () => {
-	const from = {
-		enum: pgEnum('enum', ['value1', 'value3']),
-	};
-
-	const to = {
-		enum: pgEnum('enum', ['value1', 'value2', 'value3']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum" ADD VALUE 'value2' BEFORE 'value3';`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum',
-		schema: 'public',
-		value: 'value2',
-		before: 'value3',
-	});
-});
-
-test('enums #10', async () => {
-	const schema = pgSchema('folder');
-	const from = {
-		enum: schema.enum('enum', ['value1']),
-	};
-
-	const to = {
-		enum: schema.enum('enum', ['value1', 'value2']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "folder"."enum" ADD VALUE 'value2';`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum',
-		schema: 'folder',
-		value: 'value2',
-		before: '',
-	});
-});
-
-test('enums #11', async () => {
-	const schema1 = pgSchema('folder1');
-	const from = {
-		enum: schema1.enum('enum', ['value1']),
-	};
-
-	const to = {
-		enum: pgEnum('enum', ['value1']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'folder1.enum->public.enum',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "folder1"."enum" SET SCHEMA "public";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum',
-		schemaFrom: 'folder1',
-		schemaTo: 'public',
-	});
-});
-
-test('enums #12', async () => {
-	const schema1 = pgSchema('folder1');
-	const from = {
-		enum: pgEnum('enum', ['value1']),
-	};
-
-	const to = {
-		enum: schema1.enum('enum', ['value1']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.enum->folder1.enum',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum" SET SCHEMA "folder1";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum',
-		schemaFrom: 'public',
-		schemaTo: 'folder1',
-	});
-});
-
-test('enums #13', async () => {
-	const from = {
-		enum: pgEnum('enum1', ['value1']),
-	};
-
-	const to = {
-		enum: pgEnum('enum2', ['value1']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.enum1->public.enum2',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum1" RENAME TO "enum2";`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_type_enum',
-		nameFrom: 'enum1',
-		nameTo: 'enum2',
-		schema: 'public',
-	});
-});
-
-test('enums #14', async () => {
-	const folder1 = pgSchema('folder1');
-	const folder2 = pgSchema('folder2');
-	const from = {
-		enum: folder1.enum('enum1', ['value1']),
-	};
-
-	const to = {
-		enum: folder2.enum('enum2', ['value1']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'folder1.enum1->folder2.enum2',
-	]);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`);
-	expect(sqlStatements[1]).toBe(`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum1',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_type_enum',
-		nameFrom: 'enum1',
-		nameTo: 'enum2',
-		schema: 'folder2',
-	});
-});
-
-test('enums #15', async () => {
-	const folder1 = pgSchema('folder1');
-	const folder2 = pgSchema('folder2');
-	const from = {
-		enum: folder1.enum('enum1', ['value1', 'value4']),
-	};
-
-	const to = {
-		enum: folder2.enum('enum2', ['value1', 'value2', 'value3', 'value4']),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'folder1.enum1->folder2.enum2',
-	]);
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`);
-	expect(sqlStatements[1]).toBe(`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`);
-	expect(sqlStatements[2]).toBe(`ALTER TYPE "folder2"."enum2" ADD VALUE 'value2' BEFORE 'value4';`);
-	expect(sqlStatements[3]).toBe(`ALTER TYPE "folder2"."enum2" ADD VALUE 'value3' BEFORE 'value4';`);
-
-	expect(statements.length).toBe(4);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum1',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_type_enum',
-		nameFrom: 'enum1',
-		nameTo: 'enum2',
-		schema: 'folder2',
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum2',
-		schema: 'folder2',
-		value: 'value2',
-		before: 'value4',
-	});
-	expect(statements[3]).toStrictEqual({
-		type: 'alter_type_add_value',
-		name: 'enum2',
-		schema: 'folder2',
-		value: 'value3',
-		before: 'value4',
-	});
-});
-
-test('enums #16', async () => {
-	const enum1 = pgEnum('enum1', ['value1']);
-	const enum2 = pgEnum('enum2', ['value1']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.enum1->public.enum2',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum1" RENAME TO "enum2";`);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_type_enum',
-		nameFrom: 'enum1',
-		nameTo: 'enum2',
-		schema: 'public',
-	});
-});
-
-test('enums #17', async () => {
-	const schema = pgSchema('schema');
-	const enum1 = pgEnum('enum1', ['value1']);
-	const enum2 = schema.enum('enum1', ['value1']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.enum1->schema.enum1',
-	]);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "public"."enum1" SET SCHEMA "schema";`);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum1',
-		schemaFrom: 'public',
-		schemaTo: 'schema',
-	});
-});
-
-test('enums #18', async () => {
-	const schema1 = pgSchema('schema1');
-	const schema2 = pgSchema('schema2');
-
-	const enum1 = schema1.enum('enum1', ['value1']);
-	const enum2 = schema2.enum('enum2', ['value1']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column'),
-		}),
-	};
-
-	// change name and schema of the enum, no table changes
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'schema1.enum1->schema2.enum2',
-	]);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TYPE "schema1"."enum1" SET SCHEMA "schema2";`);
-	expect(sqlStatements[1]).toBe(`ALTER TYPE "schema2"."enum1" RENAME TO "enum2";`);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'move_type_enum',
-		name: 'enum1',
-		schemaFrom: 'schema1',
-		schemaTo: 'schema2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_type_enum',
-		nameFrom: 'enum1',
-		nameTo: 'enum2',
-		schema: 'schema2',
-	});
-});
-
-test('enums #19', async () => {
-	const myEnum = pgEnum('my_enum', ["escape's quotes"]);
-
-	const from = {};
-
-	const to = { myEnum };
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toStrictEqual(
-		'CREATE TYPE "public"."my_enum" AS ENUM(\'escape\'\'s quotes\');',
-	);
-});
-
-test('enums #20', async () => {
-	const myEnum = pgEnum('my_enum', ['one', 'two', 'three']);
-
-	const from = {
-		myEnum,
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const to = {
-		myEnum,
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-			col1: myEnum('col1'),
-			col2: integer('col2'),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum";',
-		'ALTER TABLE "table" ADD COLUMN "col2" integer;',
-	]);
-});
-
-test('enums #21', async () => {
-	const myEnum = pgEnum('my_enum', ['one', 'two', 'three']);
-
-	const from = {
-		myEnum,
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const to = {
-		myEnum,
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-			col1: myEnum('col1').array(),
-			col2: integer('col2').array(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum"[];',
-		'ALTER TABLE "table" ADD COLUMN "col2" integer[];',
-	]);
-});
-
-test('drop enum value', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3']);
-	const to = {
-		enum2,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[1]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3');`);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [],
-		deletedValues: [
-			'value2',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-test('drop enum value. enum is columns data type', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		schema,
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-		table2: schema.table('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3']);
-	const to = {
-		schema,
-		enum2,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-		table2: schema.table('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum',
-			},
-			{
-				column: 'column',
-				tableSchema: 'new_schema',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum',
-			},
-		],
-		deletedValues: [
-			'value2',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-test('shuffle enum values', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		schema,
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-		table2: schema.table('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		schema,
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column'),
-		}),
-		table2: schema.table('table', {
-			column: enum2('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum',
-			},
-			{
-				column: 'column',
-				tableSchema: 'new_schema',
-				table: 'table',
-				columnType: 'enum',
-				default: undefined,
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-test('enums as ts enum', async () => {
-	enum Test {
-		value = 'value',
-	}
-
-	const to = {
-		enum: pgEnum('enum', Test),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value');`);
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'enum',
-		schema: 'public',
-		type: 'create_type_enum',
-		values: ['value'],
-	});
-});
-
-// +
-test('column is enum type with default value. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').default('value2'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"public"."enum";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: "'value2'",
-				columnType: 'enum',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum type with default value. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array().default(['value2']),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').array().default(['value3']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value3"}'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value3"}'::"public"."enum"[];`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[] USING "column"::"public"."enum"[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: `'{"value3"}'`,
-				columnType: 'enum[]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum with custom size type with default value. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3).default(['value2']),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').array(3).default(['value2']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::"public"."enum"[3];`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[3] USING "column"::"public"."enum"[3];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: `'{"value2"}'`,
-				columnType: 'enum[3]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum with custom size type. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').array(3),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[2]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[3] USING "column"::"public"."enum"[3];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum[3]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array of enum with multiple dimenions with custom sizes type. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3).array(2),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').array(3).array(2),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[2]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[3][2] USING "column"::"public"."enum"[3][2];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum[3][2]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array of enum with multiple dimenions type with custom size with default value. shuffle enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3).array(2).default([['value2']]),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').array(3).array(2).default([['value2']]),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{{"value2"}}'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{{"value2"}}'::"public"."enum"[3][2];`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[3][2] USING "column"::"public"."enum"[3][2];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: `'{{\"value2\"}}'`,
-				columnType: 'enum[3][2]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is enum type with default value. custom schema. shuffle enum', async () => {
-	const schema = pgSchema('new_schema');
-
-	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
-	const from = {
-		schema,
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').default('value2'),
-		}),
-	};
-
-	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		schema,
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "new_schema"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"new_schema"."enum";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum" USING "column"::"new_schema"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: "'value2'",
-				columnType: 'enum',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'new_schema',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum type with default value. custom schema. shuffle enum', async () => {
-	const schema = pgSchema('new_schema');
-
-	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: schema.table('table', {
-			column: enum1('column').array().default(['value2']),
-		}),
-	};
-
-	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: schema.table('table', {
-			column: enum2('column').array().default(['value2']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::text;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "new_schema"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::"new_schema"."enum"[];`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[] USING "column"::"new_schema"."enum"[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: 'new_schema',
-				table: 'table',
-				default: `'{"value2"}'`,
-				columnType: 'enum[]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'new_schema',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum type with custom size with default value. custom schema. shuffle enum', async () => {
-	const schema = pgSchema('new_schema');
-
-	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: schema.table('table', {
-			column: enum1('column').array(3).default(['value2']),
-		}),
-	};
-
-	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: schema.table('table', {
-			column: enum2('column').array(3).default(['value2']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::text;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "new_schema"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{"value2"}'::"new_schema"."enum"[3];`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[3] USING "column"::"new_schema"."enum"[3];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: 'new_schema',
-				table: 'table',
-				default: `'{"value2"}'`,
-				columnType: 'enum[3]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'new_schema',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is array enum type with custom size. custom schema. shuffle enum', async () => {
-	const schema = pgSchema('new_schema');
-
-	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: schema.table('table', {
-			column: enum1('column').array(3),
-		}),
-	};
-
-	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: schema.table('table', {
-			column: enum2('column').array(3),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`DROP TYPE "new_schema"."enum";`);
-	expect(sqlStatements[2]).toBe(`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[3] USING "column"::"new_schema"."enum"[3];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: 'new_schema',
-				table: 'table',
-				default: undefined,
-				columnType: 'enum[3]',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'new_schema',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// +
-test('column is enum type without default value. add default to column', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value3'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3';`);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'enum',
-		newDefaultValue: "'value3'",
-		schema: '',
-		tableName: 'table',
-		type: 'alter_table_alter_column_set_default',
-	});
-});
-
-// +
-test('change data type from standart type to enum', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from standart type to enum. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').default('value2'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').default('value3'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3'::"public"."enum";`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value3'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from array standart type to array enum. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array().default(['value2']),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array().default(['value3']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value3"}'::"public"."enum"[];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[] USING "column"::"public"."enum"[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"value3"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum[]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from array standart type to array enum. column without default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[] USING "column"::"public"."enum"[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum[]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from array standart type with custom size to array enum with custom size. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(3).default(['value2']),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3).default(['value3']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value3"}'::"public"."enum"[3];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[3] USING "column"::"public"."enum"[3];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"value3"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum[3]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[3]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from array standart type with custom size to array enum with custom size. column without default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(2),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(2),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum"[2] USING "column"::"public"."enum"[2];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum[2]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[2]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from enum type to standart type', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar;`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from enum type to standart type. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').default('value3'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar;`,
-	);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2';`);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value2'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from array enum type to array standart type', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from array enum with custom size type to array standart type with custom size', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(2),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(2),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[2];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar[2]',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum[2]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-//
-test('change data type from array enum type to array standart type. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array().default(['value2']),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array().default(['value2']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value2"}';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"value2"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from array enum type with custom size to array standart type with custom size. column has default', async () => {
-	const enum1 = pgEnum('enum', ['value1', 'value2']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').array(3).default(['value2']),
-		}),
-	};
-
-	const to = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').array(3).default(['value2']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[3];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"value2"}';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"value2"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'varchar[3]',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum[3]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column'),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type. column has default', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column').default('value3'),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value2'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type. columns are arrays', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column').array(),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column').array(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text[]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type. columns are arrays with custom sizes', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column').array(2),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column').array(2),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[2];`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text[2]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[2]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type. columns are arrays. column has default', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column').array().default(['hello']),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column').array().default(['hello']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"hello"}';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"hello"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text[]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from standart type to standart type. columns are arrays with custom sizes.column has default', async () => {
-	const from = {
-		table: pgTable('table', {
-			column: varchar('column').array(2).default(['hello']),
-		}),
-	};
-
-	const to = {
-		table: pgTable('table', {
-			column: text('column').array(2).default(['hello']),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[2];`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{"hello"}';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: `'{"hello"}'`,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: false,
-			name: 'text[2]',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar[2]',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: undefined,
-	});
-});
-
-// +
-test('change data type from one enum to other', async () => {
-	const enum1 = pgEnum('enum1', ['value1', 'value3']);
-	const enum2 = pgEnum('enum2', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum1('column'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum2" USING "column"::text::"public"."enum2";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: undefined,
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum2',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum1',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from one enum to other. column has default', async () => {
-	const enum1 = pgEnum('enum1', ['value1', 'value3']);
-	const enum2 = pgEnum('enum2', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum1('column').default('value3'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value3'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum2" USING "column"::text::"public"."enum2";`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value3'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum2',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum1',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-// +
-test('change data type from one enum to other. changed defaults', async () => {
-	const enum1 = pgEnum('enum1', ['value1', 'value3']);
-	const enum2 = pgEnum('enum2', ['value1', 'value3']);
-
-	const from = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum1('column').default('value3'),
-		}),
-	};
-
-	const to = {
-		enum1,
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value1'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum2" USING "column"::text::"public"."enum2";`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value1';`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value1'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum2',
-		},
-		oldDataType: {
-			isEnum: true,
-			name: 'enum1',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
-
-test('check filtering json statements. here we have recreate enum + set new type + alter default', async () => {
-	const enum1 = pgEnum('enum1', ['value1', 'value3']);
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: varchar('column').default('value3'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum1', ['value3', 'value1', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum1";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum1" AS ENUM('value3', 'value1', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"public"."enum1";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum1" USING "column"::"public"."enum1";`,
-	);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				columnType: 'enum1',
-				default: "'value2'",
-				table: 'table',
-				tableSchema: '',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		enumSchema: 'public',
-		name: 'enum1',
-		newValues: [
-			'value3',
-			'value1',
-			'value2',
-		],
-		type: 'alter_type_drop_value',
-	});
-	expect(statements[1]).toStrictEqual({
-		columnAutoIncrement: undefined,
-		columnDefault: "'value2'",
-		columnName: 'column',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: {
-			isEnum: true,
-			name: 'enum1',
-		},
-		oldDataType: {
-			isEnum: false,
-			name: 'varchar',
-		},
-		schema: '',
-		tableName: 'table',
-		type: 'pg_alter_table_alter_column_set_type',
-		typeSchema: 'public',
-	});
-});
diff --git a/drizzle-kit/tests/pg-generated.test.ts b/drizzle-kit/tests/pg-generated.test.ts
deleted file mode 100644
index e9f294891f..0000000000
--- a/drizzle-kit/tests/pg-generated.test.ts
+++ /dev/null
@@ -1,529 +0,0 @@
-// test cases
-
-import { SQL, sql } from 'drizzle-orm';
-import { integer, pgTable, text } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('generated as callback: add column with generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '"users"."name" || \'hello\'',
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'to add\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED NOT NULL;',
-	]);
-});
-
-test('generated as callback: drop generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
-	]);
-});
-
-test('generated as callback: change generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'hello\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
-	]);
-});
-
-// ---
-
-test('generated as sql: add column with generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\"users\".\"name\" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '"users"."name" || \'hello\'',
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`\"users\".\"name\" || 'to add'`),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'to add\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED NOT NULL;',
-	]);
-});
-
-test('generated as sql: drop generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\"users\".\"name\" || 'to delete'`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
-	]);
-});
-
-test('generated as sql: change generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\"users\".\"name\"`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\"users\".\"name\" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'hello\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
-	]);
-});
-
-// ---
-
-test('generated as string: add column with generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\"users\".\"name\" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '"users"."name" || \'hello\'',
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`\"users\".\"name\" || 'to add'`),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'to add\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED NOT NULL;',
-	]);
-});
-
-test('generated as string: drop generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\"users\".\"name\" || 'to delete'`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
-	]);
-});
-
-test('generated as string: change generated constraint', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id2: integer('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\"users\".\"name\" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: undefined,
-			columnDefault: undefined,
-			columnGenerated: { as: '"users"."name" || \'hello\'', type: 'stored' },
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" drop column "gen_name";',
-		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
-	]);
-});
diff --git a/drizzle-kit/tests/pg-identity.test.ts b/drizzle-kit/tests/pg-identity.test.ts
deleted file mode 100644
index efb481da30..0000000000
--- a/drizzle-kit/tests/pg-identity.test.ts
+++ /dev/null
@@ -1,447 +0,0 @@
-import { integer, pgSequence, pgTable } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-// same table - no diff
-// 2. identity always/by default - no params +
-// 3. identity always/by default - with a few params +
-// 4. identity always/by default - with all params +
-
-// diff table with create statement
-// 2. identity always/by default - no params +
-// 3. identity always/by default - with a few params +
-// 4. identity always/by default - with all params +
-
-// diff for drop statement
-// 2. identity always/by default - no params, with params +
-
-// diff for alters
-// 2. identity always/by default - no params -> add param +
-// 3. identity always/by default - with a few params - remove/add/change params +
-// 4. identity always/by default - with all params - remove/add/change params +
-
-test('create table: identity always/by default - no params', async () => {
-	const from = {};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'users_id_seq;byDefault;1;2147483647;1;1;1;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			schema: '',
-			policies: [],
-			isRLSEnabled: false,
-			tableName: 'users',
-			type: 'create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1)\n);\n',
-	]);
-});
-
-test('create table: identity always/by default - few params', async () => {
-	const from = {};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'custom_seq;byDefault;1;2147483647;4;1;1;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			policies: [],
-			schema: '',
-			isRLSEnabled: false,
-			tableName: 'users',
-			type: 'create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_seq" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1)\n);\n',
-	]);
-});
-
-test('create table: identity always/by default - all params', async () => {
-	const from = {};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-				minValue: 3,
-				maxValue: 1000,
-				cache: 200,
-				cycle: false,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'custom_seq;byDefault;3;1000;4;3;200;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			policies: [],
-			isRLSEnabled: false,
-			schema: '',
-			tableName: 'users',
-			type: 'create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_seq" INCREMENT BY 4 MINVALUE 3 MAXVALUE 1000 START WITH 3 CACHE 200)\n);\n',
-	]);
-});
-
-test('no diff: identity always/by default - no params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('no diff: identity always/by default - few params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('no diff: identity always/by default - all params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-				minValue: 3,
-				maxValue: 1000,
-				cache: 200,
-				cycle: false,
-			}),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_seq',
-				increment: 4,
-				minValue: 3,
-				maxValue: 1000,
-				cache: 200,
-				cycle: false,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('drop identity from a column - no params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
-	]);
-});
-
-test('drop identity from a column - few params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				increment: 3,
-			}),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
-	]);
-});
-
-test('drop identity from a column - all params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				increment: 3,
-				cache: 100,
-				cycle: true,
-			}),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
-	]);
-});
-
-test('alter identity from a column - no params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;2147483647;1;100;1;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
-	]);
-});
-
-test('alter identity from a column - few params', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				cache: 10,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;2147483647;1;100;10;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;100;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
-	]);
-});
-
-test('alter identity from a column - by default to always', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity({
-				startWith: 100,
-				cache: 10,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;always;1;2147483647;1;100;10;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED ALWAYS;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
-	]);
-});
-
-test('alter identity from a column - always to by default', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity(),
-		}),
-	};
-
-	const to = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				cache: 10,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;2147483647;1;100;10;false',
-			oldIdentity: 'users_id_seq;always;1;2147483647;1;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
-	]);
-});
diff --git a/drizzle-kit/tests/pg-schemas.test.ts b/drizzle-kit/tests/pg-schemas.test.ts
deleted file mode 100644
index d8c724e270..0000000000
--- a/drizzle-kit/tests/pg-schemas.test.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { pgSchema } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('add schema #1', async () => {
-	const to = {
-		devSchema: pgSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'dev',
-	});
-});
-
-test('add schema #2', async () => {
-	const from = {
-		devSchema: pgSchema('dev'),
-	};
-	const to = {
-		devSchema: pgSchema('dev'),
-		devSchema2: pgSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'dev2',
-	});
-});
-
-test('delete schema #1', async () => {
-	const from = {
-		devSchema: pgSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemas(from, {}, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_schema',
-		name: 'dev',
-	});
-});
-
-test('delete schema #2', async () => {
-	const from = {
-		devSchema: pgSchema('dev'),
-		devSchema2: pgSchema('dev2'),
-	};
-	const to = {
-		devSchema: pgSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_schema',
-		name: 'dev2',
-	});
-});
-
-test('rename schema #1', async () => {
-	const from = {
-		devSchema: pgSchema('dev'),
-	};
-	const to = {
-		devSchema2: pgSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, ['dev->dev2']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'dev',
-		to: 'dev2',
-	});
-});
-
-test('rename schema #2', async () => {
-	const from = {
-		devSchema: pgSchema('dev'),
-		devSchema1: pgSchema('dev1'),
-	};
-	const to = {
-		devSchema: pgSchema('dev'),
-		devSchema2: pgSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'dev1',
-		to: 'dev2',
-	});
-});
diff --git a/drizzle-kit/tests/pg-sequences.test.ts b/drizzle-kit/tests/pg-sequences.test.ts
deleted file mode 100644
index 05ca5b1bda..0000000000
--- a/drizzle-kit/tests/pg-sequences.test.ts
+++ /dev/null
@@ -1,298 +0,0 @@
-import { pgSchema, pgSequence } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('create sequence', async () => {
-	const from = {};
-	const to = {
-		seq: pgSequence('name', { startWith: 100 }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'name',
-			schema: 'public',
-			type: 'create_sequence',
-			values: {
-				cache: '1',
-				cycle: false,
-				increment: '1',
-				maxValue: '9223372036854775807',
-				minValue: '1',
-				startWith: '100',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE SEQUENCE "public"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
-	]);
-});
-
-test('create sequence: all fields', async () => {
-	const from = {};
-	const to = {
-		seq: pgSequence('name', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_sequence',
-			name: 'name',
-			schema: 'public',
-			values: {
-				startWith: '100',
-				maxValue: '10000',
-				minValue: '100',
-				cycle: true,
-				cache: '10',
-				increment: '2',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE SEQUENCE "public"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
-	]);
-});
-
-test('create sequence: custom schema', async () => {
-	const customSchema = pgSchema('custom');
-	const from = {};
-	const to = {
-		seq: customSchema.sequence('name', { startWith: 100 }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'name',
-			schema: 'custom',
-			type: 'create_sequence',
-			values: {
-				cache: '1',
-				cycle: false,
-				increment: '1',
-				maxValue: '9223372036854775807',
-				minValue: '1',
-				startWith: '100',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE SEQUENCE "custom"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
-	]);
-});
-
-test('create sequence: custom schema + all fields', async () => {
-	const customSchema = pgSchema('custom');
-	const from = {};
-	const to = {
-		seq: customSchema.sequence('name', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_sequence',
-			name: 'name',
-			schema: 'custom',
-			values: {
-				startWith: '100',
-				maxValue: '10000',
-				minValue: '100',
-				cycle: true,
-				cache: '10',
-				increment: '2',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE SEQUENCE "custom"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
-	]);
-});
-
-test('drop sequence', async () => {
-	const from = { seq: pgSequence('name', { startWith: 100 }) };
-	const to = {};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'drop_sequence',
-			name: 'name',
-			schema: 'public',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['DROP SEQUENCE "public"."name";']);
-});
-
-test('drop sequence: custom schema', async () => {
-	const customSchema = pgSchema('custom');
-	const from = { seq: customSchema.sequence('name', { startWith: 100 }) };
-	const to = {};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'drop_sequence',
-			name: 'name',
-			schema: 'custom',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['DROP SEQUENCE "custom"."name";']);
-});
-
-// rename sequence
-
-test('rename sequence', async () => {
-	const from = { seq: pgSequence('name', { startWith: 100 }) };
-	const to = { seq: pgSequence('name_new', { startWith: 100 }) };
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.name->public.name_new',
-	]);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'rename_sequence',
-			nameFrom: 'name',
-			nameTo: 'name_new',
-			schema: 'public',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "public"."name" RENAME TO "name_new";',
-	]);
-});
-
-test('rename sequence in custom schema', async () => {
-	const customSchema = pgSchema('custom');
-
-	const from = { seq: customSchema.sequence('name', { startWith: 100 }) };
-	const to = { seq: customSchema.sequence('name_new', { startWith: 100 }) };
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'custom.name->custom.name_new',
-	]);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'rename_sequence',
-			nameFrom: 'name',
-			nameTo: 'name_new',
-			schema: 'custom',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "custom"."name" RENAME TO "name_new";',
-	]);
-});
-
-test('move sequence between schemas #1', async () => {
-	const customSchema = pgSchema('custom');
-	const from = { seq: pgSequence('name', { startWith: 100 }) };
-	const to = { seq: customSchema.sequence('name', { startWith: 100 }) };
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'public.name->custom.name',
-	]);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'move_sequence',
-			name: 'name',
-			schemaFrom: 'public',
-			schemaTo: 'custom',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "public"."name" SET SCHEMA "custom";',
-	]);
-});
-
-test('move sequence between schemas #2', async () => {
-	const customSchema = pgSchema('custom');
-	const from = { seq: customSchema.sequence('name', { startWith: 100 }) };
-	const to = { seq: pgSequence('name', { startWith: 100 }) };
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, [
-		'custom.name->public.name',
-	]);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'move_sequence',
-			name: 'name',
-			schemaFrom: 'custom',
-			schemaTo: 'public',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "custom"."name" SET SCHEMA "public";',
-	]);
-});
-
-// Add squasher for sequences to make alters work +
-// Run all tests +
-// Finish introspect for sequences +
-// Check push for sequences +
-
-// add tests for generated to postgresql +
-// add tests for generated to mysql +
-// add tests for generated to sqlite +
-
-// add tests for identity to postgresql
-
-// check introspect generated(all dialects) +
-// check push generated(all dialect) +
-
-// add introspect ts file logic for all the features
-// manually test everything
-// beta release
-
-test('alter sequence', async () => {
-	const from = { seq: pgSequence('name', { startWith: 100 }) };
-	const to = { seq: pgSequence('name', { startWith: 105 }) };
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'name',
-			schema: 'public',
-			type: 'alter_sequence',
-			values: {
-				cache: '1',
-				cycle: false,
-				increment: '1',
-				maxValue: '9223372036854775807',
-				minValue: '1',
-				startWith: '105',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "public"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 105 CACHE 1;',
-	]);
-});
diff --git a/drizzle-kit/tests/pg-tables.test.ts b/drizzle-kit/tests/pg-tables.test.ts
deleted file mode 100644
index 4ca01f1fe7..0000000000
--- a/drizzle-kit/tests/pg-tables.test.ts
+++ /dev/null
@@ -1,957 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-	AnyPgColumn,
-	foreignKey,
-	geometry,
-	index,
-	integer,
-	pgEnum,
-	pgSchema,
-	pgSequence,
-	pgTable,
-	pgTableCreator,
-	primaryKey,
-	serial,
-	text,
-	unique,
-	uniqueIndex,
-	vector,
-} from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('add table #1', async () => {
-	const to = {
-		users: pgTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [],
-		compositePKs: [],
-		policies: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-		isRLSEnabled: false,
-		compositePkName: '',
-	});
-});
-
-test('add table #2', async () => {
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'serial',
-			},
-		],
-		compositePKs: [],
-		isRLSEnabled: false,
-		policies: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-		compositePkName: '',
-	});
-});
-
-test('add table #3', async () => {
-	const to = {
-		users: pgTable(
-			'users',
-			{
-				id: serial('id'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({
-						name: 'users_pk',
-						columns: [t.id],
-					}),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'serial',
-			},
-		],
-		compositePKs: ['id;users_pk'],
-		policies: [],
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		checkConstraints: [],
-		compositePkName: 'users_pk',
-	});
-});
-
-test('add table #4', async () => {
-	const to = {
-		users: pgTable('users', {}),
-		posts: pgTable('posts', {}),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [],
-		compositePKs: [],
-		policies: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-		isRLSEnabled: false,
-		compositePkName: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'posts',
-		policies: [],
-		schema: '',
-		columns: [],
-		compositePKs: [],
-		isRLSEnabled: false,
-		uniqueConstraints: [],
-		checkConstraints: [],
-		compositePkName: '',
-	});
-});
-
-test('add table #5', async () => {
-	const schema = pgSchema('folder');
-	const from = {
-		schema,
-	};
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: 'folder',
-		columns: [],
-		compositePKs: [],
-		policies: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-		isRLSEnabled: false,
-	});
-});
-
-test('add table #6', async () => {
-	const from = {
-		users1: pgTable('users1', {}),
-	};
-
-	const to = {
-		users2: pgTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users2',
-		schema: '',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		policies: [],
-		compositePkName: '',
-		checkConstraints: [],
-		isRLSEnabled: false,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'drop_table',
-		policies: [],
-		tableName: 'users1',
-		schema: '',
-	});
-});
-
-test('add table #7', async () => {
-	const from = {
-		users1: pgTable('users1', {}),
-	};
-
-	const to = {
-		users: pgTable('users', {}),
-		users2: pgTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'public.users1->public.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [],
-		compositePKs: [],
-		policies: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		isRLSEnabled: false,
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users1',
-		tableNameTo: 'users2',
-		fromSchema: '',
-		toSchema: '',
-	});
-});
-
-test('add table #8: geometry types', async () => {
-	const from = {};
-
-	const to = {
-		users: pgTable('users', {
-			geom: geometry('geom', { type: 'point' }).notNull(),
-			geom1: geometry('geom1').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-
-	expect(sqlStatements).toStrictEqual([
-		`CREATE TABLE "users" (\n\t"geom" geometry(point) NOT NULL,\n\t"geom1" geometry(point) NOT NULL\n);\n`,
-	]);
-});
-
-test('multiproject schema add table #1', async () => {
-	const table = pgTableCreator((name) => `prefix_${name}`);
-
-	const to = {
-		users: table('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'prefix_users',
-		schema: '',
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'serial',
-			},
-		],
-		compositePKs: [],
-		policies: [],
-		compositePkName: '',
-		isRLSEnabled: false,
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('multiproject schema drop table #1', async () => {
-	const table = pgTableCreator((name) => `prefix_${name}`);
-
-	const from = {
-		users: table('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {};
-
-	const { statements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		schema: '',
-		tableName: 'prefix_users',
-		type: 'drop_table',
-		policies: [],
-	});
-});
-
-test('multiproject schema alter table name #1', async () => {
-	const table = pgTableCreator((name) => `prefix_${name}`);
-
-	const from = {
-		users: table('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		users1: table('users1', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'public.prefix_users->public.prefix_users1',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_table',
-		fromSchema: '',
-		toSchema: '',
-		tableNameFrom: 'prefix_users',
-		tableNameTo: 'prefix_users1',
-	});
-});
-
-test('add table #8: column with pgvector', async () => {
-	const from = {};
-
-	const to = {
-		users2: pgTable('users2', {
-			id: serial('id').primaryKey(),
-			name: vector('name', { dimensions: 3 }),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE "users2" (\n\t"id" serial PRIMARY KEY NOT NULL,\n\t"name" vector(3)\n);
-`,
-	);
-});
-
-test('add schema + table #1', async () => {
-	const schema = pgSchema('folder');
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'folder',
-	});
-
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: 'folder',
-		policies: [],
-		columns: [],
-		compositePKs: [],
-		isRLSEnabled: false,
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-});
-
-test('change schema with tables #1', async () => {
-	const schema = pgSchema('folder');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, ['folder->folder2']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'folder',
-		to: 'folder2',
-	});
-});
-
-test('change table schema #1', async () => {
-	const schema = pgSchema('folder');
-	const from = {
-		schema,
-		users: pgTable('users', {}),
-	};
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'public.users->folder.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'public',
-		schemaTo: 'folder',
-	});
-});
-
-test('change table schema #2', async () => {
-	const schema = pgSchema('folder');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema,
-		users: pgTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder.users->public.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'folder',
-		schemaTo: 'public',
-	});
-});
-
-test('change table schema #3', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-});
-
-test('change table schema #4', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-});
-
-test('change table schema #5', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1, // remove schema
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(3);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'drop_schema',
-		name: 'folder1',
-	});
-});
-
-test('change table schema #5', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users2', {}), // rename and move table
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder1.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_set_schema',
-		tableName: 'users',
-		schemaFrom: 'folder1',
-		schemaTo: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users',
-		tableNameTo: 'users2',
-		fromSchema: 'folder2',
-		toSchema: 'folder2',
-	});
-});
-
-test('change table schema #6', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // rename schema
-		users: schema2.table('users2', {}), // rename table
-	};
-
-	const { statements } = await diffTestSchemas(from, to, [
-		'folder1->folder2',
-		'folder2.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'folder1',
-		to: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users',
-		tableNameTo: 'users2',
-		fromSchema: 'folder2',
-		toSchema: 'folder2',
-	});
-});
-
-test('drop table + rename schema #1', async () => {
-	const schema1 = pgSchema('folder1');
-	const schema2 = pgSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // rename schema
-		// drop table
-	};
-
-	const { statements } = await diffTestSchemas(from, to, ['folder1->folder2']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_schema',
-		from: 'folder1',
-		to: 'folder2',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'drop_table',
-		tableName: 'users',
-		schema: 'folder2',
-		policies: [],
-	});
-});
-
-test('create table with tsvector', async () => {
-	const from = {};
-	const to = {
-		users: pgTable(
-			'posts',
-			{
-				id: serial('id').primaryKey(),
-				title: text('title').notNull(),
-				description: text('description').notNull(),
-			},
-			(table) => ({
-				titleSearchIndex: index('title_search_index').using(
-					'gin',
-					sql`to_tsvector('english', ${table.title})`,
-				),
-			}),
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "posts" (\n\t"id" serial PRIMARY KEY NOT NULL,\n\t"title" text NOT NULL,\n\t"description" text NOT NULL\n);\n',
-		`CREATE INDEX "title_search_index" ON "posts" USING gin (to_tsvector('english', "title"));`,
-	]);
-});
-
-test('composite primary key', async () => {
-	const from = {};
-	const to = {
-		table: pgTable('works_to_creators', {
-			workId: integer('work_id').notNull(),
-			creatorId: integer('creator_id').notNull(),
-			classification: text('classification').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				columns: [t.workId, t.creatorId, t.classification],
-			}),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "works_to_creators" (\n\t"work_id" integer NOT NULL,\n\t"creator_id" integer NOT NULL,\n\t"classification" text NOT NULL,\n\tCONSTRAINT "works_to_creators_work_id_creator_id_classification_pk" PRIMARY KEY("work_id","creator_id","classification")\n);\n',
-	]);
-});
-
-test('add column before creating unique constraint', async () => {
-	const from = {
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const to = {
-		table: pgTable('table', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		}, (t) => ({
-			uq: unique('uq').on(t.name),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "table" ADD COLUMN "name" text NOT NULL;',
-		'ALTER TABLE "table" ADD CONSTRAINT "uq" UNIQUE("name");',
-	]);
-});
-
-test('alter composite primary key', async () => {
-	const from = {
-		table: pgTable('table', {
-			col1: integer('col1').notNull(),
-			col2: integer('col2').notNull(),
-			col3: text('col3').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				name: 'table_pk',
-				columns: [t.col1, t.col2],
-			}),
-		})),
-	};
-	const to = {
-		table: pgTable('table', {
-			col1: integer('col1').notNull(),
-			col2: integer('col2').notNull(),
-			col3: text('col3').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				name: 'table_pk',
-				columns: [t.col2, t.col3],
-			}),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "table" DROP CONSTRAINT "table_pk";\n--> statement-breakpoint\nALTER TABLE "table" ADD CONSTRAINT "table_pk" PRIMARY KEY("col2","col3");',
-	]);
-});
-
-test('add index with op', async () => {
-	const from = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-	const to = {
-		users: pgTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		}, (t) => ({
-			nameIdx: index().using('gin', t.name.op('gin_trgm_ops')),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE INDEX "users_name_index" ON "users" USING gin ("name" gin_trgm_ops);',
-	]);
-});
-
-test('optional db aliases (snake case)', async () => {
-	const from = {};
-
-	const t1 = pgTable(
-		't1',
-		{
-			t1Id1: integer().notNull().primaryKey(),
-			t1Col2: integer().notNull(),
-			t1Col3: integer().notNull(),
-			t2Ref: integer().notNull().references(() => t2.t2Id),
-			t1Uni: integer().notNull(),
-			t1UniIdx: integer().notNull(),
-			t1Idx: integer().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1_uni').on(table.t1Uni),
-			uniIdx: uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
-			idx: index('t1_idx').on(table.t1Idx).where(sql`${table.t1Idx} > 0`),
-			fk: foreignKey({
-				columns: [table.t1Col2, table.t1Col3],
-				foreignColumns: [t3.t3Id1, t3.t3Id2],
-			}),
-		}),
-	);
-
-	const t2 = pgTable(
-		't2',
-		{
-			t2Id: serial().primaryKey(),
-		},
-	);
-
-	const t3 = pgTable(
-		't3',
-		{
-			t3Id1: integer(),
-			t3Id2: integer(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3Id1, table.t3Id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, [], false, 'snake_case');
-
-	const st1 = `CREATE TABLE "t1" (
-	"t1_id1" integer PRIMARY KEY NOT NULL,
-	"t1_col2" integer NOT NULL,
-	"t1_col3" integer NOT NULL,
-	"t2_ref" integer NOT NULL,
-	"t1_uni" integer NOT NULL,
-	"t1_uni_idx" integer NOT NULL,
-	"t1_idx" integer NOT NULL,
-	CONSTRAINT "t1_uni" UNIQUE("t1_uni")
-);
-`;
-
-	const st2 = `CREATE TABLE "t2" (
-	"t2_id" serial PRIMARY KEY NOT NULL
-);
-`;
-
-	const st3 = `CREATE TABLE "t3" (
-	"t3_id1" integer,
-	"t3_id2" integer,
-	CONSTRAINT "t3_t3_id1_t3_id2_pk" PRIMARY KEY("t3_id1","t3_id2")
-);
-`;
-
-	const st4 =
-		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t2_ref_t2_t2_id_fk" FOREIGN KEY ("t2_ref") REFERENCES "public"."t2"("t2_id") ON DELETE no action ON UPDATE no action;`;
-
-	const st5 =
-		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fk" FOREIGN KEY ("t1_col2","t1_col3") REFERENCES "public"."t3"("t3_id1","t3_id2") ON DELETE no action ON UPDATE no action;`;
-
-	const st6 = `CREATE UNIQUE INDEX "t1_uni_idx" ON "t1" USING btree ("t1_uni_idx");`;
-
-	const st7 = `CREATE INDEX "t1_idx" ON "t1" USING btree ("t1_idx") WHERE "t1"."t1_idx" > 0;`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
-});
-
-test('optional db aliases (camel case)', async () => {
-	const from = {};
-
-	const t1 = pgTable(
-		't1',
-		{
-			t1_id1: integer().notNull().primaryKey(),
-			t1_col2: integer().notNull(),
-			t1_col3: integer().notNull(),
-			t2_ref: integer().notNull().references(() => t2.t2_id),
-			t1_uni: integer().notNull(),
-			t1_uni_idx: integer().notNull(),
-			t1_idx: integer().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1Uni').on(table.t1_uni),
-			uni_idx: uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
-			idx: index('t1Idx').on(table.t1_idx).where(sql`${table.t1_idx} > 0`),
-			fk: foreignKey({
-				columns: [table.t1_col2, table.t1_col3],
-				foreignColumns: [t3.t3_id1, t3.t3_id2],
-			}),
-		}),
-	);
-
-	const t2 = pgTable(
-		't2',
-		{
-			t2_id: serial().primaryKey(),
-		},
-	);
-
-	const t3 = pgTable(
-		't3',
-		{
-			t3_id1: integer(),
-			t3_id2: integer(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3_id1, table.t3_id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemas(from, to, [], false, 'camelCase');
-
-	const st1 = `CREATE TABLE "t1" (
-	"t1Id1" integer PRIMARY KEY NOT NULL,
-	"t1Col2" integer NOT NULL,
-	"t1Col3" integer NOT NULL,
-	"t2Ref" integer NOT NULL,
-	"t1Uni" integer NOT NULL,
-	"t1UniIdx" integer NOT NULL,
-	"t1Idx" integer NOT NULL,
-	CONSTRAINT "t1Uni" UNIQUE("t1Uni")
-);
-`;
-
-	const st2 = `CREATE TABLE "t2" (
-	"t2Id" serial PRIMARY KEY NOT NULL
-);
-`;
-
-	const st3 = `CREATE TABLE "t3" (
-	"t3Id1" integer,
-	"t3Id2" integer,
-	CONSTRAINT "t3_t3Id1_t3Id2_pk" PRIMARY KEY("t3Id1","t3Id2")
-);
-`;
-
-	const st4 =
-		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t2Ref_t2_t2Id_fk" FOREIGN KEY ("t2Ref") REFERENCES "public"."t2"("t2Id") ON DELETE no action ON UPDATE no action;`;
-
-	const st5 =
-		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fk" FOREIGN KEY ("t1Col2","t1Col3") REFERENCES "public"."t3"("t3Id1","t3Id2") ON DELETE no action ON UPDATE no action;`;
-
-	const st6 = `CREATE UNIQUE INDEX "t1UniIdx" ON "t1" USING btree ("t1UniIdx");`;
-
-	const st7 = `CREATE INDEX "t1Idx" ON "t1" USING btree ("t1Idx") WHERE "t1"."t1Idx" > 0;`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6, st7]);
-});
diff --git a/drizzle-kit/tests/pg-views.test.ts b/drizzle-kit/tests/pg-views.test.ts
deleted file mode 100644
index 4f24cd7762..0000000000
--- a/drizzle-kit/tests/pg-views.test.ts
+++ /dev/null
@@ -1,1929 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { integer, pgMaterializedView, pgSchema, pgTable, pgView } from 'drizzle-orm/pg-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemas } from './schemaDiffer';
-
-test('create table and view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view: pgView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		compositePkName: '',
-		checkConstraints: [],
-		policies: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view',
-		definition: `select "id" from "users"`,
-		schema: 'public',
-		with: undefined,
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE VIEW "public"."some_view" AS (select "id" from "users");`);
-});
-
-test('create table and view #2', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		compositePkName: '',
-		policies: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view',
-		definition: `SELECT * FROM "users"`,
-		schema: 'public',
-		with: undefined,
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE VIEW "public"."some_view" AS (SELECT * FROM "users");`);
-});
-
-test('create table and view #3', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgView('some_view1', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: false,
-			securityInvoker: true,
-		}).as(sql`SELECT * FROM ${users}`),
-		view2: pgView('some_view2').with({
-			checkOption: 'cascaded',
-			securityBarrier: true,
-			securityInvoker: false,
-		}).as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(3);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		checkConstraints: [],
-		isRLSEnabled: false,
-		policies: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view1',
-		definition: `SELECT * FROM "users"`,
-		schema: 'public',
-		with: {
-			checkOption: 'local',
-			securityBarrier: false,
-			securityInvoker: true,
-		},
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view2',
-		definition: `select "id" from "users"`,
-		schema: 'public',
-		with: {
-			checkOption: 'cascaded',
-			securityBarrier: true,
-			securityInvoker: false,
-		},
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE VIEW "public"."some_view1" WITH (check_option = local, security_barrier = false, security_invoker = true) AS (SELECT * FROM "users");`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`CREATE VIEW "public"."some_view2" WITH (check_option = cascaded, security_barrier = true, security_invoker = false) AS (select "id" from "users");`,
-	);
-});
-
-test('create table and view #4', async () => {
-	const schema = pgSchema('new_schema');
-
-	const users = schema.table('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		schema,
-		users: users,
-		view1: schema.view('some_view1', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: false,
-			securityInvoker: true,
-		}).as(sql`SELECT * FROM ${users}`),
-		view2: schema.view('some_view2').with({
-			checkOption: 'cascaded',
-			securityBarrier: true,
-			securityInvoker: false,
-		}).as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(4);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'new_schema',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: 'new_schema',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		isRLSEnabled: false,
-		policies: [],
-		checkConstraints: [],
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view1',
-		definition: `SELECT * FROM "new_schema"."users"`,
-		schema: 'new_schema',
-		with: {
-			checkOption: 'local',
-			securityBarrier: false,
-			securityInvoker: true,
-		},
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-	expect(statements[3]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view2',
-		definition: `select "id" from "new_schema"."users"`,
-		schema: 'new_schema',
-		with: {
-			checkOption: 'cascaded',
-			securityBarrier: true,
-			securityInvoker: false,
-		},
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(`CREATE SCHEMA "new_schema";\n`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE "new_schema"."users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`CREATE VIEW "new_schema"."some_view1" WITH (check_option = local, security_barrier = false, security_invoker = true) AS (SELECT * FROM "new_schema"."users");`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`CREATE VIEW "new_schema"."some_view2" WITH (check_option = cascaded, security_barrier = true, security_invoker = false) AS (select "id" from "new_schema"."users");`,
-	);
-});
-
-test('create table and view #5', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-		view2: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	await expect(diffTestSchemas({}, to, [])).rejects.toThrowError();
-});
-
-test('create table and view #6', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgView('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		compositePkName: '',
-		schema: '',
-		tableName: 'users',
-		type: 'create_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-		isRLSEnabled: false,
-		policies: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		definition: 'SELECT * FROM "users"',
-		name: 'some_view',
-		schema: 'public',
-		type: 'create_view',
-		with: {
-			checkOption: 'cascaded',
-		},
-		materialized: false,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE VIEW "public"."some_view" WITH (check_option = cascaded) AS (SELECT * FROM "users");`,
-	);
-});
-
-test('create view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-	};
-
-	const to = {
-		users: users,
-		view1: pgView('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('create table and materialized view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		policies: [],
-		compositePkName: '',
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view',
-		definition: `select "id" from "users"`,
-		schema: 'public',
-		with: undefined,
-		materialized: true,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE MATERIALIZED VIEW "public"."some_view" AS (select "id" from "users");`);
-});
-
-test('create table and materialized view #2', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		isRLSEnabled: false,
-		policies: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view',
-		definition: `SELECT * FROM "users"`,
-		schema: 'public',
-		with: undefined,
-		materialized: true,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE MATERIALIZED VIEW "public"."some_view" AS (SELECT * FROM "users");`);
-});
-
-test('create table and materialized view #3', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgMaterializedView('some_view1', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-		view2: pgMaterializedView('some_view2').tablespace('some_tablespace').using('heap').withNoData().with({
-			autovacuumEnabled: true,
-			autovacuumFreezeMaxAge: 1,
-			autovacuumFreezeMinAge: 1,
-			autovacuumFreezeTableAge: 1,
-			autovacuumMultixactFreezeMaxAge: 1,
-			autovacuumMultixactFreezeMinAge: 1,
-			autovacuumMultixactFreezeTableAge: 1,
-			autovacuumVacuumCostDelay: 1,
-			autovacuumVacuumCostLimit: 1,
-			autovacuumVacuumScaleFactor: 1,
-			autovacuumVacuumThreshold: 1,
-			fillfactor: 1,
-			logAutovacuumMinDuration: 1,
-			parallelWorkers: 1,
-			toastTupleTarget: 1,
-			userCatalogTable: true,
-			vacuumIndexCleanup: 'off',
-			vacuumTruncate: false,
-		}).as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(3);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: '',
-		columns: [{
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		compositePkName: '',
-		policies: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view1',
-		definition: `SELECT * FROM "users"`,
-		schema: 'public',
-		with: undefined,
-		materialized: true,
-		withNoData: false,
-		using: undefined,
-		tablespace: undefined,
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'create_view',
-		name: 'some_view2',
-		definition: `select "id" from "users"`,
-		schema: 'public',
-		with: {
-			autovacuumEnabled: true,
-			autovacuumFreezeMaxAge: 1,
-			autovacuumFreezeMinAge: 1,
-			autovacuumFreezeTableAge: 1,
-			autovacuumMultixactFreezeMaxAge: 1,
-			autovacuumMultixactFreezeMinAge: 1,
-			autovacuumMultixactFreezeTableAge: 1,
-			autovacuumVacuumCostDelay: 1,
-			autovacuumVacuumCostLimit: 1,
-			autovacuumVacuumScaleFactor: 1,
-			autovacuumVacuumThreshold: 1,
-			fillfactor: 1,
-			logAutovacuumMinDuration: 1,
-			parallelWorkers: 1,
-			toastTupleTarget: 1,
-			userCatalogTable: true,
-			vacuumIndexCleanup: 'off',
-			vacuumTruncate: false,
-		},
-		materialized: true,
-		tablespace: 'some_tablespace',
-		using: 'heap',
-		withNoData: true,
-	});
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE MATERIALIZED VIEW "public"."some_view1" AS (SELECT * FROM "users");`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`CREATE MATERIALIZED VIEW "public"."some_view2" USING "heap" WITH (autovacuum_enabled = true, autovacuum_freeze_max_age = 1, autovacuum_freeze_min_age = 1, autovacuum_freeze_table_age = 1, autovacuum_multixact_freeze_max_age = 1, autovacuum_multixact_freeze_min_age = 1, autovacuum_multixact_freeze_table_age = 1, autovacuum_vacuum_cost_delay = 1, autovacuum_vacuum_cost_limit = 1, autovacuum_vacuum_scale_factor = 1, autovacuum_vacuum_threshold = 1, fillfactor = 1, log_autovacuum_min_duration = 1, parallel_workers = 1, toast_tuple_target = 1, user_catalog_table = true, vacuum_index_cleanup = off, vacuum_truncate = false) TABLESPACE some_tablespace AS (select "id" from "users") WITH NO DATA;`,
-	);
-});
-
-test('create table and materialized view #4', async () => {
-	// same names
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-		view2: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	await expect(diffTestSchemas({}, to, [])).rejects.toThrowError();
-});
-
-test('create table and materialized view #5', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-	const to = {
-		users: users,
-		view1: pgMaterializedView('some_view', { id: integer('id') }).with({ autovacuumFreezeMinAge: 14 }).as(
-			sql`SELECT * FROM ${users}`,
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		compositePkName: '',
-		schema: '',
-		tableName: 'users',
-		type: 'create_table',
-		uniqueConstraints: [],
-		isRLSEnabled: false,
-		policies: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toEqual({
-		definition: 'SELECT * FROM "users"',
-		name: 'some_view',
-		schema: 'public',
-		type: 'create_view',
-		with: {
-			autovacuumFreezeMinAge: 14,
-		},
-		materialized: true,
-		tablespace: undefined,
-		using: undefined,
-		withNoData: false,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE "users" (
-\t"id" integer PRIMARY KEY NOT NULL
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE MATERIALIZED VIEW "public"."some_view" WITH (autovacuum_freeze_min_age = 14) AS (SELECT * FROM "users");`,
-	);
-});
-
-test('create materialized view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-	};
-
-	const to = {
-		users: users,
-		view1: pgMaterializedView('some_view', { id: integer('id') }).with({ autovacuumEnabled: true }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_view',
-		name: 'some_view',
-		schema: 'public',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP VIEW "public"."some_view";`);
-});
-
-test('drop view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop materialized view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
-	};
-
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_view',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP MATERIALIZED VIEW "public"."some_view";`);
-});
-
-test('drop materialized view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		users: users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view #1', async () => {
-	const from = {
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		view: pgView('new_some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_view',
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-		schema: 'public',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER VIEW "public"."some_view" RENAME TO "new_some_view";`);
-});
-
-test('rename view with existing flag', async () => {
-	const from = {
-		view: pgView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		view: pgView('new_some_view', { id: integer('id') }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename materialized view #1', async () => {
-	const from = {
-		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		view: pgMaterializedView('new_some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_view',
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-		schema: 'public',
-		materialized: true,
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`ALTER MATERIALIZED VIEW "public"."some_view" RENAME TO "new_some_view";`);
-});
-
-test('rename materialized view with existing flag', async () => {
-	const from = {
-		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		view: pgMaterializedView('new_some_view', { id: integer('id') }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('view alter schema', async () => {
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		schema,
-		view: schema.view('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->new_schema.some_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'new_schema',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_view_alter_schema',
-		toSchema: 'new_schema',
-		fromSchema: 'public',
-		name: 'some_view',
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE SCHEMA "new_schema";\n`);
-	expect(sqlStatements[1]).toBe(`ALTER VIEW "public"."some_view" SET SCHEMA "new_schema";`);
-});
-
-test('view alter schema with existing flag', async () => {
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		view: pgView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		schema,
-		view: schema.view('some_view', { id: integer('id') }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->new_schema.some_view']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'new_schema',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE SCHEMA "new_schema";\n`);
-});
-
-test('view alter schema for materialized', async () => {
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		schema,
-		view: schema.materializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->new_schema.some_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'new_schema',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_view_alter_schema',
-		toSchema: 'new_schema',
-		fromSchema: 'public',
-		name: 'some_view',
-		materialized: true,
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE SCHEMA "new_schema";\n`);
-	expect(sqlStatements[1]).toBe(`ALTER MATERIALIZED VIEW "public"."some_view" SET SCHEMA "new_schema";`);
-});
-
-test('view alter schema for materialized with existing flag', async () => {
-	const schema = pgSchema('new_schema');
-
-	const from = {
-		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const to = {
-		schema,
-		view: schema.materializedView('some_view', { id: integer('id') }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->new_schema.some_view']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_schema',
-		name: 'new_schema',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE SCHEMA "new_schema";\n`);
-});
-
-test('add with option to view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_add_with_option',
-		with: {
-			checkOption: 'cascaded',
-			securityBarrier: true,
-		},
-		materialized: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER VIEW "public"."some_view" SET (check_option = cascaded, security_barrier = true);`,
-	);
-});
-
-test('add with option to view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', {}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view', {}).with({ checkOption: 'cascaded', securityBarrier: true }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('add with option to materialized view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumMultixactFreezeMaxAge: 3 }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_add_with_option',
-		with: {
-			autovacuumMultixactFreezeMaxAge: 3,
-		},
-		materialized: true,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET (autovacuum_multixact_freeze_max_age = 3);`,
-	);
-});
-
-test('add with option to materialized view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', {}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', {}).with({ autovacuumMultixactFreezeMaxAge: 3 }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop with option from view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_drop_with_option',
-		materialized: false,
-		with: {
-			checkOption: 'cascaded',
-			securityBarrier: true,
-			securityInvoker: true,
-		},
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER VIEW "public"."some_view" RESET (check_option, security_barrier, security_invoker);`,
-	);
-});
-
-test('drop with option from view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', {}).with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true })
-			.existing(),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view', {}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop with option from materialized view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, autovacuumFreezeMaxAge: 10 }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_drop_with_option',
-		materialized: true,
-		with: {
-			autovacuumEnabled: true,
-			autovacuumFreezeMaxAge: 10,
-		},
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" RESET (autovacuum_enabled, autovacuum_freeze_max_age);`,
-	);
-});
-
-test('drop with option from materialized view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true, autovacuumFreezeMaxAge: 10 }).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', {}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter with option in view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view').with({ securityBarrier: true, securityInvoker: true }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view').with({ securityBarrier: true }).as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_drop_with_option',
-		with: {
-			securityInvoker: true,
-		},
-		materialized: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER VIEW "public"."some_view" RESET (security_invoker);`,
-	);
-});
-
-test('alter with option in view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', {}).with({ securityBarrier: true, securityInvoker: true }).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view', {}).with({ securityBarrier: true }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter with option in materialized view #1', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, autovacuumVacuumScaleFactor: 1 }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true }).as((qb) => qb.select().from(users)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'some_view',
-		schema: 'public',
-		type: 'alter_view_drop_with_option',
-		with: {
-			autovacuumVacuumScaleFactor: 1,
-		},
-		materialized: true,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" RESET (autovacuum_vacuum_scale_factor);`,
-	);
-});
-
-test('alter with option in materialized view with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true, autovacuumVacuumScaleFactor: 1 })
-			.existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter with option in view #2', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view').with({ checkOption: 'local', securityBarrier: true, securityInvoker: true }).as((qb) =>
-			qb.selectDistinct().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true }).as((qb) =>
-			qb.selectDistinct().from(users)
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_view_add_with_option',
-		name: 'some_view',
-		schema: 'public',
-		with: {
-			checkOption: 'cascaded',
-		},
-		materialized: false,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-
-	expect(sqlStatements[0]).toBe(
-		`ALTER VIEW "public"."some_view" SET (check_option = cascaded);`,
-	);
-});
-
-test('alter with option in materialized view #2', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, fillfactor: 1 }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view').with({ autovacuumEnabled: false, fillfactor: 1 }).as((qb) =>
-			qb.select().from(users)
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_view_add_with_option',
-		name: 'some_view',
-		schema: 'public',
-		with: {
-			autovacuumEnabled: false,
-		},
-		materialized: true,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET (autovacuum_enabled = false);`,
-	);
-});
-
-test('alter view ".as" value', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: true,
-			securityInvoker: true,
-		}).as(sql`SELECT '123'`),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: true,
-			securityInvoker: true,
-		}).as(sql`SELECT '1234'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual(
-		{
-			name: 'some_view',
-			schema: 'public',
-			type: 'drop_view',
-		},
-	);
-	expect(statements[1]).toStrictEqual(
-		{
-			definition: "SELECT '1234'",
-			name: 'some_view',
-			schema: 'public',
-			type: 'create_view',
-			materialized: false,
-			with: {
-				checkOption: 'local',
-				securityBarrier: true,
-				securityInvoker: true,
-			},
-			withNoData: false,
-			tablespace: undefined,
-			using: undefined,
-		},
-	);
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe('DROP VIEW "public"."some_view";');
-	expect(sqlStatements[1]).toBe(
-		`CREATE VIEW "public"."some_view" WITH (check_option = local, security_barrier = true, security_invoker = true) AS (SELECT '1234');`,
-	);
-});
-
-test('alter view ".as" value with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: true,
-			securityInvoker: true,
-		}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).with({
-			checkOption: 'local',
-			securityBarrier: true,
-			securityInvoker: true,
-		}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter materialized view ".as" value', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT '123'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT '1234'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual(
-		{
-			name: 'some_view',
-			schema: 'public',
-			type: 'drop_view',
-			materialized: true,
-		},
-	);
-	expect(statements[1]).toStrictEqual(
-		{
-			definition: "SELECT '1234'",
-			name: 'some_view',
-			schema: 'public',
-			type: 'create_view',
-			with: {
-				autovacuumVacuumCostLimit: 1,
-			},
-			materialized: true,
-			withNoData: false,
-			tablespace: undefined,
-			using: undefined,
-		},
-	);
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe('DROP MATERIALIZED VIEW "public"."some_view";');
-	expect(sqlStatements[1]).toBe(
-		`CREATE MATERIALIZED VIEW "public"."some_view" WITH (autovacuum_vacuum_cost_limit = 1) AS (SELECT '1234');`,
-	);
-});
-
-test('alter materialized view ".as" value with existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop existing flag', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toEqual({
-		type: 'drop_view',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-	});
-	expect(statements[1]).toEqual({
-		definition: "SELECT 'asd'",
-		materialized: true,
-		name: 'some_view',
-		schema: 'public',
-		tablespace: undefined,
-		type: 'create_view',
-		using: undefined,
-		with: {
-			autovacuumVacuumCostLimit: 1,
-		},
-		withNoData: false,
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`DROP MATERIALIZED VIEW "public"."some_view";`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE MATERIALIZED VIEW "public"."some_view" WITH (autovacuum_vacuum_cost_limit = 1) AS (SELECT 'asd');`,
-	);
-});
-
-test('alter tablespace - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('some_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('new_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_tablespace',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toTablespace: 'new_tablespace',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET TABLESPACE new_tablespace;`,
-	);
-});
-
-test('set tablespace - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('new_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_tablespace',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toTablespace: 'new_tablespace',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET TABLESPACE new_tablespace;`,
-	);
-});
-
-test('drop tablespace - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('new_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_tablespace',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toTablespace: 'pg_default',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET TABLESPACE pg_default;`,
-	);
-});
-
-test('set existing - materialized', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('new_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('new_some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-			autovacuumFreezeMinAge: 1,
-		}).withNoData().existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(0);
-
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop existing - materialized', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('new_tablespace').with({
-			autovacuumVacuumCostLimit: 1,
-		}).existing(),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-			autovacuumFreezeMinAge: 1,
-		}).withNoData().as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(2);
-
-	expect(sqlStatements.length).toBe(2);
-});
-
-test('set existing', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgView('some_view', { id: integer('id') }).with({
-			checkOption: 'cascaded',
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgView('new_some_view', { id: integer('id') }).with({
-			checkOption: 'cascaded',
-			securityBarrier: true,
-		}).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(0);
-
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('alter using - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('some_tablespace').using('some_using').with(
-			{
-				autovacuumVacuumCostLimit: 1,
-			},
-		).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('some_tablespace').using('new_using').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_using',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toUsing: 'new_using',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET ACCESS METHOD "new_using";`,
-	);
-});
-
-test('set using - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).using('new_using').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_using',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toUsing: 'new_using',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET ACCESS METHOD "new_using";`,
-	);
-});
-
-test('drop using - materialize', async () => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey().notNull(),
-	});
-
-	const from = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).using('new_using').with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const to = {
-		users,
-		view: pgMaterializedView('some_view', { id: integer('id') }).with({
-			autovacuumVacuumCostLimit: 1,
-		}).as(sql`SELECT 'asd'`),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toEqual({
-		type: 'alter_view_alter_using',
-		name: 'some_view',
-		schema: 'public',
-		materialized: true,
-		toUsing: 'heap',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."some_view" SET ACCESS METHOD "heap";`,
-	);
-});
-
-test('rename view and alter view', async () => {
-	const from = {
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		view: pgView('new_some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(
-			sql`SELECT * FROM "users"`,
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->public.new_some_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_view',
-		nameFrom: 'some_view',
-		nameTo: 'new_some_view',
-		schema: 'public',
-	});
-	expect(statements[1]).toStrictEqual({
-		materialized: false,
-		name: 'new_some_view',
-		schema: 'public',
-		type: 'alter_view_add_with_option',
-		with: {
-			checkOption: 'cascaded',
-		},
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER VIEW "public"."some_view" RENAME TO "new_some_view";`);
-	expect(sqlStatements[1]).toBe(`ALTER VIEW "public"."new_some_view" SET (check_option = cascaded);`);
-});
-
-test('moved schema and alter view', async () => {
-	const schema = pgSchema('my_schema');
-	const from = {
-		schema,
-		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
-	};
-
-	const to = {
-		schema,
-		view: schema.view('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(
-			sql`SELECT * FROM "users"`,
-		),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(from, to, ['public.some_view->my_schema.some_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		fromSchema: 'public',
-		name: 'some_view',
-		toSchema: 'my_schema',
-		type: 'alter_view_alter_schema',
-	});
-	expect(statements[1]).toStrictEqual({
-		name: 'some_view',
-		schema: 'my_schema',
-		type: 'alter_view_add_with_option',
-		materialized: false,
-		with: {
-			checkOption: 'cascaded',
-		},
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER VIEW "public"."some_view" SET SCHEMA "my_schema";`);
-	expect(sqlStatements[1]).toBe(`ALTER VIEW "my_schema"."some_view" SET (check_option = cascaded);`);
-});
diff --git a/drizzle-kit/tests/postgres/commutativity.integration.test.ts b/drizzle-kit/tests/postgres/commutativity.integration.test.ts
new file mode 100644
index 0000000000..eb9ffd0714
--- /dev/null
+++ b/drizzle-kit/tests/postgres/commutativity.integration.test.ts
@@ -0,0 +1,391 @@
+import { sql } from 'drizzle-orm';
+import { check, index, pgSchema, pgTable, primaryKey } from 'drizzle-orm/pg-core';
+import { describe, expect, test } from 'vitest';
+import { conflictsFromSchema } from './mocks';
+
+describe('conflict rule coverage (statement pairs)', () => {
+	test('column: create vs drop (same-resource-different-op)', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+				d: t.varchar(),
+			})),
+		};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('column: alter vs alter (same-resource-same-op)', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar().notNull(),
+			})),
+		};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				c: t.integer(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('table drop vs child index', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			}), (table) => [index().on(table.c)]),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('table drop vs new column on same table', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+				d: t.varchar(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('index: create vs create on different tables is commutative', async () => {
+		const parent = {
+			orders: pgTable('orders', (t) => ({
+				customerId: t.varchar(),
+			})),
+			invoices: pgTable('invoices', (t) => ({
+				accountId: t.varchar(),
+			})),
+		};
+
+		const child1 = {
+			orders: pgTable('orders', (t) => ({
+				customerId: t.varchar(),
+			}), (table) => [index().on(table.customerId)]),
+			invoices: pgTable('invoices', (t) => ({
+				accountId: t.varchar(),
+			})),
+		};
+
+		const child2 = {
+			orders: pgTable('orders', (t) => ({
+				customerId: t.varchar(),
+			})),
+			invoices: pgTable('invoices', (t) => ({
+				accountId: t.varchar(),
+			}), (table) => [index().on(table.accountId)]),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('pk: alter vs drop', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				id: t.integer().primaryKey(),
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {
+			t: pgTable('t', (t) => ({
+				id: t.integer(),
+				c: t.varchar(),
+			}), (table) => [primaryKey({ columns: [table.id, table.c] })]),
+		};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				id: t.integer(),
+				c: t.varchar(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('unique: create vs drop', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar().unique(),
+			})),
+		};
+
+		const child1 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar().unique(),
+				d: t.varchar().unique(),
+			})),
+		};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('fk: recreate vs drop', async () => {
+		const p = pgTable('p', (t) => ({
+			id: t.integer().primaryKey(),
+		}));
+
+		const parent = {
+			p,
+			t: pgTable('t', (t) => ({
+				id: t.integer().primaryKey(),
+				pId: t.integer().references(() => p.id),
+			})),
+		};
+
+		const child1 = {
+			p,
+			t: pgTable('t', (t) => ({
+				id: t.integer().primaryKey(),
+				pId: t.integer().references(() => p.id, { onDelete: 'cascade' }),
+			})),
+		};
+
+		const child2 = {
+			p,
+			t: pgTable('t', (t) => ({
+				id: t.integer().primaryKey(),
+				pId: t.integer(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('check: alter vs drop', async () => {
+		const parent = {
+			t: pgTable('t', (t) => ({
+				c: t.integer(),
+			}), (table) => [check('chk', sql`${table.c} > 0`)]),
+		};
+
+		const child1 = {
+			t: pgTable('t', (t) => ({
+				c: t.integer(),
+			}), (table) => [check('chk', sql`${table.c} > 5`)]),
+		};
+
+		const child2 = {
+			t: pgTable('t', (t) => ({
+				c: t.integer(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('schema drop vs new table in same schema', async () => {
+		const app = pgSchema('app');
+
+		const parent = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+			profiles: app.table('profiles', (t) => ({
+				id: t.integer(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('schema drop vs new enum in same schema', async () => {
+		const app = pgSchema('app');
+
+		const parent = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+			status: app.enum('status', ['pending', 'done']),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+	});
+
+	test('schema drop vs new table in different schema is commutative', async () => {
+		const app = pgSchema('app');
+		const analytics = pgSchema('analytics');
+
+		const parent = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+		};
+
+		const child1 = {};
+
+		const child2 = {
+			app,
+			users: app.table('users', (t) => ({
+				id: t.integer(),
+			})),
+			analytics,
+			events: analytics.table('events', (t) => ({
+				id: t.integer(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).toBeUndefined();
+	});
+
+	test('explainConflicts returns reason for table drop vs column alter', async () => {
+		const parent = {
+			c: pgTable('t', (t) => ({
+				c: t.varchar(),
+			})),
+		};
+
+		const child1 = {};
+		const child2 = {
+			c: pgTable('t', (t) => ({
+				c: t.varchar().notNull(),
+			})),
+		};
+
+		const conflicts = await conflictsFromSchema({
+			parent: { id: '1', schema: parent },
+			child1: { id: '2', prevId: '1', schema: child1 },
+			child2: { id: '3', prevId: '1', schema: child2 },
+		});
+
+		expect(conflicts).not.toBeUndefined();
+		expect(conflicts?.leftStatement.type).toBe('alter_column');
+		expect(conflicts?.rightStatement.type).toBe('drop_table');
+	});
+});
diff --git a/drizzle-kit/tests/postgres/commutativity.test.ts b/drizzle-kit/tests/postgres/commutativity.test.ts
new file mode 100644
index 0000000000..0ed94f128b
--- /dev/null
+++ b/drizzle-kit/tests/postgres/commutativity.test.ts
@@ -0,0 +1,1460 @@
+import { postgresCommutativity } from 'src/dialects/postgres/commutativity';
+import { createDDL } from 'src/dialects/postgres/ddl';
+import type { PostgresSnapshot } from 'src/dialects/postgres/snapshot';
+import { describe, expect, test } from 'vitest';
+
+const baseId = '00000000-0000-0000-0000-000000000000';
+
+function makeSnapshot(id: string, prevIds: string[], ddlEntities: any[] = []): PostgresSnapshot {
+	return {
+		version: '8',
+		dialect: 'postgres',
+		id,
+		prevIds,
+		ddl: ddlEntities,
+		renames: [],
+	} as any;
+}
+
+function writeTempSnapshot(dir: string, tag: string, snap: PostgresSnapshot) {
+	const fs = require('fs');
+	const path = require('path');
+	const folder = path.join(dir, tag);
+	fs.mkdirSync(folder, { recursive: true });
+	fs.writeFileSync(path.join(folder, 'snapshot.json'), JSON.stringify(snap, null, 2));
+	return path.join(folder, 'snapshot.json');
+}
+
+const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+function mkTmp(): { tmp: string; fs: any; path: any; os: any } {
+	const fs = require('fs');
+	const path = require('path');
+	const os = require('os');
+	const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'dk-comm-int-'));
+	return { tmp, fs, path, os } as any;
+}
+
+describe('commutativity integration (postgres)', () => {
+	test('Parent not empty: detects conflict when first migration of branch A has a conflict with the last migration of branch B', async () => {
+		const parentDDL = createDDL();
+		parentDDL.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		parentDDL.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const parent = makeSnapshot('p1', [baseId], parentDDL.entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		A.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const A2 = createDDL();
+		A2.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		A2.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email2',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA2 = makeSnapshot('a2', ['a1'], A2.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		B.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B.columns.push({
+			schema: 'public',
+			table: 'posts',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+		const B2 = createDDL();
+		B2.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		B2.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		B2.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B2.columns.push({
+			schema: 'public',
+			table: 'posts',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB2 = makeSnapshot('b2', ['b1'], B2.entities.list());
+
+		const B3 = createDDL();
+		B3.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B3.columns.push({
+			schema: 'public',
+			table: 'posts',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB3 = makeSnapshot('b3', ['b2'], B3.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const a2Path = writeTempSnapshot(tmp, '001_leafA2', leafA2);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+		const b2Path = writeTempSnapshot(tmp, '002_leafB2', leafB2);
+		const b3Path = writeTempSnapshot(tmp, '002_leafB3', leafB3);
+
+		const report = await postgresCommutativity.detectNonCommutative([pPath, aPath, bPath, b2Path, b3Path, a2Path]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('Parent empty: detects conflict when last migration of branch A has a conflict with a first migration of branch B', async () => {
+		const parent = makeSnapshot('p1', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		A.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const A2 = createDDL();
+		A2.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		A2.columns.push({
+			schema: 'public',
+			table: 'posts',
+			name: 'description',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA2 = makeSnapshot('a2', ['a1'], A2.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+		const B2 = createDDL();
+		B2.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B2.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB2 = makeSnapshot('b2', ['b1'], B2.entities.list());
+
+		const B3 = createDDL();
+		B3.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		B3.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'content',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		B3.tables.push({ schema: 'public', isRlsEnabled: false, name: 'media' });
+		B3.columns.push({
+			schema: 'public',
+			table: 'media',
+			name: 'url',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB3 = makeSnapshot('b3', ['b2'], B3.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const a2Path = writeTempSnapshot(tmp, '002_leafA2', leafA2);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+		const b2Path = writeTempSnapshot(tmp, '003_leafB2', leafB2);
+		const b3Path = writeTempSnapshot(tmp, '004_leafB3', leafB3);
+
+		const report = await postgresCommutativity.detectNonCommutative([pPath, aPath, a2Path, bPath, b2Path, b3Path]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('detects conflict when drop table in one branch and add column in other', async () => {
+		const parentDDL = createDDL();
+		parentDDL.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		parentDDL.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const parent = makeSnapshot('p1', [baseId], parentDDL.entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		A.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const leafB = makeSnapshot('b1', ['p1'], createDDL().entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+		const report = await postgresCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('detects conflict when both branches alter same column', async () => {
+		const parent = makeSnapshot('p1', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		A.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: false,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafA = makeSnapshot('a1', ['p1'], A.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		B.columns.push({
+			schema: 'public',
+			table: 'users',
+			name: 'email',
+			type: 'varchar',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const leafB = makeSnapshot('b1', ['p1'], B.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+		const report = await postgresCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('no conflict when branches touch different tables', async () => {
+		const parent = makeSnapshot('p2', [baseId], createDDL().entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		const leafA = makeSnapshot('a2', ['p2'], A.entities.list());
+
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'posts' });
+		const leafB = makeSnapshot('b2', ['p2'], B.entities.list());
+
+		const os = require('os');
+		const tmp = require('fs').mkdtempSync(require('path').join(os.tmpdir(), 'dk-comm-'));
+		const pPath = writeTempSnapshot(tmp, '000_parent', parent);
+		const aPath = writeTempSnapshot(tmp, '001_leafA', leafA);
+		const bPath = writeTempSnapshot(tmp, '002_leafB', leafB);
+
+		const report = await postgresCommutativity.detectNonCommutative([pPath, aPath, bPath]);
+		expect(report.conflicts.length).toBe(0);
+	});
+
+	test('column conflict: both branches change same column', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		const p = makeSnapshot('p_col', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		a.columns.push(
+			{
+				schema: 'public',
+				table: 'users',
+				name: 'email',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 'users' });
+		b.columns.push(
+			{
+				schema: 'public',
+				table: 'users',
+				name: 'email',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '000_p_col', p),
+			writeTempSnapshot(tmp, '001_a_col', makeSnapshot('a_col', ['p_col'], a.entities.list())),
+			writeTempSnapshot(tmp, '002_b_col', makeSnapshot('b_col', ['p_col'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('table drop vs child column alter', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 't1' });
+		parent.columns.push(
+			{
+				schema: 'public',
+				table: 't1',
+				name: 'c1',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const p = makeSnapshot('p_drop', [ORIGIN], parent.entities.list());
+
+		const a = createDDL(); // dropping table in branch A (no t1)
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 't1' });
+		b.columns.push(
+			{
+				schema: 'public',
+				table: 't1',
+				name: 'c1',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '010_p_drop', p),
+			writeTempSnapshot(tmp, '011_a_drop', makeSnapshot('a_drop', ['p_drop'], a.entities.list())),
+			writeTempSnapshot(tmp, '012_b_drop', makeSnapshot('b_drop', ['p_drop'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBe(1);
+		expect(report.conflicts[0].branchA.chain[report.conflicts[0].branchA.chain.length - 1].id).toStrictEqual('a_drop');
+		expect(report.conflicts[0].branchB.chain[report.conflicts[0].branchB.chain.length - 1].id).toStrictEqual('b_drop');
+		const con = report.conflicts[0];
+
+		// console.log(
+		// 	`The conflict in your migrations was detected. Starting from a ${con.parentId} we've detected 2 branches of migrations that are conflicting. A file with conflicted migration for a first branch in ${con.branchA.chain[con.branchA.chain.length - 1].id} and second branch is ${con.branchB.chain[con.branchB.chain.length - 1].id}.\n\n${con.branchA.statementDescription} statement from first branch is conflicting with ${con.branchB.statementDescription}`,
+		// );
+	});
+
+	test('schema drop conflicts with new table in the same schema', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.schemas.push({ name: 'app' } as any);
+		parent.tables.push({ schema: 'app', isRlsEnabled: false, name: 'users' } as any);
+		parent.columns.push({
+			schema: 'app',
+			table: 'users',
+			name: 'id',
+			type: 'integer',
+			options: null,
+			typeSchema: 'pg_catalog',
+			notNull: true,
+			dimensions: 0,
+			default: null,
+			generated: null,
+			identity: null,
+		} as any);
+		const p = makeSnapshot('p_drop_schema', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+
+		const b = createDDL();
+		b.schemas.push({ name: 'app' } as any);
+		b.tables.push({ schema: 'app', isRlsEnabled: false, name: 'users' } as any);
+		b.tables.push({ schema: 'app', isRlsEnabled: false, name: 'profiles' } as any);
+		b.columns.push(
+			{
+				schema: 'app',
+				table: 'users',
+				name: 'id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+			{
+				schema: 'app',
+				table: 'profiles',
+				name: 'id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '013_p_drop_schema', p),
+			writeTempSnapshot(tmp, '014_a_drop_schema', makeSnapshot('a_drop_schema', ['p_drop_schema'], a.entities.list())),
+			writeTempSnapshot(tmp, '015_b_drop_schema', makeSnapshot('b_drop_schema', ['p_drop_schema'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('create indexes on different tables do not conflict', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 'orders' });
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 'invoices' });
+		parent.columns.push(
+			{
+				schema: 'public',
+				table: 'orders',
+				name: 'customer_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+			{
+				schema: 'public',
+				table: 'invoices',
+				name: 'account_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const p = makeSnapshot('p_idx', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 'orders' });
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 'invoices' });
+		a.columns.push(
+			{
+				schema: 'public',
+				table: 'orders',
+				name: 'customer_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+			{
+				schema: 'public',
+				table: 'invoices',
+				name: 'account_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		a.indexes.push({
+			schema: 'public',
+			table: 'orders',
+			name: 'orders_customer_id_idx',
+			columns: [{ value: 'customer_id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+			isUnique: false,
+			where: null,
+			with: '',
+			concurrently: false,
+			method: 'btree',
+			nameExplicit: true,
+		} as any);
+
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 'orders' });
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 'invoices' });
+		b.columns.push(
+			{
+				schema: 'public',
+				table: 'orders',
+				name: 'customer_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+			{
+				schema: 'public',
+				table: 'invoices',
+				name: 'account_id',
+				type: 'integer',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		b.indexes.push({
+			schema: 'public',
+			table: 'invoices',
+			name: 'invoices_account_id_idx',
+			columns: [{ value: 'account_id', isExpression: false, opclass: null, nullsFirst: false, asc: false }],
+			isUnique: false,
+			where: null,
+			with: '',
+			concurrently: false,
+			method: 'btree',
+			nameExplicit: true,
+		} as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '020_p_idx', p),
+			writeTempSnapshot(tmp, '021_a_idx', makeSnapshot('a_idx', ['p_idx'], a.entities.list())),
+			writeTempSnapshot(tmp, '022_b_idx', makeSnapshot('b_idx', ['p_idx'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+	});
+
+	test('unique constraint same name on same table', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 't2' });
+		const p = makeSnapshot('p_uq', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 't2' });
+		a.uniques.push(
+			{
+				schema: 'public',
+				table: 't2',
+				nameExplicit: true,
+				name: 't2_uq',
+				columns: ['c'],
+				nullsNotDistinct: false,
+			} as any,
+		);
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 't2' });
+		b.uniques.push(
+			{
+				schema: 'public',
+				table: 't2',
+				nameExplicit: true,
+				name: 't2_uq',
+				columns: ['c'],
+				nullsNotDistinct: false,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '020_p_uq', p),
+			writeTempSnapshot(tmp, '021_a_uq', makeSnapshot('a_uq', ['p_uq'], a.entities.list())),
+			writeTempSnapshot(tmp, '022_b_uq', makeSnapshot('b_uq', ['p_uq'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('view: same name in both branches', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const p = makeSnapshot('p_view', [ORIGIN], createDDL().entities.list());
+		const a = createDDL();
+		a.views.push(
+			{
+				schema: 'public',
+				name: 'v1',
+				materialized: false,
+				definition: null,
+				with: null,
+				withNoData: null,
+				using: { name: 'sql', default: true },
+				tablespace: null,
+			} as any,
+		);
+		const b = createDDL();
+		b.views.push(
+			{
+				schema: 'public',
+				name: 'v1',
+				materialized: false,
+				definition: null,
+				with: null,
+				withNoData: null,
+				using: { name: 'sql', default: true },
+				tablespace: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '030_p_view', p),
+			writeTempSnapshot(tmp, '031_a_view', makeSnapshot('a_view', ['p_view'], a.entities.list())),
+			writeTempSnapshot(tmp, '032_b_view', makeSnapshot('b_view', ['p_view'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('enum: same name in both branches', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const p = makeSnapshot('p_enum', [ORIGIN], createDDL().entities.list());
+		const a = createDDL();
+		a.enums.push({ schema: 'public', name: 'e1', values: ['a'] } as any);
+		const b = createDDL();
+		b.enums.push({ schema: 'public', name: 'e1', values: ['a'] } as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '040_p_enum', p),
+			writeTempSnapshot(tmp, '041_a_enum', makeSnapshot('a_enum', ['p_enum'], a.entities.list())),
+			writeTempSnapshot(tmp, '042_b_enum', makeSnapshot('b_enum', ['p_enum'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('sequence: same name in both branches', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const p = makeSnapshot('p_seq', [ORIGIN], createDDL().entities.list());
+		const a = createDDL();
+		a.sequences.push(
+			{
+				schema: 'public',
+				name: 's1',
+				incrementBy: null,
+				minValue: null,
+				maxValue: null,
+				startWith: null,
+				cacheSize: null,
+				cycle: null,
+			} as any,
+		);
+		const b = createDDL();
+		b.sequences.push(
+			{
+				schema: 'public',
+				name: 's1',
+				incrementBy: null,
+				minValue: null,
+				maxValue: null,
+				startWith: null,
+				cacheSize: null,
+				cycle: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '050_p_seq', p),
+			writeTempSnapshot(tmp, '051_a_seq', makeSnapshot('a_seq', ['p_seq'], a.entities.list())),
+			writeTempSnapshot(tmp, '052_b_seq', makeSnapshot('b_seq', ['p_seq'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('policy: same name on same table in both branches', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 't3' });
+		const p = makeSnapshot('p_pol', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 't3' });
+		a.policies.push(
+			{
+				schema: 'public',
+				table: 't3',
+				name: 'pol',
+				as: 'PERMISSIVE',
+				for: 'SELECT',
+				roles: ['PUBLIC'],
+				using: null,
+				withCheck: null,
+			} as any,
+		);
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 't3' });
+		b.policies.push(
+			{
+				schema: 'public',
+				table: 't3',
+				name: 'pol',
+				as: 'PERMISSIVE',
+				for: 'SELECT',
+				roles: ['PUBLIC'],
+				using: null,
+				withCheck: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '060_p_pol', p),
+			writeTempSnapshot(tmp, '061_a_pol', makeSnapshot('a_pol', ['p_pol'], a.entities.list())),
+			writeTempSnapshot(tmp, '062_b_pol', makeSnapshot('b_pol', ['p_pol'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('RLS toggle conflict for the same table', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 't_rls' });
+		const p = makeSnapshot('p_rls', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: true, name: 't_rls' });
+		a.policies.push(
+			{
+				schema: 'public',
+				table: 't_rls',
+				name: 'p_rls',
+				as: 'PERMISSIVE',
+				for: 'SELECT',
+				roles: ['PUBLIC'],
+				using: null,
+				withCheck: null,
+			} as any,
+		);
+
+		const b = createDDL(); // simulate drop by omitting table
+
+		files.push(
+			writeTempSnapshot(tmp, '070_p_rls', p),
+			writeTempSnapshot(tmp, '071_a_rls', makeSnapshot('a_rls', ['p_rls'], a.entities.list())),
+			writeTempSnapshot(tmp, '072_b_rls', makeSnapshot('b_rls', ['p_rls'], b.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('three-way branch: A,B,C from same parent', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const parent = createDDL();
+		parent.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		const p = makeSnapshot('p_three', [ORIGIN], parent.entities.list());
+
+		const a = createDDL();
+		a.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		a.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'a',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const b = createDDL();
+		b.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		b.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'a',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const c = createDDL();
+		c.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		c.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'b',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '100_p_three', p),
+			writeTempSnapshot(tmp, '101_a_three', makeSnapshot('a_three', ['p_three'], a.entities.list())),
+			writeTempSnapshot(tmp, '102_b_three', makeSnapshot('b_three', ['p_three'], b.entities.list())),
+			writeTempSnapshot(tmp, '103_c_three', makeSnapshot('c_three', ['p_three'], c.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		// At least A vs B should conflict; C may or may not depending on overlap
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('nested branching: parent -> A -> A1 and parent -> B', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const root = createDDL();
+		root.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		const p = makeSnapshot('p_nested', [ORIGIN], root.entities.list());
+
+		const A = createDDL();
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		A.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'c',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const A1 = createDDL();
+		A1.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		A1.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'c',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 't' });
+		B.columns.push(
+			{
+				schema: 'public',
+				table: 't',
+				name: 'd',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: false,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+
+		files.push(
+			writeTempSnapshot(tmp, '110_p_nested', p),
+			writeTempSnapshot(tmp, '111_A', makeSnapshot('A', ['p_nested'], A.entities.list())),
+			writeTempSnapshot(tmp, '112_A1', makeSnapshot('A1', ['A'], A1.entities.list())),
+			writeTempSnapshot(tmp, '113_B', makeSnapshot('B', ['p_nested'], B.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		// A1 vs B should be compared (different initial children: A vs B), and should conflict on column 'c' vs 'd'? Only if overlap; ensure conflict by changing B to touch 'c'
+		expect(report.conflicts.length).toBeGreaterThanOrEqual(0);
+	});
+
+	test('complex mixed: multiple tables, enums, views, and policies diverging', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const base = createDDL();
+		base.tables.push({ schema: 'public', isRlsEnabled: false, name: 'u' });
+		base.tables.push({ schema: 'public', isRlsEnabled: false, name: 'p' });
+		const p = makeSnapshot('p_mix', [ORIGIN], base.entities.list());
+
+		// Branch X: alter u.email, create view v_users, enum e1
+		const X = createDDL();
+		X.tables.push({ schema: 'public', isRlsEnabled: false, name: 'u' });
+		X.columns.push(
+			{
+				schema: 'public',
+				table: 'u',
+				name: 'email',
+				type: 'varchar',
+				options: null,
+				typeSchema: 'pg_catalog',
+				notNull: true,
+				dimensions: 0,
+				default: null,
+				generated: null,
+				identity: null,
+			} as any,
+		);
+		X.views.push(
+			{
+				schema: 'public',
+				name: 'v_users',
+				materialized: false,
+				definition: null,
+				with: null,
+				withNoData: null,
+				using: { name: 'sql', default: true },
+				tablespace: null,
+			} as any,
+		);
+		X.enums.push({ schema: 'public', name: 'e1', values: ['a'] } as any);
+
+		// Branch Y: drop table u (conflicts with X's column/view touching u), policy on p
+		const Y = createDDL();
+		Y.tables.push({ schema: 'public', isRlsEnabled: false, name: 'p' });
+		Y.policies.push(
+			{
+				schema: 'public',
+				table: 'p',
+				name: 'pol_p',
+				as: 'PERMISSIVE',
+				for: 'SELECT',
+				roles: ['PUBLIC'],
+				using: null,
+				withCheck: null,
+			} as any,
+		);
+		// no table u -> implies drop vs X touching u
+
+		files.push(
+			writeTempSnapshot(tmp, '120_p_mix', p),
+			writeTempSnapshot(tmp, '121_X', makeSnapshot('X', ['p_mix'], X.entities.list())),
+			writeTempSnapshot(tmp, '122_Y', makeSnapshot('Y', ['p_mix'], Y.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('complex schema and moves: rename, move, drop schema/table conflicts', async () => {
+		const { tmp } = mkTmp();
+		const files: string[] = [];
+
+		const base = createDDL();
+		base.schemas.push({ name: 's1' } as any);
+		base.tables.push({ schema: 's1', isRlsEnabled: false, name: 't1' } as any);
+		base.tables.push({ schema: 'public', isRlsEnabled: false, name: 'common_table' } as any);
+		const p = makeSnapshot('p_schema_move', [ORIGIN], base.entities.list());
+
+		// Branch A: rename schema s1 to s2, move t1 from s1 to s2.t1
+		const A = createDDL();
+		A.schemas.push({ name: 's2' } as any);
+		A.tables.push({ schema: 's2', isRlsEnabled: false, name: 't1' } as any);
+		A.tables.push({ schema: 'public', isRlsEnabled: false, name: 'common_table' } as any);
+
+		// Branch B: drop schema s1, create table in public schema
+		const B = createDDL();
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'new_table_in_public' } as any);
+		B.tables.push({ schema: 'public', isRlsEnabled: false, name: 'common_table' } as any);
+		// implicitly drops schema s1 and t1 within it
+
+		// Branch C: alter common_table in public, create new schema s3
+		const C = createDDL();
+		C.schemas.push({ name: 's1' } as any);
+		C.schemas.push({ name: 's3' } as any);
+		C.tables.push({ schema: 's1', isRlsEnabled: false, name: 't1' } as any);
+		C.tables.push({ schema: 'public', isRlsEnabled: false, name: 'common_table' } as any);
+		C.columns.push({ schema: 'public', table: 'common_table', name: 'new_col', type: 'text' } as any);
+
+		files.push(
+			writeTempSnapshot(tmp, '130_p_schema_move', p),
+			writeTempSnapshot(tmp, '131_A', makeSnapshot('A_schema_move', ['p_schema_move'], A.entities.list())),
+			writeTempSnapshot(tmp, '132_B', makeSnapshot('B_schema_move', ['p_schema_move'], B.entities.list())),
+			writeTempSnapshot(tmp, '133_C', makeSnapshot('C_schema_move', ['p_schema_move'], C.entities.list())),
+		);
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		// Expect conflicts between A and B (s1 rename vs drop)
+		// Expect conflicts between A and C (s1 operations)
+		// Expect conflicts between B and C (s1 drop vs s1 operations)
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('fork closed by a merge node is not reported as an open commutative branch', async () => {
+		// init (a, b)
+		// ├── add-c (a, b, c)    \  merged
+		// └── add-d (a, b, d)    /
+		// drop-b (a, c, d)       <- merge node: prevIds = [add-c, add-d]
+		// ├── add-g (a, c, d, g) \  open commutative fork
+		// └── add-h (a, c, d, h) /
+		const { tmp } = mkTmp();
+
+		const tablesDDL = (names: string[]) => {
+			const ddl = createDDL();
+			for (const name of names) {
+				ddl.tables.push({ schema: 'public', isRlsEnabled: false, name } as any);
+			}
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '140_init', makeSnapshot('init', [ORIGIN], tablesDDL(['a', 'b']))),
+			writeTempSnapshot(tmp, '141_add_c', makeSnapshot('add_c', ['init'], tablesDDL(['a', 'b', 'c']))),
+			writeTempSnapshot(tmp, '142_add_d', makeSnapshot('add_d', ['init'], tablesDDL(['a', 'b', 'd']))),
+			writeTempSnapshot(tmp, '143_drop_b', makeSnapshot('drop_b', ['add_c', 'add_d'], tablesDDL(['a', 'c', 'd']))),
+			writeTempSnapshot(tmp, '144_add_g', makeSnapshot('add_g', ['drop_b'], tablesDDL(['a', 'c', 'd', 'g']))),
+			writeTempSnapshot(tmp, '145_add_h', makeSnapshot('add_h', ['drop_b'], tablesDDL(['a', 'c', 'd', 'h']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+
+		expect(report.conflicts).toStrictEqual([]);
+		expect(new Set(report.leafNodes)).toStrictEqual(new Set(['add_g', 'add_h']));
+
+		const branches = report.commutativeBranches ?? [];
+		expect(
+			branches.map((branch) => branch.parentId),
+			"expected only the merge node (the open heads' divergence point) to be offered as a composition base",
+		).toStrictEqual(['drop_b']);
+		expect(new Set(branches[0].leafs.map((leaf) => leaf.id))).toStrictEqual(new Set(['add_g', 'add_h']));
+		for (const leaf of branches[0].leafs) {
+			expect(leaf.statements.map((statement) => (statement as any).type)).toStrictEqual(['create_table']);
+		}
+	});
+
+	test('nested open fork: all open heads merge at their lowest common ancestor', async () => {
+		// p
+		// ├── a (leaf)
+		// └── b
+		//     ├── bx (leaf)
+		//     └── by (leaf)
+		// All three heads are open and pairwise commutative, so they merge in one
+		// step. The base is their lowest common ancestor, p — not the deeper fork b.
+		// bx and by both inherit b's migration through their shared segment, so
+		// diff(p->bx) and diff(p->by) each carry `create b`; the consumer
+		// de-duplicates it before replaying onto p.
+		const { tmp } = mkTmp();
+
+		const tablesDDL = (names: string[]) => {
+			const ddl = createDDL();
+			for (const name of names) {
+				ddl.tables.push({ schema: 'public', isRlsEnabled: false, name } as any);
+			}
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '170_p', makeSnapshot('p_deep', [ORIGIN], tablesDDL(['t']))),
+			writeTempSnapshot(tmp, '171_a', makeSnapshot('a_deep', ['p_deep'], tablesDDL(['t', 'a']))),
+			writeTempSnapshot(tmp, '172_b', makeSnapshot('b_deep', ['p_deep'], tablesDDL(['t', 'b']))),
+			writeTempSnapshot(tmp, '173_bx', makeSnapshot('bx_deep', ['b_deep'], tablesDDL(['t', 'b', 'x']))),
+			writeTempSnapshot(tmp, '174_by', makeSnapshot('by_deep', ['b_deep'], tablesDDL(['t', 'b', 'y']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+
+		expect(report.conflicts).toStrictEqual([]);
+		expect(new Set(report.leafNodes)).toStrictEqual(new Set(['a_deep', 'bx_deep', 'by_deep']));
+
+		const branches = report.commutativeBranches ?? [];
+		expect(branches.map((branch) => branch.parentId)).toStrictEqual(['p_deep']);
+		expect(new Set(branches[0].leafs.map((leaf) => leaf.id))).toStrictEqual(
+			new Set(['a_deep', 'bx_deep', 'by_deep']),
+		);
+
+		// bx and by each carry the inherited `create b`, so the raw per-head diffs
+		// overlap; the merge migration de-duplicates them down to one create per
+		// table (t already exists at the base p).
+		const byId = Object.fromEntries(branches[0].leafs.map((leaf) => [leaf.id, leaf.statements]));
+		const tableNames = (statements: unknown[]) => statements.map((statement) => (statement as any).table?.name).sort();
+		expect(tableNames(byId['a_deep'])).toStrictEqual(['a']);
+		expect(tableNames(byId['bx_deep'])).toStrictEqual(['b', 'x']);
+		expect(tableNames(byId['by_deep'])).toStrictEqual(['b', 'y']);
+	});
+
+	test('partially merged fork: children sharing a merged leaf still compose', async () => {
+		// p
+		// ├── a \  merged into m (leaf)
+		// ├── b /
+		// └── c (leaf)
+		// Every child funnels to a single leaf (a and b both to m), so p is a
+		// valid composition base for the open heads {m, c}: diff(p->m) carries
+		// both merged branches exactly once, diff(p->c) is disjoint from it.
+		const { tmp } = mkTmp();
+
+		const tablesDDL = (names: string[]) => {
+			const ddl = createDDL();
+			for (const name of names) {
+				ddl.tables.push({ schema: 'public', isRlsEnabled: false, name } as any);
+			}
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '180_p', makeSnapshot('p_part', [ORIGIN], tablesDDL(['t']))),
+			writeTempSnapshot(tmp, '181_a', makeSnapshot('a_part', ['p_part'], tablesDDL(['t', 'a']))),
+			writeTempSnapshot(tmp, '182_b', makeSnapshot('b_part', ['p_part'], tablesDDL(['t', 'b']))),
+			writeTempSnapshot(tmp, '183_m', makeSnapshot('m_part', ['a_part', 'b_part'], tablesDDL(['t', 'a', 'b']))),
+			writeTempSnapshot(tmp, '184_c', makeSnapshot('c_part', ['p_part'], tablesDDL(['t', 'c']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+
+		expect(report.conflicts).toStrictEqual([]);
+
+		const branches = report.commutativeBranches ?? [];
+		expect(branches.map((branch) => branch.parentId)).toStrictEqual(['p_part']);
+		expect(new Set(branches[0].leafs.map((leaf) => leaf.id))).toStrictEqual(new Set(['m_part', 'c_part']));
+
+		// the merged leaf's diff carries both merged branches, exactly once
+		const mergedLeaf = branches[0].leafs.find((leaf) => leaf.id === 'm_part')!;
+		expect(mergedLeaf.statements.map((statement) => (statement as any).type)).toStrictEqual([
+			'create_table',
+			'create_table',
+		]);
+	});
+
+	test('multi-migration branch: composition base stays at the divergence point', async () => {
+		// p
+		// ├── a1 ── a2 (leaf)
+		// └── b (leaf)
+		// A branch with several migrations still composes from p; the a2 leaf
+		// diff covers the whole a1+a2 chain.
+		const { tmp } = mkTmp();
+
+		const tablesDDL = (names: string[]) => {
+			const ddl = createDDL();
+			for (const name of names) {
+				ddl.tables.push({ schema: 'public', isRlsEnabled: false, name } as any);
+			}
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '190_p', makeSnapshot('p_chain', [ORIGIN], tablesDDL(['t']))),
+			writeTempSnapshot(tmp, '191_a1', makeSnapshot('a1_chain', ['p_chain'], tablesDDL(['t', 'a1']))),
+			writeTempSnapshot(tmp, '192_a2', makeSnapshot('a2_chain', ['a1_chain'], tablesDDL(['t', 'a1', 'a2']))),
+			writeTempSnapshot(tmp, '193_b', makeSnapshot('b_chain', ['p_chain'], tablesDDL(['t', 'b']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+
+		expect(report.conflicts).toStrictEqual([]);
+
+		const branches = report.commutativeBranches ?? [];
+		expect(branches.map((branch) => branch.parentId)).toStrictEqual(['p_chain']);
+		expect(new Set(branches[0].leafs.map((leaf) => leaf.id))).toStrictEqual(new Set(['a2_chain', 'b_chain']));
+
+		const chainLeaf = branches[0].leafs.find((leaf) => leaf.id === 'a2_chain')!;
+		expect(chainLeaf.statements.map((statement) => (statement as any).type)).toStrictEqual([
+			'create_table',
+			'create_table',
+		]);
+	});
+
+	test('fully merged history with a single head offers nothing', async () => {
+		// p
+		// ├── a \  merged into m (single leaf)
+		// └── b /
+		// Closed history: no conflicts, no open commutative branches.
+		const { tmp } = mkTmp();
+
+		const tablesDDL = (names: string[]) => {
+			const ddl = createDDL();
+			for (const name of names) {
+				ddl.tables.push({ schema: 'public', isRlsEnabled: false, name } as any);
+			}
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '200_p', makeSnapshot('p_closed', [ORIGIN], tablesDDL(['t']))),
+			writeTempSnapshot(tmp, '201_a', makeSnapshot('a_closed', ['p_closed'], tablesDDL(['t', 'a']))),
+			writeTempSnapshot(tmp, '202_b', makeSnapshot('b_closed', ['p_closed'], tablesDDL(['t', 'b']))),
+			writeTempSnapshot(tmp, '203_m', makeSnapshot('m_closed', ['a_closed', 'b_closed'], tablesDDL(['t', 'a', 'b']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+
+		expect(report.conflicts).toStrictEqual([]);
+		expect(report.leafNodes).toStrictEqual(['m_closed']);
+		expect(report.commutativeBranches ?? []).toStrictEqual([]);
+	});
+
+	test('enum: parallel ADD VALUE to the same enum is non-commutative', async () => {
+		// Enum value order matters in postgres, and the final order of values
+		// appended by parallel branches depends on which migration runs first —
+		// the branches must be resolved explicitly instead of merged.
+		const { tmp } = mkTmp();
+
+		const enumDDL = (values: string[]) => {
+			const ddl = createDDL();
+			ddl.enums.push({ schema: 'public', name: 'status', values } as any);
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '150_p_enum_add', makeSnapshot('p_enum_add', [ORIGIN], enumDDL(['a']))),
+			writeTempSnapshot(tmp, '151_a_enum_add', makeSnapshot('a_enum_add', ['p_enum_add'], enumDDL(['a', 'b']))),
+			writeTempSnapshot(tmp, '152_b_enum_add', makeSnapshot('b_enum_add', ['p_enum_add'], enumDDL(['a', 'c']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.commutativeBranches ?? []).toStrictEqual([]);
+	});
+
+	test('enum: parallel ADD VALUE to different enums is commutative', async () => {
+		const { tmp } = mkTmp();
+
+		const twoEnumsDDL = (statusValues: string[], colorValues: string[]) => {
+			const ddl = createDDL();
+			ddl.enums.push({ schema: 'public', name: 'status', values: statusValues } as any);
+			ddl.enums.push({ schema: 'public', name: 'color', values: colorValues } as any);
+			return ddl.entities.list();
+		};
+
+		const files = [
+			writeTempSnapshot(tmp, '160_p_enums', makeSnapshot('p_enums', [ORIGIN], twoEnumsDDL(['a'], ['x']))),
+			writeTempSnapshot(tmp, '161_a_enums', makeSnapshot('a_enums', ['p_enums'], twoEnumsDDL(['a', 'b'], ['x']))),
+			writeTempSnapshot(tmp, '162_b_enums', makeSnapshot('b_enums', ['p_enums'], twoEnumsDDL(['a'], ['x', 'y']))),
+		];
+
+		const report = await postgresCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+		expect((report.commutativeBranches ?? []).map((branch) => branch.parentId)).toStrictEqual(['p_enums']);
+	});
+});
diff --git a/drizzle-kit/tests/postgres/entity-filter.test.ts b/drizzle-kit/tests/postgres/entity-filter.test.ts
new file mode 100644
index 0000000000..671a17e8c9
--- /dev/null
+++ b/drizzle-kit/tests/postgres/entity-filter.test.ts
@@ -0,0 +1,440 @@
+import { sql } from 'drizzle-orm';
+import { pgSchema, pgView, serial } from 'drizzle-orm/pg-core';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+describe('push', () => {
+	test('push schema #1', async () => {
+		const to = { dev: pgSchema('dev') };
+		const st0 = ['CREATE SCHEMA "dev";\n'];
+
+		{
+			const { sqlStatements: pst } = await push({ db, to });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+	});
+
+	test('push schema #2', async () => {
+		const to = { dev: pgSchema('dev'), dev2: pgSchema('dev2') };
+		const st0 = ['CREATE SCHEMA "dev";\n', 'CREATE SCHEMA "dev2";\n'];
+
+		{
+			const { sqlStatements: pst } = await push({ db, to });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+			expect(pst).toStrictEqual(['CREATE SCHEMA "dev";\n']);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual(['CREATE SCHEMA "dev2";\n']);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+	});
+
+	test('push schema #3', async () => {
+		const to = { dev: pgSchema('dev').existing(), dev2: pgSchema('dev2') };
+		const st0 = ['CREATE SCHEMA "dev2";\n'];
+
+		{
+			const { sqlStatements: pst } = await push({ db, to });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+	});
+
+	test('push schema #4', async () => {
+		const dev = pgSchema('dev');
+		const table1 = dev.table('table1', { id: serial() });
+		const table2 = dev.table('table2', { id: serial() });
+		const to = { dev, table1, table2, dev2: pgSchema('dev2') };
+
+		const st0 = [
+			'CREATE SCHEMA "dev";\n',
+			'CREATE SCHEMA "dev2";\n',
+			'CREATE TABLE "dev"."table1" (\n\t"id" serial\n);\n',
+			'CREATE TABLE "dev"."table2" (\n\t"id" serial\n);\n',
+		];
+
+		{
+			const { sqlStatements: pst } = await push({ db, to });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+			expect(pst).toStrictEqual([
+				'CREATE SCHEMA "dev";\n',
+				'CREATE TABLE "dev"."table1" (\n\t"id" serial\n);\n',
+				'CREATE TABLE "dev"."table2" (\n\t"id" serial\n);\n',
+			]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual(['CREATE SCHEMA "dev2";\n']);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+	});
+
+	test('push schema #5', async () => {
+		const dev = pgSchema('dev').existing();
+		const table1 = dev.table('table1', { id: serial() });
+		const table2 = dev.table('table2', { id: serial() });
+		const to = { dev, table1, table2, dev2: pgSchema('dev2') };
+		const st0 = ['CREATE SCHEMA "dev2";\n'];
+
+		{
+			const { sqlStatements: pst } = await push({ db, to });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: [] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!public'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['dev*'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+
+		{
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['public', '!dev'] });
+			expect(pst).toStrictEqual(st0);
+			await _.clear();
+		}
+	});
+
+	test('push schema #6', async () => {
+		await db.query('create schema dev');
+
+		const to = { dev: pgSchema('dev').existing() };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual([]);
+	});
+
+	test('push schema #6', async () => {
+		await db.query('create schema dev;');
+		await db.query('create table dev.users (id int);');
+
+		const to = { dev: pgSchema('dev').existing() };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual([]);
+	});
+
+	test('push schema #7', async () => {
+		await db.query('create schema dev;');
+		await db.query('create table dev.users (id int);');
+
+		const to = { dev: pgSchema('dev') };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual(['DROP TABLE "dev"."users";']);
+	});
+
+	test('push schema #8', async () => {
+		await db.query('create schema dev;');
+		await db.query('create table dev.users (id int);');
+		await db.query('create view v as (select * from dev.users);');
+
+		const to = { dev: pgSchema('dev') };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual([
+			'DROP VIEW "v";',
+			'DROP TABLE "dev"."users";',
+		]);
+	});
+
+	test('push schema #9', async () => {
+		await db.query('create schema dev;');
+		await db.query('create table dev.users (id int);');
+		await db.query('create view dev.v as (select * from dev.users);');
+
+		const to = { dev: pgSchema('dev') };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual([
+			'DROP VIEW "dev"."v";',
+			'DROP TABLE "dev"."users";',
+		]);
+	});
+
+	test('push schema #10', async () => {
+		await db.query('create schema dev;');
+		await db.query('create table dev.users (id int);');
+		await db.query('create view v as (select * from dev.users);');
+
+		const to = { dev: pgSchema('dev').existing(), v: pgView('v', {}).existing() };
+		const { sqlStatements: pst } = await push({ db, to });
+		expect(pst).toStrictEqual([]);
+	});
+
+	test('huge schema #1', async () => {
+		const schema = await import('./schemas/schema1');
+
+		await push({ db, to: schema });
+
+		const res1 = await push({ db, to: { ...schema, core: pgSchema('core').existing() } });
+		expect(res1.sqlStatements).toStrictEqual([]);
+
+		const res2 = await push({ db, to: schema });
+		expect(res2.sqlStatements).toStrictEqual([]);
+	});
+
+	test('push schema #10', async () => {
+		{
+			await db.query('create schema dev;');
+			await db.query('create schema dev2;');
+			await db.query('create schema test;');
+			await db.query('create schema test2;');
+
+			const to = { dev2: pgSchema('dev2'), test2: pgSchema('test2'), test: pgSchema('test') };
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['test2', '!dev'] });
+			expect(pst).toStrictEqual([]);
+			await _.clear();
+		}
+
+		{
+			await db.query('create schema dev;');
+			await db.query('create schema dev2;');
+			await db.query('create schema test;');
+			await db.query('create schema test2;');
+
+			const to = { dev2: pgSchema('dev2'), test2: pgSchema('test2') };
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev'] });
+			expect(pst).toStrictEqual([`DROP SCHEMA "test";\n`]);
+			await _.clear();
+		}
+
+		{
+			await db.query('create schema dev;');
+			await db.query('create schema dev2;');
+			await db.query('create schema test;');
+			await db.query('create schema test2;');
+
+			const to = { dev2: pgSchema('dev2'), test2: pgSchema('test2') };
+			const { sqlStatements: pst } = await push({ db, to, schemas: ['!dev', '!dev2'] });
+			expect(pst).toStrictEqual([`DROP SCHEMA "test";\n`]);
+			await _.clear();
+		}
+	});
+});
+
+describe('schema filters', () => {
+	test('schema filters #1', () => {
+		const dbSchemas = ['public', 'admin', 'sales'];
+
+		const filter = prepareEntityFilter('postgresql', {
+			schemas: ['public'],
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		}, []);
+
+		const filtered = dbSchemas.filter((schema) => filter({ type: 'schema', name: schema }));
+
+		expect(filtered).toStrictEqual(['public']);
+	});
+
+	test('schema filters #2', () => {
+		const dbSchemas = ['public', 'test', 'admin'];
+
+		const filter = prepareEntityFilter('postgresql', {
+			schemas: ['!test'],
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		}, []);
+
+		const filtered = dbSchemas.filter((schema) => filter({ type: 'schema', name: schema }));
+
+		expect(filtered).toStrictEqual(['public', 'admin']);
+	});
+
+	test('schema filters #3', () => {
+		const dbSchemas = ['users_1', 'users_2', 'users_3', 'admin', 'users_4'];
+
+		const filter = prepareEntityFilter('postgresql', {
+			schemas: ['users_*', '!users_4', '!ad*'],
+			tables: undefined,
+			entities: undefined,
+			extensions: undefined,
+		}, []);
+
+		const filtered = dbSchemas.filter((schema) => filter({ type: 'schema', name: schema }));
+
+		expect(filtered).toStrictEqual(['users_1', 'users_2', 'users_3']);
+	});
+});
diff --git a/drizzle-kit/tests/postgres/ext.test.ts b/drizzle-kit/tests/postgres/ext.test.ts
new file mode 100644
index 0000000000..f4828caf96
--- /dev/null
+++ b/drizzle-kit/tests/postgres/ext.test.ts
@@ -0,0 +1,52 @@
+import { introspect } from 'src/cli/commands/pull-postgres';
+import { EmptyProgressView } from 'src/cli/views';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, test } from 'vitest';
+import { prepareTestDatabase, TestDatabase } from './mocks';
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('ext:1', async () => {
+	await db.query(
+		/*sql*/
+		`create table "t" (
+      "predict" json default '{"key":"value"}', 
+      "prediction" json generated always as (predict->'predictions') stored
+    );`,
+	);
+
+	const res = await introspect(db, () => true, new EmptyProgressView(), () => {}, {
+		schema: 'drizzle',
+		table: 'drizzle_migrations',
+	});
+});
+
+test('ext:2', async () => {
+	await db.query(
+		/*sql*/
+		`create table "t" (
+      c1 int not null, 
+      c2 int not null,
+      PRIMARY KEY (c1, c2)
+    );`,
+	);
+	await db.query(`alter table "t" drop column c2;`);
+	await introspect(db, () => true, new EmptyProgressView(), () => {}, {
+		schema: 'drizzle',
+		table: 'drizzle_migrations',
+	});
+});
diff --git a/drizzle-kit/tests/postgres/grammar.test.ts b/drizzle-kit/tests/postgres/grammar.test.ts
new file mode 100644
index 0000000000..4dd5aeae0a
--- /dev/null
+++ b/drizzle-kit/tests/postgres/grammar.test.ts
@@ -0,0 +1,84 @@
+import { splitSqlType, trimDefaultValueSuffix } from 'src/dialects/postgres/grammar';
+import { expect, test } from 'vitest';
+
+test.each([
+	["'a'::my_enum", "'a'"],
+	["'abc'::text", "'abc'"],
+	["'abc'::character varying", "'abc'"],
+	["'abc'::bpchar", "'abc'"],
+	[`'{"attr":"value"}'::json`, `'{"attr":"value"}'`],
+	[`'{"attr": "value"}'::jsonb`, `'{"attr": "value"}'`],
+	[`'00:00:00'::time without time zone`, `'00:00:00'`],
+	[`'2025-04-24 08:30:45.08+00'::timestamp with time zone`, `'2025-04-24 08:30:45.08+00'`],
+	[`'2024-01-01'::date`, `'2024-01-01'`],
+	[`'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::uuid`, `'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'`],
+	[`now()`, `now()`],
+	[`CURRENT_TIMESTAMP`, `CURRENT_TIMESTAMP`],
+	[`timezone('utc'::text, now())`, `timezone('utc'::text, now())`],
+	[`'{a,b}'::my_enum[]`, `'{a,b}'`],
+	[`'{10,20}'::smallint[]`, `'{10,20}'`],
+	[`'{10,20}'::integer[]`, `'{10,20}'`],
+	[`'{99.9,88.8}'::numeric[]`, `'{99.9,88.8}'`],
+	[`'{100,200}'::bigint[]`, `'{100,200}'`],
+	[`'{t,f}'::boolean[]`, `'{t,f}'`],
+	[`'{abc,def}'::text[]`, `'{abc,def}'`],
+	[`'{abc,def}'::character varying[]`, `'{abc,def}'`],
+	[`'{abc,def}'::bpchar[]`, `'{abc,def}'`],
+	[`'{100,200}'::double precision[]`, `'{100,200}'`],
+	[`'{100,200}'::real[]`, `'{100,200}'`],
+	["'{}'::character(1)[]", "'{}'"],
+	[
+		`'{"{\"attr\":\"value1\"}","{\"attr\":\"value2\"}"}'::json[]`,
+		`'{"{\"attr\":\"value1\"}","{\"attr\":\"value2\"}"}'`,
+	],
+	[
+		`'{"{\"attr\": \"value1\"}","{\"attr\": \"value2\"}"}'::jsonb[]`,
+		`'{"{\"attr\": \"value1\"}","{\"attr\": \"value2\"}"}'`,
+	],
+	[`'{00:00:00,01:00:00}'::time without time zone[]`, `'{00:00:00,01:00:00}'`],
+	[
+		`'{"2025-04-24 10:41:36.623+00","2025-04-24 10:41:36.623+00"}'::timestamp with time zone[]`,
+		`'{"2025-04-24 10:41:36.623+00","2025-04-24 10:41:36.623+00"}'`,
+	],
+	[`'{2024-01-01,2024-01-02}'::date[]`, `'{2024-01-01,2024-01-02}'`],
+	[
+		`'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12}'::uuid[]`,
+		`'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12}'`,
+	],
+	[`'{127.0.0.1,127.0.0.2}'::inet[]`, `'{127.0.0.1,127.0.0.2}'`],
+	[`'{127.0.0.1/32,127.0.0.2/32}'::cidr[]`, `'{127.0.0.1/32,127.0.0.2/32}'`],
+	[`'{00:00:00:00:00:00,00:00:00:00:00:01}'::macaddr[]`, `'{00:00:00:00:00:00,00:00:00:00:00:01}'`],
+	[
+		`'{00:00:00:ff:fe:00:00:00,00:00:00:ff:fe:00:00:01}'::macaddr8[]`,
+		`'{00:00:00:ff:fe:00:00:00,00:00:00:ff:fe:00:00:01}'`,
+	],
+	[`'{"1 day 01:00:00","1 day 02:00:00"}'::interval[]`, `'{"1 day 01:00:00","1 day 02:00:00"}'`],
+	[`(predict -> 'predictions'::text)`, `(predict -> 'predictions'::text)`],
+])('trim default suffix %#: %s', (it, expected) => {
+	expect(trimDefaultValueSuffix(it)).toBe(expected);
+});
+
+test('split sql type', () => {
+	expect.soft(splitSqlType('numeric')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)')).toStrictEqual({ type: 'numeric', options: '10,2' });
+
+	expect.soft(splitSqlType('numeric[]')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)[]')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)[]')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)[]')).toStrictEqual({ type: 'numeric', options: '10,2' });
+
+	expect.soft(splitSqlType('numeric[][]')).toStrictEqual({ type: 'numeric', options: null });
+	expect.soft(splitSqlType('numeric(10)[][]')).toStrictEqual({ type: 'numeric', options: '10' });
+	expect.soft(splitSqlType('numeric(10,0)[][]')).toStrictEqual({ type: 'numeric', options: '10,0' });
+	expect.soft(splitSqlType('numeric(10,2)[][]')).toStrictEqual({ type: 'numeric', options: '10,2' });
+});
+
+test('to default array', () => {
+	// TODO: wrong test?
+	// expect.soft(toDefaultArray([['one'], ['two']], 1, (it) => JSON.stringify(it))).toBe(`{["one"],["two"]}`);
+	// expect.soft(toDefaultArray([{ key: 'one' }, { key: 'two' }], 1, (it) => JSON.stringify(it))).toBe(
+	// 	`{{"key":"one"},{"key":"two"}}`,
+	// );
+});
diff --git a/drizzle-kit/tests/postgres/mocks.ts b/drizzle-kit/tests/postgres/mocks.ts
new file mode 100644
index 0000000000..38f44a1f46
--- /dev/null
+++ b/drizzle-kit/tests/postgres/mocks.ts
@@ -0,0 +1,896 @@
+import { is } from 'drizzle-orm';
+import {
+	isPgEnum,
+	isPgMaterializedView,
+	isPgSequence,
+	isPgView,
+	PgColumnBuilder,
+	PgDialect,
+	PgEnum,
+	PgEnumObject,
+	PgMaterializedView,
+	PgPolicy,
+	PgRole,
+	PgSchema,
+	PgSequence,
+	PgTable,
+	pgTable,
+	PgView,
+	serial,
+} from 'drizzle-orm/pg-core';
+import {
+	PgEnum as PgEnumOld,
+	PgEnumObject as PgEnumObjectOld,
+	PgMaterializedView as PgMaterializedViewOld,
+	PgPolicy as PgPolicyOld,
+	PgRole as PgRoleOld,
+	PgSchema as PgSchemaOld,
+	PgSequence as PgSequenceOld,
+	PgTable as PgTableOld,
+	PgView as PgViewOld,
+} from 'orm044/pg-core';
+import { configMigrations } from 'src/cli/validations/common';
+import {
+	createDDL,
+	fromEntities,
+	interimToDDL,
+	PostgresDDL,
+	postgresToRelationsPull,
+	SchemaError,
+} from 'src/dialects/postgres/ddl';
+import { ddlDiff, ddlDiffDry } from 'src/dialects/postgres/diff';
+import {
+	defaultFromColumn,
+	fromDrizzleSchema,
+	prepareFromSchemaFiles,
+	unwrapColumn,
+} from 'src/dialects/postgres/drizzle';
+import { mockResolver } from 'src/utils/mocks';
+import '../../src/@types/utils';
+import { PGlite } from '@electric-sql/pglite';
+// @ts-ignore
+import { pg_trgm } from '@electric-sql/pglite/contrib/pg_trgm';
+// @ts-ignore
+import { citext } from '@electric-sql/pglite/contrib/citext';
+// @ts-ignore
+import { vector } from '@electric-sql/pglite/vector';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import pg from 'pg';
+import { introspect } from 'src/cli/commands/pull-postgres';
+import { suggestions } from 'src/cli/commands/push-postgres';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { EmptyProgressView, explain, psqlExplain } from 'src/cli/views';
+import { hash } from 'src/dialects/common';
+import { defaultToSQL, isSystemNamespace, isSystemRole } from 'src/dialects/postgres/grammar';
+import { fromDatabaseForDrizzle } from 'src/dialects/postgres/introspect';
+import { ddlToTypeScript } from 'src/dialects/postgres/typescript';
+import { DB } from 'src/utils';
+import 'zx/globals';
+import { relationsToTypeScript } from 'src/cli/commands/pull-common';
+import { EntitiesFilter, EntitiesFilterConfig } from 'src/cli/validations/common';
+import { extractPostgresExisting } from 'src/dialects/drizzle';
+import { postgresCommutativity } from 'src/dialects/postgres/commutativity';
+import { PostgresSnapshot } from 'src/dialects/postgres/snapshot';
+import { upToV8 } from 'src/dialects/postgres/versions';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { diff as legacyDiff } from 'src/legacy/postgres-v7/pgDiff';
+import { serializePg } from 'src/legacy/postgres-v7/serializer';
+import { loadModule } from 'src/utils/utils-node';
+import { tsc } from 'tests/utils';
+import { expect } from 'vitest';
+
+const tmpDir = 'tests/postgres/tmp';
+mkdirSync(tmpDir, { recursive: true });
+
+const { Client } = pg;
+
+export type PostgresSchema = Record<
+	string,
+	| PgTable<any>
+	| PgEnum<any>
+	| PgEnumObject<any>
+	| PgSchema
+	| PgSequence
+	| PgView
+	| PgMaterializedView
+	| PgRole
+	| PgPolicy
+	| unknown
+>;
+
+export type PostgresSchemaOld = Record<
+	string,
+	| PgTableOld<any>
+	| PgEnumOld<any>
+	| PgEnumObjectOld<any>
+	| PgSchemaOld
+	| PgSequenceOld
+	| PgViewOld
+	| PgMaterializedViewOld
+	| PgRoleOld
+	| PgPolicyOld
+	| unknown
+>;
+
+class MockError extends Error {
+	constructor(readonly errors: SchemaError[]) {
+		super();
+	}
+}
+
+export const drizzleToDDL = (
+	schema: PostgresSchema,
+	filtersConfig: EntitiesFilterConfig = {
+		entities: undefined,
+		extensions: undefined,
+		schemas: undefined,
+		tables: undefined,
+	},
+) => {
+	const tables = Object.values(schema).filter((it) => is(it, PgTable)) as PgTable[];
+	const schemas = Object.values(schema).filter((it) => is(it, PgSchema)) as PgSchema[];
+	const enums = Object.values(schema).filter((it) => isPgEnum(it)) as PgEnum<any>[];
+	const sequences = Object.values(schema).filter((it) => isPgSequence(it)) as PgSequence[];
+	const roles = Object.values(schema).filter((it) => is(it, PgRole)) as PgRole[];
+	const policies = Object.values(schema).filter((it) => is(it, PgPolicy)) as PgPolicy[];
+	const views = Object.values(schema).filter((it) => isPgView(it)) as PgView[];
+	const materializedViews = Object.values(schema).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
+
+	const grouped = { schemas, tables, enums, sequences, roles, policies, views, matViews: materializedViews };
+
+	const existing = extractPostgresExisting(schemas, views, materializedViews);
+	const filter = prepareEntityFilter('postgresql', filtersConfig, existing);
+
+	const {
+		schema: res,
+		errors,
+		warnings,
+	} = fromDrizzleSchema(grouped, filter);
+
+	if (errors.length > 0) {
+		throw new Error();
+	}
+
+	return { ...interimToDDL(res), existing };
+};
+
+// 2 schemas -> 2 ddls -> diff
+export const diff = async (
+	left: PostgresSchema | PostgresDDL,
+	right: PostgresSchema | PostgresDDL,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as PostgresDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = 'entities' in right && '_' in right
+		? { ddl: right as PostgresDDL, errors: [] }
+		: drizzleToDDL(right);
+
+	if (err1.length > 0 || err2.length > 0) {
+		throw new MockError([...err1, ...err2]);
+	}
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+	return { sqlStatements, statements, groupedStatements, next: ddl2 };
+};
+
+// init schema flush to db -> introspect db to ddl -> compare ddl with destination schema
+export const push = async (config: {
+	db: DB;
+	to: PostgresSchema | PostgresDDL;
+	renames?: string[];
+	schemas?: string[];
+	tables?: string[];
+	log?: 'statements' | 'none';
+	entities?: EntitiesFilter;
+	ignoreSubsequent?: boolean;
+	explain?: true;
+	migrationsConfig?: {
+		schema?: string;
+		table?: string;
+	};
+}) => {
+	const { db, to } = config;
+
+	const log = config.log ?? 'none';
+	const schemas = config.schemas ?? [];
+	const tables = config.tables ?? [];
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+
+	const filterConfig = {
+		tables,
+		schemas,
+		entities: config.entities,
+		extensions: [],
+	};
+
+	const { ddl: ddl2, errors: err2, existing } = 'entities' in to && '_' in to
+		? { ddl: to as PostgresDDL, errors: [], existing: [] }
+		: drizzleToDDL(to, filterConfig);
+
+	const filter = prepareEntityFilter('postgresql', filterConfig, existing);
+	const { schema } = await introspect(
+		db,
+		filter,
+		new EmptyProgressView(),
+		() => {},
+		migrations,
+	);
+
+	const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+
+	if (err2.length > 0) {
+		for (const e of err2) {
+			console.error(`err2: ${JSON.stringify(e)}`);
+		}
+		throw new Error();
+	}
+
+	if (err3.length > 0) {
+		for (const e of err3) {
+			console.error(`err3: ${JSON.stringify(e)}`);
+		}
+		throw new Error();
+	}
+
+	const renames = new Set(config.renames ?? []);
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const hints = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, new HintsHandler()),
+	);
+
+	if (config.explain) {
+		const explainMessage = explain('postgres', groupedStatements, []);
+		console.log(explainMessage);
+		return { sqlStatements, statements, hints };
+	}
+
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		await db.query(sql);
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		{
+			const { schema } = await introspect(
+				db,
+				filter,
+				new EmptyProgressView(),
+				() => {},
+				migrations,
+			);
+			const { ddl: ddl1, errors: err3 } = interimToDDL(schema);
+
+			const { sqlStatements, statements } = await ddlDiff(
+				ddl1,
+				ddl2,
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				mockResolver(renames),
+				'push',
+			);
+			if (sqlStatements.length > 0) {
+				console.error('---- subsequent push is not empty ----');
+				expect(sqlStatements.join('\n')).toBe('');
+			}
+		}
+	}
+
+	return { sqlStatements, statements, hints };
+};
+
+// init schema to db -> pull from db to file -> ddl from files -> compare ddl from db with ddl from file
+export const diffIntrospect = async (
+	db: DB,
+	initSchema: PostgresSchema,
+	testName: string,
+	schemas: string[] = ['public'],
+	entities?: EntitiesFilter,
+) => {
+	const { ddl: initDDL } = drizzleToDDL(initSchema);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL, 'default');
+	for (const st of init) await db.query(st);
+
+	const filter = prepareEntityFilter('postgresql', {
+		tables: [],
+		schemas,
+		entities,
+		extensions: [],
+	}, []);
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, filter, () => true, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	// schema
+	const filePath = `${tmpDir}/${testName}.ts`;
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+	writeFileSync(filePath, file.file);
+	await tsc(file.file).catch((e) => {
+		throw new Error(`tsc error in file ${filePath}`, { cause: e });
+	});
+
+	// relations
+	const relationsPath = `${tmpDir}/${testName}-relations.ts`;
+	const schemaAbsolutePath = path.resolve(tmpDir, testName);
+	const relationsForTsc = relationsToTypeScript(
+		postgresToRelationsPull(ddl1),
+		'camel',
+		schemaAbsolutePath,
+	);
+	writeFileSync(relationsPath, relationsForTsc.file);
+	await tsc(relationsForTsc.file).catch((e) => {
+		throw new Error(`tsc error in file ${relationsPath}`, { cause: e });
+	});
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([
+		filePath,
+	]);
+
+	const {
+		schema: schema2,
+		errors: e2,
+		warnings,
+	} = fromDrizzleSchema(response, () => true);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(schema2);
+	// TODO: handle errors
+
+	const {
+		sqlStatements: pushAfterFileSqlStatements,
+		statements: pushAfterFileStatements,
+		groupedStatements: pushAfterFileGroupedStatements,
+	} = await ddlDiffDry(ddl1, ddl2, 'push');
+
+	if (pushAfterFileSqlStatements.length > 0) {
+		console.log(chalk.bgRed('After push: ') + '\n' + explain('postgres', pushAfterFileGroupedStatements, []));
+	}
+
+	const {
+		sqlStatements: generateAfterFileSqlStatements,
+		statements: generateAfterFileStatements,
+		groupedStatements: generateAfterFileGroupedStatements,
+	} = await ddlDiffDry(ddl1, ddl2, 'default');
+
+	if (generateAfterFileSqlStatements.length > 0) {
+		console.log(
+			chalk.bgRed('After generate: ') + '\n' + explain('postgres', generateAfterFileGroupedStatements, []),
+		);
+	}
+
+	let relationsError: Error | null = null;
+	try {
+		await loadModule(path.relative(process.cwd(), relationsPath));
+		rmSync(relationsPath);
+	} catch (error: any) {
+		relationsError = error;
+	}
+
+	if ([...generateAfterFileSqlStatements, ...pushAfterFileSqlStatements].length === 0) {
+		rmSync(`tests/postgres/tmp/${testName}.ts`);
+	}
+
+	return {
+		pushSqlStatements: pushAfterFileSqlStatements,
+		pushStatements: pushAfterFileStatements,
+		generateSqlStatements: generateAfterFileSqlStatements,
+		generateStatements: generateAfterFileStatements,
+		ddlAfterPull: ddl1,
+		schema2,
+		relationsError,
+	};
+};
+
+export const diffDefault = async <T extends PgColumnBuilder>(
+	kit: TestDatabase<any>,
+	builder: T,
+	expectedDefault: string,
+	pre: PostgresSchema | null = null,
+	override?: {
+		type?: string;
+		default?: string;
+	},
+	tablesFilter?: string[],
+	schemasFilter?: string[],
+) => {
+	await kit.clear();
+
+	const config = (builder as any).config;
+	const def = config['default'];
+	const column = pgTable('table', { column: builder }).column;
+	const { dimensions, typeSchema, sqlType: sqlt } = unwrapColumn(column);
+
+	const type = override?.type ?? sqlt.replace(', ', ',').replaceAll('[]', ''); // real(6, 3)->real(6,3)
+
+	const columnDefault = defaultFromColumn(column, column.default, dimensions, new PgDialect());
+
+	const defaultSql = defaultToSQL({
+		default: columnDefault,
+		type,
+		dimensions,
+		typeSchema: typeSchema,
+	});
+
+	const res = [] as string[];
+	if (defaultSql !== expectedDefault) {
+		res.push(`Unexpected sql: \n${defaultSql}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: pgTable('table', { column: builder }),
+	};
+
+	const { db, clear } = kit;
+	if (pre) await push({ db, to: pre, ignoreSubsequent: true });
+	const { sqlStatements: st1 } = await push({
+		db,
+		to: init,
+		tables: tablesFilter,
+		schemas: schemasFilter,
+		ignoreSubsequent: true,
+	});
+	const { sqlStatements: st2 } = await push({
+		db,
+		to: init,
+		tables: tablesFilter,
+		schemas: schemasFilter,
+		ignoreSubsequent: true,
+	});
+	const typeSchemaPrefix = typeSchema && typeSchema !== 'public' ? `"${typeSchema}".` : '';
+	const typeValue = typeSchema ? `"${type}"` : type;
+	const sqlType = `${typeSchemaPrefix}${typeValue}${'[]'.repeat(dimensions)}`;
+	const defaultStatement = expectedDefault ? ` DEFAULT ${expectedDefault}` : '';
+	const expectedInit = `CREATE TABLE "table" (\n\t"column" ${sqlType}${defaultStatement}\n);\n`;
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2}`);
+
+	await db.query('INSERT INTO "table" ("column") VALUES (default);');
+
+	const filter = prepareEntityFilter('postgresql', {
+		tables: tablesFilter ?? [],
+		schemas: [],
+		entities: undefined,
+		extensions: [],
+	}, []);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(
+		db,
+		filter ?? (() => true),
+		schemasFilter ? (it: string) => schemasFilter.some((x) => x === it) : ((_) => true),
+		{
+			schema: 'drizzle',
+			table: '__drizzle_migrations',
+		},
+	);
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel');
+	const path = `tests/postgres/tmp/temp-${hash(String(Math.random()))}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+	const { schema: sch } = fromDrizzleSchema(response, () => true);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		res.push(`Unexpected diff after reading ts`);
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+	}
+
+	await clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: pgTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: pgTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, tables: tablesFilter, schemas: schemasFilter, ignoreSubsequent: true });
+	await push({ db, to: schema1, tables: tablesFilter, schemas: schemasFilter, ignoreSubsequent: true });
+	const { sqlStatements: st3 } = await push({
+		db,
+		to: schema2,
+		tables: tablesFilter,
+		schemas: schemasFilter,
+		ignoreSubsequent: true,
+	});
+	const expectedAlter = `ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT ${expectedDefault};`;
+	if ((st3.length !== 1 || st3[0] !== expectedAlter) && expectedDefault) {
+		res.push(`Unexpected default alter:\n${st3}\n\n${expectedAlter}`);
+	}
+
+	await clear();
+
+	const schema3 = {
+		...pre,
+		table: pgTable('table', { id: serial() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: pgTable('table', { id: serial(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre, tables: tablesFilter, schemas: schemasFilter, ignoreSubsequent: true });
+	await push({ db, to: schema3, tables: tablesFilter, schemas: schemasFilter, ignoreSubsequent: true });
+	const { sqlStatements: st4 } = await push({
+		db,
+		to: schema4,
+		tables: tablesFilter,
+		schemas: schemasFilter,
+		ignoreSubsequent: true,
+	});
+
+	const expectedAddColumn = `ALTER TABLE "table" ADD COLUMN "column" ${sqlType}${defaultStatement};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export const diffSnapshotV7 = async (db: DB, schema: PostgresSchema, schemaOld: PostgresSchemaOld) => {
+	const res = await serializePg(schemaOld, 'camelCase');
+	const { sqlStatements } = await legacyDiff({ right: res });
+
+	for (const st of sqlStatements) {
+		await db.query(st);
+	}
+
+	const { snapshot, hints } = upToV8(res);
+	const ddl = fromEntities(snapshot.ddl);
+
+	const { sqlStatements: st, next } = await diff(ddl, schema, []);
+	const { sqlStatements: pst } = await push({ db, to: schema });
+	const { sqlStatements: st1 } = await diff(next, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	return {
+		step1: st,
+		step2: pst,
+		step3: st1,
+		step4: pst1,
+		all: [...st, ...pst, ...st1, ...pst1],
+	};
+};
+
+export type TestDatabase<TClient = any> = {
+	db: DB & { batch: (sql: string[]) => Promise<void> };
+	client: TClient;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+};
+
+const client = new PGlite({ extensions: { citext, vector, pg_trgm } });
+
+export const prepareTestDatabase = async (tx: boolean = true): Promise<TestDatabase<PGlite>> => {
+	const envPgVersion = process.env.PG_VERSION;
+	if (envPgVersion && ['18', '17', '16'].includes(envPgVersion)) {
+		return await preparePgVersionTestDatabase(tx, envPgVersion);
+	}
+
+	await client.query(`CREATE ACCESS METHOD drizzle_heap TYPE TABLE HANDLER heap_tableam_handler;`);
+	await client.query(`CREATE EXTENSION vector;`);
+	await client.query(`CREATE EXTENSION pg_trgm;`);
+	if (tx) {
+		await client.query('BEGIN');
+		await client.query('SAVEPOINT drizzle');
+	}
+
+	const clear = async () => {
+		if (tx) {
+			await client.query('ROLLBACK TO SAVEPOINT drizzle');
+			await client.query('BEGIN');
+			await client.query('SAVEPOINT drizzle');
+			return;
+		}
+
+		const namespaces = await client.query<{ name: string }>('select oid, nspname as name from pg_namespace').then((
+			res,
+		) => res.rows.filter((r) => !isSystemNamespace(r.name)));
+
+		const roles = await client.query<{ rolname: string }>(
+			`SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`,
+		).then((it) => it.rows.filter((it) => !isSystemRole(it.rolname)));
+
+		for (const namespace of namespaces) {
+			await client.query(`DROP SCHEMA "${namespace.name}" cascade`);
+		}
+
+		await client.query('CREATE SCHEMA public;');
+
+		for (const role of roles) {
+			await client.query(`DROP ROLE "${role.rolname}"`);
+		}
+
+		await client.query(`CREATE EXTENSION vector;`);
+		await client.query(`CREATE EXTENSION pg_trgm;`);
+	};
+
+	const db: TestDatabase<any>['db'] = {
+		query: async (sql, params) => {
+			return client.query(sql, params).then((it) => it.rows as any[]).catch((e: Error) => {
+				const error = new Error(`query error: ${sql}\n\n${e.message}`);
+				throw error;
+			});
+		},
+		batch: async (sqls) => {
+			for (const sql of sqls) {
+				await client.query(sql);
+			}
+		},
+	};
+	return { db, close: async () => {}, clear, client };
+};
+
+export const preparePgVersionTestDatabase = async (
+	tx: boolean = true,
+	version: string = '18',
+): Promise<TestDatabase<any>> => {
+	let envURL: string | undefined;
+	if (version === '16') {
+		envURL = process.env.PG16_URL;
+		if (!envURL) throw new Error('PG16_URL is not set');
+	} else if (version === '17') {
+		envURL = process.env.PG17_URL;
+		if (!envURL) throw new Error('PG17_URL is not set');
+	} else if (version === '18') {
+		envURL = process.env.PG18_URL;
+		if (!envURL) throw new Error('PG18_URL is not set');
+	}
+
+	if (!envURL) {
+		throw new Error('One of PG18_URL, PG17_URL or PG16_URL is not set');
+	}
+
+	const parsed = new URL(envURL);
+	parsed.pathname = '/postgres';
+
+	const adminUrl = parsed.toString();
+	const admin = new Client({ connectionString: adminUrl });
+	await admin.connect();
+	await admin!.query(`DROP DATABASE IF EXISTS drizzle;`);
+	await admin!.query(`CREATE DATABASE drizzle;`);
+	await admin.end();
+
+	// envURL should have drizzle set as database
+	const pgClient = new Client({ connectionString: envURL });
+	await pgClient.connect();
+	await pgClient!.query(`DROP ACCESS METHOD IF EXISTS drizzle_heap;`);
+	await pgClient!.query(`CREATE ACCESS METHOD drizzle_heap TYPE TABLE HANDLER heap_tableam_handler;`);
+	await pgClient!.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+	await pgClient!.query(`CREATE EXTENSION IF NOT EXISTS pg_trgm;`);
+	if (tx) {
+		await pgClient!.query('BEGIN').catch();
+		await pgClient!.query('SAVEPOINT drizzle');
+	}
+
+	const clear = async () => {
+		if (tx) {
+			await pgClient.query('ROLLBACK TO SAVEPOINT drizzle');
+			await pgClient.query('BEGIN');
+			await pgClient.query('SAVEPOINT drizzle');
+			return;
+		}
+
+		const namespaces = await pgClient.query<{ name: string }>('select oid, nspname as name from pg_namespace').then((
+			res,
+		) => res.rows.filter((r) => !isSystemNamespace(r.name)));
+
+		const roles = await pgClient.query<{ rolname: string }>(
+			`SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`,
+		).then((it) => it.rows.filter((it) => !isSystemRole(it.rolname)));
+
+		for (const namespace of namespaces) {
+			await pgClient.query(`DROP SCHEMA "${namespace.name}" cascade`);
+		}
+
+		await pgClient.query('CREATE SCHEMA public;');
+
+		for (const role of roles) {
+			await pgClient.query(`DROP ROLE "${role.rolname}"`);
+		}
+
+		await pgClient.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+		await pgClient.query(`CREATE EXTENSION IF NOT EXISTS pg_trgm;`);
+	};
+
+	const close = async () => {
+		await pgClient.end().catch(console.error);
+	};
+
+	const db: TestDatabase['db'] = {
+		query: async (sql, params) => {
+			return pgClient.query(sql, params).then((it) => it.rows as any[]).catch((e: Error) => {
+				const error = new Error(`query error: ${sql}\n\n${e.message}`);
+				throw error;
+			});
+		},
+		batch: async (sqls) => {
+			for (const sql of sqls) {
+				await pgClient.query(sql);
+			}
+		},
+	};
+	return { db, close, clear, client };
+};
+
+export const preparePostgisTestDatabase = async (tx: boolean = true): Promise<TestDatabase<any>> => {
+	const envURL = process.env.POSTGIS_URL;
+	if (!envURL) {
+		throw new Error('POSTGIS_URL is not set, starting a new Postgis container for tests...');
+	}
+
+	const parsed = new URL(envURL);
+	parsed.pathname = '/postgres';
+
+	const adminUrl = parsed.toString();
+	const admin = new Client({ connectionString: adminUrl });
+	await admin.connect();
+	await admin!.query(`DROP DATABASE IF EXISTS drizzle;`);
+	await admin!.query(`CREATE DATABASE drizzle;`);
+	await admin.end();
+
+	// envURL should have drizzle set as database
+	const pgClient = new Client({ connectionString: envURL });
+	await pgClient.connect();
+	await pgClient!.query(`DROP ACCESS METHOD IF EXISTS drizzle_heap;`);
+	await pgClient!.query(`CREATE ACCESS METHOD drizzle_heap TYPE TABLE HANDLER heap_tableam_handler;`);
+	await pgClient!.query(`CREATE EXTENSION IF NOT EXISTS postgis;`);
+	if (tx) {
+		await pgClient!.query('BEGIN').catch();
+		await pgClient!.query('SAVEPOINT drizzle');
+	}
+
+	const clear = async () => {
+		if (tx) {
+			await pgClient.query('ROLLBACK TO SAVEPOINT drizzle');
+			await pgClient.query('BEGIN');
+			await pgClient.query('SAVEPOINT drizzle');
+			return;
+		}
+
+		const namespaces = await pgClient.query<{ name: string }>('select oid, nspname as name from pg_namespace').then((
+			res,
+		) => res.rows.filter((r) => !isSystemNamespace(r.name)));
+
+		const roles = await pgClient.query<{ rolname: string }>(
+			`SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`,
+		).then((it) => it.rows.filter((it) => !isSystemRole(it.rolname)));
+
+		for (const namespace of namespaces) {
+			await pgClient.query(`DROP SCHEMA "${namespace.name}" cascade`);
+		}
+
+		await pgClient.query('CREATE SCHEMA public;');
+
+		for (const role of roles) {
+			await pgClient.query(`DROP ROLE "${role.rolname}"`);
+		}
+
+		await pgClient.query(`CREATE EXTENSION IF NOT EXISTS postgis;`);
+	};
+
+	const close = async () => {
+		await pgClient.end().catch(console.error);
+	};
+
+	const db: TestDatabase['db'] = {
+		query: async (sql, params) => {
+			return pgClient.query(sql, params).then((it) => it.rows as any[]).catch((e: Error) => {
+				const error = new Error(`query error: ${sql}\n\n${e.message}`);
+				throw error;
+			});
+		},
+		batch: async (sqls) => {
+			for (const sql of sqls) {
+				await pgClient.query(sql);
+			}
+		},
+	};
+	return { db, close, clear, client };
+};
+
+type SchemaShape = {
+	id: string;
+	prevId?: string;
+	schema: PostgresSchema;
+};
+
+export async function conflictsFromSchema(
+	{ parent, child1, child2 }: {
+		parent: SchemaShape;
+		child1: SchemaShape;
+		child2: SchemaShape;
+	},
+) {
+	const { ddl: parentDDL } = drizzleToDDL(parent.schema);
+
+	const parentSnapshot = {
+		version: '8',
+		dialect: 'postgres',
+		id: parent.id,
+		prevIds: parent.prevId ? [parent.prevId] : [],
+		ddl: parentDDL.entities.list(),
+		renames: [],
+	} satisfies PostgresSnapshot;
+
+	const { statements: st1 } = await diff(parent.schema, child1.schema, []);
+	const { statements: st2 } = await diff(parent.schema, child2.schema, []);
+
+	return await postgresCommutativity.getReasonsFromStatements(st1, st2, parentSnapshot);
+}
diff --git a/drizzle-kit/tests/postgres/pg-array.test.ts b/drizzle-kit/tests/postgres/pg-array.test.ts
new file mode 100644
index 0000000000..c07e01144e
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-array.test.ts
@@ -0,0 +1,350 @@
+import {
+	bigint,
+	boolean,
+	date,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	serial,
+	text,
+	timestamp,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('array #1: empty array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT '{}'::integer[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #2: integer array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE \"test\" ADD COLUMN \"values\" integer[] DEFAULT '{1,2,3}'::integer[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #3: bigint array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: bigint('values', { mode: 'bigint' }).array().default([BigInt(1), BigInt(2), BigInt(3)]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE \"test\" ADD COLUMN \"values\" bigint[] DEFAULT '{1,2,3}'::bigint[];`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #4: boolean array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: boolean('values').array().default([true, false, true]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE \"test\" ADD COLUMN \"values\" boolean[] DEFAULT '{t,f,t}'::boolean[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #5: multi-dimensional array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array('[][]').default([[1, 2], [3, 4]]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "test" ADD COLUMN "values" integer[][] DEFAULT '{{1,2},{3,4}}'::integer[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #6: date array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: date('values').array().default(['2024-08-06', '2024-08-07']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" date[] DEFAULT \'{2024-08-06,2024-08-07}\'::date[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #7: timestamp array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: timestamp('values').array().default([new Date('2024-08-06'), new Date('2024-08-07')]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from, ignoreSubsequent: true });
+	const { sqlStatements: pst } = await push({ db, to, ignoreSubsequent: true });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" timestamp[] DEFAULT \'{"2024-08-06 00:00:00.000","2024-08-07 00:00:00.000"}\'::timestamp[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #8: json array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: json('values').array().default([{ a: 1 }, { b: 2 }]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "test" ADD COLUMN "values" json[] DEFAULT '{"{\\"a\\":1}","{\\"b\\":2}"}'::json[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #9: text array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: text('values').array().default(['abc', 'def']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['ALTER TABLE "test" ADD COLUMN "values" text[] DEFAULT \'{abc,def}\'::text[];'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #10: uuid array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: uuid('values').array().default([
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+				'b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11',
+			]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" uuid[] DEFAULT \'{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11,b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11}\'::uuid[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #11: enum array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default(['a', 'b', 'c']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "test" ADD COLUMN "values" "test_enum"[] DEFAULT \'{a,b,c}\'::"test_enum"[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('array #12: enum empty array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default(['a', 'b']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['ALTER TABLE "test" ADD COLUMN "values" "test_enum"[] DEFAULT \'{a,b}\'::"test_enum"[];'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5013
+test('array #13: not null', async (t) => {
+	const to = {
+		test: pgTable('table1', {
+			values: varchar({ length: 20 }).notNull().array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['CREATE TABLE "table1" (\n\t"values" varchar(20)[] NOT NULL\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/postgres/pg-checks.test.ts b/drizzle-kit/tests/postgres/pg-checks.test.ts
new file mode 100644
index 0000000000..2330059aa9
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-checks.test.ts
@@ -0,0 +1,252 @@
+import { gte, sql } from 'drizzle-orm';
+import { check, integer, pgTable, serial, varchar } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create table with check #1', async (t) => {
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"age" integer,\n\tCONSTRAINT "some_check_name" CHECK ("age" > 21)\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4661
+test('create table with check #2: sql``', async (t) => {
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', gte(table.age, 21))]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"age" integer,\n\tCONSTRAINT "some_check_name" CHECK ("age" >= 21)\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check contraint to existing table', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [
+			check('some_check_name', sql`${table.age} > 21`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE "users" ADD CONSTRAINT "some_check_name" CHECK ("age" > 21);`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check contraint in existing table', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename check constraint', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('new_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "new_check_name" CHECK ("age" > 21);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter check constraint', async (t) => {
+	const from = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			age: integer('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP CONSTRAINT "some_check_name", ADD CONSTRAINT "some_check_name" CHECK ("age" > 10);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('rename + alter multiple check constraints', async (t) => {
+	const from = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				age: integer('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_1', sql`${table.age} > 21`),
+				check('some_check_name_2', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const to = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				age: integer('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [
+				check('some_check_name_3', sql`${table.age} > 21`),
+				check('some_check_name_4', sql`${table.name} != 'Alex'`),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_1";`,
+		`ALTER TABLE "users" DROP CONSTRAINT "some_check_name_2";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_3" CHECK ("age" > 21);`,
+		`ALTER TABLE "users" ADD CONSTRAINT "some_check_name_4" CHECK ("name" != \'Alex\');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create checks with same names', async (t) => {
+	const to = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				age: integer('age'),
+				name: varchar('name'),
+			},
+			(
+				table,
+			) => [check('some_check_name', sql`${table.age} > 21`), check('some_check_name', sql`${table.name} != 'Alex'`)],
+		),
+	};
+
+	// 'constraint_name_duplicate'
+	await expect(diff({}, to, [])).rejects.toThrow();
+	// adding only CONSTRAINT "some_check_name" CHECK ("users"."age" > 21), not throwing error
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test('alter check value', async () => {
+	const schema1 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').default(1),
+		}, (table) => [check('some_check', sql`${table.values} < 100`)]),
+	};
+	const schema2 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').default(1),
+		}, (table) => [check('some_check', sql`${table.values} > 100`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "test" DROP CONSTRAINT "some_check", ADD CONSTRAINT "some_check" CHECK ("values" > 100);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pg-columns.test.ts b/drizzle-kit/tests/postgres/pg-columns.test.ts
new file mode 100644
index 0000000000..0cb501cae2
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-columns.test.ts
@@ -0,0 +1,1615 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	geometry,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgSchema,
+	pgTable,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, preparePostgisTestDatabase, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add columns #1', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = ['ALTER TABLE "users" ADD COLUMN "name" text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #2', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "users" ADD COLUMN "name" text;',
+		'ALTER TABLE "users" ADD COLUMN "email" text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change name #1', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users.name->public.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users.name->public.users.name1',
+		],
+	});
+
+	const st0 = ['ALTER TABLE "users" RENAME COLUMN "name" TO "name1";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column change name #2', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name1'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users.name->public.users.name1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users.name->public.users.name1',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME COLUMN "name" TO "name1";',
+		'ALTER TABLE "users" ADD COLUMN "email" text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// TODO: @AlexBlokh revise: you can't change varchar type to inet using
+// ALTER TABLE "table1" ALTER COLUMN "column1" SET DATA TYPE inet;
+// https://github.com/drizzle-team/drizzle-orm/issues/4806
+test('alter column type to custom type', async (t) => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			column1: varchar({ length: 256 }),
+		}),
+	};
+
+	const citext = customType<{ data: string }>({
+		codec: 'text',
+		dataType() {
+			return 'text';
+		},
+	});
+	const schema2 = {
+		table1: pgTable('table1', {
+			column1: citext(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table1" ALTER COLUMN "column1" SET DATA TYPE text USING "column1"::text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4245
+test('alter text type to jsonb type', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			column1: text(),
+		}),
+	};
+
+	await push({ db, to: schema1 });
+	const { next: n1 } = await diff({}, schema1, []);
+	await db.query(`insert into table1 values ('{"b":2}');`);
+
+	const schema2 = {
+		table1: pgTable('table1', {
+			column1: jsonb(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(n1, schema2, []);
+	const { sqlStatements: pst, hints } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table1" ALTER COLUMN "column1" SET DATA TYPE jsonb USING "column1"::jsonb;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(hints).toStrictEqual([]);
+
+	// to be sure that table1 wasn't truncated
+	const res = await db.query(`select * from table1;`);
+	expect(res[0].column1).toStrictEqual({ b: 2 });
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2856
+test('alter text type to timestamp type', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			column1: text(),
+		}),
+	};
+
+	await push({ db, to: schema1 });
+	const { next: n1 } = await diff({}, schema1, []);
+	await db.query(`insert into table1 values ('2024-01-01 09:00:00.123456');`);
+
+	const schema2 = {
+		table1: pgTable('table1', {
+			column1: timestamp({ withTimezone: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(n1, schema2, []);
+	const { sqlStatements: pst, hints } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table1" ALTER COLUMN "column1" SET DATA TYPE timestamp with time zone USING "column1"::timestamp with time zone;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(hints).toStrictEqual([]);
+
+	// to be sure that table1 wasn't truncated
+	const res = await db.query(`select * from table1;`);
+	expect(res[0].column1).toBeDefined();
+	expect(res[0].column1).not.toBe(null);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2751
+test('alter text type to enum type', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			column1: text(),
+		}),
+	};
+
+	await push({ db, to: schema1 });
+	const { next: n1 } = await diff({}, schema1, []);
+	await db.query(`insert into table1 values ('admin');`);
+
+	const roles = ['admin', 'participant'] as const;
+	const roleEnum = pgEnum('role', roles);
+	const schema2 = {
+		roleEnum,
+		table1: pgTable('table1', {
+			column1: roleEnum(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(n1, schema2, []);
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE TYPE "role" AS ENUM('admin', 'participant');`,
+		'ALTER TABLE "table1" ALTER COLUMN "column1" SET DATA TYPE "role" USING "column1"::"role";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(hints).toStrictEqual([]);
+
+	// to be sure that table1 wasn't truncated
+	const res = await db.query(`select * from table1;`);
+	expect(res[0].column1).toBeDefined();
+	expect(res[0].column1).not.toBe(null);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3589
+// After discussion it was decided to postpone this feature
+test.skipIf(Date.now() < +new Date('2026-07-01'))('alter integer type to text type with fk constraints', async () => {
+	const users1 = pgTable('users', {
+		id: serial().primaryKey(),
+	});
+
+	const schema1 = {
+		users1,
+		sessions: pgTable('sessions', {
+			id: text().primaryKey(),
+			userId: integer().notNull().references(() => users1.id),
+		}),
+		content: pgTable('content', {
+			id: text().primaryKey(),
+			userId: integer().notNull().references(() => users1.id),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+	await db.query('insert into "users" values (1);');
+	await db.query('insert into "sessions" values (1,1);');
+	await db.query('insert into "content" values (1,1);');
+
+	const users2 = pgTable('users', {
+		id: text().primaryKey(),
+	});
+	const schema2 = {
+		users2,
+		sessions: pgTable('sessions', {
+			id: text().primaryKey(),
+			userId: text().notNull().references(() => users2.id),
+		}),
+		content: pgTable('content', {
+			id: text().primaryKey(),
+			userId: text().notNull().references(() => users2.id),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE "sessions" DROP CONSTRAINT "sessions_userId_users_id_fkey";',
+		'ALTER TABLE "content" DROP CONSTRAINT "content_userId_users_id_fkey";',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET DATA TYPE text;',
+		'ALTER TABLE "sessions" ALTER COLUMN "userId" SET DATA TYPE text;',
+		'ALTER TABLE "content" ALTER COLUMN "userId" SET DATA TYPE text;',
+		'ALTER TABLE "sessions" ADD CONSTRAINT "sessions_userId_users_id_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id");',
+		'ALTER TABLE "content" ADD CONSTRAINT "content_userId_users_id_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('alter table add composite pk', async (t) => {
+	const schema1 = {
+		table: pgTable('table', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}),
+	};
+
+	const schema2 = {
+		table: pgTable('table', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(
+		schema1,
+		schema2,
+		[],
+	);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = ['ALTER TABLE "table" ADD PRIMARY KEY ("id1","id2");'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table rename column #1', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users1', {
+			id: integer('id1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, [
+		'public.users->public.users1',
+		'public.users1.id->public.users1.id1',
+	]);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames: [
+			'public.users->public.users1',
+			'public.users1.id->public.users1.id1',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users1";',
+		'ALTER TABLE "users1" RENAME COLUMN "id" TO "id1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('with composite pks #1', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+			text: text('text'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = ['ALTER TABLE "users" ADD COLUMN "text" text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('with composite pks #2', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = ['ALTER TABLE "users" ADD CONSTRAINT "compositePK" PRIMARY KEY("id1","id2");'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('with composite pks #3', async (t) => {
+	const schema1 = {
+		users: pgTable(
+			'users',
+			{
+				id1: integer('id1'),
+				id2: integer('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2], name: 'compositePK' })],
+		),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id1: integer('id1'),
+			id3: integer('id3'),
+		}, (t) => [primaryKey({ columns: [t.id1, t.id3], name: 'compositePK' })]),
+	};
+
+	const renames = ['public.users.id2->public.users.id3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0 = ['ALTER TABLE "users" RENAME COLUMN "id2" TO "id3";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create composite primary key', async () => {
+	const schema1 = {};
+
+	const schema2 = {
+		table: pgTable('table', {
+			col1: integer('col1').notNull(),
+			col2: integer('col2').notNull(),
+		}, (t) => [primaryKey({
+			columns: [t.col1, t.col2],
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE "table" (\n\t"col1" integer,\n\t"col2" integer,\n\tCONSTRAINT "table_pkey" PRIMARY KEY("col1","col2")\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add multiple constraints #1', async (t) => {
+	const t1 = pgTable('t1', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const t2 = pgTable('t2', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const t3 = pgTable('t3', {
+		id: uuid('id').primaryKey().defaultRandom(),
+	});
+
+	const schema1 = {
+		t1,
+		t2,
+		t3,
+		ref1: pgTable('ref1', {
+			id1: uuid('id1').references(() => t1.id),
+			id2: uuid('id2').references(() => t2.id),
+			id3: uuid('id3').references(() => t3.id),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		t2,
+		t3,
+		ref1: pgTable('ref1', {
+			id1: uuid('id1').references(() => t1.id, { onDelete: 'cascade' }),
+			id2: uuid('id2').references(() => t2.id, { onDelete: 'set null' }),
+			id3: uuid('id3').references(() => t3.id, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id1_t1_id_fkey", ADD CONSTRAINT "ref1_id1_t1_id_fkey" FOREIGN KEY ("id1") REFERENCES "t1"("id") ON DELETE CASCADE;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id2_t2_id_fkey", ADD CONSTRAINT "ref1_id2_t2_id_fkey" FOREIGN KEY ("id2") REFERENCES "t2"("id") ON DELETE SET NULL;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id3_t3_id_fkey", ADD CONSTRAINT "ref1_id3_t3_id_fkey" FOREIGN KEY ("id3") REFERENCES "t3"("id") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add multiple constraints #2', async (t) => {
+	const t1 = pgTable('t1', {
+		id1: uuid('id1').unique(),
+		id2: uuid('id2').unique(),
+		id3: uuid('id3').unique(),
+	});
+
+	const schema1 = {
+		t1,
+		ref1: pgTable('ref1', {
+			id1: uuid('id1').references(() => t1.id1),
+			id2: uuid('id2').references(() => t1.id2),
+			id3: uuid('id3').references(() => t1.id3),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		ref1: pgTable('ref1', {
+			id1: uuid('id1').references(() => t1.id1, { onDelete: 'cascade' }),
+			id2: uuid('id2').references(() => t1.id2, { onDelete: 'set null' }),
+			id3: uuid('id3').references(() => t1.id3, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id1_t1_id1_fkey", ADD CONSTRAINT "ref1_id1_t1_id1_fkey" FOREIGN KEY ("id1") REFERENCES "t1"("id1") ON DELETE CASCADE;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id2_t1_id2_fkey", ADD CONSTRAINT "ref1_id2_t1_id2_fkey" FOREIGN KEY ("id2") REFERENCES "t1"("id2") ON DELETE SET NULL;',
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id3_t1_id3_fkey", ADD CONSTRAINT "ref1_id3_t1_id3_fkey" FOREIGN KEY ("id3") REFERENCES "t1"("id3") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add multiple constraints #3', async (t) => {
+	const t1 = pgTable('t1', {
+		id1: uuid('id1').unique(),
+		id2: uuid('id2').unique(),
+		id3: uuid('id3').unique(),
+	});
+
+	const schema1 = {
+		t1,
+		ref1: pgTable('ref1', {
+			id: uuid('id').references(() => t1.id1),
+		}),
+		ref2: pgTable('ref2', {
+			id: uuid('id').references(() => t1.id2),
+		}),
+		ref3: pgTable('ref3', {
+			id: uuid('id').references(() => t1.id3),
+		}),
+	};
+
+	const schema2 = {
+		t1,
+		ref1: pgTable('ref1', {
+			id: uuid('id').references(() => t1.id1, { onDelete: 'cascade' }),
+		}),
+		ref2: pgTable('ref2', {
+			id: uuid('id').references(() => t1.id2, { onDelete: 'set null' }),
+		}),
+		ref3: pgTable('ref3', {
+			id: uuid('id').references(() => t1.id3, { onDelete: 'cascade' }),
+		}),
+	};
+
+	// TODO: remove redundand drop/create create constraint
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "ref1" DROP CONSTRAINT "ref1_id_t1_id1_fkey", ADD CONSTRAINT "ref1_id_t1_id1_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id1") ON DELETE CASCADE;',
+		'ALTER TABLE "ref2" DROP CONSTRAINT "ref2_id_t1_id2_fkey", ADD CONSTRAINT "ref2_id_t1_id2_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id2") ON DELETE SET NULL;',
+		'ALTER TABLE "ref3" DROP CONSTRAINT "ref3_id_t1_id3_fkey", ADD CONSTRAINT "ref3_id_t1_id3_fkey" FOREIGN KEY ("id") REFERENCES "t1"("id3") ON DELETE CASCADE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('varchar and text default values escape single quotes', async () => {
+	const schema1 = {
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+			text: text('text').default("escape's quotes"),
+			varchar: varchar('varchar').default("escape's quotes"),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ADD COLUMN "text" text DEFAULT 'escape''s quotes';`,
+		`ALTER TABLE "table" ADD COLUMN "varchar" varchar DEFAULT 'escape''s quotes';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns with defaults', async () => {
+	const schema1 = {
+		table: pgTable('table', {
+			id: serial().primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: pgTable('table', {
+			id: serial().primaryKey(),
+			text1: text().default(''),
+			text2: text().default('text'),
+			int1: integer().default(10),
+			int2: integer().default(0),
+			int3: integer().default(-10),
+			bool1: boolean().default(true),
+			bool2: boolean().default(false),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "text1" text DEFAULT \'\';',
+		'ALTER TABLE "table" ADD COLUMN "text2" text DEFAULT \'text\';',
+		'ALTER TABLE "table" ADD COLUMN "int1" integer DEFAULT 10;',
+		'ALTER TABLE "table" ADD COLUMN "int2" integer DEFAULT 0;',
+		'ALTER TABLE "table" ADD COLUMN "int3" integer DEFAULT -10;',
+		'ALTER TABLE "table" ADD COLUMN "bool1" boolean DEFAULT true;',
+		'ALTER TABLE "table" ADD COLUMN "bool2" boolean DEFAULT false;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// TODO: check for created tables, etc
+});
+
+test('add array column - empty array default', async () => {
+	const schema1 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{}\'::integer[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add array column - default', async () => {
+	const schema1 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{1,2,3}\'::integer[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add not null to a column', async () => {
+	const schema1 = {
+		users: pgTable(
+			'User',
+			{
+				id: text('id').primaryKey().notNull(),
+				name: text('name'),
+				username: text('username'),
+				gh_username: text('gh_username'),
+				email: text('email'),
+				emailVerified: timestamp('emailVerified', {
+					precision: 3,
+					mode: 'date',
+				}),
+				image: text('image'),
+				createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
+					.default(sql`CURRENT_TIMESTAMP`)
+					.notNull(),
+				updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
+					.notNull()
+					.$onUpdate(() => new Date()),
+			},
+			(table) => [uniqueIndex('User_email_key').on(table.email)],
+		),
+	};
+
+	const schema2 = {
+		users: pgTable(
+			'User',
+			{
+				id: text('id').primaryKey().notNull(),
+				name: text('name'),
+				username: text('username'),
+				gh_username: text('gh_username'),
+				email: text('email').notNull(),
+				emailVerified: timestamp('emailVerified', {
+					precision: 3,
+					mode: 'date',
+				}),
+				image: text('image'),
+				createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
+					.default(sql`CURRENT_TIMESTAMP`)
+					.notNull(),
+				updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
+					.notNull()
+					.$onUpdate(() => new Date()),
+			},
+			(table) => [uniqueIndex('User_email_key').on(table.email)],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// TODO: revise should I use suggestion func?
+	// const { losses, hints } = await suggestions(db, statements);
+
+	expect(hints).toStrictEqual([]);
+});
+
+test('add not null to a column with null data. Should rollback', async () => {
+	const schema1 = {
+		users: pgTable('User', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+			username: text('username'),
+			gh_username: text('gh_username'),
+			email: text('email'),
+			emailVerified: timestamp('emailVerified', { precision: 3, mode: 'date' }),
+			image: text('image'),
+			createdAt: timestamp('createdAt', { precision: 3, mode: 'date' }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+			updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' }).notNull().$onUpdate(() => new Date()),
+		}, (table) => [uniqueIndex('User_email_key').on(table.email)]),
+	};
+
+	const schema2 = {
+		users: pgTable('User', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+			username: text('username'),
+			gh_username: text('gh_username'),
+			email: text('email').notNull(),
+			emailVerified: timestamp('emailVerified', { precision: 3, mode: 'date' }),
+			image: text('image'),
+			createdAt: timestamp('createdAt', { precision: 3, mode: 'date' }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+			updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' }).notNull().$onUpdate(() => new Date()),
+		}, (table) => [uniqueIndex('User_email_key').on(table.email)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	db.query(`INSERT INTO "User" (id, email, "updatedAt") values ('str', 'email@gmail', '2025-04-29 09:20:39');`);
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(hints).toStrictEqual([]);
+});
+
+test('add generated column', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name") STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add generated constraint to an existing column', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+		}),
+	};
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name") STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop generated constraint from a column', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
+		}),
+	};
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ALTER COLUMN "gen_name" DROP EXPRESSION;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('geometry point with srid', async () => {
+	const postgisDb = await preparePostgisTestDatabase();
+
+	try {
+		const schema1 = {
+			users: pgTable('users', {
+				id1: geometry('id1'),
+				id2: geometry('id2', { srid: 0 }),
+				id3: geometry('id3', { srid: 10 }),
+				id4: geometry('id4'),
+			}),
+		};
+		const schema2 = {
+			users: pgTable('users', {
+				id1: geometry('id1', { srid: 0 }),
+				id2: geometry('id2'),
+				id3: geometry('id3', { srid: 12 }),
+				id4: geometry('id4'),
+			}),
+		};
+
+		const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+		await push({
+			db: postgisDb.db,
+			to: schema1,
+			tables: ['users'],
+			schemas: ['public'],
+		});
+		const { sqlStatements: pst } = await push({
+			db: postgisDb.db,
+			to: schema2,
+			tables: ['users'],
+			schemas: ['public'],
+		});
+
+		const st0: string[] = [
+			'ALTER TABLE "users" ALTER COLUMN "id3" SET DATA TYPE geometry(point,12) USING "id3"::geometry(point,12);',
+		];
+
+		expect(st).toStrictEqual(st0);
+		expect(pst).toStrictEqual(st0);
+	} catch (error) {
+		await postgisDb.clear();
+		await postgisDb.close();
+		throw error;
+	}
+
+	await postgisDb.clear();
+	await postgisDb.close();
+});
+
+test('defaults: timestamptz with precision', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			time: timestamp('time', { withTimezone: true, precision: 6, mode: 'string' }).default(
+				'2023-12-12 13:00:00.123456',
+			),
+			time2: timestamp('time2', { withTimezone: true, precision: 6, mode: 'string' }).default(
+				'2023-12-12 13:00:00.123456',
+			),
+		}),
+	};
+	const schema2 = {
+		users: pgTable('users', {
+			time: timestamp('time', { withTimezone: true, precision: 6, mode: 'string' }).default(
+				'2023-12-12 13:00:00.123455',
+			),
+			time2: timestamp('time2', { withTimezone: true, precision: 6, mode: 'string' }).default(
+				'2023-12-12 13:00:00.123456',
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({
+		db,
+		to: schema1,
+		tables: ['users'],
+		schemas: ['public'],
+	});
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		tables: ['users'],
+		schemas: ['public'],
+	});
+
+	const st0: string[] = [
+		`ALTER TABLE "users" ALTER COLUMN "time" SET DEFAULT '2023-12-12 13:00:00.123455+00';`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4231
+// https://github.com/drizzle-team/drizzle-orm/issues/5119
+test('no diff for all column types', async () => {
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		columns: pgTable('columns', {
+			enum: myEnum('my_enum').default('a'),
+			smallint: smallint().default(10),
+			integer: integer().default(10),
+			numeric: numeric().default('99.9'),
+			numeric1: numeric({ precision: 3, scale: 1 }).default('99.9'),
+			numeric2: numeric({ precision: 1, scale: 1 }).default('99.9'),
+			numeric3: numeric({ precision: 78 }).default('999'),
+			bigint: bigint({ mode: 'number' }).default(100),
+			bigint1: bigint({ mode: 'bigint' }).default(100n),
+			boolean: boolean().default(true),
+			text: text().default('abc'),
+			text1: text().default(sql`gen_random_uuid()`),
+			text2: text().default('``'),
+			text3: text().default(''),
+			varchar: varchar({ length: 25 }).default('abc'),
+			varchar1: varchar({ length: 25 }).default(''),
+			varchar2: varchar({ length: 25 }).default('``'),
+			char: char({ length: 3 }).default('abc'),
+			char1: char({ length: 3 }).default(''),
+			char2: char({ length: 3 }).default('``'),
+			serial: serial(),
+			bigserial: bigserial({ mode: 'number' }),
+			smallserial: smallserial(),
+			doublePrecision: doublePrecision().default(100.12),
+			real: real().default(100.123),
+			json: json().default({ attr: 'value' }),
+			json1: json().default({ b: 2, a: 1 }),
+			jsonb: jsonb().default({ attr: 'value' }),
+			jsonb1: jsonb().default(sql`jsonb_build_object()`),
+			jsonb2: jsonb().default({}),
+			jsonb3: jsonb().default({ b: 2, a: 1 }),
+			time1: time().default('00:00:00'),
+			time2: time().defaultNow(),
+			timestamp1: timestamp({ withTimezone: true, precision: 6 }).default(new Date()),
+			timestamp2: timestamp({ withTimezone: true, precision: 6 }).defaultNow(),
+			timestamp3: timestamp({ withTimezone: true, precision: 6 }).default(sql`timezone('utc'::text, now())`),
+			date1: date().default('2024-01-01'),
+			date2: date().defaultNow(),
+			date3: date().default(sql`CURRENT_TIMESTAMP`),
+			uuid1: uuid().default('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'),
+			uuid2: uuid().defaultRandom(),
+			inet: inet().default('127.0.0.1'),
+			cidr: cidr().default('127.0.0.1/32'),
+			macaddr: macaddr().default('00:00:00:00:00:00'),
+			macaddr8: macaddr8().default('00:00:00:ff:fe:00:00:00'),
+			interval: interval().default('1 day 01:00:00'),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// TODO: remove this test after transfering all helpful .default(...) to pg-defaults.test.ts
+test('no diff for all column array types', async () => {
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		columns: pgTable('columns', {
+			enum: myEnum().array().default([]),
+			enum1: myEnum().array().default(['a', 'b']),
+			smallint: smallint().array().default([]),
+			smallint1: smallint().array().default([10, 20]),
+			integer: integer().array().default([]),
+			integer1: integer().array().default([10, 20]),
+			numeric: numeric({ precision: 3, scale: 1 }).array().default([]),
+			numeric1: numeric({ precision: 3, scale: 1 }).array().default(['99.9', '88.8']),
+			bigint: bigint({ mode: 'number' }).array().default([]),
+			bigint1: bigint({ mode: 'number' }).array().default([100, 200]),
+			boolean: boolean().array().default([]),
+			boolean1: boolean().array().default([true, false]),
+			text: text().array().default([]),
+			text1: text().array().default(['abc', 'def']),
+			varchar: varchar({ length: 25 }).array().default([]),
+			varchar1: varchar({ length: 25 }).array().default(['abc', 'def']),
+			char: char({ length: 3 }).array().default([]),
+			char1: char({ length: 3 }).array().default(['abc', 'def']),
+			doublePrecision: doublePrecision().array().default([]),
+			doublePrecision1: doublePrecision().array().default([100, 200]),
+			real: real().array().default([]),
+			real1: real().array().default([100, 200]),
+			json: json().array().default([]),
+			json1: json().array().default([{ attr: 'value1' }, { attr: 'value2' }]),
+			jsonb: jsonb().array().default([]),
+			jsonb1: jsonb().array().default(sql`'{}'`),
+			// jsonb2: jsonb().array().default([{ attr: 'value1' }, { attr: 'value2' }]),
+			time: time().array().default([]),
+			time1: time().array().default(['00:00:00', '01:00:00']),
+			timestamp: timestamp({ withTimezone: true, precision: 6 }).array().default([]),
+			timestamp1: timestamp({ withTimezone: true, precision: 6 }).array().default([
+				new Date(),
+				new Date(),
+			]),
+			date: date().array().default([]),
+			date1: date().array().default(['2024-01-01', '2024-01-02']),
+			uuid: uuid().array().default([]),
+			uuid1: uuid().array().default([
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12',
+			]),
+			inet: inet().array().default([]),
+			inet1: inet().array().default(['127.0.0.1', '127.0.0.2']),
+			cidr: cidr().array().default([]),
+			cidr1: cidr().array().default(['127.0.0.1/32', '127.0.0.2/32']),
+			macaddr: macaddr().array().default([]),
+			macaddr1: macaddr().array().default(['00:00:00:00:00:00', '00:00:00:00:00:01']),
+			macaddr8: macaddr8().array().default([]),
+			macaddr8_1: macaddr8().array().default(['00:00:00:ff:fe:00:00:00', '00:00:00:ff:fe:00:00:01']),
+			interval: interval().array().default([]),
+			interval1: interval().array().default(['1 day 01:00:00', '1 day 02:00:00']),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('no diff for enum and custom type in different schemas', async () => {
+	const mySchema = pgSchema('my_schema');
+	const mySchemaEnum = mySchema.enum('my_schema_enum', ['a', 'b', 'c']);
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		mySchema,
+		mySchemaEnum,
+		mySchemaTable: mySchema.table('my_schema_table', {
+			mySchemaEnum: mySchemaEnum().default('a'),
+			mySchemaCustomType: customType({
+				codec: 'tsvector',
+				dataType: () => 'tsvector',
+			})().default("to_tsvector('english'::regconfig, 'The Fat Rats'::text)"),
+		}),
+		myEnum,
+		table: pgTable('table', {
+			enum: myEnum().default('a'),
+			customType: customType({
+				codec: 'tsvector',
+				dataType: () => 'tsvector',
+			})().default("to_tsvector('english'::regconfig, 'The Fat Rats'::text)"),
+		}),
+	};
+
+	const schemas = ['public', 'my_schema'];
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema, schemas });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema, schemas });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('no diff for enum array type in different schemas', async () => {
+	const mySchema = pgSchema('my_schema');
+	const mySchemaEnum = mySchema.enum('my_schema_enum', ['a', 'b', 'c']);
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		mySchema,
+		mySchemaEnum,
+		mySchemaTable: mySchema.table('my_schema_table', {
+			mySchemaEnum: mySchemaEnum().array().default(['a']),
+			mySchemaEnum1: mySchemaEnum().array().default([]),
+		}),
+		myEnum,
+		table: pgTable('table', {
+			enum: myEnum().array().default([]),
+			enum1: myEnum().array().default(['a', 'b']),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('column with not null was renamed and dropped not null', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: serial().primaryKey(),
+			name: varchar('name').notNull(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: serial().primaryKey(),
+			name: varchar('name2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['public.users.name->public.users.name2']);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: to, renames: ['public.users.name->public.users.name2'] });
+	const { sqlStatements: sbsqSt } = await push({ db, to: to });
+
+	const st0: string[] = [
+		`ALTER TABLE "users" RENAME COLUMN "name" TO "name2";`,
+		`ALTER TABLE "users" ALTER COLUMN "name2" DROP NOT NULL;`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(sbsqSt).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2856
+test('alter text to timestamp', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: timestamp(),
+		}),
+	};
+
+	await push({ db, to: from });
+	const res = await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		'ALTER TABLE "users" ALTER COLUMN "name" SET DATA TYPE timestamp USING "name"::timestamp;',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2183
+test('alter integer type to serial type', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			col1: integer(),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema2 = {
+		table1: pgTable('table1', {
+			col1: serial(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'CREATE SEQUENCE "table1_col1_seq";',
+		`ALTER TABLE "table1" ALTER COLUMN \"col1\" SET DEFAULT nextval('table1_col1_seq')`,
+		'ALTER SEQUENCE "table1_col1_seq" OWNED BY "public"."table1"."col1";',
+		'ALTER TABLE "table1" ALTER COLUMN "col1" SET DATA TYPE int USING "col1"::int;',
+		'ALTER TABLE "table1" ALTER COLUMN "col1" SET NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('same column names in two tables. Check for correct not null creation. Explicit column names', async (t) => {
+	const users = pgTable(
+		'users',
+		{
+			id: integer('id').primaryKey(),
+			departmentId: integer('department_id').references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = pgTable(
+		'user_has_department_filter',
+		{
+			userId: integer('user_id').references(() => users.id),
+			departmentId: integer('department_id').references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = pgTable(
+		'departments',
+		{
+			id: integer('id').primaryKey(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE "departments" (
+\t"id" integer PRIMARY KEY
+);\n`,
+		`CREATE TABLE "user_has_department_filter" (
+\t"user_id" integer,
+\t"department_id" integer,
+\tCONSTRAINT "user_has_department_filter_pkey" PRIMARY KEY("user_id","department_id")
+);\n`,
+		`CREATE TABLE "users" (
+\t"id" integer PRIMARY KEY,
+\t"department_id" integer
+);\n`,
+
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_user_id_users_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id");`,
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_department_id_departments_id_fkey" FOREIGN KEY ("department_id") REFERENCES "departments"("id");`,
+		`ALTER TABLE "users" ADD CONSTRAINT "users_department_id_departments_id_fkey" FOREIGN KEY ("department_id") REFERENCES "departments"("id") ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #2. no casing', async (t) => {
+	const users = pgTable(
+		'users',
+		{
+			id: integer().primaryKey(),
+			departmentId: integer().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = pgTable(
+		'user_has_department_filter',
+		{
+			userId: integer().references(() => users.id),
+			departmentId: integer().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = pgTable(
+		'departments',
+		{
+			id: integer().primaryKey(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE "departments" (
+\t"id" integer PRIMARY KEY
+);\n`,
+		`CREATE TABLE "user_has_department_filter" (
+\t"userId" integer,
+\t"departmentId" integer,
+\tCONSTRAINT "user_has_department_filter_pkey" PRIMARY KEY("userId","departmentId")
+);\n`,
+		`CREATE TABLE "users" (
+\t"id" integer PRIMARY KEY,
+\t"departmentId" integer
+);\n`,
+
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_userId_users_id_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id");`,
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_departmentId_departments_id_fkey" FOREIGN KEY ("departmentId") REFERENCES "departments"("id");`,
+		`ALTER TABLE "users" ADD CONSTRAINT "users_departmentId_departments_id_fkey" FOREIGN KEY ("departmentId") REFERENCES "departments"("id") ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #3. camelCase', async (t) => {
+	const users = pgTable(
+		'users',
+		{
+			id: integer().primaryKey(),
+			departmentId: integer().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = pgTable(
+		'user_has_department_filter',
+		{
+			userId: integer().references(() => users.id),
+			departmentId: integer().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = pgTable(
+		'departments',
+		{
+			id: integer().primaryKey(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE "departments" (
+\t"id" integer PRIMARY KEY
+);\n`,
+		`CREATE TABLE "user_has_department_filter" (
+\t"userId" integer,
+\t"departmentId" integer,
+\tCONSTRAINT "user_has_department_filter_pkey" PRIMARY KEY("userId","departmentId")
+);\n`,
+		`CREATE TABLE "users" (
+\t"id" integer PRIMARY KEY,
+\t"departmentId" integer
+);\n`,
+
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_userId_users_id_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id");`,
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_departmentId_departments_id_fkey" FOREIGN KEY ("departmentId") REFERENCES "departments"("id");`,
+		`ALTER TABLE "users" ADD CONSTRAINT "users_departmentId_departments_id_fkey" FOREIGN KEY ("departmentId") REFERENCES "departments"("id") ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('same column names in two tables. Check for correct not null creation #4. snake_case', async (t) => {
+	const users = snakeCase.table(
+		'users',
+		{
+			id: integer().primaryKey(),
+			departmentId: integer().references(() => departments.id, { onDelete: 'set null' }),
+		},
+	);
+	const userHasDepartmentFilter = snakeCase.table(
+		'user_has_department_filter',
+		{
+			userId: integer().references(() => users.id),
+			departmentId: integer().references(() => departments.id),
+		},
+		(table) => {
+			return [primaryKey({ columns: [table.userId, table.departmentId] })];
+		},
+	);
+	const departments = snakeCase.table(
+		'departments',
+		{
+			id: integer().primaryKey(),
+		},
+	);
+
+	// order matters here
+	const schema1 = { departments, userHasDepartmentFilter, users };
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TABLE "departments" (
+\t"id" integer PRIMARY KEY
+);\n`,
+		`CREATE TABLE "user_has_department_filter" (
+\t"user_id" integer,
+\t"department_id" integer,
+\tCONSTRAINT "user_has_department_filter_pkey" PRIMARY KEY("user_id","department_id")
+);\n`,
+		`CREATE TABLE "users" (
+\t"id" integer PRIMARY KEY,
+\t"department_id" integer
+);\n`,
+
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_user_id_users_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id");`,
+		`ALTER TABLE "user_has_department_filter" ADD CONSTRAINT "user_has_department_filter_department_id_departments_id_fkey" FOREIGN KEY ("department_id") REFERENCES "departments"("id");`,
+		`ALTER TABLE "users" ADD CONSTRAINT "users_department_id_departments_id_fkey" FOREIGN KEY ("department_id") REFERENCES "departments"("id") ON DELETE SET NULL;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/postgres/pg-constraints.test.ts b/drizzle-kit/tests/postgres/pg-constraints.test.ts
new file mode 100644
index 0000000000..3f487796a0
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-constraints.test.ts
@@ -0,0 +1,2730 @@
+import { and, desc, isNull, SQL, sql } from 'drizzle-orm';
+import {
+	AnyPgColumn,
+	bigint,
+	boolean,
+	check,
+	foreignKey,
+	index,
+	integer,
+	pgTable,
+	primaryKey,
+	serial,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { interimToDDL } from 'src/dialects/postgres/ddl';
+import { fromDatabase } from 'src/ext/studio-postgres';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, drizzleToDDL, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('unique #1', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "users_name_key" UNIQUE("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #2', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('unique_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #3', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('unique_name', { nulls: 'distinct' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #4', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('unique_name', { nulls: 'not distinct' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE NULLS NOT DISTINCT("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #5', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('unique_name', { nulls: 'not distinct' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE NULLS NOT DISTINCT("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #6', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #7', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name).nullsNotDistinct()]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name" UNIQUE NULLS NOT DISTINCT("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #8', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "unique_name";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_name2" UNIQUE("name");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #9', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" RENAME CONSTRAINT "unique_name" TO "unique_name2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #10', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+			email: text().unique(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+			email2: text().unique(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.email->public.users.email2',
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.email->public.users.email2',
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" RENAME COLUMN "email" TO "email2";`,
+		`ALTER TABLE "users" RENAME CONSTRAINT "unique_name" TO "unique_name2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #11', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+			email: text(),
+		}, (t) => [
+			unique('unique_name').on(t.name),
+			unique('unique_email').on(t.email),
+		]),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+			email: text(),
+		}, (t) => [
+			unique('unique_name2').on(t.name),
+			unique('unique_email2').on(t.email),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users.unique_name->public.users.unique_name2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users.unique_name->public.users.unique_name2',
+		],
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" DROP CONSTRAINT "unique_email";`,
+		`ALTER TABLE "users" RENAME CONSTRAINT "unique_name" TO "unique_name2";`,
+		`ALTER TABLE "users" ADD CONSTRAINT "unique_email2" UNIQUE("email");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* rename table, unfortunately has to trigger constraint recreate */
+test('unique #12', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+	const to = {
+		users: pgTable('users2', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'public.users->public.users2',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [
+			'public.users->public.users2',
+		],
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #13', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text(),
+			email: text().unique(),
+		}),
+	};
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text(),
+			email2: text().unique('users_email_key'),
+		}),
+	};
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text(),
+			email2: text(),
+		}),
+	};
+
+	// sch1 -> sch2
+	const { sqlStatements: st1, next: n1 } = await diff(sch1, sch2, [
+		'public.users->public.users2',
+		'public.users2.email->public.users2.email2',
+	]);
+
+	await push({ db, to: sch1 });
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: sch2,
+		renames: [
+			'public.users->public.users2',
+			'public.users2.email->public.users2.email2',
+		],
+	});
+
+	const st10 = [
+		`ALTER TABLE "users" RENAME TO "users2";`,
+		`ALTER TABLE "users2" RENAME COLUMN "email" TO "email2";`,
+	];
+	expect(st1).toStrictEqual(st10);
+	expect(pst1).toStrictEqual(st10);
+
+	// sch2 -> sch3
+	const { sqlStatements: st2 } = await diff(n1, sch3, []);
+
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: sch3,
+	});
+
+	const st20 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_email_key";',
+	];
+	expect(st2).toStrictEqual(st20);
+	expect(pst2).toStrictEqual(st20);
+});
+
+test('unique multistep #1', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = ['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.name->public.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e3 = ['ALTER TABLE "users2" DROP CONSTRAINT "users_name_key";'];
+
+	expect(pst4).toStrictEqual(e3);
+	expect(st4).toStrictEqual(e3);
+});
+
+test('unique multistep #2', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const r1 = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, r1);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames: r1 });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(pst2).toStrictEqual(e2);
+	expect(st2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_name_key";']);
+	expect(pst5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_name_key";']);
+});
+
+test('unique multistep #3', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.name->public.users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_name_key";',
+		'ALTER TABLE "users2" ADD CONSTRAINT "name_unique" UNIQUE("name2");',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "name_unique";']);
+	expect(pst5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "name_unique";']);
+});
+
+test('unique multistep #4', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text UNIQUE\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2, renames });
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const renames2 = ['public.users2.users_name_key->public.users2.name_unique'];
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, renames2);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_name_key" TO "name_unique";']);
+	expect(pst4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_name_key" TO "name_unique";']);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	expect(st5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "name_unique";']);
+	expect(pst5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "name_unique";']);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4789
+test('unique multistep #5', async () => {
+	const table1 = pgTable('table1', {
+		column1: integer().notNull().primaryKey(),
+		column2: integer().notNull(),
+	}, (table) => [
+		unique().on(table.column1, table.column2),
+	]);
+	const table2 = pgTable('table2', {
+		column1: integer().notNull(),
+		column2: integer().notNull(),
+	}, (table) => [
+		foreignKey({
+			columns: [table.column2, table.column1],
+			foreignColumns: [table1.column2, table1.column1],
+		}),
+	]);
+	const sch1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n'
+		+ '\t"column1" integer PRIMARY KEY,\n'
+		+ '\t"column2" integer NOT NULL,\n'
+		+ '\tCONSTRAINT "table1_column1_column2_unique" UNIQUE("column1","column2")\n'
+		+ ');\n',
+		'CREATE TABLE "table2" (\n\t"column1" integer NOT NULL,\n\t"column2" integer NOT NULL\n);\n',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_column2_column1_table1_column2_column1_fkey" FOREIGN KEY ("column2","column1") REFERENCES "table1"("column2","column1");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, sch1, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch1 });
+
+	const expectedSt2: string[] = [];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4638
+test('uniqueIndex multistep #1', async () => {
+	const table1 = pgTable('table1', {
+		column1: integer().notNull().primaryKey(),
+		column2: integer().notNull(),
+	}, (table) => [
+		uniqueIndex('table1_unique').on(table.column1, table.column2),
+	]);
+	const table2 = pgTable('table2', {
+		column1: integer().notNull(),
+		column2: integer().notNull(),
+	}, (table) => [
+		foreignKey({
+			columns: [table.column1, table.column2],
+			foreignColumns: [table1.column1, table1.column2],
+		}),
+	]);
+	const sch1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n'
+		+ '\t"column1" integer PRIMARY KEY,\n'
+		+ '\t"column2" integer NOT NULL\n'
+		+ ');\n',
+		'CREATE TABLE "table2" (\n\t"column1" integer NOT NULL,\n\t"column2" integer NOT NULL\n);\n',
+		'CREATE UNIQUE INDEX "table1_unique" ON "table1" ("column1","column2");',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_column1_column2_table1_column1_column2_fkey" FOREIGN KEY ("column1","column2") REFERENCES "table1"("column1","column2");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, sch1, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch1 });
+
+	const expectedSt2: string[] = [];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('index multistep #1', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" text\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	expect(st4).toStrictEqual(['DROP INDEX "users_name_index";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "users_name_index";']);
+});
+
+test('index multistep #2', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" text\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'DROP INDEX "users_name_index";',
+		'CREATE INDEX "name2_idx" ON "users2" ("name2");',
+	];
+	expect(st3).toStrictEqual(e3);
+	expect(pst3).toStrictEqual(e3);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test('index multistep #3', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" text\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const renames2 = [
+		'public.users2.users_name_index->public.users2.name2_idx',
+	];
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, renames2);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st3).toStrictEqual(['ALTER INDEX "users_name_index" RENAME TO "name2_idx";']);
+	expect(pst3).toStrictEqual(['ALTER INDEX "users_name_index" RENAME TO "name2_idx";']);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test('index multistep #3', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"name" text\n);\n',
+		'CREATE INDEX "users_name_index" ON "users" ("name");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index().on(t.name)]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [index('name2_idx').on(t.name)]),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch3, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'DROP INDEX "users_name_index";',
+		'CREATE INDEX "name2_idx" ON "users2" ("name2");',
+	];
+	expect(st3).toStrictEqual(e3);
+	expect(pst3).toStrictEqual(e3);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch4 });
+
+	expect(st4).toStrictEqual(['DROP INDEX "name2_idx";']);
+	expect(pst4).toStrictEqual(['DROP INDEX "name2_idx";']);
+});
+
+test('pk #1', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(st).toStrictEqual(['ALTER TABLE "users" ADD PRIMARY KEY ("name");']);
+	expect(pst).toStrictEqual(['ALTER TABLE "users" ADD PRIMARY KEY ("name");']);
+});
+
+test('pk #2', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #3', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #4', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #5', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users" ALTER COLUMN "name" DROP NOT NULL;',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #6', async () => {
+	const from = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users" ALTER COLUMN "name" DROP NOT NULL;',
+	];
+	expect(sqlStatements).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4779
+// https://github.com/drizzle-team/drizzle-orm/issues/4944
+test('pk multistep #1', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').primaryKey(),
+		}),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const st04 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users2" ALTER COLUMN "name2" DROP NOT NULL;',
+	];
+	expect(st4).toStrictEqual(st04);
+	expect(pst4).toStrictEqual(st04);
+});
+
+test('pk multistep #2', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().primaryKey().notNull(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2').notNull(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2').notNull(),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const renames2 = ['public.users2.users_pkey->public.users2.users2_pk'];
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, renames2);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3, renames: renames2 });
+
+	expect(st4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_pkey" TO "users2_pk";']);
+	expect(pst4).toStrictEqual(['ALTER TABLE "users2" RENAME CONSTRAINT "users_pkey" TO "users2_pk";']);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+
+	expect(st5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users2_pk";']);
+	expect(pst5).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users2_pk";']);
+});
+
+test('pk multistep #3', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+	expect(pst1).toStrictEqual(['CREATE TABLE "users" (\n\t"name" text PRIMARY KEY\n);\n']);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const renames = [
+		'public.users->public.users2',
+		'public.users2.name->public.users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "name" TO "name2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}, (t) => [primaryKey({ name: 'users2_pk', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users2" ADD CONSTRAINT "users2_pk" PRIMARY KEY("name2");',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: pgTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+
+	const st05 = [
+		'ALTER TABLE "users2" DROP CONSTRAINT "users2_pk";',
+		'ALTER TABLE "users2" ALTER COLUMN "name2" DROP NOT NULL;',
+	];
+	expect(st5).toStrictEqual(st05);
+	expect(pst5).toStrictEqual(st05);
+});
+
+test('pk multistep #4', async () => {
+	const sch1 = {
+		users: pgTable('users', {
+			name: text().primaryKey(),
+		}, (t) => [
+			primaryKey({ name: 'users_pk', columns: [t.name] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" text,\n\tCONSTRAINT "users_pk" PRIMARY KEY("name")\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE "users" (\n\t"name" text,\n\tCONSTRAINT "users_pk" PRIMARY KEY("name")\n);\n',
+	]);
+
+	const sch2 = {
+		users: pgTable('users2', {
+			name: text().primaryKey(),
+		}, (t) => [
+			primaryKey({ name: 'users_pk', columns: [t.name] }),
+		]),
+	};
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3380
+// https://github.com/drizzle-team/drizzle-orm/issues/3189
+test('composite pk multistep #1', async () => {
+	const table1 = pgTable('table1', {
+		id: text('id').notNull(),
+		dbtProjectId: text('dbt_project_id').notNull(),
+	}, (table) => [
+		primaryKey({ columns: [table.dbtProjectId, table.id] }),
+	]);
+
+	const table2 = pgTable('table2', {
+		dbtProjectId: text('dbt_project_id').notNull(),
+		dbtBranchId: text('dbt_branch_id').notNull(),
+	}, (t) => [
+		foreignKey({
+			columns: [t.dbtProjectId, t.dbtBranchId],
+			foreignColumns: [table1.dbtProjectId, table1.id],
+		}),
+	]);
+
+	const schema = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n'
+		+ '\t"id" text,\n'
+		+ '\t"dbt_project_id" text,\n'
+		+ '\tCONSTRAINT "table1_pkey" PRIMARY KEY("dbt_project_id","id")\n'
+		+ ');\n',
+		'CREATE TABLE "table2" (\n'
+		+ '\t"dbt_project_id" text NOT NULL,\n'
+		+ '\t"dbt_branch_id" text NOT NULL\n'
+		+ ');\n',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_kbxVCdKFtrgY_fkey" FOREIGN KEY ("dbt_project_id","dbt_branch_id") REFERENCES "table1"("dbt_project_id","id");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3496
+test('remove/add pk', async (t) => {
+	const Step = pgTable('Step', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+	});
+	const schema1 = {
+		Step1: Step,
+		Branch: pgTable('Branch', {
+			id: bigint({ mode: 'number' }).primaryKey(),
+			stepId: bigint({ mode: 'number' }).references(() => Step.id, { onDelete: 'cascade' }),
+		}),
+	};
+	const schema2 = {
+		Step,
+		Branch: pgTable('Branch', {
+			stepId: bigint({ mode: 'number' }).primaryKey().references(() => Step.id, { onDelete: 'cascade' }),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE "Branch" DROP COLUMN "id";',
+		'ALTER TABLE "Branch" ADD PRIMARY KEY ("stepId");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('remove/add pk #2', async (t) => {
+	const Step = pgTable('Step', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+	});
+	const schema1 = {
+		Step1: Step,
+		Branch: pgTable('Branch', {
+			id: bigint({ mode: 'number' }).primaryKey(),
+			stepId: bigint({ mode: 'number' }).references(() => Step.id, { onDelete: 'cascade' }),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema2 = {
+		Step,
+		Branch: pgTable('Branch', {
+			stepId: bigint({ mode: 'number' }).references(() => Step.id, { onDelete: 'cascade' }),
+			stepId2: bigint({ mode: 'number' }).primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE "Branch" ADD COLUMN "stepId2" bigint;',
+		'ALTER TABLE "Branch" DROP COLUMN "id";',
+		'ALTER TABLE "Branch" ADD PRIMARY KEY ("stepId2");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('alter pk from single to composite with column deletion', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+		age: integer(),
+		name: varchar(),
+	});
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		age: integer(),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.age, t.name] })]);
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" DROP COLUMN "id";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("age","name");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('alter pk from composite to single with column deletion', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.age, t.name] })]);
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+		age: integer(),
+	});
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" DROP COLUMN "name";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("id");',
+		'ALTER TABLE "users" ALTER COLUMN "age" DROP NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('alter pk from composite to composite with column deletion', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.age, t.name] })]);
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.id, t.name] })]);
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" DROP COLUMN "age";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("id","name");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('alter pk from single to single with column creation', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+		age: integer(),
+	});
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+		name: varchar().primaryKey(),
+	});
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" ADD COLUMN "name" varchar;',
+		'ALTER TABLE "users" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("name");',
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('alter pk from single to composite with column creation', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }).primaryKey(),
+		age: integer(),
+	});
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.id, t.name] })]);
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" ADD COLUMN "name" varchar;',
+		'ALTER TABLE "users" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("id","name");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+test('alter pk from composite to composite with column creation', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+	}, (t) => [primaryKey({ columns: [t.id, t.age] })]);
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: integer(),
+		name: varchar(),
+	}, (t) => [primaryKey({ columns: [t.id, t.name] })]);
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		'ALTER TABLE "users" ADD COLUMN "name" varchar;',
+		'ALTER TABLE "users" DROP CONSTRAINT "users_pkey";',
+		'ALTER TABLE "users" ADD PRIMARY KEY ("id","name");',
+		'ALTER TABLE "users" ALTER COLUMN "age" DROP NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3117
+test('add column with pk to table where was no pk', async (t) => {
+	const schema1 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+	});
+
+	const { next: n1 } = await diff({}, { schema1 }, []);
+	await push({ db, to: { schema1 } });
+
+	const schema2 = pgTable('users', {
+		id: bigint({ mode: 'number' }),
+		age: bigint({ mode: 'number' }).primaryKey(),
+	});
+
+	const { sqlStatements: st2 } = await diff(n1, { schema2 }, []);
+	const { sqlStatements: pst2 } = await push({ db, to: { schema2 } });
+
+	const expectedSt2 = [
+		`ALTER TABLE "users" ADD COLUMN "age" bigint;`,
+		`ALTER TABLE "users" ADD PRIMARY KEY ("age");`,
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1144#issuecomment-1960807398
+test('rename table with composite pk', async () => {
+	const users = pgTable('users', {
+		id: text('id').primaryKey(),
+		fullName: text('full_name'),
+		email: text('email').unique().notNull(),
+		phone: text('phone'),
+		hashedPassword: text('hashed_password'),
+		updatedAt: timestamp('updated_at').notNull().defaultNow(),
+		createdAt: timestamp('created_at').notNull().defaultNow(),
+	});
+
+	const session = pgTable('session', {
+		id: text('id').primaryKey(),
+		userId: text('user_id')
+			.notNull()
+			.references(() => users.id),
+		expiresAt: timestamp('expires_at', {
+			withTimezone: true,
+			mode: 'date',
+		}).notNull(),
+	});
+
+	const oauthAccount = pgTable(
+		'oauth_account',
+		{
+			providerId: text('provider_id').notNull(),
+			providerUserId: text('provider_user_id').notNull(),
+			userId: text('user_id')
+				.notNull()
+				.references(() => users.id),
+			createdAt: timestamp('created_at', {
+				withTimezone: true,
+				mode: 'date',
+			})
+				.notNull()
+				.defaultNow(),
+		},
+		(table) => {
+			return {
+				pk: primaryKey({ columns: [table.providerId, table.userId] }),
+			};
+		},
+	);
+
+	const schema1 = { oauthAccount, session, users };
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const user = pgTable('users', {
+		id: text('id').primaryKey(),
+		fullName: text('full_name'),
+		email: text('email').unique().notNull(),
+		phone: text('phone'),
+		hashedPassword: text('hashed_password'),
+		updatedAt: timestamp('updated_at').notNull().defaultNow(),
+		createdAt: timestamp('created_at').notNull().defaultNow(),
+	});
+
+	const session2 = pgTable('sessions', {
+		id: text('id').primaryKey(),
+		userId: text('user_id')
+			.notNull()
+			.references(() => user.id),
+		expiresAt: timestamp('expires_at', {
+			withTimezone: true,
+			mode: 'date',
+		}).notNull(),
+	});
+
+	const oauthAccount2 = pgTable(
+		'oauth_accounts',
+		{
+			providerId: text('provider_id').notNull(),
+			providerUserId: text('provider_user_id').notNull(),
+			userId: text('user_id')
+				.notNull()
+				.references(() => user.id),
+			createdAt: timestamp('created_at', {
+				withTimezone: true,
+				mode: 'date',
+			})
+				.notNull()
+				.defaultNow(),
+		},
+		(table) => [primaryKey({ columns: [table.providerId, table.userId] })],
+	);
+
+	const schema2 = { user, session2, oauthAccount2 };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, [
+		'public.oauth_account->public.oauth_accounts',
+		'public.session->public.sessions',
+	]);
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: schema2,
+		renames: ['public.oauth_account->public.oauth_accounts', 'public.session->public.sessions'],
+	});
+	const expectedSt2 = [
+		'ALTER TABLE "oauth_account" RENAME TO "oauth_accounts";',
+		'ALTER TABLE "session" RENAME TO "sessions";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4369
+test('fk #1', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+	});
+	const posts = pgTable('posts', {
+		id: serial().primaryKey(),
+		authorId: integer().references(() => users.id),
+	});
+
+	const to = {
+		posts,
+		users,
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \"posts\" (\n\t"id" serial PRIMARY KEY,\n\t"authorId" integer\n);\n`,
+		`CREATE TABLE "users" (\n\t"id" serial PRIMARY KEY\n);\n`,
+		`ALTER TABLE "posts" ADD CONSTRAINT "posts_authorId_users_id_fkey" FOREIGN KEY ("authorId") REFERENCES "users"("id");`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// exactly 63 symbols fkey, fkey name explicit
+test('fk #2', async () => {
+	const users = pgTable('123456789_123456789_users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "123456789_123456789_users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n`,
+		'ALTER TABLE "123456789_123456789_users" ADD CONSTRAINT "123456789_123456789_users_id2_123456789_123456789_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "123456789_123456789_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// 65 symbols fkey, fkey = table_hash_fkey
+test('fk #3', async () => {
+	const users = pgTable('1234567890_1234567890_users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "1234567890_1234567890_users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n`,
+		'ALTER TABLE "1234567890_1234567890_users" ADD CONSTRAINT "1234567890_1234567890_users_2Ge3281eRCJ5_fkey" FOREIGN KEY ("id2") REFERENCES "1234567890_1234567890_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// >=45 length table name, fkey = hash_fkey
+test('fk #4', async () => {
+	const users = pgTable('1234567890_1234567890_1234567890_123456_users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "1234567890_1234567890_1234567890_123456_users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n`,
+		'ALTER TABLE "1234567890_1234567890_1234567890_123456_users" ADD CONSTRAINT "ydU6odH887YL_fkey" FOREIGN KEY ("id2") REFERENCES "1234567890_1234567890_1234567890_123456_users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #5', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE "users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n`,
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #6', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const users2 = pgTable('users2', {
+		id: serial('id3').primaryKey(),
+		id2: integer().references((): AnyPgColumn => users2.id),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2', 'public.users2.id->public.users2.id3'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "id" TO "id3";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #7', async () => {
+	const users = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id1),
+	});
+
+	const users2 = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer(),
+	}, (t) => [foreignKey({ name: 'id2_id1_fk', columns: [t.id2], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users.users_id2_users_id1_fkey->public.users.id2_id1_fk'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME CONSTRAINT "users_id2_users_id1_fkey" TO "id2_id1_fk";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #8', async () => {
+	const users = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().unique(),
+		id3: integer().references((): AnyPgColumn => users.id1),
+	});
+
+	const users2 = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().unique(),
+		id3: integer().references((): AnyPgColumn => users.id2),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		'ALTER TABLE "users" DROP CONSTRAINT "users_id3_users_id1_fkey";',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id3_users_id2_fkey" FOREIGN KEY ("id3") REFERENCES "users"("id2");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #9', async () => {
+	const users = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().unique(),
+		id3: integer(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const users2 = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().unique(),
+		id3: integer(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id2] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		'ALTER TABLE "users" DROP CONSTRAINT "fk1", ADD CONSTRAINT "fk1" FOREIGN KEY ("id3") REFERENCES "users"("id2");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #10', async () => {
+	const users = pgTable('users', {
+		id1: serial().primaryKey(),
+	});
+
+	const users2 = pgTable('users2', {
+		id1: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users2.id1),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" ADD COLUMN "id2" integer;',
+		'ALTER TABLE "users2" ADD CONSTRAINT "users2_id2_users2_id1_fkey" FOREIGN KEY ("id2") REFERENCES "users2"("id1");',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #11', async () => {
+	const users = pgTable('users', {
+		id1: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id1),
+	});
+
+	const users2 = pgTable('users2', {
+		id1: serial().primaryKey(),
+		id2: integer(),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['public.users->public.users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id1_fkey";',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk multistep #1', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const users2 = pgTable('users2', {
+		id: serial('id3').primaryKey(),
+		id2: integer().references((): AnyPgColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const renames = ['public.users->public.users2', 'public.users2.id->public.users2.id3'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER TABLE "users2" RENAME COLUMN "id" TO "id3";',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const users3 = pgTable('users2', {
+		id: serial('id3').primaryKey(),
+		id2: integer(),
+	});
+	const sch3 = { users: users3 };
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id_fkey";']);
+	expect(pst4).toStrictEqual(['ALTER TABLE "users2" DROP CONSTRAINT "users_id2_users_id_fkey";']);
+});
+
+test('fk multistep #2', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+		id2: integer().references((): AnyPgColumn => users.id),
+	});
+
+	const users2 = pgTable('users2', {
+		id: serial('id3').primaryKey(),
+		id2: integer().references((): AnyPgColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE "users" (\n\t"id" serial PRIMARY KEY,\n\t"id2" integer\n);\n',
+		'ALTER TABLE "users" ADD CONSTRAINT "users_id2_users_id_fkey" FOREIGN KEY ("id2") REFERENCES "users"("id");',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2 });
+
+	const e2 = [
+		'CREATE TABLE "users2" (\n\t"id3" serial PRIMARY KEY,\n\t"id2" integer\n);\n',
+		'DROP TABLE "users";',
+		'ALTER TABLE "users2" ADD CONSTRAINT "users2_id2_users2_id3_fkey" FOREIGN KEY ("id2") REFERENCES "users2"("id3");',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+test('fk multistep #3', async () => {
+	const users = pgTable('users', {
+		id: serial().primaryKey(),
+		id2: integer(),
+	}, (t) => [
+		foreignKey({ name: 'users_id2_id1_fkey', columns: [t.id2], foreignColumns: [t.id] }),
+	]);
+
+	const { ddl: ddl1 } = drizzleToDDL({ users });
+	const { ddl: ddl2 } = drizzleToDDL({ users });
+	ddl2.tables.update({
+		set: { name: 'users2' },
+		where: { name: 'users' },
+	});
+
+	const { sqlStatements: st1 } = await diff(ddl1, ddl2, ['public.users->public.users2']);
+	expect(st1).toStrictEqual(['ALTER TABLE "users" RENAME TO "users2";']);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456#issuecomment-3076042688
+test('fk multistep #4', async () => {
+	const foo = pgTable('foo', {
+		id: integer().primaryKey(),
+	});
+
+	const bar = pgTable('bar', {
+		id: integer().primaryKey(),
+		fooId: integer().references(() => foo.id),
+	});
+
+	const schema1 = { foo, bar };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "foo" (\n\t"id" integer PRIMARY KEY\n);\n',
+		'CREATE TABLE "bar" (\n\t"id" integer PRIMARY KEY,\n\t"fooId" integer\n);\n',
+		'ALTER TABLE "bar" ADD CONSTRAINT "bar_fooId_foo_id_fkey" FOREIGN KEY ("fooId") REFERENCES "foo"("id");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		bar: pgTable('bar', {
+			id: integer().primaryKey(),
+			fooId: integer(),
+		}),
+	};
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE "bar" DROP CONSTRAINT "bar_fooId_foo_id_fkey";',
+		'DROP TABLE "foo";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('unique multistep #3', async () => {
+	await db.query(`CREATE TABLE "users" ("id" integer CONSTRAINT "id_uniq" UNIQUE);`);
+	const interim = await fromDatabase(db);
+	const { ddl: ddl1 } = interimToDDL(interim);
+	const { ddl: ddl2 } = interimToDDL(interim);
+
+	ddl2.tables.update({
+		set: { name: 'users2' },
+		where: { name: 'users' },
+	});
+
+	const { sqlStatements: st1 } = await diff(ddl1, ddl2, ['public.users->public.users2']);
+	expect(st1).toStrictEqual(['ALTER TABLE "users" RENAME TO "users2";']);
+});
+
+test('constraints order', async () => {
+	const users = pgTable('users', {
+		col1: text(),
+		col2: text(),
+	}, (t) => [
+		unique().on(t.col1, t.col2),
+	]);
+
+	const posts = pgTable('posts', {
+		col1: text(),
+		col2: text(),
+	}, (t) => [
+		foreignKey({ columns: [t.col1, t.col2], foreignColumns: [users.col1, users.col2] }),
+	]);
+
+	const to = {
+		users,
+		posts,
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3260
+test('constraints order #2', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			col1: text(),
+			col2: text(),
+			col3: text(),
+		}),
+		table2: pgTable('table2', {
+			col1: text(),
+		}),
+		table3: pgTable('table3', {
+			col1: text(),
+			col2: text(),
+			col3: text(),
+			col4: text(),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const table1 = pgTable('table1', {
+		col1: text().unique(),
+		col2: text(),
+		col3: text(),
+	}, (t) => [
+		unique().on(t.col2, t.col3),
+	]);
+
+	const table2 = pgTable('table2', {
+		col1: text(),
+	}, (t) => [
+		uniqueIndex().on(t.col1),
+	]);
+
+	const schema2 = {
+		table1,
+		table2,
+		table3: pgTable('table3', {
+			col1: text().references(() => table1.col1),
+			col2: text(),
+			col3: text(),
+			col4: text().references(() => table2.col1),
+		}, (t) => [
+			foreignKey({ columns: [t.col2, t.col3], foreignColumns: [table1.col2, table1.col3] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE "table1" ADD CONSTRAINT "table1_col2_col3_unique" UNIQUE("col2","col3");',
+		'ALTER TABLE "table1" ADD CONSTRAINT "table1_col1_key" UNIQUE("col1");',
+		'CREATE UNIQUE INDEX "table2_col1_index" ON "table2" ("col1");',
+		'ALTER TABLE "table3" ADD CONSTRAINT "table3_col1_table1_col1_fkey" FOREIGN KEY ("col1") REFERENCES "table1"("col1");',
+		'ALTER TABLE "table3" ADD CONSTRAINT "table3_col4_table2_col1_fkey" FOREIGN KEY ("col4") REFERENCES "table2"("col1");',
+		'ALTER TABLE "table3" ADD CONSTRAINT "table3_col2_col3_table1_col2_col3_fkey" FOREIGN KEY ("col2","col3") REFERENCES "table1"("col2","col3");',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('generated + fk', async (t) => {
+	const table1 = pgTable(
+		'table_with_gen',
+		{
+			column1: timestamp('column1'),
+			column2: timestamp('column2'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => isNull(table1.column1),
+				).unique()
+				.notNull(),
+		},
+	);
+	const table = pgTable('table', { bool: boolean().references(() => table1.bool) });
+
+	const schema1 = { tableWithGen: table1, table };
+
+	const table2 = pgTable(
+		'table_with_gen',
+		{
+			column1: timestamp('column1'),
+			column2: timestamp('column2'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => isNull(table1.column2),
+				).unique()
+				.notNull(),
+		},
+	);
+	const schema2 = { tableWithGen: table2, table };
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'ALTER TABLE "table" DROP CONSTRAINT "table_bool_table_with_gen_bool_fkey";',
+		`ALTER TABLE \"table_with_gen\" DROP COLUMN \"bool\";`,
+		`ALTER TABLE \"table_with_gen\" ADD COLUMN \"bool\" boolean GENERATED ALWAYS AS (("table_with_gen"."column2" is null)) STORED;`,
+		'ALTER TABLE "table_with_gen" ADD CONSTRAINT "table_with_gen_bool_key" UNIQUE("bool");',
+		'ALTER TABLE "table" ADD CONSTRAINT "table_bool_table_with_gen_bool_fkey" FOREIGN KEY ("bool") REFERENCES "table_with_gen"("bool");',
+	]);
+	// push is not triggered on generated change
+	expect(pst).toStrictEqual([]);
+});
+test('generated + unique', async (t) => {
+	const table1 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column2: timestamp('column2'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table1.column1), isNull(table1.column2))!,
+				).unique()
+				.notNull(),
+		},
+	);
+	const schema1 = { table: table1 };
+
+	const table2 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column3: timestamp('column3'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table2.column1), isNull(table2.column3))!,
+				).unique()
+				.notNull(),
+		},
+	);
+	const schema2 = { table: table2 };
+
+	const renames = ['public.table.column2->public.table.column3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+		`ALTER TABLE \"table\" DROP COLUMN \"bool\";`,
+		`ALTER TABLE \"table\" ADD COLUMN \"bool\" boolean GENERATED ALWAYS AS ((((\"table\".\"column1\" is null)) and ((\"table\".\"column3\" is null)))) STORED;`,
+		'ALTER TABLE "table" ADD CONSTRAINT "table_bool_key" UNIQUE("bool");',
+	]);
+	// push is not triggered on generated change
+	expect(pst).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+	]);
+});
+test('generated + pk', async (t) => {
+	const table1 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column2: timestamp('column2'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table1.column1), isNull(table1.column2))!,
+				).primaryKey()
+				.notNull(),
+		},
+	);
+	const schema1 = { table: table1 };
+
+	const table2 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column3: timestamp('column3'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table2.column1), isNull(table2.column3))!,
+				).primaryKey()
+				.notNull(),
+		},
+	);
+	const schema2 = { table: table2 };
+
+	const renames = ['public.table.column2->public.table.column3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+		`ALTER TABLE \"table\" DROP COLUMN \"bool\";`,
+		`ALTER TABLE \"table\" ADD COLUMN \"bool\" boolean PRIMARY KEY GENERATED ALWAYS AS ((((\"table\".\"column1\" is null)) and ((\"table\".\"column3\" is null)))) STORED;`,
+	]);
+	// push is not triggered on generated change
+	expect(pst).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4456
+test('drop column with pk and add pk to another column #1', async () => {
+	const schema1 = {
+		authors: pgTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID] }),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "authors" (\n\t"publication_id" varchar(64),\n\t"author_id" varchar(10),'
+		+ '\n\tCONSTRAINT "authors_pkey" PRIMARY KEY("publication_id","author_id")\n);\n',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authors: pgTable('authors', {
+			publicationId: varchar('publication_id', { length: 64 }),
+			authorID: varchar('author_id', { length: 10 }),
+			orcidId: varchar('orcid_id', { length: 64 }),
+		}, (table) => [
+			primaryKey({ columns: [table.publicationId, table.authorID, table.orcidId] }),
+		]),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'ALTER TABLE "authors" ADD COLUMN "orcid_id" varchar(64);',
+		'ALTER TABLE "authors" DROP CONSTRAINT "authors_pkey";',
+		'ALTER TABLE "authors" ADD PRIMARY KEY ("publication_id","author_id","orcid_id");',
+	];
+
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4645
+// https://github.com/drizzle-team/drizzle-orm/issues/3280
+test('fk name is too long', async () => {
+	const table1 = pgTable(
+		'table1_loooooong',
+		{
+			column1: integer('column1_looooong').primaryKey(),
+		},
+	);
+	const table2 = pgTable(
+		'table2_loooooong',
+		{
+			column1: integer('column1_looooong').references(() => table1.column1).notNull(),
+		},
+	);
+	const to = { table1, table2 };
+
+	const { sqlStatements: st, next: n } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+	const expectedSt: string[] = [
+		'CREATE TABLE "table1_loooooong" (\n\t"column1_looooong" integer PRIMARY KEY\n);\n',
+		'CREATE TABLE "table2_loooooong" (\n\t"column1_looooong" integer NOT NULL\n);\n',
+		'ALTER TABLE "table2_loooooong" ADD CONSTRAINT "table2_loooooong_KObGFnvgHDVg_fkey" FOREIGN KEY ("column1_looooong") REFERENCES "table1_loooooong"("column1_looooong");',
+	];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+
+	const { sqlStatements: st1 } = await diff(n, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to });
+
+	const expectedSt1: string[] = [];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3713
+test('enums in check', async () => {
+	enum unit {
+		kg = 'kg',
+		lb = 'lb',
+	}
+	const to = {
+		table: pgTable('table', {
+			unit: text().$defaultFn(() => unit.kg).$type<unit>(),
+		}, (t) => [
+			check('unit_valid', sql`${t.unit} in (${unit.kg}, ${unit.lb})`),
+		]),
+	};
+
+	const res1 = await push({ db, to });
+	const res2 = await push({ db, to });
+	expect(res1.sqlStatements).toStrictEqual([
+		'CREATE TABLE "table" (\n\t"unit" text,\n\tCONSTRAINT "unit_valid" CHECK ("unit" in (\'kg\', \'lb\'))\n);\n',
+	]);
+	expect(res2.sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3844
+// https://github.com/drizzle-team/drizzle-orm/issues/3103
+test('composite pk multistep #2', async () => {
+	const userAsyncTasks = pgTable('userAsyncTask', {
+		userId: text('userId').notNull(),
+		identifier: text('identifier').notNull(),
+		type: text('type').notNull(),
+	}, (t) => [
+		primaryKey({ columns: [t.identifier, t.userId, t.type] }),
+	]);
+	const schema = { userAsyncTasks };
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4471
+test('composite pk multistep #3', async () => {
+	const firstToSecondTable = pgTable(
+		'firstToSecond',
+		{
+			firstId: integer('firstId'),
+			secondId: integer('secondId'),
+		},
+		(table) => [primaryKey({ columns: [table.firstId, table.secondId] })],
+	);
+
+	const schema = { firstToSecondTable };
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5156
+test('not null', async () => {
+	const table1 = pgTable('table1', {
+		col1: integer().primaryKey(),
+		col2: integer().notNull(),
+		col3: integer(),
+	}, (table) => [
+		// this works too
+		// check('table1_col3_not_null', sql`col3 IS NOT NULL`),
+		check('table1_col3_not_null', sql`${table.col3} IS NOT NULL`),
+	]);
+
+	const schema = { table1 };
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test('issue No4704. Composite index with sort outputs', async () => {
+	const schema1 = {
+		table: pgTable(
+			'table',
+			{ col1: integer(), col2: integer(), col3: integer() },
+			(table) => [
+				index('table_composite_idx').on(
+					table.col1,
+					table.col2,
+					desc(table.col3), // Attempting to sort by col3 DESC
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table" (\n\t"col1" integer,\n\t"col2" integer,\n\t"col3" integer\n);\n',
+		'CREATE INDEX "table_composite_idx" ON "table" ("col1","col2","col3" desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5585
+test('Issue No5585. Alter unique constraint', async () => {
+	const from = {
+		table: pgTable(
+			'table',
+			{ col1: integer(), col2: integer(), col3: integer() },
+			(table) => [unique('table_unique').on(table.col1)],
+		),
+	};
+
+	const to = {
+		table: pgTable(
+			'table',
+			{ col1: integer(), col2: integer(), col3: integer() },
+			(table) => [unique('table_unique').on(table.col1).nullsNotDistinct()],
+		),
+	};
+
+	await push({ db, to: from });
+
+	const { sqlStatements: st1, next: n1 } = await diff(from, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to: to });
+
+	const expectedSt1 = [
+		'ALTER TABLE "table" DROP CONSTRAINT "table_unique";',
+		'ALTER TABLE "table" ADD CONSTRAINT "table_unique" UNIQUE NULLS NOT DISTINCT("col1");',
+	];
+
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5879
+test('issue #5879', async () => {
+	const to = {
+		table: pgTable(
+			'table',
+			{ col1: integer(), col2: integer(), col3: integer() },
+			(t) => [
+				unique('prices_unique')
+					.on(t.col1, t.col2, t.col3)
+					.nullsNotDistinct(),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to: to });
+	const { sqlStatements: pst2 } = await push({ db, to: to });
+
+	const expectedSt1 = [`CREATE TABLE "table" (
+\t"col1" integer,
+\t"col2" integer,
+\t"col3" integer,
+\tCONSTRAINT \"prices_unique\" UNIQUE NULLS NOT DISTINCT(\"col1\",\"col2\",\"col3\")
+);\n`];
+
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pg-defaults.test.ts b/drizzle-kit/tests/postgres/pg-defaults.test.ts
new file mode 100644
index 0000000000..a5e92a8528
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-defaults.test.ts
@@ -0,0 +1,1826 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	bigserial,
+	bit,
+	boolean,
+	char,
+	cidr,
+	date,
+	doublePrecision,
+	geometry,
+	halfvec,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	point,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	sparsevec,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+	vector,
+} from 'drizzle-orm/pg-core';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffDefault, preparePostgisTestDatabase, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('integer', async () => {
+	const res1 = await diffDefault(_, integer().default(10), '10');
+	const res2 = await diffDefault(_, integer().default(0), '0');
+	const res3 = await diffDefault(_, integer().default(-10), '-10');
+	const res4 = await diffDefault(_, integer().default(1e4), '10000');
+	const res5 = await diffDefault(_, integer().default(-1e4), '-10000');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('integer arrays', async () => {
+	const res1 = await diffDefault(_, integer().array().default([]), "'{}'::integer[]");
+	const res2 = await diffDefault(_, integer().array().default([10]), "'{10}'::integer[]");
+	const res3 = await diffDefault(_, integer().array('[][]').default([]), "'{}'::integer[]");
+	const res4 = await diffDefault(_, integer().array('[][]').default([[]]), "'{}'::integer[]");
+	const res5 = await diffDefault(_, integer().array('[][]').default([[1, 2]]), "'{{1,2}}'::integer[]");
+	const res6 = await diffDefault(_, integer().array('[][]').default([[1, 2], [1, 2]]), "'{{1,2},{1,2}}'::integer[]");
+	const res7 = await diffDefault(
+		_,
+		integer().array('[][][]').default([[[1, 2]], [[1, 2]]]),
+		"'{{{1,2}},{{1,2}}}'::integer[]",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('smallint', async () => {
+	// 2^15 - 1
+	const res1 = await diffDefault(_, smallint().default(32767), '32767');
+	// -2^15
+	const res2 = await diffDefault(_, smallint().default(-32768), '-32768');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+});
+
+test('smallint arrays', async () => {
+	const res1 = await diffDefault(_, smallint().array().default([]), "'{}'::smallint[]");
+	const res2 = await diffDefault(_, smallint().array().default([32767]), "'{32767}'::smallint[]");
+	const res3 = await diffDefault(_, smallint().array('[][]').default([]), "'{}'::smallint[]");
+	const res4 = await diffDefault(_, smallint().array('[][]').default([[]]), "'{}'::smallint[]");
+	const res5 = await diffDefault(_, smallint().array('[][]').default([[1, 2]]), "'{{1,2}}'::smallint[]");
+	const res6 = await diffDefault(
+		_,
+		smallint().array('[][]').default([[1, 2], [1, 2]]),
+		"'{{1,2},{1,2}}'::smallint[]",
+	);
+	const res7 = await diffDefault(
+		_,
+		smallint().array('[][][]').default([[[1, 2]], [[1, 2]]]),
+		"'{{{1,2}},{{1,2}}}'::smallint[]",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+test('bigint', async () => {
+	// 2^53
+	const res1 = await diffDefault(_, bigint({ mode: 'number' }).default(9007199254740991), '9007199254740991');
+	const res2 = await diffDefault(_, bigint({ mode: 'number' }).default(-9007199254740991), '-9007199254740991');
+	// 2^63 - 1
+	const res3 = await diffDefault(_, bigint({ mode: 'bigint' }).default(9223372036854775807n), '9223372036854775807');
+	// -2^63
+	const res4 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).default(-9223372036854775808n),
+		'-9223372036854775808',
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('bigint arrays', async () => {
+	const res1 = await diffDefault(_, bigint({ mode: 'number' }).array().default([]), "'{}'::bigint[]");
+	const res2 = await diffDefault(_, bigint({ mode: 'bigint' }).array().default([]), "'{}'::bigint[]");
+
+	const res3 = await diffDefault(
+		_,
+		bigint({ mode: 'number' }).array().default([9007199254740991]),
+		"'{9007199254740991}'::bigint[]",
+	);
+	const res4 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).array().default([9223372036854775807n]),
+		"'{9223372036854775807}'::bigint[]",
+	);
+
+	const res5 = await diffDefault(_, bigint({ mode: 'number' }).array('[][]').default([]), "'{}'::bigint[]");
+	const res6 = await diffDefault(_, bigint({ mode: 'bigint' }).array('[][]').default([]), "'{}'::bigint[]");
+
+	const res7 = await diffDefault(_, bigint({ mode: 'number' }).array('[][]').default([[]]), "'{}'::bigint[]");
+	const res8 = await diffDefault(_, bigint({ mode: 'bigint' }).array('[][]').default([[]]), "'{}'::bigint[]");
+
+	const res9 = await diffDefault(
+		_,
+		bigint({ mode: 'number' }).array('[][]').default([[1, 2], [1, 2]]),
+		"'{{1,2},{1,2}}'::bigint[]",
+	);
+	const res10 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).array('[][]').default([[1n, 2n], [1n, 2n]]),
+		"'{{1,2},{1,2}}'::bigint[]",
+	);
+
+	const res11 = await diffDefault(
+		_,
+		bigint({ mode: 'number' }).array('[][][]').default([[[1, 2]], [[1, 2]]]),
+		"'{{{1,2}},{{1,2}}}'::bigint[]",
+	);
+	const res12 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).array('[][][]').default([[[1n, 2n]], [[1n, 2n]]]),
+		"'{{{1,2}},{{1,2}}}'::bigint[]",
+	);
+
+	const res13 = await diffDefault(_, bigint({ mode: 'bigint' }).array().default(sql`'{}'`), "'{}'::bigint[]");
+	const res14 = await diffDefault(_, bigint({ mode: 'bigint' }).array().default(sql`'{}'::bigint[]`), "'{}'::bigint[]");
+	const res15 = await diffDefault(
+		_,
+		bigint({ mode: 'bigint' }).array().default(sql`'{9223372036854775807}'::bigint[]`),
+		"'{9223372036854775807}'::bigint[]",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+});
+
+test('serials', async () => {
+	const res1 = await diffDefault(_, serial(), '');
+	const res2 = await diffDefault(_, smallserial(), '');
+	const res3 = await diffDefault(_, bigserial({ mode: 'number' }), '');
+	const res4 = await diffDefault(_, bigserial({ mode: 'bigint' }), '');
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4231#:~:text=remove%20the%20default-,Bonus,-This%20is%20the
+test('numeric', async () => {
+	const res1 = await diffDefault(_, numeric().default('10.123'), "'10.123'");
+
+	const res4 = await diffDefault(_, numeric({ mode: 'string' }).default('10.123'), "'10.123'");
+	const res2 = await diffDefault(_, numeric({ mode: 'bigint' }).default(9223372036854775807n), "'9223372036854775807'");
+	const res3 = await diffDefault(_, numeric({ mode: 'number' }).default(9007199254740991), "'9007199254740991'");
+
+	const res5 = await diffDefault(_, numeric({ precision: 6 }).default('10.123'), "'10.123'");
+	const res6 = await diffDefault(_, numeric({ precision: 6, scale: 2 }).default('10.123'), "'10.123'");
+
+	const res7 = await diffDefault(_, numeric({ mode: 'string', scale: 2 }).default('10.123'), "'10.123'");
+	const res8 = await diffDefault(_, numeric({ mode: 'string', precision: 6 }).default('10.123'), "'10.123'");
+	const res9 = await diffDefault(_, numeric({ mode: 'string', precision: 6, scale: 2 }).default('10.123'), "'10.123'");
+
+	const res10 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 19 }).default(9223372036854775807n),
+		"'9223372036854775807'",
+	);
+	const res11 = await diffDefault(_, numeric({ mode: 'number', precision: 6, scale: 2 }).default(10.123), "'10.123'");
+	const res12 = await diffDefault(_, numeric({ mode: 'number', scale: 2 }).default(10.123), "'10.123'");
+	const res13 = await diffDefault(_, numeric({ mode: 'number', precision: 6 }).default(10.123), "'10.123'");
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+});
+
+test('numeric arrays', async () => {
+	const res1 = await diffDefault(_, numeric({ mode: 'number' }).array().default([]), "'{}'::numeric[]");
+	const res2 = await diffDefault(
+		_,
+		numeric({ mode: 'number', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::numeric(4,2)[]",
+	);
+	const res3 = await diffDefault(_, numeric({ mode: 'bigint' }).array().default([]), "'{}'::numeric[]");
+	const res4 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 4 }).array().default([]),
+		"'{}'::numeric(4)[]",
+	);
+	const res5 = await diffDefault(_, numeric({ mode: 'string' }).array().default([]), "'{}'::numeric[]");
+	const res6 = await diffDefault(
+		_,
+		numeric({ mode: 'string', precision: 4, scale: 2 }).array().default([]),
+		"'{}'::numeric(4,2)[]",
+	);
+
+	const res7 = await diffDefault(
+		_,
+		numeric({ mode: 'number' }).array().default([10.123, 123.10]),
+		"'{10.123,123.1}'::numeric[]", // .1 due to number->string conversion
+	);
+
+	const res8 = await diffDefault(
+		_,
+		numeric({ mode: 'number', precision: 6, scale: 2 }).array().default([10.123, 123.10]),
+		"'{10.123,123.1}'::numeric(6,2)[]", // .1 due to number->string conversion
+	);
+	const res9 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint' }).array().default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::numeric[]",
+	);
+	const res10 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 19 }).array().default([9223372036854775807n, 9223372036854775806n]),
+		"'{9223372036854775807,9223372036854775806}'::numeric(19)[]",
+	);
+	const res11 = await diffDefault(
+		_,
+		numeric({ mode: 'string' }).array().default(['10.123', '123.10']),
+		"'{10.123,123.10}'::numeric[]",
+	);
+	const res12 = await diffDefault(
+		_,
+		numeric({ mode: 'string', precision: 6, scale: 2 }).array().default(['10.123', '123.10']),
+		"'{10.123,123.10}'::numeric(6,2)[]",
+	);
+
+	const res13 = await diffDefault(_, numeric({ mode: 'string' }).array('[][]').default([]), "'{}'::numeric[]");
+	const res14 = await diffDefault(
+		_,
+		numeric({ mode: 'string', precision: 4, scale: 2 }).array('[][]').default([]),
+		"'{}'::numeric(4,2)[]",
+	);
+	const res15 = await diffDefault(_, numeric({ mode: 'number' }).array('[][]').default([]), "'{}'::numeric[]");
+	const res16 = await diffDefault(
+		_,
+		numeric({ mode: 'number', precision: 4, scale: 2 }).array('[][]').default([]),
+		"'{}'::numeric(4,2)[]",
+	);
+	const res17 = await diffDefault(_, numeric({ mode: 'bigint' }).array('[][]').default([]), "'{}'::numeric[]");
+	const res18 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 4 }).array('[][]').default([]),
+		"'{}'::numeric(4)[]",
+	);
+	const res19 = await diffDefault(
+		_,
+		numeric({ mode: 'string' }).array('[][]').default([['10.123', '123.10'], ['10.123', '123.10']]),
+		"'{{10.123,123.10},{10.123,123.10}}'::numeric[]",
+	);
+	const res20 = await diffDefault(
+		_,
+		numeric({ mode: 'string', precision: 6, scale: 2 }).array('[][]').default([['10.123', '123.10'], [
+			'10.123',
+			'123.10',
+		]]),
+		"'{{10.123,123.10},{10.123,123.10}}'::numeric(6,2)[]",
+	);
+
+	const res23 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint' }).array('[][]').default([[9223372036854775807n, 9223372036854775806n], [
+			9223372036854775807n,
+			9223372036854775806n,
+		]]),
+		"'{{9223372036854775807,9223372036854775806},{9223372036854775807,9223372036854775806}}'::numeric[]",
+	);
+	const res24 = await diffDefault(
+		_,
+		numeric({ mode: 'bigint', precision: 19 }).array('[][]').default([[9223372036854775807n, 9223372036854775806n], [
+			9223372036854775807n,
+			9223372036854775806n,
+		]]),
+		"'{{9223372036854775807,9223372036854775806},{9223372036854775807,9223372036854775806}}'::numeric(19)[]",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+	expect.soft(res18).toStrictEqual([]);
+	expect.soft(res19).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+
+	expect.soft(res23).toStrictEqual([]);
+	expect.soft(res24).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3582
+test('real + real arrays', async () => {
+	const res1 = await diffDefault(_, real().default(1000.123), '1000.123');
+
+	const res2 = await diffDefault(_, real().array().default([]), `'{}'::real[]`);
+	const res3 = await diffDefault(_, real().array().default([1000.123, 10.2]), `'{1000.123,10.2}'::real[]`);
+
+	const res4 = await diffDefault(_, real().array('[][]').default([]), `'{}'::real[]`);
+	const res5 = await diffDefault(
+		_,
+		real().array('[][]').default([[1000.123, 10.2], [1000.123, 10.2]]),
+		`'{{1000.123,10.2},{1000.123,10.2}}'::real[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('doublePrecision + doublePrecision arrays', async () => {
+	const res1 = await diffDefault(_, doublePrecision().default(10000.123), '10000.123');
+
+	const res2 = await diffDefault(_, doublePrecision().array().default([]), `'{}'::double precision[]`);
+	const res3 = await diffDefault(
+		_,
+		doublePrecision().array().default([10000.123]),
+		`'{10000.123}'::double precision[]`,
+	);
+
+	const res4 = await diffDefault(_, doublePrecision().array('[][]').default([]), `'{}'::double precision[]`);
+	const res5 = await diffDefault(
+		_,
+		doublePrecision().array('[][]').default([[10000.123, 10.1], [10000.123, 10.1]]),
+		`'{{10000.123,10.1},{10000.123,10.1}}'::double precision[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('boolean + boolean arrays', async () => {
+	const res1 = await diffDefault(_, boolean().default(true), 'true');
+	const res2 = await diffDefault(_, boolean().default(false), 'false');
+	const res3 = await diffDefault(_, boolean().default(sql`true`), 'true');
+
+	const res4 = await diffDefault(_, boolean().array().default([]), `'{}'::boolean[]`);
+	const res5 = await diffDefault(_, boolean().array().default([true]), `'{t}'::boolean[]`);
+
+	const res6 = await diffDefault(_, boolean().array('[][]').default([]), `'{}'::boolean[]`);
+	const res7 = await diffDefault(_, boolean().array('[][]').default([[true], [false]]), `'{{t},{f}}'::boolean[]`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5370
+test('char + char arrays', async () => {
+	const res1 = await diffDefault(_, char({ length: 15 }).default('text'), `'text'`);
+	const res2 = await diffDefault(_, char({ length: 15 }).default("text'text"), `'text''text'`);
+	const res3 = await diffDefault(_, char({ length: 15 }).default('text\'text"'), "'text''text\"'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(_, char({ length: 15 }).default(`mo''",\\\`}{od`), `'mo''''",\\\\\`}{od'`);
+	const res5 = await diffDefault(_, char({ length: 15, enum: ['one', 'two', 'three'] }).default('one'), "'one'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		_,
+		char({ length: 15, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\\\`}{od`,
+		),
+		`'mo''''\",\\\\\`}{od'`,
+	);
+
+	const res7 = await diffDefault(_, char({ length: 15 }).array().default([]), `'{}'::char(15)[]`);
+	const res8 = await diffDefault(_, char({ length: 15 }).array().default(['text']), `'{text}'::char(15)[]`);
+	// raw default sql for the line below: '{text''\\text}'::char(15)[];
+	const res9 = await diffDefault(
+		_,
+		char({ length: 15 }).array().default(['\\']),
+		`'{"\\\\"}'::char(15)[]`,
+	);
+	const res10 = await diffDefault(
+		_,
+		char({ length: 15 }).array().default(["'"]),
+		`'{''}'::char(15)[]`,
+	);
+	const res11 = await diffDefault(
+		_,
+		char({ length: 15, enum: ['one', 'two', 'three'] }).array().default(['one']),
+		`'{one}'::char(15)[]`,
+	);
+	const res12 = await diffDefault(
+		_,
+		char({ length: 15, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array().default(
+			[`mo''",\`}{od`],
+		),
+		`'{"mo''''\\\",\`\}\{od"}'::char(15)[]`,
+	);
+
+	const res13 = await diffDefault(_, char({ length: 15 }).array('[][]').default([]), `'{}'::char(15)[]`);
+	// raw default sql for the line below: '{{text\\},{text}}'::text[]
+	const res14 = await diffDefault(
+		_,
+		char({ length: 15 }).array('[][]').default([['text\\'], ['text']]),
+		`'{{"text\\\\"},{text}}'::char(15)[]`,
+	);
+	const res15 = await diffDefault(
+		_,
+		char({ length: 15, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array('[][]')
+			.default(
+				[[`mo''",\`}{od`], [`mo''",\`}{od`]],
+			),
+		`'{{"mo''''\\\",\`\}\{od"},{"mo''''\\\",\`\}\{od"}}'::char(15)[]`,
+	);
+
+	const res16 = await diffDefault(
+		_,
+		char({ length: 7 }).array('[]')
+			.default(
+				['#6ddf5b', '#418536', '', '', '', '', ''],
+			),
+		`'{#6ddf5b,#418536,"","","","",""}'::char(7)[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5370
+test('varchar + varchar arrays', async () => {
+	const res1 = await diffDefault(_, varchar({ length: 256 }).default('text'), `'text'`);
+	const res2 = await diffDefault(_, varchar({ length: 256 }).default("text'text"), `'text''text'`);
+	const res3 = await diffDefault(_, varchar({ length: 256 }).default('text\'text"'), "'text''text\"'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(_, varchar({ length: 256 }).default(`mo''",\\\`}{od`), `'mo''''",\\\\\`}{od'`);
+	const res5 = await diffDefault(_, varchar({ length: 256, enum: ['one', 'two', 'three'] }).default('one'), "'one'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		_,
+		varchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\\\`}{od`,
+		),
+		`'mo''''",\\\\\`}{od'`,
+	);
+
+	const res7 = await diffDefault(_, varchar({ length: 256 }).array().default([]), `'{}'::varchar(256)[]`);
+	const res8 = await diffDefault(_, varchar({ length: 256 }).array().default(['text']), `'{text}'::varchar(256)[]`);
+	// raw default sql for the line below: '{text''\\text}'::varchar[];
+	const res9 = await diffDefault(
+		_,
+		varchar({ length: 256 }).array().default(["text'\\text"]),
+		`'{"text''\\\\text"}'::varchar(256)[]`,
+	);
+	const res10 = await diffDefault(
+		_,
+		varchar({ length: 256 }).array().default(['text\'text"']),
+		`'{"text''text\\\""}'::varchar(256)[]`,
+	);
+	const res11 = await diffDefault(
+		_,
+		varchar({ length: 256, enum: ['one', 'two', 'three'] }).array().default(['one']),
+		`'{one}'::varchar(256)[]`,
+	);
+	const res12 = await diffDefault(
+		_,
+		varchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array().default(
+			[`mo''",\`}{od`],
+		),
+		`'{"mo''''\\\",\`\}\{od"}'::varchar(256)[]`,
+	);
+
+	const res13 = await diffDefault(_, varchar({ length: 256 }).array('[][]').default([]), `'{}'::varchar(256)[]`);
+	// raw default sql for the line below: '{{text\\},{text}}'::varchar[]
+	const res14 = await diffDefault(
+		_,
+		varchar({ length: 256 }).array('[][]').default([['text\\'], ['text']]),
+		`'{{"text\\\\"},{text}}'::varchar(256)[]`,
+	);
+	const res15 = await diffDefault(
+		_,
+		varchar({ length: 256, enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array('[][]')
+			.default(
+				[[`mo''",\`}{od`], [`mo''",\`}{od`]],
+			),
+		`'{{"mo''''\\\",\`\}\{od"},{"mo''''\\\",\`\}\{od"}}'::varchar(256)[]`,
+	);
+
+	const res16 = await diffDefault(
+		_,
+		varchar({ length: 7 }).array('[]')
+			.default(
+				['#6ddf5b', '#418536', '', '', '', '', ''],
+			),
+		`'{#6ddf5b,#418536,"","","","",""}'::varchar(7)[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4231
+// https://github.com/drizzle-team/drizzle-orm/issues/4231#:~:text=Scenario%202%3A%20text().array().default(%5B%5D)
+// https://github.com/drizzle-team/drizzle-orm/issues/5370
+test('text + text arrays', async () => {
+	const res1 = await diffDefault(_, text().default('text'), `'text'`);
+	const res2 = await diffDefault(_, text().default("text'text"), `'text''text'`);
+	const res3 = await diffDefault(_, text().default('text\'text"'), "'text''text\"'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res4 = await diffDefault(_, text().default(`mo''",\\\`}{od`), `'mo''''",\\\\\`}{od'`);
+	const res5 = await diffDefault(_, text({ enum: ['one', 'two', 'three'] }).default('one'), "'one'");
+	// raw default sql for the line below: 'mo''''",\`}{od';
+	const res6 = await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\\\`}{od`, 'mo,\`od'] }).default(
+			`mo''",\\\`}{od`,
+		),
+		`'mo''''",\\\\\`}{od'`,
+	);
+
+	const res7 = await diffDefault(_, text().array().default([]), `'{}'::text[]`);
+	const res8 = await diffDefault(_, text().array().default(['text']), `'{text}'::text[]`);
+	// raw default sql for the line below: '{text''\\text}'::text[];
+	const res9 = await diffDefault(
+		_,
+		text().array().default(["text'\\text"]),
+		`'{"text''\\\\text"}'::text[]`,
+	);
+	const res10 = await diffDefault(
+		_,
+		text().array().default([`text'text"`]),
+		`'{"text''text\\""}'::text[]`,
+	);
+	const res11 = await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three'] }).array().default(['one']),
+		`'{one}'::text[]`,
+	);
+
+	const res12 = await diffDefault(_, text().array('[][]').default([]), `'{}'::text[]`);
+	// raw default sql for the line below: '{{text\\},{text}}'::text[]
+	const res13 = await diffDefault(
+		_,
+		text().array('[][]').default([['text\\'], ['text']]),
+		`'{{"text\\\\"},{text}}'::text[]`,
+	);
+
+	const res14 = await diffDefault(_, text().default(sql`gen_random_uuid()`), `gen_random_uuid()`);
+
+	const res15 = await diffDefault(
+		_,
+		text().array('[]')
+			.default(
+				['#6ddf5b', '#418536', '', '', '', '', ''],
+			),
+		`'{#6ddf5b,#418536,"","","","",""}'::text[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5119
+test('json + json arrays', async () => {
+	const res1 = await diffDefault(_, json().default({}), `'{}'`);
+	const res2 = await diffDefault(_, json().default([]), `'[]'`);
+	const res3 = await diffDefault(_, json().default([1, 2, 3]), `'[1,2,3]'`);
+	const res4 = await diffDefault(_, json().default({ key: 'value' }), `'{"key":"value"}'`);
+	const res5 = await diffDefault(_, json().default({ key: "val'ue" }), `'{"key":"val''ue"}'`);
+	const res6 = await diffDefault(_, json().default({ key: `mo''",\`}{od` }), `'{"key":"mo''''\\\",\`}{od"}'`);
+	const res7 = await diffDefault(_, json().default({ key: 'mo",\\`}{od' }), `'{"key":"mo\\\",\\\\\`}{od"}'`);
+	const res11 = await diffDefault(_, json().default({ b: 2, a: 1 }), `'{"b":2,"a":1}'`);
+
+	const res8 = await diffDefault(_, json().array().default([]), `'{}'::json[]`);
+	const res9 = await diffDefault(
+		_,
+		json().array().default([{ key: 'value' }]),
+		`'{"{\\"key\\":\\"value\\"}"}'::json[]`,
+	);
+	const res10 = await diffDefault(
+		_,
+		json().array().default([{ key: "val'ue" }]),
+		`'{"{\\"key\\":\\"val''ue\\"}"}'::json[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4231
+// https://github.com/drizzle-team/drizzle-orm/issues/5119
+test('jsonb + jsonb arrays', async () => {
+	const res1 = await diffDefault(_, jsonb().default({}), `'{}'`);
+	const res2 = await diffDefault(_, jsonb().default([]), `'[]'`);
+	const res3 = await diffDefault(_, jsonb().default([1, 2, 3]), `'[1,2,3]'`);
+	const res4 = await diffDefault(_, jsonb().default({ key: 'value' }), `'{"key":"value"}'`);
+	const res5 = await diffDefault(_, jsonb().default({ key: "val'ue" }), `'{"key":"val''ue"}'`);
+	const res6 = await diffDefault(_, jsonb().default({ key: `mo''",\`}{od` }), `'{"key":"mo''''\\\",\`}{od"}'`);
+	const res7 = await diffDefault(_, jsonb().default({ key: 'mo",\\`}{od' }), `'{"key":"mo\\\",\\\\\`}{od"}'`);
+	const res9 = await diffDefault(_, jsonb().default({ b: 2, a: 1 }), `'{"b":2,"a":1}'`);
+
+	const res8 = await diffDefault(_, jsonb().array().default([]), `'{}'::jsonb[]`);
+	const res12 = await diffDefault(_, jsonb().array('[][]').default([]), `'{}'::jsonb[]`);
+
+	const res13 = await diffDefault(
+		_,
+		jsonb().default({ confirmed: true, not_received: true }),
+		`'{"confirmed":true,"not_received":true}'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+});
+
+test('timestamp + timestamp arrays', async () => {
+	const res1 = await diffDefault(
+		_,
+		timestamp({ mode: 'date' }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	const res2 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).default(new Date('2025-05-23T12:53:53.115Z')),
+		`'2025-05-23 12:53:53.115+00'`,
+	);
+	const res3 = await diffDefault(
+		_,
+		timestamp({ mode: 'string' }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115'`,
+	);
+	const res4 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).default('2025-05-23 12:53:53.115'),
+		`'2025-05-23 12:53:53.115+00'`,
+	);
+	const res5 = await diffDefault(_, timestamp().defaultNow(), `now()`);
+	const res6 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).defaultNow(),
+		`now()`,
+	);
+
+	const res7 = await diffDefault(_, timestamp({ mode: 'date' }).array().default([]), `'{}'::timestamp[]`);
+	const res8 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).array().default([]),
+		`'{}'::timestamp(3) with time zone[]`,
+	);
+	const res9 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 5 }).array().default([new Date('2025-05-23T12:53:53.115Z')]),
+		`'{"2025-05-23 12:53:53.115"}'::timestamp(5)[]`,
+	);
+	const res10 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).array().default([
+			new Date('2025-05-23T12:53:53.115Z'),
+		]),
+		`'{"2025-05-23 12:53:53.115+00"}'::timestamp(3) with time zone[]`,
+	);
+
+	const res11 = await diffDefault(_, timestamp({ mode: 'string' }).array().default([]), `'{}'::timestamp[]`);
+	const res12 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).array().default([]),
+		`'{}'::timestamp(3) with time zone[]`,
+	);
+	const res13 = await diffDefault(
+		_,
+		timestamp({ mode: 'string' }).array().default(['2025-05-23 12:53:53.115']),
+		`'{"2025-05-23 12:53:53.115"}'::timestamp[]`,
+	);
+	const res14 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 4, withTimezone: true }).array().default(['2025-05-23 12:53:53.115+03:00']),
+		`'{"2025-05-23 12:53:53.115+03:00"}'::timestamp(4) with time zone[]`,
+	);
+	const res14_1 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 4, withTimezone: true }).default('2025-05-23 12:53:53.115+03:00'),
+		`'2025-05-23 12:53:53.115+03:00'`,
+	);
+
+	const res15 = await diffDefault(_, timestamp({ mode: 'date' }).array('[][]').default([]), `'{}'::timestamp[]`);
+	const res16 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).array('[][]').default([]),
+		`'{}'::timestamp(3) with time zone[]`,
+	);
+	const res17 = await diffDefault(
+		_,
+		timestamp({ mode: 'date' }).array('[][]').default([[new Date('2025-05-23T12:53:53.115Z')]]),
+		`'{{"2025-05-23 12:53:53.115"}}'::timestamp[]`,
+	);
+	const res18 = await diffDefault(
+		_,
+		timestamp({ mode: 'date', precision: 3, withTimezone: true }).array('[][]').default([[
+			new Date('2025-05-23T12:53:53.115Z'),
+		]]),
+		`'{{"2025-05-23 12:53:53.115+00"}}'::timestamp(3) with time zone[]`,
+	);
+
+	const res19 = await diffDefault(_, timestamp({ mode: 'string' }).array('[][]').default([]), `'{}'::timestamp[]`);
+	const res20 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).array('[][]').default([]),
+		`'{}'::timestamp(3) with time zone[]`,
+	);
+	const res21 = await diffDefault(
+		_,
+		timestamp({ mode: 'string' }).array('[][]').default([['2025-05-23 12:53:53.115']]),
+		`'{{"2025-05-23 12:53:53.115"}}'::timestamp[]`,
+	);
+	const res22 = await diffDefault(
+		_,
+		timestamp({ mode: 'string', precision: 3, withTimezone: true }).array('[][]').default([[
+			'2025-05-23 12:53:53.115',
+		]]),
+		`'{{"2025-05-23 12:53:53.115+00"}}'::timestamp(3) with time zone[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+	expect.soft(res14_1).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+	expect.soft(res17).toStrictEqual([]);
+	expect.soft(res18).toStrictEqual([]);
+	expect.soft(res19).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+	expect.soft(res21).toStrictEqual([]);
+	expect.soft(res22).toStrictEqual([]);
+});
+
+test('time + time arrays', async () => {
+	const res1 = await diffDefault(_, time().default('15:50:33'), `'15:50:33'`);
+	const res2 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).default('15:50:33.123+00'),
+		`'15:50:33.123+00'`,
+	);
+	const res3 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).default('15:50:33.123'),
+		`'15:50:33.123+00'`,
+	);
+	const res4 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).default('15:50:33.123+03'),
+		`'15:50:33.123+03'`,
+	);
+	const res5 = await diffDefault(_, time().defaultNow(), `now()`);
+	const res6 = await diffDefault(_, time({ precision: 3, withTimezone: true }).defaultNow(), `now()`);
+
+	const res7 = await diffDefault(_, time().array().default([]), `'{}'::time[]`);
+	const res8 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).array().default([]),
+		`'{}'::time(3) with time zone[]`,
+	);
+	const res9 = await diffDefault(_, time({ precision: 3 }).array().default(['15:50:33']), `'{15:50:33}'::time(3)[]`);
+	const res10 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).array().default(['15:50:33.123']),
+		`'{15:50:33.123+00}'::time(3) with time zone[]`,
+	);
+
+	const res11 = await diffDefault(_, time().array('[][]').default([]), `'{}'::time[]`);
+	const res12 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).array('[][]').default([]),
+		`'{}'::time(3) with time zone[]`,
+	);
+	const res13 = await diffDefault(_, time().array('[][]').default([['15:50:33']]), `'{{15:50:33}}'::time[]`);
+	const res14 = await diffDefault(
+		_,
+		time({ precision: 3, withTimezone: true }).array('[][]').default([['15:50:33.123']]),
+		`'{{15:50:33.123+00}}'::time(3) with time zone[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+});
+
+test('date + date arrays', async () => {
+	const res1 = await diffDefault(_, date({ mode: 'string' }).default('2025-05-23'), `'2025-05-23'`);
+	const res10 = await diffDefault(_, date({ mode: 'date' }).default(new Date('2025-05-23')), `'2025-05-23'`);
+	const res2 = await diffDefault(_, date({ mode: 'string' }).defaultNow(), `now()`);
+	const res20 = await diffDefault(_, date({ mode: 'date' }).defaultNow(), `now()`);
+
+	const res3 = await diffDefault(_, date({ mode: 'string' }).array().default([]), `'{}'::date[]`);
+	const res30 = await diffDefault(_, date({ mode: 'date' }).array().default([]), `'{}'::date[]`);
+	const res4 = await diffDefault(_, date({ mode: 'string' }).array().default(['2025-05-23']), `'{2025-05-23}'::date[]`);
+	const res40 = await diffDefault(
+		_,
+		date({ mode: 'date' }).array().default([new Date('2025-05-23')]),
+		`'{2025-05-23}'::date[]`,
+	);
+
+	const res5 = await diffDefault(_, date({ mode: 'string' }).array('[][]').default([]), `'{}'::date[]`);
+	const res50 = await diffDefault(_, date({ mode: 'date' }).array('[][]').default([]), `'{}'::date[]`);
+	const res6 = await diffDefault(
+		_,
+		date({ mode: 'string' }).array('[][]').default([['2025-05-23']]),
+		`'{{2025-05-23}}'::date[]`,
+	);
+	const res60 = await diffDefault(
+		_,
+		date({ mode: 'date' }).array('[][]').default([[new Date('2025-05-23')]]),
+		`'{{2025-05-23}}'::date[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res30).toStrictEqual([]);
+
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res40).toStrictEqual([]);
+
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res50).toStrictEqual([]);
+
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res60).toStrictEqual([]);
+});
+
+test('interval + interval arrays', async () => {
+	const res1 = await diffDefault(_, interval().default('1 day'), `'1 day'`);
+	const res10 = await diffDefault(
+		_,
+		interval({ fields: 'day to second', precision: 3 }).default('1 day 3 second'),
+		`'1 day 3 second'`,
+	);
+
+	const res2 = await diffDefault(_, interval().array().default([]), `'{}'::interval[]`);
+	const res20 = await diffDefault(
+		_,
+		interval({ fields: 'day to second', precision: 3 }).array().default([]),
+		`'{}'::interval day to second(3)[]`,
+	);
+
+	const res3 = await diffDefault(_, interval().array().default(['1 day']), `'{"1 day"}'::interval[]`);
+	const res30 = await diffDefault(
+		_,
+		interval({ fields: 'day to second', precision: 3 }).array().default(['1 day 3 second']),
+		`'{"1 day 3 second"}'::interval day to second(3)[]`,
+	);
+
+	const res4 = await diffDefault(_, interval().array('[][]').default([]), `'{}'::interval[]`);
+	const res40 = await diffDefault(
+		_,
+		interval({ fields: 'day to second', precision: 3 }).array('[][]').default([]),
+		`'{}'::interval day to second(3)[]`,
+	);
+
+	const res5 = await diffDefault(_, interval().array('[][]').default([['1 day']]), `'{{"1 day"}}'::interval[]`);
+	const res50 = await diffDefault(
+		_,
+		interval({ fields: 'day to second', precision: 3 }).array('[][]').default([['1 day 3 second']]),
+		`'{{"1 day 3 second"}}'::interval day to second(3)[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	// it's ok, that's due to '1 day 3 second' vs '1 day 00:00:03'
+	expect.soft(res10.length).toBe(1);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res20).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+
+	// it's ok, that's due to '1 day 3 second' vs '1 day 00:00:03'
+	expect.soft(res30.length).toBe(1);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res40).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	// it's ok, that's due to '1 day 3 second' vs '1 day 00:00:03'
+	expect.soft(res50.length).toBe(1);
+});
+
+test('point + point arrays', async () => {
+	const res1 = await diffDefault(_, point({ mode: 'xy' }).default({ x: 1, y: 2 }), `'(1,2)'`);
+	const res2 = await diffDefault(_, point({ mode: 'tuple' }).default([1, 2]), `'(1,2)'`);
+
+	const res3 = await diffDefault(_, point({ mode: 'tuple' }).array().default([]), `'{}'::point[]`);
+	const res4 = await diffDefault(_, point({ mode: 'tuple' }).array().default([[1, 2]]), `'{"(1,2)"}'::point[]`);
+
+	const res5 = await diffDefault(_, point({ mode: 'xy' }).array().default([]), `'{}'::point[]`);
+	const res6 = await diffDefault(_, point({ mode: 'xy' }).array().default([{ x: 1, y: 2 }]), `'{"(1,2)"}'::point[]`);
+
+	const res7 = await diffDefault(_, point({ mode: 'tuple' }).array('[][]').default([]), `'{}'::point[]`);
+	const res8 = await diffDefault(
+		_,
+		point({ mode: 'tuple' }).array('[][]').default([[[1, 2]]]),
+		`'{{"(1,2)"}}'::point[]`,
+	);
+
+	const res9 = await diffDefault(_, point({ mode: 'xy' }).array('[][]').default([]), `'{}'::point[]`);
+	const res10 = await diffDefault(
+		_,
+		point({ mode: 'xy' }).array('[][]').default([[{ x: 1, y: 2 }]]),
+		`'{{"(1,2)"}}'::point[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+test('line + line arrays', async () => {
+	const res1 = await diffDefault(_, line({ mode: 'abc' }).default({ a: 1, b: 2, c: 3 }), `'{1,2,3}'`);
+	const res2 = await diffDefault(_, line({ mode: 'tuple' }).default([1, 2, 3]), `'{1,2,3}'`);
+
+	const res3 = await diffDefault(_, line({ mode: 'tuple' }).array().default([]), `'{}'::line[]`);
+	const res4 = await diffDefault(_, line({ mode: 'tuple' }).array().default([[1, 2, 3]]), `'{"{1,2,3}"}'::line[]`);
+
+	const res5 = await diffDefault(_, line({ mode: 'abc' }).array().default([]), `'{}'::line[]`);
+	const res6 = await diffDefault(
+		_,
+		line({ mode: 'abc' }).array().default([{ a: 1, b: 2, c: 3 }]),
+		`'{"{1,2,3}"}'::line[]`,
+	);
+
+	const res7 = await diffDefault(_, line({ mode: 'tuple' }).array('[][]').default([]), `'{}'::line[]`);
+	const res8 = await diffDefault(
+		_,
+		line({ mode: 'tuple' }).array('[][]').default([[[1, 2, 3]]]),
+		`'{{"{1,2,3}"}}'::line[]`,
+	);
+
+	const res9 = await diffDefault(_, line({ mode: 'abc' }).array('[][]').default([]), `'{}'::line[]`);
+	const res10 = await diffDefault(
+		_,
+		line({ mode: 'abc' }).array('[][]').default([[{ a: 1, b: 2, c: 3 }]]),
+		`'{{"{1,2,3}"}}'::line[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+test('enum + enum arrays', async () => {
+	const moodEnum = pgEnum('mood_enum', [
+		'sad',
+		'ok',
+		'ha\\ppy',
+		`text'text"`,
+		`no,''"\`rm`,
+		"mo''\",\\`}{od",
+		'mo\`od',
+	]);
+	const pre = { moodEnum };
+
+	const res1 = await diffDefault(_, moodEnum().default('ok'), `'ok'::"mood_enum"`, pre);
+	const res2 = await diffDefault(_, moodEnum().default('ha\\ppy'), `'ha\\ppy'::"mood_enum"`, pre);
+	const res3 = await diffDefault(_, moodEnum().default(`mo''",\\\`}{od`), `'mo''''",\\\`}{od'::"mood_enum"`, pre);
+	const res4 = await diffDefault(_, moodEnum().default(`text'text"`), `'text''text"'::"mood_enum"`, pre);
+
+	const res5 = await diffDefault(_, moodEnum().array().default([]), `'{}'::"mood_enum"[]`, pre);
+	const res6 = await diffDefault(_, moodEnum().array().default(['ok']), `'{ok}'::"mood_enum"[]`, pre);
+	const res7 = await diffDefault(_, moodEnum().array().default(['ha\\ppy']), `'{"ha\\\\ppy"}'::"mood_enum"[]`, pre);
+	const res8 = await diffDefault(_, moodEnum().array().default(['mo\`od']), `'{mo\`od}'::"mood_enum"[]`, pre);
+	const res9 = await diffDefault(_, moodEnum().array('[][]').default([]), `'{}'::"mood_enum"[]`, pre);
+	const res10 = await diffDefault(_, moodEnum().array('[][]').default([['ok']]), `'{{ok}}'::"mood_enum"[]`, pre);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+test('uuid + uuid arrays', async () => {
+	const res1 = await diffDefault(
+		_,
+		uuid().default('550e8400-e29b-41d4-a716-446655440000'),
+		`'550e8400-e29b-41d4-a716-446655440000'`,
+	);
+	const res2 = await diffDefault(_, uuid().defaultRandom(), `gen_random_uuid()`);
+
+	const res3 = await diffDefault(_, uuid().array().default([]), `'{}'::uuid[]`);
+	const res4 = await diffDefault(_, uuid().array('[][]').default([]), `'{}'::uuid[]`);
+
+	const res5 = await diffDefault(
+		_,
+		uuid().array().default(['550e8400-e29b-41d4-a716-446655440000']),
+		`'{550e8400-e29b-41d4-a716-446655440000}'::uuid[]`,
+	);
+
+	const res6 = await diffDefault(
+		_,
+		uuid().array('[][]').default([['550e8400-e29b-41d4-a716-446655440000']]),
+		`'{{550e8400-e29b-41d4-a716-446655440000}}'::uuid[]`,
+	);
+
+	const res7 = await diffDefault(
+		_,
+		uuid()
+			.default(sql`'550e8400-e29b-41d4-a716-446655440001'`),
+		`'550e8400-e29b-41d4-a716-446655440001'`,
+	);
+
+	const res8 = await diffDefault(_, uuid().defaultRandom(), `gen_random_uuid()`);
+	const res9 = await diffDefault(_, uuid().array().default([]), `'{}'::uuid[]`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+});
+
+// pgvector extension
+// https://github.com/drizzle-team/drizzle-orm/issues/4473
+test('bit + bit arrays', async () => {
+	// await _.db.query('create extension vector;');
+	const res1 = await diffDefault(_, bit({ dimensions: 3 }).default(`101`), `'101'`);
+	const res2 = await diffDefault(_, bit({ dimensions: 3 }).default(sql`'101'`), `'101'`);
+
+	const res3 = await diffDefault(_, bit({ dimensions: 3 }).array().default([]), `'{}'::bit(3)[]`);
+	const res4 = await diffDefault(_, bit({ dimensions: 3 }).array().default([`101`]), `'{101}'::bit(3)[]`);
+
+	const res5 = await diffDefault(_, bit({ dimensions: 3 }).array('[][]').default([]), `'{}'::bit(3)[]`);
+	const res6 = await diffDefault(
+		_,
+		bit({ dimensions: 3 }).array('[][]').default([[`101`], [`101`]]),
+		`'{{101},{101}}'::bit(3)[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+});
+
+test('halfvec + halfvec arrays', async () => {
+	const res1 = await diffDefault(_, halfvec({ dimensions: 3 }).default([0, -2, 3]), `'[0,-2,3]'`);
+
+	const res3 = await diffDefault(_, halfvec({ dimensions: 3 }).array().default([]), `'{}'::halfvec(3)[]`);
+	const res4 = await diffDefault(
+		_,
+		halfvec({ dimensions: 3 }).array().default([[0, -2, 3]]),
+		`'{"[0,-2,3]"}'::halfvec(3)[]`,
+	);
+
+	const res6 = await diffDefault(_, halfvec({ dimensions: 3 }).array('[][]').default([]), `'{}'::halfvec(3)[]`);
+	const res7 = await diffDefault(
+		_,
+		halfvec({ dimensions: 3 }).array('[][]').default([[[0, -2, 3]], [[1, 2, 3]]]),
+		`'{{"[0,-2,3]"},{"[1,2,3]"}}'::halfvec(3)[]`,
+	);
+
+	// TODO strange rounding
+	// looks like extension or postgres makes this
+
+	// const res2 = await diffDefault(
+	// 	_,
+	// 	halfvec({ dimensions: 3 }).default([0, -2.123456789, 3.123456789]),
+	// 	`'[0,-2.123456789,3.123456789]'`,
+	// );
+	// const res5 = await diffDefault(
+	// 	_,
+	// 	halfvec({ dimensions: 3 }).array().default([[0, -2.3, 3.123456789]]),
+	// 	`'{"[0,-2.123456789,3.123456789]"}'::halfvec(3)[]`,
+	// );
+	// const res8 = await diffDefault(
+	// 	_,
+	// 	//                                                 [[[0, -2.1230469,3.1230469      ]],[[1.1230469,2.1230469,3.1230469]]]
+	// 	halfvec({ dimensions: 3 }).array('[][]').default([[[0, -2.123456, 3.123456]], [[1.123456, 2.123456, 3.123456]]]),
+	// 	`'{{"[0,-2.123456789,3.123456789]"},{"[1.123456789,2.123456789,3.123456789]"}}'::halfvec(3)[]`,
+	// );
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+
+	// expect.soft(res2).toStrictEqual([]);
+	// expect.soft(res5).toStrictEqual([]);
+	// expect.soft(res8).toStrictEqual([]);
+});
+
+test('sparsevec + sparsevec arrays', async () => {
+	const res1 = await diffDefault(_, sparsevec({ dimensions: 5 }).default(`{1:-1,3:2,5:3}/5`), `'{1:-1,3:2,5:3}/5'`);
+	const res2 = await diffDefault(
+		_,
+		sparsevec({ dimensions: 5 }).default(`{1:-1.1234567,3:2.1234567,5:3.1234567}/5`),
+		`'{1:-1.1234567,3:2.1234567,5:3.1234567}/5'`,
+	);
+
+	const res3 = await diffDefault(_, sparsevec({ dimensions: 5 }).array().default([]), `'{}'::sparsevec(5)[]`);
+	const res4 = await diffDefault(
+		_,
+		sparsevec({ dimensions: 5 }).array().default([`{1:-1,3:2,5:3}/5`]),
+		`'{"{1:-1,3:2,5:3}/5"}'::sparsevec(5)[]`,
+	);
+	const res5 = await diffDefault(
+		_,
+		sparsevec({ dimensions: 5 }).array().default(['{1:-1.1234567,3:2.1234567,5:3.1234567}/5']),
+		`'{"{1:-1.1234567,3:2.1234567,5:3.1234567}/5"}'::sparsevec(5)[]`,
+	);
+
+	const res6 = await diffDefault(_, sparsevec({ dimensions: 5 }).array('[][]').default([]), `'{}'::sparsevec(5)[]`);
+	const res7 = await diffDefault(
+		_,
+		sparsevec({ dimensions: 5 }).array('[][]').default([[`{1:-1,3:2,5:3}/5`], [`{1:-1,3:2,5:3}/5`]]),
+		`'{{"{1:-1,3:2,5:3}/5"},{"{1:-1,3:2,5:3}/5"}}'::sparsevec(5)[]`,
+	);
+	const res8 = await diffDefault(
+		_,
+		sparsevec({ dimensions: 5 }).array('[][]').default([['{1:-1.1234567,3:2.1234567,5:3.1234567}/5'], [
+			'{1:-1.1234567,3:2.1234567,5:3.1234567}/5',
+		]]),
+		`'{{"{1:-1.1234567,3:2.1234567,5:3.1234567}/5"},{"{1:-1.1234567,3:2.1234567,5:3.1234567}/5"}}'::sparsevec(5)[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+});
+
+test('macaddr + macaddr arrays', async () => {
+	const res1 = await diffDefault(_, macaddr().default('08:00:2b:01:02:03'), `'08:00:2b:01:02:03'`);
+	const res2 = await diffDefault(_, macaddr().default('ff:ff:ff:ff:ff:ff'), `'ff:ff:ff:ff:ff:ff'`);
+
+	const res3 = await diffDefault(_, macaddr().array().default([]), `'{}'::macaddr[]`);
+	const res4 = await diffDefault(
+		_,
+		macaddr().array().default(['08:00:2b:01:02:03']),
+		`'{08:00:2b:01:02:03}'::macaddr[]`,
+	);
+	const res5 = await diffDefault(
+		_,
+		macaddr().array('[][]').default([['08:00:2b:01:02:03'], ['ff:ff:ff:ff:ff:ff']]),
+		`'{{08:00:2b:01:02:03},{ff:ff:ff:ff:ff:ff}}'::macaddr[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+test('macaddr8 + macaddr8 arrays', async () => {
+	const res1 = await diffDefault(_, macaddr8().default('08:00:2b:01:02:03:04:05'), `'08:00:2b:01:02:03:04:05'`);
+	const res2 = await diffDefault(_, macaddr8().default('ff:ff:ff:ff:ff:ff:ff:ff'), `'ff:ff:ff:ff:ff:ff:ff:ff'`);
+
+	const res3 = await diffDefault(_, macaddr8().array().default([]), `'{}'::macaddr8[]`);
+	const res4 = await diffDefault(
+		_,
+		macaddr8().array().default(['08:00:2b:01:02:03:04:05']),
+		`'{08:00:2b:01:02:03:04:05}'::macaddr8[]`,
+	);
+	const res5 = await diffDefault(
+		_,
+		macaddr8().array('[][]').default([['08:00:2b:01:02:03:04:05'], ['ff:ff:ff:ff:ff:ff:ff:ff']]),
+		`'{{08:00:2b:01:02:03:04:05},{ff:ff:ff:ff:ff:ff:ff:ff}}'::macaddr8[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+});
+
+test('vector + vector arrays', async () => {
+	const res1 = await diffDefault(_, vector({ dimensions: 3 }).default([0, -2, 3]), `'[0,-2,3]'`);
+	const res2 = await diffDefault(
+		_,
+		vector({ dimensions: 3 }).default([0, -2.1234567, 3.1234567]),
+		`'[0,-2.1234567,3.1234567]'`,
+	);
+
+	const res3 = await diffDefault(_, vector({ dimensions: 3 }).array().default([]), `'{}'::vector(3)[]`);
+	const res4 = await diffDefault(
+		_,
+		vector({ dimensions: 3 }).array().default([[0, -2, 3]]),
+		`'{"[0,-2,3]"}'::vector(3)[]`,
+	);
+	const res5 = await diffDefault(
+		_,
+		vector({ dimensions: 3 }).array().default([[0, -2.1234567, 3.1234567]]),
+		`'{"[0,-2.1234567,3.1234567]"}'::vector(3)[]`,
+	);
+
+	const res6 = await diffDefault(_, vector({ dimensions: 3 }).array('[][]').default([]), `'{}'::vector(3)[]`);
+	const res7 = await diffDefault(
+		_,
+		vector({ dimensions: 3 }).array('[][]').default([[[0, -2, 3]], [[1, 2, 3]]]),
+		`'{{"[0,-2,3]"},{"[1,2,3]"}}'::vector(3)[]`,
+	);
+	const res8 = await diffDefault(
+		_,
+		vector({ dimensions: 3 }).array('[][]').default([[
+			[0, -2.1234567, 3.1234567],
+		], [[1.1234567, 2.1234567, 3.1234567]]]),
+		`'{{"[0,-2.1234567,3.1234567]"},{"[1.1234567,2.1234567,3.1234567]"}}'::vector(3)[]`,
+	);
+
+	const res9 = await diffDefault(_, vector({ dimensions: 2 }).default([0, -2]), `'[0,-2]'`);
+	const res10 = await diffDefault(_, vector({ dimensions: 5 }).default([0, -2, 0, 0, 0]), `'[0,-2,0,0,0]'`);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+});
+
+// postgis extension
+// SRID=4326 -> these coordinates are longitude/latitude values
+// Default is 0 or undefined
+test('geometry + geometry arrays', async () => {
+	const postgisDb = await preparePostgisTestDatabase();
+
+	const res1 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).default([30.5234, 50.4501]),
+		`'SRID=4326;POINT(30.5234 50.4501)'`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res2 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }),
+		`'SRID=4326;POINT(30.5234 50.4501)'`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res3 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).array().default([]),
+		`'{}'::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+	const res4 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).array().default([[30.5234, 50.4501]]),
+		`ARRAY['SRID=4326;POINT(30.5234 50.4501)']::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res5 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).array().default([]),
+		`'{}'::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+	const res6 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).array().default([{ x: 30.5234, y: 50.4501 }]),
+		`ARRAY['SRID=4326;POINT(30.5234 50.4501)']::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res7 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).array('[][]').default([]),
+		`'{}'::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+	const res8 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'tuple', type: 'point' }).array('[][]').default([[[30.5234, 50.4501]], [[
+			30.5234,
+			50.4501,
+		]]]),
+		`ARRAY[ARRAY['SRID=4326;POINT(30.5234 50.4501)'],ARRAY['SRID=4326;POINT(30.5234 50.4501)']]::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res9 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).array('[][]').default([]),
+		`'{}'::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res10 = await diffDefault(
+		postgisDb,
+		geometry({ srid: 4326, mode: 'xy', type: 'point' }).array('[][]').default([[{ x: 30.5234, y: 50.4501 }], [{
+			x: 30.5234,
+			y: 50.4501,
+		}]]),
+		`ARRAY[ARRAY['SRID=4326;POINT(30.5234 50.4501)'],ARRAY['SRID=4326;POINT(30.5234 50.4501)']]::geometry(point,4326)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res11 = await diffDefault(
+		postgisDb,
+		geometry({ mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }),
+		`'POINT(30.5234 50.4501)'`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res12 = await diffDefault(
+		postgisDb,
+		geometry({ mode: 'xy', type: 'point' }).default(sql`'SRID=4326;POINT(10 10)'`),
+		`'SRID=4326;POINT(10 10)'`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+	// const res12_1 = await diffDefault(
+	// 	postgisDb,
+	// 	geometry().default(sql`'SRID=0;POINT(12.1 12.1)'`),
+	// 	`'SRID=0;POINT(12.1 12.1)'`,
+	// 	undefined,
+	// 	undefined,
+	// 	true,
+	// );
+
+	const res13 = await diffDefault(
+		postgisDb,
+		geometry({ mode: 'xy', type: 'point' }).array().default([{ x: 13, y: 13 }]),
+		`ARRAY['POINT(13 13)']::geometry(point)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	// this will result diffs on push only
+	// i believe we should not handle this since will be log in console for user about diff and this is sql``
+	// const res14 = await diffDefault(
+	// 	postgisDb,
+	// 	geometry({ mode: 'xy', type: 'point' }).array().default(sql`'{SRID=4326;POINT(14 14)}'::geometry(point)[]`),
+	// 	`'{SRID=4326;POINT(14 14)}'::geometry(point)[]`,
+	// 	undefined,
+	// 	undefined,
+	// 	true,
+	// );
+
+	const res15 = await diffDefault(
+		postgisDb,
+		geometry({ mode: 'xy', type: 'point' }).array().default(sql`ARRAY['SRID=4326;POINT(15 15)']::geometry(point)[]`),
+		`ARRAY['SRID=4326;POINT(15 15)']::geometry(point)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	const res16 = await diffDefault(
+		postgisDb,
+		geometry({ mode: 'xy', type: 'point' }).array().default(sql`ARRAY['POINT(16 16)']::geometry(point)[]`),
+		`ARRAY['POINT(16 16)']::geometry(point)[]`,
+		undefined,
+		undefined,
+		['table'],
+		['public'],
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	// expect.soft(res12_1).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	// expect.soft(res14).toStrictEqual([]);
+	expect.soft(res15).toStrictEqual([]);
+	expect.soft(res16).toStrictEqual([]);
+});
+
+test('inet + inet arrays', async () => {
+	const res1 = await diffDefault(_, inet().default('127.0.0.1'), `'127.0.0.1'`);
+	const res2 = await diffDefault(_, inet().default('::ffff:192.168.0.1/96'), `'::ffff:192.168.0.1/96'`);
+
+	const res1_1 = await diffDefault(
+		_,
+		inet().array().default(['127.0.0.1', '127.0.0.2']),
+		`'{127.0.0.1,127.0.0.2}'::inet[]`,
+	);
+	const res2_1 = await diffDefault(
+		_,
+		inet().array().default(['::ffff:192.168.0.1/96']),
+		`'{::ffff:192.168.0.1/96}'::inet[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+
+	expect.soft(res1_1).toStrictEqual([]);
+	expect.soft(res2_1).toStrictEqual([]);
+});
+
+test('cidr + cidr arrays', async () => {
+	const res1 = await diffDefault(_, cidr().default('127.0.0.1/32'), `'127.0.0.1/32'`);
+
+	const res2_1 = await diffDefault(_, cidr().array().default([]), `'{}'::cidr[]`);
+	const res2_2 = await diffDefault(
+		_,
+		cidr().array().default(['127.0.0.1/32', '127.0.0.2/32']),
+		`'{127.0.0.1/32,127.0.0.2/32}'::cidr[]`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+
+	expect.soft(res2_1).toStrictEqual([]);
+	expect.soft(res2_2).toStrictEqual([]);
+});
+
+test.skip('corner cases', async () => {
+	const moodEnum = pgEnum('mood_enum', ['sad', 'ok', 'happy', `text'text"`, `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od']);
+	const pre = { moodEnum };
+
+	await diffDefault(
+		_,
+		moodEnum().array('[][]').default([[`text'text"`]]),
+		`'{{"text''text\\\""}}'::"mood_enum"[]`,
+		pre,
+	);
+	const res11 = await diffDefault(
+		_,
+		moodEnum().array('[][]').default([[`mo''",\`}{od`]]),
+		`'{{"mo''''\\\",\`\}\{od"}}'::"mood_enum"[]`,
+		pre,
+	);
+
+	const res6 = await diffDefault(
+		_,
+		moodEnum().array().default([`text'text"`]),
+		`'{"text''text\\\""}'::"mood_enum"[]`,
+		pre,
+	);
+
+	const res7 = await diffDefault(
+		_,
+		moodEnum().array().default([`mo''",\`}{od`]),
+		`'{"mo''''\\\",\`\}\{od"}'::"mood_enum"[]`,
+		pre,
+	);
+
+	// const res_10 = await diffDefault(
+	// 	_,
+	// 	json().array().default([{ key: `mo''",\`}{od` }]),
+	// 	`'{"{\\"key\\":\\"mo''\\\\\\",\`}{od\\"}"}'::json[]`,
+	// );
+	// expect.soft(res_10).toStrictEqual([]);
+
+	// 	const res14 = await diffDefault(
+	// 	_,
+	// 	json().array('[][]').default([[{ key: `mo''",\`}{od` }]]),
+	// 	`'{{"{\\"key\\":\\"mo''\\\\\\",\`}{od\\"}"}}'::json[]`,
+	// );
+	// expect.soft(res14).toStrictEqual([]);
+
+	// const res__10 = await diffDefault(
+	// 	_,
+	// 	json().array().default([{ key: `mo''",\`}{od` }]),
+	// 	`'{"{\\"key\\":\\"mo''\\\\\\",\`}{od\\"}"}'::json[]`,
+	// );
+	// expect.soft(res__10).toStrictEqual([]);
+
+	const res__14 = await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array('[][]')
+			.default(
+				[[`mo''",\`}{od`], [`mo''",\`}{od`]],
+			),
+		`'{{"mo''''\\\",\`\}\{od"},{"mo''''\\\",\`}{od"}}'::text[]`,
+	);
+	expect.soft(res__14).toStrictEqual([]);
+
+	// 		const res14 = await diffDefault(
+	// 	_,
+	// 	json().array('[][]').default([[{ key: `mo''",\`}{od` }]]),
+	// 	`'{{"{\\"key\\":\\"mo''\\\\\\",\`}{od\\"}"}}'::json[]`,
+	// );
+
+	// expect.soft(res14).toStrictEqual([]);
+
+	const res_11 = await diffDefault(
+		_,
+		text({ enum: ['one', 'two', 'three', `no,''"\`rm`, `mo''",\`}{od`, 'mo,\`od'] }).array().default(
+			[`mo''",\`}{od`],
+		),
+		`'{"mo''''\\\",\`\}\{od"}'::text[]`,
+	);
+	expect.soft(res_11).toStrictEqual([]);
+
+	const res21 = await diffDefault(
+		_,
+		numeric({ mode: 'number' }).array('[][]').default([[10.123, 123.10], [10.123, 123.10]]),
+		"'{{10.123,123.10},{10.123,123.10}}'::numeric[]",
+	);
+	const res22 = await diffDefault(
+		_,
+		numeric({ mode: 'number', precision: 6, scale: 2 }).array('[][]').default([[10.123, 123.10], [
+			10.123,
+			123.10,
+		]]),
+		"'{{10.123,123.10},{10.123,123.10}}'::numeric[]",
+	);
+
+	// expect.soft(res21).toStrictEqual([]);
+	// expect.soft(res22).toStrictEqual([]);
+
+	await diffDefault(
+		_,
+		json().array().default([{ key: 'mo",\\`}{od' }]),
+		`'{"{\"key\":\"mo\\\",\\\\\\\\\`}{od\"}"}'::json[]`,
+	);
+
+	await diffDefault(
+		_,
+		json().array().default([{ key: 'mo",\\`}{od' }]),
+		`'{"{\"key\":\"mo\\\",\\\\\\\\\`}{od\"}"}'::json[]`,
+	);
+
+	await diffDefault(_, json().array('[][]').default([]), `'{}'::json[]`);
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: 'value' }]]),
+		`'{{\"{\\\"key\\\":\\\"value\\\"}\"}}'::json[]`,
+	);
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: "val'ue" }]]),
+		`'{{"{\\"key\\":\\"val''ue\\"}"}}'::json[]`,
+	);
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: 'mo",\\`}{od' }]]),
+		`'{{"{\"key\":\"mo\\\",\\\\\\\\\`}{od\"}"}}'::json[]`,
+	);
+	await diffDefault(
+		_,
+		json().default(sql`jsonb_build_object('chunkIndex', NULL, 'totalChunks', NULL)`),
+		`jsonb_build_object('chunkIndex', NULL, 'totalChunks', NULL)`,
+	);
+
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: 'mo",\\`}{od' }]]),
+		`'{{"{\"key\":\"mo\\\",\\\\\\\\\`}{od\"}"}}'::json[]`,
+	);
+
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: "val'ue" }]]),
+		`'{{"{\\"key\\":\\"val''ue\\"}"}}'::json[]`,
+	);
+
+	await diffDefault(
+		_,
+		json().array('[][]').default([[{ key: 'value' }]]),
+		`'{{\"{\\\"key\\\":\\\"value\\\"}\"}}'::json[]`,
+	);
+
+	await diffDefault(
+		_,
+		jsonb().array().default([{ key: 'value' }]),
+		`'{"{\\"key\\":\\"value\\"}"}'::jsonb[]`,
+	);
+	await diffDefault(
+		_,
+		jsonb().array().default([{ key: "val'ue" }]),
+		`'{"{\\"key\\":\\"val''ue\\"}"}'::jsonb[]`,
+	);
+});
diff --git a/drizzle-kit/tests/postgres/pg-enums.test.ts b/drizzle-kit/tests/postgres/pg-enums.test.ts
new file mode 100644
index 0000000000..b97e498ddd
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-enums.test.ts
@@ -0,0 +1,2553 @@
+import { integer, pgEnum, pgSchema, pgTable, serial, text, uuid, varchar } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import type { TestDatabase } from './mocks';
+import { diff, prepareTestDatabase, push } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('enums #1', async () => {
+	const to = {
+		enum: pgEnum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #2', async () => {
+	const folder = pgSchema('folder');
+	const to = {
+		folder,
+		enum: folder.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff({ folder }, to, []);
+	await push({ db, to: { folder } });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TYPE "folder"."enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #3', async () => {
+	const from = {
+		enum: pgEnum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		`DROP TYPE "enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #4', async () => {
+	const folder = pgSchema('folder');
+
+	const from = {
+		folder,
+		enum: folder.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, { folder }, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to: { folder } });
+
+	const st0 = [
+		`DROP TYPE "folder"."enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #5', async () => {
+	const folder1 = pgSchema('folder1');
+	const folder2 = pgSchema('folder2');
+
+	const from = {
+		folder1,
+		enum: folder1.enum('enum', ['value']),
+	};
+
+	const to = {
+		folder2,
+		enum: folder2.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, ['folder1->folder2']);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: ['folder1->folder2'],
+	});
+
+	const st0 = [
+		`ALTER SCHEMA "folder1" RENAME TO "folder2";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #6', async () => {
+	const folder1 = pgSchema('folder1');
+	const folder2 = pgSchema('folder2');
+
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum', ['value']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum', ['value']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [
+		'folder1.enum->folder2.enum',
+	]);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: ['folder1.enum->folder2.enum'],
+	});
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum" SET SCHEMA "folder2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #7', async () => {
+	const from = {
+		enum: pgEnum('enum', ['value1']),
+	};
+
+	const to = {
+		enum: pgEnum('enum', ['value1', 'value2']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TYPE "enum" ADD VALUE 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #8', async () => {
+	const from = {
+		enum: pgEnum('enum', ['value1']),
+	};
+
+	const to = {
+		enum: pgEnum('enum', ['value1', 'value2', 'value3']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TYPE "enum" ADD VALUE 'value2';`,
+		`ALTER TYPE "enum" ADD VALUE 'value3';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #9', async () => {
+	const from = {
+		enum: pgEnum('enum', ['value1', 'value3']),
+	};
+
+	const to = {
+		enum: pgEnum('enum', ['value1', 'value2', 'value3']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [`ALTER TYPE "enum" ADD VALUE 'value2' BEFORE 'value3';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #10', async () => {
+	const schema = pgSchema('folder');
+	const from = {
+		schema,
+		enum: schema.enum('enum', ['value1']),
+	};
+
+	const to = {
+		schema,
+		enum: schema.enum('enum', ['value1', 'value2']),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [`ALTER TYPE "folder"."enum" ADD VALUE 'value2';`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #11', async () => {
+	const schema1 = pgSchema('folder1');
+	const from = {
+		schema1,
+		enum: schema1.enum('enum', ['value1']),
+	};
+
+	const to = {
+		schema1,
+		enum: pgEnum('enum', ['value1']),
+	};
+
+	const renames = [
+		'folder1.enum->public.enum',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "folder1"."enum" SET SCHEMA "public";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #12', async () => {
+	const schema1 = pgSchema('folder1');
+	const from = {
+		schema1,
+		enum: pgEnum('enum', ['value1']),
+	};
+
+	const to = {
+		schema1,
+		enum: schema1.enum('enum', ['value1']),
+	};
+
+	const renames = [
+		'public.enum->folder1.enum',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum" SET SCHEMA "folder1";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4338
+test('enums #13', async () => {
+	const from = {
+		enum: pgEnum('enum1', ['value1']),
+	};
+
+	const to = {
+		enum: pgEnum('enum2', ['value1']),
+	};
+
+	const renames = [
+		'public.enum1->public.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" RENAME TO "enum2";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #14', async () => {
+	const folder1 = pgSchema('folder1');
+	const folder2 = pgSchema('folder2');
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum1', ['value1']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum2', ['value1']),
+	};
+
+	const renames = [
+		'folder1.enum1->folder2.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`,
+		`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #15', async () => {
+	const folder1 = pgSchema('folder1');
+	const folder2 = pgSchema('folder2');
+	const from = {
+		folder1,
+		folder2,
+		enum: folder1.enum('enum1', ['value1', 'value4']),
+	};
+
+	const to = {
+		folder1,
+		folder2,
+		enum: folder2.enum('enum2', ['value1', 'value2', 'value3', 'value4']),
+	};
+
+	const renames = ['folder1.enum1->folder2.enum2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "folder1"."enum1" SET SCHEMA "folder2";`,
+		`ALTER TYPE "folder2"."enum1" RENAME TO "enum2";`,
+		`ALTER TYPE "folder2"."enum2" ADD VALUE 'value2' BEFORE 'value4';`,
+		`ALTER TYPE "folder2"."enum2" ADD VALUE 'value3' BEFORE 'value4';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #16', async () => {
+	const enum1 = pgEnum('enum1', ['value1']);
+	const enum2 = pgEnum('enum2', ['value1']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column'),
+		}),
+	};
+
+	const renames = [
+		'public.enum1->public.enum2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" RENAME TO "enum2";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #17', async () => {
+	const schema = pgSchema('schema');
+	const enum1 = pgEnum('enum1', ['value1']);
+	const enum2 = schema.enum('enum1', ['value1']);
+
+	const from = {
+		schema,
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const to = {
+		schema,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column'),
+		}),
+	};
+
+	const renames = [
+		'public.enum1->schema.enum1',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [`ALTER TYPE "enum1" SET SCHEMA "schema";`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #18', async () => {
+	const schema1 = pgSchema('schema1');
+	const schema2 = pgSchema('schema2');
+
+	const enum1 = schema1.enum('enum1', ['value1']);
+	const enum2 = schema2.enum('enum2', ['value1']);
+
+	const from = {
+		schema1,
+		schema2,
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const to = {
+		schema1,
+		schema2,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column'),
+		}),
+	};
+
+	const renames = [
+		'schema1.enum1->schema2.enum2',
+	];
+	// change name and schema of the enum, no table changes
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER TYPE "schema1"."enum1" SET SCHEMA "schema2";`,
+		`ALTER TYPE "schema2"."enum1" RENAME TO "enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #19', async () => {
+	const myEnum = pgEnum('my_enum', ["escape's quotes"]);
+
+	const from = {};
+
+	const to = { myEnum };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = ["CREATE TYPE \"my_enum\" AS ENUM('escape''s quotes');"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #20', async () => {
+	const myEnum = pgEnum('my_enum', ['one', 'two', 'three']);
+
+	const from = {
+		myEnum,
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const to = {
+		myEnum,
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+			col1: myEnum('col1'),
+			col2: integer('col2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum";',
+		'ALTER TABLE "table" ADD COLUMN "col2" integer;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #21', async () => {
+	const myEnum = pgEnum('my_enum', ['one', 'two', 'three']);
+
+	const from = {
+		myEnum,
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const to = {
+		myEnum,
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+			col1: myEnum('col1').array(),
+			col2: integer('col2').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "col1" "my_enum"[];',
+		'ALTER TABLE "table" ADD COLUMN "col2" integer[];',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums #22', async () => {
+	const schema = pgSchema('schema');
+	const en = schema.enum('e', ['a', 'b']);
+
+	const from = {
+		schema,
+		en,
+	};
+
+	const to = {
+		schema,
+		en,
+		table: pgTable('table', {
+			en: en(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = ['CREATE TABLE "table" (\n\t"en" "schema"."e"\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4375
+test('enums #23', async () => {
+	const schema = pgSchema('schema');
+	const en = schema.enum('e', ['a', 'b']);
+
+	const from = {
+		schema,
+		en,
+	};
+
+	const to = {
+		schema,
+		en,
+		table: pgTable('table', {
+			en1: en().array(),
+			en2: en().array('[][]'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE TABLE "table" (\n\t"en1" "schema"."e"[],\n\t"en2" "schema"."e"[][]\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5609
+test('enums #24', async () => {
+	const schema = pgSchema('schema');
+	const en = schema.enum('char_enum', ['a', 'b']);
+
+	const from = {
+		schema,
+		en,
+	};
+
+	const to = {
+		schema,
+		en,
+		table: schema.table('table', {
+			en: en(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE TABLE "schema"."table" (\n\t"en" "schema"."char_enum"\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop enum value', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop enum values', async () => {
+	// TODO: revise
+	const newSchema = pgSchema('mySchema');
+	const enum3 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
+		'addedToTop',
+		'custAll',
+		'custAdmin',
+		'custClerk',
+		'custInvoiceManager',
+		'addedToMiddle',
+		'custMgf',
+		'custApprover',
+		'custOrderWriter',
+		'custBuyer',
+	]);
+	const schema1 = {
+		enum3,
+		table: pgTable('enum_table', {
+			id: enum3(),
+		}),
+		newSchema,
+		table1: newSchema.table('enum_table', {
+			id: enum3(),
+		}),
+	};
+
+	const enum4 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
+		'addedToTop',
+		'custAll',
+		'custAdmin',
+		'custClerk',
+		'custInvoiceManager',
+		'custApprover',
+		'custOrderWriter',
+		'custBuyer',
+	]);
+	const schema2 = {
+		enum4,
+		table: pgTable('enum_table', {
+			id: enum4(),
+		}),
+		newSchema,
+		table1: newSchema.table('enum_table', {
+			id: enum4(),
+		}),
+	};
+
+	const schemas = ['public', 'mySchema'];
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, schemas });
+
+	const st0 = [
+		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
+		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
+		`DROP TYPE "enum_users_customer_and_ship_to_settings_roles";`,
+		`CREATE TYPE "enum_users_customer_and_ship_to_settings_roles" AS ENUM('addedToTop', 'custAll', 'custAdmin', 'custClerk', 'custInvoiceManager', 'custApprover', 'custOrderWriter', 'custBuyer');`,
+		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE "enum_users_customer_and_ship_to_settings_roles" USING "id"::"enum_users_customer_and_ship_to_settings_roles";`,
+		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE "enum_users_customer_and_ship_to_settings_roles" USING "id"::"enum_users_customer_and_ship_to_settings_roles";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+
+	// that breaks in pipeline. Order is different
+	expect(pst[0]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[1]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[2]).toStrictEqual(st0[2]);
+	expect(pst[3]).toStrictEqual(st0[3]);
+	expect(pst[4]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+	expect(pst[5]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+});
+
+test('drop enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		users: pgTable('users', {
+			col: enum1().default('value1'),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			col: text().default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "col" DROP DEFAULT;',
+		'ALTER TABLE "users" ALTER COLUMN "col" SET DATA TYPE text USING "col"::text;',
+		'ALTER TABLE "users" ALTER COLUMN "col" SET DEFAULT \'value1\';',
+		`DROP TYPE "enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop enum value. enum is columns data type', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		schema,
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3']);
+	const to = {
+		schema,
+		enum2,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+
+	// that breaks in pipeline. Order is different
+	expect(pst[0]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[1]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[2]).toStrictEqual(st0[2]);
+	expect(pst[3]).toStrictEqual(st0[3]);
+	expect(pst[4]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+	expect(pst[5]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+});
+
+test('shuffle enum values', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		schema,
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+		table2: schema.table('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+
+	// that breaks in pipeline. Order is different
+	expect(pst[0]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[1]).toStrictEqual(expect.toBeOneOf([st0[0], st0[1]]));
+	expect(pst[2]).toStrictEqual(st0[2]);
+	expect(pst[3]).toStrictEqual(st0[3]);
+	expect(pst[4]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+	expect(pst[5]).toStrictEqual(expect.toBeOneOf([st0[4], st0[5]]));
+});
+
+test('column is enum type with default value. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value2'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT \'value2\'::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop enum value. column of enum type. drop default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value2'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4295
+test('drop enum value. column of enum type with default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value1'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3');`,
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+		`ALTER TABLE \"table\" ALTER COLUMN \"column\" SET DEFAULT 'value1'::\"enum\";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums as ts enum', async () => {
+	enum Test {
+		value = 'value',
+	}
+
+	const to = {
+		enum: pgEnum('enum', Test),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('value');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is enum type with default value. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value2'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum type with default value. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').array().default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum with custom size type with default value. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value2}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum with custom size type. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array of enum with multiple dimenions with custom sizes type. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array('[][]'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').array('[][]'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[][];`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[][] USING "column"::"enum"[][];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array of enum with multiple dimenions type with custom size with default value. shuffle enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array('[][]').default([['value2']]),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').array('[][]').default([['value2']]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[][];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "enum";`,
+		`CREATE TYPE "enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[][] USING "column"::"enum"[][];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{{value2}}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is enum type with default value. custom schema. shuffle enum', async () => {
+	const schema = pgSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+	const from = {
+		schema,
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value2'),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum" USING "column"::"new_schema"."enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"new_schema"."enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum type with default value. custom schema. shuffle enum', async () => {
+	const schema = pgSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[] USING "column"::"new_schema"."enum"[];`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{value2}'::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum type with custom size with default value. custom schema. shuffle enum', async () => {
+	const schema = pgSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		'ALTER TABLE "new_schema"."table" ALTER COLUMN "column" DROP DEFAULT;',
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[] USING "column"::"new_schema"."enum"[];`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DEFAULT '{value2}'::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is array enum type with custom size. custom schema. shuffle enum', async () => {
+	const schema = pgSchema('new_schema');
+
+	const enum1 = schema.enum('enum', ['value1', 'value2', 'value3']);
+
+	const from = {
+		schema,
+		enum1,
+		table: schema.table('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const enum2 = schema.enum('enum', ['value1', 'value3', 'value2']);
+	const to = {
+		schema,
+		enum2,
+		table: schema.table('table', {
+			column: enum2('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE text[];`,
+		`DROP TYPE "new_schema"."enum";`,
+		`CREATE TYPE "new_schema"."enum" AS ENUM('value1', 'value3', 'value2');`,
+		`ALTER TABLE "new_schema"."table" ALTER COLUMN "column" SET DATA TYPE "new_schema"."enum"[] USING "column"::"new_schema"."enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('column is enum type without default value. add default to column', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum', ['value1', 'value3']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to enum', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to enum. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').default('value2'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3'::"enum";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change data type from standart type to enum. set default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+		`ALTER TABLE \"table\" ALTER COLUMN \"column\" SET DEFAULT 'value1'::"enum";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change data type from standart type to enum. altered column has no default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').default('value2'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change data type from standart type to enum. column has no default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum" USING "column"::"enum";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array standart type to array enum. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array standart type to array enum. column without default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array standart type with custom size to array enum with custom size. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value3']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value3}'::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array standart type with custom size to array enum with custom size. column without default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum"[] USING "column"::"enum"[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from enum type to standart type', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar USING \"column\"::varchar;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from enum type to standart type. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar USING \"column\"::varchar;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array enum type to array standart type', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[] USING \"column\"::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array enum with custom size type to array standart type with custom size', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array(),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[] USING \"column\"::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+//
+test('change data type from array enum type to array standart type. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[] USING \"column\"::varchar[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value2}'::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from array enum type with custom size to array standart type with custom size. column has default', async () => {
+	const enum1 = pgEnum('enum', ['value1', 'value2']);
+
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: enum1('column').array().default(['value2']),
+		}),
+	};
+
+	const to = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').array().default(['value2']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE varchar[] USING \"column\"::varchar[];`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT '{value2}'::varchar[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column'),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text USING \"column\"::text;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type. column has default', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column').default('value3'),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text USING \"column\"::text;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type. columns are arrays', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[] USING \"column\"::text[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type. columns are arrays with custom sizes', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column').array(),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column').array(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[] USING \"column\"::text[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type. columns are arrays. column has default', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column').array().default(['hello']),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column').array().default(['hello']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[] USING \"column\"::text[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from standart type to standart type. columns are arrays with custom sizes.column has default', async () => {
+	const from = {
+		table: pgTable('table', {
+			column: varchar('column').array().default(['hello']),
+		}),
+	};
+
+	const to = {
+		table: pgTable('table', {
+			column: text('column').array().default(['hello']),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text[] USING "column"::text[];`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from one enum to other', async () => {
+	const enum1 = pgEnum('enum1', ['value1', 'value3']);
+	const enum2 = pgEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum1('column'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum2" USING "column"::text::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from one enum to other. column has default', async () => {
+	const enum1 = pgEnum('enum1', ['value1', 'value3']);
+	const enum2 = pgEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum1('column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value3'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum2" USING "column"::text::"enum2";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value3'::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// +
+test('change data type from one enum to other. changed defaults', async () => {
+	const enum1 = pgEnum('enum1', ['value1', 'value3']);
+	const enum2 = pgEnum('enum2', ['value1', 'value3']);
+
+	const from = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum1('column').default('value3'),
+		}),
+	};
+
+	const to = {
+		enum1,
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value1'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum2" USING "column"::text::"enum2";`,
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value1'::"enum2";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('check filtering json statements. here we have recreate enum + set new type + alter default', async () => {
+	const enum1 = pgEnum('enum1', ['value1', 'value3']);
+	const from = {
+		enum1,
+		table: pgTable('table', {
+			column: varchar('column').default('value3'),
+		}),
+	};
+
+	const enum2 = pgEnum('enum1', ['value3', 'value1', 'value2']);
+	const to = {
+		enum2,
+		table: pgTable('table', {
+			column: enum2('column').default('value2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'DROP TYPE "enum1";',
+		`CREATE TYPE "enum1" AS ENUM('value3', 'value1', 'value2');`,
+		'ALTER TABLE "table" ALTER COLUMN "column" DROP DEFAULT;',
+		'ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "enum1" USING "column"::"enum1";',
+		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"enum1";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column with same name as enum', async () => {
+	const statusEnum = pgEnum('status', ['inactive', 'active', 'banned']);
+
+	const schema1 = {
+		statusEnum,
+		table1: pgTable('table1', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		statusEnum,
+		table1: pgTable('table1', {
+			id: serial('id').primaryKey(),
+			status: statusEnum('status').default('inactive'),
+		}),
+		table2: pgTable('table2', {
+			id: serial('id').primaryKey(),
+			status: statusEnum('status').default('inactive'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE TABLE "table2" (\n\t"id" serial PRIMARY KEY,\n\t"status" "status" DEFAULT \'inactive\'::"status"\n);\n',
+		'ALTER TABLE "table1" ADD COLUMN "status" "status" DEFAULT \'inactive\'::"status";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enums ordering', async () => {
+	const schema1 = {
+		enum: pgEnum('settings', ['all', 'admin']),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema3 = {
+		enum: pgEnum('settings', ['new', 'all', 'admin']),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema3, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema3 });
+
+	expect(st2).toStrictEqual(["ALTER TYPE \"settings\" ADD VALUE 'new' BEFORE 'all';"]);
+	expect(pst2).toStrictEqual(["ALTER TYPE \"settings\" ADD VALUE 'new' BEFORE 'all';"]);
+
+	const schema4 = {
+		enum3: pgEnum('settings', ['new', 'all', 'new2', 'admin']),
+	};
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, schema4, []);
+	const { sqlStatements: pst3 } = await push({ db, to: schema4 });
+
+	const st0 = [
+		`ALTER TYPE "settings" ADD VALUE 'new2' BEFORE 'admin';`,
+	];
+
+	expect(st3).toStrictEqual(st0);
+	expect(pst3).toStrictEqual(st0);
+
+	const { sqlStatements: st4 } = await diff(n3, schema4, []);
+	const { sqlStatements: pst4 } = await push({ db, to: schema4 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4345
+test('add duplicate to enum', async () => {
+	const schema1 = {
+		accountStatusList: pgEnum('accountStatusList', ['active', 'banned', 'deleted']),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const schema2 = {
+		accountStatusList: pgEnum('accountStatusList', ['active', 'banned', 'suspended', 'deleted', 'suspended']),
+	};
+
+	await expect(diff(n1, schema2, [])).rejects.toThrowError();
+	await expect(push({ db, to: schema2 })).rejects.toThrowError();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5130
+// https://github.com/drizzle-team/drizzle-orm/pull/5131
+test('enums defaults', async () => {
+	enum status {
+		active = 'active',
+		inactive = 'inactive',
+	}
+	const Status = {
+		active: 'active',
+		inactive: 'inactive',
+	} as const;
+
+	const en1 = pgEnum('en1', status);
+	const en2 = pgEnum('en2', Status);
+
+	const to = {
+		en1,
+		en2,
+		table: pgTable('table', {
+			col1: en1().default(status.active),
+			col2: en2().default('inactive'),
+		}),
+	};
+
+	const res = await diff({}, to, []);
+	await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		"CREATE TYPE \"en1\" AS ENUM('active', 'inactive');",
+		"CREATE TYPE \"en2\" AS ENUM('active', 'inactive');",
+		'CREATE TABLE "table" (\n\t"col1" "en1" DEFAULT \'active\'::"en1",\n\t"col2" "en2" DEFAULT \'inactive\'::"en2"\n);\n',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5129
+// https://github.com/drizzle-team/drizzle-orm/issues/5121
+test('enums camelcase', async () => {
+	const en1 = pgEnum('camelCase', ['active', 'inactive']);
+
+	const to = {
+		en1,
+		table: pgTable('table', {
+			col1: en1().default('active'),
+		}),
+	};
+
+	const res = await diff({}, to, []);
+	await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		"CREATE TYPE \"camelCase\" AS ENUM('active', 'inactive');",
+		'CREATE TABLE "table" (\n\t"col1" "camelCase" DEFAULT \'active\'::"camelCase"\n);\n',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5072
+// tests with enum recreations are handled above
+test('drop enum', async () => {
+	const en1 = pgEnum('camelCase', ['active', 'inactive']);
+
+	const to = {
+		en1,
+	};
+
+	const res = await diff({}, to, []);
+	await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		"CREATE TYPE \"camelCase\" AS ENUM('active', 'inactive');",
+	]);
+
+	const res2 = await diff(res.next, {}, []);
+	await push({ db, to: {} });
+
+	expect(res2.sqlStatements).toStrictEqual([
+		'DROP TYPE "camelCase";',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4982
+// enhancement
+test.skipIf(Date.now() < +new Date('2026-07-01'))(
+	'alter enum values; enum value is column default; table with data',
+	async () => {
+		enum AppStatus1 {
+			PENDING = 'PENDING',
+			ACTIVE = 'ACTIVE',
+			INACTIVE = 'INACTIVE',
+			BANNED = 'BANNED',
+		}
+
+		const appStatusEnum1 = pgEnum('app_status', AppStatus1);
+
+		const schema1 = {
+			appStatusEnum1,
+			table1: pgTable('users', {
+				id: uuid('id').primaryKey().defaultRandom(),
+				appStatus: appStatusEnum1('app_status').default(AppStatus1.PENDING).notNull(),
+				appStatusNotes: text('app_status_notes'),
+			}),
+		};
+
+		const { next: n1 } = await diff({}, schema1, []);
+		await push({ db, to: schema1 });
+		await db.query(`insert into "users"("app_status") values ('PENDING'), ('PENDING');`);
+
+		enum AppStatus2 {
+			IN_REVIEW = 'IN_REVIEW',
+			ACTIVE = 'ACTIVE',
+			PAUSED = 'PAUSED',
+			BANNED = 'BANNED',
+		}
+
+		const appStatusEnum2 = pgEnum('app_status', AppStatus2);
+
+		const schema2 = {
+			appStatusEnum2,
+			table1: pgTable('users', {
+				id: uuid('id').primaryKey().defaultRandom(),
+				appStatus: appStatusEnum2('app_status').default(AppStatus2.IN_REVIEW).notNull(),
+				appStatusNotes: text('app_status_notes'),
+			}),
+		};
+
+		const { sqlStatements: st2 } = await diff(n1, schema2, []);
+		const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+		// if it can be implemented, there is an advantage comparing to current flow:
+		// drizzle-kit can alter enum values in tables with data;
+		// (
+		// already inserted old enum values automatically changes to new;
+		// old default enum value changes to new automatically as well;
+		// on table with 1M rows all storing old enum value, rename query executes in 37ms;
+		// )
+		const expectedSt2 = [
+			`ALTER TYPE "app_status" RENAME VALUE 'PENDING' TO 'IN_REVIEW';`,
+			`ALTER TYPE "app_status" RENAME VALUE 'INACTIVE' TO 'PAUSED';`,
+		];
+		expect(st2).toStrictEqual(expectedSt2);
+		expect(pst2).toStrictEqual(expectedSt2);
+	},
+);
diff --git a/drizzle-kit/tests/postgres/pg-generated.test.ts b/drizzle-kit/tests/postgres/pg-generated.test.ts
new file mode 100644
index 0000000000..ddfced7d7b
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-generated.test.ts
@@ -0,0 +1,508 @@
+// test cases
+
+import { SQL, sql } from 'drizzle-orm';
+import { integer, pgEnum, pgTable, text } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('generated as callback: add column with generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: change generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+// ---
+
+test('generated as sql: add column with generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\"users\".\"name\" || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\"`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+// ---
+
+test('generated as string: add column with generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') STORED;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\"users\".\"name\" || 'to add'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'to add\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'to delete'`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"gen_name\" DROP EXPRESSION;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\"users\".\"name\" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we don't trigger generated column recreate if definition change within push
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4622
+test('generated as string: enum column', async () => {
+	const roleEnum = pgEnum('role-enum', ['admin', 'manager']);
+	const to = {
+		roleEnum,
+		users: pgTable('users', {
+			role: roleEnum('gen_name').generatedAlwaysAs(sql`'admin'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TYPE "role-enum" AS ENUM('admin', 'manager');`,
+		'CREATE TABLE "users" (\n'
+		+ `\t"gen_name" "role-enum" GENERATED ALWAYS AS ('admin') STORED\n`
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter generated constraint', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
+		}),
+	};
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" DROP COLUMN "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignores definition changes
+});
diff --git a/drizzle-kit/tests/postgres/pg-identity.test.ts b/drizzle-kit/tests/postgres/pg-identity.test.ts
new file mode 100644
index 0000000000..d7ffa860e8
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-identity.test.ts
@@ -0,0 +1,635 @@
+import { bigint, integer, pgSchema, pgSequence, pgTable, serial, smallint, text } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// same table - no diff
+// 2. identity always/by default - no params +
+// 3. identity always/by default - with a few params +
+// 4. identity always/by default - with all params +
+
+// diff table with create statement
+// 2. identity always/by default - no params +
+// 3. identity always/by default - with a few params +
+// 4. identity always/by default - with all params +
+
+// diff for drop statement
+// 2. identity always/by default - no params, with params +
+
+// diff for alters
+// 2. identity always/by default - no params -> add param +
+// 3. identity always/by default - with a few params - remove/add/change params +
+// 4. identity always/by default - with all params - remove/add/change params +
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create table: identity always/by default - no params', async () => {
+	const from = {};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity(),
+			id2: smallint('id2').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 1 CACHE 1),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table: identity always/by default - few params', async () => {
+	// TODO revise: added id1, id2 columns to users table, like in same test from push.test.ts
+	const from = {};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+			}),
+			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
+				startWith: 120,
+				maxValue: 17000,
+			}),
+			id2: smallint('id2').generatedByDefaultAsIdentity({ cycle: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_seq" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 1),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1 CYCLE)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table: identity always/by default - all params', async () => {
+	// TODO revise: added id1, id2 columns to users table, like in same test from push.test.ts
+	const from = {};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+				cycle: false,
+			}),
+			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
+				startWith: 120,
+				maxValue: 17000,
+				increment: 3,
+				cycle: true,
+				cache: 100,
+			}),
+			id2: smallint('id2').generatedByDefaultAsIdentity({ cycle: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_seq" INCREMENT BY 4 MINVALUE 3 MAXVALUE 1000 START WITH 3 CACHE 200),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 3 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 100 CYCLE),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1 CYCLE)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('no diff: identity always/by default - no params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+			id2: integer('id2').generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+			id2: integer('id2').generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('no diff: identity always/by default - few params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				increment: 1,
+				startWith: 3,
+			}),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				increment: 1,
+				startWith: 3,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('no diff: identity always/by default - all params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+				cycle: false,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cycle: true,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				name: 'custom_seq',
+				increment: 4,
+				minValue: 3,
+				maxValue: 1000,
+				cache: 200,
+				cycle: false,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cycle: true,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from a column - no params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from a column - few params', async () => {
+	// TODO revise: added id1, id2 columns to users table, like in the same test from push.test.ts
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				increment: 3,
+			}),
+			id1: integer('id1').generatedByDefaultAsIdentity({
+				name: 'custom_name1',
+				increment: 4,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				name: 'custom_name2',
+				increment: 4,
+			}),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP IDENTITY;',
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP NOT NULL;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP IDENTITY;',
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop identity from a column - all params', async () => {
+	// TODO revise: added id1, id2 columns to users table, like in the same test from push.test.ts
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				increment: 3,
+				cache: 100,
+				cycle: true,
+			}),
+			id1: integer('id1').generatedByDefaultAsIdentity({
+				name: 'custom_name1',
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cycle: true,
+				cache: 10,
+				increment: 2,
+			}),
+			id2: integer('id2').generatedAlwaysAsIdentity({
+				name: 'custom_name2',
+				startWith: 10,
+				minValue: 10,
+				maxValue: 1000,
+				cycle: true,
+				cache: 10,
+				increment: 2,
+			}),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP NOT NULL;',
+		`ALTER TABLE \"users\" ALTER COLUMN \"id1\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id1" DROP NOT NULL;',
+		`ALTER TABLE \"users\" ALTER COLUMN \"id2\" DROP IDENTITY;`,
+		'ALTER TABLE "users" ALTER COLUMN "id2" DROP NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter identity from a column - no params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter identity from a column - few params', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
+		}),
+	};
+
+	// TODO revise: added more params, like in same test from push.test.ts
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				cache: 10,
+				increment: 4,
+				maxValue: 10000,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET MAXVALUE 10000;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET INCREMENT BY 4;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter identity from a column - by default to always', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity({
+				startWith: 100,
+				cache: 10,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED ALWAYS;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter identity from a column - always to by default', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				startWith: 100,
+				cache: 10,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 10;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column with identity - few params', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			email: text('email'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			email: text('email'),
+			id: integer('id').generatedByDefaultAsIdentity({ name: 'custom_name' }),
+			id1: integer('id1').generatedAlwaysAsIdentity({
+				name: 'custom_name1',
+				increment: 4,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ADD COLUMN "id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+		'ALTER TABLE "users" ADD COLUMN "id1" integer GENERATED ALWAYS AS IDENTITY (sequence name "custom_name1" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add identity to column - few params', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').notNull(),
+			id1: integer('id1').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({ name: 'custom_name' }),
+			id1: integer('id1').generatedAlwaysAsIdentity({
+				name: 'custom_name1',
+				increment: 4,
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE "users" ALTER COLUMN "id" ADD GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+		'ALTER TABLE "users" ALTER COLUMN "id1" ADD GENERATED ALWAYS AS IDENTITY (sequence name "custom_name1" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2630
+test('alter sequence to identity', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: serial().primaryKey(),
+		}),
+	};
+
+	const to = {
+		users: pgTable('users', {
+			id: integer().primaryKey().generatedAlwaysAsIdentity(),
+		}),
+	};
+	await push({ db, to: from });
+	await db.query(`insert into users (id) values (default),(default),(default);`);
+
+	const res = await push({ db, to });
+
+	expect(res.sqlStatements).toStrictEqual([
+		'ALTER TABLE "users" ALTER COLUMN "id" DROP DEFAULT;',
+		'DROP SEQUENCE "users_id_seq";',
+		'ALTER TABLE "users" ALTER COLUMN "id" SET DATA TYPE integer USING "id"::integer;',
+		'ALTER TABLE "users" ALTER COLUMN "id" ADD GENERATED ALWAYS AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
+		'SELECT setval(\'users_id_seq\'::regclass, (SELECT COALESCE(MAX(id), 1) FROM "users"), false);',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4969
+test('mySchema; identity column', async () => {
+	const schema = pgSchema('my-schema');
+	const to = {
+		schema,
+		todo: schema.table('todo', {
+			id: integer('id').primaryKey().generatedAlwaysAsIdentity(),
+			title: text('title').notNull(),
+			description: text('description'),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, to, []);
+	await push({ db, to, schemas: ['public', 'my-schema'] });
+
+	const { sqlStatements: st2 } = await diff(n1, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, schemas: ['public', 'my-schema'] });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pg-indexes.test.ts b/drizzle-kit/tests/postgres/pg-indexes.test.ts
new file mode 100644
index 0000000000..8e203c8bb9
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-indexes.test.ts
@@ -0,0 +1,815 @@
+import { and, eq, isNotNull, isNull, like, SQL, sql } from 'drizzle-orm';
+import {
+	boolean,
+	index,
+	integer,
+	pgEnum,
+	pgRole,
+	pgSchema,
+	pgTable,
+	serial,
+	text,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	vector,
+} from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase(false);
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('adding basic indexes', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			},
+			(t) => [
+				index()
+					.on(t.name.desc(), t.id.asc().nullsLast())
+					.with({ fillfactor: 70 })
+					.where(sql`name != 'alef'`),
+				index('indx1')
+					.using('hash', t.name)
+					.with({ fillfactor: 70 }),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "users_name_id_index" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70) WHERE name != 'alef';`,
+		`CREATE INDEX "indx1" ON "users" USING hash ("name") WITH (fillfactor=70);`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('dropping basic index', async () => {
+	const schema1 = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+				id2: integer('id2'),
+				name2: text('name2'),
+			},
+			(
+				t,
+			) => [
+				index().on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
+				uniqueIndex().on(t.name2.desc(), t.id2.asc().nullsLast()).with({ fillfactor: 70 }),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+			id2: integer('id2'),
+			name2: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [`DROP INDEX "users_name_id_index";`, `DROP INDEX "users_name2_id2_index";`];
+
+	expect(st[0]).toBeOneOf([st0[0], st0[1]]);
+	expect(st[1]).toBeOneOf([st0[0], st0[1]]);
+	expect(pst[0]).toBeOneOf([st0[0], st0[1]]);
+	expect(pst[1]).toBeOneOf([st0[0], st0[1]]);
+});
+
+test('dropping basic index in other schema', async () => {
+	const schema = pgSchema('otherSchema');
+	const schema1 = {
+		schema,
+		users: schema.table(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+				id2: integer('id2'),
+				name2: text('name2'),
+			},
+			(
+				t,
+			) => [
+				index().on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
+				uniqueIndex().on(t.name2.desc(), t.id2.asc().nullsLast()).with({ fillfactor: 70 }),
+			],
+		),
+	};
+
+	const schema2 = {
+		schema,
+		users: schema.table('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+			id2: integer('id2'),
+			name2: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [`DROP INDEX "otherSchema"."users_name_id_index";`, `DROP INDEX "otherSchema"."users_name2_id2_index";`];
+
+	expect(st[0]).toBeOneOf([st0[0], st0[1]]);
+	expect(st[1]).toBeOneOf([st0[0], st0[1]]);
+	expect(pst[0]).toBeOneOf([st0[0], st0[1]]);
+	expect(pst[1]).toBeOneOf([st0[0], st0[1]]);
+});
+
+test('altering indexes', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('removeColumn').on(t.name, t.id),
+			index('addColumn').on(t.name.desc()).with({ fillfactor: 70 }),
+			index('removeExpression').on(t.name.desc(), sql`name`).concurrently(),
+			index('addExpression').on(t.id.desc()),
+			index('changeExpression').on(t.id.desc(), sql`name`),
+			index('changeName').on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
+			index('changeWith').on(t.name).with({ fillfactor: 70 }),
+			index('changeUsing').on(t.name),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('removeColumn').on(t.name),
+			index('addColumn').on(t.name.desc(), t.id.nullsLast()).with({ fillfactor: 70 }),
+			index('removeExpression').on(t.name.desc()).concurrently(),
+			index('addExpression').on(t.id.desc()),
+			index('changeExpression').on(t.id.desc(), sql`name desc`),
+			index('newName').on(t.name.desc(), sql`name`).with({ fillfactor: 70 }),
+			index('changeWith').on(t.name).with({ fillfactor: 90 }),
+			index('changeUsing').using('hash', t.name),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70);',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX CONCURRENTLY "removeExpression" ON "users" ("name" DESC NULLS LAST);',
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC NULLS LAST,name desc);',
+		'DROP INDEX "changeWith";',
+		'CREATE INDEX "changeWith" ON "users" ("name") WITH (fillfactor=90);',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" USING hash ("name");',
+		'CREATE INDEX "newName" ON "users" ("name" DESC NULLS LAST,name) WITH (fillfactor=70);',
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70);',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" USING hash ("name");',
+		'DROP INDEX "changeWith";',
+		'CREATE INDEX "changeWith" ON "users" ("name") WITH (fillfactor=90);',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX CONCURRENTLY "removeExpression" ON "users" ("name" DESC NULLS LAST);',
+		'CREATE INDEX "newName" ON "users" ("name" DESC NULLS LAST,name) WITH (fillfactor=70);',
+	]);
+});
+
+test('indexes test case #1', async () => {
+	const schema1 = {
+		users: pgTable(
+			'users',
+			{
+				id: uuid('id').defaultRandom().primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: boolean('in_stock').default(true),
+			},
+			(t) => [
+				index().on(t.id.desc().nullsFirst()),
+				index('indx1').on(t.id, t.imageUrl),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: pgTable(
+			'users',
+			{
+				id: uuid('id').defaultRandom().primaryKey(),
+				name: text('name').notNull(),
+				description: text('description'),
+				imageUrl: text('image_url'),
+				inStock: boolean('in_stock').default(true),
+			},
+			(t) => [
+				index().on(t.id.desc().nullsFirst()),
+				index('indx1').on(t.id, t.imageUrl),
+				index('indx4').on(t.id),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('Indexes properties that should not trigger push changes', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('changeExpression').on(t.id.desc(), sql`name`),
+			index('indx1').on(t.name.desc()).concurrently(),
+			index('indx2').on(t.name.desc()).where(sql`true`),
+			index('indx3').on(t.name.op('text_ops')).where(sql`true`),
+			index('indx4').on(sql`lower(name)`).where(sql`true`),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('changeExpression').on(t.id.desc(), sql`name desc`),
+			index('indx1').on(t.name.desc()),
+			index('indx2').on(t.name.desc()).where(sql`false`),
+			index('indx3').on(t.name.op('test')).where(sql`true`),
+			index('indx4').on(sql`lower(id)`).where(sql`true`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC NULLS LAST,name desc);',
+		'DROP INDEX "indx2";',
+		'CREATE INDEX "indx2" ON "users" ("name" DESC NULLS LAST) WHERE false;',
+		'DROP INDEX "indx3";',
+		'CREATE INDEX "indx3" ON "users" ("name" test);',
+		'DROP INDEX "indx4";',
+		'CREATE INDEX "indx4" ON "users" (lower(id));',
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX "indx2";',
+		'CREATE INDEX "indx2" ON "users" ("name" DESC NULLS LAST) WHERE false;',
+	]);
+});
+
+test('indexes #0', async (t) => {
+	const schema1 = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			},
+			(
+				t,
+			) => [
+				index('removeColumn').on(t.name, t.id),
+				index('addColumn').on(t.name.desc()).with({ fillfactor: 70 }),
+				index('removeExpression').on(t.name.desc(), sql`name`).concurrently(),
+				index('addExpression').on(t.id.desc()),
+				index('changeExpression').on(t.id.desc(), sql`name`),
+				index('changeName').on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
+				index('changeWith').on(t.name).with({ fillfactor: 70 }),
+				index('changeUsing').on(t.name),
+			],
+		),
+	};
+
+	const schema2 = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			},
+			(t) => [
+				index('removeColumn').on(t.name),
+				index('addColumn').on(t.name.desc(), t.id.nullsLast()).with({ fillfactor: 70 }),
+				index('removeExpression').on(t.name.desc()).concurrently(),
+				index('addExpression').on(t.id.desc()),
+				index('changeExpression').on(t.id.desc(), sql`name desc`),
+				index('newName').on(t.name.desc(), sql`name`).with({ fillfactor: 70 }),
+				index('changeWith').on(t.name).with({ fillfactor: 90 }),
+				index('changeUsing').using('hash', t.name),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70);',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX CONCURRENTLY "removeExpression" ON "users" ("name" DESC NULLS LAST);',
+		'DROP INDEX "changeExpression";',
+		'CREATE INDEX "changeExpression" ON "users" ("id" DESC NULLS LAST,name desc);',
+		'DROP INDEX "changeWith";',
+		'CREATE INDEX "changeWith" ON "users" ("name") WITH (fillfactor=90);',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" USING hash ("name");',
+		'CREATE INDEX "newName" ON "users" ("name" DESC NULLS LAST,name) WITH (fillfactor=70);',
+	]);
+
+	// for push we ignore change of index expressions
+	expect(pst).toStrictEqual([
+		'DROP INDEX "changeName";',
+		'DROP INDEX "addColumn";',
+		'CREATE INDEX "addColumn" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70);',
+		// 'DROP INDEX "changeExpression";',
+		'DROP INDEX "changeUsing";',
+		'CREATE INDEX "changeUsing" ON "users" USING hash ("name");',
+		'DROP INDEX "changeWith";',
+		'CREATE INDEX "changeWith" ON "users" ("name") WITH (fillfactor=90);',
+		'DROP INDEX "removeColumn";',
+		'CREATE INDEX "removeColumn" ON "users" ("name");',
+		'DROP INDEX "removeExpression";',
+		'CREATE INDEX CONCURRENTLY "removeExpression" ON "users" ("name" DESC NULLS LAST);',
+		'CREATE INDEX "newName" ON "users" ("name" DESC NULLS LAST,name) WITH (fillfactor=70);',
+		// 'CREATE INDEX "changeExpression" ON "users" ("id" DESC NULLS LAST,name desc);',
+	]);
+});
+
+test('vector index', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: vector('name', { dimensions: 3 }),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			embedding: vector('name', { dimensions: 3 }),
+		}, (t) => [
+			index('vector_embedding_idx')
+				.using('hnsw', t.embedding.op('vector_ip_ops'))
+				.with({ m: 16, ef_construction: 64 }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "vector_embedding_idx" ON "users" USING hnsw ("name" vector_ip_ops) WITH (m=16, ef_construction=64);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('index #2', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('indx').on(t.name.desc()).concurrently(),
+			index('indx1').on(t.name.desc()),
+			index('indx2').on(t.name.op('text_ops')),
+			index('indx3').on(sql`lower(name)`),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index('indx').on(t.name.desc()),
+			index('indx1').on(t.name.desc()).where(sql`false`),
+			index('indx2').on(t.name.op('test')),
+			index('indx3').on(sql`lower(${t.name})`),
+			index('indx4').on(sql`lower(name)`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP INDEX "indx1";',
+		'CREATE INDEX "indx1" ON "users" ("name" DESC NULLS LAST) WHERE false;',
+		'DROP INDEX "indx2";',
+		'CREATE INDEX "indx2" ON "users" ("name" test);',
+		'DROP INDEX "indx3";',
+		'CREATE INDEX "indx3" ON "users" (lower("name"));',
+		'CREATE INDEX "indx4" ON "users" (lower(name));',
+	]);
+	expect(pst).toStrictEqual([
+		'DROP INDEX "indx1";',
+		'CREATE INDEX "indx1" ON "users" ("name" DESC NULLS LAST) WHERE false;',
+		// TODO: we ignore columns changes during 'push', we should probably tell user about it in CLI?
+		// 'DROP INDEX "indx2";',
+		// 'DROP INDEX "indx3";',
+		'CREATE INDEX "indx4" ON "users" (lower(name));',
+		// 'CREATE INDEX "indx2" ON "users" ("name" test);',
+		// 'CREATE INDEX "indx3" ON "users" (lower("name"));',
+	]);
+});
+
+test('index #3', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		}, (t) => [
+			index().on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }).where(sql`name != 'alex'`),
+			index('indx1').using('hash', sql`${t.name}`).with({ fillfactor: 70 }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		`CREATE INDEX "users_name_id_index" ON "users" ("name" DESC NULLS LAST,"id") WITH (fillfactor=70) WHERE name != 'alex';`,
+		`CREATE INDEX "indx1" ON "users" USING hash ("name") WITH (fillfactor=70);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4929
+test('index #4', async (t) => {
+	const table1 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column2: timestamp('column2'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table1.column1), isNull(table1.column2))!,
+				)
+				.notNull(),
+		},
+		(table) => [index('table_uid_bool_idx').on(table.uid, table.bool)],
+	);
+	const schema1 = { table: table1 };
+
+	const table2 = pgTable(
+		'table',
+		{
+			uid: uuid('uid').notNull(),
+			column1: timestamp('column1'),
+			column3: timestamp('column3'),
+			bool: boolean('bool')
+				.generatedAlwaysAs(
+					(): SQL => and(isNull(table2.column1), isNull(table2.column3))!,
+				)
+				.notNull(),
+		},
+		(table) => [index('table_uid_bool_idx').on(table.uid, table.bool)],
+	);
+	const schema2 = { table: table2 };
+
+	const renames = ['public.table.column2->public.table.column3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	expect(st).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+		`ALTER TABLE \"table\" DROP COLUMN \"bool\";`,
+		`ALTER TABLE \"table\" ADD COLUMN \"bool\" boolean GENERATED ALWAYS AS ((((\"table\".\"column1\" is null)) and ((\"table\".\"column3\" is null)))) STORED;`,
+		`CREATE INDEX "table_uid_bool_idx" ON "table" ("uid","bool");`,
+	]);
+	// push is not triggered on generated change
+	expect(pst).toStrictEqual([
+		`ALTER TABLE \"table\" RENAME COLUMN \"column2\" TO \"column3\";`,
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2506
+// https://github.com/drizzle-team/drizzle-orm/issues/4790
+test('index #5', async (t) => {
+	const enum_ = pgEnum('enum', ['text', 'not_text']);
+	const schema1 = {
+		enum_,
+		table1: pgTable('table1', {
+			column1: integer(),
+			column2: integer(),
+			column3: integer(),
+			column4: boolean(),
+			column5: enum_(),
+			column6: text(),
+		}, (table) => [
+			uniqueIndex().on(table.column1).where(eq(table.column4, true)),
+			uniqueIndex().on(table.column2).where(eq(table.column5, 'text')),
+			uniqueIndex().on(table.column3).where(like(table.column6, 'text')),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('text', 'not_text');`,
+		'CREATE TABLE "table1" (\n'
+		+ '\t"column1" integer,\n'
+		+ '\t"column2" integer,\n'
+		+ '\t"column3" integer,\n'
+		+ '\t"column4" boolean,\n'
+		+ '\t"column5" "enum",\n'
+		+ '\t"column6" text\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX "table1_column1_index" ON "table1" ("column1") WHERE "column4" = true;', // or with $1 param instead of true, but then params must be included in the query
+		`CREATE UNIQUE INDEX "table1_column2_index" ON "table1" ("column2") WHERE "column5" = 'text';`,
+		`CREATE UNIQUE INDEX "table1_column3_index" ON "table1" ("column3") WHERE "column6" like 'text';`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('index #6', async (t) => {
+	const enum_ = pgEnum('enum', ['text', 'not_text', 'something_else']);
+	const schema1 = {
+		enum_,
+		table1: pgTable('table1', {
+			column1: integer(),
+			column2: boolean(),
+			column3: enum_(),
+		}, (table) => [
+			uniqueIndex().on(table.column2).where(eq(table.column2, true)),
+			uniqueIndex().on(table.column3).where(eq(table.column3, 'text')),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff({}, schema1, []);
+	const { sqlStatements: pst } = await push({ db, to: schema1 });
+
+	const st0 = [
+		`CREATE TYPE "enum" AS ENUM('text', 'not_text', 'something_else');`,
+		'CREATE TABLE "table1" (\n'
+		+ '\t"column1" integer,\n'
+		+ '\t"column2" boolean,\n'
+		+ '\t"column3" "enum"\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX "table1_column2_index" ON "table1" ("column2") WHERE "column2" = true;', // or with $1 param instead of true, but then params must be included in the query
+		`CREATE UNIQUE INDEX "table1_column3_index" ON "table1" ("column3") WHERE "column3" = 'text';`, // in indices names maybe should be some hash
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5055
+test('index #8', async () => {
+	const table1 = pgTable('table1', {
+		eventAt: timestamp('eventAt').notNull().defaultNow(),
+	}, () => [
+		index('usage_item_eventAt_month_idx').on(sql.raw('date_trunc(\'month\', "eventAt")')),
+	]);
+	const schema1 = { table1 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"eventAt" timestamp DEFAULT now() NOT NULL\n);\n',
+		`CREATE INDEX \"usage_item_eventAt_month_idx\" ON \"table1\" (date_trunc('month', \"eventAt\"));`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema1, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema1 });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('index #9', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			email: text().notNull(),
+		}, (table) => [
+			uniqueIndex('email_unique_idx').on(sql`lower(${table.email})`),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"email" text NOT NULL\n);\n',
+		`CREATE UNIQUE INDEX "email_unique_idx" ON "table1" (lower("email"));`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		table1: pgTable('table1', {
+			email: text().notNull(),
+		}, (table) => [
+			uniqueIndex('email_unique_idx').on(table.email),
+		]),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		`DROP INDEX "email_unique_idx";`,
+		`CREATE UNIQUE INDEX "email_unique_idx" ON "table1" ("email");`,
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual([]); // diffs for columns on push are ignored
+
+	const { sqlStatements: st3 } = await diff(n2, schema2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: schema2 });
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5467
+test('index in other schema', async () => {
+	const commonSchema = pgSchema('common');
+
+	const schema1 = {
+		commonSchema,
+		directoriesTable: commonSchema.table(
+			'filesystems_directories',
+			{
+				filesystemId: text(),
+			},
+			(table) => [index().on(table.filesystemId)],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE SCHEMA "common";\n',
+		'CREATE TABLE "common"."filesystems_directories" (\n\t"filesystemId" text\n);\n',
+		`CREATE INDEX "filesystems_directories_filesystemId_index" ON "common"."filesystems_directories" ("filesystemId");`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		commonSchema,
+		directoriesTable: commonSchema.table(
+			'filesystems_directories',
+			{
+				filesystemId: text(),
+			},
+		),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		`DROP INDEX "common"."filesystems_directories_filesystemId_index";`,
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5495
+test('access method issue', async () => {
+	await db.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+
+	const schema = {
+		table: pgTable(
+			'table',
+			{
+				id: integer(),
+				name: vector({ dimensions: 1536 }),
+			},
+			(table) => [index('idx_claims_embedding').using('ivfflat', table.name.asc().nullsLast().op('vector_cosine_ops'))],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	const expectedSt1 = [
+		'CREATE TABLE "table" (\n\t"id" integer,\n\t"name" vector(1536)\n);\n',
+		'CREATE INDEX "idx_claims_embedding" ON "table" USING ivfflat ("name" vector_cosine_ops);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5792
+test('issue #5792', async () => {
+	await db.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+
+	const schema = {
+		table: pgTable('readings', {
+			id: text('id').primaryKey(),
+			embedding: vector('embedding', { dimensions: 1536 }),
+		}, (table) => [
+			index('idx_readings_embedding')
+				.using('hnsw', table.embedding.op('vector_cosine_ops')),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	const expectedSt1 = [
+		'CREATE TABLE "readings" (\n\t"id" text PRIMARY KEY,\n\t"embedding" vector(1536)\n);\n',
+		'CREATE INDEX "idx_readings_embedding" ON "readings" USING hnsw ("embedding" vector_cosine_ops);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
diff --git a/drizzle-kit/tests/postgres/pg-policy.test.ts b/drizzle-kit/tests/postgres/pg-policy.test.ts
new file mode 100644
index 0000000000..3d9873fb52
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-policy.test.ts
@@ -0,0 +1,1849 @@
+import { sql } from 'drizzle-orm';
+import { authUid, crudPolicy } from 'drizzle-orm/neon';
+import { integer, pgPolicy, pgRole, pgSchema, pgTable, text } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from '../postgres/mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('full policy: no changes', async () => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + enable rls', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy + disable rls', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy without enable rls', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' }), pgPolicy('newRls')]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'CREATE POLICY "newRls" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy without disable rls', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' }), pgPolicy('oldRls')]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, ignoreSubsequent: true });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "oldRls" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy without recreation: changing roles #2', async (t) => {
+	const role = pgRole('test');
+	const schema1 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', to: role })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role.name] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role.name] } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "test";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('alter policy without recreation: changing roles', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', to: 'current_role' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, ignoreSubsequent: true });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO current_role;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy without recreation: changing using', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', using: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy without recreation: changing with check', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+///
+
+test('alter policy with recreation: changing as', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'restrictive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing for', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', for: 'delete' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing both "as" and "for"', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'restrictive', for: 'insert' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR INSERT TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy with recreation: changing all fields', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', for: 'select', using: sql`true` })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'restrictive', to: 'current_role', withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO current_role WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('alter policy with recreation: changing all fields #2', async (t) => {
+	const role = pgRole('test');
+	const schema1 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive', for: 'select', using: sql`true` })]),
+	};
+
+	const schema2 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'restrictive', to: role, withCheck: sql`true` })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role.name] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role.name] } },
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO "test" WITH CHECK (true);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename policy', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('newName', { as: 'permissive' })]),
+	};
+
+	const renames = [
+		'public.users.test->public.users.newName',
+	];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename policy in renamed table', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [
+			pgPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users2', {
+			id: integer('id').primaryKey(),
+		}, (t) => [pgPolicy('newName', { as: 'permissive' })]),
+	};
+
+	const renames = ['public.users->public.users2', 'public.users2.test->public.users2.newName'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0 = [
+		'ALTER TABLE "users" RENAME TO "users2";',
+		'ALTER POLICY "test" ON "users2" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with a policy', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: pgTable('users2', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users2" (\n\t"id" integer PRIMARY KEY\n);\n',
+		'ALTER TABLE "users2" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users2" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop table with a policy', async (t) => {
+	const schema1 = {
+		users: pgTable('users2', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { as: 'permissive' })]),
+	};
+
+	const schema2 = {};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users2";',
+		'DROP TABLE "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with multiple "to" roles', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const role = pgRole('manager');
+
+	const schema2 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: ['current_role', role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	// TODO: @AlexBlokh: it is now really weird that I have to include role names in entities when I just have them in schema
+	// if I don't - it will try to create same roles all the time
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_role, "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('add policy with multiple "to" roles #2', async (t) => {
+	const role2 = pgRole('test');
+	const schema1 = {
+		role2,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const role = pgRole('manager');
+
+	const schema2 = {
+		role2,
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: [role2, role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role2.name, role.name] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role2.name, role.name] } },
+	});
+
+	// TODO: @AlexBlokh: it is now really weird that I have to include role names in entities when I just have them in schema
+	// if I don't - it will try to create same roles all the time
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO "manager", "test";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with rls enabled', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('enable rls force', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('disable rls force', async (t) => {
+	const schema1 = {
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy with enabled rls', async (t) => {
+	const role = pgRole('manager');
+
+	const schema1 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: ['current_role', role] })]),
+	};
+
+	const schema2 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, ignoreSubsequent: true });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('drop policy with enabled rls #2', async (t) => {
+	const role = pgRole('manager');
+
+	const schema1 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: [role] })]),
+	};
+
+	const schema2 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy with enabled rls', async (t) => {
+	const schema1 = {
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const role = pgRole('manager');
+
+	const schema2 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: ['current_role', role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_role, "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('add policy with enabled rls #2', async (t) => {
+	const schema1 = {
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const role = pgRole('manager');
+
+	const schema2 = {
+		role,
+		users: pgTable.withRLS('users', {
+			id: integer('id').primaryKey(),
+		}, () => [pgPolicy('test', { to: [role] })]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link table', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('link table', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+		rls: pgPolicy('test', { as: 'permissive' }),
+	};
+
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unlink table', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop policy with link', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy in table and with link table', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	}, () => [
+		pgPolicy('test1', { to: 'current_user' }),
+	]);
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test1" ON "users" AS PERMISSIVE FOR ALL TO current_user;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('add policy in table and with link table #2', async (t) => {
+	const role = pgRole('test2');
+	const schema1 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	}, () => [
+		pgPolicy('test1', { to: role }),
+	]);
+
+	const schema2 = {
+		role,
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role.name] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role.name] } },
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test1" ON "users" AS PERMISSIVE FOR ALL TO "test2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('link non-schema table', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = { users };
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unlink non-schema table', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link non-schema table', async (t) => {
+	const cities = pgTable.withRLS('cities', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		cities,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		cities,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test2'),
+		]),
+		rls: pgPolicy('test', { as: 'permissive' }).link(cities),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0 = [
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add policy + link non-schema table from auth schema', async (t) => {
+	const authSchema = pgSchema('auth');
+	const cities = authSchema.table('cities', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		authSchema,
+		cities,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		authSchema,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test2'),
+		]),
+		cities,
+		rls: pgPolicy('test', { as: 'permissive' }).link(cities),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'ALTER TABLE "auth"."cities" ENABLE ROW LEVEL SECURITY;',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "auth"."cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	]);
+	expect(pst).toStrictEqual([
+		'ALTER TABLE "auth"."cities" ENABLE ROW LEVEL SECURITY;',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "test" ON "auth"."cities" AS PERMISSIVE FOR ALL TO public;',
+		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
+	]);
+});
+
+test('rename policy that is linked', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('newName', { as: 'permissive' }).link(users),
+	};
+
+	const renames = [
+		'public.users.test->public.users.newName',
+	];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy that is linked', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive', to: 'current_role' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO current_role;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('alter policy that is linked #2', async (t) => {
+	const role = pgRole('owner');
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		role,
+		users,
+		rls: pgPolicy('test', { as: 'permissive' }).link(users),
+	};
+
+	const schema2 = {
+		role,
+		users,
+		rls: pgPolicy('test', { as: 'permissive', to: role }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role.name, 'test'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role.name, 'test'] } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy that is linked: withCheck', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`true` }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`false` }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy that is linked: using', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive', using: sql`true` }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { as: 'permissive', using: sql`false` }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy that is linked: using', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users,
+		rls: pgPolicy('test', { for: 'insert' }).link(users),
+	};
+
+	const schema2 = {
+		users,
+		rls: pgPolicy('test', { for: 'delete' }).link(users),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+////
+
+test('alter policy in the table', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', to: 'current_role' }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['test'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['test'] } },
+		ignoreSubsequent: true,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO current_role;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+test('alter policy in the table #2', async (t) => {
+	const role = pgRole('owner');
+	const schema1 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive' }),
+		]),
+	};
+
+	const schema2 = {
+		role,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', to: role }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: [role.name] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [role.name] } },
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO "owner";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter policy in the table: withCheck', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', withCheck: sql`true` }),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', withCheck: sql`false` }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public WITH CHECK (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy in the table: using', async (t) => {
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', using: sql`true` }),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { as: 'permissive', using: sql`false` }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'ALTER POLICY "test" ON "users" TO public USING (false);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore [using withcheck] for push
+});
+
+test('alter policy in the table: using', async (t) => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+	});
+
+	const schema1 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { for: 'insert' }),
+		]),
+	};
+
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('test', { for: 'delete' }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0 = [
+		'DROP POLICY "test" ON "users";',
+		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4198
+test('create/alter policy for select, insert, update, delete', async () => {
+	const authenticatedRole = pgRole('authenticated');
+
+	const schema1 = {
+		authenticatedRole,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, () => [
+			pgPolicy('policy 1', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'select',
+				using: sql`
+(
+	(SELECT current_setting('auth.uid', true)) = 'some-user-id'
+)
+`,
+			}),
+			pgPolicy('policy 2', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'insert',
+				withCheck: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id')`,
+			}),
+			pgPolicy('policy 3', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'update',
+				using: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id')`,
+				withCheck: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id')`,
+			}),
+			pgPolicy('policy 4', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'delete',
+				using: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id')`,
+			}),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+
+	await db.query(`SET auth.uid = 'some-user-id';`);
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: schema1,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+	const expectedSt1 = [
+		'CREATE ROLE "authenticated";',
+		'CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "policy 1" ON "users" AS PERMISSIVE FOR SELECT TO "authenticated" USING (\n'
+		+ '(\n'
+		+ "\t(SELECT current_setting('auth.uid', true)) = 'some-user-id'\n"
+		+ ')\n'
+		+ ');',
+		`CREATE POLICY "policy 2" ON "users" AS PERMISSIVE FOR INSERT TO "authenticated" WITH CHECK (((SELECT current_setting('auth.uid', true)) = 'some-user-id'));`,
+		`CREATE POLICY "policy 3" ON "users" AS PERMISSIVE FOR UPDATE TO "authenticated" USING (((SELECT current_setting('auth.uid', true)) = 'some-user-id')) WITH CHECK (((SELECT current_setting('auth.uid', true)) = 'some-user-id'));`,
+		`CREATE POLICY "policy 4" ON "users" AS PERMISSIVE FOR DELETE TO "authenticated" USING (((SELECT current_setting('auth.uid', true)) = 'some-user-id'));`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authenticatedRole,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('policy 1', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'select',
+				// some-user-id => some-user-id11
+				using: sql`
+	(
+		(SELECT current_setting('auth.uid', true)) = 'some-user-id1'
+	)
+	`,
+			}),
+			pgPolicy('policy 2', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'insert',
+				withCheck: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id1')`,
+			}),
+			pgPolicy('policy 3', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'update',
+				using: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id1')`,
+				withCheck: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id1')`,
+			}),
+			pgPolicy('policy 4', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'delete',
+				using: sql`((SELECT current_setting('auth.uid', true)) = 'some-user-id1')`,
+			}),
+		]),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+
+	const expectedSt2 = [
+		'ALTER POLICY "policy 1" ON "users" TO "authenticated" USING (\n'
+		+ '\t(\n'
+		+ "\t\t(SELECT current_setting('auth.uid', true)) = 'some-user-id1'\n"
+		+ '\t)\n'
+		+ '\t);',
+		`ALTER POLICY "policy 2" ON "users" TO "authenticated" WITH CHECK (((SELECT current_setting('auth.uid', true)) = 'some-user-id1'));`,
+		`ALTER POLICY "policy 3" ON "users" TO "authenticated" USING (((SELECT current_setting('auth.uid', true)) = 'some-user-id1')) WITH CHECK (((SELECT current_setting('auth.uid', true)) = 'some-user-id1'));`,
+		`ALTER POLICY "policy 4" ON "users" TO "authenticated" USING (((SELECT current_setting('auth.uid', true)) = 'some-user-id1'));`,
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual([]); // using/with check is not handled for push
+
+	const { sqlStatements: st3 } = await diff(n2, schema2, []);
+
+	const { sqlStatements: pst3 } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	await db.query(`RESET auth.uid;`);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4198
+test('create/alter policy with comments', async () => {
+	const authenticatedRole = pgRole('authenticated');
+
+	const schema1 = {
+		authenticatedRole,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('policy 1', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'select',
+				using: sql`
+(
+	-- comment1
+	(SELECT current_setting('auth.uid', true)) = 'some-user-id'
+)
+	OR
+(
+	-- comment2
+	(SELECT current_setting('auth.uid', true)) = 'some-user-id1'
+)
+    `,
+			}),
+		]),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+
+	await db.query(`SET auth.uid = 'some-user-id';`);
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: schema1,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+	const expectedSt1 = [
+		'CREATE ROLE "authenticated";',
+		'CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n',
+		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "policy 1" ON "users" AS PERMISSIVE FOR SELECT TO "authenticated" USING (\n'
+		+ '(\n'
+		+ '\t-- comment1\n'
+		+ "\t(SELECT current_setting('auth.uid', true)) = 'some-user-id'\n"
+		+ ')\n'
+		+ '\tOR\n'
+		+ '(\n'
+		+ '\t-- comment2\n'
+		+ "\t(SELECT current_setting('auth.uid', true)) = 'some-user-id1'\n"
+		+ ')\n'
+		+ '    );',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const schema2 = {
+		authenticatedRole,
+		users: pgTable('users', {
+			id: integer('id').primaryKey(),
+		}, (t) => [
+			pgPolicy('policy 1', {
+				as: 'permissive',
+				to: authenticatedRole,
+				for: 'select',
+				using: sql`
+(
+	-- comment1
+	(SELECT current_setting('auth.uid', true)) = 'some-user-id'
+)
+	OR
+(
+	-- comment2
+	(SELECT current_setting('auth.uid', true)) = 'some-user-id2'
+)
+    `,
+			}),
+		]),
+	};
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, schema2, []);
+
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+
+	const expectedSt2 = [
+		'ALTER POLICY "policy 1" ON "users" TO "authenticated" USING (\n'
+		+ '(\n'
+		+ '\t-- comment1\n'
+		+ "\t(SELECT current_setting('auth.uid', true)) = 'some-user-id'\n"
+		+ ')\n'
+		+ '\tOR\n'
+		+ '(\n'
+		+ '\t-- comment2\n'
+		+ "\t(SELECT current_setting('auth.uid', true)) = 'some-user-id2'\n"
+		+ ')\n'
+		+ '    );',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual([]); // using/with check is not handled in push
+
+	const { sqlStatements: st3 } = await diff(n2, schema2, []);
+
+	const { sqlStatements: pst3 } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	await db.query(`RESET auth.uid;`);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4279
+test('create policy for neon', async () => {
+	const authenticatedRole = pgRole('authenticated');
+	const projectsTable = pgTable(
+		'projects',
+		{
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			owner: text('owner').notNull(),
+		},
+		(table) => [
+			crudPolicy({
+				role: authenticatedRole,
+				read: true,
+				modify: authUid(table.owner),
+			}),
+		],
+	);
+
+	const schema1 = {
+		authenticatedRole,
+		projectsTable,
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+
+	await db.query(`create schema auth;`);
+	await db.query(`create or replace function auth.user_id()
+RETURNS text
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RETURN 'some_user_id';
+END;
+$$;`);
+	const { sqlStatements: pst1 } = await push({
+		db,
+		to: schema1,
+		schemas: ['public'],
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+	const expectedSt1 = [
+		'CREATE ROLE "authenticated";',
+		'CREATE TABLE "projects" (\n\t"id" integer PRIMARY KEY,\n\t"name" text NOT NULL,\n\t"owner" text NOT NULL\n);\n',
+		'ALTER TABLE "projects" ENABLE ROW LEVEL SECURITY;',
+		'CREATE POLICY "crud-authenticated-policy-select" ON "projects" AS PERMISSIVE FOR SELECT TO "authenticated" USING (true);',
+		'CREATE POLICY "crud-authenticated-policy-insert" ON "projects" AS PERMISSIVE FOR INSERT TO "authenticated" WITH CHECK ((select auth.user_id() = "projects"."owner"));',
+		'CREATE POLICY "crud-authenticated-policy-update" ON "projects" AS PERMISSIVE FOR UPDATE TO "authenticated" USING ((select auth.user_id() = "projects"."owner")) WITH CHECK ((select auth.user_id() = "projects"."owner"));',
+		'CREATE POLICY "crud-authenticated-policy-delete" ON "projects" AS PERMISSIVE FOR DELETE TO "authenticated" USING ((select auth.user_id() = "projects"."owner"));',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema1, []);
+
+	const { sqlStatements: pst2 } = await push({
+		db,
+		to: schema1,
+		schemas: ['public'],
+		entities: { roles: { include: [authenticatedRole.name] } },
+	});
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pg-role.test.ts b/drizzle-kit/tests/postgres/pg-role.test.ts
new file mode 100644
index 0000000000..93ecc325a5
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-role.test.ts
@@ -0,0 +1,244 @@
+import { pgRole } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from '../postgres/mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create role', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: pgRole('manager'),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'CREATE ROLE "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create role with properties', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: pgRole('manager', {
+			createDb: true,
+			createRole: true,
+			inherit: false,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		`CREATE ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create role with some properties', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		manager: pgRole('manager', { createDb: true, inherit: false }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'CREATE ROLE "manager" WITH CREATEDB NOINHERIT;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop role', async (t) => {
+	const schema1 = { manager: pgRole('manager') };
+
+	const schema2 = {};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'DROP ROLE "manager";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create and drop role', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		admin: pgRole('admin'),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager', 'admin'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager', 'admin'] } },
+	});
+
+	const st0 = [
+		'DROP ROLE "manager";',
+		'CREATE ROLE "admin";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename role', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		admin: pgRole('admin'),
+	};
+
+	const renames = ['manager->admin'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager', 'admin'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		renames,
+		entities: { roles: { include: ['manager', 'admin'] } },
+	});
+
+	const st0 = [
+		'ALTER ROLE "manager" RENAME TO "admin";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter all role field', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		manager: pgRole('manager', {
+			createDb: true,
+			createRole: true,
+			inherit: false,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		`ALTER ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter createdb in role', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		manager: pgRole('manager', { createDb: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH CREATEDB;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter createrole in role', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		manager: pgRole('manager', { createRole: true }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({ db, to: schema2, entities: { roles: { include: ['manager'] } } });
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH CREATEROLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter inherit in role', async (t) => {
+	const schema1 = {
+		manager: pgRole('manager'),
+	};
+
+	const schema2 = {
+		manager: pgRole('manager', { inherit: false }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1, entities: { roles: { include: ['manager'] } } });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+		entities: { roles: { include: ['manager'] } },
+	});
+
+	const st0 = [
+		'ALTER ROLE "manager" WITH NOINHERIT;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/postgres/pg-schemas.test.ts b/drizzle-kit/tests/postgres/pg-schemas.test.ts
new file mode 100644
index 0000000000..15b385baf5
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-schemas.test.ts
@@ -0,0 +1,160 @@
+import { pgSchema } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add schema #1', async () => {
+	const to = {
+		devSchema: pgSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "dev";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add schema #2', async () => {
+	const from = {
+		devSchema: pgSchema('dev'),
+	};
+	const to = {
+		devSchema: pgSchema('dev'),
+		devSchema2: pgSchema('dev2'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #1', async () => {
+	const from = {
+		devSchema: pgSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		'DROP SCHEMA "dev";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('delete schema #2', async () => {
+	const from = {
+		devSchema: pgSchema('dev'),
+		devSchema2: pgSchema('dev2'),
+	};
+	const to = {
+		devSchema: pgSchema('dev'),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SCHEMA "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename schema #1', async () => {
+	const from = {
+		devSchema: pgSchema('dev'),
+	};
+
+	const to = {
+		devSchema2: pgSchema('dev2'),
+	};
+
+	const renames = ['dev->dev2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "dev" RENAME TO "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename schema #2', async () => {
+	const from = {
+		devSchema: pgSchema('dev'),
+		devSchema1: pgSchema('dev1'),
+	};
+	const to = {
+		devSchema: pgSchema('dev'),
+		devSchema2: pgSchema('dev2'),
+	};
+
+	const renames = ['dev1->dev2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "dev1" RENAME TO "dev2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/postgres/pg-sequences.test.ts b/drizzle-kit/tests/postgres/pg-sequences.test.ts
new file mode 100644
index 0000000000..75d086e023
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-sequences.test.ts
@@ -0,0 +1,448 @@
+import { pgSchema, pgSequence } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create sequence', async () => {
+	const to = {
+		seq: pgSequence('name', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SEQUENCE "public"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create sequence: all fields', async () => {
+	const from = {};
+	const to = {
+		seq: pgSequence('name', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SEQUENCE "public"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create sequence: custom schema', async () => {
+	const customSchema = pgSchema('custom');
+	const from = { customSchema };
+	const to = {
+		customSchema,
+		seq: customSchema.sequence('name', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE SEQUENCE "custom"."name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 100 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create sequence: custom schema + all fields', async () => {
+	const customSchema = pgSchema('custom');
+	const from = { customSchema };
+	const to = {
+		customSchema,
+		seq: customSchema.sequence('name', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE SEQUENCE "custom"."name" INCREMENT BY 2 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop sequence', async () => {
+	const from = { seq: pgSequence('name', { startWith: 100 }) };
+	const to = {};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SEQUENCE "public"."name";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop sequence: custom schema', async () => {
+	const customSchema = pgSchema('custom');
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'DROP SEQUENCE "custom"."name";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// rename sequence
+
+test('rename sequence', async () => {
+	const from = { seq: pgSequence('name', { startWith: 100 }) };
+	const to = { seq: pgSequence('name_new', { startWith: 100 }) };
+
+	const renames = [
+		'public.name->public.name_new',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" RENAME TO "name_new";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename sequence in custom schema', async () => {
+	const customSchema = pgSchema('custom');
+
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: customSchema.sequence('name_new', { startWith: 100 }) };
+
+	const renames = [
+		'custom.name->custom.name_new',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "custom"."name" RENAME TO "name_new";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('move sequence between schemas #1', async () => {
+	const customSchema = pgSchema('custom');
+	const from = { customSchema, seq: pgSequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+
+	const renames = [
+		'public.name->custom.name',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" SET SCHEMA "custom";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('move sequence between schemas #2', async () => {
+	const customSchema = pgSchema('custom');
+	const from = { customSchema, seq: customSchema.sequence('name', { startWith: 100 }) };
+	const to = { customSchema, seq: pgSequence('name', { startWith: 100 }) };
+
+	const renames = [
+		'custom.name->public.name',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "custom"."name" SET SCHEMA "public";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// Add squasher for sequences to make alters work +
+// Run all tests +
+// Finish introspect for sequences +
+// Check push for sequences +
+
+// add tests for generated to postgresql +
+// add tests for generated to mysql +
+// add tests for generated to sqlite +
+
+// add tests for identity to postgresql
+
+// check introspect generated(all dialects) +
+// check push generated(all dialect) +
+
+// add introspect ts file logic for all the features
+// manually test everything
+// beta release
+
+test('alter sequence', async () => {
+	const from = { seq: pgSequence('name', { startWith: 100 }) };
+	const to = { seq: pgSequence('name', { startWith: 105 }) };
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER SEQUENCE "name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 105 CACHE 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('full sequence: no changes', async () => {
+	const schema1 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('basic sequence: change fields', async () => {
+	const schema1 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 100000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 4,
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" INCREMENT BY 4 MINVALUE 100 MAXVALUE 100000 START WITH 100 CACHE 10 CYCLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('basic sequence: change name', async () => {
+	const schema1 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: pgSequence('my_seq2', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const renames = ['public.my_seq->public.my_seq2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" RENAME TO "my_seq2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('basic sequence: change name and fields', async () => {
+	const schema1 = {
+		seq: pgSequence('my_seq', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 2,
+		}),
+	};
+
+	const schema2 = {
+		seq: pgSequence('my_seq2', {
+			startWith: 100,
+			maxValue: 10000,
+			minValue: 100,
+			cycle: true,
+			cache: 10,
+			increment: 4,
+		}),
+	};
+
+	const renames = ['public.my_seq->public.my_seq2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER SEQUENCE "my_seq" RENAME TO "my_seq2";',
+		'ALTER SEQUENCE "my_seq2" INCREMENT BY 4 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('Add basic sequences', async () => {
+	const schema1 = {
+		seq: pgSequence('my_seq', { startWith: 100 }),
+	};
+
+	const schema2 = {
+		seq: pgSequence('my_seq', { startWith: 100 }),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/postgres/pg-snapshot-v7.test.ts b/drizzle-kit/tests/postgres/pg-snapshot-v7.test.ts
new file mode 100644
index 0000000000..94969bcf86
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-snapshot-v7.test.ts
@@ -0,0 +1,71 @@
+import { readFileSync } from 'fs';
+import { fromEntities } from 'src/dialects/postgres/ddl';
+import { upToV8 } from 'src/dialects/postgres/versions';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffSnapshotV7, prepareTestDatabase, TestDatabase } from './mocks';
+import * as s01 from './snapshots/schema01';
+import * as s01new from './snapshots/schema01new';
+import * as s02 from './snapshots/schema02';
+import * as s02new from './snapshots/schema02new';
+import * as s03 from './snapshots/schema03';
+import * as s03new from './snapshots/schema03new';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('s01', async (t) => {
+	const res = await diffSnapshotV7(db, s01new, s01);
+	expect(res.all).toStrictEqual([]);
+});
+
+test('s02', async (t) => {
+	const res = await diffSnapshotV7(db, s02new, s02);
+	expect(res.all).toStrictEqual([]);
+});
+
+test('s03', async (t) => {
+	const res = await diffSnapshotV7(db, s03new, s03);
+	expect(res.all).toStrictEqual([]);
+});
+
+// Snapshot was generated on drizzle-kit@0.23.2 version. This already generated v7 snapshot, but still it lacked of "roles", "policies", "checks", "views" in v7
+//
+// this is pretty simple schema
+/**
+ * export const users = pgTable('users', {
+ * 	id: serial("id").primaryKey(),
+ * 	name: text("name").notNull(),
+ * 	email: text("email").notNull().unique(),
+ * 	password: text("password").notNull(),
+ * 	avatar: text("avatar"),
+ * 	createdAt: timestamp("createdAt").notNull().defaultNow(),
+ * })
+ */
+// https://github.com/drizzle-team/drizzle-orm/issues/5099
+test('s05. drizzle-kit@0.23.2', async (t) => {
+	const snapshotV7 = JSON.parse(readFileSync('tests/postgres/snapshots/snapshot05-0.23.2.json', 'utf-8'));
+
+	expect(() => upToV8(snapshotV7)).not.toThrowError();
+
+	const { snapshot, hints } = upToV8(snapshotV7);
+	const ddl = fromEntities(snapshot.ddl);
+
+	expect(ddl.roles.list()).toStrictEqual([]);
+	expect(ddl.policies.list()).toStrictEqual([]);
+	expect(ddl.checks.list()).toStrictEqual([]);
+	expect(ddl.views.list()).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pg-tables.test.ts b/drizzle-kit/tests/postgres/pg-tables.test.ts
new file mode 100644
index 0000000000..8a53a59586
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-tables.test.ts
@@ -0,0 +1,1570 @@
+import type { PGlite } from '@electric-sql/pglite';
+import { aliasedTable, SQL, sql } from 'drizzle-orm';
+import {
+	camelCase,
+	foreignKey,
+	geometry,
+	index,
+	integer,
+	pgSchema,
+	pgTable,
+	pgTableCreator,
+	primaryKey,
+	serial,
+	snakeCase,
+	text,
+	unique,
+	uniqueIndex,
+	vector,
+} from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+fs.mkdirSync('./tests/postgres/migrations', { recursive: true });
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+let client: TestDatabase<PGlite>['client'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase(false); // due to migrate function from orm in tests
+	db = _.db;
+	client = _.client;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('add table #1', async () => {
+	const to = {
+		users: pgTable('users', {}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #2', async () => {
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" serial PRIMARY KEY\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #3', async () => {
+	const to = {
+		users: pgTable('users', {
+			id: serial('id'),
+		}, (t) => [primaryKey({ name: 'users_pk', columns: [t.id] })]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n'
+		+ '\t"id" serial,\n'
+		+ '\tCONSTRAINT "users_pk" PRIMARY KEY("id")\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #4', async () => {
+	const to = {
+		users: pgTable('users', { id: integer() }),
+		posts: pgTable('posts', { id: integer() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" integer\n);\n',
+		'CREATE TABLE "posts" (\n\t"id" integer\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #5', async () => {
+	const schema = pgSchema('folder');
+	const from = {
+		schema,
+	};
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: integer(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "folder"."users" (\n\t"id" integer\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #6', async () => {
+	const from = {
+		users1: pgTable('users1', { id: integer() }),
+	};
+
+	const to = {
+		users2: pgTable('users2', { id: integer() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users2" (\n\t"id" integer\n);\n',
+		'DROP TABLE "users1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #7', async () => {
+	const from = {
+		users1: pgTable('users1', { id: integer() }),
+	};
+
+	const to = {
+		users: pgTable('users', { id: integer() }),
+		users2: pgTable('users2', { id: integer() }),
+	};
+
+	const renames = ['public.users1->public.users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"id" integer\n);\n',
+		'ALTER TABLE "users1" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #8: geometry types', async () => {
+	const to = {
+		users: pgTable('users', {
+			geom: geometry('geom', { type: 'point' }).notNull(),
+			geom1: geometry('geom1').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	// TODO: for now pglite does not support postgis extension, revise later https://github.com/electric-sql/pglite/issues/11
+	// const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"geom" geometry(point) NOT NULL,\n\t"geom1" geometry(point) NOT NULL\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	// expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline */
+test('add table #9', async () => {
+	const to = {
+		users: pgTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "users" (\n'
+		+ '\t"name" text UNIQUE\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline named */
+test('add table #10', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('name_unique'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "name_unique" UNIQUE\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline named nulls not distinct */
+test('add table #11', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('name_unique', { nulls: 'not distinct' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "name_unique" UNIQUE NULLS NOT DISTINCT\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique inline default-named nulls not distinct */
+test('add table #12', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('users', {
+			name: text().unique('users_name_key', { nulls: 'not distinct' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "users_name_key" UNIQUE NULLS NOT DISTINCT\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique default-named */
+test('add table #13', async () => {
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('users_name_key').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "users_name_key" UNIQUE\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique default-named nulls not distinct */
+test('add table #14', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('users_name_key').on(t.name).nullsNotDistinct()]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "users_name_key" UNIQUE NULLS NOT DISTINCT\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+/* unique */
+test('add table #15', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('users', {
+			name: text(),
+		}, (t) => [unique('name_unique').on(t.name).nullsNotDistinct()]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"name" text CONSTRAINT "name_unique" UNIQUE NULLS NOT DISTINCT\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5603
+test.skipIf(Date.now() < +new Date('2026-07-01'))('add table #16', async () => {
+	const users = pgTable('users', {
+		name: text(),
+	}, (t) => [index('name_idx').on(t.name)]);
+	const u = aliasedTable(users, 'u');
+	const to = {
+		users,
+		u,
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE TABLE "users" (\n\t"name" text\n);\n',
+		'CREATE INDEX "name_idx" ON "users" ("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('multiproject schema add table #1', async () => {
+	const table = pgTableCreator((name) => `prefix_${name}`);
+
+	const to = {
+		users: table('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "prefix_users" (\n\t"id" serial PRIMARY KEY\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('multiproject schema drop table #1', async () => {
+	const table = pgTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, {}, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: {},
+	});
+
+	const st0 = [
+		'DROP TABLE "prefix_users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('multiproject schema alter table name #1', async () => {
+	const table = pgTableCreator((name) => `prefix_${name}`);
+
+	const from = {
+		users: table('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		users1: table('users1', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const renames = [
+		'public.prefix_users->public.prefix_users1',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "prefix_users" RENAME TO "prefix_users1";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #8: column with pgvector', async () => {
+	const to = {
+		users2: pgTable('users2', {
+			id: serial('id').primaryKey(),
+			name: vector('name', { dimensions: 3 }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users2" (\n\t"id" serial PRIMARY KEY,\n\t"name" vector(3)\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add schema + table #1', async () => {
+	const schema = pgSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: integer(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder";\n',
+		'CREATE TABLE "folder"."users" (\n\t"id" integer\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4796
+test('add schema + table #2', async () => {
+	const schema = pgSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {
+			id: integer(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const schemas = ['folder'];
+	const { sqlStatements: pst } = await push({ db, to, schemas });
+
+	const st0 = [
+		'CREATE SCHEMA "folder";\n',
+		'CREATE TABLE "folder"."users" (\n\t"id" integer\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change schema with tables #1', async () => {
+	const schema = pgSchema('folder');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = ['folder->folder2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "folder" RENAME TO "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #1', async () => {
+	const schema = pgSchema('folder');
+	const from = {
+		schema,
+		users: pgTable('users', {}),
+	};
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const renames = [
+		'public.users->folder.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "users" SET SCHEMA "folder";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #2', async () => {
+	const schema = pgSchema('folder');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema,
+		users: pgTable('users', {}),
+	};
+
+	const renames = [
+		'folder.users->public.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "folder"."users" SET SCHEMA "public";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #3', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #4', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder2";\n',
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1, // remove schema
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'CREATE SCHEMA "folder2";\n',
+		'ALTER TABLE "folder1"."users" SET SCHEMA "folder2";\n',
+		'DROP SCHEMA "folder1";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users2', {}), // rename and move table
+	};
+
+	const renames = [
+		'folder1.users->folder2.users2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		'ALTER TABLE "folder1"."users" RENAME TO "users2";',
+		'ALTER TABLE "folder1"."users2" SET SCHEMA "folder2";\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change table schema #6', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // rename schema
+		users: schema2.table('users2', {}), // rename table
+	};
+
+	const renames = [
+		'folder1->folder2',
+		'folder2.users->folder2.users2',
+	];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		'ALTER SCHEMA "folder1" RENAME TO "folder2";\n',
+		'ALTER TABLE "folder2"."users" RENAME TO "users2";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop table + rename schema #1', async () => {
+	const schema1 = pgSchema('folder1');
+	const schema2 = pgSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // rename schema
+		// drop table
+	};
+
+	const renames = ['folder1->folder2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		'ALTER SCHEMA "folder1" RENAME TO "folder2";\n',
+		'DROP TABLE "folder2"."users";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop tables with fk constraint #1', async () => {
+	const table1 = pgTable('table1', {
+		column1: integer().primaryKey(),
+	});
+	const table2 = pgTable('table2', {
+		column1: integer().primaryKey(),
+		column2: integer().references(() => table1.column1),
+	});
+	const schema1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"column1" integer PRIMARY KEY\n);\n',
+		'CREATE TABLE "table2" (\n\t"column1" integer PRIMARY KEY,\n\t"column2" integer\n);\n',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_column2_table1_column1_fkey" FOREIGN KEY ("column2") REFERENCES "table1"("column1");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, {}, []);
+	const { sqlStatements: pst2 } = await push({ db, to: {} });
+
+	const expectedSt2 = [
+		'ALTER TABLE "table2" DROP CONSTRAINT "table2_column2_table1_column1_fkey";',
+		'DROP TABLE "table1";',
+		'DROP TABLE "table2";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4155
+test('drop tables with fk constraint #2', async () => {
+	const table1 = pgTable('table1', {
+		column1: integer().primaryKey(),
+	});
+	const table2 = pgTable('table2', {
+		column1: integer().primaryKey(),
+		column2: integer().references(() => table1.column1),
+	});
+	const schema1 = { table1, table2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"column1" integer PRIMARY KEY\n);\n',
+		'CREATE TABLE "table2" (\n\t"column1" integer PRIMARY KEY,\n\t"column2" integer\n);\n',
+		'ALTER TABLE "table2" ADD CONSTRAINT "table2_column2_table1_column1_fkey" FOREIGN KEY ("column2") REFERENCES "table1"("column1");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const table2_ = pgTable('table2', {
+		column1: integer().primaryKey(),
+		column2: integer(),
+	});
+
+	const schema2 = { table2_ };
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2 = [
+		'ALTER TABLE "table2" DROP CONSTRAINT "table2_column2_table1_column1_fkey";',
+		'DROP TABLE "table1";',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('create table with tsvector', async () => {
+	const from = {};
+	const to = {
+		users: pgTable('posts', {
+			id: serial('id').primaryKey(),
+			title: text('title').notNull(),
+			description: text('description').notNull(),
+		}, (table) => [
+			index('title_search_index').using('gin', sql`to_tsvector('english', ${table.title})`),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "posts" (\n\t"id" serial PRIMARY KEY,\n\t"title" text NOT NULL,\n\t"description" text NOT NULL\n);\n',
+		`CREATE INDEX "title_search_index" ON "posts" USING gin (to_tsvector('english', "title"));`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('composite primary key', async () => {
+	const from = {};
+	const to = {
+		table: pgTable('works_to_creators', {
+			workId: integer('work_id').notNull(),
+			creatorId: integer('creator_id').notNull(),
+			classification: text('classification').notNull(),
+		}, (t) => [
+			primaryKey({ columns: [t.workId, t.creatorId, t.classification] }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'CREATE TABLE "works_to_creators" (\n\t"work_id" integer,\n\t"creator_id" integer,\n\t"classification" text,\n\tCONSTRAINT "works_to_creators_pkey" PRIMARY KEY("work_id","creator_id","classification")\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column before creating unique constraint', async () => {
+	const from = {
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		table: pgTable('table', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		}, (t) => [unique('uq').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" ADD COLUMN "name" text NOT NULL;',
+		'ALTER TABLE "table" ADD CONSTRAINT "uq" UNIQUE("name");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter composite primary key', async () => {
+	const from = {
+		table: pgTable('table', {
+			col1: integer('col1').notNull(),
+			col2: integer('col2').notNull(),
+			col3: text('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col1, t.col2],
+			}),
+		]),
+	};
+	const to = {
+		table: pgTable('table', {
+			col1: integer('col1').notNull(),
+			col2: integer('col2').notNull(),
+			col3: text('col3').notNull(),
+		}, (t) => [
+			primaryKey({
+				name: 'table_pk',
+				columns: [t.col2, t.col3],
+			}),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'ALTER TABLE "table" DROP CONSTRAINT "table_pk";',
+		'ALTER TABLE "table" ADD CONSTRAINT "table_pk" PRIMARY KEY("col2","col3");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add index with op', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		}, (t) => [index().using('gin', t.name.op('gin_trgm_ops'))]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		'CREATE INDEX "users_name_index" ON "users" USING gin ("name" gin_trgm_ops);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4800
+test('optional db aliases (snake case)', async () => {
+	const from = {};
+
+	const t1 = snakeCase.table(
+		't1',
+		{
+			t1Id1: integer().notNull().primaryKey(),
+			t1Col2: integer().notNull(),
+			t1Col3: integer().notNull(),
+			t2Ref: integer().notNull().references(() => t2.t2Id),
+			t1Uni: integer().notNull(),
+			t1UniIdx: integer().notNull(),
+			t1Idx: integer().notNull(),
+			t1Uni1: integer().unique(),
+		},
+		(table) => [
+			unique('t1_uni').on(table.t1Uni),
+			uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
+			index('t1_idx').on(table.t1Idx).where(sql`${table.t1Idx} > 0`),
+			foreignKey({
+				columns: [table.t1Col2, table.t1Col3],
+				foreignColumns: [t3.t3Id1, t3.t3Id2],
+			}),
+		],
+	);
+
+	const t2 = snakeCase.table(
+		't2',
+		{
+			t2Id: serial().primaryKey(),
+		},
+	);
+
+	const t3 = snakeCase.table(
+		't3',
+		{
+			t3Id1: integer(),
+			t3Id2: integer(),
+		},
+		(table) => [primaryKey({ columns: [table.t3Id1, table.t3Id2] })],
+	);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st1 = `CREATE TABLE "t1" (
+	"t1_id1" integer PRIMARY KEY,
+	"t1_col2" integer NOT NULL,
+	"t1_col3" integer NOT NULL,
+	"t2_ref" integer NOT NULL,
+	"t1_uni" integer NOT NULL CONSTRAINT "t1_uni" UNIQUE,
+	"t1_uni_idx" integer NOT NULL,
+	"t1_idx" integer NOT NULL,
+	"t1_uni1" integer UNIQUE
+);
+`;
+
+	const st2 = `CREATE TABLE "t2" (
+	"t2_id" serial PRIMARY KEY
+);
+`;
+
+	const st3 = `CREATE TABLE "t3" (
+	"t3_id1" integer,
+	"t3_id2" integer,
+	CONSTRAINT "t3_pkey" PRIMARY KEY("t3_id1","t3_id2")
+);
+`;
+
+	const st4 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t2_ref_t2_t2_id_fkey" FOREIGN KEY ("t2_ref") REFERENCES "t2"("t2_id");`;
+	const st5 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fkey" FOREIGN KEY ("t1_col2","t1_col3") REFERENCES "t3"("t3_id1","t3_id2");`;
+
+	const st6 = `CREATE UNIQUE INDEX "t1_uni_idx" ON "t1" ("t1_uni_idx");`;
+
+	const st7 = `CREATE INDEX "t1_idx" ON "t1" ("t1_idx") WHERE "t1_idx" > 0;`;
+
+	const st0 = [st1, st2, st3, st6, st7, st4, st5];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4541
+test('create table (camel case -> snake case)', async () => {
+	const t1 = snakeCase.table('table_snake_case1', {
+		columnCamelCase1: integer(),
+		columnCamelCase2: integer(),
+		columnCamelCase3: integer(),
+	}, (t) => [
+		primaryKey({ columns: [t.columnCamelCase1, t.columnCamelCase2] }),
+		unique().on(t.columnCamelCase1, t.columnCamelCase3),
+		uniqueIndex().on(t.columnCamelCase2, t.columnCamelCase3),
+	]);
+
+	const to = { t1 };
+
+	const casing = 'snake_case';
+	const { sqlStatements: st1 } = await diff({}, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to });
+
+	const eSt1 = [
+		'CREATE TABLE "table_snake_case1" (\n'
+		+ '\t"column_camel_case1" integer,\n'
+		+ '\t"column_camel_case2" integer,\n'
+		+ '\t"column_camel_case3" integer,\n'
+		+ '\tCONSTRAINT "table_snake_case1_pkey" PRIMARY KEY("column_camel_case1","column_camel_case2"),\n'
+		+ '\tCONSTRAINT "table_snake_case1_column_camel_case1_column_camel_case3_unique" UNIQUE("column_camel_case1","column_camel_case3")\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX "table_snake_case1_column_camel_case2_column_camel_case3_index" ON "table_snake_case1" ("column_camel_case2","column_camel_case3");',
+	];
+	expect(st1).toStrictEqual(eSt1);
+	expect(pst1).toStrictEqual(eSt1);
+});
+
+test('create table (snake case -> camel case)', async () => {
+	const t1 = camelCase.table('tableCamelcase1', {
+		column_snake_case1: integer(),
+		column_snake_case2: integer(),
+		column_snake_case3: integer(),
+	}, (t) => [
+		primaryKey({ columns: [t.column_snake_case1, t.column_snake_case2] }),
+		unique().on(t.column_snake_case1, t.column_snake_case3),
+		uniqueIndex().on(t.column_snake_case2, t.column_snake_case3),
+	]);
+
+	const to = { t1 };
+
+	const { sqlStatements: st1 } = await diff({}, to, []);
+	const { sqlStatements: pst1 } = await push({ db, to });
+
+	const eSt1 = [
+		'CREATE TABLE "tableCamelcase1" (\n'
+		+ '\t"columnSnakeCase1" integer,\n'
+		+ '\t"columnSnakeCase2" integer,\n'
+		+ '\t"columnSnakeCase3" integer,\n'
+		+ '\tCONSTRAINT "tableCamelcase1_pkey" PRIMARY KEY("columnSnakeCase1","columnSnakeCase2"),\n'
+		+ '\tCONSTRAINT "tableCamelcase1_columnSnakeCase1_columnSnakeCase3_unique" UNIQUE("columnSnakeCase1","columnSnakeCase3")\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX "tableCamelcase1_columnSnakeCase2_columnSnakeCase3_index" ON "tableCamelcase1" ("columnSnakeCase2","columnSnakeCase3");',
+	];
+	expect(st1).toStrictEqual(eSt1);
+	expect(pst1).toStrictEqual(eSt1);
+});
+
+test('optional db aliases (camel case)', async () => {
+	const from = {};
+
+	const t1 = camelCase.table('t1', {
+		t1_id1: integer().notNull().primaryKey(),
+		t1_col2: integer().notNull(),
+		t1_col3: integer().notNull(),
+		t2_ref: integer().notNull().references(() => t2.t2_id),
+		t1_uni: integer().notNull(),
+		t1_uni_idx: integer().notNull(),
+		t1_idx: integer().notNull(),
+	}, (table) => [
+		unique('t1Uni').on(table.t1_uni),
+		uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
+		index('t1Idx').on(table.t1_idx).where(sql`${table.t1_idx} > 0`),
+		foreignKey({
+			columns: [table.t1_col2, table.t1_col3],
+			foreignColumns: [t3.t3_id1, t3.t3_id2],
+		}),
+	]);
+
+	const t2 = camelCase.table('t2', {
+		t2_id: serial().primaryKey(),
+	});
+
+	const t3 = camelCase.table('t3', {
+		t3_id1: integer(),
+		t3_id2: integer(),
+	}, (table) => [primaryKey({ columns: [table.t3_id1, table.t3_id2] })]);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st1 = `CREATE TABLE "t1" (
+	"t1Id1" integer PRIMARY KEY,
+	"t1Col2" integer NOT NULL,
+	"t1Col3" integer NOT NULL,
+	"t2Ref" integer NOT NULL,
+	"t1Uni" integer NOT NULL CONSTRAINT "t1Uni" UNIQUE,
+	"t1UniIdx" integer NOT NULL,
+	"t1Idx" integer NOT NULL
+);
+`;
+
+	const st2 = `CREATE TABLE "t2" (
+	"t2Id" serial PRIMARY KEY
+);
+`;
+
+	const st3 = `CREATE TABLE "t3" (
+	"t3Id1" integer,
+	"t3Id2" integer,
+	CONSTRAINT "t3_pkey" PRIMARY KEY("t3Id1","t3Id2")
+);
+`;
+
+	const st4 = `ALTER TABLE "t1" ADD CONSTRAINT "t1_t2Ref_t2_t2Id_fkey" FOREIGN KEY ("t2Ref") REFERENCES "t2"("t2Id");`;
+	const st5 =
+		`ALTER TABLE "t1" ADD CONSTRAINT "t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fkey" FOREIGN KEY ("t1Col2","t1Col3") REFERENCES "t3"("t3Id1","t3Id2");`;
+	const st6 = `CREATE UNIQUE INDEX "t1UniIdx" ON "t1" ("t1UniIdx");`;
+	const st7 = `CREATE INDEX "t1Idx" ON "t1" ("t1Idx") WHERE "t1Idx" > 0;`;
+
+	const st0 = [st1, st2, st3, st6, st7, st4, st5];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with generated column', async () => {
+	const schema1 = {};
+	const schema2 = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE "users" (\n\t"id" integer,\n\t"id2" integer,\n\t"name" text,\n\t"gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table with composite primary key', async () => {
+	const schema1 = {
+		table: pgTable('table1', {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => [primaryKey({ columns: [t.productId, t.categoryId] })]),
+	};
+	const schema2 = {
+		test: pgTable('table2', {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => [primaryKey({ columns: [t.productId, t.categoryId] })]),
+	};
+
+	const renames = ['public.table1->public.table2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = ['ALTER TABLE "table1" RENAME TO "table2";'];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table and enable rls', async () => {
+	const schema1 = {
+		table: pgTable('table1', {
+			id: text().primaryKey(),
+		}),
+	};
+	const schema2 = {
+		table: pgTable.withRLS('table2', {
+			id: text().primaryKey(),
+		}),
+	};
+
+	const renames = ['public.table1->public.table2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	const st0: string[] = ['ALTER TABLE "table1" RENAME TO "table2";', 'ALTER TABLE "table2" ENABLE ROW LEVEL SECURITY;'];
+
+	expect(st).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4838
+test('rename 2 tables', async () => {
+	const schema1 = {
+		table1: pgTable('table1', {
+			id: text().primaryKey(),
+		}),
+		table2: pgTable('table2', {
+			id: text().primaryKey(),
+		}),
+	};
+	const schema2 = {
+		table3: pgTable('table3', {
+			id: text().primaryKey(),
+		}),
+		table4: pgTable('table4', {
+			id: text().primaryKey(),
+		}),
+	};
+
+	const renames = ['public.table1->public.table3', 'public.table2->public.table4'];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE "table1" RENAME TO "table3";',
+		'ALTER TABLE "table2" RENAME TO "table4";',
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('push after migrate with custom migrations table #1', async () => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/pglite/migrator');
+	const { drizzle } = await import('drizzle-orm/pglite');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/postgres/migrations',
+	});
+
+	const to = {
+		table: pgTable('table1', { col1: integer() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #2', async () => {
+	const migrationsConfig = {
+		schema: undefined,
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/pglite/migrator');
+	const { drizzle } = await import('drizzle-orm/pglite');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/postgres/migrations',
+	});
+
+	const to = {
+		table: pgTable('table1', { col1: integer() }),
+	};
+	const { sqlStatements: st2 } = await diff({}, to, []);
+
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #3', async () => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/pglite/migrator');
+	const { drizzle } = await import('drizzle-orm/pglite');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/postgres/migrations',
+	});
+
+	const to = {
+		table: pgTable('table1', { col1: integer() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #4', async () => {
+	const migrationsConfig = {
+		schema: 'migrations_schema',
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/pglite/migrator');
+	const { drizzle } = await import('drizzle-orm/pglite');
+	await migrate(drizzle({ client }), {
+		migrationsSchema: migrationsConfig.schema,
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/postgres/migrations',
+	});
+
+	const to = {
+		table: pgTable('table1', { col1: integer() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5190
+test('push with pscale_extensions schema', async () => {
+	await db.query(`CREATE SCHEMA pscale_extensions`);
+	const schema1 = {
+		table1: pgTable('table1', {
+			id: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: pst2 } = await push({ db, to: schema1 });
+
+	const expectedSt2: string[] = [`CREATE TABLE "table1" (\n\t"id" text PRIMARY KEY\n);\n`];
+
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5329
+test(
+	'push empty schema with `schemaFilter` set to `["public"]`',
+	async () => {
+		await db.query(`CREATE SCHEMA "cron";`);
+		await db.query(`CREATE TABLE "cron"."job" (id integer, type text);`);
+		await db.query(`CREATE POLICY "test" ON "cron"."job" AS PERMISSIVE FOR ALL TO public;`);
+
+		const { sqlStatements: pst2 } = await push({
+			db,
+			to: {},
+			schemas: ['public'],
+		});
+
+		const expectedSt2: string[] = [];
+
+		expect(pst2).toStrictEqual(expectedSt2);
+	},
+);
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4838
+test('rename table with identity column', async () => {
+	const from = {
+		Hello: pgTable('hello', {
+			id: integer().primaryKey().generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const to = {
+		Hello: pgTable('hello2', {
+			id: integer().primaryKey().generatedAlwaysAsIdentity(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, [`public.hello->public.hello2`]);
+
+	await push({ db, to: from, schemas: [] });
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		schemas: [],
+		renames: [`public.hello->public.hello2`],
+	});
+
+	const expectedSt: string[] = ['ALTER TABLE "hello" RENAME TO "hello2";'];
+
+	expect(st).toStrictEqual(expectedSt);
+	expect(pst).toStrictEqual(expectedSt);
+});
diff --git a/drizzle-kit/tests/postgres/pg-views.test.ts b/drizzle-kit/tests/postgres/pg-views.test.ts
new file mode 100644
index 0000000000..282fdeefd7
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pg-views.test.ts
@@ -0,0 +1,2329 @@
+import { and, eq, gt, or, sql } from 'drizzle-orm';
+import {
+	camelCase,
+	integer,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	snakeCase,
+	text,
+} from 'drizzle-orm/pg-core';
+import { generate } from 'src/cli/schema';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create view', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE VIEW "view" AS (select distinct "id" from "test");',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: pgView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view" AS (select "id" from "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #2', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view" AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #3', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgView('some_view1', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: false,
+			securityInvoker: true,
+		}).as(sql`SELECT * FROM ${users}`),
+		view2: pgView('some_view2').with({
+			checkOption: 'cascaded',
+			securityBarrier: true,
+			securityInvoker: false,
+		}).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view1" WITH (check_option = local, security_barrier = false, security_invoker = true) AS (SELECT * FROM "users");`,
+		`CREATE VIEW "some_view2" WITH (check_option = cascaded, security_barrier = true, security_invoker = false) AS (select "id" from "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #4', async () => {
+	const schema = pgSchema('new_schema');
+
+	const users = schema.table('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		schema,
+		users: users,
+		view1: schema.view('some_view1', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: false,
+			securityInvoker: true,
+		}).as(sql`SELECT * FROM ${users}`),
+		view2: schema.view('some_view2').with({
+			checkOption: 'cascaded',
+			securityBarrier: true,
+			securityInvoker: false,
+		}).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+		`CREATE TABLE "new_schema"."users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE VIEW "new_schema"."some_view1" WITH (check_option = local, security_barrier = false, security_invoker = true) AS (SELECT * FROM "new_schema"."users");`,
+		`CREATE VIEW "new_schema"."some_view2" WITH (check_option = cascaded, security_barrier = true, security_invoker = false) AS (select "id" from "new_schema"."users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and view #5', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	// view_name_duplicate
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test('create table and view #6', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgView('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE VIEW "some_view" WITH (check_option = cascaded) AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+	};
+
+	const to = {
+		users: users,
+		view1: pgView('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create materialized view', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgMaterializedView('view')
+			.withNoData()
+			.using('drizzle_heap')
+			.as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'CREATE MATERIALIZED VIEW "view" USING "drizzle_heap" AS (select distinct "id" from "test") WITH NO DATA;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view" AS (select "id" from "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and materialized view #2', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view" AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and materialized view #3', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgMaterializedView('some_view1', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: pgMaterializedView('some_view2').tablespace('pg_default').using('drizzle_heap').withNoData().with({
+			autovacuumEnabled: true,
+			autovacuumFreezeMaxAge: 1000000,
+			autovacuumFreezeMinAge: 1000000,
+			autovacuumFreezeTableAge: 1,
+			autovacuumMultixactFreezeMaxAge: 1000000,
+			autovacuumMultixactFreezeMinAge: 1000000,
+			autovacuumMultixactFreezeTableAge: 1000000,
+			autovacuumVacuumCostDelay: 1,
+			autovacuumVacuumCostLimit: 1,
+			autovacuumVacuumScaleFactor: 1,
+			autovacuumVacuumThreshold: 1,
+			fillfactor: 10,
+			logAutovacuumMinDuration: 1,
+			parallelWorkers: 1,
+			toastTupleTarget: 128,
+			userCatalogTable: true,
+			vacuumIndexCleanup: 'off',
+			vacuumTruncate: false,
+		}).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view1" AS (SELECT * FROM "users");`,
+		`CREATE MATERIALIZED VIEW "some_view2" USING "drizzle_heap" WITH (autovacuum_enabled = true, autovacuum_freeze_max_age = 1000000, autovacuum_freeze_min_age = 1000000, autovacuum_freeze_table_age = 1, autovacuum_multixact_freeze_max_age = 1000000, autovacuum_multixact_freeze_min_age = 1000000, autovacuum_multixact_freeze_table_age = 1000000, autovacuum_vacuum_cost_delay = 1, autovacuum_vacuum_cost_limit = 1, autovacuum_vacuum_scale_factor = 1, autovacuum_vacuum_threshold = 1, fillfactor = 10, log_autovacuum_min_duration = 1, parallel_workers = 1, toast_tuple_target = 128, user_catalog_table = true, vacuum_index_cleanup = off, vacuum_truncate = false) TABLESPACE pg_default AS (select "id" from "users") WITH NO DATA;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table and materialized view #4', async () => {
+	// same names
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+		view2: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	// view_name_duplicate
+	await expect(diff({}, to, [])).rejects.toThrow();
+	await expect(push({ db, to })).rejects.toThrow();
+});
+
+test('create table and materialized view #5', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+	const to = {
+		users: users,
+		view1: pgMaterializedView('some_view', { id: integer('id') }).with({ autovacuumFreezeMinAge: 14 }).as(
+			sql`SELECT * FROM ${users}`,
+		),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY\n);\n`,
+		`CREATE MATERIALIZED VIEW "some_view" WITH (autovacuum_freeze_min_age = 14) AS (SELECT * FROM "users");`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create materialized view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+	};
+
+	const to = {
+		users: users,
+		view1: pgMaterializedView('some_view', { id: integer('id') }).with({ autovacuumEnabled: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP VIEW "some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #2', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'DROP VIEW "view";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view with data', async () => {
+	const table = pgTable('table', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const seedStatements = [`INSERT INTO "table" ("id") VALUES (1), (2), (3)`];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({
+		db,
+		to: schema2,
+	});
+
+	// seeding
+	for (const seedSt of seedStatements) {
+		await db.query(seedSt);
+	}
+
+	const st0: string[] = [
+		`DROP VIEW "view";`,
+	];
+	const hints0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('drop materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM ${users}`),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`DROP MATERIALIZED VIEW "some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop materialized view #2', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		'DROP MATERIALIZED VIEW "view";',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop materialized view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		users: users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop materialized view with data', async () => {
+	const table = pgTable('table', {
+		id: serial('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.query(`INSERT INTO "table" ("id") VALUES (1), (2), (3)`);
+
+	const { sqlStatements: pst, hints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		`DROP MATERIALIZED VIEW "view";`,
+	];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(hints).toStrictEqual([]);
+});
+
+test('drop materialized view without data', async () => {
+	const table = pgTable('table', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		`DROP MATERIALIZED VIEW "view";`,
+	];
+	const hints0: string[] = [];
+
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('rename view #1', async () => {
+	const from = {
+		users: pgTable('users', { id: serial() }),
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		users: pgTable('users', { id: serial() }),
+		view: pgView('new_some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER VIEW "some_view" RENAME TO "new_some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view with existing flag', async () => {
+	const from = {
+		view: pgView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		view: pgView('new_some_view', { id: integer('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename materialized view #1', async () => {
+	const from = {
+		users: pgTable('users', { id: serial() }),
+		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		users: pgTable('users', { id: serial() }),
+		view: pgMaterializedView('new_some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`ALTER MATERIALIZED VIEW "some_view" RENAME TO "new_some_view";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename materialized view with existing flag', async () => {
+	const from = {
+		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		view: pgMaterializedView('new_some_view', { id: integer('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view alter schema', async () => {
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		users: pgTable('users', { id: serial() }),
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: pgTable('users', { id: serial() }),
+		view: schema.view('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+		`ALTER VIEW "some_view" SET SCHEMA "new_schema";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view alter schema with existing flag', async () => {
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		view: pgView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		schema,
+		view: schema.view('some_view', { id: integer('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view alter schema for materialized', async () => {
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		users: pgTable('users', { id: serial() }),
+		view: pgMaterializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: pgTable('users', { id: serial() }),
+		view: schema.materializedView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+		`ALTER MATERIALIZED VIEW "some_view" SET SCHEMA "new_schema";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('view alter schema for materialized with existing flag', async () => {
+	const schema = pgSchema('new_schema');
+
+	const from = {
+		view: pgMaterializedView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const to = {
+		schema,
+		view: schema.materializedView('some_view', { id: integer('id') }).existing(),
+	};
+
+	const renames = ['public.some_view->new_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0 = [
+		`CREATE SCHEMA "new_schema";\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER VIEW "some_view" SET (check_option = cascaded, security_barrier = true);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', {}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view', {}).with({ checkOption: 'cascaded', securityBarrier: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumMultixactFreezeMaxAge: 1_000_000 }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER MATERIALIZED VIEW "some_view" SET (autovacuum_multixact_freeze_max_age = 1000000);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to materialized view #1_2', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view').tablespace('pg_default').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER MATERIALIZED VIEW "some_view" SET TABLESPACE \"pg_default\";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]);
+});
+
+test('add with options for materialized view #2', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgMaterializedView('view')
+			.with({ autovacuumFreezeTableAge: 1, autovacuumEnabled: false })
+			.as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "view" SET (autovacuum_enabled = false, autovacuum_freeze_table_age = 1);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with options for materialized view #3', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgMaterializedView('view')
+			.with({ autovacuumVacuumCostDelay: 100, vacuumTruncate: false })
+			.as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "view" SET (autovacuum_vacuum_cost_delay = 100, vacuum_truncate = false);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with option to materialized view with existing flag #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', {}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', {}).with({ autovacuumMultixactFreezeMaxAge: 3 }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add with options to materialized view with existing flag #2', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view', {}).as(sql`SELECT id FROM "test"`),
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgMaterializedView('view', {}).with({ autovacuumVacuumCostDelay: 100, vacuumTruncate: false }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({
+		db,
+		to: schema2,
+	});
+
+	expect(st).toStrictEqual(['DROP MATERIALIZED VIEW "view";']);
+	expect(pst).toStrictEqual([]);
+});
+
+test('drop with option from view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`ALTER VIEW "some_view" RESET (check_option, security_barrier, security_invoker);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop with option from view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', {}).with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true })
+			.existing(),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view', {}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop with option from materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, autovacuumFreezeMaxAge: 1_000_000 }).as((
+			qb,
+		) => qb.select().from(users)),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view').as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0 = [
+		`ALTER MATERIALIZED VIEW "some_view" RESET (autovacuum_enabled, autovacuum_freeze_max_age);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop with option from materialized view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true, autovacuumFreezeMaxAge: 10 }).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', {}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view').with({ securityBarrier: true, securityInvoker: true }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view').with({ securityBarrier: true }).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER VIEW "some_view" RESET (security_invoker);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', {}).with({ securityBarrier: true, securityInvoker: true }).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view', {}).with({ securityBarrier: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, autovacuumVacuumScaleFactor: 1 }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true }).as((qb) => qb.select().from(users)),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" RESET (autovacuum_vacuum_scale_factor);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in materialized view with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true, autovacuumVacuumScaleFactor: 1 })
+			.existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', {}).with({ autovacuumEnabled: true }).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in view #2', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view').with({ checkOption: 'local', securityBarrier: true, securityInvoker: true }).as((qb) =>
+			qb.select().from(users).where(gt(users.id, 10))
+		),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view').with({ checkOption: 'cascaded', securityBarrier: true, securityInvoker: true }).as((qb) =>
+			qb.select().from(users).where(gt(users.id, 10))
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER VIEW "some_view" SET (check_option = cascaded);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter with option in materialized view #2', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumEnabled: true, fillfactor: 10 }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view').with({ autovacuumEnabled: false, fillfactor: 10 }).as((qb) =>
+			qb.select().from(users)
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET (autovacuum_enabled = false);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter view ".as" value', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: true,
+			securityInvoker: true,
+		}).as(sql`select * from users where id > 100`),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: true,
+			securityInvoker: true,
+		}).as(sql`select * from users where id > 101`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		'DROP VIEW "some_view";',
+		`CREATE VIEW "some_view" WITH (check_option = local, security_barrier = true, security_invoker = true) AS (select * from users where id > 101);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // push ignored definition change
+});
+
+test('alter view ".as" value with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: true,
+			securityInvoker: true,
+		}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).with({
+			checkOption: 'local',
+			securityBarrier: true,
+			securityInvoker: true,
+		}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter materialized view ".as" value', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT '123'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT '1234'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		'DROP MATERIALIZED VIEW "some_view";',
+		`CREATE MATERIALIZED VIEW "some_view" WITH (autovacuum_vacuum_cost_limit = 1) AS (SELECT '1234');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // we ignore definition changes for push
+});
+
+test('alter materialized view ".as" value with existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).existing(),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop existing flag', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`CREATE MATERIALIZED VIEW "some_view" WITH (autovacuum_vacuum_cost_limit = 1) AS (SELECT 'asd');`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter tablespace - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET TABLESPACE "pg_default";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // commutative
+});
+
+test('set tablespace - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET TABLESPACE "pg_default";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // commutative
+});
+
+test('drop tablespace - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 1`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 1`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET TABLESPACE "pg_default";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // commutative
+});
+
+test('set existing - materialized', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('new_some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+			autovacuumFreezeMinAge: 1,
+		}).withNoData().existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames,
+	});
+
+	const st0: string[] = ['DROP MATERIALIZED VIEW "some_view";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop existing - materialized', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('view', { id: integer('id') }).tablespace('pg_default').with({
+			autovacuumVacuumCostLimit: 1,
+		}).existing(),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+			autovacuumFreezeMinAge: 1,
+		}).withNoData().as(sql`SELECT * FROM users WHERE id > 100`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE MATERIALIZED VIEW "view" WITH (autovacuum_freeze_min_age = 1, autovacuum_vacuum_cost_limit = 1) AS (SELECT * FROM users WHERE id > 100) WITH NO DATA;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('set existing', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgView('some_view', { id: integer('id') }).with({
+			checkOption: 'cascaded',
+		}).as(sql`SELECT * from users where id > 100`),
+	};
+
+	const to = {
+		users,
+		view: pgView('new_some_view', { id: integer('id') }).with({
+			checkOption: 'cascaded',
+			securityBarrier: true,
+		}).existing(),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['DROP VIEW "some_view";'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter using - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').using('heap').with(
+			{
+				autovacuumVacuumCostLimit: 1,
+			},
+		).as(sql`SELECT 1`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).tablespace('pg_default').using('drizzle_heap').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 1`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET ACCESS METHOD "drizzle_heap";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('set using - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).using('drizzle_heap').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET ACCESS METHOD "drizzle_heap";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop using - materialize', async () => {
+	const users = pgTable('users', {
+		id: integer('id').primaryKey().notNull(),
+	});
+
+	const from = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).using('drizzle_heap').with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const to = {
+		users,
+		view: pgMaterializedView('some_view', { id: integer('id') }).with({
+			autovacuumVacuumCostLimit: 1,
+		}).as(sql`SELECT 'asd'`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`ALTER MATERIALIZED VIEW "some_view" SET ACCESS METHOD "heap";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view and alter view', async () => {
+	const from = {
+		users: pgTable('users', { id: serial() }),
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		users: pgTable('users', { id: serial() }),
+		view: pgView('new_some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(
+			sql`SELECT * FROM "users"`,
+		),
+	};
+
+	const renames = ['public.some_view->public.new_some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		`ALTER VIEW "some_view" RENAME TO "new_some_view";`,
+		`ALTER VIEW "new_some_view" SET (check_option = cascaded);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('moved schema and alter view', async () => {
+	const schema = pgSchema('my_schema');
+	const from = {
+		schema,
+		users: pgTable('users', { id: serial() }),
+		view: pgView('some_view', { id: integer('id') }).as(sql`SELECT * FROM "users"`),
+	};
+
+	const to = {
+		schema,
+		users: pgTable('users', { id: serial() }),
+		view: schema.view('some_view', { id: integer('id') }).with({ checkOption: 'cascaded' }).as(
+			sql`SELECT * FROM "users"`,
+		),
+	};
+
+	const renames = ['public.some_view->my_schema.some_view'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		`ALTER VIEW "some_view" SET SCHEMA "my_schema";`,
+		`ALTER VIEW "my_schema"."some_view" SET (check_option = cascaded);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('push view with same name', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP VIEW "view";',
+		'CREATE VIEW "view" AS (select distinct "id" from "test" where "test"."id" = 1);',
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('push materialized view with same name', async () => {
+	const table = pgTable('test', {
+		id: serial('id').primaryKey(),
+	});
+	const schema1 = {
+		test: table,
+		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([
+		'DROP MATERIALIZED VIEW "view";',
+		'CREATE MATERIALIZED VIEW "view" AS (select distinct "id" from "test" where "test"."id" = 1);',
+	]);
+	expect(pst).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4265
+test('.as in view select', async () => {
+	const user = pgTable('user', {
+		id: serial().primaryKey(),
+		email: text(),
+		name: text(),
+	});
+
+	const userSubscription = pgTable('user_subscription', {
+		id: serial().primaryKey(),
+		userId: integer().references(() => user.id),
+		status: text(),
+	});
+	const userSubscriptionView = pgView('user_subscription_view').as(
+		(qb) => {
+			return qb
+				.select({
+					userId: user.id.as('userId'),
+					email: user.email,
+					name: user.name,
+					subscriptionId: userSubscription.id.as('subscriptionId'),
+					status: userSubscription.status,
+				})
+				.from(user)
+				.leftJoin(
+					userSubscription,
+					sql`((${user.id} = ${userSubscription.userId}) and (((${userSubscription.status} = 'active') or (${userSubscription.status} = 'trialing'))))`,
+				);
+		},
+	);
+
+	const userSubscriptionView1 = pgView('user_subscription_view1').as(
+		(qb) => {
+			return qb
+				.select({
+					userId: user.id.as('userId'),
+					email: user.email,
+					name: user.name,
+					subscriptionId: userSubscription.id.as('subscriptionId'),
+					status: userSubscription.status,
+				})
+				.from(user)
+				.leftJoin(
+					userSubscription,
+					and(
+						eq(user.id, userSubscription.userId),
+						or(eq(userSubscription.status, 'active'), eq(userSubscription.status, 'trialing')),
+					),
+				);
+		},
+	);
+
+	const schema = {
+		user,
+		userSubscription,
+		userSubscriptionView,
+		userSubscriptionView1,
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+
+	const expectedSt1View = (viewName: string) =>
+		`CREATE VIEW "${viewName}" AS `
+		+ `(select "user"."id" as "userId", "user"."email", "user"."name", "user_subscription"."id" as "subscriptionId", "user_subscription"."status" `
+		+ `from "user" left join "user_subscription" on (("user"."id" = "user_subscription"."userId") `
+		+ `and ((("user_subscription"."status" = 'active') or ("user_subscription"."status" = 'trialing')))));`;
+	const expectedSt1 = [
+		'CREATE TABLE "user" (\n\t"id" serial PRIMARY KEY,\n\t"email" text,\n\t"name" text\n);\n',
+		'CREATE TABLE "user_subscription" (\n\t"id" serial PRIMARY KEY,\n\t"userId" integer,\n\t"status" text\n);\n',
+		'ALTER TABLE "user_subscription" ADD CONSTRAINT "user_subscription_userId_user_id_fkey" FOREIGN KEY ("userId") REFERENCES "user"("id");',
+		expectedSt1View('user_subscription_view'),
+		expectedSt1View('user_subscription_view1'),
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4181
+// casing bug
+test('create view with snake_case', async () => {
+	const test = snakeCase.table('test', {
+		testId: serial().primaryKey(),
+		testName: text().notNull(),
+	});
+
+	const testView = pgView('test_view').as((qb) => {
+		return qb
+			.select({
+				testId1: test.testId,
+				testName1: test.testName,
+			})
+			.from(test);
+	});
+	const schema = { test, testView };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "test" (\n'
+		+ '\t"test_id" serial PRIMARY KEY,\n'
+		+ '\t"test_name" text NOT NULL\n'
+		+ ');\n',
+		'CREATE VIEW "test_view" AS (select "test_id", "test_name" from "test");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4181
+// casing bug
+test('create view with camelCase', async () => {
+	const test = camelCase.table('test', {
+		test_id: serial().primaryKey(),
+		test_name: text().notNull(),
+	});
+
+	const testView = pgView('test_view').as((qb) => {
+		return qb
+			.select({
+				test_id: test.test_id,
+				test_name: test.test_name,
+			})
+			.from(test);
+	});
+	const schema = { test, testView };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "test" (\n'
+		+ '\t"testId" serial PRIMARY KEY,\n'
+		+ '\t"testName" text NOT NULL\n'
+		+ ');\n',
+		'CREATE VIEW "test_view" AS (select "testId", "testName" from "test");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('drop column referenced by a view', async () => {
+	const users = pgTable('users', { id: integer(), name: text() });
+	const uv = pgView('users_view').as((q) => q.select().from(users));
+	const from = { users, uv };
+
+	const users2 = pgTable('users', { id: integer() });
+	const uv2 = pgView('users_view').as((q) => q.select().from(users2));
+	const to = { users2, uv2 };
+
+	// push command ignores view definition
+	const res = await diff(from, to, []);
+	await push({ db, to: from });
+	// no view recreate in push so far, with shadow db we can
+	// const resp = await push({ db, to });
+
+	for (const st of res.sqlStatements) {
+		await db.query(st);
+	}
+
+	expect(res.sqlStatements).toStrictEqual([
+		'DROP VIEW "users_view";',
+		'ALTER TABLE "users" DROP COLUMN "name";',
+		'CREATE VIEW "users_view" AS (select "id" from "users");',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5116
+test('rename column referenced in view', async () => {
+	const users = pgTable('users', { id: integer(), name: text() });
+	const uv = pgView('users_view').as((q) => q.select().from(users));
+
+	const from = {
+		users,
+		uv,
+	};
+
+	const users2 = pgTable('users', { id2: integer(), name2: text() });
+	const uv2 = pgView('users_view').as((q) => q.select().from(users2));
+	const to = { users2, uv2 };
+
+	// push command ignores view definition
+	const res = await diff(from, to, ['public.users.name->public.users.name2', 'public.users.id->public.users.id2']);
+	await push({ db, to: from });
+	for (const s of res.sqlStatements) {
+		await db.query(s);
+	}
+	expect(res.sqlStatements).toStrictEqual([
+		'DROP VIEW "users_view";',
+		'ALTER TABLE "users" RENAME COLUMN "name" TO "name2";',
+		'ALTER TABLE "users" RENAME COLUMN "id" TO "id2";',
+		'CREATE VIEW "users_view" AS (select "id2", "name2" from "users");',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4520
+test('create 2 dependent materialized views', async () => {
+	const table1 = pgTable('table1', {
+		col1: integer(),
+		col2: integer(),
+		col3: integer(),
+	});
+	const accountBalancesPMMV = pgMaterializedView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = pgMaterializedView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer,\n\t"col2" integer,\n\t"col3" integer\n);\n',
+		'CREATE MATERIALIZED VIEW "accountBalancesPM" AS (select "col1", "col2", "col3" from "table1");',
+		'CREATE MATERIALIZED VIEW "accountBalances" AS (select "col1" from "accountBalancesPM");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('create 2 dependent views', async () => {
+	const table1 = pgTable('table1', {
+		col1: integer(),
+		col2: integer(),
+		col3: integer(),
+	});
+	const accountBalancesPMMV = pgView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = pgView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE "table1" (\n\t"col1" integer,\n\t"col2" integer,\n\t"col3" integer\n);\n',
+		'CREATE VIEW "accountBalancesPM" AS (select "col1", "col2", "col3" from "table1");',
+		'CREATE VIEW "accountBalances" AS (select "col1" from "accountBalancesPM");',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/postgres/pull.test.ts b/drizzle-kit/tests/postgres/pull.test.ts
new file mode 100644
index 0000000000..9144adb0bf
--- /dev/null
+++ b/drizzle-kit/tests/postgres/pull.test.ts
@@ -0,0 +1,2998 @@
+import { PGlite } from '@electric-sql/pglite';
+import { SQL, sql } from 'drizzle-orm';
+import {
+	AnyPgColumn,
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	check,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	foreignKey,
+	index,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgMaterializedView,
+	pgPolicy,
+	pgRole,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	pgView,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	text,
+	time,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+	varchar,
+	vector,
+} from 'drizzle-orm/pg-core';
+import fs from 'fs';
+import { fromDatabase, fromDatabaseForDrizzle } from 'src/dialects/postgres/introspect';
+import { prepareEntityFilter } from 'src/dialects/pull-utils';
+import { DB } from 'src/utils';
+import { diffIntrospect, prepareTestDatabase, push, TestDatabase } from 'tests/postgres/mocks';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+if (!fs.existsSync('tests/postgres/tmp')) {
+	fs.mkdirSync(`tests/postgres/tmp`, { recursive: true });
+}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('basic introspect test', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').notNull(),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-introspect');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic identity always test', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-identity-always-introspect');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('identity always test: few schemas', async () => {
+	const testSchema = pgSchema('test');
+	const schema = {
+		testSchema,
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+		}),
+		usersInTestSchema: testSchema.table('users', {
+			id: integer('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+		}),
+	};
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'identity always test: few schemas', [
+		'public',
+		'test',
+	]);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic identity by default test', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity(),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-identity-default-introspect');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3240
+test('basic index test', async () => {
+	const client = new PGlite();
+
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				firstName: text('first_name'),
+				lastName: text('last_name'),
+				data: jsonb('data'),
+			},
+			(table) => [
+				index('single_column').on(table.firstName),
+				index('multi_column').on(table.firstName, table.lastName),
+				index('single_expression').on(sql`lower(${table.firstName})`),
+				index('multi_expression').on(
+					sql`lower(${table.firstName})`,
+					sql`lower(${table.lastName})`,
+				),
+				index('expression_with_comma').on(
+					sql`(lower(${table.firstName}) || ', '::text || lower(${table.lastName}))`,
+				),
+				index('expression_with_double_quote').on(
+					sql`('"'::text || ${table.firstName})`,
+				),
+				index('expression_with_jsonb_operator').on(
+					sql`(${table.data} #>> '{a,b,1}'::text[])`,
+				),
+			],
+		),
+	};
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'basic-index-introspect',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// TODO: Refactor this test
+test('advanced index test', async () => {
+	db.query(
+		'CREATE table job (name text, start_after text, priority text, created_on text, id text, state text);',
+	);
+	db.query(
+		"CREATE INDEX job_i5 ON job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active';",
+	);
+
+	const { indexes } = await fromDatabase(db, () => true);
+
+	expect(indexes).toStrictEqual([
+		{
+			name: 'job_i5',
+			table: 'job',
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'name',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'start_after',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			forPK: false,
+			isUnique: false,
+			method: 'btree',
+			forUnique: false,
+			nameExplicit: true,
+			schema: 'public',
+			where: "(state < 'active'::text)",
+			with: '',
+		} satisfies (typeof indexes)[number],
+	]);
+});
+
+test('identity always test: few params', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity({
+				startWith: 100,
+				name: 'custom_name',
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'identity-always-few-params-introspect');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('identity by default test: few params', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				maxValue: 10000,
+				name: 'custom_name',
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-few-params-introspect',
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('identity always test: all params', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity({
+				startWith: 10,
+				increment: 4,
+				minValue: 10,
+				maxValue: 10000,
+				cache: 100,
+				cycle: true,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'identity-always-all-params-introspect');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('identity by default test: all params', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedByDefaultAsIdentity({
+				startWith: 10,
+				increment: 4,
+				minValue: 10,
+				maxValue: 10000,
+				cache: 100,
+				cycle: true,
+			}),
+			email: text('email'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'identity-default-all-params-introspect',
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('generated column: link to another column', async () => {
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').generatedAlwaysAsIdentity(),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`email`,
+			),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'generated-link-column');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('generated column: link to another jsonb column', async () => {
+	const schema = {
+		users: pgTable('users', {
+			predict: jsonb('predict'),
+			predictions: jsonb('predictions').generatedAlwaysAs(
+				(): SQL => sql`predict -> 'predictions'`,
+			),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'generated-link-jsonb-column');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5149
+// https://github.com/drizzle-team/drizzle-orm/issues/3593
+// https://github.com/drizzle-team/drizzle-orm/issues/4349
+// https://github.com/drizzle-team/drizzle-orm/issues/4632
+// https://github.com/drizzle-team/drizzle-orm/issues/4644
+// https://github.com/drizzle-team/drizzle-orm/issues/4730
+// https://github.com/drizzle-team/drizzle-orm/issues/4760
+// https://github.com/drizzle-team/drizzle-orm/issues/4916
+test('introspect all column types', async () => {
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		// NOTE: Types from extensions aren't tested due to PGlite not supporting at the moment
+		columns: pgTable('columns', {
+			enum: myEnum('my_enum').default('a'),
+			smallint: smallint('smallint').default(10),
+			integer: integer('integer').default(10),
+			numeric: numeric('numeric', { precision: 3, scale: 1 }).default('99.9'),
+			numeric2: numeric('numeric2', { precision: 1, scale: 1 }).default('99.9'),
+			numeric3: numeric('numeric3').default('99.9'),
+			bigint: bigint('bigint', { mode: 'number' }).default(100),
+			boolean: boolean('boolean').default(true),
+			text: text('text').default('abc'),
+			text1: text('text1').default(sql`gen_random_uuid()`),
+			text2: text('text2').default('``'),
+			text3: text('text3').default(''),
+			varchar: varchar('varchar', { length: 25 }).default('abc'),
+			varchar1: varchar('varchar1', { length: 25 }).default(''),
+			varchar2: varchar('varchar2').default(sql`md5((random())::text)`),
+			char: char('char', { length: 3 }).default('abc'),
+			char1: char('char1', { length: 3 }).default(''),
+			serial: serial('serial'),
+			bigserial: bigserial('bigserial', { mode: 'number' }),
+			smallserial: smallserial('smallserial'),
+			doublePrecision: doublePrecision('doublePrecision').default(100),
+			real: real('real').default(100),
+			json: json('json').$type<{ attr: string }>().default({ attr: 'value' }),
+			json1: json('json1').default(sql`jsonb_build_object()`),
+			jsonb: jsonb('jsonb')
+				.$type<{ attr: string }>()
+				.default({ attr: 'value' }),
+			jsonb1: jsonb('jsonb1').default(sql`jsonb_build_object()`),
+			jsonb2: jsonb('jsonb2').default({}),
+			jsonb3: jsonb('jsonb3')
+				.default({ confirmed: true, not_received: true })
+				.notNull(),
+			time1: time('time1').default('00:00:00'),
+			time2: time('time2').defaultNow(),
+			timestamp1: timestamp('timestamp1', {
+				withTimezone: true,
+				precision: 6,
+			}).default(new Date()),
+			timestamp2: timestamp('timestamp2', {
+				withTimezone: true,
+				precision: 6,
+			}).defaultNow(),
+			timestamp3: timestamp('timestamp3', {
+				withTimezone: true,
+				precision: 6,
+			}).default(sql`timezone('utc'::text, now())`),
+			date1: date('date1').default('2024-01-01'),
+			date2: date('date2').defaultNow(),
+			date3: date('date3').default(sql`CURRENT_TIMESTAMP`),
+			uuid1: uuid('uuid1').default('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'),
+			uuid2: uuid('uuid2').defaultRandom(),
+			inet: inet('inet').default('127.0.0.1'),
+			cidr: cidr('cidr').default('127.0.0.1/32'),
+			macaddr: macaddr('macaddr').default('00:00:00:00:00:00'),
+			macaddr8: macaddr8('macaddr8').default('00:00:00:ff:fe:00:00:00'),
+			interval: interval('interval').default('1 day 01:00:00'),
+			customType: customType({
+				codec: 'text',
+				dataType: () => 'tsvector',
+			})().default("to_tsvector('english', 'The Fat Rats')"),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-all-columns-types');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4956
+// https://github.com/drizzle-team/drizzle-orm/issues/5093
+test('introspect uuid column with custom default function', async () => {
+	await db.query(`CREATE OR REPLACE FUNCTION uuidv7()
+RETURNS uuid
+LANGUAGE sql
+IMMUTABLE
+AS $$
+  SELECT 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'::uuid;
+$$;`);
+
+	const schema = {
+		columns: pgTable('columns', {
+			uuid1: uuid().default(sql`uuidv7()`),
+			text: text().default(sql`uuidv7()`),
+			text1: text()
+				.default(sql`upper(substr(md5((random())::text), 1, 6))`)
+				.notNull(),
+			char: char().default(sql`uuidv7()`),
+			varchar: varchar().default(sql`uuidv7()`),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-uuid-column-custom-default');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4231#:~:text=Scenario%201%3A%20jsonb().array().default(%5B%5D)
+// https://github.com/drizzle-team/drizzle-orm/issues/4529
+test('introspect all column array types', async () => {
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		enum_: myEnum,
+		// NOTE: Types from extensions aren't tested due to PGlite not supporting at the moment
+		columns: pgTable('columns', {
+			enum: myEnum('my_enum').array().default(['a', 'b']),
+			smallint: smallint('smallint').array().default([10, 20]),
+			integer: integer('integer').array().default([10, 20]),
+			numeric: numeric('numeric', { precision: 3, scale: 1 })
+				.array()
+				.default(['99.9', '88.8']),
+			bigint: bigint('bigint', { mode: 'number' }).array().default([100, 200]),
+			boolean: boolean('boolean').array().default([true, false]),
+			text: text('test').array().default(['abc', 'def']),
+			varchar: varchar('varchar', { length: 25 })
+				.array()
+				.default(['abc', 'def']),
+			char: char('char', { length: 3 }).array().default(['abc', 'def']),
+			doublePrecision: doublePrecision('doublePrecision')
+				.array()
+				.default([100, 200]),
+			real: real('real').array().default([100, 200]),
+			json: json('json')
+				.$type<{ attr: string }>()
+				.array()
+				.default([{ attr: 'value1' }, { attr: 'value2' }]),
+			jsonb: jsonb('jsonb')
+				.$type<{ attr: string }>()
+				.array()
+				.default([{ attr: 'value1' }, { attr: 'value2' }]),
+			jsonb1: jsonb('jsonb1')
+				.array()
+				.default(sql`'{}'`),
+			jsonb2: jsonb('jsonb2').array().default([]),
+			time: time('time').array().default(['00:00:00', '01:00:00']),
+			timestamp: timestamp('timestamp', { withTimezone: true, precision: 6 })
+				.array()
+				.default([new Date(), new Date()]),
+			date: date('date').array().default(['2024-01-01', '2024-01-02']),
+			uuid: uuid('uuid')
+				.array()
+				.default([
+					'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+					'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12',
+				]),
+			inet: inet('inet').array().default(['127.0.0.1', '127.0.0.2']),
+			cidr: cidr('cidr').array().default(['127.0.0.1/32', '127.0.0.2/32']),
+			macaddr: macaddr('macaddr')
+				.array()
+				.default(['00:00:00:00:00:00', '00:00:00:00:00:01']),
+			macaddr8: macaddr8('macaddr8')
+				.array()
+				.default(['00:00:00:ff:fe:00:00:00', '00:00:00:ff:fe:00:00:01']),
+			interval: interval('interval')
+				.array()
+				.default(['1 day 01:00:00', '1 day 02:00:00']),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-all-columns-array-types');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect columns with name with non-alphanumeric characters', async () => {
+	const schema = {
+		users: pgTable('users', {
+			'not:allowed': integer('not:allowed'),
+			'nuh--uh': integer('nuh-uh'),
+			'1_nope': integer('1_nope'),
+			valid: integer('valid'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'introspect-column-with-name-with-non-alphanumeric-characters',
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect enum from different schema', async () => {
+	const schema2 = pgSchema('schema2');
+	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		schema2,
+		myEnumInSchema2,
+		users: pgTable('users', {
+			col: myEnumInSchema2('col'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-from-different-schema',
+		['public', 'schema2'],
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect enum with same names across different schema', async () => {
+	const schema2 = pgSchema('schema2');
+	const myEnumInSchema2 = schema2.enum('my_enum', ['a', 'b', 'c']);
+	const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
+	const schema = {
+		schema2,
+		myEnumInSchema2,
+		myEnum,
+		users: pgTable('users', {
+			col1: myEnumInSchema2('col1'),
+			col2: myEnum('col2'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-with-same-names-across-different-schema',
+		['public', 'schema2'],
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect enum with similar name to native type', async () => {
+	const timeLeft = pgEnum('time_left', ['short', 'medium', 'long']);
+	const schema = {
+		timeLeft,
+		auction: pgTable('auction', {
+			col: timeLeft('col1'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'introspect-enum-with-similar-name-to-native-type',
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect strings with single quotes', async () => {
+	const myEnum = pgEnum('my_enum', ['escape\'s quotes " ']);
+	const schema = {
+		enum_: myEnum,
+		columns: pgTable('columns', {
+			enum: myEnum('my_enum').default('escape\'s quotes " '),
+			text: text('text').default('escape\'s quotes " '),
+			varchar: varchar('varchar').default('escape\'s quotes " '),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-strings-with-single-quotes');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect checks', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: serial('id'),
+				name: varchar('name'),
+				age: integer('age'),
+			},
+			(table) => [check('some_check', sql`${table.age} > 21`)],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-checks');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect checks from different schemas with same names', async () => {
+	const mySchema = pgSchema('schema2');
+	const schema = {
+		mySchema,
+		users: pgTable(
+			'users',
+			{
+				id: serial('id'),
+				age: integer('age'),
+			},
+			(table) => [check('some_check', sql`${table.age} > 21`)],
+		),
+		usersInMySchema: mySchema.table(
+			'users',
+			{
+				id: serial('id'),
+				age: integer('age'),
+			},
+			(table) => [check('some_check', sql`${table.age} < 1`)],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'introspect-checks-diff-schema-same-names',
+		['public', 'schema2'],
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect view #1', async () => {
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = pgView('some_view').as((qb) => qb.select().from(users));
+	const schema = {
+		view,
+		users,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-view');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect view #2', async () => {
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = pgView('some_view', { id: integer('asd') })
+		.with({ checkOption: 'cascaded' })
+		.as(sql`SELECT * FROM ${users}`);
+	const schema = {
+		view,
+		users,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-view-2');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4764
+test('introspect view #3', async () => {
+	const enum1 = pgEnum('enum_1', ['text', 'not_text']);
+
+	const test = pgTable('test', {
+		column1: enum1().array(),
+		column2: enum1().array('[][]'),
+	});
+	const publicJobsWithCompanies = pgView('public_jobs_with_companies').as(
+		(qb) => qb.select().from(test),
+	);
+
+	const schema = { enum1, test, publicJobsWithCompanies };
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-view-3');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	// TODO: we need to check actual types generated;
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4262
+// postopone
+// Need to write discussion/guide on this and add ts comment in typescript file
+test.skipIf(Date.now() < +new Date('2026-07-01'))('introspect view #4', async () => {
+	const table = pgTable('table', {
+		column1: text().notNull(),
+		column2: text(),
+	});
+	const myView = pgView('public_table_view_4', { column1: text(), column2: text() }).as(
+		sql`select column1, column2 from "table"`,
+	);
+
+	const schema = { table, myView };
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-view-4');
+
+	throw Error('');
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	// TODO: we need to check actual types generated;
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4262
+// postopone
+// Need to write discussion/guide on this and add ts comment in typescript file
+test.skipIf(Date.now() < +new Date('2026-07-01'))('introspect view #5', async () => {
+	const applications = pgTable('applications', {
+		applicationId: serial('application_id').primaryKey(),
+		studentId: integer('student_id').references(() => students.studentId),
+		isAdminAccepted: boolean('is_admin_accepted'),
+	});
+
+	const departments = pgTable('departments', {
+		departmentId: serial('department_id').primaryKey(),
+		title: text(),
+	});
+
+	const registrations = pgTable('registrations', {
+		registrationId: serial('registration_id').primaryKey(),
+		applicationId: integer('application_id').references(
+			() => applications.applicationId,
+		),
+		departmentId: integer('department_id').references(
+			() => departments.departmentId,
+		),
+		academicDegree: text('academic_degree'),
+	});
+
+	const students = pgTable('students', {
+		studentId: serial('student_id').primaryKey(),
+		fullNameAr: text('full_name_ar').notNull(),
+	});
+
+	const adminApplicationsList = pgView('admin_applications_list', {
+		applicationId: integer('application_id'),
+		studentName: text('student_name').notNull(),
+		academicDegree: text('academic_degree'),
+		department: text(),
+		isAdminAccepted: boolean('is_admin_accepted'),
+	}).as(
+		sql`SELECT a.application_id, s.full_name_ar AS student_name, r.academic_degree, d.title AS department, a.is_admin_accepted FROM applications a JOIN students s USING (student_id) JOIN registrations r USING (application_id) JOIN departments d ON d.department_id = r.department_id`,
+	);
+
+	const schema = {
+		students,
+		departments,
+		applications,
+		registrations,
+		adminApplicationsList,
+	};
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-view-5',
+	);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	throw new Error();
+	// text('student_name') column in view should contain notNull constraint
+});
+
+test('introspect view in other schema', async () => {
+	const newSchema = pgSchema('new_schema');
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = newSchema
+		.view('some_view', { id: integer('asd') })
+		.with({ checkOption: 'cascaded' })
+		.as(sql`SELECT * FROM ${users}`);
+	const schema = {
+		view,
+		users,
+		newSchema,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-view-in-other-schema', [
+		'new_schema',
+	]);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect materialized view in other schema', async () => {
+	const newSchema = pgSchema('new_schema');
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = newSchema
+		.materializedView('some_view', { id: integer('asd') })
+		.with({ autovacuumEnabled: true })
+		.as(sql`SELECT * FROM ${users}`);
+	const schema = {
+		view,
+		users,
+		newSchema,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-mat-view-in-other-schema', [
+		'new_schema',
+	]);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect materialized view #1', async () => {
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = pgMaterializedView('some_view')
+		.using('heap')
+		.withNoData()
+		.as((qb) => qb.select().from(users));
+	const schema = {
+		view,
+		users,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-materialized-view');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect materialized view #2', async () => {
+	const users = pgTable('users', {
+		id: serial('id').primaryKey().notNull(),
+		name: varchar('users'),
+	});
+
+	const view = pgMaterializedView('some_view', { id: integer('asd') })
+		.with({ autovacuumFreezeMinAge: 1 })
+		.as(sql`SELECT * FROM ${users}`);
+	const schema = {
+		view,
+		users,
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-materialized-view-2');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic policy #1', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [pgPolicy('test')],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-policy-#1', ['public'], {
+		roles: { include: ['test'] },
+	});
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic policy with "as"', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [pgPolicy('test', { as: 'permissive' })],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-policy-as');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic policy', async () => {
+	const schema = {
+		role: pgRole('test2'),
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [pgPolicy('test', { to: 'test2' })],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-policy', ['public'], {
+		roles: { include: ['test2'] },
+	});
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic policy with all fields except "using" and "with"', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [
+				pgPolicy('test', { as: 'permissive', for: 'all', to: ['postgres'] }),
+			],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-policy-all-fields');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic policy with "using" and "with"', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [pgPolicy('test', { using: sql`true`, withCheck: sql`true` })],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-policy-using-withcheck');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('multiple policies #1', async () => {
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [
+				pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				pgPolicy('newRls'),
+			],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'multiple-policies');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4407
+test('multiple policies #2', async () => {
+	const users = pgTable(
+		'users',
+		{
+			id: integer(),
+		},
+		(table) => [
+			pgPolicy('insert_policy_for_users', {
+				for: 'insert',
+				withCheck: sql`true`,
+			}),
+			pgPolicy('update_policy_for_users', {
+				for: 'update',
+				using: sql`true`,
+				withCheck: sql`true`,
+			}),
+		],
+	);
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [
+				pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				pgPolicy('newRls'),
+			],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'multiple-policies-2');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('multiple policies with roles', async () => {
+	db.query(`CREATE ROLE manager;`);
+
+	const schema = {
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [
+				pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				pgPolicy('newRls', { to: ['postgres', 'manager'] }),
+			],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'multiple-policies-with-roles');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('basic roles', async () => {
+	const schema = {
+		usersRole: pgRole('user'),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'basic-roles', ['public'], {
+		roles: { include: ['user'] },
+	});
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('role with properties', async () => {
+	const schema = {
+		usersRole: pgRole('user', {
+			inherit: false,
+			createDb: true,
+			createRole: true,
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'roles-with-properties', ['public'], {
+		roles: { include: ['user'] },
+	});
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('role with a few properties', async () => {
+	const schema = {
+		usersRole: pgRole('user', { inherit: false, createRole: true }),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'roles-with-few-properties',
+		['public'],
+		{ roles: { include: ['user'] } },
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('multiple policies with roles from schema', async () => {
+	const usersRole = pgRole('user_role', { inherit: false, createRole: true });
+
+	const schema = {
+		usersRole,
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			() => [
+				pgPolicy('test', { using: sql`true`, withCheck: sql`true` }),
+				pgPolicy('newRls', { to: ['postgres', usersRole] }),
+			],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'multiple-policies-with-roles-from-schema',
+		['public'],
+		{ roles: { include: ['user_role'] } },
+	);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('case sensitive schema name + identity column', async () => {
+	const mySchema = pgSchema('CaseSensitiveSchema');
+	const schema = {
+		mySchema,
+		users: mySchema.table('users', {
+			id: integer('id').primaryKey().generatedAlwaysAsIdentity(),
+			name: text('name'),
+		}),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'case-sensitive-schema-name', [
+		'CaseSensitiveSchema',
+	]);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect without any schema', async () => {
+	await db.query(`DROP SCHEMA "public" cascade`);
+	const schema = {};
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-without-any-schema');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect composite pk', async () => {
+	const firstToSecondTable = pgTable(
+		'firstToSecond',
+		{
+			firstId: integer('firstId'),
+			secondId: integer('secondId'),
+		},
+		(table) => [primaryKey({ columns: [table.firstId, table.secondId] })],
+	);
+
+	const schema = { firstToSecondTable };
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-composite-pk',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect foreign keys', async () => {
+	const mySchema = pgSchema('my_schema');
+	const users = pgTable('users', {
+		id: integer('id').primaryKey(),
+		name: text('name'),
+	});
+	const schema = {
+		mySchema,
+		users,
+		posts: mySchema.table('posts', {
+			id: integer('id').primaryKey(),
+			userId: integer('user_id').references(() => users.id, {
+				onDelete: 'set null',
+				onUpdate: 'cascade',
+			}),
+		}),
+	};
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+		ddlAfterPull,
+	} = await diffIntrospect(db, schema, 'introspect-foreign-keys', [
+		'my_schema',
+		'public',
+	]);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(
+		ddlAfterPull.fks.one({
+			schema: 'my_schema',
+			table: 'posts',
+			columns: ['user_id'],
+			schemaTo: 'public',
+			tableTo: 'users',
+			columnsTo: ['id'],
+		}),
+	).not.toBeNull();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5082
+test('introspect foreign keys #2', async () => {
+	const test = pgTable(
+		'test',
+		{
+			col1: integer(),
+			col2: integer(),
+			col3: integer(),
+		},
+		(table) => [
+			unique('composite_unique').on(table.col2, table.col3),
+			unique('test_col1_key').on(table.col1),
+		],
+	);
+
+	const test1 = pgTable(
+		'test1',
+		{
+			col1: integer().references(() => test.col1),
+			col2: integer(),
+			col3: integer(),
+		},
+		(table) => [
+			foreignKey({
+				columns: [table.col2, table.col3],
+				foreignColumns: [test.col2, test.col3],
+				name: 'composite_fk',
+			}),
+		],
+	);
+
+	const schema = { test, test1 };
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+		ddlAfterPull,
+	} = await diffIntrospect(db, schema, 'introspect-foreign-keys-2', ['public']);
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(ddlAfterPull.fks.list({ schema: 'public' }).length).toBe(2);
+	const predicate = ddlAfterPull.fks
+		.list({ schema: 'public' })
+		.map((fk) => fk.columns.length !== 0 && fk.columnsTo.length !== 0)
+		.every((val) => val === true);
+	expect(predicate).toBe(true);
+});
+
+test('introspect table with self reference', async () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text(),
+		invited_id: integer().references((): AnyPgColumn => users.id),
+	});
+	const schema = { users };
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(db, schema, 'introspect-self-ref');
+
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('introspect partitioned tables', async () => {
+	await db.query(`
+		CREATE TABLE measurement (
+			city_id         int not null,
+			logdate         date not null,
+			peaktemp        int,
+			unitsales       int
+		) PARTITION BY RANGE (logdate);
+	`);
+
+	const { tables } = await fromDatabase(db);
+
+	expect(tables).toStrictEqual([
+		{
+			name: 'measurement',
+			schema: 'public',
+			entityType: 'tables',
+			isRlsEnabled: false,
+		} satisfies (typeof tables)[number],
+	]);
+});
+
+test('default sequence nextval', async () => {
+	const seqOrgCode = pgSequence('seq_org_code', {
+		startWith: '1000',
+		increment: '1',
+		minValue: '1',
+		maxValue: '9223372036854775807',
+		cache: '1',
+		cycle: false,
+	});
+
+	const organizations = pgTable('organizations', {
+		code: bigint({ mode: 'number' })
+			.default(sql`nextval('seq_org_code'::regclass)`)
+			.notNull(),
+	});
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		{ seqOrgCode, organizations },
+		'default_sequence_nextval',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+test('policy', async () => {
+	const organizationsInCore = pgTable(
+		'organizations',
+		{
+			domain: text(),
+		},
+		(table) => [unique('organizations_domain_key').on(table.domain)],
+	);
+
+	const policy = pgPolicy('new_policy', {
+		as: 'restrictive',
+		to: 'postgres',
+		withCheck: sql`1 = 1`,
+		for: 'all',
+	}).link(organizationsInCore);
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		{ organizationsInCore, policy },
+		'policy',
+	);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// test('introspect foreign tables', async () => {
+// 	await db.query('CREATE EXTENSION postgres_fdw;');
+// 	await db.query("CREATE SERVER film_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'foo', dbname 'foodb', port '5432');");
+// 	await db.query(`
+// 		CREATE FOREIGN TABLE films (
+// 			code        char(5) NOT NULL,
+// 			title       varchar(40) NOT NULL,
+// 			did         integer NOT NULL,
+// 			date_prod   date,
+// 			kind        varchar(10),
+// 			len         interval hour to minute
+// 		) SERVER film_server;
+// 	`);
+
+// 	const { tables } = await fromDatabase(db);
+
+// 	expect(tables).toStrictEqual([
+// 		{
+// 			name: 'films',
+// 			schema: 'public',
+// 			entityType: 'tables',
+// 			isRlsEnabled: false,
+// 		} satisfies typeof tables[number],
+// 	]);
+// });
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4170
+test('introspect view with table filter', async () => {
+	const table1 = pgTable('table1', {
+		column1: serial().primaryKey(),
+	});
+	const view1 = pgView('view1', { column1: serial() }).as(
+		sql`select column1 from ${table1}`,
+	);
+	const table2 = pgTable('table2', {
+		column1: serial().primaryKey(),
+	});
+	const view2 = pgView('view2', { column1: serial() }).as(
+		sql`select column1 from ${table2}`,
+	);
+	const schema1 = { table1, view1, table2, view2 };
+	await push({ db, to: schema1 });
+
+	let tables, views;
+	let filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: ['table1'],
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	({ tables, views } = await fromDatabaseForDrizzle(db, filter, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	}));
+	const expectedTables = [
+		{
+			entityType: 'tables',
+			schema: 'public',
+			name: 'table1',
+			isRlsEnabled: false,
+		},
+	];
+	expect(tables).toStrictEqual(expectedTables);
+	expect(views).toStrictEqual([]);
+
+	filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: ['table1', 'view1'],
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	({ tables, views } = await fromDatabaseForDrizzle(db, filter, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	}));
+	const expectedViews = [
+		{
+			entityType: 'views',
+			schema: 'public',
+			name: 'view1',
+			definition: 'SELECT column1 FROM table1',
+			with: null,
+			materialized: false,
+			tablespace: null,
+			using: null,
+			withNoData: null,
+		},
+	];
+	expect(tables).toStrictEqual(expectedTables);
+	expect(views).toStrictEqual(expectedViews);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4144
+// this does not look like a bug
+// sequences are separete entities
+// entity filter for sequences ??
+test.skipIf(Date.now() < +new Date('2026-07-01'))('introspect sequences with table filter', async () => {
+	// can filter sequences with select pg_get_serial_sequence('"schema_name"."table_name"', 'column_name')
+
+	// const seq1 = pgSequence('seq1');
+	const table1 = pgTable('table1', {
+		column1: serial().primaryKey(),
+		// column1: integer().default(sql`nextval('${sql.raw(seq1.seqName!)}'::regclass)`).primaryKey(),
+	});
+	const table2 = pgTable('prefix_table2', {
+		column1: serial().primaryKey(),
+		// column1: integer().default(sql`nextval('${sql.raw(seq2.seqName!)}'::regclass)`).primaryKey(),
+	});
+	const schema1 = { table1, table2 };
+	await push({ db, to: schema1 });
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: ['!prefix_*'],
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { tables, sequences } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect(tables).toStrictEqual([
+		{
+			entityType: 'tables',
+			schema: 'public',
+			name: 'table1',
+			isRlsEnabled: false,
+		},
+	]);
+	expect(sequences).toBe([
+		{
+			entityType: 'sequences',
+			schema: 'public',
+			name: 'table1_column1_seq',
+			startWith: '1',
+			minValue: '1',
+			maxValue: '2147483647',
+			incrementBy: '1',
+			cycle: false,
+			cacheSize: 1,
+		},
+	]);
+	// 	console.log(await db.query(`select pg_get_serial_sequence('"public"."table1"', 'column1');`));
+	// 	console.log(await db.query(`select pg_get_serial_sequence('"public"."table2"', 'column1');`));
+	// 	console.log(
+	// 		await db.query(`SELECT *
+	// FROM pg_sequences
+	// WHERE schemaname = 'public' AND sequencename = 'table1_column1_seq';`),
+	// 	);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4215
+test('introspect _{dataType} columns type as {dataType}[]', async () => {
+	await db.query(`CREATE TYPE mood_enum AS ENUM('ok', 'bad', 'good');`);
+	await db.query(`CREATE TABLE "_array_data_types" (
+			integer_array          _int4,
+			smallint_array         _int2,
+			bigint_array           _int8,
+			numeric_array          _numeric,
+			real_array             _float4,
+			double_precision_array double precision[],
+			boolean_array          _bool,
+			char_array             _bpchar,-- char with no length restriction
+			varchar_array          _varchar,
+			text_array             _text,
+			bit_array              _bit,
+			json_array             _json,
+			jsonb_array            _jsonb,
+			time_array             _time,
+			timestamp_array        _timestamp,
+			date_array             _date,
+			interval_array         _interval,
+			point_array            _point,
+			line_array             _line,
+			mood_enum_array        _mood_enum,
+			uuid_array             _uuid,
+			inet_array             _inet
+	);`);
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { columns } = await fromDatabaseForDrizzle(db, filter, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+
+	const columnTypes = columns.map((col) => col.type);
+	const columnDimensions = columns.map((col) => col.dimensions);
+
+	expect(columnTypes).toStrictEqual([
+		'integer',
+		'smallint',
+		'bigint',
+		'numeric',
+		'real',
+		'double precision',
+		'boolean',
+		'bpchar',
+		'varchar',
+		'text',
+		'bit',
+		'json',
+		'jsonb',
+		'time',
+		'timestamp',
+		'date',
+		'interval',
+		'point',
+		'line',
+		'mood_enum',
+		'uuid',
+		'inet',
+	]);
+	expect(columnDimensions.every((dim) => dim === 1)).toBe(true);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5149
+test('jsonb default with boolean literals', async () => {
+	const JSONB = pgTable('organizations1', {
+		notifications: jsonb()
+			.default({ confirmed: true, not_received: true })
+			.notNull(),
+	});
+	const JSON = pgTable('organizations2', {
+		notifications: json()
+			.default({ confirmed: true, not_received: true })
+			.notNull(),
+	});
+	const JSONBARRAY = pgTable('organizations3', {
+		notifications: jsonb()
+			.array()
+			.default([{ confirmed: true, not_received: true }])
+			.notNull(),
+	});
+	const JSONARRAY = pgTable('organizations4', {
+		notifications: json()
+			.array()
+			.default([{ confirmed: true, not_received: true }])
+			.notNull(),
+	});
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		{ JSONB, JSONBARRAY, JSON, JSONARRAY },
+		'jsonb_default_with_boolean_literals',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5356
+// https://github.com/drizzle-team/drizzle-orm/issues/5294
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test('single quote default', async () => {
+	const group = pgTable('group', {
+		id: text().notNull(),
+		fk_organizaton_group: text().notNull(),
+		saml_identifier: text().default('').notNull(),
+		display_name: text().default('').notNull(),
+	});
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		{ group },
+		'single_quote_default',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3418
+test('introspect enum within schema', async () => {
+	const mySchema = pgSchema('my_schema');
+	const myEnum = mySchema.enum('my_enum', ['bad', 'sad', 'mad']);
+	const myTable = mySchema.table('my_table', { col1: myEnum() });
+	const myView = mySchema.view('my_view').as((qb) => qb.select().from(myTable));
+	const table1 = pgTable('table1', {
+		column1: serial().primaryKey(),
+	});
+	const schema = { mySchema, myEnum, myTable, myView, table1 };
+	await push({ db, to: schema });
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: ['!my_schema'],
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { tables, enums, views } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect(tables).toStrictEqual([
+		{
+			entityType: 'tables',
+			schema: 'public',
+			name: 'table1',
+			isRlsEnabled: false,
+		},
+	]);
+	expect(enums).toStrictEqual([]);
+	expect(views).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5196
+test('index with option', async () => {
+	const table1 = pgTable(
+		'table1',
+		{
+			column1: integer(),
+			column2: integer(),
+			column3: integer(),
+		},
+		(t) => [
+			index('book_author_id')
+				.using('btree', t.column1.asc().nullsLast())
+				.with({ deduplicate_items: true }),
+			index('book_title_search').using('btree', t.column2.asc().nullsLast()),
+			index('created_at')
+				.using('brin', t.column3.asc().nullsLast())
+				.with({ autosummarize: false }),
+		],
+	);
+
+	const { pushSqlStatements, generateSqlStatements } = await diffIntrospect(
+		db,
+		{ table1 },
+		'index_with_option',
+	);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5224
+test('functional index', async () => {
+	const table1 = pgTable(
+		'table1',
+		{
+			normalized_address: text(),
+			state: text(),
+		},
+		(t) => [
+			uniqueIndex('idx_addresses_natural_key')
+				.using(
+					'btree',
+					sql.raw(`upper(normalized_address)`),
+					sql.raw(`upper((state)::text)`),
+				)
+				.where(
+					sql.raw(`((normalized_address IS NOT NULL) AND (state IS NOT NULL))`),
+				),
+		],
+	);
+
+	const { pushSqlStatements, generateSqlStatements, schema2 } = await diffIntrospect(
+		db,
+		{ table1 },
+		'functional_index',
+	);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(schema2.indexes).toStrictEqual([
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: true,
+					nullsFirst: false,
+					opclass: null,
+					value: 'upper(normalized_address)',
+				},
+				{
+					asc: true,
+					isExpression: true,
+					nullsFirst: false,
+					opclass: null,
+					value: 'upper(state)',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			forPK: false,
+			forUnique: false,
+			isUnique: true,
+			method: 'btree',
+			name: 'idx_addresses_natural_key',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'table1',
+			where: '((normalized_address IS NOT NULL) AND (state IS NOT NULL))',
+			with: '',
+		},
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5193
+test('check definition', async () => {
+	const table1 = pgTable(
+		'table1',
+		{
+			column1: serial().primaryKey(),
+		},
+		(t) => [check('check_positive', sql`${t.column1} > 0`)],
+	);
+	const schema = { table1 };
+	await push({ db, to: schema });
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { checks } = await fromDatabaseForDrizzle(db, filter, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+
+	expect(checks).toStrictEqual([
+		{
+			entityType: 'checks',
+			schema: 'public',
+			name: 'check_positive',
+			table: 'table1',
+			value: '(column1 > 0)',
+		},
+	]);
+});
+
+// other tables in migration schema
+test('pull after migrate with custom migrations table #1', async () => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { pks, columns, tables, schemas } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'drizzle',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'drizzle',
+		},
+		{
+			columns: ['id'],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'drizzle',
+			table: 'users',
+		},
+	]);
+});
+
+// no tables in migration schema
+test('pull after migrate with custom migrations table #2', async () => {
+	await db.query(`CREATE SCHEMA drizzle;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS public.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'public',
+		},
+		{
+			columns: ['id'],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'users',
+		},
+	]);
+});
+
+// other tables in custom migration schema
+test('pull after migrate with custom migrations table #3', async () => {
+	await db.query(`CREATE SCHEMA custom;`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS custom.custom_migrations (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL,
+			applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS custom.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS public.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { schemas, tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		filter,
+		() => {},
+		{
+			table: 'custom_migrations',
+			schema: 'custom',
+		},
+	);
+
+	expect([...schemas, ...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'schemas',
+			name: 'custom',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'custom',
+		},
+		{
+			entityType: 'tables',
+			isRlsEnabled: false,
+			name: 'users',
+			schema: 'public',
+		},
+		{
+			columns: ['id'],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'custom',
+			table: 'users',
+		},
+		{
+			columns: ['id'],
+			entityType: 'pks',
+			name: 'users_pkey',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'users',
+		},
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5190
+test('pscale_extensions schema', async () => {
+	await db.query(`CREATE SCHEMA test;`);
+	await db.query(`CREATE SCHEMA pscale_extensions;`);
+
+	await db.query(`
+		CREATE TABLE IF NOT EXISTS public.users (
+			id SERIAL PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const filter = prepareEntityFilter(
+		'postgresql',
+		{
+			tables: undefined,
+			schemas: undefined,
+			entities: undefined,
+			extensions: undefined,
+		},
+		[],
+	);
+	const { schemas } = await fromDatabaseForDrizzle(db, filter, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+
+	expect(schemas).toStrictEqual([{ name: 'test', entityType: 'schemas' }]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4655
+test('issue No4655. Problem with backslash in check constraint + custom type', async () => {
+	await db.query(`CREATE EXTENSION IF NOT EXISTS citext;`);
+
+	await db.query(`
+	CREATE TABLE public.email (
+		id integer NOT NULL,
+		email public.citext NOT NULL,
+		CONSTRAINT email_email_check CHECK ((email OPERATOR(public.~) '^[a-zA-Z0-9.!#$%&''*+/=?^_\`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$'::public.citext))
+	);
+	`);
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		{},
+		'problem-with-backslash-in-check-constraint',
+	);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5329
+test('introspect policies with schemaFilter', async (t) => {
+	const role = pgRole('owner');
+	const schema1 = {
+		role,
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			(t) => [pgPolicy('test', { as: 'permissive' })],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema1,
+		'introspect-policies-with-schema-filter',
+		['public'],
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+// https://github.com/drizzle-team/drizzle-orm/issues/5329
+test('introspect policies without schemaFilter', async (t) => {
+	const role = pgRole('owner');
+	const schema1 = {
+		role,
+		users: pgTable(
+			'users',
+			{
+				id: integer('id').primaryKey(),
+			},
+			(t) => [pgPolicy('test', { as: 'permissive' })],
+		),
+	};
+
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+	} = await diffIntrospect(
+		db,
+		schema1,
+		'introspect-policies-without-schema-filter',
+		[],
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5056
+test('#5056', async () => {
+	await db.query(`CREATE TABLE public.responses (
+    id          uuid            PRIMARY KEY DEFAULT gen_random_uuid(),
+    prompt_id   uuid            NOT NULL,
+    content     text            NOT NULL,
+    model       text,
+    created_at  timestamptz     NOT NULL DEFAULT now(),
+    updated_at  timestamptz     NOT NULL DEFAULT now()
+);`);
+	await db.query(`CREATE INDEX idx_responses_prompt_created
+    ON public.responses
+    USING btree (prompt_id uuid_ops, model text_pattern_ops, created_at timestamptz_ops DESC);`);
+
+	const fromDb = await fromDatabaseForDrizzle(db, () => true, () => {}, {
+		table: 'drizzle',
+		schema: '__drizzle_migrations',
+	});
+
+	await db.query(`DROP TABLE responses CASCADE`);
+
+	expect(fromDb.indexes).toStrictEqual([
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'prompt_id',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: {
+						default: false,
+						name: 'text_pattern_ops',
+					},
+					value: 'model',
+				},
+				{
+					asc: false,
+					isExpression: false,
+					nullsFirst: true,
+					opclass: null,
+					value: 'created_at',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			forPK: false,
+			forUnique: false,
+			isUnique: false,
+			method: 'btree',
+			name: 'idx_responses_prompt_created',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'responses',
+			where: null,
+			with: '',
+		},
+	]);
+
+	const schema = {
+		responses: pgTable(
+			'responses',
+			{
+				id: uuid().primaryKey().defaultRandom(),
+				prompt_id: uuid().notNull(),
+				content: text().notNull(),
+				model: text(),
+				created_at: timestamp({ withTimezone: true }).defaultNow(),
+				updated_at: timestamp({ withTimezone: true }).defaultNow(),
+			},
+			(
+				t,
+			) => [
+				index('idx_responses_prompt_created').using(
+					'btree',
+					t.prompt_id.op('uuid_ops'),
+					t.model.op('text_pattern_ops'),
+					t.created_at.op('timestamptz_ops').desc(),
+				),
+			],
+		),
+	};
+	const {
+		pushStatements,
+		pushSqlStatements,
+		generateStatements,
+		generateSqlStatements,
+		ddlAfterPull,
+	} = await diffIntrospect(
+		db,
+		schema,
+		'#5056',
+		[],
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5413
+test('introspect nextval defaults on integer columns in non-public schema', async () => {
+	const musicbrainz = pgSchema('musicbrainz');
+
+	const schema = {
+		musicbrainz,
+		usersIdSeq: musicbrainz.sequence('users_id_seq'),
+		users: musicbrainz.table('users', {
+			id: integer('id').notNull().default(sql`nextval('musicbrainz.users_id_seq'::regclass)`),
+		}),
+	};
+
+	const { generateSqlStatements, generateStatements, pushSqlStatements, pushStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-nextval-default-integer-non-public-schema',
+		['musicbrainz'],
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5413
+test('introspect pg_catalog.nextval defaults on integer columns', async () => {
+	const schema = {
+		usersIdSeq: pgSequence('users_id_seq'),
+		users: pgTable('users', {
+			id: integer('id').notNull().default(sql`pg_catalog.nextval('users_id_seq'::regclass)`),
+		}),
+	};
+
+	const { generateSqlStatements, generateStatements, pushSqlStatements, pushStatements } = await diffIntrospect(
+		db,
+		schema,
+		'introspect-pg-catalog-nextval-default-integer',
+	);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5495
+test('access method issue', async () => {
+	await db.query(`CREATE EXTENSION IF NOT EXISTS vector;`);
+
+	const schema = {
+		table: pgTable(
+			'table',
+			{
+				id: integer(),
+				name: vector({ dimensions: 1536 }),
+			},
+			(table) => [index('idx_claims_embedding').using('ivfflat', table.name.asc().nullsLast().op('vector_cosine_ops'))],
+		),
+	};
+
+	const { generateSqlStatements, generateStatements, pushSqlStatements, pushStatements, ddlAfterPull } =
+		await diffIntrospect(
+			db,
+			schema,
+			'issue-5495',
+		);
+
+	expect(ddlAfterPull.indexes.list()).toStrictEqual([
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: {
+						default: false,
+						name: 'vector_cosine_ops',
+					},
+					value: 'name',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			isUnique: false,
+			method: 'ivfflat',
+			name: 'idx_claims_embedding',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'table',
+			where: null,
+			with: '',
+		},
+	]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5493
+test('relations issue', async () => {
+	await db.query(`
+	CREATE TABLE customer (
+	customer_id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY	
+);`);
+	await db.query(`CREATE TABLE billing_account (
+	billing_account_id int8 GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+	customer_id int8 NOT NULL
+);`);
+	await db.query(
+		`ALTER TABLE billing_account ADD CONSTRAINT billing_account_customer_id_fkey FOREIGN KEY (customer_id) REFERENCES public.customer(customer_id);`,
+	);
+	await db.query(`CREATE TABLE contract (
+	contract_id int8 GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+	customer_id int8 NOT NULL,
+	billing_account_id int8 NOT NULL
+);`);
+	await db.query(
+		`ALTER TABLE contract ADD CONSTRAINT contract_billing_account_id_fkey FOREIGN KEY (billing_account_id) REFERENCES billing_account(billing_account_id);`,
+	);
+	await db.query(
+		`ALTER TABLE contract ADD CONSTRAINT contract_customer_id_fkey FOREIGN KEY (customer_id) REFERENCES customer(customer_id);`,
+	);
+
+	const { generateSqlStatements, generateStatements, pushSqlStatements, pushStatements, relationsError } =
+		await diffIntrospect(
+			db,
+			{},
+			'issue-5493',
+		);
+
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(relationsError).toBeNull();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5525
+test('issue 5525', async () => {
+	await db.query(`CREATE TABLE "country" (
+		id text primary key
+	);`);
+
+	await db.query(`
+CREATE TABLE "public"."constructor" (
+  "id" text COLLATE "pg_catalog"."default" NOT NULL,
+  "name" text COLLATE "pg_catalog"."default",
+  "full_name" text COLLATE "pg_catalog"."default",
+  "country_id" text COLLATE "pg_catalog"."default",
+  "best_championship_position" int8,
+  "best_starting_grid_position" int8,
+  "best_race_result" int8,
+  "best_sprint_race_result" int8,
+  "total_championship_wins" int8,
+  "total_race_entries" int8,
+  "total_race_starts" int8,
+  "total_race_wins" int8,
+  "total_1_and_2_finishes" int8,
+  "total_race_laps" int8,
+  "total_podiums" int8,
+  "total_podium_races" int8,
+  "total_points" numeric(8,2),
+  "total_championship_points" numeric(8,2),
+  "total_pole_positions" int8,
+  "total_fastest_laps" int8,
+  "total_sprint_race_starts" int8,
+  "total_sprint_race_wins" int8
+);`);
+
+	await db.query(`ALTER TABLE "public"."constructor" OWNER TO "postgres";`);
+
+	await db.query(`CREATE INDEX "idx_19612_cnst_country_id_idx" ON "public"."constructor" USING btree (
+  "country_id" COLLATE "pg_catalog"."default" "pg_catalog"."text_ops" ASC NULLS LAST
+);`);
+
+	await db.query(`
+CREATE INDEX "idx_19612_cnst_full_name_idx" ON "public"."constructor" USING btree (
+  "full_name" COLLATE "pg_catalog"."default" "pg_catalog"."text_ops" ASC NULLS LAST
+);`);
+
+	await db.query(`CREATE INDEX "idx_19612_cnst_name_idx" ON "public"."constructor" USING btree (
+  "name" COLLATE "pg_catalog"."default" "pg_catalog"."text_ops" ASC NULLS LAST
+);`);
+
+	await db.query(
+		`ALTER TABLE "public"."constructor" ADD CONSTRAINT "idx_19612_sqlite_autoindex_constructor_1" PRIMARY KEY ("id");`,
+	);
+	await db.query(
+		`ALTER TABLE "public"."constructor" ADD CONSTRAINT "constructor_country_id_fkey" FOREIGN KEY ("country_id") REFERENCES "public"."country" ("id") ON DELETE NO ACTION ON UPDATE NO ACTION;`,
+	);
+
+	const { generateSqlStatements, generateStatements, pushSqlStatements, pushStatements, ddlAfterPull } =
+		await diffIntrospect(db, {}, '#5525');
+
+	expect(generateSqlStatements).toStrictEqual([]);
+	expect(generateStatements).toStrictEqual([]);
+	expect(pushSqlStatements).toStrictEqual([]);
+	expect(pushStatements).toStrictEqual([]);
+});
+
+// when user does not have permissions, introspection should not fail
+// https://github.com/drizzle-team/drizzle-orm/issues/5568
+test('non-admin', async () => {
+	const newSchema = pgSchema('schema_not_for_non_admin');
+	const schema = {
+		users: pgTable('users', {
+			id: integer('id').primaryKey().generatedAlwaysAsIdentity(),
+			name: text('name'),
+		}),
+		schemaNotForNonAdmin: newSchema,
+		tableNotForNonAdmin: newSchema.table('table_not_for_non_admin', {
+			id: integer('id'),
+		}),
+	};
+
+	await push({ db, to: schema });
+
+	await db.query(`CREATE ROLE "non-admin" LOGIN PASSWORD 'password';`);
+	await db.query(`SET ROLE "non-admin";`);
+
+	const { tables } = await fromDatabase(db);
+
+	expect(tables).toStrictEqual([
+		{
+			entityType: 'tables',
+			schema: 'public',
+			name: 'users',
+			isRlsEnabled: false,
+		},
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5869
+test('issue #5869', async () => {
+	await db.query(`DROP TABLE IF EXISTS opclass_repro`);
+
+	await db.query(`CREATE TABLE opclass_repro (
+  id bigint PRIMARY KEY,
+  created_at timestamptz NOT NULL,
+  status text NOT NULL
+);`);
+	await db.query(`CREATE INDEX opclass_repro_id_created_idx ON opclass_repro (id, created_at);`);
+	await db.query(`CREATE INDEX opclass_repro_status_created_idx ON opclass_repro (status, created_at);`);
+
+	const {
+		generateSqlStatements: generateSqlStatements1,
+		generateStatements: generateStatements1,
+		pushSqlStatements: pushSqlStatements1,
+		pushStatements: pushStatements1,
+		ddlAfterPull: ddlAfterPull1,
+	} = await diffIntrospect(db, {}, '#5869');
+
+	expect(generateSqlStatements1).toStrictEqual([]);
+	expect(generateStatements1).toStrictEqual([]);
+	expect(pushSqlStatements1).toStrictEqual([]);
+	expect(pushStatements1).toStrictEqual([]);
+	expect(ddlAfterPull1.indexes.list()).toStrictEqual([
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'id',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'created_at',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			isUnique: false,
+			method: 'btree',
+			name: 'opclass_repro_id_created_idx',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'opclass_repro',
+			where: null,
+			with: '',
+		},
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'status',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'created_at',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			isUnique: false,
+			method: 'btree',
+			name: 'opclass_repro_status_created_idx',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'opclass_repro',
+			where: null,
+			with: '',
+		},
+	]);
+
+	await db.query(`DROP TABLE IF EXISTS opclass_repro`);
+
+	await db.query(`
+  CREATE TABLE opclass_repro (
+    id serial PRIMARY KEY,
+    created_at timestamptz NOT NULL,
+    status text NOT NULL,
+    name varchar(255) NOT NULL
+  )
+`);
+	// Non default op-classes
+	await db.query(`
+  CREATE INDEX opclass_repro_status_name_idx 
+  ON opclass_repro (status text_pattern_ops, name varchar_pattern_ops)
+`);
+	await db.query(`
+  CREATE INDEX opclass_repro_name_status_idx 
+  ON opclass_repro (name varchar_ops, status)
+`);
+
+	const {
+		generateSqlStatements: generateSqlStatements2,
+		generateStatements: generateStatements2,
+		pushSqlStatements: pushSqlStatements2,
+		pushStatements: pushStatements2,
+		ddlAfterPull: ddlAfterPull2,
+	} = await diffIntrospect(db, {}, '#5869');
+
+	expect(generateSqlStatements2).toStrictEqual([]);
+	expect(generateStatements2).toStrictEqual([]);
+	expect(pushSqlStatements2).toStrictEqual([]);
+	expect(pushStatements2).toStrictEqual([]);
+	expect(ddlAfterPull2.indexes.list()).toStrictEqual([
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: {
+						default: false,
+						name: 'varchar_ops',
+					},
+					value: 'name',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: null,
+					value: 'status',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			isUnique: false,
+			method: 'btree',
+			name: 'opclass_repro_name_status_idx',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'opclass_repro',
+			where: null,
+			with: '',
+		},
+		{
+			columns: [
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: {
+						default: false,
+						name: 'text_pattern_ops',
+					},
+					value: 'status',
+				},
+				{
+					asc: true,
+					isExpression: false,
+					nullsFirst: false,
+					opclass: {
+						default: false,
+						name: 'varchar_pattern_ops',
+					},
+					value: 'name',
+				},
+			],
+			concurrently: false,
+			entityType: 'indexes',
+			isUnique: false,
+			method: 'btree',
+			name: 'opclass_repro_status_name_idx',
+			nameExplicit: true,
+			schema: 'public',
+			table: 'opclass_repro',
+			where: null,
+			with: '',
+		},
+	]);
+});
diff --git a/drizzle-kit/tests/postgres/schemas/schema1.ts b/drizzle-kit/tests/postgres/schemas/schema1.ts
new file mode 100644
index 0000000000..105fd77566
--- /dev/null
+++ b/drizzle-kit/tests/postgres/schemas/schema1.ts
@@ -0,0 +1,1137 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	AnyPgColumn,
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	check,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	index,
+	inet,
+	integer,
+	interval,
+	jsonb,
+	numeric,
+	pgEnum,
+	pgPolicy,
+	pgSchema,
+	pgSequence,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+} from 'drizzle-orm/pg-core';
+
+// generated with AI and updated manually in some places
+
+export const core = pgSchema('core');
+export const analytics = pgSchema('analytics');
+export const billing = pgSchema('billing');
+export const monitoring = pgSchema('monitoring');
+export const alertAction = pgEnum('alert_action', ['email', 'pagerd/ut"\'y', 'slack', 'webhook']);
+export const currencyCode = pgEnum('currency_code', ['USD', 'EUR', 'GBP', 'UAH', 'JPY']);
+export const datasetVisibility = pgEnum('dataset_visibility', ['priv"ate', 'team', 'public']);
+export const env = pgEnum('env', ['dev', 'staging', 'prod']);
+export const featureState = pgEnum('feature_state', ['enabled', 'disabled', 'gradual']);
+export const invoiceStatus = pgEnum('invoice_status', ['draft', "iss'ued", 'paid', 'voided', 'failed']);
+export const jobState = pgEnum('job_state', ['queued', 'running', 'success', 'failed', 'cancelled']);
+export const notificationChannel = pgEnum('notification_channel', ['email', 'sms', 'in_app', 'webhook']);
+export const paymentMethod = pgEnum('payment_method', ['card', 'bank_transfer', 'paypal', 'crypto']);
+export const pipelineStatus = pgEnum('pipeline_status', ['created', 'running', 'paused', 'completed', 'errored']);
+export const roleKind = pgEnum('role_kind', ['system', 'custom']);
+export const ruleConditionOperator = pgEnum('rule_condition_operator', [
+	'eq',
+	'neq',
+	'gt',
+	'lt',
+	'gte',
+	'lte',
+	'in',
+	'nin',
+]);
+export const severityLevel = pgEnum('severity_level', ['low', 'medium', 'high', 'critical']);
+export const userStatus = pgEnum('user_status', ['active', 'inactive', 'suspended', 'pending']);
+
+export const seqOrgCode = pgSequence('seq_org_code', {
+	startWith: '1000',
+	increment: '1',
+	minValue: '1',
+	maxValue: '9223372036854775807',
+	cache: '1',
+	cycle: false,
+});
+
+export const organizationsInCore = core.table('organizations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: bigint({ mode: 'number' }).default(sql`nextval('seq_org_code'::regclass)`).notNull(),
+	name: text().notNull(),
+	domain: text(),
+	currency: currencyCode().default('EUR').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_org_name_idx').using('btree', table.name.asc().nullsLast().op('text_ops')),
+	index('organizations_code_idx').using('btree', table.code.asc().nullsLast().op('int8_ops')),
+	unique('organizations_domain_key').on(table.domain),
+	check('organizations_name_check', sql`char_length(name) > 1`),
+]);
+
+export const usersInCore = core.table('users', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	username: text().notNull(),
+	status: userStatus().default('pending').notNull(),
+	locale: text().default('en-US').notNull(),
+	lastLogin: timestamp('last_login', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	bio: text().$onUpdate(() => sql`bio || 'some test'`),
+	profile: jsonb(),
+}, (table) => [
+	index('core_users_username_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.username.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'users_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('users_org_username_unique').on(table.organizationId, table.username),
+]);
+
+export const rolesInCore = core.table('roles', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull().references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+	name: text().notNull(),
+	kind: roleKind().default('custom').notNull(),
+	builtin: boolean().default(false).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	unique('roles_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const permissionsInCore = core.table('permissions', {
+	id: serial().primaryKey().notNull(),
+	code: text().notNull().unique(),
+	description: text(),
+});
+
+export const membershipsInCore = core.table('memberships', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	roleId: integer('role_id').notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	joinedAt: timestamp('joined_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'memberships_user_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'memberships_role_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'memberships_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('unique_membership').on(table.userId, table.organizationId),
+]);
+
+export const apiKeysInCore = core.table('api_keys', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	userId: uuid('user_id'),
+	name: text().notNull(),
+	keyHash: text('key_hash').notNull(),
+	revoked: boolean().default(false).notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb().generatedAlwaysAs(sql`'{"some":"test"}'`),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_apikey_org_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(revoked = false)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'api_keys_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'api_keys_user_id_fkey',
+	}).onDelete('set null'),
+	unique('api_keys_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const sessionsInCore = core.table('sessions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	ip: inet(),
+	userAgent: text('user_agent'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }).notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	index('core_sessions_user_expires').using(
+		'btree',
+		table.userId.asc().nullsLast(),
+		table.expiresAt.asc().nullsLast().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'sessions_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const oauthProvidersInCore = core.table('oauth_providers', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	provider: text().notNull(),
+	clientId: text('client_id').notNull(),
+	clientSecret: text('client_secret').notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'oauth_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('oauth_providers_organization_id_provider_key').on(table.organizationId, table.provider),
+]);
+
+export const featureFlagsInCore = core.table('feature_flags', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	state: featureState().default('disabled').notNull(),
+	rolloutPercent: smallint('rollout_percent').default(0),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'feature_flags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('feature_flags_organization_id_key_key').on(table.organizationId, table.key),
+	check('feature_flags_rollout_percent_check', sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`),
+]);
+
+export const projectsInCore = core.table('projects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	slug: text().notNull(),
+	description: text(),
+	visibility: datasetVisibility().default('priv"ate').notNull(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_projects_org_name_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.name.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'projects_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'projects_created_by_fkey',
+	}),
+	unique('projects_org_slug_unique').on(table.organizationId, table.slug),
+]);
+
+export const repositoriesInCore = core.table('repositories', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	provider: text().notNull(),
+	repoOwner: text('repo_owner').notNull(),
+	repoName: text('repo_name').notNull(),
+	defaultBranch: text('default_branch').default('main').notNull(),
+	cloneUrl: text('clone_url'),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'repositories_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('repositories_project_id_provider_repo_owner_repo_name_key').on(
+		table.projectId,
+		table.provider,
+		table.repoOwner,
+		table.repoName,
+	),
+]);
+
+export const buildsInCore = core.table('builds', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	triggeredBy: uuid('triggered_by'),
+	commitSha: char('commit_sha', { length: 40 }).notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	index('core_builds_project_status_idx').using(
+		'btree',
+		table.projectId.asc().nullsLast().op('uuid_ops'),
+		table.status.asc().nullsLast(),
+	),
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'builds_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.triggeredBy],
+		foreignColumns: [usersInCore.id],
+		name: 'builds_triggered_by_fkey',
+	}),
+	unique('builds_project_id_commit_sha_key').on(table.projectId, table.commitSha),
+]);
+
+export const pipelinesInCore = core.table('pipelines', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	name: text().notNull(),
+	spec: jsonb().notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'pipelines_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipelines_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const pipelineRunsInAnalytics = analytics.table('pipeline_runs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineId: uuid('pipeline_id').notNull(),
+
+	runNumber: bigint('run_number', { mode: 'number' }).notNull(),
+	state: jobState().default('queued').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	logs: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_pipeline_runs_state_idx').using('btree', table.state.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.pipelineId],
+		foreignColumns: [pipelinesInCore.id],
+		name: 'pipeline_runs_pipeline_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipeline_runs_unique_run').on(table.pipelineId, table.runNumber),
+]);
+
+export const jobsInAnalytics = analytics.table('jobs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineRunId: uuid('pipeline_run_id'),
+	name: text().notNull(),
+	state: jobState().default('queued').notNull(),
+	attempts: integer().default(0).notNull(),
+	lastError: text('last_error'),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_jobs_state_attempts_idx').using(
+		'btree',
+		table.state.asc().nullsLast(),
+		table.attempts.asc().nullsLast().op('int4_ops'),
+	),
+	foreignKey({
+		columns: [table.pipelineRunId],
+		foreignColumns: [pipelineRunsInAnalytics.id],
+		name: 'jobs_pipeline_run_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const storageBucketsInCore = core.table('storage_buckets', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	region: text().notNull(),
+	config: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'storage_buckets_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('storage_buckets_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const objectsInCore = core.table('objects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	bucketId: uuid('bucket_id').notNull(),
+	path: text().notNull(),
+
+	size: bigint({ mode: 'number' }).default(0).notNull(),
+	contentType: text('content_type'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_objects_bucket_path_gin').using('gin', table.metadata.asc().nullsLast().op('jsonb_ops')),
+	foreignKey({
+		columns: [table.bucketId],
+		foreignColumns: [storageBucketsInCore.id],
+		name: 'objects_bucket_id_fkey',
+	}).onDelete('cascade'),
+	unique('objects_bucket_id_path_key').on(table.bucketId, table.path),
+]);
+
+export const filesInCore = core.table('files', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	name: text().notNull(),
+	latestObjectId: uuid('latest_object_id'),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'files_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.latestObjectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'files_latest_object_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'files_created_by_fkey',
+	}),
+	unique('files_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const fileVersionsInCore = core.table('file_versions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	fileId: uuid('file_id').notNull(),
+	objectId: uuid('object_id').notNull(),
+	versionNumber: integer('version_number').notNull(),
+	checksum: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.fileId],
+		foreignColumns: [filesInCore.id],
+		name: 'file_versions_file_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.objectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'file_versions_object_id_fkey',
+	}).onDelete('cascade'),
+	unique('file_versions_file_id_version_number_key').on(table.fileId, table.versionNumber),
+]);
+
+export const tagsInCore = core.table('tags', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	value: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'tags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('tags_organization_id_key_value_key').on(table.organizationId, table.key, table.value),
+]);
+
+export const conversationsInCore = core.table('conversations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	title: text(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'conversations_project_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'conversations_created_by_fkey',
+	}),
+]);
+
+export const chatMessagesInCore = core.table('chat_messages', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	conversationId: uuid('conversation_id').notNull(),
+	senderId: uuid('sender_id'),
+	body: text().notNull(),
+	attachments: jsonb(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	editedAt: timestamp('edited_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	index('core_chat_conv_sent_at_idx').using(
+		'btree',
+		table.conversationId.asc().nullsLast(),
+		table.sentAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.conversationId],
+		foreignColumns: [conversationsInCore.id],
+		name: 'chat_messages_conversation_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.senderId],
+		foreignColumns: [usersInCore.id],
+		name: 'chat_messages_sender_id_fkey',
+	}).onDelete('set null'),
+]);
+
+export const notificationsInCore = core.table('notifications', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	channel: notificationChannel().default('in_app').notNull(),
+	payload: jsonb().notNull(),
+	seen: boolean().default(false).notNull(),
+	deliveredAt: timestamp('delivered_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_notifications_unseen_idx').using('btree', table.userId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(seen = false)`,
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'notifications_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const customersInBilling = billing.table('customers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	name: text().notNull(),
+	address: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'customers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('customers_organization_id_key').on(table.organizationId),
+	unique('idnameunique').on(table.id, table.name),
+]);
+
+export const subscriptionsInBilling = billing.table('subscriptions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	plan: text().notNull(),
+	status: text().default('active').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	endedAt: timestamp('ended_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'subscriptions_customer_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const paymentsInBilling = billing.table('payments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	invoiceId: uuid('invoice_id').notNull(),
+	paidAt: timestamp('paid_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	amount: numeric({ precision: 12, scale: 2 }).notNull(),
+	amount2: decimal({ precision: 12, scale: 2 }).notNull(),
+	method: paymentMethod().notNull(),
+	transactionRef: text('transaction_ref'),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.invoiceId],
+		foreignColumns: [invoicesInBilling.id],
+		name: 'payments_invoice_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const couponsInBilling = billing.table('coupons', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+	discountPercent: smallint('discount_percent'),
+	redeemableFrom: timestamp('redeemable_from', { withTimezone: true, mode: 'string' }),
+	redeemableTo: timestamp('redeemable_to', { withTimezone: true, mode: 'string' }),
+	maxRedemptions: integer('max_redemptions').generatedAlwaysAsIdentity(),
+	metadata: jsonb(),
+}, (table) => [
+	unique('coupons_code_key').on(table.code),
+	check('coupons_discount_percent_check', sql`(discount_percent >= 0) AND (discount_percent <= 100)`),
+]);
+
+export const webhooksInCore = core.table('webhooks', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	url: text().notNull(),
+	secret: text(),
+	events: text().array().notNull(),
+	active: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_webhooks_org_active_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(active = true)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'webhooks_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const metricSourcesInAnalytics = analytics.table('metric_sources', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'metric_sources_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('metric_sources_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const metricsInAnalytics = analytics.table('metrics', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	sourceId: uuid('source_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	ts: timestamp({ withTimezone: true, mode: 'string' }).notNull(),
+	value: doublePrecision().notNull(),
+	tags: jsonb(),
+}, (table) => [
+	index('analytics_metrics_key_ts_idx').using(
+		'btree',
+		table.metricKey.asc().nullsLast().op('text_ops'),
+		table.ts.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.sourceId],
+		foreignColumns: [metricSourcesInAnalytics.id],
+		name: 'metrics_source_id_fkey',
+	}).onDelete('cascade'),
+	unique('metrics_source_id_metric_key_ts_key').on(table.sourceId, table.metricKey, table.ts),
+]);
+
+export const alertRulesInMonitoring = monitoring.table('alert_rules', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	description: text(),
+	severity: severityLevel().default('medium').notNull(),
+	enabled: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'alert_rules_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('alert_rules_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const ruleConditionsInMonitoring = monitoring.table('rule_conditions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	operator: ruleConditionOperator().notNull().unique('some_name', { nulls: 'not distinct' }),
+	threshold: doublePrecision().notNull(),
+	window: interval().default('00:05:00').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'rule_conditions_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const alertsInMonitoring = monitoring.table('alerts', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	triggeredAt: timestamp('triggered_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	resolvedAt: timestamp('resolved_at', { withTimezone: true, mode: 'string' }),
+	payload: jsonb(),
+	state: text().default('firing').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'alerts_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const escalationsInMonitoring = monitoring.table('escalations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	alertId: uuid('alert_id').notNull(),
+	action: alertAction().notNull(),
+	target: text().notNull(),
+	executedAt: timestamp('executed_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	foreignKey({
+		columns: [table.alertId],
+		foreignColumns: [alertsInMonitoring.id],
+		name: 'escalations_alert_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const ssoProvidersInCore = core.table('sso_providers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	config: jsonb().notNull(),
+	enabled: boolean().default(false).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'sso_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const auditLogsInCore = core.table('audit_logs', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	actorId: uuid('actor_id'),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').array('[][][]'),
+	action: text().notNull(),
+	beforeState: jsonb('before_state'),
+	afterState: jsonb('after_state'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_audit_org_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.createdAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+]);
+
+export const rateLimitsInCore = core.table('rate_limits', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	apiKeyId: uuid('api_key_id').notNull(),
+	windowStart: timestamp('window_start', { withTimezone: true, mode: 'string' }).notNull(),
+	requests: integer().generatedByDefaultAsIdentity().notNull(),
+	limit: integer().generatedAlwaysAs(() => sql`1`).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.apiKeyId],
+		foreignColumns: [apiKeysInCore.id],
+		name: 'rate_limits_api_key_id_fkey',
+	}).onDelete('cascade'),
+	unique('rate_limits_api_key_id_window_start_key').on(table.apiKeyId, table.windowStart).nullsNotDistinct(),
+]);
+
+export const experimentsInCore = core.table('experiments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'experiments_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiments_organization_id_key_key').on(table.organizationId, table.key),
+]);
+
+export const experimentVariantsInCore = core.table('experiment_variants', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	name: text().notNull(),
+	allocationPercent: smallint('allocation_percent').default(0).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_variants_experiment_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_variants_experiment_id_name_key').on(table.experimentId, table.name),
+	check('experiment_variants_allocation_percent_check', sql`(allocation_percent >= 0) AND (allocation_percent <= 100)`),
+]);
+
+export const experimentAssignmentsInCore = core.table('experiment_assignments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	variantId: uuid('variant_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_assignments_experiment_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.variantId],
+		foreignColumns: [experimentVariantsInCore.id],
+		name: 'experiment_assignments_variant_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'experiment_assignments_user_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_assignments_experiment_id_user_id_key').on(table.experimentId, table.userId),
+]);
+
+export const deploymentsInCore = core.table('deployments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	environment: env().default('dev').notNull(),
+	version: text().notNull(),
+	deployedBy: uuid('deployed_by'),
+	deployedAt: timestamp('deployed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	notes: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'deployments_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.deployedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'deployments_deployed_by_fkey',
+	}),
+	unique('deployments_project_id_environment_version_key').on(table.projectId, table.environment, table.version),
+]);
+
+export const servicesInCore = core.table('services', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	kind: text(),
+	ownerId: uuid('owner_id'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string', precision: 6 }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'services_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.ownerId],
+		foreignColumns: [usersInCore.id],
+		name: 'services_owner_id_fkey',
+	}),
+	unique('services_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const locksInCore = core.table('locks', {
+	name: text().primaryKey().notNull(),
+	owner: text(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string', precision: 2 }),
+});
+
+export const entitiesInCore = core.table('entities', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	data: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'entities_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const taskQueueInAnalytics = analytics.table('task_queue', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	queueName: text('queue_name').default('default').notNull(),
+	payload: jsonb().notNull(),
+	priority: smallint().default(100).notNull(),
+	reserved: boolean().default(false).notNull(),
+	reservedUntil: timestamp('reserved_until', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex('analytics_task_queue_unique_unreserved').using(
+		'btree',
+		sql`queue_name`,
+		sql`((payload ->> 'task_type'::text))`,
+	).where(sql`(reserved = false)`),
+]);
+
+export const invoicesInBilling = billing.table('invoices', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	number: text().notNull(),
+	issuedAt: timestamp('issued_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	dueAt: timestamp('due_at', { withTimezone: true, mode: 'string' }),
+	totalAmount: numeric('total_amount', { precision: 12, scale: 2 }).default('0.0').notNull(),
+	currency: currencyCode().default('USD').notNull(),
+	status: invoiceStatus().default('draft').notNull(),
+	notes: text(),
+}, (table) => [
+	index('billing_invoices_status_idx').using('btree', table.status.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.customerId, table.number],
+		foreignColumns: [customersInBilling.id, customersInBilling.name],
+		name: 'invoices_customer_id_fkey',
+	}).onDelete('cascade'),
+	unique('invoices_customer_id_number_key').on(table.customerId, table.number),
+	check('invoices_total_nonnegative', sql`total_amount >= (0)::numeric`),
+]);
+
+export const aliasesInCore = core.table('aliases', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	alias: text().notNull().unique('unique_with_name'),
+	organizationId: uuid('organization_id'),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'aliases_organization_id_fkey',
+	}).onUpdate('cascade'),
+	unique('aliases_object_type_object_id_alias_key').on(table.objectType, table.objectId, table.alias),
+]);
+
+export const selfRef = core.table('self_ref', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull().unique().references((): AnyPgColumn => selfRef.organizationId),
+	organizationId: text('organization_id').notNull().unique(),
+});
+
+export const couponRedemptionsInBilling = billing.table('coupon_redemptions', {
+	couponId: uuid('coupon_id').notNull(),
+	customerId: uuid('customer_id').notNull(),
+	redeemedAt: timestamp('redeemed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.couponId],
+		foreignColumns: [couponsInBilling.id],
+		name: 'coupon_redemptions_coupon_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'coupon_redemptions_customer_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.couponId, table.customerId], name: 'coupon_redemptions_pkey' }),
+]);
+
+export const entityLinksInCore = core.table('entity_links', {
+	parentEntityId: uuid('parent_entity_id').notNull(),
+	childEntityId: uuid('child_entity_id').notNull(),
+	relationship: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.parentEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_parent_entity_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.childEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_child_entity_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.parentEntityId, table.childEntityId, table.relationship], name: 'entity_links_pkey' }),
+]);
+
+export const rolePermissionsInCore = core.table('role_permissions', {
+	roleId: integer('role_id').notNull(),
+	permissionId: integer('permission_id').notNull(),
+	assignedBy: uuid('assigned_by'),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'role_permissions_role_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.permissionId],
+		foreignColumns: [permissionsInCore.id],
+		name: 'role_permissions_permission_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.assignedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'role_permissions_assigned_by_fkey',
+	}),
+	primaryKey({ columns: [table.roleId, table.permissionId], name: 'role_permissions_pkey' }),
+]);
+
+export const taggingsInCore = core.table('taggings', {
+	tagId: integer('tag_id').notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.tagId],
+		foreignColumns: [tagsInCore.id],
+		name: 'taggings_tag_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.tagId, table.objectType, table.objectId], name: 'taggings_pkey' }),
+]);
+
+export const reactionsInCore = core.table('reactions', {
+	messageId: uuid('message_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	reaction: text().notNull().array(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.messageId],
+		foreignColumns: [chatMessagesInCore.id],
+		name: 'reactions_message_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'reactions_user_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.messageId, table.userId, table.reaction], name: 'reactions_pkey' }),
+]);
+
+// views
+export const projectSearchInAnalytics = analytics.materializedView('project_search', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().as(
+		sql`SELECT id, name, slug, description FROM core.projects p`,
+	);
+
+export const projectSearchInAnalytics2 = analytics.materializedView('project_search2', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().existing();
+
+export const vActiveUsersInCore = core.view('v_active_users').as((qb) =>
+	qb.select({
+		id: usersInCore.id,
+		username: usersInCore.username,
+		organization_id: usersInCore.organizationId,
+	}).from(usersInCore).where(eq(usersInCore.status, 'active'))
+);
+export const vActiveUsersInCore2 = core.view('v_active_users2', {}).existing();
+
+// polices
+export const rls = pgSchema('rls');
+export const documentsInRls = rls.table('documents', {
+	docId: uuid('doc_id').defaultRandom().primaryKey().notNull(),
+	ownerId: uuid('owner_id').notNull(),
+	title: text().notNull(),
+	content: text().notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('documents_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(owner_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('documents_update_own', { as: 'permissive', for: 'update', to: ['public'] }),
+	pgPolicy('documents_select_own', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const messagesInRls = rls.table.withRLS('messages', {
+	msgId: uuid('msg_id').defaultRandom().primaryKey().notNull(),
+	senderId: uuid('sender_id').notNull(),
+	recipientId: uuid('recipient_id').notNull(),
+	message: text().notNull(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('messages_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(sender_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('messages_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const projectsInRls = rls.table('projects', {
+	projectId: uuid('project_id').defaultRandom().primaryKey().notNull(),
+	name: text().notNull(),
+	description: text(),
+	ownerId: uuid('owner_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('projects_visibility', {
+		as: 'permissive',
+		for: 'select',
+		to: ['public'],
+		using: sql`((owner_id = (CURRENT_USER)::uuid) OR (project_id IN ( SELECT pm.project_id
+   FROM rls.project_members pm
+  WHERE (pm.user_id = (CURRENT_USER)::uuid))))`,
+	}),
+]);
+
+export const projectMembersInRls = rls.table.withRLS('project_members', {
+	projectId: uuid('project_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	role: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInRls.projectId],
+		name: 'project_members_project_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.projectId, table.userId], name: 'project_members_pkey' }),
+	pgPolicy('project_members_manage', {
+		as: 'permissive',
+		for: 'all',
+		to: ['public'],
+		using: sql`(project_id IN ( SELECT p.project_id
+   FROM rls.projects p
+  WHERE (p.owner_id = (CURRENT_USER)::uuid)))`,
+	}),
+	pgPolicy('project_members_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+	check('project_members_role_check', sql`role = ANY (ARRAY['member'::text, 'admin'::text])`),
+]);
+
+export const policy = pgPolicy('new_policy', {
+	as: 'restrictive',
+	to: 'postgres',
+	withCheck: sql`1 = 1`,
+	for: 'all',
+}).link(organizationsInCore);
diff --git a/drizzle-kit/tests/postgres/serializer-snapshot.test.ts b/drizzle-kit/tests/postgres/serializer-snapshot.test.ts
new file mode 100644
index 0000000000..4446cdc9a9
--- /dev/null
+++ b/drizzle-kit/tests/postgres/serializer-snapshot.test.ts
@@ -0,0 +1,2345 @@
+import { sql } from 'drizzle-orm';
+import {
+	check,
+	index,
+	integer,
+	pgEnum,
+	pgPolicy,
+	pgRole,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	pgView,
+	primaryKey,
+	unique,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { PostgresEntity } from 'src/dialects/postgres/ddl';
+import { generateLatestSnapshot } from 'src/dialects/postgres/serializer';
+import { PostgresSnapshot } from 'src/dialects/postgres/snapshot';
+import { JsonStatement } from 'src/dialects/postgres/statements';
+import { describe, expect, test } from 'vitest';
+import { diff, drizzleToDDL, PostgresSchema } from './mocks';
+
+const originId = '00000000-0000-0000-0000-000000000000';
+
+async function applyTransition(config: {
+	from: PostgresSchema;
+	to: PostgresSchema;
+	renames: string[];
+}) {
+	const { from, renames, to } = config;
+
+	const base: PostgresSnapshot = {
+		version: '8',
+		dialect: 'postgres',
+		id: 'snapshot-id',
+		prevIds: [originId],
+		ddl: drizzleToDDL(from).ddl.entities.list(),
+		renames: [],
+	};
+
+	const { statements } = await diff(from, to, renames ?? []);
+	const actual = generateLatestSnapshot(base, statements);
+	const expected = {
+		...base,
+		ddl: drizzleToDDL(to).ddl.entities.list(),
+	};
+
+	// sort keys alphabetically
+	const stable = (value: unknown): unknown => {
+		if (Array.isArray(value)) {
+			return value.map(stable);
+		}
+		if (value && typeof value === 'object') {
+			return Object.fromEntries(
+				Object.entries(value as Record<string, unknown>)
+					.sort(([left], [right]) => left.localeCompare(right))
+					.map(([key, entry]) => [key, stable(entry)]),
+			);
+		}
+		return value;
+	};
+
+	// normalization engine
+	// sort array of stringified ddl entries
+	const ddlEntries = (ddl: PostgresEntity[]) =>
+		ddl
+			.map((entry) => JSON.stringify(stable(entry)))
+			.sort((left, right) => left.localeCompare(right));
+
+	const fromTs = { ...expected, ddl: ddlEntries(actual.ddl) };
+	const afterPatch = { ...actual, ddl: ddlEntries(actual.ddl) };
+
+	return { fromTs, afterPatch, statements };
+}
+
+describe('transition tests', () => {
+	test('create table', async () => {
+		const from = {};
+		const to = { users: pgTable('users', { id: integer('id') }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['create_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop table', async () => {
+		const from = { users: pgTable('users', { id: integer('id') }) };
+		const to = {};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename table', async () => {
+		const from = { users: pgTable('users', { id: integer('id') }) };
+		const to = { customers: pgTable('customers', { id: integer('id') }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users->public.customers'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename table that has other entities', async () => {
+		const test = pgTable('test', {
+			id: integer('id'),
+		});
+		const users = pgTable(
+			'users',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubs = pgTable('users_subsc', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => users.id),
+			subId: varchar('sub_id'),
+		});
+		const from = {
+			test,
+			users: users,
+			usersSubs: usersSubs,
+		};
+
+		const usersTo = pgTable(
+			'users_renamed',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubsTo = pgTable('users_subsc', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => usersTo.id),
+			subId: varchar('sub_id'),
+		});
+		const to = {
+			test,
+			users: usersTo,
+			usersSubs: usersSubsTo,
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users->public.users_renamed'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('move table to another schema', async () => {
+		const analytics = pgSchema('analytics');
+		const from = {
+			analytics,
+			users: pgTable('users', {
+				id: integer('id'),
+			}),
+		};
+		const to = {
+			analytics,
+			users: analytics.table('users', {
+				id: integer('id'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['move_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users->analytics.users'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('move table to another schema. Table has other entities', async () => {
+		const analytics = pgSchema('analytics');
+		const test = pgTable('test', {
+			id: integer('id'),
+		});
+
+		const users = pgTable(
+			'users',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubs = pgTable('users_subs', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => users.id),
+			subId: varchar('sub_id'),
+		});
+		const from = {
+			analytics,
+			test,
+			users: users,
+			usersSubs: usersSubs,
+		};
+
+		const usersTo = analytics.table(
+			'users',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubsTo = pgTable('users_subs', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => usersTo.id),
+			subId: varchar('sub_id'),
+		});
+		const to = {
+			analytics,
+			test,
+			users: usersTo,
+			usersSubs: usersSubsTo,
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['move_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users->analytics.users'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('move table to another schema + rename table. Table has other entities', async () => {
+		const analytics = pgSchema('analytics');
+		const test = pgTable('test', {
+			id: integer('id'),
+		});
+
+		const users = pgTable(
+			'users',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubs = pgTable('users_subs', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => users.id),
+			subId: varchar('sub_id'),
+		});
+		const from = {
+			analytics,
+			test,
+			users: users,
+			usersSubs: usersSubs,
+		};
+
+		const usersTo = analytics.table(
+			'users_renamed',
+			{
+				id: integer('id'),
+				name: varchar('name'),
+				test_id: integer('test_id').references(() => test.id),
+				age: integer('age'),
+				test: integer('test'),
+			},
+			(t) => [
+				check('age_check', sql`${t.age} > 18`),
+				index('users_name_idx').on(t.name),
+				unique().on(t.test),
+			],
+		);
+		const usersSubsTo = pgTable('users_subs', {
+			id: integer('id'),
+			userId: integer('user_id').references(() => usersTo.id),
+			subId: varchar('sub_id'),
+		});
+		const to = {
+			analytics,
+			test,
+			users: usersTo,
+			usersSubs: usersSubsTo,
+		};
+
+		const expectedTypes: JsonStatement['type'][] = [
+			'rename_table',
+			'move_table',
+		];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users->analytics.users_renamed'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('remove custom schema from table', async () => {
+		const analytics = pgSchema('analytics');
+		const from = {
+			analytics,
+
+			users: analytics.table('users', {
+				id: integer('id'),
+			}),
+		};
+		const to = {
+			analytics,
+			users: pgTable('users', {
+				id: integer('id'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['move_table'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['analytics.users->public.users'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add column', async () => {
+		const from = { users: pgTable('users', { id: integer('id') }) };
+		const to = {
+			users: pgTable('users', { id: integer('id'), age: integer('age') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_column'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop column', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id'), age: integer('age') }),
+		};
+		const to = { users: pgTable('users', { id: integer('id') }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_column'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename column', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id'), age: integer('age') }),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id'), years: integer('years') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_column'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users.age->public.users.years'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter column', async () => {
+		const from = { users: pgTable('users', { id: integer('id') }) };
+		const to = {
+			users: pgTable('users', { id: integer('id').notNull().default(0) }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_column'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('recreate_column', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id').generatedAlwaysAs(sql`13`) }),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id').generatedAlwaysAs(sql`15`) }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['recreate_column'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add index', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id'), age: integer('age') }),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [index('users_age_idx').on(t.age)],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['create_index'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop index', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [index('users_age_idx').on(t.age)],
+			),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id'), age: integer('age') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_index'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename index', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [index('users_age_idx').on(t.age)],
+			),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [index('users_age_index').on(t.age)],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_index'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users.users_age_idx->public.users.users_age_index'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('recreate index', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [index('users_age_idx').on(t.age)],
+			),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), age: integer('age') },
+				(t) => [uniqueIndex('users_age_idx').on(t.age)],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['recreate_index'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add pk to notNull', async () => {
+		const from = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id] })],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add pk to nullable', async () => {
+		const from = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.name] })],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add composite pk #1', async () => {
+		const from = {
+			users: pgTable('users', {
+				id: integer('id'),
+				name: integer('name'),
+			}),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id, t.name] })],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add composite pk #2', async () => {
+		const from = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id, t.name] })],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop pk from notNull', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id] })],
+			),
+		};
+		const to = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop pk from nullable', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id] })],
+			),
+		};
+		const to = {
+			users: pgTable('users', {
+				id: integer('id'),
+				name: integer('name'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_column', 'drop_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop composite pk #1', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), name: integer('name') },
+				(t) => [primaryKey({ columns: [t.id, t.name] })],
+			),
+		};
+		const to = {
+			users: pgTable('users', {
+				id: integer('id'),
+				name: integer('name'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = [
+			'alter_column',
+			'alter_column',
+			'drop_pk',
+		];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop composite pk #2', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name').notNull() },
+				(t) => [primaryKey({ columns: [t.id, t.name] })],
+			),
+		};
+		const to = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name').notNull(),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter pk', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name').notNull() },
+				(t) => [primaryKey({ columns: [t.id] })],
+			),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name').notNull() },
+				(t) => [primaryKey({ columns: [t.id, t.name] })],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_pk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create fk', async () => {
+		const parentRef = pgTable('parent_ref', { id: integer('id').primaryKey() });
+
+		const from = {
+			parentRef,
+			childRef: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id'),
+			}),
+		};
+		const to = {
+			parentRef,
+			childRefCascade: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id').references(() => parentRef.id, {
+					onDelete: 'cascade',
+				}),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['create_fk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop fk', async () => {
+		const parentRef = pgTable('parent_ref', { id: integer('id').primaryKey() });
+
+		const from = {
+			parentRef,
+			childRefCascade: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id').references(() => parentRef.id, {
+					onDelete: 'cascade',
+				}),
+			}),
+		};
+		const to = {
+			parentRef,
+			childRef: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_fk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('recreate fk', async () => {
+		const parentRef = pgTable('parent_ref', { id: integer('id').primaryKey() });
+
+		const from = {
+			parentRef,
+			childRef: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id').references(() => parentRef.id),
+			}),
+		};
+		const to = {
+			parentRef,
+			childRefCascade: pgTable('child_ref', {
+				id: integer('id').primaryKey(),
+				parentId: integer('parent_id').references(() => parentRef.id, {
+					onDelete: 'cascade',
+				}),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['recreate_fk'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add unique constraint', async () => {
+		const from = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [unique('users_name_idx').on(t.name)],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_unique'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop unique constraint', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [unique('users_name_idx').on(t.name)],
+			),
+		};
+		const to = {
+			users: pgTable('users', {
+				id: integer('id').notNull(),
+				name: integer('name'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_unique'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter unique constraint', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [unique('users_name_idx').on(t.name)],
+			),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id').notNull(), name: integer('name') },
+				(t) => [unique('users_name_idx').on(t.name, t.id)],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_unique'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('add check constraint', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }, (t) => [
+				check('users_id_chk', sql`${t.id} > 0`),
+			]),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['add_check'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop check constraint', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }, (t) => [
+				check('users_id_chk', sql`${t.id} > 0`),
+			]),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_check'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter check constraint', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }, (t) => [
+				check('users_id_chk', sql`${t.id} > 0`),
+			]),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }, (t) => [
+				check('users_id_chk', sql`${t.id} < 0`),
+			]),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_check'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename constraint', async () => {
+		const from = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), name: varchar('name') },
+				(t) => [
+					check('users_id_chk', sql`${t.id} > 0`),
+					unique('users_name_idx').on(t.name),
+				],
+			),
+		};
+		const to = {
+			users: pgTable(
+				'users',
+				{ id: integer('id'), name: varchar('name') },
+				(t) => [
+					check('users_id_check', sql`${t.id} > 0`),
+					unique('users_name_idx').on(t.name),
+				],
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_constraint'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users.users_id_chk->public.users.users_id_check'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create schema', async () => {
+		const dev = pgSchema('dev');
+
+		const from = {};
+		const to = { dev };
+
+		const expectedTypes: JsonStatement['type'][] = ['create_schema'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop schema', async () => {
+		const dev = pgSchema('dev');
+		const analytics = pgSchema('analytics');
+
+		const from = { dev, analytics };
+		const to = { analytics };
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_schema'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename schema', async () => {
+		const dev = pgSchema('dev');
+		const analytics = pgSchema('analytics');
+
+		const from = { dev, users: dev.table('users', { id: integer('id') }) };
+		const to = {
+			analytics,
+			users: analytics.table('users', { id: integer('id') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_schema'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['dev->analytics'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create enum', async () => {
+		const statusA = pgEnum('status', ['a', 'b']);
+
+		const from = {
+			items: pgTable('items', {
+				id: integer('id'),
+			}),
+		};
+		const to = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['create_enum'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop enum', async () => {
+		const statusA = pgEnum('status', ['a', 'b']);
+
+		const from = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+			}),
+		};
+		const to = {
+			items: pgTable('items', {
+				id: integer('id'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_enum'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename enum', async () => {
+		const statusA = pgEnum('status', ['a', 'b']);
+		const renamedStatus = pgEnum('status_renamed', ['a', 'b']);
+
+		const from = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+				statusEnum: statusA('status'),
+			}),
+		};
+		const to = {
+			statusA: renamedStatus,
+			items: pgTable('items', {
+				id: integer('id'),
+				statusEnum: renamedStatus('status'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_enum'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.status->public.status_renamed'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create schema + move enum to other schema', async () => {
+		const dev = pgSchema('dev');
+		const statusA = pgEnum('status', ['a', 'b']);
+		const movedStatusA = pgSchema('dev').enum('status', ['a', 'b']);
+
+		const from = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: statusA('status'),
+			}),
+		};
+		const to = {
+			dev,
+			statusA: movedStatusA,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: movedStatusA('status'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = [
+			'create_schema',
+			'move_enum',
+		];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.status->dev.status'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter enum (add value)', async () => {
+		const statusA = pgEnum('status', ['a', 'b']);
+		const statusAB = pgEnum('status', ['a', 'b', 'c']);
+
+		const from = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: statusA('status'),
+			}),
+		};
+		const to = {
+			statusAB,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: statusAB('status'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_enum'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter enum (drop value)', async () => {
+		const statusA = pgEnum('status', ['a', 'b']);
+		const statusAB = pgEnum('status', ['a', 'b', 'c']);
+
+		const from = {
+			statusAB,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: statusAB('status'),
+			}),
+		};
+		const to = {
+			statusA,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: statusA('status'),
+			}),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['recreate_enum'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create sequence', async () => {
+		const from = {};
+		const to = { seq: pgSequence('id_seq', { increment: '10' }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['create_sequence'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter sequence', async () => {
+		const from = { seq: pgSequence('id_seq') };
+		const to = { seq: pgSequence('id_seq', { increment: '10' }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_sequence'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename sequence', async () => {
+		const from = { seq: pgSequence('id_seq') };
+		const to = { seqRenamed: pgSequence('id_seq_renamed') };
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_sequence'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.id_seq->public.id_seq_renamed'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('move sequence to another schema', async () => {
+		const dev = pgSchema('dev');
+
+		const from = { dev, seq: pgSequence('id_seq') };
+		const to = { dev, seq: dev.sequence('id_seq') };
+
+		const expectedTypes: JsonStatement['type'][] = ['move_sequence'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.id_seq->dev.id_seq'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create policy', async () => {
+		const users = pgTable.withRLS('users', { id: integer('id') });
+
+		const from = { users };
+		const to = {
+			users,
+			policy: pgPolicy('users_policy', { for: 'select', to: 'public' }).link(
+				users,
+			),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['create_policy'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop policy', async () => {
+		const users = pgTable.withRLS('users', { id: integer('id') });
+
+		const from = {
+			users,
+			policy: pgPolicy('users_policy', { for: 'select', to: 'public' }).link(
+				users,
+			),
+		};
+		const to = { users };
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_policy'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename policy', async () => {
+		const users = pgTable.withRLS('users', { id: integer('id') });
+
+		const from = {
+			users,
+			policy: pgPolicy('users_policy', { for: 'select', to: 'public' }).link(
+				users,
+			),
+		};
+		const to = {
+			users,
+			policy: pgPolicy('users_policy_renamed', {
+				for: 'select',
+				to: 'public',
+			}).link(users),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_policy'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.users.users_policy->public.users.users_policy_renamed'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter policy', async () => {
+		const users = pgTable.withRLS('users', { id: integer('id') });
+
+		const from = {
+			users,
+			policy: pgPolicy('users_policy', {
+				for: 'select',
+				to: 'public',
+				using: sql``,
+			}).link(users),
+		};
+		const to = {
+			users,
+			policy: pgPolicy('users_policy', {
+				for: 'select',
+				to: 'public',
+				using: sql`1`,
+			}).link(users),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_policy'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('recreate policy', async () => {
+		const users = pgTable.withRLS('users', { id: integer('id') });
+
+		const from = {
+			users,
+			policy: pgPolicy('users_policy', { for: 'select', to: 'public' }).link(
+				users,
+			),
+		};
+		const to = {
+			users,
+			policy: pgPolicy('users_policy', {
+				for: 'insert',
+				to: 'public',
+			}).link(users),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['recreate_policy'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter rls', async () => {
+		const from = {
+			users: pgTable.withRLS('users', { id: integer('id') }),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_rls'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('create role', async () => {
+		const from = {};
+		const to = { manager: pgRole('manager') };
+
+		const expectedTypes: JsonStatement['type'][] = ['create_role'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop role', async () => {
+		const from = { manager: pgRole('manager') };
+		const to = {};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_role'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename role', async () => {
+		const from = { manager: pgRole('manager') };
+		const to = { manager: pgRole('manager2') };
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_role'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['manager->manager2'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('alter role', async () => {
+		const from = { manager: pgRole('manager') };
+		const to = { manager: pgRole('manager', { createDb: true }) };
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_role'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	// TODO
+	// grant_privilege;
+	// revoke_privilege;
+	// regrant_privilege;
+
+	test('create view', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+			}).as(sql`SELECT id FROM users WHERE active = true`),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['create_view'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('drop view', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+			}).as(sql`SELECT id FROM users WHERE active = true`),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['drop_view'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('rename view', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+			}).as(sql`SELECT id FROM users WHERE active = true`),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+			active_customers: pgView('active_customers', {
+				id: integer('id'),
+			}).as(sql`SELECT id FROM users WHERE active = true`),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['rename_view'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.active_users->public.active_customers'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('move view to another schema', async () => {
+		const dev = pgSchema('dev');
+
+		const from = {
+			dev,
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+			}).as(sql`SELECT id FROM users WHERE active = true`),
+		};
+		const to = {
+			dev,
+			users: pgTable('users', { id: integer('id') }),
+			active_users: dev
+				.view('active_users', {
+					id: integer('id'),
+				})
+				.as(sql`SELECT id FROM users WHERE active = true`),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['move_view'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: ['public.active_users->dev.active_users'],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+
+	test('merge commutative branches with alter_enum (no duplicates)', async () => {
+		// Simulates 3 leaf branches forking from the same parent, each independently
+		// modifying the same enum. When merging, all their alter_enum statements are
+		// concatenated and applied to the parent snapshot. Previously this caused
+		// duplicate enum entries because the 2nd/3rd alter_enum's `from` didn't match
+		// the already-modified enum.
+		const parentEnum = pgEnum('status', ['a', 'b']);
+		const finalEnum = pgEnum('status', ['a', 'b', 'c', 'd', 'e']);
+
+		const parentSchema = {
+			statusEnum: parentEnum,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: parentEnum('status'),
+			}),
+		};
+
+		// Branch A: adds 'c'
+		const branchAEnum = pgEnum('status', ['a', 'b', 'c']);
+		const branchA = {
+			statusEnum: branchAEnum,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: branchAEnum('status'),
+			}),
+		};
+
+		// Branch B: adds 'd', 'e'
+		const branchBEnum = pgEnum('status', ['a', 'b', 'd', 'e']);
+		const branchB = {
+			statusEnum: branchBEnum,
+			items: pgTable('items', {
+				id: integer('id'),
+				status: branchBEnum('status'),
+			}),
+		};
+
+		// Get statements from each branch (parent -> branch)
+		const { statements: statementsA } = await diff(parentSchema, branchA, []);
+		const { statements: statementsB } = await diff(parentSchema, branchB, []);
+
+		// Combine all statements (simulates flatMap of leaf statements)
+		const combinedStatements = [...statementsA, ...statementsB];
+
+		const base: PostgresSnapshot = {
+			version: '8',
+			dialect: 'postgres',
+			id: 'snapshot-id',
+			prevIds: [originId],
+			ddl: drizzleToDDL(parentSchema).ddl.entities.list(),
+			renames: [],
+		};
+
+		const actual = generateLatestSnapshot(base, combinedStatements);
+
+		// The expected snapshot is what the final schema looks like
+		const expected = {
+			...base,
+			ddl: drizzleToDDL({
+				statusEnum: finalEnum,
+				items: pgTable('items', {
+					id: integer('id'),
+					status: finalEnum('status'),
+				}),
+			}).ddl.entities.list(),
+		};
+
+		const stable = (value: unknown): unknown => {
+			if (Array.isArray(value)) {
+				return value.map(stable);
+			}
+			if (value && typeof value === 'object') {
+				return Object.fromEntries(
+					Object.entries(value as Record<string, unknown>)
+						.sort(([left], [right]) => left.localeCompare(right))
+						.map(([key, entry]) => [key, stable(entry)]),
+				);
+			}
+			return value;
+		};
+
+		const ddlEntries = (ddl: PostgresEntity[]) =>
+			ddl
+				.map((entry) => JSON.stringify(stable(entry)))
+				.sort((left, right) => left.localeCompare(right));
+
+		const actualDdl = ddlEntries(actual.ddl);
+		const expectedDdl = ddlEntries(expected.ddl);
+
+		// Verify no duplicate enum entries
+		const enumEntries = actual.ddl.filter(
+			(e) => (e as any).entityType === 'enums',
+		);
+		expect(
+			enumEntries.length,
+			`Expected exactly 1 enum entry, but found ${enumEntries.length}. Duplicate enums were created during branch merge.`,
+		).toBe(1);
+
+		expect(actualDdl).toStrictEqual(expectedDdl);
+	});
+
+	test('alter view', async () => {
+		const from = {
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+			}).as(sql`SELECT id, name FROM users WHERE active = true`),
+		};
+		const to = {
+			users: pgTable('users', { id: integer('id') }),
+			active_users: pgView('active_users', {
+				id: integer('id'),
+				name: varchar('name'),
+			})
+				.with({ checkOption: 'local' })
+				.as(sql`SELECT id, name FROM users WHERE active = true`),
+		};
+
+		const expectedTypes: JsonStatement['type'][] = ['alter_view'];
+
+		const { afterPatch, fromTs, statements } = await applyTransition({
+			from,
+			to,
+			renames: [],
+		});
+
+		expect(
+			statements.map((it) => it.type).sort((a, b) => a.localeCompare(b)),
+			`Inconsistent statement types. Expected: ${expectedTypes.join(', ')}. Actual: ${
+				statements
+					.map((s) => s.type)
+					.join(', ')
+			}`,
+		).toStrictEqual(expectedTypes.sort((a, b) => a.localeCompare(b)));
+		expect(afterPatch).toStrictEqual(fromTs);
+	});
+});
diff --git a/drizzle-kit/tests/postgres/snapshots/schema01.ts b/drizzle-kit/tests/postgres/snapshots/schema01.ts
new file mode 100644
index 0000000000..5c5c820326
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema01.ts
@@ -0,0 +1,64 @@
+import {
+	AnyPgColumn,
+	foreignKey,
+	integer,
+	pgEnum,
+	pgSchema,
+	pgTable,
+	primaryKey,
+	serial,
+	text,
+	unique,
+} from 'orm044/pg-core';
+
+enum E {
+	value = 'value',
+}
+
+export const folder = pgSchema('folder');
+export const en = pgEnum('e', E);
+export const users = pgTable('users', {
+	id: serial().primaryKey(),
+	enum: en(),
+	text: text().unique(),
+	text1: text(),
+	text2: text(),
+}, (t) => [unique().on(t.text1, t.text2)]);
+
+export const users1 = pgTable('users1', {
+	id1: integer(),
+	id2: integer(),
+}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]);
+
+export const users2 = pgTable('users2', {
+	id: serial(),
+	c1: text().unique(),
+	c2: text().unique('c2unique'),
+	c3: text().unique('c3unique', { nulls: 'distinct' }),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+
+export const users3 = pgTable('users3', {
+	c1: text(),
+	c2: text(),
+	c3: text(),
+}, (t) => [
+	unique().on(t.c1),
+	unique('u3c2unique').on(t.c2),
+	unique('u3c3unique').on(t.c3).nullsNotDistinct(),
+	unique('u3c2c3unique').on(t.c2, t.c3),
+]);
+
+export const users4 = pgTable('users4', {
+	c1: text().unique().references(() => users3.c1),
+	c2: text().references((): AnyPgColumn => users4.c1),
+	c3: text(),
+	c4: text(),
+	c5: text().array().default([]),
+	c6: text().array().array().default([[]]),
+	c7: text().array().array().array().default([[[]]]),
+	c8: text().array(2).array(10),
+}, (t) => [foreignKey({ columns: [t.c3, t.c4], foreignColumns: [users3.c2, users3.c3] })]);
+
+export const users5 = pgTable('users5', {
+	fullName: text(),
+});
diff --git a/drizzle-kit/tests/postgres/snapshots/schema01new.ts b/drizzle-kit/tests/postgres/snapshots/schema01new.ts
new file mode 100644
index 0000000000..3f3191b37d
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema01new.ts
@@ -0,0 +1,64 @@
+import {
+	AnyPgColumn,
+	foreignKey,
+	integer,
+	pgEnum,
+	pgSchema,
+	pgTable,
+	primaryKey,
+	serial,
+	text,
+	unique,
+} from 'drizzle-orm/pg-core';
+
+enum E {
+	value = 'value',
+}
+
+export const folder = pgSchema('folder');
+export const en = pgEnum('e', E);
+export const users = pgTable('users', {
+	id: serial().primaryKey(),
+	enum: en(),
+	text: text().unique(),
+	text1: text(),
+	text2: text(),
+}, (t) => [unique().on(t.text1, t.text2)]);
+
+export const users1 = pgTable('users1', {
+	id1: integer(),
+	id2: integer(),
+}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]);
+
+export const users2 = pgTable('users2', {
+	id: serial(),
+	c1: text().unique(),
+	c2: text().unique('c2unique'),
+	c3: text().unique('c3unique', { nulls: 'distinct' }),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+
+export const users3 = pgTable('users3', {
+	c1: text(),
+	c2: text(),
+	c3: text(),
+}, (t) => [
+	unique().on(t.c1),
+	unique('u3c2unique').on(t.c2),
+	unique('u3c3unique').on(t.c3).nullsNotDistinct(),
+	unique('u3c2c3unique').on(t.c2, t.c3),
+]);
+
+export const users4 = pgTable('users4', {
+	c1: text().unique().references(() => users3.c1),
+	c2: text().references((): AnyPgColumn => users4.c1),
+	c3: text(),
+	c4: text(),
+	c5: text().array().default([]),
+	c6: text().array('[][]').default([[]]),
+	c7: text().array('[][][]').default([[[]]]),
+	c8: text().array('[][]'),
+}, (t) => [foreignKey({ columns: [t.c3, t.c4], foreignColumns: [users3.c2, users3.c3] })]);
+
+export const users5 = pgTable('users5', {
+	fullName: text(),
+});
diff --git a/drizzle-kit/tests/postgres/snapshots/schema02.ts b/drizzle-kit/tests/postgres/snapshots/schema02.ts
new file mode 100644
index 0000000000..d9222b914c
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema02.ts
@@ -0,0 +1,772 @@
+import { SQL, sql } from 'orm044';
+import {
+	boolean,
+	date,
+	decimal,
+	index,
+	integer,
+	jsonb,
+	pgTable,
+	primaryKey,
+	text,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+} from 'orm044/pg-core';
+
+// Enum types for entity classification
+type EntityClass = 'ALPHA' | 'BETA' | 'GAMMA';
+type AccessLevel = 'STANDARD' | 'PREMIUM';
+type ProcessStage = 'INITIAL' | 'COMPLETE';
+
+export const profiles = pgTable('profiles', {
+	id: uuid().defaultRandom().primaryKey(),
+	externalRef: varchar({ length: 255 }).notNull().unique(),
+	serviceRef: varchar().unique(),
+	contactEmail: varchar({ length: 255 }).notNull().unique(),
+	givenName: varchar({ length: 100 }).notNull(),
+	familyName: varchar({ length: 100 }).notNull(),
+	accessLevel: varchar().$type<AccessLevel>().notNull(),
+	birthDate: date(),
+	classification: varchar({ length: 50 }).$type<EntityClass>(),
+	contactNumber: varchar({ length: 20 }),
+	currentStage: varchar().$type<ProcessStage>().default('INITIAL').notNull(),
+	// Location fields
+	recipientName: varchar({ length: 255 }),
+	primaryAddress: varchar({ length: 255 }),
+	secondaryAddress: varchar({ length: 255 }),
+	locality: varchar({ length: 100 }),
+	region: varchar({ length: 2 }),
+	postalCode: varchar({ length: 10 }),
+	territory: varchar({ length: 2 }).default('US').notNull(),
+	// Additional profile fields
+	avatarUrl: varchar({ length: 255 }),
+	lastAccessAt: timestamp({ withTimezone: true }),
+	emailConfirmed: boolean().default(false).notNull(),
+	phoneConfirmed: boolean().default(false).notNull(),
+	// Timestamps
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (profiles) => [
+	index().on(profiles.serviceRef),
+	index().on(profiles.contactEmail),
+	index().on(profiles.externalRef),
+]);
+
+export type Profile = typeof profiles.$inferSelect;
+export type ProfileToInsert = typeof profiles.$inferInsert;
+
+export const profileAgreements = pgTable(
+	'profile_agreements',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		profileId: uuid()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		privacyConsent: boolean().default(false).notNull(),
+		serviceConsent: boolean().default(false).notNull(),
+		termsConsent: boolean().default(false).notNull(),
+		agreementDate: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex().on(table.profileId),
+	],
+);
+
+export type ProfileAgreement = typeof profileAgreements.$inferSelect;
+export type ProfileAgreementToInsert = typeof profileAgreements.$inferInsert;
+
+export const facilities = pgTable('facilities', {
+	id: uuid().defaultRandom().primaryKey(),
+	facilityName: varchar({ length: 255 }).notNull(),
+	serviceId: integer().notNull().unique(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type Facility = typeof facilities.$inferSelect;
+export type FacilityToInsert = typeof facilities.$inferInsert;
+
+export const identifiers = pgTable('identifiers', {
+	id: uuid().defaultRandom().primaryKey(),
+	code: varchar({ length: 50 }).notNull().unique(),
+	displayName: varchar({ length: 255 }).notNull(),
+	description: text(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	measurementUnit: varchar({ length: 50 }),
+	standardRanges: jsonb(),
+	guidelines: jsonb(),
+	evaluationRules: jsonb(),
+	isFeatured: boolean().default(false),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type Identifier = typeof identifiers.$inferSelect;
+export type IdentifierToInsert = typeof identifiers.$inferInsert;
+
+export const classifications = pgTable('classifications', {
+	id: uuid().defaultRandom().primaryKey(),
+	categoryName: varchar({ length: 255 }).notNull(),
+	iconType: varchar({ length: 255 }),
+	themeColor: varchar({ length: 255 }),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type Classification = typeof classifications.$inferSelect;
+export type ClassificationToInsert = typeof classifications.$inferInsert;
+
+export const identifierClassifications = pgTable('identifier_classifications', {
+	identifierId: uuid().references(() => identifiers.id),
+	classificationId: uuid().references(() => classifications.id),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [primaryKey({ columns: [table.identifierId, table.classificationId] })]);
+
+export type IdentifierClassification = typeof identifierClassifications.$inferSelect;
+export type IdentifierClassificationToInsert = typeof identifierClassifications.$inferInsert;
+
+export const impactFactors = pgTable('impact_factors', {
+	id: uuid().defaultRandom().primaryKey(),
+	factorName: varchar({ length: 255 }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type ImpactFactor = typeof impactFactors.$inferSelect;
+export type ImpactFactorToInsert = typeof impactFactors.$inferInsert;
+
+export const impactFactorsToIdentifiers = pgTable('impact_factors_to_identifiers', {
+	impactFactorId: uuid().references(() => impactFactors.id),
+	identifierId: uuid().references(() => identifiers.id),
+});
+
+export type ImpactFactorsToIdentifiers = typeof impactFactorsToIdentifiers.$inferSelect;
+export type ImpactFactorsToIdentifiersToInsert = typeof impactFactorsToIdentifiers.$inferInsert;
+
+export const metricClusters = pgTable('metric_clusters', {
+	id: uuid().defaultRandom().primaryKey(),
+	clusterName: varchar({ length: 255 }).notNull(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	description: text(),
+	metricType: varchar({ length: 50 }).default('standard').notNull(),
+	measurementUnit: varchar({ length: 50 }),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type MetricCluster = typeof metricClusters.$inferSelect;
+export type MetricClusterToInsert = typeof metricClusters.$inferInsert;
+
+export const metricPreferences = pgTable(
+	'metric_preferences',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		profileId: uuid().references(() => profiles.id),
+		identifierId: uuid().references(() => identifiers.id),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index().on(table.profileId),
+		index().on(table.identifierId),
+	],
+);
+
+export type MetricPreference = typeof metricPreferences.$inferSelect;
+export type MetricPreferenceToInsert = typeof metricPreferences.$inferInsert;
+
+export const dataPoints = pgTable('data_points', {
+	id: uuid().defaultRandom().primaryKey(),
+	pointId: integer().notNull(),
+	clusterId: uuid().references(() => metricClusters.id),
+	identifierId: uuid().references(() => identifiers.id),
+	pointName: varchar({ length: 255 }).notNull(),
+	description: text(),
+	dataType: varchar({ length: 50 }).default('standard').notNull(),
+	isParent: boolean().default(false).notNull(),
+	measurementUnit: varchar({ length: 50 }),
+	baseRate: decimal({ precision: 10, scale: 2 }),
+	baseCentRate: integer().generatedAlwaysAs((): SQL => sql`${dataPoints.baseRate} * 100`),
+	facilityId: uuid().references(() => facilities.id).notNull(),
+	isActive: boolean().default(true).notNull(),
+	visualType: varchar({ length: 50 }).default('numeric-trend'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [index().on(table.clusterId, table.facilityId)]);
+
+export type DataPoint = typeof dataPoints.$inferSelect;
+export type DataPointToInsert = typeof dataPoints.$inferInsert;
+
+export const dataPointRelationships = pgTable(
+	'data_point_relationships',
+	{
+		parentId: uuid()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		childId: uuid()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.parentId, table.childId] }),
+		index().on(table.childId),
+	],
+);
+
+export type DataPointRelationship = typeof dataPointRelationships.$inferSelect;
+export type DataPointRelationshipToInsert = typeof dataPointRelationships.$inferInsert;
+
+export const packageClusters = pgTable('package_clusters', {
+	id: uuid().defaultRandom().primaryKey(),
+	packageName: varchar({ length: 255 }).notNull(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	description: text(),
+	partnerId: text().references(() => partners.partnerId, {
+		onDelete: 'set null',
+	}),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type PackageCluster = typeof packageClusters.$inferSelect;
+export type PackageClusterToInsert = typeof packageClusters.$inferInsert;
+
+export const servicePackages = pgTable('service_packages', {
+	id: uuid().defaultRandom().primaryKey(),
+	clusterId: uuid().references(() => packageClusters.id).notNull(),
+	packageTitle: varchar({ length: 255 }),
+	description: text(),
+	serviceRef: varchar({ length: 100 }).notNull().unique(),
+	baseRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	baseCentRate: integer().generatedAlwaysAs((): SQL => sql`${servicePackages.baseRate} * 100`),
+	discountRate: decimal({ precision: 10, scale: 2 }),
+	discountCentRate: integer().generatedAlwaysAs((): SQL => sql`${servicePackages.discountRate} * 100`),
+	facilityId: uuid().references(() => facilities.id).notNull(),
+	isPartnerCreated: boolean().default(false).notNull(),
+	allowsRemoteCollection: boolean().default(false).notNull(),
+	partnerId: text().references(() => partners.partnerId),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.clusterId, table.facilityId),
+]);
+
+export type ServicePackage = typeof servicePackages.$inferSelect;
+export type ServicePackageToInsert = typeof servicePackages.$inferInsert;
+
+export const servicePackageDataPoints = pgTable('service_package_data_points', {
+	packageId: uuid().references(() => servicePackages.id, { onDelete: 'cascade' }).notNull(),
+	dataPointId: uuid().references(() => dataPoints.id, { onDelete: 'cascade' }).notNull(),
+	displayOrder: integer(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [primaryKey({ columns: [table.packageId, table.dataPointId] })]);
+
+export type ServicePackageDataPoint = typeof servicePackageDataPoints.$inferSelect;
+export type ServicePackageDataPointToInsert = typeof servicePackageDataPoints.$inferInsert;
+
+export const collectionEvents = pgTable('collection_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	requestId: uuid().references(() => requests.id, {
+		onDelete: 'cascade',
+	}),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }),
+	facilityId: uuid().references(() => facilities.id),
+	collectionDate: timestamp({ withTimezone: true }),
+	reportDate: timestamp({ withTimezone: true }),
+	receivedDate: timestamp({ withTimezone: true }),
+	eventStatus: varchar({ length: 50 }).default('initiated'),
+	dataSource: varchar({ length: 50 }).default(''),
+	specimenRef: varchar({ length: 100 }),
+	eventMetadata: jsonb(),
+	documentUrl: varchar({ length: 255 }),
+	hasNewData: boolean().notNull().default(false),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type CollectionEvent = typeof collectionEvents.$inferSelect;
+export type CollectionEventToInsert = typeof collectionEvents.$inferInsert;
+
+export const measurements = pgTable(
+	'measurements',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		measurementName: varchar(),
+		slug: varchar(),
+		eventId: uuid().references(() => collectionEvents.id, {
+			onDelete: 'cascade',
+		}),
+		profileId: uuid().references(() => profiles.id),
+		dataPointId: uuid().references(() => dataPoints.id),
+		identifierId: uuid().references(() => identifiers.id),
+		resultValue: text(),
+		numericResult: decimal({ precision: 10, scale: 2 }),
+		rawResult: varchar({ length: 50 }),
+		measurementUnit: varchar({ length: 50 }),
+		facilityInterpretation: varchar({ length: 50 }),
+		facilityMinRange: decimal({ precision: 10, scale: 2 }),
+		facilityMaxRange: decimal({ precision: 10, scale: 2 }),
+		systemNotes: text(),
+		profileNotes: text(),
+		profileActions: jsonb(),
+		measurementMetadata: jsonb(),
+		processingStatus: varchar({ length: 50 }).default('partial_data'),
+		recordedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		isNotified: boolean().default(false),
+		isArchived: boolean().default(false),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index().on(table.eventId),
+		index().on(table.identifierId),
+		index().on(table.dataPointId),
+	],
+);
+
+export type Measurement = typeof measurements.$inferSelect;
+export type MeasurementToInsert = typeof measurements.$inferInsert;
+
+export const partners = pgTable('partners', {
+	id: uuid().defaultRandom().primaryKey(),
+	partnerId: text().notNull().unique(),
+	slug: varchar({ length: 255 }).unique(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	partnerFirstName: varchar({ length: 255 }).notNull(),
+	partnerLastName: varchar({ length: 255 }).notNull(),
+	displayName: varchar({ length: 255 }),
+	description: text(),
+	logoUrl: varchar({ length: 255 }),
+	isActive: boolean().default(true),
+	partnerMetadata: jsonb(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (partners) => [
+	index().on(partners.promoCode),
+	index().on(partners.partnerId),
+]);
+
+export type Partner = typeof partners.$inferSelect;
+
+export const partnerRelationships = pgTable('partner_relationships', {
+	parentPartnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	childPartnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	primaryKey({ columns: [table.parentPartnerId, table.childPartnerId] }),
+	index().on(table.childPartnerId),
+]);
+
+export type RequestStatus =
+	| 'pending'
+	| 'processed'
+	| 'processing_failed'
+	| 'service_creation_failed'
+	| 'service_results_failed'
+	| 'refund_pending'
+	| 'refunded'
+	| 'refund_failed'
+	| 'processing_cancellation'
+	| 'received.standard.ordered'
+	| 'received.standard.document_created'
+	| 'sample_processing.standard.partial_data'
+	| 'collecting_sample.standard.appointment_scheduled'
+	| 'completed.standard.completed'
+	| 'failed.standard.sample_error'
+	| 'cancelled.standard.cancelled'
+	| 'received.remote.ordered'
+	| 'received.remote.document_created'
+	| 'collecting_sample.remote.appointment_scheduled'
+	| 'sample_processing.remote.partial_data'
+	| 'completed.remote.completed'
+	| 'cancelled.remote.cancelled';
+
+export const serviceRequestStatuses: RequestStatus[] = [
+	'service_results_failed',
+	'received.standard.ordered',
+	'received.standard.document_created',
+	'sample_processing.standard.partial_data',
+	'completed.standard.completed',
+	'failed.standard.sample_error',
+	'cancelled.standard.cancelled',
+	'received.remote.ordered',
+	'received.remote.document_created',
+	'collecting_sample.remote.appointment_scheduled',
+	'sample_processing.remote.partial_data',
+	'completed.remote.completed',
+	'cancelled.remote.cancelled',
+];
+
+export interface Location {
+	primaryAddress: string;
+	secondaryAddress?: string;
+	locality: string;
+	region: string;
+	postalCode: string;
+	territory: string;
+}
+
+export type RequestType = 'standard' | 'remote';
+
+export const requests = pgTable('requests', {
+	id: uuid().defaultRandom().primaryKey(),
+	requestNumber: integer().notNull(),
+	serviceRequestId: uuid(),
+	totalAmount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${requests.totalAmount} * 100`),
+	requestStatus: varchar({ length: 100 }).$type<RequestStatus>().notNull(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	facilityId: uuid().references(() => facilities.id, { onDelete: 'set null' }),
+	receiptUrl: varchar({ length: 255 }),
+	itemCount: integer().notNull(),
+	requestMetadata: jsonb(),
+	requestType: varchar().$type<RequestType>().default('standard').notNull(),
+	location: jsonb().$type<Location>(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.requestNumber),
+	index().on(table.requestStatus),
+	index().on(table.serviceRequestId),
+	index().on(table.promoCode),
+	index().on(table.referralCode),
+	index().on(table.requestType),
+]);
+
+export type Request = typeof requests.$inferSelect;
+export type RequestToInsert = typeof requests.$inferInsert;
+
+export const requestsToDataPoints = pgTable('requests_to_data_points', {
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	dataPointId: uuid().references(() => dataPoints.id, { onDelete: 'cascade' }).notNull(),
+	itemRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	centRate: integer().generatedAlwaysAs((): SQL => sql`${requestsToDataPoints.itemRate} * 100`),
+}, (table) => [index().on(table.requestId), index().on(table.dataPointId)]);
+
+export type RequestToDataPoint = typeof requestsToDataPoints.$inferSelect;
+export type RequestToDataPointToInsert = typeof requestsToDataPoints.$inferInsert;
+
+export const requestsToServicePackages = pgTable('requests_to_service_packages', {
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	servicePackageId: uuid().references(() => servicePackages.id, { onDelete: 'cascade' }).notNull(),
+	packageRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	centRate: integer().generatedAlwaysAs((): SQL => sql`${requestsToServicePackages.packageRate} * 100`),
+}, (table) => [index().on(table.requestId), index().on(table.servicePackageId)]);
+
+export type RequestToServicePackage = typeof requestsToServicePackages.$inferSelect;
+export type RequestToServicePackageToInsert = typeof requestsToServicePackages.$inferInsert;
+
+export const selections = pgTable('selections', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	facilityId: uuid().references(() => facilities.id),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.facilityId),
+	uniqueIndex().on(table.id, table.profileId),
+]);
+
+export type Selection = typeof selections.$inferSelect;
+export type SelectionToInsert = typeof selections.$inferInsert;
+
+export const selectionsToDataPoints = pgTable('selections_to_data_points', {
+	selectionId: uuid()
+		.references(() => selections.id, { onDelete: 'cascade' })
+		.notNull(),
+	dataPointId: uuid()
+		.references(() => dataPoints.id, { onDelete: 'cascade' })
+		.notNull(),
+}, (table) => [
+	index().on(table.selectionId),
+	index().on(table.dataPointId),
+	uniqueIndex().on(table.selectionId, table.dataPointId),
+]);
+
+export type SelectionToDataPoint = typeof selectionsToDataPoints.$inferSelect;
+
+export const selectionsToServicePackages = pgTable('selections_to_service_packages', {
+	selectionId: uuid()
+		.references(() => selections.id, { onDelete: 'cascade' })
+		.notNull(),
+	servicePackageId: uuid()
+		.references(() => servicePackages.id, { onDelete: 'cascade' })
+		.notNull(),
+}, (table) => [
+	index().on(table.selectionId),
+	index().on(table.servicePackageId),
+	uniqueIndex().on(table.selectionId, table.servicePackageId),
+]);
+
+export type SelectionToServicePackage = typeof selectionsToServicePackages.$inferSelect;
+
+export type ProcessorPaymentStatus = 'PENDING' | 'SUCCESS' | 'DECLINE' | 'UNKNOWN';
+export type PaymentProcessor = 'PROCESSOR_A' | 'PROCESSOR_B';
+
+export const transactions = pgTable('transactions', {
+	id: uuid().defaultRandom().primaryKey(),
+	token: varchar(),
+	transactionId: varchar().notNull().unique(),
+	sourceId: varchar(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	requestId: uuid().references(() => requests.id).notNull(),
+	transactionStatus: varchar({ length: 50 }).notNull(),
+	amount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${transactions.amount} * 100`),
+	currency: varchar({ length: 10 }).notNull(),
+	responseData: jsonb(),
+	transactionMetadata: jsonb(),
+	processor: varchar().$type<PaymentProcessor>().notNull().default('PROCESSOR_A'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.transactionId, table.processor),
+	index().on(table.token),
+	index().on(table.transactionId),
+	index().on(table.profileId),
+	index().on(table.requestId),
+	index().on(table.transactionStatus),
+]);
+
+export type Transaction = typeof transactions.$inferSelect;
+export type TransactionToInsert = typeof transactions.$inferInsert;
+
+export type TransactionEventType = 'transaction.created' | 'transaction.updated';
+export type ProcessorEventType = 'transaction.sale.success' | 'transaction.sale.failure' | 'transaction.sale.unknown';
+
+export const transactionEvents = pgTable('transaction_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	eventType: varchar({ length: 50 }).$type<TransactionEventType | ProcessorEventType>().notNull(),
+	eventId: varchar().notNull(),
+	transactionId: varchar().references(() => transactions.transactionId, { onDelete: 'cascade' }).notNull(),
+	eventMetadata: jsonb().notNull(),
+	processor: varchar().$type<PaymentProcessor>().notNull().default('PROCESSOR_A'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.eventId),
+	index().on(table.eventType),
+	index().on(table.transactionId),
+]);
+
+export type TransactionEvent = typeof transactionEvents.$inferSelect;
+export type TransactionEventToInsert = typeof transactionEvents.$inferInsert;
+
+export const serviceEvents = pgTable('service_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	serviceUserId: varchar().notNull(),
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	serviceRequestId: varchar().notNull(),
+	eventType: varchar().notNull(),
+	eventId: integer().notNull(),
+	appointmentEventId: varchar(),
+	eventStatus: varchar().notNull(),
+	appointmentStatus: varchar(),
+	eventMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (serviceEvents) => [
+	index().on(serviceEvents.profileId),
+	index().on(serviceEvents.serviceUserId),
+	index().on(serviceEvents.requestId),
+	index().on(serviceEvents.serviceRequestId),
+	index().on(serviceEvents.eventId),
+	index().on(serviceEvents.eventType),
+	index().on(serviceEvents.eventStatus),
+]);
+
+export type ServiceEvent = typeof serviceEvents.$inferSelect;
+export type ServiceEventToInsert = typeof serviceEvents.$inferInsert;
+
+export type PartnerSubscriptionType = 'promo' | 'referral' | 'custom_package';
+
+export const partnerSubscriptions = pgTable('partner_subscriptions', {
+	id: uuid().defaultRandom().primaryKey(),
+	partnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	subscriptionType: varchar().$type<PartnerSubscriptionType>().notNull(),
+	expiredAt: timestamp({ withTimezone: true }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (partnerSubscriptions) => [
+	uniqueIndex().on(partnerSubscriptions.profileId, partnerSubscriptions.partnerId),
+	index().on(partnerSubscriptions.profileId),
+	index().on(partnerSubscriptions.partnerId),
+	index().on(partnerSubscriptions.promoCode),
+	index().on(partnerSubscriptions.referralCode),
+	index().on(partnerSubscriptions.subscriptionType),
+	index().on(partnerSubscriptions.expiredAt),
+]);
+
+export type PartnerSubscription = typeof partnerSubscriptions.$inferSelect;
+export type PartnerSubscriptionToInsert = typeof partnerSubscriptions.$inferInsert;
+
+export const reversals = pgTable('reversals', {
+	id: uuid().defaultRandom().primaryKey(),
+	token: varchar().notNull(),
+	transactionId: uuid().notNull().references(() => transactions.id),
+	reversalId: varchar().notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	requestId: uuid().references(() => requests.id).notNull(),
+	reversalStatus: varchar({ length: 50 }).notNull(),
+	amount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${reversals.amount} * 100`),
+	currency: varchar({ length: 10 }).notNull(),
+	reversalMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.token),
+	index().on(table.transactionId),
+	index().on(table.profileId),
+	index().on(table.requestId),
+	index().on(table.reversalStatus),
+	index().on(table.reversalId),
+]);
+
+export type Reversal = typeof reversals.$inferSelect;
+export type ReversalToInsert = typeof reversals.$inferInsert;
+
+export type ReversalEventType = 'reversal.created' | 'reversal.updated';
+
+export const reversalEvents = pgTable('reversal_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	eventType: varchar({ length: 50 }).$type<ReversalEventType>().notNull(),
+	eventId: varchar().notNull(),
+	reversalId: uuid().references(() => reversals.id, { onDelete: 'cascade' }).notNull(),
+	transactionId: uuid().references(() => transactions.id, { onDelete: 'cascade' }).notNull(),
+	eventMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.eventId),
+	index().on(table.eventType),
+	index().on(table.transactionId),
+	index().on(table.reversalId),
+]);
+
+export type ReversalEvent = typeof reversalEvents.$inferSelect;
+export type ReversalEventToInsert = typeof reversalEvents.$inferInsert;
+
+export const schedules = pgTable('schedules', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid()
+		.references(() => profiles.id, { onDelete: 'cascade' })
+		.notNull(),
+	scheduleTitle: varchar({ length: 255 }).notNull(),
+	description: text(),
+	startDate: timestamp({ withTimezone: true }).notNull(),
+	endDate: timestamp({ withTimezone: true }),
+	isCurrent: boolean().default(false).notNull(),
+	themeColor: varchar({ length: 50 }).notNull(),
+	isPrivate: boolean().default(false).notNull(),
+	applyToAllCharts: boolean().default(false).notNull(),
+	isVisible: boolean().default(true).notNull(),
+	isArchived: boolean().default(false).notNull(),
+	profileActions: jsonb(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.startDate, table.endDate),
+]);
+
+export type Schedule = typeof schedules.$inferSelect;
+export type ScheduleToInsert = typeof schedules.$inferInsert;
+
+export const schedulesToIdentifiers = pgTable('schedules_to_identifiers', {
+	scheduleId: uuid()
+		.references(() => schedules.id, {
+			onDelete: 'cascade',
+		})
+		.notNull(),
+	identifierId: uuid()
+		.references(() => identifiers.id, {
+			onDelete: 'cascade',
+		})
+		.notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+}, (table) => [
+	primaryKey({ columns: [table.scheduleId, table.identifierId] }),
+	index().on(table.identifierId),
+]);
+
+export type ScheduleToIdentifier = typeof schedulesToIdentifiers.$inferSelect;
+export type ScheduleToIdentifierToInsert = typeof schedulesToIdentifiers.$inferInsert;
+
+export const scheduleShares = pgTable('schedule_shares', {
+	id: uuid().defaultRandom().primaryKey(),
+	shareToken: text().notNull().unique(),
+	scheduleId: uuid().references(() => schedules.id, { onDelete: 'cascade' }).notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	accessCount: integer().default(0).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.shareToken),
+	index().on(table.scheduleId),
+	index().on(table.profileId),
+]);
+
+export type ScheduleShare = typeof scheduleShares.$inferSelect;
+export type ScheduleShareToInsert = typeof scheduleShares.$inferInsert;
+
+export const processingProviders = pgTable('processing_providers', {
+	id: uuid().defaultRandom().primaryKey(),
+	processor: varchar().$type<PaymentProcessor>().notNull(),
+	isActive: boolean().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (processingProviders) => [
+	index().on(processingProviders.processor),
+	index().on(processingProviders.isActive),
+]);
+
+export type ProcessingProvider = typeof processingProviders.$inferSelect;
diff --git a/drizzle-kit/tests/postgres/snapshots/schema02new.ts b/drizzle-kit/tests/postgres/snapshots/schema02new.ts
new file mode 100644
index 0000000000..b0a10e912e
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema02new.ts
@@ -0,0 +1,772 @@
+import { SQL, sql } from 'drizzle-orm';
+import {
+	boolean,
+	date,
+	decimal,
+	index,
+	integer,
+	jsonb,
+	pgTable,
+	primaryKey,
+	text,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+
+// Enum types for entity classification
+type EntityClass = 'ALPHA' | 'BETA' | 'GAMMA';
+type AccessLevel = 'STANDARD' | 'PREMIUM';
+type ProcessStage = 'INITIAL' | 'COMPLETE';
+
+export const profiles = pgTable('profiles', {
+	id: uuid().defaultRandom().primaryKey(),
+	externalRef: varchar({ length: 255 }).notNull().unique(),
+	serviceRef: varchar().unique(),
+	contactEmail: varchar({ length: 255 }).notNull().unique(),
+	givenName: varchar({ length: 100 }).notNull(),
+	familyName: varchar({ length: 100 }).notNull(),
+	accessLevel: varchar().$type<AccessLevel>().notNull(),
+	birthDate: date(),
+	classification: varchar({ length: 50 }).$type<EntityClass>(),
+	contactNumber: varchar({ length: 20 }),
+	currentStage: varchar().$type<ProcessStage>().default('INITIAL').notNull(),
+	// Location fields
+	recipientName: varchar({ length: 255 }),
+	primaryAddress: varchar({ length: 255 }),
+	secondaryAddress: varchar({ length: 255 }),
+	locality: varchar({ length: 100 }),
+	region: varchar({ length: 2 }),
+	postalCode: varchar({ length: 10 }),
+	territory: varchar({ length: 2 }).default('US').notNull(),
+	// Additional profile fields
+	avatarUrl: varchar({ length: 255 }),
+	lastAccessAt: timestamp({ withTimezone: true }),
+	emailConfirmed: boolean().default(false).notNull(),
+	phoneConfirmed: boolean().default(false).notNull(),
+	// Timestamps
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (profiles) => [
+	index().on(profiles.serviceRef),
+	index().on(profiles.contactEmail),
+	index().on(profiles.externalRef),
+]);
+
+export type Profile = typeof profiles.$inferSelect;
+export type ProfileToInsert = typeof profiles.$inferInsert;
+
+export const profileAgreements = pgTable(
+	'profile_agreements',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		profileId: uuid()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		privacyConsent: boolean().default(false).notNull(),
+		serviceConsent: boolean().default(false).notNull(),
+		termsConsent: boolean().default(false).notNull(),
+		agreementDate: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex().on(table.profileId),
+	],
+);
+
+export type ProfileAgreement = typeof profileAgreements.$inferSelect;
+export type ProfileAgreementToInsert = typeof profileAgreements.$inferInsert;
+
+export const facilities = pgTable('facilities', {
+	id: uuid().defaultRandom().primaryKey(),
+	facilityName: varchar({ length: 255 }).notNull(),
+	serviceId: integer().notNull().unique(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type Facility = typeof facilities.$inferSelect;
+export type FacilityToInsert = typeof facilities.$inferInsert;
+
+export const identifiers = pgTable('identifiers', {
+	id: uuid().defaultRandom().primaryKey(),
+	code: varchar({ length: 50 }).notNull().unique(),
+	displayName: varchar({ length: 255 }).notNull(),
+	description: text(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	measurementUnit: varchar({ length: 50 }),
+	standardRanges: jsonb(),
+	guidelines: jsonb(),
+	evaluationRules: jsonb(),
+	isFeatured: boolean().default(false),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type Identifier = typeof identifiers.$inferSelect;
+export type IdentifierToInsert = typeof identifiers.$inferInsert;
+
+export const classifications = pgTable('classifications', {
+	id: uuid().defaultRandom().primaryKey(),
+	categoryName: varchar({ length: 255 }).notNull(),
+	iconType: varchar({ length: 255 }),
+	themeColor: varchar({ length: 255 }),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type Classification = typeof classifications.$inferSelect;
+export type ClassificationToInsert = typeof classifications.$inferInsert;
+
+export const identifierClassifications = pgTable('identifier_classifications', {
+	identifierId: uuid().references(() => identifiers.id),
+	classificationId: uuid().references(() => classifications.id),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [primaryKey({ columns: [table.identifierId, table.classificationId] })]);
+
+export type IdentifierClassification = typeof identifierClassifications.$inferSelect;
+export type IdentifierClassificationToInsert = typeof identifierClassifications.$inferInsert;
+
+export const impactFactors = pgTable('impact_factors', {
+	id: uuid().defaultRandom().primaryKey(),
+	factorName: varchar({ length: 255 }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+});
+
+export type ImpactFactor = typeof impactFactors.$inferSelect;
+export type ImpactFactorToInsert = typeof impactFactors.$inferInsert;
+
+export const impactFactorsToIdentifiers = pgTable('impact_factors_to_identifiers', {
+	impactFactorId: uuid().references(() => impactFactors.id),
+	identifierId: uuid().references(() => identifiers.id),
+});
+
+export type ImpactFactorsToIdentifiers = typeof impactFactorsToIdentifiers.$inferSelect;
+export type ImpactFactorsToIdentifiersToInsert = typeof impactFactorsToIdentifiers.$inferInsert;
+
+export const metricClusters = pgTable('metric_clusters', {
+	id: uuid().defaultRandom().primaryKey(),
+	clusterName: varchar({ length: 255 }).notNull(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	description: text(),
+	metricType: varchar({ length: 50 }).default('standard').notNull(),
+	measurementUnit: varchar({ length: 50 }),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type MetricCluster = typeof metricClusters.$inferSelect;
+export type MetricClusterToInsert = typeof metricClusters.$inferInsert;
+
+export const metricPreferences = pgTable(
+	'metric_preferences',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		profileId: uuid().references(() => profiles.id),
+		identifierId: uuid().references(() => identifiers.id),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index().on(table.profileId),
+		index().on(table.identifierId),
+	],
+);
+
+export type MetricPreference = typeof metricPreferences.$inferSelect;
+export type MetricPreferenceToInsert = typeof metricPreferences.$inferInsert;
+
+export const dataPoints = pgTable('data_points', {
+	id: uuid().defaultRandom().primaryKey(),
+	pointId: integer().notNull(),
+	clusterId: uuid().references(() => metricClusters.id),
+	identifierId: uuid().references(() => identifiers.id),
+	pointName: varchar({ length: 255 }).notNull(),
+	description: text(),
+	dataType: varchar({ length: 50 }).default('standard').notNull(),
+	isParent: boolean().default(false).notNull(),
+	measurementUnit: varchar({ length: 50 }),
+	baseRate: decimal({ precision: 10, scale: 2 }),
+	baseCentRate: integer().generatedAlwaysAs((): SQL => sql`${dataPoints.baseRate} * 100`),
+	facilityId: uuid().references(() => facilities.id).notNull(),
+	isActive: boolean().default(true).notNull(),
+	visualType: varchar({ length: 50 }).default('numeric-trend'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [index().on(table.clusterId, table.facilityId)]);
+
+export type DataPoint = typeof dataPoints.$inferSelect;
+export type DataPointToInsert = typeof dataPoints.$inferInsert;
+
+export const dataPointRelationships = pgTable(
+	'data_point_relationships',
+	{
+		parentId: uuid()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		childId: uuid()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.parentId, table.childId] }),
+		index().on(table.childId),
+	],
+);
+
+export type DataPointRelationship = typeof dataPointRelationships.$inferSelect;
+export type DataPointRelationshipToInsert = typeof dataPointRelationships.$inferInsert;
+
+export const packageClusters = pgTable('package_clusters', {
+	id: uuid().defaultRandom().primaryKey(),
+	packageName: varchar({ length: 255 }).notNull(),
+	slug: varchar({ length: 255 }).notNull().unique(),
+	description: text(),
+	partnerId: text().references(() => partners.partnerId, {
+		onDelete: 'set null',
+	}),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type PackageCluster = typeof packageClusters.$inferSelect;
+export type PackageClusterToInsert = typeof packageClusters.$inferInsert;
+
+export const servicePackages = pgTable('service_packages', {
+	id: uuid().defaultRandom().primaryKey(),
+	clusterId: uuid().references(() => packageClusters.id).notNull(),
+	packageTitle: varchar({ length: 255 }),
+	description: text(),
+	serviceRef: varchar({ length: 100 }).notNull().unique(),
+	baseRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	baseCentRate: integer().generatedAlwaysAs((): SQL => sql`${servicePackages.baseRate} * 100`),
+	discountRate: decimal({ precision: 10, scale: 2 }),
+	discountCentRate: integer().generatedAlwaysAs((): SQL => sql`${servicePackages.discountRate} * 100`),
+	facilityId: uuid().references(() => facilities.id).notNull(),
+	isPartnerCreated: boolean().default(false).notNull(),
+	allowsRemoteCollection: boolean().default(false).notNull(),
+	partnerId: text().references(() => partners.partnerId),
+	isActive: boolean().default(true).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.clusterId, table.facilityId),
+]);
+
+export type ServicePackage = typeof servicePackages.$inferSelect;
+export type ServicePackageToInsert = typeof servicePackages.$inferInsert;
+
+export const servicePackageDataPoints = pgTable('service_package_data_points', {
+	packageId: uuid().references(() => servicePackages.id, { onDelete: 'cascade' }).notNull(),
+	dataPointId: uuid().references(() => dataPoints.id, { onDelete: 'cascade' }).notNull(),
+	displayOrder: integer(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [primaryKey({ columns: [table.packageId, table.dataPointId] })]);
+
+export type ServicePackageDataPoint = typeof servicePackageDataPoints.$inferSelect;
+export type ServicePackageDataPointToInsert = typeof servicePackageDataPoints.$inferInsert;
+
+export const collectionEvents = pgTable('collection_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	requestId: uuid().references(() => requests.id, {
+		onDelete: 'cascade',
+	}),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }),
+	facilityId: uuid().references(() => facilities.id),
+	collectionDate: timestamp({ withTimezone: true }),
+	reportDate: timestamp({ withTimezone: true }),
+	receivedDate: timestamp({ withTimezone: true }),
+	eventStatus: varchar({ length: 50 }).default('initiated'),
+	dataSource: varchar({ length: 50 }).default(''),
+	specimenRef: varchar({ length: 100 }),
+	eventMetadata: jsonb(),
+	documentUrl: varchar({ length: 255 }),
+	hasNewData: boolean().notNull().default(false),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+});
+
+export type CollectionEvent = typeof collectionEvents.$inferSelect;
+export type CollectionEventToInsert = typeof collectionEvents.$inferInsert;
+
+export const measurements = pgTable(
+	'measurements',
+	{
+		id: uuid().defaultRandom().primaryKey(),
+		measurementName: varchar(),
+		slug: varchar(),
+		eventId: uuid().references(() => collectionEvents.id, {
+			onDelete: 'cascade',
+		}),
+		profileId: uuid().references(() => profiles.id),
+		dataPointId: uuid().references(() => dataPoints.id),
+		identifierId: uuid().references(() => identifiers.id),
+		resultValue: text(),
+		numericResult: decimal({ precision: 10, scale: 2 }),
+		rawResult: varchar({ length: 50 }),
+		measurementUnit: varchar({ length: 50 }),
+		facilityInterpretation: varchar({ length: 50 }),
+		facilityMinRange: decimal({ precision: 10, scale: 2 }),
+		facilityMaxRange: decimal({ precision: 10, scale: 2 }),
+		systemNotes: text(),
+		profileNotes: text(),
+		profileActions: jsonb(),
+		measurementMetadata: jsonb(),
+		processingStatus: varchar({ length: 50 }).default('partial_data'),
+		recordedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		isNotified: boolean().default(false),
+		isArchived: boolean().default(false),
+		createdAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp({ withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index().on(table.eventId),
+		index().on(table.identifierId),
+		index().on(table.dataPointId),
+	],
+);
+
+export type Measurement = typeof measurements.$inferSelect;
+export type MeasurementToInsert = typeof measurements.$inferInsert;
+
+export const partners = pgTable('partners', {
+	id: uuid().defaultRandom().primaryKey(),
+	partnerId: text().notNull().unique(),
+	slug: varchar({ length: 255 }).unique(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	partnerFirstName: varchar({ length: 255 }).notNull(),
+	partnerLastName: varchar({ length: 255 }).notNull(),
+	displayName: varchar({ length: 255 }),
+	description: text(),
+	logoUrl: varchar({ length: 255 }),
+	isActive: boolean().default(true),
+	partnerMetadata: jsonb(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (partners) => [
+	index().on(partners.promoCode),
+	index().on(partners.partnerId),
+]);
+
+export type Partner = typeof partners.$inferSelect;
+
+export const partnerRelationships = pgTable('partner_relationships', {
+	parentPartnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	childPartnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	primaryKey({ columns: [table.parentPartnerId, table.childPartnerId] }),
+	index().on(table.childPartnerId),
+]);
+
+export type RequestStatus =
+	| 'pending'
+	| 'processed'
+	| 'processing_failed'
+	| 'service_creation_failed'
+	| 'service_results_failed'
+	| 'refund_pending'
+	| 'refunded'
+	| 'refund_failed'
+	| 'processing_cancellation'
+	| 'received.standard.ordered'
+	| 'received.standard.document_created'
+	| 'sample_processing.standard.partial_data'
+	| 'collecting_sample.standard.appointment_scheduled'
+	| 'completed.standard.completed'
+	| 'failed.standard.sample_error'
+	| 'cancelled.standard.cancelled'
+	| 'received.remote.ordered'
+	| 'received.remote.document_created'
+	| 'collecting_sample.remote.appointment_scheduled'
+	| 'sample_processing.remote.partial_data'
+	| 'completed.remote.completed'
+	| 'cancelled.remote.cancelled';
+
+export const serviceRequestStatuses: RequestStatus[] = [
+	'service_results_failed',
+	'received.standard.ordered',
+	'received.standard.document_created',
+	'sample_processing.standard.partial_data',
+	'completed.standard.completed',
+	'failed.standard.sample_error',
+	'cancelled.standard.cancelled',
+	'received.remote.ordered',
+	'received.remote.document_created',
+	'collecting_sample.remote.appointment_scheduled',
+	'sample_processing.remote.partial_data',
+	'completed.remote.completed',
+	'cancelled.remote.cancelled',
+];
+
+export interface Location {
+	primaryAddress: string;
+	secondaryAddress?: string;
+	locality: string;
+	region: string;
+	postalCode: string;
+	territory: string;
+}
+
+export type RequestType = 'standard' | 'remote';
+
+export const requests = pgTable('requests', {
+	id: uuid().defaultRandom().primaryKey(),
+	requestNumber: integer().notNull(),
+	serviceRequestId: uuid(),
+	totalAmount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${requests.totalAmount} * 100`),
+	requestStatus: varchar({ length: 100 }).$type<RequestStatus>().notNull(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	facilityId: uuid().references(() => facilities.id, { onDelete: 'set null' }),
+	receiptUrl: varchar({ length: 255 }),
+	itemCount: integer().notNull(),
+	requestMetadata: jsonb(),
+	requestType: varchar().$type<RequestType>().default('standard').notNull(),
+	location: jsonb().$type<Location>(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.requestNumber),
+	index().on(table.requestStatus),
+	index().on(table.serviceRequestId),
+	index().on(table.promoCode),
+	index().on(table.referralCode),
+	index().on(table.requestType),
+]);
+
+export type Request = typeof requests.$inferSelect;
+export type RequestToInsert = typeof requests.$inferInsert;
+
+export const requestsToDataPoints = pgTable('requests_to_data_points', {
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	dataPointId: uuid().references(() => dataPoints.id, { onDelete: 'cascade' }).notNull(),
+	itemRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	centRate: integer().generatedAlwaysAs((): SQL => sql`${requestsToDataPoints.itemRate} * 100`),
+}, (table) => [index().on(table.requestId), index().on(table.dataPointId)]);
+
+export type RequestToDataPoint = typeof requestsToDataPoints.$inferSelect;
+export type RequestToDataPointToInsert = typeof requestsToDataPoints.$inferInsert;
+
+export const requestsToServicePackages = pgTable('requests_to_service_packages', {
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	servicePackageId: uuid().references(() => servicePackages.id, { onDelete: 'cascade' }).notNull(),
+	packageRate: decimal({ precision: 10, scale: 2 }).notNull(),
+	centRate: integer().generatedAlwaysAs((): SQL => sql`${requestsToServicePackages.packageRate} * 100`),
+}, (table) => [index().on(table.requestId), index().on(table.servicePackageId)]);
+
+export type RequestToServicePackage = typeof requestsToServicePackages.$inferSelect;
+export type RequestToServicePackageToInsert = typeof requestsToServicePackages.$inferInsert;
+
+export const selections = pgTable('selections', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	facilityId: uuid().references(() => facilities.id),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.facilityId),
+	uniqueIndex().on(table.id, table.profileId),
+]);
+
+export type Selection = typeof selections.$inferSelect;
+export type SelectionToInsert = typeof selections.$inferInsert;
+
+export const selectionsToDataPoints = pgTable('selections_to_data_points', {
+	selectionId: uuid()
+		.references(() => selections.id, { onDelete: 'cascade' })
+		.notNull(),
+	dataPointId: uuid()
+		.references(() => dataPoints.id, { onDelete: 'cascade' })
+		.notNull(),
+}, (table) => [
+	index().on(table.selectionId),
+	index().on(table.dataPointId),
+	uniqueIndex().on(table.selectionId, table.dataPointId),
+]);
+
+export type SelectionToDataPoint = typeof selectionsToDataPoints.$inferSelect;
+
+export const selectionsToServicePackages = pgTable('selections_to_service_packages', {
+	selectionId: uuid()
+		.references(() => selections.id, { onDelete: 'cascade' })
+		.notNull(),
+	servicePackageId: uuid()
+		.references(() => servicePackages.id, { onDelete: 'cascade' })
+		.notNull(),
+}, (table) => [
+	index().on(table.selectionId),
+	index().on(table.servicePackageId),
+	uniqueIndex().on(table.selectionId, table.servicePackageId),
+]);
+
+export type SelectionToServicePackage = typeof selectionsToServicePackages.$inferSelect;
+
+export type ProcessorPaymentStatus = 'PENDING' | 'SUCCESS' | 'DECLINE' | 'UNKNOWN';
+export type PaymentProcessor = 'PROCESSOR_A' | 'PROCESSOR_B';
+
+export const transactions = pgTable('transactions', {
+	id: uuid().defaultRandom().primaryKey(),
+	token: varchar(),
+	transactionId: varchar().notNull().unique(),
+	sourceId: varchar(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	requestId: uuid().references(() => requests.id).notNull(),
+	transactionStatus: varchar({ length: 50 }).notNull(),
+	amount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${transactions.amount} * 100`),
+	currency: varchar({ length: 10 }).notNull(),
+	responseData: jsonb(),
+	transactionMetadata: jsonb(),
+	processor: varchar().$type<PaymentProcessor>().notNull().default('PROCESSOR_A'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.transactionId, table.processor),
+	index().on(table.token),
+	index().on(table.transactionId),
+	index().on(table.profileId),
+	index().on(table.requestId),
+	index().on(table.transactionStatus),
+]);
+
+export type Transaction = typeof transactions.$inferSelect;
+export type TransactionToInsert = typeof transactions.$inferInsert;
+
+export type TransactionEventType = 'transaction.created' | 'transaction.updated';
+export type ProcessorEventType = 'transaction.sale.success' | 'transaction.sale.failure' | 'transaction.sale.unknown';
+
+export const transactionEvents = pgTable('transaction_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	eventType: varchar({ length: 50 }).$type<TransactionEventType | ProcessorEventType>().notNull(),
+	eventId: varchar().notNull(),
+	transactionId: varchar().references(() => transactions.transactionId, { onDelete: 'cascade' }).notNull(),
+	eventMetadata: jsonb().notNull(),
+	processor: varchar().$type<PaymentProcessor>().notNull().default('PROCESSOR_A'),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.eventId),
+	index().on(table.eventType),
+	index().on(table.transactionId),
+]);
+
+export type TransactionEvent = typeof transactionEvents.$inferSelect;
+export type TransactionEventToInsert = typeof transactionEvents.$inferInsert;
+
+export const serviceEvents = pgTable('service_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	serviceUserId: varchar().notNull(),
+	requestId: uuid().references(() => requests.id, { onDelete: 'cascade' }).notNull(),
+	serviceRequestId: varchar().notNull(),
+	eventType: varchar().notNull(),
+	eventId: integer().notNull(),
+	appointmentEventId: varchar(),
+	eventStatus: varchar().notNull(),
+	appointmentStatus: varchar(),
+	eventMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (serviceEvents) => [
+	index().on(serviceEvents.profileId),
+	index().on(serviceEvents.serviceUserId),
+	index().on(serviceEvents.requestId),
+	index().on(serviceEvents.serviceRequestId),
+	index().on(serviceEvents.eventId),
+	index().on(serviceEvents.eventType),
+	index().on(serviceEvents.eventStatus),
+]);
+
+export type ServiceEvent = typeof serviceEvents.$inferSelect;
+export type ServiceEventToInsert = typeof serviceEvents.$inferInsert;
+
+export type PartnerSubscriptionType = 'promo' | 'referral' | 'custom_package';
+
+export const partnerSubscriptions = pgTable('partner_subscriptions', {
+	id: uuid().defaultRandom().primaryKey(),
+	partnerId: uuid().references(() => partners.id, { onDelete: 'cascade' }).notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	promoCode: varchar(),
+	referralCode: varchar(),
+	subscriptionType: varchar().$type<PartnerSubscriptionType>().notNull(),
+	expiredAt: timestamp({ withTimezone: true }).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (partnerSubscriptions) => [
+	uniqueIndex().on(partnerSubscriptions.profileId, partnerSubscriptions.partnerId),
+	index().on(partnerSubscriptions.profileId),
+	index().on(partnerSubscriptions.partnerId),
+	index().on(partnerSubscriptions.promoCode),
+	index().on(partnerSubscriptions.referralCode),
+	index().on(partnerSubscriptions.subscriptionType),
+	index().on(partnerSubscriptions.expiredAt),
+]);
+
+export type PartnerSubscription = typeof partnerSubscriptions.$inferSelect;
+export type PartnerSubscriptionToInsert = typeof partnerSubscriptions.$inferInsert;
+
+export const reversals = pgTable('reversals', {
+	id: uuid().defaultRandom().primaryKey(),
+	token: varchar().notNull(),
+	transactionId: uuid().notNull().references(() => transactions.id),
+	reversalId: varchar().notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	requestId: uuid().references(() => requests.id).notNull(),
+	reversalStatus: varchar({ length: 50 }).notNull(),
+	amount: decimal({ precision: 10, scale: 2 }).notNull(),
+	centAmount: integer().generatedAlwaysAs((): SQL => sql`${reversals.amount} * 100`),
+	currency: varchar({ length: 10 }).notNull(),
+	reversalMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.token),
+	index().on(table.transactionId),
+	index().on(table.profileId),
+	index().on(table.requestId),
+	index().on(table.reversalStatus),
+	index().on(table.reversalId),
+]);
+
+export type Reversal = typeof reversals.$inferSelect;
+export type ReversalToInsert = typeof reversals.$inferInsert;
+
+export type ReversalEventType = 'reversal.created' | 'reversal.updated';
+
+export const reversalEvents = pgTable('reversal_events', {
+	id: uuid().defaultRandom().primaryKey(),
+	eventType: varchar({ length: 50 }).$type<ReversalEventType>().notNull(),
+	eventId: varchar().notNull(),
+	reversalId: uuid().references(() => reversals.id, { onDelete: 'cascade' }).notNull(),
+	transactionId: uuid().references(() => transactions.id, { onDelete: 'cascade' }).notNull(),
+	eventMetadata: jsonb().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex().on(table.eventId),
+	index().on(table.eventType),
+	index().on(table.transactionId),
+	index().on(table.reversalId),
+]);
+
+export type ReversalEvent = typeof reversalEvents.$inferSelect;
+export type ReversalEventToInsert = typeof reversalEvents.$inferInsert;
+
+export const schedules = pgTable('schedules', {
+	id: uuid().defaultRandom().primaryKey(),
+	profileId: uuid()
+		.references(() => profiles.id, { onDelete: 'cascade' })
+		.notNull(),
+	scheduleTitle: varchar({ length: 255 }).notNull(),
+	description: text(),
+	startDate: timestamp({ withTimezone: true }).notNull(),
+	endDate: timestamp({ withTimezone: true }),
+	isCurrent: boolean().default(false).notNull(),
+	themeColor: varchar({ length: 50 }).notNull(),
+	isPrivate: boolean().default(false).notNull(),
+	applyToAllCharts: boolean().default(false).notNull(),
+	isVisible: boolean().default(true).notNull(),
+	isArchived: boolean().default(false).notNull(),
+	profileActions: jsonb(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+	updatedAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+}, (table) => [
+	index().on(table.profileId),
+	index().on(table.startDate, table.endDate),
+]);
+
+export type Schedule = typeof schedules.$inferSelect;
+export type ScheduleToInsert = typeof schedules.$inferInsert;
+
+export const schedulesToIdentifiers = pgTable('schedules_to_identifiers', {
+	scheduleId: uuid()
+		.references(() => schedules.id, {
+			onDelete: 'cascade',
+		})
+		.notNull(),
+	identifierId: uuid()
+		.references(() => identifiers.id, {
+			onDelete: 'cascade',
+		})
+		.notNull(),
+	createdAt: timestamp({ withTimezone: true })
+		.defaultNow()
+		.notNull(),
+}, (table) => [
+	primaryKey({ columns: [table.scheduleId, table.identifierId] }),
+	index().on(table.identifierId),
+]);
+
+export type ScheduleToIdentifier = typeof schedulesToIdentifiers.$inferSelect;
+export type ScheduleToIdentifierToInsert = typeof schedulesToIdentifiers.$inferInsert;
+
+export const scheduleShares = pgTable('schedule_shares', {
+	id: uuid().defaultRandom().primaryKey(),
+	shareToken: text().notNull().unique(),
+	scheduleId: uuid().references(() => schedules.id, { onDelete: 'cascade' }).notNull(),
+	profileId: uuid().references(() => profiles.id, { onDelete: 'cascade' }).notNull(),
+	accessCount: integer().default(0).notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (table) => [
+	index().on(table.shareToken),
+	index().on(table.scheduleId),
+	index().on(table.profileId),
+]);
+
+export type ScheduleShare = typeof scheduleShares.$inferSelect;
+export type ScheduleShareToInsert = typeof scheduleShares.$inferInsert;
+
+export const processingProviders = pgTable('processing_providers', {
+	id: uuid().defaultRandom().primaryKey(),
+	processor: varchar().$type<PaymentProcessor>().notNull(),
+	isActive: boolean().notNull(),
+	createdAt: timestamp({ withTimezone: true }).defaultNow().notNull(),
+}, (processingProviders) => [
+	index().on(processingProviders.processor),
+	index().on(processingProviders.isActive),
+]);
+
+export type ProcessingProvider = typeof processingProviders.$inferSelect;
diff --git a/drizzle-kit/tests/postgres/snapshots/schema03.ts b/drizzle-kit/tests/postgres/snapshots/schema03.ts
new file mode 100644
index 0000000000..0456142084
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema03.ts
@@ -0,0 +1,1138 @@
+import { eq, sql } from 'orm044';
+import {
+	AnyPgColumn,
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	check,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	index,
+	inet,
+	integer,
+	interval,
+	jsonb,
+	numeric,
+	pgEnum,
+	pgPolicy,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+} from 'orm044/pg-core';
+
+// generated with AI and updated manually in some places
+
+export const core = pgSchema('core');
+export const analytics = pgSchema('analytics');
+export const billing = pgSchema('billing');
+export const monitoring = pgSchema('monitoring');
+export const alertAction = pgEnum('alert_action', ['email', 'pagerd/ut"\'y', 'slack', 'webhook']);
+export const currencyCode = pgEnum('currency_code', ['USD', 'EUR', 'GBP', 'UAH', 'JPY']);
+export const datasetVisibility = pgEnum('dataset_visibility', ['priv"ate', 'team', 'public']);
+export const env = pgEnum('env', ['dev', 'staging', 'prod']);
+export const featureState = pgEnum('feature_state', ['enabled', 'disabled', 'gradual']);
+export const invoiceStatus = pgEnum('invoice_status', ['draft', "iss'ued", 'paid', 'voided', 'failed']);
+export const jobState = pgEnum('job_state', ['queued', 'running', 'success', 'failed', 'cancelled']);
+export const notificationChannel = pgEnum('notification_channel', ['email', 'sms', 'in_app', 'webhook']);
+export const paymentMethod = pgEnum('payment_method', ['card', 'bank_transfer', 'paypal', 'crypto']);
+export const pipelineStatus = pgEnum('pipeline_status', ['created', 'running', 'paused', 'completed', 'errored']);
+export const roleKind = pgEnum('role_kind', ['system', 'custom']);
+export const ruleConditionOperator = pgEnum('rule_condition_operator', [
+	'eq',
+	'neq',
+	'gt',
+	'lt',
+	'gte',
+	'lte',
+	'in',
+	'nin',
+]);
+export const severityLevel = pgEnum('severity_level', ['low', 'medium', 'high', 'critical']);
+export const userStatus = pgEnum('user_status', ['active', 'inactive', 'suspended', 'pending']);
+
+export const seqOrgCode = pgSequence('seq_org_code', {
+	startWith: '1000',
+	increment: '1',
+	minValue: '1',
+	maxValue: '9223372036854775807',
+	cache: '1',
+	cycle: false,
+});
+
+export const organizationsInCore = core.table('organizations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: bigint({ mode: 'number' }).default(sql`nextval('seq_org_code'::regclass)`).notNull(),
+	name: text().notNull(),
+	domain: text(),
+	currency: currencyCode().default('EUR').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_org_name_idx').using('btree', table.name.asc().nullsLast().op('text_ops')),
+	index('organizations_code_idx').using('btree', table.code.asc().nullsLast().op('int8_ops')),
+	unique('organizations_domain_key').on(table.domain),
+	check('organizations_name_check', sql`char_length(name) > 1`),
+]);
+
+export const usersInCore = core.table('users', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	username: text().notNull(),
+	status: userStatus().default('pending').notNull(),
+	locale: text().default('en-US').notNull(),
+	lastLogin: timestamp('last_login', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	bio: text().$onUpdate(() => sql`bio || 'some test'`),
+	profile: jsonb(),
+}, (table) => [
+	index('core_users_username_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.username.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'users_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('users_org_username_unique').on(table.organizationId, table.username),
+]);
+
+export const rolesInCore = core.table('roles', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull().references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+	name: text().notNull(),
+	kind: roleKind().default('custom').notNull(),
+	builtin: boolean().default(false).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	unique('roles_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const permissionsInCore = core.table('permissions', {
+	id: serial().primaryKey().notNull(),
+	code: text().notNull().unique(),
+	description: text(),
+});
+
+export const membershipsInCore = core.table('memberships', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	roleId: integer('role_id').notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	joinedAt: timestamp('joined_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'memberships_user_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'memberships_role_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'memberships_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('unique_membership').on(table.userId, table.organizationId),
+]);
+
+export const apiKeysInCore = core.table('api_keys', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	userId: uuid('user_id'),
+	name: text().notNull(),
+	keyHash: text('key_hash').notNull(),
+	revoked: boolean().default(false).notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb().generatedAlwaysAs(sql`'{"some":"test"}'`),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_apikey_org_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(revoked = false)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'api_keys_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'api_keys_user_id_fkey',
+	}).onDelete('set null'),
+	unique('api_keys_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const sessionsInCore = core.table('sessions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	ip: inet(),
+	userAgent: text('user_agent'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }).notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	index('core_sessions_user_expires').using(
+		'btree',
+		table.userId.asc().nullsLast(),
+		table.expiresAt.asc().nullsLast().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'sessions_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const oauthProvidersInCore = core.table('oauth_providers', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	provider: text().notNull(),
+	clientId: text('client_id').notNull(),
+	clientSecret: text('client_secret').notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'oauth_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('oauth_providers_organization_id_provider_key').on(table.organizationId, table.provider),
+]);
+
+export const featureFlagsInCore = core.table('feature_flags', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	state: featureState().default('disabled').notNull(),
+	rolloutPercent: smallint('rollout_percent').default(0),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'feature_flags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('feature_flags_organization_id_key_key').on(table.organizationId, table.key),
+	check('feature_flags_rollout_percent_check', sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`),
+]);
+
+export const projectsInCore = core.table('projects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	slug: text().notNull(),
+	description: text(),
+	visibility: datasetVisibility().default('priv"ate').notNull(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_projects_org_name_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.name.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'projects_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'projects_created_by_fkey',
+	}),
+	unique('projects_org_slug_unique').on(table.organizationId, table.slug),
+]);
+
+export const repositoriesInCore = core.table('repositories', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	provider: text().notNull(),
+	repoOwner: text('repo_owner').notNull(),
+	repoName: text('repo_name').notNull(),
+	defaultBranch: text('default_branch').default('main').notNull(),
+	cloneUrl: text('clone_url'),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'repositories_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('repositories_project_id_provider_repo_owner_repo_name_key').on(
+		table.projectId,
+		table.provider,
+		table.repoOwner,
+		table.repoName,
+	),
+]);
+
+export const buildsInCore = core.table('builds', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	triggeredBy: uuid('triggered_by'),
+	commitSha: char('commit_sha', { length: 40 }).notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	index('core_builds_project_status_idx').using(
+		'btree',
+		table.projectId.asc().nullsLast().op('uuid_ops'),
+		table.status.asc().nullsLast(),
+	),
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'builds_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.triggeredBy],
+		foreignColumns: [usersInCore.id],
+		name: 'builds_triggered_by_fkey',
+	}),
+	unique('builds_project_id_commit_sha_key').on(table.projectId, table.commitSha),
+]);
+
+export const pipelinesInCore = core.table('pipelines', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	name: text().notNull(),
+	spec: jsonb().notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'pipelines_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipelines_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const pipelineRunsInAnalytics = analytics.table('pipeline_runs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineId: uuid('pipeline_id').notNull(),
+
+	runNumber: bigint('run_number', { mode: 'number' }).notNull(),
+	state: jobState().default('queued').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	logs: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_pipeline_runs_state_idx').using('btree', table.state.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.pipelineId],
+		foreignColumns: [pipelinesInCore.id],
+		name: 'pipeline_runs_pipeline_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipeline_runs_unique_run').on(table.pipelineId, table.runNumber),
+]);
+
+export const jobsInAnalytics = analytics.table('jobs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineRunId: uuid('pipeline_run_id'),
+	name: text().notNull(),
+	state: jobState().default('queued').notNull(),
+	attempts: integer().default(0).notNull(),
+	lastError: text('last_error'),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_jobs_state_attempts_idx').using(
+		'btree',
+		table.state.asc().nullsLast(),
+		table.attempts.asc().nullsLast().op('int4_ops'),
+	),
+	foreignKey({
+		columns: [table.pipelineRunId],
+		foreignColumns: [pipelineRunsInAnalytics.id],
+		name: 'jobs_pipeline_run_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const storageBucketsInCore = core.table('storage_buckets', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	region: text().notNull(),
+	config: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'storage_buckets_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('storage_buckets_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const objectsInCore = core.table('objects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	bucketId: uuid('bucket_id').notNull(),
+	path: text().notNull(),
+
+	size: bigint({ mode: 'number' }).default(0).notNull(),
+	contentType: text('content_type'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_objects_bucket_path_gin').using('gin', table.metadata.asc().nullsLast().op('jsonb_ops')),
+	foreignKey({
+		columns: [table.bucketId],
+		foreignColumns: [storageBucketsInCore.id],
+		name: 'objects_bucket_id_fkey',
+	}).onDelete('cascade'),
+	unique('objects_bucket_id_path_key').on(table.bucketId, table.path),
+]);
+
+export const filesInCore = core.table('files', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	name: text().notNull(),
+	latestObjectId: uuid('latest_object_id'),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'files_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.latestObjectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'files_latest_object_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'files_created_by_fkey',
+	}),
+	unique('files_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const fileVersionsInCore = core.table('file_versions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	fileId: uuid('file_id').notNull(),
+	objectId: uuid('object_id').notNull(),
+	versionNumber: integer('version_number').notNull(),
+	checksum: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.fileId],
+		foreignColumns: [filesInCore.id],
+		name: 'file_versions_file_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.objectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'file_versions_object_id_fkey',
+	}).onDelete('cascade'),
+	unique('file_versions_file_id_version_number_key').on(table.fileId, table.versionNumber),
+]);
+
+export const tagsInCore = core.table('tags', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	value: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'tags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('tags_organization_id_key_value_key').on(table.organizationId, table.key, table.value),
+]);
+
+export const conversationsInCore = core.table('conversations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	title: text(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'conversations_project_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'conversations_created_by_fkey',
+	}),
+]);
+
+export const chatMessagesInCore = core.table('chat_messages', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	conversationId: uuid('conversation_id').notNull(),
+	senderId: uuid('sender_id'),
+	body: text().notNull(),
+	attachments: jsonb(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	editedAt: timestamp('edited_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	index('core_chat_conv_sent_at_idx').using(
+		'btree',
+		table.conversationId.asc().nullsLast(),
+		table.sentAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.conversationId],
+		foreignColumns: [conversationsInCore.id],
+		name: 'chat_messages_conversation_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.senderId],
+		foreignColumns: [usersInCore.id],
+		name: 'chat_messages_sender_id_fkey',
+	}).onDelete('set null'),
+]);
+
+export const notificationsInCore = core.table('notifications', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	channel: notificationChannel().default('in_app').notNull(),
+	payload: jsonb().notNull(),
+	seen: boolean().default(false).notNull(),
+	deliveredAt: timestamp('delivered_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_notifications_unseen_idx').using('btree', table.userId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(seen = false)`,
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'notifications_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const customersInBilling = billing.table('customers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	name: text().notNull(),
+	address: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'customers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('customers_organization_id_key').on(table.organizationId),
+	unique('idnameunique').on(table.id, table.name),
+]);
+
+export const subscriptionsInBilling = billing.table('subscriptions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	plan: text().notNull(),
+	status: text().default('active').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	endedAt: timestamp('ended_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'subscriptions_customer_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const paymentsInBilling = billing.table('payments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	invoiceId: uuid('invoice_id').notNull(),
+	paidAt: timestamp('paid_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	amount: numeric({ precision: 12, scale: 2 }).notNull(),
+	amount2: decimal({ precision: 12, scale: 2 }).notNull(),
+	method: paymentMethod().notNull(),
+	transactionRef: text('transaction_ref'),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.invoiceId],
+		foreignColumns: [invoicesInBilling.id],
+		name: 'payments_invoice_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const couponsInBilling = billing.table('coupons', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+	discountPercent: smallint('discount_percent'),
+	redeemableFrom: timestamp('redeemable_from', { withTimezone: true, mode: 'string' }),
+	redeemableTo: timestamp('redeemable_to', { withTimezone: true, mode: 'string' }),
+	maxRedemptions: integer('max_redemptions').generatedAlwaysAsIdentity(),
+	metadata: jsonb(),
+}, (table) => [
+	unique('coupons_code_key').on(table.code),
+	check('coupons_discount_percent_check', sql`(discount_percent >= 0) AND (discount_percent <= 100)`),
+]);
+
+export const webhooksInCore = core.table('webhooks', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	url: text().notNull(),
+	secret: text(),
+	events: text().array().notNull(),
+	active: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_webhooks_org_active_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(active = true)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'webhooks_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const metricSourcesInAnalytics = analytics.table('metric_sources', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'metric_sources_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('metric_sources_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const metricsInAnalytics = analytics.table('metrics', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	sourceId: uuid('source_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	ts: timestamp({ withTimezone: true, mode: 'string' }).notNull(),
+	value: doublePrecision().notNull(),
+	tags: jsonb(),
+}, (table) => [
+	index('analytics_metrics_key_ts_idx').using(
+		'btree',
+		table.metricKey.asc().nullsLast().op('text_ops'),
+		table.ts.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.sourceId],
+		foreignColumns: [metricSourcesInAnalytics.id],
+		name: 'metrics_source_id_fkey',
+	}).onDelete('cascade'),
+	unique('metrics_source_id_metric_key_ts_key').on(table.sourceId, table.metricKey, table.ts),
+]);
+
+export const alertRulesInMonitoring = monitoring.table('alert_rules', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	description: text(),
+	severity: severityLevel().default('medium').notNull(),
+	enabled: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'alert_rules_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('alert_rules_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const ruleConditionsInMonitoring = monitoring.table('rule_conditions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	operator: ruleConditionOperator().notNull().unique('some_name', { nulls: 'not distinct' }),
+	threshold: doublePrecision().notNull(),
+	window: interval().default('00:05:00').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'rule_conditions_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const alertsInMonitoring = monitoring.table('alerts', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	triggeredAt: timestamp('triggered_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	resolvedAt: timestamp('resolved_at', { withTimezone: true, mode: 'string' }),
+	payload: jsonb(),
+	state: text().default('firing').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'alerts_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const escalationsInMonitoring = monitoring.table('escalations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	alertId: uuid('alert_id').notNull(),
+	action: alertAction().notNull(),
+	target: text().notNull(),
+	executedAt: timestamp('executed_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	foreignKey({
+		columns: [table.alertId],
+		foreignColumns: [alertsInMonitoring.id],
+		name: 'escalations_alert_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const ssoProvidersInCore = core.table('sso_providers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	config: jsonb().notNull(),
+	enabled: boolean().default(false).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'sso_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const auditLogsInCore = core.table('audit_logs', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	actorId: uuid('actor_id'),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').array().array().array(),
+	action: text().notNull(),
+	beforeState: jsonb('before_state'),
+	afterState: jsonb('after_state'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_audit_org_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.createdAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+]);
+
+export const rateLimitsInCore = core.table('rate_limits', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	apiKeyId: uuid('api_key_id').notNull(),
+	windowStart: timestamp('window_start', { withTimezone: true, mode: 'string' }).notNull(),
+	requests: integer().generatedByDefaultAsIdentity().notNull(),
+	limit: integer().generatedAlwaysAs(() => sql`1`).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.apiKeyId],
+		foreignColumns: [apiKeysInCore.id],
+		name: 'rate_limits_api_key_id_fkey',
+	}).onDelete('cascade'),
+	unique('rate_limits_api_key_id_window_start_key').on(table.apiKeyId, table.windowStart).nullsNotDistinct(),
+]);
+
+export const experimentsInCore = core.table('experiments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'experiments_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiments_organization_id_key_key').on(table.organizationId, table.key),
+]);
+
+export const experimentVariantsInCore = core.table('experiment_variants', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	name: text().notNull(),
+	allocationPercent: smallint('allocation_percent').default(0).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_variants_experiment_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_variants_experiment_id_name_key').on(table.experimentId, table.name),
+	check('experiment_variants_allocation_percent_check', sql`(allocation_percent >= 0) AND (allocation_percent <= 100)`),
+]);
+
+export const experimentAssignmentsInCore = core.table('experiment_assignments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	variantId: uuid('variant_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_assignments_experiment_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.variantId],
+		foreignColumns: [experimentVariantsInCore.id],
+		name: 'experiment_assignments_variant_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'experiment_assignments_user_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_assignments_experiment_id_user_id_key').on(table.experimentId, table.userId),
+]);
+
+export const deploymentsInCore = core.table('deployments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	environment: env().default('dev').notNull(),
+	version: text().notNull(),
+	deployedBy: uuid('deployed_by'),
+	deployedAt: timestamp('deployed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	notes: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'deployments_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.deployedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'deployments_deployed_by_fkey',
+	}),
+	unique('deployments_project_id_environment_version_key').on(table.projectId, table.environment, table.version),
+]);
+
+export const servicesInCore = core.table('services', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	kind: text(),
+	ownerId: uuid('owner_id'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string', precision: 6 }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'services_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.ownerId],
+		foreignColumns: [usersInCore.id],
+		name: 'services_owner_id_fkey',
+	}),
+	unique('services_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const locksInCore = core.table('locks', {
+	name: text().primaryKey().notNull(),
+	owner: text(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string', precision: 2 }),
+});
+
+export const entitiesInCore = core.table('entities', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	data: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'entities_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const taskQueueInAnalytics = analytics.table('task_queue', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	queueName: text('queue_name').default('default').notNull(),
+	payload: jsonb().notNull(),
+	priority: smallint().default(100).notNull(),
+	reserved: boolean().default(false).notNull(),
+	reservedUntil: timestamp('reserved_until', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex('analytics_task_queue_unique_unreserved').using(
+		'btree',
+		sql`queue_name`,
+		sql`((payload ->> 'task_type'::text))`,
+	).where(sql`(reserved = false)`),
+]);
+
+export const invoicesInBilling = billing.table('invoices', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	number: text().notNull(),
+	issuedAt: timestamp('issued_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	dueAt: timestamp('due_at', { withTimezone: true, mode: 'string' }),
+	totalAmount: numeric('total_amount', { precision: 12, scale: 2 }).default('0.0').notNull(),
+	currency: currencyCode().default('USD').notNull(),
+	status: invoiceStatus().default('draft').notNull(),
+	notes: text(),
+}, (table) => [
+	index('billing_invoices_status_idx').using('btree', table.status.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.customerId, table.number],
+		foreignColumns: [customersInBilling.id, customersInBilling.name],
+		name: 'invoices_customer_id_fkey',
+	}).onDelete('cascade'),
+	unique('invoices_customer_id_number_key').on(table.customerId, table.number),
+	check('invoices_total_nonnegative', sql`total_amount >= (0)::numeric`),
+]);
+
+export const aliasesInCore = core.table('aliases', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	alias: text().notNull().unique('unique_with_name'),
+	organizationId: uuid('organization_id'),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'aliases_organization_id_fkey',
+	}).onUpdate('cascade'),
+	unique('aliases_object_type_object_id_alias_key').on(table.objectType, table.objectId, table.alias),
+]);
+
+export const selfRef = core.table('self_ref', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull().unique().references((): AnyPgColumn => selfRef.organizationId),
+	organizationId: text('organization_id').notNull().unique(),
+});
+
+export const couponRedemptionsInBilling = billing.table('coupon_redemptions', {
+	couponId: uuid('coupon_id').notNull(),
+	customerId: uuid('customer_id').notNull(),
+	redeemedAt: timestamp('redeemed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.couponId],
+		foreignColumns: [couponsInBilling.id],
+		name: 'coupon_redemptions_coupon_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'coupon_redemptions_customer_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.couponId, table.customerId], name: 'coupon_redemptions_pkey' }),
+]);
+
+export const entityLinksInCore = core.table('entity_links', {
+	parentEntityId: uuid('parent_entity_id').notNull(),
+	childEntityId: uuid('child_entity_id').notNull(),
+	relationship: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.parentEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_parent_entity_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.childEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_child_entity_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.parentEntityId, table.childEntityId, table.relationship], name: 'entity_links_pkey' }),
+]);
+
+export const rolePermissionsInCore = core.table('role_permissions', {
+	roleId: integer('role_id').notNull(),
+	permissionId: integer('permission_id').notNull(),
+	assignedBy: uuid('assigned_by'),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'role_permissions_role_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.permissionId],
+		foreignColumns: [permissionsInCore.id],
+		name: 'role_permissions_permission_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.assignedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'role_permissions_assigned_by_fkey',
+	}),
+	primaryKey({ columns: [table.roleId, table.permissionId], name: 'role_permissions_pkey' }),
+]);
+
+export const taggingsInCore = core.table('taggings', {
+	tagId: integer('tag_id').notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.tagId],
+		foreignColumns: [tagsInCore.id],
+		name: 'taggings_tag_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.tagId, table.objectType, table.objectId], name: 'taggings_pkey' }),
+]);
+
+export const reactionsInCore = core.table('reactions', {
+	messageId: uuid('message_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	reaction: text().notNull().array(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.messageId],
+		foreignColumns: [chatMessagesInCore.id],
+		name: 'reactions_message_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'reactions_user_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.messageId, table.userId, table.reaction], name: 'reactions_pkey' }),
+]);
+
+// views
+export const projectSearchInAnalytics = analytics.materializedView('project_search', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().as(
+		sql`SELECT id, name, slug, description FROM core.projects p`,
+	);
+
+export const projectSearchInAnalytics2 = analytics.materializedView('project_search2', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().existing();
+
+export const vActiveUsersInCore = core.view('v_active_users').as((qb) =>
+	qb.select({
+		id: usersInCore.id,
+		username: usersInCore.username,
+		organization_id: usersInCore.organizationId,
+	}).from(usersInCore).where(eq(usersInCore.status, 'active'))
+);
+export const vActiveUsersInCore2 = core.view('v_active_users2', {}).existing();
+
+// polices
+export const rls = pgSchema('rls');
+export const documentsInRls = rls.table('documents', {
+	docId: uuid('doc_id').defaultRandom().primaryKey().notNull(),
+	ownerId: uuid('owner_id').notNull(),
+	title: text().notNull(),
+	content: text().notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('documents_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(owner_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('documents_update_own', { as: 'permissive', for: 'update', to: ['public'] }),
+	pgPolicy('documents_select_own', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const messagesInRls = rls.table('messages', {
+	msgId: uuid('msg_id').defaultRandom().primaryKey().notNull(),
+	senderId: uuid('sender_id').notNull(),
+	recipientId: uuid('recipient_id').notNull(),
+	message: text().notNull(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('messages_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(sender_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('messages_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+]).enableRLS();
+
+export const projectsInRls = rls.table('projects', {
+	projectId: uuid('project_id').defaultRandom().primaryKey().notNull(),
+	name: text().notNull(),
+	description: text(),
+	ownerId: uuid('owner_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('projects_visibility', {
+		as: 'permissive',
+		for: 'select',
+		to: ['public'],
+		using: sql`((owner_id = (CURRENT_USER)::uuid) OR (project_id IN ( SELECT pm.project_id
+   FROM rls.project_members pm
+  WHERE (pm.user_id = (CURRENT_USER)::uuid))))`,
+	}),
+]);
+
+export const projectMembersInRls = rls.table('project_members', {
+	projectId: uuid('project_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	role: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInRls.projectId],
+		name: 'project_members_project_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.projectId, table.userId], name: 'project_members_pkey' }),
+	pgPolicy('project_members_manage', {
+		as: 'permissive',
+		for: 'all',
+		to: ['public'],
+		using: sql`(project_id IN ( SELECT p.project_id
+   FROM rls.projects p
+  WHERE (p.owner_id = (CURRENT_USER)::uuid)))`,
+	}),
+	pgPolicy('project_members_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+	check('project_members_role_check', sql`role = ANY (ARRAY['member'::text, 'admin'::text])`),
+]).enableRLS();
+
+export const policy = pgPolicy('new_policy', {
+	as: 'restrictive',
+	to: 'postgres',
+	withCheck: sql`1 = 1`,
+	for: 'all',
+}).link(organizationsInCore);
diff --git a/drizzle-kit/tests/postgres/snapshots/schema03new.ts b/drizzle-kit/tests/postgres/snapshots/schema03new.ts
new file mode 100644
index 0000000000..d81478ce74
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema03new.ts
@@ -0,0 +1,1138 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	AnyPgColumn,
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	check,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	index,
+	inet,
+	integer,
+	interval,
+	jsonb,
+	numeric,
+	pgEnum,
+	pgPolicy,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uuid,
+} from 'drizzle-orm/pg-core';
+
+// generated with AI and updated manually in some places
+
+export const core = pgSchema('core');
+export const analytics = pgSchema('analytics');
+export const billing = pgSchema('billing');
+export const monitoring = pgSchema('monitoring');
+export const alertAction = pgEnum('alert_action', ['email', 'pagerd/ut"\'y', 'slack', 'webhook']);
+export const currencyCode = pgEnum('currency_code', ['USD', 'EUR', 'GBP', 'UAH', 'JPY']);
+export const datasetVisibility = pgEnum('dataset_visibility', ['priv"ate', 'team', 'public']);
+export const env = pgEnum('env', ['dev', 'staging', 'prod']);
+export const featureState = pgEnum('feature_state', ['enabled', 'disabled', 'gradual']);
+export const invoiceStatus = pgEnum('invoice_status', ['draft', "iss'ued", 'paid', 'voided', 'failed']);
+export const jobState = pgEnum('job_state', ['queued', 'running', 'success', 'failed', 'cancelled']);
+export const notificationChannel = pgEnum('notification_channel', ['email', 'sms', 'in_app', 'webhook']);
+export const paymentMethod = pgEnum('payment_method', ['card', 'bank_transfer', 'paypal', 'crypto']);
+export const pipelineStatus = pgEnum('pipeline_status', ['created', 'running', 'paused', 'completed', 'errored']);
+export const roleKind = pgEnum('role_kind', ['system', 'custom']);
+export const ruleConditionOperator = pgEnum('rule_condition_operator', [
+	'eq',
+	'neq',
+	'gt',
+	'lt',
+	'gte',
+	'lte',
+	'in',
+	'nin',
+]);
+export const severityLevel = pgEnum('severity_level', ['low', 'medium', 'high', 'critical']);
+export const userStatus = pgEnum('user_status', ['active', 'inactive', 'suspended', 'pending']);
+
+export const seqOrgCode = pgSequence('seq_org_code', {
+	startWith: '1000',
+	increment: '1',
+	minValue: '1',
+	maxValue: '9223372036854775807',
+	cache: '1',
+	cycle: false,
+});
+
+export const organizationsInCore = core.table('organizations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: bigint({ mode: 'number' }).default(sql`nextval('seq_org_code'::regclass)`).notNull(),
+	name: text().notNull(),
+	domain: text(),
+	currency: currencyCode().default('EUR').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_org_name_idx').using('btree', table.name.asc().nullsLast().op('text_ops')),
+	index('organizations_code_idx').using('btree', table.code.asc().nullsLast().op('int8_ops')),
+	unique('organizations_domain_key').on(table.domain),
+	check('organizations_name_check', sql`char_length(name) > 1`),
+]);
+
+export const usersInCore = core.table('users', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	username: text().notNull(),
+	status: userStatus().default('pending').notNull(),
+	locale: text().default('en-US').notNull(),
+	lastLogin: timestamp('last_login', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	bio: text().$onUpdate(() => sql`bio || 'some test'`),
+	profile: jsonb(),
+}, (table) => [
+	index('core_users_username_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.username.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'users_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('users_org_username_unique').on(table.organizationId, table.username),
+]);
+
+export const rolesInCore = core.table('roles', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull().references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+	name: text().notNull(),
+	kind: roleKind().default('custom').notNull(),
+	builtin: boolean().default(false).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	unique('roles_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const permissionsInCore = core.table('permissions', {
+	id: serial().primaryKey().notNull(),
+	code: text().notNull().unique(),
+	description: text(),
+});
+
+export const membershipsInCore = core.table('memberships', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	roleId: integer('role_id').notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	joinedAt: timestamp('joined_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'memberships_user_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'memberships_role_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'memberships_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('unique_membership').on(table.userId, table.organizationId),
+]);
+
+export const apiKeysInCore = core.table('api_keys', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	userId: uuid('user_id'),
+	name: text().notNull(),
+	keyHash: text('key_hash').notNull(),
+	revoked: boolean().default(false).notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb().generatedAlwaysAs(sql`'{"some":"test"}'`),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_apikey_org_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(revoked = false)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'api_keys_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'api_keys_user_id_fkey',
+	}).onDelete('set null'),
+	unique('api_keys_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const sessionsInCore = core.table('sessions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	ip: inet(),
+	userAgent: text('user_agent'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string' }).notNull(),
+	active: boolean().default(true).notNull(),
+}, (table) => [
+	index('core_sessions_user_expires').using(
+		'btree',
+		table.userId.asc().nullsLast(),
+		table.expiresAt.asc().nullsLast().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'sessions_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const oauthProvidersInCore = core.table('oauth_providers', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	provider: text().notNull(),
+	clientId: text('client_id').notNull(),
+	clientSecret: text('client_secret').notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'oauth_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('oauth_providers_organization_id_provider_key').on(table.organizationId, table.provider),
+]);
+
+export const featureFlagsInCore = core.table('feature_flags', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	state: featureState().default('disabled').notNull(),
+	rolloutPercent: smallint('rollout_percent').default(0),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'feature_flags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('feature_flags_organization_id_key_key').on(table.organizationId, table.key),
+	check('feature_flags_rollout_percent_check', sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`),
+]);
+
+export const projectsInCore = core.table('projects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	slug: text().notNull(),
+	description: text(),
+	visibility: datasetVisibility().default('priv"ate').notNull(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_projects_org_name_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.name.asc().nullsLast().op('text_ops'),
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'projects_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'projects_created_by_fkey',
+	}),
+	unique('projects_org_slug_unique').on(table.organizationId, table.slug),
+]);
+
+export const repositoriesInCore = core.table('repositories', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	provider: text().notNull(),
+	repoOwner: text('repo_owner').notNull(),
+	repoName: text('repo_name').notNull(),
+	defaultBranch: text('default_branch').default('main').notNull(),
+	cloneUrl: text('clone_url'),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'repositories_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('repositories_project_id_provider_repo_owner_repo_name_key').on(
+		table.projectId,
+		table.provider,
+		table.repoOwner,
+		table.repoName,
+	),
+]);
+
+export const buildsInCore = core.table('builds', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	triggeredBy: uuid('triggered_by'),
+	commitSha: char('commit_sha', { length: 40 }).notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	index('core_builds_project_status_idx').using(
+		'btree',
+		table.projectId.asc().nullsLast().op('uuid_ops'),
+		table.status.asc().nullsLast(),
+	),
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'builds_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.triggeredBy],
+		foreignColumns: [usersInCore.id],
+		name: 'builds_triggered_by_fkey',
+	}),
+	unique('builds_project_id_commit_sha_key').on(table.projectId, table.commitSha),
+]);
+
+export const pipelinesInCore = core.table('pipelines', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	name: text().notNull(),
+	spec: jsonb().notNull(),
+	status: pipelineStatus().default('created').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'pipelines_project_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipelines_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const pipelineRunsInAnalytics = analytics.table('pipeline_runs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineId: uuid('pipeline_id').notNull(),
+
+	runNumber: bigint('run_number', { mode: 'number' }).notNull(),
+	state: jobState().default('queued').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	logs: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_pipeline_runs_state_idx').using('btree', table.state.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.pipelineId],
+		foreignColumns: [pipelinesInCore.id],
+		name: 'pipeline_runs_pipeline_id_fkey',
+	}).onDelete('cascade'),
+	unique('pipeline_runs_unique_run').on(table.pipelineId, table.runNumber),
+]);
+
+export const jobsInAnalytics = analytics.table('jobs', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	pipelineRunId: uuid('pipeline_run_id'),
+	name: text().notNull(),
+	state: jobState().default('queued').notNull(),
+	attempts: integer().default(0).notNull(),
+	lastError: text('last_error'),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }),
+	finishedAt: timestamp('finished_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('analytics_jobs_state_attempts_idx').using(
+		'btree',
+		table.state.asc().nullsLast(),
+		table.attempts.asc().nullsLast().op('int4_ops'),
+	),
+	foreignKey({
+		columns: [table.pipelineRunId],
+		foreignColumns: [pipelineRunsInAnalytics.id],
+		name: 'jobs_pipeline_run_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const storageBucketsInCore = core.table('storage_buckets', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	region: text().notNull(),
+	config: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'storage_buckets_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('storage_buckets_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const objectsInCore = core.table('objects', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	bucketId: uuid('bucket_id').notNull(),
+	path: text().notNull(),
+
+	size: bigint({ mode: 'number' }).default(0).notNull(),
+	contentType: text('content_type'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_objects_bucket_path_gin').using('gin', table.metadata.asc().nullsLast().op('jsonb_ops')),
+	foreignKey({
+		columns: [table.bucketId],
+		foreignColumns: [storageBucketsInCore.id],
+		name: 'objects_bucket_id_fkey',
+	}).onDelete('cascade'),
+	unique('objects_bucket_id_path_key').on(table.bucketId, table.path),
+]);
+
+export const filesInCore = core.table('files', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	name: text().notNull(),
+	latestObjectId: uuid('latest_object_id'),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'files_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.latestObjectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'files_latest_object_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'files_created_by_fkey',
+	}),
+	unique('files_project_id_name_key').on(table.projectId, table.name),
+]);
+
+export const fileVersionsInCore = core.table('file_versions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	fileId: uuid('file_id').notNull(),
+	objectId: uuid('object_id').notNull(),
+	versionNumber: integer('version_number').notNull(),
+	checksum: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.fileId],
+		foreignColumns: [filesInCore.id],
+		name: 'file_versions_file_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.objectId],
+		foreignColumns: [objectsInCore.id],
+		name: 'file_versions_object_id_fkey',
+	}).onDelete('cascade'),
+	unique('file_versions_file_id_version_number_key').on(table.fileId, table.versionNumber),
+]);
+
+export const tagsInCore = core.table('tags', {
+	id: serial().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	value: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'tags_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('tags_organization_id_key_value_key').on(table.organizationId, table.key, table.value),
+]);
+
+export const conversationsInCore = core.table('conversations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id'),
+	title: text(),
+	createdBy: uuid('created_by'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'conversations_project_id_fkey',
+	}).onDelete('set null'),
+	foreignKey({
+		columns: [table.createdBy],
+		foreignColumns: [usersInCore.id],
+		name: 'conversations_created_by_fkey',
+	}),
+]);
+
+export const chatMessagesInCore = core.table('chat_messages', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	conversationId: uuid('conversation_id').notNull(),
+	senderId: uuid('sender_id'),
+	body: text().notNull(),
+	attachments: jsonb(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	editedAt: timestamp('edited_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	index('core_chat_conv_sent_at_idx').using(
+		'btree',
+		table.conversationId.asc().nullsLast(),
+		table.sentAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.conversationId],
+		foreignColumns: [conversationsInCore.id],
+		name: 'chat_messages_conversation_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.senderId],
+		foreignColumns: [usersInCore.id],
+		name: 'chat_messages_sender_id_fkey',
+	}).onDelete('set null'),
+]);
+
+export const notificationsInCore = core.table('notifications', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	userId: uuid('user_id').notNull(),
+	channel: notificationChannel().default('in_app').notNull(),
+	payload: jsonb().notNull(),
+	seen: boolean().default(false).notNull(),
+	deliveredAt: timestamp('delivered_at', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_notifications_unseen_idx').using('btree', table.userId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(seen = false)`,
+	),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'notifications_user_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const customersInBilling = billing.table('customers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	name: text().notNull(),
+	address: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'customers_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('customers_organization_id_key').on(table.organizationId),
+	unique('idnameunique').on(table.id, table.name),
+]);
+
+export const subscriptionsInBilling = billing.table('subscriptions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	plan: text().notNull(),
+	status: text().default('active').notNull(),
+	startedAt: timestamp('started_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	endedAt: timestamp('ended_at', { withTimezone: true, mode: 'string' }),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'subscriptions_customer_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const paymentsInBilling = billing.table('payments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	invoiceId: uuid('invoice_id').notNull(),
+	paidAt: timestamp('paid_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	amount: numeric({ precision: 12, scale: 2 }).notNull(),
+	amount2: decimal({ precision: 12, scale: 2 }).notNull(),
+	method: paymentMethod().notNull(),
+	transactionRef: text('transaction_ref'),
+	metadata: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.invoiceId],
+		foreignColumns: [invoicesInBilling.id],
+		name: 'payments_invoice_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const couponsInBilling = billing.table('coupons', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+	discountPercent: smallint('discount_percent'),
+	redeemableFrom: timestamp('redeemable_from', { withTimezone: true, mode: 'string' }),
+	redeemableTo: timestamp('redeemable_to', { withTimezone: true, mode: 'string' }),
+	maxRedemptions: integer('max_redemptions').generatedAlwaysAsIdentity(),
+	metadata: jsonb(),
+}, (table) => [
+	unique('coupons_code_key').on(table.code),
+	check('coupons_discount_percent_check', sql`(discount_percent >= 0) AND (discount_percent <= 100)`),
+]);
+
+export const webhooksInCore = core.table('webhooks', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	url: text().notNull(),
+	secret: text(),
+	events: text().array().notNull(),
+	active: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_webhooks_org_active_idx').using('btree', table.organizationId.asc().nullsLast().op('uuid_ops')).where(
+		sql`(active = true)`,
+	),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'webhooks_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const metricSourcesInAnalytics = analytics.table('metric_sources', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	config: jsonb(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'metric_sources_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('metric_sources_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const metricsInAnalytics = analytics.table('metrics', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	sourceId: uuid('source_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	ts: timestamp({ withTimezone: true, mode: 'string' }).notNull(),
+	value: doublePrecision().notNull(),
+	tags: jsonb(),
+}, (table) => [
+	index('analytics_metrics_key_ts_idx').using(
+		'btree',
+		table.metricKey.asc().nullsLast().op('text_ops'),
+		table.ts.desc().nullsFirst().op('timestamptz_ops'),
+	),
+	foreignKey({
+		columns: [table.sourceId],
+		foreignColumns: [metricSourcesInAnalytics.id],
+		name: 'metrics_source_id_fkey',
+	}).onDelete('cascade'),
+	unique('metrics_source_id_metric_key_ts_key').on(table.sourceId, table.metricKey, table.ts),
+]);
+
+export const alertRulesInMonitoring = monitoring.table('alert_rules', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	description: text(),
+	severity: severityLevel().default('medium').notNull(),
+	enabled: boolean().default(true).notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'alert_rules_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('alert_rules_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const ruleConditionsInMonitoring = monitoring.table('rule_conditions', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	metricKey: text('metric_key').notNull(),
+	operator: ruleConditionOperator().notNull().unique('some_name', { nulls: 'not distinct' }),
+	threshold: doublePrecision().notNull(),
+	window: interval().default('00:05:00').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'rule_conditions_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const alertsInMonitoring = monitoring.table('alerts', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	ruleId: uuid('rule_id').notNull(),
+	triggeredAt: timestamp('triggered_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	resolvedAt: timestamp('resolved_at', { withTimezone: true, mode: 'string' }),
+	payload: jsonb(),
+	state: text().default('firing').notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.ruleId],
+		foreignColumns: [alertRulesInMonitoring.id],
+		name: 'alerts_rule_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const escalationsInMonitoring = monitoring.table('escalations', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	alertId: uuid('alert_id').notNull(),
+	action: alertAction().notNull(),
+	target: text().notNull(),
+	executedAt: timestamp('executed_at', { withTimezone: true, mode: 'string' }),
+}, (table) => [
+	foreignKey({
+		columns: [table.alertId],
+		foreignColumns: [alertsInMonitoring.id],
+		name: 'escalations_alert_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const ssoProvidersInCore = core.table('sso_providers', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	config: jsonb().notNull(),
+	enabled: boolean().default(false).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'sso_providers_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const auditLogsInCore = core.table('audit_logs', {
+	id: bigserial({ mode: 'bigint' }).primaryKey().notNull(),
+	organizationId: uuid('organization_id'),
+	actorId: uuid('actor_id'),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').array('[][][]'),
+	action: text().notNull(),
+	beforeState: jsonb('before_state'),
+	afterState: jsonb('after_state'),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	index('core_audit_org_idx').using(
+		'btree',
+		table.organizationId.asc().nullsLast(),
+		table.createdAt.desc().nullsFirst().op('timestamptz_ops'),
+	),
+]);
+
+export const rateLimitsInCore = core.table('rate_limits', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	apiKeyId: uuid('api_key_id').notNull(),
+	windowStart: timestamp('window_start', { withTimezone: true, mode: 'string' }).notNull(),
+	requests: integer().generatedByDefaultAsIdentity().notNull(),
+	limit: integer().generatedAlwaysAs(() => sql`1`).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.apiKeyId],
+		foreignColumns: [apiKeysInCore.id],
+		name: 'rate_limits_api_key_id_fkey',
+	}).onDelete('cascade'),
+	unique('rate_limits_api_key_id_window_start_key').on(table.apiKeyId, table.windowStart).nullsNotDistinct(),
+]);
+
+export const experimentsInCore = core.table('experiments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	key: text().notNull(),
+	description: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'experiments_organization_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiments_organization_id_key_key').on(table.organizationId, table.key),
+]);
+
+export const experimentVariantsInCore = core.table('experiment_variants', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	name: text().notNull(),
+	allocationPercent: smallint('allocation_percent').default(0).notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_variants_experiment_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_variants_experiment_id_name_key').on(table.experimentId, table.name),
+	check('experiment_variants_allocation_percent_check', sql`(allocation_percent >= 0) AND (allocation_percent <= 100)`),
+]);
+
+export const experimentAssignmentsInCore = core.table('experiment_assignments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	experimentId: uuid('experiment_id').notNull(),
+	variantId: uuid('variant_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.experimentId],
+		foreignColumns: [experimentsInCore.id],
+		name: 'experiment_assignments_experiment_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.variantId],
+		foreignColumns: [experimentVariantsInCore.id],
+		name: 'experiment_assignments_variant_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'experiment_assignments_user_id_fkey',
+	}).onDelete('cascade'),
+	unique('experiment_assignments_experiment_id_user_id_key').on(table.experimentId, table.userId),
+]);
+
+export const deploymentsInCore = core.table('deployments', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	projectId: uuid('project_id').notNull(),
+	environment: env().default('dev').notNull(),
+	version: text().notNull(),
+	deployedBy: uuid('deployed_by'),
+	deployedAt: timestamp('deployed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	notes: text(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInCore.id],
+		name: 'deployments_project_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.deployedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'deployments_deployed_by_fkey',
+	}),
+	unique('deployments_project_id_environment_version_key').on(table.projectId, table.environment, table.version),
+]);
+
+export const servicesInCore = core.table('services', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	name: text().notNull(),
+	kind: text(),
+	ownerId: uuid('owner_id'),
+	metadata: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string', precision: 6 }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'services_organization_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.ownerId],
+		foreignColumns: [usersInCore.id],
+		name: 'services_owner_id_fkey',
+	}),
+	unique('services_organization_id_name_key').on(table.organizationId, table.name),
+]);
+
+export const locksInCore = core.table('locks', {
+	name: text().primaryKey().notNull(),
+	owner: text(),
+	expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'string', precision: 2 }),
+});
+
+export const entitiesInCore = core.table('entities', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	organizationId: uuid('organization_id').notNull(),
+	type: text().notNull(),
+	data: jsonb(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'entities_organization_id_fkey',
+	}).onDelete('cascade'),
+]);
+
+export const taskQueueInAnalytics = analytics.table('task_queue', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	queueName: text('queue_name').default('default').notNull(),
+	payload: jsonb().notNull(),
+	priority: smallint().default(100).notNull(),
+	reserved: boolean().default(false).notNull(),
+	reservedUntil: timestamp('reserved_until', { withTimezone: true, mode: 'string' }),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	uniqueIndex('analytics_task_queue_unique_unreserved').using(
+		'btree',
+		sql`queue_name`,
+		sql`((payload ->> 'task_type'::text))`,
+	).where(sql`(reserved = false)`),
+]);
+
+export const invoicesInBilling = billing.table('invoices', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	customerId: uuid('customer_id').notNull(),
+	number: text().notNull(),
+	issuedAt: timestamp('issued_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+	dueAt: timestamp('due_at', { withTimezone: true, mode: 'string' }),
+	totalAmount: numeric('total_amount', { precision: 12, scale: 2 }).default('0.0').notNull(),
+	currency: currencyCode().default('USD').notNull(),
+	status: invoiceStatus().default('draft').notNull(),
+	notes: text(),
+}, (table) => [
+	index('billing_invoices_status_idx').using('btree', table.status.asc().nullsLast().op('enum_ops')),
+	foreignKey({
+		columns: [table.customerId, table.number],
+		foreignColumns: [customersInBilling.id, customersInBilling.name],
+		name: 'invoices_customer_id_fkey',
+	}).onDelete('cascade'),
+	unique('invoices_customer_id_number_key').on(table.customerId, table.number),
+	check('invoices_total_nonnegative', sql`total_amount >= (0)::numeric`),
+]);
+
+export const aliasesInCore = core.table('aliases', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	alias: text().notNull().unique('unique_with_name'),
+	organizationId: uuid('organization_id'),
+}, (table) => [
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organizationsInCore.id],
+		name: 'aliases_organization_id_fkey',
+	}).onUpdate('cascade'),
+	unique('aliases_object_type_object_id_alias_key').on(table.objectType, table.objectId, table.alias),
+]);
+
+export const selfRef = core.table('self_ref', {
+	id: uuid().defaultRandom().primaryKey().notNull(),
+	objectType: text('object_type').notNull().unique().references((): AnyPgColumn => selfRef.organizationId),
+	organizationId: text('organization_id').notNull().unique(),
+});
+
+export const couponRedemptionsInBilling = billing.table('coupon_redemptions', {
+	couponId: uuid('coupon_id').notNull(),
+	customerId: uuid('customer_id').notNull(),
+	redeemedAt: timestamp('redeemed_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.couponId],
+		foreignColumns: [couponsInBilling.id],
+		name: 'coupon_redemptions_coupon_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.customerId],
+		foreignColumns: [customersInBilling.id],
+		name: 'coupon_redemptions_customer_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.couponId, table.customerId], name: 'coupon_redemptions_pkey' }),
+]);
+
+export const entityLinksInCore = core.table('entity_links', {
+	parentEntityId: uuid('parent_entity_id').notNull(),
+	childEntityId: uuid('child_entity_id').notNull(),
+	relationship: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.parentEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_parent_entity_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.childEntityId],
+		foreignColumns: [entitiesInCore.id],
+		name: 'entity_links_child_entity_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.parentEntityId, table.childEntityId, table.relationship], name: 'entity_links_pkey' }),
+]);
+
+export const rolePermissionsInCore = core.table('role_permissions', {
+	roleId: integer('role_id').notNull(),
+	permissionId: integer('permission_id').notNull(),
+	assignedBy: uuid('assigned_by'),
+	assignedAt: timestamp('assigned_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.roleId],
+		foreignColumns: [rolesInCore.id],
+		name: 'role_permissions_role_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.permissionId],
+		foreignColumns: [permissionsInCore.id],
+		name: 'role_permissions_permission_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.assignedBy],
+		foreignColumns: [usersInCore.id],
+		name: 'role_permissions_assigned_by_fkey',
+	}),
+	primaryKey({ columns: [table.roleId, table.permissionId], name: 'role_permissions_pkey' }),
+]);
+
+export const taggingsInCore = core.table('taggings', {
+	tagId: integer('tag_id').notNull(),
+	objectType: text('object_type').notNull(),
+	objectId: uuid('object_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.tagId],
+		foreignColumns: [tagsInCore.id],
+		name: 'taggings_tag_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.tagId, table.objectType, table.objectId], name: 'taggings_pkey' }),
+]);
+
+export const reactionsInCore = core.table('reactions', {
+	messageId: uuid('message_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	reaction: text().notNull().array(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.messageId],
+		foreignColumns: [chatMessagesInCore.id],
+		name: 'reactions_message_id_fkey',
+	}).onDelete('cascade'),
+	foreignKey({
+		columns: [table.userId],
+		foreignColumns: [usersInCore.id],
+		name: 'reactions_user_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.messageId, table.userId, table.reaction], name: 'reactions_pkey' }),
+]);
+
+// views
+export const projectSearchInAnalytics = analytics.materializedView('project_search', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().as(
+		sql`SELECT id, name, slug, description FROM core.projects p`,
+	);
+
+export const projectSearchInAnalytics2 = analytics.materializedView('project_search2', {
+	id: uuid(),
+	name: text(),
+	slug: text(),
+	description: text(),
+}).with({ autovacuumEnabled: true, autovacuumMultixactFreezeTableAge: 12 })
+	.withNoData().existing();
+
+export const vActiveUsersInCore = core.view('v_active_users').as((qb) =>
+	qb.select({
+		id: usersInCore.id,
+		username: usersInCore.username,
+		organization_id: usersInCore.organizationId,
+	}).from(usersInCore).where(eq(usersInCore.status, 'active'))
+);
+export const vActiveUsersInCore2 = core.view('v_active_users2', {}).existing();
+
+// polices
+export const rls = pgSchema('rls');
+export const documentsInRls = rls.table('documents', {
+	docId: uuid('doc_id').defaultRandom().primaryKey().notNull(),
+	ownerId: uuid('owner_id').notNull(),
+	title: text().notNull(),
+	content: text().notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('documents_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(owner_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('documents_update_own', { as: 'permissive', for: 'update', to: ['public'] }),
+	pgPolicy('documents_select_own', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const messagesInRls = rls.table.withRLS('messages', {
+	msgId: uuid('msg_id').defaultRandom().primaryKey().notNull(),
+	senderId: uuid('sender_id').notNull(),
+	recipientId: uuid('recipient_id').notNull(),
+	message: text().notNull(),
+	sentAt: timestamp('sent_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('messages_delete_own', {
+		as: 'permissive',
+		for: 'delete',
+		to: ['public'],
+		using: sql`(sender_id = (CURRENT_USER)::uuid)`,
+	}),
+	pgPolicy('messages_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+]);
+
+export const projectsInRls = rls.table('projects', {
+	projectId: uuid('project_id').defaultRandom().primaryKey().notNull(),
+	name: text().notNull(),
+	description: text(),
+	ownerId: uuid('owner_id').notNull(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+}, (table) => [
+	pgPolicy('projects_visibility', {
+		as: 'permissive',
+		for: 'select',
+		to: ['public'],
+		using: sql`((owner_id = (CURRENT_USER)::uuid) OR (project_id IN ( SELECT pm.project_id
+   FROM rls.project_members pm
+  WHERE (pm.user_id = (CURRENT_USER)::uuid))))`,
+	}),
+]);
+
+export const projectMembersInRls = rls.table.withRLS('project_members', {
+	projectId: uuid('project_id').notNull(),
+	userId: uuid('user_id').notNull(),
+	role: text().notNull(),
+}, (table) => [
+	foreignKey({
+		columns: [table.projectId],
+		foreignColumns: [projectsInRls.projectId],
+		name: 'project_members_project_id_fkey',
+	}).onDelete('cascade'),
+	primaryKey({ columns: [table.projectId, table.userId], name: 'project_members_pkey' }),
+	pgPolicy('project_members_manage', {
+		as: 'permissive',
+		for: 'all',
+		to: ['public'],
+		using: sql`(project_id IN ( SELECT p.project_id
+   FROM rls.projects p
+  WHERE (p.owner_id = (CURRENT_USER)::uuid)))`,
+	}),
+	pgPolicy('project_members_visibility', { as: 'permissive', for: 'select', to: ['public'] }),
+	check('project_members_role_check', sql`role = ANY (ARRAY['member'::text, 'admin'::text])`),
+]);
+
+export const policy = pgPolicy('new_policy', {
+	as: 'restrictive',
+	to: 'postgres',
+	withCheck: sql`1 = 1`,
+	for: 'all',
+}).link(organizationsInCore);
diff --git a/drizzle-kit/tests/postgres/snapshots/schema04.ts b/drizzle-kit/tests/postgres/snapshots/schema04.ts
new file mode 100644
index 0000000000..53f544bd9d
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema04.ts
@@ -0,0 +1,596 @@
+// src/db/schema.ts
+import { sql } from 'orm044';
+import {
+	bigint,
+	bigserial,
+	bit,
+	boolean,
+	char,
+	cidr,
+	customType,
+	date,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	geometry,
+	halfvec,
+	index,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	pgView,
+	point,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	sparsevec,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+	vector,
+} from 'orm044/pg-core';
+
+export const citext = customType<{ data: string }>({
+	dataType() {
+		return 'citext';
+	},
+});
+
+export const customSchema = pgSchema('schemass');
+export const transactionStatusEnum = customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']);
+export const enumname = pgEnum('enumname', ['three', 'two', 'one']);
+export const test = pgEnum('test', ['ds']);
+export const testHello = pgEnum('test_hello', ['ds']);
+
+export const invoiceSeqCustom = customSchema.sequence('invoice_seq', {
+	increment: 1,
+	startWith: 1000,
+	minValue: 1000,
+	cache: 1,
+	cycle: false,
+});
+export const invoiceSeq = pgSequence('invoice_seq', {
+	increment: 1,
+	startWith: 1000,
+	minValue: 1000,
+	cache: 1,
+	cycle: false,
+});
+
+export const schemaTest = pgTable('schema_test', {
+	columnAll: uuid('column_all').defaultRandom(),
+	column: transactionStatusEnum('column').notNull(),
+});
+
+export const allSmallIntsCustom = customSchema.table(
+	'schema_test2_custom',
+	{
+		column: smallint('column').notNull().array().generatedAlwaysAs([1]),
+		column1: smallint('column1').default(1),
+		column2: smallint('column2').notNull().array().array(),
+		column3: smallint('column3').notNull().array().array(),
+		column4: smallint('column4').notNull().array().default([1]),
+	},
+	(
+		t,
+	) => [
+		uniqueIndex().on(t.column1),
+		uniqueIndex().on(t.column2),
+		uniqueIndex('testdfds').on(t.column3),
+		uniqueIndex('testdfds1').on(t.column4),
+	],
+);
+
+export const allEnumsCustom = customSchema.table(
+	'all_enums_custom',
+	{
+		columnAll: enumname('column_all').default('three').notNull(),
+		column: enumname('columns').array().generatedAlwaysAs(['three']),
+	},
+	(t: any) => [index('ds').on(t.column)],
+);
+
+export const allTimestampsCustom = customSchema.table('all_timestamps_custom', {
+	columnDateNow: timestamp('column_date_now', {
+		precision: 1,
+		withTimezone: true,
+		mode: 'string',
+	}).defaultNow(),
+	columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
+	column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
+});
+
+export const allUuidsCustom = customSchema.table('all_uuids_custom', {
+	columnAll: uuid('column_all').defaultRandom().notNull(),
+	column: uuid('column'),
+});
+
+export const allDatesCustom = customSchema.table('all_dates_custom', {
+	column_date_now: date('column_date_now').defaultNow(),
+	column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
+	column: date('column'),
+});
+
+export const allRealsCustom = customSchema.table('all_reals_custom', {
+	columnAll: real('column_all').default(32).notNull(),
+	column: real('column'),
+	columnPrimary: real('column_primary').primaryKey().notNull(),
+});
+
+export const allBigintsCustom = pgTable('all_bigints_custom', {
+	columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
+	column: bigint('column', { mode: 'number' }),
+});
+
+export const allBigserialsCustom = customSchema.table('all_bigserials_custom', {
+	columnAll: bigserial('column_all', { mode: 'bigint' }).notNull(),
+	column: bigserial('column', { mode: 'bigint' }).notNull(),
+});
+
+export const allIntervalsCustom = customSchema.table('all_intervals_custom', {
+	columnAllConstrains: interval('column_all_constrains', {
+		fields: 'month',
+	})
+		.default('1 mon')
+		.notNull(),
+	columnMinToSec: interval('column_min_to_sec', {
+		fields: 'minute to second',
+	}),
+	columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
+	column: interval('column'),
+	column5: interval('column5', {
+		fields: 'minute to second',
+		precision: 3,
+	}),
+	column6: interval('column6'),
+});
+
+export const allSerialsCustom = customSchema.table('all_serials_custom', {
+	columnAll: serial('column_all').notNull(),
+	column: serial('column').notNull(),
+});
+
+export const allSmallserialsCustom = pgTable('all_smallserials_custom', {
+	columnAll: smallserial('column_all').notNull(),
+	column: smallserial('column').notNull(),
+});
+
+export const allTextsCustom = customSchema.table(
+	'all_texts_custom',
+	{
+		columnAll: text('column_all').default('text').notNull(),
+		column: text('columns').primaryKey(),
+	},
+	(t: any) => [index('test').on(t.column)],
+);
+
+export const allBoolsCustom = customSchema.table('all_bools_custom', {
+	columnAll: boolean('column_all').default(true).notNull(),
+	column: boolean('column'),
+});
+
+export const allVarcharsCustom = customSchema.table('all_varchars_custom', {
+	columnAll: varchar('column_all').default('text').notNull(),
+	column: varchar('column', { length: 200 }),
+});
+
+export const allTimesCustom = customSchema.table('all_times_custom', {
+	columnDateNow: time('column_date_now').defaultNow(),
+	columnAll: time('column_all').default('22:12:12').notNull(),
+	column: time('column'),
+});
+
+export const allCharsCustom = customSchema.table('all_chars_custom', {
+	columnAll: char('column_all', { length: 1 }).default('text').notNull(),
+	column: char('column', { length: 1 }),
+});
+
+export const allDoublePrecisionCustom = customSchema.table('all_double_precision_custom', {
+	columnAll: doublePrecision('column_all').default(33.2).notNull(),
+	column: doublePrecision('column'),
+});
+
+export const allJsonbCustom = customSchema.table('all_jsonb_custom', {
+	columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: jsonb('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+	}),
+	column: jsonb('column'),
+});
+
+export const allJsonCustom = customSchema.table('all_json_custom', {
+	columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: json('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+		foo: 'bar',
+		fe: 23,
+	}),
+	column: json('column'),
+});
+
+export const allIntegersCustom = customSchema.table('all_integers_custom', {
+	columnAll: integer('column_all').primaryKey(),
+	column: integer('column'),
+	columnPrimary: integer('column_primary'),
+});
+
+export const allNumericsCustom = customSchema.table('all_numerics_custom', {
+	columnAll: numeric('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: numeric('column'),
+	columnPrimary: numeric('column_primary').primaryKey().notNull(),
+});
+
+export const allCidrCustom = customSchema.table('all_cidr_custom', {
+	columnAll: cidr('column_all').notNull().array().generatedAlwaysAs(['0.0.0.0/0']),
+	column: cidr('column').default('0.0.0.0/0'),
+	columnPrimary: cidr('column_primary').primaryKey().notNull(),
+});
+
+export const allCustomCustom = customSchema.table('all_custom_custom', {
+	columnAll: citext('column_all').notNull().array().generatedAlwaysAs(['0.0.0.0/0']),
+	column: citext('column').default('test{}\'://`"'),
+	columnPrimary: citext('column_primary').primaryKey().notNull(),
+});
+
+export const allInetCustom = customSchema.table('all_inet_custom', {
+	columnAll: inet('column_all').notNull().array().generatedAlwaysAs(['127.0.0.1']),
+	column: inet('column').default('127.0.0.1'),
+	columnPrimary: inet('column_primary').primaryKey().notNull(),
+});
+
+export const allLineCustom = customSchema.table('all_line_custom', {
+	columnAll: line('column_all').notNull().array().generatedAlwaysAs([[1, 1, 1]]),
+	column: line('column').default([1, 1, 1]),
+	columnPrimary: line('column_primary').primaryKey().notNull(),
+});
+
+export const allMacaddrCustom = customSchema.table('all_macaddr_custom', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(['08:00:2b:01:02:03']),
+	column: macaddr('column').default('08:00:2b:01:02:03'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+});
+
+export const allMacaddr8Custom = customSchema.table('all_macaddr8_custom', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(['08:00:2b:01:02:03:04:05']),
+	column: macaddr('column').default('08:00:2b:01:02:03:04:05'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+});
+
+export const allPointCustom = customSchema.table('all_point_custom', {
+	columnAll: point('column_all', { mode: 'xy' }).notNull().array().generatedAlwaysAs([{ x: 1, y: 2 }]),
+	columnAll1: point('column_all1', { mode: 'tuple' }).notNull().array().generatedAlwaysAs([[1, 2]]),
+	column: point('column', { mode: 'xy' }).default({ x: 1, y: 2 }),
+	column1: point('column1', { mode: 'tuple' }).default([1, 2]),
+	columnPrimary: point('column_primary').primaryKey().notNull(),
+});
+
+export const allDecimalsCustom = customSchema.table('all_decimals_custom', {
+	columnAll: decimal('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: decimal('column'),
+	columnPrimary: decimal('column_primary').primaryKey().notNull(),
+});
+
+export const allGeometryCustom = pgTable('all_geometry_custom', {
+	columnAll: geometry('column_all', { mode: 'xy', srid: 4326, type: 'point' }).default({ x: 30.5234, y: 50.4501 })
+		.notNull(),
+	columnAll1: geometry('column_all1', { mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }).notNull(),
+	columnAll2: geometry('column_all2', { mode: 'tuple', srid: 4326, type: 'point' }).default([30.5234, 50.4501])
+		.notNull(),
+	columnAll3: geometry('column_all3', { mode: 'tuple', type: 'point' }).default([30.5234, 50.4501]).notNull(),
+	column: geometry('column').array(),
+	columnPrimary: geometry('column_primary').primaryKey().notNull(),
+});
+
+export const allBitCustom = pgTable('all_bit_custom', {
+	columnAll: bit('column_all', { dimensions: 1 }).default('1').notNull(),
+	columnAll1: bit('column_all1', { dimensions: 2 }).default('11').notNull(),
+	column: bit('column', { dimensions: 3 }).array(),
+	columnPrimary: bit('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allHalfvecCustom = pgTable('all_halfvec_custom', {
+	columnAll: halfvec('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: halfvec('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	column: halfvec('column', { dimensions: 3 }).array(),
+	columnPrimary: halfvec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allVecCustom = pgTable('all_vec_custom', {
+	columnAll: vector('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: vector('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	columnAll2: vector('column_all2', { dimensions: 2 }).array().default([[0, -2, 3]]).notNull(),
+	columnPrimary: vector('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSparcevecCustom = pgTable('all_sparcevec_custom', {
+	columnAll: sparsevec('column_all', { dimensions: 1 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll1: sparsevec('column_all1', { dimensions: 2 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll3: sparsevec('column_all3', { dimensions: 2 }).array().default(['{1:-1,3:2,5:3}/5']).notNull(),
+	columnPrimary: sparsevec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSmallInts = pgTable(
+	'schema_test2',
+	{
+		columnAll: smallint('column_all').default(124).notNull(),
+		column: smallint('columns').array(),
+		column1: smallint('column1').array().array(),
+		column2: smallint('column2').array().array(),
+		column3: smallint('column3').array(),
+		column4: smallint('column4').array().notNull(),
+	},
+	(t: any) => [uniqueIndex('testdfds').on(t.column)],
+);
+
+export const allEnums = pgTable(
+	'all_enums',
+	{
+		columnAll: enumname('column_all').default('three').notNull(),
+		column: enumname('columns'),
+		column3: enumname('column3').array().notNull(),
+	},
+	(t: any) => [index('ds').on(t.column)],
+);
+
+export const allTimestamps = pgTable('all_timestamps', {
+	columnDateNow: timestamp('column_date_now', {
+		precision: 1,
+		withTimezone: true,
+		mode: 'string',
+	}).defaultNow(),
+	columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
+	column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
+	column3: timestamp('column3').array().notNull(),
+});
+
+export const allUuids = pgTable('all_uuids', {
+	columnAll: uuid('column_all').defaultRandom().notNull(),
+	column: uuid('column'),
+	column3: uuid('column3').array().notNull(),
+});
+
+export const allDates = pgTable('all_dates', {
+	column_date_now: date('column_date_now').defaultNow(),
+	column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
+	column: date('column'),
+	column3: date('column3').array().notNull(),
+});
+
+export const allReals = pgTable('all_reals', {
+	columnAll: real('column_all').default(32).notNull(),
+	column: real('column'),
+	columnPrimary: real('column_primary').primaryKey().notNull(),
+	column3: real('column3').array().notNull(),
+});
+
+export const allBigints = pgTable('all_bigints', {
+	columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
+	column: bigint('column', { mode: 'number' }),
+	column3: bigint('column3', { mode: 'number' }).array().notNull(),
+});
+
+export const allBigserials = pgTable('all_bigserials', {
+	columnAll: bigserial('column_all', { mode: 'bigint' }).notNull(),
+	column: bigserial('column', { mode: 'bigint' }).notNull(),
+	column3: bigserial('column3', { mode: 'number' }).array().notNull(),
+});
+
+export const allIntervals = pgTable('all_intervals', {
+	columnAllConstrains: interval('column_all_constrains', {
+		fields: 'month',
+	})
+		.default('1 mon')
+		.notNull(),
+	columnMinToSec: interval('column_min_to_sec', {
+		fields: 'minute to second',
+	}),
+	columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
+	column: interval('column'),
+	column5: interval('column5', {
+		fields: 'minute to second',
+		precision: 3,
+	}),
+	column6: interval('column6'),
+	column3: interval('column3').array().notNull(),
+});
+
+export const allSerials = pgTable('all_serials', {
+	columnAll: serial('column_all').notNull(),
+	column: serial('column').notNull(),
+	column3: serial('column3').array().notNull(),
+});
+
+export const allSmallserials = pgTable('all_smallserials', {
+	columnAll: smallserial('column_all').notNull(),
+	column: smallserial('column').notNull(),
+	column3: smallserial('column3').array().notNull(),
+});
+
+export const allTexts = pgTable(
+	'all_texts',
+	{
+		columnAll: text('column_all').default('text').notNull(),
+		column: text('columns').primaryKey(),
+		column3: text('column3').array().notNull(),
+	},
+	(t: any) => [index('test').on(t.column)],
+);
+
+export const allBools = pgTable('all_bools', {
+	columnAll: boolean('column_all').default(true).notNull(),
+	column: boolean('column'),
+	column3: boolean('column3').array().notNull(),
+});
+
+export const allVarchars = pgTable('all_varchars', {
+	columnAll: varchar('column_all').default('text').notNull(),
+	column: varchar('column', { length: 200 }),
+	column3: varchar('column3').array().notNull(),
+});
+
+export const allTimes = pgTable('all_times', {
+	columnDateNow: time('column_date_now').defaultNow(),
+	columnAll: time('column_all').default('22:12:12').notNull(),
+	column: time('column'),
+	column3: time('column3').array().notNull(),
+});
+
+export const allChars = pgTable('all_chars', {
+	columnAll: char('column_all', { length: 1 }).default('text').notNull(),
+	column: char('column', { length: 1 }),
+	column3: char('column3').array().notNull(),
+});
+
+export const allDoublePrecision = pgTable('all_double_precision', {
+	columnAll: doublePrecision('column_all').default(33.2).notNull(),
+	column: doublePrecision('column'),
+	column3: doublePrecision('column3').array().notNull(),
+});
+
+export const allJsonb = pgTable('all_jsonb', {
+	columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: jsonb('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+	}),
+	column: jsonb('column'),
+	column3: jsonb('column3').array().notNull(),
+});
+
+export const allJson = pgTable('all_json', {
+	columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: json('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+		foo: 'bar',
+		fe: 23,
+	}),
+	column: json('column'),
+	column3: json('column3').array().notNull(),
+});
+
+export const allIntegers = pgTable('all_integers', {
+	columnAll: integer('column_all').primaryKey(),
+	column: integer('column').default(1),
+	columnPrimary: integer('column_primary'),
+	column3: integer('column3').array().notNull(),
+});
+
+export const allNumerics = pgTable('all_numerics', {
+	columnAll: numeric('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: numeric('column'),
+	columnPrimary: numeric('column_primary').primaryKey().notNull(),
+	column3: numeric('column3').array().notNull(),
+});
+
+export const allCidr = pgTable('all_cidr', {
+	columnAll: cidr('column_all').notNull().array().generatedAlwaysAs(['0.0.0.0/0']),
+	column: cidr('column').default('0.0.0.0/0'),
+	columnPrimary: cidr('column_primary').primaryKey().notNull(),
+	column3: cidr('column3').array().notNull(),
+});
+
+export const allCustom = pgTable('all_custom', {
+	columnAll: citext('column_all').notNull().array().generatedAlwaysAs(['0.0.0.0/0']),
+	column: citext('column').default('test{}\'://`"'),
+	columnPrimary: citext('column_primary').primaryKey().notNull(),
+	column3: citext('column3').array().notNull(),
+});
+
+export const allInet = pgTable('all_inet', {
+	columnAll: inet('column_all').notNull().array().generatedAlwaysAs(['127.0.0.1']),
+	column: inet('column').default('127.0.0.1'),
+	columnPrimary: inet('column_primary').primaryKey().notNull(),
+	column3: inet('column3').array().notNull(),
+});
+
+export const allLine = pgTable('all_line', {
+	columnAll: line('column_all').notNull().array().generatedAlwaysAs([[1, 1, 1]]),
+	column: line('column').default([1, 1, 1]),
+	columnPrimary: line('column_primary').primaryKey().notNull(),
+	column3: line('column3').array().notNull(),
+});
+
+export const allMacaddr = pgTable('all_macaddr', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(['08:00:2b:01:02:03']),
+	column: macaddr('column').default('08:00:2b:01:02:03'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+	column3: macaddr('column3').notNull().array(),
+});
+
+export const allMacaddr8 = pgTable('all_macaddr8', {
+	columnAll: macaddr8('column_all').notNull().array().generatedAlwaysAs(['08:00:2b:01:02:03:04:05']),
+	column: macaddr8('column').default('08:00:2b:01:02:03:04:05'),
+	columnPrimary: macaddr8('column_primary').primaryKey().notNull(),
+	column3: macaddr8('column3').notNull().array(),
+});
+
+export const allPoint = pgTable('all_point', {
+	columnAll: point('column_all', { mode: 'xy' }).notNull().array().generatedAlwaysAs([{ x: 1, y: 2 }]),
+	columnAll1: point('column_all1', { mode: 'tuple' }).notNull().array().generatedAlwaysAs([[1, 2]]),
+	column: point('column', { mode: 'xy' }).default({ x: 1, y: 2 }),
+	column1: point('column1', { mode: 'tuple' }).default([1, 2]),
+	columnPrimary: point('column_primary').primaryKey().notNull(),
+	column3: point('column3').notNull().array(),
+});
+
+export const allDecimals = pgTable('all_decimals', {
+	columnAll: decimal('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: decimal('column').array(),
+	columnPrimary: decimal('column_primary').primaryKey().notNull(),
+});
+
+export const allGeometry = pgTable('all_geometry', {
+	columnAll: geometry('column_all', { mode: 'xy', srid: 4326, type: 'point' }).default({ x: 30.5234, y: 50.4501 })
+		.notNull(),
+	columnAll1: geometry('column_all1', { mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }).notNull(),
+	columnAll2: geometry('column_all2', { mode: 'tuple', srid: 4326, type: 'point' }).default([30.5234, 50.4501])
+		.notNull(),
+	columnAll3: geometry('column_all3', { mode: 'tuple', type: 'point' }).default([30.5234, 50.4501]).notNull(),
+	column: geometry('column').array(),
+	columnPrimary: geometry('column_primary').primaryKey().notNull(),
+});
+
+export const allBit = pgTable('all_bit', {
+	columnAll: bit('column_all', { dimensions: 1 }).default('1').notNull(),
+	columnAll1: bit('column_all1', { dimensions: 2 }).default('11').notNull(),
+	column: bit('column', { dimensions: 3 }).array(),
+	columnPrimary: bit('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allHalfvec = pgTable('all_halfvec', {
+	columnAll: halfvec('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: halfvec('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	column: halfvec('column', { dimensions: 3 }).array(),
+	columnPrimary: halfvec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allVec = pgTable('all_vec', {
+	columnAll: vector('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: vector('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	columnAll2: vector('column_all2', { dimensions: 2 }).array().default([[0, -2, 3]]).notNull(),
+	columnPrimary: vector('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSparcevec = pgTable('all_sparcevec', {
+	columnAll: sparsevec('column_all', { dimensions: 1 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll1: sparsevec('column_all1', { dimensions: 2 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll3: sparsevec('column_all3', { dimensions: 2 }).array().default(['{1:-1,3:2,5:3}/5']).notNull(),
+	columnPrimary: sparsevec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
diff --git a/drizzle-kit/tests/postgres/snapshots/schema04new.ts b/drizzle-kit/tests/postgres/snapshots/schema04new.ts
new file mode 100644
index 0000000000..389d113775
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/schema04new.ts
@@ -0,0 +1,597 @@
+// src/db/schema.ts
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	bigserial,
+	bit,
+	boolean,
+	char,
+	cidr,
+	customType,
+	date,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	geometry,
+	halfvec,
+	index,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgSequence,
+	pgTable,
+	pgView,
+	point,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	sparsevec,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+	vector,
+} from 'drizzle-orm/pg-core';
+
+export const citext = customType<{ data: string }>({
+	codec: 'text',
+	dataType() {
+		return 'citext';
+	},
+});
+
+export const customSchema = pgSchema('schemass');
+export const transactionStatusEnum = customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']);
+export const enumname = pgEnum('enumname', ['three', 'two', 'one']);
+export const test = pgEnum('test', ['ds']);
+export const testHello = pgEnum('test_hello', ['ds']);
+
+export const invoiceSeqCustom = customSchema.sequence('invoice_seq', {
+	increment: 1,
+	startWith: 1000,
+	minValue: 1000,
+	cache: 1,
+	cycle: false,
+});
+export const invoiceSeq = pgSequence('invoice_seq', {
+	increment: 1,
+	startWith: 1000,
+	minValue: 1000,
+	cache: 1,
+	cycle: false,
+});
+
+export const schemaTest = pgTable('schema_test', {
+	columnAll: uuid('column_all').defaultRandom(),
+	column: transactionStatusEnum('column').notNull(),
+});
+
+export const allSmallIntsCustom = customSchema.table(
+	'schema_test2_custom',
+	{
+		column: smallint('column').notNull().array().generatedAlwaysAs(sql`{1}`),
+		column1: smallint('column1').default(1),
+		column2: smallint('column2').notNull().array('[][]'),
+		column3: smallint('column3').notNull().array('[][]'),
+		column4: smallint('column4').notNull().array().default([1]),
+	},
+	(
+		t,
+	) => [
+		uniqueIndex().on(t.column1),
+		uniqueIndex().on(t.column2),
+		uniqueIndex('testdfds').on(t.column3),
+		uniqueIndex('testdfds1').on(t.column4),
+	],
+);
+
+export const allEnumsCustom = customSchema.table(
+	'all_enums_custom',
+	{
+		columnAll: enumname('column_all').default('three').notNull(),
+		column: enumname('columns').array().generatedAlwaysAs(sql`{'three'}`),
+	},
+	(t: any) => [index('ds').on(t.column)],
+);
+
+export const allTimestampsCustom = customSchema.table('all_timestamps_custom', {
+	columnDateNow: timestamp('column_date_now', {
+		precision: 1,
+		withTimezone: true,
+		mode: 'string',
+	}).defaultNow(),
+	columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
+	column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
+});
+
+export const allUuidsCustom = customSchema.table('all_uuids_custom', {
+	columnAll: uuid('column_all').defaultRandom().notNull(),
+	column: uuid('column'),
+});
+
+export const allDatesCustom = customSchema.table('all_dates_custom', {
+	column_date_now: date('column_date_now').defaultNow(),
+	column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
+	column: date('column'),
+});
+
+export const allRealsCustom = customSchema.table('all_reals_custom', {
+	columnAll: real('column_all').default(32).notNull(),
+	column: real('column'),
+	columnPrimary: real('column_primary').primaryKey().notNull(),
+});
+
+export const allBigintsCustom = pgTable('all_bigints_custom', {
+	columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
+	column: bigint('column', { mode: 'number' }),
+});
+
+export const allBigserialsCustom = customSchema.table('all_bigserials_custom', {
+	columnAll: bigserial('column_all', { mode: 'bigint' }).notNull(),
+	column: bigserial('column', { mode: 'bigint' }).notNull(),
+});
+
+export const allIntervalsCustom = customSchema.table('all_intervals_custom', {
+	columnAllConstrains: interval('column_all_constrains', {
+		fields: 'month',
+	})
+		.default('1 mon')
+		.notNull(),
+	columnMinToSec: interval('column_min_to_sec', {
+		fields: 'minute to second',
+	}),
+	columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
+	column: interval('column'),
+	column5: interval('column5', {
+		fields: 'minute to second',
+		precision: 3,
+	}),
+	column6: interval('column6'),
+});
+
+export const allSerialsCustom = customSchema.table('all_serials_custom', {
+	columnAll: serial('column_all').notNull(),
+	column: serial('column').notNull(),
+});
+
+export const allSmallserialsCustom = pgTable('all_smallserials_custom', {
+	columnAll: smallserial('column_all').notNull(),
+	column: smallserial('column').notNull(),
+});
+
+export const allTextsCustom = customSchema.table(
+	'all_texts_custom',
+	{
+		columnAll: text('column_all').default('text').notNull(),
+		column: text('columns').primaryKey(),
+	},
+	(t: any) => [index('test').on(t.column)],
+);
+
+export const allBoolsCustom = customSchema.table('all_bools_custom', {
+	columnAll: boolean('column_all').default(true).notNull(),
+	column: boolean('column'),
+});
+
+export const allVarcharsCustom = customSchema.table('all_varchars_custom', {
+	columnAll: varchar('column_all').default('text').notNull(),
+	column: varchar('column', { length: 200 }),
+});
+
+export const allTimesCustom = customSchema.table('all_times_custom', {
+	columnDateNow: time('column_date_now').defaultNow(),
+	columnAll: time('column_all').default('22:12:12').notNull(),
+	column: time('column'),
+});
+
+export const allCharsCustom = customSchema.table('all_chars_custom', {
+	columnAll: char('column_all', { length: 1 }).default('text').notNull(),
+	column: char('column', { length: 1 }),
+});
+
+export const allDoublePrecisionCustom = customSchema.table('all_double_precision_custom', {
+	columnAll: doublePrecision('column_all').default(33.2).notNull(),
+	column: doublePrecision('column'),
+});
+
+export const allJsonbCustom = customSchema.table('all_jsonb_custom', {
+	columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: jsonb('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+	}),
+	column: jsonb('column'),
+});
+
+export const allJsonCustom = customSchema.table('all_json_custom', {
+	columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: json('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+		foo: 'bar',
+		fe: 23,
+	}),
+	column: json('column'),
+});
+
+export const allIntegersCustom = customSchema.table('all_integers_custom', {
+	columnAll: integer('column_all').primaryKey(),
+	column: integer('column'),
+	columnPrimary: integer('column_primary'),
+});
+
+export const allNumericsCustom = customSchema.table('all_numerics_custom', {
+	columnAll: numeric('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: numeric('column'),
+	columnPrimary: numeric('column_primary').primaryKey().notNull(),
+});
+
+export const allCidrCustom = customSchema.table('all_cidr_custom', {
+	columnAll: cidr('column_all').notNull().array().generatedAlwaysAs(sql`{'0.0.0.0/0'}`),
+	column: cidr('column').default('0.0.0.0/0'),
+	columnPrimary: cidr('column_primary').primaryKey().notNull(),
+});
+
+export const allCustomCustom = customSchema.table('all_custom_custom', {
+	columnAll: citext('column_all').notNull().array().generatedAlwaysAs(sql`{'0.0.0.0/0'}`),
+	column: citext('column').default('test{}\'://`"'),
+	columnPrimary: citext('column_primary').primaryKey().notNull(),
+});
+
+export const allInetCustom = customSchema.table('all_inet_custom', {
+	columnAll: inet('column_all').notNull().array().generatedAlwaysAs(sql`{'127.0.0.1'}`),
+	column: inet('column').default('127.0.0.1'),
+	columnPrimary: inet('column_primary').primaryKey().notNull(),
+});
+
+export const allLineCustom = customSchema.table('all_line_custom', {
+	columnAll: line('column_all').notNull().array().generatedAlwaysAs(sql`{{1, 1, 1}}`),
+	column: line('column').default([1, 1, 1]),
+	columnPrimary: line('column_primary').primaryKey().notNull(),
+});
+
+export const allMacaddrCustom = customSchema.table('all_macaddr_custom', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(sql`{'08:00:2b:01:02:03'}`),
+	column: macaddr('column').default('08:00:2b:01:02:03'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+});
+
+export const allMacaddr8Custom = customSchema.table('all_macaddr8_custom', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(sql`{'08:00:2b:01:02:03:04:05'}`),
+	column: macaddr('column').default('08:00:2b:01:02:03:04:05'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+});
+
+export const allPointCustom = customSchema.table('all_point_custom', {
+	columnAll: point('column_all', { mode: 'xy' }).notNull().array().generatedAlwaysAs(sql`{{1, 2}}`),
+	columnAll1: point('column_all1', { mode: 'tuple' }).notNull().array().generatedAlwaysAs(sql`{{1, 2}}`),
+	column: point('column', { mode: 'xy' }).default({ x: 1, y: 2 }),
+	column1: point('column1', { mode: 'tuple' }).default([1, 2]),
+	columnPrimary: point('column_primary').primaryKey().notNull(),
+});
+
+export const allDecimalsCustom = customSchema.table('all_decimals_custom', {
+	columnAll: decimal('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: decimal('column'),
+	columnPrimary: decimal('column_primary').primaryKey().notNull(),
+});
+
+export const allGeometryCustom = pgTable('all_geometry_custom', {
+	columnAll: geometry('column_all', { mode: 'xy', srid: 4326, type: 'point' }).default({ x: 30.5234, y: 50.4501 })
+		.notNull(),
+	columnAll1: geometry('column_all1', { mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }).notNull(),
+	columnAll2: geometry('column_all2', { mode: 'tuple', srid: 4326, type: 'point' }).default([30.5234, 50.4501])
+		.notNull(),
+	columnAll3: geometry('column_all3', { mode: 'tuple', type: 'point' }).default([30.5234, 50.4501]).notNull(),
+	column: geometry('column').array(),
+	columnPrimary: geometry('column_primary').primaryKey().notNull(),
+});
+
+export const allBitCustom = pgTable('all_bit_custom', {
+	columnAll: bit('column_all', { dimensions: 1 }).default('1').notNull(),
+	columnAll1: bit('column_all1', { dimensions: 2 }).default('11').notNull(),
+	column: bit('column', { dimensions: 3 }).array(),
+	columnPrimary: bit('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allHalfvecCustom = pgTable('all_halfvec_custom', {
+	columnAll: halfvec('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: halfvec('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	column: halfvec('column', { dimensions: 3 }).array(),
+	columnPrimary: halfvec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allVecCustom = pgTable('all_vec_custom', {
+	columnAll: vector('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: vector('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	columnAll2: vector('column_all2', { dimensions: 2 }).array().default([[0, -2, 3]]).notNull(),
+	columnPrimary: vector('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSparcevecCustom = pgTable('all_sparcevec_custom', {
+	columnAll: sparsevec('column_all', { dimensions: 1 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll1: sparsevec('column_all1', { dimensions: 2 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll3: sparsevec('column_all3', { dimensions: 2 }).array().default(['{1:-1,3:2,5:3}/5']).notNull(),
+	columnPrimary: sparsevec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSmallInts = pgTable(
+	'schema_test2',
+	{
+		columnAll: smallint('column_all').default(124).notNull(),
+		column: smallint('columns').array(),
+		column1: smallint('column1').array('[][]'),
+		column2: smallint('column2').array('[][]'),
+		column3: smallint('column3').array(),
+		column4: smallint('column4').array().notNull(),
+	},
+	(t: any) => [uniqueIndex('testdfds').on(t.column)],
+);
+
+export const allEnums = pgTable(
+	'all_enums',
+	{
+		columnAll: enumname('column_all').default('three').notNull(),
+		column: enumname('columns'),
+		column3: enumname('column3').array().notNull(),
+	},
+	(t: any) => [index('ds').on(t.column)],
+);
+
+export const allTimestamps = pgTable('all_timestamps', {
+	columnDateNow: timestamp('column_date_now', {
+		precision: 1,
+		withTimezone: true,
+		mode: 'string',
+	}).defaultNow(),
+	columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
+	column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
+	column3: timestamp('column3').array().notNull(),
+});
+
+export const allUuids = pgTable('all_uuids', {
+	columnAll: uuid('column_all').defaultRandom().notNull(),
+	column: uuid('column'),
+	column3: uuid('column3').array().notNull(),
+});
+
+export const allDates = pgTable('all_dates', {
+	column_date_now: date('column_date_now').defaultNow(),
+	column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
+	column: date('column'),
+	column3: date('column3').array().notNull(),
+});
+
+export const allReals = pgTable('all_reals', {
+	columnAll: real('column_all').default(32).notNull(),
+	column: real('column'),
+	columnPrimary: real('column_primary').primaryKey().notNull(),
+	column3: real('column3').array().notNull(),
+});
+
+export const allBigints = pgTable('all_bigints', {
+	columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
+	column: bigint('column', { mode: 'number' }),
+	column3: bigint('column3', { mode: 'number' }).array().notNull(),
+});
+
+export const allBigserials = pgTable('all_bigserials', {
+	columnAll: bigserial('column_all', { mode: 'bigint' }).notNull(),
+	column: bigserial('column', { mode: 'bigint' }).notNull(),
+	column3: bigserial('column3', { mode: 'number' }).array().notNull(),
+});
+
+export const allIntervals = pgTable('all_intervals', {
+	columnAllConstrains: interval('column_all_constrains', {
+		fields: 'month',
+	})
+		.default('1 mon')
+		.notNull(),
+	columnMinToSec: interval('column_min_to_sec', {
+		fields: 'minute to second',
+	}),
+	columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
+	column: interval('column'),
+	column5: interval('column5', {
+		fields: 'minute to second',
+		precision: 3,
+	}),
+	column6: interval('column6'),
+	column3: interval('column3').array().notNull(),
+});
+
+export const allSerials = pgTable('all_serials', {
+	columnAll: serial('column_all').notNull(),
+	column: serial('column').notNull(),
+	column3: serial('column3').array().notNull(),
+});
+
+export const allSmallserials = pgTable('all_smallserials', {
+	columnAll: smallserial('column_all').notNull(),
+	column: smallserial('column').notNull(),
+	column3: smallserial('column3').array().notNull(),
+});
+
+export const allTexts = pgTable(
+	'all_texts',
+	{
+		columnAll: text('column_all').default('text').notNull(),
+		column: text('columns').primaryKey(),
+		column3: text('column3').array().notNull(),
+	},
+	(t: any) => [index('test').on(t.column)],
+);
+
+export const allBools = pgTable('all_bools', {
+	columnAll: boolean('column_all').default(true).notNull(),
+	column: boolean('column'),
+	column3: boolean('column3').array().notNull(),
+});
+
+export const allVarchars = pgTable('all_varchars', {
+	columnAll: varchar('column_all').default('text').notNull(),
+	column: varchar('column', { length: 200 }),
+	column3: varchar('column3').array().notNull(),
+});
+
+export const allTimes = pgTable('all_times', {
+	columnDateNow: time('column_date_now').defaultNow(),
+	columnAll: time('column_all').default('22:12:12').notNull(),
+	column: time('column'),
+	column3: time('column3').array().notNull(),
+});
+
+export const allChars = pgTable('all_chars', {
+	columnAll: char('column_all', { length: 1 }).default('text').notNull(),
+	column: char('column', { length: 1 }),
+	column3: char('column3').array().notNull(),
+});
+
+export const allDoublePrecision = pgTable('all_double_precision', {
+	columnAll: doublePrecision('column_all').default(33.2).notNull(),
+	column: doublePrecision('column'),
+	column3: doublePrecision('column3').array().notNull(),
+});
+
+export const allJsonb = pgTable('all_jsonb', {
+	columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: jsonb('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+	}),
+	column: jsonb('column'),
+	column3: jsonb('column3').array().notNull(),
+});
+
+export const allJson = pgTable('all_json', {
+	columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
+	columnDefaultArray: json('column_default_array').default({
+		hello: { 'world world': ['foo', 'bar'] },
+		foo: 'bar',
+		fe: 23,
+	}),
+	column: json('column'),
+	column3: json('column3').array().notNull(),
+});
+
+export const allIntegers = pgTable('all_integers', {
+	columnAll: integer('column_all').primaryKey(),
+	column: integer('column').default(1),
+	columnPrimary: integer('column_primary'),
+	column3: integer('column3').array().notNull(),
+});
+
+export const allNumerics = pgTable('all_numerics', {
+	columnAll: numeric('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: numeric('column'),
+	columnPrimary: numeric('column_primary').primaryKey().notNull(),
+	column3: numeric('column3').array().notNull(),
+});
+
+export const allCidr = pgTable('all_cidr', {
+	columnAll: cidr('column_all').notNull().array().generatedAlwaysAs(sql`{'0.0.0.0/0'}`),
+	column: cidr('column').default('0.0.0.0/0'),
+	columnPrimary: cidr('column_primary').primaryKey().notNull(),
+	column3: cidr('column3').array().notNull(),
+});
+
+export const allCustom = pgTable('all_custom', {
+	columnAll: citext('column_all').notNull().array().generatedAlwaysAs(sql`{'0.0.0.0/0'}`),
+	column: citext('column').default('test{}\'://`"'),
+	columnPrimary: citext('column_primary').primaryKey().notNull(),
+	column3: citext('column3').array().notNull(),
+});
+
+export const allInet = pgTable('all_inet', {
+	columnAll: inet('column_all').notNull().array().generatedAlwaysAs(sql`{'127.0.0.1'}`),
+	column: inet('column').default('127.0.0.1'),
+	columnPrimary: inet('column_primary').primaryKey().notNull(),
+	column3: inet('column3').array().notNull(),
+});
+
+export const allLine = pgTable('all_line', {
+	columnAll: line('column_all').notNull().array().generatedAlwaysAs(sql`{{1, 1, 1}}`),
+	column: line('column').default([1, 1, 1]),
+	columnPrimary: line('column_primary').primaryKey().notNull(),
+	column3: line('column3').array().notNull(),
+});
+
+export const allMacaddr = pgTable('all_macaddr', {
+	columnAll: macaddr('column_all').notNull().array().generatedAlwaysAs(sql`{'08:00:2b:01:02:03'}`),
+	column: macaddr('column').default('08:00:2b:01:02:03'),
+	columnPrimary: macaddr('column_primary').primaryKey().notNull(),
+	column3: macaddr('column3').notNull().array(),
+});
+
+export const allMacaddr8 = pgTable('all_macaddr8', {
+	columnAll: macaddr8('column_all').notNull().array().generatedAlwaysAs(sql`{'08:00:2b:01:02:03:04:05'}`),
+	column: macaddr8('column').default('08:00:2b:01:02:03:04:05'),
+	columnPrimary: macaddr8('column_primary').primaryKey().notNull(),
+	column3: macaddr8('column3').notNull().array(),
+});
+
+export const allPoint = pgTable('all_point', {
+	columnAll: point('column_all', { mode: 'xy' }).notNull().array().generatedAlwaysAs(sql`{{1, 2}}`),
+	columnAll1: point('column_all1', { mode: 'tuple' }).notNull().array().generatedAlwaysAs(sql`{{1, 2}}`),
+	column: point('column', { mode: 'xy' }).default({ x: 1, y: 2 }),
+	column1: point('column1', { mode: 'tuple' }).default([1, 2]),
+	columnPrimary: point('column_primary').primaryKey().notNull(),
+	column3: point('column3').notNull().array(),
+});
+
+export const allDecimals = pgTable('all_decimals', {
+	columnAll: decimal('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
+	column: decimal('column').array(),
+	columnPrimary: decimal('column_primary').primaryKey().notNull(),
+});
+
+export const allGeometry = pgTable('all_geometry', {
+	columnAll: geometry('column_all', { mode: 'xy', srid: 4326, type: 'point' }).default({ x: 30.5234, y: 50.4501 })
+		.notNull(),
+	columnAll1: geometry('column_all1', { mode: 'xy', type: 'point' }).default({ x: 30.5234, y: 50.4501 }).notNull(),
+	columnAll2: geometry('column_all2', { mode: 'tuple', srid: 4326, type: 'point' }).default([30.5234, 50.4501])
+		.notNull(),
+	columnAll3: geometry('column_all3', { mode: 'tuple', type: 'point' }).default([30.5234, 50.4501]).notNull(),
+	column: geometry('column').array(),
+	columnPrimary: geometry('column_primary').primaryKey().notNull(),
+});
+
+export const allBit = pgTable('all_bit', {
+	columnAll: bit('column_all', { dimensions: 1 }).default('1').notNull(),
+	columnAll1: bit('column_all1', { dimensions: 2 }).default('11').notNull(),
+	column: bit('column', { dimensions: 3 }).array(),
+	columnPrimary: bit('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allHalfvec = pgTable('all_halfvec', {
+	columnAll: halfvec('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: halfvec('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	column: halfvec('column', { dimensions: 3 }).array(),
+	columnPrimary: halfvec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allVec = pgTable('all_vec', {
+	columnAll: vector('column_all', { dimensions: 1 }).default([0, -2, 3]).notNull(),
+	columnAll1: vector('column_all1', { dimensions: 2 }).default([0, -2, 3]).notNull(),
+	columnAll2: vector('column_all2', { dimensions: 2 }).array().default([[0, -2, 3]]).notNull(),
+	columnPrimary: vector('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
+
+export const allSparcevec = pgTable('all_sparcevec', {
+	columnAll: sparsevec('column_all', { dimensions: 1 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll1: sparsevec('column_all1', { dimensions: 2 }).default('{1:-1,3:2,5:3}/5').notNull(),
+	columnAll3: sparsevec('column_all3', { dimensions: 2 }).array().default(['{1:-1,3:2,5:3}/5']).notNull(),
+	columnPrimary: sparsevec('column_primary', { dimensions: 5 }).primaryKey().notNull(),
+});
diff --git a/drizzle-kit/tests/postgres/snapshots/snapshot05-0.23.2.json b/drizzle-kit/tests/postgres/snapshots/snapshot05-0.23.2.json
new file mode 100644
index 0000000000..cce1b915cc
--- /dev/null
+++ b/drizzle-kit/tests/postgres/snapshots/snapshot05-0.23.2.json
@@ -0,0 +1,71 @@
+{
+	"id": "023db181-c1ae-4a62-a48a-f6a7ef716b9b",
+	"prevId": "00000000-0000-0000-0000-000000000000",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.users": {
+			"name": "users",
+			"schema": "",
+			"columns": {
+				"id": {
+					"name": "id",
+					"type": "serial",
+					"primaryKey": true,
+					"notNull": true
+				},
+				"name": {
+					"name": "name",
+					"type": "text",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"email": {
+					"name": "email",
+					"type": "text",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"password": {
+					"name": "password",
+					"type": "text",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"avatar": {
+					"name": "avatar",
+					"type": "text",
+					"primaryKey": false,
+					"notNull": false
+				},
+				"createdAt": {
+					"name": "createdAt",
+					"type": "timestamp",
+					"primaryKey": false,
+					"notNull": true,
+					"default": "now()"
+				}
+			},
+			"indexes": {},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {
+				"users_email_unique": {
+					"name": "users_email_unique",
+					"nullsNotDistinct": false,
+					"columns": [
+						"email"
+					]
+				}
+			}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}
diff --git a/drizzle-kit/tests/push/common.ts b/drizzle-kit/tests/push/common.ts
index 627070f117..1d8b817184 100644
--- a/drizzle-kit/tests/push/common.ts
+++ b/drizzle-kit/tests/push/common.ts
@@ -38,12 +38,9 @@ export const run = (
 	test('Indexes properties that should not trigger push changes', () => suite.indexesToBeNotTriggered(context));
 	test('Indexes test case #1', () => suite.indexesTestCase1(context));
 	test('Drop column', () => suite.case1());
-
 	test('Add not null to a column', () => suite.addNotNull());
 	test('Add not null to a column with null data. Should rollback', () => suite.addNotNullWithDataNoRollback());
-
 	test('Add basic sequences', () => suite.addBasicSequences());
-
 	test('Add generated column', () => suite.addGeneratedColumn(context));
 	test('Add generated constraint to an existing column', () => suite.addGeneratedToColumn(context));
 	test('Drop generated constraint from a column', () => suite.dropGeneratedConstraint(context));
diff --git a/drizzle-kit/tests/push/libsql.test.ts b/drizzle-kit/tests/push/libsql.test.ts
deleted file mode 100644
index 2ae2e38110..0000000000
--- a/drizzle-kit/tests/push/libsql.test.ts
+++ /dev/null
@@ -1,1400 +0,0 @@
-import { createClient } from '@libsql/client';
-import chalk from 'chalk';
-import { sql } from 'drizzle-orm';
-import {
-	blob,
-	check,
-	foreignKey,
-	getTableConfig,
-	index,
-	int,
-	integer,
-	numeric,
-	real,
-	sqliteTable,
-	sqliteView,
-	text,
-	uniqueIndex,
-} from 'drizzle-orm/sqlite-core';
-import { diffTestSchemasPushLibSQL } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-test('nothing changed in schema', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const users = sqliteTable('users', {
-		id: integer('id').primaryKey().notNull(),
-		name: text('name').notNull(),
-		email: text('email'),
-		textJson: text('text_json', { mode: 'json' }),
-		blobJon: blob('blob_json', { mode: 'json' }),
-		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
-		numeric: numeric('numeric'),
-		createdAt: integer('created_at', { mode: 'timestamp' }),
-		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
-		real: real('real'),
-		text: text('text', { length: 255 }),
-		role: text('role', { enum: ['admin', 'user'] }).default('user'),
-		isConfirmed: integer('is_confirmed', {
-			mode: 'boolean',
-		}),
-	});
-
-	const schema1 = {
-		users,
-
-		customers: sqliteTable('customers', {
-			id: integer('id').primaryKey(),
-			address: text('address').notNull(),
-			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-			registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-				.notNull()
-				.$defaultFn(() => new Date()),
-			userId: integer('user_id')
-				.references(() => users.id)
-				.notNull(),
-		}),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(turso, schema1, schema1, [], false);
-	expect(sqlStatements.length).toBe(0);
-	expect(statements.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-});
-
-test('added, dropped index', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const users = sqliteTable('users', {
-		id: integer('id').primaryKey().notNull(),
-		name: text('name').notNull(),
-		email: text('email'),
-		textJson: text('text_json', { mode: 'json' }),
-		blobJon: blob('blob_json', { mode: 'json' }),
-		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
-		numeric: numeric('numeric'),
-		createdAt: integer('created_at', { mode: 'timestamp' }),
-		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
-		real: real('real'),
-		text: text('text', { length: 255 }),
-		role: text('role', { enum: ['admin', 'user'] }).default('user'),
-		isConfirmed: integer('is_confirmed', {
-			mode: 'boolean',
-		}),
-	});
-
-	const schema1 = {
-		users,
-		customers: sqliteTable(
-			'customers',
-			{
-				id: integer('id').primaryKey(),
-				address: text('address').notNull(),
-				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-					.notNull()
-					.$defaultFn(() => new Date()),
-				userId: integer('user_id').notNull(),
-			},
-			(table) => ({
-				uniqueIndex: uniqueIndex('customers_address_unique').on(table.address),
-			}),
-		),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const schema2 = {
-		users,
-		customers: sqliteTable(
-			'customers',
-			{
-				id: integer('id').primaryKey(),
-				address: text('address').notNull(),
-				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-					.notNull()
-					.$defaultFn(() => new Date()),
-				userId: integer('user_id').notNull(),
-			},
-			(table) => ({
-				uniqueIndex: uniqueIndex('customers_is_confirmed_unique').on(
-					table.isConfirmed,
-				),
-			}),
-		),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(turso, schema1, schema2, [], false);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_index',
-		tableName: 'customers',
-		data: 'customers_address_unique;address;true;',
-		schema: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_index',
-		tableName: 'customers',
-		data: 'customers_is_confirmed_unique;is_confirmed;true;',
-		schema: '',
-		internal: { indexes: {} },
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX \`customers_address_unique\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE UNIQUE INDEX \`customers_is_confirmed_unique\` ON \`customers\` (\`is_confirmed\`);`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('added column not null and without default to table with data', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('drizzle');`,
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('turso');`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'integer',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		referenceData: undefined,
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`delete from companies;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to add not-null ${
-			chalk.underline(
-				'age',
-			)
-		} column without default value, which contains 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe('companies');
-});
-
-test('added column not null and without default to table without data', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(turso, schema1, schema2, [], false);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'integer',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		referenceData: undefined,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
-	);
-
-	expect(infoToPrint!.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop autoincrement. drop column with data', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: false }),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
-	];
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		tableName: 'companies',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: true,
-				primaryKey: true,
-				generated: undefined,
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_companies\` (
-\t\`id\` integer PRIMARY KEY NOT NULL
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`);
-	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(1);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to delete ${
-			chalk.underline(
-				'name',
-			)
-		} column in companies table with 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('change autoincrement. table is part of foreign key', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const companies1 = sqliteTable('companies', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-	});
-	const users1 = sqliteTable('users', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-		name: text('name').unique(),
-		companyId: integer('company_id').references(() => companies1.id),
-	});
-	const schema1 = {
-		companies: companies1,
-		users: users1,
-	};
-
-	const companies2 = sqliteTable('companies', {
-		id: integer('id').primaryKey({ autoIncrement: false }),
-	});
-	const users2 = sqliteTable('users', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-		name: text('name').unique(),
-		companyId: integer('company_id').references(() => companies2.id),
-	});
-	const schema2 = {
-		companies: companies2,
-		users: users2,
-	};
-
-	const { name: usersTableName } = getTableConfig(users1);
-	const { name: companiesTableName } = getTableConfig(companies1);
-	const seedStatements = [
-		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('drizzle');`,
-		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('turso');`,
-		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES (1);`,
-		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES (2);`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		tableName: 'companies',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: true,
-				primaryKey: true,
-				generated: undefined,
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_companies\` (
-\t\`id\` integer PRIMARY KEY NOT NULL
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop not null, add not null', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name').notNull(),
-				userId: int('user_id'),
-			},
-		),
-	};
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnDefault: undefined,
-		columnName: 'name',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		schema: '',
-		tableName: 'users',
-		type: 'alter_table_alter_column_drop_notnull',
-	});
-	expect(statements![1]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnDefault: undefined,
-		columnName: 'name',
-		columnNotNull: true,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		schema: '',
-		tableName: 'posts',
-		type: 'alter_table_alter_column_set_notnull',
-	});
-	expect(sqlStatements!.length).toBe(2);
-	expect(sqlStatements![0]).toBe(`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text;`);
-	expect(sqlStatements![1]).toBe(`ALTER TABLE \`posts\` ALTER COLUMN "name" TO "name" text NOT NULL;`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop table with data', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const schema2 = {
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const seedStatements = [
-		`INSERT INTO \`users\` ("name") VALUES ('drizzle')`,
-	];
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		policies: [],
-		schema: undefined,
-		tableName: 'users',
-		type: 'drop_table',
-	});
-
-	expect(sqlStatements!.length).toBe(1);
-	expect(sqlStatements![0]).toBe(`DROP TABLE \`users\`;`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(`· You're about to delete ${chalk.underline('users')} table with 1 items`);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(1);
-	expect(tablesToRemove![0]).toBe('users');
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('recreate table with nested references', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	let users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	let subscriptions = sqliteTable('subscriptions', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		userId: integer('user_id').references(() => users.id),
-		customerId: text('customer_id'),
-	});
-	const schema1 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: false }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	const schema2 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(turso, schema1, schema2, []);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements![1]).toBe(
-		`INSERT INTO \`__new_users\`("id", "name", "age") SELECT "id", "name", "age" FROM \`users\`;`,
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('recreate table with added column not null and without default', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-			newColumn: text('new_column').notNull(),
-		}),
-	};
-
-	const seedStatements = [
-		`INSERT INTO \`users\` ("name", "age") VALUES ('drizzle', 12)`,
-		`INSERT INTO \`users\` ("name", "age") VALUES ('turso', 12)`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'new_column',
-				notNull: true,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements[0]).toBe('DELETE FROM \`users\`;');
-	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer,
-\t\`new_column\` text NOT NULL
-);\n`);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to add not-null ${
-			chalk.underline('new_column')
-		} column without default value to table, which contains 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe('users');
-});
-
-test('set not null with index', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}, (table) => ({
-			someIndex: index('users_name_index').on(table.name),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}, (table) => ({
-			someIndex: index('users_name_index').on(table.name),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnDefault: undefined,
-		columnName: 'name',
-		columnNotNull: true,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		schema: '',
-		tableName: 'users',
-		type: 'alter_table_alter_column_set_notnull',
-	});
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_set_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: true,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(3);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX "users_name_index";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text NOT NULL;`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`CREATE INDEX \`users_name_index\` ON \`users\` (\`name\`);`,
-	);
-	expect(columnsToRemove!.length).toBe(0), expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop not null with two indexes', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-			age: int('age').notNull(),
-		}, (table) => ({
-			someUniqeIndex: uniqueIndex('users_name_unique').on(table.name),
-			someIndex: index('users_age_index').on(table.age),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			age: int('age').notNull(),
-		}, (table) => ({
-			someUniqeIndex: uniqueIndex('users_name_unique').on(table.name),
-			someIndex: index('users_age_index').on(table.age),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_alter_column_drop_notnull',
-		tableName: 'users',
-		columnName: 'name',
-		schema: '',
-		newDataType: 'text',
-		columnDefault: undefined,
-		columnOnUpdate: undefined,
-		columnNotNull: false,
-		columnAutoIncrement: false,
-		columnPk: false,
-	});
-
-	expect(sqlStatements.length).toBe(5);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX "users_name_unique";`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`DROP INDEX "users_age_index";`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`ALTER TABLE \`users\` ALTER COLUMN "name" TO "name" text;`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`CREATE UNIQUE INDEX \`users_name_unique\` ON \`users\` (\`name\`);`,
-	);
-	expect(sqlStatements[4]).toBe(
-		`CREATE INDEX \`users_age_index\` ON \`users\` (\`age\`);`,
-	);
-	expect(columnsToRemove!.length).toBe(0), expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('add check constraint to table', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: ['some_check;"users"."age" > 21'],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer,
-\tCONSTRAINT "some_check" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop check constraint', async (t) => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('db has checks. Push with same names', async () => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`some new value`),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		[],
-	);
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('create view', async () => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select "id" from "test"',
-			name: 'view',
-			type: 'sqlite_create_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE VIEW \`view\` AS select "id" from "test";`,
-	]);
-});
-
-test('drop view', async () => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			type: 'drop_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'DROP VIEW \`view\`;',
-	]);
-});
-
-test('alter view ".as"', async () => {
-	const turso = createClient({
-		url: ':memory:',
-	});
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushLibSQL(
-		turso,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/push/mysql-push.test.ts b/drizzle-kit/tests/push/mysql-push.test.ts
deleted file mode 100644
index ba64ccddb0..0000000000
--- a/drizzle-kit/tests/push/mysql-push.test.ts
+++ /dev/null
@@ -1,345 +0,0 @@
-import Docker from 'dockerode';
-import { sql } from 'drizzle-orm';
-import { check, int, mysqlTable, mysqlView } from 'drizzle-orm/mysql-core';
-import fs from 'fs';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { diffTestSchemasPushMysql } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
-
-let client: Connection;
-let mysqlContainer: Docker.Container;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env.MYSQL_CONNECTION_STRING ?? await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
-});
-
-if (!fs.existsSync('tests/push/mysql')) {
-	fs.mkdirSync('tests/push/mysql');
-}
-
-test('add check constraint to table', async () => {
-	const schema1 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values'),
-		}),
-	};
-	const schema2 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values'),
-		}, (table) => ({
-			checkConstraint1: check('some_check1', sql`${table.values} < 100`),
-			checkConstraint2: check('some_check2', sql`'test' < 100`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_check_constraint',
-			tableName: 'test',
-			schema: '',
-			data: 'some_check1;\`test\`.\`values\` < 100',
-		},
-		{
-			data: "some_check2;'test' < 100",
-			schema: '',
-			tableName: 'test',
-			type: 'create_check_constraint',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE \`test\` ADD CONSTRAINT \`some_check1\` CHECK (\`test\`.\`values\` < 100);',
-		`ALTER TABLE \`test\` ADD CONSTRAINT \`some_check2\` CHECK ('test' < 100);`,
-	]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
-
-test('drop check constraint to table', async () => {
-	const schema1 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values'),
-		}, (table) => ({
-			checkConstraint1: check('some_check1', sql`${table.values} < 100`),
-			checkConstraint2: check('some_check2', sql`'test' < 100`),
-		})),
-	};
-	const schema2 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'delete_check_constraint',
-			tableName: 'test',
-			schema: '',
-			constraintName: 'some_check1',
-		},
-		{
-			constraintName: 'some_check2',
-			schema: '',
-			tableName: 'test',
-			type: 'delete_check_constraint',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE \`test\` DROP CONSTRAINT \`some_check1\`;',
-		`ALTER TABLE \`test\` DROP CONSTRAINT \`some_check2\`;`,
-	]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
-
-test('db has checks. Push with same names', async () => {
-	const schema1 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values').default(1),
-		}, (table) => ({
-			checkConstraint: check('some_check', sql`${table.values} < 100`),
-		})),
-	};
-	const schema2 = {
-		test: mysqlTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values').default(1),
-		}, (table) => ({
-			checkConstraint: check('some_check', sql`some new value`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
-
-test('create view', async () => {
-	const table = mysqlTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: mysqlView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select \`id\` from \`test\`',
-			name: 'view',
-			type: 'mysql_create_view',
-			replace: false,
-			sqlSecurity: 'definer',
-			withCheckOption: undefined,
-			algorithm: 'undefined',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE ALGORITHM = undefined
-SQL SECURITY definer
-VIEW \`view\` AS (select \`id\` from \`test\`);`,
-	]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
-
-test('drop view', async () => {
-	const table = mysqlTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: mysqlView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			type: 'drop_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'DROP VIEW \`view\`;',
-	]);
-	await client.query(`DROP TABLE \`test\`;`);
-	await client.query(`DROP VIEW \`view\`;`);
-});
-
-test('alter view ".as"', async () => {
-	const table = mysqlTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: mysqlView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: mysqlView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-
-	await client.query(`DROP TABLE \`test\`;`);
-	await client.query(`DROP VIEW \`view\`;`);
-});
-
-test('alter meta options with distinct in definition', async () => {
-	const table = mysqlTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: mysqlView('view').withCheckOption('cascaded').sqlSecurity('definer').algorithm('merge').as((
-			qb,
-		) => qb.selectDistinct().from(table).where(sql`${table.id} = 1`)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: mysqlView('view').withCheckOption('cascaded').sqlSecurity('definer').algorithm('undefined').as((qb) =>
-			qb.selectDistinct().from(table)
-		),
-	};
-
-	await expect(diffTestSchemasPushMysql(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	)).rejects.toThrowError();
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
diff --git a/drizzle-kit/tests/push/mysql.test.ts b/drizzle-kit/tests/push/mysql.test.ts
deleted file mode 100644
index 6c7f5efc2c..0000000000
--- a/drizzle-kit/tests/push/mysql.test.ts
+++ /dev/null
@@ -1,788 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { SQL, sql } from 'drizzle-orm';
-import {
-	bigint,
-	binary,
-	char,
-	date,
-	datetime,
-	decimal,
-	double,
-	float,
-	int,
-	json,
-	mediumint,
-	mysqlEnum,
-	mysqlTable,
-	primaryKey,
-	serial,
-	smallint,
-	text,
-	time,
-	timestamp,
-	tinyint,
-	varbinary,
-	varchar,
-	year,
-} from 'drizzle-orm/mysql-core';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { diffTestSchemasMysql, diffTestSchemasPushMysql } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { expect, test } from 'vitest';
-import { DialectSuite, run } from './common';
-
-async function createDockerDB(context: any): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	context.mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await context.mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-const mysqlSuite: DialectSuite = {
-	allTypes: async function(context: any): Promise<void> {
-		const schema1 = {
-			allBigInts: mysqlTable('all_big_ints', {
-				simple: bigint('simple', { mode: 'number' }),
-				columnNotNull: bigint('column_not_null', { mode: 'number' }).notNull(),
-				columnDefault: bigint('column_default', { mode: 'number' }).default(12),
-				columnDefaultSql: bigint('column_default_sql', {
-					mode: 'number',
-				}).default(12),
-			}),
-			allBools: mysqlTable('all_bools', {
-				simple: tinyint('simple'),
-				columnNotNull: tinyint('column_not_null').notNull(),
-				columnDefault: tinyint('column_default').default(1),
-			}),
-			allChars: mysqlTable('all_chars', {
-				simple: char('simple', { length: 1 }),
-				columnNotNull: char('column_not_null', { length: 45 }).notNull(),
-				// columnDefault: char("column_default", { length: 1 }).default("h"),
-				columnDefaultSql: char('column_default_sql', { length: 1 }).default(
-					'h',
-				),
-			}),
-			allDateTimes: mysqlTable('all_date_times', {
-				simple: datetime('simple', { mode: 'string', fsp: 1 }),
-				columnNotNull: datetime('column_not_null', {
-					mode: 'string',
-				}).notNull(),
-				columnDefault: datetime('column_default', { mode: 'string' }).default(
-					'2023-03-01 14:05:29',
-				),
-			}),
-			allDates: mysqlTable('all_dates', {
-				simple: date('simple', { mode: 'string' }),
-				column_not_null: date('column_not_null', { mode: 'string' }).notNull(),
-				column_default: date('column_default', { mode: 'string' }).default(
-					'2023-03-01',
-				),
-			}),
-			allDecimals: mysqlTable('all_decimals', {
-				simple: decimal('simple', { precision: 1, scale: 0 }),
-				columnNotNull: decimal('column_not_null', {
-					precision: 45,
-					scale: 3,
-				}).notNull(),
-				columnDefault: decimal('column_default', {
-					precision: 10,
-					scale: 0,
-				}).default('100'),
-				columnDefaultSql: decimal('column_default_sql', {
-					precision: 10,
-					scale: 0,
-				}).default('101'),
-			}),
-
-			allDoubles: mysqlTable('all_doubles', {
-				simple: double('simple'),
-				columnNotNull: double('column_not_null').notNull(),
-				columnDefault: double('column_default').default(100),
-				columnDefaultSql: double('column_default_sql').default(101),
-			}),
-
-			allEnums: mysqlTable('all_enums', {
-				simple: mysqlEnum('simple', ['hi', 'hello']),
-			}),
-
-			allEnums1: mysqlTable('all_enums1', {
-				simple: mysqlEnum('simple', ['hi', 'hello']).default('hi'),
-			}),
-
-			allFloats: mysqlTable('all_floats', {
-				columnNotNull: float('column_not_null').notNull(),
-				columnDefault: float('column_default').default(100),
-				columnDefaultSql: float('column_default_sql').default(101),
-			}),
-
-			allInts: mysqlTable('all_ints', {
-				simple: int('simple'),
-				columnNotNull: int('column_not_null').notNull(),
-				columnDefault: int('column_default').default(100),
-				columnDefaultSql: int('column_default_sql').default(101),
-			}),
-
-			allIntsRef: mysqlTable('all_ints_ref', {
-				simple: int('simple'),
-				columnNotNull: int('column_not_null').notNull(),
-				columnDefault: int('column_default').default(100),
-				columnDefaultSql: int('column_default_sql').default(101),
-			}),
-
-			allJsons: mysqlTable('all_jsons', {
-				columnDefaultObject: json('column_default_object')
-					.default({ hello: 'world world' })
-					.notNull(),
-				columnDefaultArray: json('column_default_array').default({
-					hello: { 'world world': ['foo', 'bar'] },
-					foo: 'bar',
-					fe: 23,
-				}),
-				column: json('column'),
-			}),
-
-			allMInts: mysqlTable('all_m_ints', {
-				simple: mediumint('simple'),
-				columnNotNull: mediumint('column_not_null').notNull(),
-				columnDefault: mediumint('column_default').default(100),
-				columnDefaultSql: mediumint('column_default_sql').default(101),
-			}),
-
-			allReals: mysqlTable('all_reals', {
-				simple: double('simple', { precision: 5, scale: 2 }),
-				columnNotNull: double('column_not_null').notNull(),
-				columnDefault: double('column_default').default(100),
-				columnDefaultSql: double('column_default_sql').default(101),
-			}),
-
-			allSInts: mysqlTable('all_s_ints', {
-				simple: smallint('simple'),
-				columnNotNull: smallint('column_not_null').notNull(),
-				columnDefault: smallint('column_default').default(100),
-				columnDefaultSql: smallint('column_default_sql').default(101),
-			}),
-
-			allSmallSerials: mysqlTable('all_small_serials', {
-				columnAll: serial('column_all').primaryKey().notNull(),
-			}),
-
-			allTInts: mysqlTable('all_t_ints', {
-				simple: tinyint('simple'),
-				columnNotNull: tinyint('column_not_null').notNull(),
-				columnDefault: tinyint('column_default').default(10),
-				columnDefaultSql: tinyint('column_default_sql').default(11),
-			}),
-
-			allTexts: mysqlTable('all_texts', {
-				simple: text('simple'),
-				columnNotNull: text('column_not_null').notNull(),
-				columnDefault: text('column_default').default('hello'),
-				columnDefaultSql: text('column_default_sql').default('hello'),
-			}),
-
-			allTimes: mysqlTable('all_times', {
-				simple: time('simple', { fsp: 1 }),
-				columnNotNull: time('column_not_null').notNull(),
-				columnDefault: time('column_default').default('22:12:12'),
-			}),
-
-			allTimestamps: mysqlTable('all_timestamps', {
-				columnDateNow: timestamp('column_date_now', {
-					fsp: 1,
-					mode: 'string',
-				}).default(sql`(now())`),
-				columnAll: timestamp('column_all', { mode: 'string' })
-					.default('2023-03-01 14:05:29')
-					.notNull(),
-				column: timestamp('column', { mode: 'string' }).default(
-					'2023-02-28 16:18:31',
-				),
-			}),
-
-			allVarChars: mysqlTable('all_var_chars', {
-				simple: varchar('simple', { length: 100 }),
-				columnNotNull: varchar('column_not_null', { length: 45 }).notNull(),
-				columnDefault: varchar('column_default', { length: 100 }).default(
-					'hello',
-				),
-				columnDefaultSql: varchar('column_default_sql', {
-					length: 100,
-				}).default('hello'),
-			}),
-
-			allVarbinaries: mysqlTable('all_varbinaries', {
-				simple: varbinary('simple', { length: 100 }),
-				columnNotNull: varbinary('column_not_null', { length: 100 }).notNull(),
-				columnDefault: varbinary('column_default', { length: 12 }).default(
-					sql`(uuid_to_bin(uuid()))`,
-				),
-			}),
-
-			allYears: mysqlTable('all_years', {
-				simple: year('simple'),
-				columnNotNull: year('column_not_null').notNull(),
-				columnDefault: year('column_default').default(2022),
-			}),
-
-			binafry: mysqlTable('binary', {
-				simple: binary('simple', { length: 1 }),
-				columnNotNull: binary('column_not_null', { length: 1 }).notNull(),
-				columnDefault: binary('column_default', { length: 12 }).default(
-					sql`(uuid_to_bin(uuid()))`,
-				),
-			}),
-		};
-
-		const { statements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema1,
-			[],
-			'drizzle',
-			false,
-		);
-		expect(statements.length).toBe(2);
-		expect(statements).toEqual([
-			{
-				type: 'delete_unique_constraint',
-				tableName: 'all_small_serials',
-				data: 'column_all;column_all',
-				schema: '',
-			},
-			{
-				type: 'delete_unique_constraint',
-				tableName: 'all_small_serials',
-				data: 'column_all;column_all',
-				schema: '',
-			},
-		]);
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasMysql(
-			schema1,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	addBasicIndexes: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	changeIndexFields: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	dropIndex: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	indexesToBeNotTriggered: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	indexesTestCase1: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	async case1() {
-		// TODO: implement if needed
-		expect(true).toBe(true);
-	},
-	addNotNull: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addNotNullWithDataNoRollback: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addBasicSequences: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addGeneratedColumn: async function(context: any): Promise<void> {
-		const schema1 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-			}),
-		};
-		const schema2 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'stored' },
-				),
-				generatedName1: text('gen_name1').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'virtual' },
-				),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				column: {
-					autoincrement: false,
-					generated: {
-						as: "`users`.`name` || 'hello'",
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_add_column',
-			},
-			{
-				column: {
-					autoincrement: false,
-					generated: {
-						as: "`users`.`name` || 'hello'",
-						type: 'virtual',
-					},
-					name: 'gen_name1',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_add_column',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-			"ALTER TABLE `users` ADD `gen_name1` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-		]);
-
-		for (const st of sqlStatements) {
-			await context.client.query(st);
-		}
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasMysql(
-			schema2,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	addGeneratedToColumn: async function(context: any): Promise<void> {
-		const schema1 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name'),
-				generatedName1: text('gen_name1'),
-			}),
-		};
-		const schema2 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'stored' },
-				),
-				generatedName1: text('gen_name1').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'virtual' },
-				),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				columnAutoIncrement: false,
-				columnDefault: undefined,
-				columnGenerated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				columnName: 'gen_name',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_set_generated',
-			},
-			{
-				columnAutoIncrement: false,
-				columnDefault: undefined,
-				columnGenerated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'virtual',
-				},
-				columnName: 'gen_name1',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_set_generated',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			"ALTER TABLE `users` MODIFY COLUMN `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-			'ALTER TABLE `users` DROP COLUMN `gen_name1`;',
-			"ALTER TABLE `users` ADD `gen_name1` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-		]);
-
-		for (const st of sqlStatements) {
-			await context.client.query(st);
-		}
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasMysql(
-			schema2,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	dropGeneratedConstraint: async function(context: any): Promise<void> {
-		const schema1 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name}`,
-					{ mode: 'stored' },
-				),
-				generatedName1: text('gen_name1').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name}`,
-					{ mode: 'virtual' },
-				),
-			}),
-		};
-		const schema2 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name'),
-				generatedName1: text('gen_name1'),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				columnAutoIncrement: false,
-				columnDefault: undefined,
-				columnGenerated: undefined,
-				columnName: 'gen_name',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				oldColumn: {
-					autoincrement: false,
-					default: undefined,
-					generated: {
-						as: '`name`',
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					onUpdate: undefined,
-					primaryKey: false,
-					type: 'text',
-				},
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_drop_generated',
-			},
-			{
-				columnAutoIncrement: false,
-				columnDefault: undefined,
-				columnGenerated: undefined,
-				columnName: 'gen_name1',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				oldColumn: {
-					autoincrement: false,
-					default: undefined,
-					generated: {
-						as: '`name`',
-						type: 'virtual',
-					},
-					name: 'gen_name1',
-					notNull: false,
-					onUpdate: undefined,
-					primaryKey: false,
-					type: 'text',
-				},
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_drop_generated',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-			'ALTER TABLE `users` DROP COLUMN `gen_name1`;',
-			'ALTER TABLE `users` ADD `gen_name1` text;',
-		]);
-
-		for (const st of sqlStatements) {
-			await context.client.query(st);
-		}
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasMysql(
-			schema2,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	alterGeneratedConstraint: async function(context: any): Promise<void> {
-		const schema1 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name}`,
-					{ mode: 'stored' },
-				),
-				generatedName1: text('gen_name1').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name}`,
-					{ mode: 'virtual' },
-				),
-			}),
-		};
-		const schema2 = {
-			users: mysqlTable('users', {
-				id: int('id'),
-				id2: int('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'stored' },
-				),
-				generatedName1: text('gen_name1').generatedAlwaysAs(
-					(): SQL => sql`${schema2.users.name} || 'hello'`,
-					{ mode: 'virtual' },
-				),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([]);
-		expect(sqlStatements).toStrictEqual([]);
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasMysql(
-			schema2,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	createTableWithGeneratedConstraint: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	createCompositePrimaryKey: async function(context: any): Promise<void> {
-		const schema1 = {};
-
-		const schema2 = {
-			table: mysqlTable('table', {
-				col1: int('col1').notNull(),
-				col2: int('col2').notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.col1, t.col2],
-				}),
-			})),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				type: 'create_table',
-				tableName: 'table',
-				schema: undefined,
-				internals: {
-					indexes: {},
-					tables: {},
-				},
-				compositePKs: ['table_col1_col2_pk;col1,col2'],
-				compositePkName: 'table_col1_col2_pk',
-				uniqueConstraints: [],
-				checkConstraints: [],
-				columns: [
-					{ name: 'col1', type: 'int', primaryKey: false, notNull: true, autoincrement: false },
-					{ name: 'col2', type: 'int', primaryKey: false, notNull: true, autoincrement: false },
-				],
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'CREATE TABLE `table` (\n\t`col1` int NOT NULL,\n\t`col2` int NOT NULL,\n\tCONSTRAINT `table_col1_col2_pk` PRIMARY KEY(`col1`,`col2`)\n);\n',
-		]);
-	},
-	renameTableWithCompositePrimaryKey: async function(context?: any): Promise<void> {
-		const productsCategoriesTable = (tableName: string) => {
-			return mysqlTable(tableName, {
-				productId: varchar('product_id', { length: 10 }).notNull(),
-				categoryId: varchar('category_id', { length: 10 }).notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.productId, t.categoryId],
-				}),
-			}));
-		};
-
-		const schema1 = {
-			table: productsCategoriesTable('products_categories'),
-		};
-		const schema2 = {
-			test: productsCategoriesTable('products_to_categories'),
-		};
-
-		const { sqlStatements } = await diffTestSchemasPushMysql(
-			context.client as Connection,
-			schema1,
-			schema2,
-			['public.products_categories->public.products_to_categories'],
-			'drizzle',
-			false,
-		);
-
-		expect(sqlStatements).toStrictEqual([
-			'RENAME TABLE `products_categories` TO `products_to_categories`;',
-			'ALTER TABLE `products_to_categories` DROP PRIMARY KEY;',
-			'ALTER TABLE `products_to_categories` ADD PRIMARY KEY(`product_id`,`category_id`);',
-		]);
-
-		await context.client.query(`DROP TABLE \`products_categories\``);
-	},
-};
-
-run(
-	mysqlSuite,
-	async (context: any) => {
-		const connectionString = process.env.MYSQL_CONNECTION_STRING ?? await createDockerDB(context);
-
-		const sleep = 1000;
-		let timeLeft = 20000;
-		let connected = false;
-		let lastError: unknown | undefined;
-		do {
-			try {
-				context.client = await createConnection(connectionString);
-				await context.client.connect();
-				connected = true;
-				break;
-			} catch (e) {
-				lastError = e;
-				await new Promise((resolve) => setTimeout(resolve, sleep));
-				timeLeft -= sleep;
-			}
-		} while (timeLeft > 0);
-		if (!connected) {
-			console.error('Cannot connect to MySQL');
-			await context.client?.end().catch(console.error);
-			await context.mysqlContainer?.stop().catch(console.error);
-			throw lastError;
-		}
-	},
-	async (context: any) => {
-		await context.client?.end().catch(console.error);
-		await context.mysqlContainer?.stop().catch(console.error);
-	},
-	async (context: any) => {
-		await context.client?.query(`drop database if exists \`drizzle\`;`);
-		await context.client?.query(`create database \`drizzle\`;`);
-		await context.client?.query(`use \`drizzle\`;`);
-	},
-);
diff --git a/drizzle-kit/tests/push/pg.test.ts b/drizzle-kit/tests/push/pg.test.ts
deleted file mode 100644
index a5c8b30287..0000000000
--- a/drizzle-kit/tests/push/pg.test.ts
+++ /dev/null
@@ -1,4412 +0,0 @@
-import { PGlite } from '@electric-sql/pglite';
-import chalk from 'chalk';
-import {
-	bigint,
-	bigserial,
-	boolean,
-	char,
-	check,
-	date,
-	doublePrecision,
-	index,
-	integer,
-	interval,
-	json,
-	jsonb,
-	numeric,
-	pgEnum,
-	pgMaterializedView,
-	pgPolicy,
-	pgRole,
-	pgSchema,
-	pgSequence,
-	pgTable,
-	pgView,
-	primaryKey,
-	real,
-	serial,
-	smallint,
-	text,
-	time,
-	timestamp,
-	uniqueIndex,
-	uuid,
-	varchar,
-} from 'drizzle-orm/pg-core';
-import { drizzle } from 'drizzle-orm/pglite';
-import { eq, SQL, sql } from 'drizzle-orm/sql';
-import { pgSuggestions } from 'src/cli/commands/pgPushUtils';
-import { diffTestSchemas, diffTestSchemasPush } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-import { DialectSuite, run } from './common';
-
-const pgSuite: DialectSuite = {
-	async allTypes() {
-		const client = new PGlite();
-
-		const customSchema = pgSchema('schemass');
-
-		const transactionStatusEnum = customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']);
-
-		const enumname = pgEnum('enumname', ['three', 'two', 'one']);
-
-		const schema1 = {
-			test: pgEnum('test', ['ds']),
-			testHello: pgEnum('test_hello', ['ds']),
-			enumname: pgEnum('enumname', ['three', 'two', 'one']),
-
-			customSchema: customSchema,
-			transactionStatusEnum: customSchema.enum('TransactionStatusEnum', ['PENDING', 'FAILED', 'SUCCESS']),
-
-			allSmallSerials: pgTable('schema_test', {
-				columnAll: uuid('column_all').defaultRandom(),
-				column: transactionStatusEnum('column').notNull(),
-			}),
-
-			allSmallInts: customSchema.table(
-				'schema_test2',
-				{
-					columnAll: smallint('column_all').default(124).notNull(),
-					column: smallint('columns').array(),
-					column1: smallint('column1').array().array(),
-					column2: smallint('column2').array().array(),
-					column3: smallint('column3').array(),
-				},
-				(t) => ({
-					cd: uniqueIndex('testdfds').on(t.column),
-				}),
-			),
-
-			allEnums: customSchema.table(
-				'all_enums',
-				{
-					columnAll: enumname('column_all').default('three').notNull(),
-					column: enumname('columns'),
-				},
-				(t) => ({
-					d: index('ds').on(t.column),
-				}),
-			),
-
-			allTimestamps: customSchema.table('all_timestamps', {
-				columnDateNow: timestamp('column_date_now', {
-					precision: 1,
-					withTimezone: true,
-					mode: 'string',
-				}).defaultNow(),
-				columnAll: timestamp('column_all', { mode: 'string' }).default('2023-03-01 12:47:29.792'),
-				column: timestamp('column', { mode: 'string' }).default(sql`'2023-02-28 16:18:31.18'`),
-				column2: timestamp('column2', { mode: 'string', precision: 3 }).default(sql`'2023-02-28 16:18:31.18'`),
-			}),
-
-			allUuids: customSchema.table('all_uuids', {
-				columnAll: uuid('column_all').defaultRandom().notNull(),
-				column: uuid('column'),
-			}),
-
-			allDates: customSchema.table('all_dates', {
-				column_date_now: date('column_date_now').defaultNow(),
-				column_all: date('column_all', { mode: 'date' }).default(new Date()).notNull(),
-				column: date('column'),
-			}),
-
-			allReals: customSchema.table('all_reals', {
-				columnAll: real('column_all').default(32).notNull(),
-				column: real('column'),
-				columnPrimary: real('column_primary').primaryKey().notNull(),
-			}),
-
-			allBigints: pgTable('all_bigints', {
-				columnAll: bigint('column_all', { mode: 'number' }).default(124).notNull(),
-				column: bigint('column', { mode: 'number' }),
-			}),
-
-			allBigserials: customSchema.table('all_bigserials', {
-				columnAll: bigserial('column_all', { mode: 'bigint' }).notNull(),
-				column: bigserial('column', { mode: 'bigint' }).notNull(),
-			}),
-
-			allIntervals: customSchema.table('all_intervals', {
-				columnAllConstrains: interval('column_all_constrains', {
-					fields: 'month',
-				})
-					.default('1 mon')
-					.notNull(),
-				columnMinToSec: interval('column_min_to_sec', {
-					fields: 'minute to second',
-				}),
-				columnWithoutFields: interval('column_without_fields').default('00:00:01').notNull(),
-				column: interval('column'),
-				column5: interval('column5', {
-					fields: 'minute to second',
-					precision: 3,
-				}),
-				column6: interval('column6'),
-			}),
-
-			allSerials: customSchema.table('all_serials', {
-				columnAll: serial('column_all').notNull(),
-				column: serial('column').notNull(),
-			}),
-
-			allTexts: customSchema.table(
-				'all_texts',
-				{
-					columnAll: text('column_all').default('text').notNull(),
-					column: text('columns').primaryKey(),
-				},
-				(t) => ({
-					cd: index('test').on(t.column),
-				}),
-			),
-
-			allBools: customSchema.table('all_bools', {
-				columnAll: boolean('column_all').default(true).notNull(),
-				column: boolean('column'),
-			}),
-
-			allVarchars: customSchema.table('all_varchars', {
-				columnAll: varchar('column_all').default('text').notNull(),
-				column: varchar('column', { length: 200 }),
-			}),
-
-			allTimes: customSchema.table('all_times', {
-				columnDateNow: time('column_date_now').defaultNow(),
-				columnAll: time('column_all').default('22:12:12').notNull(),
-				column: time('column'),
-			}),
-
-			allChars: customSchema.table('all_chars', {
-				columnAll: char('column_all', { length: 1 }).default('text').notNull(),
-				column: char('column', { length: 1 }),
-			}),
-
-			allDoublePrecision: customSchema.table('all_double_precision', {
-				columnAll: doublePrecision('column_all').default(33.2).notNull(),
-				column: doublePrecision('column'),
-			}),
-
-			allJsonb: customSchema.table('all_jsonb', {
-				columnDefaultObject: jsonb('column_default_object').default({ hello: 'world world' }).notNull(),
-				columnDefaultArray: jsonb('column_default_array').default({
-					hello: { 'world world': ['foo', 'bar'] },
-				}),
-				column: jsonb('column'),
-			}),
-
-			allJson: customSchema.table('all_json', {
-				columnDefaultObject: json('column_default_object').default({ hello: 'world world' }).notNull(),
-				columnDefaultArray: json('column_default_array').default({
-					hello: { 'world world': ['foo', 'bar'] },
-					foo: 'bar',
-					fe: 23,
-				}),
-				column: json('column'),
-			}),
-
-			allIntegers: customSchema.table('all_integers', {
-				columnAll: integer('column_all').primaryKey(),
-				column: integer('column'),
-				columnPrimary: integer('column_primary'),
-			}),
-
-			allNumerics: customSchema.table('all_numerics', {
-				columnAll: numeric('column_all', { precision: 1, scale: 1 }).default('32').notNull(),
-				column: numeric('column'),
-				columnPrimary: numeric('column_primary').primaryKey().notNull(),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema1, [], false, [
-			'public',
-			'schemass',
-		]);
-		expect(statements.length).toBe(0);
-	},
-
-	async addBasicIndexes() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			}),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index()
-						.on(t.name.desc(), t.id.asc().nullsLast())
-						.with({ fillfactor: 70 })
-						.where(sql`select 1`),
-					indx1: index('indx1')
-						.using('hash', t.name.desc(), sql`${t.name}`)
-						.with({ fillfactor: 70 }),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-		expect(statements.length).toBe(2);
-		expect(statements[0]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'create_index_pg',
-			data: {
-				columns: [
-					{
-						asc: false,
-						expression: 'name',
-						isExpression: false,
-						nulls: 'last',
-						opclass: undefined,
-					},
-					{
-						asc: true,
-						expression: 'id',
-						isExpression: false,
-						nulls: 'last',
-						opclass: undefined,
-					},
-				],
-				concurrently: false,
-				isUnique: false,
-				method: 'btree',
-				name: 'users_name_id_index',
-				where: 'select 1',
-				with: {
-					fillfactor: 70,
-				},
-			},
-		});
-		expect(statements[1]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'create_index_pg',
-			data: {
-				columns: [
-					{
-						asc: false,
-						expression: 'name',
-						isExpression: false,
-						nulls: 'last',
-						opclass: undefined,
-					},
-					{
-						asc: true,
-						expression: '"name"',
-						isExpression: true,
-						nulls: 'last',
-					},
-				],
-				concurrently: false,
-				isUnique: false,
-				method: 'hash',
-				name: 'indx1',
-				where: undefined,
-				with: {
-					fillfactor: 70,
-				},
-			},
-		});
-		expect(sqlStatements.length).toBe(2);
-		expect(sqlStatements[0]).toBe(
-			`CREATE INDEX "users_name_id_index" ON "users" USING btree ("name" DESC NULLS LAST,"id") WITH (fillfactor=70) WHERE select 1;`,
-		);
-		expect(sqlStatements[1]).toBe(
-			`CREATE INDEX "indx1" ON "users" USING hash ("name" DESC NULLS LAST,"name") WITH (fillfactor=70);`,
-		);
-	},
-
-	async addGeneratedColumn() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-			}),
-		};
-		const schema2 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements).toStrictEqual([
-			{
-				column: {
-					generated: {
-						as: '"users"."name"',
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_add_column',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name") STORED;',
-		]);
-
-		// for (const st of sqlStatements) {
-		//   await client.query(st);
-		// }
-	},
-
-	async addGeneratedToColumn() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name'),
-			}),
-		};
-		const schema2 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name}`),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements).toStrictEqual([
-			{
-				columnAutoIncrement: undefined,
-				columnDefault: undefined,
-				columnGenerated: {
-					as: '"users"."name"',
-					type: 'stored',
-				},
-				columnName: 'gen_name',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_set_generated',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'ALTER TABLE "users" drop column "gen_name";',
-			'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name") STORED;',
-		]);
-
-		// for (const st of sqlStatements) {
-		//   await client.query(st);
-		// }
-	},
-
-	async dropGeneratedConstraint() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
-			}),
-		};
-		const schema2 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name'),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements).toStrictEqual([
-			{
-				columnAutoIncrement: undefined,
-				columnDefault: undefined,
-				columnGenerated: undefined,
-				columnName: 'gen_name',
-				columnNotNull: false,
-				columnOnUpdate: undefined,
-				columnPk: false,
-				newDataType: 'text',
-				schema: '',
-				tableName: 'users',
-				type: 'alter_table_alter_column_drop_generated',
-			},
-		]);
-		expect(sqlStatements).toStrictEqual(['ALTER TABLE "users" ALTER COLUMN "gen_name" DROP EXPRESSION;']);
-	},
-
-	async alterGeneratedConstraint() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema1.users.name}`),
-			}),
-		};
-		const schema2 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements).toStrictEqual([]);
-		expect(sqlStatements).toStrictEqual([]);
-	},
-
-	async createTableWithGeneratedConstraint() {
-		const client = new PGlite();
-
-		const schema1 = {};
-		const schema2 = {
-			users: pgTable('users', {
-				id: integer('id'),
-				id2: integer('id2'),
-				name: text('name'),
-				generatedName: text('gen_name').generatedAlwaysAs((): SQL => sql`${schema2.users.name} || 'hello'`),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements).toStrictEqual([
-			{
-				columns: [
-					{
-						name: 'id',
-						notNull: false,
-						primaryKey: false,
-						type: 'integer',
-					},
-					{
-						name: 'id2',
-						notNull: false,
-						primaryKey: false,
-						type: 'integer',
-					},
-					{
-						name: 'name',
-						notNull: false,
-						primaryKey: false,
-						type: 'text',
-					},
-					{
-						generated: {
-							as: '"users"."name" || \'hello\'',
-							type: 'stored',
-						},
-						name: 'gen_name',
-						notNull: false,
-						primaryKey: false,
-						type: 'text',
-					},
-				],
-				compositePKs: [],
-				compositePkName: '',
-				isRLSEnabled: false,
-				schema: '',
-				tableName: 'users',
-				policies: [],
-				type: 'create_table',
-				uniqueConstraints: [],
-				checkConstraints: [],
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'CREATE TABLE "users" (\n\t"id" integer,\n\t"id2" integer,\n\t"name" text,\n\t"gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
-		]);
-	},
-
-	async addBasicSequences() {
-		const client = new PGlite();
-
-		const schema1 = {
-			seq: pgSequence('my_seq', { startWith: 100 }),
-		};
-
-		const schema2 = {
-			seq: pgSequence('my_seq', { startWith: 100 }),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-		expect(statements.length).toBe(0);
-	},
-
-	async changeIndexFields() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					removeColumn: index('removeColumn').on(t.name, t.id),
-					addColumn: index('addColumn').on(t.name.desc()).with({ fillfactor: 70 }),
-					removeExpression: index('removeExpression')
-						.on(t.name.desc(), sql`name`)
-						.concurrently(),
-					addExpression: index('addExpression').on(t.id.desc()),
-					changeExpression: index('changeExpression').on(t.id.desc(), sql`name`),
-					changeName: index('changeName').on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
-					changeWith: index('changeWith').on(t.name).with({ fillfactor: 70 }),
-					changeUsing: index('changeUsing').on(t.name),
-				}),
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					removeColumn: index('removeColumn').on(t.name),
-					addColumn: index('addColumn').on(t.name.desc(), t.id.nullsLast()).with({ fillfactor: 70 }),
-					removeExpression: index('removeExpression').on(t.name.desc()).concurrently(),
-					addExpression: index('addExpression').on(t.id.desc()),
-					changeExpression: index('changeExpression').on(t.id.desc(), sql`name desc`),
-					changeName: index('newName')
-						.on(t.name.desc(), sql`name`)
-						.with({ fillfactor: 70 }),
-					changeWith: index('changeWith').on(t.name).with({ fillfactor: 90 }),
-					changeUsing: index('changeUsing').using('hash', t.name),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(sqlStatements).toStrictEqual([
-			'DROP INDEX "changeName";',
-			'DROP INDEX "addColumn";',
-			'DROP INDEX "changeExpression";',
-			'DROP INDEX "changeUsing";',
-			'DROP INDEX "changeWith";',
-			'DROP INDEX "removeColumn";',
-			'DROP INDEX "removeExpression";',
-			'CREATE INDEX "newName" ON "users" USING btree ("name" DESC NULLS LAST,name) WITH (fillfactor=70);',
-			'CREATE INDEX "addColumn" ON "users" USING btree ("name" DESC NULLS LAST,"id") WITH (fillfactor=70);',
-			'CREATE INDEX "changeExpression" ON "users" USING btree ("id" DESC NULLS LAST,name desc);',
-			'CREATE INDEX "changeUsing" ON "users" USING hash ("name");',
-			'CREATE INDEX "changeWith" ON "users" USING btree ("name") WITH (fillfactor=90);',
-			'CREATE INDEX "removeColumn" ON "users" USING btree ("name");',
-			'CREATE INDEX CONCURRENTLY "removeExpression" ON "users" USING btree ("name" DESC NULLS LAST);',
-		]);
-	},
-
-	async dropIndex() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index().on(t.name.desc(), t.id.asc().nullsLast()).with({ fillfactor: 70 }),
-				}),
-			),
-		};
-
-		const schema2 = {
-			users: pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			}),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements.length).toBe(1);
-		expect(statements[0]).toStrictEqual({
-			schema: '',
-			tableName: 'users',
-			type: 'drop_index',
-			data: 'users_name_id_index;name--false--last,,id--true--last;false;btree;{"fillfactor":"70"}',
-		});
-
-		expect(sqlStatements.length).toBe(1);
-		expect(sqlStatements[0]).toBe(`DROP INDEX "users_name_id_index";`);
-	},
-
-	async indexesToBeNotTriggered() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index('indx').on(t.name.desc()).concurrently(),
-					indx1: index('indx1')
-						.on(t.name.desc())
-						.where(sql`true`),
-					indx2: index('indx2')
-						.on(t.name.op('text_ops'))
-						.where(sql`true`),
-					indx3: index('indx3')
-						.on(sql`lower(name)`)
-						.where(sql`true`),
-				}),
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: serial('id').primaryKey(),
-					name: text('name'),
-				},
-				(t) => ({
-					indx: index('indx').on(t.name.desc()),
-					indx1: index('indx1')
-						.on(t.name.desc())
-						.where(sql`false`),
-					indx2: index('indx2')
-						.on(t.name.op('test'))
-						.where(sql`true`),
-					indx3: index('indx3')
-						.on(sql`lower(id)`)
-						.where(sql`true`),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements.length).toBe(0);
-	},
-
-	async indexesTestCase1() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable(
-				'users',
-				{
-					id: uuid('id').defaultRandom().primaryKey(),
-					name: text('name').notNull(),
-					description: text('description'),
-					imageUrl: text('image_url'),
-					inStock: boolean('in_stock').default(true),
-				},
-				(t) => ({
-					indx: index().on(t.id.desc().nullsFirst()),
-					indx1: index('indx1').on(t.id, t.imageUrl),
-					indx2: index('indx4').on(t.id),
-				}),
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'users',
-				{
-					id: uuid('id').defaultRandom().primaryKey(),
-					name: text('name').notNull(),
-					description: text('description'),
-					imageUrl: text('image_url'),
-					inStock: boolean('in_stock').default(true),
-				},
-				(t) => ({
-					indx: index().on(t.id.desc().nullsFirst()),
-					indx1: index('indx1').on(t.id, t.imageUrl),
-					indx2: index('indx4').on(t.id),
-				}),
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-		expect(statements.length).toBe(0);
-	},
-
-	async addNotNull() {
-		const client = new PGlite();
-
-		const schema1 = {
-			users: pgTable(
-				'User',
-				{
-					id: text('id').primaryKey().notNull(),
-					name: text('name'),
-					username: text('username'),
-					gh_username: text('gh_username'),
-					email: text('email'),
-					emailVerified: timestamp('emailVerified', {
-						precision: 3,
-						mode: 'date',
-					}),
-					image: text('image'),
-					createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
-						.default(sql`CURRENT_TIMESTAMP`)
-						.notNull(),
-					updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
-						.notNull()
-						.$onUpdate(() => new Date()),
-				},
-				(table) => {
-					return {
-						emailKey: uniqueIndex('User_email_key').on(table.email),
-					};
-				},
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'User',
-				{
-					id: text('id').primaryKey().notNull(),
-					name: text('name'),
-					username: text('username'),
-					gh_username: text('gh_username'),
-					email: text('email').notNull(),
-					emailVerified: timestamp('emailVerified', {
-						precision: 3,
-						mode: 'date',
-					}),
-					image: text('image'),
-					createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
-						.default(sql`CURRENT_TIMESTAMP`)
-						.notNull(),
-					updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
-						.notNull()
-						.$onUpdate(() => new Date()),
-				},
-				(table) => {
-					return {
-						emailKey: uniqueIndex('User_email_key').on(table.email),
-					};
-				},
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-		const query = async (sql: string, params?: any[]) => {
-			const result = await client.query(sql, params ?? []);
-			return result.rows as any[];
-		};
-
-		const { statementsToExecute } = await pgSuggestions({ query }, statements);
-
-		expect(statementsToExecute).toStrictEqual(['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;']);
-	},
-
-	async addNotNullWithDataNoRollback() {
-		const client = new PGlite();
-		const db = drizzle(client);
-
-		const schema1 = {
-			users: pgTable(
-				'User',
-				{
-					id: text('id').primaryKey().notNull(),
-					name: text('name'),
-					username: text('username'),
-					gh_username: text('gh_username'),
-					email: text('email'),
-					emailVerified: timestamp('emailVerified', {
-						precision: 3,
-						mode: 'date',
-					}),
-					image: text('image'),
-					createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
-						.default(sql`CURRENT_TIMESTAMP`)
-						.notNull(),
-					updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
-						.notNull()
-						.$onUpdate(() => new Date()),
-				},
-				(table) => {
-					return {
-						emailKey: uniqueIndex('User_email_key').on(table.email),
-					};
-				},
-			),
-		};
-
-		const schema2 = {
-			users: pgTable(
-				'User',
-				{
-					id: text('id').primaryKey().notNull(),
-					name: text('name'),
-					username: text('username'),
-					gh_username: text('gh_username'),
-					email: text('email').notNull(),
-					emailVerified: timestamp('emailVerified', {
-						precision: 3,
-						mode: 'date',
-					}),
-					image: text('image'),
-					createdAt: timestamp('createdAt', { precision: 3, mode: 'date' })
-						.default(sql`CURRENT_TIMESTAMP`)
-						.notNull(),
-					updatedAt: timestamp('updatedAt', { precision: 3, mode: 'date' })
-						.notNull()
-						.$onUpdate(() => new Date()),
-				},
-				(table) => {
-					return {
-						emailKey: uniqueIndex('User_email_key').on(table.email),
-					};
-				},
-			),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-		const query = async (sql: string, params?: any[]) => {
-			const result = await client.query(sql, params ?? []);
-			return result.rows as any[];
-		};
-
-		await db.insert(schema1.users).values({ id: 'str', email: 'email@gmail' });
-
-		const { statementsToExecute, shouldAskForApprove } = await pgSuggestions({ query }, statements);
-
-		expect(statementsToExecute).toStrictEqual(['ALTER TABLE "User" ALTER COLUMN "email" SET NOT NULL;']);
-
-		expect(shouldAskForApprove).toBeFalsy();
-	},
-
-	async createCompositePrimaryKey() {
-		const client = new PGlite();
-
-		const schema1 = {};
-
-		const schema2 = {
-			table: pgTable('table', {
-				col1: integer('col1').notNull(),
-				col2: integer('col2').notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.col1, t.col2],
-				}),
-			})),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPush(
-			client,
-			schema1,
-			schema2,
-			[],
-			false,
-			['public'],
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				type: 'create_table',
-				tableName: 'table',
-				schema: '',
-				compositePKs: ['col1,col2;table_col1_col2_pk'],
-				compositePkName: 'table_col1_col2_pk',
-				isRLSEnabled: false,
-				policies: [],
-				uniqueConstraints: [],
-				checkConstraints: [],
-				columns: [
-					{ name: 'col1', type: 'integer', primaryKey: false, notNull: true },
-					{ name: 'col2', type: 'integer', primaryKey: false, notNull: true },
-				],
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'CREATE TABLE "table" (\n\t"col1" integer NOT NULL,\n\t"col2" integer NOT NULL,\n\tCONSTRAINT "table_col1_col2_pk" PRIMARY KEY("col1","col2")\n);\n',
-		]);
-	},
-
-	async renameTableWithCompositePrimaryKey() {
-		const client = new PGlite();
-
-		const productsCategoriesTable = (tableName: string) => {
-			return pgTable(tableName, {
-				productId: text('product_id').notNull(),
-				categoryId: text('category_id').notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.productId, t.categoryId],
-				}),
-			}));
-		};
-
-		const schema1 = {
-			table: productsCategoriesTable('products_categories'),
-		};
-		const schema2 = {
-			test: productsCategoriesTable('products_to_categories'),
-		};
-
-		const { sqlStatements } = await diffTestSchemasPush(
-			client,
-			schema1,
-			schema2,
-			['public.products_categories->public.products_to_categories'],
-			false,
-			['public'],
-		);
-		expect(sqlStatements).toStrictEqual([
-			'ALTER TABLE "products_categories" RENAME TO "products_to_categories";',
-			'ALTER TABLE "products_to_categories" DROP CONSTRAINT "products_categories_product_id_category_id_pk";',
-			'ALTER TABLE "products_to_categories" ADD CONSTRAINT "products_to_categories_product_id_category_id_pk" PRIMARY KEY("product_id","category_id");',
-		]);
-	},
-
-	// async addVectorIndexes() {
-	//   const client = new PGlite();
-
-	//   const schema1 = {
-	//     users: pgTable("users", {
-	//       id: serial("id").primaryKey(),
-	//       name: vector("name", { dimensions: 3 }),
-	//     }),
-	//   };
-
-	//   const schema2 = {
-	//     users: pgTable(
-	//       "users",
-	//       {
-	//         id: serial("id").primaryKey(),
-	//         embedding: vector("name", { dimensions: 3 }),
-	//       },
-	//       (t) => ({
-	//         indx2: index("vector_embedding_idx")
-	//           .using("hnsw", t.embedding.op("vector_ip_ops"))
-	//           .with({ m: 16, ef_construction: 64 }),
-	//       })
-	//     ),
-	//   };
-
-	//   const { statements, sqlStatements } = await diffTestSchemasPush(
-	//     client,
-	//     schema1,
-	//     schema2,
-	//     [],
-	//     false,
-	//     ["public"]
-	//   );
-	//   expect(statements.length).toBe(1);
-	//   expect(statements[0]).toStrictEqual({
-	//     schema: "",
-	//     tableName: "users",
-	//     type: "create_index",
-	//     data: 'vector_embedding_idx;name,true,last,vector_ip_ops;false;false;hnsw;undefined;{"m":16,"ef_construction":64}',
-	//   });
-	//   expect(sqlStatements.length).toBe(1);
-	//   expect(sqlStatements[0]).toBe(
-	//     `CREATE INDEX IF NOT EXISTS "vector_embedding_idx" ON "users" USING hnsw (name vector_ip_ops) WITH (m=16,ef_construction=64);`
-	//   );
-	// },
-	async case1() {
-		// TODO: implement if needed
-		expect(true).toBe(true);
-	},
-};
-
-run(pgSuite);
-
-test('full sequence: no changes', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const schema2 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('basic sequence: change fields', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const schema2 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 100000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 4,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'alter_sequence',
-			schema: 'public',
-			name: 'my_seq',
-			values: {
-				minValue: '100',
-				maxValue: '100000',
-				increment: '4',
-				startWith: '100',
-				cache: '10',
-				cycle: true,
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "public"."my_seq" INCREMENT BY 4 MINVALUE 100 MAXVALUE 100000 START WITH 100 CACHE 10 CYCLE;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('basic sequence: change name', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const schema2 = {
-		seq: pgSequence('my_seq2', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		['public.my_seq->public.my_seq2'],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			nameFrom: 'my_seq',
-			nameTo: 'my_seq2',
-			schema: 'public',
-			type: 'rename_sequence',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['ALTER SEQUENCE "public"."my_seq" RENAME TO "my_seq2";']);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('basic sequence: change name and fields', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		seq: pgSequence('my_seq', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 2,
-		}),
-	};
-
-	const schema2 = {
-		seq: pgSequence('my_seq2', {
-			startWith: 100,
-			maxValue: 10000,
-			minValue: 100,
-			cycle: true,
-			cache: 10,
-			increment: 4,
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		['public.my_seq->public.my_seq2'],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			nameFrom: 'my_seq',
-			nameTo: 'my_seq2',
-			schema: 'public',
-			type: 'rename_sequence',
-		},
-		{
-			name: 'my_seq2',
-			schema: 'public',
-			type: 'alter_sequence',
-			values: {
-				cache: '10',
-				cycle: true,
-				increment: '4',
-				maxValue: '10000',
-				minValue: '100',
-				startWith: '100',
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER SEQUENCE "public"."my_seq" RENAME TO "my_seq2";',
-		'ALTER SEQUENCE "public"."my_seq2" INCREMENT BY 4 MINVALUE 100 MAXVALUE 10000 START WITH 100 CACHE 10 CYCLE;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-// identity push tests
-test('create table: identity always/by default - no params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity(),
-			id2: smallint('id2').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'users_id_seq;byDefault;1;2147483647;1;1;1;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					identity: 'users_id1_seq;byDefault;1;9223372036854775807;1;1;1;false',
-					name: 'id1',
-					notNull: true,
-					primaryKey: false,
-					type: 'bigint',
-				},
-				{
-					identity: 'users_id2_seq;byDefault;1;32767;1;1;1;false',
-					name: 'id2',
-					notNull: true,
-					primaryKey: false,
-					type: 'smallint',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			schema: '',
-			tableName: 'users',
-			policies: [],
-			type: 'create_table',
-			uniqueConstraints: [],
-			isRLSEnabled: false,
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 9223372036854775807 START WITH 1 CACHE 1),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1)\n);\n',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create table: identity always/by default - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ increment: 4 }),
-			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
-				startWith: 120,
-				maxValue: 17000,
-			}),
-			id2: smallint('id2').generatedByDefaultAsIdentity({ cycle: true }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'users_id_seq;byDefault;1;2147483647;4;1;1;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					identity: 'users_id1_seq;byDefault;1;17000;1;120;1;false',
-					name: 'id1',
-					notNull: true,
-					primaryKey: false,
-					type: 'bigint',
-				},
-				{
-					identity: 'users_id2_seq;byDefault;1;32767;1;1;1;true',
-					name: 'id2',
-					notNull: true,
-					primaryKey: false,
-					type: 'smallint',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			policies: [],
-			schema: '',
-			tableName: 'users',
-			type: 'create_table',
-			isRLSEnabled: false,
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 1),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1 CYCLE)\n);\n',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create table: identity always/by default - all params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				increment: 4,
-				minValue: 100,
-			}),
-			id1: bigint('id1', { mode: 'number' }).generatedByDefaultAsIdentity({
-				startWith: 120,
-				maxValue: 17000,
-				increment: 3,
-				cycle: true,
-				cache: 100,
-			}),
-			id2: smallint('id2').generatedByDefaultAsIdentity({ cycle: true }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					identity: 'users_id_seq;byDefault;100;2147483647;4;100;1;false',
-					name: 'id',
-					notNull: true,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					identity: 'users_id1_seq;byDefault;1;17000;3;120;100;true',
-					name: 'id1',
-					notNull: true,
-					primaryKey: false,
-					type: 'bigint',
-				},
-				{
-					identity: 'users_id2_seq;byDefault;1;32767;1;1;1;true',
-					name: 'id2',
-					notNull: true,
-					primaryKey: false,
-					type: 'smallint',
-				},
-			],
-			compositePKs: [],
-			compositePkName: '',
-			schema: '',
-			tableName: 'users',
-			type: 'create_table',
-			policies: [],
-			isRLSEnabled: false,
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users" (\n\t"id" integer GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 4 MINVALUE 100 MAXVALUE 2147483647 START WITH 100 CACHE 1),\n\t"id1" bigint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id1_seq" INCREMENT BY 3 MINVALUE 1 MAXVALUE 17000 START WITH 120 CACHE 100 CYCLE),\n\t"id2" smallint GENERATED BY DEFAULT AS IDENTITY (sequence name "users_id2_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 32767 START WITH 1 CACHE 1 CYCLE)\n);\n',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('no diff: identity always/by default - no params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-			id2: integer('id2').generatedAlwaysAsIdentity(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-			id2: integer('id2').generatedAlwaysAsIdentity(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('no diff: identity always/by default - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_name',
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				increment: 1,
-				startWith: 3,
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_name',
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				increment: 1,
-				startWith: 3,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('no diff: identity always/by default - all params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_name',
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				name: 'custom_name',
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('drop identity from a column - no params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop identity from a column - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ name: 'custom_name' }),
-			id1: integer('id1').generatedByDefaultAsIdentity({
-				name: 'custom_name1',
-				increment: 4,
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				name: 'custom_name2',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id1: integer('id1'),
-			id2: integer('id2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-		{
-			columnName: 'id1',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-		{
-			columnName: 'id2',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
-		'ALTER TABLE "users" ALTER COLUMN "id1" DROP IDENTITY;',
-		'ALTER TABLE "users" ALTER COLUMN "id2" DROP IDENTITY;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop identity from a column - all params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-			id1: integer('id1').generatedByDefaultAsIdentity({
-				name: 'custom_name1',
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-			id2: integer('id2').generatedAlwaysAsIdentity({
-				name: 'custom_name2',
-				startWith: 10,
-				minValue: 10,
-				maxValue: 1000,
-				cycle: true,
-				cache: 10,
-				increment: 2,
-			}),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id1: integer('id1'),
-			id2: integer('id2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-		{
-			columnName: 'id1',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-		{
-			columnName: 'id2',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`ALTER TABLE \"users\" ALTER COLUMN \"id\" DROP IDENTITY;`,
-		'ALTER TABLE "users" ALTER COLUMN "id1" DROP IDENTITY;',
-		'ALTER TABLE "users" ALTER COLUMN "id2" DROP IDENTITY;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter identity from a column - no params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;2147483647;1;100;1;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['ALTER TABLE "users" ALTER COLUMN "id" SET START WITH 100;']);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter identity from a column - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				increment: 4,
-				maxValue: 10000,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;10000;4;100;1;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;100;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET MAXVALUE 10000;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET INCREMENT BY 4;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter identity from a column - by default to always', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity({
-				startWith: 100,
-				increment: 4,
-				maxValue: 10000,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;always;1;10000;4;100;1;false',
-			oldIdentity: 'users_id_seq;byDefault;1;2147483647;1;100;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED ALWAYS;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET MAXVALUE 10000;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET INCREMENT BY 4;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter identity from a column - always to by default', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').generatedAlwaysAsIdentity({ startWith: 100 }),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({
-				startWith: 100,
-				increment: 4,
-				maxValue: 10000,
-				cycle: true,
-				cache: 100,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'users_id_seq;byDefault;1;10000;4;100;100;true',
-			oldIdentity: 'users_id_seq;always;1;2147483647;1;100;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_change_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET MAXVALUE 10000;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET INCREMENT BY 4;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET CACHE 100;',
-		'ALTER TABLE "users" ALTER COLUMN "id" SET CYCLE;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('add column with identity - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			email: text('email'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			email: text('email'),
-			id: integer('id').generatedByDefaultAsIdentity({ name: 'custom_name' }),
-			id1: integer('id1').generatedAlwaysAsIdentity({
-				name: 'custom_name1',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				identity: 'custom_name;byDefault;1;2147483647;1;1;1;false',
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'integer',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-		{
-			column: {
-				identity: 'custom_name1;always;1;2147483647;4;1;1;false',
-				name: 'id1',
-				notNull: true,
-				primaryKey: false,
-				type: 'integer',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ADD COLUMN "id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
-		'ALTER TABLE "users" ADD COLUMN "id1" integer NOT NULL GENERATED ALWAYS AS IDENTITY (sequence name "custom_name1" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
-	]);
-
-	// for (const st of sqlStatements) {
-	//   await client.query(st);
-	// }
-});
-
-test('add identity to column - few params', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id'),
-			id1: integer('id1'),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').generatedByDefaultAsIdentity({ name: 'custom_name' }),
-			id1: integer('id1').generatedAlwaysAsIdentity({
-				name: 'custom_name1',
-				increment: 4,
-			}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			columnName: 'id',
-			identity: 'custom_name;byDefault;1;2147483647;1;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_identity',
-		},
-		{
-			columnName: 'id1',
-			identity: 'custom_name1;always;1;2147483647;4;1;1;false',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_identity',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ALTER COLUMN "id" ADD GENERATED BY DEFAULT AS IDENTITY (sequence name "custom_name" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
-		'ALTER TABLE "users" ALTER COLUMN "id1" ADD GENERATED ALWAYS AS IDENTITY (sequence name "custom_name1" INCREMENT BY 4 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1);',
-	]);
-
-	// for (const st of sqlStatements) {
-	//   await client.query(st);
-	// }
-});
-
-test('add array column - empty array default', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const schema2 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([]),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'alter_table_add_column',
-			tableName: 'test',
-			schema: '',
-			column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{}'" },
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{}\';']);
-});
-
-test('add array column - default', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-	const schema2 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([1, 2, 3]),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'alter_table_add_column',
-			tableName: 'test',
-			schema: '',
-			column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{1,2,3}'" },
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{1,2,3}\';']);
-});
-
-test('create view', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select distinct "id" from "test"',
-			name: 'view',
-			schema: 'public',
-			type: 'create_view',
-			with: undefined,
-			materialized: false,
-			tablespace: undefined,
-			using: undefined,
-			withNoData: false,
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['CREATE VIEW "public"."view" AS (select distinct "id" from "test");']);
-});
-
-test('add check constraint to table', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([1, 2, 3]),
-		}),
-	};
-	const schema2 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').array().default([1, 2, 3]),
-		}, (table) => ({
-			checkConstraint1: check('some_check1', sql`${table.values} < 100`),
-			checkConstraint2: check('some_check2', sql`'test' < 100`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_check_constraint',
-			tableName: 'test',
-			schema: '',
-			data: 'some_check1;"test"."values" < 100',
-		},
-		{
-			data: "some_check2;'test' < 100",
-			schema: '',
-			tableName: 'test',
-			type: 'create_check_constraint',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "test" ADD CONSTRAINT "some_check1" CHECK ("test"."values" < 100);',
-		`ALTER TABLE "test" ADD CONSTRAINT "some_check2" CHECK ('test' < 100);`,
-	]);
-});
-
-test('create materialized view', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgMaterializedView('view')
-			.withNoData()
-			.using('heap')
-			.as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select distinct "id" from "test"',
-			name: 'view',
-			schema: 'public',
-			type: 'create_view',
-			with: undefined,
-			materialized: true,
-			tablespace: undefined,
-			using: 'heap',
-			withNoData: true,
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE MATERIALIZED VIEW "public"."view" USING "heap" AS (select distinct "id" from "test") WITH NO DATA;',
-	]);
-});
-
-test('drop check constraint', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').default(1),
-		}, (table) => ({
-			checkConstraint: check('some_check', sql`${table.values} < 100`),
-		})),
-	};
-	const schema2 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').default(1),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'delete_check_constraint',
-			tableName: 'test',
-			schema: '',
-			constraintName: 'some_check',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "test" DROP CONSTRAINT "some_check";',
-	]);
-});
-
-test('Column with same name as enum', async () => {
-	const client = new PGlite();
-	const statusEnum = pgEnum('status', ['inactive', 'active', 'banned']);
-
-	const schema1 = {
-		statusEnum,
-		table1: pgTable('table1', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		statusEnum,
-		table1: pgTable('table1', {
-			id: serial('id').primaryKey(),
-			status: statusEnum('status').default('inactive'),
-		}),
-		table2: pgTable('table2', {
-			id: serial('id').primaryKey(),
-			status: statusEnum('status').default('inactive'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_table',
-			tableName: 'table2',
-			schema: '',
-			compositePKs: [],
-			compositePkName: '',
-			isRLSEnabled: false,
-			policies: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-			columns: [
-				{ name: 'id', type: 'serial', primaryKey: true, notNull: true },
-				{
-					name: 'status',
-					type: 'status',
-					typeSchema: 'public',
-					primaryKey: false,
-					notNull: false,
-					default: "'inactive'",
-				},
-			],
-		},
-		{
-			type: 'alter_table_add_column',
-			tableName: 'table1',
-			schema: '',
-			column: {
-				name: 'status',
-				type: 'status',
-				typeSchema: 'public',
-				primaryKey: false,
-				notNull: false,
-				default: "'inactive'",
-			},
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "table2" (\n\t"id" serial PRIMARY KEY NOT NULL,\n\t"status" "status" DEFAULT \'inactive\'\n);\n',
-		'ALTER TABLE "table1" ADD COLUMN "status" "status" DEFAULT \'inactive\';',
-	]);
-});
-
-test('db has checks. Push with same names', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').default(1),
-		}, (table) => ({
-			checkConstraint: check('some_check', sql`${table.values} < 100`),
-		})),
-	};
-	const schema2 = {
-		test: pgTable('test', {
-			id: serial('id').primaryKey(),
-			values: integer('values').default(1),
-		}, (table) => ({
-			checkConstraint: check('some_check', sql`some new value`),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('drop view', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			schema: 'public',
-			type: 'drop_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['DROP VIEW "public"."view";']);
-});
-
-test('drop materialized view', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			schema: 'public',
-			type: 'drop_view',
-			materialized: true,
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['DROP MATERIALIZED VIEW "public"."view";']);
-});
-
-test('push view with same name', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('push materialized view with same name', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table).where(eq(table.id, 1))),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('add with options for materialized view', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgMaterializedView('view')
-			.with({ autovacuumFreezeTableAge: 1, autovacuumEnabled: false })
-			.as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		schema: 'public',
-		type: 'alter_view_add_with_option',
-		with: {
-			autovacuumFreezeTableAge: 1,
-			autovacuumEnabled: false,
-		},
-		materialized: true,
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."view" SET (autovacuum_enabled = false, autovacuum_freeze_table_age = 1);`,
-	);
-});
-
-test('add with options to materialized', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view').as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgMaterializedView('view')
-			.with({ autovacuumVacuumCostDelay: 100, vacuumTruncate: false })
-			.as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		schema: 'public',
-		type: 'alter_view_add_with_option',
-		with: {
-			autovacuumVacuumCostDelay: 100,
-			vacuumTruncate: false,
-		},
-		materialized: true,
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER MATERIALIZED VIEW "public"."view" SET (vacuum_truncate = false, autovacuum_vacuum_cost_delay = 100);`,
-	);
-});
-
-test('add with options to materialized with existing flag', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('test', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view', {}).as(sql`SELECT id FROM "test"`),
-	};
-
-	const schema2 = {
-		test: table,
-		view: pgMaterializedView('view', {}).with({ autovacuumVacuumCostDelay: 100, vacuumTruncate: false }).existing(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(client, schema1, schema2, [], false, ['public']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop mat view with data', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('table', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const seedStatements = [`INSERT INTO "public"."table" ("id") VALUES (1), (2), (3)`];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		schemasToRemove,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-		matViewsToRemove,
-	} = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ after: seedStatements },
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		materialized: true,
-		name: 'view',
-		schema: 'public',
-		type: 'drop_view',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP MATERIALIZED VIEW "public"."view";`);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(`· You're about to delete "${chalk.underline('view')}" materialized view with 3 items`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(schemasToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(matViewsToRemove!.length).toBe(1);
-});
-
-test('drop mat view without data', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('table', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgMaterializedView('view', {}).as(sql`SELECT * FROM ${table}`),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		schemasToRemove,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-		matViewsToRemove,
-	} = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		materialized: true,
-		name: 'view',
-		schema: 'public',
-		type: 'drop_view',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP MATERIALIZED VIEW "public"."view";`);
-	expect(infoToPrint!.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(schemasToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(matViewsToRemove!.length).toBe(0);
-});
-
-test('drop view with data', async () => {
-	const client = new PGlite();
-
-	const table = pgTable('table', {
-		id: serial('id').primaryKey(),
-	});
-	const schema1 = {
-		test: table,
-		view: pgView('view', {}).as(sql`SELECT * FROM ${table}`),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const seedStatements = [`INSERT INTO "public"."table" ("id") VALUES (1), (2), (3)`];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		schemasToRemove,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-		matViewsToRemove,
-	} = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ after: seedStatements },
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		schema: 'public',
-		type: 'drop_view',
-	});
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`DROP VIEW "public"."view";`);
-	expect(infoToPrint!.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(schemasToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(matViewsToRemove!.length).toBe(0);
-});
-
-test('enums ordering', async () => {
-	const enum1 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
-		'custAll',
-		'custAdmin',
-		'custClerk',
-		'custInvoiceManager',
-		'custMgf',
-		'custApprover',
-		'custOrderWriter',
-		'custBuyer',
-	]);
-	const schema1 = {};
-
-	const schema2 = {
-		enum1,
-	};
-
-	const { sqlStatements: createEnum } = await diffTestSchemas(schema1, schema2, []);
-
-	const enum2 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
-		'addedToTop',
-		'custAll',
-		'custAdmin',
-		'custClerk',
-		'custInvoiceManager',
-		'custMgf',
-		'custApprover',
-		'custOrderWriter',
-		'custBuyer',
-	]);
-	const schema3 = {
-		enum2,
-	};
-
-	const { sqlStatements: addedValueSql } = await diffTestSchemas(schema2, schema3, []);
-
-	const enum3 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
-		'addedToTop',
-		'custAll',
-		'custAdmin',
-		'custClerk',
-		'custInvoiceManager',
-		'addedToMiddle',
-		'custMgf',
-		'custApprover',
-		'custOrderWriter',
-		'custBuyer',
-	]);
-	const schema4 = {
-		enum3,
-	};
-
-	const client = new PGlite();
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema3,
-		schema4,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: [...createEnum, ...addedValueSql], runApply: false },
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		before: 'custMgf',
-		name: 'enum_users_customer_and_ship_to_settings_roles',
-		schema: 'public',
-		type: 'alter_type_add_value',
-		value: 'addedToMiddle',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TYPE "public"."enum_users_customer_and_ship_to_settings_roles" ADD VALUE 'addedToMiddle' BEFORE 'custMgf';`,
-	);
-});
-
-test('drop enum values', async () => {
-	const newSchema = pgSchema('mySchema');
-	const enum3 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
-		'addedToTop',
-		'custAll',
-		'custAdmin',
-		'custClerk',
-		'custInvoiceManager',
-		'addedToMiddle',
-		'custMgf',
-		'custApprover',
-		'custOrderWriter',
-		'custBuyer',
-	]);
-	const schema1 = {
-		enum3,
-		table: pgTable('enum_table', {
-			id: enum3(),
-		}),
-		newSchema,
-		table1: newSchema.table('enum_table', {
-			id: enum3(),
-		}),
-	};
-
-	const enum4 = pgEnum('enum_users_customer_and_ship_to_settings_roles', [
-		'addedToTop',
-		'custAll',
-		'custAdmin',
-		'custClerk',
-		'custInvoiceManager',
-		'custApprover',
-		'custOrderWriter',
-		'custBuyer',
-	]);
-	const schema2 = {
-		enum4,
-		table: pgTable('enum_table', {
-			id: enum4(),
-		}),
-		newSchema,
-		table1: newSchema.table('enum_table', {
-			id: enum4(),
-		}),
-	};
-
-	const client = new PGlite();
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public', 'mySchema'],
-		undefined,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'enum_users_customer_and_ship_to_settings_roles',
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-		newValues: [
-			'addedToTop',
-			'custAll',
-			'custAdmin',
-			'custClerk',
-			'custInvoiceManager',
-			'custApprover',
-			'custOrderWriter',
-			'custBuyer',
-		],
-		deletedValues: ['addedToMiddle', 'custMgf'],
-		columnsWithEnum: [{
-			column: 'id',
-			tableSchema: '',
-			table: 'enum_table',
-			columnType: 'enum_users_customer_and_ship_to_settings_roles',
-			default: undefined,
-		}, {
-			column: 'id',
-			tableSchema: 'mySchema',
-			table: 'enum_table',
-			columnType: 'enum_users_customer_and_ship_to_settings_roles',
-			default: undefined,
-		}],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE text;`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`DROP TYPE "public"."enum_users_customer_and_ship_to_settings_roles";`,
-	);
-	expect(sqlStatements[3]).toBe(
-		`CREATE TYPE "public"."enum_users_customer_and_ship_to_settings_roles" AS ENUM('addedToTop', 'custAll', 'custAdmin', 'custClerk', 'custInvoiceManager', 'custApprover', 'custOrderWriter', 'custBuyer');`,
-	);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "enum_table" ALTER COLUMN "id" SET DATA TYPE "public"."enum_users_customer_and_ship_to_settings_roles" USING "id"::"public"."enum_users_customer_and_ship_to_settings_roles";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "mySchema"."enum_table" ALTER COLUMN "id" SET DATA TYPE "public"."enum_users_customer_and_ship_to_settings_roles" USING "id"::"public"."enum_users_customer_and_ship_to_settings_roles";`,
-	);
-});
-
-test('column is enum type with default value. shuffle enum', async () => {
-	const client = new PGlite();
-
-	const enum1 = pgEnum('enum', ['value1', 'value2', 'value3']);
-
-	const from = {
-		enum1,
-		table: pgTable('table', {
-			column: enum1('column').default('value2'),
-		}),
-	};
-
-	const enum2 = pgEnum('enum', ['value1', 'value3', 'value2']);
-	const to = {
-		enum2,
-		table: pgTable('table', {
-			column: enum2('column').default('value2'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		from,
-		to,
-		[],
-		false,
-		['public'],
-		undefined,
-	);
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE text;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::text;`);
-	expect(sqlStatements[2]).toBe(`DROP TYPE "public"."enum";`);
-	expect(sqlStatements[3]).toBe(`CREATE TYPE "public"."enum" AS ENUM('value1', 'value3', 'value2');`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DEFAULT 'value2'::"public"."enum";`,
-	);
-	expect(sqlStatements[5]).toBe(
-		`ALTER TABLE "table" ALTER COLUMN "column" SET DATA TYPE "public"."enum" USING "column"::"public"."enum";`,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnsWithEnum: [
-			{
-				column: 'column',
-				tableSchema: '',
-				table: 'table',
-				default: "'value2'",
-				columnType: 'enum',
-			},
-		],
-		deletedValues: [
-			'value3',
-		],
-		name: 'enum',
-		newValues: [
-			'value1',
-			'value3',
-			'value2',
-		],
-		enumSchema: 'public',
-		type: 'alter_type_drop_value',
-	});
-});
-
-// Policies and Roles push test
-test('full policy: no changes', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('add policy', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{ type: 'enable_rls', tableName: 'users', schema: '' },
-		{
-			type: 'create_policy',
-			tableName: 'users',
-			data: {
-				name: 'test',
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop policy', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{ type: 'disable_rls', tableName: 'users', schema: '' },
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'disable_rls',
-		},
-		{
-			type: 'drop_policy',
-			tableName: 'users',
-			data: {
-				name: 'test',
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
-		'DROP POLICY "test" ON "users" CASCADE;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('add policy without enable rls', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-			newrls: pgPolicy('newRls'),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'create_policy',
-			tableName: 'users',
-			data: {
-				name: 'newRls',
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE POLICY "newRls" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop policy without disable rls', async () => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-			oldRls: pgPolicy('oldRls'),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			type: 'drop_policy',
-			tableName: 'users',
-			data: {
-				name: 'oldRls',
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "oldRls" ON "users" CASCADE;',
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-////
-
-test('alter policy without recreation: changing roles', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', to: 'current_role' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO current_role;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--current_role--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy without recreation: changing using', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', using: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([]);
-	expect(statements).toStrictEqual([]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy without recreation: changing with check', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', withCheck: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([]);
-	expect(statements).toStrictEqual([]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy with recreation: changing as', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy with recreation: changing for', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', for: 'delete' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'DELETE',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy with recreation: changing both "as" and "for"', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive', for: 'insert' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR INSERT TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'INSERT',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter policy with recreation: changing all fields', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', for: 'select', using: sql`true` }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive', to: 'current_role', withCheck: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO current_role;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'SELECT',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['current_role'],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('rename policy', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('newName', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		['public.users.test->public.users.newName'],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newName: 'newName',
-			oldName: 'test',
-			schema: '',
-			tableName: 'users',
-			type: 'rename_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('rename policy in renamed table', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('newName', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[
-			'public.users->public.users2',
-			'public.users2.test->public.users2.newName',
-		],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" RENAME TO "users2";',
-		'ALTER POLICY "test" ON "users2" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			fromSchema: '',
-			tableNameFrom: 'users',
-			tableNameTo: 'users2',
-			toSchema: '',
-			type: 'rename_table',
-		},
-		{
-			newName: 'newName',
-			oldName: 'test',
-			schema: '',
-			tableName: 'users2',
-			type: 'rename_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create table with a policy', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users2" (\n\t"id" integer PRIMARY KEY NOT NULL\n);\n',
-		'ALTER TABLE "users2" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users2" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					name: 'id',
-					notNull: true,
-					primaryKey: true,
-					type: 'integer',
-				},
-			],
-			checkConstraints: [],
-			compositePKs: [],
-			isRLSEnabled: false,
-			compositePkName: '',
-			policies: [
-				'test--PERMISSIVE--ALL--public--undefined',
-			],
-			schema: '',
-			tableName: 'users2',
-			type: 'create_table',
-			uniqueConstraints: [],
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: [
-					'public',
-				],
-				on: undefined,
-			},
-			schema: '',
-			tableName: 'users2',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop table with a policy', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users2" CASCADE;',
-		'DROP TABLE "users2" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			policies: [
-				'test--PERMISSIVE--ALL--public--undefined',
-			],
-			schema: '',
-			tableName: 'users2',
-			type: 'drop_table',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('add policy with multiple "to" roles', async (t) => {
-	const client = new PGlite();
-
-	client.query(`CREATE ROLE manager;`);
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const role = pgRole('manager').existing();
-
-	const schema2 = {
-		role,
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { to: ['current_role', role] }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_role, "manager";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: undefined,
-				to: ['current_role', 'manager'],
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('rename policy that is linked', async (t) => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const { sqlStatements: createUsers } = await diffTestSchemas({}, { users }, []);
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('newName', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		['public.users.test->public.users.newName'],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: createUsers },
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newName: 'newName',
-			oldName: 'test',
-			schema: '',
-			tableName: 'users',
-			type: 'rename_policy',
-		},
-	]);
-});
-
-test('alter policy that is linked', async (t) => {
-	const client = new PGlite();
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const { sqlStatements: createUsers } = await diffTestSchemas({}, { users }, []);
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive', to: 'current_role' }).link(users),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: createUsers },
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO current_role;',
-	]);
-	expect(statements).toStrictEqual([{
-		newData: 'test--PERMISSIVE--ALL--current_role--undefined',
-		oldData: 'test--PERMISSIVE--ALL--public--undefined',
-		schema: '',
-		tableName: 'users',
-		type: 'alter_policy',
-	}]);
-});
-
-test('alter policy that is linked: withCheck', async (t) => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const { sqlStatements: createUsers } = await diffTestSchemas({}, { users }, []);
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`true` }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`false` }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: createUsers },
-	);
-
-	expect(sqlStatements).toStrictEqual([]);
-	expect(statements).toStrictEqual([]);
-});
-
-test('alter policy that is linked: using', async (t) => {
-	const client = new PGlite();
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const { sqlStatements: createUsers } = await diffTestSchemas({}, { users }, []);
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive', using: sql`true` }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive', using: sql`false` }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: createUsers },
-	);
-
-	expect(sqlStatements).toStrictEqual([]);
-	expect(statements).toStrictEqual([]);
-});
-
-test('alter policy that is linked: using', async (t) => {
-	const client = new PGlite();
-
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const { sqlStatements: createUsers } = await diffTestSchemas({}, { users }, []);
-
-	const schema1 = {
-		rls: pgPolicy('test', { for: 'insert' }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { for: 'delete' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		undefined,
-		{ before: createUsers },
-	);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'INSERT',
-				name: 'test',
-				on: undefined,
-				to: [
-					'public',
-				],
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'DELETE',
-				name: 'test',
-				on: undefined,
-				to: [
-					'public',
-				],
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-////
-
-test('create role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create role with properties', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, inherit: false, createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: true,
-				createRole: true,
-				inherit: false,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create role with some properties', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager" WITH CREATEDB NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: true,
-				createRole: false,
-				inherit: false,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('drop role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = { manager: pgRole('manager') };
-
-	const schema2 = {};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['DROP ROLE "manager";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'drop_role',
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('create and drop role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		admin: pgRole('admin'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager', 'admin'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['DROP ROLE "manager";', 'CREATE ROLE "admin";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'drop_role',
-		},
-		{
-			name: 'admin',
-			type: 'create_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('rename role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		admin: pgRole('admin'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		['manager->admin'],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager', 'admin'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" RENAME TO "admin";']);
-	expect(statements).toStrictEqual([
-		{ nameFrom: 'manager', nameTo: 'admin', type: 'rename_role' },
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter all role field', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, createRole: true, inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: true,
-				createRole: true,
-				inherit: false,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter createdb in role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH CREATEDB NOCREATEROLE INHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: true,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter createrole in role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH NOCREATEDB CREATEROLE INHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: false,
-				createRole: true,
-				inherit: true,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
-
-test('alter inherit in role', async (t) => {
-	const client = new PGlite();
-
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPush(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		['public'],
-		undefined,
-		{ roles: { include: ['manager'] } },
-	);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH NOCREATEDB NOCREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: false,
-			},
-		},
-	]);
-
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-});
diff --git a/drizzle-kit/tests/push/singlestore-push.test.ts b/drizzle-kit/tests/push/singlestore-push.test.ts
deleted file mode 100644
index 0bafd5956e..0000000000
--- a/drizzle-kit/tests/push/singlestore-push.test.ts
+++ /dev/null
@@ -1,894 +0,0 @@
-import chalk from 'chalk';
-import Docker from 'dockerode';
-import { getTableConfig, index, int, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import fs from 'fs';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { diffTestSchemasPushSingleStore } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
-
-let client: Connection;
-let singlestoreContainer: Docker.Container;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'ghcr.io/singlestore-labs/singlestoredb-dev:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	singlestoreContainer = await docker.createContainer({
-		Image: image,
-		Env: ['ROOT_PASSWORD=singlestore'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await singlestoreContainer.start();
-	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-	return `singlestore://root:singlestore@localhost:${port}/`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env.MYSQL_CONNECTION_STRING ?? (await createDockerDB());
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await singlestoreContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-
-	await client.query('DROP DATABASE IF EXISTS drizzle;');
-	await client.query('CREATE DATABASE drizzle;');
-	await client.query('USE drizzle;');
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await singlestoreContainer?.stop().catch(console.error);
-});
-
-if (!fs.existsSync('tests/push/singlestore')) {
-	fs.mkdirSync('tests/push/singlestore');
-}
-
-test('db has checks. Push with same names', async () => {
-	const schema1 = {
-		test: singlestoreTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values').default(1),
-		}),
-	};
-	const schema2 = {
-		test: singlestoreTable('test', {
-			id: int('id').primaryKey(),
-			values: int('values').default(1),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-});
-
-// TODO: Unskip this test when views are implemented
-/* test.skip.skip('create view', async () => {
-	const table = singlestoreTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: singlestoreView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select `id` from `test`',
-			name: 'view',
-			type: 'singlestore_create_view',
-			replace: false,
-			sqlSecurity: 'definer',
-			withCheckOption: undefined,
-			algorithm: 'undefined',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE ALGORITHM = undefined
-SQL SECURITY definer
-VIEW \`view\` AS (select \`id\` from \`test\`);`,
-	]);
-
-	await client.query(`DROP TABLE \`test\`;`);
-}); */
-
-// TODO: Unskip this test when views are implemented
-/* test.skip('drop view', async () => {
-	const table = singlestoreTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: singlestoreView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			type: 'drop_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual(['DROP VIEW `view`;']);
-	await client.query(`DROP TABLE \`test\`;`);
-	await client.query(`DROP VIEW \`view\`;`);
-}); */
-
-// TODO: Unskip this test when views are implemented
-/* test.skip('alter view ".as"', async () => {
-	const table = singlestoreTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: singlestoreView('view').as((qb) =>
-			qb
-				.select()
-				.from(table)
-				.where(sql`${table.id} = 1`)
-		),
-	};
-
-	const schema2 = {
-		test: table,
-		view: singlestoreView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-
-	await client.query(`DROP TABLE \`test\`;`);
-	await client.query(`DROP VIEW \`view\`;`);
-}); */
-
-// TODO: Unskip this test when views are implemented
-/* test.skip('alter meta options with distinct in definition', async () => {
-	const table = singlestoreTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: singlestoreView('view')
-			.withCheckOption('cascaded')
-			.sqlSecurity('definer')
-			.algorithm('merge')
-			.as((qb) =>
-				qb
-					.selectDistinct()
-					.from(table)
-					.where(sql`${table.id} = 1`)
-			),
-	};
-
-	const schema2 = {
-		test: table,
-		view: singlestoreView('view')
-			.withCheckOption('cascaded')
-			.sqlSecurity('definer')
-			.algorithm('undefined')
-			.as((qb) => qb.selectDistinct().from(table)),
-	};
-
-	await expect(
-		diffTestSchemasPushSingleStore(
-			client,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		),
-	).rejects.toThrowError();
-
-	await client.query(`DROP TABLE \`test\`;`);
-}); */
-
-test('added column not null and without default to table with data', async (t) => {
-	const schema1 = {
-		companies: singlestoreTable('companies', {
-			id: int('id'),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		companies: singlestoreTable('companies', {
-			id: int('id'),
-			name: text('name'),
-			age: int('age').notNull(),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` (\`${schema1.companies.name.name}\`) VALUES ('drizzle');`,
-		`INSERT INTO \`${table.name}\` (\`${schema1.companies.name.name}\`) VALUES ('turso');`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-		{
-			after: seedStatements,
-		},
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'int',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		schema: '',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`truncate table companies;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` int NOT NULL;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to add not-null ${
-			chalk.underline(
-				'age',
-			)
-		} column without default value, which contains 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe('companies');
-
-	await client.query(`DROP TABLE \`companies\`;`);
-});
-
-test('added column not null and without default to table without data', async (t) => {
-	const schema1 = {
-		companies: singlestoreTable('companies', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		companies: singlestoreTable('companies', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-			age: int('age').notNull(),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'int',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		schema: '',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` int NOT NULL;`,
-	);
-
-	expect(infoToPrint!.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-
-	await client.query(`DROP TABLE \`companies\`;`);
-});
-
-test('drop not null, add not null', async (t) => {
-	const schema1 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-		posts: singlestoreTable(
-			'posts',
-			{
-				id: int('id').primaryKey(),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const schema2 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name'),
-		}),
-		posts: singlestoreTable(
-			'posts',
-			{
-				id: int('id').primaryKey(),
-				name: text('name').notNull(),
-				userId: int('user_id'),
-			},
-		),
-	};
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-	);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'int',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'user_id',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'int',
-			},
-		],
-		compositePKs: [
-			'posts_id;id',
-		],
-		tableName: 'posts',
-		type: 'singlestore_recreate_table',
-		uniqueConstraints: [],
-	});
-	expect(statements![1]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'int',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [
-			'users_id;id',
-		],
-		tableName: 'users',
-		type: 'singlestore_recreate_table',
-		uniqueConstraints: [],
-	});
-	expect(sqlStatements!.length).toBe(8);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_posts\` (
-\t\`id\` int NOT NULL,
-\t\`name\` text NOT NULL,
-\t\`user_id\` int,
-\tCONSTRAINT \`posts_id\` PRIMARY KEY(\`id\`)
-);\n`);
-	expect(sqlStatements![1]).toBe(
-		`INSERT INTO \`__new_posts\`(\`id\`, \`name\`, \`user_id\`) SELECT \`id\`, \`name\`, \`user_id\` FROM \`posts\`;`,
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`posts\`;`);
-	expect(sqlStatements![3]).toBe(`ALTER TABLE \`__new_posts\` RENAME TO \`posts\`;`);
-	expect(sqlStatements![4]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` int NOT NULL,
-\t\`name\` text,
-\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
-);\n`);
-	expect(sqlStatements![5]).toBe(
-		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
-	);
-	expect(sqlStatements![6]).toBe(
-		`DROP TABLE \`users\`;`,
-	);
-	expect(sqlStatements![7]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-
-	await client.query(`DROP TABLE \`users\`;`);
-	await client.query(`DROP TABLE \`posts\`;`);
-});
-
-test('drop table with data', async (t) => {
-	const schema1 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-		posts: singlestoreTable(
-			'posts',
-			{
-				id: int('id').primaryKey(),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const schema2 = {
-		posts: singlestoreTable(
-			'posts',
-			{
-				id: int('id').primaryKey(),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-		),
-	};
-
-	const seedStatements = [
-		`INSERT INTO \`users\` (\`id\`, \`name\`) VALUES (1, 'drizzle')`,
-	];
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-		{ after: seedStatements },
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		policies: [],
-		schema: undefined,
-		tableName: 'users',
-		type: 'drop_table',
-	});
-
-	expect(sqlStatements!.length).toBe(1);
-	expect(sqlStatements![0]).toBe(`DROP TABLE \`users\`;`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(`· You're about to delete ${chalk.underline('users')} table with 1 items`);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(1);
-	expect(tablesToRemove![0]).toBe('users');
-	expect(tablesToTruncate!.length).toBe(0);
-
-	await client.query(`DROP TABLE \`users\`;`);
-	await client.query(`DROP TABLE \`posts\`;`);
-});
-
-test('change data type. db has indexes. table does not have values', async (t) => {
-	const schema1 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: int('name').notNull(),
-		}, (table) => [index('index').on(table.name)]),
-	};
-
-	const schema2 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-		}, (table) => [index('index').on(table.name)]),
-	};
-
-	const seedStatements = [`INSERT INTO users VALUES (1, 12)`];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-	);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'int',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [
-			'users_id;id',
-		],
-		tableName: 'users',
-		type: 'singlestore_recreate_table',
-		uniqueConstraints: [],
-	});
-	expect(statements![1]).toStrictEqual({
-		data: 'index;name;false;;;',
-		internal: undefined,
-		schema: '',
-		tableName: 'users',
-		type: 'create_index',
-	});
-
-	expect(sqlStatements!.length).toBe(5);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` int NOT NULL,
-\t\`name\` text NOT NULL,
-\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
-);\n`);
-	expect(sqlStatements![1]).toBe(
-		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements![4]).toBe(`CREATE INDEX \`index\` ON \`users\` (\`name\`);`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-
-	await client.query(`DROP TABLE \`users\`;`);
-});
-
-test('change data type. db has indexes. table has values', async (t) => {
-	const schema1 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: int('name'),
-		}, (table) => [index('index').on(table.name)]),
-	};
-
-	const schema2 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name'),
-		}, (table) => [index('index').on(table.name)]),
-	};
-
-	const seedStatements = [`INSERT INTO users VALUES (1, 12);`, `INSERT INTO users (id) VALUES (2);`];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-		{ after: seedStatements },
-	);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'int',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [
-			'users_id;id',
-		],
-		tableName: 'users',
-		type: 'singlestore_recreate_table',
-		uniqueConstraints: [],
-	});
-	expect(statements![1]).toStrictEqual({
-		data: 'index;name;false;;;',
-		internal: undefined,
-		schema: '',
-		tableName: 'users',
-		type: 'create_index',
-	});
-
-	expect(sqlStatements!.length).toBe(6);
-	expect(sqlStatements![0]).toBe(`TRUNCATE TABLE \`users\`;`);
-	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` int NOT NULL,
-\t\`name\` text,
-\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
-);\n`);
-	expect(sqlStatements![2]).toBe(
-		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
-	);
-	expect(sqlStatements![3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements![5]).toBe(`CREATE INDEX \`index\` ON \`users\` (\`name\`);`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about recreate ${chalk.underline('users')} table with data type changing for ${
-			chalk.underline('name')
-		} column, which contains 1 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe(`users`);
-
-	await client.query(`DROP TABLE \`users\`;`);
-});
-
-test('add column. add default to column without not null', async (t) => {
-	const schema1 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: singlestoreTable('users', {
-			id: int('id').primaryKey(),
-			name: text('name').default('drizzle'),
-			age: int('age'),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSingleStore(
-		client,
-		schema1,
-		schema2,
-		[],
-		'drizzle',
-		false,
-		undefined,
-	);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnName: 'name',
-		columnNotNull: false,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		newDefaultValue: "'drizzle'",
-		schema: '',
-		tableName: 'users',
-		type: 'alter_table_alter_column_set_default',
-	});
-	expect(statements![1]).toStrictEqual({
-		type: 'alter_table_add_column',
-		tableName: 'users',
-		schema: '',
-		column: {
-			notNull: false,
-			primaryKey: false,
-			autoincrement: false,
-			name: 'age',
-			type: 'int',
-		},
-	});
-	expect(sqlStatements!.length).toBe(2);
-	expect(sqlStatements![0]).toBe(`ALTER TABLE \`users\` MODIFY COLUMN \`name\` text DEFAULT 'drizzle';`);
-	expect(sqlStatements![1]).toBe(`ALTER TABLE \`users\` ADD \`age\` int;`);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-
-	await client.query(`DROP TABLE \`users\`;`);
-});
diff --git a/drizzle-kit/tests/push/singlestore.test.ts b/drizzle-kit/tests/push/singlestore.test.ts
deleted file mode 100644
index 6f58e8ddd7..0000000000
--- a/drizzle-kit/tests/push/singlestore.test.ts
+++ /dev/null
@@ -1,444 +0,0 @@
-import Docker from 'dockerode';
-import { SQL, sql } from 'drizzle-orm';
-import {
-	bigint,
-	binary,
-	char,
-	date,
-	decimal,
-	double,
-	float,
-	int,
-	mediumint,
-	primaryKey,
-	singlestoreEnum,
-	singlestoreTable,
-	smallint,
-	text,
-	time,
-	timestamp,
-	tinyint,
-	varbinary,
-	varchar,
-	vector,
-	year,
-} from 'drizzle-orm/singlestore-core';
-import getPort from 'get-port';
-import { Connection, createConnection } from 'mysql2/promise';
-import { diffTestSchemasPushSingleStore, diffTestSchemasSingleStore } from 'tests/schemaDiffer';
-import { v4 as uuid } from 'uuid';
-import { expect } from 'vitest';
-import { DialectSuite, run } from './common';
-
-async function createDockerDB(context: any): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'ghcr.io/singlestore-labs/singlestoredb-dev:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	context.singlestoreContainer = await docker.createContainer({
-		Image: image,
-		Env: ['ROOT_PASSWORD=singlestore'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await context.singlestoreContainer.start();
-	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-	return `singlestore://root:singlestore@localhost:${port}/`;
-}
-
-const singlestoreSuite: DialectSuite = {
-	allTypes: async function(context: any): Promise<void> {
-		const schema1 = {
-			allBigInts: singlestoreTable('all_big_ints', {
-				simple: bigint('simple', { mode: 'number' }),
-				columnNotNull: bigint('column_not_null', { mode: 'number' }).notNull(),
-				columnDefault: bigint('column_default', { mode: 'number' }).default(12),
-				columnDefaultSql: bigint('column_default_sql', {
-					mode: 'number',
-				}).default(12),
-			}),
-			allBools: singlestoreTable('all_bools', {
-				simple: tinyint('simple'),
-				columnNotNull: tinyint('column_not_null').notNull(),
-				columnDefault: tinyint('column_default').default(1),
-			}),
-			allChars: singlestoreTable('all_chars', {
-				simple: char('simple', { length: 1 }),
-				columnNotNull: char('column_not_null', { length: 45 }).notNull(),
-				// columnDefault: char("column_default", { length: 1 }).default("h"),
-				columnDefaultSql: char('column_default_sql', { length: 1 }).default(
-					'h',
-				),
-			}),
-			//   allDateTimes: singlestoreTable("all_date_times", {
-			//     simple: datetime("simple", { mode: "string", fsp: 1 }),
-			//     columnNotNull: datetime("column_not_null", {
-			//       mode: "string",
-			//     }).notNull(),
-			//     columnDefault: datetime("column_default", { mode: "string" }).default(
-			//       "2023-03-01 14:05:29"
-			//     ),
-			//   }),
-			allDates: singlestoreTable('all_dates', {
-				simple: date('simple', { mode: 'string' }),
-				column_not_null: date('column_not_null', { mode: 'string' }).notNull(),
-				column_default: date('column_default', { mode: 'string' }).default(
-					'2023-03-01',
-				),
-			}),
-			allDecimals: singlestoreTable('all_decimals', {
-				simple: decimal('simple', { precision: 1, scale: 0 }),
-				columnNotNull: decimal('column_not_null', {
-					precision: 45,
-					scale: 3,
-				}).notNull(),
-				columnDefault: decimal('column_default', {
-					precision: 10,
-					scale: 0,
-				}).default('100'),
-				columnDefaultSql: decimal('column_default_sql', {
-					precision: 10,
-					scale: 0,
-				}).default('101'),
-			}),
-
-			allDoubles: singlestoreTable('all_doubles', {
-				simple: double('simple'),
-				columnNotNull: double('column_not_null').notNull(),
-				columnDefault: double('column_default').default(100),
-				columnDefaultSql: double('column_default_sql').default(101),
-			}),
-
-			allEnums: singlestoreTable('all_enums', {
-				simple: singlestoreEnum('simple', ['hi', 'hello']),
-			}),
-
-			allEnums1: singlestoreTable('all_enums1', {
-				simple: singlestoreEnum('simple', ['hi', 'hello']).default('hi'),
-			}),
-
-			allFloats: singlestoreTable('all_floats', {
-				columnNotNull: float('column_not_null').notNull(),
-				columnDefault: float('column_default').default(100),
-				columnDefaultSql: float('column_default_sql').default(101),
-			}),
-
-			allInts: singlestoreTable('all_ints', {
-				simple: int('simple'),
-				columnNotNull: int('column_not_null').notNull(),
-				columnDefault: int('column_default').default(100),
-				columnDefaultSql: int('column_default_sql').default(101),
-			}),
-
-			allIntsRef: singlestoreTable('all_ints_ref', {
-				simple: int('simple'),
-				columnNotNull: int('column_not_null').notNull(),
-				columnDefault: int('column_default').default(100),
-				columnDefaultSql: int('column_default_sql').default(101),
-			}),
-
-			//   allJsons: singlestoreTable("all_jsons", {
-			//     columnDefaultObject: json("column_default_object")
-			//       .default({ hello: "world world" })
-			//       .notNull(),
-			//     columnDefaultArray: json("column_default_array").default({
-			//       hello: { "world world": ["foo", "bar"] },
-			//       foo: "bar",
-			//       fe: 23,
-			//     }),
-			//     column: json("column"),
-			//   }),
-
-			allMInts: singlestoreTable('all_m_ints', {
-				simple: mediumint('simple'),
-				columnNotNull: mediumint('column_not_null').notNull(),
-				columnDefault: mediumint('column_default').default(100),
-				columnDefaultSql: mediumint('column_default_sql').default(101),
-			}),
-
-			allReals: singlestoreTable('all_reals', {
-				simple: double('simple', { precision: 5, scale: 2 }),
-				columnNotNull: double('column_not_null').notNull(),
-				columnDefault: double('column_default').default(100),
-				columnDefaultSql: double('column_default_sql').default(101),
-			}),
-
-			allSInts: singlestoreTable('all_s_ints', {
-				simple: smallint('simple'),
-				columnNotNull: smallint('column_not_null').notNull(),
-				columnDefault: smallint('column_default').default(100),
-				columnDefaultSql: smallint('column_default_sql').default(101),
-			}),
-
-			//   allSmallSerials: singlestoreTable("all_small_serials", {
-			//     columnAll: serial("column_all").notNull(),
-			//   }),
-
-			allTInts: singlestoreTable('all_t_ints', {
-				simple: tinyint('simple'),
-				columnNotNull: tinyint('column_not_null').notNull(),
-				columnDefault: tinyint('column_default').default(10),
-				columnDefaultSql: tinyint('column_default_sql').default(11),
-			}),
-
-			allTexts: singlestoreTable('all_texts', {
-				simple: text('simple'),
-				columnNotNull: text('column_not_null').notNull(),
-				columnDefault: text('column_default').default('hello'),
-				columnDefaultSql: text('column_default_sql').default('hello'),
-			}),
-
-			allTimes: singlestoreTable('all_times', {
-				// simple: time("simple", { fsp: 1 }),
-				columnNotNull: time('column_not_null').notNull(),
-				columnDefault: time('column_default').default('22:12:12'),
-			}),
-
-			allTimestamps: singlestoreTable('all_timestamps', {
-				// columnDateNow: timestamp("column_date_now", {
-				//   fsp: 1,
-				//   mode: "string",
-				// }).default(sql`(now())`),
-				columnAll: timestamp('column_all', { mode: 'string' })
-					.default('2023-03-01 14:05:29')
-					.notNull(),
-				column: timestamp('column', { mode: 'string' }).default(
-					'2023-02-28 16:18:31',
-				),
-			}),
-
-			allVarChars: singlestoreTable('all_var_chars', {
-				simple: varchar('simple', { length: 100 }),
-				columnNotNull: varchar('column_not_null', { length: 45 }).notNull(),
-				columnDefault: varchar('column_default', { length: 100 }).default(
-					'hello',
-				),
-				columnDefaultSql: varchar('column_default_sql', {
-					length: 100,
-				}).default('hello'),
-			}),
-
-			allVarbinaries: singlestoreTable('all_varbinaries', {
-				simple: varbinary('simple', { length: 100 }),
-				columnNotNull: varbinary('column_not_null', { length: 100 }).notNull(),
-				columnDefault: varbinary('column_default', { length: 12 }),
-			}),
-
-			allYears: singlestoreTable('all_years', {
-				simple: year('simple'),
-				columnNotNull: year('column_not_null').notNull(),
-				columnDefault: year('column_default').default(2022),
-			}),
-
-			binafry: singlestoreTable('binary', {
-				simple: binary('simple', { length: 1 }),
-				columnNotNull: binary('column_not_null', { length: 1 }).notNull(),
-				columnDefault: binary('column_default', { length: 12 }),
-			}),
-
-			allVectors: singlestoreTable('all_vectors', {
-				vectorSimple: vector('vector_simple', { dimensions: 1 }),
-				vectorElementType: vector('vector_element_type', { dimensions: 1, elementType: 'I8' }),
-				vectorNotNull: vector('vector_not_null', { dimensions: 1 }).notNull(),
-				vectorDefault: vector('vector_default', { dimensions: 1 }).default([1]),
-			}),
-		};
-
-		const { statements } = await diffTestSchemasPushSingleStore(
-			context.client as Connection,
-			schema1,
-			schema1,
-			[],
-			'drizzle',
-			false,
-		);
-		console.log(statements);
-		expect(statements.length).toBe(0);
-		expect(statements).toEqual([]);
-
-		const { sqlStatements: dropStatements } = await diffTestSchemasSingleStore(
-			schema1,
-			{},
-			[],
-			false,
-		);
-
-		for (const st of dropStatements) {
-			await context.client.query(st);
-		}
-	},
-	addBasicIndexes: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	changeIndexFields: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	dropIndex: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	indexesToBeNotTriggered: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	indexesTestCase1: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	async case1() {
-		// TODO: implement if needed
-		expect(true).toBe(true);
-	},
-	addNotNull: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addNotNullWithDataNoRollback: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addBasicSequences: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	addGeneratedColumn: async function(context: any): Promise<void> {
-		return {} as any;
-	},
-	addGeneratedToColumn: async function(context: any): Promise<void> {
-		return {} as any;
-	},
-	dropGeneratedConstraint: async function(context: any): Promise<void> {
-		return {} as any;
-	},
-	alterGeneratedConstraint: async function(context: any): Promise<void> {
-		return {} as any;
-	},
-	createTableWithGeneratedConstraint: function(context?: any): Promise<void> {
-		return {} as any;
-	},
-	createCompositePrimaryKey: async function(context: any): Promise<void> {
-		const schema1 = {};
-
-		const schema2 = {
-			table: singlestoreTable('table', {
-				col1: int('col1').notNull(),
-				col2: int('col2').notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.col1, t.col2],
-				}),
-			})),
-		};
-
-		const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
-			context.client as Connection,
-			schema1,
-			schema2,
-			[],
-			'drizzle',
-			false,
-		);
-
-		expect(statements).toStrictEqual([
-			{
-				type: 'create_table',
-				tableName: 'table',
-				schema: undefined,
-				internals: {
-					indexes: {},
-					tables: {},
-				},
-				compositePKs: ['table_col1_col2_pk;col1,col2'],
-				compositePkName: 'table_col1_col2_pk',
-				uniqueConstraints: [],
-				columns: [
-					{ name: 'col1', type: 'int', primaryKey: false, notNull: true, autoincrement: false },
-					{ name: 'col2', type: 'int', primaryKey: false, notNull: true, autoincrement: false },
-				],
-			},
-		]);
-		expect(sqlStatements).toStrictEqual([
-			'CREATE TABLE `table` (\n\t`col1` int NOT NULL,\n\t`col2` int NOT NULL,\n\tCONSTRAINT `table_col1_col2_pk` PRIMARY KEY(`col1`,`col2`)\n);\n',
-		]);
-	},
-	renameTableWithCompositePrimaryKey: async function(context?: any): Promise<void> {
-		const productsCategoriesTable = (tableName: string) => {
-			return singlestoreTable(tableName, {
-				productId: varchar('product_id', { length: 10 }).notNull(),
-				categoryId: varchar('category_id', { length: 10 }).notNull(),
-			}, (t) => ({
-				pk: primaryKey({
-					columns: [t.productId, t.categoryId],
-				}),
-			}));
-		};
-
-		const schema1 = {
-			table: productsCategoriesTable('products_categories'),
-		};
-		const schema2 = {
-			test: productsCategoriesTable('products_to_categories'),
-		};
-
-		const { sqlStatements } = await diffTestSchemasPushSingleStore(
-			context.client as Connection,
-			schema1,
-			schema2,
-			['public.products_categories->public.products_to_categories'],
-			'drizzle',
-			false,
-		);
-
-		// It's not possible to create/alter/drop primary keys in SingleStore
-		expect(sqlStatements).toStrictEqual([
-			'ALTER TABLE `products_categories` RENAME TO `products_to_categories`;',
-		]);
-
-		await context.client.query(`DROP TABLE \`products_categories\``);
-	},
-};
-
-run(
-	singlestoreSuite,
-	async (context: any) => {
-		const connectionString = process.env.SINGLESTORE_CONNECTION_STRING
-			?? (await createDockerDB(context));
-
-		const sleep = 1000;
-		let timeLeft = 20000;
-		let connected = false;
-		let lastError: unknown | undefined;
-		do {
-			try {
-				context.client = await createConnection(connectionString);
-				await context.client.connect();
-				connected = true;
-				break;
-			} catch (e) {
-				lastError = e;
-				await new Promise((resolve) => setTimeout(resolve, sleep));
-				timeLeft -= sleep;
-			}
-		} while (timeLeft > 0);
-		if (!connected) {
-			console.error('Cannot connect to SingleStore');
-			await context.client?.end().catch(console.error);
-			await context.singlestoreContainer?.stop().catch(console.error);
-			throw lastError;
-		}
-
-		await context.client.query(`DROP DATABASE IF EXISTS \`drizzle\`;`);
-		await context.client.query('CREATE DATABASE drizzle;');
-		await context.client.query('USE drizzle;');
-	},
-	async (context: any) => {
-		await context.client?.end().catch(console.error);
-		await context.singlestoreContainer?.stop().catch(console.error);
-	},
-);
diff --git a/drizzle-kit/tests/push/sqlite.test.ts b/drizzle-kit/tests/push/sqlite.test.ts
deleted file mode 100644
index e2c85233a3..0000000000
--- a/drizzle-kit/tests/push/sqlite.test.ts
+++ /dev/null
@@ -1,1613 +0,0 @@
-import Database from 'better-sqlite3';
-import chalk from 'chalk';
-import { sql } from 'drizzle-orm';
-import {
-	blob,
-	check,
-	foreignKey,
-	getTableConfig,
-	int,
-	integer,
-	numeric,
-	primaryKey,
-	real,
-	sqliteTable,
-	sqliteView,
-	text,
-	uniqueIndex,
-} from 'drizzle-orm/sqlite-core';
-import { diffTestSchemasPushSqlite, introspectSQLiteToFile } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-test('nothing changed in schema', async (t) => {
-	const client = new Database(':memory:');
-
-	const users = sqliteTable('users', {
-		id: integer('id').primaryKey().notNull(),
-		name: text('name').notNull(),
-		email: text('email'),
-		textJson: text('text_json', { mode: 'json' }),
-		blobJon: blob('blob_json', { mode: 'json' }),
-		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
-		numeric: numeric('numeric'),
-		createdAt: integer('created_at', { mode: 'timestamp' }),
-		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
-		real: real('real'),
-		text: text('text', { length: 255 }),
-		role: text('role', { enum: ['admin', 'user'] }).default('user'),
-		isConfirmed: integer('is_confirmed', {
-			mode: 'boolean',
-		}),
-	});
-
-	const schema1 = {
-		users,
-
-		customers: sqliteTable('customers', {
-			id: integer('id').primaryKey(),
-			address: text('address').notNull(),
-			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-			registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-				.notNull()
-				.$defaultFn(() => new Date()),
-			userId: integer('user_id')
-				.references(() => users.id)
-				.notNull(),
-		}),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema1, [], false);
-
-	expect(sqlStatements.length).toBe(0);
-	expect(statements.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-});
-
-test('dropped, added unique index', async (t) => {
-	const client = new Database(':memory:');
-
-	const users = sqliteTable('users', {
-		id: integer('id').primaryKey().notNull(),
-		name: text('name').notNull(),
-		email: text('email'),
-		textJson: text('text_json', { mode: 'json' }),
-		blobJon: blob('blob_json', { mode: 'json' }),
-		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
-		numeric: numeric('numeric'),
-		createdAt: integer('created_at', { mode: 'timestamp' }),
-		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
-		real: real('real'),
-		text: text('text', { length: 255 }),
-		role: text('role', { enum: ['admin', 'user'] }).default('user'),
-		isConfirmed: integer('is_confirmed', {
-			mode: 'boolean',
-		}),
-	});
-
-	const schema1 = {
-		users,
-
-		customers: sqliteTable(
-			'customers',
-			{
-				id: integer('id').primaryKey(),
-				address: text('address').notNull().unique(),
-				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-					.notNull()
-					.$defaultFn(() => new Date()),
-				userId: integer('user_id').notNull(),
-			},
-			(table) => ({
-				uniqueIndex: uniqueIndex('customers_address_unique').on(table.address),
-			}),
-		),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const schema2 = {
-		users,
-
-		customers: sqliteTable(
-			'customers',
-			{
-				id: integer('id').primaryKey(),
-				address: text('address').notNull(),
-				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
-				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
-					.notNull()
-					.$defaultFn(() => new Date()),
-				userId: integer('user_id').notNull(),
-			},
-			(table) => ({
-				uniqueIndex: uniqueIndex('customers_is_confirmed_unique').on(
-					table.isConfirmed,
-				),
-			}),
-		),
-
-		posts: sqliteTable('posts', {
-			id: integer('id').primaryKey(),
-			content: text('content'),
-			authorId: integer('author_id'),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [], false);
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'drop_index',
-		tableName: 'customers',
-		data: 'customers_address_unique;address;true;',
-		schema: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_index',
-		tableName: 'customers',
-		data: 'customers_is_confirmed_unique;is_confirmed;true;',
-		schema: '',
-		internal: {
-			indexes: {},
-		},
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`DROP INDEX \`customers_address_unique\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE UNIQUE INDEX \`customers_is_confirmed_unique\` ON \`customers\` (\`is_confirmed\`);`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('added column not null and without default to table with data', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('drizzle');`,
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('turso');`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'integer',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		referenceData: undefined,
-	});
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`delete from companies;`);
-	expect(sqlStatements[1]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to add not-null ${
-			chalk.underline(
-				'age',
-			)
-		} column without default value, which contains 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe('companies');
-});
-
-test('added column not null and without default to table without data', async (t) => {
-	const turso = new Database(':memory:');
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-		}),
-	};
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(turso, schema1, schema2, [], false);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'companies',
-		column: {
-			name: 'age',
-			type: 'integer',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-		referenceData: undefined,
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
-	);
-
-	expect(infoToPrint!.length).toBe(0);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop autoincrement. drop column with data', async (t) => {
-	const turso = new Database(':memory:');
-
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: false }),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
-	];
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		turso,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		tableName: 'companies',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: true,
-				primaryKey: true,
-				generated: undefined,
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_companies\` (
-\t\`id\` integer PRIMARY KEY NOT NULL
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(1);
-	expect(columnsToRemove![0]).toBe('name');
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to delete ${
-			chalk.underline(
-				'name',
-			)
-		} column in companies table with 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop autoincrement. drop column with data with pragma off', async (t) => {
-	const client = new Database(':memory:');
-
-	client.exec('PRAGMA foreign_keys=OFF;');
-
-	const users = sqliteTable('users', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-	});
-	const schema1 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			user_id: integer('user_id').references(() => users.id),
-		}),
-	};
-
-	const schema2 = {
-		companies: sqliteTable('companies', {
-			id: integer('id').primaryKey({ autoIncrement: false }),
-			user_id: integer('user_id').references(() => users.id),
-		}),
-	};
-
-	const table = getTableConfig(schema1.companies);
-	const seedStatements = [
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
-		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
-	];
-
-	const {
-		sqlStatements,
-		statements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		tableName: 'companies',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: true,
-				primaryKey: true,
-				generated: undefined,
-			},
-			{
-				name: 'user_id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: false,
-				primaryKey: false,
-				generated: undefined,
-			},
-		],
-		compositePKs: [],
-		referenceData: [
-			{
-				columnsFrom: [
-					'user_id',
-				],
-				columnsTo: [
-					'id',
-				],
-				name: '',
-				onDelete: 'no action',
-				onUpdate: 'no action',
-				tableFrom: 'companies',
-				tableTo: 'users',
-			},
-		],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_companies\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`user_id\` integer,
-\tFOREIGN KEY (\`user_id\`) REFERENCES \`users\`(\`id\`) ON UPDATE no action ON DELETE no action
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`INSERT INTO \`__new_companies\`("id", "user_id") SELECT "id", "user_id" FROM \`companies\`;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(1);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to delete ${
-			chalk.underline(
-				'name',
-			)
-		} column in companies table with 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('change autoincrement. other table references current', async (t) => {
-	const client = new Database(':memory:');
-
-	const companies1 = sqliteTable('companies', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-	});
-	const users1 = sqliteTable('users', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-		name: text('name').unique(),
-		companyId: text('company_id').references(() => companies1.id),
-	});
-	const schema1 = {
-		companies: companies1,
-		users: users1,
-	};
-
-	const companies2 = sqliteTable('companies', {
-		id: integer('id').primaryKey({ autoIncrement: false }),
-	});
-	const users2 = sqliteTable('users', {
-		id: integer('id').primaryKey({ autoIncrement: true }),
-		name: text('name').unique(),
-		companyId: text('company_id').references(() => companies1.id),
-	});
-	const schema2 = {
-		companies: companies2,
-		users: users2,
-	};
-
-	const { name: usersTableName } = getTableConfig(users1);
-	const { name: companiesTableName } = getTableConfig(companies1);
-	const seedStatements = [
-		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('drizzle');`,
-		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('turso');`,
-		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('1');`,
-		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('2');`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		tableName: 'companies',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				autoincrement: false,
-				notNull: true,
-				primaryKey: true,
-				generated: undefined,
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(
-		`CREATE TABLE \`__new_companies\` (
-\t\`id\` integer PRIMARY KEY NOT NULL
-);\n`,
-	);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`companies\`;`);
-	expect(sqlStatements[4]).toBe(
-		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
-	);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('create table with custom name references', async (t) => {
-	const client = new Database(':memory:');
-
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name').notNull(),
-	});
-
-	const schema1 = {
-		users,
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-			(t) => ({
-				fk: foreignKey({
-					columns: [t.id],
-					foreignColumns: [users.id],
-					name: 'custom_name_fk',
-				}),
-			}),
-		),
-	};
-
-	const schema2 = {
-		users,
-		posts: sqliteTable(
-			'posts',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-				userId: int('user_id'),
-			},
-			(t) => ({
-				fk: foreignKey({
-					columns: [t.id],
-					foreignColumns: [users.id],
-					name: 'custom_name_fk',
-				}),
-			}),
-		),
-	};
-
-	const { sqlStatements } = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(sqlStatements!.length).toBe(0);
-});
-
-test('drop not null, add not null', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-		posts: sqliteTable('posts', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			userId: int('user_id'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-		posts: sqliteTable('posts', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-			userId: int('user_id'),
-		}),
-	};
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema2, []);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		checkConstraints: [],
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-	});
-	expect(statements![1]).toStrictEqual({
-		checkConstraints: [],
-		columns: [
-			{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: true,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'user_id',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'posts',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(8);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`name\` text
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		`INSERT INTO \`__new_users\`("id", "name") SELECT "id", "name" FROM \`users\`;`,
-	);
-	expect(sqlStatements[2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(sqlStatements![4]).toBe(`CREATE TABLE \`__new_posts\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`name\` text NOT NULL,
-\t\`user_id\` integer
-);\n`);
-	expect(sqlStatements![5]).toBe(
-		`INSERT INTO \`__new_posts\`("id", "name", "user_id") SELECT "id", "name", "user_id" FROM \`posts\`;`,
-	);
-	expect(sqlStatements![6]).toBe(`DROP TABLE \`posts\`;`);
-	expect(sqlStatements![7]).toBe(
-		`ALTER TABLE \`__new_posts\` RENAME TO \`posts\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('rename table and change data type', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('old_users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			age: text('age'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('new_users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			age: integer('age'),
-		}),
-	};
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
-		'public.old_users->public.new_users',
-	]);
-
-	expect(statements!.length).toBe(2);
-	expect(statements![0]).toStrictEqual({
-		fromSchema: undefined,
-		tableNameFrom: 'old_users',
-		tableNameTo: 'new_users',
-		toSchema: undefined,
-		type: 'rename_table',
-	});
-	expect(statements![1]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'new_users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(5);
-	expect(sqlStatements![0]).toBe(
-		`ALTER TABLE \`old_users\` RENAME TO \`new_users\`;`,
-	);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements![2]).toBe(
-		`INSERT INTO \`__new_new_users\`("id", "age") SELECT "id", "age" FROM \`new_users\`;`,
-	);
-	expect(sqlStatements![3]).toBe(`DROP TABLE \`new_users\`;`);
-	expect(sqlStatements![4]).toBe(
-		`ALTER TABLE \`__new_new_users\` RENAME TO \`new_users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('rename column and change data type', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			age: integer('age'),
-		}),
-	};
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
-		'public.users.name->public.users.age',
-	]);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: true,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements![1]).toBe(
-		`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`,
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('recreate table with nested references', async (t) => {
-	const client = new Database(':memory:');
-
-	let users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	let subscriptions = sqliteTable('subscriptions', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		userId: integer('user_id').references(() => users.id),
-		customerId: text('customer_id'),
-	});
-	const schema1 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: false }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	const schema2 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(
-				() => subscriptions.id,
-			),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
-		'public.users.name->public.users.age',
-	]);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements![2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "name", "age") SELECT "id", "name", "age" FROM \`users\`;`,
-	);
-	expect(sqlStatements![3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![4]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-	expect(sqlStatements[5]).toBe('PRAGMA foreign_keys=ON;');
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('recreate table with added column not null and without default with data', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-			newColumn: text('new_column').notNull(),
-		}),
-	};
-
-	const seedStatements = [
-		`INSERT INTO \`users\` ("name", "age") VALUES ('drizzle', 12)`,
-		`INSERT INTO \`users\` ("name", "age") VALUES ('turso', 12)`,
-	];
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		seedStatements,
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'new_column',
-				notNull: true,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements[0]).toBe('DELETE FROM \`users\`;');
-	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer,
-\t\`new_column\` text NOT NULL
-);\n`);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(1);
-	expect(infoToPrint![0]).toBe(
-		`· You're about to add not-null ${
-			chalk.underline('new_column')
-		} column without default value to table, which contains 2 items`,
-	);
-	expect(shouldAskForApprove).toBe(true);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(1);
-	expect(tablesToTruncate![0]).toBe('users');
-});
-
-test('add check constraint to table', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: ['some_check;"users"."age" > 21'],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer,
-\tCONSTRAINT "some_check" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('drop check constraint', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements!.length).toBe(1);
-	expect(statements![0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				name: 'id',
-				notNull: true,
-				generated: undefined,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'name',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				name: 'age',
-				notNull: false,
-				generated: undefined,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements!.length).toBe(4);
-	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
-	);
-	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements![3]).toBe(
-		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
-	);
-
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('db has checks. Push with same names', async () => {
-	const client = new Database(':memory:');
-
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`${table.age} > 21`),
-		})),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: false }),
-			name: text('name'),
-			age: integer('age'),
-		}, (table) => ({
-			someCheck: check('some_check', sql`some new value`),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-		columnsToRemove,
-		infoToPrint,
-		schemasToRemove,
-		shouldAskForApprove,
-		tablesToRemove,
-		tablesToTruncate,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-		false,
-		[],
-	);
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-	expect(columnsToRemove!.length).toBe(0);
-	expect(infoToPrint!.length).toBe(0);
-	expect(shouldAskForApprove).toBe(false);
-	expect(tablesToRemove!.length).toBe(0);
-	expect(tablesToTruncate!.length).toBe(0);
-});
-
-test('create view', async () => {
-	const client = new Database(':memory:');
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-	};
-
-	const schema2 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			definition: 'select "id" from "test"',
-			name: 'view',
-			type: 'sqlite_create_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE VIEW \`view\` AS select "id" from "test";`,
-	]);
-});
-
-test('drop view', async () => {
-	const client = new Database(':memory:');
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const schema2 = {
-		test: table,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			name: 'view',
-			type: 'drop_view',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'DROP VIEW \`view\`;',
-	]);
-});
-
-test('alter view ".as"', async () => {
-	const client = new Database(':memory:');
-
-	const table = sqliteTable('test', {
-		id: int('id').primaryKey(),
-	});
-
-	const schema1 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
-	};
-
-	const schema2 = {
-		test: table,
-		view: sqliteView('view').as((qb) => qb.select().from(table)),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('create composite primary key', async (t) => {
-	const client = new Database(':memory:');
-
-	const schema1 = {};
-
-	const schema2 = {
-		table: sqliteTable('table', {
-			col1: integer('col1').notNull(),
-			col2: integer('col2').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				columns: [t.col1, t.col2],
-			}),
-		})),
-	};
-
-	const {
-		statements,
-		sqlStatements,
-	} = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements).toStrictEqual([{
-		type: 'sqlite_create_table',
-		tableName: 'table',
-		compositePKs: [['col1', 'col2']],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-		columns: [
-			{ name: 'col1', type: 'integer', primaryKey: false, notNull: true, autoincrement: false },
-			{ name: 'col2', type: 'integer', primaryKey: false, notNull: true, autoincrement: false },
-		],
-	}]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `table` (\n\t`col1` integer NOT NULL,\n\t`col2` integer NOT NULL,\n\tPRIMARY KEY(`col1`, `col2`)\n);\n',
-	]);
-});
-
-test('rename table with composite primary key', async () => {
-	const client = new Database(':memory:');
-
-	const productsCategoriesTable = (tableName: string) => {
-		return sqliteTable(tableName, {
-			productId: text('product_id').notNull(),
-			categoryId: text('category_id').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				columns: [t.productId, t.categoryId],
-			}),
-		}));
-	};
-
-	const schema1 = {
-		table: productsCategoriesTable('products_categories'),
-	};
-	const schema2 = {
-		test: productsCategoriesTable('products_to_categories'),
-	};
-
-	const { sqlStatements } = await diffTestSchemasPushSqlite(
-		client,
-		schema1,
-		schema2,
-		['public.products_categories->public.products_to_categories'],
-		false,
-	);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `products_categories` RENAME TO `products_to_categories`;',
-	]);
-});
diff --git a/drizzle-kit/tests/rls/pg-policy.test.ts b/drizzle-kit/tests/rls/pg-policy.test.ts
deleted file mode 100644
index 3d5dcbd140..0000000000
--- a/drizzle-kit/tests/rls/pg-policy.test.ts
+++ /dev/null
@@ -1,1656 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { integer, pgPolicy, pgRole, pgSchema, pgTable } from 'drizzle-orm/pg-core';
-import { diffTestSchemas } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-test('add policy + enable rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('drop policy + disable rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
-		'DROP POLICY "test" ON "users" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'disable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-	]);
-});
-
-test('add policy without enable rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-			newrls: pgPolicy('newRls'),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE POLICY "newRls" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'newRls',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('drop policy without disable rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-			oldRls: pgPolicy('oldRls'),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "oldRls" ON "users" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'oldRls',
-				to: ['public'],
-				using: undefined,
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-	]);
-});
-
-test('alter policy without recreation: changing roles', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', to: 'current_role' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO current_role;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--current_role--undefined--undefined--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-test('alter policy without recreation: changing using', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', using: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO public USING (true);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--public--true--undefined--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-test('alter policy without recreation: changing with check', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', withCheck: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO public WITH CHECK (true);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--public--undefined--true--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-///
-
-test('alter policy with recreation: changing as', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				using: undefined,
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('alter policy with recreation: changing for', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', for: 'delete' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'DELETE',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('alter policy with recreation: changing both "as" and "for"', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive', for: 'insert' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR INSERT TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				using: undefined,
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'INSERT',
-				name: 'test',
-				to: ['public'],
-				using: undefined,
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('alter policy with recreation: changing all fields', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive', for: 'select', using: sql`true` }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'restrictive', to: 'current_role', withCheck: sql`true` }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS RESTRICTIVE FOR ALL TO current_role WITH CHECK (true);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'SELECT',
-				name: 'test',
-				to: ['public'],
-				using: 'true',
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'RESTRICTIVE',
-				for: 'ALL',
-				name: 'test',
-				on: undefined,
-				to: ['current_role'],
-				using: undefined,
-				withCheck: 'true',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('rename policy', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('newName', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, [
-		'public.users.test->public.users.newName',
-	]);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newName: 'newName',
-			oldName: 'test',
-			schema: '',
-			tableName: 'users',
-			type: 'rename_policy',
-		},
-	]);
-});
-
-test('rename policy in renamed table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('newName', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, [
-		'public.users->public.users2',
-		'public.users2.test->public.users2.newName',
-	]);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" RENAME TO "users2";',
-		'ALTER POLICY "test" ON "users2" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			fromSchema: '',
-			tableNameFrom: 'users',
-			tableNameTo: 'users2',
-			toSchema: '',
-			type: 'rename_table',
-		},
-		{
-			newName: 'newName',
-			oldName: 'test',
-			schema: '',
-			tableName: 'users2',
-			type: 'rename_policy',
-		},
-	]);
-});
-
-test('create table with a policy', async (t) => {
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE "users2" (\n\t"id" integer PRIMARY KEY NOT NULL\n);\n',
-		'ALTER TABLE "users2" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users2" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					name: 'id',
-					notNull: true,
-					primaryKey: true,
-					type: 'integer',
-				},
-			],
-			compositePKs: [],
-			checkConstraints: [],
-			compositePkName: '',
-			policies: [
-				'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			],
-			schema: '',
-			tableName: 'users2',
-			isRLSEnabled: false,
-			type: 'create_table',
-			uniqueConstraints: [],
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: [
-					'public',
-				],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users2',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('drop table with a policy', async (t) => {
-	const schema1 = {
-		users: pgTable('users2', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { as: 'permissive' }),
-		})),
-	};
-
-	const schema2 = {};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users2" CASCADE;',
-		'DROP TABLE "users2" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			policies: [
-				'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			],
-			schema: '',
-			tableName: 'users2',
-			type: 'drop_table',
-		},
-	]);
-});
-
-test('add policy with multiple "to" roles', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const role = pgRole('manager').existing();
-
-	const schema2 = {
-		role,
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { to: ['current_role', role] }),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_role, "manager";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: undefined,
-				to: ['current_role', 'manager'],
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('create table with rls enabled', async (t) => {
-	const schema1 = {};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}).enableRLS(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		`CREATE TABLE "users" (\n\t"id" integer PRIMARY KEY NOT NULL\n);
-`,
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-	]);
-});
-
-test('enable rls force', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}).enableRLS(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;']);
-});
-
-test('disable rls force', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}).enableRLS(),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;']);
-});
-
-test('drop policy with enabled rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { to: ['current_role', role] }),
-		})).enableRLS(),
-	};
-
-	const role = pgRole('manager').existing();
-
-	const schema2 = {
-		role,
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}).enableRLS(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-	]);
-});
-
-test('add policy with enabled rls', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}).enableRLS(),
-	};
-
-	const role = pgRole('manager').existing();
-
-	const schema2 = {
-		role,
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, () => ({
-			rls: pgPolicy('test', { to: ['current_role', role] }),
-		})).enableRLS(),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO current_role, "manager";',
-	]);
-});
-
-test('add policy + link table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('link table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-		rls: pgPolicy('test', { as: 'permissive' }),
-	};
-
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('unlink table', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
-		'DROP POLICY "test" ON "users" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'disable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-	]);
-});
-
-test('drop policy with link', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" DISABLE ROW LEVEL SECURITY;',
-		'DROP POLICY "test" ON "users" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'disable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-	]);
-});
-
-test('add policy in table and with link table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	}, () => [
-		pgPolicy('test1', { to: 'current_user' }),
-	]);
-
-	const schema2 = {
-		users,
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test1" ON "users" AS PERMISSIVE FOR ALL TO current_user;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test1',
-				to: ['current_user'],
-				on: undefined,
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				to: ['public'],
-				using: undefined,
-				on: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
-
-test('link non-schema table', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {};
-
-	const schema2 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE POLICY "test" ON "public"."users" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"public"."users"',
-			type: 'create_ind_policy',
-		},
-	]);
-});
-
-test('unlink non-schema table', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('test', { as: 'permissive' }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "public"."users" CASCADE;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"public"."users"',
-			type: 'drop_ind_policy',
-		},
-	]);
-});
-
-test('add policy + link non-schema table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const cities = pgTable('cities', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test2'),
-		]),
-		rls: pgPolicy('test', { as: 'permissive' }).link(cities),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
-		'CREATE POLICY "test" ON "public"."cities" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test2',
-				on: undefined,
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."cities"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"public"."cities"',
-			type: 'create_ind_policy',
-		},
-	]);
-});
-
-test('add policy + link non-schema table from auth schema', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const authSchema = pgSchema('auth');
-
-	const cities = authSchema.table('cities', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test2'),
-		]),
-		rls: pgPolicy('test', { as: 'permissive' }).link(cities),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;',
-		'CREATE POLICY "test2" ON "users" AS PERMISSIVE FOR ALL TO public;',
-		'CREATE POLICY "test" ON "auth"."cities" AS PERMISSIVE FOR ALL TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			schema: '',
-			tableName: 'users',
-			type: 'enable_rls',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test2',
-				on: undefined,
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"auth"."cities"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"auth"."cities"',
-			type: 'create_ind_policy',
-		},
-	]);
-});
-
-test('rename policy that is linked', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('newName', { as: 'permissive' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, [
-		'"public"."users".test->"public"."users".newName',
-	]);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "public"."users" RENAME TO "newName";',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newName: 'newName',
-			oldName: 'test',
-			tableKey: '"public"."users"',
-			type: 'rename_ind_policy',
-		},
-	]);
-});
-
-test('alter policy that is linked', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive' }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('test', { as: 'permissive', to: 'current_role' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "public"."users" TO current_role;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'current_role',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			oldData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			type: 'alter_ind_policy',
-		},
-	]);
-});
-
-test('alter policy that is linked: withCheck', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`true` }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('test', { as: 'permissive', withCheck: sql`false` }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "public"."users" TO public WITH CHECK (false);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: 'false',
-			},
-			oldData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: 'true',
-			},
-			type: 'alter_ind_policy',
-		},
-	]);
-});
-
-test('alter policy that is linked: using', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { as: 'permissive', using: sql`true` }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('test', { as: 'permissive', using: sql`false` }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "public"."users" TO public USING (false);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: 'false',
-				withCheck: undefined,
-			},
-			oldData: {
-				as: 'PERMISSIVE',
-				for: 'ALL',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: 'true',
-				withCheck: undefined,
-			},
-			type: 'alter_ind_policy',
-		},
-	]);
-});
-
-test('alter policy that is linked: using', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		rls: pgPolicy('test', { for: 'insert' }).link(users),
-	};
-
-	const schema2 = {
-		rls: pgPolicy('test', { for: 'delete' }).link(users),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "public"."users" CASCADE;',
-		'CREATE POLICY "test" ON "public"."users" AS PERMISSIVE FOR DELETE TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'INSERT',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"public"."users"',
-			type: 'drop_ind_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'DELETE',
-				name: 'test',
-				on: '"public"."users"',
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			tableName: '"public"."users"',
-			type: 'create_ind_policy',
-		},
-	]);
-});
-
-////
-
-test('alter policy in the table', async (t) => {
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive' }),
-		]),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive', to: 'current_role' }),
-		]),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO current_role;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--current_role--undefined--undefined--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined--undefined--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-test('alter policy in the table: withCheck', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive', withCheck: sql`true` }),
-		]),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive', withCheck: sql`false` }),
-		]),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO public WITH CHECK (false);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--public--undefined--false--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--undefined--true--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-test('alter policy in the table: using', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive', using: sql`true` }),
-		]),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { as: 'permissive', using: sql`false` }),
-		]),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER POLICY "test" ON "users" TO public USING (false);',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			newData: 'test--PERMISSIVE--ALL--public--false--undefined--undefined',
-			oldData: 'test--PERMISSIVE--ALL--public--true--undefined--undefined',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_policy',
-		},
-	]);
-});
-
-test('alter policy in the table: using', async (t) => {
-	const users = pgTable('users', {
-		id: integer('id').primaryKey(),
-	});
-
-	const schema1 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { for: 'insert' }),
-		]),
-	};
-
-	const schema2 = {
-		users: pgTable('users', {
-			id: integer('id').primaryKey(),
-		}, (t) => [
-			pgPolicy('test', { for: 'delete' }),
-		]),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'DROP POLICY "test" ON "users" CASCADE;',
-		'CREATE POLICY "test" ON "users" AS PERMISSIVE FOR DELETE TO public;',
-	]);
-	expect(statements).toStrictEqual([
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'INSERT',
-				name: 'test',
-				on: undefined,
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'drop_policy',
-		},
-		{
-			data: {
-				as: 'PERMISSIVE',
-				for: 'DELETE',
-				name: 'test',
-				on: undefined,
-				to: [
-					'public',
-				],
-				using: undefined,
-				withCheck: undefined,
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'create_policy',
-		},
-	]);
-});
diff --git a/drizzle-kit/tests/rls/pg-role.test.ts b/drizzle-kit/tests/rls/pg-role.test.ts
deleted file mode 100644
index a6b7629557..0000000000
--- a/drizzle-kit/tests/rls/pg-role.test.ts
+++ /dev/null
@@ -1,234 +0,0 @@
-import { pgRole } from 'drizzle-orm/pg-core';
-import { diffTestSchemas } from 'tests/schemaDiffer';
-import { expect, test } from 'vitest';
-
-test('create role', async (t) => {
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-});
-
-test('create role with properties', async (t) => {
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, inherit: false, createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: true,
-				createRole: true,
-				inherit: false,
-			},
-		},
-	]);
-});
-
-test('create role with some properties', async (t) => {
-	const schema1 = {};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['CREATE ROLE "manager" WITH CREATEDB NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'create_role',
-			values: {
-				createDb: true,
-				createRole: false,
-				inherit: false,
-			},
-		},
-	]);
-});
-
-test('drop role', async (t) => {
-	const schema1 = { manager: pgRole('manager') };
-
-	const schema2 = {};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['DROP ROLE "manager";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'drop_role',
-		},
-	]);
-});
-
-test('create and drop role', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		admin: pgRole('admin'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['DROP ROLE "manager";', 'CREATE ROLE "admin";']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'drop_role',
-		},
-		{
-			name: 'admin',
-			type: 'create_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-});
-
-test('rename role', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		admin: pgRole('admin'),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, ['manager->admin']);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" RENAME TO "admin";']);
-	expect(statements).toStrictEqual([
-		{ nameFrom: 'manager', nameTo: 'admin', type: 'rename_role' },
-	]);
-});
-
-test('alter all role field', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true, createRole: true, inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH CREATEDB CREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: true,
-				createRole: true,
-				inherit: false,
-			},
-		},
-	]);
-});
-
-test('alter createdb in role', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createDb: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH CREATEDB NOCREATEROLE INHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: true,
-				createRole: false,
-				inherit: true,
-			},
-		},
-	]);
-});
-
-test('alter createrole in role', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { createRole: true }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH NOCREATEDB CREATEROLE INHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: false,
-				createRole: true,
-				inherit: true,
-			},
-		},
-	]);
-});
-
-test('alter inherit in role', async (t) => {
-	const schema1 = {
-		manager: pgRole('manager'),
-	};
-
-	const schema2 = {
-		manager: pgRole('manager', { inherit: false }),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemas(schema1, schema2, []);
-
-	expect(sqlStatements).toStrictEqual(['ALTER ROLE "manager" WITH NOCREATEDB NOCREATEROLE NOINHERIT;']);
-	expect(statements).toStrictEqual([
-		{
-			name: 'manager',
-			type: 'alter_role',
-			values: {
-				createDb: false,
-				createRole: false,
-				inherit: false,
-			},
-		},
-	]);
-});
diff --git a/drizzle-kit/tests/schemaDiffer.ts b/drizzle-kit/tests/schemaDiffer.ts
deleted file mode 100644
index c756875ef8..0000000000
--- a/drizzle-kit/tests/schemaDiffer.ts
+++ /dev/null
@@ -1,2784 +0,0 @@
-import { PGlite } from '@electric-sql/pglite';
-import { Client } from '@libsql/client/.';
-import { Database } from 'better-sqlite3';
-import { is } from 'drizzle-orm';
-import { MySqlSchema, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
-import {
-	getMaterializedViewConfig,
-	isPgEnum,
-	isPgMaterializedView,
-	isPgSequence,
-	isPgView,
-	PgEnum,
-	PgEnumObject,
-	PgMaterializedView,
-	PgPolicy,
-	PgRole,
-	PgSchema,
-	PgSequence,
-	PgTable,
-	PgView,
-} from 'drizzle-orm/pg-core';
-import { SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
-import { SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
-import * as fs from 'fs';
-import { type Client as GelClient } from 'gel';
-import { Connection } from 'mysql2/promise';
-import { libSqlLogSuggestionsAndReturn } from 'src/cli/commands/libSqlPushUtils';
-import {
-	columnsResolver,
-	enumsResolver,
-	indPolicyResolver,
-	mySqlViewsResolver,
-	Named,
-	policyResolver,
-	roleResolver,
-	schemasResolver,
-	sequencesResolver,
-	sqliteViewsResolver,
-	tablesResolver,
-	viewsResolver,
-} from 'src/cli/commands/migrate';
-import { pgSuggestions } from 'src/cli/commands/pgPushUtils';
-import { logSuggestionsAndReturn as singleStoreLogSuggestionsAndReturn } from 'src/cli/commands/singlestorePushUtils';
-import { logSuggestionsAndReturn } from 'src/cli/commands/sqlitePushUtils';
-import { Entities } from 'src/cli/validations/cli';
-import { CasingType } from 'src/cli/validations/common';
-import { schemaToTypeScript as schemaToTypeScriptGel } from 'src/introspect-gel';
-import { schemaToTypeScript as schemaToTypeScriptMySQL } from 'src/introspect-mysql';
-import { schemaToTypeScript } from 'src/introspect-pg';
-import { schemaToTypeScript as schemaToTypeScriptSingleStore } from 'src/introspect-singlestore';
-import { schemaToTypeScript as schemaToTypeScriptSQLite } from 'src/introspect-sqlite';
-import { fromDatabase as fromGelDatabase } from 'src/serializer/gelSerializer';
-import { prepareFromMySqlImports } from 'src/serializer/mysqlImports';
-import { mysqlSchema, squashMysqlScheme, ViewSquashed } from 'src/serializer/mysqlSchema';
-import { fromDatabase as fromMySqlDatabase, generateMySqlSnapshot } from 'src/serializer/mysqlSerializer';
-import { prepareFromPgImports } from 'src/serializer/pgImports';
-import { pgSchema, Policy, Role, squashPgScheme, View } from 'src/serializer/pgSchema';
-import { fromDatabase, generatePgSnapshot } from 'src/serializer/pgSerializer';
-import { prepareFromSingleStoreImports } from 'src/serializer/singlestoreImports';
-import { singlestoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
-import {
-	fromDatabase as fromSingleStoreDatabase,
-	generateSingleStoreSnapshot,
-} from 'src/serializer/singlestoreSerializer';
-import { prepareFromSqliteImports } from 'src/serializer/sqliteImports';
-import { sqliteSchema, squashSqliteScheme, View as SqliteView } from 'src/serializer/sqliteSchema';
-import { fromDatabase as fromSqliteDatabase, generateSqliteSnapshot } from 'src/serializer/sqliteSerializer';
-import {
-	applyLibSQLSnapshotsDiff,
-	applyMysqlSnapshotsDiff,
-	applyPgSnapshotsDiff,
-	applySingleStoreSnapshotsDiff,
-	applySqliteSnapshotsDiff,
-	Column,
-	ColumnsResolverInput,
-	ColumnsResolverOutput,
-	Enum,
-	PolicyResolverInput,
-	PolicyResolverOutput,
-	ResolverInput,
-	ResolverOutput,
-	ResolverOutputWithMoved,
-	RolesResolverInput,
-	RolesResolverOutput,
-	Sequence,
-	Table,
-	TablePolicyResolverInput,
-	TablePolicyResolverOutput,
-} from 'src/snapshotsDiffer';
-
-export type PostgresSchema = Record<
-	string,
-	| PgTable<any>
-	| PgEnum<any>
-	| PgEnumObject<any>
-	| PgSchema
-	| PgSequence
-	| PgView
-	| PgMaterializedView
-	| PgRole
-	| PgPolicy
->;
-export type MysqlSchema = Record<
-	string,
-	MySqlTable<any> | MySqlSchema | MySqlView
->;
-export type SqliteSchema = Record<string, SQLiteTable<any> | SQLiteView>;
-export type SinglestoreSchema = Record<
-	string,
-	SingleStoreTable<any> | SingleStoreSchema /* | SingleStoreView */
->;
-
-export const testSchemasResolver =
-	(renames: Set<string>) => async (input: ResolverInput<Named>): Promise<ResolverOutput<Named>> => {
-		try {
-			if (
-				input.created.length === 0
-				|| input.deleted.length === 0
-				|| renames.size === 0
-			) {
-				return {
-					created: input.created,
-					renamed: [],
-					deleted: input.deleted,
-				};
-			}
-
-			let createdSchemas = [...input.created];
-			let deletedSchemas = [...input.deleted];
-
-			const result: {
-				created: Named[];
-				renamed: { from: Named; to: Named }[];
-				deleted: Named[];
-			} = { created: [], renamed: [], deleted: [] };
-
-			for (let rename of renames) {
-				const [from, to] = rename.split('->');
-
-				const idxFrom = deletedSchemas.findIndex((it) => {
-					return it.name === from;
-				});
-
-				if (idxFrom >= 0) {
-					const idxTo = createdSchemas.findIndex((it) => {
-						return it.name === to;
-					});
-
-					result.renamed.push({
-						from: deletedSchemas[idxFrom],
-						to: createdSchemas[idxTo],
-					});
-
-					delete createdSchemas[idxTo];
-					delete deletedSchemas[idxFrom];
-
-					createdSchemas = createdSchemas.filter(Boolean);
-					deletedSchemas = deletedSchemas.filter(Boolean);
-				}
-			}
-
-			result.created = createdSchemas;
-			result.deleted = deletedSchemas;
-
-			return result;
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
-	};
-
-export const testSequencesResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Sequence>,
-): Promise<ResolverOutputWithMoved<Sequence>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdSequences = [...input.created];
-		let deletedSequences = [...input.deleted];
-
-		const result: {
-			created: Sequence[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Sequence; to: Sequence }[];
-			deleted: Sequence[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedSequences.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdSequences.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedSequences[idxFrom];
-				const tableTo = createdSequences[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedSequences[idxFrom],
-						to: createdSequences[idxTo],
-					});
-				}
-
-				delete createdSequences[idxTo];
-				delete deletedSequences[idxFrom];
-
-				createdSequences = createdSequences.filter(Boolean);
-				deletedSequences = deletedSequences.filter(Boolean);
-			}
-		}
-
-		result.created = createdSequences;
-		result.deleted = deletedSequences;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testEnumsResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Enum>,
-): Promise<ResolverOutputWithMoved<Enum>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdEnums = [...input.created];
-		let deletedEnums = [...input.deleted];
-
-		const result: {
-			created: Enum[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Enum; to: Enum }[];
-			deleted: Enum[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedEnums.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdEnums.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedEnums[idxFrom];
-				const tableTo = createdEnums[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedEnums[idxFrom],
-						to: createdEnums[idxTo],
-					});
-				}
-
-				delete createdEnums[idxTo];
-				delete deletedEnums[idxFrom];
-
-				createdEnums = createdEnums.filter(Boolean);
-				deletedEnums = deletedEnums.filter(Boolean);
-			}
-		}
-
-		result.created = createdEnums;
-		result.deleted = deletedEnums;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testTablesResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Table>,
-): Promise<ResolverOutputWithMoved<Table>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdTables = [...input.created];
-		let deletedTables = [...input.deleted];
-
-		const result: {
-			created: Table[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Table; to: Table }[];
-			deleted: Table[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedTables.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdTables.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedTables[idxFrom];
-				const tableTo = createdTables[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedTables[idxFrom],
-						to: createdTables[idxTo],
-					});
-				}
-
-				delete createdTables[idxTo];
-				delete deletedTables[idxFrom];
-
-				createdTables = createdTables.filter(Boolean);
-				deletedTables = deletedTables.filter(Boolean);
-			}
-		}
-
-		result.created = createdTables;
-		result.deleted = deletedTables;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testColumnsResolver = (renames: Set<string>) =>
-async (
-	input: ColumnsResolverInput<Column>,
-): Promise<ColumnsResolverOutput<Column>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				tableName: input.tableName,
-				schema: input.schema,
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdColumns = [...input.created];
-		let deletedColumns = [...input.deleted];
-
-		const renamed: { from: Column; to: Column }[] = [];
-
-		const schema = input.schema || 'public';
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedColumns.findIndex((it) => {
-				return `${schema}.${input.tableName}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdColumns.findIndex((it) => {
-					return `${schema}.${input.tableName}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedColumns[idxFrom],
-					to: createdColumns[idxTo],
-				});
-
-				delete createdColumns[idxTo];
-				delete deletedColumns[idxFrom];
-
-				createdColumns = createdColumns.filter(Boolean);
-				deletedColumns = deletedColumns.filter(Boolean);
-			}
-		}
-
-		return {
-			tableName: input.tableName,
-			schema: input.schema,
-			created: createdColumns,
-			deleted: deletedColumns,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testPolicyResolver = (renames: Set<string>) =>
-async (
-	input: TablePolicyResolverInput<Policy>,
-): Promise<TablePolicyResolverOutput<Policy>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				tableName: input.tableName,
-				schema: input.schema,
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		const schema = input.schema || 'public';
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${schema}.${input.tableName}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${schema}.${input.tableName}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			tableName: input.tableName,
-			schema: input.schema,
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testIndPolicyResolver = (renames: Set<string>) =>
-async (
-	input: PolicyResolverInput<Policy>,
-): Promise<PolicyResolverOutput<Policy>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${it.on}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${it.on}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testRolesResolver = (renames: Set<string>) =>
-async (
-	input: RolesResolverInput<Role>,
-): Promise<RolesResolverOutput<Role>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<View>,
-): Promise<ResolverOutputWithMoved<View>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: View[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: View; to: View }[];
-			deleted: View[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverMySql = (renames: Set<string>) =>
-async (
-	input: ResolverInput<ViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: ViewSquashed[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: ViewSquashed; to: ViewSquashed }[];
-			deleted: ViewSquashed[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverSingleStore = (renames: Set<string>) =>
-async (
-	input: ResolverInput<ViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: ViewSquashed[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: ViewSquashed; to: ViewSquashed }[];
-			deleted: ViewSquashed[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverSqlite = (renames: Set<string>) =>
-async (
-	input: ResolverInput<SqliteView>,
-): Promise<ResolverOutputWithMoved<SqliteView>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: SqliteView[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: SqliteView; to: SqliteView }[];
-			deleted: SqliteView[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return it.name === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return it.name === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const diffTestSchemasPush = async (
-	client: PGlite,
-	left: PostgresSchema,
-	right: PostgresSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	schemas: string[] = ['public'],
-	casing?: CasingType | undefined,
-	entities?: Entities,
-	sqlStatementsToRun: {
-		before?: string[];
-		after?: string[];
-		runApply?: boolean;
-	} = {
-		before: [],
-		after: [],
-		runApply: true,
-	},
-) => {
-	const shouldRunApply = sqlStatementsToRun.runApply === undefined
-		? true
-		: sqlStatementsToRun.runApply;
-
-	for (const st of sqlStatementsToRun.before ?? []) {
-		await client.query(st);
-	}
-
-	if (shouldRunApply) {
-		const res = await applyPgDiffs(left, casing);
-		for (const st of res.sqlStatements) {
-			await client.query(st);
-		}
-	}
-
-	for (const st of sqlStatementsToRun.after ?? []) {
-		await client.query(st);
-	}
-
-	const materializedViewsForRefresh = Object.values(left).filter((it) =>
-		isPgMaterializedView(it)
-	) as PgMaterializedView[];
-
-	// refresh all mat views
-	for (const view of materializedViewsForRefresh) {
-		const viewConf = getMaterializedViewConfig(view);
-		if (viewConf.isExisting) continue;
-
-		await client.exec(
-			`REFRESH MATERIALIZED VIEW "${viewConf.schema ?? 'public'}"."${viewConf.name}"${
-				viewConf.withNoData ? ' WITH NO DATA;' : ';'
-			}`,
-		);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromDatabase(
-		{
-			query: async (query: string, values?: any[] | undefined) => {
-				const res = await client.query(query, values);
-				return res.rows as any[];
-			},
-		},
-		undefined,
-		schemas,
-		entities,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const leftSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const leftEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const leftSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const leftRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const leftPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const leftViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
-
-	const leftMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized2 = generatePgSnapshot(
-		leftTables,
-		leftEnums,
-		leftSchemas,
-		leftSequences,
-		leftRoles,
-		leftPolicies,
-		leftViews,
-		leftMaterializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1, 'push');
-	const sn2 = squashPgScheme(sch2, 'push');
-
-	const validatedPrev = pgSchema.parse(sch1);
-	const validatedCur = pgSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			testSchemasResolver(renames),
-			testEnumsResolver(renames),
-			testSequencesResolver(renames),
-			testPolicyResolver(renames),
-			testIndPolicyResolver(renames),
-			testRolesResolver(renames),
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolver(renames),
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		const {
-			shouldAskForApprove,
-			statementsToExecute,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-			schemasToRemove,
-			matViewsToRemove,
-		} = await pgSuggestions(
-			{
-				query: async <T>(sql: string, params: any[] = []) => {
-					return (await client.query(sql, params)).rows as T[];
-				},
-			},
-			statements,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			shouldAskForApprove,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-			schemasToRemove,
-			matViewsToRemove,
-		};
-	} else {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			schemasResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applyPgDiffs = async (
-	sn: PostgresSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		enums: {},
-		views: {},
-		schemas: {},
-		sequences: {},
-		policies: {},
-		roles: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const schemas = Object.values(sn).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const enums = Object.values(sn).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const sequences = Object.values(sn).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const roles = Object.values(sn).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const views = Object.values(sn).filter((it) => isPgView(it)) as PgView[];
-
-	const policies = Object.values(sn).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const materializedViews = Object.values(sn).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized1 = generatePgSnapshot(
-		tables,
-		enums,
-		schemas,
-		sequences,
-		roles,
-		policies,
-		views,
-		materializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1);
-
-	const validatedPrev = pgSchema.parse(dryRun);
-	const validatedCur = pgSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-		dryRun,
-		sn1,
-		testSchemasResolver(new Set()),
-		testEnumsResolver(new Set()),
-		testSequencesResolver(new Set()),
-		testPolicyResolver(new Set()),
-		testIndPolicyResolver(new Set()),
-		testRolesResolver(new Set()),
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolver(new Set()),
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemas = async (
-	left: PostgresSchema,
-	right: PostgresSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const leftSchemas = Object.values(left).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const rightSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const leftEnums = Object.values(left).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const rightEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const leftSequences = Object.values(left).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const rightSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const leftRoles = Object.values(left).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const rightRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const leftPolicies = Object.values(left).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const rightPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const leftViews = Object.values(left).filter((it) => isPgView(it)) as PgView[];
-
-	const rightViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
-
-	const leftMaterializedViews = Object.values(left).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const rightMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized1 = generatePgSnapshot(
-		leftTables,
-		leftEnums,
-		leftSchemas,
-		leftSequences,
-		leftRoles,
-		leftPolicies,
-		leftViews,
-		leftMaterializedViews,
-		casing,
-	);
-	const serialized2 = generatePgSnapshot(
-		rightTables,
-		rightEnums,
-		rightSchemas,
-		rightSequences,
-		rightRoles,
-		rightPolicies,
-		rightViews,
-		rightMaterializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1);
-	const sn2 = squashPgScheme(sch2);
-
-	const validatedPrev = pgSchema.parse(sch1);
-	const validatedCur = pgSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			testSchemasResolver(renames),
-			testEnumsResolver(renames),
-			testSequencesResolver(renames),
-			testPolicyResolver(renames),
-			testIndPolicyResolver(renames),
-			testRolesResolver(renames),
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolver(renames),
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	} else {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			schemasResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const diffTestSchemasPushMysql = async (
-	client: Connection,
-	left: MysqlSchema,
-	right: MysqlSchema,
-	renamesArr: string[],
-	schema: string,
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const { sqlStatements } = await applyMySqlDiffs(left, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromMySqlDatabase(
-		{
-			query: async (sql: string, params?: any[]) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const leftViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized2 = generateMySqlSnapshot(leftTables, leftViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-	const sn2 = squashMysqlScheme(sch2);
-
-	const validatedPrev = mysqlSchema.parse(sch1);
-	const validatedCur = mysqlSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverMySql(renames),
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	} else {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applyMySqlDiffs = async (
-	sn: MysqlSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		views: {},
-		tables: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized1 = generateMySqlSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-
-	const validatedPrev = mysqlSchema.parse(dryRun);
-	const validatedCur = mysqlSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverMySql(new Set()),
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasMysql = async (
-	left: MysqlSchema,
-	right: MysqlSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized1 = generateMySqlSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateMySqlSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-	const sn2 = squashMysqlScheme(sch2);
-
-	const validatedPrev = mysqlSchema.parse(sch1);
-	const validatedCur = mysqlSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverMySql(renames),
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		mySqlViewsResolver,
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasSingleStore = async (
-	left: SinglestoreSchema,
-	right: SinglestoreSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const leftViews = Object.values(left).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const rightTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const rightViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized1 = generateSingleStoreSnapshot(
-		leftTables,
-		/* leftViews, */
-		casing,
-	);
-	const serialized2 = generateSingleStoreSnapshot(
-		rightTables,
-		/* rightViews, */
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-	const sn2 = squashSingleStoreScheme(sch2);
-
-	const validatedPrev = singlestoreSchema.parse(sch1);
-	const validatedCur = singlestoreSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			/* testViewsResolverSingleStore(renames), */
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		/* singleStoreViewsResolver, */
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasPushSingleStore = async (
-	client: Connection,
-	left: SinglestoreSchema,
-	right: SinglestoreSchema,
-	renamesArr: string[],
-	schema: string,
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-	sqlStatementsToRun: {
-		before?: string[];
-		after?: string[];
-		runApply?: boolean;
-	} = {
-		before: [],
-		after: [],
-		runApply: true,
-	},
-) => {
-	const shouldRunApply = sqlStatementsToRun.runApply === undefined
-		? true
-		: sqlStatementsToRun.runApply;
-
-	for (const st of sqlStatementsToRun.before ?? []) {
-		await client.query(st);
-	}
-
-	if (shouldRunApply) {
-		const res = await applySingleStoreDiffs(left, casing);
-		for (const st of res.sqlStatements) {
-			await client.query(st);
-		}
-	}
-
-	for (const st of sqlStatementsToRun.after ?? []) {
-		await client.query(st);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromSingleStoreDatabase(
-		{
-			query: async (sql: string, params?: any[]) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const leftViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized2 = generateSingleStoreSnapshot(
-		leftTables,
-		/* leftViews, */
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-	const sn2 = squashSingleStoreScheme(sch2);
-
-	const validatedPrev = singlestoreSchema.parse(sch1);
-	const validatedCur = singlestoreSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			/* testViewsResolverSingleStore(renames), */
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await singleStoreLogSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params?: any[]) => {
-					const res = await client.execute(sql, params);
-					return res[0] as T[];
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applySingleStoreDiffs = async (
-	sn: SinglestoreSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		views: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const views = Object.values(sn).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized1 = generateSingleStoreSnapshot(tables, /* views, */ casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-
-	const validatedPrev = singlestoreSchema.parse(dryRun);
-	const validatedCur = singlestoreSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		/* testViewsResolverSingleStore(new Set()), */
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasPushSqlite = async (
-	client: Database,
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	seedStatements: string[] = [],
-	casing?: CasingType | undefined,
-) => {
-	const { sqlStatements } = await applySqliteDiffs(left, 'push');
-
-	for (const st of sqlStatements) {
-		client.exec(st);
-	}
-
-	for (const st of seedStatements) {
-		client.exec(st);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return client.prepare(sql).bind(params).all() as T[];
-			},
-			run: async (query: string) => {
-				client.prepare(query).run();
-			},
-		},
-		undefined,
-	);
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, 'push');
-	const sn2 = squashSqliteScheme(sch2, 'push');
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements, _meta } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			schemasToRemove,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await logSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params: any[] = []) => {
-					return client.prepare(sql).bind(params).all() as T[];
-				},
-				run: async (query: string) => {
-					client.prepare(query).run();
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-			_meta!,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			schemasToRemove,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			sch1,
-			sch2,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export async function diffTestSchemasPushLibSQL(
-	client: Client,
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	seedStatements: string[] = [],
-	casing?: CasingType | undefined,
-) {
-	const { sqlStatements } = await applyLibSQLDiffs(left, 'push');
-
-	for (const st of sqlStatements) {
-		await client.execute(st);
-	}
-
-	for (const st of seedStatements) {
-		await client.execute(st);
-	}
-
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params?: any[]) => {
-				const res = await client.execute({ sql, args: params || [] });
-				return res.rows as T[];
-			},
-			run: async (query: string) => {
-				await client.execute(query);
-			},
-		},
-		undefined,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized2 = generateSqliteSnapshot(leftTables, leftViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, 'push');
-	const sn2 = squashSqliteScheme(sch2, 'push');
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements, _meta } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await libSqlLogSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params?: any[]) => {
-					const res = await client.execute({ sql, args: params || [] });
-					return res.rows as T[];
-				},
-				run: async (query: string) => {
-					await client.execute(query);
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-			_meta!,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			sch1,
-			sch2,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-}
-
-export const applySqliteDiffs = async (
-	sn: SqliteSchema,
-	action?: 'push' | undefined,
-	casing?: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		enums: {},
-		views: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, action);
-
-	const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		dryRun,
-		sch1,
-		action,
-	);
-
-	return { sqlStatements, statements };
-};
-
-export const applyLibSQLDiffs = async (
-	sn: SqliteSchema,
-	action?: 'push' | undefined,
-	casing?: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		views: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, action);
-
-	const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		dryRun,
-		sch1,
-		action,
-	);
-
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasSqlite = async (
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1);
-	const sn2 = squashSqliteScheme(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		sch1,
-		sch2,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasLibSQL = async (
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1);
-	const sn2 = squashSqliteScheme(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		sch1,
-		sch2,
-	);
-	return { sqlStatements, statements };
-};
-
-// --- Introspect to file helpers ---
-
-export const introspectPgToFile = async (
-	client: PGlite,
-	initSchema: PostgresSchema,
-	testName: string,
-	schemas: string[] = ['public'],
-	entities?: Entities,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyPgDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromDatabase(
-		{
-			query: async (query: string, values?: any[] | undefined) => {
-				const res = await client.query(query, values);
-				return res.rows as any[];
-			},
-		},
-		undefined,
-		schemas,
-		entities,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashPgScheme(initSch);
-	const validatedCur = pgSchema.parse(initSch);
-
-	// write to ts file
-	const file = schemaToTypeScript(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/postgres/${testName}.ts`, file.file);
-
-	// generate snapshot from ts file
-	const response = await prepareFromPgImports([
-		`tests/introspect/postgres/${testName}.ts`,
-	]);
-
-	const afterFileImports = generatePgSnapshot(
-		response.tables,
-		response.enums,
-		response.schemas,
-		response.sequences,
-		response.roles,
-		response.policies,
-		response.views,
-		response.matViews,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '7',
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashPgScheme(sch2);
-	const validatedCurAfterImport = pgSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyPgSnapshotsDiff(
-		initSn,
-		sn2AfterIm,
-		testSchemasResolver(new Set()),
-		testEnumsResolver(new Set()),
-		testSequencesResolver(new Set()),
-		testPolicyResolver(new Set()),
-		testIndPolicyResolver(new Set()),
-		testRolesResolver(new Set()),
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolver(new Set()),
-		validatedCur,
-		validatedCurAfterImport,
-	);
-
-	fs.rmSync(`tests/introspect/postgres/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectGelToFile = async (
-	client: GelClient,
-	testName: string,
-	schemas: string[] = ['public'],
-	entities?: Entities,
-	casing?: CasingType | undefined,
-) => {
-	// introspect to schema
-	const introspectedSchema = await fromGelDatabase(
-		{
-			query: async (query: string, values?: any[] | undefined) => {
-				const res = await client.querySQL(query, values);
-				return res as any[];
-			},
-		},
-		undefined,
-		schemas,
-		entities,
-	);
-
-	// write to ts file
-	const file = schemaToTypeScriptGel(introspectedSchema, 'camel');
-
-	const path = `tests/introspect/gel/${testName}.ts`;
-	fs.writeFileSync(path, file.file);
-
-	return path;
-};
-
-export const introspectMySQLToFile = async (
-	client: Connection,
-	initSchema: MysqlSchema,
-	testName: string,
-	schema: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyMySqlDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromMySqlDatabase(
-		{
-			query: async (sql: string, params?: any[] | undefined) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashMysqlScheme(initSch);
-	const validatedCur = mysqlSchema.parse(initSch);
-
-	const file = schemaToTypeScriptMySQL(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/mysql/${testName}.ts`, file.file);
-
-	const response = await prepareFromMySqlImports([
-		`tests/introspect/mysql/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateMySqlSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashMysqlScheme(sch2);
-	const validatedCurAfterImport = mysqlSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyMysqlSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverMySql(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/mysql/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectSingleStoreToFile = async (
-	client: Connection,
-	initSchema: SinglestoreSchema,
-	testName: string,
-	schema: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applySingleStoreDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSingleStoreDatabase(
-		{
-			query: async (sql: string, params?: any[] | undefined) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const file = schemaToTypeScriptSingleStore(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/singlestore/${testName}.ts`, file.file);
-
-	const response = await prepareFromSingleStoreImports([
-		`tests/introspect/singlestore/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSingleStoreSnapshot(
-		response.tables,
-		/* response.views, */
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSingleStoreScheme(sch2);
-	const validatedCurAfterImport = singlestoreSchema.parse(sch2);
-
-	const leftTables = Object.values(initSchema).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	const initSnapshot = generateSingleStoreSnapshot(
-		leftTables,
-		/* response.views, */
-		casing,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = initSnapshot;
-
-	const initSch = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSingleStoreScheme(initSch);
-	const validatedCur = singlestoreSchema.parse(initSch);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applySingleStoreSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		/* testViewsResolverSingleStore(new Set()), */
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/singlestore/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectSQLiteToFile = async (
-	client: Database,
-	initSchema: SqliteSchema,
-	testName: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applySqliteDiffs(initSchema);
-	for (const st of sqlStatements) {
-		client.exec(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return client.prepare(sql).bind(params).all() as T[];
-			},
-			run: async (query: string) => {
-				client.prepare(query).run();
-			},
-		},
-		undefined,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSqliteScheme(initSch);
-
-	const validatedCur = sqliteSchema.parse(initSch);
-
-	const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/sqlite/${testName}.ts`, file.file);
-
-	const response = await prepareFromSqliteImports([
-		`tests/introspect/sqlite/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSqliteSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSqliteScheme(sch2);
-	const validatedCurAfterImport = sqliteSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applySqliteSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/sqlite/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectLibSQLToFile = async (
-	client: Client,
-	initSchema: SqliteSchema,
-	testName: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyLibSQLDiffs(initSchema);
-	for (const st of sqlStatements) {
-		client.execute(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return (await client.execute({ sql, args: params })).rows as T[];
-			},
-			run: async (query: string) => {
-				client.execute(query);
-			},
-		},
-		undefined,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSqliteScheme(initSch);
-
-	const validatedCur = sqliteSchema.parse(initSch);
-
-	const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/libsql/${testName}.ts`, file.file);
-
-	const response = await prepareFromSqliteImports([
-		`tests/introspect/libsql/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSqliteSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSqliteScheme(sch2);
-	const validatedCurAfterImport = sqliteSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyLibSQLSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/libsql/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
diff --git a/drizzle-kit/tests/singlestore-generated.test.ts b/drizzle-kit/tests/singlestore-generated.test.ts
deleted file mode 100644
index 8944f3b211..0000000000
--- a/drizzle-kit/tests/singlestore-generated.test.ts
+++ /dev/null
@@ -1,1290 +0,0 @@
-import { SQL, sql } from 'drizzle-orm';
-import { int, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSingleStore } from './schemaDiffer';
-
-test('generated as callback: add column with generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
-	]);
-});
-
-test('generated as callback: drop generated constraint as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as callback: drop generated constraint as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as callback: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as callback: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as callback: change generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-// ---
-
-test('generated as sql: add column with generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
-	]);
-});
-
-test('generated as sql: drop generated constraint as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as sql: drop generated constraint as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as sql: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as sql: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as sql: change generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\``,
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-// ---
-
-test('generated as string: add column with generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: "`users`.`name` || 'hello'",
-					type: 'stored',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`\`users\`.\`name\` || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'stored',
-			},
-			columnAutoIncrement: false,
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`\`users\`.\`name\` || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'to add'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
-	]);
-});
-
-test('generated as string: drop generated constraint as stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'stored',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
-	]);
-});
-
-test('generated as string: drop generated constraint as virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			oldColumn: {
-				autoincrement: false,
-				generated: {
-					as: "`users`.`name` || 'to delete'",
-					type: 'virtual',
-				},
-				name: 'gen_name',
-				notNull: false,
-				onUpdate: undefined,
-				primaryKey: false,
-				type: 'text',
-			},
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as string: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``, {
-				mode: 'virtual',
-			}),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'stored',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
-	]);
-});
-
-test('generated as string: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
-
-test('generated as string: change generated constraint', async () => {
-	const from = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`\`users\`.\`name\``),
-		}),
-	};
-	const to = {
-		users: singlestoreTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`\`users\`.\`name\` || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSingleStore(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: "`users`.`name` || 'hello'",
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` drop column `gen_name`;',
-		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
-	]);
-});
diff --git a/drizzle-kit/tests/singlestore-schemas.test.ts b/drizzle-kit/tests/singlestore-schemas.test.ts
deleted file mode 100644
index db9fe04804..0000000000
--- a/drizzle-kit/tests/singlestore-schemas.test.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-import { singlestoreSchema, singlestoreTable } from 'drizzle-orm/singlestore-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSingleStore } from './schemaDiffer';
-
-// We don't manage databases(schemas) in MySQL with Drizzle Kit
-test('add schema #1', async () => {
-	const to = {
-		devSchema: singlestoreSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add schema #2', async () => {
-	const from = {
-		devSchema: singlestoreSchema('dev'),
-	};
-	const to = {
-		devSchema: singlestoreSchema('dev'),
-		devSchema2: singlestoreSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('delete schema #1', async () => {
-	const from = {
-		devSchema: singlestoreSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, {}, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('delete schema #2', async () => {
-	const from = {
-		devSchema: singlestoreSchema('dev'),
-		devSchema2: singlestoreSchema('dev2'),
-	};
-	const to = {
-		devSchema: singlestoreSchema('dev'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('rename schema #1', async () => {
-	const from = {
-		devSchema: singlestoreSchema('dev'),
-	};
-	const to = {
-		devSchema2: singlestoreSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('rename schema #2', async () => {
-	const from = {
-		devSchema: singlestoreSchema('dev'),
-		devSchema1: singlestoreSchema('dev1'),
-	};
-	const to = {
-		devSchema: singlestoreSchema('dev'),
-		devSchema2: singlestoreSchema('dev2'),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #1', async () => {
-	const dev = singlestoreSchema('dev');
-	const from = {};
-	const to = {
-		dev,
-		users: dev.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #2', async () => {
-	const dev = singlestoreSchema('dev');
-	const from = { dev };
-	const to = {
-		dev,
-		users: dev.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table to schema #3', async () => {
-	const dev = singlestoreSchema('dev');
-	const from = { dev };
-	const to = {
-		dev,
-		usersInDev: dev.table('users', {}),
-		users: singlestoreTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		uniqueConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePkName: '',
-		compositePKs: [],
-	});
-});
-
-test('remove table from schema #1', async () => {
-	const dev = singlestoreSchema('dev');
-	const from = { dev, users: dev.table('users', {}) };
-	const to = {
-		dev,
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
-
-test('remove table from schema #2', async () => {
-	const dev = singlestoreSchema('dev');
-	const from = { dev, users: dev.table('users', {}) };
-	const to = {};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, ['dev1->dev2']);
-
-	expect(statements.length).toBe(0);
-});
diff --git a/drizzle-kit/tests/singlestore.test.ts b/drizzle-kit/tests/singlestore.test.ts
deleted file mode 100644
index dca99ad2d5..0000000000
--- a/drizzle-kit/tests/singlestore.test.ts
+++ /dev/null
@@ -1,978 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-	index,
-	int,
-	json,
-	primaryKey,
-	serial,
-	singlestoreSchema,
-	singlestoreTable,
-	text,
-	uniqueIndex,
-} from 'drizzle-orm/singlestore-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSingleStore } from './schemaDiffer';
-
-test('add table #1', async () => {
-	const to = {
-		users: singlestoreTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		uniqueConstraints: [],
-		compositePkName: '',
-	});
-});
-
-test('add table #2', async () => {
-	const to = {
-		users: singlestoreTable('users', {
-			id: serial('id').primaryKey(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'serial',
-				autoincrement: true,
-			},
-		],
-		compositePKs: ['users_id;id'],
-		compositePkName: 'users_id',
-		uniqueConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('add table #3', async () => {
-	const to = {
-		users: singlestoreTable(
-			'users',
-			{
-				id: serial('id'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({
-						name: 'users_pk',
-						columns: [t.id],
-					}),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: false,
-				type: 'serial',
-				autoincrement: true,
-			},
-		],
-		compositePKs: ['users_pk;id'],
-		uniqueConstraints: [],
-		compositePkName: 'users_pk',
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('add table #4', async () => {
-	const to = {
-		users: singlestoreTable('users', {}),
-		posts: singlestoreTable('posts', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'posts',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		uniqueConstraints: [],
-		compositePkName: '',
-	});
-});
-
-test('add table #5', async () => {
-	const schema = singlestoreSchema('folder');
-	const from = {
-		schema,
-	};
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table #6', async () => {
-	const from = {
-		users1: singlestoreTable('users1', {}),
-	};
-
-	const to = {
-		users2: singlestoreTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users2',
-		schema: undefined,
-		columns: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePKs: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-	});
-	expect(statements[1]).toStrictEqual({
-		policies: [],
-		type: 'drop_table',
-		tableName: 'users1',
-		schema: undefined,
-	});
-});
-
-test('add table #7', async () => {
-	const from = {
-		users1: singlestoreTable('users1', {}),
-	};
-
-	const to = {
-		users: singlestoreTable('users', {}),
-		users2: singlestoreTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'public.users1->public.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users1',
-		tableNameTo: 'users2',
-		fromSchema: undefined,
-		toSchema: undefined,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-		compositePkName: '',
-	});
-});
-
-test('add schema + table #1', async () => {
-	const schema = singlestoreSchema('folder');
-
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore({}, to, []);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change schema with tables #1', async () => {
-	const schema = singlestoreSchema('folder');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder->folder2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #1', async () => {
-	const schema = singlestoreSchema('folder');
-	const from = {
-		schema,
-		users: singlestoreTable('users', {}),
-	};
-	const to = {
-		schema,
-		users: schema.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'public.users->folder.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		policies: [],
-		type: 'drop_table',
-		tableName: 'users',
-		schema: undefined,
-	});
-});
-
-test('change table schema #2', async () => {
-	const schema = singlestoreSchema('folder');
-	const from = {
-		schema,
-		users: schema.table('users', {}),
-	};
-	const to = {
-		schema,
-		users: singlestoreTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder.users->public.users',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_table',
-		tableName: 'users',
-		schema: undefined,
-		columns: [],
-		uniqueConstraints: [],
-		compositePkName: '',
-		compositePKs: [],
-		internals: {
-			tables: {},
-			indexes: {},
-		},
-	});
-});
-
-test('change table schema #3', async () => {
-	const schema1 = singlestoreSchema('folder1');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #4', async () => {
-	const schema1 = singlestoreSchema('folder1');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #5', async () => {
-	const schema1 = singlestoreSchema('folder1');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema1, // remove schema
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // add schema
-		users: schema2.table('users', {}), // move table
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder1.users->folder2.users',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #5', async () => {
-	const schema1 = singlestoreSchema('folder1');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema1,
-		schema2,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema1,
-		schema2,
-		users: schema2.table('users2', {}), // rename and move table
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder1.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('change table schema #6', async () => {
-	const schema1 = singlestoreSchema('folder1');
-	const schema2 = singlestoreSchema('folder2');
-	const from = {
-		schema1,
-		users: schema1.table('users', {}),
-	};
-	const to = {
-		schema2, // rename schema
-		users: schema2.table('users2', {}), // rename table
-	};
-
-	const { statements } = await diffTestSchemasSingleStore(from, to, [
-		'folder1->folder2',
-		'folder2.users->folder2.users2',
-	]);
-
-	expect(statements.length).toBe(0);
-});
-
-test('add table #10', async () => {
-	const to = {
-		users: singlestoreTable('table', {
-			json: json('json').default({}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT '{}'\n);\n",
-	);
-});
-
-test('add table #11', async () => {
-	const to = {
-		users: singlestoreTable('table', {
-			json: json('json').default([]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT '[]'\n);\n",
-	);
-});
-
-test('add table #12', async () => {
-	const to = {
-		users: singlestoreTable('table', {
-			json: json('json').default([1, 2, 3]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` json DEFAULT '[1,2,3]'\n);\n",
-	);
-});
-
-test('add table #13', async () => {
-	const to = {
-		users: singlestoreTable('table', {
-			json: json('json').default({ key: 'value' }),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` json DEFAULT \'{"key":"value"}\'\n);\n',
-	);
-});
-
-test('add table #14', async () => {
-	const to = {
-		users: singlestoreTable('table', {
-			json: json('json').default({
-				key: 'value',
-				arr: [1, 2, 3],
-			}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` json DEFAULT \'{"key":"value","arr":[1,2,3]}\'\n);\n',
-	);
-});
-
-// TODO: add bson type tests
-
-// TODO: add blob type tests
-
-// TODO: add uuid type tests
-
-// TODO: add guid type tests
-
-// TODO: add vector type tests
-
-// TODO: add geopoint type tests
-
-test('drop index', async () => {
-	const from = {
-		users: singlestoreTable(
-			'table',
-			{
-				name: text('name'),
-			},
-			(t) => {
-				return {
-					idx: index('name_idx').on(t.name),
-				};
-			},
-		),
-	};
-
-	const to = {
-		users: singlestoreTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe('DROP INDEX `name_idx` ON `table`;');
-});
-
-test('add table with indexes', async () => {
-	const from = {};
-
-	const to = {
-		users: singlestoreTable(
-			'users',
-			{
-				id: serial('id').primaryKey(),
-				name: text('name'),
-				email: text('email'),
-			},
-			(t) => ({
-				uniqueExpr: uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
-				indexExpr: index('indexExpr').on(sql`(lower(${t.email}))`),
-				indexExprMultiple: index('indexExprMultiple').on(
-					sql`(lower(${t.email}))`,
-					sql`(lower(${t.email}))`,
-				),
-
-				uniqueCol: uniqueIndex('uniqueCol').on(t.email),
-				indexCol: index('indexCol').on(t.email),
-				indexColMultiple: index('indexColMultiple').on(t.email, t.email),
-
-				indexColExpr: index('indexColExpr').on(
-					sql`(lower(${t.email}))`,
-					t.email,
-				),
-			}),
-		),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements).toStrictEqual([
-		`CREATE TABLE \`users\` (\n\t\`id\` serial AUTO_INCREMENT NOT NULL,\n\t\`name\` text,\n\t\`email\` text,\n\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`),\n\tCONSTRAINT \`uniqueExpr\` UNIQUE((lower(\`email\`))),\n\tCONSTRAINT \`uniqueCol\` UNIQUE(\`email\`)
-);
-`,
-		'CREATE INDEX `indexExpr` ON `users` ((lower(`email`)));',
-		'CREATE INDEX `indexExprMultiple` ON `users` ((lower(`email`)),(lower(`email`)));',
-		'CREATE INDEX `indexCol` ON `users` (`email`);',
-		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`email`);',
-		'CREATE INDEX `indexColExpr` ON `users` ((lower(`email`)),`email`);',
-	]);
-});
-
-test('rename table', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			json: json('json').default([]),
-		}),
-	};
-
-	const to = {
-		table1: singlestoreTable('table1', {
-			json1: json('json').default([]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, [`public.table->public.table1`]);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE `table` RENAME TO `table1`;',
-	);
-});
-
-test('rename column', async () => {
-	const from = {
-		users: singlestoreTable('table', {
-			json: json('json').default([]),
-		}),
-	};
-
-	const to = {
-		users: singlestoreTable('table', {
-			json1: json('json1').default([]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, [`public.table.json->public.table.json1`]);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE `table` CHANGE `json` `json1`;',
-	);
-});
-
-test('change data type', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: text(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('drop not null', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int().notNull(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('set not null', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int().notNull(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int NOT NULL,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('set default with not null column', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int().notNull(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int().notNull().default(1),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int NOT NULL DEFAULT 1,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('drop default with not null column', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int().notNull().default(1),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int().notNull(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int NOT NULL,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('set default', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int().default(1),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE `table` MODIFY COLUMN `id` int DEFAULT 1;',
-	);
-});
-
-test('drop default', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int().default(1),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE `table` MODIFY COLUMN `id` int;',
-	);
-});
-
-test('set pk', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int().primaryKey(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int NOT NULL,
-\t\`age\` int,
-\tCONSTRAINT \`table_id\` PRIMARY KEY(\`id\`)
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('drop pk', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int().primaryKey(),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id: int(),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, []);
-	expect(sqlStatements.length).toBe(4);
-	expect(sqlStatements[0]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id\` int,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[1]).toBe(
-		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[2]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('set not null + rename column on table with indexes', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int('id').default(1),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table: singlestoreTable('table', {
-			id3: int('id3').notNull().default(1),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, [`public.table.id->public.table.id3`]);
-	expect(sqlStatements.length).toBe(5);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE \`table\` CHANGE `id` `id3`;',
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE TABLE \`__new_table\` (
-\t\`id3\` int NOT NULL DEFAULT 1,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[2]).toBe(
-		'INSERT INTO `__new_table`(`id3`, `age`) SELECT `id3`, `age` FROM `table`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'DROP TABLE `table`;',
-	);
-	expect(sqlStatements[4]).toBe(
-		'ALTER TABLE `__new_table` RENAME TO `table`;',
-	);
-});
-
-test('set not null + rename table on table with indexes', async () => {
-	const from = {
-		table: singlestoreTable('table', {
-			id: int('id').default(1),
-			age: int(),
-		}),
-	};
-
-	const to = {
-		table1: singlestoreTable('table1', {
-			id: int('id').notNull().default(1),
-			age: int(),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSingleStore(from, to, [`public.table->public.table1`]);
-	expect(sqlStatements.length).toBe(5);
-	expect(sqlStatements[0]).toBe(
-		'ALTER TABLE `table` RENAME TO `table1`;',
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE TABLE \`__new_table1\` (
-\t\`id\` int NOT NULL DEFAULT 1,
-\t\`age\` int
-);\n`,
-	);
-	expect(sqlStatements[2]).toBe(
-		'INSERT INTO `__new_table1`(\`id\`, \`age\`) SELECT \`id\`, \`age\` FROM `table1`;',
-	);
-	expect(sqlStatements[3]).toBe(
-		'DROP TABLE `table1`;',
-	);
-	expect(sqlStatements[4]).toBe(
-		'ALTER TABLE `__new_table1` RENAME TO `table1`;',
-	);
-});
diff --git a/drizzle-kit/tests/singlestore/mocks.ts b/drizzle-kit/tests/singlestore/mocks.ts
new file mode 100644
index 0000000000..2eca59ece3
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/mocks.ts
@@ -0,0 +1,210 @@
+import { is } from 'drizzle-orm';
+import { SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { mkdirSync, writeFileSync } from 'fs';
+import { Connection, createConnection } from 'mysql2/promise';
+import { suggestions } from 'src/cli/commands/push-mysql';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { configMigrations } from 'src/cli/validations/common';
+import { explain } from 'src/cli/views';
+import { createDDL, interimToDDL } from 'src/dialects/mysql/ddl';
+import { ddlDiff, ddlDiffDry } from 'src/dialects/mysql/diff';
+import { fromDatabaseForDrizzle } from 'src/dialects/mysql/introspect';
+import { ddlToTypeScript } from 'src/dialects/mysql/typescript';
+import { fromDrizzleSchema, prepareFromSchemaFiles } from 'src/dialects/singlestore/drizzle';
+import { DB } from 'src/utils';
+import { mockResolver } from 'src/utils/mocks';
+
+export type SinglestoreSchema = Record<string, SingleStoreTable<any> | SingleStoreSchema>;
+
+export const drizzleToDDL = (sch: SinglestoreSchema) => {
+	const tables = Object.values(sch).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
+	return interimToDDL(fromDrizzleSchema(tables));
+};
+
+export const diff = async (
+	left: SinglestoreSchema,
+	right: SinglestoreSchema,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1 } = drizzleToDDL(left);
+	const { ddl: ddl2 } = drizzleToDDL(right);
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+	return { sqlStatements, statements };
+};
+
+export const pullDiff = async (
+	db: DB,
+	initSchema: SinglestoreSchema,
+	testName: string,
+) => {
+	mkdirSync('tests/mysql/tmp', { recursive: true });
+	const { ddl: initDDL } = drizzleToDDL(initSchema);
+	const { sqlStatements: init } = await ddlDiffDry(createDDL(), initDDL);
+	for (const st of init) await db.query(st);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, 'drizzle', () => true, () => {}, {
+		table: 'drizzle_migrations',
+		schema: 'drizzle',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const filePath = `tests/singlestore/tmp/${testName}.ts`;
+	const file = ddlToTypeScript(ddl1, schema.viewColumns, 'camel', 'singlestore');
+	writeFileSync(filePath, file.file);
+
+	const typeCheckResult = await $`pnpm exec tsc --noEmit --skipLibCheck ${filePath}`.nothrow();
+	if (typeCheckResult.exitCode !== 0) {
+		throw new Error(typeCheckResult.stderr || typeCheckResult.stdout);
+	}
+
+	// generate snapshot from ts file
+	const response = await prepareFromSchemaFiles([filePath]);
+
+	const interim = fromDrizzleSchema(response.tables);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(interim);
+
+	// TODO: handle errors
+	const renames = new Set<string>();
+
+	const {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	} = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	// rmSync(`tests/mysql/tmp/${testName}.ts`);
+
+	return {
+		sqlStatements: afterFileSqlStatements,
+		statements: afterFileStatements,
+	};
+};
+
+export const diffPush = async (config: {
+	db: DB;
+	init: SinglestoreSchema;
+	destination: SinglestoreSchema;
+	renames?: string[];
+	before?: string[];
+	after?: string[];
+	apply?: boolean;
+	migrationsConfig?: {
+		table?: string;
+	};
+}) => {
+	const { db, init: initSchema, destination, before, after, renames: rens } = config;
+	const apply = config.apply ?? true;
+	const { ddl: initDDL } = drizzleToDDL(initSchema);
+	const { sqlStatements: inits } = await ddlDiffDry(createDDL(), initDDL, 'default');
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+
+	const init = [] as string[];
+	if (before) init.push(...before);
+	if (apply) init.push(...inits);
+	if (after) init.push(...after);
+
+	for (const st of init) {
+		await db.query(st);
+	}
+
+	// do introspect into PgSchemaInternal
+	const introspectedSchema = await fromDatabaseForDrizzle(
+		db,
+		'drizzle',
+		undefined,
+		() => {},
+		migrations,
+	);
+
+	const { ddl: ddl1, errors: err3 } = interimToDDL(introspectedSchema);
+	const { ddl: ddl2, errors: err2 } = drizzleToDDL(destination);
+
+	// TODO: handle errors
+
+	const renames = new Set(rens);
+	const { sqlStatements, statements, groupedStatements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const hints = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, ddl2, new HintsHandler()),
+	);
+	const explainMessage = explain('singlestore', groupedStatements, []);
+	if (explainMessage) console.log(explainMessage);
+
+	return { sqlStatements, statements, hints };
+};
+
+export type TestDatabase = {
+	db: DB;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+	client: Connection;
+};
+
+export const prepareTestDatabase = async (): Promise<TestDatabase> => {
+	const url = process.env.MYSQL_CONNECTION_STRING;
+	if (!url) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up singlestore` and export the connection string before running tests (the singlestore mocks read MYSQL_CONNECTION_STRING — swap the .env line per .env.example).',
+		);
+	}
+
+	const sleep = 1000;
+	let timeLeft = 20000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			const client: Connection = await createConnection(url);
+			await client.connect();
+			const db = {
+				query: async (sql: string, params: any[]) => {
+					const [res] = await client.query(sql);
+					return res as any[];
+				},
+			};
+			connected = true;
+			const close = async () => {
+				await client?.end().catch(console.error);
+			};
+			const clear = async () => {
+				await client.query(`drop database if exists \`drizzle\`;`);
+				await client.query(`create database \`drizzle\`;`);
+				await client.query(`use \`drizzle\`;`);
+			};
+			return { db, close, clear, client };
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+
+	throw new Error();
+};
diff --git a/drizzle-kit/tests/singlestore/pull.test.ts b/drizzle-kit/tests/singlestore/pull.test.ts
new file mode 100644
index 0000000000..7dc905b250
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/pull.test.ts
@@ -0,0 +1,215 @@
+import 'dotenv/config';
+import {
+	bigint,
+	char,
+	decimal,
+	double,
+	float,
+	int,
+	mediumint,
+	singlestoreTable,
+	smallint,
+	tinyint,
+	varchar,
+} from 'drizzle-orm/singlestore-core';
+import * as fs from 'fs';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { prepareTestDatabase, pullDiff, TestDatabase } from './mocks';
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+if (!fs.existsSync('tests/singlestore/tmp')) {
+	fs.mkdirSync('tests/singlestore/tmp', { recursive: true });
+}
+
+// TODO: Unskip this test when generated column is implemented
+/* test.skip('generated always column: link to another column', async () => {
+	const schema = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectSingleStoreToFile(
+		db,
+		schema,
+		'generated-link-column',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+}); */
+
+// TODO: Unskip this test when generated column is implemented
+/* test.skip('generated always column virtual: link to another column', async () => {
+	const schema = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs(
+				(): SQL => sql`\`email\``,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await introspectSingleStoreToFile(
+		db,
+		schema,
+		'generated-link-column-virtual',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+}); */
+
+test('Default value of character type column: char', async () => {
+	const schema = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			sortKey: char('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await pullDiff(db, schema, 'default-value-char-column');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('Default value of character type column: varchar', async () => {
+	const schema = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			sortKey: varchar('sortKey', { length: 255 }).default('0'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await pullDiff(db, schema, 'default-value-varchar-column');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// TODO: Unskip this test when views are implemented
+/* test('view #1', async () => {
+	const users = singlestoreTable('users', { id: int('id') });
+	const testView = singlestoreView('some_view', { id: int('id') }).as(
+		sql`select \`drizzle\`.\`users\`.\`id\` AS \`id\` from \`drizzle\`.\`users\``,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await introspectSingleStoreToFile(
+		db,
+		schema,
+		'view-1',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+}); */
+
+// TODO: Unskip this test when views are implemented
+/* test('view #2', async () => {
+	const users = singlestoreTable('some_users', { id: int('id') });
+	const testView = singlestoreView('some_view', { id: int('id') }).algorithm('temptable').sqlSecurity('definer').as(
+		sql`SELECT * FROM ${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+	};
+
+	const { statements, sqlStatements } = await introspectSingleStoreToFile(
+		db,
+		schema,
+		'view-2',
+		'drizzle',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+}); */
+
+test('handle float type', async () => {
+	const schema = {
+		table: singlestoreTable('table', {
+			col1: float(),
+			col2: float({ precision: 2 }),
+			col3: float({ precision: 2, scale: 1 }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await pullDiff(db, schema, 'handle-float-type');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('handle unsigned numerical types', async () => {
+	const schema = {
+		table: singlestoreTable('table', {
+			col1: int({ unsigned: true }),
+			col2: tinyint({ unsigned: true }),
+			col3: smallint({ unsigned: true }),
+			col4: mediumint({ unsigned: true }),
+			col5: bigint({ mode: 'number', unsigned: true }),
+			col6: float({ unsigned: true }),
+			col7: float({ precision: 2, scale: 1, unsigned: true }),
+			col8: double({ unsigned: true }),
+			col9: double({ precision: 2, scale: 1, unsigned: true }),
+			col10: decimal({ unsigned: true }),
+			col11: decimal({ precision: 2, scale: 1, unsigned: true }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await pullDiff(db, schema, 'handle-unsigned-numerical-types');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test('single quote default', async () => {
+	const group = singlestoreTable('group', {
+		id: varchar({ length: 10 }).notNull(),
+		fk_organizaton_group: varchar({ length: 10 }).notNull(),
+		saml_identifier: varchar({ length: 10 }).default('').notNull(),
+		display_name: varchar({ length: 10 }).default('').notNull(),
+	});
+
+	const { sqlStatements } = await pullDiff(
+		db,
+		{ group },
+		'single_quote_default',
+	);
+
+	expect(sqlStatements).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/singlestore/push.test.ts b/drizzle-kit/tests/singlestore/push.test.ts
new file mode 100644
index 0000000000..de8c059344
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/push.test.ts
@@ -0,0 +1,846 @@
+import chalk from 'chalk';
+import {
+	bigint,
+	binary,
+	char,
+	date,
+	decimal,
+	double,
+	float,
+	index,
+	int,
+	mediumint,
+	primaryKey,
+	singlestoreEnum,
+	singlestoreTable,
+	singlestoreTableCreator,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	varbinary,
+	varchar,
+	vector,
+	year,
+} from 'drizzle-orm/singlestore-core';
+import { Connection } from 'mysql2/promise';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { DialectSuite, run } from '../push/common';
+import { diff, diffPush, prepareTestDatabase, TestDatabase } from './mocks';
+
+fs.mkdirSync('./tests/singlestore/migrations', { recursive: true });
+
+let _: TestDatabase;
+let db: DB;
+let client: Connection;
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+	client = _.client;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+const singlestoreSuite: DialectSuite = {
+	allTypes: async function(context: any): Promise<void> {
+		const schema1 = {
+			allBigInts: singlestoreTable('all_big_ints', {
+				simple: bigint('simple', { mode: 'number' }),
+				columnNotNull: bigint('column_not_null', { mode: 'number' }).notNull(),
+				columnDefault: bigint('column_default', { mode: 'number' }).default(12),
+				columnDefaultSql: bigint('column_default_sql', {
+					mode: 'number',
+				}).default(12),
+			}),
+			allBools: singlestoreTable('all_bools', {
+				simple: tinyint('simple'),
+				columnNotNull: tinyint('column_not_null').notNull(),
+				columnDefault: tinyint('column_default').default(1),
+			}),
+			allChars: singlestoreTable('all_chars', {
+				simple: char('simple', { length: 1 }),
+				columnNotNull: char('column_not_null', { length: 45 }).notNull(),
+				// columnDefault: char("column_default", { length: 1 }).default("h"),
+				columnDefaultSql: char('column_default_sql', { length: 1 }).default(
+					'h',
+				),
+			}),
+			//   allDateTimes: singlestoreTable("all_date_times", {
+			//     simple: datetime("simple", { mode: "string", fsp: 1 }),
+			//     columnNotNull: datetime("column_not_null", {
+			//       mode: "string",
+			//     }).notNull(),
+			//     columnDefault: datetime("column_default", { mode: "string" }).default(
+			//       "2023-03-01 14:05:29"
+			//     ),
+			//   }),
+			allDates: singlestoreTable('all_dates', {
+				simple: date('simple', { mode: 'string' }),
+				column_not_null: date('column_not_null', { mode: 'string' }).notNull(),
+				column_default: date('column_default', { mode: 'string' }).default(
+					'2023-03-01',
+				),
+			}),
+			allDecimals: singlestoreTable('all_decimals', {
+				simple: decimal('simple', { precision: 1, scale: 0 }),
+				columnNotNull: decimal('column_not_null', {
+					precision: 45,
+					scale: 3,
+				}).notNull(),
+				columnDefault: decimal('column_default', {
+					precision: 10,
+					scale: 0,
+				}).default('100'),
+				columnDefaultSql: decimal('column_default_sql', {
+					precision: 10,
+					scale: 0,
+				}).default('101'),
+			}),
+
+			allDoubles: singlestoreTable('all_doubles', {
+				simple: double('simple'),
+				columnNotNull: double('column_not_null').notNull(),
+				columnDefault: double('column_default').default(100),
+				columnDefaultSql: double('column_default_sql').default(101),
+			}),
+
+			allEnums: singlestoreTable('all_enums', {
+				simple: singlestoreEnum('simple', ['hi', 'hello']),
+			}),
+
+			allEnums1: singlestoreTable('all_enums1', {
+				simple: singlestoreEnum('simple', ['hi', 'hello']).default('hi'),
+			}),
+
+			allFloats: singlestoreTable('all_floats', {
+				columnNotNull: float('column_not_null').notNull(),
+				columnDefault: float('column_default').default(100),
+				columnDefaultSql: float('column_default_sql').default(101),
+			}),
+
+			allInts: singlestoreTable('all_ints', {
+				simple: int('simple'),
+				columnNotNull: int('column_not_null').notNull(),
+				columnDefault: int('column_default').default(100),
+				columnDefaultSql: int('column_default_sql').default(101),
+			}),
+
+			allIntsRef: singlestoreTable('all_ints_ref', {
+				simple: int('simple'),
+				columnNotNull: int('column_not_null').notNull(),
+				columnDefault: int('column_default').default(100),
+				columnDefaultSql: int('column_default_sql').default(101),
+			}),
+
+			//   allJsons: singlestoreTable("all_jsons", {
+			//     columnDefaultObject: json("column_default_object")
+			//       .default({ hello: "world world" })
+			//       .notNull(),
+			//     columnDefaultArray: json("column_default_array").default({
+			//       hello: { "world world": ["foo", "bar"] },
+			//       foo: "bar",
+			//       fe: 23,
+			//     }),
+			//     column: json("column"),
+			//   }),
+
+			allMInts: singlestoreTable('all_m_ints', {
+				simple: mediumint('simple'),
+				columnNotNull: mediumint('column_not_null').notNull(),
+				columnDefault: mediumint('column_default').default(100),
+				columnDefaultSql: mediumint('column_default_sql').default(101),
+			}),
+
+			allReals: singlestoreTable('all_reals', {
+				simple: double('simple', { precision: 5, scale: 2 }),
+				columnNotNull: double('column_not_null').notNull(),
+				columnDefault: double('column_default').default(100),
+				columnDefaultSql: double('column_default_sql').default(101),
+			}),
+
+			allSInts: singlestoreTable('all_s_ints', {
+				simple: smallint('simple'),
+				columnNotNull: smallint('column_not_null').notNull(),
+				columnDefault: smallint('column_default').default(100),
+				columnDefaultSql: smallint('column_default_sql').default(101),
+			}),
+
+			//   allSmallSerials: singlestoreTable("all_small_serials", {
+			//     columnAll: serial("column_all").notNull(),
+			//   }),
+
+			allTInts: singlestoreTable('all_t_ints', {
+				simple: tinyint('simple'),
+				columnNotNull: tinyint('column_not_null').notNull(),
+				columnDefault: tinyint('column_default').default(10),
+				columnDefaultSql: tinyint('column_default_sql').default(11),
+			}),
+
+			allTexts: singlestoreTable('all_texts', {
+				simple: text('simple'),
+				columnNotNull: text('column_not_null').notNull(),
+				columnDefault: text('column_default').default('hello'),
+				columnDefaultSql: text('column_default_sql').default('hello'),
+			}),
+
+			allTimes: singlestoreTable('all_times', {
+				// simple: time("simple", { fsp: 1 }),
+				columnNotNull: time('column_not_null').notNull(),
+				columnDefault: time('column_default').default('22:12:12'),
+			}),
+
+			allTimestamps: singlestoreTable('all_timestamps', {
+				// columnDateNow: timestamp("column_date_now", {
+				//   fsp: 1,
+				//   mode: "string",
+				// }).default(sql`(now())`),
+				columnAll: timestamp('column_all', { mode: 'string' })
+					.default('2023-03-01 14:05:29')
+					.notNull(),
+				column: timestamp('column', { mode: 'string' }).default(
+					'2023-02-28 16:18:31',
+				),
+			}),
+
+			allVarChars: singlestoreTable('all_var_chars', {
+				simple: varchar('simple', { length: 100 }),
+				columnNotNull: varchar('column_not_null', { length: 45 }).notNull(),
+				columnDefault: varchar('column_default', { length: 100 }).default(
+					'hello',
+				),
+				columnDefaultSql: varchar('column_default_sql', {
+					length: 100,
+				}).default('hello'),
+			}),
+
+			allVarbinaries: singlestoreTable('all_varbinaries', {
+				simple: varbinary('simple', { length: 100 }),
+				columnNotNull: varbinary('column_not_null', { length: 100 }).notNull(),
+				columnDefault: varbinary('column_default', { length: 12 }),
+			}),
+
+			allYears: singlestoreTable('all_years', {
+				simple: year('simple'),
+				columnNotNull: year('column_not_null').notNull(),
+				columnDefault: year('column_default').default(2022),
+			}),
+
+			binafry: singlestoreTable('binary', {
+				simple: binary('simple', { length: 1 }),
+				columnNotNull: binary('column_not_null', { length: 1 }).notNull(),
+				columnDefault: binary('column_default', { length: 12 }),
+			}),
+
+			allVectors: singlestoreTable('all_vectors', {
+				vectorSimple: vector('vector_simple', { dimensions: 1 }),
+				vectorElementType: vector('vector_element_type', { dimensions: 1, elementType: 'I8' }),
+				vectorNotNull: vector('vector_not_null', { dimensions: 1 }).notNull(),
+				vectorDefault: vector('vector_default', { dimensions: 1 }).default([1]),
+			}),
+		};
+
+		const { sqlStatements } = await diffPush({ db, init: schema1, destination: schema1 });
+		expect(sqlStatements).toStrictEqual([]);
+	},
+	addBasicIndexes: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	changeIndexFields: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	dropIndex: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	indexesToBeNotTriggered: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	indexesTestCase1: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	async case1() {
+		// TODO: implement if needed
+		expect(true).toBe(true);
+	},
+	addNotNull: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	addNotNullWithDataNoRollback: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	addBasicSequences: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	addGeneratedColumn: async function(context: any): Promise<void> {
+		return {} as any;
+	},
+	addGeneratedToColumn: async function(context: any): Promise<void> {
+		return {} as any;
+	},
+	dropGeneratedConstraint: async function(context: any): Promise<void> {
+		return {} as any;
+	},
+	alterGeneratedConstraint: async function(context: any): Promise<void> {
+		return {} as any;
+	},
+	createTableWithGeneratedConstraint: function(context?: any): Promise<void> {
+		return {} as any;
+	},
+	createCompositePrimaryKey: async function(context: any): Promise<void> {
+		const schema1 = {};
+
+		const schema2 = {
+			table: singlestoreTable('table', {
+				col1: int('col1').notNull(),
+				col2: int('col2').notNull(),
+			}, (t) => [primaryKey({
+				columns: [t.col1, t.col2],
+			})]),
+		};
+
+		const { sqlStatements } = await diffPush({ db, init: schema1, destination: schema2 });
+
+		expect(sqlStatements).toStrictEqual([
+			'CREATE TABLE `table` (\n\t`col1` int NOT NULL,\n\t`col2` int NOT NULL,\n\tCONSTRAINT `table_col1_col2_pk` PRIMARY KEY(`col1`,`col2`)\n);\n',
+		]);
+	},
+	renameTableWithCompositePrimaryKey: async function(context?: any): Promise<void> {
+		const productsCategoriesTable = (tableName: string) => {
+			return singlestoreTable(tableName, {
+				productId: varchar('product_id', { length: 10 }).notNull(),
+				categoryId: varchar('category_id', { length: 10 }).notNull(),
+			}, (t) => [primaryKey({
+				columns: [t.productId, t.categoryId],
+			})]);
+		};
+
+		const schema1 = {
+			table: productsCategoriesTable('products_categories'),
+		};
+		const schema2 = {
+			test: productsCategoriesTable('products_to_categories'),
+		};
+
+		const { sqlStatements } = await diffPush({
+			db,
+			init: schema1,
+			destination: schema2,
+			renames: ['products_categories->products_to_categories'],
+		});
+
+		// It's not possible to create/alter/drop primary keys in SingleStore
+		expect(sqlStatements).toStrictEqual([
+			'ALTER TABLE `products_categories` RENAME TO `products_to_categories`;',
+		]);
+	},
+};
+
+run(singlestoreSuite);
+
+test('db has checks. Push with same names', async () => {
+	const schema1 = {
+		test: singlestoreTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}),
+	};
+	const schema2 = {
+		test: singlestoreTable('test', {
+			id: int('id').primaryKey(),
+			values: int('values').default(1),
+		}),
+	};
+
+	const { sqlStatements } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema2,
+	});
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// TODO: Unskip this test when views are implemented
+/* test.skip.skip('create view', async () => {
+	const table = singlestoreTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: singlestoreView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
+		client,
+		schema1,
+		schema2,
+		[],
+		'drizzle',
+		false,
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			definition: 'select `id` from `test`',
+			name: 'view',
+			type: 'singlestore_create_view',
+			replace: false,
+			sqlSecurity: 'definer',
+			withCheckOption: undefined,
+			algorithm: 'undefined',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE ALGORITHM = undefined
+SQL SECURITY definer
+VIEW \`view\` AS (select \`id\` from \`test\`);`,
+	]);
+
+	await client.query(`DROP TABLE \`test\`;`);
+}); */
+
+// TODO: Unskip this test when views are implemented
+/* test.skip('drop view', async () => {
+	const table = singlestoreTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: singlestoreView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
+		client,
+		schema1,
+		schema2,
+		[],
+		'drizzle',
+		false,
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			name: 'view',
+			type: 'drop_view',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual(['DROP VIEW `view`;']);
+	await client.query(`DROP TABLE \`test\`;`);
+	await client.query(`DROP VIEW \`view\`;`);
+}); */
+
+// TODO: Unskip this test when views are implemented
+/* test.skip('alter view ".as"', async () => {
+	const table = singlestoreTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: singlestoreView('view').as((qb) =>
+			qb
+				.select()
+				.from(table)
+				.where(sql`${table.id} = 1`)
+		),
+	};
+
+	const schema2 = {
+		test: table,
+		view: singlestoreView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSingleStore(
+		client,
+		schema1,
+		schema2,
+		[],
+		'drizzle',
+		false,
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+
+	await client.query(`DROP TABLE \`test\`;`);
+	await client.query(`DROP VIEW \`view\`;`);
+}); */
+
+// TODO: Unskip this test when views are implemented
+/* test.skip('alter meta options with distinct in definition', async () => {
+	const table = singlestoreTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: singlestoreView('view')
+			.withCheckOption('cascaded')
+			.sqlSecurity('definer')
+			.algorithm('merge')
+			.as((qb) =>
+				qb
+					.selectDistinct()
+					.from(table)
+					.where(sql`${table.id} = 1`)
+			),
+	};
+
+	const schema2 = {
+		test: table,
+		view: singlestoreView('view')
+			.withCheckOption('cascaded')
+			.sqlSecurity('definer')
+			.algorithm('undefined')
+			.as((qb) => qb.selectDistinct().from(table)),
+	};
+
+	await expect(
+		diffTestSchemasPushSingleStore(
+			client,
+			schema1,
+			schema2,
+			[],
+			'drizzle',
+			false,
+		),
+	).rejects.toThrowError();
+
+	await client.query(`DROP TABLE \`test\`;`);
+}); */
+
+test('added column not null and without default to table with data', async (t) => {
+	const schema1 = {
+		companies: singlestoreTable('companies', {
+			id: int('id'),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		companies: singlestoreTable('companies', {
+			id: int('id'),
+			name: text('name'),
+			age: int('age').notNull(),
+		}),
+	};
+
+	const { sqlStatements } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema2,
+		after: [`INSERT INTO \`companies\` (\`name\`) VALUES ('drizzle'), ('turso');`],
+	});
+
+	expect(sqlStatements).toStrictEqual([
+		`truncate table companies;`,
+		`ALTER TABLE \`companies\` ADD \`age\` int NOT NULL;`,
+	]);
+});
+
+test('added column not null and without default to table without data', async (t) => {
+	const schema1 = {
+		companies: singlestoreTable('companies', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		companies: singlestoreTable('companies', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			age: int('age').notNull(),
+		}),
+	};
+
+	const { sqlStatements } = await diffPush({ db, init: schema1, destination: schema2 });
+
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE \`companies\` ADD \`age\` int NOT NULL;`,
+	]);
+});
+
+test('drop not null, add not null', async (t) => {
+	const schema1 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+		posts: singlestoreTable(
+			'posts',
+			{
+				id: int('id').primaryKey(),
+				name: text('name'),
+				userId: int('user_id'),
+			},
+		),
+	};
+
+	const schema2 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+		posts: singlestoreTable(
+			'posts',
+			{
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+				userId: int('user_id'),
+			},
+		),
+	};
+	const { sqlStatements } = await diffPush({ db, init: schema1, destination: schema2 });
+
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_posts\` (
+\t\`id\` int NOT NULL,
+\t\`name\` text NOT NULL,
+\t\`user_id\` int,
+\tCONSTRAINT \`posts_id\` PRIMARY KEY(\`id\`)
+);\n`,
+		`INSERT INTO \`__new_posts\`(\`id\`, \`name\`, \`user_id\`) SELECT \`id\`, \`name\`, \`user_id\` FROM \`posts\`;`,
+		`DROP TABLE \`posts\`;`,
+		`ALTER TABLE \`__new_posts\` RENAME TO \`posts\`;`,
+
+		`CREATE TABLE \`__new_users\` (
+\t\`id\` int NOT NULL,
+\t\`name\` text,
+\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
+);\n`,
+		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
+		`DROP TABLE \`users\`;`,
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	]);
+});
+
+test('drop table with data', async (t) => {
+	const schema1 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+		posts: singlestoreTable(
+			'posts',
+			{
+				id: int('id').primaryKey(),
+				name: text('name'),
+				userId: int('user_id'),
+			},
+		),
+	};
+
+	const schema2 = {
+		posts: singlestoreTable(
+			'posts',
+			{
+				id: int('id').primaryKey(),
+				name: text('name'),
+				userId: int('user_id'),
+			},
+		),
+	};
+
+	const { sqlStatements, hints } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema2,
+		after: [`INSERT INTO \`users\` (\`id\`, \`name\`) VALUES (1, 'drizzle')`],
+	});
+
+	expect(sqlStatements).toStrictEqual([`DROP TABLE \`users\`;`]);
+	expect(hints).toStrictEqual([{ hint: `You're about to delete ${chalk.underline('users')} table with 1 items` }]);
+});
+
+test('change data type. db has indexes. table does not have values', async (t) => {
+	const schema1 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: int('name').notNull(),
+		}, (table) => [index('index').on(table.name)]),
+	};
+
+	const schema2 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}, (table) => [index('index').on(table.name)]),
+	};
+
+	const { sqlStatements } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema2,
+		after: [`INSERT INTO users VALUES (1, 12)`],
+	});
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_users\` (
+\t\`id\` int NOT NULL,
+\t\`name\` text NOT NULL,
+\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
+);\n`,
+		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
+		`DROP TABLE \`users\`;`,
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+		`CREATE INDEX \`index\` ON \`users\` (\`name\`);`,
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4474
+test('no second creation of index', async (t) => {
+	const createTable = singlestoreTableCreator((name) => `drive_tutorial_${name}`);
+
+	const files_table = createTable('files_table', {
+		id: bigint('id', { mode: 'bigint' }).primaryKey().autoincrement(),
+		parent: bigint('parent', { mode: 'bigint' }).notNull(),
+	}, (t) => {
+		return [
+			index('parent_folder_index').on(t.parent),
+		];
+	});
+
+	const schema1 = { files_table };
+	const { sqlStatements } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema1,
+	});
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('change data type. db has indexes. table has values', async (t) => {
+	const schema1 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: int('name'),
+		}, (table) => [index('index').on(table.name)]),
+	};
+
+	const schema2 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}, (table) => [index('index').on(table.name)]),
+	};
+
+	const { sqlStatements, hints } = await diffPush({
+		db,
+		init: schema1,
+		destination: schema2,
+		after: [`INSERT INTO users VALUES (1, 12);`, `INSERT INTO users (id) VALUES (2);`],
+	});
+
+	expect(sqlStatements).toStrictEqual([
+		`TRUNCATE TABLE \`users\`;`,
+		`CREATE TABLE \`__new_users\` (
+\t\`id\` int NOT NULL,
+\t\`name\` text,
+\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
+);\n`,
+
+		`INSERT INTO \`__new_users\`(\`id\`, \`name\`) SELECT \`id\`, \`name\` FROM \`users\`;`,
+		`DROP TABLE \`users\`;`,
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+		`CREATE INDEX \`index\` ON \`users\` (\`name\`);`,
+	]);
+	expect(hints).toStrictEqual([
+		{
+			hint: `You're about recreate ${chalk.underline('users')} table with data type changing for ${
+				chalk.underline('name')
+			} column, which contains 1 items`,
+		},
+	]);
+});
+
+test('add column. add default to column without not null', async (t) => {
+	const schema1 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: singlestoreTable('users', {
+			id: int('id').primaryKey(),
+			name: text('name').default('drizzle'),
+			age: int('age'),
+		}),
+	};
+	const { sqlStatements, hints } = await diffPush({ db, init: schema1, destination: schema2 });
+
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE \`users\` MODIFY COLUMN \`name\` text DEFAULT 'drizzle';`,
+		`ALTER TABLE \`users\` ADD \`age\` int;`,
+	]);
+});
+
+test('push after migrate with custom migrations table #1', async () => {
+	const migrationsConfig = {
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/singlestore/migrator');
+	const { drizzle } = await import('drizzle-orm/singlestore');
+
+	await migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/singlestore/migrations',
+	});
+
+	const to = {
+		table: singlestoreTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await diffPush({ db, init: {}, destination: to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('push after migrate with custom migrations table #2', async () => {
+	const migrationsConfig = {
+		table: 'migrations',
+	};
+	const { migrate } = await import('drizzle-orm/singlestore/migrator');
+	const { drizzle } = await import('drizzle-orm/singlestore');
+
+	await migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/singlestore/migrations',
+	});
+
+	const to = {
+		table: singlestoreTable('table1', { col1: int() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await diffPush({ db, init: {}, destination: to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` int\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
diff --git a/drizzle-kit/tests/singlestore/singlestore-generated.test.ts b/drizzle-kit/tests/singlestore/singlestore-generated.test.ts
new file mode 100644
index 0000000000..c64512437a
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/singlestore-generated.test.ts
@@ -0,0 +1,756 @@
+import { SQL, sql } from 'drizzle-orm';
+import { int, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { expect, test } from 'vitest';
+import { diff } from './mocks';
+
+test('generated as callback: add column with generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
+	]);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
+	]);
+});
+
+test('generated as callback: drop generated constraint as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
+	]);
+});
+
+test('generated as callback: drop generated constraint as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as callback: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as callback: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
+
+test('generated as callback: change generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
+
+// ---
+
+test('generated as sql: add column with generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
+	]);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
+	]);
+});
+
+test('generated as sql: drop generated constraint as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
+	]);
+});
+
+test('generated as sql: drop generated constraint as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as sql: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as sql: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
+
+test('generated as sql: change generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\``,
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
+
+// ---
+
+test('generated as string: add column with generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as string: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		"ALTER TABLE `users` MODIFY COLUMN `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') STORED;",
+	]);
+});
+
+test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`\`users\`.\`name\` || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text NOT NULL GENERATED ALWAYS AS (`users`.`name` || 'to add') VIRTUAL;",
+	]);
+});
+
+test('generated as string: drop generated constraint as stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` MODIFY COLUMN `gen_name` text;',
+	]);
+});
+
+test('generated as string: drop generated constraint as virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as string: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') STORED;",
+	]);
+});
+
+test('generated as string: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
+
+test('generated as string: change generated constraint', async () => {
+	const from = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`\`users\`.\`name\``),
+		}),
+	};
+	const to = {
+		users: singlestoreTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`\`users\`.\`name\` || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements } = await diff(
+		from,
+		to,
+		[],
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` drop column `gen_name`;',
+		"ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (`users`.`name` || 'hello') VIRTUAL;",
+	]);
+});
diff --git a/drizzle-kit/tests/singlestore/singlestore-schemas.test.ts b/drizzle-kit/tests/singlestore/singlestore-schemas.test.ts
new file mode 100644
index 0000000000..5ed140418a
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/singlestore-schemas.test.ts
@@ -0,0 +1,155 @@
+import { singlestoreSchema, singlestoreTable } from 'drizzle-orm/singlestore-core';
+import { expect, test } from 'vitest';
+import { diff } from './mocks';
+
+// We don't manage databases(schemas) in MySQL with Drizzle Kit
+test('add schema #1', async () => {
+	const to = {
+		devSchema: singlestoreSchema('dev'),
+	};
+
+	const { statements } = await diff({}, to, []);
+
+	expect(statements.length).toBe(0);
+});
+
+test('add schema #2', async () => {
+	const from = {
+		devSchema: singlestoreSchema('dev'),
+	};
+	const to = {
+		devSchema: singlestoreSchema('dev'),
+		devSchema2: singlestoreSchema('dev2'),
+	};
+
+	const { statements } = await diff(from, to, []);
+
+	expect(statements.length).toBe(0);
+});
+
+test('delete schema #1', async () => {
+	const from = {
+		devSchema: singlestoreSchema('dev'),
+	};
+
+	const { statements } = await diff(from, {}, []);
+
+	expect(statements.length).toBe(0);
+});
+
+test('delete schema #2', async () => {
+	const from = {
+		devSchema: singlestoreSchema('dev'),
+		devSchema2: singlestoreSchema('dev2'),
+	};
+	const to = {
+		devSchema: singlestoreSchema('dev'),
+	};
+
+	const { statements } = await diff(from, to, []);
+
+	expect(statements.length).toBe(0);
+});
+
+test('rename schema #1', async () => {
+	const from = {
+		devSchema: singlestoreSchema('dev'),
+	};
+	const to = {
+		devSchema2: singlestoreSchema('dev2'),
+	};
+
+	const { statements } = await diff(from, to, ['dev->dev2']);
+
+	expect(statements.length).toBe(0);
+});
+
+test('rename schema #2', async () => {
+	const from = {
+		devSchema: singlestoreSchema('dev'),
+		devSchema1: singlestoreSchema('dev1'),
+	};
+	const to = {
+		devSchema: singlestoreSchema('dev'),
+		devSchema2: singlestoreSchema('dev2'),
+	};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(0);
+});
+
+test('add table to schema #1', async () => {
+	const dev = singlestoreSchema('dev');
+	const from = {};
+	const to = {
+		dev,
+		users: dev.table('users', {}),
+	};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(0);
+});
+
+test('add table to schema #2', async () => {
+	const dev = singlestoreSchema('dev');
+	const from = { dev };
+	const to = {
+		dev,
+		users: dev.table('users', {}),
+	};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(0);
+});
+
+test('add table to schema #3', async () => {
+	const dev = singlestoreSchema('dev');
+	const from = { dev };
+	const to = {
+		dev,
+		usersInDev: dev.table('users', {}),
+		users: singlestoreTable('users', {}),
+	};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'create_table',
+		tableName: 'users',
+		schema: undefined,
+		columns: [],
+		uniqueConstraints: [],
+		internals: {
+			tables: {},
+			indexes: {},
+		},
+		compositePkName: '',
+		compositePKs: [],
+	});
+});
+
+test('remove table from schema #1', async () => {
+	const dev = singlestoreSchema('dev');
+	const from = { dev, users: dev.table('users', {}) };
+	const to = {
+		dev,
+	};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(0);
+});
+
+test('remove table from schema #2', async () => {
+	const dev = singlestoreSchema('dev');
+	const from = { dev, users: dev.table('users', {}) };
+	const to = {};
+
+	const { statements } = await diff(from, to, ['dev1->dev2']);
+
+	expect(statements.length).toBe(0);
+});
diff --git a/drizzle-kit/tests/singlestore/singlestore.test.ts b/drizzle-kit/tests/singlestore/singlestore.test.ts
new file mode 100644
index 0000000000..ab247afb60
--- /dev/null
+++ b/drizzle-kit/tests/singlestore/singlestore.test.ts
@@ -0,0 +1,786 @@
+import { sql } from 'drizzle-orm';
+import {
+	index,
+	int,
+	json,
+	primaryKey,
+	serial,
+	singlestoreSchema,
+	singlestoreTable,
+	text,
+	uniqueIndex,
+} from 'drizzle-orm/singlestore-core';
+import { expect, test } from 'vitest';
+import { diff } from './mocks';
+
+test('add table #1', async () => {
+	const to = {
+		users: singlestoreTable('users', {}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #2', async () => {
+	const to = {
+		users: singlestoreTable('users', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #3', async () => {
+	const to = {
+		users: singlestoreTable('users', {
+			id: serial('id'),
+		}, (t) => [primaryKey({
+			name: 'users_pk',
+			columns: [t.id],
+		})]),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #4', async () => {
+	const to = {
+		users: singlestoreTable('users', {}),
+		posts: singlestoreTable('posts', {}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #5', async () => {
+	const schema = singlestoreSchema('folder');
+	const from = {
+		schema,
+	};
+
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('add table #6', async () => {
+	const from = {
+		users1: singlestoreTable('users1', {}),
+	};
+
+	const to = {
+		users2: singlestoreTable('users2', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #7', async () => {
+	const from = {
+		users1: singlestoreTable('users1', {}),
+	};
+
+	const to = {
+		users: singlestoreTable('users', {}),
+		users2: singlestoreTable('users2', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'users1->users2',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add schema + table #1', async () => {
+	const schema = singlestoreSchema('folder');
+
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('change schema with tables #1', async () => {
+	const schema = singlestoreSchema('folder');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder->folder2',
+	]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('change table schema #1', async () => {
+	const schema = singlestoreSchema('folder');
+	const from = {
+		schema,
+		users: singlestoreTable('users', {}),
+	};
+	const to = {
+		schema,
+		users: schema.table('users', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'users->folder.users',
+	]);
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #2', async () => {
+	const schema = singlestoreSchema('folder');
+	const from = {
+		schema,
+		users: schema.table('users', {}),
+	};
+	const to = {
+		schema,
+		users: singlestoreTable('users', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder.users->users',
+	]);
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #3', async () => {
+	const schema1 = singlestoreSchema('folder1');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users', {}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #4', async () => {
+	const schema1 = singlestoreSchema('folder1');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = singlestoreSchema('folder1');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema1, // remove schema
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // add schema
+		users: schema2.table('users', {}), // move table
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder1.users->folder2.users',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #5', async () => {
+	const schema1 = singlestoreSchema('folder1');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema1,
+		schema2,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema1,
+		schema2,
+		users: schema2.table('users2', {}), // rename and move table
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder1.users->folder2.users2',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('change table schema #6', async () => {
+	const schema1 = singlestoreSchema('folder1');
+	const schema2 = singlestoreSchema('folder2');
+	const from = {
+		schema1,
+		users: schema1.table('users', {}),
+	};
+	const to = {
+		schema2, // rename schema
+		users: schema2.table('users2', {}), // rename table
+	};
+
+	const { sqlStatements } = await diff(from, to, [
+		'folder1->folder2',
+		'folder2.users->folder2.users2',
+	]);
+
+	expect(sqlStatements).toStrictEqual(['']);
+});
+
+test('add table #10', async () => {
+	const to = {
+		users: singlestoreTable('table', {
+			json: json('json').default({}),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT '{}'\n);\n",
+	);
+});
+
+test('add table #11', async () => {
+	const to = {
+		users: singlestoreTable('table', {
+			json: json('json').default([]),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT '[]'\n);\n",
+	);
+});
+
+test('add table #12', async () => {
+	const to = {
+		users: singlestoreTable('table', {
+			json: json('json').default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		"CREATE TABLE `table` (\n\t`json` json DEFAULT '[1,2,3]'\n);\n",
+	);
+});
+
+test('add table #13', async () => {
+	const to = {
+		users: singlestoreTable('table', {
+			json: json('json').default({ key: 'value' }),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `table` (\n\t`json` json DEFAULT \'{"key":"value"}\'\n);\n',
+	]);
+});
+
+test('add table #14', async () => {
+	const to = {
+		users: singlestoreTable('table', {
+			json: json('json').default({
+				key: 'value',
+				arr: [1, 2, 3],
+			}),
+		}),
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `table` (\n\t`json` json DEFAULT \'{"key":"value","arr":[1,2,3]}\'\n);\n',
+	]);
+});
+
+// TODO: add bson type tests
+
+// TODO: add blob type tests
+
+// TODO: add uuid type tests
+
+// TODO: add guid type tests
+
+// TODO: add vector type tests
+
+// TODO: add geopoint type tests
+
+test('drop index', async () => {
+	const from = {
+		users: singlestoreTable(
+			'table',
+			{
+				name: text('name'),
+			},
+			(t) => [index('name_idx').on(t.name)],
+		),
+	};
+
+	const to = {
+		users: singlestoreTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'DROP INDEX `name_idx` ON `table`;',
+	]);
+});
+
+test('add table with indexes', async () => {
+	const from = {};
+
+	const to = {
+		users: singlestoreTable(
+			'users',
+			{
+				id: serial('id').primaryKey(),
+				name: text('name'),
+				email: text('email'),
+			},
+			(t) => [
+				uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
+				index('indexExpr').on(sql`(lower(${t.email}))`),
+				index('indexExprMultiple').on(
+					sql`(lower(${t.email}))`,
+					sql`(lower(${t.email}))`,
+				),
+
+				uniqueIndex('uniqueCol').on(t.email),
+				index('indexCol').on(t.email),
+				index('indexColMultiple').on(t.email, t.email),
+
+				index('indexColExpr').on(
+					sql`(lower(${t.email}))`,
+					t.email,
+				),
+			],
+		),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`users\` (\n\t\`id\` serial AUTO_INCREMENT NOT NULL,\n\t\`name\` text,\n\t\`email\` text,\n\tCONSTRAINT \`users_id\` PRIMARY KEY(\`id\`),\n\tCONSTRAINT \`uniqueExpr\` UNIQUE((lower(\`email\`))),\n\tCONSTRAINT \`uniqueCol\` UNIQUE(\`email\`)
+);
+`,
+		'CREATE INDEX `indexExpr` ON `users` ((lower(`email`)));',
+		'CREATE INDEX `indexExprMultiple` ON `users` ((lower(`email`)),(lower(`email`)));',
+		'CREATE INDEX `indexCol` ON `users` (`email`);',
+		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`email`);',
+		'CREATE INDEX `indexColExpr` ON `users` ((lower(`email`)),`email`);',
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3255
+test('index #1', async () => {
+	const table1 = singlestoreTable('table1', {
+		col1: int(),
+		col2: int(),
+	}, () => [
+		index1,
+		index2,
+		index3,
+		index4,
+		index5,
+		index6,
+	]);
+
+	const index1 = uniqueIndex('index1').on(table1.col1);
+	const index2 = uniqueIndex('index2').on(table1.col1, table1.col2);
+	const index3 = index('index3').on(table1.col1);
+	const index4 = index('index4').on(table1.col1, table1.col2);
+	const index5 = index('index5').on(sql`${table1.col1} asc`);
+	const index6 = index('index6').on(sql`${table1.col1} asc`, sql`${table1.col2} desc`);
+
+	const schema1 = { table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n'
+		+ '\t`col1` int,\n'
+		+ '\t`col2` int,\n'
+		+ '\tCONSTRAINT `index1` UNIQUE INDEX(`col1`),\n'
+		+ '\tCONSTRAINT `index2` UNIQUE INDEX(`col1`,`col2`)\n'
+		+ ');\n',
+		'CREATE INDEX `index3` ON `table1` (`col1`);',
+		'CREATE INDEX `index4` ON `table1` (`col1`,`col2`);',
+		'CREATE INDEX `index5` ON `table1` (`col1` asc);',
+		'CREATE INDEX `index6` ON `table1` (`col1` asc,`col2` desc);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+});
+
+test('rename table', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			json: json('json').default([]),
+		}),
+	};
+
+	const to = {
+		table1: singlestoreTable('table1', {
+			json1: json('json').default([]),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [`table->table1`]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `table` RENAME TO `table1`;',
+	]);
+});
+
+test('rename column', async () => {
+	const from = {
+		users: singlestoreTable('table', {
+			json: json('json').default([]),
+		}),
+	};
+
+	const to = {
+		users: singlestoreTable('table', {
+			json1: json('json1').default([]),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [`table.json->table.json1`]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `table` CHANGE `json` `json1`;',
+	]);
+});
+
+test('change data type', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: text(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('drop not null', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int().notNull(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('set not null', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int().notNull(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int NOT NULL,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('set default with not null column', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int().notNull(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int().notNull().default(1),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int NOT NULL DEFAULT 1,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('drop default with not null column', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int().notNull().default(1),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int().notNull(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int NOT NULL,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('set default', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int().default(1),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `table` MODIFY COLUMN `id` int DEFAULT 1;',
+	]);
+});
+
+test('drop default', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int().default(1),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `table` MODIFY COLUMN `id` int;',
+	]);
+});
+
+test('set pk', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int().primaryKey(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int NOT NULL,
+\t\`age\` int,
+\tCONSTRAINT \`table_id\` PRIMARY KEY(\`id\`)
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('drop pk', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int().primaryKey(),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id: int(),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, []);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE TABLE \`__new_table\` (
+\t\`id\` int,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table`(`id`, `age`) SELECT `id`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('set not null + rename column on table with indexes', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int('id').default(1),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table: singlestoreTable('table', {
+			id3: int('id3').notNull().default(1),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [`table.id->table.id3`]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE \`table\` CHANGE `id` `id3`;',
+		`CREATE TABLE \`__new_table\` (
+			\t\`id3\` int NOT NULL DEFAULT 1,
+			\t\`age\` int
+			);\n`,
+		'INSERT INTO `__new_table`(`id3`, `age`) SELECT `id3`, `age` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+	]);
+});
+
+test('set not null + rename table on table with indexes', async () => {
+	const from = {
+		table: singlestoreTable('table', {
+			id: int('id').default(1),
+			age: int(),
+		}),
+	};
+
+	const to = {
+		table1: singlestoreTable('table1', {
+			id: int('id').notNull().default(1),
+			age: int(),
+		}),
+	};
+
+	const { sqlStatements } = await diff(from, to, [`table->table1`]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `table` RENAME TO `table1`;',
+		`CREATE TABLE \`__new_table1\` (
+\t\`id\` int NOT NULL DEFAULT 1,
+\t\`age\` int
+);\n`,
+		'INSERT INTO `__new_table1`(\`id\`, \`age\`) SELECT \`id\`, \`age\` FROM `table1`;',
+		'DROP TABLE `table1`;',
+		'ALTER TABLE `__new_table1` RENAME TO `table1`;',
+	]);
+});
diff --git a/drizzle-kit/tests/sqlite-checks.test.ts b/drizzle-kit/tests/sqlite-checks.test.ts
deleted file mode 100644
index d1824e441b..0000000000
--- a/drizzle-kit/tests/sqlite-checks.test.ts
+++ /dev/null
@@ -1,308 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { check, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSqlite } from './schemaDiffer';
-
-test('create table with check', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				notNull: true,
-				primaryKey: true,
-				autoincrement: false,
-			},
-			{
-				name: 'age',
-				type: 'integer',
-				notNull: false,
-				primaryKey: false,
-				autoincrement: false,
-			},
-		],
-		compositePKs: [],
-		checkConstraints: ['some_check_name;"users"."age" > 21'],
-		referenceData: [],
-		uniqueConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("users"."age" > 21)
-);\n`);
-});
-
-test('add check contraint to existing table', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: ['some_check_name;"users"."age" > 21'],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('drop check contraint to existing table', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('new_some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [`new_some_check_name;"users"."age" > 21`],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "new_some_check_name" CHECK("__new_users"."age" > 21)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('rename check constraint', async (t) => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 21`),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-		}, (table) => ({
-			checkConstraint: check('some_check_name', sql`${table.age} > 10`),
-		})),
-	};
-
-	const { sqlStatements, statements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [`some_check_name;"users"."age" > 10`],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`age\` integer,
-\tCONSTRAINT "some_check_name" CHECK("__new_users"."age" > 10)
-);\n`);
-	expect(sqlStatements[2]).toBe(`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('create checks with same names', async (t) => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey(),
-			age: int('age'),
-			name: text('name'),
-		}, (table) => ({
-			checkConstraint1: check('some_check_name', sql`${table.age} > 21`),
-			checkConstraint2: check('some_check_name', sql`${table.name} != 'Alex'`),
-		})),
-	};
-
-	await expect(diffTestSchemasSqlite({}, to, [])).rejects.toThrowError();
-});
diff --git a/drizzle-kit/tests/sqlite-columns.test.ts b/drizzle-kit/tests/sqlite-columns.test.ts
deleted file mode 100644
index 0cb34c220c..0000000000
--- a/drizzle-kit/tests/sqlite-columns.test.ts
+++ /dev/null
@@ -1,1049 +0,0 @@
-import {
-	AnySQLiteColumn,
-	foreignKey,
-	index,
-	int,
-	integer,
-	primaryKey,
-	sqliteTable,
-	text,
-} from 'drizzle-orm/sqlite-core';
-import { JsonCreateIndexStatement, JsonRecreateTableStatement } from 'src/jsonStatements';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSqlite } from './schemaDiffer';
-
-test('create table with id', async (t) => {
-	const schema = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, schema, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				type: 'integer',
-				primaryKey: true,
-				notNull: true,
-				autoincrement: true,
-			},
-		],
-		uniqueConstraints: [],
-		referenceData: [],
-		compositePKs: [],
-		checkConstraints: [],
-	});
-});
-
-test('add columns #1', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name',
-			type: 'text',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-	});
-});
-
-test('add columns #2', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			email: text('email'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name',
-			type: 'text',
-			primaryKey: false,
-			notNull: false,
-			autoincrement: false, // TODO: add column has autoincrement???
-		},
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'email',
-			type: 'text',
-			primaryKey: false,
-			notNull: false,
-			autoincrement: false,
-		},
-	});
-});
-
-test('add columns #3', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name1: text('name1').default('name'),
-			name2: text('name2').notNull(),
-			name3: text('name3').default('name').notNull(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(3);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name1',
-			type: 'text',
-			primaryKey: false,
-			notNull: false,
-			autoincrement: false, // TODO: add column has autoincrement???
-			default: "'name'",
-		},
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name2',
-			type: 'text',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false, // TODO: add column has autoincrement???
-		},
-	});
-	expect(statements[2]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name3',
-			type: 'text',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false, // TODO: add column has autoincrement???
-			default: "'name'",
-		},
-	});
-});
-
-test('add columns #4', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name', { enum: ['one', 'two'] }),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'name',
-			type: 'text',
-			primaryKey: false,
-			notNull: false,
-			autoincrement: false,
-		},
-	});
-});
-
-test('add columns #5', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
-	});
-
-	const schema2 = {
-		users,
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	// TODO: Fix here
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: 'users_report_to_users_id_fk;users;report_to;users;id;no action;no action',
-		column: {
-			name: 'report_to',
-			type: 'integer',
-			primaryKey: false,
-			notNull: false,
-			autoincrement: false,
-		},
-	});
-});
-
-test('add columns #6', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: integer('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			email: text('email').unique().notNull(),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: integer('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			email: text('email').unique().notNull(),
-			password: text('password').notNull(),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'password',
-			type: 'text',
-			primaryKey: false,
-			notNull: true,
-			autoincrement: false,
-		},
-	});
-});
-
-test('add index #1', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
-		}),
-	};
-
-	const users = sqliteTable(
-		'users',
-		{
-			id: int('id').primaryKey({ autoIncrement: true }),
-			reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
-		},
-		(t) => {
-			return {
-				reporteeIdx: index('reportee_idx').on(t.reporteeId),
-			};
-		},
-	);
-
-	const schema2 = {
-		users,
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'create_index',
-		tableName: 'users',
-		internal: {
-			indexes: {},
-		},
-		schema: '',
-		data: 'reportee_idx;report_to;false;',
-	});
-});
-
-test('add foreign key #1', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			reporteeId: int('report_to'),
-		}),
-	};
-
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
-	});
-
-	const schema2 = {
-		users,
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual(
-		{
-			type: 'recreate_table',
-			columns: [{
-				autoincrement: true,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			}, {
-				autoincrement: false,
-				generated: undefined,
-				name: 'report_to',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			}],
-			compositePKs: [],
-			referenceData: [{
-				columnsFrom: ['report_to'],
-				columnsTo: ['id'],
-				name: 'users_report_to_users_id_fk',
-				tableFrom: 'users',
-				tableTo: 'users',
-				onDelete: 'no action',
-				onUpdate: 'no action',
-			}],
-			tableName: 'users',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		} as JsonRecreateTableStatement,
-	);
-});
-
-test('add foreign key #2', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			reporteeId: int('report_to'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				reporteeId: int('report_to'),
-			},
-			(t) => {
-				return {
-					reporteeFk: foreignKey({
-						columns: [t.reporteeId],
-						foreignColumns: [t.id],
-						name: 'reportee_fk',
-					}),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: true,
-			generated: undefined,
-			name: 'id',
-			notNull: true,
-			primaryKey: true,
-			type: 'integer',
-		}, {
-			autoincrement: false,
-			generated: undefined,
-			name: 'report_to',
-			notNull: false,
-			primaryKey: false,
-			type: 'integer',
-		}],
-		compositePKs: [],
-		referenceData: [{
-			columnsFrom: ['report_to'],
-			columnsTo: ['id'],
-			name: 'reportee_fk',
-			tableFrom: 'users',
-			tableTo: 'users',
-			onDelete: 'no action',
-			onUpdate: 'no action',
-		}],
-		tableName: 'users',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	} as JsonRecreateTableStatement);
-});
-
-test('alter column change name #1', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name1'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, [
-		'public.users.name->public.users.name1',
-	]);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		oldColumnName: 'name',
-		newColumnName: 'name1',
-	});
-});
-
-test('alter column change name #2', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name1'),
-			email: text('email'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, [
-		'public.users.name->public.users.name1',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		oldColumnName: 'name',
-		newColumnName: 'name1',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_alter_table_add_column',
-		tableName: 'users',
-		referenceData: undefined,
-		column: {
-			name: 'email',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-			autoincrement: false,
-		},
-	});
-});
-
-test('alter column change name #3', async (t) => {
-	const schema1 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name'),
-			email: text('email'),
-		}),
-	};
-
-	const schema2 = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			name: text('name1'),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, [
-		'public.users.name->public.users.name1',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'alter_table_rename_column',
-		tableName: 'users',
-		schema: '',
-		oldColumnName: 'name',
-		newColumnName: 'name1',
-	});
-
-	expect(statements[1]).toStrictEqual({
-		type: 'alter_table_drop_column',
-		tableName: 'users',
-		schema: '',
-		columnName: 'email',
-	});
-});
-
-test('alter table add composite pk', async (t) => {
-	const schema1 = {
-		table: sqliteTable('table', {
-			id1: integer('id1'),
-			id2: integer('id2'),
-		}),
-	};
-
-	const schema2 = {
-		table: sqliteTable(
-			'table',
-			{
-				id1: integer('id1'),
-				id2: integer('id2'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({ columns: [t.id1, t.id2] }),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'id1',
-			notNull: false,
-			primaryKey: false,
-			type: 'integer',
-		}, {
-			autoincrement: false,
-			generated: undefined,
-			name: 'id2',
-			notNull: false,
-			primaryKey: false,
-			type: 'integer',
-		}],
-		compositePKs: [['id1', 'id2']],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column drop not null', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name').notNull(),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column add not null', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: true,
-			primaryKey: false,
-			type: 'text',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column add default', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name').default('dan'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-			default: "'dan'",
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column drop default', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name').default('dan'),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column add default not null', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name').notNull().default('dan'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: true,
-			primaryKey: false,
-			type: 'text',
-			default: "'dan'",
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('alter column add default not null with indexes', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}, (table) => ({
-			someIndex: index('index_name').on(table.name),
-		})),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name').notNull().default('dan'),
-		}, (table) => ({
-			someIndex: index('index_name').on(table.name),
-		})),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: true,
-			primaryKey: false,
-			type: 'text',
-			default: "'dan'",
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		data: 'index_name;name;false;',
-		schema: '',
-		tableName: 'table',
-		type: 'create_index',
-		internal: undefined,
-	});
-	expect(sqlStatements.length).toBe(7);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_table\` (
-\t\`name\` text DEFAULT 'dan' NOT NULL
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_table\`("name") SELECT "name" FROM \`table\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`table\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_table\` RENAME TO \`table\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-	expect(sqlStatements[6]).toBe(`CREATE INDEX \`index_name\` ON \`table\` (\`name\`);`);
-});
-
-test('alter column drop default not null', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			name: text('name').notNull().default('dan'),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			name: text('name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'recreate_table',
-		columns: [{
-			autoincrement: false,
-			generated: undefined,
-			name: 'name',
-			notNull: false,
-			primaryKey: false,
-			type: 'text',
-		}],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_table\` (
-\t\`name\` text
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_table\`("name") SELECT "name" FROM \`table\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`table\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_table\` RENAME TO \`table\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('alter column drop generated', async (t) => {
-	const from = {
-		users: sqliteTable('table', {
-			id: int('id').primaryKey().notNull(),
-			name: text('name').generatedAlwaysAs('drizzle is the best').notNull(),
-		}),
-	};
-
-	const to = {
-		users: sqliteTable('table', {
-			id: int('id').primaryKey().notNull(),
-			name: text('name').notNull(),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columnAutoIncrement: false,
-		columnDefault: undefined,
-		columnGenerated: undefined,
-		columnName: 'name',
-		columnNotNull: true,
-		columnOnUpdate: undefined,
-		columnPk: false,
-		newDataType: 'text',
-		schema: '',
-		tableName: 'table',
-		type: 'alter_table_alter_column_drop_generated',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`ALTER TABLE \`table\` DROP COLUMN \`name\`;`);
-	expect(sqlStatements[1]).toBe(`ALTER TABLE \`table\` ADD \`name\` text NOT NULL;`);
-});
-
-test('recreate table with nested references', async (t) => {
-	let users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	let subscriptions = sqliteTable('subscriptions', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		userId: integer('user_id').references(() => users.id),
-		customerId: text('customer_id'),
-	});
-	const schema1 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(() => subscriptions.id),
-		}),
-	};
-
-	users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: false }),
-		name: text('name'),
-		age: integer('age'),
-	});
-	const schema2 = {
-		users: users,
-		subscriptions: subscriptions,
-		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-			subscriptionId: text('subscription_id').references(() => subscriptions.id),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		schema1,
-		schema2,
-		[],
-	);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		columns: [
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			{
-				autoincrement: false,
-				generated: undefined,
-				name: 'age',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		tableName: 'users',
-		type: 'recreate_table',
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-
-	expect(sqlStatements.length).toBe(6);
-	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
-	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_users\` (
-\t\`id\` integer PRIMARY KEY NOT NULL,
-\t\`name\` text,
-\t\`age\` integer
-);\n`);
-	expect(sqlStatements[2]).toBe(
-		`INSERT INTO \`__new_users\`("id", "name", "age") SELECT "id", "name", "age" FROM \`users\`;`,
-	);
-	expect(sqlStatements[3]).toBe(`DROP TABLE \`users\`;`);
-	expect(sqlStatements[4]).toBe(`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`);
-	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
-});
-
-test('text default values escape single quotes', async (t) => {
-	const schema1 = {
-		table: sqliteTable('table', {
-			id: integer('id').primaryKey(),
-		}),
-	};
-
-	const schem2 = {
-		table: sqliteTable('table', {
-			id: integer('id').primaryKey(),
-			text: text('text').default("escape's quotes"),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(schema1, schem2, []);
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toStrictEqual(
-		"ALTER TABLE `table` ADD `text` text DEFAULT 'escape''s quotes';",
-	);
-});
diff --git a/drizzle-kit/tests/sqlite-generated.test.ts b/drizzle-kit/tests/sqlite-generated.test.ts
deleted file mode 100644
index 2d3ceed978..0000000000
--- a/drizzle-kit/tests/sqlite-generated.test.ts
+++ /dev/null
@@ -1,1726 +0,0 @@
-// 1. add stored column to existing table - not supported +
-// 2. add virtual column to existing table - supported +
-// 3. create table with stored/virtual columns(pg, mysql, sqlite)
-// 4. add stored generated to column -> not supported +
-// 5. add virtual generated to column -> supported with drop+add column +
-// 6. drop stored/virtual expression -> supported with drop+add column
-// 7. alter generated expession -> stored not supported, virtual supported
-
-import { SQL, sql } from 'drizzle-orm';
-import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSqlite } from './schemaDiffer';
-
-// should generate 0 statements + warning/error in console
-test('generated as callback: add column with stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as callback: add column with virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '("name" || \'hello\')',
-					type: 'virtual',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			referenceData: undefined,
-			tableName: 'users',
-			type: 'sqlite_alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("name" || \'to add\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') VIRTUAL NOT NULL;',
-	]);
-});
-
-test('generated as callback: drop generated constraint as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as callback: drop generated constraint as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name} || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-// no way to do it
-test('generated as callback: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as callback: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-// not supported
-test('generated as callback: change stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as callback: change virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${from.users.name}`,
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as callback: add table with column with stored generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("name" || \'hello\')',
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n);\n',
-	]);
-});
-
-test('generated as callback: add table with column with virtual generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				(): SQL => sql`${to.users.name} || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("name" || \'hello\')',
-						type: 'virtual',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL\n);\n',
-	]);
-});
-
-// ---
-
-test('generated as sql: add column with stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || \'hello\' || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as sql: add column with virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || \'hello\'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '("users"."name" || \'hello\')',
-					type: 'virtual',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			referenceData: undefined,
-			tableName: 'users',
-			type: 'sqlite_alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`"users"."name" || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(sql`"users"."name" || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'to add\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'to add\') VIRTUAL NOT NULL;',
-	]);
-});
-
-test('generated as sql: drop generated constraint as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as sql: drop generated constraint as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-// no way to do it
-test('generated as sql: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
-				mode: 'virtual',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as sql: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
-				mode: 'stored',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-// not supported
-test('generated as sql: change stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
-				mode: 'stored',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as sql: change virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as sql: add table with column with stored generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("users"."name" || \'hello\')',
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
-	]);
-});
-
-test('generated as sql: add table with column with virtual generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				sql`"users"."name" || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("users"."name" || \'hello\')',
-						type: 'virtual',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL\n);\n',
-	]);
-});
-
-// ---
-
-test('generated as string: add column with stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || \'hello\'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as string: add column with virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || \'hello\'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			column: {
-				generated: {
-					as: '("users"."name" || \'hello\')',
-					type: 'virtual',
-				},
-				autoincrement: false,
-				name: 'gen_name',
-				notNull: false,
-				primaryKey: false,
-				type: 'text',
-			},
-			referenceData: undefined,
-			tableName: 'users',
-			type: 'sqlite_alter_table_add_column',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`"users"."name" || 'to add'`, {
-					mode: 'stored',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').notNull(),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name')
-				.notNull()
-				.generatedAlwaysAs(`"users"."name" || 'to add'`, {
-					mode: 'virtual',
-				}),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'to add\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: true,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_set_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'to add\') VIRTUAL NOT NULL;',
-	]);
-});
-
-test('generated as string: drop generated constraint as stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'to delete'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-test('generated as string: drop generated constraint as virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'to delete'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName1: text('gen_name'),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: undefined,
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_drop_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text;',
-	]);
-});
-
-// no way to do it
-test('generated as string: change generated constraint type from virtual to stored', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
-				mode: 'virtual',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as string: change generated constraint type from stored to virtual', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
-				mode: 'stored',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-// not supported
-test('generated as string: change stored generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
-				mode: 'stored',
-			}),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([]);
-	expect(sqlStatements).toStrictEqual([]);
-});
-
-test('generated as string: change virtual generated constraint', async () => {
-	const from = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`),
-		}),
-	};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columnAutoIncrement: false,
-			columnDefault: undefined,
-			columnGenerated: {
-				as: '("users"."name" || \'hello\')',
-				type: 'virtual',
-			},
-			columnName: 'gen_name',
-			columnNotNull: false,
-			columnOnUpdate: undefined,
-			columnPk: false,
-			newDataType: 'text',
-			schema: '',
-			tableName: 'users',
-			type: 'alter_table_alter_column_alter_generated',
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
-		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
-	]);
-});
-
-test('generated as string: add table with column with stored generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-				{ mode: 'stored' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("users"."name" || \'hello\')',
-						type: 'stored',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
-	]);
-});
-
-test('generated as string: add table with column with virtual generated constraint', async () => {
-	const from = {};
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id'),
-			id2: int('id2'),
-			name: text('name'),
-			generatedName: text('gen_name').generatedAlwaysAs(
-				`"users"."name" || 'hello'`,
-				{ mode: 'virtual' },
-			),
-		}),
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(
-		from,
-		to,
-		[],
-	);
-
-	expect(statements).toStrictEqual([
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'id2',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					generated: {
-						as: '("users"."name" || \'hello\')',
-						type: 'virtual',
-					},
-					name: 'gen_name',
-					notNull: false,
-					primaryKey: false,
-					type: 'text',
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			tableName: 'users',
-			type: 'sqlite_create_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	]);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL\n);\n',
-	]);
-});
diff --git a/drizzle-kit/tests/sqlite-tables.test.ts b/drizzle-kit/tests/sqlite-tables.test.ts
deleted file mode 100644
index 651c3633c4..0000000000
--- a/drizzle-kit/tests/sqlite-tables.test.ts
+++ /dev/null
@@ -1,637 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-	AnySQLiteColumn,
-	foreignKey,
-	index,
-	int,
-	primaryKey,
-	sqliteTable,
-	text,
-	unique,
-	uniqueIndex,
-} from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSqlite } from './schemaDiffer';
-
-test('add table #1', async () => {
-	const to = {
-		users: sqliteTable('users', {}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-});
-
-test('add table #2', async () => {
-	const to = {
-		users: sqliteTable('users', {
-			id: int('id').primaryKey({ autoIncrement: true }),
-		}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-				autoincrement: true,
-			},
-		],
-		compositePKs: [],
-		referenceData: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-	});
-});
-
-test('add table #3', async () => {
-	const to = {
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id'),
-			},
-			(t) => {
-				return {
-					pk: primaryKey({
-						name: 'users_pk',
-						columns: [t.id],
-					}),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				name: 'id',
-				notNull: false,
-				primaryKey: true,
-				type: 'integer',
-				autoincrement: false,
-			},
-		],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-});
-
-test('add table #4', async () => {
-	const to = {
-		users: sqliteTable('users', {}),
-		posts: sqliteTable('posts', {}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'posts',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-});
-
-test('add table #5', async () => {
-	// no schemas in sqlite
-});
-
-test('add table #6', async () => {
-	const from = {
-		users1: sqliteTable('users1', {}),
-	};
-
-	const to = {
-		users2: sqliteTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users2',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'drop_table',
-		tableName: 'users1',
-		schema: undefined,
-		policies: [],
-	});
-});
-
-test('add table #7', async () => {
-	const from = {
-		users1: sqliteTable('users1', {}),
-	};
-
-	const to = {
-		users: sqliteTable('users', {}),
-		users2: sqliteTable('users2', {}),
-	};
-
-	const { statements } = await diffTestSchemasSqlite(from, to, [
-		'public.users1->public.users2',
-	]);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'rename_table',
-		tableNameFrom: 'users1',
-		tableNameTo: 'users2',
-		fromSchema: undefined,
-		toSchema: undefined,
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-});
-
-test('add table #8', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-		reporteeId: int('reportee_id').references((): AnySQLiteColumn => users.id),
-	});
-
-	const to = {
-		users,
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				autoincrement: true,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'reportee_id',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		uniqueConstraints: [],
-		checkConstraints: [],
-		referenceData: [
-			{
-				columnsFrom: ['reportee_id'],
-				columnsTo: ['id'],
-				name: 'users_reportee_id_users_id_fk',
-				onDelete: 'no action',
-				onUpdate: 'no action',
-				tableFrom: 'users',
-				tableTo: 'users',
-			},
-		],
-	});
-});
-
-test('add table #9', async () => {
-	const to = {
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id').primaryKey({ autoIncrement: true }),
-				reporteeId: int('reportee_id'),
-			},
-			(t) => {
-				return {
-					reporteeIdx: index('reportee_idx').on(t.reporteeId),
-				};
-			},
-		),
-	};
-
-	const { statements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [
-			{
-				autoincrement: true,
-				name: 'id',
-				notNull: true,
-				primaryKey: true,
-				type: 'integer',
-			},
-			{
-				autoincrement: false,
-				name: 'reportee_id',
-				notNull: false,
-				primaryKey: false,
-				type: 'integer',
-			},
-		],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-
-	expect(statements[1]).toStrictEqual({
-		type: 'create_index',
-		tableName: 'users',
-		internal: {
-			indexes: {},
-		},
-		schema: undefined,
-		data: 'reportee_idx;reportee_id;false;',
-	});
-});
-
-test('add table #10', async () => {
-	const to = {
-		users: sqliteTable('table', {
-			json: text('json', { mode: 'json' }).default({}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` text DEFAULT '{}'\n);\n",
-	);
-});
-
-test('add table #11', async () => {
-	const to = {
-		users: sqliteTable('table', {
-			json: text('json', { mode: 'json' }).default([]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` text DEFAULT '[]'\n);\n",
-	);
-});
-
-test('add table #12', async () => {
-	const to = {
-		users: sqliteTable('table', {
-			json: text('json', { mode: 'json' }).default([1, 2, 3]),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		"CREATE TABLE `table` (\n\t`json` text DEFAULT '[1,2,3]'\n);\n",
-	);
-});
-
-test('add table #13', async () => {
-	const to = {
-		users: sqliteTable('table', {
-			json: text('json', { mode: 'json' }).default({ key: 'value' }),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` text DEFAULT \'{"key":"value"}\'\n);\n',
-	);
-});
-
-test('add table #14', async () => {
-	const to = {
-		users: sqliteTable('table', {
-			json: text('json', { mode: 'json' }).default({
-				key: 'value',
-				arr: [1, 2, 3],
-			}),
-		}),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		'CREATE TABLE `table` (\n\t`json` text DEFAULT \'{"key":"value","arr":[1,2,3]}\'\n);\n',
-	);
-});
-
-test('add table with indexes', async () => {
-	const from = {};
-
-	const to = {
-		users: sqliteTable(
-			'users',
-			{
-				id: int('id').primaryKey(),
-				name: text('name'),
-				email: text('email'),
-			},
-			(t) => ({
-				uniqueExpr: uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
-				indexExpr: index('indexExpr').on(sql`(lower(${t.email}))`),
-				indexExprMultiple: index('indexExprMultiple').on(
-					sql`(lower(${t.email}))`,
-					sql`(lower(${t.email}))`,
-				),
-
-				uniqueCol: uniqueIndex('uniqueCol').on(t.email),
-				indexCol: index('indexCol').on(t.email),
-				indexColMultiple: index('indexColMultiple').on(t.email, t.email),
-
-				indexColExpr: index('indexColExpr').on(
-					sql`(lower(${t.email}))`,
-					t.email,
-				),
-			}),
-		),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-	expect(sqlStatements.length).toBe(8);
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `users` (\n\t`id` integer PRIMARY KEY NOT NULL,\n\t`name` text,\n\t`email` text\n);\n',
-		'CREATE UNIQUE INDEX `uniqueExpr` ON `users` ((lower("email")));',
-		'CREATE INDEX `indexExpr` ON `users` ((lower("email")));',
-		'CREATE INDEX `indexExprMultiple` ON `users` ((lower("email")),(lower("email")));',
-		'CREATE UNIQUE INDEX `uniqueCol` ON `users` (`email`);',
-		'CREATE INDEX `indexCol` ON `users` (`email`);',
-		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`email`);',
-		'CREATE INDEX `indexColExpr` ON `users` ((lower("email")),`email`);',
-	]);
-});
-
-test('composite primary key', async () => {
-	const from = {};
-	const to = {
-		table: sqliteTable('works_to_creators', {
-			workId: int('work_id').notNull(),
-			creatorId: int('creator_id').notNull(),
-			classification: text('classification').notNull(),
-		}, (t) => ({
-			pk: primaryKey({
-				columns: [t.workId, t.creatorId, t.classification],
-			}),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'CREATE TABLE `works_to_creators` (\n\t`work_id` integer NOT NULL,\n\t`creator_id` integer NOT NULL,\n\t`classification` text NOT NULL,\n\tPRIMARY KEY(`work_id`, `creator_id`, `classification`)\n);\n',
-	]);
-});
-
-test('add column before creating unique constraint', async () => {
-	const from = {
-		table: sqliteTable('table', {
-			id: int('id').primaryKey(),
-		}),
-	};
-	const to = {
-		table: sqliteTable('table', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-		}, (t) => ({
-			uq: unique('uq').on(t.name),
-		})),
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(sqlStatements).toStrictEqual([
-		'ALTER TABLE `table` ADD `name` text NOT NULL;',
-		'CREATE UNIQUE INDEX `uq` ON `table` (`name`);',
-	]);
-});
-
-test('optional db aliases (snake case)', async () => {
-	const from = {};
-
-	const t1 = sqliteTable(
-		't1',
-		{
-			t1Id1: int().notNull().primaryKey(),
-			t1Col2: int().notNull(),
-			t1Col3: int().notNull(),
-			t2Ref: int().notNull().references(() => t2.t2Id),
-			t1Uni: int().notNull(),
-			t1UniIdx: int().notNull(),
-			t1Idx: int().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1_uni').on(table.t1Uni),
-			uniIdx: uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
-			idx: index('t1_idx').on(table.t1Idx),
-			fk: foreignKey({
-				columns: [table.t1Col2, table.t1Col3],
-				foreignColumns: [t3.t3Id1, t3.t3Id2],
-			}),
-		}),
-	);
-
-	const t2 = sqliteTable(
-		't2',
-		{
-			t2Id: int().primaryKey({ autoIncrement: true }),
-		},
-	);
-
-	const t3 = sqliteTable(
-		't3',
-		{
-			t3Id1: int(),
-			t3Id2: int(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3Id1, table.t3Id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(from, to, [], false, 'snake_case');
-
-	const st1 = `CREATE TABLE \`t1\` (
-	\`t1_id1\` integer PRIMARY KEY NOT NULL,
-	\`t1_col2\` integer NOT NULL,
-	\`t1_col3\` integer NOT NULL,
-	\`t2_ref\` integer NOT NULL,
-	\`t1_uni\` integer NOT NULL,
-	\`t1_uni_idx\` integer NOT NULL,
-	\`t1_idx\` integer NOT NULL,
-	FOREIGN KEY (\`t2_ref\`) REFERENCES \`t2\`(\`t2_id\`) ON UPDATE no action ON DELETE no action,
-	FOREIGN KEY (\`t1_col2\`,\`t1_col3\`) REFERENCES \`t3\`(\`t3_id1\`,\`t3_id2\`) ON UPDATE no action ON DELETE no action
-);
-`;
-
-	const st2 = `CREATE UNIQUE INDEX \`t1_uni_idx\` ON \`t1\` (\`t1_uni_idx\`);`;
-
-	const st3 = `CREATE INDEX \`t1_idx\` ON \`t1\` (\`t1_idx\`);`;
-
-	const st4 = `CREATE UNIQUE INDEX \`t1_uni\` ON \`t1\` (\`t1_uni\`);`;
-
-	const st5 = `CREATE TABLE \`t2\` (
-	\`t2_id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL
-);
-`;
-
-	const st6 = `CREATE TABLE \`t3\` (
-	\`t3_id1\` integer,
-	\`t3_id2\` integer,
-	PRIMARY KEY(\`t3_id1\`, \`t3_id2\`)
-);
-`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6]);
-});
-
-test('optional db aliases (camel case)', async () => {
-	const from = {};
-
-	const t1 = sqliteTable(
-		't1',
-		{
-			t1_id1: int().notNull().primaryKey(),
-			t1_col2: int().notNull(),
-			t1_col3: int().notNull(),
-			t2_ref: int().notNull().references(() => t2.t2_id),
-			t1_uni: int().notNull(),
-			t1_uni_idx: int().notNull(),
-			t1_idx: int().notNull(),
-		},
-		(table) => ({
-			uni: unique('t1Uni').on(table.t1_uni),
-			uni_idx: uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
-			idx: index('t1Idx').on(table.t1_idx),
-			fk: foreignKey({
-				columns: [table.t1_col2, table.t1_col3],
-				foreignColumns: [t3.t3_id1, t3.t3_id2],
-			}),
-		}),
-	);
-
-	const t2 = sqliteTable(
-		't2',
-		{
-			t2_id: int().primaryKey({ autoIncrement: true }),
-		},
-	);
-
-	const t3 = sqliteTable(
-		't3',
-		{
-			t3_id1: int(),
-			t3_id2: int(),
-		},
-		(table) => ({
-			pk: primaryKey({
-				columns: [table.t3_id1, table.t3_id2],
-			}),
-		}),
-	);
-
-	const to = {
-		t1,
-		t2,
-		t3,
-	};
-
-	const { sqlStatements } = await diffTestSchemasSqlite(from, to, [], false, 'camelCase');
-
-	const st1 = `CREATE TABLE \`t1\` (
-	\`t1Id1\` integer PRIMARY KEY NOT NULL,
-	\`t1Col2\` integer NOT NULL,
-	\`t1Col3\` integer NOT NULL,
-	\`t2Ref\` integer NOT NULL,
-	\`t1Uni\` integer NOT NULL,
-	\`t1UniIdx\` integer NOT NULL,
-	\`t1Idx\` integer NOT NULL,
-	FOREIGN KEY (\`t2Ref\`) REFERENCES \`t2\`(\`t2Id\`) ON UPDATE no action ON DELETE no action,
-	FOREIGN KEY (\`t1Col2\`,\`t1Col3\`) REFERENCES \`t3\`(\`t3Id1\`,\`t3Id2\`) ON UPDATE no action ON DELETE no action
-);
-`;
-
-	const st2 = `CREATE UNIQUE INDEX \`t1UniIdx\` ON \`t1\` (\`t1UniIdx\`);`;
-
-	const st3 = `CREATE INDEX \`t1Idx\` ON \`t1\` (\`t1Idx\`);`;
-
-	const st4 = `CREATE UNIQUE INDEX \`t1Uni\` ON \`t1\` (\`t1Uni\`);`;
-
-	const st5 = `CREATE TABLE \`t2\` (
-	\`t2Id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL
-);
-`;
-
-	const st6 = `CREATE TABLE \`t3\` (
-	\`t3Id1\` integer,
-	\`t3Id2\` integer,
-	PRIMARY KEY(\`t3Id1\`, \`t3Id2\`)
-);
-`;
-
-	expect(sqlStatements).toStrictEqual([st1, st2, st3, st4, st5, st6]);
-});
diff --git a/drizzle-kit/tests/sqlite-views.test.ts b/drizzle-kit/tests/sqlite-views.test.ts
deleted file mode 100644
index 8021ba37ef..0000000000
--- a/drizzle-kit/tests/sqlite-views.test.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { int, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
-import { expect, test } from 'vitest';
-import { diffTestSchemasSqlite } from './schemaDiffer';
-
-test('create view', async () => {
-	const users = sqliteTable('users', { id: int('id').default(1) });
-	const view = sqliteView('view').as((qb) => qb.select().from(users));
-	const to = {
-		users: users,
-		testView: view,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		type: 'sqlite_create_table',
-		tableName: 'users',
-		columns: [{
-			autoincrement: false,
-			default: 1,
-			name: 'id',
-			type: 'integer',
-			primaryKey: false,
-			notNull: false,
-		}],
-		compositePKs: [],
-		uniqueConstraints: [],
-		referenceData: [],
-		checkConstraints: [],
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'view',
-		definition: 'select "id" from "users"',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`CREATE TABLE \`users\` (
-\t\`id\` integer DEFAULT 1
-);\n`);
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`view\` AS select "id" from "users";`);
-});
-
-test('drop view', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(1);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-
-	expect(sqlStatements.length).toBe(1);
-	expect(sqlStatements[0]).toBe(
-		`DROP VIEW \`view\`;`,
-	);
-});
-
-test('alter view', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users WHERE users.id = 1`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		name: 'view',
-		type: 'sqlite_create_view',
-		definition: 'SELECT * FROM users WHERE users.id = 1',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(
-		`DROP VIEW \`view\`;`,
-	);
-	expect(sqlStatements[1]).toBe(
-		`CREATE VIEW \`view\` AS SELECT * FROM users WHERE users.id = 1;`,
-	);
-});
-
-test('create view with existing flag', async () => {
-	const view = sqliteView('view', {}).existing();
-	const to = {
-		testView: view,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite({}, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('drop view with existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-	};
-
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, []);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view with existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).existing(),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(0);
-	expect(sqlStatements.length).toBe(0);
-});
-
-test('rename view and drop existing flag', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).existing(),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'new_view',
-		definition: 'SELECT * FROM users',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe(`DROP VIEW \`view\`;`);
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users;`);
-});
-
-test('rename view and alter ".as"', async () => {
-	const users = sqliteTable('users', {
-		id: int('id').primaryKey({ autoIncrement: true }),
-	});
-
-	const from = {
-		users: users,
-		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
-	};
-	const to = {
-		users,
-		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users WHERE 1=1`),
-	};
-	const { statements, sqlStatements } = await diffTestSchemasSqlite(from, to, ['view->new_view']);
-
-	expect(statements.length).toBe(2);
-	expect(statements[0]).toStrictEqual({
-		name: 'view',
-		type: 'drop_view',
-	});
-	expect(statements[1]).toStrictEqual({
-		type: 'sqlite_create_view',
-		name: 'new_view',
-		definition: 'SELECT * FROM users WHERE 1=1',
-	});
-
-	expect(sqlStatements.length).toBe(2);
-	expect(sqlStatements[0]).toBe('DROP VIEW `view`;');
-	expect(sqlStatements[1]).toBe(`CREATE VIEW \`new_view\` AS SELECT * FROM users WHERE 1=1;`);
-});
diff --git a/drizzle-kit/tests/sqlite/commutativity.test.ts b/drizzle-kit/tests/sqlite/commutativity.test.ts
new file mode 100644
index 0000000000..aff19afe59
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/commutativity.test.ts
@@ -0,0 +1,224 @@
+import { index, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { sqliteCommutativity } from 'src/dialects/sqlite/commutativity';
+import type { SqliteSnapshot } from 'src/dialects/sqlite/snapshot';
+import { describe, expect, test } from 'vitest';
+import { drizzleToDDL, type SqliteSchema } from './mocks';
+
+const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+function makeSnapshot(
+	id: string,
+	prevIds: string[],
+	schema: SqliteSchema,
+): SqliteSnapshot {
+	return {
+		version: '7',
+		dialect: 'sqlite',
+		id,
+		prevIds,
+		ddl: drizzleToDDL(schema).ddl.entities.list(),
+		renames: [],
+	};
+}
+
+function writeSnapshot(dir: string, tag: string, snap: SqliteSnapshot) {
+	const folder = join(dir, tag);
+	mkdirSync(folder, { recursive: true });
+	const path = join(folder, 'snapshot.json');
+	writeFileSync(path, JSON.stringify(snap, null, 2));
+	return path;
+}
+
+function mkTmp(): string {
+	return mkdtempSync(join(tmpdir(), 'dk-comm-int-sqlite-'));
+}
+
+describe('commutativity (sqlite)', () => {
+	test('detects conflict when both branches alter the same column', async () => {
+		const parent: SqliteSchema = {
+			users: sqliteTable('users', { email: text('email') }),
+		};
+		const branchA: SqliteSchema = {
+			users: sqliteTable('users', { email: text('email').notNull() }),
+		};
+		const branchB: SqliteSchema = {
+			users: sqliteTable('users', { email: int('email') }),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+		expect(report.conflicts[0].parentId).toBe('p1');
+	});
+
+	test('no conflict when branches touch different tables', async () => {
+		const parent: SqliteSchema = {};
+		const branchA: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+		};
+		const branchB: SqliteSchema = {
+			posts: sqliteTable('posts', { id: int('id') }),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+		expect(report.commutativeBranches?.length).toBe(1);
+	});
+
+	test('drop_table in one branch conflicts with add_column in the other', async () => {
+		const parent: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+		};
+		const branchA: SqliteSchema = {}; // drops users
+		const branchB: SqliteSchema = {
+			users: sqliteTable('users', {
+				id: int('id'),
+				email: text('email'),
+			}),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBe(1);
+	});
+
+	test('two create_table for the same table on different branches conflict', async () => {
+		const parent: SqliteSchema = {};
+		const branchA: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+		};
+		const branchB: SqliteSchema = {
+			users: sqliteTable('users', { email: text('email') }),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('create_index on same table do not conflict when on different columns', async () => {
+		const parent: SqliteSchema = {
+			orders: sqliteTable('orders', {
+				customerId: int('customer_id'),
+				status: text('status'),
+			}),
+		};
+		const branchA: SqliteSchema = {
+			orders: sqliteTable(
+				'orders',
+				{
+					customerId: int('customer_id'),
+					status: text('status'),
+				},
+				(t) => [index('orders_customer_id_idx').on(t.customerId)],
+			),
+		};
+		const branchB: SqliteSchema = {
+			orders: sqliteTable(
+				'orders',
+				{
+					customerId: int('customer_id'),
+					status: text('status'),
+				},
+				(t) => [index('orders_status_idx').on(t.status)],
+			),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+	});
+
+	test('view rename on both branches collide', async () => {
+		// Parent has view `v`. Branch A renames it to `v_a`, branch B renames
+		// it to `v_b`. SQLite cannot rename views, so each branch produces a
+		// drop_view(v) — and those two drop_view statements conflict on `v`.
+		const t = sqliteTable('t', { id: int('id') });
+		const parent: SqliteSchema = {
+			t,
+			v: sqliteView('v').as((qb) => qb.select().from(t)),
+		};
+		const branchA: SqliteSchema = {
+			t,
+			v_a: sqliteView('v_a').as((qb) => qb.select().from(t)),
+		};
+		const branchB: SqliteSchema = {
+			t,
+			v_b: sqliteView('v_b').as((qb) => qb.select().from(t)),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts.length).toBeGreaterThan(0);
+	});
+
+	test('reports commutativeBranches when forks are independent', async () => {
+		const parent: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+		};
+		const branchA: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+			likes: sqliteTable('likes', { id: int('id') }),
+		};
+		const branchB: SqliteSchema = {
+			users: sqliteTable('users', { id: int('id') }),
+			groups: sqliteTable('groups', { id: int('id') }),
+		};
+
+		const tmp = mkTmp();
+		const files = [
+			writeSnapshot(tmp, '000_parent', makeSnapshot('p1', [ORIGIN], parent)),
+			writeSnapshot(tmp, '001_a', makeSnapshot('a1', ['p1'], branchA)),
+			writeSnapshot(tmp, '002_b', makeSnapshot('b1', ['p1'], branchB)),
+		];
+
+		const report = await sqliteCommutativity.detectNonCommutative(files);
+		expect(report.conflicts).toStrictEqual([]);
+		expect(report.commutativeBranches).toBeDefined();
+		expect(report.commutativeBranches!.length).toBe(1);
+		expect(report.commutativeBranches![0].parentId).toBe('p1');
+		expect(
+			report.commutativeBranches![0].leafs.map((l) => l.id).sort(),
+		).toStrictEqual(['a1', 'b1']);
+	});
+});
diff --git a/drizzle-kit/tests/sqlite/generate-flow.test.ts b/drizzle-kit/tests/sqlite/generate-flow.test.ts
new file mode 100644
index 0000000000..1a69391f6e
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/generate-flow.test.ts
@@ -0,0 +1,376 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { checkHandler } from 'src/cli/commands/check';
+import { ddlDiffDry } from 'src/dialects/sqlite/diff';
+import { generateLatestSnapshot } from 'src/dialects/sqlite/serializer';
+import type { SqliteSnapshot } from 'src/dialects/sqlite/snapshot';
+import type { JsonStatement } from 'src/dialects/sqlite/statements';
+import { describe, expect, test } from 'vitest';
+import { drizzleToDDL, type SqliteSchema } from './mocks';
+
+const ORIGIN = '00000000-0000-0000-0000-000000000000';
+
+function makeSnapshot(
+	id: string,
+	prevIds: string[],
+	schema: SqliteSchema,
+): SqliteSnapshot {
+	return {
+		version: '7',
+		dialect: 'sqlite',
+		id,
+		prevIds,
+		ddl: drizzleToDDL(schema).ddl.entities.list(),
+		renames: [],
+	};
+}
+
+function snapshotPath(out: string, tag: string, snapshot: SqliteSnapshot) {
+	const folder = join(out, tag);
+	mkdirSync(folder, { recursive: true });
+	const path = join(folder, 'snapshot.json');
+	writeFileSync(path, JSON.stringify(snapshot, null, 2));
+	return path;
+}
+
+function mkOut(prefix: string) {
+	mkdirSync('tests/tmp', { recursive: true });
+	return mkdtempSync(join(tmpdir(), prefix));
+}
+
+const stable = (value: unknown): unknown => {
+	if (Array.isArray(value)) return value.map(stable);
+	if (value && typeof value === 'object') {
+		return Object.fromEntries(
+			Object.entries(value as Record<string, unknown>)
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([k, v]) => [k, stable(v)]),
+		);
+	}
+	return value;
+};
+const stableEntries = (entities: any[]) => entities.map((e) => JSON.stringify(stable(e))).sort();
+
+const schemas = {
+	users: {
+		users: sqliteTable('users', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersWithEmail: {
+		users: sqliteTable('users', {
+			id: int('id'),
+			email: text('email'),
+		}),
+	} satisfies SqliteSchema,
+	usersAndLikes: {
+		users: sqliteTable('users', { id: int('id') }),
+		likes: sqliteTable('likes', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersAndGroups: {
+		users: sqliteTable('users', { id: int('id') }),
+		groups: sqliteTable('groups', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersLikesAndGroups: {
+		users: sqliteTable('users', { id: int('id') }),
+		likes: sqliteTable('likes', { id: int('id') }),
+		groups: sqliteTable('groups', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersAndPosts: {
+		users: sqliteTable('users', { id: int('id') }),
+		posts: sqliteTable('posts', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersWithEmailAndPosts: {
+		users: sqliteTable('users', {
+			id: int('id'),
+			email: text('email'),
+		}),
+		posts: sqliteTable('posts', { id: int('id') }),
+	} satisfies SqliteSchema,
+	usersEmailWithText: {
+		users: sqliteTable('users', { id: int('id'), email: text('email') }),
+	} satisfies SqliteSchema,
+	usersEmailNotNull: {
+		users: sqliteTable('users', {
+			id: int('id'),
+			email: text('email').notNull(),
+		}),
+	} satisfies SqliteSchema,
+	usersEmailAsInt: {
+		users: sqliteTable('users', { id: int('id'), email: int('email') }),
+	} satisfies SqliteSchema,
+};
+
+describe('checkHandler (sqlite)', () => {
+	test(
+		'returns aggregated statements + parent snapshot for commutative open branches',
+		async () => {
+			const out = mkOut('dk-check-sqlite-');
+
+			snapshotPath(out, '000_parent', makeSnapshot('p1', [ORIGIN], schemas.users));
+			snapshotPath(out, '001_left', makeSnapshot('a1', ['p1'], schemas.usersAndLikes));
+			snapshotPath(out, '002_right', makeSnapshot('b1', ['p1'], schemas.usersAndGroups));
+
+			const result = await checkHandler(out, 'sqlite');
+
+			expect(result.parentSnapshot).not.toBeNull();
+			expect((result.parentSnapshot as SqliteSnapshot).id).toBe('p1');
+			expect(result.leafIds).toStrictEqual(['a1', 'b1']);
+			expect(result.statements.length).toBeGreaterThan(0);
+			expect(result.nonCommutativityMessage).toBeUndefined();
+		},
+	);
+
+	test('returns empty statements when branches already merged into one leaf', async () => {
+		const out = mkOut('dk-check-sqlite-');
+
+		snapshotPath(out, '000_parent', makeSnapshot('p1', [ORIGIN], schemas.users));
+		snapshotPath(out, '001_left', makeSnapshot('a1', ['p1'], schemas.usersAndLikes));
+		snapshotPath(out, '002_right', makeSnapshot('b1', ['p1'], schemas.usersAndGroups));
+		snapshotPath(
+			out,
+			'003_merged',
+			makeSnapshot('m1', ['a1', 'b1'], schemas.usersLikesAndGroups),
+		);
+
+		const result = await checkHandler(out, 'sqlite');
+
+		expect(result.statements).toStrictEqual([]);
+		expect(result.parentSnapshot).toBeNull();
+		expect(result.nonCommutativityMessage).toBeUndefined();
+	});
+
+	test('reports non-commutativity for two branches altering the same column', async () => {
+		const out = mkOut('dk-check-sqlite-');
+
+		snapshotPath(out, '000_parent', makeSnapshot('p1', [ORIGIN], schemas.usersEmailWithText));
+		snapshotPath(out, '001_left', makeSnapshot('a1', ['p1'], schemas.usersEmailNotNull));
+		snapshotPath(out, '002_right', makeSnapshot('b1', ['p1'], schemas.usersEmailAsInt));
+
+		const result = await checkHandler(out, 'sqlite', false, false);
+
+		expect(result.statements).toStrictEqual([]);
+		expect(result.nonCommutativityMessage).toContain(
+			'Non-commutative migrations detected',
+		);
+	});
+
+	test('ignoreConflicts keeps both leaf ids for conflicting branches', async () => {
+		const out = mkOut('dk-check-sqlite-');
+
+		snapshotPath(out, '000_parent', makeSnapshot('p1', [ORIGIN], schemas.usersEmailWithText));
+		snapshotPath(out, '001_left', makeSnapshot('a1', ['p1'], schemas.usersEmailNotNull));
+		snapshotPath(out, '002_right', makeSnapshot('b1', ['p1'], schemas.usersEmailAsInt));
+
+		const result = await checkHandler(out, 'sqlite', true, false);
+
+		expect(result.statements).toStrictEqual([]);
+		expect(result.parentSnapshot).toBeNull();
+		expect(result.leafIds).toStrictEqual(['a1', 'b1']);
+	});
+});
+
+describe('generateLatestSnapshot (sqlite)', () => {
+	async function applyTransition(from: SqliteSchema, to: SqliteSchema) {
+		const fromDDL = drizzleToDDL(from).ddl;
+		const toDDL = drizzleToDDL(to).ddl;
+		const base: SqliteSnapshot = {
+			version: '7',
+			dialect: 'sqlite',
+			id: 'snapshot-id',
+			prevIds: [ORIGIN],
+			ddl: fromDDL.entities.list(),
+			renames: [],
+		};
+		const { statements } = await ddlDiffDry(fromDDL, toDDL, 'default');
+		const actual = generateLatestSnapshot(base, statements);
+		return {
+			actualDdl: stableEntries(actual.ddl),
+			expectedDdl: stableEntries(toDDL.entities.list()),
+			statements,
+		};
+	}
+
+	test('create_table reproduces target ddl', async () => {
+		const { actualDdl, expectedDdl, statements } = await applyTransition(
+			{},
+			schemas.users,
+		);
+		expect(statements.map((s) => s.type)).toStrictEqual(['create_table']);
+		expect(actualDdl).toStrictEqual(expectedDdl);
+	});
+
+	test('drop_table reproduces target ddl', async () => {
+		const { actualDdl, expectedDdl, statements } = await applyTransition(
+			schemas.users,
+			{},
+		);
+		expect(statements.map((s) => s.type)).toStrictEqual(['drop_table']);
+		expect(actualDdl).toStrictEqual(expectedDdl);
+	});
+
+	test('add_column reproduces target ddl', async () => {
+		const { actualDdl, expectedDdl, statements } = await applyTransition(
+			schemas.users,
+			schemas.usersWithEmail,
+		);
+		expect(statements.map((s) => s.type)).toStrictEqual(['add_column']);
+		expect(actualDdl).toStrictEqual(expectedDdl);
+	});
+
+	test('drop_column reproduces target ddl', async () => {
+		const { actualDdl, expectedDdl, statements } = await applyTransition(
+			schemas.usersWithEmail,
+			schemas.users,
+		);
+		expect(statements.map((s) => s.type)).toStrictEqual(['drop_column']);
+		expect(actualDdl).toStrictEqual(expectedDdl);
+	});
+
+	test('union of independent branches reproduces the merged schema', async () => {
+		const parentDDL = drizzleToDDL(schemas.users).ddl;
+		const branchADDL = drizzleToDDL(schemas.usersAndLikes).ddl;
+		const branchBDDL = drizzleToDDL(schemas.usersAndGroups).ddl;
+		const mergedDDL = drizzleToDDL(schemas.usersLikesAndGroups).ddl;
+
+		const { statements: stmtsA } = await ddlDiffDry(parentDDL, branchADDL, 'default');
+		const { statements: stmtsB } = await ddlDiffDry(parentDDL, branchBDDL, 'default');
+		const combined: JsonStatement[] = [...stmtsA, ...stmtsB];
+
+		const base: SqliteSnapshot = {
+			version: '7',
+			dialect: 'sqlite',
+			id: 'parent-id',
+			prevIds: [ORIGIN],
+			ddl: parentDDL.entities.list(),
+			renames: [],
+		};
+		const result = generateLatestSnapshot(base, combined);
+
+		expect(stableEntries(result.ddl)).toStrictEqual(
+			stableEntries(mergedDDL.entities.list()),
+		);
+	});
+});
+
+/**
+ * Reproduces the user-described flow:
+ *   1. branch-a generates a migration M_A from parent P (prevIds=[P]).
+ *   2. primary branch generates a migration M_P from parent P (prevIds=[P]).
+ *   3. branch-a rebases on primary → migrations folder now has M_A and M_P
+ *      as siblings under P. M_P's snapshot does not include M_A's changes.
+ *
+ * Running `drizzle-kit generate` on branch-a after rebase must:
+ *   - detect the open commutative branches under P,
+ *   - feed (parent=P, statements=A∪P) into prepareSqliteSnapshot, which uses
+ *     generateLatestSnapshot to derive the effective prev snapshot,
+ *   - yield a merge migration whose prevIds reference both leafs (M_A, M_P).
+ */
+describe('rebase scenario (sqlite)', () => {
+	test('open commutative branches resolve into a merge migration with no diff', async () => {
+		const out = mkOut('dk-rebase-sqlite-');
+
+		snapshotPath(out, '0000_parent', makeSnapshot('p1', [ORIGIN], schemas.users));
+		snapshotPath(out, '0001_branchA', makeSnapshot('a1', ['p1'], schemas.usersAndLikes));
+		snapshotPath(
+			out,
+			'0001_primary',
+			makeSnapshot('pri1', ['p1'], schemas.usersAndGroups),
+		);
+
+		const result = await checkHandler(out, 'sqlite', false, false);
+
+		expect(result.parentSnapshot).not.toBeNull();
+		expect((result.parentSnapshot as SqliteSnapshot).id).toBe('p1');
+		expect(result.leafIds?.sort()).toStrictEqual(['a1', 'pri1']);
+		expect(result.nonCommutativityMessage).toBeUndefined();
+		const types = result.statements.map((s) => (s as JsonStatement).type).sort();
+		expect(types).toStrictEqual(['create_table', 'create_table']);
+
+		const parentSnap = result.parentSnapshot as SqliteSnapshot;
+		const effectivePrev = generateLatestSnapshot(
+			parentSnap,
+			result.statements as JsonStatement[],
+		);
+		const finalDDL = drizzleToDDL(schemas.usersLikesAndGroups).ddl;
+
+		// Effective prev = parent + (branchA + primary) statements applied.
+		// It must already match the post-rebase schema (the user's TS files),
+		// so the next ddlDiff against the user schema is empty and the merge
+		// migration carries only the prevIds=[a1, pri1] linkage.
+		expect(stableEntries(effectivePrev.ddl)).toStrictEqual(
+			stableEntries(finalDDL.entities.list()),
+		);
+
+		const effectiveDDL = drizzleToDDL({}).ddl;
+		for (const e of effectivePrev.ddl) effectiveDDL.entities.push(e);
+		const { statements: mergeStatements } = await ddlDiffDry(
+			effectiveDDL,
+			finalDDL,
+			'default',
+		);
+		expect(mergeStatements).toStrictEqual([]);
+	});
+
+	test('rebase with column added in one branch and table added in the other', async () => {
+		const out = mkOut('dk-rebase-sqlite-');
+
+		snapshotPath(out, '0000_parent', makeSnapshot('p1', [ORIGIN], schemas.users));
+		snapshotPath(out, '0001_branchA', makeSnapshot('a1', ['p1'], schemas.usersWithEmail));
+		snapshotPath(
+			out,
+			'0001_primary',
+			makeSnapshot('pri1', ['p1'], schemas.usersAndPosts),
+		);
+
+		const result = await checkHandler(out, 'sqlite', false, false);
+
+		expect(result.nonCommutativityMessage).toBeUndefined();
+		expect(result.leafIds?.sort()).toStrictEqual(['a1', 'pri1']);
+		expect(result.parentSnapshot).not.toBeNull();
+
+		const parentSnap = result.parentSnapshot as SqliteSnapshot;
+		const effectivePrev = generateLatestSnapshot(
+			parentSnap,
+			result.statements as JsonStatement[],
+		);
+
+		expect(stableEntries(effectivePrev.ddl)).toStrictEqual(
+			stableEntries(drizzleToDDL(schemas.usersWithEmailAndPosts).ddl.entities.list()),
+		);
+	});
+
+	test('the next migration prevIds points at both open leafs', async () => {
+		const out = mkOut('dk-rebase-sqlite-');
+
+		snapshotPath(out, '0000_parent', makeSnapshot('p1', [ORIGIN], schemas.users));
+		snapshotPath(out, '0001_branchA', makeSnapshot('a1', ['p1'], schemas.usersAndLikes));
+		snapshotPath(
+			out,
+			'0001_primary',
+			makeSnapshot('pri1', ['p1'], schemas.usersAndGroups),
+		);
+
+		const result = await checkHandler(out, 'sqlite', false, false);
+
+		expect(result.leafIds).toBeDefined();
+		expect(result.leafIds!.length).toBe(2);
+		expect(new Set(result.leafIds)).toStrictEqual(new Set(['a1', 'pri1']));
+	});
+
+	test('rebase produces a non-commutative report when branches conflict on the same column', async () => {
+		const out = mkOut('dk-rebase-sqlite-');
+
+		snapshotPath(out, '0000_parent', makeSnapshot('p1', [ORIGIN], schemas.usersEmailWithText));
+		snapshotPath(out, '0001_branchA', makeSnapshot('a1', ['p1'], schemas.usersEmailNotNull));
+		snapshotPath(out, '0001_primary', makeSnapshot('pri1', ['p1'], schemas.usersEmailAsInt));
+
+		const result = await checkHandler(out, 'sqlite', false, false);
+
+		expect(result.statements).toStrictEqual([]);
+		expect(result.nonCommutativityMessage).toContain(
+			'Non-commutative migrations detected',
+		);
+		expect(result.nonCommutativityMessage).toContain('users');
+	});
+});
diff --git a/drizzle-kit/tests/sqlite/grammar.test.ts b/drizzle-kit/tests/sqlite/grammar.test.ts
new file mode 100644
index 0000000000..7fa1566a98
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/grammar.test.ts
@@ -0,0 +1,163 @@
+import { parseSqliteDdl, parseViewSQL } from 'src/dialects/sqlite/grammar';
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('view definition', () => {
+	parseViewSQL('CREATE VIEW current_cycle AS\nSELECT\n* from users;');
+});
+
+describe('parse ddl', (t) => {
+	test('all uniques', async () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text,' + '\n'
+			+ '\`column1\` text,' + '\n'
+			+ '\`column2\` text,' + '\n'
+			+ '\`column3\` text,' + '\n'
+			+ '\`column4\` text UNIQUE,' + '\n'
+			+ '\`column5\` text CONSTRAINT [hey] UNIQUE,' + '\n'
+			+ '\`column6\` text,' + '\n'
+			+ 'CONSTRAINT [unique_name] UNIQUE(\`column\`),' + '\n'
+			+ 'CONSTRAINT unique_name1 UNIQUE(\`column1\`),' + '\n'
+			+ 'CONSTRAINT "unique_name2" UNIQUE(\`column2\`),' + '\n'
+			+ 'CONSTRAINT \`unique_name3\` UNIQUE(\`column3\`)' + '\n'
+			+ ')';
+
+		await db.run(ddl);
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [
+				{ name: 'unique_name', columns: ['column'] },
+				{ name: 'unique_name1', columns: ['column1'] },
+				{ name: 'unique_name2', columns: ['column2'] },
+				{ name: 'unique_name3', columns: ['column3'] },
+				{ name: null, columns: ['column4'] },
+				{ name: 'hey', columns: ['column5'] },
+			],
+			pk: { name: null, columns: [] },
+		});
+	});
+
+	test('corner case uniques', async () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text,' + '\n'
+			+ '\`column1\` text,' + '\n'
+			+ '\`column2\` text,' + '\n'
+			+ '\`column3\` text,'
+			+ '\`column4\` \ntext UNIQUE,' + '\n'
+			+ '\`column5\` text \nCONSTRAINT [hey] \tUNIQUE\n\t,' + '\n'
+			+ '\`column6\` text \nCONSTRAINT "hey" \tUNIQUE\n\t,' + '\n'
+			+ '\`column7\` text \nCONSTRAINT \`hey\` \tUNIQUE\n\t,' + '\n'
+			+ '\`column8\` text \nCONSTRAINT hey \tUNIQUE\n\t,' + '\n'
+			+ '\`column9\` text,' + '\n'
+			+ 'CONSTRAINT\n\t [unique_name] UNIQUE\n(\`column\`),'
+			+ 'CONSTRAINT unique_name1 UNIQUE(\`column1\`),' + '\n'
+			+ 'CONSTRAINT "unique_name2"\n UNIQUE(\`column2\`),' + '\n'
+			+ 'CONSTRAINT \`unique_name3\` UNIQUE(\`column3\`)' + '\n'
+			+ ')';
+
+		await db.run(ddl);
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [
+				{ name: 'unique_name', columns: ['column'] },
+				{ name: 'unique_name1', columns: ['column1'] },
+				{ name: 'unique_name2', columns: ['column2'] },
+				{ name: 'unique_name3', columns: ['column3'] },
+				{ name: null, columns: ['column4'] },
+				{ name: 'hey', columns: ['column5'] },
+				{ name: 'hey', columns: ['column6'] },
+				{ name: 'hey', columns: ['column7'] },
+				{ name: 'hey', columns: ['column8'] },
+			],
+			pk: { name: null, columns: [] },
+		});
+	});
+
+	test('pk #1', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text' + '\n'
+			+ 'CONSTRAINT [pk] PRIMARY KEY(\`column\`)' + '\n'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: { name: 'pk', columns: ['column'] },
+		});
+	});
+	test('pk #2', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text' + '\n'
+			+ 'CONSTRAINT pk PRIMARY KEY(\`column\`)' + '\n'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: { name: 'pk', columns: ['column'] },
+		});
+	});
+	test('pk #3', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text' + '\n'
+			+ 'CONSTRAINT "pk" PRIMARY KEY(\`column\`)' + '\n'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: { name: 'pk', columns: ['column'] },
+		});
+	});
+	test('pk #4', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text' + '\n'
+			+ 'CONSTRAINT `pk` PRIMARY KEY(\`column\`)' + '\n'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: { name: 'pk', columns: ['column'] },
+		});
+	});
+	test('pk #5', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text PRIMARY KEY'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: {
+				name: null,
+				columns: [`column`],
+			},
+		});
+	});
+	test('pk #6', () => {
+		const ddl = 'CREATE TABLE \`users\` (' + '\n'
+			+ '\`column\` text CONSTRAINT "pk" PRIMARY KEY'
+			+ ')';
+
+		expect(parseSqliteDdl(ddl)).toStrictEqual({
+			uniques: [],
+			pk: {
+				name: 'pk',
+				columns: [`column`],
+			},
+		});
+	});
+});
diff --git a/drizzle-kit/tests/sqlite/mocks.ts b/drizzle-kit/tests/sqlite/mocks.ts
new file mode 100644
index 0000000000..13883ed164
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/mocks.ts
@@ -0,0 +1,435 @@
+import type { Database } from 'better-sqlite3';
+import BetterSqlite3 from 'better-sqlite3';
+import { is } from 'drizzle-orm';
+import { int, SQLiteColumnBuilder, SQLiteTable, sqliteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import type { SQLiteTable as SQLiteTableOld, SQLiteView as SQLiteViewOld } from 'orm044/sqlite-core';
+import { introspect } from 'src/cli/commands/pull-sqlite';
+import { suggestions } from 'src/cli/commands/push-sqlite';
+import { runWithCliContext } from 'src/cli/context';
+import { HintsHandler } from 'src/cli/hints';
+import { configMigrations } from 'src/cli/validations/common';
+import { EmptyProgressView } from 'src/cli/views';
+import { hash } from 'src/dialects/common';
+import { createDDL, fromEntities, interimToDDL, SQLiteDDL } from 'src/dialects/sqlite/ddl';
+import { ddlDiff, ddlDiffDry } from 'src/dialects/sqlite/diff';
+import { defaultFromColumn, fromDrizzleSchema, prepareFromSchemaFiles } from 'src/dialects/sqlite/drizzle';
+import { fromDatabaseForDrizzle } from 'src/dialects/sqlite/introspect';
+import { ddlToTypeScript } from 'src/dialects/sqlite/typescript';
+import { SQLiteDB } from 'src/utils';
+import { mockResolver } from 'src/utils/mocks';
+import { tsc } from 'tests/utils';
+import 'zx/globals';
+import { updateToV7 } from 'src/cli/commands/up-sqlite';
+import { serializeSQLite } from 'src/legacy/sqlite-v6/serializer';
+import { diff as legacyDiff } from 'src/legacy/sqlite-v6/sqliteDiff';
+
+mkdirSync('tests/sqlite/tmp/', { recursive: true });
+
+export type SqliteSchema = Record<string, SQLiteTable | SQLiteView | unknown>;
+export type SqliteSchemaOld = Record<string, SQLiteTableOld | SQLiteViewOld | unknown>;
+
+export const drizzleToDDL = (schema: SqliteSchema) => {
+	const tables = Object.values(schema).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
+	const views = Object.values(schema).filter((it) => is(it, SQLiteView)) as SQLiteView[];
+
+	return interimToDDL(fromDrizzleSchema(tables, views));
+};
+
+export const diff = async (
+	left: SqliteSchema | SQLiteDDL,
+	right: SqliteSchema | SQLiteDDL,
+	renamesArr: string[],
+) => {
+	const { ddl: ddl1, errors: err1 } = 'entities' in left && '_' in left
+		? { ddl: left as SQLiteDDL, errors: [] }
+		: drizzleToDDL(left);
+	const { ddl: ddl2, errors: err2 } = 'entities' in right && '_' in right
+		? { ddl: right as SQLiteDDL, errors: [] }
+		: drizzleToDDL(right);
+
+	if (err1.length > 0 || err2.length > 0) {
+		console.log('-----');
+		console.log(err1.map((it) => it.type).join('\n'));
+		console.log('-----');
+		console.log(err2.map((it) => it.type).join('\n'));
+		console.log('-----');
+	}
+
+	const renames = new Set(renamesArr);
+
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		'default',
+	);
+	return { sqlStatements, statements, err1, err2, next: ddl2 };
+};
+
+export const dbFrom = (client: Database) => {
+	return {
+		query: async <T>(sql: string, params: any[] = []) => {
+			return client.prepare(sql).bind(params).all() as T[];
+		},
+		run: async (query: string) => {
+			client.prepare(query).run();
+		},
+		batch: async (sqlStatements: string[]) => {
+			for (const sql of sqlStatements) {
+				client.prepare(sql).run();
+			}
+		},
+	};
+};
+
+export const diffAfterPull = async (
+	client: Database,
+	initSchema: SqliteSchema,
+	testName: string,
+) => {
+	const db = dbFrom(client);
+
+	const { ddl: initDDL, errors: e1 } = drizzleToDDL(initSchema);
+	const { sqlStatements: inits } = await ddlDiffDry(createDDL(), initDDL, 'push');
+	for (const st of inits) {
+		client.exec(st);
+	}
+
+	const path = `tests/sqlite/tmp/${testName}.ts`;
+
+	const schema = await fromDatabaseForDrizzle(db, () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl2, errors: err1 } = interimToDDL(schema);
+	const file = ddlToTypeScript(ddl2, 'camel', schema.viewsToColumns, 'sqlite');
+
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const res = await prepareFromSchemaFiles([path]);
+	const { ddl: ddl1, errors: err2 } = interimToDDL(fromDrizzleSchema(res.tables, res.views));
+
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(new Set()),
+		mockResolver(new Set()),
+		'push',
+	);
+
+	rmSync(path);
+
+	return { sqlStatements, statements, initDDL, ddlAfterPull: ddl1, resultDdl: ddl2 };
+};
+
+export const push = async (config: {
+	db: SQLiteDB;
+	to: SqliteSchema | SQLiteDDL;
+	renames?: string[];
+	force?: boolean;
+	expectError?: boolean;
+	log?: 'statements';
+	ignoreSubsequent?: boolean;
+	migrationsConfig?: { table?: string };
+}) => {
+	const { db, to, expectError, force, log } = config;
+
+	const migrations = configMigrations.parse(config.migrationsConfig);
+	const { ddl: ddl1, errors: err1, viewColumns } = await introspect(
+		db,
+		() => true,
+		new EmptyProgressView(),
+		() => {},
+		migrations,
+	);
+	const { ddl: ddl2, errors: err2 } = 'entities' in to && '_' in to
+		? { ddl: to as SQLiteDDL, errors: [] }
+		: drizzleToDDL(to);
+
+	if (err2.length > 0) {
+		for (const e of err2) {
+			console.error(`err2: ${JSON.stringify(e)}`);
+		}
+		throw new Error();
+	}
+
+	if (err1.length > 0) {
+		for (const e of err1) {
+			console.error(`err3: ${JSON.stringify(e)}`);
+		}
+		throw new Error();
+	}
+
+	// TODO: handle errors
+	const renames = new Set(config.renames ?? []);
+	const { sqlStatements, statements } = await ddlDiff(
+		ddl1,
+		ddl2,
+		mockResolver(renames),
+		mockResolver(renames),
+		'push',
+	);
+
+	const hints = await runWithCliContext(
+		{ output: 'text', interactive: true },
+		() => suggestions(db, statements, new HintsHandler()),
+	);
+
+	if (force) {
+		for (const st of hints) {
+			if (!st.statement) continue;
+			await db.run(st.statement);
+		}
+	}
+
+	let error: Error | null = null;
+	for (const sql of sqlStatements) {
+		if (log === 'statements') console.log(sql);
+		try {
+			await db.run(sql);
+		} catch (e) {
+			if (!expectError) throw e;
+			error = e as Error;
+			break;
+		}
+	}
+
+	// subsequent push
+	if (!config.ignoreSubsequent) {
+		const { ddl: ddl1, errors, viewColumns } = await introspect(
+			db,
+			() => true,
+			new EmptyProgressView(),
+			() => {},
+			migrations,
+		);
+
+		const { sqlStatements, statements } = await ddlDiff(
+			ddl1,
+			ddl2,
+			mockResolver(renames),
+			mockResolver(renames),
+			'push',
+		);
+		if (sqlStatements.length > 0) {
+			console.error('---- subsequent push is not empty ----');
+			console.log(sqlStatements.join('\n'));
+			throw new Error();
+		}
+	}
+
+	return { sqlStatements, statements, hints, error, next: ddl2 };
+};
+
+export const diffDefault = async <T extends SQLiteColumnBuilder>(
+	kit: TestDatabase,
+	builder: T,
+	expectedDefault: string,
+	pre: SqliteSchema | null = null,
+) => {
+	await kit.clear();
+
+	const config = (builder as any).config;
+	const def = config['default'];
+	const column = sqliteTable('table', { column: builder }).column;
+	const type = column.getSQLType();
+	const columnDefault = defaultFromColumn(column);
+	const defaultSql = columnDefault ?? '';
+
+	const res = [] as string[];
+	if (defaultSql !== expectedDefault) {
+		res.push(`Unexpected sql: \n${defaultSql}\n${expectedDefault}`);
+	}
+
+	const init = {
+		...pre,
+		table: sqliteTable('table', { column: builder }),
+	};
+
+	const { db, clear } = kit;
+	if (pre) await push({ db, to: pre });
+	const { sqlStatements: st1 } = await push({ db, to: init });
+	const { sqlStatements: st2 } = await push({ db, to: init });
+
+	const expectedInit = `CREATE TABLE \`table\` (\n\t\`column\` ${type} DEFAULT ${expectedDefault}\n);\n`;
+	if (st1.length !== 1 || st1[0] !== expectedInit) res.push(`Unexpected init:\n${st1}\n\n${expectedInit}`);
+	if (st2.length > 0) res.push(`Unexpected subsequent init:\n${st2.join('\n')}`);
+
+	// introspect to schema
+	const schema = await fromDatabaseForDrizzle(db, () => true, () => {}, {
+		schema: 'drizzle',
+		table: '__drizzle_migrations',
+	});
+	const { ddl: ddl1, errors: e1 } = interimToDDL(schema);
+
+	const file = ddlToTypeScript(ddl1, 'camel', schema.viewsToColumns, 'sqlite');
+	const path = `tests/sqlite/tmp/temp-${hash(String(Math.random()))}.ts`;
+
+	if (existsSync(path)) rmSync(path);
+	writeFileSync(path, file.file);
+	await tsc(file.file);
+
+	const response = await prepareFromSchemaFiles([path]);
+	const sch = fromDrizzleSchema(response.tables, response.views);
+	const { ddl: ddl2, errors: e3 } = interimToDDL(sch);
+
+	const { sqlStatements: afterFileSqlStatements } = await ddlDiffDry(ddl1, ddl2, 'push');
+	if (afterFileSqlStatements.length === 0) {
+		rmSync(path);
+	} else {
+		console.log(afterFileSqlStatements);
+		console.log(`./${path}`);
+	}
+
+	await clear();
+
+	config.hasDefault = false;
+	config.default = undefined;
+	const schema1 = {
+		...pre,
+		table: sqliteTable('table', { column: builder }),
+	};
+
+	config.hasDefault = true;
+	config.default = def;
+	const schema2 = {
+		...pre,
+		table: sqliteTable('table', { column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre });
+	await push({ db, to: schema1 });
+	const { sqlStatements: st3 } = await push({ db, to: schema2 });
+
+	const expectedAlter =
+		`CREATE TABLE \`__new_table\` (\n\t\`column\` ${column.getSQLType()} DEFAULT ${expectedDefault}\n);\n`;
+	if (st3.length !== 6 || st3[1] !== expectedAlter) {
+		res.push(`Unexpected default alter:\n${st3.join('\n')}\n\n${expectedAlter}`);
+	}
+
+	await clear();
+
+	const schema3 = {
+		...pre,
+		table: sqliteTable('table', { id: int() }),
+	};
+
+	const schema4 = {
+		...pre,
+		table: sqliteTable('table', { id: int(), column: builder }),
+	};
+
+	if (pre) await push({ db, to: pre });
+	await push({ db, to: schema3 });
+	const { sqlStatements: st4 } = await push({ db, to: schema4 });
+
+	const expectedAddColumn = `ALTER TABLE \`table\` ADD \`column\` ${type} DEFAULT ${expectedDefault};`;
+	if (st4.length !== 1 || st4[0] !== expectedAddColumn) {
+		res.push(`Unexpected add column:\n${st4[0]}\n\n${expectedAddColumn}`);
+	}
+
+	return res;
+};
+
+export type TestDatabase = {
+	db: SQLiteDB;
+	close: () => Promise<void>;
+	clear: () => Promise<void>;
+	getClient: () => Database;
+};
+
+export const prepareTestDatabase = () => {
+	let client = new BetterSqlite3(':memory:');
+
+	const db = {
+		query: async (sql: string, params?: any[]) => {
+			try {
+				const stmt = client.prepare(sql);
+				const res = stmt.all(...(params ?? [])) as any;
+				return res;
+			} catch (error) {
+				const newError = new Error(`query error: ${sql}\n\n${(error as Error).message}`);
+				throw newError;
+			}
+		},
+		run: async (sql: string) => {
+			try {
+				const stmt = client.prepare(sql);
+				stmt.run();
+				return;
+			} catch (error) {
+				const newError = new Error(`query error: ${sql}\n\n${(error as Error).message}`);
+				throw newError;
+			}
+		},
+		batch: async (sqlStatements: string[]) => {
+			for (const sql of sqlStatements) {
+				try {
+					const stmt = client.prepare(sql).run();
+				} catch (error) {
+					const newError = new Error(`batch error: ${sql}\n\n${(error as Error).message}`);
+					throw newError;
+				}
+			}
+		},
+	};
+	const close = async () => {
+		client.close();
+	};
+	const clear = async () => {
+		client.close();
+		client = new BetterSqlite3(':memory:');
+	};
+	const getClient = () => client;
+	return { db, close, clear, getClient };
+};
+
+export const diffSnapshotV6 = async (
+	db: SQLiteDB,
+	schema: SqliteSchema,
+	schemaOld: SqliteSchemaOld,
+	command?: 'push' | 'generate',
+) => {
+	const res = await serializeSQLite(schemaOld, 'camelCase');
+
+	const { sqlStatements } = await legacyDiff({ right: res });
+
+	for (const st of sqlStatements) {
+		await db.run(st);
+	}
+
+	const snapshot = updateToV7(res);
+
+	const ddl = fromEntities(snapshot.ddl);
+
+	let st: string[] = [];
+	let st1: string[] = [];
+	let pst: string[] = [];
+	let pst1: string[] = [];
+	if (!command || command === 'generate') {
+		const { sqlStatements: sqlStatements1, next } = await diff(ddl, schema, []);
+		const { sqlStatements: sqlStatements2 } = await diff(next, schema, []);
+
+		st = sqlStatements1;
+		st1 = sqlStatements2;
+	}
+	if (!command || command === 'push') {
+		({ sqlStatements: pst } = await push({ db, to: schema }));
+		({ sqlStatements: pst1 } = await push({ db, to: schema }));
+	}
+	return {
+		step1: st,
+		step2: pst,
+		step3: st1,
+		step4: pst1,
+		all: [
+			...st,
+			...pst,
+			...st1,
+			...pst1,
+		],
+	};
+};
diff --git a/drizzle-kit/tests/sqlite/pull.test.ts b/drizzle-kit/tests/sqlite/pull.test.ts
new file mode 100644
index 0000000000..1c3ef829d7
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/pull.test.ts
@@ -0,0 +1,579 @@
+import Database from 'better-sqlite3';
+import { SQL, sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	check,
+	customType,
+	foreignKey,
+	index,
+	int,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	sqliteView,
+	text,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import * as fs from 'fs';
+import { interimToDDL } from 'src/dialects/sqlite/ddl';
+import { fromDatabaseForDrizzle } from 'src/dialects/sqlite/introspect';
+import { expect, test } from 'vitest';
+import { dbFrom, diffAfterPull, push } from './mocks';
+
+fs.mkdirSync('tests/sqlite/tmp', { recursive: true });
+
+test('introspect tables with fk constraint', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer(),
+		name: text(),
+	});
+
+	const posts = sqliteTable('posts', {
+		id: integer(),
+		userId: integer('user_id').references(() => users.id).references(() => users.id, {
+			onDelete: 'no action',
+			onUpdate: 'no action',
+		}),
+	});
+	const schema = { users, posts };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'fk-tables');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3231
+test('introspect tables with fk constraint #2', async () => {
+	const sqlite = new Database(':memory:');
+	const db = dbFrom(sqlite);
+	await db.run('CREATE TABLE `users`(`id` integer primary key);');
+	await db.run('CREATE TABLE `posts`(`user_id` integer references `users` (`id`));');
+
+	const schema = await fromDatabaseForDrizzle(db, () => true, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+	const { ddl, errors } = interimToDDL(schema);
+
+	expect(errors.length).toBe(0);
+	expect(ddl.tables.list().length).toBe(2);
+	expect(ddl.columns.list().length).toBe(2);
+
+	expect(ddl.fks.list().length).toBe(1);
+	expect(ddl.fks.list()).toStrictEqual([
+		{
+			table: 'posts',
+			columns: ['user_id'],
+			tableTo: 'users',
+			columnsTo: ['id'],
+			onUpdate: 'NO ACTION',
+			onDelete: 'NO ACTION',
+			nameExplicit: true,
+			name: 'fk_posts_user_id_users_id_fk',
+			entityType: 'fks',
+		},
+	]);
+
+	expect(ddl.pks.list().length).toBe(1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4247
+test('introspect table with self reference', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer(),
+		name: text(),
+		invited_id: integer().references((): AnySQLiteColumn => users.id),
+	});
+
+	const schema = { users };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'self-ref-table');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect table fk on multiple columns', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer(),
+		name: text(),
+		invited_id: integer(),
+	});
+
+	const ref = sqliteTable('ref', {
+		id: integer(),
+		name: text(),
+		invited_id: integer(),
+	}, (t) => [foreignKey({ columns: [t.name, t.invited_id], foreignColumns: [users.name, users.invited_id] })]);
+
+	const schema = { users, ref };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'composite-fk');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('composite fk introspect self ref', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer(),
+		name: text(),
+		invited_id: integer(),
+	}, (t) => [foreignKey({ columns: [t.name, t.invited_id], foreignColumns: [t.name, t.invited_id] })]);
+
+	const schema = { users };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'composite-fk-self-ref');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated always column: link to another column', async () => {
+	const sqlite = new Database(':memory:');
+
+	const schema = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs((): SQL => sql`\`email\``),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'generated-link-column');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated always column virtual: link to another column', async () => {
+	const sqlite = new Database(':memory:');
+
+	const schema = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			email: text('email'),
+			generatedEmail: text('generatedEmail').generatedAlwaysAs((): SQL => sql`\`email\``, { mode: 'virtual' }),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'generated-link-column-virtual');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('complex generated always', async () => {
+	const sqlite = new Database(':memory:');
+
+	const generatedExpression = `trim(
+		coalesce(\`first_name\`, '') || ' ' || coalesce(\`last_name\`, '') ||
+		(CASE WHEN nullif(trim(coalesce(\`suffix\`, '')), '') IS NOT NULL THEN ' ' || trim(coalesce(\`suffix\`, '')) ELSE '' END)
+	)`;
+
+	const schema = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			firstName: text('first_name'),
+			lastName: text('last_name'),
+			suffix: text('suffix'),
+			fullName: text('full_name').generatedAlwaysAs((): SQL => sql.raw(generatedExpression), { mode: 'virtual' }),
+		}),
+	};
+
+	const { statements, sqlStatements, initDDL, resultDdl } = await diffAfterPull(
+		sqlite,
+		schema,
+		'complex generated always',
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+	expect(
+		initDDL.columns.one({ name: 'full_name' })?.generated,
+	).toEqual({
+		as: `(${generatedExpression})`,
+		type: 'virtual',
+	});
+	expect(
+		resultDdl.columns.one({ name: 'full_name' })?.generated,
+	).toEqual({
+		as: `(${generatedExpression})`,
+		type: 'virtual',
+	});
+});
+
+test('instrospect strings with single quotes', async () => {
+	const sqlite = new Database(':memory:');
+
+	const schema = {
+		columns: sqliteTable('columns', {
+			text: text('text').default('escape\'s quotes " '),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'introspect-strings-with-single-quotes');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4582
+test('introspect checks', async () => {
+	const sqlite = new Database(':memory:');
+
+	const initSchema = {
+		users: sqliteTable(
+			'users',
+			{
+				id: int('id'),
+				name: text('name'),
+				age: int('age'),
+			},
+			(
+				table,
+			) => [check('some_check1', sql`${table.age} > 21`), check('some_check2', sql`${table.age} IN (21, 22, 23)`)],
+		),
+	};
+
+	const db = dbFrom(sqlite);
+	await push({
+		db,
+		to: initSchema,
+	});
+
+	const schema = await fromDatabaseForDrizzle(db, () => true, () => {}, {
+		table: '__drizzle_migrations',
+		schema: 'drizzle',
+	});
+	const { ddl, errors } = interimToDDL(schema);
+
+	expect(errors.length).toBe(0);
+	expect(ddl.checks.list().length).toBe(2);
+	expect(ddl.checks.list()[0].name).toBe('some_check1');
+	expect(ddl.checks.list()[0].value).toBe('"age" > 21');
+	expect(ddl.checks.list()[1].name).toBe('some_check2');
+	expect(ddl.checks.list()[1].value).toBe('"age" IN (21, 22, 23)');
+});
+
+test('view #1', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', { id: int('id') });
+	const testView = sqliteView('some_view', { id: int('id') }).as(sql`SELECT * FROM ${users}`);
+	// view with \n newlines
+	const testView2 = sqliteView('some_view2', { id: int('id') }).as(
+		sql`SELECT\n*\nFROM\n${users}`,
+	);
+	const testView3 = sqliteView('some_view3', { id: int('id') }).as(
+		sql`WITH temp as (SELECT 1) SELECT\n*\nFROM\n${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView,
+		testView2,
+		testView3,
+	};
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'view-1');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3674
+test('view #2', async () => {
+	const sqlite = new Database(':memory:');
+
+	const userLogs = sqliteTable('user_logs', {
+		id: text().primaryKey(),
+		userId: text('user_id').notNull(),
+		type: text().notNull(),
+		entry: text().notNull(),
+		dtTimestamp: integer('dt_timestamp').notNull(),
+	});
+
+	const latestUserLogs = sqliteView('latest_user_logs', {
+		id: text(),
+		userId: text(),
+		entry: text(),
+		dtTimestamp: integer(),
+	}).as(sql`WITH ranked_logs AS (
+  SELECT
+	ul.id,
+	ul.user_id,
+	ul.entry,
+	ul.dt_timestamp,
+	ROW_NUMBER() OVER (
+	  PARTITION BY
+		ul.user_id,
+		ul.type,
+		date(datetime(ul.dt_timestamp, 'unixepoch'))
+	  ORDER BY ul.dt_timestamp DESC
+	) AS rn
+  FROM user_logs ul
+)
+SELECT
+  id,
+  user_id,
+  entry,
+  dt_timestamp
+FROM ranked_logs
+WHERE rn = 1
+ORDER BY dt_timestamp DESC`);
+
+	const schema = { userLogs, latestUserLogs };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'view-2');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4582
+test('view #3 aggregate function', async () => {
+	const sqlite = new Database(':memory:');
+
+	const orderDetails = sqliteTable(
+		'Order Details',
+		{
+			orderId: integer('OrderID').notNull(),
+			productId: integer('ProductID').notNull(),
+			unitPrice: numeric('UnitPrice', { mode: 'number' }).default(0).notNull(),
+			quantity: integer('Quantity').default(1).notNull(),
+			discount: real('Discount').default(0).notNull(),
+		},
+		(
+			table,
+		) => [
+			primaryKey({ columns: [table.orderId, table.productId], name: 'Order Details_pk' }),
+			check('Order Details_check_1', sql`[Discount]>=(0) AND [Discount]<=(1)`),
+			check('Order Details_check_2', sql`[Quantity]>(0)`),
+			check('Order Details_check_3', sql`[UnitPrice]>=(0)`),
+		],
+	);
+
+	const orderSubtotals = sqliteView('Order Subtotals', {
+		orderId: integer(),
+		subtotal: real(), // It seems that the aggregated column type of a view is not stored in the database.
+		// Instead, you can only determine its runtime storage class by running the following query once the view has rows.
+		// SELECT typeof(Subtotal) FROM [Order Subtotals];
+	}).as(sql`SELECT [Order Details].OrderID,
+		Sum(([Order Details].UnitPrice*Quantity*(1-Discount)/100)*100) AS Subtotal
+		FROM [Order Details]
+		GROUP BY [Order Details].OrderID`);
+
+	const schema = { orderDetails, orderSubtotals };
+
+	const { statements, sqlStatements } = await diffAfterPull(sqlite, schema, 'view-3');
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('broken view', async () => {
+	const sqlite = new Database(':memory:');
+
+	const users = sqliteTable('users', { id: int('id') });
+	const testView1 = sqliteView('some_view1', { id: int('id') }).as(sql`SELECT id FROM ${users}`);
+	const testView2 = sqliteView('some_view2', { id: int('id'), name: text('name') }).as(
+		sql`SELECT id, name FROM ${users}`,
+	);
+
+	const schema = {
+		users: users,
+		testView1,
+		testView2,
+	};
+
+	const { statements, sqlStatements, resultDdl } = await diffAfterPull(sqlite, schema, 'broken-view');
+
+	expect(
+		resultDdl.views.one({
+			name: 'some_view2',
+		})?.error,
+	).toBeTypeOf('string');
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5053
+test('single quote default', async () => {
+	const sqlite = new Database(':memory:');
+
+	const group = sqliteTable('group', {
+		id: text().notNull(),
+		fk_organizaton_group: text().notNull(),
+		saml_identifier: text().default('').notNull(),
+		display_name: text().default('').notNull(),
+	});
+
+	const { sqlStatements } = await diffAfterPull(sqlite, { group }, 'single_quote_default');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2827
+test('introspect text type', async () => {
+	const sqlite = new Database(':memory:');
+
+	const table = sqliteTable('table', {
+		text1: text().notNull().default(sql`CURRENT_TIMESTAMP`),
+		text2: text().default(''),
+		text3: text().default('``'),
+	});
+
+	const { sqlStatements } = await diffAfterPull(sqlite, { table }, 'introspect_text_type');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3590
+test('introspect composite pk + check', async () => {
+	const sqlite = new Database(':memory:');
+
+	const schema = {
+		table2: sqliteTable('table2', {
+			column1: text().notNull(),
+			column2: text().notNull(),
+			column3: text().notNull(),
+		}, (table) => [
+			primaryKey({ columns: [table.column1, table.column2], name: 'table2_pk' }),
+			check('table2_check_1', sql`"column3" IN ('1', '2')`),
+		]),
+	};
+
+	const { sqlStatements } = await diffAfterPull(sqlite, schema, 'introspect_composite_pk_check');
+
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('introspect unique constraint', async () => {
+	const sqlite = new Database(':memory:');
+
+	const schema = {
+		table: sqliteTable('table', {
+			col1: text('col1'),
+			col2: integer('col2').unique(),
+		}, (t) => [
+			uniqueIndex('some_idx').on(t.col1),
+		]),
+	};
+
+	const { sqlStatements } = await diffAfterPull(sqlite, schema, 'introspect_unique_constraint');
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3047
+test('create table with custom type column', async (t) => {
+	const sqlite = new Database(':memory:');
+
+	const f32Blob = customType<{
+		data: number[];
+		config: {
+			length: number;
+		};
+		configRequired: true;
+	}>({
+		dataType(conf: { length: number }) {
+			return `F32_BLOB(${conf.length})`;
+		},
+		fromDriver(value: Buffer) {
+			const fArr = new Float32Array(new Uint8Array(value).buffer);
+			return Array.from(fArr);
+		},
+
+		toDriver(value: number[]) {
+			return Buffer.from(new Float32Array(value).buffer);
+		},
+	});
+	const schema = {
+		table1: sqliteTable('table1', {
+			id: text('id').primaryKey(),
+			blob: f32Blob('blob', {
+				length: 10,
+			}),
+		}),
+	};
+
+	const { sqlStatements } = await diffAfterPull(sqlite, schema, 'table-with-custom-type-column');
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+// filter default migration table
+test('pull after migrate with custom migrations table #1', async () => {
+	const sqlite = new Database(':memory:');
+	const db = dbFrom(sqlite);
+
+	await db.run(`
+		CREATE TABLE IF NOT EXISTS __drizzle_migrations (
+			id INTEGER PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.run(`
+		CREATE TABLE IF NOT EXISTS users (
+			id INTEGER PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { pks, columns, tables } = await fromDatabaseForDrizzle(
+		db,
+		() => true,
+		() => {},
+		{
+			table: '__drizzle_migrations',
+			schema: 'drizzle',
+		},
+	);
+
+	expect([...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			name: 'users',
+		},
+	]);
+});
+
+// filter custom migration table
+test('pull after migrate with custom migrations table #2', async () => {
+	const sqlite = new Database(':memory:');
+	const db = dbFrom(sqlite);
+
+	await db.run(`
+		CREATE TABLE IF NOT EXISTS custom_migrations (
+			id INTEGER PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+	await db.run(`
+		CREATE TABLE IF NOT EXISTS users (
+			id INTEGER PRIMARY KEY,
+			name TEXT NOT NULL
+		);
+	`);
+
+	const { tables, pks } = await fromDatabaseForDrizzle(
+		db,
+		() => true,
+		() => {},
+		{
+			table: 'custom_migrations',
+			schema: 'drizzle', // default from prepare params
+		},
+	);
+
+	expect([...tables, ...pks]).toStrictEqual([
+		{
+			entityType: 'tables',
+			name: 'users',
+		},
+	]);
+});
diff --git a/drizzle-kit/tests/sqlite/snapshot-v6.test.ts b/drizzle-kit/tests/sqlite/snapshot-v6.test.ts
new file mode 100644
index 0000000000..581a39ab24
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshot-v6.test.ts
@@ -0,0 +1,57 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diffSnapshotV6, prepareTestDatabase, TestDatabase } from './mocks';
+import * as s01 from './snapshots/schema01';
+import * as s01new from './snapshots/schema01new';
+import * as s02 from './snapshots/schema02';
+import * as s02new from './snapshots/schema02new';
+import * as s03Generate from './snapshots/schema03-generate';
+import * as s03Push from './snapshots/schema03-push';
+import * as s03newGenerate from './snapshots/schema03new-generate';
+import * as s03newPush from './snapshots/schema03new-push';
+import * as s04 from './snapshots/schema04';
+import * as s04new from './snapshots/schema04new';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('s01', async (t) => {
+	const res = await diffSnapshotV6(db, s01new, s01);
+	expect(res.all).toStrictEqual([]);
+});
+
+test('s02', async (t) => {
+	const res = await diffSnapshotV6(db, s02new, s02);
+	expect(res.all).toStrictEqual([]);
+});
+
+// fk namings
+// old kit did not store fk names
+// that is okay for generate, but for push db will not have any name
+test('s03', async (t) => {
+	const res1 = await diffSnapshotV6(db, s03newGenerate, s03Generate, 'generate');
+
+	_.clear();
+
+	const res2 = await diffSnapshotV6(db, s03newPush, s03Push, 'push');
+	expect([...res1.all]).toStrictEqual([]);
+	expect([...res2.all]).toStrictEqual([]);
+});
+
+test('s04', async (t) => {
+	const res = await diffSnapshotV6(db, s04new, s04);
+	expect(res.all).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema01.ts b/drizzle-kit/tests/sqlite/snapshots/schema01.ts
new file mode 100644
index 0000000000..c083d12e20
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema01.ts
@@ -0,0 +1,50 @@
+import {
+	AnySQLiteColumn,
+	foreignKey,
+	int,
+	integer,
+	primaryKey,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'orm044/sqlite-core';
+
+export const users = sqliteTable('users', {
+	id: int().primaryKey(),
+	text: text(),
+	text1: text(),
+	text2: text(),
+}, (t) => [unique().on(t.text1, t.text2)]);
+
+export const users1 = sqliteTable('users1', {
+	id1: integer(),
+	id2: integer(),
+}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]);
+
+export const users2 = sqliteTable('users2', {
+	id: int(),
+	c1: text(),
+	c2: text(),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+
+export const users3 = sqliteTable('users3', {
+	c1: text(),
+	c2: text(),
+	c3: text(),
+}, (t) => [
+	unique(`name_some`).on(t.c1),
+	unique('u3c2unique').on(t.c2),
+	uniqueIndex('u3c2c3unique').on(t.c2, t.c3),
+]);
+
+export const users4 = sqliteTable('users4', {
+	c1: text().references(() => users3.c1),
+	c2: text().references((): AnySQLiteColumn => users4.c1),
+	c3: text(),
+	c4: text(),
+}, (t) => [foreignKey({ columns: [t.c3, t.c4], foreignColumns: [users3.c2, users3.c3] })]);
+
+export const users5 = sqliteTable('users5', {
+	fullName: text(),
+});
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema01new.ts b/drizzle-kit/tests/sqlite/snapshots/schema01new.ts
new file mode 100644
index 0000000000..f7463f30da
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema01new.ts
@@ -0,0 +1,49 @@
+import {
+	AnySQLiteColumn,
+	foreignKey,
+	int,
+	integer,
+	primaryKey,
+	sqliteTable,
+	text,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+	id: int().primaryKey(),
+	text: text(),
+	text1: text(),
+	text2: text(),
+}, (t) => [uniqueIndex(`users_text1_text2_unique`).on(t.text1, t.text2)]);
+
+export const users1 = sqliteTable('users1', {
+	id1: integer(),
+	id2: integer(),
+}, (t) => [primaryKey({ columns: [t.id1, t.id2] })]);
+
+export const users2 = sqliteTable('users2', {
+	id: int(),
+	c1: text(),
+	c2: text(),
+}, (t) => [primaryKey({ columns: [t.id] })]);
+
+export const users3 = sqliteTable('users3', {
+	c1: text(),
+	c2: text(),
+	c3: text(),
+}, (t) => [
+	uniqueIndex(`name_some`).on(t.c1),
+	uniqueIndex('u3c2unique').on(t.c2),
+	uniqueIndex('u3c2c3unique').on(t.c2, t.c3),
+]);
+
+export const users4 = sqliteTable('users4', {
+	c1: text().references(() => users3.c1),
+	c2: text().references((): AnySQLiteColumn => users4.c1),
+	c3: text(),
+	c4: text(),
+}, (t) => [foreignKey({ columns: [t.c3, t.c4], foreignColumns: [users3.c2, users3.c3] })]);
+
+export const users5 = sqliteTable('users5', {
+	fullName: text(),
+});
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema02.ts b/drizzle-kit/tests/sqlite/snapshots/schema02.ts
new file mode 100644
index 0000000000..25120f3c16
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema02.ts
@@ -0,0 +1,986 @@
+import { SQL, sql } from 'orm044';
+import { blob, index, integer, primaryKey, real, sqliteTable, text, unique, uniqueIndex } from 'orm044/sqlite-core';
+import { v4 } from 'uuid';
+
+type EntityClass = 'ALPHA' | 'BETA' | 'GAMMA';
+type AccessLevel = 'STANDARD' | 'PREMIUM';
+type ProcessStage = 'INITIAL' | 'COMPLETE';
+
+export const profiles = sqliteTable(
+	'profiles',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey(),
+		externalRef: text({ length: 255 }).notNull(),
+		serviceRef: text(),
+		contactEmail: text({ length: 255 }).notNull(),
+		givenName: text({ length: 100 }).notNull(),
+		familyName: text({ length: 100 }).notNull(),
+		accessLevel: text().$type<AccessLevel>().notNull(),
+		birthDate: text(),
+		classification: text({ length: 50 }).$type<EntityClass>(),
+		contactNumber: text({ length: 20 }),
+		currentStage: text().$type<ProcessStage>().default('INITIAL').notNull(),
+		// Location fields
+		recipientName: text({ length: 255 }),
+		primaryAddress: text({ length: 255 }),
+		secondaryAddress: text({ length: 255 }),
+		locality: text({ length: 100 }),
+		region: text({ length: 2 }),
+		postalCode: text({ length: 10 }),
+		territory: text({ length: 2 }).default('US').notNull(),
+		// Additional profile fields
+		avatarUrl: text({ length: 255 }),
+		lastAccessAt: integer({ mode: 'timestamp_ms' }).default(new Date('2023-12-12')),
+		emailConfirmed: integer({ mode: 'boolean' }).default(false).notNull(),
+		phoneConfirmed: integer({ mode: 'boolean' }).default(false).notNull(),
+		// Timestamps
+		createdAt: integer({ mode: 'timestamp' })
+			.default(sql`(CURRENT_TIMESTAMP)`)
+			.notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(profiles) => [
+		index('index_1').on(profiles.serviceRef),
+		index('index_2').on(profiles.contactEmail),
+		index('index_3').on(profiles.externalRef),
+	],
+);
+
+export type Profile = typeof profiles.$inferSelect;
+export type ProfileToInsert = typeof profiles.$inferInsert;
+
+export const profileAgreements = sqliteTable(
+	'profile_agreements',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: blob()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		privacyConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		serviceConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		termsConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		agreementDate: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [unique('index_4').on(table.profileId)],
+);
+
+export type ProfileAgreement = typeof profileAgreements.$inferSelect;
+export type ProfileAgreementToInsert = typeof profileAgreements.$inferInsert;
+
+export const facilities = sqliteTable('facilities', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	facilityName: text({ length: 255 }).notNull(),
+	serviceId: integer().notNull(),
+	createdAt: integer({ mode: 'timestamp_ms' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp_ms' }).notNull(),
+});
+
+export type Facility = typeof facilities.$inferSelect;
+export type FacilityToInsert = typeof facilities.$inferInsert;
+
+export const identifiers = sqliteTable('identifiers', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	code: text({ length: 50 }).notNull(),
+	displayName: text({ length: 255 }).notNull(),
+	description: text(),
+	slug: text({ length: 255 }).notNull(),
+	measurementUnit: text({ length: 50 }),
+	standardRanges: text({ mode: 'json' }),
+	guidelines: text({ mode: 'json' }),
+	evaluationRules: text({ mode: 'json' }),
+	isFeatured: integer({ mode: 'boolean' }).default(false),
+});
+
+export type Identifier = typeof identifiers.$inferSelect;
+export type IdentifierToInsert = typeof identifiers.$inferInsert;
+
+export const classifications = sqliteTable('classifications', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	categoryName: text({ length: 255 }).notNull(),
+	iconType: text({ length: 255 }),
+	themeColor: text({ length: 255 }),
+});
+
+export type Classification = typeof classifications.$inferSelect;
+export type ClassificationToInsert = typeof classifications.$inferInsert;
+
+export const identifierClassifications = sqliteTable(
+	'identifier_classifications',
+	{
+		identifierId: blob().references(() => identifiers.id),
+		classificationId: text().references(() => classifications.id),
+	},
+	(table) => [
+		primaryKey({ columns: [table.identifierId, table.classificationId] }),
+	],
+);
+
+export type IdentifierClassification = typeof identifierClassifications.$inferSelect;
+export type IdentifierClassificationToInsert = typeof identifierClassifications.$inferInsert;
+
+export const impactFactors = sqliteTable('impact_factors', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	factorName: text({ length: 255 }).notNull(),
+});
+
+export type ImpactFactor = typeof impactFactors.$inferSelect;
+export type ImpactFactorToInsert = typeof impactFactors.$inferInsert;
+
+export const impactFactorsToIdentifiers = sqliteTable(
+	'impact_factors_to_identifiers',
+	{
+		impactFactorId: text().references(() => impactFactors.id),
+		identifierId: text().references(() => identifiers.id),
+	},
+);
+
+export type ImpactFactorsToIdentifiers = typeof impactFactorsToIdentifiers.$inferSelect;
+export type ImpactFactorsToIdentifiersToInsert = typeof impactFactorsToIdentifiers.$inferInsert;
+
+export const metricClusters = sqliteTable('metric_clusters', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	clusterName: text({ length: 255 }).notNull(),
+	slug: text({ length: 255 }).notNull(),
+	description: text(),
+	metricType: text({ length: 50 }).default('standard').notNull(),
+	measurementUnit: text({ length: 50 }),
+	isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+});
+
+export type MetricCluster = typeof metricClusters.$inferSelect;
+export type MetricClusterToInsert = typeof metricClusters.$inferInsert;
+
+export const metricPreferences = sqliteTable(
+	'metric_preferences',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: blob().references(() => profiles.id),
+		identifierId: text().references(() => identifiers.id),
+	},
+	(table) => [
+		index('index_5').on(table.profileId),
+		index('index_6').on(table.identifierId),
+	],
+);
+
+export type MetricPreference = typeof metricPreferences.$inferSelect;
+export type MetricPreferenceToInsert = typeof metricPreferences.$inferInsert;
+
+export const dataPoints = sqliteTable(
+	'data_points',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		pointId: integer().notNull(),
+		clusterId: text().references(() => metricClusters.id),
+		identifierId: blob().references(() => identifiers.id),
+		pointName: text({ length: 255 }).notNull(),
+		description: text(),
+		dataType: text({ length: 50 }).default('standard').notNull(),
+		isParent: integer({ mode: 'boolean' }).default(false).notNull(),
+		measurementUnit: text({ length: 50 }),
+		baseRate: real(),
+		baseCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${dataPoints.baseRate} * 100`,
+		),
+		facilityId: blob()
+			.references(() => facilities.id)
+			.notNull(),
+		isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+		visualType: text({ length: 50 }).default('numeric-trend'),
+	},
+	(table) => [uniqueIndex('index_7').on(table.clusterId, table.facilityId)],
+);
+
+export type DataPoint = typeof dataPoints.$inferSelect;
+export type DataPointToInsert = typeof dataPoints.$inferInsert;
+
+export const dataPointRelationships = sqliteTable(
+	'data_point_relationships',
+	{
+		parentId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		childId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.parentId, table.childId] }),
+		index('idx_data_point_relationships_child_id').on(table.childId),
+	],
+);
+
+export type DataPointRelationship = typeof dataPointRelationships.$inferSelect;
+export type DataPointRelationshipToInsert = typeof dataPointRelationships.$inferInsert;
+
+export const packageClusters = sqliteTable('package_clusters', {
+	id: text()
+		.$default(() => v4())
+		.primaryKey(),
+	packageName: text({ length: 255 }).notNull(),
+	slug: text({ length: 255 }).notNull(),
+	description: text(),
+	partnerId: text().references(() => partners.partnerId, {
+		onDelete: 'set null',
+	}),
+	isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+	createdAt: integer({ mode: 'timestamp' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp' }).notNull(),
+});
+
+export type PackageCluster = typeof packageClusters.$inferSelect;
+export type PackageClusterToInsert = typeof packageClusters.$inferInsert;
+
+export const servicePackages = sqliteTable(
+	'service_packages',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		clusterId: text()
+			.references(() => packageClusters.id)
+			.notNull(),
+		packageTitle: text({ length: 255 }),
+		description: text(),
+		serviceRef: text({ length: 100 }).notNull(),
+		baseRate: real().notNull(),
+		baseCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${servicePackages.baseRate} * 100`,
+		),
+		discountRate: real(),
+		discountCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${servicePackages.discountRate} * 100`,
+		),
+		facilityId: text()
+			.references(() => facilities.id)
+			.notNull(),
+		isPartnerCreated: integer({ mode: 'boolean' }).default(false).notNull(),
+		allowsRemoteCollection: integer({ mode: 'boolean' })
+			.default(false)
+			.notNull(),
+		partnerId: text().references(() => partners.partnerId),
+		isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('uk_service_packages_clusterId_facilityId').on(
+			table.clusterId,
+			table.facilityId,
+		),
+	],
+);
+
+export type ServicePackage = typeof servicePackages.$inferSelect;
+export type ServicePackageToInsert = typeof servicePackages.$inferInsert;
+
+export const servicePackageDataPoints = sqliteTable(
+	'service_package_data_points',
+	{
+		packageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [primaryKey({ columns: [table.packageId, table.dataPointId] })],
+);
+
+export type ServicePackageDataPoint = typeof servicePackageDataPoints.$inferSelect;
+export type ServicePackageDataPointToInsert = typeof servicePackageDataPoints.$inferInsert;
+
+export const collectionEvents = sqliteTable('collection_events', {
+	id: text()
+		.$default(() => v4())
+		.primaryKey(),
+	requestId: text().references(() => requests.id, {
+		onDelete: 'cascade',
+	}),
+	profileId: text().references(() => profiles.id, { onDelete: 'cascade' }),
+	facilityId: text().references(() => facilities.id),
+	collectionDate: integer({ mode: 'timestamp' }),
+	reportDate: integer({ mode: 'timestamp' }),
+	receivedDate: integer({ mode: 'timestamp' }),
+	eventStatus: text({ length: 50 }).default('initiated'),
+	dataSource: text({ length: 50 }).default(''),
+	specimenRef: text({ length: 100 }),
+	eventMetadata: text(),
+	documentUrl: text({ length: 255 }),
+	hasNewData: integer({ mode: 'boolean' }).notNull().default(false),
+	createdAt: integer({ mode: 'timestamp' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp' }).notNull(),
+});
+
+export type CollectionEvent = typeof collectionEvents.$inferSelect;
+export type CollectionEventToInsert = typeof collectionEvents.$inferInsert;
+
+export const measurements = sqliteTable(
+	'measurements',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		measurementName: text(),
+		slug: text(),
+		eventId: text().references(() => collectionEvents.id, {
+			onDelete: 'cascade',
+		}),
+		profileId: text().references(() => profiles.id),
+		dataPointId: text().references(() => dataPoints.id),
+		identifierId: text().references(() => identifiers.id),
+		resultValue: text(),
+		numericResult: real(),
+		rawResult: text({ length: 50 }),
+		measurementUnit: text({ length: 50 }),
+		facilityInterpretation: text({ length: 50 }),
+		facilityMinRange: real(),
+		facilityMaxRange: real(),
+		systemNotes: text(),
+		profileNotes: text(),
+		profileActions: text(),
+		measurementMetadata: text(),
+		processingStatus: text({ length: 50 }).default('partial_data'),
+		recordedAt: integer({ mode: 'timestamp' }).notNull(),
+		isNotified: integer({ mode: 'boolean' }).default(false),
+		isArchived: integer({ mode: 'boolean' }).default(false),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('idx_measurements_eventId').on(table.eventId),
+		index('idx_measurements_identifierId').on(table.identifierId),
+		index('idx_measurements_dataPointId').on(table.dataPointId),
+	],
+);
+
+export type Measurement = typeof measurements.$inferSelect;
+export type MeasurementToInsert = typeof measurements.$inferInsert;
+
+export const partners = sqliteTable(
+	'partners',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		partnerId: text().notNull(),
+		slug: text({ length: 255 }),
+		promoCode: text(),
+		referralCode: text(),
+		partnerFirstName: text({ length: 255 }).notNull(),
+		partnerLastName: text({ length: 255 }).notNull(),
+		displayName: text({ length: 255 }),
+		description: text(),
+		logoUrl: text({ length: 255 }),
+		isActive: integer({ mode: 'boolean' }).default(true),
+		partnerMetadata: text(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(partners) => [
+		index('idx_partners_promoCode').on(partners.promoCode),
+		index('idx_partners_partnerId').on(partners.partnerId),
+	],
+);
+
+export type Partner = typeof partners.$inferSelect;
+
+// export const partnerRelationships = sqliteTable(
+// 	'partner_relationships',
+// 	{
+// 		parentPartnerId: text()
+// 			.references(() => partners.id, { onDelete: 'cascade' })
+// 			.notNull(),
+// 		childPartnerId: text()
+// 			.references(() => partners.id, { onDelete: 'cascade' })
+// 			.notNull(),
+// 		createdAt: integer({ mode: 'timestamp' }).notNull(),
+// 	},
+// 	(table) => [
+// 		primaryKey({ columns: [table.parentPartnerId, table.childPartnerId] }),
+// 		index('idx_partner_relationships_childPartnerId').on(table.childPartnerId),
+// 	],
+// );
+
+export type RequestStatus =
+	| 'pending'
+	| 'processed'
+	| 'processing_failed'
+	| 'service_creation_failed'
+	| 'service_results_failed'
+	| 'refund_pending'
+	| 'refunded'
+	| 'refund_failed'
+	| 'processing_cancellation'
+	| 'received.standard.ordered'
+	| 'received.standard.document_created'
+	| 'sample_processing.standard.partial_data'
+	| 'collecting_sample.standard.appointment_scheduled'
+	| 'completed.standard.completed'
+	| 'failed.standard.sample_error'
+	| 'cancelled.standard.cancelled'
+	| 'received.remote.ordered'
+	| 'received.remote.document_created'
+	| 'collecting_sample.remote.appointment_scheduled'
+	| 'sample_processing.remote.partial_data'
+	| 'completed.remote.completed'
+	| 'cancelled.remote.cancelled';
+
+// export const serviceRequestStatuses: RequestStatus[] = [
+// 	'service_results_failed',
+// 	'received.standard.ordered',
+// 	'received.standard.document_created',
+// 	'sample_processing.standard.partial_data',
+// 	'completed.standard.completed',
+// 	'failed.standard.sample_error',
+// 	'cancelled.standard.cancelled',
+// 	'received.remote.ordered',
+// 	'received.remote.document_created',
+// 	'collecting_sample.remote.appointment_scheduled',
+// 	'sample_processing.remote.partial_data',
+// 	'completed.remote.completed',
+// 	'cancelled.remote.cancelled',
+// ];
+
+export interface Location {
+	primaryAddress: string;
+	secondaryAddress?: string;
+	locality: string;
+	region: string;
+	postalCode: string;
+	territory: string;
+}
+
+export type RequestType = 'standard' | 'remote';
+
+export const requests = sqliteTable(
+	'requests',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		requestNumber: integer().notNull(),
+		serviceRequestId: text(),
+		totalAmount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${requests.totalAmount} * 100`,
+		),
+		requestStatus: text({ length: 100 }).$type<RequestStatus>().notNull(),
+		promoCode: text(),
+		referralCode: text(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		facilityId: text().references(() => facilities.id, {
+			onDelete: 'set null',
+		}),
+		receiptUrl: text({ length: 255 }),
+		itemCount: integer().notNull(),
+		requestMetadata: text(),
+		requestType: text().$type<RequestType>().default('standard').notNull(),
+		location: text().$type<Location>(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('requests_profileId_idx').on(table.profileId),
+		index('requests_requestNumber_idx').on(table.requestNumber),
+		index('requests_requestStatus_idx').on(table.requestStatus),
+		index('requests_serviceRequestId_idx').on(table.serviceRequestId),
+		index('requests_promoCode_idx').on(table.promoCode),
+		index('requests_referralCode_idx').on(table.referralCode),
+		index('requests_requestType_idx').on(table.requestType),
+	],
+);
+
+export type Request = typeof requests.$inferSelect;
+export type RequestToInsert = typeof requests.$inferInsert;
+
+export const requestsToDataPoints = sqliteTable(
+	'requests_to_data_points',
+	{
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		itemRate: real().notNull(),
+		centRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${requestsToDataPoints.itemRate} * 100`,
+		),
+	},
+	(table) => [
+		index('requestsToDataPoints_requestId_idx').on(table.requestId),
+		index('requestsToDataPoints_dataPointId_idx').on(table.dataPointId),
+	],
+);
+
+export type RequestToDataPoint = typeof requestsToDataPoints.$inferSelect;
+export type RequestToDataPointToInsert = typeof requestsToDataPoints.$inferInsert;
+
+export const requestsToServicePackages = sqliteTable(
+	'requests_to_service_packages',
+	{
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		servicePackageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+		packageRate: real().notNull(),
+		centRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${requestsToServicePackages.packageRate} * 100`,
+		),
+	},
+	(table) => [
+		index('requestsToServicePackages_requestId_idx').on(table.requestId),
+		index('requestsToServicePackages_servicePackageId_idx').on(
+			table.servicePackageId,
+		),
+	],
+);
+
+export type RequestToServicePackage = typeof requestsToServicePackages.$inferSelect;
+export type RequestToServicePackageToInsert = typeof requestsToServicePackages.$inferInsert;
+
+export const selections = sqliteTable(
+	'selections',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		facilityId: text().references(() => facilities.id),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('selections_profileId_idx').on(table.profileId),
+		index('selections_facilityId_idx').on(table.facilityId),
+		unique('selections_id_profileId_unique').on(table.id, table.profileId),
+	],
+);
+
+export type Selection = typeof selections.$inferSelect;
+export type SelectionToInsert = typeof selections.$inferInsert;
+
+export const selectionsToDataPoints = sqliteTable(
+	'selections_to_data_points',
+	{
+		selectionId: text()
+			.references(() => selections.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+	},
+	(table) => [
+		index('selectionsToDataPoints_selectionId_idx').on(table.selectionId),
+		index('selectionsToDataPoints_dataPointId_idx').on(table.dataPointId),
+		uniqueIndex('selectionsToDataPoints_selectionId_dataPointId_unique').on(
+			table.selectionId,
+			table.dataPointId,
+		),
+	],
+);
+
+export type SelectionToDataPoint = typeof selectionsToDataPoints.$inferSelect;
+
+export const selectionsToServicePackages = sqliteTable(
+	'selections_to_service_packages',
+	{
+		selectionId: text()
+			.references(() => selections.id, { onDelete: 'cascade' })
+			.notNull(),
+		servicePackageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+	},
+	(table) => [
+		index('selectionsToServicePackages_selectionId_idx').on(table.selectionId),
+		index('selectionsToServicePackages_servicePackageId_idx').on(
+			table.servicePackageId,
+		),
+		uniqueIndex(
+			'selectionsToServicePackages_selectionId_servicePackageId_unique',
+		).on(table.selectionId, table.servicePackageId),
+	],
+);
+
+export type SelectionToServicePackage = typeof selectionsToServicePackages.$inferSelect;
+
+export type ProcessorPaymentStatus =
+	| 'PENDING'
+	| 'SUCCESS'
+	| 'DECLINE'
+	| 'UNKNOWN';
+export type PaymentProcessor = 'PROCESSOR_A' | 'PROCESSOR_B';
+
+export const transactions = sqliteTable(
+	'transactions',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		token: text(),
+		transactionId: text().notNull(),
+		sourceId: text(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		requestId: text()
+			.references(() => requests.id)
+			.notNull(),
+		transactionStatus: text({ length: 50 }).notNull(),
+		amount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${transactions.amount} * 100`,
+		),
+		currency: text({ length: 10 }).notNull(),
+		responseData: text(),
+		transactionMetadata: text(),
+		processor: text()
+			.$type<PaymentProcessor>()
+			.notNull()
+			.default('PROCESSOR_A'),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		unique('transactions_transactionId_processor_unique').on(
+			table.transactionId,
+			table.processor,
+		),
+		index('transactions_token_idx').on(table.token),
+		index('transactions_transactionId_idx').on(table.transactionId),
+		index('transactions_profileId_idx').on(table.profileId),
+		index('transactions_requestId_idx').on(table.requestId),
+		index('transactions_transactionStatus_idx').on(table.transactionStatus),
+	],
+);
+
+export type Transaction = typeof transactions.$inferSelect;
+export type TransactionToInsert = typeof transactions.$inferInsert;
+
+export type TransactionEventType =
+	| 'transaction.created'
+	| 'transaction.updated';
+export type ProcessorEventType =
+	| 'transaction.sale.success'
+	| 'transaction.sale.failure'
+	| 'transaction.sale.unknown';
+
+export const transactionEvents = sqliteTable(
+	'transaction_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		eventType: text({ length: 50 })
+			.$type<TransactionEventType | ProcessorEventType>()
+			.notNull(),
+		eventId: text().notNull(),
+		transactionId: text()
+			.references(() => transactions.transactionId, { onDelete: 'cascade' })
+			.notNull(),
+		eventMetadata: text().notNull(),
+		processor: text()
+			.$type<PaymentProcessor>()
+			.notNull()
+			.default('PROCESSOR_A'),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('transactionEvents_eventId_unique').on(table.eventId),
+		index('transactionEvents_eventType_idx').on(table.eventType),
+		index('transactionEvents_transactionId_idx').on(table.transactionId),
+	],
+);
+
+export type TransactionEvent = typeof transactionEvents.$inferSelect;
+export type TransactionEventToInsert = typeof transactionEvents.$inferInsert;
+
+export const serviceEvents = sqliteTable(
+	'service_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		serviceUserId: text().notNull(),
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		serviceRequestId: text().notNull(),
+		eventType: text().notNull(),
+		eventId: integer().notNull(),
+		appointmentEventId: text(),
+		eventStatus: text().notNull(),
+		appointmentStatus: text(),
+		eventMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(serviceEvents) => [
+		index('serviceEvents_profileId_idx').on(serviceEvents.profileId),
+		index('serviceEvents_serviceUserId_idx').on(serviceEvents.serviceUserId),
+		index('serviceEvents_requestId_idx').on(serviceEvents.requestId),
+		index('serviceEvents_serviceRequestId_idx').on(
+			serviceEvents.serviceRequestId,
+		),
+		index('serviceEvents_eventId_idx').on(serviceEvents.eventId),
+		index('serviceEvents_eventType_idx').on(serviceEvents.eventType),
+		index('serviceEvents_eventStatus_idx').on(serviceEvents.eventStatus),
+	],
+);
+
+export type ServiceEvent = typeof serviceEvents.$inferSelect;
+export type ServiceEventToInsert = typeof serviceEvents.$inferInsert;
+
+export type PartnerSubscriptionType = 'promo' | 'referral' | 'custom_package';
+
+export const partnerSubscriptions = sqliteTable(
+	'partner_subscriptions',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		partnerId: text()
+			.references(() => partners.id, { onDelete: 'cascade' })
+			.notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		promoCode: text(),
+		referralCode: text(),
+		subscriptionType: text().$type<PartnerSubscriptionType>().notNull(),
+		expiredAt: integer({ mode: 'timestamp' }).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(partnerSubscriptions) => [
+		uniqueIndex('partnerSubscriptions_profileId_partnerId_unique').on(
+			partnerSubscriptions.profileId,
+			partnerSubscriptions.partnerId,
+		),
+		index('partnerSubscriptions_profileId_idx').on(
+			partnerSubscriptions.profileId,
+		),
+		index('partnerSubscriptions_partnerId_idx').on(
+			partnerSubscriptions.partnerId,
+		),
+		index('partnerSubscriptions_promoCode_idx').on(
+			partnerSubscriptions.promoCode,
+		),
+		index('partnerSubscriptions_referralCode_idx').on(
+			partnerSubscriptions.referralCode,
+		),
+		index('partnerSubscriptions_subscriptionType_idx').on(
+			partnerSubscriptions.subscriptionType,
+		),
+		index('partnerSubscriptions_expiredAt_idx').on(
+			partnerSubscriptions.expiredAt,
+		),
+	],
+);
+
+export type PartnerSubscription = typeof partnerSubscriptions.$inferSelect;
+export type PartnerSubscriptionToInsert = typeof partnerSubscriptions.$inferInsert;
+
+export const reversals = sqliteTable(
+	'reversals',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		token: text().notNull(),
+		transactionId: text()
+			.notNull()
+			.references(() => transactions.id),
+		reversalId: text().notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		requestId: text()
+			.references(() => requests.id)
+			.notNull(),
+		reversalStatus: text({ length: 50 }).notNull(),
+		amount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${reversals.amount} * 100`,
+		),
+		currency: text({ length: 10 }).notNull(),
+		reversalMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('reversals_token_unique').on(table.token),
+		index('reversals_transactionId_idx').on(table.transactionId),
+		index('reversals_profileId_idx').on(table.profileId),
+		index('reversals_requestId_idx').on(table.requestId),
+		index('reversals_reversalStatus_idx').on(table.reversalStatus),
+		index('reversals_reversalId_idx').on(table.reversalId),
+	],
+);
+
+export type Reversal = typeof reversals.$inferSelect;
+export type ReversalToInsert = typeof reversals.$inferInsert;
+
+export type ReversalEventType = 'reversal.created' | 'reversal.updated';
+
+export const reversalEvents = sqliteTable(
+	'reversal_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		eventType: text({ length: 50 }).$type<ReversalEventType>().notNull(),
+		eventId: text().notNull(),
+		reversalId: text()
+			.references(() => reversals.id, { onDelete: 'cascade' })
+			.notNull(),
+		transactionId: text()
+			.references(() => transactions.id, { onDelete: 'cascade' })
+			.notNull(),
+		eventMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('reversalEvents_eventId_unique').on(table.eventId),
+		index('reversalEvents_eventType_idx').on(table.eventType),
+		index('reversalEvents_transactionId_idx').on(table.transactionId),
+		index('reversalEvents_reversalId_idx').on(table.reversalId),
+	],
+);
+
+export type ReversalEvent = typeof reversalEvents.$inferSelect;
+export type ReversalEventToInsert = typeof reversalEvents.$inferInsert;
+
+export const schedules = sqliteTable(
+	'schedules',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		scheduleTitle: text({ length: 255 }).notNull(),
+		description: text(),
+		startDate: integer({ mode: 'timestamp' }).notNull(),
+		endDate: integer({ mode: 'timestamp' }),
+		isCurrent: integer({ mode: 'boolean' }).default(false).notNull(),
+		themeColor: text({ length: 50 }).notNull(),
+		isPrivate: integer({ mode: 'boolean' }).default(false).notNull(),
+		applyToAllCharts: integer({ mode: 'boolean' }).default(false).notNull(),
+		isVisible: integer({ mode: 'boolean' }).default(true).notNull(),
+		isArchived: integer({ mode: 'boolean' }).default(false).notNull(),
+		profileActions: text(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('schedules_profileId_idx').on(table.profileId),
+		index('schedules_startDate_endDate_idx').on(table.startDate, table.endDate),
+	],
+);
+
+export type Schedule = typeof schedules.$inferSelect;
+export type ScheduleToInsert = typeof schedules.$inferInsert;
+
+export const schedulesToIdentifiers = sqliteTable(
+	'schedules_to_identifiers',
+	{
+		scheduleId: text()
+			.references(() => schedules.id, {
+				onDelete: 'cascade',
+			})
+			.notNull(),
+		identifierId: text()
+			.references(() => identifiers.id, {
+				onDelete: 'cascade',
+			})
+			.notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.scheduleId, table.identifierId] }),
+		index('schedulesToIdentifiers_identifierId_idx').on(table.identifierId),
+	],
+);
+
+export type ScheduleToIdentifier = typeof schedulesToIdentifiers.$inferSelect;
+export type ScheduleToIdentifierToInsert = typeof schedulesToIdentifiers.$inferInsert;
+
+export const scheduleShares = sqliteTable(
+	'schedule_shares',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		shareToken: text().notNull(),
+		scheduleId: text()
+			.references(() => schedules.id, { onDelete: 'cascade' })
+			.notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		accessCount: integer().default(0).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('scheduleShares_shareToken_idx').on(table.shareToken),
+		index('scheduleShares_scheduleId_idx').on(table.scheduleId),
+		index('scheduleShares_profileId_idx').on(table.profileId),
+	],
+);
+
+export type ScheduleShare = typeof scheduleShares.$inferSelect;
+export type ScheduleShareToInsert = typeof scheduleShares.$inferInsert;
+
+export const processingProviders = sqliteTable(
+	'processing_providers',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		processor: text().$type<PaymentProcessor>().notNull(),
+		isActive: integer({ mode: 'boolean' }).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(processingProviders) => [
+		index('processingProviders_processor_idx').on(
+			processingProviders.processor,
+		),
+		index('processingProviders_isActive_idx').on(processingProviders.isActive),
+	],
+);
+
+export type ProcessingProvider = typeof processingProviders.$inferSelect;
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema02new.ts b/drizzle-kit/tests/sqlite/snapshots/schema02new.ts
new file mode 100644
index 0000000000..5aeb1c0f00
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema02new.ts
@@ -0,0 +1,986 @@
+import { SQL, sql } from 'drizzle-orm';
+import { blob, index, integer, primaryKey, real, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { v4 } from 'uuid';
+
+type EntityClass = 'ALPHA' | 'BETA' | 'GAMMA';
+type AccessLevel = 'STANDARD' | 'PREMIUM';
+type ProcessStage = 'INITIAL' | 'COMPLETE';
+
+export const profiles = sqliteTable(
+	'profiles',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey(),
+		externalRef: text({ length: 255 }).notNull(),
+		serviceRef: text(),
+		contactEmail: text({ length: 255 }).notNull(),
+		givenName: text({ length: 100 }).notNull(),
+		familyName: text({ length: 100 }).notNull(),
+		accessLevel: text().$type<AccessLevel>().notNull(),
+		birthDate: text(),
+		classification: text({ length: 50 }).$type<EntityClass>(),
+		contactNumber: text({ length: 20 }),
+		currentStage: text().$type<ProcessStage>().default('INITIAL').notNull(),
+		// Location fields
+		recipientName: text({ length: 255 }),
+		primaryAddress: text({ length: 255 }),
+		secondaryAddress: text({ length: 255 }),
+		locality: text({ length: 100 }),
+		region: text({ length: 2 }),
+		postalCode: text({ length: 10 }),
+		territory: text({ length: 2 }).default('US').notNull(),
+		// Additional profile fields
+		avatarUrl: text({ length: 255 }),
+		lastAccessAt: integer({ mode: 'timestamp_ms' }).default(new Date('2023-12-12')),
+		emailConfirmed: integer({ mode: 'boolean' }).default(false).notNull(),
+		phoneConfirmed: integer({ mode: 'boolean' }).default(false).notNull(),
+		// Timestamps
+		createdAt: integer({ mode: 'timestamp' })
+			.default(sql`(CURRENT_TIMESTAMP)`)
+			.notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(profiles) => [
+		index('index_1').on(profiles.serviceRef),
+		index('index_2').on(profiles.contactEmail),
+		index('index_3').on(profiles.externalRef),
+	],
+);
+
+export type Profile = typeof profiles.$inferSelect;
+export type ProfileToInsert = typeof profiles.$inferInsert;
+
+export const profileAgreements = sqliteTable(
+	'profile_agreements',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: blob()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		privacyConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		serviceConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		termsConsent: integer({ mode: 'boolean' }).default(false).notNull(),
+		agreementDate: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [uniqueIndex('index_4').on(table.profileId)],
+);
+
+export type ProfileAgreement = typeof profileAgreements.$inferSelect;
+export type ProfileAgreementToInsert = typeof profileAgreements.$inferInsert;
+
+export const facilities = sqliteTable('facilities', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	facilityName: text({ length: 255 }).notNull(),
+	serviceId: integer().notNull(),
+	createdAt: integer({ mode: 'timestamp_ms' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp_ms' }).notNull(),
+});
+
+export type Facility = typeof facilities.$inferSelect;
+export type FacilityToInsert = typeof facilities.$inferInsert;
+
+export const identifiers = sqliteTable('identifiers', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	code: text({ length: 50 }).notNull(),
+	displayName: text({ length: 255 }).notNull(),
+	description: text(),
+	slug: text({ length: 255 }).notNull(),
+	measurementUnit: text({ length: 50 }),
+	standardRanges: text({ mode: 'json' }),
+	guidelines: text({ mode: 'json' }),
+	evaluationRules: text({ mode: 'json' }),
+	isFeatured: integer({ mode: 'boolean' }).default(false),
+});
+
+export type Identifier = typeof identifiers.$inferSelect;
+export type IdentifierToInsert = typeof identifiers.$inferInsert;
+
+export const classifications = sqliteTable('classifications', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	categoryName: text({ length: 255 }).notNull(),
+	iconType: text({ length: 255 }),
+	themeColor: text({ length: 255 }),
+});
+
+export type Classification = typeof classifications.$inferSelect;
+export type ClassificationToInsert = typeof classifications.$inferInsert;
+
+export const identifierClassifications = sqliteTable(
+	'identifier_classifications',
+	{
+		identifierId: blob().references(() => identifiers.id),
+		classificationId: text().references(() => classifications.id),
+	},
+	(table) => [
+		primaryKey({ columns: [table.identifierId, table.classificationId] }),
+	],
+);
+
+export type IdentifierClassification = typeof identifierClassifications.$inferSelect;
+export type IdentifierClassificationToInsert = typeof identifierClassifications.$inferInsert;
+
+export const impactFactors = sqliteTable('impact_factors', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	factorName: text({ length: 255 }).notNull(),
+});
+
+export type ImpactFactor = typeof impactFactors.$inferSelect;
+export type ImpactFactorToInsert = typeof impactFactors.$inferInsert;
+
+export const impactFactorsToIdentifiers = sqliteTable(
+	'impact_factors_to_identifiers',
+	{
+		impactFactorId: text().references(() => impactFactors.id),
+		identifierId: text().references(() => identifiers.id),
+	},
+);
+
+export type ImpactFactorsToIdentifiers = typeof impactFactorsToIdentifiers.$inferSelect;
+export type ImpactFactorsToIdentifiersToInsert = typeof impactFactorsToIdentifiers.$inferInsert;
+
+export const metricClusters = sqliteTable('metric_clusters', {
+	id: blob()
+		.$default(() => v4())
+		.primaryKey(),
+	clusterName: text({ length: 255 }).notNull(),
+	slug: text({ length: 255 }).notNull(),
+	description: text(),
+	metricType: text({ length: 50 }).default('standard').notNull(),
+	measurementUnit: text({ length: 50 }),
+	isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+});
+
+export type MetricCluster = typeof metricClusters.$inferSelect;
+export type MetricClusterToInsert = typeof metricClusters.$inferInsert;
+
+export const metricPreferences = sqliteTable(
+	'metric_preferences',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: blob().references(() => profiles.id),
+		identifierId: text().references(() => identifiers.id),
+	},
+	(table) => [
+		index('index_5').on(table.profileId),
+		index('index_6').on(table.identifierId),
+	],
+);
+
+export type MetricPreference = typeof metricPreferences.$inferSelect;
+export type MetricPreferenceToInsert = typeof metricPreferences.$inferInsert;
+
+export const dataPoints = sqliteTable(
+	'data_points',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		pointId: integer().notNull(),
+		clusterId: text().references(() => metricClusters.id),
+		identifierId: blob().references(() => identifiers.id),
+		pointName: text({ length: 255 }).notNull(),
+		description: text(),
+		dataType: text({ length: 50 }).default('standard').notNull(),
+		isParent: integer({ mode: 'boolean' }).default(false).notNull(),
+		measurementUnit: text({ length: 50 }),
+		baseRate: real(),
+		baseCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${dataPoints.baseRate} * 100`,
+		),
+		facilityId: blob()
+			.references(() => facilities.id)
+			.notNull(),
+		isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+		visualType: text({ length: 50 }).default('numeric-trend'),
+	},
+	(table) => [uniqueIndex('index_7').on(table.clusterId, table.facilityId)],
+);
+
+export type DataPoint = typeof dataPoints.$inferSelect;
+export type DataPointToInsert = typeof dataPoints.$inferInsert;
+
+export const dataPointRelationships = sqliteTable(
+	'data_point_relationships',
+	{
+		parentId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		childId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.parentId, table.childId] }),
+		index('idx_data_point_relationships_child_id').on(table.childId),
+	],
+);
+
+export type DataPointRelationship = typeof dataPointRelationships.$inferSelect;
+export type DataPointRelationshipToInsert = typeof dataPointRelationships.$inferInsert;
+
+export const packageClusters = sqliteTable('package_clusters', {
+	id: text()
+		.$default(() => v4())
+		.primaryKey(),
+	packageName: text({ length: 255 }).notNull(),
+	slug: text({ length: 255 }).notNull(),
+	description: text(),
+	partnerId: text().references(() => partners.partnerId, {
+		onDelete: 'set null',
+	}),
+	isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+	createdAt: integer({ mode: 'timestamp' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp' }).notNull(),
+});
+
+export type PackageCluster = typeof packageClusters.$inferSelect;
+export type PackageClusterToInsert = typeof packageClusters.$inferInsert;
+
+export const servicePackages = sqliteTable(
+	'service_packages',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		clusterId: text()
+			.references(() => packageClusters.id)
+			.notNull(),
+		packageTitle: text({ length: 255 }),
+		description: text(),
+		serviceRef: text({ length: 100 }).notNull(),
+		baseRate: real().notNull(),
+		baseCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${servicePackages.baseRate} * 100`,
+		),
+		discountRate: real(),
+		discountCentRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${servicePackages.discountRate} * 100`,
+		),
+		facilityId: text()
+			.references(() => facilities.id)
+			.notNull(),
+		isPartnerCreated: integer({ mode: 'boolean' }).default(false).notNull(),
+		allowsRemoteCollection: integer({ mode: 'boolean' })
+			.default(false)
+			.notNull(),
+		partnerId: text().references(() => partners.partnerId),
+		isActive: integer({ mode: 'boolean' }).default(true).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('uk_service_packages_clusterId_facilityId').on(
+			table.clusterId,
+			table.facilityId,
+		),
+	],
+);
+
+export type ServicePackage = typeof servicePackages.$inferSelect;
+export type ServicePackageToInsert = typeof servicePackages.$inferInsert;
+
+export const servicePackageDataPoints = sqliteTable(
+	'service_package_data_points',
+	{
+		packageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		displayOrder: integer(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [primaryKey({ columns: [table.packageId, table.dataPointId] })],
+);
+
+export type ServicePackageDataPoint = typeof servicePackageDataPoints.$inferSelect;
+export type ServicePackageDataPointToInsert = typeof servicePackageDataPoints.$inferInsert;
+
+export const collectionEvents = sqliteTable('collection_events', {
+	id: text()
+		.$default(() => v4())
+		.primaryKey(),
+	requestId: text().references(() => requests.id, {
+		onDelete: 'cascade',
+	}),
+	profileId: text().references(() => profiles.id, { onDelete: 'cascade' }),
+	facilityId: text().references(() => facilities.id),
+	collectionDate: integer({ mode: 'timestamp' }),
+	reportDate: integer({ mode: 'timestamp' }),
+	receivedDate: integer({ mode: 'timestamp' }),
+	eventStatus: text({ length: 50 }).default('initiated'),
+	dataSource: text({ length: 50 }).default(''),
+	specimenRef: text({ length: 100 }),
+	eventMetadata: text(),
+	documentUrl: text({ length: 255 }),
+	hasNewData: integer({ mode: 'boolean' }).notNull().default(false),
+	createdAt: integer({ mode: 'timestamp' }).notNull(),
+	updatedAt: integer({ mode: 'timestamp' }).notNull(),
+});
+
+export type CollectionEvent = typeof collectionEvents.$inferSelect;
+export type CollectionEventToInsert = typeof collectionEvents.$inferInsert;
+
+export const measurements = sqliteTable(
+	'measurements',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		measurementName: text(),
+		slug: text(),
+		eventId: text().references(() => collectionEvents.id, {
+			onDelete: 'cascade',
+		}),
+		profileId: text().references(() => profiles.id),
+		dataPointId: text().references(() => dataPoints.id),
+		identifierId: text().references(() => identifiers.id),
+		resultValue: text(),
+		numericResult: real(),
+		rawResult: text({ length: 50 }),
+		measurementUnit: text({ length: 50 }),
+		facilityInterpretation: text({ length: 50 }),
+		facilityMinRange: real(),
+		facilityMaxRange: real(),
+		systemNotes: text(),
+		profileNotes: text(),
+		profileActions: text(),
+		measurementMetadata: text(),
+		processingStatus: text({ length: 50 }).default('partial_data'),
+		recordedAt: integer({ mode: 'timestamp' }).notNull(),
+		isNotified: integer({ mode: 'boolean' }).default(false),
+		isArchived: integer({ mode: 'boolean' }).default(false),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('idx_measurements_eventId').on(table.eventId),
+		index('idx_measurements_identifierId').on(table.identifierId),
+		index('idx_measurements_dataPointId').on(table.dataPointId),
+	],
+);
+
+export type Measurement = typeof measurements.$inferSelect;
+export type MeasurementToInsert = typeof measurements.$inferInsert;
+
+export const partners = sqliteTable(
+	'partners',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		partnerId: text().notNull(),
+		slug: text({ length: 255 }),
+		promoCode: text(),
+		referralCode: text(),
+		partnerFirstName: text({ length: 255 }).notNull(),
+		partnerLastName: text({ length: 255 }).notNull(),
+		displayName: text({ length: 255 }),
+		description: text(),
+		logoUrl: text({ length: 255 }),
+		isActive: integer({ mode: 'boolean' }).default(true),
+		partnerMetadata: text(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(partners) => [
+		index('idx_partners_promoCode').on(partners.promoCode),
+		index('idx_partners_partnerId').on(partners.partnerId),
+	],
+);
+
+export type Partner = typeof partners.$inferSelect;
+
+// export const partnerRelationships = sqliteTable(
+// 	'partner_relationships',
+// 	{
+// 		parentPartnerId: text()
+// 			.references(() => partners.id, { onDelete: 'cascade' })
+// 			.notNull(),
+// 		childPartnerId: text()
+// 			.references(() => partners.id, { onDelete: 'cascade' })
+// 			.notNull(),
+// 		createdAt: integer({ mode: 'timestamp' }).notNull(),
+// 	},
+// 	(table) => [
+// 		primaryKey({ columns: [table.parentPartnerId, table.childPartnerId] }),
+// 		index('idx_partner_relationships_childPartnerId').on(table.childPartnerId),
+// 	],
+// );
+
+export type RequestStatus =
+	| 'pending'
+	| 'processed'
+	| 'processing_failed'
+	| 'service_creation_failed'
+	| 'service_results_failed'
+	| 'refund_pending'
+	| 'refunded'
+	| 'refund_failed'
+	| 'processing_cancellation'
+	| 'received.standard.ordered'
+	| 'received.standard.document_created'
+	| 'sample_processing.standard.partial_data'
+	| 'collecting_sample.standard.appointment_scheduled'
+	| 'completed.standard.completed'
+	| 'failed.standard.sample_error'
+	| 'cancelled.standard.cancelled'
+	| 'received.remote.ordered'
+	| 'received.remote.document_created'
+	| 'collecting_sample.remote.appointment_scheduled'
+	| 'sample_processing.remote.partial_data'
+	| 'completed.remote.completed'
+	| 'cancelled.remote.cancelled';
+
+// export const serviceRequestStatuses: RequestStatus[] = [
+// 	'service_results_failed',
+// 	'received.standard.ordered',
+// 	'received.standard.document_created',
+// 	'sample_processing.standard.partial_data',
+// 	'completed.standard.completed',
+// 	'failed.standard.sample_error',
+// 	'cancelled.standard.cancelled',
+// 	'received.remote.ordered',
+// 	'received.remote.document_created',
+// 	'collecting_sample.remote.appointment_scheduled',
+// 	'sample_processing.remote.partial_data',
+// 	'completed.remote.completed',
+// 	'cancelled.remote.cancelled',
+// ];
+
+export interface Location {
+	primaryAddress: string;
+	secondaryAddress?: string;
+	locality: string;
+	region: string;
+	postalCode: string;
+	territory: string;
+}
+
+export type RequestType = 'standard' | 'remote';
+
+export const requests = sqliteTable(
+	'requests',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		requestNumber: integer().notNull(),
+		serviceRequestId: text(),
+		totalAmount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${requests.totalAmount} * 100`,
+		),
+		requestStatus: text({ length: 100 }).$type<RequestStatus>().notNull(),
+		promoCode: text(),
+		referralCode: text(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		facilityId: text().references(() => facilities.id, {
+			onDelete: 'set null',
+		}),
+		receiptUrl: text({ length: 255 }),
+		itemCount: integer().notNull(),
+		requestMetadata: text(),
+		requestType: text().$type<RequestType>().default('standard').notNull(),
+		location: text().$type<Location>(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('requests_profileId_idx').on(table.profileId),
+		index('requests_requestNumber_idx').on(table.requestNumber),
+		index('requests_requestStatus_idx').on(table.requestStatus),
+		index('requests_serviceRequestId_idx').on(table.serviceRequestId),
+		index('requests_promoCode_idx').on(table.promoCode),
+		index('requests_referralCode_idx').on(table.referralCode),
+		index('requests_requestType_idx').on(table.requestType),
+	],
+);
+
+export type Request = typeof requests.$inferSelect;
+export type RequestToInsert = typeof requests.$inferInsert;
+
+export const requestsToDataPoints = sqliteTable(
+	'requests_to_data_points',
+	{
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+		itemRate: real().notNull(),
+		centRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${requestsToDataPoints.itemRate} * 100`,
+		),
+	},
+	(table) => [
+		index('requestsToDataPoints_requestId_idx').on(table.requestId),
+		index('requestsToDataPoints_dataPointId_idx').on(table.dataPointId),
+	],
+);
+
+export type RequestToDataPoint = typeof requestsToDataPoints.$inferSelect;
+export type RequestToDataPointToInsert = typeof requestsToDataPoints.$inferInsert;
+
+export const requestsToServicePackages = sqliteTable(
+	'requests_to_service_packages',
+	{
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		servicePackageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+		packageRate: real().notNull(),
+		centRate: integer().generatedAlwaysAs(
+			(): SQL => sql`${requestsToServicePackages.packageRate} * 100`,
+		),
+	},
+	(table) => [
+		index('requestsToServicePackages_requestId_idx').on(table.requestId),
+		index('requestsToServicePackages_servicePackageId_idx').on(
+			table.servicePackageId,
+		),
+	],
+);
+
+export type RequestToServicePackage = typeof requestsToServicePackages.$inferSelect;
+export type RequestToServicePackageToInsert = typeof requestsToServicePackages.$inferInsert;
+
+export const selections = sqliteTable(
+	'selections',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		facilityId: text().references(() => facilities.id),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('selections_profileId_idx').on(table.profileId),
+		index('selections_facilityId_idx').on(table.facilityId),
+		uniqueIndex('selections_id_profileId_unique').on(table.id, table.profileId),
+	],
+);
+
+export type Selection = typeof selections.$inferSelect;
+export type SelectionToInsert = typeof selections.$inferInsert;
+
+export const selectionsToDataPoints = sqliteTable(
+	'selections_to_data_points',
+	{
+		selectionId: text()
+			.references(() => selections.id, { onDelete: 'cascade' })
+			.notNull(),
+		dataPointId: text()
+			.references(() => dataPoints.id, { onDelete: 'cascade' })
+			.notNull(),
+	},
+	(table) => [
+		index('selectionsToDataPoints_selectionId_idx').on(table.selectionId),
+		index('selectionsToDataPoints_dataPointId_idx').on(table.dataPointId),
+		uniqueIndex('selectionsToDataPoints_selectionId_dataPointId_unique').on(
+			table.selectionId,
+			table.dataPointId,
+		),
+	],
+);
+
+export type SelectionToDataPoint = typeof selectionsToDataPoints.$inferSelect;
+
+export const selectionsToServicePackages = sqliteTable(
+	'selections_to_service_packages',
+	{
+		selectionId: text()
+			.references(() => selections.id, { onDelete: 'cascade' })
+			.notNull(),
+		servicePackageId: text()
+			.references(() => servicePackages.id, { onDelete: 'cascade' })
+			.notNull(),
+	},
+	(table) => [
+		index('selectionsToServicePackages_selectionId_idx').on(table.selectionId),
+		index('selectionsToServicePackages_servicePackageId_idx').on(
+			table.servicePackageId,
+		),
+		uniqueIndex(
+			'selectionsToServicePackages_selectionId_servicePackageId_unique',
+		).on(table.selectionId, table.servicePackageId),
+	],
+);
+
+export type SelectionToServicePackage = typeof selectionsToServicePackages.$inferSelect;
+
+export type ProcessorPaymentStatus =
+	| 'PENDING'
+	| 'SUCCESS'
+	| 'DECLINE'
+	| 'UNKNOWN';
+export type PaymentProcessor = 'PROCESSOR_A' | 'PROCESSOR_B';
+
+export const transactions = sqliteTable(
+	'transactions',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		token: text(),
+		transactionId: text().notNull(),
+		sourceId: text(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		requestId: text()
+			.references(() => requests.id)
+			.notNull(),
+		transactionStatus: text({ length: 50 }).notNull(),
+		amount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${transactions.amount} * 100`,
+		),
+		currency: text({ length: 10 }).notNull(),
+		responseData: text(),
+		transactionMetadata: text(),
+		processor: text()
+			.$type<PaymentProcessor>()
+			.notNull()
+			.default('PROCESSOR_A'),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('transactions_transactionId_processor_unique').on(
+			table.transactionId,
+			table.processor,
+		),
+		index('transactions_token_idx').on(table.token),
+		index('transactions_transactionId_idx').on(table.transactionId),
+		index('transactions_profileId_idx').on(table.profileId),
+		index('transactions_requestId_idx').on(table.requestId),
+		index('transactions_transactionStatus_idx').on(table.transactionStatus),
+	],
+);
+
+export type Transaction = typeof transactions.$inferSelect;
+export type TransactionToInsert = typeof transactions.$inferInsert;
+
+export type TransactionEventType =
+	| 'transaction.created'
+	| 'transaction.updated';
+export type ProcessorEventType =
+	| 'transaction.sale.success'
+	| 'transaction.sale.failure'
+	| 'transaction.sale.unknown';
+
+export const transactionEvents = sqliteTable(
+	'transaction_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		eventType: text({ length: 50 })
+			.$type<TransactionEventType | ProcessorEventType>()
+			.notNull(),
+		eventId: text().notNull(),
+		transactionId: text()
+			.references(() => transactions.transactionId, { onDelete: 'cascade' })
+			.notNull(),
+		eventMetadata: text().notNull(),
+		processor: text()
+			.$type<PaymentProcessor>()
+			.notNull()
+			.default('PROCESSOR_A'),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('transactionEvents_eventId_unique').on(table.eventId),
+		index('transactionEvents_eventType_idx').on(table.eventType),
+		index('transactionEvents_transactionId_idx').on(table.transactionId),
+	],
+);
+
+export type TransactionEvent = typeof transactionEvents.$inferSelect;
+export type TransactionEventToInsert = typeof transactionEvents.$inferInsert;
+
+export const serviceEvents = sqliteTable(
+	'service_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		serviceUserId: text().notNull(),
+		requestId: text()
+			.references(() => requests.id, { onDelete: 'cascade' })
+			.notNull(),
+		serviceRequestId: text().notNull(),
+		eventType: text().notNull(),
+		eventId: integer().notNull(),
+		appointmentEventId: text(),
+		eventStatus: text().notNull(),
+		appointmentStatus: text(),
+		eventMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(serviceEvents) => [
+		index('serviceEvents_profileId_idx').on(serviceEvents.profileId),
+		index('serviceEvents_serviceUserId_idx').on(serviceEvents.serviceUserId),
+		index('serviceEvents_requestId_idx').on(serviceEvents.requestId),
+		index('serviceEvents_serviceRequestId_idx').on(
+			serviceEvents.serviceRequestId,
+		),
+		index('serviceEvents_eventId_idx').on(serviceEvents.eventId),
+		index('serviceEvents_eventType_idx').on(serviceEvents.eventType),
+		index('serviceEvents_eventStatus_idx').on(serviceEvents.eventStatus),
+	],
+);
+
+export type ServiceEvent = typeof serviceEvents.$inferSelect;
+export type ServiceEventToInsert = typeof serviceEvents.$inferInsert;
+
+export type PartnerSubscriptionType = 'promo' | 'referral' | 'custom_package';
+
+export const partnerSubscriptions = sqliteTable(
+	'partner_subscriptions',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		partnerId: text()
+			.references(() => partners.id, { onDelete: 'cascade' })
+			.notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		promoCode: text(),
+		referralCode: text(),
+		subscriptionType: text().$type<PartnerSubscriptionType>().notNull(),
+		expiredAt: integer({ mode: 'timestamp' }).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(partnerSubscriptions) => [
+		uniqueIndex('partnerSubscriptions_profileId_partnerId_unique').on(
+			partnerSubscriptions.profileId,
+			partnerSubscriptions.partnerId,
+		),
+		index('partnerSubscriptions_profileId_idx').on(
+			partnerSubscriptions.profileId,
+		),
+		index('partnerSubscriptions_partnerId_idx').on(
+			partnerSubscriptions.partnerId,
+		),
+		index('partnerSubscriptions_promoCode_idx').on(
+			partnerSubscriptions.promoCode,
+		),
+		index('partnerSubscriptions_referralCode_idx').on(
+			partnerSubscriptions.referralCode,
+		),
+		index('partnerSubscriptions_subscriptionType_idx').on(
+			partnerSubscriptions.subscriptionType,
+		),
+		index('partnerSubscriptions_expiredAt_idx').on(
+			partnerSubscriptions.expiredAt,
+		),
+	],
+);
+
+export type PartnerSubscription = typeof partnerSubscriptions.$inferSelect;
+export type PartnerSubscriptionToInsert = typeof partnerSubscriptions.$inferInsert;
+
+export const reversals = sqliteTable(
+	'reversals',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		token: text().notNull(),
+		transactionId: text()
+			.notNull()
+			.references(() => transactions.id),
+		reversalId: text().notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		requestId: text()
+			.references(() => requests.id)
+			.notNull(),
+		reversalStatus: text({ length: 50 }).notNull(),
+		amount: real().notNull(),
+		centAmount: integer().generatedAlwaysAs(
+			(): SQL => sql`${reversals.amount} * 100`,
+		),
+		currency: text({ length: 10 }).notNull(),
+		reversalMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('reversals_token_unique').on(table.token),
+		index('reversals_transactionId_idx').on(table.transactionId),
+		index('reversals_profileId_idx').on(table.profileId),
+		index('reversals_requestId_idx').on(table.requestId),
+		index('reversals_reversalStatus_idx').on(table.reversalStatus),
+		index('reversals_reversalId_idx').on(table.reversalId),
+	],
+);
+
+export type Reversal = typeof reversals.$inferSelect;
+export type ReversalToInsert = typeof reversals.$inferInsert;
+
+export type ReversalEventType = 'reversal.created' | 'reversal.updated';
+
+export const reversalEvents = sqliteTable(
+	'reversal_events',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		eventType: text({ length: 50 }).$type<ReversalEventType>().notNull(),
+		eventId: text().notNull(),
+		reversalId: text()
+			.references(() => reversals.id, { onDelete: 'cascade' })
+			.notNull(),
+		transactionId: text()
+			.references(() => transactions.id, { onDelete: 'cascade' })
+			.notNull(),
+		eventMetadata: text().notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		uniqueIndex('reversalEvents_eventId_unique').on(table.eventId),
+		index('reversalEvents_eventType_idx').on(table.eventType),
+		index('reversalEvents_transactionId_idx').on(table.transactionId),
+		index('reversalEvents_reversalId_idx').on(table.reversalId),
+	],
+);
+
+export type ReversalEvent = typeof reversalEvents.$inferSelect;
+export type ReversalEventToInsert = typeof reversalEvents.$inferInsert;
+
+export const schedules = sqliteTable(
+	'schedules',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		scheduleTitle: text({ length: 255 }).notNull(),
+		description: text(),
+		startDate: integer({ mode: 'timestamp' }).notNull(),
+		endDate: integer({ mode: 'timestamp' }),
+		isCurrent: integer({ mode: 'boolean' }).default(false).notNull(),
+		themeColor: text({ length: 50 }).notNull(),
+		isPrivate: integer({ mode: 'boolean' }).default(false).notNull(),
+		applyToAllCharts: integer({ mode: 'boolean' }).default(false).notNull(),
+		isVisible: integer({ mode: 'boolean' }).default(true).notNull(),
+		isArchived: integer({ mode: 'boolean' }).default(false).notNull(),
+		profileActions: text(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+		updatedAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('schedules_profileId_idx').on(table.profileId),
+		index('schedules_startDate_endDate_idx').on(table.startDate, table.endDate),
+	],
+);
+
+export type Schedule = typeof schedules.$inferSelect;
+export type ScheduleToInsert = typeof schedules.$inferInsert;
+
+export const schedulesToIdentifiers = sqliteTable(
+	'schedules_to_identifiers',
+	{
+		scheduleId: text()
+			.references(() => schedules.id, {
+				onDelete: 'cascade',
+			})
+			.notNull(),
+		identifierId: text()
+			.references(() => identifiers.id, {
+				onDelete: 'cascade',
+			})
+			.notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.scheduleId, table.identifierId] }),
+		index('schedulesToIdentifiers_identifierId_idx').on(table.identifierId),
+	],
+);
+
+export type ScheduleToIdentifier = typeof schedulesToIdentifiers.$inferSelect;
+export type ScheduleToIdentifierToInsert = typeof schedulesToIdentifiers.$inferInsert;
+
+export const scheduleShares = sqliteTable(
+	'schedule_shares',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		shareToken: text().notNull(),
+		scheduleId: text()
+			.references(() => schedules.id, { onDelete: 'cascade' })
+			.notNull(),
+		profileId: text()
+			.references(() => profiles.id, { onDelete: 'cascade' })
+			.notNull(),
+		accessCount: integer().default(0).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(table) => [
+		index('scheduleShares_shareToken_idx').on(table.shareToken),
+		index('scheduleShares_scheduleId_idx').on(table.scheduleId),
+		index('scheduleShares_profileId_idx').on(table.profileId),
+	],
+);
+
+export type ScheduleShare = typeof scheduleShares.$inferSelect;
+export type ScheduleShareToInsert = typeof scheduleShares.$inferInsert;
+
+export const processingProviders = sqliteTable(
+	'processing_providers',
+	{
+		id: text()
+			.$default(() => v4())
+			.primaryKey(),
+		processor: text().$type<PaymentProcessor>().notNull(),
+		isActive: integer({ mode: 'boolean' }).notNull(),
+		createdAt: integer({ mode: 'timestamp' }).notNull(),
+	},
+	(processingProviders) => [
+		index('processingProviders_processor_idx').on(
+			processingProviders.processor,
+		),
+		index('processingProviders_isActive_idx').on(processingProviders.isActive),
+	],
+);
+
+export type ProcessingProvider = typeof processingProviders.$inferSelect;
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema03-generate.ts b/drizzle-kit/tests/sqlite/snapshots/schema03-generate.ts
new file mode 100644
index 0000000000..eace544948
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema03-generate.ts
@@ -0,0 +1,984 @@
+import { eq, sql } from 'orm044';
+import {
+	AnySQLiteColumn,
+	blob,
+	check,
+	foreignKey,
+	index,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'orm044/sqlite-core';
+import { v4 } from 'uuid';
+
+export const organizationsInCore = sqliteTable(
+	'organizations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: integer({ mode: 'number' }).notNull(),
+		name: text().notNull(),
+		domain: text(),
+		currency: text({ enum: ['USD', 'EUR', 'GBP', 'UAH', 'JPY'] })
+			.default('EUR')
+			.notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_org_name_idx').on(table.name),
+		index('organizations_code_idx').on(table.code),
+		uniqueIndex('organizations_domain_key').on(table.domain),
+		check('organizations_name_check', sql`length(name) > 1`),
+	],
+);
+
+export const usersInCore = sqliteTable(
+	'users',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id', {
+			mode: 'text',
+			length: 100,
+		}).notNull(),
+		username: text().notNull(),
+		status: text({ enum: ['pending', 'done'] })
+			.default('pending')
+			.notNull(),
+		locale: text().default('en-US').notNull(),
+		lastLogin: integer('last_login', { mode: 'timestamp' }),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		bio: text().$onUpdate(() => sql`bio || 'some test'`),
+		profile: blob({ mode: 'json' }),
+	},
+	(table) => [
+		index('core_users_username_idx').on(table.organizationId, table.username),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+			name: 'users_organizationId_organizations_fkey',
+		}).onDelete('cascade'),
+
+		uniqueIndex('users_org_username_unique').on(
+			table.organizationId,
+			table.username,
+		),
+	],
+);
+
+export const rolesInCore = sqliteTable(
+	'roles',
+	{
+		id: integer().primaryKey({ autoIncrement: true }).notNull(),
+		organizationId: text('organization_id')
+			.notNull()
+			.references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+		name: text().notNull(),
+		kind: text({ enum: ['custom'] })
+			.default('custom')
+			.notNull(),
+		builtin: integer({ mode: 'boolean' }).default(false).notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex('roles_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const permissionsInCore = sqliteTable('permissions', {
+	id: integer().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+});
+
+export const membershipsInCore = sqliteTable(
+	'memberships',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		roleId: integer('role_id').notNull(),
+		organizationId: text('organization_id').notNull(),
+		joinedAt: integer('joined_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'memberships_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'memberships_roleId_roles_fkey',
+			columns: [table.roleId],
+			foreignColumns: [rolesInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'memberships_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('unique_membership').on(table.userId, table.organizationId),
+	],
+);
+
+export const apiKeysInCore = sqliteTable(
+	'api_keys',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text(),
+		userId: blob(),
+		name: text().notNull(),
+		keyHash: text('key_hash').notNull(),
+		revoked: integer({ mode: 'boolean' }).default(false).notNull(),
+		expiresAt: integer('expires_at', { mode: 'timestamp' }),
+		metadata: text({ mode: 'json' }).generatedAlwaysAs(sql`'{"some":"test"}'`),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_apikey_org_idx')
+			.on(table.organizationId)
+			.where(sql`(revoked = false)`),
+		foreignKey({
+			name: 'apikeys_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'apikeys_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+
+		uniqueIndex('api_keys_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const sessionsInCore = sqliteTable(
+	'sessions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: blob().notNull(),
+		ip: text(),
+		userAgent: text('user_agent'),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		expiresAt: integer('expires_at', {
+			mode: 'timestamp_ms',
+		}).notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_sessions_user_expires').on(table.userId, table.expiresAt),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const oauthProvidersInCore = sqliteTable(
+	'oauth_providers',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text().notNull(),
+		provider: text().notNull(),
+		clientId: text('client_id').notNull(),
+		clientSecret: text('client_secret').notNull(),
+		config: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'oauthproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('oauth_providers_organization_id_provider_key').on(
+			table.organizationId,
+			table.provider,
+		),
+	],
+);
+
+export const featureFlagsInCore = sqliteTable(
+	'feature_flags',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		key: text().notNull(),
+		description: text(),
+		state: text({ enum: ['disabled'] })
+			.default('disabled')
+			.notNull(),
+		rolloutPercent: integer('rollout_percent').default(0),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'featureflags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('feature_flags_organization_id_key_key').on(
+			table.organizationId,
+			table.key,
+		),
+		check(
+			'feature_flags_rollout_percent_check',
+			sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`,
+		),
+	],
+);
+
+export const projectsInCore = sqliteTable(
+	'projects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		name: text().notNull(),
+		slug: text().notNull(),
+		description: text(),
+		visibility: text().default('priv"ate').notNull(),
+		createdBy: blob('created_by'),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_projects_org_name_idx').on(table.organizationId, table.name),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'projects_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('projects_org_slug_unique').on(
+			table.organizationId,
+			table.slug,
+		),
+	],
+);
+
+export const repositoriesInCore = sqliteTable(
+	'repositories',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: blob('project_id').notNull(),
+		provider: text().notNull(),
+		repoOwner: text('repo_owner').notNull(),
+		repoName: text('repo_name').notNull(),
+		defaultBranch: text('default_branch').default('main').notNull(),
+		cloneUrl: text('clone_url'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'repositories_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('repositories_project_id_provider_repo_owner_repo_name_key').on(
+			table.projectId,
+			table.provider,
+			table.repoOwner,
+			table.repoName,
+		),
+	],
+);
+
+export const buildsInCore = sqliteTable(
+	'builds',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		projectId: blob('project_id').notNull(),
+		triggeredBy: blob('triggered_by'),
+		commitSha: text('commit_sha', { length: 40 }).notNull(),
+		status: text().default('created').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		metadata: blob({ mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_builds_project_status_idx').on(table.projectId, table.status),
+		foreignKey({
+			name: 'builds_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'builds_triggeredBy_users_fkey',
+			columns: [table.triggeredBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('builds_project_id_commit_sha_key').on(
+			table.projectId,
+			table.commitSha,
+		),
+	],
+);
+
+export const pipelinesInCore = sqliteTable(
+	'pipelines',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id').notNull(),
+		name: text().notNull(),
+		spec: blob({ mode: 'json' }).notNull(),
+		status: text().default('created').notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'pipelines_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipelines_project_id_name_key').on(
+			table.projectId,
+			table.name,
+		),
+	],
+);
+
+export const pipelineRunsInAnalytics = sqliteTable(
+	'pipeline_runs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineId: text('pipeline_id').notNull(),
+
+		runNumber: blob('run_number', { mode: 'bigint' }).notNull(),
+		state: text().default('queued').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		logs: text(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('analytics_pipeline_runs_state_idx').on(table.state),
+		foreignKey({
+			name: 'pipelinerunsinanalytics_pipelineId_pipelines_fkey',
+			columns: [table.pipelineId],
+			foreignColumns: [pipelinesInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipeline_runs_unique_run').on(
+			table.pipelineId,
+			table.runNumber,
+		),
+	],
+);
+
+export const jobsInAnalytics = sqliteTable(
+	'jobs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineRunId: text('pipeline_run_id'),
+		name: text().notNull(),
+		state: text().default('queued').notNull(),
+		attempts: integer().default(0).notNull(),
+		lastError: text('last_error'),
+	},
+	(table) => [
+		index('analytics_jobs_state_attempts_idx').on(table.state, table.attempts),
+		foreignKey({
+			name: 'jobsinanalytics_pipelineRunId_unknown_fkey',
+			columns: [table.pipelineRunId],
+			foreignColumns: [pipelineRunsInAnalytics.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const storageBucketsInCore = sqliteTable(
+	'storage_buckets',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		region: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'storagebuckets_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('storage_buckets_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const objectsInCore = sqliteTable(
+	'objects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		bucketId: text('bucket_id').notNull(),
+		path: text().notNull(),
+		size: blob({ mode: 'bigint' }).notNull(),
+		contentType: text('content_type'),
+		metadata: blob({ mode: 'bigint' }),
+	},
+	(table) => [
+		index('core_objects_bucket_path_gin').on(table.metadata),
+		foreignKey({
+			name: 'objects_bucketId_storagebuckets_fkey',
+			columns: [table.bucketId],
+			foreignColumns: [storageBucketsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('objects_bucket_id_path_key').on(table.bucketId, table.path),
+	],
+);
+
+export const filesInCore = sqliteTable(
+	'files',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		name: text().notNull(),
+		latestObjectId: text('latest_object_id'),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'files_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'files_latestObjectId_objects_fkey',
+			columns: [table.latestObjectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'files_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('files_project_id_name_key').on(table.projectId, table.name),
+	],
+);
+
+export const fileVersionsInCore = sqliteTable(
+	'file_versions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		fileId: text('file_id').notNull(),
+		objectId: text('object_id').notNull(),
+		versionNumber: integer('version_number').notNull(),
+		checksum: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'fileversions_fileId_files_fkey',
+			columns: [table.fileId],
+			foreignColumns: [filesInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'fileversions_objectId_objects_fkey',
+			columns: [table.objectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('file_versions_file_id_version_number_key').on(
+			table.fileId,
+			table.versionNumber,
+		),
+	],
+);
+
+export const tagsInCore = sqliteTable(
+	'tags',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text('organization_id').notNull(),
+		key: text().notNull(),
+		value: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'tags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('tags_organization_id_key_value_key').on(
+			table.organizationId,
+			table.key,
+			table.value,
+		),
+	],
+);
+
+export const conversationsInCore = sqliteTable(
+	'conversations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		title: text(),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'conversations_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'conversations_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+	],
+);
+
+export const chatMessagesInCore = sqliteTable(
+	'chat_messages',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		conversationId: text('conversation_id').notNull(),
+		senderId: text('sender_id'),
+		body: text().notNull(),
+		attachments: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'chatmessages_conversationId_conversations_fkey',
+			columns: [table.conversationId],
+			foreignColumns: [conversationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'chatmessages_senderId_users_fkey',
+			columns: [table.senderId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+	],
+);
+
+export const notificationsInCore = sqliteTable(
+	'notifications',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		channel: text().default('in_app').notNull(),
+		payload: text({ mode: 'json' }).notNull(),
+		seen: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		index('core_notifications_unseen_idx')
+			.on(table.userId)
+			.where(sql`(seen = false)`),
+		foreignKey({
+			name: 'notifications_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const customersInBilling = sqliteTable(
+	'customers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id'),
+		name: text().notNull(),
+		address: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'customersinbilling_organizationId_organizations_fkey',
+
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('customers_organization_id_key').on(table.organizationId),
+		uniqueIndex('idnameunique').on(table.id, table.name),
+	],
+);
+
+export const subscriptionsInBilling = sqliteTable(
+	'subscriptions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		customerId: text('customer_id').notNull(),
+		plan: text().notNull(),
+		status: text().default('active').notNull(),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'subscriptionsinbilling_customerId_unknown_fkey',
+			columns: [table.customerId],
+			foreignColumns: [customersInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const paymentsInBilling = sqliteTable(
+	'payments',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		invoiceId: text('invoice_id').notNull(),
+		paidAt: integer('paid_at', { mode: 'timestamp' }).defaultNow().notNull(),
+		amount: numeric({ mode: 'number' }).notNull(),
+		amount3: numeric({ mode: 'string' }).notNull(),
+		amount4: numeric({ mode: 'bigint' }).notNull(),
+		amount2: real().notNull(),
+		method: text().notNull(),
+		transactionRef: text('transaction_ref'),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'paymentsinbilling_invoiceId_unknown_fkey',
+			columns: [table.invoiceId],
+			foreignColumns: [couponsInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const couponsInBilling = sqliteTable(
+	'coupons',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: text().notNull(),
+		description: text(),
+		discountPercent: integer('discount_percent'),
+		maxRedemptions: integer('max_redemptions').generatedAlwaysAs(5),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		uniqueIndex('coupons_code_key').on(table.code),
+		check(
+			'coupons_discount_percent_check',
+			sql`(discount_percent >= 0) AND (discount_percent <= 100)`,
+		),
+	],
+);
+
+export const webhooksInCore = sqliteTable(
+	'webhooks',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		url: text().notNull(),
+		secret: text(),
+		events: text().notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_webhooks_org_active_idx')
+			.on(table.organizationId)
+			.where(sql`(active = true)`),
+		foreignKey({
+			name: 'webhooks_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const metricSourcesInAnalytics = sqliteTable(
+	'metric_sources',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'metricsourcesinanalytics_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metric_sources_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const metricsInAnalytics = sqliteTable(
+	'metrics',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		sourceId: text('source_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+		ts: integer({ mode: 'timestamp' }).notNull(),
+		value: text().notNull(),
+		tags: text({ mode: 'json' }),
+	},
+	(table) => [
+		index('analytics_metrics_key_ts_idx').on(table.metricKey, table.ts),
+		foreignKey({
+			name: 'metricsinanalytics_sourceId_unknown_fkey',
+			columns: [table.sourceId],
+			foreignColumns: [metricSourcesInAnalytics.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metrics_source_id_metric_key_ts_key').on(
+			table.sourceId,
+			table.metricKey,
+			table.ts,
+		),
+	],
+);
+
+export const alertRulesInMonitoring = sqliteTable(
+	'alert_rules',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		description: text(),
+		severity: text().default('medium').notNull(),
+		enabled: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertrulesinmonitoring_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('alert_rules_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const ruleConditionsInMonitoring = sqliteTable(
+	'rule_conditions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'ruleconditionsinmonitoring_ruleId_unknown_fkey',
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const alertsInMonitoring = sqliteTable(
+	'alerts',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		payload: text({ mode: 'json' }),
+		state: text().default('firing').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertsinmonitoring_ruleId_unknown_fkey',
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const escalationsInMonitoring = sqliteTable(
+	'escalations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		alertId: text('alert_id').notNull(),
+		target: text().notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'escalationsinmonitoring_alertId_unknown_fkey',
+			columns: [table.alertId],
+			foreignColumns: [alertsInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const ssoProvidersInCore = sqliteTable(
+	'sso_providers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		type: text().notNull(),
+		config: text({ mode: 'json' }).notNull(),
+		enabled: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'ssoproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const auditLogsInCore = sqliteTable(
+	'audit_logs',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		organizationId: text('organization_id'),
+		actorId: text('actor_id'),
+		objectType: text('object_type').notNull(),
+		objectId: text('object_id'),
+		action: text().notNull(),
+		beforeState: blob('before_state', { mode: 'json' }),
+		afterState: blob('after_state', { mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_audit_org_idx').on(table.organizationId, table.afterState),
+	],
+);
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema03-push.ts b/drizzle-kit/tests/sqlite/snapshots/schema03-push.ts
new file mode 100644
index 0000000000..aea996f40f
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema03-push.ts
@@ -0,0 +1,984 @@
+import { eq, sql } from 'orm044';
+import {
+	AnySQLiteColumn,
+	blob,
+	check,
+	foreignKey,
+	index,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'orm044/sqlite-core';
+import { v4 } from 'uuid';
+
+export const organizationsInCore = sqliteTable(
+	'organizations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: integer({ mode: 'number' }).notNull(),
+		name: text().notNull(),
+		domain: text(),
+		currency: text({ enum: ['USD', 'EUR', 'GBP', 'UAH', 'JPY'] })
+			.default('EUR')
+			.notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_org_name_idx').on(table.name),
+		index('organizations_code_idx').on(table.code),
+		uniqueIndex('organizations_domain_key').on(table.domain),
+		check('organizations_name_check', sql`length(name) > 1`),
+	],
+);
+
+export const usersInCore = sqliteTable(
+	'users',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id', {
+			mode: 'text',
+			length: 100,
+		}).notNull(),
+		username: text().notNull(),
+		status: text({ enum: ['pending', 'done'] })
+			.default('pending')
+			.notNull(),
+		locale: text().default('en-US').notNull(),
+		lastLogin: integer('last_login', { mode: 'timestamp' }),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		bio: text().$onUpdate(() => sql`bio || 'some test'`),
+		profile: blob({ mode: 'json' }),
+	},
+	(table) => [
+		index('core_users_username_idx').on(table.organizationId, table.username),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+			name: 'users_organizationId_organizations_fkey',
+		}).onDelete('cascade'),
+
+		uniqueIndex('users_org_username_unique').on(
+			table.organizationId,
+			table.username,
+		),
+	],
+);
+
+export const rolesInCore = sqliteTable(
+	'roles',
+	{
+		id: integer().primaryKey({ autoIncrement: true }).notNull(),
+		organizationId: text('organization_id')
+			.notNull()
+			.references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+		name: text().notNull(),
+		kind: text({ enum: ['custom'] })
+			.default('custom')
+			.notNull(),
+		builtin: integer({ mode: 'boolean' }).default(false).notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex('roles_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const permissionsInCore = sqliteTable('permissions', {
+	id: integer().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+});
+
+export const membershipsInCore = sqliteTable(
+	'memberships',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		roleId: integer('role_id').notNull(),
+		organizationId: text('organization_id').notNull(),
+		joinedAt: integer('joined_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'memberships_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'memberships_roleId_roles_fkey',
+			columns: [table.roleId],
+			foreignColumns: [rolesInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'memberships_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('unique_membership').on(table.userId, table.organizationId),
+	],
+);
+
+export const apiKeysInCore = sqliteTable(
+	'api_keys',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text(),
+		userId: blob(),
+		name: text().notNull(),
+		keyHash: text('key_hash').notNull(),
+		revoked: integer({ mode: 'boolean' }).default(false).notNull(),
+		expiresAt: integer('expires_at', { mode: 'timestamp' }),
+		metadata: text({ mode: 'json' }).generatedAlwaysAs(sql`'{"some":"test"}'`),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_apikey_org_idx')
+			.on(table.organizationId)
+			.where(sql`(revoked = false)`),
+		foreignKey({
+			name: 'apikeys_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'apikeys_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+
+		uniqueIndex('api_keys_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const sessionsInCore = sqliteTable(
+	'sessions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: blob().notNull(),
+		ip: text(),
+		userAgent: text('user_agent'),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		expiresAt: integer('expires_at', {
+			mode: 'timestamp_ms',
+		}).notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_sessions_user_expires').on(table.userId, table.expiresAt),
+		foreignKey({
+			name: 'sessions_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const oauthProvidersInCore = sqliteTable(
+	'oauth_providers',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text().notNull(),
+		provider: text().notNull(),
+		clientId: text('client_id').notNull(),
+		clientSecret: text('client_secret').notNull(),
+		config: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'oauthproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('oauth_providers_organization_id_provider_key').on(
+			table.organizationId,
+			table.provider,
+		),
+	],
+);
+
+export const featureFlagsInCore = sqliteTable(
+	'feature_flags',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		key: text().notNull(),
+		description: text(),
+		state: text({ enum: ['disabled'] })
+			.default('disabled')
+			.notNull(),
+		rolloutPercent: integer('rollout_percent').default(0),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'featureflags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('feature_flags_organization_id_key_key').on(
+			table.organizationId,
+			table.key,
+		),
+		check(
+			'feature_flags_rollout_percent_check',
+			sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`,
+		),
+	],
+);
+
+export const projectsInCore = sqliteTable(
+	'projects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		name: text().notNull(),
+		slug: text().notNull(),
+		description: text(),
+		visibility: text().default('priv"ate').notNull(),
+		createdBy: blob('created_by'),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_projects_org_name_idx').on(table.organizationId, table.name),
+		foreignKey({
+			name: 'projects_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'projects_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('projects_org_slug_unique').on(
+			table.organizationId,
+			table.slug,
+		),
+	],
+);
+
+export const repositoriesInCore = sqliteTable(
+	'repositories',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: blob('project_id').notNull(),
+		provider: text().notNull(),
+		repoOwner: text('repo_owner').notNull(),
+		repoName: text('repo_name').notNull(),
+		defaultBranch: text('default_branch').default('main').notNull(),
+		cloneUrl: text('clone_url'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'repositories_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('repositories_project_id_provider_repo_owner_repo_name_key').on(
+			table.projectId,
+			table.provider,
+			table.repoOwner,
+			table.repoName,
+		),
+	],
+);
+
+export const buildsInCore = sqliteTable(
+	'builds',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		projectId: blob('project_id').notNull(),
+		triggeredBy: blob('triggered_by'),
+		commitSha: text('commit_sha', { length: 40 }).notNull(),
+		status: text().default('created').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		metadata: blob({ mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_builds_project_status_idx').on(table.projectId, table.status),
+		foreignKey({
+			name: 'builds_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'builds_triggeredBy_users_fkey',
+			columns: [table.triggeredBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('builds_project_id_commit_sha_key').on(
+			table.projectId,
+			table.commitSha,
+		),
+	],
+);
+
+export const pipelinesInCore = sqliteTable(
+	'pipelines',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id').notNull(),
+		name: text().notNull(),
+		spec: blob({ mode: 'json' }).notNull(),
+		status: text().default('created').notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'pipelines_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipelines_project_id_name_key').on(
+			table.projectId,
+			table.name,
+		),
+	],
+);
+
+export const pipelineRunsInAnalytics = sqliteTable(
+	'pipeline_runs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineId: text('pipeline_id').notNull(),
+
+		runNumber: blob('run_number', { mode: 'bigint' }).notNull(),
+		state: text().default('queued').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		logs: text(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('analytics_pipeline_runs_state_idx').on(table.state),
+		foreignKey({
+			name: 'pipelinerunsinanalytics_pipelineId_pipelines_fkey',
+			columns: [table.pipelineId],
+			foreignColumns: [pipelinesInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipeline_runs_unique_run').on(
+			table.pipelineId,
+			table.runNumber,
+		),
+	],
+);
+
+export const jobsInAnalytics = sqliteTable(
+	'jobs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineRunId: text('pipeline_run_id'),
+		name: text().notNull(),
+		state: text().default('queued').notNull(),
+		attempts: integer().default(0).notNull(),
+		lastError: text('last_error'),
+	},
+	(table) => [
+		index('analytics_jobs_state_attempts_idx').on(table.state, table.attempts),
+		foreignKey({
+			name: 'jobsinanalytics_pipelineRunId_unknown_fkey',
+			columns: [table.pipelineRunId],
+			foreignColumns: [pipelineRunsInAnalytics.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const storageBucketsInCore = sqliteTable(
+	'storage_buckets',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		region: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'storagebuckets_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('storage_buckets_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const objectsInCore = sqliteTable(
+	'objects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		bucketId: text('bucket_id').notNull(),
+		path: text().notNull(),
+		size: blob({ mode: 'bigint' }).notNull(),
+		contentType: text('content_type'),
+		metadata: blob({ mode: 'bigint' }),
+	},
+	(table) => [
+		index('core_objects_bucket_path_gin').on(table.metadata),
+		foreignKey({
+			name: 'objects_bucketId_storagebuckets_fkey',
+			columns: [table.bucketId],
+			foreignColumns: [storageBucketsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('objects_bucket_id_path_key').on(table.bucketId, table.path),
+	],
+);
+
+export const filesInCore = sqliteTable(
+	'files',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		name: text().notNull(),
+		latestObjectId: text('latest_object_id'),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'files_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'files_latestObjectId_objects_fkey',
+			columns: [table.latestObjectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'files_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('files_project_id_name_key').on(table.projectId, table.name),
+	],
+);
+
+export const fileVersionsInCore = sqliteTable(
+	'file_versions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		fileId: text('file_id').notNull(),
+		objectId: text('object_id').notNull(),
+		versionNumber: integer('version_number').notNull(),
+		checksum: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'fileversions_fileId_files_fkey',
+			columns: [table.fileId],
+			foreignColumns: [filesInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'fileversions_objectId_objects_fkey',
+			columns: [table.objectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('file_versions_file_id_version_number_key').on(
+			table.fileId,
+			table.versionNumber,
+		),
+	],
+);
+
+export const tagsInCore = sqliteTable(
+	'tags',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text('organization_id').notNull(),
+		key: text().notNull(),
+		value: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'tags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('tags_organization_id_key_value_key').on(
+			table.organizationId,
+			table.key,
+			table.value,
+		),
+	],
+);
+
+export const conversationsInCore = sqliteTable(
+	'conversations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		title: text(),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'conversations_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'conversations_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+	],
+);
+
+export const chatMessagesInCore = sqliteTable(
+	'chat_messages',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		conversationId: text('conversation_id').notNull(),
+		senderId: text('sender_id'),
+		body: text().notNull(),
+		attachments: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'chatmessages_conversationId_conversations_fkey',
+			columns: [table.conversationId],
+			foreignColumns: [conversationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'chatmessages_senderId_users_fkey',
+			columns: [table.senderId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+	],
+);
+
+export const notificationsInCore = sqliteTable(
+	'notifications',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		channel: text().default('in_app').notNull(),
+		payload: text({ mode: 'json' }).notNull(),
+		seen: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		index('core_notifications_unseen_idx')
+			.on(table.userId)
+			.where(sql`(seen = false)`),
+		foreignKey({
+			name: 'notifications_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const customersInBilling = sqliteTable(
+	'customers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id'),
+		name: text().notNull(),
+		address: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'customersinbilling_organizationId_organizations_fkey',
+
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('customers_organization_id_key').on(table.organizationId),
+		uniqueIndex('idnameunique').on(table.id, table.name),
+	],
+);
+
+export const subscriptionsInBilling = sqliteTable(
+	'subscriptions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		customerId: text('customer_id').notNull(),
+		plan: text().notNull(),
+		status: text().default('active').notNull(),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'subscriptionsinbilling_customerId_unknown_fkey',
+			columns: [table.customerId],
+			foreignColumns: [customersInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const paymentsInBilling = sqliteTable(
+	'payments',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		invoiceId: text('invoice_id').notNull(),
+		paidAt: integer('paid_at', { mode: 'timestamp' }).defaultNow().notNull(),
+		amount: numeric({ mode: 'number' }).notNull(),
+		amount3: numeric({ mode: 'string' }).notNull(),
+		amount4: numeric({ mode: 'bigint' }).notNull(),
+		amount2: real().notNull(),
+		method: text().notNull(),
+		transactionRef: text('transaction_ref'),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'paymentsinbilling_invoiceId_unknown_fkey',
+			columns: [table.invoiceId],
+			foreignColumns: [couponsInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const couponsInBilling = sqliteTable(
+	'coupons',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: text().notNull(),
+		description: text(),
+		discountPercent: integer('discount_percent'),
+		maxRedemptions: integer('max_redemptions').generatedAlwaysAs(5),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		uniqueIndex('coupons_code_key').on(table.code),
+		check(
+			'coupons_discount_percent_check',
+			sql`(discount_percent >= 0) AND (discount_percent <= 100)`,
+		),
+	],
+);
+
+export const webhooksInCore = sqliteTable(
+	'webhooks',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		url: text().notNull(),
+		secret: text(),
+		events: text().notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_webhooks_org_active_idx')
+			.on(table.organizationId)
+			.where(sql`(active = true)`),
+		foreignKey({
+			name: 'webhooks_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const metricSourcesInAnalytics = sqliteTable(
+	'metric_sources',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metric_sources_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const metricsInAnalytics = sqliteTable(
+	'metrics',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		sourceId: text('source_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+		ts: integer({ mode: 'timestamp' }).notNull(),
+		value: text().notNull(),
+		tags: text({ mode: 'json' }),
+	},
+	(table) => [
+		index('analytics_metrics_key_ts_idx').on(table.metricKey, table.ts),
+		foreignKey({
+			name: 'metricsinanalytics_sourceId_unknown_fkey',
+			columns: [table.sourceId],
+			foreignColumns: [metricSourcesInAnalytics.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metrics_source_id_metric_key_ts_key').on(
+			table.sourceId,
+			table.metricKey,
+			table.ts,
+		),
+	],
+);
+
+export const alertRulesInMonitoring = sqliteTable(
+	'alert_rules',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		description: text(),
+		severity: text().default('medium').notNull(),
+		enabled: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertrulesinmonitoring_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('alert_rules_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const ruleConditionsInMonitoring = sqliteTable(
+	'rule_conditions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const alertsInMonitoring = sqliteTable(
+	'alerts',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		payload: text({ mode: 'json' }),
+		state: text().default('firing').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertsinmonitoring_ruleId_unknown_fkey',
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const escalationsInMonitoring = sqliteTable(
+	'escalations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		alertId: text('alert_id').notNull(),
+		target: text().notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'escalationsinmonitoring_alertId_unknown_fkey',
+			columns: [table.alertId],
+			foreignColumns: [alertsInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const ssoProvidersInCore = sqliteTable(
+	'sso_providers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		type: text().notNull(),
+		config: text({ mode: 'json' }).notNull(),
+		enabled: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'ssoproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const auditLogsInCore = sqliteTable(
+	'audit_logs',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		organizationId: text('organization_id'),
+		actorId: text('actor_id'),
+		objectType: text('object_type').notNull(),
+		objectId: text('object_id'),
+		action: text().notNull(),
+		beforeState: blob('before_state', { mode: 'json' }),
+		afterState: blob('after_state', { mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_audit_org_idx').on(table.organizationId, table.afterState),
+	],
+);
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema03new-generate.ts b/drizzle-kit/tests/sqlite/snapshots/schema03new-generate.ts
new file mode 100644
index 0000000000..e78995a152
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema03new-generate.ts
@@ -0,0 +1,984 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	blob,
+	check,
+	foreignKey,
+	index,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { v4 } from 'uuid';
+
+export const organizationsInCore = sqliteTable(
+	'organizations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: integer({ mode: 'number' }).notNull(),
+		name: text().notNull(),
+		domain: text(),
+		currency: text({ enum: ['USD', 'EUR', 'GBP', 'UAH', 'JPY'] })
+			.default('EUR')
+			.notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_org_name_idx').on(table.name),
+		index('organizations_code_idx').on(table.code),
+		uniqueIndex('organizations_domain_key').on(table.domain),
+		check('organizations_name_check', sql`length(name) > 1`),
+	],
+);
+
+export const usersInCore = sqliteTable(
+	'users',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id', {
+			mode: 'text',
+			length: 100,
+		}).notNull(),
+		username: text().notNull(),
+		status: text({ enum: ['pending', 'done'] })
+			.default('pending')
+			.notNull(),
+		locale: text().default('en-US').notNull(),
+		lastLogin: integer('last_login', { mode: 'timestamp' }),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		bio: text().$onUpdate(() => sql`bio || 'some test'`),
+		profile: blob({ mode: 'json' }),
+	},
+	(table) => [
+		index('core_users_username_idx').on(table.organizationId, table.username),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+			name: 'users_organizationId_organizations_fkey',
+		}).onDelete('cascade'),
+
+		uniqueIndex('users_org_username_unique').on(
+			table.organizationId,
+			table.username,
+		),
+	],
+);
+
+export const rolesInCore = sqliteTable(
+	'roles',
+	{
+		id: integer().primaryKey({ autoIncrement: true }).notNull(),
+		organizationId: text('organization_id')
+			.notNull()
+			.references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+		name: text().notNull(),
+		kind: text({ enum: ['custom'] })
+			.default('custom')
+			.notNull(),
+		builtin: integer({ mode: 'boolean' }).default(false).notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex('roles_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const permissionsInCore = sqliteTable('permissions', {
+	id: integer().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+});
+
+export const membershipsInCore = sqliteTable(
+	'memberships',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		roleId: integer('role_id').notNull(),
+		organizationId: text('organization_id').notNull(),
+		joinedAt: integer('joined_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'memberships_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'memberships_roleId_roles_fkey',
+			columns: [table.roleId],
+			foreignColumns: [rolesInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'memberships_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('unique_membership').on(table.userId, table.organizationId),
+	],
+);
+
+export const apiKeysInCore = sqliteTable(
+	'api_keys',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text(),
+		userId: blob(),
+		name: text().notNull(),
+		keyHash: text('key_hash').notNull(),
+		revoked: integer({ mode: 'boolean' }).default(false).notNull(),
+		expiresAt: integer('expires_at', { mode: 'timestamp' }),
+		metadata: text({ mode: 'json' }).generatedAlwaysAs(sql`'{"some":"test"}'`),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_apikey_org_idx')
+			.on(table.organizationId)
+			.where(sql`(revoked = false)`),
+		foreignKey({
+			name: 'apikeys_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'apikeys_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+
+		uniqueIndex('api_keys_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const sessionsInCore = sqliteTable(
+	'sessions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: blob().notNull(),
+		ip: text(),
+		userAgent: text('user_agent'),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		expiresAt: integer('expires_at', {
+			mode: 'timestamp_ms',
+		}).notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_sessions_user_expires').on(table.userId, table.expiresAt),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const oauthProvidersInCore = sqliteTable(
+	'oauth_providers',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text().notNull(),
+		provider: text().notNull(),
+		clientId: text('client_id').notNull(),
+		clientSecret: text('client_secret').notNull(),
+		config: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'oauthproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('oauth_providers_organization_id_provider_key').on(
+			table.organizationId,
+			table.provider,
+		),
+	],
+);
+
+export const featureFlagsInCore = sqliteTable(
+	'feature_flags',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		key: text().notNull(),
+		description: text(),
+		state: text({ enum: ['disabled'] })
+			.default('disabled')
+			.notNull(),
+		rolloutPercent: integer('rollout_percent').default(0),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'featureflags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('feature_flags_organization_id_key_key').on(
+			table.organizationId,
+			table.key,
+		),
+		check(
+			'feature_flags_rollout_percent_check',
+			sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`,
+		),
+	],
+);
+
+export const projectsInCore = sqliteTable(
+	'projects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		name: text().notNull(),
+		slug: text().notNull(),
+		description: text(),
+		visibility: text().default('priv"ate').notNull(),
+		createdBy: blob('created_by'),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_projects_org_name_idx').on(table.organizationId, table.name),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'projects_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('projects_org_slug_unique').on(
+			table.organizationId,
+			table.slug,
+		),
+	],
+);
+
+export const repositoriesInCore = sqliteTable(
+	'repositories',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: blob('project_id').notNull(),
+		provider: text().notNull(),
+		repoOwner: text('repo_owner').notNull(),
+		repoName: text('repo_name').notNull(),
+		defaultBranch: text('default_branch').default('main').notNull(),
+		cloneUrl: text('clone_url'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'repositories_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('repositories_project_id_provider_repo_owner_repo_name_key').on(
+			table.projectId,
+			table.provider,
+			table.repoOwner,
+			table.repoName,
+		),
+	],
+);
+
+export const buildsInCore = sqliteTable(
+	'builds',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		projectId: blob('project_id').notNull(),
+		triggeredBy: blob('triggered_by'),
+		commitSha: text('commit_sha', { length: 40 }).notNull(),
+		status: text().default('created').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		metadata: blob({ mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_builds_project_status_idx').on(table.projectId, table.status),
+		foreignKey({
+			name: 'builds_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'builds_triggeredBy_users_fkey',
+			columns: [table.triggeredBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('builds_project_id_commit_sha_key').on(
+			table.projectId,
+			table.commitSha,
+		),
+	],
+);
+
+export const pipelinesInCore = sqliteTable(
+	'pipelines',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id').notNull(),
+		name: text().notNull(),
+		spec: blob({ mode: 'json' }).notNull(),
+		status: text().default('created').notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'pipelines_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipelines_project_id_name_key').on(
+			table.projectId,
+			table.name,
+		),
+	],
+);
+
+export const pipelineRunsInAnalytics = sqliteTable(
+	'pipeline_runs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineId: text('pipeline_id').notNull(),
+
+		runNumber: blob('run_number', { mode: 'bigint' }).notNull(),
+		state: text().default('queued').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		logs: text(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('analytics_pipeline_runs_state_idx').on(table.state),
+		foreignKey({
+			name: 'pipelinerunsinanalytics_pipelineId_pipelines_fkey',
+			columns: [table.pipelineId],
+			foreignColumns: [pipelinesInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipeline_runs_unique_run').on(
+			table.pipelineId,
+			table.runNumber,
+		),
+	],
+);
+
+export const jobsInAnalytics = sqliteTable(
+	'jobs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineRunId: text('pipeline_run_id'),
+		name: text().notNull(),
+		state: text().default('queued').notNull(),
+		attempts: integer().default(0).notNull(),
+		lastError: text('last_error'),
+	},
+	(table) => [
+		index('analytics_jobs_state_attempts_idx').on(table.state, table.attempts),
+		foreignKey({
+			name: 'jobsinanalytics_pipelineRunId_unknown_fkey',
+			columns: [table.pipelineRunId],
+			foreignColumns: [pipelineRunsInAnalytics.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const storageBucketsInCore = sqliteTable(
+	'storage_buckets',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		region: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'storagebuckets_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('storage_buckets_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const objectsInCore = sqliteTable(
+	'objects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		bucketId: text('bucket_id').notNull(),
+		path: text().notNull(),
+		size: blob({ mode: 'bigint' }).notNull(),
+		contentType: text('content_type'),
+		metadata: blob({ mode: 'bigint' }),
+	},
+	(table) => [
+		index('core_objects_bucket_path_gin').on(table.metadata),
+		foreignKey({
+			name: 'objects_bucketId_storagebuckets_fkey',
+			columns: [table.bucketId],
+			foreignColumns: [storageBucketsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('objects_bucket_id_path_key').on(table.bucketId, table.path),
+	],
+);
+
+export const filesInCore = sqliteTable(
+	'files',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		name: text().notNull(),
+		latestObjectId: text('latest_object_id'),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'files_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'files_latestObjectId_objects_fkey',
+			columns: [table.latestObjectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'files_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('files_project_id_name_key').on(table.projectId, table.name),
+	],
+);
+
+export const fileVersionsInCore = sqliteTable(
+	'file_versions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		fileId: text('file_id').notNull(),
+		objectId: text('object_id').notNull(),
+		versionNumber: integer('version_number').notNull(),
+		checksum: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'fileversions_fileId_files_fkey',
+			columns: [table.fileId],
+			foreignColumns: [filesInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'fileversions_objectId_objects_fkey',
+			columns: [table.objectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('file_versions_file_id_version_number_key').on(
+			table.fileId,
+			table.versionNumber,
+		),
+	],
+);
+
+export const tagsInCore = sqliteTable(
+	'tags',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text('organization_id').notNull(),
+		key: text().notNull(),
+		value: text(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'tags_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('tags_organization_id_key_value_key').on(
+			table.organizationId,
+			table.key,
+			table.value,
+		),
+	],
+);
+
+export const conversationsInCore = sqliteTable(
+	'conversations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		title: text(),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			name: 'conversations_projectId_projects_fkey',
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			name: 'conversations_createdBy_users_fkey',
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+	],
+);
+
+export const chatMessagesInCore = sqliteTable(
+	'chat_messages',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		conversationId: text('conversation_id').notNull(),
+		senderId: text('sender_id'),
+		body: text().notNull(),
+		attachments: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'chatmessages_conversationId_conversations_fkey',
+			columns: [table.conversationId],
+			foreignColumns: [conversationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			name: 'chatmessages_senderId_users_fkey',
+			columns: [table.senderId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+	],
+);
+
+export const notificationsInCore = sqliteTable(
+	'notifications',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		channel: text().default('in_app').notNull(),
+		payload: text({ mode: 'json' }).notNull(),
+		seen: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		index('core_notifications_unseen_idx')
+			.on(table.userId)
+			.where(sql`(seen = false)`),
+		foreignKey({
+			name: 'notifications_userId_users_fkey',
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const customersInBilling = sqliteTable(
+	'customers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id'),
+		name: text().notNull(),
+		address: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'customersinbilling_organizationId_organizations_fkey',
+
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('customers_organization_id_key').on(table.organizationId),
+		uniqueIndex('idnameunique').on(table.id, table.name),
+	],
+);
+
+export const subscriptionsInBilling = sqliteTable(
+	'subscriptions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		customerId: text('customer_id').notNull(),
+		plan: text().notNull(),
+		status: text().default('active').notNull(),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'subscriptionsinbilling_customerId_unknown_fkey',
+			columns: [table.customerId],
+			foreignColumns: [customersInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const paymentsInBilling = sqliteTable(
+	'payments',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		invoiceId: text('invoice_id').notNull(),
+		paidAt: integer('paid_at', { mode: 'timestamp' }).defaultNow().notNull(),
+		amount: numeric({ mode: 'number' }).notNull(),
+		amount3: numeric({ mode: 'string' }).notNull(),
+		amount4: numeric({ mode: 'bigint' }).notNull(),
+		amount2: real().notNull(),
+		method: text().notNull(),
+		transactionRef: text('transaction_ref'),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'paymentsinbilling_invoiceId_unknown_fkey',
+			columns: [table.invoiceId],
+			foreignColumns: [couponsInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const couponsInBilling = sqliteTable(
+	'coupons',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: text().notNull(),
+		description: text(),
+		discountPercent: integer('discount_percent'),
+		maxRedemptions: integer('max_redemptions').generatedAlwaysAs(sql`5`),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		uniqueIndex('coupons_code_key').on(table.code),
+		check(
+			'coupons_discount_percent_check',
+			sql`(discount_percent >= 0) AND (discount_percent <= 100)`,
+		),
+	],
+);
+
+export const webhooksInCore = sqliteTable(
+	'webhooks',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		url: text().notNull(),
+		secret: text(),
+		events: text().notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_webhooks_org_active_idx')
+			.on(table.organizationId)
+			.where(sql`(active = true)`),
+		foreignKey({
+			name: 'webhooks_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const metricSourcesInAnalytics = sqliteTable(
+	'metric_sources',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			name: 'metricsourcesinanalytics_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metric_sources_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const metricsInAnalytics = sqliteTable(
+	'metrics',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		sourceId: text('source_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+		ts: integer({ mode: 'timestamp' }).notNull(),
+		value: text().notNull(),
+		tags: text({ mode: 'json' }),
+	},
+	(table) => [
+		index('analytics_metrics_key_ts_idx').on(table.metricKey, table.ts),
+		foreignKey({
+			name: 'metricsinanalytics_sourceId_unknown_fkey',
+			columns: [table.sourceId],
+			foreignColumns: [metricSourcesInAnalytics.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metrics_source_id_metric_key_ts_key').on(
+			table.sourceId,
+			table.metricKey,
+			table.ts,
+		),
+	],
+);
+
+export const alertRulesInMonitoring = sqliteTable(
+	'alert_rules',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		description: text(),
+		severity: text().default('medium').notNull(),
+		enabled: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertrulesinmonitoring_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('alert_rules_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const ruleConditionsInMonitoring = sqliteTable(
+	'rule_conditions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'ruleconditionsinmonitoring_ruleId_unknown_fkey',
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const alertsInMonitoring = sqliteTable(
+	'alerts',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		payload: text({ mode: 'json' }),
+		state: text().default('firing').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'alertsinmonitoring_ruleId_unknown_fkey',
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const escalationsInMonitoring = sqliteTable(
+	'escalations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		alertId: text('alert_id').notNull(),
+		target: text().notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'escalationsinmonitoring_alertId_unknown_fkey',
+			columns: [table.alertId],
+			foreignColumns: [alertsInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const ssoProvidersInCore = sqliteTable(
+	'sso_providers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		type: text().notNull(),
+		config: text({ mode: 'json' }).notNull(),
+		enabled: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			name: 'ssoproviders_organizationId_organizations_fkey',
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const auditLogsInCore = sqliteTable(
+	'audit_logs',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		organizationId: text('organization_id'),
+		actorId: text('actor_id'),
+		objectType: text('object_type').notNull(),
+		objectId: text('object_id'),
+		action: text().notNull(),
+		beforeState: blob('before_state', { mode: 'json' }),
+		afterState: blob('after_state', { mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_audit_org_idx').on(table.organizationId, table.afterState),
+	],
+);
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema03new-push.ts b/drizzle-kit/tests/sqlite/snapshots/schema03new-push.ts
new file mode 100644
index 0000000000..0dac7efb56
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema03new-push.ts
@@ -0,0 +1,944 @@
+import { eq, sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	blob,
+	check,
+	foreignKey,
+	index,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { v4 } from 'uuid';
+
+export const organizationsInCore = sqliteTable(
+	'organizations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: integer({ mode: 'number' }).notNull(),
+		name: text().notNull(),
+		domain: text(),
+		currency: text({ enum: ['USD', 'EUR', 'GBP', 'UAH', 'JPY'] })
+			.default('EUR')
+			.notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_org_name_idx').on(table.name),
+		index('organizations_code_idx').on(table.code),
+		uniqueIndex('organizations_domain_key').on(table.domain),
+		check('organizations_name_check', sql`length(name) > 1`),
+	],
+);
+
+export const usersInCore = sqliteTable(
+	'users',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id', {
+			mode: 'text',
+			length: 100,
+		}).notNull(),
+		username: text().notNull(),
+		status: text({ enum: ['pending', 'done'] })
+			.default('pending')
+			.notNull(),
+		locale: text().default('en-US').notNull(),
+		lastLogin: integer('last_login', { mode: 'timestamp' }),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		bio: text().$onUpdate(() => sql`bio || 'some test'`),
+		profile: blob({ mode: 'json' }),
+	},
+	(table) => [
+		index('core_users_username_idx').on(table.organizationId, table.username),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('users_org_username_unique').on(
+			table.organizationId,
+			table.username,
+		),
+	],
+);
+
+export const rolesInCore = sqliteTable(
+	'roles',
+	{
+		id: integer().primaryKey({ autoIncrement: true }).notNull(),
+		organizationId: text('organization_id')
+			.notNull()
+			.references(() => organizationsInCore.id, { onDelete: 'cascade' }),
+		name: text().notNull(),
+		kind: text({ enum: ['custom'] })
+			.default('custom')
+			.notNull(),
+		builtin: integer({ mode: 'boolean' }).default(false).notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		uniqueIndex('roles_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const permissionsInCore = sqliteTable('permissions', {
+	id: integer().primaryKey().notNull(),
+	code: text().notNull(),
+	description: text(),
+});
+
+export const membershipsInCore = sqliteTable(
+	'memberships',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		roleId: integer('role_id').notNull(),
+		organizationId: text('organization_id').notNull(),
+		joinedAt: integer('joined_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.roleId],
+			foreignColumns: [rolesInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('unique_membership').on(table.userId, table.organizationId),
+	],
+);
+
+export const apiKeysInCore = sqliteTable(
+	'api_keys',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text(),
+		userId: blob(),
+		name: text().notNull(),
+		keyHash: text('key_hash').notNull(),
+		revoked: integer({ mode: 'boolean' }).default(false).notNull(),
+		expiresAt: integer('expires_at', { mode: 'timestamp' }),
+		metadata: text({ mode: 'json' }).generatedAlwaysAs(sql`'{"some":"test"}'`),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_apikey_org_idx')
+			.on(table.organizationId)
+			.where(sql`(revoked = false)`),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+
+		uniqueIndex('api_keys_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const sessionsInCore = sqliteTable(
+	'sessions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: blob().notNull(),
+		ip: text(),
+		userAgent: text('user_agent'),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+		expiresAt: integer('expires_at', {
+			mode: 'timestamp_ms',
+		}).notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_sessions_user_expires').on(table.userId, table.expiresAt),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const oauthProvidersInCore = sqliteTable(
+	'oauth_providers',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text().notNull(),
+		provider: text().notNull(),
+		clientId: text('client_id').notNull(),
+		clientSecret: text('client_secret').notNull(),
+		config: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('oauth_providers_organization_id_provider_key').on(
+			table.organizationId,
+			table.provider,
+		),
+	],
+);
+
+export const featureFlagsInCore = sqliteTable(
+	'feature_flags',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		key: text().notNull(),
+		description: text(),
+		state: text({ enum: ['disabled'] })
+			.default('disabled')
+			.notNull(),
+		rolloutPercent: integer('rollout_percent').default(0),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('feature_flags_organization_id_key_key').on(
+			table.organizationId,
+			table.key,
+		),
+		check(
+			'feature_flags_rollout_percent_check',
+			sql`(rollout_percent >= 0) AND (rollout_percent <= 100)`,
+		),
+	],
+);
+
+export const projectsInCore = sqliteTable(
+	'projects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: blob('organization_id').notNull(),
+		name: text().notNull(),
+		slug: text().notNull(),
+		description: text(),
+		visibility: text().default('priv"ate').notNull(),
+		createdBy: blob('created_by'),
+		createdAt: integer('created_at', { mode: 'timestamp_ms' })
+			.defaultNow()
+			.notNull(),
+		updatedAt: integer('updated_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('core_projects_org_name_idx').on(table.organizationId, table.name),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('projects_org_slug_unique').on(
+			table.organizationId,
+			table.slug,
+		),
+	],
+);
+
+export const repositoriesInCore = sqliteTable(
+	'repositories',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: blob('project_id').notNull(),
+		provider: text().notNull(),
+		repoOwner: text('repo_owner').notNull(),
+		repoName: text('repo_name').notNull(),
+		defaultBranch: text('default_branch').default('main').notNull(),
+		cloneUrl: text('clone_url'),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('repositories_project_id_provider_repo_owner_repo_name_key').on(
+			table.projectId,
+			table.provider,
+			table.repoOwner,
+			table.repoName,
+		),
+	],
+);
+
+export const buildsInCore = sqliteTable(
+	'builds',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		projectId: blob('project_id').notNull(),
+		triggeredBy: blob('triggered_by'),
+		commitSha: text('commit_sha', { length: 40 }).notNull(),
+		status: text().default('created').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		metadata: blob({ mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_builds_project_status_idx').on(table.projectId, table.status),
+		foreignKey({
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.triggeredBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('builds_project_id_commit_sha_key').on(
+			table.projectId,
+			table.commitSha,
+		),
+	],
+);
+
+export const pipelinesInCore = sqliteTable(
+	'pipelines',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id').notNull(),
+		name: text().notNull(),
+		spec: blob({ mode: 'json' }).notNull(),
+		status: text().default('created').notNull(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipelines_project_id_name_key').on(
+			table.projectId,
+			table.name,
+		),
+	],
+);
+
+export const pipelineRunsInAnalytics = sqliteTable(
+	'pipeline_runs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineId: text('pipeline_id').notNull(),
+
+		runNumber: blob('run_number', { mode: 'bigint' }).notNull(),
+		state: text().default('queued').notNull(),
+		startedAt: integer('started_at', { mode: 'timestamp_ms' }),
+		finishedAt: integer('finished_at', {
+			mode: 'timestamp',
+		}),
+		logs: text(),
+		createdAt: integer('created_at', { mode: 'timestamp' })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index('analytics_pipeline_runs_state_idx').on(table.state),
+		foreignKey({
+			columns: [table.pipelineId],
+			foreignColumns: [pipelinesInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('pipeline_runs_unique_run').on(
+			table.pipelineId,
+			table.runNumber,
+		),
+	],
+);
+
+export const jobsInAnalytics = sqliteTable(
+	'jobs',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		pipelineRunId: text('pipeline_run_id'),
+		name: text().notNull(),
+		state: text().default('queued').notNull(),
+		attempts: integer().default(0).notNull(),
+		lastError: text('last_error'),
+	},
+	(table) => [
+		index('analytics_jobs_state_attempts_idx').on(table.state, table.attempts),
+		foreignKey({
+			columns: [table.pipelineRunId],
+			foreignColumns: [pipelineRunsInAnalytics.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const storageBucketsInCore = sqliteTable(
+	'storage_buckets',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		region: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('storage_buckets_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const objectsInCore = sqliteTable(
+	'objects',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		bucketId: text('bucket_id').notNull(),
+		path: text().notNull(),
+		size: blob({ mode: 'bigint' }).notNull(),
+		contentType: text('content_type'),
+		metadata: blob({ mode: 'bigint' }),
+	},
+	(table) => [
+		index('core_objects_bucket_path_gin').on(table.metadata),
+		foreignKey({
+			columns: [table.bucketId],
+			foreignColumns: [storageBucketsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('objects_bucket_id_path_key').on(table.bucketId, table.path),
+	],
+);
+
+export const filesInCore = sqliteTable(
+	'files',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		name: text().notNull(),
+		latestObjectId: text('latest_object_id'),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.latestObjectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+
+		uniqueIndex('files_project_id_name_key').on(table.projectId, table.name),
+	],
+);
+
+export const fileVersionsInCore = sqliteTable(
+	'file_versions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		fileId: text('file_id').notNull(),
+		objectId: text('object_id').notNull(),
+		versionNumber: integer('version_number').notNull(),
+		checksum: text(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.fileId],
+			foreignColumns: [filesInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.objectId],
+			foreignColumns: [objectsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('file_versions_file_id_version_number_key').on(
+			table.fileId,
+			table.versionNumber,
+		),
+	],
+);
+
+export const tagsInCore = sqliteTable(
+	'tags',
+	{
+		id: integer().primaryKey().notNull(),
+		organizationId: text('organization_id').notNull(),
+		key: text().notNull(),
+		value: text(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('tags_organization_id_key_value_key').on(
+			table.organizationId,
+			table.key,
+			table.value,
+		),
+	],
+);
+
+export const conversationsInCore = sqliteTable(
+	'conversations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		projectId: text('project_id'),
+		title: text(),
+		createdBy: text('created_by'),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.projectId],
+			foreignColumns: [projectsInCore.id],
+		}).onDelete('set null'),
+
+		foreignKey({
+			columns: [table.createdBy],
+			foreignColumns: [usersInCore.id],
+		}),
+	],
+);
+
+export const chatMessagesInCore = sqliteTable(
+	'chat_messages',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		conversationId: text('conversation_id').notNull(),
+		senderId: text('sender_id'),
+		body: text().notNull(),
+		attachments: blob({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.conversationId],
+			foreignColumns: [conversationsInCore.id],
+		}).onDelete('cascade'),
+
+		foreignKey({
+			columns: [table.senderId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('set null'),
+	],
+);
+
+export const notificationsInCore = sqliteTable(
+	'notifications',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		userId: text('user_id').notNull(),
+		channel: text().default('in_app').notNull(),
+		payload: text({ mode: 'json' }).notNull(),
+		seen: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		index('core_notifications_unseen_idx')
+			.on(table.userId)
+			.where(sql`(seen = false)`),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [usersInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const customersInBilling = sqliteTable(
+	'customers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id'),
+		name: text().notNull(),
+		address: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('customers_organization_id_key').on(table.organizationId),
+		uniqueIndex('idnameunique').on(table.id, table.name),
+	],
+);
+
+export const subscriptionsInBilling = sqliteTable(
+	'subscriptions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		customerId: text('customer_id').notNull(),
+		plan: text().notNull(),
+		status: text().default('active').notNull(),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.customerId],
+			foreignColumns: [customersInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const paymentsInBilling = sqliteTable(
+	'payments',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		invoiceId: text('invoice_id').notNull(),
+		paidAt: integer('paid_at', { mode: 'timestamp' }).defaultNow().notNull(),
+		amount: numeric({ mode: 'bigint' }).notNull(),
+		amount3: numeric({ mode: 'number' }).notNull(),
+		amount4: numeric({ mode: 'string' }).notNull(),
+		amount2: real().notNull(),
+		method: text().notNull(),
+		transactionRef: text('transaction_ref'),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.invoiceId],
+			foreignColumns: [couponsInBilling.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const couponsInBilling = sqliteTable(
+	'coupons',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		code: text().notNull(),
+		description: text(),
+		discountPercent: integer('discount_percent'),
+		maxRedemptions: integer('max_redemptions').generatedAlwaysAs(sql`5`),
+		metadata: text({ mode: 'json' }),
+	},
+	(table) => [
+		uniqueIndex('coupons_code_key').on(table.code),
+		check(
+			'coupons_discount_percent_check',
+			sql`(discount_percent >= 0) AND (discount_percent <= 100)`,
+		),
+	],
+);
+
+export const webhooksInCore = sqliteTable(
+	'webhooks',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		url: text().notNull(),
+		secret: text(),
+		events: text().notNull(),
+		active: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		index('core_webhooks_org_active_idx')
+			.on(table.organizationId)
+			.where(sql`(active = true)`),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const metricSourcesInAnalytics = sqliteTable(
+	'metric_sources',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		config: text({ mode: 'json' }),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metric_sources_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const metricsInAnalytics = sqliteTable(
+	'metrics',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		sourceId: text('source_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+		ts: integer({ mode: 'timestamp' }).notNull(),
+		value: text().notNull(),
+		tags: text({ mode: 'json' }),
+	},
+	(table) => [
+		index('analytics_metrics_key_ts_idx').on(table.metricKey, table.ts),
+		foreignKey({
+			columns: [table.sourceId],
+			foreignColumns: [metricSourcesInAnalytics.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('metrics_source_id_metric_key_ts_key').on(
+			table.sourceId,
+			table.metricKey,
+			table.ts,
+		),
+	],
+);
+
+export const alertRulesInMonitoring = sqliteTable(
+	'alert_rules',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		name: text().notNull(),
+		description: text(),
+		severity: text().default('medium').notNull(),
+		enabled: integer({ mode: 'boolean' }).default(true).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+
+		uniqueIndex('alert_rules_organization_id_name_key').on(
+			table.organizationId,
+			table.name,
+		),
+	],
+);
+
+export const ruleConditionsInMonitoring = sqliteTable(
+	'rule_conditions',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		metricKey: text('metric_key').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const alertsInMonitoring = sqliteTable(
+	'alerts',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		ruleId: text('rule_id').notNull(),
+		payload: text({ mode: 'json' }),
+		state: text().default('firing').notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.ruleId],
+			foreignColumns: [alertRulesInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const escalationsInMonitoring = sqliteTable(
+	'escalations',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		alertId: text('alert_id').notNull(),
+		target: text().notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.alertId],
+			foreignColumns: [alertsInMonitoring.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const ssoProvidersInCore = sqliteTable(
+	'sso_providers',
+	{
+		id: blob()
+			.$default(() => v4())
+			.primaryKey()
+			.notNull(),
+		organizationId: text('organization_id').notNull(),
+		type: text().notNull(),
+		config: text({ mode: 'json' }).notNull(),
+		enabled: integer({ mode: 'boolean' }).default(false).notNull(),
+	},
+	(table) => [
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organizationsInCore.id],
+		}).onDelete('cascade'),
+	],
+);
+
+export const auditLogsInCore = sqliteTable(
+	'audit_logs',
+	{
+		id: blob({ mode: 'bigint' }).primaryKey().notNull(),
+		organizationId: text('organization_id'),
+		actorId: text('actor_id'),
+		objectType: text('object_type').notNull(),
+		objectId: text('object_id'),
+		action: text().notNull(),
+		beforeState: blob('before_state', { mode: 'json' }),
+		afterState: blob('after_state', { mode: 'buffer' }),
+	},
+	(table) => [
+		index('core_audit_org_idx').on(table.organizationId, table.afterState),
+	],
+);
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema04.ts b/drizzle-kit/tests/sqlite/snapshots/schema04.ts
new file mode 100644
index 0000000000..ff676ac125
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema04.ts
@@ -0,0 +1,42 @@
+// src/db/schema.ts
+import { sql } from 'orm044';
+import { blob, customType, integer, numeric, real, sqliteTable, text, uniqueIndex } from 'orm044/sqlite-core';
+
+export const allIntsNumbers = sqliteTable(
+	'all_ints_number',
+	{
+		column: integer('column', { mode: 'number' }).notNull().generatedAlwaysAs(1),
+		column1: integer('column1', { mode: 'number' }).default(1),
+		column2: integer('column2', { mode: 'number' }).notNull(),
+	},
+);
+
+export const allIntsTimestamps1 = sqliteTable('all_ints_timestamps_1', {
+	columnDateNow: integer('column_date_now_0', { mode: 'timestamp' }).defaultNow(),
+	columnAll: integer('column_date_now', { mode: 'timestamp' }).default(new Date('2023-03-01 12:47:29')),
+	column: integer('column_date_now_1', { mode: 'timestamp' }).default(sql`'2023-02-28 16:18:31'`),
+	column2: integer('column_date_now_2', { mode: 'timestamp' }).default(sql`1766401043893`),
+});
+
+export const allIntsTimestamps2 = sqliteTable('all_ints_timestamps_2', {
+	columnDateNow: integer('column_date_now_0', { mode: 'timestamp_ms' }).defaultNow(),
+	columnAll: integer('column_date_now', { mode: 'timestamp_ms' }).default(new Date('2023-03-01 12:47:29.792')),
+	column: integer('column_date_now_1', { mode: 'timestamp_ms' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: integer('column_date_now_2', { mode: 'timestamp_ms' }).default(sql`1766401043893`),
+});
+
+export const allIntsBoolean = sqliteTable('all_ints_boolean', {
+	column1: integer('column1', { mode: 'boolean' }).default(true),
+	column2: integer('column2', { mode: 'boolean' }).default(false),
+});
+
+export const allBlobs = sqliteTable('all_blobs', {
+	columnText: blob('column_text', { mode: 'bigint' }).notNull(),
+	columnJson: blob('column_all', { mode: 'json' }).notNull().default({ hello: 'world' }),
+	columnBuffer: blob('column_buffer', { mode: 'buffer' }).notNull().default(Buffer.from('hello, world')),
+});
+
+export const allTexts = sqliteTable('all_texts', {
+	columnText: text('column_text', { enum: ['hey'], length: 100 }).notNull().default('hey'),
+	columnJson: text('column_all', { mode: 'json' }).notNull().default({ hello: 'world' }),
+});
diff --git a/drizzle-kit/tests/sqlite/snapshots/schema04new.ts b/drizzle-kit/tests/sqlite/snapshots/schema04new.ts
new file mode 100644
index 0000000000..95f447fd21
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/snapshots/schema04new.ts
@@ -0,0 +1,42 @@
+// src/db/schema.ts
+import { sql } from 'drizzle-orm';
+import { blob, customType, integer, numeric, real, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+
+export const allIntsNumbers = sqliteTable(
+	'all_ints_number',
+	{
+		column: integer('column', { mode: 'number' }).notNull().generatedAlwaysAs(sql`1`),
+		column1: integer('column1', { mode: 'number' }).default(1),
+		column2: integer('column2', { mode: 'number' }).notNull(),
+	},
+);
+
+export const allIntsTimestamps1 = sqliteTable('all_ints_timestamps_1', {
+	columnDateNow: integer('column_date_now_0', { mode: 'timestamp' }).defaultNow(),
+	columnAll: integer('column_date_now', { mode: 'timestamp' }).default(new Date('2023-03-01 12:47:29')),
+	column: integer('column_date_now_1', { mode: 'timestamp' }).default(sql`'2023-02-28 16:18:31'`),
+	column2: integer('column_date_now_2', { mode: 'timestamp' }).default(sql`1766401043893`),
+});
+
+export const allIntsTimestamps2 = sqliteTable('all_ints_timestamps_2', {
+	columnDateNow: integer('column_date_now_0', { mode: 'timestamp_ms' }).defaultNow(),
+	columnAll: integer('column_date_now', { mode: 'timestamp_ms' }).default(new Date('2023-03-01 12:47:29.792')),
+	column: integer('column_date_now_1', { mode: 'timestamp_ms' }).default(sql`'2023-02-28 16:18:31.18'`),
+	column2: integer('column_date_now_2', { mode: 'timestamp_ms' }).default(sql`1766401043893`),
+});
+
+export const allIntsBoolean = sqliteTable('all_ints_boolean', {
+	column1: integer('column1', { mode: 'boolean' }).default(true),
+	column2: integer('column2', { mode: 'boolean' }).default(false),
+});
+
+export const allBlobs = sqliteTable('all_blobs', {
+	columnText: blob('column_text', { mode: 'bigint' }).notNull(),
+	columnJson: blob('column_all', { mode: 'json' }).notNull().default({ hello: 'world' }),
+	columnBuffer: blob('column_buffer', { mode: 'buffer' }).notNull().default(Buffer.from('hello, world')),
+});
+
+export const allTexts = sqliteTable('all_texts', {
+	columnText: text('column_text', { enum: ['hey'], length: 100 }).notNull().default('hey'),
+	columnJson: text('column_all', { mode: 'json' }).notNull().default({ hello: 'world' }),
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-checks.test.ts b/drizzle-kit/tests/sqlite/sqlite-checks.test.ts
new file mode 100644
index 0000000000..aec4592c77
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-checks.test.ts
@@ -0,0 +1,251 @@
+import { sql } from 'drizzle-orm';
+import { check, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4574
+test('create table with check', async (t) => {
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`age` integer,\n'
+		+ '\tCONSTRAINT "some_check_name" CHECK("age" > 21)\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add check contraint to existing table', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`age` integer,\n'
+		+ '\tCONSTRAINT "some_check_name" CHECK("age" > 21)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `age`) SELECT `id`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop check constraint to existing table', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n\t`id` integer PRIMARY KEY,\n\t`age` integer\n);\n',
+		'INSERT INTO `__new_users`(`id`, `age`) SELECT `id`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename check constraint', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('new_some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`age` integer,\n'
+		+ '\tCONSTRAINT "new_some_check_name" CHECK("age" > 21)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `age`) SELECT `id`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('change check constraint value', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 21`)]),
+	};
+
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey(),
+			age: int('age'),
+		}, (table) => [check('some_check_name', sql`${table.age} > 10`)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`age` integer,\n'
+		+ '\tCONSTRAINT "some_check_name" CHECK("age" > 10)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `age`) SELECT `id`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create checks with same names', async (t) => {
+	const to = {
+		users: sqliteTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				age: int('age'),
+				name: text('name'),
+			},
+			(
+				table,
+			) => [check('some_check_name', sql`${table.age} > 21`), check('some_check_name', sql`${table.name} != 'Alex'`)],
+		),
+	};
+
+	const { err2 } = await diff({}, to, []);
+
+	// TODO revise: push does not return any errors. should I use push here?
+	// const {} = await push({ db, to });
+
+	expect(err2).toStrictEqual([{ name: 'some_check_name', type: 'conflict_check' }]);
+});
+
+test('db has checks. Push with same names', async () => {
+	// TODO: revise: it seems to me that this test is the same as one above, but they expect different results
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 21`)]),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => [check('some_check', sql`${table.age} > 22`)]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`name` text,\n'
+		+ '\t`age` integer,\n'
+		+ '\tCONSTRAINT "some_check" CHECK("age" > 22)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`, `age`) SELECT `id`, `name`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-columns.test.ts b/drizzle-kit/tests/sqlite/sqlite-columns.test.ts
new file mode 100644
index 0000000000..ae9a1b7b0c
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-columns.test.ts
@@ -0,0 +1,1792 @@
+import { sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	blob,
+	foreignKey,
+	getTableConfig,
+	index,
+	int,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	text,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create table with id', async (t) => {
+	const schema = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, schema, []);
+
+	const { sqlStatements: pst } = await push({ db, to: schema });
+
+	const st0: string[] = [`CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY AUTOINCREMENT\n);\n`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #1', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [`ALTER TABLE \`users\` ADD \`name\` text NOT NULL;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #2', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `name` text;',
+		'ALTER TABLE `users` ADD `email` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #3', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name1: text('name1').default('name'),
+			name2: text('name2').notNull(),
+			name3: text('name3').default('name').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		"ALTER TABLE `users` ADD `name1` text DEFAULT 'name';",
+		'ALTER TABLE `users` ADD `name2` text NOT NULL;',
+		"ALTER TABLE `users` ADD `name3` text DEFAULT 'name' NOT NULL;",
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #4', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name', { enum: ['one', 'two'] }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE `users` ADD `name` text;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #5', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
+	});
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `report_to` integer REFERENCES users(id);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #6', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email').unique().notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email').unique().notNull(),
+			password: text('password').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE `users` ADD `password` text NOT NULL;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('added column not null and without default to table with data', async (t) => {
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			age: integer('age').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.run(`INSERT INTO \`companies\` ("name") VALUES ('drizzle');`);
+	await db.run(`INSERT INTO \`companies\` ("name") VALUES ('turso');`);
+
+	const { sqlStatements: pst, hints: phints, error } = await push({
+		db,
+		to: schema2,
+		expectError: true,
+		force: true,
+	});
+
+	const st0: string[] = [`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints[0].statement).toStrictEqual('DELETE FROM "companies" where true;');
+	expect(error).toBeNull();
+
+	// TODO: check truncations
+});
+
+test('added column not null and without default to table without data', async (t) => {
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			age: integer('age').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('add generated stored column', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`123`, { mode: 'stored' }),
+		}),
+	};
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS (123) STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`) SELECT `id` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/1313#issuecomment-2753097290
+test('add a generated stored column and rename the existing one', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id1'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`123`, { mode: 'stored' }),
+		}),
+	};
+	const renames = ['users.id->users.id1'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `id` TO `id1`;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id1` integer,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS (123) STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id1`) SELECT `id1` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add generated virtual column', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`123`, { mode: 'virtual' }),
+		}),
+	};
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS (123) VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column make generated', async (t) => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			generatedName: text('gen_name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`123`, { mode: 'stored' }),
+		}),
+	};
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS (123) STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`) SELECT `id` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add columns #6', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email').unique().notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email').unique().notNull(),
+			password: text('password').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE `users` ADD `password` text NOT NULL;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4217
+test('add column with .notNull and .default', async () => {
+	const schema1 = {
+		table1: sqliteTable('table1', {
+			col1: integer(),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	await db.run('insert into `table1` values (1);');
+	const schema2 = {
+		table1: sqliteTable('table1', {
+			col1: integer(),
+			col2: integer({ mode: 'boolean' }).notNull().default(false),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+	const expectedSt2 = [
+		'ALTER TABLE `table1` ADD `col2` integer DEFAULT false NOT NULL;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+	const res = await db.query('select * from `table1`;');
+	expect(res).toStrictEqual([{ col1: 1, col2: 0 }]);
+});
+
+test('drop column', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['ALTER TABLE `users` DROP COLUMN `name`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: integer().primaryKey({ autoIncrement: true }),
+			name: text(),
+			email: text(),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: integer().primaryKey({ autoIncrement: true }),
+			name: text(),
+			email: text('email2'),
+		}),
+	};
+
+	const renames = ['users.email->users.email2'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = ['ALTER TABLE `users` RENAME COLUMN `email` TO `email2`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column and change data type', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: integer('age'),
+		}),
+	};
+
+	const renames = ['users.name->users.age'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `name` TO `age`;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`age` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `age`) SELECT `id`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('add index #1', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
+		}),
+	};
+
+	const users = sqliteTable(
+		'users',
+		{
+			id: int('id').primaryKey({ autoIncrement: true }),
+			reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
+		},
+		(t) => [
+			index('reportee_idx').on(t.reporteeId),
+		],
+	);
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	// await push({ db, to: schema1 });
+	// const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['CREATE INDEX `reportee_idx` ON `users` (`report_to`);'];
+	expect(st).toStrictEqual(st0);
+	// expect(pst).toStrictEqual(st0);
+});
+
+test('dropped, added unique index', async (t) => {
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey().notNull(),
+		name: text('name').notNull(),
+		email: text('email'),
+		textJson: text('text_json', { mode: 'json' }),
+		blobJon: blob('blob_json', { mode: 'json' }),
+		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
+		numeric: numeric('numeric'),
+		createdAt: integer('created_at', { mode: 'timestamp' }),
+		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
+		real: real('real'),
+		text: text('text', { length: 255 }),
+		role: text('role', { enum: ['admin', 'user'] }).default('user'),
+		isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+	});
+
+	const schema1 = {
+		users,
+		customers: sqliteTable('customers', {
+			id: integer('id').primaryKey(),
+			address: text('address').notNull().unique(),
+			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+			registrationDate: integer('registration_date', { mode: 'timestamp_ms' }).notNull().$defaultFn(() => new Date()),
+			userId: integer('user_id').notNull(),
+		}, (table) => [uniqueIndex('customers_address_unique').on(table.address)]),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const schema2 = {
+		users,
+		customers: sqliteTable('customers', {
+			id: integer('id').primaryKey(),
+			address: text('address').notNull(),
+			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+			registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
+				.notNull()
+				.$defaultFn(() => new Date()),
+			userId: integer('user_id').notNull(),
+		}, (table) => [
+			uniqueIndex('customers_is_confirmed_unique').on(
+				table.isConfirmed,
+			),
+		]),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		`DROP INDEX IF EXISTS \`customers_address_unique\`;`,
+		`CREATE UNIQUE INDEX \`customers_is_confirmed_unique\` ON \`customers\` (\`is_confirmed\`);`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('drop autoincrement. drop column with data', async (t) => {
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: false }),
+		}),
+	};
+
+	const table = getTableConfig(schema1.companies);
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.run(
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
+	);
+	await db.run(
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
+	);
+
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_companies` (\n\t`id` integer PRIMARY KEY\n);\n',
+		'INSERT INTO `__new_companies`(`id`) SELECT `id` FROM `companies`;',
+		'DROP TABLE `companies`;',
+		'ALTER TABLE `__new_companies` RENAME TO `companies`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints[0].hint).toStrictEqual("You're about to drop 'name' column(s) in a non-empty 'companies' table");
+});
+
+test('drop autoincrement. drop column with data with pragma off', async (t) => {
+	await db.run('PRAGMA foreign_keys=OFF;');
+
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+	});
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			user_id: integer('user_id').references(() => users.id),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: false }),
+			user_id: integer('user_id').references(() => users.id),
+		}),
+	};
+
+	const table = getTableConfig(schema1.companies);
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.run(
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
+	);
+	await db.run(
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
+	);
+
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_companies` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`user_id` integer,\n'
+		+ '\tCONSTRAINT `fk_companies_user_id_users_id_fk` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`)\n'
+		+ ');\n',
+		'INSERT INTO `__new_companies`(`id`, `user_id`) SELECT `id`, `user_id` FROM `companies`;',
+		'DROP TABLE `companies`;',
+		'ALTER TABLE `__new_companies` RENAME TO `companies`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints[0].hint).toStrictEqual("You're about to drop 'name' column(s) in a non-empty 'companies' table");
+});
+
+test('change autoincrement. other table references current', async (t) => {
+	const companies1 = sqliteTable('companies', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+	});
+	const companies2 = sqliteTable('companies', {
+		id: integer('id').primaryKey({ autoIncrement: false }),
+	});
+
+	const users1 = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').unique(),
+		companyId: text('company_id').references(() => companies1.id),
+	});
+
+	const users2 = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').unique(),
+		companyId: text('company_id').references(() => companies2.id),
+	});
+
+	const schema1 = {
+		companies: companies1,
+		users: users1,
+	};
+
+	const schema2 = {
+		companies: companies2,
+		users: users2,
+	};
+
+	const { name: usersTableName } = getTableConfig(users1);
+	const { name: companiesTableName } = getTableConfig(companies1);
+	const seedStatements = [
+		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('drizzle');`,
+		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('turso');`,
+		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('1');`,
+		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('2');`,
+	];
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	for (const seedSt of seedStatements) {
+		await db.run(seedSt);
+	}
+
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		`PRAGMA foreign_keys=OFF;`,
+		`CREATE TABLE \`__new_companies\` (
+\t\`id\` integer PRIMARY KEY
+);\n`,
+		`INSERT INTO \`__new_companies\`(\`id\`) SELECT \`id\` FROM \`companies\`;`,
+		`DROP TABLE \`companies\`;`,
+		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
+		`PRAGMA foreign_keys=ON;`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('create composite primary key', async (t) => {
+	const schema1 = {};
+
+	const schema2 = {
+		table: sqliteTable('table', {
+			col1: integer('col1').notNull(),
+			col2: integer('col2').notNull(),
+		}, (t) => [primaryKey({
+			columns: [t.col1, t.col2],
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n\t`col1` integer NOT NULL,\n\t`col2` integer NOT NULL,\n\tCONSTRAINT \`table_pk\` PRIMARY KEY(`col1`, `col2`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('add foreign key #1', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			reporteeId: int('report_to'),
+		}),
+	};
+
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		reporteeId: int('report_to').references((): AnySQLiteColumn => users.id),
+	});
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`report_to` integer,\n'
+		+ '\tCONSTRAINT `fk_users_report_to_users_id_fk` FOREIGN KEY (`report_to`) REFERENCES `users`(`id`)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `report_to`) SELECT `id`, `report_to` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add foreign key #2', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			reporteeId: int('report_to'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable(
+			'users',
+			{
+				id: int('id').primaryKey({ autoIncrement: true }),
+				reporteeId: int('report_to'),
+			},
+			(t) => [foreignKey({
+				columns: [t.reporteeId],
+				foreignColumns: [t.id],
+				name: 'reportee_fk',
+			})],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`report_to` integer,\n'
+		+ '\tCONSTRAINT `reportee_fk` FOREIGN KEY (`report_to`) REFERENCES `users`(`id`)\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `report_to`) SELECT `id`, `report_to` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column rename #1', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name1'),
+		}),
+	};
+
+	const renames = ['users.name->users.name1'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = ['ALTER TABLE `users` RENAME COLUMN `name` TO `name1`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column rename #2', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name1'),
+			email: text('email'),
+		}),
+	};
+
+	const renames = ['users.name->users.name1'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `name` TO `name1`;',
+		'ALTER TABLE `users` ADD `email` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column rename #3', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name1'),
+		}),
+	};
+
+	const renames = ['users.name->users.name1'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `name` TO `name1`;',
+		'ALTER TABLE `users` DROP COLUMN `email`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column rename #4', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			email: text('email'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name2'),
+			email: text('email2'),
+		}),
+	};
+
+	const renames = [
+		'users.name->users.name2',
+		'users.email->users.email2',
+	];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `name` TO `name2`;',
+		'ALTER TABLE `users` RENAME COLUMN `email` TO `email2`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename column in composite pk', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int(),
+			id2: int(),
+			name: text('name'),
+		}, (t) => [primaryKey({ columns: [t.id, t.id2] })]),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int(),
+			id3: int(),
+			name: text('name'),
+		}, (t) => [primaryKey({ columns: [t.id, t.id3] })]),
+	};
+
+	const renames = ['users.id2->users.id3'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = ['ALTER TABLE `users` RENAME COLUMN `id2` TO `id3`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column rename + alter type', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: int('name1'),
+		}),
+	};
+
+	const renames = ['users.name->users.name1'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` RENAME COLUMN `name` TO `name1`;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`name1` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name1`) SELECT `id`, `name1` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter table add composite pk', async (t) => {
+	const schema1 = {
+		table: sqliteTable('table', {
+			id1: integer('id1'),
+			id2: integer('id2'),
+		}),
+	};
+
+	const schema2 = {
+		table: sqliteTable(
+			'table',
+			{
+				id1: integer('id1'),
+				id2: integer('id2'),
+			},
+			(t) => [primaryKey({ columns: [t.id1, t.id2] })],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n'
+		+ '\t`id1` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\tCONSTRAINT \`table_pk\` PRIMARY KEY(`id1`, `id2`)\n'
+		+ ');\n',
+		'INSERT INTO `__new_table`(`id1`, `id2`) SELECT `id1`, `id2` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column drop not null', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name').notNull(),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n\t`name` text\n);\n',
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column add not null', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n\t`name` text NOT NULL\n);\n',
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column add default', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name').default('dan'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`name` text DEFAULT 'dan'\n);\n",
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2095
+test('alter column add default #2', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text(),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text().default('dan'),
+			age: integer(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `age` integer;',
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`name` text DEFAULT 'dan',\n\t`age` integer\n);\n",
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column drop default', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name').default('dan'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n\t`name` text\n);\n',
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column add default not null', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name').notNull().default('dan'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`name` text DEFAULT 'dan' NOT NULL\n);\n",
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// I'm not sure if this is the correct test case
+// it is expected to get an error since column cannot be altered to not null when there is existing data that violates this constraint
+test('alter column add default not null to table with data', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull().default('dan'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	await db.run('insert into `table`(`id`) values (1);');
+	await db.run("insert into `table`(`id`,`name`) values (2,'alex');");
+	const { sqlStatements: pst } = await push({ db, to, expectError: true, ignoreSubsequent: true });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`id` integer PRIMARY KEY,\n\t`name` text DEFAULT 'dan' NOT NULL\n);\n",
+		'INSERT INTO `__new_table`(`id`, `name`) SELECT `id`, `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	// const res = await db.query('select * from `table`;');
+	// expect(res).toStrictEqual([
+	// 	{ id: 1, name: 'dan' },
+	// 	{ id: 2, name: 'alex' },
+	// ]);
+});
+
+test('alter column add default not null with indexes', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}, (table) => [index('index_name').on(table.name)]),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name').notNull().default('dan'),
+		}, (table) => [index('index_name').on(table.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`name` text DEFAULT 'dan' NOT NULL\n);\n",
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+		'CREATE INDEX `index_name` ON `table` (`name`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column add default not null with indexes #2', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name').notNull().default('dan'),
+		}, (table) => [index('index_name').on(table.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		"CREATE TABLE `__new_table` (\n\t`name` text DEFAULT 'dan' NOT NULL\n);\n",
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+		'CREATE INDEX `index_name` ON `table` (`name`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column drop default not null', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			name: text('name').notNull().default('dan'),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			name: text('name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n\t`name` text\n);\n',
+		'INSERT INTO `__new_table`(`name`) SELECT `name` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column drop generated', async (t) => {
+	const from = {
+		users: sqliteTable('table', {
+			id: int('id').primaryKey().notNull(),
+			name: text('name').generatedAlwaysAs(sql`'drizzle is the best'`).notNull(),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('table', {
+			id: int('id').primaryKey().notNull(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` DROP COLUMN `name`;',
+		'ALTER TABLE `table` ADD `name` text NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('alter column drop not null, add not null', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name').notNull(),
+		}),
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			userId: int('user_id'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name').notNull(),
+			userId: int('user_id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`name` text\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_posts` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`name` text NOT NULL,\n'
+		+ '\t`user_id` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_posts`(`id`, `name`, `user_id`) SELECT `id`, `name`, `user_id` FROM `posts`;',
+		'DROP TABLE `posts`;',
+		'ALTER TABLE `__new_posts` RENAME TO `posts`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	const hints0: string[] = [];
+	expect(phints).toStrictEqual(hints0);
+});
+
+test('recreate table with nested references', async (t) => {
+	const users1 = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		name: text('name'),
+		age: integer('age'),
+	});
+
+	const subscriptions1 = sqliteTable('subscriptions', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		userId: integer('user_id').references(() => users1.id),
+		customerId: text('customer_id'),
+	});
+
+	const schema1 = {
+		users: users1,
+		subscriptions: subscriptions1,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(() => subscriptions1.id),
+		}),
+	};
+
+	const users2 = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: false }),
+		name: text('name'),
+		age: integer('age'),
+	});
+
+	const subscriptions2 = sqliteTable('subscriptions', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		userId: integer('user_id').references(() => users2.id),
+		customerId: text('customer_id'),
+	});
+
+	const schema2 = {
+		users: users2,
+		subscriptions: subscriptions2,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(() => subscriptions2.id),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		schema1,
+		schema2,
+		[],
+	);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`name` text,\n'
+		+ '\t`age` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`, `age`) SELECT `id`, `name`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('text default values escape single quotes', async (t) => {
+	const schema1 = {
+		table: sqliteTable('table', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const schema2 = {
+		table: sqliteTable('table', {
+			id: integer('id').primaryKey(),
+			text: text('text').default("escape's quotes"),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = ["ALTER TABLE `table` ADD `text` text DEFAULT 'escape''s quotes';"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3979
+test('filter out system tables created by analyze', async () => {
+	await db.run('analyze');
+
+	const schema = {
+		table: sqliteTable('table', {
+			id: integer('id').primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSql1 = ['CREATE TABLE `table` (\n\t`id` integer PRIMARY KEY\n);\n'];
+	expect(pst1).toStrictEqual(expectedSql1);
+});
+
+test('add column with reference', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const some = sqliteTable('some', {
+		id: int().unique(),
+	});
+	const users = sqliteTable(
+		'users',
+		{
+			id: int('id').primaryKey({ autoIncrement: true }),
+			reporteeId: int('report_to').references((): AnySQLiteColumn => users.id, {
+				onDelete: 'cascade',
+				onUpdate: 'restrict',
+			}),
+			reporteeId2: int('report_to2').references((): AnySQLiteColumn => users.id, {
+				onDelete: 'no action',
+				onUpdate: 'no action',
+			}),
+			reporteeId3: int('report_to3'),
+		},
+		(
+			t,
+		) => [
+			foreignKey({ columns: [t.reporteeId3], foreignColumns: [some.id], name: 'test_name' }).onDelete('set default'),
+		],
+	);
+
+	const schema2 = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `report_to` integer REFERENCES users(id) ON UPDATE RESTRICT ON DELETE CASCADE;',
+		'ALTER TABLE `users` ADD `report_to2` integer REFERENCES users(id);',
+		'ALTER TABLE `users` ADD `report_to3` integer CONSTRAINT `test_name` REFERENCES some(id) ON DELETE SET DEFAULT;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5822
+test('issue #5822. Add column - table recreation', async () => {
+	const schemaFrom = {
+		test: sqliteTable('test', {
+			column1: text('column1').notNull(),
+			column2: text('column2'),
+		}),
+	};
+
+	const schemaTo = {
+		test: sqliteTable('test', {
+			column1: text('column1').notNull(),
+			column2: text('column2'),
+			column3: text('column3').notNull().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schemaFrom, schemaTo, []);
+	await push({ db, to: schemaFrom, log: 'statements' });
+	const { sqlStatements: pst } = await push({ db, to: schemaTo, log: 'statements' });
+
+	const st0: string[] = [
+		'ALTER TABLE `test` ADD `column3` text NOT NULL;',
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_test\` (
+\t\`column1\` text NOT NULL,
+\t\`column2\` text,
+\t\`column3\` text NOT NULL UNIQUE
+);\n`,
+		'INSERT INTO \`__new_test\`(\`column1\`, \`column2\`) SELECT \`column1\`, \`column2\` FROM \`test\`;',
+		'DROP TABLE \`test\`;',
+		'ALTER TABLE \`__new_test\` RENAME TO \`test\`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-constraints.test.ts b/drizzle-kit/tests/sqlite/sqlite-constraints.test.ts
new file mode 100644
index 0000000000..1cc24527c9
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-constraints.test.ts
@@ -0,0 +1,2036 @@
+import { desc, isNotNull, isNull, sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	check,
+	foreignKey,
+	index,
+	int,
+	integer,
+	primaryKey,
+	snakeCase,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, drizzleToDDL, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('unique #1. add unique. inline param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4152
+test('unique #2. create table with unique. inline param without name', async () => {
+	const to = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		`CREATE TABLE \`users\` (\n\t\`name\` text UNIQUE\n);\n`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	await db.run(`insert into users values ('name1') on conflict (name) do update set name = 'name2';`);
+});
+
+test('unique #1_0. drop table with unique', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+	const to = {};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = ['DROP TABLE `users`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #1_1. drop column with unique', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int(),
+			name: text().unique(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`id\` integer
+);\n`,
+		'INSERT INTO `__new_users`(`id`) SELECT `id` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #2. no changes unique. inline param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('unique #3. add unique. inline param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text().unique('unique_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text CONSTRAINT \`unique_name\` UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #4. add unique. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text CONSTRAINT \`unique_name\` UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #5. add unique. 3rd param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #6. no changes unique. 3rd param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique().on(t.name)]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('unique #7.no changes unique. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [unique('unique_name').on(t.name, t.name2)]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [unique('unique_name').on(t.name, t.name2)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('unique #8. rename unique. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name').on(t.name)]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [],
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text CONSTRAINT \`unique_name2\` UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique #9. rename unique. 3rd without + with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique().on(t.name)]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [unique('unique_name2').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [],
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text CONSTRAINT \`unique_name2\` UNIQUE
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('unique multistep #1', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = ['CREATE TABLE `users` (\n\t`name` text UNIQUE\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['users->users2', 'users2.name->users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` RENAME COLUMN `name` TO `name2`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3, next: pn3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+	expect(n3.uniques.list()).toStrictEqual([{
+		columns: ['name2'],
+		nameExplicit: false,
+		name: 'users_name_unique',
+		entityType: 'uniques',
+		table: 'users2',
+	}]);
+	expect(pn3.uniques.list()).toStrictEqual([{
+		columns: ['name2'],
+		nameExplicit: false,
+		name: 'users2_name2_unique',
+		entityType: 'uniques',
+		table: 'users2',
+	}]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+
+	expect(st4).toStrictEqual(e3);
+	expect(pst4).toStrictEqual(e3);
+});
+
+test('unique multistep #2', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	const e1 = ['CREATE TABLE `users` (\n\t`name` text UNIQUE\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const r1 = [
+		'users->users2',
+		'users2.name->users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, r1);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames: r1 });
+
+	const e2 = [
+		'ALTER TABLE \`users\` RENAME TO \`users2\`;',
+		'ALTER TABLE \`users2\` RENAME COLUMN \`name\` TO \`name2\`;',
+	];
+	expect(pst2).toStrictEqual(e2);
+	expect(st2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique().on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4, next: pn4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+	expect(n4.uniques.list()).toStrictEqual([{
+		columns: [
+			'name2',
+		],
+		entityType: 'uniques',
+		name: 'users_name_unique',
+		nameExplicit: false,
+		table: 'users2',
+	}]);
+	expect(pn4.uniques.list()).toStrictEqual([{
+		columns: [
+			'name2',
+		],
+		entityType: 'uniques',
+		name: 'users2_name2_unique',
+		nameExplicit: false,
+		table: 'users2',
+	}]);
+});
+
+test('unique multistep #3', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().unique(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`name` text UNIQUE\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`name` text UNIQUE\n);\n',
+	]);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').unique(),
+		}),
+	};
+
+	const renames = ['users->users2', 'users2.name->users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` RENAME COLUMN `name` TO `name2`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}, (t) => [unique('name_unique').on(t.name)]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text CONSTRAINT \`name_unique\` UNIQUE
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	const e5 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st5).toStrictEqual(e5);
+	expect(pst5).toStrictEqual(e5);
+});
+
+test('pk #1. add pk. inline param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text PRIMARY KEY
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #1_0. drop table with pk', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+	const to = {};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'DROP TABLE `users`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4549
+// https://github.com/drizzle-team/drizzle-orm/issues/3801
+test('pk #1_1. add column with pk', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+			id: integer().primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'ALTER TABLE `users` ADD `id` integer;',
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (\n\t\`name\` text,\n\t\`id\` integer PRIMARY KEY AUTOINCREMENT\n);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #1_0. drop column with pk', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int(),
+			name: text().primaryKey(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`id\` integer
+);\n`,
+		'INSERT INTO `__new_users`(`id`) SELECT `id` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #1_2. add pk', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text PRIMARY KEY
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #1_3. add pk', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ name: 'test_pk', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text,
+	CONSTRAINT \`test_pk\` PRIMARY KEY(\`name\`)
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #2. no changes pk. inline param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #3. add pk. inline param with autoincrement', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: int(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: int().primaryKey({ autoIncrement: true, onConflict: 'replace' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` integer PRIMARY KEY AUTOINCREMENT
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #4. add pk. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ name: 'unique_name', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text,
+	CONSTRAINT \`unique_name\` PRIMARY KEY(\`name\`)
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #5. add pk. 3rd param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text PRIMARY KEY
+);\n`,
+		'INSERT INTO `__new_users`(`name`) SELECT `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #6. no changes pk. 3rd param without name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #7.no changes pk. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ name: 'pk_name', columns: [t.name] })]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ name: 'pk_name', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+	});
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('pk #8. rename pk. 3rd param with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ name: 'pk_name', columns: [t.name, t.name2] })]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ name: 'pk_name_new', columns: [t.name, t.name2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [],
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text,
+	\`name2\` text,
+	CONSTRAINT \`pk_name_new\` PRIMARY KEY(\`name\`, \`name2\`)
+);\n`,
+		'INSERT INTO `__new_users`(`name`, `name2`) SELECT `name`, `name2` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk #9. rename pk. 3rd without + with name', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ columns: [t.name, t.name2] })]),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			name: text(),
+			name2: text(),
+		}, (t) => [primaryKey({ name: 'pk_name', columns: [t.name, t.name2] })]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({
+		db,
+		to,
+		renames: [],
+	});
+
+	const st0 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+	\`name\` text,
+	\`name2\` text,
+	CONSTRAINT \`pk_name\` PRIMARY KEY(\`name\`, \`name2\`)
+);\n`,
+		'INSERT INTO `__new_users`(`name`, `name2`) SELECT `name`, `name2` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('pk multistep #1', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = ['CREATE TABLE `users` (\n\t`name` text PRIMARY KEY\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').primaryKey(),
+		}),
+	};
+
+	const renames = ['users->users2', 'users2.name->users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` RENAME COLUMN `name` TO `name2`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3, next: pn3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+	expect(n3.pks.list()).toStrictEqual([{
+		columns: ['name2'],
+		nameExplicit: false,
+		name: 'users_pk',
+		entityType: 'pks',
+		table: 'users2',
+	}]);
+	expect(pn3.pks.list()).toStrictEqual([{
+		columns: ['name2'],
+		nameExplicit: false,
+		name: 'users2_pk',
+		entityType: 'pks',
+		table: 'users2',
+	}]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e3 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+
+	expect(st4).toStrictEqual(e3);
+	expect(pst4).toStrictEqual(e3);
+});
+
+test('pk multistep #2', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+	const e1 = ['CREATE TABLE `users` (\n\t`name` text PRIMARY KEY\n);\n'];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').primaryKey(),
+		}),
+	};
+
+	const r1 = [
+		'users->users2',
+		'users2.name->users2.name2',
+	];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, r1);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames: r1 });
+
+	const e2 = [
+		'ALTER TABLE \`users\` RENAME TO \`users2\`;',
+		'ALTER TABLE \`users2\` RENAME COLUMN \`name\` TO \`name2\`;',
+	];
+	expect(pst2).toStrictEqual(e2);
+	expect(st2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}, (t) => [primaryKey({ columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4, next: pn4 } = await push({ db, to: sch3 });
+	expect(st4).toStrictEqual([]);
+	expect(pst4).toStrictEqual([]);
+	expect(n4.pks.list()).toStrictEqual([{
+		columns: [
+			'name2',
+		],
+		entityType: 'pks',
+		name: 'users_pk',
+		nameExplicit: false,
+		table: 'users2',
+	}]);
+	expect(pn4.pks.list()).toStrictEqual([{
+		columns: [
+			'name2',
+		],
+		entityType: 'pks',
+		name: 'users2_pk',
+		nameExplicit: false,
+		table: 'users2',
+	}]);
+});
+
+test('pk multistep #3', async () => {
+	const sch1 = {
+		users: sqliteTable('users', {
+			name: text().primaryKey(),
+		}),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	expect(st1).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`name` text PRIMARY KEY\n);\n',
+	]);
+	expect(pst1).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`name` text PRIMARY KEY\n);\n',
+	]);
+
+	const sch2 = {
+		users: sqliteTable('users2', {
+			name: text('name2').primaryKey(),
+		}),
+	};
+
+	const renames = ['users->users2', 'users2.name->users2.name2'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` RENAME COLUMN `name` TO `name2`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const sch3 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}, (t) => [primaryKey({ name: 'name_pk', columns: [t.name] })]),
+	};
+
+	const { sqlStatements: st4, next: n4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+
+	const e4 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text,
+	CONSTRAINT \`name_pk\` PRIMARY KEY(\`name2\`)
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+
+	const sch4 = {
+		users: sqliteTable('users2', {
+			name: text('name2'),
+		}),
+	};
+
+	const { sqlStatements: st5 } = await diff(n4, sch4, []);
+	const { sqlStatements: pst5 } = await push({ db, to: sch4 });
+	const e5 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`name2\` text
+);
+`,
+		'INSERT INTO `__new_users2`(`name2`) SELECT `name2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st5).toStrictEqual(e5);
+	expect(pst5).toStrictEqual(e5);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3103
+// https://github.com/drizzle-team/drizzle-orm/issues/3844
+test('composite pk multistep #1', async () => {
+	const organisations = sqliteTable('organisation', {
+		id: int().primaryKey({ autoIncrement: true }),
+	});
+
+	const users = sqliteTable('user', {
+		id: int().primaryKey({ autoIncrement: true }),
+	});
+
+	const organisationUsers = sqliteTable(
+		'organisationUser',
+		{
+			organisationId: int()
+				.notNull()
+				.references(() => organisations.id),
+			userId: int()
+				.notNull()
+				.references(() => users.id),
+			roles: text({ mode: 'json' }).$type<string[]>().default([]),
+		},
+		(t) => [
+			primaryKey({ columns: [t.userId, t.organisationId] }),
+		],
+	);
+
+	const schema1 = { users, organisations, organisationUsers };
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const { sqlStatements: st2 } = await diff(n1, schema1, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema1 });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3844
+// https://github.com/drizzle-team/drizzle-orm/issues/3103
+test('composite pk multistep #2', async () => {
+	const userAsyncTasks = sqliteTable('userAsyncTask', {
+		userId: text('userId').notNull(),
+		identifier: text('identifier').notNull(),
+		type: text('type').notNull(),
+	}, (t) => [
+		primaryKey({ columns: [t.userId, t.type, t.identifier] }),
+	]);
+	const schema = { userAsyncTasks };
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('fk #0', async () => {
+	const users = sqliteTable('users', {
+		id: int().references((): AnySQLiteColumn => users.id2),
+		id2: int(),
+	});
+
+	const to = {
+		users,
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \`users\` (\n\t\`id\` integer,\n\t\`id2\` integer,\n\tCONSTRAINT \`fk_users_id_users_id2_fk\` FOREIGN KEY (\`id\`) REFERENCES \`users\`(\`id2\`)\n);\n`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #1', async () => {
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+	});
+	const posts = sqliteTable('posts', {
+		id: int().primaryKey(),
+		authorId: int().references(() => users.id),
+	});
+
+	const to = {
+		posts,
+		users,
+	};
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \`posts\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`authorId\` integer,\n\tCONSTRAINT \`fk_posts_authorId_users_id_fk\` FOREIGN KEY (\`authorId\`) REFERENCES \`users\`(\`id\`)\n);\n`,
+		`CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY\n);\n`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #2', async () => {
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users.id),
+	});
+
+	const to = { users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`id2\` integer,\n\tCONSTRAINT \`fk_users_id2_users_id_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`users\`(\`id\`)\n);\n`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #3', async () => {
+	const posts = sqliteTable('posts', {
+		id: int(),
+	});
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({
+		name: 'fk_name',
+		columns: [t.id2],
+		foreignColumns: [posts.id],
+	})]);
+
+	const to = { posts, users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \`posts\` (\n\t\`id\` integer\n);\n`,
+		`CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`id2\` integer,\n\tCONSTRAINT \`fk_name\` FOREIGN KEY (\`id2\`) REFERENCES \`posts\`(\`id\`)\n);\n`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #4', async () => {
+	const posts = sqliteTable('posts', {
+		id: int(),
+	});
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({
+		columns: [t.id2],
+		foreignColumns: [posts.id],
+	})]);
+
+	const to = { posts, users };
+
+	const { sqlStatements } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		`CREATE TABLE \`posts\` (\n\t\`id\` integer\n);\n`,
+		`CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`id2\` integer,\n\tCONSTRAINT \`fk_users_id2_posts_id_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`posts\`(\`id\`)\n);\n`,
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #5', async () => {
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users.id),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users2.id),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2', 'users2.id->users2.id3'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE \`users\` RENAME TO \`users2\`;',
+		'ALTER TABLE \`users2\` RENAME COLUMN \`id\` TO \`id3\`;',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #6', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users.id1),
+	});
+
+	const users2 = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({ name: 'id2_id1_fk', columns: [t.id2], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users.users_id2_users_id1_fkey->users.id2_id1_fk'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+\t\`id1\` integer PRIMARY KEY,
+\t\`id2\` integer,
+\tCONSTRAINT \`id2_id1_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`users\`(\`id1\`)
+);\n`,
+		'INSERT INTO \`__new_users\`(\`id1\`, \`id2\`) SELECT \`id1\`, \`id2\` FROM \`users\`;',
+		'DROP TABLE \`users\`;',
+		'ALTER TABLE \`__new_users\` RENAME TO \`users\`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #8', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int().references((): AnySQLiteColumn => users.id1),
+	});
+
+	const users2 = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int().references((): AnySQLiteColumn => users.id2),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const e = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+\t\`id1\` integer PRIMARY KEY,
+\t\`id2\` integer UNIQUE,
+\t\`id3\` integer,
+\tCONSTRAINT \`fk_users_id3_users_id2_fk\` FOREIGN KEY (\`id3\`) REFERENCES \`users\`(\`id2\`)
+);\n`,
+		'INSERT INTO \`__new_users\`(\`id1\`, \`id2\`, \`id3\`) SELECT \`id1\`, \`id2\`, \`id3\` FROM \`users\`;',
+		'DROP TABLE \`users\`;',
+		'ALTER TABLE \`__new_users\` RENAME TO \`users\`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #9', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const users2 = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ name: 'fk1', columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('fk #10', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const users2 = sqliteTable('users', {
+		id1: int().primaryKey(),
+		id2: int().unique(),
+		id3: int(),
+	}, (t) => [foreignKey({ columns: [t.id3], foreignColumns: [t.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const { sqlStatements } = await diff(from, to, []);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	expect(sqlStatements).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+});
+
+test('fk #11', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id1: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users2.id1),
+	});
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` ADD `id2` integer REFERENCES users2(id1);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #12', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id1: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({ columns: [t.id2], foreignColumns: [users.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` ADD `id2` integer REFERENCES users2(id1);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #13', async () => {
+	const users = sqliteTable('users', {
+		id1: int().primaryKey(),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id1: int().primaryKey(),
+		id2: int(),
+	}, (t) => [foreignKey({ name: 'hey_fk', columns: [t.id2], foreignColumns: [users.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'ALTER TABLE `users2` ADD `id2` integer CONSTRAINT \`hey_fk\` REFERENCES users2(id1);',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #14', async () => {
+	const users = sqliteTable('users', {
+		id1: int(),
+		id2: int(),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id1: int(),
+		id2: int(),
+	}, (t) => [foreignKey({ name: 'hey_fk', columns: [t.id2, t.id1], foreignColumns: [users.id1, users.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`id1\` integer,
+	\`id2\` integer,
+	CONSTRAINT \`hey_fk\` FOREIGN KEY (\`id2\`,\`id1\`) REFERENCES \`users2\`(\`id1\`,\`id1\`)
+);\n`,
+		'INSERT INTO `__new_users2`(`id1`, `id2`) SELECT `id1`, `id2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+test('fk #15', async () => {
+	const users = sqliteTable('users', {
+		id1: int(),
+		id2: int(),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id1: int(),
+		id2: int(),
+	}, (t) => [foreignKey({ columns: [t.id2, t.id1], foreignColumns: [users.id1, users.id1] })]);
+
+	const from = { users };
+	const to = { users: users2 };
+
+	const renames = ['users->users2'];
+	const { sqlStatements } = await diff(from, to, renames);
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const e = [
+		'ALTER TABLE `users` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`id1\` integer,
+	\`id2\` integer,
+	CONSTRAINT \`fk_users2_id2_id1_users_id1_id1_fk\` FOREIGN KEY (\`id2\`,\`id1\`) REFERENCES \`users2\`(\`id1\`,\`id1\`)
+);\n`,
+		'INSERT INTO `__new_users2`(`id1`, `id2`) SELECT `id1`, `id2` FROM `users2`;',
+		'DROP TABLE `users2`;',
+		'ALTER TABLE `__new_users2` RENAME TO `users2`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(sqlStatements).toStrictEqual(e);
+	expect(pst).toStrictEqual(e);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3653
+test('fk #16', async () => {
+	const services1 = snakeCase.table('services', {
+		id: integer().primaryKey(),
+	});
+
+	const serviceLinks1 = snakeCase.table('service_links', {
+		id: integer().primaryKey(),
+		serviceId: integer().references(() => services1.id, { onUpdate: 'restrict', onDelete: 'cascade' }),
+	});
+	const schema1 = { services1, serviceLinks1 };
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+
+	const services2 = snakeCase.table('services', {
+		id: integer().primaryKey(),
+	});
+
+	const serviceLinks2 = snakeCase.table('service_links', {
+		id: integer().primaryKey(),
+		clientId: integer().references(() => services2.id, { onUpdate: 'restrict', onDelete: 'cascade' }),
+	});
+	const schema2 = { services2, serviceLinks2 };
+
+	const renames = ['service_links.service_id->service_links.client_id'];
+	const { sqlStatements: st2 } = await diff(n1, schema2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2, renames });
+
+	const expectedSt2 = [
+		'ALTER TABLE `service_links` RENAME COLUMN `service_id` TO `client_id`;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+test('fk multistep #1', async () => {
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users.id),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`id2\` integer,' + '\n'
+		+ '\tCONSTRAINT \`fk_users_id2_users_id_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`users\`(\`id\`)\n);\n',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const renames = ['users->users2', 'users2.id->users2.id3'];
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, renames);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2, renames });
+
+	const e2 = [
+		'ALTER TABLE \`users\` RENAME TO \`users2\`;',
+		'ALTER TABLE \`users2\` RENAME COLUMN \`id\` TO \`id3\`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3, next: n3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+
+	const users3 = sqliteTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int(),
+	});
+	const sch3 = { users: users3 };
+
+	const { sqlStatements: st4 } = await diff(n3, sch3, []);
+	const { sqlStatements: pst4 } = await push({ db, to: sch3 });
+	const e4 = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users2\` (
+	\`id3\` integer PRIMARY KEY,
+	\`id2\` integer
+);\n`,
+		'INSERT INTO \`__new_users2\`(\`id3\`, \`id2\`) SELECT \`id3\`, \`id2\` FROM \`users2\`;',
+		'DROP TABLE \`users2\`;',
+		'ALTER TABLE \`__new_users2\` RENAME TO \`users2\`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st4).toStrictEqual(e4);
+	expect(pst4).toStrictEqual(e4);
+});
+
+test('fk multistep #2', async () => {
+	const users = sqliteTable('users', {
+		id: int().primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users.id),
+	});
+
+	const users2 = sqliteTable('users2', {
+		id: int('id3').primaryKey(),
+		id2: int().references((): AnySQLiteColumn => users2.id),
+	});
+
+	const sch1 = { users };
+	const sch2 = { users: users2 };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, sch1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: sch1 });
+
+	const e1 = [
+		'CREATE TABLE \`users\` (\n\t\`id\` integer PRIMARY KEY,\n\t\`id2\` integer,'
+		+ '\n\tCONSTRAINT \`fk_users_id2_users_id_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`users\`(\`id\`)\n);\n',
+	];
+	expect(st1).toStrictEqual(e1);
+	expect(pst1).toStrictEqual(e1);
+
+	const { sqlStatements: st2, next: n2 } = await diff(n1, sch2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: sch2 });
+
+	const e2 = [
+		'CREATE TABLE \`users2\` (\n\t\`id3\` integer PRIMARY KEY,\n\t\`id2\` integer,'
+		+ '\n\tCONSTRAINT \`fk_users2_id2_users2_id3_fk\` FOREIGN KEY (\`id2\`) REFERENCES \`users2\`(\`id3\`)\n);\n',
+		'DROP TABLE \`users\`;',
+	];
+	expect(st2).toStrictEqual(e2);
+	expect(pst2).toStrictEqual(e2);
+
+	const { sqlStatements: st3 } = await diff(n2, sch2, []);
+	const { sqlStatements: pst3 } = await push({ db, to: sch2 });
+
+	expect(st3).toStrictEqual([]);
+	expect(pst3).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3255
+test('index #1', async () => {
+	const table1 = sqliteTable('table1', {
+		col1: integer(),
+		col2: integer(),
+	}, (t) => [
+		uniqueIndex('index1').on(t.col1),
+		uniqueIndex('index2').on(t.col1, t.col2),
+		index('index3').on(t.col1),
+		index('index4').on(t.col1, t.col2),
+		index('index5').on(sql`${t.col1} asc`),
+		index('index6').on(sql`${t.col1} asc`, sql`${t.col2} desc`),
+		uniqueIndex('index7').on(t.col1).where(isNotNull(t.col1)),
+		index('index8').on(t.col1).where(isNotNull(t.col1)),
+	]);
+
+	const schema1 = { table1 };
+
+	const { sqlStatements: st1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n'
+		+ '\t`col1` integer,\n'
+		+ '\t`col2` integer\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX `index1` ON `table1` (`col1`);',
+		'CREATE UNIQUE INDEX `index2` ON `table1` (`col1`,`col2`);',
+		'CREATE INDEX `index3` ON `table1` (`col1`);',
+		'CREATE INDEX `index4` ON `table1` (`col1`,`col2`);',
+		'CREATE INDEX `index5` ON `table1` ("col1" asc);',
+		'CREATE INDEX `index6` ON `table1` ("col1" asc,"col2" desc);',
+		'CREATE UNIQUE INDEX `index7` ON `table1` (`col1`) WHERE ("table1"."col1" is not null);',
+		'CREATE INDEX `index8` ON `table1` (`col1`) WHERE ("table1"."col1" is not null);',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+test('issue 4574', async () => {
+	const demo_with_check = sqliteTable(
+		'demo_with_check',
+		{
+			id: integer().primaryKey({ autoIncrement: true }),
+			test: integer(),
+		},
+		(table) => [check('test_positive', sql`0 < ${table.test}`)],
+	);
+
+	const demo_without_check = sqliteTable('demo_without_check', {
+		id: integer().primaryKey({ autoIncrement: true }),
+		unique: text().unique().notNull(),
+	});
+
+	const schema1 = { demo_with_check, demo_without_check };
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+
+	const expectedSt1 = [
+		`CREATE TABLE \`demo_with_check\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT,
+\t\`test\` integer,
+\tCONSTRAINT \"test_positive\" CHECK(0 < \"test\")
+);\n`,
+		`CREATE TABLE \`demo_without_check\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT,
+\t\`unique\` text NOT NULL UNIQUE
+);\n`,
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4704
+test('issue No4704. Composite index with sort outputs', async () => {
+	const schema1 = {
+		table: sqliteTable(
+			'table',
+			{ col1: text(), col2: text(), col3: text() },
+			(table) => [
+				index('table_composite_idx').on(
+					table.col1,
+					table.col2,
+					desc(table.col3), // Attempting to sort by col3 DESC
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 });
+	const expectedSt1 = [
+		'CREATE TABLE `table` (\n\t`col1` text,\n\t`col2` text,\n\t`col3` text\n);\n',
+		'CREATE INDEX `table_composite_idx` ON `table` (`col1`,`col2`,"col3" desc);', // drizzle-orm parses as "". Should work, but still...
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4688
+test('issue No4688. subsequent push with where part of partial index', async () => {
+	const schema1 = {
+		table: sqliteTable(
+			'table',
+			{
+				id: int().primaryKey(),
+				type: text(),
+				isDeleted: int({ mode: 'boolean' }),
+			},
+			(table) => [
+				index('table_composite_idx').on(table.id, table.type).where(isNull(table.isDeleted)),
+			],
+		),
+	};
+
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema1, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema1 }); // subsequent push inside
+	const expectedSt1 = [
+		'CREATE TABLE `table` (\n\t`id` integer PRIMARY KEY,\n\t`type` text,\n\t`isDeleted` integer\n);\n',
+		'CREATE INDEX `table_composite_idx` ON `table` (`id`,`type`) WHERE ("table"."isDeleted" is null);', // drizzle-orm parses as "". Should work, but still...
+	];
+
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-defaults.test.ts b/drizzle-kit/tests/sqlite/sqlite-defaults.test.ts
new file mode 100644
index 0000000000..72349ae095
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-defaults.test.ts
@@ -0,0 +1,185 @@
+import { sql } from 'drizzle-orm';
+import { blob, int, integer, numeric, real, text } from 'drizzle-orm/sqlite-core';
+import { DB } from 'src/utils';
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { diffDefault, prepareTestDatabase, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+
+let _: TestDatabase;
+let db: DB;
+
+beforeAll(async () => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/2085
+// https://github.com/drizzle-team/drizzle-orm/issues/1406
+// https://github.com/drizzle-team/drizzle-orm/issues/4217
+test('integer', async () => {
+	const res1 = await diffDefault(_, integer({ mode: 'number' }).default(10), '10');
+	const res2 = await diffDefault(_, integer({ mode: 'number' }).default(0), '0');
+	const res3 = await diffDefault(_, integer({ mode: 'number' }).default(-10), '-10');
+	const res4 = await diffDefault(_, integer({ mode: 'number' }).default(1e4), '10000');
+	const res5 = await diffDefault(_, integer({ mode: 'number' }).default(-1e4), '-10000');
+
+	const res6 = await diffDefault(_, integer({ mode: 'boolean' }).default(true), 'true');
+	const res7 = await diffDefault(_, integer({ mode: 'boolean' }).default(false), 'false');
+	const res71 = await diffDefault(_, int({ mode: 'boolean' }).default(false), 'false');
+
+	const date = new Date('2025-05-23T12:53:53.115Z');
+	const res8 = await diffDefault(_, integer({ mode: 'timestamp' }).default(date), `1748004833`);
+	const res9 = await diffDefault(_, integer({ mode: 'timestamp_ms' }).default(date), `${date.getTime()}`);
+	// this test will fail in ci/cd due to different timezones
+	// const res10 = await diffDefault(_, integer({ mode: 'timestamp_ms' }).default(new Date(2000, 1, 1)), `949356000000`);
+
+	// const res11 = await diffDefault(
+	// 	_,
+	// 	integer({ mode: 'timestamp_ms' }).defaultNow(),
+	// 	`(cast((julianday('now') - 2440587.5)*86400000 as integer))`,
+	// );
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res71).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	// expect.soft(res10).toStrictEqual([]);
+});
+
+test('text', async () => {
+	const res1 = await diffDefault(_, text().default('text'), `'text'`);
+	const res2 = await diffDefault(_, text().default("text'text"), `'text''text'`);
+	// raw default sql for the line below: ('text''\text"')
+	const res3 = await diffDefault(_, text().default('text\'\\text"'), `'text''\\\\text"'`);
+	const res4 = await diffDefault(_, text({ enum: ['one', 'two', 'three'] }).default('one'), `'one'`);
+	const res5 = await diffDefault(_, text().default(sql`CURRENT_TIME`), 'CURRENT_TIME');
+	const res6 = await diffDefault(_, text().default(sql`CURRENT_DATE`), 'CURRENT_DATE');
+	const res7 = await diffDefault(_, text().default(sql`CURRENT_TIMESTAMP`), 'CURRENT_TIMESTAMP');
+	const res8 = await diffDefault(_, text({ mode: 'json' }).default({ key: 'value' }), `'{"key":"value"}'`);
+	const res9 = await diffDefault(
+		_,
+		text({ mode: 'json' }).default({ key: 9223372036854775807n }),
+		`'{"key":9223372036854775807}'`,
+	);
+	const res10 = await diffDefault(
+		_,
+		text({ mode: 'json' }).default(sql`'{"key":9223372036854775807}'`),
+		`'{"key":9223372036854775807}'`,
+	);
+	const res11 = await diffDefault(
+		_,
+		text({ mode: 'json' }).default([9223372036854775807n, 9223372036854775806n]),
+		`'[9223372036854775807,9223372036854775806]'`,
+	);
+	const res12 = await diffDefault(
+		_,
+		text({ mode: 'json' }).default({ key: 'value\\\'"' }),
+		`'{"key":"value\\\\''\\""}'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+});
+
+test('real', async () => {
+	const res1 = await diffDefault(_, real().default(1000.123), '1000.123');
+	expect.soft(res1).toStrictEqual([]);
+});
+
+test('numeric', async () => {
+	const res1 = await diffDefault(_, numeric().default('10.123'), "'10.123'");
+	const res2 = await diffDefault(_, numeric({ mode: 'bigint' }).default(9223372036854775807n), "'9223372036854775807'");
+	const res3 = await diffDefault(_, numeric({ mode: 'number' }).default(9007199254740991), '9007199254740991');
+	const res4 = await diffDefault(
+		_,
+		numeric({ mode: 'string' }).default('9223372036854775807'),
+		"'9223372036854775807'",
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+});
+
+test('blob', async () => {
+	const res1 = await diffDefault(_, blob({ mode: 'buffer' }).default(Buffer.from('text')), `X'74657874'`);
+	const res2 = await diffDefault(
+		_,
+		blob({ mode: 'buffer' }).default(Buffer.from("text'text")),
+		`X'746578742774657874'`,
+	);
+	// raw default sql for the line below: ('text''\text"')
+	const res3 = await diffDefault(
+		_,
+		blob({ mode: 'buffer' }).default(Buffer.from('text\'\\text"')),
+		`X'74657874275C7465787422'`,
+	);
+
+	const res4 = await diffDefault(_, blob({ mode: 'bigint' }).default(9223372036854775807n), "'9223372036854775807'");
+
+	const res5 = await diffDefault(_, blob({ mode: 'json' }).default(9223372036854775807n), "'9223372036854775807'");
+	const res6 = await diffDefault(_, blob({ mode: 'json' }).default({}), `'{}'`);
+	const res7 = await diffDefault(_, blob({ mode: 'json' }).default([]), `'[]'`);
+	const res8 = await diffDefault(_, blob({ mode: 'json' }).default([1, 2, 3]), `'[1,2,3]'`);
+	const res9 = await diffDefault(_, blob({ mode: 'json' }).default({ key: 'value' }), `'{"key":"value"}'`);
+	// raw default sql for the line below: '{"key":"val'\ue"}'
+	const res10 = await diffDefault(_, blob({ mode: 'json' }).default({ key: "val'\\ue" }), `'{"key":"val''\\\\ue"}'`);
+
+	const res11 = await diffDefault(
+		_,
+		blob({ mode: 'json' }).default({ key: 9223372036854775807n }),
+		`'{"key":9223372036854775807}'`,
+	);
+	const res12 = await diffDefault(
+		_,
+		blob({ mode: 'json' }).default(sql`'{"key":9223372036854775807}'`),
+		`'{"key":9223372036854775807}'`,
+	);
+	const res13 = await diffDefault(
+		_,
+		blob({ mode: 'json' }).default([9223372036854775807n, 9223372036854775806n]),
+		`'[9223372036854775807,9223372036854775806]'`,
+	);
+	const res14 = await diffDefault(
+		_,
+		blob({ mode: 'json' }).default({ key: 'value\\\'"' }),
+		`'{"key":"value\\\\''\\""}'`,
+	);
+
+	expect.soft(res1).toStrictEqual([]);
+	expect.soft(res2).toStrictEqual([]);
+	expect.soft(res3).toStrictEqual([]);
+	expect.soft(res4).toStrictEqual([]);
+	expect.soft(res5).toStrictEqual([]);
+	expect.soft(res6).toStrictEqual([]);
+	expect.soft(res7).toStrictEqual([]);
+	expect.soft(res8).toStrictEqual([]);
+	expect.soft(res9).toStrictEqual([]);
+	expect.soft(res10).toStrictEqual([]);
+	expect.soft(res11).toStrictEqual([]);
+	expect.soft(res12).toStrictEqual([]);
+	expect.soft(res13).toStrictEqual([]);
+	expect.soft(res14).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-generated.test.ts b/drizzle-kit/tests/sqlite/sqlite-generated.test.ts
new file mode 100644
index 0000000000..e7e88adf70
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-generated.test.ts
@@ -0,0 +1,1518 @@
+import { SQL, sql } from 'drizzle-orm';
+import { int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// 1. add stored column to existing table - not supported +
+// 2. add virtual column to existing table - supported +
+// 3. create table with stored/virtual columns(pg, mysql, sqlite)
+// 4. add stored generated to column -> not supported +
+// 5. add virtual generated to column -> supported with drop+add column +
+// 6. drop stored/virtual expression -> supported with drop+add column
+// 7. alter generated expession -> stored not supported, virtual supported
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+// should generate 0 statements + warning/error in console
+test('generated as callback: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') STORED NOT NULL\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') VIRTUAL NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// no way to do it
+test('generated as callback: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// not supported
+test('generated as callback: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as callback: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// ---
+
+test('generated as sql: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || \'hello\' || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ "\t`gen_name` text GENERATED ALWAYS AS (\"name\" || 'hello' || 'hello') STORED\n"
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || \'hello\'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"name" || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') STORED NOT NULL\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"name" || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') VIRTUAL NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// no way to do it
+test('generated as sql: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// not supported
+test('generated as sql: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as sql: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5241
+test('generated as sql: change column with virtual generated constraint on another column', async () => {
+	const schema1 = {
+		table: sqliteTable('test_table', {
+			id: text().primaryKey(),
+			likes: integer('likes').notNull().default(0),
+			dislikes: integer('dislikes').notNull().default(0),
+			votes: integer('votes').generatedAlwaysAs(sql`likes + dislikes`),
+			count: integer('count').notNull(),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema1, []);
+	await push({ db, to: schema1 });
+	await db.run("insert into `test_table`(`id`,`count`) values('a',1);");
+
+	const schema2 = {
+		table: sqliteTable('test_table', {
+			id: text().primaryKey(),
+			likes: integer('likes').notNull().default(0),
+			dislikes: integer('dislikes').notNull().default(0),
+			votes: integer('votes').generatedAlwaysAs(sql`likes + dislikes`),
+			count: integer('count'),
+		}),
+	};
+
+	const { sqlStatements: st2 } = await diff(n1, schema2, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema2 });
+
+	const expectedSt2: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_test_table` (\n'
+		+ '\t`id` text PRIMARY KEY,\n'
+		+ '\t`likes` integer DEFAULT 0 NOT NULL,\n'
+		+ '\t`dislikes` integer DEFAULT 0 NOT NULL,\n'
+		+ '\t`votes` integer GENERATED ALWAYS AS (likes + dislikes) VIRTUAL,\n'
+		+ '\t`count` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_test_table`(`id`, `likes`, `dislikes`, `count`) SELECT `id`, `likes`, `dislikes`, `count` FROM `test_table`;',
+		'DROP TABLE `test_table`;',
+		'ALTER TABLE `__new_test_table` RENAME TO `test_table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// ---
+
+test('generated as string: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || \'hello\'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || \'hello\'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"name" || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') STORED NOT NULL\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"name" || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') VIRTUAL NOT NULL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// no way to do it
+test('generated as string: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `id2`, `name`) SELECT `id`, `id2`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+// not supported
+test('generated as string: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer,\n'
+		+ '\t`name` text,\n'
+		+ '\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`) SELECT `id`, `name` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"name"`),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('generated as string: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(
+		from,
+		to,
+		[],
+	);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-tables.test.ts b/drizzle-kit/tests/sqlite/sqlite-tables.test.ts
new file mode 100644
index 0000000000..380313f380
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-tables.test.ts
@@ -0,0 +1,1100 @@
+import { sql } from 'drizzle-orm';
+import {
+	AnySQLiteColumn,
+	blob,
+	camelCase,
+	customType,
+	foreignKey,
+	index,
+	int,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	snakeCase,
+	sqliteTable,
+	text,
+	unique,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+fs.mkdirSync('./tests/sqlite/migrations', { recursive: true });
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+let client: ReturnType<TestDatabase['getClient']>;
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+	client = _.getClient();
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+	client = _.getClient();
+});
+
+test('add table #1', async () => {
+	const to = {
+		users: sqliteTable('users', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE TABLE `users` (\n\t`id` integer\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #2', async () => {
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #3', async () => {
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+		}, (t) => [primaryKey({
+			name: 'users_pk',
+			columns: [t.id],
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer,\n\tCONSTRAINT \`users_pk\` PRIMARY KEY(\`id\`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #4', async () => {
+	const to = {
+		users: sqliteTable('users', { id: int() }),
+		posts: sqliteTable('posts', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer\n);\n',
+		'CREATE TABLE `posts` (\n\t`id` integer\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #5', async () => {
+	const to = {
+		users: sqliteTable('users', {
+			id1: integer(),
+			id2: integer(),
+		}, (t) => [
+			primaryKey({ columns: [t.id1, t.id2] }),
+		]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n'
+		+ '\t`id1` integer,\n'
+		+ '\t`id2` integer,\n'
+		+ '\tCONSTRAINT \`users_pk\` PRIMARY KEY(`id1`, `id2`)\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #6', async () => {
+	const from = {
+		users1: sqliteTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users2: sqliteTable('users2', { id: int() }),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE TABLE `users2` (\n\t`id` integer\n);\n', 'DROP TABLE `users1`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #7', async () => {
+	const from = {
+		users1: sqliteTable('users1', { id: int() }),
+	};
+
+	const to = {
+		users: sqliteTable('users', { id: int() }),
+		users2: sqliteTable('users2', { id: int() }),
+	};
+
+	const renames = ['users1->users2'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['CREATE TABLE `users` (\n\t`id` integer\n);\n', 'ALTER TABLE `users1` RENAME TO `users2`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #8', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		reporteeId: int('reportee_id').references((): AnySQLiteColumn => users.id),
+	});
+
+	const to = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`reportee_id` integer,\n'
+		+ '\tCONSTRAINT `fk_users_reportee_id_users_id_fk` FOREIGN KEY (`reportee_id`) REFERENCES `users`(`id`)\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #9', async () => {
+	const to = {
+		users: sqliteTable(
+			'users',
+			{
+				id: int('id').primaryKey({ autoIncrement: true }),
+				reporteeId: int('reportee_id'),
+			},
+			(t) => [index('reportee_idx').on(t.reporteeId)],
+		),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`reportee_id` integer\n'
+		+ ');\n',
+		'CREATE INDEX `reportee_idx` ON `users` (`reportee_id`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #10', async () => {
+	const to = {
+		users: sqliteTable('table', {
+			json: text('json', { mode: 'json' }).default({}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ["CREATE TABLE `table` (\n\t`json` text DEFAULT '{}'\n);\n"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #11', async () => {
+	const to = {
+		users: sqliteTable('table', {
+			json: text('json', { mode: 'json' }).default([]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ["CREATE TABLE `table` (\n\t`json` text DEFAULT '[]'\n);\n"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #12', async () => {
+	const to = {
+		users: sqliteTable('table', {
+			json: text('json', { mode: 'json' }).default([1, 2, 3]),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ["CREATE TABLE `table` (\n\t`json` text DEFAULT '[1,2,3]'\n);\n"];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #13', async () => {
+	const to = {
+		users: sqliteTable('table', {
+			json: text('json', { mode: 'json' }).default({ key: 'value' }),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE TABLE `table` (\n\t`json` text DEFAULT \'{"key":"value"}\'\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table #14', async () => {
+	const to = {
+		users: sqliteTable('table', {
+			json: text('json', { mode: 'json' }).default({
+				key: 'value',
+				arr: [1, 2, 3],
+			}),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE TABLE `table` (\n\t`json` text DEFAULT \'{"key":"value","arr":[1,2,3]}\'\n);\n'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table #1', async () => {
+	const from = {
+		users: sqliteTable('table', {
+			id: integer(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('table1', {
+			id: integer(),
+		}),
+	};
+
+	const renames = ['table->table1'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['ALTER TABLE `table` RENAME TO `table1`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table #2', async () => {
+	const profiles = sqliteTable('profiles', {
+		id: integer().primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		profiles,
+		users: sqliteTable(
+			'table',
+			{
+				id: integer().primaryKey({ autoIncrement: true }),
+				profileId: integer(),
+			},
+			(t) => [foreignKey({
+				name: 'table_profileId',
+				columns: [t.id],
+				foreignColumns: [profiles.id],
+			})],
+		),
+	};
+
+	const to = {
+		profiles,
+		users: sqliteTable(
+			'table1',
+			{
+				id: integer().primaryKey({ autoIncrement: true }),
+				profileId: integer(),
+			},
+			(t) => [foreignKey({
+				name: 'table_profileId',
+				columns: [t.id],
+				foreignColumns: [profiles.id],
+			})],
+		),
+	};
+
+	const renames = ['table->table1'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['ALTER TABLE `table` RENAME TO `table1`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename table #3', async () => {
+	const profiles = sqliteTable('profiles', {
+		id: integer().primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		profiles,
+		users: sqliteTable('table', {
+			id: integer().primaryKey({ autoIncrement: true }),
+			profileId: integer().references(() => profiles.id),
+		}),
+	};
+
+	const to = {
+		profiles,
+		users: sqliteTable('table1', {
+			id: integer().primaryKey({ autoIncrement: true }),
+			profileId: integer().references(() => profiles.id),
+		}),
+	};
+
+	const renames = ['table->table1'];
+	const { sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = ['ALTER TABLE `table` RENAME TO `table1`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add table with indexes', async () => {
+	const from = {};
+
+	const to = {
+		users: sqliteTable(
+			'users',
+			{
+				id: int('id').primaryKey(),
+				name: text('name'),
+				email: text('email'),
+			},
+			(t) => [
+				uniqueIndex('uniqueExpr').on(sql`(lower(${t.email}))`),
+				index('indexExpr').on(sql`(lower(${t.email}))`),
+				index('indexExprMultiple').on(
+					sql`(lower(${t.email}))`,
+					sql`(lower(${t.email}))`,
+				),
+
+				uniqueIndex('uniqueCol').on(t.email),
+				index('indexCol').on(t.email),
+				index('indexColMultiple').on(t.email, t.email),
+
+				index('indexColExpr').on(
+					sql`(lower(${t.email}))`,
+					t.email,
+				),
+			],
+		),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `users` (\n\t`id` integer PRIMARY KEY,\n\t`name` text,\n\t`email` text\n);\n',
+		'CREATE UNIQUE INDEX `uniqueExpr` ON `users` ((lower("email")));',
+		'CREATE INDEX `indexExpr` ON `users` ((lower("email")));',
+		'CREATE INDEX `indexExprMultiple` ON `users` ((lower("email")),(lower("email")));',
+		'CREATE UNIQUE INDEX `uniqueCol` ON `users` (`email`);',
+		'CREATE INDEX `indexCol` ON `users` (`email`);',
+		'CREATE INDEX `indexColMultiple` ON `users` (`email`,`email`);',
+		'CREATE INDEX `indexColExpr` ON `users` ((lower("email")),`email`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('composite primary key', async () => {
+	const from = {};
+	const to = {
+		table: sqliteTable('works_to_creators', {
+			workId: int('work_id').notNull(),
+			creatorId: int('creator_id').notNull(),
+			classification: text('classification').notNull(),
+		}, (t) => [primaryKey({
+			columns: [t.workId, t.creatorId, t.classification],
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `works_to_creators` (\n\t`work_id` integer NOT NULL,\n\t`creator_id` integer NOT NULL,\n\t`classification` text NOT NULL,\n\tCONSTRAINT \`works_to_creators_pk\` PRIMARY KEY(`work_id`, `creator_id`, `classification`)\n);\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('add column before creating unique constraint', async () => {
+	const from = {
+		table: sqliteTable('table', {
+			id: int('id').primaryKey(),
+		}),
+	};
+	const to = {
+		table: sqliteTable('table', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		}, (t) => [unique('uq').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'ALTER TABLE `table` ADD `name` text NOT NULL;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_table` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`name` text NOT NULL CONSTRAINT \`uq\` UNIQUE\n'
+		+ ');\n',
+		'INSERT INTO `__new_table`(`id`) SELECT `id` FROM `table`;',
+		'DROP TABLE `table`;',
+		'ALTER TABLE `__new_table` RENAME TO `table`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create table with unique in third param and in column config', async () => {
+	const to = {
+		table: sqliteTable('table', {
+			id: int('id').unique(),
+			name: text('name').notNull(),
+		}, (t) => [unique('uq').on(t.name)]),
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `table` (\n'
+		+ '\t`id` integer UNIQUE,\n'
+		+ '\t`name` text NOT NULL CONSTRAINT \`uq\` UNIQUE\n'
+		+ ');\n',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('optional db aliases (snake case)', async () => {
+	const from = {};
+
+	const t1 = snakeCase.table(
+		't1',
+		{
+			t1Id1: int().notNull().primaryKey(),
+			t1Col2: int().notNull(),
+			t1Col3: int().notNull(),
+			t2Ref: int().notNull().references(() => t2.t2Id),
+			t1Uni: int().notNull(),
+			t1UniIdx: int().notNull(),
+			t1Idx: int().notNull(),
+		},
+		(table) => [
+			unique('t1_uni').on(table.t1Uni),
+			uniqueIndex('t1_uni_idx').on(table.t1UniIdx),
+			index('t1_idx').on(table.t1Idx),
+			foreignKey({
+				columns: [table.t1Col2, table.t1Col3],
+				foreignColumns: [t3.t3Id1, t3.t3Id2],
+			}),
+		],
+	);
+
+	const t2 = snakeCase.table(
+		't2',
+		{
+			t2Id: int().primaryKey({ autoIncrement: true }),
+		},
+	);
+
+	const t3 = snakeCase.table(
+		't3',
+		{
+			t3Id1: int(),
+			t3Id2: int(),
+		},
+		(table) => [primaryKey({
+			columns: [table.t3Id1, table.t3Id2],
+		})],
+	);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `t1` (\n'
+		+ '\t`t1_id1` integer PRIMARY KEY,\n'
+		+ '\t`t1_col2` integer NOT NULL,\n'
+		+ '\t`t1_col3` integer NOT NULL,\n'
+		+ '\t`t2_ref` integer NOT NULL,\n'
+		+ '\t`t1_uni` integer NOT NULL CONSTRAINT \`t1_uni\` UNIQUE,\n'
+		+ '\t`t1_uni_idx` integer NOT NULL,\n'
+		+ '\t`t1_idx` integer NOT NULL,\n'
+		+ '\tCONSTRAINT `fk_t1_t2_ref_t2_t2_id_fk` FOREIGN KEY (`t2_ref`) REFERENCES `t2`(`t2_id`),\n'
+		+ '\tCONSTRAINT `fk_t1_t1_col2_t1_col3_t3_t3_id1_t3_id2_fk` FOREIGN KEY (`t1_col2`,`t1_col3`) REFERENCES `t3`(`t3_id1`,`t3_id2`)\n'
+		+ ');\n',
+		'CREATE TABLE `t2` (\n\t`t2_id` integer PRIMARY KEY AUTOINCREMENT\n);\n',
+		'CREATE TABLE `t3` (\n'
+		+ '\t`t3_id1` integer,\n'
+		+ '\t`t3_id2` integer,\n'
+		+ '\tCONSTRAINT \`t3_pk\` PRIMARY KEY(`t3_id1`, `t3_id2`)\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX `t1_uni_idx` ON `t1` (`t1_uni_idx`);',
+		'CREATE INDEX `t1_idx` ON `t1` (`t1_idx`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('optional db aliases (camel case)', async () => {
+	const from = {};
+
+	const t1 = camelCase.table(
+		't1',
+		{
+			t1_id1: int().notNull().primaryKey(),
+			t1_col2: int().notNull(),
+			t1_col3: int().notNull(),
+			t2_ref: int().notNull().references(() => t2.t2_id),
+			t1_uni: int().notNull(),
+			t1_uni_idx: int().notNull(),
+			t1_idx: int().notNull(),
+		},
+		(table) => [
+			unique('t1Uni').on(table.t1_uni),
+			uniqueIndex('t1UniIdx').on(table.t1_uni_idx),
+			index('t1Idx').on(table.t1_idx),
+			foreignKey({
+				columns: [table.t1_col2, table.t1_col3],
+				foreignColumns: [t3.t3_id1, t3.t3_id2],
+			}),
+		],
+	);
+
+	const t2 = camelCase.table(
+		't2',
+		{
+			t2_id: int().primaryKey({ autoIncrement: true }),
+		},
+	);
+
+	const t3 = camelCase.table(
+		't3',
+		{
+			t3_id1: int(),
+			t3_id2: int(),
+		},
+		(table) => [primaryKey({
+			columns: [table.t3_id1, table.t3_id2],
+		})],
+	);
+
+	const to = {
+		t1,
+		t2,
+		t3,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'CREATE TABLE `t1` (\n'
+		+ '\t`t1Id1` integer PRIMARY KEY,\n'
+		+ '\t`t1Col2` integer NOT NULL,\n'
+		+ '\t`t1Col3` integer NOT NULL,\n'
+		+ '\t`t2Ref` integer NOT NULL,\n'
+		+ '\t`t1Uni` integer NOT NULL CONSTRAINT `t1Uni` UNIQUE,\n'
+		+ '\t`t1UniIdx` integer NOT NULL,\n'
+		+ '\t`t1Idx` integer NOT NULL,\n'
+		+ '\tCONSTRAINT `fk_t1_t2Ref_t2_t2Id_fk` FOREIGN KEY (`t2Ref`) REFERENCES `t2`(`t2Id`),\n'
+		+ '\tCONSTRAINT `fk_t1_t1Col2_t1Col3_t3_t3Id1_t3Id2_fk` FOREIGN KEY (`t1Col2`,`t1Col3`) REFERENCES `t3`(`t3Id1`,`t3Id2`)\n'
+		+ ');\n',
+		'CREATE TABLE `t2` (\n\t`t2Id` integer PRIMARY KEY AUTOINCREMENT\n);\n',
+		'CREATE TABLE `t3` (\n'
+		+ '\t`t3Id1` integer,\n'
+		+ '\t`t3Id2` integer,\n'
+		+ '\tCONSTRAINT `t3_pk` PRIMARY KEY(`t3Id1`, `t3Id2`)\n'
+		+ ');\n',
+		'CREATE UNIQUE INDEX `t1UniIdx` ON `t1` (`t1UniIdx`);',
+		'CREATE INDEX `t1Idx` ON `t1` (`t1Idx`);',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('nothing changed in schema', async (t) => {
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey().notNull(),
+		name: text('name').notNull(),
+		email: text('email'),
+		textJson: text('text_json', { mode: 'json' }),
+		blobJon: blob('blob_json', { mode: 'json' }),
+		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
+		numeric: numeric('numeric'),
+		createdAt: integer('created_at', { mode: 'timestamp' }),
+		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
+		real: real('real'),
+		text: text('text', { length: 255 }),
+		role: text('role', { enum: ['admin', 'user'] }).default('user'),
+		isConfirmed: integer('is_confirmed', {
+			mode: 'boolean',
+		}),
+	});
+
+	const schema1 = {
+		users,
+		customers: sqliteTable('customers', {
+			id: integer('id').primaryKey(),
+			address: text('address').notNull(),
+			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+			registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
+				.notNull()
+				.$defaultFn(() => new Date()),
+			userId: integer('user_id')
+				.references(() => users.id)
+				.notNull(),
+		}),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema1, []);
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema1 });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+	expect(phints).toStrictEqual([]);
+});
+
+test('create table with custom name references', async (t) => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+
+	const schema1 = {
+		users,
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			userId: int('user_id'),
+		}, (t) => [foreignKey({
+			columns: [t.id],
+			foreignColumns: [users.id],
+			name: 'custom_name_fk',
+		})]),
+	};
+
+	const schema2 = {
+		users,
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			userId: int('user_id'),
+		}, (t) => [foreignKey({
+			columns: [t.id],
+			foreignColumns: [users.id],
+			name: 'custom_name_fk',
+		})]),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	expect(st).toStrictEqual([]);
+	expect(pst).toStrictEqual([]);
+	expect(phints).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/3047
+test('create table with custom type column', async (t) => {
+	const f32Blob = customType<{
+		data: number[];
+		config: {
+			length: number;
+		};
+		configRequired: true;
+	}>({
+		dataType(conf: { length: number }) {
+			return `F32_BLOB(${conf.length})`;
+		},
+		fromDriver(value: Buffer) {
+			const fArr = new Float32Array(new Uint8Array(value).buffer);
+			return Array.from(fArr);
+		},
+
+		toDriver(value: number[]) {
+			return Buffer.from(new Float32Array(value).buffer);
+		},
+	});
+	const schema = {
+		table1: sqliteTable('table1', {
+			id: text('id').primaryKey(),
+			blob: f32Blob('blob', {
+				length: 10,
+			}),
+		}),
+	};
+
+	const { next: n1 } = await diff({}, schema, []);
+	await push({ db, to: schema });
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
+
+test('rename table and change data type', async (t) => {
+	const schema1 = {
+		users: sqliteTable('old_users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: text('age'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('new_users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: integer('age'),
+		}),
+	};
+
+	const renames = ['old_users->new_users'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `old_users` RENAME TO `new_users`;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY AUTOINCREMENT,\n'
+		+ '\t`age` integer\n'
+		+ ');\n',
+		'INSERT INTO `__new_new_users`(`id`, `age`) SELECT `id`, `age` FROM `new_users`;',
+		'DROP TABLE `new_users`;',
+		'ALTER TABLE `__new_new_users` RENAME TO `new_users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints).toStrictEqual([]);
+});
+
+test('recreate table with nested references', async (t) => {
+	let users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		name: text('name'),
+		age: integer('age'),
+	});
+	let subscriptions = sqliteTable('subscriptions', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		userId: integer('user_id').references(() => users.id),
+		customerId: text('customer_id'),
+	});
+	const schema1 = {
+		users: users,
+		subscriptions: subscriptions,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(
+				() => subscriptions.id,
+			),
+		}),
+	};
+
+	users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: false }),
+		name: text('name'),
+		age: integer('age'),
+	});
+	const schema2 = {
+		users: users,
+		subscriptions: subscriptions,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(
+				() => subscriptions.id,
+			),
+		}),
+	};
+
+	const renames = ['users.name->users.age'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY,
+\t\`name\` text,
+\t\`age\` integer
+);\n`,
+		`INSERT INTO \`__new_users\`(\`id\`, \`name\`, \`age\`) SELECT \`id\`, \`name\`, \`age\` FROM \`users\`;`,
+		`DROP TABLE \`users\`;`,
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual([]);
+});
+
+test('recreate table with added column not null and without default with data', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			age: integer('age'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+			newColumn: text('new_column').notNull(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	await db.run(`INSERT INTO \`users\` ("name", "age") VALUES ('drizzle', 12)`);
+	await db.run(`INSERT INTO \`users\` ("name", "age") VALUES ('turso', 12)`);
+
+	const { sqlStatements: pst, hints: phints, error } = await push({
+		db,
+		to: schema2,
+		expectError: true,
+		force: true,
+	});
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `new_column` text NOT NULL;',
+		'PRAGMA foreign_keys=OFF;',
+		'CREATE TABLE `__new_users` (\n'
+		+ '\t`id` integer PRIMARY KEY,\n'
+		+ '\t`name` text,\n'
+		+ '\t`age` integer,\n'
+		+ '\t`new_column` text NOT NULL\n'
+		+ ');\n',
+		'INSERT INTO `__new_users`(`id`, `name`, `age`) SELECT `id`, `name`, `age` FROM `users`;',
+		'DROP TABLE `users`;',
+		'ALTER TABLE `__new_users` RENAME TO `users`;',
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints[0].statement).toStrictEqual('DELETE FROM "users" where true;');
+	expect(error).toBeNull();
+});
+
+test('rename table with composite primary key', async () => {
+	const productsCategoriesTable = (tableName: string) => {
+		return sqliteTable(tableName, {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => [primaryKey({
+			columns: [t.productId, t.categoryId],
+		})]);
+	};
+
+	const schema1 = {
+		table: productsCategoriesTable('products_categories'),
+	};
+	const schema2 = {
+		test: productsCategoriesTable('products_to_categories'),
+	};
+
+	const renames = ['products_categories->products_to_categories'];
+	const { sqlStatements: st } = await diff(schema1, schema2, renames);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2, renames });
+
+	const st0: string[] = [
+		'ALTER TABLE `products_categories` RENAME TO `products_to_categories`;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints).toStrictEqual([]);
+});
+
+test('push after migrate with custom migrations table #1', async () => {
+	const migrationsConfig = {
+		table: undefined,
+	};
+
+	const { migrate } = await import('drizzle-orm/better-sqlite3/migrator');
+	const { drizzle } = await import('drizzle-orm/better-sqlite3');
+
+	migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/sqlite/migrations',
+	});
+
+	const to = {
+		table: sqliteTable('table1', { col1: integer() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5083
+test('push after migrate with custom migrations table #2', async () => {
+	const migrationsConfig = {
+		table: 'migrations',
+	};
+
+	const { migrate } = await import('drizzle-orm/better-sqlite3/migrator');
+	const { drizzle } = await import('drizzle-orm/better-sqlite3');
+
+	migrate(drizzle({ client }), {
+		migrationsTable: migrationsConfig.table,
+		migrationsFolder: './tests/sqlite/migrations',
+	});
+
+	const to = {
+		table: sqliteTable('table1', { col1: integer() }),
+	};
+
+	const { sqlStatements: st2 } = await diff({}, to, []);
+	const { sqlStatements: pst2 } = await push({ db, to, migrationsConfig });
+	const expectedSt2 = [
+		'CREATE TABLE `table1` (\n\t`col1` integer\n);\n',
+	];
+	expect(st2).toStrictEqual(expectedSt2);
+	expect(pst2).toStrictEqual(expectedSt2);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5360
+test('recreate table and add unique column', async (t) => {
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: text('id').primaryKey(),
+			email: text('email').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: text('id').primaryKey(),
+			email: text('email').notNull(),
+			referralCode: text('referral_code').unique(),
+		}),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2, renames: [] });
+
+	const st0: string[] = [
+		'ALTER TABLE `users` ADD `referral_code` text;',
+		'PRAGMA foreign_keys=OFF;',
+		`CREATE TABLE \`__new_users\` (
+\t\`id\` text PRIMARY KEY,
+\t\`email\` text NOT NULL,
+\t\`referral_code\` text UNIQUE
+);\n`,
+		`INSERT INTO \`__new_users\`(\`id\`, \`email\`) SELECT \`id\`, \`email\` FROM \`users\`;`,
+		`DROP TABLE \`users\`;`,
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+		'PRAGMA foreign_keys=ON;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/sqlite/sqlite-views.test.ts b/drizzle-kit/tests/sqlite/sqlite-views.test.ts
new file mode 100644
index 0000000000..b3521919d1
--- /dev/null
+++ b/drizzle-kit/tests/sqlite/sqlite-views.test.ts
@@ -0,0 +1,333 @@
+import { sql } from 'drizzle-orm';
+import { int, integer, sqliteTable, sqliteView } from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(() => {
+	_ = prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('create view', async () => {
+	const users = sqliteTable('users', { id: int('id').default(1) });
+	const view = sqliteView('view').as((qb) => qb.select().from(users));
+	const to = {
+		users: users,
+		testView: view,
+	};
+
+	const { sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		`CREATE TABLE \`users\` (\n\t\`id\` integer DEFAULT 1\n);\n`,
+		`CREATE VIEW \`view\` AS select "id" from "users";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #1', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [`DROP VIEW \`view\`;`];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('drop view #2', async () => {
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['DROP VIEW \`view\`;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(phints).toStrictEqual([]);
+});
+
+test('alter view ".as" #1', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users WHERE users.id = 1`),
+	};
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'DROP VIEW `view`;',
+		'CREATE VIEW `view` AS SELECT * FROM users WHERE users.id = 1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual([]); // ignore AS sql for 'push'
+});
+
+test('alter view ".as" #2', async () => {
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = ['DROP VIEW `view`;', 'CREATE VIEW `view` AS select "id" from "test";'];
+	expect.soft(st).toStrictEqual(st0);
+	expect.soft(pst).toStrictEqual([]); // ignore sql change for push
+
+	expect(phints).toStrictEqual([]);
+});
+
+test('create view with existing flag', async () => {
+	const view = sqliteView('view', {}).existing();
+	const to = {
+		testView: view,
+	};
+
+	const { statements, sqlStatements: st } = await diff({}, to, []);
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(statements.length).toBe(0);
+});
+
+test('drop view with existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+	};
+
+	const { statements, sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(statements.length).toBe(0);
+});
+
+test('rename view with existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).existing(),
+	};
+
+	const renames = ['view->new_view'];
+	const { statements, sqlStatements: st } = await diff(from, to, renames);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to, renames });
+
+	const st0: string[] = [];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+
+	expect(statements.length).toBe(0);
+});
+
+test('rename view and drop existing flag', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).existing(),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = ['CREATE VIEW `new_view` AS SELECT * FROM users;'];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('rename view and alter ".as"', async () => {
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+	});
+
+	const from = {
+		users: users,
+		testView: sqliteView('view', { id: int('id') }).as(sql`SELECT * FROM users`),
+	};
+	const to = {
+		users,
+		testView: sqliteView('new_view', { id: int('id') }).as(sql`SELECT * FROM users WHERE 1=1`),
+	};
+
+	const { sqlStatements: st } = await diff(from, to, []);
+
+	await push({ db, to: from });
+	const { sqlStatements: pst } = await push({ db, to });
+
+	const st0: string[] = [
+		'DROP VIEW `view`;',
+		'CREATE VIEW `new_view` AS SELECT * FROM users WHERE 1=1;',
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+});
+
+test('create view', async () => {
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { sqlStatements: st } = await diff(schema1, schema2, []);
+
+	await push({ db, to: schema1 });
+	const { sqlStatements: pst, hints: phints } = await push({ db, to: schema2 });
+
+	const st0: string[] = [
+		`CREATE VIEW \`view\` AS select "id" from "test";`,
+	];
+	expect(st).toStrictEqual(st0);
+	expect(pst).toStrictEqual(st0);
+	expect(phints).toStrictEqual([]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4520
+test('create 2 dependent views', async () => {
+	const table1 = sqliteTable('table1', {
+		col1: integer(),
+		col2: integer(),
+		col3: integer(),
+	});
+	const accountBalancesPMMV = sqliteView('accountBalancesPM').as(
+		(qb) => {
+			return qb
+				.select({
+					col1: table1.col1,
+					col2: table1.col2,
+					col3: table1.col3,
+				})
+				.from(table1);
+		},
+	);
+
+	const accountBalancesMV = sqliteView('accountBalances').as(
+		(qb) =>
+			qb
+				.select({
+					accountId: accountBalancesPMMV.col1,
+				})
+				.from(accountBalancesPMMV),
+	);
+
+	const schema = { table1, accountBalancesMV, accountBalancesPMMV };
+	const { sqlStatements: st1, next: n1 } = await diff({}, schema, []);
+	const { sqlStatements: pst1 } = await push({ db, to: schema });
+	const expectedSt1 = [
+		'CREATE TABLE `table1` (\n\t`col1` integer,\n\t`col2` integer,\n\t`col3` integer\n);\n',
+		'CREATE VIEW `accountBalancesPM` AS select "col1", "col2", "col3" from "table1";',
+		'CREATE VIEW `accountBalances` AS select "col1" from "accountBalancesPM";',
+	];
+	expect(st1).toStrictEqual(expectedSt1);
+	expect(pst1).toStrictEqual(expectedSt1);
+
+	const { sqlStatements: st2 } = await diff(n1, schema, []);
+	const { sqlStatements: pst2 } = await push({ db, to: schema });
+	expect(st2).toStrictEqual([]);
+	expect(pst2).toStrictEqual([]);
+});
diff --git a/drizzle-kit/tests/statements-combiner/libsql-statements-combiner.test.ts b/drizzle-kit/tests/statements-combiner/libsql-statements-combiner.test.ts
deleted file mode 100644
index 449b61c6cf..0000000000
--- a/drizzle-kit/tests/statements-combiner/libsql-statements-combiner.test.ts
+++ /dev/null
@@ -1,1812 +0,0 @@
-import { JsonAddColumnStatement, JsonSqliteAddColumnStatement, JsonStatement } from 'src/jsonStatements';
-import { SQLiteSchemaSquashed } from 'src/serializer/sqliteSchema';
-import { SQLiteAlterTableAddColumnConvertor } from 'src/sqlgenerator';
-import { libSQLCombineStatements } from 'src/statementCombiner';
-import { expect, test } from 'vitest';
-
-/**
- * ! before:
- *
- * user: {
- *    id INT;
- *    first_name INT;
- *    iq INT;
- *    PRIMARY KEY (id, iq)
- *    INDEXES: {
- *      UNIQUE id;
- *    }
- * }
- *
- * ! after:
- *
- *  new_user: {
- *    id INT;
- *    first_name INT;
- *    iq INT;
- *    PRIMARY KEY (id, iq)
- *    INDEXES: {}
- * }
- *
- * rename table and drop unique index
- * expect to get "rename_table" statement and then "recreate_table"
- */
-test(`rename table and drop index`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'rename_table',
-			fromSchema: '',
-			toSchema: '',
-			tableNameFrom: 'user',
-			tableNameTo: 'new_user',
-		},
-		{
-			type: 'drop_index',
-			tableName: 'new_user',
-			data: 'user_first_name_unique;first_name;true;',
-			schema: '',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_name: {
-						name: 'first_name',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {
-					user_first_name_unique: 'user_first_name_unique;first_name;true;',
-				},
-				foreignKeys: {},
-				compositePrimaryKeys: {
-					user_id_iq_pk: 'id,iq',
-				},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			new_user: {
-				name: 'new_user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_name: {
-						name: 'first_name',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {
-					new_user_id_iq_pk: 'id,iq',
-				},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'rename_table',
-			fromSchema: '',
-			toSchema: '',
-			tableNameFrom: 'user',
-			tableNameTo: 'new_user',
-		},
-		{
-			type: 'drop_index',
-			tableName: 'new_user',
-			data: 'user_first_name_unique;first_name;true;',
-			schema: '',
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-/**
- * ! before:
- *
- * autoincrement1: {
- *    id INT PRIMARY KEY;
- * }
- *
- * autoincrement2: {
- *    id INT PRIMARY KEY AUTOINCREMENT;
- * }
- *
- * dropNotNull: {
- *    id INT NOT NULL;
- * }
- *
- * ! after:
- *
- * autoincrement1: {
- *    id INT PRIMARY KEY AUTOINCREMENT;
- * }
- *
- * autoincrement2: {
- *    id INT PRI<ARY KEY;
- * }
- *
- * dropNotNull: {
- *    id INT;
- * }
- *
- * drop autoincrement for autoincrement1
- * set autoincrement for autoincrement2
- *
- * expect to:
- * - get "recreate_table" for autoincrement1
- * - get "recreate_table" for autoincrement2
- * - get "drop_notnull" for dropNotNull
- */
-test(`drop, set autoincrement. drop not null`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_set_autoincrement',
-			tableName: 'autoincrement1',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: true,
-			columnPk: true,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_drop_autoincrement',
-			tableName: 'autoincrement2',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: false,
-			columnPk: true,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_drop_notnull',
-			tableName: 'dropNotNull',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			autoincrement1: {
-				name: 'autoincrement1',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			autoincrement2: {
-				name: 'autoincrement2',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: false,
-						autoincrement: true,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			dropNotNull: {
-				name: 'dropNotNull',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			autoincrement1: {
-				name: 'autoincrement1',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: true,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			autoincrement2: {
-				name: 'autoincrement2',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			dropNotNull: {
-				name: 'dropNotNull',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'recreate_table',
-			tableName: 'autoincrement1',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: true,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'recreate_table',
-			tableName: 'autoincrement2',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'alter_table_alter_column_drop_notnull',
-			tableName: 'dropNotNull',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-/**
- * ! before:
- *
- * pk1: {
- *    id INT;
- * }
- *
- * pk2: {
- *    id INT PRIMARY KEY;
- * }
- *
- * ref_table: {
- *    id INT;
- * }
- *
- * create_reference: {
- *    id INT;
- * }
- *
- * ! after:
- *
- * pk1: {
- *    id INT PRIMARY KEY;
- * }
- *
- * pk2: {
- *    id INT;
- * }
- *
- * ref_table: {
- *    id INT;
- * }
- *
- * create_reference: {
- *    id INT -> ref_table INT;
- * }
- *
- * drop primary key for pk2
- * set primary key for pk1
- * "create_reference" reference on "ref_table"
- *
- * expect to:
- * - "recreate_table" statement for pk1
- * - "recreate_table" statement for pk2
- * - "create_reference" statement for create_reference
- */
-test(`drop and set primary key. create reference`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_set_pk',
-			tableName: 'pk1',
-			schema: '',
-			columnName: 'id',
-		},
-		{
-			type: 'alter_table_alter_column_set_notnull',
-			tableName: 'pk1',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: false,
-			columnPk: true,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_drop_pk',
-			tableName: 'pk2',
-			columnName: 'id',
-			schema: '',
-		},
-		{
-			type: 'alter_table_alter_column_drop_notnull',
-			tableName: 'pk2',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-		{
-			type: 'create_reference',
-			tableName: 'create_reference',
-			data: 'create_reference_id_ref_table_id_fk;create_reference;id;ref_table;id;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'int',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			create_reference: {
-				name: 'create_reference',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			pk1: {
-				name: 'pk1',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			pk2: {
-				name: 'pk2',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			ref_table: {
-				name: 'ref_table',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			create_reference: {
-				name: 'create_reference',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					create_reference_id_ref_table_id_fk:
-						'create_reference_id_ref_table_id_fk;create_reference;id;ref_table;id;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			pk1: {
-				name: 'pk1',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			pk2: {
-				name: 'pk2',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			ref_table: {
-				name: 'ref_table',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'recreate_table',
-			tableName: 'pk1',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'recreate_table',
-			tableName: 'pk2',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'create_reference',
-			tableName: 'create_reference',
-			data: 'create_reference_id_ref_table_id_fk;create_reference;id;ref_table;id;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'int',
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-/**
- * ! before:
- *
- * fk1: {
- *  fk_id INT;
- *  fk_id1 INT;
- * }
- *
- * fk2: {
- *  fk2_id INT;  -> composite reference on ref_table id INT
- *  fk2_id1 INT; -> composite reference on ref_table id1 INT
- * }
- *
- * ref_table: {
- *  id INT;
- *  id1 INT;
- * }
- *
- * ! after:
- *
- * fk1: {
- *  fk_id INT;  -> composite reference on ref_table id INT
- *  fk_id1 INT; -> composite reference on ref_table id1 INT
- * }
- *
- * fk2: {
- *  fk2_id INT;
- *  fk2_id1 INT;
- * }
- *
- * ref_table: {
- *  id INT;
- *  id1 INT;
- * }
- *
- * set multi column reference for fk1
- * drop multi column reference for fk2
- *
- * expect to:
- * - "recreate_table" statement for fk1
- * - "recreate_table" statement for fk2
- */
-test(`set and drop multiple columns reference`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'delete_reference',
-			tableName: 'fk1',
-			data: 'fk1_fk_id_fk_id1_ref_table_id_id1_fk;fk1;fk_id,fk_id1;ref_table;id,id1;no action;no action',
-			schema: '',
-			isMulticolumn: true,
-		},
-		{
-			type: 'create_reference',
-			tableName: 'fk2',
-			data: 'fk2_fk2_id_fk2_id1_ref_table_id_id1_fk;fk2;fk2_id,fk2_id1;ref_table;id,id1;no action;no action',
-			schema: '',
-			isMulticolumn: true,
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			fk1: {
-				name: 'fk1',
-				columns: {
-					fk_id: {
-						name: 'fk_id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					fk_id1: {
-						name: 'fk_id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					fk1_fk_id_fk_id1_ref_table_id_id1_fk:
-						'fk1_fk_id_fk_id1_ref_table_id_id1_fk;fk1;fk_id,fk_id1;ref_table;id,id1;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			fk2: {
-				name: 'fk2',
-				columns: {
-					fk2_id: {
-						name: 'fk2_id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					fk2_id1: {
-						name: 'fk2_id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			ref_table: {
-				name: 'ref_table',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					id1: {
-						name: 'id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			fk1: {
-				name: 'fk1',
-				columns: {
-					fk_id: {
-						name: 'fk_id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					fk_id1: {
-						name: 'fk_id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			fk2: {
-				name: 'fk2',
-				columns: {
-					fk2_id: {
-						name: 'fk2_id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					fk2_id1: {
-						name: 'fk2_id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					fk2_fk2_id_fk2_id1_ref_table_id_id1_fk:
-						'fk2_fk2_id_fk2_id1_ref_table_id_id1_fk;fk2;fk2_id,fk2_id1;ref_table;id,id1;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			ref_table: {
-				name: 'ref_table',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					id1: {
-						name: 'id1',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'recreate_table',
-			tableName: 'fk1',
-			columns: [
-				{
-					name: 'fk_id',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'fk_id1',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'recreate_table',
-			tableName: 'fk2',
-			columns: [
-				{
-					name: 'fk2_id',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'fk2_id1',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [
-				{
-					name: 'fk2_fk2_id_fk2_id1_ref_table_id_id1_fk',
-					tableFrom: 'fk2',
-					tableTo: 'ref_table',
-					columnsFrom: ['fk2_id', 'fk2_id1'],
-					columnsTo: ['id', 'id1'],
-					onDelete: 'no action',
-					onUpdate: 'no action',
-				},
-			],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-/**
- * ! before:
- *
- * pk: {
- *  pk TEXT PRIMARY KEY;
- * }
- *
- * simple: {
- *  simple TEXT;
- * }
- *
- * unique: {
- *  unique INT UNIQUE;
- * }
- *
- * ! after:
- *
- * pk: {
- *  pk INT PRIMARY KEY;
- * }
- *
- * simple: {
- *  simple INT;
- * }
- *
- * unique: {
- *  unique TEXT UNIQUE;
- * }
- *
- * set new type for primary key column
- * set new type for unique column
- * set new type for column without pk or unique
- *
- * expect to:
- * - "recreate_table" statement for pk
- * - "recreate_table" statement for unique
- * - "alter_table_alter_column_set_type" statement for simple
- * - "create_index" statement for unique
- */
-test(`set new type for primary key, unique and normal column`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'pk',
-			columnName: 'pk',
-			newDataType: 'int',
-			oldDataType: 'text',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: false,
-			columnPk: true,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'simple',
-			columnName: 'simple',
-			newDataType: 'int',
-			oldDataType: 'text',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'unique',
-			columnName: 'unique',
-			newDataType: 'text',
-			oldDataType: 'int',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			pk: {
-				name: 'pk',
-				columns: {
-					pk: {
-						name: 'pk',
-						type: 'text',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			simple: {
-				name: 'simple',
-				columns: {
-					simple: {
-						name: 'simple',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			unique: {
-				name: 'unique',
-				columns: {
-					unique: {
-						name: 'unique',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {
-					unique_unique_unique: 'unique_unique_unique;unique;true;',
-				},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			pk: {
-				name: 'pk',
-				columns: {
-					pk: {
-						name: 'pk',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			simple: {
-				name: 'simple',
-				columns: {
-					simple: {
-						name: 'simple',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			unique: {
-				name: 'unique',
-				columns: {
-					unique: {
-						name: 'unique',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {
-					unique_unique_unique: 'unique_unique_unique;unique;true;',
-				},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'recreate_table',
-			tableName: 'pk',
-			columns: [
-				{
-					name: 'pk',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'simple',
-			columnName: 'simple',
-			newDataType: 'int',
-			oldDataType: 'text',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		},
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'unique',
-			columnName: 'unique',
-			newDataType: 'text',
-			oldDataType: 'int',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add columns. set fk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_new_age_user_new_age_fk: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add column and fk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_test1_user_new_age_fk: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_new_age_user_new_age_fk: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add column and fk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_test1_user_new_age_fk: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_new_age_user_new_age_fk: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-	];
-	expect(libSQLCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
diff --git a/drizzle-kit/tests/statements-combiner/singlestore-statements-combiner.test.ts b/drizzle-kit/tests/statements-combiner/singlestore-statements-combiner.test.ts
deleted file mode 100644
index 0ba6cf2782..0000000000
--- a/drizzle-kit/tests/statements-combiner/singlestore-statements-combiner.test.ts
+++ /dev/null
@@ -1,882 +0,0 @@
-import { JsonStatement } from 'src/jsonStatements';
-import { SingleStoreSchemaSquashed } from 'src/serializer/singlestoreSchema';
-import { singleStoreCombineStatements } from 'src/statementCombiner';
-import { expect, test } from 'vitest';
-
-test(`change column data type`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'user',
-			columnName: 'lastName123',
-			newDataType: 'int',
-			oldDataType: 'text',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-			columnIsUnique: false,
-		} as unknown as JsonStatement,
-	];
-	const json1: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName123',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'user',
-			columns: [
-				{
-					name: 'firstName',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'lastName123',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'test',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`set autoincrement`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_set_autoincrement',
-			tableName: 'users',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: true,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			users: {
-				name: 'users',
-				columns: {
-					new_id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: true,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					email: {
-						name: 'email',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const newJsonStatements = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'users',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: true,
-				},
-				{
-					name: 'name',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'email',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`drop autoincrement`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_drop_autoincrement',
-			tableName: 'users',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: true,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			users: {
-				name: 'users',
-				columns: {
-					new_id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					email: {
-						name: 'email',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const newJsonStatements = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'users',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'name',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'email',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`drop autoincrement`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_drop_autoincrement',
-			tableName: 'users',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: true,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			users: {
-				name: 'users',
-				columns: {
-					new_id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					email: {
-						name: 'email',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const newJsonStatements = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'users',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'name',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'email',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`set not null`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_set_notnull',
-			tableName: 'users',
-			columnName: 'name',
-			schema: '',
-			newDataType: 'text',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			users: {
-				name: 'users',
-				columns: {
-					new_id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					email: {
-						name: 'email',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const newJsonStatements = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'users',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'name',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'email',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`drop not null`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_alter_column_drop_notnull',
-			tableName: 'users',
-			columnName: 'name',
-			schema: '',
-			newDataType: 'text',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-	];
-
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			users: {
-				name: 'users',
-				columns: {
-					new_id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					email: {
-						name: 'email',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const newJsonStatements = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'users',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'name',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'email',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`renamed column and droped column "test"`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'test',
-			schema: '',
-		},
-	];
-	const json1: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName123',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'test',
-			schema: '',
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`droped column that is part of composite pk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{ type: 'delete_composite_pk', tableName: 'user', data: 'id,iq' },
-		{
-			type: 'alter_table_alter_column_set_pk',
-			tableName: 'user',
-			schema: '',
-			columnName: 'id',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'iq',
-			schema: '',
-		},
-	];
-	const json1: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_nam: {
-						name: 'first_nam',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {
-					user_id_iq_pk: 'id,iq',
-				},
-				uniqueConstraints: {},
-			},
-		},
-	};
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_nam: {
-						name: 'first_name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'singlestore_recreate_table',
-			tableName: 'user',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: true,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'first_name',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add column with pk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_add_column',
-			tableName: 'table',
-			column: {
-				name: 'test',
-				type: 'integer',
-				primaryKey: true,
-				notNull: false,
-				autoincrement: false,
-			},
-			schema: '',
-		},
-	];
-	const json2: SingleStoreSchemaSquashed = {
-		version: '1',
-		dialect: 'singlestore',
-		tables: {
-			table: {
-				name: 'table',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-			},
-		},
-	};
-
-	const newJsonStatements = [
-		{
-			columns: [
-				{
-					name: 'id1',
-					type: 'text',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'new_age',
-					type: 'integer',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'test',
-					type: 'integer',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			tableName: 'table',
-			type: 'singlestore_recreate_table',
-			uniqueConstraints: [],
-		},
-	];
-	expect(singleStoreCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
diff --git a/drizzle-kit/tests/statements-combiner/sqlite-statements-combiner.test.ts b/drizzle-kit/tests/statements-combiner/sqlite-statements-combiner.test.ts
deleted file mode 100644
index 20f953da62..0000000000
--- a/drizzle-kit/tests/statements-combiner/sqlite-statements-combiner.test.ts
+++ /dev/null
@@ -1,1211 +0,0 @@
-import { JsonStatement } from 'src/jsonStatements';
-import { SQLiteSchemaSquashed } from 'src/serializer/sqliteSchema';
-import { sqliteCombineStatements } from 'src/statementCombiner';
-import { expect, test } from 'vitest';
-
-test(`renamed column and altered this column type`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_alter_column_set_type',
-			tableName: 'user',
-			columnName: 'lastName123',
-			newDataType: 'int',
-			oldDataType: 'text',
-			schema: '',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-			columnIsUnique: false,
-		} as unknown as JsonStatement,
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName123',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'recreate_table',
-			tableName: 'user',
-			columns: [
-				{
-					name: 'firstName',
-					type: 'int',
-					primaryKey: true,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'lastName123',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'test',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	];
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`renamed column and droped column "test"`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'test',
-			schema: '',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					firstName: {
-						name: 'firstName',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					lastName: {
-						name: 'lastName123',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'user',
-			oldColumnName: 'lastName',
-			newColumnName: 'lastName123',
-			schema: '',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'test',
-			schema: '',
-		},
-	];
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`droped column that is part of composite pk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{ type: 'delete_composite_pk', tableName: 'user', data: 'id,iq' },
-		{
-			type: 'alter_table_alter_column_set_pk',
-			tableName: 'user',
-			schema: '',
-			columnName: 'id',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'user',
-			columnName: 'iq',
-			schema: '',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_nam: {
-						name: 'first_nam',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {
-					user_id_iq_pk: 'id,iq',
-				},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: false,
-						autoincrement: false,
-					},
-					first_nam: {
-						name: 'first_nam',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'recreate_table',
-			tableName: 'user',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: true,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'first_nam',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	];
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`drop column "ref"."name", rename column "ref"."age". dropped primary key "user"."id". Set not null to "user"."iq"`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'ref',
-			oldColumnName: 'age',
-			newColumnName: 'age1',
-			schema: '',
-		},
-		{
-			type: 'alter_table_alter_column_drop_pk',
-			tableName: 'user',
-			columnName: 'id',
-			schema: '',
-		},
-		{
-			type: 'alter_table_alter_column_drop_autoincrement',
-			tableName: 'user',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_drop_notnull',
-			tableName: 'user',
-			columnName: 'id',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: false,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_alter_column_set_notnull',
-			tableName: 'user',
-			columnName: 'iq',
-			schema: '',
-			newDataType: 'int',
-			columnDefault: undefined,
-			columnOnUpdate: undefined,
-			columnNotNull: true,
-			columnAutoIncrement: false,
-			columnPk: false,
-		} as unknown as JsonStatement,
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'ref',
-			columnName: 'text',
-			schema: '',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: true,
-					},
-					user_iq: {
-						name: 'user_iq',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					name: {
-						name: 'name',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					age: {
-						name: 'age',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_user_iq_user_iq_fk: 'ref_user_iq_user_iq_fk;ref;user_iq;user;iq;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: true,
-					},
-					first_name: {
-						name: 'first_name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-					user_iq: {
-						name: 'user_iq',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					age1: {
-						name: 'age1',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_user_iq_user_iq_fk: 'ref_user_iq_user_iq_fk;ref;user_iq;user;iq;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id: {
-						name: 'id',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					first_name: {
-						name: 'first_name',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					iq: {
-						name: 'iq',
-						type: 'int',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'alter_table_rename_column',
-			tableName: 'ref',
-			oldColumnName: 'age',
-			newColumnName: 'age1',
-			schema: '',
-		},
-		{
-			type: 'alter_table_drop_column',
-			tableName: 'ref',
-			columnName: 'text',
-			schema: '',
-		},
-		{
-			type: 'recreate_table',
-			tableName: 'user',
-			columns: [
-				{
-					name: 'id',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-				{
-					name: 'first_name',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'iq',
-					type: 'int',
-					primaryKey: false,
-					notNull: true,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	];
-
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`create reference on exising column (table includes unique index). expect to recreate column and recreate index`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'create_reference',
-			tableName: 'unique',
-			data: 'unique_ref_pk_pk_pk_fk;unique;ref_pk;pk;pk;no action;no action',
-			schema: '',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			pk: {
-				name: 'pk',
-				columns: {
-					pk: {
-						name: 'pk',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			unique: {
-				name: 'unique',
-				columns: {
-					unique: {
-						name: 'unique',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					ref_pk: {
-						name: 'ref_pk',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {
-					unique_unique_unique: 'unique_unique_unique;unique;true;',
-				},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			pk: {
-				name: 'pk',
-				columns: {
-					pk: {
-						name: 'pk',
-						type: 'int',
-						primaryKey: true,
-						notNull: true,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			unique: {
-				name: 'unique',
-				columns: {
-					unique: {
-						name: 'unique',
-						type: 'text',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					ref_pk: {
-						name: 'ref_pk',
-						type: 'int',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {
-					unique_unique_unique: 'unique_unique_unique;unique;true;',
-				},
-				foreignKeys: {
-					unique_ref_pk_pk_pk_fk: 'unique_ref_pk_pk_pk_fk;unique;ref_pk;pk;pk;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements: JsonStatement[] = [
-		{
-			type: 'recreate_table',
-			tableName: 'unique',
-			columns: [
-				{
-					name: 'unique',
-					type: 'text',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-				{
-					name: 'ref_pk',
-					type: 'int',
-					primaryKey: false,
-					notNull: false,
-					autoincrement: false,
-				},
-			],
-			compositePKs: [],
-			referenceData: [
-				{
-					name: 'unique_ref_pk_pk_pk_fk',
-					tableFrom: 'unique',
-					tableTo: 'pk',
-					columnsFrom: ['ref_pk'],
-					columnsTo: ['pk'],
-					onDelete: 'no action',
-					onUpdate: 'no action',
-				},
-			],
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-		{
-			data: 'unique_unique_unique;unique;true;',
-			internal: undefined,
-			schema: '',
-			tableName: 'unique',
-			type: 'create_index',
-		},
-	];
-
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add columns. set fk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: undefined,
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_new_age_user_new_age_fk: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			columns: [
-				{
-					autoincrement: false,
-					name: 'id1',
-					notNull: true,
-					primaryKey: false,
-					type: 'text',
-				},
-				{
-					autoincrement: false,
-					name: 'new_age',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'test',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-				{
-					autoincrement: false,
-					name: 'test1',
-					notNull: false,
-					primaryKey: false,
-					type: 'integer',
-				},
-			],
-			compositePKs: [],
-			referenceData: [
-				{
-					columnsFrom: [
-						'new_age',
-					],
-					columnsTo: [
-						'new_age',
-					],
-					name: 'ref_new_age_user_new_age_fk',
-					onDelete: 'no action',
-					onUpdate: 'no action',
-					tableFrom: 'ref',
-					tableTo: 'user',
-				},
-			],
-			tableName: 'ref',
-			type: 'recreate_table',
-			uniqueConstraints: [],
-			checkConstraints: [],
-		},
-	];
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
-
-test(`add column and fk`, async (t) => {
-	const statements: JsonStatement[] = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-		{
-			type: 'create_reference',
-			tableName: 'ref',
-			data: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-			schema: '',
-			columnNotNull: false,
-			columnDefault: undefined,
-			columnType: 'integer',
-		},
-	];
-	const json1: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_test1_user_new_age_fk: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-	const json2: SQLiteSchemaSquashed = {
-		version: '6',
-		dialect: 'sqlite',
-		tables: {
-			ref: {
-				name: 'ref',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test: {
-						name: 'test',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-					test1: {
-						name: 'test1',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {
-					ref_new_age_user_new_age_fk: 'ref_new_age_user_new_age_fk;ref;new_age;user;new_age;no action;no action',
-				},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-			user: {
-				name: 'user',
-				columns: {
-					id1: {
-						name: 'id1',
-						type: 'text',
-						primaryKey: false,
-						notNull: true,
-						autoincrement: false,
-					},
-					new_age: {
-						name: 'new_age',
-						type: 'integer',
-						primaryKey: false,
-						notNull: false,
-						autoincrement: false,
-					},
-				},
-				indexes: {},
-				foreignKeys: {},
-				compositePrimaryKeys: {},
-				uniqueConstraints: {},
-				checkConstraints: {},
-			},
-		},
-		enums: {},
-		views: {},
-	};
-
-	const newJsonStatements = [
-		{
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'ref',
-			column: {
-				name: 'test1',
-				type: 'integer',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-			referenceData: 'ref_test1_user_new_age_fk;ref;test1;user;new_age;no action;no action',
-		},
-	];
-	expect(sqliteCombineStatements(statements, json2)).toStrictEqual(
-		newJsonStatements,
-	);
-});
diff --git a/drizzle-kit/tests/test/sqlite.test.ts b/drizzle-kit/tests/test/sqlite.test.ts
deleted file mode 100644
index 9a00e8def3..0000000000
--- a/drizzle-kit/tests/test/sqlite.test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { diffTestSchemasSqlite } from 'tests/schemaDiffer';
-import { expect } from 'vitest';
-import { DialectSuite, run } from '../common';
-
-const sqliteSuite: DialectSuite = {
-	async columns1() {
-		const schema1 = {
-			users: sqliteTable('users', {
-				id: int('id').primaryKey({ autoIncrement: true }),
-			}),
-		};
-
-		const schema2 = {
-			users: sqliteTable('users', {
-				id: int('id').primaryKey({ autoIncrement: true }),
-				name: text('name'),
-			}),
-		};
-
-		const { statements } = await diffTestSchemasSqlite(schema1, schema2, []);
-
-		expect(statements.length).toBe(1);
-		expect(statements[0]).toStrictEqual({
-			type: 'sqlite_alter_table_add_column',
-			tableName: 'users',
-			referenceData: undefined,
-			column: {
-				name: 'name',
-				type: 'text',
-				primaryKey: false,
-				notNull: false,
-				autoincrement: false,
-			},
-		});
-	},
-};
-
-run(sqliteSuite);
diff --git a/drizzle-kit/tests/testsinglestore.ts b/drizzle-kit/tests/testsinglestore.ts
deleted file mode 100644
index 1dc97d9c32..0000000000
--- a/drizzle-kit/tests/testsinglestore.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { index, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import { diffTestSchemasSingleStore } from './schemaDiffer';
-
-const from = {
-	users: singlestoreTable(
-		'table',
-		{
-			name: text('name'),
-		},
-		(t) => {
-			return {
-				idx: index('name_idx').on(t.name),
-			};
-		},
-	),
-};
-
-const to = {
-	users: singlestoreTable('table', {
-		name: text('name'),
-	}),
-};
-
-diffTestSchemasSingleStore(from, to, []).then((res) => {
-	const { statements, sqlStatements } = res;
-
-	console.log(statements);
-	console.log(sqlStatements);
-});
diff --git a/drizzle-kit/tests/utils.ts b/drizzle-kit/tests/utils.ts
new file mode 100644
index 0000000000..538cb32474
--- /dev/null
+++ b/drizzle-kit/tests/utils.ts
@@ -0,0 +1,100 @@
+export const measure = <T>(prom: Promise<T>, label: string): Promise<T> => {
+	return new Promise<T>(async (res, rej) => { // oxlint-disable-line no-async-promise-executor
+		console.time(label);
+		try {
+			const result = await prom;
+			console.timeEnd(label);
+			res(result);
+		} catch (e) {
+			console.timeEnd(label);
+			rej(e);
+		}
+	});
+};
+
+import * as ts from 'typescript';
+
+const options = {
+	noEmit: true,
+	skipLibCheck: true,
+	target: ts.ScriptTarget.ES2020,
+	module: ts.ModuleKind.NodeNext,
+	moduleResolution: ts.ModuleResolutionKind.NodeNext,
+};
+
+type VFile = { text: string; version: number };
+
+export function makeTSC2(options: ts.CompilerOptions, fileName = 'temp.ts') {
+	const files = new Map<string, VFile>();
+	const sys = ts.sys; // fall back to real FS for libs, node_modules, etc.
+
+	const ensure = (fn: string) => {
+		if (!files.has(fn)) files.set(fn, { text: '', version: 0 });
+		return files.get(fn)!;
+	};
+	ensure(fileName);
+
+	const host: ts.LanguageServiceHost = {
+		getCompilationSettings: () => options,
+		getScriptFileNames: () => Array.from(files.keys()),
+		getScriptVersion: (fn) => (files.get(fn)?.version ?? 0).toString(),
+		getScriptSnapshot: (fn) => {
+			const mem = files.get(fn);
+			if (mem) return ts.ScriptSnapshot.fromString(mem.text);
+			// Defer to real FS for everything else
+			if (sys.fileExists(fn)) return ts.ScriptSnapshot.fromString(sys.readFile(fn)!);
+			return;
+		},
+		getCurrentDirectory: () => sys.getCurrentDirectory(),
+		getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+		fileExists: sys.fileExists,
+		readFile: sys.readFile,
+		readDirectory: sys.readDirectory,
+		directoryExists: sys.directoryExists?.bind(sys),
+		getDirectories: sys.getDirectories?.bind(sys),
+		useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
+	};
+
+	const registry = ts.createDocumentRegistry();
+	const service = ts.createLanguageService(host, registry);
+
+	const formatHost: ts.FormatDiagnosticsHost = {
+		getCurrentDirectory: host.getCurrentDirectory,
+		getCanonicalFileName: (f) => host.useCaseSensitiveFileNames?.() ? f : f.toLowerCase(),
+		getNewLine: () => sys.newLine,
+	};
+
+	async function tsc2(content: string, fn: string = fileName): Promise<void> {
+		const f = ensure(fn);
+		f.text = content;
+		f.version++;
+
+		// Ask LS for diagnostics (incremental & fast)
+		const syntactic = service.getSyntacticDiagnostics(fn);
+		const semantic = service.getSemanticDiagnostics(fn);
+		const optionsDiag = service.getCompilerOptionsDiagnostics();
+
+		const diags = [...optionsDiag, ...syntactic, ...semantic];
+		if (diags.length) {
+			const message = ts.formatDiagnostics(diags, formatHost);
+			console.log(content);
+			console.log();
+			console.error(message);
+			throw new Error(message);
+		}
+	}
+
+	return { tsc2, service, update: tsc2 };
+}
+
+export const tsc = makeTSC2(options).tsc2;
+
+// export const tsc = async (path: string) => {
+// 	const typeCheckResult =
+// 		await $`bun tsc --noEmit --skipLibCheck --target ES2020 --module NodeNext --moduleResolution NodeNext ${path}`
+// 			// .quiet()
+// 			.nothrow();
+// 	if (typeCheckResult.exitCode !== 0) {
+// 		throw new Error(typeCheckResult.stderr || typeCheckResult.stdout);
+// 	}
+// };
diff --git a/drizzle-kit/tsconfig.build.json b/drizzle-kit/tsconfig.build.json
index b57ab6b000..09717efd0b 100644
--- a/drizzle-kit/tsconfig.build.json
+++ b/drizzle-kit/tsconfig.build.json
@@ -1,4 +1,11 @@
 {
 	"extends": "./tsconfig.json",
-	"include": ["src"]
+	"compilerOptions": {
+		"noEmit": false,
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"outDir": "dist"
+	},
+	"include": ["src"],
+	"exclude": ["tests", "node_modules"]
 }
diff --git a/drizzle-kit/tsconfig.json b/drizzle-kit/tsconfig.json
index 814139e470..33cd740bb6 100644
--- a/drizzle-kit/tsconfig.json
+++ b/drizzle-kit/tsconfig.json
@@ -1,8 +1,10 @@
 {
 	"compilerOptions": {
-		"target": "es2021",
-		"lib": ["es2021"],
+		"target": "ESNext",
+		"lib": ["ESNext"],
 		"types": ["node"],
+		"module": "preserve",
+		"moduleResolution": "bundler",
 		"strictNullChecks": true,
 		"strictFunctionTypes": false,
 		"allowJs": true,
@@ -12,13 +14,15 @@
 		"strict": true,
 		"noImplicitOverride": true,
 		"forceConsistentCasingInFileNames": true,
-		"module": "CommonJS",
-		"moduleResolution": "node",
 		"resolveJsonModule": true,
 		"noErrorTruncation": true,
 		"isolatedModules": true,
 		"sourceMap": true,
 		"baseUrl": ".",
+		"paths": {
+			"@/*": ["tests/fixtures/tsconfig-paths/src/*"],
+			"@profile": ["tests/fixtures/tsconfig-paths/src/profile/schema.ts"]
+		},
 		"outDir": "dist",
 		"noEmit": true,
 		"typeRoots": ["node_modules/@types", "src/@types"]
diff --git a/drizzle-kit/tsconfig.typetest.json b/drizzle-kit/tsconfig.typetest.json
new file mode 100644
index 0000000000..435d02fa84
--- /dev/null
+++ b/drizzle-kit/tsconfig.typetest.json
@@ -0,0 +1,32 @@
+{
+	"compilerOptions": {
+		"target": "es2022",
+		"module": "esnext",
+		"moduleResolution": "node",
+		"lib": ["es2022"],
+		"types": ["node"],
+		"strictNullChecks": true,
+		"strictFunctionTypes": false,
+		"allowJs": true,
+		"skipLibCheck": true,
+		"esModuleInterop": true,
+		"allowSyntheticDefaultImports": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"noErrorTruncation": true,
+		"isolatedModules": true,
+		"sourceMap": true,
+		"baseUrl": ".",
+		"paths": {
+			"@/*": ["tests/fixtures/tsconfig-paths/src/*"],
+			"@profile": ["tests/fixtures/tsconfig-paths/src/profile/schema.ts"]
+		},
+		"outDir": "dist",
+		"noEmit": true,
+		"typeRoots": ["node_modules/@types", "src/@types"]
+	},
+	"include": ["dev", "tests", "drizzle.config.ts", "test.ts"],
+	"exclude": ["node_modules", "tests/**/tmp"]
+}
diff --git a/drizzle-kit/vitest.config.ts b/drizzle-kit/vitest.config.ts
index fd728eb116..48cc9edd6d 100644
--- a/drizzle-kit/vitest.config.ts
+++ b/drizzle-kit/vitest.config.ts
@@ -5,6 +5,7 @@ export default defineConfig({
 	test: {
 		include: [
 			'tests/**/*.test.ts',
+			'tests/**/*.test-d.ts',
 			// Need to test it first before pushing changes
 			// 'tests/singlestore-schemas.test.ts',
 			// 'tests/singlestore-views.test.ts',
@@ -14,20 +15,21 @@ export default defineConfig({
 
 		// This one was excluded because we need to modify an API for SingleStore-generated columns.
 		// It’s in the backlog.
-		exclude: ['tests/**/singlestore-generated.test.ts'],
+		exclude: [
+			// 'tests/mssql/**/*.test.ts',
+			// 'tests/cockroach/**/*.test.ts',
+			'tests/**/singlestore-generated.test.ts',
+			'tests/singlestore/**/*.test.ts',
+			'tests/gel/**/*.test.ts',
+			// 'tests/cockroach/',
+		],
 
 		typecheck: {
 			tsconfig: 'tsconfig.json',
 		},
 		testTimeout: 100000,
 		hookTimeout: 100000,
-		isolate: true,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-		maxWorkers: 1,
+		maxConcurrency: 5,
 		fileParallelism: false,
 	},
 	plugins: [tsconfigPaths()],
diff --git a/drizzle-orm/pack.sh b/drizzle-orm/pack.sh
new file mode 100644
index 0000000000..ad607377a7
--- /dev/null
+++ b/drizzle-orm/pack.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+pnpm build
+
+cd dist
+pkg_file=$(npm pack | tail -n 1)
+
+pkg_path="$(pwd)/$pkg_file"
+
+if command -v pbcopy &>/dev/null; then
+  echo -n "$pkg_path" | pbcopy
+  echo "📦 Copied package path to clipboard:"
+elif command -v xclip &>/dev/null; then
+  echo -n "$pkg_path" | xclip -selection clipboard
+  echo "📦 Copied package path to clipboard:"
+elif command -v wl-copy &>/dev/null; then
+  echo -n "$pkg_path" | wl-copy
+  echo "📦 Copied package path to clipboard:"
+else
+  echo "⚠️ No clipboard tool found. Path:"
+fi
+
+echo "$pkg_path"
\ No newline at end of file
diff --git a/drizzle-orm/package.json b/drizzle-orm/package.json
index 3158dd8fc7..3460443d0e 100644
--- a/drizzle-orm/package.json
+++ b/drizzle-orm/package.json
@@ -1,15 +1,16 @@
 {
 	"name": "drizzle-orm",
-	"version": "0.44.1",
+	"version": "1.0.0-rc.4",
 	"description": "Drizzle ORM package for SQL databases",
 	"type": "module",
 	"scripts": {
-		"p": "prisma generate --schema src/prisma/schema.prisma",
-		"build": "pnpm p && scripts/build.ts",
+		"build": "bun --bun run scripts/build.ts",
+		"build:artifact": "pnpm build",
 		"b": "pnpm build",
 		"test:types": "cd type-tests && tsc",
 		"test": "vitest run",
 		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
+		"pack:artifact": "pnpm run pack",
 		"publish": "npm publish package.tgz"
 	},
 	"main": "./index.cjs",
@@ -47,6 +48,15 @@
 	"peerDependencies": {
 		"@aws-sdk/client-rds-data": ">=3",
 		"@cloudflare/workers-types": ">=4",
+		"@effect/sql-d1": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-libsql": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-mysql2": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-pg": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-pglite": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-sqlite-bun": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-sqlite-do": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-sqlite-node": ">=4.0.0-beta.83 || >=4.0.0",
+		"@effect/sql-sqlite-wasm": ">=4.0.0-beta.83 || >=4.0.0",
 		"@electric-sql/pglite": ">=0.2.0",
 		"@libsql/client": ">=0.10.0",
 		"@libsql/client-wasm": ">=0.10.0",
@@ -54,27 +64,46 @@
 		"@op-engineering/op-sqlite": ">=2",
 		"@opentelemetry/api": "^1.4.1",
 		"@planetscale/database": ">=1.13",
-		"@prisma/client": "*",
+		"@sinclair/typebox": ">=0.34.8",
+		"@sqlitecloud/drivers": ">=1.0.653",
 		"@tidbcloud/serverless": "*",
+		"@tursodatabase/database": ">=0.6.0-pre.28 || >=0.6.0",
+		"@tursodatabase/database-common": ">=0.6.0-pre.28 || >=0.6.0",
+		"@tursodatabase/database-wasm": ">=0.6.0-pre.28 || >=0.6.0",
+		"@tursodatabase/serverless": ">=1.1.3",
+		"@tursodatabase/sync": ">=0.6.0-pre.28 || >=0.6.0",
 		"@types/better-sqlite3": "*",
+		"@types/mssql": "^9.1.4",
 		"@types/pg": "*",
 		"@types/sql.js": "*",
+		"@upstash/redis": ">=1.34.7",
 		"@vercel/postgres": ">=0.8.0",
 		"@xata.io/client": "*",
-		"better-sqlite3": ">=7",
+		"arktype": ">=2.0.0",
+		"better-sqlite3": ">=9.3.0",
 		"bun-types": "*",
+		"effect": ">=4.0.0-beta.83 || >=4.0.0",
 		"expo-sqlite": ">=14.0.0",
-		"knex": "*",
-		"kysely": "*",
+		"mssql": "^11.0.1",
 		"mysql2": ">=2",
 		"pg": ">=8",
 		"postgres": ">=3",
 		"sql.js": ">=1",
 		"sqlite3": ">=5",
-		"gel": ">=2",
-		"@upstash/redis": ">=1.34.7"
+		"typebox": ">=1.0.0",
+		"valibot": ">=1.0.0-beta.7",
+		"zod": "^3.25.0 || ^4.0.0"
 	},
 	"peerDependenciesMeta": {
+		"@types/mssql": {
+			"optional": true
+		},
+		"mssql": {
+			"optional": true
+		},
+		"arktype": {
+			"optional": true
+		},
 		"mysql2": {
 			"optional": true
 		},
@@ -123,12 +152,6 @@
 		"@planetscale/database": {
 			"optional": true
 		},
-		"knex": {
-			"optional": true
-		},
-		"kysely": {
-			"optional": true
-		},
 		"@libsql/client": {
 			"optional": true
 		},
@@ -141,32 +164,93 @@
 		"expo-sqlite": {
 			"optional": true
 		},
-		"gel": {
-			"optional": true
-		},
 		"@op-engineering/op-sqlite": {
 			"optional": true
 		},
 		"@electric-sql/pglite": {
 			"optional": true
 		},
+		"@sqlitecloud/drivers": {
+			"optional": true
+		},
 		"@tidbcloud/serverless": {
 			"optional": true
 		},
-		"prisma": {
+		"@sinclair/typebox": {
+			"optional": true
+		},
+		"@tursodatabase/database": {
+			"optional": true
+		},
+		"@tursodatabase/sync": {
 			"optional": true
 		},
-		"@prisma/client": {
+		"@tursodatabase/database-wasm": {
+			"optional": true
+		},
+		"@tursodatabase/database-common": {
+			"optional": true
+		},
+		"@tursodatabase/serverless": {
 			"optional": true
 		},
 		"@upstash/redis": {
 			"optional": true
+		},
+		"effect": {
+			"optional": true
+		},
+		"@effect/sql-d1": {
+			"optional": true
+		},
+		"@effect/sql-mysql2": {
+			"optional": true
+		},
+		"@effect/sql-pg": {
+			"optional": true
+		},
+		"@effect/sql-pglite": {
+			"optional": true
+		},
+		"@effect/sql-sqlite-bun": {
+			"optional": true
+		},
+		"@effect/sql-sqlite-do": {
+			"optional": true
+		},
+		"@effect/sql-sqlite-node": {
+			"optional": true
+		},
+		"@effect/sql-sqlite-wasm": {
+			"optional": true
+		},
+		"@effect/sql-libsql": {
+			"optional": true
+		},
+		"typebox": {
+			"optional": true
+		},
+		"valibot": {
+			"optional": true
+		},
+		"zod": {
+			"optional": true
 		}
 	},
 	"devDependencies": {
-		"@aws-sdk/client-rds-data": "^3.549.0",
-		"@cloudflare/workers-types": "^4.20241112.0",
-		"@electric-sql/pglite": "^0.2.12",
+		"@arktype/attest": "^0.46.0",
+		"@aws-sdk/client-rds-data": "^3.914.0",
+		"@cloudflare/workers-types": "^4.20251004.0",
+		"@effect/sql-d1": "4.0.0-beta.83",
+		"@effect/sql-libsql": "4.0.0-beta.83",
+		"@effect/sql-mysql2": "4.0.0-beta.83",
+		"@effect/sql-pg": "4.0.0-beta.83",
+		"@effect/sql-pglite": "4.0.0-beta.83",
+		"@effect/sql-sqlite-bun": "4.0.0-beta.83",
+		"@effect/sql-sqlite-do": "4.0.0-beta.83",
+		"@effect/sql-sqlite-node": "4.0.0-beta.83",
+		"@effect/sql-sqlite-wasm": "4.0.0-beta.83",
+		"@electric-sql/pglite": "^0.4.6",
 		"@libsql/client": "^0.10.0",
 		"@libsql/client-wasm": "^0.10.0",
 		"@miniflare/d1": "^2.14.4",
@@ -176,36 +260,40 @@
 		"@originjs/vite-plugin-commonjs": "^1.0.3",
 		"@planetscale/database": "^1.16.0",
 		"@prisma/client": "5.14.0",
+		"@sinclair/typebox": "^0.34.48",
+		"@sqlitecloud/drivers": "^1.0.653",
 		"@tidbcloud/serverless": "^0.1.1",
+		"@tursodatabase/database": "0.6.0-pre.28",
+		"@tursodatabase/database-common": "0.6.0-pre.28",
+		"@tursodatabase/database-wasm": "0.6.0-pre.28",
+		"@tursodatabase/serverless": "1.1.3",
+		"@tursodatabase/sync": "0.6.0",
 		"@types/better-sqlite3": "^7.6.12",
-		"@types/node": "^20.2.5",
+		"@types/node": "^25.4.0",
 		"@types/pg": "^8.10.1",
 		"@types/react": "^18.2.45",
 		"@types/sql.js": "^1.4.4",
 		"@upstash/redis": "^1.34.3",
 		"@vercel/postgres": "^0.8.0",
 		"@xata.io/client": "^0.29.3",
+		"arktype": "^2.1.10",
 		"better-sqlite3": "^11.9.1",
-		"bun-types": "^1.2.0",
+		"bun-types": "^1.2.23",
 		"cpy": "^10.1.0",
+		"effect": "4.0.0-beta.83",
 		"expo-sqlite": "^14.0.0",
-		"gel": "^2.0.0",
 		"glob": "^11.0.1",
-		"knex": "^2.4.2",
-		"kysely": "^0.25.0",
 		"mysql2": "^3.14.1",
 		"pg": "^8.11.0",
 		"postgres": "^3.3.5",
-		"prisma": "5.14.0",
 		"react": "^18.2.0",
 		"sql.js": "^1.8.0",
 		"sqlite3": "^5.1.2",
 		"ts-morph": "^25.0.1",
 		"tslib": "^2.5.2",
 		"tsx": "^3.12.7",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
-		"zod": "^3.20.2",
-		"zx": "^7.2.2"
+		"typebox": "^1.0.80",
+		"valibot": "1.0.0-beta.7",
+		"zod": "^3.20.2"
 	}
 }
diff --git a/drizzle-orm/scripts/build.ts b/drizzle-orm/scripts/build.ts
index 393719f31a..0ca93395d2 100755
--- a/drizzle-orm/scripts/build.ts
+++ b/drizzle-orm/scripts/build.ts
@@ -1,11 +1,14 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
+#!/usr/bin/env bun
+import { $ } from 'bun';
+import { globSync } from 'glob';
+import { mkdirSync, renameSync, rmSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import { build as tsdown } from 'tsdown';
 
-async function updateAndCopyPackageJson() {
-	const pkg = await fs.readJSON('package.json');
+const entries = globSync('src/**/*.ts', { ignore: ['src/**/*.test.ts'] });
 
-	const entries = await glob('src/**/*.ts');
+async function updateAndCopyPackageJson() {
+	const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
 
 	pkg.exports = entries.reduce<
 		Record<string, {
@@ -43,34 +46,51 @@ async function updateAndCopyPackageJson() {
 		{},
 	);
 
-	await fs.writeJSON('dist.new/package.json', pkg, { spaces: 2 });
+	await fs.writeFile('dist.new/package.json', JSON.stringify(pkg, null, 2));
 }
 
-await fs.remove('dist.new');
+async function main() {
+	const startTime = Date.now();
 
-await Promise.all([
-	(async () => {
-		await $`tsup`.stdio('pipe', 'pipe', 'pipe');
-	})(),
-	(async () => {
-		await $`tsc -p tsconfig.dts.json`.stdio('pipe', 'pipe', 'pipe');
-		await cpy('dist-dts/**/*.d.ts', 'dist.new', {
-			rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-		});
-		await cpy('dist-dts/**/*.d.ts', 'dist.new', {
-			rename: (basename) => basename.replace(/\.d\.ts$/, '.d.ts'),
-		});
-	})(),
-]);
+	rmSync('dist.new', { recursive: true, force: true });
+	mkdirSync('dist.new', { recursive: true });
 
-await Promise.all([
-	$`tsup src/version.ts --no-config --dts --format esm --outDir dist.new`.stdio('pipe', 'pipe', 'pipe'),
-	$`tsup src/version.ts --no-config --dts --format cjs --outDir dist.new`.stdio('pipe', 'pipe', 'pipe'),
-]);
+	await tsdown({
+		entry: entries,
+		outDir: './dist.new',
+		format: ['cjs', 'es'],
+		unbundle: true,
+		platform: 'node',
+		external: [/^[^./]/], // everything?
+		tsconfig: 'tsconfig.json',
+		sourcemap: true,
+		dts: true,
+		clean: false,
+		alias: {
+			'~': './src',
+		},
+		outExtensions: (ctx) => {
+			if (ctx.format === 'cjs') {
+				return { js: '.cjs', dts: '.d.cts' };
+			}
+			return { js: '.js', dts: '.d.ts' };
+		},
+	});
 
-await $`scripts/fix-imports.ts`;
+	await $`bun scripts/fix-imports.ts`.quiet();
+	await Promise.all([
+		fs.copyFile('../README.md', 'dist.new/README.md'),
+		updateAndCopyPackageJson(),
+	]);
+
+	rmSync('dist', { recursive: true, force: true });
+	renameSync('dist.new', 'dist');
+
+	const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+	console.log(`Build complete ${elapsed}s`);
+}
 
-await fs.copy('../README.md', 'dist.new/README.md');
-await updateAndCopyPackageJson();
-await fs.remove('dist');
-await fs.rename('dist.new', 'dist');
+main().catch((e) => {
+	console.error(e);
+	process.exit(1);
+}).then(() => process.exit(0));
diff --git a/drizzle-orm/scripts/fix-imports.ts b/drizzle-orm/scripts/fix-imports.ts
index 6fc63a48f9..aa35a61d37 100755
--- a/drizzle-orm/scripts/fix-imports.ts
+++ b/drizzle-orm/scripts/fix-imports.ts
@@ -1,16 +1,13 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-
+#!/usr/bin/env bun
+import { Glob } from 'bun';
+import fs from 'node:fs/promises';
 import path from 'node:path';
-import { parse, print, visit } from 'recast';
-import parser from 'recast/parsers/typescript';
 
 function resolvePathAlias(importPath: string, file: string) {
 	if (importPath.startsWith('~/')) {
 		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
-		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
+		return relativePath.startsWith('.') ? relativePath : './' + relativePath;
 	}
-
 	return importPath;
 }
 
@@ -24,78 +21,42 @@ function fixImportPath(importPath: string, file: string, ext: string) {
 	return importPath.replace(/\.(js|ts)$/, ext);
 }
 
-const cjsFiles = await glob('dist.new/**/*.{cjs,d.cts}');
-
-await Promise.all(cjsFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
+async function processFile(file: string, ext: string) {
+	let code = await fs.readFile(file, 'utf8');
 
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitCallExpression(path) {
-			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
-				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-	});
+	// Handle: import ... from "path" / export ... from "path" / export * from "path"
+	code = code.replace(
+		/(from\s+["'])([^"']+)(["'])/g,
+		(_, prefix, importPath, suffix) => prefix + fixImportPath(importPath, file, ext) + suffix,
+	);
 
-	await fs.writeFile(file, print(code).code);
-}));
+	// Handle: require("path")
+	code = code.replace(
+		/(require\s*\(\s*["'])([^"']+)(["']\s*\))/g,
+		(_, prefix, importPath, suffix) => prefix + fixImportPath(importPath, file, ext) + suffix,
+	);
 
-const esmFiles = await glob('dist.new/**/*.{js,d.ts}');
+	// Handle: import("path") - dynamic imports
+	code = code.replace(
+		/(import\s*\(\s*["'])([^"']+)(["']\s*\))/g,
+		(_, prefix, importPath, suffix) => prefix + fixImportPath(importPath, file, ext) + suffix,
+	);
 
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
+	await fs.writeFile(file, code);
+}
 
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.js');
-			}
-			this.traverse(path);
-		},
-	});
+// Process CJS files
+const cjsGlob = new Glob('dist.new/**/*.{cjs,d.cts}');
+const cjsFiles: string[] = [];
+for await (const file of cjsGlob.scan('.')) {
+	cjsFiles.push(file);
+}
+await Promise.all(cjsFiles.map((file) => processFile(file, '.cjs')));
 
-	await fs.writeFile(file, print(code).code);
-}));
+// Process ESM files
+const esmGlob = new Glob('dist.new/**/*.{js,d.ts}');
+const esmFiles: string[] = [];
+for await (const file of esmGlob.scan('.')) {
+	esmFiles.push(file);
+}
+await Promise.all(esmFiles.map((file) => processFile(file, '.js')));
diff --git a/drizzle-orm/src/_relations.ts b/drizzle-orm/src/_relations.ts
new file mode 100644
index 0000000000..6534db85f6
--- /dev/null
+++ b/drizzle-orm/src/_relations.ts
@@ -0,0 +1,797 @@
+import { type AnyTable, getTableUniqueName, type InferModelFromColumns, Table } from '~/table.ts';
+import { type AnyColumn, Column } from './column.ts';
+import { entityKind, is } from './entity.ts';
+import { PrimaryKeyBuilder } from './pg-core/primary-keys.ts';
+import {
+	and,
+	asc,
+	between,
+	desc,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNotNull,
+	isNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notIlike,
+	notInArray,
+	notLike,
+	or,
+} from './sql/expressions/index.ts';
+import { type CommentInput, type Placeholder, SQL, sql } from './sql/sql.ts';
+import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from './utils.ts';
+
+export abstract class Relation<TTableName extends string = string> {
+	static readonly [entityKind]: string = 'Relation';
+
+	declare readonly $brand: 'Relation';
+	readonly referencedTableName: TTableName;
+	fieldName!: string;
+
+	constructor(
+		readonly sourceTable: Table,
+		readonly referencedTable: AnyTable<{ name: TTableName }>,
+		readonly relationName: string | undefined,
+	) {
+		this.referencedTableName = referencedTable[Table.Symbol.Name] as TTableName;
+	}
+
+	abstract withFieldName(fieldName: string): Relation<TTableName>;
+}
+
+export class Relations<
+	TTableName extends string = string,
+	TConfig extends Record<string, Relation> = Record<string, Relation>,
+> {
+	static readonly [entityKind]: string = 'Relations';
+
+	declare readonly $brand: 'Relations';
+
+	constructor(
+		readonly table: AnyTable<{ name: TTableName }>,
+		readonly config: (helpers: TableRelationsHelpers<TTableName>) => TConfig,
+	) {}
+}
+
+export class One<
+	TTableName extends string = string,
+	TIsNullable extends boolean = boolean,
+> extends Relation<TTableName> {
+	static override readonly [entityKind]: string = 'One';
+
+	declare protected $relationBrand: 'One';
+
+	constructor(
+		sourceTable: Table,
+		referencedTable: AnyTable<{ name: TTableName }>,
+		readonly config:
+			| RelationConfig<
+				TTableName,
+				string,
+				AnyColumn<{ tableName: TTableName }>[]
+			>
+			| undefined,
+		readonly isNullable: TIsNullable,
+	) {
+		super(sourceTable, referencedTable, config?.relationName);
+	}
+
+	withFieldName(fieldName: string): One<TTableName> {
+		const relation = new One(
+			this.sourceTable,
+			this.referencedTable,
+			this.config,
+			this.isNullable,
+		);
+		relation.fieldName = fieldName;
+		return relation;
+	}
+}
+
+export class Many<TTableName extends string> extends Relation<TTableName> {
+	static override readonly [entityKind]: string = 'Many';
+
+	declare protected $relationBrand: 'Many';
+
+	constructor(
+		sourceTable: Table,
+		referencedTable: AnyTable<{ name: TTableName }>,
+		readonly config: { relationName: string } | undefined,
+	) {
+		super(sourceTable, referencedTable, config?.relationName);
+	}
+
+	withFieldName(fieldName: string): Many<TTableName> {
+		const relation = new Many(
+			this.sourceTable,
+			this.referencedTable,
+			this.config,
+		);
+		relation.fieldName = fieldName;
+		return relation;
+	}
+}
+
+export type TableRelationsKeysOnly<
+	TSchema extends Record<string, unknown>,
+	TTableName extends string,
+	K extends keyof TSchema,
+> = TSchema[K] extends Relations<TTableName> ? K : never;
+
+export type ExtractTableRelationsFromSchema<
+	TSchema extends Record<string, unknown>,
+	TTableName extends string,
+> = ExtractObjectValues<
+	{
+		[
+			K in keyof TSchema as TableRelationsKeysOnly<
+				TSchema,
+				TTableName,
+				K
+			>
+		]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never;
+	}
+>;
+
+export type ExtractObjectValues<T> = T[keyof T];
+
+export type ExtractRelationsFromTableExtraConfigSchema<
+	TConfig extends unknown[],
+> = ExtractObjectValues<
+	{
+		[
+			K in keyof TConfig as TConfig[K] extends Relations<any> ? K
+				: never
+		]: TConfig[K] extends Relations<infer TRelationConfig> ? TRelationConfig
+			: never;
+	}
+>;
+
+export function getOperators() {
+	return {
+		and,
+		between,
+		eq,
+		exists,
+		gt,
+		gte,
+		ilike,
+		inArray,
+		isNull,
+		isNotNull,
+		like,
+		lt,
+		lte,
+		ne,
+		not,
+		notBetween,
+		notExists,
+		notLike,
+		notIlike,
+		notInArray,
+		or,
+		sql,
+	};
+}
+
+export type Operators = ReturnType<typeof getOperators>;
+
+export function getOrderByOperators() {
+	return {
+		sql,
+		asc,
+		desc,
+	};
+}
+
+export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
+
+export type FindTableByDBName<
+	TSchema extends TablesRelationalConfig,
+	TTableName extends string,
+> = ExtractObjectValues<
+	{
+		[
+			K in keyof TSchema as TSchema[K]['dbName'] extends TTableName ? K
+				: never
+		]: TSchema[K];
+	}
+>;
+
+export type DBQueryConfig<
+	TRelationType extends 'one' | 'many' = 'one' | 'many',
+	TIsRoot extends boolean = boolean,
+	TSchema extends TablesRelationalConfig = TablesRelationalConfig,
+	TTableConfig extends TableRelationalConfig = TableRelationalConfig,
+> =
+	& {
+		columns?:
+			| {
+				[K in keyof TTableConfig['columns']]?: boolean;
+			}
+			| undefined;
+		with?:
+			| {
+				[K in keyof TTableConfig['relations']]?:
+					| true
+					| DBQueryConfig<
+						TTableConfig['relations'][K] extends One ? 'one' : 'many',
+						false,
+						TSchema,
+						FindTableByDBName<
+							TSchema,
+							TTableConfig['relations'][K]['referencedTableName']
+						>
+					>
+					| undefined;
+			}
+			| undefined;
+		extras?:
+			| Record<string, SQL.Aliased>
+			| ((
+				fields: Simplify<
+					[TTableConfig['columns']] extends [never] ? {}
+						: TTableConfig['columns']
+				>,
+				operators: { sql: Operators['sql'] },
+			) => Record<string, SQL.Aliased>)
+			| undefined;
+	}
+	& (TRelationType extends 'many' ?
+			& {
+				where?:
+					| SQL
+					| undefined
+					| ((
+						fields: Simplify<
+							[TTableConfig['columns']] extends [never] ? {}
+								: TTableConfig['columns']
+						>,
+						operators: Operators,
+					) => SQL | undefined);
+				orderBy?:
+					| ValueOrArray<AnyColumn | SQL>
+					| ((
+						fields: Simplify<
+							[TTableConfig['columns']] extends [never] ? {}
+								: TTableConfig['columns']
+						>,
+						operators: OrderByOperators,
+					) => ValueOrArray<AnyColumn | SQL>)
+					| undefined;
+				limit?: number | Placeholder | undefined;
+			}
+			& (TIsRoot extends true ? {
+					offset?: number | Placeholder | undefined;
+				}
+				: {})
+		: {});
+
+export type DBQueryConfigWithComment<
+	TRelationType extends 'one' | 'many' = 'one' | 'many',
+	TIsRoot extends boolean = boolean,
+	TSchema extends TablesRelationalConfig = TablesRelationalConfig,
+	TTableConfig extends TableRelationalConfig = TableRelationalConfig,
+> = DBQueryConfig<TRelationType, TIsRoot, TSchema, TTableConfig> & { comment?: CommentInput | undefined };
+
+export interface TableRelationalConfig {
+	tsName: string;
+	dbName: string;
+	columns: Record<string, Column>;
+	relations: Record<string, Relation>;
+	primaryKey: AnyColumn[];
+	schema?: string;
+}
+
+export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
+
+export interface RelationalSchemaConfig<
+	TSchema extends TablesRelationalConfig,
+> {
+	fullSchema: Record<string, unknown>;
+	schema: TSchema;
+	tableNamesMap: Record<string, string>;
+}
+
+export type ExtractTablesWithRelations<
+	TSchema extends Record<string, unknown>,
+> = {
+	[
+		K in keyof TSchema as TSchema[K] extends Table ? K
+			: never
+	]: TSchema[K] extends Table ? {
+			tsName: K & string;
+			dbName: TSchema[K]['_']['name'];
+			columns: TSchema[K]['_']['columns'];
+			relations: ExtractTableRelationsFromSchema<
+				TSchema,
+				TSchema[K]['_']['name']
+			>;
+			primaryKey: AnyColumn[];
+		}
+		: never;
+};
+
+export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R
+	: T;
+
+export type BuildRelationResult<
+	TSchema extends TablesRelationalConfig,
+	TInclude,
+	TRelations extends Record<string, Relation>,
+> = {
+	[
+		K in
+			& NonUndefinedKeysOnly<TInclude>
+			& keyof TRelations
+	]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<
+			TSchema,
+			FindTableByDBName<TSchema, TRel['referencedTableName']>,
+			Assume<TInclude[K], true | Record<string, unknown>>
+		> extends infer TResult ? TRel extends One ?
+					| TResult
+					| (Equal<TRel['isNullable'], false> extends true ? null : never)
+			: TResult[]
+		: never
+		: never;
+};
+
+export type NonUndefinedKeysOnly<T> =
+	& ExtractObjectValues<
+		{
+			[K in keyof T as T[K] extends undefined ? never : K]: K;
+		}
+	>
+	& keyof T;
+
+export type BuildQueryResult<
+	TSchema extends TablesRelationalConfig,
+	TTableConfig extends TableRelationalConfig,
+	TFullSelection extends true | Record<string, unknown>,
+> = Equal<TFullSelection, true> extends true ? InferModelFromColumns<TTableConfig['columns']>
+	: TFullSelection extends Record<string, unknown> ? Simplify<
+			& (TFullSelection['columns'] extends Record<string, unknown> ? InferModelFromColumns<
+					{
+						[
+							K in Equal<
+								Exclude<
+									TFullSelection['columns'][
+										& keyof TFullSelection['columns']
+										& keyof TTableConfig['columns']
+									],
+									undefined
+								>,
+								false
+							> extends true ? Exclude<
+									keyof TTableConfig['columns'],
+									NonUndefinedKeysOnly<TFullSelection['columns']>
+								>
+								:
+									& {
+										[K in keyof TFullSelection['columns']]: Equal<
+											TFullSelection['columns'][K],
+											true
+										> extends true ? K
+											: never;
+									}[keyof TFullSelection['columns']]
+									& keyof TTableConfig['columns']
+						]: TTableConfig['columns'][K];
+					}
+				>
+				: InferModelFromColumns<TTableConfig['columns']>)
+			& (TFullSelection['extras'] extends
+				| Record<string, unknown>
+				| ((...args: any[]) => Record<string, unknown>) ? {
+					[
+						K in NonUndefinedKeysOnly<
+							ReturnTypeOrValue<TFullSelection['extras']>
+						>
+					]: Assume<
+						ReturnTypeOrValue<TFullSelection['extras']>[K],
+						SQL.Aliased
+					>['_']['type'];
+				}
+				: {})
+			& (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<
+					TSchema,
+					TFullSelection['with'],
+					TTableConfig['relations']
+				>
+				: {})
+		>
+	: never;
+
+export interface RelationConfig<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends AnyColumn<{ tableName: TTableName }>[],
+> {
+	relationName?: string;
+	fields: TColumns;
+	references: ColumnsWithTable<TTableName, TForeignTableName, TColumns>;
+}
+
+export function extractTablesRelationalConfig<
+	TTables extends TablesRelationalConfig,
+>(
+	schema: Record<string, unknown>,
+	configHelpers: (table: Table) => any,
+): { tables: TTables; tableNamesMap: Record<string, string> } {
+	if (
+		Object.keys(schema).length === 1
+		&& 'default' in schema
+		&& !is(schema['default'], Table)
+	) {
+		schema = schema['default'] as Record<string, unknown>;
+	}
+
+	// table DB name -> schema table key
+	const tableNamesMap: Record<string, string> = {};
+	// Table relations found before their tables - need to buffer them until we know the schema table key
+	const relationsBuffer: Record<
+		string,
+		{ relations: Record<string, Relation>; primaryKey?: AnyColumn[] }
+	> = {};
+	const tablesConfig: TablesRelationalConfig = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (is(value, Table)) {
+			const dbName = getTableUniqueName(value);
+			const bufferedRelations = relationsBuffer[dbName];
+			tableNamesMap[dbName] = key;
+			tablesConfig[key] = {
+				tsName: key,
+				dbName: value[Table.Symbol.Name],
+				schema: value[Table.Symbol.Schema],
+				columns: value[Table.Symbol.Columns],
+				relations: bufferedRelations?.relations ?? {},
+				primaryKey: bufferedRelations?.primaryKey ?? [],
+			};
+
+			// Fill in primary keys
+			for (
+				const column of Object.values(
+					(value as Table)[Table.Symbol.Columns],
+				)
+			) {
+				if (column.primary) {
+					tablesConfig[key]!.primaryKey.push(column);
+				}
+			}
+
+			const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.((value as Table)[Table.Symbol.ExtraConfigColumns]);
+			if (extraConfig) {
+				for (const configEntry of Object.values(extraConfig)) {
+					if (is(configEntry, PrimaryKeyBuilder)) {
+						tablesConfig[key]!.primaryKey.push(...configEntry.columns);
+					}
+				}
+			}
+		} else if (is(value, Relations)) {
+			const dbName = getTableUniqueName(value.table);
+			const tableName = tableNamesMap[dbName];
+			const relations: Record<string, Relation> = value.config(
+				configHelpers(value.table),
+			);
+			// let primaryKey: AnyColumn[] | undefined;
+
+			for (const [relationName, relation] of Object.entries(relations)) {
+				if (tableName) {
+					const tableConfig = tablesConfig[tableName]!;
+					tableConfig.relations[relationName] = relation;
+					// if (primaryKey) {
+					// 	tableConfig.primaryKey.push(...primaryKey);
+					// }
+				} else {
+					if (!(dbName in relationsBuffer)) {
+						relationsBuffer[dbName] = {
+							relations: {},
+							// primaryKey,
+						};
+					}
+					relationsBuffer[dbName]!.relations[relationName] = relation;
+				}
+			}
+		}
+	}
+
+	return { tables: tablesConfig as TTables, tableNamesMap };
+}
+
+export function relations<
+	TTableName extends string,
+	TRelations extends Record<string, Relation<any>>,
+>(
+	table: AnyTable<{ name: TTableName }>,
+	relations: (helpers: TableRelationsHelpers<TTableName>) => TRelations,
+): Relations<TTableName, TRelations> {
+	return new Relations<TTableName, TRelations>(
+		table,
+		(helpers: TableRelationsHelpers<TTableName>) =>
+			Object.fromEntries(
+				Object.entries(relations(helpers)).map(([key, value]) => [
+					key,
+					value.withFieldName(key),
+				]),
+			) as TRelations,
+	);
+}
+
+export function createOne<TTableName extends string>(sourceTable: Table) {
+	return function one<
+		TForeignTable extends Table,
+		TColumns extends [
+			AnyColumn<{ tableName: TTableName }>,
+			...AnyColumn<{ tableName: TTableName }>[],
+		],
+	>(
+		table: TForeignTable,
+		config?: RelationConfig<TTableName, TForeignTable['_']['name'], TColumns>,
+	): One<
+		TForeignTable['_']['name'],
+		Equal<TColumns[number]['_']['notNull'], true>
+	> {
+		return new One(
+			sourceTable,
+			table,
+			config,
+			(config?.fields.reduce<boolean>((res, f) => res && f.notNull, true)
+				?? false) as Equal<TColumns[number]['_']['notNull'], true>,
+		);
+	};
+}
+
+export function createMany(sourceTable: Table) {
+	return function many<TForeignTable extends Table>(
+		referencedTable: TForeignTable,
+		config?: { relationName: string },
+	): Many<TForeignTable['_']['name']> {
+		return new Many(sourceTable, referencedTable, config);
+	};
+}
+
+export interface NormalizedRelation {
+	fields: AnyColumn[];
+	references: AnyColumn[];
+}
+
+export function normalizeRelation(
+	schema: TablesRelationalConfig,
+	tableNamesMap: Record<string, string>,
+	relation: Relation,
+): NormalizedRelation {
+	if (is(relation, One) && relation.config) {
+		return {
+			fields: relation.config.fields,
+			references: relation.config.references,
+		};
+	}
+
+	const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
+	if (!referencedTableTsName) {
+		throw new Error(
+			`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`,
+		);
+	}
+
+	const referencedTableConfig = schema[referencedTableTsName];
+	if (!referencedTableConfig) {
+		throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+	}
+
+	const sourceTable = relation.sourceTable;
+	const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
+	if (!sourceTableTsName) {
+		throw new Error(
+			`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`,
+		);
+	}
+
+	const reverseRelations: Relation[] = [];
+	for (
+		const referencedTableRelation of Object.values(
+			referencedTableConfig.relations,
+		)
+	) {
+		if (
+			(relation.relationName
+				&& relation !== referencedTableRelation
+				&& referencedTableRelation.relationName === relation.relationName)
+			|| (!relation.relationName
+				&& referencedTableRelation.referencedTable === relation.sourceTable)
+		) {
+			reverseRelations.push(referencedTableRelation);
+		}
+	}
+
+	if (reverseRelations.length > 1) {
+		throw relation.relationName
+			? new Error(
+				`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`,
+			)
+			: new Error(
+				`There are multiple relations between "${referencedTableTsName}" and "${
+					relation.sourceTable[Table.Symbol.Name]
+				}". Please specify relation name`,
+			);
+	}
+
+	if (
+		reverseRelations[0]
+		&& is(reverseRelations[0], One)
+		&& reverseRelations[0].config
+	) {
+		return {
+			fields: reverseRelations[0].config.references,
+			references: reverseRelations[0].config.fields,
+		};
+	}
+
+	throw new Error(
+		`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`,
+	);
+}
+
+export function createTableRelationsHelpers<TTableName extends string>(
+	sourceTable: AnyTable<{ name: TTableName }>,
+) {
+	return {
+		one: createOne<TTableName>(sourceTable),
+		many: createMany(sourceTable),
+	};
+}
+
+export type TableRelationsHelpers<TTableName extends string> = ReturnType<
+	typeof createTableRelationsHelpers<TTableName>
+>;
+
+export interface BuildRelationalQueryResult<
+	TTable extends Table = Table,
+	TColumn extends Column = Column,
+> {
+	tableTsKey: string;
+	selection: {
+		dbKey: string;
+		tsKey: string;
+		field: TColumn | SQL | SQL.Aliased;
+		relationTableTsKey: string | undefined;
+		isJson: boolean;
+		isExtra?: boolean;
+		selection: BuildRelationalQueryResult<TTable>['selection'];
+	}[];
+	sql: TTable | SQL;
+}
+
+export function mapRelationalRow(
+	tablesConfig: TablesRelationalConfig,
+	tableConfig: TableRelationalConfig,
+	row: unknown[],
+	buildQueryResultSelection: BuildRelationalQueryResult['selection'],
+	mapColumnValue: (value: unknown) => unknown = (value) => value,
+): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+
+	for (
+		const [
+			selectionItemIndex,
+			selectionItem,
+		] of buildQueryResultSelection.entries()
+	) {
+		if (selectionItem.isJson) {
+			const relation = tableConfig.relations[selectionItem.tsKey]!;
+			const rawSubRows = row[selectionItemIndex] as
+				| unknown[]
+				| null
+				| [null]
+				| string;
+			const subRows = typeof rawSubRows === 'string'
+				? (JSON.parse(rawSubRows) as unknown[])
+				: rawSubRows;
+			result[selectionItem.tsKey] = is(relation, One)
+				? subRows
+					&& mapRelationalRow(
+						tablesConfig,
+						tablesConfig[selectionItem.relationTableTsKey!]!,
+						subRows,
+						selectionItem.selection,
+						mapColumnValue,
+					)
+				: (subRows as unknown[][]).map((subRow) =>
+					mapRelationalRow(
+						tablesConfig,
+						tablesConfig[selectionItem.relationTableTsKey!]!,
+						subRow,
+						selectionItem.selection,
+						mapColumnValue,
+					)
+				);
+		} else {
+			const value = mapColumnValue(row[selectionItemIndex]);
+			const field = selectionItem.field!;
+			let decoder;
+			if (is(field, Column)) {
+				decoder = field;
+			} else if (is(field, SQL)) {
+				decoder = field.decoder;
+			} else {
+				decoder = field.sql.decoder;
+			}
+			result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
+		}
+	}
+
+	return result;
+}
+
+export function mapRelationalRowFromObj(
+	tablesConfig: TablesRelationalConfig,
+	tableConfig: TableRelationalConfig,
+	row: unknown[],
+	buildQueryResultSelection: BuildRelationalQueryResult['selection'],
+	mapColumnValue: (value: unknown) => unknown = (value) => value,
+): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+
+	for (
+		const [
+			selectionItemIndex,
+			selectionItem,
+		] of buildQueryResultSelection.entries()
+	) {
+		if (selectionItem.isJson) {
+			const relation = tableConfig.relations[selectionItem.tsKey]!;
+			const isOne = is(relation, One);
+			const rawSubRows = row[selectionItemIndex] as unknown[] | null | [null] | string;
+
+			let subRows = rawSubRows as unknown[] | null;
+			if (subRows || Array.isArray(subRows)) {
+				subRows = (typeof rawSubRows === 'string' ? JSON.parse(rawSubRows) : rawSubRows) as unknown[];
+
+				subRows = isOne
+					? subRows.flatMap((r) => Array.isArray(r) ? r : Object.values(r as any))
+					: subRows.map((r) => Array.isArray(r) ? r : Object.values(r as any));
+			}
+
+			result[selectionItem.tsKey] = isOne
+				? subRows
+					&& mapRelationalRowFromObj(
+						tablesConfig,
+						tablesConfig[selectionItem.relationTableTsKey!]!,
+						subRows,
+						selectionItem.selection,
+						mapColumnValue,
+					)
+				: ((subRows ?? []) as unknown[][]).map((subRow) =>
+					mapRelationalRowFromObj(
+						tablesConfig,
+						tablesConfig[selectionItem.relationTableTsKey!]!,
+						subRow,
+						selectionItem.selection,
+						mapColumnValue,
+					)
+				);
+		} else {
+			const value = mapColumnValue(row[selectionItemIndex]);
+			const field = selectionItem.field!;
+			let decoder;
+			if (is(field, Column)) {
+				decoder = field;
+			} else if (is(field, SQL)) {
+				decoder = field.decoder;
+			} else {
+				decoder = field.sql.decoder;
+			}
+			result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
+		}
+	}
+
+	return result;
+}
diff --git a/drizzle-orm/src/alias.ts b/drizzle-orm/src/alias.ts
index 21e802a1ce..2a5c1a2f73 100644
--- a/drizzle-orm/src/alias.ts
+++ b/drizzle-orm/src/alias.ts
@@ -1,30 +1,56 @@
+import type * as V1 from './_relations.ts';
+import { OriginalColumn } from './column-common.ts';
 import type { AnyColumn } from './column.ts';
 import { Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
-import type { Relation } from './relations.ts';
-import type { View } from './sql/sql.ts';
-import { SQL, sql } from './sql/sql.ts';
+import { View } from './sql/sql.ts';
+import { isSQLWrapper, SQL, sql } from './sql/sql.ts';
+import { Subquery } from './subquery.ts';
 import { Table } from './table.ts';
 import { ViewBaseConfig } from './view-common.ts';
 
-export class ColumnAliasProxyHandler<TColumn extends Column> implements ProxyHandler<TColumn> {
-	static readonly [entityKind]: string = 'ColumnAliasProxyHandler';
+export class ColumnTableAliasProxyHandler<TColumn extends Column> implements ProxyHandler<TColumn> {
+	static readonly [entityKind]: string = 'ColumnTableAliasProxyHandler';
 
-	constructor(private table: Table | View) {}
+	constructor(private table: Table | View, private ignoreColumnAlias?: boolean) {}
 
 	get(columnObj: TColumn, prop: string | symbol): any {
 		if (prop === 'table') {
 			return this.table;
 		}
 
+		if (prop === 'isAlias' && this.ignoreColumnAlias) {
+			return false;
+		}
+
 		return columnObj[prop as keyof TColumn];
 	}
 }
 
+export class ViewSelectionAliasProxyHandler<TSelection extends Record<string, unknown>>
+	implements ProxyHandler<TSelection>
+{
+	static readonly [entityKind]: string = 'ViewSelectionAliasProxyHandler';
+
+	constructor(protected view: View, protected selection: TSelection, private ignoreColumnAlias?: boolean) {}
+
+	get(selection: TSelection, prop: string | symbol): any {
+		const value = selection[prop as keyof TSelection];
+
+		if (is(value, Column)) return new Proxy(value, new ColumnTableAliasProxyHandler(this.view, this.ignoreColumnAlias));
+		if (
+			is(value, Subquery) || is(value, SQL) || is(value, SQL.Aliased) || isSQLWrapper(value)
+			|| (typeof value !== 'object' || value === null)
+		) return value;
+
+		return new Proxy(value as Record<string, unknown>, this);
+	}
+}
+
 export class TableAliasProxyHandler<T extends Table | View> implements ProxyHandler<T> {
 	static readonly [entityKind]: string = 'TableAliasProxyHandler';
 
-	constructor(private alias: string, private replaceOriginalName: boolean) {}
+	constructor(private alias: string, private replaceOriginalName: boolean, private ignoreColumnAlias?: boolean) {}
 
 	get(target: T, prop: string | symbol): any {
 		if (prop === Table.Symbol.IsAlias) {
@@ -44,6 +70,14 @@ export class TableAliasProxyHandler<T extends Table | View> implements ProxyHand
 				...target[ViewBaseConfig as keyof typeof target],
 				name: this.alias,
 				isAlias: true,
+				selectedFields: new Proxy(
+					(<View> target)[ViewBaseConfig].selectedFields,
+					new ViewSelectionAliasProxyHandler(
+						new Proxy(target, this) as View,
+						(<View> target)[ViewBaseConfig].selectedFields,
+						this.ignoreColumnAlias,
+					),
+				),
 			};
 		}
 
@@ -53,12 +87,23 @@ export class TableAliasProxyHandler<T extends Table | View> implements ProxyHand
 				return columns;
 			}
 
+			if (is(target, View)) {
+				return new Proxy(
+					(<View> target)[Table.Symbol.Columns],
+					new ViewSelectionAliasProxyHandler(
+						new Proxy(target, this) as View,
+						(<View> target)[Table.Symbol.Columns],
+						this.ignoreColumnAlias,
+					),
+				);
+			}
+
 			const proxiedColumns: { [key: string]: any } = {};
 
 			Object.keys(columns).map((key) => {
 				proxiedColumns[key] = new Proxy(
 					columns[key]!,
-					new ColumnAliasProxyHandler(new Proxy(target, this)),
+					new ColumnTableAliasProxyHandler(new Proxy(target, this), this.ignoreColumnAlias),
 				);
 			});
 
@@ -67,14 +112,43 @@ export class TableAliasProxyHandler<T extends Table | View> implements ProxyHand
 
 		const value = target[prop as keyof typeof target];
 		if (is(value, Column)) {
-			return new Proxy(value as AnyColumn, new ColumnAliasProxyHandler(new Proxy(target, this)));
+			return new Proxy(
+				value as AnyColumn,
+				new ColumnTableAliasProxyHandler(new Proxy(target, this), this.ignoreColumnAlias),
+			);
 		}
 
 		return value;
 	}
 }
 
-export class RelationTableAliasProxyHandler<T extends Relation> implements ProxyHandler<T> {
+export class ColumnAliasProxyHandler<T extends Column> implements ProxyHandler<T> {
+	static readonly [entityKind]: string = 'ColumnAliasProxyHandler';
+
+	constructor(private alias: string) {}
+
+	get(target: T, prop: keyof Column): any {
+		if (prop === 'isAlias') {
+			return true;
+		}
+
+		if (prop === 'name') {
+			return this.alias;
+		}
+
+		if (prop === 'keyAsName') {
+			return false;
+		}
+
+		if (prop === OriginalColumn) {
+			return () => target;
+		}
+
+		return target[prop];
+	}
+}
+
+export class RelationTableAliasProxyHandler<T extends V1.Relation> implements ProxyHandler<T> {
 	static readonly [entityKind]: string = 'RelationTableAliasProxyHandler';
 
 	constructor(private alias: string) {}
@@ -88,21 +162,25 @@ export class RelationTableAliasProxyHandler<T extends Relation> implements Proxy
 	}
 }
 
-export function aliasedTable<T extends Table | View>(
-	table: T,
-	tableAlias: string,
-): T {
-	return new Proxy(table, new TableAliasProxyHandler(tableAlias, false)) as any;
+export function aliasedTable<T extends Table | View>(table: T, tableAlias: string): T {
+	return new Proxy(table, new TableAliasProxyHandler(tableAlias, false, false));
+}
+
+export function aliasedColumn<T extends Column>(column: T, alias: string): T {
+	return new Proxy(column, new ColumnAliasProxyHandler(alias));
 }
 
-export function aliasedRelation<T extends Relation>(relation: T, tableAlias: string): T {
+export function aliasedRelation<T extends V1.Relation>(relation: T, tableAlias: string): T {
 	return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));
 }
 
 export function aliasedTableColumn<T extends AnyColumn>(column: T, tableAlias: string): T {
 	return new Proxy(
 		column,
-		new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))),
+		new ColumnTableAliasProxyHandler(
+			new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false, false)),
+			false,
+		),
 	);
 }
 
@@ -124,3 +202,12 @@ export function mapColumnsInSQLToAlias(query: SQL, alias: string): SQL {
 		return c;
 	}));
 }
+
+// Defined separately from the Column class to resolve circular dependency
+Column.prototype.as = function(alias: string): Column {
+	return aliasedColumn(this, alias);
+};
+
+export function getOriginalColumnFromAlias<T extends Column>(column: T): T {
+	return column[OriginalColumn]();
+}
diff --git a/drizzle-orm/src/arktype/README.md b/drizzle-orm/src/arktype/README.md
new file mode 100644
index 0000000000..29d8d9eeb0
--- /dev/null
+++ b/drizzle-orm/src/arktype/README.md
@@ -0,0 +1,51 @@
+Allows you to generate [arktype](https://arktype.io/) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import { type } from 'arktype';
+
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	role: text('role', { enum: ['admin', 'user'] }).notNull(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const insertUserSchema = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const updateUserSchema = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const selectUserSchema = createSelectSchema(users);
+
+// Overriding the fields
+const insertUserSchema = createInsertSchema(users, {
+	role: type('string'),
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const insertUserSchema = createInsertSchema(users, {
+	id: (schema) => schema.atLeast(1),
+	role: type('string'),
+});
+
+// Usage
+
+const isUserValid = parse(insertUserSchema, {
+	name: 'John Doe',
+	email: 'johndoe@test.com',
+	role: 'admin',
+});
+```
diff --git a/drizzle-orm/src/arktype/column.ts b/drizzle-orm/src/arktype/column.ts
new file mode 100644
index 0000000000..c33c6c26bd
--- /dev/null
+++ b/drizzle-orm/src/arktype/column.ts
@@ -0,0 +1,381 @@
+import { type Type, type } from 'arktype';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS } from '~/utils.ts';
+
+export const literalSchema = type.string.or(type.number).or(type.boolean).or(type.null);
+export const jsonSchema = literalSchema.or(type.unknown.as<any>().array()).or(type.object.as<Record<string, any>>());
+export const bufferSchema = type.unknown.narrow((value) => value instanceof Buffer).as<Buffer>().describe( // oxlint-disable-line no-instanceof-builtins drizzle-internal/no-instanceof
+	'a Buffer instance',
+);
+
+export function columnToSchema(column: Column): Type {
+	let schema!: Type;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions);
+	}
+
+	const { type: columnType, constraint } = extractExtendedColumnType(column);
+
+	switch (columnType) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint);
+			break;
+		}
+		case 'boolean': {
+			schema = type.boolean;
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint);
+			break;
+		}
+		case 'custom': {
+			schema = type.unknown;
+			break;
+		}
+		default: {
+			schema = type.unknown;
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(column: Column, constraint: ColumnDataNumberConstraint | undefined): Type<number, any> {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	return (integer ? type.keywords.number.integer : type.number).atLeast(min).atMost(max);
+}
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+): Type {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: Type;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint);
+			break;
+		case 'boolean':
+			baseSchema = type.boolean;
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint);
+			break;
+		default:
+			baseSchema = type.unknown;
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: Type = baseSchema.array();
+	for (let i = 1; i < dimensions; i++) {
+		schema = schema.array();
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(
+	column: Column,
+	constraint: ColumnDataArrayConstraint | undefined,
+): Type {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return type([type.number, type.number]);
+		}
+		case 'line': {
+			return type([type.number, type.number, type.number]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const length = column.length;
+			return length ? type.number.array().exactlyLength(length) : type.number.array();
+		}
+		case 'int64vector': {
+			const length = column.length;
+			// TODO - INT64 number range
+			return length ? type.bigint.array().exactlyLength(length) : type.bigint.array();
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const length = column.length;
+				const schema = columnToSchema(baseColumn).array();
+				if (length) return schema.exactlyLength(length);
+				return schema;
+			}
+			return type.unknown.array();
+		}
+		default: {
+			return type.unknown.array();
+		}
+	}
+}
+
+function objectColumnToSchema(
+	column: Column,
+	constraint: ColumnDataObjectConstraint | undefined,
+): Type {
+	switch (constraint) {
+		case 'buffer': {
+			return bufferSchema;
+		}
+		case 'date': {
+			return type.Date;
+		}
+		case 'geometry':
+		case 'point': {
+			return type({
+				x: type.number,
+				y: type.number,
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return type({
+				a: type.number,
+				b: type.number,
+				c: type.number,
+			});
+		}
+		default: {
+			return type({});
+		}
+	}
+}
+
+export const unsignedBigintNarrow = (v: bigint, ctx: { mustBe: (expected: string) => false }) =>
+	v < 0n ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_UNSIGNED_MAX ? ctx.mustBe('less than') : true;
+
+export const bigintNarrow = (v: bigint, ctx: { mustBe: (expected: string) => false }) =>
+	v < CONSTANTS.INT64_MIN ? ctx.mustBe('greater than') : v > CONSTANTS.INT64_MAX ? ctx.mustBe('less than') : true;
+
+export const bigintStringModeSchema = type.string.narrow((v, ctx) => {
+	if (typeof v !== 'string') {
+		return ctx.mustBe('a string');
+	}
+	if (!(/^-?\d+$/.test(v))) {
+		return ctx.mustBe('a string representing a number');
+	}
+
+	const bigint = BigInt(v);
+	if (bigint < CONSTANTS.INT64_MIN) {
+		return ctx.mustBe('greater than');
+	}
+	if (bigint > CONSTANTS.INT64_MAX) {
+		return ctx.mustBe('less than');
+	}
+
+	return true;
+});
+
+export const unsignedBigintStringModeSchema = type.string.narrow((v, ctx) => {
+	if (typeof v !== 'string') {
+		return ctx.mustBe('a string');
+	}
+	if (!(/^\d+$/.test(v))) {
+		return ctx.mustBe('a string representing a number');
+	}
+
+	const bigint = BigInt(v);
+	if (bigint < 0) {
+		return ctx.mustBe('greater than');
+	}
+	if (bigint > CONSTANTS.INT64_MAX) {
+		return ctx.mustBe('less than');
+	}
+
+	return true;
+});
+
+function bigintColumnToSchema(column: Column, constraint?: ColumnDataBigIntConstraint | undefined): Type {
+	switch (constraint) {
+		case 'int64': {
+			return type.bigint.narrow(bigintNarrow);
+		}
+		case 'uint64': {
+			return type.bigint.narrow(unsignedBigintNarrow);
+		}
+	}
+
+	return type.bigint;
+}
+
+function stringColumnToSchema(column: Column, constraint: ColumnDataStringConstraint | undefined): Type {
+	const { name: columnName, length, isLengthExact } = column;
+	if (constraint === 'binary') {
+		return type(`/^[01]${length ? `{${isLengthExact ? length : `0,${length}`}}` : '*'}$/`)
+			.describe(
+				`a string containing ones or zeros${
+					length ? ` while being ${isLengthExact ? '' : 'up to '}${length} characters long` : ''
+				}`,
+			);
+	}
+	if (constraint === 'uuid') {
+		return type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID');
+	}
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return type.enumerated(...enumValues);
+	}
+	if (constraint === 'int64') {
+		return bigintStringModeSchema;
+	}
+	if (constraint === 'uint64') {
+		return unsignedBigintStringModeSchema;
+	}
+
+	return length && isLengthExact
+		? type.string.exactlyLength(length)
+		: length
+		? type.string.atMostLength(length)
+		: type.string;
+}
diff --git a/drizzle-orm/src/arktype/column.types.ts b/drizzle-orm/src/arktype/column.types.ts
new file mode 100644
index 0000000000..64f6c2cc7f
--- /dev/null
+++ b/drizzle-orm/src/arktype/column.types.ts
@@ -0,0 +1,42 @@
+import type { Type, type } from 'arktype';
+import type { ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Json } from '../utils.ts';
+
+export type ArktypeNullable<TSchema> = Type<type.infer<TSchema> | null>;
+
+export type ArktypeOptional<TSchema> = [Type<type.infer<TSchema>>, '?'];
+
+export type GetArktypeType<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = TType['constraint'] extends 'json' ? Type<Json>
+	: TType['type'] extends 'custom' ? Type<any>
+	: Type<TColumn['_']['data']>;
+
+type HandleSelectColumn<
+	TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: ArktypeNullable<TSchema>;
+
+type HandleInsertColumn<
+	TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? ArktypeOptional<TSchema>
+	: TSchema
+	: ArktypeOptional<ArktypeNullable<TSchema>>;
+
+type HandleUpdateColumn<
+	TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? ArktypeOptional<TSchema>
+	: ArktypeOptional<ArktypeNullable<TSchema>>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+> = TType extends 'select' ? HandleSelectColumn<GetArktypeType<TColumn>, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<GetArktypeType<TColumn>, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<GetArktypeType<TColumn>, TColumn>
+	: GetArktypeType<TColumn>;
diff --git a/drizzle-orm/src/arktype/index.ts b/drizzle-orm/src/arktype/index.ts
new file mode 100644
index 0000000000..5d00169d6e
--- /dev/null
+++ b/drizzle-orm/src/arktype/index.ts
@@ -0,0 +1,11 @@
+export {
+	bigintStringModeSchema,
+	bufferSchema,
+	jsonSchema,
+	literalSchema,
+	unsignedBigintStringModeSchema,
+} from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/arktype/schema.ts b/drizzle-orm/src/arktype/schema.ts
new file mode 100644
index 0000000000..e57915b824
--- /dev/null
+++ b/drizzle-orm/src/arktype/schema.ts
@@ -0,0 +1,101 @@
+import { type Type, type } from 'arktype';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type { CreateInsertSchema, CreateSelectSchema, CreateUpdateSchema } from './schema.types.ts';
+
+function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+): Type {
+	const columnSchemas: Record<string, Type> = {};
+
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
+			continue;
+		}
+
+		const refinement = refinements[key];
+		if (
+			refinement !== undefined
+			&& (typeof refinement !== 'function' || (typeof refinement === 'function' && refinement.expression !== undefined))
+		) {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column) : type.unknown;
+		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = columnSchemas[key]!.or(type.null);
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = columnSchemas[key]!.optional() as any;
+			}
+		}
+	}
+
+	return type(columnSchemas);
+}
+
+export const createSelectSchema = ((
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return type.enumerated(...entity.enumValues);
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: () => false,
+		optional: () => false,
+		nullable: (column) => !column.notNull,
+	}) as any;
+}) as CreateSelectSchema;
+
+export const createInsertSchema = ((
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: (column) =>
+			column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+			|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+		optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+		nullable: (column) => !column.notNull,
+	}) as any;
+}) as CreateInsertSchema;
+
+export const createUpdateSchema = ((
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: (column) =>
+			column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+			|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+		optional: () => true,
+		nullable: (column) => !column.notNull,
+	}) as any;
+}) as CreateUpdateSchema;
diff --git a/drizzle-orm/src/arktype/schema.types.internal.ts b/drizzle-orm/src/arktype/schema.types.internal.ts
new file mode 100644
index 0000000000..b30985990f
--- /dev/null
+++ b/drizzle-orm/src/arktype/schema.types.internal.ts
@@ -0,0 +1,80 @@
+import type { Type, type } from 'arktype';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { ArktypeNullable, ArktypeOptional, GetArktypeType, HandleColumn } from './column.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type GenericSchema = type.cast<unknown> | [type.cast<unknown>, '?'];
+
+type BuildRefineField<T> = T extends GenericSchema ? ((schema: T) => GenericSchema) | GenericSchema : never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+> = {
+	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
+		TColumns[K] extends Column ? BuildRefineField<GetArktypeType<TColumns[K]>>
+			: BuildRefine<GetSelection<TColumns[K]>>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (schema: any) => GenericSchema ? (
+		TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
+			: ArktypeNullable<ReturnType<TRefinement>>
+	) extends infer TSchema ? TType extends 'update' ? ArktypeOptional<TSchema>
+		: TSchema
+	: Type<any>
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object ? TRefinements[TKey] extends GenericSchema | ((schema: any) => any) ? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+> = type.instantiate<
+	Simplify<
+		{
+			readonly [
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column
+				? IsRefinementDefined<TRefinements, K> extends true
+					? HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>
+				: HandleColumn<TType, TColumn>
+				: TColumns[K] extends infer TNested extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TNested>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
+					>
+				: any;
+		}
+	>
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare
+		? TRefinement[K] extends Record<string, GenericSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/arktype/schema.types.ts b/drizzle-orm/src/arktype/schema.types.ts
new file mode 100644
index 0000000000..d78f6c9b0c
--- /dev/null
+++ b/drizzle-orm/src/arktype/schema.types.ts
@@ -0,0 +1,50 @@
+import type { Type } from 'arktype';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns']>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields']>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(enum_: TEnum): Type<TEnum['enumValues'][number]>;
+}
+
+export interface CreateInsertSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateUpdateSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
+}
diff --git a/drizzle-orm/src/aws-data-api/common/index.ts b/drizzle-orm/src/aws-data-api/common/index.ts
index cbc65cd6c2..060925cef9 100644
--- a/drizzle-orm/src/aws-data-api/common/index.ts
+++ b/drizzle-orm/src/aws-data-api/common/index.ts
@@ -1,22 +1,26 @@
 import type { Field } from '@aws-sdk/client-rds-data';
-import { TypeHint } from '@aws-sdk/client-rds-data';
-import type { QueryTypingsValue } from '~/sql/sql.ts';
 
 export function getValueFromDataApi(field: Field) {
 	if (field.stringValue !== undefined) {
 		return field.stringValue;
-	} else if (field.booleanValue !== undefined) {
+	}
+	if (field.booleanValue !== undefined) {
 		return field.booleanValue;
-	} else if (field.doubleValue !== undefined) {
+	}
+	if (field.doubleValue !== undefined) {
 		return field.doubleValue;
-	} else if (field.isNull !== undefined) {
+	}
+	if (field.isNull !== undefined) {
 		return null;
-	} else if (field.longValue !== undefined) {
+	}
+	if (field.longValue !== undefined) {
 		return field.longValue;
-	} else if (field.blobValue !== undefined) {
+	}
+	if (field.blobValue !== undefined) {
 		return field.blobValue;
-		// eslint-disable-next-line unicorn/no-negated-condition
-	} else if (field.arrayValue !== undefined) {
+	}
+
+	if (field.arrayValue !== undefined) {
 		if (field.arrayValue.stringValues !== undefined) {
 			return field.arrayValue.stringValues;
 		}
@@ -34,64 +38,35 @@ export function getValueFromDataApi(field: Field) {
 		}
 
 		throw new Error('Unknown array type');
-	} else {
-		throw new Error('Unknown type');
 	}
-}
 
-export function typingsToAwsTypeHint(typings?: QueryTypingsValue): TypeHint | undefined {
-	if (typings === 'date') {
-		return TypeHint.DATE;
-	} else if (typings === 'decimal') {
-		return TypeHint.DECIMAL;
-	} else if (typings === 'json') {
-		return TypeHint.JSON;
-	} else if (typings === 'time') {
-		return TypeHint.TIME;
-	} else if (typings === 'timestamp') {
-		return TypeHint.TIMESTAMP;
-	} else if (typings === 'uuid') {
-		return TypeHint.UUID;
-	} else {
-		return undefined;
-	}
+	throw new Error('Unknown type');
 }
 
-export function toValueParam(value: any, typings?: QueryTypingsValue): { value: Field; typeHint?: TypeHint } {
-	const response: { value: Field; typeHint?: TypeHint } = {
-		value: {} as any,
-		typeHint: typingsToAwsTypeHint(typings),
-	};
-
+export function toValueParam(value: any): Field {
 	if (value === null) {
-		response.value = { isNull: true };
-	} else if (typeof value === 'string') {
-		switch (response.typeHint) {
-			case TypeHint.DATE: {
-				response.value = { stringValue: value.split('T')[0]! };
-				break;
-			}
-			case TypeHint.TIMESTAMP: {
-				response.value = { stringValue: value.replace('T', ' ').replace('Z', '') };
-				break;
-			}
-			default: {
-				response.value = { stringValue: value };
-				break;
-			}
-		}
-	} else if (typeof value === 'number' && Number.isInteger(value)) {
-		response.value = { longValue: value };
-	} else if (typeof value === 'number' && !Number.isInteger(value)) {
-		response.value = { doubleValue: value };
-	} else if (typeof value === 'boolean') {
-		response.value = { booleanValue: value };
-	} else if (value instanceof Date) { // eslint-disable-line no-instanceof/no-instanceof
-		// TODO: check if this clause is needed? Seems like date value always comes as string
-		response.value = { stringValue: value.toISOString().replace('T', ' ').replace('Z', '') };
-	} else {
-		throw new Error(`Unknown type for ${value}`);
+		return { isNull: true };
+	}
+
+	const valueType = typeof value;
+	if (valueType === 'string') {
+		return { stringValue: value };
+	}
+	if (valueType === 'number') {
+		return Number.isInteger(value) ? { longValue: value } : { doubleValue: value };
+	}
+	if (valueType === 'boolean') {
+		return { booleanValue: value };
+	}
+	if (valueType === 'bigint') {
+		return { stringValue: value.toString() };
+	}
+	if (value instanceof Date) { // oxlint-disable-line drizzle-internal/no-instanceof
+		return { stringValue: value.toISOString().replace('T', ' ').replace('Z', '') };
+	}
+	if ((typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) || value instanceof Uint8Array) { // oxlint-disable-line drizzle-internal/no-instanceof
+		return { blobValue: value };
 	}
 
-	return response;
+	throw new Error(`Unknown type for ${value}`);
 }
diff --git a/drizzle-orm/src/aws-data-api/pg/codecs.ts b/drizzle-orm/src/aws-data-api/pg/codecs.ts
new file mode 100644
index 0000000000..cd8042488c
--- /dev/null
+++ b/drizzle-orm/src/aws-data-api/pg/codecs.ts
@@ -0,0 +1,520 @@
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	arrayCompatNormalizeInput,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+const byteaFromBlob = (v: Uint8Array | Buffer): Buffer => Buffer.from(v);
+const byteaFromPgHex = (v: string): Buffer => Buffer.from(v.slice(2), 'hex');
+
+export const awsDataApiPgCodecs = refineGenericPgCodecs({
+	json: {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::json`,
+		castArrayParam: (name, _column, dim) => `${name}::json${'[]'.repeat(dim)}`,
+		normalize: (v) => JSON.parse(v),
+		normalizeArray: arrayCompatNormalize((v: string) => JSON.parse(v)),
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::jsonb`,
+		castArrayParam: (name, _column, dim) => `${name}::jsonb${'[]'.repeat(dim)}`,
+		normalize: (v) => JSON.parse(v),
+		normalizeArray: arrayCompatNormalize((v: string) => JSON.parse(v)),
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	bytea: {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bytea`,
+		castArrayParam: (name, _column, dim) => `${name}::bytea${'[]'.repeat(dim)}`,
+		normalize: byteaFromBlob,
+		normalizeArray: arrayCompatNormalize(byteaFromPgHex),
+		normalizeParamArray: makePgArray,
+	},
+	bit: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name, column) => `${name}::bit(${column.length})`,
+		castArrayParam: (name, column, dim) => `${name}::bit(${column.length})${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point)': {
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dim) => `${name}::geometry${'[]'.repeat(dim)}`,
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dim) => `${name}::geometry${'[]'.repeat(dim)}`,
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		normalizeParamArray: makePgArray,
+	},
+	interval: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::interval`,
+		castArrayParam: (name, _column, dim) => `${name}::interval${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::line`,
+		castArrayParam: (name, _column, dim) => `${name}::line${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::line`,
+		castArrayParam: (name, _column, dim) => `${name}::line${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	macaddr: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::macaddr`,
+		castArrayParam: (name, _column, dim) => `${name}::macaddr${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	macaddr8: {
+		cast: castToText,
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::macaddr8`,
+		castArrayParam: (name, _column, dim) => `${name}::macaddr8${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	cidr: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::cidr`,
+		castArrayParam: (name, _column, dim) => `${name}::cidr${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	inet: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::inet`,
+		castArrayParam: (name, _column, dim) => `${name}::inet${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::point`,
+		castArrayParam: (name, _column, dim) => `${name}::point${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::point`,
+		castArrayParam: (name, _column, dim) => `${name}::point${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	halfvec: {
+		castParam: (name) => `${name}::halfvec`,
+		castArrayParam: (name, _column, dim) => `${name}::halfvec${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	sparsevec: {
+		castParam: (name) => `${name}::sparsevec`,
+		castArrayParam: (name, _column, dim) => `${name}::sparsevec${'[]'.repeat(dim)}`,
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	vector: {
+		castParam: (name) => `${name}::vector`,
+		castArrayParam: (name, _column, dim) => `${name}::vector${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+
+	bool: {
+		castParam: (name) => `${name}::boolean`,
+		castArrayParam: (name, _column, dim) => `${name}::boolean${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	box: {
+		castParam: (name) => `${name}::box`,
+		castArrayParam: (name, _column, dim) => `${name}::box${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	box2d: {
+		castParam: (name) => `${name}::box2d`,
+		castArrayParam: (name, _column, dim) => `${name}::box2d${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	box3d: {
+		castParam: (name) => `${name}::box3d`,
+		castArrayParam: (name, _column, dim) => `${name}::box3d${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	char: {
+		castParam: (name) => `${name}::char`,
+		castArrayParam: (name, _column, dim) => `${name}::char${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	circle: {
+		castParam: (name) => `${name}::circle`,
+		castArrayParam: (name, _column, dim) => `${name}::circle${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	datemultirange: {
+		castParam: (name) => `${name}::datemultirange`,
+		castArrayParam: (name, _column, dim) => `${name}::datemultirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	daterange: {
+		castParam: (name) => `${name}::daterange`,
+		castArrayParam: (name, _column, dim) => `${name}::daterange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	float8: {
+		castParam: (name) => `${name}::double precision`,
+		castArrayParam: (name, _column, dim) => `${name}::double precision${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'geography(point)': {
+		castParam: (name) => `${name}::geography`,
+		castArrayParam: (name, _column, dim) => `${name}::geography${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'geography(point):tuple': {
+		castParam: (name) => `${name}::geography`,
+		castArrayParam: (name, _column, dim) => `${name}::geography${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	int4multirange: {
+		castParam: (name) => `${name}::int4multirange`,
+		castArrayParam: (name, _column, dim) => `${name}::int4multirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	int4range: {
+		castParam: (name) => `${name}::int4range`,
+		castArrayParam: (name, _column, dim) => `${name}::int4range${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	int8multirange: {
+		castParam: (name) => `${name}::int8multirange`,
+		castArrayParam: (name, _column, dim) => `${name}::int8multirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	int8range: {
+		castParam: (name) => `${name}::int8range`,
+		castArrayParam: (name, _column, dim) => `${name}::int8range${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	lseg: {
+		castParam: (name) => `${name}::lseg`,
+		castArrayParam: (name, _column, dim) => `${name}::lseg${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	money: {
+		castParam: (name) => `${name}::money`,
+		castArrayParam: (name, _column, dim) => `${name}::money${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	nummultirange: {
+		castParam: (name) => `${name}::nummultirange`,
+		castArrayParam: (name, _column, dim) => `${name}::nummultirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	numrange: {
+		castParam: (name) => `${name}::numrange`,
+		castArrayParam: (name, _column, dim) => `${name}::numrange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	oid: {
+		castParam: (name) => `${name}::oid`,
+		castArrayParam: (name, _column, dim) => `${name}::oid${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	path: {
+		castParam: (name) => `${name}::path`,
+		castArrayParam: (name, _column, dim) => `${name}::path${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	polygon: {
+		castParam: (name) => `${name}::polygon`,
+		castArrayParam: (name, _column, dim) => `${name}::polygon${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	raster: {
+		castParam: (name) => `${name}::raster`,
+		castArrayParam: (name, _column, dim) => `${name}::raster${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regclass: {
+		castParam: (name) => `${name}::regclass`,
+		castArrayParam: (name, _column, dim) => `${name}::regclass${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regconfig: {
+		castParam: (name) => `${name}::regconfig`,
+		castArrayParam: (name, _column, dim) => `${name}::regconfig${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regdictionary: {
+		castParam: (name) => `${name}::regdictionary`,
+		castArrayParam: (name, _column, dim) => `${name}::regdictionary${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regnamespace: {
+		castParam: (name) => `${name}::regnamespace`,
+		castArrayParam: (name, _column, dim) => `${name}::regnamespace${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regoper: {
+		castParam: (name) => `${name}::regoper`,
+		castArrayParam: (name, _column, dim) => `${name}::regoper${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regoperator: {
+		castParam: (name) => `${name}::regoperator`,
+		castArrayParam: (name, _column, dim) => `${name}::regoperator${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regproc: {
+		castParam: (name) => `${name}::regproc`,
+		castArrayParam: (name, _column, dim) => `${name}::regproc${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regprocedure: {
+		castParam: (name) => `${name}::regprocedure`,
+		castArrayParam: (name, _column, dim) => `${name}::regprocedure${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regrole: {
+		castParam: (name) => `${name}::regrole`,
+		castArrayParam: (name, _column, dim) => `${name}::regrole${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	regtype: {
+		castParam: (name) => `${name}::regtype`,
+		castArrayParam: (name, _column, dim) => `${name}::regtype${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	serial: {
+		castParam: (name) => `${name}::integer`,
+		castArrayParam: (name, _column, dim) => `${name}::integer${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	smallint: {
+		castParam: (name) => `${name}::smallint`,
+		castArrayParam: (name, _column, dim) => `${name}::smallint${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	smallserial: {
+		castParam: (name) => `${name}::smallint`,
+		castArrayParam: (name, _column, dim) => `${name}::smallint${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	text: {
+		castParam: (name) => `${name}::text`,
+		castArrayParam: (name, _column, dim) => `${name}::text${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	time: {
+		castParam: (name) => `${name}::time`,
+		castArrayParam: (name, _column, dim) => `${name}::time${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	timetz: {
+		castParam: (name) => `${name}::timetz`,
+		castArrayParam: (name, _column, dim) => `${name}::timetz${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tsmultirange: {
+		castParam: (name) => `${name}::tsmultirange`,
+		castArrayParam: (name, _column, dim) => `${name}::tsmultirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tsquery: {
+		castParam: (name) => `${name}::tsquery`,
+		castArrayParam: (name, _column, dim) => `${name}::tsquery${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tsrange: {
+		castParam: (name) => `${name}::tsrange`,
+		castArrayParam: (name, _column, dim) => `${name}::tsrange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tstzmultirange: {
+		castParam: (name) => `${name}::tstzmultirange`,
+		castArrayParam: (name, _column, dim) => `${name}::tstzmultirange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tstzrange: {
+		castParam: (name) => `${name}::tstzrange`,
+		castArrayParam: (name, _column, dim) => `${name}::tstzrange${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	tsvector: {
+		castParam: (name) => `${name}::tsvector`,
+		castArrayParam: (name, _column, dim) => `${name}::tsvector${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	varbit: {
+		castParam: (name) => `${name}::varbit`,
+		castArrayParam: (name, _column, dim) => `${name}::varbit${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	varchar: {
+		castParam: (name) => `${name}::varchar`,
+		castArrayParam: (name, _column, dim) => `${name}::varchar${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	xml: {
+		castParam: (name) => `${name}::xml`,
+		castArrayParam: (name, _column, dim) => `${name}::xml${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	enum: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name, column) => `${name}::${column.getSQLType()}`,
+		castArrayParam: (name, column, dimensions) => `${name}::${column.getSQLType()}${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	numeric: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::numeric`,
+		castArrayParam: (name, _column, dim) => `${name}::numeric${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'numeric:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::numeric`,
+		castArrayParam: (name, _column, dim) => `${name}::numeric${'[]'.repeat(dim)}`,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeParamArray: makePgArray,
+	},
+	'numeric:bigint': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::numeric`,
+		castArrayParam: (name, _column, dim) => `${name}::numeric${'[]'.repeat(dim)}`,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	bigint: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bigint`,
+		castArrayParam: (name, _column, dim) => `${name}::bigint${'[]'.repeat(dim)}`,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	'bigint:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bigint`,
+		castArrayParam: (name, _column, dim) => `${name}::bigint${'[]'.repeat(dim)}`,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeParamArray: makePgArray,
+	},
+	'bigint:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bigint`,
+		castArrayParam: (name, _column, dim) => `${name}::bigint${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	bigserial: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bigint`,
+		castArrayParam: (name, _column, dim) => `${name}::bigint${'[]'.repeat(dim)}`,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	'bigserial:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::bigint`,
+		castArrayParam: (name, _column, dim) => `${name}::bigint${'[]'.repeat(dim)}`,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeParamArray: makePgArray,
+	},
+	date: {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::date`,
+		castArrayParam: (name, _column, dim) => `${name}::date${'[]'.repeat(dim)}`,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'date:string': {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::date`,
+		castArrayParam: (name, _column, dim) => `${name}::date${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	float4: {
+		castParam: (name) => `${name}::real`,
+		castArrayParam: (name, _column, dim) => `${name}::real${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	int: {
+		castParam: (name) => `${name}::integer`,
+		castArrayParam: (name, _column, dim) => `${name}::integer${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::timestamp`,
+		castArrayParam: (name, _column, dim) => `${name}::timestamp${'[]'.repeat(dim)}`,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+		normalizeParam: (value) => value.replace('T', ' ').replace('Z', ''),
+		normalizeParamArray: makePgArray,
+	},
+	timestamptz: {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::timestamptz`,
+		castArrayParam: (name, _column, dim) => `${name}::timestamptz${'[]'.repeat(dim)}`,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::timestamp`,
+		castArrayParam: (name, _column, dim) => `${name}::timestamp${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'timestamptz:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		castParam: (name) => `${name}::timestamptz`,
+		castArrayParam: (name, _column, dim) => `${name}::timestamptz${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+	uuid: {
+		castParam: (name) => `${name}::uuid`,
+		castArrayParam: (name, _column, dim) => `${name}::uuid${'[]'.repeat(dim)}`,
+		normalizeParamArray: makePgArray,
+	},
+});
diff --git a/drizzle-orm/src/aws-data-api/pg/driver.ts b/drizzle-orm/src/aws-data-api/pg/driver.ts
index 7395930ad0..a23517fab3 100644
--- a/drizzle-orm/src/aws-data-api/pg/driver.ts
+++ b/drizzle-orm/src/aws-data-api/pg/driver.ts
@@ -1,22 +1,14 @@
 import { RDSDataClient, type RDSDataClientConfig } from '@aws-sdk/client-rds-data';
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import type { PgColumn, PgInsertConfig, PgTable, TableConfig } from '~/pg-core/index.ts';
-import { PgArray } from '~/pg-core/index.ts';
-import type { PgRaw } from '~/pg-core/query-builders/raw.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { Param, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import { Table } from '~/table.ts';
-import type { DrizzleConfig, UpdateSet } from '~/utils.ts';
-import type { AwsDataApiClient, AwsDataApiPgQueryResult, AwsDataApiPgQueryResultHKT } from './session.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { type DrizzleConfig, jitCompatCheck } from '~/utils.ts';
+import { awsDataApiPgCodecs } from './codecs.ts';
+import type { AwsDataApiClient, AwsDataApiPgQueryResultHKT } from './session.ts';
 import { AwsDataApiSession } from './session.ts';
 
 export interface PgDriverOptions {
@@ -27,24 +19,18 @@ export interface PgDriverOptions {
 	secretArn: string;
 }
 
-export interface DrizzleAwsDataApiPgConfig<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends DrizzleConfig<TSchema> {
+export interface DrizzleAwsDataApiPgConfig<TRelations extends AnyRelations = EmptyRelations>
+	extends DrizzlePgConfig<TRelations>
+{
 	database: string;
 	resourceArn: string;
 	secretArn: string;
 }
 
-export class AwsDataApiPgDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<AwsDataApiPgQueryResultHKT, TSchema> {
+export class AwsDataApiPgDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<AwsDataApiPgQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'AwsDataApiPgDatabase';
-
-	override execute<
-		TRow extends Record<string, unknown> = Record<string, unknown>,
-	>(query: SQLWrapper | string): PgRaw<AwsDataApiPgQueryResult<TRow>> {
-		return super.execute(query);
-	}
 }
 
 export class AwsPgDialect extends PgDialect {
@@ -53,52 +39,18 @@ export class AwsPgDialect extends PgDialect {
 	override escapeParam(num: number): string {
 		return `:${num + 1}`;
 	}
-
-	override buildInsertQuery(
-		{ table, values, onConflict, returning, select, withList }: PgInsertConfig<PgTable<TableConfig>>,
-	): SQL<unknown> {
-		const columns: Record<string, PgColumn> = table[Table.Symbol.Columns];
-
-		if (!select) {
-			for (const value of (values as Record<string, Param | SQL>[])) {
-				for (const fieldName of Object.keys(columns)) {
-					const colValue = value[fieldName];
-					if (
-						is(colValue, Param) && colValue.value !== undefined && is(colValue.encoder, PgArray)
-						&& Array.isArray(colValue.value)
-					) {
-						value[fieldName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
-					}
-				}
-			}
-		}
-
-		return super.buildInsertQuery({ table, values, onConflict, returning, withList });
-	}
-
-	override buildUpdateSet(table: PgTable<TableConfig>, set: UpdateSet): SQL<unknown> {
-		const columns: Record<string, PgColumn> = table[Table.Symbol.Columns];
-
-		for (const [colName, colValue] of Object.entries(set)) {
-			const currentColumn = columns[colName];
-			if (
-				currentColumn && is(colValue, Param) && colValue.value !== undefined && is(colValue.encoder, PgArray)
-				&& Array.isArray(colValue.value)
-			) {
-				set[colName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
-			}
-		}
-		return super.buildUpdateSet(table, set);
-	}
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<TRelations extends AnyRelations = EmptyRelations>(
 	client: AwsDataApiClient,
-	config: DrizzleAwsDataApiPgConfig<TSchema>,
-): AwsDataApiPgDatabase<TSchema> & {
+	config: DrizzleAwsDataApiPgConfig<TRelations>,
+): AwsDataApiPgDatabase<TRelations> & {
 	$client: AwsDataApiClient;
 } {
-	const dialect = new AwsPgDialect({ casing: config.casing });
+	const dialect = new AwsPgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? awsDataApiPgCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -106,21 +58,13 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new AwsDataApiSession(client, dialect, schema, { ...config, logger, cache: config.cache }, undefined);
-	const db = new AwsDataApiPgDatabase(dialect, session, schema as any);
+	const relations = config.relations ?? {} as TRelations;
+	const session = new AwsDataApiSession(client, dialect, relations, {
+		...config,
+		logger,
+		cache: config.cache,
+	}, undefined);
+	const db = new AwsDataApiPgDatabase(dialect, session, relations, true);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -131,47 +75,39 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends AwsDataApiClient = RDSDataClient,
 >(
 	...params: [
-		TClient,
-		DrizzleAwsDataApiPgConfig<TSchema>,
-	] | [
 		(
 			| (
-				& DrizzleConfig<TSchema>
+				& DrizzlePgConfig<TRelations>
 				& {
 					connection: RDSDataClientConfig & Omit<DrizzleAwsDataApiPgConfig, keyof DrizzleConfig>;
 				}
 			)
 			| (
-				& DrizzleAwsDataApiPgConfig<TSchema>
+				& DrizzleAwsDataApiPgConfig<TRelations>
 				& {
 					client: TClient;
 				}
 			)
 		),
 	]
-): AwsDataApiPgDatabase<TSchema> & {
+): AwsDataApiPgDatabase<TRelations> & {
 	$client: TClient;
 } {
-	// eslint-disable-next-line no-instanceof/no-instanceof
-	if (params[0] instanceof RDSDataClient || params[0].constructor.name !== 'Object') {
-		return construct(params[0] as TClient, params[1] as DrizzleAwsDataApiPgConfig<TSchema>) as any;
-	}
-
 	if ((params[0] as { client?: TClient }).client) {
 		const { client, ...drizzleConfig } = params[0] as {
 			client: TClient;
-		} & DrizzleAwsDataApiPgConfig<TSchema>;
+		} & DrizzleAwsDataApiPgConfig<TRelations>;
 
 		return construct(client, drizzleConfig) as any;
 	}
 
 	const { connection, ...drizzleConfig } = params[0] as {
 		connection: RDSDataClientConfig & Omit<DrizzleAwsDataApiPgConfig, keyof DrizzleConfig>;
-	} & DrizzleConfig<TSchema>;
+	} & DrizzlePgConfig<TRelations>;
 	const { resourceArn, database, secretArn, ...rdsConfig } = connection;
 
 	const instance = new RDSDataClient(rdsConfig);
@@ -179,9 +115,9 @@ export function drizzle<
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config: DrizzleAwsDataApiPgConfig<TSchema>,
-	): AwsDataApiPgDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config: DrizzleAwsDataApiPgConfig<TRelations>,
+	): AwsDataApiPgDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/aws-data-api/pg/index.ts b/drizzle-orm/src/aws-data-api/pg/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/aws-data-api/pg/index.ts
+++ b/drizzle-orm/src/aws-data-api/pg/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/aws-data-api/pg/migrator.ts b/drizzle-orm/src/aws-data-api/pg/migrator.ts
index c58ba7ab1a..4e51c0a06a 100644
--- a/drizzle-orm/src/aws-data-api/pg/migrator.ts
+++ b/drizzle-orm/src/aws-data-api/pg/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { AwsDataApiPgDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: AwsDataApiPgDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: AwsDataApiPgDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/aws-data-api/pg/session.ts b/drizzle-orm/src/aws-data-api/pg/session.ts
index 6c915967f7..273e0959c7 100644
--- a/drizzle-orm/src/aws-data-api/pg/session.ts
+++ b/drizzle-orm/src/aws-data-api/pg/session.ts
@@ -1,4 +1,4 @@
-import type { ColumnMetadata, ExecuteStatementCommandOutput, Field, RDSDataClient } from '@aws-sdk/client-rds-data';
+import type { ExecuteStatementCommandOutput, Field, RDSDataClient } from '@aws-sdk/client-rds-data';
 import {
 	BeginTransactionCommand,
 	CommitTransactionCommand,
@@ -9,145 +9,16 @@ import type { Cache } from '~/cache/core/cache.ts';
 import { NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
-import {
-	type PgDialect,
-	PgPreparedQuery,
-	type PgQueryResultHKT,
-	PgSession,
-	PgTransaction,
-	type PgTransactionConfig,
-	type PreparedQueryConfig,
-} from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type QueryTypingsValue, type QueryWithTypings, type SQL, sql } from '~/sql/sql.ts';
-import { mapResultRow } from '~/utils.ts';
+import { type Logger, NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 import { getValueFromDataApi, toValueParam } from '../common/index.ts';
 
 export type AwsDataApiClient = RDSDataClient;
 
-export class AwsDataApiPreparedQuery<
-	T extends PreparedQueryConfig & { values: AwsDataApiPgQueryResult<unknown[]> },
-> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'AwsDataApiPreparedQuery';
-
-	private rawQuery: ExecuteStatementCommand;
-
-	constructor(
-		private client: AwsDataApiClient,
-		private queryString: string,
-		private params: unknown[],
-		private typings: QueryTypingsValue[],
-		private options: AwsDataApiSessionOptions,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		/** @internal */
-		readonly transactionId: string | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-		this.rawQuery = new ExecuteStatementCommand({
-			sql: queryString,
-			parameters: [],
-			secretArn: options.secretArn,
-			resourceArn: options.resourceArn,
-			database: options.database,
-			transactionId,
-			includeResultMetadata: !fields && !customResultMapper,
-		});
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const { fields, joinsNotNullableMap, customResultMapper } = this;
-
-		const result = await this.values(placeholderValues);
-		if (!fields && !customResultMapper) {
-			const { columnMetadata, rows } = result;
-			if (!columnMetadata) {
-				return result;
-			}
-			const mappedRows = rows.map((sourceRow) => {
-				const row: Record<string, unknown> = {};
-				for (const [index, value] of sourceRow.entries()) {
-					const metadata = columnMetadata[index];
-					if (!metadata) {
-						throw new Error(
-							`Unexpected state: no column metadata found for index ${index}. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`,
-						);
-					}
-					if (!metadata.name) {
-						throw new Error(
-							`Unexpected state: no column name for index ${index} found in the column metadata. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`,
-						);
-					}
-					row[metadata.name] = value;
-				}
-				return row;
-			});
-			return Object.assign(result, { rows: mappedRows });
-		}
-
-		return customResultMapper
-			? customResultMapper(result.rows!)
-			: result.rows!.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	async all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']> {
-		const result = await this.execute(placeholderValues);
-		if (!this.fields && !this.customResultMapper) {
-			return (result as AwsDataApiPgQueryResult<unknown>).rows;
-		}
-		return result;
-	}
-
-	async values(placeholderValues: Record<string, unknown> = {}): Promise<T['values']> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-
-		this.rawQuery.input.parameters = params.map((param, index) => ({
-			name: `${index + 1}`,
-			...toValueParam(param, this.typings[index]),
-		}));
-
-		this.options.logger?.logQuery(this.rawQuery.input.sql!, this.rawQuery.input.parameters);
-
-		const result = await this.queryWithCache(this.queryString, params, async () => {
-			return await this.client.send(this.rawQuery);
-		});
-		const rows = result.records?.map((row) => {
-			return row.map((field) => getValueFromDataApi(field));
-		}) ?? [];
-
-		return {
-			...result,
-			rows,
-		};
-	}
-
-	/** @internal */
-	mapResultRows(records: Field[][], columnMetadata: ColumnMetadata[]) {
-		return records.map((record) => {
-			const row: Record<string, unknown> = {};
-			for (const [index, field] of record.entries()) {
-				const { name } = columnMetadata[index]!;
-				row[name ?? index] = getValueFromDataApi(field); // not what to default if name is undefined
-			}
-			return row;
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
 export interface AwsDataApiSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
@@ -163,20 +34,20 @@ interface AwsDataApiQueryBase {
 }
 
 export class AwsDataApiSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<AwsDataApiPgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncSession<AwsDataApiPgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'AwsDataApiSession';
 
 	/** @internal */
 	readonly rawQuery: AwsDataApiQueryBase;
 	private cache: Cache;
+	private logger: Logger;
 
 	constructor(
 		/** @internal */
 		readonly client: AwsDataApiClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: AwsDataApiSessionOptions,
 		/** @internal */
 		readonly transactionId: string | undefined,
@@ -188,60 +59,108 @@ export class AwsDataApiSession<
 			database: options.database,
 		};
 		this.cache = options.cache ?? new NoopCache();
+		this.logger = options.logger ?? new NoopLogger();
 	}
 
-	prepareQuery<
-		T extends PreparedQueryConfig & {
-			values: AwsDataApiPgQueryResult<unknown[]>;
-		} = PreparedQueryConfig & {
-			values: AwsDataApiPgQueryResult<unknown[]>;
+	prepareQuery<T extends PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
 		},
-	>(
-		query: QueryWithTypings,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		queryMetadata?: { type: 'select' | 'update' | 'delete' | 'insert'; tables: string[] },
 		cacheConfig?: WithCacheConfig,
-		transactionId?: string,
-	): AwsDataApiPreparedQuery<T> {
-		return new AwsDataApiPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			query.typings ?? [],
-			this.options,
+	): PgAsyncPreparedQuery<T> {
+		const executor = async (params?: unknown[]) => {
+			const command = new ExecuteStatementCommand({
+				sql: query.sql,
+				parameters: params
+					? params.map((param, index) => ({
+						name: `${index + 1}`,
+						value: toValueParam(param),
+					}))
+					: [],
+				secretArn: this.options.secretArn,
+				resourceArn: this.options.resourceArn,
+				database: this.options.database,
+				transactionId: this.transactionId,
+				includeResultMetadata: mode === 'objects' || mode === 'raw',
+			});
+
+			const result = await this.client.send(command);
+			const rows = result.records ?? [];
+			if (result.records) {
+				for (let i = 0; i < result.records.length; ++i) {
+					const row = rows[i] as unknown[];
+					for (let j = 0; j < row.length; ++j) {
+						row[j] = getValueFromDataApi(row[j] as Field);
+					}
+				}
+			}
+
+			if (mode === 'arrays') return rows;
+
+			const { columnMetadata } = result;
+			if (!columnMetadata) {
+				return Object.assign(result, { rows });
+			}
+
+			const mappedRows = rows.map((sourceRow) => {
+				const row: Record<string, unknown> = {};
+				for (const [index, value] of sourceRow.entries()) {
+					const metadata = columnMetadata[index];
+					if (!metadata) {
+						throw new Error(
+							`Unexpected state: no column metadata found for index ${index}. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`,
+						);
+					}
+					if (!metadata.name) {
+						throw new Error(
+							`Unexpected state: no column name for index ${index} found in the column metadata. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`,
+						);
+					}
+					row[metadata.name] = value;
+				}
+				return row;
+			});
+
+			if (mode === 'objects') return mappedRows;
+			return Object.assign(result, { rows: mappedRows });
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			transactionId ?? this.transactionId,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
-	override execute<T>(query: SQL): Promise<T> {
-		return this.prepareQuery<PreparedQueryConfig & { execute: T; values: AwsDataApiPgQueryResult<unknown[]> }>(
-			this.dialect.sqlToQuery(query),
-			undefined,
-			undefined,
-			false,
-			undefined,
-			undefined,
-			undefined,
-			this.transactionId,
-		).execute();
-	}
-
 	override async transaction<T>(
-		transaction: (tx: AwsDataApiTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: AwsDataApiTransaction<TRelations>) => Promise<T>,
 		config?: PgTransactionConfig | undefined,
 	): Promise<T> {
 		const { transactionId } = await this.client.send(new BeginTransactionCommand(this.rawQuery));
-		const session = new AwsDataApiSession(this.client, this.dialect, this.schema, this.options, transactionId);
-		const tx = new AwsDataApiTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+		const session = new AwsDataApiSession(
+			this.client,
+			this.dialect,
+			this.relations,
+			this.options,
+			transactionId,
+		);
+		const tx = new AwsDataApiTransaction<TRelations>(
+			this.dialect,
+			session,
+			this.relations,
+			undefined,
+			true,
+		);
 		if (config) {
 			await tx.setTransaction(config);
 		}
@@ -257,20 +176,20 @@ export class AwsDataApiSession<
 }
 
 export class AwsDataApiTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<AwsDataApiPgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<AwsDataApiPgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'AwsDataApiTransaction';
 
 	override async transaction<T>(
-		transaction: (tx: AwsDataApiTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: AwsDataApiTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new AwsDataApiTransaction<TFullSchema, TSchema>(
+		const tx = new AwsDataApiTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this._.relations,
 			this.nestedIndex + 1,
+			true,
 		);
 		await this.session.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
@@ -287,5 +206,5 @@ export class AwsDataApiTransaction<
 export type AwsDataApiPgQueryResult<T> = ExecuteStatementCommandOutput & { rows: T[] };
 
 export interface AwsDataApiPgQueryResultHKT extends PgQueryResultHKT {
-	type: AwsDataApiPgQueryResult<any>;
+	type: AwsDataApiPgQueryResult<this['row']>;
 }
diff --git a/drizzle-orm/src/better-sqlite3/driver.ts b/drizzle-orm/src/better-sqlite3/driver.ts
index fc91b8f934..3962f5dd0a 100644
--- a/drizzle-orm/src/better-sqlite3/driver.ts
+++ b/drizzle-orm/src/better-sqlite3/driver.ts
@@ -1,16 +1,12 @@
-import Client, { type Database, type Options, type RunResult } from 'better-sqlite3';
+import Client, { type Database, type Options } from 'better-sqlite3';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import { BetterSQLiteSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type BetterSQLite3RunResult, BetterSQLiteSession } from './session.ts';
 
 export type DrizzleBetterSQLite3DatabaseConfig =
 	| ({
@@ -21,19 +17,21 @@ export type DrizzleBetterSQLite3DatabaseConfig =
 	| string
 	| undefined;
 
-export class BetterSQLite3Database<TSchema extends Record<string, unknown> = Record<string, never>>
-	extends BaseSQLiteDatabase<'sync', RunResult, TSchema>
+export class BetterSQLite3Database<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'sync', BetterSQLite3RunResult, TRelations>
 {
 	static override readonly [entityKind]: string = 'BetterSQLite3Database';
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<TRelations extends AnyRelations = EmptyRelations>(
 	client: Database,
-	config: Omit<DrizzleConfig<TSchema>, 'cache'> = {},
-): BetterSQLite3Database<TSchema> & {
+	config: Omit<DrizzleSQLiteConfig<TRelations>, 'cache'> = {},
+): BetterSQLite3Database<TRelations> & {
 	$client: Database;
 } {
-	const dialect = new SQLiteSyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -41,21 +39,16 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new BetterSQLiteSession(client, dialect, schema, { logger });
-	const db = new BetterSQLite3Database('sync', dialect, session, schema);
+	const relations = config.relations ?? {} as TRelations;
+	const session = new BetterSQLiteSession(
+		client,
+		dialect,
+		relations,
+		{
+			logger,
+		},
+	);
+	const db = new BetterSQLite3Database('sync', dialect, session, relations);
 	(<any> db).$client = client;
 	// (<any> db).$cache = config.cache;
 	// if ((<any> db).$cache) {
@@ -65,21 +58,19 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 	return db as any;
 }
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	...params:
 		| []
 		| [
-			Database | string,
+			string,
 		]
 		| [
-			Database | string,
-			DrizzleConfig<TSchema>,
+			string,
+			DrizzleSQLiteConfig<TRelations>,
 		]
 		| [
 			(
-				& DrizzleConfig<TSchema>
+				& DrizzleSQLiteConfig<TRelations>
 				& ({
 					connection?: DrizzleBetterSQLite3DatabaseConfig;
 				} | {
@@ -87,7 +78,7 @@ export function drizzle<
 				})
 			),
 		]
-): BetterSQLite3Database<TSchema> & {
+): BetterSQLite3Database<TRelations> & {
 	$client: Database;
 } {
 	if (params[0] === undefined || typeof params[0] === 'string') {
@@ -96,36 +87,32 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& {
-				connection?: DrizzleBetterSQLite3DatabaseConfig;
-				client?: Database;
-			}
-			& DrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig) as any;
-
-		if (typeof connection === 'object') {
-			const { source, ...options } = connection;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& {
+			connection?: DrizzleBetterSQLite3DatabaseConfig;
+			client?: Database;
+		}
+		& DrizzleSQLiteConfig<TRelations>;
 
-			const instance = new Client(source, options);
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-			return construct(instance, drizzleConfig) as any;
-		}
+	if (typeof connection === 'object') {
+		const { source, ...options } = connection;
 
-		const instance = new Client(connection);
+		const instance = new Client(source, options);
 
-		return construct(instance, drizzleConfig) as any;
+		return construct(instance, DrizzleSQLiteConfig) as any;
 	}
 
-	return construct(params[0] as Database, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	const instance = new Client(connection);
+
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): BetterSQLite3Database<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): BetterSQLite3Database<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/better-sqlite3/migrator.ts b/drizzle-orm/src/better-sqlite3/migrator.ts
index cea1982574..06588ada52 100644
--- a/drizzle-orm/src/better-sqlite3/migrator.ts
+++ b/drizzle-orm/src/better-sqlite3/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateSync } from '~/sqlite-core/async/session.ts';
 import type { BetterSQLite3Database } from './driver.ts';
 
-export function migrate<TSchema extends Record<string, unknown>>(
-	db: BetterSQLite3Database<TSchema>,
+export function migrate<TRelations extends AnyRelations>(
+	db: BetterSQLite3Database<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	db.dialect.migrate(migrations, db.session, config);
+	return migrateSync(migrations, db.session, config);
 }
diff --git a/drizzle-orm/src/better-sqlite3/session.ts b/drizzle-orm/src/better-sqlite3/session.ts
index 3f67934651..e75bc7c207 100644
--- a/drizzle-orm/src/better-sqlite3/session.ts
+++ b/drizzle-orm/src/better-sqlite3/session.ts
@@ -1,182 +1,131 @@
 import type { Database, RunResult, Statement } from 'better-sqlite3';
-import { type Cache, NoopCache } from '~/cache/core/index.ts';
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	SQLitePreparedQuery as PreparedQueryBase,
-	SQLiteSession,
-	type SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 
 export interface BetterSQLiteSessionOptions {
 	logger?: Logger;
-	cache?: Cache;
 }
 
+export type BetterSQLite3RunResult = RunResult;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class BetterSQLiteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'sync', RunResult, TFullSchema, TSchema> {
+export class BetterSQLiteSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'sync', BetterSQLite3RunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'BetterSQLiteSession';
 
 	private logger: Logger;
-	private cache: Cache;
 
 	constructor(
 		private client: Database,
-		dialect: SQLiteSyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: BetterSQLiteSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: BetterSQLiteSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'sync');
 		this.logger = options.logger ?? new NoopLogger();
-		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
-		cacheConfig?: WithCacheConfig,
-	): PreparedQuery<T> {
-		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(
-			stmt,
+	): SQLiteAsyncPreparedQuery<T & { run: BetterSQLite3RunResult }> {
+		let stmt: Statement;
+		try {
+			stmt = this.client.prepare(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				if (mode === 'arrays') return stmt.raw().all(...params as any[]);
+				return stmt.all(...params as any[]);
+			},
+			get: (params) => {
+				if (mode === 'arrays') return stmt.raw().get(...params as any[]);
+				return stmt.get(...params as any[]);
+			},
+			run: (params) => {
+				return stmt.run(...params as any[]);
+			},
+			values: (params) => {
+				return stmt.raw().all(...params as any[]);
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
-			this.cache,
+			undefined,
 			queryMetadata,
-			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+			undefined,
 		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: BetterSQLiteTransaction<TFullSchema, TSchema>) => T,
+		transaction: (tx: BetterSQLiteTransaction<TRelations>) => T,
 		config: SQLiteTransactionConfig = {},
 	): T {
-		const tx = new BetterSQLiteTransaction('sync', this.dialect, this, this.schema);
+		const tx = new BetterSQLiteTransaction('sync', this.dialect, this, this.relations);
 		const nativeTx = this.client.transaction(transaction);
 		return nativeTx[config.behavior ?? 'deferred'](tx);
 	}
 }
 
-export class BetterSQLiteTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'sync', RunResult, TFullSchema, TSchema> {
+export class BetterSQLiteTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'sync', BetterSQLite3RunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'BetterSQLiteTransaction';
 
-	override transaction<T>(transaction: (tx: BetterSQLiteTransaction<TFullSchema, TSchema>) => T): T {
+	override transaction<T>(
+		transaction: (
+			tx: BetterSQLiteTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new BetterSQLiteTransaction('sync', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new BetterSQLiteTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = transaction(tx);
 			this.session.run(sql.raw(`release savepoint ${savepointName}`));
-			return result;
+			return result as T;
 		} catch (err) {
 			this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
 			throw err;
 		}
 	}
 }
-
-export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<
-	{ type: 'sync'; run: RunResult; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'BetterSQLitePreparedQuery';
-
-	constructor(
-		private stmt: Statement,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
-	) {
-		super('sync', executeMethod, query, cache, queryMetadata, cacheConfig);
-	}
-
-	run(placeholderValues?: Record<string, unknown>): RunResult {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.stmt.run(...params);
-	}
-
-	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return stmt.all(...params);
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, stmt, joinsNotNullableMap, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			return stmt.get(...params);
-		}
-
-		const row = stmt.raw().get(...params) as unknown[];
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper([row]) as T['get'];
-		}
-
-		return mapResultRow(fields!, row, joinsNotNullableMap);
-	}
-
-	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.stmt.raw().all(...params) as T['values'];
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
diff --git a/drizzle-orm/src/bun-sql/driver.ts b/drizzle-orm/src/bun-sql/driver.ts
index 8e930510f6..6aeb0420b5 100644
--- a/drizzle-orm/src/bun-sql/driver.ts
+++ b/drizzle-orm/src/bun-sql/driver.ts
@@ -1,126 +1,152 @@
-/// <reference types="bun-types" />
-
-import type { SQLOptions } from 'bun';
-import { SQL } from 'bun';
-import { entityKind } from '~/entity.ts';
-import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
-import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import type { BunSQLQueryResultHKT } from './session.ts';
-import { BunSQLSession } from './session.ts';
-
-export class BunSQLDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<BunSQLQueryResultHKT, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLDatabase';
-}
-
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
-	client: SQL,
-	config: DrizzleConfig<TSchema> = {},
-): BunSQLDatabase<TSchema> & {
-	$client: SQL;
-} {
-	const dialect = new PgDialect({ casing: config.casing });
-	let logger;
-	if (config.logger === true) {
-		logger = new DefaultLogger();
-	} else if (config.logger !== false) {
-		logger = config.logger;
-	}
-
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new BunSQLSession(client, dialect, schema, { logger, cache: config.cache });
-	const db = new BunSQLDatabase(dialect, session, schema as any) as BunSQLDatabase<TSchema>;
-	(<any> db).$client = client;
-	(<any> db).$cache = config.cache;
-	if ((<any> db).$cache) {
-		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
-	}
-
-	return db as any;
-}
+import type { SQL } from 'bun';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { type BunMySqlDatabase, drizzle as mysqlConstructor } from './mysql/driver.ts';
+import { type BunSQLDatabase, drizzle as postgresConstructor } from './postgres/driver.ts';
+import { type BunSQLiteDatabase, drizzle as sqliteConstructor } from './sqlite/driver.ts';
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends SQL = SQL,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzlePgConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzlePgConfig<TRelations>
 			& ({
-				connection: string | ({ url?: string } & SQLOptions);
+				connection: string | ({ url?: string } & SQL.Options);
 			} | {
 				client: TClient;
 			})
 		),
 	]
-): BunSQLDatabase<TSchema> & {
+): BunSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
-	if (typeof params[0] === 'string') {
-		const instance = new SQL(params[0]);
+	return postgresConstructor(...params);
+}
 
-		return construct(instance, params[1]) as any;
+export namespace drizzle {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config?: DrizzlePgConfig<TRelations>): BunSQLDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return postgresConstructor.mock(config);
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as {
-			connection?: { url?: string } & SQLOptions;
-			client?: TClient;
-		} & DrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig) as any;
-
-		if (typeof connection === 'object' && connection.url !== undefined) {
-			const { url, ...config } = connection;
+	export function postgres<
+		TRelations extends AnyRelations = EmptyRelations,
+		TClient extends SQL = SQL,
+	>(
+		...params: [
+			string,
+		] | [
+			string,
+			DrizzlePgConfig<TRelations>,
+		] | [
+			(
+				& DrizzlePgConfig<TRelations>
+				& ({
+					connection: string | ({ url?: string } & SQL.Options);
+				} | {
+					client: TClient;
+				})
+			),
+		]
+	): BunSQLDatabase<TRelations> & {
+		$client: TClient;
+	} {
+		return postgresConstructor(...params);
+	}
 
-			const instance = new SQL({ url, ...config });
-			return construct(instance, drizzleConfig) as any;
+	export namespace postgres {
+		export function mock<
+			TRelations extends AnyRelations = EmptyRelations,
+		>(config?: DrizzlePgConfig<TRelations>): BunSQLDatabase<TRelations> & {
+			$client: '$client is not available on drizzle.mock()';
+		} {
+			return postgresConstructor.mock(config);
 		}
+	}
 
-		const instance = new SQL(connection);
-		return construct(instance, drizzleConfig) as any;
+	export function sqlite<
+		TRelations extends AnyRelations = EmptyRelations,
+		TClient extends SQL = SQL,
+	>(
+		...params: [
+			string,
+		] | [
+			string,
+			DrizzleSQLiteConfig<TRelations>,
+		] | [
+			(
+				& DrizzleSQLiteConfig<TRelations>
+				& ({
+					connection: string | ({ url?: string } & SQL.Options);
+				} | {
+					client: TClient;
+				})
+			),
+		]
+	): BunSQLiteDatabase<TRelations> & {
+		$client: TClient;
+	} {
+		return sqliteConstructor(...params);
 	}
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
-}
+	export namespace sqlite {
+		export function mock<
+			TRelations extends AnyRelations = EmptyRelations,
+		>(config?: DrizzleSQLiteConfig<TRelations>): BunSQLiteDatabase<TRelations> & {
+			$client: '$client is not available on drizzle.mock()';
+		} {
+			return sqliteConstructor.mock(config);
+		}
+	}
 
-export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): BunSQLDatabase<TSchema> & {
-		$client: '$client is not available on drizzle.mock()';
+	export function mysql<
+		TRelations extends AnyRelations = EmptyRelations,
+		TClient extends SQL = SQL,
+	>(
+		...params: [
+			string,
+		] | [
+			string,
+			DrizzleMySqlConfig<TRelations>,
+		] | [
+			(
+				& DrizzleMySqlConfig<TRelations>
+				& ({
+					connection: string | ({ url?: string } & SQL.Options);
+				} | {
+					client: TClient;
+				})
+			),
+		]
+	): BunMySqlDatabase<TRelations> & {
+		$client: TClient;
 	} {
-		return construct({
-			options: {
-				parsers: {},
-				serializers: {},
-			},
-		} as any, config) as any;
+		return mysqlConstructor(...params) as BunMySqlDatabase<TRelations> & {
+			$client: TClient;
+		};
+	}
+
+	export namespace mysql {
+		export function mock<
+			TRelations extends AnyRelations = EmptyRelations,
+		>(config?: DrizzleMySqlConfig<TRelations>): BunMySqlDatabase<TRelations> & {
+			$client: '$client is not available on drizzle.mock()';
+		} {
+			return mysqlConstructor.mock(config) as BunMySqlDatabase<TRelations> & {
+				$client: '$client is not available on drizzle.mock()';
+			};
+		}
 	}
 }
diff --git a/drizzle-orm/src/bun-sql/migrator.ts b/drizzle-orm/src/bun-sql/migrator.ts
index 48be01318a..ad6d58350e 100644
--- a/drizzle-orm/src/bun-sql/migrator.ts
+++ b/drizzle-orm/src/bun-sql/migrator.ts
@@ -1,11 +1,38 @@
 import type { MigrationConfig } from '~/migrator.ts';
-import { readMigrationFiles } from '~/migrator.ts';
-import type { BunSQLDatabase } from './driver.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { BunMySqlDatabase } from './mysql/driver.ts';
+import { migrate as mysqlMigrator } from './mysql/migrator.ts';
+import type { BunSQLDatabase } from './postgres/driver.ts';
+import { migrate as pgMigrator } from './postgres/migrator.ts';
+import type { BunSQLiteDatabase } from './sqlite/driver.ts';
+import { migrate as sqliteMigrator } from './sqlite/migrator.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: BunSQLDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: BunSQLDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
-	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return pgMigrator(db, config);
+}
+
+export namespace migrate {
+	export async function postgres<TRelations extends AnyRelations>(
+		db: BunSQLDatabase<TRelations>,
+		config: MigrationConfig,
+	) {
+		return pgMigrator(db, config);
+	}
+
+	export async function sqlite<TRelations extends AnyRelations>(
+		db: BunSQLiteDatabase<TRelations>,
+		config: MigrationConfig,
+	) {
+		return sqliteMigrator(db, config);
+	}
+
+	export async function mysql<TRelations extends AnyRelations>(
+		db: BunMySqlDatabase<TRelations>,
+		config: MigrationConfig,
+	) {
+		return mysqlMigrator(db, config);
+	}
 }
diff --git a/drizzle-orm/src/bun-sql/mysql/codecs.ts b/drizzle-orm/src/bun-sql/mysql/codecs.ts
new file mode 100644
index 0000000000..4829ff34d0
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/mysql/codecs.ts
@@ -0,0 +1,56 @@
+import { castToText, floatFromDouble, refineGenericMySqlCodecs } from '~/mysql-core/codecs.ts';
+import { sql } from '~/sql/sql.ts';
+
+export const bunSqlMySqlCodecs = refineGenericMySqlCodecs({
+	'bigint:number': {
+		normalize: Number,
+	},
+	'bigint:string': {
+		normalize: String,
+	},
+	boolean: {
+		normalize: (value: number) => value === 1,
+	},
+	year: {
+		// YEAR type is corrupted by driver in bun v1.3 and earlier
+		cast: (name) => sql`cast(${name} as unsigned)`,
+		normalize: Number,
+	},
+	'date:string': {
+		normalize: (value: Date) => value.toISOString().slice(0, -14),
+	},
+	'datetime:string': {
+		normalize: (value: Date) => value.toISOString().slice(0, -1).replace('T', ' '),
+	},
+	'timestamp:string': {
+		cast: castToText,
+	},
+	'decimal:number': {
+		normalize: Number,
+	},
+	'decimal:bigint': {
+		normalize: BigInt,
+	},
+	float: {
+		cast: (name) => sql`cast(${name} as double)`,
+		normalize: floatFromDouble,
+	},
+	binary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	varbinary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	blob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	tinyblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	mediumblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	longblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+});
diff --git a/drizzle-orm/src/bun-sql/mysql/driver.ts b/drizzle-orm/src/bun-sql/mysql/driver.ts
new file mode 100644
index 0000000000..0be7e301a5
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/mysql/driver.ts
@@ -0,0 +1,119 @@
+/// <reference types="bun-types" />
+
+import { SQL } from 'bun';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import { MySqlAsyncDatabase } from '~/mysql-core/async/db.ts';
+import { MySqlDialect } from '~/mysql-core/dialect.ts';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { bunSqlMySqlCodecs } from './codecs.ts';
+import type { BunMySqlQueryResultHKT } from './session.ts';
+import { BunMySqlSession } from './session.ts';
+
+export class BunMySqlDatabase<
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlAsyncDatabase<BunMySqlQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'BunMySqlDatabase';
+}
+
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	client: SQL,
+	config: DrizzleMySqlConfig<TRelations> = {},
+): BunMySqlDatabase<TRelations> & {
+	$client: SQL;
+} {
+	client.options.bigint = true;
+	const dialect = new MySqlDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? bunSqlMySqlCodecs,
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new BunMySqlSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new BunMySqlDatabase(dialect, session, relations) as BunMySqlDatabase<
+		TRelations
+	>;
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+
+	return db as any;
+}
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+	TClient extends SQL = SQL,
+>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleMySqlConfig<TRelations>,
+	] | [
+		(
+			& DrizzleMySqlConfig<TRelations>
+			& ({
+				connection: string | ({ url?: string } & SQL.Options);
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): BunMySqlDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new SQL(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...drizzleConfig } = params[0] as {
+		connection?: { url?: string } & SQL.Options;
+		client?: TClient;
+	} & DrizzleMySqlConfig<TRelations>;
+
+	if (client) return construct(client, drizzleConfig) as any;
+
+	if (typeof connection === 'object' && connection.url !== undefined) {
+		const { url, ...config } = connection;
+
+		const instance = new SQL({ url, ...config });
+		return construct(instance, drizzleConfig) as any;
+	}
+
+	const instance = new SQL(connection);
+	return construct(instance, drizzleConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzleMySqlConfig<TRelations>,
+	): BunMySqlDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({
+			options: {
+				parsers: {},
+				serializers: {},
+			},
+		} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/bun-sql/mysql/index.ts b/drizzle-orm/src/bun-sql/mysql/index.ts
new file mode 100644
index 0000000000..703d940e26
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/mysql/index.ts
@@ -0,0 +1,3 @@
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/bun-sql/mysql/migrator.ts b/drizzle-orm/src/bun-sql/mysql/migrator.ts
new file mode 100644
index 0000000000..7b260a6303
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/mysql/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/mysql-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { BunMySqlDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: BunMySqlDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db, config);
+}
diff --git a/drizzle-orm/src/bun-sql/mysql/session.ts b/drizzle-orm/src/bun-sql/mysql/session.ts
new file mode 100644
index 0000000000..6cedc85359
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/mysql/session.ts
@@ -0,0 +1,141 @@
+/// <reference types="bun-types" />
+
+import type { SavepointSQL, SQL as BunSQL, TransactionSQL } from 'bun';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import { MySqlAsyncPreparedQuery, MySqlAsyncSession, MySqlAsyncTransaction } from '~/mysql-core/async/session.ts';
+import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlTransactionConfig } from '~/mysql-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+export interface BunMySqlSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+export class BunMySqlSession<
+	TSQL extends BunSQL,
+	TRelations extends AnyRelations,
+> extends MySqlAsyncSession<MySqlQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'BunMySqlSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		readonly client: TSQL,
+		dialect: MySqlDialect,
+		private relations: TRelations,
+		readonly options: BunMySqlSessionOptions,
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends MySqlPreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (response: Record<string, unknown>[] | unknown[][] | { insertId: number; affectedRows: number }) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): MySqlAsyncPreparedQuery<T> {
+		const { client } = this;
+
+		const executor = async (params: any[] = []) => {
+			const raw = client.unsafe(query.sql, params);
+			if (mode === 'arrays') return raw.values();
+			if (mode === 'objects') return raw;
+			if (!mapper) return raw;
+
+			return raw.then(({ lastInsertRowid, affectedRows }) => ({
+				insertId: lastInsertRowid,
+				affectedRows: affectedRows,
+			}));
+		};
+
+		return new MySqlAsyncPreparedQuery(
+			executor,
+			undefined,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (tx: BunMySqlTransaction<TRelations>) => Promise<T>,
+		config?: MySqlTransactionConfig,
+	): Promise<T> {
+		const startTransactionSql = config
+			? this.getStartTransactionSQL(config)?.inlineParams().toQuery(this.dialect).sql.slice(18) ?? ''
+			: '';
+
+		if (config?.isolationLevel) throw new Error("Driver doesn't support setting isolation level on transaction");
+
+		return this.client.begin(startTransactionSql, async (client) => {
+			const session = new BunMySqlSession<TransactionSQL, TRelations>(
+				client,
+				this.dialect,
+				this.relations,
+				this.options,
+			);
+			const tx = new BunMySqlTransaction<TRelations>(
+				this.dialect,
+				session as MySqlAsyncSession<any, any>,
+				this.relations,
+				0,
+			);
+			// if (config) {
+			// 	const setTransactionConfigSql = this.getSetTransactionSQL(config);
+			// 	if (setTransactionConfigSql) {
+			// 		await tx.execute(setTransactionConfigSql);
+			// 	}
+			// }
+			return transaction(tx);
+		}) as Promise<T>;
+	}
+}
+
+export class BunMySqlTransaction<
+	TRelations extends AnyRelations,
+> extends MySqlAsyncTransaction<
+	BunMySqlQueryResultHKT,
+	TRelations
+> {
+	static override readonly [entityKind]: string = 'BunMySqlTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: BunMySqlTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		return (<BunMySqlSession<TransactionSQL, any>> this.session).client.savepoint((client) => {
+			const session = new BunMySqlSession<SavepointSQL, TRelations>(
+				client,
+				this.dialect,
+				this.relations,
+				(<BunMySqlSession<any, any>> this.session).options,
+			);
+			const tx = new BunMySqlTransaction<TRelations>(
+				this.dialect,
+				session as MySqlAsyncSession<any, any>,
+				this.relations,
+				this.nestedIndex + 1,
+			);
+			return transaction(tx);
+		}) as Promise<T>;
+	}
+}
+
+export interface BunMySqlQueryResultHKT extends MySqlQueryResultHKT {
+	type: Record<string, unknown>[] & Record<string, unknown>;
+}
diff --git a/drizzle-orm/src/bun-sql/postgres/codecs.ts b/drizzle-orm/src/bun-sql/postgres/codecs.ts
new file mode 100644
index 0000000000..4e6212029d
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/postgres/codecs.ts
@@ -0,0 +1,198 @@
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	arrayCompatNormalizeInput,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+} from '~/pg-core/codecs.ts';
+
+export const bunSqlPgCodecs = refineGenericPgCodecs({
+	date: { normalizeParamArray: makePgArray },
+	'date:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	uuid: {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	timestamp: { normalizeParamArray: makePgArray },
+	timestamptz: { normalizeParamArray: makePgArray },
+	'timestamp:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'timestamptz:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	float4: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeParamArray: makePgArray,
+	},
+	bigint: {
+		normalizeParamArray: makePgArray,
+	},
+	'bigint:number': { normalizeParamArray: makePgArray },
+	'bigint:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	bigserial: { normalizeParamArray: makePgArray },
+	'bigserial:number': { normalizeParamArray: makePgArray },
+	int: {
+		normalizeArray: (
+			value: any,
+			dimensions: number,
+		) => {
+			if (dimensions <= 1) {
+				// eslint-disable-next-line drizzle-internal/no-instanceof
+				if (value instanceof Int32Array) {
+					return Array.from(value) as any;
+				}
+				return value;
+			}
+
+			const stack: { arr: any; depth: number }[] = [{ arr: value, depth: 1 }];
+
+			while (stack.length > 0) {
+				const { arr, depth } = stack.pop()!;
+
+				if (depth === dimensions - 1) {
+					for (let i = 0; i < arr.length; i++) {
+						const leaf = arr[i];
+						// eslint-disable-next-line drizzle-internal/no-instanceof
+						if (leaf instanceof Int32Array) {
+							arr[i] = Array.from(leaf);
+						}
+					}
+				} else {
+					for (let i = 0; i < arr.length; i++) {
+						stack.push({ arr: arr[i], depth: depth + 1 });
+					}
+				}
+			}
+
+			return value;
+		},
+		normalizeParamArray: makePgArray,
+	},
+
+	bit: { normalizeParamArray: makePgArray },
+	bool: { normalizeParamArray: makePgArray },
+	box: { normalizeParamArray: makePgArray },
+	box2d: { normalizeParamArray: makePgArray },
+	box3d: { normalizeParamArray: makePgArray },
+	char: { normalizeParamArray: makePgArray },
+	cidr: { normalizeParamArray: makePgArray },
+	circle: { normalizeParamArray: makePgArray },
+	datemultirange: { normalizeParamArray: makePgArray },
+	daterange: { normalizeParamArray: makePgArray },
+	float8: { normalizeParamArray: makePgArray },
+	'geography(point)': { normalizeParamArray: makePgArray },
+	'geography(point):tuple': { normalizeParamArray: makePgArray },
+	inet: { normalizeParamArray: makePgArray },
+	int4multirange: { normalizeParamArray: makePgArray },
+	int4range: { normalizeParamArray: makePgArray },
+	int8multirange: { normalizeParamArray: makePgArray },
+	int8range: { normalizeParamArray: makePgArray },
+	lseg: { normalizeParamArray: makePgArray },
+	macaddr: { normalizeParamArray: makePgArray },
+	money: { normalizeParamArray: makePgArray },
+	nummultirange: { normalizeParamArray: makePgArray },
+	numrange: { normalizeParamArray: makePgArray },
+	oid: { normalizeParamArray: makePgArray },
+	path: { normalizeParamArray: makePgArray },
+	polygon: { normalizeParamArray: makePgArray },
+	raster: { normalizeParamArray: makePgArray },
+	regclass: { normalizeParamArray: makePgArray },
+	regconfig: { normalizeParamArray: makePgArray },
+	regdictionary: { normalizeParamArray: makePgArray },
+	regnamespace: { normalizeParamArray: makePgArray },
+	regoper: { normalizeParamArray: makePgArray },
+	regoperator: { normalizeParamArray: makePgArray },
+	regproc: { normalizeParamArray: makePgArray },
+	regprocedure: { normalizeParamArray: makePgArray },
+	regrole: { normalizeParamArray: makePgArray },
+	regtype: { normalizeParamArray: makePgArray },
+	serial: { normalizeParamArray: makePgArray },
+	smallint: { normalizeParamArray: makePgArray },
+	smallserial: { normalizeParamArray: makePgArray },
+	text: { normalizeParamArray: makePgArray },
+	time: { normalizeParamArray: makePgArray },
+	timetz: { normalizeParamArray: makePgArray },
+	tsmultirange: { normalizeParamArray: makePgArray },
+	tsquery: { normalizeParamArray: makePgArray },
+	tsrange: { normalizeParamArray: makePgArray },
+	tstzmultirange: { normalizeParamArray: makePgArray },
+	tstzrange: { normalizeParamArray: makePgArray },
+	tsvector: { normalizeParamArray: makePgArray },
+	varbit: { normalizeParamArray: makePgArray },
+	varchar: { normalizeParamArray: makePgArray },
+	xml: { normalizeParamArray: makePgArray },
+	bytea: { normalizeParamArray: makePgArray },
+	enum: { normalizeParamArray: makePgArray },
+	json: {
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		normalizeParamArray: makePgArray,
+	},
+	interval: {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	numeric: { normalizeParamArray: makePgArray },
+	'numeric:number': { normalizeParamArray: makePgArray },
+	'numeric:bigint': { normalizeParamArray: makePgArray },
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	halfvec: { normalizeParamArray: makePgArray },
+	sparsevec: {
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	vector: { normalizeParamArray: makePgArray },
+});
diff --git a/drizzle-orm/src/bun-sql/postgres/driver.ts b/drizzle-orm/src/bun-sql/postgres/driver.ts
new file mode 100644
index 0000000000..0f0abc4b2b
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/postgres/driver.ts
@@ -0,0 +1,119 @@
+/// <reference types="bun-types" />
+
+import { SQL } from 'bun';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { bunSqlPgCodecs } from './codecs.ts';
+import type { BunSQLQueryResultHKT } from './session.ts';
+import { BunSQLSession } from './session.ts';
+
+export class BunSQLDatabase<
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgAsyncDatabase<BunSQLQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'BunSQLDatabase';
+}
+
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	client: SQL,
+	config: DrizzlePgConfig<TRelations> = {},
+): BunSQLDatabase<TRelations> & {
+	$client: SQL;
+} {
+	client.options.bigint = true;
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? bunSqlPgCodecs,
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new BunSQLSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new BunSQLDatabase(dialect, session, relations, false, true) as BunSQLDatabase<TRelations>;
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+
+	return db as any;
+}
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+	TClient extends SQL = SQL,
+>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzlePgConfig<TRelations>,
+	] | [
+		(
+			& DrizzlePgConfig<TRelations>
+			& ({
+				connection: string | ({ url?: string } & SQL.Options);
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): BunSQLDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new SQL(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...DrizzlePgConfig } = params[0] as
+		& {
+			connection?: { url?: string } & SQL.Options;
+			client?: TClient;
+		}
+		& DrizzlePgConfig<TRelations>;
+
+	if (client) return construct(client, DrizzlePgConfig) as any;
+
+	if (typeof connection === 'object' && connection.url !== undefined) {
+		const { url, ...config } = connection;
+
+		const instance = new SQL({ url, ...config });
+		return construct(instance, DrizzlePgConfig) as any;
+	}
+
+	const instance = new SQL(connection);
+	return construct(instance, DrizzlePgConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): BunSQLDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({
+			options: {
+				parsers: {},
+				serializers: {},
+			},
+		} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/bun-sql/postgres/index.ts b/drizzle-orm/src/bun-sql/postgres/index.ts
new file mode 100644
index 0000000000..703d940e26
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/postgres/index.ts
@@ -0,0 +1,3 @@
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/bun-sql/postgres/migrator.ts b/drizzle-orm/src/bun-sql/postgres/migrator.ts
new file mode 100644
index 0000000000..cf366c10e1
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/postgres/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { BunSQLDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: BunSQLDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return await coreMigrate(migrations, db, config);
+}
diff --git a/drizzle-orm/src/bun-sql/postgres/session.ts b/drizzle-orm/src/bun-sql/postgres/session.ts
new file mode 100644
index 0000000000..b91c29a718
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/postgres/session.ts
@@ -0,0 +1,134 @@
+/// <reference types="bun-types" />
+
+import type { SavepointSQL, SQL, TransactionSQL } from 'bun';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+
+export interface BunSQLSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+export class BunSQLSession<
+	TSQL extends SQL,
+	TRelations extends AnyRelations,
+> extends PgAsyncSession<BunSQLQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'BunSQLSession';
+
+	logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		readonly client: TSQL,
+		dialect: PgDialect,
+		private relations: TRelations,
+		/** @internal */
+		readonly options: BunSQLSessionOptions = {},
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgAsyncPreparedQuery<T> {
+		const tagged = query._sql ? query._sql : null;
+		const client = this.client;
+		const executor = tagged
+			? mode === 'arrays'
+				? (params?: unknown[]) => params ? client(tagged, ...params).values() : client(tagged).values()
+				: (params?: unknown[]) => params ? client(tagged, ...params) : client(tagged)
+			: mode === 'arrays'
+			? (params?: unknown[]) => client.unsafe(query.sql, params).values()
+			: (params?: unknown[]) => client.unsafe(query.sql, params);
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<T>(
+		transaction: (tx: BunSQLTransaction<TRelations>) => Promise<T>,
+		config?: PgTransactionConfig,
+	): Promise<T> {
+		return this.client.begin(async (client) => {
+			const session = new BunSQLSession<TransactionSQL, TRelations>(
+				client,
+				this.dialect,
+				this.relations,
+				this.options,
+			);
+			const tx = new BunSQLTransaction(this.dialect, session, this.relations);
+			if (config) {
+				await tx.setTransaction(config);
+			}
+			return transaction(tx);
+		}) as Promise<T>;
+	}
+}
+
+export class BunSQLTransaction<
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<BunSQLQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'BunSQLTransaction';
+
+	constructor(
+		dialect: PgDialect,
+		/** @internal */
+		override readonly session: BunSQLSession<
+			TransactionSQL | SavepointSQL,
+			TRelations
+		>,
+		relations: TRelations,
+		nestedIndex = 0,
+	) {
+		super(dialect, session, relations, nestedIndex, false);
+	}
+
+	override transaction<T>(
+		transaction: (tx: BunSQLTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		return (this.session.client as TransactionSQL).savepoint((client) => {
+			const session = new BunSQLSession<SavepointSQL, TRelations>(
+				client,
+				this.dialect,
+				this._.relations,
+				this.session.options,
+			);
+			const tx = new BunSQLTransaction<TRelations>(
+				this.dialect,
+				session,
+				this._.relations,
+			);
+			return transaction(tx);
+		}) as Promise<T>;
+	}
+}
+
+export interface BunSQLQueryResultHKT extends PgQueryResultHKT {
+	type: this['row'][];
+}
diff --git a/drizzle-orm/src/bun-sql/session.ts b/drizzle-orm/src/bun-sql/session.ts
index 6aa62faa0b..5b758420a9 100644
--- a/drizzle-orm/src/bun-sql/session.ts
+++ b/drizzle-orm/src/bun-sql/session.ts
@@ -1,224 +1 @@
-/// <reference types="bun-types" />
-
-import type { SavepointSQL, SQL, TransactionSQL } from 'bun';
-import { type Cache, NoopCache } from '~/cache/core/index.ts';
-import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
-import { NoopLogger } from '~/logger.ts';
-import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
-import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
-export class BunSQLPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'BunSQLPreparedQuery';
-
-	constructor(
-		private client: SQL,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		return tracer.startActiveSpan('drizzle.execute', async (span) => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-
-			span?.setAttributes({
-				'drizzle.query.text': this.queryString,
-				'drizzle.query.params': JSON.stringify(params),
-			});
-
-			this.logger.logQuery(this.queryString, params);
-
-			const { fields, queryString: query, client, joinsNotNullableMap, customResultMapper } = this;
-			if (!fields && !customResultMapper) {
-				return tracer.startActiveSpan('drizzle.driver.execute', async () => {
-					return await this.queryWithCache(query, params, async () => {
-						return await client.unsafe(query, params as any[]);
-					});
-				});
-			}
-
-			const rows: any[] = await tracer.startActiveSpan('drizzle.driver.execute', async () => {
-				span?.setAttributes({
-					'drizzle.query.text': query,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-
-				return await this.queryWithCache(query, params, async () => {
-					return client.unsafe(query, params as any[]).values();
-				});
-			});
-
-			return tracer.startActiveSpan('drizzle.mapResponse', () => {
-				return customResultMapper
-					? customResultMapper(rows)
-					: rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-			});
-		});
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		return tracer.startActiveSpan('drizzle.execute', async (span) => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-			span?.setAttributes({
-				'drizzle.query.text': this.queryString,
-				'drizzle.query.params': JSON.stringify(params),
-			});
-			this.logger.logQuery(this.queryString, params);
-			return tracer.startActiveSpan('drizzle.driver.execute', async () => {
-				span?.setAttributes({
-					'drizzle.query.text': this.queryString,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return await this.queryWithCache(this.queryString, params, async () => {
-					return await this.client.unsafe(this.queryString, params as any[]);
-				});
-			});
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
-export interface BunSQLSessionOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class BunSQLSession<
-	TSQL extends SQL,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<BunSQLQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLSession';
-
-	logger: Logger;
-	private cache: Cache;
-
-	constructor(
-		public client: TSQL,
-		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		/** @internal */
-		readonly options: BunSQLSessionOptions = {},
-	) {
-		super(dialect);
-		this.logger = options.logger ?? new NoopLogger();
-		this.cache = options.cache ?? new NoopCache();
-	}
-
-	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		},
-		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new BunSQLPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
-		);
-	}
-
-	query(query: string, params: unknown[]): Promise<any> {
-		this.logger.logQuery(query, params);
-		return this.client.unsafe(query, params as any[]).values();
-	}
-
-	queryObjects(
-		query: string,
-		params: unknown[],
-	): Promise<any> {
-		return this.client.unsafe(query, params as any[]);
-	}
-
-	override transaction<T>(
-		transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>,
-		config?: PgTransactionConfig,
-	): Promise<T> {
-		return this.client.begin(async (client) => {
-			const session = new BunSQLSession<TransactionSQL, TFullSchema, TSchema>(
-				client,
-				this.dialect,
-				this.schema,
-				this.options,
-			);
-			const tx = new BunSQLTransaction(this.dialect, session, this.schema);
-			if (config) {
-				await tx.setTransaction(config);
-			}
-			return transaction(tx);
-		}) as Promise<T>;
-	}
-}
-
-export class BunSQLTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<BunSQLQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLTransaction';
-
-	constructor(
-		dialect: PgDialect,
-		/** @internal */
-		override readonly session: BunSQLSession<TransactionSQL | SavepointSQL, TFullSchema, TSchema>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
-		nestedIndex = 0,
-	) {
-		super(dialect, session, schema, nestedIndex);
-	}
-
-	override transaction<T>(
-		transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T> {
-		return (this.session.client as TransactionSQL).savepoint((client) => {
-			const session = new BunSQLSession<SavepointSQL, TFullSchema, TSchema>(
-				client,
-				this.dialect,
-				this.schema,
-				this.session.options,
-			);
-			const tx = new BunSQLTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
-			return transaction(tx);
-		}) as Promise<T>;
-	}
-}
-
-export interface BunSQLQueryResultHKT extends PgQueryResultHKT {
-	type: Assume<this['row'], Record<string, any>[]>;
-}
+export * from './postgres/session.ts';
diff --git a/drizzle-orm/src/bun-sql/sqlite/driver.ts b/drizzle-orm/src/bun-sql/sqlite/driver.ts
new file mode 100644
index 0000000000..9b16845310
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/sqlite/driver.ts
@@ -0,0 +1,114 @@
+/// <reference types="bun-types" />
+
+import { SQL } from 'bun';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import type { BunSQLiteRunResult } from './session.ts';
+import { BunSQLiteSession } from './session.ts';
+
+export class BunSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', BunSQLiteRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'BunSQLiteDatabase';
+}
+
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	client: SQL,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): BunSQLiteDatabase<TRelations> & {
+	$client: SQL;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new BunSQLiteSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new BunSQLiteDatabase('async', dialect, session, relations);
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+
+	return db as any;
+}
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+	TClient extends SQL = SQL,
+>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | ({ url?: string } & SQL.Options);
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): BunSQLiteDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new SQL(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as {
+		connection?: { url?: string } & SQL.Options;
+		client?: TClient;
+	} & DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
+
+	if (typeof connection === 'object' && connection.url !== undefined) {
+		const { url, ...config } = connection;
+
+		const instance = new SQL({ url, ...config });
+		return construct(instance, DrizzleSQLiteConfig) as any;
+	}
+
+	const instance = new SQL(connection);
+	return construct(instance, DrizzleSQLiteConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): BunSQLiteDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({
+			options: {
+				parsers: {},
+				serializers: {},
+			},
+		} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/gel/index.ts b/drizzle-orm/src/bun-sql/sqlite/index.ts
similarity index 100%
rename from drizzle-orm/src/gel/index.ts
rename to drizzle-orm/src/bun-sql/sqlite/index.ts
diff --git a/drizzle-orm/src/bun-sql/sqlite/migrator.ts b/drizzle-orm/src/bun-sql/sqlite/migrator.ts
new file mode 100644
index 0000000000..1242cb0570
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/sqlite/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
+import type { BunSQLiteDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: BunSQLiteDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return await migrateAsync(migrations, db, config);
+}
diff --git a/drizzle-orm/src/bun-sql/sqlite/session.ts b/drizzle-orm/src/bun-sql/sqlite/session.ts
new file mode 100644
index 0000000000..38675f014c
--- /dev/null
+++ b/drizzle-orm/src/bun-sql/sqlite/session.ts
@@ -0,0 +1,146 @@
+/// <reference types="bun-types" />
+
+import type { SavepointSQL, SQL as BunSQL, TransactionSQL } from 'bun';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+
+export interface BunSQLiteSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+export type BunSQLiteRunResult = Record<string, unknown>[] & Record<string, unknown>;
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class BunSQLiteSession<
+	TSQL extends BunSQL,
+	TRelations extends AnyRelations,
+> extends SQLiteAsyncSession<'async', BunSQLiteRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'BunSQLiteSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		readonly client: TSQL,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		readonly options: BunSQLiteSessionOptions,
+	) {
+		super(dialect, 'async');
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<T & { run: BunSQLiteRunResult }> {
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values();
+				return q;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values().then((rows) => rows[0]);
+				return q.then((rows) => rows[0]);
+			},
+			run: (params) => {
+				return this.client.unsafe(query.sql, params);
+			},
+			values: (params) => {
+				return this.client.unsafe(query.sql, params).values();
+			},
+		};
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (db: BunSQLiteTransaction<TRelations>) => T | Promise<T>,
+		config?: SQLiteTransactionConfig,
+	): Promise<T> {
+		return this.client.begin(config?.behavior ?? '', async (client) => {
+			const session = new BunSQLiteSession<SavepointSQL, TRelations>(
+				client,
+				this.dialect,
+				this.relations,
+				this.options,
+			);
+			const tx = new BunSQLiteTransaction<TRelations>(
+				'async',
+				this.dialect,
+				session,
+				this.relations,
+			);
+
+			return await transaction(tx);
+		}) as Promise<T>;
+	}
+}
+
+export class BunSQLiteTransaction<
+	TRelations extends AnyRelations,
+> extends SQLiteAsyncTransaction<'async', BunSQLiteRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'BunSQLiteTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: BunSQLiteTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		return (<BunSQLiteSession<TransactionSQL, any>> <unknown> this.session).client.savepoint(
+			async (client) => {
+				const session = new BunSQLiteSession<SavepointSQL, TRelations>(
+					client,
+					this.session.dialect,
+					this._.relations,
+					(<BunSQLiteSession<TransactionSQL, any>> <unknown> this.session).options,
+				);
+				const tx = new BunSQLiteTransaction(
+					'async',
+					this.dialect,
+					session,
+					this._.relations,
+					this.nestedIndex + 1,
+				);
+				return await transaction(tx);
+			},
+		);
+	}
+}
diff --git a/drizzle-orm/src/bun-sqlite/driver.ts b/drizzle-orm/src/bun-sqlite/driver.ts
index 9d2f9415be..45bc45c68d 100644
--- a/drizzle-orm/src/bun-sqlite/driver.ts
+++ b/drizzle-orm/src/bun-sqlite/driver.ts
@@ -3,24 +3,20 @@
 import { Database } from 'bun:sqlite';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import { SQLiteBunSession } from './session.ts';
-
-export class BunSQLiteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'sync', void, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLiteDatabase';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type SQLiteBunRunResult, SQLiteBunSession } from './session.ts';
+
+export class SQLiteBunDatabase<
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SQLiteAsyncDatabase<'sync', SQLiteBunRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'SQLiteBunDatabase';
 }
 
-type DrizzleBunSqliteDatabaseOptions = {
+type DrizzleSqliteBunDatabaseOptions = {
 	/**
 	 * Open the database as read-only (no write operations, no create).
 	 *
@@ -44,17 +40,21 @@ type DrizzleBunSqliteDatabaseOptions = {
 export type DrizzleBunSqliteDatabaseConfig =
 	| ({
 		source?: string;
-	} & DrizzleBunSqliteDatabaseOptions)
+	} & DrizzleSqliteBunDatabaseOptions)
 	| string
 	| undefined;
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
 	client: Database,
-	config: DrizzleConfig<TSchema> = {},
-): BunSQLiteDatabase<TSchema> & {
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): SQLiteBunDatabase<TRelations> & {
 	$client: Database;
 } {
-	const dialect = new SQLiteSyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -62,42 +62,37 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new SQLiteBunSession(client, dialect, schema, { logger });
-	const db = new BunSQLiteDatabase('sync', dialect, session, schema) as BunSQLiteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SQLiteBunSession<TRelations>(
+		client,
+		dialect,
+		relations,
+		{
+			logger,
+		},
+	);
+	const db = new SQLiteBunDatabase('sync', dialect, session, relations);
 	(<any> db).$client = client;
 
 	return db as any;
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Database = Database,
 >(
 	...params:
 		| []
 		| [
-			TClient | string,
+			string,
 		]
 		| [
-			TClient | string,
-			DrizzleConfig<TSchema>,
+			string,
+			DrizzleSQLiteConfig<TRelations>,
 		]
 		| [
 			(
-				& DrizzleConfig<TSchema>
+				& DrizzleSQLiteConfig<TRelations>
 				& ({
 					connection?: DrizzleBunSqliteDatabaseConfig;
 				} | {
@@ -105,7 +100,7 @@ export function drizzle<
 				})
 			),
 		]
-): BunSQLiteDatabase<TSchema> & {
+): SQLiteBunDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (params[0] === undefined || typeof params[0] === 'string') {
@@ -114,38 +109,34 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& ({
-				connection?: DrizzleBunSqliteDatabaseConfig | string;
-				client?: TClient;
-			})
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& ({
+			connection?: DrizzleBunSqliteDatabaseConfig | string;
+			client?: TClient;
+		})
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		if (typeof connection === 'object') {
-			const { source, ...opts } = connection;
+	if (typeof connection === 'object') {
+		const { source, ...opts } = connection;
 
-			const options = Object.values(opts).filter((v) => v !== undefined).length ? opts : undefined;
+		const options = Object.values(opts).filter((v) => v !== undefined).length ? opts : undefined;
 
-			const instance = new Database(source, options);
+		const instance = new Database(source, options);
 
-			return construct(instance, drizzleConfig) as any;
-		}
-
-		const instance = new Database(connection);
-
-		return construct(instance, drizzleConfig) as any;
+		return construct(instance, DrizzleSQLiteConfig) as any;
 	}
 
-	return construct(params[0] as Database, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	const instance = new Database(connection);
+
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): BunSQLiteDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): SQLiteBunDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/bun-sqlite/migrator.ts b/drizzle-orm/src/bun-sqlite/migrator.ts
index 785dabae95..fda9b0df3d 100644
--- a/drizzle-orm/src/bun-sqlite/migrator.ts
+++ b/drizzle-orm/src/bun-sqlite/migrator.ts
@@ -1,11 +1,44 @@
-import type { MigrationConfig } from '~/migrator.ts';
+import type {
+	MigrationConfig,
+	MigrationFromJournalConfig,
+	MigrationMeta,
+	MigrationsJournal,
+	MigratorInitFailResponse,
+} from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import type { BunSQLiteDatabase } from './driver.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { migrateSync } from '~/sqlite-core/async/session.ts';
+import type { SQLiteBunDatabase } from './driver.ts';
 
-export function migrate<TSchema extends Record<string, unknown>>(
-	db: BunSQLiteDatabase<TSchema>,
+export function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: SQLiteBunDatabase<TRelations>,
 	config: MigrationConfig,
-) {
-	const migrations = readMigrationFiles(config);
-	db.dialect.migrate(migrations, db.session, config);
+): void | MigratorInitFailResponse;
+export function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: SQLiteBunDatabase<TRelations>,
+	config: MigrationFromJournalConfig | MigrationsJournal,
+): void;
+export function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: SQLiteBunDatabase<TRelations>,
+	config: MigrationConfig | MigrationFromJournalConfig | MigrationsJournal,
+): void | MigratorInitFailResponse {
+	if (Array.isArray(config) || 'migrationsJournal' in config) {
+		const journal = Array.isArray(config) ? config : config.migrationsJournal;
+		const migrationsTable = Array.isArray(config) ? undefined : config.migrationsTable;
+
+		const migrations: MigrationMeta[] = journal.map((d) => ({
+			sql: d.sql.split('--> statement-breakpoint'),
+			folderMillis: d.timestamp,
+			hash: '',
+			bps: true,
+			name: d.name,
+		}));
+
+		return migrateSync(migrations, db.session, {
+			migrationsTable,
+		});
+	}
+
+	const migrations = readMigrationFiles(config as MigrationConfig);
+	return migrateSync(migrations, db.session, config as MigrationConfig);
 }
diff --git a/drizzle-orm/src/bun-sqlite/session.ts b/drizzle-orm/src/bun-sqlite/session.ts
index 88d7364614..413c84611e 100644
--- a/drizzle-orm/src/bun-sqlite/session.ts
+++ b/drizzle-orm/src/bun-sqlite/session.ts
@@ -1,44 +1,46 @@
 /// <reference types="bun-types" />
 
-import type { Database, Statement as BunStatement } from 'bun:sqlite';
+import type { Changes, Database } from 'bun:sqlite';
 import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SQLiteExecuteMethod,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 
 export interface SQLiteBunSessionOptions {
 	logger?: Logger;
+	cache?: Cache;
 }
 
+export type SQLiteBunRunResult = Changes;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
-type Statement = BunStatement<any>;
 
-export class SQLiteBunSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'sync', void, TFullSchema, TSchema> {
+export class SQLiteBunSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'sync', SQLiteBunRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SQLiteBunSession';
 
 	private logger: Logger;
 
 	constructor(
 		private client: Database,
-		dialect: SQLiteSyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: SQLiteBunSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: SQLiteBunSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'sync');
 		this.logger = options.logger ?? new NoopLogger();
 	}
 
@@ -48,28 +50,57 @@ export class SQLiteBunSession<
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
-	): PreparedQuery<T> {
-		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(
-			stmt,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+	): SQLiteAsyncPreparedQuery<T & { run: SQLiteBunRunResult }> {
+		let stmt: ReturnType<typeof this.client.query>;
+		try {
+			stmt = this.client.query(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				if (mode === 'arrays') return stmt.values(...params as any[]);
+				return stmt.all(...params as any[]);
+			},
+			get: (params) => {
+				if (mode === 'arrays') return stmt.values(...params as any[])[0];
+				return stmt.get(...params as any[]);
+			},
+			run: (params) => {
+				return stmt.run(...params as any[]);
+			},
+			values: (params) => {
+				return stmt.values(...params as any[]);
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+			undefined,
+			queryMetadata,
+			undefined,
 		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: SQLiteBunTransaction<TFullSchema, TSchema>) => T,
+		transaction: (tx: SQLiteBunTransaction<TRelations>) => T,
 		config: SQLiteTransactionConfig = {},
 	): T {
-		const tx = new SQLiteBunTransaction('sync', this.dialect, this, this.schema);
+		const tx = new SQLiteBunTransaction('sync', this.dialect, this, this.relations);
 		let result: T | undefined;
 		const nativeTx = this.client.transaction(() => {
 			result = transaction(tx);
@@ -80,95 +111,32 @@ export class SQLiteBunSession<
 }
 
 export class SQLiteBunTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'sync', void, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends SQLiteAsyncTransaction<'sync', SQLiteBunRunResult, TRelations> {
 	static override readonly [entityKind]: string = 'SQLiteBunTransaction';
 
-	override transaction<T>(transaction: (tx: SQLiteBunTransaction<TFullSchema, TSchema>) => T): T {
+	override transaction<T>(
+		transaction: (
+			tx: SQLiteBunTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new SQLiteBunTransaction('sync', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new SQLiteBunTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = transaction(tx);
 			this.session.run(sql.raw(`release savepoint ${savepointName}`));
-			return result;
+			return result as T;
 		} catch (err) {
 			this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
 			throw err;
 		}
 	}
 }
-
-export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<
-	{ type: 'sync'; run: void; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'SQLiteBunPreparedQuery';
-
-	constructor(
-		private stmt: Statement,
-		query: Query,
-		private logger: Logger,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
-	) {
-		super('sync', executeMethod, query);
-	}
-
-	run(placeholderValues?: Record<string, unknown>) {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.stmt.run(...params);
-	}
-
-	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, query, logger, joinsNotNullableMap, stmt, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return stmt.all(...params);
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		const row = this.stmt.values(...params)[0];
-
-		if (!row) {
-			return undefined;
-		}
-
-		const { fields, joinsNotNullableMap, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			return row;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper([row]) as T['get'];
-		}
-
-		return mapResultRow(fields!, row, joinsNotNullableMap);
-	}
-
-	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.stmt.values(...params);
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
diff --git a/drizzle-orm/src/cache/core/cache-effect.ts b/drizzle-orm/src/cache/core/cache-effect.ts
new file mode 100644
index 0000000000..9bf94e915c
--- /dev/null
+++ b/drizzle-orm/src/cache/core/cache-effect.ts
@@ -0,0 +1,135 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+import { entityKind } from '~/entity.ts';
+import { type Cache as DrizzleCache, type MutationOption, NoopCache } from './cache.ts';
+import type { CacheConfig } from './types.ts';
+
+export interface EffectCacheShape {
+	readonly strategy: () => 'explicit' | 'all';
+	readonly get: (
+		key: string,
+		tables: string[],
+		isTag: boolean,
+		isAutoInvalidate?: boolean,
+	) => Effect.Effect<any[] | undefined, EffectCacheError, never>;
+	readonly put: (
+		hashedQuery: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	) => Effect.Effect<void, EffectCacheError, never>;
+	readonly onMutate: (params: MutationOption) => Effect.Effect<void, EffectCacheError, never>;
+	/** Container for async cache if made by wrapping one */
+	readonly cache?: DrizzleCache;
+}
+
+/**
+ * Effect service for caching query results in Drizzle ORM.
+ *
+ * By default, this service uses a no-op cache (no caching occurs). Use
+ * `EffectCache.fromDrizzle` to adapt a standard Drizzle cache implementation.
+ *
+ * @example
+ * ```ts
+ * // Use default (no caching)
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // Use a custom Drizzle cache
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectCache.layerFromDrizzle(myCache)),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export class EffectCache extends Context.Service<EffectCache, EffectCacheShape>()('drizzle-orm/EffectCache', {
+	make: Effect.sync((): EffectCacheShape => make(new NoopCache())),
+}) {
+	static readonly [entityKind]: string = 'drizzle-orm/EffectCache';
+
+	/**
+	 * The default layer providing a no-op cache.
+	 */
+	static readonly Default = Layer.effect(EffectCache, EffectCache.make);
+
+	/**
+	 * Creates an EffectCacheShape from a standard Drizzle cache.
+	 *
+	 * @param cache - A Drizzle cache instance implementing the `Cache` interface.
+	 * @returns A new EffectCacheShape that delegates to the provided Drizzle cache.
+	 *
+	 * @example
+	 * ```ts
+	 * const drizzleCache = new MyCustomCache();
+	 * const effectCache = EffectCache.fromDrizzle(drizzleCache);
+	 * ```
+	 */
+	static fromDrizzle(cache: DrizzleCache): EffectCacheShape {
+		return make(cache);
+	}
+
+	/**
+	 * Creates a Layer that provides an EffectCache from a standard Drizzle cache.
+	 *
+	 * @param cache - A Drizzle cache instance implementing the `Cache` interface.
+	 * @returns A Layer that provides the EffectCache service.
+	 *
+	 * @example
+	 * ```ts
+	 * const drizzleCache = new MyCustomCache();
+	 * const db = yield* PgDrizzle.make({ relations }).pipe(
+	 *   Effect.provide(EffectCache.layerFromDrizzle(drizzleCache)),
+	 *   Effect.provide(PgDrizzle.DefaultServices),
+	 * );
+	 * ```
+	 */
+	static layerFromDrizzle(cache: DrizzleCache) {
+		return Layer.succeed(EffectCache, EffectCache.fromDrizzle(cache));
+	}
+}
+
+function make(cache: DrizzleCache): EffectCacheShape {
+	const strategy = () => cache.strategy();
+
+	const get = (...args: Parameters<DrizzleCache['get']>) =>
+		Effect.tryPromise({
+			try: () => cache.get(...args),
+			catch: (error) => new EffectCacheError({ cause: error }),
+		});
+
+	const put = (...args: Parameters<DrizzleCache['put']>) =>
+		Effect.tryPromise({
+			try: () => cache.put(...args),
+			catch: (error) => new EffectCacheError({ cause: error }),
+		});
+
+	const onMutate = (params: MutationOption) =>
+		Effect.tryPromise({
+			try: () => cache.onMutate(params),
+			catch: (error) => new EffectCacheError({ cause: error }),
+		});
+
+	return {
+		strategy,
+		get,
+		put,
+		onMutate,
+		cache,
+	};
+}
+
+/**
+ * Error type for cache operation failures.
+ *
+ * This error is thrown when any cache operation (get, put, onMutate) fails.
+ * The original error is available in the `cause` property.
+ */
+export class EffectCacheError extends Schema.TaggedErrorClass<EffectCacheError>()('EffectCacheError', {
+	cause: Schema.Unknown,
+}) {
+	static readonly [entityKind]: string = 'EffectCacheError';
+}
diff --git a/drizzle-orm/src/cache/core/cache.ts b/drizzle-orm/src/cache/core/cache.ts
index 4f71a273f0..598230d07d 100644
--- a/drizzle-orm/src/cache/core/cache.ts
+++ b/drizzle-orm/src/cache/core/cache.ts
@@ -1,6 +1,6 @@
 import { entityKind } from '~/entity.ts';
-import type { Table } from '~/index.ts';
-import type { CacheConfig } from './types.ts';
+import type { Table } from '~/table.ts';
+import type { CacheConfig, WithCacheConfig } from './types.ts';
 
 export abstract class Cache {
 	static readonly [entityKind]: string = 'Cache';
@@ -42,12 +42,12 @@ export abstract class Cache {
 }
 
 export class NoopCache extends Cache {
+	static override readonly [entityKind]: string = 'NoopCache';
+
 	override strategy() {
 		return 'all' as const;
 	}
 
-	static override readonly [entityKind]: string = 'NoopCache';
-
 	override async get(_key: string): Promise<any[] | undefined> {
 		return undefined;
 	}
@@ -64,10 +64,46 @@ export class NoopCache extends Cache {
 	}
 }
 
+// TODO: one place for all dialects
+export const strategyFor = async (
+	query: string,
+	params: any[] | undefined,
+	queryMetadata: {
+		type: 'select' | 'update' | 'delete' | 'insert';
+		tables: string[];
+	} | undefined,
+	withCacheConfig?: WithCacheConfig,
+) => {
+	if (!queryMetadata) return { type: 'skip' as const };
+
+	const { type, tables } = queryMetadata;
+
+	if ((type === 'insert' || type === 'update' || type === 'delete') && tables.length > 0) {
+		return { type: 'invalidate' as const, tables };
+	}
+
+	if (!withCacheConfig) return { type: 'skip' as const };
+	if (!withCacheConfig.enabled) return { type: 'skip' as const };
+
+	if (type === 'select') {
+		const tag = withCacheConfig.tag ?? await hashQuery(query, params);
+
+		return {
+			type: 'try' as const,
+			key: tag,
+			isTag: typeof withCacheConfig.tag !== 'undefined',
+			autoInvalidate: withCacheConfig.autoInvalidate,
+			tables: queryMetadata.tables,
+			config: withCacheConfig.config,
+		};
+	}
+	return { type: 'skip' as const };
+};
+
 export type MutationOption = { tags?: string | string[]; tables?: Table<any> | Table<any>[] | string | string[] };
 
 export async function hashQuery(sql: string, params?: any[]) {
-	const dataToHash = `${sql}-${JSON.stringify(params)}`;
+	const dataToHash = `${sql}-${JSON.stringify(params, (_, v) => typeof v === 'bigint' ? `${v}n` : v)}`;
 	const encoder = new TextEncoder();
 	const data = encoder.encode(dataToHash);
 	const hashBuffer = await crypto.subtle.digest('SHA-256', data);
diff --git a/drizzle-orm/src/cache/core/types.ts b/drizzle-orm/src/cache/core/types.ts
index 1b31193cec..19a56a86da 100644
--- a/drizzle-orm/src/cache/core/types.ts
+++ b/drizzle-orm/src/cache/core/types.ts
@@ -26,4 +26,4 @@ export type CacheConfig = {
 	hexOptions?: 'NX' | 'nx' | 'XX' | 'xx' | 'GT' | 'gt' | 'LT' | 'lt';
 };
 
-export type WithCacheConfig = { enable: boolean; config?: CacheConfig; tag?: string; autoInvalidate?: boolean };
+export type WithCacheConfig = { enabled: boolean; config?: CacheConfig; tag?: string; autoInvalidate?: boolean };
diff --git a/drizzle-orm/src/cache/upstash/cache.ts b/drizzle-orm/src/cache/upstash/cache.ts
index 8e6a54c1a8..6a8388c142 100644
--- a/drizzle-orm/src/cache/upstash/cache.ts
+++ b/drizzle-orm/src/cache/upstash/cache.ts
@@ -2,7 +2,7 @@ import { Redis } from '@upstash/redis';
 import type { MutationOption } from '~/cache/core/index.ts';
 import { Cache } from '~/cache/core/index.ts';
 import { entityKind, is } from '~/entity.ts';
-import { OriginalName, Table } from '~/index.ts';
+import { OriginalName, Table } from '~/table.ts';
 import type { CacheConfig } from '../core/types.ts';
 
 const getByTagScript = `
diff --git a/drizzle-orm/src/casing.ts b/drizzle-orm/src/casing.ts
index 8372227b3c..12e5b4cecb 100644
--- a/drizzle-orm/src/casing.ts
+++ b/drizzle-orm/src/casing.ts
@@ -1,7 +1,4 @@
-import type { Column } from '~/column.ts';
-import { entityKind } from './entity.ts';
-import { Table } from './table.ts';
-import type { Casing } from './utils.ts';
+export type Casing = 'snake_case' | 'camelCase';
 
 export function toSnakeCase(input: string) {
 	const words = input
@@ -22,55 +19,8 @@ export function toCamelCase(input: string) {
 	}, '');
 }
 
-function noopCase(input: string) {
-	return input;
-}
-
-export class CasingCache {
-	static readonly [entityKind]: string = 'CasingCache';
-
-	/** @internal */
-	cache: Record<string, string> = {};
-	private cachedTables: Record<string, true> = {};
-	private convert: (input: string) => string;
-
-	constructor(casing?: Casing) {
-		this.convert = casing === 'snake_case'
-			? toSnakeCase
-			: casing === 'camelCase'
-			? toCamelCase
-			: noopCase;
-	}
-
-	getColumnCasing(column: Column): string {
-		if (!column.keyAsName) return column.name;
-
-		const schema = column.table[Table.Symbol.Schema] ?? 'public';
-		const tableName = column.table[Table.Symbol.OriginalName];
-		const key = `${schema}.${tableName}.${column.name}`;
-
-		if (!this.cache[key]) {
-			this.cacheTable(column.table);
-		}
-		return this.cache[key]!;
-	}
-
-	private cacheTable(table: Table) {
-		const schema = table[Table.Symbol.Schema] ?? 'public';
-		const tableName = table[Table.Symbol.OriginalName];
-		const tableKey = `${schema}.${tableName}`;
-
-		if (!this.cachedTables[tableKey]) {
-			for (const column of Object.values(table[Table.Symbol.Columns])) {
-				const columnKey = `${tableKey}.${column.name}`;
-				this.cache[columnKey] = this.convert(column.name);
-			}
-			this.cachedTables[tableKey] = true;
-		}
-	}
-
-	clearCache() {
-		this.cache = {};
-		this.cachedTables = {};
-	}
+export function getCasingFn(casing: Casing | undefined) {
+	if (casing === 'snake_case') return toSnakeCase;
+	if (casing === 'camelCase') return toCamelCase;
+	return (name: string) => name;
 }
diff --git a/drizzle-orm/src/cockroach-core/alias.ts b/drizzle-orm/src/cockroach-core/alias.ts
new file mode 100644
index 0000000000..1bf0d9a30d
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/alias.ts
@@ -0,0 +1,11 @@
+import { TableAliasProxyHandler } from '~/alias.ts';
+import type { BuildAliasTable } from './query-builders/select.types.ts';
+import type { CockroachTable } from './table.ts';
+import type { CockroachViewBase } from './view-base.ts';
+
+export function alias<TTable extends CockroachTable | CockroachViewBase, TAlias extends string>(
+	table: TTable,
+	alias: TAlias,
+): BuildAliasTable<TTable, TAlias> {
+	return new Proxy(table, new TableAliasProxyHandler(alias, false)) as any;
+}
diff --git a/drizzle-orm/src/cockroach-core/casing.ts b/drizzle-orm/src/cockroach-core/casing.ts
new file mode 100644
index 0000000000..89c60eadcc
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/casing.ts
@@ -0,0 +1,21 @@
+import { type CockroachSchema, cockroachSchema } from './schema.ts';
+import { cockroachTableWithCasing } from './table.ts';
+import { cockroachMaterializedViewWithCasing, cockroachViewWithCasing } from './view.ts';
+
+export const snakeCase = {
+	table: cockroachTableWithCasing('snake_case'),
+	view: cockroachViewWithCasing('snake_case'),
+	materializedView: cockroachMaterializedViewWithCasing('snake_case'),
+	schema: <T extends string>(name: T): CockroachSchema<T> => {
+		return cockroachSchema(name, 'snake_case');
+	},
+};
+
+export const camelCase = {
+	table: cockroachTableWithCasing('camelCase'),
+	view: cockroachViewWithCasing('camelCase'),
+	materializedView: cockroachMaterializedViewWithCasing('camelCase'),
+	schema: <T extends string>(name: T): CockroachSchema<T> => {
+		return cockroachSchema(name, 'camelCase');
+	},
+};
diff --git a/drizzle-orm/src/cockroach-core/checks.ts b/drizzle-orm/src/cockroach-core/checks.ts
new file mode 100644
index 0000000000..0077960896
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/checks.ts
@@ -0,0 +1,32 @@
+import { entityKind } from '~/entity.ts';
+import type { SQL } from '~/sql/index.ts';
+import type { CockroachTable } from './table.ts';
+
+export class CheckBuilder {
+	static readonly [entityKind]: string = 'CockroachCheckBuilder';
+
+	protected brand!: 'CockroachConstraintBuilder';
+
+	constructor(public name: string, public value: SQL) {}
+
+	/** @internal */
+	build(table: CockroachTable): Check {
+		return new Check(table, this);
+	}
+}
+
+export class Check {
+	static readonly [entityKind]: string = 'CockroachCheck';
+
+	readonly name: string;
+	readonly value: SQL;
+
+	constructor(public table: CockroachTable, builder: CheckBuilder) {
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+}
+
+export function check(name: string, value: SQL): CheckBuilder {
+	return new CheckBuilder(name, value);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/all.ts b/drizzle-orm/src/cockroach-core/columns/all.ts
new file mode 100644
index 0000000000..f7ff121ec0
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/all.ts
@@ -0,0 +1,56 @@
+import { bigint, int8 } from './bigint.ts';
+import { bit } from './bit.ts';
+import { bool } from './bool.ts';
+import { char } from './char.ts';
+import { customType } from './custom.ts';
+import { date } from './date.ts';
+import { decimal, numeric } from './decimal.ts';
+import { doublePrecision, float } from './float.ts';
+import { geometry } from './geometry.ts';
+import { inet } from './inet.ts';
+import { int4 } from './integer.ts';
+import { interval } from './interval.ts';
+import { jsonb } from './jsonb.ts';
+import { real } from './real.ts';
+import { int2, smallint } from './smallint.ts';
+import { string, text } from './string.ts';
+import { time } from './time.ts';
+import { timestamp } from './timestamp.ts';
+import { uuid } from './uuid.ts';
+import { varbit } from './varbit.ts';
+import { varchar } from './varchar.ts';
+import { vector } from './vector.ts';
+
+export function getCockroachColumnBuilders() {
+	return {
+		bigint,
+		bool,
+		char,
+		customType,
+		date,
+		doublePrecision,
+		inet,
+		int4,
+		int2,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		decimal,
+		geometry,
+		real,
+		smallint,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		bit,
+		vector,
+		float,
+		string,
+		varbit,
+	};
+}
+
+export type CockroachColumnsBuilders = ReturnType<typeof getCockroachColumnBuilders>;
diff --git a/drizzle-orm/src/cockroach-core/columns/bigint.ts b/drizzle-orm/src/cockroach-core/columns/bigint.ts
new file mode 100644
index 0000000000..6224796dbd
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/bigint.ts
@@ -0,0 +1,111 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn } from './common.ts';
+import { CockroachIntColumnBaseBuilder } from './int.common.ts';
+
+export class CockroachBigInt53Builder extends CockroachIntColumnBaseBuilder<{
+	dataType: 'number int53';
+	data: number;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachBigInt53Builder';
+
+	constructor(name: string) {
+		super(name, 'number int53', 'CockroachBigInt53');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachBigInt53(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachBigInt53<T extends ColumnBaseConfig<'number int53'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachBigInt53';
+
+	getSQLType(): string {
+		return 'int8';
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'number') {
+			return value;
+		}
+		return Number(value);
+	};
+}
+
+export class CockroachBigInt64Builder extends CockroachIntColumnBaseBuilder<{
+	dataType: 'bigint int64';
+	data: bigint;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachBigInt64Builder';
+
+	constructor(name: string) {
+		super(name, 'bigint int64', 'CockroachBigInt64');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachBigInt64(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachBigInt64<T extends ColumnBaseConfig<'bigint int64'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachBigInt64';
+
+	getSQLType(): string {
+		return 'int8';
+	}
+
+	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
+	override mapFromDriverValue = (value: string): bigint => {
+		return BigInt(value);
+	};
+}
+
+export interface CockroachBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+	mode: T;
+}
+
+export function bigint<TMode extends CockroachBigIntConfig['mode']>(
+	config: CockroachBigIntConfig<TMode>,
+): TMode extends 'number' ? CockroachBigInt53Builder : CockroachBigInt64Builder;
+export function bigint<TMode extends CockroachBigIntConfig['mode']>(
+	name: string,
+	config: CockroachBigIntConfig<TMode>,
+): TMode extends 'number' ? CockroachBigInt53Builder : CockroachBigInt64Builder;
+export function bigint(a: string | CockroachBigIntConfig, b?: CockroachBigIntConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachBigIntConfig>(a, b);
+	if (config.mode === 'number') {
+		return new CockroachBigInt53Builder(name);
+	}
+	return new CockroachBigInt64Builder(name);
+}
+export function int8<TMode extends CockroachBigIntConfig['mode']>(
+	config: CockroachBigIntConfig<TMode>,
+): TMode extends 'number' ? CockroachBigInt53Builder : CockroachBigInt64Builder;
+export function int8<TMode extends CockroachBigIntConfig['mode']>(
+	name: string,
+	config: CockroachBigIntConfig<TMode>,
+): TMode extends 'number' ? CockroachBigInt53Builder : CockroachBigInt64Builder;
+export function int8(a: string | CockroachBigIntConfig, b?: CockroachBigIntConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachBigIntConfig>(a, b);
+	if (config.mode === 'number') {
+		return new CockroachBigInt53Builder(name);
+	}
+	return new CockroachBigInt64Builder(name);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/bit.ts b/drizzle-orm/src/cockroach-core/columns/bit.ts
new file mode 100644
index 0000000000..e54d7927d5
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/bit.ts
@@ -0,0 +1,54 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachBitBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string binary';
+	data: string;
+	driverParam: string;
+}, { length: number | undefined; setLength: boolean; isLengthExact: true }> {
+	static override readonly [entityKind]: string = 'CockroachBitBuilder';
+
+	constructor(name: string, config: CockroachBitConfig) {
+		super(name, 'string binary', 'CockroachBit');
+		this.config.length = config.length ?? 1;
+		this.config.setLength = config.length !== undefined;
+		this.config.isLengthExact = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachBit(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachBit<T extends ColumnBaseConfig<'string binary'> & { length?: number }>
+	extends CockroachColumn<T, { length: T['length']; setLength: boolean }>
+{
+	static override readonly [entityKind]: string = 'CockroachBit';
+
+	getSQLType(): string {
+		return this.config.setLength ? `bit(${this.length})` : 'bit';
+	}
+}
+
+export interface CockroachBitConfig {
+	length?: number | undefined;
+}
+
+export function bit(config?: CockroachBitConfig): CockroachBitBuilder;
+export function bit(
+	name: string,
+	config?: CockroachBitConfig,
+): CockroachBitBuilder;
+export function bit(a?: string | CockroachBitConfig, b: CockroachBitConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<CockroachBitConfig>(a, b);
+	return new CockroachBitBuilder(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/bool.ts b/drizzle-orm/src/cockroach-core/columns/bool.ts
new file mode 100644
index 0000000000..5c32997076
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/bool.ts
@@ -0,0 +1,40 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachBooleanBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'boolean';
+	data: boolean;
+	driverParam: boolean;
+}> {
+	static override readonly [entityKind]: string = 'CockroachBooleanBuilder';
+
+	constructor(name: string) {
+		super(name, 'boolean', 'CockroachBoolean');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachBoolean(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachBoolean<T extends ColumnBaseConfig<'boolean'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachBoolean';
+
+	getSQLType(): string {
+		return 'bool';
+	}
+}
+
+export function bool(name?: string) {
+	return new CockroachBooleanBuilder(name ?? '');
+}
+
+export const boolean = bool;
diff --git a/drizzle-orm/src/cockroach-core/columns/char.ts b/drizzle-orm/src/cockroach-core/columns/char.ts
new file mode 100644
index 0000000000..3a60766c2a
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/char.ts
@@ -0,0 +1,70 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachCharBuilder<
+	TEnum extends [string, ...string[]],
+> extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		enumValues: TEnum;
+		driverParam: string;
+	},
+	{ enumValues: TEnum | undefined; length: number; setLength: boolean }
+> {
+	static override readonly [entityKind]: string = 'CockroachCharBuilder';
+
+	constructor(name: string, config: CockroachCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'CockroachChar');
+		this.config.enumValues = config.enum;
+		this.config.length = config.length ?? 1;
+		this.config.setLength = config.length !== undefined;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachChar(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachChar<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends CockroachColumn<T, { enumValues: T['enumValues']; setLength: boolean }>
+{
+	static override readonly [entityKind]: string = 'CockroachChar';
+
+	override readonly enumValues = this.config.enumValues;
+
+	getSQLType(): string {
+		return this.config.setLength ? `char(${this.length})` : `char`;
+	}
+}
+
+export interface CockroachCharConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> {
+	enum?: TEnum;
+	length?: number | undefined;
+}
+
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: CockroachCharConfig<T | Writable<T>>,
+): CockroachCharBuilder<Writable<T>>;
+export function char<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	name: string,
+	config?: CockroachCharConfig<T | Writable<T>>,
+): CockroachCharBuilder<Writable<T>>;
+export function char(a?: string | CockroachCharConfig, b: CockroachCharConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<CockroachCharConfig>(a, b);
+	return new CockroachCharBuilder(name, config as any);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/common.ts b/drizzle-orm/src/cockroach-core/columns/common.ts
new file mode 100644
index 0000000000..a8254d9caa
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/common.ts
@@ -0,0 +1,318 @@
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderRuntimeConfig,
+	ColumnType,
+	HasGenerated,
+} from '~/column-builder.ts';
+import { ColumnBuilder } from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { Column } from '~/column.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { Update } from '~/utils.ts';
+
+import type { ForeignKey, UpdateDeleteAction } from '~/cockroach-core/foreign-keys.ts';
+import { ForeignKeyBuilder } from '~/cockroach-core/foreign-keys.ts';
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { SQL } from '~/sql/sql.ts';
+import { iife } from '~/tracing-utils.ts';
+import { makeCockroachArray, parseCockroachArray } from '../utils/array.ts';
+
+export type CockroachColumns = Record<string, CockroachColumn<any>>;
+
+export interface ReferenceConfig {
+	ref: () => CockroachColumn;
+	config: {
+		name?: string;
+		onUpdate?: UpdateDeleteAction;
+		onDelete?: UpdateDeleteAction;
+	};
+}
+export abstract class CockroachColumnBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends ColumnBuilder<T, TRuntimeConfig> {
+	private foreignKeyConfigs: ReferenceConfig[] = [];
+
+	static override readonly [entityKind]: string = 'CockroachColumnBuilder';
+
+	references(
+		ref: ReferenceConfig['ref'],
+		config: ReferenceConfig['config'] = {},
+	): this {
+		this.foreignKeyConfigs.push({ ref, config });
+		return this;
+	}
+
+	unique(
+		name?: string,
+	): this {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		return this;
+	}
+
+	generatedAlwaysAs(as: SQL | (() => SQL)): HasGenerated<this, {
+		type: 'always';
+	}> {
+		this.config.generated = {
+			as,
+			type: 'always',
+			mode: 'stored',
+		};
+		return this as HasGenerated<this, {
+			type: 'always';
+		}>;
+	}
+
+	/** @internal */
+	buildForeignKeys(column: CockroachColumn, table: CockroachTable): ForeignKey[] {
+		return this.foreignKeyConfigs.map(({ ref, config }) => {
+			return iife(
+				(ref, config) => {
+					const builder = new ForeignKeyBuilder(() => {
+						const foreignColumn = ref();
+						return { name: config.name, columns: [column], foreignColumns: [foreignColumn] };
+					});
+					if (config.onUpdate) {
+						builder.onUpdate(config.onUpdate);
+					}
+					if (config.onDelete) {
+						builder.onDelete(config.onDelete);
+					}
+					return builder.build(table);
+				},
+				ref,
+				config,
+			);
+		});
+	}
+
+	/** @internal */
+	abstract build(table: CockroachTable): CockroachColumn<any>;
+
+	/** @internal */
+	buildExtraConfigColumn<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	): ExtraConfigColumn {
+		return new ExtraConfigColumn(table, this.config);
+	}
+}
+
+export abstract class CockroachColumnWithArrayBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends CockroachColumnBuilder<T, TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'CockroachColumnWithArrayBuilder';
+	array<TSize extends number | undefined = undefined>(size?: TSize): Omit<
+		CockroachArrayBuilder<
+			& {
+				name: string;
+				dataType: 'array basecolumn';
+				data: T['data'][];
+				driverParam: T['driverParam'][] | string;
+				baseBuilder: T;
+			}
+			& (T extends { notNull: true } ? { notNull: true } : {})
+			& (T extends { hasDefault: true } ? { hasDefault: true } : {}),
+			T
+		>,
+		'array'
+	> {
+		return new CockroachArrayBuilder(
+			this.config.name,
+			this as CockroachColumnWithArrayBuilder<any, any>,
+			size as any,
+		) as any; // size as any
+	}
+}
+
+// To understand how to use `CockroachColumn` and `AnyCockroachColumn`, see `Column` and `AnyColumn` documentation.
+export abstract class CockroachColumn<
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = {},
+> extends Column<T, TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'CockroachColumn';
+
+	/** @internal */
+	override readonly table: CockroachTable;
+
+	constructor(
+		table: CockroachTable,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
+	) {
+		super(table, config);
+		this.table = table;
+	}
+
+	/** @internal */
+	override shouldDisableInsert(): boolean {
+		return (this.config.generatedIdentity !== undefined && this.config.generatedIdentity.type === 'always')
+			|| (this.config.generated !== undefined && this.config.generated.type !== 'byDefault');
+	}
+}
+
+export type IndexedExtraConfigType = { order?: 'asc' | 'desc' };
+
+export class ExtraConfigColumn<
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
+> extends CockroachColumn<T, IndexedExtraConfigType> {
+	static override readonly [entityKind]: string = 'ExtraConfigColumn';
+
+	override getSQLType(): string {
+		return this.getSQLType();
+	}
+
+	indexConfig: IndexedExtraConfigType = {
+		order: this.config.order ?? 'asc',
+	};
+	defaultConfig: IndexedExtraConfigType = {
+		order: 'asc',
+	};
+
+	asc(): Omit<this, 'asc' | 'desc'> {
+		this.indexConfig.order = 'asc';
+		return this;
+	}
+
+	desc(): Omit<this, 'asc' | 'desc'> {
+		this.indexConfig.order = 'desc';
+		return this;
+	}
+}
+
+export class IndexedColumn {
+	static readonly [entityKind]: string = 'IndexedColumn';
+	constructor(
+		name: string,
+		keyAsName: boolean,
+		type: string,
+		indexConfig: IndexedExtraConfigType,
+	) {
+		this.name = name;
+		this.keyAsName = keyAsName;
+		this.type = type;
+		this.indexConfig = indexConfig;
+	}
+
+	name: string;
+	keyAsName: boolean;
+	type: string;
+	indexConfig: IndexedExtraConfigType;
+}
+
+export type AnyCockroachColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = CockroachColumn<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
+>;
+
+export type CockroachArrayColumnBuilderBaseConfig = ColumnBuilderBaseConfig<'array basecolumn'> & {
+	baseBuilder: ColumnBuilderBaseConfig<ColumnType>;
+};
+
+export class CockroachArrayBuilder<
+	T extends CockroachArrayColumnBuilderBaseConfig,
+	TBase extends ColumnBuilderBaseConfig<ColumnType> | CockroachArrayColumnBuilderBaseConfig,
+> extends CockroachColumnWithArrayBuilder<
+	T & {
+		baseBuilder: TBase extends CockroachArrayColumnBuilderBaseConfig ? CockroachArrayBuilder<
+				TBase,
+				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any> } ? TBaseBuilder
+					: never
+			>
+			: CockroachColumnWithArrayBuilder<TBase, {}>;
+	},
+	{
+		baseBuilder: TBase extends CockroachArrayColumnBuilderBaseConfig ? CockroachArrayBuilder<
+				TBase,
+				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any> } ? TBaseBuilder
+					: never
+			>
+			: CockroachColumnWithArrayBuilder<TBase, {}>;
+		length: number | undefined;
+	}
+> {
+	static override readonly [entityKind]: string = 'CockroachArrayBuilder';
+
+	constructor(
+		name: string,
+		// CockroachArrayBuilder<T, TBase>['config']['baseBuilder'] - removed - 'config' is internal property, do not reference directly in types
+		baseBuilder: TBase extends CockroachArrayColumnBuilderBaseConfig ? CockroachArrayBuilder<
+				TBase,
+				TBase extends {
+					baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any>;
+				} ? TBaseBuilder
+					: never
+			>
+			: CockroachColumnWithArrayBuilder<TBase, {}>,
+		length: number | undefined,
+	) {
+		super(name, 'array basecolumn', 'CockroachArray');
+		this.config.baseBuilder = baseBuilder;
+		this.config.length = length;
+	}
+
+	/** @internal */
+	override build(table: CockroachTable) {
+		const baseColumn: any = this.config.baseBuilder.build(table);
+		return new CockroachArray(
+			table,
+			this.config as any,
+			baseColumn,
+		);
+	}
+}
+
+export class CockroachArray<
+	T extends ColumnBaseConfig<'array basecolumn'> & {
+		length: number | undefined;
+		baseBuilder: ColumnBuilderBaseConfig<ColumnType>;
+	},
+	TBase extends ColumnBuilderBaseConfig<ColumnType>,
+> extends CockroachColumn<T, {}> {
+	static override readonly [entityKind]: string = 'CockroachArray';
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachArrayBuilder<T, TBase>['config'],
+		readonly baseColumn: CockroachColumn,
+		readonly range?: [number | undefined, number | undefined],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return `${this.baseColumn.getSQLType()}[${typeof this.length === 'number' ? this.length : ''}]`;
+	}
+
+	override mapFromDriverValue = (value: unknown[] | string): T['data'] => {
+		if (typeof value === 'string') {
+			value = parseCockroachArray(value);
+		}
+		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+	};
+
+	// Needed for arrays of custom types
+	mapFromJsonValue(value: unknown[] | string): T['data'] {
+		if (typeof value === 'string') {
+			// Thank you node-postgres for not parsing enum arrays
+			value = parseCockroachArray(value);
+		}
+
+		const base = this.baseColumn;
+
+		return 'mapFromJsonValue' in base
+			? value.map((v) => (<(value: unknown) => unknown> base.mapFromJsonValue)(v))
+			: value.map((v) => base.mapFromDriverValue(v));
+	}
+
+	override mapToDriverValue = (value: unknown[], isNestedArray = false): unknown[] | string => {
+		const a = value.map((v) =>
+			v === null
+				? null
+				: is(this.baseColumn, CockroachArray)
+				? this.baseColumn.mapToDriverValue(v as unknown[], true)
+				: this.baseColumn.mapToDriverValue(v)
+		);
+		if (isNestedArray) return a;
+		return makeCockroachArray(a);
+	};
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/custom.ts b/drizzle-orm/src/cockroach-core/columns/custom.ts
new file mode 100644
index 0000000000..9556dac4b2
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/custom.ts
@@ -0,0 +1,369 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBuilderBaseConfig } from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
+	& {
+		dataType: 'custom';
+		data: T['data'];
+		driverParam: T['driverData'];
+	}
+	& (T['notNull'] extends true ? { notNull: true } : {})
+	& (T['default'] extends true ? { hasDefault: true } : {});
+
+export interface CockroachCustomColumnInnerConfig {
+	customTypeValues: CustomTypeValues;
+}
+
+export class CockroachCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>>
+	extends CockroachColumnWithArrayBuilder<
+		T,
+		{
+			fieldConfig: CustomTypeValues['config'];
+			customTypeParams: CustomTypeParams<any>;
+		}
+	>
+{
+	static override readonly [entityKind]: string = 'CockroachCustomColumnBuilder';
+
+	constructor(
+		name: string,
+		fieldConfig: CustomTypeValues['config'],
+		customTypeParams: CustomTypeParams<any>,
+	) {
+		super(name, 'custom', 'CockroachCustomColumn');
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+
+	/** @internal */
+	build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachCustomColumn(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachCustomColumn<T extends ColumnBaseConfig<'custom'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachCustomColumn';
+
+	private sqlName: string;
+	private mapTo?: (value: T['data']) => T['driverParam'];
+	private mapFrom?: (value: T['driverParam']) => T['data'];
+	private mapJson?: (value: unknown) => T['data'];
+	private forJsonSelect?: (identifier: SQL, sql: SQLGenerator, arrayDimensions?: number) => SQL;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachCustomColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapJson = config.customTypeParams.fromJson;
+		this.forJsonSelect = config.customTypeParams.forJsonSelect;
+	}
+
+	getSQLType(): string {
+		return this.sqlName;
+	}
+
+	override mapFromDriverValue = (value: T['driverParam']): T['data'] => {
+		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	};
+
+	mapFromJsonValue(value: unknown): T['data'] {
+		return typeof this.mapJson === 'function' ? this.mapJson(value) : this.mapFromDriverValue(value) as T['data'];
+	}
+
+	jsonSelectIdentifier(identifier: SQL, sql: SQLGenerator, arrayDimensions?: number): SQL {
+		if (typeof this.forJsonSelect === 'function') return this.forJsonSelect(identifier, sql, arrayDimensions);
+
+		const rawType = this.getSQLType().toLowerCase();
+		const parenPos = rawType.indexOf('(');
+		const type = (parenPos + 1) ? rawType.slice(0, parenPos) : rawType;
+
+		switch (type) {
+			case 'geometry':
+			case 'timestamp':
+			case 'decimal':
+			case 'int8': {
+				const arrVal = '[]'.repeat(arrayDimensions ?? 0);
+
+				return sql`${identifier}::text${sql.raw(arrVal).if(arrayDimensions)}`;
+			}
+			default: {
+				return identifier;
+			}
+		}
+	}
+
+	override mapToDriverValue = (value: T['data']): T['driverParam'] => {
+		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	};
+}
+
+export type CustomTypeValues = {
+	/**
+	 * Required type for custom column, that will infer proper type model
+	 *
+	 * Examples:
+	 *
+	 * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+	 *
+	 * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+	 */
+	data: unknown;
+
+	/**
+	 * Type helper, that represents what type database driver is accepting for specific database data type
+	 */
+	driverData?: unknown;
+
+	/**
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
+	/**
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
+	/**
+	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
+	 */
+	config?: Record<string, any>;
+
+	/**
+	 * Whether the config argument should be required or not
+	 * @default false
+	 */
+	configRequired?: boolean;
+
+	/**
+	 * If your custom data type should be notNull by default you can use `notNull: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	notNull?: boolean;
+
+	/**
+	 * If your custom data type has default you can use `default: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	default?: boolean;
+};
+
+export interface CustomTypeParams<T extends CustomTypeValues> {
+	/**
+	 * Database data type string representation, that is used for migrations
+	 * @example
+	 * ```
+	 * `jsonb`, `text`
+	 * ```
+	 *
+	 * If database data type needs additional params you can use them from `config` param
+	 * @example
+	 * ```
+	 * `varchar(256)`, `numeric(2,3)`
+	 * ```
+	 *
+	 * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+	 *
+	 * @example
+	 * Usage example
+	 * ```
+	 *   dataType() {
+	 *     return 'boolean';
+	 *   },
+	 * ```
+	 * Or
+	 * ```
+	 *   dataType(config) {
+	 * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+	 * 	 }
+	 * ```
+	 */
+	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+
+	/**
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
+	 * @example
+	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
+	 * ```
+	 * toDriver(value: TData): string {
+	 * 	 return JSON.stringify(value);
+	 * }
+	 * ```
+	 */
+	toDriver?: (value: T['data']) => T['driverData'] | SQL;
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
+	 * @example
+	 * For example, when using timestamp we need to map string Date representation to JS Date
+	 * ```
+	 * fromDriver(value: string): Date {
+	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07T03:25:16.635Z";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07T03:25:16.635Z");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying bigint column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's string representation, as opposed to bigint from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): bigint {
+	 * 	return BigInt(value);
+	 * },
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "5044565289845416380";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: 5044565289845416380n;
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `bytea`, `geometry`, `timestamp`, `numeric`, `bigint`
+	 * @example
+	 * For example, when using bigint we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator, arrayDimensions?: number): SQL {
+	 * 	return sql`${identifier}::text`
+	 * },
+	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	row_to_json("t".*)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		"table"."custom_bigint" AS "bigint"
+	 * 		FROM
+	 * 		"table"
+	 * 	) AS "t"
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	row_to_json("t".*)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		"table"."custom_bigint"::text AS "bigint"
+	 * 		FROM
+	 * 		"table"
+	 * 	) AS "t"
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
+	 */
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator, arrayDimensions?: number) => SQL;
+}
+
+/**
+ * Custom cockroach database data type generator
+ */
+export function customType<T extends CustomTypeValues = CustomTypeValues>(
+	customTypeParams: CustomTypeParams<T>,
+): Equal<T['configRequired'], true> extends true ? {
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig: TConfig,
+		): CockroachCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
+			fieldConfig: T['config'],
+		): CockroachCustomColumnBuilder<ConvertCustomConfig<T>>;
+	}
+	: {
+		(): CockroachCustomColumnBuilder<ConvertCustomConfig<T>>;
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig?: TConfig,
+		): CockroachCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
+			fieldConfig?: T['config'],
+		): CockroachCustomColumnBuilder<ConvertCustomConfig<T>>;
+	}
+{
+	return (
+		a?: string | T['config'],
+		b?: T['config'],
+	): CockroachCustomColumnBuilder<ConvertCustomConfig<T>> => {
+		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
+		return new CockroachCustomColumnBuilder(name, config, customTypeParams);
+	};
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/date.common.ts b/drizzle-orm/src/cockroach-core/columns/date.common.ts
new file mode 100644
index 0000000000..f3043c2b45
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/date.common.ts
@@ -0,0 +1,15 @@
+import type { ColumnBuilderBaseConfig, ColumnType } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import { sql } from '~/sql/sql.ts';
+import { CockroachColumnWithArrayBuilder } from './common.ts';
+
+export abstract class CockroachDateColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends CockroachColumnWithArrayBuilder<T, TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'CockroachDateColumnBaseBuilder';
+
+	defaultNow() {
+		return this.default(sql`now()`);
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/date.ts b/drizzle-orm/src/cockroach-core/columns/date.ts
new file mode 100644
index 0000000000..a21dbd5249
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/date.ts
@@ -0,0 +1,100 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn } from './common.ts';
+import { CockroachDateColumnBaseBuilder } from './date.common.ts';
+
+export class CockroachDateBuilder extends CockroachDateColumnBaseBuilder<{
+	dataType: 'object date';
+	data: Date;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachDateBuilder';
+
+	constructor(name: string) {
+		super(name, 'object date', 'CockroachDate');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachDate(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachDate<T extends ColumnBaseConfig<'object date'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachDate';
+
+	getSQLType(): string {
+		return 'date';
+	}
+
+	override mapFromDriverValue = (value: string): Date => {
+		return new Date(value);
+	};
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
+}
+
+export class CockroachDateStringBuilder extends CockroachDateColumnBaseBuilder<{
+	dataType: 'string date';
+	data: string;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachDateStringBuilder';
+
+	constructor(name: string) {
+		super(name, 'string date', 'CockroachDateString');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachDateString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachDateString<T extends ColumnBaseConfig<'string date'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachDateString';
+
+	getSQLType(): string {
+		return 'date';
+	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
+}
+
+export interface CockroachDateConfig<T extends 'date' | 'string' = 'date' | 'string'> {
+	mode: T;
+}
+
+export function date<TMode extends CockroachDateConfig['mode'] & {}>(
+	config?: CockroachDateConfig<TMode>,
+): Equal<TMode, 'date'> extends true ? CockroachDateBuilder : CockroachDateStringBuilder;
+export function date<TMode extends CockroachDateConfig['mode'] & {}>(
+	name: string,
+	config?: CockroachDateConfig<TMode>,
+): Equal<TMode, 'date'> extends true ? CockroachDateBuilder
+	: CockroachDateStringBuilder;
+export function date(a?: string | CockroachDateConfig, b?: CockroachDateConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachDateConfig>(a, b);
+	if (config?.mode === 'date') {
+		return new CockroachDateBuilder(name);
+	}
+	return new CockroachDateStringBuilder(name);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/decimal.ts b/drizzle-orm/src/cockroach-core/columns/decimal.ts
new file mode 100644
index 0000000000..5ef49b46fe
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/decimal.ts
@@ -0,0 +1,219 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachDecimalBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'string numeric';
+		data: string;
+		driverParam: string;
+	},
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
+	static override readonly [entityKind]: string = 'CockroachDecimalBuilder';
+
+	constructor(name: string, precision?: number, scale?: number) {
+		super(name, 'string numeric', 'CockroachDecimal');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachDecimal(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachDecimal<T extends ColumnBaseConfig<'string numeric'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachDecimal';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(table: CockroachTable<any>, config: CockroachDecimalBuilder['config']) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue = (value: unknown): string => {
+		if (typeof value === 'string') return value;
+
+		return String(value);
+	};
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export class CockroachDecimalNumberBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'number';
+		data: number;
+		driverParam: string;
+	},
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
+	static override readonly [entityKind]: string = 'CockroachDecimalNumberBuilder';
+
+	constructor(name: string, precision?: number, scale?: number) {
+		super(name, 'number', 'CockroachDecimalNumber');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachDecimalNumber(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachDecimalNumber<T extends ColumnBaseConfig<'number'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachDecimalNumber';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachDecimalNumberBuilder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue = (value: unknown): number => {
+		if (typeof value === 'number') return value;
+
+		return Number(value);
+	};
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export class CockroachDecimalBigIntBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	},
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
+	static override readonly [entityKind]: string = 'CockroachDecimalBigIntBuilder';
+
+	constructor(name: string, precision?: number, scale?: number) {
+		super(name, 'bigint int64', 'CockroachDecimalBigInt');
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachDecimalBigInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachDecimalBigInt<T extends ColumnBaseConfig<'bigint int64'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachDecimalBigInt';
+
+	readonly precision: number | undefined;
+	readonly scale: number | undefined;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachDecimalBigIntBuilder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+
+	override mapFromDriverValue = BigInt;
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export type CockroachDecimalConfig<
+	T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint',
+> =
+	| { precision: number; scale?: number; mode?: T }
+	| { precision?: number; scale: number; mode?: T }
+	| { precision?: number; scale?: number; mode: T };
+
+export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
+	config?: CockroachDecimalConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? CockroachDecimalNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? CockroachDecimalBigIntBuilder
+	: CockroachDecimalBuilder;
+export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
+	name: string,
+	config?: CockroachDecimalConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? CockroachDecimalNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? CockroachDecimalBigIntBuilder
+	: CockroachDecimalBuilder;
+export function decimal(a?: string | CockroachDecimalConfig, b?: CockroachDecimalConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachDecimalConfig>(a, b);
+	const mode = config?.mode;
+	return mode === 'number'
+		? new CockroachDecimalNumberBuilder(name, config?.precision, config?.scale)
+		: mode === 'bigint'
+		? new CockroachDecimalBigIntBuilder(name, config?.precision, config?.scale)
+		: new CockroachDecimalBuilder(name, config?.precision, config?.scale);
+}
+
+// numeric is alias for decimal
+export const numeric = decimal;
diff --git a/drizzle-orm/src/cockroach-core/columns/enum.ts b/drizzle-orm/src/cockroach-core/columns/enum.ts
new file mode 100644
index 0000000000..99e628419b
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/enum.ts
@@ -0,0 +1,184 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { NonArray, Writable } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+// Enum as ts enum
+export interface CockroachEnumObject<TValues extends object> {
+	(name?: string): CockroachEnumObjectColumnBuilder<TValues>;
+
+	readonly enumName: string;
+	readonly enumValues: string[];
+	readonly schema: string | undefined;
+	/** @internal */
+	[isCockroachEnumSym]: true;
+}
+
+export class CockroachEnumObjectColumnBuilder<TValues extends object> extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'string enum';
+		data: TValues[keyof TValues];
+		enumValues: string[];
+		driverParam: string;
+	},
+	{ enum: CockroachEnumObject<any> }
+> {
+	static override readonly [entityKind]: string = 'CockroachEnumObjectColumnBuilder';
+
+	constructor(name: string, enumInstance: CockroachEnumObject<any>) {
+		super(name, 'string enum', 'CockroachEnumObjectColumn');
+		this.config.enum = enumInstance;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachEnumObjectColumn(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachEnumObjectColumn<
+	T extends ColumnBaseConfig<'string enum'> & { enumValues: object },
+> extends CockroachColumn<T, { enum: CockroachEnumObject<object> }> {
+	static override readonly [entityKind]: string = 'CockroachEnumObjectColumn';
+
+	readonly enum;
+	override readonly enumValues = this.config.enum.enumValues;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachEnumObjectColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+
+	getSQLType(): string {
+		return this.enum.enumName;
+	}
+}
+
+// Enum as string union
+const isCockroachEnumSym = Symbol.for('drizzle:isCockroachEnum');
+export interface CockroachEnum<TValues extends [string, ...string[]]> {
+	(name?: string): CockroachEnumColumnBuilder<TValues>;
+
+	readonly enumName: string;
+	readonly enumValues: TValues;
+	readonly schema: string | undefined;
+	/** @internal */
+	[isCockroachEnumSym]: true;
+}
+
+export function isCockroachEnum(obj: unknown): obj is CockroachEnum<[string, ...string[]]> {
+	return !!obj && typeof obj === 'function' && isCockroachEnumSym in obj && obj[isCockroachEnumSym] === true;
+}
+
+export class CockroachEnumColumnBuilder<TValues extends [string, ...string[]]> extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string';
+	data: TValues[number];
+	enumValues: TValues;
+	driverParam: string;
+}, { enum: CockroachEnum<TValues> }> {
+	static override readonly [entityKind]: string = 'CockroachEnumColumnBuilder';
+
+	constructor(name: string, enumInstance: CockroachEnum<TValues>) {
+		super(name, 'string enum', 'CockroachEnumColumn');
+		this.config.enum = enumInstance;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachEnumColumn(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachEnumColumn<
+	T extends ColumnBaseConfig<'string enum'> & { enumValues: [string, ...string[]] },
+> extends CockroachColumn<T, { enum: CockroachEnum<T['enumValues']> }> {
+	static override readonly [entityKind]: string = 'CockroachEnumColumn';
+
+	readonly enum = this.config.enum;
+	override readonly enumValues = this.config.enum.enumValues;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachEnumColumnBuilder<T['enumValues']>['config'],
+	) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+
+	getSQLType(): string {
+		return this.enum.enumName;
+	}
+}
+
+export function cockroachEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
+	enumName: string,
+	values: T | Writable<T>,
+): CockroachEnum<Writable<T>>;
+
+export function cockroachEnum<E extends Record<string, string>>(
+	enumName: string,
+	enumObj: NonArray<E>,
+): CockroachEnumObject<E>;
+
+export function cockroachEnum(
+	enumName: any,
+	input: any,
+): any {
+	return Array.isArray(input)
+		? cockroachEnumWithSchema(enumName, [...input] as [string, ...string[]], undefined)
+		: cockroachEnumObjectWithSchema(enumName, input, undefined);
+}
+
+/** @internal */
+export function cockroachEnumWithSchema<U extends string, T extends Readonly<[U, ...U[]]>>(
+	enumName: string,
+	values: T | Writable<T>,
+	schema?: string,
+): CockroachEnum<Writable<T>> {
+	const enumInstance: CockroachEnum<Writable<T>> = Object.assign(
+		(name?: string): CockroachEnumColumnBuilder<Writable<T>> =>
+			new CockroachEnumColumnBuilder(name ?? '', enumInstance),
+		{
+			enumName,
+			enumValues: values,
+			schema,
+			[isCockroachEnumSym]: true,
+		} as const,
+	);
+
+	return enumInstance;
+}
+
+/** @internal */
+export function cockroachEnumObjectWithSchema<T extends object>(
+	enumName: string,
+	values: T,
+	schema?: string,
+): CockroachEnumObject<T> {
+	const enumInstance: CockroachEnumObject<T> = Object.assign(
+		(name?: string): CockroachEnumObjectColumnBuilder<T> =>
+			new CockroachEnumObjectColumnBuilder(name ?? '', enumInstance),
+		{
+			enumName,
+			enumValues: Object.values(values),
+			schema,
+			[isCockroachEnumSym]: true,
+		} as const,
+	);
+
+	return enumInstance;
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/float.ts b/drizzle-orm/src/cockroach-core/columns/float.ts
new file mode 100644
index 0000000000..cf04f8a3ca
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/float.ts
@@ -0,0 +1,49 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachFloatBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'number double';
+		data: number;
+		driverParam: string | number;
+	}
+> {
+	static override readonly [entityKind]: string = 'CockroachFloatBuilder';
+
+	constructor(name: string) {
+		super(name, 'number double', 'CockroachFloat');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachFloat(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachFloat<T extends ColumnBaseConfig<'number double'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachFloat';
+
+	getSQLType(): string {
+		return 'float';
+	}
+
+	override mapFromDriverValue = (value: string | number): number => {
+		if (typeof value === 'string') {
+			return Number.parseFloat(value);
+		}
+		return value;
+	};
+}
+export function float(name?: string) {
+	return new CockroachFloatBuilder(name ?? '');
+}
+
+// double precision is alias for float
+export const doublePrecision = float;
diff --git a/drizzle-orm/src/cockroach-core/columns/geometry.ts b/drizzle-orm/src/cockroach-core/columns/geometry.ts
new file mode 100644
index 0000000000..b511576413
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/geometry.ts
@@ -0,0 +1,114 @@
+import type { CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+import { parseEWKB } from './utils.ts';
+
+export class CockroachGeometryBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'array geometry';
+	data: [number, number];
+	driverParam: string;
+}, { srid: number | undefined }> {
+	static override readonly [entityKind]: string = 'CockroachGeometryBuilder';
+
+	constructor(name: string, srid?: number) {
+		super(name, 'array geometry', 'CockroachGeometry');
+		this.config.srid = srid;
+	}
+
+	/** @internal */
+	override build(table: CockroachTable<any>) {
+		return new CockroachGeometry(
+			table,
+			this.config as any,
+		);
+	}
+}
+
+export class CockroachGeometry<T extends ColumnBaseConfig<'array geometry'>>
+	extends CockroachColumn<T, { srid: number | undefined }>
+{
+	static override readonly [entityKind]: string = 'CockroachGeometry';
+
+	readonly srid = this.config.srid;
+	readonly mode = 'tuple';
+
+	getSQLType(): string {
+		return `geometry(point${this.srid === undefined ? '' : `,${this.srid}`})`;
+	}
+
+	override mapFromDriverValue = (value: string | [number, number]): [number, number] => {
+		if (typeof value !== 'string') return value as [number, number];
+
+		return parseEWKB(value).point;
+	};
+
+	override mapToDriverValue = (value: [number, number]): string => {
+		return `point(${value[0]} ${value[1]})`;
+	};
+}
+
+export class CockroachGeometryObjectBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'object geometry';
+	data: { x: number; y: number };
+	driverParam: string;
+}, { srid?: number }> {
+	static override readonly [entityKind]: string = 'CockroachGeometryObjectBuilder';
+
+	constructor(name: string, srid: number | undefined) {
+		super(name, 'object geometry', 'CockroachGeometryObject');
+		this.config.srid = srid;
+	}
+
+	/** @internal */
+	override build(table: CockroachTable<any>) {
+		return new CockroachGeometryObject(
+			table,
+			this.config as any,
+		);
+	}
+}
+
+export class CockroachGeometryObject<T extends ColumnBaseConfig<'object geometry'>>
+	extends CockroachColumn<T, { srid: number | undefined }>
+{
+	static override readonly [entityKind]: string = 'CockroachGeometryObject';
+
+	readonly srid = this.config.srid;
+	readonly mode = 'object';
+
+	getSQLType(): string {
+		return `geometry(point${this.srid === undefined ? '' : `,${this.srid}`})`;
+	}
+
+	override mapFromDriverValue = (value: string): { x: number; y: number } => {
+		const parsed = parseEWKB(value);
+		return { x: parsed.point[0], y: parsed.point[1] };
+	};
+
+	override mapToDriverValue = (value: { x: number; y: number }): string => {
+		return `point(${value.x} ${value.y})`;
+	};
+}
+
+export interface CockroachGeometryConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
+	mode?: T;
+	type?: 'point' | (string & {});
+	srid?: number;
+}
+
+export function geometry<TMode extends CockroachGeometryConfig['mode'] & {}>(
+	config?: CockroachGeometryConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? CockroachGeometryObjectBuilder : CockroachGeometryBuilder;
+export function geometry<TMode extends CockroachGeometryConfig['mode'] & {}>(
+	name: string,
+	config?: CockroachGeometryConfig<TMode>,
+): Equal<TMode, 'xy'> extends true ? CockroachGeometryObjectBuilder : CockroachGeometryBuilder;
+export function geometry(a?: string | CockroachGeometryConfig, b?: CockroachGeometryConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachGeometryConfig>(a, b);
+	if (!config?.mode || config.mode === 'tuple') {
+		return new CockroachGeometryBuilder(name, config?.srid);
+	}
+	return new CockroachGeometryObjectBuilder(name, config?.srid);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/index.ts b/drizzle-orm/src/cockroach-core/columns/index.ts
new file mode 100644
index 0000000000..0076d5bf1e
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/index.ts
@@ -0,0 +1,25 @@
+export * from './bigint.ts';
+export * from './bit.ts';
+export * from './bool.ts';
+export * from './char.ts';
+export * from './common.ts';
+export * from './custom.ts';
+export * from './date.ts';
+export * from './decimal.ts';
+export * from './enum.ts';
+export * from './float.ts';
+export * from './geometry.ts';
+export * from './inet.ts';
+export * from './int.common.ts';
+export * from './integer.ts';
+export * from './interval.ts';
+export * from './jsonb.ts';
+export * from './real.ts';
+export * from './smallint.ts';
+export * from './string.ts';
+export * from './time.ts';
+export * from './timestamp.ts';
+export * from './uuid.ts';
+export * from './varbit.ts';
+export * from './varchar.ts';
+export * from './vector.ts';
diff --git a/drizzle-orm/src/cockroach-core/columns/inet.ts b/drizzle-orm/src/cockroach-core/columns/inet.ts
new file mode 100644
index 0000000000..11c1c8ddb7
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/inet.ts
@@ -0,0 +1,38 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyCockroachTable } from '../table.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachInetBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string inet';
+	data: string;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachInetBuilder';
+
+	constructor(name: string) {
+		super(name, 'string inet', 'CockroachInet');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachInet(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachInet<T extends ColumnBaseConfig<'string inet'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachInet';
+
+	getSQLType(): string {
+		return 'inet';
+	}
+}
+
+export function inet(name?: string) {
+	return new CockroachInetBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/int.common.ts b/drizzle-orm/src/cockroach-core/columns/int.common.ts
new file mode 100644
index 0000000000..e8e08ddc8f
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/int.common.ts
@@ -0,0 +1,49 @@
+import type { ColumnBuilderBaseConfig, ColumnType, GeneratedIdentityConfig, IsIdentity } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import type { CockroachSequenceOptions } from '../sequence.ts';
+import { CockroachColumnWithArrayBuilder } from './common.ts';
+
+export abstract class CockroachIntColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType>,
+> extends CockroachColumnWithArrayBuilder<
+	T,
+	{ generatedIdentity: GeneratedIdentityConfig }
+> {
+	static override readonly [entityKind]: string = 'CockroachIntColumnBaseBuilder';
+
+	generatedAlwaysAsIdentity(
+		sequence?: CockroachSequenceOptions,
+	): IsIdentity<this, 'always'> {
+		this.config.generatedIdentity = sequence
+			? {
+				type: 'always',
+				sequenceOptions: sequence,
+			}
+			: {
+				type: 'always',
+			};
+
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+
+		return this as IsIdentity<this, 'always'>;
+	}
+
+	generatedByDefaultAsIdentity(
+		sequence?: CockroachSequenceOptions,
+	): IsIdentity<this, 'byDefault'> {
+		this.config.generatedIdentity = sequence
+			? {
+				type: 'byDefault',
+				sequenceOptions: sequence,
+			}
+			: {
+				type: 'byDefault',
+			};
+
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+
+		return this as IsIdentity<this, 'byDefault'>;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/integer.ts b/drizzle-orm/src/cockroach-core/columns/integer.ts
new file mode 100644
index 0000000000..15d9bedeb3
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/integer.ts
@@ -0,0 +1,46 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyCockroachTable } from '../table.ts';
+import { CockroachColumn } from './common.ts';
+import { CockroachIntColumnBaseBuilder } from './int.common.ts';
+
+export class CockroachIntegerBuilder extends CockroachIntColumnBaseBuilder<{
+	dataType: 'number int32';
+	data: number;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachIntegerBuilder';
+
+	constructor(name: string) {
+		super(name, 'number int32', 'CockroachInteger');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachInteger(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachInteger<T extends ColumnBaseConfig<'number int32'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachInteger';
+
+	getSQLType(): string {
+		return 'int4';
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'string') {
+			return Number.parseInt(value);
+		}
+		return value;
+	};
+}
+
+export function int4(name?: string) {
+	return new CockroachIntegerBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/interval.ts b/drizzle-orm/src/cockroach-core/columns/interval.ts
new file mode 100644
index 0000000000..bf97c75774
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/interval.ts
@@ -0,0 +1,77 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+import type { Precision } from './timestamp.ts';
+
+export class CockroachIntervalBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string interval';
+	data: string;
+	driverParam: string;
+}, { intervalConfig: IntervalConfig }> {
+	static override readonly [entityKind]: string = 'CockroachIntervalBuilder';
+
+	constructor(
+		name: string,
+		intervalConfig: IntervalConfig,
+	) {
+		super(name, 'string interval', 'CockroachInterval');
+		this.config.intervalConfig = intervalConfig;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachInterval(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachInterval<T extends ColumnBaseConfig<'string interval'>>
+	extends CockroachColumn<T, { intervalConfig: IntervalConfig }>
+{
+	static override readonly [entityKind]: string = 'CockroachInterval';
+
+	readonly fields: IntervalConfig['fields'] = this.config.intervalConfig.fields;
+	readonly precision: IntervalConfig['precision'] = this.config.intervalConfig.precision;
+
+	getSQLType(): string {
+		const fields = this.fields ? ` ${this.fields}` : '';
+		const precision = this.precision ? `(${this.precision})` : '';
+		return `interval${fields}${precision}`;
+	}
+}
+
+export interface IntervalConfig {
+	fields?:
+		| 'year'
+		| 'month'
+		| 'day'
+		| 'hour'
+		| 'minute'
+		| 'second'
+		| 'year to month'
+		| 'day to hour'
+		| 'day to minute'
+		| 'day to second'
+		| 'hour to minute'
+		| 'hour to second'
+		| 'minute to second';
+	precision?: Precision;
+}
+
+export function interval(
+	config?: IntervalConfig,
+): CockroachIntervalBuilder;
+export function interval(
+	name: string,
+	config?: IntervalConfig,
+): CockroachIntervalBuilder;
+export function interval(a?: string | IntervalConfig, b: IntervalConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<IntervalConfig>(a, b);
+	return new CockroachIntervalBuilder(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/jsonb.ts b/drizzle-orm/src/cockroach-core/columns/jsonb.ts
new file mode 100644
index 0000000000..6aef49729e
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/jsonb.ts
@@ -0,0 +1,57 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { CockroachColumn, CockroachColumnBuilder } from './common.ts';
+
+export class CockroachJsonbBuilder extends CockroachColumnBuilder<{
+	dataType: 'object json';
+	data: unknown;
+	driverParam: unknown;
+}> {
+	static override readonly [entityKind]: string = 'CockroachJsonbBuilder';
+
+	constructor(name: string) {
+		super(name, 'object json', 'CockroachJsonb');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachJsonb(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachJsonb<T extends ColumnBaseConfig<'object json'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachJsonb';
+
+	constructor(table: CockroachTable<any>, config: CockroachJsonbBuilder['config']) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'jsonb';
+	}
+
+	override mapToDriverValue = (value: T['data']): string => {
+		return JSON.stringify(value);
+	};
+
+	override mapFromDriverValue = (value: T['data'] | string): T['data'] => {
+		if (typeof value === 'string') {
+			try {
+				return JSON.parse(value);
+			} catch {
+				return value as T['data'];
+			}
+		}
+		return value;
+	};
+}
+
+export function jsonb(name?: string) {
+	return new CockroachJsonbBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/real.ts b/drizzle-orm/src/cockroach-core/columns/real.ts
new file mode 100644
index 0000000000..cd1c82f83b
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/real.ts
@@ -0,0 +1,53 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachRealBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'number float';
+		data: number;
+		driverParam: string | number;
+	},
+	{ length: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachRealBuilder';
+
+	constructor(name: string, length?: number) {
+		super(name, 'number float', 'CockroachReal');
+		this.config.length = length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachReal(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachReal<T extends ColumnBaseConfig<'number float'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachReal';
+
+	constructor(table: CockroachTable<any>, config: CockroachRealBuilder['config']) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'real';
+	}
+
+	override mapFromDriverValue = (value: string | number): number => {
+		if (typeof value === 'string') {
+			return Number.parseFloat(value);
+		}
+		return value;
+	};
+}
+
+export function real(name?: string) {
+	return new CockroachRealBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/smallint.ts b/drizzle-orm/src/cockroach-core/columns/smallint.ts
new file mode 100644
index 0000000000..d1f93c98a1
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/smallint.ts
@@ -0,0 +1,49 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { CockroachColumn } from './common.ts';
+import { CockroachIntColumnBaseBuilder } from './int.common.ts';
+
+export class CockroachSmallIntBuilder extends CockroachIntColumnBaseBuilder<{
+	dataType: 'number int16';
+	data: number;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachSmallIntBuilder';
+
+	constructor(name: string) {
+		super(name, 'number int16', 'CockroachSmallInt');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachSmallInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachSmallInt<T extends ColumnBaseConfig<'number int16'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachSmallInt';
+
+	getSQLType(): string {
+		return 'int2';
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'string') {
+			return Number(value);
+		}
+		return value;
+	};
+}
+
+export function smallint(name?: string) {
+	return new CockroachSmallIntBuilder(name ?? '');
+}
+export function int2(name?: string) {
+	return new CockroachSmallIntBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/string.ts b/drizzle-orm/src/cockroach-core/columns/string.ts
new file mode 100644
index 0000000000..4f01bda072
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/string.ts
@@ -0,0 +1,97 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachStringBuilder<TEnum extends [string, ...string[]]> extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		enumValues: TEnum;
+		driverParam: string;
+	},
+	{ enumValues: TEnum | undefined; length: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachStringBuilder';
+
+	constructor(name: string, config: CockroachStringConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'CockroachString');
+		this.config.enumValues = config.enum;
+		this.config.length = config.length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachString<
+	T extends ColumnBaseConfig<'string' | 'string enum'>,
+> extends CockroachColumn<T, { enumValues: [string, ...string[]] | undefined }> {
+	static override readonly [entityKind]: string = 'CockroachString';
+
+	override readonly enumValues = this.config.enumValues;
+
+	getSQLType(): string {
+		return this.length === undefined ? `string` : `string(${this.length})`;
+	}
+}
+
+export interface CockroachStringConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> {
+	enum?: TEnum;
+	length?: number | undefined;
+}
+
+export interface CockroachTextConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> {
+	enum?: TEnum;
+}
+
+export function string(): CockroachStringBuilder<[string, ...string[]]>;
+export function string<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	config?: CockroachStringConfig<T | Writable<T>>,
+): CockroachStringBuilder<Writable<T>>;
+export function string<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	name: string,
+	config?: CockroachStringConfig<T | Writable<T>>,
+): CockroachStringBuilder<Writable<T>>;
+export function string(a?: string | CockroachStringConfig, b: CockroachStringConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<CockroachStringConfig>(a, b);
+	return new CockroachStringBuilder(name, config as any);
+}
+
+// text is alias for string but without ability to add length
+export function text(): CockroachStringBuilder<[string, ...string[]]>;
+export function text<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	config?: CockroachTextConfig<T | Writable<T>>,
+): CockroachStringBuilder<Writable<T>>;
+export function text<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	name: string,
+	config?: CockroachTextConfig<T | Writable<T>>,
+): CockroachStringBuilder<Writable<T>>;
+export function text(a?: string | CockroachStringConfig, b: CockroachStringConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<CockroachStringConfig>(a, b);
+	return new CockroachStringBuilder(name, config as any);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/time.ts b/drizzle-orm/src/cockroach-core/columns/time.ts
new file mode 100644
index 0000000000..057902de1f
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/time.ts
@@ -0,0 +1,67 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+import type { Precision } from './timestamp.ts';
+
+export class CockroachTimeBuilder extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: 'string time';
+		data: string;
+		driverParam: string;
+	},
+	{ withTimezone: boolean; precision: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachTimeBuilder';
+
+	constructor(
+		name: string,
+		readonly withTimezone: boolean,
+		readonly precision: number | undefined,
+	) {
+		super(name, 'string time', 'CockroachTime');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachTime(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachTime<T extends ColumnBaseConfig<'string time'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachTime';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(table: CockroachTable<any>, config: CockroachTimeBuilder['config']) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `time${this.withTimezone ? 'tz' : ''}${precision}`;
+	}
+}
+
+export interface TimeConfig {
+	precision?: Precision;
+	withTimezone?: boolean;
+}
+
+export function time(config?: TimeConfig): CockroachTimeBuilder;
+export function time(name: string, config?: TimeConfig): CockroachTimeBuilder;
+export function time(a?: string | TimeConfig, b: TimeConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<TimeConfig>(a, b);
+	return new CockroachTimeBuilder(name, config.withTimezone ?? false, config.precision);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/timestamp.ts b/drizzle-orm/src/cockroach-core/columns/timestamp.ts
new file mode 100644
index 0000000000..591a9467c5
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/timestamp.ts
@@ -0,0 +1,138 @@
+import type { AnyCockroachTable, CockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn } from './common.ts';
+import { CockroachDateColumnBaseBuilder } from './date.common.ts';
+
+export class CockroachTimestampBuilder extends CockroachDateColumnBaseBuilder<
+	{
+		dataType: 'object date';
+		data: Date;
+		driverParam: string;
+	},
+	{ withTimezone: boolean; precision: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachTimestampBuilder';
+
+	constructor(name: string, withTimezone: boolean, precision: number | undefined) {
+		super(name, 'object date', 'CockroachTimestamp');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachTimestamp(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachTimestamp<T extends ColumnBaseConfig<'object date'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachTimestamp';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(table: CockroachTable<any>, config: CockroachTimestampBuilder['config']) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `timestamp${this.withTimezone ? 'tz' : ''}${precision}`;
+	}
+
+	override mapFromDriverValue = (value: string): Date | null => {
+		return new Date(this.withTimezone ? value : value + '+0000');
+	};
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
+}
+
+export class CockroachTimestampStringBuilder extends CockroachDateColumnBaseBuilder<
+	{
+		dataType: 'string timestamp';
+		data: string;
+		driverParam: string;
+	},
+	{ withTimezone: boolean; precision: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachTimestampStringBuilder';
+
+	constructor(name: string, withTimezone: boolean, precision: number | undefined) {
+		super(name, 'string timestamp', 'CockroachTimestampString');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachTimestampString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachTimestampString<T extends ColumnBaseConfig<'string timestamp'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachTimestampString';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(
+		table: CockroachTable<any>,
+		config: CockroachTimestampStringBuilder['config'],
+	) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `timestamp${this.withTimezone ? 'tz' : ''}${precision}`;
+	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
+}
+
+export type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export interface CockroachTimestampConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+	mode?: TMode;
+	precision?: Precision;
+	withTimezone?: boolean;
+}
+
+export function timestamp<TMode extends CockroachTimestampConfig['mode'] & {}>(
+	config?: CockroachTimestampConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? CockroachTimestampStringBuilder
+	: CockroachTimestampBuilder;
+export function timestamp<TMode extends CockroachTimestampConfig['mode'] & {}>(
+	name: string,
+	config?: CockroachTimestampConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? CockroachTimestampStringBuilder
+	: CockroachTimestampBuilder;
+export function timestamp(a?: string | CockroachTimestampConfig, b: CockroachTimestampConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<CockroachTimestampConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new CockroachTimestampStringBuilder(name, config.withTimezone ?? false, config.precision);
+	}
+	return new CockroachTimestampBuilder(name, config?.withTimezone ?? false, config?.precision);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/utils.ts b/drizzle-orm/src/cockroach-core/columns/utils.ts
new file mode 100644
index 0000000000..18a48315bb
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/utils.ts
@@ -0,0 +1,47 @@
+function hexToBytes(hex: string): Uint8Array {
+	const bytes: number[] = [];
+	for (let c = 0; c < hex.length; c += 2) {
+		bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+	}
+	return new Uint8Array(bytes);
+}
+
+function bytesToFloat64(bytes: Uint8Array, offset: number): number {
+	const buffer = new ArrayBuffer(8);
+	const view = new DataView(buffer);
+	for (let i = 0; i < 8; i++) {
+		view.setUint8(i, bytes[offset + i]!);
+	}
+	return view.getFloat64(0, true);
+}
+
+export function parseEWKB(hex: string): { srid: number | undefined; point: [number, number] } {
+	const bytes = hexToBytes(hex);
+
+	let offset = 0;
+
+	// Byte order: 1 is little-endian, 0 is big-endian
+	const byteOrder = bytes[offset];
+	offset += 1;
+
+	const view = new DataView(bytes.buffer);
+	const geomType = view.getUint32(offset, byteOrder === 1);
+	offset += 4;
+
+	let srid: number | undefined;
+	if (geomType & 0x20000000) { // SRID flag
+		srid = view.getUint32(offset, byteOrder === 1);
+		offset += 4;
+	}
+
+	if ((geomType & 0xFFFF) === 1) {
+		const x = bytesToFloat64(bytes, offset);
+		offset += 8;
+		const y = bytesToFloat64(bytes, offset);
+		offset += 8;
+
+		return { srid, point: [x, y] };
+	}
+
+	throw new Error('Unsupported geometry type');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/uuid.ts b/drizzle-orm/src/cockroach-core/columns/uuid.ts
new file mode 100644
index 0000000000..c3a2db7cef
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/uuid.ts
@@ -0,0 +1,46 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { sql } from '~/sql/sql.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachUUIDBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string uuid';
+	data: string;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'CockroachUUIDBuilder';
+
+	constructor(name: string) {
+		super(name, 'string uuid', 'CockroachUUID');
+	}
+
+	/**
+	 * Adds `default gen_random_uuid()` to the column definition.
+	 */
+	defaultRandom(): ReturnType<this['default']> {
+		return this.default(sql`gen_random_uuid()`) as ReturnType<this['default']>;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachUUID(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachUUID<T extends ColumnBaseConfig<'string uuid'>> extends CockroachColumn<T> {
+	static override readonly [entityKind]: string = 'CockroachUUID';
+
+	getSQLType(): string {
+		return 'uuid';
+	}
+}
+
+export function uuid(name?: string) {
+	return new CockroachUUIDBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/varbit.ts b/drizzle-orm/src/cockroach-core/columns/varbit.ts
new file mode 100644
index 0000000000..82e0c46db7
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/varbit.ts
@@ -0,0 +1,54 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachVarbitBuilder extends CockroachColumnWithArrayBuilder<{
+	dataType: 'string binary';
+	data: string;
+	driverParam: string;
+}, { length: number | undefined }> {
+	static override readonly [entityKind]: string = 'CockroachVarbitBuilder';
+
+	constructor(name: string, config: CockroachVarbitConfig) {
+		super(name, 'string binary', 'CockroachVarbit');
+		this.config.length = config.length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachVarbit(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachVarbit<T extends ColumnBaseConfig<'string binary'>>
+	extends CockroachColumn<T, { length: number | undefined }>
+{
+	static override readonly [entityKind]: string = 'CockroachVarbit';
+
+	getSQLType(): string {
+		return this.length ? `varbit(${this.length})` : 'varbit';
+	}
+}
+
+export interface CockroachVarbitConfig {
+	length?: number | undefined;
+}
+
+export function varbit(
+	config?: CockroachVarbitConfig,
+): CockroachVarbitBuilder;
+export function varbit(
+	name: string,
+	config?: CockroachVarbitConfig,
+): CockroachVarbitBuilder;
+export function varbit(a?: string | CockroachVarbitConfig, b: CockroachVarbitConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<CockroachVarbitConfig>(a, b);
+	return new CockroachVarbitBuilder(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/varchar.ts b/drizzle-orm/src/cockroach-core/columns/varchar.ts
new file mode 100644
index 0000000000..1caf63c997
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/varchar.ts
@@ -0,0 +1,72 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnWithArrayBuilder } from './common.ts';
+
+export class CockroachVarcharBuilder<
+	TEnum extends [string, ...string[]],
+> extends CockroachColumnWithArrayBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: string;
+		enumValues: TEnum;
+	},
+	{ length: number | undefined; enumValues: TEnum | undefined }
+> {
+	static override readonly [entityKind]: string = 'CockroachVarcharBuilder';
+
+	constructor(name: string, config: CockroachVarcharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'CockroachVarchar');
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachVarchar(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachVarchar<
+	T extends ColumnBaseConfig<'string' | 'string enum'>,
+> extends CockroachColumn<T, { length: number | undefined; enumValues: T['enumValues'] }> {
+	static override readonly [entityKind]: string = 'CockroachVarchar';
+
+	override readonly enumValues = this.config.enumValues;
+
+	getSQLType(): string {
+		return this.length === undefined ? `varchar` : `varchar(${this.length})`;
+	}
+}
+
+export interface CockroachVarcharConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> {
+	enum?: TEnum;
+	length?: number | undefined;
+}
+
+export function varchar<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	config?: CockroachVarcharConfig<T | Writable<T>>,
+): CockroachVarcharBuilder<Writable<T>>;
+export function varchar<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+>(
+	name: string,
+	config?: CockroachVarcharConfig<T | Writable<T>>,
+): CockroachVarcharBuilder<Writable<T>>;
+export function varchar(a?: string | CockroachVarcharConfig, b: CockroachVarcharConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<CockroachVarcharConfig>(a, b);
+	return new CockroachVarcharBuilder(name, config as any);
+}
diff --git a/drizzle-orm/src/cockroach-core/columns/vector.ts b/drizzle-orm/src/cockroach-core/columns/vector.ts
new file mode 100644
index 0000000000..2cbfdce98d
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/columns/vector.ts
@@ -0,0 +1,68 @@
+import type { AnyCockroachTable } from '~/cockroach-core/table.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { CockroachColumn, CockroachColumnBuilder } from './common.ts';
+
+export class CockroachVectorBuilder extends CockroachColumnBuilder<
+	{
+		dataType: 'array vector';
+		data: number[];
+		driverParam: string;
+	},
+	{ length: number }
+> {
+	static override readonly [entityKind]: string = 'CockroachVectorBuilder';
+
+	constructor(name: string, config: CockroachVectorConfig) {
+		super(name, 'array vector', 'CockroachVector');
+		this.config.length = config.dimensions;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyCockroachTable<{ name: TTableName }>,
+	) {
+		return new CockroachVector(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class CockroachVector<
+	T extends ColumnBaseConfig<'array vector'>,
+> extends CockroachColumn<T, { length: number }> {
+	static override readonly [entityKind]: string = 'CockroachVector';
+
+	getSQLType(): string {
+		return `vector(${this.config.length})`;
+	}
+
+	override mapToDriverValue = (value: unknown): unknown => {
+		return JSON.stringify(value);
+	};
+
+	override mapFromDriverValue = (value: string): unknown => {
+		return value
+			.slice(1, -1)
+			.split(',')
+			.map((v) => Number.parseFloat(v));
+	};
+}
+
+export interface CockroachVectorConfig {
+	dimensions: number;
+}
+
+export function vector(
+	config: CockroachVectorConfig,
+): CockroachVectorBuilder;
+export function vector(
+	name: string,
+	config: CockroachVectorConfig,
+): CockroachVectorBuilder;
+export function vector(a: string | CockroachVectorConfig, b?: CockroachVectorConfig) {
+	const { name, config } = getColumnNameAndConfig<CockroachVectorConfig>(a, b);
+	return new CockroachVectorBuilder(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/db.ts b/drizzle-orm/src/cockroach-core/db.ts
new file mode 100644
index 0000000000..c5aee0219f
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/db.ts
@@ -0,0 +1,699 @@
+import type * as V1 from '~/_relations.ts';
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import {
+	CockroachDeleteBase,
+	CockroachInsertBuilder,
+	CockroachSelectBuilder,
+	CockroachUpdateBuilder,
+	QueryBuilder,
+} from '~/cockroach-core/query-builders/index.ts';
+import type {
+	CockroachQueryResultHKT,
+	CockroachQueryResultKind,
+	CockroachSession,
+	CockroachTransaction,
+	CockroachTransactionConfig,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import type { CockroachTable } from '~/cockroach-core/table.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { DrizzleTypeError, NeonAuthToken } from '~/utils.ts';
+import type { CockroachColumn } from './columns/index.ts';
+import { CockroachCountBuilder } from './query-builders/count.ts';
+import { RelationalQueryBuilder } from './query-builders/query.ts';
+import { CockroachRaw } from './query-builders/raw.ts';
+import { CockroachRefreshMaterializedView } from './query-builders/refresh-materialized-view.ts';
+import type { SelectedFields } from './query-builders/select.types.ts';
+import type { WithBuilder } from './subquery.ts';
+import type { CockroachViewBase } from './view-base.ts';
+import type { CockroachMaterializedView } from './view.ts';
+
+export class CockroachDatabase<
+	TQueryResult extends CockroachQueryResultHKT,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends V1.TablesRelationalConfig = V1.ExtractTablesWithRelations<TFullSchema>,
+> {
+	static readonly [entityKind]: string = 'CockroachDatabase';
+
+	declare readonly _: {
+		readonly schema: TSchema | undefined;
+		readonly fullSchema: TFullSchema;
+		readonly tableNamesMap: Record<string, string>;
+		readonly session: CockroachSession<TQueryResult, TFullSchema, TSchema>;
+	};
+
+	_query: TFullSchema extends Record<string, never>
+		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
+		: {
+			[K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
+		};
+
+	constructor(
+		/** @internal */
+		readonly dialect: CockroachDialect,
+		/** @internal */
+		readonly session: CockroachSession<any, any, any>,
+		schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+	) {
+		this._ = schema
+			? {
+				schema: schema.schema,
+				fullSchema: schema.fullSchema as TFullSchema,
+				tableNamesMap: schema.tableNamesMap,
+				session,
+			}
+			: {
+				schema: undefined,
+				fullSchema: {} as TFullSchema,
+				tableNamesMap: {},
+				session,
+			};
+		this._query = {} as typeof this['_query'];
+		if (this._.schema) {
+			for (const [tableName, columns] of Object.entries(this._.schema)) {
+				(this._query as CockroachDatabase<TQueryResult, Record<string, any>>['_query'])[tableName] =
+					new RelationalQueryBuilder(
+						schema!.fullSchema,
+						this._.schema,
+						this._.tableNamesMap,
+						schema!.fullSchema[tableName] as CockroachTable,
+						columns,
+						dialect,
+						session,
+					);
+			}
+		}
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const self = this;
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(self.dialect));
+			}
+
+			return new Proxy(
+				new WithSubquery(
+					qb.getSQL(),
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: CockroachTable | CockroachViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	) {
+		return new CockroachCountBuilder({ source, filters, session: this.session, dialect: this.dialect });
+	}
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = await db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): CockroachSelectBuilder<undefined>;
+		function select<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection>;
+		function select<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			});
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * await db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * await db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): CockroachSelectBuilder<undefined>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): CockroachSelectBuilder<TSelection>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			});
+		}
+
+		/**
+		 * Adds `distinct on` expression to the select query.
+		 *
+		 * Calling this method will specify how the unique rows are determined.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param on The expression defining uniqueness.
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select the first row for each unique brand from the 'cars' table
+		 * await db.selectDistinctOn([cars.brand])
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 *
+		 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+		 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand, cars.color);
+		 * ```
+		 */
+		function selectDistinctOn(on: (CockroachColumn | SQLWrapper)[]): CockroachSelectBuilder<undefined>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (CockroachColumn | SQLWrapper)[],
+			fields: TSelection,
+		): CockroachSelectBuilder<TSelection>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (CockroachColumn | SQLWrapper)[],
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: { on },
+			});
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * await db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 *
+		 * // Update with returning clause
+		 * const updatedCar: Car[] = await db.update(cars)
+		 *   .set({ color: 'red' })
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function update<TTable extends CockroachTable>(table: TTable): CockroachUpdateBuilder<TTable, TQueryResult> {
+			return new CockroachUpdateBuilder(table, self.session, self.dialect, queries);
+		}
+
+		/**
+		 * Creates an insert query.
+		 *
+		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/insert}
+		 *
+		 * @param table The table to insert into.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Insert one row
+		 * await db.insert(cars).values({ brand: 'BMW' });
+		 *
+		 * // Insert multiple rows
+		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+		 *
+		 * // Insert with returning clause
+		 * const insertedCar: Car[] = await db.insert(cars)
+		 *   .values({ brand: 'BMW' })
+		 *   .returning();
+		 * ```
+		 */
+		function insert<TTable extends CockroachTable>(table: TTable): CockroachInsertBuilder<TTable, TQueryResult> {
+			return new CockroachInsertBuilder(table, self.session, self.dialect, queries);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * await db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * await db.delete(cars).where(eq(cars.color, 'green'));
+		 *
+		 * // Delete with returning clause
+		 * const deletedCar: Car[] = await db.delete(cars)
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function delete_<TTable extends CockroachTable>(table: TTable): CockroachDeleteBase<TTable, TQueryResult> {
+			return new CockroachDeleteBase(table, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = await db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): CockroachSelectBuilder<undefined>;
+	select<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection>;
+	select<TSelection extends SelectedFields>(fields?: TSelection): CockroachSelectBuilder<TSelection | undefined> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+		});
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * await db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * await db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): CockroachSelectBuilder<undefined>;
+	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): CockroachSelectBuilder<TSelection | undefined> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		});
+	}
+
+	/**
+	 * Adds `distinct on` expression to the select query.
+	 *
+	 * Calling this method will specify how the unique rows are determined.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param on The expression defining uniqueness.
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select the first row for each unique brand from the 'cars' table
+	 * await db.selectDistinctOn([cars.brand])
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 *
+	 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+	 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand, cars.color);
+	 * ```
+	 */
+	selectDistinctOn(on: (CockroachColumn | SQLWrapper)[]): CockroachSelectBuilder<undefined>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (CockroachColumn | SQLWrapper)[],
+		fields: TSelection,
+	): CockroachSelectBuilder<TSelection>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (CockroachColumn | SQLWrapper)[],
+		fields?: TSelection,
+	): CockroachSelectBuilder<TSelection | undefined> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: { on },
+		});
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * await db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 *
+	 * // Update with returning clause
+	 * const updatedCar: Car[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	update<TTable extends CockroachTable>(table: TTable): CockroachUpdateBuilder<TTable, TQueryResult> {
+		return new CockroachUpdateBuilder(table, this.session, this.dialect);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * await db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 *
+	 * // Insert with returning clause
+	 * const insertedCar: Car[] = await db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 * ```
+	 */
+	insert<TTable extends CockroachTable>(table: TTable): CockroachInsertBuilder<TTable, TQueryResult> {
+		return new CockroachInsertBuilder(table, this.session, this.dialect);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * await db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 *
+	 * // Delete with returning clause
+	 * const deletedCar: Car[] = await db.delete(cars)
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	delete<TTable extends CockroachTable>(table: TTable): CockroachDeleteBase<TTable, TQueryResult> {
+		return new CockroachDeleteBase(table, this.session, this.dialect);
+	}
+
+	refreshMaterializedView<TView extends CockroachMaterializedView>(
+		view: TView,
+	): CockroachRefreshMaterializedView<TQueryResult> {
+		return new CockroachRefreshMaterializedView(view, this.session, this.dialect);
+	}
+
+	protected authToken?: NeonAuthToken;
+
+	execute<TRow extends Record<string, unknown> = Record<string, unknown>>(
+		query: SQLWrapper | string,
+	): CockroachRaw<CockroachQueryResultKind<TQueryResult, TRow>> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: CockroachQueryResultKind<TQueryResult, TRow> }
+		>(
+			builtQuery,
+			undefined,
+			undefined,
+		);
+		return new CockroachRaw(
+			() => prepared.execute(undefined, this.authToken),
+			sequel,
+			builtQuery,
+			(result) => prepared.mapResult(result, true),
+		);
+	}
+
+	transaction<T>(
+		transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
+		config?: CockroachTransactionConfig,
+	): Promise<T> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type CockroachWithReplicas<Q> = Q & { $primary: Q };
+
+export const withReplicas = <
+	HKT extends CockroachQueryResultHKT,
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+	Q extends CockroachDatabase<
+		HKT,
+		TFullSchema,
+		TSchema extends Record<string, unknown> ? V1.ExtractTablesWithRelations<TFullSchema> : TSchema
+	>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): CockroachWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const selectDistinctOn: Q['selectDistinctOn'] = (...args: [any]) => getReplica(replicas).selectDistinctOn(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const _with: Q['with'] = (...args: any) => getReplica(replicas).with(...args);
+	const $with: Q['$with'] = (arg: any) => getReplica(replicas).$with(arg) as any;
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
+	const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: [any]) =>
+		primary.refreshMaterializedView(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		refreshMaterializedView,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		selectDistinctOn,
+		$count,
+		$with,
+		with: _with,
+		get _query() {
+			return getReplica(replicas)._query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/cockroach-core/dialect.ts b/drizzle-orm/src/cockroach-core/dialect.ts
new file mode 100644
index 0000000000..3bd7f6e2f9
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/dialect.ts
@@ -0,0 +1,1583 @@
+import * as V1 from '~/_relations.ts';
+import {
+	aliasedTable,
+	aliasedTableColumn,
+	getOriginalColumnFromAlias,
+	mapColumnsInAliasedSQLToAlias,
+	mapColumnsInSQLToAlias,
+} from '~/alias.ts';
+import { CockroachColumn } from '~/cockroach-core/columns/index.ts';
+import type {
+	AnyCockroachSelectQueryBuilder,
+	CockroachDeleteConfig,
+	CockroachInsertConfig,
+	CockroachSelectJoinConfig,
+	CockroachUpdateConfig,
+} from '~/cockroach-core/query-builders/index.ts';
+import type { CockroachSelectConfig, SelectedFieldsOrdered } from '~/cockroach-core/query-builders/select.types.ts';
+import { CockroachTable } from '~/cockroach-core/table.ts';
+import { Column } from '~/column.ts';
+import { entityKind, is } from '~/entity.ts';
+import { DrizzleError } from '~/errors.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { and, eq, View } from '~/sql/index.ts';
+import { type Name, Param, type Query, SQL, sql, type SQLChunk } from '~/sql/sql.ts';
+import { Subquery } from '~/subquery.ts';
+import { getTableName, getTableUniqueName, Table } from '~/table.ts';
+import { upgradeIfNeeded } from '~/up-migrations/cockroach.ts';
+import type { UpdateSet } from '~/utils.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import type { CockroachSession } from './session.ts';
+import { CockroachViewBase } from './view-base.ts';
+import type { CockroachMaterializedView } from './view.ts';
+
+// Will add codecs here, do not remove
+export interface CockroachDialectConfig {}
+
+export class CockroachDialect {
+	static readonly [entityKind]: string = 'CockroachDialect';
+
+	constructor(_config?: CockroachDialectConfig) {}
+
+	async migrate(
+		migrations: MigrationMeta[],
+		session: CockroachSession,
+		config: string | MigrationConfig,
+	): Promise<void | MigratorInitFailResponse> {
+		const migrationsTable = typeof config === 'string'
+			? '__drizzle_migrations'
+			: (config.migrationsTable ?? '__drizzle_migrations');
+		const migrationsSchema = typeof config === 'string'
+			? 'drizzle'
+			: (config.migrationsSchema ?? 'drizzle');
+
+		await session.execute(
+			sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`,
+		);
+
+		const { newDb } = await upgradeIfNeeded(
+			migrationsSchema,
+			migrationsTable,
+			session,
+			migrations,
+		);
+
+		if (newDb) {
+			const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
+				id INT GENERATED ALWAYS AS IDENTITY,
+				hash text NOT NULL,
+				created_at bigint,
+				name text,
+				applied_at timestamp with time zone DEFAULT now()
+			)
+		`;
+
+			await session.execute(migrationTableCreate);
+		}
+
+		const dbMigrations = await session.all<{
+			id: number;
+			hash: string;
+			created_at: string;
+			name: string | null;
+		}>(
+			sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${
+				sql.identifier(
+					migrationsTable,
+				)
+			}`,
+		);
+
+		if (typeof config === 'object' && config.init) {
+			if (dbMigrations.length) {
+				return { exitCode: 'databaseMigrations' as const };
+			}
+
+			if (migrations.length > 1) {
+				return { exitCode: 'localMigrations' as const };
+			}
+
+			const [migration] = migrations;
+
+			if (!migration) return;
+
+			await session.execute(
+				sql`insert into ${sql.identifier(migrationsSchema)}.${
+					sql.identifier(
+						migrationsTable,
+					)
+				} ("hash", "created_at", "name") 
+				values (${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+			);
+
+			return;
+		}
+
+		const migrationsToRun = getMigrationsToRun({
+			localMigrations: migrations,
+			dbMigrations,
+		});
+		await session.transaction(async (tx) => {
+			for await (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					await tx.execute(sql.raw(stmt));
+				}
+				await tx.execute(
+					sql`insert into ${sql.identifier(migrationsSchema)}.${
+						sql.identifier(
+							migrationsTable,
+						)
+					} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+				);
+			}
+		});
+	}
+
+	escapeName(name: string): string {
+		return `"${name.replace(/"/g, '""')}"`;
+	}
+
+	escapeParam(num: number): string {
+		return `$${num + 1}`;
+	}
+
+	escapeString(str: string): string {
+		return `'${str.replace(/'/g, "''")}'`;
+	}
+
+	private buildWithCTE(queries: Subquery[] | undefined): SQL | undefined {
+		if (!queries?.length) return undefined;
+
+		const withSqlChunks = [sql`with `];
+		for (const [i, w] of queries.entries()) {
+			withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);
+			if (i < queries.length - 1) {
+				withSqlChunks.push(sql`, `);
+			}
+		}
+		withSqlChunks.push(sql` `);
+		return sql.join(withSqlChunks);
+	}
+
+	buildDeleteQuery({
+		table,
+		where,
+		returning,
+		withList,
+	}: CockroachDeleteConfig): SQL {
+		const withSql = this.buildWithCTE(withList);
+
+		const returningSql = returning
+			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
+			: undefined;
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		return sql`${withSql}delete from ${table}${whereSql}${returningSql}`;
+	}
+
+	buildUpdateSet(table: CockroachTable, set: UpdateSet): SQL {
+		const tableColumns = table[Table.Symbol.Columns];
+
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
+		);
+
+		const setSize = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
+
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
+
+				if (i < setSize - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
+	}
+
+	buildUpdateQuery({
+		table,
+		set,
+		where,
+		returning,
+		withList,
+		from,
+		joins,
+	}: CockroachUpdateConfig): SQL {
+		const withSql = this.buildWithCTE(withList);
+
+		const tableName = table[CockroachTable.Symbol.Name];
+		const tableSchema = table[CockroachTable.Symbol.Schema];
+		const origTableName = table[CockroachTable.Symbol.OriginalName];
+		const alias = tableName === origTableName ? undefined : tableName;
+		const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${
+			sql.identifier(
+				origTableName,
+			)
+		}${alias && sql` ${sql.identifier(alias)}`}`;
+
+		const setSql = this.buildUpdateSet(table, set);
+
+		const fromSql = from && sql.join([sql.raw(' from '), this.buildFromTable(from)]);
+
+		const joinsSql = this.buildJoins(joins);
+
+		const returningSql = returning
+			? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}`
+			: undefined;
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
+	}
+
+	/**
+	 * Builds selection SQL with provided fields/expressions
+	 *
+	 * Examples:
+	 *
+	 * `select <selection> from`
+	 *
+	 * `insert ... returning <selection>`
+	 *
+	 * If `isSingleTable` is true, then columns won't be prefixed with table name
+	 */
+	private buildSelection(
+		fields: SelectedFieldsOrdered,
+		{ isSingleTable = false }: { isSingleTable?: boolean } = {},
+	): SQL {
+		const columnsLen = fields.length;
+
+		const chunks = fields.flatMap(({ field }, i) => {
+			const chunk: SQLChunk[] = [];
+
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					if (!isSingleTable && field.origin !== undefined) {
+						chunk.push(sql.identifier(field.origin), sql.raw('.'));
+					}
+					chunk.push(sql.identifier(field.fieldAlias));
+				} else {
+					const query = field.sql;
+
+					if (isSingleTable) {
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, Column)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
+						);
+
+						chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+					} else {
+						chunk.push(query);
+					}
+
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, Column)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
+
+					chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+				} else {
+					chunk.push(query);
+				}
+			} else if (is(field, Column)) {
+				if (isSingleTable) {
+					chunk.push(
+						field.isAlias
+							? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}`
+							: sql.identifier(field.name),
+					);
+				} else {
+					chunk.push(
+						field.isAlias
+							? sql`${getOriginalColumnFromAlias(field)} as ${field}`
+							: field,
+					);
+				}
+			} else if (is(field, Subquery)) {
+				if (!field._.isWith) {
+					chunk.push(sql`(${field._.sql}) ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(field);
+				}
+			}
+
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
+
+		return sql.join(chunks);
+	}
+
+	private buildJoins(
+		joins: CockroachSelectJoinConfig[] | undefined,
+	): SQL | undefined {
+		if (!joins || joins.length === 0) {
+			return undefined;
+		}
+
+		const joinsArray: SQL[] = [];
+
+		for (const [index, joinMeta] of joins.entries()) {
+			if (index === 0) {
+				joinsArray.push(sql` `);
+			}
+			const table = joinMeta.table;
+			const lateralSql = joinMeta.lateral ? sql` lateral` : undefined;
+			const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : undefined;
+
+			if (is(table, CockroachTable)) {
+				const tableName = table[CockroachTable.Symbol.Name];
+				const tableSchema = table[CockroachTable.Symbol.Schema];
+				const origTableName = table[CockroachTable.Symbol.OriginalName];
+				const alias = tableName === origTableName ? undefined : joinMeta.alias;
+				joinsArray.push(
+					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
+						tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined
+					}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`,
+				);
+			} else if (is(table, View)) {
+				const viewName = table[ViewBaseConfig].name;
+				const viewSchema = table[ViewBaseConfig].schema;
+				const origViewName = table[ViewBaseConfig].originalName;
+				const alias = viewName === origViewName ? undefined : joinMeta.alias;
+				joinsArray.push(
+					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
+						viewSchema ? sql`${sql.identifier(viewSchema)}.` : undefined
+					}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`,
+				);
+			} else {
+				joinsArray.push(
+					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table}${onSql}`,
+				);
+			}
+			if (index < joins.length - 1) {
+				joinsArray.push(sql` `);
+			}
+		}
+
+		return sql.join(joinsArray);
+	}
+
+	private buildFromTable(
+		table: SQL | Subquery | CockroachViewBase | CockroachTable | undefined,
+	): SQL | Subquery | CockroachViewBase | CockroachTable | undefined {
+		if (is(table, Table) && table[Table.Symbol.IsAlias]) {
+			let fullName = sql`${sql.identifier(table[Table.Symbol.OriginalName])}`;
+			if (table[Table.Symbol.Schema]) {
+				fullName = sql`${sql.identifier(table[Table.Symbol.Schema]!)}.${fullName}`;
+			}
+			return sql`${fullName} ${sql.identifier(table[Table.Symbol.Name])}`;
+		}
+
+		if (is(table, View) && table[ViewBaseConfig].isAlias) {
+			let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+			if (table[ViewBaseConfig].schema) {
+				fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+			}
+			return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+		}
+
+		return table;
+	}
+
+	buildSelectQuery({
+		withList,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		limit,
+		offset,
+		lockingClause,
+		distinct,
+		setOperators,
+	}: CockroachSelectConfig): SQL {
+		if (!fieldsFlat) {
+			throw new Error('Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation');
+		}
+		const fieldsList = fieldsFlat;
+		for (const f of fieldsList) {
+			if (
+				is(f.field, Column)
+				&& getTableName(f.field.table)
+					!== (is(table, Subquery)
+						? table._.alias
+						: is(table, CockroachViewBase)
+						? table[ViewBaseConfig].name
+						: is(table, SQL)
+						? undefined
+						: getTableName(table))
+				&& !((table) =>
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
+					))(f.field.table)
+			) {
+				const tableName = getTableName(f.field.table);
+				throw new Error(
+					`Your "${
+						f.path.join(
+							'->',
+						)
+					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
+				);
+			}
+		}
+
+		const isSingleTable = !joins || joins.length === 0;
+
+		const withSql = this.buildWithCTE(withList);
+
+		let distinctSql: SQL | undefined;
+		if (distinct) {
+			distinctSql = distinct === true
+				? sql` distinct`
+				: sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
+		}
+
+		const selection = this.buildSelection(fieldsList, { isSingleTable });
+
+		const tableSql = this.buildFromTable(table);
+
+		const joinsSql = this.buildJoins(joins);
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		const havingSql = having ? sql` having ${having}` : undefined;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			orderBySql = sql` order by ${sql.join(orderBy, sql`, `)}`;
+		}
+
+		let groupBySql;
+		if (groupBy && groupBy.length > 0) {
+			groupBySql = sql` group by ${sql.join(groupBy, sql`, `)}`;
+		}
+
+		const limitSql = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
+			? sql` limit ${limit}`
+			: undefined;
+
+		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+
+		const lockingClauseSql = sql.empty();
+		if (lockingClause) {
+			const clauseSql = sql` for ${sql.raw(lockingClause.strength)}`;
+			if (lockingClause.config.of) {
+				clauseSql.append(
+					sql` of ${
+						sql.join(
+							Array.isArray(lockingClause.config.of)
+								? lockingClause.config.of
+								: [lockingClause.config.of],
+							sql`, `,
+						)
+					}`,
+				);
+			}
+			if (lockingClause.config.noWait) {
+				clauseSql.append(sql` nowait`);
+			} else if (lockingClause.config.skipLocked) {
+				clauseSql.append(sql` skip locked`);
+			}
+			lockingClauseSql.append(clauseSql);
+		}
+		const finalQuery =
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
+
+		if (setOperators.length > 0) {
+			return this.buildSetOperations(finalQuery, setOperators);
+		}
+
+		return finalQuery;
+	}
+
+	buildSetOperations(
+		leftSelect: SQL,
+		setOperators: CockroachSelectConfig['setOperators'],
+	): SQL {
+		const [setOperator, ...rest] = setOperators;
+
+		if (!setOperator) {
+			throw new Error('Cannot pass undefined values to any set operator');
+		}
+
+		if (rest.length === 0) {
+			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		}
+
+		// Some recursive magic here
+		return this.buildSetOperations(
+			this.buildSetOperationQuery({ leftSelect, setOperator }),
+			rest,
+		);
+	}
+
+	buildSetOperationQuery({
+		leftSelect,
+		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
+	}: {
+		leftSelect: SQL;
+		setOperator: CockroachSelectConfig['setOperators'][number];
+	}): SQL {
+		const leftChunk = sql`(${leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			const orderByValues: (SQL<unknown> | Name)[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid Sql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const singleOrderBy of orderBy) {
+				if (is(singleOrderBy, CockroachColumn)) {
+					orderByValues.push(sql.identifier(singleOrderBy.name));
+				} else if (is(singleOrderBy, SQL)) {
+					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
+						const chunk = singleOrderBy.queryChunks[i];
+
+						if (is(chunk, CockroachColumn)) {
+							singleOrderBy.queryChunks[i] = sql.identifier(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${singleOrderBy}`);
+				} else {
+					orderByValues.push(sql`${singleOrderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const limitSql = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
+			? sql` limit ${limit}`
+			: undefined;
+
+		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
+
+		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+	}
+
+	buildInsertQuery({
+		table,
+		values: valuesOrSelect,
+		onConflict,
+		returning,
+		withList,
+		select,
+	}: CockroachInsertConfig): SQL {
+		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
+		const columns: Record<string, CockroachColumn> = table[Table.Symbol.Columns];
+
+		const colEntries: [string, CockroachColumn][] = Object.entries(columns);
+		const colEntriesFiltered: [string, CockroachColumn][] = select && !is(valuesOrSelect, SQL)
+			? Object
+				.keys((valuesOrSelect as TypedQueryBuilder<any>).getSelectedFields())
+				.map((key) => [key, columns[key]] as [string, CockroachColumn])
+			: colEntries.filter(([_, col]) => !col.shouldDisableInsert());
+
+		const insertOrder = colEntriesFiltered.map(([, column]) => sql.identifier(column.name));
+
+		if (select) {
+			const select = valuesOrSelect as AnyCockroachSelectQueryBuilder | SQL;
+
+			if (is(select, SQL)) {
+				valuesSqlList.push(select);
+			} else {
+				valuesSqlList.push(select.getSQL());
+			}
+		} else {
+			const values = valuesOrSelect as Record<string, Param | SQL>[];
+			valuesSqlList.push(sql.raw('values '));
+
+			for (const [valueIndex, value] of values.entries()) {
+				const valueList: (SQLChunk | SQL)[] = [];
+				for (const [fieldName, col] of colEntriesFiltered) {
+					const colValue = value[fieldName];
+					if (
+						colValue === undefined
+						|| (is(colValue, Param) && colValue.value === undefined)
+					) {
+						// eslint-disable-next-line unicorn/no-negated-condition
+						if (col.defaultFn !== undefined) {
+							const defaultFnResult = col.defaultFn();
+							const defaultValue = is(defaultFnResult, SQL)
+								? defaultFnResult
+								: sql.param(defaultFnResult, col);
+							valueList.push(defaultValue);
+							// eslint-disable-next-line unicorn/no-negated-condition
+						} else if (!col.default && col.onUpdateFn !== undefined) {
+							const onUpdateFnResult = col.onUpdateFn();
+							const newValue = is(onUpdateFnResult, SQL)
+								? onUpdateFnResult
+								: sql.param(onUpdateFnResult, col);
+							valueList.push(newValue);
+						} else {
+							valueList.push(sql`default`);
+						}
+					} else {
+						valueList.push(colValue);
+					}
+				}
+
+				valuesSqlList.push(valueList);
+				if (valueIndex < values.length - 1) {
+					valuesSqlList.push(sql`, `);
+				}
+			}
+		}
+
+		const withSql = this.buildWithCTE(withList);
+
+		const valuesSql = sql.join(valuesSqlList);
+
+		const returningSql = returning
+			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
+			: undefined;
+
+		const onConflictSql = onConflict
+			? sql` on conflict ${onConflict}`
+			: undefined;
+
+		return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
+	}
+
+	buildRefreshMaterializedViewQuery({
+		view,
+		concurrently,
+		withNoData,
+	}: {
+		view: CockroachMaterializedView;
+		concurrently?: boolean;
+		withNoData?: boolean;
+	}): SQL {
+		const concurrentlySql = concurrently ? sql` concurrently` : undefined;
+		const withNoDataSql = withNoData ? sql` with no data` : undefined;
+
+		return sql`refresh materialized view${concurrentlySql} ${view}${withNoDataSql}`;
+	}
+
+	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): Query {
+		return sql.toQuery({
+			escapeName: this.escapeName,
+			escapeParam: this.escapeParam,
+			escapeString: this.escapeString,
+			invokeSource,
+		});
+	}
+
+	// buildRelationalQueryWithPK({
+	// 	fullSchema,
+	// 	schema,
+	// 	tableNamesMap,
+	// 	table,
+	// 	tableConfig,
+	// 	queryConfig: config,
+	// 	tableAlias,
+	// 	isRoot = false,
+	// 	joinOn,
+	// }: {
+	// 	fullSchema: Record<string, unknown>;
+	// 	schema: TablesRelationalConfig;
+	// 	tableNamesMap: Record<string, string>;
+	// 	table: CockroachTable;
+	// 	tableConfig: TableRelationalConfig;
+	// 	queryConfig: true | DBQueryConfig<'many', true>;
+	// 	tableAlias: string;
+	// 	isRoot?: boolean;
+	// 	joinOn?: SQL;
+	// }): BuildRelationalQueryResult<CockroachTable, CockroachColumn> {
+	// 	// For { "<relation>": true }, return a table with selection of all columns
+	// 	if (config === true) {
+	// 		const selectionEntries = Object.entries(tableConfig.columns);
+	// 		const selection: BuildRelationalQueryResult<CockroachTable, CockroachColumn>['selection'] = selectionEntries.map((
+	// 			[key, value],
+	// 		) => ({
+	// 			dbKey: value.name,
+	// 			tsKey: key,
+	// 			field: value as CockroachColumn,
+	// 			relationTableTsKey: undefined,
+	// 			isJson: false,
+	// 			selection: [],
+	// 		}));
+
+	// 		return {
+	// 			tableTsKey: tableConfig.tsName,
+	// 			sql: table,
+	// 			selection,
+	// 		};
+	// 	}
+
+	// 	// let selection: BuildRelationalQueryResult<CockroachTable, CockroachColumn>['selection'] = [];
+	// 	// let selectionForBuild = selection;
+
+	// 	const aliasedColumns = Object.fromEntries(
+	// 		Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
+	// 	);
+
+	// 	const aliasedRelations = Object.fromEntries(
+	// 		Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]),
+	// 	);
+
+	// 	const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
+
+	// 	let where, hasUserDefinedWhere;
+	// 	if (config.where) {
+	// 		const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
+	// 		where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+	// 		hasUserDefinedWhere = !!where;
+	// 	}
+	// 	where = and(joinOn, where);
+
+	// 	// const fieldsSelection: { tsKey: string; value: CockroachColumn | SQL.Aliased; isExtra?: boolean }[] = [];
+	// 	let joins: Join[] = [];
+	// 	let selectedColumns: string[] = [];
+
+	// 	// Figure out which columns to select
+	// 	if (config.columns) {
+	// 		let isIncludeMode = false;
+
+	// 		for (const [field, value] of Object.entries(config.columns)) {
+	// 			if (value === undefined) {
+	// 				continue;
+	// 			}
+
+	// 			if (field in tableConfig.columns) {
+	// 				if (!isIncludeMode && value === true) {
+	// 					isIncludeMode = true;
+	// 				}
+	// 				selectedColumns.push(field);
+	// 			}
+	// 		}
+
+	// 		if (selectedColumns.length > 0) {
+	// 			selectedColumns = isIncludeMode
+	// 				? selectedColumns.filter((c) => config.columns?.[c] === true)
+	// 				: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+	// 		}
+	// 	} else {
+	// 		// Select all columns if selection is not specified
+	// 		selectedColumns = Object.keys(tableConfig.columns);
+	// 	}
+
+	// 	// for (const field of selectedColumns) {
+	// 	// 	const column = tableConfig.columns[field]! as CockroachColumn;
+	// 	// 	fieldsSelection.push({ tsKey: field, value: column });
+	// 	// }
+
+	// 	let initiallySelectedRelations: {
+	// 		tsKey: string;
+	// 		queryConfig: true | DBQueryConfig<'many', false>;
+	// 		relation: Relation;
+	// 	}[] = [];
+
+	// 	// let selectedRelations: BuildRelationalQueryResult<CockroachTable, CockroachColumn>['selection'] = [];
+
+	// 	// Figure out which relations to select
+	// 	if (config.with) {
+	// 		initiallySelectedRelations = Object.entries(config.with)
+	// 			.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
+	// 			.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
+	// 	}
+
+	// 	const manyRelations = initiallySelectedRelations.filter((r) =>
+	// 		is(r.relation, Many)
+	// 		&& (schema[tableNamesMap[r.relation.referencedTable[Table.Symbol.Name]]!]?.primaryKey.length ?? 0) > 0
+	// 	);
+	// 	// If this is the last Many relation (or there are no Many relations), we are on the innermost subquery level
+	// 	const isInnermostQuery = manyRelations.length < 2;
+
+	// 	const selectedExtras: {
+	// 		tsKey: string;
+	// 		value: SQL.Aliased;
+	// 	}[] = [];
+
+	// 	// Figure out which extras to select
+	// 	if (isInnermostQuery && config.extras) {
+	// 		const extras = typeof config.extras === 'function'
+	// 			? config.extras(aliasedFields, { sql })
+	// 			: config.extras;
+	// 		for (const [tsKey, value] of Object.entries(extras)) {
+	// 			selectedExtras.push({
+	// 				tsKey,
+	// 				value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
+	// 			});
+	// 		}
+	// 	}
+
+	// 	// Transform `fieldsSelection` into `selection`
+	// 	// `fieldsSelection` shouldn't be used after this point
+	// 	// for (const { tsKey, value, isExtra } of fieldsSelection) {
+	// 	// 	selection.push({
+	// 	// 		dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
+	// 	// 		tsKey,
+	// 	// 		field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
+	// 	// 		relationTableTsKey: undefined,
+	// 	// 		isJson: false,
+	// 	// 		isExtra,
+	// 	// 		selection: [],
+	// 	// 	});
+	// 	// }
+
+	// 	let orderByOrig = typeof config.orderBy === 'function'
+	// 		? config.orderBy(aliasedFields, orderByOperators)
+	// 		: config.orderBy ?? [];
+	// 	if (!Array.isArray(orderByOrig)) {
+	// 		orderByOrig = [orderByOrig];
+	// 	}
+	// 	const orderBy = orderByOrig.map((orderByValue) => {
+	// 		if (is(orderByValue, Column)) {
+	// 			return aliasedTableColumn(orderByValue, tableAlias) as CockroachColumn;
+	// 		}
+	// 		return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+	// 	});
+
+	// 	const limit = isInnermostQuery ? config.limit : undefined;
+	// 	const offset = isInnermostQuery ? config.offset : undefined;
+
+	// 	// For non-root queries without additional config except columns, return a table with selection
+	// 	if (
+	// 		!isRoot
+	// 		&& initiallySelectedRelations.length === 0
+	// 		&& selectedExtras.length === 0
+	// 		&& !where
+	// 		&& orderBy.length === 0
+	// 		&& limit === undefined
+	// 		&& offset === undefined
+	// 	) {
+	// 		return {
+	// 			tableTsKey: tableConfig.tsName,
+	// 			sql: table,
+	// 			selection: selectedColumns.map((key) => ({
+	// 				dbKey: tableConfig.columns[key]!.name,
+	// 				tsKey: key,
+	// 				field: tableConfig.columns[key] as CockroachColumn,
+	// 				relationTableTsKey: undefined,
+	// 				isJson: false,
+	// 				selection: [],
+	// 			})),
+	// 		};
+	// 	}
+
+	// 	const selectedRelationsWithoutPK:
+
+	// 	// Process all relations without primary keys, because they need to be joined differently and will all be on the same query level
+	// 	for (
+	// 		const {
+	// 			tsKey: selectedRelationTsKey,
+	// 			queryConfig: selectedRelationConfigValue,
+	// 			relation,
+	// 		} of initiallySelectedRelations
+	// 	) {
+	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
+	// 		const relationTable = schema[relationTableTsName]!;
+
+	// 		if (relationTable.primaryKey.length > 0) {
+	// 			continue;
+	// 		}
+
+	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+	// 		const joinOn = and(
+	// 			...normalizedRelation.fields.map((field, i) =>
+	// 				eq(
+	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+	// 					aliasedTableColumn(field, tableAlias),
+	// 				)
+	// 			),
+	// 		);
+	// 		const builtRelation = this.buildRelationalQueryWithoutPK({
+	// 			fullSchema,
+	// 			schema,
+	// 			tableNamesMap,
+	// 			table: fullSchema[relationTableTsName] as CockroachTable,
+	// 			tableConfig: schema[relationTableTsName]!,
+	// 			queryConfig: selectedRelationConfigValue,
+	// 			tableAlias: relationTableAlias,
+	// 			joinOn,
+	// 			nestedQueryRelation: relation,
+	// 		});
+	// 		const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
+	// 		joins.push({
+	// 			on: sql`true`,
+	// 			table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
+	// 			alias: relationTableAlias,
+	// 			joinType: 'left',
+	// 			lateral: true,
+	// 		});
+	// 		selectedRelations.push({
+	// 			dbKey: selectedRelationTsKey,
+	// 			tsKey: selectedRelationTsKey,
+	// 			field,
+	// 			relationTableTsKey: relationTableTsName,
+	// 			isJson: true,
+	// 			selection: builtRelation.selection,
+	// 		});
+	// 	}
+
+	// 	const oneRelations = initiallySelectedRelations.filter((r): r is typeof r & { relation: One } =>
+	// 		is(r.relation, One)
+	// 	);
+
+	// 	// Process all One relations with PKs, because they can all be joined on the same level
+	// 	for (
+	// 		const {
+	// 			tsKey: selectedRelationTsKey,
+	// 			queryConfig: selectedRelationConfigValue,
+	// 			relation,
+	// 		} of oneRelations
+	// 	) {
+	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
+	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+	// 		const relationTable = schema[relationTableTsName]!;
+
+	// 		if (relationTable.primaryKey.length === 0) {
+	// 			continue;
+	// 		}
+
+	// 		const joinOn = and(
+	// 			...normalizedRelation.fields.map((field, i) =>
+	// 				eq(
+	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+	// 					aliasedTableColumn(field, tableAlias),
+	// 				)
+	// 			),
+	// 		);
+	// 		const builtRelation = this.buildRelationalQueryWithPK({
+	// 			fullSchema,
+	// 			schema,
+	// 			tableNamesMap,
+	// 			table: fullSchema[relationTableTsName] as CockroachTable,
+	// 			tableConfig: schema[relationTableTsName]!,
+	// 			queryConfig: selectedRelationConfigValue,
+	// 			tableAlias: relationTableAlias,
+	// 			joinOn,
+	// 		});
+	// 		const field = sql`case when ${sql.identifier(relationTableAlias)} is null then null else json_build_array(${
+	// 			sql.join(
+	// 				builtRelation.selection.map(({ field }) =>
+	// 					is(field, SQL.Aliased)
+	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
+	// 						: is(field, Column)
+	// 						? aliasedTableColumn(field, relationTableAlias)
+	// 						: field
+	// 				),
+	// 				sql`, `,
+	// 			)
+	// 		}) end`.as(selectedRelationTsKey);
+	// 		const isLateralJoin = is(builtRelation.sql, SQL);
+	// 		joins.push({
+	// 			on: isLateralJoin ? sql`true` : joinOn,
+	// 			table: is(builtRelation.sql, SQL)
+	// 				? new Subquery(builtRelation.sql, {}, relationTableAlias)
+	// 				: aliasedTable(builtRelation.sql, relationTableAlias),
+	// 			alias: relationTableAlias,
+	// 			joinType: 'left',
+	// 			lateral: is(builtRelation.sql, SQL),
+	// 		});
+	// 		selectedRelations.push({
+	// 			dbKey: selectedRelationTsKey,
+	// 			tsKey: selectedRelationTsKey,
+	// 			field,
+	// 			relationTableTsKey: relationTableTsName,
+	// 			isJson: true,
+	// 			selection: builtRelation.selection,
+	// 		});
+	// 	}
+
+	// 	let distinct: CockroachSelectConfig['distinct'];
+	// 	let tableFrom: CockroachTable | Subquery = table;
+
+	// 	// Process first Many relation - each one requires a nested subquery
+	// 	const manyRelation = manyRelations[0];
+	// 	if (manyRelation) {
+	// 		const {
+	// 			tsKey: selectedRelationTsKey,
+	// 			queryConfig: selectedRelationQueryConfig,
+	// 			relation,
+	// 		} = manyRelation;
+
+	// 		distinct = {
+	// 			on: tableConfig.primaryKey.map((c) => aliasedTableColumn(c as CockroachColumn, tableAlias)),
+	// 		};
+
+	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
+	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+	// 		const joinOn = and(
+	// 			...normalizedRelation.fields.map((field, i) =>
+	// 				eq(
+	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+	// 					aliasedTableColumn(field, tableAlias),
+	// 				)
+	// 			),
+	// 		);
+
+	// 		const builtRelationJoin = this.buildRelationalQueryWithPK({
+	// 			fullSchema,
+	// 			schema,
+	// 			tableNamesMap,
+	// 			table: fullSchema[relationTableTsName] as CockroachTable,
+	// 			tableConfig: schema[relationTableTsName]!,
+	// 			queryConfig: selectedRelationQueryConfig,
+	// 			tableAlias: relationTableAlias,
+	// 			joinOn,
+	// 		});
+
+	// 		const builtRelationSelectionField = sql`case when ${
+	// 			sql.identifier(relationTableAlias)
+	// 		} is null then '[]' else json_agg(json_build_array(${
+	// 			sql.join(
+	// 				builtRelationJoin.selection.map(({ field }) =>
+	// 					is(field, SQL.Aliased)
+	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
+	// 						: is(field, Column)
+	// 						? aliasedTableColumn(field, relationTableAlias)
+	// 						: field
+	// 				),
+	// 				sql`, `,
+	// 			)
+	// 		})) over (partition by ${sql.join(distinct.on, sql`, `)}) end`.as(selectedRelationTsKey);
+	// 		const isLateralJoin = is(builtRelationJoin.sql, SQL);
+	// 		joins.push({
+	// 			on: isLateralJoin ? sql`true` : joinOn,
+	// 			table: isLateralJoin
+	// 				? new Subquery(builtRelationJoin.sql as SQL, {}, relationTableAlias)
+	// 				: aliasedTable(builtRelationJoin.sql as CockroachTable, relationTableAlias),
+	// 			alias: relationTableAlias,
+	// 			joinType: 'left',
+	// 			lateral: isLateralJoin,
+	// 		});
+
+	// 		// Build the "from" subquery with the remaining Many relations
+	// 		const builtTableFrom = this.buildRelationalQueryWithPK({
+	// 			fullSchema,
+	// 			schema,
+	// 			tableNamesMap,
+	// 			table,
+	// 			tableConfig,
+	// 			queryConfig: {
+	// 				...config,
+	// 				where: undefined,
+	// 				orderBy: undefined,
+	// 				limit: undefined,
+	// 				offset: undefined,
+	// 				with: manyRelations.slice(1).reduce<NonNullable<typeof config['with']>>(
+	// 					(result, { tsKey, queryConfig: configValue }) => {
+	// 						result[tsKey] = configValue;
+	// 						return result;
+	// 					},
+	// 					{},
+	// 				),
+	// 			},
+	// 			tableAlias,
+	// 		});
+
+	// 		selectedRelations.push({
+	// 			dbKey: selectedRelationTsKey,
+	// 			tsKey: selectedRelationTsKey,
+	// 			field: builtRelationSelectionField,
+	// 			relationTableTsKey: relationTableTsName,
+	// 			isJson: true,
+	// 			selection: builtRelationJoin.selection,
+	// 		});
+
+	// 		// selection = builtTableFrom.selection.map((item) =>
+	// 		// 	is(item.field, SQL.Aliased)
+	// 		// 		? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
+	// 		// 		: item
+	// 		// );
+	// 		// selectionForBuild = [{
+	// 		// 	dbKey: '*',
+	// 		// 	tsKey: '*',
+	// 		// 	field: sql`${sql.identifier(tableAlias)}.*`,
+	// 		// 	selection: [],
+	// 		// 	isJson: false,
+	// 		// 	relationTableTsKey: undefined,
+	// 		// }];
+	// 		// const newSelectionItem: (typeof selection)[number] = {
+	// 		// 	dbKey: selectedRelationTsKey,
+	// 		// 	tsKey: selectedRelationTsKey,
+	// 		// 	field,
+	// 		// 	relationTableTsKey: relationTableTsName,
+	// 		// 	isJson: true,
+	// 		// 	selection: builtRelationJoin.selection,
+	// 		// };
+	// 		// selection.push(newSelectionItem);
+	// 		// selectionForBuild.push(newSelectionItem);
+
+	// 		tableFrom = is(builtTableFrom.sql, CockroachTable)
+	// 			? builtTableFrom.sql
+	// 			: new Subquery(builtTableFrom.sql, {}, tableAlias);
+	// 	}
+
+	// 	if (selectedColumns.length === 0 && selectedRelations.length === 0 && selectedExtras.length === 0) {
+	// 		throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+	// 	}
+
+	// 	let selection: BuildRelationalQueryResult<CockroachTable, CockroachColumn>['selection'];
+
+	// 	function prepareSelectedColumns() {
+	// 		return selectedColumns.map((key) => ({
+	// 			dbKey: tableConfig.columns[key]!.name,
+	// 			tsKey: key,
+	// 			field: tableConfig.columns[key] as CockroachColumn,
+	// 			relationTableTsKey: undefined,
+	// 			isJson: false,
+	// 			selection: [],
+	// 		}));
+	// 	}
+
+	// 	function prepareSelectedExtras() {
+	// 		return selectedExtras.map((item) => ({
+	// 			dbKey: item.value.fieldAlias,
+	// 			tsKey: item.tsKey,
+	// 			field: item.value,
+	// 			relationTableTsKey: undefined,
+	// 			isJson: false,
+	// 			selection: [],
+	// 		}));
+	// 	}
+
+	// 	if (isRoot) {
+	// 		selection = [
+	// 			...prepareSelectedColumns(),
+	// 			...prepareSelectedExtras(),
+	// 		];
+	// 	}
+
+	// 	if (hasUserDefinedWhere || orderBy.length > 0) {
+	// 		tableFrom = new Subquery(
+	// 			this.buildSelectQuery({
+	// 				table: is(tableFrom, CockroachTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
+	// 				fields: {},
+	// 				fieldsFlat: selectionForBuild.map(({ field }) => ({
+	// 					path: [],
+	// 					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+	// 				})),
+	// 				joins,
+	// 				distinct,
+	// 			}),
+	// 			{},
+	// 			tableAlias,
+	// 		);
+	// 		selectionForBuild = selection.map((item) =>
+	// 			is(item.field, SQL.Aliased)
+	// 				? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
+	// 				: item
+	// 		);
+	// 		joins = [];
+	// 		distinct = undefined;
+	// 	}
+
+	// 	const result = this.buildSelectQuery({
+	// 		table: is(tableFrom, CockroachTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
+	// 		fields: {},
+	// 		fieldsFlat: selectionForBuild.map(({ field }) => ({
+	// 			path: [],
+	// 			field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+	// 		})),
+	// 		where,
+	// 		limit,
+	// 		offset,
+	// 		joins,
+	// 		orderBy,
+	// 		distinct,
+	// 	});
+
+	// 	return {
+	// 		tableTsKey: tableConfig.tsName,
+	// 		sql: result,
+	// 		selection,
+	// 	};
+	// }
+
+	buildRelationalQueryWithoutPK({
+		fullSchema,
+		schema,
+		tableNamesMap,
+		table,
+		tableConfig,
+		queryConfig: config,
+		tableAlias,
+		nestedQueryRelation,
+		joinOn,
+	}: {
+		fullSchema: Record<string, unknown>;
+		schema: V1.TablesRelationalConfig;
+		tableNamesMap: Record<string, string>;
+		table: CockroachTable;
+		tableConfig: V1.TableRelationalConfig;
+		queryConfig: true | V1.DBQueryConfig<'many', true>;
+		tableAlias: string;
+		nestedQueryRelation?: V1.Relation;
+		joinOn?: SQL;
+	}): V1.BuildRelationalQueryResult<CockroachTable, CockroachColumn> {
+		let selection: V1.BuildRelationalQueryResult<
+			CockroachTable,
+			CockroachColumn
+		>['selection'] = [];
+		let limit,
+			offset,
+			orderBy: NonNullable<CockroachSelectConfig['orderBy']> = [],
+			where;
+		const joins: CockroachSelectJoinConfig[] = [];
+
+		if (config === true) {
+			const selectionEntries = Object.entries(tableConfig.columns);
+			selection = selectionEntries.map(([key, value]) => ({
+				dbKey: value.name,
+				tsKey: key,
+				field: aliasedTableColumn(value as CockroachColumn, tableAlias),
+				relationTableTsKey: undefined,
+				isJson: false,
+				selection: [],
+			}));
+		} else {
+			const aliasedColumns = Object.fromEntries(
+				Object.entries(tableConfig.columns).map(([key, value]) => [
+					key,
+					aliasedTableColumn(value, tableAlias),
+				]),
+			);
+
+			if (config.where) {
+				const whereSql = typeof config.where === 'function'
+					? config.where(aliasedColumns, V1.getOperators())
+					: config.where;
+				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+			}
+
+			const fieldsSelection: {
+				tsKey: string;
+				value: CockroachColumn | SQL.Aliased;
+			}[] = [];
+			let selectedColumns: string[] = [];
+
+			// Figure out which columns to select
+			if (config.columns) {
+				let isIncludeMode = false;
+
+				for (const [field, value] of Object.entries(config.columns)) {
+					if (value === undefined) {
+						continue;
+					}
+
+					if (field in tableConfig.columns) {
+						if (!isIncludeMode && value === true) {
+							isIncludeMode = true;
+						}
+						selectedColumns.push(field);
+					}
+				}
+
+				if (selectedColumns.length > 0) {
+					selectedColumns = isIncludeMode
+						? selectedColumns.filter((c) => config.columns?.[c] === true)
+						: Object.keys(tableConfig.columns).filter(
+							(key) => !selectedColumns.includes(key),
+						);
+				}
+			} else {
+				// Select all columns if selection is not specified
+				selectedColumns = Object.keys(tableConfig.columns);
+			}
+
+			for (const field of selectedColumns) {
+				const column = tableConfig.columns[field]! as CockroachColumn;
+				fieldsSelection.push({ tsKey: field, value: column });
+			}
+
+			let selectedRelations: {
+				tsKey: string;
+				queryConfig: true | V1.DBQueryConfig<'many', false>;
+				relation: V1.Relation;
+			}[] = [];
+
+			// Figure out which relations to select
+			if (config.with) {
+				selectedRelations = Object.entries(config.with)
+					.filter(
+						(
+							entry,
+						): entry is [(typeof entry)[0], NonNullable<(typeof entry)[1]>] => !!entry[1],
+					)
+					.map(([tsKey, queryConfig]) => ({
+						tsKey,
+						queryConfig,
+						relation: tableConfig.relations[tsKey]!,
+					}));
+			}
+
+			let extras;
+
+			// Figure out which extras to select
+			if (config.extras) {
+				extras = typeof config.extras === 'function'
+					? config.extras(aliasedColumns, { sql })
+					: config.extras;
+				for (const [tsKey, value] of Object.entries(extras)) {
+					fieldsSelection.push({
+						tsKey,
+						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
+					});
+				}
+			}
+
+			// Transform `fieldsSelection` into `selection`
+			// `fieldsSelection` shouldn't be used after this point
+			for (const { tsKey, value } of fieldsSelection) {
+				selection.push({
+					dbKey: is(value, SQL.Aliased)
+						? value.fieldAlias
+						: tableConfig.columns[tsKey]!.name,
+					tsKey,
+					field: is(value, Column)
+						? aliasedTableColumn(value, tableAlias)
+						: value,
+					relationTableTsKey: undefined,
+					isJson: false,
+					selection: [],
+				});
+			}
+
+			let orderByOrig = typeof config.orderBy === 'function'
+				? config.orderBy(aliasedColumns, V1.getOrderByOperators())
+				: (config.orderBy ?? []);
+			if (!Array.isArray(orderByOrig)) {
+				orderByOrig = [orderByOrig];
+			}
+			orderBy = orderByOrig.map((orderByValue) => {
+				if (is(orderByValue, Column)) {
+					return aliasedTableColumn(
+						orderByValue,
+						tableAlias,
+					) as CockroachColumn;
+				}
+				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+			});
+
+			limit = config.limit;
+			offset = config.offset;
+
+			// Process all relations
+			for (
+				const {
+					tsKey: selectedRelationTsKey,
+					queryConfig: selectedRelationConfigValue,
+					relation,
+				} of selectedRelations
+			) {
+				const normalizedRelation = V1.normalizeRelation(
+					schema,
+					tableNamesMap,
+					relation,
+				);
+				const relationTableName = getTableUniqueName(relation.referencedTable);
+				const relationTableTsName = tableNamesMap[relationTableName]!;
+				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+				const joinOn = and(
+					...normalizedRelation.fields.map((field, i) =>
+						eq(
+							aliasedTableColumn(
+								normalizedRelation.references[i]!,
+								relationTableAlias,
+							),
+							aliasedTableColumn(field, tableAlias),
+						)
+					),
+				);
+				const builtRelation = this.buildRelationalQueryWithoutPK({
+					fullSchema,
+					schema,
+					tableNamesMap,
+					table: fullSchema[relationTableTsName] as CockroachTable,
+					tableConfig: schema[relationTableTsName]!,
+					queryConfig: is(relation, V1.One)
+						? selectedRelationConfigValue === true
+							? { limit: 1 }
+							: { ...selectedRelationConfigValue, limit: 1 }
+						: selectedRelationConfigValue,
+					tableAlias: relationTableAlias,
+					joinOn,
+					nestedQueryRelation: relation,
+				});
+				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(
+					selectedRelationTsKey,
+				);
+				joins.push({
+					on: sql`true`,
+					table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
+					alias: relationTableAlias,
+					joinType: 'left',
+					lateral: true,
+				});
+				selection.push({
+					dbKey: selectedRelationTsKey,
+					tsKey: selectedRelationTsKey,
+					field,
+					relationTableTsKey: relationTableTsName,
+					isJson: true,
+					selection: builtRelation.selection,
+				});
+			}
+		}
+
+		if (selection.length === 0) {
+			throw new DrizzleError({
+				message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`,
+			});
+		}
+
+		let result;
+
+		where = and(joinOn, where);
+
+		if (nestedQueryRelation) {
+			let field = sql`json_build_array(${
+				sql.join(
+					selection.map(({ field, tsKey, isJson }) =>
+						isJson
+							? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier('data')}`
+							: is(field, SQL.Aliased)
+							? field.sql
+							: field
+					),
+					sql`, `,
+				)
+			})`;
+			if (is(nestedQueryRelation, V1.Many)) {
+				field = sql`coalesce(json_agg(${field}${
+					orderBy.length > 0
+						? sql` order by ${sql.join(orderBy, sql`, `)}`
+						: undefined
+				}), '[]'::json)`;
+				// orderBy = [];
+			}
+			const nestedSelection = [
+				{
+					dbKey: 'data',
+					tsKey: 'data',
+					field: field.as('data'),
+					isJson: true,
+					relationTableTsKey: tableConfig.tsName,
+					selection,
+				},
+			];
+
+			const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
+
+			if (needsSubquery) {
+				result = this.buildSelectQuery({
+					table: aliasedTable(table, tableAlias),
+					fields: {},
+					fieldsFlat: [
+						{
+							path: [],
+							field: sql.raw('*'),
+						},
+					],
+					where,
+					limit,
+					offset,
+					orderBy,
+					setOperators: [],
+				});
+
+				where = undefined;
+				limit = undefined;
+				offset = undefined;
+				orderBy = [];
+			} else {
+				result = aliasedTable(table, tableAlias);
+			}
+
+			result = this.buildSelectQuery({
+				table: is(result, CockroachTable)
+					? result
+					: new Subquery(result, {}, tableAlias),
+				fields: {},
+				fieldsFlat: nestedSelection.map(({ field }) => ({
+					path: [],
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
+				})),
+				joins,
+				where,
+				limit,
+				offset,
+				orderBy,
+				setOperators: [],
+			});
+		} else {
+			result = this.buildSelectQuery({
+				table: aliasedTable(table, tableAlias),
+				fields: {},
+				fieldsFlat: selection.map(({ field }) => ({
+					path: [],
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
+				})),
+				joins,
+				where,
+				limit,
+				offset,
+				orderBy,
+				setOperators: [],
+			});
+		}
+
+		return {
+			tableTsKey: tableConfig.tsName,
+			sql: result,
+			selection,
+		};
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/expressions.ts b/drizzle-orm/src/cockroach-core/expressions.ts
new file mode 100644
index 0000000000..3e3781eb48
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/expressions.ts
@@ -0,0 +1,25 @@
+import type { CockroachColumn } from '~/cockroach-core/columns/index.ts';
+import { bindIfParam } from '~/sql/expressions/index.ts';
+import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
+
+export * from '~/sql/expressions/index.ts';
+
+export function concat(column: CockroachColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
+	return sql`${column} || ${bindIfParam(value, column)}`;
+}
+
+export function substring(
+	column: CockroachColumn | SQL.Aliased,
+	{ from, for: _for }: { from?: number | Placeholder | SQLWrapper; for?: number | Placeholder | SQLWrapper },
+): SQL {
+	const chunks: SQLChunk[] = [sql`substring(`, column];
+	if (from !== undefined) {
+		chunks.push(sql` from `, bindIfParam(from, column));
+	}
+	if (_for !== undefined) {
+		chunks.push(sql` for `, bindIfParam(_for, column));
+	}
+	chunks.push(sql`)`);
+	return sql.join(chunks);
+}
diff --git a/drizzle-orm/src/cockroach-core/foreign-keys.ts b/drizzle-orm/src/cockroach-core/foreign-keys.ts
new file mode 100644
index 0000000000..2d339da5fe
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/foreign-keys.ts
@@ -0,0 +1,119 @@
+import { entityKind } from '~/entity.ts';
+import type { AnyCockroachColumn, CockroachColumn } from './columns/index.ts';
+import type { CockroachTable } from './table.ts';
+
+export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
+
+export type Reference = () => {
+	readonly name?: string;
+	readonly columns: CockroachColumn[];
+	readonly foreignTable: CockroachTable;
+	readonly foreignColumns: CockroachColumn[];
+};
+
+export class ForeignKeyBuilder {
+	static readonly [entityKind]: string = 'CockroachForeignKeyBuilder';
+
+	/** @internal */
+	reference: Reference;
+
+	/** @internal */
+	_onUpdate: UpdateDeleteAction | undefined = 'no action';
+
+	/** @internal */
+	_onDelete: UpdateDeleteAction | undefined = 'no action';
+
+	constructor(
+		config: () => {
+			name?: string;
+			columns: CockroachColumn[];
+			foreignColumns: CockroachColumn[];
+		},
+		actions?: {
+			onUpdate?: UpdateDeleteAction;
+			onDelete?: UpdateDeleteAction;
+		} | undefined,
+	) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as CockroachTable, foreignColumns };
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+
+	onUpdate(action: UpdateDeleteAction): this {
+		this._onUpdate = action === undefined ? 'no action' : action;
+		return this;
+	}
+
+	onDelete(action: UpdateDeleteAction): this {
+		this._onDelete = action === undefined ? 'no action' : action;
+		return this;
+	}
+
+	/** @internal */
+	build(table: CockroachTable): ForeignKey {
+		return new ForeignKey(table, this);
+	}
+}
+
+export type AnyForeignKeyBuilder = ForeignKeyBuilder;
+
+export class ForeignKey {
+	static readonly [entityKind]: string = 'CockroachForeignKey';
+
+	readonly reference: Reference;
+	readonly onUpdate: UpdateDeleteAction | undefined;
+	readonly onDelete: UpdateDeleteAction | undefined;
+	readonly name?: string;
+
+	constructor(readonly table: CockroachTable, builder: ForeignKeyBuilder) {
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+	}
+
+	getName(): string | undefined {
+		const { name } = this.reference();
+
+		return name;
+	}
+
+	isNameExplicit() {
+		return !!this.reference().name;
+	}
+}
+
+type ColumnsWithTable<
+	TTableName extends string,
+	TColumns extends CockroachColumn[],
+> = { [Key in keyof TColumns]: AnyCockroachColumn<{ tableName: TTableName }> };
+
+export function foreignKey<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends [
+		AnyCockroachColumn<{ tableName: TTableName }>,
+		...AnyCockroachColumn<{ tableName: TTableName }>[],
+	],
+>(
+	config: {
+		name?: string;
+		columns: TColumns;
+		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+	},
+): ForeignKeyBuilder {
+	function mappedConfig() {
+		const { name, columns, foreignColumns } = config;
+		return {
+			name,
+			columns,
+			foreignColumns,
+		};
+	}
+
+	return new ForeignKeyBuilder(mappedConfig);
+}
diff --git a/drizzle-orm/src/cockroach-core/index.ts b/drizzle-orm/src/cockroach-core/index.ts
new file mode 100644
index 0000000000..e3cd0ce8ed
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/index.ts
@@ -0,0 +1,21 @@
+export * from './alias.ts';
+export * from './casing.ts';
+export * from './checks.ts';
+export * from './columns/index.ts';
+export * from './db.ts';
+export * from './dialect.ts';
+export * from './foreign-keys.ts';
+export * from './indexes.ts';
+export * from './policies.ts';
+export * from './primary-keys.ts';
+export * from './query-builders/index.ts';
+export * from './roles.ts';
+export * from './schema.ts';
+export * from './sequence.ts';
+export * from './session.ts';
+export * from './subquery.ts';
+export * from './table.ts';
+export * from './unique-constraint.ts';
+export * from './utils.ts';
+export * from './utils/index.ts';
+export * from './view.ts';
diff --git a/drizzle-orm/src/cockroach-core/indexes.ts b/drizzle-orm/src/cockroach-core/indexes.ts
new file mode 100644
index 0000000000..c1d3a8c62c
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/indexes.ts
@@ -0,0 +1,230 @@
+import { entityKind, is } from '~/entity.ts';
+import { SQL } from '~/sql/sql.ts';
+import { ExtraConfigColumn } from './columns/index.ts';
+import type { CockroachColumn } from './columns/index.ts';
+import { IndexedColumn } from './columns/index.ts';
+import type { CockroachTable } from './table.ts';
+
+interface IndexConfig {
+	name?: string;
+
+	columns: Partial<IndexedColumn | SQL>[];
+
+	/**
+	 * If true, the index will be created as `create unique index` instead of `create index`.
+	 */
+	unique: boolean;
+
+	/**
+	 * If true, the index will be created as `create index ... on only <table>` instead of `create index ... on <table>`.
+	 */
+	only: boolean;
+
+	/**
+	 * Condition for partial index.
+	 */
+	where?: SQL;
+
+	/**
+	 * The optional USING clause method for the index
+	 */
+	method?: 'btree' | string;
+}
+
+export type IndexColumn = CockroachColumn;
+
+export type CockroachIndexMethod =
+	| 'btree'
+	| 'hash'
+	| 'gin'
+	| 'cspann';
+
+export class IndexBuilderOn {
+	static readonly [entityKind]: string = 'CockroachIndexBuilderOn';
+
+	constructor(private unique: boolean, private name?: string) {}
+
+	on(
+		...columns: [
+			Partial<ExtraConfigColumn> | SQL | CockroachColumn,
+			...Partial<ExtraConfigColumn | SQL | CockroachColumn>[],
+		]
+	): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as CockroachColumn;
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
+			}),
+			this.unique,
+			false,
+			this.name,
+		);
+	}
+
+	onOnly(
+		...columns: [
+			Partial<ExtraConfigColumn | SQL | CockroachColumn>,
+			...Partial<ExtraConfigColumn | SQL | CockroachColumn>[],
+		]
+	): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as CockroachColumn;
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
+			}),
+			this.unique,
+			true,
+			this.name,
+		);
+	}
+
+	/**
+	 * Specify what index method to use. Choices are `btree`, `hash`, `gin`, `cspann`. The default method is `btree`.
+	 *
+	 * @param method The name of the index method to be used
+	 * @param columns
+	 * @returns
+	 */
+	using(
+		method: CockroachIndexMethod,
+		...columns: [
+			Partial<ExtraConfigColumn | SQL | CockroachColumn>,
+			...Partial<ExtraConfigColumn | SQL | CockroachColumn>[],
+		]
+	): IndexBuilder {
+		return new IndexBuilder(
+			columns.map((it) => {
+				if (is(it, SQL)) {
+					return it;
+				}
+
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as CockroachColumn;
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
+			}),
+			this.unique,
+			true,
+			this.name,
+			method,
+		);
+	}
+}
+
+export interface AnyIndexBuilder {
+	build(table: CockroachTable): Index;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface IndexBuilder extends AnyIndexBuilder {}
+
+export class IndexBuilder implements AnyIndexBuilder {
+	static readonly [entityKind]: string = 'CockroachIndexBuilder';
+
+	/** @internal */
+	config: IndexConfig;
+
+	constructor(
+		columns: Partial<IndexedColumn | SQL>[],
+		unique: boolean,
+		only: boolean,
+		name?: string,
+		method: string = 'btree',
+	) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			only,
+			method,
+		};
+	}
+
+	where(condition: SQL): this {
+		this.config.where = condition;
+		return this;
+	}
+
+	/** @internal */
+	build(table: CockroachTable): Index {
+		return new Index(this.config, table);
+	}
+}
+
+export class Index {
+	static readonly [entityKind]: string = 'CockroachIndex';
+
+	readonly config: IndexConfig & { table: CockroachTable };
+	readonly isNameExplicit: boolean;
+
+	constructor(config: IndexConfig, table: CockroachTable) {
+		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
+	}
+}
+
+export type GetColumnsTableName<TColumns> = TColumns extends CockroachColumn ? TColumns['_']['name']
+	: TColumns extends CockroachColumn[] ? TColumns[number]['_']['name']
+	: never;
+
+export function index(name?: string): IndexBuilderOn {
+	return new IndexBuilderOn(false, name);
+}
+
+export function uniqueIndex(name?: string): IndexBuilderOn {
+	return new IndexBuilderOn(true, name);
+}
diff --git a/drizzle-orm/src/cockroach-core/policies.ts b/drizzle-orm/src/cockroach-core/policies.ts
new file mode 100644
index 0000000000..f2c076c598
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/policies.ts
@@ -0,0 +1,55 @@
+import { entityKind } from '~/entity.ts';
+import type { SQL } from '~/sql/sql.ts';
+import type { CockroachRole } from './roles.ts';
+import type { CockroachTable } from './table.ts';
+
+export type CockroachPolicyToOption =
+	| 'public'
+	| 'current_user'
+	| 'session_user'
+	| (string & {})
+	| CockroachPolicyToOption[]
+	| CockroachRole;
+
+export interface CockroachPolicyConfig {
+	as?: 'permissive' | 'restrictive';
+	for?: 'all' | 'select' | 'insert' | 'update' | 'delete';
+	to?: CockroachPolicyToOption;
+	using?: SQL;
+	withCheck?: SQL;
+}
+
+export class CockroachPolicy implements CockroachPolicyConfig {
+	static readonly [entityKind]: string = 'CockroachPolicy';
+
+	readonly as: CockroachPolicyConfig['as'];
+	readonly for: CockroachPolicyConfig['for'];
+	readonly to: CockroachPolicyConfig['to'];
+	readonly using: CockroachPolicyConfig['using'];
+	readonly withCheck: CockroachPolicyConfig['withCheck'];
+
+	/** @internal */
+	_linkedTable?: CockroachTable;
+
+	constructor(
+		readonly name: string,
+		config?: CockroachPolicyConfig,
+	) {
+		if (config) {
+			this.as = config.as;
+			this.for = config.for;
+			this.to = config.to;
+			this.using = config.using;
+			this.withCheck = config.withCheck;
+		}
+	}
+
+	link(table: CockroachTable): this {
+		this._linkedTable = table;
+		return this;
+	}
+}
+
+export function cockroachPolicy(name: string, config?: CockroachPolicyConfig) {
+	return new CockroachPolicy(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/primary-keys.ts b/drizzle-orm/src/cockroach-core/primary-keys.ts
new file mode 100644
index 0000000000..e89352fbd2
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/primary-keys.ts
@@ -0,0 +1,52 @@
+import { entityKind } from '~/entity.ts';
+import type { AnyCockroachColumn, CockroachColumn } from './columns/index.ts';
+import type { CockroachTable } from './table.ts';
+
+export function primaryKey<
+	TTableName extends string,
+	TColumn extends AnyCockroachColumn<{ tableName: TTableName }>,
+	TColumns extends AnyCockroachColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder {
+	return new PrimaryKeyBuilder(config.columns, config.name);
+}
+
+export class PrimaryKeyBuilder {
+	static readonly [entityKind]: string = 'CockroachPrimaryKeyBuilder';
+
+	/** @internal */
+	columns: CockroachColumn[];
+
+	/** @internal */
+	name?: string;
+
+	constructor(
+		columns: CockroachColumn[],
+		name?: string,
+	) {
+		this.columns = columns;
+		this.name = name;
+	}
+
+	/** @internal */
+	build(table: CockroachTable): PrimaryKey {
+		return new PrimaryKey(table, this.columns, this.name);
+	}
+}
+
+export class PrimaryKey {
+	static readonly [entityKind]: string = 'CockroachPrimaryKey';
+
+	readonly columns: AnyCockroachColumn<{}>[];
+	readonly name?: string;
+	readonly isNameExplicit: boolean;
+
+	constructor(readonly table: CockroachTable, columns: AnyCockroachColumn<{}>[], name?: string) {
+		this.columns = columns;
+		this.name = name;
+		this.isNameExplicit = !!name;
+	}
+
+	getName(): string | undefined {
+		return this.name;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/count.ts b/drizzle-orm/src/cockroach-core/query-builders/count.ts
new file mode 100644
index 0000000000..312d63e837
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/count.ts
@@ -0,0 +1,73 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { Query } from '~/sql/sql.ts';
+import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { applyMixins } from '~/utils.ts';
+import type { CockroachDialect } from '../dialect.ts';
+import type { CockroachSession } from '../session.ts';
+import type { CockroachTable } from '../table.ts';
+import type { CockroachViewBase } from '../view-base.ts';
+
+// oxlint-disable-next-line no-unused-vars
+export interface CockroachCountBuilder extends SQL<number>, SQLWrapper<number>, QueryPromise<number> {}
+
+export class CockroachCountBuilder extends SQL<number> implements SQLWrapper<number> {
+	static override readonly [entityKind]: string = 'CockroachCountBuilder';
+
+	protected dialect: CockroachDialect;
+	protected session: CockroachSession<any, any, any>;
+
+	private static buildCount(
+		source: CockroachTable | CockroachViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+		parens?: boolean,
+	): SQL<number> {
+		const where = sql` where ${filters}`.if(filters);
+		const query = sql<number>`select count(*) from ${source}${where}`;
+
+		return parens ? sql`(${query})` : query;
+	}
+
+	constructor(
+		protected countConfig: {
+			source: CockroachTable | CockroachViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: CockroachDialect;
+			session: CockroachSession<any, any, any>;
+		},
+	) {
+		super(CockroachCountBuilder.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+		this.dialect = countConfig.dialect;
+		this.session = countConfig.session;
+		this.mapWith((e) => {
+			if (typeof e === 'number') return e;
+
+			return Number(e ?? 0);
+		});
+	}
+
+	private executableSql: SQL<number> | undefined;
+	protected build(): Query {
+		if (!this.executableSql) {
+			const { source, filters } = this.countConfig;
+			this.executableSql = CockroachCountBuilder.buildCount(source, filters);
+		}
+
+		return this.dialect.sqlToQuery(this.executableSql);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>): Promise<number> {
+		return this.session.prepareQuery(
+			this.build(),
+			undefined,
+			undefined,
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues) as any;
+	}
+}
+
+applyMixins(CockroachCountBuilder, [QueryPromise]);
diff --git a/drizzle-orm/src/cockroach-core/query-builders/delete.ts b/drizzle-orm/src/cockroach-core/query-builders/delete.ts
new file mode 100644
index 0000000000..fbdc9a4d05
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/delete.ts
@@ -0,0 +1,296 @@
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import type {
+	CockroachPreparedQuery,
+	CockroachQueryResultHKT,
+	CockroachQueryResultKind,
+	CockroachSession,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import type { CockroachTable } from '~/cockroach-core/table.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { SelectResultFields } from '~/query-builders/select.types.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import { getTableName, Table } from '~/table.ts';
+import { tracer } from '~/tracing.ts';
+import { orderSelectedFields } from '~/utils.ts';
+import type { CockroachColumn } from '../columns/common.ts';
+import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
+
+export type CockroachDeleteWithout<
+	T extends AnyCockroachDeleteBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		CockroachDeleteBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['selectedFields'],
+			T['_']['returning'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type CockroachDelete<
+	TTable extends CockroachTable = CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = CockroachDeleteBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+
+export interface CockroachDeleteConfig {
+	where?: SQL | undefined;
+	table: CockroachTable;
+	returningFields?: SelectedFieldsFlat;
+	returning?: SelectedFieldsOrdered;
+	withList?: Subquery[];
+}
+
+export type CockroachDeleteReturningAll<
+	T extends AnyCockroachDeleteBase,
+	TDynamic extends boolean,
+> = CockroachDeleteWithout<
+	CockroachDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['table']['_']['columns'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type CockroachDeleteReturning<
+	T extends AnyCockroachDeleteBase,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = CockroachDeleteWithout<
+	CockroachDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		TSelectedFields,
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type CockroachDeletePrepare<T extends AnyCockroachDeleteBase> = CockroachPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? CockroachQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type CockroachDeleteDynamic<T extends AnyCockroachDeleteBase> = CockroachDelete<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['selectedFields'],
+	T['_']['returning']
+>;
+
+export type AnyCockroachDeleteBase = CockroachDeleteBase<any, any, any, any, any, any>;
+
+export interface CockroachDeleteBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>,
+	RunnableQuery<
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+		'cockroach'
+	>,
+	SQLWrapper
+{
+	readonly _: {
+		readonly dialect: 'cockroach';
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly selectedFields: TSelectedFields;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+	};
+}
+
+export class CockroachDeleteBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>
+	implements
+		TypedQueryBuilder<
+			TSelectedFields,
+			TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]
+		>,
+		RunnableQuery<
+			TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+			'cockroach'
+		>,
+		SQLWrapper
+{
+	static override readonly [entityKind]: string = 'CockroachDelete';
+
+	private config: CockroachDeleteConfig;
+
+	constructor(
+		table: TTable,
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+		withList?: Subquery[],
+	) {
+		super();
+		this.config = { table, withList };
+	}
+
+	/**
+	 * Adds a `where` clause to the query.
+	 *
+	 * Calling this method will delete only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param where the `where` clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be deleted.
+	 *
+	 * ```ts
+	 * // Delete all cars with green color
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 * // or
+	 * await db.delete(cars).where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Delete all BMW cars with a green color
+	 * await db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Delete all cars with the green or blue color
+	 * await db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(where: SQL | undefined): CockroachDeleteWithout<this, TDynamic, 'where'> {
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `returning` clause to the query.
+	 *
+	 * Calling this method will return the specified fields of the deleted rows. If no fields are specified, all fields will be returned.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete#delete-with-return}
+	 *
+	 * @example
+	 * ```ts
+	 * // Delete all cars with the green color and return all fields
+	 * const deletedCars: Car[] = await db.delete(cars)
+	 *   .where(eq(cars.color, 'green'))
+	 *   .returning();
+	 *
+	 * // Delete all cars with the green color and return only their id and brand fields
+	 * const deletedCarsIdsAndBrands: { id: number, brand: string }[] = await db.delete(cars)
+	 *   .where(eq(cars.color, 'green'))
+	 *   .returning({ id: cars.id, brand: cars.brand });
+	 * ```
+	 */
+	returning(): CockroachDeleteReturningAll<this, TDynamic>;
+	returning<TSelectedFields extends SelectedFieldsFlat>(
+		fields: TSelectedFields,
+	): CockroachDeleteReturning<this, TDynamic, TSelectedFields>;
+	returning(
+		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
+	): CockroachDeleteReturning<this, TDynamic, any> | CockroachDeleteReturningAll<this, TDynamic> {
+		this.config.returningFields = fields;
+		this.config.returning = orderSelectedFields<CockroachColumn>(fields);
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildDeleteQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachDeletePrepare<this> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = this.dialect.sqlToQuery(this.getSQL());
+			return this.session.prepareQuery<
+				PreparedQueryConfig & {
+					execute: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+				}
+			>(
+				query,
+				this.config.returning,
+				name ?? (generateName ? preparedStatementName(query.sql, query.params) : name),
+			);
+		});
+	}
+
+	prepare(name: string): CockroachDeletePrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+
+	/** @internal */
+	getSelectedFields(): this['_']['selectedFields'] {
+		return (
+			this.config.returningFields
+				? new Proxy(
+					this.config.returningFields,
+					new SelectionProxyHandler({
+						alias: getTableName(this.config.table),
+						sqlAliasedBehavior: 'alias',
+						sqlBehavior: 'error',
+					}),
+				)
+				: undefined
+		) as this['_']['selectedFields'];
+	}
+
+	/** @internal */
+	withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
+	$dynamic(): CockroachDeleteDynamic<this> {
+		return this as any;
+	}
+}
diff --git a/drizzle-orm/src/gel-core/query-builders/index.ts b/drizzle-orm/src/cockroach-core/query-builders/index.ts
similarity index 100%
rename from drizzle-orm/src/gel-core/query-builders/index.ts
rename to drizzle-orm/src/cockroach-core/query-builders/index.ts
diff --git a/drizzle-orm/src/cockroach-core/query-builders/insert.ts b/drizzle-orm/src/cockroach-core/query-builders/insert.ts
new file mode 100644
index 0000000000..8a4357adbb
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/insert.ts
@@ -0,0 +1,486 @@
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import type { IndexColumn } from '~/cockroach-core/indexes.ts';
+import type {
+	CockroachPreparedQuery,
+	CockroachQueryResultHKT,
+	CockroachQueryResultKind,
+	CockroachSession,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import type { CockroachTable, TableConfig } from '~/cockroach-core/table.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { SelectResultFields } from '~/query-builders/select.types.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Param, SQL, sql } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import type { InferInsertModel } from '~/table.ts';
+import { getTableName, Table } from '~/table.ts';
+import { tracer } from '~/tracing.ts';
+import { type DrizzleTypeError, mapUpdateSet, type NeonAuthToken, orderSelectedFields } from '~/utils.ts';
+import type { AnyCockroachColumn, CockroachColumn } from '../columns/common.ts';
+import { QueryBuilder } from './query-builder.ts';
+import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
+import type { CockroachUpdateSetSource } from './update.ts';
+
+export interface CockroachInsertConfig<TTable extends CockroachTable = CockroachTable> {
+	table: TTable;
+	values: Record<string, Param | SQL>[] | TypedQueryBuilder<CockroachInsertSelection<TTable>> | SQL;
+	withList?: Subquery[];
+	onConflict?: SQL;
+	returningFields?: SelectedFieldsFlat;
+	returning?: SelectedFieldsOrdered;
+	select?: boolean;
+}
+
+export type CockroachInsertValue<
+	TTable extends CockroachTable<TableConfig>,
+	OverrideT extends boolean = false,
+	TModel extends Record<string, any> = InferInsertModel<TTable, { dbColumnNames: false; override: OverrideT }>,
+> =
+	& {
+		[Key in keyof TModel]:
+			| TModel[Key]
+			| SQL
+			| Placeholder;
+	}
+	& {};
+
+export type CockroachInsertSelection<
+	TTable extends CockroachTable<TableConfig>,
+	TModel extends Record<string, unknown> = InferInsertModel<TTable>,
+> =
+	& {
+		[K in keyof TModel]:
+			| AnyCockroachColumn
+			| SQL
+			| SQL.Aliased
+			| TModel[K];
+	}
+	& {};
+
+export type NoUnknownKeysInInsertSelection<
+	TTable extends CockroachTable<TableConfig>,
+	TSelection extends CockroachInsertSelection<any>,
+> = {
+	[K in keyof TSelection]: K extends keyof InferInsertModel<TTable> ? TSelection[K]
+		: K extends keyof InferInsertModel<TTable, { override: true }> ? DrizzleTypeError<
+				`Column "${
+					& K
+					& string}" in table "${TTable['_'][
+					'name'
+				]}" is a generated column - manual value insertion restricted`
+			>
+		: DrizzleTypeError<`Column "${K & string}" does not exist in table "${TTable['_']['name']}"`>;
+};
+
+export class CockroachInsertBuilder<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	OverrideT extends boolean = false,
+> {
+	static readonly [entityKind]: string = 'CockroachInsertBuilder';
+
+	constructor(
+		private table: TTable,
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+		private withList?: Subquery[],
+	) {}
+
+	values(value: CockroachInsertValue<TTable, OverrideT>): CockroachInsertBase<TTable, TQueryResult>;
+	values(values: CockroachInsertValue<TTable, OverrideT>[]): CockroachInsertBase<TTable, TQueryResult>;
+	values(
+		values: CockroachInsertValue<TTable, OverrideT> | CockroachInsertValue<TTable, OverrideT>[],
+	): CockroachInsertBase<TTable, TQueryResult> {
+		values = Array.isArray(values) ? values : [values];
+		if (values.length === 0) {
+			throw new Error('values() must be called with at least one value');
+		}
+		const mappedValues = values.map((entry) => {
+			const result: Record<string, Param | SQL> = {};
+			const cols = this.table[Table.Symbol.Columns];
+			for (const colKey of Object.keys(entry)) {
+				const colValue = entry[colKey as keyof typeof entry];
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
+			}
+			return result;
+		});
+
+		return new CockroachInsertBase(
+			this.table,
+			mappedValues,
+			this.session,
+			this.dialect,
+			this.withList,
+			false,
+		) as any;
+	}
+
+	select<TSelection extends CockroachInsertSelection<TTable>>(
+		selectQuery: (qb: QueryBuilder) => TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): CockroachInsertBase<TTable, TQueryResult>;
+	select(selectQuery: (qb: QueryBuilder) => SQL): CockroachInsertBase<TTable, TQueryResult>;
+	select(selectQuery: SQL): CockroachInsertBase<TTable, TQueryResult>;
+	select<TSelection extends CockroachInsertSelection<TTable>>(
+		selectQuery: TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): CockroachInsertBase<TTable, TQueryResult>;
+	select(
+		selectQuery:
+			| SQL
+			| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, CockroachInsertSelection<TTable>>>
+			| ((qb: QueryBuilder) =>
+				| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, CockroachInsertSelection<TTable>>>
+				| SQL),
+	): CockroachInsertBase<TTable, TQueryResult> {
+		const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
+
+		if (!is(select, SQL)) {
+			const insertCols = Object.keys(this.table[Table.Symbol.Columns]);
+			const selected = Object.keys(select._.selectedFields);
+
+			for (const col of selected) {
+				if (!insertCols.includes(col)) {
+					throw new Error(
+						`Insert select error: column "${col}" does not exist in table "${this.table[Table.Symbol.Name]}"`,
+					);
+				}
+			}
+		}
+
+		return new CockroachInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+	}
+}
+
+export type CockroachInsertWithout<
+	T extends AnyCockroachInsert,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		CockroachInsertBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['selectedFields'],
+			T['_']['returning'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type CockroachInsertReturning<
+	T extends AnyCockroachInsert,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = CockroachInsertBase<
+	T['_']['table'],
+	T['_']['queryResult'],
+	TSelectedFields,
+	SelectResultFields<TSelectedFields>,
+	TDynamic,
+	T['_']['excludedMethods']
+>;
+
+export type CockroachInsertReturningAll<T extends AnyCockroachInsert, TDynamic extends boolean> = CockroachInsertBase<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['table']['_']['columns'],
+	T['_']['table']['$inferSelect'],
+	TDynamic,
+	T['_']['excludedMethods']
+>;
+
+export interface CockroachInsertOnConflictDoUpdateConfig<T extends AnyCockroachInsert> {
+	target: IndexColumn | IndexColumn[];
+	/** @deprecated use either `targetWhere` or `setWhere` */
+	where?: SQL;
+	// TODO: add tests for targetWhere and setWhere
+	targetWhere?: SQL;
+	setWhere?: SQL;
+	set: CockroachUpdateSetSource<T['_']['table']>;
+}
+
+export type CockroachInsertPrepare<T extends AnyCockroachInsert> = CockroachPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? CockroachQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type CockroachInsertDynamic<T extends AnyCockroachInsert> = CockroachInsert<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['returning']
+>;
+
+export type AnyCockroachInsert = CockroachInsertBase<any, any, any, any, any, any>;
+
+export type CockroachInsert<
+	TTable extends CockroachTable = CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = ColumnsSelection | undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = CockroachInsertBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+
+export interface CockroachInsertBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>,
+	RunnableQuery<
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+		'cockroach'
+	>,
+	SQLWrapper
+{
+	readonly _: {
+		readonly dialect: 'cockroach';
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly selectedFields: TSelectedFields;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+	};
+}
+
+export class CockroachInsertBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>
+	implements
+		TypedQueryBuilder<
+			TSelectedFields,
+			TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]
+		>,
+		RunnableQuery<
+			TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+			'cockroach'
+		>,
+		SQLWrapper
+{
+	static override readonly [entityKind]: string = 'CockroachInsert';
+
+	private config: CockroachInsertConfig<TTable>;
+
+	constructor(
+		table: TTable,
+		values: CockroachInsertConfig['values'],
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+		withList?: Subquery[],
+		select?: boolean,
+	) {
+		super();
+		this.config = { table, values: values as any, withList, select };
+	}
+
+	/**
+	 * Adds a `returning` clause to the query.
+	 *
+	 * Calling this method will return the specified fields of the inserted rows. If no fields are specified, all fields will be returned.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert#insert-returning}
+	 *
+	 * @example
+	 * ```ts
+	 * // Insert one row and return all fields
+	 * const insertedCar: Car[] = await db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 *
+	 * // Insert one row and return only the id
+	 * const insertedCarId: { id: number }[] = await db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning({ id: cars.id });
+	 * ```
+	 */
+	returning(): CockroachInsertWithout<CockroachInsertReturningAll<this, TDynamic>, TDynamic, 'returning'>;
+	returning<TSelectedFields extends SelectedFieldsFlat>(
+		fields: TSelectedFields,
+	): CockroachInsertWithout<CockroachInsertReturning<this, TDynamic, TSelectedFields>, TDynamic, 'returning'>;
+	returning(
+		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
+	): CockroachInsertWithout<AnyCockroachInsert, TDynamic, 'returning'> {
+		this.config.returningFields = fields;
+		this.config.returning = orderSelectedFields<CockroachColumn>(fields);
+		return this as any;
+	}
+
+	/**
+	 * Adds an `on conflict do nothing` clause to the query.
+	 *
+	 * Calling this method simply avoids inserting a row as its alternative action.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
+	 *
+	 * @param config The `target` and `where` clauses.
+	 *
+	 * @example
+	 * ```ts
+	 * // Insert one row and cancel the insert if there's a conflict
+	 * await db.insert(cars)
+	 *   .values({ id: 1, brand: 'BMW' })
+	 *   .onConflictDoNothing();
+	 *
+	 * // Explicitly specify conflict target
+	 * await db.insert(cars)
+	 *   .values({ id: 1, brand: 'BMW' })
+	 *   .onConflictDoNothing({ target: cars.id });
+	 * ```
+	 */
+	onConflictDoNothing(
+		config: { target?: IndexColumn | IndexColumn[]; where?: SQL } = {},
+	): CockroachInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
+		if (config.target === undefined) {
+			this.config.onConflict = sql`do nothing`;
+		} else {
+			let targetColumn = '';
+			targetColumn = Array.isArray(config.target)
+				? config.target.map((it) => this.dialect.escapeName(it.name)).join(',')
+				: this.dialect.escapeName(config.target.name);
+
+			const whereSql = config.where ? sql` where ${config.where}` : undefined;
+			this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds an `on conflict do update` clause to the query.
+	 *
+	 * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
+	 *
+	 * @param config The `target`, `set` and `where` clauses.
+	 *
+	 * @example
+	 * ```ts
+	 * // Update the row if there's a conflict
+	 * await db.insert(cars)
+	 *   .values({ id: 1, brand: 'BMW' })
+	 *   .onConflictDoUpdate({
+	 *     target: cars.id,
+	 *     set: { brand: 'Porsche' }
+	 *   });
+	 *
+	 * // Upsert with 'where' clause
+	 * await db.insert(cars)
+	 *   .values({ id: 1, brand: 'BMW' })
+	 *   .onConflictDoUpdate({
+	 *     target: cars.id,
+	 *     set: { brand: 'newBMW' },
+	 *     targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
+	 *   });
+	 * ```
+	 */
+	onConflictDoUpdate(
+		config: CockroachInsertOnConflictDoUpdateConfig<this>,
+	): CockroachInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
+		if (config.where && (config.targetWhere || config.setWhere)) {
+			throw new Error(
+				'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.',
+			);
+		}
+		const whereSql = config.where ? sql` where ${config.where}` : undefined;
+		const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
+		const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
+		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+		let targetColumn = '';
+		targetColumn = Array.isArray(config.target)
+			? config.target.map((it) => this.dialect.escapeName(it.name)).join(',')
+			: this.dialect.escapeName(config.target.name);
+		this.config.onConflict = sql`(${
+			sql.raw(targetColumn)
+		})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildInsertQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachInsertPrepare<this> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = this.dialect.sqlToQuery(this.getSQL());
+			return this.session.prepareQuery<
+				PreparedQueryConfig & {
+					execute: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+				}
+			>(
+				query,
+				this.config.returning,
+				name ?? (generateName ? preparedStatementName(query.sql, query.params) : name),
+			);
+		});
+	}
+
+	prepare(name?: string): CockroachInsertPrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	private authToken?: NeonAuthToken;
+	/** @internal */
+	setToken(token?: NeonAuthToken) {
+		this.authToken = token;
+		return this;
+	}
+
+	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues, this.authToken);
+		});
+	};
+
+	/** @internal */
+	getSelectedFields(): this['_']['selectedFields'] {
+		return (
+			this.config.returningFields
+				? new Proxy(
+					this.config.returningFields,
+					new SelectionProxyHandler({
+						alias: getTableName(this.config.table),
+						sqlAliasedBehavior: 'alias',
+						sqlBehavior: 'error',
+					}),
+				)
+				: undefined
+		) as this['_']['selectedFields'];
+	}
+
+	/** @internal */
+	withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
+	$dynamic(): CockroachInsertDynamic<this> {
+		return this as any;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/query-builder.ts b/drizzle-orm/src/cockroach-core/query-builders/query-builder.ts
new file mode 100644
index 0000000000..12b00d10f8
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/query-builder.ts
@@ -0,0 +1,150 @@
+import type { CockroachDialectConfig } from '~/cockroach-core/dialect.ts';
+import { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { CockroachColumn } from '../columns/index.ts';
+import type { WithBuilder } from '../subquery.ts';
+import { CockroachSelectBuilder } from './select.ts';
+import type { SelectedFields } from './select.types.ts';
+
+export class QueryBuilder {
+	static readonly [entityKind]: string = 'CockroachQueryBuilder';
+
+	private dialect: CockroachDialect | undefined;
+	private dialectConfig: CockroachDialectConfig | undefined;
+
+	constructor(dialect?: CockroachDialect | CockroachDialectConfig) {
+		this.dialect = is(dialect, CockroachDialect) ? dialect : undefined;
+		this.dialectConfig = is(dialect, CockroachDialect) ? undefined : dialect;
+	}
+
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const queryBuilder = this;
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(queryBuilder);
+			}
+
+			return new Proxy(
+				new WithSubquery(
+					qb.getSQL(),
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			) as any;
+		};
+		return { as };
+	};
+
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		function select(): CockroachSelectBuilder<undefined, 'qb'>;
+		function select<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection, 'qb'>;
+		function select<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined, 'qb'> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: undefined,
+				dialect: self.getDialect(),
+				withList: queries,
+			});
+		}
+
+		function selectDistinct(): CockroachSelectBuilder<undefined, 'qb'>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): CockroachSelectBuilder<TSelection, 'qb'>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined, 'qb'> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: undefined,
+				dialect: self.getDialect(),
+				distinct: true,
+			});
+		}
+
+		function selectDistinctOn(on: (CockroachColumn | SQLWrapper)[]): CockroachSelectBuilder<undefined, 'qb'>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (CockroachColumn | SQLWrapper)[],
+			fields: TSelection,
+		): CockroachSelectBuilder<TSelection, 'qb'>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (CockroachColumn | SQLWrapper)[],
+			fields?: TSelection,
+		): CockroachSelectBuilder<TSelection | undefined, 'qb'> {
+			return new CockroachSelectBuilder({
+				fields: fields ?? undefined,
+				session: undefined,
+				dialect: self.getDialect(),
+				distinct: { on },
+			});
+		}
+
+		return { select, selectDistinct, selectDistinctOn };
+	}
+
+	select(): CockroachSelectBuilder<undefined, 'qb'>;
+	select<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection, 'qb'>;
+	select<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): CockroachSelectBuilder<TSelection | undefined, 'qb'> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: undefined,
+			dialect: this.getDialect(),
+		});
+	}
+
+	selectDistinct(): CockroachSelectBuilder<undefined>;
+	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): CockroachSelectBuilder<TSelection>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): CockroachSelectBuilder<TSelection | undefined> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: undefined,
+			dialect: this.getDialect(),
+			distinct: true,
+		});
+	}
+
+	selectDistinctOn(on: (CockroachColumn | SQLWrapper)[]): CockroachSelectBuilder<undefined>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (CockroachColumn | SQLWrapper)[],
+		fields: TSelection,
+	): CockroachSelectBuilder<TSelection>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (CockroachColumn | SQLWrapper)[],
+		fields?: TSelection,
+	): CockroachSelectBuilder<TSelection | undefined> {
+		return new CockroachSelectBuilder({
+			fields: fields ?? undefined,
+			session: undefined,
+			dialect: this.getDialect(),
+			distinct: { on },
+		});
+	}
+
+	// Lazy load dialect to avoid circular dependency
+	private getDialect() {
+		if (!this.dialect) {
+			this.dialect = new CockroachDialect(this.dialectConfig);
+		}
+
+		return this.dialect;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/query.ts b/drizzle-orm/src/cockroach-core/query-builders/query.ts
new file mode 100644
index 0000000000..36ceef707a
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/query.ts
@@ -0,0 +1,150 @@
+import {
+	type BuildQueryResult,
+	type BuildRelationalQueryResult,
+	type DBQueryConfig,
+	mapRelationalRow,
+	type TableRelationalConfig,
+	type TablesRelationalConfig,
+} from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
+import type { CockroachDialect } from '../dialect.ts';
+import type { CockroachPreparedQuery, CockroachSession, PreparedQueryConfig } from '../session.ts';
+import type { CockroachTable } from '../table.ts';
+
+export class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+	static readonly [entityKind]: string = 'CockroachRelationalQueryBuilder';
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: TSchema,
+		private tableNamesMap: Record<string, string>,
+		private table: CockroachTable,
+		private tableConfig: TableRelationalConfig,
+		private dialect: CockroachDialect,
+		private session: CockroachSession,
+	) {}
+
+	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
+	): CockroachRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new CockroachRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? (config as DBQueryConfig<'many', true>) : {},
+			'many',
+		);
+	}
+
+	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
+		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
+	): CockroachRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
+		return new CockroachRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			'first',
+		);
+	}
+}
+
+export class CockroachRelationalQuery<TResult> extends QueryPromise<TResult>
+	implements RunnableQuery<TResult, 'pg'>, SQLWrapper
+{
+	static override readonly [entityKind]: string = 'CockroachRelationalQuery';
+
+	declare readonly _: {
+		readonly dialect: 'pg';
+		readonly result: TResult;
+	};
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: TablesRelationalConfig,
+		private tableNamesMap: Record<string, string>,
+		private table: CockroachTable,
+		private tableConfig: TableRelationalConfig,
+		private dialect: CockroachDialect,
+		private session: CockroachSession,
+		private config: DBQueryConfig<'many', true> | true,
+		private mode: 'many' | 'first',
+	) {
+		super();
+	}
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const { query, builtQuery } = this._toSQL();
+
+			return this.session.prepareQuery<PreparedQueryConfig & { execute: TResult }>(
+				builtQuery,
+				undefined,
+				name ?? (generateName ? preparedStatementName(builtQuery.sql, builtQuery.params) : name),
+				(rawRows, mapColumnValue) => {
+					const rows = rawRows.map((row) =>
+						mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
+					);
+					if (this.mode === 'first') {
+						return rows[0] as TResult;
+					}
+					return rows as TResult;
+				},
+			);
+		});
+	}
+
+	prepare(name?: string): CockroachPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
+		return this._prepare(name, true);
+	}
+
+	private _getQuery() {
+		return this.dialect.buildRelationalQueryWithoutPK({
+			fullSchema: this.fullSchema,
+			schema: this.schema,
+			tableNamesMap: this.tableNamesMap,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			tableAlias: this.tableConfig.tsName,
+		});
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this._getQuery().sql as SQL;
+	}
+
+	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
+		const query = this._getQuery();
+
+		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+
+		return { query, builtQuery };
+	}
+
+	toSQL(): Query {
+		return this._toSQL().builtQuery;
+	}
+
+	override execute(): Promise<TResult> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(undefined);
+		});
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/raw.ts b/drizzle-orm/src/cockroach-core/query-builders/raw.ts
new file mode 100644
index 0000000000..198cb9e6de
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/raw.ts
@@ -0,0 +1,44 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { PreparedQuery } from '~/session.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+
+export interface CockroachRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'cockroach'>, SQLWrapper {}
+
+export class CockroachRaw<TResult> extends QueryPromise<TResult>
+	implements RunnableQuery<TResult, 'cockroach'>, SQLWrapper, PreparedQuery
+{
+	static override readonly [entityKind]: string = 'CockroachRaw';
+
+	declare readonly _: {
+		readonly dialect: 'cockroach';
+		readonly result: TResult;
+	};
+
+	constructor(
+		public execute: () => Promise<TResult>,
+		private sql: SQL,
+		private query: Query,
+		private mapBatchResult: (result: unknown) => unknown,
+	) {
+		super();
+	}
+
+	/** @internal */
+	getSQL() {
+		return this.sql;
+	}
+
+	getQuery() {
+		return this.query;
+	}
+
+	mapResult(result: unknown, isFromBatch?: boolean) {
+		return isFromBatch ? this.mapBatchResult(result) : result;
+	}
+
+	_prepare(): PreparedQuery {
+		return this;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/refresh-materialized-view.ts b/drizzle-orm/src/cockroach-core/query-builders/refresh-materialized-view.ts
new file mode 100644
index 0000000000..15fde2dde8
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/refresh-materialized-view.ts
@@ -0,0 +1,105 @@
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import type {
+	CockroachPreparedQuery,
+	CockroachQueryResultHKT,
+	CockroachQueryResultKind,
+	CockroachSession,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import type { CockroachMaterializedView } from '~/cockroach-core/view.ts';
+import { entityKind } from '~/entity.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface CockroachRefreshMaterializedView<TQueryResult extends CockroachQueryResultHKT>
+	extends
+		QueryPromise<CockroachQueryResultKind<TQueryResult, never>>,
+		RunnableQuery<CockroachQueryResultKind<TQueryResult, never>, 'cockroach'>,
+		SQLWrapper
+{
+	readonly _: {
+		readonly dialect: 'cockroach';
+		readonly result: CockroachQueryResultKind<TQueryResult, never>;
+	};
+}
+
+export class CockroachRefreshMaterializedView<TQueryResult extends CockroachQueryResultHKT>
+	extends QueryPromise<CockroachQueryResultKind<TQueryResult, never>>
+	implements RunnableQuery<CockroachQueryResultKind<TQueryResult, never>, 'cockroach'>, SQLWrapper
+{
+	static override readonly [entityKind]: string = 'CockroachRefreshMaterializedView';
+
+	private config: {
+		view: CockroachMaterializedView;
+		concurrently?: boolean;
+		withNoData?: boolean;
+	};
+
+	constructor(
+		view: CockroachMaterializedView,
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+	) {
+		super();
+		this.config = { view };
+	}
+
+	concurrently(): this {
+		if (this.config.withNoData !== undefined) {
+			throw new Error('Cannot use concurrently and withNoData together');
+		}
+		this.config.concurrently = true;
+		return this;
+	}
+
+	withNoData(): this {
+		if (this.config.concurrently !== undefined) {
+			throw new Error('Cannot use concurrently and withNoData together');
+		}
+		this.config.withNoData = true;
+		return this;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildRefreshMaterializedViewQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachPreparedQuery<
+		PreparedQueryConfig & {
+			execute: CockroachQueryResultKind<TQueryResult, never>;
+		}
+	> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = this.dialect.sqlToQuery(this.getSQL());
+			return this.session.prepareQuery(
+				query,
+				undefined,
+				name ?? (generateName ? preparedStatementName(query.sql, query.params) : name),
+			);
+		});
+	}
+
+	prepare(name?: string): CockroachPreparedQuery<
+		PreparedQueryConfig & {
+			execute: CockroachQueryResultKind<TQueryResult, never>;
+		}
+	> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
diff --git a/drizzle-orm/src/cockroach-core/query-builders/select.ts b/drizzle-orm/src/cockroach-core/query-builders/select.ts
new file mode 100644
index 0000000000..1047aa2a7e
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/select.ts
@@ -0,0 +1,1309 @@
+import type { CockroachColumn } from '~/cockroach-core/columns/index.ts';
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import type { CockroachSession, PreparedQueryConfig } from '~/cockroach-core/session.ts';
+import type { SubqueryWithSelection } from '~/cockroach-core/subquery.ts';
+import type { CockroachTable } from '~/cockroach-core/table.ts';
+import { CockroachViewBase } from '~/cockroach-core/view-base.ts';
+import { entityKind, is } from '~/entity.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	BuildSubquerySelection,
+	GetSelectTableName,
+	GetSelectTableSelection,
+	JoinNullability,
+	JoinType,
+	SelectMode,
+	SelectResult,
+	SetOperator,
+} from '~/query-builders/select.types.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { SQL, View } from '~/sql/sql.ts';
+import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Subquery } from '~/subquery.ts';
+import { Table } from '~/table.ts';
+import { tracer } from '~/tracing.ts';
+import {
+	applyMixins,
+	type DrizzleTypeError,
+	getTableColumns,
+	getTableLikeName,
+	haveSameKeys,
+	orderSelectedFields,
+	type ValueOrArray,
+} from '~/utils.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import type {
+	AnyCockroachSelect,
+	CockroachCreateSetOperatorFn,
+	CockroachSelectConfig,
+	CockroachSelectCrossJoinFn,
+	CockroachSelectDynamic,
+	CockroachSelectHKT,
+	CockroachSelectHKTBase,
+	CockroachSelectJoinFn,
+	CockroachSelectPrepare,
+	CockroachSelectWithout,
+	CockroachSetOperatorExcludedMethods,
+	CockroachSetOperatorWithResult,
+	CreateCockroachSelectFromBuilderMode,
+	GetCockroachSetOperators,
+	LockConfig,
+	LockStrength,
+	SelectedFields,
+	SetOperatorRightSelect,
+	TableLikeHasEmptySelection,
+} from './select.types.ts';
+
+export class CockroachSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TBuilderMode extends 'db' | 'qb' = 'db',
+> {
+	static readonly [entityKind]: string = 'CockroachSelectBuilder';
+
+	private fields: TSelection;
+	private session: CockroachSession | undefined;
+	private dialect: CockroachDialect;
+	private withList: Subquery[] = [];
+	private distinct: boolean | {
+		on: (CockroachColumn | SQLWrapper)[];
+	} | undefined;
+
+	constructor(
+		config: {
+			fields: TSelection;
+			session: CockroachSession | undefined;
+			dialect: CockroachDialect;
+			withList?: Subquery[];
+			distinct?: boolean | {
+				on: (CockroachColumn | SQLWrapper)[];
+			};
+		},
+	) {
+		this.fields = config.fields;
+		this.session = config.session;
+		this.dialect = config.dialect;
+		if (config.withList) {
+			this.withList = config.withList;
+		}
+		this.distinct = config.distinct;
+	}
+
+	/**
+	 * Specify the table, subquery, or other target that you're
+	 * building a select query against.
+	 *
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
+	 */
+	from<TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL>(
+		source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<
+				"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+			>
+			: TFrom,
+	): CreateCockroachSelectFromBuilderMode<
+		TBuilderMode,
+		GetSelectTableName<TFrom>,
+		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
+		TSelection extends undefined ? 'single' : 'partial'
+	> {
+		const isPartialSelect = !!this.fields;
+		const src = source as TFrom;
+
+		let fields: SelectedFields;
+		if (this.fields) {
+			fields = this.fields;
+		} else if (is(src, Subquery)) {
+			// This is required to use the proxy handler to get the correct field values from the subquery
+			fields = Object.fromEntries(
+				Object.keys(src._.selectedFields).map((
+					key,
+				) => [key, src[key as unknown as keyof typeof src] as unknown as SelectedFields[string]]),
+			);
+		} else if (is(src, CockroachViewBase)) {
+			fields = src[ViewBaseConfig].selectedFields as SelectedFields;
+		} else if (is(src, SQL)) {
+			fields = {};
+		} else {
+			fields = getTableColumns<CockroachTable>(src);
+		}
+
+		return (new CockroachSelectBase({
+			table: src,
+			fields,
+			isPartialSelect,
+			session: this.session,
+			dialect: this.dialect,
+			withList: this.withList,
+			distinct: this.distinct,
+		}));
+	}
+}
+
+export abstract class CockroachSelectQueryBuilderBase<
+	THKT extends CockroachSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
+	static override readonly [entityKind]: string = 'CockroachSelectQueryBuilder';
+
+	override readonly _: {
+		readonly dialect: 'cockroach';
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
+	protected config: CockroachSelectConfig;
+	protected joinsNotNullableMap: Record<string, boolean>;
+	private tableName: string | undefined;
+	private isPartialSelect: boolean;
+	protected session: CockroachSession | undefined;
+	protected dialect: CockroachDialect;
+
+	constructor(
+		{ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+			table: CockroachSelectConfig['table'];
+			fields: CockroachSelectConfig['fields'];
+			isPartialSelect: boolean;
+			session: CockroachSession | undefined;
+			dialect: CockroachDialect;
+			withList: Subquery[];
+			distinct: boolean | {
+				on: (CockroachColumn | SQLWrapper)[];
+			} | undefined;
+		},
+	) {
+		super();
+		this.config = {
+			withList,
+			table,
+			fields: { ...fields },
+			distinct,
+			setOperators: [],
+		};
+		this.isPartialSelect = isPartialSelect;
+		this.session = session;
+		this.dialect = dialect;
+		this._ = {
+			selectedFields: fields as TSelectedFields,
+		} as this['_'];
+		this.tableName = getTableLikeName(table);
+		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
+	}
+
+	private createJoin<
+		TJoinType extends JoinType,
+		TIsLateral extends (TJoinType extends 'full' | 'right' ? false : boolean),
+	>(
+		joinType: TJoinType,
+		lateral: TIsLateral,
+	): 'cross' extends TJoinType ? CockroachSelectCrossJoinFn<this, TDynamic, TIsLateral>
+		: CockroachSelectJoinFn<this, TDynamic, TJoinType, TIsLateral>
+	{
+		return ((
+			table: TIsLateral extends true ? Subquery | SQL : CockroachTable | Subquery | CockroachViewBase | SQL,
+			on?: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
+		) => {
+			const baseTableName = this.tableName;
+			const tableName = getTableLikeName(table);
+
+			if (typeof tableName === 'string' && this.config.joins?.some((join) => join.alias === tableName)) {
+				throw new Error(`Alias "${tableName}" is already used in this query`);
+			}
+
+			if (!this.isPartialSelect) {
+				// If this is the first join and this is not a partial select and we're not selecting from raw SQL, "move" the fields from the main table to the nested object
+				if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === 'string') {
+					this.config.fields = {
+						[baseTableName]: this.config.fields,
+					};
+				}
+				if (typeof tableName === 'string' && !is(table, SQL)) {
+					const selection = is(table, Subquery)
+						? table._.selectedFields
+						: is(table, View)
+						? table[ViewBaseConfig].selectedFields
+						: table[Table.Symbol.Columns];
+					this.config.fields[tableName] = selection;
+				}
+			}
+
+			if (typeof on === 'function') {
+				on = on(
+					new Proxy(
+						this.config.fields,
+						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+					) as TSelection,
+				);
+			}
+
+			if (!this.config.joins) {
+				this.config.joins = [];
+			}
+
+			this.config.joins.push({ on, table, joinType, alias: tableName, lateral });
+
+			if (typeof tableName === 'string') {
+				switch (joinType) {
+					case 'left': {
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+					case 'right': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'cross':
+					case 'inner': {
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'full': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+				}
+			}
+
+			return this as any;
+		}) as any;
+	}
+
+	/**
+	 * Executes a `left join` operation by adding another table to the current query.
+	 *
+	 * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
+	 *   .from(users)
+	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	leftJoin = this.createJoin('left', false);
+
+	/**
+	 * Executes a `left join lateral` operation by adding subquery to the current query.
+	 *
+	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+	 *
+	 * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}
+	 *
+	 * @param table the subquery to join.
+	 * @param on the `on` clause.
+	 */
+	leftJoinLateral = this.createJoin('left', true);
+
+	/**
+	 * Executes a `right join` operation by adding another table to the current query.
+	 *
+	 * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
+	 *   .from(users)
+	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	rightJoin = this.createJoin('right', false);
+
+	/**
+	 * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
+	 *
+	 * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+	 *   .from(users)
+	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	innerJoin = this.createJoin('inner', false);
+
+	/**
+	 * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
+	 *
+	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+	 *
+	 * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}
+	 *
+	 * @param table the subquery to join.
+	 * @param on the `on` clause.
+	 */
+	innerJoinLateral = this.createJoin('inner', true);
+
+	/**
+	 * Executes a `full join` operation by combining rows from two tables into a new table.
+	 *
+	 * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
+	 *   .from(users)
+	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	fullJoin = this.createJoin('full', false);
+
+	/**
+	 * Executes a `cross join` operation by combining rows from two tables into a new table.
+	 *
+	 * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
+	 *
+	 * @param table the table to join.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users, each user with every pet
+	 * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+	 *   .from(users)
+	 *   .crossJoin(pets)
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .crossJoin(pets)
+	 * ```
+	 */
+	crossJoin = this.createJoin('cross', false);
+
+	/**
+	 * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
+	 *
+	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+	 *
+	 * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
+	 *
+	 * @param table the query to join.
+	 */
+	crossJoinLateral = this.createJoin('cross', true);
+
+	private createSetOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends CockroachSetOperatorWithResult<TResult>>(
+		rightSelection:
+			| ((setOperators: GetCockroachSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => CockroachSelectWithout<
+		this,
+		TDynamic,
+		CockroachSetOperatorExcludedMethods,
+		true
+	> {
+		return (rightSelection) => {
+			const rightSelect = (typeof rightSelection === 'function'
+				? rightSelection(getCockroachSetOperators())
+				: rightSelection) as TypedQueryBuilder<
+					any,
+					TResult
+				>;
+
+			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+
+			this.config.setOperators.push({ type, isAll, rightSelect });
+			return this as any;
+		};
+	}
+
+	/**
+	 * Adds `union` set operator to the query.
+	 *
+	 * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all unique names from customers and users tables
+	 * await db.select({ name: users.name })
+	 *   .from(users)
+	 *   .union(
+	 *     db.select({ name: customers.name }).from(customers)
+	 *   );
+	 * // or
+	 * import { union } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await union(
+	 *   db.select({ name: users.name }).from(users),
+	 *   db.select({ name: customers.name }).from(customers)
+	 * );
+	 * ```
+	 */
+	union = this.createSetOperator('union', false);
+
+	/**
+	 * Adds `union all` set operator to the query.
+	 *
+	 * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all transaction ids from both online and in-store sales
+	 * await db.select({ transaction: onlineSales.transactionId })
+	 *   .from(onlineSales)
+	 *   .unionAll(
+	 *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+	 *   );
+	 * // or
+	 * import { unionAll } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await unionAll(
+	 *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+	 *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+	 * );
+	 * ```
+	 */
+	unionAll = this.createSetOperator('union', true);
+
+	/**
+	 * Adds `intersect` set operator to the query.
+	 *
+	 * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select course names that are offered in both departments A and B
+	 * await db.select({ courseName: depA.courseName })
+	 *   .from(depA)
+	 *   .intersect(
+	 *     db.select({ courseName: depB.courseName }).from(depB)
+	 *   );
+	 * // or
+	 * import { intersect } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await intersect(
+	 *   db.select({ courseName: depA.courseName }).from(depA),
+	 *   db.select({ courseName: depB.courseName }).from(depB)
+	 * );
+	 * ```
+	 */
+	intersect = this.createSetOperator('intersect', false);
+
+	/**
+	 * Adds `intersect all` set operator to the query.
+	 *
+	 * Calling this method will retain only the rows that are present in both result sets including all duplicates.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all products and quantities that are ordered by both regular and VIP customers
+	 * await db.select({
+	 *   productId: regularCustomerOrders.productId,
+	 *   quantityOrdered: regularCustomerOrders.quantityOrdered
+	 * })
+	 * .from(regularCustomerOrders)
+	 * .intersectAll(
+	 *   db.select({
+	 *     productId: vipCustomerOrders.productId,
+	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
+	 *   })
+	 *   .from(vipCustomerOrders)
+	 * );
+	 * // or
+	 * import { intersectAll } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await intersectAll(
+	 *   db.select({
+	 *     productId: regularCustomerOrders.productId,
+	 *     quantityOrdered: regularCustomerOrders.quantityOrdered
+	 *   })
+	 *   .from(regularCustomerOrders),
+	 *   db.select({
+	 *     productId: vipCustomerOrders.productId,
+	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
+	 *   })
+	 *   .from(vipCustomerOrders)
+	 * );
+	 * ```
+	 */
+	intersectAll = this.createSetOperator('intersect', true);
+
+	/**
+	 * Adds `except` set operator to the query.
+	 *
+	 * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all courses offered in department A but not in department B
+	 * await db.select({ courseName: depA.courseName })
+	 *   .from(depA)
+	 *   .except(
+	 *     db.select({ courseName: depB.courseName }).from(depB)
+	 *   );
+	 * // or
+	 * import { except } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await except(
+	 *   db.select({ courseName: depA.courseName }).from(depA),
+	 *   db.select({ courseName: depB.courseName }).from(depB)
+	 * );
+	 * ```
+	 */
+	except = this.createSetOperator('except', false);
+
+	/**
+	 * Adds `except all` set operator to the query.
+	 *
+	 * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all products that are ordered by regular customers but not by VIP customers
+	 * await db.select({
+	 *   productId: regularCustomerOrders.productId,
+	 *   quantityOrdered: regularCustomerOrders.quantityOrdered,
+	 * })
+	 * .from(regularCustomerOrders)
+	 * .exceptAll(
+	 *   db.select({
+	 *     productId: vipCustomerOrders.productId,
+	 *     quantityOrdered: vipCustomerOrders.quantityOrdered,
+	 *   })
+	 *   .from(vipCustomerOrders)
+	 * );
+	 * // or
+	 * import { exceptAll } from 'drizzle-orm/cockroach-core'
+	 *
+	 * await exceptAll(
+	 *   db.select({
+	 *     productId: regularCustomerOrders.productId,
+	 *     quantityOrdered: regularCustomerOrders.quantityOrdered
+	 *   })
+	 *   .from(regularCustomerOrders),
+	 *   db.select({
+	 *     productId: vipCustomerOrders.productId,
+	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
+	 *   })
+	 *   .from(vipCustomerOrders)
+	 * );
+	 * ```
+	 */
+	exceptAll = this.createSetOperator('except', true);
+
+	/** @internal */
+	addSetOperators(setOperators: CockroachSelectConfig['setOperators']): CockroachSelectWithout<
+		this,
+		TDynamic,
+		CockroachSetOperatorExcludedMethods,
+		true
+	> {
+		this.config.setOperators.push(...setOperators);
+		return this as any;
+	}
+
+	/**
+	 * Adds a `where` clause to the query.
+	 *
+	 * Calling this method will select only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
+	 *
+	 * @param where the `where` clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be selected.
+	 *
+	 * ```ts
+	 * // Select all cars with green color
+	 * await db.select().from(cars).where(eq(cars.color, 'green'));
+	 * // or
+	 * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Select all BMW cars with a green color
+	 * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Select all cars with the green or blue color
+	 * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(
+		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): CockroachSelectWithout<this, TDynamic, 'where'> {
+		if (typeof where === 'function') {
+			where = where(
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+		}
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `having` clause to the query.
+	 *
+	 * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+	 *
+	 * @param having the `having` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all brands with more than one car
+	 * await db.select({
+	 * 	brand: cars.brand,
+	 * 	count: sql<number>`cast(count(${cars.id}) as int)`,
+	 * })
+	 *   .from(cars)
+	 *   .groupBy(cars.brand)
+	 *   .having(({ count }) => gt(count, 1));
+	 * ```
+	 */
+	having(
+		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): CockroachSelectWithout<this, TDynamic, 'having'> {
+		if (typeof having === 'function') {
+			having = having(
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+		}
+		this.config.having = having;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `group by` clause to the query.
+	 *
+	 * Calling this method will group rows that have the same values into summary rows, often used for aggregation purposes.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Group and count people by their last names
+	 * await db.select({
+	 *    lastName: people.lastName,
+	 *    count: sql<number>`cast(count(*) as int)`
+	 * })
+	 *   .from(people)
+	 *   .groupBy(people.lastName);
+	 * ```
+	 */
+	groupBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<CockroachColumn | SQL | SQL.Aliased>,
+	): CockroachSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (CockroachColumn | SQL | SQL.Aliased)[]): CockroachSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(
+		...columns:
+			| [(aliases: this['_']['selection']) => ValueOrArray<CockroachColumn | SQL | SQL.Aliased>]
+			| (CockroachColumn | SQL | SQL.Aliased)[]
+	): CockroachSelectWithout<this, TDynamic, 'groupBy'> {
+		if (typeof columns[0] === 'function') {
+			const groupBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+			this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
+		} else {
+			this.config.groupBy = columns as (CockroachColumn | SQL | SQL.Aliased)[];
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds an `order by` clause to the query.
+	 *
+	 * Calling this method will sort the result-set in ascending or descending order. By default, the sort order is ascending.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#order-by}
+	 *
+	 * @example
+	 *
+	 * ```
+	 * // Select cars ordered by year
+	 * await db.select().from(cars).orderBy(cars.year);
+	 * ```
+	 *
+	 * You can specify whether results are in ascending or descending order with the `asc()` and `desc()` operators.
+	 *
+	 * ```ts
+	 * // Select cars ordered by year in descending order
+	 * await db.select().from(cars).orderBy(desc(cars.year));
+	 *
+	 * // Select cars ordered by year and price
+	 * await db.select().from(cars).orderBy(asc(cars.year), desc(cars.price));
+	 * ```
+	 */
+	orderBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<CockroachColumn | SQL | SQL.Aliased>,
+	): CockroachSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (CockroachColumn | SQL | SQL.Aliased)[]): CockroachSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(
+		...columns:
+			| [(aliases: this['_']['selection']) => ValueOrArray<CockroachColumn | SQL | SQL.Aliased>]
+			| (CockroachColumn | SQL | SQL.Aliased)[]
+	): CockroachSelectWithout<this, TDynamic, 'orderBy'> {
+		if (typeof columns[0] === 'function') {
+			const orderBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
+		} else {
+			const orderByArray = columns as (CockroachColumn | SQL | SQL.Aliased)[];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds a `limit` clause to the query.
+	 *
+	 * Calling this method will set the maximum number of rows that will be returned by this query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+	 *
+	 * @param limit the `limit` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Get the first 10 people from this query.
+	 * await db.select().from(people).limit(10);
+	 * ```
+	 */
+	limit(limit: number | Placeholder): CockroachSelectWithout<this, TDynamic, 'limit'> {
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.limit = limit;
+		} else {
+			this.config.limit = limit;
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds an `offset` clause to the query.
+	 *
+	 * Calling this method will skip a number of rows when returning results from this query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
+	 *
+	 * @param offset the `offset` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Get the 10th-20th people from this query.
+	 * await db.select().from(people).offset(10).limit(10);
+	 * ```
+	 */
+	offset(offset: number | Placeholder): CockroachSelectWithout<this, TDynamic, 'offset'> {
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.offset = offset;
+		} else {
+			this.config.offset = offset;
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds a `for` clause to the query.
+	 *
+	 * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
+	 *
+	 * See docs: {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE}
+	 *
+	 * @param strength the lock strength.
+	 * @param config the lock configuration.
+	 */
+	for(strength: LockStrength, config: LockConfig = {}): CockroachSelectWithout<this, TDynamic, 'for'> {
+		this.config.lockingClause = { strength, config };
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<CockroachColumn>(this.config.fields);
+		return this.dialect.buildSelectQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	as<TAlias extends string>(
+		alias: TAlias,
+	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
+		return new Proxy(
+			new Subquery(this.getSQL(), this.config.fields, alias),
+			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
+	}
+
+	/** @internal */
+	override getSelectedFields(): this['_']['selectedFields'] {
+		return new Proxy(
+			this.config.fields,
+			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as this['_']['selectedFields'];
+	}
+
+	/** @internal */
+	override withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
+	$dynamic(): CockroachSelectDynamic<this> {
+		return this;
+	}
+}
+
+export interface CockroachSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	CockroachSelectQueryBuilderBase<
+		CockroachSelectHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	QueryPromise<TResult>,
+	SQLWrapper
+{}
+
+export class CockroachSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends CockroachSelectQueryBuilderBase<
+	CockroachSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> implements RunnableQuery<TResult, 'cockroach'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'CockroachSelect';
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachSelectPrepare<this> {
+		const { session, dialect, joinsNotNullableMap } = this;
+		if (!session) {
+			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
+		}
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			// Build query before accessing `fieldsFlat` - build mutates it
+			const query = dialect.sqlToQuery(this.getSQL());
+			const fieldsList = this.config.fieldsFlat!;
+			const preparedQuery = session.prepareQuery<
+				PreparedQueryConfig & { execute: TResult }
+			>(
+				query,
+				fieldsList,
+				name ?? (generateName ? preparedStatementName(query.sql, query.params) : name),
+			);
+			preparedQuery.joinsNotNullableMap = joinsNotNullableMap;
+
+			return preparedQuery;
+		});
+	}
+
+	/**
+	 * Create a prepared statement for this query. This allows
+	 * the database to remember this query for the given session
+	 * and call it by name, rather than specifying the full query.
+	 *
+	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
+	 */
+	prepare(name?: string): CockroachSelectPrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
+
+applyMixins(CockroachSelectBase, [QueryPromise]);
+
+function createSetOperator(type: SetOperator, isAll: boolean): CockroachCreateSetOperatorFn {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		const setOperators = [rightSelect, ...restSelects].map((select) => ({
+			type,
+			isAll,
+			rightSelect: select as AnyCockroachSelect,
+		}));
+
+		for (const setOperator of setOperators) {
+			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+		}
+
+		return (leftSelect as AnyCockroachSelect).addSetOperators(setOperators) as any;
+	};
+}
+
+const getCockroachSetOperators = () => ({
+	union,
+	unionAll,
+	intersect,
+	intersectAll,
+	except,
+	exceptAll,
+});
+
+/**
+ * Adds `union` set operator to the query.
+ *
+ * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all unique names from customers and users tables
+ * import { union } from 'drizzle-orm/cockroach-core'
+ *
+ * await union(
+ *   db.select({ name: users.name }).from(users),
+ *   db.select({ name: customers.name }).from(customers)
+ * );
+ * // or
+ * await db.select({ name: users.name })
+ *   .from(users)
+ *   .union(
+ *     db.select({ name: customers.name }).from(customers)
+ *   );
+ * ```
+ */
+export const union = createSetOperator('union', false);
+
+/**
+ * Adds `union all` set operator to the query.
+ *
+ * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all transaction ids from both online and in-store sales
+ * import { unionAll } from 'drizzle-orm/cockroach-core'
+ *
+ * await unionAll(
+ *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+ *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+ * );
+ * // or
+ * await db.select({ transaction: onlineSales.transactionId })
+ *   .from(onlineSales)
+ *   .unionAll(
+ *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+ *   );
+ * ```
+ */
+export const unionAll = createSetOperator('union', true);
+
+/**
+ * Adds `intersect` set operator to the query.
+ *
+ * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select course names that are offered in both departments A and B
+ * import { intersect } from 'drizzle-orm/cockroach-core'
+ *
+ * await intersect(
+ *   db.select({ courseName: depA.courseName }).from(depA),
+ *   db.select({ courseName: depB.courseName }).from(depB)
+ * );
+ * // or
+ * await db.select({ courseName: depA.courseName })
+ *   .from(depA)
+ *   .intersect(
+ *     db.select({ courseName: depB.courseName }).from(depB)
+ *   );
+ * ```
+ */
+export const intersect = createSetOperator('intersect', false);
+
+/**
+ * Adds `intersect all` set operator to the query.
+ *
+ * Calling this method will retain only the rows that are present in both result sets including all duplicates.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all products and quantities that are ordered by both regular and VIP customers
+ * import { intersectAll } from 'drizzle-orm/cockroach-core'
+ *
+ * await intersectAll(
+ *   db.select({
+ *     productId: regularCustomerOrders.productId,
+ *     quantityOrdered: regularCustomerOrders.quantityOrdered
+ *   })
+ *   .from(regularCustomerOrders),
+ *   db.select({
+ *     productId: vipCustomerOrders.productId,
+ *     quantityOrdered: vipCustomerOrders.quantityOrdered
+ *   })
+ *   .from(vipCustomerOrders)
+ * );
+ * // or
+ * await db.select({
+ *   productId: regularCustomerOrders.productId,
+ *   quantityOrdered: regularCustomerOrders.quantityOrdered
+ * })
+ * .from(regularCustomerOrders)
+ * .intersectAll(
+ *   db.select({
+ *     productId: vipCustomerOrders.productId,
+ *     quantityOrdered: vipCustomerOrders.quantityOrdered
+ *   })
+ *   .from(vipCustomerOrders)
+ * );
+ * ```
+ */
+export const intersectAll = createSetOperator('intersect', true);
+
+/**
+ * Adds `except` set operator to the query.
+ *
+ * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all courses offered in department A but not in department B
+ * import { except } from 'drizzle-orm/cockroach-core'
+ *
+ * await except(
+ *   db.select({ courseName: depA.courseName }).from(depA),
+ *   db.select({ courseName: depB.courseName }).from(depB)
+ * );
+ * // or
+ * await db.select({ courseName: depA.courseName })
+ *   .from(depA)
+ *   .except(
+ *     db.select({ courseName: depB.courseName }).from(depB)
+ *   );
+ * ```
+ */
+export const except = createSetOperator('except', false);
+
+/**
+ * Adds `except all` set operator to the query.
+ *
+ * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all products that are ordered by regular customers but not by VIP customers
+ * import { exceptAll } from 'drizzle-orm/cockroach-core'
+ *
+ * await exceptAll(
+ *   db.select({
+ *     productId: regularCustomerOrders.productId,
+ *     quantityOrdered: regularCustomerOrders.quantityOrdered
+ *   })
+ *   .from(regularCustomerOrders),
+ *   db.select({
+ *     productId: vipCustomerOrders.productId,
+ *     quantityOrdered: vipCustomerOrders.quantityOrdered
+ *   })
+ *   .from(vipCustomerOrders)
+ * );
+ * // or
+ * await db.select({
+ *   productId: regularCustomerOrders.productId,
+ *   quantityOrdered: regularCustomerOrders.quantityOrdered,
+ * })
+ * .from(regularCustomerOrders)
+ * .exceptAll(
+ *   db.select({
+ *     productId: vipCustomerOrders.productId,
+ *     quantityOrdered: vipCustomerOrders.quantityOrdered,
+ *   })
+ *   .from(vipCustomerOrders)
+ * );
+ * ```
+ */
+export const exceptAll = createSetOperator('except', true);
diff --git a/drizzle-orm/src/cockroach-core/query-builders/select.types.ts b/drizzle-orm/src/cockroach-core/query-builders/select.types.ts
new file mode 100644
index 0000000000..a62f544b54
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/select.types.ts
@@ -0,0 +1,456 @@
+import type { CockroachColumn } from '~/cockroach-core/columns/index.ts';
+import type { CockroachTable, CockroachTableWithColumns } from '~/cockroach-core/table.ts';
+import type { CockroachViewBase } from '~/cockroach-core/view-base.ts';
+import type { CockroachViewWithSelection } from '~/cockroach-core/view.ts';
+import type {
+	SelectedFields as SelectedFieldsBase,
+	SelectedFieldsFlat as SelectedFieldsFlatBase,
+	SelectedFieldsOrdered as SelectedFieldsOrderedBase,
+} from '~/operations.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	AppendToNullabilityMap,
+	AppendToResult,
+	BuildSubquerySelection,
+	GetSelectTableName,
+	JoinNullability,
+	JoinType,
+	MapColumnsToTableAlias,
+	SelectMode,
+	SelectResult,
+	SetOperator,
+} from '~/query-builders/select.types.ts';
+import type { ColumnsSelection, Placeholder, SQL, SQLWrapper, View } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import type { Table, UpdateTableConfig } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Equal, ValidateShape, ValueOrArray } from '~/utils.ts';
+import type { CockroachPreparedQuery, PreparedQueryConfig } from '../session.ts';
+import type { CockroachSelectBase, CockroachSelectQueryBuilderBase } from './select.ts';
+
+export interface CockroachSelectJoinConfig {
+	on: SQL | undefined;
+	table: CockroachTable | Subquery | CockroachViewBase | SQL;
+	alias: string | undefined;
+	joinType: JoinType;
+	lateral?: boolean;
+}
+
+export type BuildAliasTable<TTable extends CockroachTable | View, TAlias extends string> = TTable extends Table
+	? CockroachTableWithColumns<
+		UpdateTableConfig<TTable['_'], {
+			name: TAlias;
+			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'cockroach'>;
+		}>
+	>
+	: TTable extends View ? CockroachViewWithSelection<
+			TAlias,
+			TTable['_']['existing'],
+			MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'cockroach'>
+		>
+	: never;
+
+export interface CockroachSelectConfig {
+	withList?: Subquery[];
+	// Either fields or fieldsFlat must be defined
+	fields: Record<string, unknown>;
+	fieldsFlat?: SelectedFieldsOrdered;
+	where?: SQL;
+	having?: SQL;
+	table: CockroachTable | Subquery | CockroachViewBase | SQL;
+	limit?: number | Placeholder;
+	offset?: number | Placeholder;
+	joins?: CockroachSelectJoinConfig[];
+	orderBy?: (CockroachColumn | SQL | SQL.Aliased)[];
+	groupBy?: (CockroachColumn | SQL | SQL.Aliased)[];
+	lockingClause?: {
+		strength: LockStrength;
+		config: LockConfig;
+	};
+	distinct?: boolean | {
+		on: (CockroachColumn | SQLWrapper)[];
+	};
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (CockroachColumn | SQL | SQL.Aliased)[];
+		limit?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
+}
+
+export type TableLikeHasEmptySelection<T extends CockroachTable | Subquery | CockroachViewBase | SQL> = T extends
+	Subquery ? Equal<T['_']['selectedFields'], {}> extends true ? true : false
+	: false;
+
+export type CockroachSelectJoin<
+	T extends AnyCockroachSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? CockroachSelectWithout<
+		CockroachSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends Table ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			T['_']['dynamic'],
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type CockroachSelectJoinFn<
+	T extends AnyCockroachSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : CockroachTable | Subquery | CockroachViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => CockroachSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type CockroachSelectCrossJoinFn<
+	T extends AnyCockroachSelectQueryBuilder,
+	TDynamic extends boolean,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : CockroachTable | Subquery | CockroachViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+) => CockroachSelectJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
+
+export type SelectedFieldsFlat = SelectedFieldsFlatBase<CockroachColumn>;
+
+export type SelectedFields = SelectedFieldsBase<CockroachColumn, CockroachTable>;
+
+export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<CockroachColumn>;
+
+export type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
+
+export type LockConfig =
+	& {
+		of?: ValueOrArray<CockroachTable>;
+	}
+	& ({
+		noWait: true;
+		skipLocked?: undefined;
+	} | {
+		noWait?: undefined;
+		skipLocked: true;
+	} | {
+		noWait?: undefined;
+		skipLocked?: undefined;
+	});
+
+export interface CockroachSelectHKTBase {
+	tableName: string | undefined;
+	selection: unknown;
+	selectMode: SelectMode;
+	nullabilityMap: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
+	_type: unknown;
+}
+
+export type CockroachSelectKind<
+	T extends CockroachSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> = (T & {
+	tableName: TTableName;
+	selection: TSelection;
+	selectMode: TSelectMode;
+	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
+})['_type'];
+
+export interface CockroachSelectQueryBuilderHKT extends CockroachSelectHKTBase {
+	_type: CockroachSelectQueryBuilderBase<
+		CockroachSelectQueryBuilderHKT,
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface CockroachSelectHKT extends CockroachSelectHKTBase {
+	_type: CockroachSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export type CreateCockroachSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+> = TBuilderMode extends 'db' ? CockroachSelectBase<TTableName, TSelection, TSelectMode>
+	: CockroachSelectQueryBuilderBase<CockroachSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
+
+export type CockroachSetOperatorExcludedMethods =
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin'
+	| 'where'
+	| 'having'
+	| 'groupBy'
+	| 'for';
+
+export type CockroachSelectWithout<
+	T extends AnyCockroachSelectQueryBuilder,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+	TResetExcluded extends boolean = false,
+> = TDynamic extends true ? T : Omit<
+	CockroachSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
+>;
+
+export type CockroachSelectPrepare<T extends AnyCockroachSelect> = CockroachPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	}
+>;
+
+export type CockroachSelectDynamic<T extends AnyCockroachSelectQueryBuilder> = CockroachSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type CockroachSelectQueryBuilder<
+	THKT extends CockroachSelectHKTBase = CockroachSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult extends any[] = unknown[],
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = CockroachSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyCockroachSelectQueryBuilder = CockroachSelectQueryBuilderBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type AnyCockroachSetOperatorInterface = CockroachSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export interface CockroachSetOperatorInterface<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> {
+	_: {
+		readonly hkt: CockroachSelectHKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+}
+
+export type CockroachSetOperatorWithResult<TResult extends any[]> = CockroachSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	TResult,
+	any
+>;
+
+export type CockroachSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = CockroachSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnyCockroachSelect = CockroachSelectBase<any, any, any, any, any, any, any, any>;
+
+export type CockroachSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = CockroachSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	CockroachSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends CockroachSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends CockroachSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly CockroachSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends CockroachSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
+		? Rest extends AnyCockroachSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+	: never
+	: TValue;
+
+export type CockroachCreateSetOperatorFn = <
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TValue extends CockroachSetOperatorWithResult<TResult>,
+	TRest extends CockroachSetOperatorWithResult<TResult>[],
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: CockroachSetOperatorInterface<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => CockroachSelectWithout<
+	CockroachSelectBase<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	false,
+	CockroachSetOperatorExcludedMethods,
+	true
+>;
+
+export type GetCockroachSetOperators = {
+	union: CockroachCreateSetOperatorFn;
+	intersect: CockroachCreateSetOperatorFn;
+	except: CockroachCreateSetOperatorFn;
+	unionAll: CockroachCreateSetOperatorFn;
+	intersectAll: CockroachCreateSetOperatorFn;
+	exceptAll: CockroachCreateSetOperatorFn;
+};
diff --git a/drizzle-orm/src/cockroach-core/query-builders/update.ts b/drizzle-orm/src/cockroach-core/query-builders/update.ts
new file mode 100644
index 0000000000..58327d6cd0
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/query-builders/update.ts
@@ -0,0 +1,637 @@
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import type {
+	CockroachPreparedQuery,
+	CockroachQueryResultHKT,
+	CockroachQueryResultKind,
+	CockroachSession,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import { CockroachTable } from '~/cockroach-core/table.ts';
+import type { GetColumnData } from '~/column.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	AppendToNullabilityMap,
+	AppendToResult,
+	GetSelectTableName,
+	GetSelectTableSelection,
+	JoinNullability,
+	JoinType,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type Placeholder, type Query, SQL, type SQLWrapper } from '~/sql/sql.ts';
+import { Subquery } from '~/subquery.ts';
+import { getTableName, type InferInsertModel, Table } from '~/table.ts';
+import {
+	type Assume,
+	type DrizzleTypeError,
+	type Equal,
+	getTableLikeName,
+	mapUpdateSet,
+	orderSelectedFields,
+	type Simplify,
+	type UpdateSet,
+} from '~/utils.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import type { CockroachColumn } from '../columns/common.ts';
+import type { CockroachViewBase } from '../view-base.ts';
+import type {
+	CockroachSelectJoinConfig,
+	SelectedFields,
+	SelectedFieldsOrdered,
+	TableLikeHasEmptySelection,
+} from './select.types.ts';
+
+export interface CockroachUpdateConfig {
+	where?: SQL | undefined;
+	set: UpdateSet;
+	table: CockroachTable;
+	from?: CockroachTable | Subquery | CockroachViewBase | SQL;
+	joins: CockroachSelectJoinConfig[];
+	returningFields?: SelectedFields;
+	returning?: SelectedFieldsOrdered;
+	withList?: Subquery[];
+}
+
+export type CockroachUpdateSetSource<TTable extends CockroachTable> =
+	& {
+		[Key in keyof InferInsertModel<TTable>]?:
+			| GetColumnData<TTable['_']['columns'][Key]>
+			| SQL
+			| CockroachColumn
+			| Placeholder
+			| undefined;
+	}
+	& {};
+
+export class CockroachUpdateBuilder<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT> {
+	static readonly [entityKind]: string = 'CockroachUpdateBuilder';
+
+	declare readonly _: {
+		readonly table: TTable;
+	};
+
+	constructor(
+		private table: TTable,
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+		private withList?: Subquery[],
+	) {}
+
+	set(
+		values: CockroachUpdateSetSource<TTable>,
+	): CockroachUpdateWithout<
+		CockroachUpdateBase<TTable, TQueryResult>,
+		false,
+		'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'
+	> {
+		return new CockroachUpdateBase<TTable, TQueryResult>(
+			this.table,
+			mapUpdateSet(this.table, values),
+			this.session,
+			this.dialect,
+			this.withList,
+		);
+	}
+}
+
+export type CockroachUpdateWithout<
+	T extends AnyCockroachUpdate,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	CockroachUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['from'],
+		T['_']['selectedFields'],
+		T['_']['returning'],
+		T['_']['nullabilityMap'],
+		T['_']['joins'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type CockroachUpdateWithJoins<
+	T extends AnyCockroachUpdate,
+	TDynamic extends boolean,
+	TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL,
+> = TDynamic extends true ? T : Omit<
+	CockroachUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		TFrom,
+		T['_']['selectedFields'],
+		T['_']['returning'],
+		AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TFrom>, 'inner'>,
+		[...T['_']['joins'], {
+			name: GetSelectTableName<TFrom>;
+			joinType: 'inner';
+			table: TFrom;
+		}],
+		TDynamic,
+		Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
+	>,
+	Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
+>;
+
+export type CockroachUpdateJoinFn<
+	T extends AnyCockroachUpdate,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+> = <
+	TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+	on:
+		| (
+			(
+				updateTable: T['_']['table']['_']['columns'],
+				from: T['_']['from'] extends CockroachTable ? T['_']['from']['_']['columns']
+					: T['_']['from'] extends Subquery | CockroachViewBase ? T['_']['from']['_']['selectedFields']
+					: never,
+			) => SQL | undefined
+		)
+		| SQL
+		| undefined,
+) => CockroachUpdateJoin<T, TDynamic, TJoinType, TJoinedTable>;
+
+export type CockroachUpdateJoin<
+	T extends AnyCockroachUpdate,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL,
+> = TDynamic extends true ? T : CockroachUpdateBase<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['from'],
+	T['_']['selectedFields'],
+	T['_']['returning'],
+	AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>,
+	[...T['_']['joins'], {
+		name: GetSelectTableName<TJoinedTable>;
+		joinType: TJoinType;
+		table: TJoinedTable;
+	}],
+	TDynamic,
+	T['_']['excludedMethods']
+>;
+
+type Join = {
+	name: string | undefined;
+	joinType: JoinType;
+	table: CockroachTable | Subquery | CockroachViewBase | SQL;
+};
+
+type AccumulateToResult<
+	T extends AnyCockroachUpdate,
+	TSelectMode extends SelectMode,
+	TJoins extends Join[],
+	TSelectedFields extends ColumnsSelection,
+> = TJoins extends [infer TJoin extends Join, ...infer TRest extends Join[]] ? AccumulateToResult<
+		T,
+		TSelectMode extends 'partial' ? TSelectMode : 'multiple',
+		TRest,
+		AppendToResult<
+			T['_']['table']['_']['name'],
+			TSelectedFields,
+			TJoin['name'],
+			TJoin['table'] extends Table ? TJoin['table']['_']['columns']
+				: TJoin['table'] extends Subquery ? Assume<TJoin['table']['_']['selectedFields'], SelectedFields>
+				: never,
+			TSelectMode extends 'partial' ? TSelectMode : 'multiple'
+		>
+	>
+	: TSelectedFields;
+
+export type CockroachUpdateReturningAll<T extends AnyCockroachUpdate, TDynamic extends boolean> =
+	CockroachUpdateWithout<
+		CockroachUpdateBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['from'],
+			Equal<T['_']['joins'], []> extends true ? T['_']['table']['_']['columns'] : Simplify<
+				& Record<T['_']['table']['_']['name'], T['_']['table']['_']['columns']>
+				& {
+					[K in keyof T['_']['joins'] as T['_']['joins'][K]['table']['_']['name']]:
+						T['_']['joins'][K]['table']['_']['columns'];
+				}
+			>,
+			SelectResult<
+				AccumulateToResult<
+					T,
+					'single',
+					T['_']['joins'],
+					GetSelectTableSelection<T['_']['table']>
+				>,
+				'partial',
+				T['_']['nullabilityMap']
+			>,
+			T['_']['nullabilityMap'],
+			T['_']['joins'],
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		'returning'
+	>;
+
+export type CockroachUpdateReturning<
+	T extends AnyCockroachUpdate,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFields,
+> = CockroachUpdateWithout<
+	CockroachUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['from'],
+		TSelectedFields,
+		SelectResult<
+			AccumulateToResult<
+				T,
+				'partial',
+				T['_']['joins'],
+				TSelectedFields
+			>,
+			'partial',
+			T['_']['nullabilityMap']
+		>,
+		T['_']['nullabilityMap'],
+		T['_']['joins'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type CockroachUpdatePrepare<T extends AnyCockroachUpdate> = CockroachPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? CockroachQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type CockroachUpdateDynamic<T extends AnyCockroachUpdate> = CockroachUpdate<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['from'],
+	T['_']['returning'],
+	T['_']['nullabilityMap']
+>;
+
+export type CockroachUpdate<
+	TTable extends CockroachTable = CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT,
+	TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+> = CockroachUpdateBase<
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	true,
+	never
+>;
+
+export type AnyCockroachUpdate = CockroachUpdateBase<any, any, any, any, any, any, any, any, any>;
+
+export interface CockroachUpdateBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>,
+	RunnableQuery<
+		TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+		'cockroach'
+	>,
+	SQLWrapper
+{
+	readonly _: {
+		readonly dialect: 'cockroach';
+		readonly table: TTable;
+		readonly joins: TJoins;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly queryResult: TQueryResult;
+		readonly from: TFrom;
+		readonly selectedFields: TSelectedFields;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+	};
+}
+
+export class CockroachUpdateBase<
+	TTable extends CockroachTable,
+	TQueryResult extends CockroachQueryResultHKT,
+	TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TJoins extends Join[] = [],
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>
+	implements
+		RunnableQuery<
+			TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[],
+			'cockroach'
+		>,
+		SQLWrapper
+{
+	static override readonly [entityKind]: string = 'CockroachUpdate';
+
+	private config: CockroachUpdateConfig;
+	private tableName: string | undefined;
+	private joinsNotNullableMap: Record<string, boolean>;
+
+	constructor(
+		table: TTable,
+		set: UpdateSet,
+		private session: CockroachSession,
+		private dialect: CockroachDialect,
+		withList?: Subquery[],
+	) {
+		super();
+		this.config = { set, table, withList, joins: [] };
+		this.tableName = getTableLikeName(table);
+		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
+	}
+
+	from<TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL>(
+		source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<
+				"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+			>
+			: TFrom,
+	): CockroachUpdateWithJoins<this, TDynamic, TFrom> {
+		const src = source as TFrom;
+		const tableName = getTableLikeName(src);
+		if (typeof tableName === 'string') {
+			this.joinsNotNullableMap[tableName] = true;
+		}
+		this.config.from = src;
+		return this as any;
+	}
+
+	private getTableLikeFields(table: CockroachTable | Subquery | CockroachViewBase): Record<string, unknown> {
+		if (is(table, CockroachTable)) {
+			return table[Table.Symbol.Columns];
+		} else if (is(table, Subquery)) {
+			return table._.selectedFields;
+		}
+		return table[ViewBaseConfig].selectedFields;
+	}
+
+	private createJoin<TJoinType extends JoinType>(
+		joinType: TJoinType,
+	): CockroachUpdateJoinFn<this, TDynamic, TJoinType> {
+		return ((
+			table: CockroachTable | Subquery | CockroachViewBase | SQL,
+			on: ((updateTable: TTable, from: TFrom) => SQL | undefined) | SQL | undefined,
+		) => {
+			const tableName = getTableLikeName(table);
+
+			if (typeof tableName === 'string' && this.config.joins.some((join) => join.alias === tableName)) {
+				throw new Error(`Alias "${tableName}" is already used in this query`);
+			}
+
+			if (typeof on === 'function') {
+				const from = this.config.from && !is(this.config.from, SQL)
+					? this.getTableLikeFields(this.config.from)
+					: undefined;
+				on = on(
+					new Proxy(
+						this.config.table[Table.Symbol.Columns],
+						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+					) as any,
+					from && new Proxy(
+						from,
+						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+					) as any,
+				);
+			}
+
+			this.config.joins.push({ on, table, joinType, alias: tableName });
+
+			if (typeof tableName === 'string') {
+				switch (joinType) {
+					case 'left': {
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+					case 'right': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'inner': {
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'full': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+				}
+			}
+
+			return this as any;
+		}) as any;
+	}
+
+	leftJoin = this.createJoin('left');
+
+	rightJoin = this.createJoin('right');
+
+	innerJoin = this.createJoin('inner');
+
+	fullJoin = this.createJoin('full');
+
+	/**
+	 * Adds a 'where' clause to the query.
+	 *
+	 * Calling this method will update only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param where the 'where' clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be updated.
+	 *
+	 * ```ts
+	 * // Update all cars with green color
+	 * await db.update(cars).set({ color: 'red' })
+	 *   .where(eq(cars.color, 'green'));
+	 * // or
+	 * await db.update(cars).set({ color: 'red' })
+	 *   .where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Update all BMW cars with a green color
+	 * await db.update(cars).set({ color: 'red' })
+	 *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Update all cars with the green or blue color
+	 * await db.update(cars).set({ color: 'red' })
+	 *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(where: SQL | undefined): CockroachUpdateWithout<this, TDynamic, 'where'> {
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `returning` clause to the query.
+	 *
+	 * Calling this method will return the specified fields of the updated rows. If no fields are specified, all fields will be returned.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update#update-with-returning}
+	 *
+	 * @example
+	 * ```ts
+	 * // Update all cars with the green color and return all fields
+	 * const updatedCars: Car[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.color, 'green'))
+	 *   .returning();
+	 *
+	 * // Update all cars with the green color and return only their id and brand fields
+	 * const updatedCarsIdsAndBrands: { id: number, brand: string }[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.color, 'green'))
+	 *   .returning({ id: cars.id, brand: cars.brand });
+	 * ```
+	 */
+	returning(): CockroachUpdateReturningAll<this, TDynamic>;
+	returning<TSelectedFields extends SelectedFields>(
+		fields: TSelectedFields,
+	): CockroachUpdateReturning<this, TDynamic, TSelectedFields>;
+	returning(
+		fields?: SelectedFields,
+	): CockroachUpdateWithout<AnyCockroachUpdate, TDynamic, 'returning'> {
+		if (!fields) {
+			fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);
+
+			if (this.config.from) {
+				const tableName = getTableLikeName(this.config.from);
+
+				if (typeof tableName === 'string' && this.config.from && !is(this.config.from, SQL)) {
+					const fromFields = this.getTableLikeFields(this.config.from);
+					fields[tableName] = fromFields as any;
+				}
+
+				for (const join of this.config.joins) {
+					const tableName = getTableLikeName(join.table);
+
+					if (typeof tableName === 'string' && !is(join.table, SQL)) {
+						const fromFields = this.getTableLikeFields(join.table);
+						fields[tableName] = fromFields as any;
+					}
+				}
+			}
+		}
+
+		this.config.returningFields = fields;
+		this.config.returning = orderSelectedFields<CockroachColumn>(fields);
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildUpdateQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): CockroachUpdatePrepare<this> {
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const preparedQuery = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: TReturning[] }
+		>(
+			query,
+			this.config.returning,
+			name ?? (generateName ? preparedStatementName(query.sql, query.params) : name),
+		);
+		preparedQuery.joinsNotNullableMap = this.joinsNotNullableMap;
+		return preparedQuery;
+	}
+
+	prepare(name?: string): CockroachUpdatePrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this._prepare().execute(placeholderValues);
+	};
+
+	/** @internal */
+	getSelectedFields(): this['_']['selectedFields'] {
+		return (
+			this.config.returningFields
+				? new Proxy(
+					this.config.returningFields,
+					new SelectionProxyHandler({
+						alias: getTableName(this.config.table),
+						sqlAliasedBehavior: 'alias',
+						sqlBehavior: 'error',
+					}),
+				)
+				: undefined
+		) as this['_']['selectedFields'];
+	}
+
+	/** @internal */
+	withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
+	$dynamic(): CockroachUpdateDynamic<this> {
+		return this as any;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/roles.ts b/drizzle-orm/src/cockroach-core/roles.ts
new file mode 100644
index 0000000000..3af61c0211
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/roles.ts
@@ -0,0 +1,37 @@
+import { entityKind } from '~/entity.ts';
+
+export interface CockroachRoleConfig {
+	createDb?: boolean;
+	createRole?: boolean;
+}
+
+export class CockroachRole implements CockroachRoleConfig {
+	static readonly [entityKind]: string = 'CockroachRole';
+
+	/** @internal */
+	_existing?: boolean;
+
+	/** @internal */
+	readonly createDb: CockroachRoleConfig['createDb'];
+	/** @internal */
+	readonly createRole: CockroachRoleConfig['createRole'];
+
+	constructor(
+		readonly name: string,
+		config?: CockroachRoleConfig,
+	) {
+		if (config) {
+			this.createDb = config.createDb;
+			this.createRole = config.createRole;
+		}
+	}
+
+	existing(): this {
+		this._existing = true;
+		return this;
+	}
+}
+
+export function cockroachRole(name: string, config?: CockroachRoleConfig) {
+	return new CockroachRole(name, config);
+}
diff --git a/drizzle-orm/src/cockroach-core/schema.ts b/drizzle-orm/src/cockroach-core/schema.ts
new file mode 100644
index 0000000000..da84ba8a9e
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/schema.ts
@@ -0,0 +1,104 @@
+import type { Casing } from '~/casing.ts';
+import { entityKind, is } from '~/entity.ts';
+import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import type { NonArray, Writable } from '~/utils.ts';
+import {
+	type CockroachEnum,
+	type CockroachEnumObject,
+	cockroachEnumObjectWithSchema,
+	cockroachEnumWithSchema,
+} from './columns/enum.ts';
+import { type cockroachSequence, cockroachSequenceWithSchema } from './sequence.ts';
+import { type CockroachTableFn, type CockroachTableFnInternal, cockroachTableWithSchema, EnableRLS } from './table.ts';
+import {
+	type cockroachMaterializedView,
+	cockroachMaterializedViewWithSchema,
+	type cockroachView,
+	cockroachViewWithSchema,
+} from './view.ts';
+
+export class CockroachSchema<TName extends string = string> implements SQLWrapper {
+	static readonly [entityKind]: string = 'CockroachSchema';
+
+	isExisting: boolean = false;
+	constructor(
+		public readonly schemaName: TName,
+		protected casing: Casing | undefined,
+	) {
+		this.table = Object.assign(this.table, {
+			withRLS: ((name, columns, extraConfig) => {
+				const table = cockroachTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
+				table[EnableRLS] = true;
+
+				return table;
+			}) as CockroachTableFnInternal<TName>,
+		});
+	}
+
+	table: CockroachTableFn<TName> = ((name, columns, extraConfig) => {
+		return cockroachTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
+	}) as CockroachTableFn<TName>;
+
+	view = ((name, columns) => {
+		return cockroachViewWithSchema(name, columns, this.schemaName, this.casing);
+	}) as typeof cockroachView;
+
+	materializedView = ((name, columns) => {
+		return cockroachMaterializedViewWithSchema(name, columns, this.schemaName, this.casing);
+	}) as typeof cockroachMaterializedView;
+
+	public enum<U extends string, T extends Readonly<[U, ...U[]]>>(
+		enumName: string,
+		values: T | Writable<T>,
+	): CockroachEnum<Writable<T>>;
+
+	public enum<E extends Record<string, string>>(
+		enumName: string,
+		enumObj: NonArray<E>,
+	): CockroachEnumObject<E>;
+
+	public enum(enumName: any, input: any): any {
+		return Array.isArray(input)
+			? cockroachEnumWithSchema(
+				enumName,
+				[...input] as [string, ...string[]],
+				this.schemaName,
+			)
+			: cockroachEnumObjectWithSchema(enumName, input, this.schemaName);
+	}
+
+	sequence: typeof cockroachSequence = ((name, options) => {
+		return cockroachSequenceWithSchema(name, options, this.schemaName);
+	});
+
+	getSQL(): SQL {
+		return new SQL([sql.identifier(this.schemaName)]);
+	}
+
+	shouldOmitSQLParens(): boolean {
+		return true;
+	}
+
+	existing(): this {
+		this.isExisting = true;
+		return this;
+	}
+}
+
+export function isCockroachSchema(obj: unknown): obj is CockroachSchema {
+	return is(obj, CockroachSchema);
+}
+
+export function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;
+/** @internal */
+export function cockroachSchema<T extends string>(name: T, casing?: Casing): CockroachSchema<T>;
+/** @internal */
+export function cockroachSchema<T extends string>(name: T, casing?: Casing): CockroachSchema<T> {
+	if (name === 'public') {
+		throw new Error(
+			`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use cockroachTable() instead of creating a schema`,
+		);
+	}
+
+	return new CockroachSchema(name, casing);
+}
diff --git a/drizzle-orm/src/cockroach-core/sequence.ts b/drizzle-orm/src/cockroach-core/sequence.ts
new file mode 100644
index 0000000000..b71b16596d
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/sequence.ts
@@ -0,0 +1,40 @@
+import { entityKind, is } from '~/entity.ts';
+
+export type CockroachSequenceOptions = {
+	increment?: number | string;
+	minValue?: number | string;
+	maxValue?: number | string;
+	startWith?: number | string;
+	cache?: number | string;
+};
+
+export class CockroachSequence {
+	static readonly [entityKind]: string = 'CockroachSequence';
+
+	constructor(
+		public readonly seqName: string,
+		public readonly seqOptions: CockroachSequenceOptions | undefined,
+		public readonly schema: string | undefined,
+	) {
+	}
+}
+
+export function cockroachSequence(
+	name: string,
+	options?: CockroachSequenceOptions,
+): CockroachSequence {
+	return cockroachSequenceWithSchema(name, options, undefined);
+}
+
+/** @internal */
+export function cockroachSequenceWithSchema(
+	name: string,
+	options?: CockroachSequenceOptions,
+	schema?: string,
+): CockroachSequence {
+	return new CockroachSequence(name, options, schema);
+}
+
+export function isCockroachSequence(obj: unknown): obj is CockroachSequence {
+	return is(obj, CockroachSequence);
+}
diff --git a/drizzle-orm/src/cockroach-core/session.ts b/drizzle-orm/src/cockroach-core/session.ts
new file mode 100644
index 0000000000..85007c202a
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/session.ts
@@ -0,0 +1,164 @@
+import type * as V1 from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { TransactionRollbackError } from '~/errors.ts';
+import type { PreparedQuery } from '~/session.ts';
+import { type Query, type SQL, sql } from '~/sql/index.ts';
+import { tracer } from '~/tracing.ts';
+import type { NeonAuthToken } from '~/utils.ts';
+import { CockroachDatabase } from './db.ts';
+import type { CockroachDialect } from './dialect.ts';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
+
+export interface PreparedQueryConfig {
+	execute: unknown;
+	all: unknown;
+	values: unknown;
+}
+
+export abstract class CockroachPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+	constructor(protected query: Query) {}
+
+	protected authToken?: NeonAuthToken;
+
+	getQuery(): Query {
+		return this.query;
+	}
+
+	mapResult(response: unknown, _isFromBatch?: boolean): unknown {
+		return response;
+	}
+
+	/** @internal */
+	setToken(token?: NeonAuthToken) {
+		this.authToken = token;
+		return this;
+	}
+
+	static readonly [entityKind]: string = 'CockroachPreparedQuery';
+
+	/** @internal */
+	joinsNotNullableMap?: Record<string, boolean>;
+
+	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+	/** @internal */
+	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
+	/** @internal */
+	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
+
+	/** @internal */
+	abstract all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;
+}
+
+export interface CockroachTransactionConfig {
+	isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+	accessMode?: 'read only' | 'read write';
+	deferrable?: boolean;
+}
+
+export abstract class CockroachSession<
+	TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
+> {
+	static readonly [entityKind]: string = 'CockroachSession';
+
+	constructor(protected dialect: CockroachDialect) {}
+
+	abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		name: string | undefined,
+		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute'],
+	): CockroachPreparedQuery<T>;
+
+	execute<T>(query: SQL): Promise<T>;
+	/** @internal */
+	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T>;
+	/** @internal */
+	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
+				return this.prepareQuery<PreparedQueryConfig & { execute: T }>(
+					this.dialect.sqlToQuery(query),
+					undefined,
+					undefined,
+					undefined,
+				);
+			});
+
+			return prepared.setToken(token).execute(undefined, token);
+		});
+	}
+
+	all<T = unknown>(query: SQL): Promise<T[]> {
+		return this.prepareQuery<PreparedQueryConfig & { all: T[] }>(
+			this.dialect.sqlToQuery(query),
+			undefined,
+			undefined,
+			undefined,
+		).all();
+	}
+
+	abstract transaction<T>(
+		transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
+		config?: CockroachTransactionConfig,
+	): Promise<T>;
+}
+
+export abstract class CockroachTransaction<
+	TQueryResult extends CockroachQueryResultHKT,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
+> extends CockroachDatabase<TQueryResult, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'CockroachTransaction';
+
+	constructor(
+		dialect: CockroachDialect,
+		session: CockroachSession<any, any, any>,
+		protected schema: {
+			fullSchema: Record<string, unknown>;
+			schema: TSchema;
+			tableNamesMap: Record<string, string>;
+		} | undefined,
+		protected readonly nestedIndex = 0,
+	) {
+		super(dialect, session, schema);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+
+	/** @internal */
+	getTransactionConfigSQL(config: CockroachTransactionConfig): SQL {
+		const chunks: string[] = [];
+		if (config.isolationLevel) {
+			chunks.push(`isolation level ${config.isolationLevel}`);
+		}
+		if (config.accessMode) {
+			chunks.push(config.accessMode);
+		}
+		if (typeof config.deferrable === 'boolean') {
+			chunks.push(config.deferrable ? 'deferrable' : 'not deferrable');
+		}
+		return sql.raw(chunks.join(' '));
+	}
+
+	setTransaction(config: CockroachTransactionConfig): Promise<void> {
+		return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+	}
+
+	abstract override transaction<T>(
+		transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T>;
+}
+
+export interface CockroachQueryResultHKT {
+	readonly $brand: 'CockroachQueryResultHKT';
+	readonly row: unknown;
+	readonly type: unknown;
+}
+
+export type CockroachQueryResultKind<TKind extends CockroachQueryResultHKT, TRow> = (TKind & {
+	readonly row: TRow;
+})['type'];
diff --git a/drizzle-orm/src/cockroach-core/subquery.ts b/drizzle-orm/src/cockroach-core/subquery.ts
new file mode 100644
index 0000000000..ca02f0c6f8
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/subquery.ts
@@ -0,0 +1,29 @@
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import type { Subquery, WithSubquery, WithSubqueryWithoutSelection } from '~/subquery.ts';
+import type { QueryBuilder } from './query-builders/query-builder.ts';
+
+export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
+	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'cockroach'>>
+	& AddAliasToSelection<TSelection, TAlias, 'cockroach'>;
+
+export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
+	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'cockroach'>>
+	& AddAliasToSelection<TSelection, TAlias, 'cockroach'>;
+
+export interface WithBuilder {
+	<TAlias extends string>(alias: TAlias): {
+		as: {
+			<TSelection extends ColumnsSelection>(
+				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
+			): WithSubqueryWithSelection<TSelection, TAlias>;
+			(
+				qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>),
+			): WithSubqueryWithoutSelection<TAlias>;
+		};
+	};
+	<TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
+		as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
+	};
+}
diff --git a/drizzle-orm/src/cockroach-core/table.ts b/drizzle-orm/src/cockroach-core/table.ts
new file mode 100644
index 0000000000..c74177e4e4
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/table.ts
@@ -0,0 +1,247 @@
+import { type Casing, getCasingFn } from '~/casing.ts';
+import type { BuildColumns, BuildExtraConfigColumns, ColumnBuilderBase } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import {
+	type InferTableColumnsModels,
+	Table,
+	type TableConfig as TableConfigBase,
+	type UpdateTableConfig,
+} from '~/table.ts';
+import type { CheckBuilder } from './checks.ts';
+import { type CockroachColumnsBuilders, getCockroachColumnBuilders } from './columns/all.ts';
+import type {
+	CockroachColumn,
+	CockroachColumns,
+	CockroachColumnWithArrayBuilder,
+	ExtraConfigColumn,
+} from './columns/common.ts';
+import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
+import type { AnyIndexBuilder } from './indexes.ts';
+import type { CockroachPolicy } from './policies.ts';
+import type { PrimaryKeyBuilder } from './primary-keys.ts';
+import type { UniqueConstraintBuilder } from './unique-constraint.ts';
+
+export type CockroachTableExtraConfigValue =
+	| AnyIndexBuilder
+	| CheckBuilder
+	| ForeignKeyBuilder
+	| PrimaryKeyBuilder
+	| UniqueConstraintBuilder
+	| CockroachPolicy;
+
+export type CockroachTableExtraConfig = Record<
+	string,
+	CockroachTableExtraConfigValue
+>;
+
+export type TableConfig = TableConfigBase<CockroachColumns>;
+
+/** @internal */
+export const InlineForeignKeys = Symbol.for('drizzle:CockroachInlineForeignKeys');
+/** @internal */
+export const EnableRLS = Symbol.for('drizzle:EnableRLS');
+
+export class CockroachTable<T extends TableConfig = TableConfig> extends Table<T> {
+	static override readonly [entityKind]: string = 'CockroachTable';
+
+	/** @internal */
+	static override readonly Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys: InlineForeignKeys as typeof InlineForeignKeys,
+		EnableRLS: EnableRLS as typeof EnableRLS,
+	});
+
+	/**@internal */
+	[InlineForeignKeys]: ForeignKey[] = [];
+
+	/** @internal */
+	[EnableRLS]: boolean = false;
+
+	/** @internal */
+	override [Table.Symbol.ExtraConfigBuilder]:
+		| ((self: Record<string, CockroachColumn>) => CockroachTableExtraConfig)
+		| undefined = undefined;
+
+	/** @internal */
+	override [Table.Symbol.ExtraConfigColumns]: Record<string, ExtraConfigColumn> = {};
+}
+
+export type AnyCockroachTable<TPartial extends Partial<TableConfig> = {}> = CockroachTable<
+	UpdateTableConfig<TableConfig, TPartial>
+>;
+
+export type CockroachTableWithColumns<T extends TableConfig> =
+	& CockroachTable<T>
+	& T['columns']
+	& InferTableColumnsModels<T['columns']>
+	& {
+		/** @deprecated use `cockroachTable.withRLS()` instead*/
+		enableRLS: () => Omit<
+			CockroachTableWithColumns<T>,
+			'enableRLS'
+		>;
+	};
+
+/** @internal */
+export function cockroachTableWithSchema<
+	TTableName extends string,
+	TSchemaName extends string | undefined,
+	TColumnsMap extends Record<string, ColumnBuilderBase>,
+>(
+	name: TTableName,
+	columns: TColumnsMap | ((columnTypes: CockroachColumnsBuilders) => TColumnsMap),
+	extraConfig:
+		| ((
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'cockroach'>,
+		) => CockroachTableExtraConfig | CockroachTableExtraConfigValue[])
+		| undefined,
+	schema: TSchemaName,
+	casing: Casing | undefined,
+	baseName = name,
+): CockroachTableWithColumns<{
+	name: TTableName;
+	schema: TSchemaName;
+	columns: BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+	dialect: 'cockroach';
+}> {
+	const casingFn = getCasingFn(casing);
+	const rawTable = new CockroachTable<{
+		name: TTableName;
+		schema: TSchemaName;
+		columns: BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+		dialect: 'cockroach';
+	}>(name, schema, baseName);
+
+	const parsedColumns: TColumnsMap = typeof columns === 'function' ? columns(getCockroachColumnBuilders()) : columns;
+
+	const builtColumns = Object.fromEntries(
+		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+			const colBuilder = colBuilderBase as CockroachColumnWithArrayBuilder;
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
+			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+			return [name, column];
+		}),
+	) as unknown as BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+
+	const builtColumnsForExtraConfig = Object.fromEntries(
+		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+			const colBuilder = colBuilderBase as CockroachColumnWithArrayBuilder;
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.buildExtraConfigColumn(rawTable);
+			return [name, column];
+		}),
+	) as unknown as BuildExtraConfigColumns<TTableName, TColumnsMap, 'cockroach'>;
+
+	const table = Object.assign(rawTable, builtColumns);
+
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+
+	if (extraConfig) {
+		table[CockroachTable.Symbol.ExtraConfigBuilder] = extraConfig as any;
+	}
+
+	return Object.assign(table, {
+		enableRLS: () => {
+			table[CockroachTable.Symbol.EnableRLS] = true;
+			return table as CockroachTableWithColumns<{
+				name: TTableName;
+				schema: TSchemaName;
+				columns: BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+				dialect: 'cockroach';
+			}>;
+		},
+	}) as any;
+}
+
+export interface CockroachTableFnInternal<TSchema extends string | undefined = undefined> {
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig?: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'cockroach'>,
+		) => CockroachTableExtraConfigValue[],
+	): CockroachTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+		dialect: 'cockroach';
+	}>;
+
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: (columnTypes: CockroachColumnsBuilders) => TColumnsMap,
+		extraConfig?: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'cockroach'>,
+		) => CockroachTableExtraConfigValue[],
+	): CockroachTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'cockroach'>;
+		dialect: 'cockroach';
+	}>;
+}
+
+export interface CockroachTableFn<TSchema extends string | undefined = undefined>
+	extends CockroachTableFnInternal<TSchema>
+{
+	withRLS: CockroachTableFnInternal<TSchema>;
+}
+
+/** @internal */
+export function cockroachTableWithCasing(casing: Casing | undefined): CockroachTableFn {
+	const cockroachTableInternal: CockroachTableFnInternal = (name, columns, extraConfig) => {
+		return cockroachTableWithSchema(name, columns, extraConfig, undefined, casing);
+	};
+
+	const cockroachTableWithRLS: CockroachTableFn['withRLS'] = (name, columns, extraConfig) => {
+		const table = cockroachTableWithSchema(name, columns, extraConfig, undefined, casing);
+		table[EnableRLS] = true;
+
+		return table;
+	};
+
+	return Object.assign(cockroachTableInternal, {
+		withRLS: cockroachTableWithRLS,
+	});
+}
+
+export const cockroachTable = cockroachTableWithCasing(undefined);
+
+export function cockroachTableCreator(
+	customizeTableName: (name: string) => string,
+	casing?: Casing | undefined,
+): CockroachTableFn {
+	const fn: CockroachTableFnInternal = (name, columns, extraConfig) => {
+		return cockroachTableWithSchema(
+			customizeTableName(name) as typeof name,
+			columns,
+			extraConfig,
+			undefined,
+			casing,
+			name,
+		);
+	};
+
+	return Object.assign(fn, {
+		withRLS: ((name, columns, extraConfig) => {
+			const table = cockroachTableWithSchema(
+				customizeTableName(name) as typeof name,
+				columns,
+				extraConfig,
+				undefined,
+				casing,
+				name,
+			);
+			table[EnableRLS] = true;
+
+			return table;
+		}) as CockroachTableFnInternal,
+	});
+}
diff --git a/drizzle-orm/src/cockroach-core/unique-constraint.ts b/drizzle-orm/src/cockroach-core/unique-constraint.ts
new file mode 100644
index 0000000000..83140a0583
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/unique-constraint.ts
@@ -0,0 +1,65 @@
+import { entityKind } from '~/entity.ts';
+import type { CockroachColumn } from './columns/index.ts';
+import type { CockroachTable } from './table.ts';
+
+export function unique(name?: string): UniqueOnConstraintBuilder {
+	return new UniqueOnConstraintBuilder(name);
+}
+
+export class UniqueConstraintBuilder {
+	static readonly [entityKind]: string = 'CockroachUniqueConstraintBuilder';
+
+	/** @internal */
+	columns: CockroachColumn[];
+
+	constructor(
+		columns: CockroachColumn[],
+		private name?: string,
+	) {
+		this.columns = columns;
+	}
+
+	/** @internal */
+	build(table: CockroachTable): UniqueConstraint {
+		return new UniqueConstraint(table, this.columns, this.name);
+	}
+}
+
+export class UniqueOnConstraintBuilder {
+	static readonly [entityKind]: string = 'CockroachUniqueOnConstraintBuilder';
+
+	/** @internal */
+	name?: string;
+
+	constructor(
+		name?: string,
+	) {
+		this.name = name;
+	}
+
+	on(...columns: [CockroachColumn, ...CockroachColumn[]]) {
+		return new UniqueConstraintBuilder(columns, this.name);
+	}
+}
+
+export class UniqueConstraint {
+	static readonly [entityKind]: string = 'CockroachUniqueConstraint';
+
+	readonly columns: CockroachColumn[];
+	readonly name?: string;
+	readonly isNameExplicit: boolean;
+
+	constructor(
+		readonly table: CockroachTable,
+		columns: CockroachColumn[],
+		name?: string,
+	) {
+		this.columns = columns;
+		this.name = name;
+		this.isNameExplicit = !!name;
+	}
+
+	getName(): string | undefined {
+		return this.name;
+	}
+}
diff --git a/drizzle-orm/src/cockroach-core/utils.ts b/drizzle-orm/src/cockroach-core/utils.ts
new file mode 100644
index 0000000000..2d6d137cd3
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/utils.ts
@@ -0,0 +1,86 @@
+import { CockroachTable } from '~/cockroach-core/table.ts';
+import { is } from '~/entity.ts';
+import { Table } from '~/table.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { type Check, CheckBuilder } from './checks.ts';
+import type { AnyCockroachColumn } from './columns/index.ts';
+import { type ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
+import type { Index } from './indexes.ts';
+import { IndexBuilder } from './indexes.ts';
+import { CockroachPolicy } from './policies.ts';
+import { type PrimaryKey, PrimaryKeyBuilder } from './primary-keys.ts';
+import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
+import { type CockroachMaterializedView, CockroachMaterializedViewConfig, type CockroachView } from './view.ts';
+
+export function getTableConfig<TTable extends CockroachTable>(table: TTable) {
+	const columns = Object.values(table[Table.Symbol.Columns]);
+	const indexes: Index[] = [];
+	const checks: Check[] = [];
+	const primaryKeys: PrimaryKey[] = [];
+	const foreignKeys: ForeignKey[] = Object.values(table[CockroachTable.Symbol.InlineForeignKeys]);
+	const uniqueConstraints: UniqueConstraint[] = [];
+	const name = table[Table.Symbol.Name];
+	const schema = table[Table.Symbol.Schema];
+	const policies: CockroachPolicy[] = [];
+	const enableRLS: boolean = table[CockroachTable.Symbol.EnableRLS];
+
+	const extraConfigBuilder = table[CockroachTable.Symbol.ExtraConfigBuilder];
+
+	if (extraConfigBuilder !== undefined) {
+		const extraConfig = extraConfigBuilder(table[Table.Symbol.ExtraConfigColumns]);
+		const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) as any[] : Object.values(extraConfig);
+		for (const builder of extraValues) {
+			if (is(builder, IndexBuilder)) {
+				indexes.push(builder.build(table));
+			} else if (is(builder, CheckBuilder)) {
+				checks.push(builder.build(table));
+			} else if (is(builder, UniqueConstraintBuilder)) {
+				uniqueConstraints.push(builder.build(table));
+			} else if (is(builder, PrimaryKeyBuilder)) {
+				primaryKeys.push(builder.build(table));
+			} else if (is(builder, ForeignKeyBuilder)) {
+				foreignKeys.push(builder.build(table));
+			} else if (is(builder, CockroachPolicy)) {
+				policies.push(builder);
+			}
+		}
+	}
+
+	return {
+		columns,
+		indexes,
+		foreignKeys,
+		checks,
+		primaryKeys,
+		uniqueConstraints,
+		name,
+		schema,
+		policies,
+		enableRLS,
+	};
+}
+
+export function getViewConfig<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+>(view: CockroachView<TName, TExisting>) {
+	return {
+		...view[ViewBaseConfig],
+	};
+}
+
+export function getMaterializedViewConfig<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+>(view: CockroachMaterializedView<TName, TExisting>) {
+	return {
+		...view[ViewBaseConfig],
+		...view[CockroachMaterializedViewConfig],
+	};
+}
+
+export type ColumnsWithTable<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends AnyCockroachColumn<{ tableName: TTableName }>[],
+> = { [Key in keyof TColumns]: AnyCockroachColumn<{ tableName: TForeignTableName }> };
diff --git a/drizzle-orm/src/cockroach-core/utils/array.ts b/drizzle-orm/src/cockroach-core/utils/array.ts
new file mode 100644
index 0000000000..14bb7819fa
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/utils/array.ts
@@ -0,0 +1,95 @@
+function parseCockroachArrayValue(arrayString: string, startFrom: number, inQuotes: boolean): [string, number] {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char = arrayString[i];
+
+		if (char === '\\') {
+			i++;
+			continue;
+		}
+
+		if (char === '"') {
+			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i + 1];
+		}
+
+		if (inQuotes) {
+			continue;
+		}
+
+		if (char === ',' || char === '}') {
+			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i];
+		}
+	}
+
+	return [arrayString.slice(startFrom).replace(/\\/g, ''), arrayString.length];
+}
+
+export function parseCockroachNestedArray(arrayString: string, startFrom = 0): [any[], number] {
+	const result: any[] = [];
+	let i = startFrom;
+	let lastCharIsComma = false;
+
+	while (i < arrayString.length) {
+		const char = arrayString[i];
+
+		if (char === ',') {
+			if (lastCharIsComma || i === startFrom) {
+				result.push('');
+			}
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+
+		lastCharIsComma = false;
+
+		if (char === '\\') {
+			i += 2;
+			continue;
+		}
+
+		if (char === '"') {
+			const [value, startFrom] = parseCockroachArrayValue(arrayString, i + 1, true);
+			result.push(value);
+			i = startFrom;
+			continue;
+		}
+
+		if (char === '}') {
+			return [result, i + 1];
+		}
+
+		if (char === '{') {
+			const [value, startFrom] = parseCockroachNestedArray(arrayString, i + 1);
+			result.push(value);
+			i = startFrom;
+			continue;
+		}
+
+		const [value, newStartFrom] = parseCockroachArrayValue(arrayString, i, false);
+		result.push(value);
+		i = newStartFrom;
+	}
+
+	return [result, i];
+}
+
+export function parseCockroachArray(arrayString: string): any[] {
+	const [result] = parseCockroachNestedArray(arrayString, 1);
+	return result;
+}
+
+export function makeCockroachArray(array: any[]): string {
+	return `{${
+		array.map((item) => {
+			if (Array.isArray(item)) {
+				return makeCockroachArray(item);
+			}
+
+			if (typeof item === 'string') {
+				return `"${item.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+			}
+
+			return `${item}`;
+		}).join(',')
+	}}`;
+}
diff --git a/drizzle-orm/src/pg-core/utils/index.ts b/drizzle-orm/src/cockroach-core/utils/index.ts
similarity index 100%
rename from drizzle-orm/src/pg-core/utils/index.ts
rename to drizzle-orm/src/cockroach-core/utils/index.ts
diff --git a/drizzle-orm/src/cockroach-core/view-base.ts b/drizzle-orm/src/cockroach-core/view-base.ts
new file mode 100644
index 0000000000..0a953085dd
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/view-base.ts
@@ -0,0 +1,14 @@
+import { entityKind } from '~/entity.ts';
+import { type ColumnsSelection, View } from '~/sql/sql.ts';
+
+export abstract class CockroachViewBase<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends View<TName, TExisting, TSelectedFields> {
+	static override readonly [entityKind]: string = 'CockroachViewBase';
+
+	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+		readonly viewBrand: 'CockroachViewBase';
+	};
+}
diff --git a/drizzle-orm/src/cockroach-core/view.ts b/drizzle-orm/src/cockroach-core/view.ts
new file mode 100644
index 0000000000..85b9f17ee7
--- /dev/null
+++ b/drizzle-orm/src/cockroach-core/view.ts
@@ -0,0 +1,368 @@
+import type { Casing } from '~/casing.ts';
+import type { BuildColumns, ColumnBuilderBase } from '~/column-builder.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import { getTableColumns } from '~/utils.ts';
+import type { CockroachColumn } from './columns/common.ts';
+import { QueryBuilder } from './query-builders/query-builder.ts';
+import { cockroachTableWithSchema } from './table.ts';
+import { CockroachViewBase } from './view-base.ts';
+
+export class DefaultViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
+	static readonly [entityKind]: string = 'CockroachDefaultViewBuilderCore';
+
+	declare readonly _: {
+		readonly name: TConfig['name'];
+		readonly columns: TConfig['columns'];
+	};
+
+	constructor(
+		protected name: TConfig['name'],
+		protected schema: string | undefined,
+	) {}
+}
+
+export class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{ name: TName }> {
+	static override readonly [entityKind]: string = 'CockroachViewBuilder';
+
+	as<TSelectedFields extends ColumnsSelection>(
+		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
+	): CockroachViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'cockroach'>> {
+		if (typeof qb === 'function') {
+			qb = qb(new QueryBuilder());
+		}
+		const selectionProxy = new SelectionProxyHandler<TSelectedFields>({
+			alias: this.name,
+			sqlBehavior: 'error',
+			sqlAliasedBehavior: 'alias',
+			replaceOriginalName: true,
+		});
+		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+		return new Proxy(
+			new CockroachView({
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: aliasedSelection,
+					query: qb.getSQL().inlineParams(),
+				},
+			}),
+			selectionProxy as any,
+		) as CockroachViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'cockroach'>>;
+	}
+}
+
+export class ManualViewBuilder<
+	TName extends string = string,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
+> extends DefaultViewBuilderCore<{ name: TName; columns: TColumns }> {
+	static override readonly [entityKind]: string = 'CockroachManualViewBuilder';
+
+	private columns: Record<string, CockroachColumn>;
+
+	constructor(
+		name: TName,
+		columns: TColumns,
+		schema: string | undefined,
+		casing: Casing | undefined,
+	) {
+		super(name, schema);
+		this.columns = getTableColumns(cockroachTableWithSchema(name, columns, undefined, schema, casing));
+	}
+
+	existing(): CockroachViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'cockroach'>> {
+		return new Proxy(
+			new CockroachView({
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: undefined,
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as CockroachViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'cockroach'>>;
+	}
+
+	as(query: SQL): CockroachViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'cockroach'>> {
+		return new Proxy(
+			new CockroachView({
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: query.inlineParams(),
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as CockroachViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'cockroach'>>;
+	}
+}
+
+export class MaterializedViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
+	static readonly [entityKind]: string = 'CockroachMaterializedViewBuilderCore';
+
+	declare _: {
+		readonly name: TConfig['name'];
+		readonly columns: TConfig['columns'];
+	};
+
+	constructor(
+		protected name: TConfig['name'],
+		protected schema: string | undefined,
+	) {}
+
+	protected config: {
+		withNoData?: boolean;
+	} = {};
+
+	withNoData(): this {
+		this.config.withNoData = true;
+		return this;
+	}
+}
+
+export class MaterializedViewBuilder<TName extends string = string>
+	extends MaterializedViewBuilderCore<{ name: TName }>
+{
+	static override readonly [entityKind]: string = 'CockroachMaterializedViewBuilder';
+
+	as<TSelectedFields extends ColumnsSelection>(
+		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
+	): CockroachMaterializedViewWithSelection<
+		TName,
+		false,
+		AddAliasToSelection<TSelectedFields, TName, 'cockroach'>
+	> {
+		if (typeof qb === 'function') {
+			qb = qb(new QueryBuilder());
+		}
+		const selectionProxy = new SelectionProxyHandler<TSelectedFields>({
+			alias: this.name,
+			sqlBehavior: 'error',
+			sqlAliasedBehavior: 'alias',
+			replaceOriginalName: true,
+		});
+		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+		return new Proxy(
+			new CockroachMaterializedView({
+				cockroachConfig: {
+					withNoData: this.config.withNoData,
+				},
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: aliasedSelection,
+					query: qb.getSQL().inlineParams(),
+				},
+			}),
+			selectionProxy as any,
+		) as CockroachMaterializedViewWithSelection<
+			TName,
+			false,
+			AddAliasToSelection<TSelectedFields, TName, 'cockroach'>
+		>;
+	}
+}
+
+export class ManualMaterializedViewBuilder<
+	TName extends string = string,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
+> extends MaterializedViewBuilderCore<{ name: TName; columns: TColumns }> {
+	static override readonly [entityKind]: string = 'CockroachManualMaterializedViewBuilder';
+
+	private columns: Record<string, CockroachColumn>;
+
+	constructor(
+		name: TName,
+		columns: TColumns,
+		schema: string | undefined,
+		casing: Casing | undefined,
+	) {
+		super(name, schema);
+		this.columns = getTableColumns(cockroachTableWithSchema(name, columns, undefined, schema, casing));
+	}
+
+	existing(): CockroachMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'cockroach'>> {
+		return new Proxy(
+			new CockroachMaterializedView({
+				cockroachConfig: {
+					withNoData: this.config.withNoData,
+				},
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: undefined,
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as CockroachMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'cockroach'>>;
+	}
+
+	as(query: SQL): CockroachMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'cockroach'>> {
+		return new Proxy(
+			new CockroachMaterializedView({
+				cockroachConfig: {
+					withNoData: this.config.withNoData,
+				},
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: query.inlineParams(),
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as CockroachMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'cockroach'>>;
+	}
+}
+
+export class CockroachView<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends CockroachViewBase<TName, TExisting, TSelectedFields> {
+	static override readonly [entityKind]: string = 'CockroachView';
+
+	constructor({ config }: {
+		config: {
+			name: TName;
+			schema: string | undefined;
+			selectedFields: ColumnsSelection;
+			query: SQL | undefined;
+		};
+	}) {
+		super(config);
+	}
+}
+
+export type CockroachViewWithSelection<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = CockroachView<TName, TExisting, TSelectedFields> & TSelectedFields;
+
+export const CockroachMaterializedViewConfig = Symbol.for('drizzle:CockroachMaterializedViewConfig');
+
+export class CockroachMaterializedView<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends CockroachViewBase<TName, TExisting, TSelectedFields> {
+	static override readonly [entityKind]: string = 'CockroachMaterializedView';
+
+	readonly [CockroachMaterializedViewConfig]: {
+		readonly withNoData?: boolean;
+	} | undefined;
+
+	constructor({ cockroachConfig, config }: {
+		cockroachConfig: {
+			withNoData: boolean | undefined;
+		} | undefined;
+		config: {
+			name: TName;
+			schema: string | undefined;
+			selectedFields: ColumnsSelection;
+			query: SQL | undefined;
+		};
+	}) {
+		super(config);
+		this[CockroachMaterializedViewConfig] = {
+			withNoData: cockroachConfig?.withNoData,
+		};
+	}
+}
+
+export type CockroachMaterializedViewWithSelection<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = CockroachMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
+
+/** @internal */
+export function cockroachViewWithSchema(
+	name: string,
+	selection: Record<string, ColumnBuilderBase> | undefined,
+	schema: string | undefined,
+	casing: Casing | undefined,
+): ViewBuilder | ManualViewBuilder {
+	if (selection) {
+		return new ManualViewBuilder(name, selection, schema, casing);
+	}
+	return new ViewBuilder(name, schema);
+}
+
+/** @internal */
+export function cockroachMaterializedViewWithSchema(
+	name: string,
+	selection: Record<string, ColumnBuilderBase> | undefined,
+	schema: string | undefined,
+	casing: Casing | undefined,
+): MaterializedViewBuilder | ManualMaterializedViewBuilder {
+	if (selection) {
+		return new ManualMaterializedViewBuilder(name, selection, schema, casing);
+	}
+	return new MaterializedViewBuilder(name, schema);
+}
+
+export interface CockroachViewFn {
+	<TName extends string>(name: TName): ViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, ColumnBuilderBase>>(
+		name: TName,
+		columns: TColumns,
+	): ManualViewBuilder<TName, TColumns>;
+}
+
+export interface CockroachMaterializedViewFn {
+	<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, ColumnBuilderBase>>(
+		name: TName,
+		columns: TColumns,
+	): ManualMaterializedViewBuilder<TName, TColumns>;
+}
+
+export function cockroachViewWithCasing(casing: Casing | undefined): CockroachViewFn {
+	return ((name, columns) => cockroachViewWithSchema(name, columns, undefined, casing)) as CockroachViewFn;
+}
+
+/** @internal */
+export function cockroachMaterializedViewWithCasing(casing: Casing | undefined): CockroachMaterializedViewFn {
+	return ((name, columns) =>
+		cockroachMaterializedViewWithSchema(name, columns, undefined, casing)) as CockroachMaterializedViewFn;
+}
+
+export const cockroachView = cockroachViewWithCasing(undefined);
+
+export const cockroachMaterializedView = cockroachMaterializedViewWithCasing(undefined);
+
+export function isCockroachView(obj: unknown): obj is CockroachView {
+	return is(obj, CockroachView);
+}
+
+export function isCockroachMaterializedView(obj: unknown): obj is CockroachMaterializedView {
+	return is(obj, CockroachMaterializedView);
+}
diff --git a/drizzle-orm/src/cockroach/driver.ts b/drizzle-orm/src/cockroach/driver.ts
new file mode 100644
index 0000000000..b34b926a57
--- /dev/null
+++ b/drizzle-orm/src/cockroach/driver.ts
@@ -0,0 +1,141 @@
+import pg, { type Pool, type PoolConfig } from 'pg';
+import * as V1 from '~/_relations.ts';
+import { CockroachDatabase } from '~/cockroach-core/db.ts';
+import { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { DefaultLogger } from '~/logger.ts';
+import { type DrizzleConfig, jitCompatCheck } from '~/utils.ts';
+import type { NodeCockroachClient, NodeCockroachQueryResultHKT } from './session.ts';
+import { NodeCockroachSession } from './session.ts';
+
+export interface CockroachDriverOptions {
+	logger?: Logger;
+	useJitMappers?: boolean;
+}
+
+export class NodeCockroachDriver {
+	static readonly [entityKind]: string = 'NodeCockroachDriver';
+
+	constructor(
+		private client: NodeCockroachClient,
+		private dialect: CockroachDialect,
+		private options: CockroachDriverOptions = {},
+	) {
+	}
+
+	createSession(
+		schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined,
+	): NodeCockroachSession<Record<string, unknown>, V1.TablesRelationalConfig> {
+		return new NodeCockroachSession(this.client, this.dialect, schema, {
+			logger: this.options.logger,
+			useJitMappers: this.options.useJitMappers,
+		});
+	}
+}
+
+export class NodeCockroachDatabase<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> extends CockroachDatabase<NodeCockroachQueryResultHKT, TSchema> {
+	static override readonly [entityKind]: string = 'NodeCockroachDatabase';
+}
+
+function construct<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TClient extends NodeCockroachClient = NodeCockroachClient,
+>(
+	client: TClient,
+	config: DrizzleConfig<TSchema> = {},
+): NodeCockroachDatabase<TSchema> & {
+	$client: TClient;
+} {
+	const dialect = new CockroachDialect();
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	let schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined;
+	if (config.schema) {
+		const tablesConfig = V1.extractTablesRelationalConfig(
+			config.schema,
+			V1.createTableRelationsHelpers,
+		);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap,
+		};
+	}
+
+	const driver = new NodeCockroachDriver(client, dialect, {
+		logger,
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	const session = driver.createSession(schema);
+	const db = new NodeCockroachDatabase(dialect, session, schema as any) as NodeCockroachDatabase<TSchema>;
+	(<any> db).$client = client;
+
+	return db as any;
+}
+
+export function drizzle<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TClient extends NodeCockroachClient = Pool,
+>(
+	...params:
+		| [
+			string,
+		]
+		| [
+			string,
+			DrizzleConfig<TSchema>,
+		]
+		| [
+			(
+				& DrizzleConfig<TSchema>
+				& ({
+					connection: string | PoolConfig;
+				} | {
+					client: TClient;
+				})
+			),
+		]
+): NodeCockroachDatabase<TSchema> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new pg.Pool({
+			connectionString: params[0],
+		});
+
+		return construct(instance, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	}
+
+	const { connection, client, ...drizzleConfig } = params[0] as (
+		& ({ connection?: PoolConfig | string; client?: TClient })
+		& DrizzleConfig<TSchema>
+	);
+
+	if (client) return construct(client, drizzleConfig);
+
+	const instance = typeof connection === 'string'
+		? new pg.Pool({
+			connectionString: connection,
+		})
+		: new pg.Pool(connection!);
+
+	return construct(instance, drizzleConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
+		config?: DrizzleConfig<TSchema>,
+	): NodeCockroachDatabase<TSchema> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/prisma/mysql/index.ts b/drizzle-orm/src/cockroach/index.ts
similarity index 100%
rename from drizzle-orm/src/prisma/mysql/index.ts
rename to drizzle-orm/src/cockroach/index.ts
diff --git a/drizzle-orm/src/cockroach/migrator.ts b/drizzle-orm/src/cockroach/migrator.ts
new file mode 100644
index 0000000000..d19aaf8f0c
--- /dev/null
+++ b/drizzle-orm/src/cockroach/migrator.ts
@@ -0,0 +1,11 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { NodeCockroachDatabase } from './driver.ts';
+
+export async function migrate<TSchema extends Record<string, unknown>>(
+	db: NodeCockroachDatabase<TSchema>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return await db.dialect.migrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/cockroach/session.ts b/drizzle-orm/src/cockroach/session.ts
new file mode 100644
index 0000000000..078f5a9f95
--- /dev/null
+++ b/drizzle-orm/src/cockroach/session.ts
@@ -0,0 +1,281 @@
+import type { Client, PoolClient, QueryArrayConfig, QueryConfig, QueryResult, QueryResultRow } from 'pg';
+import pg from 'pg';
+import type * as V1 from '~/_relations.ts';
+import type { CockroachDialect } from '~/cockroach-core/dialect.ts';
+import { CockroachTransaction } from '~/cockroach-core/index.ts';
+import type { SelectedFieldsOrdered } from '~/cockroach-core/query-builders/select.types.ts';
+import type {
+	CockroachQueryResultHKT,
+	CockroachTransactionConfig,
+	PreparedQueryConfig,
+} from '~/cockroach-core/session.ts';
+import { CockroachPreparedQuery, CockroachSession } from '~/cockroach-core/session.ts';
+import { entityKind } from '~/entity.ts';
+import { type Logger, NoopLogger } from '~/logger.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+import { type Assume, makeJitQueryMapper, mapResultRow, type RowsMapper } from '~/utils.ts';
+
+const { Pool, types } = pg;
+
+export type NodeCockroachClient = pg.Pool | PoolClient | Client;
+
+export class NodeCockroachPreparedQuery<T extends PreparedQueryConfig> extends CockroachPreparedQuery<T> {
+	static override readonly [entityKind]: string = 'NodeCockroachPreparedQuery';
+
+	private rawQueryConfig: QueryConfig;
+	private queryConfig: QueryArrayConfig;
+	private jitMapper?: RowsMapper<T['execute']>;
+
+	constructor(
+		private client: NodeCockroachClient,
+		queryString: string,
+		private params: unknown[],
+		private logger: Logger,
+		private fields: SelectedFieldsOrdered | undefined,
+		name: string | undefined,
+		private useJitMappers: boolean | undefined,
+		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+	) {
+		super({ sql: queryString, params });
+		this.rawQueryConfig = {
+			name,
+			text: queryString,
+			types: {
+				// @ts-ignore
+				getTypeParser: (typeId, format) => {
+					if (typeId === types.builtins.TIMESTAMPTZ) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.TIMESTAMP) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.DATE) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.INTERVAL) {
+						return (val: any) => val;
+					}
+					// numeric[]
+					if (typeId as number === 1231) {
+						return (val: any) => val;
+					}
+					// timestamp[]
+					if (typeId as number === 1115) {
+						return (val: any) => val;
+					}
+					// timestamp with timezone[]
+					if (typeId as number === 1185) {
+						return (val: any) => val;
+					}
+					// interval[]
+					if (typeId as number === 1187) {
+						return (val: any) => val;
+					}
+					// date[]
+					if (typeId as number === 1182) {
+						return (val: any) => val;
+					}
+					// @ts-ignore
+					return types.getTypeParser(typeId, format);
+				},
+			},
+		};
+		this.queryConfig = {
+			name,
+			text: queryString,
+			rowMode: 'array',
+			types: {
+				// @ts-ignore
+				getTypeParser: (typeId, format) => {
+					if (typeId === types.builtins.TIMESTAMPTZ) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.TIMESTAMP) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.DATE) {
+						return (val: any) => val;
+					}
+					if (typeId === types.builtins.INTERVAL) {
+						return (val: any) => val;
+					}
+					// numeric[]
+					if (typeId as number === 1231) {
+						return (val: any) => val;
+					}
+					// timestamp[]
+					if (typeId as number === 1115) {
+						return (val: any) => val;
+					}
+					// timestamp with timezone[]
+					if (typeId as number === 1185) {
+						return (val: any) => val;
+					}
+					// interval[]
+					if (typeId as number === 1187) {
+						return (val: any) => val;
+					}
+					// date[]
+					if (typeId as number === 1182) {
+						return (val: any) => val;
+					}
+					// @ts-ignore
+					return types.getTypeParser(typeId, format);
+				},
+			},
+		};
+	}
+
+	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
+		return tracer.startActiveSpan('drizzle.execute', async () => {
+			const params = fillPlaceholders(this.params, placeholderValues);
+
+			this.logger.logQuery(this.rawQueryConfig.text, params);
+
+			const { fields, rawQueryConfig: rawQuery, client, queryConfig: query, joinsNotNullableMap, customResultMapper } =
+				this;
+			if (!fields && !customResultMapper) {
+				return tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
+					span?.setAttributes({
+						'drizzle.query.name': rawQuery.name,
+						'drizzle.query.text': rawQuery.text,
+						'drizzle.query.params': JSON.stringify(params),
+					});
+					return client.query(rawQuery, params);
+				});
+			}
+
+			const result = await tracer.startActiveSpan('drizzle.driver.execute', (span) => {
+				span?.setAttributes({
+					'drizzle.query.name': query.name,
+					'drizzle.query.text': query.text,
+					'drizzle.query.params': JSON.stringify(params),
+				});
+				return client.query(query, params);
+			});
+
+			return tracer.startActiveSpan('drizzle.mapResponse', () => {
+				if (customResultMapper) {
+					return (customResultMapper as (rows: unknown[][]) => unknown)(result.rows);
+				}
+
+				return this.useJitMappers
+					? (this.jitMapper ??= makeJitQueryMapper(fields!, joinsNotNullableMap))(result.rows)
+					: result.rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
+			});
+		});
+	}
+
+	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
+		return tracer.startActiveSpan('drizzle.execute', () => {
+			const params = fillPlaceholders(this.params, placeholderValues);
+			this.logger.logQuery(this.rawQueryConfig.text, params);
+			return tracer.startActiveSpan('drizzle.driver.execute', (span) => {
+				span?.setAttributes({
+					'drizzle.query.name': this.rawQueryConfig.name,
+					'drizzle.query.text': this.rawQueryConfig.text,
+					'drizzle.query.params': JSON.stringify(params),
+				});
+				return this.client.query(this.rawQueryConfig, params).then((result) => result.rows);
+			});
+		});
+	}
+}
+
+export interface NodeCockroachSessionOptions {
+	logger?: Logger;
+	useJitMappers?: boolean;
+}
+
+export class NodeCockroachSession<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+> extends CockroachSession<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'NodeCockroachSession';
+
+	private logger: Logger;
+
+	constructor(
+		private client: NodeCockroachClient,
+		dialect: CockroachDialect,
+		private schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+		private options: NodeCockroachSessionOptions = {},
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		name: string | undefined,
+		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	): CockroachPreparedQuery<T> {
+		return new NodeCockroachPreparedQuery(
+			this.client,
+			query.sql,
+			query.params,
+			this.logger,
+			fields,
+			name,
+			this.options.useJitMappers,
+			customResultMapper,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>,
+		config?: CockroachTransactionConfig | undefined,
+	): Promise<T> {
+		const session = this.client instanceof Pool // oxlint-disable-line drizzle-internal/no-instanceof
+			? new NodeCockroachSession(await this.client.connect(), this.dialect, this.schema, this.options)
+			: this;
+		const tx = new NodeCockroachTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+		await tx.execute(sql`begin${config ? sql` ${tx.getTransactionConfigSQL(config)}` : undefined}`);
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql`commit`);
+			return result;
+		} catch (error) {
+			await tx.execute(sql`rollback`);
+			throw error;
+		} finally {
+			if (this.client instanceof Pool) { // oxlint-disable-line drizzle-internal/no-instanceof
+				(session.client as PoolClient).release();
+			}
+		}
+	}
+}
+
+export class NodeCockroachTransaction<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+> extends CockroachTransaction<NodeCockroachQueryResultHKT, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'NodeCockroachTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: NodeCockroachTransaction<TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new NodeCockroachTransaction<TFullSchema, TSchema>(
+			this.dialect,
+			this.session,
+			this.schema,
+			this.nestedIndex + 1,
+		);
+		await tx.execute(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
+
+export interface NodeCockroachQueryResultHKT extends CockroachQueryResultHKT {
+	type: QueryResult<Assume<this['row'], QueryResultRow>>;
+}
diff --git a/drizzle-orm/src/codecs.ts b/drizzle-orm/src/codecs.ts
new file mode 100644
index 0000000000..f4b0f92bdd
--- /dev/null
+++ b/drizzle-orm/src/codecs.ts
@@ -0,0 +1,141 @@
+import type { Column } from './column.ts';
+import { entityKind } from './entity.ts';
+import type { SQLChunk } from './sql/sql.ts';
+import type { PartialWithUndefined } from './utils.ts';
+
+export type NormalizeCodec = (value: any) => any;
+export type NormalizeArrayCodec = (value: any, arrayDimensions: number) => any;
+export type CastCodec = (name: SQLChunk) => SQLChunk;
+export type CastArrayCodec = (name: SQLChunk, arrayDimensions: number) => SQLChunk;
+export type CastParamCodec = (name: string, column: Column) => string;
+export type CastArrayParamCodec = (name: string, column: Column, arrayDimensions: number) => string;
+
+export interface Codec {
+	cast?: CastCodec | undefined;
+	castArray?: CastArrayCodec | undefined;
+	castInJson?: CastCodec | undefined;
+	castArrayInJson?: CastArrayCodec | undefined;
+	castParam?: CastParamCodec | undefined;
+	castArrayParam?: CastArrayParamCodec | undefined;
+	normalize?: NormalizeCodec | undefined;
+	normalizeArray?: NormalizeArrayCodec | undefined;
+	normalizeInJson?: NormalizeCodec | undefined;
+	normalizeArrayInJson?: NormalizeArrayCodec | undefined;
+	normalizeParam?: NormalizeCodec | undefined;
+	normalizeParamArray?: NormalizeArrayCodec | undefined;
+}
+
+export type Codecs<TTypeSet extends string = string> = PartialWithUndefined<Record<TTypeSet, Codec>>;
+
+export const noopCodecs: Codecs = {};
+
+const arrayToItemTypeCodecNameMap = {
+	cast: 'cast',
+	castArray: 'cast',
+	castInJson: 'castInJson',
+	castArrayInJson: 'castInJson',
+	castParam: 'castParam',
+	castArrayParam: 'castParam',
+	normalize: 'normalize',
+	normalizeArray: 'normalize',
+	normalizeInJson: 'normalizeInJson',
+	normalizeArrayInJson: 'normalizeInJson',
+	normalizeParam: 'normalizeParam',
+	normalizeParamArray: 'normalizeParam',
+} as const satisfies Record<keyof Codec, keyof Codec>;
+
+const itemToArrayTypeCodecNameMap = {
+	cast: 'castArray',
+	castArray: 'castArray',
+	castInJson: 'castArrayInJson',
+	castArrayInJson: 'castArrayInJson',
+	castParam: 'castArrayParam',
+	castArrayParam: 'castArrayParam',
+	normalize: 'normalizeArray',
+	normalizeArray: 'normalizeArray',
+	normalizeInJson: 'normalizeArrayInJson',
+	normalizeArrayInJson: 'normalizeArrayInJson',
+	normalizeParam: 'normalizeParamArray',
+	normalizeParamArray: 'normalizeParamArray',
+} as const satisfies Record<keyof Codec, keyof Codec>;
+
+export class CodecsCollection<TTypeSet extends string = string> {
+	static readonly [entityKind]: string = 'CodecsCollection';
+
+	constructor(protected resolveTypes: (type: string) => string, readonly codecs: Codecs<TTypeSet> = noopCodecs) {}
+
+	get<TCodecType extends keyof Codec>(
+		column: Column,
+		type: TCodecType,
+		override?: TTypeSet,
+	):
+		| Codec[typeof arrayToItemTypeCodecNameMap[TCodecType]]
+		| Codec[typeof itemToArrayTypeCodecNameMap[TCodecType]]
+	{
+		const sqlType = (override ?? column.codec) as TTypeSet | undefined;
+		if (!sqlType) return undefined;
+
+		const codecType = (<any> column).dimensions
+			? itemToArrayTypeCodecNameMap[type]
+			: arrayToItemTypeCodecNameMap[type];
+
+		return this.codecs[sqlType]?.[codecType];
+	}
+
+	apply<TCodecType extends keyof Codec>(
+		column: Column,
+		type: TCodecType,
+		value: Codec[TCodecType] extends ((v: infer TValue, ...rest: any[]) => any) ? TValue : unknown,
+		override?: TTypeSet,
+	): ReturnType<Exclude<Codec[TCodecType], undefined>> {
+		const sqlType = (override ?? column.codec) as TTypeSet | undefined;
+		if (!sqlType) return value as any;
+
+		const codecType = (<any> column).dimensions
+			? itemToArrayTypeCodecNameMap[type]
+			: arrayToItemTypeCodecNameMap[type];
+
+		const codec = this.codecs[sqlType]?.[codecType];
+		if (!codec) return value as any;
+
+		if (codecType === 'castParam' || codecType === 'castArrayParam') {
+			return (<CastParamCodec | CastArrayParamCodec> codec)(value as string, column, (<any> column).dimensions) as any;
+		}
+
+		return (<NormalizeCodec | NormalizeArrayCodec | CastCodec | CastArrayCodec> codec)(
+			value as any,
+			(<any> column).dimensions,
+		);
+	}
+}
+
+export function refineCodecs<TTypeSet extends string>(
+	source: Codecs<TTypeSet>,
+	extension: Codecs<TTypeSet> = {},
+): Codecs<TTypeSet> {
+	const keys = new Set<TTypeSet>([...Object.keys(source), ...Object.keys(extension)] as TTypeSet[]).values();
+	const result: Codecs<TTypeSet> = {};
+
+	for (const k of keys) {
+		if (!(k in extension)) {
+			result[k] = source[k] ? { ...source[k] } : undefined;
+			continue;
+		}
+
+		if (!(k in source) || (extension[k] === undefined)) {
+			result[k] = extension[k] ? { ...extension[k] } : undefined;
+			continue;
+		}
+
+		const innerKeys = new Set<keyof Codec>(
+			[...Object.keys(extension[k]), ...(Object.keys(source[k] ?? {}))] as (keyof Codec)[],
+		).values();
+
+		result[k] = {};
+		for (const ik of innerKeys) {
+			result[k][ik] = (ik in extension[k] ? extension[k][ik] : source[k]?.[ik]) as any;
+		}
+	}
+
+	return result;
+}
diff --git a/drizzle-orm/src/column-builder.ts b/drizzle-orm/src/column-builder.ts
index 1cc4c5ae1e..29ccd2c429 100644
--- a/drizzle-orm/src/column-builder.ts
+++ b/drizzle-orm/src/column-builder.ts
@@ -1,75 +1,172 @@
 import { entityKind } from '~/entity.ts';
-import type { Column } from './column.ts';
-import type { GelColumn, GelExtraConfigColumn } from './gel-core/index.ts';
+import type { CockroachColumn, ExtraConfigColumn as CockroachExtraConfigColumn } from './cockroach-core/index.ts';
+import type { Column, ColumnBaseConfig } from './column.ts';
+import type { MsSqlColumn } from './mssql-core/index.ts';
 import type { MySqlColumn } from './mysql-core/index.ts';
 import type { ExtraConfigColumn, PgColumn, PgSequenceOptions } from './pg-core/index.ts';
 import type { SingleStoreColumn } from './singlestore-core/index.ts';
 import type { SQL } from './sql/sql.ts';
 import type { SQLiteColumn } from './sqlite-core/index.ts';
-import type { Assume, Simplify } from './utils.ts';
+import type { Assume } from './utils.ts';
 
 export type ColumnDataType =
-	| 'string'
-	| 'number'
-	| 'boolean'
 	| 'array'
-	| 'json'
-	| 'date'
 	| 'bigint'
+	| 'boolean'
 	| 'custom'
+	| 'number'
+	| 'object'
+	| 'string';
+
+export type ColumnDataArrayConstraint =
+	| 'vector'
+	| 'int64vector'
+	| 'halfvector'
+	| 'basecolumn'
+	| 'point'
+	| 'geometry'
+	| 'line';
+
+export type ColumnDataBigIntConstraint = 'int64' | 'uint64';
+
+export type ColumnDataNumberConstraint =
+	| 'double'
+	| 'float'
+	| 'int8'
+	| 'int16'
+	| 'int24'
+	| 'int32'
+	| 'int53'
+	| 'udouble'
+	| 'ufloat'
+	| 'uint8'
+	| 'uint16'
+	| 'uint24'
+	| 'uint32'
+	| 'uint53'
+	| 'unsigned'
+	| 'year';
+
+export type ColumnDataObjectConstraint =
 	| 'buffer'
+	| 'date'
+	| 'geometry'
+	| 'json'
+	| 'line'
+	| 'point'
+	// Gel-specific
 	| 'dateDuration'
 	| 'duration'
-	| 'relDuration'
-	| 'localTime'
 	| 'localDate'
-	| 'localDateTime';
+	| 'localDateTime'
+	| 'localTime'
+	| 'relDuration';
 
-export type Dialect = 'pg' | 'mysql' | 'sqlite' | 'singlestore' | 'common' | 'gel';
+export type ColumnDataStringConstraint =
+	| 'binary'
+	| 'cidr'
+	| 'date'
+	| 'datetime'
+	| 'enum'
+	| 'inet'
+	| 'int64'
+	| 'interval'
+	| 'macaddr'
+	| 'macaddr8'
+	| 'numeric'
+	| 'sparsevec'
+	| 'time'
+	| 'timestamp'
+	| 'uint64'
+	| 'unumeric'
+	| 'uuid';
+
+export type ColumnDataConstraint =
+	| ColumnDataArrayConstraint
+	| ColumnDataBigIntConstraint
+	| ColumnDataNumberConstraint
+	| ColumnDataObjectConstraint
+	| ColumnDataStringConstraint;
+
+export type ColumnType =
+	| ColumnDataType
+	| `array ${ColumnDataArrayConstraint}`
+	| `bigint ${ColumnDataBigIntConstraint}`
+	| `number ${ColumnDataNumberConstraint}`
+	| `object ${ColumnDataObjectConstraint}`
+	| `string ${ColumnDataStringConstraint}`;
+
+export interface ColumnTypeData<
+	TType extends ColumnDataType = ColumnDataType,
+	TConstraint extends ColumnDataConstraint | undefined = ColumnDataConstraint | undefined,
+> {
+	type: TType;
+	constraint: TConstraint;
+}
+
+export type ExtractColumnTypeData<T extends ColumnType> = T extends
+	`${infer Type extends ColumnDataType} ${infer Constraint extends ColumnDataConstraint}`
+	? ColumnTypeData<Type, Constraint>
+	: ColumnTypeData<Assume<T, ColumnDataType>, undefined>;
+
+export function extractExtendedColumnType<TColumn extends Column>(
+	column: TColumn,
+): ExtractColumnTypeData<TColumn['_']['dataType']> {
+	const [type, constraint] = column.dataType.split(' ');
+
+	return { type, constraint } as any;
+}
+
+export type Dialect = 'pg' | 'mysql' | 'sqlite' | 'singlestore' | 'mssql' | 'common' | 'cockroach';
 
-export type GeneratedStorageMode = 'virtual' | 'stored';
+// TODO update description
+// 'virtual' | 'stored'  for postgres
+// 'stored' for mysql
+// 'virtual' | 'persisted' for mssql
+// We should remove this option from common Column and store it per dialect common
+// Was discussed with Andrew
+export type GeneratedStorageMode = 'virtual' | 'stored' | 'persisted';
 
 export type GeneratedType = 'always' | 'byDefault';
 
-export type GeneratedColumnConfig<TDataType> = {
+export interface GeneratedColumnConfig<TDataType> {
 	as: TDataType | SQL | (() => SQL);
 	type?: GeneratedType;
 	mode?: GeneratedStorageMode;
-};
+}
 
-export type GeneratedIdentityConfig = {
+export interface GeneratedIdentityConfig {
 	sequenceName?: string;
 	sequenceOptions?: PgSequenceOptions;
 	type: 'always' | 'byDefault';
-};
+}
 
-export interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
-	name: string;
+export interface ColumnBuilderBaseConfig<TDataType extends ColumnType> {
 	dataType: TDataType;
-	columnType: TColumnType;
 	data: unknown;
 	driverParam: unknown;
-	enumValues: string[] | undefined;
+	notNull?: boolean;
+	hasDefault?: boolean;
 }
 
 export type MakeColumnConfig<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType>,
 	TTableName extends string,
+	TDialect extends Dialect = 'common',
 	TData = T extends { $type: infer U } ? U : T['data'],
 > = {
-	name: T['name'];
+	name: string;
 	tableName: TTableName;
 	dataType: T['dataType'];
-	columnType: T['columnType'];
 	data: TData;
 	driverParam: T['driverParam'];
-	notNull: T extends { notNull: true } ? true : false;
-	hasDefault: T extends { hasDefault: true } ? true : false;
+	notNull: T['notNull'] extends true ? true : false;
+	hasDefault: T['hasDefault'] extends true ? true : false;
 	isPrimaryKey: T extends { isPrimaryKey: true } ? true : false;
 	isAutoincrement: T extends { isAutoincrement: true } ? true : false;
 	hasRuntimeDefault: T extends { hasRuntimeDefault: true } ? true : false;
-	enumValues: T['enumValues'];
-	baseColumn: T extends { baseBuilder: infer U extends ColumnBuilderBase } ? BuildColumn<TTableName, U, 'common'>
+	enumValues: T extends { enumValues: [string, ...string[]] } ? T['enumValues'] : undefined;
+	baseColumn: T extends { baseBuilder: infer U extends ColumnBuilderBase } ? BuildColumn<TTableName, U, TDialect>
 		: never;
 	identity: T extends { identity: 'always' } ? 'always' : T extends { identity: 'byDefault' } ? 'byDefault' : undefined;
 	generated: T extends { generated: infer G } ? unknown extends G ? undefined
@@ -78,28 +175,7 @@ export type MakeColumnConfig<
 		: undefined;
 } & {};
 
-export type ColumnBuilderTypeConfig<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> = Simplify<
-	& {
-		brand: 'ColumnBuilder';
-		name: T['name'];
-		dataType: T['dataType'];
-		columnType: T['columnType'];
-		data: T['data'];
-		driverParam: T['driverParam'];
-		notNull: T extends { notNull: infer U } ? U : boolean;
-		hasDefault: T extends { hasDefault: infer U } ? U : boolean;
-		enumValues: T['enumValues'];
-		identity: T extends { identity: infer U } ? U : unknown;
-		generated: T extends { generated: infer G } ? G extends undefined ? unknown : G : unknown;
-	}
-	& TTypeConfig
->;
-
-export type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
+export interface ColumnBuilderRuntimeConfig<TData> {
 	name: string;
 	keyAsName: boolean;
 	notNull: boolean;
@@ -115,86 +191,84 @@ export type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = ob
 	columnType: string;
 	generated: GeneratedColumnConfig<TData> | undefined;
 	generatedIdentity: GeneratedIdentityConfig | undefined;
-} & TRuntimeConfig;
+}
 
 export interface ColumnBuilderExtraConfig {
 	primaryKeyHasDefault?: boolean;
 }
 
-export type NotNull<T extends ColumnBuilderBase> = T & {
+export type NotNull<T> = T & {
 	_: {
 		notNull: true;
 	};
 };
 
-export type HasDefault<T extends ColumnBuilderBase> = T & {
+export type HasDefault<T> = T & {
 	_: {
 		hasDefault: true;
 	};
 };
 
-export type IsPrimaryKey<T extends ColumnBuilderBase> = T & {
+export type IsPrimaryKey<T> = T & {
 	_: {
 		isPrimaryKey: true;
+		notNull: true;
 	};
 };
 
-export type IsAutoincrement<T extends ColumnBuilderBase> = T & {
+export type IsAutoincrement<T> = T & {
 	_: {
 		isAutoincrement: true;
 	};
 };
 
-export type HasRuntimeDefault<T extends ColumnBuilderBase> = T & {
+export type HasRuntimeDefault<T> = T & {
 	_: {
 		hasRuntimeDefault: true;
 	};
 };
 
-export type $Type<T extends ColumnBuilderBase, TType> = T & {
+export type $Type<T, TType> = T & {
 	_: {
 		$type: TType;
 	};
 };
 
-export type HasGenerated<T extends ColumnBuilderBase, TGenerated extends {} = {}> = T & {
+export type HasGenerated<T, TGenerated = {}> = T & {
 	_: {
 		hasDefault: true;
 		generated: TGenerated;
 	};
 };
 
-export type IsIdentity<
-	T extends ColumnBuilderBase,
-	TType extends 'always' | 'byDefault',
-> = T & {
+export type IsIdentity<T, TType extends 'always' | 'byDefault'> = T & {
 	_: {
 		notNull: true;
 		hasDefault: true;
 		identity: TType;
 	};
 };
+
 export interface ColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
+	out T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
 > {
-	_: ColumnBuilderTypeConfig<T, TTypeConfig>;
+	_: T;
 }
 
 // To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
 export abstract class ColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	out T extends ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> implements ColumnBuilderBase<T, TTypeConfig> {
+> implements ColumnBuilderBase<T> {
 	static readonly [entityKind]: string = 'ColumnBuilder';
 
-	declare _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+	declare _: T;
 
-	protected config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>;
+	/** @internal */
+	protected config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
 
-	constructor(name: T['name'], dataType: T['dataType'], columnType: T['columnType']) {
+	constructor(name: string, dataType: ColumnType, columnType: string) {
 		this.config = {
 			name,
 			keyAsName: name === '',
@@ -208,7 +282,7 @@ export abstract class ColumnBuilder<
 			dataType,
 			columnType,
 			generated: undefined,
-		} as ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>;
+		} as ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig; // TODO: ??
 	}
 
 	/**
@@ -293,13 +367,13 @@ export abstract class ColumnBuilder<
 	 *
 	 * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
 	 */
-	primaryKey(): TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<NotNull<this>>>
-		: IsPrimaryKey<NotNull<this>>
+	primaryKey(): TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<this>>
+		: IsPrimaryKey<this>
 	{
 		this.config.primaryKey = true;
 		this.config.notNull = true;
-		return this as TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<NotNull<this>>>
-			: IsPrimaryKey<NotNull<this>>;
+		return this as TExtraConfig['primaryKeyHasDefault'] extends true ? IsPrimaryKey<HasDefault<this>>
+			: IsPrimaryKey<this>;
 	}
 
 	abstract generatedAlwaysAs(
@@ -310,9 +384,9 @@ export abstract class ColumnBuilder<
 	}>;
 
 	/** @internal Sets the name of the column to the key within the table definition if a name was not given. */
-	setName(name: string) {
+	setName(name: string, casingFn: (name: string) => string) {
 		if (this.config.name !== '') return;
-		this.config.name = name;
+		this.config.name = casingFn(name);
 	}
 }
 
@@ -320,60 +394,21 @@ export type BuildColumn<
 	TTableName extends string,
 	TBuilder extends ColumnBuilderBase,
 	TDialect extends Dialect,
-> = TDialect extends 'pg' ? PgColumn<
-		MakeColumnConfig<TBuilder['_'], TTableName>,
-		{},
-		Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
-	>
-	: TDialect extends 'mysql' ? MySqlColumn<
-			MakeColumnConfig<TBuilder['_'], TTableName>,
-			{},
-			Simplify<
-				Omit<
-					TBuilder['_'],
-					| keyof MakeColumnConfig<TBuilder['_'], TTableName>
-					| 'brand'
-					| 'dialect'
-					| 'primaryKeyHasDefault'
-					| 'mysqlColumnBuilderBrand'
-				>
-			>
-		>
-	: TDialect extends 'sqlite' ? SQLiteColumn<
-			MakeColumnConfig<TBuilder['_'], TTableName>,
-			{},
-			Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
-		>
-	: TDialect extends 'common' ? Column<
-			MakeColumnConfig<TBuilder['_'], TTableName>,
-			{},
-			Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
-		>
-	: TDialect extends 'singlestore' ? SingleStoreColumn<
-			MakeColumnConfig<TBuilder['_'], TTableName>,
-			{},
-			Simplify<
-				Omit<
-					TBuilder['_'],
-					| keyof MakeColumnConfig<TBuilder['_'], TTableName>
-					| 'brand'
-					| 'dialect'
-					| 'primaryKeyHasDefault'
-					| 'singlestoreColumnBuilderBrand'
-				>
-			>
-		>
-	: TDialect extends 'gel' ? GelColumn<
-			MakeColumnConfig<TBuilder['_'], TTableName>,
-			{},
-			Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>
-		>
-	: never;
+	TBuiltConfig extends ColumnBaseConfig<ColumnType> = MakeColumnConfig<TBuilder['_'], TTableName, TDialect>,
+> =
+	// TDialect extends 'pg' ? PgColumn<TBuiltConfig, {}>
+	TDialect extends 'mysql' ? MySqlColumn<TBuiltConfig, {}>
+		: TDialect extends 'mssql' ? MsSqlColumn<TBuiltConfig, {}>
+		: TDialect extends 'sqlite' ? SQLiteColumn<TBuiltConfig, {}>
+		: TDialect extends 'singlestore' ? SingleStoreColumn<TBuiltConfig, {}>
+		: TDialect extends 'cockroach' ? CockroachColumn<TBuiltConfig, {}>
+		: TDialect extends 'common' ? Column<TBuiltConfig, {}>
+		: never;
 
 export type BuildIndexColumn<
 	TDialect extends Dialect,
 > = TDialect extends 'pg' ? ExtraConfigColumn
-	: TDialect extends 'gel' ? GelExtraConfigColumn
+	: TDialect extends 'cockroach' ? CockroachExtraConfigColumn
 	: never;
 
 // TODO
@@ -389,11 +424,11 @@ export type BuildColumns<
 	TDialect extends Dialect,
 > =
 	& {
-		[Key in keyof TConfigMap]: BuildColumn<TTableName, {
-			_:
-				& Omit<TConfigMap[Key]['_'], 'name'>
-				& { name: TConfigMap[Key]['_']['name'] extends '' ? Assume<Key, string> : TConfigMap[Key]['_']['name'] };
-		}, TDialect>;
+		[Key in keyof TConfigMap]: BuildColumn<
+			TTableName,
+			TConfigMap[Key],
+			TDialect
+		>;
 	}
 	& {};
 
@@ -407,10 +442,19 @@ export type BuildExtraConfigColumns<
 	}
 	& {};
 
-export type ChangeColumnTableName<TColumn extends Column, TAlias extends string, TDialect extends Dialect> =
-	TDialect extends 'pg' ? PgColumn<MakeColumnConfig<TColumn['_'], TAlias>>
+export type ChangeColumnTableName<
+	TColumn extends Column,
+	TAlias extends string,
+	TDialect extends Dialect,
+> =
+	// TODO: optimise
+	TDialect extends 'pg' ? PgColumn<
+			TColumn['_']['dataType'],
+			Omit<TColumn['_'], 'tableName'> & { tableName: TAlias; insertType: unknown }
+		>
 		: TDialect extends 'mysql' ? MySqlColumn<MakeColumnConfig<TColumn['_'], TAlias>>
 		: TDialect extends 'singlestore' ? SingleStoreColumn<MakeColumnConfig<TColumn['_'], TAlias>>
 		: TDialect extends 'sqlite' ? SQLiteColumn<MakeColumnConfig<TColumn['_'], TAlias>>
-		: TDialect extends 'gel' ? GelColumn<MakeColumnConfig<TColumn['_'], TAlias>>
+		: TDialect extends 'mssql' ? MsSqlColumn<MakeColumnConfig<TColumn['_'], TAlias>>
+		: TDialect extends 'cockroach' ? CockroachColumn<MakeColumnConfig<TColumn['_'], TAlias>>
 		: never;
diff --git a/drizzle-orm/src/column-common.ts b/drizzle-orm/src/column-common.ts
new file mode 100644
index 0000000000..f3ac7c5bb1
--- /dev/null
+++ b/drizzle-orm/src/column-common.ts
@@ -0,0 +1 @@
+export const OriginalColumn = Symbol.for('drizzle:OriginalColumn');
diff --git a/drizzle-orm/src/column.ts b/drizzle-orm/src/column.ts
index 1396e3a612..584d069f07 100644
--- a/drizzle-orm/src/column.ts
+++ b/drizzle-orm/src/column.ts
@@ -1,73 +1,61 @@
 import type {
-	ColumnBuilderBaseConfig,
 	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
+	ColumnType,
 	GeneratedColumnConfig,
 	GeneratedIdentityConfig,
 } from './column-builder.ts';
+import { OriginalColumn } from './column-common.ts';
 import { entityKind } from './entity.ts';
-import type { DriverValueMapper, SQL, SQLWrapper } from './sql/sql.ts';
+import type { DriverValueDecoderFn, DriverValueEncoderFn, DriverValueMapper, SQL, SQLWrapper } from './sql/sql.ts';
 import type { Table } from './table.ts';
 import type { Update } from './utils.ts';
 
-export interface ColumnBaseConfig<
-	TDataType extends ColumnDataType,
-	TColumnType extends string,
-> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+export type Columns = Record<string, Column<any>>;
+
+export interface ColumnBaseConfig<TDataType extends ColumnType> {
+	name: string;
+	dataType: TDataType;
 	tableName: string;
 	notNull: boolean;
 	hasDefault: boolean;
 	isPrimaryKey: boolean;
 	isAutoincrement: boolean;
 	hasRuntimeDefault: boolean;
-}
-
-export type ColumnTypeConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = T & {
-	brand: 'Column';
-	tableName: T['tableName'];
-	name: T['name'];
-	dataType: T['dataType'];
-	columnType: T['columnType'];
-	data: T['data'];
-	driverParam: T['driverParam'];
-	notNull: T['notNull'];
-	hasDefault: T['hasDefault'];
-	isPrimaryKey: T['isPrimaryKey'];
-	isAutoincrement: T['isAutoincrement'];
-	hasRuntimeDefault: T['hasRuntimeDefault'];
-	enumValues: T['enumValues'];
-	baseColumn: T extends { baseColumn: infer U } ? U : unknown;
-	generated: GeneratedColumnConfig<T['data']> | undefined;
+	data: unknown;
+	driverParam: unknown;
+	enumValues: string[] | undefined;
+	generated: unknown;
 	identity: undefined | 'always' | 'byDefault';
-} & TTypeConfig;
+}
 
-export type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<
-	TData,
-	TRuntimeConfig
->;
+const noop: DriverValueDecoderFn<any, any> | DriverValueEncoderFn<any, any> = (v) => v;
+noop.isNoop = true;
 
 export interface Column<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	out T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TRuntimeConfig extends object = object,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TTypeConfig extends object = object,
+	out TRuntimeConfig extends object = object,
 > extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
 	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+	// `as` runtime implementation is defined in 'alias.ts'
+	as(alias: string): this;
 }
+
 /*
 	`Column` only accepts a full `ColumnConfig` as its generic.
 	To infer parts of the config, use `AnyColumn` that accepts a partial config.
 	See `GetColumnData` for example usage of inferring.
 */
 export abstract class Column<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
+	out T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
+	out TRuntimeConfig extends object = object,
 > implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
 	static readonly [entityKind]: string = 'Column';
 
-	declare readonly _: ColumnTypeConfig<T, TTypeConfig>;
+	declare readonly _: T;
+
+	/** @internal */
+	readonly codec?: string;
 
 	readonly name: string;
 	readonly keyAsName: boolean;
@@ -81,19 +69,33 @@ export abstract class Column<
 	readonly uniqueName: string | undefined;
 	readonly uniqueType: string | undefined;
 	readonly dataType: T['dataType'];
-	readonly columnType: T['columnType'];
+	readonly columnType: string;
 	readonly enumValues: T['enumValues'] = undefined;
 	readonly generated: GeneratedColumnConfig<T['data']> | undefined = undefined;
 	readonly generatedIdentity: GeneratedIdentityConfig | undefined = undefined;
+	readonly length: number | undefined;
+	readonly isLengthExact: boolean | undefined;
+	readonly isAlias: boolean;
+
+	/** @internal */
+	protected config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
 
-	protected config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>;
+	/** @internal */
+	readonly table: Table;
+
+	/** @internal */
+	protected onInit(): void {}
 
 	constructor(
-		readonly table: Table,
-		config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>,
+		table: Table,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
 	) {
 		this.config = config;
+		this.onInit();
+		this.table = table;
+
 		this.name = config.name;
+		this.isAlias = false;
 		this.keyAsName = config.keyAsName;
 		this.notNull = config.notNull;
 		this.default = config.default;
@@ -108,31 +110,40 @@ export abstract class Column<
 		this.columnType = config.columnType;
 		this.generated = config.generated;
 		this.generatedIdentity = config.generatedIdentity;
+		this.length = (<{ length?: number }> config)['length'];
+		this.isLengthExact = (<{ isLengthExact?: boolean }> config)['isLengthExact'];
 	}
 
 	abstract getSQLType(): string;
 
-	mapFromDriverValue(value: unknown): unknown {
-		return value;
-	}
+	mapFromDriverValue = noop;
+
+	mapToDriverValue = noop;
 
-	mapToDriverValue(value: unknown): unknown {
-		return value;
+	// TODO: Revisit
+	/** @internal */
+	postBuild() {
+		return this;
 	}
 
-	// ** @internal */
+	/** @internal */
 	shouldDisableInsert(): boolean {
 		return this.config.generated !== undefined && this.config.generated.type !== 'byDefault';
 	}
+
+	/** @internal */
+	[OriginalColumn](): this {
+		return this;
+	}
 }
 
 export type UpdateColConfig<
-	T extends ColumnBaseConfig<ColumnDataType, string>,
-	TUpdate extends Partial<ColumnBaseConfig<ColumnDataType, string>>,
+	T extends ColumnBaseConfig<ColumnType>,
+	TUpdate extends Partial<ColumnBaseConfig<ColumnType>>,
 > = Update<T, TUpdate>;
 
-export type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+export type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = Column<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
 >;
 
 export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> =
@@ -146,3 +157,7 @@ export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | '
 export type InferColumnsDataTypes<TColumns extends Record<string, Column>> = {
 	[Key in keyof TColumns]: GetColumnData<TColumns[Key], 'query'>;
 };
+
+export function getColumnTable<TTable extends Table<any> = Table<any>>(column: Column<any>): TTable {
+	return column.table as TTable;
+}
diff --git a/drizzle-orm/src/d1/driver.ts b/drizzle-orm/src/d1/driver.ts
index 1a688a3f04..35bba15259 100644
--- a/drizzle-orm/src/d1/driver.ts
+++ b/drizzle-orm/src/d1/driver.ts
@@ -3,31 +3,28 @@ import type { D1Database as MiniflareD1Database } from '@miniflare/d1';
 import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig, IfNotImported } from '~/utils.ts';
-import { SQLiteD1Session } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import type { IfNotImported } from '~/utils.ts';
+import { type D1RunResult, SQLiteD1Session } from './session.ts';
 
 export type AnyD1Database = IfNotImported<
 	D1Database,
 	MiniflareD1Database,
-	D1Database | IfNotImported<MiniflareD1Database, never, MiniflareD1Database>
+	| D1Database
+	| IfNotImported<D1DatabaseSession, never, D1DatabaseSession>
+	| IfNotImported<MiniflareD1Database, never, MiniflareD1Database>
 >;
 
-export class DrizzleD1Database<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'async', D1Result, TSchema> {
+export class DrizzleD1Database<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', D1RunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'D1Database';
 
 	/** @internal */
-	declare readonly session: SQLiteD1Session<TSchema, ExtractTablesWithRelations<TSchema>>;
+	declare readonly session: SQLiteD1Session<TRelations>;
 
 	async batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
@@ -37,15 +34,15 @@ export class DrizzleD1Database<
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends AnyD1Database = AnyD1Database,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): DrizzleD1Database<TSchema> & {
+	config: Omit<DrizzleSQLiteConfig<TRelations>, 'jit'> = {},
+): DrizzleD1Database<TRelations> & {
 	$client: TClient;
 } {
-	const dialect = new SQLiteAsyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect();
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -53,21 +50,18 @@ export function drizzle<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new SQLiteD1Session(client as D1Database, dialect, schema, { logger, cache: config.cache });
-	const db = new DrizzleD1Database('async', dialect, session, schema) as DrizzleD1Database<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SQLiteD1Session(client as D1Database, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new DrizzleD1Database(
+		'async',
+		dialect,
+		session,
+		relations,
+		true,
+	);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
diff --git a/drizzle-orm/src/d1/migrator.ts b/drizzle-orm/src/d1/migrator.ts
index 2259516bf8..c07f4e04ef 100644
--- a/drizzle-orm/src/d1/migrator.ts
+++ b/drizzle-orm/src/d1/migrator.ts
@@ -1,46 +1,78 @@
-import type { MigrationConfig } from '~/migrator.ts';
+import type { MigrationConfig, MigratorInitFailResponse } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeAsyncIfNeeded } from '~/up-migrations/sqlite.ts';
 import type { DrizzleD1Database } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: DrizzleD1Database<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: DrizzleD1Database<TRelations>,
 	config: MigrationConfig,
-) {
+): Promise<void | MigratorInitFailResponse> {
 	const migrations = readMigrationFiles(config);
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
 
-	const migrationTableCreate = sql`
+	const { newDb } = await upgradeAsyncIfNeeded(migrationsTable, db, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-			id SERIAL PRIMARY KEY,
+			id INTEGER PRIMARY KEY,
 			hash text NOT NULL,
-			created_at numeric
+			created_at numeric,
+			name text,
+			applied_at TEXT
 		)
 	`;
-	await db.session.run(migrationTableCreate);
+		await db.session.run(migrationTableCreate);
+	}
 
-	const dbMigrations = await db.values<[number, string, string]>(
-		sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
+	const dbMigrations = await db.all<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
 	);
 
-	const lastDbMigration = dbMigrations[0] ?? undefined;
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
 
-	const statementToBatch = [];
+		const [migration] = migrations;
 
-	for (const migration of migrations) {
-		if (!lastDbMigration || Number(lastDbMigration[2])! < migration.folderMillis) {
-			for (const stmt of migration.sql) {
-				statementToBatch.push(db.run(sql.raw(stmt)));
-			}
-
-			statementToBatch.push(
-				db.run(
-					sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${
-						sql.raw(`'${migration.hash}'`)
-					}, ${sql.raw(`${migration.folderMillis}`)})`,
-				),
-			);
+		if (!migration) return;
+
+		await db.run(
+			sql`INSERT INTO ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`
+				.inlineParams(),
+		);
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const statementToBatch = [];
+	for (const migration of migrationsToRun) {
+		for (const stmt of migration.sql) {
+			statementToBatch.push(db.run(sql.raw(stmt)));
 		}
+
+		statementToBatch.push(
+			db.run(
+				sql`INSERT INTO ${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+					new Date().toISOString()
+				})`
+					.inlineParams(),
+			),
+		);
 	}
 
 	if (statementToBatch.length > 0) {
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index 363ea4a9a7..7f1cab5ac9 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -4,86 +4,109 @@ import type { BatchItem } from '~/batch.ts';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { PreparedQuery } from '~/session.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SQLiteExecuteMethod,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
 
 export interface SQLiteD1SessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
+export type D1RunResult = D1Result;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class SQLiteD1Session<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'async', D1Result, TFullSchema, TSchema> {
+export class SQLiteD1Session<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', D1RunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SQLiteD1Session';
 
 	private logger: Logger;
 	private cache: Cache;
 
 	constructor(
-		private client: D1Database,
-		dialect: SQLiteAsyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private client: D1Database | D1DatabaseSession,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
 		private options: SQLiteD1SessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'async');
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
 	): D1PreparedQuery {
-		const stmt = this.client.prepare(query.sql);
+		let stmt: D1PreparedStatement;
+		try {
+			stmt = this.client.prepare(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) => {
+				if (mode === 'arrays') return stmt.bind(...params).raw();
+				return stmt.bind(...params).all().then(({ results }) => results);
+			},
+			get: (params) => {
+				if (mode === 'arrays') return stmt.bind(...params).raw().then((rows) => rows[0]);
+				return stmt.bind(...params).first();
+			},
+			run: (params) => {
+				return stmt.bind(...params).run();
+			},
+			values: (params) => {
+				return stmt.bind(...params).raw();
+			},
+		};
 		return new D1PreparedQuery(
 			stmt,
+			'async',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
 	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
-		const preparedQueries: PreparedQuery[] = [];
+		const preparedQueries: SQLiteAsyncPreparedQuery<any>[] = [];
 		const builtQueries: D1PreparedStatement[] = [];
 
 		for (const query of queries) {
-			const preparedQuery = query._prepare();
+			const preparedQuery = query._prepare() as D1PreparedQuery<any>;
 			const builtQuery = preparedQuery.getQuery();
 			preparedQueries.push(preparedQuery);
 			if (builtQuery.params.length > 0) {
-				builtQueries.push((preparedQuery as D1PreparedQuery).stmt.bind(...builtQuery.params));
+				builtQueries.push((preparedQuery as D1PreparedQuery<any>).stmt.bind(...builtQuery.params));
 			} else {
 				const builtQuery = preparedQuery.getQuery();
 				builtQueries.push(
@@ -93,26 +116,33 @@ export class SQLiteD1Session<
 		}
 
 		const batchResults = await this.client.batch<any>(builtQueries);
-		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
-	}
+		return batchResults.map((result, i) => {
+			const { executeMethod, mapper, mode } = preparedQueries[i]!;
 
-	override extractRawAllValueFromBatchResult(result: unknown): unknown {
-		return (result as D1Result).results;
-	}
+			if (executeMethod === 'run') return result;
 
-	override extractRawGetValueFromBatchResult(result: unknown): unknown {
-		return (result as D1Result).results[0];
-	}
+			let values: any = result.results;
+			if (executeMethod === 'values') return d1ToRawMapping(values);
+			if (executeMethod === 'get') {
+				if (!values[0]) return;
 
-	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
-		return d1ToRawMapping((result as D1Result).results);
+				if (!mapper) return mode === 'arrays' ? d1ToRawMapping([values[0]])[0] : values[0];
+
+				return mapper(mode === 'arrays' ? d1ToRawMapping([values[0]]) : [values[0]])[0];
+			}
+
+			values = mode === 'arrays' ? d1ToRawMapping(values) : values;
+			if (!mapper) return values;
+
+			return mapper(values);
+		});
 	}
 
 	override async transaction<T>(
-		transaction: (tx: D1Transaction<TFullSchema, TSchema>) => T | Promise<T>,
+		transaction: (tx: D1Transaction<TRelations>) => T | Promise<T>,
 		config?: SQLiteTransactionConfig,
 	): Promise<T> {
-		const tx = new D1Transaction('async', this.dialect, this, this.schema);
+		const tx = new D1Transaction('async', this.dialect, this, this.relations, undefined, true);
 		await this.run(sql.raw(`begin${config?.behavior ? ' ' + config.behavior : ''}`));
 		try {
 			const result = await transaction(tx);
@@ -125,15 +155,23 @@ export class SQLiteD1Session<
 	}
 }
 
-export class D1Transaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'async', D1Result, TFullSchema, TSchema> {
+export class D1Transaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', D1RunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'D1Transaction';
 
-	override async transaction<T>(transaction: (tx: D1Transaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: D1Transaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new D1Transaction('async', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new D1Transaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+			this.forbidJsonb,
+		);
 		await this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = await transaction(tx);
@@ -161,129 +199,46 @@ function d1ToRawMapping(results: any) {
 	return rows;
 }
 
-export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
+export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLiteAsyncPreparedQuery<
 	{ type: 'async'; run: D1Response; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
 > {
 	static override readonly [entityKind]: string = 'D1PreparedQuery';
 
-	/** @internal */
-	customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown;
-
 	/** @internal */
 	fields?: SelectedFieldsOrdered;
 
 	/** @internal */
-	stmt: D1PreparedStatement;
+	readonly stmt: D1PreparedStatement;
 
 	constructor(
 		stmt: D1PreparedStatement,
+		resultKind: 'sync' | 'async',
+		executeMethod: SQLiteExecuteMethod = 'all',
+		executors: SQLiteQueryExecutors<'async'>,
 		query: Query,
-		private logger: Logger,
-		cache: Cache,
+		mapper: ((rows: any[]) => any) | undefined,
+		mode: 'arrays' | 'objects' | 'raw',
+		logger: Logger,
+		cache: Cache | undefined,
 		queryMetadata: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		} | undefined,
 		cacheConfig: WithCacheConfig | undefined,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
 	) {
-		super('async', executeMethod, query, cache, queryMetadata, cacheConfig);
-		this.customResultMapper = customResultMapper;
-		this.fields = fields;
-		this.stmt = stmt;
-	}
-
-	async run(placeholderValues?: Record<string, unknown>): Promise<D1Response> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			return this.stmt.bind(...params).run();
-		});
-	}
-
-	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, query, logger, stmt, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return await this.queryWithCache(query.sql, params, async () => {
-				return stmt.bind(...params).all().then(({ results }) => this.mapAllResult(results!));
-			});
-		}
-
-		const rows = await this.values(placeholderValues);
-
-		return this.mapAllResult(rows);
-	}
-
-	override mapAllResult(rows: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			rows = d1ToRawMapping((rows as D1Result).results);
-		}
-
-		if (!this.fields && !this.customResultMapper) {
-			return rows;
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper(rows as unknown[][]);
-		}
-
-		return (rows as unknown[][]).map((row) => mapResultRow(this.fields!, row, this.joinsNotNullableMap));
-	}
-
-	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return await this.queryWithCache(query.sql, params, async () => {
-				return stmt.bind(...params).all().then(({ results }) => results![0]);
-			});
-		}
-
-		const rows = await this.values(placeholderValues);
-
-		if (!rows[0]) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-
-		return mapResultRow(fields!, rows[0], joinsNotNullableMap);
-	}
-
-	override mapGetResult(result: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			result = d1ToRawMapping((result as D1Result).results)[0];
-		}
-
-		if (!this.fields && !this.customResultMapper) {
-			return result;
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper([result as unknown[]]) as T['all'];
-		}
-
-		return mapResultRow(this.fields!, result as unknown[], this.joinsNotNullableMap);
-	}
-
-	async values<T extends any[] = unknown[]>(placeholderValues?: Record<string, unknown>): Promise<T[]> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			return this.stmt.bind(...params).raw();
-		});
-	}
+		super(
+			resultKind,
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			logger,
+			cache,
+			queryMetadata,
+			cacheConfig,
+		);
 
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
+		this.stmt = stmt;
 	}
 }
diff --git a/drizzle-orm/src/durable-sqlite/driver.ts b/drizzle-orm/src/durable-sqlite/driver.ts
index 0be110084b..d8aa99bb6b 100644
--- a/drizzle-orm/src/durable-sqlite/driver.ts
+++ b/drizzle-orm/src/durable-sqlite/driver.ts
@@ -1,37 +1,31 @@
 /// <reference types="@cloudflare/workers-types" />
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { SQLiteDOSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { type DurableSQLiteRunResult, SQLiteDOSession } from './session.ts';
 
-export class DrizzleSqliteDODatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'sync', SqlStorageCursor<Record<string, SqlStorageValue>>, TSchema> {
+export class DrizzleSqliteDODatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'sync', DurableSQLiteRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'DrizzleSqliteDODatabase';
 
 	/** @internal */
-	declare readonly session: SQLiteDOSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+	declare readonly session: SQLiteDOSession<TRelations>;
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends DurableObjectStorage = DurableObjectStorage,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): DrizzleSqliteDODatabase<TSchema> & {
+	config: Omit<DrizzleSQLiteConfig<TRelations>, 'jit'> = {},
+): DrizzleSqliteDODatabase<TRelations> & {
 	$client: TClient;
 } {
-	const dialect = new SQLiteSyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect();
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -39,21 +33,17 @@ export function drizzle<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new SQLiteDOSession(client as DurableObjectStorage, dialect, schema, { logger });
-	const db = new DrizzleSqliteDODatabase('sync', dialect, session, schema) as DrizzleSqliteDODatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SQLiteDOSession(client as DurableObjectStorage, dialect, relations, {
+		logger,
+	});
+	const db = new DrizzleSqliteDODatabase(
+		'sync',
+		dialect,
+		session,
+		relations,
+		true,
+	);
 	(<any> db).$client = client;
 
 	return db as any;
diff --git a/drizzle-orm/src/durable-sqlite/migrator.ts b/drizzle-orm/src/durable-sqlite/migrator.ts
index 8410b2900f..5f1e3fc1d6 100644
--- a/drizzle-orm/src/durable-sqlite/migrator.ts
+++ b/drizzle-orm/src/durable-sqlite/migrator.ts
@@ -1,22 +1,25 @@
-import type { MigrationMeta } from '~/migrator.ts';
+import type { MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { formatToMillis, getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/index.ts';
+import { upgradeSyncIfNeeded } from '~/up-migrations/sqlite.ts';
 import type { DrizzleSqliteDODatabase } from './driver.ts';
 
 interface MigrationConfig {
-	journal: {
-		entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
-	};
 	migrations: Record<string, string>;
+	/** @internal */
+	init?: boolean;
 }
 
-function readMigrationFiles({ journal, migrations }: MigrationConfig): MigrationMeta[] {
+function readMigrationFiles({ migrations }: MigrationConfig): MigrationMeta[] {
 	const migrationQueries: MigrationMeta[] = [];
 
-	for (const journalEntry of journal.entries) {
-		const query = migrations[`m${journalEntry.idx.toString().padStart(4, '0')}`];
+	const sortedMigrations = Object.keys(migrations).sort();
 
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
 		if (!query) {
-			throw new Error(`Missing migration: ${journalEntry.tag}`);
+			throw new Error(`Missing migration: ${key}`);
 		}
 
 		try {
@@ -24,59 +27,91 @@ function readMigrationFiles({ journal, migrations }: MigrationConfig): Migration
 				return it;
 			});
 
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
 			migrationQueries.push({
 				sql: result,
-				bps: journalEntry.breakpoints,
-				folderMillis: journalEntry.when,
+				bps: true,
+				folderMillis: migrationDate,
 				hash: '',
+				name: key,
 			});
 		} catch {
-			throw new Error(`Failed to parse migration: ${journalEntry.tag}`);
+			throw new Error(`Failed to parse migration: ${key}`);
 		}
 	}
 
 	return migrationQueries;
 }
 
-export async function migrate<
-	TSchema extends Record<string, unknown>,
->(
-	db: DrizzleSqliteDODatabase<TSchema>,
+export function migrate<TRelations extends AnyRelations>(
+	db: DrizzleSqliteDODatabase<TRelations>,
 	config: MigrationConfig,
-): Promise<void> {
+): void | MigratorInitFailResponse {
 	const migrations = readMigrationFiles(config);
 
-	db.transaction((tx) => {
+	return db.transaction((tx) => {
 		try {
 			const migrationsTable = '__drizzle_migrations';
 
-			const migrationTableCreate = sql`
+			const { newDb } = upgradeSyncIfNeeded(migrationsTable, db.session, migrations);
+
+			if (newDb) {
+				const migrationTableCreate = sql`
 				CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-					id SERIAL PRIMARY KEY,
+					id INTEGER PRIMARY KEY,
 					hash text NOT NULL,
-					created_at numeric
+					created_at numeric,
+					name text,
+					applied_at TEXT
 				)
 			`;
-			db.run(migrationTableCreate);
-
-			const dbMigrations = db.values<[number, string, string]>(
-				sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
-			);
-
-			const lastDbMigration = dbMigrations[0] ?? undefined;
-
-			for (const migration of migrations) {
-				if (!lastDbMigration || Number(lastDbMigration[2])! < migration.folderMillis) {
-					for (const stmt of migration.sql) {
-						db.run(sql.raw(stmt));
-					}
-					db.run(
-						sql`INSERT INTO ${
-							sql.identifier(migrationsTable)
-						} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
-					);
+				db.run(migrationTableCreate);
+			}
+
+			const dbMigrations = (db.values<[number, string, string, string | null]>(
+				sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
+			)).map(([id, hash, created_at, name]) => ({ id, hash, created_at, name }));
+
+			if (config.init) {
+				if (dbMigrations.length) {
+					return { exitCode: 'databaseMigrations' as const };
+				}
+
+				if (migrations.length > 1) {
+					return { exitCode: 'localMigrations' as const };
 				}
+
+				const [migration] = migrations;
+
+				if (!migration) return;
+
+				db.run(
+					sql`insert into ${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+						new Date().toISOString()
+					})`,
+				);
+
+				return;
 			}
+
+			const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					db.run(sql.raw(stmt));
+				}
+				db.run(
+					sql`INSERT INTO ${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name", "applied_at") VALUES(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+						new Date().toISOString()
+					})`,
+				);
+			}
+
+			return;
 		} catch (error: any) {
 			tx.rollback();
 			throw error;
diff --git a/drizzle-orm/src/durable-sqlite/session.ts b/drizzle-orm/src/durable-sqlite/session.ts
index 98c5918713..0b2bbe43b6 100644
--- a/drizzle-orm/src/durable-sqlite/session.ts
+++ b/drizzle-orm/src/durable-sqlite/session.ts
@@ -1,18 +1,18 @@
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/sql.ts';
-import { type SQLiteSyncDialect, SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
 import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	SQLiteSession,
-	type SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery as PreparedQueryBase } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/index.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 
 export interface SQLiteDOSessionOptions {
 	logger?: Logger;
@@ -20,163 +20,120 @@ export interface SQLiteDOSessionOptions {
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class SQLiteDOSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends SQLiteSession<
-		'sync',
-		SqlStorageCursor<Record<string, SqlStorageValue>>,
-		TFullSchema,
-		TSchema
-	>
-{
+export type DurableSQLiteRunResult = SqlStorageCursor<Record<string, SqlStorageValue>>;
+
+export class SQLiteDOSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<
+	'sync',
+	DurableSQLiteRunResult,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'SQLiteDOSession';
 
 	private logger: Logger;
 
 	constructor(
 		private client: DurableObjectStorage,
-		dialect: SQLiteSyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: SQLiteDOSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: SQLiteDOSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'sync');
 		this.logger = options.logger ?? new NoopLogger();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
-	): SQLiteDOPreparedQuery<T> {
-		return new SQLiteDOPreparedQuery(
-			this.client,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+	): SQLiteAsyncPreparedQuery<T & { run: DurableSQLiteRunResult }> {
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				const res = params.length > 0
+					? this.client.sql.exec(query.sql, ...params)
+					: this.client.sql.exec(query.sql);
+
+				if (mode === 'objects') return res.toArray();
+				// @ts-ignore .raw().toArray() exists
+				return res.raw().toArray();
+			},
+			get: (params) => {
+				const res = params.length > 0
+					? this.client.sql.exec(query.sql, ...params)
+					: this.client.sql.exec(query.sql);
+
+				if (mode === 'objects') return res.one();
+
+				return res.raw().next().value;
+			},
+			run: (params) => {
+				return params.length > 0
+					? this.client.sql.exec(query.sql, ...params)
+					: this.client.sql.exec(query.sql);
+			},
+			values: (params) => {
+				const res = params.length > 0
+					? this.client.sql.exec(query.sql, ...params)
+					: this.client.sql.exec(query.sql);
+
+				// @ts-ignore .raw().toArray() exists
+				return res.raw().toArray();
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+			undefined,
+			queryMetadata,
+			undefined,
 		);
 	}
 
 	override transaction<T>(
 		transaction: (
-			tx: SQLiteTransaction<'sync', SqlStorageCursor<Record<string, SqlStorageValue>>, TFullSchema, TSchema>,
+			tx: SQLiteAsyncTransaction<
+				'sync',
+				DurableSQLiteRunResult,
+				TRelations
+			>,
 		) => T,
 		_config?: SQLiteTransactionConfig,
 	): T {
-		const tx = new SQLiteDOTransaction('sync', this.dialect, this, this.schema);
-		this.client.transactionSync(() => {
-			transaction(tx);
-		});
-		return {} as any;
+		const tx = new SQLiteDOTransaction('sync', this.dialect, this, this.relations, undefined, true);
+		return this.client.transactionSync(() => transaction(tx));
 	}
 }
 
-export class SQLiteDOTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends SQLiteTransaction<
-		'sync',
-		SqlStorageCursor<Record<string, SqlStorageValue>>,
-		TFullSchema,
-		TSchema
-	>
+export class SQLiteDOTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'sync', DurableSQLiteRunResult, TRelations>
 {
 	static override readonly [entityKind]: string = 'SQLiteDOTransaction';
 
-	override transaction<T>(transaction: (tx: SQLiteDOTransaction<TFullSchema, TSchema>) => T): T {
-		const tx = new SQLiteDOTransaction('sync', this.dialect, this.session, this.schema, this.nestedIndex + 1);
-		this.session.transaction(() => transaction(tx));
-
-		return {} as any;
-	}
-}
-
-export class SQLiteDOPreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<{
-	type: 'sync';
-	run: void;
-	all: T['all'];
-	get: T['get'];
-	values: T['values'];
-	execute: T['execute'];
-}> {
-	static override readonly [entityKind]: string = 'SQLiteDOPreparedQuery';
-
-	constructor(
-		private client: DurableObjectStorage,
-		query: Query,
-		private logger: Logger,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
-	) {
-		// 3-6 params are for cache. As long as we don't support sync cache - it will be skipped here
-		super('sync', executeMethod, query, undefined, undefined, undefined);
-	}
-
-	run(placeholderValues?: Record<string, unknown>): void {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		params.length > 0 ? this.client.sql.exec(this.query.sql, ...params) : this.client.sql.exec(this.query.sql);
-	}
-
-	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, joinsNotNullableMap, query, logger, client, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-
-			return params.length > 0 ? client.sql.exec(query.sql, ...params).toArray() : client.sql.exec(query.sql).toArray();
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, client, joinsNotNullableMap, customResultMapper, query } = this;
-		if (!fields && !customResultMapper) {
-			return params.length > 0 ? client.sql.exec(query.sql, ...params).one() : client.sql.exec(query.sql).one();
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-		const row = rows[0];
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['get'];
-		}
-
-		return mapResultRow(fields!, row, joinsNotNullableMap);
-	}
-
-	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		const res = params.length > 0
-			? this.client.sql.exec(this.query.sql, ...params)
-			: this.client.sql.exec(this.query.sql);
-
-		// @ts-ignore .raw().toArray() exists
-		return res.raw().toArray();
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
+	override transaction<T>(
+		transaction: (
+			tx: SQLiteDOTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
+		const tx = new SQLiteDOTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+			true,
+		);
+		return this.session.transaction(() => transaction(tx)) as T;
 	}
 }
diff --git a/drizzle-orm/src/effect-core/defaults.ts b/drizzle-orm/src/effect-core/defaults.ts
new file mode 100644
index 0000000000..eca4cc3c25
--- /dev/null
+++ b/drizzle-orm/src/effect-core/defaults.ts
@@ -0,0 +1,8 @@
+import { Layer } from 'effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { EffectLogger } from './logger.ts';
+
+export const DefaultServices = Layer.merge(
+	EffectCache.Default,
+	EffectLogger.Default,
+);
diff --git a/drizzle-orm/src/effect-core/errors.ts b/drizzle-orm/src/effect-core/errors.ts
new file mode 100644
index 0000000000..aefe120e69
--- /dev/null
+++ b/drizzle-orm/src/effect-core/errors.ts
@@ -0,0 +1,42 @@
+import * as Schema from 'effect/Schema';
+import { entityKind } from '~/entity.ts';
+
+export class EffectDrizzleError extends Schema.TaggedErrorClass<EffectDrizzleError>()('EffectDrizzleError', {
+	message: Schema.String,
+	cause: Schema.Unknown,
+}) {
+	static readonly [entityKind]: string = 'EffectDrizzleError';
+}
+
+export class EffectDrizzleQueryError
+	extends Schema.TaggedErrorClass<EffectDrizzleQueryError>()('EffectDrizzleQueryError', {
+		query: Schema.String,
+		params: Schema.Array(Schema.Any).pipe(Schema.mutable),
+		cause: Schema.Unknown,
+	})
+{
+	static readonly [entityKind]: string = 'EffectDrizzleQueryError';
+
+	override get message() {
+		return `Failed query: ${this.query}\nparams: ${this.params}`;
+	}
+
+	constructor(params: Omit<Schema.Struct.MakeIn<typeof EffectDrizzleQueryError.fields>, '_tag'>) {
+		super(params);
+		Error.captureStackTrace(this, EffectDrizzleQueryError);
+	}
+}
+
+export class EffectTransactionRollbackError
+	extends Schema.TaggedErrorClass<EffectTransactionRollbackError>()('EffectTransactionRollbackError', {})
+{
+	static readonly [entityKind]: string = 'EffectTransactionRollbackError';
+
+	override readonly message = 'Rollback';
+}
+
+export class MigratorInitError extends Schema.TaggedErrorClass<MigratorInitError>()('MigratorInitError', {
+	exitCode: Schema.Literals(['databaseMigrations', 'localMigrations']),
+}) {
+	static readonly [entityKind]: string = 'MigratorInitError';
+}
diff --git a/drizzle-orm/src/effect-core/index.ts b/drizzle-orm/src/effect-core/index.ts
new file mode 100644
index 0000000000..0371886cf4
--- /dev/null
+++ b/drizzle-orm/src/effect-core/index.ts
@@ -0,0 +1,3 @@
+export * from './errors.ts';
+export * from './logger.ts';
+export * from './query-effect.ts';
diff --git a/drizzle-orm/src/effect-core/logger.ts b/drizzle-orm/src/effect-core/logger.ts
new file mode 100644
index 0000000000..e1dde4edf9
--- /dev/null
+++ b/drizzle-orm/src/effect-core/logger.ts
@@ -0,0 +1,124 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+
+export interface EffectLoggerShape {
+	readonly logQuery: (query: string, params: unknown[]) => Effect.Effect<void, never, never>;
+}
+
+/**
+ * Effect service for logging SQL queries in Drizzle ORM.
+ *
+ * By default, this service is a no-op (no logging occurs). Use `EffectLogger.layer`
+ * to enable Effect-based logging, or `EffectLogger.fromDrizzle` to adapt a standard
+ * Drizzle logger.
+ *
+ * @example
+ * ```ts
+ * // Use default (no logging)
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // Enable Effect-based logging
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // Use a custom Drizzle logger
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export class EffectLogger extends Context.Service<EffectLogger, EffectLoggerShape>()('drizzle-orm/EffectLogger', {
+	make: Effect.sync((): EffectLoggerShape => ({
+		logQuery: (_query: string, _params: unknown[]) => Effect.void,
+	})),
+}) {
+	static readonly [entityKind]: string = 'drizzle-orm/EffectLogger';
+
+	/**
+	 * The default layer providing a no-op logger.
+	 */
+	static readonly Default = Layer.effect(EffectLogger, EffectLogger.make);
+
+	/**
+	 * Creates an EffectLoggerShape from a standard Drizzle logger.
+	 *
+	 * @param logger - A Drizzle logger instance implementing the `Logger` interface.
+	 * @returns A new EffectLoggerShape that delegates to the provided Drizzle logger.
+	 *
+	 * @example
+	 * ```ts
+	 * const drizzleLogger = new DefaultLogger();
+	 * const effectLogger = EffectLogger.fromDrizzle(drizzleLogger);
+	 * ```
+	 */
+	static fromDrizzle(logger: Logger): EffectLoggerShape {
+		return {
+			logQuery: (query: string, params: unknown[]) => {
+				return Effect.sync(() => logger.logQuery(query, params));
+			},
+		};
+	}
+
+	/**
+	 * Creates a Layer that provides an EffectLogger from a standard Drizzle logger.
+	 *
+	 * @param logger - A Drizzle logger instance implementing the `Logger` interface.
+	 * @returns A Layer that provides the EffectLogger service.
+	 *
+	 * @example
+	 * ```ts
+	 * const drizzleLogger = new DefaultLogger();
+	 * const db = yield* PgDrizzle.make({ relations }).pipe(
+	 *   Effect.provide(EffectLogger.layerFromDrizzle(drizzleLogger)),
+	 *   Effect.provide(PgDrizzle.DefaultServices),
+	 * );
+	 * ```
+	 */
+	static layerFromDrizzle(logger: Logger) {
+		return Layer.succeed(EffectLogger, EffectLogger.fromDrizzle(logger));
+	}
+
+	/**
+	 * A Layer that provides an EffectLogger with Effect-based logging.
+	 *
+	 * This layer logs queries using `Effect.log()` with annotations for the query
+	 * SQL and parameters. Use this when you want query logging integrated with
+	 * Effect's logging infrastructure.
+	 *
+	 * @example
+	 * ```ts
+	 * const db = yield* PgDrizzle.make({ relations }).pipe(
+	 *   Effect.provide(EffectLogger.layer),
+	 *   Effect.provide(PgDrizzle.DefaultServices),
+	 * );
+	 * ```
+	 */
+	static layer = Layer.succeed(
+		EffectLogger,
+		{
+			logQuery: Effect.fn('EffectLogger.logQuery')(function*(query: string, params: unknown[]) {
+				const stringifiedParams = params.map((p) => {
+					try {
+						return JSON.stringify(p);
+					} catch {
+						return String(p);
+					}
+				});
+				yield* Effect.log().pipe(
+					Effect.annotateLogs({
+						query,
+						params: stringifiedParams,
+					}),
+				);
+			}),
+		} satisfies EffectLoggerShape,
+	);
+}
diff --git a/drizzle-orm/src/effect-core/query-effect.ts b/drizzle-orm/src/effect-core/query-effect.ts
new file mode 100644
index 0000000000..8265973fd1
--- /dev/null
+++ b/drizzle-orm/src/effect-core/query-effect.ts
@@ -0,0 +1,27 @@
+import type * as Effect from 'effect/Effect';
+import * as Effectable from 'effect/Effectable';
+
+export interface QueryEffectHKTBase {
+	readonly $brand: 'QueryEffectHKT';
+	readonly error: unknown;
+	readonly context: unknown;
+}
+
+export type QueryEffectKind<
+	TKind extends QueryEffectHKTBase,
+	TSuccess,
+	TError = never,
+	TContext = never,
+> = Effect.Effect<TSuccess, TKind['error'] | TError, TKind['context'] | TContext>;
+
+export function applyEffectWrapper(baseClass: any) {
+	Object.assign(
+		baseClass.prototype,
+		Effectable.Prototype({
+			label: 'DrizzleQuery',
+			evaluate(this: { execute(): Effect.Effect<any, any, any> }) {
+				return this.execute();
+			},
+		} as any),
+	);
+}
diff --git a/drizzle-orm/src/effect-d1/driver.ts b/drizzle-orm/src/effect-d1/driver.ts
new file mode 100644
index 0000000000..7c96600072
--- /dev/null
+++ b/drizzle-orm/src/effect-d1/driver.ts
@@ -0,0 +1,84 @@
+import { D1Client } from '@effect/sql-d1/D1Client';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { type EffectSQLiteD1QueryEffectHKT, type EffectSQLiteD1RunResult, EffectSQLiteD1Session } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export type EffectDrizzleSQLiteD1Config<TRelations extends AnyRelations> = Omit<
+	EffectDrizzleSQLiteConfig<TRelations>,
+	'jit'
+>;
+
+export class EffectSQLiteD1Database<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectSQLiteD1QueryEffectHKT, EffectSQLiteD1RunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteD1Database';
+}
+
+/**
+ * Creates an EffectSQLiteD1Database instance.
+ *
+ * Requires `D1Client`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* SQLiteD1Drizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteD1Drizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* SQLiteD1Drizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(SQLiteD1Drizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* SQLiteD1Drizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(SQLiteD1Drizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('SQLiteD1Drizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteD1Config<TRelations>) {
+		const client = yield* D1Client;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect();
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectSQLiteD1Session(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectSQLiteD1Database(dialect, session, relations, true);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectSQLiteD1Database<TRelations> & {
+			$client: D1Client;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectSQLiteD1Database with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteD1Config<TRelations>) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-d1/index.ts b/drizzle-orm/src/effect-d1/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-d1/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-d1/session.ts b/drizzle-orm/src/effect-d1/session.ts
new file mode 100644
index 0000000000..598ffdfacf
--- /dev/null
+++ b/drizzle-orm/src/effect-d1/session.ts
@@ -0,0 +1,124 @@
+import type { D1Client } from '@effect/sql-d1/D1Client';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectSQLiteD1QueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectSQLiteD1RunResult = unknown;
+
+export interface EffectSQLiteD1SessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectSQLiteD1Session<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectSQLiteD1RunResult, EffectSQLiteD1QueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteD1Session';
+
+	constructor(
+		private client: D1Client,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectSQLiteD1SessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectSQLiteD1QueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectSQLiteD1QueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	// Kept in case D1 supports transactions
+	// Currently throws
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectSQLiteD1Transaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectSQLiteD1Transaction<TRelations>(
+				dialect,
+				this,
+				relations,
+				undefined,
+				true,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectSQLiteD1Transaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectSQLiteD1QueryEffectHKT, EffectSQLiteD1RunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteD1Transaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectSQLiteD1QueryEffectHKT, EffectSQLiteD1RunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-libsql/driver.ts b/drizzle-orm/src/effect-libsql/driver.ts
new file mode 100644
index 0000000000..e8dd142446
--- /dev/null
+++ b/drizzle-orm/src/effect-libsql/driver.ts
@@ -0,0 +1,82 @@
+import { LibsqlClient } from '@effect/sql-libsql/LibsqlClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type EffectLibsqlQueryEffectHKT, type EffectLibsqlRunResult, EffectLibsqlSession } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectLibsqlDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectLibsqlQueryEffectHKT, EffectLibsqlRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectLibsqlDatabase';
+}
+
+/**
+ * Creates an EffectLibsqlDatabase instance.
+ *
+ * Requires `LibsqlClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* LibsqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(LibsqlDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* LibsqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(LibsqlDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* LibsqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(LibsqlDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('LibsqlDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) {
+		const client = yield* LibsqlClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectLibsqlSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectLibsqlDatabase(dialect, session, relations);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectLibsqlDatabase<TRelations> & {
+			$client: LibsqlClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectLibsqlDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-libsql/index.ts b/drizzle-orm/src/effect-libsql/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-libsql/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-libsql/migrator.ts b/drizzle-orm/src/effect-libsql/migrator.ts
new file mode 100644
index 0000000000..442e5f771f
--- /dev/null
+++ b/drizzle-orm/src/effect-libsql/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrate as coreMigrate } from '~/sqlite-core/effect/session.ts';
+import type { EffectLibsqlDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectLibsqlDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-libsql/session.ts b/drizzle-orm/src/effect-libsql/session.ts
new file mode 100644
index 0000000000..eb8c588e2b
--- /dev/null
+++ b/drizzle-orm/src/effect-libsql/session.ts
@@ -0,0 +1,120 @@
+import type { LibsqlClient } from '@effect/sql-libsql/LibsqlClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectLibsqlQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectLibsqlRunResult = unknown;
+
+export interface EffectLibsqlSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectLibsqlSession<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectLibsqlRunResult, EffectLibsqlQueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectLibsqlSession';
+
+	constructor(
+		private client: LibsqlClient,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectLibsqlSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectLibsqlQueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectLibsqlQueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectLibsqlTransaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectLibsqlTransaction<TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectLibsqlTransaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectLibsqlQueryEffectHKT, EffectLibsqlRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectLibsqlTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectLibsqlQueryEffectHKT, EffectLibsqlRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-mysql2/codecs.ts b/drizzle-orm/src/effect-mysql2/codecs.ts
new file mode 100644
index 0000000000..12a729a2a5
--- /dev/null
+++ b/drizzle-orm/src/effect-mysql2/codecs.ts
@@ -0,0 +1,64 @@
+import { castToText, floatFromDouble, refineGenericMySqlCodecs } from '~/mysql-core/codecs.ts';
+
+export const effectMysql2Codecs = refineGenericMySqlCodecs({
+	bigint: {
+		normalize: BigInt,
+	},
+	'bigint:number': {
+		normalize: Number,
+	},
+	'bigint:string': {
+		normalize: String,
+	},
+	boolean: {
+		normalize: (value: number) => value === 1,
+	},
+	'decimal:number': {
+		normalize: Number,
+	},
+	'decimal:bigint': {
+		normalize: BigInt,
+	},
+	float: {
+		normalize: floatFromDouble,
+	},
+	date: {
+		cast: castToText,
+		normalize: (value: string) => new Date(value),
+	},
+	'date:string': {
+		cast: castToText,
+	},
+	datetime: {
+		cast: castToText,
+		normalize: (value: string) => new Date(value.replace(' ', 'T') + 'Z'),
+	},
+	'datetime:string': {
+		cast: castToText,
+	},
+	timestamp: {
+		cast: castToText,
+		normalize: (value: string) => new Date(value + '+0000'),
+	},
+	'timestamp:string': {
+		cast: castToText,
+	},
+	binary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	varbinary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	blob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	tinyblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	mediumblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	longblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+});
diff --git a/drizzle-orm/src/effect-mysql2/driver.ts b/drizzle-orm/src/effect-mysql2/driver.ts
new file mode 100644
index 0000000000..9d8214dbdf
--- /dev/null
+++ b/drizzle-orm/src/effect-mysql2/driver.ts
@@ -0,0 +1,85 @@
+import { MysqlClient } from '@effect/sql-mysql2/MysqlClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlDialect } from '~/mysql-core/dialect.ts';
+import { MySqlEffectDatabase } from '~/mysql-core/effect/db.ts';
+import type { EffectDrizzleMySqlConfig } from '~/mysql-core/effect/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { effectMysql2Codecs } from './codecs.ts';
+import { type EffectMysql2QueryEffectHKT, type EffectMysql2QueryResultHKT, EffectMysql2Session } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectMysql2Database<TRelations extends AnyRelations = EmptyRelations>
+	extends MySqlEffectDatabase<EffectMysql2QueryEffectHKT, EffectMysql2QueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectMysql2Database';
+}
+
+/**
+ * Creates an EffectMysql2Database instance.
+ *
+ * Requires `MysqlClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* MySqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(MySqlDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* MySqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(MySqlDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* MySqlDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(MySqlDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('MySqlDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleMySqlConfig<TRelations> = {}) {
+		const client = yield* MysqlClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new MySqlDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+			codecs: config.codecs ?? effectMysql2Codecs,
+			paginationToBigint: true,
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectMysql2Session(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectMysql2Database(dialect, session, relations) as EffectMysql2Database<TRelations>;
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectMysql2Database<TRelations> & {
+			$client: MysqlClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectMysql2Database with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleMySqlConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-mysql2/index.ts b/drizzle-orm/src/effect-mysql2/index.ts
new file mode 100644
index 0000000000..5a9003bd6d
--- /dev/null
+++ b/drizzle-orm/src/effect-mysql2/index.ts
@@ -0,0 +1,4 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-mysql2/migrator.ts b/drizzle-orm/src/effect-mysql2/migrator.ts
new file mode 100644
index 0000000000..46a960d740
--- /dev/null
+++ b/drizzle-orm/src/effect-mysql2/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/mysql-core/effect/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { EffectMysql2Database } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectMysql2Database<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-mysql2/session.ts b/drizzle-orm/src/effect-mysql2/session.ts
new file mode 100644
index 0000000000..5c21db18e1
--- /dev/null
+++ b/drizzle-orm/src/effect-mysql2/session.ts
@@ -0,0 +1,113 @@
+import type { MysqlClient } from '@effect/sql-mysql2/MysqlClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import { MySqlEffectPreparedQuery, MySqlEffectSession, MySqlEffectTransaction } from '~/mysql-core/effect/session.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+
+export interface EffectMysql2QueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export interface EffectMysql2QueryResultHKT extends MySqlQueryResultHKT {
+	type: readonly Assume<this['row'], object>[];
+}
+
+export interface EffectMysql2SessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectMysql2Session<
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends MySqlEffectSession<EffectMysql2QueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectMysql2Session';
+
+	constructor(
+		private client: MysqlClient,
+		dialect: MySqlDialect,
+		protected relations: TRelations,
+		private options: EffectMysql2SessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends MySqlPreparedQueryConfig = MySqlPreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): MySqlEffectPreparedQuery<T, EffectMysql2QueryEffectHKT> {
+		const executor = (params?: unknown[]) => {
+			const q = this.client.unsafe(query.sql, params);
+
+			if (mode === 'arrays') return q.values;
+			if (mode === 'objects') return q.withoutTransform;
+			if (!mapper) return q.raw;
+
+			return q.raw.pipe(Effect.map(({ insertId, affectedRows }: any) => ({
+				insertId,
+				affectedRows,
+			})));
+		};
+
+		return new MySqlEffectPreparedQuery<T, EffectMysql2QueryEffectHKT>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectMysql2Transaction<TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectMysql2Transaction<TQueryResult, TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectMysql2Transaction<
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends MySqlEffectTransaction<EffectMysql2QueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectMysql2Transaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: MySqlEffectTransaction<EffectMysql2QueryEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, SqlError | E, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-pglite/codecs.ts b/drizzle-orm/src/effect-pglite/codecs.ts
new file mode 100644
index 0000000000..fe74d202d8
--- /dev/null
+++ b/drizzle-orm/src/effect-pglite/codecs.ts
@@ -0,0 +1,83 @@
+import { refineCodecs } from '~/codecs.ts';
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	genericPgCodecs,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+} from '~/pg-core/codecs.ts';
+import { base64ToUint8Array } from '~/utils.ts';
+import { effectPgCodecs } from '../effect-postgres/codecs.ts';
+
+export const effectPgliteCodecs = refineCodecs(effectPgCodecs, {
+	bigint: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	'bigint:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'bigint:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'bigserial:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	bytea: {
+		normalizeInJson: typeof Buffer === 'undefined' ? base64ToUint8Array : genericPgCodecs.bytea?.normalizeInJson,
+		normalizeArrayInJson: typeof Buffer === 'undefined'
+			? arrayCompatNormalize(base64ToUint8Array)
+			: genericPgCodecs.bytea?.normalizeArrayInJson,
+		normalize: typeof Buffer === 'undefined'
+			? undefined
+			: (v: Uint8Array) => Buffer.from(v),
+		normalizeArray: typeof Buffer === 'undefined'
+			? undefined
+			: arrayCompatNormalize((v: Uint8Array) => Buffer.from(v)),
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dimensions) => `${name}::geometry${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dimensions) => `${name}::geometry${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	bit: {
+		normalizeArray: undefined,
+	},
+	halfvec: {
+		castParam: (name) => `${name}::halfvec`,
+		castArrayParam: (name, _column, dimensions) => `${name}::halfvec${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	vector: {
+		castParam: (name) => `${name}::vector`,
+		castArrayParam: (name, _column, dimensions) => `${name}::vector${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+		castParam: (name) => `${name}::sparsevec`,
+		castArrayParam: (name, _column, dimensions) => `${name}::sparsevec${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+});
diff --git a/drizzle-orm/src/effect-pglite/driver.ts b/drizzle-orm/src/effect-pglite/driver.ts
new file mode 100644
index 0000000000..dfb2d7ad24
--- /dev/null
+++ b/drizzle-orm/src/effect-pglite/driver.ts
@@ -0,0 +1,84 @@
+import { PgliteClient } from '@effect/sql-pglite/PgliteClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import { PgEffectDatabase } from '~/pg-core/effect/db.ts';
+import type { EffectDrizzlePgConfig } from '~/pg-core/effect/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { effectPgliteCodecs } from './codecs.ts';
+import { type EffectPgQueryEffectHKT, type EffectPgQueryResultHKT, EffectPgSession } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectPgDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgEffectDatabase<EffectPgQueryEffectHKT, EffectPgQueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectPgDatabase';
+}
+
+/**
+ * Creates an EffectPgDatabase instance.
+ *
+ * Requires `PgliteClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('PgDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzlePgConfig<TRelations> = {}) {
+		const client = yield* PgliteClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new PgDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+			codecs: config.codecs ?? effectPgliteCodecs,
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectPgSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectPgDatabase(dialect, session, relations) as EffectPgDatabase<TRelations>;
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectPgDatabase<TRelations> & {
+			$client: PgliteClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectPgDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzlePgConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-pglite/index.ts b/drizzle-orm/src/effect-pglite/index.ts
new file mode 100644
index 0000000000..5a9003bd6d
--- /dev/null
+++ b/drizzle-orm/src/effect-pglite/index.ts
@@ -0,0 +1,4 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-pglite/migrator.ts b/drizzle-orm/src/effect-pglite/migrator.ts
new file mode 100644
index 0000000000..3237577818
--- /dev/null
+++ b/drizzle-orm/src/effect-pglite/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/effect/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { EffectPgDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectPgDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-pglite/session.ts b/drizzle-orm/src/effect-pglite/session.ts
new file mode 100644
index 0000000000..0799e094d6
--- /dev/null
+++ b/drizzle-orm/src/effect-pglite/session.ts
@@ -0,0 +1,109 @@
+import type { PgliteClient } from '@effect/sql-pglite/PgliteClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import { PgEffectPreparedQuery, PgEffectSession, PgEffectTransaction } from '~/pg-core/effect/session.ts';
+import type { PgQueryResultHKT, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+
+export interface EffectPgQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export interface EffectPgQueryResultHKT extends PgQueryResultHKT {
+	type: readonly Assume<this['row'], object>[];
+}
+
+export interface EffectPgSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectPgSession<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends PgEffectSession<EffectPgQueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectPgSession';
+
+	constructor(
+		private client: PgliteClient,
+		dialect: PgDialect,
+		protected relations: TRelations,
+		private options: EffectPgSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgEffectPreparedQuery<T, EffectPgQueryEffectHKT> {
+		const executor = (params?: unknown[]) => {
+			const q = this.client.unsafe(query.sql, params);
+
+			if (mode === 'arrays') return q.values;
+			if (mode === 'objects') return q.withoutTransform;
+			return q.raw;
+		};
+
+		return new PgEffectPreparedQuery<T, EffectPgQueryEffectHKT>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectPgTransaction<TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectPgTransaction<TQueryResult, TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectPgTransaction<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends PgEffectTransaction<EffectPgQueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectPgTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: PgEffectTransaction<EffectPgQueryEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, SqlError | E, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-postgres/codecs.ts b/drizzle-orm/src/effect-postgres/codecs.ts
new file mode 100644
index 0000000000..490320e3a2
--- /dev/null
+++ b/drizzle-orm/src/effect-postgres/codecs.ts
@@ -0,0 +1,181 @@
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	arrayCompatNormalizeInput,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const effectPgCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	date: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'date:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		normalizeParamArray: makePgArray,
+	},
+	interval: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	timestamp: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+		normalizeParamArray: makePgArray,
+	},
+	timestamptz: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'timestamp:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'timestamptz:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	json: {
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+
+	bool: { normalizeParamArray: makePgArray },
+	box: { normalizeParamArray: makePgArray },
+	box2d: { normalizeParamArray: makePgArray },
+	box3d: { normalizeParamArray: makePgArray },
+	char: { normalizeParamArray: makePgArray },
+	cidr: { normalizeParamArray: makePgArray },
+	circle: { normalizeParamArray: makePgArray },
+	datemultirange: { normalizeParamArray: makePgArray },
+	daterange: { normalizeParamArray: makePgArray },
+	float8: { normalizeParamArray: makePgArray },
+	'geography(point)': { normalizeParamArray: makePgArray },
+	'geography(point):tuple': { normalizeParamArray: makePgArray },
+	inet: { normalizeParamArray: makePgArray },
+	int4multirange: { normalizeParamArray: makePgArray },
+	int4range: { normalizeParamArray: makePgArray },
+	int8multirange: { normalizeParamArray: makePgArray },
+	int8range: { normalizeParamArray: makePgArray },
+	lseg: { normalizeParamArray: makePgArray },
+	macaddr: { normalizeParamArray: makePgArray },
+	money: { normalizeParamArray: makePgArray },
+	nummultirange: { normalizeParamArray: makePgArray },
+	numrange: { normalizeParamArray: makePgArray },
+	oid: { normalizeParamArray: makePgArray },
+	path: { normalizeParamArray: makePgArray },
+	polygon: { normalizeParamArray: makePgArray },
+	raster: { normalizeParamArray: makePgArray },
+	regclass: { normalizeParamArray: makePgArray },
+	regconfig: { normalizeParamArray: makePgArray },
+	regdictionary: { normalizeParamArray: makePgArray },
+	regnamespace: { normalizeParamArray: makePgArray },
+	regoper: { normalizeParamArray: makePgArray },
+	regoperator: { normalizeParamArray: makePgArray },
+	regproc: { normalizeParamArray: makePgArray },
+	regprocedure: { normalizeParamArray: makePgArray },
+	regrole: { normalizeParamArray: makePgArray },
+	regtype: { normalizeParamArray: makePgArray },
+	serial: { normalizeParamArray: makePgArray },
+	smallint: { normalizeParamArray: makePgArray },
+	smallserial: { normalizeParamArray: makePgArray },
+	text: { normalizeParamArray: makePgArray },
+	time: { normalizeParamArray: makePgArray },
+	timetz: { normalizeParamArray: makePgArray },
+	tsmultirange: { normalizeParamArray: makePgArray },
+	tsquery: { normalizeParamArray: makePgArray },
+	tsrange: { normalizeParamArray: makePgArray },
+	tstzmultirange: { normalizeParamArray: makePgArray },
+	tstzrange: { normalizeParamArray: makePgArray },
+	tsvector: { normalizeParamArray: makePgArray },
+	varbit: { normalizeParamArray: makePgArray },
+	varchar: { normalizeParamArray: makePgArray },
+	xml: { normalizeParamArray: makePgArray },
+	bytea: { normalizeParamArray: makePgArray },
+	enum: { normalizeParamArray: makePgArray },
+	numeric: { normalizeParamArray: makePgArray },
+	'numeric:number': { normalizeParamArray: makePgArray },
+	'numeric:bigint': { normalizeParamArray: makePgArray },
+	'bigint:number': { normalizeParamArray: makePgArray },
+	'bigint:string': { normalizeParamArray: makePgArray },
+	'bigserial:number': { normalizeParamArray: makePgArray },
+	float4: { normalizeParamArray: makePgArray },
+	int: { normalizeParamArray: makePgArray },
+	uuid: { normalizeParamArray: makePgArray },
+	halfvec: { normalizeParamArray: makePgArray },
+	sparsevec: {
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	vector: { normalizeParamArray: makePgArray },
+});
diff --git a/drizzle-orm/src/effect-postgres/driver.ts b/drizzle-orm/src/effect-postgres/driver.ts
new file mode 100644
index 0000000000..f533392872
--- /dev/null
+++ b/drizzle-orm/src/effect-postgres/driver.ts
@@ -0,0 +1,84 @@
+import { PgClient } from '@effect/sql-pg/PgClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import { PgEffectDatabase } from '~/pg-core/effect/db.ts';
+import type { EffectDrizzlePgConfig } from '~/pg-core/effect/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { effectPgCodecs } from './codecs.ts';
+import { type EffectPgQueryEffectHKT, type EffectPgQueryResultHKT, EffectPgSession } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectPgDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgEffectDatabase<EffectPgQueryEffectHKT, EffectPgQueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectPgDatabase';
+}
+
+/**
+ * Creates an EffectPgDatabase instance.
+ *
+ * Requires `PgClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* PgDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(PgDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('PgDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzlePgConfig<TRelations> = {}) {
+		const client = yield* PgClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new PgDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+			codecs: config.codecs ?? effectPgCodecs,
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectPgSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectPgDatabase(dialect, session, relations) as EffectPgDatabase<TRelations>;
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectPgDatabase<TRelations> & {
+			$client: PgClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectPgDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzlePgConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-postgres/index.ts b/drizzle-orm/src/effect-postgres/index.ts
new file mode 100644
index 0000000000..5a9003bd6d
--- /dev/null
+++ b/drizzle-orm/src/effect-postgres/index.ts
@@ -0,0 +1,4 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-postgres/migrator.ts b/drizzle-orm/src/effect-postgres/migrator.ts
new file mode 100644
index 0000000000..3237577818
--- /dev/null
+++ b/drizzle-orm/src/effect-postgres/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/effect/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { EffectPgDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectPgDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-postgres/session.ts b/drizzle-orm/src/effect-postgres/session.ts
new file mode 100644
index 0000000000..6f0f89aecc
--- /dev/null
+++ b/drizzle-orm/src/effect-postgres/session.ts
@@ -0,0 +1,109 @@
+import type { PgClient } from '@effect/sql-pg/PgClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import { PgEffectPreparedQuery, PgEffectSession, PgEffectTransaction } from '~/pg-core/effect/session.ts';
+import type { PgQueryResultHKT, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+
+export interface EffectPgQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export interface EffectPgQueryResultHKT extends PgQueryResultHKT {
+	type: readonly Assume<this['row'], object>[];
+}
+
+export interface EffectPgSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectPgSession<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends PgEffectSession<EffectPgQueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectPgSession';
+
+	constructor(
+		private client: PgClient,
+		dialect: PgDialect,
+		protected relations: TRelations,
+		private options: EffectPgSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgEffectPreparedQuery<T, EffectPgQueryEffectHKT> {
+		const executor = (params?: unknown[]) => {
+			const q = this.client.unsafe(query.sql, params);
+
+			if (mode === 'arrays') return q.values;
+			if (mode === 'objects') return q.withoutTransform;
+			return q.raw;
+		};
+
+		return new PgEffectPreparedQuery<T, EffectPgQueryEffectHKT>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectPgTransaction<TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectPgTransaction<TQueryResult, TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectPgTransaction<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+> extends PgEffectTransaction<EffectPgQueryEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'EffectPgTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: PgEffectTransaction<EffectPgQueryEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, SqlError | E, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-schema/README.md b/drizzle-orm/src/effect-schema/README.md
new file mode 100644
index 0000000000..4ec021ef53
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/README.md
@@ -0,0 +1,52 @@
+Allows you to generate [effect](https://effect.website/) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { Effect, Schema } from "effect";
+
+const users = pgTable('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	role: text({ enum: ['admin', 'user'] }).notNull(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const UserInsert = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const UserUpdate = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const UserSelect = createSelectSchema(users);
+
+// Overriding the fields
+const UserInsert = createInsertSchema(users, {
+	role: Schema.String,
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const UserInsert = createInsertSchema(users, {
+	id: (schema) => schema.check(Schema.isGreaterThanOrEqualTo(0)),
+	role: Schema.String,
+});
+
+// Usage
+const program = Effect.gen(function*() {
+	const parsedUser = yield* Schema.decodeUnknownEffect(UserInsert)({
+		name: 'John Doe',
+		email: 'johndoe@test.com',
+		role: 'admin',
+	});
+});
+```
\ No newline at end of file
diff --git a/drizzle-orm/src/effect-schema/column.ts b/drizzle-orm/src/effect-schema/column.ts
new file mode 100644
index 0000000000..1e8fd750c7
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/column.ts
@@ -0,0 +1,397 @@
+import { Schema as S } from 'effect';
+import type { Schema, Top as SchemaTop } from 'effect/Schema';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS, type Json } from '../utils.ts';
+
+export const literalSchema = S.Union([
+	S.String,
+	S.Number,
+	S.Boolean,
+	S.Null,
+]);
+
+export const jsonSchema = S.Union([
+	literalSchema,
+	S.Record(S.String, S.Any),
+	S.Array(S.Any),
+]) satisfies Schema<Json>;
+
+export const bufferSchema = (typeof Buffer === 'undefined' ? S.Unknown : S.instanceOf(Buffer)) as Schema<Buffer>;
+
+export function columnToSchema(
+	column: Column,
+): SchemaTop {
+	let schema!: SchemaTop;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions);
+	}
+
+	const { type, constraint } = extractExtendedColumnType(column);
+
+	switch (type) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint);
+			break;
+		}
+		case 'boolean': {
+			schema = S.Boolean;
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint);
+			break;
+		}
+		case 'custom': {
+			schema = S.Any;
+			break;
+		}
+		default: {
+			schema = S.Any;
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(
+	column: Column,
+	constraint: ColumnDataNumberConstraint | undefined,
+): SchemaTop {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	let schema = integer
+		? S.Int
+		: S.Number;
+	schema = schema.check(
+		S.isGreaterThanOrEqualTo(min),
+		S.isLessThanOrEqualTo(max),
+	);
+	return schema;
+}
+
+export const bigintStringModeSchema = S.BigInt.check(
+	S.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+	S.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+);
+
+export const unsignedBigintStringModeSchema = S.BigInt.check(
+	S.isGreaterThanOrEqualToBigInt(0n),
+	S.isLessThanOrEqualToBigInt(CONSTANTS.INT64_UNSIGNED_MAX),
+);
+
+function bigintColumnToSchema(
+	column: Column,
+	constraint: ColumnDataBigIntConstraint | undefined,
+): SchemaTop {
+	let min!: bigint | undefined;
+	let max!: bigint | undefined;
+
+	switch (constraint) {
+		case 'int64': {
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		}
+		case 'uint64': {
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+		}
+	}
+
+	let schema: Schema<bigint> = S.BigInt;
+
+	if (min !== undefined) schema = schema.check(S.isGreaterThanOrEqualToBigInt(min));
+	if (max !== undefined) schema = schema.check(S.isLessThanOrEqualToBigInt(max));
+	return schema;
+}
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+): SchemaTop {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: SchemaTop;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint);
+			break;
+		case 'boolean':
+			baseSchema = S.Boolean;
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint);
+			break;
+		default:
+			baseSchema = S.Any;
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: SchemaTop = S.Array(baseSchema);
+	for (let i = 1; i < dimensions; i++) {
+		schema = S.Array(schema);
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(
+	column: Column,
+	constraint: ColumnDataArrayConstraint | undefined,
+): SchemaTop {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return S.Tuple([S.Number, S.Number]);
+		}
+		case 'line': {
+			return S.Tuple([S.Number, S.Number, S.Number]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const length = column.length;
+			const schema = S.Array(S.Number);
+			return length
+				? schema.check(S.isLengthBetween(length, length))
+				: schema;
+		}
+		case 'int64vector': {
+			const length = column.length;
+			const schema = S.Array(
+				S.BigInt.check(
+					S.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+					S.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+				),
+			);
+			return length
+				? schema.check(S.isLengthBetween(length, length))
+				: schema;
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const baseSchema = columnToSchema(baseColumn);
+				// For CockroachDB style, column.length is the array size
+				const length = column.length;
+				const schema = S.Array(baseSchema);
+				if (length) {
+					return schema.check(S.isLengthBetween(length, length));
+				}
+				return schema;
+			}
+			return S.Array(S.Any);
+		}
+		default: {
+			return S.Array(S.Any);
+		}
+	}
+}
+
+function objectColumnToSchema(
+	column: Column,
+	constraint: ColumnDataObjectConstraint | undefined,
+): SchemaTop {
+	switch (constraint) {
+		case 'buffer': {
+			return bufferSchema;
+		}
+		case 'date': {
+			return S.Date;
+		}
+		case 'geometry':
+		case 'point': {
+			return S.Struct({
+				x: S.Number,
+				y: S.Number,
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return S.Struct({
+				a: S.Number,
+				b: S.Number,
+				c: S.Number,
+			});
+		}
+		default: {
+			return S.ObjectKeyword;
+		}
+	}
+}
+
+function stringColumnToSchema(
+	column: Column<any>,
+	constraint: ColumnDataStringConstraint | undefined,
+): SchemaTop {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex: RegExp | undefined;
+
+	if (constraint === 'binary') {
+		regex = /^[01]*$/;
+	}
+	if (constraint === 'uuid') return S.String.check(S.isUUID());
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues as [string, ...string[]] | undefined;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return S.Literals(enumValues);
+	}
+	if (constraint === 'int64') {
+		return bigintStringModeSchema;
+	}
+	if (constraint === 'uint64') {
+		return unsignedBigintStringModeSchema;
+	}
+
+	let schema = S.String;
+	schema = regex ? schema.check(S.isPattern(regex)) : schema;
+	return length && isLengthExact
+		? schema.check(S.isLengthBetween(length, length))
+		: length
+		? schema.check(S.isMaxLength(length))
+		: schema;
+}
diff --git a/drizzle-orm/src/effect-schema/column.types.ts b/drizzle-orm/src/effect-schema/column.types.ts
new file mode 100644
index 0000000000..6eb5baa07f
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/column.types.ts
@@ -0,0 +1,97 @@
+import type { Schema as s } from 'effect';
+import type { $Array, Literals, NullOr, optional, Struct, Top as SchemaTop, Tuple, UndefinedOr } from 'effect/Schema';
+import type { LiteralValue } from 'effect/SchemaAST';
+import type { ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Assume } from '~/utils.ts';
+import type { bigintStringModeSchema, bufferSchema, jsonSchema, unsignedBigintStringModeSchema } from './column.ts';
+
+type GetArrayDepth<T, Depth extends number = 0> = Depth extends 5 ? 5
+	: T extends readonly (infer U)[] ? GetArrayDepth<U, [1, 2, 3, 4, 5][Depth]>
+	: Depth;
+
+type WrapInEffectSchemaArray<TSchema extends SchemaTop, TDepth extends number> = TDepth extends 0 ? TSchema
+	: TDepth extends 1 ? $Array<TSchema>
+	: TDepth extends 2 ? $Array<$Array<TSchema>>
+	: TDepth extends 3 ? $Array<$Array<$Array<TSchema>>>
+	: TDepth extends 4 ? $Array<$Array<$Array<$Array<TSchema>>>>
+	: TDepth extends 5 ? $Array<$Array<$Array<$Array<$Array<TSchema>>>>>
+	: $Array<typeof s.Any>;
+
+type IsPgArrayColumn<TColumn extends Column<any>, TType extends ColumnTypeData> = TType['type'] extends 'array' ? false // Already handled as explicit array type
+	: GetArrayDepth<TColumn['_']['data']> extends 0 ? false
+	: true;
+
+export type GetEffectSchemaType<
+	TColumn extends Column<any>,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = IsPgArrayColumn<TColumn, TType> extends true ? WrapInEffectSchemaArray<
+		GetBaseEffectSchemaType<TColumn, TType>,
+		GetArrayDepth<TColumn['_']['data']>
+	>
+	: GetBaseEffectSchemaType<TColumn, TType>;
+
+type GetBaseEffectSchemaType<
+	TColumn extends Column<any>,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = TType['type'] extends 'array'
+	? TType['constraint'] extends 'geometry' | 'point' ? Tuple<readonly [typeof s.Number, typeof s.Number]>
+	: TType['constraint'] extends 'line' ? Tuple<readonly [typeof s.Number, typeof s.Number, typeof s.Number]>
+	: TType['constraint'] extends 'vector' | 'halfvector' ? $Array<typeof s.Number>
+	: TType['constraint'] extends 'int64vector' ? $Array<typeof s.BigInt>
+	: TType['constraint'] extends 'basecolumn'
+		? TColumn['_'] extends { baseColumn: infer TBaseColumn extends Column<any> }
+			? $Array<Assume<GetEffectSchemaType<TBaseColumn>, SchemaTop>>
+		: never
+	: $Array<typeof s.Any>
+	: TType['type'] extends 'object' ? TType['constraint'] extends 'date' ? typeof s.Date
+		: TType['constraint'] extends 'buffer' ? typeof bufferSchema
+		: TType['constraint'] extends 'point' | 'geometry'
+			? Struct<{ readonly x: typeof s.Number; readonly y: typeof s.Number }>
+		: TType['constraint'] extends 'line'
+			? Struct<{ readonly a: typeof s.Number; readonly b: typeof s.Number; readonly c: typeof s.Number }>
+		: TType['constraint'] extends 'json' ? typeof jsonSchema
+		: typeof s.ObjectKeyword
+	: TType['type'] extends 'custom' ? typeof s.Any
+	: TType['type'] extends 'number'
+		? (TType['constraint'] extends
+			'int8' | 'int16' | 'int24' | 'int32' | 'int53' | 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint53' | 'year'
+			? typeof s.Int
+			: typeof s.Number)
+	: TType['type'] extends 'bigint' ? typeof s.BigInt
+	: TType['type'] extends 'boolean' ? typeof s.Boolean
+	: TType['type'] extends 'string' ? TType['constraint'] extends 'uuid' ? typeof s.String
+		: TType['constraint'] extends 'enum' ? Literals<
+				Readonly<TColumn['enumValues']> extends infer R extends readonly LiteralValue[] ? R : TColumn['enumValues']
+			>
+		: TType['constraint'] extends 'int64' ? typeof bigintStringModeSchema
+		: TType['constraint'] extends 'uint64' ? typeof unsignedBigintStringModeSchema
+		: typeof s.String
+	: typeof s.Any;
+
+type HandleSelectColumn<
+	TSchema extends SchemaTop,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: NullOr<TSchema>;
+
+type HandleInsertColumn<
+	TSchema extends SchemaTop,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? optional<UndefinedOr<TSchema>>
+	: TSchema
+	: optional<UndefinedOr<NullOr<TSchema>>>;
+
+type HandleUpdateColumn<
+	TSchema extends SchemaTop,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? optional<UndefinedOr<TSchema>>
+	: optional<UndefinedOr<NullOr<TSchema>>>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+> = TType extends 'select' ? HandleSelectColumn<GetEffectSchemaType<TColumn>, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<GetEffectSchemaType<TColumn>, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<GetEffectSchemaType<TColumn>, TColumn>
+	: GetEffectSchemaType<TColumn>;
diff --git a/drizzle-orm/src/effect-schema/index.ts b/drizzle-orm/src/effect-schema/index.ts
new file mode 100644
index 0000000000..5d00169d6e
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/index.ts
@@ -0,0 +1,11 @@
+export {
+	bigintStringModeSchema,
+	bufferSchema,
+	jsonSchema,
+	literalSchema,
+	unsignedBigintStringModeSchema,
+} from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/effect-schema/schema.ts b/drizzle-orm/src/effect-schema/schema.ts
new file mode 100644
index 0000000000..8df5981a2e
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/schema.ts
@@ -0,0 +1,124 @@
+import { Schema as s } from 'effect';
+import type { Top as SchemaTop } from 'effect/Schema';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type { CreateInsertSchema, CreateSelectSchema, CreateUpdateSchema } from './schema.types.ts';
+
+function isOptional(schema: unknown): schema is s.optional<SchemaTop> {
+	if ((typeof schema !== 'object' || schema === null) && typeof schema !== 'function') return false;
+
+	return s.isSchema(schema) && (schema as any).ast?.context?.isOptional === true;
+}
+
+function isStructField(schema: unknown): schema is s.optional<SchemaTop> | SchemaTop {
+	if (s.isSchema(schema)) return true;
+
+	return isOptional(schema);
+}
+
+function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+): SchemaTop {
+	const columnSchemas: Record<string, SchemaTop | s.optional<SchemaTop>> = {};
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
+			continue;
+		}
+
+		const refinement = refinements[key];
+
+		if (refinement !== undefined && !(typeof refinement === 'function' && !isStructField(refinement))) {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column) : s.Any;
+		const _refined = isStructField(refinement) || typeof refinement !== 'function' ? schema : refinement(schema);
+		const refined = isOptional(_refined) ? (_refined as any).schema : _refined as SchemaTop;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = s.NullOr(columnSchemas[key] as SchemaTop);
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = s.optional(s.UndefinedOr(columnSchemas[key] as SchemaTop));
+			}
+		}
+	}
+
+	return s.Struct(columnSchemas);
+}
+
+function handleEnum(
+	enum_: PgEnum<[string, ...string[]]>,
+) {
+	return s.Literals(enum_.enumValues);
+}
+
+const selectConditions: Conditions = {
+	never: () => false,
+	optional: () => false,
+	nullable: (column) => !column.notNull,
+};
+
+const insertConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+	nullable: (column) => !column.notNull,
+};
+
+const updateConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: () => true,
+	nullable: (column) => !column.notNull,
+};
+
+export const createSelectSchema: CreateSelectSchema = (
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return handleEnum(entity);
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, selectConditions) as any;
+};
+
+export const createInsertSchema: CreateInsertSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, insertConditions) as any;
+};
+
+export const createUpdateSchema: CreateUpdateSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, updateConditions) as any;
+};
diff --git a/drizzle-orm/src/effect-schema/schema.types.internal.ts b/drizzle-orm/src/effect-schema/schema.types.internal.ts
new file mode 100644
index 0000000000..bbb93d1bc8
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/schema.types.internal.ts
@@ -0,0 +1,81 @@
+import type { Schema as s } from 'effect';
+import type { Struct, Top as SchemaTop, UndefinedOr } from 'effect/Schema';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { GetEffectSchemaType, HandleColumn } from './column.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type BuildRefineField<T> = T extends SchemaTop ? ((schema: T) => SchemaTop) | SchemaTop
+	: never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+> = {
+	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
+		TColumns[K] extends Column ? BuildRefineField<GetEffectSchemaType<TColumns[K]>>
+			: BuildRefine<GetSelection<TColumns[K]>>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (((schema: any) => infer R extends SchemaTop)) ? (TColumn['_']['notNull'] extends true ? R
+		: (s.NullOr<R>)) extends infer TSchema extends SchemaTop ? TType extends 'update' ? s.optional<UndefinedOr<TSchema>>
+		: TSchema
+	: typeof s.Any
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object
+	? TRefinements[TKey] extends SchemaTop | s.optional<SchemaTop> | s.optionalKey<SchemaTop> | ((schema: any) => any)
+		? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+> = Struct<
+	Simplify<
+		{
+			readonly [
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column ? IsRefinementDefined<TRefinements, K> extends true ? Assume<
+						HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>,
+						SchemaTop | s.optional<SchemaTop> | s.optionalKey<SchemaTop>
+					>
+				: HandleColumn<TType, TColumn>
+				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TObject>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
+					>
+				: typeof s.Any;
+		}
+	>
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare
+		? TRefinement[K] extends Record<string, SchemaTop> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/effect-schema/schema.types.ts b/drizzle-orm/src/effect-schema/schema.types.ts
new file mode 100644
index 0000000000..08c0b30ea0
--- /dev/null
+++ b/drizzle-orm/src/effect-schema/schema.types.ts
@@ -0,0 +1,53 @@
+import type { Literals } from 'effect/Schema';
+import type { LiteralValue } from 'effect/SchemaAST';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns']>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields']>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(
+		enum_: TEnum,
+	): Literals<Readonly<TEnum['enumValues']> extends infer R extends readonly LiteralValue[] ? R : TEnum['enumValues']>;
+}
+
+export interface CreateInsertSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateUpdateSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
+}
diff --git a/drizzle-orm/src/effect-sqlite-bun/driver.ts b/drizzle-orm/src/effect-sqlite-bun/driver.ts
new file mode 100644
index 0000000000..061b7dff97
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-bun/driver.ts
@@ -0,0 +1,86 @@
+import { SqliteClient } from '@effect/sql-sqlite-bun/SqliteClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import {
+	type EffectSQLiteBunQueryEffectHKT,
+	type EffectSQLiteBunRunResult,
+	EffectSQLiteBunSession,
+} from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectSQLiteBunDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectSQLiteBunQueryEffectHKT, EffectSQLiteBunRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteBunDatabase';
+}
+
+/**
+ * Creates an EffectSQLiteBunDatabase instance.
+ *
+ * Requires `SqliteClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* SQLiteBunDrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteBunDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* SQLiteBunDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(SQLiteBunDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* SQLiteBunDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(SQLiteBunDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('SQLiteBunDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) {
+		const client = yield* SqliteClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectSQLiteBunSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectSQLiteBunDatabase(dialect, session, relations);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectSQLiteBunDatabase<TRelations> & {
+			$client: SqliteClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectSQLiteBunDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-sqlite-bun/index.ts b/drizzle-orm/src/effect-sqlite-bun/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-bun/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-sqlite-bun/migrator.ts b/drizzle-orm/src/effect-sqlite-bun/migrator.ts
new file mode 100644
index 0000000000..55b0b007fa
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-bun/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrate as coreMigrate } from '~/sqlite-core/effect/session.ts';
+import type { EffectSQLiteBunDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectSQLiteBunDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-sqlite-bun/session.ts b/drizzle-orm/src/effect-sqlite-bun/session.ts
new file mode 100644
index 0000000000..a05bc21b0d
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-bun/session.ts
@@ -0,0 +1,120 @@
+import type { SqliteClient } from '@effect/sql-sqlite-bun/SqliteClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectSQLiteBunQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectSQLiteBunRunResult = unknown;
+
+export interface EffectSQLiteBunSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectSQLiteBunSession<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectSQLiteBunRunResult, EffectSQLiteBunQueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteBunSession';
+
+	constructor(
+		private client: SqliteClient,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectSQLiteBunSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectSQLiteBunQueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectSQLiteBunQueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectSQLiteBunTransaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectSQLiteBunTransaction<TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectSQLiteBunTransaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectSQLiteBunQueryEffectHKT, EffectSQLiteBunRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteBunTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectSQLiteBunQueryEffectHKT, EffectSQLiteBunRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-sqlite-do/driver.ts b/drizzle-orm/src/effect-sqlite-do/driver.ts
new file mode 100644
index 0000000000..c6a7b088d6
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-do/driver.ts
@@ -0,0 +1,88 @@
+/// <reference types="@cloudflare/workers-types" />
+import { SqliteClient } from '@effect/sql-sqlite-do/SqliteClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { type EffectSQLiteDoQueryEffectHKT, type EffectSQLiteDoRunResult, EffectSQLiteDOSession } from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectSQLiteDoDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectSQLiteDoQueryEffectHKT, EffectSQLiteDoRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteDoDatabase';
+}
+
+export type EffectDrizzleSQLiteDoConfig<TRelations extends AnyRelations> =
+	& Omit<EffectDrizzleSQLiteConfig<TRelations>, 'jit'>
+	& {
+		/** Required to make transactions functional by bypassing broken implementation from `@effect/sql-sqlite-do` wrapper */
+		storage: DurableObjectStorage;
+	};
+
+/**
+ * Creates an EffectSQLiteDoDatabase instance.
+ *
+ * Requires `SqliteClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* SQLiteDODrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteDODrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* SQLiteDODrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(SQLiteDODrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* SQLiteDODrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(SQLiteDODrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('SQLiteDODrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteDoConfig<TRelations>) {
+		const client = yield* SqliteClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect();
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectSQLiteDOSession(client, dialect, relations, {
+			logger,
+			cache,
+			storage: config.storage,
+		});
+		const db = new EffectSQLiteDoDatabase(dialect, session, relations);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectSQLiteDoDatabase<TRelations> & {
+			$client: SqliteClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectSQLiteDoDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteDoConfig<TRelations>) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-sqlite-do/index.ts b/drizzle-orm/src/effect-sqlite-do/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-do/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-sqlite-do/migrator.ts b/drizzle-orm/src/effect-sqlite-do/migrator.ts
new file mode 100644
index 0000000000..ac64f1ff95
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-do/migrator.ts
@@ -0,0 +1,53 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import { formatToMillis } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrate as coreMigrate } from '~/sqlite-core/effect/session.ts';
+import type { EffectSQLiteDoDatabase } from './driver.ts';
+
+interface MigrationConfig {
+	migrations: Record<string, string>;
+	migrationsTable?: string;
+	/** @internal */
+	init?: boolean;
+}
+
+function readMigrationFiles({ migrations }: MigrationConfig): MigrationMeta[] {
+	const migrationQueries: MigrationMeta[] = [];
+
+	const sortedMigrations = Object.keys(migrations).sort();
+
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
+		if (!query) {
+			throw new Error(`Missing migration: ${key}`);
+		}
+
+		try {
+			const result = query.split('--> statement-breakpoint').map((it) => {
+				return it;
+			});
+
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
+			migrationQueries.push({
+				sql: result,
+				bps: true,
+				folderMillis: migrationDate,
+				hash: '',
+				name: key,
+			});
+		} catch {
+			throw new Error(`Failed to parse migration: ${key}`);
+		}
+	}
+
+	return migrationQueries;
+}
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectSQLiteDoDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-sqlite-do/session.ts b/drizzle-orm/src/effect-sqlite-do/session.ts
new file mode 100644
index 0000000000..8ed2b06321
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-do/session.ts
@@ -0,0 +1,148 @@
+/// <reference types="@cloudflare/workers-types" />
+import type { SqliteClient } from '@effect/sql-sqlite-do/SqliteClient';
+import type * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import { TransactionRollbackError } from '~/errors.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectSQLiteDoQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectSQLiteDoRunResult = unknown;
+
+export interface EffectSQLiteDOSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+	storage: DurableObjectStorage;
+}
+
+export class EffectSQLiteDOSession<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectSQLiteDoRunResult, EffectSQLiteDoQueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteDOSession';
+
+	constructor(
+		private client: SqliteClient,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectSQLiteDOSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectSQLiteDoQueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectSQLiteDoQueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectSQLiteDOTransaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations, options: { storage } } = this;
+
+		// Bypass effect wrapper's transaction bug by using driver directly
+		return Effect.gen({ self: this }, function*() {
+			const context = yield* Effect.context<R>();
+			let cause: Cause.Cause<E> | undefined;
+
+			try {
+				return storage.transactionSync(() => {
+					const tx = new EffectSQLiteDOTransaction<TRelations>(dialect, this, relations);
+					const exit = Effect.runSyncExit(Effect.provideContext(transaction(tx), context));
+
+					if (Exit.isFailure(exit)) {
+						cause = exit.cause;
+						throw new TransactionRollbackError();
+					}
+
+					return exit.value;
+				});
+			} catch (e) {
+				if (cause) return yield* Effect.failCause(cause);
+				throw e;
+			}
+		});
+
+		// return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+		// 	const tx = new EffectSQLiteDOTransaction<TRelations>(
+		// 		dialect,
+		// 		this,
+		// 		relations,
+		// 	);
+
+		// 	return yield* transaction(tx);
+		// }));
+	}
+}
+
+export class EffectSQLiteDOTransaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectSQLiteDoQueryEffectHKT, EffectSQLiteDoRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteDOTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectSQLiteDoQueryEffectHKT, EffectSQLiteDoRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-sqlite-node/driver.ts b/drizzle-orm/src/effect-sqlite-node/driver.ts
new file mode 100644
index 0000000000..bcf3537aae
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-node/driver.ts
@@ -0,0 +1,86 @@
+import { SqliteClient } from '@effect/sql-sqlite-node/SqliteClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import {
+	type EffectSQLiteNodeQueryEffectHKT,
+	type EffectSQLiteNodeRunResult,
+	EffectSQLiteNodeSession,
+} from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectSQLiteNodeDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectSQLiteNodeQueryEffectHKT, EffectSQLiteNodeRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteNodeDatabase';
+}
+
+/**
+ * Creates an EffectSQLiteNodeDatabase instance.
+ *
+ * Requires `SqliteClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* SQLiteNodeDrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteNodeDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* SQLiteNodeDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(SQLiteNodeDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* SQLiteNodeDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(SQLiteNodeDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('SQLiteNodeDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) {
+		const client = yield* SqliteClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectSQLiteNodeSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectSQLiteNodeDatabase(dialect, session, relations);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectSQLiteNodeDatabase<TRelations> & {
+			$client: SqliteClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectSQLiteNodeDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-sqlite-node/index.ts b/drizzle-orm/src/effect-sqlite-node/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-node/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-sqlite-node/migrator.ts b/drizzle-orm/src/effect-sqlite-node/migrator.ts
new file mode 100644
index 0000000000..dd1b2e7167
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-node/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrate as coreMigrate } from '~/sqlite-core/effect/session.ts';
+import type { EffectSQLiteNodeDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectSQLiteNodeDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-sqlite-node/session.ts b/drizzle-orm/src/effect-sqlite-node/session.ts
new file mode 100644
index 0000000000..13874e2a36
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-node/session.ts
@@ -0,0 +1,120 @@
+import type { SqliteClient } from '@effect/sql-sqlite-node/SqliteClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectSQLiteNodeQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectSQLiteNodeRunResult = unknown;
+
+export interface EffectSQLiteNodeSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectSQLiteNodeSession<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectSQLiteNodeRunResult, EffectSQLiteNodeQueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteNodeSession';
+
+	constructor(
+		private client: SqliteClient,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectSQLiteNodeSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectSQLiteNodeQueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectSQLiteNodeQueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectSQLiteNodeTransaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectSQLiteNodeTransaction<TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectSQLiteNodeTransaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectSQLiteNodeQueryEffectHKT, EffectSQLiteNodeRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteNodeTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectSQLiteNodeQueryEffectHKT, EffectSQLiteNodeRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/effect-sqlite-wasm/driver.ts b/drizzle-orm/src/effect-sqlite-wasm/driver.ts
new file mode 100644
index 0000000000..d846709796
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-wasm/driver.ts
@@ -0,0 +1,86 @@
+import { SqliteClient } from '@effect/sql-sqlite-wasm/SqliteClient';
+import * as Effect from 'effect/Effect';
+import { EffectCache } from '~/cache/core/cache-effect.ts';
+import { DefaultServices } from '~/effect-core/defaults.ts';
+import { EffectLogger } from '~/effect-core/index.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import type { EffectDrizzleSQLiteConfig } from '~/sqlite-core/effect/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import {
+	type EffectSQLiteWasmQueryEffectHKT,
+	type EffectSQLiteWasmRunResult,
+	EffectSQLiteWasmSession,
+} from './session.ts';
+export { DefaultServices } from '~/effect-core/defaults.ts';
+
+export class EffectSQLiteWasmDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteEffectDatabase<EffectSQLiteWasmQueryEffectHKT, EffectSQLiteWasmRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteWasmDatabase';
+}
+
+/**
+ * Creates an EffectSQLiteWasmDatabase instance.
+ *
+ * Requires `SqliteClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Use `DefaultServices` to provide default (no-op) logger and cache implementations.
+ *
+ * @example
+ * ```ts
+ * // With default services (no logging, no caching)
+ * const db = yield* SQLiteWasmDrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteWasmDrizzle.DefaultServices),
+ * );
+ *
+ * // With Effect-based logging
+ * const db = yield* SQLiteWasmDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layer),
+ *   Effect.provide(SQLiteWasmDrizzle.DefaultServices),
+ * );
+ *
+ * // With custom Drizzle logger
+ * const db = yield* SQLiteWasmDrizzle.make({ relations }).pipe(
+ *   Effect.provide(EffectLogger.layerFromDrizzle(myLogger)),
+ *   Effect.provide(SQLiteWasmDrizzle.DefaultServices),
+ * );
+ * ```
+ */
+export const make = Effect.fn('SQLiteWasmDrizzle.make')(
+	function*<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) {
+		const client = yield* SqliteClient;
+		const cache = yield* EffectCache;
+		const logger = yield* EffectLogger;
+
+		const dialect = new SQLiteDialect({
+			useJitMappers: jitCompatCheck(config.jit),
+		});
+
+		const relations = config.relations ?? {} as TRelations;
+		const session = new EffectSQLiteWasmSession(client, dialect, relations, {
+			logger,
+			cache,
+		});
+		const db = new EffectSQLiteWasmDatabase(dialect, session, relations);
+		(<any> db).$client = client;
+		(<any> db).$cache = cache;
+		if ((<any> db).$cache) {
+			(<any> db).$cache['invalidate'] = cache.onMutate;
+		}
+
+		return db as EffectSQLiteWasmDatabase<TRelations> & {
+			$client: SqliteClient;
+		};
+	},
+);
+
+/**
+ * Convenience function that creates an EffectSQLiteWasmDatabase with `DefaultServices` already provided.
+ */
+export const makeWithDefaults = <
+	TRelations extends AnyRelations = EmptyRelations,
+>(config: EffectDrizzleSQLiteConfig<TRelations> = {}) => make(config).pipe(Effect.provide(DefaultServices));
diff --git a/drizzle-orm/src/effect-sqlite-wasm/index.ts b/drizzle-orm/src/effect-sqlite-wasm/index.ts
new file mode 100644
index 0000000000..e85b4d1813
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-wasm/index.ts
@@ -0,0 +1,3 @@
+export { EffectLogger } from '~/effect-core/index.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/effect-sqlite-wasm/migrator.ts b/drizzle-orm/src/effect-sqlite-wasm/migrator.ts
new file mode 100644
index 0000000000..08e9161900
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-wasm/migrator.ts
@@ -0,0 +1,53 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import { formatToMillis } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrate as coreMigrate } from '~/sqlite-core/effect/session.ts';
+import type { EffectSQLiteWasmDatabase } from './driver.ts';
+
+interface MigrationConfig {
+	migrations: Record<string, string>;
+	migrationsTable?: string;
+	/** @internal */
+	init?: boolean;
+}
+
+function readMigrationFiles({ migrations }: MigrationConfig): MigrationMeta[] {
+	const migrationQueries: MigrationMeta[] = [];
+
+	const sortedMigrations = Object.keys(migrations).sort();
+
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
+		if (!query) {
+			throw new Error(`Missing migration: ${key}`);
+		}
+
+		try {
+			const result = query.split('--> statement-breakpoint').map((it) => {
+				return it;
+			});
+
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
+			migrationQueries.push({
+				sql: result,
+				bps: true,
+				folderMillis: migrationDate,
+				hash: '',
+				name: key,
+			});
+		} catch {
+			throw new Error(`Failed to parse migration: ${key}`);
+		}
+	}
+
+	return migrationQueries;
+}
+
+export function migrate<TRelations extends AnyRelations>(
+	db: EffectSQLiteWasmDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/effect-sqlite-wasm/session.ts b/drizzle-orm/src/effect-sqlite-wasm/session.ts
new file mode 100644
index 0000000000..48c8696af5
--- /dev/null
+++ b/drizzle-orm/src/effect-sqlite-wasm/session.ts
@@ -0,0 +1,120 @@
+import type { SqliteClient } from '@effect/sql-sqlite-wasm/SqliteClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { EffectDrizzleQueryError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	SQLiteEffectPreparedQuery,
+	type SQLiteEffectQueryExecutors,
+	SQLiteEffectSession,
+	SQLiteEffectTransaction,
+} from '~/sqlite-core/effect/session.ts';
+import type { PreparedQueryConfig, SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+
+export interface EffectSQLiteWasmQueryEffectHKT extends QueryEffectHKTBase {
+	readonly error: EffectDrizzleQueryError;
+	readonly context: never;
+}
+
+export type EffectSQLiteWasmRunResult = unknown;
+
+export interface EffectSQLiteWasmSessionOptions {
+	logger: EffectLoggerShape;
+	cache: EffectCacheShape;
+}
+
+export class EffectSQLiteWasmSession<TRelations extends AnyRelations>
+	extends SQLiteEffectSession<EffectSQLiteWasmRunResult, EffectSQLiteWasmQueryEffectHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteWasmSession';
+
+	constructor(
+		private client: SqliteClient,
+		dialect: SQLiteDialect,
+		protected relations: TRelations,
+		private options: EffectSQLiteWasmSessionOptions,
+	) {
+		super(dialect);
+	}
+
+	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, EffectSQLiteWasmQueryEffectHKT> {
+		const executors: SQLiteEffectQueryExecutors = {
+			all: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values;
+				return q.withoutTransform;
+			},
+			get: (params) => {
+				const q = this.client.unsafe(query.sql, params);
+
+				if (mode === 'arrays') return q.values.pipe(Effect.map((e) => e[0]));
+				return q.withoutTransform.pipe(Effect.map((e) => e[0]));
+			},
+			values: (params) => this.client.unsafe(query.sql, params).values,
+			run: (params) => this.client.unsafe(query.sql, params).raw,
+		};
+
+		return new SQLiteEffectPreparedQuery<T, EffectSQLiteWasmQueryEffectHKT>(
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.options.logger,
+			this.options.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: EffectSQLiteWasmTransaction<TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		const { dialect, relations } = this;
+
+		return this.client.withTransaction(Effect.gen({ self: this }, function*() {
+			const tx = new EffectSQLiteWasmTransaction<TRelations>(
+				dialect,
+				this,
+				relations,
+			);
+
+			return yield* transaction(tx);
+		}));
+	}
+}
+
+export class EffectSQLiteWasmTransaction<TRelations extends AnyRelations>
+	extends SQLiteEffectTransaction<EffectSQLiteWasmQueryEffectHKT, EffectSQLiteWasmRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'EffectSQLiteWasmTransaction';
+
+	override transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<EffectSQLiteWasmQueryEffectHKT, EffectSQLiteWasmRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
diff --git a/drizzle-orm/src/entity.ts b/drizzle-orm/src/entity.ts
index 2b6dfb4def..bd462a03e7 100644
--- a/drizzle-orm/src/entity.ts
+++ b/drizzle-orm/src/entity.ts
@@ -14,7 +14,7 @@ export function is<T extends DrizzleEntityClass<any>>(value: any, type: T): valu
 		return false;
 	}
 
-	if (value instanceof type) { // eslint-disable-line no-instanceof/no-instanceof
+	if (value instanceof type) { // oxlint-disable-line drizzle-internal/no-instanceof
 		return true;
 	}
 
@@ -26,7 +26,7 @@ export function is<T extends DrizzleEntityClass<any>>(value: any, type: T): valu
 		);
 	}
 
-	let cls = Object.getPrototypeOf(value).constructor;
+	let cls = Object.getPrototypeOf(value)?.constructor;
 	if (cls) {
 		// Traverse the prototype chain to find the entityKind
 		while (cls) {
diff --git a/drizzle-orm/src/errors.ts b/drizzle-orm/src/errors.ts
index a72615c9bf..0ab83f8abb 100644
--- a/drizzle-orm/src/errors.ts
+++ b/drizzle-orm/src/errors.ts
@@ -10,10 +10,28 @@ export class DrizzleError extends Error {
 	}
 }
 
+export class DrizzleQueryError extends Error {
+	static readonly [entityKind]: string = 'DrizzleQueryError';
+
+	constructor(
+		public query: string,
+		public params: any[],
+		public override cause?: Error,
+	) {
+		super(`Failed query: ${query}\nparams: ${params}`);
+		this.name = 'DrizzleQueryError';
+		Error.captureStackTrace(this, DrizzleQueryError);
+
+		// ES2022+: preserves original error on `.cause`
+		if (cause) (this as any).cause = cause;
+	}
+}
+
 export class TransactionRollbackError extends DrizzleError {
 	static override readonly [entityKind]: string = 'TransactionRollbackError';
 
 	constructor() {
 		super({ message: 'Rollback' });
+		this.name = 'TransactionRollbackError';
 	}
 }
diff --git a/drizzle-orm/src/errors/index.ts b/drizzle-orm/src/errors/index.ts
deleted file mode 100644
index 55f1cd949f..0000000000
--- a/drizzle-orm/src/errors/index.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export class DrizzleQueryError extends Error {
-	constructor(
-		public query: string,
-		public params: any[],
-		public override cause?: Error,
-	) {
-		super(`Failed query: ${query}\nparams: ${params}`);
-		Error.captureStackTrace(this, DrizzleQueryError);
-
-		// ES2022+: preserves original error on `.cause`
-		if (cause) (this as any).cause = cause;
-	}
-}
diff --git a/drizzle-orm/src/expo-sqlite/driver.ts b/drizzle-orm/src/expo-sqlite/driver.ts
index fce53eed21..98ba7b02e2 100644
--- a/drizzle-orm/src/expo-sqlite/driver.ts
+++ b/drizzle-orm/src/expo-sqlite/driver.ts
@@ -1,30 +1,28 @@
-import type { SQLiteDatabase, SQLiteRunResult } from 'expo-sqlite';
+import type { SQLiteDatabase } from 'expo-sqlite';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { ExpoSQLiteSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type ExpoSQLiteRunResult, ExpoSQLiteSession } from './session.ts';
 
-export class ExpoSQLiteDatabase<TSchema extends Record<string, unknown> = Record<string, never>>
-	extends BaseSQLiteDatabase<'sync', SQLiteRunResult, TSchema>
+export class ExpoSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'sync', ExpoSQLiteRunResult, TRelations>
 {
 	static override readonly [entityKind]: string = 'ExpoSQLiteDatabase';
 }
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	client: SQLiteDatabase,
-	config: DrizzleConfig<TSchema> = {},
-): ExpoSQLiteDatabase<TSchema> & {
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): ExpoSQLiteDatabase<TRelations> & {
 	$client: SQLiteDatabase;
 } {
-	const dialect = new SQLiteSyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -32,21 +30,16 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new ExpoSQLiteSession(client, dialect, schema, { logger });
-	const db = new ExpoSQLiteDatabase('sync', dialect, session, schema) as ExpoSQLiteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new ExpoSQLiteSession(client, dialect, relations, {
+		logger,
+	});
+	const db = new ExpoSQLiteDatabase(
+		'sync',
+		dialect,
+		session,
+		relations,
+	) as ExpoSQLiteDatabase<TRelations>;
 	(<any> db).$client = client;
 
 	return db as any;
diff --git a/drizzle-orm/src/expo-sqlite/migrator.ts b/drizzle-orm/src/expo-sqlite/migrator.ts
index 8906121cfa..f16fd4526c 100644
--- a/drizzle-orm/src/expo-sqlite/migrator.ts
+++ b/drizzle-orm/src/expo-sqlite/migrator.ts
@@ -1,22 +1,23 @@
 import { useEffect, useReducer } from 'react';
-import type { MigrationMeta } from '~/migrator.ts';
+import { formatToMillis } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { migrateSync } from '~/sqlite-core/async/session.ts';
+import type { MigrationMeta } from '../migrator.ts';
 import type { ExpoSQLiteDatabase } from './driver.ts';
 
 interface MigrationConfig {
-	journal: {
-		entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
-	};
 	migrations: Record<string, string>;
 }
 
-async function readMigrationFiles({ journal, migrations }: MigrationConfig): Promise<MigrationMeta[]> {
+async function readMigrationFiles({ migrations }: MigrationConfig): Promise<MigrationMeta[]> {
 	const migrationQueries: MigrationMeta[] = [];
 
-	for await (const journalEntry of journal.entries) {
-		const query = migrations[`m${journalEntry.idx.toString().padStart(4, '0')}`];
+	const sortedMigrations = Object.keys(migrations).sort();
 
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
 		if (!query) {
-			throw new Error(`Missing migration: ${journalEntry.tag}`);
+			throw new Error(`Missing migration: ${key}`);
 		}
 
 		try {
@@ -24,26 +25,29 @@ async function readMigrationFiles({ journal, migrations }: MigrationConfig): Pro
 				return it;
 			});
 
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
 			migrationQueries.push({
 				sql: result,
-				bps: journalEntry.breakpoints,
-				folderMillis: journalEntry.when,
+				bps: true,
+				folderMillis: migrationDate,
 				hash: '',
+				name: key,
 			});
 		} catch {
-			throw new Error(`Failed to parse migration: ${journalEntry.tag}`);
+			throw new Error(`Failed to parse migration: ${key}`);
 		}
 	}
 
 	return migrationQueries;
 }
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: ExpoSQLiteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: ExpoSQLiteDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = await readMigrationFiles(config);
-	return db.dialect.migrate(migrations, db.session);
+	return migrateSync(migrations, db.session);
 }
 
 interface State {
diff --git a/drizzle-orm/src/expo-sqlite/query.ts b/drizzle-orm/src/expo-sqlite/query.ts
index a38fc30466..d0a85c587a 100644
--- a/drizzle-orm/src/expo-sqlite/query.ts
+++ b/drizzle-orm/src/expo-sqlite/query.ts
@@ -2,23 +2,31 @@ import { addDatabaseChangeListener } from 'expo-sqlite';
 import { useEffect, useState } from 'react';
 import { is } from '~/entity.ts';
 import { SQL } from '~/sql/sql.ts';
-import type { AnySQLiteSelect } from '~/sqlite-core/index.ts';
+import { SQLiteAsyncRelationalQuery } from '~/sqlite-core/async/query.ts';
+import type { AnySQLiteAsyncSelect } from '~/sqlite-core/async/select.ts';
 import { getTableConfig, getViewConfig, SQLiteTable, SQLiteView } from '~/sqlite-core/index.ts';
-import { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
 import { Subquery } from '~/subquery.ts';
 
-export const useLiveQuery = <T extends Pick<AnySQLiteSelect, '_' | 'then'> | SQLiteRelationalQuery<'sync', unknown>>(
+export const useLiveQuery = <
+	T extends
+		| Pick<AnySQLiteAsyncSelect, '_' | 'then'>
+		| SQLiteAsyncRelationalQuery<'sync', unknown>,
+>(
 	query: T,
 	deps: unknown[] = [],
 ) => {
 	const [data, setData] = useState<Awaited<T>>(
-		(is(query, SQLiteRelationalQuery) && query.mode === 'first' ? undefined : []) as Awaited<T>,
+		(is(query, SQLiteAsyncRelationalQuery) && query.mode === 'first'
+			? undefined
+			: []) as Awaited<T>,
 	);
 	const [error, setError] = useState<Error>();
 	const [updatedAt, setUpdatedAt] = useState<Date>();
 
 	useEffect(() => {
-		const entity = is(query, SQLiteRelationalQuery) ? query.table : (query as AnySQLiteSelect).config.table;
+		const entity = is(query, SQLiteAsyncRelationalQuery)
+			? query.table
+			: (query as AnySQLiteAsyncSelect).config.table;
 
 		if (is(entity, Subquery) || is(entity, SQL)) {
 			setError(new Error('Selecting from subqueries and SQL are not supported in useLiveQuery'));
diff --git a/drizzle-orm/src/expo-sqlite/session.ts b/drizzle-orm/src/expo-sqlite/session.ts
index cb880ac6e3..7eab8fde12 100644
--- a/drizzle-orm/src/expo-sqlite/session.ts
+++ b/drizzle-orm/src/expo-sqlite/session.ts
@@ -1,69 +1,104 @@
 import type { SQLiteDatabase, SQLiteRunResult, SQLiteStatement } from 'expo-sqlite';
 import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	SQLitePreparedQuery,
-	SQLiteSession,
-	type SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 
 export interface ExpoSQLiteSessionOptions {
 	logger?: Logger;
 }
 
+export type ExpoSQLiteRunResult = SQLiteRunResult;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class ExpoSQLiteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'sync', SQLiteRunResult, TFullSchema, TSchema> {
+export class ExpoSQLiteSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'sync', ExpoSQLiteRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'ExpoSQLiteSession';
 
 	private logger: Logger;
 
 	constructor(
 		private client: SQLiteDatabase,
-		dialect: SQLiteSyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: ExpoSQLiteSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: ExpoSQLiteSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'sync');
 		this.logger = options.logger ?? new NoopLogger();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
-	): ExpoSQLitePreparedQuery<T> {
-		const stmt = this.client.prepareSync(query.sql);
-		return new ExpoSQLitePreparedQuery(
-			stmt,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+	): SQLiteAsyncPreparedQuery<T & { run: ExpoSQLiteRunResult }> {
+		let stmt: SQLiteStatement;
+		try {
+			stmt = this.client.prepareSync(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				if (mode === 'arrays') return stmt.executeForRawResultSync(params as any[]).getAllSync();
+				return stmt.executeSync(params as any[]).getAllSync();
+			},
+			get: (params) => {
+				if (mode === 'arrays') return stmt.executeForRawResultSync(params as any[]).getFirstSync();
+				return stmt.executeSync(params as any[]).getFirstSync();
+			},
+			run: (params) => {
+				const res = stmt.executeSync(params as any[]);
+				return {
+					changes: res.changes,
+					lastInsertRowId: res.lastInsertRowId,
+				};
+			},
+			values: (params) => {
+				return stmt.executeForRawResultSync(params as any[]).getAllSync();
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+			undefined,
+			queryMetadata,
+			undefined,
 		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: ExpoSQLiteTransaction<TFullSchema, TSchema>) => T,
+		transaction: (tx: ExpoSQLiteTransaction<TRelations>) => T,
 		config: SQLiteTransactionConfig = {},
 	): T {
-		const tx = new ExpoSQLiteTransaction('sync', this.dialect, this, this.schema);
+		const tx = new ExpoSQLiteTransaction('sync', this.dialect, this, this.relations);
 		this.run(sql.raw(`begin${config?.behavior ? ' ' + config.behavior : ''}`));
 		try {
 			const result = transaction(tx);
@@ -77,99 +112,32 @@ export class ExpoSQLiteSession<
 }
 
 export class ExpoSQLiteTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'sync', SQLiteRunResult, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends SQLiteAsyncTransaction<'sync', ExpoSQLiteRunResult, TRelations> {
 	static override readonly [entityKind]: string = 'ExpoSQLiteTransaction';
 
-	override transaction<T>(transaction: (tx: ExpoSQLiteTransaction<TFullSchema, TSchema>) => T): T {
+	override transaction<T>(
+		transaction: (
+			tx: ExpoSQLiteTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new ExpoSQLiteTransaction('sync', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new ExpoSQLiteTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = transaction(tx);
 			this.session.run(sql.raw(`release savepoint ${savepointName}`));
-			return result;
+			return result as T;
 		} catch (err) {
 			this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
 			throw err;
 		}
 	}
 }
-
-export class ExpoSQLitePreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
-	{ type: 'sync'; run: SQLiteRunResult; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'ExpoSQLitePreparedQuery';
-
-	constructor(
-		private stmt: SQLiteStatement,
-		query: Query,
-		private logger: Logger,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
-	) {
-		super('sync', executeMethod, query);
-	}
-
-	run(placeholderValues?: Record<string, unknown>): SQLiteRunResult {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		const { changes, lastInsertRowId } = this.stmt.executeSync(params as any[]);
-		return {
-			changes,
-			lastInsertRowId,
-		};
-	}
-
-	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return stmt.executeSync(params as any[]).getAllSync();
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, stmt, joinsNotNullableMap, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			return stmt.executeSync(params as any[]).getFirstSync();
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-		const row = rows[0];
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['get'];
-		}
-
-		return mapResultRow(fields!, row, joinsNotNullableMap);
-	}
-
-	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.stmt.executeForRawResultSync(params as any[]).getAllSync();
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/alias.ts b/drizzle-orm/src/gel-core/alias.ts
deleted file mode 100644
index 99dd07fb89..0000000000
--- a/drizzle-orm/src/gel-core/alias.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { TableAliasProxyHandler } from '~/alias.ts';
-import type { BuildAliasTable } from './query-builders/select.types.ts';
-
-import type { GelTable } from './table.ts';
-import type { GelViewBase } from './view-base.ts';
-
-export function alias<TTable extends GelTable | GelViewBase, TAlias extends string>(
-	table: TTable,
-	alias: TAlias,
-): BuildAliasTable<TTable, TAlias> {
-	return new Proxy(table, new TableAliasProxyHandler(alias, false)) as any;
-}
diff --git a/drizzle-orm/src/gel-core/checks.ts b/drizzle-orm/src/gel-core/checks.ts
deleted file mode 100644
index 18dd46c49c..0000000000
--- a/drizzle-orm/src/gel-core/checks.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
-import type { GelTable } from './table.ts';
-
-export class CheckBuilder {
-	static readonly [entityKind]: string = 'GelCheckBuilder';
-
-	protected brand!: 'GelConstraintBuilder';
-
-	constructor(public name: string, public value: SQL) {}
-
-	/** @internal */
-	build(table: GelTable): Check {
-		return new Check(table, this);
-	}
-}
-
-export class Check {
-	static readonly [entityKind]: string = 'GelCheck';
-
-	readonly name: string;
-	readonly value: SQL;
-
-	constructor(public table: GelTable, builder: CheckBuilder) {
-		this.name = builder.name;
-		this.value = builder.value;
-	}
-}
-
-export function check(name: string, value: SQL): CheckBuilder {
-	return new CheckBuilder(name, value);
-}
diff --git a/drizzle-orm/src/gel-core/columns/all.ts b/drizzle-orm/src/gel-core/columns/all.ts
deleted file mode 100644
index 8220702c8a..0000000000
--- a/drizzle-orm/src/gel-core/columns/all.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { bigint } from './bigint.ts';
-import { bigintT } from './bigintT.ts';
-import { boolean } from './boolean.ts';
-import { bytes } from './bytes.ts';
-import { customType } from './custom.ts';
-import { dateDuration } from './date-duration.ts';
-import { decimal } from './decimal.ts';
-import { doublePrecision } from './double-precision.ts';
-import { duration } from './duration.ts';
-import { integer } from './integer.ts';
-import { json } from './json.ts';
-import { localDate } from './localdate.ts';
-import { localTime } from './localtime.ts';
-import { real } from './real.ts';
-import { relDuration } from './relative-duration.ts';
-import { smallint } from './smallint.ts';
-import { text } from './text.ts';
-import { timestamp } from './timestamp.ts';
-import { timestamptz } from './timestamptz.ts';
-import { uuid } from './uuid.ts';
-
-// TODO add
-export function getGelColumnBuilders() {
-	return {
-		localDate,
-		localTime,
-		decimal,
-		dateDuration,
-		bigintT,
-		duration,
-		relDuration,
-		bytes,
-		customType,
-		bigint,
-		boolean,
-		doublePrecision,
-		integer,
-		json,
-		real,
-		smallint,
-		text,
-		timestamptz,
-		uuid,
-		timestamp,
-	};
-}
-
-export type GelColumnsBuilders = ReturnType<typeof getGelColumnBuilders>;
diff --git a/drizzle-orm/src/gel-core/columns/bigint.ts b/drizzle-orm/src/gel-core/columns/bigint.ts
deleted file mode 100644
index d2664891dc..0000000000
--- a/drizzle-orm/src/gel-core/columns/bigint.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelIntColumnBaseBuilder } from './int.common.ts';
-
-export type GelInt53BuilderInitial<TName extends string> = GelInt53Builder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'GelInt53';
-	data: number;
-	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class GelInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'GelInt53'>>
-	extends GelIntColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelInt53Builder';
-
-	constructor(name: T['name']) {
-		super(name, 'number', 'GelInt53');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelInt53<MakeColumnConfig<T, TTableName>> {
-		return new GelInt53<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelInt53<T extends ColumnBaseConfig<'number', 'GelInt53'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelInt53';
-
-	getSQLType(): string {
-		return 'bigint';
-	}
-}
-
-export function bigint(): GelInt53BuilderInitial<''>;
-export function bigint<TName extends string>(name: TName): GelInt53BuilderInitial<TName>;
-export function bigint(name?: string) {
-	return new GelInt53Builder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/bigintT.ts b/drizzle-orm/src/gel-core/columns/bigintT.ts
deleted file mode 100644
index 563d47c892..0000000000
--- a/drizzle-orm/src/gel-core/columns/bigintT.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelIntColumnBaseBuilder } from './int.common.ts';
-
-export type GelBigInt64BuilderInitial<TName extends string> = GelBigInt64Builder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'GelBigInt64';
-	data: bigint;
-	driverParam: bigint;
-	enumValues: undefined;
-}>;
-
-export class GelBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'GelBigInt64'>>
-	extends GelIntColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelBigInt64Builder';
-
-	constructor(name: T['name']) {
-		super(name, 'bigint', 'GelBigInt64');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelBigInt64<MakeColumnConfig<T, TTableName>> {
-		return new GelBigInt64<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelBigInt64<T extends ColumnBaseConfig<'bigint', 'GelBigInt64'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelBigInt64';
-
-	getSQLType(): string {
-		return 'edgedbt.bigint_t';
-	}
-
-	override mapFromDriverValue(value: string): bigint {
-		return BigInt(value as string); // TODO ts error if remove 'as string'
-	}
-}
-
-export function bigintT(): GelBigInt64BuilderInitial<''>;
-export function bigintT<TName extends string>(name: TName): GelBigInt64BuilderInitial<TName>;
-export function bigintT(name?: string) {
-	return new GelBigInt64Builder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/boolean.ts b/drizzle-orm/src/gel-core/columns/boolean.ts
deleted file mode 100644
index 1e79c26ad3..0000000000
--- a/drizzle-orm/src/gel-core/columns/boolean.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelBooleanBuilderInitial<TName extends string> = GelBooleanBuilder<{
-	name: TName;
-	dataType: 'boolean';
-	columnType: 'GelBoolean';
-	data: boolean;
-	driverParam: boolean;
-	enumValues: undefined;
-}>;
-
-export class GelBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'GelBoolean'>> extends GelColumnBuilder<T> {
-	static override readonly [entityKind]: string = 'GelBooleanBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'boolean', 'GelBoolean');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelBoolean<MakeColumnConfig<T, TTableName>> {
-		return new GelBoolean<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelBoolean<T extends ColumnBaseConfig<'boolean', 'GelBoolean'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelBoolean';
-
-	getSQLType(): string {
-		return 'boolean';
-	}
-}
-
-export function boolean(): GelBooleanBuilderInitial<''>;
-export function boolean<TName extends string>(name: TName): GelBooleanBuilderInitial<TName>;
-export function boolean(name?: string) {
-	return new GelBooleanBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/bytes.ts b/drizzle-orm/src/gel-core/columns/bytes.ts
deleted file mode 100644
index f8110db3d0..0000000000
--- a/drizzle-orm/src/gel-core/columns/bytes.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelBytesBuilderInitial<TName extends string> = GelBytesBuilder<{
-	name: TName;
-	dataType: 'buffer';
-	columnType: 'GelBytes';
-	data: Uint8Array;
-	driverParam: Uint8Array | Buffer;
-	enumValues: undefined;
-}>;
-
-export class GelBytesBuilder<T extends ColumnBuilderBaseConfig<'buffer', 'GelBytes'>> extends GelColumnBuilder<T> {
-	static override readonly [entityKind]: string = 'GelBytesBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'buffer', 'GelBytes');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelBytes<MakeColumnConfig<T, TTableName>> {
-		return new GelBytes<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelBytes<T extends ColumnBaseConfig<'buffer', 'GelBytes'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelBytes';
-
-	getSQLType(): string {
-		return 'bytea';
-	}
-}
-
-export function bytes(): GelBytesBuilderInitial<''>;
-export function bytes<TName extends string>(name: TName): GelBytesBuilderInitial<TName>;
-export function bytes(name?: string) {
-	return new GelBytesBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/common.ts b/drizzle-orm/src/gel-core/columns/common.ts
deleted file mode 100644
index f1f87f086a..0000000000
--- a/drizzle-orm/src/gel-core/columns/common.ts
+++ /dev/null
@@ -1,332 +0,0 @@
-import type {
-	ColumnBuilderBase,
-	ColumnBuilderBaseConfig,
-	ColumnBuilderExtraConfig,
-	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
-	HasGenerated,
-	MakeColumnConfig,
-} from '~/column-builder.ts';
-import { ColumnBuilder } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { Column } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { Simplify, Update } from '~/utils.ts';
-
-import type { ForeignKey, UpdateDeleteAction } from '~/gel-core/foreign-keys.ts';
-import { ForeignKeyBuilder } from '~/gel-core/foreign-keys.ts';
-import type { AnyGelTable, GelTable } from '~/gel-core/table.ts';
-import type { SQL } from '~/sql/sql.ts';
-import { iife } from '~/tracing-utils.ts';
-import type { GelIndexOpClass } from '../indexes.ts';
-import { uniqueKeyName } from '../unique-constraint.ts';
-
-export interface ReferenceConfig {
-	ref: () => GelColumn;
-	actions: {
-		onUpdate?: UpdateDeleteAction;
-		onDelete?: UpdateDeleteAction;
-	};
-}
-
-export interface GelColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'gel' }> {}
-
-export abstract class GelColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
-	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'gel' }, TExtraConfig>
-	implements GelColumnBuilderBase<T, TTypeConfig>
-{
-	private foreignKeyConfigs: ReferenceConfig[] = [];
-
-	static override readonly [entityKind]: string = 'GelColumnBuilder';
-
-	array<TSize extends number | undefined = undefined>(size?: TSize): GelArrayBuilder<
-		& {
-			name: T['name'];
-			dataType: 'array';
-			columnType: 'GelArray';
-			data: T['data'][];
-			driverParam: T['driverParam'][] | string;
-			enumValues: T['enumValues'];
-			size: TSize;
-			baseBuilder: T;
-		}
-		& (T extends { notNull: true } ? { notNull: true } : {})
-		& (T extends { hasDefault: true } ? { hasDefault: true } : {}),
-		T
-	> {
-		return new GelArrayBuilder(this.config.name, this as GelColumnBuilder<any, any>, size as any);
-	}
-
-	references(
-		ref: ReferenceConfig['ref'],
-		actions: ReferenceConfig['actions'] = {},
-	): this {
-		this.foreignKeyConfigs.push({ ref, actions });
-		return this;
-	}
-
-	unique(
-		name?: string,
-		config?: { nulls: 'distinct' | 'not distinct' },
-	): this {
-		this.config.isUnique = true;
-		this.config.uniqueName = name;
-		this.config.uniqueType = config?.nulls;
-		return this;
-	}
-
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL)): HasGenerated<this, {
-		type: 'always';
-	}> {
-		this.config.generated = {
-			as,
-			type: 'always',
-			mode: 'stored',
-		};
-		return this as HasGenerated<this, {
-			type: 'always';
-		}>;
-	}
-
-	/** @internal */
-	buildForeignKeys(column: GelColumn, table: GelTable): ForeignKey[] {
-		return this.foreignKeyConfigs.map(({ ref, actions }) => {
-			return iife(
-				(ref, actions) => {
-					const builder = new ForeignKeyBuilder(() => {
-						const foreignColumn = ref();
-						return { columns: [column], foreignColumns: [foreignColumn] };
-					});
-					if (actions.onUpdate) {
-						builder.onUpdate(actions.onUpdate);
-					}
-					if (actions.onDelete) {
-						builder.onDelete(actions.onDelete);
-					}
-					return builder.build(table);
-				},
-				ref,
-				actions,
-			);
-		});
-	}
-
-	/** @internal */
-	abstract build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelColumn<MakeColumnConfig<T, TTableName>>;
-
-	/** @internal */
-	buildExtraConfigColumn<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelExtraConfigColumn {
-		return new GelExtraConfigColumn(table, this.config);
-	}
-}
-
-// To understand how to use `GelColumn` and `GelColumn`, see `Column` and `AnyColumn` documentation.
-export abstract class GelColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = {},
-	TTypeConfig extends object = {},
-> extends Column<T, TRuntimeConfig, TTypeConfig & { dialect: 'gel' }> {
-	static override readonly [entityKind]: string = 'GelColumn';
-
-	constructor(
-		override readonly table: GelTable,
-		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
-	) {
-		if (!config.uniqueName) {
-			config.uniqueName = uniqueKeyName(table, [config.name]);
-		}
-		super(table, config);
-	}
-}
-
-export type IndexedExtraConfigType = { order?: 'asc' | 'desc'; nulls?: 'first' | 'last'; opClass?: string };
-
-export class GelExtraConfigColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-> extends GelColumn<T, IndexedExtraConfigType> {
-	static override readonly [entityKind]: string = 'GelExtraConfigColumn';
-
-	override getSQLType(): string {
-		return this.getSQLType();
-	}
-
-	indexConfig: IndexedExtraConfigType = {
-		order: this.config.order ?? 'asc',
-		nulls: this.config.nulls ?? 'last',
-		opClass: this.config.opClass,
-	};
-	defaultConfig: IndexedExtraConfigType = {
-		order: 'asc',
-		nulls: 'last',
-		opClass: undefined,
-	};
-
-	asc(): Omit<this, 'asc' | 'desc'> {
-		this.indexConfig.order = 'asc';
-		return this;
-	}
-
-	desc(): Omit<this, 'asc' | 'desc'> {
-		this.indexConfig.order = 'desc';
-		return this;
-	}
-
-	nullsFirst(): Omit<this, 'nullsFirst' | 'nullsLast'> {
-		this.indexConfig.nulls = 'first';
-		return this;
-	}
-
-	nullsLast(): Omit<this, 'nullsFirst' | 'nullsLast'> {
-		this.indexConfig.nulls = 'last';
-		return this;
-	}
-
-	/**
-	 * ### PostgreSQL documentation quote
-	 *
-	 * > An operator class with optional parameters can be specified for each column of an index.
-	 * The operator class identifies the operators to be used by the index for that column.
-	 * For example, a B-tree index on four-byte integers would use the int4_ops class;
-	 * this operator class includes comparison functions for four-byte integers.
-	 * In practice the default operator class for the column's data type is usually sufficient.
-	 * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
-	 * For example, we might want to sort a complex-number data type either by absolute value or by real part.
-	 * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
-	 * More information about operator classes check:
-	 *
-	 * ### Useful links
-	 * https://www.postgresql.org/docs/current/sql-createindex.html
-	 *
-	 * https://www.postgresql.org/docs/current/indexes-opclass.html
-	 *
-	 * https://www.postgresql.org/docs/current/xindex.html
-	 *
-	 * ### Additional types
-	 * If you have the `Gel_vector` extension installed in your database, you can use the
-	 * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
-	 *
-	 * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
-	 *
-	 * @param opClass
-	 * @returns
-	 */
-	op(opClass: GelIndexOpClass): Omit<this, 'op'> {
-		this.indexConfig.opClass = opClass;
-		return this;
-	}
-}
-
-export class IndexedColumn {
-	static readonly [entityKind]: string = 'IndexedColumn';
-	constructor(
-		name: string | undefined,
-		keyAsName: boolean,
-		type: string,
-		indexConfig: IndexedExtraConfigType,
-	) {
-		this.name = name;
-		this.keyAsName = keyAsName;
-		this.type = type;
-		this.indexConfig = indexConfig;
-	}
-
-	name: string | undefined;
-	keyAsName: boolean;
-	type: string;
-	indexConfig: IndexedExtraConfigType;
-}
-
-export type AnyGelColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = GelColumn<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
->;
-
-export type GelArrayColumnBuilderBaseConfig = ColumnBuilderBaseConfig<'array', 'GelArray'> & {
-	size: number | undefined;
-	baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-};
-
-export class GelArrayBuilder<
-	T extends GelArrayColumnBuilderBaseConfig,
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string> | GelArrayColumnBuilderBaseConfig,
-> extends GelColumnBuilder<
-	T,
-	{
-		baseBuilder: TBase extends GelArrayColumnBuilderBaseConfig ? GelArrayBuilder<
-				TBase,
-				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any> } ? TBaseBuilder
-					: never
-			>
-			: GelColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-		size: T['size'];
-	},
-	{
-		baseBuilder: TBase extends GelArrayColumnBuilderBaseConfig ? GelArrayBuilder<
-				TBase,
-				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any> } ? TBaseBuilder
-					: never
-			>
-			: GelColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-		size: T['size'];
-	}
-> {
-	static override readonly [entityKind] = 'GelArrayBuilder';
-
-	constructor(
-		name: string,
-		baseBuilder: GelArrayBuilder<T, TBase>['config']['baseBuilder'],
-		size: T['size'],
-	) {
-		super(name, 'array', 'GelArray');
-		this.config.baseBuilder = baseBuilder;
-		this.config.size = size;
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelArray<MakeColumnConfig<T, TTableName> & { size: T['size']; baseBuilder: T['baseBuilder'] }, TBase> {
-		const baseColumn = this.config.baseBuilder.build(table);
-		return new GelArray<MakeColumnConfig<T, TTableName> & { size: T['size']; baseBuilder: T['baseBuilder'] }, TBase>(
-			table as AnyGelTable<{ name: MakeColumnConfig<T, TTableName>['tableName'] }>,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-			baseColumn,
-		);
-	}
-}
-
-export class GelArray<
-	T extends ColumnBaseConfig<'array', 'GelArray'> & {
-		size: number | undefined;
-		baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-	},
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends GelColumn<T, {}, { size: T['size']; baseBuilder: T['baseBuilder'] }> {
-	readonly size: T['size'];
-
-	static override readonly [entityKind]: string = 'GelArray';
-
-	constructor(
-		table: AnyGelTable<{ name: T['tableName'] }>,
-		config: GelArrayBuilder<T, TBase>['config'],
-		readonly baseColumn: GelColumn,
-		readonly range?: [number | undefined, number | undefined],
-	) {
-		super(table, config);
-		this.size = config.size;
-	}
-
-	getSQLType(): string {
-		return `${this.baseColumn.getSQLType()}[${typeof this.size === 'number' ? this.size : ''}]`;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/columns/custom.ts b/drizzle-orm/src/gel-core/columns/custom.ts
deleted file mode 100644
index 08971c35b9..0000000000
--- a/drizzle-orm/src/gel-core/columns/custom.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import type { SQL } from '~/sql/sql.ts';
-import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
-	& {
-		name: TName;
-		dataType: 'custom';
-		columnType: 'GelCustomColumn';
-		data: T['data'];
-		driverParam: T['driverData'];
-		enumValues: undefined;
-	}
-	& (T['notNull'] extends true ? { notNull: true } : {})
-	& (T['default'] extends true ? { hasDefault: true } : {});
-
-export interface GelCustomColumnInnerConfig {
-	customTypeValues: CustomTypeValues;
-}
-
-export class GelCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'GelCustomColumn'>>
-	extends GelColumnBuilder<
-		T,
-		{
-			fieldConfig: CustomTypeValues['config'];
-			customTypeParams: CustomTypeParams<any>;
-		},
-		{
-			gelColumnBuilderBrand: 'GelCustomColumnBuilderBrand';
-		}
-	>
-{
-	static override readonly [entityKind]: string = 'GelCustomColumnBuilder';
-
-	constructor(
-		name: T['name'],
-		fieldConfig: CustomTypeValues['config'],
-		customTypeParams: CustomTypeParams<any>,
-	) {
-		super(name, 'custom', 'GelCustomColumn');
-		this.config.fieldConfig = fieldConfig;
-		this.config.customTypeParams = customTypeParams;
-	}
-
-	/** @internal */
-	build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new GelCustomColumn<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelCustomColumn<T extends ColumnBaseConfig<'custom', 'GelCustomColumn'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelCustomColumn';
-
-	private sqlName: string;
-	private mapTo?: (value: T['data']) => T['driverParam'];
-	private mapFrom?: (value: T['driverParam']) => T['data'];
-
-	constructor(
-		table: AnyGelTable<{ name: T['tableName'] }>,
-		config: GelCustomColumnBuilder<T>['config'],
-	) {
-		super(table, config);
-		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-		this.mapTo = config.customTypeParams.toDriver;
-		this.mapFrom = config.customTypeParams.fromDriver;
-	}
-
-	getSQLType(): string {
-		return this.sqlName;
-	}
-
-	override mapFromDriverValue(value: T['driverParam']): T['data'] {
-		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
-	}
-
-	override mapToDriverValue(value: T['data']): T['driverParam'] {
-		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
-	}
-}
-
-export type CustomTypeValues = {
-	/**
-	 * Required type for custom column, that will infer proper type model
-	 *
-	 * Examples:
-	 *
-	 * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
-	 *
-	 * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
-	 */
-	data: unknown;
-
-	/**
-	 * Type helper, that represents what type database driver is accepting for specific database data type
-	 */
-	driverData?: unknown;
-
-	/**
-	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
-	 */
-	config?: Record<string, any>;
-
-	/**
-	 * Whether the config argument should be required or not
-	 * @default false
-	 */
-	configRequired?: boolean;
-
-	/**
-	 * If your custom data type should be notNull by default you can use `notNull: true`
-	 *
-	 * @example
-	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
-	 * 	  dataType() {
-	 * 	    return 'serial';
-	 *    },
-	 * });
-	 */
-	notNull?: boolean;
-
-	/**
-	 * If your custom data type has default you can use `default: true`
-	 *
-	 * @example
-	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
-	 * 	  dataType() {
-	 * 	    return 'serial';
-	 *    },
-	 * });
-	 */
-	default?: boolean;
-};
-
-export interface CustomTypeParams<T extends CustomTypeValues> {
-	/**
-	 * Database data type string representation, that is used for migrations
-	 * @example
-	 * ```
-	 * `jsonb`, `text`
-	 * ```
-	 *
-	 * If database data type needs additional params you can use them from `config` param
-	 * @example
-	 * ```
-	 * `varchar(256)`, `numeric(2,3)`
-	 * ```
-	 *
-	 * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
-	 *
-	 * @example
-	 * Usage example
-	 * ```
-	 *   dataType() {
-	 *     return 'boolean';
-	 *   },
-	 * ```
-	 * Or
-	 * ```
-	 *   dataType(config) {
-	 * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
-	 * 	 }
-	 * ```
-	 */
-	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
-
-	/**
-	 * Optional mapping function, between user input and driver
-	 * @example
-	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
-	 * ```
-	 * toDriver(value: TData): string {
-	 * 	 return JSON.stringify(value);
-	 * }
-	 * ```
-	 */
-	toDriver?: (value: T['data']) => T['driverData'] | SQL;
-
-	/**
-	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
-	 * @example
-	 * For example, when using timestamp we need to map string Date representation to JS Date
-	 * ```
-	 * fromDriver(value: string): Date {
-	 * 	return new Date(value);
-	 * },
-	 * ```
-	 */
-	fromDriver?: (value: T['driverData']) => T['data'];
-}
-
-/**
- * Custom gel database data type generator
- */
-export function customType<T extends CustomTypeValues = CustomTypeValues>(
-	customTypeParams: CustomTypeParams<T>,
-): Equal<T['configRequired'], true> extends true ? {
-		<TConfig extends Record<string, any> & T['config']>(
-			fieldConfig: TConfig,
-		): GelCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
-			fieldConfig: T['config'],
-		): GelCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
-	}
-	: {
-		(): GelCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TConfig extends Record<string, any> & T['config']>(
-			fieldConfig?: TConfig,
-		): GelCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
-			fieldConfig?: T['config'],
-		): GelCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
-	}
-{
-	return <TName extends string>(
-		a?: TName | T['config'],
-		b?: T['config'],
-	): GelCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
-		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
-		return new GelCustomColumnBuilder(name as ConvertCustomConfig<TName, T>['name'], config, customTypeParams);
-	};
-}
diff --git a/drizzle-orm/src/gel-core/columns/date-duration.ts b/drizzle-orm/src/gel-core/columns/date-duration.ts
deleted file mode 100644
index 0298b5d27e..0000000000
--- a/drizzle-orm/src/gel-core/columns/date-duration.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { DateDuration } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelDateDurationBuilderInitial<TName extends string> = GelDateDurationBuilder<{
-	name: TName;
-	dataType: 'dateDuration';
-	columnType: 'GelDateDuration';
-	data: DateDuration;
-	driverParam: DateDuration;
-	enumValues: undefined;
-}>;
-
-export class GelDateDurationBuilder<T extends ColumnBuilderBaseConfig<'dateDuration', 'GelDateDuration'>>
-	extends GelColumnBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelDateDurationBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'dateDuration', 'GelDateDuration');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelDateDuration<MakeColumnConfig<T, TTableName>> {
-		return new GelDateDuration<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelDateDuration<T extends ColumnBaseConfig<'dateDuration', 'GelDateDuration'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelDateDuration';
-
-	getSQLType(): string {
-		return `dateDuration`;
-	}
-}
-
-export function dateDuration(): GelDateDurationBuilderInitial<''>;
-export function dateDuration<TName extends string>(name: TName): GelDateDurationBuilderInitial<TName>;
-export function dateDuration(name?: string) {
-	return new GelDateDurationBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/date.common.ts b/drizzle-orm/src/gel-core/columns/date.common.ts
deleted file mode 100644
index f4bebb4833..0000000000
--- a/drizzle-orm/src/gel-core/columns/date.common.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnDataType } from '~/column-builder.ts';
-import { entityKind } from '~/entity.ts';
-import { sql } from '~/sql/sql.ts';
-import { GelColumnBuilder } from './common.ts';
-
-export abstract class GelLocalDateColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = object,
-> extends GelColumnBuilder<T, TRuntimeConfig> {
-	static override readonly [entityKind]: string = 'GelLocalDateColumnBaseBuilder';
-
-	defaultNow() {
-		return this.default(sql`now()`);
-	}
-}
diff --git a/drizzle-orm/src/gel-core/columns/decimal.ts b/drizzle-orm/src/gel-core/columns/decimal.ts
deleted file mode 100644
index 12104e4f8d..0000000000
--- a/drizzle-orm/src/gel-core/columns/decimal.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelDecimalBuilderInitial<TName extends string> = GelDecimalBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'GelDecimal';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class GelDecimalBuilder<T extends ColumnBuilderBaseConfig<'string', 'GelDecimal'>> extends GelColumnBuilder<
-	T
-> {
-	static override readonly [entityKind]: string = 'GelDecimalBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'string', 'GelDecimal');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelDecimal<MakeColumnConfig<T, TTableName>> {
-		return new GelDecimal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelDecimal<T extends ColumnBaseConfig<'string', 'GelDecimal'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelDecimal';
-
-	constructor(table: AnyGelTable<{ name: T['tableName'] }>, config: GelDecimalBuilder<T>['config']) {
-		super(table, config);
-	}
-
-	getSQLType(): string {
-		return 'numeric';
-	}
-}
-
-export function decimal(): GelDecimalBuilderInitial<''>;
-export function decimal<TName extends string>(name: TName): GelDecimalBuilderInitial<TName>;
-export function decimal(name?: string) {
-	return new GelDecimalBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/double-precision.ts b/drizzle-orm/src/gel-core/columns/double-precision.ts
deleted file mode 100644
index 797dc1350e..0000000000
--- a/drizzle-orm/src/gel-core/columns/double-precision.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelDoublePrecisionBuilderInitial<TName extends string> = GelDoublePrecisionBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'GelDoublePrecision';
-	data: number;
-	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class GelDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'GelDoublePrecision'>>
-	extends GelColumnBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelDoublePrecisionBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'number', 'GelDoublePrecision');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelDoublePrecision<MakeColumnConfig<T, TTableName>> {
-		return new GelDoublePrecision<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelDoublePrecision<T extends ColumnBaseConfig<'number', 'GelDoublePrecision'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelDoublePrecision';
-
-	getSQLType(): string {
-		return 'double precision';
-	}
-
-	override mapFromDriverValue(value: string | number): number {
-		if (typeof value === 'string') {
-			return Number.parseFloat(value);
-		}
-		return value;
-	}
-}
-
-export function doublePrecision(): GelDoublePrecisionBuilderInitial<''>;
-export function doublePrecision<TName extends string>(name: TName): GelDoublePrecisionBuilderInitial<TName>;
-export function doublePrecision(name?: string) {
-	return new GelDoublePrecisionBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/duration.ts b/drizzle-orm/src/gel-core/columns/duration.ts
deleted file mode 100644
index 93b70ffa62..0000000000
--- a/drizzle-orm/src/gel-core/columns/duration.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { Duration } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelDurationBuilderInitial<TName extends string> = GelDurationBuilder<{
-	name: TName;
-	dataType: 'duration';
-	columnType: 'GelDuration';
-	data: Duration;
-	driverParam: Duration;
-	enumValues: undefined;
-}>;
-
-export class GelDurationBuilder<T extends ColumnBuilderBaseConfig<'duration', 'GelDuration'>>
-	extends GelColumnBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelDurationBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'duration', 'GelDuration');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelDuration<MakeColumnConfig<T, TTableName>> {
-		return new GelDuration<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelDuration<T extends ColumnBaseConfig<'duration', 'GelDuration'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelDuration';
-
-	getSQLType(): string {
-		return `duration`;
-	}
-}
-
-export function duration(): GelDurationBuilderInitial<''>;
-export function duration<TName extends string>(name: TName): GelDurationBuilderInitial<TName>;
-export function duration(name?: string) {
-	return new GelDurationBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/index.ts b/drizzle-orm/src/gel-core/columns/index.ts
deleted file mode 100644
index 2a0ca0a2c2..0000000000
--- a/drizzle-orm/src/gel-core/columns/index.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-export * from './bigint.ts';
-export * from './bigintT.ts';
-export * from './boolean.ts';
-export * from './bytes.ts';
-export * from './common.ts';
-export * from './custom.ts';
-export * from './date-duration.ts';
-export * from './decimal.ts';
-export * from './double-precision.ts';
-export * from './duration.ts';
-export * from './int.common.ts';
-export * from './integer.ts';
-export * from './json.ts';
-export * from './localdate.ts';
-export * from './localtime.ts';
-export * from './real.ts';
-export * from './relative-duration.ts';
-export * from './smallint.ts';
-export * from './text.ts';
-export * from './timestamp.ts';
-export * from './timestamptz.ts';
-export * from './uuid.ts';
diff --git a/drizzle-orm/src/gel-core/columns/int.common.ts b/drizzle-orm/src/gel-core/columns/int.common.ts
deleted file mode 100644
index 99d5631a45..0000000000
--- a/drizzle-orm/src/gel-core/columns/int.common.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnDataType, GeneratedIdentityConfig, IsIdentity } from '~/column-builder.ts';
-import { entityKind } from '~/entity.ts';
-import type { GelSequenceOptions } from '../sequence.ts';
-import { GelColumnBuilder } from './common.ts';
-
-export abstract class GelIntColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends GelColumnBuilder<
-	T,
-	{ generatedIdentity: GeneratedIdentityConfig }
-> {
-	static override readonly [entityKind]: string = 'GelIntColumnBaseBuilder';
-
-	generatedAlwaysAsIdentity(
-		sequence?: GelSequenceOptions & { name?: string },
-	): IsIdentity<this, 'always'> {
-		if (sequence) {
-			const { name, ...options } = sequence;
-			this.config.generatedIdentity = {
-				type: 'always',
-				sequenceName: name,
-				sequenceOptions: options,
-			};
-		} else {
-			this.config.generatedIdentity = {
-				type: 'always',
-			};
-		}
-
-		this.config.hasDefault = true;
-		this.config.notNull = true;
-
-		return this as IsIdentity<this, 'always'>;
-	}
-
-	generatedByDefaultAsIdentity(
-		sequence?: GelSequenceOptions & { name?: string },
-	): IsIdentity<this, 'byDefault'> {
-		if (sequence) {
-			const { name, ...options } = sequence;
-			this.config.generatedIdentity = {
-				type: 'byDefault',
-				sequenceName: name,
-				sequenceOptions: options,
-			};
-		} else {
-			this.config.generatedIdentity = {
-				type: 'byDefault',
-			};
-		}
-
-		this.config.hasDefault = true;
-		this.config.notNull = true;
-
-		return this as IsIdentity<this, 'byDefault'>;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/columns/integer.ts b/drizzle-orm/src/gel-core/columns/integer.ts
deleted file mode 100644
index 8b8e88e83e..0000000000
--- a/drizzle-orm/src/gel-core/columns/integer.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '../table.ts';
-import { GelColumn } from './common.ts';
-import { GelIntColumnBaseBuilder } from './int.common.ts';
-
-export type GelIntegerBuilderInitial<TName extends string> = GelIntegerBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'GelInteger';
-	data: number;
-	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class GelIntegerBuilder<T extends ColumnBuilderBaseConfig<'number', 'GelInteger'>>
-	extends GelIntColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelIntegerBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'number', 'GelInteger');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelInteger<MakeColumnConfig<T, TTableName>> {
-		return new GelInteger<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelInteger<T extends ColumnBaseConfig<'number', 'GelInteger'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelInteger';
-
-	getSQLType(): string {
-		return 'integer';
-	}
-}
-
-export function integer(): GelIntegerBuilderInitial<''>;
-export function integer<TName extends string>(name: TName): GelIntegerBuilderInitial<TName>;
-export function integer(name?: string) {
-	return new GelIntegerBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/json.ts b/drizzle-orm/src/gel-core/columns/json.ts
deleted file mode 100644
index d6a8346249..0000000000
--- a/drizzle-orm/src/gel-core/columns/json.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelJsonBuilderInitial<TName extends string> = GelJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'GelJson';
-	data: unknown;
-	driverParam: unknown;
-	enumValues: undefined;
-}>;
-
-export class GelJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'GelJson'>> extends GelColumnBuilder<
-	T
-> {
-	static override readonly [entityKind]: string = 'GelJsonBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'json', 'GelJson');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelJson<MakeColumnConfig<T, TTableName>> {
-		return new GelJson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelJson<T extends ColumnBaseConfig<'json', 'GelJson'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelJson';
-
-	constructor(table: AnyGelTable<{ name: T['tableName'] }>, config: GelJsonBuilder<T>['config']) {
-		super(table, config);
-	}
-
-	getSQLType(): string {
-		return 'json';
-	}
-}
-
-export function json(): GelJsonBuilderInitial<''>;
-export function json<TName extends string>(name: TName): GelJsonBuilderInitial<TName>;
-export function json(name?: string) {
-	return new GelJsonBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/localdate.ts b/drizzle-orm/src/gel-core/columns/localdate.ts
deleted file mode 100644
index eea0a1d6b1..0000000000
--- a/drizzle-orm/src/gel-core/columns/localdate.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { LocalDate } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelLocalDateColumnBaseBuilder } from './date.common.ts';
-
-export type GelLocalDateStringBuilderInitial<TName extends string> = GelLocalDateStringBuilder<{
-	name: TName;
-	dataType: 'localDate';
-	columnType: 'GelLocalDateString';
-	data: LocalDate;
-	driverParam: LocalDate;
-	enumValues: undefined;
-}>;
-
-export class GelLocalDateStringBuilder<T extends ColumnBuilderBaseConfig<'localDate', 'GelLocalDateString'>>
-	extends GelLocalDateColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelLocalDateStringBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'localDate', 'GelLocalDateString');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelLocalDateString<MakeColumnConfig<T, TTableName>> {
-		return new GelLocalDateString<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelLocalDateString<T extends ColumnBaseConfig<'localDate', 'GelLocalDateString'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelLocalDateString';
-
-	getSQLType(): string {
-		return 'cal::local_date';
-	}
-}
-
-export function localDate(): GelLocalDateStringBuilderInitial<''>;
-export function localDate<TName extends string>(name: TName): GelLocalDateStringBuilderInitial<TName>;
-export function localDate(name?: string) {
-	return new GelLocalDateStringBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/localtime.ts b/drizzle-orm/src/gel-core/columns/localtime.ts
deleted file mode 100644
index 5b11db9b6b..0000000000
--- a/drizzle-orm/src/gel-core/columns/localtime.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { LocalTime } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelLocalDateColumnBaseBuilder } from './date.common.ts';
-
-export type GelLocalTimeBuilderInitial<TName extends string> = GelLocalTimeBuilder<{
-	name: TName;
-	dataType: 'localTime';
-	columnType: 'GelLocalTime';
-	data: LocalTime;
-	driverParam: LocalTime;
-	enumValues: undefined;
-}>;
-
-export class GelLocalTimeBuilder<T extends ColumnBuilderBaseConfig<'localTime', 'GelLocalTime'>>
-	extends GelLocalDateColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelLocalTimeBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'localTime', 'GelLocalTime');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelLocalTime<MakeColumnConfig<T, TTableName>> {
-		return new GelLocalTime<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelLocalTime<T extends ColumnBaseConfig<'localTime', 'GelLocalTime'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelLocalTime';
-
-	getSQLType(): string {
-		return 'cal::local_time';
-	}
-}
-
-export function localTime(): GelLocalTimeBuilderInitial<''>;
-export function localTime<TName extends string>(name: TName): GelLocalTimeBuilderInitial<TName>;
-export function localTime(name?: string) {
-	return new GelLocalTimeBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/real.ts b/drizzle-orm/src/gel-core/columns/real.ts
deleted file mode 100644
index 2f993f028e..0000000000
--- a/drizzle-orm/src/gel-core/columns/real.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelRealBuilderInitial<TName extends string> = GelRealBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'GelReal';
-	data: number;
-	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class GelRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'GelReal'>> extends GelColumnBuilder<
-	T,
-	{ length: number | undefined }
-> {
-	static override readonly [entityKind]: string = 'GelRealBuilder';
-
-	constructor(name: T['name'], length?: number) {
-		super(name, 'number', 'GelReal');
-		this.config.length = length;
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelReal<MakeColumnConfig<T, TTableName>> {
-		return new GelReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelReal<T extends ColumnBaseConfig<'number', 'GelReal'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelReal';
-
-	constructor(table: AnyGelTable<{ name: T['tableName'] }>, config: GelRealBuilder<T>['config']) {
-		super(table, config);
-	}
-
-	getSQLType(): string {
-		return 'real';
-	}
-}
-
-export function real(): GelRealBuilderInitial<''>;
-export function real<TName extends string>(name: TName): GelRealBuilderInitial<TName>;
-export function real(name?: string) {
-	return new GelRealBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/relative-duration.ts b/drizzle-orm/src/gel-core/columns/relative-duration.ts
deleted file mode 100644
index e6007bfae1..0000000000
--- a/drizzle-orm/src/gel-core/columns/relative-duration.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { RelativeDuration } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelRelDurationBuilderInitial<TName extends string> = GelRelDurationBuilder<{
-	name: TName;
-	dataType: 'relDuration';
-	columnType: 'GelRelDuration';
-	data: RelativeDuration;
-	driverParam: RelativeDuration;
-	enumValues: undefined;
-}>;
-
-export class GelRelDurationBuilder<T extends ColumnBuilderBaseConfig<'relDuration', 'GelRelDuration'>>
-	extends GelColumnBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelRelDurationBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'relDuration', 'GelRelDuration');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelRelDuration<MakeColumnConfig<T, TTableName>> {
-		return new GelRelDuration<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelRelDuration<T extends ColumnBaseConfig<'relDuration', 'GelRelDuration'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelRelDuration';
-
-	getSQLType(): string {
-		return `edgedbt.relative_duration_t`;
-	}
-}
-
-export function relDuration(): GelRelDurationBuilderInitial<''>;
-export function relDuration<TName extends string>(name: TName): GelRelDurationBuilderInitial<TName>;
-export function relDuration(name?: string) {
-	return new GelRelDurationBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/smallint.ts b/drizzle-orm/src/gel-core/columns/smallint.ts
deleted file mode 100644
index 9546311a78..0000000000
--- a/drizzle-orm/src/gel-core/columns/smallint.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelIntColumnBaseBuilder } from './int.common.ts';
-
-export type GelSmallIntBuilderInitial<TName extends string> = GelSmallIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'GelSmallInt';
-	data: number;
-	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class GelSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'GelSmallInt'>>
-	extends GelIntColumnBaseBuilder<T>
-{
-	static override readonly [entityKind]: string = 'GelSmallIntBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'number', 'GelSmallInt');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelSmallInt<MakeColumnConfig<T, TTableName>> {
-		return new GelSmallInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelSmallInt<T extends ColumnBaseConfig<'number', 'GelSmallInt'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelSmallInt';
-
-	getSQLType(): string {
-		return 'smallint';
-	}
-}
-
-export function smallint(): GelSmallIntBuilderInitial<''>;
-export function smallint<TName extends string>(name: TName): GelSmallIntBuilderInitial<TName>;
-export function smallint(name?: string) {
-	return new GelSmallIntBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/text.ts b/drizzle-orm/src/gel-core/columns/text.ts
deleted file mode 100644
index fc73c7b613..0000000000
--- a/drizzle-orm/src/gel-core/columns/text.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-type GelTextBuilderInitial<TName extends string> = GelTextBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'GelText';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class GelTextBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'GelText'>,
-> extends GelColumnBuilder<T> {
-	static override readonly [entityKind]: string = 'GelTextBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'string', 'GelText');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelText<MakeColumnConfig<T, TTableName>> {
-		return new GelText<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelText<T extends ColumnBaseConfig<'string', 'GelText'>>
-	extends GelColumn<T, { enumValues: T['enumValues'] }>
-{
-	static override readonly [entityKind]: string = 'GelText';
-
-	override readonly enumValues = this.config.enumValues;
-
-	getSQLType(): string {
-		return 'text';
-	}
-}
-
-export function text(): GelTextBuilderInitial<''>;
-export function text<TName extends string>(name: TName): GelTextBuilderInitial<TName>;
-export function text(name?: string): any {
-	return new GelTextBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/timestamp.ts b/drizzle-orm/src/gel-core/columns/timestamp.ts
deleted file mode 100644
index 74209fa2ae..0000000000
--- a/drizzle-orm/src/gel-core/columns/timestamp.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import type { LocalDateTime } from 'gel';
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelLocalDateColumnBaseBuilder } from './date.common.ts';
-
-export type GelTimestampBuilderInitial<TName extends string> = GelTimestampBuilder<{
-	name: TName;
-	dataType: 'localDateTime';
-	columnType: 'GelTimestamp';
-	data: LocalDateTime;
-	driverParam: LocalDateTime;
-	enumValues: undefined;
-}>;
-
-export class GelTimestampBuilder<T extends ColumnBuilderBaseConfig<'localDateTime', 'GelTimestamp'>>
-	extends GelLocalDateColumnBaseBuilder<
-		T
-	>
-{
-	static override readonly [entityKind]: string = 'GelTimestampBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'localDateTime', 'GelTimestamp');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new GelTimestamp<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelTimestamp<T extends ColumnBaseConfig<'localDateTime', 'GelTimestamp'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelTimestamp';
-
-	constructor(table: AnyGelTable<{ name: T['tableName'] }>, config: GelTimestampBuilder<T>['config']) {
-		super(table, config);
-	}
-
-	getSQLType(): string {
-		return 'cal::local_datetime';
-	}
-}
-
-export function timestamp(): GelTimestampBuilderInitial<''>;
-export function timestamp<TName extends string>(
-	name: TName,
-): GelTimestampBuilderInitial<TName>;
-export function timestamp(name?: string) {
-	return new GelTimestampBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/timestamptz.ts b/drizzle-orm/src/gel-core/columns/timestamptz.ts
deleted file mode 100644
index 12ce925c56..0000000000
--- a/drizzle-orm/src/gel-core/columns/timestamptz.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn } from './common.ts';
-import { GelLocalDateColumnBaseBuilder } from './date.common.ts';
-
-export type GelTimestampTzBuilderInitial<TName extends string> = GelTimestampTzBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'GelTimestampTz';
-	data: Date;
-	driverParam: Date;
-	enumValues: undefined;
-}>;
-
-export class GelTimestampTzBuilder<T extends ColumnBuilderBaseConfig<'date', 'GelTimestampTz'>>
-	extends GelLocalDateColumnBaseBuilder<
-		T
-	>
-{
-	static override readonly [entityKind]: string = 'GelTimestampTzBuilder';
-
-	constructor(
-		name: T['name'],
-	) {
-		super(name, 'date', 'GelTimestampTz');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelTimestampTz<MakeColumnConfig<T, TTableName>> {
-		return new GelTimestampTz<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
-	}
-}
-
-export class GelTimestampTz<T extends ColumnBaseConfig<'date', 'GelTimestampTz'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelTimestampTz';
-
-	constructor(table: AnyGelTable<{ name: T['tableName'] }>, config: GelTimestampTzBuilder<T>['config']) {
-		super(table, config);
-	}
-
-	getSQLType(): string {
-		return 'datetime';
-	}
-}
-
-export function timestamptz(): GelTimestampTzBuilderInitial<''>;
-export function timestamptz<TName extends string>(
-	name: TName,
-): GelTimestampTzBuilderInitial<TName>;
-export function timestamptz(name?: string) {
-	return new GelTimestampTzBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/columns/uuid.ts b/drizzle-orm/src/gel-core/columns/uuid.ts
deleted file mode 100644
index 7438932618..0000000000
--- a/drizzle-orm/src/gel-core/columns/uuid.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
-import type { AnyGelTable } from '~/gel-core/table.ts';
-import { GelColumn, GelColumnBuilder } from './common.ts';
-
-export type GelUUIDBuilderInitial<TName extends string> = GelUUIDBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'GelUUID';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class GelUUIDBuilder<T extends ColumnBuilderBaseConfig<'string', 'GelUUID'>> extends GelColumnBuilder<T> {
-	static override readonly [entityKind]: string = 'GelUUIDBuilder';
-
-	constructor(name: T['name']) {
-		super(name, 'string', 'GelUUID');
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyGelTable<{ name: TTableName }>,
-	): GelUUID<MakeColumnConfig<T, TTableName>> {
-		return new GelUUID<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
-	}
-}
-
-export class GelUUID<T extends ColumnBaseConfig<'string', 'GelUUID'>> extends GelColumn<T> {
-	static override readonly [entityKind]: string = 'GelUUID';
-
-	getSQLType(): string {
-		return 'uuid';
-	}
-}
-
-export function uuid(): GelUUIDBuilderInitial<''>;
-export function uuid<TName extends string>(name: TName): GelUUIDBuilderInitial<TName>;
-export function uuid(name?: string) {
-	return new GelUUIDBuilder(name ?? '');
-}
diff --git a/drizzle-orm/src/gel-core/db.ts b/drizzle-orm/src/gel-core/db.ts
deleted file mode 100644
index dadcc3cc31..0000000000
--- a/drizzle-orm/src/gel-core/db.ts
+++ /dev/null
@@ -1,673 +0,0 @@
-import type { Cache } from '~/cache/core/cache.ts';
-import { entityKind } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import {
-	GelDeleteBase,
-	GelInsertBuilder,
-	GelSelectBuilder,
-	GelUpdateBuilder,
-	QueryBuilder,
-} from '~/gel-core/query-builders/index.ts';
-import type { GelQueryResultHKT, GelSession, GelTransaction, PreparedQueryConfig } from '~/gel-core/session.ts';
-import type { GelTable } from '~/gel-core/table.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import { WithSubquery } from '~/subquery.ts';
-import type { DrizzleTypeError } from '~/utils.ts';
-import type { GelColumn } from './columns/index.ts';
-import { GelCountBuilder } from './query-builders/count.ts';
-import { RelationalQueryBuilder } from './query-builders/query.ts';
-import { GelRaw } from './query-builders/raw.ts';
-import type { SelectedFields } from './query-builders/select.types.ts';
-import type { WithSubqueryWithSelection } from './subquery.ts';
-import type { GelViewBase } from './view-base.ts';
-
-export class GelDatabase<
-	TQueryResult extends GelQueryResultHKT,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
-> {
-	static readonly [entityKind]: string = 'GelDatabase';
-
-	declare readonly _: {
-		readonly schema: TSchema | undefined;
-		readonly fullSchema: TFullSchema;
-		readonly tableNamesMap: Record<string, string>;
-		readonly session: GelSession<TQueryResult, TFullSchema, TSchema>;
-	};
-
-	query: TFullSchema extends Record<string, never>
-		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
-		: {
-			[K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
-		};
-
-	constructor(
-		/** @internal */
-		readonly dialect: GelDialect,
-		/** @internal */
-		readonly session: GelSession<any, any, any>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
-	) {
-		this._ = schema
-			? {
-				schema: schema.schema,
-				fullSchema: schema.fullSchema as TFullSchema,
-				tableNamesMap: schema.tableNamesMap,
-				session,
-			}
-			: {
-				schema: undefined,
-				fullSchema: {} as TFullSchema,
-				tableNamesMap: {},
-				session,
-			};
-		this.query = {} as typeof this['query'];
-		if (this._.schema) {
-			for (const [tableName, columns] of Object.entries(this._.schema)) {
-				(this.query as GelDatabase<TQueryResult, Record<string, any>>['query'])[tableName] = new RelationalQueryBuilder(
-					schema!.fullSchema,
-					this._.schema,
-					this._.tableNamesMap,
-					schema!.fullSchema[tableName] as GelTable,
-					columns,
-					dialect,
-					session,
-				);
-			}
-		}
-
-		this.$cache = { invalidate: async (_params: any) => {} };
-	}
-
-	/**
-	 * Creates a subquery that defines a temporary named result set as a CTE.
-	 *
-	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param alias The alias for the subquery.
-	 *
-	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Create a subquery with alias 'sq' and use it in the select query
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 *
-	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
-	 *
-	 * ```ts
-	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
-	 * const sq = db.$with('sq').as(db.select({
-	 *   name: sql<string>`upper(${users.name})`.as('name'),
-	 * })
-	 * .from(users));
-	 *
-	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
-	 * ```
-	 */
-	$with<TAlias extends string>(alias: TAlias) {
-		const self = this;
-		return {
-			as<TSelection extends ColumnsSelection>(
-				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
-			): WithSubqueryWithSelection<TSelection, TAlias> {
-				if (typeof qb === 'function') {
-					qb = qb(new QueryBuilder(self.dialect));
-				}
-
-				return new Proxy(
-					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
-					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-				) as WithSubqueryWithSelection<TSelection, TAlias>;
-			},
-		};
-	}
-
-	$count(
-		source: GelTable | GelViewBase | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	) {
-		return new GelCountBuilder({ source, filters, session: this.session });
-	}
-
-	/**
-	 * Incorporates a previously defined CTE (using `$with`) into the main query.
-	 *
-	 * This method allows the main query to reference a temporary named result set.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param queries The CTEs to incorporate into the main query.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Define a subquery 'sq' as a CTE using $with
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * // Incorporate the CTE 'sq' into the main query and select from it
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 */
-	with(...queries: WithSubquery[]) {
-		const self = this;
-
-		/**
-		 * Creates a select query.
-		 *
-		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Select all columns and all rows from the 'cars' table
-		 * const allCars: Car[] = await db.select().from(cars);
-		 *
-		 * // Select specific columns and all rows from the 'cars' table
-		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   brand: cars.brand
-		 * })
-		 *   .from(cars);
-		 * ```
-		 *
-		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-		 *
-		 * ```ts
-		 * // Select specific columns along with expression and all rows from the 'cars' table
-		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-		 * })
-		 *   .from(cars);
-		 * ```
-		 */
-		function select(): GelSelectBuilder<undefined>;
-		function select<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection>;
-		function select(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-			});
-		}
-
-		/**
-		 * Adds `distinct` expression to the select query.
-		 *
-		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 * ```ts
-		 * // Select all unique rows from the 'cars' table
-		 * await db.selectDistinct()
-		 *   .from(cars)
-		 *   .orderBy(cars.id, cars.brand, cars.color);
-		 *
-		 * // Select all unique brands from the 'cars' table
-		 * await db.selectDistinct({ brand: cars.brand })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 * ```
-		 */
-		function selectDistinct(): GelSelectBuilder<undefined>;
-		function selectDistinct<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection>;
-		function selectDistinct(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: true,
-			});
-		}
-
-		/**
-		 * Adds `distinct on` expression to the select query.
-		 *
-		 * Calling this method will specify how the unique rows are determined.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param on The expression defining uniqueness.
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 * ```ts
-		 * // Select the first row for each unique brand from the 'cars' table
-		 * await db.selectDistinctOn([cars.brand])
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 *
-		 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
-		 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand, cars.color);
-		 * ```
-		 */
-		function selectDistinctOn(on: (GelColumn | SQLWrapper)[]): GelSelectBuilder<undefined>;
-		function selectDistinctOn<TSelection extends SelectedFields>(
-			on: (GelColumn | SQLWrapper)[],
-			fields: TSelection,
-		): GelSelectBuilder<TSelection>;
-		function selectDistinctOn(
-			on: (GelColumn | SQLWrapper)[],
-			fields?: SelectedFields,
-		): GelSelectBuilder<SelectedFields | undefined> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: { on },
-			});
-		}
-
-		/**
-		 * Creates an update query.
-		 *
-		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-		 *
-		 * Use `.set()` method to specify which values to update.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/update}
-		 *
-		 * @param table The table to update.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Update all rows in the 'cars' table
-		 * await db.update(cars).set({ color: 'red' });
-		 *
-		 * // Update rows with filters and conditions
-		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-		 *
-		 * // Update with returning clause
-		 * const updatedCar: Car[] = await db.update(cars)
-		 *   .set({ color: 'red' })
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function update<TTable extends GelTable>(table: TTable): GelUpdateBuilder<TTable, TQueryResult> {
-			return new GelUpdateBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates an insert query.
-		 *
-		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/insert}
-		 *
-		 * @param table The table to insert into.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Insert one row
-		 * await db.insert(cars).values({ brand: 'BMW' });
-		 *
-		 * // Insert multiple rows
-		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-		 *
-		 * // Insert with returning clause
-		 * const insertedCar: Car[] = await db.insert(cars)
-		 *   .values({ brand: 'BMW' })
-		 *   .returning();
-		 * ```
-		 */
-		function insert<TTable extends GelTable>(table: TTable): GelInsertBuilder<TTable, TQueryResult> {
-			return new GelInsertBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates a delete query.
-		 *
-		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/delete}
-		 *
-		 * @param table The table to delete from.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Delete all rows in the 'cars' table
-		 * await db.delete(cars);
-		 *
-		 * // Delete rows with filters and conditions
-		 * await db.delete(cars).where(eq(cars.color, 'green'));
-		 *
-		 * // Delete with returning clause
-		 * const deletedCar: Car[] = await db.delete(cars)
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function delete_<TTable extends GelTable>(table: TTable): GelDeleteBase<TTable, TQueryResult> {
-			return new GelDeleteBase(table, self.session, self.dialect, queries);
-		}
-
-		return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
-	}
-
-	/**
-	 * Creates a select query.
-	 *
-	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all columns and all rows from the 'cars' table
-	 * const allCars: Car[] = await db.select().from(cars);
-	 *
-	 * // Select specific columns and all rows from the 'cars' table
-	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   brand: cars.brand
-	 * })
-	 *   .from(cars);
-	 * ```
-	 *
-	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-	 *
-	 * ```ts
-	 * // Select specific columns along with expression and all rows from the 'cars' table
-	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-	 * })
-	 *   .from(cars);
-	 * ```
-	 */
-	select(): GelSelectBuilder<undefined>;
-	select<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection>;
-	select(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-		});
-	}
-
-	/**
-	 * Adds `distinct` expression to the select query.
-	 *
-	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 * ```ts
-	 * // Select all unique rows from the 'cars' table
-	 * await db.selectDistinct()
-	 *   .from(cars)
-	 *   .orderBy(cars.id, cars.brand, cars.color);
-	 *
-	 * // Select all unique brands from the 'cars' table
-	 * await db.selectDistinct({ brand: cars.brand })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 * ```
-	 */
-	selectDistinct(): GelSelectBuilder<undefined>;
-	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection>;
-	selectDistinct(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: true,
-		});
-	}
-
-	/**
-	 * Adds `distinct on` expression to the select query.
-	 *
-	 * Calling this method will specify how the unique rows are determined.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param on The expression defining uniqueness.
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 * ```ts
-	 * // Select the first row for each unique brand from the 'cars' table
-	 * await db.selectDistinctOn([cars.brand])
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 *
-	 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
-	 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand, cars.color);
-	 * ```
-	 */
-	selectDistinctOn(on: (GelColumn | SQLWrapper)[]): GelSelectBuilder<undefined>;
-	selectDistinctOn<TSelection extends SelectedFields>(
-		on: (GelColumn | SQLWrapper)[],
-		fields: TSelection,
-	): GelSelectBuilder<TSelection>;
-	selectDistinctOn(
-		on: (GelColumn | SQLWrapper)[],
-		fields?: SelectedFields,
-	): GelSelectBuilder<SelectedFields | undefined> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: { on },
-		});
-	}
-
-	$cache: { invalidate: Cache['onMutate'] };
-
-	/**
-	 * Creates an update query.
-	 *
-	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-	 *
-	 * Use `.set()` method to specify which values to update.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update}
-	 *
-	 * @param table The table to update.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Update all rows in the 'cars' table
-	 * await db.update(cars).set({ color: 'red' });
-	 *
-	 * // Update rows with filters and conditions
-	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-	 *
-	 * // Update with returning clause
-	 * const updatedCar: Car[] = await db.update(cars)
-	 *   .set({ color: 'red' })
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	update<TTable extends GelTable>(table: TTable): GelUpdateBuilder<TTable, TQueryResult> {
-		return new GelUpdateBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates an insert query.
-	 *
-	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert}
-	 *
-	 * @param table The table to insert into.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Insert one row
-	 * await db.insert(cars).values({ brand: 'BMW' });
-	 *
-	 * // Insert multiple rows
-	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-	 *
-	 * // Insert with returning clause
-	 * const insertedCar: Car[] = await db.insert(cars)
-	 *   .values({ brand: 'BMW' })
-	 *   .returning();
-	 * ```
-	 */
-	insert<TTable extends GelTable>(table: TTable): GelInsertBuilder<TTable, TQueryResult> {
-		return new GelInsertBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates a delete query.
-	 *
-	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete}
-	 *
-	 * @param table The table to delete from.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Delete all rows in the 'cars' table
-	 * await db.delete(cars);
-	 *
-	 * // Delete rows with filters and conditions
-	 * await db.delete(cars).where(eq(cars.color, 'green'));
-	 *
-	 * // Delete with returning clause
-	 * const deletedCar: Car[] = await db.delete(cars)
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	delete<TTable extends GelTable>(table: TTable): GelDeleteBase<TTable, TQueryResult> {
-		return new GelDeleteBase(table, this.session, this.dialect);
-	}
-
-	// TODO views are not implemented
-	// refreshMaterializedView<TView extends GelMaterializedView>(view: TView): GelRefreshMaterializedView<TQueryResult> {
-	// 	return new GelRefreshMaterializedView(view, this.session, this.dialect);
-	// }
-
-	execute<TRow extends Record<string, unknown> = Record<string, unknown>>(
-		query: SQLWrapper | string,
-	): GelRaw<TRow[]> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		const builtQuery = this.dialect.sqlToQuery(sequel);
-		const prepared = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: TRow[] }
-		>(
-			builtQuery,
-			undefined,
-			undefined,
-			false,
-		);
-		return new GelRaw(
-			() => prepared.execute(undefined),
-			sequel,
-			builtQuery,
-			(result) => prepared.mapResult(result, true),
-		);
-	}
-
-	transaction<T>(
-		transaction: (tx: GelTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T> {
-		return this.session.transaction(transaction);
-	}
-}
-
-export type GelWithReplicas<Q> = Q & { $primary: Q };
-
-export const withReplicas = <
-	HKT extends GelQueryResultHKT,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-	Q extends GelDatabase<
-		HKT,
-		TFullSchema,
-		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
-	>,
->(
-	primary: Q,
-	replicas: [Q, ...Q[]],
-	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
-): GelWithReplicas<Q> => {
-	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
-	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
-	const selectDistinctOn: Q['selectDistinctOn'] = (...args: [any]) => getReplica(replicas).selectDistinctOn(...args);
-	const _with: Q['with'] = (...args: any) => getReplica(replicas).with(...args);
-	const $with: Q['$with'] = (arg: any) => getReplica(replicas).$with(arg);
-
-	const update: Q['update'] = (...args: [any]) => primary.update(...args);
-	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
-	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
-	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
-	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
-	// const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: [any]) =>
-	// 	primary.refreshMaterializedView(...args);
-
-	return {
-		...primary,
-		update,
-		insert,
-		delete: $delete,
-		execute,
-		transaction,
-		// refreshMaterializedView,
-		$primary: primary,
-		select,
-		selectDistinct,
-		selectDistinctOn,
-		$with,
-		with: _with,
-		get query() {
-			return getReplica(replicas).query;
-		},
-	};
-};
diff --git a/drizzle-orm/src/gel-core/dialect.ts b/drizzle-orm/src/gel-core/dialect.ts
deleted file mode 100644
index 5b40dfdb01..0000000000
--- a/drizzle-orm/src/gel-core/dialect.ts
+++ /dev/null
@@ -1,1418 +0,0 @@
-import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from '~/alias.ts';
-import { CasingCache } from '~/casing.ts';
-import { Column } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
-import { DrizzleError } from '~/errors.ts';
-import { GelColumn, GelDecimal, GelJson, GelUUID } from '~/gel-core/columns/index.ts';
-import type {
-	AnyGelSelectQueryBuilder,
-	GelDeleteConfig,
-	GelInsertConfig,
-	GelSelectJoinConfig,
-	GelUpdateConfig,
-} from '~/gel-core/query-builders/index.ts';
-import type { GelSelectConfig, SelectedFieldsOrdered } from '~/gel-core/query-builders/select.types.ts';
-import { GelTable } from '~/gel-core/table.ts';
-import {
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	getOperators,
-	getOrderByOperators,
-	Many,
-	normalizeRelation,
-	One,
-	type Relation,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { and, eq, View } from '~/sql/index.ts';
-import {
-	type DriverValueEncoder,
-	type Name,
-	Param,
-	type QueryTypingsValue,
-	type QueryWithTypings,
-	SQL,
-	sql,
-	type SQLChunk,
-} from '~/sql/sql.ts';
-import { Subquery } from '~/subquery.ts';
-import { getTableName, getTableUniqueName, Table } from '~/table.ts';
-import { type Casing, orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { ViewBaseConfig } from '~/view-common.ts';
-import { GelTimestamp } from './columns/timestamp.ts';
-import { GelViewBase } from './view-base.ts';
-import type { GelMaterializedView } from './view.ts';
-
-export interface GelDialectConfig {
-	casing?: Casing;
-}
-
-export class GelDialect {
-	static readonly [entityKind]: string = 'GelDialect';
-
-	/** @internal */
-	readonly casing: CasingCache;
-
-	constructor(config?: GelDialectConfig) {
-		this.casing = new CasingCache(config?.casing);
-	}
-
-	// TODO can not migrate gel with drizzle
-	// async migrate(migrations: MigrationMeta[], session: GelSession, config: string | MigrationConfig): Promise<void> {
-	// 	const migrationsTable = typeof config === 'string'
-	// 		? '__drizzle_migrations'
-	// 		: config.migrationsTable ?? '__drizzle_migrations';
-	// 	const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle';
-	// 	const migrationTableCreate = sql`
-	// 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
-	// 			id SERIAL PRIMARY KEY,
-	// 			hash text NOT NULL,
-	// 			created_at bigint
-	// 		)
-	// 	`;
-	// 	await session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
-	// 	await session.execute(migrationTableCreate);
-
-	// 	const dbMigrations = await session.all<{ id: number; hash: string; created_at: string }>(
-	// 		sql`select id, hash, created_at from ${sql.identifier(migrationsSchema)}.${
-	// 			sql.identifier(migrationsTable)
-	// 		} order by created_at desc limit 1`,
-	// 	);
-
-	// 	const lastDbMigration = dbMigrations[0];
-	// 	await session.transaction(async (tx) => {
-	// 		for await (const migration of migrations) {
-	// 			if (
-	// 				!lastDbMigration
-	// 				|| Number(lastDbMigration.created_at) < migration.folderMillis
-	// 			) {
-	// 				for (const stmt of migration.sql) {
-	// 					await tx.execute(sql.raw(stmt));
-	// 				}
-	// 				await tx.execute(
-	// 					sql`insert into ${sql.identifier(migrationsSchema)}.${
-	// 						sql.identifier(migrationsTable)
-	// 					} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`,
-	// 				);
-	// 			}
-	// 		}
-	// 	});
-	// }
-
-	escapeName(name: string): string {
-		return `"${name}"`;
-	}
-
-	escapeParam(num: number): string {
-		return `$${num + 1}`;
-	}
-
-	escapeString(str: string): string {
-		return `'${str.replace(/'/g, "''")}'`;
-	}
-
-	private buildWithCTE(queries: Subquery[] | undefined): SQL | undefined {
-		if (!queries?.length) return undefined;
-
-		const withSqlChunks = [sql`with `];
-		for (const [i, w] of queries.entries()) {
-			withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);
-			if (i < queries.length - 1) {
-				withSqlChunks.push(sql`, `);
-			}
-		}
-		withSqlChunks.push(sql` `);
-		return sql.join(withSqlChunks);
-	}
-
-	buildDeleteQuery({ table, where, returning, withList }: GelDeleteConfig): SQL {
-		const withSql = this.buildWithCTE(withList);
-
-		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
-			: undefined;
-
-		const whereSql = where ? sql` where ${where}` : undefined;
-
-		return sql`${withSql}delete from ${table}${whereSql}${returningSql}`;
-	}
-
-	buildUpdateSet(table: GelTable, set: UpdateSet): SQL {
-		const tableColumns = table[Table.Symbol.Columns];
-
-		const columnNames = Object.keys(tableColumns).filter((colName) =>
-			set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined
-		);
-
-		const setSize = columnNames.length;
-		return sql.join(columnNames.flatMap((colName, i) => {
-			const col = tableColumns[colName]!;
-
-			const value = set[colName] ?? sql.param(col.onUpdateFn!(), col);
-			const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
-
-			if (i < setSize - 1) {
-				return [res, sql.raw(', ')];
-			}
-			return [res];
-		}));
-	}
-
-	buildUpdateQuery({ table, set, where, returning, withList, from, joins }: GelUpdateConfig): SQL {
-		const withSql = this.buildWithCTE(withList);
-
-		const tableName = table[GelTable.Symbol.Name];
-		const tableSchema = table[GelTable.Symbol.Schema];
-		const origTableName = table[GelTable.Symbol.OriginalName];
-		const alias = tableName === origTableName ? undefined : tableName;
-		const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${
-			sql.identifier(origTableName)
-		}${alias && sql` ${sql.identifier(alias)}`}`;
-
-		const setSql = this.buildUpdateSet(table, set);
-
-		const fromSql = from && sql.join([sql.raw(' from '), this.buildFromTable(from)]);
-
-		const joinsSql = this.buildJoins(joins);
-
-		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}`
-			: undefined;
-
-		const whereSql = where ? sql` where ${where}` : undefined;
-
-		return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
-	}
-
-	/**
-	 * Builds selection SQL with provided fields/expressions
-	 *
-	 * Examples:
-	 *
-	 * `select <selection> from`
-	 *
-	 * `insert ... returning <selection>`
-	 *
-	 * If `isSingleTable` is true, then columns won't be prefixed with table name
-	 * ^ Temporarily disabled behaviour, see comments within method for a reasoning
-	 */
-	private buildSelection(
-		fields: SelectedFieldsOrdered,
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
-		{ isSingleTable = false }: { isSingleTable?: boolean } = {},
-	): SQL {
-		const columnsLen = fields.length;
-
-		const chunks = fields
-			.flatMap(({ field }, i) => {
-				const chunk: SQLChunk[] = [];
-
-				if (is(field, SQL.Aliased) && field.isSelectionField) {
-					chunk.push(sql.identifier(field.fieldAlias));
-				} else if (is(field, SQL.Aliased) || is(field, SQL)) {
-					const query = is(field, SQL.Aliased) ? field.sql : field;
-
-					// Gel throws an error when more than one similarly named columns exist within context instead of preferring the closest one
-					// thus forcing us to be explicit about column's source
-					// if (isSingleTable) {
-					// 	chunk.push(
-					// 		new SQL(
-					// 			query.queryChunks.map((c) => {
-					// 				if (is(c, GelColumn)) {
-					// 					return sql.identifier(this.casing.getColumnCasing(c));
-					// 				}
-					// 				return c;
-					// 			}),
-					// 		),
-					// 	);
-					// } else {
-					chunk.push(query);
-					// }
-
-					if (is(field, SQL.Aliased)) {
-						chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-					}
-				} else if (is(field, Column)) {
-					// Gel throws an error when more than one similarly named columns exist within context instead of preferring the closest one
-					// thus forcing us to be explicit about column's source
-					// if (isSingleTable) {
-					// 	chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
-					// } else {
-					chunk.push(field);
-					// }
-				}
-
-				if (i < columnsLen - 1) {
-					chunk.push(sql`, `);
-				}
-
-				return chunk;
-			});
-
-		return sql.join(chunks);
-	}
-
-	private buildJoins(joins: GelSelectJoinConfig[] | undefined): SQL | undefined {
-		if (!joins || joins.length === 0) {
-			return undefined;
-		}
-
-		const joinsArray: SQL[] = [];
-
-		for (const [index, joinMeta] of joins.entries()) {
-			if (index === 0) {
-				joinsArray.push(sql` `);
-			}
-			const table = joinMeta.table;
-			const lateralSql = joinMeta.lateral ? sql` lateral` : undefined;
-			const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : undefined;
-
-			if (is(table, GelTable)) {
-				const tableName = table[GelTable.Symbol.Name];
-				const tableSchema = table[GelTable.Symbol.Schema];
-				const origTableName = table[GelTable.Symbol.OriginalName];
-				const alias = tableName === origTableName ? undefined : joinMeta.alias;
-				joinsArray.push(
-					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
-						tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined
-					}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`,
-				);
-			} else if (is(table, View)) {
-				const viewName = table[ViewBaseConfig].name;
-				const viewSchema = table[ViewBaseConfig].schema;
-				const origViewName = table[ViewBaseConfig].originalName;
-				const alias = viewName === origViewName ? undefined : joinMeta.alias;
-				joinsArray.push(
-					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
-						viewSchema ? sql`${sql.identifier(viewSchema)}.` : undefined
-					}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`,
-				);
-			} else {
-				joinsArray.push(
-					sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table}${onSql}`,
-				);
-			}
-			if (index < joins.length - 1) {
-				joinsArray.push(sql` `);
-			}
-		}
-
-		return sql.join(joinsArray);
-	}
-
-	private buildFromTable(
-		table: SQL | Subquery | GelViewBase | GelTable | undefined,
-	): SQL | Subquery | GelViewBase | GelTable | undefined {
-		if (is(table, Table) && table[Table.Symbol.OriginalName] !== table[Table.Symbol.Name]) {
-			let fullName = sql`${sql.identifier(table[Table.Symbol.OriginalName])}`;
-			if (table[Table.Symbol.Schema]) {
-				fullName = sql`${sql.identifier(table[Table.Symbol.Schema]!)}.${fullName}`;
-			}
-			return sql`${fullName} ${sql.identifier(table[Table.Symbol.Name])}`;
-		}
-
-		return table;
-	}
-
-	buildSelectQuery(
-		{
-			withList,
-			fields,
-			fieldsFlat,
-			where,
-			having,
-			table,
-			joins,
-			orderBy,
-			groupBy,
-			limit,
-			offset,
-			lockingClause,
-			distinct,
-			setOperators,
-		}: GelSelectConfig,
-	): SQL {
-		const fieldsList = fieldsFlat ?? orderSelectedFields<GelColumn>(fields);
-		for (const f of fieldsList) {
-			if (
-				is(f.field, Column)
-				&& getTableName(f.field.table)
-					!== (is(table, Subquery)
-						? table._.alias
-						: is(table, GelViewBase)
-						? table[ViewBaseConfig].name
-						: is(table, SQL)
-						? undefined
-						: getTableName(table))
-				&& !((table) =>
-					joins?.some(({ alias }) =>
-						alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])
-					))(f.field.table)
-			) {
-				const tableName = getTableName(f.field.table);
-				throw new Error(
-					`Your "${
-						f.path.join('->')
-					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
-				);
-			}
-		}
-
-		const isSingleTable = !joins || joins.length === 0;
-
-		const withSql = this.buildWithCTE(withList);
-
-		let distinctSql: SQL | undefined;
-		if (distinct) {
-			distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
-		}
-
-		const selection = this.buildSelection(fieldsList, { isSingleTable });
-
-		const tableSql = this.buildFromTable(table);
-
-		const joinsSql = this.buildJoins(joins);
-
-		const whereSql = where ? sql` where ${where}` : undefined;
-
-		const havingSql = having ? sql` having ${having}` : undefined;
-
-		let orderBySql;
-		if (orderBy && orderBy.length > 0) {
-			orderBySql = sql` order by ${sql.join(orderBy, sql`, `)}`;
-		}
-
-		let groupBySql;
-		if (groupBy && groupBy.length > 0) {
-			groupBySql = sql` group by ${sql.join(groupBy, sql`, `)}`;
-		}
-
-		const limitSql = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
-			? sql` limit ${limit}`
-			: undefined;
-
-		const offsetSql = offset ? sql` offset ${offset}` : undefined;
-
-		const lockingClauseSql = sql.empty();
-		if (lockingClause) {
-			const clauseSql = sql` for ${sql.raw(lockingClause.strength)}`;
-			if (lockingClause.config.of) {
-				clauseSql.append(
-					sql` of ${
-						sql.join(
-							Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of],
-							sql`, `,
-						)
-					}`,
-				);
-			}
-			if (lockingClause.config.noWait) {
-				clauseSql.append(sql` nowait`);
-			} else if (lockingClause.config.skipLocked) {
-				clauseSql.append(sql` skip locked`);
-			}
-			lockingClauseSql.append(clauseSql);
-		}
-		const finalQuery =
-			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
-
-		if (setOperators.length > 0) {
-			return this.buildSetOperations(finalQuery, setOperators);
-		}
-
-		return finalQuery;
-	}
-
-	buildSetOperations(leftSelect: SQL, setOperators: GelSelectConfig['setOperators']): SQL {
-		const [setOperator, ...rest] = setOperators;
-
-		if (!setOperator) {
-			throw new Error('Cannot pass undefined values to any set operator');
-		}
-
-		if (rest.length === 0) {
-			return this.buildSetOperationQuery({ leftSelect, setOperator });
-		}
-
-		// Some recursive magic here
-		return this.buildSetOperations(
-			this.buildSetOperationQuery({ leftSelect, setOperator }),
-			rest,
-		);
-	}
-
-	buildSetOperationQuery({
-		leftSelect,
-		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: GelSelectConfig['setOperators'][number] }): SQL {
-		const leftChunk = sql`(${leftSelect.getSQL()}) `;
-		const rightChunk = sql`(${rightSelect.getSQL()})`;
-
-		let orderBySql;
-		if (orderBy && orderBy.length > 0) {
-			const orderByValues: (SQL<unknown> | Name)[] = [];
-
-			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid Sql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
-			for (const singleOrderBy of orderBy) {
-				if (is(singleOrderBy, GelColumn)) {
-					orderByValues.push(sql.identifier(singleOrderBy.name));
-				} else if (is(singleOrderBy, SQL)) {
-					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
-						const chunk = singleOrderBy.queryChunks[i];
-
-						if (is(chunk, GelColumn)) {
-							singleOrderBy.queryChunks[i] = sql.identifier(chunk.name);
-						}
-					}
-
-					orderByValues.push(sql`${singleOrderBy}`);
-				} else {
-					orderByValues.push(sql`${singleOrderBy}`);
-				}
-			}
-
-			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
-		}
-
-		const limitSql = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
-			? sql` limit ${limit}`
-			: undefined;
-
-		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
-
-		const offsetSql = offset ? sql` offset ${offset}` : undefined;
-
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
-	}
-
-	buildInsertQuery(
-		{ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_ }: GelInsertConfig,
-	): SQL {
-		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
-		const columns: Record<string, GelColumn> = table[Table.Symbol.Columns];
-
-		const colEntries: [string, GelColumn][] = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
-
-		const insertOrder = colEntries.map(
-			([, column]) => sql.identifier(this.casing.getColumnCasing(column)),
-		);
-
-		if (select) {
-			const select = valuesOrSelect as AnyGelSelectQueryBuilder | SQL;
-
-			if (is(select, SQL)) {
-				valuesSqlList.push(select);
-			} else {
-				valuesSqlList.push(select.getSQL());
-			}
-		} else {
-			const values = valuesOrSelect as Record<string, Param | SQL>[];
-			valuesSqlList.push(sql.raw('values '));
-
-			for (const [valueIndex, value] of values.entries()) {
-				const valueList: (SQLChunk | SQL)[] = [];
-				for (const [fieldName, col] of colEntries) {
-					const colValue = value[fieldName];
-					if (colValue === undefined || (is(colValue, Param) && colValue.value === undefined)) {
-						// eslint-disable-next-line unicorn/no-negated-condition
-						if (col.defaultFn !== undefined) {
-							const defaultFnResult = col.defaultFn();
-							const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
-							valueList.push(defaultValue);
-							// eslint-disable-next-line unicorn/no-negated-condition
-						} else if (!col.default && col.onUpdateFn !== undefined) {
-							const onUpdateFnResult = col.onUpdateFn();
-							const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
-							valueList.push(newValue);
-						} else {
-							valueList.push(sql`default`);
-						}
-					} else {
-						valueList.push(colValue);
-					}
-				}
-
-				valuesSqlList.push(valueList);
-				if (valueIndex < values.length - 1) {
-					valuesSqlList.push(sql`, `);
-				}
-			}
-		}
-
-		const withSql = this.buildWithCTE(withList);
-
-		const valuesSql = sql.join(valuesSqlList);
-
-		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
-			: undefined;
-
-		const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : undefined;
-
-		const overridingSql = overridingSystemValue_ === true ? sql`overriding system value ` : undefined;
-
-		return sql`${withSql}insert into ${table} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`;
-	}
-
-	buildRefreshMaterializedViewQuery(
-		{ view, concurrently, withNoData }: { view: GelMaterializedView; concurrently?: boolean; withNoData?: boolean },
-	): SQL {
-		const concurrentlySql = concurrently ? sql` concurrently` : undefined;
-		const withNoDataSql = withNoData ? sql` with no data` : undefined;
-
-		return sql`refresh materialized view${concurrentlySql} ${view}${withNoDataSql}`;
-	}
-
-	prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue {
-		if (is(encoder, GelJson)) {
-			return 'json';
-		} else if (is(encoder, GelDecimal)) {
-			return 'decimal';
-		} else if (is(encoder, GelTimestamp)) {
-			return 'timestamp';
-		} else if (is(encoder, GelUUID)) {
-			return 'uuid';
-		} else {
-			return 'none';
-		}
-	}
-
-	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): QueryWithTypings {
-		return sql.toQuery({
-			casing: this.casing,
-			escapeName: this.escapeName,
-			escapeParam: this.escapeParam,
-			escapeString: this.escapeString,
-			prepareTyping: this.prepareTyping,
-			invokeSource,
-		});
-	}
-
-	// buildRelationalQueryWithPK({
-	// 	fullSchema,
-	// 	schema,
-	// 	tableNamesMap,
-	// 	table,
-	// 	tableConfig,
-	// 	queryConfig: config,
-	// 	tableAlias,
-	// 	isRoot = false,
-	// 	joinOn,
-	// }: {
-	// 	fullSchema: Record<string, unknown>;
-	// 	schema: TablesRelationalConfig;
-	// 	tableNamesMap: Record<string, string>;
-	// 	table: GelTable;
-	// 	tableConfig: TableRelationalConfig;
-	// 	queryConfig: true | DBQueryConfig<'many', true>;
-	// 	tableAlias: string;
-	// 	isRoot?: boolean;
-	// 	joinOn?: SQL;
-	// }): BuildRelationalQueryResult<GelTable, GelColumn> {
-	// 	// For { "<relation>": true }, return a table with selection of all columns
-	// 	if (config === true) {
-	// 		const selectionEntries = Object.entries(tableConfig.columns);
-	// 		const selection: BuildRelationalQueryResult<GelTable, GelColumn>['selection'] = selectionEntries.map((
-	// 			[key, value],
-	// 		) => ({
-	// 			dbKey: value.name,
-	// 			tsKey: key,
-	// 			field: value as GelColumn,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-
-	// 		return {
-	// 			tableTsKey: tableConfig.tsName,
-	// 			sql: table,
-	// 			selection,
-	// 		};
-	// 	}
-
-	// 	// let selection: BuildRelationalQueryResult<GelTable, GelColumn>['selection'] = [];
-	// 	// let selectionForBuild = selection;
-
-	// 	const aliasedColumns = Object.fromEntries(
-	// 		Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
-	// 	);
-
-	// 	const aliasedRelations = Object.fromEntries(
-	// 		Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]),
-	// 	);
-
-	// 	const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
-
-	// 	let where, hasUserDefinedWhere;
-	// 	if (config.where) {
-	// 		const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
-	// 		where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-	// 		hasUserDefinedWhere = !!where;
-	// 	}
-	// 	where = and(joinOn, where);
-
-	// 	// const fieldsSelection: { tsKey: string; value: GelColumn | SQL.Aliased; isExtra?: boolean }[] = [];
-	// 	let joins: Join[] = [];
-	// 	let selectedColumns: string[] = [];
-
-	// 	// Figure out which columns to select
-	// 	if (config.columns) {
-	// 		let isIncludeMode = false;
-
-	// 		for (const [field, value] of Object.entries(config.columns)) {
-	// 			if (value === undefined) {
-	// 				continue;
-	// 			}
-
-	// 			if (field in tableConfig.columns) {
-	// 				if (!isIncludeMode && value === true) {
-	// 					isIncludeMode = true;
-	// 				}
-	// 				selectedColumns.push(field);
-	// 			}
-	// 		}
-
-	// 		if (selectedColumns.length > 0) {
-	// 			selectedColumns = isIncludeMode
-	// 				? selectedColumns.filter((c) => config.columns?.[c] === true)
-	// 				: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-	// 		}
-	// 	} else {
-	// 		// Select all columns if selection is not specified
-	// 		selectedColumns = Object.keys(tableConfig.columns);
-	// 	}
-
-	// 	// for (const field of selectedColumns) {
-	// 	// 	const column = tableConfig.columns[field]! as GelColumn;
-	// 	// 	fieldsSelection.push({ tsKey: field, value: column });
-	// 	// }
-
-	// 	let initiallySelectedRelations: {
-	// 		tsKey: string;
-	// 		queryConfig: true | DBQueryConfig<'many', false>;
-	// 		relation: Relation;
-	// 	}[] = [];
-
-	// 	// let selectedRelations: BuildRelationalQueryResult<GelTable, GelColumn>['selection'] = [];
-
-	// 	// Figure out which relations to select
-	// 	if (config.with) {
-	// 		initiallySelectedRelations = Object.entries(config.with)
-	// 			.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-	// 			.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-	// 	}
-
-	// 	const manyRelations = initiallySelectedRelations.filter((r) =>
-	// 		is(r.relation, Many)
-	// 		&& (schema[tableNamesMap[r.relation.referencedTable[Table.Symbol.Name]]!]?.primaryKey.length ?? 0) > 0
-	// 	);
-	// 	// If this is the last Many relation (or there are no Many relations), we are on the innermost subquery level
-	// 	const isInnermostQuery = manyRelations.length < 2;
-
-	// 	const selectedExtras: {
-	// 		tsKey: string;
-	// 		value: SQL.Aliased;
-	// 	}[] = [];
-
-	// 	// Figure out which extras to select
-	// 	if (isInnermostQuery && config.extras) {
-	// 		const extras = typeof config.extras === 'function'
-	// 			? config.extras(aliasedFields, { sql })
-	// 			: config.extras;
-	// 		for (const [tsKey, value] of Object.entries(extras)) {
-	// 			selectedExtras.push({
-	// 				tsKey,
-	// 				value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-	// 			});
-	// 		}
-	// 	}
-
-	// 	// Transform `fieldsSelection` into `selection`
-	// 	// `fieldsSelection` shouldn't be used after this point
-	// 	// for (const { tsKey, value, isExtra } of fieldsSelection) {
-	// 	// 	selection.push({
-	// 	// 		dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-	// 	// 		tsKey,
-	// 	// 		field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-	// 	// 		relationTableTsKey: undefined,
-	// 	// 		isJson: false,
-	// 	// 		isExtra,
-	// 	// 		selection: [],
-	// 	// 	});
-	// 	// }
-
-	// 	let orderByOrig = typeof config.orderBy === 'function'
-	// 		? config.orderBy(aliasedFields, orderByOperators)
-	// 		: config.orderBy ?? [];
-	// 	if (!Array.isArray(orderByOrig)) {
-	// 		orderByOrig = [orderByOrig];
-	// 	}
-	// 	const orderBy = orderByOrig.map((orderByValue) => {
-	// 		if (is(orderByValue, Column)) {
-	// 			return aliasedTableColumn(orderByValue, tableAlias) as GelColumn;
-	// 		}
-	// 		return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-	// 	});
-
-	// 	const limit = isInnermostQuery ? config.limit : undefined;
-	// 	const offset = isInnermostQuery ? config.offset : undefined;
-
-	// 	// For non-root queries without additional config except columns, return a table with selection
-	// 	if (
-	// 		!isRoot
-	// 		&& initiallySelectedRelations.length === 0
-	// 		&& selectedExtras.length === 0
-	// 		&& !where
-	// 		&& orderBy.length === 0
-	// 		&& limit === undefined
-	// 		&& offset === undefined
-	// 	) {
-	// 		return {
-	// 			tableTsKey: tableConfig.tsName,
-	// 			sql: table,
-	// 			selection: selectedColumns.map((key) => ({
-	// 				dbKey: tableConfig.columns[key]!.name,
-	// 				tsKey: key,
-	// 				field: tableConfig.columns[key] as GelColumn,
-	// 				relationTableTsKey: undefined,
-	// 				isJson: false,
-	// 				selection: [],
-	// 			})),
-	// 		};
-	// 	}
-
-	// 	const selectedRelationsWithoutPK:
-
-	// 	// Process all relations without primary keys, because they need to be joined differently and will all be on the same query level
-	// 	for (
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			relation,
-	// 		} of initiallySelectedRelations
-	// 	) {
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTable = schema[relationTableTsName]!;
-
-	// 		if (relationTable.primaryKey.length > 0) {
-	// 			continue;
-	// 		}
-
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-	// 		const builtRelation = this.buildRelationalQueryWithoutPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as GelTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 			nestedQueryRelation: relation,
-	// 		});
-	// 		const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
-	// 		joins.push({
-	// 			on: sql`true`,
-	// 			table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: true,
-	// 		});
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelation.selection,
-	// 		});
-	// 	}
-
-	// 	const oneRelations = initiallySelectedRelations.filter((r): r is typeof r & { relation: One } =>
-	// 		is(r.relation, One)
-	// 	);
-
-	// 	// Process all One relations with PKs, because they can all be joined on the same level
-	// 	for (
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			relation,
-	// 		} of oneRelations
-	// 	) {
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const relationTable = schema[relationTableTsName]!;
-
-	// 		if (relationTable.primaryKey.length === 0) {
-	// 			continue;
-	// 		}
-
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-	// 		const builtRelation = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as GelTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 		});
-	// 		const field = sql`case when ${sql.identifier(relationTableAlias)} is null then null else json_build_array(${
-	// 			sql.join(
-	// 				builtRelation.selection.map(({ field }) =>
-	// 					is(field, SQL.Aliased)
-	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
-	// 						: is(field, Column)
-	// 						? aliasedTableColumn(field, relationTableAlias)
-	// 						: field
-	// 				),
-	// 				sql`, `,
-	// 			)
-	// 		}) end`.as(selectedRelationTsKey);
-	// 		const isLateralJoin = is(builtRelation.sql, SQL);
-	// 		joins.push({
-	// 			on: isLateralJoin ? sql`true` : joinOn,
-	// 			table: is(builtRelation.sql, SQL)
-	// 				? new Subquery(builtRelation.sql, {}, relationTableAlias)
-	// 				: aliasedTable(builtRelation.sql, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: is(builtRelation.sql, SQL),
-	// 		});
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelation.selection,
-	// 		});
-	// 	}
-
-	// 	let distinct: GelSelectConfig['distinct'];
-	// 	let tableFrom: GelTable | Subquery = table;
-
-	// 	// Process first Many relation - each one requires a nested subquery
-	// 	const manyRelation = manyRelations[0];
-	// 	if (manyRelation) {
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationQueryConfig,
-	// 			relation,
-	// 		} = manyRelation;
-
-	// 		distinct = {
-	// 			on: tableConfig.primaryKey.map((c) => aliasedTableColumn(c as GelColumn, tableAlias)),
-	// 		};
-
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-
-	// 		const builtRelationJoin = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as GelTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationQueryConfig,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 		});
-
-	// 		const builtRelationSelectionField = sql`case when ${
-	// 			sql.identifier(relationTableAlias)
-	// 		} is null then '[]' else json_agg(json_build_array(${
-	// 			sql.join(
-	// 				builtRelationJoin.selection.map(({ field }) =>
-	// 					is(field, SQL.Aliased)
-	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
-	// 						: is(field, Column)
-	// 						? aliasedTableColumn(field, relationTableAlias)
-	// 						: field
-	// 				),
-	// 				sql`, `,
-	// 			)
-	// 		})) over (partition by ${sql.join(distinct.on, sql`, `)}) end`.as(selectedRelationTsKey);
-	// 		const isLateralJoin = is(builtRelationJoin.sql, SQL);
-	// 		joins.push({
-	// 			on: isLateralJoin ? sql`true` : joinOn,
-	// 			table: isLateralJoin
-	// 				? new Subquery(builtRelationJoin.sql as SQL, {}, relationTableAlias)
-	// 				: aliasedTable(builtRelationJoin.sql as GelTable, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: isLateralJoin,
-	// 		});
-
-	// 		// Build the "from" subquery with the remaining Many relations
-	// 		const builtTableFrom = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table,
-	// 			tableConfig,
-	// 			queryConfig: {
-	// 				...config,
-	// 				where: undefined,
-	// 				orderBy: undefined,
-	// 				limit: undefined,
-	// 				offset: undefined,
-	// 				with: manyRelations.slice(1).reduce<NonNullable<typeof config['with']>>(
-	// 					(result, { tsKey, queryConfig: configValue }) => {
-	// 						result[tsKey] = configValue;
-	// 						return result;
-	// 					},
-	// 					{},
-	// 				),
-	// 			},
-	// 			tableAlias,
-	// 		});
-
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field: builtRelationSelectionField,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelationJoin.selection,
-	// 		});
-
-	// 		// selection = builtTableFrom.selection.map((item) =>
-	// 		// 	is(item.field, SQL.Aliased)
-	// 		// 		? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
-	// 		// 		: item
-	// 		// );
-	// 		// selectionForBuild = [{
-	// 		// 	dbKey: '*',
-	// 		// 	tsKey: '*',
-	// 		// 	field: sql`${sql.identifier(tableAlias)}.*`,
-	// 		// 	selection: [],
-	// 		// 	isJson: false,
-	// 		// 	relationTableTsKey: undefined,
-	// 		// }];
-	// 		// const newSelectionItem: (typeof selection)[number] = {
-	// 		// 	dbKey: selectedRelationTsKey,
-	// 		// 	tsKey: selectedRelationTsKey,
-	// 		// 	field,
-	// 		// 	relationTableTsKey: relationTableTsName,
-	// 		// 	isJson: true,
-	// 		// 	selection: builtRelationJoin.selection,
-	// 		// };
-	// 		// selection.push(newSelectionItem);
-	// 		// selectionForBuild.push(newSelectionItem);
-
-	// 		tableFrom = is(builtTableFrom.sql, GelTable)
-	// 			? builtTableFrom.sql
-	// 			: new Subquery(builtTableFrom.sql, {}, tableAlias);
-	// 	}
-
-	// 	if (selectedColumns.length === 0 && selectedRelations.length === 0 && selectedExtras.length === 0) {
-	// 		throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
-	// 	}
-
-	// 	let selection: BuildRelationalQueryResult<GelTable, GelColumn>['selection'];
-
-	// 	function prepareSelectedColumns() {
-	// 		return selectedColumns.map((key) => ({
-	// 			dbKey: tableConfig.columns[key]!.name,
-	// 			tsKey: key,
-	// 			field: tableConfig.columns[key] as GelColumn,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-	// 	}
-
-	// 	function prepareSelectedExtras() {
-	// 		return selectedExtras.map((item) => ({
-	// 			dbKey: item.value.fieldAlias,
-	// 			tsKey: item.tsKey,
-	// 			field: item.value,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-	// 	}
-
-	// 	if (isRoot) {
-	// 		selection = [
-	// 			...prepareSelectedColumns(),
-	// 			...prepareSelectedExtras(),
-	// 		];
-	// 	}
-
-	// 	if (hasUserDefinedWhere || orderBy.length > 0) {
-	// 		tableFrom = new Subquery(
-	// 			this.buildSelectQuery({
-	// 				table: is(tableFrom, GelTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
-	// 				fields: {},
-	// 				fieldsFlat: selectionForBuild.map(({ field }) => ({
-	// 					path: [],
-	// 					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-	// 				})),
-	// 				joins,
-	// 				distinct,
-	// 			}),
-	// 			{},
-	// 			tableAlias,
-	// 		);
-	// 		selectionForBuild = selection.map((item) =>
-	// 			is(item.field, SQL.Aliased)
-	// 				? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
-	// 				: item
-	// 		);
-	// 		joins = [];
-	// 		distinct = undefined;
-	// 	}
-
-	// 	const result = this.buildSelectQuery({
-	// 		table: is(tableFrom, GelTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
-	// 		fields: {},
-	// 		fieldsFlat: selectionForBuild.map(({ field }) => ({
-	// 			path: [],
-	// 			field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-	// 		})),
-	// 		where,
-	// 		limit,
-	// 		offset,
-	// 		joins,
-	// 		orderBy,
-	// 		distinct,
-	// 	});
-
-	// 	return {
-	// 		tableTsKey: tableConfig.tsName,
-	// 		sql: result,
-	// 		selection,
-	// 	};
-	// }
-
-	buildRelationalQueryWithoutPK({
-		fullSchema,
-		schema,
-		tableNamesMap,
-		table,
-		tableConfig,
-		queryConfig: config,
-		tableAlias,
-		nestedQueryRelation,
-		joinOn,
-	}: {
-		fullSchema: Record<string, unknown>;
-		schema: TablesRelationalConfig;
-		tableNamesMap: Record<string, string>;
-		table: GelTable;
-		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
-		tableAlias: string;
-		nestedQueryRelation?: Relation;
-		joinOn?: SQL;
-	}): BuildRelationalQueryResult<GelTable, GelColumn> {
-		let selection: BuildRelationalQueryResult<GelTable, GelColumn>['selection'] = [];
-		let limit, offset, orderBy: NonNullable<GelSelectConfig['orderBy']> = [], where;
-		const joins: GelSelectJoinConfig[] = [];
-
-		if (config === true) {
-			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
-				dbKey: value.name,
-				tsKey: key,
-				field: aliasedTableColumn(value as GelColumn, tableAlias),
-				relationTableTsKey: undefined,
-				isJson: false,
-				selection: [],
-			}));
-		} else {
-			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map((
-					[key, value],
-				) => [key, aliasedTableColumn(value, tableAlias)]),
-			);
-
-			if (config.where) {
-				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
-					: config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
-
-			const fieldsSelection: { tsKey: string; value: GelColumn | SQL.Aliased }[] = [];
-			let selectedColumns: string[] = [];
-
-			// Figure out which columns to select
-			if (config.columns) {
-				let isIncludeMode = false;
-
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === undefined) {
-						continue;
-					}
-
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) {
-							isIncludeMode = true;
-						}
-						selectedColumns.push(field);
-					}
-				}
-
-				if (selectedColumns.length > 0) {
-					selectedColumns = isIncludeMode
-						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-				}
-			} else {
-				// Select all columns if selection is not specified
-				selectedColumns = Object.keys(tableConfig.columns);
-			}
-
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as GelColumn;
-				fieldsSelection.push({ tsKey: field, value: column });
-			}
-
-			let selectedRelations: {
-				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
-			}[] = [];
-
-			// Figure out which relations to select
-			if (config.with) {
-				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-			}
-
-			let extras;
-
-			// Figure out which extras to select
-			if (config.extras) {
-				extras = typeof config.extras === 'function'
-					? config.extras(aliasedColumns, { sql })
-					: config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) {
-					fieldsSelection.push({
-						tsKey,
-						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-					});
-				}
-			}
-
-			// Transform `fieldsSelection` into `selection`
-			// `fieldsSelection` shouldn't be used after this point
-			for (const { tsKey, value } of fieldsSelection) {
-				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-					relationTableTsKey: undefined,
-					isJson: false,
-					selection: [],
-				});
-			}
-
-			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) {
-				orderByOrig = [orderByOrig];
-			}
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as GelColumn;
-				}
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
-
-			limit = config.limit;
-			offset = config.offset;
-
-			// Process all relations
-			for (
-				const {
-					tsKey: selectedRelationTsKey,
-					queryConfig: selectedRelationConfigValue,
-					relation,
-				} of selectedRelations
-			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableName = getTableUniqueName(relation.referencedTable);
-				const relationTableTsName = tableNamesMap[relationTableName]!;
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				const joinOn = and(
-					...normalizedRelation.fields.map((field, i) =>
-						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-							aliasedTableColumn(field, tableAlias),
-						)
-					),
-				);
-				const builtRelation = this.buildRelationalQueryWithoutPK({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName] as GelTable,
-					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
-							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
-						: selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation,
-				});
-				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
-				joins.push({
-					on: sql`true`,
-					table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
-					alias: relationTableAlias,
-					joinType: 'left',
-					lateral: true,
-				});
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection,
-				});
-			}
-		}
-
-		if (selection.length === 0) {
-			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
-		}
-
-		let result;
-
-		where = and(joinOn, where);
-
-		if (nestedQueryRelation) {
-			let field = sql`json_build_array(${
-				sql.join(
-					selection.map(({ field, tsKey, isJson }) =>
-						isJson
-							? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier('data')}`
-							: is(field, SQL.Aliased)
-							? field.sql
-							: field
-					),
-					sql`, `,
-				)
-			})`;
-			if (is(nestedQueryRelation, Many)) {
-				field = sql`coalesce(json_agg(${field}${
-					orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : undefined
-				}), '[]'::json)`;
-				// orderBy = [];
-			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field: field.as('data'),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
-
-			const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
-
-			if (needsSubquery) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [{
-						path: [],
-						field: sql.raw('*'),
-					}],
-					where,
-					limit,
-					offset,
-					orderBy,
-					setOperators: [],
-				});
-
-				where = undefined;
-				limit = undefined;
-				offset = undefined;
-				orderBy = [];
-			} else {
-				result = aliasedTable(table, tableAlias);
-			}
-
-			result = this.buildSelectQuery({
-				table: is(result, GelTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		} else {
-			result = this.buildSelectQuery({
-				table: aliasedTable(table, tableAlias),
-				fields: {},
-				fieldsFlat: selection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		}
-
-		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
-			selection,
-		};
-	}
-}
diff --git a/drizzle-orm/src/gel-core/expressions.ts b/drizzle-orm/src/gel-core/expressions.ts
deleted file mode 100644
index 9993cd48e8..0000000000
--- a/drizzle-orm/src/gel-core/expressions.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import type { GelColumn } from '~/gel-core/columns/index.ts';
-import { bindIfParam } from '~/sql/expressions/index.ts';
-import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
-import { sql } from '~/sql/sql.ts';
-
-export * from '~/sql/expressions/index.ts';
-
-export function concat(column: GelColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
-	return sql`${column} || ${bindIfParam(value, column)}`;
-}
-
-export function substring(
-	column: GelColumn | SQL.Aliased,
-	{ from, for: _for }: { from?: number | Placeholder | SQLWrapper; for?: number | Placeholder | SQLWrapper },
-): SQL {
-	const chunks: SQLChunk[] = [sql`substring(`, column];
-	if (from !== undefined) {
-		chunks.push(sql` from `, bindIfParam(from, column));
-	}
-	if (_for !== undefined) {
-		chunks.push(sql` for `, bindIfParam(_for, column));
-	}
-	chunks.push(sql`)`);
-	return sql.join(chunks);
-}
diff --git a/drizzle-orm/src/gel-core/foreign-keys.ts b/drizzle-orm/src/gel-core/foreign-keys.ts
deleted file mode 100644
index 13ccb0e662..0000000000
--- a/drizzle-orm/src/gel-core/foreign-keys.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { TableName } from '~/table.utils.ts';
-import type { AnyGelColumn, GelColumn } from './columns/index.ts';
-import type { GelTable } from './table.ts';
-
-export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
-
-export type Reference = () => {
-	readonly name?: string;
-	readonly columns: GelColumn[];
-	readonly foreignTable: GelTable;
-	readonly foreignColumns: GelColumn[];
-};
-
-export class ForeignKeyBuilder {
-	static readonly [entityKind]: string = 'GelForeignKeyBuilder';
-
-	/** @internal */
-	reference: Reference;
-
-	/** @internal */
-	_onUpdate: UpdateDeleteAction | undefined = 'no action';
-
-	/** @internal */
-	_onDelete: UpdateDeleteAction | undefined = 'no action';
-
-	constructor(
-		config: () => {
-			name?: string;
-			columns: GelColumn[];
-			foreignColumns: GelColumn[];
-		},
-		actions?: {
-			onUpdate?: UpdateDeleteAction;
-			onDelete?: UpdateDeleteAction;
-		} | undefined,
-	) {
-		this.reference = () => {
-			const { name, columns, foreignColumns } = config();
-			return { name, columns, foreignTable: foreignColumns[0]!.table as GelTable, foreignColumns };
-		};
-		if (actions) {
-			this._onUpdate = actions.onUpdate;
-			this._onDelete = actions.onDelete;
-		}
-	}
-
-	onUpdate(action: UpdateDeleteAction): this {
-		this._onUpdate = action === undefined ? 'no action' : action;
-		return this;
-	}
-
-	onDelete(action: UpdateDeleteAction): this {
-		this._onDelete = action === undefined ? 'no action' : action;
-		return this;
-	}
-
-	/** @internal */
-	build(table: GelTable): ForeignKey {
-		return new ForeignKey(table, this);
-	}
-}
-
-export type AnyForeignKeyBuilder = ForeignKeyBuilder;
-
-export class ForeignKey {
-	static readonly [entityKind]: string = 'GelForeignKey';
-
-	readonly reference: Reference;
-	readonly onUpdate: UpdateDeleteAction | undefined;
-	readonly onDelete: UpdateDeleteAction | undefined;
-
-	constructor(readonly table: GelTable, builder: ForeignKeyBuilder) {
-		this.reference = builder.reference;
-		this.onUpdate = builder._onUpdate;
-		this.onDelete = builder._onDelete;
-	}
-
-	getName(): string {
-		const { name, columns, foreignColumns } = this.reference();
-		const columnNames = columns.map((column) => column.name);
-		const foreignColumnNames = foreignColumns.map((column) => column.name);
-		const chunks = [
-			this.table[TableName],
-			...columnNames,
-			foreignColumns[0]!.table[TableName],
-			...foreignColumnNames,
-		];
-		return name ?? `${chunks.join('_')}_fk`;
-	}
-}
-
-type ColumnsWithTable<
-	TTableName extends string,
-	TColumns extends GelColumn[],
-> = { [Key in keyof TColumns]: AnyGelColumn<{ tableName: TTableName }> };
-
-export function foreignKey<
-	TTableName extends string,
-	TForeignTableName extends string,
-	TColumns extends [AnyGelColumn<{ tableName: TTableName }>, ...AnyGelColumn<{ tableName: TTableName }>[]],
->(
-	config: {
-		name?: string;
-		columns: TColumns;
-		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
-	},
-): ForeignKeyBuilder {
-	function mappedConfig() {
-		const { name, columns, foreignColumns } = config;
-		return {
-			name,
-			columns,
-			foreignColumns,
-		};
-	}
-
-	return new ForeignKeyBuilder(mappedConfig);
-}
diff --git a/drizzle-orm/src/gel-core/index.ts b/drizzle-orm/src/gel-core/index.ts
deleted file mode 100644
index e75312e451..0000000000
--- a/drizzle-orm/src/gel-core/index.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-export * from './alias.ts';
-export * from './checks.ts';
-export * from './columns/index.ts';
-export * from './db.ts';
-export * from './dialect.ts';
-export * from './foreign-keys.ts';
-export * from './indexes.ts';
-export * from './policies.ts';
-export * from './primary-keys.ts';
-export * from './query-builders/index.ts';
-export * from './roles.ts';
-export * from './schema.ts';
-export * from './sequence.ts';
-export * from './session.ts';
-export * from './subquery.ts';
-export * from './table.ts';
-export * from './unique-constraint.ts';
-export * from './utils.ts';
-export * from './view-common.ts';
-export * from './view.ts';
diff --git a/drizzle-orm/src/gel-core/indexes.ts b/drizzle-orm/src/gel-core/indexes.ts
deleted file mode 100644
index 55234e419a..0000000000
--- a/drizzle-orm/src/gel-core/indexes.ts
+++ /dev/null
@@ -1,259 +0,0 @@
-import { SQL } from '~/sql/sql.ts';
-
-import { entityKind, is } from '~/entity.ts';
-import type { GelColumn, GelExtraConfigColumn } from './columns/index.ts';
-import { IndexedColumn } from './columns/index.ts';
-import type { GelTable } from './table.ts';
-
-interface IndexConfig {
-	name?: string;
-
-	columns: Partial<IndexedColumn | SQL>[];
-
-	/**
-	 * If true, the index will be created as `create unique index` instead of `create index`.
-	 */
-	unique: boolean;
-
-	/**
-	 * If true, the index will be created as `create index concurrently` instead of `create index`.
-	 */
-	concurrently?: boolean;
-
-	/**
-	 * If true, the index will be created as `create index ... on only <table>` instead of `create index ... on <table>`.
-	 */
-	only: boolean;
-
-	/**
-	 * Condition for partial index.
-	 */
-	where?: SQL;
-
-	/**
-	 * The optional WITH clause specifies storage parameters for the index
-	 */
-	with?: Record<string, any>;
-
-	/**
-	 * The optional WITH clause method for the index
-	 */
-	method?: 'btree' | string;
-}
-
-export type IndexColumn = GelColumn;
-
-export type GelIndexMethod =
-	| 'btree'
-	| 'hash'
-	| 'gist'
-	| 'sGelist'
-	| 'gin'
-	| 'brin'
-	| 'hnsw'
-	| 'ivfflat'
-	| (string & {});
-
-export type GelIndexOpClass =
-	| 'abstime_ops'
-	| 'access_method'
-	| 'anyarray_eq'
-	| 'anyarray_ge'
-	| 'anyarray_gt'
-	| 'anyarray_le'
-	| 'anyarray_lt'
-	| 'anyarray_ne'
-	| 'bigint_ops'
-	| 'bit_ops'
-	| 'bool_ops'
-	| 'box_ops'
-	| 'bpchar_ops'
-	| 'char_ops'
-	| 'cidr_ops'
-	| 'cstring_ops'
-	| 'date_ops'
-	| 'float_ops'
-	| 'int2_ops'
-	| 'int4_ops'
-	| 'int8_ops'
-	| 'interval_ops'
-	| 'jsonb_ops'
-	| 'macaddr_ops'
-	| 'name_ops'
-	| 'numeric_ops'
-	| 'oid_ops'
-	| 'oidint4_ops'
-	| 'oidint8_ops'
-	| 'oidname_ops'
-	| 'oidvector_ops'
-	| 'point_ops'
-	| 'polygon_ops'
-	| 'range_ops'
-	| 'record_eq'
-	| 'record_ge'
-	| 'record_gt'
-	| 'record_le'
-	| 'record_lt'
-	| 'record_ne'
-	| 'text_ops'
-	| 'time_ops'
-	| 'timestamp_ops'
-	| 'timestamptz_ops'
-	| 'timetz_ops'
-	| 'uuid_ops'
-	| 'varbit_ops'
-	| 'varchar_ops'
-	| 'xml_ops'
-	| 'vector_l2_ops'
-	| 'vector_ip_ops'
-	| 'vector_cosine_ops'
-	| 'vector_l1_ops'
-	| 'bit_hamming_ops'
-	| 'bit_jaccard_ops'
-	| 'halfvec_l2_ops'
-	| 'sparsevec_l2_op'
-	| (string & {});
-
-export class IndexBuilderOn {
-	static readonly [entityKind]: string = 'GelIndexBuilderOn';
-
-	constructor(private unique: boolean, private name?: string) {}
-
-	on(...columns: [Partial<GelExtraConfigColumn> | SQL, ...Partial<GelExtraConfigColumn | SQL>[]]): IndexBuilder {
-		return new IndexBuilder(
-			columns.map((it) => {
-				if (is(it, SQL)) {
-					return it;
-				}
-				it = it as GelExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-				return clonedIndexedColumn;
-			}),
-			this.unique,
-			false,
-			this.name,
-		);
-	}
-
-	onOnly(...columns: [Partial<GelExtraConfigColumn | SQL>, ...Partial<GelExtraConfigColumn | SQL>[]]): IndexBuilder {
-		return new IndexBuilder(
-			columns.map((it) => {
-				if (is(it, SQL)) {
-					return it;
-				}
-				it = it as GelExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = it.defaultConfig;
-				return clonedIndexedColumn;
-			}),
-			this.unique,
-			true,
-			this.name,
-		);
-	}
-
-	/**
-	 * Specify what index method to use. Choices are `btree`, `hash`, `gist`, `sGelist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
-	 *
-	 * If you have the `Gel_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
-	 *
-	 * **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
-	 *
-	 * @param method The name of the index method to be used
-	 * @param columns
-	 * @returns
-	 */
-	using(
-		method: GelIndexMethod,
-		...columns: [Partial<GelExtraConfigColumn | SQL>, ...Partial<GelExtraConfigColumn | SQL>[]]
-	): IndexBuilder {
-		return new IndexBuilder(
-			columns.map((it) => {
-				if (is(it, SQL)) {
-					return it;
-				}
-				it = it as GelExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-				return clonedIndexedColumn;
-			}),
-			this.unique,
-			true,
-			this.name,
-			method,
-		);
-	}
-}
-
-export interface AnyIndexBuilder {
-	build(table: GelTable): Index;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface IndexBuilder extends AnyIndexBuilder {}
-
-export class IndexBuilder implements AnyIndexBuilder {
-	static readonly [entityKind]: string = 'GelIndexBuilder';
-
-	/** @internal */
-	config: IndexConfig;
-
-	constructor(
-		columns: Partial<IndexedColumn | SQL>[],
-		unique: boolean,
-		only: boolean,
-		name?: string,
-		method: string = 'btree',
-	) {
-		this.config = {
-			name,
-			columns,
-			unique,
-			only,
-			method,
-		};
-	}
-
-	concurrently(): this {
-		this.config.concurrently = true;
-		return this;
-	}
-
-	with(obj: Record<string, any>): this {
-		this.config.with = obj;
-		return this;
-	}
-
-	where(condition: SQL): this {
-		this.config.where = condition;
-		return this;
-	}
-
-	/** @internal */
-	build(table: GelTable): Index {
-		return new Index(this.config, table);
-	}
-}
-
-export class Index {
-	static readonly [entityKind]: string = 'GelIndex';
-
-	readonly config: IndexConfig & { table: GelTable };
-
-	constructor(config: IndexConfig, table: GelTable) {
-		this.config = { ...config, table };
-	}
-}
-
-export type GetColumnsTableName<TColumns> = TColumns extends GelColumn ? TColumns['_']['name']
-	: TColumns extends GelColumn[] ? TColumns[number]['_']['name']
-	: never;
-
-export function index(name?: string): IndexBuilderOn {
-	return new IndexBuilderOn(false, name);
-}
-
-export function uniqueIndex(name?: string): IndexBuilderOn {
-	return new IndexBuilderOn(true, name);
-}
diff --git a/drizzle-orm/src/gel-core/policies.ts b/drizzle-orm/src/gel-core/policies.ts
deleted file mode 100644
index f302dca684..0000000000
--- a/drizzle-orm/src/gel-core/policies.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/sql.ts';
-import type { GelRole } from './roles.ts';
-import type { GelTable } from './table.ts';
-
-export type GelPolicyToOption =
-	| 'public'
-	| 'current_role'
-	| 'current_user'
-	| 'session_user'
-	| (string & {})
-	| GelPolicyToOption[]
-	| GelRole;
-
-export interface GelPolicyConfig {
-	as?: 'permissive' | 'restrictive';
-	for?: 'all' | 'select' | 'insert' | 'update' | 'delete';
-	to?: GelPolicyToOption;
-	using?: SQL;
-	withCheck?: SQL;
-}
-
-export class GelPolicy implements GelPolicyConfig {
-	static readonly [entityKind]: string = 'GelPolicy';
-
-	readonly as: GelPolicyConfig['as'];
-	readonly for: GelPolicyConfig['for'];
-	readonly to: GelPolicyConfig['to'];
-	readonly using: GelPolicyConfig['using'];
-	readonly withCheck: GelPolicyConfig['withCheck'];
-
-	/** @internal */
-	_linkedTable?: GelTable;
-
-	constructor(
-		readonly name: string,
-		config?: GelPolicyConfig,
-	) {
-		if (config) {
-			this.as = config.as;
-			this.for = config.for;
-			this.to = config.to;
-			this.using = config.using;
-			this.withCheck = config.withCheck;
-		}
-	}
-
-	link(table: GelTable): this {
-		this._linkedTable = table;
-		return this;
-	}
-}
-
-export function gelPolicy(name: string, config?: GelPolicyConfig) {
-	return new GelPolicy(name, config);
-}
diff --git a/drizzle-orm/src/gel-core/primary-keys.ts b/drizzle-orm/src/gel-core/primary-keys.ts
deleted file mode 100644
index 8bbc831bb2..0000000000
--- a/drizzle-orm/src/gel-core/primary-keys.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import type { AnyGelColumn, GelColumn } from './columns/index.ts';
-import { GelTable } from './table.ts';
-
-export function primaryKey<
-	TTableName extends string,
-	TColumn extends AnyGelColumn<{ tableName: TTableName }>,
-	TColumns extends AnyGelColumn<{ tableName: TTableName }>[],
->(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
-/**
- * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
- * @param columns
- */
-export function primaryKey<
-	TTableName extends string,
-	TColumns extends AnyGelColumn<{ tableName: TTableName }>[],
->(...columns: TColumns): PrimaryKeyBuilder;
-export function primaryKey(...config: any) {
-	if (config[0].columns) {
-		return new PrimaryKeyBuilder(config[0].columns, config[0].name);
-	}
-	return new PrimaryKeyBuilder(config);
-}
-
-export class PrimaryKeyBuilder {
-	static readonly [entityKind]: string = 'GelPrimaryKeyBuilder';
-
-	/** @internal */
-	columns: GelColumn[];
-
-	/** @internal */
-	name?: string;
-
-	constructor(
-		columns: GelColumn[],
-		name?: string,
-	) {
-		this.columns = columns;
-		this.name = name;
-	}
-
-	/** @internal */
-	build(table: GelTable): PrimaryKey {
-		return new PrimaryKey(table, this.columns, this.name);
-	}
-}
-
-export class PrimaryKey {
-	static readonly [entityKind]: string = 'GelPrimaryKey';
-
-	readonly columns: AnyGelColumn<{}>[];
-	readonly name?: string;
-
-	constructor(readonly table: GelTable, columns: AnyGelColumn<{}>[], name?: string) {
-		this.columns = columns;
-		this.name = name;
-	}
-
-	getName(): string {
-		return this.name ?? `${this.table[GelTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/count.ts b/drizzle-orm/src/gel-core/query-builders/count.ts
deleted file mode 100644
index b795d5a28b..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/count.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import type { GelSession } from '../session.ts';
-import type { GelTable } from '../table.ts';
-
-export class GelCountBuilder<
-	TSession extends GelSession<any, any, any>,
-> extends SQL<number> implements Promise<number>, SQLWrapper {
-	private sql: SQL<number>;
-
-	static override readonly [entityKind] = 'GelCountBuilder';
-	[Symbol.toStringTag] = 'GelCountBuilder';
-
-	private session: TSession;
-
-	private static buildEmbeddedCount(
-		source: GelTable | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	): SQL<number> {
-		return sql<number>`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
-	}
-
-	private static buildCount(
-		source: GelTable | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	): SQL<number> {
-		return sql<number>`select count(*) as count from ${source}${sql.raw(' where ').if(filters)}${filters};`;
-	}
-
-	constructor(
-		readonly params: {
-			source: GelTable | SQL | SQLWrapper;
-			filters?: SQL<unknown>;
-			session: TSession;
-		},
-	) {
-		super(GelCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-
-		this.mapWith(Number);
-
-		this.session = params.session;
-
-		this.sql = GelCountBuilder.buildCount(
-			params.source,
-			params.filters,
-		);
-	}
-
-	then<TResult1 = number, TResult2 = never>(
-		onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined,
-	): Promise<TResult1 | TResult2> {
-		return Promise.resolve(this.session.count(this.sql))
-			.then(
-				onfulfilled,
-				onrejected,
-			);
-	}
-
-	catch(
-		onRejected?: ((reason: any) => any) | null | undefined,
-	): Promise<number> {
-		return this.then(undefined, onRejected);
-	}
-
-	finally(onFinally?: (() => void) | null | undefined): Promise<number> {
-		return this.then(
-			(value) => {
-				onFinally?.();
-				return value;
-			},
-			(reason) => {
-				onFinally?.();
-				throw reason;
-			},
-		);
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/delete.ts b/drizzle-orm/src/gel-core/query-builders/delete.ts
deleted file mode 100644
index cbb0ddacab..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/delete.ts
+++ /dev/null
@@ -1,248 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type {
-	GelPreparedQuery,
-	GelQueryResultHKT,
-	GelQueryResultKind,
-	GelSession,
-	PreparedQueryConfig,
-} from '~/gel-core/session.ts';
-import type { GelTable } from '~/gel-core/table.ts';
-import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
-import type { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
-import { orderSelectedFields } from '~/utils.ts';
-import type { GelColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
-import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
-
-export type GelDeleteWithout<
-	T extends AnyGelDeleteBase,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-> = TDynamic extends true ? T
-	: Omit<
-		GelDeleteBase<
-			T['_']['table'],
-			T['_']['queryResult'],
-			T['_']['returning'],
-			TDynamic,
-			T['_']['excludedMethods'] | K
-		>,
-		T['_']['excludedMethods'] | K
-	>;
-
-export type GelDelete<
-	TTable extends GelTable = GelTable,
-	TQueryResult extends GelQueryResultHKT = GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = GelDeleteBase<TTable, TQueryResult, TReturning, true, never>;
-
-export interface GelDeleteConfig {
-	where?: SQL | undefined;
-	table: GelTable;
-	returning?: SelectedFieldsOrdered;
-	withList?: Subquery[];
-}
-
-export type GelDeleteReturningAll<
-	T extends AnyGelDeleteBase,
-	TDynamic extends boolean,
-> = GelDeleteWithout<
-	GelDeleteBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['table']['$inferSelect'],
-		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
-
-export type GelDeleteReturning<
-	T extends AnyGelDeleteBase,
-	TDynamic extends boolean,
-	TSelectedFields extends SelectedFieldsFlat,
-> = GelDeleteWithout<
-	GelDeleteBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		SelectResultFields<TSelectedFields>,
-		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
-
-export type GelDeletePrepare<T extends AnyGelDeleteBase> = GelPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? GelQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
-
-export type GelDeleteDynamic<T extends AnyGelDeleteBase> = GelDelete<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['returning']
->;
-
-export type AnyGelDeleteBase = GelDeleteBase<any, any, any, any, any>;
-
-export interface GelDeleteBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-> extends
-	QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-	SQLWrapper
-{
-	readonly _: {
-		dialect: 'gel';
-		readonly table: TTable;
-		readonly queryResult: TQueryResult;
-		readonly returning: TReturning;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[];
-	};
-}
-
-export class GelDeleteBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-		SQLWrapper
-{
-	static override readonly [entityKind]: string = 'GelDelete';
-
-	private config: GelDeleteConfig;
-
-	constructor(
-		table: TTable,
-		private session: GelSession,
-		private dialect: GelDialect,
-		withList?: Subquery[],
-	) {
-		super();
-		this.config = { table, withList };
-	}
-
-	/**
-	 * Adds a `where` clause to the query.
-	 *
-	 * Calling this method will delete only those rows that fulfill a specified condition.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete}
-	 *
-	 * @param where the `where` clause.
-	 *
-	 * @example
-	 * You can use conditional operators and `sql function` to filter the rows to be deleted.
-	 *
-	 * ```ts
-	 * // Delete all cars with green color
-	 * await db.delete(cars).where(eq(cars.color, 'green'));
-	 * // or
-	 * await db.delete(cars).where(sql`${cars.color} = 'green'`)
-	 * ```
-	 *
-	 * You can logically combine conditional operators with `and()` and `or()` operators:
-	 *
-	 * ```ts
-	 * // Delete all BMW cars with a green color
-	 * await db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
-	 *
-	 * // Delete all cars with the green or blue color
-	 * await db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
-	 * ```
-	 */
-	where(where: SQL | undefined): GelDeleteWithout<this, TDynamic, 'where'> {
-		this.config.where = where;
-		return this as any;
-	}
-
-	/**
-	 * Adds a `returning` clause to the query.
-	 *
-	 * Calling this method will return the specified fields of the deleted rows. If no fields are specified, all fields will be returned.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete#delete-with-return}
-	 *
-	 * @example
-	 * ```ts
-	 * // Delete all cars with the green color and return all fields
-	 * const deletedCars: Car[] = await db.delete(cars)
-	 *   .where(eq(cars.color, 'green'))
-	 *   .returning();
-	 *
-	 * // Delete all cars with the green color and return only their id and brand fields
-	 * const deletedCarsIdsAndBrands: { id: number, brand: string }[] = await db.delete(cars)
-	 *   .where(eq(cars.color, 'green'))
-	 *   .returning({ id: cars.id, brand: cars.brand });
-	 * ```
-	 */
-	returning(): GelDeleteReturningAll<this, TDynamic>;
-	returning<TSelectedFields extends SelectedFieldsFlat>(
-		fields: TSelectedFields,
-	): GelDeleteReturning<this, TDynamic, TSelectedFields>;
-	returning(
-		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
-	): GelDeleteReturning<this, TDynamic, any> {
-		this.config.returning = orderSelectedFields<GelColumn>(fields);
-		return this as any;
-	}
-
-	/** @internal */
-	getSQL(): SQL {
-		return this.dialect.buildDeleteQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): GelDeletePrepare<this> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery<
-				PreparedQueryConfig & {
-					execute: TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[];
-				}
-			>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-				type: 'delete',
-				tables: extractUsedTable(this.config.table),
-			});
-		});
-	}
-
-	prepare(name: string): GelDeletePrepare<this> {
-		return this._prepare(name);
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues);
-		});
-	};
-
-	$dynamic(): GelDeleteDynamic<this> {
-		return this as any;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/insert.ts b/drizzle-orm/src/gel-core/query-builders/insert.ts
deleted file mode 100644
index 754dbd2b10..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/insert.ts
+++ /dev/null
@@ -1,410 +0,0 @@
-import { entityKind, is } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type { IndexColumn } from '~/gel-core/indexes.ts';
-import type {
-	GelPreparedQuery,
-	GelQueryResultHKT,
-	GelQueryResultKind,
-	GelSession,
-	PreparedQueryConfig,
-} from '~/gel-core/session.ts';
-import type { GelTable, TableConfig } from '~/gel-core/table.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
-import { Param, SQL } from '~/sql/sql.ts';
-import type { Subquery } from '~/subquery.ts';
-import type { InferInsertModel } from '~/table.ts';
-import { Columns, Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
-import { haveSameKeys, type NeonAuthToken, orderSelectedFields } from '~/utils.ts';
-import type { AnyGelColumn, GelColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
-import { QueryBuilder } from './query-builder.ts';
-import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
-import type { GelUpdateSetSource } from './update.ts';
-
-export interface GelInsertConfig<TTable extends GelTable = GelTable> {
-	table: TTable;
-	values: Record<string, Param | SQL>[] | GelInsertSelectQueryBuilder<TTable> | SQL;
-	withList?: Subquery[];
-	onConflict?: SQL;
-	returning?: SelectedFieldsOrdered;
-	select?: boolean;
-	overridingSystemValue_?: boolean;
-}
-
-export type GelInsertValue<TTable extends GelTable<TableConfig>, OverrideT extends boolean = false> =
-	& {
-		[Key in keyof InferInsertModel<TTable, { dbColumnNames: false; override: OverrideT }>]:
-			| InferInsertModel<TTable, { dbColumnNames: false; override: OverrideT }>[Key]
-			| SQL
-			| Placeholder;
-	}
-	& {};
-
-export type GelInsertSelectQueryBuilder<TTable extends GelTable> = TypedQueryBuilder<
-	{ [K in keyof TTable['$inferInsert']]: AnyGelColumn | SQL | SQL.Aliased | TTable['$inferInsert'][K] }
->;
-
-export class GelInsertBuilder<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	OverrideT extends boolean = false,
-> {
-	static readonly [entityKind]: string = 'GelInsertBuilder';
-
-	constructor(
-		private table: TTable,
-		private session: GelSession,
-		private dialect: GelDialect,
-		private withList?: Subquery[],
-		private overridingSystemValue_?: boolean,
-	) {}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	overridingSystemValue(): Omit<GelInsertBuilder<TTable, TQueryResult, true>, 'overridingSystemValue'> {
-		this.overridingSystemValue_ = true;
-		return this as any;
-	}
-
-	values(value: GelInsertValue<TTable, OverrideT>): GelInsertBase<TTable, TQueryResult>;
-	values(values: GelInsertValue<TTable, OverrideT>[]): GelInsertBase<TTable, TQueryResult>;
-	values(
-		values: GelInsertValue<TTable, OverrideT> | GelInsertValue<TTable, OverrideT>[],
-	): GelInsertBase<TTable, TQueryResult> {
-		values = Array.isArray(values) ? values : [values];
-		if (values.length === 0) {
-			throw new Error('values() must be called with at least one value');
-		}
-		const mappedValues = values.map((entry) => {
-			const result: Record<string, Param | SQL> = {};
-			const cols = this.table[Table.Symbol.Columns];
-			for (const colKey of Object.keys(entry)) {
-				const colValue = entry[colKey as keyof typeof entry];
-				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
-			}
-			return result;
-		});
-
-		return new GelInsertBase(
-			this.table,
-			mappedValues,
-			this.session,
-			this.dialect,
-			this.withList,
-			false,
-			this.overridingSystemValue_,
-		);
-	}
-
-	select(selectQuery: (qb: QueryBuilder) => GelInsertSelectQueryBuilder<TTable>): GelInsertBase<TTable, TQueryResult>;
-	select(selectQuery: (qb: QueryBuilder) => SQL): GelInsertBase<TTable, TQueryResult>;
-	select(selectQuery: SQL): GelInsertBase<TTable, TQueryResult>;
-	select(selectQuery: GelInsertSelectQueryBuilder<TTable>): GelInsertBase<TTable, TQueryResult>;
-	select(
-		selectQuery:
-			| SQL
-			| GelInsertSelectQueryBuilder<TTable>
-			| ((qb: QueryBuilder) => GelInsertSelectQueryBuilder<TTable> | SQL),
-	): GelInsertBase<TTable, TQueryResult> {
-		const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
-
-		if (
-			!is(select, SQL)
-			&& !haveSameKeys(this.table[Columns], select._.selectedFields)
-		) {
-			throw new Error(
-				'Insert select error: selected fields are not the same or are in a different order compared to the table definition',
-			);
-		}
-
-		return new GelInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
-	}
-}
-
-export type GelInsertWithout<T extends AnyGelInsert, TDynamic extends boolean, K extends keyof T & string> =
-	TDynamic extends true ? T
-		: Omit<
-			GelInsertBase<
-				T['_']['table'],
-				T['_']['queryResult'],
-				T['_']['returning'],
-				TDynamic,
-				T['_']['excludedMethods'] | K
-			>,
-			T['_']['excludedMethods'] | K
-		>;
-
-export type GelInsertReturning<
-	T extends AnyGelInsert,
-	TDynamic extends boolean,
-	TSelectedFields extends SelectedFieldsFlat,
-> = GelInsertBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	SelectResultFields<TSelectedFields>,
-	TDynamic,
-	T['_']['excludedMethods']
->;
-
-export type GelInsertReturningAll<T extends AnyGelInsert, TDynamic extends boolean> = GelInsertBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['table']['$inferSelect'],
-	TDynamic,
-	T['_']['excludedMethods']
->;
-
-export interface GelInsertOnConflictDoUpdateConfig<T extends AnyGelInsert> {
-	target: IndexColumn | IndexColumn[];
-	/** @deprecated use either `targetWhere` or `setWhere` */
-	where?: SQL;
-	// TODO: add tests for targetWhere and setWhere
-	targetWhere?: SQL;
-	setWhere?: SQL;
-	set: GelUpdateSetSource<T['_']['table']>;
-}
-
-export type GelInsertPrepare<T extends AnyGelInsert> = GelPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? GelQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
-
-export type GelInsertDynamic<T extends AnyGelInsert> = GelInsert<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['returning']
->;
-
-export type AnyGelInsert = GelInsertBase<any, any, any, any, any>;
-
-export type GelInsert<
-	TTable extends GelTable = GelTable,
-	TQueryResult extends GelQueryResultHKT = GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = GelInsertBase<TTable, TQueryResult, TReturning, true, never>;
-
-export interface GelInsertBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-> extends
-	QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-	SQLWrapper
-{
-	readonly _: {
-		readonly dialect: 'gel';
-		readonly table: TTable;
-		readonly queryResult: TQueryResult;
-		readonly returning: TReturning;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[];
-	};
-}
-
-export class GelInsertBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-		SQLWrapper
-{
-	static override readonly [entityKind]: string = 'GelInsert';
-
-	private config: GelInsertConfig<TTable>;
-
-	constructor(
-		table: TTable,
-		values: GelInsertConfig['values'],
-		private session: GelSession,
-		private dialect: GelDialect,
-		withList?: Subquery[],
-		select?: boolean,
-		overridingSystemValue_?: boolean,
-	) {
-		super();
-		this.config = { table, values: values as any, withList, select, overridingSystemValue_ };
-	}
-
-	/**
-	 * Adds a `returning` clause to the query.
-	 *
-	 * Calling this method will return the specified fields of the inserted rows. If no fields are specified, all fields will be returned.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert#insert-returning}
-	 *
-	 * @example
-	 * ```ts
-	 * // Insert one row and return all fields
-	 * const insertedCar: Car[] = await db.insert(cars)
-	 *   .values({ brand: 'BMW' })
-	 *   .returning();
-	 *
-	 * // Insert one row and return only the id
-	 * const insertedCarId: { id: number }[] = await db.insert(cars)
-	 *   .values({ brand: 'BMW' })
-	 *   .returning({ id: cars.id });
-	 * ```
-	 */
-	returning(): GelInsertWithout<GelInsertReturningAll<this, TDynamic>, TDynamic, 'returning'>;
-	returning<TSelectedFields extends SelectedFieldsFlat>(
-		fields: TSelectedFields,
-	): GelInsertWithout<GelInsertReturning<this, TDynamic, TSelectedFields>, TDynamic, 'returning'>;
-	returning(
-		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
-	): GelInsertWithout<AnyGelInsert, TDynamic, 'returning'> {
-		this.config.returning = orderSelectedFields<GelColumn>(fields);
-		return this as any;
-	}
-
-	/**
-	 * Adds an `on conflict do nothing` clause to the query.
-	 *
-	 * Calling this method simply avoids inserting a row as its alternative action.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
-	 *
-	 * @param config The `target` and `where` clauses.
-	 *
-	 * @example
-	 * ```ts
-	 * // Insert one row and cancel the insert if there's a conflict
-	 * await db.insert(cars)
-	 *   .values({ id: 1, brand: 'BMW' })
-	 *   .onConflictDoNothing();
-	 *
-	 * // Explicitly specify conflict target
-	 * await db.insert(cars)
-	 *   .values({ id: 1, brand: 'BMW' })
-	 *   .onConflictDoNothing({ target: cars.id });
-	 * ```
-	 */
-	// TODO not supported
-	// onConflictDoNothing(
-	// 	config: { target?: IndexColumn | IndexColumn[]; where?: SQL } = {},
-	// ): GelInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
-	// 	if (config.target === undefined) {
-	// 		this.config.onConflict = sql`do nothing`;
-	// 	} else {
-	// 		let targetColumn = '';
-	// 		targetColumn = Array.isArray(config.target)
-	// 			? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(',')
-	// 			: this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
-
-	// 		const whereSql = config.where ? sql` where ${config.where}` : undefined;
-	// 		this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
-	// 	}
-	// 	return this as any;
-	// }
-
-	/**
-	 * Adds an `on conflict do update` clause to the query.
-	 *
-	 * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
-	 *
-	 * @param config The `target`, `set` and `where` clauses.
-	 *
-	 * @example
-	 * ```ts
-	 * // Update the row if there's a conflict
-	 * await db.insert(cars)
-	 *   .values({ id: 1, brand: 'BMW' })
-	 *   .onConflictDoUpdate({
-	 *     target: cars.id,
-	 *     set: { brand: 'Porsche' }
-	 *   });
-	 *
-	 * // Upsert with 'where' clause
-	 * await db.insert(cars)
-	 *   .values({ id: 1, brand: 'BMW' })
-	 *   .onConflictDoUpdate({
-	 *     target: cars.id,
-	 *     set: { brand: 'newBMW' },
-	 *     targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
-	 *   });
-	 * ```
-	 */
-	// TODO not supported
-	// onConflictDoUpdate(
-	// 	config: GelInsertOnConflictDoUpdateConfig<this>,
-	// ): GelInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
-	// 	if (config.where && (config.targetWhere || config.setWhere)) {
-	// 		throw new Error(
-	// 			'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.',
-	// 		);
-	// 	}
-	// 	const whereSql = config.where ? sql` where ${config.where}` : undefined;
-	// 	const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
-	// 	const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
-	// 	const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
-	// 	let targetColumn = '';
-	// 	targetColumn = Array.isArray(config.target)
-	// 		? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(',')
-	// 		: this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
-	// 	this.config.onConflict = sql`(${
-	// 		sql.raw(targetColumn)
-	// 	})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
-	// 	return this as any;
-	// }
-
-	/** @internal */
-	getSQL(): SQL {
-		return this.dialect.buildInsertQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): GelInsertPrepare<this> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery<
-				PreparedQueryConfig & {
-					execute: TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[];
-				}
-			>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			});
-		});
-	}
-
-	prepare(name: string): GelInsertPrepare<this> {
-		return this._prepare(name);
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues);
-		});
-	};
-
-	$dynamic(): GelInsertDynamic<this> {
-		return this as any;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/query-builder.ts b/drizzle-orm/src/gel-core/query-builders/query-builder.ts
deleted file mode 100644
index ad665baa0a..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/query-builder.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { entityKind, is } from '~/entity.ts';
-import type { GelDialectConfig } from '~/gel-core/dialect.ts';
-import { GelDialect } from '~/gel-core/dialect.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
-import { WithSubquery } from '~/subquery.ts';
-import type { GelColumn } from '../columns/index.ts';
-import type { WithSubqueryWithSelection } from '../subquery.ts';
-import { GelSelectBuilder } from './select.ts';
-import type { SelectedFields } from './select.types.ts';
-
-export class QueryBuilder {
-	static readonly [entityKind]: string = 'GelQueryBuilder';
-
-	private dialect: GelDialect | undefined;
-	private dialectConfig: GelDialectConfig | undefined;
-
-	constructor(dialect?: GelDialect | GelDialectConfig) {
-		this.dialect = is(dialect, GelDialect) ? dialect : undefined;
-		this.dialectConfig = is(dialect, GelDialect) ? undefined : dialect;
-	}
-
-	$with<TAlias extends string>(alias: TAlias) {
-		const queryBuilder = this;
-
-		return {
-			as<TSelection extends ColumnsSelection>(
-				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
-			): WithSubqueryWithSelection<TSelection, TAlias> {
-				if (typeof qb === 'function') {
-					qb = qb(queryBuilder);
-				}
-
-				return new Proxy(
-					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
-					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-				) as WithSubqueryWithSelection<TSelection, TAlias>;
-			},
-		};
-	}
-
-	with(...queries: WithSubquery[]) {
-		const self = this;
-
-		function select(): GelSelectBuilder<undefined, 'qb'>;
-		function select<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection, 'qb'>;
-		function select<TSelection extends SelectedFields>(
-			fields?: TSelection,
-		): GelSelectBuilder<TSelection | undefined, 'qb'> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: undefined,
-				dialect: self.getDialect(),
-				withList: queries,
-			});
-		}
-
-		function selectDistinct(): GelSelectBuilder<undefined, 'qb'>;
-		function selectDistinct<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection, 'qb'>;
-		function selectDistinct(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined, 'qb'> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: undefined,
-				dialect: self.getDialect(),
-				distinct: true,
-			});
-		}
-
-		function selectDistinctOn(on: (GelColumn | SQLWrapper)[]): GelSelectBuilder<undefined, 'qb'>;
-		function selectDistinctOn<TSelection extends SelectedFields>(
-			on: (GelColumn | SQLWrapper)[],
-			fields: TSelection,
-		): GelSelectBuilder<TSelection, 'qb'>;
-		function selectDistinctOn(
-			on: (GelColumn | SQLWrapper)[],
-			fields?: SelectedFields,
-		): GelSelectBuilder<SelectedFields | undefined, 'qb'> {
-			return new GelSelectBuilder({
-				fields: fields ?? undefined,
-				session: undefined,
-				dialect: self.getDialect(),
-				distinct: { on },
-			});
-		}
-
-		return { select, selectDistinct, selectDistinctOn };
-	}
-
-	select(): GelSelectBuilder<undefined, 'qb'>;
-	select<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection, 'qb'>;
-	select<TSelection extends SelectedFields>(fields?: TSelection): GelSelectBuilder<TSelection | undefined, 'qb'> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: undefined,
-			dialect: this.getDialect(),
-		});
-	}
-
-	selectDistinct(): GelSelectBuilder<undefined>;
-	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): GelSelectBuilder<TSelection>;
-	selectDistinct(fields?: SelectedFields): GelSelectBuilder<SelectedFields | undefined> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: undefined,
-			dialect: this.getDialect(),
-			distinct: true,
-		});
-	}
-
-	selectDistinctOn(on: (GelColumn | SQLWrapper)[]): GelSelectBuilder<undefined>;
-	selectDistinctOn<TSelection extends SelectedFields>(
-		on: (GelColumn | SQLWrapper)[],
-		fields: TSelection,
-	): GelSelectBuilder<TSelection>;
-	selectDistinctOn(
-		on: (GelColumn | SQLWrapper)[],
-		fields?: SelectedFields,
-	): GelSelectBuilder<SelectedFields | undefined> {
-		return new GelSelectBuilder({
-			fields: fields ?? undefined,
-			session: undefined,
-			dialect: this.getDialect(),
-			distinct: { on },
-		});
-	}
-
-	// Lazy load dialect to avoid circular dependency
-	private getDialect() {
-		if (!this.dialect) {
-			this.dialect = new GelDialect(this.dialectConfig);
-		}
-
-		return this.dialect;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/query.ts b/drizzle-orm/src/gel-core/query-builders/query.ts
deleted file mode 100644
index 810227a6c2..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/query.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import {
-	type BuildQueryResult,
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	mapRelationalRow,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import type { KnownKeysOnly } from '~/utils.ts';
-import type { GelDialect } from '../dialect.ts';
-import type { GelPreparedQuery, GelSession, PreparedQueryConfig } from '../session.ts';
-import type { GelTable } from '../table.ts';
-
-export class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-	static readonly [entityKind]: string = 'GelRelationalQueryBuilder';
-
-	constructor(
-		private fullSchema: Record<string, unknown>,
-		private schema: TSchema,
-		private tableNamesMap: Record<string, string>,
-		private table: GelTable,
-		private tableConfig: TableRelationalConfig,
-		private dialect: GelDialect,
-		private session: GelSession,
-	) {}
-
-	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
-		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
-	): GelRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]> {
-		return new GelRelationalQuery(
-			this.fullSchema,
-			this.schema,
-			this.tableNamesMap,
-			this.table,
-			this.tableConfig,
-			this.dialect,
-			this.session,
-			config ? (config as DBQueryConfig<'many', true>) : {},
-			'many',
-		);
-	}
-
-	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
-		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
-	): GelRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
-		return new GelRelationalQuery(
-			this.fullSchema,
-			this.schema,
-			this.tableNamesMap,
-			this.table,
-			this.tableConfig,
-			this.dialect,
-			this.session,
-			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
-			'first',
-		);
-	}
-}
-
-export class GelRelationalQuery<TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'gel'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'GelRelationalQuery';
-
-	declare readonly _: {
-		readonly dialect: 'gel';
-		readonly result: TResult;
-	};
-
-	constructor(
-		private fullSchema: Record<string, unknown>,
-		private schema: TablesRelationalConfig,
-		private tableNamesMap: Record<string, string>,
-		private table: GelTable,
-		private tableConfig: TableRelationalConfig,
-		private dialect: GelDialect,
-		private session: GelSession,
-		private config: DBQueryConfig<'many', true> | true,
-		private mode: 'many' | 'first',
-	) {
-		super();
-	}
-
-	/** @internal */
-	_prepare(name?: string): GelPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			const { query, builtQuery } = this._toSQL();
-
-			return this.session.prepareQuery<PreparedQueryConfig & { execute: TResult }>(
-				builtQuery,
-				undefined,
-				name,
-				true,
-				(rawRows, mapColumnValue) => {
-					const rows = rawRows.map((row) =>
-						mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
-					);
-					if (this.mode === 'first') {
-						return rows[0] as TResult;
-					}
-					return rows as TResult;
-				},
-			);
-		});
-	}
-
-	prepare(name: string): GelPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
-		return this._prepare(name);
-	}
-
-	private _getQuery() {
-		return this.dialect.buildRelationalQueryWithoutPK({
-			fullSchema: this.fullSchema,
-			schema: this.schema,
-			tableNamesMap: this.tableNamesMap,
-			table: this.table,
-			tableConfig: this.tableConfig,
-			queryConfig: this.config,
-			tableAlias: this.tableConfig.tsName,
-		});
-	}
-
-	/** @internal */
-	getSQL(): SQL {
-		return this._getQuery().sql as SQL;
-	}
-
-	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
-		const query = this._getQuery();
-
-		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
-
-		return { query, builtQuery };
-	}
-
-	toSQL(): Query {
-		return this._toSQL().builtQuery;
-	}
-
-	override execute(): Promise<TResult> {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(undefined);
-		});
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/raw.ts b/drizzle-orm/src/gel-core/query-builders/raw.ts
deleted file mode 100644
index e9d5661459..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/raw.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { PreparedQuery } from '~/session.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
-
-export interface GelRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'gel'>, SQLWrapper {}
-
-export class GelRaw<TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'gel'>, SQLWrapper, PreparedQuery
-{
-	static override readonly [entityKind]: string = 'GelRaw';
-
-	declare readonly _: {
-		readonly dialect: 'gel';
-		readonly result: TResult;
-	};
-
-	constructor(
-		public execute: () => Promise<TResult>,
-		private sql: SQL,
-		private query: Query,
-		private mapBatchResult: (result: unknown) => unknown,
-	) {
-		super();
-	}
-
-	/** @internal */
-	getSQL() {
-		return this.sql;
-	}
-
-	getQuery() {
-		return this.query;
-	}
-
-	mapResult(result: unknown, isFromBatch?: boolean) {
-		return isFromBatch ? this.mapBatchResult(result) : result;
-	}
-
-	_prepare(): PreparedQuery {
-		return this;
-	}
-
-	/** @internal */
-	isResponseInArrayMode() {
-		return false;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/refresh-materialized-view.ts b/drizzle-orm/src/gel-core/query-builders/refresh-materialized-view.ts
deleted file mode 100644
index c2fa8c19d8..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/refresh-materialized-view.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type {
-	GelPreparedQuery,
-	GelQueryResultHKT,
-	GelQueryResultKind,
-	GelSession,
-	PreparedQueryConfig,
-} from '~/gel-core/session.ts';
-import type { GelMaterializedView } from '~/gel-core/view.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface GelRefreshMaterializedView<TQueryResult extends GelQueryResultHKT>
-	extends
-		QueryPromise<GelQueryResultKind<TQueryResult, never>>,
-		RunnableQuery<GelQueryResultKind<TQueryResult, never>, 'gel'>,
-		SQLWrapper
-{
-	readonly _: {
-		readonly dialect: 'gel';
-		readonly result: GelQueryResultKind<TQueryResult, never>;
-	};
-}
-
-export class GelRefreshMaterializedView<TQueryResult extends GelQueryResultHKT>
-	extends QueryPromise<GelQueryResultKind<TQueryResult, never>>
-	implements RunnableQuery<GelQueryResultKind<TQueryResult, never>, 'gel'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'GelRefreshMaterializedView';
-
-	private config: {
-		view: GelMaterializedView;
-		concurrently?: boolean;
-		withNoData?: boolean;
-	};
-
-	constructor(
-		view: GelMaterializedView,
-		private session: GelSession,
-		private dialect: GelDialect,
-	) {
-		super();
-		this.config = { view };
-	}
-
-	concurrently(): this {
-		if (this.config.withNoData !== undefined) {
-			throw new Error('Cannot use concurrently and withNoData together');
-		}
-		this.config.concurrently = true;
-		return this;
-	}
-
-	withNoData(): this {
-		if (this.config.concurrently !== undefined) {
-			throw new Error('Cannot use concurrently and withNoData together');
-		}
-		this.config.withNoData = true;
-		return this;
-	}
-
-	/** @internal */
-	getSQL(): SQL {
-		return this.dialect.buildRefreshMaterializedViewQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): GelPreparedQuery<
-		PreparedQueryConfig & {
-			execute: GelQueryResultKind<TQueryResult, never>;
-		}
-	> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), undefined, name, true);
-		});
-	}
-
-	prepare(name: string): GelPreparedQuery<
-		PreparedQueryConfig & {
-			execute: GelQueryResultKind<TQueryResult, never>;
-		}
-	> {
-		return this._prepare(name);
-	}
-
-	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues);
-		});
-	};
-}
diff --git a/drizzle-orm/src/gel-core/query-builders/select.ts b/drizzle-orm/src/gel-core/query-builders/select.ts
deleted file mode 100644
index 204f95d7d5..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/select.ts
+++ /dev/null
@@ -1,1327 +0,0 @@
-import type { CacheConfig, WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind, is } from '~/entity.ts';
-import type { GelColumn } from '~/gel-core/columns/index.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type { GelSession, PreparedQueryConfig } from '~/gel-core/session.ts';
-import type { SubqueryWithSelection } from '~/gel-core/subquery.ts';
-import type { GelTable } from '~/gel-core/table.ts';
-import { GelViewBase } from '~/gel-core/view-base.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	BuildSubquerySelection,
-	GetSelectTableName,
-	GetSelectTableSelection,
-	JoinNullability,
-	JoinType,
-	SelectMode,
-	SelectResult,
-	SetOperator,
-} from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { SQL, View } from '~/sql/sql.ts';
-import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
-import { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
-import {
-	applyMixins,
-	getTableColumns,
-	getTableLikeName,
-	haveSameKeys,
-	type NeonAuthToken,
-	type ValueOrArray,
-} from '~/utils.ts';
-import { orderSelectedFields } from '~/utils.ts';
-import { ViewBaseConfig } from '~/view-common.ts';
-import { extractUsedTable } from '../utils.ts';
-import type {
-	AnyGelSelect,
-	CreateGelSelectFromBuilderMode,
-	GelCreateSetOperatorFn,
-	GelSelectConfig,
-	GelSelectDynamic,
-	GelSelectHKT,
-	GelSelectHKTBase,
-	GelSelectJoinFn,
-	GelSelectPrepare,
-	GelSelectWithout,
-	GelSetOperatorExcludedMethods,
-	GelSetOperatorWithResult,
-	GetGelSetOperators,
-	LockConfig,
-	LockStrength,
-	SelectedFields,
-	SetOperatorRightSelect,
-} from './select.types.ts';
-
-export class GelSelectBuilder<
-	TSelection extends SelectedFields | undefined,
-	TBuilderMode extends 'db' | 'qb' = 'db',
-> {
-	static readonly [entityKind]: string = 'GelSelectBuilder';
-
-	private fields: TSelection;
-	private session: GelSession | undefined;
-	private dialect: GelDialect;
-	private withList: Subquery[] = [];
-	private distinct: boolean | {
-		on: (GelColumn | SQLWrapper)[];
-	} | undefined;
-
-	constructor(
-		config: {
-			fields: TSelection;
-			session: GelSession | undefined;
-			dialect: GelDialect;
-			withList?: Subquery[];
-			distinct?: boolean | {
-				on: (GelColumn | SQLWrapper)[];
-			};
-		},
-	) {
-		this.fields = config.fields;
-		this.session = config.session;
-		this.dialect = config.dialect;
-		if (config.withList) {
-			this.withList = config.withList;
-		}
-		this.distinct = config.distinct;
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	/**
-	 * Specify the table, subquery, or other target that you're
-	 * building a select query against.
-	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
-	 */
-	from<TFrom extends GelTable | Subquery | GelViewBase | SQL>(
-		source: TFrom,
-	): CreateGelSelectFromBuilderMode<
-		TBuilderMode,
-		GetSelectTableName<TFrom>,
-		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
-		TSelection extends undefined ? 'single' : 'partial'
-	> {
-		const isPartialSelect = !!this.fields;
-
-		let fields: SelectedFields;
-		if (this.fields) {
-			fields = this.fields;
-		} else if (is(source, Subquery)) {
-			// This is required to use the proxy handler to get the correct field values from the subquery
-			fields = Object.fromEntries(
-				Object.keys(source._.selectedFields).map((
-					key,
-				) => [key, source[key as unknown as keyof typeof source] as unknown as SelectedFields[string]]),
-			);
-		} else if (is(source, GelViewBase)) {
-			fields = source[ViewBaseConfig].selectedFields as SelectedFields;
-		} else if (is(source, SQL)) {
-			fields = {};
-		} else {
-			fields = getTableColumns<GelTable>(source);
-		}
-
-		return new GelSelectBase({
-			table: source,
-			fields,
-			isPartialSelect,
-			session: this.session,
-			dialect: this.dialect,
-			withList: this.withList,
-			distinct: this.distinct,
-		}) as any;
-	}
-}
-
-export abstract class GelSelectQueryBuilderBase<
-	THKT extends GelSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult> {
-	static override readonly [entityKind]: string = 'GelSelectQueryBuilder';
-
-	override readonly _: {
-		readonly dialect: 'gel';
-		readonly hkt: THKT;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-		readonly config: GelSelectConfig;
-	};
-
-	protected config: GelSelectConfig;
-	protected joinsNotNullableMap: Record<string, boolean>;
-	private tableName: string | undefined;
-	private isPartialSelect: boolean;
-	protected session: GelSession | undefined;
-	protected dialect: GelDialect;
-	protected cacheConfig?: WithCacheConfig = undefined;
-	protected usedTables: Set<string> = new Set();
-
-	constructor(
-		{ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
-			table: GelSelectConfig['table'];
-			fields: GelSelectConfig['fields'];
-			isPartialSelect: boolean;
-			session: GelSession | undefined;
-			dialect: GelDialect;
-			withList: Subquery[];
-			distinct: boolean | {
-				on: (GelColumn | SQLWrapper)[];
-			} | undefined;
-		},
-	) {
-		super();
-		this.config = {
-			withList,
-			table,
-			fields: { ...fields },
-			distinct,
-			setOperators: [],
-		};
-		this.isPartialSelect = isPartialSelect;
-		this.session = session;
-		this.dialect = dialect;
-		this._ = {
-			selectedFields: fields as TSelectedFields,
-			config: this.config,
-		} as this['_'];
-		this.tableName = getTableLikeName(table);
-		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
-		for (const item of extractUsedTable(table)) this.usedTables.add(item);
-	}
-
-	/** @internal */
-	getUsedTables() {
-		return [...this.usedTables];
-	}
-
-	private createJoin<
-		TJoinType extends JoinType,
-		TIsLateral extends (TJoinType extends 'full' | 'right' ? false : boolean),
-	>(
-		joinType: TJoinType,
-		lateral: TIsLateral,
-	): GelSelectJoinFn<this, TDynamic, TJoinType, TIsLateral> {
-		return (
-			table: GelTable | Subquery | GelViewBase | SQL,
-			on?: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
-		) => {
-			const baseTableName = this.tableName;
-			const tableName = getTableLikeName(table);
-
-			if (typeof tableName === 'string' && this.config.joins?.some((join) => join.alias === tableName)) {
-				throw new Error(`Alias "${tableName}" is already used in this query`);
-			}
-
-			// store all tables used in a query
-			for (const item of extractUsedTable(table)) this.usedTables.add(item);
-
-			if (!this.isPartialSelect) {
-				// If this is the first join and this is not a partial select and we're not selecting from raw SQL, "move" the fields from the main table to the nested object
-				if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === 'string') {
-					this.config.fields = {
-						[baseTableName]: this.config.fields,
-					};
-				}
-				if (typeof tableName === 'string' && !is(table, SQL)) {
-					const selection = is(table, Subquery)
-						? table._.selectedFields
-						: is(table, View)
-						? table[ViewBaseConfig].selectedFields
-						: table[Table.Symbol.Columns];
-					this.config.fields[tableName] = selection;
-				}
-			}
-
-			if (typeof on === 'function') {
-				on = on(
-					new Proxy(
-						this.config.fields,
-						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
-					) as TSelection,
-				);
-			}
-
-			if (!this.config.joins) {
-				this.config.joins = [];
-			}
-
-			this.config.joins.push({ on, table, joinType, alias: tableName, lateral });
-
-			if (typeof tableName === 'string') {
-				switch (joinType) {
-					case 'left': {
-						this.joinsNotNullableMap[tableName] = false;
-						break;
-					}
-					case 'right': {
-						this.joinsNotNullableMap = Object.fromEntries(
-							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
-						);
-						this.joinsNotNullableMap[tableName] = true;
-						break;
-					}
-					case 'cross':
-					case 'inner': {
-						this.joinsNotNullableMap[tableName] = true;
-						break;
-					}
-					case 'full': {
-						this.joinsNotNullableMap = Object.fromEntries(
-							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
-						);
-						this.joinsNotNullableMap[tableName] = false;
-						break;
-					}
-				}
-			}
-
-			return this as any;
-		};
-	}
-
-	/**
-	 * Executes a `left join` operation by adding another table to the current query.
-	 *
-	 * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
-	 *
-	 * @param table the table to join.
-	 * @param on the `on` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all users and their pets
-	 * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
-	 *   .from(users)
-	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
-	 *
-	 * // Select userId and petId
-	 * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
-	 *   userId: users.id,
-	 *   petId: pets.id,
-	 * })
-	 *   .from(users)
-	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
-	 * ```
-	 */
-	leftJoin = this.createJoin('left', false);
-
-	/**
-	 * Executes a `left join lateral` operation by adding subquery to the current query.
-	 *
-	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-	 *
-	 * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}
-	 *
-	 * @param table the subquery to join.
-	 * @param on the `on` clause.
-	 */
-	leftJoinLateral = this.createJoin('left', true);
-
-	/**
-	 * Executes a `right join` operation by adding another table to the current query.
-	 *
-	 * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
-	 *
-	 * @param table the table to join.
-	 * @param on the `on` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all users and their pets
-	 * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
-	 *   .from(users)
-	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
-	 *
-	 * // Select userId and petId
-	 * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
-	 *   userId: users.id,
-	 *   petId: pets.id,
-	 * })
-	 *   .from(users)
-	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
-	 * ```
-	 */
-	rightJoin = this.createJoin('right', false);
-
-	/**
-	 * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
-	 *
-	 * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
-	 *
-	 * @param table the table to join.
-	 * @param on the `on` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all users and their pets
-	 * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
-	 *   .from(users)
-	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
-	 *
-	 * // Select userId and petId
-	 * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
-	 *   userId: users.id,
-	 *   petId: pets.id,
-	 * })
-	 *   .from(users)
-	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
-	 * ```
-	 */
-	innerJoin = this.createJoin('inner', false);
-
-	/**
-	 * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
-	 *
-	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-	 *
-	 * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}
-	 *
-	 * @param table the subquery to join.
-	 * @param on the `on` clause.
-	 */
-	innerJoinLateral = this.createJoin('inner', true);
-
-	/**
-	 * Executes a `full join` operation by combining rows from two tables into a new table.
-	 *
-	 * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
-	 *
-	 * @param table the table to join.
-	 * @param on the `on` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all users and their pets
-	 * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
-	 *   .from(users)
-	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
-	 *
-	 * // Select userId and petId
-	 * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
-	 *   userId: users.id,
-	 *   petId: pets.id,
-	 * })
-	 *   .from(users)
-	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
-	 * ```
-	 */
-	fullJoin = this.createJoin('full', false);
-
-	/**
-	 * Executes a `cross join` operation by combining rows from two tables into a new table.
-	 *
-	 * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
-	 *
-	 * @param table the table to join.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all users, each user with every pet
-	 * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
-	 *   .from(users)
-	 *   .crossJoin(pets)
-	 *
-	 * // Select userId and petId
-	 * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
-	 *   userId: users.id,
-	 *   petId: pets.id,
-	 * })
-	 *   .from(users)
-	 *   .crossJoin(pets)
-	 * ```
-	 */
-	crossJoin = this.createJoin('cross', false);
-
-	/**
-	 * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
-	 *
-	 * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-	 *
-	 * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
-	 *
-	 * @param table the query to join.
-	 */
-	crossJoinLateral = this.createJoin('cross', true);
-
-	private createSetOperator(
-		type: SetOperator,
-		isAll: boolean,
-	): <TValue extends GelSetOperatorWithResult<TResult>>(
-		rightSelection:
-			| ((setOperators: GetGelSetOperators) => SetOperatorRightSelect<TValue, TResult>)
-			| SetOperatorRightSelect<TValue, TResult>,
-	) => GelSelectWithout<
-		this,
-		TDynamic,
-		GelSetOperatorExcludedMethods,
-		true
-	> {
-		return (rightSelection) => {
-			const rightSelect = (typeof rightSelection === 'function'
-				? rightSelection(getGelSetOperators())
-				: rightSelection) as TypedQueryBuilder<
-					any,
-					TResult
-				>;
-
-			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
-				throw new Error(
-					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
-				);
-			}
-
-			this.config.setOperators.push({ type, isAll, rightSelect });
-			return this as any;
-		};
-	}
-
-	/**
-	 * Adds `union` set operator to the query.
-	 *
-	 * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all unique names from customers and users tables
-	 * await db.select({ name: users.name })
-	 *   .from(users)
-	 *   .union(
-	 *     db.select({ name: customers.name }).from(customers)
-	 *   );
-	 * // or
-	 * import { union } from 'drizzle-orm/gel-core'
-	 *
-	 * await union(
-	 *   db.select({ name: users.name }).from(users),
-	 *   db.select({ name: customers.name }).from(customers)
-	 * );
-	 * ```
-	 */
-	union = this.createSetOperator('union', false);
-
-	/**
-	 * Adds `union all` set operator to the query.
-	 *
-	 * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all transaction ids from both online and in-store sales
-	 * await db.select({ transaction: onlineSales.transactionId })
-	 *   .from(onlineSales)
-	 *   .unionAll(
-	 *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
-	 *   );
-	 * // or
-	 * import { unionAll } from 'drizzle-orm/gel-core'
-	 *
-	 * await unionAll(
-	 *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
-	 *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
-	 * );
-	 * ```
-	 */
-	unionAll = this.createSetOperator('union', true);
-
-	/**
-	 * Adds `intersect` set operator to the query.
-	 *
-	 * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select course names that are offered in both departments A and B
-	 * await db.select({ courseName: depA.courseName })
-	 *   .from(depA)
-	 *   .intersect(
-	 *     db.select({ courseName: depB.courseName }).from(depB)
-	 *   );
-	 * // or
-	 * import { intersect } from 'drizzle-orm/gel-core'
-	 *
-	 * await intersect(
-	 *   db.select({ courseName: depA.courseName }).from(depA),
-	 *   db.select({ courseName: depB.courseName }).from(depB)
-	 * );
-	 * ```
-	 */
-	intersect = this.createSetOperator('intersect', false);
-
-	/**
-	 * Adds `intersect all` set operator to the query.
-	 *
-	 * Calling this method will retain only the rows that are present in both result sets including all duplicates.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all products and quantities that are ordered by both regular and VIP customers
-	 * await db.select({
-	 *   productId: regularCustomerOrders.productId,
-	 *   quantityOrdered: regularCustomerOrders.quantityOrdered
-	 * })
-	 * .from(regularCustomerOrders)
-	 * .intersectAll(
-	 *   db.select({
-	 *     productId: vipCustomerOrders.productId,
-	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
-	 *   })
-	 *   .from(vipCustomerOrders)
-	 * );
-	 * // or
-	 * import { intersectAll } from 'drizzle-orm/gel-core'
-	 *
-	 * await intersectAll(
-	 *   db.select({
-	 *     productId: regularCustomerOrders.productId,
-	 *     quantityOrdered: regularCustomerOrders.quantityOrdered
-	 *   })
-	 *   .from(regularCustomerOrders),
-	 *   db.select({
-	 *     productId: vipCustomerOrders.productId,
-	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
-	 *   })
-	 *   .from(vipCustomerOrders)
-	 * );
-	 * ```
-	 */
-	intersectAll = this.createSetOperator('intersect', true);
-
-	/**
-	 * Adds `except` set operator to the query.
-	 *
-	 * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all courses offered in department A but not in department B
-	 * await db.select({ courseName: depA.courseName })
-	 *   .from(depA)
-	 *   .except(
-	 *     db.select({ courseName: depB.courseName }).from(depB)
-	 *   );
-	 * // or
-	 * import { except } from 'drizzle-orm/gel-core'
-	 *
-	 * await except(
-	 *   db.select({ courseName: depA.courseName }).from(depA),
-	 *   db.select({ courseName: depB.courseName }).from(depB)
-	 * );
-	 * ```
-	 */
-	except = this.createSetOperator('except', false);
-
-	/**
-	 * Adds `except all` set operator to the query.
-	 *
-	 * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all products that are ordered by regular customers but not by VIP customers
-	 * await db.select({
-	 *   productId: regularCustomerOrders.productId,
-	 *   quantityOrdered: regularCustomerOrders.quantityOrdered,
-	 * })
-	 * .from(regularCustomerOrders)
-	 * .exceptAll(
-	 *   db.select({
-	 *     productId: vipCustomerOrders.productId,
-	 *     quantityOrdered: vipCustomerOrders.quantityOrdered,
-	 *   })
-	 *   .from(vipCustomerOrders)
-	 * );
-	 * // or
-	 * import { exceptAll } from 'drizzle-orm/gel-core'
-	 *
-	 * await exceptAll(
-	 *   db.select({
-	 *     productId: regularCustomerOrders.productId,
-	 *     quantityOrdered: regularCustomerOrders.quantityOrdered
-	 *   })
-	 *   .from(regularCustomerOrders),
-	 *   db.select({
-	 *     productId: vipCustomerOrders.productId,
-	 *     quantityOrdered: vipCustomerOrders.quantityOrdered
-	 *   })
-	 *   .from(vipCustomerOrders)
-	 * );
-	 * ```
-	 */
-	exceptAll = this.createSetOperator('except', true);
-
-	/** @internal */
-	addSetOperators(setOperators: GelSelectConfig['setOperators']): GelSelectWithout<
-		this,
-		TDynamic,
-		GelSetOperatorExcludedMethods,
-		true
-	> {
-		this.config.setOperators.push(...setOperators);
-		return this as any;
-	}
-
-	/**
-	 * Adds a `where` clause to the query.
-	 *
-	 * Calling this method will select only those rows that fulfill a specified condition.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
-	 *
-	 * @param where the `where` clause.
-	 *
-	 * @example
-	 * You can use conditional operators and `sql function` to filter the rows to be selected.
-	 *
-	 * ```ts
-	 * // Select all cars with green color
-	 * await db.select().from(cars).where(eq(cars.color, 'green'));
-	 * // or
-	 * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
-	 * ```
-	 *
-	 * You can logically combine conditional operators with `and()` and `or()` operators:
-	 *
-	 * ```ts
-	 * // Select all BMW cars with a green color
-	 * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
-	 *
-	 * // Select all cars with the green or blue color
-	 * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
-	 * ```
-	 */
-	where(
-		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
-	): GelSelectWithout<this, TDynamic, 'where'> {
-		if (typeof where === 'function') {
-			where = where(
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-		}
-		this.config.where = where;
-		return this as any;
-	}
-
-	/**
-	 * Adds a `having` clause to the query.
-	 *
-	 * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
-	 *
-	 * @param having the `having` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all brands with more than one car
-	 * await db.select({
-	 * 	brand: cars.brand,
-	 * 	count: sql<number>`cast(count(${cars.id}) as int)`,
-	 * })
-	 *   .from(cars)
-	 *   .groupBy(cars.brand)
-	 *   .having(({ count }) => gt(count, 1));
-	 * ```
-	 */
-	having(
-		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
-	): GelSelectWithout<this, TDynamic, 'having'> {
-		if (typeof having === 'function') {
-			having = having(
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-		}
-		this.config.having = having;
-		return this as any;
-	}
-
-	/**
-	 * Adds a `group by` clause to the query.
-	 *
-	 * Calling this method will group rows that have the same values into summary rows, often used for aggregation purposes.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Group and count people by their last names
-	 * await db.select({
-	 *    lastName: people.lastName,
-	 *    count: sql<number>`cast(count(*) as int)`
-	 * })
-	 *   .from(people)
-	 *   .groupBy(people.lastName);
-	 * ```
-	 */
-	groupBy(
-		builder: (aliases: this['_']['selection']) => ValueOrArray<GelColumn | SQL | SQL.Aliased>,
-	): GelSelectWithout<this, TDynamic, 'groupBy'>;
-	groupBy(...columns: (GelColumn | SQL | SQL.Aliased)[]): GelSelectWithout<this, TDynamic, 'groupBy'>;
-	groupBy(
-		...columns:
-			| [(aliases: this['_']['selection']) => ValueOrArray<GelColumn | SQL | SQL.Aliased>]
-			| (GelColumn | SQL | SQL.Aliased)[]
-	): GelSelectWithout<this, TDynamic, 'groupBy'> {
-		if (typeof columns[0] === 'function') {
-			const groupBy = columns[0](
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-			this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
-		} else {
-			this.config.groupBy = columns as (GelColumn | SQL | SQL.Aliased)[];
-		}
-		return this as any;
-	}
-
-	/**
-	 * Adds an `order by` clause to the query.
-	 *
-	 * Calling this method will sort the result-set in ascending or descending order. By default, the sort order is ascending.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#order-by}
-	 *
-	 * @example
-	 *
-	 * ```
-	 * // Select cars ordered by year
-	 * await db.select().from(cars).orderBy(cars.year);
-	 * ```
-	 *
-	 * You can specify whether results are in ascending or descending order with the `asc()` and `desc()` operators.
-	 *
-	 * ```ts
-	 * // Select cars ordered by year in descending order
-	 * await db.select().from(cars).orderBy(desc(cars.year));
-	 *
-	 * // Select cars ordered by year and price
-	 * await db.select().from(cars).orderBy(asc(cars.year), desc(cars.price));
-	 * ```
-	 */
-	orderBy(
-		builder: (aliases: this['_']['selection']) => ValueOrArray<GelColumn | SQL | SQL.Aliased>,
-	): GelSelectWithout<this, TDynamic, 'orderBy'>;
-	orderBy(...columns: (GelColumn | SQL | SQL.Aliased)[]): GelSelectWithout<this, TDynamic, 'orderBy'>;
-	orderBy(
-		...columns:
-			| [(aliases: this['_']['selection']) => ValueOrArray<GelColumn | SQL | SQL.Aliased>]
-			| (GelColumn | SQL | SQL.Aliased)[]
-	): GelSelectWithout<this, TDynamic, 'orderBy'> {
-		if (typeof columns[0] === 'function') {
-			const orderBy = columns[0](
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-
-			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
-
-			if (this.config.setOperators.length > 0) {
-				this.config.setOperators.at(-1)!.orderBy = orderByArray;
-			} else {
-				this.config.orderBy = orderByArray;
-			}
-		} else {
-			const orderByArray = columns as (GelColumn | SQL | SQL.Aliased)[];
-
-			if (this.config.setOperators.length > 0) {
-				this.config.setOperators.at(-1)!.orderBy = orderByArray;
-			} else {
-				this.config.orderBy = orderByArray;
-			}
-		}
-		return this as any;
-	}
-
-	/**
-	 * Adds a `limit` clause to the query.
-	 *
-	 * Calling this method will set the maximum number of rows that will be returned by this query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
-	 *
-	 * @param limit the `limit` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Get the first 10 people from this query.
-	 * await db.select().from(people).limit(10);
-	 * ```
-	 */
-	limit(limit: number | Placeholder): GelSelectWithout<this, TDynamic, 'limit'> {
-		if (this.config.setOperators.length > 0) {
-			this.config.setOperators.at(-1)!.limit = limit;
-		} else {
-			this.config.limit = limit;
-		}
-		return this as any;
-	}
-
-	/**
-	 * Adds an `offset` clause to the query.
-	 *
-	 * Calling this method will skip a number of rows when returning results from this query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
-	 *
-	 * @param offset the `offset` clause.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Get the 10th-20th people from this query.
-	 * await db.select().from(people).offset(10).limit(10);
-	 * ```
-	 */
-	offset(offset: number | Placeholder): GelSelectWithout<this, TDynamic, 'offset'> {
-		if (this.config.setOperators.length > 0) {
-			this.config.setOperators.at(-1)!.offset = offset;
-		} else {
-			this.config.offset = offset;
-		}
-		return this as any;
-	}
-
-	/**
-	 * Adds a `for` clause to the query.
-	 *
-	 * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
-	 *
-	 * See docs: {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE}
-	 *
-	 * @param strength the lock strength.
-	 * @param config the lock configuration.
-	 */
-	for(strength: LockStrength, config: LockConfig = {}): GelSelectWithout<this, TDynamic, 'for'> {
-		this.config.lockingClause = { strength, config };
-		return this as any;
-	}
-
-	/** @internal */
-	getSQL(): SQL {
-		return this.dialect.buildSelectQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	as<TAlias extends string>(
-		alias: TAlias,
-	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
-		const usedTables: string[] = [];
-		usedTables.push(...extractUsedTable(this.config.table));
-		if (this.config.joins) { for (const it of this.config.joins) usedTables.push(...extractUsedTable(it.table)); }
-
-		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),
-			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
-	}
-
-	/** @internal */
-	override getSelectedFields(): this['_']['selectedFields'] {
-		return new Proxy(
-			this.config.fields,
-			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as this['_']['selectedFields'];
-	}
-
-	$dynamic(): GelSelectDynamic<this> {
-		return this;
-	}
-}
-
-export interface GelSelectBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	GelSelectQueryBuilderBase<
-		GelSelectHKT,
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	QueryPromise<TResult>,
-	SQLWrapper
-{}
-
-export class GelSelectBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends GelSelectQueryBuilderBase<
-	GelSelectHKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> implements RunnableQuery<TResult, 'gel'>, SQLWrapper {
-	static override readonly [entityKind]: string = 'GelSelect';
-
-	/** @internal */
-	_prepare(name?: string): GelSelectPrepare<this> {
-		const { session, config, dialect, joinsNotNullableMap, cacheConfig, usedTables } = this;
-		if (!session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			const fieldsList = orderSelectedFields<GelColumn>(config.fields);
-			const query = session.prepareQuery<
-				PreparedQueryConfig & { execute: TResult }
-			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name, true, undefined, {
-				type: 'select',
-				tables: [...usedTables],
-			}, cacheConfig);
-			query.joinsNotNullableMap = joinsNotNullableMap;
-
-			return query;
-		});
-	}
-
-	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
-		this.cacheConfig = config === undefined
-			? { config: {}, enable: true, autoInvalidate: true }
-			: config === false
-			? { enable: false }
-			: { enable: true, autoInvalidate: true, ...config };
-		return this;
-	}
-
-	/**
-	 * Create a prepared statement for this query. This allows
-	 * the database to remember this query for the given session
-	 * and call it by name, rather than specifying the full query.
-	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
-	 */
-	prepare(name: string): GelSelectPrepare<this> {
-		return this._prepare(name);
-	}
-
-	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues);
-		});
-	};
-}
-
-applyMixins(GelSelectBase, [QueryPromise]);
-
-function createSetOperator(type: SetOperator, isAll: boolean): GelCreateSetOperatorFn {
-	return (leftSelect, rightSelect, ...restSelects) => {
-		const setOperators = [rightSelect, ...restSelects].map((select) => ({
-			type,
-			isAll,
-			rightSelect: select as AnyGelSelect,
-		}));
-
-		for (const setOperator of setOperators) {
-			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
-				throw new Error(
-					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
-				);
-			}
-		}
-
-		return (leftSelect as AnyGelSelect).addSetOperators(setOperators) as any;
-	};
-}
-
-const getGelSetOperators = () => ({
-	union,
-	unionAll,
-	intersect,
-	intersectAll,
-	except,
-	exceptAll,
-});
-
-/**
- * Adds `union` set operator to the query.
- *
- * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
- *
- * @example
- *
- * ```ts
- * // Select all unique names from customers and users tables
- * import { union } from 'drizzle-orm/Gel-core'
- *
- * await union(
- *   db.select({ name: users.name }).from(users),
- *   db.select({ name: customers.name }).from(customers)
- * );
- * // or
- * await db.select({ name: users.name })
- *   .from(users)
- *   .union(
- *     db.select({ name: customers.name }).from(customers)
- *   );
- * ```
- */
-export const union = createSetOperator('union', false);
-
-/**
- * Adds `union all` set operator to the query.
- *
- * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
- *
- * @example
- *
- * ```ts
- * // Select all transaction ids from both online and in-store sales
- * import { unionAll } from 'drizzle-orm/Gel-core'
- *
- * await unionAll(
- *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
- *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
- * );
- * // or
- * await db.select({ transaction: onlineSales.transactionId })
- *   .from(onlineSales)
- *   .unionAll(
- *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
- *   );
- * ```
- */
-export const unionAll = createSetOperator('union', true);
-
-/**
- * Adds `intersect` set operator to the query.
- *
- * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
- *
- * @example
- *
- * ```ts
- * // Select course names that are offered in both departments A and B
- * import { intersect } from 'drizzle-orm/Gel-core'
- *
- * await intersect(
- *   db.select({ courseName: depA.courseName }).from(depA),
- *   db.select({ courseName: depB.courseName }).from(depB)
- * );
- * // or
- * await db.select({ courseName: depA.courseName })
- *   .from(depA)
- *   .intersect(
- *     db.select({ courseName: depB.courseName }).from(depB)
- *   );
- * ```
- */
-export const intersect = createSetOperator('intersect', false);
-
-/**
- * Adds `intersect all` set operator to the query.
- *
- * Calling this method will retain only the rows that are present in both result sets including all duplicates.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
- *
- * @example
- *
- * ```ts
- * // Select all products and quantities that are ordered by both regular and VIP customers
- * import { intersectAll } from 'drizzle-orm/Gel-core'
- *
- * await intersectAll(
- *   db.select({
- *     productId: regularCustomerOrders.productId,
- *     quantityOrdered: regularCustomerOrders.quantityOrdered
- *   })
- *   .from(regularCustomerOrders),
- *   db.select({
- *     productId: vipCustomerOrders.productId,
- *     quantityOrdered: vipCustomerOrders.quantityOrdered
- *   })
- *   .from(vipCustomerOrders)
- * );
- * // or
- * await db.select({
- *   productId: regularCustomerOrders.productId,
- *   quantityOrdered: regularCustomerOrders.quantityOrdered
- * })
- * .from(regularCustomerOrders)
- * .intersectAll(
- *   db.select({
- *     productId: vipCustomerOrders.productId,
- *     quantityOrdered: vipCustomerOrders.quantityOrdered
- *   })
- *   .from(vipCustomerOrders)
- * );
- * ```
- */
-export const intersectAll = createSetOperator('intersect', true);
-
-/**
- * Adds `except` set operator to the query.
- *
- * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
- *
- * @example
- *
- * ```ts
- * // Select all courses offered in department A but not in department B
- * import { except } from 'drizzle-orm/Gel-core'
- *
- * await except(
- *   db.select({ courseName: depA.courseName }).from(depA),
- *   db.select({ courseName: depB.courseName }).from(depB)
- * );
- * // or
- * await db.select({ courseName: depA.courseName })
- *   .from(depA)
- *   .except(
- *     db.select({ courseName: depB.courseName }).from(depB)
- *   );
- * ```
- */
-export const except = createSetOperator('except', false);
-
-/**
- * Adds `except all` set operator to the query.
- *
- * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
- *
- * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
- *
- * @example
- *
- * ```ts
- * // Select all products that are ordered by regular customers but not by VIP customers
- * import { exceptAll } from 'drizzle-orm/Gel-core'
- *
- * await exceptAll(
- *   db.select({
- *     productId: regularCustomerOrders.productId,
- *     quantityOrdered: regularCustomerOrders.quantityOrdered
- *   })
- *   .from(regularCustomerOrders),
- *   db.select({
- *     productId: vipCustomerOrders.productId,
- *     quantityOrdered: vipCustomerOrders.quantityOrdered
- *   })
- *   .from(vipCustomerOrders)
- * );
- * // or
- * await db.select({
- *   productId: regularCustomerOrders.productId,
- *   quantityOrdered: regularCustomerOrders.quantityOrdered,
- * })
- * .from(regularCustomerOrders)
- * .exceptAll(
- *   db.select({
- *     productId: vipCustomerOrders.productId,
- *     quantityOrdered: vipCustomerOrders.quantityOrdered,
- *   })
- *   .from(vipCustomerOrders)
- * );
- * ```
- */
-export const exceptAll = createSetOperator('except', true);
diff --git a/drizzle-orm/src/gel-core/query-builders/select.types.ts b/drizzle-orm/src/gel-core/query-builders/select.types.ts
deleted file mode 100644
index 0a35c31829..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/select.types.ts
+++ /dev/null
@@ -1,420 +0,0 @@
-import type { GelColumn } from '~/gel-core/columns/index.ts';
-import type { GelTable, GelTableWithColumns } from '~/gel-core/table.ts';
-import type { GelViewBase } from '~/gel-core/view-base.ts';
-import type { GelViewWithSelection } from '~/gel-core/view.ts';
-import type {
-	SelectedFields as SelectedFieldsBase,
-	SelectedFieldsFlat as SelectedFieldsFlatBase,
-	SelectedFieldsOrdered as SelectedFieldsOrderedBase,
-} from '~/operations.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	AppendToNullabilityMap,
-	AppendToResult,
-	BuildSubquerySelection,
-	GetSelectTableName,
-	JoinNullability,
-	JoinType,
-	MapColumnsToTableAlias,
-	SelectMode,
-	SelectResult,
-	SetOperator,
-} from '~/query-builders/select.types.ts';
-import type { ColumnsSelection, Placeholder, SQL, SQLWrapper, View } from '~/sql/sql.ts';
-import type { Subquery } from '~/subquery.ts';
-import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { Assume, ValidateShape, ValueOrArray } from '~/utils.ts';
-import type { GelPreparedQuery, PreparedQueryConfig } from '../session.ts';
-import type { GelSelectBase, GelSelectQueryBuilderBase } from './select.ts';
-
-export interface GelSelectJoinConfig {
-	on: SQL | undefined;
-	table: GelTable | Subquery | GelViewBase | SQL;
-	alias: string | undefined;
-	joinType: JoinType;
-	lateral?: boolean;
-}
-
-export type BuildAliasTable<TTable extends GelTable | View, TAlias extends string> = TTable extends Table
-	? GelTableWithColumns<
-		UpdateTableConfig<TTable['_']['config'], {
-			name: TAlias;
-			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'gel'>;
-		}>
-	>
-	: TTable extends View ? GelViewWithSelection<
-			TAlias,
-			TTable['_']['existing'],
-			MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'gel'>
-		>
-	: never;
-
-export interface GelSelectConfig {
-	withList?: Subquery[];
-	// Either fields or fieldsFlat must be defined
-	fields: Record<string, unknown>;
-	fieldsFlat?: SelectedFieldsOrdered;
-	where?: SQL;
-	having?: SQL;
-	table: GelTable | Subquery | GelViewBase | SQL;
-	limit?: number | Placeholder;
-	offset?: number | Placeholder;
-	joins?: GelSelectJoinConfig[];
-	orderBy?: (GelColumn | SQL | SQL.Aliased)[];
-	groupBy?: (GelColumn | SQL | SQL.Aliased)[];
-	lockingClause?: {
-		strength: LockStrength;
-		config: LockConfig;
-	};
-	distinct?: boolean | {
-		on: (GelColumn | SQLWrapper)[];
-	};
-	setOperators: {
-		rightSelect: TypedQueryBuilder<any, any>;
-		type: SetOperator;
-		isAll: boolean;
-		orderBy?: (GelColumn | SQL | SQL.Aliased)[];
-		limit?: number | Placeholder;
-		offset?: number | Placeholder;
-	}[];
-}
-
-export type GelSelectJoin<
-	T extends AnyGelSelectQueryBuilder,
-	TDynamic extends boolean,
-	TJoinType extends JoinType,
-	TJoinedTable extends GelTable | Subquery | GelViewBase | SQL,
-	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-> = T extends any ? GelSelectWithout<
-		GelSelectKind<
-			T['_']['hkt'],
-			T['_']['tableName'],
-			AppendToResult<
-				T['_']['tableName'],
-				T['_']['selection'],
-				TJoinedName,
-				TJoinedTable extends Table ? TJoinedTable['_']['columns']
-					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
-					: never,
-				T['_']['selectMode']
-			>,
-			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
-			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
-			T['_']['dynamic'],
-			T['_']['excludedMethods']
-		>,
-		TDynamic,
-		T['_']['excludedMethods']
-	>
-	: never;
-
-export type GelSelectJoinFn<
-	T extends AnyGelSelectQueryBuilder,
-	TDynamic extends boolean,
-	TJoinType extends JoinType,
-	TIsLateral extends boolean,
-> = 'cross' extends TJoinType ? <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : GelTable | Subquery | GelViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(table: TJoinedTable) => GelSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>
-	: <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : GelTable | Subquery | GelViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TJoinedTable,
-		on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-	) => GelSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
-
-export type SelectedFieldsFlat = SelectedFieldsFlatBase<GelColumn>;
-
-export type SelectedFields = SelectedFieldsBase<GelColumn, GelTable>;
-
-export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<GelColumn>;
-
-export type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
-
-export type LockConfig =
-	& {
-		of?: ValueOrArray<GelTable>;
-	}
-	& ({
-		noWait: true;
-		skipLocked?: undefined;
-	} | {
-		noWait?: undefined;
-		skipLocked: true;
-	} | {
-		noWait?: undefined;
-		skipLocked?: undefined;
-	});
-
-export interface GelSelectHKTBase {
-	tableName: string | undefined;
-	selection: unknown;
-	selectMode: SelectMode;
-	nullabilityMap: unknown;
-	dynamic: boolean;
-	excludedMethods: string;
-	result: unknown;
-	selectedFields: unknown;
-	_type: unknown;
-}
-
-export type GelSelectKind<
-	T extends GelSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TDynamic extends boolean,
-	TExcludedMethods extends string,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> = (T & {
-	tableName: TTableName;
-	selection: TSelection;
-	selectMode: TSelectMode;
-	nullabilityMap: TNullabilityMap;
-	dynamic: TDynamic;
-	excludedMethods: TExcludedMethods;
-	result: TResult;
-	selectedFields: TSelectedFields;
-})['_type'];
-
-export interface GelSelectQueryBuilderHKT extends GelSelectHKTBase {
-	_type: GelSelectQueryBuilderBase<
-		GelSelectQueryBuilderHKT,
-		this['tableName'],
-		Assume<this['selection'], ColumnsSelection>,
-		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
-		this['dynamic'],
-		this['excludedMethods'],
-		Assume<this['result'], any[]>,
-		Assume<this['selectedFields'], ColumnsSelection>
-	>;
-}
-
-export interface GelSelectHKT extends GelSelectHKTBase {
-	_type: GelSelectBase<
-		this['tableName'],
-		Assume<this['selection'], ColumnsSelection>,
-		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
-		this['dynamic'],
-		this['excludedMethods'],
-		Assume<this['result'], any[]>,
-		Assume<this['selectedFields'], ColumnsSelection>
-	>;
-}
-
-export type CreateGelSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-> = TBuilderMode extends 'db' ? GelSelectBase<TTableName, TSelection, TSelectMode>
-	: GelSelectQueryBuilderBase<GelSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
-
-export type GelSetOperatorExcludedMethods =
-	| 'leftJoin'
-	| 'rightJoin'
-	| 'innerJoin'
-	| 'fullJoin'
-	| 'where'
-	| 'having'
-	| 'groupBy'
-	| 'for';
-
-export type GelSelectWithout<
-	T extends AnyGelSelectQueryBuilder,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-	TResetExcluded extends boolean = false,
-> = TDynamic extends true ? T : Omit<
-	GelSelectKind<
-		T['_']['hkt'],
-		T['_']['tableName'],
-		T['_']['selection'],
-		T['_']['selectMode'],
-		T['_']['nullabilityMap'],
-		TDynamic,
-		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
-		T['_']['result'],
-		T['_']['selectedFields']
-	>,
-	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
->;
-
-export type GelSelectPrepare<T extends AnyGelSelect> = GelPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['result'];
-	}
->;
-
-export type GelSelectDynamic<T extends AnyGelSelectQueryBuilder> = GelSelectKind<
-	T['_']['hkt'],
-	T['_']['tableName'],
-	T['_']['selection'],
-	T['_']['selectMode'],
-	T['_']['nullabilityMap'],
-	true,
-	never,
-	T['_']['result'],
-	T['_']['selectedFields']
->;
-
-export type GelSelectQueryBuilder<
-	THKT extends GelSelectHKTBase = GelSelectQueryBuilderHKT,
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = ColumnsSelection,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-	TResult extends any[] = unknown[],
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = GelSelectQueryBuilderBase<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	true,
-	never,
-	TResult,
-	TSelectedFields
->;
-
-export type AnyGelSelectQueryBuilder = GelSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
-
-export type AnyGelSetOperatorInterface = GelSetOperatorInterface<any, any, any, any, any, any, any, any>;
-
-export interface GelSetOperatorInterface<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> {
-	_: {
-		readonly hkt: GelSelectHKT;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-}
-
-export type GelSetOperatorWithResult<TResult extends any[]> = GelSetOperatorInterface<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	TResult,
-	any
->;
-
-export type GelSelect<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = GelSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnyGelSelect = GelSelectBase<any, any, any, any, any, any, any, any>;
-
-export type GelSetOperator<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = GelSelectBase<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	true,
-	GelSetOperatorExcludedMethods
->;
-
-export type SetOperatorRightSelect<
-	TValue extends GelSetOperatorWithResult<TResult>,
-	TResult extends any[],
-> = TValue extends GelSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
-		TValueResult[number],
-		TResult[number],
-		TypedQueryBuilder<any, TValueResult>
-	>
-	: TValue;
-
-export type SetOperatorRestSelect<
-	TValue extends readonly GelSetOperatorWithResult<TResult>[],
-	TResult extends any[],
-> = TValue extends [infer First, ...infer Rest]
-	? First extends GelSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
-		? Rest extends AnyGelSetOperatorInterface[] ? [
-				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
-				...SetOperatorRestSelect<Rest, TResult>,
-			]
-		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-	: never
-	: TValue;
-
-export type GelCreateSetOperatorFn = <
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TValue extends GelSetOperatorWithResult<TResult>,
-	TRest extends GelSetOperatorWithResult<TResult>[],
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
->(
-	leftSelect: GelSetOperatorInterface<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TResult>,
-	...restSelects: SetOperatorRestSelect<TRest, TResult>
-) => GelSelectWithout<
-	GelSelectBase<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	false,
-	GelSetOperatorExcludedMethods,
-	true
->;
-
-export type GetGelSetOperators = {
-	union: GelCreateSetOperatorFn;
-	intersect: GelCreateSetOperatorFn;
-	except: GelCreateSetOperatorFn;
-	unionAll: GelCreateSetOperatorFn;
-	intersectAll: GelCreateSetOperatorFn;
-	exceptAll: GelCreateSetOperatorFn;
-};
diff --git a/drizzle-orm/src/gel-core/query-builders/update.ts b/drizzle-orm/src/gel-core/query-builders/update.ts
deleted file mode 100644
index 3cd8d98b24..0000000000
--- a/drizzle-orm/src/gel-core/query-builders/update.ts
+++ /dev/null
@@ -1,561 +0,0 @@
-import type { GetColumnData } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type {
-	GelPreparedQuery,
-	GelQueryResultHKT,
-	GelQueryResultKind,
-	GelSession,
-	PreparedQueryConfig,
-} from '~/gel-core/session.ts';
-import { GelTable } from '~/gel-core/table.ts';
-import type {
-	AppendToNullabilityMap,
-	AppendToResult,
-	GetSelectTableName,
-	GetSelectTableSelection,
-	JoinNullability,
-	JoinType,
-	SelectMode,
-	SelectResult,
-} from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type Query, SQL, type SQLWrapper } from '~/sql/sql.ts';
-import { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
-import {
-	type Assume,
-	getTableLikeName,
-	mapUpdateSet,
-	type NeonAuthToken,
-	orderSelectedFields,
-	type UpdateSet,
-} from '~/utils.ts';
-import { ViewBaseConfig } from '~/view-common.ts';
-import type { GelColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
-import type { GelViewBase } from '../view-base.ts';
-import type { GelSelectJoinConfig, SelectedFields, SelectedFieldsOrdered } from './select.types.ts';
-
-export interface GelUpdateConfig {
-	where?: SQL | undefined;
-	set: UpdateSet;
-	table: GelTable;
-	from?: GelTable | Subquery | GelViewBase | SQL;
-	joins: GelSelectJoinConfig[];
-	returning?: SelectedFieldsOrdered;
-	withList?: Subquery[];
-}
-
-export type GelUpdateSetSource<TTable extends GelTable> =
-	& {
-		[Key in keyof TTable['$inferInsert']]?:
-			| GetColumnData<TTable['_']['columns'][Key]>
-			| SQL
-			| GelColumn;
-	}
-	& {};
-
-export class GelUpdateBuilder<TTable extends GelTable, TQueryResult extends GelQueryResultHKT> {
-	static readonly [entityKind]: string = 'GelUpdateBuilder';
-
-	declare readonly _: {
-		readonly table: TTable;
-	};
-
-	constructor(
-		private table: TTable,
-		private session: GelSession,
-		private dialect: GelDialect,
-		private withList?: Subquery[],
-	) {}
-
-	private authToken?: NeonAuthToken;
-	setToken(token: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	set(
-		values: GelUpdateSetSource<TTable>,
-	): GelUpdateWithout<GelUpdateBase<TTable, TQueryResult>, false, 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'> {
-		return new GelUpdateBase<TTable, TQueryResult>(
-			this.table,
-			mapUpdateSet(this.table, values),
-			this.session,
-			this.dialect,
-			this.withList,
-		);
-	}
-}
-
-export type GelUpdateWithout<
-	T extends AnyGelUpdate,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-> = TDynamic extends true ? T : Omit<
-	GelUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['from'],
-		T['_']['returning'],
-		T['_']['nullabilityMap'],
-		T['_']['joins'],
-		TDynamic,
-		T['_']['excludedMethods'] | K
-	>,
-	T['_']['excludedMethods'] | K
->;
-
-export type GelUpdateWithJoins<
-	T extends AnyGelUpdate,
-	TDynamic extends boolean,
-	TFrom extends GelTable | Subquery | GelViewBase | SQL,
-> = TDynamic extends true ? T : Omit<
-	GelUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		TFrom,
-		T['_']['returning'],
-		AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TFrom>, 'inner'>,
-		[...T['_']['joins'], {
-			name: GetSelectTableName<TFrom>;
-			joinType: 'inner';
-			table: TFrom;
-		}],
-		TDynamic,
-		Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
-	>,
-	Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
->;
-
-export type GelUpdateJoinFn<
-	T extends AnyGelUpdate,
-	TDynamic extends boolean,
-	TJoinType extends JoinType,
-> = <
-	TJoinedTable extends GelTable | Subquery | GelViewBase | SQL,
->(
-	table: TJoinedTable,
-	on:
-		| (
-			(
-				updateTable: T['_']['table']['_']['columns'],
-				from: T['_']['from'] extends GelTable ? T['_']['from']['_']['columns']
-					: T['_']['from'] extends Subquery | GelViewBase ? T['_']['from']['_']['selectedFields']
-					: never,
-			) => SQL | undefined
-		)
-		| SQL
-		| undefined,
-) => GelUpdateJoin<T, TDynamic, TJoinType, TJoinedTable>;
-
-export type GelUpdateJoin<
-	T extends AnyGelUpdate,
-	TDynamic extends boolean,
-	TJoinType extends JoinType,
-	TJoinedTable extends GelTable | Subquery | GelViewBase | SQL,
-> = TDynamic extends true ? T : GelUpdateBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['from'],
-	T['_']['returning'],
-	AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>,
-	[...T['_']['joins'], {
-		name: GetSelectTableName<TJoinedTable>;
-		joinType: TJoinType;
-		table: TJoinedTable;
-	}],
-	TDynamic,
-	T['_']['excludedMethods']
->;
-
-type Join = {
-	name: string | undefined;
-	joinType: JoinType;
-	table: GelTable | Subquery | GelViewBase | SQL;
-};
-
-type AccumulateToResult<
-	T extends AnyGelUpdate,
-	TSelectMode extends SelectMode,
-	TJoins extends Join[],
-	TSelectedFields extends ColumnsSelection,
-> = TJoins extends [infer TJoin extends Join, ...infer TRest extends Join[]] ? AccumulateToResult<
-		T,
-		TSelectMode extends 'partial' ? TSelectMode : 'multiple',
-		TRest,
-		AppendToResult<
-			T['_']['table']['_']['name'],
-			TSelectedFields,
-			TJoin['name'],
-			TJoin['table'] extends Table ? TJoin['table']['_']['columns']
-				: TJoin['table'] extends Subquery ? Assume<TJoin['table']['_']['selectedFields'], SelectedFields>
-				: never,
-			TSelectMode extends 'partial' ? TSelectMode : 'multiple'
-		>
-	>
-	: TSelectedFields;
-
-export type GelUpdateReturningAll<T extends AnyGelUpdate, TDynamic extends boolean> = GelUpdateWithout<
-	GelUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['from'],
-		SelectResult<
-			AccumulateToResult<
-				T,
-				'single',
-				T['_']['joins'],
-				GetSelectTableSelection<T['_']['table']>
-			>,
-			'partial',
-			T['_']['nullabilityMap']
-		>,
-		T['_']['nullabilityMap'],
-		T['_']['joins'],
-		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
-
-export type GelUpdateReturning<
-	T extends AnyGelUpdate,
-	TDynamic extends boolean,
-	TSelectedFields extends SelectedFields,
-> = GelUpdateWithout<
-	GelUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['from'],
-		SelectResult<
-			AccumulateToResult<
-				T,
-				'partial',
-				T['_']['joins'],
-				TSelectedFields
-			>,
-			'partial',
-			T['_']['nullabilityMap']
-		>,
-		T['_']['nullabilityMap'],
-		T['_']['joins'],
-		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
-
-export type GelUpdatePrepare<T extends AnyGelUpdate> = GelPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? GelQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
-
-export type GelUpdateDynamic<T extends AnyGelUpdate> = GelUpdate<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['from'],
-	T['_']['returning'],
-	T['_']['nullabilityMap']
->;
-
-export type GelUpdate<
-	TTable extends GelTable = GelTable,
-	TQueryResult extends GelQueryResultHKT = GelQueryResultHKT,
-	TFrom extends GelTable | Subquery | GelViewBase | SQL | undefined = undefined,
-	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
-	TJoins extends Join[] = [],
-> = GelUpdateBase<TTable, TQueryResult, TFrom, TReturning, TNullabilityMap, TJoins, true, never>;
-
-export type AnyGelUpdate = GelUpdateBase<any, any, any, any, any, any, any, any>;
-
-export interface GelUpdateBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TFrom extends GelTable | Subquery | GelViewBase | SQL | undefined = undefined,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
-	TJoins extends Join[] = [],
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-> extends
-	QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-	SQLWrapper
-{
-	readonly _: {
-		readonly dialect: 'gel';
-		readonly table: TTable;
-		readonly joins: TJoins;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly queryResult: TQueryResult;
-		readonly from: TFrom;
-		readonly returning: TReturning;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[];
-	};
-}
-
-export class GelUpdateBase<
-	TTable extends GelTable,
-	TQueryResult extends GelQueryResultHKT,
-	TFrom extends GelTable | Subquery | GelViewBase | SQL | undefined = undefined,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TJoins extends Join[] = [],
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		RunnableQuery<TReturning extends undefined ? GelQueryResultKind<TQueryResult, never> : TReturning[], 'gel'>,
-		SQLWrapper
-{
-	static override readonly [entityKind]: string = 'GelUpdate';
-
-	private config: GelUpdateConfig;
-	private tableName: string | undefined;
-	private joinsNotNullableMap: Record<string, boolean>;
-
-	constructor(
-		table: TTable,
-		set: UpdateSet,
-		private session: GelSession,
-		private dialect: GelDialect,
-		withList?: Subquery[],
-	) {
-		super();
-		this.config = { set, table, withList, joins: [] };
-		this.tableName = getTableLikeName(table);
-		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
-	}
-
-	from<TFrom extends GelTable | Subquery | GelViewBase | SQL>(
-		source: TFrom,
-	): GelUpdateWithJoins<this, TDynamic, TFrom> {
-		const tableName = getTableLikeName(source);
-		if (typeof tableName === 'string') {
-			this.joinsNotNullableMap[tableName] = true;
-		}
-		this.config.from = source;
-		return this as any;
-	}
-
-	private getTableLikeFields(table: GelTable | Subquery | GelViewBase): Record<string, unknown> {
-		if (is(table, GelTable)) {
-			return table[Table.Symbol.Columns];
-		} else if (is(table, Subquery)) {
-			return table._.selectedFields;
-		}
-		return table[ViewBaseConfig].selectedFields;
-	}
-
-	private createJoin<TJoinType extends JoinType>(
-		joinType: TJoinType,
-	): GelUpdateJoinFn<this, TDynamic, TJoinType> {
-		return ((
-			table: GelTable | Subquery | GelViewBase | SQL,
-			on: ((updateTable: TTable, from: TFrom) => SQL | undefined) | SQL | undefined,
-		) => {
-			const tableName = getTableLikeName(table);
-
-			if (typeof tableName === 'string' && this.config.joins.some((join) => join.alias === tableName)) {
-				throw new Error(`Alias "${tableName}" is already used in this query`);
-			}
-
-			if (typeof on === 'function') {
-				const from = this.config.from && !is(this.config.from, SQL)
-					? this.getTableLikeFields(this.config.from)
-					: undefined;
-				on = on(
-					new Proxy(
-						this.config.table[Table.Symbol.Columns],
-						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
-					) as any,
-					from && new Proxy(
-						from,
-						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
-					) as any,
-				);
-			}
-
-			this.config.joins.push({ on, table, joinType, alias: tableName });
-
-			if (typeof tableName === 'string') {
-				switch (joinType) {
-					case 'left': {
-						this.joinsNotNullableMap[tableName] = false;
-						break;
-					}
-					case 'right': {
-						this.joinsNotNullableMap = Object.fromEntries(
-							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
-						);
-						this.joinsNotNullableMap[tableName] = true;
-						break;
-					}
-					case 'inner': {
-						this.joinsNotNullableMap[tableName] = true;
-						break;
-					}
-					case 'full': {
-						this.joinsNotNullableMap = Object.fromEntries(
-							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
-						);
-						this.joinsNotNullableMap[tableName] = false;
-						break;
-					}
-				}
-			}
-
-			return this as any;
-		}) as any;
-	}
-
-	leftJoin = this.createJoin('left');
-
-	rightJoin = this.createJoin('right');
-
-	innerJoin = this.createJoin('inner');
-
-	fullJoin = this.createJoin('full');
-
-	/**
-	 * Adds a 'where' clause to the query.
-	 *
-	 * Calling this method will update only those rows that fulfill a specified condition.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update}
-	 *
-	 * @param where the 'where' clause.
-	 *
-	 * @example
-	 * You can use conditional operators and `sql function` to filter the rows to be updated.
-	 *
-	 * ```ts
-	 * // Update all cars with green color
-	 * await db.update(cars).set({ color: 'red' })
-	 *   .where(eq(cars.color, 'green'));
-	 * // or
-	 * await db.update(cars).set({ color: 'red' })
-	 *   .where(sql`${cars.color} = 'green'`)
-	 * ```
-	 *
-	 * You can logically combine conditional operators with `and()` and `or()` operators:
-	 *
-	 * ```ts
-	 * // Update all BMW cars with a green color
-	 * await db.update(cars).set({ color: 'red' })
-	 *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
-	 *
-	 * // Update all cars with the green or blue color
-	 * await db.update(cars).set({ color: 'red' })
-	 *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
-	 * ```
-	 */
-	where(where: SQL | undefined): GelUpdateWithout<this, TDynamic, 'where'> {
-		this.config.where = where;
-		return this as any;
-	}
-
-	/**
-	 * Adds a `returning` clause to the query.
-	 *
-	 * Calling this method will return the specified fields of the updated rows. If no fields are specified, all fields will be returned.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update#update-with-returning}
-	 *
-	 * @example
-	 * ```ts
-	 * // Update all cars with the green color and return all fields
-	 * const updatedCars: Car[] = await db.update(cars)
-	 *   .set({ color: 'red' })
-	 *   .where(eq(cars.color, 'green'))
-	 *   .returning();
-	 *
-	 * // Update all cars with the green color and return only their id and brand fields
-	 * const updatedCarsIdsAndBrands: { id: number, brand: string }[] = await db.update(cars)
-	 *   .set({ color: 'red' })
-	 *   .where(eq(cars.color, 'green'))
-	 *   .returning({ id: cars.id, brand: cars.brand });
-	 * ```
-	 */
-	returning(): GelUpdateReturningAll<this, TDynamic>;
-	returning<TSelectedFields extends SelectedFields>(
-		fields: TSelectedFields,
-	): GelUpdateReturning<this, TDynamic, TSelectedFields>;
-	returning(
-		fields?: SelectedFields,
-	): GelUpdateWithout<AnyGelUpdate, TDynamic, 'returning'> {
-		if (!fields) {
-			fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);
-
-			if (this.config.from) {
-				const tableName = getTableLikeName(this.config.from);
-
-				if (typeof tableName === 'string' && this.config.from && !is(this.config.from, SQL)) {
-					const fromFields = this.getTableLikeFields(this.config.from);
-					fields[tableName] = fromFields as any;
-				}
-
-				for (const join of this.config.joins) {
-					const tableName = getTableLikeName(join.table);
-
-					if (typeof tableName === 'string' && !is(join.table, SQL)) {
-						const fromFields = this.getTableLikeFields(join.table);
-						fields[tableName] = fromFields as any;
-					}
-				}
-			}
-		}
-
-		this.config.returning = orderSelectedFields<GelColumn>(fields);
-		return this as any;
-	}
-
-	/** @internal */
-	getSQL(): SQL {
-		return this.dialect.buildUpdateQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): GelUpdatePrepare<this> {
-		const query = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: TReturning[] }
-		>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-			type: 'update',
-			tables: extractUsedTable(this.config.table),
-		});
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query;
-	}
-
-	prepare(name: string): GelUpdatePrepare<this> {
-		return this._prepare(name);
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return this._prepare().execute(placeholderValues);
-	};
-
-	$dynamic(): GelUpdateDynamic<this> {
-		return this as any;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/roles.ts b/drizzle-orm/src/gel-core/roles.ts
deleted file mode 100644
index 32aa3f1977..0000000000
--- a/drizzle-orm/src/gel-core/roles.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { entityKind } from '~/entity.ts';
-
-export interface GelRoleConfig {
-	createDb?: boolean;
-	createRole?: boolean;
-	inherit?: boolean;
-}
-
-export class GelRole implements GelRoleConfig {
-	static readonly [entityKind]: string = 'GelRole';
-
-	/** @internal */
-	_existing?: boolean;
-
-	/** @internal */
-	readonly createDb: GelRoleConfig['createDb'];
-	/** @internal */
-	readonly createRole: GelRoleConfig['createRole'];
-	/** @internal */
-	readonly inherit: GelRoleConfig['inherit'];
-
-	constructor(
-		readonly name: string,
-		config?: GelRoleConfig,
-	) {
-		if (config) {
-			this.createDb = config.createDb;
-			this.createRole = config.createRole;
-			this.inherit = config.inherit;
-		}
-	}
-
-	existing(): this {
-		this._existing = true;
-		return this;
-	}
-}
-
-export function gelRole(name: string, config?: GelRoleConfig) {
-	return new GelRole(name, config);
-}
diff --git a/drizzle-orm/src/gel-core/schema.ts b/drizzle-orm/src/gel-core/schema.ts
deleted file mode 100644
index 9753793b90..0000000000
--- a/drizzle-orm/src/gel-core/schema.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { entityKind, is } from '~/entity.ts';
-import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import type { gelSequence } from './sequence.ts';
-import { gelSequenceWithSchema } from './sequence.ts';
-import { type GelTableFn, gelTableWithSchema } from './table.ts';
-// import type { gelMaterializedView, gelView } from './view.ts';
-// import { gelMaterializedViewWithSchema, gelViewWithSchema } from './view.ts';
-
-export class GelSchema<TName extends string = string> implements SQLWrapper {
-	static readonly [entityKind]: string = 'GelSchema';
-	constructor(
-		public readonly schemaName: TName,
-	) {}
-
-	table: GelTableFn<TName> = ((name, columns, extraConfig) => {
-		return gelTableWithSchema(name, columns, extraConfig, this.schemaName);
-	});
-
-	// view = ((name, columns) => {
-	// 	return gelViewWithSchema(name, columns, this.schemaName);
-	// }) as typeof gelView;
-
-	// materializedView = ((name, columns) => {
-	// 	return gelMaterializedViewWithSchema(name, columns, this.schemaName);
-	// }) as typeof gelMaterializedView;
-
-	// enum: typeof gelEnum = ((name, values) => {
-	// 	return gelEnumWithSchema(name, values, this.schemaName);
-	// });
-
-	sequence: typeof gelSequence = ((name, options) => {
-		return gelSequenceWithSchema(name, options, this.schemaName);
-	});
-
-	getSQL(): SQL {
-		return new SQL([sql.identifier(this.schemaName)]);
-	}
-
-	shouldOmitSQLParens(): boolean {
-		return true;
-	}
-}
-
-export function isGelSchema(obj: unknown): obj is GelSchema {
-	return is(obj, GelSchema);
-}
-
-export function gelSchema<T extends string>(name: T) {
-	if (name === 'public') {
-		throw new Error(
-			`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use GelTable() instead of creating a schema`,
-		);
-	}
-
-	return new GelSchema(name);
-}
diff --git a/drizzle-orm/src/gel-core/sequence.ts b/drizzle-orm/src/gel-core/sequence.ts
deleted file mode 100644
index 4f16f88a13..0000000000
--- a/drizzle-orm/src/gel-core/sequence.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { entityKind, is } from '~/entity.ts';
-
-export type GelSequenceOptions = {
-	increment?: number | string;
-	minValue?: number | string;
-	maxValue?: number | string;
-	startWith?: number | string;
-	cache?: number | string;
-	cycle?: boolean;
-};
-
-export class GelSequence {
-	static readonly [entityKind]: string = 'GelSequence';
-
-	constructor(
-		public readonly seqName: string | undefined,
-		public readonly seqOptions: GelSequenceOptions | undefined,
-		public readonly schema: string | undefined,
-	) {
-	}
-}
-
-export function gelSequence(
-	name: string,
-	options?: GelSequenceOptions,
-): GelSequence {
-	return gelSequenceWithSchema(name, options, undefined);
-}
-
-/** @internal */
-export function gelSequenceWithSchema(
-	name: string,
-	options?: GelSequenceOptions,
-	schema?: string,
-): GelSequence {
-	return new GelSequence(name, options, schema);
-}
-
-export function isGelSequence(obj: unknown): obj is GelSequence {
-	return is(obj, GelSequence);
-}
diff --git a/drizzle-orm/src/gel-core/session.ts b/drizzle-orm/src/gel-core/session.ts
deleted file mode 100644
index 4057e9478b..0000000000
--- a/drizzle-orm/src/gel-core/session.ts
+++ /dev/null
@@ -1,248 +0,0 @@
-import { type Cache, hashQuery, NoopCache } from '~/cache/core/cache.ts';
-import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind, is } from '~/entity.ts';
-import { TransactionRollbackError } from '~/errors.ts';
-import { DrizzleQueryError } from '~/errors/index.ts';
-import type { TablesRelationalConfig } from '~/relations.ts';
-import type { PreparedQuery } from '~/session.ts';
-import type { Query, SQL } from '~/sql/index.ts';
-import { tracer } from '~/tracing.ts';
-import type { NeonAuthToken } from '~/utils.ts';
-import { GelDatabase } from './db.ts';
-import type { GelDialect } from './dialect.ts';
-import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
-
-export interface PreparedQueryConfig {
-	execute: unknown;
-	all: unknown;
-	values: unknown;
-}
-
-export abstract class GelPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
-	constructor(
-		protected query: Query,
-		private cache?: Cache,
-		// per query related metadata
-		private queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		// config that was passed through $withCache
-		private cacheConfig?: WithCacheConfig,
-	) {
-		// it means that no $withCache options were passed and it should be just enabled
-		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
-			this.cacheConfig = { enable: true, autoInvalidate: true };
-		}
-		if (!this.cacheConfig?.enable) {
-			this.cacheConfig = undefined;
-		}
-	}
-
-	/** @internal */
-	protected async queryWithCache<T>(
-		queryString: string,
-		params: any[],
-		query: () => Promise<T>,
-	): Promise<T> {
-		if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any mutations, if globally is false
-		if (this.cacheConfig && !this.cacheConfig.enable) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
-		if (
-			(
-				this.queryMetadata.type === 'insert' || this.queryMetadata.type === 'update'
-				|| this.queryMetadata.type === 'delete'
-			) && this.queryMetadata.tables.length > 0
-		) {
-			try {
-				const [res] = await Promise.all([
-					query(),
-					this.cache.onMutate({ tables: this.queryMetadata.tables }),
-				]);
-				return res;
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any reads if globally disabled
-		if (!this.cacheConfig) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		if (this.queryMetadata.type === 'select') {
-			const fromCache = await this.cache.get(
-				this.cacheConfig.tag ?? await hashQuery(queryString, params),
-				this.queryMetadata.tables,
-				this.cacheConfig.tag !== undefined,
-				this.cacheConfig.autoInvalidate,
-			);
-			if (fromCache === undefined) {
-				let result;
-				try {
-					result = await query();
-				} catch (e) {
-					throw new DrizzleQueryError(queryString, params, e as Error);
-				}
-
-				// put actual key
-				await this.cache.put(
-					this.cacheConfig.tag ?? await hashQuery(queryString, params),
-					result,
-					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
-					this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
-					this.cacheConfig.tag !== undefined,
-					this.cacheConfig.config,
-				);
-				// put flag if we should invalidate or not
-				return result;
-			}
-
-			return fromCache as unknown as T;
-		}
-		try {
-			return await query();
-		} catch (e) {
-			throw new DrizzleQueryError(queryString, params, e as Error);
-		}
-	}
-
-	protected authToken?: NeonAuthToken;
-
-	getQuery(): Query {
-		return this.query;
-	}
-
-	mapResult(response: unknown, _isFromBatch?: boolean): unknown {
-		return response;
-	}
-
-	static readonly [entityKind]: string = 'GelPreparedQuery';
-
-	/** @internal */
-	joinsNotNullableMap?: Record<string, boolean>;
-
-	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-
-	/** @internal */
-	abstract all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;
-
-	/** @internal */
-	abstract isResponseInArrayMode(): boolean;
-}
-
-export abstract class GelSession<
-	TQueryResult extends GelQueryResultHKT = any, // TO
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> {
-	static readonly [entityKind]: string = 'GelSession';
-
-	constructor(protected dialect: GelDialect) {}
-
-	abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute'],
-		queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		},
-		cacheConfig?: WithCacheConfig,
-	): GelPreparedQuery<T>;
-
-	execute<T>(query: SQL): Promise<T> {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
-				return this.prepareQuery<PreparedQueryConfig & { execute: T }>(
-					this.dialect.sqlToQuery(query),
-					undefined,
-					undefined,
-					false,
-				);
-			});
-
-			return prepared.execute(undefined);
-		});
-	}
-
-	all<T = unknown>(query: SQL): Promise<T[]> {
-		return this.prepareQuery<PreparedQueryConfig & { all: T[] }>(
-			this.dialect.sqlToQuery(query),
-			undefined,
-			undefined,
-			false,
-		).all();
-	}
-
-	async count(sql: SQL): Promise<number> {
-		const res = await this.execute<[{ count: string }]>(sql);
-
-		return Number(
-			res[0]['count'],
-		);
-	}
-
-	abstract transaction<T>(
-		transaction: (tx: GelTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T>;
-}
-
-export abstract class GelTransaction<
-	TQueryResult extends GelQueryResultHKT,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends GelDatabase<TQueryResult, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'GelTransaction';
-
-	constructor(
-		dialect: GelDialect,
-		session: GelSession<any, any, any>,
-		protected schema: {
-			fullSchema: Record<string, unknown>;
-			schema: TSchema;
-			tableNamesMap: Record<string, string>;
-		} | undefined,
-	) {
-		super(dialect, session, schema);
-	}
-
-	rollback(): never {
-		throw new TransactionRollbackError();
-	}
-
-	abstract override transaction<T>(
-		transaction: (tx: GelTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T>;
-}
-
-export interface GelQueryResultHKT {
-	readonly $brand: 'GelQueryResultHKT';
-	readonly row: unknown;
-	readonly type: unknown;
-}
-
-export type GelQueryResultKind<TKind extends GelQueryResultHKT, TRow> = (TKind & {
-	readonly row: TRow;
-})['type'];
diff --git a/drizzle-orm/src/gel-core/subquery.ts b/drizzle-orm/src/gel-core/subquery.ts
deleted file mode 100644
index e2cf0de7ce..0000000000
--- a/drizzle-orm/src/gel-core/subquery.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
-import type { ColumnsSelection } from '~/sql/sql.ts';
-import type { Subquery, WithSubquery } from '~/subquery.ts';
-
-export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
-	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'gel'>>
-	& AddAliasToSelection<TSelection, TAlias, 'gel'>;
-
-export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
-	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'gel'>>
-	& AddAliasToSelection<TSelection, TAlias, 'gel'>;
diff --git a/drizzle-orm/src/gel-core/table.ts b/drizzle-orm/src/gel-core/table.ts
deleted file mode 100644
index c1d3478dd6..0000000000
--- a/drizzle-orm/src/gel-core/table.ts
+++ /dev/null
@@ -1,257 +0,0 @@
-import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts';
-import { entityKind } from '~/entity.ts';
-import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
-import type { CheckBuilder } from './checks.ts';
-import { type GelColumnsBuilders, getGelColumnBuilders } from './columns/all.ts';
-import type { GelColumn, GelColumnBuilder, GelColumnBuilderBase, GelExtraConfigColumn } from './columns/common.ts';
-import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
-import type { AnyIndexBuilder } from './indexes.ts';
-import type { GelPolicy } from './policies.ts';
-import type { PrimaryKeyBuilder } from './primary-keys.ts';
-import type { UniqueConstraintBuilder } from './unique-constraint.ts';
-
-export type GelTableExtraConfigValue =
-	| AnyIndexBuilder
-	| CheckBuilder
-	| ForeignKeyBuilder
-	| PrimaryKeyBuilder
-	| UniqueConstraintBuilder
-	| GelPolicy;
-
-export type GelTableExtraConfig = Record<
-	string,
-	GelTableExtraConfigValue
->;
-
-export type TableConfig = TableConfigBase<GelColumn>;
-
-/** @internal */
-export const InlineForeignKeys = Symbol.for('drizzle:GelInlineForeignKeys');
-/** @internal */
-export const EnableRLS = Symbol.for('drizzle:EnableRLS');
-
-export class GelTable<T extends TableConfig = TableConfig> extends Table<T> {
-	static override readonly [entityKind]: string = 'GelTable';
-
-	/** @internal */
-	static override readonly Symbol = Object.assign({}, Table.Symbol, {
-		InlineForeignKeys: InlineForeignKeys as typeof InlineForeignKeys,
-		EnableRLS: EnableRLS as typeof EnableRLS,
-	});
-
-	/**@internal */
-	[InlineForeignKeys]: ForeignKey[] = [];
-
-	/** @internal */
-	[EnableRLS]: boolean = false;
-
-	/** @internal */
-	override [Table.Symbol.ExtraConfigBuilder]: ((self: Record<string, GelColumn>) => GelTableExtraConfig) | undefined =
-		undefined;
-
-	/** @internal */
-	override [Table.Symbol.ExtraConfigColumns]: Record<string, GelExtraConfigColumn> = {};
-}
-
-export type AnyGelTable<TPartial extends Partial<TableConfig> = {}> = GelTable<
-	UpdateTableConfig<TableConfig, TPartial>
->;
-
-export type GelTableWithColumns<T extends TableConfig> =
-	& GelTable<T>
-	& {
-		[Key in keyof T['columns']]: T['columns'][Key];
-	}
-	& {
-		enableRLS: () => Omit<
-			GelTableWithColumns<T>,
-			'enableRLS'
-		>;
-	};
-
-/** @internal */
-export function gelTableWithSchema<
-	TTableName extends string,
-	TSchemaName extends string | undefined,
-	TColumnsMap extends Record<string, GelColumnBuilderBase>,
->(
-	name: TTableName,
-	columns: TColumnsMap | ((columnTypes: GelColumnsBuilders) => TColumnsMap),
-	extraConfig:
-		| ((
-			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>,
-		) => GelTableExtraConfig | GelTableExtraConfigValue[])
-		| undefined,
-	schema: TSchemaName,
-	baseName = name,
-): GelTableWithColumns<{
-	name: TTableName;
-	schema: TSchemaName;
-	columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-	dialect: 'gel';
-}> {
-	const rawTable = new GelTable<{
-		name: TTableName;
-		schema: TSchemaName;
-		columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-		dialect: 'gel';
-	}>(name, schema, baseName);
-
-	const parsedColumns: TColumnsMap = typeof columns === 'function' ? columns(getGelColumnBuilders()) : columns;
-
-	const builtColumns = Object.fromEntries(
-		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
-			const colBuilder = colBuilderBase as GelColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.build(rawTable);
-			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
-			return [name, column];
-		}),
-	) as unknown as BuildColumns<TTableName, TColumnsMap, 'gel'>;
-
-	const builtColumnsForExtraConfig = Object.fromEntries(
-		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
-			const colBuilder = colBuilderBase as GelColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.buildExtraConfigColumn(rawTable);
-			return [name, column];
-		}),
-	) as unknown as BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>;
-
-	const table = Object.assign(rawTable, builtColumns);
-
-	table[Table.Symbol.Columns] = builtColumns;
-	table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
-
-	if (extraConfig) {
-		table[GelTable.Symbol.ExtraConfigBuilder] = extraConfig as any;
-	}
-
-	return Object.assign(table, {
-		enableRLS: () => {
-			table[GelTable.Symbol.EnableRLS] = true;
-			return table as GelTableWithColumns<{
-				name: TTableName;
-				schema: TSchemaName;
-				columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-				dialect: 'gel';
-			}>;
-		},
-	});
-}
-
-export interface GelTableFn<TSchema extends string | undefined = undefined> {
-	/**
-	 * @deprecated The third parameter of GelTable is changing and will only accept an array instead of an object
-	 *
-	 * @example
-	 * Deprecated version:
-	 * ```ts
-	 * export const users = gelTable("users", {
-	 * 	id: integer(),
-	 * }, (t) => ({
-	 * 	idx: index('custom_name').on(t.id)
-	 * }));
-	 * ```
-	 *
-	 * New API:
-	 * ```ts
-	 * export const users = gelTable("users", {
-	 * 	id: integer(),
-	 * }, (t) => [
-	 * 	index('custom_name').on(t.id)
-	 * ]);
-	 * ```
-	 */
-	<
-		TTableName extends string,
-		TColumnsMap extends Record<string, GelColumnBuilderBase>,
-	>(
-		name: TTableName,
-		columns: TColumnsMap,
-		extraConfig: (
-			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>,
-		) => GelTableExtraConfig,
-	): GelTableWithColumns<{
-		name: TTableName;
-		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-		dialect: 'gel';
-	}>;
-
-	/**
-	 * @deprecated The third parameter of gelTable is changing and will only accept an array instead of an object
-	 *
-	 * @example
-	 * Deprecated version:
-	 * ```ts
-	 * export const users = gelTable("users", {
-	 * 	id: integer(),
-	 * }, (t) => ({
-	 * 	idx: index('custom_name').on(t.id)
-	 * }));
-	 * ```
-	 *
-	 * New API:
-	 * ```ts
-	 * export const users = gelTable("users", {
-	 * 	id: integer(),
-	 * }, (t) => [
-	 * 	index('custom_name').on(t.id)
-	 * ]);
-	 * ```
-	 */
-	<
-		TTableName extends string,
-		TColumnsMap extends Record<string, GelColumnBuilderBase>,
-	>(
-		name: TTableName,
-		columns: (columnTypes: GelColumnsBuilders) => TColumnsMap,
-		extraConfig: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>) => GelTableExtraConfig,
-	): GelTableWithColumns<{
-		name: TTableName;
-		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-		dialect: 'gel';
-	}>;
-
-	<
-		TTableName extends string,
-		TColumnsMap extends Record<string, GelColumnBuilderBase>,
-	>(
-		name: TTableName,
-		columns: TColumnsMap,
-		extraConfig?: (
-			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>,
-		) => GelTableExtraConfigValue[],
-	): GelTableWithColumns<{
-		name: TTableName;
-		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-		dialect: 'gel';
-	}>;
-
-	<
-		TTableName extends string,
-		TColumnsMap extends Record<string, GelColumnBuilderBase>,
-	>(
-		name: TTableName,
-		columns: (columnTypes: GelColumnsBuilders) => TColumnsMap,
-		extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'gel'>) => GelTableExtraConfigValue[],
-	): GelTableWithColumns<{
-		name: TTableName;
-		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'gel'>;
-		dialect: 'gel';
-	}>;
-}
-
-export const gelTable: GelTableFn = (name, columns, extraConfig) => {
-	return gelTableWithSchema(name, columns, extraConfig, undefined);
-};
-
-export function gelTableCreator(customizeTableName: (name: string) => string): GelTableFn {
-	return (name, columns, extraConfig) => {
-		return gelTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
-	};
-}
diff --git a/drizzle-orm/src/gel-core/unique-constraint.ts b/drizzle-orm/src/gel-core/unique-constraint.ts
deleted file mode 100644
index 4f64908096..0000000000
--- a/drizzle-orm/src/gel-core/unique-constraint.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { TableName } from '~/table.utils.ts';
-import type { GelColumn } from './columns/index.ts';
-import type { GelTable } from './table.ts';
-
-export function unique(name?: string): UniqueOnConstraintBuilder {
-	return new UniqueOnConstraintBuilder(name);
-}
-
-export function uniqueKeyName(table: GelTable, columns: string[]) {
-	return `${table[TableName]}_${columns.join('_')}_unique`;
-}
-
-export class UniqueConstraintBuilder {
-	static readonly [entityKind]: string = 'GelUniqueConstraintBuilder';
-
-	/** @internal */
-	columns: GelColumn[];
-	/** @internal */
-	nullsNotDistinctConfig = false;
-
-	constructor(
-		columns: GelColumn[],
-		private name?: string,
-	) {
-		this.columns = columns;
-	}
-
-	nullsNotDistinct() {
-		this.nullsNotDistinctConfig = true;
-		return this;
-	}
-
-	/** @internal */
-	build(table: GelTable): UniqueConstraint {
-		return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
-	}
-}
-
-export class UniqueOnConstraintBuilder {
-	static readonly [entityKind]: string = 'GelUniqueOnConstraintBuilder';
-
-	/** @internal */
-	name?: string;
-
-	constructor(
-		name?: string,
-	) {
-		this.name = name;
-	}
-
-	on(...columns: [GelColumn, ...GelColumn[]]) {
-		return new UniqueConstraintBuilder(columns, this.name);
-	}
-}
-
-export class UniqueConstraint {
-	static readonly [entityKind]: string = 'GelUniqueConstraint';
-
-	readonly columns: GelColumn[];
-	readonly name?: string;
-	readonly nullsNotDistinct: boolean = false;
-
-	constructor(readonly table: GelTable, columns: GelColumn[], nullsNotDistinct: boolean, name?: string) {
-		this.columns = columns;
-		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
-		this.nullsNotDistinct = nullsNotDistinct;
-	}
-
-	getName() {
-		return this.name;
-	}
-}
diff --git a/drizzle-orm/src/gel-core/utils.ts b/drizzle-orm/src/gel-core/utils.ts
deleted file mode 100644
index c638de8ba8..0000000000
--- a/drizzle-orm/src/gel-core/utils.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { is } from '~/entity.ts';
-import { SQL } from '~/sql/sql.ts';
-import { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
-import { ViewBaseConfig } from '~/view-common.ts';
-import { type Check, CheckBuilder } from './checks.ts';
-import type { AnyGelColumn } from './columns/index.ts';
-import { type ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
-import type { Index } from './indexes.ts';
-import { IndexBuilder } from './indexes.ts';
-import { GelPolicy } from './policies.ts';
-import { type PrimaryKey, PrimaryKeyBuilder } from './primary-keys.ts';
-import { GelTable } from './table.ts';
-import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
-import type { GelViewBase } from './view-base.ts';
-import { GelViewConfig } from './view-common.ts';
-import { type GelMaterializedView, GelMaterializedViewConfig, type GelView } from './view.ts';
-
-export function getTableConfig<TTable extends GelTable>(table: TTable) {
-	const columns = Object.values(table[Table.Symbol.Columns]);
-	const indexes: Index[] = [];
-	const checks: Check[] = [];
-	const primaryKeys: PrimaryKey[] = [];
-	const foreignKeys: ForeignKey[] = Object.values(table[GelTable.Symbol.InlineForeignKeys]);
-	const uniqueConstraints: UniqueConstraint[] = [];
-	const name = table[Table.Symbol.Name];
-	const schema = table[Table.Symbol.Schema];
-	const policies: GelPolicy[] = [];
-	const enableRLS: boolean = table[GelTable.Symbol.EnableRLS];
-
-	const extraConfigBuilder = table[GelTable.Symbol.ExtraConfigBuilder];
-
-	if (extraConfigBuilder !== undefined) {
-		const extraConfig = extraConfigBuilder(table[Table.Symbol.ExtraConfigColumns]);
-		const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) as any[] : Object.values(extraConfig);
-		for (const builder of extraValues) {
-			if (is(builder, IndexBuilder)) {
-				indexes.push(builder.build(table));
-			} else if (is(builder, CheckBuilder)) {
-				checks.push(builder.build(table));
-			} else if (is(builder, UniqueConstraintBuilder)) {
-				uniqueConstraints.push(builder.build(table));
-			} else if (is(builder, PrimaryKeyBuilder)) {
-				primaryKeys.push(builder.build(table));
-			} else if (is(builder, ForeignKeyBuilder)) {
-				foreignKeys.push(builder.build(table));
-			} else if (is(builder, GelPolicy)) {
-				policies.push(builder);
-			}
-		}
-	}
-
-	return {
-		columns,
-		indexes,
-		foreignKeys,
-		checks,
-		primaryKeys,
-		uniqueConstraints,
-		name,
-		schema,
-		policies,
-		enableRLS,
-	};
-}
-
-export function extractUsedTable(table: GelTable | Subquery | GelViewBase | SQL): string[] {
-	if (is(table, GelTable)) {
-		return [`${table[Table.Symbol.BaseName]}`];
-	}
-	if (is(table, Subquery)) {
-		return table._.usedTables ?? [];
-	}
-	if (is(table, SQL)) {
-		return table.usedTables ?? [];
-	}
-	return [];
-}
-
-export function getViewConfig<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
->(view: GelView<TName, TExisting>) {
-	return {
-		...view[ViewBaseConfig],
-		...view[GelViewConfig],
-	};
-}
-
-export function getMaterializedViewConfig<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
->(view: GelMaterializedView<TName, TExisting>) {
-	return {
-		...view[ViewBaseConfig],
-		...view[GelMaterializedViewConfig],
-	};
-}
-
-export type ColumnsWithTable<
-	TTableName extends string,
-	TForeignTableName extends string,
-	TColumns extends AnyGelColumn<{ tableName: TTableName }>[],
-> = { [Key in keyof TColumns]: AnyGelColumn<{ tableName: TForeignTableName }> };
diff --git a/drizzle-orm/src/gel-core/view-base.ts b/drizzle-orm/src/gel-core/view-base.ts
deleted file mode 100644
index ea16f3b410..0000000000
--- a/drizzle-orm/src/gel-core/view-base.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import { type ColumnsSelection, View } from '~/sql/sql.ts';
-
-export abstract class GelViewBase<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends View<TName, TExisting, TSelectedFields> {
-	static override readonly [entityKind]: string = 'GelViewBase';
-
-	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
-		readonly viewBrand: 'GelViewBase';
-	};
-}
diff --git a/drizzle-orm/src/gel-core/view-common.ts b/drizzle-orm/src/gel-core/view-common.ts
deleted file mode 100644
index 1980402f34..0000000000
--- a/drizzle-orm/src/gel-core/view-common.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const GelViewConfig = Symbol.for('drizzle:GelViewConfig');
diff --git a/drizzle-orm/src/gel-core/view.ts b/drizzle-orm/src/gel-core/view.ts
deleted file mode 100644
index 1d0373863c..0000000000
--- a/drizzle-orm/src/gel-core/view.ts
+++ /dev/null
@@ -1,439 +0,0 @@
-import type { BuildColumns } from '~/column-builder.ts';
-import { entityKind, is } from '~/entity.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
-import { getTableColumns } from '~/utils.ts';
-import type { RequireAtLeastOne } from '~/utils.ts';
-import type { GelColumn, GelColumnBuilderBase } from './columns/common.ts';
-import { QueryBuilder } from './query-builders/query-builder.ts';
-import { gelTable } from './table.ts';
-import { GelViewBase } from './view-base.ts';
-import { GelViewConfig } from './view-common.ts';
-
-export type ViewWithConfig = RequireAtLeastOne<{
-	checkOption: 'local' | 'cascaded';
-	securityBarrier: boolean;
-	securityInvoker: boolean;
-}>;
-
-export class DefaultViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
-	static readonly [entityKind]: string = 'GelDefaultViewBuilderCore';
-
-	declare readonly _: {
-		readonly name: TConfig['name'];
-		readonly columns: TConfig['columns'];
-	};
-
-	constructor(
-		protected name: TConfig['name'],
-		protected schema: string | undefined,
-	) {}
-
-	protected config: {
-		with?: ViewWithConfig;
-	} = {};
-
-	with(config: ViewWithConfig): this {
-		this.config.with = config;
-		return this;
-	}
-}
-
-export class ViewBuilder<TName extends string = string> extends DefaultViewBuilderCore<{ name: TName }> {
-	static override readonly [entityKind]: string = 'GelViewBuilder';
-
-	as<TSelectedFields extends ColumnsSelection>(
-		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
-	): GelViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'gel'>> {
-		if (typeof qb === 'function') {
-			qb = qb(new QueryBuilder());
-		}
-		const selectionProxy = new SelectionProxyHandler<TSelectedFields>({
-			alias: this.name,
-			sqlBehavior: 'error',
-			sqlAliasedBehavior: 'alias',
-			replaceOriginalName: true,
-		});
-		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
-		return new Proxy(
-			new GelView({
-				GelConfig: this.config,
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: aliasedSelection,
-					query: qb.getSQL().inlineParams(),
-				},
-			}),
-			selectionProxy as any,
-		) as GelViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'gel'>>;
-	}
-}
-
-export class ManualViewBuilder<
-	TName extends string = string,
-	TColumns extends Record<string, GelColumnBuilderBase> = Record<string, GelColumnBuilderBase>,
-> extends DefaultViewBuilderCore<{ name: TName; columns: TColumns }> {
-	static override readonly [entityKind]: string = 'GelManualViewBuilder';
-
-	private columns: Record<string, GelColumn>;
-
-	constructor(
-		name: TName,
-		columns: TColumns,
-		schema: string | undefined,
-	) {
-		super(name, schema);
-		this.columns = getTableColumns(gelTable(name, columns));
-	}
-
-	existing(): GelViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'gel'>> {
-		return new Proxy(
-			new GelView({
-				GelConfig: undefined,
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: this.columns,
-					query: undefined,
-				},
-			}),
-			new SelectionProxyHandler({
-				alias: this.name,
-				sqlBehavior: 'error',
-				sqlAliasedBehavior: 'alias',
-				replaceOriginalName: true,
-			}),
-		) as GelViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'gel'>>;
-	}
-
-	as(query: SQL): GelViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'gel'>> {
-		return new Proxy(
-			new GelView({
-				GelConfig: this.config,
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: this.columns,
-					query: query.inlineParams(),
-				},
-			}),
-			new SelectionProxyHandler({
-				alias: this.name,
-				sqlBehavior: 'error',
-				sqlAliasedBehavior: 'alias',
-				replaceOriginalName: true,
-			}),
-		) as GelViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'gel'>>;
-	}
-}
-
-export type GelMaterializedViewWithConfig = RequireAtLeastOne<{
-	fillfactor: number;
-	toastTupleTarget: number;
-	parallelWorkers: number;
-	autovacuumEnabled: boolean;
-	vacuumIndexCleanup: 'auto' | 'off' | 'on';
-	vacuumTruncate: boolean;
-	autovacuumVacuumThreshold: number;
-	autovacuumVacuumScaleFactor: number;
-	autovacuumVacuumCostDelay: number;
-	autovacuumVacuumCostLimit: number;
-	autovacuumFreezeMinAge: number;
-	autovacuumFreezeMaxAge: number;
-	autovacuumFreezeTableAge: number;
-	autovacuumMultixactFreezeMinAge: number;
-	autovacuumMultixactFreezeMaxAge: number;
-	autovacuumMultixactFreezeTableAge: number;
-	logAutovacuumMinDuration: number;
-	userCatalogTable: boolean;
-}>;
-
-export class MaterializedViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
-	static readonly [entityKind]: string = 'GelMaterializedViewBuilderCore';
-
-	declare _: {
-		readonly name: TConfig['name'];
-		readonly columns: TConfig['columns'];
-	};
-
-	constructor(
-		protected name: TConfig['name'],
-		protected schema: string | undefined,
-	) {}
-
-	protected config: {
-		with?: GelMaterializedViewWithConfig;
-		using?: string;
-		tablespace?: string;
-		withNoData?: boolean;
-	} = {};
-
-	using(using: string): this {
-		this.config.using = using;
-		return this;
-	}
-
-	with(config: GelMaterializedViewWithConfig): this {
-		this.config.with = config;
-		return this;
-	}
-
-	tablespace(tablespace: string): this {
-		this.config.tablespace = tablespace;
-		return this;
-	}
-
-	withNoData(): this {
-		this.config.withNoData = true;
-		return this;
-	}
-}
-
-export class MaterializedViewBuilder<TName extends string = string>
-	extends MaterializedViewBuilderCore<{ name: TName }>
-{
-	static override readonly [entityKind]: string = 'GelMaterializedViewBuilder';
-
-	as<TSelectedFields extends ColumnsSelection>(
-		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
-	): GelMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'gel'>> {
-		if (typeof qb === 'function') {
-			qb = qb(new QueryBuilder());
-		}
-		const selectionProxy = new SelectionProxyHandler<TSelectedFields>({
-			alias: this.name,
-			sqlBehavior: 'error',
-			sqlAliasedBehavior: 'alias',
-			replaceOriginalName: true,
-		});
-		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
-		return new Proxy(
-			new GelMaterializedView({
-				GelConfig: {
-					with: this.config.with,
-					using: this.config.using,
-					tablespace: this.config.tablespace,
-					withNoData: this.config.withNoData,
-				},
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: aliasedSelection,
-					query: qb.getSQL().inlineParams(),
-				},
-			}),
-			selectionProxy as any,
-		) as GelMaterializedViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'gel'>>;
-	}
-}
-
-export class ManualMaterializedViewBuilder<
-	TName extends string = string,
-	TColumns extends Record<string, GelColumnBuilderBase> = Record<string, GelColumnBuilderBase>,
-> extends MaterializedViewBuilderCore<{ name: TName; columns: TColumns }> {
-	static override readonly [entityKind]: string = 'GelManualMaterializedViewBuilder';
-
-	private columns: Record<string, GelColumn>;
-
-	constructor(
-		name: TName,
-		columns: TColumns,
-		schema: string | undefined,
-	) {
-		super(name, schema);
-		this.columns = getTableColumns(gelTable(name, columns));
-	}
-
-	existing(): GelMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'gel'>> {
-		return new Proxy(
-			new GelMaterializedView({
-				GelConfig: {
-					tablespace: this.config.tablespace,
-					using: this.config.using,
-					with: this.config.with,
-					withNoData: this.config.withNoData,
-				},
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: this.columns,
-					query: undefined,
-				},
-			}),
-			new SelectionProxyHandler({
-				alias: this.name,
-				sqlBehavior: 'error',
-				sqlAliasedBehavior: 'alias',
-				replaceOriginalName: true,
-			}),
-		) as GelMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'gel'>>;
-	}
-
-	as(query: SQL): GelMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'gel'>> {
-		return new Proxy(
-			new GelMaterializedView({
-				GelConfig: {
-					tablespace: this.config.tablespace,
-					using: this.config.using,
-					with: this.config.with,
-					withNoData: this.config.withNoData,
-				},
-				config: {
-					name: this.name,
-					schema: this.schema,
-					selectedFields: this.columns,
-					query: query.inlineParams(),
-				},
-			}),
-			new SelectionProxyHandler({
-				alias: this.name,
-				sqlBehavior: 'error',
-				sqlAliasedBehavior: 'alias',
-				replaceOriginalName: true,
-			}),
-		) as GelMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'gel'>>;
-	}
-}
-
-export class GelView<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends GelViewBase<TName, TExisting, TSelectedFields> {
-	static override readonly [entityKind]: string = 'GelView';
-
-	[GelViewConfig]: {
-		with?: ViewWithConfig;
-	} | undefined;
-
-	constructor({ GelConfig, config }: {
-		GelConfig: {
-			with?: ViewWithConfig;
-		} | undefined;
-		config: {
-			name: TName;
-			schema: string | undefined;
-			selectedFields: ColumnsSelection;
-			query: SQL | undefined;
-		};
-	}) {
-		super(config);
-		if (GelConfig) {
-			this[GelViewConfig] = {
-				with: GelConfig.with,
-			};
-		}
-	}
-}
-
-export type GelViewWithSelection<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = GelView<TName, TExisting, TSelectedFields> & TSelectedFields;
-
-export const GelMaterializedViewConfig = Symbol.for('drizzle:GelMaterializedViewConfig');
-
-export class GelMaterializedView<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends GelViewBase<TName, TExisting, TSelectedFields> {
-	static override readonly [entityKind]: string = 'GelMaterializedView';
-
-	readonly [GelMaterializedViewConfig]: {
-		readonly with?: GelMaterializedViewWithConfig;
-		readonly using?: string;
-		readonly tablespace?: string;
-		readonly withNoData?: boolean;
-	} | undefined;
-
-	constructor({ GelConfig, config }: {
-		GelConfig: {
-			with: GelMaterializedViewWithConfig | undefined;
-			using: string | undefined;
-			tablespace: string | undefined;
-			withNoData: boolean | undefined;
-		} | undefined;
-		config: {
-			name: TName;
-			schema: string | undefined;
-			selectedFields: ColumnsSelection;
-			query: SQL | undefined;
-		};
-	}) {
-		super(config);
-		this[GelMaterializedViewConfig] = {
-			with: GelConfig?.with,
-			using: GelConfig?.using,
-			tablespace: GelConfig?.tablespace,
-			withNoData: GelConfig?.withNoData,
-		};
-	}
-}
-
-export type GelMaterializedViewWithSelection<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = GelMaterializedView<TName, TExisting, TSelectedFields> & TSelectedFields;
-
-/** @internal */
-export function gelViewWithSchema(
-	name: string,
-	selection: Record<string, GelColumnBuilderBase> | undefined,
-	schema: string | undefined,
-): ViewBuilder | ManualViewBuilder {
-	if (selection) {
-		return new ManualViewBuilder(name, selection, schema);
-	}
-	return new ViewBuilder(name, schema);
-}
-
-/** @internal */
-export function gelMaterializedViewWithSchema(
-	name: string,
-	selection: Record<string, GelColumnBuilderBase> | undefined,
-	schema: string | undefined,
-): MaterializedViewBuilder | ManualMaterializedViewBuilder {
-	if (selection) {
-		return new ManualMaterializedViewBuilder(name, selection, schema);
-	}
-	return new MaterializedViewBuilder(name, schema);
-}
-
-// TODO not implemented
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function gelView<TName extends string>(name: TName): ViewBuilder<TName>;
-function gelView<TName extends string, TColumns extends Record<string, GelColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualViewBuilder<TName, TColumns>;
-function gelView(name: string, columns?: Record<string, GelColumnBuilderBase>): ViewBuilder | ManualViewBuilder {
-	return gelViewWithSchema(name, columns, undefined);
-}
-
-// TODO not implemented
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function gelMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
-function gelMaterializedView<TName extends string, TColumns extends Record<string, GelColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualMaterializedViewBuilder<TName, TColumns>;
-function gelMaterializedView(
-	name: string,
-	columns?: Record<string, GelColumnBuilderBase>,
-): MaterializedViewBuilder | ManualMaterializedViewBuilder {
-	return gelMaterializedViewWithSchema(name, columns, undefined);
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function isGelView(obj: unknown): obj is GelView {
-	return is(obj, GelView);
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function isGelMaterializedView(obj: unknown): obj is GelMaterializedView {
-	return is(obj, GelMaterializedView);
-}
diff --git a/drizzle-orm/src/gel/driver.ts b/drizzle-orm/src/gel/driver.ts
deleted file mode 100644
index 74952f6e32..0000000000
--- a/drizzle-orm/src/gel/driver.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { type Client, type ConnectOptions, createClient } from 'gel';
-import type { Cache } from '~/cache/core/index.ts';
-import { entityKind } from '~/entity.ts';
-import { GelDatabase } from '~/gel-core/db.ts';
-import { GelDialect } from '~/gel-core/dialect.ts';
-import type { GelQueryResultHKT } from '~/gel-core/session.ts';
-import type { Logger } from '~/logger.ts';
-import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import type { GelClient } from './session.ts';
-import { GelDbSession } from './session.ts';
-
-export interface GelDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class GelDriver {
-	static readonly [entityKind]: string = 'GelDriver';
-
-	constructor(
-		private client: GelClient,
-		private dialect: GelDialect,
-		private options: GelDriverOptions = {},
-	) {}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): GelDbSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new GelDbSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-}
-
-export class GelJsDatabase<TSchema extends Record<string, unknown> = Record<string, never>>
-	extends GelDatabase<GelQueryResultHKT, TSchema>
-{
-	static override readonly [entityKind]: string = 'GelJsDatabase';
-}
-
-function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends GelClient = GelClient,
->(
-	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): GelJsDatabase<TSchema> & {
-	$client: TClient;
-} {
-	const dialect = new GelDialect({ casing: config.casing });
-	let logger;
-	if (config.logger === true) {
-		logger = new DefaultLogger();
-	} else if (config.logger !== false) {
-		logger = config.logger;
-	}
-
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new GelDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
-	const db = new GelJsDatabase(dialect, session, schema as any) as GelJsDatabase<TSchema>;
-	(<any> db).$client = client;
-	(<any> db).$cache = config.cache;
-	if ((<any> db).$cache) {
-		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
-	}
-
-	return db as any;
-}
-
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends GelClient = Client,
->(
-	...params:
-		| [TClient | string]
-		| [TClient | string, DrizzleConfig<TSchema>]
-		| [
-			& DrizzleConfig<TSchema>
-			& (
-				| {
-					connection: string | ConnectOptions;
-				}
-				| {
-					client: TClient;
-				}
-			),
-		]
-): GelJsDatabase<TSchema> & {
-	$client: TClient;
-} {
-	if (typeof params[0] === 'string') {
-		const instance = createClient({ dsn: params[0] });
-
-		return construct(instance, params[1] as DrizzleConfig<TSchema> | undefined) as any;
-	}
-
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as (
-			& ({ connection?: ConnectOptions | string; client?: TClient })
-			& DrizzleConfig<TSchema>
-		);
-
-		if (client) return construct(client, drizzleConfig);
-
-		const instance = createClient(connection);
-
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
-}
-
-export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): GelJsDatabase<TSchema> & {
-		$client: '$client is not available on drizzle.mock()';
-	} {
-		return construct({} as any, config) as any;
-	}
-}
diff --git a/drizzle-orm/src/gel/migrator.ts b/drizzle-orm/src/gel/migrator.ts
deleted file mode 100644
index 7e6216a94c..0000000000
--- a/drizzle-orm/src/gel/migrator.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-// import type { MigrationConfig } from '~/migrator.ts';
-// import { readMigrationFiles } from '~/migrator.ts';
-// import type { GelJsDatabase } from './driver.ts';
-
-// not supported
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function migrate<TSchema extends Record<string, unknown>>(
-	// db: GelJsDatabase<TSchema>,
-	// config: MigrationConfig,
-) {
-	return {};
-	// const migrations = readMigrationFiles(config);
-	// await db.dialect.migrate(migrations, db.session, config);
-}
diff --git a/drizzle-orm/src/gel/session.ts b/drizzle-orm/src/gel/session.ts
deleted file mode 100644
index d902541e63..0000000000
--- a/drizzle-orm/src/gel/session.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-import type { Client } from 'gel';
-import type { Transaction } from 'gel/dist/transaction';
-import { type Cache, NoopCache } from '~/cache/core/index.ts';
-import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind } from '~/entity.ts';
-import type { GelDialect } from '~/gel-core/dialect.ts';
-import type { SelectedFieldsOrdered } from '~/gel-core/query-builders/select.types.ts';
-import { GelPreparedQuery, GelSession, GelTransaction, type PreparedQueryConfig } from '~/gel-core/session.ts';
-import { type Logger, NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import { mapResultRow } from '~/utils.ts';
-
-export type GelClient = Client | Transaction;
-
-export class GelDbPreparedQuery<T extends PreparedQueryConfig> extends GelPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'GelPreparedQuery';
-
-	constructor(
-		private client: GelClient,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-		private transaction: boolean = false,
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		return tracer.startActiveSpan('drizzle.execute', async () => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-
-			this.logger.logQuery(this.queryString, params);
-			const { fields, queryString: query, client, joinsNotNullableMap, customResultMapper } = this;
-			if (!fields && !customResultMapper) {
-				return tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
-					span?.setAttributes({
-						'drizzle.query.text': query,
-						'drizzle.query.params': JSON.stringify(params),
-					});
-
-					return await this.queryWithCache(query, params, async () => {
-						return await client.querySQL(query, params.length ? params : undefined);
-					});
-				});
-			}
-
-			const result = (await tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
-				span?.setAttributes({
-					'drizzle.query.text': query,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-
-				return await this.queryWithCache(query, params, async () => {
-					return await client.withSQLRowMode('array').querySQL(query, params.length ? params : undefined);
-				});
-			})) as unknown[][];
-
-			return tracer.startActiveSpan('drizzle.mapResponse', () => {
-				return customResultMapper
-					? customResultMapper(result)
-					: result.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-			});
-		});
-	}
-
-	async all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		return await tracer.startActiveSpan('drizzle.execute', async () => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-			this.logger.logQuery(this.queryString, params);
-			return await tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
-				span?.setAttributes({
-					'drizzle.query.text': this.queryString,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return await this.queryWithCache(this.queryString, params, async () => {
-					return await this.client.withSQLRowMode('array').querySQL(
-						this.queryString,
-						params.length ? params : undefined,
-					).then((
-						result,
-					) => result);
-				});
-			});
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
-export interface GelSessionOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class GelDbSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends GelSession<GelQueryResultHKT, TFullSchema, TSchema>
-{
-	static override readonly [entityKind]: string = 'GelDbSession';
-
-	private logger: Logger;
-	private cache: Cache;
-
-	constructor(
-		private client: GelClient,
-		dialect: GelDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		private options: GelSessionOptions = {},
-	) {
-		super(dialect);
-		this.logger = options.logger ?? new NoopLogger();
-		this.cache = options.cache ?? new NoopCache();
-	}
-
-	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		},
-		cacheConfig?: WithCacheConfig,
-	): GelDbPreparedQuery<T> {
-		return new GelDbPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
-		);
-	}
-
-	override async transaction<T>(
-		transaction: (tx: GelTransaction<GelQueryResultHKT, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T> {
-		return await (this.client as Client).transaction(async (clientTx) => {
-			const session = new GelDbSession(clientTx, this.dialect, this.schema, this.options);
-			const tx = new GelDbTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
-			return await transaction(tx);
-		});
-	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<[{ count: string }]>(sql);
-		return Number(res[0]['count']);
-	}
-}
-
-export class GelDbTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends GelTransaction<GelQueryResultHKT, TFullSchema, TSchema>
-{
-	static override readonly [entityKind]: string = 'GelDbTransaction';
-
-	override async transaction<T>(transaction: (tx: GelDbTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
-		const tx = new GelDbTransaction<TFullSchema, TSchema>(
-			this.dialect,
-			this.session,
-			this.schema,
-		);
-		return await transaction(tx);
-	}
-}
-
-// TODO fix this
-export interface GelQueryResultHKT {
-	readonly $brand: 'GelQueryResultHKT';
-	readonly row: unknown;
-	readonly type: unknown;
-}
diff --git a/drizzle-orm/src/knex/README.md b/drizzle-orm/src/knex/README.md
deleted file mode 100644
index 7e38596c3b..0000000000
--- a/drizzle-orm/src/knex/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Drizzle ORM + Knex.js
-
-This is a toolchain for integrating Drizzle with [Knex.js](https://knexjs.org/).
-
-## Using Knex as a query builder
-
-You can define you DB schema using Drizzle and use Knex as the query builder. With this approach you benefit from schema definition and automated migrations provided by Drizzle, and you can use Knex to build your queries. This might be helpful if you have an existing Knex.js project and you want to add Drizzle features to it.
-
-This integration is based on [official Knex TypeScript guide](https://knexjs.org/guide/#typescript).
-
-```ts
-import Knex from 'knex';
-import { pgTable, serial, text } from 'drizzle-orm/pg-core';
-// This line is important - it allows you to use the Knexify type
-import 'drizzle-orm/knex';
-
-const test = pgTable('test', {
-  id: serial('id').primaryKey(),
-  name: text('name').notNull(),
-});
-
-declare module 'knex/types/tables' {
-  interface Tables {
-    test: Knexify<typeof test>;
-  }
-}
-
-const db = Knex({});
-
-const result/*: { id: number, name: string }[] */ = db('test').select();
-```
-
-## Wrapping Knex connection with Drizzle
-
-Coming soon!
diff --git a/drizzle-orm/src/knex/index.ts b/drizzle-orm/src/knex/index.ts
deleted file mode 100644
index 9aa5e8854a..0000000000
--- a/drizzle-orm/src/knex/index.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import type { Knex as KnexType } from 'knex';
-import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
-
-declare module 'knex/types/tables.ts' {
-	export type Knexify<T extends Table> =
-		& KnexType.CompositeTableType<
-			InferSelectModel<T, { dbColumnNames: true }>,
-			InferInsertModel<T, { dbColumnNames: true }>
-		>
-		& {};
-}
diff --git a/drizzle-orm/src/kysely/README.md b/drizzle-orm/src/kysely/README.md
deleted file mode 100644
index c7559424db..0000000000
--- a/drizzle-orm/src/kysely/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Drizzle ORM + Kysely
-
-This is a toolchain for integrating Drizzle with [Kysely](https://kysely-org.github.io/kysely/).
-
-## Using Kysely as a query builder
-
-You can define you DB schema using Drizzle and use Kysely as the query builder. With this approach you benefit from schema definition and automated migrations provided by Drizzle, and you can use Kysely to build your queries. This might be helpful if you have an existing Kysely project and you want to add Drizzle features to it.
-
-```ts
-import { Kysely, PostgresDialect } from 'kysely';
-import { Pool } from 'pg';
-import { Kyselify } from 'drizzle-orm/kysely';
-import { pgTable, serial, text } from 'drizzle-orm/pg-core';
-
-const test = pgTable('test', {
-  id: serial('id').primaryKey(),
-  name: text('name').notNull(),
-});
-
-interface Database {
-  test: Kyselify<typeof test>;
-}
-
-const db = new Kysely<Database>({
-  dialect: new PostgresDialect({
-    pool: new Pool(),
-  }),
-});
-
-const result/*: { id: number, name: string }[] */ = db.selectFrom('test').selectAll().execute();
-```
diff --git a/drizzle-orm/src/kysely/index.ts b/drizzle-orm/src/kysely/index.ts
deleted file mode 100644
index 45703e72f7..0000000000
--- a/drizzle-orm/src/kysely/index.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import type { ColumnType } from 'kysely';
-import type { InferInsertModel, InferSelectModel, MapColumnName, Table } from '~/table.ts';
-import type { Simplify } from '~/utils.ts';
-
-export type Kyselify<T extends Table> = Simplify<
-	{
-		[Key in keyof T['_']['columns'] & string as MapColumnName<Key, T['_']['columns'][Key], true>]: ColumnType<
-			// select
-			InferSelectModel<T, { dbColumnNames: true }>[MapColumnName<Key, T['_']['columns'][Key], true>],
-			// insert
-			MapColumnName<Key, T['_']['columns'][Key], true> extends keyof InferInsertModel<
-				T,
-				{ dbColumnNames: true }
-			> ? InferInsertModel<T, { dbColumnNames: true }>[MapColumnName<Key, T['_']['columns'][Key], true>]
-				: never,
-			// update
-			MapColumnName<Key, T['_']['columns'][Key], true> extends keyof InferInsertModel<
-				T,
-				{ dbColumnNames: true }
-			> ? InferInsertModel<T, { dbColumnNames: true }>[MapColumnName<Key, T['_']['columns'][Key], true>]
-				: never
-		>;
-	}
->;
diff --git a/drizzle-orm/src/libsql/driver-core.ts b/drizzle-orm/src/libsql/driver-core.ts
index c427637e82..d670d54510 100644
--- a/drizzle-orm/src/libsql/driver-core.ts
+++ b/drizzle-orm/src/libsql/driver-core.ts
@@ -1,26 +1,21 @@
-import type { Client, ResultSet } from '@libsql/client';
+import type { Client } from '@libsql/client';
 import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { LibSQLSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type LibSQLRunResult, LibSQLSession } from './session.ts';
 
-export class LibSQLDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'async', ResultSet, TSchema> {
+export class LibSQLDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', LibSQLRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'LibSQLDatabase';
 
 	/** @internal */
-	declare readonly session: LibSQLSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+	declare readonly session: LibSQLSession<TRelations>;
 
 	async batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
@@ -30,12 +25,15 @@ export class LibSQLDatabase<
 }
 
 /** @internal */
-export function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
->(client: Client, config: DrizzleConfig<TSchema> = {}): LibSQLDatabase<TSchema> & {
+export function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: Client,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): LibSQLDatabase<TRelations> & {
 	$client: Client;
 } {
-	const dialect = new SQLiteAsyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -43,21 +41,12 @@ export function construct<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new LibSQLSession(client, dialect, schema, { logger, cache: config.cache }, undefined);
-	const db = new LibSQLDatabase('async', dialect, session, schema) as LibSQLDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new LibSQLSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	}, undefined);
+	const db = new LibSQLDatabase('async', dialect, session as LibSQLSession<TRelations>, relations);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
diff --git a/drizzle-orm/src/libsql/driver.ts b/drizzle-orm/src/libsql/driver.ts
index b69a5d7bcc..4ec578ef0f 100644
--- a/drizzle-orm/src/libsql/driver.ts
+++ b/drizzle-orm/src/libsql/driver.ts
@@ -1,21 +1,19 @@
 import { type Client, type Config, createClient } from '@libsql/client';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import { construct as construct, type LibSQLDatabase } from './driver-core.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { construct, type LibSQLDatabase } from './driver-core.ts';
 
 export { LibSQLDatabase } from './driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -23,7 +21,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -34,25 +32,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/http/index.ts b/drizzle-orm/src/libsql/http/index.ts
index 1a07af6a88..741fa241d8 100644
--- a/drizzle-orm/src/libsql/http/index.ts
+++ b/drizzle-orm/src/libsql/http/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client/http';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/migrator.ts b/drizzle-orm/src/libsql/migrator.ts
index 373a8aab4a..2a4697e497 100644
--- a/drizzle-orm/src/libsql/migrator.ts
+++ b/drizzle-orm/src/libsql/migrator.ts
@@ -1,47 +1,80 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeAsyncIfNeeded } from '~/up-migrations/sqlite.ts';
 import type { LibSQLDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: LibSQLDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: LibSQLDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
 
-	const migrationTableCreate = sql`
+	const { newDb } = await upgradeAsyncIfNeeded(migrationsTable, db, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-			id SERIAL PRIMARY KEY,
+			id INTEGER PRIMARY KEY,
 			hash text NOT NULL,
-			created_at numeric
+			created_at numeric,
+			name text,
+			applied_at TEXT
 		)
 	`;
-	await db.session.run(migrationTableCreate);
+		await db.session.run(migrationTableCreate);
+	}
 
-	const dbMigrations = await db.values<[number, string, string]>(
-		sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
+	const dbMigrations = await db.all<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
 	);
 
-	const lastDbMigration = dbMigrations[0] ?? undefined;
+	if (config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
 
-	const statementToBatch = [];
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
 
-	for (const migration of migrations) {
-		if (!lastDbMigration || Number(lastDbMigration[2])! < migration.folderMillis) {
-			for (const stmt of migration.sql) {
-				statementToBatch.push(db.run(sql.raw(stmt)));
-			}
-
-			statementToBatch.push(
-				db.run(
-					sql`INSERT INTO ${
-						sql.identifier(migrationsTable)
-					} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
-				),
-			);
+		await db.run(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const statementToBatch = [];
+	for (const migration of migrationsToRun) {
+		for (const stmt of migration.sql) {
+			statementToBatch.push(db.run(sql.raw(stmt)));
 		}
+
+		statementToBatch.push(
+			db.run(
+				sql`INSERT INTO ${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+					new Date().toISOString()
+				})`,
+			),
+		);
 	}
 
 	await db.session.migrate(statementToBatch);
+
+	return;
 }
diff --git a/drizzle-orm/src/libsql/node/index.ts b/drizzle-orm/src/libsql/node/index.ts
index bd6d5200dc..0c2998efe4 100644
--- a/drizzle-orm/src/libsql/node/index.ts
+++ b/drizzle-orm/src/libsql/node/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client/node';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/session.ts b/drizzle-orm/src/libsql/session.ts
index b4c331068b..028bc20e98 100644
--- a/drizzle-orm/src/libsql/session.ts
+++ b/drizzle-orm/src/libsql/session.ts
@@ -1,23 +1,21 @@
 import type { Client, InArgs, InStatement, ResultSet, Transaction } from '@libsql/client';
-import type { BatchItem as BatchItem } from '~/batch.ts';
+import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { PreparedQuery } from '~/session.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SQLiteExecuteMethod,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
 
 export interface LibSQLSessionOptions {
 	logger?: Logger;
@@ -26,10 +24,9 @@ export interface LibSQLSessionOptions {
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class LibSQLSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'async', ResultSet, TFullSchema, TSchema> {
+export type LibSQLRunResult = ResultSet;
+
+export class LibSQLSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'async', ResultSet, TRelations> {
 	static override readonly [entityKind]: string = 'LibSQLSession';
 
 	private logger: Logger;
@@ -37,87 +34,128 @@ export class LibSQLSession<
 
 	constructor(
 		private client: Client,
-		dialect: SQLiteAsyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
 		private options: LibSQLSessionOptions,
 		private tx: Transaction | undefined,
 	) {
-		super(dialect);
+		super(dialect, 'async');
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): LibSQLPreparedQuery<T> {
-		return new LibSQLPreparedQuery(
-			this.client,
+	): SQLiteAsyncPreparedQuery<T & { run: LibSQLRunResult }> {
+		const client = this.tx ?? this.client;
+
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) =>
+				client.execute({ sql: query.sql, args: params as InArgs }).then(({ rows }) =>
+					mode === 'arrays' ? rows.map(toArrayRow) : rows.map(normalizeRow)
+				),
+			get: (params) =>
+				client.execute({ sql: query.sql, args: params as InArgs }).then(({ rows }) =>
+					rows[0] ? (mode === 'arrays' ? toArrayRow(rows[0]) : normalizeRow(rows[0])) : undefined
+				),
+			run: (params) => client.execute({ sql: query.sql, args: params as InArgs }),
+			values: (params) =>
+				client.execute({ sql: query.sql, args: params as InArgs }).then(({ rows }) => rows.map(toArrayRow)),
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			this.tx,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
-	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
-		const preparedQueries: PreparedQuery[] = [];
+	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T): Promise<BatchResponse<T>>;
+	/** @internal */
+	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(
+		queries: T,
+		isMigration?: boolean,
+	): Promise<BatchResponse<T>>;
+	/** @internal */
+	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(
+		queries: T,
+		isMigration?: boolean,
+	): Promise<BatchResponse<T>> {
+		const preparedQueries: SQLiteAsyncPreparedQuery<any>[] = [];
 		const builtQueries: InStatement[] = [];
 
 		for (const query of queries) {
-			const preparedQuery = query._prepare();
+			const preparedQuery = query._prepare() as SQLiteAsyncPreparedQuery<any>;
 			const builtQuery = preparedQuery.getQuery();
 			preparedQueries.push(preparedQuery);
 			builtQueries.push({ sql: builtQuery.sql, args: builtQuery.params as InArgs });
 		}
 
-		const batchResults = await this.client.batch(builtQueries);
-		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
-	}
+		const batchResults = await (isMigration
+			? this.client.migrate(builtQueries)
+			: (this.tx ?? this.client).batch(builtQueries));
+		return batchResults.map((result, i) => {
+			const { executeMethod, mapper, mode } = preparedQueries[i]!;
 
-	async migrate<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
-		const preparedQueries: PreparedQuery[] = [];
-		const builtQueries: InStatement[] = [];
+			if (executeMethod === 'run') return result;
+			if (executeMethod === 'values') return result.rows;
 
-		for (const query of queries) {
-			const preparedQuery = query._prepare();
-			const builtQuery = preparedQuery.getQuery();
-			preparedQueries.push(preparedQuery);
-			builtQueries.push({ sql: builtQuery.sql, args: builtQuery.params as InArgs });
-		}
+			if (executeMethod === 'get') {
+				const value = result.rows[0];
+				if (!value) return;
+				const mapped = mode === 'arrays' ? toArrayRow(value) : normalizeRow(value);
+				if (!mapper) return mapped;
+
+				return mapper([mapped])[0];
+			}
 
-		const batchResults = await this.client.migrate(builtQueries);
-		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
+			const { rows } = result;
+			const mapped = mode === 'arrays' ? rows.map(toArrayRow) : rows.map(normalizeRow);
+			if (!mapper) return mapped;
+
+			return mapper(mapped);
+		}) as BatchResponse<T>;
+	}
+
+	async migrate<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
+		return this.batch(queries, true);
 	}
 
 	override async transaction<T>(
-		transaction: (db: LibSQLTransaction<TFullSchema, TSchema>) => T | Promise<T>,
+		transaction: (db: LibSQLTransaction<TRelations>) => T | Promise<T>,
 		_config?: SQLiteTransactionConfig,
 	): Promise<T> {
 		// TODO: support transaction behavior
 		const libsqlTx = await this.client.transaction();
-		const session = new LibSQLSession<TFullSchema, TSchema>(
+		const session = new LibSQLSession<TRelations>(
 			this.client,
 			this.dialect,
-			this.schema,
+			this.relations,
 			this.options,
 			libsqlTx,
 		);
-		const tx = new LibSQLTransaction<TFullSchema, TSchema>('async', this.dialect, session, this.schema);
+		const tx = new LibSQLTransaction<TRelations>(
+			'async',
+			this.dialect,
+			session,
+			this.relations,
+		);
 		try {
 			const result = await transaction(tx);
 			await libsqlTx.commit();
@@ -127,29 +165,24 @@ export class LibSQLSession<
 			throw err;
 		}
 	}
-
-	override extractRawAllValueFromBatchResult(result: unknown): unknown {
-		return (result as ResultSet).rows;
-	}
-
-	override extractRawGetValueFromBatchResult(result: unknown): unknown {
-		return (result as ResultSet).rows[0];
-	}
-
-	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
-		return (result as ResultSet).rows;
-	}
 }
 
-export class LibSQLTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'async', ResultSet, TFullSchema, TSchema> {
+export class LibSQLTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', LibSQLRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'LibSQLTransaction';
 
-	override async transaction<T>(transaction: (tx: LibSQLTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: LibSQLTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new LibSQLTransaction('async', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new LibSQLTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		await this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = await transaction(tx);
@@ -162,139 +195,11 @@ export class LibSQLTransaction<
 	}
 }
 
-export class LibSQLPreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
-	{ type: 'async'; run: ResultSet; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'LibSQLPreparedQuery';
-
-	constructor(
-		private client: Client,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		/** @internal */ public fields: SelectedFieldsOrdered | undefined,
-		private tx: Transaction | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		/** @internal */ public customResultMapper?: (
-			rows: unknown[][],
-			mapColumnValue?: (value: unknown) => unknown,
-		) => unknown,
-	) {
-		super('async', executeMethod, query, cache, queryMetadata, cacheConfig);
-		this.customResultMapper = customResultMapper;
-		this.fields = fields;
-	}
-
-	async run(placeholderValues?: Record<string, unknown>): Promise<ResultSet> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			const stmt: InStatement = { sql: this.query.sql, args: params as InArgs };
-			return this.tx ? this.tx.execute(stmt) : this.client.execute(stmt);
-		});
-	}
-
-	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, logger, query, tx, client, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return await this.queryWithCache(query.sql, params, async () => {
-				const stmt: InStatement = { sql: query.sql, args: params as InArgs };
-				return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => this.mapAllResult(rows));
-			});
-		}
-
-		const rows = await this.values(placeholderValues) as unknown[][];
-
-		return this.mapAllResult(rows);
-	}
-
-	override mapAllResult(rows: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			rows = (rows as ResultSet).rows;
-		}
-
-		if (!this.fields && !this.customResultMapper) {
-			return (rows as unknown[]).map((row) => normalizeRow(row));
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper(rows as unknown[][], normalizeFieldValue) as T['all'];
-		}
-
-		return (rows as unknown[]).map((row) => {
-			return mapResultRow(
-				this.fields!,
-				Array.prototype.slice.call(row).map((v) => normalizeFieldValue(v)),
-				this.joinsNotNullableMap,
-			);
-		});
-	}
-
-	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, logger, query, tx, client, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			return await this.queryWithCache(query.sql, params, async () => {
-				const stmt: InStatement = { sql: query.sql, args: params as InArgs };
-				return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => this.mapGetResult(rows));
-			});
-		}
-
-		const rows = await this.values(placeholderValues) as unknown[][];
-
-		return this.mapGetResult(rows);
-	}
-
-	override mapGetResult(rows: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			rows = (rows as ResultSet).rows;
-		}
-
-		const row = (rows as unknown[])[0];
-
-		if (!this.fields && !this.customResultMapper) {
-			return normalizeRow(row);
-		}
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper(rows as unknown[][], normalizeFieldValue) as T['get'];
-		}
-
-		return mapResultRow(
-			this.fields!,
-			Array.prototype.slice.call(row).map((v) => normalizeFieldValue(v)),
-			this.joinsNotNullableMap,
-		);
-	}
-
-	async values(placeholderValues?: Record<string, unknown>): Promise<T['values']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			const stmt: InStatement = { sql: this.query.sql, args: params as InArgs };
-			return (this.tx ? this.tx.execute(stmt) : this.client.execute(stmt)).then(({ rows }) => rows) as Promise<
-				T['values']
-			>;
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
+function toArrayRow(obj: any) {
+	// The libSQL node-sqlite3 compatibility wrapper returns array-like rows that
+	// expose numeric indices and a `length`, but aren't iterable. Materialize a
+	// real array so downstream consumers (e.g. the jit row mappers) can iterate them.
+	return Array.prototype.slice.call(obj);
 }
 
 function normalizeRow(obj: any) {
@@ -309,19 +214,3 @@ function normalizeRow(obj: any) {
 		return acc;
 	}, {});
 }
-
-function normalizeFieldValue(value: unknown) {
-	if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { // eslint-disable-line no-instanceof/no-instanceof
-		if (typeof Buffer !== 'undefined') {
-			if (!(value instanceof Buffer)) { // eslint-disable-line no-instanceof/no-instanceof
-				return Buffer.from(value);
-			}
-			return value;
-		}
-		if (typeof TextDecoder !== 'undefined') {
-			return new TextDecoder().decode(value);
-		}
-		throw new Error('TextDecoder is not available. Please provide either Buffer or TextDecoder polyfill.');
-	}
-	return value;
-}
diff --git a/drizzle-orm/src/libsql/sqlite3/index.ts b/drizzle-orm/src/libsql/sqlite3/index.ts
index afb11f6117..7dc3d66f0f 100644
--- a/drizzle-orm/src/libsql/sqlite3/index.ts
+++ b/drizzle-orm/src/libsql/sqlite3/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client/sqlite3';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/wasm/index.ts b/drizzle-orm/src/libsql/wasm/index.ts
index a27a124b54..9575ce704b 100644
--- a/drizzle-orm/src/libsql/wasm/index.ts
+++ b/drizzle-orm/src/libsql/wasm/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client-wasm';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/web/index.ts b/drizzle-orm/src/libsql/web/index.ts
index 9b1e2c8e01..a84241039c 100644
--- a/drizzle-orm/src/libsql/web/index.ts
+++ b/drizzle-orm/src/libsql/web/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client/web';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/libsql/ws/index.ts b/drizzle-orm/src/libsql/ws/index.ts
index 645ff1a071..840b01bde9 100644
--- a/drizzle-orm/src/libsql/ws/index.ts
+++ b/drizzle-orm/src/libsql/ws/index.ts
@@ -1,19 +1,17 @@
 import { type Client, type Config, createClient } from '@libsql/client/ws';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
 import { construct, type LibSQLDatabase } from '../driver-core.ts';
 
-export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Client = Client,
->(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Client = Client>(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleSQLiteConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleSQLiteConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -21,7 +19,7 @@ export function drizzle<
 			})
 		),
 	]
-): LibSQLDatabase<TSchema> & {
+): LibSQLDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -32,25 +30,21 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
 
-		const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
+	const instance = typeof connection === 'string' ? createClient({ url: connection }) : createClient(connection!);
 
-		return construct(instance, drizzleConfig) as any;
-	}
-
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleSQLiteConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): LibSQLDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): LibSQLDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/migrator.ts b/drizzle-orm/src/migrator.ts
index 8b7636a44e..094a14610a 100644
--- a/drizzle-orm/src/migrator.ts
+++ b/drizzle-orm/src/migrator.ts
@@ -1,5 +1,7 @@
 import crypto from 'node:crypto';
-import fs from 'node:fs';
+import fs, { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { formatToMillis } from './migrator.utils.ts';
 
 export interface KitConfig {
 	out: string;
@@ -10,6 +12,8 @@ export interface MigrationConfig {
 	migrationsFolder: string;
 	migrationsTable?: string;
 	migrationsSchema?: string;
+	/** @internal */
+	init?: boolean;
 }
 
 export interface MigrationMeta {
@@ -17,43 +21,67 @@ export interface MigrationMeta {
 	folderMillis: number;
 	hash: string;
 	bps: boolean;
+	name: string;
+}
+
+export interface MigrationFromJournalConfig {
+	migrationsJournal: MigrationsJournal;
+	migrationsTable?: string;
+}
+
+export type MigrationsJournal = {
+	sql: string;
+	timestamp: number;
+	name: string;
+}[];
+
+/** Only gets returned if migrator failed with `init: true` used by `drizzle-kit pull --init`*/
+export interface MigratorInitFailResponse {
+	exitCode: 'databaseMigrations' | 'localMigrations';
+}
+
+/** Only gets returned if migrator failed with `init: true` used by `drizzle-kit pull --init`*/
+export interface MigratorInitFailResponse {
+	exitCode: 'databaseMigrations' | 'localMigrations';
 }
 
 export function readMigrationFiles(config: MigrationConfig): MigrationMeta[] {
+	if (fs.existsSync(`${config.migrationsFolder}/meta/_journal.json`)) {
+		// it means user has folders V2
+		// we need to warn to up the folders
+		throw Error(
+			'We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"',
+		);
+	}
+
 	const migrationFolderTo = config.migrationsFolder;
 
 	const migrationQueries: MigrationMeta[] = [];
 
-	const journalPath = `${migrationFolderTo}/meta/_journal.json`;
-	if (!fs.existsSync(journalPath)) {
-		throw new Error(`Can't find meta/_journal.json file`);
-	}
-
-	const journalAsString = fs.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
+	const migrations = readdirSync(migrationFolderTo)
+		.map((subdir) => ({ path: join(migrationFolderTo, subdir, 'migration.sql'), name: subdir }))
+		.filter((it) => existsSync(it.path));
 
-	const journal = JSON.parse(journalAsString) as {
-		entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
-	};
+	migrations.sort((a, b) => a.name.localeCompare(b.name));
 
-	for (const journalEntry of journal.entries) {
-		const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
+	for (const migration of migrations) {
+		const migrationPath = migration.path;
+		const migrationDate = migration.name.slice(0, 14);
+		const query = fs.readFileSync(migrationPath).toString();
 
-		try {
-			const query = fs.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
+		const result = query.split('--> statement-breakpoint').map((it) => {
+			return it;
+		});
 
-			const result = query.split('--> statement-breakpoint').map((it) => {
-				return it;
-			});
+		const millis = formatToMillis(migrationDate);
 
-			migrationQueries.push({
-				sql: result,
-				bps: journalEntry.breakpoints,
-				folderMillis: journalEntry.when,
-				hash: crypto.createHash('sha256').update(query).digest('hex'),
-			});
-		} catch {
-			throw new Error(`No file ${migrationPath} found in ${migrationFolderTo} folder`);
-		}
+		migrationQueries.push({
+			sql: result,
+			bps: true,
+			folderMillis: millis,
+			hash: crypto.createHash('sha256').update(query).digest('hex'),
+			name: migration.name,
+		});
 	}
 
 	return migrationQueries;
diff --git a/drizzle-orm/src/migrator.utils.ts b/drizzle-orm/src/migrator.utils.ts
new file mode 100644
index 0000000000..83f0ba4547
--- /dev/null
+++ b/drizzle-orm/src/migrator.utils.ts
@@ -0,0 +1,24 @@
+import type { MigrationMeta } from './migrator.ts';
+
+export function formatToMillis(dateStr: string): number {
+	const year = parseInt(dateStr.slice(0, 4), 10);
+	const month = parseInt(dateStr.slice(4, 6), 10) - 1;
+	const day = parseInt(dateStr.slice(6, 8), 10);
+	const hour = parseInt(dateStr.slice(8, 10), 10);
+	const minute = parseInt(dateStr.slice(10, 12), 10);
+	const second = parseInt(dateStr.slice(12, 14), 10);
+
+	return Date.UTC(year, month, day, hour, minute, second);
+}
+
+export function getMigrationsToRun(params: {
+	localMigrations: MigrationMeta[];
+	dbMigrations: { id: number; hash: string; created_at: string; name: string | null }[];
+}): MigrationMeta[] {
+	const { localMigrations, dbMigrations } = params;
+
+	const dbNamesSet = new Set(
+		dbMigrations.map((m) => m.name).filter((n): n is string => n !== null),
+	);
+	return localMigrations.filter((lm) => !lm.name || !dbNamesSet.has(lm.name));
+}
diff --git a/drizzle-orm/src/mssql-core/alias.ts b/drizzle-orm/src/mssql-core/alias.ts
new file mode 100644
index 0000000000..be646fb9c8
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/alias.ts
@@ -0,0 +1,11 @@
+import { TableAliasProxyHandler } from '~/alias.ts';
+import type { BuildAliasTable } from './query-builders/select.types.ts';
+import type { MsSqlTable } from './table.ts';
+import type { MsSqlView } from './view.ts';
+
+export function alias<TTable extends MsSqlTable | MsSqlView, TAlias extends string>(
+	table: TTable,
+	alias: TAlias,
+): BuildAliasTable<TTable, TAlias> {
+	return new Proxy(table, new TableAliasProxyHandler(alias, false)) as any;
+}
diff --git a/drizzle-orm/src/mssql-core/casing.ts b/drizzle-orm/src/mssql-core/casing.ts
new file mode 100644
index 0000000000..cf15ee993d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/casing.ts
@@ -0,0 +1,19 @@
+import { type MsSqlSchema, mssqlSchema } from './schema.ts';
+import { mssqlTableWithCasing } from './table.ts';
+import { mssqlViewWithCasing } from './view.ts';
+
+export const snakeCase = {
+	table: mssqlTableWithCasing('snake_case'),
+	view: mssqlViewWithCasing('snake_case'),
+	schema: <T extends string>(name: T): MsSqlSchema<T> => {
+		return mssqlSchema(name, 'snake_case');
+	},
+};
+
+export const camelCase = {
+	table: mssqlTableWithCasing('camelCase'),
+	view: mssqlViewWithCasing('camelCase'),
+	schema: <T extends string>(name: T): MsSqlSchema<T> => {
+		return mssqlSchema(name, 'camelCase');
+	},
+};
diff --git a/drizzle-orm/src/mssql-core/checks.ts b/drizzle-orm/src/mssql-core/checks.ts
new file mode 100644
index 0000000000..fc580c9d8a
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/checks.ts
@@ -0,0 +1,32 @@
+import { entityKind } from '~/entity.ts';
+import type { SQL } from '~/sql/sql.ts';
+import type { MsSqlTable } from './table.ts';
+
+export class CheckBuilder {
+	static readonly [entityKind]: string = 'MsSqlCheckBuilder';
+
+	protected brand!: 'MsSqlConstraintBuilder';
+
+	constructor(public name: string, public value: SQL) {}
+
+	/** @internal */
+	build(table: MsSqlTable): Check {
+		return new Check(table, this);
+	}
+}
+
+export class Check {
+	static readonly [entityKind]: string = 'MsSqlCheck';
+
+	readonly name: string;
+	readonly value: SQL;
+
+	constructor(public table: MsSqlTable, builder: CheckBuilder) {
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+}
+
+export function check(name: string, value: SQL): CheckBuilder {
+	return new CheckBuilder(name, value);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/all.ts b/drizzle-orm/src/mssql-core/columns/all.ts
new file mode 100644
index 0000000000..e6501aa234
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/all.ts
@@ -0,0 +1,49 @@
+import { bigint } from './bigint.ts';
+import { binary } from './binary.ts';
+import { bit } from './bit.ts';
+import { char } from './char.ts';
+import { customType } from './custom.ts';
+import { date } from './date.ts';
+import { datetime } from './datetime.ts';
+import { datetime2 } from './datetime2.ts';
+import { datetimeoffset } from './datetimeoffset.ts';
+import { decimal } from './decimal.ts';
+import { float } from './float.ts';
+import { int } from './int.ts';
+import { numeric } from './numeric.ts';
+import { real } from './real.ts';
+import { smallint } from './smallint.ts';
+import { ntext, text } from './text.ts';
+import { time } from './time.ts';
+import { tinyint } from './tinyint.ts';
+import { varbinary } from './varbinary.ts';
+import { nvarchar, varchar } from './varchar.ts';
+
+export function getMsSqlColumnBuilders() {
+	return {
+		bigint,
+		binary,
+		bit,
+		char,
+		customType,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		real,
+		numeric,
+		smallint,
+		text,
+		ntext,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		nvarchar,
+	};
+}
+
+export type MsSqlColumnBuilders = ReturnType<typeof getMsSqlColumnBuilders>;
diff --git a/drizzle-orm/src/mssql-core/columns/bigint.ts b/drizzle-orm/src/mssql-core/columns/bigint.ts
new file mode 100644
index 0000000000..bc5856d764
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/bigint.ts
@@ -0,0 +1,70 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlBigIntBuilder<TMode extends 'number' | 'bigint' | 'string'> extends MsSqlColumnBuilderWithIdentity<{
+	dataType: TMode extends 'string' ? 'string int64' : TMode extends 'number' ? 'number int53' : 'bigint int64';
+	data: TMode extends 'string' ? string : TMode extends 'number' ? number : bigint;
+	driverParam: string;
+}, MsSqlBigIntConfig> {
+	static override readonly [entityKind]: string = 'MsSqlBigIntBuilder';
+
+	constructor(name: string, config: MsSqlBigIntConfig) {
+		const { mode } = config;
+		super(
+			name,
+			mode === 'string' ? 'string int64' : mode === 'number' ? 'number int53' : 'bigint int64' as any,
+			mode === 'string' ? 'MsSqlBigIntString' : mode === 'number' ? 'MsSqlBigIntNumber' : 'MsSqlBigInt',
+		);
+		this.config.mode = mode;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlBigInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlBigInt<T extends ColumnBaseConfig<'bigint int64' | 'number int53' | 'string int64'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlBigIntConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlBigInt';
+
+	readonly mode: 'number' | 'bigint' | 'string' = this.config.mode;
+
+	getSQLType(): string {
+		return `bigint`;
+	}
+
+	constructor(table: MsSqlTable<any>, config: MsSqlBigIntBuilder<'string' | 'number' | 'bigint'>['config']) {
+		super(table, config);
+		this.mode = config.mode;
+	}
+
+	override mapFromDriverValue = (value: string): T['data'] => {
+		return this.mode === 'string' ? value.toString() : this.mode === 'number' ? Number(value) : BigInt(value);
+	};
+}
+
+interface MsSqlBigIntConfig<T extends 'number' | 'bigint' | 'string' = 'number' | 'bigint' | 'string'> {
+	mode: T;
+}
+
+export function bigint<TMode extends 'number' | 'bigint' | 'string'>(
+	config: MsSqlBigIntConfig<TMode>,
+): MsSqlBigIntBuilder<TMode>;
+export function bigint<TMode extends 'number' | 'bigint' | 'string'>(
+	name: string,
+	config: MsSqlBigIntConfig<TMode>,
+): MsSqlBigIntBuilder<TMode>;
+export function bigint(a: string | MsSqlBigIntConfig, b?: MsSqlBigIntConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlBigIntConfig>(a, b);
+	return new MsSqlBigIntBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/binary.ts b/drizzle-orm/src/mssql-core/columns/binary.ts
new file mode 100644
index 0000000000..f5dd9d0a6e
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/binary.ts
@@ -0,0 +1,58 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlBinaryBuilder extends MsSqlColumnBuilder<
+	{
+		dataType: 'object buffer';
+		data: Buffer;
+		driverParam: Buffer;
+	},
+	MsSqlBinaryConfig & {
+		setLength: boolean;
+	}
+> {
+	static override readonly [entityKind]: string = 'MsSqlBinaryBuilder';
+
+	constructor(name: string, length: number | undefined) {
+		super(name, 'object buffer', 'MsSqlBinary');
+		this.config.length = length ?? 1;
+		this.config.setLength = length !== undefined;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlBinary(table, this.config);
+	}
+}
+
+export class MsSqlBinary<T extends ColumnBaseConfig<'object buffer'>> extends MsSqlColumn<
+	T,
+	MsSqlBinaryConfig & { setLength: boolean }
+> {
+	static override readonly [entityKind]: string = 'MsSqlBinary';
+
+	getSQLType(): string {
+		return this.config.setLength ? `binary(${this.length})` : `binary`;
+	}
+}
+
+export interface MsSqlBinaryConfig {
+	length?: number;
+}
+
+export function binary(
+	config?: MsSqlBinaryConfig,
+): MsSqlBinaryBuilder;
+export function binary(
+	name: string,
+	config?: MsSqlBinaryConfig,
+): MsSqlBinaryBuilder;
+export function binary(a?: string | MsSqlBinaryConfig, b: MsSqlBinaryConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<MsSqlBinaryConfig>(a, b);
+	return new MsSqlBinaryBuilder(name, config.length);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/bit.ts b/drizzle-orm/src/mssql-core/columns/bit.ts
new file mode 100644
index 0000000000..e35019aa1a
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/bit.ts
@@ -0,0 +1,37 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlBitBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'boolean';
+	data: boolean;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlBitBuilder';
+
+	constructor(name: string) {
+		super(name, 'boolean', 'MsSqlBit');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlBit(table, this.config);
+	}
+}
+
+export class MsSqlBit<T extends ColumnBaseConfig<'boolean'>> extends MsSqlColumnWithIdentity<T> {
+	static override readonly [entityKind]: string = 'MsSqlBit';
+
+	getSQLType(): string {
+		return `bit`;
+	}
+
+	override mapFromDriverValue = Boolean;
+}
+
+export function bit(name?: string) {
+	return new MsSqlBitBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/mssql-core/columns/char.ts b/drizzle-orm/src/mssql-core/columns/char.ts
new file mode 100644
index 0000000000..b5e223ea10
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/char.ts
@@ -0,0 +1,97 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlCharBuilder<TEnum extends [string, ...string[]]> extends MsSqlColumnBuilder<{
+	dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+	data: TEnum[number];
+	driverParam: number | string;
+	enumValues: TEnum;
+}, MsSqlCharConfig<TEnum>> {
+	static override readonly [entityKind]: string = 'MsSqlCharBuilder';
+
+	/** @internal */
+	constructor(name: string, config: MsSqlCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MsSqlChar');
+		this.config.length = config.length ?? 1;
+		this.config.enum = config.enum;
+		this.config.nonUnicode = config.nonUnicode;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlChar(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlChar<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends MsSqlColumn<T, MsSqlCharConfig<T['enumValues']>>
+{
+	static override readonly [entityKind]: string = 'MsSqlChar';
+
+	override readonly enumValues = this.config.enum;
+
+	readonly nonUnicode: boolean = this.config.nonUnicode;
+
+	getSQLType(): string {
+		return this.length === undefined
+			? this.nonUnicode ? `nchar` : `char`
+			: this.nonUnicode
+			? `nchar(${this.length})`
+			: `char(${this.length})`;
+	}
+}
+
+export type MsSqlCharConfig<TEnum extends string[] | readonly string[] | undefined> =
+	& MsSqlCharConfigInitial<TEnum>
+	& {
+		nonUnicode: boolean;
+	};
+
+export type MsSqlCharConfigInitial<
+	TEnum extends string[] | readonly string[] | undefined = string[] | readonly string[] | undefined,
+> = {
+	length?: number;
+	enum?: TEnum;
+};
+
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MsSqlCharConfigInitial<T | Writable<T>>,
+): MsSqlCharBuilder<Writable<T>>;
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config?: MsSqlCharConfigInitial<T | Writable<T>>,
+): MsSqlCharBuilder<Writable<T>>;
+export function char(
+	a?: string | MsSqlCharConfigInitial,
+	b?: MsSqlCharConfigInitial,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlCharConfigInitial>(a, b);
+
+	return new MsSqlCharBuilder(name, { ...config, nonUnicode: false } as any);
+}
+
+export function nchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MsSqlCharConfigInitial<T | Writable<T>>,
+): MsSqlCharBuilder<Writable<T>>;
+export function nchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config?: MsSqlCharConfigInitial<T | Writable<T>>,
+): MsSqlCharBuilder<Writable<T>>;
+export function nchar(
+	a?: string | MsSqlCharConfigInitial,
+	b?: MsSqlCharConfigInitial,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlCharConfigInitial>(a, b);
+	return new MsSqlCharBuilder(name, {
+		...config,
+		nonUnicode: true,
+	} as any);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/common.ts b/drizzle-orm/src/mssql-core/columns/common.ts
new file mode 100644
index 0000000000..21fcf4a5c8
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/common.ts
@@ -0,0 +1,162 @@
+import { ColumnBuilder } from '~/column-builder.ts';
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderExtraConfig,
+	ColumnBuilderRuntimeConfig,
+	ColumnType,
+	HasGenerated,
+	NotNull,
+} from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { Column } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { ForeignKey, UpdateDeleteAction } from '~/mssql-core/foreign-keys.ts';
+import { ForeignKeyBuilder } from '~/mssql-core/foreign-keys.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import type { SQL } from '~/sql/index.ts';
+import type { Update } from '~/utils.ts';
+
+export type MsSqlColumns = Record<string, MsSqlColumn<any>>;
+
+export interface ReferenceConfig {
+	ref: () => MsSqlColumn;
+	actions: {
+		onUpdate?: UpdateDeleteAction;
+		onDelete?: UpdateDeleteAction;
+	};
+}
+
+export interface MsSqlGeneratedColumnConfig {
+	mode?: 'virtual' | 'persisted';
+}
+
+export abstract class MsSqlColumnBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
+> extends ColumnBuilder<T, TRuntimeConfig, TExtraConfig> {
+	static override readonly [entityKind]: string = 'MsSqlColumnBuilder';
+
+	private foreignKeyConfigs: ReferenceConfig[] = [];
+
+	references(ref: ReferenceConfig['ref'], actions: ReferenceConfig['actions'] = {}): this {
+		this.foreignKeyConfigs.push({ ref, actions });
+		return this;
+	}
+
+	unique(name?: string): this {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		return this;
+	}
+
+	generatedAlwaysAs(
+		as: SQL | (() => SQL),
+		config?: MsSqlGeneratedColumnConfig,
+	): HasGenerated<this, {
+		type: 'always';
+	}> {
+		this.config.generated = {
+			as,
+			type: 'always',
+			mode: config?.mode ?? 'virtual',
+		};
+		return this as any;
+	}
+
+	/** @internal */
+	buildForeignKeys(column: MsSqlColumn, table: MsSqlTable): ForeignKey[] {
+		return this.foreignKeyConfigs.map(({ ref, actions }) => {
+			return ((ref, actions) => {
+				const builder = new ForeignKeyBuilder(() => {
+					const foreignColumn = ref();
+					return { columns: [column], foreignColumns: [foreignColumn] };
+				});
+				if (actions.onUpdate) {
+					builder.onUpdate(actions.onUpdate);
+				}
+				if (actions.onDelete) {
+					builder.onDelete(actions.onDelete);
+				}
+				return builder.build(table);
+			})(ref, actions);
+		});
+	}
+
+	/** @internal */
+	abstract build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	): MsSqlColumn<any>;
+}
+
+// To understand how to use `MsSqlColumn` and `AnyMsSqlColumn`, see `Column` and `AnyColumn` documentation.
+export abstract class MsSqlColumn<
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends Column<T, TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlColumn';
+
+	/** @internal */
+	override readonly table: MsSqlTable;
+
+	constructor(
+		table: MsSqlTable,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
+	) {
+		super(table, config);
+		this.table = table;
+	}
+
+	/** @internal */
+	override shouldDisableInsert(): boolean {
+		// mssql has only generatedAlwaysAs
+		return !!this.config.generated;
+	}
+}
+
+export type AnyMsSqlColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = MsSqlColumn<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
+>;
+
+export interface MsSqlColumnWithIdentityConfig {
+	identity: { seed?: number; increment?: number } | undefined;
+}
+
+export abstract class MsSqlColumnBuilderWithIdentity<
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<
+		ColumnType
+	>,
+	TRuntimeConfig extends object = object,
+	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
+> extends MsSqlColumnBuilder<T, TRuntimeConfig & MsSqlColumnWithIdentityConfig, TExtraConfig> {
+	static override readonly [entityKind]: string = 'MsSqlColumnBuilderWithAutoIncrement';
+
+	constructor(name: string, dataType: T['dataType'], columnType: string) {
+		super(name, dataType, columnType);
+	}
+
+	identity(): NotNull<HasGenerated<this>>;
+	identity(config: { seed: number; increment: number }): NotNull<HasGenerated<this>>;
+	identity(config?: { seed: number; increment: number }): NotNull<HasGenerated<this>> {
+		this.config.identity = {
+			seed: config ? config.seed : 1,
+			increment: config ? config.increment : 1,
+		};
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this as NotNull<HasGenerated<this>>;
+	}
+}
+
+export abstract class MsSqlColumnWithIdentity<
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends MsSqlColumn<T, MsSqlColumnWithIdentityConfig & TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlColumnWithAutoIncrement';
+
+	readonly identity = this.config.identity;
+
+	override shouldDisableInsert(): boolean {
+		return !!this.identity;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/columns/custom.ts b/drizzle-orm/src/mssql-core/columns/custom.ts
new file mode 100644
index 0000000000..d6d9c0551e
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/custom.ts
@@ -0,0 +1,369 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { ColumnBuilderBaseConfig } from '~/index.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
+	& {
+		dataType: 'custom';
+		data: T['data'];
+		driverParam: T['driverData'];
+	}
+	& (T['notNull'] extends true ? { notNull: true } : {})
+	& (T['default'] extends true ? { hasDefault: true } : {});
+
+export interface MsSqlCustomColumnInnerConfig {
+	customTypeValues: CustomTypeValues;
+}
+
+export class MsSqlCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>> extends MsSqlColumnBuilder<
+	T,
+	{
+		fieldConfig: CustomTypeValues['config'];
+		customTypeParams: CustomTypeParams<any>;
+	}
+> {
+	static override readonly [entityKind]: string = 'MsSqlCustomColumnBuilder';
+
+	constructor(
+		name: string,
+		fieldConfig: CustomTypeValues['config'],
+		customTypeParams: CustomTypeParams<any>,
+	) {
+		super(name, 'custom', 'MsSqlCustomColumn');
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+
+	/** @internal */
+	build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlCustomColumn(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlCustomColumn<T extends ColumnBaseConfig<'custom'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlCustomColumn';
+
+	private sqlName: string;
+	private mapTo?: (value: T['data']) => T['driverParam'];
+	private mapFrom?: (value: T['driverParam']) => T['data'];
+	private mapJson?: (value: unknown) => T['data'];
+	private forJsonSelect?: (name: SQL, sql: SQLGenerator) => SQL;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlCustomColumnBuilder<T>['config'],
+	) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapJson = config.customTypeParams.fromJson;
+		this.forJsonSelect = config.customTypeParams.forJsonSelect;
+	}
+
+	getSQLType(): string {
+		return this.sqlName;
+	}
+
+	override mapFromDriverValue = (value: T['driverParam']): T['data'] => {
+		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	};
+
+	mapFromJsonValue(value: unknown): T['data'] {
+		return typeof this.mapJson === 'function' ? this.mapJson(value) : this.mapFromDriverValue(value) as T['data'];
+	}
+
+	jsonSelectIdentifier(identifier: SQL, sql: SQLGenerator): SQL {
+		if (typeof this.forJsonSelect === 'function') return this.forJsonSelect(identifier, sql);
+
+		const rawType = this.getSQLType().toLowerCase();
+		const parenPos = rawType.indexOf('(');
+		const type = (parenPos + 1) ? rawType.slice(0, parenPos) : rawType;
+
+		switch (type) {
+			case 'binary':
+			case 'varbinary':
+			case 'time':
+			case 'datetime':
+			case 'datetime2':
+			case 'decimal':
+			case 'float':
+			case 'bigint': {
+				return sql`cast(${identifier} as char)`;
+			}
+			default: {
+				return identifier;
+			}
+		}
+	}
+
+	override mapToDriverValue = (value: T['data']): T['driverParam'] => {
+		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	};
+}
+
+export type CustomTypeValues = {
+	/**
+	 * Required type for custom column, that will infer proper type model
+	 *
+	 * Examples:
+	 *
+	 * If you want your column to be `string` type after selecting/or on inserting - use `data: string`. Like `text`, `varchar`
+	 *
+	 * If you want your column to be `number` type after selecting/or on inserting - use `data: number`. Like `integer`
+	 */
+	data: unknown;
+
+	/**
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
+	/**
+	 * Type helper, that represents what type database driver is accepting for specific database data type
+	 */
+	driverData?: unknown;
+
+	/**
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
+	/**
+	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
+	 */
+	config?: Record<string, any>;
+
+	/**
+	 * Whether the config argument should be required or not
+	 * @default false
+	 */
+	configRequired?: boolean;
+
+	/**
+	 * If your custom data type should be notNull by default you can use `notNull: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	notNull?: boolean;
+
+	/**
+	 * If your custom data type has default you can use `default: true`
+	 *
+	 * @example
+	 * const customSerial = customType<{ data: number, notNull: true, default: true }>({
+	 * 	  dataType() {
+	 * 	    return 'serial';
+	 *    },
+	 * });
+	 */
+	default?: boolean;
+};
+
+export interface CustomTypeParams<T extends CustomTypeValues> {
+	/**
+	 * Database data type string representation, that is used for migrations
+	 * @example
+	 * ```
+	 * `jsonb`, `text`
+	 * ```
+	 *
+	 * If database data type needs additional params you can use them from `config` param
+	 * @example
+	 * ```
+	 * `varchar(256)`, `numeric(2,3)`
+	 * ```
+	 *
+	 * To make `config` be of specific type please use config generic in {@link CustomTypeValues}
+	 *
+	 * @example
+	 * Usage example
+	 * ```
+	 *   dataType() {
+	 *     return 'boolean';
+	 *   },
+	 * ```
+	 * Or
+	 * ```
+	 *   dataType(config) {
+	 * 	   return typeof config.length !== 'undefined' ? `varchar(${config.length})` : `varchar`;
+	 * 	 }
+	 * ```
+	 */
+	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
+
+	/**
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
+	 * @example
+	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
+	 * ```
+	 * toDriver(value: TData): string {
+	 * 	 return JSON.stringify(value);
+	 * }
+	 * ```
+	 */
+	toDriver?: (value: T['data']) => T['driverData'] | SQL;
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
+	 * @example
+	 * For example, when using timestamp we need to map string Date representation to JS Date
+	 * ```
+	 * fromDriver(value: string): Date {
+	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07 03:25:16.635";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07 03:25:16.635");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying bigint column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's string representation, as opposed to bigint from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): bigint {
+	 * 	return BigInt(value);
+	 * },
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "5044565289845416380";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: 5044565289845416380n;
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `binary`, `varbinary`, `time`, `datetime`, `decimal`, `float`, `bigint`
+	 * @example
+	 * For example, when using bigint we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator): SQL {
+	 * 	return sql`cast(${identifier} as char)`
+	 * },
+	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		`table`.`custom_bigint` AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		cast(`table`.`custom_bigint` as char) AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
+	 */
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator) => SQL;
+}
+
+/**
+ * Custom mssql database data type generator
+ */
+export function customType<T extends CustomTypeValues = CustomTypeValues>(
+	customTypeParams: CustomTypeParams<T>,
+): Equal<T['configRequired'], true> extends true ? {
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig: TConfig,
+		): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
+			fieldConfig: T['config'],
+		): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+	}
+	: {
+		(): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+		<TConfig extends Record<string, any> & T['config']>(
+			fieldConfig?: TConfig,
+		): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
+			fieldConfig?: T['config'],
+		): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+	}
+{
+	return (
+		a?: string | T['config'],
+		b?: T['config'],
+	): MsSqlCustomColumnBuilder<ConvertCustomConfig<T>> => {
+		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
+		return new MsSqlCustomColumnBuilder(name, config, customTypeParams);
+	};
+}
diff --git a/drizzle-orm/src/mssql-core/columns/date.common.ts b/drizzle-orm/src/mssql-core/columns/date.common.ts
new file mode 100644
index 0000000000..c122a5371e
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/date.common.ts
@@ -0,0 +1,23 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnType } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import { sql } from '~/sql/sql.ts';
+import { MsSqlColumnBuilder } from './common.ts';
+
+export abstract class MsSqlDateColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
+> extends MsSqlColumnBuilder<T, TRuntimeConfig, TExtraConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateColumnBuilder';
+
+	defaultGetDate() {
+		return this.default(sql`(getdate())`);
+	}
+}
+
+export type DatetimePrecision = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+export interface MsSqlDatetimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+	mode?: TMode;
+	precision?: DatetimePrecision;
+}
diff --git a/drizzle-orm/src/mssql-core/columns/date.ts b/drizzle-orm/src/mssql-core/columns/date.ts
new file mode 100644
index 0000000000..3e8e9355ab
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/date.ts
@@ -0,0 +1,105 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn } from './common.ts';
+import { MsSqlDateColumnBaseBuilder } from './date.common.ts';
+
+export class MsSqlDateBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'object date';
+	data: Date;
+	driverParam: string | number;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlDateBuilder';
+
+	constructor(name: string) {
+		super(name, 'object date', 'MsSqlDate');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDate(table, this.config);
+	}
+}
+
+export class MsSqlDate<T extends ColumnBaseConfig<'object date'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDate';
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateBuilder['config'],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return `date`;
+	}
+
+	override mapFromDriverValue = (value: Date | string): Date => {
+		return new Date(value);
+	};
+}
+
+export class MsSqlDateStringBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'string date';
+	data: string;
+	driverParam: string | number;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlDateStringBuilder';
+
+	constructor(name: string) {
+		super(name, 'string date', 'MsSqlDateString');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateString<T extends ColumnBaseConfig<'string date'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateString';
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateStringBuilder['config'],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return `date`;
+	}
+
+	override mapFromDriverValue = (value: Date | string | null): string | null => {
+		return typeof value === 'string' ? value : value?.toISOString().split('T')[0] ?? null;
+	};
+}
+
+export interface MsSqlDateConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+	mode?: TMode;
+}
+
+export function date<TMode extends MsSqlDateConfig['mode'] & {}>(
+	config?: MsSqlDateConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateStringBuilder : MsSqlDateBuilder;
+export function date<TMode extends MsSqlDateConfig['mode'] & {}>(
+	name: string,
+	config?: MsSqlDateConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateStringBuilder : MsSqlDateBuilder;
+export function date(a?: string | MsSqlDateConfig, b?: MsSqlDateConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlDateConfig | undefined>(a, b);
+
+	if (config?.mode === 'string') {
+		return new MsSqlDateStringBuilder(name);
+	}
+	return new MsSqlDateBuilder(name);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/datetime.ts b/drizzle-orm/src/mssql-core/columns/datetime.ts
new file mode 100644
index 0000000000..aae667f4df
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/datetime.ts
@@ -0,0 +1,103 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn } from './common.ts';
+import { MsSqlDateColumnBaseBuilder } from './date.common.ts';
+
+export class MsSqlDateTimeBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'object date';
+	data: Date;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeBuilder';
+
+	constructor(name: string) {
+		super(name, 'object date', 'MsSqlDateTime');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTime(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTime<T extends ColumnBaseConfig<'object date'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTime';
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTimeBuilder['config'],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return `datetime`;
+	}
+}
+
+export class MsSqlDateTimeStringBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'string datetime';
+	data: string;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeStringBuilder';
+
+	constructor(name: string) {
+		super(name, 'string datetime', 'MsSqlDateTimeString');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTimeString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTimeString<T extends ColumnBaseConfig<'string datetime'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeString';
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTimeStringBuilder['config'],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return 'datetime';
+	}
+
+	override mapFromDriverValue = (value: Date | string | null): string | null => {
+		return typeof value === 'string' ? value : value?.toISOString() ?? null;
+	};
+}
+
+export interface MsSqlDatetimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+	mode?: TMode;
+}
+
+export function datetime<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTimeStringBuilder : MsSqlDateTimeBuilder;
+export function datetime<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	name: string,
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTimeStringBuilder : MsSqlDateTimeBuilder;
+export function datetime(a?: string | MsSqlDatetimeConfig, b?: MsSqlDatetimeConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlDatetimeConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MsSqlDateTimeStringBuilder(name);
+	}
+	return new MsSqlDateTimeBuilder(name);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/datetime2.ts b/drizzle-orm/src/mssql-core/columns/datetime2.ts
new file mode 100644
index 0000000000..428c7e7ef5
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/datetime2.ts
@@ -0,0 +1,110 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn } from './common.ts';
+import type { MsSqlDatetimeConfig } from './date.common.ts';
+import { MsSqlDateColumnBaseBuilder } from './date.common.ts';
+
+export class MsSqlDateTime2Builder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'object date';
+	data: Date;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTime2Builder';
+
+	constructor(name: string, config: MsSqlDatetimeConfig | undefined) {
+		super(name, 'object date', 'MsSqlDateTime2');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTime2(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTime2<T extends ColumnBaseConfig<'object date'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTime2';
+
+	readonly precision: number | undefined;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTime2Builder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `datetime2${precision}`;
+	}
+}
+
+export class MsSqlDateTime2StringBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'string datetime';
+	data: string;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTime2StringBuilder';
+
+	constructor(name: string, config: MsSqlDatetimeConfig | undefined) {
+		super(name, 'string datetime', 'MsSqlDateTime2String');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTime2String(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTime2String<T extends ColumnBaseConfig<'string datetime'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTime2String';
+
+	readonly precision: number | undefined;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTime2StringBuilder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `datetime2${precision}`;
+	}
+
+	override mapFromDriverValue = (value: Date | string | null): string | null => {
+		return typeof value === 'string' ? value : value?.toISOString() ?? null;
+	};
+}
+export function datetime2<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTime2StringBuilder : MsSqlDateTime2Builder;
+export function datetime2<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	name: string,
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTime2StringBuilder
+	: MsSqlDateTime2Builder;
+export function datetime2(a?: string | MsSqlDatetimeConfig, b?: MsSqlDatetimeConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlDatetimeConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MsSqlDateTime2StringBuilder(name, config);
+	}
+	return new MsSqlDateTime2Builder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/datetimeoffset.ts b/drizzle-orm/src/mssql-core/columns/datetimeoffset.ts
new file mode 100644
index 0000000000..1a322cb714
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/datetimeoffset.ts
@@ -0,0 +1,113 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn } from './common.ts';
+import type { MsSqlDatetimeConfig } from './date.common.ts';
+import { MsSqlDateColumnBaseBuilder } from './date.common.ts';
+
+export class MsSqlDateTimeOffsetBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'object date';
+	data: Date;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeOffsetBuilder';
+
+	constructor(name: string, config: MsSqlDatetimeConfig | undefined) {
+		super(name, 'object date', 'MsSqlDateTimeOffset');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTimeOffset(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTimeOffset<T extends ColumnBaseConfig<'object date'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeOffset';
+
+	readonly precision: number | undefined;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTimeOffsetBuilder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `datetimeoffset${precision}`;
+	}
+}
+
+export class MsSqlDateTimeOffsetStringBuilder extends MsSqlDateColumnBaseBuilder<{
+	dataType: 'string datetime';
+	data: string;
+	driverParam: string | Date;
+}, MsSqlDatetimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeOffsetStringBuilder';
+
+	constructor(name: string, config: MsSqlDatetimeConfig | undefined) {
+		super(name, 'string datetime', 'MsSqlDateTimeOffsetString');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDateTimeOffsetString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDateTimeOffsetString<T extends ColumnBaseConfig<'string datetime'>> extends MsSqlColumn<T> {
+	static override readonly [entityKind]: string = 'MsSqlDateTimeOffsetString';
+
+	readonly precision: number | undefined;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlDateTimeOffsetStringBuilder['config'],
+	) {
+		super(table, config);
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `datetimeoffset${precision}`;
+	}
+
+	override mapFromDriverValue = (value: Date | string | null): string | null => {
+		return typeof value === 'string' ? value : value?.toISOString() ?? null;
+	};
+}
+
+export function datetimeoffset(): MsSqlDateTimeOffsetBuilder;
+export function datetimeoffset<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTimeOffsetStringBuilder
+	: MsSqlDateTimeOffsetBuilder;
+export function datetimeoffset<TMode extends MsSqlDatetimeConfig['mode'] & {}>(
+	name: string,
+	config?: MsSqlDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlDateTimeOffsetStringBuilder
+	: MsSqlDateTimeOffsetBuilder;
+export function datetimeoffset(a?: string | MsSqlDatetimeConfig, b?: MsSqlDatetimeConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlDatetimeConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MsSqlDateTimeOffsetStringBuilder(name, config);
+	}
+	return new MsSqlDateTimeOffsetBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/decimal.ts b/drizzle-orm/src/mssql-core/columns/decimal.ts
new file mode 100644
index 0000000000..3806fbd2e6
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/decimal.ts
@@ -0,0 +1,184 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlDecimalBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'string numeric';
+	data: string;
+	driverParam: string;
+}, MsSqlDecimalConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDecimalBuilder';
+
+	constructor(name: string, config: MsSqlDecimalConfig | undefined) {
+		super(name, 'string numeric', 'MsSqlDecimal');
+		this.config.precision = config?.precision;
+		this.config.scale = config?.scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDecimal(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDecimal<T extends ColumnBaseConfig<'string numeric'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlDecimalConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlDecimal';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = (value: unknown): string => {
+		if (typeof value === 'string') return value;
+
+		return String(value);
+	};
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export class MsSqlDecimalNumberBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number';
+	data: number;
+	driverParam: string;
+}, MsSqlDecimalConfig> {
+	static override readonly [entityKind]: string = 'MsSqlDecimalNumberBuilder';
+
+	constructor(name: string, config: MsSqlDecimalConfig | undefined) {
+		super(name, 'number', 'MsSqlDecimalNumber');
+		this.config.precision = config?.precision;
+		this.config.scale = config?.scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDecimalNumber(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDecimalNumber<T extends ColumnBaseConfig<'number'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlDecimalConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlDecimalNumber';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = (value: unknown): number => {
+		if (typeof value === 'number') return value;
+
+		return Number(value);
+	};
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export class MsSqlDecimalBigIntBuilder extends MsSqlColumnBuilderWithIdentity<
+	{
+		dataType: 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	},
+	MsSqlDecimalConfig
+> {
+	static override readonly [entityKind]: string = 'MsSqlDecimalBigIntBuilder';
+
+	constructor(name: string, config: MsSqlDecimalConfig | undefined) {
+		super(name, 'bigint int64', 'MsSqlDecimalBigInt');
+		this.config.precision = config?.precision ?? 18;
+		this.config.scale = config?.scale ?? 0;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlDecimalBigInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlDecimalBigInt<T extends ColumnBaseConfig<'bigint int64'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlDecimalConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlDecimalBigInt';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = BigInt;
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `decimal(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'decimal';
+		} else {
+			return `decimal(${this.precision})`;
+		}
+	}
+}
+
+export interface MsSqlDecimalConfig<
+	T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint',
+> {
+	precision?: number;
+	scale?: number;
+	mode?: T;
+}
+
+export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
+	config?: MsSqlDecimalConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? MsSqlDecimalNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? MsSqlDecimalBigIntBuilder
+	: MsSqlDecimalBuilder;
+export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
+	name: string,
+	config?: MsSqlDecimalConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? MsSqlDecimalNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? MsSqlDecimalBigIntBuilder
+	: MsSqlDecimalBuilder;
+export function decimal(a?: string | MsSqlDecimalConfig, b?: MsSqlDecimalConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlDecimalConfig>(a, b);
+	const mode = config?.mode;
+	return mode === 'number'
+		? new MsSqlDecimalNumberBuilder(name, config)
+		: mode === 'bigint'
+		? new MsSqlDecimalBigIntBuilder(name, config)
+		: new MsSqlDecimalBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/float.ts b/drizzle-orm/src/mssql-core/columns/float.ts
new file mode 100644
index 0000000000..229275171d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/float.ts
@@ -0,0 +1,54 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlFloatBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number double';
+	data: number;
+	driverParam: number;
+}, MsSqlFloatConfig> {
+	static override readonly [entityKind]: string = 'MsSqlFloatBuilder';
+
+	constructor(name: string, config?: MsSqlFloatConfig) {
+		super(name, 'number double', 'MsSqlFloat');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlFloat(table, this.config);
+	}
+}
+
+export class MsSqlFloat<T extends ColumnBaseConfig<'number double'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlFloatConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlFloat';
+
+	readonly precision: number | undefined = this.config.precision;
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `float${precision}`;
+	}
+}
+
+export interface MsSqlFloatConfig {
+	precision?: number;
+}
+
+export function float(
+	config?: MsSqlFloatConfig,
+): MsSqlFloatBuilder;
+export function float(
+	name: string,
+	config?: MsSqlFloatConfig,
+): MsSqlFloatBuilder;
+export function float(a?: string | MsSqlFloatConfig, b: MsSqlFloatConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<MsSqlFloatConfig>(a, b);
+	return new MsSqlFloatBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/index.ts b/drizzle-orm/src/mssql-core/columns/index.ts
new file mode 100644
index 0000000000..fcc2c30808
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/index.ts
@@ -0,0 +1,21 @@
+export * from './bigint.ts';
+export * from './binary.ts';
+export * from './bit.ts';
+export * from './char.ts';
+export * from './common.ts';
+export * from './custom.ts';
+export * from './date.ts';
+export * from './datetime.ts';
+export * from './datetime2.ts';
+export * from './datetimeoffset.ts';
+export * from './decimal.ts';
+export * from './float.ts';
+export * from './int.ts';
+export * from './numeric.ts';
+export * from './real.ts';
+export * from './smallint.ts';
+export * from './text.ts';
+export * from './time.ts';
+export * from './tinyint.ts';
+export * from './varbinary.ts';
+export * from './varchar.ts';
diff --git a/drizzle-orm/src/mssql-core/columns/int.ts b/drizzle-orm/src/mssql-core/columns/int.ts
new file mode 100644
index 0000000000..ad569404f9
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/int.ts
@@ -0,0 +1,35 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlIntBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number int32';
+	data: number;
+	driverParam: number;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlIntBuilder';
+
+	constructor(name: string) {
+		super(name, 'number int32', 'MsSqlInt');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlInt(table, this.config);
+	}
+}
+
+export class MsSqlInt<T extends ColumnBaseConfig<'number int32'>> extends MsSqlColumnWithIdentity<T> {
+	static override readonly [entityKind]: string = 'MsSqlInt';
+
+	getSQLType(): string {
+		return `int`;
+	}
+}
+
+export function int(name?: string) {
+	return new MsSqlIntBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/mssql-core/columns/numeric.ts b/drizzle-orm/src/mssql-core/columns/numeric.ts
new file mode 100644
index 0000000000..806c0c1c44
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/numeric.ts
@@ -0,0 +1,181 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlNumericBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'string numeric';
+	data: string;
+	driverParam: string;
+}, MsSqlNumericConfig> {
+	static override readonly [entityKind]: string = 'MsSqlNumericBuilder';
+
+	constructor(name: string, config: MsSqlNumericConfig | undefined) {
+		super(name, 'string numeric', 'MsSqlNumeric');
+		this.config.precision = config?.precision;
+		this.config.scale = config?.scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlNumeric(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlNumeric<T extends ColumnBaseConfig<'string numeric'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlNumericConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlNumeric';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = (value: unknown): string => {
+		if (typeof value === 'string') return value;
+
+		return String(value);
+	};
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export class MsSqlNumericNumberBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number';
+	data: number;
+	driverParam: string;
+}, MsSqlNumericConfig> {
+	static override readonly [entityKind]: string = 'MsSqlNumericNumberBuilder';
+
+	constructor(name: string, config: MsSqlNumericConfig | undefined) {
+		super(name, 'number', 'MsSqlNumericNumber');
+		this.config.precision = config?.precision;
+		this.config.scale = config?.scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlNumericNumber(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlNumericNumber<T extends ColumnBaseConfig<'number'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlNumericConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlNumericNumber';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = (value: unknown): number => {
+		if (typeof value === 'number') return value;
+
+		return Number(value);
+	};
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export class MsSqlNumericBigIntBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'bigint int64';
+	data: bigint;
+	driverParam: string;
+}, MsSqlNumericConfig> {
+	static override readonly [entityKind]: string = 'MsSqlNumericBigIntBuilder';
+
+	constructor(name: string, config: MsSqlNumericConfig | undefined) {
+		super(name, 'bigint int64', 'MsSqlNumericBigInt');
+		this.config.precision = config?.precision;
+		this.config.scale = config?.scale;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlNumericBigInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlNumericBigInt<T extends ColumnBaseConfig<'bigint int64'>>
+	extends MsSqlColumnWithIdentity<T, MsSqlNumericConfig>
+{
+	static override readonly [entityKind]: string = 'MsSqlNumericBigInt';
+
+	readonly precision: number | undefined = this.config.precision;
+	readonly scale: number | undefined = this.config.scale;
+
+	override mapFromDriverValue = BigInt;
+
+	override mapToDriverValue = String;
+
+	getSQLType(): string {
+		if (this.precision !== undefined && this.scale !== undefined) {
+			return `numeric(${this.precision},${this.scale})`;
+		} else if (this.precision === undefined) {
+			return 'numeric';
+		} else {
+			return `numeric(${this.precision})`;
+		}
+	}
+}
+
+export interface MsSqlNumericConfig<
+	T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint',
+> {
+	precision?: number;
+	scale?: number;
+	mode?: T;
+}
+
+export function numeric<TMode extends 'string' | 'number' | 'bigint'>(
+	config?: MsSqlNumericConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? MsSqlNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? MsSqlNumericBigIntBuilder
+	: MsSqlNumericBuilder;
+export function numeric<TMode extends 'string' | 'number' | 'bigint'>(
+	name: string,
+	config?: MsSqlNumericConfig<TMode>,
+): Equal<TMode, 'number'> extends true ? MsSqlNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? MsSqlNumericBigIntBuilder
+	: MsSqlNumericBuilder;
+export function numeric(a?: string | MsSqlNumericConfig, b?: MsSqlNumericConfig) {
+	const { name, config } = getColumnNameAndConfig<MsSqlNumericConfig>(a, b);
+	const mode = config?.mode;
+	return mode === 'number'
+		? new MsSqlNumericNumberBuilder(name, config)
+		: mode === 'bigint'
+		? new MsSqlNumericBigIntBuilder(name, config)
+		: new MsSqlNumericBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/real.ts b/drizzle-orm/src/mssql-core/columns/real.ts
new file mode 100644
index 0000000000..c086bbca3b
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/real.ts
@@ -0,0 +1,39 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlRealBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number float';
+	data: number;
+	driverParam: number;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlRealBuilder';
+
+	constructor(name: string) {
+		super(name, 'number float', 'MsSqlReal');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlReal(table, this.config);
+	}
+}
+
+export class MsSqlReal<T extends ColumnBaseConfig<'number float'>> extends MsSqlColumnWithIdentity<T> {
+	static override readonly [entityKind]: string = 'MsSqlReal';
+
+	getSQLType(): string {
+		return 'real';
+	}
+
+	override mapFromDriverValue = (value: number): number => {
+		return parseFloat(value.toPrecision(7));
+	};
+}
+
+export function real(name?: string) {
+	return new MsSqlRealBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/mssql-core/columns/smallint.ts b/drizzle-orm/src/mssql-core/columns/smallint.ts
new file mode 100644
index 0000000000..272e4f3f5b
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/smallint.ts
@@ -0,0 +1,45 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlSmallIntBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number int16';
+	data: number;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlSmallIntBuilder';
+
+	constructor(name: string) {
+		super(name, 'number int16', 'MsSqlSmallInt');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlSmallInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlSmallInt<T extends ColumnBaseConfig<'number int16'>> extends MsSqlColumnWithIdentity<T> {
+	static override readonly [entityKind]: string = 'MsSqlSmallInt';
+
+	getSQLType(): string {
+		return `smallint`;
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'string') {
+			return Number(value);
+		}
+		return value;
+	};
+}
+
+export function smallint(name?: string) {
+	return new MsSqlSmallIntBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/mssql-core/columns/text.ts b/drizzle-orm/src/mssql-core/columns/text.ts
new file mode 100644
index 0000000000..8427756f43
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/text.ts
@@ -0,0 +1,89 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable, MsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlTextBuilder<TEnum extends [string, ...string[]]> extends MsSqlColumnBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: string;
+		enumValues: TEnum;
+	},
+	{ enumValues: TEnum | undefined; nonUnicode: boolean }
+> {
+	static override readonly [entityKind]: string = 'MsSqlTextBuilder';
+
+	constructor(name: string, config: MsSqlTextConfig<TEnum> & { nonUnicode: boolean }) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MsSqlText');
+		this.config.enumValues = config.enum;
+		this.config.nonUnicode = config.nonUnicode;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlText(table, this.config);
+	}
+}
+
+export class MsSqlText<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends MsSqlColumn<T, { enumValues: T['enumValues'] | undefined; nonUnicode: boolean }>
+{
+	static override readonly [entityKind]: string = 'MsSqlText';
+
+	override readonly enumValues = this.config.enumValues;
+
+	readonly nonUnicode: boolean = this.config.nonUnicode;
+
+	constructor(
+		table: MsSqlTable<any>,
+		config: MsSqlTextBuilder<[string, ...string[]]>['config'],
+	) {
+		super(table, config);
+	}
+
+	getSQLType(): string {
+		return `${this.nonUnicode ? 'n' : ''}text`;
+	}
+}
+
+export type MsSqlTextConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> = {
+	enum?: TEnum;
+};
+
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MsSqlTextConfig<T | Writable<T>>,
+): MsSqlTextBuilder<Writable<T>>;
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config?: MsSqlTextConfig<T | Writable<T>>,
+): MsSqlTextBuilder<Writable<T>>;
+export function text(
+	a?: string | MsSqlTextConfig,
+	b?: MsSqlTextConfig,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlTextConfig>(a, b);
+
+	return new MsSqlTextBuilder(name, { ...config, nonUnicode: false } as any);
+}
+
+export function ntext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MsSqlTextConfig<T | Writable<T>>,
+): MsSqlTextBuilder<Writable<T>>;
+export function ntext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config?: MsSqlTextConfig<T | Writable<T>>,
+): MsSqlTextBuilder<Writable<T>>;
+export function ntext(
+	a?: string | MsSqlTextConfig,
+	b?: MsSqlTextConfig,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlTextConfig>(a, b);
+
+	return new MsSqlTextBuilder(name, { ...config, nonUnicode: true } as any);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/time.ts b/drizzle-orm/src/mssql-core/columns/time.ts
new file mode 100644
index 0000000000..07ff26eaca
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/time.ts
@@ -0,0 +1,108 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlTimeStringBuilder extends MsSqlColumnBuilder<
+	{
+		dataType: 'string time';
+		data: string;
+		driverParam: string | Date;
+	},
+	TimeConfig
+> {
+	static override readonly [entityKind]: string = 'MsSqlTimeBuilder';
+
+	constructor(
+		name: string,
+		config: TimeConfig | undefined,
+	) {
+		super(name, 'string time', 'MsSqlTime');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlTimeString(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlTimeString<T extends ColumnBaseConfig<'string time'>> extends MsSqlColumn<T, TimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlTime';
+
+	readonly fsp: number | undefined = this.config.precision;
+
+	getSQLType(): string {
+		const precision = this.fsp === undefined ? '' : `(${this.fsp})`;
+		return `time${precision}`;
+	}
+
+	override mapFromDriverValue = (value: Date | string | null): string | null => {
+		return typeof value === 'string' ? value : value?.toISOString().split('T')[1]?.split('Z')[0] ?? null;
+	};
+}
+
+export class MsSqlTimeBuilder extends MsSqlColumnBuilder<
+	{
+		dataType: 'object date';
+		data: Date;
+		driverParam: string | Date;
+	},
+	TimeConfig
+> {
+	static override readonly [entityKind]: string = 'MsSqlTimeBuilder';
+
+	constructor(
+		name: string,
+		config: TimeConfig | undefined,
+	) {
+		super(name, 'object date', 'MsSqlTime');
+		this.config.precision = config?.precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlTime(table, this.config);
+	}
+}
+
+export class MsSqlTime<
+	T extends ColumnBaseConfig<'object date'>,
+> extends MsSqlColumn<T, TimeConfig> {
+	static override readonly [entityKind]: string = 'MsSqlTime';
+
+	readonly fsp: number | undefined = this.config.precision;
+
+	getSQLType(): string {
+		const precision = this.fsp === undefined ? '' : `(${this.fsp})`;
+		return `time${precision}`;
+	}
+}
+export type TimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> = {
+	precision?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+	mode?: TMode;
+};
+
+export function time<TMode extends TimeConfig['mode'] & {}>(
+	config?: TimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlTimeStringBuilder : MsSqlTimeBuilder;
+export function time<TMode extends TimeConfig['mode'] & {}>(
+	name: string,
+	config?: TimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MsSqlTimeStringBuilder
+	: MsSqlTimeBuilder;
+export function time(a?: string | TimeConfig, b?: TimeConfig) {
+	const { name, config } = getColumnNameAndConfig<TimeConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MsSqlTimeStringBuilder(name, config);
+	}
+	return new MsSqlTimeBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/tinyint.ts b/drizzle-orm/src/mssql-core/columns/tinyint.ts
new file mode 100644
index 0000000000..84bbf7cbfc
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/tinyint.ts
@@ -0,0 +1,45 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { MsSqlColumnBuilderWithIdentity, MsSqlColumnWithIdentity } from './common.ts';
+
+export class MsSqlTinyIntBuilder extends MsSqlColumnBuilderWithIdentity<{
+	dataType: 'number uint8';
+	data: number;
+	driverParam: number | string;
+}> {
+	static override readonly [entityKind]: string = 'MsSqlTinyIntBuilder';
+
+	constructor(name: string) {
+		super(name, 'number uint8', 'MsSqlTinyInt');
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlTinyInt(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlTinyInt<T extends ColumnBaseConfig<'number uint8'>> extends MsSqlColumnWithIdentity<T> {
+	static override readonly [entityKind]: string = 'MsSqlTinyInt';
+
+	getSQLType(): string {
+		return `tinyint`;
+	}
+
+	override mapFromDriverValue = (value: number | string): number => {
+		if (typeof value === 'string') {
+			return Number(value);
+		}
+		return value;
+	};
+}
+
+export function tinyint(name?: string) {
+	return new MsSqlTinyIntBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/mssql-core/columns/varbinary.ts b/drizzle-orm/src/mssql-core/columns/varbinary.ts
new file mode 100644
index 0000000000..896d8fc55d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/varbinary.ts
@@ -0,0 +1,56 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { getColumnNameAndConfig } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlVarBinaryBuilder extends MsSqlColumnBuilder<{
+	dataType: 'object buffer';
+	data: Buffer;
+	driverParam: Buffer;
+}, MsSqlVarbinaryOptions & { rawLength: MsSqlVarbinaryOptions['length'] | undefined }> {
+	static override readonly [entityKind]: string = 'MsSqlVarBinaryBuilder';
+
+	/** @internal */
+	constructor(name: string, config?: MsSqlVarbinaryOptions) {
+		super(name, 'object buffer', 'MsSqlVarBinary');
+		this.config.length = typeof config?.length === 'number' ? config.length : config?.length === 'max' ? 2147483647 : 1;
+		this.config.rawLength = config?.length;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlVarBinary(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlVarBinary<
+	T extends ColumnBaseConfig<'object buffer'>,
+> extends MsSqlColumn<T, MsSqlVarbinaryOptions & { rawLength: MsSqlVarbinaryOptions['length'] | undefined }> {
+	static override readonly [entityKind]: string = 'MsSqlVarBinary';
+
+	getSQLType(): string {
+		return this.config.rawLength === undefined ? `varbinary` : `varbinary(${this.config.rawLength})`;
+	}
+}
+
+export interface MsSqlVarbinaryOptions {
+	length: number | 'max';
+}
+
+export function varbinary(
+	config?: MsSqlVarbinaryOptions,
+): MsSqlVarBinaryBuilder;
+export function varbinary(
+	name: string,
+	config?: MsSqlVarbinaryOptions,
+): MsSqlVarBinaryBuilder;
+export function varbinary(a?: string | MsSqlVarbinaryOptions, b?: MsSqlVarbinaryOptions) {
+	const { name, config } = getColumnNameAndConfig<MsSqlVarbinaryOptions>(a, b);
+	return new MsSqlVarBinaryBuilder(name, config);
+}
diff --git a/drizzle-orm/src/mssql-core/columns/varchar.ts b/drizzle-orm/src/mssql-core/columns/varchar.ts
new file mode 100644
index 0000000000..4d74f6ef2b
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/columns/varchar.ts
@@ -0,0 +1,180 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlTable } from '~/mssql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MsSqlColumn, MsSqlColumnBuilder } from './common.ts';
+
+export class MsSqlVarCharBuilder<TEnum extends [string, ...string[]]> extends MsSqlColumnBuilder<{
+	dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+	data: TEnum[number];
+	driverParam: number | string;
+	enumValues: TEnum;
+}, MsSqlVarCharConfig<'text', TEnum> & { rawLength: number | 'max' | undefined }> {
+	static override readonly [entityKind]: string = 'MsSqlVarCharBuilder';
+
+	/** @internal */
+	constructor(name: string, config: MsSqlVarCharConfig<'text', TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MsSqlVarChar');
+		this.config.length = typeof config?.length === 'number' ? config.length : config?.length === 'max' ? 2147483647 : 1;
+		this.config.rawLength = config?.length;
+		this.config.enum = config.enum;
+		this.config.nonUnicode = config.nonUnicode;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlVarChar(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlVarChar<T extends ColumnBaseConfig<'string' | 'string enum'>> extends MsSqlColumn<
+	T,
+	MsSqlVarCharConfig<
+		'text',
+		T['enumValues']
+	> & { rawLength: number | 'max' | undefined }
+> {
+	static override readonly [entityKind]: string = 'MsSqlVarChar';
+
+	override readonly enumValues = this.config.enum;
+
+	readonly nonUnicode: boolean = this.config.nonUnicode;
+
+	getSQLType(): string {
+		return this.config.rawLength === undefined
+			? this.nonUnicode ? `nvarchar` : `varchar`
+			: this.nonUnicode
+			? `nvarchar(${this.config.rawLength})`
+			: `varchar(${this.config.rawLength})`;
+	}
+}
+
+export class MsSqlVarCharJsonBuilder extends MsSqlColumnBuilder<{
+	dataType: 'object json';
+	data: unknown;
+	driverParam: string;
+}, { length: number; nonUnicode: boolean; rawLength: number | 'max' | undefined }> {
+	static override readonly [entityKind]: string = 'MsSqlVarCharJsonBuilder';
+
+	/** @internal */
+	constructor(name: string, config: { length: number | 'max' | undefined }) {
+		super(name, 'object json', 'MsSqlNVarCharJson');
+		this.config.length = typeof config?.length === 'number' ? config.length : config?.length === 'max' ? 2147483647 : 1;
+		this.config.rawLength = config?.length;
+		this.config.nonUnicode = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyMsSqlTable<{ name: TTableName }>,
+	) {
+		return new MsSqlVarCharJson(
+			table,
+			this.config,
+		);
+	}
+}
+
+export class MsSqlVarCharJson<T extends ColumnBaseConfig<'object json'>>
+	extends MsSqlColumn<T, { length: number; nonUnicode: boolean; rawLength: number | 'max' | undefined }>
+{
+	static override readonly [entityKind]: string = 'MsSqlVarCharJson';
+
+	getSQLType(): string {
+		return this.config.rawLength === undefined
+			? `nvarchar`
+			: `nvarchar(${this.config.rawLength})`;
+	}
+
+	override mapFromDriverValue = (value: string): T['data'] => {
+		return JSON.parse(value);
+	};
+
+	override mapToDriverValue = (value: T['data']): string => {
+		return JSON.stringify(value);
+	};
+}
+
+export type MsSqlVarCharConfig<
+	TMode extends 'text' | 'json',
+	TEnum extends string[] | readonly string[] | undefined,
+> =
+	& MsSqlVarCharConfigInitial<TMode, TEnum>
+	& {
+		nonUnicode: boolean;
+	};
+
+export type MsSqlVarCharConfigInitial<
+	TMode extends 'text' | 'json' = 'text' | 'json',
+	TEnum extends string[] | readonly string[] | undefined = string[] | readonly string[] | undefined,
+> = TMode extends 'text' ? {
+		mode?: TMode;
+		length?: number | 'max';
+		enum?: TEnum;
+	}
+	: {
+		mode?: TMode;
+		length?: number | 'max';
+	};
+
+export function varchar(): MsSqlVarCharBuilder<[string, ...string[]]>;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MsSqlVarCharConfigInitial<'text', T | Writable<T>>,
+): MsSqlVarCharBuilder<Writable<T>>;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config?: MsSqlVarCharConfigInitial<'text', T | Writable<T>>,
+): MsSqlVarCharBuilder<Writable<T>>;
+export function varchar(
+	a?: string | MsSqlVarCharConfigInitial<'text'>,
+	b?: MsSqlVarCharConfigInitial<'text'>,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlVarCharConfigInitial<'text'>>(a, b);
+
+	return new MsSqlVarCharBuilder(name, {
+		...config,
+		mode: 'text',
+		nonUnicode: false,
+	} as any);
+}
+
+export function nvarchar<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+	TMode extends 'text' | 'json' = 'text' | 'json',
+>(
+	config?: MsSqlVarCharConfigInitial<TMode, T | Writable<T>>,
+): Equal<TMode, 'json'> extends true ? MsSqlVarCharJsonBuilder
+	: MsSqlVarCharBuilder<Writable<T>>;
+export function nvarchar<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+	TMode extends 'text' | 'json' = 'text' | 'json',
+>(
+	name: string,
+	config?: MsSqlVarCharConfigInitial<TMode, T | Writable<T>>,
+): Equal<TMode, 'json'> extends true ? MsSqlVarCharJsonBuilder
+	: MsSqlVarCharBuilder<Writable<T>>;
+export function nvarchar(
+	a?: string | MsSqlVarCharConfigInitial,
+	b?: MsSqlVarCharConfigInitial,
+): any {
+	const { name, config } = getColumnNameAndConfig<MsSqlVarCharConfigInitial>(a, b);
+
+	if (config?.mode === 'json') {
+		return new MsSqlVarCharJsonBuilder(name, {
+			length: config.length,
+		});
+	}
+
+	return new MsSqlVarCharBuilder(name, {
+		length: config?.length,
+		enum: (config as any)?.enum,
+		nonUnicode: true,
+	});
+}
diff --git a/drizzle-orm/src/mssql-core/db.ts b/drizzle-orm/src/mssql-core/db.ts
new file mode 100644
index 0000000000..f5dd6eaded
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/db.ts
@@ -0,0 +1,391 @@
+import type * as V1 from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import type { MsSqlDialect } from './dialect.ts';
+import {
+	MsSqlDeleteBase,
+	MsSqlInsertBuilder,
+	MsSqlSelectBuilder,
+	MsSqlUpdateBuilder,
+	QueryBuilder,
+} from './query-builders/index.ts';
+import { RelationalQueryBuilder } from './query-builders/query.ts';
+import type { SelectedFields } from './query-builders/select.types.ts';
+import type {
+	MsSqlSession,
+	MsSqlTransaction,
+	MsSqlTransactionConfig,
+	PreparedQueryHKTBase,
+	QueryResultHKT,
+	QueryResultKind,
+} from './session.ts';
+import type { WithSubqueryWithSelection } from './subquery.ts';
+import type { MsSqlTable } from './table.ts';
+
+export class MsSqlDatabase<
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TFullSchema extends Record<string, unknown> = {},
+	TSchema extends V1.TablesRelationalConfig = V1.ExtractTablesWithRelations<TFullSchema>,
+> {
+	static readonly [entityKind]: string = 'MsSqlDatabase';
+
+	declare readonly _: {
+		readonly schema: TSchema | undefined;
+		readonly tableNamesMap: Record<string, string>;
+	};
+
+	_query: TFullSchema extends Record<string, never>
+		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
+		: {
+			[K in keyof TSchema]: RelationalQueryBuilder<TPreparedQueryHKT, TSchema, TSchema[K]>;
+		};
+
+	constructor(
+		/** @internal */
+		readonly dialect: MsSqlDialect,
+		/** @internal */
+		readonly session: MsSqlSession<any, any, any, any>,
+		schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+	) {
+		this._ = schema
+			? { schema: schema.schema, tableNamesMap: schema.tableNamesMap }
+			: { schema: undefined, tableNamesMap: {} };
+		this._query = {} as typeof this['_query'];
+		if (this._.schema) {
+			for (const [tableName, columns] of Object.entries(this._.schema)) {
+				(this._query as MsSqlDatabase<TQueryResult, TPreparedQueryHKT, Record<string, any>>['_query'])[tableName] =
+					new RelationalQueryBuilder(
+						schema!.fullSchema,
+						this._.schema,
+						this._.tableNamesMap,
+						schema!.fullSchema[tableName] as MsSqlTable,
+						columns,
+						dialect,
+						session,
+					);
+			}
+		}
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with<TAlias extends string>(alias: TAlias) {
+		const self = this;
+
+		return {
+			as<TSelection extends ColumnsSelection>(
+				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
+			): WithSubqueryWithSelection<TSelection, TAlias> {
+				if (typeof qb === 'function') {
+					qb = qb(new QueryBuilder(self.dialect));
+				}
+
+				return new Proxy(
+					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
+					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+				) as WithSubqueryWithSelection<TSelection, TAlias>;
+			},
+		};
+	}
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		function select(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+		function select(fields?: SelectedFields): MsSqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+			return new MsSqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			});
+		}
+
+		function selectDistinct(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+		function selectDistinct(
+			fields?: SelectedFields,
+		): MsSqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+			return new MsSqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			});
+		}
+
+		return { select, selectDistinct };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = await db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+	select<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+	select(fields?: SelectedFields): MsSqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+		return new MsSqlSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * await db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * await db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+	selectDistinct(fields?: SelectedFields): MsSqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+		return new MsSqlSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		});
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * await db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 * ```
+	 */
+	update<TTable extends MsSqlTable>(table: TTable): MsSqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MsSqlUpdateBuilder(table, this.session, this.dialect);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * await db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 * ```
+	 */
+	insert<TTable extends MsSqlTable>(table: TTable): MsSqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MsSqlInsertBuilder(table, this.session, this.dialect);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * await db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 * ```
+	 */
+	delete<TTable extends MsSqlTable>(table: TTable): MsSqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MsSqlDeleteBase(table, this.session, this.dialect);
+	}
+
+	execute<T extends { [column: string]: any } | { [column: string]: any }[]>(
+		query: SQLWrapper | string,
+	): Promise<QueryResultKind<TQueryResult, T>> {
+		return this.session.execute((typeof query === 'string' ? sql.raw(query) : query).getSQL());
+	}
+
+	transaction<T>(
+		transaction: (
+			tx: MsSqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>,
+			config?: MsSqlTransactionConfig,
+		) => Promise<T>,
+		config?: MsSqlTransactionConfig,
+	): Promise<T> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type MySQLWithReplicas<Q> = Q & { $primary: Q };
+
+export const withReplicas = <
+	HKT extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+	Q extends MsSqlDatabase<
+		HKT,
+		TPreparedQueryHKT,
+		TFullSchema,
+		TSchema extends Record<string, unknown> ? V1.ExtractTablesWithRelations<TFullSchema> : TSchema
+	>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): MySQLWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any, any]) => primary.transaction(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		with: $with,
+		get _query() {
+			return getReplica(replicas)._query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/mssql-core/dialect.ts b/drizzle-orm/src/mssql-core/dialect.ts
new file mode 100644
index 0000000000..6b1bf7889c
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/dialect.ts
@@ -0,0 +1,1045 @@
+import * as V1 from '~/_relations.ts';
+import {
+	aliasedTable,
+	aliasedTableColumn,
+	getOriginalColumnFromAlias,
+	mapColumnsInAliasedSQLToAlias,
+	mapColumnsInSQLToAlias,
+} from '~/alias.ts';
+import { Column } from '~/column.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import { Param, type Query, SQL, sql, type SQLChunk, View } from '~/sql/sql.ts';
+import { Subquery } from '~/subquery.ts';
+import { getTableName, getTableUniqueName, Table } from '~/table.ts';
+import { upgradeIfNeeded } from '~/up-migrations/mssql.ts';
+import type { UpdateSet } from '~/utils.ts';
+import { and, DrizzleError, eq, type Name, ViewBaseConfig } from '../index.ts';
+import { MsSqlColumn } from './columns/common.ts';
+import type { MsSqlDeleteConfig } from './query-builders/delete.ts';
+import type { MsSqlInsertConfig } from './query-builders/insert.ts';
+import type { MsSqlSelectConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
+import type { MsSqlUpdateConfig } from './query-builders/update.ts';
+import type { MsSqlSession } from './session.ts';
+import { MsSqlTable } from './table.ts';
+import { MsSqlViewBase } from './view-base.ts';
+
+// Will add codecs here, do not remove
+export interface MsSqlDialectConfig {}
+
+export class MsSqlDialect {
+	static readonly [entityKind]: string = 'MsSqlDialect';
+
+	constructor(_config?: MsSqlDialectConfig) {}
+
+	async migrate(
+		migrations: MigrationMeta[],
+		session: MsSqlSession,
+		config: MigrationConfig,
+	): Promise<void | MigratorInitFailResponse> {
+		const migrationsSchema = typeof config === 'string'
+			? 'drizzle'
+			: (config.migrationsSchema ?? 'drizzle');
+
+		const migrationSchemaCreate = sql`
+			IF NOT EXISTS (
+				SELECT 1 FROM sys.schemas WHERE name = ${migrationsSchema}
+			)
+			EXEC(\'CREATE SCHEMA ${sql.identifier(migrationsSchema)}\')
+		`;
+
+		await session.execute(migrationSchemaCreate);
+
+		const migrationsTable = typeof config === 'string'
+			? '__drizzle_migrations'
+			: (config.migrationsTable ?? '__drizzle_migrations');
+
+		// Detect DB version and upgrade table schema if needed
+		const { newDb } = await upgradeIfNeeded(
+			migrationsSchema,
+			migrationsTable,
+			session,
+			migrations,
+		);
+
+		if (newDb) {
+			const migrationTableCreate = sql`
+			IF NOT EXISTS (
+				SELECT 1 FROM INFORMATION_SCHEMA.TABLES 
+				WHERE TABLE_NAME = ${migrationsTable} AND TABLE_SCHEMA = ${migrationsSchema}
+			)
+			CREATE TABLE ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
+				id bigint identity PRIMARY KEY,
+				hash text NOT NULL,
+				created_at bigint,
+				name text,
+				applied_at datetime2 NOT NULL DEFAULT GETUTCDATE()
+			)
+		`;
+
+			await session.execute(migrationTableCreate);
+		}
+
+		const dbMigrations = (
+			await session.execute<{
+				recordset: {
+					id: number;
+					hash: string;
+					created_at: string;
+					name: string | null;
+				}[];
+			}>(
+				sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${
+					sql.identifier(
+						migrationsTable,
+					)
+				}`,
+			)
+		).recordset;
+
+		if (typeof config === 'object' && config.init) {
+			if (dbMigrations.length > 0) {
+				return { exitCode: 'databaseMigrations' as const };
+			}
+
+			if (migrations.length > 1) {
+				return { exitCode: 'localMigrations' as const };
+			}
+
+			const [migration] = migrations;
+
+			if (!migration) return;
+
+			await session.execute(
+				sql`insert into ${sql.identifier(migrationsSchema)}.${
+					sql.identifier(
+						migrationsTable,
+					)
+				} ([hash], [created_at], [name]) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+			);
+
+			return;
+		}
+
+		const migrationsToRun = getMigrationsToRun({
+			localMigrations: migrations,
+			dbMigrations,
+		});
+		await session.transaction(async (tx) => {
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					await tx.execute(sql.raw(stmt));
+				}
+				await tx.execute(
+					sql`insert into ${sql.identifier(migrationsSchema)}.${
+						sql.identifier(
+							migrationsTable,
+						)
+					} ([hash], [created_at], [name]) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+				);
+			}
+		});
+	}
+
+	escapeName(name: string): string {
+		return `[${name.replace(/\]/g, ']]')}]`;
+	}
+
+	escapeParam(_num: number): string {
+		return `@par${_num}`;
+	}
+
+	escapeString(str: string): string {
+		return `'${str.replace(/'/g, "''")}'`;
+	}
+
+	buildDeleteQuery({ table, where, output }: MsSqlDeleteConfig): SQL {
+		const outputSql = output
+			? sql` output ${this.buildSelectionOutput(output, { type: 'DELETED' })}`
+			: undefined;
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		return sql`delete from ${table}${outputSql}${whereSql}`;
+	}
+
+	buildUpdateSet(table: MsSqlTable, set: UpdateSet): SQL {
+		const tableColumns = table[Table.Symbol.Columns];
+
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
+		);
+
+		const setSize = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
+
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
+
+				if (i < setSize - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
+		// const setEntries = Object.entries(set);
+		//
+		// const setSize = setEntries.length;
+		// return sql.join(
+		// 	setEntries
+		// 		.flatMap(([colName, value], i): SQL[] => {
+		// 			const col: MsSqlColumn = table[Table.Symbol.Columns][colName]!;
+		// 			const res = sql`${sql.identifier(col.name)} = ${value}`;
+		// 			if (i < setSize - 1) {
+		// 				return [res, sql.raw(', ')];
+		// 			}
+		// 			return [res];
+		// 		}),
+		// );
+	}
+
+	buildUpdateQuery({ table, set, where, output }: MsSqlUpdateConfig): SQL {
+		const setSql = this.buildUpdateSet(table, set);
+
+		const outputSql = sql``;
+
+		if (output) {
+			outputSql.append(sql` output `);
+
+			if (output.inserted) {
+				outputSql.append(
+					this.buildSelectionOutput(output.inserted, { type: 'INSERTED' }),
+				);
+			}
+
+			if (output.deleted) {
+				if (output.inserted) outputSql.append(sql`, `); // add space if both are present
+				outputSql.append(
+					this.buildSelectionOutput(output.deleted, { type: 'DELETED' }),
+				);
+			}
+		}
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		return sql`update ${table} set ${setSql}${outputSql}${whereSql}`;
+	}
+
+	/**
+	 * Builds selection SQL with provided fields/expressions
+	 *
+	 * Examples:
+	 *
+	 * `select <selection> from`
+	 *
+	 * `insert ... returning <selection>`
+	 *
+	 * If `isSingleTable` is true, then columns won't be prefixed with table name
+	 */
+	private buildSelection(
+		fields: SelectedFieldsOrdered,
+		{ isSingleTable = false }: { isSingleTable?: boolean } = {},
+	): SQL {
+		const columnsLen = fields.length;
+
+		const chunks = fields.flatMap(({ field }, i) => {
+			const chunk: SQLChunk[] = [];
+
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					if (!isSingleTable && field.origin !== undefined) {
+						chunk.push(sql.identifier(field.origin), sql.raw('.'));
+					}
+					chunk.push(sql.identifier(field.fieldAlias));
+				} else {
+					const query = field.sql;
+
+					if (isSingleTable) {
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, Column)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
+						);
+
+						chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+					} else {
+						chunk.push(query);
+					}
+
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, Column)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
+
+					chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+				} else {
+					chunk.push(query);
+				}
+			} else if (is(field, Column)) {
+				if (isSingleTable) {
+					chunk.push(
+						field.isAlias
+							? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}`
+							: sql.identifier(field.name),
+					);
+				} else {
+					chunk.push(
+						field.isAlias
+							? sql`${getOriginalColumnFromAlias(field)} as ${field}`
+							: field,
+					);
+				}
+			} else if (is(field, Subquery)) {
+				if (!field._.isWith) {
+					chunk.push(sql`(${field._.sql}) ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(field);
+				}
+			}
+
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
+
+		return sql.join(chunks);
+	}
+
+	private buildSelectionOutput(
+		fields: SelectedFieldsOrdered,
+		{ type }: { type: 'INSERTED' | 'DELETED' },
+	): SQL {
+		const columnsLen = fields.length;
+
+		const chunks = fields.flatMap(({ field }, i) => {
+			const chunk: SQLChunk[] = [];
+
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					chunk.push(
+						sql.join([sql.raw(`${type}.`), sql.identifier(field.fieldAlias)]),
+					);
+				} else {
+					const query = field.sql;
+
+					chunk.push(
+						new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, MsSqlColumn)) {
+									return sql.join([
+										sql.raw(`${type}.`),
+										sql.identifier(c.name),
+									]);
+								}
+								return c;
+							}),
+						),
+					);
+
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				chunk.push(
+					new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, MsSqlColumn)) {
+								return sql.join([
+									sql.raw(`${type}.`),
+									sql.identifier(c.name),
+								]);
+							}
+							return c;
+						}),
+					),
+				);
+			} else if (is(field, Column)) {
+				chunk.push(
+					sql.join([
+						sql.raw(`${type}.`),
+						field.isAlias
+							? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}`
+							: sql.identifier(field.name),
+					]),
+				);
+			}
+
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
+
+		return sql.join(chunks);
+	}
+
+	buildSelectQuery({
+		withList,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		fetch,
+		for: _for,
+		top,
+		offset,
+		distinct,
+		setOperators,
+	}: MsSqlSelectConfig): SQL {
+		if (!fieldsFlat) {
+			throw new Error('Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation');
+		}
+		const fieldsList = fieldsFlat;
+		for (const f of fieldsList) {
+			if (
+				is(f.field, Column)
+				&& getTableName(f.field.table)
+					!== (is(table, Subquery)
+						? table._.alias
+						: is(table, MsSqlViewBase)
+						? table[ViewBaseConfig].name
+						: is(table, SQL)
+						? undefined
+						: getTableName(table))
+				&& !((table) =>
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
+					))(f.field.table)
+			) {
+				const tableName = getTableName(f.field.table);
+				throw new Error(
+					`Your "${
+						f.path.join(
+							'->',
+						)
+					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
+				);
+			}
+		}
+
+		const isSingleTable = !joins || joins.length === 0;
+
+		let withSql: SQL | undefined;
+		if (withList?.length) {
+			const withSqlChunks = [sql`with `];
+			for (const [i, w] of withList.entries()) {
+				withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);
+				if (i < withList.length - 1) {
+					withSqlChunks.push(sql`, `);
+				}
+			}
+			withSqlChunks.push(sql` `);
+			withSql = sql.join(withSqlChunks);
+		}
+
+		const distinctSql = distinct ? sql` distinct` : undefined;
+
+		const topSql = top ? sql` top(${top})` : undefined;
+
+		const selection = this.buildSelection(fieldsList, { isSingleTable });
+
+		const tableSql = (() => {
+			if (
+				is(table, Table)
+				&& table[Table.Symbol.OriginalName] !== table[Table.Symbol.Name]
+			) {
+				let fullName = sql`${sql.identifier(table[Table.Symbol.OriginalName])} ${
+					sql.identifier(
+						table[Table.Symbol.Name],
+					)
+				}`;
+				if (table[Table.Symbol.Schema]) {
+					fullName = sql`${sql.identifier(table[Table.Symbol.Schema]!)}.${fullName}`;
+				}
+				return fullName;
+			}
+
+			if (is(table, View) && table[ViewBaseConfig].isAlias) {
+				let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+				if (table[ViewBaseConfig].schema) {
+					fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+				}
+				return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+			}
+
+			return table;
+		})();
+
+		const joinsArray: SQL[] = [];
+
+		if (joins) {
+			for (const [index, joinMeta] of joins.entries()) {
+				if (index === 0) {
+					joinsArray.push(sql` `);
+				}
+				const table = joinMeta.table;
+				const lateralSql = joinMeta.lateral ? sql` lateral` : undefined;
+
+				if (is(table, MsSqlTable)) {
+					const tableName = table[MsSqlTable.Symbol.Name];
+					const tableSchema = table[MsSqlTable.Symbol.Schema];
+					const origTableName = table[MsSqlTable.Symbol.OriginalName];
+					const alias = tableName === origTableName ? undefined : joinMeta.alias;
+					joinsArray.push(
+						sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
+							tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined
+						}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`,
+					);
+				} else if (is(table, View)) {
+					const viewName = table[ViewBaseConfig].name;
+					const viewSchema = table[ViewBaseConfig].schema;
+					const origViewName = table[ViewBaseConfig].originalName;
+					const alias = viewName === origViewName ? undefined : joinMeta.alias;
+					joinsArray.push(
+						sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
+							viewSchema ? sql`${sql.identifier(viewSchema)}.` : undefined
+						}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`,
+					);
+				} else {
+					joinsArray.push(
+						sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table} on ${joinMeta.on}`,
+					);
+				}
+				if (index < joins.length - 1) {
+					joinsArray.push(sql` `);
+				}
+			}
+		}
+
+		const joinsSql = sql.join(joinsArray);
+
+		const whereSql = where ? sql` where ${where}` : undefined;
+
+		const havingSql = having ? sql` having ${having}` : undefined;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			orderBySql = sql` order by ${sql.join(orderBy, sql`, `)}`;
+		}
+
+		let groupBySql;
+		if (groupBy && groupBy.length > 0) {
+			groupBySql = sql` group by ${sql.join(groupBy, sql`, `)}`;
+		}
+
+		const offsetSql = offset === undefined ? undefined : sql` offset ${offset} rows`;
+
+		const fetchSql = fetch === undefined ? undefined : sql` fetch next ${fetch} rows only`;
+
+		let forSQL: SQL | undefined;
+		if (_for && _for.mode === 'json') {
+			forSQL = sql` for json ${sql.raw(_for.type)}${
+				_for.options?.root
+					? sql` root(${sql.identifier(_for.options.root)})`
+					: undefined
+			}${_for.options?.includeNullValues ? sql` include_null_values` : undefined}${
+				_for.options?.withoutArrayWrapper
+					? sql` without_array_wrapper`
+					: undefined
+			}`;
+		}
+
+		const finalQuery =
+			sql`${withSql}select${distinctSql}${topSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${offsetSql}${fetchSql}${forSQL}`;
+
+		if (setOperators.length > 0) {
+			return this.buildSetOperations(finalQuery, setOperators);
+		}
+
+		return finalQuery;
+	}
+
+	buildSetOperations(
+		leftSelect: SQL,
+		setOperators: MsSqlSelectConfig['setOperators'],
+	): SQL {
+		const [setOperator, ...rest] = setOperators;
+
+		if (!setOperator) {
+			throw new Error('Cannot pass undefined values to any set operator');
+		}
+
+		if (rest.length === 0) {
+			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		}
+
+		// Some recursive magic here
+		return this.buildSetOperations(
+			this.buildSetOperationQuery({ leftSelect, setOperator }),
+			rest,
+		);
+	}
+
+	buildSetOperationQuery({
+		leftSelect,
+		setOperator: { type, isAll, rightSelect, fetch, orderBy, offset },
+	}: {
+		leftSelect: SQL;
+		setOperator: MsSqlSelectConfig['setOperators'][number];
+	}): SQL {
+		const leftChunk = sql`(${leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			const orderByValues: (SQL<unknown> | Name)[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MsSql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const orderByUnit of orderBy) {
+				if (is(orderByUnit, MsSqlColumn)) {
+					orderByValues.push(sql.identifier(orderByUnit.name));
+				} else if (is(orderByUnit, SQL)) {
+					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
+						const chunk = orderByUnit.queryChunks[i];
+
+						if (is(chunk, MsSqlColumn)) {
+							orderByUnit.queryChunks[i] = sql.identifier(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${orderByUnit}`);
+				} else {
+					orderByValues.push(sql`${orderByUnit}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const offsetSql = offset === undefined ? undefined : sql` offset ${offset} rows`;
+
+		const fetchSql = fetch === undefined ? undefined : sql` fetch next ${fetch} rows only`;
+
+		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${offsetSql}${fetchSql}`;
+	}
+
+	buildInsertQuery({ table, values, output }: MsSqlInsertConfig): SQL {
+		// const isSingleValue = values.length === 1;
+		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
+		const columns: Record<string, MsSqlColumn> = table[Table.Symbol.Columns];
+		const colEntries: [string, MsSqlColumn][] = Object.entries(columns).filter(
+			([_, col]) => !col.shouldDisableInsert(),
+		);
+
+		const insertOrder = colEntries.map(([, column]) => sql.identifier(column.name));
+
+		for (const [valueIndex, value] of values.entries()) {
+			const valueList: (SQLChunk | SQL)[] = [];
+			for (const [fieldName, col] of colEntries) {
+				const colValue = value[fieldName];
+				if (
+					colValue === undefined
+					|| (is(colValue, Param) && colValue.value === undefined)
+				) {
+					if (col.defaultFn !== undefined) {
+						const defaultFnResult = col.defaultFn();
+						const defaultValue = is(defaultFnResult, SQL)
+							? defaultFnResult
+							: sql.param(defaultFnResult, col);
+						valueList.push(defaultValue);
+					} else if (!col.default && col.onUpdateFn !== undefined) {
+						const onUpdateFnResult = col.onUpdateFn();
+						const newValue = is(onUpdateFnResult, SQL)
+							? onUpdateFnResult
+							: sql.param(onUpdateFnResult, col);
+						valueList.push(newValue);
+					} else {
+						valueList.push(sql`default`);
+					}
+				} else {
+					valueList.push(colValue);
+				}
+			}
+			valuesSqlList.push(valueList);
+			if (valueIndex < values.length - 1) {
+				valuesSqlList.push(sql`, `);
+			}
+		}
+
+		const valuesSql = insertOrder.length === 0 ? undefined : sql.join(valuesSqlList);
+
+		const outputSql = output
+			? sql` output ${this.buildSelectionOutput(output, { type: 'INSERTED' })}`
+			: undefined;
+
+		return sql`insert into ${table} ${
+			insertOrder.length === 0 ? sql`default` : insertOrder
+		}${outputSql} values ${valuesSql}`;
+	}
+
+	sqlToQuery(
+		sql: SQL,
+		invokeSource?: 'indexes' | 'mssql-check' | 'mssql-view-with-schemabinding',
+	): Query {
+		const res = sql.toQuery({
+			escapeName: this.escapeName,
+			escapeParam: this.escapeParam,
+			escapeString: this.escapeString,
+			invokeSource,
+		});
+		return res;
+	}
+
+	buildRelationalQuery({
+		fullSchema,
+		schema,
+		tableNamesMap,
+		table,
+		tableConfig,
+		queryConfig: config,
+		tableAlias,
+		nestedQueryRelation,
+		joinOn,
+	}: {
+		fullSchema: Record<string, unknown>;
+		schema: V1.TablesRelationalConfig;
+		tableNamesMap: Record<string, string>;
+		table: MsSqlTable;
+		tableConfig: V1.TableRelationalConfig;
+		queryConfig: true | V1.DBQueryConfig<'many', true>;
+		tableAlias: string;
+		nestedQueryRelation?: V1.Relation;
+		joinOn?: SQL;
+	}): V1.BuildRelationalQueryResult<MsSqlTable, MsSqlColumn> {
+		let selection: V1.BuildRelationalQueryResult<
+			MsSqlTable,
+			MsSqlColumn
+		>['selection'] = [];
+		let limit,
+			offset,
+			orderBy: MsSqlSelectConfig['orderBy'] = [],
+			where;
+
+		if (config === true) {
+			const selectionEntries = Object.entries(tableConfig.columns);
+			selection = selectionEntries.map(([key, value]) => ({
+				dbKey: value.name,
+				tsKey: key,
+				field: aliasedTableColumn(value as MsSqlColumn, tableAlias),
+				relationTableTsKey: undefined,
+				isJson: false,
+				selection: [],
+			}));
+		} else {
+			const aliasedColumns = Object.fromEntries(
+				Object.entries(tableConfig.columns).map(([key, value]) => [
+					key,
+					aliasedTableColumn(value, tableAlias),
+				]),
+			);
+
+			if (config.where) {
+				const whereSql = typeof config.where === 'function'
+					? config.where(aliasedColumns, V1.getOperators())
+					: config.where;
+				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+			}
+
+			const fieldsSelection: {
+				tsKey: string;
+				value: MsSqlColumn | SQL.Aliased;
+			}[] = [];
+			let selectedColumns: string[] = [];
+
+			// Figure out which columns to select
+			if (config.columns) {
+				let isIncludeMode = false;
+
+				for (const [field, value] of Object.entries(config.columns)) {
+					if (value === undefined) {
+						continue;
+					}
+
+					if (field in tableConfig.columns) {
+						if (!isIncludeMode && value === true) {
+							isIncludeMode = true;
+						}
+						selectedColumns.push(field);
+					}
+				}
+
+				if (selectedColumns.length > 0) {
+					selectedColumns = isIncludeMode
+						? selectedColumns.filter((c) => config.columns?.[c] === true)
+						: Object.keys(tableConfig.columns).filter(
+							(key) => !selectedColumns.includes(key),
+						);
+				}
+			} else {
+				// Select all columns if selection is not specified
+				selectedColumns = Object.keys(tableConfig.columns);
+			}
+
+			for (const field of selectedColumns) {
+				const column = tableConfig.columns[field]! as MsSqlColumn;
+				fieldsSelection.push({ tsKey: field, value: column });
+			}
+
+			let selectedRelations: {
+				tsKey: string;
+				queryConfig: true | V1.DBQueryConfig<'many', false>;
+				relation: V1.Relation;
+			}[] = [];
+
+			// Figure out which relations to select
+			if (config.with) {
+				selectedRelations = Object.entries(config.with)
+					.filter(
+						(
+							entry,
+						): entry is [(typeof entry)[0], NonNullable<(typeof entry)[1]>] => !!entry[1],
+					)
+					.map(([tsKey, queryConfig]) => ({
+						tsKey,
+						queryConfig,
+						relation: tableConfig.relations[tsKey]!,
+					}));
+			}
+
+			let extras;
+
+			// Figure out which extras to select
+			if (config.extras) {
+				extras = typeof config.extras === 'function'
+					? config.extras(aliasedColumns, { sql })
+					: config.extras;
+				for (const [tsKey, value] of Object.entries(extras)) {
+					fieldsSelection.push({
+						tsKey,
+						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
+					});
+				}
+			}
+
+			// Transform `fieldsSelection` into `selection`
+			// `fieldsSelection` shouldn't be used after this point
+			for (const { tsKey, value } of fieldsSelection) {
+				selection.push({
+					dbKey: is(value, SQL.Aliased)
+						? value.fieldAlias
+						: tableConfig.columns[tsKey]!.name,
+					tsKey,
+					field: is(value, Column)
+						? aliasedTableColumn(value, tableAlias)
+						: value,
+					relationTableTsKey: undefined,
+					isJson: false,
+					selection: [],
+				});
+			}
+
+			let orderByOrig = typeof config.orderBy === 'function'
+				? config.orderBy(aliasedColumns, V1.getOrderByOperators())
+				: (config.orderBy ?? []);
+			if (!Array.isArray(orderByOrig)) {
+				orderByOrig = [orderByOrig];
+			}
+			orderBy = orderByOrig.map((orderByValue) => {
+				if (is(orderByValue, Column)) {
+					return aliasedTableColumn(orderByValue, tableAlias) as MsSqlColumn;
+				}
+				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+			});
+
+			limit = config.limit;
+			offset = config.offset;
+
+			// Process all relations
+			for (
+				const {
+					tsKey: selectedRelationTsKey,
+					queryConfig: selectedRelationConfigValue,
+					relation,
+				} of selectedRelations
+			) {
+				const normalizedRelation = V1.normalizeRelation(
+					schema,
+					tableNamesMap,
+					relation,
+				);
+				const relationTableName = getTableUniqueName(relation.referencedTable);
+				const relationTableTsName = tableNamesMap[relationTableName]!;
+				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+				const joinOn = and(
+					...normalizedRelation.fields.map((field, i) =>
+						eq(
+							aliasedTableColumn(
+								normalizedRelation.references[i]!,
+								relationTableAlias,
+							),
+							aliasedTableColumn(field, tableAlias),
+						)
+					),
+				);
+				const builtRelation = this.buildRelationalQuery({
+					fullSchema,
+					schema,
+					tableNamesMap,
+					table: fullSchema[relationTableTsName] as MsSqlTable,
+					tableConfig: schema[relationTableTsName]!,
+					queryConfig: is(relation, V1.One)
+						? selectedRelationConfigValue === true
+							? { limit: 1 }
+							: { ...selectedRelationConfigValue, limit: 1 }
+						: selectedRelationConfigValue,
+					tableAlias: relationTableAlias,
+					joinOn,
+					nestedQueryRelation: relation,
+				});
+				let fieldSql = sql`(${builtRelation.sql} for json auto, include_null_values)${
+					nestedQueryRelation
+						? sql` as ${sql.identifier(relationTableAlias)}`
+						: undefined
+				}`;
+				if (is(relation, V1.Many)) {
+					fieldSql = sql`${fieldSql}`;
+				}
+				const field = fieldSql.as(selectedRelationTsKey);
+				selection.push({
+					dbKey: selectedRelationTsKey,
+					tsKey: selectedRelationTsKey,
+					field,
+					relationTableTsKey: relationTableTsName,
+					isJson: true,
+					selection: builtRelation.selection,
+				});
+			}
+		}
+
+		if (selection.length === 0) {
+			throw new DrizzleError({
+				message:
+					`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
+			});
+		}
+
+		let result;
+
+		where = and(joinOn, where);
+
+		if (nestedQueryRelation) {
+			let field = sql`${
+				sql.join(
+					selection.map((sel) => {
+						return is(sel.field, MsSqlColumn)
+							? sql.identifier(sel.field.name)
+							: is(sel.field, SQL.Aliased)
+							? sel.isJson
+								? sel.field.sql
+								: sql`${sel.field.sql} as ${sql.identifier(sel.field.fieldAlias)}`
+							: sel.field;
+					}),
+					sql`, `,
+				)
+			}`;
+			if (is(nestedQueryRelation, V1.Many)) {
+				field = sql`${field}`;
+			}
+			const nestedSelection = [
+				{
+					dbKey: 'data',
+					tsKey: 'data',
+					field,
+					isJson: true,
+					relationTableTsKey: tableConfig.tsName,
+					selection,
+				},
+			];
+
+			result = aliasedTable(table, tableAlias);
+
+			const top = offset ? undefined : (limit ?? undefined);
+			const fetch = offset && limit ? limit : undefined;
+
+			// Mssql required order by to be present in the query if using offset and fetch(limit)
+			// With order by 1, the query will be ordered by the first column in the selection
+			if (orderBy.length === 0 && offset !== undefined && fetch !== undefined) {
+				orderBy = [sql`1`];
+			}
+
+			result = this.buildSelectQuery({
+				table: is(result, MsSqlTable)
+					? result
+					: new Subquery(result, {}, tableAlias),
+				fields: {},
+				fieldsFlat: nestedSelection.map(({ field }) => ({
+					path: [],
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
+				})),
+				where,
+				top,
+				offset,
+				fetch,
+				orderBy,
+				setOperators: [],
+			});
+		} else {
+			const top = offset ? undefined : (limit ?? undefined);
+			const fetch = offset && limit ? limit : undefined;
+
+			if (orderBy.length === 0 && offset !== undefined && fetch !== undefined) {
+				orderBy = [sql`1`];
+			}
+			result = this.buildSelectQuery({
+				table: aliasedTable(table, tableAlias),
+				fields: {},
+				fieldsFlat: selection.map(({ field }) => ({
+					path: [],
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
+				})),
+				where,
+				top,
+				offset,
+				fetch,
+				orderBy,
+				setOperators: [],
+			});
+		}
+
+		return {
+			tableTsKey: tableConfig.tsName,
+			sql: result,
+			selection,
+		};
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/expressions.ts b/drizzle-orm/src/mssql-core/expressions.ts
new file mode 100644
index 0000000000..9ec4d5c1e1
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/expressions.ts
@@ -0,0 +1,31 @@
+import { bindIfParam } from '~/sql/expressions/index.ts';
+import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
+import type { MsSqlColumn } from './columns/index.ts';
+
+export * from '~/sql/expressions/index.ts';
+
+// type ConcatValue = string | number | Placeholder | SQLWrapper;
+//
+// export function concat(...values: [ConcatValue, ConcatValue, ...ConcatValue[]]): SQL<string> {
+// 	return sql.join(values.map((value) => sql`${value}`), sql`, `) as SQL<string>;
+// }
+
+export function concat(column: MsSqlColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
+	return sql`${column} || ${bindIfParam(value, column)}`;
+}
+
+export function substring(
+	column: MsSqlColumn | SQL.Aliased,
+	{ from, for: _for }: { from?: number | Placeholder | SQLWrapper; for?: number | Placeholder | SQLWrapper },
+): SQL {
+	const chunks: SQLChunk[] = [sql`substring(`, column];
+	if (from !== undefined) {
+		chunks.push(sql` from `, bindIfParam(from, column));
+	}
+	if (_for !== undefined) {
+		chunks.push(sql` for `, bindIfParam(_for, column));
+	}
+	chunks.push(sql`)`);
+	return sql.join(chunks);
+}
diff --git a/drizzle-orm/src/mssql-core/foreign-keys.ts b/drizzle-orm/src/mssql-core/foreign-keys.ts
new file mode 100644
index 0000000000..0ef560604d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/foreign-keys.ts
@@ -0,0 +1,121 @@
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlColumn, MsSqlColumn } from './columns/index.ts';
+import type { MsSqlTable } from './table.ts';
+
+export type UpdateDeleteAction = 'cascade' | 'no action' | 'set null' | 'set default';
+
+export type Reference = () => {
+	readonly name?: string;
+	readonly columns: MsSqlColumn[];
+	readonly foreignTable: MsSqlTable;
+	readonly foreignColumns: MsSqlColumn[];
+};
+
+export class ForeignKeyBuilder {
+	static readonly [entityKind]: string = 'MsSqlForeignKeyBuilder';
+
+	/** @internal */
+	reference: Reference;
+
+	/** @internal */
+	_onUpdate: UpdateDeleteAction | undefined;
+
+	/** @internal */
+	_onDelete: UpdateDeleteAction | undefined;
+
+	constructor(
+		config: () => {
+			name?: string;
+			columns: MsSqlColumn[];
+			foreignColumns: MsSqlColumn[];
+		},
+		actions?: {
+			onUpdate?: UpdateDeleteAction;
+			onDelete?: UpdateDeleteAction;
+		} | undefined,
+	) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as MsSqlTable, foreignColumns };
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+
+	onUpdate(action: UpdateDeleteAction): this {
+		this._onUpdate = action;
+		return this;
+	}
+
+	onDelete(action: UpdateDeleteAction): this {
+		this._onDelete = action;
+		return this;
+	}
+
+	/** @internal */
+	build(table: MsSqlTable): ForeignKey {
+		return new ForeignKey(table, this);
+	}
+}
+
+export type AnyForeignKeyBuilder = ForeignKeyBuilder;
+
+export class ForeignKey {
+	static readonly [entityKind]: string = 'MsSqlForeignKey';
+
+	readonly reference: Reference;
+	readonly onUpdate: UpdateDeleteAction | undefined;
+	readonly onDelete: UpdateDeleteAction | undefined;
+
+	constructor(readonly table: MsSqlTable, builder: ForeignKeyBuilder) {
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+	}
+
+	getName() {
+		const { name } = this.reference();
+		return name;
+	}
+
+	isNameExplicit() {
+		return !!this.reference().name;
+	}
+}
+
+type ColumnsWithTable<
+	TTableName extends string,
+	TColumns extends MsSqlColumn[],
+> = { [Key in keyof TColumns]: AnyMsSqlColumn<{ tableName: TTableName }> };
+
+export type GetColumnsTable<TColumns extends MsSqlColumn | MsSqlColumn[]> = (
+	TColumns extends MsSqlColumn ? TColumns
+		: TColumns extends MsSqlColumn[] ? TColumns[number]
+		: never
+) extends AnyMsSqlColumn<{ tableName: infer TTableName extends string }> ? TTableName
+	: never;
+
+export function foreignKey<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends [AnyMsSqlColumn<{ tableName: TTableName }>, ...AnyMsSqlColumn<{ tableName: TTableName }>[]],
+>(
+	config: {
+		name?: string;
+		columns: TColumns;
+		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+	},
+): ForeignKeyBuilder {
+	function mappedConfig() {
+		const { name, columns, foreignColumns } = config;
+		return {
+			name,
+			columns,
+			foreignColumns,
+		};
+	}
+
+	return new ForeignKeyBuilder(mappedConfig);
+}
diff --git a/drizzle-orm/src/mssql-core/index.ts b/drizzle-orm/src/mssql-core/index.ts
new file mode 100644
index 0000000000..52b1a9e1cc
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/index.ts
@@ -0,0 +1,18 @@
+export * from './alias.ts';
+export * from './casing.ts';
+export * from './checks.ts';
+export * from './columns/index.ts';
+export * from './db.ts';
+export * from './dialect.ts';
+export * from './foreign-keys.ts';
+export * from './indexes.ts';
+export * from './primary-keys.ts';
+export * from './query-builders/index.ts';
+export * from './schema.ts';
+export * from './session.ts';
+export * from './subquery.ts';
+export * from './table.ts';
+export * from './unique-constraint.ts';
+export * from './utils.ts';
+export * from './view-common.ts';
+export * from './view.ts';
diff --git a/drizzle-orm/src/mssql-core/indexes.ts b/drizzle-orm/src/mssql-core/indexes.ts
new file mode 100644
index 0000000000..650d19be74
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/indexes.ts
@@ -0,0 +1,90 @@
+import { entityKind } from '~/entity.ts';
+import type { SQL } from '~/sql/sql.ts';
+import type { AnyMsSqlColumn, MsSqlColumn } from './columns/index.ts';
+import type { MsSqlTable } from './table.ts';
+
+interface IndexConfig {
+	name: string;
+
+	columns: IndexColumn[];
+
+	/**
+	 * If true, the index will be created as `create unique index` instead of `create index`.
+	 */
+	unique?: boolean;
+
+	/**
+	 * Condition for partial index.
+	 */
+	where?: SQL;
+}
+
+export type IndexColumn = MsSqlColumn | SQL;
+
+export class IndexBuilderOn {
+	static readonly [entityKind]: string = 'MsSqlIndexBuilderOn';
+
+	constructor(private name: string, private unique: boolean) {}
+
+	on(...columns: [IndexColumn, ...IndexColumn[]]): IndexBuilder {
+		return new IndexBuilder(this.name, columns, this.unique);
+	}
+}
+
+export interface AnyIndexBuilder {
+	build(table: MsSqlTable): Index;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface IndexBuilder extends AnyIndexBuilder {}
+
+export class IndexBuilder implements AnyIndexBuilder {
+	static readonly [entityKind]: string = 'MsSqlIndexBuilder';
+
+	/** @internal */
+	config: IndexConfig;
+
+	constructor(name: string, columns: IndexColumn[], unique: boolean) {
+		this.config = {
+			name,
+			columns,
+			unique,
+		};
+	}
+
+	where(condition: SQL): this {
+		this.config.where = condition;
+		return this;
+	}
+
+	/** @internal */
+	build(table: MsSqlTable): Index {
+		return new Index(this.config, table);
+	}
+}
+
+export class Index {
+	static readonly [entityKind]: string = 'MsSqlIndex';
+
+	readonly config: IndexConfig & { table: MsSqlTable };
+	readonly isNameExplicit: boolean;
+
+	constructor(config: IndexConfig, table: MsSqlTable) {
+		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
+	}
+}
+
+export type GetColumnsTableName<TColumns> = TColumns extends
+	AnyMsSqlColumn<{ tableName: infer TTableName extends string }> | AnyMsSqlColumn<
+		{ tableName: infer TTableName extends string }
+	>[] ? TTableName
+	: never;
+
+export function index(name: string): IndexBuilderOn {
+	return new IndexBuilderOn(name, false);
+}
+
+export function uniqueIndex(name: string): IndexBuilderOn {
+	return new IndexBuilderOn(name, true);
+}
diff --git a/drizzle-orm/src/mssql-core/primary-keys.ts b/drizzle-orm/src/mssql-core/primary-keys.ts
new file mode 100644
index 0000000000..3f320874f2
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/primary-keys.ts
@@ -0,0 +1,52 @@
+import { entityKind } from '~/entity.ts';
+import type { AnyMsSqlColumn, MsSqlColumn } from './columns/index.ts';
+import type { MsSqlTable } from './table.ts';
+
+export function primaryKey<
+	TTableName extends string,
+	TColumn extends AnyMsSqlColumn<{ tableName: TTableName }>,
+	TColumns extends AnyMsSqlColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder {
+	return new PrimaryKeyBuilder(config.columns, config.name);
+}
+
+export class PrimaryKeyBuilder {
+	static readonly [entityKind]: string = 'MsSqlPrimaryKeyBuilder';
+
+	/** @internal */
+	columns: MsSqlColumn[];
+
+	/** @internal */
+	name?: string;
+
+	constructor(
+		columns: MsSqlColumn[],
+		name?: string,
+	) {
+		this.columns = columns;
+		this.name = name;
+	}
+
+	/** @internal */
+	build(table: MsSqlTable): PrimaryKey {
+		return new PrimaryKey(table, this.columns, this.name);
+	}
+}
+
+export class PrimaryKey {
+	static readonly [entityKind]: string = 'MsSqlPrimaryKey';
+
+	readonly columns: MsSqlColumn[];
+	readonly name?: string;
+	readonly isNameExplicit: boolean;
+
+	constructor(readonly table: MsSqlTable, columns: MsSqlColumn[], name?: string) {
+		this.columns = columns;
+		this.name = name;
+		this.isNameExplicit = !!name;
+	}
+
+	getName() {
+		return this.name;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/query-builders/delete.ts b/drizzle-orm/src/mssql-core/query-builders/delete.ts
new file mode 100644
index 0000000000..6c3d0cfb14
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/delete.ts
@@ -0,0 +1,242 @@
+import { entityKind } from '~/entity.ts';
+import type { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import type {
+	AnyQueryResultHKT,
+	MsSqlSession,
+	PreparedQueryConfig,
+	PreparedQueryHKTBase,
+	PreparedQueryKind,
+	QueryResultHKT,
+	QueryResultKind,
+} from '~/mssql-core/session.ts';
+import type { MsSqlTable } from '~/mssql-core/table.ts';
+import type { SelectResultFields } from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { Table } from '~/table.ts';
+import { orderSelectedFields } from '~/utils.ts';
+import type { MsSqlColumn } from '../columns/common.ts';
+import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
+
+export type MsSqlDeleteWithout<
+	T extends AnyMsSqlDeleteBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		MsSqlDeleteBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['preparedQueryHKT'],
+			T['_']['output'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type MsSqlDeleteReturningAll<
+	T extends AnyMsSqlDeleteBase,
+	TDynamic extends boolean,
+> = MsSqlDeleteWithout<
+	MsSqlDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'output'
+>;
+
+export type MsSqlDeleteReturning<
+	T extends AnyMsSqlDeleteBase,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = MsSqlDeleteWithout<
+	MsSqlDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'output'
+>;
+
+export type MsSqlDelete<
+	TTable extends MsSqlTable = MsSqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = MsSqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput, true, never>;
+
+export interface MsSqlDeleteConfig {
+	where?: SQL | undefined;
+	table: MsSqlTable;
+	output?: SelectedFieldsOrdered;
+}
+
+export type MsSqlDeletePrepare<T extends AnyMsSqlDeleteBase> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: T['_']['output'] extends undefined ? QueryResultKind<T['_']['queryResult'], any> : T['_']['output'][];
+		iterator: never;
+	}
+>;
+
+type MsSqlDeleteDynamic<T extends AnyMsSqlDeleteBase> = MsSqlDelete<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT'],
+	T['_']['output']
+>;
+
+type AnyMsSqlDeleteBase = MsSqlDeleteBase<any, any, any, any, any, any>;
+
+export interface MsSqlDeleteBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]> {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly dynamic: TDynamic;
+		readonly output: TOutput;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
+
+export class MsSqlDeleteBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TOutput extends Record<string, unknown> | undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]>
+	implements SQLWrapper
+{
+	static override readonly [entityKind]: string = 'MsSqlDelete';
+
+	private config: MsSqlDeleteConfig;
+
+	constructor(
+		private table: TTable,
+		private session: MsSqlSession,
+		private dialect: MsSqlDialect,
+	) {
+		super();
+		this.config = { table };
+	}
+
+	/**
+	 * Adds a `where` clause to the query.
+	 *
+	 * Calling this method will delete only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param where the `where` clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be deleted.
+	 *
+	 * ```ts
+	 * // Delete all cars with green color
+	 * db.delete(cars).where(eq(cars.color, 'green'));
+	 * // or
+	 * db.delete(cars).where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Delete all BMW cars with a green color
+	 * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Delete all cars with the green or blue color
+	 * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(where: SQL | undefined): MsSqlDeleteWithout<this, TDynamic, 'where'> {
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds an `output` clause to the query.
+	 *
+	 * Calling this method will return the specified fields of the deleted rows. If no fields are specified, all fields will be returned.
+	 *
+	 * @example
+	 * ```ts
+	 * // Delete all cars with the green color and return all fields
+	 * const deletedCars: Car[] = await db.delete(cars)
+	 *   .output();
+	 *   .where(eq(cars.color, 'green'))
+	 *
+	 * // Delete all cars with the green color and return only their id and brand fields
+	 * const deletedCarsIdsAndBrands: { id: number, brand: string }[] = await db.delete(cars)
+	 *   .output({ id: cars.id, brand: cars.brand });
+	 *   .where(eq(cars.color, 'green'))
+	 * ```
+	 */
+	output(): MsSqlDeleteReturningAll<this, TDynamic>;
+	output<TSelectedFields extends SelectedFieldsFlat>(
+		fields: TSelectedFields,
+	): MsSqlDeleteReturning<this, TDynamic, TSelectedFields>;
+	output(
+		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
+	): MsSqlDeleteWithout<AnyMsSqlDeleteBase, TDynamic, 'output'> {
+		this.config.output = orderSelectedFields<MsSqlColumn>(fields);
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildDeleteQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	prepare(): MsSqlDeletePrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			this.config.output,
+		) as MsSqlDeletePrepare<this>;
+	}
+
+	override execute(
+		placeholderValues?: Record<string, unknown>,
+	): Promise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]> {
+		return this.prepare().execute(placeholderValues) as any;
+	}
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+
+	$dynamic(): MsSqlDeleteDynamic<this> {
+		return this as any;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/query-builders/index.ts b/drizzle-orm/src/mssql-core/query-builders/index.ts
new file mode 100644
index 0000000000..16f0e1d4d9
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/index.ts
@@ -0,0 +1,6 @@
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query-builder.ts';
+export * from './select.ts';
+export * from './select.types.ts';
+export * from './update.ts';
diff --git a/drizzle-orm/src/mssql-core/query-builders/insert.ts b/drizzle-orm/src/mssql-core/query-builders/insert.ts
new file mode 100644
index 0000000000..69aa04e5ff
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/insert.ts
@@ -0,0 +1,242 @@
+import { entityKind, is } from '~/entity.ts';
+import type { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import type {
+	AnyQueryResultHKT,
+	MsSqlSession,
+	PreparedQueryConfig,
+	PreparedQueryHKTBase,
+	PreparedQueryKind,
+	QueryResultHKT,
+	QueryResultKind,
+} from '~/mssql-core/session.ts';
+import type { MsSqlTable } from '~/mssql-core/table.ts';
+import type { SelectResultFields } from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Param, SQL } from '~/sql/sql.ts';
+import { type InferInsertModel, type InferSelectModel, Table } from '~/table.ts';
+import { orderSelectedFields } from '~/utils.ts';
+import type { MsSqlColumn } from '../columns/common.ts';
+import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
+
+export interface MsSqlInsertConfig<TTable extends MsSqlTable = MsSqlTable> {
+	table: TTable;
+	values: Record<string, Param | SQL>[];
+	output?: SelectedFieldsOrdered;
+}
+
+export type MsSqlInsertValue<
+	TTable extends MsSqlTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
+	& {
+		[Key in keyof TModel]: TModel[Key] | SQL | Placeholder;
+	}
+	& {};
+
+export class MsSqlInsertBuilder<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = undefined,
+> {
+	static readonly [entityKind]: string = 'MsSqlInsertBuilder';
+
+	private config: {
+		output?: SelectedFieldsOrdered;
+		table: TTable;
+	};
+
+	protected table: TTable;
+	protected session: MsSqlSession;
+	protected dialect: MsSqlDialect;
+
+	constructor(
+		table: TTable,
+		session: MsSqlSession,
+		dialect: MsSqlDialect,
+		output?: SelectedFieldsOrdered,
+	) {
+		this.table = table;
+		this.session = session;
+		this.dialect = dialect;
+
+		this.config = { table, output };
+	}
+
+	values(
+		value: MsSqlInsertValue<TTable>,
+	): MsSqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput>;
+	values(values: MsSqlInsertValue<TTable>[]): MsSqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput>;
+	values(
+		values: MsSqlInsertValue<TTable> | MsSqlInsertValue<TTable>[],
+	): MsSqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput> {
+		values = Array.isArray(values) ? values : [values];
+		if (values.length === 0) {
+			throw new Error('values() must be called with at least one value');
+		}
+		const mappedValues = values.map((entry) => {
+			const result: Record<string, Param | SQL> = {};
+			const cols = this.table[Table.Symbol.Columns];
+			for (const colKey of Object.keys(entry)) {
+				const colValue = entry[colKey as keyof typeof entry];
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
+			}
+			return result;
+		});
+
+		return new MsSqlInsertBase(this.table, mappedValues, this.session, this.dialect, this.config.output);
+	}
+
+	/**
+	 * Adds an `output` clause to the query.
+	 *
+	 * Calling this method will return the specified fields of the inserted rows. If no fields are specified, all fields will be returned.
+	 *
+	 * @example
+	 * ```ts
+	 * // Insert one row and return all fields
+	 * const insertedCar: Car[] = await db.insert(cars)
+	 *   .output();
+	 *   .values({ brand: 'BMW' })
+	 *
+	 * // Insert one row and return only the id
+	 * const insertedCarId: { id: number }[] = await db.insert(cars)
+	 *   .output({ id: cars.id });
+	 *   .values({ brand: 'BMW' })
+	 * ```
+	 */
+	output(): Omit<MsSqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT, InferSelectModel<TTable>>, 'output'>;
+	output<SelectedFields extends SelectedFieldsFlat>(
+		fields: SelectedFields,
+	): Omit<MsSqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT, SelectResultFields<SelectedFields>>, 'output'>;
+	output(
+		fields: SelectedFieldsFlat = this.table[Table.Symbol.Columns],
+	) {
+		this.config.output = orderSelectedFields<MsSqlColumn>(fields);
+		return this as any;
+	}
+}
+
+export type MsSqlInsertWithout<T extends AnyMsSqlInsert, TDynamic extends boolean, K extends keyof T & string> =
+	TDynamic extends true ? T
+		: Omit<
+			MsSqlInsertBase<
+				T['_']['table'],
+				T['_']['queryResult'],
+				T['_']['preparedQueryHKT'],
+				T['_']['output'],
+				TDynamic,
+				T['_']['excludedMethods'] | K
+			>,
+			T['_']['excludedMethods'] | K
+		>;
+
+export type MsSqlInsertDynamic<T extends AnyMsSqlInsert> = MsSqlInsert<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT'],
+	T['_']['output']
+>;
+
+export type MsSqlInsertPrepare<T extends AnyMsSqlInsert> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: T['_']['output'] extends undefined ? QueryResultKind<T['_']['queryResult'], any> : T['_']['output'][];
+		iterator: never;
+	}
+>;
+
+export type MsSqlInsert<
+	TTable extends MsSqlTable = MsSqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = MsSqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput, true, never>;
+
+export type AnyMsSqlInsert = MsSqlInsertBase<any, any, any, any, any, any>;
+
+export interface MsSqlInsertBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly output: TOutput;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
+
+export class MsSqlInsertBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TOutput extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]>
+	implements SQLWrapper
+{
+	static override readonly [entityKind]: string = 'MsSqlInsert';
+
+	declare protected $table: TTable;
+
+	private config: MsSqlInsertConfig<TTable>;
+
+	constructor(
+		table: TTable,
+		values: MsSqlInsertConfig['values'],
+		private session: MsSqlSession,
+		private dialect: MsSqlDialect,
+		output?: SelectedFieldsOrdered,
+	) {
+		super();
+		this.config = { table, values, output };
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildInsertQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	prepare(): MsSqlInsertPrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			this.config.output,
+		) as MsSqlInsertPrepare<this>;
+	}
+
+	override execute(
+		placeholderValues?: Record<string, unknown>,
+	): Promise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]> {
+		return this.prepare().execute(placeholderValues) as any;
+	}
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+
+	// $dynamic(): MsSqlInsertDynamic<this> {
+	// 	return this as any;
+	// }
+}
diff --git a/drizzle-orm/src/mssql-core/query-builders/query-builder.ts b/drizzle-orm/src/mssql-core/query-builders/query-builder.ts
new file mode 100644
index 0000000000..4e2e07f104
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/query-builder.ts
@@ -0,0 +1,109 @@
+import { entityKind, is } from '~/entity.ts';
+import { MsSqlDialect, type MsSqlDialectConfig } from '~/mssql-core/dialect.ts';
+import type { WithSubqueryWithSelection } from '~/mssql-core/subquery.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { MsSqlSelectBuilder } from './select.ts';
+import type { SelectedFields } from './select.types.ts';
+
+export class QueryBuilder {
+	static readonly [entityKind]: string = 'MsSqlQueryBuilder';
+
+	private dialect: MsSqlDialect | undefined;
+	private dialectConfig: MsSqlDialectConfig | undefined;
+
+	constructor(dialect?: MsSqlDialect | MsSqlDialectConfig) {
+		this.dialect = is(dialect, MsSqlDialect) ? dialect : undefined;
+		this.dialectConfig = is(dialect, MsSqlDialect) ? undefined : dialect;
+	}
+
+	$with<TAlias extends string>(alias: TAlias) {
+		const queryBuilder = this;
+
+		return {
+			as<TSelection extends ColumnsSelection>(
+				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
+			): WithSubqueryWithSelection<TSelection, TAlias> {
+				if (typeof qb === 'function') {
+					qb = qb(queryBuilder);
+				}
+
+				return new Proxy(
+					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
+					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+				) as WithSubqueryWithSelection<TSelection, TAlias>;
+			},
+		};
+	}
+
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		function select(): MsSqlSelectBuilder<undefined, never, 'qb'>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MsSqlSelectBuilder<TSelection, never, 'qb'>;
+		function select<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): MsSqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+			return new MsSqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: undefined,
+				dialect: self.getDialect(),
+				withList: queries,
+			});
+		}
+
+		function selectDistinct(): MsSqlSelectBuilder<undefined, never, 'qb'>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MsSqlSelectBuilder<TSelection, never, 'qb'>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): MsSqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+			return new MsSqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: undefined,
+				dialect: self.getDialect(),
+				withList: queries,
+				distinct: true,
+			});
+		}
+
+		return { select, selectDistinct };
+	}
+
+	select(): MsSqlSelectBuilder<undefined, never, 'qb'>;
+	select<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, never, 'qb'>;
+	select<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): MsSqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+		return new MsSqlSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
+	}
+
+	selectDistinct(): MsSqlSelectBuilder<undefined, never, 'qb'>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): MsSqlSelectBuilder<TSelection, never, 'qb'>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): MsSqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+		return new MsSqlSelectBuilder({
+			fields: fields ?? undefined,
+			session: undefined,
+			dialect: this.getDialect(),
+			distinct: true,
+		});
+	}
+
+	// Lazy load dialect to avoid circular dependency
+	private getDialect() {
+		if (!this.dialect) {
+			this.dialect = new MsSqlDialect(this.dialectConfig);
+		}
+
+		return this.dialect;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/query-builders/query.ts b/drizzle-orm/src/mssql-core/query-builders/query.ts
new file mode 100644
index 0000000000..b6e4d7fb5a
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/query.ts
@@ -0,0 +1,136 @@
+import {
+	type BuildQueryResult,
+	type BuildRelationalQueryResult,
+	type DBQueryConfig,
+	mapRelationalRowFromObj,
+	type TableRelationalConfig,
+	type TablesRelationalConfig,
+} from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
+import type { MsSqlDialect } from '../dialect.ts';
+import type { MsSqlSession, PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { MsSqlTable } from '../table.ts';
+
+export class RelationalQueryBuilder<
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TSchema extends TablesRelationalConfig,
+	TFields extends TableRelationalConfig,
+> {
+	static readonly [entityKind]: string = 'MsSqlRelationalQueryBuilder';
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: TSchema,
+		private tableNamesMap: Record<string, string>,
+		private table: MsSqlTable,
+		private tableConfig: TableRelationalConfig,
+		private dialect: MsSqlDialect,
+		private session: MsSqlSession,
+	) {}
+
+	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
+	): MsSqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new MsSqlRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? (config as DBQueryConfig<'many', true>) : {},
+			'many',
+		);
+	}
+
+	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
+		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
+	): MsSqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
+		return new MsSqlRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			'first',
+		);
+	}
+}
+
+export class MsSqlRelationalQuery<
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TResult,
+> extends QueryPromise<TResult> {
+	static override readonly [entityKind]: string = 'MsSqlRelationalQuery';
+
+	declare protected $brand: 'MsSqlRelationalQuery';
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: TablesRelationalConfig,
+		private tableNamesMap: Record<string, string>,
+		private table: MsSqlTable,
+		private tableConfig: TableRelationalConfig,
+		private dialect: MsSqlDialect,
+		private session: MsSqlSession,
+		private config: DBQueryConfig<'many', true> | true,
+		private queryMode: 'many' | 'first',
+	) {
+		super();
+	}
+
+	prepare() {
+		const { query, builtQuery } = this._toSQL();
+		return this.session.prepareQuery(
+			builtQuery,
+			undefined,
+			(rawRows) => {
+				const rows = rawRows.map((row) => mapRelationalRowFromObj(this.schema, this.tableConfig, row, query.selection));
+				if (this.queryMode === 'first') {
+					return rows[0] as TResult;
+				}
+				return rows as TResult;
+			},
+		) as PreparedQueryKind<TPreparedQueryHKT, PreparedQueryConfig & { execute: TResult }, true>;
+	}
+
+	private _getQuery() {
+		return this.dialect.buildRelationalQuery({
+			fullSchema: this.fullSchema,
+			schema: this.schema,
+			tableNamesMap: this.tableNamesMap,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			tableAlias: this.tableConfig.tsName,
+		});
+	}
+
+	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
+		const query = this._getQuery();
+
+		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+
+		return { builtQuery, query };
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this._getQuery().sql as SQL;
+	}
+
+	toSQL(): Query {
+		return this._toSQL().builtQuery;
+	}
+
+	override execute(): Promise<TResult> {
+		return this.prepare().execute();
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/query-builders/select.ts b/drizzle-orm/src/mssql-core/query-builders/select.ts
new file mode 100644
index 0000000000..e0bd8e1f0d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/select.ts
@@ -0,0 +1,1072 @@
+import { entityKind, is } from '~/entity.ts';
+import type { MsSqlColumn } from '~/mssql-core/columns/index.ts';
+import type { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import type { MsSqlSession, PreparedQueryConfig, PreparedQueryHKTBase } from '~/mssql-core/session.ts';
+import type { SubqueryWithSelection } from '~/mssql-core/subquery.ts';
+import type { MsSqlTable } from '~/mssql-core/table.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	BuildSubquerySelection,
+	GetSelectTableName,
+	GetSelectTableSelection,
+	JoinNullability,
+	JoinType,
+	SelectMode,
+	SelectResult,
+	SetOperator,
+} from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, Placeholder, Query } from '~/sql/sql.ts';
+import { SQL, View } from '~/sql/sql.ts';
+import { Subquery } from '~/subquery.ts';
+import { Table } from '~/table.ts';
+import {
+	applyMixins,
+	getTableColumns,
+	getTableLikeName,
+	haveSameKeys,
+	orderSelectedFields,
+	type ValueOrArray,
+} from '~/utils.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { MsSqlViewBase } from '../view-base.ts';
+import type {
+	AnyMsSqlSelect,
+	CreateMsSqlSelectFromBuilderMode,
+	GetMsSqlSetOperators,
+	MsSqlCreateSetOperatorFn,
+	MsSqlJoinFn,
+	MsSqlSelectConfig,
+	MsSqlSelectDynamic,
+	MsSqlSelectHKT,
+	MsSqlSelectHKTBase,
+	MsSqlSelectPrepare,
+	MsSqlSelectReplace,
+	MsSqlSelectWithout,
+	MsSqlSetOperatorExcludedMethods,
+	MsSqlSetOperatorWithResult,
+	SelectedFields,
+	SetOperatorRightSelect,
+} from './select.types.ts';
+
+// Shared base class for `from()`
+class MsSqlSelectFromBuilderBase<
+	TSelection extends SelectedFields | undefined,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBuilderMode extends 'db' | 'qb',
+	TBranch extends 'from' | 'top',
+> {
+	static readonly [entityKind]: string = 'MsSqlSelectFromBuilderBase';
+
+	protected fields: TSelection;
+	protected session: MsSqlSession | undefined;
+	protected dialect: MsSqlDialect;
+	protected withList: Subquery[] = [];
+	protected distinct: boolean | undefined;
+	protected topValue?: number | Placeholder;
+
+	constructor(config: {
+		fields: TSelection;
+		session: MsSqlSession | undefined;
+		dialect: MsSqlDialect;
+		withList?: Subquery[];
+		distinct?: boolean;
+		topValue?: number | Placeholder;
+	}) {
+		this.fields = config.fields;
+		this.session = config.session;
+		this.dialect = config.dialect;
+		if (config.withList) {
+			this.withList = config.withList;
+		}
+		this.distinct = config.distinct;
+		this.topValue = config.topValue;
+	}
+
+	from<TFrom extends MsSqlTable | Subquery | MsSqlViewBase | SQL>(
+		source: TFrom,
+	): Omit<
+		CreateMsSqlSelectFromBuilderMode<
+			TBuilderMode,
+			GetSelectTableName<TFrom>,
+			TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
+			TSelection extends undefined ? 'single' : 'partial',
+			TPreparedQueryHKT,
+			TBranch
+		>,
+		'fetch' | 'offset'
+	> {
+		const isPartialSelect = !!this.fields;
+		let fields: SelectedFields;
+		if (this.fields) {
+			fields = this.fields;
+		} else if (is(source, Subquery)) {
+			// This is required to use the proxy handler to get the correct field values from the subquery
+			fields = Object.fromEntries(
+				Object.keys(source._.selectedFields).map((
+					key,
+				) => [key, source[key as unknown as keyof typeof source] as unknown as SelectedFields[string]]),
+			);
+		} else if (is(source, MsSqlViewBase)) {
+			fields = source[ViewBaseConfig].selectedFields as SelectedFields;
+		} else if (is(source, SQL)) {
+			fields = {};
+		} else {
+			fields = getTableColumns<MsSqlTable>(source);
+		}
+
+		return new MsSqlSelectBase({
+			table: source,
+			fields,
+			isPartialSelect,
+			session: this.session,
+			dialect: this.dialect,
+			withList: this.withList,
+			distinct: this.distinct,
+			topValue: this.topValue,
+		}) as any;
+	}
+}
+
+export class MsSqlSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBuilderMode extends 'db' | 'qb' = 'db',
+> extends MsSqlSelectFromBuilderBase<TSelection, TPreparedQueryHKT, TBuilderMode, 'from'> {
+	static override readonly [entityKind]: string = 'MsSqlSelectFromBuilderBase';
+
+	top(top: number | Placeholder): MsSqlSelectFromBuilderBase<TSelection, TPreparedQueryHKT, TBuilderMode, 'top'> {
+		return new MsSqlSelectFromBuilderBase({
+			fields: this.fields,
+			session: this.session,
+			dialect: this.dialect,
+			withList: this.withList,
+			distinct: this.distinct,
+			topValue: top,
+		});
+	}
+}
+
+export abstract class MsSqlSelectQueryBuilderBase<
+	THKT extends MsSqlSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = 'offset' | 'fetch',
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
+	static override readonly [entityKind]: string = 'MsSqlSelectQueryBuilderBase';
+
+	override readonly _: {
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+		readonly branch: TBranch;
+	};
+
+	protected config: MsSqlSelectConfig;
+	protected joinsNotNullableMap: Record<string, boolean>;
+	private tableName: string | undefined;
+	private isPartialSelect: boolean;
+	/** @internal */
+	readonly session: MsSqlSession | undefined;
+	protected dialect: MsSqlDialect;
+
+	constructor(
+		{ table, fields, isPartialSelect, session, dialect, withList, distinct, topValue }: {
+			table: MsSqlSelectConfig['table'];
+			fields: MsSqlSelectConfig['fields'];
+			isPartialSelect: boolean;
+			session: MsSqlSession | undefined;
+			dialect: MsSqlDialect;
+			withList: Subquery[];
+			distinct: boolean | undefined;
+			topValue: number | undefined | Placeholder;
+		},
+	) {
+		super();
+		this.config = {
+			withList,
+			table,
+			fields: { ...fields },
+			distinct,
+			setOperators: [],
+			top: topValue,
+		};
+		this.isPartialSelect = isPartialSelect;
+		this.session = session;
+		this.dialect = dialect;
+		this._ = {
+			selectedFields: fields as TSelectedFields,
+		} as this['_'];
+		this.tableName = getTableLikeName(table);
+		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
+	}
+
+	private createJoin<TJoinType extends JoinType>(
+		joinType: TJoinType,
+	): MsSqlJoinFn<this, TDynamic, TJoinType> {
+		return (
+			table: MsSqlTable | Subquery | MsSqlViewBase | SQL,
+			on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
+		) => {
+			const baseTableName = this.tableName;
+			const tableName = getTableLikeName(table);
+
+			if (typeof tableName === 'string' && this.config.joins?.some((join) => join.alias === tableName)) {
+				throw new Error(`Alias "${tableName}" is already used in this query`);
+			}
+
+			if (!this.isPartialSelect) {
+				// If this is the first join and this is not a partial select and we're not selecting from raw SQL, "move" the fields from the main table to the nested object
+				if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === 'string') {
+					this.config.fields = {
+						[baseTableName]: this.config.fields,
+					};
+				}
+				if (typeof tableName === 'string' && !is(table, SQL)) {
+					const selection = is(table, Subquery)
+						? table._.selectedFields
+						: is(table, View)
+						? table[ViewBaseConfig].selectedFields
+						: table[Table.Symbol.Columns];
+					this.config.fields[tableName] = selection;
+				}
+			}
+
+			if (typeof on === 'function') {
+				on = on(
+					new Proxy(
+						this.config.fields,
+						new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+					) as TSelection,
+				);
+			}
+
+			if (!this.config.joins) {
+				this.config.joins = [];
+			}
+
+			this.config.joins.push({ on, table, joinType, alias: tableName });
+
+			if (typeof tableName === 'string') {
+				switch (joinType) {
+					case 'left': {
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+					case 'right': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'inner': {
+						this.joinsNotNullableMap[tableName] = true;
+						break;
+					}
+					case 'full': {
+						this.joinsNotNullableMap = Object.fromEntries(
+							Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]),
+						);
+						this.joinsNotNullableMap[tableName] = false;
+						break;
+					}
+				}
+			}
+
+			return this as any;
+		};
+	}
+
+	/**
+	 * Executes a `left join` operation by adding another table to the current query.
+	 *
+	 * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User; pets: Pet | null }[] = await db.select()
+	 *   .from(users)
+	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number; petId: number | null }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .leftJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	leftJoin = this.createJoin('left');
+
+	/**
+	 * Executes a `right join` operation by adding another table to the current query.
+	 *
+	 * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User | null; pets: Pet }[] = await db.select()
+	 *   .from(users)
+	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number | null; petId: number }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .rightJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	rightJoin = this.createJoin('right');
+
+	/**
+	 * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
+	 *
+	 * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User; pets: Pet }[] = await db.select()
+	 *   .from(users)
+	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number; petId: number }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .innerJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	innerJoin = this.createJoin('inner');
+
+	/**
+	 * Executes a `full join` operation by combining rows from two tables into a new table.
+	 *
+	 * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
+	 *
+	 * @param table the table to join.
+	 * @param on the `on` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all users and their pets
+	 * const usersWithPets: { user: User | null; pets: Pet | null }[] = await db.select()
+	 *   .from(users)
+	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
+	 *
+	 * // Select userId and petId
+	 * const usersIdsAndPetIds: { userId: number | null; petId: number | null }[] = await db.select({
+	 *   userId: users.id,
+	 *   petId: pets.id,
+	 * })
+	 *   .from(users)
+	 *   .fullJoin(pets, eq(users.id, pets.ownerId))
+	 * ```
+	 */
+	fullJoin = this.createJoin('full');
+
+	private createSetOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends MsSqlSetOperatorWithResult<TResult>>(
+		rightSelection:
+			| ((setOperators: GetMsSqlSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => MsSqlSelectWithout<
+		this,
+		TDynamic,
+		MsSqlSetOperatorExcludedMethods,
+		true
+	> {
+		return (rightSelection) => {
+			const rightSelect = (typeof rightSelection === 'function'
+				? rightSelection(getMsSqlSetOperators())
+				: rightSelection) as TypedQueryBuilder<
+					any,
+					TResult
+				>;
+
+			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+
+			this.config.setOperators.push({ type, isAll, rightSelect });
+			return this as any;
+		};
+	}
+
+	/**
+	 * Adds `union` set operator to the query.
+	 *
+	 * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all unique names from customers and users tables
+	 * await db.select({ name: users.name })
+	 *   .from(users)
+	 *   .union(
+	 *     db.select({ name: customers.name }).from(customers)
+	 *   );
+	 * // or
+	 * import { union } from 'drizzle-orm/mssql-core'
+	 *
+	 * await union(
+	 *   db.select({ name: users.name }).from(users),
+	 *   db.select({ name: customers.name }).from(customers)
+	 * );
+	 * ```
+	 */
+	union = this.createSetOperator('union', false);
+
+	/**
+	 * Adds `union all` set operator to the query.
+	 *
+	 * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all transaction ids from both online and in-store sales
+	 * await db.select({ transaction: onlineSales.transactionId })
+	 *   .from(onlineSales)
+	 *   .unionAll(
+	 *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+	 *   );
+	 * // or
+	 * import { unionAll } from 'drizzle-orm/mssql-core'
+	 *
+	 * await unionAll(
+	 *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+	 *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+	 * );
+	 * ```
+	 */
+	unionAll = this.createSetOperator('union', true);
+
+	/**
+	 * Adds `intersect` set operator to the query.
+	 *
+	 * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select course names that are offered in both departments A and B
+	 * await db.select({ courseName: depA.courseName })
+	 *   .from(depA)
+	 *   .intersect(
+	 *     db.select({ courseName: depB.courseName }).from(depB)
+	 *   );
+	 * // or
+	 * import { intersect } from 'drizzle-orm/mssql-core'
+	 *
+	 * await intersect(
+	 *   db.select({ courseName: depA.courseName }).from(depA),
+	 *   db.select({ courseName: depB.courseName }).from(depB)
+	 * );
+	 * ```
+	 */
+	intersect = this.createSetOperator('intersect', false);
+
+	/**
+	 * Adds `except` set operator to the query.
+	 *
+	 * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all courses offered in department A but not in department B
+	 * await db.select({ courseName: depA.courseName })
+	 *   .from(depA)
+	 *   .except(
+	 *     db.select({ courseName: depB.courseName }).from(depB)
+	 *   );
+	 * // or
+	 * import { except } from 'drizzle-orm/mssql-core'
+	 *
+	 * await except(
+	 *   db.select({ courseName: depA.courseName }).from(depA),
+	 *   db.select({ courseName: depB.courseName }).from(depB)
+	 * );
+	 * ```
+	 */
+	except = this.createSetOperator('except', false);
+
+	/** @internal */
+	addSetOperators(setOperators: MsSqlSelectConfig['setOperators']): MsSqlSelectWithout<
+		this,
+		TDynamic,
+		MsSqlSetOperatorExcludedMethods,
+		true
+	> {
+		this.config.setOperators.push(...setOperators);
+		return this as any;
+	}
+
+	/**
+	 * Adds a `where` clause to the query.
+	 *
+	 * Calling this method will select only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
+	 *
+	 * @param where the `where` clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be selected.
+	 *
+	 * ```ts
+	 * // Select all cars with green color
+	 * await db.select().from(cars).where(eq(cars.color, 'green'));
+	 * // or
+	 * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Select all BMW cars with a green color
+	 * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Select all cars with the green or blue color
+	 * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(
+		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): MsSqlSelectWithout<this, TDynamic, 'where'> {
+		if (typeof where === 'function') {
+			where = where(
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+		}
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `having` clause to the query.
+	 *
+	 * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+	 *
+	 * @param having the `having` clause.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all brands with more than one car
+	 * await db.select({
+	 *  brand: cars.brand,
+	 *  count: sql<number>`cast(count(${cars.id}) as int)`,
+	 * })
+	 *   .from(cars)
+	 *   .groupBy(cars.brand)
+	 *   .having(({ count }) => gt(count, 1));
+	 * ```
+	 */
+	having(
+		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): MsSqlSelectWithout<this, TDynamic, 'having'> {
+		if (typeof having === 'function') {
+			having = having(
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+		}
+		this.config.having = having;
+		return this as any;
+	}
+
+	/**
+	 * Adds a `group by` clause to the query.
+	 *
+	 * Calling this method will group rows that have the same values into summary rows, often used for aggregation purposes.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Group and count people by their last names
+	 * await db.select({
+	 *    lastName: people.lastName,
+	 *    count: sql<number>`cast(count(*) as int)`
+	 * })
+	 *   .from(people)
+	 *   .groupBy(people.lastName);
+	 * ```
+	 */
+	groupBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<MsSqlColumn | SQL | SQL.Aliased>,
+	): MsSqlSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (MsSqlColumn | SQL | SQL.Aliased)[]): MsSqlSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(
+		...columns:
+			| [(aliases: this['_']['selection']) => ValueOrArray<MsSqlColumn | SQL | SQL.Aliased>]
+			| (MsSqlColumn | SQL | SQL.Aliased)[]
+	): MsSqlSelectWithout<this, TDynamic, 'groupBy'> {
+		if (typeof columns[0] === 'function') {
+			const groupBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+			this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
+		} else {
+			this.config.groupBy = columns as (MsSqlColumn | SQL | SQL.Aliased)[];
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds an `order by` clause to the query.
+	 *
+	 * Calling this method will sort the result-set in ascending or descending order. By default, the sort order is ascending.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#order-by}
+	 *
+	 * @example
+	 *
+	 * ```
+	 * // Select cars ordered by year
+	 * await db.select().from(cars).orderBy(cars.year);
+	 * ```
+	 *
+	 * You can specify whether results are in ascending or descending order with the `asc()` and `desc()` operators.
+	 *
+	 * ```ts
+	 * // Select cars ordered by year in descending order
+	 * await db.select().from(cars).orderBy(desc(cars.year));
+	 *
+	 * // Select cars ordered by year and price
+	 * await db.select().from(cars).orderBy(asc(cars.year), desc(cars.price));
+	 * ```
+	 */
+	orderBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<MsSqlColumn | SQL | SQL.Aliased>,
+	): TBranch extends 'from' ? MsSqlSelectReplace<this, TDynamic, 'orderBy', 'offset'>
+		: MsSqlSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(
+		...columns: (MsSqlColumn | SQL | SQL.Aliased)[]
+	): TBranch extends 'from' ? MsSqlSelectReplace<this, TDynamic, 'orderBy', 'offset'>
+		: MsSqlSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(
+		...columns:
+			| [(aliases: this['_']['selection']) => ValueOrArray<MsSqlColumn | SQL | SQL.Aliased>]
+			| (MsSqlColumn | SQL | SQL.Aliased)[]
+	): TBranch extends 'from' ? MsSqlSelectReplace<this, TDynamic, 'orderBy', 'offset'>
+		: MsSqlSelectWithout<this, TDynamic, 'orderBy'>
+	{
+		if (typeof columns[0] === 'function') {
+			const orderBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
+		} else {
+			const orderByArray = columns as (MsSqlColumn | SQL | SQL.Aliased)[];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds an `OFFSET` clause to the query.
+	 *
+	 * Calling this method will skip the first N rows of the result set. This is commonly used for pagination, often in combination with `FETCH NEXT` (e.g., `.fetch()`).
+	 *
+	 *  * ⚠️ **Note:** This method can only be used after calling `.orderBy()`, as SQL Server requires `ORDER BY` to be present with `OFFSET`.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Skip the first 10 results
+	 * await db.select().from(cars).orderBy(cars.year).offset(10);
+	 * ```
+	 *
+	 * `OFFSET` is zero-based — `offset(0)` will include all rows, while `offset(10)` will skip the first 10.
+	 *
+	 * Typically used with `.fetch()` to implement pagination:
+	 *
+	 * ```ts
+	 * // Get 10 cars, skipping the first 20
+	 * await db.select().from(cars).orderBy(cars.year).offset(20).fetch(10);
+	 * ```
+	 *
+	 * @param offset The number of rows to skip
+	 */
+	offset(offset: number | Placeholder): MsSqlSelectReplace<this, TDynamic, 'offset', 'fetch'> {
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.offset = offset;
+		} else {
+			this.config.offset = offset;
+		}
+		return this as any;
+	}
+
+	/**
+	 * Adds a `FETCH NEXT` clause to the query (commonly known as `LIMIT`).
+	 *
+	 * Limits the number of rows returned — used after `.offset()`.
+	 *
+	 * @example
+	 * ```ts
+	 * // Get only 10 rows, skipping 5 rows
+	 * await db.select().from(cars).orderBy(cars.year).offset(5).fetch(10);
+	 * ```
+	 *
+	 * @example
+	 * ```ts
+	 * // Pagination: skip 20 cars, then fetch 10
+	 * await db.select().from(cars).orderBy(cars.year).offset(20).fetch(10);
+	 * ```
+	 *
+	 * @param fetch The number of rows to fetch
+	 */
+	fetch(fetch: number | Placeholder): MsSqlSelectWithout<this, TDynamic, 'fetch'> {
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.fetch = fetch;
+		} else {
+			this.config.fetch = fetch;
+		}
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<MsSqlColumn>(this.config.fields);
+		return this.dialect.buildSelectQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	as<TAlias extends string>(
+		alias: TAlias,
+	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
+		return new Proxy(
+			new Subquery(this.getSQL(), this.config.fields, alias),
+			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
+	}
+
+	/** @internal */
+	override getSelectedFields(): this['_']['selectedFields'] {
+		return new Proxy(
+			this.config.fields,
+			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as this['_']['selectedFields'];
+	}
+
+	/** @internal */
+	override withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
+	$dynamic(): MsSqlSelectDynamic<this> {
+		return this as any;
+	}
+}
+
+export interface MsSqlSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = 'offset' | 'fetch',
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	MsSqlSelectQueryBuilderBase<
+		MsSqlSelectHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TBranch,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	QueryPromise<TResult>
+{}
+
+export class MsSqlSelectBase<
+	TTableName extends string | undefined,
+	TSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = 'offset' | 'fetch',
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends MsSqlSelectQueryBuilderBase<
+	MsSqlSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TBranch,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'MsSqlSelect';
+
+	prepare(): MsSqlSelectPrepare<this> {
+		if (!this.session) {
+			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
+		}
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const preparedQuery = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
+			TPreparedQueryHKT
+		>(query, fieldsList);
+		preparedQuery.joinsNotNullableMap = this.joinsNotNullableMap;
+		return preparedQuery as MsSqlSelectPrepare<this>;
+	}
+
+	execute = ((placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	}) as ReturnType<this['prepare']>['execute'];
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MsSqlSelectBase, [QueryPromise]);
+
+function createSetOperator(type: SetOperator, isAll: boolean): MsSqlCreateSetOperatorFn {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		const setOperators = [rightSelect, ...restSelects].map((select) => ({
+			type,
+			isAll,
+			rightSelect: select as AnyMsSqlSelect,
+		}));
+
+		for (const setOperator of setOperators) {
+			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+		}
+
+		return (leftSelect as AnyMsSqlSelect).addSetOperators(setOperators) as any;
+	};
+}
+
+const getMsSqlSetOperators = () => ({
+	union,
+	unionAll,
+	intersect,
+	except,
+});
+
+/**
+ * Adds `union` set operator to the query.
+ *
+ * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all unique names from customers and users tables
+ * import { union } from 'drizzle-orm/mssql-core'
+ *
+ * await union(
+ *   db.select({ name: users.name }).from(users),
+ *   db.select({ name: customers.name }).from(customers)
+ * );
+ * // or
+ * await db.select({ name: users.name })
+ *   .from(users)
+ *   .union(
+ *     db.select({ name: customers.name }).from(customers)
+ *   );
+ * ```
+ */
+export const union = createSetOperator('union', false);
+
+/**
+ * Adds `union all` set operator to the query.
+ *
+ * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all transaction ids from both online and in-store sales
+ * import { unionAll } from 'drizzle-orm/mssql-core'
+ *
+ * await unionAll(
+ *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+ *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+ * );
+ * // or
+ * await db.select({ transaction: onlineSales.transactionId })
+ *   .from(onlineSales)
+ *   .unionAll(
+ *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+ *   );
+ * ```
+ */
+export const unionAll = createSetOperator('union', true);
+
+/**
+ * Adds `intersect` set operator to the query.
+ *
+ * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select course names that are offered in both departments A and B
+ * import { intersect } from 'drizzle-orm/mssql-core'
+ *
+ * await intersect(
+ *   db.select({ courseName: depA.courseName }).from(depA),
+ *   db.select({ courseName: depB.courseName }).from(depB)
+ * );
+ * // or
+ * await db.select({ courseName: depA.courseName })
+ *   .from(depA)
+ *   .intersect(
+ *     db.select({ courseName: depB.courseName }).from(depB)
+ *   );
+ * ```
+ */
+export const intersect = createSetOperator('intersect', false);
+
+/**
+ * Adds `except` set operator to the query.
+ *
+ * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
+ *
+ * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
+ *
+ * @example
+ *
+ * ```ts
+ * // Select all courses offered in department A but not in department B
+ * import { except } from 'drizzle-orm/mssql-core'
+ *
+ * await except(
+ *   db.select({ courseName: depA.courseName }).from(depA),
+ *   db.select({ courseName: depB.courseName }).from(depB)
+ * );
+ * // or
+ * await db.select({ courseName: depA.courseName })
+ *   .from(depA)
+ *   .except(
+ *     db.select({ courseName: depB.courseName }).from(depB)
+ *   );
+ * ```
+ */
+export const except = createSetOperator('except', false);
diff --git a/drizzle-orm/src/mssql-core/query-builders/select.types.ts b/drizzle-orm/src/mssql-core/query-builders/select.types.ts
new file mode 100644
index 0000000000..f3afe7768f
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/select.types.ts
@@ -0,0 +1,478 @@
+import type { MsSqlColumn } from '~/mssql-core/columns/index.ts';
+import type { MsSqlTable, MsSqlTableWithColumns } from '~/mssql-core/table.ts';
+import type {
+	SelectedFields as SelectedFieldsBase,
+	SelectedFieldsFlat as SelectedFieldsFlatBase,
+	SelectedFieldsOrdered as SelectedFieldsOrderedBase,
+} from '~/operations.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	AppendToNullabilityMap,
+	AppendToResult,
+	BuildSubquerySelection,
+	GetSelectTableName,
+	JoinNullability,
+	JoinType,
+	MapColumnsToTableAlias,
+	SelectMode,
+	SelectResult,
+	SetOperator,
+} from '~/query-builders/select.types.ts';
+import type { ColumnsSelection, Placeholder, SQL, View } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import type { Table, UpdateTableConfig } from '~/table.ts';
+import type { Assume, ValidateShape } from '~/utils.ts';
+import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { MsSqlViewBase } from '../view-base.ts';
+import type { MsSqlView, MsSqlViewWithSelection } from '../view.ts';
+import type { MsSqlSelectBase, MsSqlSelectQueryBuilderBase } from './select.ts';
+
+export interface MsSqlSelectJoinConfig {
+	on: SQL | undefined;
+	table: MsSqlTable | Subquery | MsSqlViewBase | SQL;
+	alias: string | undefined;
+	joinType: JoinType;
+	lateral?: boolean;
+}
+
+export type BuildAliasTable<TTable extends MsSqlTable | MsSqlView, TAlias extends string> = TTable extends Table<any>
+	? MsSqlTableWithColumns<
+		UpdateTableConfig<TTable['_'], {
+			name: TAlias;
+			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'mssql'>;
+		}>
+	>
+	: TTable extends View<any, any, any> ? MsSqlViewWithSelection<
+			TAlias,
+			TTable['_']['existing'],
+			MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'mssql'>
+		>
+	: never;
+
+export interface MsSqlSelectConfig {
+	withList?: Subquery[];
+	fields: Record<string, unknown>;
+	fieldsFlat?: SelectedFieldsOrdered;
+	where?: SQL;
+	having?: SQL;
+	table: MsSqlTable | Subquery | MsSqlViewBase | SQL;
+	fetch?: number | Placeholder;
+	joins?: MsSqlSelectJoinConfig[];
+	orderBy?: (MsSqlColumn | SQL | SQL.Aliased)[];
+	groupBy?: (MsSqlColumn | SQL | SQL.Aliased)[];
+	for?: { // this is not exposed. Just used internally for the RQB
+		mode: 'browse'; // TODO: implement in dialect
+	} | {
+		mode: 'xml'; // TODO: implement in dialect
+	} | {
+		mode: 'json';
+		type: 'auto' | 'path';
+		options?: {
+			root?: string;
+			includeNullValues?: true;
+			withoutArrayWrapper?: true;
+		};
+	};
+	top?: number | Placeholder;
+	offset?: number | Placeholder;
+	distinct?: boolean;
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (MsSqlColumn | SQL | SQL.Aliased)[];
+		fetch?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
+}
+
+export type MsSqlJoin<
+	T extends AnyMsSqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends MsSqlTable | Subquery | MsSqlViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? MsSqlSelectWithout<
+		MsSqlSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends MsSqlTable ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			T['_']['preparedQueryHKT'],
+			T['_']['branch'],
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type MsSqlJoinFn<
+	T extends AnyMsSqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+> = <
+	TJoinedTable extends MsSqlTable | Subquery | MsSqlViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => MsSqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type SelectedFieldsFlat = SelectedFieldsFlatBase<MsSqlColumn>;
+
+export type SelectedFieldsFlatUpdate = {
+	inserted?: SelectedFieldsFlat | true;
+	deleted?: SelectedFieldsFlat | true;
+};
+
+export type SelectedFields = SelectedFieldsBase<MsSqlColumn, MsSqlTable>;
+
+export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<MsSqlColumn>;
+
+export interface MsSqlSelectHKTBase {
+	tableName: string | undefined;
+	selection: unknown;
+	selectMode: SelectMode;
+	preparedQueryHKT: unknown;
+	branch: 'from' | 'top';
+	nullabilityMap: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
+	_type: unknown;
+}
+
+export type MsSqlSelectKind<
+	T extends MsSqlSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top',
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> = (T & {
+	tableName: TTableName;
+	selection: TSelection;
+	selectMode: TSelectMode;
+	preparedQueryHKT: TPreparedQueryHKT;
+	branch: TBranch;
+	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
+})['_type'];
+
+export interface MsSqlSelectQueryBuilderHKT extends MsSqlSelectHKTBase {
+	_type: MsSqlSelectQueryBuilderBase<
+		MsSqlSelectQueryBuilderHKT,
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
+		this['branch'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface MsSqlSelectHKT extends MsSqlSelectHKTBase {
+	_type: MsSqlSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
+		this['branch'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export type MsSqlSetOperatorExcludedMethods =
+	| 'where'
+	| 'having'
+	| 'groupBy'
+	| 'session'
+	| 'fetch'
+	| 'offset'
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin';
+
+export type MsSqlSelectWithout<
+	T extends AnyMsSqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+	TResetExcluded extends boolean = false,
+> = TDynamic extends true ? T : Omit<
+	MsSqlSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['preparedQueryHKT'],
+		T['_']['branch'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
+>;
+
+export type MsSqlSelectReplace<
+	T extends AnyMsSqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	NewExcluded extends string,
+	OldExcluded extends string,
+> = TDynamic extends true ? T
+	: Omit<
+		MsSqlSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			T['_']['selection'],
+			T['_']['selectMode'],
+			T['_']['preparedQueryHKT'],
+			T['_']['branch'],
+			T['_']['nullabilityMap'],
+			TDynamic,
+			Exclude<T['_']['excludedMethods'], OldExcluded> | NewExcluded,
+			T['_']['result'],
+			T['_']['selectedFields']
+		>,
+		NewExcluded | Exclude<T['_']['excludedMethods'], OldExcluded>
+	>;
+
+export type MsSqlSelectPrepare<T extends AnyMsSqlSelect> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+		iterator: T['_']['result'][number];
+	},
+	true
+>;
+
+export type MsSqlSelectDynamic<T extends AnyMsSqlSelectQueryBuilder> = MsSqlSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['preparedQueryHKT'],
+	T['_']['branch'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type CreateMsSqlSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top',
+> = TBuilderMode extends 'db' ? MsSqlSelectBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TBranch>
+	: MsSqlSelectQueryBuilderBase<
+		MsSqlSelectQueryBuilderHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TBranch
+	>;
+
+export type AnyMsSqlSelectQueryBuilder = MsSqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+
+export type AnyMsSqlSetOperatorInterface = MsSqlSetOperatorInterface<any, any, any, any, any, any, any, any>;
+
+export interface MsSqlSetOperatorInterface<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> {
+	_: {
+		readonly hkt: MsSqlSelectHKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+}
+
+export type MsSqlSetOperatorWithResult<TResult extends any[]> = MsSqlSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	TResult,
+	any
+>;
+
+export type AnyMsSqlSelect = MsSqlSelectBase<any, any, any, any, any, any, any, any, any>;
+
+export type SetOperatorRightSelect<
+	TValue extends MsSqlSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends MsSqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+	? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
+	: TValue;
+
+export type MsSqlSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TBranch extends 'from' | 'top' = 'from' | 'top',
+> = MsSqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TBranch, TNullabilityMap, true, never>;
+
+export type MsSqlSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TBranch extends 'from' | 'top' = 'from' | 'top',
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MsSqlSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TBranch,
+	TNullabilityMap,
+	true,
+	MsSqlSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly MsSqlSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends MsSqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+		? Rest extends AnyMsSqlSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+	: never
+	: TValue;
+
+export type MsSqlCreateSetOperatorFn = <
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TValue extends MsSqlSetOperatorWithResult<TResult>,
+	TRest extends MsSqlSetOperatorWithResult<TResult>[],
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = 'offset' | 'fetch',
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: MsSqlSetOperatorInterface<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => MsSqlSelectWithout<
+	MsSqlSelectBase<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		'from',
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	false,
+	MsSqlSetOperatorExcludedMethods,
+	true
+>;
+
+export type GetMsSqlSetOperators = {
+	union: MsSqlCreateSetOperatorFn;
+	intersect: MsSqlCreateSetOperatorFn;
+	except: MsSqlCreateSetOperatorFn;
+	unionAll: MsSqlCreateSetOperatorFn;
+};
+
+export type MsSqlSelectQueryBuilder<
+	THKT extends MsSqlSelectHKTBase = MsSqlSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult extends any[] = unknown[],
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+	TBranch extends 'from' | 'top' = 'from' | 'top',
+> = MsSqlSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TBranch,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
diff --git a/drizzle-orm/src/mssql-core/query-builders/update.ts b/drizzle-orm/src/mssql-core/query-builders/update.ts
new file mode 100644
index 0000000000..3cff55b91f
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/query-builders/update.ts
@@ -0,0 +1,332 @@
+import type { GetColumnData } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import type {
+	AnyQueryResultHKT,
+	MsSqlSession,
+	PreparedQueryConfig,
+	PreparedQueryHKTBase,
+	PreparedQueryKind,
+	QueryResultHKT,
+	QueryResultKind,
+} from '~/mssql-core/session.ts';
+import type { MsSqlTable } from '~/mssql-core/table.ts';
+import type { SelectResultFields } from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { ExtractObjectValues } from '~/relations.ts';
+import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { type InferInsertModel, Table } from '~/table.ts';
+import { mapUpdateSet, orderSelectedFields, type UpdateSet } from '~/utils.ts';
+import type { MsSqlColumn } from '../columns/common.ts';
+import type { SelectedFieldsFlatUpdate, SelectedFieldsOrdered } from './select.types.ts';
+
+export interface MsSqlUpdateConfig {
+	where?: SQL | undefined;
+	set: UpdateSet;
+	table: MsSqlTable;
+	output?: {
+		inserted?: SelectedFieldsOrdered;
+		deleted?: SelectedFieldsOrdered;
+	};
+}
+
+export type MsSqlUpdateSetSource<TTable extends MsSqlTable> =
+	& {
+		[Key in keyof InferInsertModel<TTable>]?:
+			| GetColumnData<TTable['_']['columns'][Key], 'query'>
+			| Placeholder
+			| SQL;
+	}
+	& {};
+
+export type NonUndefinedKeysOnly<T> =
+	& ExtractObjectValues<
+		{
+			[K in keyof T as T[K] extends undefined ? never : K]: K;
+		}
+	>
+	& keyof T;
+
+export type FormSelection<T, TTable extends MsSqlTable> = {
+	[K in keyof T as T[K] extends undefined ? never : K]: T[K] extends true ? TTable['_']['columns'] : T[K];
+};
+
+export type MsSqlUpdateReturning<
+	T extends AnyMsSqlUpdateBase,
+	TDynamic extends boolean,
+	SelectedFields extends SelectedFieldsFlatUpdate,
+> = MsSqlUpdateWithout<
+	MsSqlUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		SelectResultFields<FormSelection<SelectedFields, T['_']['table']>>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'output'
+>;
+
+export type MsSqlUpdateReturningAll<T extends AnyMsSqlUpdateBase, TDynamic extends boolean> = MsSqlUpdateWithout<
+	MsSqlUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'output'
+>;
+
+export class MsSqlUpdateBuilder<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+> {
+	static readonly [entityKind]: string = 'MsSqlUpdateBuilder';
+
+	declare readonly _: {
+		readonly table: TTable;
+	};
+
+	constructor(
+		private table: TTable,
+		private session: MsSqlSession,
+		private dialect: MsSqlDialect,
+	) {}
+
+	set(values: MsSqlUpdateSetSource<TTable>): MsSqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MsSqlUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
+	}
+}
+
+export type MsSqlUpdateWithout<
+	T extends AnyMsSqlUpdateBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	MsSqlUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		T['_']['output'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type MsSqlUpdatePrepare<T extends AnyMsSqlUpdateBase> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: T['_']['output'] extends undefined ? QueryResultKind<T['_']['queryResult'], any> : T['_']['output'][];
+		iterator: never;
+	}
+>;
+
+export type MsSqlUpdateDynamic<T extends AnyMsSqlUpdateBase> = MsSqlUpdate<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT'],
+	T['_']['output']
+>;
+
+export type MsSqlUpdate<
+	TTable extends MsSqlTable = MsSqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = MsSqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT, TOutput, true, never>;
+
+export type AnyMsSqlUpdateBase = MsSqlUpdateBase<any, any, any, any, any, any>;
+
+export interface MsSqlUpdateBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TOutput extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly output: TOutput;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
+
+export class MsSqlUpdateBase<
+	TTable extends MsSqlTable,
+	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TOutput extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]>
+	implements SQLWrapper
+{
+	static override readonly [entityKind]: string = 'MsSqlUpdate';
+
+	private config: MsSqlUpdateConfig;
+
+	constructor(
+		table: TTable,
+		set: UpdateSet,
+		private session: MsSqlSession,
+		private dialect: MsSqlDialect,
+	) {
+		super();
+		this.config = { set, table };
+	}
+
+	/**
+	 * Adds a 'where' clause to the query.
+	 *
+	 * Calling this method will update only those rows that fulfill a specified condition.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param where the 'where' clause.
+	 *
+	 * @example
+	 * You can use conditional operators and `sql function` to filter the rows to be updated.
+	 *
+	 * ```ts
+	 * // Update all cars with green color
+	 * db.update(cars).set({ color: 'red' })
+	 *   .where(eq(cars.color, 'green'));
+	 * // or
+	 * db.update(cars).set({ color: 'red' })
+	 *   .where(sql`${cars.color} = 'green'`)
+	 * ```
+	 *
+	 * You can logically combine conditional operators with `and()` and `or()` operators:
+	 *
+	 * ```ts
+	 * // Update all BMW cars with a green color
+	 * db.update(cars).set({ color: 'red' })
+	 *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	 *
+	 * // Update all cars with the green or blue color
+	 * db.update(cars).set({ color: 'red' })
+	 *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	 * ```
+	 */
+	where(where: SQL | undefined): MsSqlUpdateWithout<this, TDynamic, 'where'> {
+		this.config.where = where;
+		return this as any;
+	}
+
+	/**
+	 * Adds an `output` clause to the query.
+	 *
+	 * This method allows you to return values from the rows affected by the query.
+	 * MSSQL supports returning `inserted` (new row values) and `deleted` (old row values) values.
+	 *
+	 * If no fields are specified, all `inserted` values will be returned by default.
+	 *
+	 * @example
+	 * ```ts
+	 * // Update cars and return all new values
+	 * const updatedCars: Car[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .output()
+	 *   .where(eq(cars.color, 'green'));
+	 *
+	 * // Update cars and return all old values
+	 * const updatedCarsIds: { deleted: Car }[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .output({ deleted: true })
+	 *   .where(eq(cars.color, 'green'));
+	 *
+	 * // Update cars and return partial old and new values
+	 * const beforeAndAfter: { deleted: { oldColor: string }, inserted: { newColor: string } }[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .output({
+	 *     deleted: { oldColor: cars.color },
+	 *     inserted: { newColor: cars.color }
+	 *   })
+	 *   .where(eq(cars.color, 'green'));
+	 * ```
+	 */
+	output(): MsSqlUpdateReturningAll<this, TDynamic>;
+	output<TSelectedFields extends SelectedFieldsFlatUpdate>(
+		fields: TSelectedFields,
+	): MsSqlUpdateReturning<this, TDynamic, TSelectedFields>;
+	output(
+		fields?: SelectedFieldsFlatUpdate,
+	): MsSqlUpdateWithout<AnyMsSqlUpdateBase, TDynamic, 'output'> {
+		const columns = this.config.table[Table.Symbol.Columns];
+
+		if (fields) {
+			const output: typeof this.config.output = {};
+
+			if (fields.inserted) {
+				output.inserted = typeof fields.inserted === 'boolean'
+					? orderSelectedFields<MsSqlColumn>(columns, ['inserted'])
+					: orderSelectedFields<MsSqlColumn>(fields.inserted, ['inserted']);
+			}
+
+			if (fields.deleted) {
+				output.deleted = typeof fields.deleted === 'boolean'
+					? orderSelectedFields<MsSqlColumn>(columns, ['deleted'])
+					: orderSelectedFields<MsSqlColumn>(fields.deleted, ['deleted']);
+			}
+
+			this.config.output = output;
+		} else {
+			this.config.output = {
+				inserted: orderSelectedFields<MsSqlColumn>(columns),
+			};
+		}
+
+		return this as any;
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this.dialect.buildUpdateQuery(this.config);
+	}
+
+	toSQL(): Query {
+		return this.dialect.sqlToQuery(this.getSQL());
+	}
+
+	prepare(): MsSqlUpdatePrepare<this> {
+		const output = [...(this.config.output?.inserted ?? []), ...(this.config.output?.deleted ?? [])];
+
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			output.length ? output : undefined,
+		) as MsSqlUpdatePrepare<this>;
+	}
+
+	override execute(
+		placeholderValues?: Record<string, unknown>,
+	): Promise<TOutput extends undefined ? QueryResultKind<TQueryResult, any> : TOutput[]> {
+		return this.prepare().execute(placeholderValues) as any;
+	}
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+
+	$dynamic(): MsSqlUpdateDynamic<this> {
+		return this as any;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/schema.ts b/drizzle-orm/src/mssql-core/schema.ts
new file mode 100644
index 0000000000..364cb5ad95
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/schema.ts
@@ -0,0 +1,35 @@
+import type { Casing } from '~/casing.ts';
+import { entityKind } from '~/entity.ts';
+import { type MsSqlTableFn, mssqlTableWithSchema } from './table.ts';
+import { type mssqlView, mssqlViewWithSchema } from './view.ts';
+
+export class MsSqlSchema<TName extends string = string> {
+	static readonly [entityKind]: string = 'MsSqlSchema';
+
+	isExisting: boolean = false;
+	constructor(
+		public readonly schemaName: TName,
+		protected casing: Casing | undefined,
+	) {}
+
+	table: MsSqlTableFn<TName> = (name, columns, extraConfig) => {
+		return mssqlTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
+	};
+
+	view = ((name, columns) => {
+		return mssqlViewWithSchema(name, columns, this.schemaName, this.casing);
+	}) as typeof mssqlView;
+
+	existing(): this {
+		this.isExisting = true;
+		return this;
+	}
+}
+
+export function mssqlSchema<TName extends string>(name: TName): MsSqlSchema<TName>;
+/** @internal */
+export function mssqlSchema<TName extends string>(name: TName, casing: Casing | undefined): MsSqlSchema<TName>;
+/** @internal */
+export function mssqlSchema<TName extends string>(name: TName, casing?: Casing): MsSqlSchema<TName> {
+	return new MsSqlSchema(name, casing);
+}
diff --git a/drizzle-orm/src/mssql-core/session.ts b/drizzle-orm/src/mssql-core/session.ts
new file mode 100644
index 0000000000..c44e98b513
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/session.ts
@@ -0,0 +1,131 @@
+import type * as V1 from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { TransactionRollbackError } from '~/errors.ts';
+import { type Query, type SQL, sql } from '~/sql/sql.ts';
+import type { Assume, Equal } from '~/utils.ts';
+import { MsSqlDatabase } from './db.ts';
+import type { MsSqlDialect } from './dialect.ts';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
+
+export interface QueryResultHKT {
+	readonly $brand: 'MsSqlQueryRowHKT';
+	readonly row: unknown;
+	readonly type: unknown;
+}
+
+export interface AnyQueryResultHKT extends QueryResultHKT {
+	readonly type: any;
+}
+
+export type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
+	readonly row: TRow;
+})['type'];
+
+export interface PreparedQueryConfig {
+	execute: unknown;
+	iterator: unknown;
+}
+
+export interface PreparedQueryHKT {
+	readonly $brand: 'MsSqlPreparedQueryHKT';
+	readonly config: unknown;
+	readonly type: unknown;
+}
+
+export type PreparedQueryKind<
+	TKind extends PreparedQueryHKT,
+	TConfig extends PreparedQueryConfig,
+	TAssume extends boolean = false,
+> = Equal<TAssume, true> extends true ? Assume<(TKind & { readonly config: TConfig })['type'], PreparedQuery<TConfig>>
+	: (TKind & { readonly config: TConfig })['type'];
+
+export abstract class PreparedQuery<T extends PreparedQueryConfig> {
+	static readonly [entityKind]: string = 'MsSqlPreparedQuery';
+
+	/** @internal */
+	joinsNotNullableMap?: Record<string, boolean>;
+
+	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+
+	abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
+}
+
+export interface MsSqlTransactionConfig {
+	isolationLevel: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable' | 'snapshot';
+}
+
+export abstract class MsSqlSession<
+	TQueryResult extends QueryResultHKT = QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
+> {
+	static readonly [entityKind]: string = 'MsSqlSession';
+
+	constructor(protected dialect: MsSqlDialect) {}
+
+	abstract prepareQuery<T extends PreparedQueryConfig, TPreparedQueryHKT extends PreparedQueryHKT>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	): PreparedQueryKind<TPreparedQueryHKT, T>;
+
+	execute<T>(query: SQL): Promise<T> {
+		return this.prepareQuery<PreparedQueryConfig & { execute: T }, PreparedQueryHKTBase>(
+			this.dialect.sqlToQuery(query),
+			undefined,
+		).execute();
+	}
+
+	abstract all<T = unknown>(query: SQL): Promise<T[]>;
+
+	abstract transaction<T>(
+		transaction: (tx: MsSqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+		config?: MsSqlTransactionConfig,
+	): Promise<T>;
+
+	protected getSetTransactionSQL(config: MsSqlTransactionConfig): SQL | undefined {
+		const parts: string[] = [];
+
+		if (config.isolationLevel) {
+			parts.push(`isolation level ${config.isolationLevel}`);
+		}
+
+		return parts.length ? sql`set transaction ${sql.raw(parts.join(' '))}` : undefined;
+	}
+
+	protected getStartTransactionSQL(_config: MsSqlTransactionConfig): SQL | undefined {
+		return sql`begin transaction`;
+	}
+}
+
+export abstract class MsSqlTransaction<
+	TQueryResult extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TFullSchema extends Record<string, unknown> = Record<string, never>,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
+> extends MsSqlDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'MsSqlTransaction';
+
+	constructor(
+		dialect: MsSqlDialect,
+		session: MsSqlSession,
+		protected schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+		protected readonly nestedIndex: number,
+	) {
+		super(dialect, session, schema);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+
+	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
+	abstract override transaction<T>(
+		transaction: (tx: MsSqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T>;
+}
+
+export interface PreparedQueryHKTBase extends PreparedQueryHKT {
+	type: PreparedQuery<Assume<this['config'], PreparedQueryConfig>>;
+}
diff --git a/drizzle-orm/src/mssql-core/subquery.ts b/drizzle-orm/src/mssql-core/subquery.ts
new file mode 100644
index 0000000000..329742b95d
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/subquery.ts
@@ -0,0 +1,35 @@
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import type { Subquery, WithSubquery, WithSubqueryWithoutSelection } from '~/subquery.ts';
+import type { QueryBuilder } from './query-builders/query-builder.ts';
+
+export type SubqueryWithSelection<
+	TSelection extends ColumnsSelection,
+	TAlias extends string,
+> =
+	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mssql'>>
+	& AddAliasToSelection<TSelection, TAlias, 'mssql'>;
+
+export type WithSubqueryWithSelection<
+	TSelection extends ColumnsSelection,
+	TAlias extends string,
+> =
+	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mssql'>>
+	& AddAliasToSelection<TSelection, TAlias, 'mssql'>;
+
+export interface WithBuilder {
+	<TAlias extends string>(alias: TAlias): {
+		as: {
+			<TSelection extends ColumnsSelection>(
+				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
+			): WithSubqueryWithSelection<TSelection, TAlias>;
+			(
+				qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>),
+			): WithSubqueryWithoutSelection<TAlias>;
+		};
+	};
+	<TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
+		as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
+	};
+}
diff --git a/drizzle-orm/src/mssql-core/table.ts b/drizzle-orm/src/mssql-core/table.ts
new file mode 100644
index 0000000000..0b362f7e86
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/table.ts
@@ -0,0 +1,168 @@
+import { type Casing, getCasingFn } from '~/casing.ts';
+import type { BuildColumns, BuildExtraConfigColumns, ColumnBuilderBase } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import {
+	type InferTableColumnsModels,
+	Table,
+	type TableConfig as TableConfigBase,
+	type UpdateTableConfig,
+} from '~/table.ts';
+import type { CheckBuilder } from './checks.ts';
+import { getMsSqlColumnBuilders, type MsSqlColumnBuilders } from './columns/all.ts';
+import type { MsSqlColumn, MsSqlColumnBuilder, MsSqlColumns } from './columns/common.ts';
+import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
+import type { AnyIndexBuilder } from './indexes.ts';
+import type { PrimaryKeyBuilder } from './primary-keys.ts';
+import type { UniqueConstraintBuilder } from './unique-constraint.ts';
+
+export type MsSqlTableExtraConfigValue =
+	| AnyIndexBuilder
+	| CheckBuilder
+	| ForeignKeyBuilder
+	| PrimaryKeyBuilder
+	| UniqueConstraintBuilder;
+
+export type MsSqlTableExtraConfig = Record<
+	string,
+	MsSqlTableExtraConfigValue
+>;
+
+export type TableConfig = TableConfigBase<MsSqlColumns>;
+
+/** @internal */
+export const InlineForeignKeys = Symbol.for('drizzle:MsSqlInlineForeignKeys');
+
+export class MsSqlTable<T extends TableConfig = TableConfig> extends Table<T> {
+	static override readonly [entityKind]: string = 'MsSqlTable';
+
+	/** @internal */
+	static override readonly Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys: InlineForeignKeys as typeof InlineForeignKeys,
+	});
+
+	/** @internal */
+	override [Table.Symbol.Columns]!: NonNullable<T['columns']>;
+
+	/** @internal */
+	[InlineForeignKeys]: ForeignKey[] = [];
+
+	/** @internal */
+	override [Table.Symbol.ExtraConfigBuilder]:
+		| ((self: Record<string, MsSqlColumn>) => MsSqlTableExtraConfig)
+		| undefined = undefined;
+}
+
+export type AnyMsSqlTable<TPartial extends Partial<TableConfig> = {}> = MsSqlTable<
+	UpdateTableConfig<TableConfig, TPartial>
+>;
+
+export type MsSqlTableWithColumns<T extends TableConfig> =
+	& MsSqlTable<T>
+	& T['columns']
+	& InferTableColumnsModels<T['columns']>;
+
+export function mssqlTableWithSchema<
+	TTableName extends string,
+	TSchemaName extends string | undefined,
+	TColumnsMap extends Record<string, ColumnBuilderBase>,
+>(
+	name: TTableName,
+	columns: TColumnsMap | ((columnTypes: MsSqlColumnBuilders) => TColumnsMap),
+	extraConfig:
+		| ((
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'mssql'>,
+		) => MsSqlTableExtraConfig | MsSqlTableExtraConfigValue[])
+		| undefined,
+	schema: TSchemaName,
+	casing: Casing | undefined,
+	baseName = name,
+): MsSqlTableWithColumns<{
+	name: TTableName;
+	schema: TSchemaName;
+	columns: BuildColumns<TTableName, TColumnsMap, 'mssql'>;
+	dialect: 'mssql';
+}> {
+	const casingFn = getCasingFn(casing);
+	const rawTable = new MsSqlTable<{
+		name: TTableName;
+		schema: TSchemaName;
+		columns: BuildColumns<TTableName, TColumnsMap, 'mssql'>;
+		dialect: 'mssql';
+	}>(name, schema, baseName);
+
+	const parsedColumns: TColumnsMap = typeof columns === 'function' ? columns(getMsSqlColumnBuilders()) : columns;
+
+	const builtColumns = Object.fromEntries(
+		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+			const colBuilder = colBuilderBase as MsSqlColumnBuilder;
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
+			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+			return [name, column];
+		}),
+	) as unknown as BuildColumns<TTableName, TColumnsMap, 'mssql'>;
+
+	const table = Object.assign(rawTable, builtColumns);
+
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumns as unknown as BuildExtraConfigColumns<
+		TTableName,
+		TColumnsMap,
+		'mssql'
+	>;
+
+	if (extraConfig) {
+		table[MsSqlTable.Symbol.ExtraConfigBuilder] = extraConfig as unknown as (
+			self: Record<string, MsSqlColumn>,
+		) => MsSqlTableExtraConfig;
+	}
+
+	return table as any;
+}
+
+export interface MsSqlTableFn<TSchema extends string | undefined = undefined> {
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'mssql'>) => MsSqlTableExtraConfigValue[],
+	): MsSqlTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'mssql'>;
+		dialect: 'mssql';
+	}>;
+
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: (columnTypes: MsSqlColumnBuilders) => TColumnsMap,
+		extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'mssql'>) => MsSqlTableExtraConfigValue[],
+	): MsSqlTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap, 'mssql'>;
+		dialect: 'mssql';
+	}>;
+}
+
+export function mssqlTableWithCasing(casing: Casing | undefined): MsSqlTableFn {
+	return (name, columns, extraConfig) => {
+		return mssqlTableWithSchema(name, columns, extraConfig, undefined, casing, name);
+	};
+}
+
+export const mssqlTable = mssqlTableWithCasing(undefined);
+
+export function mssqlTableCreator(
+	customizeTableName: (name: string) => string,
+	casing?: Casing | undefined,
+): MsSqlTableFn {
+	return (name, columns, extraConfig) => {
+		return mssqlTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, casing, name);
+	};
+}
diff --git a/drizzle-orm/src/mssql-core/unique-constraint.ts b/drizzle-orm/src/mssql-core/unique-constraint.ts
new file mode 100644
index 0000000000..98f3cb1e8e
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/unique-constraint.ts
@@ -0,0 +1,62 @@
+import { entityKind } from '~/entity.ts';
+import type { MsSqlColumn } from './columns/index.ts';
+import type { MsSqlTable } from './table.ts';
+
+export function unique(name?: string): UniqueOnConstraintBuilder {
+	return new UniqueOnConstraintBuilder(name);
+}
+
+export class UniqueConstraintBuilder {
+	static readonly [entityKind]: string = 'MsSqlUniqueConstraintBuilder';
+
+	/** @internal */
+	columns: MsSqlColumn[];
+
+	constructor(
+		columns: MsSqlColumn[],
+		private name?: string,
+	) {
+		this.columns = columns;
+	}
+
+	/** @internal */
+	build(table: MsSqlTable): UniqueConstraint {
+		return new UniqueConstraint(table, this.columns, this.name);
+	}
+}
+
+export class UniqueOnConstraintBuilder {
+	static readonly [entityKind]: string = 'MsSqlUniqueOnConstraintBuilder';
+
+	/** @internal */
+	name?: string;
+
+	constructor(
+		name?: string,
+	) {
+		this.name = name;
+	}
+
+	on(...columns: [MsSqlColumn, ...MsSqlColumn[]]) {
+		return new UniqueConstraintBuilder(columns, this.name);
+	}
+}
+
+export class UniqueConstraint {
+	static readonly [entityKind]: string = 'MsSqlUniqueConstraint';
+
+	readonly columns: MsSqlColumn[];
+	readonly name?: string;
+	readonly nullsNotDistinct: boolean = false;
+	readonly isNameExplicit: boolean;
+
+	constructor(readonly table: MsSqlTable, columns: MsSqlColumn[], name?: string) {
+		this.columns = columns;
+		this.name = name;
+		this.isNameExplicit = !!name;
+	}
+
+	getName() {
+		return this.name;
+	}
+}
diff --git a/drizzle-orm/src/mssql-core/utils.ts b/drizzle-orm/src/mssql-core/utils.ts
new file mode 100644
index 0000000000..4cc73afadf
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/utils.ts
@@ -0,0 +1,68 @@
+import { is } from '~/entity.ts';
+import { Table } from '~/table.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import type { Check } from './checks.ts';
+import { CheckBuilder } from './checks.ts';
+import type { ForeignKey } from './foreign-keys.ts';
+import { ForeignKeyBuilder } from './foreign-keys.ts';
+import type { Index } from './indexes.ts';
+import { IndexBuilder } from './indexes.ts';
+import type { PrimaryKey } from './primary-keys.ts';
+import { PrimaryKeyBuilder } from './primary-keys.ts';
+import { MsSqlTable } from './table.ts';
+import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
+import { MsSqlViewConfig } from './view-common.ts';
+import type { MsSqlView } from './view.ts';
+
+export function getTableConfig(table: MsSqlTable) {
+	const columns = Object.values(table[MsSqlTable.Symbol.Columns]);
+	const indexes: Index[] = [];
+	const checks: Check[] = [];
+	const primaryKeys: PrimaryKey[] = [];
+	const uniqueConstraints: UniqueConstraint[] = [];
+	const foreignKeys: ForeignKey[] = Object.values(table[MsSqlTable.Symbol.InlineForeignKeys]);
+	const name = table[Table.Symbol.Name];
+	const schema = table[Table.Symbol.Schema];
+	const baseName = table[Table.Symbol.BaseName];
+
+	const extraConfigBuilder = table[MsSqlTable.Symbol.ExtraConfigBuilder];
+
+	if (extraConfigBuilder !== undefined) {
+		const extraConfig = extraConfigBuilder(table[MsSqlTable.Symbol.Columns]);
+		for (const builder of Object.values(extraConfig)) {
+			if (is(builder, IndexBuilder)) {
+				indexes.push(builder.build(table));
+			} else if (is(builder, CheckBuilder)) {
+				checks.push(builder.build(table));
+			} else if (is(builder, UniqueConstraintBuilder)) {
+				uniqueConstraints.push(builder.build(table));
+			} else if (is(builder, PrimaryKeyBuilder)) {
+				primaryKeys.push(builder.build(table));
+			} else if (is(builder, ForeignKeyBuilder)) {
+				foreignKeys.push(builder.build(table));
+			}
+		}
+	}
+
+	return {
+		columns,
+		indexes,
+		foreignKeys,
+		checks,
+		primaryKeys,
+		uniqueConstraints,
+		name,
+		schema,
+		baseName,
+	};
+}
+
+export function getViewConfig<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+>(view: MsSqlView<TName, TExisting>) {
+	return {
+		...view[ViewBaseConfig],
+		...view[MsSqlViewConfig],
+	};
+}
diff --git a/drizzle-orm/src/mssql-core/view-base.ts b/drizzle-orm/src/mssql-core/view-base.ts
new file mode 100644
index 0000000000..5ad76153d0
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/view-base.ts
@@ -0,0 +1,15 @@
+import { entityKind } from '~/entity.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { View } from '~/sql/sql.ts';
+
+export abstract class MsSqlViewBase<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends View<TName, TExisting, TSelectedFields> {
+	static override readonly [entityKind]: string = 'MsSqlViewBase';
+
+	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+		readonly viewBrand: 'MsSqlViewBase';
+	};
+}
diff --git a/drizzle-orm/src/mssql-core/view-common.ts b/drizzle-orm/src/mssql-core/view-common.ts
new file mode 100644
index 0000000000..fb97254b0f
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/view-common.ts
@@ -0,0 +1 @@
+export const MsSqlViewConfig = Symbol.for('drizzle:MsSqlViewConfig');
diff --git a/drizzle-orm/src/mssql-core/view.ts b/drizzle-orm/src/mssql-core/view.ts
new file mode 100644
index 0000000000..fcf19d2175
--- /dev/null
+++ b/drizzle-orm/src/mssql-core/view.ts
@@ -0,0 +1,202 @@
+import type { Casing } from '~/casing.ts';
+import type { BuildColumns, ColumnBuilderBase } from '~/column-builder.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import { getTableColumns } from '~/utils.ts';
+import type { MsSqlColumn } from './columns/index.ts';
+import { QueryBuilder } from './query-builders/query-builder.ts';
+import type { SelectedFields } from './query-builders/select.types.ts';
+import { mssqlTableWithSchema } from './table.ts';
+import { MsSqlViewBase } from './view-base.ts';
+import { MsSqlViewConfig } from './view-common.ts';
+
+export interface ViewBuilderConfig {
+	encryption?: boolean;
+	schemaBinding?: boolean;
+	viewMetadata?: boolean;
+	checkOption?: boolean;
+}
+
+export class ViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
+	static readonly [entityKind]: string = 'MsSqlViewBuilder';
+
+	declare readonly _: {
+		readonly name: TConfig['name'];
+		readonly columns: TConfig['columns'];
+	};
+
+	constructor(
+		protected name: TConfig['name'],
+		protected schema: string | undefined,
+	) {}
+
+	protected config: ViewBuilderConfig = {
+		encryption: false,
+		schemaBinding: false,
+		viewMetadata: false,
+	};
+
+	with(
+		config?: ViewBuilderConfig,
+	): this {
+		this.config.encryption = config?.encryption;
+		this.config.schemaBinding = config?.schemaBinding;
+		this.config.viewMetadata = config?.viewMetadata;
+		this.config.checkOption = config?.checkOption;
+		return this;
+	}
+}
+
+export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<{ name: TName }> {
+	static override readonly [entityKind]: string = 'MsSqlViewBuilder';
+
+	as<TSelectedFields extends SelectedFields>(
+		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
+	): MsSqlViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'mssql'>> {
+		if (typeof qb === 'function') {
+			qb = qb(new QueryBuilder());
+		}
+		const selectionProxy = new SelectionProxyHandler<TSelectedFields>({
+			alias: this.name,
+			sqlBehavior: 'error',
+			sqlAliasedBehavior: 'alias',
+			replaceOriginalName: true,
+		});
+		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+		return new Proxy(
+			new MsSqlView({
+				mssqlConfig: this.config,
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: aliasedSelection,
+					query: qb.getSQL().inlineParams(),
+				},
+			}),
+			selectionProxy as any,
+		) as MsSqlViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'mssql'>>;
+	}
+}
+
+export class ManualViewBuilder<
+	TName extends string = string,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
+> extends ViewBuilderCore<{ name: TName; columns: TColumns }> {
+	static override readonly [entityKind]: string = 'MsSqlManualViewBuilder';
+
+	private columns: Record<string, MsSqlColumn>;
+
+	constructor(
+		name: TName,
+		columns: TColumns,
+		schema: string | undefined,
+		casing: Casing | undefined,
+	) {
+		super(name, schema);
+		this.columns = getTableColumns(
+			mssqlTableWithSchema(name, columns, undefined, schema, casing),
+		) as BuildColumns<TName, TColumns, 'mssql'>;
+	}
+
+	existing(): MsSqlViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'mssql'>> {
+		return new Proxy(
+			new MsSqlView({
+				mssqlConfig: undefined,
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: undefined,
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as MsSqlViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'mssql'>>;
+	}
+
+	as(query: SQL): MsSqlViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'mssql'>> {
+		return new Proxy(
+			new MsSqlView({
+				mssqlConfig: this.config,
+				config: {
+					name: this.name,
+					schema: this.schema,
+					selectedFields: this.columns,
+					query: query.inlineParams(),
+				},
+			}),
+			new SelectionProxyHandler({
+				alias: this.name,
+				sqlBehavior: 'error',
+				sqlAliasedBehavior: 'alias',
+				replaceOriginalName: true,
+			}),
+		) as MsSqlViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'mssql'>>;
+	}
+}
+
+export class MsSqlView<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends MsSqlViewBase<TName, TExisting, TSelectedFields> {
+	static override readonly [entityKind]: string = 'MsSqlView';
+
+	declare protected $MsSqlViewBrand: 'MsSqlView';
+
+	[MsSqlViewConfig]: ViewBuilderConfig | undefined;
+
+	constructor({ mssqlConfig, config }: {
+		mssqlConfig: ViewBuilderConfig | undefined;
+		config: {
+			name: TName;
+			schema: string | undefined;
+			selectedFields: SelectedFields;
+			query: SQL | undefined;
+		};
+	}) {
+		super(config);
+		this[MsSqlViewConfig] = mssqlConfig;
+	}
+}
+
+export type MsSqlViewWithSelection<
+	TName extends string,
+	TExisting extends boolean,
+	TSelectedFields extends ColumnsSelection,
+> = MsSqlView<TName, TExisting, TSelectedFields> & TSelectedFields;
+
+/** @internal */
+export function mssqlViewWithSchema(
+	name: string,
+	selection: Record<string, ColumnBuilderBase> | undefined,
+	schema: string | undefined,
+	casing: Casing | undefined,
+): ViewBuilder | ManualViewBuilder {
+	if (selection) {
+		return new ManualViewBuilder(name, selection, schema, casing);
+	}
+	return new ViewBuilder(name, schema);
+}
+
+export interface MsSqlViewFn {
+	<TName extends string>(name: TName): ViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, ColumnBuilderBase>>(
+		name: TName,
+		columns: TColumns,
+	): ManualViewBuilder<TName, TColumns>;
+}
+
+/** @internal */
+export function mssqlViewWithCasing(casing: Casing | undefined): MsSqlViewFn {
+	return ((name, columns) => mssqlViewWithSchema(name, columns, undefined, casing)) as MsSqlViewFn;
+}
+
+export const mssqlView = mssqlViewWithCasing(undefined);
diff --git a/drizzle-orm/src/mysql-core/async/count.ts b/drizzle-orm/src/mysql-core/async/count.ts
new file mode 100644
index 0000000000..1046f86bfb
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/count.ts
@@ -0,0 +1,46 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import { applyMixins } from '~/utils.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import { MySqlCountBuilder } from '../query-builders/count.ts';
+import type { MySqlTable } from '../table.ts';
+import type { MySqlViewBase } from '../view-base.ts';
+import type { MySqlAsyncSession } from './session.ts';
+
+export interface MySqlAsyncCountBuilder extends MySqlCountBuilder, QueryPromise<number> {}
+
+export class MySqlAsyncCountBuilder extends MySqlCountBuilder {
+	static override readonly [entityKind]: string = 'MySqlAsyncCountBuilder';
+
+	protected session: MySqlAsyncSession;
+
+	constructor(
+		{ source, dialect, filters, session }: {
+			source: MySqlTable | MySqlViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: MySqlDialect;
+			session: MySqlAsyncSession;
+		},
+	) {
+		super({ source, dialect, filters });
+		this.session = session;
+	}
+
+	execute(placeholderValues?: Record<string, unknown>): Promise<number> {
+		return this.session.prepareQuery<{
+			execute: number;
+			iterator: never;
+		}>(
+			this.build(),
+			'arrays',
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues);
+	}
+}
+
+applyMixins(MySqlAsyncCountBuilder, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/async/db.ts b/drizzle-orm/src/mysql-core/async/db.ts
new file mode 100644
index 0000000000..d2a81632f9
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/db.ts
@@ -0,0 +1,530 @@
+import type { ResultSetHeader } from 'mysql2/promise';
+import type { Cache } from '~/cache/core/cache.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import { MySqlInsertBuilder, MySqlSelectBuilder, MySqlUpdateBuilder, QueryBuilder } from '../query-builders/index.ts';
+import { RelationalQueryBuilder } from '../query-builders/query.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import type {
+	MySqlPreparedQueryConfig,
+	MySqlQueryResultHKT,
+	MySqlQueryResultKind,
+	MySqlTransactionConfig,
+} from '../session.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { MySqlTable } from '../table.ts';
+import type { MySqlViewBase } from '../view-base.ts';
+import type { MySqlView } from '../view.ts';
+import { MySqlAsyncCountBuilder } from './count.ts';
+import { MySqlAsyncDeleteBase } from './delete.ts';
+import { MySqlAsyncInsertBase, type MySqlAsyncInsertHKT } from './insert.ts';
+import { MySqlAsyncRelationalQuery, type MySqlAsyncRelationalQueryHKT } from './query.ts';
+import { MySqlAsyncRaw } from './raw.ts';
+import { MySqlAsyncSelectBase, type MySqlAsyncSelectBuilder } from './select.ts';
+import type { MySqlAsyncSession, MySqlAsyncTransaction } from './session.ts';
+import { MySqlAsyncUpdateBase, type MySqlAsyncUpdateHKT } from './update.ts';
+
+export class MySqlAsyncDatabase<
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'MySqlDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: MySqlAsyncSession<TQueryResult, TRelations>;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TRelations,
+			TRelations[K],
+			MySqlAsyncRelationalQueryHKT
+		>;
+	};
+
+	constructor(
+		/** @internal */
+		readonly dialect: MySqlDialect,
+		/** @internal */
+		readonly session: MySqlAsyncSession<any, any>,
+		relations: TRelations,
+	) {
+		this._ = {
+			relations,
+			session,
+		};
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as MySqlAsyncDatabase<
+				TQueryResult,
+				AnyRelations
+			>['query'])[
+				tableName
+			] = new RelationalQueryBuilder(
+				relations,
+				relations[relation.name]!.table as MySqlTable | MySqlView,
+				relation,
+				dialect,
+				session,
+				MySqlAsyncRelationalQuery,
+			);
+		}
+
+		this.$cache = { invalidate: async (_params: any) => {} };
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(this.dialect));
+			}
+
+			const sql = ('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL();
+			return new Proxy(
+				new WithSubquery(
+					sql,
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+					sql.usedTables ?? [],
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: MySqlTable | MySqlViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	) {
+		return new MySqlAsyncCountBuilder({ source, filters, session: this.session, dialect: this.dialect });
+	}
+
+	$cache: { invalidate: Cache['onMutate'] };
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = await db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): MySqlAsyncSelectBuilder<undefined>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MySqlAsyncSelectBuilder<TSelection>;
+		function select(fields?: SelectedFields): MySqlAsyncSelectBuilder<SelectedFields | undefined> {
+			return new MySqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			}, MySqlAsyncSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * await db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * await db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): MySqlAsyncSelectBuilder<undefined>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MySqlAsyncSelectBuilder<TSelection>;
+		function selectDistinct(
+			fields?: SelectedFields,
+		): MySqlAsyncSelectBuilder<SelectedFields | undefined> {
+			return new MySqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			}, MySqlAsyncSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * await db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 * ```
+		 */
+		function update<TTable extends MySqlTable>(
+			table: TTable,
+		): MySqlUpdateBuilder<TTable, TQueryResult, MySqlAsyncUpdateHKT> {
+			return new MySqlUpdateBuilder(table, self.session, self.dialect, queries, MySqlAsyncUpdateBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * await db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * await db.delete(cars).where(eq(cars.color, 'green'));
+		 * ```
+		 */
+		function delete_<TTable extends MySqlTable>(
+			table: TTable,
+		): MySqlAsyncDeleteBase<TTable, TQueryResult> {
+			return new MySqlAsyncDeleteBase(table, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, update, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = await db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): MySqlAsyncSelectBuilder<undefined>;
+	select<TSelection extends SelectedFields>(fields: TSelection): MySqlAsyncSelectBuilder<TSelection>;
+	select(fields?: SelectedFields): MySqlAsyncSelectBuilder<SelectedFields | undefined> {
+		return new MySqlSelectBuilder(
+			{ fields: fields ?? undefined, session: this.session, dialect: this.dialect },
+			MySqlAsyncSelectBase,
+		);
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * await db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * await db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): MySqlAsyncSelectBuilder<undefined>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): MySqlAsyncSelectBuilder<TSelection>;
+	selectDistinct(fields?: SelectedFields): MySqlAsyncSelectBuilder<SelectedFields | undefined> {
+		return new MySqlSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		}, MySqlAsyncSelectBase);
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * await db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 * ```
+	 */
+	update<TTable extends MySqlTable>(table: TTable): MySqlUpdateBuilder<TTable, TQueryResult, MySqlAsyncUpdateHKT> {
+		return new MySqlUpdateBuilder(table, this.session, this.dialect, undefined, MySqlAsyncUpdateBase);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * await db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 * ```
+	 */
+	insert<TTable extends MySqlTable>(table: TTable): MySqlInsertBuilder<TTable, TQueryResult, MySqlAsyncInsertHKT> {
+		return new MySqlInsertBuilder(table, this.session, this.dialect, MySqlAsyncInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * await db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 * ```
+	 */
+	delete<TTable extends MySqlTable>(table: TTable): MySqlAsyncDeleteBase<TTable, TQueryResult> {
+		return new MySqlAsyncDeleteBase(table, this.session, this.dialect);
+	}
+
+	execute<T extends { [column: string]: any } = ResultSetHeader>(
+		query: SQLWrapper | string,
+	): MySqlAsyncRaw<MySqlQueryResultKind<TQueryResult, T>> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<
+			MySqlPreparedQueryConfig & { execute: MySqlQueryResultKind<TQueryResult, T> }
+		>(builtQuery, 'raw');
+		return new MySqlAsyncRaw(prepared, sequel, builtQuery);
+	}
+
+	transaction<T>(
+		transaction: (
+			tx: MySqlAsyncTransaction<TQueryResult, TRelations>,
+			config?: MySqlTransactionConfig,
+		) => Promise<T>,
+		config?: MySqlTransactionConfig,
+	): Promise<T> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type MySQLWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	HKT extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations,
+	Q extends MySqlAsyncDatabase<HKT, TRelations>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): MySQLWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any, any]) => primary.transaction(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		$count,
+		with: $with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/mysql-core/async/delete.ts b/drizzle-orm/src/mysql-core/async/delete.ts
new file mode 100644
index 0000000000..47341838f6
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/delete.ts
@@ -0,0 +1,79 @@
+import { entityKind } from '~/entity.ts';
+import { MySqlDeleteBase, type MySqlDeleteHKTBase } from '~/mysql-core/query-builders/delete.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlAsyncPreparedQuery, MySqlAsyncSession } from './session.ts';
+
+export type MySqlAsyncDelete<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+> = MySqlAsyncDeleteBase<TTable, TQueryResult, true, never>;
+
+export type MySqlAsyncDeletePrepare<T extends AnyMySqlAsyncDelete> = MySqlAsyncPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	}
+>;
+
+export type AnyMySqlAsyncDelete = MySqlAsyncDeleteBase<any, any, any, any>;
+
+export interface MySqlAsyncDeleteHKT extends MySqlDeleteHKTBase {
+	_type: MySqlAsyncDeleteBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export interface MySqlAsyncDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> {}
+
+export class MySqlAsyncDeleteBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends MySqlDeleteBase<MySqlAsyncDeleteHKT, TTable, TQueryResult, TDynamic, TExcludedMethods> {
+	static override readonly [entityKind]: string = 'MySqlAsyncDelete';
+
+	declare protected session: MySqlAsyncSession<TQueryResult, any>;
+
+	prepare(): MySqlAsyncDeletePrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'raw',
+			undefined,
+			{
+				type: 'delete',
+				tables: extractUsedTable(this.config.table),
+			},
+		);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MySqlAsyncDeleteBase, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/async/index.ts b/drizzle-orm/src/mysql-core/async/index.ts
new file mode 100644
index 0000000000..98e8de2793
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/index.ts
@@ -0,0 +1,9 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
diff --git a/drizzle-orm/src/mysql-core/async/insert.ts b/drizzle-orm/src/mysql-core/async/insert.ts
new file mode 100644
index 0000000000..d6f812629d
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/insert.ts
@@ -0,0 +1,96 @@
+import { entityKind } from '~/entity.ts';
+import { MySqlInsertBase, type MySqlInsertHKTBase } from '~/mysql-core/query-builders/insert.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlAsyncPreparedQuery, MySqlAsyncSession } from './session.ts';
+
+export interface MySqlAsyncInsertHKT extends MySqlInsertHKTBase {
+	_type: MySqlAsyncInsertBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnyMySqlAsyncInsert = MySqlAsyncInsertBase<any, any, any, any, any>;
+
+export type MySqlAsyncInsertPrepare<
+	T extends AnyMySqlAsyncInsert,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+> = MySqlAsyncPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: TReturning extends undefined ? MySqlQueryResultKind<T['_']['queryResult'], never> : TReturning[];
+		iterator: never;
+	}
+>;
+
+export type MySqlAsyncInsert<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = MySqlAsyncInsertBase<TTable, TQueryResult, TReturning, true, never>;
+
+export interface MySqlAsyncInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[]> {}
+
+export class MySqlAsyncInsertBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends MySqlInsertBase<MySqlAsyncInsertHKT, TTable, TQueryResult, TReturning, TDynamic, TExcludedMethods>
+	implements
+		RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>
+{
+	static override readonly [entityKind]: string = 'MySqlAsyncInsert';
+
+	declare protected session: MySqlAsyncSession<TQueryResult, any>;
+
+	/** @internal */
+	_prepare(): MySqlAsyncInsertPrepare<this, TReturning> {
+		const { sql, generatedIds } = this.dialect.buildInsertQuery(this.config);
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(sql),
+			'raw',
+			this.dialect.mapperGenerators.$returning(this.config.returning, generatedIds),
+			{
+				type: 'insert',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as MySqlAsyncInsertPrepare<this, TReturning>;
+	}
+
+	prepare(): MySqlAsyncInsertPrepare<this, TReturning> {
+		return this._prepare();
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MySqlAsyncInsertBase, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/async/query.ts b/drizzle-orm/src/mysql-core/async/query.ts
new file mode 100644
index 0000000000..1327c5abd4
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/query.ts
@@ -0,0 +1,43 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import { applyMixins } from '~/utils.ts';
+import { MySqlRelationalQuery, type MySqlRelationalQueryHKTBase } from '../query-builders/query.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlAsyncPreparedQuery, MySqlAsyncSession } from './session.ts';
+
+export type AnyMySqlAsyncRelationalQuery = MySqlAsyncRelationalQuery<any>;
+
+export interface MySqlAsyncRelationalQueryHKT extends MySqlRelationalQueryHKTBase {
+	_type: MySqlAsyncRelationalQuery<this['result']>;
+}
+
+export interface MySqlAsyncRelationalQuery<TResult> extends QueryPromise<TResult> {}
+export class MySqlAsyncRelationalQuery<TResult> extends MySqlRelationalQuery<MySqlAsyncRelationalQueryHKT, TResult> {
+	static override readonly [entityKind]: string = 'MySqlAsyncRelationalQueryV2';
+
+	declare protected session: MySqlAsyncSession;
+
+	prepare() {
+		const { query, builtQuery } = this._toSQL();
+		const mapper = this.dialect.mapperGenerators.relationalRows({
+			isFirst: this.mode === 'first',
+			parseJson: false,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			arrayModeRoot: true,
+			selection: query.selection,
+		});
+
+		return this.session.prepareQuery(
+			builtQuery,
+			'arrays',
+			mapper,
+		) as MySqlAsyncPreparedQuery<MySqlPreparedQueryConfig & { execute: TResult }>;
+	}
+
+	execute(): Promise<TResult> {
+		return this.prepare().execute();
+	}
+}
+
+applyMixins(MySqlAsyncRelationalQuery, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/async/raw.ts b/drizzle-orm/src/mysql-core/async/raw.ts
new file mode 100644
index 0000000000..7f0463e877
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/raw.ts
@@ -0,0 +1,46 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { applyMixins } from '~/utils.ts';
+import { MySqlRaw } from '../query-builders/raw.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlAsyncPreparedQuery } from './session.ts';
+
+export interface MySqlAsyncRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'mysql'>, SQLWrapper {}
+export class MySqlAsyncRaw<TResult> extends MySqlRaw<TResult> implements RunnableQuery<TResult, 'mysql'> {
+	static override readonly [entityKind]: string = 'MySqlAsyncRaw';
+
+	declare readonly _: {
+		readonly dialect: 'mysql';
+		readonly result: TResult;
+	};
+
+	declare protected prepared: MySqlAsyncPreparedQuery<
+		MySqlPreparedQueryConfig & {
+			execute: TResult;
+		}
+	>;
+
+	constructor(
+		prepared: MySqlAsyncPreparedQuery<
+			MySqlPreparedQueryConfig & {
+				execute: TResult;
+			}
+		>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.prepared.execute(placeholderValues);
+	}
+
+	override _prepare() {
+		return this.prepared;
+	}
+}
+
+applyMixins(MySqlAsyncRaw, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/async/select.ts b/drizzle-orm/src/mysql-core/async/select.ts
new file mode 100644
index 0000000000..bb1ef9d296
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/select.ts
@@ -0,0 +1,136 @@
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { MySqlSelectBase, type MySqlSelectBuilder } from '../query-builders/select.ts';
+import type { MySqlSelectHKTBase, SelectedFields } from '../query-builders/select.types.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlAsyncPreparedQuery, MySqlAsyncSession } from './session.ts';
+
+export type MySqlAsyncSelectPrepare<T extends AnyMySqlAsyncSelect> = MySqlAsyncPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: T['_']['result'];
+		iterator: T['_']['result'][number];
+	}
+>;
+
+export type MySqlAsyncSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+> = MySqlSelectBuilder<TSelection, MySqlAsyncSelectHKT>;
+
+export type MySqlAsyncSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlAsyncSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export interface MySqlAsyncSelectHKT extends MySqlSelectHKTBase {
+	_type: MySqlAsyncSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface MySqlAsyncSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	MySqlSelectBase<
+		MySqlAsyncSelectHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	QueryPromise<TResult>
+{}
+
+export class MySqlAsyncSelectBase<
+	TTableName extends string | undefined,
+	TSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends MySqlSelectBase<
+	MySqlAsyncSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'MySqlSelect';
+
+	declare readonly session: MySqlAsyncSession<any, any>;
+
+	prepare(): MySqlAsyncSelectPrepare<this> {
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+		const preparedQuery = this.session.prepareQuery<
+			MySqlPreparedQueryConfig & { execute: TResult[] }
+		>(query, 'arrays', mapper, {
+			type: 'select',
+			tables: [...this.usedTables],
+		}, this.cacheConfig);
+
+		return preparedQuery as MySqlAsyncSelectPrepare<this>;
+	}
+
+	execute = ((placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	}) as ReturnType<this['prepare']>['execute'];
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MySqlAsyncSelectBase, [QueryPromise]);
+
+export type AnyMySqlAsyncSelect = MySqlAsyncSelectBase<any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/mysql-core/async/session.ts b/drizzle-orm/src/mysql-core/async/session.ts
new file mode 100644
index 0000000000..220f307378
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/session.ts
@@ -0,0 +1,346 @@
+import { type Cache, NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind, is } from '~/entity.ts';
+import { DrizzleQueryError, TransactionRollbackError } from '~/errors.ts';
+import type { Logger } from '~/logger.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/mysql.ts';
+import { assertUnreachable } from '~/utils.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import {
+	type AnyMySqlMapper,
+	MySqlBasePreparedQuery,
+	type MySqlPreparedQueryConfig,
+	type MySqlQueryResultHKT,
+	MySqlSession,
+	type MySqlTransactionConfig,
+} from '../session.ts';
+import { MySqlAsyncDatabase } from './db.ts';
+
+export class MySqlAsyncPreparedQuery<T extends MySqlPreparedQueryConfig> extends MySqlBasePreparedQuery {
+	static override readonly [entityKind]: string = 'MySqlAsyncPreparedQuery';
+
+	/** @internal */
+	readonly mapper: {
+		(rows: any[]): any;
+		body?: string;
+	} | undefined;
+
+	private fastPath: boolean;
+
+	constructor(
+		protected executor: (params?: unknown[]) => Promise<any>,
+		protected _iterator: ((params?: unknown[]) => AsyncGenerator<any[]>) | undefined,
+		query: Query,
+		mapper:
+			| AnyMySqlMapper
+			| undefined,
+		readonly mode: 'arrays' | 'objects' | 'raw',
+		protected logger: Logger,
+		// cache instance
+		private cache: Cache | undefined,
+		// per query related metadata
+		private queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		private cacheConfig?: WithCacheConfig | undefined,
+	) {
+		super(query);
+		this.mapper = mapper;
+		// it means that no $withCache options were passed and it should be just enabled
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+
+		this.fastPath = cacheConfig === undefined
+			&& (cache === undefined || is(cache, NoopCache));
+	}
+
+	/** @internal */
+	protected async queryWithCache<T>(
+		queryString: string,
+		params: any[],
+		query: () => Promise<T>,
+	): Promise<T> {
+		const cacheStrat = this.cache !== undefined && !is(this.cache, NoopCache)
+			? await strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)
+			: { type: 'skip' as const };
+
+		if (cacheStrat.type === 'skip') {
+			return query().catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		const cache = this.cache!;
+
+		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+		if (cacheStrat.type === 'invalidate') {
+			return Promise.all([
+				query(),
+				cache.onMutate({ tables: cacheStrat.tables }),
+			]).then((res) => res[0]).catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		if (cacheStrat.type === 'try') {
+			const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+			const fromCache = await cache.get(
+				key,
+				tables,
+				isTag,
+				autoInvalidate,
+			);
+
+			if (fromCache === undefined) {
+				const result = await query().catch((e) => {
+					throw new DrizzleQueryError(queryString, params, e as Error);
+				});
+				// put actual key
+				await cache.put(
+					key,
+					result,
+					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+				// put flag if we should invalidate or not
+				return result;
+			}
+
+			return fromCache as unknown as T;
+		}
+
+		assertUnreachable(cacheStrat);
+	}
+
+	override async execute(placeholderValues: Record<string, unknown> = {}): Promise<T['execute']> {
+		const { query, logger, executor, mapper, fastPath } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+		const res = fastPath
+			? executor(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, () => executor(params));
+		if (!mapper) return res;
+
+		return res.then((rows) => mapper(rows));
+	}
+
+	async *iterator(placeholderValues: Record<string, unknown> = {}): AsyncGenerator<T['iterator']> {
+		const { query, logger, executor, _iterator, mapper, fastPath } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+
+		if (_iterator) {
+			try {
+				if (mapper) {
+					for await (const row of _iterator(params)) {
+						yield (mapper([row])[0]);
+					}
+
+					return;
+				}
+
+				for await (const row of _iterator(params)) {
+					yield row as Awaited<T['iterator']>;
+				}
+
+				return;
+			} catch (e) {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			}
+		}
+
+		// Fallback for compatibility between drivers
+		const rows = await (fastPath
+			? executor(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, () => executor(params)));
+
+		if (mapper) {
+			for (const row of rows) {
+				yield mapper([row])[0];
+			}
+
+			return;
+		}
+
+		for (const row of rows) {
+			yield row;
+		}
+
+		return;
+	}
+}
+
+export abstract class MySqlAsyncSession<
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlSession {
+	static override readonly [entityKind]: string = 'MySqlAsyncSession';
+
+	abstract override prepareQuery<T extends MySqlPreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (rows: any) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): MySqlAsyncPreparedQuery<T>;
+
+	override execute<T>(query: SQL): Promise<T> {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T }>(
+			this.dialect.sqlToQuery(query),
+			'raw',
+		).execute();
+	}
+
+	override arrays<T>(query: SQL): Promise<T[]> {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'arrays',
+		).execute();
+	}
+
+	override objects<T>(query: SQL): Promise<T[]> {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'objects',
+		).execute();
+	}
+
+	abstract transaction<T>(
+		transaction: (
+			tx: MySqlAsyncTransaction<TQueryResult, TRelations>,
+		) => Promise<T>,
+		config?: MySqlTransactionConfig,
+	): Promise<T>;
+}
+
+export abstract class MySqlAsyncTransaction<
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlAsyncDatabase<TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'MySqlAsyncTransaction';
+
+	constructor(
+		dialect: MySqlDialect,
+		session: MySqlAsyncSession,
+		protected relations: TRelations,
+		protected readonly nestedIndex: number,
+	) {
+		super(dialect, session, relations);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+
+	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
+	abstract override transaction<T>(
+		transaction: (
+			tx: MySqlAsyncTransaction<TQueryResult, TRelations>,
+		) => Promise<T>,
+	): Promise<T>;
+}
+
+export async function migrate(
+	migrations: MigrationMeta[],
+	db: MySqlAsyncDatabase<MySqlQueryResultHKT, any>,
+	config: Omit<MigrationConfig, 'migrationsSchema'>,
+): Promise<void | MigratorInitFailResponse> {
+	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded(
+		migrationsTable,
+		db.session,
+		migrations,
+	);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash TEXT NOT NULL,
+				created_at BIGINT,
+				name TEXT,
+				applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+			)
+		`;
+		await db.session.execute(migrationTableCreate);
+	}
+
+	const dbMigrations = await db.session.objects<{
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await db.session.execute(
+			sql`insert into ${
+				sql.identifier(
+					migrationsTable,
+				)
+			} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({
+		localMigrations: migrations,
+		dbMigrations,
+	});
+	await db.transaction(async (tx) => {
+		for (const migration of migrationsToRun) {
+			for (const stmt of migration.sql) {
+				await tx.execute(sql.raw(stmt));
+			}
+			await tx.execute(
+				sql`insert into ${
+					sql.identifier(
+						migrationsTable,
+					)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+			);
+		}
+	});
+}
diff --git a/drizzle-orm/src/mysql-core/async/update.ts b/drizzle-orm/src/mysql-core/async/update.ts
new file mode 100644
index 0000000000..bbad0bbeb4
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/async/update.ts
@@ -0,0 +1,79 @@
+import { entityKind } from '~/entity.ts';
+import { MySqlUpdateBase, type MySqlUpdateHKTBase } from '~/mysql-core/query-builders/update.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlAsyncPreparedQuery, MySqlAsyncSession } from './session.ts';
+
+export type MySqlAsyncUpdate<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+> = MySqlAsyncUpdateBase<TTable, TQueryResult, true, never>;
+
+export type MySqlAsyncUpdatePrepare<T extends AnyMySqlAsyncUpdate> = MySqlAsyncPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	}
+>;
+
+export type AnyMySqlAsyncUpdate = MySqlAsyncUpdateBase<any, any, any, any>;
+
+export interface MySqlAsyncUpdateHKT extends MySqlUpdateHKTBase {
+	_type: MySqlAsyncUpdateBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export interface MySqlAsyncUpdateBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> {}
+
+export class MySqlAsyncUpdateBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends MySqlUpdateBase<MySqlAsyncUpdateHKT, TTable, TQueryResult, TDynamic, TExcludedMethods> {
+	static override readonly [entityKind]: string = 'MySqlAsyncUpdate';
+
+	declare protected session: MySqlAsyncSession<TQueryResult, any>;
+
+	prepare(): MySqlAsyncUpdatePrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'raw',
+			undefined,
+			{
+				type: 'update',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as MySqlAsyncUpdatePrepare<this>;
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MySqlAsyncUpdateBase, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/casing.ts b/drizzle-orm/src/mysql-core/casing.ts
new file mode 100644
index 0000000000..db5be15cb4
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/casing.ts
@@ -0,0 +1,19 @@
+import { type MySqlSchema, mysqlSchema } from './schema.ts';
+import { mysqlTableWithCasing } from './table.ts';
+import { mysqlViewWithCasing } from './view.ts';
+
+export const snakeCase = {
+	table: mysqlTableWithCasing('snake_case'),
+	view: mysqlViewWithCasing('snake_case'),
+	schema: <T extends string>(name: T): MySqlSchema<T> => {
+		return mysqlSchema(name, 'snake_case');
+	},
+};
+
+export const camelCase = {
+	table: mysqlTableWithCasing('camelCase'),
+	view: mysqlViewWithCasing('camelCase'),
+	schema: <T extends string>(name: T): MySqlSchema<T> => {
+		return mysqlSchema(name, 'camelCase');
+	},
+};
diff --git a/drizzle-orm/src/mysql-core/codecs.ts b/drizzle-orm/src/mysql-core/codecs.ts
new file mode 100644
index 0000000000..0e967a05c6
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/codecs.ts
@@ -0,0 +1,2966 @@
+import { type CastCodec, type Codecs, refineCodecs } from '~/codecs.ts';
+import { sql } from '~/sql/sql.ts';
+import type { PartialWithUndefined } from '~/utils.ts';
+
+export type MySqlType =
+	// Numeric
+	| 'tinyint'
+	| 'smallint'
+	| 'mediumint'
+	| 'int'
+	| 'bigint'
+	| 'bigint:number'
+	| 'bigint:string'
+	| 'serial'
+	| 'decimal'
+	| 'decimal:number'
+	| 'decimal:bigint'
+	| 'float'
+	| 'double'
+	| 'real'
+	| 'bit'
+	// Boolean
+	| 'boolean'
+	// Text
+	| 'char'
+	| 'varchar'
+	| 'tinytext'
+	| 'text'
+	| 'mediumtext'
+	| 'longtext'
+	// Enumerated
+	| 'enum'
+	| 'set'
+	// Binary
+	| 'binary'
+	| 'varbinary'
+	| 'tinyblob'
+	| 'tinyblob:buffer'
+	| 'blob'
+	| 'blob:buffer'
+	| 'mediumblob'
+	| 'mediumblob:buffer'
+	| 'longblob'
+	| 'longblob:buffer'
+	// Datetime
+	| 'date'
+	| 'date:string'
+	| 'datetime'
+	| 'datetime:string'
+	| 'time'
+	| 'timestamp'
+	| 'timestamp:string'
+	| 'year'
+	// JSON
+	| 'json'
+	// Spatial
+	| 'geometry'
+	| 'point'
+	| 'linestring'
+	| 'polygon'
+	| 'multipoint'
+	| 'multilinestring'
+	| 'multipolygon'
+	| 'geometrycollection';
+
+// Some originals were swapped with aliases for simpler keys
+export type MySqlAliasType =
+	// Numeric
+	| 'integer' // int
+	| 'int1' // tinyint
+	| 'int2' // smallint
+	| 'int3' // mediumint
+	| 'middleint' // mediumint
+	| 'int4' // int
+	| 'int8' // bigint
+	| 'dec' // decimal
+	| 'fixed' // decimal
+	| 'numeric' // decimal
+	| 'double precision' // double
+	// Boolean
+	| 'bool' // boolean
+	// Text
+	| 'character' // char
+	| 'nchar' // char
+	| 'national char' // char
+	| 'national character' // char
+	| 'character varying' // varchar
+	| 'char varying' // varchar
+	| 'nvarchar' // varchar
+	| 'national varchar' // varchar
+	| 'national character varying' // varchar
+	| 'long varchar' // mediumtext
+	| 'long' // mediumtext
+	// Binary
+	| 'long varbinary'; // mediumblob
+
+export type MySqlColumnType =
+	| MySqlType
+	| MySqlAliasType;
+
+const MYSQL_ALIAS_TO_TYPE_MAP: Record<MySqlAliasType, MySqlType> = {
+	integer: 'int',
+	int1: 'tinyint',
+	int2: 'smallint',
+	int3: 'mediumint',
+	middleint: 'mediumint',
+	int4: 'int',
+	int8: 'bigint',
+	dec: 'decimal',
+	fixed: 'decimal',
+	numeric: 'decimal',
+	'double precision': 'double',
+	bool: 'boolean',
+	character: 'char',
+	nchar: 'char',
+	'national char': 'char',
+	'national character': 'char',
+	'character varying': 'varchar',
+	'char varying': 'varchar',
+	nvarchar: 'varchar',
+	'national varchar': 'varchar',
+	'national character varying': 'varchar',
+	'long varchar': 'mediumtext',
+	long: 'mediumtext',
+	'long varbinary': 'mediumblob',
+};
+
+export function resolveMySqlTypeAlias(type: string) {
+	return (MYSQL_ALIAS_TO_TYPE_MAP as Record<string, MySqlType | undefined>)[type] ?? type;
+}
+
+// Cross-type unions mutate data types
+// update codec based on type combination
+export const unionsTypeTable = {
+	tinyint: {
+		tinyint: 'tinyint',
+		smallint: 'smallint',
+		mediumint: 'mediumint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'tinyint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'tinyint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	smallint: {
+		tinyint: 'smallint',
+		smallint: 'smallint',
+		mediumint: 'mediumint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'smallint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'smallint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	mediumint: {
+		tinyint: 'mediumint',
+		smallint: 'mediumint',
+		mediumint: 'mediumint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'mediumint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'mediumint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	int: {
+		tinyint: 'int',
+		smallint: 'int',
+		mediumint: 'int',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'int',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'int',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	bigint: {
+		tinyint: 'bigint',
+		smallint: 'bigint',
+		mediumint: 'bigint',
+		int: 'bigint',
+		bigint: 'bigint',
+		'bigint:number': 'bigint',
+		'bigint:string': 'bigint',
+		serial: 'decimal:bigint',
+		decimal: 'decimal:bigint',
+		'decimal:number': 'decimal:bigint',
+		'decimal:bigint': 'decimal:bigint',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:bigint',
+		boolean: 'bigint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'bigint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'bigint:number': {
+		tinyint: 'bigint:number',
+		smallint: 'bigint:number',
+		mediumint: 'bigint:number',
+		int: 'bigint:number',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'bigint:number',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'bigint:number',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'bigint:string': {
+		tinyint: 'bigint:string',
+		smallint: 'bigint:string',
+		mediumint: 'bigint:string',
+		int: 'bigint:string',
+		bigint: 'bigint:string',
+		'bigint:number': 'bigint:string',
+		'bigint:string': 'bigint:string',
+		serial: 'decimal',
+		decimal: 'decimal',
+		'decimal:number': 'decimal',
+		'decimal:bigint': 'decimal',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal',
+		boolean: 'bigint:string',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'bigint:string',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	serial: {
+		tinyint: 'decimal:number',
+		smallint: 'decimal:number',
+		mediumint: 'decimal:number',
+		int: 'decimal:number',
+		bigint: 'decimal:number',
+		'bigint:number': 'decimal:number',
+		'bigint:string': 'decimal:number',
+		serial: 'bigint:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'bigint:number',
+		boolean: 'decimal:number',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'bigint:number',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	decimal: {
+		tinyint: 'decimal',
+		smallint: 'decimal',
+		mediumint: 'decimal',
+		int: 'decimal',
+		bigint: 'decimal',
+		'bigint:number': 'decimal',
+		'bigint:string': 'decimal',
+		serial: 'decimal',
+		decimal: 'decimal',
+		'decimal:number': 'decimal',
+		'decimal:bigint': 'decimal',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal',
+		boolean: 'decimal',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'decimal',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'decimal:number': {
+		tinyint: 'decimal:number',
+		smallint: 'decimal:number',
+		mediumint: 'decimal:number',
+		int: 'decimal:number',
+		bigint: 'decimal:number',
+		'bigint:number': 'decimal:number',
+		'bigint:string': 'decimal:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'decimal:number',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'decimal:number',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'decimal:bigint': {
+		tinyint: 'decimal:bigint',
+		smallint: 'decimal:bigint',
+		mediumint: 'decimal:bigint',
+		int: 'decimal:bigint',
+		bigint: 'decimal:bigint',
+		'bigint:number': 'decimal:bigint',
+		'bigint:string': 'decimal:bigint',
+		serial: 'decimal:bigint',
+		decimal: 'decimal:bigint',
+		'decimal:number': 'decimal:bigint',
+		'decimal:bigint': 'decimal:bigint',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:bigint',
+		boolean: 'decimal:bigint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'decimal:bigint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	float: {
+		tinyint: 'float',
+		smallint: 'float',
+		mediumint: 'float',
+		int: 'double',
+		bigint: 'float',
+		'bigint:number': 'float',
+		'bigint:string': 'float',
+		serial: 'float',
+		decimal: 'double',
+		'decimal:number': 'double',
+		'decimal:bigint': 'double',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'double',
+		boolean: 'float',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'float',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	double: {
+		tinyint: 'double',
+		smallint: 'double',
+		mediumint: 'double',
+		int: 'double',
+		bigint: 'double',
+		'bigint:number': 'double',
+		'bigint:string': 'double',
+		serial: 'double',
+		decimal: 'double',
+		'decimal:number': 'double',
+		'decimal:bigint': 'double',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'double',
+		boolean: 'double',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'double',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	real: {
+		tinyint: 'double',
+		smallint: 'double',
+		mediumint: 'double',
+		int: 'double',
+		bigint: 'double',
+		'bigint:number': 'double',
+		'bigint:string': 'double',
+		serial: 'double',
+		decimal: 'double',
+		'decimal:number': 'double',
+		'decimal:bigint': 'double',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'double',
+		boolean: 'double',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'double',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	bit: {
+		tinyint: 'decimal',
+		smallint: 'decimal',
+		mediumint: 'decimal',
+		int: 'decimal',
+		bigint: 'decimal',
+		'bigint:number': 'decimal',
+		'bigint:string': 'decimal',
+		serial: 'bigint:string',
+		decimal: 'decimal',
+		'decimal:number': 'decimal',
+		'decimal:bigint': 'decimal',
+		float: 'double',
+		double: 'double',
+		real: 'double',
+		bit: 'bit',
+		boolean: 'decimal',
+		char: 'binary',
+		varchar: 'varbinary',
+		tinytext: 'blob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'varbinary',
+		set: 'varbinary',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varbinary',
+		'date:string': 'varbinary',
+		datetime: 'varbinary',
+		'datetime:string': 'varbinary',
+		time: 'varbinary',
+		timestamp: 'varbinary',
+		'timestamp:string': 'varbinary',
+		year: 'bigint:string',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	boolean: {
+		tinyint: 'tinyint',
+		smallint: 'smallint',
+		mediumint: 'mediumint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'decimal:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'decimal:number',
+		boolean: 'boolean',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'tinyint',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	char: {
+		tinyint: 'char',
+		smallint: 'char',
+		mediumint: 'char',
+		int: 'char',
+		bigint: 'char',
+		'bigint:number': 'char',
+		'bigint:string': 'char',
+		serial: 'char',
+		decimal: 'char',
+		'decimal:number': 'char',
+		'decimal:bigint': 'char',
+		float: 'char',
+		double: 'char',
+		real: 'char',
+		bit: 'binary',
+		boolean: 'char',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'char',
+		set: 'char',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'char',
+		'date:string': 'char',
+		datetime: 'char',
+		'datetime:string': 'char',
+		time: 'char',
+		timestamp: 'char',
+		'timestamp:string': 'char',
+		year: 'char',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	varchar: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'varchar',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'varbinary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	tinytext: {
+		tinyint: 'text',
+		smallint: 'text',
+		mediumint: 'text',
+		int: 'text',
+		bigint: 'text',
+		'bigint:number': 'text',
+		'bigint:string': 'text',
+		serial: 'text',
+		decimal: 'text',
+		'decimal:number': 'text',
+		'decimal:bigint': 'text',
+		float: 'text',
+		double: 'text',
+		real: 'text',
+		bit: 'blob',
+		boolean: 'text',
+		char: 'text',
+		varchar: 'text',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'text',
+		set: 'text',
+		binary: 'blob',
+		varbinary: 'blob',
+		tinyblob: 'blob',
+		'tinyblob:buffer': 'blob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'text',
+		'date:string': 'text',
+		datetime: 'text',
+		'datetime:string': 'text',
+		time: 'text',
+		timestamp: 'text',
+		'timestamp:string': 'text',
+		year: 'text',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	text: {
+		tinyint: 'mediumtext',
+		smallint: 'mediumtext',
+		mediumint: 'mediumtext',
+		int: 'mediumtext',
+		bigint: 'mediumtext',
+		'bigint:number': 'mediumtext',
+		'bigint:string': 'mediumtext',
+		serial: 'mediumtext',
+		decimal: 'mediumtext',
+		'decimal:number': 'mediumtext',
+		'decimal:bigint': 'mediumtext',
+		float: 'mediumtext',
+		double: 'mediumtext',
+		real: 'mediumtext',
+		bit: 'mediumblob',
+		boolean: 'mediumtext',
+		char: 'mediumtext',
+		varchar: 'mediumtext',
+		tinytext: 'mediumtext',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'mediumtext',
+		set: 'mediumtext',
+		binary: 'mediumblob',
+		varbinary: 'mediumblob',
+		tinyblob: 'mediumblob',
+		'tinyblob:buffer': 'mediumblob',
+		blob: 'mediumblob',
+		'blob:buffer': 'mediumblob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'mediumtext',
+		'date:string': 'mediumtext',
+		datetime: 'mediumtext',
+		'datetime:string': 'mediumtext',
+		time: 'mediumtext',
+		timestamp: 'mediumtext',
+		'timestamp:string': 'mediumtext',
+		year: 'mediumtext',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	mediumtext: {
+		tinyint: 'longtext',
+		smallint: 'longtext',
+		mediumint: 'longtext',
+		int: 'longtext',
+		bigint: 'longtext',
+		'bigint:number': 'longtext',
+		'bigint:string': 'longtext',
+		serial: 'longtext',
+		decimal: 'longtext',
+		'decimal:number': 'longtext',
+		'decimal:bigint': 'longtext',
+		float: 'longtext',
+		double: 'longtext',
+		real: 'longtext',
+		bit: 'longblob',
+		boolean: 'longtext',
+		char: 'longtext',
+		varchar: 'longtext',
+		tinytext: 'longtext',
+		text: 'longtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'longtext',
+		set: 'longtext',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longtext',
+		'date:string': 'longtext',
+		datetime: 'longtext',
+		'datetime:string': 'longtext',
+		time: 'longtext',
+		timestamp: 'longtext',
+		'timestamp:string': 'longtext',
+		year: 'longtext',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	longtext: {
+		tinyint: 'longtext',
+		smallint: 'longtext',
+		mediumint: 'longtext',
+		int: 'longtext',
+		bigint: 'longtext',
+		'bigint:number': 'longtext',
+		'bigint:string': 'longtext',
+		serial: 'longtext',
+		decimal: 'longtext',
+		'decimal:number': 'longtext',
+		'decimal:bigint': 'longtext',
+		float: 'longtext',
+		double: 'longtext',
+		real: 'longtext',
+		bit: 'longblob',
+		boolean: 'longtext',
+		char: 'longtext',
+		varchar: 'longtext',
+		tinytext: 'longtext',
+		text: 'longtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'longtext',
+		set: 'longtext',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longtext',
+		'date:string': 'longtext',
+		datetime: 'longtext',
+		'datetime:string': 'longtext',
+		time: 'longtext',
+		timestamp: 'longtext',
+		'timestamp:string': 'longtext',
+		year: 'longtext',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	enum: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	set: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	binary: {
+		tinyint: 'binary',
+		smallint: 'binary',
+		mediumint: 'binary',
+		int: 'binary',
+		bigint: 'binary',
+		'bigint:number': 'binary',
+		'bigint:string': 'binary',
+		serial: 'binary',
+		decimal: 'binary',
+		'decimal:number': 'binary',
+		'decimal:bigint': 'binary',
+		float: 'binary',
+		double: 'binary',
+		real: 'binary',
+		bit: 'binary',
+		boolean: 'binary',
+		char: 'binary',
+		varchar: 'varbinary',
+		tinytext: 'blob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'binary',
+		set: 'binary',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'binary',
+		'date:string': 'binary',
+		datetime: 'binary',
+		'datetime:string': 'binary',
+		time: 'binary',
+		timestamp: 'binary',
+		'timestamp:string': 'binary',
+		year: 'binary',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	varbinary: {
+		tinyint: 'varbinary',
+		smallint: 'varbinary',
+		mediumint: 'varbinary',
+		int: 'varbinary',
+		bigint: 'varbinary',
+		'bigint:number': 'varbinary',
+		'bigint:string': 'varbinary',
+		serial: 'varbinary',
+		decimal: 'varbinary',
+		'decimal:number': 'varbinary',
+		'decimal:bigint': 'varbinary',
+		float: 'varbinary',
+		double: 'varbinary',
+		real: 'varbinary',
+		bit: 'varbinary',
+		boolean: 'varbinary',
+		char: 'varbinary',
+		varchar: 'varbinary',
+		tinytext: 'blob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'varbinary',
+		set: 'varbinary',
+		binary: 'varbinary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varbinary',
+		'date:string': 'varbinary',
+		datetime: 'varbinary',
+		'datetime:string': 'varbinary',
+		time: 'varbinary',
+		timestamp: 'varbinary',
+		'timestamp:string': 'varbinary',
+		year: 'varbinary',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	tinyblob: {
+		tinyint: 'tinyblob',
+		smallint: 'tinyblob',
+		mediumint: 'tinyblob',
+		int: 'tinyblob',
+		bigint: 'tinyblob',
+		'bigint:number': 'tinyblob',
+		'bigint:string': 'tinyblob',
+		serial: 'tinyblob',
+		decimal: 'tinyblob',
+		'decimal:number': 'tinyblob',
+		'decimal:bigint': 'tinyblob',
+		float: 'tinyblob',
+		double: 'tinyblob',
+		real: 'tinyblob',
+		bit: 'tinyblob',
+		boolean: 'tinyblob',
+		char: 'tinyblob',
+		varchar: 'tinyblob',
+		tinytext: 'blob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'tinyblob',
+		set: 'tinyblob',
+		binary: 'tinyblob',
+		varbinary: 'tinyblob',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'tinyblob',
+		'date:string': 'tinyblob',
+		datetime: 'tinyblob',
+		'datetime:string': 'tinyblob',
+		time: 'tinyblob',
+		timestamp: 'tinyblob',
+		'timestamp:string': 'tinyblob',
+		year: 'tinyblob',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'tinyblob:buffer': {
+		tinyint: 'tinyblob:buffer',
+		smallint: 'tinyblob:buffer',
+		mediumint: 'tinyblob:buffer',
+		int: 'tinyblob:buffer',
+		bigint: 'tinyblob:buffer',
+		'bigint:number': 'tinyblob:buffer',
+		'bigint:string': 'tinyblob:buffer',
+		serial: 'tinyblob:buffer',
+		decimal: 'tinyblob:buffer',
+		'decimal:number': 'tinyblob:buffer',
+		'decimal:bigint': 'tinyblob:buffer',
+		float: 'tinyblob:buffer',
+		double: 'tinyblob:buffer',
+		real: 'tinyblob:buffer',
+		bit: 'tinyblob:buffer',
+		boolean: 'tinyblob:buffer',
+		char: 'tinyblob:buffer',
+		varchar: 'tinyblob:buffer',
+		tinytext: 'blob:buffer',
+		text: 'mediumblob:buffer',
+		mediumtext: 'longblob:buffer',
+		longtext: 'longblob:buffer',
+		enum: 'tinyblob:buffer',
+		set: 'tinyblob:buffer',
+		binary: 'tinyblob:buffer',
+		varbinary: 'tinyblob:buffer',
+		tinyblob: 'tinyblob:buffer',
+		'tinyblob:buffer': 'tinyblob:buffer',
+		blob: 'blob:buffer',
+		'blob:buffer': 'blob:buffer',
+		mediumblob: 'mediumblob:buffer',
+		'mediumblob:buffer': 'mediumblob:buffer',
+		longblob: 'longblob:buffer',
+		'longblob:buffer': 'longblob:buffer',
+		date: 'tinyblob:buffer',
+		'date:string': 'tinyblob:buffer',
+		datetime: 'tinyblob:buffer',
+		'datetime:string': 'tinyblob:buffer',
+		time: 'tinyblob:buffer',
+		timestamp: 'tinyblob:buffer',
+		'timestamp:string': 'tinyblob:buffer',
+		year: 'tinyblob:buffer',
+		json: 'longblob:buffer',
+		geometry: 'longblob:buffer',
+		point: 'longblob:buffer',
+		linestring: 'longblob:buffer',
+		polygon: 'longblob:buffer',
+		multipoint: 'longblob:buffer',
+		multilinestring: 'longblob:buffer',
+		multipolygon: 'longblob:buffer',
+		geometrycollection: 'longblob:buffer',
+	},
+	blob: {
+		tinyint: 'blob',
+		smallint: 'blob',
+		mediumint: 'blob',
+		int: 'blob',
+		bigint: 'blob',
+		'bigint:number': 'blob',
+		'bigint:string': 'blob',
+		serial: 'blob',
+		decimal: 'blob',
+		'decimal:number': 'blob',
+		'decimal:bigint': 'blob',
+		float: 'blob',
+		double: 'blob',
+		real: 'blob',
+		bit: 'blob',
+		boolean: 'blob',
+		char: 'blob',
+		varchar: 'blob',
+		tinytext: 'blob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'blob',
+		set: 'blob',
+		binary: 'blob',
+		varbinary: 'blob',
+		tinyblob: 'blob',
+		'tinyblob:buffer': 'blob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'blob',
+		'date:string': 'blob',
+		datetime: 'blob',
+		'datetime:string': 'blob',
+		time: 'blob',
+		timestamp: 'blob',
+		'timestamp:string': 'blob',
+		year: 'blob',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'blob:buffer': {
+		tinyint: 'blob:buffer',
+		smallint: 'blob:buffer',
+		mediumint: 'blob:buffer',
+		int: 'blob:buffer',
+		bigint: 'blob:buffer',
+		'bigint:number': 'blob:buffer',
+		'bigint:string': 'blob:buffer',
+		serial: 'blob:buffer',
+		decimal: 'blob:buffer',
+		'decimal:number': 'blob:buffer',
+		'decimal:bigint': 'blob:buffer',
+		float: 'blob:buffer',
+		double: 'blob:buffer',
+		real: 'blob:buffer',
+		bit: 'blob:buffer',
+		boolean: 'blob:buffer',
+		char: 'blob:buffer',
+		varchar: 'blob:buffer',
+		tinytext: 'blob:buffer',
+		text: 'mediumblob:buffer',
+		mediumtext: 'longblob:buffer',
+		longtext: 'longblob:buffer',
+		enum: 'blob:buffer',
+		set: 'blob:buffer',
+		binary: 'blob:buffer',
+		varbinary: 'blob:buffer',
+		tinyblob: 'blob:buffer',
+		'tinyblob:buffer': 'blob:buffer',
+		blob: 'blob:buffer',
+		'blob:buffer': 'blob:buffer',
+		mediumblob: 'mediumblob:buffer',
+		'mediumblob:buffer': 'mediumblob:buffer',
+		longblob: 'longblob:buffer',
+		'longblob:buffer': 'longblob:buffer',
+		date: 'blob:buffer',
+		'date:string': 'blob:buffer',
+		datetime: 'blob:buffer',
+		'datetime:string': 'blob:buffer',
+		time: 'blob:buffer',
+		timestamp: 'blob:buffer',
+		'timestamp:string': 'blob:buffer',
+		year: 'blob:buffer',
+		json: 'longblob:buffer',
+		geometry: 'longblob:buffer',
+		point: 'longblob:buffer',
+		linestring: 'longblob:buffer',
+		polygon: 'longblob:buffer',
+		multipoint: 'longblob:buffer',
+		multilinestring: 'longblob:buffer',
+		multipolygon: 'longblob:buffer',
+		geometrycollection: 'longblob:buffer',
+	},
+	mediumblob: {
+		tinyint: 'mediumblob',
+		smallint: 'mediumblob',
+		mediumint: 'mediumblob',
+		int: 'mediumblob',
+		bigint: 'mediumblob',
+		'bigint:number': 'mediumblob',
+		'bigint:string': 'mediumblob',
+		serial: 'mediumblob',
+		decimal: 'mediumblob',
+		'decimal:number': 'mediumblob',
+		'decimal:bigint': 'mediumblob',
+		float: 'mediumblob',
+		double: 'mediumblob',
+		real: 'mediumblob',
+		bit: 'mediumblob',
+		boolean: 'mediumblob',
+		char: 'mediumblob',
+		varchar: 'mediumblob',
+		tinytext: 'mediumblob',
+		text: 'mediumblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'mediumblob',
+		set: 'mediumblob',
+		binary: 'mediumblob',
+		varbinary: 'mediumblob',
+		tinyblob: 'mediumblob',
+		'tinyblob:buffer': 'mediumblob',
+		blob: 'mediumblob',
+		'blob:buffer': 'mediumblob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'mediumblob',
+		'date:string': 'mediumblob',
+		datetime: 'mediumblob',
+		'datetime:string': 'mediumblob',
+		time: 'mediumblob',
+		timestamp: 'mediumblob',
+		'timestamp:string': 'mediumblob',
+		year: 'mediumblob',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'mediumblob:buffer': {
+		tinyint: 'mediumblob:buffer',
+		smallint: 'mediumblob:buffer',
+		mediumint: 'mediumblob:buffer',
+		int: 'mediumblob:buffer',
+		bigint: 'mediumblob:buffer',
+		'bigint:number': 'mediumblob:buffer',
+		'bigint:string': 'mediumblob:buffer',
+		serial: 'mediumblob:buffer',
+		decimal: 'mediumblob:buffer',
+		'decimal:number': 'mediumblob:buffer',
+		'decimal:bigint': 'mediumblob:buffer',
+		float: 'mediumblob:buffer',
+		double: 'mediumblob:buffer',
+		real: 'mediumblob:buffer',
+		bit: 'mediumblob:buffer',
+		boolean: 'mediumblob:buffer',
+		char: 'mediumblob:buffer',
+		varchar: 'mediumblob:buffer',
+		tinytext: 'mediumblob:buffer',
+		text: 'mediumblob:buffer',
+		mediumtext: 'longblob:buffer',
+		longtext: 'longblob:buffer',
+		enum: 'mediumblob:buffer',
+		set: 'mediumblob:buffer',
+		binary: 'mediumblob:buffer',
+		varbinary: 'mediumblob:buffer',
+		tinyblob: 'mediumblob:buffer',
+		'tinyblob:buffer': 'mediumblob:buffer',
+		blob: 'mediumblob:buffer',
+		'blob:buffer': 'mediumblob:buffer',
+		mediumblob: 'mediumblob:buffer',
+		'mediumblob:buffer': 'mediumblob:buffer',
+		longblob: 'longblob:buffer',
+		'longblob:buffer': 'longblob:buffer',
+		date: 'mediumblob:buffer',
+		'date:string': 'mediumblob:buffer',
+		datetime: 'mediumblob:buffer',
+		'datetime:string': 'mediumblob:buffer',
+		time: 'mediumblob:buffer',
+		timestamp: 'mediumblob:buffer',
+		'timestamp:string': 'mediumblob:buffer',
+		year: 'mediumblob:buffer',
+		json: 'longblob:buffer',
+		geometry: 'longblob:buffer',
+		point: 'longblob:buffer',
+		linestring: 'longblob:buffer',
+		polygon: 'longblob:buffer',
+		multipoint: 'longblob:buffer',
+		multilinestring: 'longblob:buffer',
+		multipolygon: 'longblob:buffer',
+		geometrycollection: 'longblob:buffer',
+	},
+	longblob: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'longblob:buffer': {
+		tinyint: 'longblob:buffer',
+		smallint: 'longblob:buffer',
+		mediumint: 'longblob:buffer',
+		int: 'longblob:buffer',
+		bigint: 'longblob:buffer',
+		'bigint:number': 'longblob:buffer',
+		'bigint:string': 'longblob:buffer',
+		serial: 'longblob:buffer',
+		decimal: 'longblob:buffer',
+		'decimal:number': 'longblob:buffer',
+		'decimal:bigint': 'longblob:buffer',
+		float: 'longblob:buffer',
+		double: 'longblob:buffer',
+		real: 'longblob:buffer',
+		bit: 'longblob:buffer',
+		boolean: 'longblob:buffer',
+		char: 'longblob:buffer',
+		varchar: 'longblob:buffer',
+		tinytext: 'longblob:buffer',
+		text: 'longblob:buffer',
+		mediumtext: 'longblob:buffer',
+		longtext: 'longblob:buffer',
+		enum: 'longblob:buffer',
+		set: 'longblob:buffer',
+		binary: 'longblob:buffer',
+		varbinary: 'longblob:buffer',
+		tinyblob: 'longblob:buffer',
+		'tinyblob:buffer': 'longblob:buffer',
+		blob: 'longblob:buffer',
+		'blob:buffer': 'longblob:buffer',
+		mediumblob: 'longblob:buffer',
+		'mediumblob:buffer': 'longblob:buffer',
+		longblob: 'longblob:buffer',
+		'longblob:buffer': 'longblob:buffer',
+		date: 'longblob:buffer',
+		'date:string': 'longblob:buffer',
+		datetime: 'longblob:buffer',
+		'datetime:string': 'longblob:buffer',
+		time: 'longblob:buffer',
+		timestamp: 'longblob:buffer',
+		'timestamp:string': 'longblob:buffer',
+		year: 'longblob:buffer',
+		json: 'longblob:buffer',
+		geometry: 'longblob:buffer',
+		point: 'longblob:buffer',
+		linestring: 'longblob:buffer',
+		polygon: 'longblob:buffer',
+		multipoint: 'longblob:buffer',
+		multilinestring: 'longblob:buffer',
+		multipolygon: 'longblob:buffer',
+		geometrycollection: 'longblob:buffer',
+	},
+	date: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'date',
+		'date:string': 'date',
+		datetime: 'datetime',
+		'datetime:string': 'datetime',
+		time: 'datetime',
+		timestamp: 'datetime',
+		'timestamp:string': 'datetime',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'date:string': {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'date:string',
+		'date:string': 'date:string',
+		datetime: 'datetime:string',
+		'datetime:string': 'datetime:string',
+		time: 'datetime:string',
+		timestamp: 'datetime:string',
+		'timestamp:string': 'datetime:string',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	datetime: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'datetime',
+		'date:string': 'datetime',
+		datetime: 'datetime',
+		'datetime:string': 'datetime',
+		time: 'datetime',
+		timestamp: 'datetime',
+		'timestamp:string': 'datetime',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'datetime:string': {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'datetime:string',
+		'date:string': 'datetime:string',
+		datetime: 'datetime:string',
+		'datetime:string': 'datetime:string',
+		time: 'datetime:string',
+		timestamp: 'datetime:string',
+		'timestamp:string': 'datetime:string',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	time: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'datetime:string',
+		'date:string': 'datetime:string',
+		datetime: 'datetime:string',
+		'datetime:string': 'datetime:string',
+		time: 'time',
+		timestamp: 'datetime:string',
+		'timestamp:string': 'datetime:string',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	timestamp: {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'datetime',
+		'date:string': 'datetime',
+		datetime: 'datetime',
+		'datetime:string': 'datetime',
+		time: 'datetime',
+		timestamp: 'timestamp',
+		'timestamp:string': 'timestamp',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	'timestamp:string': {
+		tinyint: 'varchar',
+		smallint: 'varchar',
+		mediumint: 'varchar',
+		int: 'varchar',
+		bigint: 'varchar',
+		'bigint:number': 'varchar',
+		'bigint:string': 'varchar',
+		serial: 'varchar',
+		decimal: 'varchar',
+		'decimal:number': 'varchar',
+		'decimal:bigint': 'varchar',
+		float: 'varchar',
+		double: 'varchar',
+		real: 'varchar',
+		bit: 'varbinary',
+		boolean: 'varchar',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'datetime:string',
+		'date:string': 'datetime:string',
+		datetime: 'datetime:string',
+		'datetime:string': 'datetime:string',
+		time: 'datetime:string',
+		timestamp: 'timestamp:string',
+		'timestamp:string': 'timestamp:string',
+		year: 'varchar',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	year: {
+		tinyint: 'tinyint',
+		smallint: 'smallint',
+		mediumint: 'mediumint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		serial: 'bigint:number',
+		decimal: 'decimal:number',
+		'decimal:number': 'decimal:number',
+		'decimal:bigint': 'decimal:number',
+		float: 'float',
+		double: 'double',
+		real: 'double',
+		bit: 'bigint:number',
+		boolean: 'tinyint',
+		char: 'char',
+		varchar: 'varchar',
+		tinytext: 'text',
+		text: 'mediumtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'varchar',
+		set: 'varchar',
+		binary: 'binary',
+		varbinary: 'varbinary',
+		tinyblob: 'tinyblob',
+		'tinyblob:buffer': 'tinyblob',
+		blob: 'blob',
+		'blob:buffer': 'blob',
+		mediumblob: 'mediumblob',
+		'mediumblob:buffer': 'mediumblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'varchar',
+		'date:string': 'varchar',
+		datetime: 'varchar',
+		'datetime:string': 'varchar',
+		time: 'varchar',
+		timestamp: 'varchar',
+		'timestamp:string': 'varchar',
+		year: 'year',
+		json: 'longtext',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	json: {
+		tinyint: 'longtext',
+		smallint: 'longtext',
+		mediumint: 'longtext',
+		int: 'longtext',
+		bigint: 'longtext',
+		'bigint:number': 'longtext',
+		'bigint:string': 'longtext',
+		serial: 'longtext',
+		decimal: 'longtext',
+		'decimal:number': 'longtext',
+		'decimal:bigint': 'longtext',
+		float: 'longtext',
+		double: 'longtext',
+		real: 'longtext',
+		bit: 'longblob',
+		boolean: 'longtext',
+		char: 'longtext',
+		varchar: 'longtext',
+		tinytext: 'longtext',
+		text: 'longtext',
+		mediumtext: 'longtext',
+		longtext: 'longtext',
+		enum: 'longtext',
+		set: 'longtext',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longtext',
+		'date:string': 'longtext',
+		datetime: 'longtext',
+		'datetime:string': 'longtext',
+		time: 'longtext',
+		timestamp: 'longtext',
+		'timestamp:string': 'longtext',
+		year: 'longtext',
+		json: 'json',
+		geometry: 'longblob',
+		point: 'longblob',
+		linestring: 'longblob',
+		polygon: 'longblob',
+		multipoint: 'longblob',
+		multilinestring: 'longblob',
+		multipolygon: 'longblob',
+		geometrycollection: 'longblob',
+	},
+	geometry: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	point: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'point',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	linestring: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'linestring',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	polygon: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'polygon',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	multipoint: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'multipoint',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	multilinestring: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'multilinestring',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometry',
+	},
+	multipolygon: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'multipolygon',
+		geometrycollection: 'geometry',
+	},
+	geometrycollection: {
+		tinyint: 'longblob',
+		smallint: 'longblob',
+		mediumint: 'longblob',
+		int: 'longblob',
+		bigint: 'longblob',
+		'bigint:number': 'longblob',
+		'bigint:string': 'longblob',
+		serial: 'longblob',
+		decimal: 'longblob',
+		'decimal:number': 'longblob',
+		'decimal:bigint': 'longblob',
+		float: 'longblob',
+		double: 'longblob',
+		real: 'longblob',
+		bit: 'longblob',
+		boolean: 'longblob',
+		char: 'longblob',
+		varchar: 'longblob',
+		tinytext: 'longblob',
+		text: 'longblob',
+		mediumtext: 'longblob',
+		longtext: 'longblob',
+		enum: 'longblob',
+		set: 'longblob',
+		binary: 'longblob',
+		varbinary: 'longblob',
+		tinyblob: 'longblob',
+		'tinyblob:buffer': 'longblob',
+		blob: 'longblob',
+		'blob:buffer': 'longblob',
+		mediumblob: 'longblob',
+		'mediumblob:buffer': 'longblob',
+		longblob: 'longblob',
+		'longblob:buffer': 'longblob',
+		date: 'longblob',
+		'date:string': 'longblob',
+		datetime: 'longblob',
+		'datetime:string': 'longblob',
+		time: 'longblob',
+		timestamp: 'longblob',
+		'timestamp:string': 'longblob',
+		year: 'longblob',
+		json: 'longblob',
+		geometry: 'geometry',
+		point: 'geometry',
+		linestring: 'geometry',
+		polygon: 'geometry',
+		multipoint: 'geometry',
+		multilinestring: 'geometry',
+		multipolygon: 'geometry',
+		geometrycollection: 'geometrycollection',
+	},
+} as const satisfies Partial<Record<MySqlColumnType, Partial<Record<MySqlColumnType, MySqlColumnType>>>>;
+
+export type MySqlCodecs = Codecs<MySqlType>;
+
+export const castToText: CastCodec = (name) => sql`cast(${name} as char)`;
+
+/** Recover float32 casted to double
+ *
+ * Needed to avoid db\driver-side rounding
+ */
+export const floatFromDouble = (value: number): number => {
+	const f = Math.fround(value);
+	if (!Number.isFinite(f)) return f;
+
+	for (let precision = 1; precision <= 9; precision++) {
+		const candidate = Number(f.toPrecision(precision));
+		if (Math.fround(candidate) === f) return candidate;
+	}
+
+	return f;
+};
+
+/** Recover float32 casted to double -> string
+ *
+ * Needed to avoid db\driver-side rounding
+ */
+export const floatFromDoubleString = (value: string): number => {
+	const f = Math.fround(Number(value));
+	if (!Number.isFinite(f)) return f;
+
+	for (let precision = 1; precision <= 9; precision++) {
+		const candidate = Number(f.toPrecision(precision));
+		if (Math.fround(candidate) === f) return candidate;
+	}
+
+	return f;
+};
+
+export const genericMySqlCodecs = {
+	boolean: {
+		normalizeInJson: Boolean,
+	},
+	date: {
+		normalizeInJson: (value: string) => new Date(value),
+	},
+	float: {
+		normalizeInJson: floatFromDoubleString,
+	},
+	bigint: {
+		castInJson: castToText,
+		normalizeInJson: BigInt,
+	},
+	'bigint:number': {
+		castInJson: castToText,
+		normalizeInJson: Number,
+	},
+	'bigint:string': {
+		castInJson: castToText,
+	},
+	time: {
+		castInJson: castToText,
+	},
+	timestamp: {
+		castInJson: castToText,
+		normalizeInJson: (v: string): Date => new Date(v + '+0000'),
+	},
+	'timestamp:string': {
+		castInJson: castToText,
+	},
+	datetime: {
+		castInJson: castToText,
+		normalizeInJson: (value: string) => new Date(value.replace(' ', 'T') + 'Z'),
+	},
+	'datetime:string': {
+		castInJson: castToText,
+	},
+	decimal: {
+		castInJson: castToText,
+	},
+	'decimal:number': {
+		castInJson: castToText,
+		normalizeInJson: Number,
+	},
+	'decimal:bigint': {
+		castInJson: castToText,
+		normalizeInJson: BigInt,
+	},
+	binary: {
+		castInJson: castToText,
+	},
+	varbinary: {
+		castInJson: castToText,
+	},
+	tinyblob: {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: atob,
+	},
+	'tinyblob:buffer': {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: (value: string) => Buffer.from(value, 'base64'),
+	},
+	blob: {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: atob,
+	},
+	'blob:buffer': {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: (value: string) => Buffer.from(value, 'base64'),
+	},
+	mediumblob: {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: atob,
+	},
+	'mediumblob:buffer': {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: (value: string) => Buffer.from(value, 'base64'),
+	},
+	longblob: {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: atob,
+	},
+	'longblob:buffer': {
+		castInJson: (name) => sql`to_base64(${name})`,
+		normalizeInJson: (value: string) => Buffer.from(value, 'base64'),
+	},
+} as const satisfies MySqlCodecs;
+
+export const refineGenericMySqlCodecs = (extension?: PartialWithUndefined<MySqlCodecs>): MySqlCodecs =>
+	refineCodecs<MySqlType>(genericMySqlCodecs, extension);
diff --git a/drizzle-orm/src/mysql-core/columns/all.ts b/drizzle-orm/src/mysql-core/columns/all.ts
index 44c03eff0c..23e3014d1b 100644
--- a/drizzle-orm/src/mysql-core/columns/all.ts
+++ b/drizzle-orm/src/mysql-core/columns/all.ts
@@ -1,5 +1,6 @@
 import { bigint } from './bigint.ts';
 import { binary } from './binary.ts';
+import { blob, longblob, mediumblob, tinyblob } from './blob.ts';
 import { boolean } from './boolean.ts';
 import { char } from './char.ts';
 import { customType } from './custom.ts';
@@ -52,6 +53,10 @@ export function getMySqlColumnBuilders() {
 		longtext,
 		mediumtext,
 		tinytext,
+		blob,
+		longblob,
+		mediumblob,
+		tinyblob,
 	};
 }
 
diff --git a/drizzle-orm/src/mysql-core/columns/bigint.ts b/drizzle-orm/src/mysql-core/columns/bigint.ts
index 0973a13461..ce23858b04 100644
--- a/drizzle-orm/src/mysql-core/columns/bigint.ts
+++ b/drizzle-orm/src/mysql-core/columns/bigint.ts
@@ -1,118 +1,143 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlBigInt53BuilderInitial<TName extends string> = MySqlBigInt53Builder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlBigInt53';
+export class MySqlBigInt53Builder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number uint53' : 'number int53';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'MySqlBigInt53'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
-{
+}, { unsigned?: boolean }> {
 	static override readonly [entityKind]: string = 'MySqlBigInt53Builder';
 
-	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'number', 'MySqlBigInt53');
-		this.config.unsigned = unsigned;
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, (unsigned ? 'number uint53' : 'number int53') as any, 'MySqlBigInt53');
+		this.config.unsigned = unsigned as TUnsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBigInt53<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBigInt53<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlBigInt53(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlBigInt53<T extends ColumnBaseConfig<'number', 'MySqlBigInt53'>>
+export class MySqlBigInt53<T extends ColumnBaseConfig<'number int53' | 'number uint53'>>
 	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'MySqlBigInt53';
 
+	/** @internal */
+	override readonly codec = 'bigint:number';
+
 	getSQLType(): string {
 		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'number') {
-			return value;
-		}
-		return Number(value);
-	}
 }
 
-export type MySqlBigInt64BuilderInitial<TName extends string> = MySqlBigInt64Builder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'MySqlBigInt64';
+export class MySqlBigInt64Builder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'bigint uint64' : 'bigint int64';
 	data: bigint;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'MySqlBigInt64'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
-{
+}, { unsigned?: boolean }> {
 	static override readonly [entityKind]: string = 'MySqlBigInt64Builder';
 
-	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'bigint', 'MySqlBigInt64');
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, (unsigned ? 'bigint uint64' : 'bigint int64') as any, 'MySqlBigInt64');
 		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBigInt64<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBigInt64<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlBigInt64(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint', 'MySqlBigInt64'>>
+export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint int64' | 'bigint uint64'>>
 	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'MySqlBigInt64';
 
+	/** @internal */
+	override readonly codec = 'bigint';
+
 	getSQLType(): string {
 		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
-	override mapFromDriverValue(value: string): bigint {
-		return BigInt(value);
+	override mapToDriverValue = (value: bigint): string => {
+		return value.toString();
+	};
+}
+
+export class MySqlBigIntStringBuilder<TUnsigned extends boolean | undefined>
+	extends MySqlColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'string uint64' : 'string int64';
+		data: string;
+		driverParam: number | string;
+	}, { unsigned?: boolean }>
+{
+	static override readonly [entityKind]: string = 'MySqlBigIntStringBuilder';
+
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, unsigned ? 'string uint64' : 'string int64' as any, 'MySqlBigIntString');
+		this.config.unsigned = unsigned as TUnsigned;
+	}
+
+	/** @internal */
+	override build(table: MySqlTable) {
+		return new MySqlBigIntString(
+			table,
+			this.config as any,
+		);
 	}
 }
 
-export interface MySqlBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+export class MySqlBigIntString<T extends ColumnBaseConfig<'string int64' | 'string uint64'>>
+	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
+{
+	static override readonly [entityKind]: string = 'MySqlBigIntString';
+
+	/** @internal */
+	override readonly codec = 'bigint:string';
+
+	getSQLType(): string {
+		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
+	}
+}
+
+export interface MySqlBigIntConfig<
+	T extends 'number' | 'bigint' | 'string' = 'number' | 'bigint' | 'string',
+	TUnsigned extends boolean | undefined = boolean | undefined,
+> {
 	mode: T;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function bigint<TMode extends MySqlBigIntConfig['mode']>(
-	config: MySqlBigIntConfig<TMode>,
-): TMode extends 'number' ? MySqlBigInt53BuilderInitial<''> : MySqlBigInt64BuilderInitial<''>;
-export function bigint<TName extends string, TMode extends MySqlBigIntConfig['mode']>(
-	name: TName,
-	config: MySqlBigIntConfig<TMode>,
-): TMode extends 'number' ? MySqlBigInt53BuilderInitial<TName> : MySqlBigInt64BuilderInitial<TName>;
-export function bigint(a?: string | MySqlBigIntConfig, b?: MySqlBigIntConfig) {
+export function bigint<TMode extends MySqlBigIntConfig['mode'], TUnsigned extends boolean | undefined>(
+	config: MySqlBigIntConfig<TMode, TUnsigned>,
+): TMode extends 'bigint' ? MySqlBigInt64Builder<TUnsigned>
+	: TMode extends 'string' ? MySqlBigIntStringBuilder<TUnsigned>
+	: MySqlBigInt53Builder<TUnsigned>;
+export function bigint<TMode extends MySqlBigIntConfig['mode'], TUnsigned extends boolean | undefined>(
+	name: string,
+	config: MySqlBigIntConfig<TMode, TUnsigned>,
+): TMode extends 'bigint' ? MySqlBigInt64Builder<TUnsigned>
+	: TMode extends 'string' ? MySqlBigIntStringBuilder<TUnsigned>
+	: MySqlBigInt53Builder<TUnsigned>;
+export function bigint(a: string | MySqlBigIntConfig, b?: MySqlBigIntConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlBigIntConfig>(a, b);
 	if (config.mode === 'number') {
 		return new MySqlBigInt53Builder(name, config.unsigned);
 	}
+	if (config.mode === 'string') {
+		return new MySqlBigIntStringBuilder(name, config.unsigned);
+	}
 	return new MySqlBigInt64Builder(name, config.unsigned);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/binary.ts b/drizzle-orm/src/mysql-core/columns/binary.ts
index f94da26c5f..ebf7b56f4a 100644
--- a/drizzle-orm/src/mysql-core/columns/binary.ts
+++ b/drizzle-orm/src/mysql-core/columns/binary.ts
@@ -1,60 +1,42 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlBinaryBuilderInitial<TName extends string> = MySqlBinaryBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlBinary';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlBinary'>> extends MySqlColumnBuilder<
-	T,
-	MySqlBinaryConfig
+export class MySqlBinaryBuilder extends MySqlColumnBuilder<
+	{
+		dataType: 'string binary';
+		data: string;
+		driverParam: string;
+	},
+	MySqlBinaryConfig & { setLength: boolean }
 > {
 	static override readonly [entityKind]: string = 'MySqlBinaryBuilder';
 
-	constructor(name: T['name'], length: number | undefined) {
-		super(name, 'string', 'MySqlBinary');
-		this.config.length = length;
+	constructor(name: string, length: number | undefined) {
+		super(name, 'string binary', 'MySqlBinary');
+		this.config.length = length ?? 1;
+		this.config.setLength = length !== undefined;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBinary<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBinary<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlBinary(table, this.config as any);
 	}
 }
 
-export class MySqlBinary<T extends ColumnBaseConfig<'string', 'MySqlBinary'>> extends MySqlColumn<
+export class MySqlBinary<T extends ColumnBaseConfig<'string binary'>> extends MySqlColumn<
 	T,
-	MySqlBinaryConfig
+	MySqlBinaryConfig & { setLength: boolean }
 > {
 	static override readonly [entityKind]: string = 'MySqlBinary';
 
-	length: number | undefined = this.config.length;
-
-	override mapFromDriverValue(value: string | Buffer | Uint8Array): string {
-		if (typeof value === 'string') return value;
-		if (Buffer.isBuffer(value)) return value.toString();
-
-		const str: string[] = [];
-		for (const v of value) {
-			str.push(v === 49 ? '1' : '0');
-		}
-
-		return str.join('');
-	}
+	/** @internal */
+	override readonly codec = 'binary';
 
 	getSQLType(): string {
-		return this.length === undefined ? `binary` : `binary(${this.length})`;
+		return this.config.setLength ? `binary(${this.length})` : `binary`;
 	}
 }
 
@@ -62,14 +44,13 @@ export interface MySqlBinaryConfig {
 	length?: number;
 }
 
-export function binary(): MySqlBinaryBuilderInitial<''>;
 export function binary(
 	config?: MySqlBinaryConfig,
-): MySqlBinaryBuilderInitial<''>;
-export function binary<TName extends string>(
-	name: TName,
+): MySqlBinaryBuilder;
+export function binary(
+	name: string,
 	config?: MySqlBinaryConfig,
-): MySqlBinaryBuilderInitial<TName>;
+): MySqlBinaryBuilder;
 export function binary(a?: string | MySqlBinaryConfig, b: MySqlBinaryConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<MySqlBinaryConfig>(a, b);
 	return new MySqlBinaryBuilder(name, config.length);
diff --git a/drizzle-orm/src/mysql-core/columns/blob.ts b/drizzle-orm/src/mysql-core/columns/blob.ts
new file mode 100644
index 0000000000..f7786e42b9
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/columns/blob.ts
@@ -0,0 +1,188 @@
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+
+export type MySqlBlobColumnType = 'tinyblob' | 'blob' | 'mediumblob' | 'longblob';
+
+export class MySqlStringBlobBuilder extends MySqlColumnBuilder<
+	{
+		dataType: 'string';
+		data: string;
+		driverParam: string;
+	},
+	{ blobType: MySqlBlobColumnType; length: number }
+> {
+	static override readonly [entityKind]: string = 'MySqlBlobBuilder';
+
+	constructor(name: string, blobType: MySqlBlobColumnType) {
+		super(name, 'string', 'MySqlBlob');
+		this.config.blobType = blobType;
+		switch (blobType) {
+			case 'tinyblob': {
+				this.config.length = 255;
+				break;
+			}
+			case 'blob': {
+				this.config.length = 65535;
+				break;
+			}
+			case 'mediumblob': {
+				this.config.length = 16777215;
+				break;
+			}
+			case 'longblob': {
+				this.config.length = 4294967295;
+				break;
+			}
+		}
+	}
+
+	/** @internal */
+	override build(table: MySqlTable) {
+		return new MySqlStringBlob(table, this.config as any);
+	}
+}
+
+export class MySqlStringBlob<T extends ColumnBaseConfig<'string'>>
+	extends MySqlColumn<T, { blobType: MySqlBlobColumnType }>
+{
+	static override readonly [entityKind]: string = 'MySqlBlob';
+
+	/** @internal */
+	override readonly codec: MySqlBlobColumnType = this.config.blobType;
+
+	readonly blobType: MySqlBlobColumnType = this.config.blobType;
+
+	getSQLType(): string {
+		return this.blobType;
+	}
+}
+
+export class MySqlBufferBlobBuilder extends MySqlColumnBuilder<
+	{
+		dataType: 'string';
+		data: Buffer;
+		driverParam: string;
+	},
+	{ blobType: MySqlBlobColumnType; length: number }
+> {
+	static override readonly [entityKind]: string = 'MySqlBlobBuilder';
+
+	constructor(name: string, blobType: MySqlBlobColumnType) {
+		super(name, 'string', 'MySqlBlob');
+		this.config.blobType = blobType;
+		switch (blobType) {
+			case 'tinyblob': {
+				this.config.length = 255;
+				break;
+			}
+			case 'blob': {
+				this.config.length = 65535;
+				break;
+			}
+			case 'mediumblob': {
+				this.config.length = 16777215;
+				break;
+			}
+			case 'longblob': {
+				this.config.length = 4294967295;
+				break;
+			}
+		}
+	}
+
+	/** @internal */
+	override build(table: MySqlTable) {
+		return new MySqlBufferBlob(table, this.config as any);
+	}
+}
+export class MySqlBufferBlob<T extends ColumnBaseConfig<'object buffer'>>
+	extends MySqlColumn<T, { blobType: MySqlBlobColumnType }>
+{
+	static override readonly [entityKind]: string = 'MySqlBlob';
+
+	/** @internal */
+	override readonly codec: `${MySqlBlobColumnType}:buffer` = `${this.config.blobType}:buffer`;
+
+	readonly blobType: MySqlBlobColumnType = this.config.blobType;
+
+	getSQLType(): string {
+		return this.blobType;
+	}
+}
+
+export interface MySqlBlobConfig<
+	TMode extends 'buffer' | 'string' = 'buffer' | 'string',
+> {
+	mode?: TMode;
+}
+
+export function blob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function blob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	name: string,
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function blob(a?: string | MySqlBlobConfig, b: MySqlBlobConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<MySqlBlobConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MySqlStringBlobBuilder(name, 'blob');
+	}
+	return new MySqlBufferBlobBuilder(name, 'blob');
+}
+
+export function tinyblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function tinyblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	name: string,
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function tinyblob(a?: string | MySqlBlobConfig, b: MySqlBlobConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<MySqlBlobConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MySqlStringBlobBuilder(name, 'tinyblob');
+	}
+	return new MySqlBufferBlobBuilder(name, 'tinyblob');
+}
+
+export function mediumblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function mediumblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	name: string,
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function mediumblob(a?: string | MySqlBlobConfig, b: MySqlBlobConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<MySqlBlobConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MySqlStringBlobBuilder(name, 'mediumblob');
+	}
+	return new MySqlBufferBlobBuilder(name, 'mediumblob');
+}
+
+export function longblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function longblob<TMode extends MySqlBlobConfig['mode'] & {}>(
+	name: string,
+	config?: MySqlBlobConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? MySqlStringBlobBuilder
+	: MySqlBufferBlobBuilder;
+export function longblob(a?: string | MySqlBlobConfig, b: MySqlBlobConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<MySqlBlobConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new MySqlStringBlobBuilder(name, 'longblob');
+	}
+	return new MySqlBufferBlobBuilder(name, 'longblob');
+}
diff --git a/drizzle-orm/src/mysql-core/columns/boolean.ts b/drizzle-orm/src/mysql-core/columns/boolean.ts
index 2057496b6b..85c5368d37 100644
--- a/drizzle-orm/src/mysql-core/columns/boolean.ts
+++ b/drizzle-orm/src/mysql-core/columns/boolean.ts
@@ -1,55 +1,39 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlBooleanBuilderInitial<TName extends string> = MySqlBooleanBuilder<{
-	name: TName;
+export class MySqlBooleanBuilder extends MySqlColumnBuilder<{
 	dataType: 'boolean';
-	columnType: 'MySqlBoolean';
 	data: boolean;
 	driverParam: number | boolean;
-	enumValues: undefined;
-}>;
-
-export class MySqlBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'MySqlBoolean'>>
-	extends MySqlColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'MySqlBooleanBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: string) {
 		super(name, 'boolean', 'MySqlBoolean');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBoolean<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBoolean<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlBoolean(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlBoolean<T extends ColumnBaseConfig<'boolean', 'MySqlBoolean'>> extends MySqlColumn<T> {
+export class MySqlBoolean<T extends ColumnBaseConfig<'boolean'>> extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlBoolean';
 
+	/** @internal */
+	override readonly codec = 'boolean';
+
 	getSQLType(): string {
 		return 'boolean';
 	}
-
-	override mapFromDriverValue(value: number | boolean): boolean {
-		if (typeof value === 'boolean') {
-			return value;
-		}
-		return value === 1;
-	}
 }
 
-export function boolean(): MySqlBooleanBuilderInitial<''>;
-export function boolean<TName extends string>(name: TName): MySqlBooleanBuilderInitial<TName>;
-export function boolean(name?: string) {
+export function boolean(name?: string): MySqlBooleanBuilder {
 	return new MySqlBooleanBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/mysql-core/columns/char.ts b/drizzle-orm/src/mysql-core/columns/char.ts
index 55743a5d4a..0d8cf60ccb 100644
--- a/drizzle-orm/src/mysql-core/columns/char.ts
+++ b/drizzle-orm/src/mysql-core/columns/char.ts
@@ -1,84 +1,70 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
-
-export type MySqlCharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = MySqlCharBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlChar';
-	data: TEnum[number];
-	driverParam: number | string;
-	enumValues: TEnum;
-	length: TLength;
-}>;
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MySqlStringBaseColumn, MySqlStringColumnBaseBuilder } from './string.common.ts';
 
 export class MySqlCharBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'MySqlChar'> & { length?: number | undefined },
-> extends MySqlColumnBuilder<
-	T,
-	MySqlCharConfig<T['enumValues'], T['length']>,
-	{ length: T['length'] }
+	TEnum extends [string, ...string[]],
+> extends MySqlStringColumnBaseBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: number | string;
+		enumValues: TEnum;
+	},
+	{ enum?: TEnum; length: number; setLength: boolean }
 > {
 	static override readonly [entityKind]: string = 'MySqlCharBuilder';
 
-	constructor(name: T['name'], config: MySqlCharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'MySqlChar');
-		this.config.length = config.length;
+	constructor(name: string, config: MySqlCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MySqlChar');
+		this.config.length = (config.length ?? 1) as number;
+		this.config.setLength = config.length !== undefined;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }> {
-		return new MySqlChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }>(
+	override build(table: MySqlTable) {
+		return new MySqlChar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlChar<T extends ColumnBaseConfig<'string', 'MySqlChar'> & { length?: number | undefined }>
-	extends MySqlColumn<T, MySqlCharConfig<T['enumValues'], T['length']>, { length: T['length'] }>
+export class MySqlChar<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends MySqlStringBaseColumn<T, { enum?: T['enumValues']; length: number; setLength: boolean }>
 {
 	static override readonly [entityKind]: string = 'MySqlChar';
 
-	readonly length: T['length'] = this.config.length;
+	/** @internal */
+	override readonly codec = 'char';
+
 	override readonly enumValues = this.config.enum;
 
 	getSQLType(): string {
-		return this.length === undefined ? `char` : `char(${this.length})`;
+		return this.config.setLength ? `char(${this.length})` : `char`;
 	}
 }
 
 export interface MySqlCharConfig<
 	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length?: TLength;
+	length?: number;
 }
 
-export function char(): MySqlCharBuilderInitial<'', [string, ...string[]], undefined>;
-export function char<U extends string, T extends Readonly<[U, ...U[]]>, L extends number | undefined>(
-	config?: MySqlCharConfig<T | Writable<T>, L>,
-): MySqlCharBuilderInitial<'', Writable<T>, L>;
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: MySqlCharConfig<T | Writable<T>>,
+): MySqlCharBuilder<Writable<T>>;
 export function char<
-	TName extends string,
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 >(
-	name: TName,
-	config?: MySqlCharConfig<T | Writable<T>, L>,
-): MySqlCharBuilderInitial<TName, Writable<T>, L>;
+	name: string,
+	config?: MySqlCharConfig<T | Writable<T>>,
+): MySqlCharBuilder<Writable<T>>;
 export function char(a?: string | MySqlCharConfig, b: MySqlCharConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<MySqlCharConfig>(a, b);
 	return new MySqlCharBuilder(name, config as any);
diff --git a/drizzle-orm/src/mysql-core/columns/common.ts b/drizzle-orm/src/mysql-core/columns/common.ts
index 289c420ae7..32cce720e3 100644
--- a/drizzle-orm/src/mysql-core/columns/common.ts
+++ b/drizzle-orm/src/mysql-core/columns/common.ts
@@ -1,24 +1,24 @@
 import { ColumnBuilder } from '~/column-builder.ts';
 import type {
-	ColumnBuilderBase,
 	ColumnBuilderBaseConfig,
 	ColumnBuilderExtraConfig,
 	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
+	ColumnType,
 	HasDefault,
 	HasGenerated,
 	IsAutoincrement,
-	MakeColumnConfig,
 } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { Column } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { ForeignKey, UpdateDeleteAction } from '~/mysql-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/mysql-core/foreign-keys.ts';
-import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import type { SQL } from '~/sql/sql.ts';
 import type { Update } from '~/utils.ts';
-import { uniqueKeyName } from '../unique-constraint.ts';
+import type { MySqlType } from '../codecs.ts';
+
+export type MySqlColumns = Record<string, MySqlColumn<any>>;
 
 export interface ReferenceConfig {
 	ref: () => MySqlColumn;
@@ -28,25 +28,17 @@ export interface ReferenceConfig {
 	};
 }
 
-export interface MySqlColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'mysql' }> {}
-
 export interface MySqlGeneratedColumnConfig {
 	mode?: 'virtual' | 'stored';
 }
 
 export abstract class MySqlColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string> & {
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType> & {
 		data: any;
 	},
 	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'mysql' }, TExtraConfig>
-	implements MySqlColumnBuilderBase<T, TTypeConfig>
-{
+> extends ColumnBuilder<T, TRuntimeConfig, TExtraConfig> {
 	static override readonly [entityKind]: string = 'MySqlColumnBuilder';
 
 	private foreignKeyConfigs: ReferenceConfig[] = [];
@@ -62,7 +54,7 @@ export abstract class MySqlColumnBuilder<
 		return this;
 	}
 
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: MySqlGeneratedColumnConfig): HasGenerated<this, {
+	generatedAlwaysAs(as: SQL | (() => SQL), config?: MySqlGeneratedColumnConfig): HasGenerated<this, {
 		type: 'always';
 	}> {
 		this.config.generated = {
@@ -93,32 +85,33 @@ export abstract class MySqlColumnBuilder<
 	}
 
 	/** @internal */
-	abstract build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlColumn<MakeColumnConfig<T, TTableName>>;
+	abstract build(table: MySqlTable): MySqlColumn;
 }
 
 // To understand how to use `MySqlColumn` and `AnyMySqlColumn`, see `Column` and `AnyColumn` documentation.
 export abstract class MySqlColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = {},
-	TTypeConfig extends object = {},
-> extends Column<T, TRuntimeConfig, TTypeConfig & { dialect: 'mysql' }> {
+> extends Column<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlColumn';
 
+	/** @internal */
+	abstract override readonly codec?: MySqlType;
+
+	/** @internal */
+	override readonly table: MySqlTable;
+
 	constructor(
-		override readonly table: MySqlTable,
-		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
+		table: MySqlTable,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
 	) {
-		if (!config.uniqueName) {
-			config.uniqueName = uniqueKeyName(table, [config.name]);
-		}
 		super(table, config);
+		this.table = table;
 	}
 }
 
-export type AnyMySqlColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = MySqlColumn<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+export type AnyMySqlColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = MySqlColumn<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
 >;
 
 export interface MySqlColumnWithAutoIncrementConfig {
@@ -126,13 +119,13 @@ export interface MySqlColumnWithAutoIncrementConfig {
 }
 
 export abstract class MySqlColumnBuilderWithAutoIncrement<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
 > extends MySqlColumnBuilder<T, TRuntimeConfig & MySqlColumnWithAutoIncrementConfig, TExtraConfig> {
 	static override readonly [entityKind]: string = 'MySqlColumnBuilderWithAutoIncrement';
 
-	constructor(name: NonNullable<T['name']>, dataType: T['dataType'], columnType: T['columnType']) {
+	constructor(name: string, dataType: T['dataType'], columnType: string) {
 		super(name, dataType, columnType);
 		this.config.autoIncrement = false;
 	}
@@ -145,7 +138,7 @@ export abstract class MySqlColumnBuilderWithAutoIncrement<
 }
 
 export abstract class MySqlColumnWithAutoIncrement<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends MySqlColumn<T, MySqlColumnWithAutoIncrementConfig & TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlColumnWithAutoIncrement';
diff --git a/drizzle-orm/src/mysql-core/columns/custom.ts b/drizzle-orm/src/mysql-core/columns/custom.ts
index 50585bece1..5a79831bb9 100644
--- a/drizzle-orm/src/mysql-core/columns/custom.ts
+++ b/drizzle-orm/src/mysql-core/columns/custom.ts
@@ -1,19 +1,17 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import type { SQL } from '~/sql/sql.ts';
+import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { type MySqlColumnType, type MySqlType, resolveMySqlTypeAlias } from '../codecs.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
 	& {
-		name: TName;
 		dataType: 'custom';
-		columnType: 'MySqlCustomColumn';
 		data: T['data'];
 		driverParam: T['driverData'];
-		enumValues: undefined;
 	}
 	& (T['notNull'] extends true ? { notNull: true } : {})
 	& (T['default'] extends true ? { hasDefault: true } : {});
@@ -22,22 +20,17 @@ export interface MySqlCustomColumnInnerConfig {
 	customTypeValues: CustomTypeValues;
 }
 
-export class MySqlCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'MySqlCustomColumn'>>
-	extends MySqlColumnBuilder<
-		T,
-		{
-			fieldConfig: CustomTypeValues['config'];
-			customTypeParams: CustomTypeParams<any>;
-		},
-		{
-			mysqlColumnBuilderBrand: 'MySqlCustomColumnBuilderBrand';
-		}
-	>
-{
+export class MySqlCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>> extends MySqlColumnBuilder<
+	T,
+	{
+		fieldConfig: CustomTypeValues['config'];
+		customTypeParams: CustomTypeParams<any>;
+	}
+> {
 	static override readonly [entityKind]: string = 'MySqlCustomColumnBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		fieldConfig: CustomTypeValues['config'],
 		customTypeParams: CustomTypeParams<any>,
 	) {
@@ -47,47 +40,49 @@ export class MySqlCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'
 	}
 
 	/** @internal */
-	build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new MySqlCustomColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlCustomColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlCustomColumn<T extends ColumnBaseConfig<'custom', 'MySqlCustomColumn'>> extends MySqlColumn<T> {
+export class MySqlCustomColumn<T extends ColumnBaseConfig<'custom'>> extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlCustomColumn';
 
+	/** @internal */
+	override readonly codec?: MySqlType | undefined;
+
 	private sqlName: string;
-	private mapTo?: (value: T['data']) => T['driverParam'];
-	private mapFrom?: (value: T['driverParam']) => T['data'];
+	readonly mapFromJsonValue?: (value: unknown) => T['data'];
+	readonly jsonSelectIdentifier?: (identifier: SQL, sql: SQLGenerator, arrayDimensions?: number) => SQL;
 
 	constructor(
 		table: AnyMySqlTable<{ name: T['tableName'] }>,
 		config: MySqlCustomColumnBuilder<T>['config'],
 	) {
-		super(table, config);
+		super(table, config as any);
 		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-		this.mapTo = config.customTypeParams.toDriver;
-		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapToDriverValue = config.customTypeParams.toDriver ?? this.mapToDriverValue;
+		this.mapFromDriverValue = config.customTypeParams.fromDriver ?? this.mapFromDriverValue;
+		this.mapFromJsonValue = config.customTypeParams.fromJson;
+		this.jsonSelectIdentifier = config.customTypeParams.forJsonSelect;
+		const cfgCodec =
+			typeof config.customTypeParams.codec === 'string' || typeof config.customTypeParams.codec === 'undefined'
+				? config.customTypeParams.codec
+				: config.customTypeParams.codec(config.fieldConfig);
+		this.codec = typeof cfgCodec === 'string'
+			? resolveMySqlTypeAlias(cfgCodec) as MySqlType // If it isn't `MySqlType`, codec search will simply resolve to no codec, which is supported behaviour
+			: undefined;
 	}
 
 	getSQLType(): string {
 		return this.sqlName;
 	}
-
-	override mapFromDriverValue(value: T['driverParam']): T['data'] {
-		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
-	}
-
-	override mapToDriverValue(value: T['data']): T['driverParam'] {
-		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
-	}
 }
 
-export type CustomTypeValues = {
+export interface CustomTypeValues {
 	/**
 	 * Required type for custom column, that will infer proper type model
 	 *
@@ -104,6 +99,24 @@ export type CustomTypeValues = {
 	 */
 	driverData?: unknown;
 
+	/**
+	 * @deprecated Use codecs instead
+	 *
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
+	/**
+	 * @deprecated Use codecs instead
+	 *
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
 	/**
 	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
 	 */
@@ -138,7 +151,7 @@ export type CustomTypeValues = {
 	 * });
 	 */
 	default?: boolean;
-};
+}
 
 export interface CustomTypeParams<T extends CustomTypeValues> {
 	/**
@@ -173,7 +186,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
 
 	/**
-	 * Optional mapping function, between user input and driver
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
 	 * @example
 	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
 	 * ```
@@ -185,16 +198,129 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	toDriver?: (value: T['data']) => T['driverData'] | SQL;
 
 	/**
-	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
 	 * @example
 	 * For example, when using timestamp we need to map string Date representation to JS Date
 	 * ```
 	 * fromDriver(value: string): Date {
 	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07 03:25:16.635";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07 03:25:16.635");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * @deprecated Use codecs instead; bypasses JSON codecs if used
+	 *
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying bigint column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's string representation, as opposed to bigint from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): bigint {
+	 * 	return BigInt(value);
+	 * },
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "5044565289845416380";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: 5044565289845416380n;
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * @deprecated Use codecs instead; bypasses JSON codecs if used
+	 *
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `binary`, `varbinary`, `time`, `datetime`, `decimal`, `float`, `bigint`
+	 * @example
+	 * For example, when using bigint we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator): SQL {
+	 * 	return sql`cast(${identifier} as char)`
 	 * },
 	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		`table`.`custom_bigint` AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		cast(`table`.`custom_bigint` as char) AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
+	 */
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator) => SQL;
+
+	/**
+	 * Select which column type codec will be used for this column
 	 */
-	fromDriver?: (value: T['driverData']) => T['data'];
+	codec?:
+		| MySqlColumnType
+		| undefined
+		| ((
+			config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined),
+		) => MySqlColumnType | undefined);
 }
 
 /**
@@ -205,28 +331,27 @@ export function customType<T extends CustomTypeValues = CustomTypeValues>(
 ): Equal<T['configRequired'], true> extends true ? {
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig: TConfig,
-		): MySqlCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): MySqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
 			fieldConfig: T['config'],
-		): MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): MySqlCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 	: {
-		(): MySqlCustomColumnBuilder<ConvertCustomConfig<'', T>>;
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig?: TConfig,
-		): MySqlCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): MySqlCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
 			fieldConfig?: T['config'],
-		): MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): MySqlCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 {
-	return <TName extends string>(
-		a?: TName | T['config'],
+	return (
+		a?: string | T['config'],
 		b?: T['config'],
-	): MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+	): MySqlCustomColumnBuilder<ConvertCustomConfig<T>> => {
 		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
-		return new MySqlCustomColumnBuilder(name as ConvertCustomConfig<TName, T>['name'], config, customTypeParams);
+		return new MySqlCustomColumnBuilder(name, config, customTypeParams);
 	};
 }
diff --git a/drizzle-orm/src/mysql-core/columns/date.common.ts b/drizzle-orm/src/mysql-core/columns/date.common.ts
index 75faad5b85..3c4bfae8e7 100644
--- a/drizzle-orm/src/mysql-core/columns/date.common.ts
+++ b/drizzle-orm/src/mysql-core/columns/date.common.ts
@@ -1,20 +1,17 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderExtraConfig,
-	ColumnDataType,
-	HasDefault,
-} from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnType, HasDefault } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/sql.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { TimestampFsp } from './timestamp.ts';
 
 export interface MySqlDateColumnBaseConfig {
 	hasOnUpdateNow: boolean;
+	onUpdateNowFsp: TimestampFsp | undefined;
 }
 
 export abstract class MySqlDateColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
 > extends MySqlColumnBuilder<T, TRuntimeConfig & MySqlDateColumnBaseConfig, TExtraConfig> {
@@ -24,19 +21,21 @@ export abstract class MySqlDateColumnBaseBuilder<
 		return this.default(sql`(now())`);
 	}
 
-	// "on update now" also adds an implicit default value to the column - https://dev.mysql.com/doc/refman/8.0/en/timestamp-initialization.html
-	onUpdateNow(): HasDefault<this> {
+	// "on update now" also adds an implicit default value to the column - https://dev.mysql.com/doc/refman/8.0/en/timestamp-ization.html
+	onUpdateNow(config?: { fsp: TimestampFsp }): HasDefault<this> {
 		this.config.hasOnUpdateNow = true;
+		this.config.onUpdateNowFsp = config?.fsp;
 		this.config.hasDefault = true;
 		return this as HasDefault<this>;
 	}
 }
 
 export abstract class MySqlDateBaseColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends MySqlColumn<T, MySqlDateColumnBaseConfig & TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlDateColumn';
 
 	readonly hasOnUpdateNow: boolean = this.config.hasOnUpdateNow;
+	readonly onUpdateNowFsp: TimestampFsp | undefined = this.config.onUpdateNowFsp;
 }
diff --git a/drizzle-orm/src/mysql-core/columns/date.ts b/drizzle-orm/src/mysql-core/columns/date.ts
index f3797ee6e7..41b9ec16fa 100644
--- a/drizzle-orm/src/mysql-core/columns/date.ts
+++ b/drizzle-orm/src/mysql-core/columns/date.ts
@@ -1,40 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlDateBuilderInitial<TName extends string> = MySqlDateBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'MySqlDate';
+export class MySqlDateBuilder extends MySqlColumnBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlDate'>> extends MySqlColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'MySqlDateBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'date', 'MySqlDate');
+	constructor(name: string) {
+		super(name, 'object date', 'MySqlDate');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDate<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDate<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlDate(table, this.config as any);
 	}
 }
 
-export class MySqlDate<T extends ColumnBaseConfig<'date', 'MySqlDate'>> extends MySqlColumn<T> {
+export class MySqlDate<T extends ColumnBaseConfig<'object date'>> extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlDate';
 
+	/** @internal */
+	override readonly codec = 'date';
+
 	constructor(
 		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateBuilder<T>['config'],
+		config: MySqlDateBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -42,47 +37,37 @@ export class MySqlDate<T extends ColumnBaseConfig<'date', 'MySqlDate'>> extends
 	getSQLType(): string {
 		return `date`;
 	}
-
-	override mapFromDriverValue(value: string): Date {
-		return new Date(value);
-	}
 }
 
-export type MySqlDateStringBuilderInitial<TName extends string> = MySqlDateStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlDateString';
+export class MySqlDateStringBuilder extends MySqlColumnBuilder<{
+	dataType: 'string date';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlDateString'>>
-	extends MySqlColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'MySqlDateStringBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'MySqlDateString');
+	constructor(name: string) {
+		super(name, 'string date', 'MySqlDateString');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateString<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDateString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDateString<T extends ColumnBaseConfig<'string', 'MySqlDateString'>> extends MySqlColumn<T> {
+export class MySqlDateString<T extends ColumnBaseConfig<'string date'>> extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlDateString';
 
+	/** @internal */
+	override readonly codec = 'date:string';
+
 	constructor(
 		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateStringBuilder<T>['config'],
+		config: MySqlDateStringBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -96,14 +81,13 @@ export interface MySqlDateConfig<TMode extends 'date' | 'string' = 'date' | 'str
 	mode?: TMode;
 }
 
-export function date(): MySqlDateBuilderInitial<''>;
 export function date<TMode extends MySqlDateConfig['mode'] & {}>(
 	config?: MySqlDateConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateStringBuilderInitial<''> : MySqlDateBuilderInitial<''>;
-export function date<TName extends string, TMode extends MySqlDateConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? MySqlDateStringBuilder : MySqlDateBuilder;
+export function date<TMode extends MySqlDateConfig['mode'] & {}>(
+	name: string,
 	config?: MySqlDateConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateStringBuilderInitial<TName> : MySqlDateBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? MySqlDateStringBuilder : MySqlDateBuilder;
 export function date(a?: string | MySqlDateConfig, b?: MySqlDateConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlDateConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/mysql-core/columns/datetime.ts b/drizzle-orm/src/mysql-core/columns/datetime.ts
index ea5b917b92..b22e786311 100644
--- a/drizzle-orm/src/mysql-core/columns/datetime.ts
+++ b/drizzle-orm/src/mysql-core/columns/datetime.ts
@@ -1,48 +1,41 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { MySqlDateBaseColumn, MySqlDateColumnBaseBuilder } from './date.common.ts';
 
-export type MySqlDateTimeBuilderInitial<TName extends string> = MySqlDateTimeBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'MySqlDateTime';
+export class MySqlDateTimeBuilder extends MySqlDateColumnBaseBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlDateTimeBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlDateTime'>>
-	extends MySqlColumnBuilder<T, MySqlDatetimeConfig>
-{
+}, MySqlDatetimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlDateTimeBuilder';
 
-	constructor(name: T['name'], config: MySqlDatetimeConfig | undefined) {
-		super(name, 'date', 'MySqlDateTime');
+	constructor(name: string, config: MySqlDatetimeConfig | undefined) {
+		super(name, 'object date', 'MySqlDateTime');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateTime<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateTime<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDateTime(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDateTime<T extends ColumnBaseConfig<'date', 'MySqlDateTime'>> extends MySqlColumn<T> {
+export class MySqlDateTime<T extends ColumnBaseConfig<'object date'>> extends MySqlDateBaseColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlDateTime';
 
+	/** @internal */
+	override readonly codec = 'datetime';
+
 	readonly fsp: number | undefined;
 
 	constructor(
 		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateTimeBuilder<T>['config'],
+		config: MySqlDateTimeBuilder['config'],
 	) {
 		super(table, config);
 		this.fsp = config.fsp;
@@ -53,53 +46,44 @@ export class MySqlDateTime<T extends ColumnBaseConfig<'date', 'MySqlDateTime'>>
 		return `datetime${precision}`;
 	}
 
-	override mapToDriverValue(value: Date): unknown {
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
 		return value.toISOString().replace('T', ' ').replace('Z', '');
-	}
-
-	override mapFromDriverValue(value: string): Date {
-		return new Date(value.replace(' ', 'T') + 'Z');
-	}
+	};
 }
 
-export type MySqlDateTimeStringBuilderInitial<TName extends string> = MySqlDateTimeStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlDateTimeString';
+export class MySqlDateTimeStringBuilder extends MySqlDateColumnBaseBuilder<{
+	dataType: 'string datetime';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlDateTimeStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlDateTimeString'>>
-	extends MySqlColumnBuilder<T, MySqlDatetimeConfig>
-{
+}, MySqlDatetimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlDateTimeStringBuilder';
 
-	constructor(name: T['name'], config: MySqlDatetimeConfig | undefined) {
-		super(name, 'string', 'MySqlDateTimeString');
+	constructor(name: string, config: MySqlDatetimeConfig | undefined) {
+		super(name, 'string datetime', 'MySqlDateTimeString');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateTimeString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateTimeString<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDateTimeString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDateTimeString<T extends ColumnBaseConfig<'string', 'MySqlDateTimeString'>> extends MySqlColumn<T> {
+export class MySqlDateTimeString<T extends ColumnBaseConfig<'string datetime'>> extends MySqlDateBaseColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlDateTimeString';
 
+	/** @internal */
+	override readonly codec = 'datetime:string';
+
 	readonly fsp: number | undefined;
 
 	constructor(
 		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateTimeStringBuilder<T>['config'],
+		config: MySqlDateTimeStringBuilder['config'],
 	) {
 		super(table, config);
 		this.fsp = config.fsp;
@@ -109,6 +93,11 @@ export class MySqlDateTimeString<T extends ColumnBaseConfig<'string', 'MySqlDate
 		const precision = this.fsp === undefined ? '' : `(${this.fsp})`;
 		return `datetime${precision}`;
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString().replace('T', ' ').replace('Z', '');
+	};
 }
 
 export type DatetimeFsp = 0 | 1 | 2 | 3 | 4 | 5 | 6;
@@ -118,14 +107,13 @@ export interface MySqlDatetimeConfig<TMode extends 'date' | 'string' = 'date' |
 	fsp?: DatetimeFsp;
 }
 
-export function datetime(): MySqlDateTimeBuilderInitial<''>;
 export function datetime<TMode extends MySqlDatetimeConfig['mode'] & {}>(
 	config?: MySqlDatetimeConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateTimeStringBuilderInitial<''> : MySqlDateTimeBuilderInitial<''>;
-export function datetime<TName extends string, TMode extends MySqlDatetimeConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? MySqlDateTimeStringBuilder : MySqlDateTimeBuilder;
+export function datetime<TMode extends MySqlDatetimeConfig['mode'] & {}>(
+	name: string,
 	config?: MySqlDatetimeConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateTimeStringBuilderInitial<TName> : MySqlDateTimeBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? MySqlDateTimeStringBuilder : MySqlDateTimeBuilder;
 export function datetime(a?: string | MySqlDatetimeConfig, b?: MySqlDatetimeConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlDatetimeConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/mysql-core/columns/decimal.ts b/drizzle-orm/src/mysql-core/columns/decimal.ts
index 223ef3991d..f3de855bbf 100644
--- a/drizzle-orm/src/mysql-core/columns/decimal.ts
+++ b/drizzle-orm/src/mysql-core/columns/decimal.ts
@@ -1,57 +1,44 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlDecimalBuilderInitial<TName extends string> = MySqlDecimalBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlDecimal';
+export class MySqlDecimalBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'string unumeric' : 'string numeric';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlDecimalBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'MySqlDecimal'>,
-> extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDecimalConfig> {
+}, MySqlDecimalConfig> {
 	static override readonly [entityKind]: string = 'MySqlDecimalBuilder';
 
-	constructor(name: T['name'], config: MySqlDecimalConfig | undefined) {
-		super(name, 'string', 'MySqlDecimal');
+	constructor(name: string, config: MySqlDecimalConfig | undefined) {
+		super(name, (config?.unsigned ? 'string unumeric' : 'string numeric') as any, 'MySqlDecimal');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDecimal<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDecimal<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDecimal(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDecimal<T extends ColumnBaseConfig<'string', 'MySqlDecimal'>>
+export class MySqlDecimal<T extends ColumnBaseConfig<'string numeric' | 'string unumeric'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlDecimal';
 
+	/** @internal */
+	override readonly codec = 'decimal';
+
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
 
-	override mapFromDriverValue(value: unknown): string {
-		if (typeof value === 'string') return value;
-
-		return String(value);
-	}
-
 	getSQLType(): string {
 		let type = '';
 		if (this.precision !== undefined && this.scale !== undefined) {
@@ -66,53 +53,43 @@ export class MySqlDecimal<T extends ColumnBaseConfig<'string', 'MySqlDecimal'>>
 	}
 }
 
-export type MySqlDecimalNumberBuilderInitial<TName extends string> = MySqlDecimalNumberBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlDecimalNumber';
-	data: number;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlDecimalNumberBuilder<
-	T extends ColumnBuilderBaseConfig<'number', 'MySqlDecimalNumber'>,
-> extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDecimalConfig> {
+export class MySqlDecimalNumberBuilder<TUnsigned extends boolean | undefined>
+	extends MySqlColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number unsigned' : 'number';
+		data: number;
+		driverParam: string;
+	}, MySqlDecimalConfig>
+{
 	static override readonly [entityKind]: string = 'MySqlDecimalNumberBuilder';
 
-	constructor(name: T['name'], config: MySqlDecimalConfig | undefined) {
-		super(name, 'number', 'MySqlDecimalNumber');
+	constructor(name: string, config: MySqlDecimalConfig | undefined) {
+		super(name, config?.unsigned ? 'number unsigned' : 'number' as any, 'MySqlDecimalNumber');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDecimalNumber<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDecimalNumber<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDecimalNumber(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDecimalNumber<T extends ColumnBaseConfig<'number', 'MySqlDecimalNumber'>>
+export class MySqlDecimalNumber<T extends ColumnBaseConfig<'number' | 'number unsigned'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlDecimalNumber';
 
+	/** @internal */
+	override readonly codec = 'decimal:number';
+
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
 
-	override mapFromDriverValue(value: unknown): number {
-		if (typeof value === 'number') return value;
-
-		return Number(value);
-	}
-
 	override mapToDriverValue = String;
 
 	getSQLType(): string {
@@ -128,50 +105,43 @@ export class MySqlDecimalNumber<T extends ColumnBaseConfig<'number', 'MySqlDecim
 		return this.unsigned ? `${type} unsigned` : type;
 	}
 }
-
-export type MySqlDecimalBigIntBuilderInitial<TName extends string> = MySqlDecimalBigIntBuilder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'MySqlDecimalBigInt';
-	data: bigint;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlDecimalBigIntBuilder<
-	T extends ColumnBuilderBaseConfig<'bigint', 'MySqlDecimalBigInt'>,
-> extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDecimalConfig> {
+export class MySqlDecimalBigIntBuilder<TUnsigned extends boolean | undefined>
+	extends MySqlColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'bigint uint64' : 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	}, MySqlDecimalConfig>
+{
 	static override readonly [entityKind]: string = 'MySqlDecimalBigIntBuilder';
 
-	constructor(name: T['name'], config: MySqlDecimalConfig | undefined) {
-		super(name, 'bigint', 'MySqlDecimalBigInt');
+	constructor(name: string, config: MySqlDecimalConfig | undefined) {
+		super(name, config?.unsigned ? 'bigint uint64' : 'bigint int64' as any, 'MySqlDecimalBigInt');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDecimalBigInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDecimalBigInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlDecimalBigInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlDecimalBigInt<T extends ColumnBaseConfig<'bigint', 'MySqlDecimalBigInt'>>
+export class MySqlDecimalBigInt<T extends ColumnBaseConfig<'bigint int64' | 'bigint uint64'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlDecimalBigInt';
 
+	/** @internal */
+	override readonly codec = 'decimal:bigint';
+
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
 
-	override mapFromDriverValue = BigInt;
-
 	override mapToDriverValue = String;
 
 	getSQLType(): string {
@@ -188,25 +158,27 @@ export class MySqlDecimalBigInt<T extends ColumnBaseConfig<'bigint', 'MySqlDecim
 	}
 }
 
-export interface MySqlDecimalConfig<T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint'> {
+export interface MySqlDecimalConfig<
+	T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint',
+	TUnsigned extends boolean | undefined = boolean | undefined,
+> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 	mode?: T;
 }
 
-export function decimal(): MySqlDecimalBuilderInitial<''>;
-export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
-	config: MySqlDecimalConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? MySqlDecimalNumberBuilderInitial<''>
-	: Equal<TMode, 'bigint'> extends true ? MySqlDecimalBigIntBuilderInitial<''>
-	: MySqlDecimalBuilderInitial<''>;
-export function decimal<TName extends string, TMode extends 'string' | 'number' | 'bigint'>(
-	name: TName,
-	config?: MySqlDecimalConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? MySqlDecimalNumberBuilderInitial<TName>
-	: Equal<TMode, 'bigint'> extends true ? MySqlDecimalBigIntBuilderInitial<TName>
-	: MySqlDecimalBuilderInitial<TName>;
+export function decimal<TMode extends 'string' | 'number' | 'bigint', TUnsigned extends boolean | undefined>(
+	config?: MySqlDecimalConfig<TMode, TUnsigned>,
+): Equal<TMode, 'number'> extends true ? MySqlDecimalNumberBuilder<TUnsigned>
+	: Equal<TMode, 'bigint'> extends true ? MySqlDecimalBigIntBuilder<TUnsigned>
+	: MySqlDecimalBuilder<TUnsigned>;
+export function decimal<TMode extends 'string' | 'number' | 'bigint', TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlDecimalConfig<TMode, TUnsigned>,
+): Equal<TMode, 'number'> extends true ? MySqlDecimalNumberBuilder<TUnsigned>
+	: Equal<TMode, 'bigint'> extends true ? MySqlDecimalBigIntBuilder<TUnsigned>
+	: MySqlDecimalBuilder<TUnsigned>;
 export function decimal(a?: string | MySqlDecimalConfig, b: MySqlDecimalConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<MySqlDecimalConfig>(a, b);
 	const mode = config?.mode;
diff --git a/drizzle-orm/src/mysql-core/columns/double.ts b/drizzle-orm/src/mysql-core/columns/double.ts
index bc23fc74c0..3116cb0891 100644
--- a/drizzle-orm/src/mysql-core/columns/double.ts
+++ b/drizzle-orm/src/mysql-core/columns/double.ts
@@ -1,44 +1,37 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlDoubleBuilderInitial<TName extends string> = MySqlDoubleBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlDouble';
+export class MySqlDoubleBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number udouble' : 'number double';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlDoubleBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlDouble'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDoubleConfig>
-{
+}, MySqlDoubleConfig> {
 	static override readonly [entityKind]: string = 'MySqlDoubleBuilder';
 
-	constructor(name: T['name'], config: MySqlDoubleConfig | undefined) {
-		super(name, 'number', 'MySqlDouble');
+	constructor(name: string, config: MySqlDoubleConfig | undefined) {
+		super(name, config?.unsigned ? 'number udouble' : 'number double' as any, 'MySqlDouble');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDouble<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDouble<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlDouble(table, this.config as any);
 	}
 }
 
-export class MySqlDouble<T extends ColumnBaseConfig<'number', 'MySqlDouble'>>
+export class MySqlDouble<T extends ColumnBaseConfig<'number double' | 'number udouble'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlDoubleConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlDouble';
 
+	/** @internal */
+	override readonly codec = 'double';
+
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
@@ -56,20 +49,19 @@ export class MySqlDouble<T extends ColumnBaseConfig<'number', 'MySqlDouble'>>
 	}
 }
 
-export interface MySqlDoubleConfig {
+export interface MySqlDoubleConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function double(): MySqlDoubleBuilderInitial<''>;
-export function double(
-	config?: MySqlDoubleConfig,
-): MySqlDoubleBuilderInitial<''>;
-export function double<TName extends string>(
-	name: TName,
-	config?: MySqlDoubleConfig,
-): MySqlDoubleBuilderInitial<TName>;
+export function double<TUnsigned extends boolean | undefined>(
+	config?: MySqlDoubleConfig<TUnsigned>,
+): MySqlDoubleBuilder<TUnsigned>;
+export function double<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlDoubleConfig<TUnsigned>,
+): MySqlDoubleBuilder<TUnsigned>;
 export function double(a?: string | MySqlDoubleConfig, b?: MySqlDoubleConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlDoubleConfig>(a, b);
 	return new MySqlDoubleBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/enum.ts b/drizzle-orm/src/mysql-core/columns/enum.ts
index 9fc94283d6..d615f3eefc 100644
--- a/drizzle-orm/src/mysql-core/columns/enum.ts
+++ b/drizzle-orm/src/mysql-core/columns/enum.ts
@@ -1,46 +1,39 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import type { NonArray, Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { MySqlStringBaseColumn, MySqlStringColumnBaseBuilder } from './string.common.ts';
 
-// enum as string union
-export type MySqlEnumColumnBuilderInitial<TName extends string, TEnum extends string[]> = MySqlEnumColumnBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlEnumColumn';
+export class MySqlEnumColumnBuilder<TEnum extends [string, ...string[]]> extends MySqlStringColumnBaseBuilder<{
+	dataType: 'string enum';
 	data: TEnum[number];
 	driverParam: string;
 	enumValues: TEnum;
-}>;
-
-export class MySqlEnumColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlEnumColumn'>>
-	extends MySqlColumnBuilder<T, { enumValues: T['enumValues'] }>
-{
+}, { enumValues: TEnum }> {
 	static override readonly [entityKind]: string = 'MySqlEnumColumnBuilder';
 
-	constructor(name: T['name'], values: T['enumValues']) {
-		super(name, 'string', 'MySqlEnumColumn');
+	constructor(name: string, values: TEnum) {
+		super(name, 'string enum', 'MySqlEnumColumn');
 		this.config.enumValues = values;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new MySqlEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+	override build(table: MySqlTable) {
+		return new MySqlEnumColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlEnumColumn<T extends ColumnBaseConfig<'string', 'MySqlEnumColumn'>>
-	extends MySqlColumn<T, { enumValues: T['enumValues'] }>
+export class MySqlEnumColumn<T extends ColumnBaseConfig<'string enum'>>
+	extends MySqlStringBaseColumn<T, { enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'MySqlEnumColumn';
 
+	/** @internal */
+	override readonly codec = 'enum';
+
 	override readonly enumValues = this.config.enumValues;
 
 	getSQLType(): string {
@@ -49,43 +42,36 @@ export class MySqlEnumColumn<T extends ColumnBaseConfig<'string', 'MySqlEnumColu
 }
 
 // enum as ts enum
-
-export type MySqlEnumObjectColumnBuilderInitial<TName extends string, TEnum extends object> =
-	MySqlEnumObjectColumnBuilder<{
-		name: TName;
-		dataType: 'string';
-		columnType: 'MySqlEnumObjectColumn';
-		data: TEnum[keyof TEnum];
-		driverParam: string;
-		enumValues: string[];
-	}>;
-
-export class MySqlEnumObjectColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlEnumObjectColumn'>>
-	extends MySqlColumnBuilder<T, { enumValues: T['enumValues'] }>
-{
+export class MySqlEnumObjectColumnBuilder<TEnum extends object> extends MySqlStringColumnBaseBuilder<{
+	dataType: 'string enum';
+	data: TEnum[keyof TEnum];
+	driverParam: string;
+	enumValues: string[];
+}, { enumValues: TEnum }> {
 	static override readonly [entityKind]: string = 'MySqlEnumObjectColumnBuilder';
 
-	constructor(name: T['name'], values: T['enumValues']) {
-		super(name, 'string', 'MySqlEnumObjectColumn');
+	constructor(name: string, values: TEnum) {
+		super(name, 'string enum', 'MySqlEnumObjectColumn');
 		this.config.enumValues = values;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlEnumObjectColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new MySqlEnumObjectColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+	override build(table: MySqlTable) {
+		return new MySqlEnumObjectColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlEnumObjectColumn<T extends ColumnBaseConfig<'string', 'MySqlEnumObjectColumn'>>
-	extends MySqlColumn<T, { enumValues: T['enumValues'] }>
+export class MySqlEnumObjectColumn<T extends ColumnBaseConfig<'string enum'>>
+	extends MySqlStringBaseColumn<T, { enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'MySqlEnumObjectColumn';
 
+	/** @internal */
+	override readonly codec = 'enum';
+
 	override readonly enumValues = this.config.enumValues;
 
 	getSQLType(): string {
@@ -95,18 +81,18 @@ export class MySqlEnumObjectColumn<T extends ColumnBaseConfig<'string', 'MySqlEn
 
 export function mysqlEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
 	values: T | Writable<T>,
-): MySqlEnumColumnBuilderInitial<'', Writable<T>>;
-export function mysqlEnum<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): MySqlEnumColumnBuilder<Writable<T>>;
+export function mysqlEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	values: T | Writable<T>,
-): MySqlEnumColumnBuilderInitial<TName, Writable<T>>;
+): MySqlEnumColumnBuilder<Writable<T>>;
 export function mysqlEnum<E extends Record<string, string>>(
 	enumObj: NonArray<E>,
-): MySqlEnumObjectColumnBuilderInitial<'', E>;
-export function mysqlEnum<TName extends string, E extends Record<string, string>>(
-	name: TName,
+): MySqlEnumObjectColumnBuilder<E>;
+export function mysqlEnum<E extends Record<string, string>>(
+	name: string,
 	values: NonArray<E>,
-): MySqlEnumObjectColumnBuilderInitial<TName, E>;
+): MySqlEnumObjectColumnBuilder<E>;
 export function mysqlEnum(
 	a?: string | readonly [string, ...string[]] | [string, ...string[]] | Record<string, string>,
 	b?: readonly [string, ...string[]] | [string, ...string[]] | Record<string, string>,
diff --git a/drizzle-orm/src/mysql-core/columns/float.ts b/drizzle-orm/src/mysql-core/columns/float.ts
index e368740a0e..ab01d887d0 100644
--- a/drizzle-orm/src/mysql-core/columns/float.ts
+++ b/drizzle-orm/src/mysql-core/columns/float.ts
@@ -1,44 +1,37 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlFloatBuilderInitial<TName extends string> = MySqlFloatBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlFloat';
+export class MySqlFloatBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number ufloat' : 'number float';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlFloatBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlFloat'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlFloatConfig>
-{
+}, MySqlFloatConfig> {
 	static override readonly [entityKind]: string = 'MySqlFloatBuilder';
 
-	constructor(name: T['name'], config: MySqlFloatConfig | undefined) {
-		super(name, 'number', 'MySqlFloat');
+	constructor(name: string, config: MySqlFloatConfig | undefined) {
+		super(name, config?.unsigned ? 'number ufloat' : 'number float' as any, 'MySqlFloat');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlFloat<MakeColumnConfig<T, TTableName>> {
-		return new MySqlFloat<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlFloat(table, this.config as any);
 	}
 }
 
-export class MySqlFloat<T extends ColumnBaseConfig<'number', 'MySqlFloat'>>
+export class MySqlFloat<T extends ColumnBaseConfig<'number float' | 'number ufloat'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlFloatConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlFloat';
 
+	/** @internal */
+	override readonly codec = 'float';
+
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
@@ -56,20 +49,19 @@ export class MySqlFloat<T extends ColumnBaseConfig<'number', 'MySqlFloat'>>
 	}
 }
 
-export interface MySqlFloatConfig {
+export interface MySqlFloatConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function float(): MySqlFloatBuilderInitial<''>;
-export function float(
-	config?: MySqlFloatConfig,
-): MySqlFloatBuilderInitial<''>;
-export function float<TName extends string>(
-	name: TName,
-	config?: MySqlFloatConfig,
-): MySqlFloatBuilderInitial<TName>;
+export function float<TUnsigned extends boolean | undefined>(
+	config?: MySqlFloatConfig<TUnsigned>,
+): MySqlFloatBuilder<TUnsigned>;
+export function float<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlFloatConfig<TUnsigned>,
+): MySqlFloatBuilder<TUnsigned>;
 export function float(a?: string | MySqlFloatConfig, b?: MySqlFloatConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlFloatConfig>(a, b);
 	return new MySqlFloatBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/index.ts b/drizzle-orm/src/mysql-core/columns/index.ts
index b51f0fac48..1c3ba71f37 100644
--- a/drizzle-orm/src/mysql-core/columns/index.ts
+++ b/drizzle-orm/src/mysql-core/columns/index.ts
@@ -1,5 +1,6 @@
 export * from './bigint.ts';
 export * from './binary.ts';
+export * from './blob.ts';
 export * from './boolean.ts';
 export * from './char.ts';
 export * from './common.ts';
diff --git a/drizzle-orm/src/mysql-core/columns/int.ts b/drizzle-orm/src/mysql-core/columns/int.ts
index 79b93bdf75..c4a80a3b65 100644
--- a/drizzle-orm/src/mysql-core/columns/int.ts
+++ b/drizzle-orm/src/mysql-core/columns/int.ts
@@ -1,66 +1,51 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlIntBuilderInitial<TName extends string> = MySqlIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlInt';
+export class MySqlIntBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number uint32' : 'number int32';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
-{
+}, MySqlIntConfig> {
 	static override readonly [entityKind]: string = 'MySqlIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlInt');
+	constructor(name: string, config?: MySqlIntConfig) {
+		super(name, config?.unsigned ? 'number uint32' : 'number int32' as any, 'MySqlInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlInt(table, this.config as any);
 	}
 }
 
-export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>>
+export class MySqlInt<T extends ColumnBaseConfig<'number int32' | 'number uint32'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlInt';
 
+	/** @internal */
+	override readonly codec = 'int';
+
 	getSQLType(): string {
 		return `int${this.config.unsigned ? ' unsigned' : ''}`;
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	}
 }
 
-export interface MySqlIntConfig {
-	unsigned?: boolean;
+export interface MySqlIntConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
+	unsigned?: TUnsigned;
 }
 
-export function int(): MySqlIntBuilderInitial<''>;
-export function int(
-	config?: MySqlIntConfig,
-): MySqlIntBuilderInitial<''>;
-export function int<TName extends string>(
-	name: TName,
+export function int<TUnsigned extends boolean | undefined>(
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlIntBuilder<TUnsigned>;
+export function int<TUnsigned extends boolean | undefined>(
+	name: string,
 	config?: MySqlIntConfig,
-): MySqlIntBuilderInitial<TName>;
+): MySqlIntBuilder<TUnsigned>;
 export function int(a?: string | MySqlIntConfig, b?: MySqlIntConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlIntConfig>(a, b);
 	return new MySqlIntBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/json.ts b/drizzle-orm/src/mysql-core/columns/json.ts
index 12d11bd4a5..9413574eac 100644
--- a/drizzle-orm/src/mysql-core/columns/json.ts
+++ b/drizzle-orm/src/mysql-core/columns/json.ts
@@ -1,47 +1,40 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlJsonBuilderInitial<TName extends string> = MySqlJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'MySqlJson';
+export class MySqlJsonBuilder extends MySqlColumnBuilder<{
+	dataType: 'object json';
 	data: unknown;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'MySqlJson'>> extends MySqlColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'MySqlJsonBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'MySqlJson');
+	constructor(name: string) {
+		super(name, 'object json', 'MySqlJson');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlJson<MakeColumnConfig<T, TTableName>> {
-		return new MySqlJson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlJson(table, this.config as any);
 	}
 }
 
-export class MySqlJson<T extends ColumnBaseConfig<'json', 'MySqlJson'>> extends MySqlColumn<T> {
+export class MySqlJson<T extends ColumnBaseConfig<'object json'>> extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlJson';
 
+	/** @internal */
+	override readonly codec = 'json';
+
 	getSQLType(): string {
 		return 'json';
 	}
 
-	override mapToDriverValue(value: T['data']): string {
+	override mapToDriverValue = (value: T['data']): string => {
 		return JSON.stringify(value);
-	}
+	};
 }
 
-export function json(): MySqlJsonBuilderInitial<''>;
-export function json<TName extends string>(name: TName): MySqlJsonBuilderInitial<TName>;
-export function json(name?: string) {
+export function json(name?: string): MySqlJsonBuilder {
 	return new MySqlJsonBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/mysql-core/columns/mediumint.ts b/drizzle-orm/src/mysql-core/columns/mediumint.ts
index 7ba5cc9449..ba42cc9d69 100644
--- a/drizzle-orm/src/mysql-core/columns/mediumint.ts
+++ b/drizzle-orm/src/mysql-core/columns/mediumint.ts
@@ -1,66 +1,51 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 import type { MySqlIntConfig } from './int.ts';
 
-export type MySqlMediumIntBuilderInitial<TName extends string> = MySqlMediumIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlMediumInt';
+export class MySqlMediumIntBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number uint24' : 'number int24';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlMediumInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
-{
+}, MySqlIntConfig> {
 	static override readonly [entityKind]: string = 'MySqlMediumIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlMediumInt');
+	constructor(name: string, config?: MySqlIntConfig) {
+		super(name, config?.unsigned ? 'number uint24' : 'number int24' as any, 'MySqlMediumInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlMediumInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlMediumInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlMediumInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlMediumInt<T extends ColumnBaseConfig<'number', 'MySqlMediumInt'>>
+export class MySqlMediumInt<T extends ColumnBaseConfig<'number int24' | 'number uint24'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlMediumInt';
 
+	/** @internal */
+	override readonly codec = 'mediumint';
+
 	getSQLType(): string {
 		return `mediumint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	}
 }
 
-export function mediumint(): MySqlMediumIntBuilderInitial<''>;
-export function mediumint(
-	config?: MySqlIntConfig,
-): MySqlMediumIntBuilderInitial<''>;
-export function mediumint<TName extends string>(
-	name: TName,
-	config?: MySqlIntConfig,
-): MySqlMediumIntBuilderInitial<TName>;
+export function mediumint<TUnsigned extends boolean | undefined>(
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlMediumIntBuilder<TUnsigned>;
+export function mediumint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlMediumIntBuilder<TUnsigned>;
 export function mediumint(a?: string | MySqlIntConfig, b?: MySqlIntConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlIntConfig>(a, b);
 	return new MySqlMediumIntBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/real.ts b/drizzle-orm/src/mysql-core/columns/real.ts
index c6b4473108..7628ddceb6 100644
--- a/drizzle-orm/src/mysql-core/columns/real.ts
+++ b/drizzle-orm/src/mysql-core/columns/real.ts
@@ -1,47 +1,40 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlRealBuilderInitial<TName extends string> = MySqlRealBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlReal';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlReal'>>
-	extends MySqlColumnBuilderWithAutoIncrement<
-		T,
-		MySqlRealConfig
-	>
-{
+export class MySqlRealBuilder extends MySqlColumnBuilderWithAutoIncrement<
+	{
+		dataType: 'number double';
+		data: number;
+		driverParam: number | string;
+	},
+	MySqlRealConfig
+> {
 	static override readonly [entityKind]: string = 'MySqlRealBuilder';
 
-	constructor(name: T['name'], config: MySqlRealConfig | undefined) {
-		super(name, 'number', 'MySqlReal');
+	constructor(name: string, config: MySqlRealConfig | undefined) {
+		super(name, 'number double', 'MySqlReal');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlReal<MakeColumnConfig<T, TTableName>> {
-		return new MySqlReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlReal(table, this.config as any);
 	}
 }
 
-export class MySqlReal<T extends ColumnBaseConfig<'number', 'MySqlReal'>> extends MySqlColumnWithAutoIncrement<
+export class MySqlReal<T extends ColumnBaseConfig<'number double'>> extends MySqlColumnWithAutoIncrement<
 	T,
 	MySqlRealConfig
 > {
 	static override readonly [entityKind]: string = 'MySqlReal';
 
+	/** @internal */
+	override readonly codec = 'real';
+
 	precision: number | undefined = this.config.precision;
 	scale: number | undefined = this.config.scale;
 
@@ -61,14 +54,13 @@ export interface MySqlRealConfig {
 	scale?: number;
 }
 
-export function real(): MySqlRealBuilderInitial<''>;
 export function real(
 	config?: MySqlRealConfig,
-): MySqlRealBuilderInitial<''>;
-export function real<TName extends string>(
-	name: TName,
+): MySqlRealBuilder;
+export function real(
+	name: string,
 	config?: MySqlRealConfig,
-): MySqlRealBuilderInitial<TName>;
+): MySqlRealBuilder;
 export function real(a?: string | MySqlRealConfig, b: MySqlRealConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<MySqlRealConfig>(a, b);
 	return new MySqlRealBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/serial.ts b/drizzle-orm/src/mysql-core/columns/serial.ts
index 90fd7a2e5e..a48ac7b590 100644
--- a/drizzle-orm/src/mysql-core/columns/serial.ts
+++ b/drizzle-orm/src/mysql-core/columns/serial.ts
@@ -1,72 +1,44 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	HasDefault,
-	IsAutoincrement,
-	IsPrimaryKey,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlSerialBuilderInitial<TName extends string> = IsAutoincrement<
-	IsPrimaryKey<
-		NotNull<
-			HasDefault<
-				MySqlSerialBuilder<{
-					name: TName;
-					dataType: 'number';
-					columnType: 'MySqlSerial';
-					data: number;
-					driverParam: number;
-					enumValues: undefined;
-				}>
-			>
-		>
-	>
->;
-
-export class MySqlSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlSerial'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
-{
+export class MySqlSerialBuilder extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: 'number uint53';
+	data: number;
+	driverParam: number;
+	hasDefault: true;
+	notNull: true;
+	isPrimaryKey: true;
+	isAutoincrement: true;
+}> {
 	static override readonly [entityKind]: string = 'MySqlSerialBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'MySqlSerial');
+	constructor(name: string) {
+		super(name, 'number uint53', 'MySqlSerial');
 		this.config.hasDefault = true;
 		this.config.autoIncrement = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlSerial<MakeColumnConfig<T, TTableName>> {
-		return new MySqlSerial<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlSerial(table, this.config as any);
 	}
 }
 
 export class MySqlSerial<
-	T extends ColumnBaseConfig<'number', 'MySqlSerial'>,
+	T extends ColumnBaseConfig<'number uint53'>,
 > extends MySqlColumnWithAutoIncrement<T> {
 	static override readonly [entityKind]: string = 'MySqlSerial';
 
+	/** @internal */
+	override readonly codec = 'serial';
+
 	getSQLType(): string {
 		return 'serial';
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	}
 }
 
-export function serial(): MySqlSerialBuilderInitial<''>;
-export function serial<TName extends string>(name: TName): MySqlSerialBuilderInitial<TName>;
-export function serial(name?: string) {
+export function serial(name?: string): MySqlSerialBuilder {
 	return new MySqlSerialBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/mysql-core/columns/smallint.ts b/drizzle-orm/src/mysql-core/columns/smallint.ts
index 87083f0fab..9f4715e9f2 100644
--- a/drizzle-orm/src/mysql-core/columns/smallint.ts
+++ b/drizzle-orm/src/mysql-core/columns/smallint.ts
@@ -1,66 +1,51 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 import type { MySqlIntConfig } from './int.ts';
 
-export type MySqlSmallIntBuilderInitial<TName extends string> = MySqlSmallIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlSmallInt';
+export class MySqlSmallIntBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number uint16' : 'number int16';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlSmallInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
-{
+}, MySqlIntConfig> {
 	static override readonly [entityKind]: string = 'MySqlSmallIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlSmallInt');
+	constructor(name: string, config?: MySqlIntConfig) {
+		super(name, config?.unsigned ? 'number uint16' : 'number int16' as any, 'MySqlSmallInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlSmallInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlSmallInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlSmallInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>>
+export class MySqlSmallInt<T extends ColumnBaseConfig<'number int16' | 'number uint16'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlSmallInt';
 
+	/** @internal */
+	override readonly codec = 'smallint';
+
 	getSQLType(): string {
 		return `smallint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	}
 }
 
-export function smallint(): MySqlSmallIntBuilderInitial<''>;
-export function smallint(
-	config?: MySqlIntConfig,
-): MySqlSmallIntBuilderInitial<''>;
-export function smallint<TName extends string>(
-	name: TName,
-	config?: MySqlIntConfig,
-): MySqlSmallIntBuilderInitial<TName>;
+export function smallint<TUnsigned extends boolean | undefined>(
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlSmallIntBuilder<TUnsigned>;
+export function smallint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlSmallIntBuilder<TUnsigned>;
 export function smallint(a?: string | MySqlIntConfig, b?: MySqlIntConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlIntConfig>(a, b);
 	return new MySqlSmallIntBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/string.common.ts b/drizzle-orm/src/mysql-core/columns/string.common.ts
new file mode 100644
index 0000000000..d2d0774778
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/columns/string.common.ts
@@ -0,0 +1,369 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnType } from '~/column-builder.ts';
+import type { ColumnBaseConfig } from '~/column.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+
+export interface MySqlStringColumnBaseConfig {
+	charSet: CharSet;
+	collation: Collation;
+}
+
+export abstract class MySqlStringColumnBaseBuilder<
+	T extends ColumnBuilderBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
+> extends MySqlColumnBuilder<T, TRuntimeConfig & MySqlStringColumnBaseConfig, TExtraConfig> {
+	static override readonly [entityKind]: string = 'MySqlStringColumnBuilder';
+
+	charSet(charSet: CharSet): Omit<this, 'charSet'> {
+		this.config.charSet = charSet;
+		return this;
+	}
+
+	collate(collation: Collation): Omit<this, 'collate'> {
+		this.config.collation = collation;
+		return this;
+	}
+}
+
+export abstract class MySqlStringBaseColumn<
+	T extends ColumnBaseConfig<ColumnType>,
+	TRuntimeConfig extends object = object,
+> extends MySqlColumn<T, MySqlStringColumnBaseConfig & TRuntimeConfig> {
+	static override readonly [entityKind]: string = 'MySqlStringColumn';
+
+	readonly charSet: CharSet = this.config.charSet;
+	readonly collation: Collation = this.config.collation;
+}
+
+type CharSet =
+	| 'ascii'
+	| 'big5'
+	| 'binary'
+	| 'cp1250'
+	| 'cp1251'
+	| 'cp1256'
+	| 'cp1257'
+	| 'cp850'
+	| 'cp852'
+	| 'cp866'
+	| 'cp932'
+	| 'dec8'
+	| 'eucjpms'
+	| 'euckr'
+	| 'gb18030'
+	| 'gb2312'
+	| 'gbk'
+	| 'geostd8'
+	| 'greek'
+	| 'hebrew'
+	| 'hp8'
+	| 'keybcs2'
+	| 'koi8r'
+	| 'koi8u'
+	| 'latin1'
+	| 'latin2'
+	| 'latin5'
+	| 'latin7'
+	| 'macce'
+	| 'macroman'
+	| 'sjis'
+	| 'swe7'
+	| 'tis620'
+	| 'ucs2'
+	| 'ujis'
+	| 'utf16'
+	| 'utf16le'
+	| 'utf32'
+	| 'utf8mb3'
+	| 'utf8mb4'
+	| (string & {});
+
+type Collation =
+	| 'armscii8_bin'
+	| 'armscii8_general_ci'
+	| 'ascii_bin'
+	| 'ascii_general_ci'
+	| 'big5_bin'
+	| 'big5_chinese_ci'
+	| 'binary'
+	| 'cp1250_bin'
+	| 'cp1250_croatian_ci'
+	| 'cp1250_czech_cs'
+	| 'cp1250_general_ci'
+	| 'cp1250_polish_ci'
+	| 'cp1251_bin'
+	| 'cp1251_bulgarian_ci'
+	| 'cp1251_general_ci'
+	| 'cp1251_general_cs'
+	| 'cp1251_ukrainian_ci'
+	| 'cp1256_bin'
+	| 'cp1256_general_ci'
+	| 'cp1257_bin'
+	| 'cp1257_general_ci'
+	| 'cp1257_lithuanian_ci'
+	| 'cp850_bin'
+	| 'cp850_general_ci'
+	| 'cp852_bin'
+	| 'cp852_general_ci'
+	| 'cp866_bin'
+	| 'cp866_general_ci'
+	| 'cp932_bin'
+	| 'cp932_japanese_ci'
+	| 'dec8_bin'
+	| 'dec8_swedish_ci'
+	| 'eucjpms_bin'
+	| 'eucjpms_japanese_ci'
+	| 'euckr_bin'
+	| 'euckr_korean_ci'
+	| 'gb18030_bin'
+	| 'gb18030_chinese_ci'
+	| 'gb18030_unicode_520_ci'
+	| 'gb2312_bin'
+	| 'gb2312_chinese_ci'
+	| 'gbk_bin'
+	| 'gbk_chinese_ci'
+	| 'geostd8_bin'
+	| 'geostd8_general_ci'
+	| 'greek_bin'
+	| 'greek_general_ci'
+	| 'hebrew_bin'
+	| 'hebrew_general_ci'
+	| 'hp8_bin'
+	| 'hp8_english_ci'
+	| 'keybcs2_bin'
+	| 'keybcs2_general_ci'
+	| 'koi8r_bin'
+	| 'koi8r_general_ci'
+	| 'koi8u_bin'
+	| 'koi8u_general_ci'
+	| 'latin1_bin'
+	| 'latin1_danish_ci'
+	| 'latin1_general_ci'
+	| 'latin1_general_cs'
+	| 'latin1_german1_ci'
+	| 'latin1_german2_ci'
+	| 'latin1_spanish_ci'
+	| 'latin1_swedish_ci'
+	| 'latin2_bin'
+	| 'latin2_croatian_ci'
+	| 'latin2_czech_cs'
+	| 'latin2_general_ci'
+	| 'latin2_hungarian_ci'
+	| 'latin5_bin'
+	| 'latin5_turkish_ci'
+	| 'latin7_bin'
+	| 'latin7_estonian_cs'
+	| 'latin7_general_ci'
+	| 'latin7_general_cs'
+	| 'macce_bin'
+	| 'macce_general_ci'
+	| 'macroman_bin'
+	| 'macroman_general_ci'
+	| 'sjis_bin'
+	| 'sjis_japanese_ci'
+	| 'swe7_bin'
+	| 'swe7_swedish_ci'
+	| 'tis620_bin'
+	| 'tis620_thai_ci'
+	| 'ucs2_bin'
+	| 'ucs2_croatian_ci'
+	| 'ucs2_czech_ci'
+	| 'ucs2_danish_ci'
+	| 'ucs2_esperanto_ci'
+	| 'ucs2_estonian_ci'
+	| 'ucs2_general_ci'
+	| 'ucs2_general_mysql500_ci'
+	| 'ucs2_german2_ci'
+	| 'ucs2_hungarian_ci'
+	| 'ucs2_icelandic_ci'
+	| 'ucs2_latvian_ci'
+	| 'ucs2_lithuanian_ci'
+	| 'ucs2_persian_ci'
+	| 'ucs2_polish_ci'
+	| 'ucs2_romanian_ci'
+	| 'ucs2_roman_ci'
+	| 'ucs2_sinhala_ci'
+	| 'ucs2_slovak_ci'
+	| 'ucs2_slovenian_ci'
+	| 'ucs2_spanish2_ci'
+	| 'ucs2_spanish_ci'
+	| 'ucs2_swedish_ci'
+	| 'ucs2_turkish_ci'
+	| 'ucs2_unicode_520_ci'
+	| 'ucs2_unicode_ci'
+	| 'ucs2_vietnamese_ci'
+	| 'ujis_bin'
+	| 'ujis_japanese_ci'
+	| 'utf16_bin'
+	| 'utf16_croatian_ci'
+	| 'utf16_czech_ci'
+	| 'utf16_danish_ci'
+	| 'utf16_esperanto_ci'
+	| 'utf16_estonian_ci'
+	| 'utf16_general_ci'
+	| 'utf16_german2_ci'
+	| 'utf16_hungarian_ci'
+	| 'utf16_icelandic_ci'
+	| 'utf16_latvian_ci'
+	| 'utf16_lithuanian_ci'
+	| 'utf16_persian_ci'
+	| 'utf16_polish_ci'
+	| 'utf16_romanian_ci'
+	| 'utf16_roman_ci'
+	| 'utf16_sinhala_ci'
+	| 'utf16_slovak_ci'
+	| 'utf16_slovenian_ci'
+	| 'utf16_spanish2_ci'
+	| 'utf16_spanish_ci'
+	| 'utf16_swedish_ci'
+	| 'utf16_turkish_ci'
+	| 'utf16_unicode_520_ci'
+	| 'utf16_unicode_ci'
+	| 'utf16_vietnamese_ci'
+	| 'utf16le_bin'
+	| 'utf16le_general_ci'
+	| 'utf32_bin'
+	| 'utf32_croatian_ci'
+	| 'utf32_czech_ci'
+	| 'utf32_danish_ci'
+	| 'utf32_esperanto_ci'
+	| 'utf32_estonian_ci'
+	| 'utf32_general_ci'
+	| 'utf32_german2_ci'
+	| 'utf32_hungarian_ci'
+	| 'utf32_icelandic_ci'
+	| 'utf32_latvian_ci'
+	| 'utf32_lithuanian_ci'
+	| 'utf32_persian_ci'
+	| 'utf32_polish_ci'
+	| 'utf32_romanian_ci'
+	| 'utf32_roman_ci'
+	| 'utf32_sinhala_ci'
+	| 'utf32_slovak_ci'
+	| 'utf32_slovenian_ci'
+	| 'utf32_spanish2_ci'
+	| 'utf32_spanish_ci'
+	| 'utf32_swedish_ci'
+	| 'utf32_turkish_ci'
+	| 'utf32_unicode_520_ci'
+	| 'utf32_unicode_ci'
+	| 'utf32_vietnamese_ci'
+	| 'utf8mb3_bin'
+	| 'utf8mb3_croatian_ci'
+	| 'utf8mb3_czech_ci'
+	| 'utf8mb3_danish_ci'
+	| 'utf8mb3_esperanto_ci'
+	| 'utf8mb3_estonian_ci'
+	| 'utf8mb3_general_ci'
+	| 'utf8mb3_general_mysql500_ci'
+	| 'utf8mb3_german2_ci'
+	| 'utf8mb3_hungarian_ci'
+	| 'utf8mb3_icelandic_ci'
+	| 'utf8mb3_latvian_ci'
+	| 'utf8mb3_lithuanian_ci'
+	| 'utf8mb3_persian_ci'
+	| 'utf8mb3_polish_ci'
+	| 'utf8mb3_romanian_ci'
+	| 'utf8mb3_roman_ci'
+	| 'utf8mb3_sinhala_ci'
+	| 'utf8mb3_slovak_ci'
+	| 'utf8mb3_slovenian_ci'
+	| 'utf8mb3_spanish2_ci'
+	| 'utf8mb3_spanish_ci'
+	| 'utf8mb3_swedish_ci'
+	| 'utf8mb3_tolower_ci'
+	| 'utf8mb3_turkish_ci'
+	| 'utf8mb3_unicode_520_ci'
+	| 'utf8mb3_unicode_ci'
+	| 'utf8mb3_vietnamese_ci'
+	| 'utf8mb4_0900_ai_ci'
+	| 'utf8mb4_0900_as_ci'
+	| 'utf8mb4_0900_as_cs'
+	| 'utf8mb4_0900_bin'
+	| 'utf8mb4_bg_0900_ai_ci'
+	| 'utf8mb4_bg_0900_as_cs'
+	| 'utf8mb4_bin'
+	| 'utf8mb4_bs_0900_ai_ci'
+	| 'utf8mb4_bs_0900_as_cs'
+	| 'utf8mb4_croatian_ci'
+	| 'utf8mb4_cs_0900_ai_ci'
+	| 'utf8mb4_cs_0900_as_cs'
+	| 'utf8mb4_czech_ci'
+	| 'utf8mb4_danish_ci'
+	| 'utf8mb4_da_0900_ai_ci'
+	| 'utf8mb4_da_0900_as_cs'
+	| 'utf8mb4_de_pb_0900_ai_ci'
+	| 'utf8mb4_de_pb_0900_as_cs'
+	| 'utf8mb4_eo_0900_ai_ci'
+	| 'utf8mb4_eo_0900_as_cs'
+	| 'utf8mb4_esperanto_ci'
+	| 'utf8mb4_estonian_ci'
+	| 'utf8mb4_es_0900_ai_ci'
+	| 'utf8mb4_es_0900_as_cs'
+	| 'utf8mb4_es_trad_0900_ai_ci'
+	| 'utf8mb4_es_trad_0900_as_cs'
+	| 'utf8mb4_et_0900_ai_ci'
+	| 'utf8mb4_et_0900_as_cs'
+	| 'utf8mb4_general_ci'
+	| 'utf8mb4_german2_ci'
+	| 'utf8mb4_gl_0900_ai_ci'
+	| 'utf8mb4_gl_0900_as_cs'
+	| 'utf8mb4_hr_0900_ai_ci'
+	| 'utf8mb4_hr_0900_as_cs'
+	| 'utf8mb4_hungarian_ci'
+	| 'utf8mb4_hu_0900_ai_ci'
+	| 'utf8mb4_hu_0900_as_cs'
+	| 'utf8mb4_icelandic_ci'
+	| 'utf8mb4_is_0900_ai_ci'
+	| 'utf8mb4_is_0900_as_cs'
+	| 'utf8mb4_ja_0900_as_cs'
+	| 'utf8mb4_ja_0900_as_cs_ks'
+	| 'utf8mb4_latvian_ci'
+	| 'utf8mb4_la_0900_ai_ci'
+	| 'utf8mb4_la_0900_as_cs'
+	| 'utf8mb4_lithuanian_ci'
+	| 'utf8mb4_lt_0900_ai_ci'
+	| 'utf8mb4_lt_0900_as_cs'
+	| 'utf8mb4_lv_0900_ai_ci'
+	| 'utf8mb4_lv_0900_as_cs'
+	| 'utf8mb4_mn_cyrl_0900_ai_ci'
+	| 'utf8mb4_mn_cyrl_0900_as_cs'
+	| 'utf8mb4_nb_0900_ai_ci'
+	| 'utf8mb4_nb_0900_as_cs'
+	| 'utf8mb4_nn_0900_ai_ci'
+	| 'utf8mb4_nn_0900_as_cs'
+	| 'utf8mb4_persian_ci'
+	| 'utf8mb4_pl_0900_ai_ci'
+	| 'utf8mb4_pl_0900_as_cs'
+	| 'utf8mb4_polish_ci'
+	| 'utf8mb4_romanian_ci'
+	| 'utf8mb4_roman_ci'
+	| 'utf8mb4_ro_0900_ai_ci'
+	| 'utf8mb4_ro_0900_as_cs'
+	| 'utf8mb4_ru_0900_ai_ci'
+	| 'utf8mb4_ru_0900_as_cs'
+	| 'utf8mb4_sinhala_ci'
+	| 'utf8mb4_sk_0900_ai_ci'
+	| 'utf8mb4_sk_0900_as_cs'
+	| 'utf8mb4_slovak_ci'
+	| 'utf8mb4_slovenian_ci'
+	| 'utf8mb4_sl_0900_ai_ci'
+	| 'utf8mb4_sl_0900_as_cs'
+	| 'utf8mb4_spanish2_ci'
+	| 'utf8mb4_spanish_ci'
+	| 'utf8mb4_sr_latn_0900_ai_ci'
+	| 'utf8mb4_sr_latn_0900_as_cs'
+	| 'utf8mb4_sv_0900_ai_ci'
+	| 'utf8mb4_sv_0900_as_cs'
+	| 'utf8mb4_swedish_ci'
+	| 'utf8mb4_tr_0900_ai_ci'
+	| 'utf8mb4_tr_0900_as_cs'
+	| 'utf8mb4_turkish_ci'
+	| 'utf8mb4_unicode_520_ci'
+	| 'utf8mb4_unicode_ci'
+	| 'utf8mb4_vietnamese_ci'
+	| 'utf8mb4_vi_0900_ai_ci'
+	| 'utf8mb4_vi_0900_as_cs'
+	| 'utf8mb4_zh_0900_as_cs'
+	| (string & {});
diff --git a/drizzle-orm/src/mysql-core/columns/text.ts b/drizzle-orm/src/mysql-core/columns/text.ts
index 6106fd45bf..0fae456f58 100644
--- a/drizzle-orm/src/mysql-core/columns/text.ts
+++ b/drizzle-orm/src/mysql-core/columns/text.ts
@@ -1,46 +1,60 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MySqlStringBaseColumn, MySqlStringColumnBaseBuilder } from './string.common.ts';
 
 export type MySqlTextColumnType = 'tinytext' | 'text' | 'mediumtext' | 'longtext';
 
-export type MySqlTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlTextBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlText';
-	data: TEnum[number];
-	driverParam: string;
-	enumValues: TEnum;
-}>;
-
-export class MySqlTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlText'>> extends MySqlColumnBuilder<
-	T,
-	{ textType: MySqlTextColumnType; enumValues: T['enumValues'] }
+export class MySqlTextBuilder<TEnum extends [string, ...string[]]> extends MySqlStringColumnBaseBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: string;
+		enumValues: TEnum;
+	},
+	{ textType: MySqlTextColumnType; enumValues?: TEnum; length: number }
 > {
 	static override readonly [entityKind]: string = 'MySqlTextBuilder';
 
-	constructor(name: T['name'], textType: MySqlTextColumnType, config: MySqlTextConfig<T['enumValues']>) {
-		super(name, 'string', 'MySqlText');
+	constructor(name: string, textType: MySqlTextColumnType, config: MySqlTextConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MySqlText');
 		this.config.textType = textType;
 		this.config.enumValues = config.enum;
+		switch (textType) {
+			case 'tinytext': {
+				this.config.length = 255;
+				break;
+			}
+			case 'text': {
+				this.config.length = 65535;
+				break;
+			}
+			case 'mediumtext': {
+				this.config.length = 16777215;
+				break;
+			}
+			case 'longtext': {
+				this.config.length = 4294967295;
+				break;
+			}
+		}
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlText<MakeColumnConfig<T, TTableName>> {
-		return new MySqlText<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlText(table, this.config as any);
 	}
 }
 
-export class MySqlText<T extends ColumnBaseConfig<'string', 'MySqlText'>>
-	extends MySqlColumn<T, { textType: MySqlTextColumnType; enumValues: T['enumValues'] }>
+export class MySqlText<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends MySqlStringBaseColumn<T, { textType: MySqlTextColumnType; enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'MySqlText';
 
+	/** @internal */
+	override readonly codec: MySqlTextColumnType = this.config.textType;
+
 	readonly textType: MySqlTextColumnType = this.config.textType;
 
 	override readonly enumValues = this.config.enumValues;
@@ -56,53 +70,49 @@ export interface MySqlTextConfig<
 	enum?: TEnum;
 }
 
-export function text(): MySqlTextBuilderInitial<'', [string, ...string[]]>;
 export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<'', Writable<T>>;
-export function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): MySqlTextBuilder<Writable<T>>;
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<TName, Writable<T>>;
+): MySqlTextBuilder<Writable<T>>;
 export function text(a?: string | MySqlTextConfig, b: MySqlTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<MySqlTextConfig>(a, b);
 	return new MySqlTextBuilder(name, 'text', config as any);
 }
 
-export function tinytext(): MySqlTextBuilderInitial<'', [string, ...string[]]>;
 export function tinytext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<'', Writable<T>>;
-export function tinytext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): MySqlTextBuilder<Writable<T>>;
+export function tinytext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<TName, Writable<T>>;
+): MySqlTextBuilder<Writable<T>>;
 export function tinytext(a?: string | MySqlTextConfig, b: MySqlTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<MySqlTextConfig>(a, b);
 	return new MySqlTextBuilder(name, 'tinytext', config as any);
 }
 
-export function mediumtext(): MySqlTextBuilderInitial<'', [string, ...string[]]>;
 export function mediumtext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<'', Writable<T>>;
-export function mediumtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): MySqlTextBuilder<Writable<T>>;
+export function mediumtext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<TName, Writable<T>>;
+): MySqlTextBuilder<Writable<T>>;
 export function mediumtext(a?: string | MySqlTextConfig, b: MySqlTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<MySqlTextConfig>(a, b);
 	return new MySqlTextBuilder(name, 'mediumtext', config as any);
 }
 
-export function longtext(): MySqlTextBuilderInitial<'', [string, ...string[]]>;
 export function longtext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<'', Writable<T>>;
-export function longtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): MySqlTextBuilder<Writable<T>>;
+export function longtext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: MySqlTextConfig<T | Writable<T>>,
-): MySqlTextBuilderInitial<TName, Writable<T>>;
+): MySqlTextBuilder<Writable<T>>;
 export function longtext(a?: string | MySqlTextConfig, b: MySqlTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<MySqlTextConfig>(a, b);
 	return new MySqlTextBuilder(name, 'longtext', config as any);
diff --git a/drizzle-orm/src/mysql-core/columns/time.ts b/drizzle-orm/src/mysql-core/columns/time.ts
index 7ca5426ec5..34310e1084 100644
--- a/drizzle-orm/src/mysql-core/columns/time.ts
+++ b/drizzle-orm/src/mysql-core/columns/time.ts
@@ -1,46 +1,41 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlTimeBuilderInitial<TName extends string> = MySqlTimeBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlTime';
-	data: string;
-	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlTime'>> extends MySqlColumnBuilder<
-	T,
+export class MySqlTimeBuilder extends MySqlColumnBuilder<
+	{
+		dataType: 'string time';
+		data: string;
+		driverParam: string | number;
+	},
 	TimeConfig
 > {
 	static override readonly [entityKind]: string = 'MySqlTimeBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		config: TimeConfig | undefined,
 	) {
-		super(name, 'string', 'MySqlTime');
+		super(name, 'string time', 'MySqlTime');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTime<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTime<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlTime(table, this.config as any);
 	}
 }
 
 export class MySqlTime<
-	T extends ColumnBaseConfig<'string', 'MySqlTime'>,
+	T extends ColumnBaseConfig<'string time'>,
 > extends MySqlColumn<T, TimeConfig> {
 	static override readonly [entityKind]: string = 'MySqlTime';
 
+	/** @internal */
+	override readonly codec = 'time';
+
 	readonly fsp: number | undefined = this.config.fsp;
 
 	getSQLType(): string {
@@ -53,14 +48,13 @@ export type TimeConfig = {
 	fsp?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
 };
 
-export function time(): MySqlTimeBuilderInitial<''>;
 export function time(
 	config?: TimeConfig,
-): MySqlTimeBuilderInitial<''>;
-export function time<TName extends string>(
-	name: TName,
+): MySqlTimeBuilder;
+export function time(
+	name: string,
 	config?: TimeConfig,
-): MySqlTimeBuilderInitial<TName>;
+): MySqlTimeBuilder;
 export function time(a?: string | TimeConfig, b?: TimeConfig) {
 	const { name, config } = getColumnNameAndConfig<TimeConfig>(a, b);
 	return new MySqlTimeBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/timestamp.ts b/drizzle-orm/src/mysql-core/columns/timestamp.ts
index 2ccc2925f4..d06a321f44 100644
--- a/drizzle-orm/src/mysql-core/columns/timestamp.ts
+++ b/drizzle-orm/src/mysql-core/columns/timestamp.ts
@@ -1,45 +1,38 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlDateBaseColumn, MySqlDateColumnBaseBuilder } from './date.common.ts';
 
-export type MySqlTimestampBuilderInitial<TName extends string> = MySqlTimestampBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'MySqlTimestamp';
+export class MySqlTimestampBuilder extends MySqlDateColumnBaseBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlTimestamp'>>
-	extends MySqlDateColumnBaseBuilder<T, MySqlTimestampConfig>
-{
+}, MySqlTimestampConfig> {
 	static override readonly [entityKind]: string = 'MySqlTimestampBuilder';
 
-	constructor(name: T['name'], config: MySqlTimestampConfig | undefined) {
-		super(name, 'date', 'MySqlTimestamp');
+	constructor(name: string, config: MySqlTimestampConfig | undefined) {
+		super(name, 'object date', 'MySqlTimestamp');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTimestamp<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlTimestamp(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlTimestamp<T extends ColumnBaseConfig<'date', 'MySqlTimestamp'>>
+export class MySqlTimestamp<T extends ColumnBaseConfig<'object date'>>
 	extends MySqlDateBaseColumn<T, MySqlTimestampConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlTimestamp';
 
+	/** @internal */
+	override readonly codec = 'timestamp';
+
 	readonly fsp: number | undefined = this.config.fsp;
 
 	getSQLType(): string {
@@ -47,56 +40,52 @@ export class MySqlTimestamp<T extends ColumnBaseConfig<'date', 'MySqlTimestamp'>
 		return `timestamp${precision}`;
 	}
 
-	override mapFromDriverValue(value: string): Date {
-		return new Date(value + '+0000');
-	}
-
-	override mapToDriverValue(value: Date): string {
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
 		return value.toISOString().slice(0, -1).replace('T', ' ');
-	}
+	};
 }
 
-export type MySqlTimestampStringBuilderInitial<TName extends string> = MySqlTimestampStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlTimestampString';
+export class MySqlTimestampStringBuilder extends MySqlDateColumnBaseBuilder<{
+	dataType: 'string timestamp';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class MySqlTimestampStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlTimestampString'>>
-	extends MySqlDateColumnBaseBuilder<T, MySqlTimestampConfig>
-{
+}, MySqlTimestampConfig> {
 	static override readonly [entityKind]: string = 'MySqlTimestampStringBuilder';
 
-	constructor(name: T['name'], config: MySqlTimestampConfig | undefined) {
-		super(name, 'string', 'MySqlTimestampString');
+	constructor(name: string, config: MySqlTimestampConfig | undefined) {
+		super(name, 'string timestamp', 'MySqlTimestampString');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTimestampString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTimestampString<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlTimestampString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlTimestampString<T extends ColumnBaseConfig<'string', 'MySqlTimestampString'>>
+export class MySqlTimestampString<T extends ColumnBaseConfig<'string timestamp'>>
 	extends MySqlDateBaseColumn<T, MySqlTimestampConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlTimestampString';
 
+	/** @internal */
+	override readonly codec = 'timestamp:string';
+
 	readonly fsp: number | undefined = this.config.fsp;
 
 	getSQLType(): string {
 		const precision = this.fsp === undefined ? '' : `(${this.fsp})`;
 		return `timestamp${precision}`;
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString().slice(0, -1).replace('T', ' ');
+	};
 }
 
 export type TimestampFsp = 0 | 1 | 2 | 3 | 4 | 5 | 6;
@@ -106,16 +95,15 @@ export interface MySqlTimestampConfig<TMode extends 'string' | 'date' = 'string'
 	fsp?: TimestampFsp;
 }
 
-export function timestamp(): MySqlTimestampBuilderInitial<''>;
 export function timestamp<TMode extends MySqlTimestampConfig['mode'] & {}>(
 	config?: MySqlTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlTimestampStringBuilderInitial<''>
-	: MySqlTimestampBuilderInitial<''>;
-export function timestamp<TName extends string, TMode extends MySqlTimestampConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? MySqlTimestampStringBuilder
+	: MySqlTimestampBuilder;
+export function timestamp<TMode extends MySqlTimestampConfig['mode'] & {}>(
+	name: string,
 	config?: MySqlTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlTimestampStringBuilderInitial<TName>
-	: MySqlTimestampBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? MySqlTimestampStringBuilder
+	: MySqlTimestampBuilder;
 export function timestamp(a?: string | MySqlTimestampConfig, b: MySqlTimestampConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<MySqlTimestampConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/mysql-core/columns/tinyint.ts b/drizzle-orm/src/mysql-core/columns/tinyint.ts
index 890f169bd4..a8819cefb9 100644
--- a/drizzle-orm/src/mysql-core/columns/tinyint.ts
+++ b/drizzle-orm/src/mysql-core/columns/tinyint.ts
@@ -1,66 +1,51 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
 import type { MySqlIntConfig } from './int.ts';
 
-export type MySqlTinyIntBuilderInitial<TName extends string> = MySqlTinyIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlTinyInt';
+export class MySqlTinyIntBuilder<TUnsigned extends boolean | undefined> extends MySqlColumnBuilderWithAutoIncrement<{
+	dataType: Equal<TUnsigned, true> extends true ? 'number uint8' : 'number int8';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class MySqlTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlTinyInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
-{
+}, MySqlIntConfig> {
 	static override readonly [entityKind]: string = 'MySqlTinyIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlTinyInt');
+	constructor(name: string, config?: MySqlIntConfig) {
+		super(name, config?.unsigned ? 'number uint8' : 'number int8' as any, 'MySqlTinyInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTinyInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTinyInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlTinyInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlTinyInt<T extends ColumnBaseConfig<'number', 'MySqlTinyInt'>>
+export class MySqlTinyInt<T extends ColumnBaseConfig<'number int8' | 'number uint8'>>
 	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static override readonly [entityKind]: string = 'MySqlTinyInt';
 
+	/** @internal */
+	override readonly codec = 'tinyint';
+
 	getSQLType(): string {
 		return `tinyint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	}
 }
 
-export function tinyint(): MySqlTinyIntBuilderInitial<''>;
-export function tinyint(
-	config?: MySqlIntConfig,
-): MySqlTinyIntBuilderInitial<''>;
-export function tinyint<TName extends string>(
-	name: TName,
-	config?: MySqlIntConfig,
-): MySqlTinyIntBuilderInitial<TName>;
+export function tinyint<TUnsigned extends boolean | undefined>(
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlTinyIntBuilder<TUnsigned>;
+export function tinyint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: MySqlIntConfig<TUnsigned>,
+): MySqlTinyIntBuilder<TUnsigned>;
 export function tinyint(a?: string | MySqlIntConfig, b?: MySqlIntConfig) {
 	const { name, config } = getColumnNameAndConfig<MySqlIntConfig>(a, b);
 	return new MySqlTinyIntBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/varbinary.ts b/drizzle-orm/src/mysql-core/columns/varbinary.ts
index 25b6864031..7fbd27fd7c 100644
--- a/drizzle-orm/src/mysql-core/columns/varbinary.ts
+++ b/drizzle-orm/src/mysql-core/columns/varbinary.ts
@@ -1,59 +1,38 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlVarBinaryBuilderInitial<TName extends string> = MySqlVarBinaryBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlVarBinary';
+export class MySqlVarBinaryBuilder extends MySqlColumnBuilder<{
+	dataType: 'string binary';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class MySqlVarBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlVarBinary'>>
-	extends MySqlColumnBuilder<T, MySqlVarbinaryOptions>
-{
+}, MySqlVarbinaryOptions> {
 	static override readonly [entityKind]: string = 'MySqlVarBinaryBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: MySqlVarbinaryOptions) {
-		super(name, 'string', 'MySqlVarBinary');
-		this.config.length = config?.length;
+	constructor(name: string, config: MySqlVarbinaryOptions) {
+		super(name, 'string binary', 'MySqlVarBinary');
+		this.config.length = config.length;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlVarBinary<MakeColumnConfig<T, TTableName>> {
-		return new MySqlVarBinary<MakeColumnConfig<T, TTableName>>(
+	override build(table: MySqlTable) {
+		return new MySqlVarBinary(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class MySqlVarBinary<
-	T extends ColumnBaseConfig<'string', 'MySqlVarBinary'>,
+	T extends ColumnBaseConfig<'string binary'>,
 > extends MySqlColumn<T, MySqlVarbinaryOptions> {
 	static override readonly [entityKind]: string = 'MySqlVarBinary';
 
-	length: number | undefined = this.config.length;
-
-	override mapFromDriverValue(value: string | Buffer | Uint8Array): string {
-		if (typeof value === 'string') return value;
-		if (Buffer.isBuffer(value)) return value.toString();
-
-		const str: string[] = [];
-		for (const v of value) {
-			str.push(v === 49 ? '1' : '0');
-		}
-
-		return str.join('');
-	}
+	/** @internal */
+	override readonly codec = 'varbinary';
 
 	getSQLType(): string {
 		return this.length === undefined ? `varbinary` : `varbinary(${this.length})`;
@@ -66,11 +45,11 @@ export interface MySqlVarbinaryOptions {
 
 export function varbinary(
 	config: MySqlVarbinaryOptions,
-): MySqlVarBinaryBuilderInitial<''>;
-export function varbinary<TName extends string>(
-	name: TName,
+): MySqlVarBinaryBuilder;
+export function varbinary(
+	name: string,
 	config: MySqlVarbinaryOptions,
-): MySqlVarBinaryBuilderInitial<TName>;
+): MySqlVarBinaryBuilder;
 export function varbinary(a?: string | MySqlVarbinaryOptions, b?: MySqlVarbinaryOptions) {
 	const { name, config } = getColumnNameAndConfig<MySqlVarbinaryOptions>(a, b);
 	return new MySqlVarBinaryBuilder(name, config);
diff --git a/drizzle-orm/src/mysql-core/columns/varchar.ts b/drizzle-orm/src/mysql-core/columns/varchar.ts
index 0a47071f9a..0477caa3ba 100644
--- a/drizzle-orm/src/mysql-core/columns/varchar.ts
+++ b/drizzle-orm/src/mysql-core/columns/varchar.ts
@@ -1,84 +1,68 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
-
-export type MySqlVarCharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = MySqlVarCharBuilder<
-	{
-		name: TName;
-		dataType: 'string';
-		columnType: 'MySqlVarChar';
-		data: TEnum[number];
-		driverParam: number | string;
-		enumValues: TEnum;
-		length: TLength;
-	}
->;
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import { MySqlStringBaseColumn, MySqlStringColumnBaseBuilder } from './string.common.ts';
 
 export class MySqlVarCharBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'MySqlVarChar'> & { length?: number | undefined },
-> extends MySqlColumnBuilder<T, MySqlVarCharConfig<T['enumValues'], T['length']>> {
+	TEnum extends [string, ...string[]],
+> extends MySqlStringColumnBaseBuilder<{
+	dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+	data: TEnum[number];
+	driverParam: number | string;
+	enumValues: TEnum;
+}, MySqlVarCharConfig<TEnum>> {
 	static override readonly [entityKind]: string = 'MySqlVarCharBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: MySqlVarCharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'MySqlVarChar');
+	constructor(name: string, config: MySqlVarCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'MySqlVarChar');
 		this.config.length = config.length;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlVarChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }> {
-		return new MySqlVarChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }>(
+	override build(table: MySqlTable) {
+		return new MySqlVarChar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class MySqlVarChar<T extends ColumnBaseConfig<'string', 'MySqlVarChar'> & { length?: number | undefined }>
-	extends MySqlColumn<T, MySqlVarCharConfig<T['enumValues'], T['length']>, { length: T['length'] }>
-{
+export class MySqlVarChar<
+	T extends ColumnBaseConfig<'string' | 'string enum'> & { length: number },
+> extends MySqlStringBaseColumn<T, MySqlVarCharConfig<T['enumValues']>> {
 	static override readonly [entityKind]: string = 'MySqlVarChar';
 
-	readonly length: number | undefined = this.config.length;
+	/** @internal */
+	override readonly codec = 'varchar';
 
 	override readonly enumValues = this.config.enum;
 
 	getSQLType(): string {
-		return this.length === undefined ? `varchar` : `varchar(${this.length})`;
+		return `varchar(${this.length})`;
 	}
 }
 
 export interface MySqlVarCharConfig<
 	TEnum extends string[] | readonly string[] | undefined = string[] | readonly string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length: TLength;
+	length: number;
 }
 
-export function varchar<U extends string, T extends Readonly<[U, ...U[]]>, L extends number | undefined>(
-	config: MySqlVarCharConfig<T | Writable<T>, L>,
-): MySqlVarCharBuilderInitial<'', Writable<T>, L>;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config: MySqlVarCharConfig<T | Writable<T>>,
+): MySqlVarCharBuilder<Writable<T>>;
 export function varchar<
-	TName extends string,
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 >(
-	name: TName,
-	config: MySqlVarCharConfig<T | Writable<T>, L>,
-): MySqlVarCharBuilderInitial<TName, Writable<T>, L>;
-export function varchar(a?: string | MySqlVarCharConfig, b?: MySqlVarCharConfig): any {
+	name: string,
+	config: MySqlVarCharConfig<T | Writable<T>>,
+): MySqlVarCharBuilder<Writable<T>>;
+export function varchar(a: string | MySqlVarCharConfig, b?: MySqlVarCharConfig): any {
 	const { name, config } = getColumnNameAndConfig<MySqlVarCharConfig>(a, b);
 	return new MySqlVarCharBuilder(name, config as any);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/year.ts b/drizzle-orm/src/mysql-core/columns/year.ts
index 4e4ae4faf4..f3c94f6ee8 100644
--- a/drizzle-orm/src/mysql-core/columns/year.ts
+++ b/drizzle-orm/src/mysql-core/columns/year.ts
@@ -1,45 +1,38 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
-export type MySqlYearBuilderInitial<TName extends string> = MySqlYearBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'MySqlYear';
+export class MySqlYearBuilder extends MySqlColumnBuilder<{
+	dataType: 'number year';
 	data: number;
 	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class MySqlYearBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlYear'>> extends MySqlColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'MySqlYearBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'MySqlYear');
+	constructor(name: string) {
+		super(name, 'number year', 'MySqlYear');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlYear<MakeColumnConfig<T, TTableName>> {
-		return new MySqlYear<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: MySqlTable) {
+		return new MySqlYear(table, this.config as any);
 	}
 }
 
 export class MySqlYear<
-	T extends ColumnBaseConfig<'number', 'MySqlYear'>,
+	T extends ColumnBaseConfig<'number year'>,
 > extends MySqlColumn<T> {
 	static override readonly [entityKind]: string = 'MySqlYear';
 
+	/** @internal */
+	override readonly codec = 'year';
+
 	getSQLType(): string {
 		return `year`;
 	}
 }
 
-export function year(): MySqlYearBuilderInitial<''>;
-export function year<TName extends string>(name: TName): MySqlYearBuilderInitial<TName>;
-export function year(name?: string) {
+export function year(name?: string): MySqlYearBuilder {
 	return new MySqlYearBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
deleted file mode 100644
index 78cd86a599..0000000000
--- a/drizzle-orm/src/mysql-core/db.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-import type { ResultSetHeader } from 'mysql2/promise';
-import type { Cache } from '~/cache/core/cache.ts';
-import { entityKind } from '~/entity.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import { WithSubquery } from '~/subquery.ts';
-import type { DrizzleTypeError } from '~/utils.ts';
-import type { MySqlDialect } from './dialect.ts';
-import { MySqlCountBuilder } from './query-builders/count.ts';
-import {
-	MySqlDeleteBase,
-	MySqlInsertBuilder,
-	MySqlSelectBuilder,
-	MySqlUpdateBuilder,
-	QueryBuilder,
-} from './query-builders/index.ts';
-import { RelationalQueryBuilder } from './query-builders/query.ts';
-import type { SelectedFields } from './query-builders/select.types.ts';
-import type {
-	Mode,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
-	MySqlTransaction,
-	MySqlTransactionConfig,
-	PreparedQueryHKTBase,
-} from './session.ts';
-import type { WithBuilder } from './subquery.ts';
-import type { MySqlTable } from './table.ts';
-import type { MySqlViewBase } from './view-base.ts';
-
-export class MySqlDatabase<
-	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TFullSchema extends Record<string, unknown> = {},
-	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
-> {
-	static readonly [entityKind]: string = 'MySqlDatabase';
-
-	declare readonly _: {
-		readonly schema: TSchema | undefined;
-		readonly fullSchema: TFullSchema;
-		readonly tableNamesMap: Record<string, string>;
-	};
-
-	query: TFullSchema extends Record<string, never>
-		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
-		: {
-			[K in keyof TSchema]: RelationalQueryBuilder<TPreparedQueryHKT, TSchema, TSchema[K]>;
-		};
-
-	constructor(
-		/** @internal */
-		readonly dialect: MySqlDialect,
-		/** @internal */
-		readonly session: MySqlSession<any, any, any, any>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
-		protected readonly mode: Mode,
-	) {
-		this._ = schema
-			? {
-				schema: schema.schema,
-				fullSchema: schema.fullSchema as TFullSchema,
-				tableNamesMap: schema.tableNamesMap,
-			}
-			: {
-				schema: undefined,
-				fullSchema: {} as TFullSchema,
-				tableNamesMap: {},
-			};
-		this.query = {} as typeof this['query'];
-		if (this._.schema) {
-			for (const [tableName, columns] of Object.entries(this._.schema)) {
-				(this.query as MySqlDatabase<TQueryResult, TPreparedQueryHKT, Record<string, any>>['query'])[tableName] =
-					new RelationalQueryBuilder(
-						schema!.fullSchema,
-						this._.schema,
-						this._.tableNamesMap,
-						schema!.fullSchema[tableName] as MySqlTable,
-						columns,
-						dialect,
-						session,
-						this.mode,
-					);
-			}
-		}
-		this.$cache = { invalidate: async (_params: any) => {} };
-	}
-
-	/**
-	 * Creates a subquery that defines a temporary named result set as a CTE.
-	 *
-	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param alias The alias for the subquery.
-	 *
-	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Create a subquery with alias 'sq' and use it in the select query
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 *
-	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
-	 *
-	 * ```ts
-	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
-	 * const sq = db.$with('sq').as(db.select({
-	 *   name: sql<string>`upper(${users.name})`.as('name'),
-	 * })
-	 * .from(users));
-	 *
-	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
-	 * ```
-	 */
-	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
-		const self = this;
-		const as = (
-			qb:
-				| TypedQueryBuilder<ColumnsSelection | undefined>
-				| SQL
-				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
-		) => {
-			if (typeof qb === 'function') {
-				qb = qb(new QueryBuilder(self.dialect));
-			}
-
-			return new Proxy(
-				new WithSubquery(
-					qb.getSQL(),
-					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
-					alias,
-					true,
-				),
-				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-			);
-		};
-		return { as };
-	};
-
-	$count(
-		source: MySqlTable | MySqlViewBase | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	) {
-		return new MySqlCountBuilder({ source, filters, session: this.session });
-	}
-
-	$cache: { invalidate: Cache['onMutate'] };
-
-	/**
-	 * Incorporates a previously defined CTE (using `$with`) into the main query.
-	 *
-	 * This method allows the main query to reference a temporary named result set.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param queries The CTEs to incorporate into the main query.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Define a subquery 'sq' as a CTE using $with
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * // Incorporate the CTE 'sq' into the main query and select from it
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 */
-	with(...queries: WithSubquery[]) {
-		const self = this;
-
-		/**
-		 * Creates a select query.
-		 *
-		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Select all columns and all rows from the 'cars' table
-		 * const allCars: Car[] = await db.select().from(cars);
-		 *
-		 * // Select specific columns and all rows from the 'cars' table
-		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   brand: cars.brand
-		 * })
-		 *   .from(cars);
-		 * ```
-		 *
-		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-		 *
-		 * ```ts
-		 * // Select specific columns along with expression and all rows from the 'cars' table
-		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-		 * })
-		 *   .from(cars);
-		 * ```
-		 */
-		function select(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
-		function select<TSelection extends SelectedFields>(
-			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-		function select(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-			return new MySqlSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-			});
-		}
-
-		/**
-		 * Adds `distinct` expression to the select query.
-		 *
-		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 * ```ts
-		 * // Select all unique rows from the 'cars' table
-		 * await db.selectDistinct()
-		 *   .from(cars)
-		 *   .orderBy(cars.id, cars.brand, cars.color);
-		 *
-		 * // Select all unique brands from the 'cars' table
-		 * await db.selectDistinct({ brand: cars.brand })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 * ```
-		 */
-		function selectDistinct(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
-		function selectDistinct<TSelection extends SelectedFields>(
-			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-		function selectDistinct(
-			fields?: SelectedFields,
-		): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-			return new MySqlSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: true,
-			});
-		}
-
-		/**
-		 * Creates an update query.
-		 *
-		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-		 *
-		 * Use `.set()` method to specify which values to update.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/update}
-		 *
-		 * @param table The table to update.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Update all rows in the 'cars' table
-		 * await db.update(cars).set({ color: 'red' });
-		 *
-		 * // Update rows with filters and conditions
-		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-		 * ```
-		 */
-		function update<TTable extends MySqlTable>(
-			table: TTable,
-		): MySqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-			return new MySqlUpdateBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates a delete query.
-		 *
-		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/delete}
-		 *
-		 * @param table The table to delete from.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Delete all rows in the 'cars' table
-		 * await db.delete(cars);
-		 *
-		 * // Delete rows with filters and conditions
-		 * await db.delete(cars).where(eq(cars.color, 'green'));
-		 * ```
-		 */
-		function delete_<TTable extends MySqlTable>(
-			table: TTable,
-		): MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
-			return new MySqlDeleteBase(table, self.session, self.dialect, queries);
-		}
-
-		return { select, selectDistinct, update, delete: delete_ };
-	}
-
-	/**
-	 * Creates a select query.
-	 *
-	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all columns and all rows from the 'cars' table
-	 * const allCars: Car[] = await db.select().from(cars);
-	 *
-	 * // Select specific columns and all rows from the 'cars' table
-	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   brand: cars.brand
-	 * })
-	 *   .from(cars);
-	 * ```
-	 *
-	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-	 *
-	 * ```ts
-	 * // Select specific columns along with expression and all rows from the 'cars' table
-	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-	 * })
-	 *   .from(cars);
-	 * ```
-	 */
-	select(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
-	select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-	select(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-		return new MySqlSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
-	}
-
-	/**
-	 * Adds `distinct` expression to the select query.
-	 *
-	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 * ```ts
-	 * // Select all unique rows from the 'cars' table
-	 * await db.selectDistinct()
-	 *   .from(cars)
-	 *   .orderBy(cars.id, cars.brand, cars.color);
-	 *
-	 * // Select all unique brands from the 'cars' table
-	 * await db.selectDistinct({ brand: cars.brand })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 * ```
-	 */
-	selectDistinct(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
-	selectDistinct<TSelection extends SelectedFields>(
-		fields: TSelection,
-	): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-	selectDistinct(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-		return new MySqlSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: true,
-		});
-	}
-
-	/**
-	 * Creates an update query.
-	 *
-	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-	 *
-	 * Use `.set()` method to specify which values to update.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update}
-	 *
-	 * @param table The table to update.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Update all rows in the 'cars' table
-	 * await db.update(cars).set({ color: 'red' });
-	 *
-	 * // Update rows with filters and conditions
-	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-	 * ```
-	 */
-	update<TTable extends MySqlTable>(table: TTable): MySqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlUpdateBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates an insert query.
-	 *
-	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert}
-	 *
-	 * @param table The table to insert into.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Insert one row
-	 * await db.insert(cars).values({ brand: 'BMW' });
-	 *
-	 * // Insert multiple rows
-	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-	 * ```
-	 */
-	insert<TTable extends MySqlTable>(table: TTable): MySqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlInsertBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates a delete query.
-	 *
-	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete}
-	 *
-	 * @param table The table to delete from.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Delete all rows in the 'cars' table
-	 * await db.delete(cars);
-	 *
-	 * // Delete rows with filters and conditions
-	 * await db.delete(cars).where(eq(cars.color, 'green'));
-	 * ```
-	 */
-	delete<TTable extends MySqlTable>(table: TTable): MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlDeleteBase(table, this.session, this.dialect);
-	}
-
-	execute<T extends { [column: string]: any } = ResultSetHeader>(
-		query: SQLWrapper | string,
-	): Promise<MySqlQueryResultKind<TQueryResult, T>> {
-		return this.session.execute(typeof query === 'string' ? sql.raw(query) : query.getSQL());
-	}
-
-	transaction<T>(
-		transaction: (
-			tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>,
-			config?: MySqlTransactionConfig,
-		) => Promise<T>,
-		config?: MySqlTransactionConfig,
-	): Promise<T> {
-		return this.session.transaction(transaction, config);
-	}
-}
-
-export type MySQLWithReplicas<Q> = Q & { $primary: Q };
-
-export const withReplicas = <
-	HKT extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-	Q extends MySqlDatabase<
-		HKT,
-		TPreparedQueryHKT,
-		TFullSchema,
-		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
-	>,
->(
-	primary: Q,
-	replicas: [Q, ...Q[]],
-	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
-): MySQLWithReplicas<Q> => {
-	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
-	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
-	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
-	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
-
-	const update: Q['update'] = (...args: [any]) => primary.update(...args);
-	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
-	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
-	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
-	const transaction: Q['transaction'] = (...args: [any, any]) => primary.transaction(...args);
-
-	return {
-		...primary,
-		update,
-		insert,
-		delete: $delete,
-		execute,
-		transaction,
-		$primary: primary,
-		select,
-		selectDistinct,
-		$count,
-		with: $with,
-		get query() {
-			return getReplica(replicas).query;
-		},
-	};
-};
diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 0014dd303f..151a52fa3a 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -1,98 +1,101 @@
-import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from '~/alias.ts';
-import { CasingCache } from '~/casing.ts';
+import { aliasedTable, getOriginalColumnFromAlias } from '~/alias.ts';
+import { CodecsCollection } from '~/codecs.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import { DrizzleError } from '~/errors.ts';
-import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	AnyOne,
+	BuildRelationalQueryResult,
+	DBQueryConfigWithComment,
+	Relation,
+	RelationalRowsMapperGenerator,
+	TableRelationalConfig,
+	TablesRelationalConfig,
+	WithContainer,
+} from '~/relations.ts';
 import {
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	getOperators,
-	getOrderByOperators,
-	Many,
-	normalizeRelation,
+	// AggregatedField,
+	getTableAsAliasSQL,
+	makeDefaultRqbMapper,
+	makeJitRqbMapper,
 	One,
-	type Relation,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
+	relationExtrasToSQL,
+	relationsFilterToSQL,
+	relationsOrderToSQL,
+	relationToSQL,
 } from '~/relations.ts';
-import { and, eq } from '~/sql/expressions/index.ts';
-import { Param, SQL, sql, View } from '~/sql/sql.ts';
-import type { Name, Placeholder, QueryWithTypings, SQLChunk } from '~/sql/sql.ts';
+import { and } from '~/sql/expressions/index.ts';
+import { isSQLWrapper, noopEncoder, Param, SQL, sql, View } from '~/sql/sql.ts';
+import type { DriverValueEncoder, Name, Placeholder, Query, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
-import { getTableName, getTableUniqueName, Table } from '~/table.ts';
-import { type Casing, orderSelectedFields, type UpdateSet } from '~/utils.ts';
+import { getTableName, Table, TableColumns } from '~/table.ts';
+import {
+	getColumnFromDecoder,
+	make$ReturningResponseMapper,
+	makeDefaultQueryMapper,
+	makeJitQueryMapper,
+	orderSelectedFields,
+	type RowsMapperGenerator,
+	type UpdateSet,
+} from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
+import { type MySqlCodecs, type MySqlType, resolveMySqlTypeAlias, unionsTypeTable } from './codecs.ts';
 import { MySqlColumn } from './columns/common.ts';
+import type { MySqlCustomColumn } from './columns/custom.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
 import type {
 	AnyMySqlSelectQueryBuilder,
 	MySqlSelectConfig,
-	MySqlSelectJoinConfig,
 	SelectedFieldsOrdered,
 } from './query-builders/select.types.ts';
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
-import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
 import { MySqlViewBase } from './view-base.ts';
+import type { MySqlView } from './view.ts';
 
 export interface MySqlDialectConfig {
-	casing?: Casing;
+	escapeParam?: (num: number) => string;
+	codecs?: MySqlCodecs;
+	useJitMappers?: boolean;
+	/** Resolves mysql binary protocol bug that rejects numbers in pagination */
+	paginationToBigint?: boolean;
 }
 
 export class MySqlDialect {
 	static readonly [entityKind]: string = 'MySqlDialect';
 
-	/** @internal */
-	readonly casing: CasingCache;
+	readonly codecs: CodecsCollection<MySqlType>;
+	readonly mapperGenerators: {
+		rows: RowsMapperGenerator;
+		relationalRows: RelationalRowsMapperGenerator;
+		$returning: typeof make$ReturningResponseMapper; // TODO: jit ver
+	};
+	readonly paginationEncoder: DriverValueEncoder<any, any>;
 
 	constructor(config?: MySqlDialectConfig) {
-		this.casing = new CasingCache(config?.casing);
-	}
-
-	async migrate(
-		migrations: MigrationMeta[],
-		session: MySqlSession,
-		config: Omit<MigrationConfig, 'migrationsSchema'>,
-	): Promise<void> {
-		const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
-		const migrationTableCreate = sql`
-			create table if not exists ${sql.identifier(migrationsTable)} (
-				id serial primary key,
-				hash text not null,
-				created_at bigint
-			)
-		`;
-		await session.execute(migrationTableCreate);
-
-		const dbMigrations = await session.all<{ id: number; hash: string; created_at: string }>(
-			sql`select id, hash, created_at from ${sql.identifier(migrationsTable)} order by created_at desc limit 1`,
-		);
-
-		const lastDbMigration = dbMigrations[0];
+		if (config?.escapeParam) {
+			this.escapeParam = config.escapeParam;
+		}
 
-		await session.transaction(async (tx) => {
-			for (const migration of migrations) {
-				if (
-					!lastDbMigration
-					|| Number(lastDbMigration.created_at) < migration.folderMillis
-				) {
-					for (const stmt of migration.sql) {
-						await tx.execute(sql.raw(stmt));
-					}
-					await tx.execute(
-						sql`insert into ${
-							sql.identifier(migrationsTable)
-						} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`,
-					);
-				}
+		this.codecs = new CodecsCollection<MySqlType>(resolveMySqlTypeAlias, config?.codecs);
+		this.mapperGenerators = config?.useJitMappers
+			? {
+				rows: makeJitQueryMapper,
+				relationalRows: makeJitRqbMapper,
+				$returning: make$ReturningResponseMapper,
 			}
-		});
+			: {
+				rows: makeDefaultQueryMapper,
+				relationalRows: makeDefaultRqbMapper,
+				$returning: make$ReturningResponseMapper,
+			};
+		this.paginationEncoder = config?.paginationToBigint ? { mapToDriverValue: BigInt } : noopEncoder;
 	}
 
 	escapeName(name: string): string {
-		return `\`${name}\``;
+		return `\`${name.replace(/`/g, '``')}\``;
 	}
 
 	escapeParam(_num: number): string {
@@ -117,59 +120,78 @@ export class MySqlDialect {
 		return sql.join(withSqlChunks);
 	}
 
-	buildDeleteQuery({ table, where, returning, withList, limit, orderBy }: MySqlDeleteConfig): SQL {
+	buildDeleteQuery({
+		table,
+		where,
+		withList,
+		limit,
+		orderBy,
+		comment,
+	}: MySqlDeleteConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
-		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
-			: undefined;
-
 		const whereSql = where ? sql` where ${where}` : undefined;
 
 		const orderBySql = this.buildOrderBy(orderBy);
 
 		const limitSql = this.buildLimit(limit);
 
-		return sql`${withSql}delete from ${table}${whereSql}${orderBySql}${limitSql}${returningSql}`;
+		return sql`${withSql}delete from ${table}${whereSql}${orderBySql}${limitSql}${
+			comment !== undefined ? sql` ${comment}` : undefined
+		}`;
 	}
 
 	buildUpdateSet(table: MySqlTable, set: UpdateSet): SQL {
 		const tableColumns = table[Table.Symbol.Columns];
 
-		const columnNames = Object.keys(tableColumns).filter((colName) =>
-			set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
 		);
 
-		const setSize = columnNames.length;
-		return sql.join(columnNames.flatMap((colName, i) => {
-			const col = tableColumns[colName]!;
+		const setLength = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
 
-			const value = set[colName] ?? sql.param(col.onUpdateFn!(), col);
-			const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
 
-			if (i < setSize - 1) {
-				return [res, sql.raw(', ')];
-			}
-			return [res];
-		}));
+				if (i < setLength - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
 	}
 
-	buildUpdateQuery({ table, set, where, returning, withList, limit, orderBy }: MySqlUpdateConfig): SQL {
+	buildUpdateQuery({
+		table,
+		set,
+		where,
+		withList,
+		limit,
+		orderBy,
+		comment,
+	}: MySqlUpdateConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const setSql = this.buildUpdateSet(table, set);
 
-		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
-			: undefined;
-
 		const whereSql = where ? sql` where ${where}` : undefined;
 
 		const orderBySql = this.buildOrderBy(orderBy);
 
 		const limitSql = this.buildLimit(limit);
 
-		return sql`${withSql}update ${table} set ${setSql}${whereSql}${orderBySql}${limitSql}${returningSql}`;
+		return sql`${withSql}update ${table} set ${setSql}${whereSql}${orderBySql}${limitSql}${
+			comment !== undefined ? sql` ${comment}` : undefined
+		}`;
 	}
 
 	/**
@@ -179,69 +201,109 @@ export class MySqlDialect {
 	 *
 	 * `select <selection> from`
 	 *
-	 * `insert ... returning <selection>`
-	 *
 	 * If `isSingleTable` is true, then columns won't be prefixed with table name
 	 */
 	private buildSelection(
 		fields: SelectedFieldsOrdered,
-		{ isSingleTable = false }: { isSingleTable?: boolean } = {},
+		{ isSingleTable = false, ignoreCastCodecs = false }: { isSingleTable?: boolean; ignoreCastCodecs?: boolean } = {},
 	): SQL {
 		const columnsLen = fields.length;
 
-		const chunks = fields
-			.flatMap(({ field }, i) => {
-				const chunk: SQLChunk[] = [];
-
-				if (is(field, SQL.Aliased) && field.isSelectionField) {
-					chunk.push(sql.identifier(field.fieldAlias));
-				} else if (is(field, SQL.Aliased) || is(field, SQL)) {
-					const query = is(field, SQL.Aliased) ? field.sql : field;
+		const chunks = fields.flatMap(({ field, codecOverride, column }, i) => {
+			const chunk: SQLChunk[] = [];
+			const override = codecOverride as MySqlType | undefined;
+
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					const query = !isSingleTable && field.origin !== undefined
+						? sql`${sql.identifier(field.origin)}.${sql.identifier(field.fieldAlias)}`
+						: sql.identifier(field.fieldAlias);
+					if (column && !ignoreCastCodecs) chunk.push(this.codecs.apply(column, 'cast', query, override));
+					else chunk.push(query);
+				} else {
+					const query = field.sql;
 
 					if (isSingleTable) {
-						chunk.push(
-							new SQL(
-								query.queryChunks.map((c) => {
-									if (is(c, MySqlColumn)) {
-										return sql.identifier(this.casing.getColumnCasing(c));
-									}
-									return c;
-								}),
-							),
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, MySqlColumn)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
 						);
-					} else {
-						chunk.push(query);
-					}
 
-					if (is(field, SQL.Aliased)) {
-						chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-					}
-				} else if (is(field, Column)) {
-					if (isSingleTable) {
-						chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
+						if (query.shouldInlineParams) newSql.inlineParams();
+						chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', newSql, override) : newSql);
 					} else {
-						chunk.push(field);
+						chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', query, override) : query);
 					}
+
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
 				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, MySqlColumn)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
 
-				if (i < columnsLen - 1) {
-					chunk.push(sql`, `);
+					if (query.shouldInlineParams) newSql.inlineParams();
+					chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', newSql, override) : newSql);
+				} else {
+					chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', query, override) : query);
+				}
+			} else if (is(field, Column)) {
+				let name: Name | Column;
+				if (isSingleTable) {
+					name = field.isAlias
+						? sql.identifier(getOriginalColumnFromAlias(field).name)
+						: sql.identifier(field.name);
+				} else {
+					name = field.isAlias ? getOriginalColumnFromAlias(field) : field;
 				}
 
-				return chunk;
-			});
+				const casted = ignoreCastCodecs ? name : this.codecs.apply(field, 'cast', name, override);
+				chunk.push(field.isAlias ? sql`${casted} as ${field}` : casted);
+			} else if (is(field, Subquery)) {
+				if (column && !ignoreCastCodecs && !field._.isWith) {
+					const innerCasted = this.codecs.apply(column, 'cast', sql`(${field._.sql})`, override);
+					chunk.push(sql`${innerCasted} ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(column ? this.codecs.apply(column, 'cast', field) : field, override);
+				}
+			}
+
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
 
 		return sql.join(chunks);
 	}
 
 	private buildLimit(limit: number | Placeholder | undefined): SQL | undefined {
-		return typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
-			? sql` limit ${limit}`
+		return typeof limit === 'object'
+				|| (typeof limit === 'number' && limit >= 0)
+			// Binary protocol bug bypass
+			? sql` limit ${sql.param(limit, this.paginationEncoder)}`
 			: undefined;
 	}
 
-	private buildOrderBy(orderBy: (MySqlColumn | SQL | SQL.Aliased)[] | undefined): SQL | undefined {
-		return orderBy && orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : undefined;
+	private buildOrderBy(
+		orderBy: (MySqlColumn | SQL | SQL.Aliased)[] | undefined,
+	): SQL | undefined {
+		return orderBy && orderBy.length > 0
+			? sql` order by ${sql.join(orderBy, sql`, `)}`
+			: undefined;
 	}
 
 	private buildIndex({
@@ -252,32 +314,34 @@ export class MySqlDialect {
 		indexFor: 'USE' | 'FORCE' | 'IGNORE';
 	}): SQL | undefined {
 		return indexes && indexes.length > 0
-			? sql` ${sql.raw(indexFor)} INDEX (${sql.raw(indexes.join(`, `))})`
+			? sql` ${sql.raw(indexFor)} INDEX ${indexes.map((it) => sql.identifier(it))}`
 			: undefined;
 	}
 
-	buildSelectQuery(
-		{
-			withList,
-			fields,
-			fieldsFlat,
-			where,
-			having,
-			table,
-			joins,
-			orderBy,
-			groupBy,
-			limit,
-			offset,
-			lockingClause,
-			distinct,
-			setOperators,
-			useIndex,
-			forceIndex,
-			ignoreIndex,
-		}: MySqlSelectConfig,
-	): SQL {
-		const fieldsList = fieldsFlat ?? orderSelectedFields<MySqlColumn>(fields);
+	buildSelectQuery({
+		withList,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		limit,
+		offset,
+		lockingClause,
+		distinct,
+		setOperators,
+		useIndex,
+		forceIndex,
+		ignoreIndex,
+		comment,
+		ignoreSelectionCastCodecs,
+	}: MySqlSelectConfig): SQL {
+		if (!fieldsFlat) {
+			throw new Error('Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation');
+		}
+		const fieldsList = fieldsFlat;
 		for (const f of fieldsList) {
 			if (
 				is(f.field, Column)
@@ -290,14 +354,20 @@ export class MySqlDialect {
 						? undefined
 						: getTableName(table))
 				&& !((table) =>
-					joins?.some(({ alias }) =>
-						alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
 					))(f.field.table)
 			) {
 				const tableName = getTableName(f.field.table);
 				throw new Error(
 					`Your "${
-						f.path.join('->')
+						f.path.join(
+							'->',
+						)
 					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
 				);
 			}
@@ -309,15 +379,28 @@ export class MySqlDialect {
 
 		const distinctSql = distinct ? sql` distinct` : undefined;
 
-		const selection = this.buildSelection(fieldsList, { isSingleTable });
+		const selection = this.buildSelection(fieldsList, {
+			isSingleTable,
+			ignoreCastCodecs: ignoreSelectionCastCodecs || setOperators.length > 0,
+		});
 
 		const tableSql = (() => {
 			if (is(table, Table) && table[Table.Symbol.IsAlias]) {
-				return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? '')}.`.if(table[Table.Symbol.Schema])}${
-					sql.identifier(table[Table.Symbol.OriginalName])
+				return sql`${table[Table.Symbol.Schema] ? sql`${sql.identifier(table[Table.Symbol.Schema]!)}.` : undefined}${
+					sql.identifier(
+						table[Table.Symbol.OriginalName],
+					)
 				} ${sql.identifier(table[Table.Symbol.Name])}`;
 			}
 
+			if (is(table, View) && table[ViewBaseConfig].isAlias) {
+				let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+				if (table[ViewBaseConfig].schema) {
+					fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+				}
+				return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+			}
+
 			return table;
 		})();
 
@@ -337,9 +420,18 @@ export class MySqlDialect {
 					const tableSchema = table[MySqlTable.Symbol.Schema];
 					const origTableName = table[MySqlTable.Symbol.OriginalName];
 					const alias = tableName === origTableName ? undefined : joinMeta.alias;
-					const useIndexSql = this.buildIndex({ indexes: joinMeta.useIndex, indexFor: 'USE' });
-					const forceIndexSql = this.buildIndex({ indexes: joinMeta.forceIndex, indexFor: 'FORCE' });
-					const ignoreIndexSql = this.buildIndex({ indexes: joinMeta.ignoreIndex, indexFor: 'IGNORE' });
+					const useIndexSql = this.buildIndex({
+						indexes: joinMeta.useIndex,
+						indexFor: 'USE',
+					});
+					const forceIndexSql = this.buildIndex({
+						indexes: joinMeta.forceIndex,
+						indexFor: 'FORCE',
+					});
+					const ignoreIndexSql = this.buildIndex({
+						indexes: joinMeta.ignoreIndex,
+						indexFor: 'IGNORE',
+					});
 					joinsArray.push(
 						sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
 							tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined
@@ -376,17 +468,28 @@ export class MySqlDialect {
 
 		const orderBySql = this.buildOrderBy(orderBy);
 
-		const groupBySql = groupBy && groupBy.length > 0 ? sql` group by ${sql.join(groupBy, sql`, `)}` : undefined;
+		const groupBySql = groupBy && groupBy.length > 0
+			? sql` group by ${sql.join(groupBy, sql`, `)}`
+			: undefined;
 
 		const limitSql = this.buildLimit(limit);
 
-		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+		// Binary protocol bug bypass
+		const offsetSql = offset
+			? sql` offset ${sql.param(offset, this.paginationEncoder)}`
+			: undefined;
 
 		const useIndexSql = this.buildIndex({ indexes: useIndex, indexFor: 'USE' });
 
-		const forceIndexSql = this.buildIndex({ indexes: forceIndex, indexFor: 'FORCE' });
+		const forceIndexSql = this.buildIndex({
+			indexes: forceIndex,
+			indexFor: 'FORCE',
+		});
 
-		const ignoreIndexSql = this.buildIndex({ indexes: ignoreIndex, indexFor: 'IGNORE' });
+		const ignoreIndexSql = this.buildIndex({
+			indexes: ignoreIndex,
+			indexFor: 'IGNORE',
+		});
 
 		let lockingClausesSql;
 		if (lockingClause) {
@@ -400,39 +503,90 @@ export class MySqlDialect {
 		}
 
 		const finalQuery =
-			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${useIndexSql}${forceIndexSql}${ignoreIndexSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${useIndexSql}${forceIndexSql}${ignoreIndexSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}${
+				comment !== undefined ? sql` ${comment}` : undefined
+			}`;
 
 		if (setOperators.length > 0) {
-			return this.buildSetOperations(finalQuery, setOperators);
+			return this.buildSetOperations(finalQuery, fieldsList, ignoreSelectionCastCodecs, setOperators);
 		}
 
 		return finalQuery;
 	}
 
-	buildSetOperations(leftSelect: SQL, setOperators: MySqlSelectConfig['setOperators']): SQL {
-		const [setOperator, ...rest] = setOperators;
+	buildSetOperations(
+		leftSelect: SQL,
+		leftSelection: SelectedFieldsOrdered,
+		ignoreSelectionCastCodecs: boolean | undefined,
+		setOperators: MySqlSelectConfig['setOperators'],
+	): SQL {
+		const outputSelection = leftSelection;
+		for (let i = 0; i < setOperators.length; ++i) {
+			const setOperator = setOperators[i];
+			if (!setOperator) {
+				throw new Error('Cannot pass undefined values to any set operator');
+			}
+
+			leftSelect = this.buildSetOperationQuery({ leftSelect, setOperator });
+			const rightSelection = orderSelectedFields(setOperator.rightSelect.getSelectedFields());
+			for (let j = 0; j < outputSelection.length; ++j) {
+				const l = outputSelection[j]!;
+				const lPath = l.path.join('.');
+				const r = rightSelection.find((e) => e.path.join('.') === lPath)!; // Equivalency of selections is a pre-requisite for unions
 
-		if (!setOperator) {
-			throw new Error('Cannot pass undefined values to any set operator');
+				const lc = l.codecOverride ?? l.column?.codec;
+				const rc = r.codecOverride ?? r.column?.codec;
+
+				outputSelection[j]!.codecOverride = (lc && rc)
+					? unionsTypeTable[lc as any as keyof typeof unionsTypeTable]?.[rc as any as keyof typeof unionsTypeTable]
+					: lc;
+			}
 		}
 
-		if (rest.length === 0) {
-			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		for (let i = 0; i < outputSelection.length; ++i) {
+			const out = outputSelection[i]!;
+			out.codec = out.codecOverride
+				? this.codecs.get(out.column!, 'normalize', out.codecOverride as MySqlType)
+				: out.codec;
 		}
 
-		// Some recursive magic here
-		return this.buildSetOperations(
-			this.buildSetOperationQuery({ leftSelect, setOperator }),
-			rest,
-		);
+		return ignoreSelectionCastCodecs ? leftSelect : sql`select ${
+			this.buildSelection(
+				outputSelection.map((field) => {
+					if (is(field.field, SQL.Aliased)) {
+						const ref = field.field.clone();
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					if (is(field.field, Column) && field.field.isAlias) {
+						const ref = new SQL.Aliased(sql`${sql.identifier(field.field.name)}`, field.field.name);
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					if (is(field.field, Subquery)) {
+						const ref = new SQL.Aliased(sql`${field.field.getSQL()}`, field.field._.alias);
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					return field;
+				}),
+				{
+					isSingleTable: true,
+					ignoreCastCodecs: ignoreSelectionCastCodecs,
+				},
+			)
+		} from (${leftSelect}) ${sql.identifier('drizzle_union')}`;
 	}
 
 	buildSetOperationQuery({
 		leftSelect,
 		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: MySqlSelectConfig['setOperators'][number] }): SQL {
+	}: {
+		leftSelect: SQL;
+		setOperator: MySqlSelectConfig['setOperators'][number];
+	}): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
-		const rightChunk = sql`(${rightSelect.getSQL()})`;
+		const rightChunk = sql`(${rightSelect.withoutSelectionCastCodecs().getSQL()})`;
 
 		let orderBySql;
 		if (orderBy && orderBy.length > 0) {
@@ -442,13 +596,15 @@ export class MySqlDialect {
 			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const orderByUnit of orderBy) {
 				if (is(orderByUnit, MySqlColumn)) {
-					orderByValues.push(sql.identifier(this.casing.getColumnCasing(orderByUnit)));
+					orderByValues.push(
+						sql.identifier(orderByUnit.name),
+					);
 				} else if (is(orderByUnit, SQL)) {
 					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
 						const chunk = orderByUnit.queryChunks[i];
 
 						if (is(chunk, MySqlColumn)) {
-							orderByUnit.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));
+							orderByUnit.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
@@ -467,22 +623,33 @@ export class MySqlDialect {
 
 		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
 
-		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+		// Binary protocol bug bypass
+		const offsetSql = offset
+			? sql` offset ${sql.param(offset, this.paginationEncoder)}`
+			: undefined;
 
 		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
-	buildInsertQuery(
-		{ table, values: valuesOrSelect, ignore, onConflict, select }: MySqlInsertConfig,
-	): { sql: SQL; generatedIds: Record<string, unknown>[] } {
+	buildInsertQuery({
+		table,
+		values: valuesOrSelect,
+		ignore,
+		onConflict,
+		select,
+		comment,
+	}: MySqlInsertConfig): { sql: SQL; generatedIds: Record<string, unknown>[] } {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
 		const columns: Record<string, MySqlColumn> = table[Table.Symbol.Columns];
-		const colEntries: [string, MySqlColumn][] = Object.entries(columns).filter(([_, col]) =>
-			!col.shouldDisableInsert()
-		);
-
-		const insertOrder = colEntries.map(([, column]) => sql.identifier(this.casing.getColumnCasing(column)));
+		const colEntries: [string, MySqlColumn][] = Object.entries(columns);
+		const colEntriesFiltered: [string, MySqlColumn][] = select && !is(valuesOrSelect, SQL)
+			? Object
+				.keys((valuesOrSelect as TypedQueryBuilder<any>).getSelectedFields())
+				.map((key) => [key, columns[key]] as [string, MySqlColumn])
+			: colEntries.filter(([_, col]) => !col.shouldDisableInsert());
+
+		const insertOrder = colEntriesFiltered.map(([, column]) => sql.identifier(column.name));
 		const generatedIdsResponse: Record<string, unknown>[] = [];
 
 		if (select) {
@@ -501,19 +668,26 @@ export class MySqlDialect {
 				const generatedIds: Record<string, unknown> = {};
 
 				const valueList: (SQLChunk | SQL)[] = [];
-				for (const [fieldName, col] of colEntries) {
+				for (const [fieldName, col] of colEntriesFiltered) {
 					const colValue = value[fieldName];
-					if (colValue === undefined || (is(colValue, Param) && colValue.value === undefined)) {
+					if (
+						colValue === undefined
+						|| (is(colValue, Param) && colValue.value === undefined)
+					) {
 						// eslint-disable-next-line unicorn/no-negated-condition
 						if (col.defaultFn !== undefined) {
 							const defaultFnResult = col.defaultFn();
 							generatedIds[fieldName] = defaultFnResult;
-							const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
+							const defaultValue = is(defaultFnResult, SQL)
+								? defaultFnResult
+								: sql.param(defaultFnResult, col);
 							valueList.push(defaultValue);
 							// eslint-disable-next-line unicorn/no-negated-condition
 						} else if (!col.default && col.onUpdateFn !== undefined) {
 							const onUpdateFnResult = col.onUpdateFn();
-							const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
+							const newValue = is(onUpdateFnResult, SQL)
+								? onUpdateFnResult
+								: sql.param(onUpdateFnResult, col);
 							valueList.push(newValue);
 						} else {
 							valueList.push(sql`default`);
@@ -538,613 +712,318 @@ export class MySqlDialect {
 
 		const ignoreSql = ignore ? sql` ignore` : undefined;
 
-		const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : undefined;
+		const onConflictSql = onConflict
+			? sql` on duplicate key ${onConflict}`
+			: undefined;
 
 		return {
-			sql: sql`insert${ignoreSql} into ${table} ${insertOrder} ${valuesSql}${onConflictSql}`,
+			sql: sql`insert${ignoreSql} into ${table} ${insertOrder} ${valuesSql}${onConflictSql}${
+				comment !== undefined ? sql` ${comment}` : undefined
+			}`,
 			generatedIds: generatedIdsResponse,
 		};
 	}
 
-	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): QueryWithTypings {
+	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): Query {
 		return sql.toQuery({
-			casing: this.casing,
 			escapeName: this.escapeName,
 			escapeParam: this.escapeParam,
 			escapeString: this.escapeString,
+			codecs: this.codecs,
 			invokeSource,
 		});
 	}
 
-	buildRelationalQuery({
-		fullSchema,
-		schema,
-		tableNamesMap,
-		table,
-		tableConfig,
-		queryConfig: config,
-		tableAlias,
-		nestedQueryRelation,
-		joinOn,
-	}: {
-		fullSchema: Record<string, unknown>;
-		schema: TablesRelationalConfig;
-		tableNamesMap: Record<string, string>;
-		table: MySqlTable;
-		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
-		tableAlias: string;
-		nestedQueryRelation?: Relation;
-		joinOn?: SQL;
-	}): BuildRelationalQueryResult<MySqlTable, MySqlColumn> {
-		let selection: BuildRelationalQueryResult<MySqlTable, MySqlColumn>['selection'] = [];
-		let limit, offset, orderBy: MySqlSelectConfig['orderBy'], where;
-		const joins: MySqlSelectJoinConfig[] = [];
-
-		if (config === true) {
-			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
-				dbKey: value.name,
-				tsKey: key,
-				field: aliasedTableColumn(value as MySqlColumn, tableAlias),
-				relationTableTsKey: undefined,
-				isJson: false,
-				selection: [],
-			}));
-		} else {
-			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
-			);
-
-			if (config.where) {
-				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
-					: config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
-
-			const fieldsSelection: { tsKey: string; value: MySqlColumn | SQL.Aliased }[] = [];
-			let selectedColumns: string[] = [];
+	private buildRqbColumn(table: Table | View, field: unknown, key: string, inJson: boolean) {
+		if (is(field, Column)) {
+			const name = sql`${table}.${sql.identifier(field.name)}`;
+			const casted = inJson && (<MySqlCustomColumn<any>> field).jsonSelectIdentifier
+				? (<MySqlCustomColumn<any>> field).jsonSelectIdentifier!(name, sql)
+				: this.codecs.apply(field, inJson ? 'castInJson' : 'cast', name);
 
-			// Figure out which columns to select
-			if (config.columns) {
-				let isIncludeMode = false;
+			return sql`${casted} as ${sql.identifier(key)}`;
+		}
 
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === undefined) {
-						continue;
-					}
+		if (is(field, SQL.Aliased)) {
+			const column = getColumnFromDecoder(field);
+			const q = sql`${table}.${sql.identifier(field.fieldAlias)}`;
+			return sql`${column ? this.codecs.apply(column, inJson ? 'castInJson' : 'cast', q) : q} as ${
+				sql.identifier(key)
+			}`;
+		}
 
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) {
-							isIncludeMode = true;
-						}
-						selectedColumns.push(field);
-					}
-				}
+		if (isSQLWrapper(field)) {
+			const column = getColumnFromDecoder(field);
+			const q = sql`${table}.${sql.identifier(key)}`;
+			return sql`${column ? this.codecs.apply(column, inJson ? 'castInJson' : 'cast', q) : q} as ${
+				sql.identifier(key)
+			}`;
+		}
 
-				if (selectedColumns.length > 0) {
-					selectedColumns = isIncludeMode
-						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-				}
-			} else {
-				// Select all columns if selection is not specified
-				selectedColumns = Object.keys(tableConfig.columns);
-			}
+		throw new DrizzleError({
+			message: `Views with nested selections are not supported by the relational query builder`,
+		});
+	}
 
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as MySqlColumn;
-				fieldsSelection.push({ tsKey: field, value: column });
-			}
+	private resolveSelection(field: unknown, key: string, inJson: boolean) {
+		if (is(field, Column)) {
+			return {
+				key,
+				field: field,
+				codec: this.codecs.get(field, inJson ? 'normalizeInJson' : 'normalize'),
+			};
+		}
 
-			let selectedRelations: {
-				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
-			}[] = [];
-
-			// Figure out which relations to select
-			if (config.with) {
-				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
+		const decoderColumn = getColumnFromDecoder(field as SQL | SQLWrapper | SQL.Aliased);
+		return decoderColumn
+			? {
+				key,
+				field: field as SQL | SQLWrapper | SQL.Aliased,
+				codec: decoderColumn && (!inJson || !(<MySqlCustomColumn<any>> decoderColumn).mapFromJsonValue)
+					? this.codecs.get(decoderColumn, inJson ? 'normalizeInJson' : 'normalize')
+					: undefined,
 			}
+			: {
+				key,
+				field: field as SQL | SQLWrapper | SQL.Aliased,
+			};
+	}
 
-			let extras;
-
-			// Figure out which extras to select
-			if (config.extras) {
-				extras = typeof config.extras === 'function'
-					? config.extras(aliasedColumns, { sql })
-					: config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) {
-					fieldsSelection.push({
-						tsKey,
-						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-					});
-				}
-			}
+	private buildColumns = (
+		table: Table | View,
+		selection: BuildRelationalQueryResult['selection'],
+		inJson: boolean,
+		config?: DBQueryConfigWithComment<'many'>,
+	) => {
+		if (!config?.columns) {
+			return sql.join(
+				Object.entries(table[TableColumns]).map(([k, v]) => {
+					selection.push(this.resolveSelection(v, k, inJson));
+
+					return this.buildRqbColumn(table, v, k, inJson);
+				}),
+				sql`, `,
+			);
+		}
 
-			// Transform `fieldsSelection` into `selection`
-			// `fieldsSelection` shouldn't be used after this point
-			for (const { tsKey, value } of fieldsSelection) {
-				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-					relationTableTsKey: undefined,
-					isJson: false,
-					selection: [],
-				});
-			}
+		const entries = Object.entries(config.columns);
+		const columnContainer: Record<string, unknown> = table[TableColumns];
 
-			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) {
-				orderByOrig = [orderByOrig];
-			}
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as MySqlColumn;
-				}
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
+		const columnIdentifiers: SQL[] = [];
+		let colSelectionMode: boolean | undefined;
+		for (const [k, v] of entries) {
+			if (v === undefined) continue;
+			colSelectionMode = colSelectionMode || v;
 
-			limit = config.limit;
-			offset = config.offset;
+			if (v) {
+				const column = columnContainer[k];
+				columnIdentifiers.push(this.buildRqbColumn(table, column, k, inJson));
 
-			// Process all relations
-			for (
-				const {
-					tsKey: selectedRelationTsKey,
-					queryConfig: selectedRelationConfigValue,
-					relation,
-				} of selectedRelations
-			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableName = getTableUniqueName(relation.referencedTable);
-				const relationTableTsName = tableNamesMap[relationTableName]!;
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				const joinOn = and(
-					...normalizedRelation.fields.map((field, i) =>
-						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-							aliasedTableColumn(field, tableAlias),
-						)
-					),
-				);
-				const builtRelation = this.buildRelationalQuery({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName] as MySqlTable,
-					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
-							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
-						: selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation,
-				});
-				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
-				joins.push({
-					on: sql`true`,
-					table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
-					alias: relationTableAlias,
-					joinType: 'left',
-					lateral: true,
-				});
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection,
-				});
+				selection.push(this.resolveSelection(column, k, inJson));
 			}
 		}
 
-		if (selection.length === 0) {
-			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
-		}
+		if (colSelectionMode === false) {
+			for (const [k, v] of Object.entries(columnContainer)) {
+				if (config.columns[k] === false) continue;
+				columnIdentifiers.push(this.buildRqbColumn(table, v, k, inJson));
 
-		let result;
-
-		where = and(joinOn, where);
-
-		if (nestedQueryRelation) {
-			let field = sql`json_array(${
-				sql.join(
-					selection.map(({ field, tsKey, isJson }) =>
-						isJson
-							? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier('data')}`
-							: is(field, SQL.Aliased)
-							? field.sql
-							: field
-					),
-					sql`, `,
-				)
-			})`;
-			if (is(nestedQueryRelation, Many)) {
-				field = sql`coalesce(json_arrayagg(${field}), json_array())`;
+				selection.push(this.resolveSelection(v, k, inJson));
 			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field: field.as('data'),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
-
-			const needsSubquery = limit !== undefined || offset !== undefined || (orderBy?.length ?? 0) > 0;
-
-			if (needsSubquery) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [
-						{
-							path: [],
-							field: sql.raw('*'),
-						},
-						...(((orderBy?.length ?? 0) > 0)
-							? [{
-								path: [],
-								field: sql`row_number() over (order by ${sql.join(orderBy!, sql`, `)})`,
-							}]
-							: []),
-					],
-					where,
-					limit,
-					offset,
-					setOperators: [],
-				});
-
-				where = undefined;
-				limit = undefined;
-				offset = undefined;
-				orderBy = undefined;
-			} else {
-				result = aliasedTable(table, tableAlias);
-			}
-
-			result = this.buildSelectQuery({
-				table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		} else {
-			result = this.buildSelectQuery({
-				table: aliasedTable(table, tableAlias),
-				fields: {},
-				fieldsFlat: selection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
 		}
 
-		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
-			selection,
-		};
-	}
+		return columnIdentifiers.length
+			? sql.join(columnIdentifiers, sql`, `)
+			: undefined;
+	};
 
-	buildRelationalQueryWithoutLateralSubqueries({
-		fullSchema,
+	buildRelationalQuery({
 		schema,
-		tableNamesMap,
 		table,
 		tableConfig,
 		queryConfig: config,
-		tableAlias,
-		nestedQueryRelation,
-		joinOn,
+		relationWhere,
+		mode,
+		errorPath,
+		depth,
+		isNestedMany,
+		throughJoin,
+		nested,
 	}: {
-		fullSchema: Record<string, unknown>;
 		schema: TablesRelationalConfig;
-		tableNamesMap: Record<string, string>;
-		table: MySqlTable;
+		table: MySqlTable | MySqlView;
 		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
-		tableAlias: string;
-		nestedQueryRelation?: Relation;
-		joinOn?: SQL;
-	}): BuildRelationalQueryResult<MySqlTable, MySqlColumn> {
-		let selection: BuildRelationalQueryResult<MySqlTable, MySqlColumn>['selection'] = [];
-		let limit, offset, orderBy: MySqlSelectConfig['orderBy'] = [], where;
-
-		if (config === true) {
-			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
-				dbKey: value.name,
-				tsKey: key,
-				field: aliasedTableColumn(value as MySqlColumn, tableAlias),
-				relationTableTsKey: undefined,
-				isJson: false,
-				selection: [],
-			}));
-		} else {
-			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
-			);
-
-			if (config.where) {
-				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
-					: config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
-
-			const fieldsSelection: { tsKey: string; value: MySqlColumn | SQL.Aliased }[] = [];
-			let selectedColumns: string[] = [];
+		queryConfig?: DBQueryConfigWithComment<'many'> | true;
+		relationWhere?: SQL;
+		mode: 'first' | 'many';
+		errorPath?: string;
+		depth?: number;
+		isNestedMany?: boolean;
+		throughJoin?: SQL;
+		nested?: boolean;
+	}): BuildRelationalQueryResult {
+		const selection: BuildRelationalQueryResult['selection'] = [];
+		const isSingle = mode === 'first';
+		const params = config === true ? undefined : config;
+		const currentPath = errorPath ?? '';
+		const currentDepth = depth ?? 0;
+		if (!currentDepth) table = aliasedTable(table, `d${currentDepth}`);
+
+		const limit = isSingle ? 1 : params?.limit;
+		const offset = params?.offset;
+
+		const columns = this.buildColumns(table, selection, !!nested, params);
+
+		const where: SQL | undefined = params?.where && relationWhere
+			? and(
+				relationsFilterToSQL(
+					table,
+					params.where,
+					tableConfig.relations,
+					schema,
+				),
+				relationWhere,
+			)
+			: params?.where
+			? relationsFilterToSQL(
+				table,
+				params.where,
+				tableConfig.relations,
+				schema,
+			)
+			: relationWhere;
+		const order = params?.orderBy
+			? relationsOrderToSQL(table, params.orderBy)
+			: undefined;
+		const extras = params?.extras
+			? relationExtrasToSQL(table, params.extras, this.codecs, nested)
+			: undefined;
+		if (extras) selection.push(...extras.selection);
 
-			// Figure out which columns to select
-			if (config.columns) {
-				let isIncludeMode = false;
+		const selectionArr: SQL[] = columns ? [columns] : [];
+		if (extras?.sql) selectionArr.push(extras.sql);
 
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === undefined) {
-						continue;
-					}
+		const joins = params
+			? (() => {
+				const { with: joins } = params as WithContainer;
+				if (!joins) return;
 
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) {
-							isIncludeMode = true;
-						}
-						selectedColumns.push(field);
-					}
-				}
+				const withEntries = Object.entries(joins).filter(([_, v]) => v);
+				if (!withEntries.length) return;
 
-				if (selectedColumns.length > 0) {
-					selectedColumns = isIncludeMode
-						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-				}
-			} else {
-				// Select all columns if selection is not specified
-				selectedColumns = Object.keys(tableConfig.columns);
-			}
+				return sql.join(
+					withEntries.map(([k, join]) => {
+						selectionArr.push(
+							sql`${sql.identifier(k)}.${sql.identifier('r')} as ${sql.identifier(k)}`,
+						);
 
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as MySqlColumn;
-				fieldsSelection.push({ tsKey: field, value: column });
-			}
+						// if (is(tableConfig.relations[k]!, AggregatedField)) {
+						// 	const relation = tableConfig.relations[k]!;
+						// 	relation.onTable(table);
+						// 	const query = relation.getSQL();
 
-			let selectedRelations: {
-				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
-			}[] = [];
-
-			// Figure out which relations to select
-			if (config.with) {
-				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-			}
+						// 	selection.push({
+						// 		key: k,
+						// 		field: relation,
+						// 	});
 
-			let extras;
-
-			// Figure out which extras to select
-			if (config.extras) {
-				extras = typeof config.extras === 'function'
-					? config.extras(aliasedColumns, { sql })
-					: config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) {
-					fieldsSelection.push({
-						tsKey,
-						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-					});
-				}
-			}
-
-			// Transform `fieldsSelection` into `selection`
-			// `fieldsSelection` shouldn't be used after this point
-			for (const { tsKey, value } of fieldsSelection) {
-				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-					relationTableTsKey: undefined,
-					isJson: false,
-					selection: [],
-				});
-			}
+						// 	return sql` left join lateral (${query}) as ${sql.identifier(k)} on true`;
+						// }
 
-			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) {
-				orderByOrig = [orderByOrig];
-			}
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as MySqlColumn;
-				}
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
+						const relation = tableConfig.relations[k]! as Relation;
+						const isSingle = is(relation, One);
+						const targetTable = aliasedTable(
+							relation.targetTable,
+							`d${currentDepth + 1}`,
+						);
+						const throughTable = relation.throughTable
+							? aliasedTable(relation.throughTable, `tr${currentDepth}`)
+							: undefined;
+						const { filter, joinCondition } = relationToSQL(
+							relation,
+							table,
+							targetTable,
+							throughTable,
+						);
 
-			limit = config.limit;
-			offset = config.offset;
+						const throughJoin = throughTable
+							? sql` inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition!}`
+							: undefined;
+
+						const innerQuery = this.buildRelationalQuery({
+							table: targetTable as MySqlTable,
+							mode: isSingle ? 'first' : 'many',
+							schema,
+							queryConfig: join as DBQueryConfigWithComment,
+							tableConfig: schema[relation.targetTableName]!,
+							relationWhere: filter,
+							errorPath: `${currentPath.length ? `${currentPath}.` : ''}${k}`,
+							depth: currentDepth + 1,
+							isNestedMany: !isSingle,
+							throughJoin,
+							nested: true,
+						});
+
+						selection.push({
+							field: targetTable,
+							key: k,
+							selection: innerQuery.selection,
+							isArray: !isSingle,
+							isOptional: ((relation as AnyOne).optional ?? false)
+								|| (join !== true
+									&& !!(join as Exclude<typeof join, boolean | undefined>)
+										.where),
+						});
+
+						const jsonColumns = sql.join(
+							innerQuery.selection.map(
+								(s) => sql`${sql.raw(this.escapeString(s.key))}, ${sql.identifier(s.key)}`,
+							),
+							sql`, `,
+						);
 
-			// Process all relations
-			for (
-				const {
-					tsKey: selectedRelationTsKey,
-					queryConfig: selectedRelationConfigValue,
-					relation,
-				} of selectedRelations
-			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableName = getTableUniqueName(relation.referencedTable);
-				const relationTableTsName = tableNamesMap[relationTableName]!;
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				const joinOn = and(
-					...normalizedRelation.fields.map((field, i) =>
-						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-							aliasedTableColumn(field, tableAlias),
-						)
-					),
+						const joinQuery = sql` left join lateral(select ${sql`${
+							isSingle
+								? sql`json_object(${jsonColumns})`
+								: sql`coalesce(json_arrayagg(json_object(${jsonColumns})), json_array())`
+						} as ${sql.identifier('r')}`} from (${innerQuery.sql}) as ${sql.identifier('t')}) as ${
+							sql.identifier(
+								k,
+							)
+						} on true`;
+
+						return joinQuery;
+					}),
 				);
-				const builtRelation = this.buildRelationalQueryWithoutLateralSubqueries({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName] as MySqlTable,
-					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
-							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
-						: selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation,
-				});
-				let fieldSql = sql`(${builtRelation.sql})`;
-				if (is(relation, Many)) {
-					fieldSql = sql`coalesce(${fieldSql}, json_array())`;
-				}
-				const field = fieldSql.as(selectedRelationTsKey);
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection,
-				});
-			}
-		}
+			})()
+			: undefined;
 
-		if (selection.length === 0) {
+		if (!selectionArr.length) {
 			throw new DrizzleError({
-				message:
-					`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
+				message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ''}`,
 			});
 		}
-
-		let result;
-
-		where = and(joinOn, where);
-
-		if (nestedQueryRelation) {
-			let field = sql`json_array(${
-				sql.join(
-					selection.map(({ field }) =>
-						is(field, MySqlColumn)
-							? sql.identifier(this.casing.getColumnCasing(field))
-							: is(field, SQL.Aliased)
-							? field.sql
-							: field
-					),
-					sql`, `,
-				)
-			})`;
-			if (is(nestedQueryRelation, Many)) {
-				field = sql`json_arrayagg(${field})`;
-			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field,
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
-
-			const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
-
-			if (needsSubquery) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [
-						{
-							path: [],
-							field: sql.raw('*'),
-						},
-						...(orderBy.length > 0)
-							? [{
-								path: [],
-								field: sql`row_number() over (order by ${sql.join(orderBy, sql`, `)})`,
-							}]
-							: [],
-					],
-					where,
-					limit,
-					offset,
-					setOperators: [],
-				});
-
-				where = undefined;
-				limit = undefined;
-				offset = undefined;
-				orderBy = undefined;
-			} else {
-				result = aliasedTable(table, tableAlias);
-			}
-
-			result = this.buildSelectQuery({
-				table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		} else {
-			result = this.buildSelectQuery({
-				table: aliasedTable(table, tableAlias),
-				fields: {},
-				fieldsFlat: selection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
+		// json_arrayagg() ignores order by clause otherwise
+		if (isNestedMany && order) {
+			selectionArr.push(sql`row_number() over (order by ${order})`);
 		}
+		const selectionSet = sql.join(selectionArr, sql`, `);
+		const comment = config !== true && config?.comment
+			? sql.comment(config.comment)
+			: undefined;
+
+		const query = sql`select ${selectionSet} from ${getTableAsAliasSQL(table)}${throughJoin}${
+			joins ? sql`${joins}` : undefined
+		}${where ? sql` where ${where}` : undefined}${order ? sql` order by ${order}` : undefined}${
+			limit !== undefined ? sql` limit ${sql.param(limit, this.paginationEncoder)}` : undefined
+		}${
+			offset !== undefined
+				? sql` offset ${sql.param(offset, this.paginationEncoder)}`
+				: undefined
+		}${comment ? sql` ${comment}` : undefined}`;
 
 		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
+			sql: query,
 			selection,
 		};
 	}
diff --git a/drizzle-orm/src/mysql-core/effect/count.ts b/drizzle-orm/src/mysql-core/effect/count.ts
new file mode 100644
index 0000000000..ad3a2d1449
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/count.ts
@@ -0,0 +1,50 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import { MySqlCountBuilder } from '../query-builders/count.ts';
+import type { MySqlTable } from '../table.ts';
+import type { MySqlViewBase } from '../view-base.ts';
+import type { MySqlEffectSession } from './session.ts';
+
+export interface MySqlEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlCountBuilder, Effect.Effect<number, TEffectHKT['error'], TEffectHKT['context']>
+{}
+
+export class MySqlEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlCountBuilder
+{
+	static override readonly [entityKind]: string = 'MySqlEffectCountBuilder';
+
+	protected session: MySqlEffectSession<TEffectHKT, any, any>;
+
+	constructor(
+		{ source, dialect, filters, session }: {
+			source: MySqlTable | MySqlViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: MySqlDialect;
+			session: MySqlEffectSession<TEffectHKT, any, any>;
+		},
+	) {
+		super({ source, dialect, filters });
+		this.session = session;
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.session.prepareQuery<{
+			execute: number;
+			iterator: never;
+		}>(
+			this.build(),
+			'arrays',
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(MySqlEffectCountBuilder);
diff --git a/drizzle-orm/src/mysql-core/effect/db.ts b/drizzle-orm/src/mysql-core/effect/db.ts
new file mode 100644
index 0000000000..68d1464e07
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/db.ts
@@ -0,0 +1,544 @@
+import { Effect } from 'effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { ResultSetHeader } from 'mysql2/promise';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { MutationOption } from '~/cache/core/cache.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { MySqlInsertBuilder } from '../query-builders/insert.ts';
+import { QueryBuilder } from '../query-builders/query-builder.ts';
+import { RelationalQueryBuilder } from '../query-builders/query.ts';
+import { MySqlSelectBuilder } from '../query-builders/select.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import { MySqlUpdateBuilder } from '../query-builders/update.ts';
+import type {
+	MySqlPreparedQueryConfig,
+	MySqlQueryResultHKT,
+	MySqlQueryResultKind,
+	MySqlTransactionConfig,
+} from '../session.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { MySqlTable } from '../table.ts';
+import type { MySqlViewBase } from '../view-base.ts';
+import type { MySqlView } from '../view.ts';
+import { MySqlEffectCountBuilder } from './count.ts';
+import { MySqlEffectDeleteBase } from './delete.ts';
+import { MySqlEffectInsertBase, type MySqlEffectInsertHKT } from './insert.ts';
+import { MySqlEffectRelationalQuery, type MySqlEffectRelationalQueryHKT } from './query.ts';
+import { MySqlEffectRaw } from './raw.ts';
+import { MySqlEffectSelectBase, type MySqlEffectSelectBuilder } from './select.ts';
+import type { MySqlEffectSession, MySqlEffectTransaction } from './session.ts';
+import { MySqlEffectUpdateBase, type MySqlEffectUpdateHKT } from './update.ts';
+
+export class MySqlEffectDatabase<
+	TEffectHKT extends QueryEffectHKTBase,
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'MySqlEffectDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: MySqlEffectSession<TEffectHKT, TQueryResult, TRelations>;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TRelations,
+			TRelations[K],
+			MySqlEffectRelationalQueryHKT<TEffectHKT>
+		>;
+	};
+
+	constructor(
+		/** @internal */
+		readonly dialect: MySqlDialect,
+		/** @internal */
+		readonly session: MySqlEffectSession<TEffectHKT, any, any>,
+		relations: TRelations,
+	) {
+		this._ = {
+			relations,
+			session,
+		};
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as MySqlEffectDatabase<
+				TEffectHKT,
+				TQueryResult,
+				AnyRelations
+			>['query'])[tableName] = new RelationalQueryBuilder(
+				relations,
+				relations[relation.name]!.table as MySqlTable | MySqlView,
+				relation,
+				dialect,
+				session,
+				MySqlEffectRelationalQuery,
+			);
+		}
+
+		this.$cache = { invalidate: (_params: MutationOption) => Effect.void };
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = yield* db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(this.dialect));
+			}
+
+			const sql = ('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL();
+			return new Proxy(
+				new WithSubquery(
+					sql,
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+					sql.usedTables ?? [],
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: MySqlTable | MySqlViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	) {
+		return new MySqlEffectCountBuilder({ source, filters, session: this.session, dialect: this.dialect });
+	}
+
+	$cache: { invalidate: EffectCacheShape['onMutate'] };
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = yield* db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): MySqlEffectSelectBuilder<undefined, TEffectHKT>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MySqlEffectSelectBuilder<TSelection, TEffectHKT>;
+		function select(fields?: SelectedFields): MySqlEffectSelectBuilder<SelectedFields | undefined, TEffectHKT> {
+			return new MySqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			}, MySqlEffectSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * yield* db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * yield* db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): MySqlEffectSelectBuilder<undefined, TEffectHKT>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MySqlEffectSelectBuilder<TSelection, TEffectHKT>;
+		function selectDistinct(
+			fields?: SelectedFields,
+		): MySqlEffectSelectBuilder<SelectedFields | undefined, TEffectHKT> {
+			return new MySqlSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			}, MySqlEffectSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * yield* db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 * ```
+		 */
+		function update<TTable extends MySqlTable>(
+			table: TTable,
+		): MySqlUpdateBuilder<TTable, TQueryResult, MySqlEffectUpdateHKT<TEffectHKT>> {
+			return new MySqlUpdateBuilder(table, self.session, self.dialect, queries, MySqlEffectUpdateBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * yield* db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+		 * ```
+		 */
+		function delete_<TTable extends MySqlTable>(
+			table: TTable,
+		): MySqlEffectDeleteBase<TTable, TQueryResult, false, never, TEffectHKT> {
+			return new MySqlEffectDeleteBase(table, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, update, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = yield* db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): MySqlEffectSelectBuilder<undefined, TEffectHKT>;
+	select<TSelection extends SelectedFields>(fields: TSelection): MySqlEffectSelectBuilder<TSelection, TEffectHKT>;
+	select(fields?: SelectedFields): MySqlEffectSelectBuilder<SelectedFields | undefined, TEffectHKT> {
+		return new MySqlSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+		}, MySqlEffectSelectBase);
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * yield* db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * yield* db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): MySqlEffectSelectBuilder<undefined, TEffectHKT>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): MySqlEffectSelectBuilder<TSelection, TEffectHKT>;
+	selectDistinct(fields?: SelectedFields): MySqlEffectSelectBuilder<SelectedFields | undefined, TEffectHKT> {
+		return new MySqlSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		}, MySqlEffectSelectBase);
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * yield* db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 * ```
+	 */
+	update<TTable extends MySqlTable>(
+		table: TTable,
+	): MySqlUpdateBuilder<TTable, TQueryResult, MySqlEffectUpdateHKT<TEffectHKT>> {
+		return new MySqlUpdateBuilder(table, this.session, this.dialect, undefined, MySqlEffectUpdateBase);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * yield* db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * yield* db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 * ```
+	 */
+	insert<TTable extends MySqlTable>(
+		table: TTable,
+	): MySqlInsertBuilder<TTable, TQueryResult, MySqlEffectInsertHKT<TEffectHKT>> {
+		return new MySqlInsertBuilder(table, this.session, this.dialect, MySqlEffectInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * yield* db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+	 * ```
+	 */
+	delete<TTable extends MySqlTable>(
+		table: TTable,
+	): MySqlEffectDeleteBase<TTable, TQueryResult, false, never, TEffectHKT> {
+		return new MySqlEffectDeleteBase(table, this.session, this.dialect);
+	}
+
+	execute<T extends { [column: string]: any } = ResultSetHeader>(
+		query: SQLWrapper | string,
+	): MySqlEffectRaw<MySqlQueryResultKind<TQueryResult, T>, TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<
+			MySqlPreparedQueryConfig & { execute: MySqlQueryResultKind<TQueryResult, T> }
+		>(builtQuery, 'raw');
+		return new MySqlEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	transaction<A, E, R>(
+		transaction: (
+			tx: MySqlEffectTransaction<TEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+		config?: MySqlTransactionConfig,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type MySqlEffectWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	TEffectHKT extends QueryEffectHKTBase,
+	HKT extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations,
+	Q extends MySqlEffectDatabase<TEffectHKT, HKT, TRelations>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): MySqlEffectWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any, any]) => primary.transaction(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		$count,
+		with: $with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/mysql-core/effect/delete.ts b/drizzle-orm/src/mysql-core/effect/delete.ts
new file mode 100644
index 0000000000..cc2de8a972
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/delete.ts
@@ -0,0 +1,81 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlDeleteBase, type MySqlDeleteHKTBase } from '~/mysql-core/query-builders/delete.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import type { Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlEffectPreparedQuery, MySqlEffectSession } from './session.ts';
+
+export type MySqlEffectDelete<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectDeleteBase<TTable, TQueryResult, true, never, TEffectHKT>;
+
+export type MySqlEffectDeletePrepare<
+	T extends AnyMySqlEffectDelete,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	},
+	TEffectHKT
+>;
+
+export type AnyMySqlEffectDelete = MySqlEffectDeleteBase<any, any, any, any, any>;
+
+export interface MySqlEffectDeleteHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlDeleteHKTBase
+{
+	_type: MySqlEffectDeleteBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export interface MySqlEffectDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends Effect.Effect<MySqlQueryResultKind<TQueryResult, never>, TEffectHKT['error'], TEffectHKT['context']> {}
+
+export class MySqlEffectDeleteBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends MySqlDeleteBase<MySqlEffectDeleteHKT<TEffectHKT>, TTable, TQueryResult, TDynamic, TExcludedMethods> {
+	static override readonly [entityKind]: string = 'MySqlEffectDelete';
+
+	declare protected session: MySqlEffectSession<TEffectHKT, TQueryResult, any>;
+
+	prepare(): MySqlEffectDeletePrepare<this, TEffectHKT> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'raw',
+			undefined,
+			{
+				type: 'delete',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as MySqlEffectDeletePrepare<this, TEffectHKT>;
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(MySqlEffectDeleteBase);
diff --git a/drizzle-orm/src/mysql-core/effect/index.ts b/drizzle-orm/src/mysql-core/effect/index.ts
new file mode 100644
index 0000000000..7a4d5c2e0e
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/index.ts
@@ -0,0 +1,10 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
+export * from './utils.ts';
diff --git a/drizzle-orm/src/mysql-core/effect/insert.ts b/drizzle-orm/src/mysql-core/effect/insert.ts
new file mode 100644
index 0000000000..d8c07381e8
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/insert.ts
@@ -0,0 +1,108 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlInsertBase, type MySqlInsertHKTBase } from '~/mysql-core/query-builders/insert.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlEffectPreparedQuery, MySqlEffectSession } from './session.ts';
+
+export interface MySqlEffectInsertHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlInsertHKTBase
+{
+	_type: MySqlEffectInsertBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnyMySqlEffectInsert = MySqlEffectInsertBase<any, any, any, any, any>;
+
+export type MySqlEffectInsertPrepare<
+	T extends AnyMySqlEffectInsert,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: TReturning extends undefined ? MySqlQueryResultKind<T['_']['queryResult'], never> : TReturning[];
+		iterator: never;
+	},
+	TEffectHKT
+>;
+
+export type MySqlEffectInsert<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectInsertBase<TTable, TQueryResult, TReturning, true, never, TEffectHKT>;
+
+export interface MySqlEffectInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends
+	Effect.Effect<
+		TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[],
+		TEffectHKT['error'],
+		TEffectHKT['context']
+	>
+{}
+
+export class MySqlEffectInsertBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends MySqlInsertBase<
+	MySqlEffectInsertHKT<TEffectHKT>,
+	TTable,
+	TQueryResult,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements
+	RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>
+{
+	static override readonly [entityKind]: string = 'MySqlEffectInsert';
+
+	declare protected session: MySqlEffectSession<TEffectHKT, TQueryResult, any>;
+
+	/** @internal */
+	_prepare(): MySqlEffectInsertPrepare<this, TReturning, TEffectHKT> {
+		const { sql, generatedIds } = this.dialect.buildInsertQuery(this.config);
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(sql),
+			'raw',
+			this.dialect.mapperGenerators.$returning(this.config.returning, generatedIds),
+			{
+				type: 'insert',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as MySqlEffectInsertPrepare<this, TReturning, TEffectHKT>;
+	}
+
+	prepare(): MySqlEffectInsertPrepare<this, TReturning, TEffectHKT> {
+		return this._prepare();
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(MySqlEffectInsertBase);
diff --git a/drizzle-orm/src/mysql-core/effect/query.ts b/drizzle-orm/src/mysql-core/effect/query.ts
new file mode 100644
index 0000000000..28b190ad5b
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/query.ts
@@ -0,0 +1,49 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlRelationalQuery, type MySqlRelationalQueryHKTBase } from '../query-builders/query.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlEffectPreparedQuery, MySqlEffectSession } from './session.ts';
+
+export type AnyMySqlEffectRelationalQuery = MySqlEffectRelationalQuery<any, any>;
+
+export interface MySqlEffectRelationalQueryHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlRelationalQueryHKTBase
+{
+	_type: MySqlEffectRelationalQuery<this['result'], TEffectHKT>;
+}
+
+export interface MySqlEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends Effect.Effect<TResult, TEffectHKT['error'], TEffectHKT['context']>
+{}
+export class MySqlEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlRelationalQuery<MySqlEffectRelationalQueryHKT<TEffectHKT>, TResult>
+{
+	static override readonly [entityKind]: string = 'MySqlEffectRelationalQueryV2';
+
+	declare protected session: MySqlEffectSession<TEffectHKT, any, any>;
+
+	prepare() {
+		const { query, builtQuery } = this._toSQL();
+		const mapper = this.dialect.mapperGenerators.relationalRows({
+			isFirst: this.mode === 'first',
+			parseJson: false,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			arrayModeRoot: true,
+			selection: query.selection,
+		});
+
+		return this.session.prepareQuery(
+			builtQuery,
+			'arrays',
+			mapper,
+		) as MySqlEffectPreparedQuery<MySqlPreparedQueryConfig & { execute: TResult }, TEffectHKT>;
+	}
+
+	execute() {
+		return this.prepare().execute();
+	}
+}
+
+applyEffectWrapper(MySqlEffectRelationalQuery);
diff --git a/drizzle-orm/src/mysql-core/effect/raw.ts b/drizzle-orm/src/mysql-core/effect/raw.ts
new file mode 100644
index 0000000000..00bc54fae0
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/raw.ts
@@ -0,0 +1,48 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { MySqlRaw } from '../query-builders/raw.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlEffectPreparedQuery } from './session.ts';
+
+export interface MySqlEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlRaw<TResult>, QueryEffectKind<TEffectHKT, TResult>, RunnableQuery<TResult, 'mysql'>, SQLWrapper
+{}
+
+export class MySqlEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlRaw<TResult>
+	implements RunnableQuery<TResult, 'mysql'>, SQLWrapper
+{
+	static override readonly [entityKind]: string = 'MySqlEffectRaw';
+
+	declare protected prepared: MySqlEffectPreparedQuery<
+		MySqlPreparedQueryConfig & {
+			execute: TResult;
+		},
+		TEffectHKT
+	>;
+
+	constructor(
+		prepared: MySqlEffectPreparedQuery<
+			MySqlPreparedQueryConfig & {
+				execute: TResult;
+			},
+			TEffectHKT
+		>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.prepared.execute(placeholderValues);
+	}
+
+	override _prepare() {
+		return this.prepared;
+	}
+}
+
+applyEffectWrapper(MySqlEffectRaw);
diff --git a/drizzle-orm/src/mysql-core/effect/select.ts b/drizzle-orm/src/mysql-core/effect/select.ts
new file mode 100644
index 0000000000..72fe35a6a0
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/select.ts
@@ -0,0 +1,128 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+import { MySqlSelectBase, type MySqlSelectBuilder } from '../query-builders/select.ts';
+import type { MySqlSelectHKTBase, SelectedFields } from '../query-builders/select.types.ts';
+import type { MySqlPreparedQueryConfig } from '../session.ts';
+import type { MySqlEffectPreparedQuery, MySqlEffectSession } from './session.ts';
+
+export type MySqlEffectSelectPrepare<
+	T extends AnyMySqlEffectSelect,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: T['_']['result'];
+		iterator: T['_']['result'][number];
+	},
+	TEffectHKT
+>;
+
+export type MySqlEffectSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlSelectBuilder<TSelection, MySqlEffectSelectHKT<TEffectHKT>>;
+
+export type MySqlEffectSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlEffectSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export interface MySqlEffectSelectHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlSelectHKTBase
+{
+	_type: MySqlEffectSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>,
+		TEffectHKT
+	>;
+}
+
+export interface MySqlEffectSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends Effect.Effect<TResult, TEffectHKT['error'], TEffectHKT['context']> {
+}
+
+export class MySqlEffectSelectBase<
+	TTableName extends string | undefined,
+	TSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends MySqlSelectBase<
+	MySqlEffectSelectHKT<TEffectHKT>,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'MySqlEffectSelectQueryBuilder';
+
+	declare readonly session: MySqlEffectSession<TEffectHKT, any, any>;
+
+	prepare(): MySqlEffectSelectPrepare<this, TEffectHKT> {
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+		const preparedQuery = this.session.prepareQuery<
+			MySqlPreparedQueryConfig & { execute: any }
+		>(query, 'arrays', mapper, {
+			type: 'select',
+			tables: [...this.usedTables],
+		}, this.cacheConfig);
+
+		return preparedQuery as MySqlEffectSelectPrepare<this, TEffectHKT>;
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this.prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(MySqlEffectSelectBase);
+
+export type AnyMySqlEffectSelect = MySqlEffectSelectBase<any, any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/mysql-core/effect/session.ts b/drizzle-orm/src/mysql-core/effect/session.ts
new file mode 100644
index 0000000000..e5a0df7edb
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/session.ts
@@ -0,0 +1,300 @@
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import { EffectCache, type EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import { NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase, QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/effect-mysql.ts';
+import { assertUnreachable } from '~/utils.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import {
+	MySqlBasePreparedQuery,
+	type MySqlPreparedQueryConfig,
+	type MySqlQueryResultHKT,
+	MySqlSession,
+	type MySqlTransactionConfig,
+} from '../session.ts';
+import { MySqlEffectDatabase } from './db.ts';
+
+export class MySqlEffectPreparedQuery<
+	T extends MySqlPreparedQueryConfig,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends MySqlBasePreparedQuery {
+	static override readonly [entityKind]: string = 'MySqlEffectPreparedQuery';
+
+	/** @internal */
+	readonly mapper: {
+		(rows: any[]): any;
+		body?: string;
+	} | undefined;
+
+	constructor(
+		protected executor: (params?: unknown[]) => Effect.Effect<unknown, unknown, unknown>,
+		query: Query,
+		mapper: ((rows: any[]) => any) | undefined,
+		readonly mode: 'arrays' | 'objects' | 'raw',
+		private logger: EffectLoggerShape,
+		// cache instance
+		protected cache: EffectCacheShape,
+		// per query related metadata
+		protected queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		protected cacheConfig: WithCacheConfig | undefined,
+	) {
+		super(query);
+		this.mapper = mapper;
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+	}
+
+	override execute(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['execute']> {
+		return Effect.gen({ self: this }, function*() {
+			const { query, mapper, logger } = this;
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+
+			yield* logger.logQuery(sql, params);
+
+			const result = this.queryWithCache(sql, params, Effect.suspend(() => this.executor(params)));
+
+			if (!mapper) return yield* result;
+
+			return yield* result.pipe(Effect.map((rows) => mapper(rows as unknown[])));
+		});
+	}
+
+	/** @internal */
+	protected queryWithCache<A, E, R>(
+		queryString: string,
+		params: any[],
+		query: Effect.Effect<A, E, R>,
+	) {
+		return Effect.gen({ self: this }, function*() {
+			const { cacheConfig, queryMetadata } = this;
+			const cache = yield* EffectCache;
+
+			const cacheStrat: Awaited<ReturnType<typeof strategyFor>> = cache && !(cache.cache && is(cache.cache, NoopCache))
+				? yield* Effect.tryPromise(
+					() => strategyFor(queryString, params, queryMetadata, cacheConfig),
+				)
+				: { type: 'skip' as const };
+
+			if (cacheStrat.type === 'skip') {
+				return yield* query;
+			}
+
+			// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+			if (cacheStrat.type === 'invalidate') {
+				const result = yield* query;
+				yield* cache!.onMutate({ tables: cacheStrat.tables });
+
+				return result;
+			}
+
+			if (cacheStrat.type === 'try') {
+				const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+				const fromCache: any[] | undefined = yield* cache!.get(
+					key,
+					tables,
+					isTag,
+					autoInvalidate,
+				);
+
+				if (typeof fromCache !== 'undefined') return fromCache as unknown as A;
+
+				const result = yield* query;
+
+				yield* cache!.put(
+					key,
+					result,
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+
+				return result;
+			}
+
+			assertUnreachable(cacheStrat);
+		}).pipe(
+			Effect.provideService(EffectCache, this.cache),
+			Effect.catch((e) => {
+				return Effect.fail(new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) }));
+			}),
+		);
+	}
+}
+
+export abstract class MySqlEffectSession<
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlSession {
+	static override readonly [entityKind]: string = 'MySqlEffectSession';
+
+	constructor(dialect: MySqlDialect) {
+		super(dialect);
+	}
+
+	abstract override prepareQuery<T extends MySqlPreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (rows: any) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): MySqlEffectPreparedQuery<T, TEffectHKT>;
+
+	override execute<T>(query: SQL) {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T }>(
+			this.dialect.sqlToQuery(query),
+			'raw',
+		).execute();
+	}
+
+	override arrays<T>(query: SQL) {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'arrays',
+		).execute();
+	}
+
+	override objects<T>(query: SQL) {
+		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'objects',
+		).execute();
+	}
+
+	abstract transaction<A, E, R>(
+		transaction: (
+			tx: MySqlEffectTransaction<TEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+		config?: MySqlTransactionConfig,
+	): Effect.Effect<A, E | SqlError, R>;
+}
+
+export abstract class MySqlEffectTransaction<
+	TEffectHKT extends QueryEffectHKTBase,
+	TQueryResult extends MySqlQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlEffectDatabase<TEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'MySqlEffectTransaction';
+
+	constructor(
+		dialect: MySqlDialect,
+		session: MySqlEffectSession<TEffectHKT, any, any>,
+		protected relations: TRelations,
+		protected readonly nestedIndex = 0,
+	) {
+		super(dialect, session, relations);
+	}
+
+	rollback() {
+		return new EffectTransactionRollbackError();
+	}
+
+	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
+	abstract override transaction<A, E, R>(
+		transaction: (
+			tx: MySqlEffectTransaction<TEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R>;
+}
+
+export const migrate = Effect.fn('migrate')(function*<TEffectHKT extends QueryEffectHKTBase>(
+	migrations: MigrationMeta[],
+	session: MySqlEffectSession<TEffectHKT>,
+	config: Omit<MigrationConfig, 'migrationsSchema'>,
+) {
+	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
+
+	const { newDb } = yield* upgradeIfNeeded(migrationsTable, session, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash TEXT NOT NULL,
+				created_at BIGINT,
+				name TEXT,
+				applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+			)
+		`;
+		yield* session.execute(migrationTableCreate);
+	}
+
+	const dbMigrations = yield* session.objects<{
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return yield* new MigratorInitError({ exitCode: 'databaseMigrations' });
+		}
+
+		if (migrations.length > 1) {
+			return yield* new MigratorInitError({ exitCode: 'localMigrations' });
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		yield* session.execute(
+			sql`insert into ${
+				sql.identifier(
+					migrationsTable,
+				)
+			} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({
+		localMigrations: migrations,
+		dbMigrations,
+	});
+
+	yield* session.transaction((tx) =>
+		Effect.gen(function*() {
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					yield* tx.execute(sql.raw(stmt));
+				}
+				yield* tx.execute(
+					sql`insert into ${
+						sql.identifier(
+							migrationsTable,
+						)
+					} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+				);
+			}
+		})
+	);
+});
diff --git a/drizzle-orm/src/mysql-core/effect/update.ts b/drizzle-orm/src/mysql-core/effect/update.ts
new file mode 100644
index 0000000000..581842e01b
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/update.ts
@@ -0,0 +1,81 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import { MySqlUpdateBase, type MySqlUpdateHKTBase } from '~/mysql-core/query-builders/update.ts';
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlTable } from '~/mysql-core/table.ts';
+import type { Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { MySqlEffectPreparedQuery, MySqlEffectSession } from './session.ts';
+
+export type MySqlEffectUpdate<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectUpdateBase<TTable, TQueryResult, true, never, TEffectHKT>;
+
+export type MySqlEffectUpdatePrepare<
+	T extends AnyMySqlEffectUpdate,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = MySqlEffectPreparedQuery<
+	MySqlPreparedQueryConfig & {
+		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	},
+	TEffectHKT
+>;
+
+export type AnyMySqlEffectUpdate = MySqlEffectUpdateBase<any, any, any, any, any>;
+
+export interface MySqlEffectUpdateHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends MySqlUpdateHKTBase
+{
+	_type: MySqlEffectUpdateBase<
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export interface MySqlEffectUpdateBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends Effect.Effect<MySqlQueryResultKind<TQueryResult, never>, TEffectHKT['error'], TEffectHKT['context']> {}
+
+export class MySqlEffectUpdateBase<
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends MySqlUpdateBase<MySqlEffectUpdateHKT<TEffectHKT>, TTable, TQueryResult, TDynamic, TExcludedMethods> {
+	static override readonly [entityKind]: string = 'MySqlEffectUpdate';
+
+	declare protected session: MySqlEffectSession<TEffectHKT, TQueryResult, any>;
+
+	prepare(): MySqlEffectUpdatePrepare<this, TEffectHKT> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'raw',
+			undefined,
+			{
+				type: 'update',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as MySqlEffectUpdatePrepare<this, TEffectHKT>;
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(MySqlEffectUpdateBase);
diff --git a/drizzle-orm/src/mysql-core/effect/utils.ts b/drizzle-orm/src/mysql-core/effect/utils.ts
new file mode 100644
index 0000000000..1fad689ad1
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/effect/utils.ts
@@ -0,0 +1,6 @@
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleMySqlConfig } from '../utils.ts';
+
+export type EffectDrizzleMySqlConfig<
+	TRelations extends AnyRelations = EmptyRelations,
+> = Omit<DrizzleMySqlConfig<TRelations>, 'cache' | 'logger'>;
diff --git a/drizzle-orm/src/mysql-core/foreign-keys.ts b/drizzle-orm/src/mysql-core/foreign-keys.ts
index c8c34d6fd4..1a78ddfdf3 100644
--- a/drizzle-orm/src/mysql-core/foreign-keys.ts
+++ b/drizzle-orm/src/mysql-core/foreign-keys.ts
@@ -88,6 +88,10 @@ export class ForeignKey {
 		];
 		return name ?? `${chunks.join('_')}_fk`;
 	}
+
+	isNameExplicit(): boolean {
+		return this.reference().name ? true : false;
+	}
 }
 
 type ColumnsWithTable<
diff --git a/drizzle-orm/src/mysql-core/index.ts b/drizzle-orm/src/mysql-core/index.ts
index 204e0af3c4..f5bda0c029 100644
--- a/drizzle-orm/src/mysql-core/index.ts
+++ b/drizzle-orm/src/mysql-core/index.ts
@@ -1,7 +1,8 @@
 export * from './alias.ts';
+export * from './async/index.ts';
+export * from './casing.ts';
 export * from './checks.ts';
 export * from './columns/index.ts';
-export * from './db.ts';
 export * from './dialect.ts';
 export * from './foreign-keys.ts';
 export * from './indexes.ts';
diff --git a/drizzle-orm/src/mysql-core/indexes.ts b/drizzle-orm/src/mysql-core/indexes.ts
index 5b73b1d309..000542be70 100644
--- a/drizzle-orm/src/mysql-core/indexes.ts
+++ b/drizzle-orm/src/mysql-core/indexes.ts
@@ -19,9 +19,9 @@ interface IndexConfig {
 	using?: 'btree' | 'hash';
 
 	/**
-	 * If set, the index will be created as `create index ... algorythm { 'default' | 'inplace' | 'copy' }`.
+	 * If set, the index will be created as `create index ... algorithm { 'default' | 'inplace' | 'copy' }`.
 	 */
-	algorythm?: 'default' | 'inplace' | 'copy';
+	algorithm?: 'default' | 'inplace' | 'copy';
 
 	/**
 	 * If set, adds locks to the index creation.
@@ -67,8 +67,8 @@ export class IndexBuilder implements AnyIndexBuilder {
 		return this;
 	}
 
-	algorythm(algorythm: IndexConfig['algorythm']): this {
-		this.config.algorythm = algorythm;
+	algorithm(algorithm: IndexConfig['algorithm']): this {
+		this.config.algorithm = algorithm;
 		return this;
 	}
 
@@ -87,9 +87,11 @@ export class Index {
 	static readonly [entityKind]: string = 'MySqlIndex';
 
 	readonly config: IndexConfig & { table: MySqlTable };
+	readonly isNameExplicit: boolean;
 
 	constructor(config: IndexConfig, table: MySqlTable) {
 		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
 	}
 }
 
diff --git a/drizzle-orm/src/mysql-core/primary-keys.ts b/drizzle-orm/src/mysql-core/primary-keys.ts
index 014cbd8c0b..a3e60993cd 100644
--- a/drizzle-orm/src/mysql-core/primary-keys.ts
+++ b/drizzle-orm/src/mysql-core/primary-keys.ts
@@ -1,12 +1,12 @@
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
-import { MySqlTable } from './table.ts';
+import type { MySqlTable } from './table.ts';
 
 export function primaryKey<
 	TTableName extends string,
 	TColumn extends AnyMySqlColumn<{ tableName: TTableName }>,
 	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
->(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
+>(config: { columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
  * @param columns
@@ -17,7 +17,7 @@ export function primaryKey<
 >(...columns: TColumns): PrimaryKeyBuilder;
 export function primaryKey(...config: any) {
 	if (config[0].columns) {
-		return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+		return new PrimaryKeyBuilder(config[0].columns);
 	}
 	return new PrimaryKeyBuilder(config);
 }
@@ -28,20 +28,15 @@ export class PrimaryKeyBuilder {
 	/** @internal */
 	columns: MySqlColumn[];
 
-	/** @internal */
-	name?: string;
-
 	constructor(
 		columns: MySqlColumn[],
-		name?: string,
 	) {
 		this.columns = columns;
-		this.name = name;
 	}
 
 	/** @internal */
 	build(table: MySqlTable): PrimaryKey {
-		return new PrimaryKey(table, this.columns, this.name);
+		return new PrimaryKey(table, this.columns);
 	}
 }
 
@@ -49,15 +44,8 @@ export class PrimaryKey {
 	static readonly [entityKind]: string = 'MySqlPrimaryKey';
 
 	readonly columns: MySqlColumn[];
-	readonly name?: string;
 
-	constructor(readonly table: MySqlTable, columns: MySqlColumn[], name?: string) {
+	constructor(readonly table: MySqlTable, columns: MySqlColumn[]) {
 		this.columns = columns;
-		this.name = name;
-	}
-
-	getName(): string {
-		return this.name
-			?? `${this.table[MySqlTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/drizzle-orm/src/mysql-core/query-builders/count.ts b/drizzle-orm/src/mysql-core/query-builders/count.ts
index 9a0241c70e..f9be4fdb38 100644
--- a/drizzle-orm/src/mysql-core/query-builders/count.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/count.ts
@@ -1,79 +1,48 @@
 import { entityKind } from '~/entity.ts';
-import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import type { MySqlSession } from '../session.ts';
+import { type Query, SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import type { MySqlDialect } from '../dialect.ts';
 import type { MySqlTable } from '../table.ts';
 import type { MySqlViewBase } from '../view-base.ts';
 
-export class MySqlCountBuilder<
-	TSession extends MySqlSession<any, any, any>,
-> extends SQL<number> implements Promise<number>, SQLWrapper {
-	private sql: SQL<number>;
+export class MySqlCountBuilder extends SQL<number> implements SQLWrapper<number> {
+	static override readonly [entityKind]: string = 'MySqlCountBuilder';
 
-	static override readonly [entityKind] = 'MySqlCountBuilder';
-	[Symbol.toStringTag] = 'MySqlCountBuilder';
-
-	private session: TSession;
-
-	private static buildEmbeddedCount(
-		source: MySqlTable | MySqlViewBase | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	): SQL<number> {
-		return sql<number>`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
-	}
+	private dialect: MySqlDialect;
 
 	private static buildCount(
 		source: MySqlTable | MySqlViewBase | SQL | SQLWrapper,
 		filters?: SQL<unknown>,
+		parens?: boolean,
 	): SQL<number> {
-		return sql<number>`select count(*) as count from ${source}${sql.raw(' where ').if(filters)}${filters}`;
+		const where = sql` where ${filters}`.if(filters);
+		const query = sql<number>`select count(*) from ${source}${where}`;
+
+		return parens ? sql`(${query})` : query;
 	}
 
 	constructor(
-		readonly params: {
+		protected countConfig: {
 			source: MySqlTable | MySqlViewBase | SQL | SQLWrapper;
 			filters?: SQL<unknown>;
-			session: TSession;
+			dialect: MySqlDialect;
 		},
 	) {
-		super(MySqlCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-
-		this.mapWith(Number);
-
-		this.session = params.session;
+		super(MySqlCountBuilder.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+		this.dialect = countConfig.dialect;
+		this.mapWith((e) => {
+			if (typeof e === 'number') return e;
 
-		this.sql = MySqlCountBuilder.buildCount(
-			params.source,
-			params.filters,
-		);
+			return Number(e ?? 0);
+		});
 	}
 
-	then<TResult1 = number, TResult2 = never>(
-		onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined,
-	): Promise<TResult1 | TResult2> {
-		return Promise.resolve(this.session.count(this.sql))
-			.then(
-				onfulfilled,
-				onrejected,
-			);
-	}
-
-	catch(
-		onRejected?: ((reason: any) => never | PromiseLike<never>) | null | undefined,
-	): Promise<number> {
-		return this.then(undefined, onRejected);
-	}
+	private executableSql: SQL<number> | undefined;
+	protected build(): Query {
+		if (!this.executableSql) {
+			const { source, filters } = this.countConfig;
+			this.executableSql = MySqlCountBuilder.buildCount(source, filters);
+		}
 
-	finally(onFinally?: (() => void) | null | undefined): Promise<number> {
-		return this.then(
-			(value) => {
-				onFinally?.();
-				return value;
-			},
-			(reason) => {
-				onFinally?.();
-				throw reason;
-			},
-		);
+		return this.dialect.sqlToQuery(this.executableSql);
 	}
 }
diff --git a/drizzle-orm/src/mysql-core/query-builders/delete.ts b/drizzle-orm/src/mysql-core/query-builders/delete.ts
index 8d00a0f643..0928fa7143 100644
--- a/drizzle-orm/src/mysql-core/query-builders/delete.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/delete.ts
@@ -1,35 +1,25 @@
 import { entityKind } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
+import type { AnyMySqlQueryResultHKT, MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { MySqlSession } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
-import { QueryPromise } from '~/query-promise.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { type CommentInput, type Placeholder, type Query, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import type { ValueOrArray } from '~/utils.ts';
+import type { Assume, ValueOrArray } from '~/utils.ts';
 import type { MySqlColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
-import type { SelectedFieldsOrdered } from './select.types.ts';
 
 export type MySqlDeleteWithout<
-	T extends AnyMySqlDeleteBase,
+	T extends AnyMySqlDelete,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T
 	: Omit<
-		MySqlDeleteBase<
+		MySqlDeleteKind<
+			T['_']['hkt'],
 			T['_']['table'],
 			T['_']['queryResult'],
-			T['_']['preparedQueryHKT'],
 			TDynamic,
 			T['_']['excludedMethods'] | K
 		>,
@@ -39,71 +29,94 @@ export type MySqlDeleteWithout<
 export type MySqlDelete<
 	TTable extends MySqlTable = MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-> = MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+> = MySqlDeleteBase<MySqlDeleteHKT, TTable, TQueryResult, true, never>;
 
 export interface MySqlDeleteConfig {
 	where?: SQL | undefined;
 	limit?: number | Placeholder;
 	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
 	table: MySqlTable;
-	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
+	comment?: SQL;
 }
 
-export type MySqlDeletePrepare<T extends AnyMySqlDeleteBase> = PreparedQueryKind<
-	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
-		iterator: never;
-	},
-	true
->;
-
-type MySqlDeleteDynamic<T extends AnyMySqlDeleteBase> = MySqlDelete<
+export type MySqlDeleteDynamic<T extends AnyMySqlDelete> = MySqlDeleteKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
-	T['_']['preparedQueryHKT']
+	true,
+	never
 >;
 
-type AnyMySqlDeleteBase = MySqlDeleteBase<any, any, any, any, any>;
+export type AnyMySqlDelete = MySqlDeleteBase<any, any, any, any, any>;
+
+export interface MySqlDeleteHKTBase {
+	table: unknown;
+	queryResult: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	_type: unknown;
+}
+
+export interface MySqlDeleteHKT extends MySqlDeleteHKTBase {
+	_type: MySqlDeleteBase<
+		MySqlDeleteHKT,
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type MySqlDeleteKind<
+	T extends MySqlDeleteHKTBase,
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	queryResult: TQueryResult;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
 
 export interface MySqlDeleteBase<
+	THKT extends MySqlDeleteHKTBase,
 	TTable extends MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> {
+> extends SQLWrapper {
 	readonly _: {
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
 	};
 }
 
 export class MySqlDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends MySqlDeleteHKTBase,
 	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TQueryResult extends MySqlQueryResultHKT,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> implements SQLWrapper {
-	static override readonly [entityKind]: string = 'MySqlDelete';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'MySqlDelete';
 
-	private config: MySqlDeleteConfig;
+	protected config: MySqlDeleteConfig;
 
 	constructor(
 		private table: TTable,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		protected session: MySqlSession,
+		protected dialect: MySqlDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { table, withList };
 	}
 
@@ -172,43 +185,22 @@ export class MySqlDeleteBase<
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): MySqlDeleteWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
 		return this.dialect.buildDeleteQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	prepare(): MySqlDeletePrepare<this> {
-		return this.session.prepareQuery(
-			this.dialect.sqlToQuery(this.getSQL()),
-			this.config.returning,
-			undefined,
-			undefined,
-			undefined,
-			{
-				type: 'delete',
-				tables: extractUsedTable(this.config.table),
-			},
-		) as MySqlDeletePrepare<this>;
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return this.prepare().execute(placeholderValues);
-	};
-
-	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
-		const self = this;
-		return async function*(placeholderValues) {
-			yield* self.prepare().iterator(placeholderValues);
-		};
-	};
-
-	iterator = this.createIterator();
-
 	$dynamic(): MySqlDeleteDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/mysql-core/query-builders/insert.ts b/drizzle-orm/src/mysql-core/query-builders/insert.ts
index f2b8153ac7..6fac3437a4 100644
--- a/drizzle-orm/src/mysql-core/query-builders/insert.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/insert.ts
@@ -1,55 +1,83 @@
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
+import type { AnyMySqlQueryResultHKT, MySqlQueryResultHKT, MySqlQueryResultKind } from '~/mysql-core/session.ts';
+import type { MySqlSession } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import type { CommentInput, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Param, SQL, sql } from '~/sql/sql.ts';
-import type { InferModelFromColumns } from '~/table.ts';
-import { Columns, Table } from '~/table.ts';
-import { haveSameKeys, mapUpdateSet } from '~/utils.ts';
+import type { InferInsertModel, InferModelFromColumns } from '~/table.ts';
+import { Table } from '~/table.ts';
+import { type Assume, type DrizzleTypeError, mapUpdateSet } from '~/utils.ts';
 import type { AnyMySqlColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import { QueryBuilder } from './query-builder.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 import type { MySqlUpdateSetSource } from './update.ts';
 
 export interface MySqlInsertConfig<TTable extends MySqlTable = MySqlTable> {
 	table: TTable;
-	values: Record<string, Param | SQL>[] | MySqlInsertSelectQueryBuilder<TTable> | SQL;
+	values: Record<string, Param | SQL>[] | TypedQueryBuilder<MySqlInsertSelection<TTable>> | SQL;
 	ignore: boolean;
 	onConflict?: SQL;
 	returning?: SelectedFieldsOrdered;
 	select?: boolean;
+	comment?: SQL;
 }
 
 export type AnyMySqlInsertConfig = MySqlInsertConfig<MySqlTable>;
 
-export type MySqlInsertValue<TTable extends MySqlTable> =
+export type MySqlInsertValue<
+	TTable extends MySqlTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
+		[Key in keyof TModel]: TModel[Key] | SQL | Placeholder;
 	}
 	& {};
 
-export type MySqlInsertSelectQueryBuilder<TTable extends MySqlTable> = TypedQueryBuilder<
-	{ [K in keyof TTable['$inferInsert']]: AnyMySqlColumn | SQL | SQL.Aliased | TTable['$inferInsert'][K] }
->;
+export type MySqlInsertSelection<
+	TTable extends MySqlTable,
+	TModel extends Record<string, unknown> = InferInsertModel<TTable>,
+> =
+	& {
+		[K in keyof TModel]:
+			| AnyMySqlColumn
+			| SQL
+			| SQL.Aliased
+			| TModel[K];
+	}
+	& {};
+
+export type NoUnknownKeysInInsertSelection<
+	TTable extends MySqlTable,
+	TSelection extends MySqlInsertSelection<any>,
+> = {
+	[K in keyof TSelection]: K extends keyof InferInsertModel<TTable> ? TSelection[K]
+		: K extends keyof InferInsertModel<TTable, { override: true }> ? DrizzleTypeError<
+				`Column "${
+					& K
+					& string}" in table "${TTable['_'][
+					'name'
+				]}" is a generated column - manual value insertion restricted`
+			>
+		: DrizzleTypeError<`Column "${K & string}" does not exist in table "${TTable['_']['name']}"`>;
+};
+
+export interface MySqlInsertBuilderConstructor {
+	new(
+		table: MySqlTable,
+		values: MySqlInsertConfig['values'],
+		ignore: boolean,
+		session: MySqlSession,
+		dialect: MySqlDialect,
+		select?: boolean,
+	): AnyMySqlInsert;
+}
 
 export class MySqlInsertBuilder<
 	TTable extends MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBuilderHKT extends MySqlInsertHKTBase = MySqlInsertHKT,
 > {
 	static readonly [entityKind]: string = 'MySqlInsertBuilder';
 
@@ -59,6 +87,7 @@ export class MySqlInsertBuilder<
 		private table: TTable,
 		private session: MySqlSession,
 		private dialect: MySqlDialect,
+		private builder: MySqlInsertBuilderConstructor = MySqlInsertBase as unknown as MySqlInsertBuilderConstructor,
 	) {}
 
 	ignore(): this {
@@ -66,11 +95,11 @@ export class MySqlInsertBuilder<
 		return this;
 	}
 
-	values(value: MySqlInsertValue<TTable>): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
-	values(values: MySqlInsertValue<TTable>[]): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
+	values(value: MySqlInsertValue<TTable>): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	values(values: MySqlInsertValue<TTable>[]): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
 	values(
 		values: MySqlInsertValue<TTable> | MySqlInsertValue<TTable>[],
-	): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT> {
+	): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -80,72 +109,71 @@ export class MySqlInsertBuilder<
 			const cols = this.table[Table.Symbol.Columns];
 			for (const colKey of Object.keys(entry)) {
 				const colValue = entry[colKey as keyof typeof entry];
-				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
 			}
 			return result;
 		});
 
-		return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
+		return new this.builder(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect) as any;
 	}
 
-	select(
-		selectQuery: (qb: QueryBuilder) => MySqlInsertSelectQueryBuilder<TTable>,
-	): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
-	select(selectQuery: (qb: QueryBuilder) => SQL): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
-	select(selectQuery: SQL): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
-	select(selectQuery: MySqlInsertSelectQueryBuilder<TTable>): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
+	select<TSelection extends MySqlInsertSelection<TTable>>(
+		selectQuery: (qb: QueryBuilder) => TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	select(selectQuery: (qb: QueryBuilder) => SQL): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	select(selectQuery: SQL): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	select<TSelection extends MySqlInsertSelection<TTable>>(
+		selectQuery: TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult>;
 	select(
 		selectQuery:
 			| SQL
-			| MySqlInsertSelectQueryBuilder<TTable>
-			| ((qb: QueryBuilder) => MySqlInsertSelectQueryBuilder<TTable> | SQL),
-	): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT> {
+			| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, MySqlInsertSelection<TTable>>>
+			| ((qb: QueryBuilder) =>
+				| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, MySqlInsertSelection<TTable>>>
+				| SQL),
+	): MySqlInsertKind<TBuilderHKT, TTable, TQueryResult> {
 		const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
-
-		if (
-			!is(select, SQL)
-			&& !haveSameKeys(this.table[Columns], select._.selectedFields)
-		) {
-			throw new Error(
-				'Insert select error: selected fields are not the same or are in a different order compared to the table definition',
-			);
+		if ('withoutSelectionCastCodecs' in select) select.withoutSelectionCastCodecs();
+
+		if (!is(select, SQL)) {
+			const insertCols = Object.keys(this.table[Table.Symbol.Columns]);
+			const selected = Object.keys(select._.selectedFields);
+
+			for (const col of selected) {
+				if (!insertCols.includes(col)) {
+					throw new Error(
+						`Insert select error: column "${col}" does not exist in table "${this.table[Table.Symbol.Name]}"`,
+					);
+				}
+			}
 		}
 
-		return new MySqlInsertBase(this.table, select, this.shouldIgnore, this.session, this.dialect, true);
+		return new this.builder(this.table, select, this.shouldIgnore, this.session, this.dialect, true) as any;
 	}
 }
 
 export type MySqlInsertWithout<T extends AnyMySqlInsert, TDynamic extends boolean, K extends keyof T & string> =
 	TDynamic extends true ? T
 		: Omit<
-			MySqlInsertBase<
+			MySqlInsertKind<
+				T['_']['hkt'],
 				T['_']['table'],
 				T['_']['queryResult'],
-				T['_']['preparedQueryHKT'],
 				T['_']['returning'],
 				TDynamic,
-				T['_']['excludedMethods'] | '$returning'
+				T['_']['excludedMethods'] | K
 			>,
 			T['_']['excludedMethods'] | K
 		>;
 
-export type MySqlInsertDynamic<T extends AnyMySqlInsert> = MySqlInsert<
+export type MySqlInsertDynamic<T extends AnyMySqlInsert> = MySqlInsertKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
-	T['_']['preparedQueryHKT'],
-	T['_']['returning']
->;
-
-export type MySqlInsertPrepare<
-	T extends AnyMySqlInsert,
-	TReturning extends Record<string, unknown> | undefined = undefined,
-> = PreparedQueryKind<
-	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: TReturning extends undefined ? MySqlQueryResultKind<T['_']['queryResult'], never> : TReturning[];
-		iterator: never;
-	},
-	true
+	T['_']['returning'],
+	true,
+	never
 >;
 
 export type MySqlInsertOnDuplicateKeyUpdateConfig<T extends AnyMySqlInsert> = {
@@ -155,41 +183,73 @@ export type MySqlInsertOnDuplicateKeyUpdateConfig<T extends AnyMySqlInsert> = {
 export type MySqlInsert<
 	TTable extends MySqlTable = MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TReturning, true, never>;
-
-export type MySqlInsertReturning<
-	T extends AnyMySqlInsert,
-	TDynamic extends boolean,
-> = MySqlInsertBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['preparedQueryHKT'],
-	InferModelFromColumns<GetPrimarySerialOrDefaultKeys<T['_']['table']['_']['columns']>>,
-	TDynamic,
-	T['_']['excludedMethods'] | '$returning'
->;
+> = MySqlInsertBase<MySqlInsertHKT, TTable, TQueryResult, TReturning, true, never>;
+
+export type MySqlInsertReturning<T extends AnyMySqlInsert> = T extends any ? MySqlInsertWithout<
+		MySqlInsertKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			InferModelFromColumns<GetPrimarySerialOrDefaultKeys<T['_']['table']['_']['columns']>>,
+			T['_']['dynamic'],
+			T['_']['excludedMethods']
+		>,
+		T['_']['dynamic'],
+		'$returningId'
+	>
+	: never;
 
 export type AnyMySqlInsert = MySqlInsertBase<any, any, any, any, any, any>;
 
+export interface MySqlInsertHKTBase {
+	table: unknown;
+	queryResult: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	_type: unknown;
+}
+
+export interface MySqlInsertHKT extends MySqlInsertHKTBase {
+	_type: MySqlInsertBase<
+		MySqlInsertHKT,
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type MySqlInsertKind<
+	T extends MySqlInsertHKTBase,
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	queryResult: TQueryResult;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
+
 export interface MySqlInsertBase<
+	THKT extends MySqlInsertHKTBase,
 	TTable extends MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TReturning extends Record<string, unknown> | undefined = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends
-	QueryPromise<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>,
-	SQLWrapper
-{
+> extends SQLWrapper {
 	readonly _: {
 		readonly dialect: 'mysql';
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
 		readonly returning: TReturning;
@@ -210,37 +270,31 @@ export type GetPrimarySerialOrDefaultKeys<T extends Record<string, AnyMySqlColum
 };
 
 export class MySqlInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends MySqlInsertHKTBase,
 	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TQueryResult extends MySqlQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TReturning extends Record<string, unknown> | undefined = undefined,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>,
-		SQLWrapper
-{
-	static override readonly [entityKind]: string = 'MySqlInsert';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'MySqlInsert';
 
 	declare protected $table: TTable;
 
-	private config: MySqlInsertConfig<TTable>;
-	protected cacheConfig?: WithCacheConfig;
+	protected config: MySqlInsertConfig<TTable>;
 
 	constructor(
 		table: TTable,
 		values: MySqlInsertConfig['values'],
 		ignore: boolean,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		protected session: MySqlSession,
+		protected dialect: MySqlDialect,
 		select?: boolean,
 	) {
-		super();
 		this.config = { table, values: values as any, select, ignore };
 	}
 
@@ -278,11 +332,7 @@ export class MySqlInsertBase<
 		return this as any;
 	}
 
-	$returningId(): MySqlInsertWithout<
-		MySqlInsertReturning<this, TDynamic>,
-		TDynamic,
-		'$returningId'
-	> {
+	$returningId(): MySqlInsertReturning<this> {
 		const returning: SelectedFieldsOrdered = [];
 		for (const [key, value] of Object.entries(this.config.table[Table.Symbol.Columns])) {
 			if (value.primary) {
@@ -293,45 +343,22 @@ export class MySqlInsertBase<
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): MySqlInsertWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
 		return this.dialect.buildInsertQuery(this.config).sql;
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	prepare(): MySqlInsertPrepare<this, TReturning> {
-		const { sql, generatedIds } = this.dialect.buildInsertQuery(this.config);
-		return this.session.prepareQuery(
-			this.dialect.sqlToQuery(sql),
-			undefined,
-			undefined,
-			generatedIds,
-			this.config.returning,
-			{
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			},
-			this.cacheConfig,
-		) as MySqlInsertPrepare<this, TReturning>;
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return this.prepare().execute(placeholderValues);
-	};
-
-	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
-		const self = this;
-		return async function*(placeholderValues) {
-			yield* self.prepare().iterator(placeholderValues);
-		};
-	};
-
-	iterator = this.createIterator();
-
 	$dynamic(): MySqlInsertDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
index 5c144d48fb..9000792979 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
@@ -34,7 +34,7 @@ export class QueryBuilder {
 
 			return new Proxy(
 				new WithSubquery(
-					qb.getSQL(),
+					('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL(),
 					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
 					alias,
 					true,
@@ -48,13 +48,13 @@ export class QueryBuilder {
 	with(...queries: WithSubquery[]) {
 		const self = this;
 
-		function select(): MySqlSelectBuilder<undefined, never, 'qb'>;
+		function select(): MySqlSelectBuilder<undefined>;
 		function select<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, never, 'qb'>;
+		): MySqlSelectBuilder<TSelection>;
 		function select<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+		): MySqlSelectBuilder<TSelection | undefined> {
 			return new MySqlSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -63,13 +63,13 @@ export class QueryBuilder {
 			});
 		}
 
-		function selectDistinct(): MySqlSelectBuilder<undefined, never, 'qb'>;
+		function selectDistinct(): MySqlSelectBuilder<undefined>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, never, 'qb'>;
+		): MySqlSelectBuilder<TSelection>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+		): MySqlSelectBuilder<TSelection | undefined> {
 			return new MySqlSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -82,21 +82,21 @@ export class QueryBuilder {
 		return { select, selectDistinct };
 	}
 
-	select(): MySqlSelectBuilder<undefined, never, 'qb'>;
-	select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, never, 'qb'>;
+	select(): MySqlSelectBuilder<undefined>;
+	select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection>;
 	select<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+	): MySqlSelectBuilder<TSelection | undefined> {
 		return new MySqlSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
 	}
 
-	selectDistinct(): MySqlSelectBuilder<undefined, never, 'qb'>;
+	selectDistinct(): MySqlSelectBuilder<undefined>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields: TSelection,
-	): MySqlSelectBuilder<TSelection, never, 'qb'>;
+	): MySqlSelectBuilder<TSelection>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
+	): MySqlSelectBuilder<TSelection | undefined> {
 		return new MySqlSelectBuilder({
 			fields: fields ?? undefined,
 			session: undefined,
diff --git a/drizzle-orm/src/mysql-core/query-builders/query.ts b/drizzle-orm/src/mysql-core/query-builders/query.ts
index 16d2945981..28d50097e2 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query.ts
@@ -1,157 +1,136 @@
 import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import {
-	type BuildQueryResult,
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	mapRelationalRow,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
+import type {
+	BuildQueryResult,
+	BuildRelationalQueryResult,
+	DBQueryConfigWithComment,
+	TableRelationalConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
-import type { Query, QueryWithTypings, SQL } from '~/sql/sql.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { MySqlDialect } from '../dialect.ts';
-import type {
-	Mode,
-	MySqlPreparedQueryConfig,
-	MySqlSession,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '../session.ts';
+import type { MySqlSession } from '../session.ts';
 import type { MySqlTable } from '../table.ts';
+import type { MySqlView } from '../view.ts';
+
+export interface MySqlRelationalQueryConstructor {
+	new(
+		schema: TablesRelationalConfig,
+		table: MySqlTable | MySqlView,
+		tableConfig: TableRelationalConfig,
+		dialect: MySqlDialect,
+		session: MySqlSession,
+		config: DBQueryConfigWithComment<'many' | 'one'> | true,
+		mode: 'many' | 'first',
+	): AnyMySqlRelationalQuery;
+}
+
+export type AnyMySqlRelationalQuery = MySqlRelationalQuery<any, any>;
 
 export class RelationalQueryBuilder<
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TSchema extends TablesRelationalConfig,
 	TFields extends TableRelationalConfig,
+	TBuilderHKT extends MySqlRelationalQueryHKTBase = MySqlRelationalQueryHKT,
 > {
-	static readonly [entityKind]: string = 'MySqlRelationalQueryBuilder';
+	static readonly [entityKind]: string = 'MySqlRelationalQueryBuilderV2';
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
 		private schema: TSchema,
-		private tableNamesMap: Record<string, string>,
-		private table: MySqlTable,
+		private table: MySqlTable | MySqlView,
 		private tableConfig: TableRelationalConfig,
 		private dialect: MySqlDialect,
 		private session: MySqlSession,
-		private mode: Mode,
+		private builder: MySqlRelationalQueryConstructor = MySqlRelationalQuery,
 	) {}
 
-	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
-		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
-	): MySqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
-		return new MySqlRelationalQuery(
-			this.fullSchema,
+	findMany<TConfig extends DBQueryConfigWithComment<'many', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfigWithComment<'many', TSchema, TFields>>,
+	): MySqlRelationalQueryKind<TBuilderHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new this.builder(
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? (config as DBQueryConfig<'many', true>) : {},
+			config as DBQueryConfigWithComment<'many'> | undefined ?? true,
 			'many',
-			this.mode,
 		);
 	}
 
-	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
-		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
-	): MySqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
-		return new MySqlRelationalQuery(
-			this.fullSchema,
+	findFirst<TSelection extends DBQueryConfigWithComment<'one', TSchema, TFields>>(
+		config?: KnownKeysOnly<TSelection, DBQueryConfigWithComment<'one', TSchema, TFields>>,
+	): MySqlRelationalQueryKind<TBuilderHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
+		return new this.builder(
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			config as DBQueryConfigWithComment<'one'> | undefined ?? true,
 			'first',
-			this.mode,
 		);
 	}
 }
 
-export class MySqlRelationalQuery<
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+export interface MySqlRelationalQueryHKTBase {
+	result: unknown;
+	_type: unknown;
+}
+
+export interface MySqlRelationalQueryHKT extends MySqlRelationalQueryHKTBase {
+	_type: MySqlRelationalQuery<MySqlRelationalQueryHKT, this['result']>;
+}
+
+export type MySqlRelationalQueryKind<
+	T extends MySqlRelationalQueryHKTBase,
 	TResult,
-> extends QueryPromise<TResult> {
-	static override readonly [entityKind]: string = 'MySqlRelationalQuery';
+> = (T & {
+	result: TResult;
+})['_type'];
+
+export class MySqlRelationalQuery<THKT extends MySqlRelationalQueryHKTBase, TResult> implements SQLWrapper {
+	static readonly [entityKind]: string = 'MySqlRelationalQueryV2';
+
+	declare readonly _: {
+		readonly hkt: THKT;
+		readonly result: TResult;
+	};
 
 	declare protected $brand: 'MySqlRelationalQuery';
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
-		private schema: TablesRelationalConfig,
-		private tableNamesMap: Record<string, string>,
-		private table: MySqlTable,
-		private tableConfig: TableRelationalConfig,
-		private dialect: MySqlDialect,
-		private session: MySqlSession,
-		private config: DBQueryConfig<'many', true> | true,
-		private queryMode: 'many' | 'first',
-		private mode?: Mode,
-	) {
-		super();
-	}
-
-	prepare() {
-		const { query, builtQuery } = this._toSQL();
-		return this.session.prepareQuery(
-			builtQuery,
-			undefined,
-			(rawRows) => {
-				const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection));
-				if (this.queryMode === 'first') {
-					return rows[0] as TResult;
-				}
-				return rows as TResult;
-			},
-		) as PreparedQueryKind<TPreparedQueryHKT, MySqlPreparedQueryConfig & { execute: TResult }, true>;
-	}
+		protected schema: TablesRelationalConfig,
+		protected table: MySqlTable | MySqlView,
+		protected tableConfig: TableRelationalConfig,
+		protected dialect: MySqlDialect,
+		protected session: MySqlSession,
+		protected config: DBQueryConfigWithComment<'many' | 'one'> | true,
+		protected mode: 'many' | 'first',
+	) {}
 
-	private _getQuery() {
-		const query = this.mode === 'planetscale'
-			? this.dialect.buildRelationalQueryWithoutLateralSubqueries({
-				fullSchema: this.fullSchema,
-				schema: this.schema,
-				tableNamesMap: this.tableNamesMap,
-				table: this.table,
-				tableConfig: this.tableConfig,
-				queryConfig: this.config,
-				tableAlias: this.tableConfig.tsName,
-			})
-			: this.dialect.buildRelationalQuery({
-				fullSchema: this.fullSchema,
-				schema: this.schema,
-				tableNamesMap: this.tableNamesMap,
-				table: this.table,
-				tableConfig: this.tableConfig,
-				queryConfig: this.config,
-				tableAlias: this.tableConfig.tsName,
-			});
-		return query;
+	protected _getQuery() {
+		return this.dialect.buildRelationalQuery({
+			schema: this.schema,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			mode: this.mode,
+		});
 	}
 
-	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
+	protected _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
 		const query = this._getQuery();
 
-		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+		const builtQuery = this.dialect.sqlToQuery(query.sql);
 
 		return { builtQuery, query };
 	}
 
-	/** @internal */
 	getSQL(): SQL {
-		return this._getQuery().sql as SQL;
+		return this._getQuery().sql;
 	}
 
 	toSQL(): Query {
 		return this._toSQL().builtQuery;
 	}
-
-	override execute(): Promise<TResult> {
-		return this.prepare().execute();
-	}
 }
diff --git a/drizzle-orm/src/mysql-core/query-builders/raw.ts b/drizzle-orm/src/mysql-core/query-builders/raw.ts
new file mode 100644
index 0000000000..a13c9bdb66
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/query-builders/raw.ts
@@ -0,0 +1,34 @@
+import { entityKind } from '~/entity.ts';
+import type { PreparedQuery } from '~/session.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { MySqlBasePreparedQuery } from '../session.ts';
+
+// oxlint-disable-next-line no-unused-vars
+export interface MySqlRaw<TResult> extends SQLWrapper {}
+export class MySqlRaw<TResult> implements SQLWrapper, PreparedQuery {
+	static readonly [entityKind]: string = 'MySqlRaw';
+
+	declare readonly _: {
+		readonly dialect: 'mysql';
+		readonly result: TResult;
+	};
+
+	constructor(
+		protected prepared: MySqlBasePreparedQuery,
+		protected sql: SQL,
+		protected query: Query,
+	) {
+	}
+
+	getSQL() {
+		return this.sql;
+	}
+
+	getQuery() {
+		return this.query;
+	}
+
+	_prepare() {
+		return this.prepared;
+	}
+}
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index 478c9c1822..ec33b50b1c 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -2,7 +2,7 @@ import type { CacheConfig, WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { MySqlColumn } from '~/mysql-core/columns/index.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { MySqlPreparedQueryConfig, MySqlSession, PreparedQueryHKTBase } from '~/mysql-core/session.ts';
+import type { MySqlSession } from '~/mysql-core/session.ts';
 import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import { MySqlTable } from '~/mysql-core/table.ts';
 import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
@@ -15,32 +15,32 @@ import type {
 	SelectResult,
 	SetOperator,
 } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { ColumnsSelection, Placeholder, Query } from '~/sql/sql.ts';
-import { SQL, View } from '~/sql/sql.ts';
+import type { ColumnsSelection, CommentInput, Placeholder, Query } from '~/sql/sql.ts';
+import { SQL, sql, View } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import type { ValueOrArray } from '~/utils.ts';
-import { applyMixins, getTableColumns, getTableLikeName, haveSameKeys, orderSelectedFields } from '~/utils.ts';
+import { getTableColumns, getTableLikeName, haveSameKeys, orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { IndexBuilder } from '../indexes.ts';
+import type { UniqueConstraintBuilder } from '../unique-constraint.ts';
 import { convertIndexToString, extractUsedTable, toArray } from '../utils.ts';
 import { MySqlViewBase } from '../view-base.ts';
 import type {
-	AnyMySqlSelect,
-	CreateMySqlSelectFromBuilderMode,
+	AnyMySqlSelectQueryBuilder,
 	GetMySqlSetOperators,
 	LockConfig,
 	LockStrength,
 	MySqlCreateSetOperatorFn,
+	MySqlCrossJoinFn,
 	MySqlJoinFn,
 	MySqlJoinType,
 	MySqlSelectConfig,
 	MySqlSelectDynamic,
-	MySqlSelectHKT,
 	MySqlSelectHKTBase,
-	MySqlSelectPrepare,
+	MySqlSelectKind,
+	MySqlSelectQueryBuilderHKT,
 	MySqlSelectWithout,
 	MySqlSetOperatorExcludedMethods,
 	MySqlSetOperatorWithResult,
@@ -48,7 +48,10 @@ import type {
 	SetOperatorRightSelect,
 } from './select.types.ts';
 
-export type IndexForHint = IndexBuilder | string;
+export type IndexForHint =
+	| IndexBuilder
+	| UniqueConstraintBuilder<string>
+	| string;
 
 export type IndexConfig = {
 	useIndex?: IndexForHint | IndexForHint[];
@@ -56,10 +59,26 @@ export type IndexConfig = {
 	ignoreIndex?: IndexForHint | IndexForHint[];
 };
 
+export interface MySqlSelectBuilderConstructor {
+	new(
+		config: {
+			table: MySqlSelectConfig['table'];
+			fields: MySqlSelectConfig['fields'];
+			isPartialSelect: boolean;
+			session: MySqlSession | undefined;
+			dialect: MySqlDialect;
+			withList: Subquery[];
+			distinct: boolean | undefined;
+			useIndex?: string[];
+			forceIndex?: string[];
+			ignoreIndex?: string[];
+		},
+	): AnyMySqlSelectQueryBuilder;
+}
+
 export class MySqlSelectBuilder<
 	TSelection extends SelectedFields | undefined,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TBuilderMode extends 'db' | 'qb' = 'db',
+	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
 > {
 	static readonly [entityKind]: string = 'MySqlSelectBuilder';
 
@@ -77,6 +96,7 @@ export class MySqlSelectBuilder<
 			withList?: Subquery[];
 			distinct?: boolean;
 		},
+		private builder: MySqlSelectBuilderConstructor = MySqlSelectBase as unknown as MySqlSelectBuilderConstructor,
 	) {
 		this.fields = config.fields;
 		this.session = config.session;
@@ -91,12 +111,14 @@ export class MySqlSelectBuilder<
 		source: TFrom,
 		onIndex?: TFrom extends MySqlTable ? IndexConfig
 			: 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views',
-	): CreateMySqlSelectFromBuilderMode<
-		TBuilderMode,
+	): MySqlSelectKind<
+		THKT,
 		GetSelectTableName<TFrom>,
 		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
 		TSelection extends undefined ? 'single' : 'partial',
-		TPreparedQueryHKT
+		GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, 'not-null'> : {},
+		false,
+		never
 	> {
 		const isPartialSelect = !!this.fields;
 
@@ -133,7 +155,7 @@ export class MySqlSelectBuilder<
 			}
 		}
 
-		return new MySqlSelectBase(
+		return new this.builder(
 			{
 				table: source,
 				fields,
@@ -150,12 +172,26 @@ export class MySqlSelectBuilder<
 	}
 }
 
-export abstract class MySqlSelectQueryBuilderBase<
+export type MySqlSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlSelectBase<
+	MySqlSelectQueryBuilderHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export class MySqlSelectBase<
 	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
 	TDynamic extends boolean = false,
@@ -170,7 +206,6 @@ export abstract class MySqlSelectQueryBuilderBase<
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly nullabilityMap: TNullabilityMap;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
@@ -237,7 +272,9 @@ export abstract class MySqlSelectQueryBuilderBase<
 	>(
 		joinType: TJoinType,
 		lateral: TIsLateral,
-	): MySqlJoinFn<this, TDynamic, TJoinType, TIsLateral> {
+	): 'cross' extends TJoinType ? MySqlCrossJoinFn<this, TDynamic, TIsLateral>
+		: MySqlJoinFn<this, TDynamic, TJoinType, TIsLateral>
+	{
 		return <
 			TJoinedTable extends MySqlTable | Subquery | MySqlViewBase | SQL,
 		>(
@@ -1025,14 +1062,21 @@ export abstract class MySqlSelectQueryBuilderBase<
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): MySqlSelectWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<MySqlColumn>(this.config.fields, undefined, this.dialect.codecs);
 		return this.dialect.buildSelectQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	as<TAlias extends string>(
@@ -1043,7 +1087,9 @@ export abstract class MySqlSelectQueryBuilderBase<
 		if (this.config.joins) { for (const it of this.config.joins) usedTables.push(...extractUsedTable(it.table)); }
 
 		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),
+			new Subquery(this.withoutSelectionCastCodecs().getSQL(), this.config.fields, alias, false, [
+				...new Set(usedTables),
+			]),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
 	}
@@ -1056,110 +1102,32 @@ export abstract class MySqlSelectQueryBuilderBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	override withoutSelectionCastCodecs(): this {
+		this.config.ignoreSelectionCastCodecs = true;
+		return this;
+	}
+
 	$dynamic(): MySqlSelectDynamic<this> {
 		return this as any;
 	}
 
 	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
 		this.cacheConfig = config === undefined
-			? { config: {}, enable: true, autoInvalidate: true }
+			? { config: {}, enabled: true, autoInvalidate: true }
 			: config === false
-			? { enable: false }
-			: { enable: true, autoInvalidate: true, ...config };
+			? { enabled: false }
+			: { enabled: true, autoInvalidate: true, ...config };
 		return this;
 	}
 }
 
-export interface MySqlSelectBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	MySqlSelectQueryBuilderBase<
-		MySqlSelectHKT,
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	QueryPromise<TResult>
-{}
-
-export class MySqlSelectBase<
-	TTableName extends string | undefined,
-	TSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends MySqlSelectQueryBuilderBase<
-	MySqlSelectHKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
-	static override readonly [entityKind]: string = 'MySqlSelect';
-
-	prepare(): MySqlSelectPrepare<this> {
-		if (!this.session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		const fieldsList = orderSelectedFields<MySqlColumn>(this.config.fields);
-		const query = this.session.prepareQuery<
-			MySqlPreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
-			TPreparedQueryHKT
-		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList, undefined, undefined, undefined, {
-			type: 'select',
-			tables: [...this.usedTables],
-		}, this.cacheConfig);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as MySqlSelectPrepare<this>;
-	}
-
-	execute = ((placeholderValues) => {
-		return this.prepare().execute(placeholderValues);
-	}) as ReturnType<this['prepare']>['execute'];
-
-	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
-		const self = this;
-		return async function*(placeholderValues) {
-			yield* self.prepare().iterator(placeholderValues);
-		};
-	};
-
-	iterator = this.createIterator();
-}
-
-applyMixins(MySqlSelectBase, [QueryPromise]);
-
 function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		const setOperators = [rightSelect, ...restSelects].map((select) => ({
 			type,
 			isAll,
-			rightSelect: select as AnyMySqlSelect,
+			rightSelect: select as AnyMySqlSelectQueryBuilder,
 		}));
 
 		for (const setOperator of setOperators) {
@@ -1170,7 +1138,7 @@ function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOpe
 			}
 		}
 
-		return (leftSelect as AnyMySqlSelect).addSetOperators(setOperators) as any;
+		return (leftSelect as AnyMySqlSelectQueryBuilder).addSetOperators(setOperators) as any;
 	};
 }
 
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 773bc7acf4..c01a4a6fb3 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -22,10 +22,9 @@ import type { ColumnsSelection, Placeholder, SQL, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume, ValidateShape } from '~/utils.ts';
-import type { MySqlPreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
 import type { MySqlViewBase } from '../view-base.ts';
 import type { MySqlViewWithSelection } from '../view.ts';
-import type { IndexConfig, MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
+import type { IndexConfig, MySqlSelectBase } from './select.ts';
 
 export type MySqlJoinType = Exclude<JoinType, 'full'>;
 
@@ -42,7 +41,7 @@ export interface MySqlSelectJoinConfig {
 
 export type BuildAliasTable<TTable extends MySqlTable | View, TAlias extends string> = TTable extends Table
 	? MySqlTableWithColumns<
-		UpdateTableConfig<TTable['_']['config'], {
+		UpdateTableConfig<TTable['_'], {
 			name: TAlias;
 			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'mysql'>;
 		}>
@@ -82,6 +81,8 @@ export interface MySqlSelectConfig {
 	useIndex?: string[];
 	forceIndex?: string[];
 	ignoreIndex?: string[];
+	comment?: SQL;
+	ignoreSelectionCastCodecs?: boolean;
 }
 
 export type MySqlJoin<
@@ -104,7 +105,6 @@ export type MySqlJoin<
 				T['_']['selectMode']
 			>,
 			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
-			T['_']['preparedQueryHKT'],
 			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
 			TDynamic,
 			T['_']['excludedMethods']
@@ -119,27 +119,32 @@ export type MySqlJoinFn<
 	TDynamic extends boolean,
 	TJoinType extends MySqlJoinType,
 	TIsLateral extends boolean,
-> = 'cross' extends TJoinType ? <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : MySqlTable | Subquery | MySqlViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TJoinedTable,
-		onIndex?:
-			| (TJoinedTable extends MySqlTable ? IndexConfig
-				: 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views')
-			| undefined,
-	) => MySqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>
-	: <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : MySqlTable | Subquery | MySqlViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TJoinedTable,
-		on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-		onIndex?:
-			| (TJoinedTable extends MySqlTable ? IndexConfig
-				: 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views')
-			| undefined,
-	) => MySqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : MySqlTable | Subquery | MySqlViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+	onIndex?:
+		| (TJoinedTable extends MySqlTable ? IndexConfig
+			: 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views')
+		| undefined,
+) => MySqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type MySqlCrossJoinFn<
+	T extends AnyMySqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : MySqlTable | Subquery | MySqlViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TJoinedTable,
+	onIndex?:
+		| (TJoinedTable extends MySqlTable ? IndexConfig
+			: 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views')
+		| undefined,
+) => MySqlJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectedFieldsFlatBase<MySqlColumn>;
 
@@ -164,7 +169,6 @@ export interface MySqlSelectHKTBase {
 	tableName: string | undefined;
 	selection: unknown;
 	selectMode: SelectMode;
-	preparedQueryHKT: unknown;
 	nullabilityMap: unknown;
 	dynamic: boolean;
 	excludedMethods: string;
@@ -178,7 +182,6 @@ export type MySqlSelectKind<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TDynamic extends boolean,
 	TExcludedMethods extends string,
@@ -188,7 +191,6 @@ export type MySqlSelectKind<
 	tableName: TTableName;
 	selection: TSelection;
 	selectMode: TSelectMode;
-	preparedQueryHKT: TPreparedQueryHKT;
 	nullabilityMap: TNullabilityMap;
 	dynamic: TDynamic;
 	excludedMethods: TExcludedMethods;
@@ -197,26 +199,11 @@ export type MySqlSelectKind<
 })['_type'];
 
 export interface MySqlSelectQueryBuilderHKT extends MySqlSelectHKTBase {
-	_type: MySqlSelectQueryBuilderBase<
-		MySqlSelectQueryBuilderHKT,
-		this['tableName'],
-		Assume<this['selection'], ColumnsSelection>,
-		this['selectMode'],
-		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
-		this['dynamic'],
-		this['excludedMethods'],
-		Assume<this['result'], any[]>,
-		Assume<this['selectedFields'], ColumnsSelection>
-	>;
-}
-
-export interface MySqlSelectHKT extends MySqlSelectHKTBase {
 	_type: MySqlSelectBase<
+		MySqlSelectQueryBuilderHKT,
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
@@ -246,7 +233,6 @@ export type MySqlSelectWithout<
 		T['_']['tableName'],
 		T['_']['selection'],
 		T['_']['selectMode'],
-		T['_']['preparedQueryHKT'],
 		T['_']['nullabilityMap'],
 		TDynamic,
 		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
@@ -256,21 +242,11 @@ export type MySqlSelectWithout<
 	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
 >;
 
-export type MySqlSelectPrepare<T extends AnyMySqlSelect> = PreparedQueryKind<
-	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: T['_']['result'];
-		iterator: T['_']['result'][number];
-	},
-	true
->;
-
 export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSelectKind<
 	T['_']['hkt'],
 	T['_']['tableName'],
 	T['_']['selection'],
 	T['_']['selectMode'],
-	T['_']['preparedQueryHKT'],
 	T['_']['nullabilityMap'],
 	true,
 	never,
@@ -278,30 +254,19 @@ export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSele
 	T['_']['selectedFields']
 >;
 
-export type CreateMySqlSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> = TBuilderMode extends 'db' ? MySqlSelectBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT>
-	: MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode, TPreparedQueryHKT>;
-
 export type MySqlSelectQueryBuilder<
 	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = MySqlSelectQueryBuilderBase<
+> = MySqlSelectBase<
 	THKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
-	TPreparedQueryHKT,
 	TNullabilityMap,
 	true,
 	never,
@@ -309,15 +274,15 @@ export type MySqlSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+export type AnyMySqlSelectQueryBuilder = MySqlSelectBase<any, any, any, any, any, any, any, any, any>;
 
 export type AnyMySqlSetOperatorInterface = MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
 
 export interface MySqlSetOperatorInterface<
+	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
 	TDynamic extends boolean = false,
@@ -326,11 +291,10 @@ export interface MySqlSetOperatorInterface<
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > {
 	_: {
-		readonly hkt: MySqlSelectHKT;
+		readonly hkt: THKT;
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly nullabilityMap: TNullabilityMap;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
@@ -340,7 +304,7 @@ export interface MySqlSetOperatorInterface<
 }
 
 export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperatorInterface<
-	any,
+	MySqlSelectQueryBuilderHKT,
 	any,
 	any,
 	any,
@@ -351,26 +315,16 @@ export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperator
 	any
 >;
 
-export type MySqlSelect<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
-
-export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
-
 export type MySqlSetOperator<
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 > = MySqlSelectBase<
+	MySqlSelectQueryBuilderHKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
-	TPreparedQueryHKT,
 	TNullabilityMap,
 	true,
 	MySqlSetOperatorExcludedMethods
@@ -401,12 +355,12 @@ export type SetOperatorRestSelect<
 	: TValue;
 
 export type MySqlCreateSetOperatorFn = <
+	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TValue extends MySqlSetOperatorWithResult<TResult>,
 	TRest extends MySqlSetOperatorWithResult<TResult>[],
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
 	TDynamic extends boolean = false,
@@ -415,10 +369,10 @@ export type MySqlCreateSetOperatorFn = <
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: MySqlSetOperatorInterface<
+		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT,
 		TNullabilityMap,
 		TDynamic,
 		TExcludedMethods,
@@ -429,10 +383,10 @@ export type MySqlCreateSetOperatorFn = <
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
 ) => MySqlSelectWithout<
 	MySqlSelectBase<
+		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT,
 		TNullabilityMap,
 		TDynamic,
 		TExcludedMethods,
diff --git a/drizzle-orm/src/mysql-core/query-builders/update.ts b/drizzle-orm/src/mysql-core/query-builders/update.ts
index 7da5bbb74a..f2d4f697d3 100644
--- a/drizzle-orm/src/mysql-core/query-builders/update.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/update.ts
@@ -1,26 +1,15 @@
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import type { GetColumnData } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
+import type { AnyMySqlQueryResultHKT, MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { MySqlSession } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
-import { QueryPromise } from '~/query-promise.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { type CommentInput, type Placeholder, type Query, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
-import { mapUpdateSet, type UpdateSet, type ValueOrArray } from '~/utils.ts';
+import { type InferInsertModel, Table } from '~/table.ts';
+import { type Assume, mapUpdateSet, type UpdateSet, type ValueOrArray } from '~/utils.ts';
 import type { MySqlColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
-import type { SelectedFieldsOrdered } from './select.types.ts';
 
 export interface MySqlUpdateConfig {
 	where?: SQL | undefined;
@@ -28,23 +17,37 @@ export interface MySqlUpdateConfig {
 	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
 	set: UpdateSet;
 	table: MySqlTable;
-	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
+	comment?: SQL;
 }
 
-export type MySqlUpdateSetSource<TTable extends MySqlTable> =
+export type MySqlUpdateSetSource<
+	TTable extends MySqlTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]?:
+		[Key in keyof TModel & string]?:
 			| GetColumnData<TTable['_']['columns'][Key], 'query'>
 			| SQL
+			| Placeholder
 			| undefined;
 	}
 	& {};
 
+export interface MySqlUpdateBuilderConstructor {
+	new(
+		table: MySqlTable,
+		set: UpdateSet,
+		session: MySqlSession,
+		dialect: MySqlDialect,
+		withList?: Subquery[],
+	): AnyMySqlUpdate;
+}
+
 export class MySqlUpdateBuilder<
 	TTable extends MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TBuilderHKT extends MySqlUpdateHKTBase = MySqlUpdateHKT,
 > {
 	static readonly [entityKind]: string = 'MySqlUpdateBuilder';
 
@@ -57,90 +60,118 @@ export class MySqlUpdateBuilder<
 		private session: MySqlSession,
 		private dialect: MySqlDialect,
 		private withList?: Subquery[],
+		private builder: MySqlUpdateBuilderConstructor = MySqlUpdateBase as unknown as MySqlUpdateBuilderConstructor,
 	) {}
 
-	set(values: MySqlUpdateSetSource<TTable>): MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+	set(values: MySqlUpdateSetSource<TTable>): MySqlUpdateKind<TBuilderHKT, TTable, TQueryResult> {
+		return new this.builder(
+			this.table,
+			mapUpdateSet(this.table, values),
+			this.session,
+			this.dialect,
+			this.withList,
+		) as any;
 	}
 }
 
 export type MySqlUpdateWithout<
-	T extends AnyMySqlUpdateBase,
+	T extends AnyMySqlUpdate,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T : Omit<
-	MySqlUpdateBase<
+	MySqlUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
 		T['_']['queryResult'],
-		T['_']['preparedQueryHKT'],
 		TDynamic,
 		T['_']['excludedMethods'] | K
 	>,
 	T['_']['excludedMethods'] | K
 >;
 
-export type MySqlUpdatePrepare<T extends AnyMySqlUpdateBase> = PreparedQueryKind<
-	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
-		iterator: never;
-	},
-	true
->;
-
-export type MySqlUpdateDynamic<T extends AnyMySqlUpdateBase> = MySqlUpdate<
+export type MySqlUpdateDynamic<T extends AnyMySqlUpdate> = MySqlUpdateKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
-	T['_']['preparedQueryHKT']
+	true,
+	never
 >;
 
 export type MySqlUpdate<
 	TTable extends MySqlTable = MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-> = MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+> = MySqlUpdateBase<MySqlUpdateHKT, TTable, TQueryResult, true, never>;
 
-export type AnyMySqlUpdateBase = MySqlUpdateBase<any, any, any, any, any>;
+export type AnyMySqlUpdate = MySqlUpdateBase<any, any, any, any, any>;
+
+export interface MySqlUpdateHKTBase {
+	table: unknown;
+	queryResult: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	_type: unknown;
+}
+
+export interface MySqlUpdateHKT extends MySqlUpdateHKTBase {
+	_type: MySqlUpdateBase<
+		MySqlUpdateHKT,
+		Assume<this['table'], MySqlTable>,
+		Assume<this['queryResult'], MySqlQueryResultHKT>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type MySqlUpdateKind<
+	T extends MySqlUpdateHKTBase,
+	TTable extends MySqlTable,
+	TQueryResult extends MySqlQueryResultHKT,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	queryResult: TQueryResult;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
 
 export interface MySqlUpdateBase<
+	THKT extends MySqlUpdateHKTBase,
 	TTable extends MySqlTable,
 	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>>, SQLWrapper {
+> extends SQLWrapper {
 	readonly _: {
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
 	};
 }
 
 export class MySqlUpdateBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	THKT extends MySqlUpdateHKTBase,
+	TTable extends MySqlTable,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TQueryResult extends MySqlQueryResultHKT,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> implements SQLWrapper {
-	static override readonly [entityKind]: string = 'MySqlUpdate';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'MySqlUpdate';
 
-	private config: MySqlUpdateConfig;
-	protected cacheConfig?: WithCacheConfig;
+	protected config: MySqlUpdateConfig;
 
 	constructor(
 		table: TTable,
 		set: UpdateSet,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		protected session: MySqlSession,
+		protected dialect: MySqlDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { set, table, withList };
 	}
 
@@ -213,44 +244,22 @@ export class MySqlUpdateBase<
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): MySqlUpdateWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
 		return this.dialect.buildUpdateQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	prepare(): MySqlUpdatePrepare<this> {
-		return this.session.prepareQuery(
-			this.dialect.sqlToQuery(this.getSQL()),
-			undefined,
-			undefined,
-			undefined,
-			this.config.returning,
-			{
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			},
-			this.cacheConfig,
-		) as MySqlUpdatePrepare<this>;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return this.prepare().execute(placeholderValues);
-	};
-
-	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
-		const self = this;
-		return async function*(placeholderValues) {
-			yield* self.prepare().iterator(placeholderValues);
-		};
-	};
-
-	iterator = this.createIterator();
-
 	$dynamic(): MySqlUpdateDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/mysql-core/schema.ts b/drizzle-orm/src/mysql-core/schema.ts
index b36531e44e..7f329e8a27 100644
--- a/drizzle-orm/src/mysql-core/schema.ts
+++ b/drizzle-orm/src/mysql-core/schema.ts
@@ -1,3 +1,4 @@
+import type { Casing } from '~/casing.ts';
 import { entityKind, is } from '~/entity.ts';
 import { type MySqlTableFn, mysqlTableWithSchema } from './table.ts';
 import { type mysqlView, mysqlViewWithSchema } from './view.ts';
@@ -7,14 +8,15 @@ export class MySqlSchema<TName extends string = string> {
 
 	constructor(
 		public readonly schemaName: TName,
+		protected casing: Casing | undefined,
 	) {}
 
 	table: MySqlTableFn<TName> = (name, columns, extraConfig) => {
-		return mysqlTableWithSchema(name, columns, extraConfig, this.schemaName);
+		return mysqlTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
 	};
 
 	view = ((name, columns) => {
-		return mysqlViewWithSchema(name, columns, this.schemaName);
+		return mysqlViewWithSchema(name, columns, this.schemaName, this.casing);
 	}) as typeof mysqlView;
 }
 
@@ -30,8 +32,12 @@ export function isMySqlSchema(obj: unknown): obj is MySqlSchema {
  * @param name mysql use schema name
  * @returns MySQL schema
  */
-export function mysqlDatabase<TName extends string>(name: TName) {
-	return new MySqlSchema(name);
+export function mysqlDatabase<TName extends string>(name: TName): MySqlSchema<TName>;
+/** @internal */
+export function mysqlDatabase<TName extends string>(name: TName, casing: Casing | undefined): MySqlSchema<TName>;
+/** @internal */
+export function mysqlDatabase<TName extends string>(name: TName, casing?: Casing): MySqlSchema<TName> {
+	return new MySqlSchema(name, casing);
 }
 
 /**
diff --git a/drizzle-orm/src/mysql-core/session.ts b/drizzle-orm/src/mysql-core/session.ts
index 9aa6fb8119..d11f76aa95 100644
--- a/drizzle-orm/src/mysql-core/session.ts
+++ b/drizzle-orm/src/mysql-core/session.ts
@@ -1,16 +1,9 @@
-import { type Cache, hashQuery, NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind, is } from '~/entity.ts';
-import { TransactionRollbackError } from '~/errors.ts';
-import { DrizzleQueryError } from '~/errors/index.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { type Query, type SQL, sql } from '~/sql/sql.ts';
-import type { Assume, Equal } from '~/utils.ts';
-import { MySqlDatabase } from './db.ts';
+import { entityKind } from '~/entity.ts';
+import type { PreparedQuery } from '~/session.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
 import type { MySqlDialect } from './dialect.ts';
-import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
-
-export type Mode = 'default' | 'planetscale';
 
 export interface MySqlQueryResultHKT {
 	readonly $brand: 'MySqlQueryResultHKT';
@@ -37,129 +30,22 @@ export interface MySqlPreparedQueryHKT {
 	readonly type: unknown;
 }
 
-export type PreparedQueryKind<
-	TKind extends MySqlPreparedQueryHKT,
-	TConfig extends MySqlPreparedQueryConfig,
-	TAssume extends boolean = false,
-> = Equal<TAssume, true> extends true
-	? Assume<(TKind & { readonly config: TConfig })['type'], MySqlPreparedQuery<TConfig>>
-	: (TKind & { readonly config: TConfig })['type'];
-
-export abstract class MySqlPreparedQuery<T extends MySqlPreparedQueryConfig> {
-	static readonly [entityKind]: string = 'MySqlPreparedQuery';
-
-	constructor( // cache instance
-		private cache: Cache | undefined,
-		// per query related metadata
-		private queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		// config that was passed through $withCache
-		private cacheConfig?: WithCacheConfig,
-	) {
-		// it means that no $withCache options were passed and it should be just enabled
-		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
-			this.cacheConfig = { enable: true, autoInvalidate: true };
-		}
-		if (!this.cacheConfig?.enable) {
-			this.cacheConfig = undefined;
-		}
-	}
-
-	/** @internal */
-	protected async queryWithCache<T>(
-		queryString: string,
-		params: any[],
-		query: () => Promise<T>,
-	): Promise<T> {
-		if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
+export type AnyMySqlMapper = (
+	response: Record<string, unknown>[] | unknown[][] | { insertId: number; affectedRows: number },
+) => any;
 
-		// don't do any mutations, if globally is false
-		if (this.cacheConfig && !this.cacheConfig.enable) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
+export abstract class MySqlBasePreparedQuery implements PreparedQuery {
+	static readonly [entityKind]: string = 'MySqlBasePreparedQuery';
 
-		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
-		if (
-			(
-				this.queryMetadata.type === 'insert' || this.queryMetadata.type === 'update'
-				|| this.queryMetadata.type === 'delete'
-			) && this.queryMetadata.tables.length > 0
-		) {
-			try {
-				const [res] = await Promise.all([
-					query(),
-					this.cache.onMutate({ tables: this.queryMetadata.tables }),
-				]);
-				return res;
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any reads if globally disabled
-		if (!this.cacheConfig) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		if (this.queryMetadata.type === 'select') {
-			const fromCache = await this.cache.get(
-				this.cacheConfig.tag ?? await hashQuery(queryString, params),
-				this.queryMetadata.tables,
-				this.cacheConfig.tag !== undefined,
-				this.cacheConfig.autoInvalidate,
-			);
-			if (fromCache === undefined) {
-				let result;
-				try {
-					result = await query();
-				} catch (e) {
-					throw new DrizzleQueryError(queryString, params, e as Error);
-				}
-
-				// put actual key
-				await this.cache.put(
-					this.cacheConfig.tag ?? await hashQuery(queryString, params),
-					result,
-					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
-					this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
-					this.cacheConfig.tag !== undefined,
-					this.cacheConfig.config,
-				);
-				// put flag if we should invalidate or not
-				return result;
-			}
+	constructor(
+		protected query: Query,
+	) {}
 
-			return fromCache as unknown as T;
-		}
-		try {
-			return await query();
-		} catch (e) {
-			throw new DrizzleQueryError(queryString, params, e as Error);
-		}
+	getQuery(): Query {
+		return this.query;
 	}
 
-	/** @internal */
-	joinsNotNullableMap?: Record<string, boolean>;
-
-	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-
-	abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
+	abstract execute(placeholderValues?: Record<string, unknown>): unknown;
 }
 
 export interface MySqlTransactionConfig {
@@ -168,50 +54,27 @@ export interface MySqlTransactionConfig {
 	isolationLevel: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
 }
 
-export abstract class MySqlSession<
-	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> {
+export abstract class MySqlSession {
 	static readonly [entityKind]: string = 'MySqlSession';
 
 	constructor(protected dialect: MySqlDialect) {}
 
-	abstract prepareQuery<T extends MySqlPreparedQueryConfig, TPreparedQueryHKT extends MySqlPreparedQueryHKT>(
+	abstract prepareQuery(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		generatedIds?: Record<string, unknown>[],
-		returningIds?: SelectedFieldsOrdered,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (rows: any) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PreparedQueryKind<TPreparedQueryHKT, T>;
+	): MySqlBasePreparedQuery;
 
-	execute<T>(query: SQL): Promise<T> {
-		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T }, PreparedQueryHKTBase>(
-			this.dialect.sqlToQuery(query),
-			undefined,
-		).execute();
-	}
+	abstract execute(query: SQL): unknown;
 
-	abstract all<T = unknown>(query: SQL): Promise<T[]>;
+	abstract arrays(query: SQL): unknown;
 
-	async count(sql: SQL): Promise<number> {
-		const res = await this.execute<[[{ count: string }]]>(sql);
-
-		return Number(
-			res[0][0]['count'],
-		);
-	}
-
-	abstract transaction<T>(
-		transaction: (tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
-		config?: MySqlTransactionConfig,
-	): Promise<T>;
+	abstract objects(query: SQL): unknown;
 
 	protected getSetTransactionSQL(config: MySqlTransactionConfig): SQL | undefined {
 		const parts: string[] = [];
@@ -237,35 +100,3 @@ export abstract class MySqlSession<
 		return parts.length ? sql`start transaction ${sql.raw(parts.join(' '))}` : undefined;
 	}
 }
-
-export abstract class MySqlTransaction<
-	TQueryResult extends MySqlQueryResultHKT,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends MySqlDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'MySqlTransaction';
-
-	constructor(
-		dialect: MySqlDialect,
-		session: MySqlSession,
-		protected schema: RelationalSchemaConfig<TSchema> | undefined,
-		protected readonly nestedIndex: number,
-		mode: Mode,
-	) {
-		super(dialect, session, schema, mode);
-	}
-
-	rollback(): never {
-		throw new TransactionRollbackError();
-	}
-
-	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
-	abstract override transaction<T>(
-		transaction: (tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T>;
-}
-
-export interface PreparedQueryHKTBase extends MySqlPreparedQueryHKT {
-	type: MySqlPreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/mysql-core/table.ts b/drizzle-orm/src/mysql-core/table.ts
index 2616e71597..302dc67ce1 100644
--- a/drizzle-orm/src/mysql-core/table.ts
+++ b/drizzle-orm/src/mysql-core/table.ts
@@ -1,9 +1,15 @@
-import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts';
+import { type Casing, getCasingFn } from '~/casing.ts';
+import type { BuildColumns, BuildExtraConfigColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
-import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
+import {
+	type InferTableColumnsModels,
+	Table,
+	type TableConfig as TableConfigBase,
+	type UpdateTableConfig,
+} from '~/table.ts';
 import type { CheckBuilder } from './checks.ts';
 import { getMySqlColumnBuilders, type MySqlColumnBuilders } from './columns/all.ts';
-import type { MySqlColumn, MySqlColumnBuilder, MySqlColumnBuilderBase } from './columns/common.ts';
+import type { MySqlColumn, MySqlColumnBuilder, MySqlColumns } from './columns/common.ts';
 import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import type { AnyIndexBuilder } from './indexes.ts';
 import type { PrimaryKeyBuilder } from './primary-keys.ts';
@@ -21,7 +27,7 @@ export type MySqlTableExtraConfig = Record<
 	MySqlTableExtraConfigValue
 >;
 
-export type TableConfig = TableConfigBase<MySqlColumn>;
+export type TableConfig = TableConfigBase<MySqlColumns>;
 
 /** @internal */
 export const InlineForeignKeys = Symbol.for('drizzle:MySqlInlineForeignKeys');
@@ -29,8 +35,6 @@ export const InlineForeignKeys = Symbol.for('drizzle:MySqlInlineForeignKeys');
 export class MySqlTable<T extends TableConfig = TableConfig> extends Table<T> {
 	static override readonly [entityKind]: string = 'MySqlTable';
 
-	declare protected $columns: T['columns'];
-
 	/** @internal */
 	static override readonly Symbol = Object.assign({}, Table.Symbol, {
 		InlineForeignKeys: InlineForeignKeys as typeof InlineForeignKeys,
@@ -54,14 +58,13 @@ export type AnyMySqlTable<TPartial extends Partial<TableConfig> = {}> = MySqlTab
 
 export type MySqlTableWithColumns<T extends TableConfig> =
 	& MySqlTable<T>
-	& {
-		[Key in keyof T['columns']]: T['columns'][Key];
-	};
+	& T['columns']
+	& InferTableColumnsModels<T['columns']>;
 
 export function mysqlTableWithSchema<
 	TTableName extends string,
 	TSchemaName extends string | undefined,
-	TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+	TColumnsMap extends Record<string, ColumnBuilderBase>,
 >(
 	name: TTableName,
 	columns: TColumnsMap | ((columnTypes: MySqlColumnBuilders) => TColumnsMap),
@@ -71,6 +74,7 @@ export function mysqlTableWithSchema<
 		) => MySqlTableExtraConfig | MySqlTableExtraConfigValue[])
 		| undefined,
 	schema: TSchemaName,
+	casing: Casing | undefined,
 	baseName = name,
 ): MySqlTableWithColumns<{
 	name: TTableName;
@@ -78,6 +82,7 @@ export function mysqlTableWithSchema<
 	columns: BuildColumns<TTableName, TColumnsMap, 'mysql'>;
 	dialect: 'mysql';
 }> {
+	const casingFn = getCasingFn(casing);
 	const rawTable = new MySqlTable<{
 		name: TTableName;
 		schema: TSchemaName;
@@ -90,8 +95,8 @@ export function mysqlTableWithSchema<
 	const builtColumns = Object.fromEntries(
 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
 			const colBuilder = colBuilderBase as MySqlColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.build(rawTable);
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
 			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
 			return [name, column];
 		}),
@@ -112,13 +117,13 @@ export function mysqlTableWithSchema<
 		) => MySqlTableExtraConfig;
 	}
 
-	return table;
+	return table as any;
 }
 
 export interface MySqlTableFn<TSchemaName extends string | undefined = undefined> {
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -134,7 +139,7 @@ export interface MySqlTableFn<TSchemaName extends string | undefined = undefined
 
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: MySqlColumnBuilders) => TColumnsMap,
@@ -169,7 +174,7 @@ export interface MySqlTableFn<TSchemaName extends string | undefined = undefined
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -205,7 +210,7 @@ export interface MySqlTableFn<TSchemaName extends string | undefined = undefined
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: MySqlColumnBuilders) => TColumnsMap,
@@ -218,12 +223,18 @@ export interface MySqlTableFn<TSchemaName extends string | undefined = undefined
 	}>;
 }
 
-export const mysqlTable: MySqlTableFn = (name, columns, extraConfig) => {
-	return mysqlTableWithSchema(name, columns, extraConfig, undefined, name);
-};
+/** @internal */
+export function mysqlTableWithCasing(casing: Casing | undefined): MySqlTableFn {
+	return (name, columns, extraConfig) => mysqlTableWithSchema(name, columns, extraConfig, undefined, casing, name);
+}
+
+export const mysqlTable = mysqlTableWithCasing(undefined);
 
-export function mysqlTableCreator(customizeTableName: (name: string) => string): MySqlTableFn {
+export function mysqlTableCreator(
+	customizeTableName: (name: string) => string,
+	casing?: Casing | undefined,
+): MySqlTableFn {
 	return (name, columns, extraConfig) => {
-		return mysqlTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+		return mysqlTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, casing, name);
 	};
 }
diff --git a/drizzle-orm/src/mysql-core/unique-constraint.ts b/drizzle-orm/src/mysql-core/unique-constraint.ts
index 01a3c36c28..b4240fe713 100644
--- a/drizzle-orm/src/mysql-core/unique-constraint.ts
+++ b/drizzle-orm/src/mysql-core/unique-constraint.ts
@@ -3,25 +3,28 @@ import { TableName } from '~/table.utils.ts';
 import type { MySqlColumn } from './columns/index.ts';
 import type { MySqlTable } from './table.ts';
 
-export function unique(name?: string): UniqueOnConstraintBuilder {
-	return new UniqueOnConstraintBuilder(name);
+export function unique<TName extends string | undefined = undefined>(name?: TName): UniqueOnConstraintBuilder<TName> {
+	return new UniqueOnConstraintBuilder<TName>(name);
 }
 
 export function uniqueKeyName(table: MySqlTable, columns: string[]) {
 	return `${table[TableName]}_${columns.join('_')}_unique`;
 }
 
-export class UniqueConstraintBuilder {
+export class UniqueConstraintBuilder<TName extends string | undefined = undefined> {
 	static readonly [entityKind]: string = 'MySqlUniqueConstraintBuilder';
 
 	/** @internal */
 	columns: MySqlColumn[];
+	/** @internal */
+	name?: TName;
 
 	constructor(
 		columns: MySqlColumn[],
-		private name?: string,
+		name?: TName,
 	) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	/** @internal */
@@ -30,20 +33,20 @@ export class UniqueConstraintBuilder {
 	}
 }
 
-export class UniqueOnConstraintBuilder {
+export class UniqueOnConstraintBuilder<TName extends string | undefined = undefined> {
 	static readonly [entityKind]: string = 'MySqlUniqueOnConstraintBuilder';
 
 	/** @internal */
-	name?: string;
+	name?: TName;
 
 	constructor(
-		name?: string,
+		name?: TName,
 	) {
 		this.name = name;
 	}
 
 	on(...columns: [MySqlColumn, ...MySqlColumn[]]) {
-		return new UniqueConstraintBuilder(columns, this.name);
+		return new UniqueConstraintBuilder<TName>(columns, this.name);
 	}
 }
 
@@ -51,11 +54,13 @@ export class UniqueConstraint {
 	static readonly [entityKind]: string = 'MySqlUniqueConstraint';
 
 	readonly columns: MySqlColumn[];
-	readonly name?: string;
+	readonly name: string;
+	readonly isNameExplicit: boolean;
 	readonly nullsNotDistinct: boolean = false;
 
 	constructor(readonly table: MySqlTable, columns: MySqlColumn[], name?: string) {
 		this.columns = columns;
+		this.isNameExplicit = !!name;
 		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
 	}
 
diff --git a/drizzle-orm/src/mysql-core/utils.ts b/drizzle-orm/src/mysql-core/utils.ts
index db454c793a..4681ef4291 100644
--- a/drizzle-orm/src/mysql-core/utils.ts
+++ b/drizzle-orm/src/mysql-core/utils.ts
@@ -1,10 +1,13 @@
 import { is } from '~/entity.ts';
-import { SQL } from '~/index.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { SQL } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { Check } from './checks.ts';
 import { CheckBuilder } from './checks.ts';
+import type { MySqlCodecs } from './codecs.ts';
 import type { ForeignKey } from './foreign-keys.ts';
 import { ForeignKeyBuilder } from './foreign-keys.ts';
 import type { Index } from './indexes.ts';
@@ -87,10 +90,14 @@ export function getViewConfig<
 
 export function convertIndexToString(indexes: IndexForHint[]) {
 	return indexes.map((idx) => {
-		return typeof idx === 'object' ? idx.config.name : idx;
+		return typeof idx === 'object' ? is(idx, IndexBuilder) ? idx.config.name : idx.name! : idx;
 	});
 }
 
 export function toArray<T>(value: T | T[]): T[] {
 	return Array.isArray(value) ? value : [value];
 }
+
+export type DrizzleMySqlConfig<TRelations extends AnyRelations> =
+	& Omit<DrizzleConfig<Record<string, never>, TRelations>, 'schema'>
+	& { codecs?: MySqlCodecs | undefined };
diff --git a/drizzle-orm/src/mysql-core/view.ts b/drizzle-orm/src/mysql-core/view.ts
index 42d9b3af6d..97cbd01335 100644
--- a/drizzle-orm/src/mysql-core/view.ts
+++ b/drizzle-orm/src/mysql-core/view.ts
@@ -1,13 +1,14 @@
-import type { BuildColumns } from '~/column-builder.ts';
+import type { Casing } from '~/casing.ts';
+import type { BuildColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import type { MySqlColumn, MySqlColumnBuilderBase } from './columns/index.ts';
+import type { MySqlColumn } from './columns/index.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
-import { mysqlTable } from './table.ts';
+import { mysqlTableWithSchema } from './table.ts';
 import { MySqlViewBase } from './view-base.ts';
 import { MySqlViewConfig } from './view-common.ts';
 
@@ -77,7 +78,7 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 					name: this.name,
 					schema: this.schema,
 					selectedFields: aliasedSelection,
-					query: qb.getSQL().inlineParams(),
+					query: qb.withoutSelectionCastCodecs().getSQL().inlineParams(),
 				},
 			}),
 			selectionProxy as any,
@@ -87,7 +88,7 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 
 export class ManualViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, MySqlColumnBuilderBase> = Record<string, MySqlColumnBuilderBase>,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
 > extends ViewBuilderCore<{ name: TName; columns: TColumns }> {
 	static override readonly [entityKind]: string = 'MySqlManualViewBuilder';
 
@@ -97,9 +98,14 @@ export class ManualViewBuilder<
 		name: TName,
 		columns: TColumns,
 		schema: string | undefined,
+		casing: Casing | undefined,
 	) {
 		super(name, schema);
-		this.columns = getTableColumns(mysqlTable(name, columns)) as BuildColumns<TName, TColumns, 'mysql'>;
+		this.columns = getTableColumns(mysqlTableWithSchema(name, columns, undefined, schema, casing)) as BuildColumns<
+			TName,
+			TColumns,
+			'mysql'
+		>;
 	}
 
 	existing(): MySqlViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'mysql'>> {
@@ -177,23 +183,27 @@ export type MySqlViewWithSelection<
 /** @internal */
 export function mysqlViewWithSchema(
 	name: string,
-	selection: Record<string, MySqlColumnBuilderBase> | undefined,
+	selection: Record<string, ColumnBuilderBase> | undefined,
 	schema: string | undefined,
+	casing: Casing | undefined,
 ): ViewBuilder | ManualViewBuilder {
 	if (selection) {
-		return new ManualViewBuilder(name, selection, schema);
+		return new ManualViewBuilder(name, selection, schema, casing);
 	}
 	return new ViewBuilder(name, schema);
 }
 
-export function mysqlView<TName extends string>(name: TName): ViewBuilder<TName>;
-export function mysqlView<TName extends string, TColumns extends Record<string, MySqlColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualViewBuilder<TName, TColumns>;
-export function mysqlView(
-	name: string,
-	selection?: Record<string, MySqlColumnBuilderBase>,
-): ViewBuilder | ManualViewBuilder {
-	return mysqlViewWithSchema(name, selection, undefined);
+export interface MySqlViewFn {
+	<TName extends string>(name: TName): ViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, ColumnBuilderBase>>(
+		name: TName,
+		columns: TColumns,
+	): ManualViewBuilder<TName, TColumns>;
 }
+
+/** @internal */
+export function mysqlViewWithCasing(casing: Casing | undefined): MySqlViewFn {
+	return ((name, columns) => mysqlViewWithSchema(name, columns, undefined, casing)) as MySqlViewFn;
+}
+
+export const mysqlView = mysqlViewWithCasing(undefined);
diff --git a/drizzle-orm/src/mysql-proxy/driver.ts b/drizzle-orm/src/mysql-proxy/driver.ts
index bb0c21134f..e7eb32253e 100644
--- a/drizzle-orm/src/mysql-proxy/driver.ts
+++ b/drizzle-orm/src/mysql-proxy/driver.ts
@@ -1,19 +1,15 @@
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { MySqlDatabase } from '~/mysql-core/db.ts';
-import { MySqlDialect } from '~/mysql-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { type MySqlRemotePreparedQueryHKT, type MySqlRemoteQueryResultHKT, MySqlRemoteSession } from './session.ts';
+import { MySqlAsyncDatabase } from '~/mysql-core/async/db.ts';
+import { MySqlDialect, type MySqlDialectConfig } from '~/mysql-core/dialect.ts';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type MySqlRemoteQueryResultHKT, MySqlRemoteSession } from './session.ts';
 
 export class MySqlRemoteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends MySqlDatabase<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlAsyncDatabase<MySqlRemoteQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'MySqlRemoteDatabase';
 }
 
@@ -23,11 +19,15 @@ export type RemoteCallback = (
 	method: 'all' | 'execute',
 ) => Promise<{ rows: any[]; insertId?: number; affectedRows?: number }>;
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	callback: RemoteCallback,
-	config: DrizzleConfig<TSchema> = {},
-): MySqlRemoteDatabase<TSchema> {
-	const dialect = new MySqlDialect({ casing: config.casing });
+	config: DrizzleMySqlConfig<TRelations> = {},
+	_dialect: (config?: MySqlDialectConfig) => MySqlDialect = (config) => new MySqlDialect(config),
+): MySqlRemoteDatabase<TRelations> {
+	const dialect = _dialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -35,19 +35,13 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new MySqlRemoteSession(callback, dialect, schema, { logger });
-	return new MySqlRemoteDatabase(dialect, session, schema as any, 'default') as MySqlRemoteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new MySqlRemoteSession(callback, dialect, relations, {
+		logger,
+	});
+	return new MySqlRemoteDatabase(
+		dialect,
+		session,
+		relations,
+	) as MySqlRemoteDatabase<TRelations>;
 }
diff --git a/drizzle-orm/src/mysql-proxy/migrator.ts b/drizzle-orm/src/mysql-proxy/migrator.ts
index d0bbae51b6..f2a26bf9f9 100644
--- a/drizzle-orm/src/mysql-proxy/migrator.ts
+++ b/drizzle-orm/src/mysql-proxy/migrator.ts
@@ -1,51 +1,87 @@
-import type { MigrationConfig } from '~/migrator.ts';
+import type { MigrationConfig, MigratorInitFailResponse } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/mysql-proxy.ts';
 import type { MySqlRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: MySqlRemoteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: MySqlRemoteDatabase<TRelations>,
 	callback: ProxyMigrator,
 	config: MigrationConfig,
-) {
+): Promise<void | MigratorInitFailResponse> {
 	const migrations = readMigrationFiles(config);
 
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
-	const migrationTableCreate = sql`
-		create table if not exists ${sql.identifier(migrationsTable)} (
-			id serial primary key,
-			hash text not null,
-			created_at bigint
-		)
-	`;
-	await db.execute(migrationTableCreate);
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded(migrationsTable, db, callback, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash TEXT NOT NULL,
+				created_at BIGINT,
+				name TEXT,
+				applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+			)
+		`;
+		await db.session.execute(migrationTableCreate);
+	}
 
 	const dbMigrations = await db.select({
 		id: sql.raw('id'),
 		hash: sql.raw('hash'),
 		created_at: sql.raw('created_at'),
-	}).from(sql.identifier(migrationsTable).getSQL()).orderBy(
-		sql.raw('created_at desc'),
-	).limit(1);
-
-	const lastDbMigration = dbMigrations[0];
+		name: sql.raw('name'),
+	}).from(sql.identifier(migrationsTable).getSQL()) as {
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}[];
 
-	const queriesToRun: string[] = [];
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
 
-	for (const migration of migrations) {
-		if (
-			!lastDbMigration
-			|| Number(lastDbMigration.created_at) < migration.folderMillis
-		) {
-			queriesToRun.push(
-				...migration.sql,
-				`insert into ${
-					sql.identifier(migrationsTable).value
-				} (\`hash\`, \`created_at\`) values('${migration.hash}', '${migration.folderMillis}')`,
-			);
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
 		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await callback([
+			db.dialect.sqlToQuery(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, '${migration.folderMillis}', ${migration.name})`
+					.inlineParams(),
+			).sql,
+		]);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const queriesToRun: string[] = [];
+	for (const migration of migrationsToRun) {
+		queriesToRun.push(
+			...migration.sql,
+			db.dialect.sqlToQuery(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, '${migration.folderMillis}', ${migration.name})`
+					.inlineParams(),
+			).sql,
+		);
 	}
 
 	await callback(queriesToRun);
diff --git a/drizzle-orm/src/mysql-proxy/session.ts b/drizzle-orm/src/mysql-proxy/session.ts
index 452402d8c2..d4d7befff1 100644
--- a/drizzle-orm/src/mysql-proxy/session.ts
+++ b/drizzle-orm/src/mysql-proxy/session.ts
@@ -1,25 +1,19 @@
 import type { FieldPacket, ResultSetHeader } from 'mysql2/promise';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { Column } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { MySqlAsyncPreparedQuery, MySqlAsyncSession, type MySqlAsyncTransaction } from '~/mysql-core/async/session.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import { MySqlTransaction } from '~/mysql-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
 import type {
+	AnyMySqlMapper,
 	MySqlPreparedQueryConfig,
-	MySqlPreparedQueryHKT,
 	MySqlQueryResultHKT,
 	MySqlTransactionConfig,
-	PreparedQueryKind,
 } from '~/mysql-core/session.ts';
-import { MySqlPreparedQuery as PreparedQueryBase, MySqlSession } from '~/mysql-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders } from '~/sql/sql.ts';
-import type { Query, SQL } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
 import type { RemoteCallback } from './driver.ts';
 
 export type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
@@ -30,9 +24,11 @@ export interface MySqlRemoteSessionOptions {
 }
 
 export class MySqlRemoteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlSession<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncSession<
+	MySqlRemoteQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'MySqlRemoteSession';
 
 	private logger: Logger;
@@ -41,8 +37,8 @@ export class MySqlRemoteSession<
 	constructor(
 		private client: RemoteCallback,
 		dialect: MySqlDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: MySqlRemoteSessionOptions,
+		private relations: TRelations,
+		private options: MySqlRemoteSessionOptions,
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
@@ -51,146 +47,47 @@ export class MySqlRemoteSession<
 
 	prepareQuery<T extends MySqlPreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		generatedIds?: Record<string, unknown>[],
-		returningIds?: SelectedFieldsOrdered,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: AnyMySqlMapper,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PreparedQueryKind<MySqlRemotePreparedQueryHKT, T> {
-		return new PreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): MySqlAsyncPreparedQuery<T> {
+		const executor = async (params: any[] = []) => {
+			const raw = this.client(query.sql, params, mode === 'arrays' ? 'all' : 'execute');
+
+			if (mode === 'objects') return raw.then(({ rows }) => rows[0]);
+			if (mode === 'arrays' || !mapper) return raw.then(({ rows }) => rows);
+			return raw.then(({ rows, insertId, affectedRows }) => ({
+				// Backwards compat with old implementation (types remain unaffected)
+				insertId: insertId ?? rows[0]?.insertId,
+				affectedRows: affectedRows ?? rows[0]?.affectedRows,
+			}));
+		};
+
+		return new MySqlAsyncPreparedQuery(
+			executor,
+			undefined,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			customResultMapper,
-			generatedIds,
-			returningIds,
-		) as PreparedQueryKind<MySqlRemotePreparedQueryHKT, T>;
-	}
-
-	override all<T = unknown>(query: SQL): Promise<T[]> {
-		const querySql = this.dialect.sqlToQuery(query);
-		this.logger.logQuery(querySql.sql, querySql.params);
-		return this.client(querySql.sql, querySql.params, 'all').then(({ rows }) => rows) as Promise<T[]>;
+		);
 	}
 
 	override async transaction<T>(
-		_transaction: (tx: MySqlProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: MySqlAsyncTransaction<MySqlRemoteQueryResultHKT, TRelations>) => Promise<T>,
 		_config?: MySqlTransactionConfig,
 	): Promise<T> {
 		throw new Error('Transactions are not supported by the MySql Proxy driver');
 	}
 }
 
-export class MySqlProxyTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlTransaction<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'MySqlProxyTransaction';
-
-	override async transaction<T>(
-		_transaction: (tx: MySqlProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T> {
-		throw new Error('Transactions are not supported by the MySql Proxy driver');
-	}
-}
-
-export class PreparedQuery<T extends MySqlPreparedQueryConfig> extends PreparedQueryBase<T> {
-	static override readonly [entityKind]: string = 'MySqlProxyPreparedQuery';
-
-	constructor(
-		private client: RemoteCallback,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-		// Keys that were used in $default and the value that was generated for them
-		private generatedIds?: Record<string, unknown>[],
-		// Keys that should be returned, it has the column with all properries + key from object
-		private returningIds?: SelectedFieldsOrdered,
-	) {
-		super(cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		const { fields, client, queryString, logger, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } =
-			this;
-
-		logger.logQuery(queryString, params);
-
-		if (!fields && !customResultMapper) {
-			const { rows: data } = await this.queryWithCache(queryString, params, async () => {
-				return await client(queryString, params, 'execute');
-			});
-
-			const insertId = data[0].insertId as number;
-			const affectedRows = data[0].affectedRows;
-
-			if (returningIds) {
-				const returningResponse = [];
-				let j = 0;
-				for (let i = insertId; i < insertId + affectedRows; i++) {
-					for (const column of returningIds) {
-						const key = returningIds[0]!.path[0]!;
-						if (is(column.field, Column)) {
-							// @ts-ignore
-							if (column.field.primary && column.field.autoIncrement) {
-								returningResponse.push({ [key]: i });
-							}
-							if (column.field.defaultFn && generatedIds) {
-								// generatedIds[rowIdx][key]
-								returningResponse.push({ [key]: generatedIds[j]![key] });
-							}
-						}
-					}
-					j++;
-				}
-
-				return returningResponse;
-			}
-
-			return data;
-		}
-
-		const { rows } = await this.queryWithCache(queryString, params, async () => {
-			return await client(queryString, params, 'all');
-		});
-
-		if (customResultMapper) {
-			return customResultMapper(rows);
-		}
-
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	override iterator(
-		_placeholderValues: Record<string, unknown> = {},
-	): AsyncGenerator<T['iterator']> {
-		throw new Error('Streaming is not supported by the MySql Proxy driver');
-	}
-}
-
 export interface MySqlRemoteQueryResultHKT extends MySqlQueryResultHKT {
 	type: MySqlRawQueryResult;
 }
-
-export interface MySqlRemotePreparedQueryHKT extends MySqlPreparedQueryHKT {
-	type: PreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/mysql2/codecs.ts b/drizzle-orm/src/mysql2/codecs.ts
new file mode 100644
index 0000000000..3733346ed9
--- /dev/null
+++ b/drizzle-orm/src/mysql2/codecs.ts
@@ -0,0 +1,51 @@
+import { floatFromDouble, refineGenericMySqlCodecs } from '~/mysql-core/codecs.ts';
+import { sql } from '~/sql/sql.ts';
+
+export const mysql2Codecs = refineGenericMySqlCodecs({
+	bigint: {
+		normalize: BigInt,
+	},
+	'bigint:number': {
+		normalize: Number,
+	},
+	boolean: {
+		normalize: (value: number) => value === 1,
+	},
+	date: {
+		normalize: (value: string) => new Date(value),
+	},
+	datetime: {
+		normalize: (value: string) => new Date(value.replace(' ', 'T') + 'Z'),
+	},
+	timestamp: {
+		normalize: (value: string) => new Date(value + '+0000'),
+	},
+	'decimal:number': {
+		normalize: Number,
+	},
+	'decimal:bigint': {
+		normalize: BigInt,
+	},
+	float: {
+		cast: (name) => sql`cast(${name} as double)`,
+		normalize: floatFromDouble,
+	},
+	binary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	varbinary: {
+		normalize: (value: Buffer) => value.toString(),
+	},
+	blob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	tinyblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	mediumblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+	longblob: {
+		normalize: (value: Buffer) => value.toString('utf8'),
+	},
+});
diff --git a/drizzle-orm/src/mysql2/driver.ts b/drizzle-orm/src/mysql2/driver.ts
index 3db9ea369a..915f666649 100644
--- a/drizzle-orm/src/mysql2/driver.ts
+++ b/drizzle-orm/src/mysql2/driver.ts
@@ -1,72 +1,44 @@
-import { type Connection as CallbackConnection, createPool, type Pool as CallbackPool, type PoolOptions } from 'mysql2';
-import type { Connection, Pool } from 'mysql2/promise';
+import type { Connection as CallbackConnection, Pool as CallbackPool } from 'mysql2';
+import { type Connection, createPool, type Pool, type PoolOptions } from 'mysql2/promise';
 import type { Cache } from '~/cache/core/index.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { MySqlDatabase } from '~/mysql-core/db.ts';
+import { MySqlAsyncDatabase } from '~/mysql-core/async/db.ts';
 import { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { Mode } from '~/mysql-core/session.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import { DrizzleError } from '../errors.ts';
-import type { MySql2Client, MySql2PreparedQueryHKT, MySql2QueryResultHKT } from './session.ts';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { mysql2Codecs } from './codecs.ts';
+import type { MySql2Client, MySql2QueryResultHKT } from './session.ts';
 import { MySql2Session } from './session.ts';
 
 export interface MySqlDriverOptions {
 	logger?: Logger;
 	cache?: Cache;
+	useJitMappers?: boolean;
 }
-
-export class MySql2Driver {
-	static readonly [entityKind]: string = 'MySql2Driver';
-
-	constructor(
-		private client: MySql2Client,
-		private dialect: MySqlDialect,
-		private options: MySqlDriverOptions = {},
-	) {
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-		mode: Mode,
-	): MySql2Session<Record<string, unknown>, TablesRelationalConfig> {
-		return new MySql2Session(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			mode,
-			cache: this.options.cache,
-		});
-	}
-}
-
-export { MySqlDatabase } from '~/mysql-core/db.ts';
+export { MySqlAsyncDatabase as MySqlDatabase } from '~/mysql-core/async/db.ts';
 
 export class MySql2Database<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends MySqlDatabase<MySql2QueryResultHKT, MySql2PreparedQueryHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlAsyncDatabase<MySql2QueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'MySql2Database';
 }
-
-export type MySql2DrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> =
-	& Omit<DrizzleConfig<TSchema>, 'schema'>
-	& ({ schema: TSchema; mode: Mode } | { schema?: undefined; mode?: Mode });
-
 function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends Pool | Connection | CallbackPool | CallbackConnection = CallbackPool,
+	TRelations extends AnyRelations = EmptyRelations,
+	TClient extends Pool | Connection | CallbackPool | CallbackConnection = Pool,
 >(
 	client: TClient,
-	config: MySql2DrizzleConfig<TSchema> = {},
-): MySql2Database<TSchema> & {
-	$client: TClient;
+	config: DrizzleMySqlConfig<TRelations> = {},
+): MySql2Database<TRelations> & {
+	$client: AnyMySql2Connection extends TClient ? Pool : TClient;
 } {
-	const dialect = new MySqlDialect({ casing: config.casing });
+	client.config.supportBigNumbers = true;
+	const dialect = new MySqlDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: mysql2Codecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -76,31 +48,16 @@ function construct<
 
 	const clientForInstance = isCallbackClient(client) ? client.promise() : client;
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		if (config.mode === undefined) {
-			throw new DrizzleError({
-				message:
-					'You need to specify "mode": "planetscale" or "default" when providing a schema. Read more: https://orm.drizzle.team/docs/rqb#modes',
-			});
-		}
-
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const mode = config.mode ?? 'default';
-
-	const driver = new MySql2Driver(clientForInstance as MySql2Client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema, mode);
-	const db = new MySql2Database(dialect, session, schema as any, mode) as MySql2Database<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new MySql2Session(clientForInstance as MySql2Client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new MySql2Database(
+		dialect,
+		session,
+		relations,
+	) as MySql2Database<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -121,17 +78,17 @@ function isCallbackClient(client: any): client is CallbackClient {
 export type AnyMySql2Connection = Pool | Connection | CallbackPool | CallbackConnection;
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-	TClient extends AnyMySql2Connection = CallbackPool,
+	TRelations extends AnyRelations = EmptyRelations,
+	TClient extends AnyMySql2Connection = Pool,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		MySql2DrizzleConfig<TSchema>,
+		string,
+		DrizzleMySqlConfig<TRelations>,
 	] | [
 		(
-			& MySql2DrizzleConfig<TSchema>
+			& DrizzleMySqlConfig<TRelations>
 			& ({
 				connection: string | PoolOptions;
 			} | {
@@ -139,8 +96,8 @@ export function drizzle<
 			})
 		),
 	]
-): MySql2Database<TSchema> & {
-	$client: TClient;
+): MySql2Database<TRelations> & {
+	$client: AnyMySql2Connection extends TClient ? Pool : TClient;
 } {
 	if (typeof params[0] === 'string') {
 		const connectionString = params[0]!;
@@ -151,33 +108,30 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: PoolOptions | string; client?: TClient }
-			& MySql2DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleMySqlConfig } = params[0] as
+		& { connection?: PoolOptions | string; client?: TClient }
+		& DrizzleMySqlConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleMySqlConfig) as any;
 
-		const instance = typeof connection === 'string'
-			? createPool({
-				uri: connection,
-				supportBigNumbers: true,
-			})
-			: createPool(connection!);
-		const db = construct(instance, drizzleConfig);
-
-		return db as any;
-	}
+	const instance = typeof connection === 'string'
+		? createPool({
+			uri: connection,
+		})
+		: createPool(connection!);
+	const db = construct(instance, DrizzleMySqlConfig);
 
-	return construct(params[0] as TClient, params[1] as MySql2DrizzleConfig<TSchema> | undefined) as any;
+	return db as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: MySql2DrizzleConfig<TSchema>,
-	): MySql2Database<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzleMySqlConfig<TRelations>,
+	): MySql2Database<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
-		return construct({} as any, config) as any;
+		return construct({ config: {} } as any, config) as any;
 	}
 }
diff --git a/drizzle-orm/src/mysql2/index.ts b/drizzle-orm/src/mysql2/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/mysql2/index.ts
+++ b/drizzle-orm/src/mysql2/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/mysql2/migrator.ts b/drizzle-orm/src/mysql2/migrator.ts
index 2f3c9c3dcf..ff6f6696aa 100644
--- a/drizzle-orm/src/mysql2/migrator.ts
+++ b/drizzle-orm/src/mysql2/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/mysql-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { MySql2Database } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: MySql2Database<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: MySql2Database<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/mysql2/session.ts b/drizzle-orm/src/mysql2/session.ts
index 7c0b35c9ce..7e105cbdd2 100644
--- a/drizzle-orm/src/mysql2/session.ts
+++ b/drizzle-orm/src/mysql2/session.ts
@@ -1,39 +1,30 @@
-import type { Connection as CallbackConnection } from 'mysql2';
+import type { Connection as CallbackConnection, TypeCast } from 'mysql2';
 import type {
 	Connection,
 	FieldPacket,
 	OkPacket,
 	Pool,
 	PoolConnection,
-	QueryOptions,
 	ResultSetHeader,
 	RowDataPacket,
 } from 'mysql2/promise';
 import { once } from 'node:events';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { Column } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { MySqlAsyncPreparedQuery, MySqlAsyncSession, MySqlAsyncTransaction } from '~/mysql-core/async/session.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
-import {
-	type Mode,
-	MySqlPreparedQuery,
-	type MySqlPreparedQueryConfig,
-	type MySqlPreparedQueryHKT,
-	type MySqlQueryResultHKT,
-	MySqlSession,
-	MySqlTransaction,
-	type MySqlTransactionConfig,
-	type PreparedQueryKind,
+import type {
+	AnyMySqlMapper,
+	MySqlPreparedQueryConfig,
+	MySqlQueryResultHKT,
+	MySqlTransactionConfig,
 } from '~/mysql-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, sql } from '~/sql/sql.ts';
-import type { Query, SQL } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
+import type { AnyRelations } from '~/relations.ts';
+import { sql } from '~/sql/sql.ts';
+import type { Query } from '~/sql/sql.ts';
 export type MySql2Client = Pool | Connection;
 
 export type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
@@ -42,260 +33,134 @@ export type MySqlQueryResult<
 	T = any,
 > = [T extends ResultSetHeader ? T : T[], FieldPacket[]];
 
-export class MySql2PreparedQuery<T extends MySqlPreparedQueryConfig> extends MySqlPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'MySql2PreparedQuery';
-
-	private rawQuery: QueryOptions;
-	private query: QueryOptions;
-
-	constructor(
-		private client: MySql2Client,
-		queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-		// Keys that were used in $default and the value that was generated for them
-		private generatedIds?: Record<string, unknown>[],
-		// Keys that should be returned, it has the column with all properries + key from object
-		private returningIds?: SelectedFieldsOrdered,
-	) {
-		super(cache, queryMetadata, cacheConfig);
-		this.rawQuery = {
-			sql: queryString,
-			// rowsAsArray: true,
-			typeCast: function(field: any, next: any) {
-				if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-					return field.string();
-				}
-				return next();
-			},
-		};
-		this.query = {
-			sql: queryString,
-			rowsAsArray: true,
-			typeCast: function(field: any, next: any) {
-				if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-					return field.string();
-				}
-				return next();
-			},
-		};
-	}
-
-	async execute(placeholderValues: Record<string, unknown> = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.rawQuery.sql, params);
-
-		const { fields, client, rawQuery, query, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } =
-			this;
-		if (!fields && !customResultMapper) {
-			const res = await this.queryWithCache(rawQuery.sql, params, async () => {
-				return await client.query<any>(rawQuery, params);
-			});
-
-			const insertId = res[0].insertId;
-			const affectedRows = res[0].affectedRows;
-			// for each row, I need to check keys from
-			if (returningIds) {
-				const returningResponse = [];
-				let j = 0;
-				for (let i = insertId; i < insertId + affectedRows; i++) {
-					for (const column of returningIds) {
-						const key = returningIds[0]!.path[0]!;
-						if (is(column.field, Column)) {
-							// @ts-ignore
-							if (column.field.primary && column.field.autoIncrement) {
-								returningResponse.push({ [key]: i });
-							}
-							if (column.field.defaultFn && generatedIds) {
-								// generatedIds[rowIdx][key]
-								returningResponse.push({ [key]: generatedIds[j]![key] });
-							}
-						}
-					}
-					j++;
-				}
-
-				return returningResponse;
-			}
-			return res;
-		}
-
-		const result = await this.queryWithCache(query.sql, params, async () => {
-			return await client.query<any[]>(query, params);
-		});
-
-		const rows = result[0];
-
-		if (customResultMapper) {
-			return customResultMapper(rows);
-		}
-
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	async *iterator(
-		placeholderValues: Record<string, unknown> = {},
-	): AsyncGenerator<T['execute'] extends any[] ? T['execute'][number] : T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		const conn = ((isPool(this.client) ? await this.client.getConnection() : this.client) as {} as {
-			connection: CallbackConnection;
-		}).connection;
-
-		const { fields, query, rawQuery, joinsNotNullableMap, client, customResultMapper } = this;
-		const hasRowsMapper = Boolean(fields || customResultMapper);
-		const driverQuery = hasRowsMapper ? conn.query(query, params) : conn.query(rawQuery, params);
-
-		const stream = driverQuery.stream();
-
-		function dataListener() {
-			stream.pause();
-		}
-
-		stream.on('data', dataListener);
-
-		try {
-			const onEnd = once(stream, 'end');
-			const onError = once(stream, 'error');
-
-			while (true) {
-				stream.resume();
-				const row = await Promise.race([onEnd, onError, new Promise((resolve) => stream.once('data', resolve))]);
-				if (row === undefined || (Array.isArray(row) && row.length === 0)) {
-					break;
-				} else if (row instanceof Error) { // eslint-disable-line no-instanceof/no-instanceof
-					throw row;
-				} else {
-					if (hasRowsMapper) {
-						if (customResultMapper) {
-							const mappedRow = customResultMapper([row as unknown[]]);
-							yield (Array.isArray(mappedRow) ? mappedRow[0] : mappedRow);
-						} else {
-							yield mapResultRow(fields!, row as unknown[], joinsNotNullableMap);
-						}
-					} else {
-						yield row as T['execute'];
-					}
-				}
-			}
-		} finally {
-			stream.off('data', dataListener);
-			if (isPool(client)) {
-				conn.end();
-			}
-		}
-	}
-}
-
 export interface MySql2SessionOptions {
 	logger?: Logger;
 	cache?: Cache;
-	mode: Mode;
 }
 
+const typeCast: TypeCast = function(field, next) {
+	if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+		return field.string();
+	}
+	return next();
+};
+
 export class MySql2Session<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlSession<MySqlQueryResultHKT, MySql2PreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncSession<MySqlQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'MySql2Session';
 
 	private logger: Logger;
-	private mode: Mode;
 	private cache: Cache;
 
 	constructor(
 		private client: MySql2Client,
 		dialect: MySqlDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: MySql2SessionOptions,
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
-		this.mode = options.mode;
 	}
 
 	prepareQuery<T extends MySqlPreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		generatedIds?: Record<string, unknown>[],
-		returningIds?: SelectedFieldsOrdered,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: AnyMySqlMapper,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PreparedQueryKind<MySql2PreparedQueryHKT, T> {
-		// Add returningId fields
-		// Each driver gets them from response from database
-		return new MySql2PreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): MySqlAsyncPreparedQuery<T> {
+		const { client } = this;
+
+		const executor = async (params: any[] = []) => {
+			const raw = client.query<any[]>({
+				sql: query.sql,
+				typeCast,
+				rowsAsArray: mode === 'arrays',
+			}, params);
+			if (mode !== 'raw') return raw.then((data) => data[0]);
+			if (!mapper) return raw;
+
+			return raw.then(([res]: [any, FieldPacket[]]) => ({
+				insertId: res.insertId,
+				affectedRows: res.affectedRows,
+			}));
+		};
+
+		const iterator = async function*(params: any[] = []): AsyncGenerator<any> {
+			const conn = ((isPool(client) ? await client.getConnection() : client) as {} as {
+				connection: CallbackConnection;
+			}).connection;
+			const driverQuery = conn.query({
+				sql: query.sql,
+				typeCast,
+				rowsAsArray: mode === 'arrays',
+			}, params);
+			const stream = driverQuery.stream();
+
+			function dataListener() {
+				stream.pause();
+			}
+
+			stream.on('data', dataListener);
+
+			try {
+				const onEnd = once(stream, 'end');
+				const onError = once(stream, 'error');
+				while (true) {
+					stream.resume();
+
+					const row = await Promise.race([onEnd, onError, new Promise((resolve) => stream.once('data', resolve))]);
+					if (row === undefined || (Array.isArray(row) && row.length === 0)) {
+						break;
+					}
+					if (row instanceof Error) { // oxlint-disable-line drizzle-internal/no-instanceof
+						throw row;
+					}
+					yield row;
+				}
+			} finally {
+				stream.off('data', dataListener);
+				if (isPool(client)) {
+					conn.end();
+				}
+			}
+		};
+
+		return new MySqlAsyncPreparedQuery(
+			executor,
+			iterator,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			customResultMapper,
-			generatedIds,
-			returningIds,
-		) as PreparedQueryKind<MySql2PreparedQueryHKT, T>;
-	}
-
-	/**
-	 * @internal
-	 * What is its purpose?
-	 */
-	async query(query: string, params: unknown[]): Promise<MySqlQueryResult> {
-		this.logger.logQuery(query, params);
-		const result = await this.client.query({
-			sql: query,
-			values: params,
-			rowsAsArray: true,
-			typeCast: function(field: any, next: any) {
-				if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-					return field.string();
-				}
-				return next();
-			},
-		});
-		return result;
-	}
-
-	override all<T = unknown>(query: SQL): Promise<T[]> {
-		const querySql = this.dialect.sqlToQuery(query);
-		this.logger.logQuery(querySql.sql, querySql.params);
-		return this.client.execute(querySql.sql, querySql.params).then((result) => result[0]) as Promise<T[]>;
+		);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: MySql2Transaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: MySql2Transaction<TRelations>) => Promise<T>,
 		config?: MySqlTransactionConfig,
 	): Promise<T> {
 		const session = isPool(this.client)
 			? new MySql2Session(
 				await this.client.getConnection(),
 				this.dialect,
-				this.schema,
+				this.relations,
 				this.options,
 			)
 			: this;
-		const tx = new MySql2Transaction<TFullSchema, TSchema>(
+		const tx = new MySql2Transaction<TRelations>(
 			this.dialect,
-			session as MySqlSession<any, any, any, any>,
-			this.schema,
+			session as MySqlAsyncSession<any, any>,
+			this.relations,
 			0,
-			this.mode,
 		);
 		if (config) {
 			const setTransactionConfigSql = this.getSetTransactionSQL(config);
@@ -323,19 +188,22 @@ export class MySql2Session<
 }
 
 export class MySql2Transaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlTransaction<MySql2QueryResultHKT, MySql2PreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncTransaction<
+	MySql2QueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'MySql2Transaction';
 
-	override async transaction<T>(transaction: (tx: MySql2Transaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: MySql2Transaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new MySql2Transaction<TFullSchema, TSchema>(
+		const tx = new MySql2Transaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this.relations,
 			this.nestedIndex + 1,
-			this.mode,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
@@ -356,7 +224,3 @@ function isPool(client: MySql2Client): client is Pool {
 export interface MySql2QueryResultHKT extends MySqlQueryResultHKT {
 	type: MySqlRawQueryResult;
 }
-
-export interface MySql2PreparedQueryHKT extends MySqlPreparedQueryHKT {
-	type: MySql2PreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/neon-http/codecs.ts b/drizzle-orm/src/neon-http/codecs.ts
new file mode 100644
index 0000000000..220d62fa44
--- /dev/null
+++ b/drizzle-orm/src/neon-http/codecs.ts
@@ -0,0 +1,91 @@
+import { parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const neonHttpCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	bytea: {
+		normalizeParam: String,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	json: {
+		normalizeParam: (v) => JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
diff --git a/drizzle-orm/src/neon-http/driver.ts b/drizzle-orm/src/neon-http/driver.ts
index 53ed6e2117..f13b833091 100644
--- a/drizzle-orm/src/neon-http/driver.ts
+++ b/drizzle-orm/src/neon-http/driver.ts
@@ -1,118 +1,34 @@
 import type { HTTPQueryOptions, HTTPTransactionOptions, NeonQueryFunction } from '@neondatabase/serverless';
 import { neon, types } from '@neondatabase/serverless';
 import type { BatchItem, BatchResponse } from '~/batch.ts';
-import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import { createTableRelationsHelpers, extractTablesRelationalConfig } from '~/relations.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import { type NeonHttpClient, type NeonHttpQueryResultHKT, NeonHttpSession } from './session.ts';
-
-export interface NeonDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class NeonHttpDriver {
-	static readonly [entityKind]: string = 'NeonHttpDriver';
-
-	constructor(
-		private client: NeonHttpClient,
-		private dialect: PgDialect,
-		private options: NeonDriverOptions = {},
-	) {
-		this.initMappers();
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): NeonHttpSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new NeonHttpSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-
-	initMappers() {
-		types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
-		types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
-		types.setTypeParser(types.builtins.DATE, (val) => val);
-		types.setTypeParser(types.builtins.INTERVAL, (val) => val);
-		types.setTypeParser(1231, (val) => val);
-		types.setTypeParser(1115, (val) => val);
-		types.setTypeParser(1185, (val) => val);
-		types.setTypeParser(1187, (val) => val);
-		types.setTypeParser(1182, (val) => val);
-	}
-}
-
-function wrap<T extends object>(
-	target: T,
-	token: Exclude<HTTPQueryOptions<true, true>['authToken'], undefined>,
-	cb: (target: any, p: string | symbol, res: any) => any,
-	deep?: boolean,
-) {
-	return new Proxy(target, {
-		get(target, p) {
-			const element = target[p as keyof typeof p];
-			if (typeof element !== 'function' && (typeof element !== 'object' || element === null)) return element;
-
-			if (deep) return wrap(element, token, cb);
-			if (p === 'query') return wrap(element, token, cb, true);
-
-			return new Proxy(element as any, {
-				apply(target, thisArg, argArray) {
-					const res = target.call(thisArg, ...argArray);
-					if (typeof res === 'object' && res !== null && 'setToken' in res && typeof res.setToken === 'function') {
-						res.setToken(token);
-					}
-					return cb(target, p, res);
-				},
-			});
-		},
-	});
-}
-
-export class NeonHttpDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<NeonHttpQueryResultHKT, TSchema> {
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { neonHttpCodecs } from './codecs.ts';
+import { type NeonHttpQueryResultHKT, NeonHttpSession } from './session.ts';
+
+export class NeonHttpDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<NeonHttpQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'NeonHttpDatabase';
 
+	/** @intenal */
+	declare session: NeonHttpSession<TRelations>;
+
 	$withAuth(
 		token: Exclude<HTTPQueryOptions<true, true>['authToken'], undefined>,
-	): Omit<
-		this,
-		Exclude<
-			keyof this,
-			| '$count'
-			| 'delete'
-			| 'select'
-			| 'selectDistinct'
-			| 'selectDistinctOn'
-			| 'update'
-			| 'insert'
-			| 'with'
-			| 'query'
-			| 'execute'
-			| 'refreshMaterializedView'
-		>
-	> {
-		this.authToken = token;
-
-		return wrap(this, token, (target, p, res) => {
-			if (p === 'with') {
-				return wrap(res, token, (_, __, res) => res);
-			}
-			return res;
+	): Omit<this, '$withAuth'> {
+		const session = new NeonHttpSession(this.session.client, this.dialect, this._.relations, {
+			...this.session.options,
+			authToken: token,
 		});
-	}
 
-	/** @internal */
-	declare readonly session: NeonHttpSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+		return new NeonHttpDatabase(this.dialect, session, this._.relations) as any;
+	}
 
 	async batch<U extends BatchItem<'pg'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
@@ -122,15 +38,18 @@ export class NeonHttpDatabase<
 }
 
 function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NeonQueryFunction<any, any> = NeonQueryFunction<any, any>,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): NeonHttpDatabase<TSchema> & {
+	config: DrizzlePgConfig<TRelations> = {},
+): NeonHttpDatabase<TRelations> & {
 	$client: TClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? neonHttpCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -138,27 +57,24 @@ function construct<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
+	const relations = config.relations ?? {} as TRelations;
 
-	const driver = new NeonHttpDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
+	const session = new NeonHttpSession(client, dialect, relations ?? {} as EmptyRelations, {
+		logger,
+		cache: config.cache,
+	});
 
-	const db = new NeonHttpDatabase(
-		dialect,
-		session,
-		schema as RelationalSchemaConfig<ExtractTablesWithRelations<TSchema>> | undefined,
-	);
+	types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
+	types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
+	types.setTypeParser(types.builtins.DATE, (val) => val);
+	types.setTypeParser(types.builtins.INTERVAL, (val) => val);
+	types.setTypeParser(1231, (val) => val);
+	types.setTypeParser(1115, (val) => val);
+	types.setTypeParser(1185, (val) => val);
+	types.setTypeParser(1187, (val) => val);
+	types.setTypeParser(1182, (val) => val);
+
+	const db = new NeonHttpDatabase(dialect, session, relations);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -169,17 +85,17 @@ function construct<
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NeonQueryFunction<any, any> = NeonQueryFunction<false, false>,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzlePgConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzlePgConfig<TRelations>
 			& ({
 				connection: string | ({ connectionString: string } & HTTPTransactionOptions<boolean, boolean>);
 			} | {
@@ -187,7 +103,7 @@ export function drizzle<
 			})
 		),
 	]
-): NeonHttpDatabase<TSchema> & {
+): NeonHttpDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -195,40 +111,38 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& {
-				connection?:
-					| ({
-						connectionString: string;
-					} & HTTPTransactionOptions<boolean, boolean>)
-					| string;
-				client?: TClient;
-			}
-			& DrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig);
-
-		if (typeof connection === 'object') {
-			const { connectionString, ...options } = connection;
+	const { connection, client, ...DrizzlePgConfig } = params[0] as
+		& {
+			connection?:
+				| ({
+					connectionString: string;
+				} & HTTPTransactionOptions<boolean, boolean>)
+				| string;
+			client?: TClient;
+		}
+		& DrizzlePgConfig<TRelations>;
 
-			const instance = neon(connectionString, options);
+	if (client) return construct(client, DrizzlePgConfig);
 
-			return construct(instance, drizzleConfig) as any;
-		}
+	if (typeof connection === 'object') {
+		const { connectionString, ...options } = connection;
 
-		const instance = neon(connection!);
+		const instance = neon(connectionString, options);
 
-		return construct(instance, drizzleConfig) as any;
+		return construct(instance, DrizzlePgConfig) as any;
 	}
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	const instance = neon(connection!);
+
+	return construct(instance, DrizzlePgConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): NeonHttpDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): NeonHttpDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/neon-http/index.ts b/drizzle-orm/src/neon-http/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/neon-http/index.ts
+++ b/drizzle-orm/src/neon-http/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/neon-http/migrator.ts b/drizzle-orm/src/neon-http/migrator.ts
index db87842487..a77209e7bb 100644
--- a/drizzle-orm/src/neon-http/migrator.ts
+++ b/drizzle-orm/src/neon-http/migrator.ts
@@ -1,6 +1,9 @@
-import type { MigrationConfig } from '~/migrator.ts';
+import type { MigrationConfig, MigratorInitFailResponse } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { type SQL, sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/pg.ts';
 import type { NeonHttpDatabase } from './driver.ts';
 
 /**
@@ -11,46 +14,70 @@ import type { NeonHttpDatabase } from './driver.ts';
  * @param db - drizzle db instance
  * @param config - path to migration folder generated by drizzle-kit
  */
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: NeonHttpDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: NeonHttpDatabase<TRelations>,
 	config: MigrationConfig,
-) {
+): Promise<void | MigratorInitFailResponse> {
 	const migrations = readMigrationFiles(config);
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
 	const migrationsSchema = config.migrationsSchema ?? 'drizzle';
-	const migrationTableCreate = sql`
+
+	await db.session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
+
+	const { newDb } = await upgradeIfNeeded(migrationsSchema, migrationsTable, db, migrations, 'batch');
+
+	if (newDb) {
+		const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
 			id SERIAL PRIMARY KEY,
 			hash text NOT NULL,
-			created_at bigint
+			created_at bigint,
+			name text,
+			applied_at timestamp with time zone DEFAULT now()
 		)
 	`;
-	await db.session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
-	await db.session.execute(migrationTableCreate);
 
-	const dbMigrations = await db.session.all<{ id: number; hash: string; created_at: string }>(
-		sql`select id, hash, created_at from ${sql.identifier(migrationsSchema)}.${
-			sql.identifier(migrationsTable)
-		} order by created_at desc limit 1`,
+		await db.session.execute(migrationTableCreate);
+	}
+
+	const dbMigrations = await db.session.objects<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} `,
 	);
 
-	const lastDbMigration = dbMigrations[0];
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await db.session.execute(
+			sql`insert into ${sql.identifier(migrationsSchema)}.${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
 	const rowsToInsert: SQL[] = [];
-	for await (const migration of migrations) {
-		if (
-			!lastDbMigration
-			|| Number(lastDbMigration.created_at) < migration.folderMillis
-		) {
-			for (const stmt of migration.sql) {
-				await db.session.execute(sql.raw(stmt));
-			}
-
-			rowsToInsert.push(
-				sql`insert into ${sql.identifier(migrationsSchema)}.${
-					sql.identifier(migrationsTable)
-				} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`,
-			);
+	for await (const migration of migrationsToRun) {
+		for (const stmt of migration.sql) {
+			await db.session.execute(sql.raw(stmt));
 		}
+
+		rowsToInsert.push(
+			sql`insert into ${sql.identifier(migrationsSchema)}.${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
 	}
 
 	for await (const rowToInsert of rowsToInsert) {
diff --git a/drizzle-orm/src/neon-http/session.ts b/drizzle-orm/src/neon-http/session.ts
index 567c464710..be7759b357 100644
--- a/drizzle-orm/src/neon-http/session.ts
+++ b/drizzle-orm/src/neon-http/session.ts
@@ -5,248 +5,111 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, type PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery as PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { PreparedQuery } from '~/session.ts';
-import { fillPlaceholders, type Query, type SQL } from '~/sql/sql.ts';
-import { mapResultRow, type NeonAuthToken } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { NeonAuthToken } from '~/utils.ts';
 
 export type NeonHttpClient = NeonQueryFunction<any, any>;
 
-const rawQueryConfig = {
-	arrayMode: false,
-	fullResults: true,
-} as const;
-const queryConfig = {
-	arrayMode: true,
-	fullResults: true,
-} as const;
-
-export class NeonHttpPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'NeonHttpPreparedQuery';
-	private clientQuery: (sql: string, params: any[], opts: Record<string, any>) => NeonQueryPromise<any, any>;
-
-	constructor(
-		private client: NeonHttpClient,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super(query, cache, queryMetadata, cacheConfig);
-		// `client.query` is for @neondatabase/serverless v1.0.0 and up, where the
-		// root query function `client` is only usable as a template function;
-		// `client` is a fallback for earlier versions
-		this.clientQuery = (client as any).query ?? client as any;
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined): Promise<T['execute']>;
-	/** @internal */
-	async execute(placeholderValues: Record<string, unknown> | undefined, token?: NeonAuthToken): Promise<T['execute']>;
-	/** @internal */
-	async execute(
-		placeholderValues: Record<string, unknown> | undefined = {},
-		token: NeonAuthToken | undefined = this.authToken,
-	): Promise<T['execute']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, clientQuery, query, customResultMapper } = this;
-
-		if (!fields && !customResultMapper) {
-			return this.queryWithCache(query.sql, params, async () => {
-				return clientQuery(
-					query.sql,
-					params,
-					token === undefined
-						? rawQueryConfig
-						: {
-							...rawQueryConfig,
-							authToken: token,
-						},
-				);
-			});
-		}
-
-		const result = await this.queryWithCache(query.sql, params, async () => {
-			return await clientQuery(
-				query.sql,
-				params,
-				token === undefined
-					? queryConfig
-					: {
-						...queryConfig,
-						authToken: token,
-					},
-			);
-		});
-
-		return this.mapResult(result);
-	}
-
-	override mapResult(result: unknown): unknown {
-		if (!this.fields && !this.customResultMapper) {
-			return result;
-		}
-
-		const rows = (result as FullQueryResults<true>).rows;
-
-		if (this.customResultMapper) {
-			return this.customResultMapper(rows);
-		}
-
-		return rows.map((row) => mapResultRow(this.fields!, row, this.joinsNotNullableMap));
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-		this.logger.logQuery(this.query.sql, params);
-		return this.clientQuery(
-			this.query.sql,
-			params,
-			this.authToken === undefined ? rawQueryConfig : {
-				...rawQueryConfig,
-				authToken: this.authToken,
-			},
-		).then((result) => result.rows);
-	}
-
-	values(placeholderValues: Record<string, unknown> | undefined): Promise<T['values']>;
-	/** @internal */
-	values(placeholderValues: Record<string, unknown> | undefined, token?: NeonAuthToken): Promise<T['values']>;
-	/** @internal */
-	values(placeholderValues: Record<string, unknown> | undefined = {}, token?: NeonAuthToken): Promise<T['values']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-		this.logger.logQuery(this.query.sql, params);
-		return this.clientQuery(this.query.sql, params, { arrayMode: true, fullResults: true, authToken: token }).then((
-			result,
-		) => result.rows);
-	}
-
-	/** @internal */
-	isResponseInArrayMode() {
-		return this._isResponseInArrayMode;
-	}
-}
-
 export interface NeonHttpSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	authToken?: NeonAuthToken;
 }
 
-export class NeonHttpSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<NeonHttpQueryResultHKT, TFullSchema, TSchema> {
+export class NeonHttpSession<TRelations extends AnyRelations>
+	extends PgAsyncSession<NeonHttpQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'NeonHttpSession';
 
-	private clientQuery: (sql: string, params: any[], opts: Record<string, any>) => NeonQueryPromise<any, any>;
 	private logger: Logger;
 	private cache: Cache;
 
+	/** @internal */
+	readonly client: NeonHttpClient;
 	constructor(
-		private client: NeonHttpClient,
+		client: NeonHttpClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		private options: NeonHttpSessionOptions = {},
+		private relations: AnyRelations,
+		readonly options: NeonHttpSessionOptions = {},
 	) {
 		super(dialect);
+		this.client = client;
 		// `client.query` is for @neondatabase/serverless v1.0.0 and up, where the
 		// root query function `client` is only usable as a template function;
 		// `client` is a fallback for earlier versions
-		this.clientQuery = (client as any).query ?? client as any;
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new NeonHttpPreparedQuery(
-			this.client,
-			query,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
-		);
+	): PgAsyncPreparedQuery<T> {
+		const executor = (params?: unknown[]) => {
+			// `client.query` is for @neondatabase/serverless v1.0.0 and up, where the
+			// root query function `httpClient` is only usable as a template function;
+			// `client` is a fallback for earlier versions
+			const q = ((this.client as any).query ?? this.client as any) as NeonHttpClient;
+			if (mode === 'raw') {
+				// otherwise raw queries with .then crash due to .then not existing on raw mode queries
+				return (async () =>
+					q(query.sql, params, {
+						arrayMode: false,
+						fullResults: true,
+						authToken: this.options.authToken,
+					}))();
+			}
+
+			return q(query.sql, params, {
+				arrayMode: mode === 'arrays',
+				fullResults: true,
+				authToken: this.options.authToken,
+			}).then((it: any) => it.rows);
+		};
+
+		return new PgAsyncPreparedQuery(executor, query, mapper, mode, this.logger, this.cache, queryMetadata, cacheConfig);
 	}
 
-	async batch<U extends BatchItem<'pg'>, T extends Readonly<[U, ...U[]]>>(
-		queries: T,
-	) {
-		const preparedQueries: PreparedQuery[] = [];
+	async batch<U extends BatchItem<'pg'>, T extends Readonly<[U, ...U[]]>>(queries: T) {
+		const preparedQueries: PgAsyncPreparedQuery<any>[] = [];
 		const builtQueries: NeonQueryPromise<any, true>[] = [];
+		const q = (this.client as any).query ?? this.client as any;
+
 		for (const query of queries) {
-			const preparedQuery = query._prepare();
+			const preparedQuery = query._prepare() as PgAsyncPreparedQuery<any>;
 			const builtQuery = preparedQuery.getQuery();
 			preparedQueries.push(preparedQuery);
 			builtQueries.push(
-				this.clientQuery(builtQuery.sql, builtQuery.params, {
+				q(builtQuery.sql, builtQuery.params, {
 					fullResults: true,
-					arrayMode: preparedQuery.isResponseInArrayMode(),
+					arrayMode: preparedQuery.mode === 'arrays',
 				}),
 			);
 		}
 
-		const batchResults = await this.client.transaction(builtQueries, queryConfig);
-
-		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true)) as any;
-	}
-
-	// change return type to QueryRows<true>
-	async query(query: string, params: unknown[]): Promise<FullQueryResults<true>> {
-		this.logger.logQuery(query, params);
-		const result = await this.clientQuery(query, params, { arrayMode: true, fullResults: true });
-		return result;
-	}
-
-	// change return type to QueryRows<false>
-	async queryObjects(
-		query: string,
-		params: unknown[],
-	): Promise<FullQueryResults<false>> {
-		return this.clientQuery(query, params, { arrayMode: false, fullResults: true });
-	}
-
-	override async count(sql: SQL): Promise<number>;
-	/** @internal */
-	override async count(sql: SQL, token?: NeonAuthToken): Promise<number>;
-	/** @internal */
-	override async count(sql: SQL, token?: NeonAuthToken): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql, token);
-
-		return Number(
-			res['rows'][0]['count'],
-		);
+		const batchResults = await this.client.transaction(builtQueries, {
+			authToken: this.options.authToken,
+			fullResults: true,
+			arrayMode: true,
+		});
+		return batchResults.map((result, i) =>
+			preparedQueries[i]!.mapper ? preparedQueries[i]!.mapper(result.rows) : result
+		) as any;
 	}
 
 	override async transaction<T>(
-		_transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: PgAsyncTransaction<NeonHttpQueryResultHKT, TRelations>) => Promise<T>,
 		// eslint-disable-next-line @typescript-eslint/no-unused-vars
 		_config: PgTransactionConfig = {},
 	): Promise<T> {
@@ -254,28 +117,6 @@ export class NeonHttpSession<
 	}
 }
 
-export class NeonTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<NeonHttpQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'NeonHttpTransaction';
-
-	override async transaction<T>(_transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
-		throw new Error('No transactions support in neon-http driver');
-		// const savepointName = `sp${this.nestedIndex + 1}`;
-		// const tx = new NeonTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
-		// await tx.execute(sql.raw(`savepoint ${savepointName}`));
-		// try {
-		// 	const result = await transaction(tx);
-		// 	await tx.execute(sql.raw(`release savepoint ${savepointName}`));
-		// 	return result;
-		// } catch (e) {
-		// 	await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
-		// 	throw e;
-		// }
-	}
-}
-
 export type NeonHttpQueryResult<T> = Omit<FullQueryResults<false>, 'rows'> & { rows: T[] };
 
 export interface NeonHttpQueryResultHKT extends PgQueryResultHKT {
diff --git a/drizzle-orm/src/neon-serverless/codecs.ts b/drizzle-orm/src/neon-serverless/codecs.ts
new file mode 100644
index 0000000000..63c4a750fd
--- /dev/null
+++ b/drizzle-orm/src/neon-serverless/codecs.ts
@@ -0,0 +1,89 @@
+import { parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const neonServerlessCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	// driver handles objects, other types need to be stringified
+	json: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
diff --git a/drizzle-orm/src/neon-serverless/driver.ts b/drizzle-orm/src/neon-serverless/driver.ts
index 765732f607..4f9c6902d9 100644
--- a/drizzle-orm/src/neon-serverless/driver.ts
+++ b/drizzle-orm/src/neon-serverless/driver.ts
@@ -3,59 +3,40 @@ import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { neonServerlessCodecs } from './codecs.ts';
 import type { NeonClient, NeonQueryResultHKT } from './session.ts';
 import { NeonSession } from './session.ts';
 
 export interface NeonDriverOptions {
 	logger?: Logger;
 	cache?: Cache;
+	useJitMappers?: boolean;
 }
 
-export class NeonDriver {
-	static readonly [entityKind]: string = 'NeonDriver';
-
-	constructor(
-		private client: NeonClient,
-		private dialect: PgDialect,
-		private options: NeonDriverOptions = {},
-	) {
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): NeonSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new NeonSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-}
-
-export class NeonDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<NeonQueryResultHKT, TSchema> {
+export class NeonDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<NeonQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'NeonServerlessDatabase';
 }
 
 function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NeonClient = NeonClient,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): NeonDatabase<TSchema> & {
-	$client: TClient;
+	config: DrizzlePgConfig<TRelations> = {},
+): NeonDatabase<TRelations> & {
+	$client: NeonClient extends TClient ? Pool : TClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? neonServerlessCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -63,22 +44,12 @@ function construct<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new NeonDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
-	const db = new NeonDatabase(dialect, session, schema as any) as NeonDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new NeonSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new NeonDatabase(dialect, session, relations) as NeonDatabase<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -89,17 +60,17 @@ function construct<
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NeonClient = Pool,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzlePgConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzlePgConfig<TRelations>
 			& ({
 				connection: string | PoolConfig;
 			} | {
@@ -110,8 +81,8 @@ export function drizzle<
 			}
 		),
 	]
-): NeonDatabase<TSchema> & {
-	$client: TClient;
+): NeonDatabase<TRelations> & {
+	$client: NeonClient extends TClient ? Pool : TClient;
 } {
 	if (typeof params[0] === 'string') {
 		const instance = new Pool({
@@ -121,35 +92,33 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ws, ...drizzleConfig } = params[0] as {
+	const { connection, client, ws, ...DrizzlePgConfig } = params[0] as
+		& {
 			connection?: PoolConfig | string;
 			ws?: any;
 			client?: TClient;
-		} & DrizzleConfig<TSchema>;
-
-		if (ws) {
-			neonConfig.webSocketConstructor = ws;
 		}
+		& DrizzlePgConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig);
+	if (ws) {
+		neonConfig.webSocketConstructor = ws;
+	}
 
-		const instance = typeof connection === 'string'
-			? new Pool({
-				connectionString: connection,
-			})
-			: new Pool(connection);
+	if (client) return construct(client, DrizzlePgConfig);
 
-		return construct(instance, drizzleConfig) as any;
-	}
+	const instance = typeof connection === 'string'
+		? new Pool({
+			connectionString: connection,
+		})
+		: new Pool(connection);
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzlePgConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): NeonDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzlePgConfig<TRelations>,
+	): NeonDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/neon-serverless/index.ts b/drizzle-orm/src/neon-serverless/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/neon-serverless/index.ts
+++ b/drizzle-orm/src/neon-serverless/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/neon-serverless/migrator.ts b/drizzle-orm/src/neon-serverless/migrator.ts
index 9948f245ca..e3b6cec9e6 100644
--- a/drizzle-orm/src/neon-serverless/migrator.ts
+++ b/drizzle-orm/src/neon-serverless/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { NeonDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: NeonDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: NeonDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/neon-serverless/session.ts b/drizzle-orm/src/neon-serverless/session.ts
index bc60642a18..25ea48108c 100644
--- a/drizzle-orm/src/neon-serverless/session.ts
+++ b/drizzle-orm/src/neon-serverless/session.ts
@@ -1,9 +1,8 @@
 import {
 	type Client,
+	type CustomTypesConfig,
 	Pool,
 	type PoolClient,
-	type QueryArrayConfig,
-	type QueryConfig,
 	type QueryResult,
 	type QueryResultRow,
 	types,
@@ -13,182 +12,42 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 
 export type NeonClient = Pool | PoolClient | Client;
 
-export class NeonPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'NeonPreparedQuery';
-
-	private rawQueryConfig: QueryConfig;
-	private queryConfig: QueryArrayConfig;
-
-	constructor(
-		private client: NeonClient,
-		queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-		this.rawQueryConfig = {
-			name,
-			text: queryString,
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val: any) => val;
-					}
-					// numeric[]
-					if (typeId === 1231) {
-						return (val: any) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115) {
-						return (val) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185) {
-						return (val) => val;
-					}
-					// interval[]
-					if (typeId === 1187) {
-						return (val) => val;
-					}
-					// date[]
-					if (typeId === 1182) {
-						return (val) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-		this.queryConfig = {
-			name,
-			text: queryString,
-			rowMode: 'array',
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val: any) => val;
-					}
-					// numeric[]
-					if (typeId === 1231) {
-						return (val: any) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115) {
-						return (val) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185) {
-						return (val) => val;
-					}
-					// interval[]
-					if (typeId === 1187) {
-						return (val) => val;
-					}
-					// date[]
-					if (typeId === 1182) {
-						return (val) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.rawQueryConfig.text, params);
-
-		const { fields, client, rawQueryConfig: rawQuery, queryConfig: query, joinsNotNullableMap, customResultMapper } =
-			this;
-		if (!fields && !customResultMapper) {
-			return await this.queryWithCache(rawQuery.text, params, async () => {
-				return await client.query(rawQuery, params);
-			});
+const noop = (val: any) => val;
+const typeConfig: CustomTypesConfig = {
+	getTypeParser: <CustomTypesConfig['getTypeParser']> ((typeId, format) => {
+		switch (typeId as number) {
+			case types.builtins.TIMESTAMPTZ:
+			case types.builtins.TIMESTAMP:
+			case types.builtins.DATE:
+			case types.builtins.INTERVAL:
+			case 1231: // numeric[]
+			case 1115: // timestamp[]
+			case 1185: // timestamp with timezone[]
+			case 1187: // interval[]
+			case 1182: // date[]
+				return noop;
+			default:
+				return types.getTypeParser(typeId, format as any);
 		}
-
-		const result = await this.queryWithCache(query.text, params, async () => {
-			return await client.query(query, params);
-		});
-
-		return customResultMapper
-			? customResultMapper(result.rows)
-			: result.rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		this.logger.logQuery(this.rawQueryConfig.text, params);
-		return this.queryWithCache(this.rawQueryConfig.text, params, async () => {
-			return await this.client.query(this.rawQueryConfig, params);
-		}).then((result) => result.rows);
-	}
-
-	values(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['values']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		this.logger.logQuery(this.rawQueryConfig.text, params);
-		return this.queryWithCache(this.queryConfig.text, params, async () => {
-			return await this.client.query(this.queryConfig, params);
-		}).then((result) => result.rows);
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
+	}),
+};
 
 export interface NeonSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class NeonSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<NeonQueryResultHKT, TFullSchema, TSchema> {
+export class NeonSession<TRelations extends AnyRelations> extends PgAsyncSession<NeonQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'NeonSession';
 
 	private logger: Logger;
@@ -197,7 +56,7 @@ export class NeonSession<
 	constructor(
 		private client: NeonClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: NeonSessionOptions = {},
 	) {
 		super(dialect);
@@ -207,64 +66,56 @@ export class NeonSession<
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new NeonPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): PgAsyncPreparedQuery<T> {
+		const queryName = typeof name === 'string'
+			? name
+			: name === true
+			? preparedStatementName(query.sql, query.params)
+			: undefined;
+
+		const executor = async (params?: unknown[]) => {
+			return this.client.query({
+				name: queryName,
+				rowMode: mode === 'arrays' ? 'array' : undefined as any,
+				text: query.sql,
+				types: typeConfig,
+			}, params).then((r) => mode === 'raw' ? r : r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			name,
-			isResponseInArrayMode,
-			customResultMapper,
-		);
-	}
-
-	async query(query: string, params: unknown[]): Promise<QueryResult> {
-		this.logger.logQuery(query, params);
-		const result = await this.client.query({
-			rowMode: 'array',
-			text: query,
-			values: params,
-		});
-		return result;
-	}
-
-	async queryObjects<T extends QueryResultRow>(
-		query: string,
-		params: unknown[],
-	): Promise<QueryResult<T>> {
-		return this.client.query<T>(query, params);
-	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql);
-
-		return Number(
-			res['rows'][0]['count'],
 		);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: NeonTransaction<TRelations>) => Promise<T>,
 		config: PgTransactionConfig = {},
 	): Promise<T> {
-		const session = this.client instanceof Pool // eslint-disable-line no-instanceof/no-instanceof
-			? new NeonSession(await this.client.connect(), this.dialect, this.schema, this.options)
+		const session = this.client instanceof Pool // oxlint-disable-line drizzle-internal/no-instanceof
+			? new NeonSession(await this.client.connect(), this.dialect, this.relations, this.options)
 			: this;
-		const tx = new NeonTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+		const tx = new NeonTransaction<TRelations>(
+			this.dialect,
+			session,
+			this.relations,
+			undefined,
+			false,
+		);
 		await tx.execute(sql`begin ${tx.getTransactionConfigSQL(config)}`);
 		try {
 			const result = await transaction(tx);
@@ -274,7 +125,7 @@ export class NeonSession<
 			await tx.execute(sql`rollback`);
 			throw error;
 		} finally {
-			if (this.client instanceof Pool) { // eslint-disable-line no-instanceof/no-instanceof
+			if (this.client instanceof Pool) { // oxlint-disable-line drizzle-internal/no-instanceof
 				(session.client as PoolClient).release();
 			}
 		}
@@ -282,14 +133,21 @@ export class NeonSession<
 }
 
 export class NeonTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<NeonQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<NeonQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'NeonTransaction';
 
-	override async transaction<T>(transaction: (tx: NeonTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: NeonTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new NeonTransaction<TFullSchema, TSchema>(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new NeonTransaction<TRelations>(
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+			false,
+		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = await transaction(tx);
diff --git a/drizzle-orm/src/neon/index.ts b/drizzle-orm/src/neon/index.ts
index 6def59dee6..d0d96176ca 100644
--- a/drizzle-orm/src/neon/index.ts
+++ b/drizzle-orm/src/neon/index.ts
@@ -1,2 +1,2 @@
-export * from './neon-identity.ts';
+export * from './neon-auth.ts';
 export * from './rls.ts';
diff --git a/drizzle-orm/src/neon/neon-auth.ts b/drizzle-orm/src/neon/neon-auth.ts
new file mode 100644
index 0000000000..687cee7cc7
--- /dev/null
+++ b/drizzle-orm/src/neon/neon-auth.ts
@@ -0,0 +1,20 @@
+import { jsonb, pgSchema, text, timestamp } from '~/pg-core/index.ts';
+
+const neonAuthSchema = pgSchema('neon_auth');
+
+/**
+ * Table schema of the `users_sync` table used by Neon Auth.
+ * This table automatically synchronizes and stores user data from external authentication providers.
+ *
+ * @schema neon_auth
+ * @table users_sync
+ */
+export const usersSync = neonAuthSchema.table('users_sync', {
+	rawJson: jsonb('raw_json').notNull(),
+	id: text().primaryKey().notNull(),
+	name: text(),
+	email: text(),
+	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }),
+	deletedAt: timestamp('deleted_at', { withTimezone: true, mode: 'string' }),
+	updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }),
+});
diff --git a/drizzle-orm/src/neon/neon-identity.ts b/drizzle-orm/src/neon/neon-identity.ts
deleted file mode 100644
index 60af78135f..0000000000
--- a/drizzle-orm/src/neon/neon-identity.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { jsonb, pgSchema, text, timestamp } from '~/pg-core/index.ts';
-
-const neonAuthSchema = pgSchema('neon_auth');
-
-/**
- * Table schema of the `users_sync` table used by Neon Auth.
- * This table automatically synchronizes and stores user data from external authentication providers.
- *
- * @schema neon_auth
- * @table users_sync
- */
-export const usersSync = neonAuthSchema.table('users_sync', {
-	rawJson: jsonb('raw_json').notNull(),
-	id: text().primaryKey().notNull(),
-	name: text(),
-	email: text(),
-	createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }),
-	deletedAt: timestamp('deleted_at', { withTimezone: true, mode: 'string' }),
-});
diff --git a/drizzle-orm/src/netlify-db/codecs.ts b/drizzle-orm/src/netlify-db/codecs.ts
new file mode 100644
index 0000000000..adb2d61c46
--- /dev/null
+++ b/drizzle-orm/src/netlify-db/codecs.ts
@@ -0,0 +1,168 @@
+import { parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const netlifyDbCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	bytea: {
+		normalizeParam: String,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	json: {
+		normalizeParam: (v) => JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
+
+export const netlifyDbTransactionCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	// driver handles objects, other types need to be stringified
+	json: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
diff --git a/drizzle-orm/src/netlify-db/driver.ts b/drizzle-orm/src/netlify-db/driver.ts
new file mode 100644
index 0000000000..02b2bc26ab
--- /dev/null
+++ b/drizzle-orm/src/netlify-db/driver.ts
@@ -0,0 +1,264 @@
+import { type HTTPQueryOptions, neon, Pool, types } from '@neondatabase/serverless';
+import type { BatchItem, BatchResponse } from '~/batch.ts';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { NeonHttpClient, NeonHttpQueryResultHKT } from '~/neon-http/session.ts';
+import { drizzle as drizzleNodePg, type NodePgDatabase } from '~/node-postgres/driver.ts';
+import type { NodePgClient } from '~/node-postgres/session.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
+import type { PgCodecs } from '~/pg-core/codecs.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { isConfig, jitCompatCheck } from '~/utils.ts';
+import { netlifyDbCodecs, netlifyDbTransactionCodecs } from './codecs.ts';
+import { type NetlifyDbClient, NetlifyDbSession } from './session.ts';
+
+export interface ServerlessDrizzleClient {
+	driver: 'serverless';
+	httpClient: NeonHttpClient;
+	pool: Pool;
+	connectionString: string;
+}
+
+export interface ServerDrizzleClient {
+	driver: 'server';
+	pool: NodePgClient;
+	connectionString: string;
+}
+
+export type DrizzleClient = ServerlessDrizzleClient | ServerDrizzleClient;
+
+export interface DrizzleNetlifyConfig<TRelations extends AnyRelations = EmptyRelations>
+	extends DrizzlePgConfig<TRelations>
+{
+	/** Netlify utilizes different driver for transactions, thus requiring separate set of codecs */
+	transactionCodecs?: PgCodecs | undefined;
+}
+
+export class NetlifyDbDatabase<
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgAsyncDatabase<NeonHttpQueryResultHKT, TRelations> {
+	static override readonly [entityKind]: string = 'NetlifyDbDatabase';
+
+	declare session: NetlifyDbSession<TRelations>;
+
+	$withAuth(
+		token: Exclude<HTTPQueryOptions<true, true>['authToken'], undefined>,
+	): Omit<this, '$withAuth'> {
+		const session = new NetlifyDbSession(this.session.httpClient, this.session.pool, this.dialect, this._.relations, {
+			...this.session.options,
+			authToken: token,
+		});
+
+		return new NetlifyDbDatabase(this.dialect, session, this._.relations) as any;
+	}
+
+	async batch<U extends BatchItem<'pg'>, T extends Readonly<[U, ...U[]]>>(
+		batch: T,
+	): Promise<BatchResponse<T>> {
+		return this.session.batch(
+			batch,
+		) as Promise<BatchResponse<T>>;
+	}
+}
+
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	httpClient: NeonHttpClient,
+	pool: Pool,
+	config: DrizzleNetlifyConfig<TRelations> = {},
+): NetlifyDbDatabase<TRelations> & {
+	$client: NetlifyDbClient;
+} {
+	const dialect = new PgDialect({
+		codecs: config.codecs ?? netlifyDbCodecs,
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+	const relations = config.relations ?? {} as TRelations;
+
+	const session = new NetlifyDbSession(httpClient, pool, dialect, relations ?? {}, {
+		logger: logger,
+		cache: config.cache,
+		transactionCodecs: config.transactionCodecs ?? netlifyDbTransactionCodecs,
+	});
+
+	types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
+	types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
+	types.setTypeParser(types.builtins.DATE, (val) => val);
+	types.setTypeParser(types.builtins.INTERVAL, (val) => val);
+	types.setTypeParser(1231, (val) => val);
+	types.setTypeParser(1115, (val) => val);
+	types.setTypeParser(1185, (val) => val);
+	types.setTypeParser(1187, (val) => val);
+	types.setTypeParser(1182, (val) => val);
+
+	const db = new NetlifyDbDatabase(
+		dialect,
+		session,
+		relations,
+	);
+	(<any> db).$client = { http: httpClient, pool } satisfies NetlifyDbClient;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+
+	return db as any;
+}
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>():
+	| (NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient })
+	| (NodePgDatabase<TRelations> & { $client: NodePgClient });
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	config: DrizzleNetlifyConfig<TRelations>,
+):
+	| (NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient })
+	| (NodePgDatabase<TRelations> & { $client: NodePgClient });
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	config: DrizzleNetlifyConfig<TRelations> & { client: ServerlessDrizzleClient },
+): NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient };
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	config: DrizzleNetlifyConfig<TRelations> & { client: ServerDrizzleClient },
+): NodePgDatabase<TRelations> & { $client: NodePgClient };
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	config: DrizzleNetlifyConfig<TRelations> & { client: DrizzleClient },
+):
+	| (NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient })
+	| (NodePgDatabase<TRelations> & { $client: NodePgClient });
+
+export function drizzle<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleNetlifyConfig<TRelations>,
+	] | [
+		(
+			& DrizzleNetlifyConfig<TRelations>
+			& ({
+				connection: string | { connectionString: string };
+			} | {
+				client: NetlifyDbClient | DrizzleClient;
+			})
+		),
+	]
+): NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient };
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
+	...params: [] | [
+		DrizzleNetlifyConfig<TRelations>,
+	] | [
+		string,
+	] | [
+		string,
+		DrizzleNetlifyConfig<TRelations>,
+	] | [
+		(
+			& DrizzleNetlifyConfig<TRelations>
+			& ({
+				connection: string | { connectionString: string };
+			} | {
+				client: NetlifyDbClient | DrizzleClient;
+			})
+		),
+	]
+):
+	| (NetlifyDbDatabase<TRelations> & { $client: NetlifyDbClient })
+	| (NodePgDatabase<TRelations> & { $client: NodePgClient })
+{
+	// Zero-config: read env vars
+	if (
+		params.length === 0
+		|| (params.length === 1 && isConfig(params[0]) && !('connection' in (params[0] as any))
+			&& !('client' in (params[0] as any)))
+	) {
+		const drizzleConfig = (params[0] ?? {}) as DrizzleNetlifyConfig<TRelations>;
+		const connectionString = process.env['NETLIFY_DB_URL'];
+
+		if (!connectionString) {
+			throw new Error(
+				'NETLIFY_DB_URL environment variable is not set. '
+					+ 'Provide a connection string or client to drizzle().',
+			);
+		}
+
+		const driver = process.env['NETLIFY_DB_DRIVER'];
+
+		if (driver === 'server') {
+			return drizzleNodePg({ connection: connectionString, ...drizzleConfig }) as any;
+		}
+
+		const httpClient = neon(connectionString);
+		const pool = new Pool({ connectionString });
+		return construct(httpClient, pool, drizzleConfig) as any;
+	}
+
+	if (typeof params[0] === 'string') {
+		const connectionString = params[0];
+		const httpClient = neon(connectionString);
+		const pool = new Pool({ connectionString });
+		return construct(httpClient, pool, params[1]) as any;
+	}
+
+	if (isConfig(params[0])) {
+		const { connection, client, ...drizzleConfig } = params[0] as {
+			connection?: { connectionString: string } | string;
+			client?: NetlifyDbClient | DrizzleClient;
+		} & DrizzleNetlifyConfig<TRelations>;
+
+		if (client) {
+			if ('driver' in client) {
+				if (client.driver === 'serverless') {
+					return construct(client.httpClient, client.pool, drizzleConfig);
+				}
+				return drizzleNodePg({ client: client.pool, ...drizzleConfig }) as any;
+			}
+			return construct(client.http, client.pool, drizzleConfig);
+		}
+
+		const connectionString = typeof connection === 'string' ? connection : connection!.connectionString;
+		const httpClient = neon(connectionString);
+		const pool = new Pool({ connectionString });
+
+		return construct(httpClient, pool, drizzleConfig) as any;
+	}
+
+	throw new Error('Invalid arguments. Expected a connection string or a config object.');
+}
+
+export namespace drizzle {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzleNetlifyConfig<TRelations>,
+	): NetlifyDbDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, {} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/netlify-db/index.ts b/drizzle-orm/src/netlify-db/index.ts
new file mode 100644
index 0000000000..703d940e26
--- /dev/null
+++ b/drizzle-orm/src/netlify-db/index.ts
@@ -0,0 +1,3 @@
+export * from './codecs.ts';
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/netlify-db/migrator.ts b/drizzle-orm/src/netlify-db/migrator.ts
new file mode 100644
index 0000000000..397546c735
--- /dev/null
+++ b/drizzle-orm/src/netlify-db/migrator.ts
@@ -0,0 +1,20 @@
+import { is } from '~/entity.ts';
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as nodePgMigrate } from '~/node-postgres/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { NodePgDatabase } from '../node-postgres/driver.ts';
+import type { NetlifyDbDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: NetlifyDbDatabase<TRelations> | NodePgDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	if (is(db, NodePgDatabase)) {
+		return nodePgMigrate(db, config);
+	}
+
+	const migrations = readMigrationFiles(config);
+	return coreMigrate(migrations, db, config);
+}
diff --git a/drizzle-orm/src/netlify-db/session.ts b/drizzle-orm/src/netlify-db/session.ts
new file mode 100644
index 0000000000..aff05b6ad7
--- /dev/null
+++ b/drizzle-orm/src/netlify-db/session.ts
@@ -0,0 +1,293 @@
+import type { CustomTypesConfig, FullQueryResults, NeonQueryPromise, Pool, PoolClient } from '@neondatabase/serverless';
+import { neonConfig, types } from '@neondatabase/serverless';
+import type { BatchItem } from '~/batch.ts';
+import type { Cache } from '~/cache/core/cache.ts';
+import { NoopCache } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { NeonHttpClient, NeonHttpQueryResultHKT, NeonHttpSessionOptions } from '~/neon-http/session.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgCodecs } from '~/pg-core/codecs.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import type { PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
+
+/**
+ * Ensures a WebSocket implementation is available for Neon's
+ * serverless driver. The Neon driver checks for a global WebSocket
+ * automatically, but this sets it on neonConfig explicitly so the
+ * check only happens once.
+ */
+function ensureWebSocket(): void {
+	if (neonConfig.webSocketConstructor) return;
+
+	if (typeof WebSocket !== 'undefined') {
+		neonConfig.webSocketConstructor = WebSocket as any;
+	}
+}
+
+export type NetlifyDbClient = {
+	http: NeonHttpClient;
+	pool: Pool;
+};
+
+export interface NetlifyDbSessionOptions extends NeonHttpSessionOptions {
+	useJitMappers?: boolean | undefined;
+	transactionCodecs?: PgCodecs | undefined;
+}
+
+export class NetlifyDbSession<TRelations extends AnyRelations>
+	extends PgAsyncSession<NeonHttpQueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'NetlifyDbSession';
+
+	private clientQuery: (sql: string, params: any[], opts: Record<string, any>) => NeonQueryPromise<any, any>;
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		readonly httpClient: NeonHttpClient,
+		readonly pool: Pool,
+		dialect: PgDialect,
+		private relations: TRelations,
+		readonly options: NetlifyDbSessionOptions,
+	) {
+		super(dialect);
+		// `httpClient.query` is for @neondatabase/serverless v1.0.0 and up, where the
+		// root query function `httpClient` is only usable as a template function;
+		// `httpClient` is a fallback for earlier versions
+		this.clientQuery = (httpClient as any).query ?? httpClient as any;
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgAsyncPreparedQuery<T> {
+		const executor = (params?: unknown[]) => {
+			if (mode === 'raw') {
+				// otherwise raw queries with .then crash due to .then not existing on raw mode queries
+				return (async () =>
+					this.httpClient(query.sql, params, {
+						arrayMode: false,
+						fullResults: true,
+						authToken: this.options.authToken,
+					}))();
+			}
+
+			return this.httpClient(query.sql, params, {
+				arrayMode: mode === 'arrays',
+				fullResults: true,
+				authToken: this.options.authToken,
+			}).then((it: any) => it.rows);
+		};
+
+		return new PgAsyncPreparedQuery(executor, query, mapper, mode, this.logger, this.cache, queryMetadata, cacheConfig);
+	}
+
+	async batch<U extends BatchItem<'pg'>, T extends Readonly<[U, ...U[]]>>(queries: T) {
+		const preparedQueries: PgAsyncPreparedQuery<any>[] = [];
+		const builtQueries: NeonQueryPromise<any, true>[] = [];
+		const q = this.httpClient;
+
+		for (const query of queries) {
+			const preparedQuery = query._prepare() as PgAsyncPreparedQuery<any>;
+			const builtQuery = preparedQuery.getQuery();
+			preparedQueries.push(preparedQuery);
+			builtQueries.push(
+				q(builtQuery.sql, builtQuery.params, {
+					fullResults: true,
+					arrayMode: preparedQuery.mode === 'arrays',
+				}),
+			);
+		}
+
+		const batchResults = await this.httpClient.transaction(builtQueries, {
+			authToken: this.options.authToken,
+			fullResults: true,
+			arrayMode: true,
+		});
+		return batchResults.map((result, i) =>
+			preparedQueries[i]!.mapper ? preparedQueries[i]!.mapper(result.rows) : result
+		) as any;
+	}
+
+	async query(query: string, params: unknown[]): Promise<FullQueryResults<true>> {
+		this.logger.logQuery(query, params);
+		const result = await this.clientQuery(query, params, { arrayMode: true, fullResults: true });
+		return result;
+	}
+
+	async queryObjects(
+		query: string,
+		params: unknown[],
+	): Promise<FullQueryResults<false>> {
+		return this.clientQuery(query, params, { arrayMode: false, fullResults: true });
+	}
+
+	override async transaction<T>(
+		transaction: (tx: NetlifyDbTransaction<TRelations>) => Promise<T>,
+		config: PgTransactionConfig = {},
+	): Promise<T> {
+		ensureWebSocket();
+		const poolClient = await this.pool.connect();
+		const dialect = new PgDialect({
+			useJitMappers: this.options.useJitMappers,
+			codecs: this.options.transactionCodecs,
+		});
+		const session = new NetlifyDbWsSession<TRelations>(
+			poolClient,
+			dialect,
+			this.relations,
+			this.options,
+		);
+		const tx = new NetlifyDbTransaction<TRelations>(
+			dialect,
+			session,
+			this.relations,
+			undefined,
+			false,
+		);
+		await tx.execute(sql`begin ${tx.getTransactionConfigSQL(config)}`);
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql`commit`);
+			return result;
+		} catch (error) {
+			await tx.execute(sql`rollback`);
+			throw error;
+		} finally {
+			poolClient.release();
+		}
+	}
+}
+
+const noop = (val: any) => val;
+const typeConfig: CustomTypesConfig = {
+	getTypeParser: <CustomTypesConfig['getTypeParser']> ((typeId, format) => {
+		switch (typeId as number) {
+			case types.builtins.TIMESTAMPTZ:
+			case types.builtins.TIMESTAMP:
+			case types.builtins.DATE:
+			case types.builtins.INTERVAL:
+			case 1231: // numeric[]
+			case 1115: // timestamp[]
+			case 1185: // timestamp with timezone[]
+			case 1187: // interval[]
+			case 1182: // date[]
+				return noop;
+			default:
+				return types.getTypeParser(typeId, format as any);
+		}
+	}),
+};
+
+/**
+ * Internal WebSocket-based session used only within transactions.
+ * Delegates all queries to a PoolClient over WebSocket, using
+ * NeonPreparedQuery from the neon-serverless adapter.
+ */
+export class NetlifyDbWsSession<TRelations extends AnyRelations>
+	extends PgAsyncSession<NeonHttpQueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'NetlifyDbWsSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		private client: PoolClient,
+		dialect: PgDialect,
+		private relations: TRelations,
+		options: NeonHttpSessionOptions = {},
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgAsyncPreparedQuery<T> {
+		const queryName = typeof name === 'string'
+			? name
+			: name === true
+			? preparedStatementName(query.sql, query.params)
+			: undefined;
+
+		const executor = async (params?: unknown[]) => {
+			return this.client.query({
+				name: queryName,
+				rowMode: mode === 'arrays' ? 'array' : undefined as any,
+				text: query.sql,
+				types: typeConfig,
+			}, params).then((r) => mode === 'raw' ? r : r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+	override async transaction<T>(
+		_transaction: (tx: NetlifyDbTransaction<TRelations>) => Promise<T>,
+		_config?: PgTransactionConfig,
+	): Promise<T> {
+		throw new Error('Nested transactions are handled by NetlifyDbTransaction via savepoints');
+	}
+}
+
+export class NetlifyDbTransaction<TRelations extends AnyRelations>
+	extends PgAsyncTransaction<NeonHttpQueryResultHKT, TRelations>
+{
+	static override readonly [entityKind]: string = 'NetlifyDbTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: NetlifyDbTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new NetlifyDbTransaction<TRelations>(
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+			false,
+		);
+		await tx.execute(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (e) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw e;
+		}
+	}
+}
diff --git a/drizzle-orm/src/node-mssql/driver.ts b/drizzle-orm/src/node-mssql/driver.ts
new file mode 100644
index 0000000000..a4deda054a
--- /dev/null
+++ b/drizzle-orm/src/node-mssql/driver.ts
@@ -0,0 +1,172 @@
+import type mssql from 'mssql';
+import * as V1 from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { DefaultLogger } from '~/logger.ts';
+import { MsSqlDatabase } from '~/mssql-core/db.ts';
+import { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import { type DrizzleConfig, type Equal, jitCompatCheck } from '~/utils.ts';
+import { AutoPool } from './pool.ts';
+import type { NodeMsSqlClient, NodeMsSqlPreparedQueryHKT, NodeMsSqlQueryResultHKT } from './session.ts';
+import { NodeMsSqlSession } from './session.ts';
+
+export interface MsSqlDriverOptions {
+	logger?: Logger;
+	useJitMappers?: boolean;
+}
+
+export class NodeMsSqlDriver {
+	static readonly [entityKind]: string = 'NodeMsSqlDriver';
+
+	constructor(
+		private client: NodeMsSqlClient,
+		private dialect: MsSqlDialect,
+		private options: MsSqlDriverOptions = {},
+	) {
+	}
+
+	createSession(
+		schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined,
+	): NodeMsSqlSession<Record<string, unknown>, V1.TablesRelationalConfig> {
+		return new NodeMsSqlSession(this.client, this.dialect, schema, {
+			logger: this.options.logger,
+			useJitMappers: this.options.useJitMappers,
+		});
+	}
+}
+
+export { MsSqlDatabase } from '~/mssql-core/db.ts';
+
+export type NodeMsSqlDatabase<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> = MsSqlDatabase<NodeMsSqlQueryResultHKT, NodeMsSqlPreparedQueryHKT, TSchema>;
+
+export type NodeMsSqlDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> =
+	& Omit<DrizzleConfig<TSchema>, 'schema'>
+	& ({ schema: TSchema } | { schema?: undefined });
+
+function construct<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TClient extends NodeMsSqlClient = NodeMsSqlClient,
+>(
+	client: TClient,
+	config: DrizzleConfig<TSchema> = {},
+): NodeMsSqlDatabase<TSchema> & {
+	$client: Equal<TClient, NodeMsSqlClient> extends true ? AutoPool : TClient;
+} {
+	const dialect = new MsSqlDialect();
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+	if (isCallbackClient(client)) {
+		client = client.promise() as any;
+	}
+
+	let schema: V1.RelationalSchemaConfig<V1.TablesRelationalConfig> | undefined;
+	if (config.schema) {
+		const tablesConfig = V1.extractTablesRelationalConfig(
+			config.schema,
+			V1.createTableRelationsHelpers,
+		);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap,
+		};
+	}
+
+	const driver = new NodeMsSqlDriver(client as NodeMsSqlClient, dialect, {
+		logger,
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	const session = driver.createSession(schema);
+	const db = new MsSqlDatabase(dialect, session, schema) as NodeMsSqlDatabase<TSchema>;
+	(<any> db).$client = client;
+
+	return db as any;
+}
+
+export function getMsSqlConnectionParams(connectionString: string): mssql.config | string {
+	try {
+		const url = new URL(connectionString);
+		return {
+			user: url.username,
+			password: url.password,
+			server: url.hostname,
+			port: Number.parseInt(url.port, 10),
+			database: url.pathname.replace(/^\//, ''),
+			options: {
+				encrypt: url.searchParams.get('encrypt') === 'true',
+				trustServerCertificate: url.searchParams.get('trustServerCertificate') === 'true',
+			},
+		};
+	} catch {
+		return connectionString;
+	}
+}
+
+export function drizzle<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TClient extends NodeMsSqlClient = AutoPool,
+>(
+	...params:
+		| [
+			string,
+		]
+		| [
+			string,
+			DrizzleConfig<TSchema>,
+		]
+		| [
+			(
+				& DrizzleConfig<TSchema>
+				& ({
+					connection: string;
+				} | {
+					client: TClient;
+				})
+			),
+		]
+): NodeMsSqlDatabase<TSchema> & {
+	$client: Equal<TClient, NodeMsSqlClient> extends true ? AutoPool : TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new AutoPool(getMsSqlConnectionParams(params[0]));
+
+		return construct(instance, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	}
+
+	const { connection, client, ...drizzleConfig } = params[0] as (
+		& ({ connection?: mssql.config | string; client?: TClient })
+		& DrizzleConfig<TSchema>
+	);
+
+	if (client) return construct(client, drizzleConfig);
+
+	const instance = typeof connection === 'string'
+		? new AutoPool(getMsSqlConnectionParams(connection))
+		: new AutoPool(connection!);
+
+	return construct(instance, drizzleConfig) as any;
+}
+
+interface CallbackClient {
+	promise(): NodeMsSqlClient;
+}
+
+function isCallbackClient(client: any): client is CallbackClient {
+	return typeof client.promise === 'function';
+}
+
+export namespace drizzle {
+	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
+		config?: DrizzleConfig<TSchema>,
+	): NodeMsSqlDatabase<TSchema> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/prisma/pg/index.ts b/drizzle-orm/src/node-mssql/index.ts
similarity index 100%
rename from drizzle-orm/src/prisma/pg/index.ts
rename to drizzle-orm/src/node-mssql/index.ts
diff --git a/drizzle-orm/src/node-mssql/migrator.ts b/drizzle-orm/src/node-mssql/migrator.ts
new file mode 100644
index 0000000000..51db049e8e
--- /dev/null
+++ b/drizzle-orm/src/node-mssql/migrator.ts
@@ -0,0 +1,11 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { NodeMsSqlDatabase } from './driver.ts';
+
+export async function migrate<TSchema extends Record<string, unknown>>(
+	db: NodeMsSqlDatabase<TSchema>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return await db.dialect.migrate(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/node-mssql/pool.ts b/drizzle-orm/src/node-mssql/pool.ts
new file mode 100644
index 0000000000..f269085b22
--- /dev/null
+++ b/drizzle-orm/src/node-mssql/pool.ts
@@ -0,0 +1,20 @@
+import mssql from 'mssql';
+import { entityKind } from '~/entity.ts';
+
+export class AutoPool {
+	static readonly [entityKind]: string = 'AutoPool';
+
+	private pool: mssql.ConnectionPool;
+
+	constructor(config: string | mssql.config) {
+		this.pool = new mssql.ConnectionPool(config as any);
+	}
+
+	async $instance() {
+		await this.pool.connect().catch((err) => {
+			console.error('❌ AutoPool failed to connect:', err);
+			throw err;
+		});
+		return this.pool;
+	}
+}
diff --git a/drizzle-orm/src/node-mssql/session.ts b/drizzle-orm/src/node-mssql/session.ts
new file mode 100644
index 0000000000..082c17ff05
--- /dev/null
+++ b/drizzle-orm/src/node-mssql/session.ts
@@ -0,0 +1,352 @@
+import type { ConnectionPool, IResult, Request } from 'mssql';
+import mssql from 'mssql';
+import { once } from 'node:events';
+import type * as V1 from '~/_relations.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { MsSqlDialect } from '~/mssql-core/dialect.ts';
+import type { SelectedFieldsOrdered } from '~/mssql-core/query-builders/select.types.ts';
+import {
+	MsSqlSession,
+	MsSqlTransaction,
+	type MsSqlTransactionConfig,
+	PreparedQuery,
+	type PreparedQueryConfig,
+	type PreparedQueryHKT,
+	type PreparedQueryKind,
+	type QueryResultHKT,
+} from '~/mssql-core/session.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import { type Assume, makeJitQueryMapper, mapResultRow, type RowsMapper } from '~/utils.ts';
+import { AutoPool } from './pool.ts';
+
+export type NodeMsSqlClient = Pick<ConnectionPool, 'request'> | AutoPool;
+
+export type MsSqlQueryResult<T extends unknown | unknown[] = any> = IResult<T>;
+
+export class NodeMsSqlPreparedQuery<
+	T extends PreparedQueryConfig,
+> extends PreparedQuery<T> {
+	static override readonly [entityKind]: string = 'NodeMsSqlPreparedQuery';
+	private jitMapper?: RowsMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>;
+
+	private rawQuery: {
+		sql: string;
+		parameters: unknown[];
+	};
+
+	constructor(
+		private client: NodeMsSqlClient,
+		queryString: string,
+		private params: unknown[],
+		private logger: Logger,
+		private fields: SelectedFieldsOrdered | undefined,
+		private useJitMappers: boolean | undefined,
+		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+	) {
+		super();
+		this.rawQuery = {
+			sql: queryString,
+			parameters: params,
+		};
+	}
+
+	async execute(
+		placeholderValues: Record<string, unknown> = {},
+	): Promise<T['execute']> {
+		const params = fillPlaceholders(this.params, placeholderValues);
+
+		this.logger.logQuery(this.rawQuery.sql, params);
+
+		const {
+			fields,
+			client,
+			rawQuery,
+			joinsNotNullableMap,
+			customResultMapper,
+		} = this;
+		let queryClient = client as ConnectionPool;
+		if (is(client, AutoPool)) {
+			queryClient = await client.$instance();
+		}
+		const request = queryClient.request() as Request & { arrayRowMode: boolean };
+		for (const [index, param] of params.entries()) {
+			request.input(`par${index}`, param);
+		}
+
+		if (!fields && !customResultMapper) {
+			return request.query(rawQuery.sql) as Promise<T['execute']>;
+		}
+
+		request.arrayRowMode = true;
+		const rows = await request.query<any[]>(rawQuery.sql);
+
+		if (customResultMapper) {
+			return customResultMapper(rows.recordset);
+		}
+
+		return this.useJitMappers
+			? (this.jitMapper =
+				this.jitMapper as RowsMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>
+					?? makeJitQueryMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>(
+						fields!,
+						joinsNotNullableMap,
+					))(
+					rows.recordset,
+				)
+			: rows.recordset.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
+	}
+
+	async *iterator(
+		placeholderValues: Record<string, unknown> = {},
+	): AsyncGenerator<
+		T['execute'] extends any[] ? T['execute'][number] : T['execute']
+	> {
+		const params = fillPlaceholders(this.params, placeholderValues);
+
+		const {
+			fields,
+			rawQuery,
+			joinsNotNullableMap,
+			client,
+			customResultMapper,
+		} = this;
+		let queryClient = client as ConnectionPool;
+		if (is(client, AutoPool)) {
+			queryClient = await client.$instance();
+		}
+		const request = queryClient.request() as Request & { arrayRowMode: boolean };
+		request.stream = true;
+		const hasRowsMapper = Boolean(fields || customResultMapper);
+
+		if (hasRowsMapper) {
+			request.arrayRowMode = true;
+		}
+
+		for (const [index, param] of params.entries()) {
+			request.input(`par${index}`, param);
+		}
+
+		const stream = request.toReadableStream();
+
+		request.query(rawQuery.sql);
+
+		function dataListener() {
+			stream.pause();
+		}
+
+		stream.on('data', dataListener);
+
+		try {
+			const onEnd = once(stream, 'end');
+			const onError = once(stream, 'error');
+
+			while (true) {
+				stream.resume();
+				const row = await Promise.race([
+					onEnd,
+					onError,
+					new Promise((resolve) => stream.once('data', resolve)),
+				]);
+				if (row === undefined || (Array.isArray(row) && row.length === 0)) {
+					break;
+					// oxlint-disable-next-line drizzle-internal/no-instanceof
+				} else if (row instanceof Error) {
+					throw row;
+				} else {
+					if (hasRowsMapper) {
+						if (customResultMapper) {
+							const mappedRow = customResultMapper([row as unknown[]]);
+							yield Array.isArray(mappedRow) ? mappedRow[0] : mappedRow;
+						} else {
+							yield this.useJitMappers
+								? (this.jitMapper = this.jitMapper as RowsMapper<(T['execute'] extends any[] ? T['execute'][number]
+									: T['execute'])[]>
+									?? makeJitQueryMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>(
+										fields!,
+										joinsNotNullableMap,
+									))([
+										row as unknown[],
+									])[0] as T['execute']
+								: mapResultRow(fields!, row as unknown[], joinsNotNullableMap);
+						}
+					} else {
+						yield row as T['execute'];
+					}
+				}
+			}
+		} finally {
+			stream.off('data', dataListener);
+			request.cancel();
+		}
+	}
+}
+
+export interface NodeMsSqlSessionOptions {
+	logger?: Logger;
+	useJitMappers?: boolean;
+}
+
+export class NodeMsSqlSession<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+> extends MsSqlSession<
+	NodeMsSqlQueryResultHKT,
+	NodeMsSqlPreparedQueryHKT,
+	TFullSchema,
+	TSchema
+> {
+	static override readonly [entityKind]: string = 'NodeMsSqlSession';
+
+	private logger: Logger;
+
+	constructor(
+		private client: NodeMsSqlClient,
+		dialect: MsSqlDialect,
+		private schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+		private options: NodeMsSqlSessionOptions,
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	): PreparedQueryKind<NodeMsSqlPreparedQueryHKT, T> {
+		return new NodeMsSqlPreparedQuery(
+			this.client,
+			query.sql,
+			query.params,
+			this.logger,
+			fields,
+			this.options.useJitMappers,
+			customResultMapper,
+		) as PreparedQueryKind<NodeMsSqlPreparedQueryHKT, T>;
+	}
+
+	/**
+	 * @internal
+	 * What is its purpose?
+	 */
+	async query(query: string, params: unknown[]): Promise<MsSqlQueryResult> {
+		this.logger.logQuery(query, params);
+
+		let queryClient = this.client as ConnectionPool;
+		if (is(this.client, AutoPool)) {
+			queryClient = await this.client.$instance();
+		}
+		const request = queryClient.request() as Request & {
+			arrayRowMode: boolean;
+		};
+		request.arrayRowMode = true;
+
+		for (const [index, param] of params.entries()) {
+			request.input(`par${index}`, param);
+		}
+
+		return request.query(query);
+	}
+
+	override async all<T = unknown>(query: SQL): Promise<T[]> {
+		const querySql = this.dialect.sqlToQuery(query);
+		this.logger.logQuery(querySql.sql, querySql.params);
+		return await this.query(querySql.sql, querySql.params).then(
+			(result) => result.recordset,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (tx: NodeMsSqlTransaction<TFullSchema, TSchema>) => Promise<T>,
+		config?: MsSqlTransactionConfig,
+	): Promise<T> {
+		let queryClient = this.client as ConnectionPool;
+
+		if (is(this.client, AutoPool)) {
+			queryClient = await this.client.$instance();
+		}
+
+		const mssqlTransaction = queryClient.transaction();
+		const session = new NodeMsSqlSession(
+			mssqlTransaction,
+			this.dialect,
+			this.schema,
+			this.options,
+		);
+		const tx = new NodeMsSqlTransaction(
+			this.dialect,
+			session as MsSqlSession<any, any, any, any>,
+			this.schema,
+			0,
+		);
+
+		await mssqlTransaction.begin(
+			config?.isolationLevel
+				? isolationLevelMap[config.isolationLevel]
+				: undefined,
+		);
+
+		try {
+			const result = await transaction(tx);
+			await mssqlTransaction.commit();
+			return result;
+		} catch (err) {
+			await mssqlTransaction.rollback();
+			throw err;
+		}
+	}
+}
+
+export class NodeMsSqlTransaction<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends V1.TablesRelationalConfig,
+> extends MsSqlTransaction<
+	NodeMsSqlQueryResultHKT,
+	NodeMsSqlPreparedQueryHKT,
+	TFullSchema,
+	TSchema
+> {
+	static override readonly [entityKind]: string = 'NodeMsSqlTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: NodeMsSqlTransaction<TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new NodeMsSqlTransaction(
+			this.dialect,
+			this.session,
+			this.schema,
+			this.nestedIndex + 1,
+		);
+
+		await tx.execute(sql.raw(`save transaction ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			return result;
+		} catch (err) {
+			await tx.execute(sql.raw(`rollback transaction ${savepointName}`));
+			throw err;
+		}
+	}
+}
+
+const isolationLevelMap: Record<
+	MsSqlTransactionConfig['isolationLevel'],
+	(typeof mssql.ISOLATION_LEVEL)[keyof (typeof mssql)['ISOLATION_LEVEL']]
+> = {
+	'read uncommitted': mssql.ISOLATION_LEVEL.READ_UNCOMMITTED,
+	'read committed': mssql.ISOLATION_LEVEL.READ_COMMITTED,
+	'repeatable read': mssql.ISOLATION_LEVEL.REPEATABLE_READ,
+	serializable: mssql.ISOLATION_LEVEL.SERIALIZABLE,
+	snapshot: mssql.ISOLATION_LEVEL.SNAPSHOT,
+};
+
+export interface NodeMsSqlQueryResultHKT extends QueryResultHKT {
+	type: MsSqlQueryResult<this['row']>;
+}
+
+export interface NodeMsSqlPreparedQueryHKT extends PreparedQueryHKT {
+	type: NodeMsSqlPreparedQuery<Assume<this['config'], PreparedQueryConfig>>;
+}
diff --git a/drizzle-orm/src/node-postgres/codecs.ts b/drizzle-orm/src/node-postgres/codecs.ts
new file mode 100644
index 0000000000..c3eb617a33
--- /dev/null
+++ b/drizzle-orm/src/node-postgres/codecs.ts
@@ -0,0 +1,89 @@
+import { parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const nodePgCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	// driver handles objects, other types need to be stringified
+	json: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
diff --git a/drizzle-orm/src/node-postgres/driver.ts b/drizzle-orm/src/node-postgres/driver.ts
index 9ea0ae2df8..5224fed02d 100644
--- a/drizzle-orm/src/node-postgres/driver.ts
+++ b/drizzle-orm/src/node-postgres/driver.ts
@@ -1,61 +1,34 @@
 import pg, { type Pool, type PoolConfig } from 'pg';
-import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { nodePgCodecs } from './codecs.ts';
 import type { NodePgClient, NodePgQueryResultHKT } from './session.ts';
 import { NodePgSession } from './session.ts';
 
-export interface PgDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class NodePgDriver {
-	static readonly [entityKind]: string = 'NodePgDriver';
-
-	constructor(
-		private client: NodePgClient,
-		private dialect: PgDialect,
-		private options: PgDriverOptions = {},
-	) {
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): NodePgSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new NodePgSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-}
-
 export class NodePgDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<NodePgQueryResultHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgAsyncDatabase<NodePgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'NodePgDatabase';
 }
 
 function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NodePgClient = NodePgClient,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): NodePgDatabase<TSchema> & {
-	$client: TClient;
+	config: DrizzlePgConfig<TRelations> = {},
+): NodePgDatabase<TRelations> & {
+	$client: NodePgClient extends TClient ? Pool : TClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? nodePgCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -63,22 +36,17 @@ function construct<
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new NodePgDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
-	const db = new NodePgDatabase(dialect, session, schema as any) as NodePgDatabase<TSchema>;
+	const relations = config.relations ?? {};
+	const session = new NodePgSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+
+	const db = new NodePgDatabase(
+		dialect,
+		session,
+		relations,
+	) as NodePgDatabase<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -89,62 +57,61 @@ function construct<
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends NodePgClient = Pool,
 >(
 	...params:
 		| [
-			TClient | string,
+			string,
 		]
 		| [
-			TClient | string,
-			DrizzleConfig<TSchema>,
+			string,
+			DrizzlePgConfig<TRelations>,
 		]
 		| [
-			(
-				& DrizzleConfig<TSchema>
-				& ({
-					connection: string | PoolConfig;
-				} | {
-					client: TClient;
-				})
-			),
+			& DrizzlePgConfig<TRelations>
+			& ({
+				client: TClient;
+			} | {
+				connection: string | PoolConfig;
+			}),
 		]
-): NodePgDatabase<TSchema> & {
-	$client: TClient;
+): NodePgDatabase<TRelations> & {
+	$client: NodePgClient extends TClient ? Pool : TClient;
 } {
 	if (typeof params[0] === 'string') {
 		const instance = new pg.Pool({
 			connectionString: params[0],
 		});
 
-		return construct(instance, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+		return construct(
+			instance,
+			params[1] as DrizzlePgConfig<TRelations> | undefined,
+		) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as (
-			& ({ connection?: PoolConfig | string; client?: TClient })
-			& DrizzleConfig<TSchema>
-		);
-
-		if (client) return construct(client, drizzleConfig);
+	const { connection, client, ...drizzlePgCDrizzlePgConfig } = params[0] as (
+		& ({ connection?: PoolConfig | string; client?: TClient })
+		& DrizzlePgConfig<TRelations>
+	);
 
-		const instance = typeof connection === 'string'
-			? new pg.Pool({
-				connectionString: connection,
-			})
-			: new pg.Pool(connection!);
+	if (client) return construct(client, drizzlePgCDrizzlePgConfig);
 
-		return construct(instance, drizzleConfig) as any;
-	}
+	const instance = typeof connection === 'string'
+		? new pg.Pool({
+			connectionString: connection,
+		})
+		: new pg.Pool(connection!);
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, drizzlePgCDrizzlePgConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): NodePgDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): NodePgDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/node-postgres/index.ts b/drizzle-orm/src/node-postgres/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/node-postgres/index.ts
+++ b/drizzle-orm/src/node-postgres/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/node-postgres/migrator.ts b/drizzle-orm/src/node-postgres/migrator.ts
index 933e5a4862..869304af69 100644
--- a/drizzle-orm/src/node-postgres/migrator.ts
+++ b/drizzle-orm/src/node-postgres/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { NodePgDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: NodePgDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: NodePgDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/node-postgres/session.ts b/drizzle-orm/src/node-postgres/session.ts
index e5fb6ba7b7..1a2d1cc4fe 100644
--- a/drizzle-orm/src/node-postgres/session.ts
+++ b/drizzle-orm/src/node-postgres/session.ts
@@ -1,197 +1,42 @@
-import type { Client, PoolClient, QueryArrayConfig, QueryConfig, QueryResult, QueryResultRow } from 'pg';
+import type { Client, CustomTypesConfig, PoolClient, QueryResult, QueryResultRow } from 'pg';
 import pg from 'pg';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import { type Logger, NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery } from '~/pg-core/async/session.ts';
+import { PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
-import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import type { PgQueryResultHKT, PgTransactionConfig } from '~/pg-core/session.ts';
+import type { PreparedQueryConfig } from '~/pg-core/session.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 
 const { Pool, types } = pg;
-
 export type NodePgClient = pg.Pool | PoolClient | Client;
 
-export class NodePgPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'NodePgPreparedQuery';
-
-	private rawQueryConfig: QueryConfig;
-	private queryConfig: QueryArrayConfig;
-
-	constructor(
-		private client: NodePgClient,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-		this.rawQueryConfig = {
-			name,
-			text: queryString,
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val) => val;
-					}
-					// numeric[]
-					if (typeId === 1231) {
-						return (val) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115) {
-						return (val) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185) {
-						return (val) => val;
-					}
-					// interval[]
-					if (typeId === 1187) {
-						return (val) => val;
-					}
-					// date[]
-					if (typeId === 1182) {
-						return (val) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-		this.queryConfig = {
-			name,
-			text: queryString,
-			rowMode: 'array',
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val) => val;
-					}
-					// numeric[]
-					if (typeId === 1231) {
-						return (val) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115) {
-						return (val) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185) {
-						return (val) => val;
-					}
-					// interval[]
-					if (typeId === 1187) {
-						return (val) => val;
-					}
-					// date[]
-					if (typeId === 1182) {
-						return (val) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		return tracer.startActiveSpan('drizzle.execute', async () => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-
-			this.logger.logQuery(this.rawQueryConfig.text, params);
-
-			const { fields, rawQueryConfig: rawQuery, client, queryConfig: query, joinsNotNullableMap, customResultMapper } =
-				this;
-			if (!fields && !customResultMapper) {
-				return tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
-					span?.setAttributes({
-						'drizzle.query.name': rawQuery.name,
-						'drizzle.query.text': rawQuery.text,
-						'drizzle.query.params': JSON.stringify(params),
-					});
-					return this.queryWithCache(rawQuery.text, params, async () => {
-						return await client.query(rawQuery, params);
-					});
-				});
-			}
-
-			const result = await tracer.startActiveSpan('drizzle.driver.execute', (span) => {
-				span?.setAttributes({
-					'drizzle.query.name': query.name,
-					'drizzle.query.text': query.text,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return this.queryWithCache(query.text, params, async () => {
-					return await client.query(query, params);
-				});
-			});
-
-			return tracer.startActiveSpan('drizzle.mapResponse', () => {
-				return customResultMapper
-					? customResultMapper(result.rows)
-					: result.rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-			});
-		});
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		return tracer.startActiveSpan('drizzle.execute', () => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-			this.logger.logQuery(this.rawQueryConfig.text, params);
-			return tracer.startActiveSpan('drizzle.driver.execute', (span) => {
-				span?.setAttributes({
-					'drizzle.query.name': this.rawQueryConfig.name,
-					'drizzle.query.text': this.rawQueryConfig.text,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return this.queryWithCache(this.rawQueryConfig.text, params, async () => {
-					return this.client.query(this.rawQueryConfig, params);
-				}).then((result) => result.rows);
-			});
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
+const noop = (val: any) => val;
+
+const typeConfig: CustomTypesConfig = {
+	getTypeParser: <CustomTypesConfig['getTypeParser']> ((typeId, format) => {
+		switch (typeId as number) {
+			case types.builtins.TIMESTAMPTZ:
+			case types.builtins.TIMESTAMP:
+			case types.builtins.DATE:
+			case types.builtins.INTERVAL:
+			case 1231: // numeric[]
+			case 1115: // timestamp[]
+			case 1185: // timestamp with timezone[]
+			case 1187: // interval[]
+			case 1182: // date[]
+				return noop;
+			default:
+				return types.getTypeParser(typeId, format);
+		}
+	}),
+};
 
 export interface NodePgSessionOptions {
 	logger?: Logger;
@@ -199,9 +44,8 @@ export interface NodePgSessionOptions {
 }
 
 export class NodePgSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<NodePgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncSession<NodePgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'NodePgSession';
 
 	private logger: Logger;
@@ -210,7 +54,7 @@ export class NodePgSession<
 	constructor(
 		private client: NodePgClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: NodePgSessionOptions = {},
 	) {
 		super(dialect);
@@ -220,39 +64,62 @@ export class NodePgSession<
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new NodePgPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	) {
+		const queryName = typeof name === 'string'
+			? name
+			: name === true
+			? preparedStatementName(query.sql, query.params)
+			: undefined;
+
+		const executor = async (params?: unknown[]) => {
+			return this.client.query({
+				name: queryName,
+				rowMode: mode === 'arrays' ? 'array' : undefined as any,
+				text: query.sql,
+				types: typeConfig,
+			}, params).then((r) => mode === 'raw' ? r : r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			name,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: NodePgTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: NodePgTransaction<TRelations>) => Promise<T>,
 		config?: PgTransactionConfig | undefined,
 	): Promise<T> {
-		const session = this.client instanceof Pool // eslint-disable-line no-instanceof/no-instanceof
-			? new NodePgSession(await this.client.connect(), this.dialect, this.schema, this.options)
+		const isPool = this.client instanceof Pool || Object.getPrototypeOf(this.client).constructor.name.includes('Pool'); // oxlint-disable-line drizzle-internal/no-instanceof
+		const session = isPool
+			? new NodePgSession(
+				await (<pg.Pool> this.client).connect(),
+				this.dialect,
+				this.relations,
+				this.options,
+			)
 			: this;
-		const tx = new NodePgTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+		const tx = new NodePgTransaction<TRelations>(
+			this.dialect,
+			session,
+			this.relations,
+			undefined,
+			false,
+		);
 		await tx.execute(sql`begin${config ? sql` ${tx.getTransactionConfigSQL(config)}` : undefined}`);
 		try {
 			const result = await transaction(tx);
@@ -262,33 +129,26 @@ export class NodePgSession<
 			await tx.execute(sql`rollback`);
 			throw error;
 		} finally {
-			if (this.client instanceof Pool) { // eslint-disable-line no-instanceof/no-instanceof
-				(session.client as PoolClient).release();
-			}
+			if (isPool) (session.client as PoolClient).release();
 		}
 	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql);
-		return Number(
-			res['rows'][0]['count'],
-		);
-	}
 }
 
 export class NodePgTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<NodePgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<NodePgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'NodePgTransaction';
 
-	override async transaction<T>(transaction: (tx: NodePgTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: NodePgTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new NodePgTransaction<TFullSchema, TSchema>(
+		const tx = new NodePgTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this._.relations,
 			this.nestedIndex + 1,
+			false,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
diff --git a/drizzle-orm/src/node-sqlite/driver.ts b/drizzle-orm/src/node-sqlite/driver.ts
new file mode 100644
index 0000000000..2a03ea760c
--- /dev/null
+++ b/drizzle-orm/src/node-sqlite/driver.ts
@@ -0,0 +1,114 @@
+import { DatabaseSync, type DatabaseSyncOptions } from 'node:sqlite';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type NodeSQLiteRunResult, NodeSQLiteSession } from './session.ts';
+
+export class NodeSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'sync', NodeSQLiteRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'NodeSQLiteDatabase';
+}
+
+export type DrizzleNodeSQLiteDatabaseConfig =
+	| ({
+		path?: string;
+	} & DatabaseSyncOptions)
+	| string
+	| undefined;
+
+function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: DatabaseSync,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): NodeSQLiteDatabase<TRelations> & {
+	$client: DatabaseSync;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new NodeSQLiteSession(client, dialect, relations, {
+		logger,
+	});
+	const db = new NodeSQLiteDatabase(
+		'sync',
+		dialect,
+		session,
+		relations,
+	);
+	(<any> db).$client = client;
+
+	return db as any;
+}
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends DatabaseSync = DatabaseSync>(
+	...params:
+		| []
+		| [
+			string,
+		]
+		| [
+			string,
+			DrizzleSQLiteConfig<TRelations>,
+		]
+		| [
+			(
+				& DrizzleSQLiteConfig<TRelations>
+				& ({
+					connection?: DrizzleNodeSQLiteDatabaseConfig | string;
+				} | {
+					client: TClient;
+				})
+			),
+		]
+): NodeSQLiteDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (params[0] === undefined || typeof params[0] === 'string') {
+		const instance = params[0] === undefined ? new DatabaseSync(':memory:') : new DatabaseSync(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...config } = params[0] as
+		& ({
+			connection?: DrizzleNodeSQLiteDatabaseConfig | string;
+			client?: TClient;
+		})
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, config) as any;
+
+	if (typeof connection === 'object') {
+		const { path, ...options } = connection;
+
+		const instance = new DatabaseSync(path ?? ':memory:', options);
+
+		return construct(instance, config) as any;
+	}
+
+	const instance = new DatabaseSync(connection ?? ':memory:');
+
+	return construct(instance, config) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): NodeSQLiteDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/prisma/sqlite/index.ts b/drizzle-orm/src/node-sqlite/index.ts
similarity index 100%
rename from drizzle-orm/src/prisma/sqlite/index.ts
rename to drizzle-orm/src/node-sqlite/index.ts
diff --git a/drizzle-orm/src/node-sqlite/migrator.ts b/drizzle-orm/src/node-sqlite/migrator.ts
new file mode 100644
index 0000000000..8c16f54696
--- /dev/null
+++ b/drizzle-orm/src/node-sqlite/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { migrateSync } from '~/sqlite-core/async/session.ts';
+import type { NodeSQLiteDatabase } from './driver.ts';
+
+export function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: NodeSQLiteDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return migrateSync(migrations, db.session, config);
+}
diff --git a/drizzle-orm/src/node-sqlite/session.ts b/drizzle-orm/src/node-sqlite/session.ts
new file mode 100644
index 0000000000..a0742a1770
--- /dev/null
+++ b/drizzle-orm/src/node-sqlite/session.ts
@@ -0,0 +1,149 @@
+import type { DatabaseSync, SQLInputValue, StatementResultingChanges } from 'node:sqlite';
+import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+
+export interface NodeSQLiteSessionOptions {
+	logger?: Logger;
+}
+
+export type NodeSQLiteRunResult = StatementResultingChanges;
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class NodeSQLiteSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'sync', NodeSQLiteRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLJsSession';
+
+	private logger: Logger;
+
+	constructor(
+		private client: DatabaseSync,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: NodeSQLiteSessionOptions = {},
+	) {
+		super(dialect, 'sync');
+		this.logger = options.logger ?? new NoopLogger();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+	): SQLiteAsyncPreparedQuery<T & { run: NodeSQLiteRunResult }> {
+		let stmt: ReturnType<typeof this.client.prepare>;
+		try {
+			stmt = this.client.prepare(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				stmt.setReturnArrays(mode === 'arrays');
+				const res = stmt.all(...params as SQLInputValue[]);
+
+				// Null-prototype object => object
+				if (mode === 'objects') return res.map((row) => ({ ...row }));
+				return res;
+			},
+			get: (params) => {
+				stmt.setReturnArrays(mode === 'arrays');
+				const res = stmt.get(...params as SQLInputValue[]);
+
+				// Null-prototype object => object
+				if (res && mode === 'objects') return { ...res };
+				return res;
+			},
+			run: (params) => {
+				stmt.setReturnArrays(false);
+				return stmt.run(...params as SQLInputValue[]);
+			},
+			values: (params) => {
+				stmt.setReturnArrays(true);
+				return stmt.all(...params as SQLInputValue[]);
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			undefined,
+			queryMetadata,
+			undefined,
+		);
+	}
+
+	override transaction<T>(
+		transaction: (tx: NodeSQLiteTransaction<TRelations>) => T,
+		config: SQLiteTransactionConfig = {},
+	): T {
+		const tx = new NodeSQLiteTransaction('sync', this.dialect, this, this.relations);
+		this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ''}`));
+		try {
+			const result = transaction(tx);
+			this.run(sql`commit`);
+			return result;
+		} catch (err) {
+			this.run(sql`rollback`);
+			throw err;
+		}
+	}
+}
+
+export class NodeSQLiteTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'sync', StatementResultingChanges, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLJsTransaction';
+
+	override transaction<T>(
+		transaction: (
+			tx: NodeSQLiteTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new NodeSQLiteTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
+		tx.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = transaction(tx);
+			tx.run(sql.raw(`release savepoint ${savepointName}`));
+			return result as T;
+		} catch (err) {
+			tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
diff --git a/drizzle-orm/src/op-sqlite/driver.ts b/drizzle-orm/src/op-sqlite/driver.ts
index 07b21b61ab..d4298d9502 100644
--- a/drizzle-orm/src/op-sqlite/driver.ts
+++ b/drizzle-orm/src/op-sqlite/driver.ts
@@ -1,30 +1,27 @@
-import type { OPSQLiteConnection, QueryResult } from '@op-engineering/op-sqlite';
+import type { OPSQLiteConnection } from '@op-engineering/op-sqlite';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { OPSQLiteSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { type DrizzleConfig, jitCompatCheck } from '~/utils.ts';
+import { type OPSQLiteRunResult, OPSQLiteSession } from './session.ts';
 
-export class OPSQLiteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'async', QueryResult, TSchema> {
+export class OPSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', OPSQLiteRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'OPSQLiteDatabase';
 }
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	client: OPSQLiteConnection,
-	config: DrizzleConfig<TSchema> = {},
-): OPSQLiteDatabase<TSchema> & {
+	config: DrizzleConfig<TRelations> = {},
+): OPSQLiteDatabase<TRelations> & {
 	$client: OPSQLiteConnection;
 } {
-	const dialect = new SQLiteAsyncDialect({ casing: config.casing });
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -32,21 +29,17 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new OPSQLiteSession(client, dialect, schema, { logger, cache: config.cache });
-	const db = new OPSQLiteDatabase('async', dialect, session, schema) as OPSQLiteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new OPSQLiteSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new OPSQLiteDatabase(
+		'async',
+		dialect,
+		session,
+		relations,
+	);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
diff --git a/drizzle-orm/src/op-sqlite/migrator.ts b/drizzle-orm/src/op-sqlite/migrator.ts
index 317b6b5df5..a947179ee5 100644
--- a/drizzle-orm/src/op-sqlite/migrator.ts
+++ b/drizzle-orm/src/op-sqlite/migrator.ts
@@ -1,22 +1,23 @@
 import { useEffect, useReducer } from 'react';
 import type { MigrationMeta } from '~/migrator.ts';
+import { formatToMillis } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
 import type { OPSQLiteDatabase } from './driver.ts';
 
 interface MigrationConfig {
-	journal: {
-		entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
-	};
 	migrations: Record<string, string>;
 }
 
-async function readMigrationFiles({ journal, migrations }: MigrationConfig): Promise<MigrationMeta[]> {
+async function readMigrationFiles({ migrations }: MigrationConfig): Promise<MigrationMeta[]> {
 	const migrationQueries: MigrationMeta[] = [];
 
-	for await (const journalEntry of journal.entries) {
-		const query = migrations[`m${journalEntry.idx.toString().padStart(4, '0')}`];
+	const sortedMigrations = Object.keys(migrations).sort();
 
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
 		if (!query) {
-			throw new Error(`Missing migration: ${journalEntry.tag}`);
+			throw new Error(`Missing migration: ${key}`);
 		}
 
 		try {
@@ -24,26 +25,29 @@ async function readMigrationFiles({ journal, migrations }: MigrationConfig): Pro
 				return it;
 			});
 
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
 			migrationQueries.push({
 				sql: result,
-				bps: journalEntry.breakpoints,
-				folderMillis: journalEntry.when,
+				bps: true,
+				folderMillis: migrationDate,
 				hash: '',
+				name: key,
 			});
 		} catch {
-			throw new Error(`Failed to parse migration: ${journalEntry.tag}`);
+			throw new Error(`Failed to parse migration: ${key}`);
 		}
 	}
 
 	return migrationQueries;
 }
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: OPSQLiteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: OPSQLiteDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = await readMigrationFiles(config);
-	return db.dialect.migrate(migrations, db.session);
+	return await migrateAsync(migrations, db);
 }
 
 interface State {
@@ -57,9 +61,6 @@ type Action =
 	| { type: 'error'; payload: Error };
 
 export const useMigrations = (db: OPSQLiteDatabase<any>, migrations: {
-	journal: {
-		entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
-	};
 	migrations: Record<string, string>;
 }): State => {
 	const initialState: State = {
diff --git a/drizzle-orm/src/op-sqlite/session.ts b/drizzle-orm/src/op-sqlite/session.ts
index a8a515c42d..309e0373f2 100644
--- a/drizzle-orm/src/op-sqlite/session.ts
+++ b/drizzle-orm/src/op-sqlite/session.ts
@@ -4,31 +4,30 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	SQLitePreparedQuery,
-	SQLiteSession,
-	type SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
 
 export interface OPSQLiteSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
+export type OPSQLiteRunResult = QueryResult;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class OPSQLiteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'async', QueryResult, TFullSchema, TSchema> {
+export class OPSQLiteSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', OPSQLiteRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'OPSQLiteSession';
 
 	private logger: Logger;
@@ -36,46 +35,63 @@ export class OPSQLiteSession<
 
 	constructor(
 		private client: OPSQLiteConnection,
-		dialect: SQLiteAsyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: OPSQLiteSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: OPSQLiteSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'async');
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): OPSQLitePreparedQuery<T> {
-		return new OPSQLitePreparedQuery(
-			this.client,
+	): SQLiteAsyncPreparedQuery<T & { run: OPSQLiteRunResult }> {
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) => {
+				if (mode === 'arrays') return this.client.executeRawAsync(query.sql, params);
+				return this.client.executeAsync(query.sql, params).then(({ rows }) => rows?._array || []);
+			},
+			get: (params) => {
+				if (mode === 'arrays') return this.client.executeRawAsync(query.sql, params).then((rows) => rows[0]);
+				return this.client.executeAsync(query.sql, params).then(({ rows }) => rows?._array?.[0]);
+			},
+			run: (params) => {
+				return this.client.executeAsync(query.sql, params);
+			},
+			values: (params) => {
+				return this.client.executeRawAsync(query.sql, params);
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: OPSQLiteTransaction<TFullSchema, TSchema>) => T,
+		transaction: (tx: OPSQLiteTransaction<TRelations>) => T,
 		config: SQLiteTransactionConfig = {},
 	): T {
-		const tx = new OPSQLiteTransaction('async', this.dialect, this, this.schema);
+		const tx = new OPSQLiteTransaction('async', this.dialect, this, this.relations);
 		this.run(sql.raw(`begin${config?.behavior ? ' ' + config.behavior : ''}`));
 		try {
 			const result = transaction(tx);
@@ -88,15 +104,22 @@ export class OPSQLiteSession<
 	}
 }
 
-export class OPSQLiteTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'async', QueryResult, TFullSchema, TSchema> {
+export class OPSQLiteTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', OPSQLiteRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'OPSQLiteTransaction';
 
-	override transaction<T>(transaction: (tx: OPSQLiteTransaction<TFullSchema, TSchema>) => T): T {
+	override transaction<T>(
+		transaction: (tx: OPSQLiteTransaction<TRelations>) => T,
+	): T {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new OPSQLiteTransaction('async', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new OPSQLiteTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = transaction(tx);
@@ -108,92 +131,3 @@ export class OPSQLiteTransaction<
 		}
 	}
 }
-
-export class OPSQLitePreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
-	{ type: 'async'; run: QueryResult; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'OPSQLitePreparedQuery';
-
-	constructor(
-		private client: OPSQLiteConnection,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
-	) {
-		super('sync', executeMethod, query, cache, queryMetadata, cacheConfig);
-	}
-
-	async run(placeholderValues?: Record<string, unknown>): Promise<QueryResult> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			return this.client.executeAsync(this.query.sql, params);
-		});
-	}
-
-	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, joinsNotNullableMap, query, logger, customResultMapper, client } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-
-			return await this.queryWithCache(query.sql, params, async () => {
-				return client.execute(query.sql, params).rows?._array || [];
-			});
-		}
-
-		const rows = await this.values(placeholderValues) as unknown[][];
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
-		}
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
-	}
-
-	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, joinsNotNullableMap, customResultMapper, query, logger, client } = this;
-		const params = fillPlaceholders(query.params, placeholderValues ?? {});
-		logger.logQuery(query.sql, params);
-		if (!fields && !customResultMapper) {
-			const rows = await this.queryWithCache(query.sql, params, async () => {
-				return client.execute(query.sql, params).rows?._array || [];
-			});
-			return rows[0];
-		}
-
-		const rows = await this.values(placeholderValues) as unknown[][];
-		const row = rows[0];
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['get'];
-		}
-
-		return mapResultRow(fields!, row, joinsNotNullableMap);
-	}
-
-	async values(placeholderValues?: Record<string, unknown>): Promise<T['values']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			return await this.client.executeRawAsync(this.query.sql, params);
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
diff --git a/drizzle-orm/src/operations.ts b/drizzle-orm/src/operations.ts
index 135e01fefb..25e567b2a6 100644
--- a/drizzle-orm/src/operations.ts
+++ b/drizzle-orm/src/operations.ts
@@ -1,31 +1,34 @@
-import type { AnyColumn, Column } from './column.ts';
+import type { NormalizeArrayCodec, NormalizeCodec } from './codecs.ts';
+import type { Column } from './column.ts';
 import type { SQL } from './sql/sql.ts';
+import type { Subquery } from './subquery.ts';
 import type { Table } from './table.ts';
 
-export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
-	notNull: true;
-	hasDefault: false;
-}> ? TKey
+// Optimized: Direct property access instead of structural extends check
+// This reduces type instantiations by ~25% for InferInsertModel
+export type RequiredKeyOnly<TKey extends string, T extends Column> = T['_']['notNull'] extends true
+	? T['_']['hasDefault'] extends false ? TKey : never
 	: never;
 
+// Optimized: Inline the required check instead of referencing RequiredKeyOnly
+// This avoids computing RequiredKeyOnly twice per key
 export type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> =
-	TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
-		_: {
-			generated: undefined;
-		};
-	} ? (T extends {
-			_: {
-				identity: undefined;
-			};
-		} ? TKey
+	// First check if it would be required (notNull=true && hasDefault=false)
+	T['_']['notNull'] extends true ? T['_']['hasDefault'] extends false ? never // It's required, not optional
+		: T['_']['generated'] extends undefined ? T['_']['identity'] extends undefined ? TKey
 			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
-			: TKey)
-	: never;
+			: TKey
+		: never
+		// Not notNull, so check generated/identity
+		: T['_']['generated'] extends undefined ? T['_']['identity'] extends undefined ? TKey
+			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
+			: TKey
+		: never;
 
 // TODO: SQL -> SQLWrapper
 export type SelectedFieldsFlat<TColumn extends Column> = Record<
 	string,
-	TColumn | SQL | SQL.Aliased
+	TColumn | SQL | SQL.Aliased | Subquery
 >;
 
 export type SelectedFieldsFlatFull<TColumn extends Column> = Record<
@@ -40,5 +43,10 @@ export type SelectedFields<TColumn extends Column, TTable extends Table> = Recor
 
 export type SelectedFieldsOrdered<TColumn extends Column> = {
 	path: string[];
-	field: TColumn | SQL | SQL.Aliased;
+	field: TColumn | SQL | SQL.Aliased | Subquery;
+	codec?: NormalizeCodec | NormalizeArrayCodec;
+	arrayDimensions?: number;
+	column?: Column;
+	/** Set operators may mutate type, set appropriate codec for resulting type */
+	codecOverride?: string;
 }[];
diff --git a/drizzle-orm/src/pg-core/utils/array.ts b/drizzle-orm/src/pg-core/array.ts
similarity index 100%
rename from drizzle-orm/src/pg-core/utils/array.ts
rename to drizzle-orm/src/pg-core/array.ts
diff --git a/drizzle-orm/src/pg-core/async/count.ts b/drizzle-orm/src/pg-core/async/count.ts
new file mode 100644
index 0000000000..b14a0ae2cc
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/count.ts
@@ -0,0 +1,49 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import { applyMixins } from '~/utils.ts';
+import type { PgDialect } from '../dialect.ts';
+import { PgCountBuilder } from '../query-builders/count.ts';
+import type { PgTable } from '../table.ts';
+import type { PgViewBase } from '../view-base.ts';
+import type { PgAsyncSession } from './session.ts';
+
+export interface PgAsyncCountBuilder extends PgCountBuilder, QueryPromise<number> {}
+
+export class PgAsyncCountBuilder extends PgCountBuilder {
+	static override readonly [entityKind]: string = 'PgAsyncCountBuilder';
+
+	protected session: PgAsyncSession;
+
+	constructor(
+		{ source, dialect, filters, session }: {
+			source: PgTable | PgViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: PgDialect;
+			session: PgAsyncSession;
+		},
+	) {
+		super({ source, dialect, filters });
+		this.session = session;
+	}
+
+	execute(placeholderValues?: Record<string, unknown>): Promise<number> {
+		return this.session.prepareQuery<{
+			execute: number;
+			objects: unknown;
+			arrays: unknown;
+			raw: unknown;
+		}>(
+			this.build(),
+			'arrays',
+			false,
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues);
+	}
+}
+
+applyMixins(PgAsyncCountBuilder, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/db.ts b/drizzle-orm/src/pg-core/async/db.ts
new file mode 100644
index 0000000000..df6636a389
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/db.ts
@@ -0,0 +1,685 @@
+import type { Cache } from '~/cache/core/cache.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import { PgInsertBuilder, PgSelectBuilder, PgUpdateBuilder, QueryBuilder } from '~/pg-core/query-builders/index.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PgTransactionConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { PgColumn } from '../columns/index.ts';
+import { RelationalQueryBuilder } from '../query-builders/query.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { PgViewBase } from '../view-base.ts';
+import type { PgMaterializedView } from '../view.ts';
+import { PgAsyncCountBuilder } from './count.ts';
+import { PgAsyncDeleteBase } from './delete.ts';
+import { PgAsyncInsertBase, type PgAsyncInsertHKT } from './insert.ts';
+import { PgAsyncRelationalQuery, type PgAsyncRelationalQueryHKT } from './query.ts';
+import { PgAsyncRaw } from './raw.ts';
+import { PgAsyncRefreshMaterializedView } from './refresh-materialized-view.ts';
+import { PgAsyncSelectBase, type PgAsyncSelectBuilder } from './select.ts';
+import { PgAsyncUpdateBase, type PgAsyncUpdateHKT } from './update.ts';
+
+export class PgAsyncDatabase<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'PgAsyncDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: PgAsyncSession<TQueryResult, TRelations>;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TRelations,
+			TRelations[K],
+			PgAsyncRelationalQueryHKT
+		>;
+	};
+
+	constructor(
+		/** @internal */
+		readonly dialect: PgDialect,
+		/** @internal */
+		readonly session: PgAsyncSession<any, any>,
+		relations: TRelations,
+		parseRqbJson: boolean = false,
+		readonly tagged: boolean = false,
+	) {
+		this._ = {
+			relations: relations,
+			session,
+		};
+
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as PgAsyncDatabase<
+				TQueryResult,
+				AnyRelations
+			>['query'])[tableName] = new RelationalQueryBuilder(
+				relations,
+				relations[relation.name]!.table as PgTable,
+				relation,
+				dialect,
+				session,
+				parseRqbJson,
+				PgAsyncRelationalQuery,
+			);
+		}
+
+		this.$cache = { invalidate: async (_params: any) => {} };
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(this.dialect));
+			}
+
+			const sql = ('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL();
+			return new Proxy(
+				new WithSubquery(
+					sql,
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+					sql.usedTables ?? [],
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: PgTable | PgViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	) {
+		return new PgAsyncCountBuilder({ source, filters, session: this.session, dialect: this.dialect });
+	}
+
+	$cache: { invalidate: Cache['onMutate'] };
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = await db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): PgAsyncSelectBuilder<undefined>;
+		function select<TSelection extends SelectedFields>(fields: TSelection): PgAsyncSelectBuilder<TSelection>;
+		function select<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): PgAsyncSelectBuilder<TSelection | undefined> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				tagged: self.tagged,
+			}, PgAsyncSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * await db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * await db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): PgAsyncSelectBuilder<undefined>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): PgAsyncSelectBuilder<TSelection>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): PgAsyncSelectBuilder<TSelection | undefined> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+				tagged: self.tagged,
+			}, PgAsyncSelectBase);
+		}
+
+		/**
+		 * Adds `distinct on` expression to the select query.
+		 *
+		 * Calling this method will specify how the unique rows are determined.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param on The expression defining uniqueness.
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select the first row for each unique brand from the 'cars' table
+		 * await db.selectDistinctOn([cars.brand])
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 *
+		 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+		 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand, cars.color);
+		 * ```
+		 */
+		function selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgAsyncSelectBuilder<undefined>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (PgColumn | SQLWrapper)[],
+			fields: TSelection,
+		): PgAsyncSelectBuilder<TSelection>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (PgColumn | SQLWrapper)[],
+			fields?: TSelection,
+		): PgAsyncSelectBuilder<TSelection | undefined> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: { on },
+				tagged: self.tagged,
+			}, PgAsyncSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * await db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 *
+		 * // Update with returning clause
+		 * const updatedCar: Car[] = await db.update(cars)
+		 *   .set({ color: 'red' })
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult, PgAsyncUpdateHKT> {
+			return new PgUpdateBuilder(table, self.session, self.dialect, queries, PgAsyncUpdateBase);
+		}
+
+		/**
+		 * Creates an insert query.
+		 *
+		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/insert}
+		 *
+		 * @param table The table to insert into.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Insert one row
+		 * await db.insert(cars).values({ brand: 'BMW' });
+		 *
+		 * // Insert multiple rows
+		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+		 *
+		 * // Insert with returning clause
+		 * const insertedCar: Car[] = await db.insert(cars)
+		 *   .values({ brand: 'BMW' })
+		 *   .returning();
+		 * ```
+		 */
+		function insert<TTable extends PgTable>(
+			table: TTable,
+		): PgInsertBuilder<TTable, TQueryResult, false, PgAsyncInsertHKT> {
+			return new PgInsertBuilder(table, self.session, self.dialect, queries, undefined, PgAsyncInsertBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * await db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * await db.delete(cars).where(eq(cars.color, 'green'));
+		 *
+		 * // Delete with returning clause
+		 * const deletedCar: Car[] = await db.delete(cars)
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function delete_<TTable extends PgTable>(table: TTable): PgAsyncDeleteBase<TTable, TQueryResult> {
+			return new PgAsyncDeleteBase(table, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = await db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): PgAsyncSelectBuilder<undefined>;
+	select<TSelection extends SelectedFields>(fields: TSelection): PgAsyncSelectBuilder<TSelection>;
+	select<TSelection extends SelectedFields | undefined>(
+		fields?: TSelection,
+	): PgAsyncSelectBuilder<TSelection> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			tagged: this.tagged,
+		}, PgAsyncSelectBase) as PgAsyncSelectBuilder<TSelection>;
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * await db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * await db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): PgAsyncSelectBuilder<undefined>;
+	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgAsyncSelectBuilder<TSelection>;
+	selectDistinct<TSelection extends SelectedFields | undefined>(
+		fields?: TSelection,
+	): PgAsyncSelectBuilder<TSelection | undefined> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+			tagged: this.tagged,
+		}, PgAsyncSelectBase);
+	}
+
+	/**
+	 * Adds `distinct on` expression to the select query.
+	 *
+	 * Calling this method will specify how the unique rows are determined.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param on The expression defining uniqueness.
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select the first row for each unique brand from the 'cars' table
+	 * await db.selectDistinctOn([cars.brand])
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 *
+	 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+	 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand, cars.color);
+	 * ```
+	 */
+	selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgAsyncSelectBuilder<undefined>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (PgColumn | SQLWrapper)[],
+		fields: TSelection,
+	): PgAsyncSelectBuilder<TSelection>;
+	selectDistinctOn<TSelection extends SelectedFields | undefined>(
+		on: (PgColumn | SQLWrapper)[],
+		fields?: TSelection,
+	): PgAsyncSelectBuilder<TSelection> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: { on },
+			tagged: this.tagged,
+		}, PgAsyncSelectBase) as PgAsyncSelectBuilder<TSelection>;
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * await db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 *
+	 * // Update with returning clause
+	 * const updatedCar: Car[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult, PgAsyncUpdateHKT> {
+		return new PgUpdateBuilder(table, this.session, this.dialect, undefined, PgAsyncUpdateBase);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * await db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 *
+	 * // Insert with returning clause
+	 * const insertedCar: Car[] = await db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 * ```
+	 */
+	insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult, false, PgAsyncInsertHKT> {
+		return new PgInsertBuilder(table, this.session, this.dialect, undefined, undefined, PgAsyncInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * await db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 *
+	 * // Delete with returning clause
+	 * const deletedCar: Car[] = await db.delete(cars)
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	delete<TTable extends PgTable>(table: TTable): PgAsyncDeleteBase<TTable, TQueryResult> {
+		return new PgAsyncDeleteBase(table, this.session, this.dialect);
+	}
+
+	refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgAsyncRefreshMaterializedView<TQueryResult> {
+		return new PgAsyncRefreshMaterializedView(view, this.session, this.dialect);
+	}
+
+	execute<TRow extends Record<string, unknown> = Record<string, unknown>>(
+		query: SQLWrapper | string,
+	): PgAsyncRaw<PgQueryResultKind<TQueryResult, TRow>> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: PgQueryResultKind<TQueryResult, TRow> }
+		>(builtQuery, 'raw', false);
+		return new PgAsyncRaw(prepared, sequel, builtQuery);
+	}
+
+	transaction<T>(
+		transaction: (tx: PgAsyncTransaction<TQueryResult, TRelations>) => Promise<T>,
+		config?: PgTransactionConfig,
+	): Promise<T> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type PgAsyncWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	HKT extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+	Q extends PgAsyncDatabase<HKT, TRelations>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): PgAsyncWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const selectDistinctOn: Q['selectDistinctOn'] = (...args: [any]) => getReplica(replicas).selectDistinctOn(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const _with: Q['with'] = (...args: any) => getReplica(replicas).with(...args);
+	const $with: Q['$with'] = (arg: any) => getReplica(replicas).$with(arg) as any;
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
+
+	const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: [any]) =>
+		primary.refreshMaterializedView(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		refreshMaterializedView,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		selectDistinctOn,
+		$count,
+		$with,
+		with: _with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/pg-core/async/delete.ts b/drizzle-orm/src/pg-core/async/delete.ts
new file mode 100644
index 0000000000..11994d74ce
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/delete.ts
@@ -0,0 +1,109 @@
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { PgDeleteBase, type PgDeleteHKTBase } from '../query-builders/delete.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+export type PgAsyncDelete<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = PgAsyncDeleteBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+
+export type PgAsyncDeletePrepare<T extends AnyAsyncPgDelete> = PgAsyncPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type AnyAsyncPgDelete = PgAsyncDeleteBase<any, any, any, any, any, any>;
+
+export interface PgAsyncDeleteHKT extends PgDeleteHKTBase {
+	_type: PgAsyncDeleteBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export interface PgAsyncDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]> {}
+
+export class PgAsyncDeleteBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends PgDeleteBase<PgAsyncDeleteHKT, TTable, TQueryResult, TSelectedFields, TReturning, TDynamic, TExcludedMethods>
+	implements
+		TypedQueryBuilder<
+			TSelectedFields,
+			TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
+		>,
+		RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
+		SQLWrapper
+{
+	static override readonly [entityKind]: string = 'PgAsyncDelete';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgAsyncDeletePrepare<this> {
+		const { session, config, dialect } = this;
+		const { returning: fields } = config;
+
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = dialect.sqlToQuery(this.getSQL());
+			const mapper = fields
+				? this.dialect.mapperGenerators.rows(fields, undefined)
+				: undefined;
+
+			const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+				query,
+				fields ? 'arrays' : 'raw',
+				name ?? generateName,
+				mapper,
+				{ type: 'delete', tables: [...extractUsedTable(this.config.table)] },
+			);
+
+			return preparedQuery;
+		});
+	}
+
+	prepare(name?: string): PgAsyncDeletePrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
+
+applyMixins(PgAsyncDeleteBase, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/index.ts b/drizzle-orm/src/pg-core/async/index.ts
new file mode 100644
index 0000000000..e325010cd3
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/index.ts
@@ -0,0 +1,10 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './refresh-materialized-view.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
diff --git a/drizzle-orm/src/pg-core/async/insert.ts b/drizzle-orm/src/pg-core/async/insert.ts
new file mode 100644
index 0000000000..91f5dbaa2b
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/insert.ts
@@ -0,0 +1,110 @@
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import type { PgInsertHKTBase } from '../query-builders/insert.ts';
+import { PgInsertBase } from '../query-builders/insert.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+export interface PgAsyncInsertHKT extends PgInsertHKTBase {
+	_type: PgAsyncInsertBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		this['selectedFields'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnyPgAsyncInsert = PgAsyncInsertBase<any, any, any, any, any, any>;
+
+export type PgInsertPrepare<T extends AnyPgAsyncInsert> = PgAsyncPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	}
+>;
+
+export type PgAsyncInsert<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = ColumnsSelection | undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = PgAsyncInsertBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+
+export interface PgAsyncInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]> {
+}
+
+export class PgAsyncInsertBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends PgInsertBase<
+	PgAsyncInsertHKT,
+	TTable,
+	TQueryResult,
+	TSelectedFields,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'> {
+	static override readonly [entityKind]: string = 'PgAsyncInsert';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgInsertPrepare<this> {
+		const { session, config, dialect } = this;
+		const { returning: fields } = config;
+
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = dialect.sqlToQuery(this.getSQL());
+			const mapper = fields
+				? this.dialect.mapperGenerators.rows(fields, undefined)
+				: undefined;
+
+			const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+				query,
+				fields ? 'arrays' : 'raw',
+				name ?? generateName,
+				mapper,
+				{ type: 'insert', tables: [...extractUsedTable(this.config.table)] },
+			);
+
+			return preparedQuery;
+		});
+	}
+
+	prepare(name?: string): PgInsertPrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
+
+applyMixins(PgAsyncInsertBase, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/query.ts b/drizzle-orm/src/pg-core/async/query.ts
new file mode 100644
index 0000000000..f39c5f7df0
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/query.ts
@@ -0,0 +1,59 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins } from '~/utils.ts';
+import { PgRelationalQuery, type PgRelationalQueryHKTBase } from '../query-builders/query.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+export type AnyPgAsyncRelationalQuery = PgAsyncRelationalQuery<any>;
+
+export interface PgAsyncRelationalQueryHKT extends PgRelationalQueryHKTBase {
+	_type: PgAsyncRelationalQuery<this['result']>;
+}
+
+export interface PgAsyncRelationalQuery<TResult> extends QueryPromise<TResult> {}
+export class PgAsyncRelationalQuery<TResult> extends PgRelationalQuery<PgAsyncRelationalQueryHKT, TResult>
+	implements RunnableQuery<TResult, 'pg'>
+{
+	static override readonly [entityKind]: string = 'PgAsyncRelationalQueryV2';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgAsyncPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const { query, builtQuery } = this._toSQL();
+
+			const mapper = this.dialect.mapperGenerators.relationalRows({
+				isFirst: this.mode === 'first',
+				parseJson: this.parseJson,
+				parseJsonIfString: false,
+				rootJsonMappers: false,
+				selection: query.selection,
+				arrayModeRoot: true,
+			});
+
+			return this.session.prepareQuery<PreparedQueryConfig & { execute: TResult }>(
+				builtQuery,
+				'arrays',
+				name ?? generateName,
+				mapper,
+				// TODO: implement cache
+			);
+		});
+	}
+
+	prepare(name?: string): PgAsyncPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
+		return this._prepare(name, true);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>): Promise<TResult> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	}
+}
+
+applyMixins(PgAsyncRelationalQuery, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/raw.ts b/drizzle-orm/src/pg-core/async/raw.ts
new file mode 100644
index 0000000000..ed62a5bb8e
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/raw.ts
@@ -0,0 +1,41 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { applyMixins } from '~/utils.ts';
+import { PgRaw } from '../query-builders/raw.ts';
+import type { PgAsyncPreparedQuery } from './session.ts';
+
+export interface PgAsyncRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'pg'>, SQLWrapper {}
+export class PgAsyncRaw<TResult> extends PgRaw<TResult> implements RunnableQuery<TResult, 'pg'> {
+	static override readonly [entityKind]: string = 'PgAsyncRaw';
+
+	declare readonly _: {
+		readonly dialect: 'pg';
+		readonly result: TResult;
+	};
+
+	declare protected prepared: PgAsyncPreparedQuery<{
+		execute: TResult;
+	}>;
+
+	constructor(
+		prepared: PgAsyncPreparedQuery<{
+			execute: TResult;
+		}>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.prepared.execute(placeholderValues);
+	}
+
+	override _prepare() {
+		return this.prepared;
+	}
+}
+
+applyMixins(PgAsyncRaw, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/refresh-materialized-view.ts b/drizzle-orm/src/pg-core/async/refresh-materialized-view.ts
new file mode 100644
index 0000000000..ec2cb96e88
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/refresh-materialized-view.ts
@@ -0,0 +1,54 @@
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins } from '~/utils.ts';
+import { PgRefreshMaterializedView } from '../query-builders/refresh-materialized-view.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface PgAsyncRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
+	extends QueryPromise<PgQueryResultKind<TQueryResult, never>>
+{}
+
+export class PgAsyncRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
+	extends PgRefreshMaterializedView<TQueryResult>
+	implements RunnableQuery<PgQueryResultKind<TQueryResult, never>, 'pg'>
+{
+	static override readonly [entityKind]: string = 'PgAsyncRefreshMaterializedView';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgAsyncPreparedQuery<
+		PreparedQueryConfig & {
+			execute: PgQueryResultKind<TQueryResult, never>;
+		}
+	> {
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = this.dialect.sqlToQuery(this.getSQL());
+			return this.session.prepareQuery(
+				query,
+				'raw',
+				name ?? generateName,
+			);
+		});
+	}
+
+	prepare(name?: string): PgAsyncPreparedQuery<
+		PreparedQueryConfig & {
+			execute: PgQueryResultKind<TQueryResult, never>;
+		}
+	> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
+
+applyMixins(PgAsyncRefreshMaterializedView, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/async/select.ts b/drizzle-orm/src/pg-core/async/select.ts
new file mode 100644
index 0000000000..ec9965260a
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/select.ts
@@ -0,0 +1,147 @@
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { PgSelectBase, type PgSelectBuilder } from '../query-builders/select.ts';
+import type { PgSelectHKTBase, SelectedFields } from '../query-builders/select.types.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+export type PgAsyncSelectPrepare<T extends AnyPgAsyncSelect> = PgAsyncPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	}
+>;
+
+export type PgAsyncSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+> = PgSelectBuilder<TSelection, PgAsyncSelectHKT>;
+
+export type PgAsyncSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgAsyncSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export interface PgAsyncSelectHKT extends PgSelectHKTBase {
+	_type: PgAsyncSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface PgAsyncSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection | undefined,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	// oxlint-disable-next-line no-unused-vars
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	// oxlint-disable-next-line no-unused-vars
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<
+		Assume<TSelection, ColumnsSelection>,
+		TNullabilityMap
+	>,
+> extends QueryPromise<TResult> {
+}
+
+export class PgAsyncSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection | undefined,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<
+		Assume<TSelection, ColumnsSelection>,
+		TNullabilityMap
+	>,
+> extends PgSelectBase<
+	PgAsyncSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'PgAsyncSelectQueryBuilder';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgAsyncSelectPrepare<this> {
+		const { session, dialect, cacheConfig, usedTables } = this;
+
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			// Build query before accessing `fieldsFlat` - build mutates it
+			const query = this.config.tagged ? dialect._sqlToQuery(this.getSQL()) : dialect.sqlToQuery(this.getSQL());
+			const fieldsList = this.config.fieldsFlat!;
+			const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+			const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+				query,
+				'arrays',
+				name ?? generateName,
+				mapper,
+				{ type: 'select', tables: [...usedTables] },
+				cacheConfig,
+			);
+
+			return preparedQuery;
+		});
+	}
+
+	/**
+	 * Create a prepared statement for this query. This allows
+	 * the database to remember this query for the given session
+	 * and call it by name, rather than specifying the full query.
+	 *
+	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
+	 */
+	prepare(
+		name?: string,
+	): PgAsyncSelectPrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	}
+}
+
+applyMixins(PgAsyncSelectBase, [QueryPromise]);
+
+export type AnyPgAsyncSelect = PgAsyncSelectBase<any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/pg-core/async/session.ts b/drizzle-orm/src/pg-core/async/session.ts
new file mode 100644
index 0000000000..9b02cadd89
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/session.ts
@@ -0,0 +1,347 @@
+import { type Cache, NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import { is } from '~/entity.ts';
+import { TransactionRollbackError } from '~/errors.ts';
+import { DrizzleQueryError } from '~/errors.ts';
+import type { Logger } from '~/logger.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import { hasTelemetry, tracer } from '~/tracing.ts';
+import { upgradeIfNeeded } from '~/up-migrations/pg.ts';
+import { assertUnreachable } from '~/utils.ts';
+import type { PgDialect } from '../dialect.ts';
+import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '../session.ts';
+import { PgBasePreparedQuery, PgSession } from '../session.ts';
+import { PgAsyncDatabase } from './db.ts';
+
+export class PgAsyncPreparedQuery<T extends PreparedQueryConfig> extends PgBasePreparedQuery {
+	static override readonly [entityKind]: string = 'PgAsyncPreparedQuery';
+
+	/** @internal */
+	readonly mapper: {
+		(rows: any[]): any;
+		body?: string;
+	} | undefined;
+
+	private fastPath: boolean;
+
+	constructor(
+		protected executor: (params?: unknown[]) => Promise<any>,
+		query: Query,
+		mapper: ((rows: any[]) => any) | undefined,
+		readonly mode: 'arrays' | 'objects' | 'raw',
+		protected logger: Logger,
+		// cache instance
+		protected cache: Cache | undefined,
+		// per query related metadata
+		protected queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		protected cacheConfig: WithCacheConfig | undefined,
+	) {
+		super(query);
+		this.mapper = mapper;
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+
+		this.fastPath = cacheConfig === undefined
+			&& (cache === undefined || is(cache, NoopCache))
+			&& !hasTelemetry;
+	}
+
+	override async execute(placeholderValues: Record<string, unknown> = {}): Promise<T['execute']> {
+		const { query, logger, executor, mapper, fastPath } = this;
+
+		if (fastPath) {
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+			logger.logQuery(sql, params);
+			const res = executor(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			});
+			if (!mapper) return res;
+
+			return res.then((rows) => mapper(rows));
+		}
+
+		return tracer.startActiveSpan('drizzle.execute', async (span) => {
+			const params = fillPlaceholders(this.query.params, placeholderValues);
+			const sql = this.query._sql ? this.query._sql.join(' ') : this.query.sql;
+			const { mapper } = this;
+
+			span?.setAttributes({
+				'drizzle.query.text': sql,
+				'drizzle.query.params': JSON.stringify(params),
+			});
+
+			this.logger.logQuery(sql, params);
+
+			const query = tracer.startActiveSpan('drizzle.driver.execute', async (span) => {
+				span?.setAttributes({
+					'drizzle.query.text': sql,
+					'drizzle.query.params': JSON.stringify(params),
+				});
+
+				// return await so tracer captures time accurately
+				return await this.queryWithCache(sql, params, () => this.executor(params));
+			});
+
+			if (!mapper) return query;
+
+			return query.then((rows) => tracer.startActiveSpan('drizzle.mapResponse', () => mapper(rows as unknown[])));
+		});
+	}
+
+	/** @internal */
+	protected async queryWithCache<T>(
+		queryString: string,
+		params: any[],
+		query: () => Promise<T>,
+	): Promise<T> {
+		const cacheStrat = this.cache !== undefined && !is(this.cache, NoopCache)
+			? await strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)
+			: { type: 'skip' as const };
+
+		if (cacheStrat.type === 'skip') {
+			return query().catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		const cache = this.cache!;
+
+		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+		if (cacheStrat.type === 'invalidate') {
+			return Promise.all([
+				query(),
+				cache.onMutate({ tables: cacheStrat.tables }),
+			]).then((res) => res[0]).catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		if (cacheStrat.type === 'try') {
+			const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+			const fromCache = await cache.get(
+				key,
+				tables,
+				isTag,
+				autoInvalidate,
+			);
+
+			if (fromCache === undefined) {
+				const result = await query().catch((e) => {
+					throw new DrizzleQueryError(queryString, params, e as Error);
+				});
+				// put actual key
+				await cache.put(
+					key,
+					result,
+					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+				// put flag if we should invalidate or not
+				return result;
+			}
+
+			return fromCache as unknown as T;
+		}
+
+		assertUnreachable(cacheStrat);
+	}
+}
+
+export abstract class PgAsyncSession<
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgSession {
+	static override readonly [entityKind]: string = 'PgAsyncSession';
+
+	abstract override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgAsyncPreparedQuery<T>;
+
+	override execute<T>(query: SQL): Promise<T[]> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
+				return this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+					this.dialect.sqlToQuery(query),
+					'raw',
+					false,
+				);
+			});
+
+			return prepared.execute();
+		});
+	}
+
+	override arrays<T>(query: SQL): Promise<T[]> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
+				return this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+					this.dialect.sqlToQuery(query),
+					'arrays',
+					false,
+				);
+			});
+
+			return prepared.execute();
+		});
+	}
+
+	override objects<T>(query: SQL): Promise<T[]> {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
+				return this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+					this.dialect.sqlToQuery(query),
+					'objects',
+					false,
+				);
+			});
+
+			return prepared.execute();
+		});
+	}
+
+	abstract transaction<T>(
+		transaction: (tx: PgAsyncTransaction<TQueryResult, TRelations>) => Promise<T>,
+		config?: PgTransactionConfig,
+	): Promise<T>;
+}
+
+export abstract class PgAsyncTransaction<
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgAsyncDatabase<TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'PgAsyncTransaction';
+
+	constructor(
+		dialect: PgDialect,
+		session: PgAsyncSession<any, any>,
+		relations: TRelations,
+		protected readonly nestedIndex = 0,
+		parseRqbJson: boolean | undefined,
+	) {
+		super(dialect, session, relations, parseRqbJson);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+
+	/** @internal */
+	getTransactionConfigSQL(config: PgTransactionConfig): SQL {
+		const chunks: string[] = [];
+		if (config.isolationLevel) {
+			chunks.push(`isolation level ${config.isolationLevel}`);
+		}
+		if (config.accessMode) {
+			chunks.push(config.accessMode);
+		}
+		if (typeof config.deferrable === 'boolean') {
+			chunks.push(config.deferrable ? 'deferrable' : 'not deferrable');
+		}
+		return sql.raw(chunks.join(' '));
+	}
+
+	setTransaction(config: PgTransactionConfig): Promise<unknown> {
+		return this.session.execute<void>(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+	}
+
+	abstract override transaction<T>(
+		transaction: (tx: PgAsyncTransaction<TQueryResult, TRelations>) => Promise<T>,
+	): Promise<T>;
+}
+
+export async function migrate(
+	migrations: MigrationMeta[],
+	db: PgAsyncDatabase<PgQueryResultHKT, any>,
+	config: string | MigrationConfig,
+): Promise<void | MigratorInitFailResponse> {
+	const migrationsTable = typeof config === 'string'
+		? '__drizzle_migrations'
+		: config.migrationsTable ?? '__drizzle_migrations';
+	const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle';
+
+	await db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded(migrationsSchema, migrationsTable, db, migrations);
+
+	// Create table with latest schema (version 1) if this is a new database
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash text NOT NULL,
+				created_at bigint,
+				name text,
+				applied_at timestamp with time zone DEFAULT now()
+			)
+		`;
+		await db.execute(migrationTableCreate);
+	}
+
+	const dbMigrations = await db.session.objects<{ id: number; hash: string; created_at: string; name: string }>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await db.execute(
+			sql`insert into ${sql.identifier(migrationsSchema)}.${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name ?? null})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	await db.transaction(async (tx) => {
+		for (const migration of migrationsToRun) {
+			for (const stmt of migration.sql) {
+				await tx.execute(sql.raw(stmt));
+			}
+			await tx.execute(
+				sql`insert into ${sql.identifier(migrationsSchema)}.${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${
+					migration.name ?? null
+				})`,
+			);
+		}
+	});
+}
diff --git a/drizzle-orm/src/pg-core/async/update.ts b/drizzle-orm/src/pg-core/async/update.ts
new file mode 100644
index 0000000000..69f2f30034
--- /dev/null
+++ b/drizzle-orm/src/pg-core/async/update.ts
@@ -0,0 +1,135 @@
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { JoinNullability } from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import { tracer } from '~/tracing.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { type Join, PgUpdateBase, type PgUpdateHKTBase } from '../query-builders/update.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgViewBase } from '../view-base.ts';
+import type { PgAsyncPreparedQuery, PgAsyncSession } from './session.ts';
+
+export type PgAsyncUpdatePrepare<T extends AnyPgAsyncUpdate> = PgAsyncPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type PgAsyncUpdate<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+> = PgAsyncUpdateBase<
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	true,
+	never
+>;
+
+export interface PgAsyncUpdateHKT extends PgUpdateHKTBase {
+	_type: PgAsyncUpdateBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['from'], PgTable | Subquery | PgViewBase | SQL | undefined>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		Assume<this['joins'], Join[]>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnyPgAsyncUpdate = PgAsyncUpdateBase<any, any, any, any, any, any, any, any, any>;
+
+export interface PgAsyncUpdateBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TJoins extends Join[] = [],
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]> {}
+
+export class PgAsyncUpdateBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends PgUpdateBase<
+	PgAsyncUpdateHKT,
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'> {
+	static override readonly [entityKind]: string = 'PgAsyncUpdate';
+
+	declare protected session: PgAsyncSession;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgAsyncUpdatePrepare<this> {
+		const { session, config, dialect, joinsNotNullableMap } = this;
+		const { returning: fields } = config;
+
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const query = dialect.sqlToQuery(this.getSQL());
+			const mapper = fields
+				? this.dialect.mapperGenerators.rows(fields, joinsNotNullableMap)
+				: undefined;
+
+			const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+				query,
+				fields ? 'arrays' : 'raw',
+				name ?? generateName,
+				mapper,
+				{ type: 'update', tables: [...extractUsedTable(this.config.table)] },
+			);
+
+			return preparedQuery;
+		});
+	}
+
+	prepare(name?: string): PgAsyncUpdatePrepare<this> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues: Record<string, unknown> = {}) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyMixins(PgAsyncUpdateBase, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/casing.ts b/drizzle-orm/src/pg-core/casing.ts
new file mode 100644
index 0000000000..95cb85b549
--- /dev/null
+++ b/drizzle-orm/src/pg-core/casing.ts
@@ -0,0 +1,21 @@
+import { type PgSchema, pgSchema } from './schema.ts';
+import { pgTableWithCasing } from './table.ts';
+import { pgMaterializedViewWithCasing, pgViewWithCasing } from './view.ts';
+
+export const snakeCase = {
+	table: pgTableWithCasing('snake_case'),
+	view: pgViewWithCasing('snake_case'),
+	materializedView: pgMaterializedViewWithCasing('snake_case'),
+	schema: <T extends string>(name: T): PgSchema<T> => {
+		return pgSchema(name, 'snake_case');
+	},
+};
+
+export const camelCase = {
+	table: pgTableWithCasing('camelCase'),
+	view: pgViewWithCasing('camelCase'),
+	materializedView: pgMaterializedViewWithCasing('camelCase'),
+	schema: <T extends string>(name: T): PgSchema<T> => {
+		return pgSchema(name, 'camelCase');
+	},
+};
diff --git a/drizzle-orm/src/pg-core/codecs.ts b/drizzle-orm/src/pg-core/codecs.ts
new file mode 100644
index 0000000000..a3de92e6fd
--- /dev/null
+++ b/drizzle-orm/src/pg-core/codecs.ts
@@ -0,0 +1,1221 @@
+import {
+	type CastArrayCodec,
+	type CastCodec,
+	type Codecs,
+	type NormalizeArrayCodec,
+	type NormalizeCodec,
+	refineCodecs,
+} from '~/codecs.ts';
+import { type Name, sql, type SQLChunk } from '~/sql/sql.ts';
+import type { PartialWithUndefined } from '~/utils.ts';
+import { makePgArray, parsePgArray } from './array.ts';
+import { parseEWKB } from './columns/postgis_extension/utils.ts';
+
+export type PostGISType =
+	| 'geometry(point)'
+	| 'geometry(pointz)'
+	| 'geometry(pointm)'
+	| 'geometry(pointzm)'
+	| 'geometry(linestring)'
+	| 'geometry(linestringz)'
+	| 'geometry(linestringm)'
+	| 'geometry(linestringzm)'
+	| 'geometry(polygon)'
+	| 'geometry(polygonz)'
+	| 'geometry(polygonm)'
+	| 'geometry(polygonzm)'
+	| 'geometry(multipoint)'
+	| 'geometry(multipointz)'
+	| 'geometry(multipointm)'
+	| 'geometry(multipointzm)'
+	| 'geometry(multilinestring)'
+	| 'geometry(multilinestringz)'
+	| 'geometry(multilinestringm)'
+	| 'geometry(multilinestringzm)'
+	| 'geometry(multipolygon)'
+	| 'geometry(multipolygonz)'
+	| 'geometry(multipolygonm)'
+	| 'geometry(multipolygonzm)'
+	| 'geometry(geometrycollection)'
+	| 'geometry(geometrycollectionz)'
+	| 'geometry(geometrycollectionm)'
+	| 'geometry(geometrycollectionzm)'
+	| 'geometry(circularstring)'
+	| 'geometry(circularstringz)'
+	| 'geometry(circularstringm)'
+	| 'geometry(circularstringzm)'
+	| 'geometry(compoundcurve)'
+	| 'geometry(compoundcurvez)'
+	| 'geometry(compoundcurvem)'
+	| 'geometry(compoundcurvezm)'
+	| 'geometry(curvepolygon)'
+	| 'geometry(curvepolygonz)'
+	| 'geometry(curvepolygonm)'
+	| 'geometry(curvepolygonzm)'
+	| 'geometry(multicurve)'
+	| 'geometry(multicurvez)'
+	| 'geometry(multicurvem)'
+	| 'geometry(multicurvezm)'
+	| 'geometry(multisurface)'
+	| 'geometry(multisurfacez)'
+	| 'geometry(multisurfacem)'
+	| 'geometry(multisurfacezm)'
+	| 'geometry(polyhedralsurface)'
+	| 'geometry(polyhedralsurfacez)'
+	| 'geometry(polyhedralsurfacem)'
+	| 'geometry(polyhedralsurfacezm)'
+	| 'geometry(tin)'
+	| 'geometry(tinz)'
+	| 'geometry(tinm)'
+	| 'geometry(tinzm)'
+	| 'geometry(triangle)'
+	| 'geometry(trianglez)'
+	| 'geometry(trianglem)'
+	| 'geometry(trianglezm)'
+	| 'geography(point)'
+	| 'geography(linestring)'
+	| 'geography(polygon)'
+	| 'geography(multipoint)'
+	| 'geography(multilinestring)'
+	| 'geography(multipolygon)'
+	| 'geography(geometrycollection)'
+	| 'box2d'
+	| 'box3d'
+	| 'raster';
+
+export type PostgresType =
+	// Numeric
+	| 'smallint'
+	| 'int'
+	| 'bigint'
+	| 'bigint:number'
+	| 'bigint:string'
+	| 'numeric'
+	| 'numeric:number'
+	| 'numeric:bigint'
+	| 'float4'
+	| 'float8'
+	| 'money'
+	| 'smallserial'
+	| 'serial'
+	| 'bigserial'
+	| 'bigserial:number'
+	// Text
+	| 'char'
+	| 'varchar'
+	| 'text'
+	// Binary
+	| 'bytea'
+	// Datetime
+	| 'date'
+	| 'date:string'
+	| 'time'
+	| 'timetz'
+	| 'timestamp'
+	| 'timestamptz'
+	| 'timestamp:string'
+	| 'timestamptz:string'
+	| 'interval'
+	| 'interval:tuple'
+	// Boolean
+	| 'bool'
+	// Enumerated
+	| 'enum'
+	// Geometric
+	| 'point'
+	| 'point:tuple'
+	| 'line'
+	| 'line:tuple'
+	| 'lseg'
+	| 'box'
+	| 'path'
+	| 'polygon'
+	| 'circle'
+	// Network Address
+	| 'cidr'
+	| 'inet'
+	| 'macaddr'
+	| 'macaddr8'
+	// Bit String
+	| 'bit'
+	| 'varbit'
+	// Full-Text Search
+	| 'tsvector'
+	| 'tsquery'
+	// UUID
+	| 'uuid'
+	// XML
+	| 'xml'
+	// JSON
+	| 'json'
+	| 'jsonb'
+	// Range
+	| 'int4range'
+	| 'int8range'
+	| 'numrange'
+	| 'tsrange'
+	| 'tstzrange'
+	| 'daterange'
+	// Multirange
+	| 'int4multirange'
+	| 'int8multirange'
+	| 'nummultirange'
+	| 'tsmultirange'
+	| 'tstzmultirange'
+	| 'datemultirange'
+	// Object Identifier / System Reference
+	| 'oid'
+	| 'regproc'
+	| 'regprocedure'
+	| 'regoper'
+	| 'regoperator'
+	| 'regclass'
+	| 'regtype'
+	| 'regrole'
+	| 'regnamespace'
+	| 'regconfig'
+	| 'regdictionary'
+	// PostGIS
+	| PostGISType
+	| `${PostGISType}:tuple`
+	// pgvector
+	| 'halfvec'
+	| 'sparsevec'
+	| 'vector';
+
+// Some originals were swapped with aliases for simpler keys
+export type PostgresAliasType =
+	// Numeric
+	| 'int2' // smallint
+	| 'integer' // int
+	| 'int4' // int
+	| 'int8' // bigint
+	| 'decimal' // numeric
+	| 'real' // float4
+	| 'double' // float8
+	| 'double precision' // float8
+	| 'serial2' // smallserial
+	| 'serial4' // serial
+	| 'serial8' // bigserial
+	// Text
+	| 'character' // char
+	| 'character varying' // varchar
+	// Datetime
+	| 'time with time zone' // timetz
+	| 'time without time zone' // timetz
+	| 'timestamp with time zone' // timestamptz
+	| 'timestamp without time zone' // timestamptz
+	// Boolean
+	| 'boolean' // bool
+	// Bit String
+	| 'bit varying'; // varbit;
+
+export type PostgresColumnType =
+	| PostgresType
+	| PostgresAliasType;
+
+const PG_ALIAS_TO_TYPE_MAP: Record<PostgresAliasType, PostgresType> = {
+	int2: 'smallint',
+	integer: 'int',
+	int4: 'int',
+	int8: 'bigint',
+	decimal: 'numeric',
+	real: 'float4',
+	double: 'float8',
+	'double precision': 'float8',
+	serial2: 'smallserial',
+	serial4: 'serial',
+	serial8: 'bigserial',
+	character: 'char',
+	'character varying': 'varchar',
+	'time with time zone': 'timetz',
+	'time without time zone': 'time',
+	'timestamp with time zone': 'timestamptz',
+	'timestamp without time zone': 'timestamp',
+	boolean: 'bool',
+	'bit varying': 'varbit',
+};
+
+export function resolvePgTypeAlias(type: string) {
+	return (PG_ALIAS_TO_TYPE_MAP as Record<string, PostgresType | undefined>)[type] ?? type;
+}
+
+// Cross-type unions mutate data types
+// update codec based on type combination
+export const unionsTypeTable = {
+	smallint: {
+		smallint: 'smallint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'smallint',
+		serial: 'int',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	int: {
+		smallint: 'int',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'int',
+		serial: 'int',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	bigint: {
+		smallint: 'bigint',
+		int: 'bigint',
+		bigint: 'bigint',
+		'bigint:number': 'bigint',
+		'bigint:string': 'bigint',
+		numeric: 'numeric:bigint',
+		'numeric:number': 'numeric:bigint',
+		'numeric:bigint': 'numeric:bigint',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'bigint',
+		serial: 'bigint',
+		bigserial: 'bigint',
+		'bigserial:number': 'bigint',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	'bigint:number': {
+		smallint: 'bigint:number',
+		int: 'bigint:number',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'bigint:number',
+		serial: 'bigint:number',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	'bigint:string': {
+		smallint: 'bigint:string',
+		int: 'bigint:string',
+		bigint: 'bigint:string',
+		'bigint:number': 'bigint:string',
+		'bigint:string': 'bigint:string',
+		numeric: 'numeric',
+		'numeric:number': 'numeric',
+		'numeric:bigint': 'numeric',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'bigint:string',
+		serial: 'bigint:string',
+		bigserial: 'bigint:string',
+		'bigserial:number': 'bigint:string',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	numeric: {
+		smallint: 'numeric',
+		int: 'numeric',
+		bigint: 'numeric',
+		'bigint:number': 'numeric',
+		'bigint:string': 'numeric',
+		numeric: 'numeric',
+		'numeric:number': 'numeric',
+		'numeric:bigint': 'numeric',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'numeric',
+		serial: 'numeric',
+		bigserial: 'numeric',
+		'bigserial:number': 'numeric',
+	},
+	'numeric:number': {
+		smallint: 'numeric:number',
+		int: 'numeric:number',
+		bigint: 'numeric:number',
+		'bigint:number': 'numeric:number',
+		'bigint:string': 'numeric:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'numeric:number',
+		serial: 'numeric:number',
+		bigserial: 'numeric:number',
+		'bigserial:number': 'numeric:number',
+	},
+	'numeric:bigint': {
+		smallint: 'numeric:bigint',
+		int: 'numeric:bigint',
+		bigint: 'numeric:bigint',
+		'bigint:number': 'numeric:bigint',
+		'bigint:string': 'numeric:bigint',
+		numeric: 'numeric:bigint',
+		'numeric:number': 'numeric:bigint',
+		'numeric:bigint': 'numeric:bigint',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'numeric:bigint',
+		serial: 'numeric:bigint',
+		bigserial: 'numeric:bigint',
+		'bigserial:number': 'numeric:bigint',
+	},
+	float4: {
+		smallint: 'float4',
+		int: 'float4',
+		bigint: 'float4',
+		'bigint:number': 'float4',
+		'bigint:string': 'float4',
+		numeric: 'float4',
+		'numeric:number': 'float4',
+		'numeric:bigint': 'float4',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'float4',
+		serial: 'float4',
+		bigserial: 'float4',
+		'bigserial:number': 'float4',
+	},
+	float8: {
+		smallint: 'float8',
+		int: 'float8',
+		bigint: 'float8',
+		'bigint:number': 'float8',
+		'bigint:string': 'float8',
+		numeric: 'float8',
+		'numeric:number': 'float8',
+		'numeric:bigint': 'float8',
+		float4: 'float8',
+		float8: 'float8',
+		smallserial: 'float8',
+		serial: 'float8',
+		bigserial: 'float8',
+		'bigserial:number': 'float8',
+	},
+	money: {
+		money: 'money',
+	},
+	smallserial: {
+		smallint: 'smallint',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'smallint',
+		serial: 'int',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	serial: {
+		smallint: 'int',
+		int: 'int',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'int',
+		serial: 'int',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	bigserial: {
+		smallint: 'bigint',
+		int: 'bigint',
+		bigint: 'bigint',
+		'bigint:number': 'bigint',
+		'bigint:string': 'bigint',
+		numeric: 'numeric:bigint',
+		'numeric:number': 'numeric:bigint',
+		'numeric:bigint': 'numeric:bigint',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'bigint',
+		serial: 'bigint',
+		bigserial: 'bigint',
+		'bigserial:number': 'bigint',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	'bigserial:number': {
+		smallint: 'bigint:number',
+		int: 'bigint:number',
+		bigint: 'bigint:number',
+		'bigint:number': 'bigint:number',
+		'bigint:string': 'bigint:number',
+		numeric: 'numeric:number',
+		'numeric:number': 'numeric:number',
+		'numeric:bigint': 'numeric:number',
+		float4: 'float4',
+		float8: 'float8',
+		smallserial: 'bigint:number',
+		serial: 'bigint:number',
+		bigserial: 'bigint:number',
+		'bigserial:number': 'bigint:number',
+		oid: 'oid',
+		regproc: 'regproc',
+		regprocedure: 'regprocedure',
+		regoper: 'regoper',
+		regoperator: 'regoperator',
+		regclass: 'regclass',
+		regtype: 'regtype',
+		regrole: 'regrole',
+		regnamespace: 'regnamespace',
+		regconfig: 'regconfig',
+		regdictionary: 'regdictionary',
+	},
+	char: {
+		char: 'char',
+		varchar: 'char',
+		text: 'char',
+	},
+	varchar: {
+		char: 'varchar',
+		varchar: 'varchar',
+		text: 'varchar',
+	},
+	text: {
+		char: 'text',
+		varchar: 'text',
+		text: 'text',
+	},
+	bytea: {
+		bytea: 'bytea',
+	},
+	date: {
+		date: 'date',
+		'date:string': 'date',
+		timestamp: 'timestamp',
+		'timestamp:string': 'timestamp',
+		timestamptz: 'timestamptz',
+		'timestamptz:string': 'timestamptz',
+	},
+	'date:string': {
+		date: 'date:string',
+		'date:string': 'date:string',
+		timestamp: 'timestamp:string',
+		'timestamp:string': 'timestamp:string',
+		timestamptz: 'timestamptz:string',
+		'timestamptz:string': 'timestamptz:string',
+	},
+	time: {
+		time: 'time',
+		timetz: 'timetz',
+	},
+	timetz: {
+		time: 'timetz',
+		timetz: 'timetz',
+	},
+	timestamp: {
+		date: 'timestamp',
+		'date:string': 'timestamp',
+		timestamp: 'timestamp',
+		'timestamp:string': 'timestamp',
+		timestamptz: 'timestamptz',
+		'timestamptz:string': 'timestamptz',
+	},
+	'timestamp:string': {
+		date: 'timestamp:string',
+		'date:string': 'timestamp:string',
+		timestamp: 'timestamp:string',
+		'timestamp:string': 'timestamp:string',
+		timestamptz: 'timestamptz:string',
+		'timestamptz:string': 'timestamptz:string',
+	},
+	timestamptz: {
+		date: 'timestamptz',
+		'date:string': 'timestamptz',
+		timestamp: 'timestamptz',
+		'timestamp:string': 'timestamptz',
+		timestamptz: 'timestamptz',
+		'timestamptz:string': 'timestamptz',
+	},
+	'timestamptz:string': {
+		date: 'timestamptz:string',
+		'date:string': 'timestamptz:string',
+		timestamp: 'timestamptz:string',
+		'timestamp:string': 'timestamptz:string',
+		timestamptz: 'timestamptz:string',
+		'timestamptz:string': 'timestamptz:string',
+	},
+	interval: {
+		interval: 'interval',
+		'interval:tuple': 'interval',
+	},
+	'interval:tuple': {
+		interval: 'interval:tuple',
+		'interval:tuple': 'interval:tuple',
+	},
+	bool: {
+		bool: 'bool',
+	},
+	enum: {
+		enum: 'enum',
+	},
+	point: {
+		point: 'point',
+		'point:tuple': 'point',
+	},
+	'point:tuple': {
+		point: 'point:tuple',
+		'point:tuple': 'point:tuple',
+	},
+	line: {
+		line: 'line',
+		'line:tuple': 'line',
+	},
+	'line:tuple': {
+		line: 'line:tuple',
+		'line:tuple': 'line:tuple',
+	},
+	lseg: {
+		lseg: 'lseg',
+	},
+	box: {
+		box: 'box',
+	},
+	path: {
+		path: 'path',
+	},
+	polygon: {
+		polygon: 'polygon',
+	},
+	circle: {
+		circle: 'circle',
+	},
+	cidr: {
+		cidr: 'cidr',
+		inet: 'inet',
+	},
+	inet: {
+		cidr: 'inet',
+		inet: 'inet',
+	},
+	macaddr: {
+		macaddr: 'macaddr',
+		macaddr8: 'macaddr',
+	},
+	macaddr8: {
+		macaddr: 'macaddr8',
+		macaddr8: 'macaddr8',
+	},
+	bit: {
+		bit: 'bit',
+		varbit: 'bit',
+	},
+	varbit: {
+		bit: 'varbit',
+		varbit: 'varbit',
+	},
+	tsvector: {
+		tsvector: 'tsvector',
+	},
+	tsquery: {
+		tsquery: 'tsquery',
+	},
+	uuid: {
+		uuid: 'uuid',
+	},
+	xml: {
+		xml: 'xml',
+	},
+	json: {
+		json: 'json',
+	},
+	jsonb: {
+		jsonb: 'jsonb',
+	},
+	int4range: {
+		int4range: 'int4range',
+	},
+	int8range: {
+		int8range: 'int8range',
+	},
+	numrange: {
+		numrange: 'numrange',
+	},
+	tsrange: {
+		tsrange: 'tsrange',
+	},
+	tstzrange: {
+		tstzrange: 'tstzrange',
+	},
+	daterange: {
+		daterange: 'daterange',
+	},
+	int4multirange: {
+		int4multirange: 'int4multirange',
+	},
+	int8multirange: {
+		int8multirange: 'int8multirange',
+	},
+	nummultirange: {
+		nummultirange: 'nummultirange',
+	},
+	tsmultirange: {
+		tsmultirange: 'tsmultirange',
+	},
+	tstzmultirange: {
+		tstzmultirange: 'tstzmultirange',
+	},
+	datemultirange: {
+		datemultirange: 'datemultirange',
+	},
+	oid: {
+		smallint: 'oid',
+		int: 'oid',
+		bigint: 'oid',
+		'bigint:number': 'oid',
+		'bigint:string': 'oid',
+		smallserial: 'oid',
+		serial: 'oid',
+		bigserial: 'oid',
+		'bigserial:number': 'oid',
+		oid: 'oid',
+		regproc: 'oid',
+		regprocedure: 'oid',
+		regoper: 'oid',
+		regoperator: 'oid',
+		regclass: 'oid',
+		regtype: 'oid',
+		regrole: 'oid',
+		regnamespace: 'oid',
+		regconfig: 'oid',
+		regdictionary: 'oid',
+	},
+	regproc: {
+		smallint: 'regproc',
+		int: 'regproc',
+		bigint: 'regproc',
+		'bigint:number': 'regproc',
+		'bigint:string': 'regproc',
+		smallserial: 'regproc',
+		serial: 'regproc',
+		bigserial: 'regproc',
+		'bigserial:number': 'regproc',
+		oid: 'regproc',
+		regproc: 'regproc',
+		regprocedure: 'regproc',
+	},
+	regprocedure: {
+		smallint: 'regprocedure',
+		int: 'regprocedure',
+		bigint: 'regprocedure',
+		'bigint:number': 'regprocedure',
+		'bigint:string': 'regprocedure',
+		smallserial: 'regprocedure',
+		serial: 'regprocedure',
+		bigserial: 'regprocedure',
+		'bigserial:number': 'regprocedure',
+		oid: 'regprocedure',
+		regproc: 'regprocedure',
+		regprocedure: 'regprocedure',
+	},
+	regoper: {
+		smallint: 'regoper',
+		int: 'regoper',
+		bigint: 'regoper',
+		'bigint:number': 'regoper',
+		'bigint:string': 'regoper',
+		smallserial: 'regoper',
+		serial: 'regoper',
+		bigserial: 'regoper',
+		'bigserial:number': 'regoper',
+		oid: 'regoper',
+		regoper: 'regoper',
+		regoperator: 'regoper',
+	},
+	regoperator: {
+		smallint: 'regoperator',
+		int: 'regoperator',
+		bigint: 'regoperator',
+		'bigint:number': 'regoperator',
+		'bigint:string': 'regoperator',
+		smallserial: 'regoperator',
+		serial: 'regoperator',
+		bigserial: 'regoperator',
+		'bigserial:number': 'regoperator',
+		oid: 'regoperator',
+		regoper: 'regoperator',
+		regoperator: 'regoperator',
+	},
+	regclass: {
+		smallint: 'regclass',
+		int: 'regclass',
+		bigint: 'regclass',
+		'bigint:number': 'regclass',
+		'bigint:string': 'regclass',
+		smallserial: 'regclass',
+		serial: 'regclass',
+		bigserial: 'regclass',
+		'bigserial:number': 'regclass',
+		oid: 'regclass',
+		regclass: 'regclass',
+	},
+	regtype: {
+		smallint: 'regtype',
+		int: 'regtype',
+		bigint: 'regtype',
+		'bigint:number': 'regtype',
+		'bigint:string': 'regtype',
+		smallserial: 'regtype',
+		serial: 'regtype',
+		bigserial: 'regtype',
+		'bigserial:number': 'regtype',
+		oid: 'regtype',
+		regtype: 'regtype',
+	},
+	regrole: {
+		smallint: 'regrole',
+		int: 'regrole',
+		bigint: 'regrole',
+		'bigint:number': 'regrole',
+		'bigint:string': 'regrole',
+		smallserial: 'regrole',
+		serial: 'regrole',
+		bigserial: 'regrole',
+		'bigserial:number': 'regrole',
+		oid: 'regrole',
+		regrole: 'regrole',
+	},
+	regnamespace: {
+		smallint: 'regnamespace',
+		int: 'regnamespace',
+		bigint: 'regnamespace',
+		'bigint:number': 'regnamespace',
+		'bigint:string': 'regnamespace',
+		smallserial: 'regnamespace',
+		serial: 'regnamespace',
+		bigserial: 'regnamespace',
+		'bigserial:number': 'regnamespace',
+		oid: 'regnamespace',
+		regnamespace: 'regnamespace',
+	},
+	regconfig: {
+		smallint: 'regconfig',
+		int: 'regconfig',
+		bigint: 'regconfig',
+		'bigint:number': 'regconfig',
+		'bigint:string': 'regconfig',
+		smallserial: 'regconfig',
+		serial: 'regconfig',
+		bigserial: 'regconfig',
+		'bigserial:number': 'regconfig',
+		oid: 'regconfig',
+		regconfig: 'regconfig',
+	},
+	regdictionary: {
+		smallint: 'regdictionary',
+		int: 'regdictionary',
+		bigint: 'regdictionary',
+		'bigint:number': 'regdictionary',
+		'bigint:string': 'regdictionary',
+		smallserial: 'regdictionary',
+		serial: 'regdictionary',
+		bigserial: 'regdictionary',
+		'bigserial:number': 'regdictionary',
+		oid: 'regdictionary',
+		regdictionary: 'regdictionary',
+	},
+} as const satisfies Partial<Record<PostgresColumnType, Partial<Record<PostgresColumnType, PostgresColumnType>>>>;
+
+export type PgCodecs = Codecs<PostgresType>;
+
+export const castToText: CastCodec = (name) => sql`${name}::text`;
+export const castToTextArr: CastArrayCodec = (name, arrayDimensions) =>
+	sql`${name}::text${sql.raw('[]'.repeat(arrayDimensions))}`;
+
+/** Used for cases when casting requires to unwrap and rebuild arrays
+ *
+ * @example
+ * string_mtx::text[][] // can be casted to array directly
+ *
+ * encode(bytea_mtx, 'base64')[][] // invalid syntax, cast requires unwrapping and rebuilding array
+ */
+export const arrayCompatCast = (cast: CastCodec) =>
+(
+	name: SQLChunk,
+	arrayDimensions: number | undefined,
+): SQLChunk => {
+	if (!arrayDimensions) return cast(name);
+
+	const aliases: Name[] = [];
+	for (let i = 0; i < arrayDimensions; i++) {
+		aliases.push(sql.identifier(`s${i}`));
+	}
+
+	let indexed = name;
+	for (const alias of aliases) {
+		indexed = sql`${indexed}[${alias}]`;
+	}
+
+	let expression = sql`array(\
+select ${cast(indexed)} \
+from generate_subscripts(${name}, ${sql.raw(arrayDimensions.toString())}) ${aliases[arrayDimensions - 1]} \
+order by ${aliases[arrayDimensions - 1]})`;
+
+	for (let dim = arrayDimensions - 1; dim > 0; dim--) {
+		expression = sql`array(\
+select ${expression} \
+from generate_subscripts(${name}, ${sql.raw(dim.toString())}) ${aliases[dim - 1]} \
+order by ${aliases[dim - 1]})`;
+	}
+
+	// Otherwise null returns as []
+	return sql`case when ${name} is null then null else ${expression} end`;
+};
+
+/** Used to recursively apply value normalizer to array of unknown dimensions */
+export const arrayCompatNormalize = (normalize: NormalizeCodec) => {
+	const loop: NormalizeArrayCodec = (value, arrayDimensions) => {
+		const innerDimensions = arrayDimensions - 1;
+		if (arrayDimensions > 1) {
+			for (let i = 0; i < (value as unknown[][]).length; ++i) {
+				loop((value as unknown[][])[i]!, innerDimensions);
+			}
+		} else {
+			for (let i = 0; i < (value as unknown[][]).length; ++i) {
+				value[i] = normalize((value as unknown[][])[i]!);
+			}
+		}
+
+		return value;
+	};
+
+	return loop;
+};
+
+/** Doesn't mutate original data - used for insertions */
+export const arrayCompatNormalizeInput = (normalize: NormalizeCodec, transformToPgArray = false) => {
+	const loop: NormalizeArrayCodec = (value, arrayDimensions): any => {
+		const innerDimensions = arrayDimensions - 1;
+		const out = Array.from({ length: value.length });
+		if (arrayDimensions > 1) {
+			for (let i = 0; i < (value as unknown[][]).length; ++i) {
+				out[i] = loop((value as unknown[][])[i]!, innerDimensions);
+			}
+		} else {
+			for (let i = 0; i < (value as unknown[][]).length; ++i) {
+				out[i] = normalize((value as unknown[][])[i]!);
+			}
+		}
+
+		return out;
+	};
+
+	return transformToPgArray ? (v: any, d: number) => makePgArray(loop(v, d)) : loop;
+};
+
+/** Parses a raw PG array text representation, then applies a per-item normalizer */
+export const parsePgArrayAndNormalize = (normalize: NormalizeCodec): NormalizeArrayCodec => {
+	const codec = arrayCompatNormalize(normalize);
+	return (value, arrayDimensions) => codec(parsePgArray(value), arrayDimensions);
+};
+
+export const parseLineTuple = (v: string): [number, number, number] => {
+	const [a, b, c] = v.slice(1, -1).split(',');
+	return [Number.parseFloat(a!), Number.parseFloat(b!), Number.parseFloat(c!)];
+};
+
+export const parseLineABC = (v: string): { a: number; b: number; c: number } => {
+	const [a, b, c] = v.slice(1, -1).split(',');
+	return { a: Number.parseFloat(a!), b: Number.parseFloat(b!), c: Number.parseFloat(c!) };
+};
+
+export const parsePointTuple = (v: string): [number, number] => {
+	const [x, y] = v.slice(1, -1).split(',');
+	return [Number.parseFloat(x!), Number.parseFloat(y!)];
+};
+
+export const parsePointXY = (v: string): { x: number; y: number } => {
+	const [x, y] = v.slice(1, -1).split(',');
+	return { x: Number.parseFloat(x!), y: Number.parseFloat(y!) };
+};
+
+export const parseGeometryTuple = (v: string): [number, number] => parseEWKB(v).point;
+
+export const parseGeometryXY = (v: string): { x: number; y: number } => {
+	const parsed = parseEWKB(v);
+	return { x: parsed.point[0], y: parsed.point[1] };
+};
+
+export const textToDate = (v: string): Date => new Date(v);
+export const textToDateWithTz = (v: string): Date => new Date(v + '+0000');
+
+export const parsePgVector = (v: string): number[] => {
+	const body = v.slice(1, -1);
+	if (body.length === 0) return [];
+	return body.split(',').map(Number.parseFloat);
+};
+
+export const genericPgCodecs = {
+	bytea: {
+		castInJson: (name) => sql`encode(${name}, 'base64')`,
+		castArrayInJson: arrayCompatCast((name) => sql`encode(${name}, 'base64')`),
+		normalizeInJson: (v: string) => Buffer.from(v, 'base64'),
+		normalizeArrayInJson: arrayCompatNormalize((v: string) => Buffer.from(v, 'base64')),
+	},
+	bigint: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalizeInJson: BigInt,
+		normalizeArrayInJson: arrayCompatNormalize(BigInt),
+	},
+	'bigint:number': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeInJson: Number,
+		normalizeArrayInJson: arrayCompatNormalize(Number),
+	},
+	'bigint:string': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+	},
+	bigserial: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalizeInJson: BigInt,
+		normalizeArrayInJson: arrayCompatNormalize(BigInt),
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	'bigserial:number': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeInJson: Number,
+		normalizeArrayInJson: arrayCompatNormalize(Number),
+	},
+	date: {
+		normalizeInJson: textToDate,
+		normalizeArrayInJson: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {},
+	enum: {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point)': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parseGeometryXY,
+		normalizeArray: arrayCompatNormalize(parseGeometryXY),
+		normalizeInJson: parseGeometryXY,
+		normalizeArrayInJson: arrayCompatNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parseGeometryTuple,
+		normalizeArray: arrayCompatNormalize(parseGeometryTuple),
+		normalizeInJson: parseGeometryTuple,
+		normalizeArrayInJson: arrayCompatNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArrayInJson: castToTextArr,
+	},
+	json: {
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	line: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parseLineABC,
+		normalizeArray: arrayCompatNormalize(parseLineABC),
+		normalizeInJson: parseLineABC,
+		normalizeArrayInJson: arrayCompatNormalize(parseLineABC),
+	},
+	'line:tuple': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parseLineTuple,
+		normalizeArray: arrayCompatNormalize(parseLineTuple),
+		normalizeInJson: parseLineTuple,
+		normalizeArrayInJson: arrayCompatNormalize(parseLineTuple),
+	},
+	numeric: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	'numeric:number': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		normalize: Number,
+		normalizeArray: arrayCompatNormalize(Number),
+		normalizeInJson: Number,
+		normalizeArrayInJson: arrayCompatNormalize(Number),
+	},
+	'numeric:bigint': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeInJson: BigInt,
+		normalizeArrayInJson: arrayCompatNormalize(BigInt),
+	},
+	point: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parsePointXY,
+		normalizeArray: arrayCompatNormalize(parsePointXY),
+		normalizeInJson: parsePointXY,
+		normalizeArrayInJson: arrayCompatNormalize(parsePointXY),
+	},
+	'point:tuple': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalize: parsePointTuple,
+		normalizeArray: arrayCompatNormalize(parsePointTuple),
+		normalizeInJson: parsePointTuple,
+		normalizeArrayInJson: arrayCompatNormalize(parsePointTuple),
+	},
+	timestamp: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalizeInJson: textToDateWithTz,
+		normalizeArrayInJson: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+		normalizeInJson: textToDate,
+		normalizeArrayInJson: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+	},
+	'timestamptz:string': {
+		castInJson: castToText,
+		castArrayInJson: castToTextArr,
+	},
+	halfvec: {
+		normalize: parsePgVector,
+		normalizeArray: parsePgArrayAndNormalize(parsePgVector),
+		normalizeInJson: parsePgVector,
+		normalizeArrayInJson: arrayCompatNormalize(parsePgVector),
+	},
+	vector: {
+		normalize: parsePgVector,
+		normalizeArray: parsePgArrayAndNormalize(parsePgVector),
+		normalizeInJson: parsePgVector,
+		normalizeArrayInJson: arrayCompatNormalize(parsePgVector),
+	},
+} as const satisfies PgCodecs;
+
+export const refineGenericPgCodecs = (extension?: PartialWithUndefined<PgCodecs>): PgCodecs =>
+	refineCodecs<PostgresType>(genericPgCodecs, extension);
diff --git a/drizzle-orm/src/pg-core/columns/bigint.ts b/drizzle-orm/src/pg-core/columns/bigint.ts
index 17ac0798b8..1028f9d751 100644
--- a/drizzle-orm/src/pg-core/columns/bigint.ts
+++ b/drizzle-orm/src/pg-core/columns/bigint.ts
@@ -1,110 +1,111 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn } from './common.ts';
-import { PgIntColumnBaseBuilder } from './int.common.ts';
+import { PgIntColumnBuilder } from './int.common.ts';
 
-export type PgBigInt53BuilderInitial<TName extends string> = PgBigInt53Builder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgBigInt53';
+export class PgBigInt53Builder extends PgIntColumnBuilder<{
+	dataType: 'number int53';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class PgBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigInt53'>>
-	extends PgIntColumnBaseBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgBigInt53Builder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgBigInt53');
+	constructor(name: string) {
+		super(name, 'number int53', 'PgBigInt53');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBigInt53<MakeColumnConfig<T, TTableName>> {
-		return new PgBigInt53<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgBigInt53(table, this.config as any);
 	}
 }
 
-export class PgBigInt53<T extends ColumnBaseConfig<'number', 'PgBigInt53'>> extends PgColumn<T> {
+export class PgBigInt53 extends PgColumn<'number int53'> {
 	static override readonly [entityKind]: string = 'PgBigInt53';
 
+	/** @internal */
+	override readonly codec = 'bigint:number';
+
 	getSQLType(): string {
 		return 'bigint';
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'number') {
-			return value;
-		}
-		return Number(value);
-	}
 }
 
-export type PgBigInt64BuilderInitial<TName extends string> = PgBigInt64Builder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'PgBigInt64';
+export class PgBigInt64Builder extends PgIntColumnBuilder<{
+	dataType: 'bigint int64';
 	data: bigint;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigInt64'>>
-	extends PgIntColumnBaseBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgBigInt64Builder';
 
-	constructor(name: T['name']) {
-		super(name, 'bigint', 'PgBigInt64');
+	constructor(name: string) {
+		super(name, 'bigint int64', 'PgBigInt64');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBigInt64<MakeColumnConfig<T, TTableName>> {
-		return new PgBigInt64<MakeColumnConfig<T, TTableName>>(
-			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-		);
+	override build(table: PgTable<any>) {
+		return new PgBigInt64(table, this.config as any);
 	}
 }
 
-export class PgBigInt64<T extends ColumnBaseConfig<'bigint', 'PgBigInt64'>> extends PgColumn<T> {
+export class PgBigInt64 extends PgColumn<'bigint int64'> {
 	static override readonly [entityKind]: string = 'PgBigInt64';
 
+	/** @internal */
+	override readonly codec = 'bigint';
+
 	getSQLType(): string {
 		return 'bigint';
 	}
+}
 
-	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
-	override mapFromDriverValue(value: string): bigint {
-		return BigInt(value);
+export class PgBigIntStringBuilder extends PgIntColumnBuilder<{
+	dataType: 'string int64';
+	data: string;
+	driverParam: string;
+}> {
+	static override readonly [entityKind]: string = 'PgBigIntStringBuilder';
+
+	constructor(name: string) {
+		super(name, 'string int64', 'PgBigIntString');
+	}
+
+	/** @internal */
+	override build(table: PgTable<any>) {
+		return new PgBigIntString(table, this.config as any);
+	}
+}
+
+export class PgBigIntString extends PgColumn<'string int64'> {
+	static override readonly [entityKind]: string = 'PgBigIntString';
+
+	/** @internal */
+	override readonly codec = 'bigint:string';
+
+	getSQLType(): string {
+		return 'bigint';
 	}
 }
 
-export interface PgBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+export interface PgBigIntConfig<T extends 'number' | 'bigint' | 'string' = 'number' | 'bigint' | 'string'> {
 	mode: T;
 }
 
 export function bigint<TMode extends PgBigIntConfig['mode']>(
 	config: PgBigIntConfig<TMode>,
-): TMode extends 'number' ? PgBigInt53BuilderInitial<''> : PgBigInt64BuilderInitial<''>;
-export function bigint<TName extends string, TMode extends PgBigIntConfig['mode']>(
-	name: TName,
+): TMode extends 'string' ? PgBigIntStringBuilder : TMode extends 'bigint' ? PgBigInt64Builder : PgBigInt53Builder;
+export function bigint<TMode extends PgBigIntConfig['mode']>(
+	name: string,
 	config: PgBigIntConfig<TMode>,
-): TMode extends 'number' ? PgBigInt53BuilderInitial<TName> : PgBigInt64BuilderInitial<TName>;
+): TMode extends 'string' ? PgBigIntStringBuilder : TMode extends 'bigint' ? PgBigInt64Builder : PgBigInt53Builder;
 export function bigint(a: string | PgBigIntConfig, b?: PgBigIntConfig) {
 	const { name, config } = getColumnNameAndConfig<PgBigIntConfig>(a, b);
 	if (config.mode === 'number') {
 		return new PgBigInt53Builder(name);
 	}
+	if (config.mode === 'string') {
+		return new PgBigIntStringBuilder(name);
+	}
 	return new PgBigInt64Builder(name);
 }
diff --git a/drizzle-orm/src/pg-core/columns/bigserial.ts b/drizzle-orm/src/pg-core/columns/bigserial.ts
index 0aa7e7a7fe..f3593de5ae 100644
--- a/drizzle-orm/src/pg-core/columns/bigserial.ts
+++ b/drizzle-orm/src/pg-core/columns/bigserial.ts
@@ -1,111 +1,76 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	HasDefault,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgBigSerial53BuilderInitial<TName extends string> = NotNull<
-	HasDefault<
-		PgBigSerial53Builder<{
-			name: TName;
-			dataType: 'number';
-			columnType: 'PgBigSerial53';
-			data: number;
-			driverParam: number;
-			enumValues: undefined;
-		}>
-	>
->;
-
-export class PgBigSerial53Builder<T extends ColumnBuilderBaseConfig<'number', 'PgBigSerial53'>>
-	extends PgColumnBuilder<T>
-{
+export class PgBigSerial53Builder extends PgColumnBuilder<{
+	dataType: 'number int53';
+	data: number;
+	driverParam: number;
+	notNull: true;
+	hasDefault: true;
+}> {
 	static override readonly [entityKind]: string = 'PgBigSerial53Builder';
 
 	constructor(name: string) {
-		super(name, 'number', 'PgBigSerial53');
+		super(name, 'number int53', 'PgBigSerial53');
 		this.config.hasDefault = true;
 		this.config.notNull = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBigSerial53<MakeColumnConfig<T, TTableName>> {
-		return new PgBigSerial53<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgBigSerial53(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgBigSerial53<T extends ColumnBaseConfig<'number', 'PgBigSerial53'>> extends PgColumn<T> {
+export class PgBigSerial53 extends PgColumn<'number int53'> {
 	static override readonly [entityKind]: string = 'PgBigSerial53';
 
+	/** @internal */
+	override readonly codec = 'bigserial:number';
+
 	getSQLType(): string {
 		return 'bigserial';
 	}
-
-	override mapFromDriverValue(value: number): number {
-		if (typeof value === 'number') {
-			return value;
-		}
-		return Number(value);
-	}
 }
 
-export type PgBigSerial64BuilderInitial<TName extends string> = NotNull<
-	HasDefault<
-		PgBigSerial64Builder<{
-			name: TName;
-			dataType: 'bigint';
-			columnType: 'PgBigSerial64';
-			data: bigint;
-			driverParam: string;
-			enumValues: undefined;
-		}>
-	>
->;
-
-export class PgBigSerial64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'PgBigSerial64'>>
-	extends PgColumnBuilder<T>
-{
+export class PgBigSerial64Builder extends PgColumnBuilder<{
+	dataType: 'bigint int64';
+	data: bigint;
+	driverParam: string;
+	notNull: true;
+	hasDefault: true;
+}> {
 	static override readonly [entityKind]: string = 'PgBigSerial64Builder';
 
 	constructor(name: string) {
-		super(name, 'bigint', 'PgBigSerial64');
+		super(name, 'bigint int64', 'PgBigSerial64');
 		this.config.hasDefault = true;
+		this.config.notNull = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBigSerial64<MakeColumnConfig<T, TTableName>> {
-		return new PgBigSerial64<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgBigSerial64(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgBigSerial64<T extends ColumnBaseConfig<'bigint', 'PgBigSerial64'>> extends PgColumn<T> {
+export class PgBigSerial64 extends PgColumn<'bigint int64'> {
 	static override readonly [entityKind]: string = 'PgBigSerial64';
 
+	/** @internal */
+	override readonly codec = 'bigserial';
+
 	getSQLType(): string {
 		return 'bigserial';
 	}
-
-	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
-	override mapFromDriverValue(value: string): bigint {
-		return BigInt(value);
-	}
 }
 
 export interface PgBigSerialConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
@@ -114,11 +79,11 @@ export interface PgBigSerialConfig<T extends 'number' | 'bigint' = 'number' | 'b
 
 export function bigserial<TMode extends PgBigSerialConfig['mode']>(
 	config: PgBigSerialConfig<TMode>,
-): TMode extends 'number' ? PgBigSerial53BuilderInitial<''> : PgBigSerial64BuilderInitial<''>;
-export function bigserial<TName extends string, TMode extends PgBigSerialConfig['mode']>(
-	name: TName,
+): TMode extends 'number' ? PgBigSerial53Builder : PgBigSerial64Builder;
+export function bigserial<TMode extends PgBigSerialConfig['mode']>(
+	name: string,
 	config: PgBigSerialConfig<TMode>,
-): TMode extends 'number' ? PgBigSerial53BuilderInitial<TName> : PgBigSerial64BuilderInitial<TName>;
+): TMode extends 'number' ? PgBigSerial53Builder : PgBigSerial64Builder;
 export function bigserial(a: string | PgBigSerialConfig, b?: PgBigSerialConfig) {
 	const { name, config } = getColumnNameAndConfig<PgBigSerialConfig>(a, b);
 	if (config.mode === 'number') {
diff --git a/drizzle-orm/src/pg-core/columns/boolean.ts b/drizzle-orm/src/pg-core/columns/boolean.ts
index e2d514864f..d55398a87a 100644
--- a/drizzle-orm/src/pg-core/columns/boolean.ts
+++ b/drizzle-orm/src/pg-core/columns/boolean.ts
@@ -1,43 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgBooleanBuilderInitial<TName extends string> = PgBooleanBuilder<{
-	name: TName;
+export class PgBooleanBuilder extends PgColumnBuilder<{
 	dataType: 'boolean';
-	columnType: 'PgBoolean';
 	data: boolean;
 	driverParam: boolean;
-	enumValues: undefined;
-}>;
-
-export class PgBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'PgBoolean'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgBooleanBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: string) {
 		super(name, 'boolean', 'PgBoolean');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBoolean<MakeColumnConfig<T, TTableName>> {
-		return new PgBoolean<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgBoolean(table, this.config as any);
 	}
 }
 
-export class PgBoolean<T extends ColumnBaseConfig<'boolean', 'PgBoolean'>> extends PgColumn<T> {
+export class PgBoolean extends PgColumn<'boolean'> {
 	static override readonly [entityKind]: string = 'PgBoolean';
 
+	/** @internal */
+	override readonly codec = 'bool';
+
 	getSQLType(): string {
 		return 'boolean';
 	}
 }
 
-export function boolean(): PgBooleanBuilderInitial<''>;
-export function boolean<TName extends string>(name: TName): PgBooleanBuilderInitial<TName>;
-export function boolean(name?: string) {
+export function boolean(name?: string): PgBooleanBuilder {
 	return new PgBooleanBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/bytea.ts b/drizzle-orm/src/pg-core/columns/bytea.ts
new file mode 100644
index 0000000000..cf2bc6678e
--- /dev/null
+++ b/drizzle-orm/src/pg-core/columns/bytea.ts
@@ -0,0 +1,35 @@
+import { entityKind } from '~/entity.ts';
+import type { PgTable } from '../table.ts';
+import { PgColumn, PgColumnBuilder } from './common.ts';
+
+export class PgByteaBuilder extends PgColumnBuilder<{
+	dataType: 'object buffer';
+	data: Buffer;
+	driverParam: Buffer;
+}> {
+	static override readonly [entityKind]: string = 'PgByteaBuilder';
+
+	constructor(name: string) {
+		super(name, 'object buffer', 'PgBytea');
+	}
+
+	/** @internal */
+	override build(table: PgTable<any>) {
+		return new PgBytea(table, this.config as any);
+	}
+}
+
+export class PgBytea extends PgColumn<'object buffer'> {
+	static override readonly [entityKind]: string = 'PgBytea';
+
+	/** @internal */
+	override readonly codec = 'bytea';
+
+	getSQLType(): string {
+		return 'bytea';
+	}
+}
+
+export function bytea(name?: string): PgByteaBuilder {
+	return new PgByteaBuilder(name ?? '');
+}
diff --git a/drizzle-orm/src/pg-core/columns/char.ts b/drizzle-orm/src/pg-core/columns/char.ts
index e362e2f426..93532085c0 100644
--- a/drizzle-orm/src/pg-core/columns/char.ts
+++ b/drizzle-orm/src/pg-core/columns/char.ts
@@ -1,84 +1,74 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgCharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = PgCharBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgChar';
-	data: TEnum[number];
-	enumValues: TEnum;
-	driverParam: string;
-	length: TLength;
-}>;
+type PgCharBuilderConfig<TEnum extends [string, ...string[]]> = Equal<TEnum, [string, ...string[]]> extends true
+	? { dataType: 'string'; data: string; driverParam: string }
+	: { dataType: 'string enum'; data: TEnum[number]; enumValues: TEnum; driverParam: string };
 
-export class PgCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgChar'> & { length?: number | undefined }>
-	extends PgColumnBuilder<
-		T,
-		{ length: T['length']; enumValues: T['enumValues'] },
-		{ length: T['length'] }
-	>
-{
+export class PgCharBuilder<TEnum extends [string, ...string[]] = [string, ...string[]]> extends PgColumnBuilder<
+	PgCharBuilderConfig<TEnum>,
+	{ enumValues: TEnum; length: number; setLength: boolean }
+> {
 	static override readonly [entityKind]: string = 'PgCharBuilder';
 
-	constructor(name: T['name'], config: PgCharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'PgChar');
-		this.config.length = config.length;
-		this.config.enumValues = config.enum;
+	constructor(name: string, config: PgCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'PgChar');
+		this.config.length = config.length ?? 1;
+		this.config.setLength = config.length !== undefined;
+		this.config.enumValues = config.enum as TEnum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgChar<MakeColumnConfig<T, TTableName> & { length: T['length'] }> {
-		return new PgChar<MakeColumnConfig<T, TTableName> & { length: T['length'] }>(
+	override build(table: PgTable<any>) {
+		return new PgChar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgChar<T extends ColumnBaseConfig<'string', 'PgChar'> & { length?: number | undefined }>
-	extends PgColumn<T, { length: T['length']; enumValues: T['enumValues'] }, { length: T['length'] }>
+export class PgChar<TEnum extends [string, ...string[]] = [string, ...string[]]>
+	extends PgColumn<Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum'>
 {
 	static override readonly [entityKind]: string = 'PgChar';
 
-	readonly length = this.config.length;
-	override readonly enumValues = this.config.enumValues;
+	/** @internal */
+	override readonly codec = 'char';
+
+	override readonly enumValues: TEnum;
+	private readonly setLength: boolean;
+
+	constructor(table: PgTable<any>, config: PgCharBuilder<TEnum>['config']) {
+		super(table, config as any);
+		this.enumValues = config.enumValues;
+		this.setLength = config.setLength;
+	}
 
 	getSQLType(): string {
-		return this.length === undefined ? `char` : `char(${this.length})`;
+		return this.setLength ? `char(${this.length})` : `char`;
 	}
 }
 
 export interface PgCharConfig<
 	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length?: TLength;
+	length?: number;
 }
 
-export function char(): PgCharBuilderInitial<'', [string, ...string[]], undefined>;
-export function char<U extends string, T extends Readonly<[U, ...U[]]>, L extends number | undefined>(
-	config?: PgCharConfig<T | Writable<T>, L>,
-): PgCharBuilderInitial<'', Writable<T>, L>;
-export function char<
-	TName extends string,
-	U extends string,
-	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
->(
-	name: TName,
-	config?: PgCharConfig<T | Writable<T>, L>,
-): PgCharBuilderInitial<TName, Writable<T>, L>;
+export function char(): PgCharBuilder;
+export function char(name: string): PgCharBuilder;
+export function char(config: { length?: number }): PgCharBuilder;
+export function char(name: string, config: { length?: number }): PgCharBuilder;
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config: PgCharConfig<T | Writable<T>> & { enum: T | Writable<T> },
+): PgCharBuilder<Writable<T>>;
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config: PgCharConfig<T | Writable<T>> & { enum: T | Writable<T> },
+): PgCharBuilder<Writable<T>>;
 export function char(a?: string | PgCharConfig, b: PgCharConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<PgCharConfig>(a, b);
 	return new PgCharBuilder(name, config as any);
diff --git a/drizzle-orm/src/pg-core/columns/cidr.ts b/drizzle-orm/src/pg-core/columns/cidr.ts
index ab97536ee3..fb60a95a40 100644
--- a/drizzle-orm/src/pg-core/columns/cidr.ts
+++ b/drizzle-orm/src/pg-core/columns/cidr.ts
@@ -1,43 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgCidrBuilderInitial<TName extends string> = PgCidrBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgCidr';
+export class PgCidrBuilder extends PgColumnBuilder<{
+	dataType: 'string cidr';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgCidrBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgCidr'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgCidrBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgCidr');
+	constructor(name: string) {
+		super(name, 'string cidr', 'PgCidr');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgCidr<MakeColumnConfig<T, TTableName>> {
-		return new PgCidr<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgCidr(table, this.config as any);
 	}
 }
 
-export class PgCidr<T extends ColumnBaseConfig<'string', 'PgCidr'>> extends PgColumn<T> {
+export class PgCidr extends PgColumn<'string cidr'> {
 	static override readonly [entityKind]: string = 'PgCidr';
 
+	/** @internal */
+	override readonly codec = 'cidr';
+
 	getSQLType(): string {
 		return 'cidr';
 	}
 }
 
-export function cidr(): PgCidrBuilderInitial<''>;
-export function cidr<TName extends string>(name: TName): PgCidrBuilderInitial<TName>;
-export function cidr(name?: string) {
+export function cidr(name?: string): PgCidrBuilder {
 	return new PgCidrBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/common.ts b/drizzle-orm/src/pg-core/columns/common.ts
index aa1d6c1f23..4079c5de28 100644
--- a/drizzle-orm/src/pg-core/columns/common.ts
+++ b/drizzle-orm/src/pg-core/columns/common.ts
@@ -1,75 +1,350 @@
-import type {
-	ColumnBuilderBase,
-	ColumnBuilderBaseConfig,
-	ColumnBuilderExtraConfig,
-	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
-	HasGenerated,
-	MakeColumnConfig,
-} from '~/column-builder.ts';
-import { ColumnBuilder } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
+import type { ColumnType, GeneratedColumnConfig, GeneratedIdentityConfig } from '~/column-builder.ts';
 import { Column } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
-import type { Simplify, Update } from '~/utils.ts';
-
+import { entityKind } from '~/entity.ts';
 import type { ForeignKey, UpdateDeleteAction } from '~/pg-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/pg-core/foreign-keys.ts';
 import type { AnyPgTable, PgTable } from '~/pg-core/table.ts';
 import type { SQL } from '~/sql/sql.ts';
 import { iife } from '~/tracing-utils.ts';
+import type { Update } from '~/utils.ts';
+import type { PostgresType } from '../codecs.ts';
 import type { PgIndexOpClass } from '../indexes.ts';
-import { uniqueKeyName } from '../unique-constraint.ts';
-import { makePgArray, parsePgArray } from '../utils/array.ts';
+
+export type PgArrayDimension = 0 | 1 | 2 | 3 | 4 | 5;
+type PgArrayDimensionString = '[]' | '[][]' | '[][][]' | '[][][][]' | '[][][][][]';
+
+type ArrayDimensionStringToNumber<T extends PgArrayDimensionString> = T extends '[]' ? 1
+	: T extends '[][]' ? 2
+	: T extends '[][][]' ? 3
+	: T extends '[][][][]' ? 4
+	: T extends '[][][][][]' ? 5
+	: never;
+
+export interface PgColumnBuilderConfig {
+	dataType: ColumnType;
+	data: unknown;
+	driverParam: unknown;
+	// Optional - set via chain methods
+	notNull?: boolean;
+	hasDefault?: boolean;
+	isPrimaryKey?: boolean;
+	isAutoincrement?: boolean;
+	hasRuntimeDefault?: boolean;
+	enumValues?: string[];
+	identity?: 'always' | 'byDefault';
+	generated?: unknown;
+	dimensions?: PgArrayDimension;
+	$type?: unknown;
+}
+
+export interface PgColumnBuilderRuntimeConfig<TData> {
+	name: string;
+	keyAsName: boolean;
+	notNull: boolean;
+	default: TData | SQL | undefined;
+	defaultFn: (() => TData | SQL) | undefined;
+	onUpdateFn: (() => TData | SQL) | undefined;
+	hasDefault: boolean;
+	primaryKey: boolean;
+	isUnique: boolean;
+	uniqueName: string | undefined;
+	uniqueType: string | undefined;
+	dataType: string;
+	columnType: string;
+	generated: GeneratedColumnConfig<TData> | undefined;
+	generatedIdentity: GeneratedIdentityConfig | undefined;
+	dimensions?: PgArrayDimension;
+}
+
+// TODO: remove isAutoincrement and hasRuntimeDefault
+export interface PgColumnBaseConfig<out TDataType extends ColumnType = ColumnType> {
+	name: string;
+	dataType: TDataType;
+	tableName: string;
+	notNull: boolean;
+	hasDefault: boolean;
+	isPrimaryKey: boolean;
+	isAutoincrement: boolean;
+	hasRuntimeDefault: boolean;
+	data: unknown;
+	driverParam: unknown;
+	enumValues: string[] | undefined;
+	generated: unknown;
+	identity: undefined | 'always' | 'byDefault';
+}
+
+type WrapArray<T, N extends number> = N extends 1 ? T[]
+	: N extends 2 ? T[][]
+	: N extends 3 ? T[][][]
+	: N extends 4 ? T[][][][]
+	: N extends 5 ? T[][][][][]
+	: T;
+
+export type SetNotNull<T> = T & { readonly _: { notNull: true } };
+export type SetHasDefault<T> = T & { readonly _: { hasDefault: true } };
+export type SetIsPrimaryKey<T> = T & { readonly _: { isPrimaryKey: true; notNull: true } };
+export type SetHasRuntimeDefault<T> = T & {
+	readonly _: { hasRuntimeDefault: true; hasDefault: true };
+};
+export type Set$Type<T, TType> = T & { readonly _: { $type: TType } };
+export type SetHasGenerated<T> = T & {
+	readonly _: { hasDefault: true; generated: true };
+};
+export type SetDimensions<T, TDim extends PgArrayDimension> = T & {
+	readonly _: { dimensions: TDim };
+};
+export type SetIdentity<T, TType extends 'always' | 'byDefault'> = T & {
+	readonly _: { notNull: true; hasDefault: true; identity: TType };
+};
+
+export type HasIdentity<T, TType extends 'always' | 'byDefault'> = SetIdentity<T, TType>;
+
+type GetBaseData<T> = T extends { $type: infer U } ? U : T extends { data: infer D } ? D : unknown;
+
+export type ResolvePgColumnConfig<
+	out T extends PgColumnBuilderConfig,
+	out TTableName extends string,
+	out TData = T['dimensions'] extends 1 | 2 | 3 | 4 | 5 ? WrapArray<GetBaseData<T>, T['dimensions']>
+		: GetBaseData<T>,
+> = {
+	name: string;
+	tableName: TTableName;
+	dataType: T['dataType'];
+	data: TData;
+	driverParam: T['dimensions'] extends 1 | 2 | 3 | 4 | 5 ? WrapArray<T['driverParam'], T['dimensions']> | string
+		: T['driverParam'];
+	notNull: T['notNull'] extends true ? true : false;
+	hasDefault: T['hasDefault'] extends true ? true : false;
+	isPrimaryKey: false;
+	isAutoincrement: false;
+	hasRuntimeDefault: false;
+	enumValues: T extends { enumValues: infer E extends string[] } ? E : undefined;
+	identity: T['identity'] extends 'always' | 'byDefault' ? T['identity'] : undefined;
+	generated: T['generated'] extends true ? true : undefined;
+} & {};
+
+export interface AnyPgColumnBuilder {
+	readonly _: PgColumnBuilderConfig;
+}
+
+export type PgBuildColumn<
+	TTableName extends string,
+	TBuilder extends AnyPgColumnBuilder,
+	TBuiltConfig extends PgColumnBaseConfig<ColumnType> = ResolvePgColumnConfig<
+		TBuilder['_'],
+		TTableName
+	>,
+> = PgColumn<ColumnType, TBuiltConfig, {}>;
+
+export type PgBuildColumns<
+	out TTableName extends string,
+	out TConfigMap extends Record<string, AnyPgColumnBuilder>,
+> =
+	& {
+		[Key in keyof TConfigMap]: PgBuildColumn<TTableName, TConfigMap[Key]>;
+	}
+	& {};
+
+export type PgBuildExtraConfigColumns<
+	out TConfigMap extends Record<string, AnyPgColumnBuilder>,
+> =
+	& {
+		[Key in keyof TConfigMap]: ExtraConfigColumn;
+	}
+	& {};
+
+export type PgColumns = Record<string, PgColumn>;
 
 export interface ReferenceConfig {
 	ref: () => PgColumn;
-	actions: {
+	config: {
+		name?: string;
 		onUpdate?: UpdateDeleteAction;
 		onDelete?: UpdateDeleteAction;
 	};
 }
 
-export interface PgColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'pg' }> {}
-
 export abstract class PgColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
-	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'pg' }, TExtraConfig>
-	implements PgColumnBuilderBase<T, TTypeConfig>
-{
+	out T extends PgColumnBuilderConfig = PgColumnBuilderConfig,
+	out TRuntimeConfig extends object = object,
+> {
+	static readonly [entityKind]: string = 'PgColumnBuilder';
+
+	declare readonly _: T;
+
 	private foreignKeyConfigs: ReferenceConfig[] = [];
 
-	static override readonly [entityKind]: string = 'PgColumnBuilder';
-
-	array<TSize extends number | undefined = undefined>(size?: TSize): PgArrayBuilder<
-		& {
-			name: T['name'];
-			dataType: 'array';
-			columnType: 'PgArray';
-			data: T['data'][];
-			driverParam: T['driverParam'][] | string;
-			enumValues: T['enumValues'];
-			size: TSize;
-			baseBuilder: T;
-		}
-		& (T extends { notNull: true } ? { notNull: true } : {})
-		& (T extends { hasDefault: true } ? { hasDefault: true } : {}),
-		T
-	> {
-		return new PgArrayBuilder(this.config.name, this as PgColumnBuilder<any, any>, size as any);
+	protected config: PgColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
+
+	constructor(name: string, dataType: ColumnType, columnType: string) {
+		this.config = {
+			name,
+			keyAsName: name === '',
+			notNull: false,
+			default: undefined,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: undefined,
+			uniqueType: undefined,
+			dataType,
+			columnType,
+			generated: undefined,
+			defaultFn: undefined,
+			onUpdateFn: undefined,
+			generatedIdentity: undefined,
+		} as PgColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
+	}
+
+	/**
+	 * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+	 *
+	 * @example
+	 * ```ts
+	 * const users = pgTable('users', {
+	 * 	id: integer('id').$type<UserId>().primaryKey(),
+	 * 	details: json('details').$type<UserDetails>().notNull(),
+	 * });
+	 * ```
+	 */
+	$type<TType>(): Set$Type<this, TType> {
+		return this as Set$Type<this, TType>;
+	}
+
+	/**
+	 * Adds a `not null` clause to the column definition.
+	 *
+	 * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+	 */
+	notNull(): SetNotNull<this> {
+		this.config.notNull = true;
+		return this as SetNotNull<this>;
+	}
+
+	/**
+	 * Adds a `default <value>` clause to the column definition.
+	 *
+	 * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+	 *
+	 * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+	 */
+	default(
+		value:
+			| (this['_'] extends { dimensions: 1 | 2 | 3 | 4 | 5 } ? WrapArray<
+					this['_'] extends { $type: infer U } ? U : this['_']['data'],
+					this['_']['dimensions']
+				>
+				: this['_'] extends { $type: infer U } ? U
+				: this['_']['data'])
+			| SQL,
+	): SetHasDefault<this> {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this as SetHasDefault<this>;
+	}
+
+	/**
+	 * Adds a dynamic default value to the column.
+	 * The function will be called when the row is inserted, and the returned value will be used as the column value.
+	 *
+	 * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	 */
+	$defaultFn(
+		fn: () =>
+			| (this['_'] extends { dimensions: 1 | 2 | 3 | 4 | 5 } ? WrapArray<
+					this['_'] extends { $type: infer U } ? U : this['_']['data'],
+					this['_']['dimensions']
+				>
+				: this['_'] extends { $type: infer U } ? U
+				: this['_']['data'])
+			| SQL,
+	): SetHasRuntimeDefault<this> {
+		this.config.defaultFn = fn;
+		this.config.hasDefault = true;
+		return this as SetHasRuntimeDefault<this>;
+	}
+
+	/**
+	 * Alias for {@link $defaultFn}.
+	 */
+	$default = this.$defaultFn;
+
+	/**
+	 * Adds a dynamic update value to the column.
+	 * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+	 * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+	 *
+	 * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	 */
+	$onUpdateFn(
+		fn: () =>
+			| (this['_'] extends { dimensions: 1 | 2 | 3 | 4 | 5 } ? WrapArray<
+					this['_'] extends { $type: infer U } ? U : this['_']['data'],
+					this['_']['dimensions']
+				>
+				: this['_'] extends { $type: infer U } ? U
+				: this['_']['data'])
+			| SQL,
+	): SetHasDefault<this> {
+		this.config.onUpdateFn = fn;
+		this.config.hasDefault = true;
+		return this as SetHasDefault<this>;
+	}
+
+	/**
+	 * Alias for {@link $onUpdateFn}.
+	 */
+	$onUpdate = this.$onUpdateFn;
+
+	/**
+	 * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+	 *
+	 * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+	 */
+	primaryKey(): SetIsPrimaryKey<this> {
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this as SetIsPrimaryKey<this>;
+	}
+
+	/** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+	setName(name: string, casingFn: (name: string) => string) {
+		if (this.config.name !== '') return;
+		this.config.name = casingFn(name);
+	}
+
+	/**
+	 * Makes this column a PostgreSQL array column.
+	 *
+	 * @example
+	 * ```ts
+	 * const t = pgTable('t', {
+	 *   // 1D array: number[]
+	 *   tags: integer().array(),
+	 *   // Or explicitly: integer().array('[]')
+	 *   // 2D array: number[][]
+	 *   matrix: integer().array('[][]'),
+	 * });
+	 * ```
+	 */
+	array(): SetDimensions<this, 1>;
+	array<TDim extends PgArrayDimensionString>(
+		dimensions: TDim,
+	): SetDimensions<this, ArrayDimensionStringToNumber<TDim>>;
+	array<TDim extends PgArrayDimensionString>(
+		dimensions?: TDim,
+	): SetDimensions<this, ArrayDimensionStringToNumber<TDim>> {
+		// Calculate dimensions as number from string notation
+		const dim = dimensions ?? '[]';
+		(this.config as any).dimensions = (dim.length / 2) as PgArrayDimension;
+		return this as SetDimensions<this, ArrayDimensionStringToNumber<TDim>>;
 	}
 
 	references(
 		ref: ReferenceConfig['ref'],
-		actions: ReferenceConfig['actions'] = {},
+		config: ReferenceConfig['config'] = {},
 	): this {
-		this.foreignKeyConfigs.push({ ref, actions });
+		this.foreignKeyConfigs.push({ ref, config });
 		return this;
 	}
 
@@ -83,81 +358,126 @@ export abstract class PgColumnBuilder<
 		return this;
 	}
 
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL)): HasGenerated<this, {
-		type: 'always';
-	}> {
+	generatedAlwaysAs(
+		as:
+			| SQL
+			| (() => SQL),
+	): SetHasGenerated<this> {
 		this.config.generated = {
 			as,
 			type: 'always',
 			mode: 'stored',
 		};
-		return this as HasGenerated<this, {
-			type: 'always';
-		}>;
+		return this as SetHasGenerated<this>;
 	}
 
 	/** @internal */
 	buildForeignKeys(column: PgColumn, table: PgTable): ForeignKey[] {
-		return this.foreignKeyConfigs.map(({ ref, actions }) => {
+		return this.foreignKeyConfigs.map(({ ref, config }) => {
 			return iife(
-				(ref, actions) => {
+				(ref, config) => {
 					const builder = new ForeignKeyBuilder(() => {
 						const foreignColumn = ref();
-						return { columns: [column], foreignColumns: [foreignColumn] };
+						return { name: config.name, columns: [column], foreignColumns: [foreignColumn] };
 					});
-					if (actions.onUpdate) {
-						builder.onUpdate(actions.onUpdate);
+					if (config.onUpdate) {
+						builder.onUpdate(config.onUpdate);
 					}
-					if (actions.onDelete) {
-						builder.onDelete(actions.onDelete);
+					if (config.onDelete) {
+						builder.onDelete(config.onDelete);
 					}
 					return builder.build(table);
 				},
 				ref,
-				actions,
+				config,
 			);
 		});
 	}
 
 	/** @internal */
-	abstract build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgColumn<MakeColumnConfig<T, TTableName>>;
+	abstract build(table: PgTable): PgColumn<any>;
 
 	/** @internal */
 	buildExtraConfigColumn<TTableName extends string>(
 		table: AnyPgTable<{ name: TTableName }>,
 	): ExtraConfigColumn {
-		return new ExtraConfigColumn(table, this.config);
+		return new ExtraConfigColumn(table, { ...this.config, dimensions: (this.config as any).dimensions ?? 0 });
 	}
 }
 
-// To understand how to use `PgColumn` and `PgColumn`, see `Column` and `AnyColumn` documentation.
+// TODO: we should potenitally do column to be
+// in charge of map value/array of values/json value and json array of values in 1 place
 export abstract class PgColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = {},
-	TTypeConfig extends object = {},
-> extends Column<T, TRuntimeConfig, TTypeConfig & { dialect: 'pg' }> {
+	out TColumnType extends ColumnType = any,
+	out T extends PgColumnBaseConfig<TColumnType> = PgColumnBaseConfig<TColumnType>,
+	out TRuntimeConfig extends object = {},
+> extends Column<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'PgColumn';
 
+	/** @internal */
+	abstract override readonly codec?: PostgresType;
+
+	/** @internal */
+	override readonly table: PgTable;
+
+	readonly dimensions: PgArrayDimension;
+
 	constructor(
-		override readonly table: PgTable,
-		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
+		table: PgTable,
+		config: PgColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
 	) {
-		if (!config.uniqueName) {
-			config.uniqueName = uniqueKeyName(table, [config.name]);
-		}
 		super(table, config);
+		this.table = table;
+		this.dimensions = config.dimensions ?? 0;
+	}
+
+	/** @internal */
+	override postBuild() {
+		if (this.dimensions) {
+			const originalFromDriver = this.mapFromDriverValue.bind(this);
+			const originalToDriver = this.mapToDriverValue.bind(this);
+
+			this.mapFromDriverValue = this.mapFromDriverValue.isNoop
+				? this.mapFromDriverValue
+				: (value: unknown): unknown => {
+					return this.mapArrayElements(value, originalFromDriver, this.dimensions);
+				};
+
+			this.mapToDriverValue = this.mapToDriverValue.isNoop
+				? this.mapToDriverValue
+				: (value: unknown): unknown => {
+					return this.mapArrayElements(value as unknown[], originalToDriver, this.dimensions);
+				};
+		}
+
+		return this;
+	}
+
+	/** @internal */
+	override shouldDisableInsert(): boolean {
+		return (this.config.generatedIdentity !== undefined && this.config.generatedIdentity.type !== 'byDefault')
+			|| (this.config.generated !== undefined && this.config.generated.type !== 'byDefault');
+	}
+
+	/** @internal */
+	private mapArrayElements(value: unknown, mapper: (v: unknown) => unknown, depth: number): unknown {
+		if (depth > 0 && Array.isArray(value)) {
+			return value.map((v) => v === null ? null : this.mapArrayElements(v, mapper, depth - 1));
+		}
+		return mapper(value);
 	}
 }
 
 export type IndexedExtraConfigType = { order?: 'asc' | 'desc'; nulls?: 'first' | 'last'; opClass?: string };
 
 export class ExtraConfigColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-> extends PgColumn<T, IndexedExtraConfigType> {
+	out T extends PgColumnBaseConfig<ColumnType> = PgColumnBaseConfig<ColumnType>,
+> extends PgColumn<ColumnType, T, IndexedExtraConfigType> {
 	static override readonly [entityKind]: string = 'ExtraConfigColumn';
 
+	/** @itnernal */
+	override readonly codec = undefined;
+
 	override getSQLType(): string {
 		return this.getSQLType();
 	}
@@ -231,7 +551,7 @@ export class ExtraConfigColumn<
 export class IndexedColumn {
 	static readonly [entityKind]: string = 'IndexedColumn';
 	constructor(
-		name: string | undefined,
+		name: string,
 		keyAsName: boolean,
 		type: string,
 		indexConfig: IndexedExtraConfigType,
@@ -242,112 +562,15 @@ export class IndexedColumn {
 		this.indexConfig = indexConfig;
 	}
 
-	name: string | undefined;
+	name: string;
 	keyAsName: boolean;
 	type: string;
 	indexConfig: IndexedExtraConfigType;
 }
 
-export type AnyPgColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = PgColumn<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+export type AnyPgColumn<
+	TPartial extends Partial<PgColumnBaseConfig<ColumnType>> = {},
+> = PgColumn<
+	any,
+	Required<Update<PgColumnBaseConfig<ColumnType>, TPartial>>
 >;
-
-export type PgArrayColumnBuilderBaseConfig = ColumnBuilderBaseConfig<'array', 'PgArray'> & {
-	size: number | undefined;
-	baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-};
-
-export class PgArrayBuilder<
-	T extends PgArrayColumnBuilderBaseConfig,
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string> | PgArrayColumnBuilderBaseConfig,
-> extends PgColumnBuilder<
-	T,
-	{
-		baseBuilder: TBase extends PgArrayColumnBuilderBaseConfig ? PgArrayBuilder<
-				TBase,
-				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any> } ? TBaseBuilder
-					: never
-			>
-			: PgColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-		size: T['size'];
-	},
-	{
-		baseBuilder: TBase extends PgArrayColumnBuilderBaseConfig ? PgArrayBuilder<
-				TBase,
-				TBase extends { baseBuilder: infer TBaseBuilder extends ColumnBuilderBaseConfig<any, any> } ? TBaseBuilder
-					: never
-			>
-			: PgColumnBuilder<TBase, {}, Simplify<Omit<TBase, keyof ColumnBuilderBaseConfig<any, any>>>>;
-		size: T['size'];
-	}
-> {
-	static override readonly [entityKind] = 'PgArrayBuilder';
-
-	constructor(
-		name: string,
-		baseBuilder: PgArrayBuilder<T, TBase>['config']['baseBuilder'],
-		size: T['size'],
-	) {
-		super(name, 'array', 'PgArray');
-		this.config.baseBuilder = baseBuilder;
-		this.config.size = size;
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgArray<MakeColumnConfig<T, TTableName> & { size: T['size']; baseBuilder: T['baseBuilder'] }, TBase> {
-		const baseColumn = this.config.baseBuilder.build(table);
-		return new PgArray<MakeColumnConfig<T, TTableName> & { size: T['size']; baseBuilder: T['baseBuilder'] }, TBase>(
-			table as AnyPgTable<{ name: MakeColumnConfig<T, TTableName>['tableName'] }>,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-			baseColumn,
-		);
-	}
-}
-
-export class PgArray<
-	T extends ColumnBaseConfig<'array', 'PgArray'> & {
-		size: number | undefined;
-		baseBuilder: ColumnBuilderBaseConfig<ColumnDataType, string>;
-	},
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends PgColumn<T, {}, { size: T['size']; baseBuilder: T['baseBuilder'] }> {
-	readonly size: T['size'];
-
-	static override readonly [entityKind]: string = 'PgArray';
-
-	constructor(
-		table: AnyPgTable<{ name: T['tableName'] }>,
-		config: PgArrayBuilder<T, TBase>['config'],
-		readonly baseColumn: PgColumn,
-		readonly range?: [number | undefined, number | undefined],
-	) {
-		super(table, config);
-		this.size = config.size;
-	}
-
-	getSQLType(): string {
-		return `${this.baseColumn.getSQLType()}[${typeof this.size === 'number' ? this.size : ''}]`;
-	}
-
-	override mapFromDriverValue(value: unknown[] | string): T['data'] {
-		if (typeof value === 'string') {
-			// Thank you node-postgres for not parsing enum arrays
-			value = parsePgArray(value);
-		}
-		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
-	}
-
-	override mapToDriverValue(value: unknown[], isNestedArray = false): unknown[] | string {
-		const a = value.map((v) =>
-			v === null
-				? null
-				: is(this.baseColumn, PgArray)
-				? this.baseColumn.mapToDriverValue(v as unknown[], true)
-				: this.baseColumn.mapToDriverValue(v)
-		);
-		if (isNestedArray) return a;
-		return makePgArray(a);
-	}
-}
diff --git a/drizzle-orm/src/pg-core/columns/custom.ts b/drizzle-orm/src/pg-core/columns/custom.ts
index f4f622ff68..23957f97ab 100644
--- a/drizzle-orm/src/pg-core/columns/custom.ts
+++ b/drizzle-orm/src/pg-core/columns/custom.ts
@@ -1,19 +1,17 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
+import type { ColumnBuilderBaseConfig } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-import type { SQL } from '~/sql/sql.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { parsePgArray } from '../array.ts';
+import { type PostgresColumnType, type PostgresType, resolvePgTypeAlias } from '../codecs.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
 	& {
-		name: TName;
 		dataType: 'custom';
-		columnType: 'PgCustomColumn';
 		data: T['data'];
 		driverParam: T['driverData'];
-		enumValues: undefined;
 	}
 	& (T['notNull'] extends true ? { notNull: true } : {})
 	& (T['default'] extends true ? { hasDefault: true } : {});
@@ -22,22 +20,17 @@ export interface PgCustomColumnInnerConfig {
 	customTypeValues: CustomTypeValues;
 }
 
-export class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'PgCustomColumn'>>
-	extends PgColumnBuilder<
-		T,
-		{
-			fieldConfig: CustomTypeValues['config'];
-			customTypeParams: CustomTypeParams<any>;
-		},
-		{
-			pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
-		}
-	>
-{
+export class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>> extends PgColumnBuilder<
+	T,
+	{
+		fieldConfig: CustomTypeValues['config'];
+		customTypeParams: CustomTypeParams<any>;
+	}
+> {
 	static override readonly [entityKind]: string = 'PgCustomColumnBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		fieldConfig: CustomTypeValues['config'],
 		customTypeParams: CustomTypeParams<any>,
 	) {
@@ -47,47 +40,65 @@ export class PgCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', '
 	}
 
 	/** @internal */
-	build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new PgCustomColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgCustomColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgCustomColumn<T extends ColumnBaseConfig<'custom', 'PgCustomColumn'>> extends PgColumn<T> {
+export class PgCustomColumn<T extends ColumnBuilderBaseConfig<'custom'>> extends PgColumn<'custom'> {
 	static override readonly [entityKind]: string = 'PgCustomColumn';
 
+	/** @internal */
+	override readonly codec?: PostgresType | undefined;
+
 	private sqlName: string;
-	private mapTo?: (value: T['data']) => T['driverParam'];
-	private mapFrom?: (value: T['driverParam']) => T['data'];
+	readonly mapFromJsonValue?: (value: unknown) => T['data'];
+	readonly jsonSelectIdentifier?: (identifier: SQL, sql: SQLGenerator, arrayDimensions?: number) => SQL;
 
 	constructor(
-		table: AnyPgTable<{ name: T['tableName'] }>,
+		table: PgTable<any>,
 		config: PgCustomColumnBuilder<T>['config'],
 	) {
-		super(table, config);
+		super(table, config as any);
 		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
-		this.mapTo = config.customTypeParams.toDriver;
-		this.mapFrom = config.customTypeParams.fromDriver;
-	}
+		this.mapToDriverValue = config.customTypeParams.toDriver ?? this.mapToDriverValue;
+		this.mapFromDriverValue = config.customTypeParams.fromDriver ?? this.mapFromDriverValue;
+		this.mapFromJsonValue = config.customTypeParams.fromJson;
+		this.jsonSelectIdentifier = config.customTypeParams.forJsonSelect;
+		const cfgCodec =
+			typeof config.customTypeParams.codec === 'string' || typeof config.customTypeParams.codec === 'undefined'
+				? config.customTypeParams.codec
+				: config.customTypeParams.codec(config.fieldConfig);
+		this.codec = typeof cfgCodec === 'string'
+			? resolvePgTypeAlias(cfgCodec) as PostgresType // If it isn't `PostgresType`, codec search will simply resolve to no codec, which is supported behaviour
+			: undefined;
 
-	getSQLType(): string {
-		return this.sqlName;
+		if (this.dimensions && config.customTypeParams.fromJson) {
+			this.mapFromJsonValue = (value: unknown): unknown => {
+				if (value === null) return value;
+				const arr = typeof value === 'string' ? parsePgArray(value) : value as unknown[];
+				return this.mapJsonArrayElements(arr, config.customTypeParams.fromJson!, this.dimensions);
+			};
+		}
 	}
 
-	override mapFromDriverValue(value: T['driverParam']): T['data'] {
-		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	/** @internal */
+	private mapJsonArrayElements(value: unknown, mapper: (v: unknown) => unknown, depth: number): unknown {
+		if (depth > 0 && Array.isArray(value)) {
+			return value.map((v) => v === null ? null : this.mapJsonArrayElements(v, mapper, depth - 1));
+		}
+		return mapper(value);
 	}
 
-	override mapToDriverValue(value: T['data']): T['driverParam'] {
-		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	getSQLType(): string {
+		return this.sqlName;
 	}
 }
 
-export type CustomTypeValues = {
+export interface CustomTypeValues {
 	/**
 	 * Required type for custom column, that will infer proper type model
 	 *
@@ -104,6 +115,24 @@ export type CustomTypeValues = {
 	 */
 	driverData?: unknown;
 
+	/**
+	 * @deprecated Use codecs instead
+	 *
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
+	/**
+	 * @deprecated Use codecs instead
+	 *
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
 	/**
 	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
 	 */
@@ -138,7 +167,7 @@ export type CustomTypeValues = {
 	 * });
 	 */
 	default?: boolean;
-};
+}
 
 export interface CustomTypeParams<T extends CustomTypeValues> {
 	/**
@@ -173,7 +202,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
 
 	/**
-	 * Optional mapping function, between user input and driver
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
 	 * @example
 	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
 	 * ```
@@ -185,16 +214,129 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	toDriver?: (value: T['data']) => T['driverData'] | SQL;
 
 	/**
-	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
 	 * @example
 	 * For example, when using timestamp we need to map string Date representation to JS Date
 	 * ```
 	 * fromDriver(value: string): Date {
 	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07T03:25:16.635Z";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07T03:25:16.635Z");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * @deprecated Use codecs instead; bypasses JSON codecs if used
+	 *
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying bigint column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's string representation, as opposed to bigint from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): bigint {
+	 * 	return BigInt(value);
 	 * },
 	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "5044565289845416380";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: 5044565289845416380n;
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * @deprecated Use codecs instead; bypasses JSON codecs if used
+	 *
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `bytea`, `geometry`, `timestamp`, `numeric`, `bigint`
+	 * @example
+	 * For example, when using bigint we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator, arrayDimensions?: number): SQL {
+	 * 	return sql`${identifier}::text`
+	 * },
+	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	row_to_json("t".*)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		"table"."custom_bigint" AS "bigint"
+	 * 		FROM
+	 * 		"table"
+	 * 	) AS "t"
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	row_to_json("t".*)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		"table"."custom_bigint"::text AS "bigint"
+	 * 		FROM
+	 * 		"table"
+	 * 	) AS "t"
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
+	 */
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator, arrayDimensions?: number) => SQL;
+
+	/**
+	 * Select which column type codec will be used for this column
 	 */
-	fromDriver?: (value: T['driverData']) => T['data'];
+	codec?:
+		| PostgresColumnType
+		| undefined
+		| ((
+			config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined),
+		) => PostgresColumnType | undefined);
 }
 
 /**
@@ -205,28 +347,27 @@ export function customType<T extends CustomTypeValues = CustomTypeValues>(
 ): Equal<T['configRequired'], true> extends true ? {
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig: TConfig,
-		): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): PgCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
 			fieldConfig: T['config'],
-		): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): PgCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 	: {
-		(): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig?: TConfig,
-		): PgCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): PgCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbName: string,
 			fieldConfig?: T['config'],
-		): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): PgCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 {
-	return <TName extends string>(
-		a?: TName | T['config'],
+	return (
+		a?: string | T['config'],
 		b?: T['config'],
-	): PgCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+	): PgCustomColumnBuilder<ConvertCustomConfig<T>> => {
 		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
-		return new PgCustomColumnBuilder(name as ConvertCustomConfig<TName, T>['name'], config, customTypeParams);
+		return new PgCustomColumnBuilder(name, config, customTypeParams);
 	};
 }
diff --git a/drizzle-orm/src/pg-core/columns/date.common.ts b/drizzle-orm/src/pg-core/columns/date.common.ts
index e8bfbf2b13..02b00701f2 100644
--- a/drizzle-orm/src/pg-core/columns/date.common.ts
+++ b/drizzle-orm/src/pg-core/columns/date.common.ts
@@ -1,15 +1,19 @@
-import type { ColumnBuilderBaseConfig, ColumnDataType } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/sql.ts';
+import type { PgColumnBuilderConfig, SetHasDefault } from './common.ts';
 import { PgColumnBuilder } from './common.ts';
 
-export abstract class PgDateColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TRuntimeConfig extends object = object,
+export abstract class PgDateColumnBuilder<
+	out T extends PgColumnBuilderConfig = PgColumnBuilderConfig,
+	out TRuntimeConfig extends object = object,
 > extends PgColumnBuilder<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'PgDateColumnBaseBuilder';
 
-	defaultNow() {
+	/**
+	 * Adds a `default now()` clause to the column definition.
+	 * Available for date/time column types.
+	 */
+	defaultNow(): SetHasDefault<this> {
 		return this.default(sql`now()`);
 	}
 }
diff --git a/drizzle-orm/src/pg-core/columns/date.ts b/drizzle-orm/src/pg-core/columns/date.ts
index 54f3d1a0ea..2bca3ff1dc 100644
--- a/drizzle-orm/src/pg-core/columns/date.ts
+++ b/drizzle-orm/src/pg-core/columns/date.ts
@@ -1,100 +1,89 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn } from './common.ts';
-import { PgDateColumnBaseBuilder } from './date.common.ts';
+import { PgDateColumnBuilder } from './date.common.ts';
 
-export type PgDateBuilderInitial<TName extends string> = PgDateBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'PgDate';
+export class PgDateBuilder extends PgDateColumnBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgDate'>> extends PgDateColumnBaseBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgDateBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'date', 'PgDate');
+	constructor(name: string) {
+		super(name, 'object date', 'PgDate');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgDate<MakeColumnConfig<T, TTableName>> {
-		return new PgDate<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgDate(table, this.config as any);
 	}
 }
 
-export class PgDate<T extends ColumnBaseConfig<'date', 'PgDate'>> extends PgColumn<T> {
+export class PgDate extends PgColumn<'object date'> {
 	static override readonly [entityKind]: string = 'PgDate';
 
+	/** @internal */
+	override readonly codec = 'date';
+
 	getSQLType(): string {
 		return 'date';
 	}
 
-	override mapFromDriverValue(value: string): Date {
-		return new Date(value);
-	}
-
-	override mapToDriverValue(value: Date): string {
+	override mapToDriverValue = function(value: Date | string): string {
+		if (typeof value === 'string') return value;
 		return value.toISOString();
-	}
+	};
 }
 
-export type PgDateStringBuilderInitial<TName extends string> = PgDateStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgDateString';
+export class PgDateStringBuilder extends PgDateColumnBuilder<{
+	dataType: 'string date';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgDateString'>>
-	extends PgDateColumnBaseBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgDateStringBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgDateString');
+	constructor(name: string) {
+		super(name, 'string date', 'PgDateString');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgDateString<MakeColumnConfig<T, TTableName>> {
-		return new PgDateString<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgDateString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgDateString<T extends ColumnBaseConfig<'string', 'PgDateString'>> extends PgColumn<T> {
+export class PgDateString extends PgColumn<'string date'> {
 	static override readonly [entityKind]: string = 'PgDateString';
 
+	/** @internal */
+	override readonly codec = 'date:string';
+
 	getSQLType(): string {
 		return 'date';
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
 }
 
 export interface PgDateConfig<T extends 'date' | 'string' = 'date' | 'string'> {
 	mode: T;
 }
 
-export function date(): PgDateStringBuilderInitial<''>;
 export function date<TMode extends PgDateConfig['mode'] & {}>(
 	config?: PgDateConfig<TMode>,
-): Equal<TMode, 'date'> extends true ? PgDateBuilderInitial<''> : PgDateStringBuilderInitial<''>;
-export function date<TName extends string, TMode extends PgDateConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'date'> extends true ? PgDateBuilder : PgDateStringBuilder;
+export function date<TMode extends PgDateConfig['mode'] & {}>(
+	name: string,
 	config?: PgDateConfig<TMode>,
-): Equal<TMode, 'date'> extends true ? PgDateBuilderInitial<TName> : PgDateStringBuilderInitial<TName>;
+): Equal<TMode, 'date'> extends true ? PgDateBuilder : PgDateStringBuilder;
 export function date(a?: string | PgDateConfig, b?: PgDateConfig) {
 	const { name, config } = getColumnNameAndConfig<PgDateConfig>(a, b);
 	if (config?.mode === 'date') {
diff --git a/drizzle-orm/src/pg-core/columns/double-precision.ts b/drizzle-orm/src/pg-core/columns/double-precision.ts
index 942085bc1b..9605240e2f 100644
--- a/drizzle-orm/src/pg-core/columns/double-precision.ts
+++ b/drizzle-orm/src/pg-core/columns/double-precision.ts
@@ -1,55 +1,38 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgDoublePrecisionBuilderInitial<TName extends string> = PgDoublePrecisionBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgDoublePrecision';
+export class PgDoublePrecisionBuilder extends PgColumnBuilder<{
+	dataType: 'number double';
 	data: number;
 	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class PgDoublePrecisionBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgDoublePrecision'>>
-	extends PgColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgDoublePrecisionBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgDoublePrecision');
+	constructor(name: string) {
+		super(name, 'number double', 'PgDoublePrecision');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgDoublePrecision<MakeColumnConfig<T, TTableName>> {
-		return new PgDoublePrecision<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgDoublePrecision(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config,
 		);
 	}
 }
 
-export class PgDoublePrecision<T extends ColumnBaseConfig<'number', 'PgDoublePrecision'>> extends PgColumn<T> {
+export class PgDoublePrecision extends PgColumn<'number double'> {
 	static override readonly [entityKind]: string = 'PgDoublePrecision';
 
+	/** @internal */
+	override readonly codec = 'float8';
+
 	getSQLType(): string {
 		return 'double precision';
 	}
-
-	override mapFromDriverValue(value: string | number): number {
-		if (typeof value === 'string') {
-			return Number.parseFloat(value);
-		}
-		return value;
-	}
 }
 
-export function doublePrecision(): PgDoublePrecisionBuilderInitial<''>;
-export function doublePrecision<TName extends string>(name: TName): PgDoublePrecisionBuilderInitial<TName>;
-export function doublePrecision(name?: string) {
+export function doublePrecision(name?: string): PgDoublePrecisionBuilder {
 	return new PgDoublePrecisionBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/enum.ts b/drizzle-orm/src/pg-core/columns/enum.ts
index c35a068720..9cab3d693c 100644
--- a/drizzle-orm/src/pg-core/columns/enum.ts
+++ b/drizzle-orm/src/pg-core/columns/enum.ts
@@ -1,25 +1,11 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import type { NonArray, Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 // Enum as ts enum
-
-export type PgEnumObjectColumnBuilderInitial<TName extends string, TValues extends object> = PgEnumObjectColumnBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgEnumObjectColumn';
-	data: TValues[keyof TValues];
-	enumValues: string[];
-	driverParam: string;
-}>;
-
 export interface PgEnumObject<TValues extends object> {
-	(): PgEnumObjectColumnBuilderInitial<'', TValues>;
-	<TName extends string>(name: TName): PgEnumObjectColumnBuilderInitial<TName, TValues>;
-	<TName extends string>(name?: TName): PgEnumObjectColumnBuilderInitial<TName, TValues>;
+	(name?: string): PgEnumObjectColumnBuilder<TValues>;
 
 	readonly enumName: string;
 	readonly enumValues: string[];
@@ -29,40 +15,45 @@ export interface PgEnumObject<TValues extends object> {
 }
 
 export class PgEnumObjectColumnBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'PgEnumObjectColumn'> & { enumValues: string[] },
-> extends PgColumnBuilder<T, { enum: PgEnumObject<any> }> {
+	TValues extends object,
+> extends PgColumnBuilder<{
+	dataType: 'string enum';
+	data: TValues[keyof TValues];
+	enumValues: string[];
+	driverParam: string;
+}, { enum: PgEnumObject<any> }> {
 	static override readonly [entityKind]: string = 'PgEnumObjectColumnBuilder';
 
-	constructor(name: T['name'], enumInstance: PgEnumObject<any>) {
-		super(name, 'string', 'PgEnumObjectColumn');
+	constructor(name: string, enumInstance: PgEnumObject<any>) {
+		super(name, 'string enum', 'PgEnumObjectColumn');
 		this.config.enum = enumInstance;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgEnumObjectColumn<MakeColumnConfig<T, TTableName>> {
-		return new PgEnumObjectColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgEnumObjectColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgEnumObjectColumn<T extends ColumnBaseConfig<'string', 'PgEnumObjectColumn'> & { enumValues: object }>
-	extends PgColumn<T, { enum: PgEnumObject<object> }>
-{
+export class PgEnumObjectColumn<TValues extends object> extends PgColumn<'string enum'> {
 	static override readonly [entityKind]: string = 'PgEnumObjectColumn';
 
-	readonly enum;
-	override readonly enumValues = this.config.enum.enumValues;
+	/** @internal */
+	override readonly codec = 'enum';
+
+	readonly enum: PgEnumObject<TValues>;
+	override readonly enumValues: string[];
 
 	constructor(
-		table: AnyPgTable<{ name: T['tableName'] }>,
-		config: PgEnumObjectColumnBuilder<T>['config'],
+		table: PgTable<any>,
+		config: PgEnumObjectColumnBuilder<TValues>['config'],
 	) {
-		super(table, config);
-		this.enum = config.enum;
+		super(table, config as any);
+		this.enum = config.enum as PgEnumObject<TValues>;
+		this.enumValues = config.enum.enumValues;
 	}
 
 	getSQLType(): string {
@@ -72,21 +63,9 @@ export class PgEnumObjectColumn<T extends ColumnBaseConfig<'string', 'PgEnumObje
 
 // Enum as string union
 
-export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> =
-	PgEnumColumnBuilder<{
-		name: TName;
-		dataType: 'string';
-		columnType: 'PgEnumColumn';
-		data: TValues[number];
-		enumValues: TValues;
-		driverParam: string;
-	}>;
-
 const isPgEnumSym = Symbol.for('drizzle:isPgEnum');
 export interface PgEnum<TValues extends [string, ...string[]]> {
-	(): PgEnumColumnBuilderInitial<'', TValues>;
-	<TName extends string>(name: TName): PgEnumColumnBuilderInitial<TName, TValues>;
-	<TName extends string>(name?: TName): PgEnumColumnBuilderInitial<TName, TValues>;
+	(name?: string): PgEnumColumnBuilder<TValues>;
 
 	readonly enumName: string;
 	readonly enumValues: TValues;
@@ -100,40 +79,45 @@ export function isPgEnum(obj: unknown): obj is PgEnum<[string, ...string[]]> {
 }
 
 export class PgEnumColumnBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'PgEnumColumn'> & { enumValues: [string, ...string[]] },
-> extends PgColumnBuilder<T, { enum: PgEnum<T['enumValues']> }> {
+	TValues extends [string, ...string[]],
+> extends PgColumnBuilder<{
+	dataType: 'string enum';
+	data: TValues[number];
+	enumValues: TValues;
+	driverParam: string;
+}, { enum: PgEnum<TValues> }> {
 	static override readonly [entityKind]: string = 'PgEnumColumnBuilder';
 
-	constructor(name: T['name'], enumInstance: PgEnum<T['enumValues']>) {
-		super(name, 'string', 'PgEnumColumn');
+	constructor(name: string, enumInstance: PgEnum<TValues>) {
+		super(name, 'string enum', 'PgEnumColumn');
 		this.config.enum = enumInstance;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgEnumColumn<MakeColumnConfig<T, TTableName>> {
-		return new PgEnumColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgEnumColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgEnumColumn<T extends ColumnBaseConfig<'string', 'PgEnumColumn'> & { enumValues: [string, ...string[]] }>
-	extends PgColumn<T, { enum: PgEnum<T['enumValues']> }>
-{
+export class PgEnumColumn<TValues extends [string, ...string[]]> extends PgColumn<'string enum'> {
 	static override readonly [entityKind]: string = 'PgEnumColumn';
 
-	readonly enum = this.config.enum;
-	override readonly enumValues = this.config.enum.enumValues;
+	/** @internal */
+	override readonly codec = 'enum';
+
+	readonly enum: PgEnum<TValues>;
+	override readonly enumValues: TValues;
 
 	constructor(
-		table: AnyPgTable<{ name: T['tableName'] }>,
-		config: PgEnumColumnBuilder<T>['config'],
+		table: PgTable<any>,
+		config: PgEnumColumnBuilder<TValues>['config'],
 	) {
-		super(table, config);
+		super(table, config as any);
 		this.enum = config.enum;
+		this.enumValues = config.enum.enumValues;
 	}
 
 	getSQLType(): string {
@@ -167,8 +151,7 @@ export function pgEnumWithSchema<U extends string, T extends Readonly<[U, ...U[]
 	schema?: string,
 ): PgEnum<Writable<T>> {
 	const enumInstance: PgEnum<Writable<T>> = Object.assign(
-		<TName extends string>(name?: TName): PgEnumColumnBuilderInitial<TName, Writable<T>> =>
-			new PgEnumColumnBuilder(name ?? '' as TName, enumInstance),
+		(name?: string): PgEnumColumnBuilder<Writable<T>> => new PgEnumColumnBuilder(name ?? '', enumInstance),
 		{
 			enumName,
 			enumValues: values,
@@ -187,8 +170,7 @@ export function pgEnumObjectWithSchema<T extends object>(
 	schema?: string,
 ): PgEnumObject<T> {
 	const enumInstance: PgEnumObject<T> = Object.assign(
-		<TName extends string>(name?: TName): PgEnumObjectColumnBuilderInitial<TName, T> =>
-			new PgEnumObjectColumnBuilder(name ?? '' as TName, enumInstance),
+		(name?: string): PgEnumObjectColumnBuilder<T> => new PgEnumObjectColumnBuilder(name ?? '', enumInstance),
 		{
 			enumName,
 			enumValues: Object.values(values),
diff --git a/drizzle-orm/src/pg-core/columns/index.ts b/drizzle-orm/src/pg-core/columns/index.ts
index 79afc74c64..519f8e599c 100644
--- a/drizzle-orm/src/pg-core/columns/index.ts
+++ b/drizzle-orm/src/pg-core/columns/index.ts
@@ -1,6 +1,7 @@
 export * from './bigint.ts';
 export * from './bigserial.ts';
 export * from './boolean.ts';
+export * from './bytea.ts';
 export * from './char.ts';
 export * from './cidr.ts';
 export * from './common.ts';
@@ -9,7 +10,6 @@ export * from './date.ts';
 export * from './double-precision.ts';
 export * from './enum.ts';
 export * from './inet.ts';
-export * from './int.common.ts';
 export * from './integer.ts';
 export * from './interval.ts';
 export * from './json.ts';
diff --git a/drizzle-orm/src/pg-core/columns/inet.ts b/drizzle-orm/src/pg-core/columns/inet.ts
index 741bbdf868..aae983c19a 100644
--- a/drizzle-orm/src/pg-core/columns/inet.ts
+++ b/drizzle-orm/src/pg-core/columns/inet.ts
@@ -1,43 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgInetBuilderInitial<TName extends string> = PgInetBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgInet';
+export class PgInetBuilder extends PgColumnBuilder<{
+	dataType: 'string inet';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgInetBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInet'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgInetBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgInet');
+	constructor(name: string) {
+		super(name, 'string inet', 'PgInet');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgInet<MakeColumnConfig<T, TTableName>> {
-		return new PgInet<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgInet(table, this.config as any);
 	}
 }
 
-export class PgInet<T extends ColumnBaseConfig<'string', 'PgInet'>> extends PgColumn<T> {
+export class PgInet extends PgColumn<'string inet'> {
 	static override readonly [entityKind]: string = 'PgInet';
 
+	/** @internal */
+	override readonly codec = 'inet';
+
 	getSQLType(): string {
 		return 'inet';
 	}
 }
 
-export function inet(): PgInetBuilderInitial<''>;
-export function inet<TName extends string>(name: TName): PgInetBuilderInitial<TName>;
-export function inet(name?: string) {
+export function inet(name?: string): PgInetBuilder {
 	return new PgInetBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/int.common.ts b/drizzle-orm/src/pg-core/columns/int.common.ts
index 32d5d12cdd..55b1813d14 100644
--- a/drizzle-orm/src/pg-core/columns/int.common.ts
+++ b/drizzle-orm/src/pg-core/columns/int.common.ts
@@ -1,57 +1,60 @@
-import type { ColumnBuilderBaseConfig, ColumnDataType, GeneratedIdentityConfig, IsIdentity } from '~/column-builder.ts';
+import type { GeneratedIdentityConfig } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { PgSequenceOptions } from '../sequence.ts';
+import type { HasIdentity, PgColumnBuilderConfig } from './common.ts';
 import { PgColumnBuilder } from './common.ts';
 
-export abstract class PgIntColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends PgColumnBuilder<
-	T,
-	{ generatedIdentity: GeneratedIdentityConfig }
-> {
+export abstract class PgIntColumnBuilder<
+	out T extends PgColumnBuilderConfig = PgColumnBuilderConfig,
+	out TRuntimeConfig extends object = object,
+> extends PgColumnBuilder<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'PgIntColumnBaseBuilder';
 
+	/**
+	 * Adds an `ALWAYS AS IDENTITY` clause to the column definition.
+	 * Available for integer column types.
+	 */
 	generatedAlwaysAsIdentity(
 		sequence?: PgSequenceOptions & { name?: string },
-	): IsIdentity<this, 'always'> {
+	): HasIdentity<this, 'always'> {
 		if (sequence) {
 			const { name, ...options } = sequence;
 			this.config.generatedIdentity = {
 				type: 'always',
 				sequenceName: name,
 				sequenceOptions: options,
-			};
+			} satisfies GeneratedIdentityConfig;
 		} else {
 			this.config.generatedIdentity = {
 				type: 'always',
-			};
+			} satisfies GeneratedIdentityConfig;
 		}
-
 		this.config.hasDefault = true;
 		this.config.notNull = true;
-
-		return this as IsIdentity<this, 'always'>;
+		return this as HasIdentity<this, 'always'>;
 	}
 
+	/**
+	 * Adds a `BY DEFAULT AS IDENTITY` clause to the column definition.
+	 * Available for integer column types.
+	 */
 	generatedByDefaultAsIdentity(
 		sequence?: PgSequenceOptions & { name?: string },
-	): IsIdentity<this, 'byDefault'> {
+	): HasIdentity<this, 'byDefault'> {
 		if (sequence) {
 			const { name, ...options } = sequence;
 			this.config.generatedIdentity = {
 				type: 'byDefault',
 				sequenceName: name,
 				sequenceOptions: options,
-			};
+			} satisfies GeneratedIdentityConfig;
 		} else {
 			this.config.generatedIdentity = {
 				type: 'byDefault',
-			};
+			} satisfies GeneratedIdentityConfig;
 		}
-
 		this.config.hasDefault = true;
 		this.config.notNull = true;
-
-		return this as IsIdentity<this, 'byDefault'>;
+		return this as HasIdentity<this, 'byDefault'>;
 	}
 }
diff --git a/drizzle-orm/src/pg-core/columns/integer.ts b/drizzle-orm/src/pg-core/columns/integer.ts
index 9be92bb34d..5c91a02e4d 100644
--- a/drizzle-orm/src/pg-core/columns/integer.ts
+++ b/drizzle-orm/src/pg-core/columns/integer.ts
@@ -1,53 +1,36 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn } from './common.ts';
-import { PgIntColumnBaseBuilder } from './int.common.ts';
+import { PgIntColumnBuilder } from './int.common.ts';
 
-export type PgIntegerBuilderInitial<TName extends string> = PgIntegerBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgInteger';
+export class PgIntegerBuilder extends PgIntColumnBuilder<{
+	dataType: 'number int32';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class PgIntegerBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgInteger'>>
-	extends PgIntColumnBaseBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgIntegerBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgInteger');
+	constructor(name: string) {
+		super(name, 'number int32', 'PgInteger');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgInteger<MakeColumnConfig<T, TTableName>> {
-		return new PgInteger<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgInteger(table, this.config as any);
 	}
 }
 
-export class PgInteger<T extends ColumnBaseConfig<'number', 'PgInteger'>> extends PgColumn<T> {
+export class PgInteger extends PgColumn<'number int32'> {
 	static override readonly [entityKind]: string = 'PgInteger';
 
+	/** @internal */
+	override readonly codec = 'int';
+
 	getSQLType(): string {
 		return 'integer';
 	}
-
-	override mapFromDriverValue(value: number | string): number {
-		if (typeof value === 'string') {
-			return Number.parseInt(value);
-		}
-		return value;
-	}
 }
 
-export function integer(): PgIntegerBuilderInitial<''>;
-export function integer<TName extends string>(name: TName): PgIntegerBuilderInitial<TName>;
-export function integer(name?: string) {
+export function integer(name?: string): PgIntegerBuilder {
 	return new PgIntegerBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/interval.ts b/drizzle-orm/src/pg-core/columns/interval.ts
index 8f81e98675..f652e652a2 100644
--- a/drizzle-orm/src/pg-core/columns/interval.ts
+++ b/drizzle-orm/src/pg-core/columns/interval.ts
@@ -1,48 +1,44 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 import type { Precision } from './timestamp.ts';
 
-export type PgIntervalBuilderInitial<TName extends string> = PgIntervalBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgInterval';
+export class PgIntervalBuilder extends PgColumnBuilder<{
+	dataType: 'string interval';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgIntervalBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgInterval'>>
-	extends PgColumnBuilder<T, { intervalConfig: IntervalConfig }>
-{
+}, { intervalConfig: IntervalConfig }> {
 	static override readonly [entityKind]: string = 'PgIntervalBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		intervalConfig: IntervalConfig,
 	) {
-		super(name, 'string', 'PgInterval');
+		super(name, 'string interval', 'PgInterval');
 		this.config.intervalConfig = intervalConfig;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgInterval<MakeColumnConfig<T, TTableName>> {
-		return new PgInterval<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgInterval(table, this.config as any);
 	}
 }
 
-export class PgInterval<T extends ColumnBaseConfig<'string', 'PgInterval'>>
-	extends PgColumn<T, { intervalConfig: IntervalConfig }>
-{
+export class PgInterval extends PgColumn<'string interval'> {
 	static override readonly [entityKind]: string = 'PgInterval';
 
-	readonly fields: IntervalConfig['fields'] = this.config.intervalConfig.fields;
-	readonly precision: IntervalConfig['precision'] = this.config.intervalConfig.precision;
+	/** @internal */
+	override readonly codec = 'interval';
+
+	readonly fields: IntervalConfig['fields'];
+	readonly precision: IntervalConfig['precision'];
+
+	constructor(table: PgTable<any>, config: PgIntervalBuilder['config']) {
+		super(table, config);
+		this.fields = config.intervalConfig.fields;
+		this.precision = config.intervalConfig.precision;
+	}
 
 	getSQLType(): string {
 		const fields = this.fields ? ` ${this.fields}` : '';
@@ -69,14 +65,13 @@ export interface IntervalConfig {
 	precision?: Precision;
 }
 
-export function interval(): PgIntervalBuilderInitial<''>;
 export function interval(
 	config?: IntervalConfig,
-): PgIntervalBuilderInitial<''>;
-export function interval<TName extends string>(
-	name: TName,
+): PgIntervalBuilder;
+export function interval(
+	name: string,
 	config?: IntervalConfig,
-): PgIntervalBuilderInitial<TName>;
+): PgIntervalBuilder;
 export function interval(a?: string | IntervalConfig, b: IntervalConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<IntervalConfig>(a, b);
 	return new PgIntervalBuilder(name, config);
diff --git a/drizzle-orm/src/pg-core/columns/json.ts b/drizzle-orm/src/pg-core/columns/json.ts
index deed256b91..5a26ab1cfd 100644
--- a/drizzle-orm/src/pg-core/columns/json.ts
+++ b/drizzle-orm/src/pg-core/columns/json.ts
@@ -1,64 +1,41 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgJsonBuilderInitial<TName extends string> = PgJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'PgJson';
-	data: unknown;
-	driverParam: unknown;
-	enumValues: undefined;
-}>;
-
-export class PgJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJson'>> extends PgColumnBuilder<
-	T
+export class PgJsonBuilder extends PgColumnBuilder<
+	{
+		dataType: 'object json';
+		data: unknown;
+		driverParam: unknown;
+	}
 > {
 	static override readonly [entityKind]: string = 'PgJsonBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'PgJson');
+	constructor(name: string) {
+		super(name, 'object json', 'PgJson');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgJson<MakeColumnConfig<T, TTableName>> {
-		return new PgJson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgJson(table, this.config as any);
 	}
 }
 
-export class PgJson<T extends ColumnBaseConfig<'json', 'PgJson'>> extends PgColumn<T> {
+export class PgJson extends PgColumn<'object json'> {
 	static override readonly [entityKind]: string = 'PgJson';
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgJsonBuilder<T>['config']) {
+	/** @internal */
+	override readonly codec = 'json';
+
+	constructor(table: PgTable<any>, config: PgJsonBuilder['config']) {
 		super(table, config);
 	}
 
 	getSQLType(): string {
 		return 'json';
 	}
-
-	override mapToDriverValue(value: T['data']): string {
-		return JSON.stringify(value);
-	}
-
-	override mapFromDriverValue(value: T['data'] | string): T['data'] {
-		if (typeof value === 'string') {
-			try {
-				return JSON.parse(value);
-			} catch {
-				return value as T['data'];
-			}
-		}
-		return value;
-	}
 }
 
-export function json(): PgJsonBuilderInitial<''>;
-export function json<TName extends string>(name: TName): PgJsonBuilderInitial<TName>;
-export function json(name?: string) {
+export function json(name?: string): PgJsonBuilder {
 	return new PgJsonBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/jsonb.ts b/drizzle-orm/src/pg-core/columns/jsonb.ts
index 14af7c9e9a..5d84ce11a2 100644
--- a/drizzle-orm/src/pg-core/columns/jsonb.ts
+++ b/drizzle-orm/src/pg-core/columns/jsonb.ts
@@ -1,62 +1,39 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgJsonbBuilderInitial<TName extends string> = PgJsonbBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'PgJsonb';
+export class PgJsonbBuilder extends PgColumnBuilder<{
+	dataType: 'object json';
 	data: unknown;
 	driverParam: unknown;
-	enumValues: undefined;
-}>;
-
-export class PgJsonbBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgJsonb'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgJsonbBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'PgJsonb');
+	constructor(name: string) {
+		super(name, 'object json', 'PgJsonb');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgJsonb<MakeColumnConfig<T, TTableName>> {
-		return new PgJsonb<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgJsonb(table, this.config as any);
 	}
 }
 
-export class PgJsonb<T extends ColumnBaseConfig<'json', 'PgJsonb'>> extends PgColumn<T> {
+export class PgJsonb extends PgColumn<'object json'> {
 	static override readonly [entityKind]: string = 'PgJsonb';
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgJsonbBuilder<T>['config']) {
+	/** @internal */
+	override readonly codec = 'jsonb';
+
+	constructor(table: PgTable<any>, config: PgJsonbBuilder['config']) {
 		super(table, config);
 	}
 
 	getSQLType(): string {
 		return 'jsonb';
 	}
-
-	override mapToDriverValue(value: T['data']): string {
-		return JSON.stringify(value);
-	}
-
-	override mapFromDriverValue(value: T['data'] | string): T['data'] {
-		if (typeof value === 'string') {
-			try {
-				return JSON.parse(value);
-			} catch {
-				return value as T['data'];
-			}
-		}
-		return value;
-	}
 }
 
-export function jsonb(): PgJsonbBuilderInitial<''>;
-export function jsonb<TName extends string>(name: TName): PgJsonbBuilderInitial<TName>;
-export function jsonb(name?: string) {
+export function jsonb(name?: string): PgJsonbBuilder {
 	return new PgJsonbBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/line.ts b/drizzle-orm/src/pg-core/columns/line.ts
index 9378d1aa16..b0dba92f7b 100644
--- a/drizzle-orm/src/pg-core/columns/line.ts
+++ b/drizzle-orm/src/pg-core/columns/line.ts
@@ -1,113 +1,95 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgLineBuilderInitial<TName extends string> = PgLineBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'PgLine';
+export class PgLineBuilder extends PgColumnBuilder<{
+	dataType: 'array line';
 	data: [number, number, number];
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class PgLineBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgLine'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgLineBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'array', 'PgLine');
+	constructor(name: string) {
+		super(name, 'array line', 'PgLine');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgLineTuple<MakeColumnConfig<T, TTableName>> {
-		return new PgLineTuple<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgLineTuple(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgLineTuple<T extends ColumnBaseConfig<'array', 'PgLine'>> extends PgColumn<T> {
+export class PgLineTuple extends PgColumn<'array line'> {
 	static override readonly [entityKind]: string = 'PgLine';
 
+	/** @internal */
+	override readonly codec = 'line:tuple';
+
+	readonly mode = 'tuple';
+
 	getSQLType(): string {
 		return 'line';
 	}
 
-	override mapFromDriverValue(value: string): [number, number, number] {
-		const [a, b, c] = value.slice(1, -1).split(',');
-		return [Number.parseFloat(a!), Number.parseFloat(b!), Number.parseFloat(c!)];
-	}
-
-	override mapToDriverValue(value: [number, number, number]): string {
+	override mapToDriverValue = (value: [number, number, number]): string => {
 		return `{${value[0]},${value[1]},${value[2]}}`;
-	}
+	};
 }
 
-export type PgLineABCBuilderInitial<TName extends string> = PgLineABCBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'PgLineABC';
+export class PgLineABCBuilder extends PgColumnBuilder<{
+	dataType: 'object line';
 	data: { a: number; b: number; c: number };
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgLineABCBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgLineABC'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgLineABCBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'PgLineABC');
+	constructor(name: string) {
+		super(name, 'object line', 'PgLineABC');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgLineABC<MakeColumnConfig<T, TTableName>> {
-		return new PgLineABC<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgLineABC(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgLineABC<T extends ColumnBaseConfig<'json', 'PgLineABC'>> extends PgColumn<T> {
+export class PgLineABC extends PgColumn<'object line'> {
 	static override readonly [entityKind]: string = 'PgLineABC';
 
+	/** @internal */
+	override readonly codec = 'line';
+
+	readonly mode = 'abc';
+
 	getSQLType(): string {
 		return 'line';
 	}
 
-	override mapFromDriverValue(value: string): { a: number; b: number; c: number } {
-		const [a, b, c] = value.slice(1, -1).split(',');
-		return { a: Number.parseFloat(a!), b: Number.parseFloat(b!), c: Number.parseFloat(c!) };
-	}
-
-	override mapToDriverValue(value: { a: number; b: number; c: number }): string {
+	override mapToDriverValue = (value: { a: number; b: number; c: number }): string => {
 		return `{${value.a},${value.b},${value.c}}`;
-	}
+	};
 }
 
 export interface PgLineTypeConfig<T extends 'tuple' | 'abc' = 'tuple' | 'abc'> {
 	mode?: T;
 }
 
-export function line(): PgLineBuilderInitial<''>;
 export function line<TMode extends PgLineTypeConfig['mode'] & {}>(
 	config?: PgLineTypeConfig<TMode>,
-): Equal<TMode, 'abc'> extends true ? PgLineABCBuilderInitial<''>
-	: PgLineBuilderInitial<''>;
-export function line<TName extends string, TMode extends PgLineTypeConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'abc'> extends true ? PgLineABCBuilder
+	: PgLineBuilder;
+export function line<TMode extends PgLineTypeConfig['mode'] & {}>(
+	name: string,
 	config?: PgLineTypeConfig<TMode>,
-): Equal<TMode, 'abc'> extends true ? PgLineABCBuilderInitial<TName>
-	: PgLineBuilderInitial<TName>;
+): Equal<TMode, 'abc'> extends true ? PgLineABCBuilder
+	: PgLineBuilder;
 export function line(a?: string | PgLineTypeConfig, b?: PgLineTypeConfig) {
 	const { name, config } = getColumnNameAndConfig<PgLineTypeConfig>(a, b);
 	if (!config?.mode || config.mode === 'tuple') {
diff --git a/drizzle-orm/src/pg-core/columns/macaddr.ts b/drizzle-orm/src/pg-core/columns/macaddr.ts
index bcd8b02bce..422f4a2c45 100644
--- a/drizzle-orm/src/pg-core/columns/macaddr.ts
+++ b/drizzle-orm/src/pg-core/columns/macaddr.ts
@@ -1,43 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgMacaddrBuilderInitial<TName extends string> = PgMacaddrBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgMacaddr';
+export class PgMacaddrBuilder extends PgColumnBuilder<{
+	dataType: 'string macaddr';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgMacaddrBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgMacaddrBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgMacaddr');
+	constructor(name: string) {
+		super(name, 'string macaddr', 'PgMacaddr');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgMacaddr<MakeColumnConfig<T, TTableName>> {
-		return new PgMacaddr<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgMacaddr(table, this.config as any);
 	}
 }
 
-export class PgMacaddr<T extends ColumnBaseConfig<'string', 'PgMacaddr'>> extends PgColumn<T> {
+export class PgMacaddr extends PgColumn<'string macaddr'> {
 	static override readonly [entityKind]: string = 'PgMacaddr';
 
+	/** @internal */
+	override readonly codec = 'macaddr';
+
 	getSQLType(): string {
 		return 'macaddr';
 	}
 }
 
-export function macaddr(): PgMacaddrBuilderInitial<''>;
-export function macaddr<TName extends string>(name: TName): PgMacaddrBuilderInitial<TName>;
-export function macaddr(name?: string) {
+export function macaddr(name?: string): PgMacaddrBuilder {
 	return new PgMacaddrBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/macaddr8.ts b/drizzle-orm/src/pg-core/columns/macaddr8.ts
index e9e3e4befb..f7521ef126 100644
--- a/drizzle-orm/src/pg-core/columns/macaddr8.ts
+++ b/drizzle-orm/src/pg-core/columns/macaddr8.ts
@@ -1,43 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgMacaddr8BuilderInitial<TName extends string> = PgMacaddr8Builder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgMacaddr8';
+export class PgMacaddr8Builder extends PgColumnBuilder<{
+	dataType: 'string macaddr8';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgMacaddr8Builder<T extends ColumnBuilderBaseConfig<'string', 'PgMacaddr8'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgMacaddr8Builder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgMacaddr8');
+	constructor(name: string) {
+		super(name, 'string macaddr8', 'PgMacaddr8');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgMacaddr8<MakeColumnConfig<T, TTableName>> {
-		return new PgMacaddr8<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgMacaddr8(table, this.config as any);
 	}
 }
 
-export class PgMacaddr8<T extends ColumnBaseConfig<'string', 'PgMacaddr8'>> extends PgColumn<T> {
+export class PgMacaddr8 extends PgColumn<'string macaddr8'> {
 	static override readonly [entityKind]: string = 'PgMacaddr8';
 
+	/** @internal */
+	override readonly codec = 'macaddr8';
+
 	getSQLType(): string {
 		return 'macaddr8';
 	}
 }
 
-export function macaddr8(): PgMacaddr8BuilderInitial<''>;
-export function macaddr8<TName extends string>(name: TName): PgMacaddr8BuilderInitial<TName>;
-export function macaddr8(name?: string) {
+export function macaddr8(name?: string): PgMacaddr8Builder {
 	return new PgMacaddr8Builder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/numeric.ts b/drizzle-orm/src/pg-core/columns/numeric.ts
index b35476993b..c8bd1bfff3 100644
--- a/drizzle-orm/src/pg-core/columns/numeric.ts
+++ b/drizzle-orm/src/pg-core/columns/numeric.ts
@@ -1,21 +1,14 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgNumericBuilderInitial<TName extends string> = PgNumericBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgNumeric';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgNumericBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgNumeric'>> extends PgColumnBuilder<
-	T,
+export class PgNumericBuilder extends PgColumnBuilder<
+	{
+		dataType: 'string numeric';
+		data: string;
+		driverParam: string;
+	},
 	{
 		precision: number | undefined;
 		scale: number | undefined;
@@ -23,38 +16,33 @@ export class PgNumericBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgNum
 > {
 	static override readonly [entityKind]: string = 'PgNumericBuilder';
 
-	constructor(name: T['name'], precision?: number, scale?: number) {
-		super(name, 'string', 'PgNumeric');
+	constructor(name: string, precision?: number, scale?: number) {
+		super(name, 'string numeric', 'PgNumeric');
 		this.config.precision = precision;
 		this.config.scale = scale;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgNumeric<MakeColumnConfig<T, TTableName>> {
-		return new PgNumeric<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgNumeric(table, this.config as any);
 	}
 }
 
-export class PgNumeric<T extends ColumnBaseConfig<'string', 'PgNumeric'>> extends PgColumn<T> {
+export class PgNumeric extends PgColumn<'string numeric'> {
 	static override readonly [entityKind]: string = 'PgNumeric';
 
+	/** @internal */
+	override readonly codec = 'numeric';
+
 	readonly precision: number | undefined;
 	readonly scale: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgNumericBuilder['config']) {
 		super(table, config);
 		this.precision = config.precision;
 		this.scale = config.scale;
 	}
 
-	override mapFromDriverValue(value: unknown): string {
-		if (typeof value === 'string') return value;
-
-		return String(value);
-	}
-
 	getSQLType(): string {
 		if (this.precision !== undefined && this.scale !== undefined) {
 			return `numeric(${this.precision}, ${this.scale})`;
@@ -66,61 +54,49 @@ export class PgNumeric<T extends ColumnBaseConfig<'string', 'PgNumeric'>> extend
 	}
 }
 
-export type PgNumericNumberBuilderInitial<TName extends string> = PgNumericNumberBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgNumericNumber';
-	data: number;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgNumericNumberBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgNumericNumber'>>
-	extends PgColumnBuilder<
-		T,
-		{
-			precision: number | undefined;
-			scale: number | undefined;
-		}
-	>
-{
+export class PgNumericNumberBuilder extends PgColumnBuilder<
+	{
+		dataType: 'number';
+		data: number;
+		driverParam: string;
+	},
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
 	static override readonly [entityKind]: string = 'PgNumericNumberBuilder';
 
-	constructor(name: T['name'], precision?: number, scale?: number) {
+	constructor(name: string, precision?: number, scale?: number) {
 		super(name, 'number', 'PgNumericNumber');
 		this.config.precision = precision;
 		this.config.scale = scale;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgNumericNumber<MakeColumnConfig<T, TTableName>> {
-		return new PgNumericNumber<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgNumericNumber(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgNumericNumber<T extends ColumnBaseConfig<'number', 'PgNumericNumber'>> extends PgColumn<T> {
+export class PgNumericNumber extends PgColumn<'number'> {
 	static override readonly [entityKind]: string = 'PgNumericNumber';
 
+	/** @internal */
+	override readonly codec = 'numeric:number';
+
 	readonly precision: number | undefined;
 	readonly scale: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericNumberBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgNumericNumberBuilder['config']) {
 		super(table, config);
 		this.precision = config.precision;
 		this.scale = config.scale;
 	}
 
-	override mapFromDriverValue(value: unknown): number {
-		if (typeof value === 'number') return value;
-
-		return Number(value);
-	}
-
 	override mapToDriverValue = String;
 
 	getSQLType(): string {
@@ -134,57 +110,49 @@ export class PgNumericNumber<T extends ColumnBaseConfig<'number', 'PgNumericNumb
 	}
 }
 
-export type PgNumericBigIntBuilderInitial<TName extends string> = PgNumericBigIntBuilder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'PgNumericBigInt';
-	data: bigint;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgNumericBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'PgNumericBigInt'>>
-	extends PgColumnBuilder<
-		T,
-		{
-			precision: number | undefined;
-			scale: number | undefined;
-		}
-	>
-{
+export class PgNumericBigIntBuilder extends PgColumnBuilder<
+	{
+		dataType: 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	},
+	{
+		precision: number | undefined;
+		scale: number | undefined;
+	}
+> {
 	static override readonly [entityKind]: string = 'PgNumericBigIntBuilder';
 
-	constructor(name: T['name'], precision?: number, scale?: number) {
-		super(name, 'bigint', 'PgNumericBigInt');
+	constructor(name: string, precision?: number, scale?: number) {
+		super(name, 'bigint int64', 'PgNumericBigInt');
 		this.config.precision = precision;
 		this.config.scale = scale;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgNumericBigInt<MakeColumnConfig<T, TTableName>> {
-		return new PgNumericBigInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgNumericBigInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgNumericBigInt<T extends ColumnBaseConfig<'bigint', 'PgNumericBigInt'>> extends PgColumn<T> {
+export class PgNumericBigInt extends PgColumn<'bigint int64'> {
 	static override readonly [entityKind]: string = 'PgNumericBigInt';
 
+	/** @internal */
+	override readonly codec = 'numeric:bigint';
+
 	readonly precision: number | undefined;
 	readonly scale: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgNumericBigIntBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgNumericBigIntBuilder['config']) {
 		super(table, config);
 		this.precision = config.precision;
 		this.scale = config.scale;
 	}
 
-	override mapFromDriverValue = BigInt;
-
 	override mapToDriverValue = String;
 
 	getSQLType(): string {
@@ -205,15 +173,15 @@ export type PgNumericConfig<T extends 'string' | 'number' | 'bigint' = 'string'
 
 export function numeric<TMode extends 'string' | 'number' | 'bigint'>(
 	config?: PgNumericConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilderInitial<''>
-	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilderInitial<''>
-	: PgNumericBuilderInitial<''>;
-export function numeric<TName extends string, TMode extends 'string' | 'number' | 'bigint'>(
-	name: TName,
+): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilder
+	: PgNumericBuilder;
+export function numeric<TMode extends 'string' | 'number' | 'bigint'>(
+	name: string,
 	config?: PgNumericConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilderInitial<TName>
-	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilderInitial<TName>
-	: PgNumericBuilderInitial<TName>;
+): Equal<TMode, 'number'> extends true ? PgNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? PgNumericBigIntBuilder
+	: PgNumericBuilder;
 export function numeric(a?: string | PgNumericConfig, b?: PgNumericConfig) {
 	const { name, config } = getColumnNameAndConfig<PgNumericConfig>(a, b);
 	const mode = config?.mode;
diff --git a/drizzle-orm/src/pg-core/columns/point.ts b/drizzle-orm/src/pg-core/columns/point.ts
index c204aedeae..2601b57458 100644
--- a/drizzle-orm/src/pg-core/columns/point.ts
+++ b/drizzle-orm/src/pg-core/columns/point.ts
@@ -1,123 +1,95 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgPointTupleBuilderInitial<TName extends string> = PgPointTupleBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'PgPointTuple';
+export class PgPointTupleBuilder extends PgColumnBuilder<{
+	dataType: 'array point';
 	data: [number, number];
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class PgPointTupleBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgPointTuple'>>
-	extends PgColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgPointTupleBuilder';
 
 	constructor(name: string) {
-		super(name, 'array', 'PgPointTuple');
+		super(name, 'array point', 'PgPointTuple');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgPointTuple<MakeColumnConfig<T, TTableName>> {
-		return new PgPointTuple<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgPointTuple(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgPointTuple<T extends ColumnBaseConfig<'array', 'PgPointTuple'>> extends PgColumn<T> {
+export class PgPointTuple extends PgColumn<'array point'> {
 	static override readonly [entityKind]: string = 'PgPointTuple';
 
+	/** @internal */
+	override readonly codec = 'point:tuple';
+
+	readonly mode = 'tuple';
+
 	getSQLType(): string {
 		return 'point';
 	}
 
-	override mapFromDriverValue(value: string | { x: number; y: number }): [number, number] {
-		if (typeof value === 'string') {
-			const [x, y] = value.slice(1, -1).split(',');
-			return [Number.parseFloat(x!), Number.parseFloat(y!)];
-		}
-		return [value.x, value.y];
-	}
-
-	override mapToDriverValue(value: [number, number]): string {
+	override mapToDriverValue = (value: [number, number]): string => {
 		return `(${value[0]},${value[1]})`;
-	}
+	};
 }
 
-export type PgPointObjectBuilderInitial<TName extends string> = PgPointObjectBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'PgPointObject';
+export class PgPointObjectBuilder extends PgColumnBuilder<{
+	dataType: 'object point';
 	data: { x: number; y: number };
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgPointObjectBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgPointObject'>>
-	extends PgColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgPointObjectBuilder';
 
 	constructor(name: string) {
-		super(name, 'json', 'PgPointObject');
+		super(name, 'object point', 'PgPointObject');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgPointObject<MakeColumnConfig<T, TTableName>> {
-		return new PgPointObject<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgPointObject(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgPointObject<T extends ColumnBaseConfig<'json', 'PgPointObject'>> extends PgColumn<T> {
+export class PgPointObject extends PgColumn<'object point'> {
 	static override readonly [entityKind]: string = 'PgPointObject';
 
+	/** @internal */
+	override readonly codec = 'point';
+
+	readonly mode = 'xy';
+
 	getSQLType(): string {
 		return 'point';
 	}
 
-	override mapFromDriverValue(value: string | { x: number; y: number }): { x: number; y: number } {
-		if (typeof value === 'string') {
-			const [x, y] = value.slice(1, -1).split(',');
-			return { x: Number.parseFloat(x!), y: Number.parseFloat(y!) };
-		}
-		return value;
-	}
-
-	override mapToDriverValue(value: { x: number; y: number }): string {
+	override mapToDriverValue = (value: { x: number; y: number }): string => {
 		return `(${value.x},${value.y})`;
-	}
+	};
 }
 
 export interface PgPointConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
 	mode?: T;
 }
 
-export function point(): PgPointTupleBuilderInitial<''>;
 export function point<TMode extends PgPointConfig['mode'] & {}>(
 	config?: PgPointConfig<TMode>,
-): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilderInitial<''>
-	: PgPointTupleBuilderInitial<''>;
-export function point<TName extends string, TMode extends PgPointConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilder
+	: PgPointTupleBuilder;
+export function point<TMode extends PgPointConfig['mode'] & {}>(
+	name: string,
 	config?: PgPointConfig<TMode>,
-): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilderInitial<TName>
-	: PgPointTupleBuilderInitial<TName>;
+): Equal<TMode, 'xy'> extends true ? PgPointObjectBuilder
+	: PgPointTupleBuilder;
 export function point(a?: string | PgPointConfig, b?: PgPointConfig) {
 	const { name, config } = getColumnNameAndConfig<PgPointConfig>(a, b);
 	if (!config?.mode || config.mode === 'tuple') {
diff --git a/drizzle-orm/src/pg-core/columns/postgis_extension/geometry.ts b/drizzle-orm/src/pg-core/columns/postgis_extension/geometry.ts
index 93632d31c9..976a8ce337 100644
--- a/drizzle-orm/src/pg-core/columns/postgis_extension/geometry.ts
+++ b/drizzle-orm/src/pg-core/columns/postgis_extension/geometry.ts
@@ -1,99 +1,89 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import type { PgColumnBaseConfig } from '../common.ts';
 import { PgColumn, PgColumnBuilder } from '../common.ts';
-import { parseEWKB } from './utils.ts';
 
-export type PgGeometryBuilderInitial<TName extends string> = PgGeometryBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'PgGeometry';
+export class PgGeometryBuilder extends PgColumnBuilder<{
+	dataType: 'array geometry';
 	data: [number, number];
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgGeometryBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgGeometry'>> extends PgColumnBuilder<T> {
+}, { srid: number | undefined }> {
 	static override readonly [entityKind]: string = 'PgGeometryBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'array', 'PgGeometry');
+	constructor(name: string, srid?: number) {
+		super(name, 'array geometry', 'PgGeometry');
+		this.config.srid = srid;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgGeometry<MakeColumnConfig<T, TTableName>> {
-		return new PgGeometry<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgGeometry(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgGeometry<T extends ColumnBaseConfig<'array', 'PgGeometry'>> extends PgColumn<T> {
+export class PgGeometry
+	extends PgColumn<'array geometry', PgColumnBaseConfig<'array geometry'>, { srid: number | undefined }>
+{
 	static override readonly [entityKind]: string = 'PgGeometry';
 
-	getSQLType(): string {
-		return 'geometry(point)';
-	}
+	/** @internal */
+	override readonly codec = 'geometry(point):tuple';
+
+	readonly srid = this.config.srid;
+	readonly mode = 'tuple';
 
-	override mapFromDriverValue(value: string): [number, number] {
-		return parseEWKB(value);
+	getSQLType(): string {
+		return `geometry(point${this.srid === undefined ? '' : `,${this.srid}`})`;
 	}
 
-	override mapToDriverValue(value: [number, number]): string {
+	override mapToDriverValue = (value: [number, number]): string => {
 		return `point(${value[0]} ${value[1]})`;
-	}
+	};
 }
 
-export type PgGeometryObjectBuilderInitial<TName extends string> = PgGeometryObjectBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'PgGeometryObject';
+export class PgGeometryObjectBuilder extends PgColumnBuilder<{
+	dataType: 'object geometry';
 	data: { x: number; y: number };
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgGeometryObjectBuilder<T extends ColumnBuilderBaseConfig<'json', 'PgGeometryObject'>>
-	extends PgColumnBuilder<T>
-{
+}, { srid?: number }> {
 	static override readonly [entityKind]: string = 'PgGeometryObjectBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'PgGeometryObject');
+	constructor(name: string, srid: number | undefined) {
+		super(name, 'object geometry', 'PgGeometryObject');
+		this.config.srid = srid;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgGeometryObject<MakeColumnConfig<T, TTableName>> {
-		return new PgGeometryObject<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgGeometryObject(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgGeometryObject<T extends ColumnBaseConfig<'json', 'PgGeometryObject'>> extends PgColumn<T> {
+export class PgGeometryObject
+	extends PgColumn<'object geometry', PgColumnBaseConfig<'object geometry'>, { srid: number | undefined }>
+{
 	static override readonly [entityKind]: string = 'PgGeometryObject';
 
-	getSQLType(): string {
-		return 'geometry(point)';
-	}
+	/** @internal */
+	override readonly codec = 'geometry(point)';
 
-	override mapFromDriverValue(value: string): { x: number; y: number } {
-		const parsed = parseEWKB(value);
-		return { x: parsed[0], y: parsed[1] };
+	readonly srid = this.config.srid;
+	readonly mode = 'object';
+
+	getSQLType(): string {
+		return `geometry(point${this.srid === undefined ? '' : `,${this.srid}`})`;
 	}
 
-	override mapToDriverValue(value: { x: number; y: number }): string {
+	override mapToDriverValue = (value: { x: number; y: number }): string => {
 		return `point(${value.x} ${value.y})`;
-	}
+	};
 }
 
 export interface PgGeometryConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
@@ -102,18 +92,17 @@ export interface PgGeometryConfig<T extends 'tuple' | 'xy' = 'tuple' | 'xy'> {
 	srid?: number;
 }
 
-export function geometry(): PgGeometryBuilderInitial<''>;
 export function geometry<TMode extends PgGeometryConfig['mode'] & {}>(
 	config?: PgGeometryConfig<TMode>,
-): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilderInitial<''> : PgGeometryBuilderInitial<''>;
-export function geometry<TName extends string, TMode extends PgGeometryConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilder : PgGeometryBuilder;
+export function geometry<TMode extends PgGeometryConfig['mode'] & {}>(
+	name: string,
 	config?: PgGeometryConfig<TMode>,
-): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilderInitial<TName> : PgGeometryBuilderInitial<TName>;
+): Equal<TMode, 'xy'> extends true ? PgGeometryObjectBuilder : PgGeometryBuilder;
 export function geometry(a?: string | PgGeometryConfig, b?: PgGeometryConfig) {
 	const { name, config } = getColumnNameAndConfig<PgGeometryConfig>(a, b);
 	if (!config?.mode || config.mode === 'tuple') {
-		return new PgGeometryBuilder(name);
+		return new PgGeometryBuilder(name, config?.srid);
 	}
-	return new PgGeometryObjectBuilder(name);
+	return new PgGeometryObjectBuilder(name, config?.srid);
 }
diff --git a/drizzle-orm/src/pg-core/columns/postgis_extension/utils.ts b/drizzle-orm/src/pg-core/columns/postgis_extension/utils.ts
index 8b5d9a7865..18a48315bb 100644
--- a/drizzle-orm/src/pg-core/columns/postgis_extension/utils.ts
+++ b/drizzle-orm/src/pg-core/columns/postgis_extension/utils.ts
@@ -15,7 +15,7 @@ function bytesToFloat64(bytes: Uint8Array, offset: number): number {
 	return view.getFloat64(0, true);
 }
 
-export function parseEWKB(hex: string): [number, number] {
+export function parseEWKB(hex: string): { srid: number | undefined; point: [number, number] } {
 	const bytes = hexToBytes(hex);
 
 	let offset = 0;
@@ -28,9 +28,9 @@ export function parseEWKB(hex: string): [number, number] {
 	const geomType = view.getUint32(offset, byteOrder === 1);
 	offset += 4;
 
-	let _srid: number | undefined;
+	let srid: number | undefined;
 	if (geomType & 0x20000000) { // SRID flag
-		_srid = view.getUint32(offset, byteOrder === 1);
+		srid = view.getUint32(offset, byteOrder === 1);
 		offset += 4;
 	}
 
@@ -40,7 +40,7 @@ export function parseEWKB(hex: string): [number, number] {
 		const y = bytesToFloat64(bytes, offset);
 		offset += 8;
 
-		return [x, y];
+		return { srid, point: [x, y] };
 	}
 
 	throw new Error('Unsupported geometry type');
diff --git a/drizzle-orm/src/pg-core/columns/real.ts b/drizzle-orm/src/pg-core/columns/real.ts
index b3c339c9b3..8b2529253e 100644
--- a/drizzle-orm/src/pg-core/columns/real.ts
+++ b/drizzle-orm/src/pg-core/columns/real.ts
@@ -1,58 +1,43 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgRealBuilderInitial<TName extends string> = PgRealBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgReal';
-	data: number;
-	driverParam: string | number;
-	enumValues: undefined;
-}>;
-
-export class PgRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgReal'>> extends PgColumnBuilder<
-	T,
+export class PgRealBuilder extends PgColumnBuilder<
+	{
+		dataType: 'number float';
+		data: number;
+		driverParam: string | number;
+	},
 	{ length: number | undefined }
 > {
 	static override readonly [entityKind]: string = 'PgRealBuilder';
 
-	constructor(name: T['name'], length?: number) {
-		super(name, 'number', 'PgReal');
+	constructor(name: string, length?: number) {
+		super(name, 'number float', 'PgReal');
 		this.config.length = length;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgReal<MakeColumnConfig<T, TTableName>> {
-		return new PgReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgReal(table, this.config as any);
 	}
 }
 
-export class PgReal<T extends ColumnBaseConfig<'number', 'PgReal'>> extends PgColumn<T> {
+export class PgReal extends PgColumn<'number float'> {
 	static override readonly [entityKind]: string = 'PgReal';
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgRealBuilder<T>['config']) {
+	/** @internal */
+	override readonly codec = 'float4';
+
+	constructor(table: PgTable<any>, config: PgRealBuilder['config']) {
 		super(table, config);
 	}
 
 	getSQLType(): string {
 		return 'real';
 	}
-
-	override mapFromDriverValue = (value: string | number): number => {
-		if (typeof value === 'string') {
-			return Number.parseFloat(value);
-		}
-		return value;
-	};
 }
 
-export function real(): PgRealBuilderInitial<''>;
-export function real<TName extends string>(name: TName): PgRealBuilderInitial<TName>;
-export function real(name?: string) {
+export function real(name?: string): PgRealBuilder {
 	return new PgRealBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/serial.ts b/drizzle-orm/src/pg-core/columns/serial.ts
index 261ef2af9b..2e2c4d3830 100644
--- a/drizzle-orm/src/pg-core/columns/serial.ts
+++ b/drizzle-orm/src/pg-core/columns/serial.ts
@@ -1,55 +1,40 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	HasDefault,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgSerialBuilderInitial<TName extends string> = NotNull<
-	HasDefault<
-		PgSerialBuilder<{
-			name: TName;
-			dataType: 'number';
-			columnType: 'PgSerial';
-			data: number;
-			driverParam: number;
-			enumValues: undefined;
-		}>
-	>
->;
-
-export class PgSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSerial'>> extends PgColumnBuilder<T> {
+export class PgSerialBuilder extends PgColumnBuilder<{
+	dataType: 'number int32';
+	data: number;
+	driverParam: number;
+
+	notNull: true;
+	hasDefault: true;
+}> {
 	static override readonly [entityKind]: string = 'PgSerialBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgSerial');
+	constructor(name: string) {
+		super(name, 'number int32', 'PgSerial');
 		this.config.hasDefault = true;
 		this.config.notNull = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgSerial<MakeColumnConfig<T, TTableName>> {
-		return new PgSerial<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgSerial(table, this.config as any);
 	}
 }
 
-export class PgSerial<T extends ColumnBaseConfig<'number', 'PgSerial'>> extends PgColumn<T> {
+export class PgSerial extends PgColumn<'number int32'> {
 	static override readonly [entityKind]: string = 'PgSerial';
 
+	/** @internal */
+	override readonly codec = 'serial';
+
 	getSQLType(): string {
 		return 'serial';
 	}
 }
 
-export function serial(): PgSerialBuilderInitial<''>;
-export function serial<TName extends string>(name: TName): PgSerialBuilderInitial<TName>;
-export function serial(name?: string) {
+export function serial(name?: string): PgSerialBuilder {
 	return new PgSerialBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/smallint.ts b/drizzle-orm/src/pg-core/columns/smallint.ts
index e662904b57..1581f6b292 100644
--- a/drizzle-orm/src/pg-core/columns/smallint.ts
+++ b/drizzle-orm/src/pg-core/columns/smallint.ts
@@ -1,53 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn } from './common.ts';
-import { PgIntColumnBaseBuilder } from './int.common.ts';
+import { PgIntColumnBuilder } from './int.common.ts';
 
-export type PgSmallIntBuilderInitial<TName extends string> = PgSmallIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'PgSmallInt';
+export class PgSmallIntBuilder extends PgIntColumnBuilder<{
+	dataType: 'number int16';
 	data: number;
 	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class PgSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallInt'>>
-	extends PgIntColumnBaseBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'PgSmallIntBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgSmallInt');
+	constructor(name: string) {
+		super(name, 'number int16', 'PgSmallInt');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgSmallInt<MakeColumnConfig<T, TTableName>> {
-		return new PgSmallInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgSmallInt(table, this.config as any);
 	}
 }
 
-export class PgSmallInt<T extends ColumnBaseConfig<'number', 'PgSmallInt'>> extends PgColumn<T> {
+export class PgSmallInt extends PgColumn<'number int16'> {
 	static override readonly [entityKind]: string = 'PgSmallInt';
 
+	/** @internal */
+	override readonly codec = 'smallint';
+
 	getSQLType(): string {
 		return 'smallint';
 	}
-
-	override mapFromDriverValue = (value: number | string): number => {
-		if (typeof value === 'string') {
-			return Number(value);
-		}
-		return value;
-	};
 }
-
-export function smallint(): PgSmallIntBuilderInitial<''>;
-export function smallint<TName extends string>(name: TName): PgSmallIntBuilderInitial<TName>;
-export function smallint(name?: string) {
+export function smallint(name?: string): PgSmallIntBuilder {
 	return new PgSmallIntBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/smallserial.ts b/drizzle-orm/src/pg-core/columns/smallserial.ts
index c92fc8350a..b6a4796a20 100644
--- a/drizzle-orm/src/pg-core/columns/smallserial.ts
+++ b/drizzle-orm/src/pg-core/columns/smallserial.ts
@@ -1,60 +1,42 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	HasDefault,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgSmallSerialBuilderInitial<TName extends string> = NotNull<
-	HasDefault<
-		PgSmallSerialBuilder<{
-			name: TName;
-			dataType: 'number';
-			columnType: 'PgSmallSerial';
-			data: number;
-			driverParam: number;
-			enumValues: undefined;
-		}>
-	>
->;
-
-export class PgSmallSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallSerial'>>
-	extends PgColumnBuilder<T>
-{
+export class PgSmallSerialBuilder extends PgColumnBuilder<{
+	dataType: 'number int16';
+	data: number;
+	driverParam: number;
+	notNull: true;
+	hasDefault: true;
+}> {
 	static override readonly [entityKind]: string = 'PgSmallSerialBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'PgSmallSerial');
+	constructor(name: string) {
+		super(name, 'number int16', 'PgSmallSerial');
 		this.config.hasDefault = true;
 		this.config.notNull = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgSmallSerial<MakeColumnConfig<T, TTableName>> {
-		return new PgSmallSerial<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgSmallSerial(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgSmallSerial<T extends ColumnBaseConfig<'number', 'PgSmallSerial'>> extends PgColumn<T> {
+export class PgSmallSerial extends PgColumn<'number int16'> {
 	static override readonly [entityKind]: string = 'PgSmallSerial';
 
+	/** @internal */
+	override readonly codec = 'smallserial';
+
 	getSQLType(): string {
 		return 'smallserial';
 	}
 }
 
-export function smallserial(): PgSmallSerialBuilderInitial<''>;
-export function smallserial<TName extends string>(name: TName): PgSmallSerialBuilderInitial<TName>;
-export function smallserial(name?: string) {
+export function smallserial(name?: string): PgSmallSerialBuilder {
 	return new PgSmallSerialBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/text.ts b/drizzle-orm/src/pg-core/columns/text.ts
index 856d44a934..a6713f6b66 100644
--- a/drizzle-orm/src/pg-core/columns/text.ts
+++ b/drizzle-orm/src/pg-core/columns/text.ts
@@ -1,46 +1,49 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgTextBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgText';
-	data: TEnum[number];
-	enumValues: TEnum;
-	driverParam: string;
-}>;
+type PgTextBuilderConfig<TEnum extends [string, ...string[]]> = Equal<TEnum, [string, ...string[]]> extends true
+	? { dataType: 'string'; data: string; driverParam: string }
+	: { dataType: 'string enum'; data: TEnum[number]; enumValues: TEnum; driverParam: string };
 
-export class PgTextBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'PgText'>,
-> extends PgColumnBuilder<T, { enumValues: T['enumValues'] }> {
+export class PgTextBuilder<TEnum extends [string, ...string[]] = [string, ...string[]]> extends PgColumnBuilder<
+	PgTextBuilderConfig<TEnum>,
+	{ enumValues: TEnum }
+> {
 	static override readonly [entityKind]: string = 'PgTextBuilder';
 
 	constructor(
-		name: T['name'],
-		config: PgTextConfig<T['enumValues']>,
+		name: string,
+		config: PgTextConfig<TEnum>,
 	) {
-		super(name, 'string', 'PgText');
-		this.config.enumValues = config.enum;
+		super(name, config.enum?.length ? 'string enum' : 'string', 'PgText');
+		this.config.enumValues = config.enum as TEnum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgText<MakeColumnConfig<T, TTableName>> {
-		return new PgText<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgText(table, this.config as any, this.config.enumValues);
 	}
 }
 
-export class PgText<T extends ColumnBaseConfig<'string', 'PgText'>>
-	extends PgColumn<T, { enumValues: T['enumValues'] }>
-{
+export class PgText<TEnum extends [string, ...string[]] = [string, ...string[]]> extends PgColumn<
+	Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum'
+> {
 	static override readonly [entityKind]: string = 'PgText';
+	override readonly enumValues;
+
+	/** @internal */
+	override readonly codec = 'text';
 
-	override readonly enumValues = this.config.enumValues;
+	constructor(
+		table: PgTable<any>,
+		config: any,
+		enumValues?: string[],
+	) {
+		super(table, config);
+		this.enumValues = enumValues;
+	}
 
 	getSQLType(): string {
 		return 'text';
@@ -48,19 +51,21 @@ export class PgText<T extends ColumnBaseConfig<'string', 'PgText'>>
 }
 
 export interface PgTextConfig<
-	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+	TEnum extends readonly string[] | undefined = readonly string[] | undefined,
 > {
 	enum?: TEnum;
 }
 
-export function text(): PgTextBuilderInitial<'', [string, ...string[]]>;
+// Original function overloads style
+export function text(): PgTextBuilder;
+export function text(name: string): PgTextBuilder;
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config: PgTextConfig<T | Writable<T>>,
+): PgTextBuilder<Writable<T>>;
 export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
-	config?: PgTextConfig<T | Writable<T>>,
-): PgTextBuilderInitial<'', Writable<T>>;
-export function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
-	config?: PgTextConfig<T | Writable<T>>,
-): PgTextBuilderInitial<TName, Writable<T>>;
+	name: string,
+	config: PgTextConfig<T | Writable<T>>,
+): PgTextBuilder<Writable<T>>;
 export function text(a?: string | PgTextConfig, b: PgTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<PgTextConfig>(a, b);
 	return new PgTextBuilder(name, config as any);
diff --git a/drizzle-orm/src/pg-core/columns/time.ts b/drizzle-orm/src/pg-core/columns/time.ts
index b9b52fd796..3967925329 100644
--- a/drizzle-orm/src/pg-core/columns/time.ts
+++ b/drizzle-orm/src/pg-core/columns/time.ts
@@ -1,52 +1,46 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn } from './common.ts';
-import { PgDateColumnBaseBuilder } from './date.common.ts';
+import { PgDateColumnBuilder } from './date.common.ts';
 import type { Precision } from './timestamp.ts';
 
-export type PgTimeBuilderInitial<TName extends string> = PgTimeBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgTime';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTime'>> extends PgDateColumnBaseBuilder<
-	T,
+export class PgTimeBuilder extends PgDateColumnBuilder<
+	{
+		dataType: 'string time';
+		data: string;
+		driverParam: string;
+	},
 	{ withTimezone: boolean; precision: number | undefined }
 > {
 	static override readonly [entityKind]: string = 'PgTimeBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		readonly withTimezone: boolean,
 		readonly precision: number | undefined,
 	) {
-		super(name, 'string', 'PgTime');
+		super(name, 'string time', 'PgTime');
 		this.config.withTimezone = withTimezone;
 		this.config.precision = precision;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgTime<MakeColumnConfig<T, TTableName>> {
-		return new PgTime<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgTime(table, this.config as any);
 	}
 }
 
-export class PgTime<T extends ColumnBaseConfig<'string', 'PgTime'>> extends PgColumn<T> {
+export class PgTime extends PgColumn<'string time'> {
 	static override readonly [entityKind]: string = 'PgTime';
 
+	/** @internal */
+	override readonly codec = 'time';
+
 	readonly withTimezone: boolean;
 	readonly precision: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimeBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgTimeBuilder['config']) {
 		super(table, config);
 		this.withTimezone = config.withTimezone;
 		this.precision = config.precision;
@@ -63,9 +57,8 @@ export interface TimeConfig {
 	withTimezone?: boolean;
 }
 
-export function time(): PgTimeBuilderInitial<''>;
-export function time(config?: TimeConfig): PgTimeBuilderInitial<''>;
-export function time<TName extends string>(name: TName, config?: TimeConfig): PgTimeBuilderInitial<TName>;
+export function time(config?: TimeConfig): PgTimeBuilder;
+export function time(name: string, config?: TimeConfig): PgTimeBuilder;
 export function time(a?: string | TimeConfig, b: TimeConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<TimeConfig>(a, b);
 	return new PgTimeBuilder(name, config.withTimezone ?? false, config.precision);
diff --git a/drizzle-orm/src/pg-core/columns/timestamp.ts b/drizzle-orm/src/pg-core/columns/timestamp.ts
index f5a5cb0a6d..8362e37155 100644
--- a/drizzle-orm/src/pg-core/columns/timestamp.ts
+++ b/drizzle-orm/src/pg-core/columns/timestamp.ts
@@ -1,56 +1,49 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn } from './common.ts';
-import { PgDateColumnBaseBuilder } from './date.common.ts';
-
-export type PgTimestampBuilderInitial<TName extends string> = PgTimestampBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'PgTimestamp';
-	data: Date;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgTimestamp'>>
-	extends PgDateColumnBaseBuilder<
-		T,
-		{ withTimezone: boolean; precision: number | undefined }
-	>
-{
+import { PgDateColumnBuilder } from './date.common.ts';
+
+export class PgTimestampBuilder extends PgDateColumnBuilder<
+	{
+		dataType: 'object date';
+		data: Date;
+		driverParam: string;
+	},
+	{ withTimezone: boolean; precision: number | undefined }
+> {
 	static override readonly [entityKind]: string = 'PgTimestampBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		withTimezone: boolean,
 		precision: number | undefined,
 	) {
-		super(name, 'date', 'PgTimestamp');
+		super(name, 'object date', 'PgTimestamp');
 		this.config.withTimezone = withTimezone;
 		this.config.precision = precision;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new PgTimestamp<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgTimestamp(table, this.config as any);
 	}
 }
 
-export class PgTimestamp<T extends ColumnBaseConfig<'date', 'PgTimestamp'>> extends PgColumn<T> {
+export class PgTimestamp extends PgColumn<'object date'> {
 	static override readonly [entityKind]: string = 'PgTimestamp';
 
+	/** @internal */
+	override readonly codec: 'timestamp' | 'timestamptz';
+
 	readonly withTimezone: boolean;
 	readonly precision: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimestampBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgTimestampBuilder['config']) {
 		super(table, config);
 		this.withTimezone = config.withTimezone;
 		this.precision = config.precision;
+		this.codec = this.withTimezone ? 'timestamptz' : 'timestamp';
 	}
 
 	getSQLType(): string {
@@ -58,69 +51,66 @@ export class PgTimestamp<T extends ColumnBaseConfig<'date', 'PgTimestamp'>> exte
 		return `timestamp${precision}${this.withTimezone ? ' with time zone' : ''}`;
 	}
 
-	override mapFromDriverValue = (value: string): Date | null => {
-		return new Date(this.withTimezone ? value : value + '+0000');
-	};
-
-	override mapToDriverValue = (value: Date): string => {
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
 		return value.toISOString();
 	};
 }
 
-export type PgTimestampStringBuilderInitial<TName extends string> = PgTimestampStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgTimestampString';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgTimestampStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTimestampString'>>
-	extends PgDateColumnBaseBuilder<
-		T,
-		{ withTimezone: boolean; precision: number | undefined }
-	>
-{
+export class PgTimestampStringBuilder extends PgDateColumnBuilder<
+	{
+		dataType: 'string timestamp';
+		data: string;
+		driverParam: string;
+	},
+	{ withTimezone: boolean; precision: number | undefined }
+> {
 	static override readonly [entityKind]: string = 'PgTimestampStringBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		withTimezone: boolean,
 		precision: number | undefined,
 	) {
-		super(name, 'string', 'PgTimestampString');
+		super(name, 'string timestamp', 'PgTimestampString');
 		this.config.withTimezone = withTimezone;
 		this.config.precision = precision;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgTimestampString<MakeColumnConfig<T, TTableName>> {
-		return new PgTimestampString<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgTimestampString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgTimestampString<T extends ColumnBaseConfig<'string', 'PgTimestampString'>> extends PgColumn<T> {
+export class PgTimestampString extends PgColumn<'string timestamp'> {
 	static override readonly [entityKind]: string = 'PgTimestampString';
 
+	/** @internal */
+	override readonly codec: 'timestamp:string' | 'timestamptz:string';
+
 	readonly withTimezone: boolean;
 	readonly precision: number | undefined;
 
-	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimestampStringBuilder<T>['config']) {
+	constructor(table: PgTable<any>, config: PgTimestampStringBuilder['config']) {
 		super(table, config);
 		this.withTimezone = config.withTimezone;
 		this.precision = config.precision;
+		this.codec = this.withTimezone ? 'timestamptz:string' : 'timestamp:string';
 	}
 
 	getSQLType(): string {
 		const precision = this.precision === undefined ? '' : `(${this.precision})`;
 		return `timestamp${precision}${this.withTimezone ? ' with time zone' : ''}`;
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString();
+	};
 }
 
 export type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
@@ -131,14 +121,13 @@ export interface PgTimestampConfig<TMode extends 'date' | 'string' = 'date' | 's
 	withTimezone?: boolean;
 }
 
-export function timestamp(): PgTimestampBuilderInitial<''>;
 export function timestamp<TMode extends PgTimestampConfig['mode'] & {}>(
 	config?: PgTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilderInitial<''> : PgTimestampBuilderInitial<''>;
-export function timestamp<TName extends string, TMode extends PgTimestampConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilder : PgTimestampBuilder;
+export function timestamp<TMode extends PgTimestampConfig['mode'] & {}>(
+	name: string,
 	config?: PgTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilderInitial<TName> : PgTimestampBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilder : PgTimestampBuilder;
 export function timestamp(a?: string | PgTimestampConfig, b: PgTimestampConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<PgTimestampConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/pg-core/columns/uuid.ts b/drizzle-orm/src/pg-core/columns/uuid.ts
index c8455d3729..6af6a04928 100644
--- a/drizzle-orm/src/pg-core/columns/uuid.ts
+++ b/drizzle-orm/src/pg-core/columns/uuid.ts
@@ -1,24 +1,17 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { sql } from '~/sql/sql.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgUUIDBuilderInitial<TName extends string> = PgUUIDBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgUUID';
+export class PgUUIDBuilder extends PgColumnBuilder<{
+	dataType: 'string uuid';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgUUIDBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgUUID'>> extends PgColumnBuilder<T> {
+}> {
 	static override readonly [entityKind]: string = 'PgUUIDBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'PgUUID');
+	constructor(name: string) {
+		super(name, 'string uuid', 'PgUUID');
 	}
 
 	/**
@@ -29,23 +22,22 @@ export class PgUUIDBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgUUID'>
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgUUID<MakeColumnConfig<T, TTableName>> {
-		return new PgUUID<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: PgTable<any>) {
+		return new PgUUID(table, this.config as any);
 	}
 }
 
-export class PgUUID<T extends ColumnBaseConfig<'string', 'PgUUID'>> extends PgColumn<T> {
+export class PgUUID extends PgColumn<'string uuid'> {
 	static override readonly [entityKind]: string = 'PgUUID';
 
+	/** @internal */
+	override readonly codec = 'uuid';
+
 	getSQLType(): string {
 		return 'uuid';
 	}
 }
 
-export function uuid(): PgUUIDBuilderInitial<''>;
-export function uuid<TName extends string>(name: TName): PgUUIDBuilderInitial<TName>;
-export function uuid(name?: string) {
+export function uuid(name?: string): PgUUIDBuilder {
 	return new PgUUIDBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/pg-core/columns/varchar.ts b/drizzle-orm/src/pg-core/columns/varchar.ts
index 6c2042ae4f..f4a2181784 100644
--- a/drizzle-orm/src/pg-core/columns/varchar.ts
+++ b/drizzle-orm/src/pg-core/columns/varchar.ts
@@ -1,57 +1,47 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
-export type PgVarcharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = PgVarcharBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgVarchar';
-	data: TEnum[number];
-	driverParam: string;
-	enumValues: TEnum;
-	length: TLength;
-}>;
+type PgVarcharBuilderConfig<TEnum extends [string, ...string[]]> = Equal<TEnum, [string, ...string[]]> extends true
+	? { dataType: 'string'; data: string; driverParam: string }
+	: { dataType: 'string enum'; data: TEnum[number]; enumValues: TEnum; driverParam: string };
 
-export class PgVarcharBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'PgVarchar'> & { length?: number | undefined },
-> extends PgColumnBuilder<
-	T,
-	{ length: T['length']; enumValues: T['enumValues'] },
-	{ length: T['length'] }
+export class PgVarcharBuilder<TEnum extends [string, ...string[]] = [string, ...string[]]> extends PgColumnBuilder<
+	PgVarcharBuilderConfig<TEnum>,
+	{ length: number | undefined; enumValues: TEnum }
 > {
 	static override readonly [entityKind]: string = 'PgVarcharBuilder';
 
-	constructor(name: T['name'], config: PgVarcharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'PgVarchar');
-		this.config.length = config.length;
-		this.config.enumValues = config.enum;
+	constructor(name: string, config: PgVarcharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'PgVarchar');
+		this.config.length = config.length!;
+		this.config.enumValues = config.enum as TEnum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgVarchar<MakeColumnConfig<T, TTableName> & { length: T['length'] }> {
-		return new PgVarchar<MakeColumnConfig<T, TTableName> & { length: T['length'] }>(
+	override build(table: PgTable<any>) {
+		return new PgVarchar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'> & { length?: number | undefined }>
-	extends PgColumn<T, { length: T['length']; enumValues: T['enumValues'] }, { length: T['length'] }>
+export class PgVarchar<TEnum extends [string, ...string[]] = [string, ...string[]]>
+	extends PgColumn<Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum'>
 {
 	static override readonly [entityKind]: string = 'PgVarchar';
 
-	readonly length = this.config.length;
-	override readonly enumValues = this.config.enumValues;
+	/** @internal */
+	override readonly codec = 'varchar';
+
+	override readonly enumValues: TEnum;
+
+	constructor(table: PgTable<any>, config: PgVarcharBuilder<TEnum>['config']) {
+		super(table, config as any);
+		this.enumValues = config.enumValues;
+	}
 
 	getSQLType(): string {
 		return this.length === undefined ? `varchar` : `varchar(${this.length})`;
@@ -60,29 +50,22 @@ export class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'> & { len
 
 export interface PgVarcharConfig<
 	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length?: TLength;
+	length?: number;
 }
 
-export function varchar(): PgVarcharBuilderInitial<'', [string, ...string[]], undefined>;
-export function varchar<
-	U extends string,
-	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
->(
-	config?: PgVarcharConfig<T | Writable<T>, L>,
-): PgVarcharBuilderInitial<'', Writable<T>, L>;
-export function varchar<
-	TName extends string,
-	U extends string,
-	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
->(
-	name: TName,
-	config?: PgVarcharConfig<T | Writable<T>, L>,
-): PgVarcharBuilderInitial<TName, Writable<T>, L>;
+export function varchar(): PgVarcharBuilder;
+export function varchar(name: string): PgVarcharBuilder;
+export function varchar(config: { length?: number }): PgVarcharBuilder;
+export function varchar(name: string, config: { length?: number }): PgVarcharBuilder;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config: PgVarcharConfig<T | Writable<T>> & { enum: T | Writable<T> },
+): PgVarcharBuilder<Writable<T>>;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
+	config: PgVarcharConfig<T | Writable<T>> & { enum: T | Writable<T> },
+): PgVarcharBuilder<Writable<T>>;
 export function varchar(a?: string | PgVarcharConfig, b: PgVarcharConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<PgVarcharConfig>(a, b);
 	return new PgVarcharBuilder(name, config as any);
diff --git a/drizzle-orm/src/pg-core/columns/vector_extension/bit.ts b/drizzle-orm/src/pg-core/columns/vector_extension/bit.ts
index a3bdd6bdf9..00dac9a841 100644
--- a/drizzle-orm/src/pg-core/columns/vector_extension/bit.ts
+++ b/drizzle-orm/src/pg-core/columns/vector_extension/bit.ts
@@ -1,67 +1,55 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from '../common.ts';
 
-export type PgBinaryVectorBuilderInitial<TName extends string, TDimensions extends number> = PgBinaryVectorBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgBinaryVector';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-	dimensions: TDimensions;
-}>;
-
-export class PgBinaryVectorBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'PgBinaryVector'> & { dimensions: number },
-> extends PgColumnBuilder<
-	T,
-	{ dimensions: T['dimensions'] }
+export class PgBinaryVectorBuilder extends PgColumnBuilder<
+	{
+		dataType: 'string binary';
+		data: string;
+		driverParam: string;
+	},
+	{ length: number; isLengthExact: true }
 > {
 	static override readonly [entityKind]: string = 'PgBinaryVectorBuilder';
 
-	constructor(name: string, config: PgBinaryVectorConfig<T['dimensions']>) {
-		super(name, 'string', 'PgBinaryVector');
-		this.config.dimensions = config.dimensions;
+	constructor(name: string, config: PgBinaryVectorConfig) {
+		super(name, 'string binary', 'PgBinaryVector');
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgBinaryVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }> {
-		return new PgBinaryVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }>(
+	override build(table: PgTable<any>) {
+		return new PgBinaryVector(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgBinaryVector<T extends ColumnBaseConfig<'string', 'PgBinaryVector'> & { dimensions: number }>
-	extends PgColumn<T, { dimensions: T['dimensions'] }, { dimensions: T['dimensions'] }>
-{
+export class PgBinaryVector extends PgColumn<'string binary'> {
 	static override readonly [entityKind]: string = 'PgBinaryVector';
 
-	readonly dimensions = this.config.dimensions;
+	/** @internal */
+	override readonly codec = 'bit';
 
 	getSQLType(): string {
-		return `bit(${this.dimensions})`;
+		return `bit(${this.length})`;
 	}
 }
 
-export interface PgBinaryVectorConfig<TDimensions extends number = number> {
-	dimensions: TDimensions;
+export interface PgBinaryVectorConfig {
+	dimensions: number;
 }
 
-export function bit<D extends number>(
-	config: PgBinaryVectorConfig<D>,
-): PgBinaryVectorBuilderInitial<'', D>;
-export function bit<TName extends string, D extends number>(
-	name: TName,
-	config: PgBinaryVectorConfig<D>,
-): PgBinaryVectorBuilderInitial<TName, D>;
+export function bit(
+	config: PgBinaryVectorConfig,
+): PgBinaryVectorBuilder;
+export function bit(
+	name: string,
+	config: PgBinaryVectorConfig,
+): PgBinaryVectorBuilder;
 export function bit(a: string | PgBinaryVectorConfig, b?: PgBinaryVectorConfig) {
 	const { name, config } = getColumnNameAndConfig<PgBinaryVectorConfig>(a, b);
 	return new PgBinaryVectorBuilder(name, config);
diff --git a/drizzle-orm/src/pg-core/columns/vector_extension/halfvec.ts b/drizzle-orm/src/pg-core/columns/vector_extension/halfvec.ts
index 5f52f5f166..6fd30a2c3d 100644
--- a/drizzle-orm/src/pg-core/columns/vector_extension/halfvec.ts
+++ b/drizzle-orm/src/pg-core/columns/vector_extension/halfvec.ts
@@ -1,79 +1,59 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from '../common.ts';
 
-export type PgHalfVectorBuilderInitial<TName extends string, TDimensions extends number> = PgHalfVectorBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'PgHalfVector';
-	data: number[];
-	driverParam: string;
-	enumValues: undefined;
-	dimensions: TDimensions;
-}>;
-
-export class PgHalfVectorBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgHalfVector'> & { dimensions: number }>
-	extends PgColumnBuilder<
-		T,
-		{ dimensions: T['dimensions'] },
-		{ dimensions: T['dimensions'] }
-	>
-{
+export class PgHalfVectorBuilder extends PgColumnBuilder<
+	{
+		dataType: 'array halfvector';
+		data: number[];
+		driverParam: string;
+	},
+	{ length: number; isLengthExact: true }
+> {
 	static override readonly [entityKind]: string = 'PgHalfVectorBuilder';
 
-	constructor(name: string, config: PgHalfVectorConfig<T['dimensions']>) {
-		super(name, 'array', 'PgHalfVector');
-		this.config.dimensions = config.dimensions;
+	constructor(name: string, config: PgHalfVectorConfig) {
+		super(name, 'array halfvector', 'PgHalfVector');
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgHalfVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }> {
-		return new PgHalfVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }>(
+	override build(table: PgTable<any>) {
+		return new PgHalfVector(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgHalfVector<T extends ColumnBaseConfig<'array', 'PgHalfVector'> & { dimensions: number }>
-	extends PgColumn<T, { dimensions: T['dimensions'] }, { dimensions: T['dimensions'] }>
-{
+export class PgHalfVector extends PgColumn<'array halfvector'> {
 	static override readonly [entityKind]: string = 'PgHalfVector';
 
-	readonly dimensions: T['dimensions'] = this.config.dimensions;
+	/** @internal */
+	override readonly codec = 'halfvec';
 
 	getSQLType(): string {
-		return `halfvec(${this.dimensions})`;
+		return `halfvec(${this.length})`;
 	}
 
-	override mapToDriverValue(value: unknown): unknown {
+	override mapToDriverValue = (value: unknown): unknown => {
 		return JSON.stringify(value);
-	}
-
-	override mapFromDriverValue(value: string): unknown {
-		return value
-			.slice(1, -1)
-			.split(',')
-			.map((v) => Number.parseFloat(v));
-	}
+	};
 }
 
-export interface PgHalfVectorConfig<TDimensions extends number = number> {
-	dimensions: TDimensions;
+export interface PgHalfVectorConfig {
+	dimensions: number;
 }
 
-export function halfvec<D extends number>(
-	config: PgHalfVectorConfig<D>,
-): PgHalfVectorBuilderInitial<'', D>;
-export function halfvec<TName extends string, D extends number>(
-	name: TName,
+export function halfvec(
+	config: PgHalfVectorConfig,
+): PgHalfVectorBuilder;
+export function halfvec(
+	name: string,
 	config: PgHalfVectorConfig,
-): PgHalfVectorBuilderInitial<TName, D>;
+): PgHalfVectorBuilder;
 export function halfvec(a: string | PgHalfVectorConfig, b?: PgHalfVectorConfig) {
 	const { name, config } = getColumnNameAndConfig<PgHalfVectorConfig>(a, b);
 	return new PgHalfVectorBuilder(name, config);
diff --git a/drizzle-orm/src/pg-core/columns/vector_extension/sparsevec.ts b/drizzle-orm/src/pg-core/columns/vector_extension/sparsevec.ts
index 4817fa51f9..07cc3a0ca6 100644
--- a/drizzle-orm/src/pg-core/columns/vector_extension/sparsevec.ts
+++ b/drizzle-orm/src/pg-core/columns/vector_extension/sparsevec.ts
@@ -1,52 +1,45 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
+import type { PgColumnBaseConfig } from '../common.ts';
 import { PgColumn, PgColumnBuilder } from '../common.ts';
 
-export type PgSparseVectorBuilderInitial<TName extends string> = PgSparseVectorBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'PgSparseVector';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class PgSparseVectorBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgSparseVector'>>
-	extends PgColumnBuilder<
-		T,
-		{ dimensions: number | undefined }
-	>
-{
+export class PgSparseVectorBuilder extends PgColumnBuilder<
+	{
+		dataType: 'string sparsevec';
+		data: string;
+		driverParam: string;
+	},
+	{ vectorDimensions: number | undefined }
+> {
 	static override readonly [entityKind]: string = 'PgSparseVectorBuilder';
 
 	constructor(name: string, config: PgSparseVectorConfig) {
-		super(name, 'string', 'PgSparseVector');
-		this.config.dimensions = config.dimensions;
+		super(name, 'string sparsevec', 'PgSparseVector');
+		this.config.vectorDimensions = config.dimensions;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgSparseVector<MakeColumnConfig<T, TTableName>> {
-		return new PgSparseVector<MakeColumnConfig<T, TTableName>>(
+	override build(table: PgTable<any>) {
+		return new PgSparseVector(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgSparseVector<T extends ColumnBaseConfig<'string', 'PgSparseVector'>>
-	extends PgColumn<T, { dimensions: number | undefined }>
+export class PgSparseVector
+	extends PgColumn<'string sparsevec', PgColumnBaseConfig<'string sparsevec'>, { vectorDimensions: number | undefined }>
 {
 	static override readonly [entityKind]: string = 'PgSparseVector';
 
-	readonly dimensions = this.config.dimensions;
+	/** @internal */
+	override readonly codec = 'sparsevec';
+
+	readonly vectorDimensions = this.config.vectorDimensions;
 
 	getSQLType(): string {
-		return `sparsevec(${this.dimensions})`;
+		return `sparsevec(${this.vectorDimensions})`;
 	}
 }
 
@@ -56,11 +49,11 @@ export interface PgSparseVectorConfig {
 
 export function sparsevec(
 	config: PgSparseVectorConfig,
-): PgSparseVectorBuilderInitial<''>;
-export function sparsevec<TName extends string>(
-	name: TName,
+): PgSparseVectorBuilder;
+export function sparsevec(
+	name: string,
 	config: PgSparseVectorConfig,
-): PgSparseVectorBuilderInitial<TName>;
+): PgSparseVectorBuilder;
 export function sparsevec(a: string | PgSparseVectorConfig, b?: PgSparseVectorConfig) {
 	const { name, config } = getColumnNameAndConfig<PgSparseVectorConfig>(a, b);
 	return new PgSparseVectorBuilder(name, config);
diff --git a/drizzle-orm/src/pg-core/columns/vector_extension/vector.ts b/drizzle-orm/src/pg-core/columns/vector_extension/vector.ts
index f36a9b1caf..193690d661 100644
--- a/drizzle-orm/src/pg-core/columns/vector_extension/vector.ts
+++ b/drizzle-orm/src/pg-core/columns/vector_extension/vector.ts
@@ -1,79 +1,59 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from '../common.ts';
 
-export type PgVectorBuilderInitial<TName extends string, TDimensions extends number> = PgVectorBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'PgVector';
-	data: number[];
-	driverParam: string;
-	enumValues: undefined;
-	dimensions: TDimensions;
-}>;
-
-export class PgVectorBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgVector'> & { dimensions: number }>
-	extends PgColumnBuilder<
-		T,
-		{ dimensions: T['dimensions'] },
-		{ dimensions: T['dimensions'] }
-	>
-{
+export class PgVectorBuilder extends PgColumnBuilder<
+	{
+		dataType: 'array vector';
+		data: number[];
+		driverParam: string;
+	},
+	{ length: number; isLengthExact: true }
+> {
 	static override readonly [entityKind]: string = 'PgVectorBuilder';
 
-	constructor(name: string, config: PgVectorConfig<T['dimensions']>) {
-		super(name, 'array', 'PgVector');
-		this.config.dimensions = config.dimensions;
+	constructor(name: string, config: PgVectorConfig) {
+		super(name, 'array vector', 'PgVector');
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }> {
-		return new PgVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }>(
+	override build(table: PgTable<any>) {
+		return new PgVector(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class PgVector<T extends ColumnBaseConfig<'array', 'PgVector'> & { dimensions: number | undefined }>
-	extends PgColumn<T, { dimensions: T['dimensions'] }, { dimensions: T['dimensions'] }>
-{
+export class PgVector extends PgColumn<'array vector'> {
 	static override readonly [entityKind]: string = 'PgVector';
 
-	readonly dimensions: T['dimensions'] = this.config.dimensions;
+	/** @internal */
+	override readonly codec = 'vector';
 
 	getSQLType(): string {
-		return `vector(${this.dimensions})`;
+		return `vector(${this.length})`;
 	}
 
-	override mapToDriverValue(value: unknown): unknown {
+	override mapToDriverValue = (value: unknown): unknown => {
 		return JSON.stringify(value);
-	}
-
-	override mapFromDriverValue(value: string): unknown {
-		return value
-			.slice(1, -1)
-			.split(',')
-			.map((v) => Number.parseFloat(v));
-	}
+	};
 }
 
-export interface PgVectorConfig<TDimensions extends number = number> {
-	dimensions: TDimensions;
+export interface PgVectorConfig {
+	dimensions: number;
 }
 
-export function vector<D extends number>(
-	config: PgVectorConfig<D>,
-): PgVectorBuilderInitial<'', D>;
-export function vector<TName extends string, D extends number>(
-	name: TName,
-	config: PgVectorConfig<D>,
-): PgVectorBuilderInitial<TName, D>;
+export function vector(
+	config: PgVectorConfig,
+): PgVectorBuilder;
+export function vector(
+	name: string,
+	config: PgVectorConfig,
+): PgVectorBuilder;
 export function vector(a: string | PgVectorConfig, b?: PgVectorConfig) {
 	const { name, config } = getColumnNameAndConfig<PgVectorConfig>(a, b);
 	return new PgVectorBuilder(name, config);
diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
deleted file mode 100644
index cc9508d2e3..0000000000
--- a/drizzle-orm/src/pg-core/db.ts
+++ /dev/null
@@ -1,694 +0,0 @@
-import type { Cache } from '~/cache/core/cache.ts';
-import { entityKind } from '~/entity.ts';
-import type { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	PgDeleteBase,
-	PgInsertBuilder,
-	PgSelectBuilder,
-	PgUpdateBuilder,
-	QueryBuilder,
-} from '~/pg-core/query-builders/index.ts';
-import type {
-	PgQueryResultHKT,
-	PgQueryResultKind,
-	PgSession,
-	PgTransaction,
-	PgTransactionConfig,
-	PreparedQueryConfig,
-} from '~/pg-core/session.ts';
-import type { PgTable } from '~/pg-core/table.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import { WithSubquery } from '~/subquery.ts';
-import type { DrizzleTypeError, NeonAuthToken } from '~/utils.ts';
-import type { PgColumn } from './columns/index.ts';
-import { PgCountBuilder } from './query-builders/count.ts';
-import { RelationalQueryBuilder } from './query-builders/query.ts';
-import { PgRaw } from './query-builders/raw.ts';
-import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.ts';
-import type { SelectedFields } from './query-builders/select.types.ts';
-import type { WithBuilder } from './subquery.ts';
-import type { PgViewBase } from './view-base.ts';
-import type { PgMaterializedView } from './view.ts';
-
-export class PgDatabase<
-	TQueryResult extends PgQueryResultHKT,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
-> {
-	static readonly [entityKind]: string = 'PgDatabase';
-
-	declare readonly _: {
-		readonly schema: TSchema | undefined;
-		readonly fullSchema: TFullSchema;
-		readonly tableNamesMap: Record<string, string>;
-		readonly session: PgSession<TQueryResult, TFullSchema, TSchema>;
-	};
-
-	query: TFullSchema extends Record<string, never>
-		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
-		: {
-			[K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]>;
-		};
-
-	constructor(
-		/** @internal */
-		readonly dialect: PgDialect,
-		/** @internal */
-		readonly session: PgSession<any, any, any>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
-	) {
-		this._ = schema
-			? {
-				schema: schema.schema,
-				fullSchema: schema.fullSchema as TFullSchema,
-				tableNamesMap: schema.tableNamesMap,
-				session,
-			}
-			: {
-				schema: undefined,
-				fullSchema: {} as TFullSchema,
-				tableNamesMap: {},
-				session,
-			};
-		this.query = {} as typeof this['query'];
-		if (this._.schema) {
-			for (const [tableName, columns] of Object.entries(this._.schema)) {
-				(this.query as PgDatabase<TQueryResult, Record<string, any>>['query'])[tableName] = new RelationalQueryBuilder(
-					schema!.fullSchema,
-					this._.schema,
-					this._.tableNamesMap,
-					schema!.fullSchema[tableName] as PgTable,
-					columns,
-					dialect,
-					session,
-				);
-			}
-		}
-		this.$cache = { invalidate: async (_params: any) => {} };
-	}
-
-	/**
-	 * Creates a subquery that defines a temporary named result set as a CTE.
-	 *
-	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param alias The alias for the subquery.
-	 *
-	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Create a subquery with alias 'sq' and use it in the select query
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 *
-	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
-	 *
-	 * ```ts
-	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
-	 * const sq = db.$with('sq').as(db.select({
-	 *   name: sql<string>`upper(${users.name})`.as('name'),
-	 * })
-	 * .from(users));
-	 *
-	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
-	 * ```
-	 */
-	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
-		const self = this;
-		const as = (
-			qb:
-				| TypedQueryBuilder<ColumnsSelection | undefined>
-				| SQL
-				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
-		) => {
-			if (typeof qb === 'function') {
-				qb = qb(new QueryBuilder(self.dialect));
-			}
-
-			return new Proxy(
-				new WithSubquery(
-					qb.getSQL(),
-					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
-					alias,
-					true,
-				),
-				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-			);
-		};
-		return { as };
-	};
-
-	$count(
-		source: PgTable | PgViewBase | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	) {
-		return new PgCountBuilder({ source, filters, session: this.session });
-	}
-
-	$cache: { invalidate: Cache['onMutate'] };
-
-	/**
-	 * Incorporates a previously defined CTE (using `$with`) into the main query.
-	 *
-	 * This method allows the main query to reference a temporary named result set.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param queries The CTEs to incorporate into the main query.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Define a subquery 'sq' as a CTE using $with
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * // Incorporate the CTE 'sq' into the main query and select from it
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 */
-	with(...queries: WithSubquery[]) {
-		const self = this;
-
-		/**
-		 * Creates a select query.
-		 *
-		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Select all columns and all rows from the 'cars' table
-		 * const allCars: Car[] = await db.select().from(cars);
-		 *
-		 * // Select specific columns and all rows from the 'cars' table
-		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   brand: cars.brand
-		 * })
-		 *   .from(cars);
-		 * ```
-		 *
-		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-		 *
-		 * ```ts
-		 * // Select specific columns along with expression and all rows from the 'cars' table
-		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-		 * })
-		 *   .from(cars);
-		 * ```
-		 */
-		function select(): PgSelectBuilder<undefined>;
-		function select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-		function select<TSelection extends SelectedFields>(fields?: TSelection): PgSelectBuilder<TSelection | undefined> {
-			return new PgSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-			});
-		}
-
-		/**
-		 * Adds `distinct` expression to the select query.
-		 *
-		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 * ```ts
-		 * // Select all unique rows from the 'cars' table
-		 * await db.selectDistinct()
-		 *   .from(cars)
-		 *   .orderBy(cars.id, cars.brand, cars.color);
-		 *
-		 * // Select all unique brands from the 'cars' table
-		 * await db.selectDistinct({ brand: cars.brand })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 * ```
-		 */
-		function selectDistinct(): PgSelectBuilder<undefined>;
-		function selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-		function selectDistinct<TSelection extends SelectedFields>(
-			fields?: TSelection,
-		): PgSelectBuilder<TSelection | undefined> {
-			return new PgSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: true,
-			});
-		}
-
-		/**
-		 * Adds `distinct on` expression to the select query.
-		 *
-		 * Calling this method will specify how the unique rows are determined.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param on The expression defining uniqueness.
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 * ```ts
-		 * // Select the first row for each unique brand from the 'cars' table
-		 * await db.selectDistinctOn([cars.brand])
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 *
-		 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
-		 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand, cars.color);
-		 * ```
-		 */
-		function selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
-		function selectDistinctOn<TSelection extends SelectedFields>(
-			on: (PgColumn | SQLWrapper)[],
-			fields: TSelection,
-		): PgSelectBuilder<TSelection>;
-		function selectDistinctOn<TSelection extends SelectedFields>(
-			on: (PgColumn | SQLWrapper)[],
-			fields?: TSelection,
-		): PgSelectBuilder<TSelection | undefined> {
-			return new PgSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: { on },
-			});
-		}
-
-		/**
-		 * Creates an update query.
-		 *
-		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-		 *
-		 * Use `.set()` method to specify which values to update.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/update}
-		 *
-		 * @param table The table to update.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Update all rows in the 'cars' table
-		 * await db.update(cars).set({ color: 'red' });
-		 *
-		 * // Update rows with filters and conditions
-		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-		 *
-		 * // Update with returning clause
-		 * const updatedCar: Car[] = await db.update(cars)
-		 *   .set({ color: 'red' })
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult> {
-			return new PgUpdateBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates an insert query.
-		 *
-		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/insert}
-		 *
-		 * @param table The table to insert into.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Insert one row
-		 * await db.insert(cars).values({ brand: 'BMW' });
-		 *
-		 * // Insert multiple rows
-		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-		 *
-		 * // Insert with returning clause
-		 * const insertedCar: Car[] = await db.insert(cars)
-		 *   .values({ brand: 'BMW' })
-		 *   .returning();
-		 * ```
-		 */
-		function insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult> {
-			return new PgInsertBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates a delete query.
-		 *
-		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/delete}
-		 *
-		 * @param table The table to delete from.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Delete all rows in the 'cars' table
-		 * await db.delete(cars);
-		 *
-		 * // Delete rows with filters and conditions
-		 * await db.delete(cars).where(eq(cars.color, 'green'));
-		 *
-		 * // Delete with returning clause
-		 * const deletedCar: Car[] = await db.delete(cars)
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function delete_<TTable extends PgTable>(table: TTable): PgDeleteBase<TTable, TQueryResult> {
-			return new PgDeleteBase(table, self.session, self.dialect, queries);
-		}
-
-		return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
-	}
-
-	/**
-	 * Creates a select query.
-	 *
-	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all columns and all rows from the 'cars' table
-	 * const allCars: Car[] = await db.select().from(cars);
-	 *
-	 * // Select specific columns and all rows from the 'cars' table
-	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   brand: cars.brand
-	 * })
-	 *   .from(cars);
-	 * ```
-	 *
-	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-	 *
-	 * ```ts
-	 * // Select specific columns along with expression and all rows from the 'cars' table
-	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-	 * })
-	 *   .from(cars);
-	 * ```
-	 */
-	select(): PgSelectBuilder<undefined>;
-	select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-	select<TSelection extends SelectedFields>(fields?: TSelection): PgSelectBuilder<TSelection | undefined> {
-		return new PgSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-		});
-	}
-
-	/**
-	 * Adds `distinct` expression to the select query.
-	 *
-	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 * ```ts
-	 * // Select all unique rows from the 'cars' table
-	 * await db.selectDistinct()
-	 *   .from(cars)
-	 *   .orderBy(cars.id, cars.brand, cars.color);
-	 *
-	 * // Select all unique brands from the 'cars' table
-	 * await db.selectDistinct({ brand: cars.brand })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 * ```
-	 */
-	selectDistinct(): PgSelectBuilder<undefined>;
-	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-	selectDistinct<TSelection extends SelectedFields>(fields?: TSelection): PgSelectBuilder<TSelection | undefined> {
-		return new PgSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: true,
-		});
-	}
-
-	/**
-	 * Adds `distinct on` expression to the select query.
-	 *
-	 * Calling this method will specify how the unique rows are determined.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param on The expression defining uniqueness.
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 * ```ts
-	 * // Select the first row for each unique brand from the 'cars' table
-	 * await db.selectDistinctOn([cars.brand])
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 *
-	 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
-	 * await db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand, cars.color);
-	 * ```
-	 */
-	selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
-	selectDistinctOn<TSelection extends SelectedFields>(
-		on: (PgColumn | SQLWrapper)[],
-		fields: TSelection,
-	): PgSelectBuilder<TSelection>;
-	selectDistinctOn<TSelection extends SelectedFields>(
-		on: (PgColumn | SQLWrapper)[],
-		fields?: TSelection,
-	): PgSelectBuilder<TSelection | undefined> {
-		return new PgSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: { on },
-		});
-	}
-
-	/**
-	 * Creates an update query.
-	 *
-	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-	 *
-	 * Use `.set()` method to specify which values to update.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update}
-	 *
-	 * @param table The table to update.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Update all rows in the 'cars' table
-	 * await db.update(cars).set({ color: 'red' });
-	 *
-	 * // Update rows with filters and conditions
-	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-	 *
-	 * // Update with returning clause
-	 * const updatedCar: Car[] = await db.update(cars)
-	 *   .set({ color: 'red' })
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult> {
-		return new PgUpdateBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates an insert query.
-	 *
-	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert}
-	 *
-	 * @param table The table to insert into.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Insert one row
-	 * await db.insert(cars).values({ brand: 'BMW' });
-	 *
-	 * // Insert multiple rows
-	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-	 *
-	 * // Insert with returning clause
-	 * const insertedCar: Car[] = await db.insert(cars)
-	 *   .values({ brand: 'BMW' })
-	 *   .returning();
-	 * ```
-	 */
-	insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, TQueryResult> {
-		return new PgInsertBuilder(table, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates a delete query.
-	 *
-	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete}
-	 *
-	 * @param table The table to delete from.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Delete all rows in the 'cars' table
-	 * await db.delete(cars);
-	 *
-	 * // Delete rows with filters and conditions
-	 * await db.delete(cars).where(eq(cars.color, 'green'));
-	 *
-	 * // Delete with returning clause
-	 * const deletedCar: Car[] = await db.delete(cars)
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	delete<TTable extends PgTable>(table: TTable): PgDeleteBase<TTable, TQueryResult> {
-		return new PgDeleteBase(table, this.session, this.dialect);
-	}
-
-	refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgRefreshMaterializedView<TQueryResult> {
-		return new PgRefreshMaterializedView(view, this.session, this.dialect);
-	}
-
-	protected authToken?: NeonAuthToken;
-
-	execute<TRow extends Record<string, unknown> = Record<string, unknown>>(
-		query: SQLWrapper | string,
-	): PgRaw<PgQueryResultKind<TQueryResult, TRow>> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		const builtQuery = this.dialect.sqlToQuery(sequel);
-		const prepared = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: PgQueryResultKind<TQueryResult, TRow> }
-		>(
-			builtQuery,
-			undefined,
-			undefined,
-			false,
-		);
-		return new PgRaw(
-			() => prepared.execute(undefined, this.authToken),
-			sequel,
-			builtQuery,
-			(result) => prepared.mapResult(result, true),
-		);
-	}
-
-	transaction<T>(
-		transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-		config?: PgTransactionConfig,
-	): Promise<T> {
-		return this.session.transaction(transaction, config);
-	}
-}
-
-export type PgWithReplicas<Q> = Q & { $primary: Q };
-
-export const withReplicas = <
-	HKT extends PgQueryResultHKT,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-	Q extends PgDatabase<
-		HKT,
-		TFullSchema,
-		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
-	>,
->(
-	primary: Q,
-	replicas: [Q, ...Q[]],
-	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
-): PgWithReplicas<Q> => {
-	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
-	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
-	const selectDistinctOn: Q['selectDistinctOn'] = (...args: [any]) => getReplica(replicas).selectDistinctOn(...args);
-	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
-	const _with: Q['with'] = (...args: any) => getReplica(replicas).with(...args);
-	const $with: Q['$with'] = (arg: any) => getReplica(replicas).$with(arg) as any;
-
-	const update: Q['update'] = (...args: [any]) => primary.update(...args);
-	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
-	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
-	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
-	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
-	const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: [any]) =>
-		primary.refreshMaterializedView(...args);
-
-	return {
-		...primary,
-		update,
-		insert,
-		delete: $delete,
-		execute,
-		transaction,
-		refreshMaterializedView,
-		$primary: primary,
-		select,
-		selectDistinct,
-		selectDistinctOn,
-		$count,
-		$with,
-		with: _with,
-		get query() {
-			return getReplica(replicas).query;
-		},
-	};
-};
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 59ec42b169..413df7ea41 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -1,21 +1,9 @@
-import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from '~/alias.ts';
-import { CasingCache } from '~/casing.ts';
+import { aliasedTable, getOriginalColumnFromAlias } from '~/alias.ts';
+import { CodecsCollection } from '~/codecs.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import { DrizzleError } from '~/errors.ts';
-import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
-import {
-	PgColumn,
-	PgDate,
-	PgDateString,
-	PgJson,
-	PgJsonb,
-	PgNumeric,
-	PgTime,
-	PgTimestamp,
-	PgTimestampString,
-	PgUUID,
-} from '~/pg-core/columns/index.ts';
+import { PgColumn, type PgCustomColumn } from '~/pg-core/columns/index.ts';
 import type {
 	AnyPgSelectQueryBuilder,
 	PgDeleteConfig,
@@ -25,94 +13,72 @@ import type {
 } from '~/pg-core/query-builders/index.ts';
 import type { PgSelectConfig, SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import { PgTable } from '~/pg-core/table.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import {
+	type AnyOne,
+	// AggregatedField,
 	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	getOperators,
-	getOrderByOperators,
-	Many,
-	normalizeRelation,
+	type DBQueryConfigWithComment,
+	getTableAsAliasSQL,
+	makeDefaultRqbMapper,
+	makeJitRqbMapper,
 	One,
 	type Relation,
+	type RelationalRowsMapperGenerator,
+	relationExtrasToSQL,
+	relationsFilterToSQL,
+	relationsOrderToSQL,
+	relationToSQL,
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
+	type WithContainer,
 } from '~/relations.ts';
-import { and, eq, View } from '~/sql/index.ts';
-import {
-	type DriverValueEncoder,
-	type Name,
-	Param,
-	type QueryTypingsValue,
-	type QueryWithTypings,
-	SQL,
-	sql,
-	type SQLChunk,
-} from '~/sql/sql.ts';
+import { and, isSQLWrapper, type SQLWrapper, View } from '~/sql/index.ts';
+import { type Name, Param, type Query, SQL, sql, type SQLChunk } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
-import { getTableName, getTableUniqueName, Table } from '~/table.ts';
-import { type Casing, orderSelectedFields, type UpdateSet } from '~/utils.ts';
+import { getTableName, Table, TableColumns } from '~/table.ts';
+import {
+	getColumnFromDecoder,
+	makeDefaultQueryMapper,
+	makeJitQueryMapper,
+	orderSelectedFields,
+	type RowsMapperGenerator,
+	type UpdateSet,
+} from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import type { PgSession } from './session.ts';
+import { type PgCodecs, type PostgresType, resolvePgTypeAlias, unionsTypeTable } from './codecs.ts';
 import { PgViewBase } from './view-base.ts';
-import type { PgMaterializedView } from './view.ts';
+import type { PgMaterializedView, PgView } from './view.ts';
 
 export interface PgDialectConfig {
-	casing?: Casing;
+	codecs?: PgCodecs;
+	useJitMappers?: boolean;
 }
 
 export class PgDialect {
 	static readonly [entityKind]: string = 'PgDialect';
 
-	/** @internal */
-	readonly casing: CasingCache;
+	readonly codecs: CodecsCollection<PostgresType>;
+	readonly mapperGenerators: {
+		rows: RowsMapperGenerator;
+		relationalRows: RelationalRowsMapperGenerator;
+	};
 
 	constructor(config?: PgDialectConfig) {
-		this.casing = new CasingCache(config?.casing);
-	}
-
-	async migrate(migrations: MigrationMeta[], session: PgSession, config: string | MigrationConfig): Promise<void> {
-		const migrationsTable = typeof config === 'string'
-			? '__drizzle_migrations'
-			: config.migrationsTable ?? '__drizzle_migrations';
-		const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle';
-		const migrationTableCreate = sql`
-			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
-				id SERIAL PRIMARY KEY,
-				hash text NOT NULL,
-				created_at bigint
-			)
-		`;
-		await session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
-		await session.execute(migrationTableCreate);
-
-		const dbMigrations = await session.all<{ id: number; hash: string; created_at: string }>(
-			sql`select id, hash, created_at from ${sql.identifier(migrationsSchema)}.${
-				sql.identifier(migrationsTable)
-			} order by created_at desc limit 1`,
-		);
-
-		const lastDbMigration = dbMigrations[0];
-		await session.transaction(async (tx) => {
-			for await (const migration of migrations) {
-				if (
-					!lastDbMigration
-					|| Number(lastDbMigration.created_at) < migration.folderMillis
-				) {
-					for (const stmt of migration.sql) {
-						await tx.execute(sql.raw(stmt));
-					}
-					await tx.execute(
-						sql`insert into ${sql.identifier(migrationsSchema)}.${
-							sql.identifier(migrationsTable)
-						} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`,
-					);
-				}
+		this.codecs = new CodecsCollection<PostgresType>(resolvePgTypeAlias, config?.codecs);
+		this.mapperGenerators = config?.useJitMappers
+			? {
+				rows: makeJitQueryMapper,
+				relationalRows: makeJitRqbMapper,
 			}
-		});
+			: {
+				rows: makeDefaultQueryMapper,
+				relationalRows: makeDefaultRqbMapper,
+			};
 	}
 
 	escapeName(name: string): string {
-		return `"${name}"`;
+		return `"${name.replace(/"/g, '""')}"`;
 	}
 
 	escapeParam(num: number): string {
@@ -137,40 +103,69 @@ export class PgDialect {
 		return sql.join(withSqlChunks);
 	}
 
-	buildDeleteQuery({ table, where, returning, withList }: PgDeleteConfig): SQL {
+	buildDeleteQuery({
+		table,
+		where,
+		returning,
+		withList,
+		comment,
+		ignoreSelectionCastCodecs,
+	}: PgDeleteConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
+			? sql` returning ${
+				this.buildSelection(returning, { isSingleTable: true, ignoreCastCodecs: ignoreSelectionCastCodecs })
+			}`
 			: undefined;
 
 		const whereSql = where ? sql` where ${where}` : undefined;
 
-		return sql`${withSql}delete from ${table}${whereSql}${returningSql}`;
+		return sql`${withSql}delete from ${table}${whereSql}${returningSql}${
+			comment !== undefined ? sql` ${comment}` : undefined
+		}`;
 	}
 
 	buildUpdateSet(table: PgTable, set: UpdateSet): SQL {
 		const tableColumns = table[Table.Symbol.Columns];
 
-		const columnNames = Object.keys(tableColumns).filter((colName) =>
-			set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
 		);
 
-		const setSize = columnNames.length;
-		return sql.join(columnNames.flatMap((colName, i) => {
-			const col = tableColumns[colName]!;
+		const setLength = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
 
-			const value = set[colName] ?? sql.param(col.onUpdateFn!(), col);
-			const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
 
-			if (i < setSize - 1) {
-				return [res, sql.raw(', ')];
-			}
-			return [res];
-		}));
+				if (i < setLength - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
 	}
 
-	buildUpdateQuery({ table, set, where, returning, withList, from, joins }: PgUpdateConfig): SQL {
+	buildUpdateQuery({
+		table,
+		set,
+		where,
+		returning,
+		withList,
+		from,
+		joins,
+		comment,
+		ignoreSelectionCastCodecs,
+	}: PgUpdateConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const tableName = table[PgTable.Symbol.Name];
@@ -178,7 +173,9 @@ export class PgDialect {
 		const origTableName = table[PgTable.Symbol.OriginalName];
 		const alias = tableName === origTableName ? undefined : tableName;
 		const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${
-			sql.identifier(origTableName)
+			sql.identifier(
+				origTableName,
+			)
 		}${alias && sql` ${sql.identifier(alias)}`}`;
 
 		const setSql = this.buildUpdateSet(table, set);
@@ -188,12 +185,16 @@ export class PgDialect {
 		const joinsSql = this.buildJoins(joins);
 
 		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}`
+			? sql` returning ${
+				this.buildSelection(returning, { isSingleTable: !from, ignoreCastCodecs: ignoreSelectionCastCodecs })
+			}`
 			: undefined;
 
 		const whereSql = where ? sql` where ${where}` : undefined;
 
-		return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
+		return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${
+			comment !== undefined ? sql` ${comment}` : undefined
+		}`;
 	}
 
 	/**
@@ -209,51 +210,87 @@ export class PgDialect {
 	 */
 	private buildSelection(
 		fields: SelectedFieldsOrdered,
-		{ isSingleTable = false }: { isSingleTable?: boolean } = {},
+		{ isSingleTable = false, ignoreCastCodecs = false }: { isSingleTable?: boolean; ignoreCastCodecs?: boolean } = {},
 	): SQL {
 		const columnsLen = fields.length;
 
-		const chunks = fields
-			.flatMap(({ field }, i) => {
-				const chunk: SQLChunk[] = [];
-
-				if (is(field, SQL.Aliased) && field.isSelectionField) {
-					chunk.push(sql.identifier(field.fieldAlias));
-				} else if (is(field, SQL.Aliased) || is(field, SQL)) {
-					const query = is(field, SQL.Aliased) ? field.sql : field;
+		const chunks = fields.flatMap(({ field, codecOverride, column }, i) => {
+			const chunk: SQLChunk[] = [];
+			const override = codecOverride as PostgresType | undefined;
+
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					const query = !isSingleTable && field.origin !== undefined
+						? sql`${sql.identifier(field.origin)}.${sql.identifier(field.fieldAlias)}`
+						: sql.identifier(field.fieldAlias);
+					if (column && !ignoreCastCodecs) chunk.push(this.codecs.apply(column, 'cast', query, override));
+					else chunk.push(query);
+				} else {
+					const query = field.sql;
 
 					if (isSingleTable) {
-						chunk.push(
-							new SQL(
-								query.queryChunks.map((c) => {
-									if (is(c, PgColumn)) {
-										return sql.identifier(this.casing.getColumnCasing(c));
-									}
-									return c;
-								}),
-							),
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, PgColumn)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
 						);
-					} else {
-						chunk.push(query);
-					}
 
-					if (is(field, SQL.Aliased)) {
-						chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-					}
-				} else if (is(field, Column)) {
-					if (isSingleTable) {
-						chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
+						if (query.shouldInlineParams) newSql.inlineParams();
+						chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', newSql, override) : newSql);
 					} else {
-						chunk.push(field);
+						chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', query, override) : query);
 					}
+
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, PgColumn)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
+
+					if (query.shouldInlineParams) newSql.inlineParams();
+					chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', newSql, override) : newSql);
+				} else {
+					chunk.push(column && !ignoreCastCodecs ? this.codecs.apply(column, 'cast', query, override) : query);
+				}
+			} else if (is(field, Column)) {
+				let name: Name | Column;
+				if (isSingleTable) {
+					name = field.isAlias
+						? sql.identifier(getOriginalColumnFromAlias(field).name)
+						: sql.identifier(field.name);
+				} else {
+					name = field.isAlias ? getOriginalColumnFromAlias(field) : field;
 				}
 
-				if (i < columnsLen - 1) {
-					chunk.push(sql`, `);
+				const casted = ignoreCastCodecs ? name : this.codecs.apply(field, 'cast', name, override);
+				chunk.push(field.isAlias ? sql`${casted} as ${field}` : casted);
+			} else if (is(field, Subquery)) {
+				if (column && !ignoreCastCodecs && !field._.isWith) {
+					const innerCasted = this.codecs.apply(column, 'cast', sql`(${field._.sql})`, override);
+					chunk.push(sql`${innerCasted} ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(column ? this.codecs.apply(column, 'cast', field) : field, override);
 				}
+			}
 
-				return chunk;
-			});
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
 
 		return sql.join(chunks);
 	}
@@ -317,28 +354,38 @@ export class PgDialect {
 			return sql`${fullName} ${sql.identifier(table[Table.Symbol.Name])}`;
 		}
 
+		if (is(table, View) && table[ViewBaseConfig].isAlias) {
+			let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+			if (table[ViewBaseConfig].schema) {
+				fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+			}
+			return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+		}
+
 		return table;
 	}
 
-	buildSelectQuery(
-		{
-			withList,
-			fields,
-			fieldsFlat,
-			where,
-			having,
-			table,
-			joins,
-			orderBy,
-			groupBy,
-			limit,
-			offset,
-			lockingClause,
-			distinct,
-			setOperators,
-		}: PgSelectConfig,
-	): SQL {
-		const fieldsList = fieldsFlat ?? orderSelectedFields<PgColumn>(fields);
+	buildSelectQuery({
+		withList,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		limit,
+		offset,
+		lockingClause,
+		distinct,
+		setOperators,
+		comment,
+		ignoreSelectionCastCodecs,
+	}: PgSelectConfig): SQL {
+		if (!fieldsFlat) {
+			throw new Error('Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation');
+		}
+		const fieldsList = fieldsFlat;
 		for (const f of fieldsList) {
 			if (
 				is(f.field, Column)
@@ -351,14 +398,20 @@ export class PgDialect {
 						? undefined
 						: getTableName(table))
 				&& !((table) =>
-					joins?.some(({ alias }) =>
-						alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
 					))(f.field.table)
 			) {
 				const tableName = getTableName(f.field.table);
 				throw new Error(
 					`Your "${
-						f.path.join('->')
+						f.path.join(
+							'->',
+						)
 					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
 				);
 			}
@@ -370,10 +423,15 @@ export class PgDialect {
 
 		let distinctSql: SQL | undefined;
 		if (distinct) {
-			distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
+			distinctSql = distinct === true
+				? sql` distinct`
+				: sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
 		}
 
-		const selection = this.buildSelection(fieldsList, { isSingleTable });
+		const selection = this.buildSelection(fieldsList, {
+			isSingleTable,
+			ignoreCastCodecs: ignoreSelectionCastCodecs || setOperators.length > 0,
+		});
 
 		const tableSql = this.buildFromTable(table);
 
@@ -406,7 +464,9 @@ export class PgDialect {
 				clauseSql.append(
 					sql` of ${
 						sql.join(
-							Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of],
+							Array.isArray(lockingClause.config.of)
+								? lockingClause.config.of.map((it) => sql.identifier(it[PgTable.Symbol.Name]))
+								: [sql.identifier(lockingClause.config.of[PgTable.Symbol.Name])],
 							sql`, `,
 						)
 					}`,
@@ -420,39 +480,90 @@ export class PgDialect {
 			lockingClauseSql.append(clauseSql);
 		}
 		const finalQuery =
-			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}${
+				comment !== undefined ? sql` ${comment}` : undefined
+			}`;
 
 		if (setOperators.length > 0) {
-			return this.buildSetOperations(finalQuery, setOperators);
+			return this.buildSetOperations(finalQuery, fieldsList, ignoreSelectionCastCodecs, setOperators);
 		}
 
 		return finalQuery;
 	}
 
-	buildSetOperations(leftSelect: SQL, setOperators: PgSelectConfig['setOperators']): SQL {
-		const [setOperator, ...rest] = setOperators;
+	buildSetOperations(
+		leftSelect: SQL,
+		leftSelection: SelectedFieldsOrdered,
+		ignoreSelectionCastCodecs: boolean | undefined,
+		setOperators: PgSelectConfig['setOperators'],
+	): SQL {
+		const outputSelection = leftSelection;
+		for (let i = 0; i < setOperators.length; ++i) {
+			const setOperator = setOperators[i];
+			if (!setOperator) {
+				throw new Error('Cannot pass undefined values to any set operator');
+			}
 
-		if (!setOperator) {
-			throw new Error('Cannot pass undefined values to any set operator');
+			leftSelect = this.buildSetOperationQuery({ leftSelect, setOperator });
+			const rightSelection = orderSelectedFields(setOperator.rightSelect.getSelectedFields());
+			for (let j = 0; j < outputSelection.length; ++j) {
+				const l = outputSelection[j]!;
+				const lPath = l.path.join('.');
+				const r = rightSelection.find((e) => e.path.join('.') === lPath)!; // Equivalency of selections is a pre-requisite for unions
+
+				const lc = l.codecOverride ?? l.column?.codec;
+				const rc = r.codecOverride ?? r.column?.codec;
+
+				outputSelection[j]!.codecOverride = (lc && rc)
+					? (<Record<string, Record<string, PostgresType>>> unionsTypeTable)[lc]?.[rc]
+					: lc;
+			}
 		}
 
-		if (rest.length === 0) {
-			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		for (let i = 0; i < outputSelection.length; ++i) {
+			const out = outputSelection[i]!;
+			out.codec = out.codecOverride
+				? this.codecs.get(out.column!, 'normalize', out.codecOverride as PostgresType)
+				: out.codec;
 		}
 
-		// Some recursive magic here
-		return this.buildSetOperations(
-			this.buildSetOperationQuery({ leftSelect, setOperator }),
-			rest,
-		);
+		return ignoreSelectionCastCodecs ? leftSelect : sql`select ${
+			this.buildSelection(
+				outputSelection.map((field) => {
+					if (is(field.field, SQL.Aliased)) {
+						const ref = field.field.clone();
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					if (is(field.field, Column) && field.field.isAlias) {
+						const ref = new SQL.Aliased(sql`${sql.identifier(field.field.name)}`, field.field.name);
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					if (is(field.field, Subquery)) {
+						const ref = new SQL.Aliased(sql`${field.field.getSQL()}`, field.field._.alias);
+						ref.isSelectionField = true;
+						return { ...field, field: ref };
+					}
+					return field;
+				}),
+				{
+					isSingleTable: true,
+					ignoreCastCodecs: ignoreSelectionCastCodecs,
+				},
+			)
+		} from (${leftSelect}) ${sql.identifier('drizzle_union')}`;
 	}
 
 	buildSetOperationQuery({
 		leftSelect,
 		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: PgSelectConfig['setOperators'][number] }): SQL {
+	}: {
+		leftSelect: SQL;
+		setOperator: PgSelectConfig['setOperators'][number];
+	}): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
-		const rightChunk = sql`(${rightSelect.getSQL()})`;
+		const rightChunk = sql`(${rightSelect.withoutSelectionCastCodecs().getSQL()})`;
 
 		let orderBySql;
 		if (orderBy && orderBy.length > 0) {
@@ -492,17 +603,30 @@ export class PgDialect {
 		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
-	buildInsertQuery(
-		{ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_ }: PgInsertConfig,
-	): SQL {
+	buildInsertQuery({
+		table,
+		values: valuesOrSelect,
+		onConflict,
+		returning,
+		withList,
+		select,
+		overridingSystemValue_,
+		comment,
+		ignoreSelectionCastCodecs,
+	}: PgInsertConfig): SQL {
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
 		const columns: Record<string, PgColumn> = table[Table.Symbol.Columns];
+		const colEntries: [string, PgColumn][] = Object.entries(columns);
 
-		const colEntries: [string, PgColumn][] = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
+		const colFilteredEntries: [string, PgColumn][] = select && !is(valuesOrSelect, SQL)
+			? Object
+				.keys((valuesOrSelect as TypedQueryBuilder<any>).getSelectedFields())
+				.map((key) => [key, columns[key]] as [string, PgColumn])
+			: overridingSystemValue_
+			? colEntries
+			: colEntries.filter(([_, col]) => !col.shouldDisableInsert());
 
-		const insertOrder = colEntries.map(
-			([, column]) => sql.identifier(this.casing.getColumnCasing(column)),
-		);
+		const insertOrder = colFilteredEntries.map(([, column]) => sql.identifier(column.name));
 
 		if (select) {
 			const select = valuesOrSelect as AnyPgSelectQueryBuilder | SQL;
@@ -518,18 +642,25 @@ export class PgDialect {
 
 			for (const [valueIndex, value] of values.entries()) {
 				const valueList: (SQLChunk | SQL)[] = [];
-				for (const [fieldName, col] of colEntries) {
+				for (const [fieldName, col] of colFilteredEntries) {
 					const colValue = value[fieldName];
-					if (colValue === undefined || (is(colValue, Param) && colValue.value === undefined)) {
+					if (
+						colValue === undefined
+						|| (is(colValue, Param) && colValue.value === undefined)
+					) {
 						// eslint-disable-next-line unicorn/no-negated-condition
 						if (col.defaultFn !== undefined) {
 							const defaultFnResult = col.defaultFn();
-							const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
+							const defaultValue = is(defaultFnResult, SQL)
+								? defaultFnResult
+								: sql.param(defaultFnResult, col);
 							valueList.push(defaultValue);
 							// eslint-disable-next-line unicorn/no-negated-condition
 						} else if (!col.default && col.onUpdateFn !== undefined) {
 							const onUpdateFnResult = col.onUpdateFn();
-							const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
+							const newValue = is(onUpdateFnResult, SQL)
+								? onUpdateFnResult
+								: sql.param(onUpdateFnResult, col);
 							valueList.push(newValue);
 						} else {
 							valueList.push(sql`default`);
@@ -551,876 +682,337 @@ export class PgDialect {
 		const valuesSql = sql.join(valuesSqlList);
 
 		const returningSql = returning
-			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
+			? sql` returning ${
+				this.buildSelection(returning, { isSingleTable: true, ignoreCastCodecs: ignoreSelectionCastCodecs })
+			}`
 			: undefined;
 
-		const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : undefined;
+		const onConflictSql = onConflict
+			? sql` on conflict ${onConflict}`
+			: undefined;
 
-		const overridingSql = overridingSystemValue_ === true ? sql`overriding system value ` : undefined;
+		const overridingSql = overridingSystemValue_ === true
+			? sql`overriding system value `
+			: undefined;
 
-		return sql`${withSql}insert into ${table} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`;
+		return sql`${withSql}insert into ${table} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}${
+			comment !== undefined ? sql` ${comment}` : undefined
+		}`;
 	}
 
-	buildRefreshMaterializedViewQuery(
-		{ view, concurrently, withNoData }: { view: PgMaterializedView; concurrently?: boolean; withNoData?: boolean },
-	): SQL {
+	buildRefreshMaterializedViewQuery({
+		view,
+		concurrently,
+		withNoData,
+	}: {
+		view: PgMaterializedView;
+		concurrently?: boolean;
+		withNoData?: boolean;
+	}): SQL {
 		const concurrentlySql = concurrently ? sql` concurrently` : undefined;
 		const withNoDataSql = withNoData ? sql` with no data` : undefined;
 
 		return sql`refresh materialized view${concurrentlySql} ${view}${withNoDataSql}`;
 	}
 
-	prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue {
-		if (is(encoder, PgJsonb) || is(encoder, PgJson)) {
-			return 'json';
-		} else if (is(encoder, PgNumeric)) {
-			return 'decimal';
-		} else if (is(encoder, PgTime)) {
-			return 'time';
-		} else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
-			return 'timestamp';
-		} else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
-			return 'date';
-		} else if (is(encoder, PgUUID)) {
-			return 'uuid';
-		} else {
-			return 'none';
-		}
-	}
-
-	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): QueryWithTypings {
+	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): Query {
 		return sql.toQuery({
-			casing: this.casing,
 			escapeName: this.escapeName,
 			escapeParam: this.escapeParam,
 			escapeString: this.escapeString,
-			prepareTyping: this.prepareTyping,
+			codecs: this.codecs,
 			invokeSource,
 		});
 	}
+	_sqlToQuery(sql: SQL): Query {
+		return sql.toQuery({
+			escapeName: this.escapeName,
+			escapeParam: this.escapeParam,
+			escapeString: this.escapeString,
+			codecs: this.codecs,
+			tagged: true,
+		});
+	}
+
+	private buildRqbColumn(table: Table | View, field: unknown, key: string, inJson: boolean) {
+		if (is(field, Column)) {
+			const name = sql`${table}.${sql.identifier(field.name)}`;
+			const casted = inJson && (<PgCustomColumn<any>> field).jsonSelectIdentifier
+				? (<PgCustomColumn<any>> field).jsonSelectIdentifier!(name, sql, (<PgCustomColumn<any>> field).dimensions)
+				: this.codecs.apply(field, inJson ? 'castInJson' : 'cast', name);
 
-	// buildRelationalQueryWithPK({
-	// 	fullSchema,
-	// 	schema,
-	// 	tableNamesMap,
-	// 	table,
-	// 	tableConfig,
-	// 	queryConfig: config,
-	// 	tableAlias,
-	// 	isRoot = false,
-	// 	joinOn,
-	// }: {
-	// 	fullSchema: Record<string, unknown>;
-	// 	schema: TablesRelationalConfig;
-	// 	tableNamesMap: Record<string, string>;
-	// 	table: PgTable;
-	// 	tableConfig: TableRelationalConfig;
-	// 	queryConfig: true | DBQueryConfig<'many', true>;
-	// 	tableAlias: string;
-	// 	isRoot?: boolean;
-	// 	joinOn?: SQL;
-	// }): BuildRelationalQueryResult<PgTable, PgColumn> {
-	// 	// For { "<relation>": true }, return a table with selection of all columns
-	// 	if (config === true) {
-	// 		const selectionEntries = Object.entries(tableConfig.columns);
-	// 		const selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = selectionEntries.map((
-	// 			[key, value],
-	// 		) => ({
-	// 			dbKey: value.name,
-	// 			tsKey: key,
-	// 			field: value as PgColumn,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-
-	// 		return {
-	// 			tableTsKey: tableConfig.tsName,
-	// 			sql: table,
-	// 			selection,
-	// 		};
-	// 	}
-
-	// 	// let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
-	// 	// let selectionForBuild = selection;
-
-	// 	const aliasedColumns = Object.fromEntries(
-	// 		Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
-	// 	);
-
-	// 	const aliasedRelations = Object.fromEntries(
-	// 		Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]),
-	// 	);
-
-	// 	const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
-
-	// 	let where, hasUserDefinedWhere;
-	// 	if (config.where) {
-	// 		const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
-	// 		where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-	// 		hasUserDefinedWhere = !!where;
-	// 	}
-	// 	where = and(joinOn, where);
-
-	// 	// const fieldsSelection: { tsKey: string; value: PgColumn | SQL.Aliased; isExtra?: boolean }[] = [];
-	// 	let joins: Join[] = [];
-	// 	let selectedColumns: string[] = [];
-
-	// 	// Figure out which columns to select
-	// 	if (config.columns) {
-	// 		let isIncludeMode = false;
-
-	// 		for (const [field, value] of Object.entries(config.columns)) {
-	// 			if (value === undefined) {
-	// 				continue;
-	// 			}
-
-	// 			if (field in tableConfig.columns) {
-	// 				if (!isIncludeMode && value === true) {
-	// 					isIncludeMode = true;
-	// 				}
-	// 				selectedColumns.push(field);
-	// 			}
-	// 		}
-
-	// 		if (selectedColumns.length > 0) {
-	// 			selectedColumns = isIncludeMode
-	// 				? selectedColumns.filter((c) => config.columns?.[c] === true)
-	// 				: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-	// 		}
-	// 	} else {
-	// 		// Select all columns if selection is not specified
-	// 		selectedColumns = Object.keys(tableConfig.columns);
-	// 	}
-
-	// 	// for (const field of selectedColumns) {
-	// 	// 	const column = tableConfig.columns[field]! as PgColumn;
-	// 	// 	fieldsSelection.push({ tsKey: field, value: column });
-	// 	// }
-
-	// 	let initiallySelectedRelations: {
-	// 		tsKey: string;
-	// 		queryConfig: true | DBQueryConfig<'many', false>;
-	// 		relation: Relation;
-	// 	}[] = [];
-
-	// 	// let selectedRelations: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
-
-	// 	// Figure out which relations to select
-	// 	if (config.with) {
-	// 		initiallySelectedRelations = Object.entries(config.with)
-	// 			.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-	// 			.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-	// 	}
-
-	// 	const manyRelations = initiallySelectedRelations.filter((r) =>
-	// 		is(r.relation, Many)
-	// 		&& (schema[tableNamesMap[r.relation.referencedTable[Table.Symbol.Name]]!]?.primaryKey.length ?? 0) > 0
-	// 	);
-	// 	// If this is the last Many relation (or there are no Many relations), we are on the innermost subquery level
-	// 	const isInnermostQuery = manyRelations.length < 2;
-
-	// 	const selectedExtras: {
-	// 		tsKey: string;
-	// 		value: SQL.Aliased;
-	// 	}[] = [];
-
-	// 	// Figure out which extras to select
-	// 	if (isInnermostQuery && config.extras) {
-	// 		const extras = typeof config.extras === 'function'
-	// 			? config.extras(aliasedFields, { sql })
-	// 			: config.extras;
-	// 		for (const [tsKey, value] of Object.entries(extras)) {
-	// 			selectedExtras.push({
-	// 				tsKey,
-	// 				value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-	// 			});
-	// 		}
-	// 	}
-
-	// 	// Transform `fieldsSelection` into `selection`
-	// 	// `fieldsSelection` shouldn't be used after this point
-	// 	// for (const { tsKey, value, isExtra } of fieldsSelection) {
-	// 	// 	selection.push({
-	// 	// 		dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-	// 	// 		tsKey,
-	// 	// 		field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-	// 	// 		relationTableTsKey: undefined,
-	// 	// 		isJson: false,
-	// 	// 		isExtra,
-	// 	// 		selection: [],
-	// 	// 	});
-	// 	// }
-
-	// 	let orderByOrig = typeof config.orderBy === 'function'
-	// 		? config.orderBy(aliasedFields, orderByOperators)
-	// 		: config.orderBy ?? [];
-	// 	if (!Array.isArray(orderByOrig)) {
-	// 		orderByOrig = [orderByOrig];
-	// 	}
-	// 	const orderBy = orderByOrig.map((orderByValue) => {
-	// 		if (is(orderByValue, Column)) {
-	// 			return aliasedTableColumn(orderByValue, tableAlias) as PgColumn;
-	// 		}
-	// 		return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-	// 	});
-
-	// 	const limit = isInnermostQuery ? config.limit : undefined;
-	// 	const offset = isInnermostQuery ? config.offset : undefined;
-
-	// 	// For non-root queries without additional config except columns, return a table with selection
-	// 	if (
-	// 		!isRoot
-	// 		&& initiallySelectedRelations.length === 0
-	// 		&& selectedExtras.length === 0
-	// 		&& !where
-	// 		&& orderBy.length === 0
-	// 		&& limit === undefined
-	// 		&& offset === undefined
-	// 	) {
-	// 		return {
-	// 			tableTsKey: tableConfig.tsName,
-	// 			sql: table,
-	// 			selection: selectedColumns.map((key) => ({
-	// 				dbKey: tableConfig.columns[key]!.name,
-	// 				tsKey: key,
-	// 				field: tableConfig.columns[key] as PgColumn,
-	// 				relationTableTsKey: undefined,
-	// 				isJson: false,
-	// 				selection: [],
-	// 			})),
-	// 		};
-	// 	}
-
-	// 	const selectedRelationsWithoutPK:
-
-	// 	// Process all relations without primary keys, because they need to be joined differently and will all be on the same query level
-	// 	for (
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			relation,
-	// 		} of initiallySelectedRelations
-	// 	) {
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTable = schema[relationTableTsName]!;
-
-	// 		if (relationTable.primaryKey.length > 0) {
-	// 			continue;
-	// 		}
-
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-	// 		const builtRelation = this.buildRelationalQueryWithoutPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as PgTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 			nestedQueryRelation: relation,
-	// 		});
-	// 		const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
-	// 		joins.push({
-	// 			on: sql`true`,
-	// 			table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: true,
-	// 		});
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelation.selection,
-	// 		});
-	// 	}
-
-	// 	const oneRelations = initiallySelectedRelations.filter((r): r is typeof r & { relation: One } =>
-	// 		is(r.relation, One)
-	// 	);
-
-	// 	// Process all One relations with PKs, because they can all be joined on the same level
-	// 	for (
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			relation,
-	// 		} of oneRelations
-	// 	) {
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const relationTable = schema[relationTableTsName]!;
-
-	// 		if (relationTable.primaryKey.length === 0) {
-	// 			continue;
-	// 		}
-
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-	// 		const builtRelation = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as PgTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationConfigValue,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 		});
-	// 		const field = sql`case when ${sql.identifier(relationTableAlias)} is null then null else json_build_array(${
-	// 			sql.join(
-	// 				builtRelation.selection.map(({ field }) =>
-	// 					is(field, SQL.Aliased)
-	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
-	// 						: is(field, Column)
-	// 						? aliasedTableColumn(field, relationTableAlias)
-	// 						: field
-	// 				),
-	// 				sql`, `,
-	// 			)
-	// 		}) end`.as(selectedRelationTsKey);
-	// 		const isLateralJoin = is(builtRelation.sql, SQL);
-	// 		joins.push({
-	// 			on: isLateralJoin ? sql`true` : joinOn,
-	// 			table: is(builtRelation.sql, SQL)
-	// 				? new Subquery(builtRelation.sql, {}, relationTableAlias)
-	// 				: aliasedTable(builtRelation.sql, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: is(builtRelation.sql, SQL),
-	// 		});
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelation.selection,
-	// 		});
-	// 	}
-
-	// 	let distinct: PgSelectConfig['distinct'];
-	// 	let tableFrom: PgTable | Subquery = table;
-
-	// 	// Process first Many relation - each one requires a nested subquery
-	// 	const manyRelation = manyRelations[0];
-	// 	if (manyRelation) {
-	// 		const {
-	// 			tsKey: selectedRelationTsKey,
-	// 			queryConfig: selectedRelationQueryConfig,
-	// 			relation,
-	// 		} = manyRelation;
-
-	// 		distinct = {
-	// 			on: tableConfig.primaryKey.map((c) => aliasedTableColumn(c as PgColumn, tableAlias)),
-	// 		};
-
-	// 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-	// 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
-	// 		const relationTableTsName = tableNamesMap[relationTableName]!;
-	// 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-	// 		const joinOn = and(
-	// 			...normalizedRelation.fields.map((field, i) =>
-	// 				eq(
-	// 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-	// 					aliasedTableColumn(field, tableAlias),
-	// 				)
-	// 			),
-	// 		);
-
-	// 		const builtRelationJoin = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table: fullSchema[relationTableTsName] as PgTable,
-	// 			tableConfig: schema[relationTableTsName]!,
-	// 			queryConfig: selectedRelationQueryConfig,
-	// 			tableAlias: relationTableAlias,
-	// 			joinOn,
-	// 		});
-
-	// 		const builtRelationSelectionField = sql`case when ${
-	// 			sql.identifier(relationTableAlias)
-	// 		} is null then '[]' else json_agg(json_build_array(${
-	// 			sql.join(
-	// 				builtRelationJoin.selection.map(({ field }) =>
-	// 					is(field, SQL.Aliased)
-	// 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
-	// 						: is(field, Column)
-	// 						? aliasedTableColumn(field, relationTableAlias)
-	// 						: field
-	// 				),
-	// 				sql`, `,
-	// 			)
-	// 		})) over (partition by ${sql.join(distinct.on, sql`, `)}) end`.as(selectedRelationTsKey);
-	// 		const isLateralJoin = is(builtRelationJoin.sql, SQL);
-	// 		joins.push({
-	// 			on: isLateralJoin ? sql`true` : joinOn,
-	// 			table: isLateralJoin
-	// 				? new Subquery(builtRelationJoin.sql as SQL, {}, relationTableAlias)
-	// 				: aliasedTable(builtRelationJoin.sql as PgTable, relationTableAlias),
-	// 			alias: relationTableAlias,
-	// 			joinType: 'left',
-	// 			lateral: isLateralJoin,
-	// 		});
-
-	// 		// Build the "from" subquery with the remaining Many relations
-	// 		const builtTableFrom = this.buildRelationalQueryWithPK({
-	// 			fullSchema,
-	// 			schema,
-	// 			tableNamesMap,
-	// 			table,
-	// 			tableConfig,
-	// 			queryConfig: {
-	// 				...config,
-	// 				where: undefined,
-	// 				orderBy: undefined,
-	// 				limit: undefined,
-	// 				offset: undefined,
-	// 				with: manyRelations.slice(1).reduce<NonNullable<typeof config['with']>>(
-	// 					(result, { tsKey, queryConfig: configValue }) => {
-	// 						result[tsKey] = configValue;
-	// 						return result;
-	// 					},
-	// 					{},
-	// 				),
-	// 			},
-	// 			tableAlias,
-	// 		});
-
-	// 		selectedRelations.push({
-	// 			dbKey: selectedRelationTsKey,
-	// 			tsKey: selectedRelationTsKey,
-	// 			field: builtRelationSelectionField,
-	// 			relationTableTsKey: relationTableTsName,
-	// 			isJson: true,
-	// 			selection: builtRelationJoin.selection,
-	// 		});
-
-	// 		// selection = builtTableFrom.selection.map((item) =>
-	// 		// 	is(item.field, SQL.Aliased)
-	// 		// 		? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
-	// 		// 		: item
-	// 		// );
-	// 		// selectionForBuild = [{
-	// 		// 	dbKey: '*',
-	// 		// 	tsKey: '*',
-	// 		// 	field: sql`${sql.identifier(tableAlias)}.*`,
-	// 		// 	selection: [],
-	// 		// 	isJson: false,
-	// 		// 	relationTableTsKey: undefined,
-	// 		// }];
-	// 		// const newSelectionItem: (typeof selection)[number] = {
-	// 		// 	dbKey: selectedRelationTsKey,
-	// 		// 	tsKey: selectedRelationTsKey,
-	// 		// 	field,
-	// 		// 	relationTableTsKey: relationTableTsName,
-	// 		// 	isJson: true,
-	// 		// 	selection: builtRelationJoin.selection,
-	// 		// };
-	// 		// selection.push(newSelectionItem);
-	// 		// selectionForBuild.push(newSelectionItem);
-
-	// 		tableFrom = is(builtTableFrom.sql, PgTable)
-	// 			? builtTableFrom.sql
-	// 			: new Subquery(builtTableFrom.sql, {}, tableAlias);
-	// 	}
-
-	// 	if (selectedColumns.length === 0 && selectedRelations.length === 0 && selectedExtras.length === 0) {
-	// 		throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
-	// 	}
-
-	// 	let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'];
-
-	// 	function prepareSelectedColumns() {
-	// 		return selectedColumns.map((key) => ({
-	// 			dbKey: tableConfig.columns[key]!.name,
-	// 			tsKey: key,
-	// 			field: tableConfig.columns[key] as PgColumn,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-	// 	}
-
-	// 	function prepareSelectedExtras() {
-	// 		return selectedExtras.map((item) => ({
-	// 			dbKey: item.value.fieldAlias,
-	// 			tsKey: item.tsKey,
-	// 			field: item.value,
-	// 			relationTableTsKey: undefined,
-	// 			isJson: false,
-	// 			selection: [],
-	// 		}));
-	// 	}
-
-	// 	if (isRoot) {
-	// 		selection = [
-	// 			...prepareSelectedColumns(),
-	// 			...prepareSelectedExtras(),
-	// 		];
-	// 	}
-
-	// 	if (hasUserDefinedWhere || orderBy.length > 0) {
-	// 		tableFrom = new Subquery(
-	// 			this.buildSelectQuery({
-	// 				table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
-	// 				fields: {},
-	// 				fieldsFlat: selectionForBuild.map(({ field }) => ({
-	// 					path: [],
-	// 					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-	// 				})),
-	// 				joins,
-	// 				distinct,
-	// 			}),
-	// 			{},
-	// 			tableAlias,
-	// 		);
-	// 		selectionForBuild = selection.map((item) =>
-	// 			is(item.field, SQL.Aliased)
-	// 				? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
-	// 				: item
-	// 		);
-	// 		joins = [];
-	// 		distinct = undefined;
-	// 	}
-
-	// 	const result = this.buildSelectQuery({
-	// 		table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
-	// 		fields: {},
-	// 		fieldsFlat: selectionForBuild.map(({ field }) => ({
-	// 			path: [],
-	// 			field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-	// 		})),
-	// 		where,
-	// 		limit,
-	// 		offset,
-	// 		joins,
-	// 		orderBy,
-	// 		distinct,
-	// 	});
-
-	// 	return {
-	// 		tableTsKey: tableConfig.tsName,
-	// 		sql: result,
-	// 		selection,
-	// 	};
-	// }
-
-	buildRelationalQueryWithoutPK({
-		fullSchema,
+			return sql`${casted} as ${sql.identifier(key)}`;
+		}
+
+		if (is(field, SQL.Aliased)) {
+			const column = getColumnFromDecoder(field);
+			const q = sql`${table}.${sql.identifier(field.fieldAlias)}`;
+			return sql`${column ? this.codecs.apply(column, inJson ? 'castInJson' : 'cast', q) : q} as ${
+				sql.identifier(key)
+			}`;
+		}
+
+		if (isSQLWrapper(field)) {
+			const column = getColumnFromDecoder(field);
+			const q = sql`${table}.${sql.identifier(key)}`;
+			return sql`${column ? this.codecs.apply(column, inJson ? 'castInJson' : 'cast', q) : q} as ${
+				sql.identifier(key)
+			}`;
+		}
+
+		throw new DrizzleError({
+			message: `Views with nested selections are not supported by the relational query builder`,
+		});
+	}
+
+	private resolveSelection(field: unknown, key: string, inJson: boolean) {
+		if (is(field, Column)) {
+			return {
+				key,
+				field: field,
+				codec: this.codecs.get(field, inJson ? 'normalizeInJson' : 'normalize'),
+				arrayDimensions: (<PgColumn> field).dimensions,
+			};
+		}
+
+		const decoderColumn = getColumnFromDecoder(field as SQL | SQLWrapper | SQL.Aliased);
+		return decoderColumn
+			? {
+				key,
+				field: field as SQL | SQLWrapper | SQL.Aliased,
+				codec: decoderColumn && (!inJson || !(<PgCustomColumn<any>> decoderColumn).mapFromJsonValue)
+					? this.codecs.get(decoderColumn, inJson ? 'normalizeInJson' : 'normalize')
+					: undefined,
+				arrayDimensions: (<PgColumn> decoderColumn).dimensions,
+			}
+			: {
+				key,
+				field: field as SQL | SQLWrapper | SQL.Aliased,
+			};
+	}
+
+	private buildColumns = (
+		table: Table | View,
+		selection: BuildRelationalQueryResult['selection'],
+		inJson: boolean,
+		config?: DBQueryConfigWithComment<'many'>,
+	) => {
+		if (!config?.columns) {
+			return sql.join(
+				Object.entries(table[TableColumns]).map(([k, v]) => {
+					selection.push(this.resolveSelection(v, k, inJson));
+
+					return this.buildRqbColumn(table, v, k, inJson);
+				}),
+				sql`, `,
+			);
+		}
+
+		const entries = Object.entries(config.columns);
+		const columnContainer: Record<string, unknown> = table[TableColumns];
+
+		const columnIdentifiers: SQL[] = [];
+		let colSelectionMode: boolean | undefined;
+		for (const [k, v] of entries) {
+			if (v === undefined) continue;
+			colSelectionMode = colSelectionMode || v;
+
+			if (v) {
+				const column = columnContainer[k];
+				columnIdentifiers.push(this.buildRqbColumn(table, column, k, inJson));
+
+				selection.push(this.resolveSelection(column, k, inJson));
+			}
+		}
+
+		if (colSelectionMode === false) {
+			for (const [k, v] of Object.entries(columnContainer)) {
+				if (config.columns[k] === false) continue;
+				columnIdentifiers.push(this.buildRqbColumn(table, v, k, inJson));
+
+				selection.push(this.resolveSelection(v, k, inJson));
+			}
+		}
+
+		return columnIdentifiers.length
+			? sql.join(columnIdentifiers, sql`, `)
+			: undefined;
+	};
+
+	buildRelationalQuery({
 		schema,
-		tableNamesMap,
 		table,
 		tableConfig,
 		queryConfig: config,
-		tableAlias,
-		nestedQueryRelation,
-		joinOn,
+		relationWhere,
+		mode,
+		errorPath,
+		depth,
+		throughJoin,
+		nested,
 	}: {
-		fullSchema: Record<string, unknown>;
 		schema: TablesRelationalConfig;
-		tableNamesMap: Record<string, string>;
-		table: PgTable;
+		table: PgTable | PgView;
 		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
-		tableAlias: string;
-		nestedQueryRelation?: Relation;
-		joinOn?: SQL;
-	}): BuildRelationalQueryResult<PgTable, PgColumn> {
-		let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
-		let limit, offset, orderBy: NonNullable<PgSelectConfig['orderBy']> = [], where;
-		const joins: PgSelectJoinConfig[] = [];
-
-		if (config === true) {
-			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
-				dbKey: value.name,
-				tsKey: key,
-				field: aliasedTableColumn(value as PgColumn, tableAlias),
-				relationTableTsKey: undefined,
-				isJson: false,
-				selection: [],
-			}));
-		} else {
-			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map((
-					[key, value],
-				) => [key, aliasedTableColumn(value, tableAlias)]),
-			);
-
-			if (config.where) {
-				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
-					: config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
+		queryConfig?: DBQueryConfigWithComment<'many'> | true;
+		relationWhere?: SQL;
+		mode: 'first' | 'many';
+		errorPath?: string;
+		depth?: number;
+		throughJoin?: SQL;
+		nested?: boolean;
+	}): BuildRelationalQueryResult {
+		const selection: BuildRelationalQueryResult['selection'] = [];
+		const isSingle = mode === 'first';
+		const params = config === true ? undefined : config;
+		const currentPath = errorPath ?? '';
+		const currentDepth = depth ?? 0;
+		if (!currentDepth) table = aliasedTable(table, `d${currentDepth}`);
+
+		const limit = isSingle ? 1 : params?.limit;
+		const offset = params?.offset;
+
+		const where: SQL | undefined = params?.where && relationWhere
+			? and(
+				relationsFilterToSQL(
+					table,
+					params.where,
+					tableConfig.relations,
+					schema,
+				),
+				relationWhere,
+			)
+			: params?.where
+			? relationsFilterToSQL(
+				table,
+				params.where,
+				tableConfig.relations,
+				schema,
+			)
+			: relationWhere;
 
-			const fieldsSelection: { tsKey: string; value: PgColumn | SQL.Aliased }[] = [];
-			let selectedColumns: string[] = [];
+		const order = params?.orderBy
+			? relationsOrderToSQL(table, params.orderBy)
+			: undefined;
+		const columns = this.buildColumns(table, selection, !!nested, params);
+		const extras = params?.extras
+			? relationExtrasToSQL(table, params.extras, this.codecs, nested)
+			: undefined;
+		if (extras) selection.push(...extras.selection);
 
-			// Figure out which columns to select
-			if (config.columns) {
-				let isIncludeMode = false;
+		const selectionArr: SQL[] = columns ? [columns] : [];
+		if (extras?.sql) selectionArr.push(extras.sql);
 
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === undefined) {
-						continue;
-					}
+		const joins = params
+			? (() => {
+				const { with: joins } = params as WithContainer;
+				if (!joins) return;
 
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) {
-							isIncludeMode = true;
-						}
-						selectedColumns.push(field);
-					}
-				}
+				const withEntries = Object.entries(joins).filter(([_, v]) => v);
+				if (!withEntries.length) return;
 
-				if (selectedColumns.length > 0) {
-					selectedColumns = isIncludeMode
-						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
-				}
-			} else {
-				// Select all columns if selection is not specified
-				selectedColumns = Object.keys(tableConfig.columns);
-			}
+				return sql.join(
+					withEntries.map(([k, join]) => {
+						// if (is(tableConfig.relations[k]!, AggregatedField)) {
+						// 	const relation = tableConfig.relations[k]!;
 
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as PgColumn;
-				fieldsSelection.push({ tsKey: field, value: column });
-			}
+						// 	relation.onTable(table);
+						// 	const query = relation.getSQL();
 
-			let selectedRelations: {
-				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
-			}[] = [];
-
-			// Figure out which relations to select
-			if (config.with) {
-				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-			}
+						// 	selection.push({
+						// 		key: k,
+						// 		field: relation,
+						// 	});
 
-			let extras;
-
-			// Figure out which extras to select
-			if (config.extras) {
-				extras = typeof config.extras === 'function'
-					? config.extras(aliasedColumns, { sql })
-					: config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) {
-					fieldsSelection.push({
-						tsKey,
-						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-					});
-				}
-			}
+						// 	selectionArr.push(sql`${sql.identifier(k)}.${sql.identifier('r')} as ${sql.identifier(k)}`);
 
-			// Transform `fieldsSelection` into `selection`
-			// `fieldsSelection` shouldn't be used after this point
-			for (const { tsKey, value } of fieldsSelection) {
-				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-					relationTableTsKey: undefined,
-					isJson: false,
-					selection: [],
-				});
-			}
+						// 	return sql`left join lateral(${query}) as ${sql.identifier(k)} on true`;
+						// }
 
-			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) {
-				orderByOrig = [orderByOrig];
-			}
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as PgColumn;
-				}
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
+						const relation = tableConfig.relations[k]! as Relation;
+						const isSingle = is(relation, One);
+						const targetTable = aliasedTable(
+							relation.targetTable,
+							`d${currentDepth + 1}`,
+						);
+						const throughTable = relation.throughTable
+							? (aliasedTable(relation.throughTable, `tr${currentDepth}`) as
+								| Table
+								| View)
+							: undefined;
+						const { filter, joinCondition } = relationToSQL(
+							relation,
+							table,
+							targetTable,
+							throughTable,
+						);
 
-			limit = config.limit;
-			offset = config.offset;
+						selectionArr.push(
+							sql`${sql.identifier(k)}.${sql.identifier('r')} as ${sql.identifier(k)}`,
+						);
 
-			// Process all relations
-			for (
-				const {
-					tsKey: selectedRelationTsKey,
-					queryConfig: selectedRelationConfigValue,
-					relation,
-				} of selectedRelations
-			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableName = getTableUniqueName(relation.referencedTable);
-				const relationTableTsName = tableNamesMap[relationTableName]!;
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				const joinOn = and(
-					...normalizedRelation.fields.map((field, i) =>
-						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-							aliasedTableColumn(field, tableAlias),
-						)
-					),
+						const throughJoin = throughTable
+							? sql` inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition!}`
+							: undefined;
+
+						const innerQuery = this.buildRelationalQuery({
+							table: targetTable as PgTable | PgView,
+							mode: isSingle ? 'first' : 'many',
+							schema,
+							queryConfig: join as DBQueryConfigWithComment,
+							tableConfig: schema[relation.targetTableName]!,
+							relationWhere: filter,
+							errorPath: `${currentPath.length ? `${currentPath}.` : ''}${k}`,
+							depth: currentDepth + 1,
+							throughJoin,
+							nested: true,
+						});
+
+						selection.push({
+							field: targetTable,
+							key: k,
+							selection: innerQuery.selection,
+							isArray: !isSingle,
+							isOptional: ((relation as AnyOne).optional ?? false)
+								|| (join !== true
+									&& !!(join as Exclude<typeof join, boolean | undefined>)
+										.where),
+						});
+
+						const joinQuery = sql`left join lateral(select ${
+							isSingle
+								? sql`row_to_json(${sql.identifier('t')}.*) ${sql.identifier('r')}`
+								: sql`coalesce(json_agg(row_to_json(${sql.identifier('t')}.*)), '[]') as ${sql.identifier('r')}`
+						} from (${innerQuery.sql}) as ${sql.identifier('t')}) as ${sql.identifier(k)} on true`;
+
+						return joinQuery;
+					}),
+					sql` `,
 				);
-				const builtRelation = this.buildRelationalQueryWithoutPK({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName] as PgTable,
-					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
-							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
-						: selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation,
-				});
-				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
-				joins.push({
-					on: sql`true`,
-					table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
-					alias: relationTableAlias,
-					joinType: 'left',
-					lateral: true,
-				});
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection,
-				});
-			}
-		}
-
-		if (selection.length === 0) {
-			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
-		}
-
-		let result;
-
-		where = and(joinOn, where);
-
-		if (nestedQueryRelation) {
-			let field = sql`json_build_array(${
-				sql.join(
-					selection.map(({ field, tsKey, isJson }) =>
-						isJson
-							? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier('data')}`
-							: is(field, SQL.Aliased)
-							? field.sql
-							: field
-					),
-					sql`, `,
-				)
-			})`;
-			if (is(nestedQueryRelation, Many)) {
-				field = sql`coalesce(json_agg(${field}${
-					orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : undefined
-				}), '[]'::json)`;
-				// orderBy = [];
-			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field: field.as('data'),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
-
-			const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
-
-			if (needsSubquery) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [{
-						path: [],
-						field: sql.raw('*'),
-					}],
-					where,
-					limit,
-					offset,
-					orderBy,
-					setOperators: [],
-				});
-
-				where = undefined;
-				limit = undefined;
-				offset = undefined;
-				orderBy = [];
-			} else {
-				result = aliasedTable(table, tableAlias);
-			}
+			})()
+			: undefined;
 
-			result = this.buildSelectQuery({
-				table: is(result, PgTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		} else {
-			result = this.buildSelectQuery({
-				table: aliasedTable(table, tableAlias),
-				fields: {},
-				fieldsFlat: selection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
+		if (!selectionArr.length) {
+			throw new DrizzleError({
+				message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ''}`,
 			});
 		}
+		const selectionSet = sql.join(
+			selectionArr.filter((e) => e !== undefined),
+			sql`, `,
+		);
+		const comment = config !== true && config?.comment
+			? sql.comment(config.comment)
+			: undefined;
+
+		const query = sql`select ${selectionSet} from ${getTableAsAliasSQL(table)}${throughJoin}${
+			joins ? sql` ${joins}` : undefined
+		}${where ? sql` where ${where}` : undefined}${order ? sql` order by ${order}` : undefined}${
+			limit !== undefined ? sql` limit ${limit}` : undefined
+		}${offset !== undefined ? sql` offset ${offset}` : undefined}${comment ? sql` ${comment}` : undefined}`;
 
 		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
+			sql: query,
 			selection,
 		};
 	}
diff --git a/drizzle-orm/src/pg-core/effect/count.ts b/drizzle-orm/src/pg-core/effect/count.ts
new file mode 100644
index 0000000000..10a867c947
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/count.ts
@@ -0,0 +1,51 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { PgDialect } from '../dialect.ts';
+import { PgCountBuilder } from '../query-builders/count.ts';
+import type { PgTable } from '../table.ts';
+import type { PgViewBase } from '../view-base.ts';
+import type { PgEffectSession } from './session.ts';
+
+export interface PgEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends PgCountBuilder, Effect.Effect<number, TEffectHKT['error'], TEffectHKT['context']>
+{}
+
+export class PgEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgCountBuilder {
+	static override readonly [entityKind]: string = 'PgEffectCountBuilder';
+
+	protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	constructor(
+		{ source, dialect, filters, session }: {
+			source: PgTable | PgViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: PgDialect;
+			session: PgEffectSession<TEffectHKT, any, any>;
+		},
+	) {
+		super({ source, dialect, filters });
+		this.session = session;
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.session.prepareQuery<{
+			execute: number;
+			objects: unknown;
+			arrays: unknown;
+			raw: unknown;
+		}>(
+			this.build(),
+			'arrays',
+			false,
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(PgEffectCountBuilder);
diff --git a/drizzle-orm/src/pg-core/effect/db.ts b/drizzle-orm/src/pg-core/effect/db.ts
new file mode 100644
index 0000000000..f0e1ccddaa
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/db.ts
@@ -0,0 +1,705 @@
+import { Effect } from 'effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { MutationOption } from '~/cache/core/cache.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import { PgEffectCountBuilder } from '~/pg-core/effect/count.ts';
+import { PgEffectInsertBase, type PgEffectInsertHKT } from '~/pg-core/effect/insert.ts';
+import { PgEffectSelectBase, type PgEffectSelectBuilder } from '~/pg-core/effect/select.ts';
+import { PgInsertBuilder } from '~/pg-core/query-builders/insert.ts';
+import { RelationalQueryBuilder } from '~/pg-core/query-builders/query.ts';
+import { PgSelectBuilder } from '~/pg-core/query-builders/select.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { PgViewBase } from '~/pg-core/view-base.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { PgColumn } from '../columns/common.ts';
+import { QueryBuilder } from '../query-builders/query-builder.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import { PgUpdateBuilder } from '../query-builders/update.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '../session.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { PgMaterializedView } from '../view.ts';
+import { PgEffectDeleteBase } from './delete.ts';
+import { PgEffectRelationalQuery, type PgEffectRelationalQueryHKT } from './query.ts';
+import { PgEffectRaw } from './raw.ts';
+import { PgEffectRefreshMaterializedView } from './refresh-materialized-view.ts';
+import type { PgEffectSession, PgEffectTransaction } from './session.ts';
+import { PgEffectUpdateBase, type PgEffectUpdateHKT } from './update.ts';
+
+export class PgEffectDatabase<
+	TEffectHKT extends QueryEffectHKTBase,
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'EffectPgDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: PgEffectSession<TEffectHKT, TQueryResult, TRelations>;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TRelations,
+			TRelations[K],
+			PgEffectRelationalQueryHKT<TEffectHKT>
+		>;
+	};
+
+	constructor(
+		/** @internal */
+		readonly dialect: PgDialect,
+		/** @internal */
+		readonly session: PgEffectSession<TEffectHKT, any, any>,
+		relations: TRelations,
+		parseRqbJson: boolean = false,
+	) {
+		this._ = {
+			relations: relations,
+			session,
+		};
+
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as PgEffectDatabase<
+				TEffectHKT,
+				TQueryResult,
+				AnyRelations
+			>['query'])[tableName] = new RelationalQueryBuilder(
+				relations,
+				relations[relation.name]!.table as PgTable,
+				relation,
+				dialect,
+				session,
+				parseRqbJson,
+				PgEffectRelationalQuery,
+			);
+		}
+
+		this.$cache = {
+			invalidate: (_params: MutationOption) => Effect.void,
+		};
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = yield* db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(this.dialect));
+			}
+
+			const sql = ('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL();
+			return new Proxy(
+				new WithSubquery(
+					sql,
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+					sql.usedTables ?? [],
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$cache: { invalidate: EffectCacheShape['onMutate'] };
+
+	$count(
+		source: PgTable | PgViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	) {
+		return new PgEffectCountBuilder({ source, filters, session: this.session, dialect: this.dialect });
+	}
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = yield* db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): PgEffectSelectBuilder<undefined, TEffectHKT>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+		function select<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): PgEffectSelectBuilder<TSelection | undefined, TEffectHKT> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			}, PgEffectSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * yield* db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * yield* db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): PgEffectSelectBuilder<undefined, TEffectHKT>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields?: TSelection,
+		): PgEffectSelectBuilder<TSelection | undefined, TEffectHKT> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			}, PgEffectSelectBase);
+		}
+
+		/**
+		 * Adds `distinct on` expression to the select query.
+		 *
+		 * Calling this method will specify how the unique rows are determined.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param on The expression defining uniqueness.
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 * ```ts
+		 * // Select the first row for each unique brand from the 'cars' table
+		 * yield* db.selectDistinctOn([cars.brand])
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 *
+		 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+		 * yield* db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand, cars.color);
+		 * ```
+		 */
+		function selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgEffectSelectBuilder<undefined, TEffectHKT>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (PgColumn | SQLWrapper)[],
+			fields: TSelection,
+		): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+		function selectDistinctOn<TSelection extends SelectedFields>(
+			on: (PgColumn | SQLWrapper)[],
+			fields?: TSelection,
+		): PgEffectSelectBuilder<TSelection | undefined, TEffectHKT> {
+			return new PgSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: { on },
+			}, PgEffectSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * yield* db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 *
+		 * // Update with returning clause
+		 * const updatedCar: Car[] = yield* db.update(cars)
+		 *   .set({ color: 'red' })
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function update<TTable extends PgTable>(
+			table: TTable,
+		): PgUpdateBuilder<TTable, TQueryResult, PgEffectUpdateHKT<TEffectHKT>> {
+			return new PgUpdateBuilder(table, self.session, self.dialect, queries, PgEffectUpdateBase);
+		}
+
+		/**
+		 * Creates an insert query.
+		 *
+		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/insert}
+		 *
+		 * @param table The table to insert into.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Insert one row
+		 * yield* db.insert(cars).values({ brand: 'BMW' });
+		 *
+		 * // Insert multiple rows
+		 * yield* db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+		 *
+		 * // Insert with returning clause
+		 * const insertedCar: Car[] = yield* db.insert(cars)
+		 *   .values({ brand: 'BMW' })
+		 *   .returning();
+		 * ```
+		 */
+		function insert<TTable extends PgTable>(
+			table: TTable,
+		): PgInsertBuilder<TTable, TQueryResult, false, PgEffectInsertHKT<TEffectHKT>> {
+			return new PgInsertBuilder(table, self.session, self.dialect, queries, undefined, PgEffectInsertBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * yield* db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+		 *
+		 * // Delete with returning clause
+		 * const deletedCar: Car[] = yield* db.delete(cars)
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function delete_<TTable extends PgTable>(
+			table: TTable,
+		): PgEffectDeleteBase<TTable, TQueryResult, undefined, undefined, false, never, TEffectHKT> {
+			return new PgEffectDeleteBase(table, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = yield* db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): PgEffectSelectBuilder<undefined, TEffectHKT>;
+	select<TSelection extends SelectedFields>(fields: TSelection): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+	select<TSelection extends SelectedFields | undefined>(
+		fields?: TSelection,
+	): PgEffectSelectBuilder<TSelection, TEffectHKT> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+		}, PgEffectSelectBase) as PgEffectSelectBuilder<TSelection, TEffectHKT>;
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * yield* db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * yield* db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): PgEffectSelectBuilder<undefined, TEffectHKT>;
+	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+	selectDistinct<TSelection extends SelectedFields | undefined>(
+		fields?: TSelection,
+	): PgEffectSelectBuilder<TSelection | undefined, TEffectHKT> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		}, PgEffectSelectBase);
+	}
+
+	/**
+	 * Adds `distinct on` expression to the select query.
+	 *
+	 * Calling this method will specify how the unique rows are determined.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param on The expression defining uniqueness.
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 * ```ts
+	 * // Select the first row for each unique brand from the 'cars' table
+	 * yield* db.selectDistinctOn([cars.brand])
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 *
+	 * // Selects the first occurrence of each unique car brand along with its color from the 'cars' table
+	 * yield* db.selectDistinctOn([cars.brand], { brand: cars.brand, color: cars.color })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand, cars.color);
+	 * ```
+	 */
+	selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgEffectSelectBuilder<undefined, TEffectHKT>;
+	selectDistinctOn<TSelection extends SelectedFields>(
+		on: (PgColumn | SQLWrapper)[],
+		fields: TSelection,
+	): PgEffectSelectBuilder<TSelection, TEffectHKT>;
+	selectDistinctOn<TSelection extends SelectedFields | undefined>(
+		on: (PgColumn | SQLWrapper)[],
+		fields?: TSelection,
+	): PgEffectSelectBuilder<TSelection, TEffectHKT> {
+		return new PgSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: { on },
+		}, PgEffectSelectBase) as PgEffectSelectBuilder<TSelection, TEffectHKT>;
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * yield* db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 *
+	 * // Update with returning clause
+	 * const updatedCar: Car[] = yield* db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, TQueryResult, PgEffectUpdateHKT<TEffectHKT>> {
+		return new PgUpdateBuilder(table, this.session, this.dialect, undefined, PgEffectUpdateBase);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * yield* db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * yield* db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 *
+	 * // Insert with returning clause
+	 * const insertedCar: Car[] = yield* db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 * ```
+	 */
+	insert<TTable extends PgTable>(
+		table: TTable,
+	): PgInsertBuilder<TTable, TQueryResult, false, PgEffectInsertHKT<TEffectHKT>> {
+		return new PgInsertBuilder(table, this.session, this.dialect, undefined, undefined, PgEffectInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * yield* db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+	 *
+	 * // Delete with returning clause
+	 * const deletedCar: Car[] = yield* db.delete(cars)
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	delete<TTable extends PgTable>(
+		table: TTable,
+	): PgEffectDeleteBase<TTable, TQueryResult, undefined, undefined, false, never, TEffectHKT> {
+		return new PgEffectDeleteBase(table, this.session, this.dialect);
+	}
+
+	refreshMaterializedView<TView extends PgMaterializedView>(
+		view: TView,
+	): PgEffectRefreshMaterializedView<TQueryResult, TEffectHKT> {
+		return new PgEffectRefreshMaterializedView(view, this.session, this.dialect);
+	}
+
+	execute<TRow extends Record<string, unknown>>(
+		query: SQLWrapper | string,
+	): PgEffectRaw<PgQueryResultKind<TQueryResult, TRow>, TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: PgQueryResultKind<TQueryResult, TRow> }
+		>(
+			builtQuery,
+			'raw',
+			false,
+		);
+		return new PgEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	transaction<A, E, R>(
+		transaction: (
+			tx: PgEffectTransaction<TEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction);
+	}
+}
+
+export type PgEffectWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	TEffectHKT extends QueryEffectHKTBase,
+	HKT extends PgQueryResultHKT,
+	TRelations extends AnyRelations,
+	Q extends PgEffectDatabase<TEffectHKT, HKT, TRelations>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): PgEffectWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const selectDistinctOn: Q['selectDistinctOn'] = (...args: [any]) => getReplica(replicas).selectDistinctOn(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const _with: Q['with'] = (...args: any) => getReplica(replicas).with(...args);
+	const $with: Q['$with'] = (arg: any) => getReplica(replicas).$with(arg) as any;
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const execute: Q['execute'] = (...args: [any]) => primary.execute(...args);
+	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
+	const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: [any]) =>
+		primary.refreshMaterializedView(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		execute,
+		transaction,
+		refreshMaterializedView,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		selectDistinctOn,
+		$count,
+		$with,
+		with: _with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/pg-core/effect/delete.ts b/drizzle-orm/src/pg-core/effect/delete.ts
new file mode 100644
index 0000000000..c514b98ef3
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/delete.ts
@@ -0,0 +1,125 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+import { PgDeleteBase, type PgDeleteHKTBase } from '../query-builders/delete.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+export type PgEffectDelete<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectDeleteBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never, TEffectHKT>;
+
+export type PgEffectDeletePrepare<
+	T extends AnyEffectPgDelete,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	},
+	TEffectHKT
+>;
+
+export type AnyEffectPgDelete = PgEffectDeleteBase<any, any, any, any, any, any, any>;
+
+export interface PgEffectDeleteHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgDeleteHKTBase {
+	_type: PgEffectDeleteBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export interface PgEffectDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends
+	Effect.Effect<
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[],
+		TEffectHKT['error'],
+		TEffectHKT['context']
+	>
+{}
+
+export class PgEffectDeleteBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgDeleteBase<
+	PgEffectDeleteHKT<TEffectHKT>,
+	TTable,
+	TQueryResult,
+	TSelectedFields,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
+	SQLWrapper
+{
+	static override readonly [entityKind]: string = 'PgEffectDelete';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgEffectDeletePrepare<this, TEffectHKT> {
+		const { session, config, dialect } = this;
+		const { returning: fields } = config;
+
+		const query = dialect.sqlToQuery(this.getSQL());
+		const mapper = fields
+			? this.dialect.mapperGenerators.rows(fields, undefined)
+			: undefined;
+
+		const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+			query,
+			fields ? 'arrays' : 'raw',
+			name ?? generateName,
+			mapper,
+			{ type: 'delete', tables: [...extractUsedTable(this.config.table)] },
+		);
+
+		return preparedQuery;
+	}
+
+	prepare(name?: string): PgEffectDeletePrepare<this, TEffectHKT> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(PgEffectDeleteBase);
diff --git a/drizzle-orm/src/pg-core/effect/index.ts b/drizzle-orm/src/pg-core/effect/index.ts
new file mode 100644
index 0000000000..df9a52006a
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/index.ts
@@ -0,0 +1,11 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './refresh-materialized-view.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
+export * from './utils.ts';
diff --git a/drizzle-orm/src/pg-core/effect/insert.ts b/drizzle-orm/src/pg-core/effect/insert.ts
new file mode 100644
index 0000000000..983d41bcd6
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/insert.ts
@@ -0,0 +1,122 @@
+import * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+import type { PgInsertHKTBase } from '../query-builders/insert.ts';
+import { PgInsertBase } from '../query-builders/insert.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+export interface PgEffectInsertHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgInsertHKTBase {
+	_type: PgEffectInsertBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		this['selectedFields'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnyPgEffectInsert = PgEffectInsertBase<any, any, any, any, any, any>;
+
+export type PgInsertPrepare<
+	T extends AnyPgEffectInsert,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	},
+	TEffectHKT
+>;
+
+export type PgInsert<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = ColumnsSelection | undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgInsertBase<PgEffectInsertHKT<TEffectHKT>, TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+
+export interface PgEffectInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends
+	Effect.Effect<
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[],
+		TEffectHKT['error'],
+		TEffectHKT['context']
+	>
+{
+}
+
+export class PgEffectInsertBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgInsertBase<
+	PgEffectInsertHKT<TEffectHKT>,
+	TTable,
+	TQueryResult,
+	TSelectedFields,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'> {
+	static override readonly [entityKind]: string = 'PgEffectInsert';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgInsertPrepare<this, TEffectHKT> {
+		const { session, config, dialect } = this;
+		const { returning: fields } = config;
+
+		const query = dialect.sqlToQuery(this.getSQL());
+		const mapper = fields
+			? this.dialect.mapperGenerators.rows(fields, undefined)
+			: undefined;
+
+		const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+			query,
+			fields ? 'arrays' : 'raw',
+			name ?? generateName,
+			mapper,
+			{ type: 'insert', tables: [...extractUsedTable(this.config.table)] },
+		);
+
+		return preparedQuery;
+	}
+
+	prepare(name?: string): PgInsertPrepare<this, TEffectHKT> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this._prepare().execute(placeholderValues).pipe(
+			Effect.withSpan('drizzle.operation'),
+		);
+	};
+}
+
+applyEffectWrapper(PgEffectInsertBase);
diff --git a/drizzle-orm/src/pg-core/effect/query.ts b/drizzle-orm/src/pg-core/effect/query.ts
new file mode 100644
index 0000000000..754f57986a
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/query.ts
@@ -0,0 +1,61 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { PgRelationalQuery, type PgRelationalQueryHKTBase } from '../query-builders/query.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+export type AnyPgEffectRelationalQuery = PgEffectRelationalQuery<any, any>;
+
+export interface PgEffectRelationalQueryHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends PgRelationalQueryHKTBase
+{
+	_type: PgEffectRelationalQuery<this['result'], TEffectHKT>;
+}
+
+export interface PgEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends Effect.Effect<TResult, TEffectHKT['error'], TEffectHKT['context']>
+{}
+export class PgEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends PgRelationalQuery<PgEffectRelationalQueryHKT<TEffectHKT>, TResult>
+	implements RunnableQuery<TResult, 'pg'>
+{
+	static override readonly [entityKind]: string = 'PgEffectRelationalQueryV2';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(
+		name?: string,
+		generateName = false,
+	): PgEffectPreparedQuery<PreparedQueryConfig & { execute: TResult }, TEffectHKT> {
+		const { query, builtQuery } = this._toSQL();
+
+		const mapper = this.dialect.mapperGenerators.relationalRows({
+			isFirst: this.mode === 'first',
+			parseJson: this.parseJson,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			selection: query.selection,
+			arrayModeRoot: true,
+		});
+
+		return this.session.prepareQuery<PreparedQueryConfig & { execute: TResult }>(
+			builtQuery,
+			'arrays',
+			name ?? generateName,
+			mapper,
+		);
+	}
+
+	prepare(name?: string): PgEffectPreparedQuery<PreparedQueryConfig & { execute: TResult }, TEffectHKT> {
+		return this._prepare(name, true);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this._prepare().execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(PgEffectRelationalQuery);
diff --git a/drizzle-orm/src/pg-core/effect/raw.ts b/drizzle-orm/src/pg-core/effect/raw.ts
new file mode 100644
index 0000000000..ef6b55396e
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/raw.ts
@@ -0,0 +1,45 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { PgRaw } from '../query-builders/raw.ts';
+import type { PgEffectPreparedQuery } from './session.ts';
+
+export interface PgEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends Effect.Effect<TResult, TEffectHKT['error'], TEffectHKT['context']>, RunnableQuery<TResult, 'pg'>, SQLWrapper
+{}
+export class PgEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgRaw<TResult>
+	implements RunnableQuery<TResult, 'pg'>
+{
+	static override readonly [entityKind]: string = 'PgEffectRaw';
+
+	declare readonly _: {
+		readonly dialect: 'pg';
+		readonly result: TResult;
+	};
+
+	declare protected prepared: PgEffectPreparedQuery<{
+		execute: TResult;
+	}, TEffectHKT>;
+
+	constructor(
+		prepared: PgEffectPreparedQuery<{
+			execute: TResult;
+		}, TEffectHKT>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.prepared.execute(placeholderValues);
+	}
+
+	override _prepare() {
+		return this.prepared;
+	}
+}
+
+applyEffectWrapper(PgEffectRaw);
diff --git a/drizzle-orm/src/pg-core/effect/refresh-materialized-view.ts b/drizzle-orm/src/pg-core/effect/refresh-materialized-view.ts
new file mode 100644
index 0000000000..55ba124a8d
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/refresh-materialized-view.ts
@@ -0,0 +1,54 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { PgRefreshMaterializedView } from '../query-builders/refresh-materialized-view.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface PgEffectRefreshMaterializedView<
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends Effect.Effect<PgQueryResultKind<TQueryResult, never>, TEffectHKT['error'], TEffectHKT['context']> {}
+
+export class PgEffectRefreshMaterializedView<
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgRefreshMaterializedView<TQueryResult>
+	implements RunnableQuery<PgQueryResultKind<TQueryResult, never>, 'pg'>
+{
+	static override readonly [entityKind]: string = 'PgEffectRefreshMaterializedView';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgEffectPreparedQuery<
+		PreparedQueryConfig & {
+			execute: PgQueryResultKind<TQueryResult, never>;
+		},
+		TEffectHKT
+	> {
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		return this.session.prepareQuery(
+			query,
+			'raw',
+			name ?? generateName,
+		);
+	}
+
+	prepare(name?: string): PgEffectPreparedQuery<
+		PreparedQueryConfig & {
+			execute: PgQueryResultKind<TQueryResult, never>;
+		},
+		TEffectHKT
+	> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(PgEffectRefreshMaterializedView);
diff --git a/drizzle-orm/src/pg-core/effect/select.ts b/drizzle-orm/src/pg-core/effect/select.ts
new file mode 100644
index 0000000000..c17220ecb6
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/select.ts
@@ -0,0 +1,148 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
+import { PgSelectBase, type PgSelectBuilder } from '../query-builders/select.ts';
+import type { PgSelectHKTBase, SelectedFields } from '../query-builders/select.types.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+export type PgEffectSelectPrepare<
+	T extends AnyPgEffectSelect,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	},
+	TEffectHKT
+>;
+
+export type PgEffectSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgSelectBuilder<TSelection, PgEffectSelectHKT<TEffectHKT>>;
+
+export type PgEffectSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgEffectSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export interface PgEffectSelectHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgSelectHKTBase {
+	_type: PgEffectSelectBase<
+		this['tableName'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>,
+		TEffectHKT
+	>;
+}
+
+export interface PgEffectSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection | undefined,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	// oxlint-disable-next-line no-unused-vars
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<
+		Assume<TSelection, ColumnsSelection>,
+		TNullabilityMap
+	>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends Effect.Effect<TResult, TEffectHKT['error'], TEffectHKT['context']> {
+}
+
+export class PgEffectSelectBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection | undefined,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<
+		Assume<TSelection, ColumnsSelection>,
+		TNullabilityMap
+	>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgSelectBase<
+	PgEffectSelectHKT<TEffectHKT>,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'PgEffectSelectQueryBuilder';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgEffectSelectPrepare<this, TEffectHKT> {
+		const { session, cacheConfig, usedTables } = this;
+
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+		const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+			query,
+			'arrays',
+			name ?? generateName,
+			mapper,
+			{ type: 'select', tables: [...usedTables] },
+			cacheConfig,
+		);
+
+		return preparedQuery;
+	}
+
+	/**
+	 * Create a prepared statement for this query. This allows
+	 * the database to remember this query for the given session
+	 * and call it by name, rather than specifying the full query.
+	 *
+	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
+	 */
+	prepare(name?: string): PgEffectSelectPrepare<this, TEffectHKT> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(PgEffectSelectBase);
+
+export type AnyPgEffectSelect = PgEffectSelectBase<any, any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/pg-core/effect/session.ts b/drizzle-orm/src/pg-core/effect/session.ts
new file mode 100644
index 0000000000..8b981e1431
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/session.ts
@@ -0,0 +1,314 @@
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import { EffectCache, type EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import { NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { MigratorInitError } from '~/effect-core/errors.ts';
+import { EffectDrizzleQueryError, EffectTransactionRollbackError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase, QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/effect-pg.ts';
+import { assertUnreachable } from '~/utils.ts';
+import type { PgDialect } from '../dialect.ts';
+import {
+	PgBasePreparedQuery,
+	type PgQueryResultHKT,
+	PgSession,
+	type PgTransactionConfig,
+	type PreparedQueryConfig,
+} from '../session.ts';
+import { PgEffectDatabase } from './db.ts';
+
+export class PgEffectPreparedQuery<
+	T extends PreparedQueryConfig,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgBasePreparedQuery {
+	static override readonly [entityKind]: string = 'PgEffectPreparedQuery';
+
+	/** @internal */
+	readonly mapper: {
+		(rows: any[]): any;
+		body?: string;
+	} | undefined;
+
+	constructor(
+		protected executor: (params?: unknown[]) => Effect.Effect<unknown, unknown, unknown>,
+		query: Query,
+		mapper: ((rows: any[]) => any) | undefined,
+		readonly mode: 'arrays' | 'objects' | 'raw',
+		private logger: EffectLoggerShape,
+		// cache instance
+		protected cache: EffectCacheShape,
+		// per query related metadata
+		protected queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		protected cacheConfig: WithCacheConfig | undefined,
+	) {
+		super(query);
+		this.mapper = mapper;
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+	}
+
+	override execute(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['execute']> {
+		return Effect.gen({ self: this }, function*() {
+			const params = fillPlaceholders(this.query.params, placeholderValues);
+			const { query: { sql }, mapper, logger } = this;
+
+			yield* logger.logQuery(sql, params);
+
+			const query = this.queryWithCache(sql, params, Effect.suspend(() => this.executor(params)));
+
+			if (!mapper) return yield* query;
+
+			return yield* query.pipe(Effect.map((rows) => mapper(rows as unknown[])));
+		});
+	}
+
+	/** @internal */
+	protected queryWithCache<A, E, R>(
+		queryString: string,
+		params: any[],
+		query: Effect.Effect<A, E, R>,
+	) {
+		return Effect.gen({ self: this }, function*() {
+			const { cacheConfig, queryMetadata } = this;
+			const cache = yield* EffectCache;
+
+			const cacheStrat: Awaited<ReturnType<typeof strategyFor>> = cache && !(cache.cache && is(cache.cache, NoopCache))
+				? yield* Effect.tryPromise(
+					() => strategyFor(queryString, params, queryMetadata, cacheConfig),
+				)
+				: { type: 'skip' as const };
+
+			if (cacheStrat.type === 'skip') {
+				return yield* query;
+			}
+
+			// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+			if (cacheStrat.type === 'invalidate') {
+				const result = yield* query;
+				yield* cache!.onMutate({ tables: cacheStrat.tables });
+
+				return result;
+			}
+
+			if (cacheStrat.type === 'try') {
+				const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+				const fromCache: any[] | undefined = yield* cache!.get(
+					key,
+					tables,
+					isTag,
+					autoInvalidate,
+				);
+
+				if (typeof fromCache !== 'undefined') return fromCache as unknown as A;
+
+				const result = yield* query;
+
+				yield* cache!.put(
+					key,
+					result,
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+
+				return result;
+			}
+
+			assertUnreachable(cacheStrat);
+		}).pipe(
+			Effect.provideService(EffectCache, this.cache),
+			Effect.catch((e) => {
+				return Effect.fail(new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) }));
+			}),
+		);
+	}
+}
+
+export abstract class PgEffectSession<
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgSession {
+	static override readonly [entityKind]: string = 'PgEffectSession';
+
+	constructor(dialect: PgDialect) {
+		super(dialect);
+	}
+
+	abstract override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): PgEffectPreparedQuery<T, TEffectHKT>;
+
+	override execute<T>(query: SQL) {
+		const prepared = this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'raw',
+			false,
+		);
+
+		return prepared.execute();
+	}
+
+	override arrays<T>(query: SQL) {
+		const prepared = this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'arrays',
+			false,
+		);
+
+		return prepared.execute();
+	}
+
+	override objects<T>(query: SQL) {
+		const prepared = this.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'objects',
+			false,
+		);
+
+		return prepared.execute();
+	}
+
+	abstract transaction<A, E, R>(
+		transaction: (
+			tx: PgEffectTransaction<TEffectHKT, TQueryResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | SqlError, R>;
+}
+
+export abstract class PgEffectTransaction<
+	TEffectHKT extends QueryEffectHKTBase,
+	TQueryResult extends PgQueryResultHKT,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgEffectDatabase<TEffectHKT, TQueryResult, TRelations> {
+	static override readonly [entityKind]: string = 'PgEffectTransaction';
+
+	constructor(
+		dialect: PgDialect,
+		session: PgEffectSession<TEffectHKT, any, any>,
+		protected relations: TRelations,
+		protected readonly nestedIndex = 0,
+		parseRqbJson?: boolean,
+	) {
+		super(dialect, session, relations, parseRqbJson);
+	}
+
+	rollback() {
+		return new EffectTransactionRollbackError();
+	}
+
+	/** @internal */
+	getTransactionConfigSQL(config: PgTransactionConfig): SQL {
+		const chunks: string[] = [];
+		if (config.isolationLevel) {
+			chunks.push(`isolation level ${config.isolationLevel}`);
+		}
+		if (config.accessMode) {
+			chunks.push(config.accessMode);
+		}
+		if (typeof config.deferrable === 'boolean') {
+			chunks.push(config.deferrable ? 'deferrable' : 'not deferrable');
+		}
+		return sql.raw(chunks.join(' '));
+	}
+
+	setTransaction(config: PgTransactionConfig) {
+		return this.session.execute<void>(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+	}
+}
+
+export const migrate = Effect.fn('migrate')(function*<TEffectHKT extends QueryEffectHKTBase>(
+	migrations: MigrationMeta[],
+	session: PgEffectSession<TEffectHKT>,
+	config: string | MigrationConfig,
+) {
+	const migrationsTable = typeof config === 'string'
+		? '__drizzle_migrations'
+		: config.migrationsTable ?? '__drizzle_migrations';
+	const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle';
+
+	yield* session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
+
+	const { newDb } = yield* upgradeIfNeeded(migrationsSchema, migrationsTable, session, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash text NOT NULL,
+				created_at bigint,
+				name text,
+				applied_at timestamp with time zone DEFAULT now()
+			)
+		`;
+
+		yield* session.execute(migrationTableCreate);
+	}
+
+	const dbMigrations = yield* session.objects<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return yield* new MigratorInitError({ exitCode: 'databaseMigrations' });
+		}
+
+		if (migrations.length > 1) {
+			return yield* new MigratorInitError({ exitCode: 'localMigrations' });
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		yield* session.execute(
+			sql`insert into ${sql.identifier(migrationsSchema)}.${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+
+	yield* session.transaction((tx) =>
+		Effect.gen(function*() {
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					yield* tx.execute(sql.raw(stmt));
+				}
+				yield* tx.execute(
+					sql`insert into ${sql.identifier(migrationsSchema)}.${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+				);
+			}
+		})
+	);
+});
diff --git a/drizzle-orm/src/pg-core/effect/update.ts b/drizzle-orm/src/pg-core/effect/update.ts
new file mode 100644
index 0000000000..b35f6e93e7
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/update.ts
@@ -0,0 +1,148 @@
+import type * as Effect from 'effect/Effect';
+import { applyEffectWrapper, type QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgTable } from '~/pg-core/table.ts';
+import type { JoinNullability } from '~/query-builders/select.types.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
+import type { Subquery } from '~/subquery.ts';
+import type { Assume } from '~/utils.ts';
+import { type Join, PgUpdateBase, type PgUpdateHKTBase } from '../query-builders/update.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { PgViewBase } from '../view-base.ts';
+import type { PgEffectPreparedQuery, PgEffectSession } from './session.ts';
+
+export type PgEffectUpdatePrepare<
+	T extends AnyPgEffectUpdate,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectPreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	},
+	TEffectHKT
+>;
+
+export type PgEffectUpdate<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = PgEffectUpdateBase<
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	true,
+	never,
+	TEffectHKT
+>;
+
+export interface PgEffectUpdateHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends PgUpdateHKTBase {
+	_type: PgEffectUpdateBase<
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['from'], PgTable | Subquery | PgViewBase | SQL | undefined>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		Assume<this['joins'], Join[]>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnyPgEffectUpdate = PgEffectUpdateBase<any, any, any, any, any, any, any, any, any, any>;
+
+export interface PgEffectUpdateBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TJoins extends Join[] = [],
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends
+	Effect.Effect<
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[],
+		TEffectHKT['error'],
+		TEffectHKT['context']
+	>
+{}
+
+export class PgEffectUpdateBase<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends PgUpdateBase<
+	PgEffectUpdateHKT<TEffectHKT>,
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'> {
+	static override readonly [entityKind]: string = 'PgEffectUpdate';
+
+	declare protected session: PgEffectSession<TEffectHKT, any, any>;
+
+	/** @internal */
+	_prepare(name?: string, generateName = false): PgEffectUpdatePrepare<this, TEffectHKT> {
+		const { session, config, dialect, joinsNotNullableMap } = this;
+		const { returning: fields } = config;
+
+		const query = dialect.sqlToQuery(this.getSQL());
+		const mapper = fields
+			? this.dialect.mapperGenerators.rows(fields, joinsNotNullableMap)
+			: undefined;
+
+		const preparedQuery = session.prepareQuery<PreparedQueryConfig & { execute: any }>(
+			query,
+			fields ? 'arrays' : 'raw',
+			name ?? generateName,
+			mapper,
+			{ type: 'update', tables: [...extractUsedTable(this.config.table)] },
+		);
+
+		return preparedQuery;
+	}
+
+	prepare(name?: string): PgEffectUpdatePrepare<this, TEffectHKT> {
+		return this._prepare(name, true);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues: Record<string, unknown> = {}) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(PgEffectUpdateBase);
diff --git a/drizzle-orm/src/pg-core/effect/utils.ts b/drizzle-orm/src/pg-core/effect/utils.ts
new file mode 100644
index 0000000000..32fa0be099
--- /dev/null
+++ b/drizzle-orm/src/pg-core/effect/utils.ts
@@ -0,0 +1,6 @@
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzlePgConfig } from '../utils.ts';
+
+export type EffectDrizzlePgConfig<
+	TRelations extends AnyRelations = EmptyRelations,
+> = Omit<DrizzlePgConfig<TRelations>, 'cache' | 'logger'>;
diff --git a/drizzle-orm/src/pg-core/foreign-keys.ts b/drizzle-orm/src/pg-core/foreign-keys.ts
index f8ba0b8623..3ba0e0d85e 100644
--- a/drizzle-orm/src/pg-core/foreign-keys.ts
+++ b/drizzle-orm/src/pg-core/foreign-keys.ts
@@ -69,6 +69,7 @@ export class ForeignKey {
 	readonly reference: Reference;
 	readonly onUpdate: UpdateDeleteAction | undefined;
 	readonly onDelete: UpdateDeleteAction | undefined;
+	readonly name?: string;
 
 	constructor(readonly table: PgTable, builder: ForeignKeyBuilder) {
 		this.reference = builder.reference;
@@ -88,6 +89,10 @@ export class ForeignKey {
 		];
 		return name ?? `${chunks.join('_')}_fk`;
 	}
+
+	isNameExplicit(): boolean {
+		return !!this.reference().name;
+	}
 }
 
 type ColumnsWithTable<
diff --git a/drizzle-orm/src/pg-core/index.ts b/drizzle-orm/src/pg-core/index.ts
index ebc436bc15..aebf9b7211 100644
--- a/drizzle-orm/src/pg-core/index.ts
+++ b/drizzle-orm/src/pg-core/index.ts
@@ -1,7 +1,9 @@
 export * from './alias.ts';
+export * from './array.ts';
+export * from './async/index.ts';
+export * from './casing.ts';
 export * from './checks.ts';
 export * from './columns/index.ts';
-export * from './db.ts';
 export * from './dialect.ts';
 export * from './foreign-keys.ts';
 export * from './indexes.ts';
@@ -16,6 +18,5 @@ export * from './subquery.ts';
 export * from './table.ts';
 export * from './unique-constraint.ts';
 export * from './utils.ts';
-export * from './utils/index.ts';
 export * from './view-common.ts';
 export * from './view.ts';
diff --git a/drizzle-orm/src/pg-core/indexes.ts b/drizzle-orm/src/pg-core/indexes.ts
index bf53a56cee..dfc97aa414 100644
--- a/drizzle-orm/src/pg-core/indexes.ts
+++ b/drizzle-orm/src/pg-core/indexes.ts
@@ -1,7 +1,7 @@
-import { SQL } from '~/sql/sql.ts';
-
 import { entityKind, is } from '~/entity.ts';
-import type { ExtraConfigColumn, PgColumn } from './columns/index.ts';
+import { SQL } from '~/sql/sql.ts';
+import { ExtraConfigColumn } from './columns/index.ts';
+import type { PgColumn } from './columns/index.ts';
 import { IndexedColumn } from './columns/index.ts';
 import type { PgTable } from './table.ts';
 
@@ -111,16 +111,34 @@ export class IndexBuilderOn {
 
 	constructor(private unique: boolean, private name?: string) {}
 
-	on(...columns: [Partial<ExtraConfigColumn> | SQL, ...Partial<ExtraConfigColumn | SQL>[]]): IndexBuilder {
+	on(
+		...columns: [Partial<ExtraConfigColumn> | SQL | PgColumn, ...(Partial<ExtraConfigColumn | SQL | PgColumn>)[]]
+	): IndexBuilder {
 		return new IndexBuilder(
 			columns.map((it) => {
 				if (is(it, SQL)) {
 					return it;
 				}
-				it = it as ExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-				return clonedIndexedColumn;
+
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as PgColumn;
+
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
 			}),
 			this.unique,
 			false,
@@ -128,16 +146,34 @@ export class IndexBuilderOn {
 		);
 	}
 
-	onOnly(...columns: [Partial<ExtraConfigColumn | SQL>, ...Partial<ExtraConfigColumn | SQL>[]]): IndexBuilder {
+	onOnly(
+		...columns: [Partial<ExtraConfigColumn | SQL | PgColumn>, ...Partial<ExtraConfigColumn | SQL | PgColumn>[]]
+	): IndexBuilder {
 		return new IndexBuilder(
 			columns.map((it) => {
 				if (is(it, SQL)) {
 					return it;
 				}
-				it = it as ExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = it.defaultConfig;
-				return clonedIndexedColumn;
+
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as PgColumn;
+
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
 			}),
 			this.unique,
 			true,
@@ -158,17 +194,32 @@ export class IndexBuilderOn {
 	 */
 	using(
 		method: PgIndexMethod,
-		...columns: [Partial<ExtraConfigColumn | SQL>, ...Partial<ExtraConfigColumn | SQL>[]]
+		...columns: [Partial<ExtraConfigColumn | SQL | PgColumn>, ...Partial<ExtraConfigColumn | SQL | PgColumn>[]]
 	): IndexBuilder {
 		return new IndexBuilder(
 			columns.map((it) => {
 				if (is(it, SQL)) {
 					return it;
 				}
-				it = it as ExtraConfigColumn;
-				const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType!, it.indexConfig!);
-				it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-				return clonedIndexedColumn;
+				if (is(it, ExtraConfigColumn)) {
+					const clonedIndexedColumn = new IndexedColumn(
+						it.name,
+						!!it.keyAsName,
+						it.columnType!,
+						it.indexConfig!,
+					);
+					it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+					return clonedIndexedColumn;
+				}
+
+				it = it as PgColumn;
+
+				return new IndexedColumn(
+					it.name!,
+					!!it.keyAsName,
+					it.columnType!,
+					{},
+				);
 			}),
 			this.unique,
 			true,
@@ -232,9 +283,11 @@ export class Index {
 	static readonly [entityKind]: string = 'PgIndex';
 
 	readonly config: IndexConfig & { table: PgTable };
+	readonly isNameExplicit: boolean;
 
 	constructor(config: IndexConfig, table: PgTable) {
 		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
 	}
 }
 
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index 98d7d3e794..452138df95 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -50,10 +50,12 @@ export class PrimaryKey {
 
 	readonly columns: AnyPgColumn<{}>[];
 	readonly name?: string;
+	readonly isNameExplicit: boolean;
 
 	constructor(readonly table: PgTable, columns: AnyPgColumn<{}>[], name?: string) {
 		this.columns = columns;
 		this.name = name;
+		this.isNameExplicit = !!name;
 	}
 
 	getName(): string {
diff --git a/drizzle-orm/src/pg-core/query-builders/count.ts b/drizzle-orm/src/pg-core/query-builders/count.ts
index a86ffd7450..726e9bc34d 100644
--- a/drizzle-orm/src/pg-core/query-builders/count.ts
+++ b/drizzle-orm/src/pg-core/query-builders/count.ts
@@ -1,86 +1,48 @@
 import { entityKind } from '~/entity.ts';
-import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import type { NeonAuthToken } from '~/utils.ts';
-import type { PgSession } from '../session.ts';
+import { type Query, SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import type { PgDialect } from '../dialect.ts';
 import type { PgTable } from '../table.ts';
+import type { PgViewBase } from '../view-base.ts';
 
-export class PgCountBuilder<
-	TSession extends PgSession<any, any, any>,
-> extends SQL<number> implements Promise<number>, SQLWrapper {
-	private sql: SQL<number>;
-	private token?: NeonAuthToken;
+export class PgCountBuilder extends SQL<number> implements SQLWrapper<number> {
+	static override readonly [entityKind]: string = 'PgCountBuilder';
 
-	static override readonly [entityKind] = 'PgCountBuilder';
-	[Symbol.toStringTag] = 'PgCountBuilder';
-
-	private session: TSession;
-
-	private static buildEmbeddedCount(
-		source: PgTable | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	): SQL<number> {
-		return sql<number>`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
-	}
+	private dialect: PgDialect;
 
 	private static buildCount(
-		source: PgTable | SQL | SQLWrapper,
+		source: PgTable | PgViewBase | SQL | SQLWrapper,
 		filters?: SQL<unknown>,
+		parens?: boolean,
 	): SQL<number> {
-		return sql<number>`select count(*) as count from ${source}${sql.raw(' where ').if(filters)}${filters};`;
+		const where = sql` where ${filters}`.if(filters);
+		const query = sql<number>`select count(*) from ${source}${where}`;
+
+		return parens ? sql`(${query})` : query;
 	}
 
 	constructor(
-		readonly params: {
-			source: PgTable | SQL | SQLWrapper;
+		protected countConfig: {
+			source: PgTable | PgViewBase | SQL | SQLWrapper;
 			filters?: SQL<unknown>;
-			session: TSession;
+			dialect: PgDialect;
 		},
 	) {
-		super(PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-
-		this.mapWith(Number);
+		super(PgCountBuilder.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+		this.dialect = countConfig.dialect;
+		this.mapWith((e) => {
+			if (typeof e === 'number') return e;
 
-		this.session = params.session;
-
-		this.sql = PgCountBuilder.buildCount(
-			params.source,
-			params.filters,
-		);
-	}
-
-	/** @intrnal */
-	setToken(token?: NeonAuthToken) {
-		this.token = token;
-		return this;
+			return Number(e ?? 0);
+		});
 	}
 
-	then<TResult1 = number, TResult2 = never>(
-		onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined,
-	): Promise<TResult1 | TResult2> {
-		return Promise.resolve(this.session.count(this.sql, this.token))
-			.then(
-				onfulfilled,
-				onrejected,
-			);
-	}
-
-	catch(
-		onRejected?: ((reason: any) => any) | null | undefined,
-	): Promise<number> {
-		return this.then(undefined, onRejected);
-	}
+	private executableSql: SQL<number> | undefined;
+	protected build(): Query {
+		if (!this.executableSql) {
+			const { source, filters } = this.countConfig;
+			this.executableSql = PgCountBuilder.buildCount(source, filters);
+		}
 
-	finally(onFinally?: (() => void) | null | undefined): Promise<number> {
-		return this.then(
-			(value) => {
-				onFinally?.();
-				return value;
-			},
-			(reason) => {
-				onFinally?.();
-				throw reason;
-			},
-		);
+		return this.dialect.sqlToQuery(this.executableSql);
 	}
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/delete.ts b/drizzle-orm/src/pg-core/query-builders/delete.ts
index d6cc150d56..8876da5f26 100644
--- a/drizzle-orm/src/pg-core/query-builders/delete.ts
+++ b/drizzle-orm/src/pg-core/query-builders/delete.ts
@@ -1,35 +1,25 @@
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import type {
-	PgPreparedQuery,
-	PgQueryResultHKT,
-	PgQueryResultKind,
-	PgSession,
-	PreparedQueryConfig,
-} from '~/pg-core/session.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PgSession } from '~/pg-core/session.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { ColumnsSelection, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { type ColumnsSelection, type CommentInput, type Query, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
-import { type NeonAuthToken, orderSelectedFields } from '~/utils.ts';
+import { type Assume, orderSelectedFields } from '~/utils.ts';
 import type { PgColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 
 export type PgDeleteWithout<
-	T extends AnyPgDeleteBase,
+	T extends AnyPgDelete,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T
 	: Omit<
-		PgDeleteBase<
+		PgDeleteKind<
+			T['_']['hkt'],
 			T['_']['table'],
 			T['_']['queryResult'],
 			T['_']['selectedFields'],
@@ -45,7 +35,7 @@ export type PgDelete<
 	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
 	TSelectedFields extends ColumnsSelection | undefined = undefined,
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = PgDeleteBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+> = PgDeleteBase<PgDeleteHKT, TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
 
 export interface PgDeleteConfig {
 	where?: SQL | undefined;
@@ -53,58 +43,100 @@ export interface PgDeleteConfig {
 	returningFields?: SelectedFieldsFlat;
 	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
+	comment?: SQL;
+	ignoreSelectionCastCodecs?: boolean;
 }
 
 export type PgDeleteReturningAll<
-	T extends AnyPgDeleteBase,
+	T extends AnyPgDelete,
 	TDynamic extends boolean,
-> = PgDeleteWithout<
-	PgDeleteBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['table']['_']['columns'],
-		T['_']['table']['$inferSelect'],
+> = T extends any ? PgDeleteWithout<
+		PgDeleteKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['table']['_']['columns'],
+			T['_']['table']['$inferSelect'],
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
 		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
+		'returning'
+	>
+	: never;
 
 export type PgDeleteReturning<
-	T extends AnyPgDeleteBase,
+	T extends AnyPgDelete,
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFieldsFlat,
-> = PgDeleteWithout<
-	PgDeleteBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		TSelectedFields,
-		SelectResultFields<TSelectedFields>,
+> = T extends any ? PgDeleteWithout<
+		PgDeleteKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			TSelectedFields,
+			SelectResultFields<TSelectedFields>,
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
 		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
+		'returning'
+	>
+	: never;
 
-export type PgDeletePrepare<T extends AnyPgDeleteBase> = PgPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
-
-export type PgDeleteDynamic<T extends AnyPgDeleteBase> = PgDelete<
+export type PgDeleteDynamic<T extends AnyPgDelete> = PgDeleteKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['selectedFields'],
-	T['_']['returning']
+	T['_']['returning'],
+	true,
+	never
 >;
 
-export type AnyPgDeleteBase = PgDeleteBase<any, any, any, any, any, any>;
+export type AnyPgDelete = PgDeleteBase<any, any, any, any, any, any, any>;
+
+export interface PgDeleteHKTBase {
+	table: unknown;
+	queryResult: unknown;
+	selectedFields: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	_type: unknown;
+}
+
+export interface PgDeleteHKT extends PgDeleteHKTBase {
+	_type: PgDeleteBase<
+		PgDeleteHKT,
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type PgDeleteKind<
+	T extends PgDeleteHKTBase,
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	queryResult: TQueryResult;
+	selectedFields: TSelectedFields;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
 
 export interface PgDeleteBase<
+	THKT extends PgDeleteHKTBase,
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
 	TSelectedFields extends ColumnsSelection | undefined = undefined,
@@ -116,12 +148,11 @@ export interface PgDeleteBase<
 		TSelectedFields,
 		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
 	>,
-	QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
 	SQLWrapper
 {
 	readonly _: {
 		readonly dialect: 'pg';
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
 		readonly selectedFields: TSelectedFields;
@@ -133,6 +164,8 @@ export interface PgDeleteBase<
 }
 
 export class PgDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends PgDeleteHKTBase,
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
 	TSelectedFields extends ColumnsSelection | undefined = undefined,
@@ -140,27 +173,23 @@ export class PgDeleteBase<
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		TypedQueryBuilder<
-			TSelectedFields,
-			TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
-		>,
-		RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
-		SQLWrapper
+> implements
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	SQLWrapper
 {
-	static override readonly [entityKind]: string = 'PgDelete';
+	static readonly [entityKind]: string = 'PgDelete';
 
-	private config: PgDeleteConfig;
-	protected cacheConfig?: WithCacheConfig;
+	protected config: PgDeleteConfig;
 
 	constructor(
 		table: TTable,
-		private session: PgSession,
-		private dialect: PgDialect,
+		protected session: PgSession,
+		protected dialect: PgDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { table, withList };
 	}
 
@@ -224,53 +253,32 @@ export class PgDeleteBase<
 	): PgDeleteReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
-	): PgDeleteReturning<this, TDynamic, any> {
+	): PgDeleteReturning<this, TDynamic, any> | PgDeleteReturningAll<this, TDynamic> {
 		this.config.returningFields = fields;
-		this.config.returning = orderSelectedFields<PgColumn>(fields);
+		this.config.returning = orderSelectedFields<PgColumn>(
+			fields,
+			undefined,
+			this.dialect.codecs,
+		);
+		return this as any;
+	}
+
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): PgDeleteWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
 		return this as any;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
 		return this.dialect.buildDeleteQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	/** @internal */
-	_prepare(name?: string): PgDeletePrepare<this> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery<
-				PreparedQueryConfig & {
-					execute: TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[];
-				}
-			>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-				type: 'delete',
-				tables: extractUsedTable(this.config.table),
-			}, this.cacheConfig);
-		});
-	}
-
-	prepare(name: string): PgDeletePrepare<this> {
-		return this._prepare(name);
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues, this.authToken);
-		});
-	};
-
 	/** @internal */
 	getSelectedFields(): this['_']['selectedFields'] {
 		return (
@@ -287,6 +295,12 @@ export class PgDeleteBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	withoutSelectionCastCodecs() {
+		this.config.ignoreSelectionCastCodecs = true;
+		return this;
+	}
+
 	$dynamic(): PgDeleteDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/pg-core/query-builders/insert.ts b/drizzle-orm/src/pg-core/query-builders/insert.ts
index 28978cc841..98a295d32d 100644
--- a/drizzle-orm/src/pg-core/query-builders/insert.ts
+++ b/drizzle-orm/src/pg-core/query-builders/insert.ts
@@ -1,61 +1,95 @@
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
 import type { IndexColumn } from '~/pg-core/indexes.ts';
-import type {
-	PgPreparedQuery,
-	PgQueryResultHKT,
-	PgQueryResultKind,
-	PgSession,
-	PreparedQueryConfig,
-} from '~/pg-core/session.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PgSession } from '~/pg-core/session.ts';
 import type { PgTable, TableConfig } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import type { ColumnsSelection, CommentInput, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Param, SQL, sql } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { InferInsertModel } from '~/table.ts';
-import { Columns, getTableName, Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
-import { haveSameKeys, mapUpdateSet, type NeonAuthToken, orderSelectedFields } from '~/utils.ts';
+import { getTableName, Table } from '~/table.ts';
+import { type Assume, type DrizzleTypeError, mapUpdateSet, orderSelectedFields } from '~/utils.ts';
 import type { AnyPgColumn, PgColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import { QueryBuilder } from './query-builder.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 import type { PgUpdateSetSource } from './update.ts';
 
 export interface PgInsertConfig<TTable extends PgTable = PgTable> {
 	table: TTable;
-	values: Record<string, Param | SQL>[] | PgInsertSelectQueryBuilder<TTable> | SQL;
+	values: Record<string, Param | SQL>[] | TypedQueryBuilder<PgInsertSelection<TTable>> | SQL;
 	withList?: Subquery[];
 	onConflict?: SQL;
 	returningFields?: SelectedFieldsFlat;
 	returning?: SelectedFieldsOrdered;
 	select?: boolean;
 	overridingSystemValue_?: boolean;
+	comment?: SQL;
+	ignoreSelectionCastCodecs?: boolean;
 }
 
-export type PgInsertValue<TTable extends PgTable<TableConfig>, OverrideT extends boolean = false> =
+export type PgInsertValue<
+	TTable extends PgTable<TableConfig>,
+	OverrideT extends boolean = false,
+	TModel extends Record<string, any> = InferInsertModel<TTable, { override: OverrideT }>,
+> =
 	& {
-		[Key in keyof InferInsertModel<TTable, { dbColumnNames: false; override: OverrideT }>]:
-			| InferInsertModel<TTable, { dbColumnNames: false; override: OverrideT }>[Key]
+		[Key in keyof TModel]:
+			| TModel[Key]
 			| SQL
 			| Placeholder;
 	}
 	& {};
 
-export type PgInsertSelectQueryBuilder<TTable extends PgTable> = TypedQueryBuilder<
-	{ [K in keyof TTable['$inferInsert']]: AnyPgColumn | SQL | SQL.Aliased | TTable['$inferInsert'][K] }
->;
+export type PgInsertSelection<
+	TTable extends PgTable<TableConfig>,
+	OverrideT extends boolean = false,
+	TModel extends Record<string, unknown> = InferInsertModel<TTable, { override: OverrideT }>,
+> =
+	& {
+		[K in keyof TModel]:
+			| AnyPgColumn
+			| SQL
+			| SQL.Aliased
+			| TModel[K];
+	}
+	& {};
+
+export type NoUnknownKeysInInsertSelection<
+	TTable extends PgTable<TableConfig>,
+	TSelection extends PgInsertSelection<any, any>,
+	OverrideT extends boolean = false,
+> = {
+	[K in keyof TSelection]: K extends keyof InferInsertModel<TTable, { override: OverrideT }> ? TSelection[K]
+		: K extends keyof InferInsertModel<TTable, { override: true }> ? DrizzleTypeError<
+				`Column "${
+					& K
+					& string}" in table "${TTable['_'][
+					'name'
+				]}" is a generated column. Use \`.overridingSystemValue()\` to manually insert into this column`
+			>
+		: DrizzleTypeError<`Column "${K & string}" does not exist in table "${TTable['_']['name']}"`>;
+};
+
+export interface PgInsertBuilderConstructor {
+	new(
+		table: PgTable,
+		values: PgInsertConfig['values'],
+		session: PgSession,
+		dialect: PgDialect,
+		withList?: Subquery[],
+		select?: boolean,
+		overridingSystemValue_?: boolean,
+	): AnyPgInsert;
+}
 
 export class PgInsertBuilder<
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
 	OverrideT extends boolean = false,
+	TBuilderHKT extends PgInsertHKTBase = PgInsertHKT,
 > {
 	static readonly [entityKind]: string = 'PgInsertBuilder';
 
@@ -65,25 +99,19 @@ export class PgInsertBuilder<
 		private dialect: PgDialect,
 		private withList?: Subquery[],
 		private overridingSystemValue_?: boolean,
+		private builder: PgInsertBuilderConstructor = PgInsertBase,
 	) {}
 
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	overridingSystemValue(): Omit<PgInsertBuilder<TTable, TQueryResult, true>, 'overridingSystemValue'> {
+	overridingSystemValue(): Omit<PgInsertBuilder<TTable, TQueryResult, true, TBuilderHKT>, 'overridingSystemValue'> {
 		this.overridingSystemValue_ = true;
 		return this as any;
 	}
 
-	values(value: PgInsertValue<TTable, OverrideT>): PgInsertBase<TTable, TQueryResult>;
-	values(values: PgInsertValue<TTable, OverrideT>[]): PgInsertBase<TTable, TQueryResult>;
+	values(value: PgInsertValue<TTable, OverrideT>): PgInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	values(values: PgInsertValue<TTable, OverrideT>[]): PgInsertKind<TBuilderHKT, TTable, TQueryResult>;
 	values(
 		values: PgInsertValue<TTable, OverrideT> | PgInsertValue<TTable, OverrideT>[],
-	): PgInsertBase<TTable, TQueryResult> {
+	): PgInsertKind<TBuilderHKT, TTable, TQueryResult> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -93,12 +121,12 @@ export class PgInsertBuilder<
 			const cols = this.table[Table.Symbol.Columns];
 			for (const colKey of Object.keys(entry)) {
 				const colValue = entry[colKey as keyof typeof entry];
-				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
 			}
 			return result;
 		});
 
-		return new PgInsertBase(
+		const builder = new this.builder(
 			this.table,
 			mappedValues,
 			this.session,
@@ -106,69 +134,145 @@ export class PgInsertBuilder<
 			this.withList,
 			false,
 			this.overridingSystemValue_,
-		).setToken(this.authToken) as any;
+		);
+
+		return builder as any;
 	}
 
-	select(selectQuery: (qb: QueryBuilder) => PgInsertSelectQueryBuilder<TTable>): PgInsertBase<TTable, TQueryResult>;
-	select(selectQuery: (qb: QueryBuilder) => SQL): PgInsertBase<TTable, TQueryResult>;
-	select(selectQuery: SQL): PgInsertBase<TTable, TQueryResult>;
-	select(selectQuery: PgInsertSelectQueryBuilder<TTable>): PgInsertBase<TTable, TQueryResult>;
+	select<TSelection extends PgInsertSelection<TTable, OverrideT>>(
+		selectQuery: (qb: QueryBuilder) => TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection, OverrideT>>,
+	): PgInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	select(selectQuery: (qb: QueryBuilder) => SQL): PgInsertKind<TBuilderHKT, TTable, TQueryResult>;
+	select(selectQuery: SQL): PgInsertBase<TBuilderHKT, TTable, TQueryResult>;
+	select<TSelection extends PgInsertSelection<TTable, OverrideT>>(
+		selectQuery: TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection, OverrideT>>,
+	): PgInsertKind<TBuilderHKT, TTable, TQueryResult>;
 	select(
 		selectQuery:
 			| SQL
-			| PgInsertSelectQueryBuilder<TTable>
-			| ((qb: QueryBuilder) => PgInsertSelectQueryBuilder<TTable> | SQL),
-	): PgInsertBase<TTable, TQueryResult> {
+			| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, PgInsertSelection<TTable, OverrideT>, OverrideT>>
+			| ((qb: QueryBuilder) =>
+				| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, PgInsertSelection<TTable, OverrideT>, OverrideT>>
+				| SQL),
+	): PgInsertKind<TBuilderHKT, TTable, TQueryResult> {
 		const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
+		if ('withoutSelectionCastCodecs' in select) select.withoutSelectionCastCodecs();
 
-		if (
-			!is(select, SQL)
-			&& !haveSameKeys(this.table[Columns], select._.selectedFields)
-		) {
-			throw new Error(
-				'Insert select error: selected fields are not the same or are in a different order compared to the table definition',
-			);
+		if (!is(select, SQL)) {
+			const insertCols = Object.keys(this.table[Table.Symbol.Columns]);
+			const selected = Object.keys(select._.selectedFields);
+
+			for (const col of selected) {
+				if (!insertCols.includes(col)) {
+					throw new Error(
+						`Insert select error: column "${col}" does not exist in table "${this.table[Table.Symbol.Name]}"`,
+					);
+				}
+			}
 		}
 
-		return new PgInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+		const builder = new this.builder(
+			this.table,
+			select,
+			this.session,
+			this.dialect,
+			this.withList,
+			true,
+			this.overridingSystemValue_,
+		) as any;
+
+		return builder as any;
 	}
 }
 
-export type PgInsertWithout<T extends AnyPgInsert, TDynamic extends boolean, K extends keyof T & string> =
-	TDynamic extends true ? T
-		: Omit<
-			PgInsertBase<
-				T['_']['table'],
-				T['_']['queryResult'],
-				T['_']['selectedFields'],
-				T['_']['returning'],
-				TDynamic,
-				T['_']['excludedMethods'] | K
-			>,
+export interface PgInsertHKTBase {
+	table: unknown;
+	queryResult: unknown;
+	selectedFields: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	_type: unknown;
+}
+
+export interface PgInsertHKT extends PgInsertHKTBase {
+	_type: PgInsertBase<
+		PgInsertHKT,
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		this['selectedFields'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type PgInsertKind<
+	T extends PgInsertHKTBase,
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	queryResult: TQueryResult;
+	selectedFields: TSelectedFields;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
+
+export type PgInsertWithout<T extends AnyPgInsert, TDynamic extends boolean, K extends string> = TDynamic extends true
+	? T
+	: Omit<
+		PgInsertKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['selectedFields'],
+			T['_']['returning'],
+			TDynamic,
 			T['_']['excludedMethods'] | K
-		>;
+		>,
+		T['_']['excludedMethods'] | K
+	>;
 
 export type PgInsertReturning<
 	T extends AnyPgInsert,
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFieldsFlat,
-> = PgInsertBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	TSelectedFields,
-	SelectResultFields<TSelectedFields>,
-	TDynamic,
-	T['_']['excludedMethods']
->;
-
-export type PgInsertReturningAll<T extends AnyPgInsert, TDynamic extends boolean> = PgInsertBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['table']['_']['columns'],
-	T['_']['table']['$inferSelect'],
-	TDynamic,
-	T['_']['excludedMethods']
->;
+> = T extends any ? PgInsertWithout<
+		PgInsertKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			TSelectedFields,
+			SelectResultFields<TSelectedFields>,
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		'returning'
+	>
+	: never;
+
+export type PgInsertReturningAll<T extends AnyPgInsert, TDynamic extends boolean> = T extends any ? PgInsertWithout<
+		PgInsertKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['table']['_']['columns'],
+			T['_']['table']['$inferSelect'],
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		'returning'
+	>
+	: never;
 
 export interface PgInsertOnConflictDoUpdateConfig<T extends AnyPgInsert> {
 	target: IndexColumn | IndexColumn[];
@@ -180,33 +284,31 @@ export interface PgInsertOnConflictDoUpdateConfig<T extends AnyPgInsert> {
 	set: PgUpdateSetSource<T['_']['table']>;
 }
 
-export type PgInsertPrepare<T extends AnyPgInsert> = PgPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
-
-export type PgInsertDynamic<T extends AnyPgInsert> = PgInsert<
+export type PgInsertDynamic<T extends AnyPgInsert> = PgInsertKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
-	T['_']['returning']
+	T['_']['selectedFields'],
+	T['_']['returning'],
+	true,
+	never
 >;
 
-export type AnyPgInsert = PgInsertBase<any, any, any, any, any, any>;
+export type AnyPgInsert = PgInsertBase<any, any, any, any, any, any, any>;
 
 export type PgInsert<
 	TTable extends PgTable = PgTable,
 	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
 	TSelectedFields extends ColumnsSelection | undefined = ColumnsSelection | undefined,
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = PgInsertBase<TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
+> = PgInsertBase<PgInsertHKT, TTable, TQueryResult, TSelectedFields, TReturning, true, never>;
 
 export interface PgInsertBase<
+	THKT extends PgInsertHKTBase,
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
-	TSelectedFields extends ColumnsSelection | undefined = undefined,
-	TReturning extends Record<string, unknown> | undefined = undefined,
+	TSelectedFields = undefined,
+	TReturning = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 > extends
@@ -214,12 +316,11 @@ export interface PgInsertBase<
 		TSelectedFields,
 		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
 	>,
-	QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
 	SQLWrapper
 {
 	readonly _: {
 		readonly dialect: 'pg';
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
 		readonly selectedFields: TSelectedFields;
@@ -231,38 +332,36 @@ export interface PgInsertBase<
 }
 
 export class PgInsertBase<
+	// oxlint-disable-next-line no-unused-vars
+	THKT extends PgInsertHKTBase,
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
-	TSelectedFields extends ColumnsSelection | undefined = undefined,
-	TReturning extends Record<string, unknown> | undefined = undefined,
+	TSelectedFields = undefined,
+	TReturning = undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		TypedQueryBuilder<
-			TSelectedFields,
-			TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
-		>,
-		RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
-		SQLWrapper
+> implements
+	TypedQueryBuilder<
+		TSelectedFields,
+		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
+	>,
+	SQLWrapper
 {
-	static override readonly [entityKind]: string = 'PgInsert';
+	static readonly [entityKind]: string = 'PgInsert';
 
-	private config: PgInsertConfig<TTable>;
-	protected cacheConfig?: WithCacheConfig;
+	protected config: PgInsertConfig<TTable>;
 
 	constructor(
 		table: TTable,
 		values: PgInsertConfig['values'],
-		private session: PgSession,
-		private dialect: PgDialect,
+		protected session: PgSession,
+		protected dialect: PgDialect,
 		withList?: Subquery[],
 		select?: boolean,
 		overridingSystemValue_?: boolean,
 	) {
-		super();
 		this.config = { table, values: values as any, withList, select, overridingSystemValue_ };
 	}
 
@@ -286,15 +385,19 @@ export class PgInsertBase<
 	 *   .returning({ id: cars.id });
 	 * ```
 	 */
-	returning(): PgInsertWithout<PgInsertReturningAll<this, TDynamic>, TDynamic, 'returning'>;
+	returning(): PgInsertReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFieldsFlat>(
 		fields: TSelectedFields,
-	): PgInsertWithout<PgInsertReturning<this, TDynamic, TSelectedFields>, TDynamic, 'returning'>;
+	): PgInsertReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
-	): PgInsertWithout<AnyPgInsert, TDynamic, 'returning'> {
+	): PgInsertReturningAll<this, TDynamic> | PgInsertReturning<this, TDynamic, SelectedFieldsFlat> {
 		this.config.returningFields = fields;
-		this.config.returning = orderSelectedFields<PgColumn>(fields);
+		this.config.returning = orderSelectedFields<PgColumn>(
+			this.config.returningFields,
+			undefined,
+			this.dialect.codecs,
+		);
 		return this as any;
 	}
 
@@ -328,8 +431,8 @@ export class PgInsertBase<
 		} else {
 			let targetColumn = '';
 			targetColumn = Array.isArray(config.target)
-				? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(',')
-				: this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
+				? config.target.map((it) => this.dialect.escapeName(it.name)).join(',')
+				: this.dialect.escapeName(config.target.name);
 
 			const whereSql = config.where ? sql` where ${config.where}` : undefined;
 			this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
@@ -380,55 +483,30 @@ export class PgInsertBase<
 		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
 		let targetColumn = '';
 		targetColumn = Array.isArray(config.target)
-			? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(',')
-			: this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
+			? config.target.map((it) => this.dialect.escapeName(it.name)).join(',')
+			: this.dialect.escapeName(config.target.name);
 		this.config.onConflict = sql`(${
 			sql.raw(targetColumn)
 		})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): PgInsertWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
 		return this.dialect.buildInsertQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): PgInsertPrepare<this> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery<
-				PreparedQueryConfig & {
-					execute: TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[];
-				}
-			>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			}, this.cacheConfig);
-		});
-	}
-
-	prepare(name: string): PgInsertPrepare<this> {
-		return this._prepare(name);
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues, this.authToken);
-		});
-	};
-
 	/** @internal */
 	getSelectedFields(): this['_']['selectedFields'] {
 		return (
@@ -445,6 +523,12 @@ export class PgInsertBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	withoutSelectionCastCodecs() {
+		this.config.ignoreSelectionCastCodecs = true;
+		return this;
+	}
+
 	$dynamic(): PgInsertDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/pg-core/query-builders/query-builder.ts b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
index e6c749adde..8181a6722c 100644
--- a/drizzle-orm/src/pg-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
@@ -33,12 +33,14 @@ export class QueryBuilder {
 				qb = qb(queryBuilder);
 			}
 
+			const sql = ('withoutSelectionCastCodecs' in qb ? qb.withoutSelectionCastCodecs() : qb).getSQL();
 			return new Proxy(
 				new WithSubquery(
-					qb.getSQL(),
+					sql,
 					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
 					alias,
 					true,
+					sql.usedTables ?? [],
 				),
 				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 			) as any;
@@ -49,11 +51,11 @@ export class QueryBuilder {
 	with(...queries: WithSubquery[]) {
 		const self = this;
 
-		function select(): PgSelectBuilder<undefined, 'qb'>;
-		function select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, 'qb'>;
+		function select(): PgSelectBuilder<undefined>;
+		function select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
 		function select<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): PgSelectBuilder<TSelection | undefined, 'qb'> {
+		): PgSelectBuilder<TSelection | undefined> {
 			return new PgSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -62,11 +64,13 @@ export class QueryBuilder {
 			});
 		}
 
-		function selectDistinct(): PgSelectBuilder<undefined, 'qb'>;
-		function selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, 'qb'>;
+		function selectDistinct(): PgSelectBuilder<undefined>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): PgSelectBuilder<TSelection>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): PgSelectBuilder<TSelection | undefined, 'qb'> {
+		): PgSelectBuilder<TSelection | undefined> {
 			return new PgSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -75,15 +79,15 @@ export class QueryBuilder {
 			});
 		}
 
-		function selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined, 'qb'>;
+		function selectDistinctOn(on: (PgColumn | SQLWrapper)[]): PgSelectBuilder<undefined>;
 		function selectDistinctOn<TSelection extends SelectedFields>(
 			on: (PgColumn | SQLWrapper)[],
 			fields: TSelection,
-		): PgSelectBuilder<TSelection, 'qb'>;
+		): PgSelectBuilder<TSelection>;
 		function selectDistinctOn<TSelection extends SelectedFields>(
 			on: (PgColumn | SQLWrapper)[],
 			fields?: TSelection,
-		): PgSelectBuilder<TSelection | undefined, 'qb'> {
+		): PgSelectBuilder<TSelection | undefined> {
 			return new PgSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -95,9 +99,11 @@ export class QueryBuilder {
 		return { select, selectDistinct, selectDistinctOn };
 	}
 
-	select(): PgSelectBuilder<undefined, 'qb'>;
-	select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection, 'qb'>;
-	select<TSelection extends SelectedFields>(fields?: TSelection): PgSelectBuilder<TSelection | undefined, 'qb'> {
+	select(): PgSelectBuilder<undefined>;
+	select<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
+	select<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): PgSelectBuilder<TSelection | undefined> {
 		return new PgSelectBuilder({
 			fields: fields ?? undefined,
 			session: undefined,
@@ -107,7 +113,9 @@ export class QueryBuilder {
 
 	selectDistinct(): PgSelectBuilder<undefined>;
 	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): PgSelectBuilder<TSelection>;
-	selectDistinct<TSelection extends SelectedFields>(fields?: TSelection): PgSelectBuilder<TSelection | undefined> {
+	selectDistinct<TSelection extends SelectedFields>(
+		fields?: TSelection,
+	): PgSelectBuilder<TSelection | undefined> {
 		return new PgSelectBuilder({
 			fields: fields ?? undefined,
 			session: undefined,
diff --git a/drizzle-orm/src/pg-core/query-builders/query.ts b/drizzle-orm/src/pg-core/query-builders/query.ts
index 816b60500c..b91b7d7ff2 100644
--- a/drizzle-orm/src/pg-core/query-builders/query.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query.ts
@@ -1,139 +1,134 @@
 import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import {
-	type BuildQueryResult,
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	mapRelationalRow,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
+import type {
+	BuildQueryResult,
+	BuildRelationalQueryResult,
+	DBQueryConfigWithComment,
+	TableRelationalConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import type { KnownKeysOnly, NeonAuthToken } from '~/utils.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
 import type { PgDialect } from '../dialect.ts';
-import type { PgPreparedQuery, PgSession, PreparedQueryConfig } from '../session.ts';
+import type { PgSession } from '../session.ts';
 import type { PgTable } from '../table.ts';
 
-export class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-	static readonly [entityKind]: string = 'PgRelationalQueryBuilder';
+export interface PgRelationalQueryConstructor {
+	new(
+		schema: TablesRelationalConfig,
+		table: PgTable,
+		tableConfig: TableRelationalConfig,
+		dialect: PgDialect,
+		session: PgSession,
+		config: DBQueryConfigWithComment<'many' | 'one'> | true,
+		mode: 'many' | 'first',
+		parseJson: boolean,
+	): AnyPgRelationalQuery;
+}
+
+export type AnyPgRelationalQuery = PgRelationalQuery<any, any>;
+
+export class RelationalQueryBuilder<
+	TSchema extends TablesRelationalConfig,
+	TFields extends TableRelationalConfig,
+	TBuilderHKT extends PgRelationalQueryHKTBase = PgRelationalQueryHKT,
+> {
+	static readonly [entityKind]: string = 'PgRelationalQueryBuilderV2';
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
 		private schema: TSchema,
-		private tableNamesMap: Record<string, string>,
 		private table: PgTable,
 		private tableConfig: TableRelationalConfig,
 		private dialect: PgDialect,
 		private session: PgSession,
+		private parseJson: boolean,
+		private builder: PgRelationalQueryConstructor = PgRelationalQuery,
 	) {}
 
-	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
-		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
-	): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]> {
-		return new PgRelationalQuery(
-			this.fullSchema,
+	findMany<TConfig extends DBQueryConfigWithComment<'many', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfigWithComment<'many', TSchema, TFields>>,
+	): PgRelationalQueryKind<TBuilderHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new this.builder(
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? (config as DBQueryConfig<'many', true>) : {},
+			config as DBQueryConfigWithComment<'many'> | undefined ?? true,
 			'many',
+			this.parseJson,
 		);
 	}
 
-	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
-		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
-	): PgRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
-		return new PgRelationalQuery(
-			this.fullSchema,
+	findFirst<TConfig extends DBQueryConfigWithComment<'one', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfigWithComment<'one', TSchema, TFields>>,
+	): PgRelationalQueryKind<TBuilderHKT, BuildQueryResult<TSchema, TFields, TConfig> | undefined> {
+		return new this.builder(
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			config as DBQueryConfigWithComment<'one'> | undefined ?? true,
 			'first',
+			this.parseJson,
 		);
 	}
 }
 
-export class PgRelationalQuery<TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'pg'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'PgRelationalQuery';
+export interface PgRelationalQueryHKTBase {
+	result: unknown;
+	_type: unknown;
+}
+
+export interface PgRelationalQueryHKT extends PgRelationalQueryHKTBase {
+	_type: PgRelationalQuery<PgRelationalQueryHKT, this['result']>;
+}
+
+export type PgRelationalQueryKind<
+	T extends PgRelationalQueryHKTBase,
+	TResult,
+> = (T & {
+	result: TResult;
+})['_type'];
+
+export class PgRelationalQuery<THKT extends PgRelationalQueryHKTBase, TResult> implements SQLWrapper {
+	static readonly [entityKind]: string = 'PgRelationalQueryV2';
 
 	declare readonly _: {
 		readonly dialect: 'pg';
+		readonly hkt: THKT;
 		readonly result: TResult;
 	};
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
-		private schema: TablesRelationalConfig,
-		private tableNamesMap: Record<string, string>,
-		private table: PgTable,
-		private tableConfig: TableRelationalConfig,
-		private dialect: PgDialect,
-		private session: PgSession,
-		private config: DBQueryConfig<'many', true> | true,
-		private mode: 'many' | 'first',
-	) {
-		super();
-	}
-
-	/** @internal */
-	_prepare(name?: string): PgPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			const { query, builtQuery } = this._toSQL();
-
-			return this.session.prepareQuery<PreparedQueryConfig & { execute: TResult }>(
-				builtQuery,
-				undefined,
-				name,
-				true,
-				(rawRows, mapColumnValue) => {
-					const rows = rawRows.map((row) =>
-						mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
-					);
-					if (this.mode === 'first') {
-						return rows[0] as TResult;
-					}
-					return rows as TResult;
-				},
-			);
-		});
-	}
-
-	prepare(name: string): PgPreparedQuery<PreparedQueryConfig & { execute: TResult }> {
-		return this._prepare(name);
-	}
+		protected schema: TablesRelationalConfig,
+		protected table: PgTable,
+		protected tableConfig: TableRelationalConfig,
+		protected dialect: PgDialect,
+		protected session: PgSession,
+		protected config: DBQueryConfigWithComment<'many' | 'one'> | true,
+		protected mode: 'many' | 'first',
+		protected parseJson: boolean,
+	) {}
 
-	private _getQuery() {
-		return this.dialect.buildRelationalQueryWithoutPK({
-			fullSchema: this.fullSchema,
+	protected _getQuery() {
+		return this.dialect.buildRelationalQuery({
 			schema: this.schema,
-			tableNamesMap: this.tableNamesMap,
 			table: this.table,
 			tableConfig: this.tableConfig,
 			queryConfig: this.config,
-			tableAlias: this.tableConfig.tsName,
+			mode: this.mode,
 		});
 	}
 
-	/** @internal */
 	getSQL(): SQL {
-		return this._getQuery().sql as SQL;
+		return this._getQuery().sql;
 	}
 
-	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
+	protected _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
 		const query = this._getQuery();
 
-		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+		const builtQuery = this.dialect.sqlToQuery(query.sql);
 
 		return { query, builtQuery };
 	}
@@ -141,17 +136,4 @@ export class PgRelationalQuery<TResult> extends QueryPromise<TResult>
 	toSQL(): Query {
 		return this._toSQL().builtQuery;
 	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	override execute(): Promise<TResult> {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(undefined, this.authToken);
-		});
-	}
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/raw.ts b/drizzle-orm/src/pg-core/query-builders/raw.ts
index d08c1ee144..c637354f87 100644
--- a/drizzle-orm/src/pg-core/query-builders/raw.ts
+++ b/drizzle-orm/src/pg-core/query-builders/raw.ts
@@ -1,15 +1,12 @@
 import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import type { PreparedQuery } from '~/session.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { PgBasePreparedQuery } from '../session.ts';
 
-export interface PgRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'pg'>, SQLWrapper {}
-
-export class PgRaw<TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'pg'>, SQLWrapper, PreparedQuery
-{
-	static override readonly [entityKind]: string = 'PgRaw';
+// oxlint-disable-next-line no-unused-vars
+export interface PgRaw<TResult> extends SQLWrapper {}
+export class PgRaw<TResult> implements SQLWrapper, PreparedQuery {
+	static readonly [entityKind]: string = 'PgRaw';
 
 	declare readonly _: {
 		readonly dialect: 'pg';
@@ -17,15 +14,12 @@ export class PgRaw<TResult> extends QueryPromise<TResult>
 	};
 
 	constructor(
-		public execute: () => Promise<TResult>,
-		private sql: SQL,
-		private query: Query,
-		private mapBatchResult: (result: unknown) => unknown,
+		protected prepared: PgBasePreparedQuery,
+		protected sql: SQL,
+		protected query: Query,
 	) {
-		super();
 	}
 
-	/** @internal */
 	getSQL() {
 		return this.sql;
 	}
@@ -34,16 +28,7 @@ export class PgRaw<TResult> extends QueryPromise<TResult>
 		return this.query;
 	}
 
-	mapResult(result: unknown, isFromBatch?: boolean) {
-		return isFromBatch ? this.mapBatchResult(result) : result;
-	}
-
-	_prepare(): PreparedQuery {
-		return this;
-	}
-
-	/** @internal */
-	isResponseInArrayMode() {
-		return false;
+	_prepare() {
+		return this.prepared;
 	}
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts b/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
index c20baaf5ad..8e6bb6441d 100644
--- a/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
+++ b/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
@@ -1,39 +1,19 @@
 import { entityKind } from '~/entity.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import type {
-	PgPreparedQuery,
-	PgQueryResultHKT,
-	PgQueryResultKind,
-	PgSession,
-	PreparedQueryConfig,
-} from '~/pg-core/session.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PgSession } from '~/pg-core/session.ts';
 import type { PgMaterializedView } from '~/pg-core/view.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import type { NeonAuthToken } from '~/utils';
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface PgRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
-	extends
-		QueryPromise<PgQueryResultKind<TQueryResult, never>>,
-		RunnableQuery<PgQueryResultKind<TQueryResult, never>, 'pg'>,
-		SQLWrapper
-{
-	readonly _: {
+// eslint-disable-next-line no-unused-vars
+export class PgRefreshMaterializedView<TQueryResult extends PgQueryResultHKT> implements SQLWrapper {
+	static readonly [entityKind]: string = 'PgRefreshMaterializedView';
+
+	declare readonly _: {
 		readonly dialect: 'pg';
 		readonly result: PgQueryResultKind<TQueryResult, never>;
 	};
-}
 
-export class PgRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
-	extends QueryPromise<PgQueryResultKind<TQueryResult, never>>
-	implements RunnableQuery<PgQueryResultKind<TQueryResult, never>, 'pg'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'PgRefreshMaterializedView';
-
-	private config: {
+	protected config: {
 		view: PgMaterializedView;
 		concurrently?: boolean;
 		withNoData?: boolean;
@@ -41,10 +21,9 @@ export class PgRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
 
 	constructor(
 		view: PgMaterializedView,
-		private session: PgSession,
-		private dialect: PgDialect,
+		protected session: PgSession,
+		protected dialect: PgDialect,
 	) {
-		super();
 		this.config = { view };
 	}
 
@@ -70,39 +49,6 @@ export class PgRefreshMaterializedView<TQueryResult extends PgQueryResultHKT>
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): PgPreparedQuery<
-		PreparedQueryConfig & {
-			execute: PgQueryResultKind<TQueryResult, never>;
-		}
-	> {
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), undefined, name, true);
-		});
-	}
-
-	prepare(name: string): PgPreparedQuery<
-		PreparedQueryConfig & {
-			execute: PgQueryResultKind<TQueryResult, never>;
-		}
-	> {
-		return this._prepare(name);
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token: NeonAuthToken) {
-		this.authToken = token;
-		return this;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
-
-	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues, this.authToken);
-		});
-	};
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index dac94cb5c4..882caf85d8 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -2,7 +2,7 @@ import type { CacheConfig, WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { PgColumn } from '~/pg-core/columns/index.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import type { PgSession, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgSession } from '~/pg-core/session.ts';
 import type { SubqueryWithSelection } from '~/pg-core/subquery.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import { PgViewBase } from '~/pg-core/view-base.ts';
@@ -17,39 +17,35 @@ import type {
 	SelectResult,
 	SetOperator,
 } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { SQL, View } from '~/sql/sql.ts';
-import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { SQL, sql, View } from '~/sql/sql.ts';
+import type { ColumnsSelection, CommentInput, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import { tracer } from '~/tracing.ts';
 import {
-	applyMixins,
+	type Assume,
 	type DrizzleTypeError,
 	getTableColumns,
 	getTableLikeName,
 	haveSameKeys,
-	type NeonAuthToken,
+	orderSelectedFields,
 	type ValueOrArray,
 } from '~/utils.ts';
-import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { extractUsedTable } from '../utils.ts';
 import type {
-	AnyPgSelect,
-	CreatePgSelectFromBuilderMode,
+	AnyPgSelectQueryBuilder,
 	GetPgSetOperators,
 	LockConfig,
 	LockStrength,
 	PgCreateSetOperatorFn,
 	PgSelectConfig,
+	PgSelectCrossJoinFn,
 	PgSelectDynamic,
-	PgSelectHKT,
 	PgSelectHKTBase,
 	PgSelectJoinFn,
-	PgSelectPrepare,
+	PgSelectKind,
+	PgSelectQueryBuilderHKT as PgSelectHKT,
 	PgSelectWithout,
 	PgSetOperatorExcludedMethods,
 	PgSetOperatorWithResult,
@@ -58,9 +54,24 @@ import type {
 	TableLikeHasEmptySelection,
 } from './select.types.ts';
 
+export interface PgSelectBuilderConstructor {
+	new(
+		config: {
+			table: PgSelectConfig['table'];
+			fields: PgSelectConfig['fields'];
+			isPartialSelect: boolean;
+			session: PgSession | undefined;
+			dialect: PgDialect;
+			withList: Subquery[];
+			distinct: boolean | { on: (PgColumn | SQLWrapper)[] } | undefined;
+			tagged?: boolean;
+		},
+	): AnyPgSelectQueryBuilder;
+}
+
 export class PgSelectBuilder<
 	TSelection extends SelectedFields | undefined,
-	TBuilderMode extends 'db' | 'qb' = 'db',
+	THKT extends PgSelectHKTBase = PgSelectHKT,
 > {
 	static readonly [entityKind]: string = 'PgSelectBuilder';
 
@@ -68,9 +79,8 @@ export class PgSelectBuilder<
 	private session: PgSession | undefined;
 	private dialect: PgDialect;
 	private withList: Subquery[] = [];
-	private distinct: boolean | {
-		on: (PgColumn | SQLWrapper)[];
-	} | undefined;
+	private distinct: boolean | { on: (PgColumn | SQLWrapper)[] } | undefined;
+	private tagged: boolean | undefined;
 
 	constructor(
 		config: {
@@ -78,10 +88,10 @@ export class PgSelectBuilder<
 			session: PgSession | undefined;
 			dialect: PgDialect;
 			withList?: Subquery[];
-			distinct?: boolean | {
-				on: (PgColumn | SQLWrapper)[];
-			};
+			distinct?: boolean | { on: (PgColumn | SQLWrapper)[] };
+			tagged?: boolean;
 		},
+		private builder: PgSelectBuilderConstructor = PgSelectBase as unknown as PgSelectBuilderConstructor,
 	) {
 		this.fields = config.fields;
 		this.session = config.session;
@@ -90,13 +100,7 @@ export class PgSelectBuilder<
 			this.withList = config.withList;
 		}
 		this.distinct = config.distinct;
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
+		// this.tagged = config.tagged; // TODO: bugged, to be remade
 	}
 
 	/**
@@ -105,23 +109,34 @@ export class PgSelectBuilder<
 	 *
 	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
 	 */
-	from<TFrom extends PgTable | Subquery | PgViewBase | SQL>(
+	from<
+		TFrom extends PgTable | Subquery | PgViewBase | SQL,
+		TConfig extends Record<string, any> = {
+			tableName: GetSelectTableName<TFrom>;
+			selection: TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection;
+			selectMode: TSelection extends undefined ? 'single' : 'partial';
+			nullabilityMap: GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, 'not-null'> : {};
+		},
+	>(
 		source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<
 				"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
 			>
 			: TFrom,
-	): CreatePgSelectFromBuilderMode<
-		TBuilderMode,
-		GetSelectTableName<TFrom>,
-		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
-		TSelection extends undefined ? 'single' : 'partial'
+	): PgSelectKind<
+		THKT,
+		TConfig['tableName'],
+		TConfig['selection'],
+		TConfig['selectMode'],
+		TConfig['tableName'] extends string ? Record<TConfig['tableName'], 'not-null'> : {},
+		false,
+		never
 	> {
 		const isPartialSelect = !!this.fields;
 		const src = source as TFrom;
 
 		let fields: SelectedFields;
 		if (this.fields) {
-			fields = this.fields;
+			fields = this.fields as SelectedFields;
 		} else if (is(src, Subquery)) {
 			// This is required to use the proxy handler to get the correct field values from the subquery
 			fields = Object.fromEntries(
@@ -137,7 +152,7 @@ export class PgSelectBuilder<
 			fields = getTableColumns<PgTable>(src);
 		}
 
-		return (new PgSelectBase({
+		return new this.builder({
 			table: src,
 			fields,
 			isPartialSelect,
@@ -145,21 +160,60 @@ export class PgSelectBuilder<
 			dialect: this.dialect,
 			withList: this.withList,
 			distinct: this.distinct,
-		}).setToken(this.authToken)) as any;
+			// tagged: this.tagged,  // TODO: bugged, to be remade
+		}) as any;
 	}
 }
 
-export abstract class PgSelectQueryBuilderBase<
+export type PgSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<
+	PgSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never
+>;
+
+export type PgSelectQueryBuilder<
+	THKT extends PgSelectHKTBase = PgSelectHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult extends any[] = unknown[],
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = PgSelectBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export class PgSelectBase<
 	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
+	TSelection extends ColumnsSelection | undefined,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<
+		Assume<TSelection, ColumnsSelection>,
+		TNullabilityMap
+	>,
 > extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static override readonly [entityKind]: string = 'PgSelectQueryBuilder';
 
@@ -180,44 +234,49 @@ export abstract class PgSelectQueryBuilderBase<
 	protected config: PgSelectConfig;
 	protected joinsNotNullableMap: Record<string, boolean>;
 	protected tableName: string | undefined;
-	private isPartialSelect: boolean;
+	protected isPartialSelect: boolean;
 	protected session: PgSession | undefined;
 	protected dialect: PgDialect;
-	protected cacheConfig?: WithCacheConfig = undefined;
+	protected cacheConfig?: WithCacheConfig;
 	protected usedTables: Set<string> = new Set();
 
 	constructor(
-		{ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+		config: {
 			table: PgSelectConfig['table'];
 			fields: PgSelectConfig['fields'];
 			isPartialSelect: boolean;
 			session: PgSession | undefined;
 			dialect: PgDialect;
 			withList: Subquery[];
-			distinct: boolean | {
-				on: (PgColumn | SQLWrapper)[];
-			} | undefined;
+			distinct: boolean | { on: (PgColumn | SQLWrapper)[] } | undefined;
+			tagged?: boolean;
 		},
 	) {
 		super();
+		this.session = config.session;
+		this.dialect = config.dialect;
 		this.config = {
-			withList,
-			table,
-			fields: { ...fields },
-			distinct,
+			withList: config.withList,
+			table: config.table,
+			fields: { ...config.fields },
+			distinct: config.distinct,
 			setOperators: [],
+			// tagged: config.tagged, // TODO: bugged, to be remade
 		};
-		this.isPartialSelect = isPartialSelect;
-		this.session = session;
-		this.dialect = dialect;
+		this.isPartialSelect = config.isPartialSelect;
 		this._ = {
-			selectedFields: fields as TSelectedFields,
+			selectedFields: this.config.fields as TSelectedFields,
 			config: this.config,
 		} as this['_'];
-		this.tableName = getTableLikeName(table);
+		this.tableName = getTableLikeName(config.table);
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
 
-		for (const item of extractUsedTable(table)) this.usedTables.add(item);
+		for (const item of extractUsedTable(config.table)) this.usedTables.add(item);
+
+		this.config.withList?.forEach((it) => {
+			const extracted = extractUsedTable(it);
+			for (const el of extracted) this.usedTables.add(el);
+		});
 	}
 
 	/** @internal */
@@ -231,7 +290,9 @@ export abstract class PgSelectQueryBuilderBase<
 	>(
 		joinType: TJoinType,
 		lateral: TIsLateral,
-	): PgSelectJoinFn<this, TDynamic, TJoinType, TIsLateral> {
+	): 'cross' extends TJoinType ? PgSelectCrossJoinFn<this, TDynamic, TIsLateral>
+		: PgSelectJoinFn<this, TDynamic, TJoinType, TIsLateral>
+	{
 		return ((
 			table: TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL,
 			on?: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -978,14 +1039,21 @@ export abstract class PgSelectQueryBuilderBase<
 		return this as any;
 	}
 
-	/** @internal */
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): PgSelectWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
+		return this as any;
+	}
+
 	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<PgColumn>(this.config.fields, undefined, this.dialect.codecs);
 		return this.dialect.buildSelectQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 	as<TAlias extends string>(
 		alias: TAlias,
@@ -995,7 +1063,9 @@ export abstract class PgSelectQueryBuilderBase<
 		if (this.config.joins) { for (const it of this.config.joins) usedTables.push(...extractUsedTable(it.table)); }
 
 		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),
+			new Subquery(this.withoutSelectionCastCodecs().getSQL(), this.config.fields, alias, false, [
+				...new Set(usedTables),
+			]),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
 	}
@@ -1008,125 +1078,32 @@ export abstract class PgSelectQueryBuilderBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	override withoutSelectionCastCodecs(): this {
+		this.config.ignoreSelectionCastCodecs = true;
+		return this;
+	}
+
 	$dynamic(): PgSelectDynamic<this> {
 		return this;
 	}
 
 	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
 		this.cacheConfig = config === undefined
-			? { config: {}, enable: true, autoInvalidate: true }
+			? { config: {}, enabled: true, autoInvalidate: true }
 			: config === false
-			? { enable: false }
-			: { enable: true, autoInvalidate: true, ...config };
+			? { enabled: false }
+			: { enabled: true, autoInvalidate: true, ...config };
 		return this;
 	}
 }
 
-export interface PgSelectBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	PgSelectQueryBuilderBase<
-		PgSelectHKT,
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	QueryPromise<TResult>,
-	SQLWrapper
-{}
-
-export class PgSelectBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends PgSelectQueryBuilderBase<
-	PgSelectHKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> implements RunnableQuery<TResult, 'pg'>, SQLWrapper {
-	static override readonly [entityKind]: string = 'PgSelect';
-
-	/** @internal */
-	_prepare(name?: string): PgSelectPrepare<this> {
-		const { session, config, dialect, joinsNotNullableMap, authToken, cacheConfig, usedTables } = this;
-		if (!session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-
-		const { fields } = config;
-
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			const fieldsList = orderSelectedFields<PgColumn>(fields);
-			const query = session.prepareQuery<
-				PreparedQueryConfig & { execute: TResult }
-			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name, true, undefined, {
-				type: 'select',
-				tables: [...usedTables],
-			}, cacheConfig);
-			query.joinsNotNullableMap = joinsNotNullableMap;
-
-			return query.setToken(authToken);
-		});
-	}
-
-	/**
-	 * Create a prepared statement for this query. This allows
-	 * the database to remember this query for the given session
-	 * and call it by name, rather than specifying the full query.
-	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
-	 */
-	prepare(name: string): PgSelectPrepare<this> {
-		return this._prepare(name);
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues, this.authToken);
-		});
-	};
-}
-
-applyMixins(PgSelectBase, [QueryPromise]);
-
 function createSetOperator(type: SetOperator, isAll: boolean): PgCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		const setOperators = [rightSelect, ...restSelects].map((select) => ({
 			type,
 			isAll,
-			rightSelect: select as AnyPgSelect,
+			rightSelect: select as AnyPgSelectQueryBuilder,
 		}));
 
 		for (const setOperator of setOperators) {
@@ -1137,7 +1114,7 @@ function createSetOperator(type: SetOperator, isAll: boolean): PgCreateSetOperat
 			}
 		}
 
-		return (leftSelect as AnyPgSelect).addSetOperators(setOperators) as any;
+		return (leftSelect as AnyPgSelectQueryBuilder).addSetOperators(setOperators) as any;
 	};
 }
 
diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 6d4de1c914..149869fd31 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -24,8 +24,7 @@ import type { ColumnsSelection, Placeholder, SQL, SQLWrapper, View } from '~/sql
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume, DrizzleTypeError, Equal, ValidateShape, ValueOrArray } from '~/utils.ts';
-import type { PgPreparedQuery, PreparedQueryConfig } from '../session.ts';
-import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.ts';
+import type { PgSelectBase } from './select.ts';
 
 export interface PgSelectJoinConfig {
 	on: SQL | undefined;
@@ -37,7 +36,7 @@ export interface PgSelectJoinConfig {
 
 export type BuildAliasTable<TTable extends PgTable | View, TAlias extends string> = TTable extends Table
 	? PgTableWithColumns<
-		UpdateTableConfig<TTable['_']['config'], {
+		UpdateTableConfig<TTable['_'], {
 			name: TAlias;
 			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'pg'>;
 		}>
@@ -77,6 +76,9 @@ export interface PgSelectConfig {
 		limit?: number | Placeholder;
 		offset?: number | Placeholder;
 	}[];
+	comment?: SQL;
+	ignoreSelectionCastCodecs?: boolean;
+	tagged?: boolean;
 }
 
 export type TableLikeHasEmptySelection<T extends PgTable | Subquery | PgViewBase | SQL> = T extends Subquery
@@ -117,25 +119,30 @@ export type PgSelectJoinFn<
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 	TIsLateral extends boolean,
-> = 'cross' extends TJoinType ? <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
-				"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
-			>
-			: TJoinedTable,
-	) => PgSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>
-	: <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
-				"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
-			>
-			: TJoinedTable,
-		on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-	) => PgSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => PgSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type PgSelectCrossJoinFn<
+	T extends AnyPgSelectQueryBuilder,
+	TDynamic extends boolean,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL : PgTable | Subquery | PgViewBase | SQL),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<
+			"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"
+		>
+		: TJoinedTable,
+) => PgSelectJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectedFieldsFlatBase<PgColumn>;
 
@@ -194,21 +201,8 @@ export type PgSelectKind<
 })['_type'];
 
 export interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
-	_type: PgSelectQueryBuilderBase<
-		PgSelectQueryBuilderHKT,
-		this['tableName'],
-		Assume<this['selection'], ColumnsSelection>,
-		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
-		this['dynamic'],
-		this['excludedMethods'],
-		Assume<this['result'], any[]>,
-		Assume<this['selectedFields'], ColumnsSelection>
-	>;
-}
-
-export interface PgSelectHKT extends PgSelectHKTBase {
 	_type: PgSelectBase<
+		PgSelectQueryBuilderHKT,
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
@@ -220,14 +214,6 @@ export interface PgSelectHKT extends PgSelectHKTBase {
 	>;
 }
 
-export type CreatePgSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-> = TBuilderMode extends 'db' ? PgSelectBase<TTableName, TSelection, TSelectMode>
-	: PgSelectQueryBuilderBase<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
-
 export type PgSetOperatorExcludedMethods =
 	| 'leftJoin'
 	| 'rightJoin'
@@ -258,12 +244,6 @@ export type PgSelectWithout<
 	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
 >;
 
-export type PgSelectPrepare<T extends AnyPgSelect> = PgPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['result'];
-	}
->;
-
 export type PgSelectDynamic<T extends AnyPgSelectQueryBuilder> = PgSelectKind<
 	T['_']['hkt'],
 	T['_']['tableName'],
@@ -276,31 +256,12 @@ export type PgSelectDynamic<T extends AnyPgSelectQueryBuilder> = PgSelectKind<
 	T['_']['selectedFields']
 >;
 
-export type PgSelectQueryBuilder<
-	THKT extends PgSelectHKTBase = PgSelectQueryBuilderHKT,
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = ColumnsSelection,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-	TResult extends any[] = unknown[],
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = PgSelectQueryBuilderBase<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	true,
-	never,
-	TResult,
-	TSelectedFields
->;
-
-export type AnyPgSelectQueryBuilder = PgSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+export type AnyPgSelectQueryBuilder = PgSelectBase<any, any, any, any, any, any, any, any, any>;
 
 export type AnyPgSetOperatorInterface = PgSetOperatorInterface<any, any, any, any, any, any, any, any>;
 
 export interface PgSetOperatorInterface<
+	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -312,7 +273,7 @@ export interface PgSetOperatorInterface<
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > {
 	_: {
-		readonly hkt: PgSelectHKT;
+		readonly hkt: THKT;
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -325,6 +286,7 @@ export interface PgSetOperatorInterface<
 }
 
 export type PgSetOperatorWithResult<TResult extends any[]> = PgSetOperatorInterface<
+	PgSelectQueryBuilderHKT,
 	any,
 	any,
 	any,
@@ -335,21 +297,13 @@ export type PgSetOperatorWithResult<TResult extends any[]> = PgSetOperatorInterf
 	any
 >;
 
-export type PgSelect<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
-
 export type PgSetOperator<
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 > = PgSelectBase<
+	PgSelectQueryBuilderHKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
@@ -361,7 +315,7 @@ export type PgSetOperator<
 export type SetOperatorRightSelect<
 	TValue extends PgSetOperatorWithResult<TResult>,
 	TResult extends any[],
-> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
+> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
 		TValueResult[number],
 		TResult[number],
 		TypedQueryBuilder<any, TValueResult>
@@ -372,7 +326,7 @@ export type SetOperatorRestSelect<
 	TValue extends readonly PgSetOperatorWithResult<TResult>[],
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
-	? First extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
+	? First extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
 		? Rest extends AnyPgSetOperatorInterface[] ? [
 				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
 				...SetOperatorRestSelect<Rest, TResult>,
@@ -382,6 +336,7 @@ export type SetOperatorRestSelect<
 	: TValue;
 
 export type PgCreateSetOperatorFn = <
+	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -395,6 +350,7 @@ export type PgCreateSetOperatorFn = <
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: PgSetOperatorInterface<
+		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -408,6 +364,7 @@ export type PgCreateSetOperatorFn = <
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
 ) => PgSelectWithout<
 	PgSelectBase<
+		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
diff --git a/drizzle-orm/src/pg-core/query-builders/update.ts b/drizzle-orm/src/pg-core/query-builders/update.ts
index f9e366fbc6..a814e0f283 100644
--- a/drizzle-orm/src/pg-core/query-builders/update.ts
+++ b/drizzle-orm/src/pg-core/query-builders/update.ts
@@ -1,14 +1,7 @@
-import type { WithCacheConfig } from '~/cache/core/types.ts';
 import type { GetColumnData } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import type {
-	PgPreparedQuery,
-	PgQueryResultHKT,
-	PgQueryResultKind,
-	PgSession,
-	PreparedQueryConfig,
-} from '~/pg-core/session.ts';
+import type { PgQueryResultHKT, PgQueryResultKind, PgSession } from '~/pg-core/session.ts';
 import { PgTable } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
@@ -21,26 +14,30 @@ import type {
 	SelectMode,
 	SelectResult,
 } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type Query, SQL, type SQLWrapper } from '~/sql/sql.ts';
+import {
+	type ColumnsSelection,
+	type CommentInput,
+	type Placeholder,
+	type Query,
+	SQL,
+	sql,
+	type SQLWrapper,
+} from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
-import { getTableName, Table } from '~/table.ts';
+import { getTableName, type InferInsertModel, Table } from '~/table.ts';
 import {
 	type Assume,
 	type DrizzleTypeError,
 	type Equal,
 	getTableLikeName,
 	mapUpdateSet,
-	type NeonAuthToken,
 	orderSelectedFields,
 	type Simplify,
 	type UpdateSet,
 } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { PgColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import type { PgViewBase } from '../view-base.ts';
 import type {
 	PgSelectJoinConfig,
@@ -58,19 +55,39 @@ export interface PgUpdateConfig {
 	returningFields?: SelectedFields;
 	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
+	comment?: SQL;
+	ignoreSelectionCastCodecs?: boolean;
 }
 
-export type PgUpdateSetSource<TTable extends PgTable> =
+export type PgUpdateSetSource<
+	TTable extends PgTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]?:
+		[Key in keyof TModel & string]?:
 			| GetColumnData<TTable['_']['columns'][Key]>
 			| SQL
 			| PgColumn
+			| Placeholder
 			| undefined;
 	}
 	& {};
 
-export class PgUpdateBuilder<TTable extends PgTable, TQueryResult extends PgQueryResultHKT> {
+export interface PgUpdateBuilderConstructor {
+	new(
+		table: PgTable,
+		set: UpdateSet,
+		session: PgSession,
+		dialect: PgDialect,
+		withList?: Subquery[],
+	): AnyPgUpdate;
+}
+
+export class PgUpdateBuilder<
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TBuilderHKT extends PgUpdateHKTBase = PgUpdateHKT,
+> {
 	static readonly [entityKind]: string = 'PgUpdateBuilder';
 
 	declare readonly _: {
@@ -82,24 +99,25 @@ export class PgUpdateBuilder<TTable extends PgTable, TQueryResult extends PgQuer
 		private session: PgSession,
 		private dialect: PgDialect,
 		private withList?: Subquery[],
+		private builder: PgUpdateBuilderConstructor = PgUpdateBase,
 	) {}
 
-	private authToken?: NeonAuthToken;
-	setToken(token: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
 	set(
 		values: PgUpdateSetSource<TTable>,
-	): PgUpdateWithout<PgUpdateBase<TTable, TQueryResult>, false, 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'> {
-		return new PgUpdateBase<TTable, TQueryResult>(
+	): PgUpdateWithout<
+		Assume<PgUpdateKind<TBuilderHKT, TTable, TQueryResult>, AnyPgUpdate>,
+		false,
+		'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'
+	> {
+		const builder = new this.builder(
 			this.table,
 			mapUpdateSet(this.table, values),
 			this.session,
 			this.dialect,
 			this.withList,
-		).setToken(this.authToken);
+		) as AnyPgUpdate;
+
+		return builder as any;
 	}
 }
 
@@ -108,7 +126,8 @@ export type PgUpdateWithout<
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T : Omit<
-	PgUpdateBase<
+	PgUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
 		T['_']['queryResult'],
 		T['_']['from'],
@@ -126,8 +145,9 @@ export type PgUpdateWithJoins<
 	T extends AnyPgUpdate,
 	TDynamic extends boolean,
 	TFrom extends PgTable | Subquery | PgViewBase | SQL,
-> = TDynamic extends true ? T : Omit<
-	PgUpdateBase<
+> = Omit<
+	PgUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
 		T['_']['queryResult'],
 		TFrom,
@@ -140,9 +160,11 @@ export type PgUpdateWithJoins<
 			table: TFrom;
 		}],
 		TDynamic,
-		Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
+		TDynamic extends true ? never
+			: Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
 	>,
-	Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
+	TDynamic extends true ? never
+		: Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>
 >;
 
 export type PgUpdateJoinFn<
@@ -174,23 +196,27 @@ export type PgUpdateJoin<
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 	TJoinedTable extends PgTable | Subquery | PgViewBase | SQL,
-> = TDynamic extends true ? T : PgUpdateBase<
-	T['_']['table'],
-	T['_']['queryResult'],
-	T['_']['from'],
-	T['_']['selectedFields'],
-	T['_']['returning'],
-	AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>,
-	[...T['_']['joins'], {
-		name: GetSelectTableName<TJoinedTable>;
-		joinType: TJoinType;
-		table: TJoinedTable;
-	}],
-	TDynamic,
-	T['_']['excludedMethods']
+> = Omit<
+	PgUpdateKind<
+		T['_']['hkt'],
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['from'],
+		T['_']['selectedFields'],
+		T['_']['returning'],
+		AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>,
+		[...T['_']['joins'], {
+			name: GetSelectTableName<TJoinedTable>;
+			joinType: TJoinType;
+			table: TJoinedTable;
+		}],
+		TDynamic,
+		TDynamic extends true ? never : T['_']['excludedMethods']
+	>,
+	TDynamic extends true ? never : T['_']['excludedMethods']
 >;
 
-type Join = {
+export type Join = {
 	name: string | undefined;
 	joinType: JoinType;
 	table: PgTable | Subquery | PgViewBase | SQL;
@@ -217,79 +243,81 @@ type AccumulateToResult<
 	>
 	: TSelectedFields;
 
-export type PgUpdateReturningAll<T extends AnyPgUpdate, TDynamic extends boolean> = PgUpdateWithout<
-	PgUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['from'],
-		Equal<T['_']['joins'], []> extends true ? T['_']['table']['_']['columns'] : Simplify<
-			& Record<T['_']['table']['_']['name'], T['_']['table']['_']['columns']>
-			& {
-				[K in keyof T['_']['joins'] as T['_']['joins'][K]['table']['_']['name']]:
-					T['_']['joins'][K]['table']['_']['columns'];
-			}
-		>,
-		SelectResult<
-			AccumulateToResult<
-				T,
-				'single',
-				T['_']['joins'],
-				GetSelectTableSelection<T['_']['table']>
+export type PgUpdateReturningAll<T extends AnyPgUpdate, TDynamic extends boolean> = T extends any ? PgUpdateWithout<
+		PgUpdateKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['from'],
+			Equal<T['_']['joins'], []> extends true ? T['_']['table']['_']['columns'] : Simplify<
+				& Record<T['_']['table']['_']['name'], T['_']['table']['_']['columns']>
+				& {
+					[K in keyof T['_']['joins'] as T['_']['joins'][K]['table']['_']['name']]:
+						T['_']['joins'][K]['table']['_']['columns'];
+				}
+			>,
+			SelectResult<
+				AccumulateToResult<
+					T,
+					'single',
+					T['_']['joins'],
+					GetSelectTableSelection<T['_']['table']>
+				>,
+				'partial',
+				T['_']['nullabilityMap']
 			>,
-			'partial',
-			T['_']['nullabilityMap']
+			T['_']['nullabilityMap'],
+			T['_']['joins'],
+			TDynamic,
+			T['_']['excludedMethods']
 		>,
-		T['_']['nullabilityMap'],
-		T['_']['joins'],
 		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
+		'returning'
+	>
+	: never;
 
 export type PgUpdateReturning<
 	T extends AnyPgUpdate,
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFields,
-> = PgUpdateWithout<
-	PgUpdateBase<
-		T['_']['table'],
-		T['_']['queryResult'],
-		T['_']['from'],
-		TSelectedFields,
-		SelectResult<
-			AccumulateToResult<
-				T,
+> = T extends any ? PgUpdateWithout<
+		PgUpdateKind<
+			T['_']['hkt'],
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['from'],
+			TSelectedFields,
+			SelectResult<
+				AccumulateToResult<
+					T,
+					'partial',
+					T['_']['joins'],
+					TSelectedFields
+				>,
 				'partial',
-				T['_']['joins'],
-				TSelectedFields
+				T['_']['nullabilityMap']
 			>,
-			'partial',
-			T['_']['nullabilityMap']
+			T['_']['nullabilityMap'],
+			T['_']['joins'],
+			TDynamic,
+			T['_']['excludedMethods']
 		>,
-		T['_']['nullabilityMap'],
-		T['_']['joins'],
 		TDynamic,
-		T['_']['excludedMethods']
-	>,
-	TDynamic,
-	'returning'
->;
-
-export type PgUpdatePrepare<T extends AnyPgUpdate> = PgPreparedQuery<
-	PreparedQueryConfig & {
-		execute: T['_']['returning'] extends undefined ? PgQueryResultKind<T['_']['queryResult'], never>
-			: T['_']['returning'][];
-	}
->;
+		'returning'
+	>
+	: never;
 
-export type PgUpdateDynamic<T extends AnyPgUpdate> = PgUpdate<
+export type PgUpdateDynamic<T extends AnyPgUpdate> = PgUpdateKind<
+	T['_']['hkt'],
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['from'],
+	T['_']['selectedFields'],
 	T['_']['returning'],
-	T['_']['nullabilityMap']
+	T['_']['nullabilityMap'],
+	T['_']['joins'],
+	true,
+	never
 >;
 
 export type PgUpdate<
@@ -300,11 +328,75 @@ export type PgUpdate<
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
 	TJoins extends Join[] = [],
-> = PgUpdateBase<TTable, TQueryResult, TFrom, TSelectedFields, TReturning, TNullabilityMap, TJoins, true, never>;
+> = PgUpdateBase<
+	PgUpdateHKT,
+	TTable,
+	TQueryResult,
+	TFrom,
+	TSelectedFields,
+	TReturning,
+	TNullabilityMap,
+	TJoins,
+	true,
+	never
+>;
+
+export interface PgUpdateHKTBase {
+	table: unknown;
+	joins: unknown;
+	nullabilityMap: unknown;
+	queryResult: unknown;
+	from: unknown;
+	selectedFields: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	_type: unknown;
+}
+
+export interface PgUpdateHKT extends PgUpdateHKTBase {
+	_type: PgUpdateBase<
+		PgUpdateHKT,
+		Assume<this['table'], PgTable>,
+		Assume<this['queryResult'], PgQueryResultHKT>,
+		Assume<this['from'], PgTable | Subquery | PgViewBase | SQL | undefined>,
+		Assume<this['selectedFields'], ColumnsSelection | undefined>,
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		Assume<this['joins'], Join[]>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
 
-export type AnyPgUpdate = PgUpdateBase<any, any, any, any, any, any, any, any, any>;
+export type PgUpdateKind<
+	T extends PgUpdateHKTBase,
+	TTable extends PgTable,
+	TQueryResult extends PgQueryResultHKT,
+	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
+	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
+	TJoins extends Join[] = [],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	joins: TJoins;
+	nullabilityMap: TNullabilityMap;
+	queryResult: TQueryResult;
+	from: TFrom;
+	selectedFields: TSelectedFields;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[];
+})['_type'];
+
+export type AnyPgUpdate = PgUpdateBase<any, any, any, any, any, any, any, any, any, any>;
 
 export interface PgUpdateBase<
+	THKT extends PgUpdateHKTBase,
 	TTable extends PgTable,
 	TQueryResult extends PgQueryResultHKT,
 	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
@@ -319,12 +411,11 @@ export interface PgUpdateBase<
 		TSelectedFields,
 		TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]
 	>,
-	QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
 	SQLWrapper
 {
 	readonly _: {
 		readonly dialect: 'pg';
+		readonly hkt: THKT;
 		readonly table: TTable;
 		readonly joins: TJoins;
 		readonly nullabilityMap: TNullabilityMap;
@@ -339,11 +430,15 @@ export interface PgUpdateBase<
 }
 
 export class PgUpdateBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends PgUpdateHKTBase,
 	TTable extends PgTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TQueryResult extends PgQueryResultHKT,
 	TFrom extends PgTable | Subquery | PgViewBase | SQL | undefined = undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TSelectedFields extends ColumnsSelection | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TReturning extends Record<string, unknown> | undefined = undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>,
@@ -353,26 +448,20 @@ export class PgUpdateBase<
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[]>
-	implements
-		RunnableQuery<TReturning extends undefined ? PgQueryResultKind<TQueryResult, never> : TReturning[], 'pg'>,
-		SQLWrapper
-{
-	static override readonly [entityKind]: string = 'PgUpdate';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'PgUpdate';
 
-	private config: PgUpdateConfig;
-	private tableName: string | undefined;
-	private joinsNotNullableMap: Record<string, boolean>;
-	protected cacheConfig?: WithCacheConfig;
+	protected config: PgUpdateConfig;
+	protected tableName: string | undefined;
+	protected joinsNotNullableMap: Record<string, boolean>;
 
 	constructor(
 		table: TTable,
 		set: UpdateSet,
-		private session: PgSession,
-		private dialect: PgDialect,
+		protected session: PgSession,
+		protected dialect: PgDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { set, table, withList, joins: [] };
 		this.tableName = getTableLikeName(table);
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
@@ -538,7 +627,7 @@ export class PgUpdateBase<
 	): PgUpdateReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields?: SelectedFields,
-	): PgUpdateWithout<AnyPgUpdate, TDynamic, 'returning'> {
+	): PgUpdateReturningAll<this, TDynamic> | PgUpdateReturning<this, TDynamic, SelectedFields> {
 		if (!fields) {
 			fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);
 
@@ -562,47 +651,30 @@ export class PgUpdateBase<
 		}
 
 		this.config.returningFields = fields;
-		this.config.returning = orderSelectedFields<PgColumn>(fields);
+		this.config.returning = orderSelectedFields<PgColumn>(
+			fields,
+			undefined,
+			this.dialect.codecs,
+		);
+		return this as any;
+	}
+
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment(comment: CommentInput): PgUpdateWithout<this, TDynamic, 'comment'> {
+		this.config.comment = sql.comment(comment);
 		return this as any;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
 		return this.dialect.buildUpdateQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(name?: string): PgUpdatePrepare<this> {
-		const query = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: TReturning[] }
-		>(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, undefined, {
-			type: 'insert',
-			tables: extractUsedTable(this.config.table),
-		}, this.cacheConfig);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
-	prepare(name: string): PgUpdatePrepare<this> {
-		return this._prepare(name);
-	}
-
-	private authToken?: NeonAuthToken;
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return this._prepare().execute(placeholderValues, this.authToken);
-	};
-
 	/** @internal */
 	getSelectedFields(): this['_']['selectedFields'] {
 		return (
@@ -619,6 +691,12 @@ export class PgUpdateBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	withoutSelectionCastCodecs() {
+		this.config.ignoreSelectionCastCodecs = true;
+		return this;
+	}
+
 	$dynamic(): PgUpdateDynamic<this> {
 		return this as any;
 	}
diff --git a/drizzle-orm/src/pg-core/schema.ts b/drizzle-orm/src/pg-core/schema.ts
index 828cef1ca0..a8d5adbf5a 100644
--- a/drizzle-orm/src/pg-core/schema.ts
+++ b/drizzle-orm/src/pg-core/schema.ts
@@ -1,27 +1,40 @@
+import type { Casing } from '~/casing.ts';
 import { entityKind, is } from '~/entity.ts';
 import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
 import type { NonArray, Writable } from '~/utils.ts';
 import { type PgEnum, type PgEnumObject, pgEnumObjectWithSchema, pgEnumWithSchema } from './columns/enum.ts';
 import { type pgSequence, pgSequenceWithSchema } from './sequence.ts';
-import { type PgTableFn, pgTableWithSchema } from './table.ts';
+import { EnableRLS, type PgTableFn, type PgTableFnInternal, pgTableWithSchema } from './table.ts';
 import { type pgMaterializedView, pgMaterializedViewWithSchema, type pgView, pgViewWithSchema } from './view.ts';
 
 export class PgSchema<TName extends string = string> implements SQLWrapper {
 	static readonly [entityKind]: string = 'PgSchema';
+
+	isExisting: boolean = false;
 	constructor(
 		public readonly schemaName: TName,
-	) {}
+		protected casing: Casing | undefined,
+	) {
+		this.table = Object.assign(this.table, {
+			withRLS: ((name, columns, extraConfig) => {
+				const table = pgTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
+				table[EnableRLS] = true;
+
+				return table;
+			}) as PgTableFnInternal<TName>,
+		});
+	}
 
 	table: PgTableFn<TName> = ((name, columns, extraConfig) => {
-		return pgTableWithSchema(name, columns, extraConfig, this.schemaName);
-	});
+		return pgTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
+	}) as PgTableFn<TName>;
 
 	view = ((name, columns) => {
-		return pgViewWithSchema(name, columns, this.schemaName);
+		return pgViewWithSchema(name, columns, this.schemaName, this.casing);
 	}) as typeof pgView;
 
 	materializedView = ((name, columns) => {
-		return pgMaterializedViewWithSchema(name, columns, this.schemaName);
+		return pgMaterializedViewWithSchema(name, columns, this.schemaName, this.casing);
 	}) as typeof pgMaterializedView;
 
 	public enum<U extends string, T extends Readonly<[U, ...U[]]>>(
@@ -55,18 +68,27 @@ export class PgSchema<TName extends string = string> implements SQLWrapper {
 	shouldOmitSQLParens(): boolean {
 		return true;
 	}
+
+	existing(): this {
+		this.isExisting = true;
+		return this;
+	}
 }
 
 export function isPgSchema(obj: unknown): obj is PgSchema {
 	return is(obj, PgSchema);
 }
 
-export function pgSchema<T extends string>(name: T) {
+export function pgSchema<T extends string>(name: T): PgSchema<T>;
+/** @internal */
+export function pgSchema<T extends string>(name: T, casing: Casing | undefined): PgSchema<T>;
+/** @internal */
+export function pgSchema<T extends string>(name: T, casing?: Casing): PgSchema<T> {
 	if (name === 'public') {
 		throw new Error(
 			`You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use pgTable() instead of creating a schema`,
 		);
 	}
 
-	return new PgSchema(name);
+	return new PgSchema(name, casing);
 }
diff --git a/drizzle-orm/src/pg-core/session.ts b/drizzle-orm/src/pg-core/session.ts
index 47f848e17a..355b472f54 100644
--- a/drizzle-orm/src/pg-core/session.ts
+++ b/drizzle-orm/src/pg-core/session.ts
@@ -1,163 +1,25 @@
-import { type Cache, hashQuery, NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind, is } from '~/entity.ts';
-import { TransactionRollbackError } from '~/errors.ts';
-import { DrizzleQueryError } from '~/errors/index.ts';
-import type { TablesRelationalConfig } from '~/relations.ts';
+import { entityKind } from '~/entity.ts';
 import type { PreparedQuery } from '~/session.ts';
-import { type Query, type SQL, sql } from '~/sql/index.ts';
-import { tracer } from '~/tracing.ts';
-import type { NeonAuthToken } from '~/utils.ts';
-import { PgDatabase } from './db.ts';
+import type { Query, SQL } from '~/sql/index.ts';
 import type { PgDialect } from './dialect.ts';
-import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
 
 export interface PreparedQueryConfig {
 	execute: unknown;
-	all: unknown;
-	values: unknown;
 }
 
-export abstract class PgPreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
+export abstract class PgBasePreparedQuery implements PreparedQuery {
+	static readonly [entityKind]: string = 'PgBasePreparedQuery';
+
 	constructor(
 		protected query: Query,
-		// cache instance
-		private cache: Cache | undefined,
-		// per query related metadata
-		private queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		// config that was passed through $withCache
-		private cacheConfig?: WithCacheConfig,
-	) {
-		// it means that no $withCache options were passed and it should be just enabled
-		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
-			this.cacheConfig = { enable: true, autoInvalidate: true };
-		}
-		if (!this.cacheConfig?.enable) {
-			this.cacheConfig = undefined;
-		}
-	}
-
-	protected authToken?: NeonAuthToken;
+	) {}
 
 	getQuery(): Query {
 		return this.query;
 	}
 
-	mapResult(response: unknown, _isFromBatch?: boolean): unknown {
-		return response;
-	}
-
-	/** @internal */
-	setToken(token?: NeonAuthToken) {
-		this.authToken = token;
-		return this;
-	}
-
-	static readonly [entityKind]: string = 'PgPreparedQuery';
-
-	/** @internal */
-	joinsNotNullableMap?: Record<string, boolean>;
-
-	/** @internal */
-	protected async queryWithCache<T>(
-		queryString: string,
-		params: any[],
-		query: () => Promise<T>,
-	): Promise<T> {
-		if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any mutations, if globally is false
-		if (this.cacheConfig && !this.cacheConfig.enable) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
-		if (
-			(
-				this.queryMetadata.type === 'insert' || this.queryMetadata.type === 'update'
-				|| this.queryMetadata.type === 'delete'
-			) && this.queryMetadata.tables.length > 0
-		) {
-			try {
-				const [res] = await Promise.all([
-					query(),
-					this.cache.onMutate({ tables: this.queryMetadata.tables }),
-				]);
-				return res;
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any reads if globally disabled
-		if (!this.cacheConfig) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		if (this.queryMetadata.type === 'select') {
-			const fromCache = await this.cache.get(
-				this.cacheConfig.tag ?? await hashQuery(queryString, params),
-				this.queryMetadata.tables,
-				this.cacheConfig.tag !== undefined,
-				this.cacheConfig.autoInvalidate,
-			);
-			if (fromCache === undefined) {
-				let result;
-				try {
-					result = await query();
-				} catch (e) {
-					throw new DrizzleQueryError(queryString, params, e as Error);
-				}
-				// put actual key
-				await this.cache.put(
-					this.cacheConfig.tag ?? await hashQuery(queryString, params),
-					result,
-					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
-					this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
-					this.cacheConfig.tag !== undefined,
-					this.cacheConfig.config,
-				);
-				// put flag if we should invalidate or not
-				return result;
-			}
-
-			return fromCache as unknown as T;
-		}
-		try {
-			return await query();
-		} catch (e) {
-			throw new DrizzleQueryError(queryString, params, e as Error);
-		}
-	}
-
-	abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-	/** @internal */
-	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
-	/** @internal */
-	abstract execute(placeholderValues?: Record<string, unknown>, token?: NeonAuthToken): Promise<T['execute']>;
-
-	/** @internal */
-	abstract all(placeholderValues?: Record<string, unknown>): Promise<T['all']>;
-
-	/** @internal */
-	abstract isResponseInArrayMode(): boolean;
+	abstract execute(placeholderValues?: Record<string, unknown>): unknown;
 }
 
 export interface PgTransactionConfig {
@@ -166,120 +28,26 @@ export interface PgTransactionConfig {
 	deferrable?: boolean;
 }
 
-export abstract class PgSession<
-	TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> {
+export abstract class PgSession {
 	static readonly [entityKind]: string = 'PgSession';
 
 	constructor(protected dialect: PgDialect) {}
 
-	abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+	abstract prepareQuery(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: unknown[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T>;
-
-	execute<T>(query: SQL): Promise<T>;
-	/** @internal */
-	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T>;
-	/** @internal */
-	execute<T>(query: SQL, token?: NeonAuthToken): Promise<T> {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			const prepared = tracer.startActiveSpan('drizzle.prepareQuery', () => {
-				return this.prepareQuery<PreparedQueryConfig & { execute: T }>(
-					this.dialect.sqlToQuery(query),
-					undefined,
-					undefined,
-					false,
-				);
-			});
-
-			return prepared.setToken(token).execute(undefined, token);
-		});
-	}
-
-	all<T = unknown>(query: SQL): Promise<T[]> {
-		return this.prepareQuery<PreparedQueryConfig & { all: T[] }>(
-			this.dialect.sqlToQuery(query),
-			undefined,
-			undefined,
-			false,
-		).all();
-	}
-
-	async count(sql: SQL): Promise<number>;
-	/** @internal */
-	async count(sql: SQL, token?: NeonAuthToken): Promise<number>;
-	/** @internal */
-	async count(sql: SQL, token?: NeonAuthToken): Promise<number> {
-		const res = await this.execute<[{ count: string }]>(sql, token);
-
-		return Number(
-			res[0]['count'],
-		);
-	}
-
-	abstract transaction<T>(
-		transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-		config?: PgTransactionConfig,
-	): Promise<T>;
-}
-
-export abstract class PgTransaction<
-	TQueryResult extends PgQueryResultHKT,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends PgDatabase<TQueryResult, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'PgTransaction';
-
-	constructor(
-		dialect: PgDialect,
-		session: PgSession<any, any, any>,
-		protected schema: {
-			fullSchema: Record<string, unknown>;
-			schema: TSchema;
-			tableNamesMap: Record<string, string>;
-		} | undefined,
-		protected readonly nestedIndex = 0,
-	) {
-		super(dialect, session, schema);
-	}
-
-	rollback(): never {
-		throw new TransactionRollbackError();
-	}
-
-	/** @internal */
-	getTransactionConfigSQL(config: PgTransactionConfig): SQL {
-		const chunks: string[] = [];
-		if (config.isolationLevel) {
-			chunks.push(`isolation level ${config.isolationLevel}`);
-		}
-		if (config.accessMode) {
-			chunks.push(config.accessMode);
-		}
-		if (typeof config.deferrable === 'boolean') {
-			chunks.push(config.deferrable ? 'deferrable' : 'not deferrable');
-		}
-		return sql.raw(chunks.join(' '));
-	}
-
-	setTransaction(config: PgTransactionConfig): Promise<void> {
-		return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
-	}
+	): PgBasePreparedQuery;
 
-	abstract override transaction<T>(
-		transaction: (tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T>;
+	abstract execute(query: SQL): unknown;
+	abstract arrays(query: SQL): unknown;
+	abstract objects(query: SQL): unknown;
 }
 
 export interface PgQueryResultHKT {
diff --git a/drizzle-orm/src/pg-core/table.ts b/drizzle-orm/src/pg-core/table.ts
index e66de1dd71..8522fb2562 100644
--- a/drizzle-orm/src/pg-core/table.ts
+++ b/drizzle-orm/src/pg-core/table.ts
@@ -1,9 +1,18 @@
-import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts';
+import { type Casing, getCasingFn } from '~/casing.ts';
 import { entityKind } from '~/entity.ts';
+import type { InferModelFromColumns } from '~/table.ts';
 import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
 import type { CheckBuilder } from './checks.ts';
 import { getPgColumnBuilders, type PgColumnsBuilders } from './columns/all.ts';
-import type { ExtraConfigColumn, PgColumn, PgColumnBuilder, PgColumnBuilderBase } from './columns/common.ts';
+import type {
+	AnyPgColumnBuilder,
+	ExtraConfigColumn,
+	PgBuildColumns,
+	PgBuildExtraConfigColumns,
+	PgColumn,
+	PgColumnBuilder,
+	PgColumns,
+} from './columns/common.ts';
 import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import type { AnyIndexBuilder } from './indexes.ts';
 import type { PgPolicy } from './policies.ts';
@@ -18,19 +27,16 @@ export type PgTableExtraConfigValue =
 	| UniqueConstraintBuilder
 	| PgPolicy;
 
-export type PgTableExtraConfig = Record<
-	string,
-	PgTableExtraConfigValue
->;
+export type PgTableExtraConfig = Record<string, PgTableExtraConfigValue>;
 
-export type TableConfig = TableConfigBase<PgColumn>;
+export type TableConfig = TableConfigBase<PgColumns>;
 
 /** @internal */
 export const InlineForeignKeys = Symbol.for('drizzle:PgInlineForeignKeys');
 /** @internal */
 export const EnableRLS = Symbol.for('drizzle:EnableRLS');
 
-export class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+export class PgTable<out T extends TableConfig = TableConfig> extends Table<T> {
 	static override readonly [entityKind]: string = 'PgTable';
 
 	/** @internal */
@@ -57,10 +63,13 @@ export type AnyPgTable<TPartial extends Partial<TableConfig> = {}> = PgTable<Upd
 
 export type PgTableWithColumns<T extends TableConfig> =
 	& PgTable<T>
+	& T['columns']
 	& {
-		[Key in keyof T['columns']]: T['columns'][Key];
+		readonly $inferSelect: InferModelFromColumns<T['columns'], 'select'>;
+		readonly $inferInsert: InferModelFromColumns<T['columns'], 'insert'>;
 	}
 	& {
+		/** @deprecated use `pgTable.withRLS()` instead*/
 		enableRLS: () => Omit<
 			PgTableWithColumns<T>,
 			'enableRLS'
@@ -71,25 +80,27 @@ export type PgTableWithColumns<T extends TableConfig> =
 export function pgTableWithSchema<
 	TTableName extends string,
 	TSchemaName extends string | undefined,
-	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	TColumnsMap extends Record<string, AnyPgColumnBuilder>,
 >(
 	name: TTableName,
 	columns: TColumnsMap | ((columnTypes: PgColumnsBuilders) => TColumnsMap),
 	extraConfig:
-		| ((self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig | PgTableExtraConfigValue[])
+		| ((self: PgBuildExtraConfigColumns<TColumnsMap>) => PgTableExtraConfig | PgTableExtraConfigValue[])
 		| undefined,
 	schema: TSchemaName,
+	casing: Casing | undefined,
 	baseName = name,
 ): PgTableWithColumns<{
 	name: TTableName;
 	schema: TSchemaName;
-	columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+	columns: PgBuildColumns<TTableName, TColumnsMap>;
 	dialect: 'pg';
 }> {
+	const casingFn = getCasingFn(casing);
 	const rawTable = new PgTable<{
 		name: TTableName;
 		schema: TSchemaName;
-		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		columns: PgBuildColumns<TTableName, TColumnsMap>;
 		dialect: 'pg';
 	}>(name, schema, baseName);
 
@@ -98,21 +109,21 @@ export function pgTableWithSchema<
 	const builtColumns = Object.fromEntries(
 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
 			const colBuilder = colBuilderBase as PgColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.build(rawTable);
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
 			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
 			return [name, column];
 		}),
-	) as unknown as BuildColumns<TTableName, TColumnsMap, 'pg'>;
+	) as unknown as PgBuildColumns<TTableName, TColumnsMap>;
 
 	const builtColumnsForExtraConfig = Object.fromEntries(
 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
 			const colBuilder = colBuilderBase as PgColumnBuilder;
-			colBuilder.setName(name);
+			colBuilder.setName(name, casingFn);
 			const column = colBuilder.buildExtraConfigColumn(rawTable);
 			return [name, column];
 		}),
-	) as unknown as BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>;
+	) as unknown as PgBuildExtraConfigColumns<TColumnsMap>;
 
 	const table = Object.assign(rawTable, builtColumns);
 
@@ -129,41 +140,40 @@ export function pgTableWithSchema<
 			return table as PgTableWithColumns<{
 				name: TTableName;
 				schema: TSchemaName;
-				columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+				columns: PgBuildColumns<TTableName, TColumnsMap>;
 				dialect: 'pg';
 			}>;
 		},
-	});
+	}) as any;
 }
-
-export interface PgTableFn<TSchema extends string | undefined = undefined> {
+export interface PgTableFnInternal<TSchema extends string | undefined = undefined> {
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+		TColumnsMap extends Record<string, AnyPgColumnBuilder>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
 		extraConfig?: (
-			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+			self: PgBuildExtraConfigColumns<TColumnsMap>,
 		) => PgTableExtraConfigValue[],
 	): PgTableWithColumns<{
 		name: TTableName;
 		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		columns: PgBuildColumns<TTableName, TColumnsMap>;
 		dialect: 'pg';
 	}>;
 
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+		TColumnsMap extends Record<string, AnyPgColumnBuilder>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
-		extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfigValue[],
+		extraConfig?: (self: PgBuildExtraConfigColumns<TColumnsMap>) => PgTableExtraConfigValue[],
 	): PgTableWithColumns<{
 		name: TTableName;
 		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		columns: PgBuildColumns<TTableName, TColumnsMap>;
 		dialect: 'pg';
 	}>;
 	/**
@@ -190,17 +200,17 @@ export interface PgTableFn<TSchema extends string | undefined = undefined> {
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+		TColumnsMap extends Record<string, AnyPgColumnBuilder>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
 		extraConfig: (
-			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+			self: PgBuildExtraConfigColumns<TColumnsMap>,
 		) => PgTableExtraConfig,
 	): PgTableWithColumns<{
 		name: TTableName;
 		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		columns: PgBuildColumns<TTableName, TColumnsMap>;
 		dialect: 'pg';
 	}>;
 
@@ -228,25 +238,59 @@ export interface PgTableFn<TSchema extends string | undefined = undefined> {
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+		TColumnsMap extends Record<string, AnyPgColumnBuilder>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
-		extraConfig: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfig,
+		extraConfig: (self: PgBuildExtraConfigColumns<TColumnsMap>) => PgTableExtraConfig,
 	): PgTableWithColumns<{
 		name: TTableName;
 		schema: TSchema;
-		columns: BuildColumns<TTableName, TColumnsMap, 'pg'>;
+		columns: PgBuildColumns<TTableName, TColumnsMap>;
 		dialect: 'pg';
 	}>;
 }
 
-export const pgTable: PgTableFn = (name, columns, extraConfig) => {
-	return pgTableWithSchema(name, columns, extraConfig, undefined);
-};
+export interface PgTableFn<TSchema extends string | undefined = undefined> extends PgTableFnInternal<TSchema> {
+	withRLS: PgTableFnInternal<TSchema>;
+}
+
+/** @internal */
+export function pgTableWithCasing(casing: Casing | undefined): PgTableFn {
+	const pgTableInternal: PgTableFnInternal = (name, columns, extraConfig) => {
+		return pgTableWithSchema(name, columns, extraConfig, undefined, casing);
+	};
 
-export function pgTableCreator(customizeTableName: (name: string) => string): PgTableFn {
-	return (name, columns, extraConfig) => {
-		return pgTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+	const pgTableWithRLS: PgTableFn['withRLS'] = (name, columns, extraConfig) => {
+		const table = pgTableWithSchema(name, columns, extraConfig, undefined, casing);
+		table[EnableRLS] = true;
+
+		return table;
 	};
+
+	return Object.assign(pgTableInternal, { withRLS: pgTableWithRLS });
+}
+
+export const pgTable = pgTableWithCasing(undefined);
+
+export function pgTableCreator(customizeTableName: (name: string) => string, casing?: Casing | undefined): PgTableFn {
+	const fn: PgTableFnInternal = (name, columns, extraConfig) => {
+		return pgTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, casing, name);
+	};
+
+	return Object.assign(fn, {
+		withRLS: ((name, columns, extraConfig) => {
+			const table = pgTableWithSchema(
+				customizeTableName(name) as typeof name,
+				columns,
+				extraConfig,
+				undefined,
+				casing,
+				name,
+			);
+			table[EnableRLS] = true;
+
+			return table;
+		}) as PgTableFnInternal,
+	});
 }
diff --git a/drizzle-orm/src/pg-core/unique-constraint.ts b/drizzle-orm/src/pg-core/unique-constraint.ts
index ceb860b6f8..3a4a874ae0 100644
--- a/drizzle-orm/src/pg-core/unique-constraint.ts
+++ b/drizzle-orm/src/pg-core/unique-constraint.ts
@@ -59,11 +59,13 @@ export class UniqueConstraint {
 
 	readonly columns: PgColumn[];
 	readonly name?: string;
+	readonly isNameExplicit: boolean;
 	readonly nullsNotDistinct: boolean = false;
 
 	constructor(readonly table: PgTable, columns: PgColumn[], nullsNotDistinct: boolean, name?: string) {
 		this.columns = columns;
 		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+		this.isNameExplicit = !!name;
 		this.nullsNotDistinct = nullsNotDistinct;
 	}
 
diff --git a/drizzle-orm/src/pg-core/utils.ts b/drizzle-orm/src/pg-core/utils.ts
index b7547ad664..de36464740 100644
--- a/drizzle-orm/src/pg-core/utils.ts
+++ b/drizzle-orm/src/pg-core/utils.ts
@@ -1,11 +1,13 @@
 import { is } from '~/entity.ts';
 import { PgTable } from '~/pg-core/table.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { SQL } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
-import { Schema, Table } from '~/table.ts';
+import { Table, TableSchema } from '~/table.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { type Check, CheckBuilder } from './checks.ts';
-import type { AnyPgColumn } from './columns/index.ts';
+import type { PgCodecs } from './codecs.ts';
 import { type ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import type { Index } from './indexes.ts';
 import { IndexBuilder } from './indexes.ts';
@@ -13,8 +15,8 @@ import { PgPolicy } from './policies.ts';
 import { type PrimaryKey, PrimaryKeyBuilder } from './primary-keys.ts';
 import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
 import type { PgViewBase } from './view-base.ts';
-import { PgViewConfig } from './view-common.ts';
-import { type PgMaterializedView, PgMaterializedViewConfig, type PgView } from './view.ts';
+import { PgMaterializedViewConfig, PgViewConfig } from './view-common.ts';
+import type { PgMaterializedView, PgView } from './view.ts';
 
 export function getTableConfig<TTable extends PgTable>(table: TTable) {
 	const columns = Object.values(table[Table.Symbol.Columns]);
@@ -66,7 +68,9 @@ export function getTableConfig<TTable extends PgTable>(table: TTable) {
 
 export function extractUsedTable(table: PgTable | Subquery | PgViewBase | SQL): string[] {
 	if (is(table, PgTable)) {
-		return [table[Schema] ? `${table[Schema]}.${table[Table.Symbol.BaseName]}` : table[Table.Symbol.BaseName]];
+		return [
+			table[TableSchema] ? `${table[TableSchema]}.${table[Table.Symbol.BaseName]}` : table[Table.Symbol.BaseName],
+		];
 	}
 	if (is(table, Subquery)) {
 		return table._.usedTables ?? [];
@@ -97,8 +101,6 @@ export function getMaterializedViewConfig<
 	};
 }
 
-export type ColumnsWithTable<
-	TTableName extends string,
-	TForeignTableName extends string,
-	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
-> = { [Key in keyof TColumns]: AnyPgColumn<{ tableName: TForeignTableName }> };
+export type DrizzlePgConfig<TRelations extends AnyRelations> =
+	& Omit<DrizzleConfig<Record<string, never>, TRelations>, 'schema'>
+	& { codecs?: PgCodecs | undefined };
diff --git a/drizzle-orm/src/pg-core/view-common.ts b/drizzle-orm/src/pg-core/view-common.ts
index 01194c7f24..7d98d13723 100644
--- a/drizzle-orm/src/pg-core/view-common.ts
+++ b/drizzle-orm/src/pg-core/view-common.ts
@@ -1 +1,3 @@
 export const PgViewConfig = Symbol.for('drizzle:PgViewConfig');
+
+export const PgMaterializedViewConfig = Symbol.for('drizzle:PgMaterializedViewConfig');
diff --git a/drizzle-orm/src/pg-core/view.ts b/drizzle-orm/src/pg-core/view.ts
index f8e916a31f..532d64f39b 100644
--- a/drizzle-orm/src/pg-core/view.ts
+++ b/drizzle-orm/src/pg-core/view.ts
@@ -1,4 +1,4 @@
-import type { BuildColumns } from '~/column-builder.ts';
+import type { Casing } from '~/casing.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
@@ -6,11 +6,11 @@ import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
 import type { RequireAtLeastOne } from '~/utils.ts';
-import type { PgColumn, PgColumnBuilderBase } from './columns/common.ts';
+import type { AnyPgColumnBuilder, PgBuildColumns, PgColumn } from './columns/common.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
-import { pgTable } from './table.ts';
+import { pgTableWithSchema } from './table.ts';
 import { PgViewBase } from './view-base.ts';
-import { PgViewConfig } from './view-common.ts';
+import { PgMaterializedViewConfig, PgViewConfig } from './view-common.ts';
 
 export type ViewWithConfig = RequireAtLeastOne<{
 	checkOption: 'local' | 'cascaded';
@@ -64,7 +64,7 @@ export class ViewBuilder<TName extends string = string> extends DefaultViewBuild
 					name: this.name,
 					schema: this.schema,
 					selectedFields: aliasedSelection,
-					query: qb.getSQL().inlineParams(),
+					query: qb.withoutSelectionCastCodecs().getSQL().inlineParams(),
 				},
 			}),
 			selectionProxy as any,
@@ -74,7 +74,7 @@ export class ViewBuilder<TName extends string = string> extends DefaultViewBuild
 
 export class ManualViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>,
+	TColumns extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>,
 > extends DefaultViewBuilderCore<{ name: TName; columns: TColumns }> {
 	static override readonly [entityKind]: string = 'PgManualViewBuilder';
 
@@ -84,12 +84,13 @@ export class ManualViewBuilder<
 		name: TName,
 		columns: TColumns,
 		schema: string | undefined,
+		casing: Casing | undefined,
 	) {
 		super(name, schema);
-		this.columns = getTableColumns(pgTable(name, columns));
+		this.columns = getTableColumns(pgTableWithSchema(name, columns, undefined, schema, casing));
 	}
 
-	existing(): PgViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>> {
+	existing(): PgViewWithSelection<TName, true, PgBuildColumns<TName, TColumns>> {
 		return new Proxy(
 			new PgView({
 				pgConfig: undefined,
@@ -106,10 +107,10 @@ export class ManualViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as PgViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+		) as PgViewWithSelection<TName, true, PgBuildColumns<TName, TColumns>>;
 	}
 
-	as(query: SQL): PgViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>> {
+	as(query: SQL): PgViewWithSelection<TName, false, PgBuildColumns<TName, TColumns>> {
 		return new Proxy(
 			new PgView({
 				pgConfig: this.config,
@@ -126,7 +127,7 @@ export class ManualViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as PgViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+		) as PgViewWithSelection<TName, false, PgBuildColumns<TName, TColumns>>;
 	}
 }
 
@@ -222,7 +223,7 @@ export class MaterializedViewBuilder<TName extends string = string>
 					name: this.name,
 					schema: this.schema,
 					selectedFields: aliasedSelection,
-					query: qb.getSQL().inlineParams(),
+					query: qb.withoutSelectionCastCodecs().getSQL().inlineParams(),
 				},
 			}),
 			selectionProxy as any,
@@ -232,7 +233,7 @@ export class MaterializedViewBuilder<TName extends string = string>
 
 export class ManualMaterializedViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, PgColumnBuilderBase> = Record<string, PgColumnBuilderBase>,
+	TColumns extends Record<string, AnyPgColumnBuilder> = Record<string, AnyPgColumnBuilder>,
 > extends MaterializedViewBuilderCore<{ name: TName; columns: TColumns }> {
 	static override readonly [entityKind]: string = 'PgManualMaterializedViewBuilder';
 
@@ -242,12 +243,13 @@ export class ManualMaterializedViewBuilder<
 		name: TName,
 		columns: TColumns,
 		schema: string | undefined,
+		casing: Casing | undefined,
 	) {
 		super(name, schema);
-		this.columns = getTableColumns(pgTable(name, columns));
+		this.columns = getTableColumns(pgTableWithSchema(name, columns, undefined, schema, casing));
 	}
 
-	existing(): PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>> {
+	existing(): PgMaterializedViewWithSelection<TName, true, PgBuildColumns<TName, TColumns>> {
 		return new Proxy(
 			new PgMaterializedView({
 				pgConfig: {
@@ -269,10 +271,10 @@ export class ManualMaterializedViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as PgMaterializedViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'pg'>>;
+		) as PgMaterializedViewWithSelection<TName, true, PgBuildColumns<TName, TColumns>>;
 	}
 
-	as(query: SQL): PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>> {
+	as(query: SQL): PgMaterializedViewWithSelection<TName, false, PgBuildColumns<TName, TColumns>> {
 		return new Proxy(
 			new PgMaterializedView({
 				pgConfig: {
@@ -294,7 +296,7 @@ export class ManualMaterializedViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as PgMaterializedViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'pg'>>;
+		) as PgMaterializedViewWithSelection<TName, false, PgBuildColumns<TName, TColumns>>;
 	}
 }
 
@@ -335,8 +337,6 @@ export type PgViewWithSelection<
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > = PgView<TName, TExisting, TSelectedFields> & TSelectedFields;
 
-export const PgMaterializedViewConfig = Symbol.for('drizzle:PgMaterializedViewConfig');
-
 export class PgMaterializedView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
@@ -384,11 +384,12 @@ export type PgMaterializedViewWithSelection<
 /** @internal */
 export function pgViewWithSchema(
 	name: string,
-	selection: Record<string, PgColumnBuilderBase> | undefined,
+	selection: Record<string, AnyPgColumnBuilder> | undefined,
 	schema: string | undefined,
+	casing: Casing | undefined,
 ): ViewBuilder | ManualViewBuilder {
 	if (selection) {
-		return new ManualViewBuilder(name, selection, schema);
+		return new ManualViewBuilder(name, selection, schema, casing);
 	}
 	return new ViewBuilder(name, schema);
 }
@@ -396,36 +397,46 @@ export function pgViewWithSchema(
 /** @internal */
 export function pgMaterializedViewWithSchema(
 	name: string,
-	selection: Record<string, PgColumnBuilderBase> | undefined,
+	selection: Record<string, AnyPgColumnBuilder> | undefined,
 	schema: string | undefined,
+	casing: Casing | undefined,
 ): MaterializedViewBuilder | ManualMaterializedViewBuilder {
 	if (selection) {
-		return new ManualMaterializedViewBuilder(name, selection, schema);
+		return new ManualMaterializedViewBuilder(name, selection, schema, casing);
 	}
 	return new MaterializedViewBuilder(name, schema);
 }
 
-export function pgView<TName extends string>(name: TName): ViewBuilder<TName>;
-export function pgView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualViewBuilder<TName, TColumns>;
-export function pgView(name: string, columns?: Record<string, PgColumnBuilderBase>): ViewBuilder | ManualViewBuilder {
-	return pgViewWithSchema(name, columns, undefined);
+export interface PgViewFn {
+	<TName extends string>(name: TName): ViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(
+		name: TName,
+		columns: TColumns,
+	): ManualViewBuilder<TName, TColumns>;
 }
 
-export function pgMaterializedView<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
-export function pgMaterializedView<TName extends string, TColumns extends Record<string, PgColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualMaterializedViewBuilder<TName, TColumns>;
-export function pgMaterializedView(
-	name: string,
-	columns?: Record<string, PgColumnBuilderBase>,
-): MaterializedViewBuilder | ManualMaterializedViewBuilder {
-	return pgMaterializedViewWithSchema(name, columns, undefined);
+export interface PgMaterializedViewFn {
+	<TName extends string>(name: TName): MaterializedViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, AnyPgColumnBuilder>>(
+		name: TName,
+		columns: TColumns,
+	): ManualMaterializedViewBuilder<TName, TColumns>;
 }
 
+/** @internal */
+export function pgViewWithCasing(casing: Casing | undefined): PgViewFn {
+	return ((name, columns) => pgViewWithSchema(name, columns, undefined, casing)) as PgViewFn;
+}
+
+/** @internal */
+export function pgMaterializedViewWithCasing(casing: Casing | undefined): PgMaterializedViewFn {
+	return ((name, columns) => pgMaterializedViewWithSchema(name, columns, undefined, casing)) as PgMaterializedViewFn;
+}
+
+export const pgView = pgViewWithCasing(undefined);
+
+export const pgMaterializedView = pgMaterializedViewWithCasing(undefined);
+
 export function isPgView(obj: unknown): obj is PgView {
 	return is(obj, PgView);
 }
diff --git a/drizzle-orm/src/pg-proxy/driver.ts b/drizzle-orm/src/pg-proxy/driver.ts
index 6016dd34cd..aa7c7598c0 100644
--- a/drizzle-orm/src/pg-proxy/driver.ts
+++ b/drizzle-orm/src/pg-proxy/driver.ts
@@ -1,19 +1,15 @@
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
-import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import type { DrizzleConfig } from '~/utils.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
+import { PgDialect, type PgDialectConfig } from '~/pg-core/dialect.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
 import { type PgRemoteQueryResultHKT, PgRemoteSession } from './session.ts';
 
-export class PgRemoteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<PgRemoteQueryResultHKT, TSchema> {
+export class PgRemoteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<PgRemoteQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'PgRemoteDatabase';
 }
 
@@ -21,15 +17,17 @@ export type RemoteCallback = (
 	sql: string,
 	params: any[],
 	method: 'all' | 'execute',
-	typings?: any[],
 ) => Promise<{ rows: any[] }>;
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	callback: RemoteCallback,
-	config: DrizzleConfig<TSchema> = {},
-	_dialect: () => PgDialect = () => new PgDialect({ casing: config.casing }),
-): PgRemoteDatabase<TSchema> {
-	const dialect = _dialect();
+	config: DrizzlePgConfig<TRelations> = {},
+	_dialect: (config?: PgDialectConfig) => PgDialect = (cfg) => new PgDialect(cfg),
+): PgRemoteDatabase<TRelations> {
+	const dialect = _dialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -37,21 +35,13 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new PgRemoteSession(callback, dialect, schema, { logger, cache: config.cache });
-	const db = new PgRemoteDatabase(dialect, session, schema as any) as PgRemoteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new PgRemoteSession(callback, dialect, relations, { logger, cache: config.cache });
+	const db = new PgRemoteDatabase(
+		dialect,
+		session,
+		relations,
+	) as PgRemoteDatabase<TRelations>;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
 		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
diff --git a/drizzle-orm/src/pg-proxy/migrator.ts b/drizzle-orm/src/pg-proxy/migrator.ts
index 68214ca58e..5b725922fa 100644
--- a/drizzle-orm/src/pg-proxy/migrator.ts
+++ b/drizzle-orm/src/pg-proxy/migrator.ts
@@ -1,51 +1,88 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/pg-proxy.ts';
 import type { PgRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: PgRemoteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: PgRemoteDatabase<TRelations>,
 	callback: ProxyMigrator,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
 
-	const migrationTableCreate = sql`
-		CREATE TABLE IF NOT EXISTS "drizzle"."__drizzle_migrations" (
+	const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle';
+	await db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
+
+	const migrationsTable = typeof config === 'string'
+		? '__drizzle_migrations'
+		: config.migrationsTable ?? '__drizzle_migrations';
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded(migrationsSchema, migrationsTable, db, callback, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
 			id SERIAL PRIMARY KEY,
 			hash text NOT NULL,
-			created_at numeric
-		)
-	`;
-
-	await db.execute(sql`CREATE SCHEMA IF NOT EXISTS "drizzle"`);
-	await db.execute(migrationTableCreate);
-
-	const dbMigrations = await db.execute<{
-		id: number;
-		hash: string;
-		created_at: string;
-	}>(
-		sql`SELECT id, hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at DESC LIMIT 1`,
-	);
+			created_at bigint,
+			name text,
+			applied_at timestamp with time zone DEFAULT now()
+		)`;
+		await db.session.execute(migrationTableCreate);
+	}
 
-	const lastDbMigration = dbMigrations[0] ?? undefined;
+	const dbMigrations = await db.execute<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+	);
 
-	const queriesToRun: string[] = [];
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
 
-	for (const migration of migrations) {
-		if (
-			!lastDbMigration
-			|| Number(lastDbMigration.created_at)! < migration.folderMillis
-		) {
-			queriesToRun.push(
-				...migration.sql,
-				`INSERT INTO "drizzle"."__drizzle_migrations" ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`,
-			);
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
 		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await callback(
+			[
+				db.dialect.sqlToQuery(
+					sql`insert into ${sql.identifier(migrationsSchema)}.${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`
+						.inlineParams(),
+				).sql,
+			],
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const queriesToRun: string[] = [];
+	for (const migration of migrationsToRun) {
+		queriesToRun.push(
+			...migration.sql,
+			db.dialect.sqlToQuery(
+				sql`insert into ${sql.identifier(migrationsSchema)}.${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`
+					.inlineParams(),
+			).sql,
+		);
 	}
 
 	await callback(queriesToRun);
+
+	return;
 }
diff --git a/drizzle-orm/src/pg-proxy/session.ts b/drizzle-orm/src/pg-proxy/session.ts
index 5f098a8d25..1d8b206c21 100644
--- a/drizzle-orm/src/pg-proxy/session.ts
+++ b/drizzle-orm/src/pg-proxy/session.ts
@@ -3,16 +3,12 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, type PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery as PreparedQueryBase, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { QueryWithTypings } from '~/sql/sql.ts';
-import { fillPlaceholders } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
 
 export interface PgRemoteSessionOptions {
@@ -21,9 +17,8 @@ export interface PgRemoteSessionOptions {
 }
 
 export class PgRemoteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<PgRemoteQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncSession<PgRemoteQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PgRemoteSession';
 
 	private logger: Logger;
@@ -32,136 +27,51 @@ export class PgRemoteSession<
 	constructor(
 		private client: RemoteCallback,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: PgRemoteSessionOptions = {},
+		private relations: TRelations,
+		private options: PgRemoteSessionOptions = {},
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
-	prepareQuery<T extends PreparedQueryConfig>(
-		query: QueryWithTypings,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PreparedQuery<T> {
-		return new PreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			query.typings,
+	) {
+		const executor = async (params?: unknown[]) => {
+			if (mode === 'arrays') return this.client(query.sql, params as any[], 'all').then((r) => r.rows);
+
+			return this.client(query.sql, params as any[], 'execute').then((r) => r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
 	override async transaction<T>(
-		_transaction: (tx: PgProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: PgAsyncTransaction<PgRemoteQueryResultHKT, TRelations>) => Promise<T>,
 		_config?: PgTransactionConfig,
 	): Promise<T> {
 		throw new Error('Transactions are not supported by the Postgres Proxy driver');
 	}
 }
 
-export class PgProxyTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<PgRemoteQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'PgProxyTransaction';
-
-	override async transaction<T>(
-		_transaction: (tx: PgProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
-	): Promise<T> {
-		throw new Error('Transactions are not supported by the Postgres Proxy driver');
-	}
-}
-
-export class PreparedQuery<T extends PreparedQueryConfig> extends PreparedQueryBase<T> {
-	static override readonly [entityKind]: string = 'PgProxyPreparedQuery';
-
-	constructor(
-		private client: RemoteCallback,
-		private queryString: string,
-		private params: unknown[],
-		private typings: any[] | undefined,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		return tracer.startActiveSpan('drizzle.execute', async (span) => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-			const { fields, client, queryString, joinsNotNullableMap, customResultMapper, logger, typings } = this;
-
-			span?.setAttributes({
-				'drizzle.query.text': queryString,
-				'drizzle.query.params': JSON.stringify(params),
-			});
-
-			logger.logQuery(queryString, params);
-
-			if (!fields && !customResultMapper) {
-				return tracer.startActiveSpan('drizzle.driver.execute', async () => {
-					const { rows } = await this.queryWithCache(queryString, params, async () => {
-						return await client(queryString, params as any[], 'execute', typings);
-					});
-
-					return rows;
-				});
-			}
-
-			const rows = await tracer.startActiveSpan('drizzle.driver.execute', async () => {
-				span?.setAttributes({
-					'drizzle.query.text': queryString,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-
-				const { rows } = await this.queryWithCache(queryString, params, async () => {
-					return await client(queryString, params as any[], 'all', typings);
-				});
-
-				return rows;
-			});
-
-			return tracer.startActiveSpan('drizzle.mapResponse', () => {
-				return customResultMapper
-					? customResultMapper(rows)
-					: rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-			});
-		});
-	}
-
-	async all() {
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
 export interface PgRemoteQueryResultHKT extends PgQueryResultHKT {
 	type: Assume<this['row'], {
 		[column: string]: any;
diff --git a/drizzle-orm/src/pglite/codecs.ts b/drizzle-orm/src/pglite/codecs.ts
new file mode 100644
index 0000000000..012df2c377
--- /dev/null
+++ b/drizzle-orm/src/pglite/codecs.ts
@@ -0,0 +1,121 @@
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	genericPgCodecs,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+import { base64ToUint8Array } from '~/utils.ts';
+
+export const pgliteCodecs = refineGenericPgCodecs({
+	// Otherwise outputs are inconsistent
+	bigint: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	// Otherwise outputs are inconsistent
+	'bigint:string': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	// Otherwise outputs are inconsistent
+	'bigint:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	// Otherwise outputs are inconsistent
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	// Otherwise outputs are inconsistent
+	'bigserial:number': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	bytea: {
+		normalizeInJson: typeof Buffer === 'undefined' ? base64ToUint8Array : genericPgCodecs.bytea?.normalizeInJson,
+		normalizeArrayInJson: typeof Buffer === 'undefined'
+			? arrayCompatNormalize(base64ToUint8Array)
+			: genericPgCodecs.bytea?.normalizeArrayInJson,
+		normalize: typeof Buffer === 'undefined'
+			? undefined
+			: (v: Uint8Array) => Buffer.from(v),
+		normalizeArray: typeof Buffer === 'undefined'
+			? undefined
+			: arrayCompatNormalize((v: Uint8Array) => Buffer.from(v)),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	json: {
+		// Driver handles objects, other types need to be stringified
+		normalizeParam: (v) => typeof v === 'object' ? v : JSON.stringify(v),
+	},
+	jsonb: {
+		// Driver handles objects, other types need to be stringified
+		normalizeParam: (v) => typeof v === 'object' ? v : JSON.stringify(v),
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dimensions) => `${name}::geometry${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		castParam: (name) => `${name}::geometry`,
+		castArrayParam: (name, _column, dimensions) => `${name}::geometry${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	halfvec: {
+		castParam: (name) => `${name}::halfvec`,
+		castArrayParam: (name, _column, dimensions) => `${name}::halfvec${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	vector: {
+		castParam: (name) => `${name}::vector`,
+		castArrayParam: (name, _column, dimensions) => `${name}::vector${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+		castParam: (name) => `${name}::sparsevec`,
+		castArrayParam: (name, _column, dimensions) => `${name}::sparsevec${'[]'.repeat(dimensions)}`,
+		normalizeParamArray: makePgArray,
+	},
+});
diff --git a/drizzle-orm/src/pglite/driver.ts b/drizzle-orm/src/pglite/driver.ts
index 9d5f52a34b..dbc80b1505 100644
--- a/drizzle-orm/src/pglite/driver.ts
+++ b/drizzle-orm/src/pglite/driver.ts
@@ -1,58 +1,31 @@
 import { PGlite, type PGliteOptions } from '@electric-sql/pglite';
-import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { pgliteCodecs } from './codecs.ts';
 import type { PgliteClient, PgliteQueryResultHKT } from './session.ts';
 import { PgliteSession } from './session.ts';
 
-export interface PgDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class PgliteDriver {
-	static readonly [entityKind]: string = 'PgliteDriver';
-
-	constructor(
-		private client: PgliteClient,
-		private dialect: PgDialect,
-		private options: PgDriverOptions = {},
-	) {
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): PgliteSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new PgliteSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-}
-
 export class PgliteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<PgliteQueryResultHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends PgAsyncDatabase<PgliteQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PgliteDatabase';
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<TRelations extends AnyRelations = EmptyRelations>(
 	client: PgliteClient,
-	config: DrizzleConfig<TSchema> = {},
-): PgliteDatabase<TSchema> & {
+	config: DrizzlePgConfig<TRelations> = {},
+): PgliteDatabase<TRelations> & {
 	$client: PgliteClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? pgliteCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -60,22 +33,16 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new PgliteDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
-	const db = new PgliteDatabase(dialect, session, schema as any) as PgliteDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new PgliteSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new PgliteDatabase(
+		dialect,
+		session,
+		relations,
+	) as PgliteDatabase<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -96,21 +63,21 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends PGlite = PGlite,
 >(
 	...params:
 		| []
 		| [
-			TClient | string,
+			string,
 		]
 		| [
-			TClient | string,
-			DrizzleConfig<TSchema>,
+			string,
+			DrizzlePgConfig<TRelations>,
 		]
 		| [
 			(
-				& DrizzleConfig<TSchema>
+				& DrizzlePgConfig<TRelations>
 				& ({
 					connection?: (PGliteOptions & { dataDir?: string }) | string;
 				} | {
@@ -118,7 +85,7 @@ export function drizzle<
 				})
 			),
 		]
-): PgliteDatabase<TSchema> & {
+): PgliteDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (params[0] === undefined || typeof params[0] === 'string') {
@@ -126,34 +93,34 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as {
+	const { connection, client, ...DrizzlePgConfig } = params[0] as
+		& {
 			connection?: PGliteOptions & { dataDir: string };
 			client?: TClient;
-		} & DrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig) as any;
-
-		if (typeof connection === 'object') {
-			const { dataDir, ...options } = connection;
+		}
+		& DrizzlePgConfig<TRelations>;
 
-			const instance = new PGlite(dataDir, options);
+	if (client) return construct(client, DrizzlePgConfig) as any;
 
-			return construct(instance, drizzleConfig) as any;
-		}
+	if (typeof connection === 'object') {
+		const { dataDir, ...options } = connection;
 
-		const instance = new PGlite(connection);
+		const instance = new PGlite(dataDir, options);
 
-		return construct(instance, drizzleConfig) as any;
+		return construct(instance, DrizzlePgConfig) as any;
 	}
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	const instance = new PGlite(connection);
+
+	return construct(instance, DrizzlePgConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): PgliteDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): PgliteDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/pglite/index.ts b/drizzle-orm/src/pglite/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/pglite/index.ts
+++ b/drizzle-orm/src/pglite/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/pglite/migrator.ts b/drizzle-orm/src/pglite/migrator.ts
index f43d9f6184..dde36c09eb 100644
--- a/drizzle-orm/src/pglite/migrator.ts
+++ b/drizzle-orm/src/pglite/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { PgliteDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: PgliteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: PgliteDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/pglite/session.ts b/drizzle-orm/src/pglite/session.ts
index 7e15ceff30..b852f4e886 100644
--- a/drizzle-orm/src/pglite/session.ts
+++ b/drizzle-orm/src/pglite/session.ts
@@ -1,129 +1,42 @@
-import type { PGlite, QueryOptions, Results, Row, Transaction } from '@electric-sql/pglite';
+import type { ParserOptions, PGlite, Results, Row, Transaction } from '@electric-sql/pglite';
+import { types } from '@electric-sql/pglite';
+import { type Cache, NoopCache } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import { type Logger, NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession } from '~/pg-core/async/session.ts';
+import { PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
-import { types } from '@electric-sql/pglite';
-import { type Cache, NoopCache } from '~/cache/core/cache.ts';
-import type { WithCacheConfig } from '~/cache/core/types.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 
 export type PgliteClient = PGlite;
 
-export class PglitePreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'PglitePreparedQuery';
-
-	private rawQueryConfig: QueryOptions;
-	private queryConfig: QueryOptions;
-
-	constructor(
-		private client: PgliteClient | Transaction,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-		this.rawQueryConfig = {
-			rowMode: 'object',
-			parsers: {
-				[types.TIMESTAMP]: (value) => value,
-				[types.TIMESTAMPTZ]: (value) => value,
-				[types.INTERVAL]: (value) => value,
-				[types.DATE]: (value) => value,
-				// numeric[]
-				[1231]: (value) => value,
-				// timestamp[]
-				[1115]: (value) => value,
-				// timestamp with timezone[]
-				[1185]: (value) => value,
-				// interval[]
-				[1187]: (value) => value,
-				// date[]
-				[1182]: (value) => value,
-			},
-		};
-		this.queryConfig = {
-			rowMode: 'array',
-			parsers: {
-				[types.TIMESTAMP]: (value) => value,
-				[types.TIMESTAMPTZ]: (value) => value,
-				[types.INTERVAL]: (value) => value,
-				[types.DATE]: (value) => value,
-				// numeric[]
-				[1231]: (value) => value,
-				// timestamp[]
-				[1115]: (value) => value,
-				// timestamp with timezone[]
-				[1185]: (value) => value,
-				// interval[]
-				[1187]: (value) => value,
-				// date[]
-				[1182]: (value) => value,
-			},
-		};
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.queryString, params);
-
-		const { fields, client, queryConfig, joinsNotNullableMap, customResultMapper, queryString, rawQueryConfig } = this;
-
-		if (!fields && !customResultMapper) {
-			return this.queryWithCache(queryString, params, async () => {
-				return await client.query<any[]>(queryString, params, rawQueryConfig);
-			});
-		}
-
-		const result = await this.queryWithCache(queryString, params, async () => {
-			return await client.query<any[]>(queryString, params, queryConfig);
-		});
-
-		return customResultMapper
-			? customResultMapper(result.rows)
-			: result.rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		this.logger.logQuery(this.queryString, params);
-		return this.queryWithCache(this.queryString, params, async () => {
-			return await this.client.query<any[]>(this.queryString, params, this.rawQueryConfig);
-		}).then((result) => result.rows);
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
+const parsers: ParserOptions = {
+	[types.TIMESTAMP]: (value) => value,
+	[types.TIMESTAMPTZ]: (value) => value,
+	[types.INTERVAL]: (value) => value,
+	[types.DATE]: (value) => value,
+	// numeric[]
+	[1231]: (value) => value,
+	// timestamp[]
+	[1115]: (value) => value,
+	// timestamp with timezone[]
+	[1185]: (value) => value,
+	// interval[]
+	[1187]: (value) => value,
+	// date[]
+	[1182]: (value) => value,
+};
 
 export interface PgliteSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class PgliteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<PgliteQueryResultHKT, TFullSchema, TSchema> {
+export class PgliteSession<TRelations extends AnyRelations> extends PgAsyncSession<PgliteQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PgliteSession';
 
 	private logger: Logger;
@@ -132,7 +45,7 @@ export class PgliteSession<
 	constructor(
 		private client: PgliteClient | Transaction,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: PgliteSessionOptions = {},
 	) {
 		super(dialect);
@@ -142,71 +55,75 @@ export class PgliteSession<
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new PglitePreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): PgAsyncPreparedQuery<T> {
+		const executor = async (params?: unknown[]) => {
+			return this.client.query(query.sql, params, {
+				rowMode: mode === 'arrays' ? 'array' : 'object',
+				parsers,
+			}).then((r) => mode === 'raw' ? r : r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			name,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: PgliteTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: PgliteTransaction<TRelations>) => Promise<T>,
 		config?: PgTransactionConfig | undefined,
 	): Promise<T> {
 		return (this.client as PgliteClient).transaction(async (client) => {
-			const session = new PgliteSession<TFullSchema, TSchema>(
+			const session = new PgliteSession<TRelations>(
 				client,
 				this.dialect,
-				this.schema,
+				this.relations,
 				this.options,
 			);
-			const tx = new PgliteTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+			const tx = new PgliteTransaction<TRelations>(
+				this.dialect,
+				session,
+				this.relations,
+				undefined,
+				false,
+			);
 			if (config) {
 				await tx.setTransaction(config);
 			}
 			return transaction(tx);
 		}) as Promise<T>;
 	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql);
-		return Number(
-			res['rows'][0]['count'],
-		);
-	}
 }
 
 export class PgliteTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<PgliteQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<PgliteQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PgliteTransaction';
 
-	override async transaction<T>(transaction: (tx: PgliteTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
+	override async transaction<T>(
+		transaction: (tx: PgliteTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new PgliteTransaction<TFullSchema, TSchema>(
+		const tx = new PgliteTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this._.relations,
 			this.nestedIndex + 1,
+			false,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
diff --git a/drizzle-orm/src/planetscale-serverless/codecs.ts b/drizzle-orm/src/planetscale-serverless/codecs.ts
new file mode 100644
index 0000000000..8174078f79
--- /dev/null
+++ b/drizzle-orm/src/planetscale-serverless/codecs.ts
@@ -0,0 +1,83 @@
+import { floatFromDouble, refineGenericMySqlCodecs } from '~/mysql-core/codecs.ts';
+import { sql } from '~/sql/sql.ts';
+import { textDecoder } from '~/utils.ts';
+
+const bitStringFromBytes = (value: Uint8Array): string => {
+	const str: string[] = Array.from({ length: value.length });
+	for (let i = 0; i < value.length; ++i) {
+		str[i] = value[i] === 49 ? '1' : '0';
+	}
+	return str.join('');
+};
+
+export const planetscaleServerlessCodecs = refineGenericMySqlCodecs({
+	serial: {
+		normalize: Number,
+	},
+	bigint: {
+		normalize: BigInt,
+	},
+	'bigint:number': {
+		normalize: Number,
+	},
+	boolean: {
+		normalize: (value: number) => value === 1,
+	},
+	date: {
+		normalize: (value: string) => new Date(value),
+	},
+	datetime: {
+		normalize: (value: string) => new Date(value.replace(' ', 'T') + 'Z'),
+	},
+	timestamp: {
+		normalize: (value: string) => new Date(value + '+0000'),
+	},
+	'decimal:number': {
+		normalize: Number,
+	},
+	'decimal:bigint': {
+		normalize: BigInt,
+	},
+	float: {
+		cast: (name) => sql`cast(${name} as double)`,
+		normalize: floatFromDouble,
+	},
+	binary: {
+		normalize: bitStringFromBytes,
+	},
+	varbinary: {
+		normalize: bitStringFromBytes,
+	},
+	blob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	tinyblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	mediumblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	longblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	'blob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'tinyblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'mediumblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'longblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+});
diff --git a/drizzle-orm/src/planetscale-serverless/driver.ts b/drizzle-orm/src/planetscale-serverless/driver.ts
index c03086f91c..afe581f57b 100644
--- a/drizzle-orm/src/planetscale-serverless/driver.ts
+++ b/drizzle-orm/src/planetscale-serverless/driver.ts
@@ -1,42 +1,33 @@
 import type { Config } from '@planetscale/database';
 import { Client } from '@planetscale/database';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { MySqlDatabase } from '~/mysql-core/db.ts';
+import { MySqlAsyncDatabase } from '~/mysql-core/async/db.ts';
 import { MySqlDialect } from '~/mysql-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session.ts';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { planetscaleServerlessCodecs } from './codecs.ts';
+import type { PlanetscaleQueryResultHKT } from './session.ts';
 import { PlanetscaleSession } from './session.ts';
 
-export interface PlanetscaleSDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
 export class PlanetScaleDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends MySqlDatabase<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends MySqlAsyncDatabase<PlanetscaleQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PlanetScaleDatabase';
 }
 
 function construct<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Client = Client,
 >(
 	client: TClient,
-	config: DrizzleConfig<TSchema> = {},
-): PlanetScaleDatabase<TSchema> & {
+	config: DrizzleMySqlConfig<TRelations> = {},
+): PlanetScaleDatabase<TRelations> & {
 	$client: TClient;
 } {
 	// Client is not Drizzle Object, so we can ignore this rule here
-	// eslint-disable-next-line no-instanceof/no-instanceof
+	// oxlint-disable-next-line drizzle-internal/no-instanceof
 	if (!(client instanceof Client)) {
 		throw new Error(`Warning: You need to pass an instance of Client:
 
@@ -48,11 +39,14 @@ const client = new Client({
   password: process.env["DATABASE_PASSWORD"],
 });
 
-const db = drizzle(client);
+const db = drizzle({ client });
 		`);
 	}
 
-	const dialect = new MySqlDialect({ casing: config.casing });
+	const dialect = new MySqlDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? planetscaleServerlessCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -60,21 +54,16 @@ const db = drizzle(client);
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new PlanetscaleSession(client, dialect, undefined, schema, { logger, cache: config.cache });
-	const db = new PlanetScaleDatabase(dialect, session, schema as any, 'planetscale') as PlanetScaleDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new PlanetscaleSession(client, dialect, undefined, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new PlanetScaleDatabase(
+		dialect,
+		session,
+		relations,
+	) as PlanetScaleDatabase<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -85,17 +74,17 @@ const db = drizzle(client);
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Client = Client,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleMySqlConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzleMySqlConfig<TRelations>
 			& ({
 				connection: string | Config;
 			} | {
@@ -103,7 +92,7 @@ export function drizzle<
 			})
 		),
 	]
-): PlanetScaleDatabase<TSchema> & {
+): PlanetScaleDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -114,31 +103,29 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config | string; client?: TClient }
-			& DrizzleConfig;
+	const { connection, client, ...DrizzleMySqlConfig } = params[0] as
+		& { connection?: Config | string; client?: TClient }
+		& DrizzleMySqlConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleMySqlConfig) as any;
 
-		const instance = typeof connection === 'string'
-			? new Client({
-				url: connection,
-			})
-			: new Client(
-				connection!,
-			);
-
-		return construct(instance, drizzleConfig) as any;
-	}
+	const instance = typeof connection === 'string'
+		? new Client({
+			url: connection,
+		})
+		: new Client(
+			connection!,
+		);
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleMySqlConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): PlanetScaleDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzleMySqlConfig<TRelations>,
+	): PlanetScaleDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/planetscale-serverless/index.ts b/drizzle-orm/src/planetscale-serverless/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/planetscale-serverless/index.ts
+++ b/drizzle-orm/src/planetscale-serverless/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/planetscale-serverless/migrator.ts b/drizzle-orm/src/planetscale-serverless/migrator.ts
index c6b964051f..d3ae60ce8d 100644
--- a/drizzle-orm/src/planetscale-serverless/migrator.ts
+++ b/drizzle-orm/src/planetscale-serverless/migrator.ts
@@ -1,12 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/mysql-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { PlanetScaleDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: PlanetScaleDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: PlanetScaleDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-
-	await db.dialect.migrate(migrations, db.session, config);
+	return coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/planetscale-serverless/session.ts b/drizzle-orm/src/planetscale-serverless/session.ts
index 471aed4a28..3ccd206327 100644
--- a/drizzle-orm/src/planetscale-serverless/session.ts
+++ b/drizzle-orm/src/planetscale-serverless/session.ts
@@ -1,124 +1,24 @@
 import type { Client, Connection, ExecutedQuery, Transaction } from '@planetscale/database';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { Column } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { MySqlAsyncPreparedQuery, MySqlAsyncSession, MySqlAsyncTransaction } from '~/mysql-core/async/session.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
-import {
-	MySqlPreparedQuery,
-	type MySqlPreparedQueryConfig,
-	type MySqlPreparedQueryHKT,
-	type MySqlQueryResultHKT,
-	MySqlSession,
-	MySqlTransaction,
-} from '~/mysql-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
-export class PlanetScalePreparedQuery<T extends MySqlPreparedQueryConfig> extends MySqlPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'PlanetScalePreparedQuery';
-
-	private rawQuery = { as: 'object' } as const;
-	private query = { as: 'array' } as const;
-
-	constructor(
-		private client: Client | Transaction | Connection,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-		// Keys that were used in $default and the value that was generated for them
-		private generatedIds?: Record<string, unknown>[],
-		// Keys that should be returned, it has the column with all properries + key from object
-		private returningIds?: SelectedFieldsOrdered,
-	) {
-		super(cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.queryString, params);
-
-		const {
-			fields,
-			client,
-			queryString,
-			rawQuery,
-			query,
-			joinsNotNullableMap,
-			customResultMapper,
-			returningIds,
-			generatedIds,
-		} = this;
-		if (!fields && !customResultMapper) {
-			const res = await this.queryWithCache(queryString, params, async () => {
-				return await client.execute(queryString, params, rawQuery);
-			});
-
-			const insertId = Number.parseFloat(res.insertId);
-			const affectedRows = res.rowsAffected;
-
-			// for each row, I need to check keys from
-			if (returningIds) {
-				const returningResponse = [];
-				let j = 0;
-				for (let i = insertId; i < insertId + affectedRows; i++) {
-					for (const column of returningIds) {
-						const key = returningIds[0]!.path[0]!;
-						if (is(column.field, Column)) {
-							// @ts-ignore
-							if (column.field.primary && column.field.autoIncrement) {
-								returningResponse.push({ [key]: i });
-							}
-							if (column.field.defaultFn && generatedIds) {
-								// generatedIds[rowIdx][key]
-								returningResponse.push({ [key]: generatedIds[j]![key] });
-							}
-						}
-					}
-					j++;
-				}
-				return returningResponse;
-			}
-			return res;
-		}
-		const { rows } = await this.queryWithCache(queryString, params, async () => {
-			return await client.execute(queryString, params, query);
-		});
-
-		if (customResultMapper) {
-			return customResultMapper(rows as unknown[][]);
-		}
-
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row as unknown[], joinsNotNullableMap));
-	}
-
-	override iterator(_placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']> {
-		throw new Error('Streaming is not supported by the PlanetScale Serverless driver');
-	}
-}
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 
 export interface PlanetscaleSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class PlanetscaleSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlSession<MySqlQueryResultHKT, PlanetScalePreparedQueryHKT, TFullSchema, TSchema> {
+export class PlanetscaleSession<TRelations extends AnyRelations> extends MySqlAsyncSession<
+	MySqlQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'PlanetscaleSession';
 
 	private logger: Logger;
@@ -129,7 +29,7 @@ export class PlanetscaleSession<
 		private baseClient: Client | Connection,
 		dialect: MySqlDialect,
 		tx: Transaction | undefined,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: PlanetscaleSessionOptions = {},
 	) {
 		super(dialect);
@@ -138,72 +38,61 @@ export class PlanetscaleSession<
 		this.cache = options.cache ?? new NoopCache();
 	}
 
-	prepareQuery<T extends MySqlPreparedQueryConfig = MySqlPreparedQueryConfig>(
+	prepareQuery<T extends MySqlPreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		generatedIds?: Record<string, unknown>[],
-		returningIds?: SelectedFieldsOrdered,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (response: Record<string, unknown>[] | unknown[][] | { insertId: number; affectedRows: number }) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): MySqlPreparedQuery<T> {
-		return new PlanetScalePreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): MySqlAsyncPreparedQuery<T> {
+		const { client } = this;
+		const queryConfig = {
+			as: mode === 'arrays' ? 'array' : 'object' as any,
+		};
+
+		const executor = async (params: any[] = []) => {
+			const raw = client.execute(query.sql, params, queryConfig);
+
+			if (mode !== 'raw') return raw.then(({ rows }) => rows);
+			if (!mapper) return raw;
+
+			return raw.then(({ insertId, rowsAffected }) => ({
+				insertId: Number.parseFloat(insertId),
+				affectedRows: rowsAffected,
+			}));
+		};
+
+		return new MySqlAsyncPreparedQuery(
+			executor,
+			undefined,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			customResultMapper,
-			generatedIds,
-			returningIds,
-		);
-	}
-
-	async query(query: string, params: unknown[]): Promise<ExecutedQuery> {
-		this.logger.logQuery(query, params);
-
-		return await this.client.execute(query, params, { as: 'array' });
-	}
-
-	async queryObjects(
-		query: string,
-		params: unknown[],
-	): Promise<ExecutedQuery> {
-		return this.client.execute(query, params, { as: 'object' });
-	}
-
-	override all<T = unknown>(query: SQL): Promise<T[]> {
-		const querySql = this.dialect.sqlToQuery(query);
-		this.logger.logQuery(querySql.sql, querySql.params);
-
-		return this.client.execute<T>(querySql.sql, querySql.params, { as: 'object' }).then((
-			eQuery,
-		) => eQuery.rows);
-	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql);
-
-		return Number(
-			res['rows'][0]['count'],
 		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: PlanetScaleTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: PlanetScaleTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		return this.baseClient.transaction((pstx) => {
-			const session = new PlanetscaleSession(this.baseClient, this.dialect, pstx, this.schema, this.options);
-			const tx = new PlanetScaleTransaction<TFullSchema, TSchema>(
+			const session = new PlanetscaleSession(
+				this.baseClient,
+				this.dialect,
+				pstx,
+				this.relations,
+				this.options,
+			);
+			const tx = new PlanetScaleTransaction<TRelations>(
 				this.dialect,
-				session as MySqlSession<any, any, any, any>,
-				this.schema,
+				session as MySqlAsyncSession<any, any>,
+				this.relations,
 			);
 			return transaction(tx);
 		});
@@ -211,28 +100,30 @@ export class PlanetscaleSession<
 }
 
 export class PlanetScaleTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncTransaction<
+	PlanetscaleQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'PlanetScaleTransaction';
 
 	constructor(
 		dialect: MySqlDialect,
-		session: MySqlSession,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
+		session: MySqlAsyncSession,
+		relations: TRelations,
 		nestedIndex = 0,
 	) {
-		super(dialect, session, schema, nestedIndex, 'planetscale');
+		super(dialect, session, relations, nestedIndex);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: PlanetScaleTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: PlanetScaleTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new PlanetScaleTransaction<TFullSchema, TSchema>(
+		const tx = new PlanetScaleTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this.relations,
 			this.nestedIndex + 1,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
@@ -250,7 +141,3 @@ export class PlanetScaleTransaction<
 export interface PlanetscaleQueryResultHKT extends MySqlQueryResultHKT {
 	type: ExecutedQuery;
 }
-
-export interface PlanetScalePreparedQueryHKT extends MySqlPreparedQueryHKT {
-	type: PlanetScalePreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/postgres-js/codecs.ts b/drizzle-orm/src/postgres-js/codecs.ts
new file mode 100644
index 0000000000..6bb4afbdc3
--- /dev/null
+++ b/drizzle-orm/src/postgres-js/codecs.ts
@@ -0,0 +1,148 @@
+import { makePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	arrayCompatNormalizeInput,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgVector,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const postgresJsCodecs = refineGenericPgCodecs({
+	interval: { normalizeParamArray: makePgArray },
+	point: { normalizeParamArray: makePgArray },
+	'point:tuple': { normalizeParamArray: makePgArray },
+	line: { normalizeParamArray: makePgArray },
+	'line:tuple': { normalizeParamArray: makePgArray },
+	macaddr8: { normalizeParamArray: makePgArray },
+	json: {
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		normalizeParam: (v) => JSON.stringify(v),
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+
+	bit: { normalizeParamArray: makePgArray },
+	bool: { normalizeParamArray: makePgArray },
+	box: { normalizeParamArray: makePgArray },
+	box2d: { normalizeParamArray: makePgArray },
+	box3d: { normalizeParamArray: makePgArray },
+	char: { normalizeParamArray: makePgArray },
+	cidr: { normalizeParamArray: makePgArray },
+	circle: { normalizeParamArray: makePgArray },
+	datemultirange: { normalizeParamArray: makePgArray },
+	daterange: { normalizeParamArray: makePgArray },
+	float8: { normalizeParamArray: makePgArray },
+	'geography(point)': { normalizeParamArray: makePgArray },
+	'geography(point):tuple': { normalizeParamArray: makePgArray },
+	halfvec: {
+		normalize: parsePgVector,
+		normalizeArray: arrayCompatNormalize(parsePgVector),
+		normalizeParamArray: makePgArray,
+	},
+	inet: { normalizeParamArray: makePgArray },
+	int4multirange: { normalizeParamArray: makePgArray },
+	int4range: { normalizeParamArray: makePgArray },
+	int8multirange: { normalizeParamArray: makePgArray },
+	int8range: { normalizeParamArray: makePgArray },
+	lseg: { normalizeParamArray: makePgArray },
+	macaddr: { normalizeParamArray: makePgArray },
+	money: { normalizeParamArray: makePgArray },
+	nummultirange: { normalizeParamArray: makePgArray },
+	numrange: { normalizeParamArray: makePgArray },
+	oid: { normalizeParamArray: makePgArray },
+	path: { normalizeParamArray: makePgArray },
+	polygon: { normalizeParamArray: makePgArray },
+	raster: { normalizeParamArray: makePgArray },
+	regclass: { normalizeParamArray: makePgArray },
+	regconfig: { normalizeParamArray: makePgArray },
+	regdictionary: { normalizeParamArray: makePgArray },
+	regnamespace: { normalizeParamArray: makePgArray },
+	regoper: { normalizeParamArray: makePgArray },
+	regoperator: { normalizeParamArray: makePgArray },
+	regproc: { normalizeParamArray: makePgArray },
+	regprocedure: { normalizeParamArray: makePgArray },
+	regrole: { normalizeParamArray: makePgArray },
+	regtype: { normalizeParamArray: makePgArray },
+	serial: { normalizeParamArray: makePgArray },
+	smallint: { normalizeParamArray: makePgArray },
+	smallserial: { normalizeParamArray: makePgArray },
+	sparsevec: { normalizeParamArray: makePgArray },
+	text: { normalizeParamArray: makePgArray },
+	time: { normalizeParamArray: makePgArray },
+	timetz: { normalizeParamArray: makePgArray },
+	tsmultirange: { normalizeParamArray: makePgArray },
+	tsquery: { normalizeParamArray: makePgArray },
+	tsrange: { normalizeParamArray: makePgArray },
+	tstzmultirange: { normalizeParamArray: makePgArray },
+	tstzrange: { normalizeParamArray: makePgArray },
+	tsvector: { normalizeParamArray: makePgArray },
+	varbit: { normalizeParamArray: makePgArray },
+	varchar: { normalizeParamArray: makePgArray },
+	vector: {
+		normalize: parsePgVector,
+		normalizeArray: arrayCompatNormalize(parsePgVector),
+		normalizeParamArray: makePgArray,
+	},
+	xml: { normalizeParamArray: makePgArray },
+	bytea: { normalizeParamArray: makePgArray },
+	enum: { normalizeParamArray: makePgArray },
+	'geometry(point)': {
+		normalizeArray: arrayCompatNormalize(parseGeometryXY),
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: arrayCompatNormalize(parseGeometryTuple),
+		normalizeParamArray: makePgArray,
+	},
+	numeric: { normalizeParamArray: makePgArray },
+	'numeric:number': { normalizeParamArray: makePgArray },
+	'numeric:bigint': { normalizeParamArray: makePgArray },
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	'bigint:number': { normalizeParamArray: makePgArray },
+	'bigint:string': { normalizeParamArray: makePgArray },
+	bigserial: { normalize: BigInt, normalizeArray: arrayCompatNormalize(BigInt), normalizeParamArray: makePgArray },
+	'bigserial:number': { normalizeParamArray: makePgArray },
+	float4: { normalizeParamArray: makePgArray },
+	int: { normalizeParamArray: makePgArray },
+	uuid: { normalizeParamArray: makePgArray },
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'date:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+		normalizeParamArray: makePgArray,
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+});
diff --git a/drizzle-orm/src/postgres-js/driver.ts b/drizzle-orm/src/postgres-js/driver.ts
index 411df042da..bc94899d9c 100644
--- a/drizzle-orm/src/postgres-js/driver.ts
+++ b/drizzle-orm/src/postgres-js/driver.ts
@@ -1,28 +1,27 @@
 import pgClient, { type Options, type PostgresType, type Sql } from 'postgres';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { postgresJsCodecs } from './codecs.ts';
 import type { PostgresJsQueryResultHKT } from './session.ts';
 import { PostgresJsSession } from './session.ts';
 
-export class PostgresJsDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<PostgresJsQueryResultHKT, TSchema> {
+export class PostgresJsDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<PostgresJsQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'PostgresJsDatabase';
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
 	client: Sql,
-	config: DrizzleConfig<TSchema> = {},
-): PostgresJsDatabase<TSchema> & {
+	config: DrizzlePgConfig<TRelations> = {},
+): PostgresJsDatabase<TRelations> & {
 	$client: Sql;
 } {
 	const transparentParser = (val: any) => val;
@@ -35,7 +34,10 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 	client.options.serializers['114'] = transparentParser;
 	client.options.serializers['3802'] = transparentParser;
 
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? postgresJsCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -43,21 +45,12 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new PostgresJsSession(client, dialect, schema, { logger, cache: config.cache });
-	const db = new PostgresJsDatabase(dialect, session, schema as any) as PostgresJsDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new PostgresJsSession(client, dialect, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new PostgresJsDatabase(dialect, session, relations);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -68,17 +61,17 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Sql = Sql,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzlePgConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzlePgConfig<TRelations>
 			& ({
 				connection: string | ({ url?: string } & Options<Record<string, PostgresType>>);
 			} | {
@@ -86,7 +79,7 @@ export function drizzle<
 			})
 		),
 	]
-): PostgresJsDatabase<TSchema> & {
+): PostgresJsDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -95,32 +88,30 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as {
-			connection?: { url?: string } & Options<Record<string, PostgresType>>;
-			client?: TClient;
-		} & DrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig) as any;
+	const { connection, client, ...DrizzlePgConfig } = params[0] as {
+		connection?: { url?: string } & Options<Record<string, PostgresType>>;
+		client?: TClient;
+	} & DrizzlePgConfig<TRelations>;
 
-		if (typeof connection === 'object' && connection.url !== undefined) {
-			const { url, ...config } = connection;
+	if (client) return construct(client, DrizzlePgConfig) as any;
 
-			const instance = pgClient(url, config);
-			return construct(instance, drizzleConfig) as any;
-		}
+	if (typeof connection === 'object' && connection.url !== undefined) {
+		const { url, ...config } = connection;
 
-		const instance = pgClient(connection);
-		return construct(instance, drizzleConfig) as any;
+		const instance = pgClient(url, config);
+		return construct(instance, DrizzlePgConfig) as any;
 	}
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	const instance = pgClient(connection);
+	return construct(instance, DrizzlePgConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): PostgresJsDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): PostgresJsDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({
diff --git a/drizzle-orm/src/postgres-js/index.ts b/drizzle-orm/src/postgres-js/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/postgres-js/index.ts
+++ b/drizzle-orm/src/postgres-js/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/postgres-js/migrator.ts b/drizzle-orm/src/postgres-js/migrator.ts
index 7930129f40..ff05cc3ef8 100644
--- a/drizzle-orm/src/postgres-js/migrator.ts
+++ b/drizzle-orm/src/postgres-js/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { PostgresJsDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: PostgresJsDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: PostgresJsDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/postgres-js/session.ts b/drizzle-orm/src/postgres-js/session.ts
index 3673dd8b30..787f4590fe 100644
--- a/drizzle-orm/src/postgres-js/session.ts
+++ b/drizzle-orm/src/postgres-js/session.ts
@@ -4,111 +4,22 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
-import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/sql.ts';
-import { tracer } from '~/tracing.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
-export class PostgresJsPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'PostgresJsPreparedQuery';
-
-	constructor(
-		private client: Sql,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		return tracer.startActiveSpan('drizzle.execute', async (span) => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-
-			span?.setAttributes({
-				'drizzle.query.text': this.queryString,
-				'drizzle.query.params': JSON.stringify(params),
-			});
-
-			this.logger.logQuery(this.queryString, params);
-
-			const { fields, queryString: query, client, joinsNotNullableMap, customResultMapper } = this;
-			if (!fields && !customResultMapper) {
-				return tracer.startActiveSpan('drizzle.driver.execute', () => {
-					return this.queryWithCache(query, params, async () => {
-						return await client.unsafe(query, params as any[]);
-					});
-				});
-			}
-
-			const rows = await tracer.startActiveSpan('drizzle.driver.execute', () => {
-				span?.setAttributes({
-					'drizzle.query.text': query,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return this.queryWithCache(query, params, async () => {
-					return await client.unsafe(query, params as any[]).values();
-				});
-			});
-
-			return tracer.startActiveSpan('drizzle.mapResponse', () => {
-				return customResultMapper
-					? customResultMapper(rows)
-					: rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-			});
-		});
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		return tracer.startActiveSpan('drizzle.execute', async (span) => {
-			const params = fillPlaceholders(this.params, placeholderValues);
-			span?.setAttributes({
-				'drizzle.query.text': this.queryString,
-				'drizzle.query.params': JSON.stringify(params),
-			});
-			this.logger.logQuery(this.queryString, params);
-			return tracer.startActiveSpan('drizzle.driver.execute', () => {
-				span?.setAttributes({
-					'drizzle.query.text': this.queryString,
-					'drizzle.query.params': JSON.stringify(params),
-				});
-				return this.queryWithCache(this.queryString, params, async () => {
-					return this.client.unsafe(this.queryString, params as any[]);
-				});
-			});
-		});
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
+import type { PgQueryResultHKT, PgTransactionConfig } from '~/pg-core/session.ts';
+import type { PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 
 export interface PostgresJsSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class PostgresJsSession<
-	TSQL extends Sql,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<PostgresJsQueryResultHKT, TFullSchema, TSchema> {
+export class PostgresJsSession<TSQL extends Sql, TRelations extends AnyRelations>
+	extends PgAsyncSession<PostgresJsQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'PostgresJsSession';
 
 	logger: Logger;
@@ -117,7 +28,7 @@ export class PostgresJsSession<
 	constructor(
 		public client: TSQL,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		/** @internal */
 		readonly options: PostgresJsSessionOptions = {},
 	) {
@@ -128,54 +39,54 @@ export class PostgresJsSession<
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new PostgresJsPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	) {
+		const executor = async (params?: unknown[]) => {
+			if (mode === 'objects') {
+				return this.client.unsafe(query.sql, params ?? [] as any[], {
+					prepare: name !== false,
+				}).then((rows) => Object.values(rows));
+			}
+			if (mode === 'raw') {
+				return this.client.unsafe(query.sql, params ?? [] as any[], {
+					prepare: name !== false,
+				});
+			}
+			return this.client.unsafe(query.sql, params ?? [] as any[], {
+				prepare: name !== false,
+			}).values();
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
-
-	query(query: string, params: unknown[]): Promise<RowList<Row[]>> {
-		this.logger.logQuery(query, params);
-		return this.client.unsafe(query, params as any[]).values();
-	}
-
-	queryObjects<T extends Row>(
-		query: string,
-		params: unknown[],
-	): Promise<RowList<T[]>> {
-		return this.client.unsafe(query, params as any[]);
-	}
-
 	override transaction<T>(
-		transaction: (tx: PostgresJsTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: PostgresJsTransaction<TRelations>) => Promise<T>,
 		config?: PgTransactionConfig,
 	): Promise<T> {
 		return this.client.begin(async (client) => {
-			const session = new PostgresJsSession<TransactionSql, TFullSchema, TSchema>(
+			const session = new PostgresJsSession<TransactionSql, TRelations>(
 				client,
 				this.dialect,
-				this.schema,
+				this.relations,
 				this.options,
 			);
-			const tx = new PostgresJsTransaction(this.dialect, session, this.schema);
+			const tx = new PostgresJsTransaction(this.dialect, session, this.relations);
 			if (config) {
 				await tx.setTransaction(config);
 			}
@@ -185,32 +96,35 @@ export class PostgresJsSession<
 }
 
 export class PostgresJsTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<PostgresJsQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<PostgresJsQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'PostgresJsTransaction';
 
 	constructor(
 		dialect: PgDialect,
 		/** @internal */
-		override readonly session: PostgresJsSession<TransactionSql, TFullSchema, TSchema>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
+		override readonly session: PostgresJsSession<TransactionSql, TRelations>,
+		relations: TRelations,
 		nestedIndex = 0,
 	) {
-		super(dialect, session, schema, nestedIndex);
+		super(dialect, session, relations, nestedIndex, false);
 	}
 
 	override transaction<T>(
-		transaction: (tx: PostgresJsTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: PostgresJsTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		return this.session.client.savepoint((client) => {
-			const session = new PostgresJsSession<TransactionSql, TFullSchema, TSchema>(
+			const session = new PostgresJsSession<TransactionSql, TRelations>(
 				client,
 				this.dialect,
-				this.schema,
+				this._.relations,
 				this.session.options,
 			);
-			const tx = new PostgresJsTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+			const tx = new PostgresJsTransaction<TRelations>(
+				this.dialect,
+				session,
+				this._.relations,
+			);
 			return transaction(tx);
 		}) as Promise<T>;
 	}
diff --git a/drizzle-orm/src/prisma/mysql/driver.ts b/drizzle-orm/src/prisma/mysql/driver.ts
deleted file mode 100644
index c6ca143df1..0000000000
--- a/drizzle-orm/src/prisma/mysql/driver.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { PrismaClient } from '@prisma/client/extension';
-
-import { Prisma } from '@prisma/client';
-
-import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
-import { DefaultLogger } from '~/logger.ts';
-import { MySqlDatabase, MySqlDialect } from '~/mysql-core/index.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import type { PrismaMySqlPreparedQueryHKT, PrismaMySqlQueryResultHKT } from './session.ts';
-import { PrismaMySqlSession } from './session.ts';
-
-export class PrismaMySqlDatabase
-	extends MySqlDatabase<PrismaMySqlQueryResultHKT, PrismaMySqlPreparedQueryHKT, Record<string, never>>
-{
-	static override readonly [entityKind]: string = 'PrismaMySqlDatabase';
-
-	constructor(client: PrismaClient, logger: Logger | undefined) {
-		const dialect = new MySqlDialect();
-		super(dialect, new PrismaMySqlSession(dialect, client, { logger }), undefined, 'default');
-	}
-}
-
-export type PrismaMySqlConfig = Omit<DrizzleConfig, 'schema'>;
-
-export function drizzle(config: PrismaMySqlConfig = {}) {
-	let logger: Logger | undefined;
-	if (config.logger === true) {
-		logger = new DefaultLogger();
-	} else if (config.logger !== false) {
-		logger = config.logger;
-	}
-
-	return Prisma.defineExtension((client) => {
-		return client.$extends({
-			name: 'drizzle',
-			client: {
-				$drizzle: new PrismaMySqlDatabase(client, logger),
-			},
-		});
-	});
-}
diff --git a/drizzle-orm/src/prisma/mysql/session.ts b/drizzle-orm/src/prisma/mysql/session.ts
deleted file mode 100644
index 377c40fa6b..0000000000
--- a/drizzle-orm/src/prisma/mysql/session.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import type { PrismaClient } from '@prisma/client/extension';
-
-import { entityKind } from '~/entity.ts';
-import { type Logger, NoopLogger } from '~/logger.ts';
-import type {
-	MySqlDialect,
-	MySqlPreparedQueryConfig,
-	MySqlPreparedQueryHKT,
-	MySqlQueryResultHKT,
-	MySqlTransaction,
-	MySqlTransactionConfig,
-} from '~/mysql-core/index.ts';
-import { MySqlPreparedQuery, MySqlSession } from '~/mysql-core/index.ts';
-import { fillPlaceholders } from '~/sql/sql.ts';
-import type { Query, SQL } from '~/sql/sql.ts';
-import type { Assume } from '~/utils.ts';
-
-export class PrismaMySqlPreparedQuery<T> extends MySqlPreparedQuery<MySqlPreparedQueryConfig & { execute: T }> {
-	override iterator(_placeholderValues?: Record<string, unknown> | undefined): AsyncGenerator<unknown, any, unknown> {
-		throw new Error('Method not implemented.');
-	}
-	static override readonly [entityKind]: string = 'PrismaMySqlPreparedQuery';
-
-	constructor(
-		private readonly prisma: PrismaClient,
-		private readonly query: Query,
-		private readonly logger: Logger,
-	) {
-		super(undefined, undefined, undefined);
-	}
-
-	override execute(placeholderValues?: Record<string, unknown>): Promise<T> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.prisma.$queryRawUnsafe(this.query.sql, ...params);
-	}
-}
-
-export interface PrismaMySqlSessionOptions {
-	logger?: Logger;
-}
-
-export class PrismaMySqlSession extends MySqlSession {
-	static override readonly [entityKind]: string = 'PrismaMySqlSession';
-
-	private readonly logger: Logger;
-
-	constructor(
-		dialect: MySqlDialect,
-		private readonly prisma: PrismaClient,
-		private readonly options: PrismaMySqlSessionOptions,
-	) {
-		super(dialect);
-		this.logger = options.logger ?? new NoopLogger();
-	}
-
-	override execute<T>(query: SQL): Promise<T> {
-		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T }>(this.dialect.sqlToQuery(query)).execute();
-	}
-
-	override all<T = unknown>(_query: SQL): Promise<T[]> {
-		throw new Error('Method not implemented.');
-	}
-
-	override prepareQuery<T extends MySqlPreparedQueryConfig = MySqlPreparedQueryConfig>(
-		query: Query,
-	): MySqlPreparedQuery<T> {
-		return new PrismaMySqlPreparedQuery(this.prisma, query, this.logger);
-	}
-
-	override transaction<T>(
-		_transaction: (
-			tx: MySqlTransaction<
-				PrismaMySqlQueryResultHKT,
-				PrismaMySqlPreparedQueryHKT,
-				Record<string, never>,
-				Record<string, never>
-			>,
-		) => Promise<T>,
-		_config?: MySqlTransactionConfig,
-	): Promise<T> {
-		throw new Error('Method not implemented.');
-	}
-}
-
-export interface PrismaMySqlQueryResultHKT extends MySqlQueryResultHKT {
-	type: [];
-}
-
-export interface PrismaMySqlPreparedQueryHKT extends MySqlPreparedQueryHKT {
-	type: PrismaMySqlPreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/prisma/pg/driver.ts b/drizzle-orm/src/prisma/pg/driver.ts
deleted file mode 100644
index f9038d8a13..0000000000
--- a/drizzle-orm/src/prisma/pg/driver.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { PrismaClient } from '@prisma/client/extension';
-
-import { Prisma } from '@prisma/client';
-
-import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
-import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase, PgDialect } from '~/pg-core/index.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import type { PrismaPgQueryResultHKT } from './session.ts';
-import { PrismaPgSession } from './session.ts';
-
-export class PrismaPgDatabase extends PgDatabase<PrismaPgQueryResultHKT, Record<string, never>> {
-	static override readonly [entityKind]: string = 'PrismaPgDatabase';
-
-	constructor(client: PrismaClient, logger: Logger | undefined) {
-		const dialect = new PgDialect();
-		super(dialect, new PrismaPgSession(dialect, client, { logger }), undefined);
-	}
-}
-
-export type PrismaPgConfig = Omit<DrizzleConfig, 'schema'>;
-
-export function drizzle(config: PrismaPgConfig = {}) {
-	let logger: Logger | undefined;
-	if (config.logger === true) {
-		logger = new DefaultLogger();
-	} else if (config.logger !== false) {
-		logger = config.logger;
-	}
-
-	return Prisma.defineExtension((client) => {
-		return client.$extends({
-			name: 'drizzle',
-			client: {
-				$drizzle: new PrismaPgDatabase(client, logger),
-			},
-		});
-	});
-}
diff --git a/drizzle-orm/src/prisma/pg/session.ts b/drizzle-orm/src/prisma/pg/session.ts
deleted file mode 100644
index 809c229b7e..0000000000
--- a/drizzle-orm/src/prisma/pg/session.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import type { PrismaClient } from '@prisma/client/extension';
-
-import { entityKind } from '~/entity.ts';
-import { type Logger, NoopLogger } from '~/logger.ts';
-import type {
-	PgDialect,
-	PgQueryResultHKT,
-	PgTransaction,
-	PgTransactionConfig,
-	PreparedQueryConfig,
-} from '~/pg-core/index.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/index.ts';
-import type { Query, SQL } from '~/sql/sql.ts';
-import { fillPlaceholders } from '~/sql/sql.ts';
-
-export class PrismaPgPreparedQuery<T> extends PgPreparedQuery<PreparedQueryConfig & { execute: T }> {
-	static override readonly [entityKind]: string = 'PrismaPgPreparedQuery';
-
-	constructor(
-		private readonly prisma: PrismaClient,
-		query: Query,
-		private readonly logger: Logger,
-	) {
-		super(query, undefined, undefined, undefined);
-	}
-
-	override execute(placeholderValues?: Record<string, unknown>): Promise<T> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.prisma.$queryRawUnsafe(this.query.sql, ...params);
-	}
-
-	override all(): Promise<unknown> {
-		throw new Error('Method not implemented.');
-	}
-
-	override isResponseInArrayMode(): boolean {
-		return false;
-	}
-}
-
-export interface PrismaPgSessionOptions {
-	logger?: Logger;
-}
-
-export class PrismaPgSession extends PgSession {
-	static override readonly [entityKind]: string = 'PrismaPgSession';
-
-	private readonly logger: Logger;
-
-	constructor(
-		dialect: PgDialect,
-		private readonly prisma: PrismaClient,
-		private readonly options: PrismaPgSessionOptions,
-	) {
-		super(dialect);
-		this.logger = options.logger ?? new NoopLogger();
-	}
-
-	override execute<T>(query: SQL): Promise<T> {
-		return this.prepareQuery<PreparedQueryConfig & { execute: T }>(this.dialect.sqlToQuery(query)).execute();
-	}
-
-	override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query): PgPreparedQuery<T> {
-		return new PrismaPgPreparedQuery(this.prisma, query, this.logger);
-	}
-
-	override transaction<T>(
-		_transaction: (tx: PgTransaction<PgQueryResultHKT, Record<string, never>, Record<string, never>>) => Promise<T>,
-		_config?: PgTransactionConfig,
-	): Promise<T> {
-		throw new Error('Method not implemented.');
-	}
-}
-
-export interface PrismaPgQueryResultHKT extends PgQueryResultHKT {
-	type: [];
-}
diff --git a/drizzle-orm/src/prisma/schema.prisma b/drizzle-orm/src/prisma/schema.prisma
deleted file mode 100644
index e9b2f3ce63..0000000000
--- a/drizzle-orm/src/prisma/schema.prisma
+++ /dev/null
@@ -1,14 +0,0 @@
-generator client {
-  provider = "prisma-client-js"
-}
-
-datasource db {
-  provider = "postgresql"
-  url      = env("DB_URL")
-}
-
-model User {
-  id    Int     @id @default(autoincrement())
-  email String  @unique
-  name  String?
-}
diff --git a/drizzle-orm/src/prisma/sqlite/driver.ts b/drizzle-orm/src/prisma/sqlite/driver.ts
deleted file mode 100644
index 2a8f1e4c85..0000000000
--- a/drizzle-orm/src/prisma/sqlite/driver.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Prisma } from '@prisma/client';
-
-import type { Logger } from '~/logger.ts';
-import { DefaultLogger } from '~/logger.ts';
-import { BaseSQLiteDatabase, SQLiteAsyncDialect } from '~/sqlite-core/index.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { PrismaSQLiteSession } from './session.ts';
-
-export type PrismaSQLiteDatabase = BaseSQLiteDatabase<'async', []>;
-
-export type PrismaSQLiteConfig = Omit<DrizzleConfig, 'schema'>;
-
-export function drizzle(config: PrismaSQLiteConfig = {}) {
-	const dialect = new SQLiteAsyncDialect();
-	let logger: Logger | undefined;
-	if (config.logger === true) {
-		logger = new DefaultLogger();
-	} else if (config.logger !== false) {
-		logger = config.logger;
-	}
-
-	return Prisma.defineExtension((client) => {
-		const session = new PrismaSQLiteSession(client, dialect, { logger });
-
-		return client.$extends({
-			name: 'drizzle',
-			client: {
-				$drizzle: new BaseSQLiteDatabase('async', dialect, session, undefined) as PrismaSQLiteDatabase,
-			},
-		});
-	});
-}
diff --git a/drizzle-orm/src/prisma/sqlite/session.ts b/drizzle-orm/src/prisma/sqlite/session.ts
deleted file mode 100644
index 3a10fddbda..0000000000
--- a/drizzle-orm/src/prisma/sqlite/session.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import type { PrismaClient } from '@prisma/client/extension';
-
-import { entityKind } from '~/entity.ts';
-import { type Logger, NoopLogger } from '~/logger.ts';
-import type { Query } from '~/sql/sql.ts';
-import { fillPlaceholders } from '~/sql/sql.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SelectedFieldsOrdered,
-	SQLiteAsyncDialect,
-	SQLiteExecuteMethod,
-	SQLiteTransaction,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/index.ts';
-import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/index.ts';
-
-type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
-
-export class PrismaSQLitePreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
-	{ type: 'async'; run: []; all: T['all']; get: T['get']; values: never; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'PrismaSQLitePreparedQuery';
-
-	constructor(
-		private readonly prisma: PrismaClient,
-		query: Query,
-		private readonly logger: Logger,
-		executeMethod: SQLiteExecuteMethod,
-	) {
-		super('async', executeMethod, query);
-	}
-
-	override all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return this.prisma.$queryRawUnsafe(this.query.sql, ...params);
-	}
-
-	override async run(placeholderValues?: Record<string, unknown> | undefined): Promise<[]> {
-		await this.all(placeholderValues);
-		return [];
-	}
-
-	override async get(placeholderValues?: Record<string, unknown> | undefined): Promise<T['get']> {
-		const all = await this.all(placeholderValues) as unknown[];
-		return all[0];
-	}
-
-	override values(_placeholderValues?: Record<string, unknown> | undefined): Promise<never> {
-		throw new Error('Method not implemented.');
-	}
-
-	override isResponseInArrayMode(): boolean {
-		return false;
-	}
-}
-
-export interface PrismaSQLiteSessionOptions {
-	logger?: Logger;
-}
-
-export class PrismaSQLiteSession extends SQLiteSession<'async', unknown, Record<string, never>, Record<string, never>> {
-	static override readonly [entityKind]: string = 'PrismaSQLiteSession';
-
-	private readonly logger: Logger;
-
-	constructor(
-		private readonly prisma: PrismaClient,
-		dialect: SQLiteAsyncDialect,
-		options: PrismaSQLiteSessionOptions,
-	) {
-		super(dialect);
-		this.logger = options.logger ?? new NoopLogger();
-	}
-
-	override prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-	): PrismaSQLitePreparedQuery<T> {
-		return new PrismaSQLitePreparedQuery(this.prisma, query, this.logger, executeMethod);
-	}
-
-	override transaction<T>(
-		_transaction: (tx: SQLiteTransaction<'async', unknown, Record<string, never>, Record<string, never>>) => Promise<T>,
-		_config?: SQLiteTransactionConfig,
-	): Promise<T> {
-		throw new Error('Method not implemented.');
-	}
-}
diff --git a/drizzle-orm/src/query-builders/query-builder.ts b/drizzle-orm/src/query-builders/query-builder.ts
index cef2767aa5..49b54e9068 100644
--- a/drizzle-orm/src/query-builders/query-builder.ts
+++ b/drizzle-orm/src/query-builders/query-builder.ts
@@ -15,5 +15,10 @@ export abstract class TypedQueryBuilder<TSelection, TResult = unknown, TConfig =
 		return this._.selectedFields;
 	}
 
+	/** @internal */
+	withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
 	abstract getSQL(): SQL;
 }
diff --git a/drizzle-orm/src/query-builders/select.types.ts b/drizzle-orm/src/query-builders/select.types.ts
index 6ba4462789..7830252aa8 100644
--- a/drizzle-orm/src/query-builders/select.types.ts
+++ b/drizzle-orm/src/query-builders/select.types.ts
@@ -1,10 +1,10 @@
-import type { ChangeColumnTableName, ColumnDataType, Dialect } from '~/column-builder.ts';
+import type { ChangeColumnTableName, ColumnType, Dialect } from '~/column-builder.ts';
 import type { AnyColumn, Column, ColumnBaseConfig, GetColumnData, UpdateColConfig } from '~/column.ts';
 import type { SelectedFields } from '~/operations.ts';
 import type { ColumnsSelection, SQL, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table } from '~/table.ts';
-import type { Assume, DrizzleTypeError, Equal, IsAny, Simplify } from '~/utils.ts';
+import type { Assume, DrizzleTypeError, Equal, FromSingleKeyObject, IsAny, IsUnion, Not, Simplify } from '~/utils.ts';
 
 export type JoinType = 'inner' | 'left' | 'right' | 'full' | 'cross';
 
@@ -21,7 +21,7 @@ export type ApplyNullabilityToColumn<TColumn extends Column, TNullability extend
 				UpdateColConfig<TColumn['_'], {
 					notNull: TNullability extends 'nullable' ? false : TColumn['_']['notNull'];
 				}>,
-				ColumnBaseConfig<ColumnDataType, string>
+				ColumnBaseConfig<ColumnType>
 			>
 		>;
 
@@ -44,10 +44,6 @@ export type SelectResult<
 	: TSelectMode extends 'single' ? SelectResultFields<TResult>
 	: ApplyNotNullMapToJoins<SelectResultFields<TResult>, TNullabilityMap>;
 
-type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
-
-type Not<T extends boolean> = T extends true ? false : true;
-
 type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullability>> = TNullability extends
 	TNullability ? {
 		[Key in keyof TFields]: TFields[Key] extends infer TField
@@ -61,6 +57,11 @@ type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullab
 					? ApplyNullability<SelectResultField<TField>, TNullability[TField['_']['tableName']]>
 				: never
 			: TField extends SQL | SQL.Aliased ? SelectResultField<TField>
+			: TField extends Subquery ? FromSingleKeyObject<
+					TField['_']['selectedFields'],
+					TField['_']['selectedFields'] extends { [key: string]: infer TValue } ? SelectResultField<TValue> : never,
+					'You can only select one column in the subquery'
+				>
 			: TField extends Record<string, any>
 				? TField[keyof TField] extends AnyColumn<{ tableName: infer TTableName extends string }> | SQL | SQL.Aliased
 					? Not<IsUnion<TTableName>> extends true
@@ -95,6 +96,13 @@ export type AddAliasToSelection<
 				? ChangeColumnTableName<TSelection[Key], TAlias, TDialect>
 				: TSelection[Key] extends Table ? AddAliasToSelection<TSelection[Key]['_']['columns'], TAlias, TDialect>
 				: TSelection[Key] extends SQL | SQL.Aliased ? TSelection[Key]
+				: TSelection[Key] extends Subquery ? FromSingleKeyObject<
+						TSelection[Key]['_']['selectedFields'],
+						TSelection[Key]['_']['selectedFields'] extends { [key: string]: infer TValue }
+							? SQL.Aliased<SelectResultField<TValue>>
+							: never,
+						'You can only select one column in the subquery'
+					>
 				: TSelection[Key] extends ColumnsSelection ? MapColumnsToTableAlias<TSelection[Key], TAlias, TDialect>
 				: never;
 		}
@@ -124,6 +132,13 @@ export type BuildSubquerySelection<
 				: TSelection[Key] extends Table ? BuildSubquerySelection<TSelection[Key]['_']['columns'], TNullability>
 				: TSelection[Key] extends Column
 					? ApplyNullabilityToColumn<TSelection[Key], TNullability[TSelection[Key]['_']['tableName']]>
+				: TSelection[Key] extends Subquery ? FromSingleKeyObject<
+						TSelection[Key]['_']['selectedFields'],
+						TSelection[Key]['_']['selectedFields'] extends { [key: string]: infer TValue }
+							? SQL.Aliased<SelectResultField<TValue>>
+							: never,
+						'You can only select one column in the subquery'
+					>
 				: TSelection[Key] extends ColumnsSelection ? BuildSubquerySelection<TSelection[Key], TNullability>
 				: never;
 		}
diff --git a/drizzle-orm/src/query-name-generator.ts b/drizzle-orm/src/query-name-generator.ts
new file mode 100644
index 0000000000..cbb70a78ee
--- /dev/null
+++ b/drizzle-orm/src/query-name-generator.ts
@@ -0,0 +1,94 @@
+import { is } from './entity.ts';
+import { Placeholder } from './sql/sql.ts';
+
+function isBinary(value: unknown): boolean {
+	if (
+		typeof Buffer !== 'undefined'
+		&& typeof Buffer.isBuffer === 'function'
+		&& Buffer.isBuffer(value)
+	) return true;
+	// oxlint-disable-next-line drizzle-internal/no-instanceof
+	if (value instanceof ArrayBuffer) return true;
+	if (ArrayBuffer.isView(value)) return true;
+	return false;
+}
+
+function arrayTypeId(arr: readonly unknown[]) {
+	if (!arr.length) return 'array<void>';
+	let elementId: string | undefined;
+	for (let i = 0; i < arr.length; i++) {
+		const id = jsTypeId(arr[i]);
+
+		if (!elementId) {
+			elementId = id;
+			continue;
+		}
+
+		if (elementId !== id) {
+			elementId = `${elementId},${id}`;
+			continue;
+		}
+
+		elementId = id;
+	}
+	return `array<${elementId}>`;
+}
+
+// replacement for type OID
+function jsTypeId(value: unknown): string {
+	if (value === null) return 'null';
+	if (is(value, Placeholder)) return 'placeholder';
+	// oxlint-disable-next-line drizzle-internal/no-instanceof
+	if (value instanceof Date) return 'date';
+	if (Array.isArray(value)) return arrayTypeId(value);
+	if (isBinary(value)) return 'binary';
+	return typeof value;
+}
+
+function hash(str: string, seed = 5381): number {
+	let h = seed;
+	for (let i = 0; i < str.length; i++) {
+		h = ((h << 5) + h) ^ str.charCodeAt(i);
+	}
+	return h >>> 0;
+}
+
+const safeChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_';
+function stringify(hash: number, length: number, startWithLetter = false): string {
+	let result = '';
+	let h = hash;
+
+	if (startWithLetter) {
+		result += safeChars[h % 52];
+		h = h >>> 6;
+		--length;
+	}
+
+	while (result.length < length) {
+		result += safeChars[h % safeChars.length];
+		h = h >>> 6;
+		if (h === 0) break;
+	}
+
+	return result;
+}
+
+export function preparedStatementName(
+	sql: string,
+	params: readonly unknown[] = [],
+): string {
+	let hash1 = hash(sql);
+	let hash2 = hash(sql, 5381 ^ 0xdeadbeef);
+
+	const paramIds = params.map(jsTypeId).join(',');
+	for (let ti = 0; ti < paramIds.length; ti++) {
+		hash1 = ((hash1 << 5) + hash1) ^ paramIds.charCodeAt(ti);
+		hash2 = ((hash2 << 5) + hash2) ^ paramIds.charCodeAt(ti);
+	}
+
+	const part1 = stringify(hash1, 31, true);
+	const part2 = stringify(hash2, 32);
+
+	// Max out allowed name length to prevent collisions
+	return part1 + part2;
+}
diff --git a/drizzle-orm/src/relations.ts b/drizzle-orm/src/relations.ts
index adaee80765..e954570a93 100644
--- a/drizzle-orm/src/relations.ts
+++ b/drizzle-orm/src/relations.ts
@@ -1,9 +1,14 @@
-import { type AnyTable, getTableUniqueName, type InferModelFromColumns, Table } from '~/table.ts';
+import { IsAlias, OriginalName, Table, TableColumns, TableSchema } from '~/table.ts';
+import { aliasedTable } from './alias.ts';
+import type { CodecsCollection, NormalizeArrayCodec, NormalizeCodec } from './codecs.ts';
 import { type AnyColumn, Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
-import { PrimaryKeyBuilder } from './pg-core/primary-keys.ts';
+import { DrizzleError } from './errors.ts';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	between,
 	desc,
@@ -27,370 +32,700 @@ import {
 	notLike,
 	or,
 } from './sql/expressions/index.ts';
-import { type Placeholder, SQL, sql } from './sql/sql.ts';
-import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from './utils.ts';
+import { type CommentInput, noopDecoder, Placeholder, SQL, sql, type SQLWrapper, View } from './sql/sql.ts';
+import {
+	type Assume,
+	type DrizzleTypeError,
+	type Equal,
+	FnConstructor,
+	getColumnFromDecoder,
+	type Simplify,
+	type ValueOrArray,
+} from './utils.ts';
 
-export abstract class Relation<TTableName extends string = string> {
-	static readonly [entityKind]: string = 'Relation';
+export type FilteredSchemaEntry = Table<any> | View<string, boolean, FieldSelection>;
 
-	declare readonly $brand: 'Relation';
-	readonly referencedTableName: TTableName;
-	fieldName!: string;
+export type SchemaEntry = Table<any> | View<string, boolean, any>;
 
-	constructor(
-		readonly sourceTable: Table,
-		readonly referencedTable: AnyTable<{ name: TTableName }>,
-		readonly relationName: string | undefined,
-	) {
-		this.referencedTableName = referencedTable[Table.Symbol.Name] as TTableName;
+export type Schema = Record<string, SchemaEntry>;
+
+export type GetTableViewColumns<T extends SchemaEntry> = T extends View<string, boolean, any> ? T['_']['selectedFields']
+	: T extends Table<any> ? T['_']['columns']
+	: never;
+
+export type GetTableViewFieldSelection<T extends SchemaEntry> = T extends View<string, boolean, FieldSelection>
+	? T['_']['selectedFields']
+	: T extends Table<any> ? T['_']['columns']
+	: never;
+
+export type FieldValue =
+	| Column<any>
+	| SQLWrapper
+	| SQL.Aliased
+	| SQL;
+
+export type FieldSelection = Record<string, FieldValue>;
+
+export function processRelations(tablesConfig: TablesRelationalConfig, tables: Schema) {
+	for (const tableConfig of Object.values(tablesConfig)) {
+		for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+			if (!is(relation, Relation)) {
+				continue;
+			}
+
+			relation.sourceTable = tableConfig.table;
+			relation.fieldName = relationFieldName;
+		}
+	}
+
+	for (const [sourceTableName, tableConfig] of Object.entries(tablesConfig)) {
+		for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+			if (!is(relation, Relation)) {
+				continue;
+			}
+
+			let reverseRelation: Relation | undefined;
+			const {
+				targetTableName,
+				alias,
+				sourceColumns,
+				targetColumns,
+				throughTable,
+				sourceTable,
+				through,
+				where,
+				sourceColumnTableNames,
+				targetColumnTableNames,
+			} = relation;
+			const relationPrintName = `relations -> ${tableConfig.name}: { ${relationFieldName}: r.${
+				is(relation, One) ? 'one' : 'many'
+			}.${targetTableName}(...) }`;
+
+			if (relationFieldName in tableConfig.table[TableColumns]) {
+				throw new Error(
+					`${relationPrintName}: relation name collides with column "${relationFieldName}" of table "${tableConfig.name}"`,
+				);
+			}
+
+			if (typeof alias === 'string' && !alias) {
+				throw new Error(`${relationPrintName}: "alias" cannot be an empty string - omit it if you don't need it`);
+			}
+
+			if (sourceColumns?.length === 0) {
+				throw new Error(`${relationPrintName}: "from" cannot be empty`);
+			}
+
+			if (targetColumns?.length === 0) {
+				throw new Error(`${relationPrintName}: "to" cannot be empty`);
+			}
+
+			if (sourceColumns && targetColumns) {
+				if (sourceColumns.length !== targetColumns.length && !throughTable) {
+					throw new Error(
+						`${relationPrintName}: "from" and "to" fields without "through" must have the same length`,
+					);
+				}
+
+				for (const sName of sourceColumnTableNames) {
+					if (sName !== sourceTableName) {
+						throw new Error(
+							`${relationPrintName}: all "from" columns must belong to table "${sourceTableName}", found column of table "${sName}"`,
+						);
+					}
+				}
+				for (const tName of targetColumnTableNames) {
+					if (tName !== targetTableName) {
+						throw new Error(
+							`${relationPrintName}: all "to" columns must belong to table "${targetTableName}", found column of table "${tName}"`,
+						);
+					}
+				}
+
+				if (through) {
+					if (
+						through.source.length !== sourceColumns.length
+						|| through.target.length !== targetColumns.length
+					) {
+						throw new Error(
+							`${relationPrintName}: ".through(column)" must be used either on all columns in "from" and "to" or not defined on any of them`,
+						);
+					}
+
+					for (const column of through.source) {
+						if (tables[column._.tableName] !== throughTable) {
+							throw new Error(
+								`${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`,
+							);
+						}
+					}
+
+					for (const column of through.target) {
+						if (tables[column._.tableName] !== throughTable) {
+							throw new Error(
+								`${relationPrintName}: ".through(column)" must be used on the same table by all columns of the relation`,
+							);
+						}
+					}
+				}
+
+				continue;
+			}
+
+			if (sourceColumns || targetColumns) {
+				throw new Error(
+					`${relationPrintName}: relation must have either both "from" and "to" defined, or none of them`,
+				);
+			}
+
+			const reverseTableConfig = tablesConfig[targetTableName];
+			if (!reverseTableConfig) {
+				throw new Error(
+					`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and no reverse relations of table "${targetTableName}" were found"`,
+				);
+			}
+			if (alias) {
+				const reverseRelations = Object.values(reverseTableConfig.relations).filter((it): it is Relation =>
+					is(it, Relation) && it.alias === alias && it !== relation
+				);
+				if (reverseRelations.length > 1) {
+					throw new Error(
+						`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and multiple relations with alias "${alias}" found in table "${targetTableName}": ${
+							reverseRelations.map((it) => `"${it.fieldName}"`).join(', ')
+						}`,
+					);
+				}
+				reverseRelation = reverseRelations[0];
+				if (!reverseRelation) {
+					throw new Error(
+						`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and there is no reverse relation of table "${targetTableName}" with alias "${alias}"`,
+					);
+				}
+			} else {
+				const reverseRelations = Object.values(reverseTableConfig.relations).filter((it): it is Relation =>
+					is(it, Relation) && it.targetTable === sourceTable && !it.alias && it !== relation
+				);
+				if (reverseRelations.length > 1) {
+					throw new Error(
+						`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and multiple relations between "${targetTableName}" and "${sourceTableName}" were found.\nHint: you can specify "alias" on both sides of the relation with the same value`,
+					);
+				}
+				reverseRelation = reverseRelations[0];
+				if (!reverseRelation) {
+					throw new Error(
+						`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and no reverse relation of table "${targetTableName}" with target table "${sourceTableName}" was found`,
+					);
+				}
+			}
+			if (!reverseRelation.sourceColumns || !reverseRelation.targetColumns) {
+				throw new Error(
+					`${relationPrintName}: not enough data provided to build the relation - "from"/"to" are not defined, and reverse relation "${targetTableName}.${reverseRelation.fieldName}" does not have "from"/"to" defined`,
+				);
+			}
+
+			relation.sourceColumns = reverseRelation.targetColumns;
+			relation.targetColumns = reverseRelation.sourceColumns;
+			relation.through = reverseRelation.through
+				? {
+					source: reverseRelation.through.target,
+					target: reverseRelation.through.source,
+				}
+				: undefined;
+			relation.throughTable = reverseRelation.throughTable;
+			relation.isReversed = !where;
+			relation.where = where ?? reverseRelation.where;
+		}
 	}
 
-	abstract withFieldName(fieldName: string): Relation<TTableName>;
+	return tablesConfig;
 }
 
-export class Relations<
-	TTableName extends string = string,
-	TConfig extends Record<string, Relation> = Record<string, Relation>,
+/** Builds relational config for every table in schema */
+export function buildRelations<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(
+	tables: TTables,
+	config: TConfig,
+): ExtractTablesWithRelations<TConfig, TTables> {
+	const tablesConfig = {} as TablesRelationalConfig;
+
+	for (const [tsName, table] of Object.entries(tables)) {
+		tablesConfig[tsName] = {
+			table,
+			name: tsName,
+			relations: config[tsName] ?? {},
+		};
+	}
+
+	return processRelations(tablesConfig, tables) as any;
+}
+
+/** Builds relational config only for tables present in relational config */
+export function buildRelationsParts<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(
+	tables: TTables,
+	config: TConfig,
+): ExtractTablesWithRelationsParts<TConfig, TTables> {
+	const tablesConfig = {} as TablesRelationalConfig;
+
+	for (const [tsName, relations] of Object.entries(config)) {
+		if (!relations || !tables[tsName]) continue;
+		tablesConfig[tsName] = {
+			table: tables[tsName],
+			name: tsName,
+			relations,
+		};
+	}
+
+	return processRelations(tablesConfig, tables) as any;
+}
+
+export type RelationsRecord = Record<string, AnyRelation>;
+export type EmptyRelations = {};
+export type AnyRelations = TablesRelationalConfig;
+
+export abstract class Relation<
+	TTargetTableName extends string = string,
 > {
-	static readonly [entityKind]: string = 'Relations';
+	static readonly [entityKind]: string = 'RelationV2';
+	declare readonly $brand: 'RelationV2';
+	declare public readonly relationType: 'many' | 'one';
+
+	fieldName!: string;
+	sourceColumns!: Column<any>[];
+	targetColumns!: Column<any>[];
+	alias: string | undefined;
+	where: AnyTableFilter | undefined;
+	sourceTable!: SchemaEntry;
+	targetTable: SchemaEntry;
+	through?: {
+		source: RelationsBuilderColumnBase[];
+		target: RelationsBuilderColumnBase[];
+	};
+	throughTable?: SchemaEntry;
+	isReversed?: boolean;
 
-	declare readonly $brand: 'Relations';
+	/** @internal */
+	sourceColumnTableNames: string[] = [];
+	/** @internal */
+	targetColumnTableNames: string[] = [];
 
 	constructor(
-		readonly table: AnyTable<{ name: TTableName }>,
-		readonly config: (helpers: TableRelationsHelpers<TTableName>) => TConfig,
-	) {}
+		targetTable: SchemaEntry,
+		readonly targetTableName: TTargetTableName,
+	) {
+		this.targetTable = targetTable;
+	}
 }
 
+export type AnyRelation = Relation<string>;
+
 export class One<
-	TTableName extends string = string,
-	TIsNullable extends boolean = boolean,
-> extends Relation<TTableName> {
-	static override readonly [entityKind]: string = 'One';
+	TTargetTableName extends string,
+	TOptional extends boolean = boolean,
+> extends Relation<TTargetTableName> {
+	static override readonly [entityKind]: string = 'OneV2';
+	declare protected $relationBrand: 'OneV2';
 
-	declare protected $relationBrand: 'One';
+	public override readonly relationType = 'one' as const;
+
+	readonly optional: TOptional;
 
 	constructor(
-		sourceTable: Table,
-		referencedTable: AnyTable<{ name: TTableName }>,
-		readonly config:
-			| RelationConfig<
-				TTableName,
-				string,
-				AnyColumn<{ tableName: TTableName }>[]
-			>
-			| undefined,
-		readonly isNullable: TIsNullable,
+		tables: Schema,
+		targetTable: SchemaEntry,
+		targetTableName: TTargetTableName,
+		config: AnyOneConfig | undefined,
 	) {
-		super(sourceTable, referencedTable, config?.relationName);
-	}
+		super(targetTable, targetTableName);
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) {
+			this.sourceColumns = ((Array.isArray(config.from)
+				? config.from
+				: [config.from]) as RelationsBuilderColumnBase[]).map((it: RelationsBuilderColumnBase) => {
+					this.throughTable ??= it._.through ? tables[it._.through._.tableName]! as SchemaEntry : undefined;
+					this.sourceColumnTableNames.push(it._.tableName);
+					return it._.column as Column;
+				});
+		}
+		if (config?.to) {
+			this.targetColumns = (Array.isArray(config.to)
+				? config.to
+				: [config.to]).map((it: RelationsBuilderColumnBase) => {
+					this.throughTable ??= it._.through ? tables[it._.through._.tableName]! as SchemaEntry : undefined;
+					this.targetColumnTableNames.push(it._.tableName);
+					return it._.column as Column;
+				});
+		}
 
-	withFieldName(fieldName: string): One<TTableName> {
-		const relation = new One(
-			this.sourceTable,
-			this.referencedTable,
-			this.config,
-			this.isNullable,
-		);
-		relation.fieldName = fieldName;
-		return relation;
+		if (this.throughTable) {
+			this.through = {
+				source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((
+					c,
+				) => c._.through!),
+				target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through!),
+			};
+		}
+		this.optional = (config?.optional ?? true) as TOptional;
 	}
 }
 
-export class Many<TTableName extends string> extends Relation<TTableName> {
-	static override readonly [entityKind]: string = 'Many';
+export type AnyOne = One<string, boolean>;
 
-	declare protected $relationBrand: 'Many';
+export class Many<TTargetTableName extends string> extends Relation<TTargetTableName> {
+	static override readonly [entityKind]: string = 'ManyV2';
+	declare protected $relationBrand: 'ManyV2';
+
+	public override readonly relationType = 'many' as const;
 
 	constructor(
-		sourceTable: Table,
-		referencedTable: AnyTable<{ name: TTableName }>,
-		readonly config: { relationName: string } | undefined,
+		tables: Schema,
+		targetTable: SchemaEntry,
+		targetTableName: TTargetTableName,
+		readonly config: AnyManyConfig | undefined,
 	) {
-		super(sourceTable, referencedTable, config?.relationName);
+		super(targetTable, targetTableName);
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) {
+			this.sourceColumns = ((Array.isArray(config.from)
+				? config.from
+				: [config.from]) as RelationsBuilderColumnBase[]).map((it: RelationsBuilderColumnBase) => {
+					this.throughTable ??= it._.through ? tables[it._.through._.tableName]! as SchemaEntry : undefined;
+					this.sourceColumnTableNames.push(it._.tableName);
+					return it._.column as Column;
+				});
+		}
+		if (config?.to) {
+			this.targetColumns = (Array.isArray(config.to)
+				? config.to
+				: [config.to]).map((it: RelationsBuilderColumnBase) => {
+					this.throughTable ??= it._.through ? tables[it._.through._.tableName]! as SchemaEntry : undefined;
+					this.targetColumnTableNames.push(it._.tableName);
+					return it._.column as Column;
+				});
+		}
+		if (this.throughTable) {
+			this.through = {
+				source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((
+					c,
+				) => c._.through!),
+				target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through!),
+			};
+		}
 	}
+}
 
-	withFieldName(fieldName: string): Many<TTableName> {
-		const relation = new Many(
-			this.sourceTable,
-			this.referencedTable,
-			this.config,
-		);
-		relation.fieldName = fieldName;
-		return relation;
+export type AnyMany = Many<string>;
+
+export abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
+	static readonly [entityKind]: string = 'AggregatedField';
+
+	declare readonly $brand: 'AggregatedField';
+
+	declare readonly _: {
+		readonly data: T;
+	};
+
+	protected table: SchemaEntry | undefined;
+
+	onTable(table: SchemaEntry) {
+		this.table = table;
+
+		return this;
 	}
+
+	abstract getSQL(): SQL<T>;
 }
 
-export type TableRelationsKeysOnly<
-	TSchema extends Record<string, unknown>,
-	TTableName extends string,
-	K extends keyof TSchema,
-> = TSchema[K] extends Relations<TTableName> ? K : never;
+export class Count extends AggregatedField<number> {
+	static override readonly [entityKind]: string = 'AggregatedFieldCount';
 
-export type ExtractTableRelationsFromSchema<
-	TSchema extends Record<string, unknown>,
-	TTableName extends string,
-> = ExtractObjectValues<
-	{
-		[
-			K in keyof TSchema as TableRelationsKeysOnly<
-				TSchema,
-				TTableName,
-				K
-			>
-		]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never;
+	declare protected $aggregatedFieldBrand: 'Count';
+
+	private query: SQL<number> | undefined;
+
+	getSQL(): SQL<number> {
+		if (!this.query) {
+			if (!this.table) throw new Error('Table must be set before building aggregate field');
+			this.query = sql`select count(*) as ${sql.identifier('r')} from ${getTableAsAliasSQL(this.table)}`
+				.mapWith(Number);
+		}
+
+		return this.query;
 	}
->;
+}
 
 export type ExtractObjectValues<T> = T[keyof T];
 
-export type ExtractRelationsFromTableExtraConfigSchema<
-	TConfig extends unknown[],
-> = ExtractObjectValues<
-	{
-		[
-			K in keyof TConfig as TConfig[K] extends Relations<any> ? K
-				: never
-		]: TConfig[K] extends Relations<infer TRelationConfig> ? TRelationConfig
-			: never;
-	}
->;
+export const operators = {
+	and,
+	between,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	arrayContains,
+	arrayContained,
+	arrayOverlaps,
+	isNull,
+	isNotNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notLike,
+	notIlike,
+	notInArray,
+	or,
+	sql,
+};
 
-export function getOperators() {
-	return {
-		and,
-		between,
-		eq,
-		exists,
-		gt,
-		gte,
-		ilike,
-		inArray,
-		isNull,
-		isNotNull,
-		like,
-		lt,
-		lte,
-		ne,
-		not,
-		notBetween,
-		notExists,
-		notLike,
-		notIlike,
-		notInArray,
-		or,
-		sql,
-	};
+export type Operators = typeof operators;
+
+export const orderByOperators = {
+	sql,
+	asc,
+	desc,
+};
+
+export type OrderByOperators = typeof orderByOperators;
+
+export function getOrderByOperators(): OrderByOperators {
+	return orderByOperators;
 }
 
-export type Operators = ReturnType<typeof getOperators>;
+export type FindTargetTableInRelationalConfig<
+	TConfig extends TablesRelationalConfig,
+	TRelation extends AnyRelation,
+> = TConfig[TRelation['targetTableName']];
 
-export function getOrderByOperators() {
-	return {
-		sql,
-		asc,
-		desc,
-	};
+export interface SQLOperator {
+	sql: Operators['sql'];
 }
 
-export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
+export type DBQueryConfigColumns<TColumns extends FieldSelection> = {
+	[K in keyof TColumns]?: boolean | undefined;
+};
 
-export type FindTableByDBName<
-	TSchema extends TablesRelationalConfig,
-	TTableName extends string,
-> = ExtractObjectValues<
-	{
-		[
-			K in keyof TSchema as TSchema[K]['dbName'] extends TTableName ? K
-				: never
-		]: TSchema[K];
-	}
+export type DBQueryConfigExtras<TTable extends SchemaEntry> = Record<
+	string,
+	| SQLWrapper
+	| ((
+		table: TTable,
+		operators: SQLOperator,
+	) => SQLWrapper)
 >;
 
+export type DBQueryConfigOrderByCallback<TTable extends SchemaEntry> = (
+	table: TTable,
+	operators: OrderByOperators,
+) => ValueOrArray<AnyColumn | SQL>;
+
+export type DBQueryConfigOrderByObject<TColumns extends FieldSelection> = {
+	[K in keyof TColumns]?: 'asc' | 'desc' | undefined;
+};
+
+export type DBQueryConfigOrderBy<TTable extends SchemaEntry, TColumns extends FieldSelection> =
+	| DBQueryConfigOrderByCallback<TTable>
+	| DBQueryConfigOrderByObject<TColumns>;
+
+export type DBQueryConfigWith<TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord> = {
+	[K in keyof TRelations]?:
+		| boolean
+		| (DBQueryConfig<
+			TRelations[K]['relationType'],
+			TSchema,
+			FindTargetTableInRelationalConfig<TSchema, TRelations[K]>
+		>)
+		| undefined;
+};
+
 export type DBQueryConfig<
 	TRelationType extends 'one' | 'many' = 'one' | 'many',
-	TIsRoot extends boolean = boolean,
 	TSchema extends TablesRelationalConfig = TablesRelationalConfig,
 	TTableConfig extends TableRelationalConfig = TableRelationalConfig,
 > =
+	& (TTableConfig['relations'] extends Record<string, never> ? {}
+		: {
+			with?:
+				| DBQueryConfigWith<TSchema, TTableConfig['relations']>
+				| undefined;
+		})
 	& {
-		columns?:
-			| {
-				[K in keyof TTableConfig['columns']]?: boolean;
-			}
-			| undefined;
-		with?:
-			| {
-				[K in keyof TTableConfig['relations']]?:
-					| true
-					| DBQueryConfig<
-						TTableConfig['relations'][K] extends One ? 'one' : 'many',
-						false,
-						TSchema,
-						FindTableByDBName<
-							TSchema,
-							TTableConfig['relations'][K]['referencedTableName']
-						>
-					>
-					| undefined;
-			}
-			| undefined;
+		columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
+		where?: RelationsFilter<TTableConfig, TSchema> | undefined;
 		extras?:
-			| Record<string, SQL.Aliased>
-			| ((
-				fields: Simplify<
-					[TTableConfig['columns']] extends [never] ? {}
-						: TTableConfig['columns']
-				>,
-				operators: { sql: Operators['sql'] },
-			) => Record<string, SQL.Aliased>)
+			| DBQueryConfigExtras<TTableConfig['table']>
 			| undefined;
+		orderBy?:
+			| DBQueryConfigOrderBy<TTableConfig['table'], GetTableViewFieldSelection<TTableConfig['table']>>
+			| undefined;
+		offset?: number | Placeholder | undefined;
 	}
-	& (TRelationType extends 'many' ?
-			& {
-				where?:
-					| SQL
-					| undefined
-					| ((
-						fields: Simplify<
-							[TTableConfig['columns']] extends [never] ? {}
-								: TTableConfig['columns']
-						>,
-						operators: Operators,
-					) => SQL | undefined);
-				orderBy?:
-					| ValueOrArray<AnyColumn | SQL>
-					| ((
-						fields: Simplify<
-							[TTableConfig['columns']] extends [never] ? {}
-								: TTableConfig['columns']
-						>,
-						operators: OrderByOperators,
-					) => ValueOrArray<AnyColumn | SQL>)
-					| undefined;
-				limit?: number | Placeholder | undefined;
-			}
-			& (TIsRoot extends true ? {
-					offset?: number | Placeholder | undefined;
-				}
-				: {})
+	& (TRelationType extends 'many' ? {
+			limit?: number | Placeholder | undefined;
+		}
 		: {});
 
+export type DBQueryConfigWithComment<
+	TRelationType extends 'one' | 'many' = 'one' | 'many',
+	TSchema extends TablesRelationalConfig = TablesRelationalConfig,
+	TTableConfig extends TableRelationalConfig = TableRelationalConfig,
+> = DBQueryConfig<TRelationType, TSchema, TTableConfig> & {
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	comment?: CommentInput | undefined;
+};
+
+export type AnyDBQueryConfig = {
+	columns?:
+		| DBQueryConfigColumns<GetTableViewFieldSelection<TableRelationalConfig['table']>>
+		| undefined;
+	where?: RelationsFilter<TableRelationalConfig, TablesRelationalConfig> | undefined;
+	extras?:
+		| DBQueryConfigExtras<TableRelationalConfig['table']>
+		| undefined;
+	with?:
+		| Record<string, AnyDBQueryConfig>
+		| undefined;
+	orderBy?:
+		| DBQueryConfigOrderBy<TableRelationalConfig['table'], GetTableViewFieldSelection<TableRelationalConfig['table']>>
+		| undefined;
+	offset?: number | Placeholder | undefined;
+	limit?: number | Placeholder | undefined;
+	comment?: CommentInput | undefined;
+};
+
 export interface TableRelationalConfig {
-	tsName: string;
-	dbName: string;
-	columns: Record<string, Column>;
-	relations: Record<string, Relation>;
-	primaryKey: AnyColumn[];
-	schema?: string;
+	table: SchemaEntry;
+	name: string;
+	relations: RelationsRecord;
 }
 
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
 
-export interface RelationalSchemaConfig<
-	TSchema extends TablesRelationalConfig,
-> {
-	fullSchema: Record<string, unknown>;
-	schema: TSchema;
-	tableNamesMap: Record<string, string>;
-}
-
 export type ExtractTablesWithRelations<
-	TSchema extends Record<string, unknown>,
+	TConfig extends AnyRelationsBuilderConfig,
+	TTables extends Schema,
 > = {
-	[
-		K in keyof TSchema as TSchema[K] extends Table ? K
-			: never
-	]: TSchema[K] extends Table ? {
-			tsName: K & string;
-			dbName: TSchema[K]['_']['name'];
-			columns: TSchema[K]['_']['columns'];
-			relations: ExtractTableRelationsFromSchema<
-				TSchema,
-				TSchema[K]['_']['name']
-			>;
-			primaryKey: AnyColumn[];
-		}
-		: never;
+	[K in keyof TTables]: {
+		table: TTables[K];
+		name: K & string;
+		relations: TConfig extends { [CK in K]: Record<string, any> } ? TConfig[K] : {};
+	};
+};
+
+export type ExtractTablesWithRelationsParts<
+	TConfig extends AnyRelationsBuilderConfig,
+	TTables extends Schema,
+> = {
+	[K in NonUndefinedKeysOnly<TConfig> & keyof TTables]: {
+		table: TTables[K & string];
+		name: K & string;
+		relations: TConfig[K] extends Record<string, any> ? TConfig[K] : {};
+	};
 };
 
 export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R
 	: T;
 
+export type RelationResultKind<TResult, TInclude, TRelation extends AnyRelation> = TRelation extends AnyOne ? (
+		| TResult
+		| (Equal<TRelation['optional'], true> extends true ? null
+			: TInclude extends Record<string, unknown> ? TInclude['where'] extends Record<string, any> ? null
+				: never
+			: never)
+	)
+	: TResult[];
+
 export type BuildRelationResult<
-	TSchema extends TablesRelationalConfig,
+	TConfig extends TablesRelationalConfig,
 	TInclude,
-	TRelations extends Record<string, Relation>,
+	TRelations extends RelationsRecord,
 > = {
 	[
 		K in
-			& NonUndefinedKeysOnly<TInclude>
+			& TruthyKeysOnly<TInclude>
 			& keyof TRelations
-	]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<
-			TSchema,
-			FindTableByDBName<TSchema, TRel['referencedTableName']>,
-			Assume<TInclude[K], true | Record<string, unknown>>
-		> extends infer TResult ? TRel extends One ?
-					| TResult
-					| (Equal<TRel['isNullable'], false> extends true ? null : never)
-			: TResult[]
-		: never
+	]: TRelations[K] extends infer TRel extends AnyRelation ? RelationResultKind<
+			BuildQueryResult<
+				TConfig,
+				FindTargetTableInRelationalConfig<TConfig, TRel>,
+				Assume<TInclude[K], true | Record<string, unknown>>
+			>,
+			TInclude[K],
+			TRel
+		>
+		: TRelations[K] extends AggregatedField<infer TData> ? TData
 		: never;
 };
 
-export type NonUndefinedKeysOnly<T> =
-	& ExtractObjectValues<
-		{
-			[K in keyof T as T[K] extends undefined ? never : K]: K;
-		}
-	>
-	& keyof T;
+export type NonUndefinedKeysOnly<T> = {
+	[K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+
+export type TruthyKeysOnly<T> = {
+	[K in keyof T]: T[K] extends undefined | false ? never : K;
+}[keyof T];
+
+export type InferRelationalQueryTableResult<
+	TRawSelection extends Record<string, unknown>,
+	TSelectedFields extends Record<string, unknown> | 'Full' = 'Full',
+> = TSelectedFields extends 'Full' ? TRawSelection : {
+	[
+		K in Equal<
+			Exclude<
+				TSelectedFields[
+					& keyof TSelectedFields
+					& keyof TRawSelection
+				],
+				undefined
+			>,
+			false
+		> extends true ? Exclude<
+				keyof TRawSelection,
+				NonUndefinedKeysOnly<TSelectedFields>
+			>
+			:
+				& {
+					[K in keyof TSelectedFields]: Equal<
+						TSelectedFields[K],
+						true
+					> extends true ? K
+						: never;
+				}[keyof TSelectedFields]
+				& keyof TRawSelection
+	]: TRawSelection[K];
+};
 
 export type BuildQueryResult<
 	TSchema extends TablesRelationalConfig,
 	TTableConfig extends TableRelationalConfig,
 	TFullSelection extends true | Record<string, unknown>,
-> = Equal<TFullSelection, true> extends true ? InferModelFromColumns<TTableConfig['columns']>
+	TModel extends Record<string, unknown> = Assume<
+		TTableConfig['table'],
+		{ $inferSelect: Record<string, unknown> }
+	>['$inferSelect'],
+> = TFullSelection extends true | Record<string, never> ? TModel
 	: TFullSelection extends Record<string, unknown> ? Simplify<
-			& (TFullSelection['columns'] extends Record<string, unknown> ? InferModelFromColumns<
-					{
-						[
-							K in Equal<
-								Exclude<
-									TFullSelection['columns'][
-										& keyof TFullSelection['columns']
-										& keyof TTableConfig['columns']
-									],
-									undefined
-								>,
-								false
-							> extends true ? Exclude<
-									keyof TTableConfig['columns'],
-									NonUndefinedKeysOnly<TFullSelection['columns']>
-								>
-								:
-									& {
-										[K in keyof TFullSelection['columns']]: Equal<
-											TFullSelection['columns'][K],
-											true
-										> extends true ? K
-											: never;
-									}[keyof TFullSelection['columns']]
-									& keyof TTableConfig['columns']
-						]: TTableConfig['columns'][K];
-					}
-				>
-				: InferModelFromColumns<TTableConfig['columns']>)
-			& (TFullSelection['extras'] extends
-				| Record<string, unknown>
-				| ((...args: any[]) => Record<string, unknown>) ? {
+			& (InferRelationalQueryTableResult<
+				TModel,
+				TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'
+			>)
+			& (TFullSelection['extras'] extends Record<string, SQLWrapper | ((...args: any[]) => SQLWrapper)> ? {
 					[
 						K in NonUndefinedKeysOnly<
 							ReturnTypeOrValue<TFullSelection['extras']>
 						>
-					]: Assume<
-						ReturnTypeOrValue<TFullSelection['extras']>[K],
-						SQL.Aliased
+					]: ReturnType<
+						Assume<
+							ReturnTypeOrValue<TFullSelection['extras'][K & string]>,
+							SQLWrapper
+						>['getSQL']
 					>['_']['type'];
 				}
 				: {})
@@ -403,323 +738,1316 @@ export type BuildQueryResult<
 		>
 	: never;
 
-export interface RelationConfig<
-	TTableName extends string,
-	TForeignTableName extends string,
-	TColumns extends AnyColumn<{ tableName: TTableName }>[],
-> {
-	relationName?: string;
-	fields: TColumns;
-	references: ColumnsWithTable<TTableName, TForeignTableName, TColumns>;
+export interface BuildRelationalQueryResult {
+	selection: {
+		key: string;
+		field: Column<any> | Table | View | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+		/** For array type relations */
+		isArray?: boolean;
+		selection?: BuildRelationalQueryResult['selection'];
+		isOptional?: boolean;
+		codec?: NormalizeCodec | NormalizeArrayCodec;
+		/** For array type columns */
+		arrayDimensions?: number;
+	}[];
+	sql: SQL;
 }
 
-export function extractTablesRelationalConfig<
-	TTables extends TablesRelationalConfig,
->(
-	schema: Record<string, unknown>,
-	configHelpers: (table: Table) => any,
-): { tables: TTables; tableNamesMap: Record<string, string> } {
-	if (
-		Object.keys(schema).length === 1
-		&& 'default' in schema
-		&& !is(schema['default'], Table)
-	) {
-		schema = schema['default'] as Record<string, unknown>;
-	}
-
-	// table DB name -> schema table key
-	const tableNamesMap: Record<string, string> = {};
-	// Table relations found before their tables - need to buffer them until we know the schema table key
-	const relationsBuffer: Record<
-		string,
-		{ relations: Record<string, Relation>; primaryKey?: AnyColumn[] }
-	> = {};
-	const tablesConfig: TablesRelationalConfig = {};
-	for (const [key, value] of Object.entries(schema)) {
-		if (is(value, Table)) {
-			const dbName = getTableUniqueName(value);
-			const bufferedRelations = relationsBuffer[dbName];
-			tableNamesMap[dbName] = key;
-			tablesConfig[key] = {
-				tsName: key,
-				dbName: value[Table.Symbol.Name],
-				schema: value[Table.Symbol.Schema],
-				columns: value[Table.Symbol.Columns],
-				relations: bufferedRelations?.relations ?? {},
-				primaryKey: bufferedRelations?.primaryKey ?? [],
-			};
+export function mapRelationalRow(
+	rows: Record<string, unknown> | Record<string, unknown>[],
+	isOne: boolean,
+	buildQueryResultSelection: BuildRelationalQueryResult['selection'],
+	/** Needed for SQLite as it returns JSON values as strings */
+	parseJson: boolean = false,
+	/** Needed for SingleStore as it returns JSON arrays as strings */
+	parseJsonIfString: boolean = false,
+	/** Root level data of query is usually not nested in JSON */
+	useJsonMappers: boolean = true,
+): Record<string, unknown> | Record<string, unknown>[] {
+	const maxIdx = isOne ? 1 : (rows as Record<string, unknown>[]).length;
+	const decoders: (undefined | ((v: any) => any))[] = buildQueryResultSelection.map(
+		({ field, codec, arrayDimensions }) => {
+			let decoder;
+			if (is(field, Column)) {
+				decoder = field;
+			} else if (is(field, SQL)) {
+				decoder = field.decoder;
+			} else if (is(field, SQL.Aliased)) {
+				decoder = field.sql.decoder;
+			} else if (is(field, Table) || is(field, View)) {
+				decoder = noopDecoder;
+			} else {
+				decoder = field.getSQL().decoder;
+			}
 
-			// Fill in primary keys
-			for (
-				const column of Object.values(
-					(value as Table)[Table.Symbol.Columns],
-				)
-			) {
-				if (column.primary) {
-					tablesConfig[key]!.primaryKey.push(column);
-				}
+			// Support for old custom column JSON field API
+			if (useJsonMappers && (<any> field).mapFromJsonValue) {
+				return (v) => (<(value: unknown) => unknown> (<any> field).mapFromJsonValue)(v);
 			}
 
-			const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.((value as Table)[Table.Symbol.ExtraConfigColumns]);
-			if (extraConfig) {
-				for (const configEntry of Object.values(extraConfig)) {
-					if (is(configEntry, PrimaryKeyBuilder)) {
-						tablesConfig[key]!.primaryKey.push(...configEntry.columns);
-					}
+			return decoder.mapFromDriverValue.isNoop
+				? codec
+					? (value) => codec(value, arrayDimensions!)
+					: undefined
+				: codec
+				? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions!))
+				: (value) => decoder.mapFromDriverValue(value);
+		},
+	);
+
+	for (let i = 0; i < maxIdx; ++i) {
+		const row = (isOne ? rows : (rows as Record<string, unknown>[])[i]) as Record<string, unknown>;
+
+		for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+			const selectionItem = buildQueryResultSelection[selectionItemIdx]!;
+
+			if (selectionItem.selection) {
+				if (row[selectionItem.key] === null) continue;
+
+				if (parseJson) {
+					row[selectionItem.key] = JSON.parse(row[selectionItem.key] as string);
+					if (row[selectionItem.key] === null) continue;
+				} else if (parseJsonIfString && typeof row[selectionItem.key] === 'string') {
+					row[selectionItem.key] = JSON.parse(row[selectionItem.key] as string);
 				}
-			}
-		} else if (is(value, Relations)) {
-			const dbName = getTableUniqueName(value.table);
-			const tableName = tableNamesMap[dbName];
-			const relations: Record<string, Relation> = value.config(
-				configHelpers(value.table),
-			);
-			let primaryKey: AnyColumn[] | undefined;
-
-			for (const [relationName, relation] of Object.entries(relations)) {
-				if (tableName) {
-					const tableConfig = tablesConfig[tableName]!;
-					tableConfig.relations[relationName] = relation;
-					if (primaryKey) {
-						tableConfig.primaryKey.push(...primaryKey);
-					}
-				} else {
-					if (!(dbName in relationsBuffer)) {
-						relationsBuffer[dbName] = {
-							relations: {},
-							primaryKey,
-						};
-					}
-					relationsBuffer[dbName]!.relations[relationName] = relation;
+
+				if (selectionItem.isArray) {
+					mapRelationalRow(
+						row[selectionItem.key] as Array<Record<string, unknown>>,
+						false,
+						selectionItem.selection!,
+						false,
+						parseJsonIfString,
+					);
+
+					continue;
 				}
+
+				mapRelationalRow(
+					row[selectionItem.key] as Record<string, unknown>,
+					true,
+					selectionItem.selection!,
+					false,
+					parseJsonIfString,
+				);
+
+				continue;
 			}
+
+			if (row[selectionItem.key] === null) continue;
+
+			const decoder = decoders[selectionItemIdx];
+			if (!decoder) continue;
+
+			row[selectionItem.key] = decoder(row[selectionItem.key]);
 		}
 	}
 
-	return { tables: tablesConfig as TTables, tableNamesMap };
+	return rows;
 }
 
-export function relations<
-	TTableName extends string,
-	TRelations extends Record<string, Relation<any>>,
->(
-	table: AnyTable<{ name: TTableName }>,
-	relations: (helpers: TableRelationsHelpers<TTableName>) => TRelations,
-): Relations<TTableName, TRelations> {
-	return new Relations<TTableName, TRelations>(
-		table,
-		(helpers: TableRelationsHelpers<TTableName>) =>
-			Object.fromEntries(
-				Object.entries(relations(helpers)).map(([key, value]) => [
-					key,
-					value.withFieldName(key),
-				]),
-			) as TRelations,
-	);
-}
-
-export function createOne<TTableName extends string>(sourceTable: Table) {
-	return function one<
-		TForeignTable extends Table,
-		TColumns extends [
-			AnyColumn<{ tableName: TTableName }>,
-			...AnyColumn<{ tableName: TTableName }>[],
-		],
-	>(
-		table: TForeignTable,
-		config?: RelationConfig<TTableName, TForeignTable['_']['name'], TColumns>,
-	): One<
-		TForeignTable['_']['name'],
-		Equal<TColumns[number]['_']['notNull'], true>
-	> {
-		return new One(
-			sourceTable,
-			table,
-			config,
-			(config?.fields.reduce<boolean>((res, f) => res && f.notNull, true)
-				?? false) as Equal<TColumns[number]['_']['notNull'], true>,
-		);
-	};
+export function mapRelationalRowFromArrays(
+	rows: unknown[][] | unknown[],
+	isOne: boolean,
+	buildQueryResultSelection: BuildRelationalQueryResult['selection'],
+	/** Needed for SQLite as it returns JSON values as strings */
+	parseJson: boolean = false,
+	/** Needed for SingleStore as it returns JSON arrays as strings */
+	parseJsonIfString: boolean = false,
+): Record<string, unknown> | Record<string, unknown>[] {
+	const maxIdx = isOne ? 1 : rows.length;
+	const decoders: (undefined | ((v: any) => any))[] = buildQueryResultSelection.map(
+		({ field, codec, arrayDimensions }) => {
+			let decoder;
+			if (is(field, Column)) {
+				decoder = field;
+			} else if (is(field, SQL)) {
+				decoder = field.decoder;
+			} else if (is(field, SQL.Aliased)) {
+				decoder = field.sql.decoder;
+			} else if (is(field, Table) || is(field, View)) {
+				decoder = noopDecoder;
+			} else {
+				decoder = field.getSQL().decoder;
+			}
+
+			return decoder.mapFromDriverValue.isNoop
+				? codec
+					? (value) => codec(value, arrayDimensions!)
+					: undefined
+				: codec
+				? (value) => decoder.mapFromDriverValue(codec(value, arrayDimensions!))
+				: (value) => decoder.mapFromDriverValue(value);
+		},
+	);
+
+	const results: Record<string, unknown>[] = Array.from({ length: maxIdx });
+
+	for (let i = 0; i < maxIdx; ++i) {
+		const row = (isOne ? rows : rows[i]!) as unknown[];
+		const result: Record<string, unknown> = {};
+
+		for (let selectionItemIdx = 0; selectionItemIdx < buildQueryResultSelection.length; ++selectionItemIdx) {
+			const selectionItem = buildQueryResultSelection[selectionItemIdx]!;
+			let value = row[selectionItemIdx];
+
+			if (selectionItem.selection) {
+				if (value === null) {
+					result[selectionItem.key] = null;
+					continue;
+				}
+
+				if (parseJson) {
+					value = JSON.parse(value as string);
+					if (value === null) {
+						result[selectionItem.key] = null;
+						continue;
+					}
+				} else if (parseJsonIfString && typeof value === 'string') {
+					value = JSON.parse(value);
+				}
+
+				if (selectionItem.isArray) {
+					mapRelationalRow(
+						value as Array<Record<string, unknown>>,
+						false,
+						selectionItem.selection!,
+						false,
+						parseJsonIfString,
+					);
+				} else {
+					mapRelationalRow(
+						value as Record<string, unknown>,
+						true,
+						selectionItem.selection!,
+						false,
+						parseJsonIfString,
+					);
+				}
+
+				result[selectionItem.key] = value;
+				continue;
+			}
+
+			if (value === null) {
+				result[selectionItem.key] = null;
+				continue;
+			}
+
+			const decoder = decoders[selectionItemIdx];
+			result[selectionItem.key] = decoder ? decoder(value) : value;
+		}
+
+		results[i] = result;
+	}
+
+	return isOne ? results[0]! : results;
+}
+
+export interface RelationalRowsMapper<T = any> {
+	(rows: unknown[][] | Record<string, unknown>[]): T;
+	/** @internal jit mapper's function body for debugging */
+	body?: string;
 }
 
-export function createMany(sourceTable: Table) {
-	return function many<TForeignTable extends Table>(
-		referencedTable: TForeignTable,
-		config?: { relationName: string },
-	): Many<TForeignTable['_']['name']> {
-		return new Many(sourceTable, referencedTable, config);
+export type RelationalRowsMapperGenerator<T = any> = (
+	config: RelationalQueryMapperConfig,
+) => RelationalRowsMapper<T>;
+
+export function makeDefaultRqbMapper<T = any>(
+	{ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }: RelationalQueryMapperConfig,
+): RelationalRowsMapper<T> {
+	return ((rows) => {
+		if (isFirst && !rows[0]) return rows[0];
+
+		return arrayModeRoot
+			? mapRelationalRowFromArrays(
+				(isFirst ? rows[0]! : rows) as unknown[][] | unknown[],
+				isFirst,
+				selection,
+				parseJson,
+				parseJsonIfString,
+			)
+			: mapRelationalRow(
+				(isFirst ? rows[0]! : rows) as Record<string, unknown>[] | Record<string, unknown>,
+				isFirst,
+				selection,
+				parseJson,
+				parseJsonIfString,
+				rootJsonMappers,
+			);
+	}) as RelationalRowsMapper<T>;
+}
+
+function makeJitRqbMapperInner(
+	selection: BuildRelationalQueryResult['selection'],
+	rowExpr: string,
+	selectionVar: string,
+	/** Needed for SQLite as it returns JSON values as strings */
+	parseJson: boolean,
+	/** Needed for SingleStore as it returns JSON arrays as strings */
+	parseJsonIfString: boolean,
+	/** Root level data of query is usually not nested in JSON */
+	useJsonMappers: boolean,
+	preFn: string[],
+	counter: { n: number },
+	accessByIdx: boolean,
+): { bodyStmts: string[]; literal: string; hasWork: boolean } {
+	const bodyStmts: string[] = [];
+	const literalEntries: string[] = [];
+	let hasWork = false;
+
+	const fieldVars: string[] = selection.map(() => `c${counter.n++}`);
+	const destructurePieces = selection.map((item, idx) =>
+		accessByIdx ? fieldVars[idx]! : `${JSON.stringify(item.key)}: ${fieldVars[idx]}`
+	);
+	bodyStmts.push(
+		accessByIdx
+			? `let [ ${destructurePieces.join(', ')} ] = ${rowExpr};`
+			: `let { ${destructurePieces.join(', ')} } = ${rowExpr};`,
+	);
+
+	for (
+		const [idx, { field, key, codec, isArray, selection: innerSelection, arrayDimensions }] of selection
+			.entries()
+	) {
+		const sel = `${selectionVar}[${idx}]`;
+		const keyStr = JSON.stringify(key);
+		const slot = fieldVars[idx]!;
+
+		if (innerSelection) {
+			if (parseJson) {
+				bodyStmts.push(`if (${slot} !== null) ${slot} = JSON.parse(${slot});`);
+				hasWork = true;
+			} else if (parseJsonIfString) {
+				bodyStmts.push(`if (typeof ${slot} === 'string') ${slot} = JSON.parse(${slot});`);
+				hasWork = true;
+			}
+
+			const nestedSelVar = `s${counter.n++}`;
+			const savedPreFnLen = preFn.length;
+			preFn.push(`const { selection: ${nestedSelVar} } = ${sel};`);
+
+			if (isArray) {
+				const j = `j${counter.n++}`;
+				const inner = makeJitRqbMapperInner(
+					innerSelection,
+					`${slot}[${j}]`,
+					nestedSelVar,
+					false,
+					parseJsonIfString,
+					true,
+					preFn,
+					counter,
+					false,
+				);
+				if (inner.hasWork) {
+					hasWork = true;
+					bodyStmts.push(`if (${slot} !== null) {`);
+					bodyStmts.push(`\tfor (let ${j} = 0; ${j} < ${slot}.length; ++${j}) {`);
+					for (const s of inner.bodyStmts) bodyStmts.push(`\t\t${s}`);
+					bodyStmts.push(`\t\t${slot}[${j}] = ${inner.literal};`);
+					bodyStmts.push(`\t}`);
+					bodyStmts.push(`}`);
+				} else {
+					preFn.splice(savedPreFnLen, 1);
+				}
+			} else {
+				const inner = makeJitRqbMapperInner(
+					innerSelection,
+					slot,
+					nestedSelVar,
+					false,
+					parseJsonIfString,
+					true,
+					preFn,
+					counter,
+					false,
+				);
+				if (inner.hasWork) {
+					hasWork = true;
+					bodyStmts.push(`if (${slot} !== null) {`);
+					for (const s of inner.bodyStmts) bodyStmts.push(`\t${s}`);
+					bodyStmts.push(`\t${slot} = ${inner.literal};`);
+					bodyStmts.push(`}`);
+				} else {
+					preFn.splice(savedPreFnLen, 1);
+				}
+			}
+
+			literalEntries.push(`${keyStr}: ${slot}`);
+			continue;
+		}
+
+		let decoderExpr = '';
+		let destructure = '';
+		let bypassCodecs = false;
+		if (is(field, Column)) {
+			if (useJsonMappers && (<any> field).mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: dec${id}`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: dec${id}`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, SQL)) {
+			if (useJsonMappers && (<any> field.decoder).mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: { decoder: dec${id} }`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: { decoder: dec${id} }`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, SQL.Aliased)) {
+			if (useJsonMappers && (<any> field.sql.decoder).mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				destructure = `field: { sql: { decoder: dec${id} } }`;
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!field.sql.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				destructure = `field: { sql: { decoder: dec${id} } }`;
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		} else if (is(field, Table) || is(field, View)) {
+			// no decoder
+		} else {
+			const sqlExpr = field.getSQL();
+
+			if (useJsonMappers && (<any> sqlExpr.decoder).mapFromJsonValue) {
+				bypassCodecs = true;
+				const id = counter.n++;
+				preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+				decoderExpr = `dec${id}.mapFromJsonValue`;
+			} else if (!sqlExpr.decoder.mapFromDriverValue.isNoop) {
+				const id = counter.n++;
+				preFn.push(`const dec${id} = ${sel}.field.getSQL().decoder;`);
+				decoderExpr = `dec${id}.mapFromDriverValue`;
+			}
+		}
+
+		let codecVar = '';
+		if (!bypassCodecs && codec) {
+			codecVar = `codec${counter.n++}`;
+		}
+
+		if (destructure || codecVar) {
+			const parts: string[] = [];
+			if (destructure) parts.push(destructure);
+			if (codecVar) parts.push(`codec: ${codecVar}`);
+			preFn.push(`const { ${parts.join(', ')} } = ${sel};`);
+		}
+
+		if (decoderExpr || codecVar) {
+			hasWork = true;
+			let decoded = slot;
+			if (codecVar) decoded = `${codecVar}(${decoded}, ${arrayDimensions})`;
+			if (decoderExpr) decoded = `${decoderExpr}(${decoded})`;
+			literalEntries.push(`${keyStr}: ${slot} === null ? null : ${decoded}`);
+		} else {
+			literalEntries.push(`${keyStr}: ${slot}`);
+		}
+	}
+
+	const literal = `{ ${literalEntries.join(', ')} }`;
+
+	return { bodyStmts, literal, hasWork };
+}
+
+export interface RelationalQueryMapperConfig {
+	selection: BuildRelationalQueryResult['selection'];
+	/** Used for `db.query.table.findFirst(...)` */
+	isFirst: boolean;
+	/** Used by SQLite & drivers that return JSON-s as strings by default */
+	parseJson: boolean;
+	/** Used by SingleStore to fix malformed outputs for empty JSON arrays */
+	parseJsonIfString: boolean;
+	/** Enable for non-reworked dialects & drivers with JSON-ified root level of relational query */
+	rootJsonMappers: boolean;
+	/** Used when root level of data is in array mode */
+	arrayModeRoot?: boolean;
+}
+
+export function makeJitRqbMapper<T = unknown>(
+	{ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }: RelationalQueryMapperConfig,
+): RelationalRowsMapper<T> {
+	const preFn: string[] = [];
+	const counter = { n: 0 };
+
+	const inner = makeJitRqbMapperInner(
+		selection,
+		'row',
+		'selection',
+		parseJson,
+		parseJsonIfString,
+		arrayModeRoot ? false : rootJsonMappers,
+		preFn,
+		counter,
+		!!arrayModeRoot,
+	);
+
+	const lines: string[] = [];
+	lines.push(`\t"use strict";
+	const { selection } = this;`);
+	for (const p of preFn) lines.push(`\t${p}`);
+
+	if (arrayModeRoot) {
+		if (isFirst) {
+			lines.push(`\tconst row = rows[0];`);
+			lines.push(`\tif (!row) return undefined;`);
+			for (const s of inner.bodyStmts) lines.push(`\t${s}`);
+			lines.push(`\treturn ${inner.literal};`);
+		} else {
+			lines.push(`\tconst { length } = rows;`);
+			lines.push(`\tconst mapped = Array.from({ length });`);
+			lines.push(`\tfor (let i = 0; i < length; ++i) {`);
+			lines.push(`\t\tconst row = rows[i];`);
+			for (const s of inner.bodyStmts) lines.push(`\t\t${s}`);
+			lines.push(`\t\tmapped[i] = ${inner.literal};`);
+			lines.push(`\t}`);
+			lines.push(`\treturn mapped;`);
+		}
+	} else if (!inner.hasWork) {
+		lines.push(isFirst ? `\treturn rows[0];` : `\treturn rows;`);
+	} else if (isFirst) {
+		lines.push(`\tconst row = rows[0];`);
+		lines.push(`\tif (!row) return undefined;`);
+		for (const s of inner.bodyStmts) lines.push(`\t${s}`);
+		lines.push(`\trows[0] = ${inner.literal};`);
+		lines.push(`\treturn rows[0];`);
+	} else {
+		lines.push(`\tfor (let i = 0; i < rows.length; ++i) {`);
+		lines.push(`\t\tconst row = rows[i];`);
+		for (const s of inner.bodyStmts) lines.push(`\t\t${s}`);
+		lines.push(`\t\trows[i] = ${inner.literal};`);
+		lines.push(`\t}`);
+		lines.push(`\treturn rows;`);
+	}
+
+	lines.push('\t//# sourceURL=drizzle:jit-relational-query-mapper');
+	const compiled = lines.join('\n');
+
+	return Object.assign(
+		new FnConstructor(
+			'rows',
+			compiled,
+		).bind({
+			selection,
+		}),
+		{ body: `function jitRqbMapper (rows) {\n${compiled}\n}` },
+	) as RelationalRowsMapper<T>;
+}
+
+export class RelationsBuilderTable<TTableName extends string = string> {
+	static readonly [entityKind]: string = 'RelationsBuilderTable';
+
+	protected readonly _: {
+		readonly name: TTableName;
+		readonly table: SchemaEntry;
 	};
+
+	constructor(table: SchemaEntry, name: TTableName) {
+		this._ = {
+			name,
+			table,
+		};
+	}
 }
 
-export interface NormalizedRelation {
-	fields: AnyColumn[];
-	references: AnyColumn[];
+export interface RelationsBuilderColumnConfig<
+	TTableName extends string = string,
+> {
+	readonly tableName: TTableName;
+	readonly column: FieldValue;
+	readonly through?: RelationsBuilderColumnBase;
+	readonly key: string;
 }
 
-export function normalizeRelation(
-	schema: TablesRelationalConfig,
-	tableNamesMap: Record<string, string>,
-	relation: Relation,
-): NormalizedRelation {
-	if (is(relation, One) && relation.config) {
-		return {
-			fields: relation.config.fields,
-			references: relation.config.references,
+export interface RelationsBuilderColumnBase<
+	TTableName extends string = string,
+> {
+	_: RelationsBuilderColumnConfig<TTableName>;
+}
+
+export class RelationsBuilderColumn<
+	TTableName extends string = string,
+> implements RelationsBuilderColumnBase<TTableName> {
+	static readonly [entityKind]: string = 'RelationsBuilderColumn';
+
+	readonly _: {
+		readonly tableName: TTableName;
+		readonly column: FieldValue;
+		readonly key: string;
+	};
+
+	constructor(
+		column: FieldValue,
+		tableName: TTableName,
+		key: string,
+	) {
+		this._ = {
+			tableName: tableName,
+			column,
+			key,
 		};
 	}
 
-	const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-	if (!referencedTableTsName) {
-		throw new Error(
-			`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`,
+	through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName> {
+		return new RelationsBuilderJunctionColumn(
+			this._.column,
+			this._.tableName,
+			this._.key,
+			column,
 		);
 	}
+}
 
-	const referencedTableConfig = schema[referencedTableTsName];
-	if (!referencedTableConfig) {
-		throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+export class RelationsBuilderJunctionColumn<
+	TTableName extends string = string,
+> implements RelationsBuilderColumnBase<TTableName> {
+	static readonly [entityKind]: string = 'RelationsBuilderColumn';
+
+	readonly _: {
+		readonly tableName: TTableName;
+		readonly column: FieldValue;
+		readonly through: RelationsBuilderColumnBase;
+		readonly key: string;
+	};
+
+	constructor(
+		column: FieldValue,
+		tableName: TTableName,
+		key: string,
+		through: RelationsBuilderColumnBase,
+	) {
+		this._ = {
+			tableName: tableName,
+			column,
+			through,
+			key,
+		};
 	}
+}
 
-	const sourceTable = relation.sourceTable;
-	const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-	if (!sourceTableTsName) {
-		throw new Error(
-			`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`,
-		);
+export interface RelationFieldsFilterInternals<T> {
+	eq?: T | Placeholder | undefined;
+	ne?: T | Placeholder | undefined;
+	gt?: T | Placeholder | undefined;
+	gte?: T | Placeholder | undefined;
+	lt?: T | Placeholder | undefined;
+	lte?: T | Placeholder | undefined;
+	in?: (T | Placeholder)[] | Placeholder | undefined;
+	notIn?: (T | Placeholder)[] | Placeholder | undefined;
+	arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+	arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+	arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+	like?: string | Placeholder | undefined;
+	ilike?: string | Placeholder | undefined;
+	notLike?: string | Placeholder | undefined;
+	notIlike?: string | Placeholder | undefined;
+	isNull?: true | undefined;
+	isNotNull?: true | undefined;
+	NOT?: RelationsFieldFilter<T> | undefined;
+	OR?: RelationsFieldFilter<T>[] | undefined;
+	AND?: RelationsFieldFilter<T>[] | undefined;
+}
+
+export type RelationsFieldFilter<T = unknown> =
+	| RelationFieldsFilterInternals<T>
+	| (
+		unknown extends T ? never : T extends object ? never : T
+	)
+	// Bleeds into filters - discuss removal
+	| Placeholder;
+
+export interface RelationsFilterCommons<
+	TTable extends TableRelationalConfig = TableRelationalConfig,
+	TSchema extends TablesRelationalConfig = TablesRelationalConfig,
+> {
+	OR?: RelationsFilter<TTable, TSchema>[] | undefined;
+	NOT?: RelationsFilter<TTable, TSchema> | undefined;
+	AND?: RelationsFilter<TTable, TSchema>[] | undefined;
+	RAW?:
+		| SQLWrapper
+		| ((
+			table: TTable['table'],
+			operators: Operators,
+		) => SQL)
+		| undefined;
+}
+
+export type RelationsFilterColumns<
+	TColumns extends Record<string, unknown>,
+> = {
+	[K in keyof TColumns]?:
+		| (TColumns[K] extends { _: { data: infer Data } } ? RelationsFieldFilter<Data>
+			: RelationsFieldFilter<unknown>)
+		| undefined;
+};
+
+export type RelationsFilterRelations<
+	TTable extends TableRelationalConfig,
+	TSchema extends TablesRelationalConfig,
+	TRelations extends RelationsRecord = TTable['relations'],
+> = {
+	[K in keyof TRelations]?:
+		| boolean
+		| RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema>
+		| undefined;
+};
+
+export type RelationsFilter<
+	TTable extends TableRelationalConfig,
+	TSchema extends TablesRelationalConfig,
+	TColumns extends FieldSelection = GetTableViewFieldSelection<TTable['table']>,
+> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']>
+	:
+		& RelationsFilterColumns<TColumns>
+		& RelationsFilterRelations<TTable, TSchema>
+		& RelationsFilterCommons<TTable, TSchema>;
+
+export interface TableFilterCommons<
+	TTable extends SchemaEntry = SchemaEntry,
+	TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>,
+> {
+	OR?: TableFilter<TTable, TColumns>[] | undefined;
+	NOT?: TableFilter<TTable, TColumns> | undefined;
+	AND?: TableFilter<TTable, TColumns>[] | undefined;
+	RAW?:
+		| SQLWrapper
+		| ((
+			table: TTable,
+			operators: Operators,
+		) => SQL)
+		| undefined;
+}
+
+export type TableFilterColumns<
+	TColumns extends Record<string, unknown>,
+> = {
+	[K in keyof TColumns]?:
+		| (TColumns[K] extends { _: { data: infer Data } } ? RelationsFieldFilter<Data>
+			: RelationsFieldFilter<unknown>)
+		| undefined;
+};
+
+export type TableFilter<
+	TTable extends SchemaEntry = SchemaEntry,
+	TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>,
+> =
+	& TableFilterColumns<TColumns>
+	& TableFilterCommons<TTable, TColumns>;
+
+export type AnyRelationsFilter = RelationsFilter<
+	TableRelationalConfig,
+	TablesRelationalConfig,
+	FieldSelection
+>;
+
+export type AnyTableFilter = TableFilter<
+	SchemaEntry,
+	FieldSelection
+>;
+
+export interface OneConfig<TTargetTable extends SchemaEntry, TOptional extends boolean> {
+	from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+	to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+	where?: TableFilter<TTargetTable>;
+	optional?: TOptional;
+	alias?: string;
+}
+
+export type AnyOneConfig = OneConfig<
+	SchemaEntry,
+	boolean
+>;
+
+export interface ManyConfig<TTargetTable extends SchemaEntry> {
+	from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+	to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+	where?: TableFilter<TTargetTable>;
+	alias?: string;
+}
+
+export type AnyManyConfig = ManyConfig<SchemaEntry>;
+
+export interface OneFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
+	<TOptional extends boolean = true>(config?: OneConfig<TTargetTable, TOptional>): One<TTargetTableName, TOptional>;
+}
+
+export interface ManyFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
+	(config?: ManyConfig<TTargetTable>): Many<TTargetTableName>;
+}
+
+export class RelationsHelperStatic<TTables extends Schema> {
+	static readonly [entityKind]: string = 'RelationsHelperStatic';
+	// declare readonly $brand: 'RelationsHelperStatic';
+
+	private readonly _: {
+		readonly tables: TTables;
+	};
+
+	constructor(tables: TTables) {
+		this._ = {
+			tables,
+		};
+
+		const one: Record<string, OneFn<TTables[string], string>> = {};
+		const many: Record<string, ManyFn<TTables[string], string>> = {};
+
+		for (const [tableName, table] of Object.entries(tables)) {
+			one[tableName] = (config) => {
+				return new One(tables, table, tableName, config as unknown as AnyOneConfig);
+			};
+
+			many[tableName] = (config) => {
+				return new Many(tables, table, tableName, config as AnyManyConfig);
+			};
+		}
+
+		this.one = one as any as this['one'];
+		this.many = many as any as this['many'];
 	}
 
-	const reverseRelations: Relation[] = [];
-	for (
-		const referencedTableRelation of Object.values(
-			referencedTableConfig.relations,
+	one: {
+		[K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? OneFn<TTables[K], K & string>
+			: DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+	};
+
+	many: {
+		[K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? ManyFn<TTables[K], K & string>
+			: DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+	};
+
+	/** @internal - to be reworked */
+	aggs = {
+		count(): Count {
+			return new Count();
+		},
+	};
+}
+
+export type RelationsBuilderColumns<TTable extends SchemaEntry, TTableName extends string> = {
+	[
+		TColumnName in keyof GetTableViewColumns<TTable>
+	]: RelationsBuilderColumn<
+		TTableName
+	>;
+};
+
+export type RelationsBuilderTables<TSchema extends Schema> = {
+	[TTableName in keyof TSchema]: TSchema[TTableName] extends FilteredSchemaEntry ? (
+			& RelationsBuilderColumns<TSchema[TTableName], TTableName & string>
+			& RelationsBuilderTable<TTableName & string>
 		)
-	) {
-		if (
-			(relation.relationName
-				&& relation !== referencedTableRelation
-				&& referencedTableRelation.relationName === relation.relationName)
-			|| (!relation.relationName
-				&& referencedTableRelation.referencedTable === relation.sourceTable)
-		) {
-			reverseRelations.push(referencedTableRelation);
+		: DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+};
+
+export type RelationsBuilder<TSchema extends Schema> =
+	& RelationsBuilderTables<TSchema>
+	& RelationsHelperStatic<TSchema>;
+
+export type RelationsBuilderConfigValue =
+	| RelationsRecord
+	| undefined;
+
+export type RelationsBuilderConfig<TTables extends Schema> = {
+	[TTableName in keyof TTables]?: RelationsBuilderConfigValue;
+};
+
+export type AnyRelationsBuilderConfig = Record<string, RelationsBuilderConfigValue>;
+
+export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
+	[K in keyof TSchema as TSchema[K] extends SchemaEntry ? K extends string ? K : never : never]: Assume<
+		TSchema[K],
+		SchemaEntry
+	>;
+};
+
+export function createRelationsHelper<
+	TTables extends Schema,
+>(tables: TTables): RelationsBuilder<TTables> {
+	const helperStatic = new RelationsHelperStatic(tables);
+	const relationsTables = Object.entries(tables).reduce<Record<string, RelationsBuilderTable>>((acc, [tKey, value]) => {
+		const rTable = new RelationsBuilderTable(value, tKey);
+		const columns = Object.entries(value[TableColumns]).reduce<
+			Record<string, RelationsBuilderColumnBase>
+		>(
+			(acc, [cKey, column]) => {
+				const rbColumn = new RelationsBuilderColumn(column as FieldValue, tKey, cKey);
+				acc[cKey] = rbColumn;
+				return acc;
+			},
+			{},
+		);
+
+		acc[tKey] = Object.assign(rTable, columns);
+
+		return acc;
+	}, {});
+
+	return Object.assign(helperStatic, relationsTables) as any;
+}
+
+export function extractTablesFromSchema<TSchema extends Record<string, unknown>>(
+	schema: TSchema,
+): ExtractTablesFromSchema<TSchema> {
+	return Object.fromEntries(
+		Object.entries(schema).filter(([_, e]) => is(e, Table) || is(e, View)),
+	) as ExtractTablesFromSchema<TSchema>;
+}
+
+export type IncludeEveryTable<TTables extends Schema> = { [K in keyof TTables]: {} };
+
+/** Builds relational config for every table in schema */
+export function defineRelations<
+	TSchema extends Record<string, unknown>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+): ExtractTablesWithRelations<{}, TTables>;
+/** Builds relational config for every table in schema */
+export function defineRelations<
+	TSchema extends Record<string, unknown>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+): ExtractTablesWithRelations<TConfig, TTables>;
+export function defineRelations(
+	schema: Record<string, unknown>,
+	relations?: (helpers: RelationsBuilder<Schema>) => AnyRelationsBuilderConfig,
+): TablesRelationalConfig {
+	const tables = extractTablesFromSchema(schema);
+	const config = relations
+		? relations(
+			createRelationsHelper(tables) as RelationsBuilder<Schema>,
+		)
+		: {};
+
+	return buildRelations(tables, config);
+}
+
+/** Builds relational config for every table in schema */
+export function defineRelationsPart<
+	TSchema extends Record<string, unknown>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+): ExtractTablesWithRelationsParts<IncludeEveryTable<TTables>, TTables>;
+/** Builds relational config only for tables present in relational config */
+export function defineRelationsPart<
+	TSchema extends Record<string, unknown>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+): ExtractTablesWithRelationsParts<TConfig, TTables>;
+export function defineRelationsPart(
+	schema: Record<string, unknown>,
+	relations?: (helpers: RelationsBuilder<Schema>) => AnyRelationsBuilderConfig,
+): TablesRelationalConfig {
+	const tables = extractTablesFromSchema(schema);
+	const config = relations
+		? relations(
+			createRelationsHelper(tables) as RelationsBuilder<Schema>,
+		)
+		: Object.fromEntries(Object.keys(tables).map((k) => [k, {}])) as AnyRelationsBuilderConfig;
+
+	return buildRelationsParts(tables, config);
+}
+
+export interface WithContainer {
+	with?: Record<string, boolean | AnyDBQueryConfig | undefined>;
+}
+
+export interface ColumnWithTSName {
+	column: Table | View | Column<any> | SQL | SQLWrapper | SQL.Aliased;
+	tsName: string;
+}
+
+export type RelationsOrder<TColumns extends FieldSelection> = {
+	[K in keyof TColumns]?: 'asc' | 'desc';
+};
+
+export type OrderBy = Exclude<AnyDBQueryConfig['orderBy'], undefined>;
+
+export type Extras = Exclude<AnyDBQueryConfig['extras'], undefined>;
+
+/** @internal */
+export function fieldSelectionToSQL(table: SchemaEntry, target: string) {
+	const field = table[TableColumns][target];
+
+	return field
+		? is(field, Column)
+			? field
+			: is(field, SQL.Aliased)
+			? sql`${table}.${sql.identifier(field.fieldAlias)}`
+			: sql`${table}.${sql.identifier(target)}`
+		: sql`${table}.${sql.identifier(target)}`;
+}
+
+function relationsFieldFilterToSQL(column: SQLWrapper, filter: RelationsFieldFilter<unknown>): SQL | undefined {
+	if (typeof filter !== 'object' || is(filter, Placeholder)) return eq(column, filter);
+
+	const entries = Object.entries(filter as RelationFieldsFilterInternals<unknown>);
+	if (!entries.length) return undefined;
+
+	const parts: (SQL)[] = [];
+	for (const [target, value] of entries) {
+		if (value === undefined) continue;
+
+		switch (target as keyof RelationFieldsFilterInternals<unknown>) {
+			case 'NOT': {
+				const res = relationsFieldFilterToSQL(column, value as RelationsFieldFilter<unknown>);
+				if (!res) continue;
+
+				parts.push(not(res));
+
+				continue;
+			}
+
+			case 'OR': {
+				if (!(value as RelationsFieldFilter<unknown>[]).length) continue;
+
+				parts.push(
+					or(
+						...(value as AnyRelationsFilter[]).map((subFilter) => relationsFieldFilterToSQL(column, subFilter)),
+					)!,
+				);
+
+				continue;
+			}
+
+			case 'AND': {
+				if (!(value as RelationsFieldFilter<unknown>[]).length) continue;
+
+				parts.push(
+					and(
+						...(value as AnyRelationsFilter[]).map((subFilter) => relationsFieldFilterToSQL(column, subFilter)),
+					)!,
+				);
+
+				continue;
+			}
+
+			case 'isNotNull':
+			case 'isNull': {
+				if (!value) continue;
+
+				parts.push(operators[target as 'isNull' | 'isNotNull'](column));
+
+				continue;
+			}
+
+			case 'in': {
+				parts.push(operators.inArray(column, value as any[] | Placeholder));
+
+				continue;
+			}
+
+			case 'notIn': {
+				parts.push(operators.notInArray(column, value as any[] | Placeholder));
+
+				continue;
+			}
+
+			default: {
+				parts.push(
+					(operators[target as keyof typeof operators] as ((col: SQLWrapper, data: any) => SQL | undefined))(
+						column,
+						value,
+					)!,
+				);
+
+				continue;
+			}
 		}
 	}
 
-	if (reverseRelations.length > 1) {
-		throw relation.relationName
-			? new Error(
-				`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`,
-			)
-			: new Error(
-				`There are multiple relations between "${referencedTableTsName}" and "${
-					relation.sourceTable[Table.Symbol.Name]
-				}". Please specify relation name`,
-			);
+	if (!parts.length) return undefined;
+
+	return and(...parts);
+}
+
+export function relationsFilterToSQL(
+	table: SchemaEntry,
+	filter: AnyRelationsFilter | AnyTableFilter,
+): SQL | undefined;
+export function relationsFilterToSQL(
+	table: SchemaEntry,
+	filter: AnyRelationsFilter | AnyTableFilter,
+	tableRelations: RelationsRecord,
+	tablesRelations: TablesRelationalConfig,
+	depth?: number,
+): SQL | undefined;
+export function relationsFilterToSQL(
+	table: SchemaEntry,
+	filter: AnyRelationsFilter | AnyTableFilter,
+	tableRelations: RelationsRecord = {},
+	tablesRelations: TablesRelationalConfig = {},
+	depth: number = 0,
+): SQL | undefined {
+	const entries = Object.entries(filter);
+	if (!entries.length) return undefined;
+
+	const parts: SQL[] = [];
+	for (const [target, value] of entries) {
+		if (value === undefined) continue;
+
+		switch (target) {
+			case 'RAW': {
+				const processed = typeof value === 'function'
+					? (value as unknown as (table: FieldSelection, operators: Operators) => SQL)(table as any, operators)
+					: (value as SQLWrapper).getSQL();
+
+				parts.push(processed);
+
+				continue;
+			}
+			case 'OR': {
+				if (!(value as AnyRelationsFilter[] | undefined)?.length) continue;
+
+				parts.push(
+					or(
+						...(value as AnyRelationsFilter[]).map((subFilter) =>
+							relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth)
+						),
+					)!,
+				);
+
+				continue;
+			}
+			case 'AND': {
+				if (!(value as AnyRelationsFilter[] | undefined)?.length) continue;
+
+				parts.push(
+					and(
+						...(value as AnyRelationsFilter[]).map((subFilter) =>
+							relationsFilterToSQL(table, subFilter, tableRelations, tablesRelations, depth)
+						),
+					)!,
+				);
+
+				continue;
+			}
+			case 'NOT': {
+				if (value === undefined) continue;
+
+				const built = relationsFilterToSQL(
+					table,
+					value as AnyRelationsFilter,
+					tableRelations,
+					tablesRelations,
+					depth,
+				);
+				if (!built) continue;
+
+				parts.push(not(built));
+
+				continue;
+			}
+			default: {
+				if (table[TableColumns][target]) {
+					const column = fieldSelectionToSQL(table, target);
+
+					const colFilter = relationsFieldFilterToSQL(
+						column,
+						value as RelationsFieldFilter,
+					);
+					if (colFilter) parts.push(colFilter);
+
+					continue;
+				}
+
+				const relation = tableRelations[target];
+				if (!relation) {
+					// Should never trigger unless the types've been violated
+					throw new DrizzleError({
+						message: `Unknown relational filter field: "${target}"`,
+					});
+				}
+
+				const targetTable = aliasedTable(relation.targetTable, `f${depth}`);
+				const throughTable = relation.throughTable ? aliasedTable(relation.throughTable, `ft${depth}`) : undefined;
+				const targetConfig = tablesRelations[relation.targetTableName]!;
+
+				const {
+					filter: relationFilter,
+					joinCondition,
+				} = relationToSQL(relation, table, targetTable, throughTable);
+				const subfilter = typeof value === 'boolean' ? undefined : relationsFilterToSQL(
+					targetTable,
+					value as AnyRelationsFilter,
+					targetConfig.relations,
+					tablesRelations,
+					depth + 1,
+				);
+				const filter = and(
+					relationFilter,
+					subfilter,
+				);
+
+				const subquery = throughTable
+					? sql`(select * from ${getTableAsAliasSQL(targetTable)} inner join ${
+						getTableAsAliasSQL(throughTable)
+					} on ${joinCondition}${sql` where ${filter}`.if(filter)} limit 1)`
+					: sql`(select * from ${getTableAsAliasSQL(targetTable)}${sql` where ${filter}`.if(filter)} limit 1)`;
+				if (filter) parts.push((value ? exists : notExists)(subquery));
+			}
+		}
 	}
 
-	if (
-		reverseRelations[0]
-		&& is(reverseRelations[0], One)
-		&& reverseRelations[0].config
-	) {
-		return {
-			fields: reverseRelations[0].config.references,
-			references: reverseRelations[0].config.fields,
-		};
+	return and(...parts)!;
+}
+
+export function relationsOrderToSQL(
+	table: SchemaEntry,
+	orders: OrderBy,
+): SQL | undefined {
+	if (typeof orders === 'function') {
+		const data = orders(table as any, orderByOperators);
+
+		return is(data, SQL)
+			? data
+			: Array.isArray(data)
+			? data.length
+				? sql.join(data.map((o) => is(o, SQL) ? o : asc(o)), sql`, `)
+				: undefined
+			: is(data, Column)
+			? asc(data)
+			: undefined;
 	}
 
-	throw new Error(
-		`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`,
+	const entries = Object.entries(orders).filter(([_, value]) => value);
+	if (!entries.length) return undefined;
+
+	return sql.join(
+		entries.map(([target, value]) => (value === 'asc' ? asc : desc)(fieldSelectionToSQL(table, target))),
+		sql`, `,
 	);
 }
 
-export function createTableRelationsHelpers<TTableName extends string>(
-	sourceTable: AnyTable<{ name: TTableName }>,
+export function relationExtrasToSQL(
+	table: SchemaEntry,
+	extras: Extras,
+	codecs?: CodecsCollection,
+	inJson?: boolean,
 ) {
+	const subqueries: SQL[] = [];
+	const selection: BuildRelationalQueryResult['selection'] = [];
+
+	for (
+		const [key, field] of Object.entries(extras)
+	) {
+		if (!field) continue;
+		const extra = typeof field === 'function' ? field(table as any, { sql: operators.sql }) : field;
+
+		const subq = extra.getSQL();
+		const column = codecs ? getColumnFromDecoder(subq) : undefined;
+		// Codec bypass for custom columns with enabled legacy JSON api
+		const query = column && (!inJson || !(<any> column).jsonSelectIdentifier)
+			? sql`${codecs!.apply(column, inJson ? 'castInJson' : 'cast', sql`(${subq})`)} as ${sql.identifier(key)}`
+			: sql`(${subq}) as ${sql.identifier(key)}`;
+		query.decoder = subq.decoder;
+
+		subqueries.push(query);
+		selection.push(
+			// Codec bypass for custom columns with enabled legacy JSON api
+			column && (!inJson || !(<any> column).mapFromJsonValue)
+				? {
+					key,
+					field: query,
+					codec: codecs!.get(column, inJson ? 'normalizeInJson' : 'normalize'),
+					arrayDimensions: (<any> column).dimensions,
+				}
+				: {
+					key,
+					field: query,
+				},
+		);
+	}
+
 	return {
-		one: createOne<TTableName>(sourceTable),
-		many: createMany(sourceTable),
+		sql: subqueries.length ? sql.join(subqueries, sql`, `) : undefined,
+		selection,
 	};
 }
 
-export type TableRelationsHelpers<TTableName extends string> = ReturnType<
-	typeof createTableRelationsHelpers<TTableName>
->;
-
-export interface BuildRelationalQueryResult<
-	TTable extends Table = Table,
-	TColumn extends Column = Column,
-> {
-	tableTsKey: string;
-	selection: {
-		dbKey: string;
-		tsKey: string;
-		field: TColumn | SQL | SQL.Aliased;
-		relationTableTsKey: string | undefined;
-		isJson: boolean;
-		isExtra?: boolean;
-		selection: BuildRelationalQueryResult<TTable>['selection'];
-	}[];
-	sql: TTable | SQL;
+export interface BuiltRelationFilters {
+	filter?: SQL;
+	joinCondition?: SQL;
 }
 
-export function mapRelationalRow(
-	tablesConfig: TablesRelationalConfig,
-	tableConfig: TableRelationalConfig,
-	row: unknown[],
-	buildQueryResultSelection: BuildRelationalQueryResult['selection'],
-	mapColumnValue: (value: unknown) => unknown = (value) => value,
-): Record<string, unknown> {
-	const result: Record<string, unknown> = {};
+export function relationToSQL(
+	relation: Relation,
+	sourceTable: SchemaEntry,
+	targetTable: SchemaEntry,
+	throughTable?: SchemaEntry,
+): BuiltRelationFilters {
+	if (relation.through) {
+		const outerColumnWhere = relation.sourceColumns.map((s, i) => {
+			const t = relation.through!.source[i]!;
 
-	for (
-		const [
-			selectionItemIndex,
-			selectionItem,
-		] of buildQueryResultSelection.entries()
-	) {
-		if (selectionItem.isJson) {
-			const relation = tableConfig.relations[selectionItem.tsKey]!;
-			const rawSubRows = row[selectionItemIndex] as
-				| unknown[]
-				| null
-				| [null]
-				| string;
-			const subRows = typeof rawSubRows === 'string'
-				? (JSON.parse(rawSubRows) as unknown[])
-				: rawSubRows;
-			result[selectionItem.tsKey] = is(relation, One)
-				? subRows
-					&& mapRelationalRow(
-						tablesConfig,
-						tablesConfig[selectionItem.relationTableTsKey!]!,
-						subRows,
-						selectionItem.selection,
-						mapColumnValue,
-					)
-				: (subRows as unknown[][]).map((subRow) =>
-					mapRelationalRow(
-						tablesConfig,
-						tablesConfig[selectionItem.relationTableTsKey!]!,
-						subRow,
-						selectionItem.selection,
-						mapColumnValue,
-					)
-				);
-		} else {
-			const value = mapColumnValue(row[selectionItemIndex]);
-			const field = selectionItem.field!;
-			let decoder;
-			if (is(field, Column)) {
-				decoder = field;
-			} else if (is(field, SQL)) {
-				decoder = field.decoder;
-			} else {
-				decoder = field.sql.decoder;
-			}
-			result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
-		}
+			return eq(
+				sql`${sourceTable}.${sql.identifier(s.name)}`,
+				sql`${throughTable!}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`,
+			);
+		});
+
+		const innerColumnWhere = relation.targetColumns.map((s, i) => {
+			const t = relation.through!.target[i]!;
+
+			return eq(
+				sql`${throughTable!}.${sql.identifier(is(t._.column, Column) ? t._.column.name : t._.key)}`,
+				sql`${targetTable}.${sql.identifier(s.name)}`,
+			);
+		});
+
+		return {
+			filter: and(
+				relation.where
+					? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where)
+					: undefined,
+				...outerColumnWhere,
+			),
+			joinCondition: and(...innerColumnWhere),
+		};
 	}
 
-	return result;
+	const columnWhere = relation.sourceColumns.map((s, i) => {
+		const t = relation.targetColumns[i]!;
+
+		return eq(
+			sql`${sourceTable}.${sql.identifier(s.name)}`,
+			sql`${targetTable}.${sql.identifier(t.name)}`,
+		);
+	});
+
+	const fullWhere = and(
+		...columnWhere,
+		relation.where
+			? relationsFilterToSQL(relation.isReversed ? sourceTable : targetTable, relation.where)
+			: undefined,
+	)!;
+
+	return { filter: fullWhere };
+}
+
+export function getTableAsAliasSQL(table: SchemaEntry) {
+	return sql`${
+		table[IsAlias]
+			? sql`${sql`${sql.identifier(table[TableSchema] ?? '')}.`.if(table[TableSchema])}${
+				sql.identifier(table[OriginalName])
+			} as ${table}`
+			: table
+	}`;
 }
diff --git a/drizzle-orm/src/selection-proxy.ts b/drizzle-orm/src/selection-proxy.ts
index 7cf46415a1..f3491609f1 100644
--- a/drizzle-orm/src/selection-proxy.ts
+++ b/drizzle-orm/src/selection-proxy.ts
@@ -1,4 +1,4 @@
-import { ColumnAliasProxyHandler, TableAliasProxyHandler } from './alias.ts';
+import { ColumnTableAliasProxyHandler, TableAliasProxyHandler } from './alias.ts';
 import { Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
 import { SQL, View } from './sql/sql.ts';
@@ -84,6 +84,7 @@ export class SelectionProxyHandler<T extends Subquery | Record<string, unknown>
 
 			const newValue = value.clone();
 			newValue.isSelectionField = true;
+			newValue.origin = this.config.alias;
 			return newValue;
 		}
 
@@ -101,11 +102,12 @@ export class SelectionProxyHandler<T extends Subquery | Record<string, unknown>
 			if (this.config.alias) {
 				return new Proxy(
 					value,
-					new ColumnAliasProxyHandler(
+					new ColumnTableAliasProxyHandler(
 						new Proxy(
 							value.table,
-							new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false),
+							new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false, true),
 						),
+						true,
 					),
 				);
 			}
diff --git a/drizzle-orm/src/session.ts b/drizzle-orm/src/session.ts
index 7446905b6b..1c4ec029a7 100644
--- a/drizzle-orm/src/session.ts
+++ b/drizzle-orm/src/session.ts
@@ -1,8 +1,5 @@
-import type { Query } from './index.ts';
+import type { Query } from './sql/sql.ts';
 
 export interface PreparedQuery {
 	getQuery(): Query;
-	mapResult(response: unknown, isFromBatch?: boolean): unknown;
-	/** @internal */
-	isResponseInArrayMode(): boolean;
 }
diff --git a/drizzle-orm/src/singlestore-core/casing.ts b/drizzle-orm/src/singlestore-core/casing.ts
new file mode 100644
index 0000000000..bd62efa982
--- /dev/null
+++ b/drizzle-orm/src/singlestore-core/casing.ts
@@ -0,0 +1,16 @@
+import { type SingleStoreSchema, singlestoreSchema } from './schema.ts';
+import { singlestoreTableWithCasing } from './table.ts';
+
+export const snakeCase = {
+	table: singlestoreTableWithCasing('snake_case'),
+	schema: <T extends string>(name: T): SingleStoreSchema<T> => {
+		return singlestoreSchema(name, 'snake_case');
+	},
+};
+
+export const camelCase = {
+	table: singlestoreTableWithCasing('camelCase'),
+	schema: <T extends string>(name: T): SingleStoreSchema<T> => {
+		return singlestoreSchema(name, 'camelCase');
+	},
+};
diff --git a/drizzle-orm/src/singlestore-core/columns/bigint.ts b/drizzle-orm/src/singlestore-core/columns/bigint.ts
index fed436993c..7354094807 100644
--- a/drizzle-orm/src/singlestore-core/columns/bigint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/bigint.ts
@@ -1,41 +1,33 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreBigInt53BuilderInitial<TName extends string> = SingleStoreBigInt53Builder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreBigInt53';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-}>;
-
-export class SingleStoreBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreBigInt53'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt53Builder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number uint53' : 'number int53';
+		data: number;
+		driverParam: number | string;
+	}, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreBigInt53Builder';
 
-	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'number', 'SingleStoreBigInt53');
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, unsigned ? 'number uint53' : 'number int53' as any, 'SingleStoreBigInt53');
 		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreBigInt53<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreBigInt53<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBigInt53(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreBigInt53<T extends ColumnBaseConfig<'number', 'SingleStoreBigInt53'>>
+export class SingleStoreBigInt53<T extends ColumnBaseConfig<'number int53' | 'number uint53'>>
 	extends SingleStoreColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreBigInt53';
@@ -44,46 +36,38 @@ export class SingleStoreBigInt53<T extends ColumnBaseConfig<'number', 'SingleSto
 		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'number') {
 			return value;
 		}
 		return Number(value);
-	}
+	};
 }
 
-export type SingleStoreBigInt64BuilderInitial<TName extends string> = SingleStoreBigInt64Builder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'SingleStoreBigInt64';
-	data: bigint;
-	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'SingleStoreBigInt64'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt64Builder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'bigint uint64' : 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	}, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreBigInt64Builder';
 
-	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'bigint', 'SingleStoreBigInt64');
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, unsigned ? 'bigint uint64' : 'bigint int64' as any, 'SingleStoreBigInt64');
 		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreBigInt64<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreBigInt64<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBigInt64(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreBigInt64<T extends ColumnBaseConfig<'bigint', 'SingleStoreBigInt64'>>
+export class SingleStoreBigInt64<T extends ColumnBaseConfig<'bigint int64' | 'bigint uint64'>>
 	extends SingleStoreColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreBigInt64';
@@ -93,27 +77,70 @@ export class SingleStoreBigInt64<T extends ColumnBaseConfig<'bigint', 'SingleSto
 	}
 
 	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
-	override mapFromDriverValue(value: string): bigint {
+	override mapFromDriverValue = (value: string): bigint => {
 		return BigInt(value);
+	};
+}
+
+export class SingleStoreBigIntStringBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'string uint64' : 'string int64';
+		data: string;
+		driverParam: string;
+	}, { unsigned: boolean }>
+{
+	static override readonly [entityKind]: string = 'SingleStoreBigIntStringBuilder';
+
+	constructor(name: string, unsigned: boolean = false) {
+		super(name, unsigned ? 'string uint64' : 'string int64' as any, 'SingleStoreBigIntString');
+		this.config.unsigned = unsigned;
+	}
+
+	/** @internal */
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBigIntString(
+			table,
+			this.config as any,
+		);
+	}
+}
+
+export class SingleStoreBigIntString<T extends ColumnBaseConfig<'string int64' | 'string uint64'>>
+	extends SingleStoreColumnWithAutoIncrement<T, { unsigned: boolean }>
+{
+	static override readonly [entityKind]: string = 'SingleStoreBigIntString';
+
+	getSQLType(): string {
+		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 }
 
-export interface SingleStoreBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+export interface SingleStoreBigIntConfig<
+	T extends 'number' | 'bigint' | 'string' = 'number' | 'bigint' | 'string',
+	TUnsigned extends boolean | undefined = boolean | undefined,
+> {
 	mode: T;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function bigint<TMode extends SingleStoreBigIntConfig['mode']>(
-	config: SingleStoreBigIntConfig<TMode>,
-): TMode extends 'number' ? SingleStoreBigInt53BuilderInitial<''> : SingleStoreBigInt64BuilderInitial<''>;
-export function bigint<TName extends string, TMode extends SingleStoreBigIntConfig['mode']>(
-	name: TName,
-	config: SingleStoreBigIntConfig<TMode>,
-): TMode extends 'number' ? SingleStoreBigInt53BuilderInitial<TName> : SingleStoreBigInt64BuilderInitial<TName>;
+export function bigint<TMode extends SingleStoreBigIntConfig['mode'], TUnsigned extends boolean | undefined>(
+	config: SingleStoreBigIntConfig<TMode, TUnsigned>,
+): TMode extends 'string' ? SingleStoreBigIntStringBuilder<TUnsigned>
+	: TMode extends 'bigint' ? SingleStoreBigInt64Builder<TUnsigned>
+	: SingleStoreBigInt53Builder<TUnsigned>;
+export function bigint<TMode extends SingleStoreBigIntConfig['mode'], TUnsigned extends boolean | undefined>(
+	name: string,
+	config: SingleStoreBigIntConfig<TMode, TUnsigned>,
+): TMode extends 'string' ? SingleStoreBigIntStringBuilder<TUnsigned>
+	: TMode extends 'bigint' ? SingleStoreBigInt64Builder<TUnsigned>
+	: SingleStoreBigInt53Builder<TUnsigned>;
 export function bigint(a?: string | SingleStoreBigIntConfig, b?: SingleStoreBigIntConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreBigIntConfig>(a, b);
 	if (config.mode === 'number') {
 		return new SingleStoreBigInt53Builder(name, config.unsigned);
 	}
+	if (config.mode === 'string') {
+		return new SingleStoreBigIntStringBuilder(name, config.unsigned);
+	}
 	return new SingleStoreBigInt64Builder(name, config.unsigned);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/binary.ts b/drizzle-orm/src/singlestore-core/columns/binary.ts
index 3e9af83ade..8039de7f59 100644
--- a/drizzle-orm/src/singlestore-core/columns/binary.ts
+++ b/drizzle-orm/src/singlestore-core/columns/binary.ts
@@ -1,53 +1,41 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreBinaryBuilderInitial<TName extends string> = SingleStoreBinaryBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreBinary';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreBinary'>>
-	extends SingleStoreColumnBuilder<
-		T,
-		SingleStoreBinaryConfig
-	>
-{
+export class SingleStoreBinaryBuilder extends SingleStoreColumnBuilder<
+	{
+		dataType: 'string binary';
+		data: string;
+		driverParam: string;
+	},
+	SingleStoreBinaryConfig & { setLength: boolean }
+> {
 	static override readonly [entityKind]: string = 'SingleStoreBinaryBuilder';
 
-	constructor(name: T['name'], length: number | undefined) {
-		super(name, 'string', 'SingleStoreBinary');
-		this.config.length = length;
+	constructor(name: string, length: number | undefined) {
+		super(name, 'string binary', 'SingleStoreBinary');
+		this.config.length = length ?? 1;
+		this.config.setLength = length !== undefined;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreBinary<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreBinary<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBinary(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreBinary<T extends ColumnBaseConfig<'string', 'SingleStoreBinary'>> extends SingleStoreColumn<
+export class SingleStoreBinary<T extends ColumnBaseConfig<'string binary'>> extends SingleStoreColumn<
 	T,
-	SingleStoreBinaryConfig
+	SingleStoreBinaryConfig & { setLength: boolean }
 > {
 	static override readonly [entityKind]: string = 'SingleStoreBinary';
 
-	length: number | undefined = this.config.length;
-
-	override mapFromDriverValue(value: string | Buffer | Uint8Array): string {
+	override mapFromDriverValue = (value: string | Buffer | Uint8Array): string => {
 		if (typeof value === 'string') return value;
 		if (Buffer.isBuffer(value)) return value.toString();
 
@@ -57,10 +45,10 @@ export class SingleStoreBinary<T extends ColumnBaseConfig<'string', 'SingleStore
 		}
 
 		return str.join('');
-	}
+	};
 
 	getSQLType(): string {
-		return this.length === undefined ? `binary` : `binary(${this.length})`;
+		return this.config.setLength ? `binary(${this.length})` : `binary`;
 	}
 }
 
@@ -68,14 +56,13 @@ export interface SingleStoreBinaryConfig {
 	length?: number;
 }
 
-export function binary(): SingleStoreBinaryBuilderInitial<''>;
 export function binary(
 	config?: SingleStoreBinaryConfig,
-): SingleStoreBinaryBuilderInitial<''>;
-export function binary<TName extends string>(
-	name: TName,
+): SingleStoreBinaryBuilder;
+export function binary(
+	name: string,
 	config?: SingleStoreBinaryConfig,
-): SingleStoreBinaryBuilderInitial<TName>;
+): SingleStoreBinaryBuilder;
 export function binary(a?: string | SingleStoreBinaryConfig, b: SingleStoreBinaryConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreBinaryConfig>(a, b);
 	return new SingleStoreBinaryBuilder(name, config.length);
diff --git a/drizzle-orm/src/singlestore-core/columns/boolean.ts b/drizzle-orm/src/singlestore-core/columns/boolean.ts
index bf48ff1daa..2a242dec68 100644
--- a/drizzle-orm/src/singlestore-core/columns/boolean.ts
+++ b/drizzle-orm/src/singlestore-core/columns/boolean.ts
@@ -1,58 +1,43 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreBooleanBuilderInitial<TName extends string> = SingleStoreBooleanBuilder<{
-	name: TName;
+export class SingleStoreBooleanBuilder extends SingleStoreColumnBuilder<{
 	dataType: 'boolean';
-	columnType: 'SingleStoreBoolean';
 	data: boolean;
 	driverParam: number | boolean;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'SingleStoreBoolean'>>
-	extends SingleStoreColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreBooleanBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: string) {
 		super(name, 'boolean', 'SingleStoreBoolean');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreBoolean<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreBoolean<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBoolean(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreBoolean<T extends ColumnBaseConfig<'boolean', 'SingleStoreBoolean'>>
-	extends SingleStoreColumn<T>
-{
+export class SingleStoreBoolean<T extends ColumnBaseConfig<'boolean'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreBoolean';
 
 	getSQLType(): string {
 		return 'boolean';
 	}
 
-	override mapFromDriverValue(value: number | boolean): boolean {
+	override mapFromDriverValue = (value: number | boolean): boolean => {
 		if (typeof value === 'boolean') {
 			return value;
 		}
 		return value === 1;
-	}
+	};
 }
 
-export function boolean(): SingleStoreBooleanBuilderInitial<''>;
-export function boolean<TName extends string>(name: TName): SingleStoreBooleanBuilderInitial<TName>;
-export function boolean(name?: string) {
+export function boolean(name?: string): SingleStoreBooleanBuilder {
 	return new SingleStoreBooleanBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/char.ts b/drizzle-orm/src/singlestore-core/columns/char.ts
index 9039466886..d0be993002 100644
--- a/drizzle-orm/src/singlestore-core/columns/char.ts
+++ b/drizzle-orm/src/singlestore-core/columns/char.ts
@@ -1,85 +1,67 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreCharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = SingleStoreCharBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreChar';
-	data: TEnum[number];
-	driverParam: number | string;
-	enumValues: TEnum;
-	generated: undefined;
-	length: TLength;
-}>;
-
 export class SingleStoreCharBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreChar'> & { length?: number | undefined },
+	TEnum extends [string, ...string[]],
 > extends SingleStoreColumnBuilder<
-	T,
-	SingleStoreCharConfig<T['enumValues'], T['length']>,
-	{ length: T['length'] }
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: number | string;
+		enumValues: TEnum;
+	},
+	{ enum?: TEnum; length: number; setLength: boolean }
 > {
 	static override readonly [entityKind]: string = 'SingleStoreCharBuilder';
 
-	constructor(name: T['name'], config: SingleStoreCharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'SingleStoreChar');
-		this.config.length = config.length;
+	constructor(name: string, config: SingleStoreCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'SingleStoreChar');
+		this.config.length = config.length ?? 1;
+		this.config.setLength = config.length !== undefined;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }> {
-		return new SingleStoreChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreChar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreChar<T extends ColumnBaseConfig<'string', 'SingleStoreChar'> & { length?: number | undefined }>
-	extends SingleStoreColumn<T, SingleStoreCharConfig<T['enumValues'], T['length']>, { length: T['length'] }>
-{
+export class SingleStoreChar<
+	T extends ColumnBaseConfig<'string' | 'string enum'>,
+> extends SingleStoreColumn<T, { enum?: T['enumValues']; length: number; setLength: boolean }> {
 	static override readonly [entityKind]: string = 'SingleStoreChar';
 
-	readonly length: T['length'] = this.config.length;
 	override readonly enumValues = this.config.enum;
 
 	getSQLType(): string {
-		return this.length === undefined ? `char` : `char(${this.length})`;
+		return this.config.setLength ? `char(${this.length})` : `char`;
 	}
 }
 
 export interface SingleStoreCharConfig<
 	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length?: TLength;
+	length?: number;
 }
 
-export function char(): SingleStoreCharBuilderInitial<'', [string, ...string[]], undefined>;
-export function char<U extends string, T extends Readonly<[U, ...U[]]>, L extends number | undefined>(
-	config?: SingleStoreCharConfig<T | Writable<T>, L>,
-): SingleStoreCharBuilderInitial<'', Writable<T>, L>;
+export function char<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: SingleStoreCharConfig<T | Writable<T>>,
+): SingleStoreCharBuilder<Writable<T>>;
 export function char<
-	TName extends string,
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 >(
-	name: TName,
-	config?: SingleStoreCharConfig<T | Writable<T>, L>,
-): SingleStoreCharBuilderInitial<TName, Writable<T>, L>;
+	name: string,
+	config?: SingleStoreCharConfig<T | Writable<T>>,
+): SingleStoreCharBuilder<Writable<T>>;
 export function char(a?: string | SingleStoreCharConfig, b: SingleStoreCharConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreCharConfig>(a, b);
 	return new SingleStoreCharBuilder(name, config as any);
diff --git a/drizzle-orm/src/singlestore-core/columns/common.ts b/drizzle-orm/src/singlestore-core/columns/common.ts
index 7f2a521e5b..2f5bbeb044 100644
--- a/drizzle-orm/src/singlestore-core/columns/common.ts
+++ b/drizzle-orm/src/singlestore-core/columns/common.ts
@@ -1,41 +1,33 @@
 import type {
-	ColumnBuilderBase,
 	ColumnBuilderBaseConfig,
 	ColumnBuilderExtraConfig,
 	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
+	ColumnType,
 	HasDefault,
+	HasGenerated,
 	IsAutoincrement,
-	MakeColumnConfig,
 } from '~/column-builder.ts';
 import { ColumnBuilder } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { Column } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable, SingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { SQL } from '~/sql/sql.ts';
 import type { Update } from '~/utils.ts';
-import { uniqueKeyName } from '../unique-constraint.ts';
 
-export interface SingleStoreColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'singlestore' }> {}
+export type SingleStoreColumns = Record<string, SingleStoreColumn<any>>;
 
 export interface SingleStoreGeneratedColumnConfig {
 	mode?: 'virtual' | 'stored';
 }
 
 export abstract class SingleStoreColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string> & {
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType> & {
 		data: any;
 	},
 	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'singlestore' }, TExtraConfig>
-	implements SingleStoreColumnBuilderBase<T, TTypeConfig>
-{
+> extends ColumnBuilder<T, TRuntimeConfig, TExtraConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreColumnBuilder';
 
 	unique(name?: string): this {
@@ -45,8 +37,10 @@ export abstract class SingleStoreColumnBuilder<
 	}
 
 	// TODO: Implement generated columns for SingleStore (https://docs.singlestore.com/cloud/create-a-database/using-persistent-computed-columns/)
-	/** @internal */
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: SingleStoreGeneratedColumnConfig) {
+	generatedAlwaysAs(
+		as: SQL | (() => SQL),
+		config?: SingleStoreGeneratedColumnConfig,
+	): HasGenerated<this, { type: 'always' }> {
 		this.config.generated = {
 			as,
 			type: 'always',
@@ -56,47 +50,44 @@ export abstract class SingleStoreColumnBuilder<
 	}
 
 	/** @internal */
-	abstract build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreColumn<MakeColumnConfig<T, TTableName>>;
+	abstract build(table: SingleStoreTable): SingleStoreColumn;
 }
 
 // To understand how to use `SingleStoreColumn` and `AnySingleStoreColumn`, see `Column` and `AnyColumn` documentation.
 export abstract class SingleStoreColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = {},
-	TTypeConfig extends object = {},
-> extends Column<T, TRuntimeConfig, TTypeConfig & { dialect: 'singlestore' }> {
+> extends Column<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreColumn';
 
+	/** @internal */
+	override readonly table: SingleStoreTable;
+
 	constructor(
-		override readonly table: SingleStoreTable,
-		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
+		table: SingleStoreTable,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
 	) {
-		if (!config.uniqueName) {
-			config.uniqueName = uniqueKeyName(table, [config.name]);
-		}
 		super(table, config);
+		this.table = table;
 	}
 }
 
-export type AnySingleStoreColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> =
-	SingleStoreColumn<
-		Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
-	>;
+export type AnySingleStoreColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = SingleStoreColumn<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
+>;
 
 export interface SingleStoreColumnWithAutoIncrementConfig {
 	autoIncrement: boolean;
 }
 
 export abstract class SingleStoreColumnBuilderWithAutoIncrement<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
 > extends SingleStoreColumnBuilder<T, TRuntimeConfig & SingleStoreColumnWithAutoIncrementConfig, TExtraConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreColumnBuilderWithAutoIncrement';
 
-	constructor(name: NonNullable<T['name']>, dataType: T['dataType'], columnType: T['columnType']) {
+	constructor(name: string, dataType: T['dataType'], columnType: string) {
 		super(name, dataType, columnType);
 		this.config.autoIncrement = false;
 	}
@@ -109,7 +100,7 @@ export abstract class SingleStoreColumnBuilderWithAutoIncrement<
 }
 
 export abstract class SingleStoreColumnWithAutoIncrement<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends SingleStoreColumn<T, SingleStoreColumnWithAutoIncrementConfig & TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreColumnWithAutoIncrement';
diff --git a/drizzle-orm/src/singlestore-core/columns/custom.ts b/drizzle-orm/src/singlestore-core/columns/custom.ts
index 964e077d7d..1c21614506 100644
--- a/drizzle-orm/src/singlestore-core/columns/custom.ts
+++ b/drizzle-orm/src/singlestore-core/columns/custom.ts
@@ -1,20 +1,16 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import type { SQL } from '~/sql/sql.ts';
+import type { AnySingleStoreTable, SingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
 	& {
-		name: TName;
 		dataType: 'custom';
-		columnType: 'SingleStoreCustomColumn';
 		data: T['data'];
 		driverParam: T['driverData'];
-		enumValues: undefined;
-		generated: undefined;
 	}
 	& (T['notNull'] extends true ? { notNull: true } : {})
 	& (T['default'] extends true ? { hasDefault: true } : {});
@@ -23,22 +19,19 @@ export interface SingleStoreCustomColumnInnerConfig {
 	customTypeValues: CustomTypeValues;
 }
 
-export class SingleStoreCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'SingleStoreCustomColumn'>>
+export class SingleStoreCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>>
 	extends SingleStoreColumnBuilder<
 		T,
 		{
 			fieldConfig: CustomTypeValues['config'];
 			customTypeParams: CustomTypeParams<any>;
-		},
-		{
-			singlestoreColumnBuilderBrand: 'SingleStoreCustomColumnBuilderBrand';
 		}
 	>
 {
 	static override readonly [entityKind]: string = 'SingleStoreCustomColumnBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		fieldConfig: CustomTypeValues['config'],
 		customTypeParams: CustomTypeParams<any>,
 	) {
@@ -48,24 +41,22 @@ export class SingleStoreCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'c
 	}
 
 	/** @internal */
-	build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreCustomColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreCustomColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreCustomColumn<T extends ColumnBaseConfig<'custom', 'SingleStoreCustomColumn'>>
-	extends SingleStoreColumn<T>
-{
+export class SingleStoreCustomColumn<T extends ColumnBaseConfig<'custom'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreCustomColumn';
 
 	private sqlName: string;
 	private mapTo?: (value: T['data']) => T['driverParam'];
 	private mapFrom?: (value: T['driverParam']) => T['data'];
+	private mapJson?: (value: unknown) => T['data'];
+	private forJsonSelect?: (name: SQL, sql: SQLGenerator) => SQL;
 
 	constructor(
 		table: AnySingleStoreTable<{ name: T['tableName'] }>,
@@ -75,22 +66,51 @@ export class SingleStoreCustomColumn<T extends ColumnBaseConfig<'custom', 'Singl
 		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
 		this.mapTo = config.customTypeParams.toDriver;
 		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapJson = config.customTypeParams.fromJson;
+		this.forJsonSelect = config.customTypeParams.forJsonSelect;
 	}
 
 	getSQLType(): string {
 		return this.sqlName;
 	}
 
-	override mapFromDriverValue(value: T['driverParam']): T['data'] {
+	override mapFromDriverValue = (value: T['driverParam']): T['data'] => {
 		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	};
+
+	mapFromJsonValue(value: unknown): T['data'] {
+		return typeof this.mapJson === 'function' ? this.mapJson(value) : this.mapFromDriverValue(value) as T['data'];
 	}
 
-	override mapToDriverValue(value: T['data']): T['driverParam'] {
-		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	jsonSelectIdentifier(identifier: SQL, sql: SQLGenerator): SQL {
+		if (typeof this.forJsonSelect === 'function') return this.forJsonSelect(identifier, sql);
+
+		const rawType = this.getSQLType().toLowerCase();
+		const parenPos = rawType.indexOf('(');
+		const type = (parenPos + 1) ? rawType.slice(0, parenPos) : rawType;
+
+		switch (type) {
+			case 'binary':
+			case 'varbinary':
+			case 'time':
+			case 'datetime':
+			case 'decimal':
+			case 'float':
+			case 'bigint': {
+				return sql`cast(${identifier} as char)`;
+			}
+			default: {
+				return identifier;
+			}
+		}
 	}
+
+	override mapToDriverValue = (value: T['data']): T['driverParam'] => {
+		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	};
 }
 
-export type CustomTypeValues = {
+export interface CustomTypeValues {
 	/**
 	 * Required type for custom column, that will infer proper type model
 	 *
@@ -102,11 +122,25 @@ export type CustomTypeValues = {
 	 */
 	data: unknown;
 
+	/**
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
 	/**
 	 * Type helper, that represents what type database driver is accepting for specific database data type
 	 */
 	driverData?: unknown;
 
+	/**
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
 	/**
 	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
 	 */
@@ -141,7 +175,7 @@ export type CustomTypeValues = {
 	 * });
 	 */
 	default?: boolean;
-};
+}
 
 export interface CustomTypeParams<T extends CustomTypeValues> {
 	/**
@@ -176,7 +210,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
 
 	/**
-	 * Optional mapping function, between user input and driver
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
 	 * @example
 	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
 	 * ```
@@ -188,16 +222,115 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	toDriver?: (value: T['data']) => T['driverData'] | SQL;
 
 	/**
-	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
 	 * @example
 	 * For example, when using timestamp we need to map string Date representation to JS Date
 	 * ```
 	 * fromDriver(value: string): Date {
 	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07 03:25:16.635";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07 03:25:16.635");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying bigint column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's string representation, as opposed to bigint from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): bigint {
+	 * 	return BigInt(value);
+	 * },
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "5044565289845416380";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: 5044565289845416380n;
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `binary`, `varbinary`, `time`, `datetime`, `decimal`, `float`, `bigint`
+	 * @example
+	 * For example, when using bigint we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator): SQL {
+	 * 	return sql`cast(${identifier} as char)`
 	 * },
 	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		`table`.`custom_bigint` AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	json_build_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		cast(`table`.`custom_bigint` as char) AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
 	 */
-	fromDriver?: (value: T['driverData']) => T['data'];
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator) => SQL;
 }
 
 /**
@@ -208,28 +341,28 @@ export function customType<T extends CustomTypeValues = CustomTypeValues>(
 ): Equal<T['configRequired'], true> extends true ? {
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig: TConfig,
-		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbname: string,
 			fieldConfig: T['config'],
-		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 	: {
-		(): SingleStoreCustomColumnBuilder<ConvertCustomConfig<'', T>>;
+		(): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>>;
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig?: TConfig,
-		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbname: string,
 			fieldConfig?: T['config'],
-		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 {
-	return <TName extends string>(
-		a?: TName | T['config'],
+	return (
+		a?: string | T['config'],
 		b?: T['config'],
-	): SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+	): SingleStoreCustomColumnBuilder<ConvertCustomConfig<T>> => {
 		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
-		return new SingleStoreCustomColumnBuilder(name as ConvertCustomConfig<TName, T>['name'], config, customTypeParams);
+		return new SingleStoreCustomColumnBuilder(name, config, customTypeParams);
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/date.common.ts b/drizzle-orm/src/singlestore-core/columns/date.common.ts
index 39b2507ebd..06b3733be2 100644
--- a/drizzle-orm/src/singlestore-core/columns/date.common.ts
+++ b/drizzle-orm/src/singlestore-core/columns/date.common.ts
@@ -1,9 +1,4 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderExtraConfig,
-	ColumnDataType,
-	HasDefault,
-} from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig, ColumnBuilderExtraConfig, ColumnType, HasDefault } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/sql.ts';
@@ -14,7 +9,7 @@ export interface SingleStoreDateColumnBaseConfig {
 }
 
 export abstract class SingleStoreDateColumnBaseBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
 > extends SingleStoreColumnBuilder<T, TRuntimeConfig & SingleStoreDateColumnBaseConfig, TExtraConfig> {
@@ -32,7 +27,7 @@ export abstract class SingleStoreDateColumnBaseBuilder<
 }
 
 export abstract class SingleStoreDateBaseColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends SingleStoreColumn<T, SingleStoreDateColumnBaseConfig & TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreDateColumn';
diff --git a/drizzle-orm/src/singlestore-core/columns/date.ts b/drizzle-orm/src/singlestore-core/columns/date.ts
index 70da74f3a6..83b51fd284 100644
--- a/drizzle-orm/src/singlestore-core/columns/date.ts
+++ b/drizzle-orm/src/singlestore-core/columns/date.ts
@@ -1,46 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { AnySingleStoreTable, SingleStoreTable } from '~/singlestore-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreDateBuilderInitial<TName extends string> = SingleStoreDateBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'SingleStoreDate';
+export class SingleStoreDateBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreDate'>>
-	extends SingleStoreColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreDateBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'date', 'SingleStoreDate');
+	constructor(name: string) {
+		super(name, 'object date', 'SingleStoreDate');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDate<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDate<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDate(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDate<T extends ColumnBaseConfig<'date', 'SingleStoreDate'>> extends SingleStoreColumn<T> {
+export class SingleStoreDate<T extends ColumnBaseConfig<'object date'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreDate';
 
 	constructor(
 		table: AnySingleStoreTable<{ name: T['tableName'] }>,
-		config: SingleStoreDateBuilder<T>['config'],
+		config: SingleStoreDateBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -49,49 +38,37 @@ export class SingleStoreDate<T extends ColumnBaseConfig<'date', 'SingleStoreDate
 		return `date`;
 	}
 
-	override mapFromDriverValue(value: string): Date {
+	override mapFromDriverValue = (value: string): Date => {
 		return new Date(value);
-	}
+	};
 }
 
-export type SingleStoreDateStringBuilderInitial<TName extends string> = SingleStoreDateStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreDateString';
+export class SingleStoreDateStringBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'string date';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDateString'>>
-	extends SingleStoreColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreDateStringBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'SingleStoreDateString');
+	constructor(name: string) {
+		super(name, 'string date', 'SingleStoreDateString');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDateString<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDateString<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDateString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDateString<T extends ColumnBaseConfig<'string', 'SingleStoreDateString'>>
-	extends SingleStoreColumn<T>
-{
+export class SingleStoreDateString<T extends ColumnBaseConfig<'string date'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreDateString';
 
 	constructor(
 		table: AnySingleStoreTable<{ name: T['tableName'] }>,
-		config: SingleStoreDateStringBuilder<T>['config'],
+		config: SingleStoreDateStringBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -105,15 +82,14 @@ export interface SingleStoreDateConfig<TMode extends 'date' | 'string' = 'date'
 	mode?: TMode;
 }
 
-export function date(): SingleStoreDateBuilderInitial<''>;
 export function date<TMode extends SingleStoreDateConfig['mode'] & {}>(
 	config?: SingleStoreDateConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreDateStringBuilderInitial<''> : SingleStoreDateBuilderInitial<''>;
-export function date<TName extends string, TMode extends SingleStoreDateConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? SingleStoreDateStringBuilder : SingleStoreDateBuilder;
+export function date<TMode extends SingleStoreDateConfig['mode'] & {}>(
+	name: string,
 	config?: SingleStoreDateConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreDateStringBuilderInitial<TName>
-	: SingleStoreDateBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? SingleStoreDateStringBuilder
+	: SingleStoreDateBuilder;
 export function date(a?: string | SingleStoreDateConfig, b?: SingleStoreDateConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreDateConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/singlestore-core/columns/datetime.ts b/drizzle-orm/src/singlestore-core/columns/datetime.ts
index 16f137901e..6b485011ce 100644
--- a/drizzle-orm/src/singlestore-core/columns/datetime.ts
+++ b/drizzle-orm/src/singlestore-core/columns/datetime.ts
@@ -1,63 +1,46 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	GeneratedColumnConfig,
-	HasGenerated,
-	MakeColumnConfig,
-} from '~/column-builder.ts';
+import type { GeneratedColumnConfig, HasGenerated } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { AnySingleStoreTable, SingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SQL } from '~/sql/sql.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
-import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder, type SingleStoreGeneratedColumnConfig } from './common.ts';
 
-export type SingleStoreDateTimeBuilderInitial<TName extends string> = SingleStoreDateTimeBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'SingleStoreDateTime';
+export class SingleStoreDateTimeBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDateTimeBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreDateTime'>>
-	extends SingleStoreColumnBuilder<T, SingleStoreDatetimeConfig>
-{
-	/** @internal */
+}, SingleStoreDatetimeConfig> {
 	// TODO: we need to add a proper support for SingleStore
 	override generatedAlwaysAs(
-		_as: SQL<unknown> | (() => SQL) | T['data'],
-		_config?: Partial<GeneratedColumnConfig<unknown>>,
-	): HasGenerated<this, {}> {
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		as: SQL | (() => SQL) | this['_']['data'],
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		config?: SingleStoreGeneratedColumnConfig,
+	): HasGenerated<this, { type: 'always' }> {
 		throw new Error('Method not implemented.');
 	}
 	static override readonly [entityKind]: string = 'SingleStoreDateTimeBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'date', 'SingleStoreDateTime');
+	constructor(name: string) {
+		super(name, 'object date', 'SingleStoreDateTime');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDateTime<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDateTime<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDateTime(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDateTime<T extends ColumnBaseConfig<'date', 'SingleStoreDateTime'>>
-	extends SingleStoreColumn<T>
-{
+export class SingleStoreDateTime<T extends ColumnBaseConfig<'object date'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreDateTime';
 
 	constructor(
 		table: AnySingleStoreTable<{ name: T['tableName'] }>,
-		config: SingleStoreDateTimeBuilder<T>['config'],
+		config: SingleStoreDateTimeBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -66,61 +49,49 @@ export class SingleStoreDateTime<T extends ColumnBaseConfig<'date', 'SingleStore
 		return `datetime`;
 	}
 
-	override mapToDriverValue(value: Date): unknown {
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
 		return value.toISOString().replace('T', ' ').replace('Z', '');
-	}
+	};
 
-	override mapFromDriverValue(value: string): Date {
+	override mapFromDriverValue = (value: string): Date => {
 		return new Date(value.replace(' ', 'T') + 'Z');
-	}
+	};
 }
 
-export type SingleStoreDateTimeStringBuilderInitial<TName extends string> = SingleStoreDateTimeStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreDateTimeString';
+export class SingleStoreDateTimeStringBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'string datetime';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDateTimeStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDateTimeString'>>
-	extends SingleStoreColumnBuilder<T, SingleStoreDatetimeConfig>
-{
-	/** @internal */
+}, SingleStoreDatetimeConfig> {
 	// TODO: we need to add a proper support for SingleStore
 	override generatedAlwaysAs(
-		_as: SQL<unknown> | (() => SQL) | T['data'],
+		_as: SQL | (() => SQL) | this['_']['data'],
 		_config?: Partial<GeneratedColumnConfig<unknown>>,
-	): HasGenerated<this, {}> {
+	): HasGenerated<this, { type: 'always' }> {
 		throw new Error('Method not implemented.');
 	}
 	static override readonly [entityKind]: string = 'SingleStoreDateTimeStringBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'SingleStoreDateTimeString');
+	constructor(name: string) {
+		super(name, 'string datetime', 'SingleStoreDateTimeString');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDateTimeString<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDateTimeString<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDateTimeString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDateTimeString<T extends ColumnBaseConfig<'string', 'SingleStoreDateTimeString'>>
-	extends SingleStoreColumn<T>
-{
+export class SingleStoreDateTimeString<T extends ColumnBaseConfig<'string datetime'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreDateTimeString';
 
 	constructor(
 		table: AnySingleStoreTable<{ name: T['tableName'] }>,
-		config: SingleStoreDateTimeStringBuilder<T>['config'],
+		config: SingleStoreDateTimeStringBuilder['config'],
 	) {
 		super(table, config);
 	}
@@ -128,22 +99,26 @@ export class SingleStoreDateTimeString<T extends ColumnBaseConfig<'string', 'Sin
 	getSQLType(): string {
 		return `datetime`;
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString().replace('T', ' ').replace('Z', '');
+	};
 }
 
 export interface SingleStoreDatetimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
 	mode?: TMode;
 }
 
-export function datetime(): SingleStoreDateTimeBuilderInitial<''>;
 export function datetime<TMode extends SingleStoreDatetimeConfig['mode'] & {}>(
 	config?: SingleStoreDatetimeConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreDateTimeStringBuilderInitial<''>
-	: SingleStoreDateTimeBuilderInitial<''>;
-export function datetime<TName extends string, TMode extends SingleStoreDatetimeConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? SingleStoreDateTimeStringBuilder
+	: SingleStoreDateTimeBuilder;
+export function datetime<TMode extends SingleStoreDatetimeConfig['mode'] & {}>(
+	name: string,
 	config?: SingleStoreDatetimeConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreDateTimeStringBuilderInitial<TName>
-	: SingleStoreDateTimeBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? SingleStoreDateTimeStringBuilder
+	: SingleStoreDateTimeBuilder;
 export function datetime(a?: string | SingleStoreDatetimeConfig, b?: SingleStoreDatetimeConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreDatetimeConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/singlestore-core/columns/decimal.ts b/drizzle-orm/src/singlestore-core/columns/decimal.ts
index 0baf9e85b2..7be7e85009 100644
--- a/drizzle-orm/src/singlestore-core/columns/decimal.ts
+++ b/drizzle-orm/src/singlestore-core/columns/decimal.ts
@@ -1,44 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreDecimalBuilderInitial<TName extends string> = SingleStoreDecimalBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreDecimal';
-	data: string;
-	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDecimalBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDecimal'>,
-> extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDecimalConfig> {
+export class SingleStoreDecimalBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'string unumeric' : 'string numeric';
+		data: string;
+		driverParam: string;
+	}, SingleStoreDecimalConfig>
+{
 	static override readonly [entityKind]: string = 'SingleStoreDecimalBuilder';
 
-	constructor(name: T['name'], config: SingleStoreDecimalConfig | undefined) {
-		super(name, 'string', 'SingleStoreDecimal');
+	constructor(name: string, config: SingleStoreDecimalConfig | undefined) {
+		super(name, config?.unsigned ? 'string unumeric' : 'string numeric' as any, 'SingleStoreDecimal');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDecimal<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDecimal<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDecimal(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDecimal<T extends ColumnBaseConfig<'string', 'SingleStoreDecimal'>>
+export class SingleStoreDecimal<T extends ColumnBaseConfig<'string numeric' | 'string unumeric'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDecimal';
@@ -47,12 +38,12 @@ export class SingleStoreDecimal<T extends ColumnBaseConfig<'string', 'SingleStor
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
 
-	override mapFromDriverValue(value: unknown): string {
+	override mapFromDriverValue = (value: unknown): string => {
 		// For RQBv2
 		if (typeof value === 'string') return value;
 
 		return String(value);
-	}
+	};
 
 	getSQLType(): string {
 		let type = '';
@@ -68,40 +59,32 @@ export class SingleStoreDecimal<T extends ColumnBaseConfig<'string', 'SingleStor
 	}
 }
 
-export type SingleStoreDecimalNumberBuilderInitial<TName extends string> = SingleStoreDecimalNumberBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreDecimalNumber';
-	data: number;
-	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDecimalNumberBuilder<
-	T extends ColumnBuilderBaseConfig<'number', 'SingleStoreDecimalNumber'>,
-> extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDecimalConfig> {
+export class SingleStoreDecimalNumberBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number unsigned' : 'number';
+		data: number;
+		driverParam: string;
+	}, SingleStoreDecimalConfig>
+{
 	static override readonly [entityKind]: string = 'SingleStoreDecimalNumberBuilder';
 
-	constructor(name: T['name'], config: SingleStoreDecimalConfig | undefined) {
-		super(name, 'number', 'SingleStoreDecimalNumber');
+	constructor(name: string, config: SingleStoreDecimalConfig | undefined) {
+		super(name, config?.unsigned ? 'number unsigned' : 'number' as any, 'SingleStoreDecimalNumber');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDecimalNumber<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDecimalNumber<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDecimalNumber(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDecimalNumber<T extends ColumnBaseConfig<'number', 'SingleStoreDecimalNumber'>>
+export class SingleStoreDecimalNumber<T extends ColumnBaseConfig<'number' | 'number unsigned'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDecimalNumber';
@@ -110,11 +93,11 @@ export class SingleStoreDecimalNumber<T extends ColumnBaseConfig<'number', 'Sing
 	readonly scale: number | undefined = this.config.scale;
 	readonly unsigned: boolean | undefined = this.config.unsigned;
 
-	override mapFromDriverValue(value: unknown): number {
+	override mapFromDriverValue = (value: unknown): number => {
 		if (typeof value === 'number') return value;
 
 		return Number(value);
-	}
+	};
 
 	override mapToDriverValue = String;
 
@@ -132,40 +115,32 @@ export class SingleStoreDecimalNumber<T extends ColumnBaseConfig<'number', 'Sing
 	}
 }
 
-export type SingleStoreDecimalBigIntBuilderInitial<TName extends string> = SingleStoreDecimalBigIntBuilder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'SingleStoreDecimalBigInt';
-	data: bigint;
-	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDecimalBigIntBuilder<
-	T extends ColumnBuilderBaseConfig<'bigint', 'SingleStoreDecimalBigInt'>,
-> extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDecimalConfig> {
+export class SingleStoreDecimalBigIntBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'bigint uint64' : 'bigint int64';
+		data: bigint;
+		driverParam: string;
+	}, SingleStoreDecimalConfig>
+{
 	static override readonly [entityKind]: string = 'SingleStoreDecimalBigIntBuilder';
 
-	constructor(name: T['name'], config: SingleStoreDecimalConfig | undefined) {
-		super(name, 'bigint', 'SingleStoreDecimalBigInt');
+	constructor(name: string, config: SingleStoreDecimalConfig | undefined) {
+		super(name, config?.unsigned ? 'bigint uint64' : 'bigint int64' as any, 'SingleStoreDecimalBigInt');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDecimalBigInt<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDecimalBigInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDecimalBigInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDecimalBigInt<T extends ColumnBaseConfig<'bigint', 'SingleStoreDecimalBigInt'>>
+export class SingleStoreDecimalBigInt<T extends ColumnBaseConfig<'bigint int64' | 'bigint uint64'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDecimalConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDecimalBigInt';
@@ -192,25 +167,27 @@ export class SingleStoreDecimalBigInt<T extends ColumnBaseConfig<'bigint', 'Sing
 	}
 }
 
-export interface SingleStoreDecimalConfig<T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint'> {
+export interface SingleStoreDecimalConfig<
+	T extends 'string' | 'number' | 'bigint' = 'string' | 'number' | 'bigint',
+	TUnsigned extends boolean | undefined = boolean | undefined,
+> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 	mode?: T;
 }
 
-export function decimal(): SingleStoreDecimalBuilderInitial<''>;
-export function decimal<TMode extends 'string' | 'number' | 'bigint'>(
-	config: SingleStoreDecimalConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? SingleStoreDecimalNumberBuilderInitial<''>
-	: Equal<TMode, 'bigint'> extends true ? SingleStoreDecimalBigIntBuilderInitial<''>
-	: SingleStoreDecimalBuilderInitial<''>;
-export function decimal<TName extends string, TMode extends 'string' | 'number' | 'bigint'>(
-	name: TName,
-	config?: SingleStoreDecimalConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? SingleStoreDecimalNumberBuilderInitial<TName>
-	: Equal<TMode, 'bigint'> extends true ? SingleStoreDecimalBigIntBuilderInitial<TName>
-	: SingleStoreDecimalBuilderInitial<TName>;
+export function decimal<TMode extends 'string' | 'number' | 'bigint', TUnsigned extends boolean | undefined>(
+	config?: SingleStoreDecimalConfig<TMode, TUnsigned>,
+): Equal<TMode, 'number'> extends true ? SingleStoreDecimalNumberBuilder<TUnsigned>
+	: Equal<TMode, 'bigint'> extends true ? SingleStoreDecimalBigIntBuilder<TUnsigned>
+	: SingleStoreDecimalBuilder<TUnsigned>;
+export function decimal<TMode extends 'string' | 'number' | 'bigint', TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreDecimalConfig<TMode, TUnsigned>,
+): Equal<TMode, 'number'> extends true ? SingleStoreDecimalNumberBuilder<TUnsigned>
+	: Equal<TMode, 'bigint'> extends true ? SingleStoreDecimalBigIntBuilder<TUnsigned>
+	: SingleStoreDecimalBuilder<TUnsigned>;
 export function decimal(a?: string | SingleStoreDecimalConfig, b: SingleStoreDecimalConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreDecimalConfig>(a, b);
 	const mode = config?.mode;
diff --git a/drizzle-orm/src/singlestore-core/columns/double.ts b/drizzle-orm/src/singlestore-core/columns/double.ts
index 103731eabc..e0975d0233 100644
--- a/drizzle-orm/src/singlestore-core/columns/double.ts
+++ b/drizzle-orm/src/singlestore-core/columns/double.ts
@@ -1,44 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreDoubleBuilderInitial<TName extends string> = SingleStoreDoubleBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreDouble';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreDoubleBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreDouble'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDoubleConfig>
+export class SingleStoreDoubleBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number udouble' : 'number double';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreDoubleConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDoubleBuilder';
 
-	constructor(name: T['name'], config: SingleStoreDoubleConfig | undefined) {
-		super(name, 'number', 'SingleStoreDouble');
+	constructor(name: string, config: SingleStoreDoubleConfig | undefined) {
+		super(name, config?.unsigned ? 'number udouble' : 'number double' as any, 'SingleStoreDouble');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreDouble<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreDouble<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreDouble(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreDouble<T extends ColumnBaseConfig<'number', 'SingleStoreDouble'>>
+export class SingleStoreDouble<T extends ColumnBaseConfig<'number double' | 'number udouble'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDoubleConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDouble';
@@ -60,20 +51,19 @@ export class SingleStoreDouble<T extends ColumnBaseConfig<'number', 'SingleStore
 	}
 }
 
-export interface SingleStoreDoubleConfig {
+export interface SingleStoreDoubleConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function double(): SingleStoreDoubleBuilderInitial<''>;
-export function double(
-	config?: SingleStoreDoubleConfig,
-): SingleStoreDoubleBuilderInitial<''>;
-export function double<TName extends string>(
-	name: TName,
-	config?: SingleStoreDoubleConfig,
-): SingleStoreDoubleBuilderInitial<TName>;
+export function double<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreDoubleConfig<TUnsigned>,
+): SingleStoreDoubleBuilder<TUnsigned>;
+export function double<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreDoubleConfig<TUnsigned>,
+): SingleStoreDoubleBuilder<TUnsigned>;
 export function double(a?: string | SingleStoreDoubleConfig, b?: SingleStoreDoubleConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreDoubleConfig>(a, b);
 	return new SingleStoreDoubleBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/enum.ts b/drizzle-orm/src/singlestore-core/columns/enum.ts
index 98f3d78e3c..d567ce931b 100644
--- a/drizzle-orm/src/singlestore-core/columns/enum.ts
+++ b/drizzle-orm/src/singlestore-core/columns/enum.ts
@@ -1,57 +1,42 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	GeneratedColumnConfig,
-	HasGenerated,
-	MakeColumnConfig,
-} from '~/column-builder.ts';
+import type { HasGenerated } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { SQL } from '~/sql/index.ts';
 import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
-import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder, type SingleStoreGeneratedColumnConfig } from './common.ts';
 
-export type SingleStoreEnumColumnBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
-	SingleStoreEnumColumnBuilder<{
-		name: TName;
-		dataType: 'string';
-		columnType: 'SingleStoreEnumColumn';
-		data: TEnum[number];
-		driverParam: string;
-		enumValues: TEnum;
-		generated: undefined;
-	}>;
-
-export class SingleStoreEnumColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreEnumColumn'>>
-	extends SingleStoreColumnBuilder<T, { enumValues: T['enumValues'] }>
-{
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class SingleStoreEnumColumnBuilder<TEnum extends [string, ...string[]]> extends SingleStoreColumnBuilder<{
+	dataType: 'string enum';
+	data: TEnum[number];
+	driverParam: string;
+	enumValues: TEnum;
+}, { enumValues: TEnum }> {
 	override generatedAlwaysAs(
-		as: SQL<unknown> | (() => SQL) | T['data'],
-		config?: Partial<GeneratedColumnConfig<unknown>>,
-	): HasGenerated<this, {}> {
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		as: SQL<unknown> | (() => SQL) | TEnum[number],
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		config?: SingleStoreGeneratedColumnConfig,
+	): HasGenerated<this, { type: 'always' }> {
 		throw new Error('Method not implemented.');
 	}
 	static override readonly [entityKind]: string = 'SingleStoreEnumColumnBuilder';
 
-	constructor(name: T['name'], values: T['enumValues']) {
-		super(name, 'string', 'SingleStoreEnumColumn');
+	constructor(name: string, values: TEnum) {
+		super(name, 'string enum', 'SingleStoreEnumColumn');
 		this.config.enumValues = values;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new SingleStoreEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreEnumColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreEnumColumn<T extends ColumnBaseConfig<'string', 'SingleStoreEnumColumn'>>
+export class SingleStoreEnumColumn<T extends ColumnBaseConfig<'string enum'>>
 	extends SingleStoreColumn<T, { enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreEnumColumn';
@@ -65,11 +50,11 @@ export class SingleStoreEnumColumn<T extends ColumnBaseConfig<'string', 'SingleS
 
 export function singlestoreEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
 	values: T | Writable<T>,
-): SingleStoreEnumColumnBuilderInitial<'', Writable<T>>;
-export function singlestoreEnum<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): SingleStoreEnumColumnBuilder<Writable<T>>;
+export function singlestoreEnum<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	values: T | Writable<T>,
-): SingleStoreEnumColumnBuilderInitial<TName, Writable<T>>;
+): SingleStoreEnumColumnBuilder<Writable<T>>;
 export function singlestoreEnum(
 	a?: string | readonly [string, ...string[]] | [string, ...string[]],
 	b?: readonly [string, ...string[]] | [string, ...string[]],
diff --git a/drizzle-orm/src/singlestore-core/columns/float.ts b/drizzle-orm/src/singlestore-core/columns/float.ts
index 9cfed61312..d9ba6c5976 100644
--- a/drizzle-orm/src/singlestore-core/columns/float.ts
+++ b/drizzle-orm/src/singlestore-core/columns/float.ts
@@ -1,44 +1,35 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreFloatBuilderInitial<TName extends string> = SingleStoreFloatBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreFloat';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreFloatBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreFloat'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreFloatConfig>
+export class SingleStoreFloatBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number ufloat' : 'number float';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreFloatConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreFloatBuilder';
 
-	constructor(name: T['name'], config: SingleStoreFloatConfig | undefined) {
-		super(name, 'number', 'SingleStoreFloat');
+	constructor(name: string, config: SingleStoreFloatConfig | undefined) {
+		super(name, config?.unsigned ? 'number ufloat' : 'number float' as any, 'SingleStoreFloat');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 		this.config.unsigned = config?.unsigned;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreFloat<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreFloat<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreFloat(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreFloat<T extends ColumnBaseConfig<'number', 'SingleStoreFloat'>>
+export class SingleStoreFloat<T extends ColumnBaseConfig<'number float' | 'number ufloat'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreFloatConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreFloat';
@@ -58,22 +49,27 @@ export class SingleStoreFloat<T extends ColumnBaseConfig<'number', 'SingleStoreF
 		}
 		return this.unsigned ? `${type} unsigned` : type;
 	}
+
+	override mapFromDriverValue = (value: unknown): number => {
+		if (typeof value !== 'number') return Number(value);
+
+		return value;
+	};
 }
 
-export interface SingleStoreFloatConfig {
+export interface SingleStoreFloatConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
 	precision?: number;
 	scale?: number;
-	unsigned?: boolean;
+	unsigned?: TUnsigned;
 }
 
-export function float(): SingleStoreFloatBuilderInitial<''>;
-export function float(
-	config?: SingleStoreFloatConfig,
-): SingleStoreFloatBuilderInitial<''>;
-export function float<TName extends string>(
-	name: TName,
-	config?: SingleStoreFloatConfig,
-): SingleStoreFloatBuilderInitial<TName>;
+export function float<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreFloatConfig<TUnsigned>,
+): SingleStoreFloatBuilder<TUnsigned>;
+export function float<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreFloatConfig<TUnsigned>,
+): SingleStoreFloatBuilder<TUnsigned>;
 export function float(a?: string | SingleStoreFloatConfig, b?: SingleStoreFloatConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreFloatConfig>(a, b);
 	return new SingleStoreFloatBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/int.ts b/drizzle-orm/src/singlestore-core/columns/int.ts
index b6a661f666..ff81d174c4 100644
--- a/drizzle-orm/src/singlestore-core/columns/int.ts
+++ b/drizzle-orm/src/singlestore-core/columns/int.ts
@@ -1,42 +1,33 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreIntBuilderInitial<TName extends string> = SingleStoreIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreInt';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreInt'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
+export class SingleStoreIntBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number uint32' : 'number int32';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreIntBuilder';
 
-	constructor(name: T['name'], config?: SingleStoreIntConfig) {
-		super(name, 'number', 'SingleStoreInt');
+	constructor(name: string, config?: SingleStoreIntConfig) {
+		super(name, config?.unsigned ? 'number uint32' : 'number int32' as any, 'SingleStoreInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreInt<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreInt<T extends ColumnBaseConfig<'number', 'SingleStoreInt'>>
+export class SingleStoreInt<T extends ColumnBaseConfig<'number int32' | 'number uint32'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreInt';
@@ -45,26 +36,25 @@ export class SingleStoreInt<T extends ColumnBaseConfig<'number', 'SingleStoreInt
 		return `int${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'string') {
 			return Number(value);
 		}
 		return value;
-	}
+	};
 }
 
-export interface SingleStoreIntConfig {
-	unsigned?: boolean;
+export interface SingleStoreIntConfig<TUnsigned extends boolean | undefined = boolean | undefined> {
+	unsigned?: TUnsigned;
 }
 
-export function int(): SingleStoreIntBuilderInitial<''>;
-export function int(
-	config?: SingleStoreIntConfig,
-): SingleStoreIntBuilderInitial<''>;
-export function int<TName extends string>(
-	name: TName,
-	config?: SingleStoreIntConfig,
-): SingleStoreIntBuilderInitial<TName>;
+export function int<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreIntBuilder<TUnsigned>;
+export function int<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreIntBuilder<TUnsigned>;
 export function int(a?: string | SingleStoreIntConfig, b?: SingleStoreIntConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreIntConfig>(a, b);
 	return new SingleStoreIntBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/json.ts b/drizzle-orm/src/singlestore-core/columns/json.ts
index 97ff759d10..60b3644d24 100644
--- a/drizzle-orm/src/singlestore-core/columns/json.ts
+++ b/drizzle-orm/src/singlestore-core/columns/json.ts
@@ -1,53 +1,40 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreJsonBuilderInitial<TName extends string> = SingleStoreJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'SingleStoreJson';
+export class SingleStoreJsonBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'object json';
 	data: unknown;
 	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SingleStoreJson'>>
-	extends SingleStoreColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreJsonBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'SingleStoreJson');
+	constructor(name: string) {
+		super(name, 'object json', 'SingleStoreJson');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreJson<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreJson<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreJson(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreJson<T extends ColumnBaseConfig<'json', 'SingleStoreJson'>> extends SingleStoreColumn<T> {
+export class SingleStoreJson<T extends ColumnBaseConfig<'object json'>> extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreJson';
 
 	getSQLType(): string {
 		return 'json';
 	}
 
-	override mapToDriverValue(value: T['data']): string {
+	override mapToDriverValue = (value: T['data']): string => {
 		return JSON.stringify(value);
-	}
+	};
 }
 
-export function json(): SingleStoreJsonBuilderInitial<''>;
-export function json<TName extends string>(name: TName): SingleStoreJsonBuilderInitial<TName>;
-export function json(name?: string) {
+export function json(name?: string): SingleStoreJsonBuilder {
 	return new SingleStoreJsonBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/mediumint.ts b/drizzle-orm/src/singlestore-core/columns/mediumint.ts
index 4a5fa80f94..069dc5bd61 100644
--- a/drizzle-orm/src/singlestore-core/columns/mediumint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/mediumint.ts
@@ -1,43 +1,34 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 import type { SingleStoreIntConfig } from './int.ts';
 
-export type SingleStoreMediumIntBuilderInitial<TName extends string> = SingleStoreMediumIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreMediumInt';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreMediumInt'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
+export class SingleStoreMediumIntBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number uint24' : 'number int24';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreMediumIntBuilder';
 
-	constructor(name: T['name'], config?: SingleStoreIntConfig) {
-		super(name, 'number', 'SingleStoreMediumInt');
+	constructor(name: string, config?: SingleStoreIntConfig) {
+		super(name, config?.unsigned ? 'number uint24' : 'number int24' as any, 'SingleStoreMediumInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreMediumInt<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreMediumInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreMediumInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreMediumInt<T extends ColumnBaseConfig<'number', 'SingleStoreMediumInt'>>
+export class SingleStoreMediumInt<T extends ColumnBaseConfig<'number int24' | 'number uint24'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreMediumInt';
@@ -46,22 +37,21 @@ export class SingleStoreMediumInt<T extends ColumnBaseConfig<'number', 'SingleSt
 		return `mediumint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'string') {
 			return Number(value);
 		}
 		return value;
-	}
+	};
 }
 
-export function mediumint(): SingleStoreMediumIntBuilderInitial<''>;
-export function mediumint(
-	config?: SingleStoreIntConfig,
-): SingleStoreMediumIntBuilderInitial<''>;
-export function mediumint<TName extends string>(
-	name: TName,
-	config?: SingleStoreIntConfig,
-): SingleStoreMediumIntBuilderInitial<TName>;
+export function mediumint<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreMediumIntBuilder<TUnsigned>;
+export function mediumint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreMediumIntBuilder<TUnsigned>;
 export function mediumint(a?: string | SingleStoreIntConfig, b?: SingleStoreIntConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreIntConfig>(a, b);
 	return new SingleStoreMediumIntBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/real.ts b/drizzle-orm/src/singlestore-core/columns/real.ts
index 53d15345c0..6f1aa963f6 100644
--- a/drizzle-orm/src/singlestore-core/columns/real.ts
+++ b/drizzle-orm/src/singlestore-core/columns/real.ts
@@ -1,51 +1,38 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreRealBuilderInitial<TName extends string> = SingleStoreRealBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreReal';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreReal'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<
-		T,
-		SingleStoreRealConfig
-	>
-{
+export class SingleStoreRealBuilder extends SingleStoreColumnBuilderWithAutoIncrement<
+	{
+		dataType: 'number double';
+		data: number;
+		driverParam: number | string;
+	},
+	SingleStoreRealConfig
+> {
 	static override readonly [entityKind]: string = 'SingleStoreRealBuilder';
 
-	constructor(name: T['name'], config: SingleStoreRealConfig | undefined) {
-		super(name, 'number', 'SingleStoreReal');
+	constructor(name: string, config: SingleStoreRealConfig | undefined) {
+		super(name, 'number double', 'SingleStoreReal');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreReal<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreReal<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreReal(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreReal<T extends ColumnBaseConfig<'number', 'SingleStoreReal'>>
-	extends SingleStoreColumnWithAutoIncrement<
-		T,
-		SingleStoreRealConfig
-	>
-{
+export class SingleStoreReal<T extends ColumnBaseConfig<'number double'>> extends SingleStoreColumnWithAutoIncrement<
+	T,
+	SingleStoreRealConfig
+> {
 	static override readonly [entityKind]: string = 'SingleStoreReal';
 
 	precision: number | undefined = this.config.precision;
@@ -67,14 +54,13 @@ export interface SingleStoreRealConfig {
 	scale?: number;
 }
 
-export function real(): SingleStoreRealBuilderInitial<''>;
 export function real(
 	config?: SingleStoreRealConfig,
-): SingleStoreRealBuilderInitial<''>;
-export function real<TName extends string>(
-	name: TName,
+): SingleStoreRealBuilder;
+export function real(
+	name: string,
 	config?: SingleStoreRealConfig,
-): SingleStoreRealBuilderInitial<TName>;
+): SingleStoreRealBuilder;
 export function real(a?: string | SingleStoreRealConfig, b: SingleStoreRealConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreRealConfig>(a, b);
 	return new SingleStoreRealBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/serial.ts b/drizzle-orm/src/singlestore-core/columns/serial.ts
index df415d47e6..b9408bf1de 100644
--- a/drizzle-orm/src/singlestore-core/columns/serial.ts
+++ b/drizzle-orm/src/singlestore-core/columns/serial.ts
@@ -1,59 +1,37 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	HasDefault,
-	IsAutoincrement,
-	IsPrimaryKey,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type SingleStoreSerialBuilderInitial<TName extends string> = IsAutoincrement<
-	IsPrimaryKey<
-		NotNull<
-			HasDefault<
-				SingleStoreSerialBuilder<{
-					name: TName;
-					dataType: 'number';
-					columnType: 'SingleStoreSerial';
-					data: number;
-					driverParam: number;
-					enumValues: undefined;
-					generated: undefined;
-				}>
-			>
-		>
-	>
->;
+export class SingleStoreSerialBuilder extends SingleStoreColumnBuilderWithAutoIncrement<{
+	dataType: 'number uint53';
+	data: number;
+	driverParam: number;
 
-export class SingleStoreSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreSerial'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T>
-{
+	isPrimaryKey: true;
+	hasDefault: true;
+	notNull: true;
+	isAutoincrement: true;
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreSerialBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'SingleStoreSerial');
+	constructor(name: string) {
+		super(name, 'number uint53', 'SingleStoreSerial');
 		this.config.hasDefault = true;
 		this.config.autoIncrement = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreSerial<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreSerial<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreSerial(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class SingleStoreSerial<
-	T extends ColumnBaseConfig<'number', 'SingleStoreSerial'>,
+	T extends ColumnBaseConfig<'number uint53'>,
 > extends SingleStoreColumnWithAutoIncrement<T> {
 	static override readonly [entityKind]: string = 'SingleStoreSerial';
 
@@ -61,16 +39,14 @@ export class SingleStoreSerial<
 		return 'serial';
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'string') {
 			return Number(value);
 		}
 		return value;
-	}
+	};
 }
 
-export function serial(): SingleStoreSerialBuilderInitial<''>;
-export function serial<TName extends string>(name: TName): SingleStoreSerialBuilderInitial<TName>;
-export function serial(name?: string) {
+export function serial(name?: string): SingleStoreSerialBuilder {
 	return new SingleStoreSerialBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/smallint.ts b/drizzle-orm/src/singlestore-core/columns/smallint.ts
index 3f504b68c1..08a3a03b45 100644
--- a/drizzle-orm/src/singlestore-core/columns/smallint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/smallint.ts
@@ -1,43 +1,34 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 import type { SingleStoreIntConfig } from './int.ts';
 
-export type SingleStoreSmallIntBuilderInitial<TName extends string> = SingleStoreSmallIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreSmallInt';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreSmallInt'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
+export class SingleStoreSmallIntBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number uint16' : 'number int16';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreSmallIntBuilder';
 
-	constructor(name: T['name'], config?: SingleStoreIntConfig) {
-		super(name, 'number', 'SingleStoreSmallInt');
+	constructor(name: string, config?: SingleStoreIntConfig) {
+		super(name, config?.unsigned ? 'number uint16' : 'number int16' as any, 'SingleStoreSmallInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreSmallInt<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreSmallInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreSmallInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreSmallInt<T extends ColumnBaseConfig<'number', 'SingleStoreSmallInt'>>
+export class SingleStoreSmallInt<T extends ColumnBaseConfig<'number int16' | 'number uint16'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreSmallInt';
@@ -46,22 +37,21 @@ export class SingleStoreSmallInt<T extends ColumnBaseConfig<'number', 'SingleSto
 		return `smallint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'string') {
 			return Number(value);
 		}
 		return value;
-	}
+	};
 }
 
-export function smallint(): SingleStoreSmallIntBuilderInitial<''>;
-export function smallint(
-	config?: SingleStoreIntConfig,
-): SingleStoreSmallIntBuilderInitial<''>;
-export function smallint<TName extends string>(
-	name: TName,
-	config?: SingleStoreIntConfig,
-): SingleStoreSmallIntBuilderInitial<TName>;
+export function smallint<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreSmallIntBuilder<TUnsigned>;
+export function smallint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreSmallIntBuilder<TUnsigned>;
 export function smallint(a?: string | SingleStoreIntConfig, b?: SingleStoreIntConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreIntConfig>(a, b);
 	return new SingleStoreSmallIntBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/text.ts b/drizzle-orm/src/singlestore-core/columns/text.ts
index d4d46ab2cc..f274e76276 100644
--- a/drizzle-orm/src/singlestore-core/columns/text.ts
+++ b/drizzle-orm/src/singlestore-core/columns/text.ts
@@ -1,49 +1,56 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
 export type SingleStoreTextColumnType = 'tinytext' | 'text' | 'mediumtext' | 'longtext';
 
-export type SingleStoreTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
-	SingleStoreTextBuilder<{
-		name: TName;
-		dataType: 'string';
-		columnType: 'SingleStoreText';
+export class SingleStoreTextBuilder<TEnum extends [string, ...string[]]> extends SingleStoreColumnBuilder<
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
 		data: TEnum[number];
 		driverParam: string;
 		enumValues: TEnum;
-		generated: undefined;
-	}>;
-
-export class SingleStoreTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreText'>>
-	extends SingleStoreColumnBuilder<
-		T,
-		{ textType: SingleStoreTextColumnType; enumValues: T['enumValues'] }
-	>
-{
+	},
+	{ textType: SingleStoreTextColumnType; enumValues?: TEnum; length: number | undefined }
+> {
 	static override readonly [entityKind]: string = 'SingleStoreTextBuilder';
 
-	constructor(name: T['name'], textType: SingleStoreTextColumnType, config: SingleStoreTextConfig<T['enumValues']>) {
-		super(name, 'string', 'SingleStoreText');
+	constructor(name: string, textType: SingleStoreTextColumnType, config: SingleStoreTextConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'SingleStoreText');
 		this.config.textType = textType;
 		this.config.enumValues = config.enum;
+		switch (textType) {
+			case 'tinytext': {
+				this.config.length = 255;
+				break;
+			}
+			case 'text': {
+				this.config.length = 65535;
+				break;
+			}
+			case 'mediumtext': {
+				this.config.length = 16777215;
+				break;
+			}
+			case 'longtext': {
+				this.config.length = 4294967295;
+				break;
+			}
+		}
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreText<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreText<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreText(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreText<T extends ColumnBaseConfig<'string', 'SingleStoreText'>>
+export class SingleStoreText<T extends ColumnBaseConfig<'string' | 'string enum'>>
 	extends SingleStoreColumn<T, { textType: SingleStoreTextColumnType; enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreText';
@@ -63,53 +70,49 @@ export interface SingleStoreTextConfig<
 	enum?: TEnum;
 }
 
-export function text(): SingleStoreTextBuilderInitial<'', [string, ...string[]]>;
 export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<'', Writable<T>>;
-export function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): SingleStoreTextBuilder<Writable<T>>;
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<TName, Writable<T>>;
+): SingleStoreTextBuilder<Writable<T>>;
 export function text(a?: string | SingleStoreTextConfig, b: SingleStoreTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreTextConfig>(a, b);
 	return new SingleStoreTextBuilder(name, 'text', config as any);
 }
 
-export function tinytext(): SingleStoreTextBuilderInitial<'', [string, ...string[]]>;
 export function tinytext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<'', Writable<T>>;
-export function tinytext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): SingleStoreTextBuilder<Writable<T>>;
+export function tinytext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<TName, Writable<T>>;
+): SingleStoreTextBuilder<Writable<T>>;
 export function tinytext(a?: string | SingleStoreTextConfig, b: SingleStoreTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreTextConfig>(a, b);
 	return new SingleStoreTextBuilder(name, 'tinytext', config as any);
 }
 
-export function mediumtext(): SingleStoreTextBuilderInitial<'', [string, ...string[]]>;
 export function mediumtext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<'', Writable<T>>;
-export function mediumtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): SingleStoreTextBuilder<Writable<T>>;
+export function mediumtext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<TName, Writable<T>>;
+): SingleStoreTextBuilder<Writable<T>>;
 export function mediumtext(a?: string | SingleStoreTextConfig, b: SingleStoreTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreTextConfig>(a, b);
 	return new SingleStoreTextBuilder(name, 'mediumtext', config as any);
 }
 
-export function longtext(): SingleStoreTextBuilderInitial<'', [string, ...string[]]>;
 export function longtext<U extends string, T extends Readonly<[U, ...U[]]>>(
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<'', Writable<T>>;
-export function longtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
-	name: TName,
+): SingleStoreTextBuilder<Writable<T>>;
+export function longtext<U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: string,
 	config?: SingleStoreTextConfig<T | Writable<T>>,
-): SingleStoreTextBuilderInitial<TName, Writable<T>>;
+): SingleStoreTextBuilder<Writable<T>>;
 export function longtext(a?: string | SingleStoreTextConfig, b: SingleStoreTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreTextConfig>(a, b);
 	return new SingleStoreTextBuilder(name, 'longtext', config as any);
diff --git a/drizzle-orm/src/singlestore-core/columns/time.ts b/drizzle-orm/src/singlestore-core/columns/time.ts
index b7605a4ee6..9b4e81ca5b 100644
--- a/drizzle-orm/src/singlestore-core/columns/time.ts
+++ b/drizzle-orm/src/singlestore-core/columns/time.ts
@@ -1,45 +1,34 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreTimeBuilderInitial<TName extends string> = SingleStoreTimeBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreTime';
-	data: string;
-	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreTime'>>
-	extends SingleStoreColumnBuilder<
-		T
-	>
-{
+export class SingleStoreTimeBuilder extends SingleStoreColumnBuilder<
+	{
+		dataType: 'string time';
+		data: string;
+		driverParam: string | number;
+	}
+> {
 	static override readonly [entityKind]: string = 'SingleStoreTimeBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 	) {
-		super(name, 'string', 'SingleStoreTime');
+		super(name, 'string time', 'SingleStoreTime');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreTime<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreTime<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreTime(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class SingleStoreTime<
-	T extends ColumnBaseConfig<'string', 'SingleStoreTime'>,
+	T extends ColumnBaseConfig<'string time'>,
 > extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreTime';
 
@@ -48,8 +37,6 @@ export class SingleStoreTime<
 	}
 }
 
-export function time(): SingleStoreTimeBuilderInitial<''>;
-export function time<TName extends string>(name: TName): SingleStoreTimeBuilderInitial<TName>;
-export function time(name?: string) {
+export function time(name?: string): SingleStoreTimeBuilder {
 	return new SingleStoreTimeBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/timestamp.ts b/drizzle-orm/src/singlestore-core/columns/timestamp.ts
index ea7342fd72..52a3249adb 100644
--- a/drizzle-orm/src/singlestore-core/columns/timestamp.ts
+++ b/drizzle-orm/src/singlestore-core/columns/timestamp.ts
@@ -1,37 +1,26 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { sql } from '~/sql/sql.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreDateBaseColumn, SingleStoreDateColumnBaseBuilder } from './date.common.ts';
 
-export type SingleStoreTimestampBuilderInitial<TName extends string> = SingleStoreTimestampBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'SingleStoreTimestamp';
+export class SingleStoreTimestampBuilder extends SingleStoreDateColumnBaseBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreTimestamp'>>
-	extends SingleStoreDateColumnBaseBuilder<T, SingleStoreTimestampConfig>
-{
+}, SingleStoreTimestampConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreTimestampBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'date', 'SingleStoreTimestamp');
+	constructor(name: string) {
+		super(name, 'object date', 'SingleStoreTimestamp');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreTimestamp<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreTimestamp(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 
@@ -40,7 +29,7 @@ export class SingleStoreTimestampBuilder<T extends ColumnBuilderBaseConfig<'date
 	}
 }
 
-export class SingleStoreTimestamp<T extends ColumnBaseConfig<'date', 'SingleStoreTimestamp'>>
+export class SingleStoreTimestamp<T extends ColumnBaseConfig<'object date'>>
 	extends SingleStoreDateBaseColumn<T, SingleStoreTimestampConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreTimestamp';
@@ -49,41 +38,32 @@ export class SingleStoreTimestamp<T extends ColumnBaseConfig<'date', 'SingleStor
 		return `timestamp`;
 	}
 
-	override mapFromDriverValue(value: string): Date {
+	override mapFromDriverValue = (value: string): Date => {
 		return new Date(value + '+0000');
-	}
+	};
 
-	override mapToDriverValue(value: Date): string {
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
 		return value.toISOString().slice(0, -1).replace('T', ' ');
-	}
+	};
 }
 
-export type SingleStoreTimestampStringBuilderInitial<TName extends string> = SingleStoreTimestampStringBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreTimestampString';
+export class SingleStoreTimestampStringBuilder extends SingleStoreDateColumnBaseBuilder<{
+	dataType: 'string timestamp';
 	data: string;
 	driverParam: string | number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreTimestampStringBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreTimestampString'>,
-> extends SingleStoreDateColumnBaseBuilder<T, SingleStoreTimestampConfig> {
+}, SingleStoreTimestampConfig> {
 	static override readonly [entityKind]: string = 'SingleStoreTimestampStringBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'SingleStoreTimestampString');
+	constructor(name: string) {
+		super(name, 'string timestamp', 'SingleStoreTimestampString');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreTimestampString<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreTimestampString<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreTimestampString(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 
@@ -92,7 +72,7 @@ export class SingleStoreTimestampStringBuilder<
 	}
 }
 
-export class SingleStoreTimestampString<T extends ColumnBaseConfig<'string', 'SingleStoreTimestampString'>>
+export class SingleStoreTimestampString<T extends ColumnBaseConfig<'string timestamp'>>
 	extends SingleStoreDateBaseColumn<T, SingleStoreTimestampConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreTimestampString';
@@ -100,22 +80,26 @@ export class SingleStoreTimestampString<T extends ColumnBaseConfig<'string', 'Si
 	getSQLType(): string {
 		return `timestamp`;
 	}
+
+	override mapToDriverValue = (value: Date | string): string => {
+		if (typeof value === 'string') return value;
+		return value.toISOString().slice(0, -1).replace('T', ' ');
+	};
 }
 
 export interface SingleStoreTimestampConfig<TMode extends 'string' | 'date' = 'string' | 'date'> {
 	mode?: TMode;
 }
 
-export function timestamp(): SingleStoreTimestampBuilderInitial<''>;
 export function timestamp<TMode extends SingleStoreTimestampConfig['mode'] & {}>(
 	config?: SingleStoreTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreTimestampStringBuilderInitial<''>
-	: SingleStoreTimestampBuilderInitial<''>;
-export function timestamp<TName extends string, TMode extends SingleStoreTimestampConfig['mode'] & {}>(
-	name: TName,
+): Equal<TMode, 'string'> extends true ? SingleStoreTimestampStringBuilder
+	: SingleStoreTimestampBuilder;
+export function timestamp<TMode extends SingleStoreTimestampConfig['mode'] & {}>(
+	name: string,
 	config?: SingleStoreTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? SingleStoreTimestampStringBuilderInitial<TName>
-	: SingleStoreTimestampBuilderInitial<TName>;
+): Equal<TMode, 'string'> extends true ? SingleStoreTimestampStringBuilder
+	: SingleStoreTimestampBuilder;
 export function timestamp(a?: string | SingleStoreTimestampConfig, b: SingleStoreTimestampConfig = {}) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreTimestampConfig | undefined>(a, b);
 	if (config?.mode === 'string') {
diff --git a/drizzle-orm/src/singlestore-core/columns/tinyint.ts b/drizzle-orm/src/singlestore-core/columns/tinyint.ts
index 090619a6da..f58cad75f2 100644
--- a/drizzle-orm/src/singlestore-core/columns/tinyint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/tinyint.ts
@@ -1,43 +1,34 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 import type { SingleStoreIntConfig } from './int.ts';
 
-export type SingleStoreTinyIntBuilderInitial<TName extends string> = SingleStoreTinyIntBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreTinyInt';
-	data: number;
-	driverParam: number | string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreTinyInt'>>
-	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
+export class SingleStoreTinyIntBuilder<TUnsigned extends boolean | undefined>
+	extends SingleStoreColumnBuilderWithAutoIncrement<{
+		dataType: Equal<TUnsigned, true> extends true ? 'number uint8' : 'number int8';
+		data: number;
+		driverParam: number | string;
+	}, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreTinyIntBuilder';
 
-	constructor(name: T['name'], config?: SingleStoreIntConfig) {
-		super(name, 'number', 'SingleStoreTinyInt');
+	constructor(name: string, config?: SingleStoreIntConfig) {
+		super(name, config?.unsigned ? 'number uint8' : 'number int8' as any, 'SingleStoreTinyInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreTinyInt<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreTinyInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreTinyInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SingleStoreTinyInt<T extends ColumnBaseConfig<'number', 'SingleStoreTinyInt'>>
+export class SingleStoreTinyInt<T extends ColumnBaseConfig<'number int8' | 'number uint8'>>
 	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
 	static override readonly [entityKind]: string = 'SingleStoreTinyInt';
@@ -46,22 +37,21 @@ export class SingleStoreTinyInt<T extends ColumnBaseConfig<'number', 'SingleStor
 		return `tinyint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
-	override mapFromDriverValue(value: number | string): number {
+	override mapFromDriverValue = (value: number | string): number => {
 		if (typeof value === 'string') {
 			return Number(value);
 		}
 		return value;
-	}
+	};
 }
 
-export function tinyint(): SingleStoreTinyIntBuilderInitial<''>;
-export function tinyint(
-	config?: SingleStoreIntConfig,
-): SingleStoreTinyIntBuilderInitial<''>;
-export function tinyint<TName extends string>(
-	name: TName,
-	config?: SingleStoreIntConfig,
-): SingleStoreTinyIntBuilderInitial<TName>;
+export function tinyint<TUnsigned extends boolean | undefined>(
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreTinyIntBuilder<TUnsigned>;
+export function tinyint<TUnsigned extends boolean | undefined>(
+	name: string,
+	config?: SingleStoreIntConfig<TUnsigned>,
+): SingleStoreTinyIntBuilder<TUnsigned>;
 export function tinyint(a?: string | SingleStoreIntConfig, b?: SingleStoreIntConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreIntConfig>(a, b);
 	return new SingleStoreTinyIntBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/varbinary.ts b/drizzle-orm/src/singlestore-core/columns/varbinary.ts
index 221a32012d..7e85d2b41c 100644
--- a/drizzle-orm/src/singlestore-core/columns/varbinary.ts
+++ b/drizzle-orm/src/singlestore-core/columns/varbinary.ts
@@ -1,50 +1,37 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { getColumnNameAndConfig } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreVarBinaryBuilderInitial<TName extends string> = SingleStoreVarBinaryBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SingleStoreVarBinary';
+export class SingleStoreVarBinaryBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'string binary';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreVarBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreVarBinary'>>
-	extends SingleStoreColumnBuilder<T, SingleStoreVarbinaryOptions>
-{
+}, SingleStoreVarbinaryOptions> {
 	static override readonly [entityKind]: string = 'SingleStoreVarBinaryBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: SingleStoreVarbinaryOptions) {
-		super(name, 'string', 'SingleStoreVarBinary');
-		this.config.length = config?.length;
+	constructor(name: string, config: SingleStoreVarbinaryOptions) {
+		super(name, 'string binary', 'SingleStoreVarBinary');
+		this.config.length = config.length;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreVarBinary<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreVarBinary<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreVarBinary(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class SingleStoreVarBinary<
-	T extends ColumnBaseConfig<'string', 'SingleStoreVarBinary'>,
+	T extends ColumnBaseConfig<'string binary'>,
 > extends SingleStoreColumn<T, SingleStoreVarbinaryOptions> {
 	static override readonly [entityKind]: string = 'SingleStoreVarBinary';
 
-	length: number | undefined = this.config.length;
-
-	override mapFromDriverValue(value: string | Buffer | Uint8Array): string {
+	override mapFromDriverValue = (value: string | Buffer | Uint8Array): string => {
 		if (typeof value === 'string') return value;
 		if (Buffer.isBuffer(value)) return value.toString();
 
@@ -54,7 +41,7 @@ export class SingleStoreVarBinary<
 		}
 
 		return str.join('');
-	}
+	};
 
 	getSQLType(): string {
 		return this.length === undefined ? `varbinary` : `varbinary(${this.length})`;
@@ -67,11 +54,11 @@ export interface SingleStoreVarbinaryOptions {
 
 export function varbinary(
 	config: SingleStoreVarbinaryOptions,
-): SingleStoreVarBinaryBuilderInitial<''>;
-export function varbinary<TName extends string>(
-	name: TName,
+): SingleStoreVarBinaryBuilder;
+export function varbinary(
+	name: string,
 	config: SingleStoreVarbinaryOptions,
-): SingleStoreVarBinaryBuilderInitial<TName>;
+): SingleStoreVarBinaryBuilder;
 export function varbinary(a?: string | SingleStoreVarbinaryOptions, b?: SingleStoreVarbinaryOptions) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreVarbinaryOptions>(a, b);
 	return new SingleStoreVarBinaryBuilder(name, config);
diff --git a/drizzle-orm/src/singlestore-core/columns/varchar.ts b/drizzle-orm/src/singlestore-core/columns/varchar.ts
index 279569329d..7c07266b02 100644
--- a/drizzle-orm/src/singlestore-core/columns/varchar.ts
+++ b/drizzle-orm/src/singlestore-core/columns/varchar.ts
@@ -1,58 +1,40 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreVarCharBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = SingleStoreVarCharBuilder<
-	{
-		name: TName;
-		dataType: 'string';
-		columnType: 'SingleStoreVarChar';
-		data: TEnum[number];
-		driverParam: number | string;
-		enumValues: TEnum;
-		generated: undefined;
-		length: TLength;
-	}
->;
-
 export class SingleStoreVarCharBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreVarChar'> & { length?: number | undefined },
-> extends SingleStoreColumnBuilder<T, SingleStoreVarCharConfig<T['enumValues'], T['length']>, { length: T['length'] }> {
+	TEnum extends [string, ...string[]],
+> extends SingleStoreColumnBuilder<{
+	dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+	data: TEnum[number];
+	driverParam: number | string;
+	enumValues: TEnum;
+}, SingleStoreVarCharConfig<TEnum>> {
 	static override readonly [entityKind]: string = 'SingleStoreVarCharBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: SingleStoreVarCharConfig<T['enumValues'], T['length']>) {
-		super(name, 'string', 'SingleStoreVarChar');
+	constructor(name: string, config: SingleStoreVarCharConfig<TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'SingleStoreVarChar');
 		this.config.length = config.length;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreVarChar<MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }> {
-		return new SingleStoreVarChar<
-			MakeColumnConfig<T, TTableName> & { length: T['length']; enumValues: T['enumValues'] }
-		>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreVarChar(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class SingleStoreVarChar<
-	T extends ColumnBaseConfig<'string', 'SingleStoreVarChar'> & { length?: number | undefined },
-> extends SingleStoreColumn<T, SingleStoreVarCharConfig<T['enumValues'], T['length']>, { length: T['length'] }> {
+	T extends ColumnBaseConfig<'string' | 'string enum'> & { length: number },
+> extends SingleStoreColumn<T, SingleStoreVarCharConfig<T['enumValues']>> {
 	static override readonly [entityKind]: string = 'SingleStoreVarChar';
 
-	readonly length: T['length'] = this.config.length;
 	override readonly enumValues = this.config.enum;
 
 	getSQLType(): string {
@@ -62,24 +44,21 @@ export class SingleStoreVarChar<
 
 export interface SingleStoreVarCharConfig<
 	TEnum extends string[] | readonly string[] | undefined = string[] | readonly string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > {
 	enum?: TEnum;
-	length: TLength;
+	length: number;
 }
 
-export function varchar<U extends string, T extends Readonly<[U, ...U[]]>, L extends number | undefined>(
-	config: SingleStoreVarCharConfig<T | Writable<T>, L>,
-): SingleStoreVarCharBuilderInitial<'', Writable<T>, L>;
+export function varchar<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config: SingleStoreVarCharConfig<T | Writable<T>>,
+): SingleStoreVarCharBuilder<Writable<T>>;
 export function varchar<
-	TName extends string,
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 >(
-	name: TName,
-	config: SingleStoreVarCharConfig<T | Writable<T>, L>,
-): SingleStoreVarCharBuilderInitial<TName, Writable<T>, L>;
+	name: string,
+	config: SingleStoreVarCharConfig<T | Writable<T>>,
+): SingleStoreVarCharBuilder<Writable<T>>;
 export function varchar(a?: string | SingleStoreVarCharConfig, b?: SingleStoreVarCharConfig): any {
 	const { name, config } = getColumnNameAndConfig<SingleStoreVarCharConfig>(a, b);
 	return new SingleStoreVarCharBuilder(name, config as any);
diff --git a/drizzle-orm/src/singlestore-core/columns/vector.ts b/drizzle-orm/src/singlestore-core/columns/vector.ts
index d33b819b9c..9d845500ab 100644
--- a/drizzle-orm/src/singlestore-core/columns/vector.ts
+++ b/drizzle-orm/src/singlestore-core/columns/vector.ts
@@ -1,83 +1,180 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { HasGenerated } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
-import { SQL } from '~/sql/index.ts';
-import { getColumnNameAndConfig } from '~/utils.ts';
-import { SingleStoreColumn, SingleStoreColumnBuilder, SingleStoreGeneratedColumnConfig } from './common.ts';
-
-export type SingleStoreVectorBuilderInitial<TName extends string> = SingleStoreVectorBuilder<{
-	name: TName;
-	dataType: 'array';
-	columnType: 'SingleStoreVector';
-	data: Array<number>;
-	driverParam: string;
-	enumValues: undefined;
-}>;
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SQL } from '~/sql/sql.ts';
+import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder, type SingleStoreGeneratedColumnConfig } from './common.ts';
 
-export class SingleStoreVectorBuilder<T extends ColumnBuilderBaseConfig<'array', 'SingleStoreVector'>>
-	extends SingleStoreColumnBuilder<T, SingleStoreVectorConfig>
-{
+export class SingleStoreVectorBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'array vector';
+	data: Array<number>;
+	driverParam: string | Buffer;
+	isLengthExact: true;
+}, { length: number; isLengthExact: true; elementType?: Exclude<ElementType, 'I64'> }> {
 	static override readonly [entityKind]: string = 'SingleStoreVectorBuilder';
 
-	constructor(name: T['name'], config: SingleStoreVectorConfig) {
-		super(name, 'array', 'SingleStoreVector');
-		this.config.dimensions = config.dimensions;
-		this.config.elementType = config.elementType;
+	constructor(name: string, config: SingleStoreVectorConfig) {
+		super(name, 'array vector', 'SingleStoreVector');
+		this.config.length = config.dimensions;
+		this.config.elementType = config.elementType as Exclude<ElementType, 'I64'> | undefined;
+		this.config.isLengthExact = true;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreVector<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreVector<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreVector(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 
 	/** @internal */
-	override generatedAlwaysAs(as: SQL<unknown> | (() => SQL) | T['data'], config?: SingleStoreGeneratedColumnConfig) {
-		throw new Error('not implemented');
+	override generatedAlwaysAs(
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		as: SQL | (() => SQL) | this['_']['data'],
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		config?: Partial<SingleStoreGeneratedColumnConfig>,
+	): HasGenerated<this, { type: 'always' }> {
+		throw new Error('Method not implemented.');
 	}
 }
 
-export class SingleStoreVector<T extends ColumnBaseConfig<'array', 'SingleStoreVector'>>
-	extends SingleStoreColumn<T, SingleStoreVectorConfig>
+export class SingleStoreVector<T extends ColumnBaseConfig<'array vector'>>
+	extends SingleStoreColumn<T, { length: number; elementType?: Exclude<ElementType, 'I64'> }>
 {
 	static override readonly [entityKind]: string = 'SingleStoreVector';
 
-	dimensions: number = this.config.dimensions;
-	elementType: ElementType | undefined = this.config.elementType;
+	readonly elementType: Exclude<ElementType, 'I64'> | undefined = this.config.elementType;
 
 	getSQLType(): string {
-		return `vector(${this.dimensions}, ${this.elementType || 'F32'})`;
+		return `vector(${this.config.length}, ${this.elementType || 'F32'})`;
+	}
+
+	override mapToDriverValue = (value: Array<number>): string => {
+		return `[${value.map((e) => e.toString()).join(',')}]`;
+	};
+
+	override mapFromDriverValue = (value: string | Buffer | Array<number>): Array<number> => {
+		if (typeof value === 'string') {
+			if (value.startsWith('[')) return value.slice(1, -1).split(',').map(Number);
+
+			value = Buffer.from(value, 'hex');
+		}
+
+		if (Buffer.isBuffer(value)) {
+			const type = this.elementType || 'F32';
+			const bytearr = new Uint8Array(value);
+			switch (type) {
+				case 'I8': {
+					// eslint-disable-next-line unicorn/prefer-spread
+					return Array.from(new Int8Array(bytearr.buffer, 0, bytearr.length / 1));
+				}
+				case 'I16': {
+					// eslint-disable-next-line unicorn/prefer-spread
+					return Array.from(new Int16Array(bytearr.buffer, 0, bytearr.length / 2));
+				}
+				case 'I32': {
+					// eslint-disable-next-line unicorn/prefer-spread
+					return Array.from(new Int32Array(bytearr.buffer, 0, bytearr.length / 4));
+				}
+				case 'F32': {
+					// eslint-disable-next-line unicorn/prefer-spread
+					return Array.from(new Float32Array(bytearr.buffer, 0, bytearr.length / 4));
+				}
+				case 'F64': {
+					// eslint-disable-next-line unicorn/prefer-spread
+					return Array.from(new Float64Array(bytearr.buffer, 0, bytearr.length / 8));
+				}
+			}
+		}
+
+		return value;
+	};
+}
+
+export class SingleStoreBigIntVectorBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'array int64vector';
+	data: Array<bigint>;
+	driverParam: string | Buffer;
+	isLengthExact: true;
+}, { length: number; isLengthExact: true }> {
+	static override readonly [entityKind]: string = 'SingleStoreBigIntVectorBuilder';
+
+	constructor(name: string, config: SingleStoreVectorConfig) {
+		super(name, 'array int64vector', 'SingleStoreBigIntVector');
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
+	}
+
+	/** @internal */
+	override build(table: SingleStoreTable) {
+		return new SingleStoreBigIntVector(
+			table,
+			this.config as any,
+		);
 	}
 
-	override mapToDriverValue(value: Array<number>) {
-		return JSON.stringify(value);
+	/** @internal */
+	override generatedAlwaysAs(
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		as: SQL | (() => SQL) | this['_']['data'],
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		config?: Partial<SingleStoreGeneratedColumnConfig>,
+	): HasGenerated<this, { type: 'always' }> {
+		throw new Error('Method not implemented.');
 	}
+}
+
+export class SingleStoreBigIntVector<T extends ColumnBaseConfig<'array int64vector'>>
+	extends SingleStoreColumn<T, { length: number }>
+{
+	static override readonly [entityKind]: string = 'SingleStoreBigIntVector';
 
-	override mapFromDriverValue(value: string): Array<number> {
-		return JSON.parse(value);
+	readonly elementType = 'I64';
+
+	getSQLType(): string {
+		return `vector(${this.config.length}, ${this.elementType})`;
 	}
+
+	override mapToDriverValue = (value: Array<bigint>): string => {
+		return `[${value.map((e) => e.toString()).join(',')}]`;
+	};
+
+	override mapFromDriverValue = (value: string | Buffer | Array<bigint>): Array<bigint> => {
+		if (typeof value === 'string') {
+			if (value.startsWith('[')) return value.slice(1, -1).split(',').map(BigInt);
+
+			value = Buffer.from(value, 'hex');
+		}
+
+		if (Buffer.isBuffer(value)) {
+			const bytearr = new Uint8Array(value);
+			// eslint-disable-next-line unicorn/prefer-spread
+			return Array.from(new BigInt64Array(bytearr.buffer, 0, bytearr.length / 8));
+		}
+
+		return value;
+	};
 }
 
 type ElementType = 'I8' | 'I16' | 'I32' | 'I64' | 'F32' | 'F64';
 
-export interface SingleStoreVectorConfig {
+export interface SingleStoreVectorConfig<TType extends ElementType | undefined = ElementType | undefined> {
 	dimensions: number;
-	elementType?: ElementType;
+	elementType?: TType;
 }
 
-export function vector(
-	config: SingleStoreVectorConfig,
-): SingleStoreVectorBuilderInitial<''>;
-export function vector<TName extends string>(
-	name: TName,
-	config: SingleStoreVectorConfig,
-): SingleStoreVectorBuilderInitial<TName>;
+export function vector<TType extends ElementType | undefined>(
+	config: SingleStoreVectorConfig<TType>,
+): Equal<TType, 'I64'> extends true ? SingleStoreBigIntVectorBuilder : SingleStoreVectorBuilder;
+export function vector<TType extends ElementType | undefined>(
+	name: string,
+	config: SingleStoreVectorConfig<TType>,
+): Equal<TType, 'I64'> extends true ? SingleStoreBigIntVectorBuilder : SingleStoreVectorBuilder;
 export function vector(a: string | SingleStoreVectorConfig, b?: SingleStoreVectorConfig) {
 	const { name, config } = getColumnNameAndConfig<SingleStoreVectorConfig>(a, b);
-	return new SingleStoreVectorBuilder(name, config);
+	return config.elementType === 'I64'
+		? new SingleStoreBigIntVectorBuilder(name, config)
+		: new SingleStoreVectorBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/year.ts b/drizzle-orm/src/singlestore-core/columns/year.ts
index 37f3d55a30..a4a92ca9a4 100644
--- a/drizzle-orm/src/singlestore-core/columns/year.ts
+++ b/drizzle-orm/src/singlestore-core/columns/year.ts
@@ -1,51 +1,44 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type SingleStoreYearBuilderInitial<TName extends string> = SingleStoreYearBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SingleStoreYear';
+export class SingleStoreYearBuilder extends SingleStoreColumnBuilder<{
+	dataType: 'number year';
 	data: number;
 	driverParam: number;
-	enumValues: undefined;
-	generated: undefined;
-}>;
-
-export class SingleStoreYearBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreYear'>>
-	extends SingleStoreColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SingleStoreYearBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'SingleStoreYear');
+	constructor(name: string) {
+		super(name, 'number year', 'SingleStoreYear');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySingleStoreTable<{ name: TTableName }>,
-	): SingleStoreYear<MakeColumnConfig<T, TTableName>> {
-		return new SingleStoreYear<MakeColumnConfig<T, TTableName>>(
+	override build(table: SingleStoreTable) {
+		return new SingleStoreYear(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
 export class SingleStoreYear<
-	T extends ColumnBaseConfig<'number', 'SingleStoreYear'>,
+	T extends ColumnBaseConfig<'number year'>,
 > extends SingleStoreColumn<T> {
 	static override readonly [entityKind]: string = 'SingleStoreYear';
 
 	getSQLType(): string {
 		return `year`;
 	}
+
+	override mapFromDriverValue = (value: unknown): number => {
+		if (typeof value !== 'number') return Number(value);
+
+		return value;
+	};
 }
 
-export function year(): SingleStoreYearBuilderInitial<''>;
-export function year<TName extends string>(name: TName): SingleStoreYearBuilderInitial<TName>;
-export function year(name?: string) {
+export function year(name?: string): SingleStoreYearBuilder {
 	return new SingleStoreYearBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/singlestore-core/db.ts b/drizzle-orm/src/singlestore-core/db.ts
index 02eb866586..f20bf4ab27 100644
--- a/drizzle-orm/src/singlestore-core/db.ts
+++ b/drizzle-orm/src/singlestore-core/db.ts
@@ -1,8 +1,9 @@
 import type { ResultSetHeader } from 'mysql2/promise';
+import type * as V1 from '~/_relations.ts';
 import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { SingleStoreDriverDatabase } from '~/singlestore/driver.ts';
 import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
@@ -16,6 +17,7 @@ import {
 	SingleStoreSelectBuilder,
 	SingleStoreUpdateBuilder,
 } from './query-builders/index.ts';
+import { RelationalQueryBuilder } from './query-builders/query.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type {
 	PreparedQueryHKTBase,
@@ -32,54 +34,67 @@ export class SingleStoreDatabase<
 	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = {},
-	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
+	TRelations extends AnyRelations = EmptyRelations,
+	TSchema extends V1.TablesRelationalConfig = V1.ExtractTablesWithRelations<TFullSchema>,
 > {
 	static readonly [entityKind]: string = 'SingleStoreDatabase';
 
 	declare readonly _: {
 		readonly schema: TSchema | undefined;
 		readonly fullSchema: TFullSchema;
+		readonly relations: TRelations;
 		readonly tableNamesMap: Record<string, string>;
 	};
 
-	// We are waiting for SingleStore support for `json_array` function
-	/**@inrernal */
-	query: unknown;
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TPreparedQueryHKT,
+			TRelations,
+			TRelations[K]
+		>;
+	};
 
 	constructor(
 		/** @internal */
 		readonly dialect: SingleStoreDialect,
 		/** @internal */
-		readonly session: SingleStoreSession<any, any, any, any>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
+		readonly session: SingleStoreSession<any, any, any, any, any>,
+		relations: TRelations,
+		schema: V1.RelationalSchemaConfig<TSchema> | undefined,
 	) {
 		this._ = schema
 			? {
 				schema: schema.schema,
 				fullSchema: schema.fullSchema as TFullSchema,
 				tableNamesMap: schema.tableNamesMap,
+				relations,
 			}
 			: {
 				schema: undefined,
 				fullSchema: {} as TFullSchema,
 				tableNamesMap: {},
+				relations,
 			};
 		this.query = {} as typeof this['query'];
-		// this.queryNotSupported = true;
-		// if (this._.schema) {
-		// 	for (const [tableName, columns] of Object.entries(this._.schema)) {
-		// 		(this.query as SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, Record<string, any>>['query'])[tableName] =
-		// 			new RelationalQueryBuilder(
-		// 				schema!.fullSchema,
-		// 				this._.schema,
-		// 				this._.tableNamesMap,
-		// 				schema!.fullSchema[tableName] as SingleStoreTable,
-		// 				columns,
-		// 				dialect,
-		// 				session,
-		// 			);
-		// 	}
-		// }
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as SingleStoreDatabase<
+				TQueryResult,
+				TPreparedQueryHKT,
+				TSchema,
+				AnyRelations,
+				V1.TablesRelationalConfig
+			>['query'])[
+				tableName
+			] = new RelationalQueryBuilder(
+				relations,
+				relations[relation.name]!.table as SingleStoreTable,
+				relation,
+				dialect,
+				session,
+			);
+		}
+
 		this.$cache = { invalidate: async (_params: any) => {} };
 	}
 
@@ -481,7 +496,7 @@ export class SingleStoreDatabase<
 
 	transaction<T>(
 		transaction: (
-			tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>,
+			tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>,
 			config?: SingleStoreTransactionConfig,
 		) => Promise<T>,
 		config?: SingleStoreTransactionConfig,
@@ -490,7 +505,7 @@ export class SingleStoreDatabase<
 	}
 }
 
-export type SingleStoreWithReplicas<Q> = Q & { $primary: Q };
+export type SingleStoreWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
 
 export const withReplicas = <
 	Q extends SingleStoreDriverDatabase,
@@ -518,6 +533,7 @@ export const withReplicas = <
 		execute,
 		transaction,
 		$primary: primary,
+		$replicas: replicas,
 		select,
 		selectDistinct,
 		$count,
diff --git a/drizzle-orm/src/singlestore-core/dialect.ts b/drizzle-orm/src/singlestore-core/dialect.ts
index 359809b0e9..a73537a197 100644
--- a/drizzle-orm/src/singlestore-core/dialect.ts
+++ b/drizzle-orm/src/singlestore-core/dialect.ts
@@ -1,29 +1,44 @@
-import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from '~/alias.ts';
-import { CasingCache } from '~/casing.ts';
+import * as V1 from '~/_relations.ts';
+import {
+	aliasedTable,
+	aliasedTableColumn,
+	getOriginalColumnFromAlias,
+	mapColumnsInAliasedSQLToAlias,
+	mapColumnsInSQLToAlias,
+} from '~/alias.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import { DrizzleError } from '~/errors.ts';
-import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type {
+	AnyOne,
+	BuildRelationalQueryResult,
+	ColumnWithTSName,
+	DBQueryConfig,
+	Relation,
+	TableRelationalConfig,
+	TablesRelationalConfig,
+	WithContainer,
+} from '~/relations.ts';
 import {
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	getOperators,
-	getOrderByOperators,
-	Many,
-	normalizeRelation,
+	getTableAsAliasSQL,
 	One,
-	type Relation,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
+	relationExtrasToSQL,
+	relationsFilterToSQL,
+	relationsOrderToSQL,
+	relationToSQL,
 } from '~/relations.ts';
 import { and, eq } from '~/sql/expressions/index.ts';
-import type { Name, Placeholder, QueryWithTypings, SQLChunk } from '~/sql/sql.ts';
-import { Param, SQL, sql, View } from '~/sql/sql.ts';
+import type { Name, Placeholder, Query, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { isSQLWrapper, Param, SQL, sql, View } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
-import { getTableName, getTableUniqueName, Table } from '~/table.ts';
-import { type Casing, orderSelectedFields, type UpdateSet } from '~/utils.ts';
+import { getTableName, getTableUniqueName, Table, TableColumns } from '~/table.ts';
+import { upgradeIfNeeded } from '~/up-migrations/singlestore.ts';
+import type { UpdateSet } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { SingleStoreColumn } from './columns/common.ts';
+import type { SingleStoreCustomColumn } from './columns/custom.ts';
 import type { SingleStoreDeleteConfig } from './query-builders/delete.ts';
 import type { SingleStoreInsertConfig } from './query-builders/insert.ts';
 import type {
@@ -34,64 +49,102 @@ import type {
 import type { SingleStoreUpdateConfig } from './query-builders/update.ts';
 import type { SingleStoreSession } from './session.ts';
 import { SingleStoreTable } from './table.ts';
-/* import { SingleStoreViewBase } from './view-base.ts'; */
+import type { SingleStoreView } from './view.ts';
 
-export interface SingleStoreDialectConfig {
-	casing?: Casing;
+// Will add codecs here, do not remove
+export interface SingleStoreDialectConfig {}
+
+interface BuildRelationalQueryResultWithOrder extends BuildRelationalQueryResult {
+	order?: SQL;
 }
 
 export class SingleStoreDialect {
 	static readonly [entityKind]: string = 'SingleStoreDialect';
 
-	/** @internal */
-	readonly casing: CasingCache;
-
-	constructor(config?: SingleStoreDialectConfig) {
-		this.casing = new CasingCache(config?.casing);
-	}
+	constructor(_config?: SingleStoreDialectConfig) {}
 
 	async migrate(
 		migrations: MigrationMeta[],
 		session: SingleStoreSession,
 		config: Omit<MigrationConfig, 'migrationsSchema'>,
-	): Promise<void> {
+	): Promise<void | MigratorInitFailResponse> {
 		const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
-		const migrationTableCreate = sql`
-			create table if not exists ${sql.identifier(migrationsTable)} (
-				id serial primary key,
-				hash text not null,
-				created_at bigint
+
+		// Detect DB version and upgrade table schema if needed
+		const { newDb } = await upgradeIfNeeded(
+			migrationsTable,
+			session,
+			migrations,
+		);
+
+		if (newDb) {
+			const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash TEXT NOT NULL,
+				created_at BIGINT,
+				name TEXT,
+				applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 			)
 		`;
-		await session.execute(migrationTableCreate);
+			await session.execute(migrationTableCreate);
+		}
 
-		const dbMigrations = await session.all<{ id: number; hash: string; created_at: string }>(
-			sql`select id, hash, created_at from ${sql.identifier(migrationsTable)} order by created_at desc limit 1`,
+		const dbMigrations = await session.all<{
+			id: number;
+			hash: string;
+			created_at: string;
+			name: string | null;
+		}>(
+			sql`select id, hash, created_at, name from ${sql.identifier(migrationsTable)}`,
 		);
 
-		const lastDbMigration = dbMigrations[0];
+		if (typeof config === 'object' && config.init) {
+			if (dbMigrations.length) {
+				return { exitCode: 'databaseMigrations' as const };
+			}
+
+			if (migrations.length > 1) {
+				return { exitCode: 'localMigrations' as const };
+			}
+
+			const [migration] = migrations;
+
+			if (!migration) return;
 
+			await session.execute(
+				sql`insert into ${
+					sql.identifier(
+						migrationsTable,
+					)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+			);
+
+			return;
+		}
+
+		const migrationsToRun = getMigrationsToRun({
+			localMigrations: migrations,
+			dbMigrations,
+		});
 		await session.transaction(async (tx) => {
-			for (const migration of migrations) {
-				if (
-					!lastDbMigration
-					|| Number(lastDbMigration.created_at) < migration.folderMillis
-				) {
-					for (const stmt of migration.sql) {
-						await tx.execute(sql.raw(stmt));
-					}
-					await tx.execute(
-						sql`insert into ${
-							sql.identifier(migrationsTable)
-						} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`,
-					);
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					await tx.execute(sql.raw(stmt));
 				}
+				await tx.execute(
+					sql`insert into ${
+						sql.identifier(
+							migrationsTable,
+						)
+					} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+				);
 			}
 		});
 	}
 
 	escapeName(name: string): string {
-		return `\`${name}\``;
+		return `\`${name.replace(/`/g, '``')}\``;
 	}
 
 	escapeParam(_num: number): string {
@@ -116,7 +169,14 @@ export class SingleStoreDialect {
 		return sql.join(withSqlChunks);
 	}
 
-	buildDeleteQuery({ table, where, returning, withList, limit, orderBy }: SingleStoreDeleteConfig): SQL {
+	buildDeleteQuery({
+		table,
+		where,
+		returning,
+		withList,
+		limit,
+		orderBy,
+	}: SingleStoreDeleteConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const returningSql = returning
@@ -135,25 +195,41 @@ export class SingleStoreDialect {
 	buildUpdateSet(table: SingleStoreTable, set: UpdateSet): SQL {
 		const tableColumns = table[Table.Symbol.Columns];
 
-		const columnNames = Object.keys(tableColumns).filter((colName) =>
-			set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
 		);
 
-		const setSize = columnNames.length;
-		return sql.join(columnNames.flatMap((colName, i) => {
-			const col = tableColumns[colName]!;
+		const setLength = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
 
-			const value = set[colName] ?? sql.param(col.onUpdateFn!(), col);
-			const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
 
-			if (i < setSize - 1) {
-				return [res, sql.raw(', ')];
-			}
-			return [res];
-		}));
+				if (i < setLength - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
 	}
 
-	buildUpdateQuery({ table, set, where, returning, withList, limit, orderBy }: SingleStoreUpdateConfig): SQL {
+	buildUpdateQuery({
+		table,
+		set,
+		where,
+		returning,
+		withList,
+		limit,
+		orderBy,
+	}: SingleStoreUpdateConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const setSql = this.buildUpdateSet(table, set);
@@ -188,80 +264,118 @@ export class SingleStoreDialect {
 	): SQL {
 		const columnsLen = fields.length;
 
-		const chunks = fields
-			.flatMap(({ field }, i) => {
-				const chunk: SQLChunk[] = [];
+		const chunks = fields.flatMap(({ field }, i) => {
+			const chunk: SQLChunk[] = [];
 
-				if (is(field, SQL.Aliased) && field.isSelectionField) {
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					if (!isSingleTable && field.origin !== undefined) {
+						chunk.push(sql.identifier(field.origin), sql.raw('.'));
+					}
 					chunk.push(sql.identifier(field.fieldAlias));
-				} else if (is(field, SQL.Aliased) || is(field, SQL)) {
-					const query = is(field, SQL.Aliased) ? field.sql : field;
+				} else {
+					const query = field.sql;
 
 					if (isSingleTable) {
-						chunk.push(
-							new SQL(
-								query.queryChunks.map((c) => {
-									if (is(c, SingleStoreColumn)) {
-										return sql.identifier(this.casing.getColumnCasing(c));
-									}
-									return c;
-								}),
-							),
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, Column)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
 						);
+
+						chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
 					} else {
 						chunk.push(query);
 					}
 
-					if (is(field, SQL.Aliased)) {
-						chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
-					}
-				} else if (is(field, Column)) {
-					if (isSingleTable) {
-						chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
-					} else {
-						chunk.push(field);
-					}
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
 				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, Column)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
 
-				if (i < columnsLen - 1) {
-					chunk.push(sql`, `);
+					chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+				} else {
+					chunk.push(query);
+				}
+			} else if (is(field, Column)) {
+				if (isSingleTable) {
+					chunk.push(
+						field.isAlias
+							? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}`
+							: sql.identifier(field.name),
+					);
+				} else {
+					chunk.push(
+						field.isAlias
+							? sql`${getOriginalColumnFromAlias(field)} as ${field}`
+							: field,
+					);
 				}
+			} else if (is(field, Subquery)) {
+				if (!field._.isWith) {
+					chunk.push(sql`(${field._.sql}) ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(field);
+				}
+			}
 
-				return chunk;
-			});
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
 
 		return sql.join(chunks);
 	}
 
 	private buildLimit(limit: number | Placeholder | undefined): SQL | undefined {
-		return typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
+		return typeof limit === 'object'
+				|| (typeof limit === 'number' && limit >= 0)
 			? sql` limit ${limit}`
 			: undefined;
 	}
 
-	private buildOrderBy(orderBy: (SingleStoreColumn | SQL | SQL.Aliased)[] | undefined): SQL | undefined {
-		return orderBy && orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : undefined;
+	private buildOrderBy(
+		orderBy: (SingleStoreColumn | SQL | SQL.Aliased)[] | undefined,
+	): SQL | undefined {
+		return orderBy && orderBy.length > 0
+			? sql` order by ${sql.join(orderBy, sql`, `)}`
+			: undefined;
 	}
 
-	buildSelectQuery(
-		{
-			withList,
-			fields,
-			fieldsFlat,
-			where,
-			having,
-			table,
-			joins,
-			orderBy,
-			groupBy,
-			limit,
-			offset,
-			lockingClause,
-			distinct,
-			setOperators,
-		}: SingleStoreSelectConfig,
-	): SQL {
-		const fieldsList = fieldsFlat ?? orderSelectedFields<SingleStoreColumn>(fields);
+	buildSelectQuery({
+		withList,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		limit,
+		offset,
+		lockingClause,
+		distinct,
+		setOperators,
+	}: SingleStoreSelectConfig): SQL {
+		if (!fieldsFlat) {
+			throw new Error('Select query builder must be provided with `fieldsFlat` on `buildSelectQuery` invocation');
+		}
+		const fieldsList = fieldsFlat;
 		for (const f of fieldsList) {
 			if (
 				is(f.field, Column)
@@ -274,14 +388,20 @@ export class SingleStoreDialect {
 						? undefined
 						: getTableName(table))
 				&& !((table) =>
-					joins?.some(({ alias }) =>
-						alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
 					))(f.field.table)
 			) {
 				const tableName = getTableName(f.field.table);
 				throw new Error(
 					`Your "${
-						f.path.join('->')
+						f.path.join(
+							'->',
+						)
 					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
 				);
 			}
@@ -298,10 +418,20 @@ export class SingleStoreDialect {
 		const tableSql = (() => {
 			if (is(table, Table) && table[Table.Symbol.IsAlias]) {
 				return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? '')}.`.if(table[Table.Symbol.Schema])}${
-					sql.identifier(table[Table.Symbol.OriginalName])
+					sql.identifier(
+						table[Table.Symbol.OriginalName],
+					)
 				} ${sql.identifier(table[Table.Symbol.Name])}`;
 			}
 
+			if (is(table, View) && table[ViewBaseConfig].isAlias) {
+				let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+				if (table[ViewBaseConfig].schema) {
+					fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+				}
+				return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+			}
+
 			return table;
 		})();
 
@@ -355,7 +485,9 @@ export class SingleStoreDialect {
 
 		const orderBySql = this.buildOrderBy(orderBy);
 
-		const groupBySql = groupBy && groupBy.length > 0 ? sql` group by ${sql.join(groupBy, sql`, `)}` : undefined;
+		const groupBySql = groupBy && groupBy.length > 0
+			? sql` group by ${sql.join(groupBy, sql`, `)}`
+			: undefined;
 
 		const limitSql = this.buildLimit(limit);
 
@@ -382,7 +514,10 @@ export class SingleStoreDialect {
 		return finalQuery;
 	}
 
-	buildSetOperations(leftSelect: SQL, setOperators: SingleStoreSelectConfig['setOperators']): SQL {
+	buildSetOperations(
+		leftSelect: SQL,
+		setOperators: SingleStoreSelectConfig['setOperators'],
+	): SQL {
 		const [setOperator, ...rest] = setOperators;
 
 		if (!setOperator) {
@@ -403,7 +538,10 @@ export class SingleStoreDialect {
 	buildSetOperationQuery({
 		leftSelect,
 		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: SingleStoreSelectConfig['setOperators'][number] }): SQL {
+	}: {
+		leftSelect: SQL;
+		setOperator: SingleStoreSelectConfig['setOperators'][number];
+	}): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${rightSelect.getSQL()})`;
 
@@ -415,13 +553,15 @@ export class SingleStoreDialect {
 			// which is invalid SingleStore syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const orderByUnit of orderBy) {
 				if (is(orderByUnit, SingleStoreColumn)) {
-					orderByValues.push(sql.identifier(this.casing.getColumnCasing(orderByUnit)));
+					orderByValues.push(
+						sql.identifier(orderByUnit.name),
+					);
 				} else if (is(orderByUnit, SQL)) {
 					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
 						const chunk = orderByUnit.queryChunks[i];
 
 						if (is(chunk, SingleStoreColumn)) {
-							orderByUnit.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));
+							orderByUnit.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
@@ -445,17 +585,23 @@ export class SingleStoreDialect {
 		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
-	buildInsertQuery(
-		{ table, values, ignore, onConflict }: SingleStoreInsertConfig,
-	): { sql: SQL; generatedIds: Record<string, unknown>[] } {
+	buildInsertQuery({
+		table,
+		values,
+		ignore,
+		onConflict,
+	}: SingleStoreInsertConfig): {
+		sql: SQL;
+		generatedIds: Record<string, unknown>[];
+	} {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
 		const columns: Record<string, SingleStoreColumn> = table[Table.Symbol.Columns];
-		const colEntries: [string, SingleStoreColumn][] = Object.entries(columns).filter(([_, col]) =>
-			!col.shouldDisableInsert()
-		);
+		const colEntries: [string, SingleStoreColumn][] = Object.entries(
+			columns,
+		).filter(([_, col]) => !col.shouldDisableInsert());
 
-		const insertOrder = colEntries.map(([, column]) => sql.identifier(this.casing.getColumnCasing(column)));
+		const insertOrder = colEntries.map(([, column]) => sql.identifier(column.name));
 		const generatedIdsResponse: Record<string, unknown>[] = [];
 
 		for (const [valueIndex, value] of values.entries()) {
@@ -464,17 +610,24 @@ export class SingleStoreDialect {
 			const valueList: (SQLChunk | SQL)[] = [];
 			for (const [fieldName, col] of colEntries) {
 				const colValue = value[fieldName];
-				if (colValue === undefined || (is(colValue, Param) && colValue.value === undefined)) {
+				if (
+					colValue === undefined
+					|| (is(colValue, Param) && colValue.value === undefined)
+				) {
 					// eslint-disable-next-line unicorn/no-negated-condition
 					if (col.defaultFn !== undefined) {
 						const defaultFnResult = col.defaultFn();
 						generatedIds[fieldName] = defaultFnResult;
-						const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
+						const defaultValue = is(defaultFnResult, SQL)
+							? defaultFnResult
+							: sql.param(defaultFnResult, col);
 						valueList.push(defaultValue);
 						// eslint-disable-next-line unicorn/no-negated-condition
 					} else if (!col.default && col.onUpdateFn !== undefined) {
 						const onUpdateFnResult = col.onUpdateFn();
-						const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
+						const newValue = is(onUpdateFnResult, SQL)
+							? onUpdateFnResult
+							: sql.param(onUpdateFnResult, col);
 						valueList.push(newValue);
 					} else {
 						valueList.push(sql`default`);
@@ -498,7 +651,9 @@ export class SingleStoreDialect {
 
 		const ignoreSql = ignore ? sql` ignore` : undefined;
 
-		const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : undefined;
+		const onConflictSql = onConflict
+			? sql` on duplicate key ${onConflict}`
+			: undefined;
 
 		return {
 			sql: sql`insert${ignoreSql} into ${table} ${insertOrder} values ${valuesSql}${onConflictSql}`,
@@ -506,9 +661,8 @@ export class SingleStoreDialect {
 		};
 	}
 
-	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): QueryWithTypings {
+	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): Query {
 		return sql.toQuery({
-			casing: this.casing,
 			escapeName: this.escapeName,
 			escapeParam: this.escapeParam,
 			escapeString: this.escapeString,
@@ -516,7 +670,7 @@ export class SingleStoreDialect {
 		});
 	}
 
-	buildRelationalQuery({
+	_buildRelationalQuery({
 		fullSchema,
 		schema,
 		tableNamesMap,
@@ -528,24 +682,25 @@ export class SingleStoreDialect {
 		joinOn,
 	}: {
 		fullSchema: Record<string, unknown>;
-		schema: TablesRelationalConfig;
+		schema: V1.TablesRelationalConfig;
 		tableNamesMap: Record<string, string>;
 		table: SingleStoreTable;
-		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
+		tableConfig: V1.TableRelationalConfig;
+		queryConfig: true | V1.DBQueryConfig<'many', true>;
 		tableAlias: string;
-		nestedQueryRelation?: Relation;
+		nestedQueryRelation?: V1.Relation;
 		joinOn?: SQL;
-	}): BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn> {
-		let selection: BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn>['selection'] = [];
+	}): V1.BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn> {
+		let selection: V1.BuildRelationalQueryResult<
+			SingleStoreTable,
+			SingleStoreColumn
+		>['selection'] = [];
 		let limit, offset, orderBy: SingleStoreSelectConfig['orderBy'], where;
 		const joins: SingleStoreSelectJoinConfig[] = [];
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
+			selection = selectionEntries.map(([key, value]) => ({
 				dbKey: value.name,
 				tsKey: key,
 				field: aliasedTableColumn(value as SingleStoreColumn, tableAlias),
@@ -555,17 +710,23 @@ export class SingleStoreDialect {
 			}));
 		} else {
 			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
+				Object.entries(tableConfig.columns).map(([key, value]) => [
+					key,
+					aliasedTableColumn(value, tableAlias),
+				]),
 			);
 
 			if (config.where) {
 				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
+					? config.where(aliasedColumns, V1.getOperators())
 					: config.where;
 				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
 			}
 
-			const fieldsSelection: { tsKey: string; value: SingleStoreColumn | SQL.Aliased }[] = [];
+			const fieldsSelection: {
+				tsKey: string;
+				value: SingleStoreColumn | SQL.Aliased;
+			}[] = [];
 			let selectedColumns: string[] = [];
 
 			// Figure out which columns to select
@@ -588,7 +749,9 @@ export class SingleStoreDialect {
 				if (selectedColumns.length > 0) {
 					selectedColumns = isIncludeMode
 						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+						: Object.keys(tableConfig.columns).filter(
+							(key) => !selectedColumns.includes(key),
+						);
 				}
 			} else {
 				// Select all columns if selection is not specified
@@ -602,15 +765,23 @@ export class SingleStoreDialect {
 
 			let selectedRelations: {
 				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
+				queryConfig: true | V1.DBQueryConfig<'many', false>;
+				relation: V1.Relation;
 			}[] = [];
 
-			// Figure out which relations to select
+			// Figure out which V1.relations to select
 			if (config.with) {
 				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
+					.filter(
+						(
+							entry,
+						): entry is [(typeof entry)[0], NonNullable<(typeof entry)[1]>] => !!entry[1],
+					)
+					.map(([tsKey, queryConfig]) => ({
+						tsKey,
+						queryConfig,
+						relation: tableConfig.relations[tsKey]!,
+					}));
 			}
 
 			let extras;
@@ -632,9 +803,13 @@ export class SingleStoreDialect {
 			// `fieldsSelection` shouldn't be used after this point
 			for (const { tsKey, value } of fieldsSelection) {
 				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
+					dbKey: is(value, SQL.Aliased)
+						? value.fieldAlias
+						: tableConfig.columns[tsKey]!.name,
 					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
+					field: is(value, Column)
+						? aliasedTableColumn(value, tableAlias)
+						: value,
 					relationTableTsKey: undefined,
 					isJson: false,
 					selection: [],
@@ -642,14 +817,17 @@ export class SingleStoreDialect {
 			}
 
 			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
+				? config.orderBy(aliasedColumns, V1.getOrderByOperators())
+				: (config.orderBy ?? []);
 			if (!Array.isArray(orderByOrig)) {
 				orderByOrig = [orderByOrig];
 			}
 			orderBy = orderByOrig.map((orderByValue) => {
 				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as SingleStoreColumn;
+					return aliasedTableColumn(
+						orderByValue,
+						tableAlias,
+					) as SingleStoreColumn;
 				}
 				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
 			});
@@ -657,7 +835,7 @@ export class SingleStoreDialect {
 			limit = config.limit;
 			offset = config.offset;
 
-			// Process all relations
+			// Process all V1.relations
 			for (
 				const {
 					tsKey: selectedRelationTsKey,
@@ -665,34 +843,43 @@ export class SingleStoreDialect {
 					relation,
 				} of selectedRelations
 			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+				const normalizedRelation = V1.normalizeRelation(
+					schema,
+					tableNamesMap,
+					relation,
+				);
 				const relationTableName = getTableUniqueName(relation.referencedTable);
 				const relationTableTsName = tableNamesMap[relationTableName]!;
 				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
 				const joinOn = and(
 					...normalizedRelation.fields.map((field, i) =>
 						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+							aliasedTableColumn(
+								normalizedRelation.references[i]!,
+								relationTableAlias,
+							),
 							aliasedTableColumn(field, tableAlias),
 						)
 					),
 				);
-				const builtRelation = this.buildRelationalQuery({
+				const builtRelation = this._buildRelationalQuery({
 					fullSchema,
 					schema,
 					tableNamesMap,
 					table: fullSchema[relationTableTsName] as SingleStoreTable,
 					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
+					queryConfig: is(relation, V1.One)
+						? selectedRelationConfigValue === true
 							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
+							: { ...selectedRelationConfigValue, limit: 1 }
 						: selectedRelationConfigValue,
 					tableAlias: relationTableAlias,
 					joinOn,
 					nestedQueryRelation: relation,
 				});
-				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
+				const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(
+					selectedRelationTsKey,
+				);
 				joins.push({
 					on: sql`true`,
 					table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
@@ -712,7 +899,9 @@ export class SingleStoreDialect {
 		}
 
 		if (selection.length === 0) {
-			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
+			throw new DrizzleError({
+				message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`,
+			});
 		}
 
 		let result;
@@ -732,19 +921,23 @@ export class SingleStoreDialect {
 					sql`, `,
 				)
 			})`;
-			if (is(nestedQueryRelation, Many)) {
+			if (is(nestedQueryRelation, V1.Many)) {
 				field = sql`json_agg(${field})`;
 			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field: field.as('data'),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
+			const nestedSelection = [
+				{
+					dbKey: 'data',
+					tsKey: 'data',
+					field: field.as('data'),
+					isJson: true,
+					relationTableTsKey: tableConfig.tsName,
+					selection,
+				},
+			];
 
-			const needsSubquery = limit !== undefined || offset !== undefined || (orderBy?.length ?? 0) > 0;
+			const needsSubquery = limit !== undefined
+				|| offset !== undefined
+				|| (orderBy?.length ?? 0) > 0;
 
 			if (needsSubquery) {
 				result = this.buildSelectQuery({
@@ -755,11 +948,13 @@ export class SingleStoreDialect {
 							path: [],
 							field: sql.raw('*'),
 						},
-						...(((orderBy?.length ?? 0) > 0)
-							? [{
-								path: [],
-								field: sql`row_number() over (order by ${sql.join(orderBy!, sql`, `)})`,
-							}]
+						...((orderBy?.length ?? 0) > 0
+							? [
+								{
+									path: [],
+									field: sql`row_number() over (order by ${sql.join(orderBy!, sql`, `)})`,
+								},
+							]
 							: []),
 					],
 					where,
@@ -777,11 +972,15 @@ export class SingleStoreDialect {
 			}
 
 			result = this.buildSelectQuery({
-				table: is(result, SingleStoreTable) ? result : new Subquery(result, {}, tableAlias),
+				table: is(result, SingleStoreTable)
+					? result
+					: new Subquery(result, {}, tableAlias),
 				fields: {},
 				fieldsFlat: nestedSelection.map(({ field }) => ({
 					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
 				})),
 				joins,
 				where,
@@ -796,7 +995,9 @@ export class SingleStoreDialect {
 				fields: {},
 				fieldsFlat: selection.map(({ field }) => ({
 					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+					field: is(field, Column)
+						? aliasedTableColumn(field, tableAlias)
+						: field,
 				})),
 				joins,
 				where,
@@ -813,4 +1014,326 @@ export class SingleStoreDialect {
 			selection,
 		};
 	}
+
+	private nestedSelectionerror() {
+		throw new DrizzleError({
+			message: `Views with nested selections are not supported by the relational query builder`,
+		});
+	}
+
+	private buildRqbColumn(table: Table | View, column: unknown, key: string) {
+		if (is(column, Column)) {
+			const name = sql`${table}.${sql.identifier(column.name)}`;
+
+			switch (column.columnType) {
+				case 'SingleStoreBinary':
+				case 'SingleStoreVarBinary':
+				case 'SingleStoreTime':
+				case 'SingleStoreDateTimeString':
+				case 'SingleStoreTimestampString':
+				case 'SingleStoreFloat':
+				case 'SingleStoreDecimal':
+				case 'SingleStoreDecimalNumber':
+				case 'SingleStoreDecimalBigInt':
+				case 'SingleStoreBigInt64':
+				case 'SingleStoreBigIntString':
+				case 'SingleStoreEnumColumn': {
+					return sql`cast(${name} as char) as ${sql.identifier(key)}`;
+				}
+
+				case 'SingleStoreVector':
+				case 'SingleStoreBigIntVector': {
+					return sql`hex(${name} :> blob) as ${sql.identifier(key)}`;
+				}
+
+				case 'SingleStoreCustomColumn': {
+					return sql`${(<SingleStoreCustomColumn<any>> column).jsonSelectIdentifier(name, sql)} as ${
+						sql.identifier(
+							key,
+						)
+					}`;
+				}
+
+				default: {
+					return sql`${name} as ${sql.identifier(key)}`;
+				}
+			}
+		}
+
+		return sql`${table}.${
+			is(column, SQL.Aliased)
+				? sql.identifier(column.fieldAlias)
+				: isSQLWrapper(column)
+				? sql.identifier(key)
+				: this.nestedSelectionerror()
+		} as ${sql.identifier(key)}`;
+	}
+
+	private unwrapAllColumns = (
+		table: Table | View,
+		selection: BuildRelationalQueryResult['selection'],
+	) => {
+		return sql.join(
+			Object.entries(table[TableColumns]).map(([k, v]) => {
+				selection.push({
+					key: k,
+					field: v as Column | SQL | SQLWrapper | SQL.Aliased,
+				});
+
+				return this.buildRqbColumn(table, v, k);
+			}),
+			sql`, `,
+		);
+	};
+
+	private getSelectedTableColumns = (
+		table: Table | View,
+		columns: Record<string, boolean | undefined>,
+	) => {
+		const selectedColumns: ColumnWithTSName[] = [];
+		const columnContainer = table[TableColumns];
+		const entries = Object.entries(columns);
+
+		let colSelectionMode: boolean | undefined;
+		for (const [k, v] of entries) {
+			if (v === undefined) continue;
+			colSelectionMode = colSelectionMode || v;
+
+			if (v) {
+				const column = columnContainer[k]!;
+
+				selectedColumns.push({
+					column: column as Column | SQL | SQLWrapper | SQL.Aliased,
+					tsName: k,
+				});
+			}
+		}
+
+		if (colSelectionMode === false) {
+			for (const [k, v] of Object.entries(columnContainer)) {
+				if (columns[k] === false) continue;
+
+				selectedColumns.push({
+					column: v as Column | SQL | SQLWrapper | SQL.Aliased | Table,
+					tsName: k,
+				});
+			}
+		}
+
+		return selectedColumns;
+	};
+
+	private buildColumns = (
+		table: SingleStoreTable | SingleStoreView,
+		selection: BuildRelationalQueryResult['selection'],
+		params?: DBQueryConfig<'many'>,
+	) =>
+		params?.columns
+			? (() => {
+				const columnIdentifiers: SQL[] = [];
+
+				const selectedColumns = this.getSelectedTableColumns(
+					table,
+					params.columns,
+				);
+
+				for (const { column, tsName } of selectedColumns) {
+					columnIdentifiers.push(this.buildRqbColumn(table, column, tsName));
+
+					selection.push({
+						key: tsName,
+						field: column,
+					});
+				}
+
+				return columnIdentifiers.length
+					? sql.join(columnIdentifiers, sql`, `)
+					: undefined;
+			})()
+			: this.unwrapAllColumns(table, selection);
+
+	buildRelationalQuery({
+		schema,
+		table,
+		tableConfig,
+		queryConfig: config,
+		relationWhere,
+		mode,
+		errorPath,
+		depth,
+		isNestedMany,
+		throughJoin,
+	}: {
+		schema: TablesRelationalConfig;
+		table: SingleStoreTable | SingleStoreView;
+		tableConfig: TableRelationalConfig;
+		queryConfig?: DBQueryConfig<'many'> | true;
+		relationWhere?: SQL;
+		mode: 'first' | 'many';
+		errorPath?: string;
+		depth?: number;
+		isNestedMany?: boolean;
+		throughJoin?: SQL;
+	}): BuildRelationalQueryResultWithOrder {
+		const selection: BuildRelationalQueryResult['selection'] = [];
+		const isSingle = mode === 'first';
+		const params = config === true ? undefined : config;
+		const currentPath = errorPath ?? '';
+		const currentDepth = depth ?? 0;
+		if (!currentDepth) table = aliasedTable(table, `d${currentDepth}`);
+
+		const limit = isSingle ? 1 : params?.limit;
+		const offset = params?.offset;
+
+		const columns = this.buildColumns(table, selection, params);
+
+		const where: SQL | undefined = params?.where && relationWhere
+			? and(
+				relationsFilterToSQL(
+					table,
+					params.where,
+					tableConfig.relations,
+					schema,
+				),
+				relationWhere,
+			)
+			: params?.where
+			? relationsFilterToSQL(
+				table,
+				params.where,
+				tableConfig.relations,
+				schema,
+			)
+			: relationWhere;
+		const order = params?.orderBy
+			? relationsOrderToSQL(table, params.orderBy)
+			: undefined;
+		const extras = params?.extras
+			? relationExtrasToSQL(table, params.extras)
+			: undefined;
+		if (extras) selection.push(...extras.selection);
+
+		const selectionArr: SQL[] = columns ? [columns] : [];
+		if (extras?.sql) selectionArr.push(extras.sql);
+
+		const joins = params
+			? (() => {
+				const { with: joins } = params as WithContainer;
+				if (!joins) return;
+
+				const withEntries = Object.entries(joins).filter(([_, v]) => v);
+				if (!withEntries.length) return;
+
+				return sql.join(
+					withEntries.map(([k, join]) => {
+						const relation = tableConfig.relations[k]! as Relation;
+						const isSingle = is(relation, One);
+						selectionArr.push(
+							isSingle
+								? sql`${sql.identifier(k)}.${sql.identifier('r')} as ${sql.identifier(k)}`
+								: sql`coalesce(${sql.identifier(k)}.${sql.identifier('r')}, json_build_array()) as ${
+									sql.identifier(
+										k,
+									)
+								}`,
+						);
+						const targetTable = aliasedTable(
+							relation.targetTable,
+							`d${currentDepth + 1}`,
+						);
+						const throughTable = relation.throughTable
+							? aliasedTable(relation.throughTable, `tr${currentDepth}`)
+							: undefined;
+						const { filter, joinCondition } = relationToSQL(
+							relation,
+							table,
+							targetTable,
+							throughTable,
+						);
+
+						const throughJoin = throughTable
+							? sql` inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition!}`
+							: undefined;
+
+						const innerQuery = this.buildRelationalQuery({
+							table: targetTable as SingleStoreTable,
+							mode: isSingle ? 'first' : 'many',
+							schema,
+							queryConfig: join as DBQueryConfig,
+							tableConfig: schema[relation.targetTableName]!,
+							relationWhere: filter,
+							errorPath: `${currentPath.length ? `${currentPath}.` : ''}${k}`,
+							depth: currentDepth + 1,
+							isNestedMany: !isSingle,
+							throughJoin,
+						});
+
+						selection.push({
+							field: targetTable,
+							key: k,
+							selection: innerQuery.selection,
+							isArray: !isSingle,
+							isOptional: ((relation as AnyOne).optional ?? false)
+								|| (join !== true
+									&& !!(join as Exclude<typeof join, boolean | undefined>)
+										.where),
+						});
+
+						const jsonColumns = sql.join(
+							innerQuery.selection.map(
+								(s) => sql`${sql.raw(this.escapeString(s.key))}, ${sql.identifier(s.key)}`,
+							),
+							sql`, `,
+						);
+
+						const joinQuery = sql` left join lateral(select ${sql`${
+							isSingle
+								? sql`json_build_object(${jsonColumns})`
+								: sql`json_agg(json_build_object(${jsonColumns})${
+									innerQuery.order
+										? sql` ORDER BY ${sql.identifier(`$drizzle_order_row_number`)}`
+										: undefined
+								})`
+						} as ${sql.identifier('r')}`} from (${innerQuery.sql}) as ${sql.identifier('t')}) as ${
+							sql.identifier(
+								k,
+							)
+						} on true`;
+
+						return joinQuery;
+					}),
+				);
+			})()
+			: undefined;
+
+		if (!selectionArr.length) {
+			throw new DrizzleError({
+				message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ''}`,
+			});
+		}
+
+		// TO BE TESTED: json_arrayagg() ignores order by clause otherwise
+		if (isNestedMany && order) {
+			selectionArr.push(
+				sql`row_number() over (order by ${order}) as ${sql.identifier(`$drizzle_order_row_number`)}`,
+			);
+		}
+		const selectionSet = sql.join(selectionArr, sql`, `);
+
+		const query = sql`select ${selectionSet} from ${getTableAsAliasSQL(table)}${throughJoin}${sql`${joins}`.if(joins)}${
+			sql` where ${where}`.if(
+				where,
+			)
+		}${sql` order by ${order}`.if(order)}${sql` limit ${limit}`.if(limit !== undefined)}${
+			sql` offset ${offset}`.if(
+				offset !== undefined,
+			)
+		}`;
+
+		return {
+			sql: query,
+			selection,
+			order,
+		};
+	}
 }
diff --git a/drizzle-orm/src/singlestore-core/index.ts b/drizzle-orm/src/singlestore-core/index.ts
index 4e7d4268ef..49c800562f 100644
--- a/drizzle-orm/src/singlestore-core/index.ts
+++ b/drizzle-orm/src/singlestore-core/index.ts
@@ -1,4 +1,5 @@
 export * from './alias.ts';
+export * from './casing.ts';
 export * from './columns/index.ts';
 export * from './db.ts';
 export * from './dialect.ts';
diff --git a/drizzle-orm/src/singlestore-core/indexes.ts b/drizzle-orm/src/singlestore-core/indexes.ts
index 3120cab1b6..f5bda856ff 100644
--- a/drizzle-orm/src/singlestore-core/indexes.ts
+++ b/drizzle-orm/src/singlestore-core/indexes.ts
@@ -19,9 +19,9 @@ interface IndexConfig {
 	using?: 'btree' | 'hash';
 
 	/**
-	 * If set, the index will be created as `create index ... algorythm { 'default' | 'inplace' | 'copy' }`.
+	 * If set, the index will be created as `create index ... algorithm { 'default' | 'inplace' | 'copy' }`.
 	 */
-	algorythm?: 'default' | 'inplace' | 'copy';
+	algorithm?: 'default' | 'inplace' | 'copy';
 
 	/**
 	 * If set, adds locks to the index creation.
@@ -67,8 +67,8 @@ export class IndexBuilder implements AnyIndexBuilder {
 		return this;
 	}
 
-	algorythm(algorythm: IndexConfig['algorythm']): this {
-		this.config.algorythm = algorythm;
+	algorithm(algorithm: IndexConfig['algorithm']): this {
+		this.config.algorithm = algorithm;
 		return this;
 	}
 
@@ -87,9 +87,11 @@ export class Index {
 	static readonly [entityKind]: string = 'SingleStoreIndex';
 
 	readonly config: IndexConfig & { table: SingleStoreTable };
+	readonly isNameExplicit: boolean;
 
 	constructor(config: IndexConfig, table: SingleStoreTable) {
 		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
 	}
 }
 
diff --git a/drizzle-orm/src/singlestore-core/primary-keys.ts b/drizzle-orm/src/singlestore-core/primary-keys.ts
index 47dc0a19cc..36bedd1acf 100644
--- a/drizzle-orm/src/singlestore-core/primary-keys.ts
+++ b/drizzle-orm/src/singlestore-core/primary-keys.ts
@@ -50,10 +50,12 @@ export class PrimaryKey {
 
 	readonly columns: SingleStoreColumn[];
 	readonly name?: string;
+	readonly isNameExplicit: boolean;
 
 	constructor(readonly table: SingleStoreTable, columns: SingleStoreColumn[], name?: string) {
 		this.columns = columns;
 		this.name = name;
+		this.isNameExplicit = !!name;
 	}
 
 	getName(): string {
diff --git a/drizzle-orm/src/singlestore-core/query-builders/_query.ts b/drizzle-orm/src/singlestore-core/query-builders/_query.ts
new file mode 100644
index 0000000000..b189831066
--- /dev/null
+++ b/drizzle-orm/src/singlestore-core/query-builders/_query.ts
@@ -0,0 +1,134 @@
+import * as V1 from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
+import type { SingleStoreDialect } from '../dialect.ts';
+import type {
+	PreparedQueryHKTBase,
+	PreparedQueryKind,
+	SingleStorePreparedQueryConfig,
+	SingleStoreSession,
+} from '../session.ts';
+import type { SingleStoreTable } from '../table.ts';
+
+export class _RelationalQueryBuilder<
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TSchema extends V1.TablesRelationalConfig,
+	TFields extends V1.TableRelationalConfig,
+> {
+	static readonly [entityKind]: string = 'SingleStoreRelationalQueryBuilder';
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: TSchema,
+		private tableNamesMap: Record<string, string>,
+		private table: SingleStoreTable,
+		private tableConfig: V1.TableRelationalConfig,
+		private dialect: SingleStoreDialect,
+		private session: SingleStoreSession,
+	) {}
+
+	findMany<TConfig extends V1.DBQueryConfig<'many', true, TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, V1.DBQueryConfig<'many', true, TSchema, TFields>>,
+	): SingleStoreRelationalQuery<TPreparedQueryHKT, V1.BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new SingleStoreRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? (config as V1.DBQueryConfig<'many', true>) : {},
+			'many',
+		);
+	}
+
+	findFirst<TSelection extends Omit<V1.DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
+		config?: KnownKeysOnly<TSelection, Omit<V1.DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
+	): SingleStoreRelationalQuery<TPreparedQueryHKT, V1.BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
+		return new SingleStoreRelationalQuery(
+			this.fullSchema,
+			this.schema,
+			this.tableNamesMap,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config ? { ...(config as V1.DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			'first',
+		);
+	}
+}
+
+export class SingleStoreRelationalQuery<
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TResult,
+> extends QueryPromise<TResult> {
+	static override readonly [entityKind]: string = 'SingleStoreRelationalQuery';
+
+	declare protected $brand: 'SingleStoreRelationalQuery';
+
+	constructor(
+		private fullSchema: Record<string, unknown>,
+		private schema: V1.TablesRelationalConfig,
+		private tableNamesMap: Record<string, string>,
+		private table: SingleStoreTable,
+		private tableConfig: V1.TableRelationalConfig,
+		private dialect: SingleStoreDialect,
+		private session: SingleStoreSession,
+		private config: V1.DBQueryConfig<'many', true> | true,
+		private queryMode: 'many' | 'first',
+	) {
+		super();
+	}
+
+	prepare() {
+		const { query, builtQuery } = this._toSQL();
+		return this.session.prepareQuery(
+			builtQuery,
+			undefined,
+			(rawRows) => {
+				const rows = rawRows.map((row) => V1.mapRelationalRow(this.schema, this.tableConfig, row, query.selection));
+				if (this.queryMode === 'first') {
+					return rows[0] as TResult;
+				}
+				return rows as TResult;
+			},
+		) as PreparedQueryKind<TPreparedQueryHKT, SingleStorePreparedQueryConfig & { execute: TResult }, true>;
+	}
+
+	private _getQuery() {
+		return this.dialect._buildRelationalQuery({
+			fullSchema: this.fullSchema,
+			schema: this.schema,
+			tableNamesMap: this.tableNamesMap,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			tableAlias: this.tableConfig.tsName,
+		});
+	}
+
+	private _toSQL(): { query: V1.BuildRelationalQueryResult; builtQuery: Query } {
+		const query = this._getQuery();
+
+		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+
+		return { builtQuery, query };
+	}
+
+	/** @internal */
+	getSQL(): SQL {
+		return this._getQuery().sql as SQL;
+	}
+
+	toSQL(): Query {
+		return this._toSQL().builtQuery;
+	}
+
+	override execute(): Promise<TResult> {
+		return this.prepare().execute();
+	}
+}
diff --git a/drizzle-orm/src/singlestore-core/query-builders/count.ts b/drizzle-orm/src/singlestore-core/query-builders/count.ts
index aba5b2f3f5..064b5cacf0 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/count.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/count.ts
@@ -9,7 +9,7 @@ export class SingleStoreCountBuilder<
 > extends SQL<number> implements Promise<number>, SQLWrapper {
 	private sql: SQL<number>;
 
-	static override readonly [entityKind] = 'SingleStoreCountBuilder';
+	static override readonly [entityKind]: string = 'SingleStoreCountBuilder';
 	[Symbol.toStringTag] = 'SingleStoreCountBuilder';
 
 	private session: TSession;
diff --git a/drizzle-orm/src/singlestore-core/query-builders/delete.ts b/drizzle-orm/src/singlestore-core/query-builders/delete.ts
index 91a1222663..648e3191df 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/delete.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/delete.ts
@@ -178,8 +178,7 @@ export class SingleStoreDeleteBase<
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	prepare(): SingleStoreDeletePrepare<this> {
diff --git a/drizzle-orm/src/singlestore-core/query-builders/insert.ts b/drizzle-orm/src/singlestore-core/query-builders/insert.ts
index 626c1798f1..cb22e07383 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/insert.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/insert.ts
@@ -14,7 +14,7 @@ import type {
 import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Param, SQL, sql } from '~/sql/sql.ts';
-import type { InferModelFromColumns } from '~/table.ts';
+import type { InferInsertModel, InferModelFromColumns } from '~/table.ts';
 import { Table } from '~/table.ts';
 import { mapUpdateSet, orderSelectedFields } from '~/utils.ts';
 import type { AnySingleStoreColumn, SingleStoreColumn } from '../columns/common.ts';
@@ -32,9 +32,12 @@ export interface SingleStoreInsertConfig<TTable extends SingleStoreTable = Singl
 
 export type AnySingleStoreInsertConfig = SingleStoreInsertConfig<SingleStoreTable>;
 
-export type SingleStoreInsertValue<TTable extends SingleStoreTable> =
+export type SingleStoreInsertValue<
+	TTable extends SingleStoreTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
+		[Key in keyof TModel]: TModel[Key] | SQL | Placeholder;
 	}
 	& {};
 
@@ -72,7 +75,7 @@ export class SingleStoreInsertBuilder<
 			const cols = this.table[Table.Symbol.Columns];
 			for (const colKey of Object.keys(entry)) {
 				const colValue = entry[colKey as keyof typeof entry];
-				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
 			}
 			return result;
 		});
@@ -272,8 +275,7 @@ export class SingleStoreInsertBase<
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	prepare(): SingleStoreInsertPrepare<this, TReturning> {
diff --git a/drizzle-orm/src/singlestore-core/query-builders/query.ts b/drizzle-orm/src/singlestore-core/query-builders/query.ts
index c15f7ad598..959d29ceff 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/query.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/query.ts
@@ -4,11 +4,11 @@ import {
 	type BuildQueryResult,
 	type BuildRelationalQueryResult,
 	type DBQueryConfig,
-	mapRelationalRow,
+	makeDefaultRqbMapper,
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import type { Query, QueryWithTypings, SQL } from '~/sql/sql.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { SingleStoreDialect } from '../dialect.ts';
 import type {
@@ -18,52 +18,47 @@ import type {
 	SingleStoreSession,
 } from '../session.ts';
 import type { SingleStoreTable } from '../table.ts';
+import type { SingleStoreView } from '../view.ts';
 
 export class RelationalQueryBuilder<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TSchema extends TablesRelationalConfig,
 	TFields extends TableRelationalConfig,
 > {
-	static readonly [entityKind]: string = 'SingleStoreRelationalQueryBuilder';
+	static readonly [entityKind]: string = 'SingleStoreRelationalQueryBuilderV2';
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
 		private schema: TSchema,
-		private tableNamesMap: Record<string, string>,
-		private table: SingleStoreTable,
+		private table: SingleStoreTable | SingleStoreView,
 		private tableConfig: TableRelationalConfig,
 		private dialect: SingleStoreDialect,
 		private session: SingleStoreSession,
 	) {}
 
-	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
-		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
+	findMany<TConfig extends DBQueryConfig<'many', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', TSchema, TFields>>,
 	): SingleStoreRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
 		return new SingleStoreRelationalQuery(
-			this.fullSchema,
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? (config as DBQueryConfig<'many', true>) : {},
+			config as DBQueryConfig<'many'> | undefined ?? true,
 			'many',
 		);
 	}
 
-	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
-		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
+	findFirst<TSelection extends DBQueryConfig<'one', TSchema, TFields>>(
+		config?: KnownKeysOnly<TSelection, DBQueryConfig<'one', TSchema, TFields>>,
 	): SingleStoreRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
 		return new SingleStoreRelationalQuery(
-			this.fullSchema,
 			this.schema,
-			this.tableNamesMap,
 			this.table,
 			this.tableConfig,
 			this.dialect,
 			this.session,
-			config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
+			config as DBQueryConfig<'one'> | undefined ?? true,
 			'first',
 		);
 	}
@@ -73,62 +68,65 @@ export class SingleStoreRelationalQuery<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TResult,
 > extends QueryPromise<TResult> {
-	static override readonly [entityKind]: string = 'SingleStoreRelationalQuery';
+	static override readonly [entityKind]: string = 'SingleStoreRelationalQueryV2';
 
 	declare protected $brand: 'SingleStoreRelationalQuery';
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
 		private schema: TablesRelationalConfig,
-		private tableNamesMap: Record<string, string>,
-		private table: SingleStoreTable,
+		private table: SingleStoreTable | SingleStoreView,
 		private tableConfig: TableRelationalConfig,
 		private dialect: SingleStoreDialect,
 		private session: SingleStoreSession,
-		private config: DBQueryConfig<'many', true> | true,
-		private queryMode: 'many' | 'first',
+		private config: DBQueryConfig<'many' | 'one'> | true,
+		private mode: 'many' | 'first',
 	) {
 		super();
 	}
 
 	prepare() {
 		const { query, builtQuery } = this._toSQL();
-		return this.session.prepareQuery(
+		return this.session.prepareRelationalQuery(
 			builtQuery,
 			undefined,
-			(rawRows) => {
-				const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection));
-				if (this.queryMode === 'first') {
-					return rows[0] as TResult;
-				}
-				return rows as TResult;
+			makeDefaultRqbMapper({
+				isFirst: this.mode === 'first',
+				parseJson: false,
+				parseJsonIfString: true,
+				rootJsonMappers: true,
+				selection: query.selection,
+			}),
+			{
+				isFirst: this.mode === 'first',
+				parseJson: false,
+				parseJsonIfString: true,
+				rootJsonMappers: true,
+				selection: query.selection,
 			},
 		) as PreparedQueryKind<TPreparedQueryHKT, SingleStorePreparedQueryConfig & { execute: TResult }, true>;
 	}
 
 	private _getQuery() {
 		return this.dialect.buildRelationalQuery({
-			fullSchema: this.fullSchema,
 			schema: this.schema,
-			tableNamesMap: this.tableNamesMap,
 			table: this.table,
 			tableConfig: this.tableConfig,
 			queryConfig: this.config,
-			tableAlias: this.tableConfig.tsName,
+			mode: this.mode,
 		});
 	}
 
-	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
+	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
 		const query = this._getQuery();
 
-		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+		const builtQuery = this.dialect.sqlToQuery(query.sql);
 
 		return { builtQuery, query };
 	}
 
 	/** @internal */
 	getSQL(): SQL {
-		return this._getQuery().sql as SQL;
+		return this._getQuery().sql;
 	}
 
 	toSQL(): Query {
diff --git a/drizzle-orm/src/singlestore-core/query-builders/select.ts b/drizzle-orm/src/singlestore-core/query-builders/select.ts
index 75906d26bf..60109cf61c 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/select.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/select.ts
@@ -44,6 +44,7 @@ import type {
 	SelectedFields,
 	SetOperatorRightSelect,
 	SingleStoreCreateSetOperatorFn,
+	SingleStoreCrossJoinFn,
 	SingleStoreJoinFn,
 	SingleStoreSelectConfig,
 	SingleStoreSelectDynamic,
@@ -210,7 +211,9 @@ export abstract class SingleStoreSelectQueryBuilderBase<
 	>(
 		joinType: TJoinType,
 		lateral: TIsLateral,
-	): SingleStoreJoinFn<this, TDynamic, TJoinType, TIsLateral> {
+	): 'cross' extends TJoinType ? SingleStoreCrossJoinFn<this, TDynamic, TIsLateral>
+		: SingleStoreJoinFn<this, TDynamic, TJoinType, TIsLateral>
+	{
 		return (
 			table: SingleStoreTable | Subquery | SQL, // | SingleStoreViewBase
 			on?: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -898,12 +901,12 @@ export abstract class SingleStoreSelectQueryBuilderBase<
 
 	/** @internal */
 	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<SingleStoreColumn>(this.config.fields);
 		return this.dialect.buildSelectQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	as<TAlias extends string>(
@@ -927,6 +930,11 @@ export abstract class SingleStoreSelectQueryBuilderBase<
 		) as this['_']['selectedFields'];
 	}
 
+	/** @internal */
+	override withoutSelectionCastCodecs(): this {
+		return this;
+	}
+
 	$dynamic(): SingleStoreSelectDynamic<this> {
 		return this as any;
 	}
@@ -988,24 +996,26 @@ export class SingleStoreSelectBase<
 		if (!this.session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
 		}
-		const fieldsList = orderSelectedFields<SingleStoreColumn>(this.config.fields);
-		const query = this.session.prepareQuery<
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const preparedQuery = this.session.prepareQuery<
 			SingleStorePreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
 			TPreparedQueryHKT
-		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList, undefined, undefined, undefined, {
+		>(query, fieldsList, undefined, undefined, undefined, {
 			type: 'select',
 			tables: [...this.usedTables],
 		}, this.cacheConfig);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as SingleStoreSelectPrepare<this>;
+		preparedQuery.joinsNotNullableMap = this.joinsNotNullableMap;
+		return preparedQuery as SingleStoreSelectPrepare<this>;
 	}
 
 	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
 		this.cacheConfig = config === undefined
-			? { config: {}, enable: true, autoInvalidate: true }
+			? { config: {}, enabled: true, autoInvalidate: true }
 			: config === false
-			? { enable: false }
-			: { enable: true, autoInvalidate: true, ...config };
+			? { enabled: false }
+			: { enabled: true, autoInvalidate: true, ...config };
 		return this;
 	}
 
diff --git a/drizzle-orm/src/singlestore-core/query-builders/select.types.ts b/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
index e9887f1aa6..561bcd3d59 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
@@ -37,7 +37,7 @@ export interface SingleStoreSelectJoinConfig {
 
 export type BuildAliasTable<TTable extends SingleStoreTable | View, TAlias extends string> = TTable extends Table
 	? SingleStoreTableWithColumns<
-		UpdateTableConfig<TTable['_']['config'], {
+		UpdateTableConfig<TTable['_'], {
 			name: TAlias;
 			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'singlestore'>;
 		}>
@@ -111,19 +111,24 @@ export type SingleStoreJoinFn<
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 	TIsLateral extends boolean,
-> = 'cross' extends TJoinType ? <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL
-			: SingleStoreTable | Subquery | SQL /* | SingleStoreViewBase */),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(table: TJoinedTable) => SingleStoreJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>
-	: <
-		TJoinedTable extends (TIsLateral extends true ? Subquery | SQL
-			: SingleStoreTable | Subquery | SQL /* | SingleStoreViewBase */),
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TJoinedTable,
-		on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-	) => SingleStoreJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL
+		: SingleStoreTable | Subquery | SQL /* | SingleStoreViewBase */),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => SingleStoreJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type SingleStoreCrossJoinFn<
+	T extends AnySingleStoreSelectQueryBuilder,
+	TDynamic extends boolean,
+	TIsLateral extends boolean,
+> = <
+	TJoinedTable extends (TIsLateral extends true ? Subquery | SQL
+		: SingleStoreTable | Subquery | SQL /* | SingleStoreViewBase */),
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(table: TJoinedTable) => SingleStoreJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectedFieldsFlatBase<SingleStoreColumn>;
 
diff --git a/drizzle-orm/src/singlestore-core/query-builders/update.ts b/drizzle-orm/src/singlestore-core/query-builders/update.ts
index 90a42880de..2953fbda39 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/update.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/update.ts
@@ -15,7 +15,7 @@ import type {
 import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
+import { type InferInsertModel, Table } from '~/table.ts';
 import { mapUpdateSet, type UpdateSet, type ValueOrArray } from '~/utils.ts';
 import type { SingleStoreColumn } from '../columns/common.ts';
 import { extractUsedTable } from '../utils.ts';
@@ -31,11 +31,15 @@ export interface SingleStoreUpdateConfig {
 	withList?: Subquery[];
 }
 
-export type SingleStoreUpdateSetSource<TTable extends SingleStoreTable> =
+export type SingleStoreUpdateSetSource<
+	TTable extends SingleStoreTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]?:
+		[Key in keyof TModel & string]?:
 			| GetColumnData<TTable['_']['columns'][Key], 'query'>
 			| SQL
+			| Placeholder
 			| undefined;
 	}
 	& {};
@@ -223,8 +227,7 @@ export class SingleStoreUpdateBase<
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	prepare(): SingleStoreUpdatePrepare<this> {
diff --git a/drizzle-orm/src/singlestore-core/schema.ts b/drizzle-orm/src/singlestore-core/schema.ts
index ea7a539247..bcc7fb5c16 100644
--- a/drizzle-orm/src/singlestore-core/schema.ts
+++ b/drizzle-orm/src/singlestore-core/schema.ts
@@ -1,3 +1,4 @@
+import type { Casing } from '~/casing.ts';
 import { entityKind, is } from '~/entity.ts';
 import { type SingleStoreTableFn, singlestoreTableWithSchema } from './table.ts';
 /* import { type singlestoreView, singlestoreViewWithSchema } from './view.ts'; */
@@ -7,10 +8,11 @@ export class SingleStoreSchema<TName extends string = string> {
 
 	constructor(
 		public readonly schemaName: TName,
+		protected casing: Casing | undefined,
 	) {}
 
 	table: SingleStoreTableFn<TName> = (name, columns, extraConfig) => {
-		return singlestoreTableWithSchema(name, columns, extraConfig, this.schemaName);
+		return singlestoreTableWithSchema(name, columns, extraConfig, this.schemaName, this.casing);
 	};
 	/*
 	view = ((name, columns) => {
@@ -30,8 +32,12 @@ export function isSingleStoreSchema(obj: unknown): obj is SingleStoreSchema {
  * @param name singlestore use schema name
  * @returns SingleStore schema
  */
-export function singlestoreDatabase<TName extends string>(name: TName) {
-	return new SingleStoreSchema(name);
+export function singlestoreDatabase<TName extends string>(name: TName): SingleStoreSchema<TName>;
+/** @internal */
+export function singlestoreDatabase<TName extends string>(name: TName, casing?: Casing): SingleStoreSchema<TName>;
+/** @internal */
+export function singlestoreDatabase<TName extends string>(name: TName, casing?: Casing): SingleStoreSchema<TName> {
+	return new SingleStoreSchema(name, casing);
 }
 
 /**
diff --git a/drizzle-orm/src/singlestore-core/session.ts b/drizzle-orm/src/singlestore-core/session.ts
index 1d8359d8fb..d63aec078e 100644
--- a/drizzle-orm/src/singlestore-core/session.ts
+++ b/drizzle-orm/src/singlestore-core/session.ts
@@ -1,9 +1,9 @@
+import type * as V1 from '~/_relations.ts';
 import { type Cache, hashQuery, NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind, is } from '~/entity.ts';
-import { TransactionRollbackError } from '~/errors.ts';
-import { DrizzleQueryError } from '~/errors/index.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
+import { DrizzleQueryError, TransactionRollbackError } from '~/errors.ts';
+import type { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from '~/relations.ts';
 import { type Query, type SQL, sql } from '~/sql/sql.ts';
 import type { Assume, Equal } from '~/utils.ts';
 import { SingleStoreDatabase } from './db.ts';
@@ -58,9 +58,9 @@ export abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQuer
 	) {
 		// it means that no $withCache options were passed and it should be just enabled
 		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
-			this.cacheConfig = { enable: true, autoInvalidate: true };
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
 		}
-		if (!this.cacheConfig?.enable) {
+		if (!this.cacheConfig?.enabled) {
 			this.cacheConfig = undefined;
 		}
 	}
@@ -80,7 +80,7 @@ export abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQuer
 		}
 
 		// don't do any mutations, if globally is false
-		if (this.cacheConfig && !this.cacheConfig.enable) {
+		if (this.cacheConfig && !this.cacheConfig.enabled) {
 			try {
 				return await query();
 			} catch (e) {
@@ -170,7 +170,8 @@ export abstract class SingleStoreSession<
 	TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
 > {
 	static readonly [entityKind]: string = 'SingleStoreSession';
 
@@ -192,6 +193,18 @@ export abstract class SingleStoreSession<
 		cacheConfig?: WithCacheConfig,
 	): PreparedQueryKind<TPreparedQueryHKT, T>;
 
+	abstract prepareRelationalQuery<
+		T extends SingleStorePreparedQueryConfig,
+		TPreparedQueryHKT extends SingleStorePreparedQueryHKT,
+	>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper: (rows: Record<string, unknown>[]) => T['execute'],
+		config: RelationalQueryMapperConfig,
+		generatedIds?: Record<string, unknown>[],
+		returningIds?: SelectedFieldsOrdered,
+	): PreparedQueryKind<TPreparedQueryHKT, T>;
+
 	execute<T>(query: SQL): Promise<T> {
 		return this.prepareQuery<SingleStorePreparedQueryConfig & { execute: T }, PreparedQueryHKTBase>(
 			this.dialect.sqlToQuery(query),
@@ -210,7 +223,9 @@ export abstract class SingleStoreSession<
 	}
 
 	abstract transaction<T>(
-		transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+		transaction: (
+			tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>,
+		) => Promise<T>,
 		config?: SingleStoreTransactionConfig,
 	): Promise<T>;
 
@@ -243,17 +258,19 @@ export abstract class SingleStoreTransaction<
 	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+	TSchema extends V1.TablesRelationalConfig = Record<string, never>,
+> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema> {
 	static override readonly [entityKind]: string = 'SingleStoreTransaction';
 
 	constructor(
 		dialect: SingleStoreDialect,
 		session: SingleStoreSession,
-		protected schema: RelationalSchemaConfig<TSchema> | undefined,
+		protected relations: TRelations,
+		protected schema: V1.RelationalSchemaConfig<TSchema> | undefined,
 		protected readonly nestedIndex: number,
 	) {
-		super(dialect, session, schema);
+		super(dialect, session, relations, schema);
 	}
 
 	rollback(): never {
@@ -262,7 +279,9 @@ export abstract class SingleStoreTransaction<
 
 	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
 	abstract override transaction<T>(
-		transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+		transaction: (
+			tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>,
+		) => Promise<T>,
 	): Promise<T>;
 }
 
diff --git a/drizzle-orm/src/singlestore-core/table.ts b/drizzle-orm/src/singlestore-core/table.ts
index 4eb01c62e4..9de2960870 100644
--- a/drizzle-orm/src/singlestore-core/table.ts
+++ b/drizzle-orm/src/singlestore-core/table.ts
@@ -1,8 +1,14 @@
-import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts';
+import { type Casing, getCasingFn } from '~/casing.ts';
+import type { BuildColumns, BuildExtraConfigColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
-import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
+import {
+	type InferTableColumnsModels,
+	Table,
+	type TableConfig as TableConfigBase,
+	type UpdateTableConfig,
+} from '~/table.ts';
 import { getSingleStoreColumnBuilders, type SingleStoreColumnBuilders } from './columns/all.ts';
-import type { SingleStoreColumn, SingleStoreColumnBuilder, SingleStoreColumnBuilderBase } from './columns/common.ts';
+import type { SingleStoreColumn, SingleStoreColumnBuilder, SingleStoreColumns } from './columns/common.ts';
 import type { AnyIndexBuilder } from './indexes.ts';
 import type { PrimaryKeyBuilder } from './primary-keys.ts';
 import type { UniqueConstraintBuilder } from './unique-constraint.ts';
@@ -17,13 +23,11 @@ export type SingleStoreTableExtraConfig = Record<
 	SingleStoreTableExtraConfigValue
 >;
 
-export type TableConfig = TableConfigBase<SingleStoreColumn>;
+export type TableConfig = TableConfigBase<SingleStoreColumns>;
 
 export class SingleStoreTable<T extends TableConfig = TableConfig> extends Table<T> {
 	static override readonly [entityKind]: string = 'SingleStoreTable';
 
-	declare protected $columns: T['columns'];
-
 	/** @internal */
 	static override readonly Symbol = Object.assign({}, Table.Symbol, {});
 
@@ -42,14 +46,13 @@ export type AnySingleStoreTable<TPartial extends Partial<TableConfig> = {}> = Si
 
 export type SingleStoreTableWithColumns<T extends TableConfig> =
 	& SingleStoreTable<T>
-	& {
-		[Key in keyof T['columns']]: T['columns'][Key];
-	};
+	& T['columns']
+	& InferTableColumnsModels<T['columns']>;
 
 export function singlestoreTableWithSchema<
 	TTableName extends string,
 	TSchemaName extends string | undefined,
-	TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
+	TColumnsMap extends Record<string, ColumnBuilderBase>,
 >(
 	name: TTableName,
 	columns: TColumnsMap | ((columnTypes: SingleStoreColumnBuilders) => TColumnsMap),
@@ -59,6 +62,7 @@ export function singlestoreTableWithSchema<
 		) => SingleStoreTableExtraConfig | SingleStoreTableExtraConfigValue[])
 		| undefined,
 	schema: TSchemaName,
+	casing: Casing | undefined,
 	baseName = name,
 ): SingleStoreTableWithColumns<{
 	name: TTableName;
@@ -66,6 +70,7 @@ export function singlestoreTableWithSchema<
 	columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
 	dialect: 'singlestore';
 }> {
+	const casingFn = getCasingFn(casing);
 	const rawTable = new SingleStoreTable<{
 		name: TTableName;
 		schema: TSchemaName;
@@ -78,8 +83,8 @@ export function singlestoreTableWithSchema<
 	const builtColumns = Object.fromEntries(
 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
 			const colBuilder = colBuilderBase as SingleStoreColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.build(rawTable);
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
 			return [name, column];
 		}),
 	) as unknown as BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
@@ -99,13 +104,13 @@ export function singlestoreTableWithSchema<
 		) => SingleStoreTableExtraConfig;
 	}
 
-	return table;
+	return table as any;
 }
 
 export interface SingleStoreTableFn<TSchemaName extends string | undefined = undefined> {
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -121,7 +126,7 @@ export interface SingleStoreTableFn<TSchemaName extends string | undefined = und
 
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap,
@@ -156,7 +161,7 @@ export interface SingleStoreTableFn<TSchemaName extends string | undefined = und
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -192,7 +197,7 @@ export interface SingleStoreTableFn<TSchemaName extends string | undefined = und
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap,
@@ -205,12 +210,26 @@ export interface SingleStoreTableFn<TSchemaName extends string | undefined = und
 	}>;
 }
 
-export const singlestoreTable: SingleStoreTableFn = (name, columns, extraConfig) => {
-	return singlestoreTableWithSchema(name, columns, extraConfig, undefined, name);
-};
+/** @internal */
+export function singlestoreTableWithCasing(casing: Casing | undefined): SingleStoreTableFn {
+	return (name, columns, extraConfig) =>
+		singlestoreTableWithSchema(name, columns, extraConfig, undefined, casing, name);
+}
+
+export const singlestoreTable = singlestoreTableWithCasing(undefined);
 
-export function singlestoreTableCreator(customizeTableName: (name: string) => string): SingleStoreTableFn {
+export function singlestoreTableCreator(
+	customizeTableName: (name: string) => string,
+	casing?: Casing | undefined,
+): SingleStoreTableFn {
 	return (name, columns, extraConfig) => {
-		return singlestoreTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+		return singlestoreTableWithSchema(
+			customizeTableName(name) as typeof name,
+			columns,
+			extraConfig,
+			undefined,
+			casing,
+			name,
+		);
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/unique-constraint.ts b/drizzle-orm/src/singlestore-core/unique-constraint.ts
index 511e466dc3..377ef065d6 100644
--- a/drizzle-orm/src/singlestore-core/unique-constraint.ts
+++ b/drizzle-orm/src/singlestore-core/unique-constraint.ts
@@ -51,12 +51,14 @@ export class UniqueConstraint {
 	static readonly [entityKind]: string = 'SingleStoreUniqueConstraint';
 
 	readonly columns: SingleStoreColumn[];
-	readonly name?: string;
+	readonly name: string;
 	readonly nullsNotDistinct: boolean = false;
+	readonly isNameExplicit: boolean;
 
 	constructor(readonly table: SingleStoreTable, columns: SingleStoreColumn[], name?: string) {
 		this.columns = columns;
 		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+		this.isNameExplicit = !!name;
 	}
 
 	getName() {
diff --git a/drizzle-orm/src/singlestore-core/view.ts b/drizzle-orm/src/singlestore-core/view.ts
index 58f1114286..7e20e61c97 100644
--- a/drizzle-orm/src/singlestore-core/view.ts
+++ b/drizzle-orm/src/singlestore-core/view.ts
@@ -1,11 +1,11 @@
-import type { BuildColumns } from '~/column-builder.ts';
+import type { BuildColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import type { SingleStoreColumn, SingleStoreColumnBuilderBase } from './columns/index.ts';
+import type { SingleStoreColumn } from './columns/index.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { singlestoreTable } from './table.ts';
@@ -96,7 +96,7 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 
 export class ManualViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, SingleStoreColumnBuilderBase> = Record<string, SingleStoreColumnBuilderBase>,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
 > extends ViewBuilderCore<{ name: TName; columns: TColumns }> {
 	static override readonly [entityKind]: string = 'SingleStoreManualViewBuilder';
 
diff --git a/drizzle-orm/src/singlestore-proxy/driver.ts b/drizzle-orm/src/singlestore-proxy/driver.ts
index ea24ae2d8e..0578a03bd6 100644
--- a/drizzle-orm/src/singlestore-proxy/driver.ts
+++ b/drizzle-orm/src/singlestore-proxy/driver.ts
@@ -1,14 +1,15 @@
-import { entityKind } from '~/entity.ts';
-import { DefaultLogger } from '~/logger.ts';
 import {
 	createTableRelationsHelpers,
 	extractTablesRelationalConfig,
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
-} from '~/relations.ts';
+} from '~/_relations.ts';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
 import { SingleStoreDatabase } from '~/singlestore-core/db.ts';
 import { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
+import { type DrizzleConfig, jitCompatCheck } from '~/utils.ts';
 import {
 	type SingleStoreRemotePreparedQueryHKT,
 	type SingleStoreRemoteQueryResultHKT,
@@ -17,7 +18,8 @@ import {
 
 export class SingleStoreRemoteDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends SingleStoreDatabase<SingleStoreRemoteQueryResultHKT, SingleStoreRemotePreparedQueryHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SingleStoreDatabase<SingleStoreRemoteQueryResultHKT, SingleStoreRemotePreparedQueryHKT, TSchema, TRelations> {
 	static override readonly [entityKind]: string = 'SingleStoreRemoteDatabase';
 }
 
@@ -27,11 +29,14 @@ export type RemoteCallback = (
 	method: 'all' | 'execute',
 ) => Promise<{ rows: any[]; insertId?: number; affectedRows?: number }>;
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
+>(
 	callback: RemoteCallback,
-	config: DrizzleConfig<TSchema> = {},
-): SingleStoreRemoteDatabase<TSchema> {
-	const dialect = new SingleStoreDialect({ casing: config.casing });
+	config: DrizzleConfig<TSchema, TRelations> = {},
+): SingleStoreRemoteDatabase<TSchema, TRelations> {
+	const dialect = new SingleStoreDialect();
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -52,8 +57,13 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		};
 	}
 
-	const session = new SingleStoreRemoteSession(callback, dialect, schema, { logger });
-	return new SingleStoreRemoteDatabase(dialect, session, schema as any) as SingleStoreRemoteDatabase<
-		TSchema
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SingleStoreRemoteSession(callback, dialect, relations, schema, {
+		logger,
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	return new SingleStoreRemoteDatabase(dialect, session, relations, schema as any) as SingleStoreRemoteDatabase<
+		TSchema,
+		TRelations
 	>;
 }
diff --git a/drizzle-orm/src/singlestore-proxy/migrator.ts b/drizzle-orm/src/singlestore-proxy/migrator.ts
index 2ed0172fb3..b9d670fdcd 100644
--- a/drizzle-orm/src/singlestore-proxy/migrator.ts
+++ b/drizzle-orm/src/singlestore-proxy/migrator.ts
@@ -1,52 +1,90 @@
-import type { MigrationConfig } from '~/migrator.ts';
+import type { MigrationConfig, MigratorInitFailResponse } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/singlestore-proxy.ts';
 import type { SingleStoreRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: SingleStoreRemoteDatabase<TSchema>,
+export async function migrate<TSchema extends Record<string, unknown>, TRelations extends AnyRelations>(
+	db: SingleStoreRemoteDatabase<TSchema, TRelations>,
 	callback: ProxyMigrator,
 	config: MigrationConfig,
-) {
+): Promise<void | MigratorInitFailResponse> {
 	const migrations = readMigrationFiles(config);
 
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
-	const migrationTableCreate = sql`
-		create table if not exists ${sql.identifier(migrationsTable)} (
-			id serial primary key,
-			hash text not null,
-			created_at bigint
-		)
-	`;
-	await db.execute(migrationTableCreate);
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded(migrationsTable, db, callback, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id SERIAL PRIMARY KEY,
+				hash TEXT NOT NULL,
+				created_at BIGINT,
+				name TEXT,
+				applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+			)
+		`;
+		await db.session.execute(migrationTableCreate);
+	}
 
 	const dbMigrations = await db.select({
 		id: sql.raw('id'),
 		hash: sql.raw('hash'),
 		created_at: sql.raw('created_at'),
-	}).from(sql.identifier(migrationsTable).getSQL()).orderBy(
-		sql.raw('created_at desc'),
-	).limit(1);
-
-	const lastDbMigration = dbMigrations[0];
+		name: sql.raw('name'),
+	}).from(sql.identifier(migrationsTable).getSQL()) as {
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}[];
 
-	const queriesToRun: string[] = [];
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
 
-	for (const migration of migrations) {
-		if (
-			!lastDbMigration
-			|| Number(lastDbMigration.created_at) < migration.folderMillis
-		) {
-			queriesToRun.push(
-				...migration.sql,
-				`insert into ${
-					sql.identifier(migrationsTable).value
-				} (\`hash\`, \`created_at\`) values('${migration.hash}', '${migration.folderMillis}')`,
-			);
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
 		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await callback([
+			db.dialect.sqlToQuery(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, '${migration.folderMillis}', ${migration.name})`
+					.inlineParams(),
+			).sql,
+		]);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const queriesToRun: string[] = [];
+	for (const migration of migrationsToRun) {
+		queriesToRun.push(
+			...migration.sql,
+			db.dialect.sqlToQuery(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} (\`hash\`, \`created_at\`, \`name\`) values(${migration.hash}, '${migration.folderMillis}', ${migration.name})`
+					.inlineParams(),
+			).sql,
+		);
 	}
 
 	await callback(queriesToRun);
+
+	return;
 }
diff --git a/drizzle-orm/src/singlestore-proxy/session.ts b/drizzle-orm/src/singlestore-proxy/session.ts
index 42cc8ecdef..93c88285ec 100644
--- a/drizzle-orm/src/singlestore-proxy/session.ts
+++ b/drizzle-orm/src/singlestore-proxy/session.ts
@@ -1,9 +1,15 @@
 import type { FieldPacket, ResultSetHeader } from 'mysql2/promise';
+import type * as V1 from '~/_relations.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
+import {
+	type AnyRelations,
+	makeJitRqbMapper,
+	type RelationalQueryMapperConfig,
+	type RelationalRowsMapper,
+} from '~/relations.ts';
 import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
 import { SingleStoreTransaction } from '~/singlestore-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/singlestore-core/query-builders/select.types.ts';
@@ -17,19 +23,27 @@ import type {
 import { SingleStorePreparedQuery as PreparedQueryBase, SingleStoreSession } from '~/singlestore-core/session.ts';
 import type { Query, SQL } from '~/sql/sql.ts';
 import { fillPlaceholders } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import { type Assume, makeJitQueryMapper, mapResultRow, type RowsMapper } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
 
 export type SingleStoreRawQueryResult = [ResultSetHeader, FieldPacket[]];
 
 export interface SingleStoreRemoteSessionOptions {
 	logger?: Logger;
+	useJitMappers?: boolean;
 }
 
 export class SingleStoreRemoteSession<
 	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SingleStoreSession<SingleStoreRemoteQueryResultHKT, SingleStoreRemotePreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+	TSchema extends V1.TablesRelationalConfig,
+> extends SingleStoreSession<
+	SingleStoreRemoteQueryResultHKT,
+	SingleStoreRemotePreparedQueryHKT,
+	TFullSchema,
+	TRelations,
+	TSchema
+> {
 	static override readonly [entityKind]: string = 'SingleStoreRemoteSession';
 
 	private logger: Logger;
@@ -37,8 +51,9 @@ export class SingleStoreRemoteSession<
 	constructor(
 		private client: RemoteCallback,
 		dialect: SingleStoreDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: SingleStoreRemoteSessionOptions,
+		private relations: TRelations,
+		private schema: V1.RelationalSchemaConfig<TSchema> | undefined,
+		private options: SingleStoreRemoteSessionOptions,
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
@@ -57,12 +72,36 @@ export class SingleStoreRemoteSession<
 			query.params,
 			this.logger,
 			fields,
+			this.options.useJitMappers,
 			customResultMapper,
 			generatedIds,
 			returningIds,
 		) as PreparedQueryKind<SingleStoreRemotePreparedQueryHKT, T>;
 	}
 
+	prepareRelationalQuery<T extends SingleStorePreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper: (rows: Record<string, unknown>[]) => T['execute'],
+		config: RelationalQueryMapperConfig,
+		generatedIds?: Record<string, unknown>[],
+		returningIds?: SelectedFieldsOrdered,
+	): PreparedQueryKind<SingleStoreRemotePreparedQueryHKT, T> {
+		return new PreparedQuery(
+			this.client,
+			query.sql,
+			query.params,
+			this.logger,
+			fields,
+			this.options.useJitMappers,
+			customResultMapper,
+			generatedIds,
+			returningIds,
+			true,
+			config,
+		) as any;
+	}
+
 	override all<T = unknown>(query: SQL): Promise<T[]> {
 		const querySql = this.dialect.sqlToQuery(query);
 		this.logger.logQuery(querySql.sql, querySql.params);
@@ -70,7 +109,7 @@ export class SingleStoreRemoteSession<
 	}
 
 	override async transaction<T>(
-		_transaction: (tx: SingleStoreProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: SingleStoreProxyTransaction<TFullSchema, TRelations, TSchema>) => Promise<T>,
 		_config?: SingleStoreTransactionConfig,
 	): Promise<T> {
 		throw new Error('Transactions are not supported by the SingleStore Proxy driver');
@@ -79,24 +118,29 @@ export class SingleStoreRemoteSession<
 
 export class SingleStoreProxyTransaction<
 	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
+	TRelations extends AnyRelations,
+	TSchema extends V1.TablesRelationalConfig,
 > extends SingleStoreTransaction<
 	SingleStoreRemoteQueryResultHKT,
 	SingleStoreRemotePreparedQueryHKT,
 	TFullSchema,
+	TRelations,
 	TSchema
 > {
 	static override readonly [entityKind]: string = 'SingleStoreProxyTransaction';
 
 	override async transaction<T>(
-		_transaction: (tx: SingleStoreProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: SingleStoreProxyTransaction<TFullSchema, TRelations, TSchema>) => Promise<T>,
 	): Promise<T> {
 		throw new Error('Transactions are not supported by the SingleStore Proxy driver');
 	}
 }
 
-export class PreparedQuery<T extends SingleStorePreparedQueryConfig> extends PreparedQueryBase<T> {
+export class PreparedQuery<T extends SingleStorePreparedQueryConfig, TIsRqbV2 extends boolean = false>
+	extends PreparedQueryBase<T>
+{
 	static override readonly [entityKind]: string = 'SingleStoreProxyPreparedQuery';
+	private jitMapper?: RowsMapper<T['execute']> | RelationalRowsMapper<T['execute']>;
 
 	constructor(
 		private client: RemoteCallback,
@@ -104,16 +148,23 @@ export class PreparedQuery<T extends SingleStorePreparedQueryConfig> extends Pre
 		private params: unknown[],
 		private logger: Logger,
 		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+		private useJitMappers: boolean | undefined,
+		private customResultMapper?: (
+			rows: TIsRqbV2 extends true ? Record<string, unknown>[] : unknown[][],
+		) => T['execute'],
 		// Keys that were used in $default and the value that was generated for them
 		private generatedIds?: Record<string, unknown>[],
 		// Keys that should be returned, it has the column with all properries + key from object
 		private returningIds?: SelectedFieldsOrdered,
+		private isRqbV2Query?: TIsRqbV2,
+		private rqbConfig?: RelationalQueryMapperConfig,
 	) {
 		super();
 	}
 
 	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
+		if (this.isRqbV2Query) return this.executeRqbV2(placeholderValues);
+
 		const params = fillPlaceholders(this.params, placeholderValues);
 
 		const { fields, client, queryString, logger, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } =
@@ -159,7 +210,26 @@ export class PreparedQuery<T extends SingleStorePreparedQueryConfig> extends Pre
 			return customResultMapper(rows);
 		}
 
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
+		return this.useJitMappers
+			? (this.jitMapper = this.jitMapper as RowsMapper<T['execute']>
+				?? makeJitQueryMapper<T['execute']>(fields!, joinsNotNullableMap))(rows)
+			: rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
+	}
+
+	private async executeRqbV2(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
+		const params = fillPlaceholders(this.params, placeholderValues);
+
+		const { client, queryString, logger, customResultMapper } = this;
+
+		logger.logQuery(queryString, params);
+
+		const { rows: res } = await client(queryString, params, 'execute');
+		const rows = res[0];
+
+		return this.useJitMappers
+			? (this.jitMapper = this.jitMapper as RelationalRowsMapper<T['execute']>
+				?? makeJitRqbMapper<T['execute']>(this.rqbConfig!))(rows)
+			: customResultMapper!(rows);
 	}
 
 	override iterator(
diff --git a/drizzle-orm/src/singlestore/driver.ts b/drizzle-orm/src/singlestore/driver.ts
index a534ea83eb..de0ec91dc7 100644
--- a/drizzle-orm/src/singlestore/driver.ts
+++ b/drizzle-orm/src/singlestore/driver.ts
@@ -1,18 +1,19 @@
 import { type Connection as CallbackConnection, createPool, type Pool as CallbackPool, type PoolOptions } from 'mysql2';
 import type { Connection, Pool } from 'mysql2/promise';
-import type { Cache } from '~/cache/core/cache.ts';
-import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
-import { DefaultLogger } from '~/logger.ts';
 import {
 	createTableRelationsHelpers,
 	extractTablesRelationalConfig,
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
-} from '~/relations.ts';
+} from '~/_relations.ts';
+import type { Cache } from '~/cache/core/cache.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
 import { SingleStoreDatabase } from '~/singlestore-core/db.ts';
 import { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import { type DrizzleConfig, jitCompatCheck } from '~/utils.ts';
 import { npmVersion } from '~/version.ts';
 import type {
 	SingleStoreDriverClient,
@@ -24,6 +25,7 @@ import { SingleStoreDriverSession } from './session.ts';
 export interface SingleStoreDriverOptions {
 	logger?: Logger;
 	cache?: Cache;
+	useJitMappers?: boolean;
 }
 
 export class SingleStoreDriverDriver {
@@ -38,9 +40,11 @@ export class SingleStoreDriverDriver {
 
 	createSession(
 		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): SingleStoreDriverSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new SingleStoreDriverSession(this.client, this.dialect, schema, {
+		relations: AnyRelations,
+	): SingleStoreDriverSession<Record<string, unknown>, AnyRelations, TablesRelationalConfig> {
+		return new SingleStoreDriverSession(this.client, this.dialect, relations, schema, {
 			logger: this.options.logger,
+			useJitMappers: this.options.useJitMappers ?? false,
 			cache: this.options.cache,
 		});
 	}
@@ -50,24 +54,29 @@ export { SingleStoreDatabase } from '~/singlestore-core/db.ts';
 
 export class SingleStoreDriverDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends SingleStoreDatabase<SingleStoreDriverQueryResultHKT, SingleStoreDriverPreparedQueryHKT, TSchema> {
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SingleStoreDatabase<SingleStoreDriverQueryResultHKT, SingleStoreDriverPreparedQueryHKT, TSchema, TRelations> {
 	static override readonly [entityKind]: string = 'SingleStoreDriverDatabase';
 }
 
-export type SingleStoreDriverDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> =
-	& Omit<DrizzleConfig<TSchema>, 'schema'>
+export type SingleStoreDriverDrizzleConfig<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
+> =
+	& Omit<DrizzleConfig<TSchema, TRelations>, 'schema'>
 	& ({ schema: TSchema } | { schema?: undefined });
 
 function construct<
 	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Pool | Connection | CallbackPool | CallbackConnection = CallbackPool,
 >(
 	client: TClient,
-	config: SingleStoreDriverDrizzleConfig<TSchema> = {},
-): SingleStoreDriverDatabase<TSchema> & {
-	$client: TClient;
+	config: SingleStoreDriverDrizzleConfig<TSchema, TRelations> = {},
+): SingleStoreDriverDatabase<TSchema, TRelations> & {
+	$client: AnySingleStoreDriverConnection extends TClient ? CallbackPool : TClient;
 } {
-	const dialect = new SingleStoreDialect({ casing: config.casing });
+	const dialect = new SingleStoreDialect();
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -90,12 +99,16 @@ function construct<
 		};
 	}
 
+	const relations = config.relations ?? {} as TRelations;
 	const driver = new SingleStoreDriverDriver(clientForInstance as SingleStoreDriverClient, dialect, {
 		logger,
 		cache: config.cache,
+		useJitMappers: jitCompatCheck(config.jit),
 	});
-	const session = driver.createSession(schema);
-	const db = new SingleStoreDriverDatabase(dialect, session, schema as any) as SingleStoreDriverDatabase<TSchema>;
+	const session = driver.createSession(schema, relations);
+	const db = new SingleStoreDriverDatabase(dialect, session, relations, schema as any) as SingleStoreDriverDatabase<
+		TSchema
+	>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -122,16 +135,17 @@ const CONNECTION_ATTRS: PoolOptions['connectAttributes'] = {
 
 export function drizzle<
 	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends AnySingleStoreDriverConnection = CallbackPool,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		SingleStoreDriverDrizzleConfig<TSchema>,
+		string,
+		SingleStoreDriverDrizzleConfig<TSchema, TRelations>,
 	] | [
 		(
-			& SingleStoreDriverDrizzleConfig<TSchema>
+			& SingleStoreDriverDrizzleConfig<TSchema, TRelations>
 			& ({
 				connection: string | PoolOptions;
 			} | {
@@ -139,8 +153,8 @@ export function drizzle<
 			})
 		),
 	]
-): SingleStoreDriverDatabase<TSchema> & {
-	$client: TClient;
+): SingleStoreDriverDatabase<TSchema, TRelations> & {
+	$client: AnySingleStoreDriverConnection extends TClient ? CallbackPool : TClient;
 } {
 	if (typeof params[0] === 'string') {
 		const connectionString = params[0]!;
@@ -152,43 +166,40 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: PoolOptions | string; client?: TClient }
-			& SingleStoreDriverDrizzleConfig<TSchema>;
-
-		if (client) return construct(client, drizzleConfig) as any;
-
-		let opts: PoolOptions = {};
-		if (typeof connection === 'string') {
-			opts = {
-				uri: connection,
-				supportBigNumbers: true,
-				connectAttributes: CONNECTION_ATTRS,
-			};
-		} else {
-			opts = {
-				...connection,
-				connectAttributes: {
-					...connection!.connectAttributes,
-					...CONNECTION_ATTRS,
-				},
-			};
-		}
+	const { connection, client, ...drizzleConfig } = params[0] as
+		& { connection?: PoolOptions | string; client?: TClient }
+		& SingleStoreDriverDrizzleConfig<TSchema, TRelations>;
 
-		const instance = createPool(opts);
-		const db = construct(instance, drizzleConfig);
+	if (client) return construct(client, drizzleConfig) as any;
 
-		return db as any;
-	}
+	let opts: PoolOptions = {};
+	opts = typeof connection === 'string'
+		? {
+			uri: connection,
+			supportBigNumbers: true,
+			connectAttributes: CONNECTION_ATTRS,
+		}
+		: {
+			...connection,
+			connectAttributes: {
+				...connection!.connectAttributes,
+				...CONNECTION_ATTRS,
+			},
+		};
 
-	return construct(params[0] as TClient, params[1] as SingleStoreDriverDrizzleConfig<TSchema> | undefined) as any;
+	const instance = createPool(opts);
+	const db = construct(instance, drizzleConfig);
+
+	return db as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: SingleStoreDriverDrizzleConfig<TSchema>,
-	): SingleStoreDriverDatabase<TSchema> & {
+	export function mock<
+		TSchema extends Record<string, unknown> = Record<string, never>,
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: SingleStoreDriverDrizzleConfig<TSchema, TRelations>,
+	): SingleStoreDriverDatabase<TSchema, TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/singlestore/migrator.ts b/drizzle-orm/src/singlestore/migrator.ts
index 6f342c0c58..7dba82938d 100644
--- a/drizzle-orm/src/singlestore/migrator.ts
+++ b/drizzle-orm/src/singlestore/migrator.ts
@@ -1,11 +1,12 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { SingleStoreDriverDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: SingleStoreDriverDatabase<TSchema>,
+export async function migrate<TSchema extends Record<string, unknown>, TRelations extends AnyRelations>(
+	db: SingleStoreDriverDatabase<TSchema, TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await db.dialect.migrate(migrations, db.session, config);
 }
diff --git a/drizzle-orm/src/singlestore/session.ts b/drizzle-orm/src/singlestore/session.ts
index 0b05e1c311..bc58a1e368 100644
--- a/drizzle-orm/src/singlestore/session.ts
+++ b/drizzle-orm/src/singlestore/session.ts
@@ -10,13 +10,19 @@ import type {
 	RowDataPacket,
 } from 'mysql2/promise';
 import { once } from 'node:events';
+import type * as V1 from '~/_relations.ts';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
+import {
+	type AnyRelations,
+	makeJitRqbMapper,
+	type RelationalQueryMapperConfig,
+	type RelationalRowsMapper,
+} from '~/relations.ts';
 import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
 import type { SelectedFieldsOrdered } from '~/singlestore-core/query-builders/select.types.ts';
 import {
@@ -31,7 +37,7 @@ import {
 } from '~/singlestore-core/session.ts';
 import type { Query, SQL } from '~/sql/sql.ts';
 import { fillPlaceholders, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import { type Assume, makeJitQueryMapper, mapResultRow, type RowsMapper } from '~/utils.ts';
 
 export type SingleStoreDriverClient = Pool | Connection;
 
@@ -41,13 +47,16 @@ export type SingleStoreQueryResult<
 	T = any,
 > = [T extends ResultSetHeader ? T : T[], FieldPacket[]];
 
-export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryConfig>
+export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryConfig, TIsRqbV2 extends boolean = false>
 	extends SingleStorePreparedQuery<T>
 {
 	static override readonly [entityKind]: string = 'SingleStoreDriverPreparedQuery';
 
 	private rawQuery: QueryOptions;
 	private query: QueryOptions;
+	private jitMapper?:
+		| RowsMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>
+		| RelationalRowsMapper<T['execute']>;
 
 	constructor(
 		private client: SingleStoreDriverClient,
@@ -61,11 +70,16 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 		} | undefined,
 		cacheConfig: WithCacheConfig | undefined,
 		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+		private useJitMappers: boolean | undefined,
+		private customResultMapper?: (
+			rows: TIsRqbV2 extends true ? Record<string, unknown>[] : unknown[][],
+		) => T['execute'],
 		// Keys that were used in $default and the value that was generated for them
 		private generatedIds?: Record<string, unknown>[],
 		// Keys that should be returned, it has the column with all properties + key from object
 		private returningIds?: SelectedFieldsOrdered,
+		private isRqbV2Query?: TIsRqbV2,
+		private rqbConfig?: RelationalQueryMapperConfig,
 	) {
 		super(cache, queryMetadata, cacheConfig);
 		this.rawQuery = {
@@ -91,6 +105,8 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 	}
 
 	async execute(placeholderValues: Record<string, unknown> = {}): Promise<T['execute']> {
+		if (this.isRqbV2Query) return this.executeRqbV2(placeholderValues);
+
 		const params = fillPlaceholders(this.params, placeholderValues);
 
 		this.logger.logQuery(this.rawQuery.sql, params);
@@ -101,6 +117,7 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 			const res = await this.queryWithCache(rawQuery.sql, params, async () => {
 				return await client.query<any>(rawQuery, params);
 			});
+
 			const insertId = res[0].insertId;
 			const affectedRows = res[0].affectedRows;
 			// for each row, I need to check keys from
@@ -132,13 +149,34 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 		const result = await this.queryWithCache(query.sql, params, async () => {
 			return await client.query<any[]>(query, params);
 		});
+
 		const rows = result[0];
 
 		if (customResultMapper) {
 			return customResultMapper(rows);
 		}
 
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
+		return this.useJitMappers
+			? (this.jitMapper =
+				this.jitMapper as RowsMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>
+					?? makeJitQueryMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>(
+						fields!,
+						joinsNotNullableMap,
+					))(rows)
+			: rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
+	}
+
+	private async executeRqbV2(placeholderValues: Record<string, unknown> = {}): Promise<T['execute']> {
+		const params = fillPlaceholders(this.params, placeholderValues);
+
+		this.logger.logQuery(this.rawQuery.sql, params);
+
+		const { client, rawQuery, customResultMapper } = this;
+		const res = await client.query<any>(rawQuery, params);
+
+		const rows = res[0];
+
+		return (customResultMapper as (rows: Record<string, unknown>[]) => T['execute'])(rows);
 	}
 
 	async *iterator(
@@ -170,15 +208,33 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 				const row = await Promise.race([onEnd, onError, new Promise((resolve) => stream.once('data', resolve))]);
 				if (row === undefined || (Array.isArray(row) && row.length === 0)) {
 					break;
-				} else if (row instanceof Error) { // eslint-disable-line no-instanceof/no-instanceof
+				} else if (row instanceof Error) { // oxlint-disable-line drizzle-internal/no-instanceof
 					throw row;
 				} else {
-					if (hasRowsMapper) {
+					if (this.isRqbV2Query) {
+						if (this.useJitMappers) {
+							yield (this.jitMapper = this.jitMapper as RelationalRowsMapper<T['execute']>
+								?? makeJitRqbMapper<T['execute']>(this.rqbConfig!))([row as Record<string, unknown>]);
+						} else {
+							const mapped = (customResultMapper as (rows: Record<string, unknown>[]) => T['execute'])([
+								row as Record<string, unknown>,
+							]);
+							if (this.rqbConfig!.isFirst) yield mapped;
+							else yield ((<any[]> mapped)[0]);
+						}
+					} else if (hasRowsMapper) {
 						if (customResultMapper) {
-							const mappedRow = customResultMapper([row as unknown[]]);
+							const mappedRow = (customResultMapper as (rows: unknown[][]) => T['execute'])([row as unknown[]]);
 							yield (Array.isArray(mappedRow) ? mappedRow[0] : mappedRow);
 						} else {
-							yield mapResultRow(fields!, row as unknown[], joinsNotNullableMap);
+							yield this.useJitMappers
+								? (this.jitMapper = this.jitMapper as RowsMapper<(T['execute'] extends any[] ? T['execute'][number]
+									: T['execute'])[]>
+									?? makeJitQueryMapper<(T['execute'] extends any[] ? T['execute'][number] : T['execute'])[]>(
+										fields!,
+										joinsNotNullableMap,
+									))([row as unknown[]])[0] as T['execute']
+								: mapResultRow(fields!, row as unknown[], joinsNotNullableMap);
 						}
 					} else {
 						yield row as T['execute'];
@@ -197,12 +253,20 @@ export class SingleStoreDriverPreparedQuery<T extends SingleStorePreparedQueryCo
 export interface SingleStoreDriverSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	useJitMappers?: boolean;
 }
 
 export class SingleStoreDriverSession<
 	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SingleStoreSession<SingleStoreQueryResultHKT, SingleStoreDriverPreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+	TSchema extends V1.TablesRelationalConfig,
+> extends SingleStoreSession<
+	SingleStoreQueryResultHKT,
+	SingleStoreDriverPreparedQueryHKT,
+	TFullSchema,
+	TRelations,
+	TSchema
+> {
 	static override readonly [entityKind]: string = 'SingleStoreDriverSession';
 
 	private logger: Logger;
@@ -211,7 +275,8 @@ export class SingleStoreDriverSession<
 	constructor(
 		private client: SingleStoreDriverClient,
 		dialect: SingleStoreDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
+		private schema: V1.RelationalSchemaConfig<TSchema> | undefined,
 		private options: SingleStoreDriverSessionOptions,
 	) {
 		super(dialect);
@@ -242,12 +307,41 @@ export class SingleStoreDriverSession<
 			queryMetadata,
 			cacheConfig,
 			fields,
+			this.options.useJitMappers,
 			customResultMapper,
 			generatedIds,
 			returningIds,
 		) as PreparedQueryKind<SingleStoreDriverPreparedQueryHKT, T>;
 	}
 
+	prepareRelationalQuery<T extends SingleStorePreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper: (rows: Record<string, unknown>[]) => T['execute'],
+		config: RelationalQueryMapperConfig,
+		generatedIds?: Record<string, unknown>[],
+		returningIds?: SelectedFieldsOrdered,
+	): PreparedQueryKind<SingleStorePreparedQueryHKT, T> {
+		// Add returningId fields
+		// Each driver gets them from response from database
+		return new SingleStoreDriverPreparedQuery(
+			this.client,
+			query.sql,
+			query.params,
+			this.logger,
+			this.cache,
+			undefined,
+			undefined,
+			fields,
+			this.options.useJitMappers,
+			customResultMapper,
+			generatedIds,
+			returningIds,
+			true,
+			config,
+		) as any;
+	}
+
 	/**
 	 * @internal
 	 * What is its purpose?
@@ -271,24 +365,26 @@ export class SingleStoreDriverSession<
 	override all<T = unknown>(query: SQL): Promise<T[]> {
 		const querySql = this.dialect.sqlToQuery(query);
 		this.logger.logQuery(querySql.sql, querySql.params);
-		return this.client.execute(querySql.sql, querySql.params).then((result) => result[0]) as Promise<T[]>;
+		return this.client.query(querySql.sql, querySql.params).then((result) => result[0]) as Promise<T[]>;
 	}
 
 	override async transaction<T>(
-		transaction: (tx: SingleStoreDriverTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: SingleStoreDriverTransaction<TFullSchema, TRelations, TSchema>) => Promise<T>,
 		config?: SingleStoreTransactionConfig,
 	): Promise<T> {
 		const session = isPool(this.client)
 			? new SingleStoreDriverSession(
 				await this.client.getConnection(),
 				this.dialect,
+				this.relations,
 				this.schema,
 				this.options,
 			)
 			: this;
-		const tx = new SingleStoreDriverTransaction<TFullSchema, TSchema>(
+		const tx = new SingleStoreDriverTransaction<TFullSchema, TRelations, TSchema>(
 			this.dialect,
-			session as SingleStoreSession<any, any, any, any>,
+			session as SingleStoreSession<any, any, any, any, any>,
+			this.relations,
 			this.schema,
 			0,
 		);
@@ -319,22 +415,25 @@ export class SingleStoreDriverSession<
 
 export class SingleStoreDriverTransaction<
 	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
+	TRelations extends AnyRelations,
+	TSchema extends V1.TablesRelationalConfig,
 > extends SingleStoreTransaction<
 	SingleStoreDriverQueryResultHKT,
 	SingleStoreDriverPreparedQueryHKT,
 	TFullSchema,
+	TRelations,
 	TSchema
 > {
 	static override readonly [entityKind]: string = 'SingleStoreDriverTransaction';
 
 	override async transaction<T>(
-		transaction: (tx: SingleStoreDriverTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: SingleStoreDriverTransaction<TFullSchema, TRelations, TSchema>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new SingleStoreDriverTransaction<TFullSchema, TSchema>(
+		const tx = new SingleStoreDriverTransaction<TFullSchema, TRelations, TSchema>(
 			this.dialect,
 			this.session,
+			this.relations,
 			this.schema,
 			this.nestedIndex + 1,
 		);
diff --git a/drizzle-orm/src/sql-js/driver.ts b/drizzle-orm/src/sql-js/driver.ts
index 994d80bc88..497ac372f6 100644
--- a/drizzle-orm/src/sql-js/driver.ts
+++ b/drizzle-orm/src/sql-js/driver.ts
@@ -1,25 +1,26 @@
 import type { Database } from 'sql.js';
+import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
-import { SQLJsSession } from './session.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { type SQLJsRunResult, SQLJsSession } from './session.ts';
 
-export type SQLJsDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> = BaseSQLiteDatabase<'sync', void, TSchema>;
+export class SQLJsDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'sync', SQLJsRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLJsDatabase';
+}
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	client: Database,
-	config: DrizzleConfig<TSchema> = {},
-): SQLJsDatabase<TSchema> {
-	const dialect = new SQLiteSyncDialect({ casing: config.casing });
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): SQLJsDatabase<TRelations> & { $client: Database } {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -27,19 +28,17 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SQLJsSession(client, dialect, relations, {
+		logger,
+	});
+	const db = new SQLJsDatabase(
+		'sync',
+		dialect,
+		session,
+		relations,
+	);
+	(<any> db).$client = client;
 
-	const session = new SQLJsSession(client, dialect, schema, { logger });
-	return new BaseSQLiteDatabase('sync', dialect, session, schema) as SQLJsDatabase<TSchema>;
+	return db as any;
 }
diff --git a/drizzle-orm/src/sql-js/migrator.ts b/drizzle-orm/src/sql-js/migrator.ts
index 1b3d5faa39..5ee1777448 100644
--- a/drizzle-orm/src/sql-js/migrator.ts
+++ b/drizzle-orm/src/sql-js/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { migrateSync } from '~/sqlite-core/async/session.ts';
 import type { SQLJsDatabase } from './driver.ts';
 
-export function migrate<TSchema extends Record<string, unknown>>(
-	db: SQLJsDatabase<TSchema>,
+export function migrate<TRelations extends AnyRelations = EmptyRelations>(
+	db: SQLJsDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	db.dialect.migrate(migrations, db.session, config);
+	return migrateSync(migrations, db.session, config);
 }
diff --git a/drizzle-orm/src/sql-js/session.ts b/drizzle-orm/src/sql-js/session.ts
index a502791915..eff3d9b040 100644
--- a/drizzle-orm/src/sql-js/session.ts
+++ b/drizzle-orm/src/sql-js/session.ts
@@ -2,57 +2,123 @@ import type { BindParams, Database } from 'sql.js';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SQLiteExecuteMethod,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 
 export interface SQLJsSessionOptions {
 	logger?: Logger;
 }
 
+export type SQLJsRunResult = void;
+
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
-export class SQLJsSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'sync', void, TFullSchema, TSchema> {
+export class SQLJsSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'sync', SQLJsRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SQLJsSession';
 
 	private logger: Logger;
 
 	constructor(
 		private client: Database,
-		dialect: SQLiteSyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		options: SQLJsSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: SQLJsSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'sync');
 		this.logger = options.logger ?? new NoopLogger();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-	): PreparedQuery<T> {
-		return new PreparedQuery(this.client, query, this.logger, fields, executeMethod, isResponseInArrayMode);
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+	): SQLiteAsyncPreparedQuery<T & { run: SQLJsRunResult }> {
+		const executors: SQLiteQueryExecutors<'sync'> = {
+			all: (params) => {
+				const stmt = this.client.prepare(query.sql);
+				stmt.bind(params as BindParams);
+				const rows: unknown[] = [];
+				if (mode === 'arrays') {
+					while (stmt.step()) {
+						rows.push(stmt.get());
+					}
+				} else {
+					while (stmt.step()) {
+						rows.push(stmt.getAsObject());
+					}
+				}
+
+				stmt.free();
+				return rows;
+			},
+			get: (params) => {
+				const stmt = this.client.prepare(query.sql);
+				stmt.bind(params as BindParams);
+				let row;
+				if (stmt.step()) {
+					row = mode === 'arrays' ? stmt.get() : stmt.getAsObject();
+				}
+
+				stmt.free();
+				return row;
+			},
+			run: (params) => {
+				const stmt = this.client.prepare(query.sql);
+				const res = stmt.run(params as BindParams);
+				stmt.free();
+
+				return res;
+			},
+			values: (params) => {
+				const stmt = this.client.prepare(query.sql);
+				stmt.bind(params as BindParams);
+				const rows: unknown[] = [];
+				while (stmt.step()) {
+					rows.push(stmt.get());
+				}
+
+				stmt.free();
+				return rows;
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'sync',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			undefined,
+			queryMetadata,
+			undefined,
+		);
 	}
 
 	override transaction<T>(
-		transaction: (tx: SQLJsTransaction<TFullSchema, TSchema>) => T,
+		transaction: (tx: SQLJsTransaction<TRelations>) => T,
 		config: SQLiteTransactionConfig = {},
 	): T {
-		const tx = new SQLJsTransaction('sync', this.dialect, this, this.schema);
+		const tx = new SQLJsTransaction('sync', this.dialect, this, this.relations);
 		this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ''}`));
 		try {
 			const result = transaction(tx);
@@ -65,147 +131,33 @@ export class SQLJsSession<
 	}
 }
 
-export class SQLJsTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'sync', void, TFullSchema, TSchema> {
+export class SQLJsTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'sync', SQLJsRunResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SQLJsTransaction';
 
-	override transaction<T>(transaction: (tx: SQLJsTransaction<TFullSchema, TSchema>) => T): T {
+	override transaction<T>(
+		transaction: (
+			tx: SQLJsTransaction<TRelations>,
+		) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!">
+			: T,
+	): T {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new SQLJsTransaction('sync', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new SQLJsTransaction(
+			'sync',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		tx.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = transaction(tx);
 			tx.run(sql.raw(`release savepoint ${savepointName}`));
-			return result;
+			return result as T;
 		} catch (err) {
 			tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
 			throw err;
 		}
 	}
 }
-
-export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<
-	{ type: 'sync'; run: void; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'SQLJsPreparedQuery';
-
-	constructor(
-		private client: Database,
-		query: Query,
-		private logger: Logger,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
-	) {
-		super('sync', executeMethod, query);
-	}
-
-	run(placeholderValues?: Record<string, unknown>): void {
-		const stmt = this.client.prepare(this.query.sql);
-
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		const result = stmt.run(params as BindParams);
-
-		stmt.free();
-
-		return result;
-	}
-
-	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const stmt = this.client.prepare(this.query.sql);
-
-		const { fields, joinsNotNullableMap, logger, query, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(query.params, placeholderValues ?? {});
-			logger.logQuery(query.sql, params);
-			stmt.bind(params as BindParams);
-			const rows: unknown[] = [];
-			while (stmt.step()) {
-				rows.push(stmt.getAsObject());
-			}
-
-			stmt.free();
-
-			return rows;
-		}
-
-		const rows = this.values(placeholderValues) as unknown[][];
-
-		if (customResultMapper) {
-			return customResultMapper(rows, normalizeFieldValue) as T['all'];
-		}
-
-		return rows.map((row) => mapResultRow(fields!, row.map((v) => normalizeFieldValue(v)), joinsNotNullableMap));
-	}
-
-	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const stmt = this.client.prepare(this.query.sql);
-
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, joinsNotNullableMap, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			const result = stmt.getAsObject(params as BindParams);
-
-			stmt.free();
-
-			return result;
-		}
-
-		const row = stmt.get(params as BindParams);
-
-		stmt.free();
-
-		if (!row || (row.length === 0 && fields!.length > 0)) {
-			return undefined;
-		}
-
-		if (customResultMapper) {
-			return customResultMapper([row], normalizeFieldValue) as T['get'];
-		}
-
-		return mapResultRow(fields!, row.map((v) => normalizeFieldValue(v)), joinsNotNullableMap);
-	}
-
-	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const stmt = this.client.prepare(this.query.sql);
-
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		stmt.bind(params as BindParams);
-		const rows: unknown[] = [];
-		while (stmt.step()) {
-			rows.push(stmt.get());
-		}
-
-		stmt.free();
-
-		return rows;
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
-function normalizeFieldValue(value: unknown) {
-	if (value instanceof Uint8Array) { // eslint-disable-line no-instanceof/no-instanceof
-		if (typeof Buffer !== 'undefined') {
-			if (!(value instanceof Buffer)) { // eslint-disable-line no-instanceof/no-instanceof
-				return Buffer.from(value);
-			}
-			return value;
-		}
-		if (typeof TextDecoder !== 'undefined') {
-			return new TextDecoder().decode(value);
-		}
-		throw new Error('TextDecoder is not available. Please provide either Buffer or TextDecoder polyfill.');
-	}
-	return value;
-}
diff --git a/drizzle-orm/src/sql/expressions/conditions.ts b/drizzle-orm/src/sql/expressions/conditions.ts
index 506e082396..9bd7f3eb1c 100644
--- a/drizzle-orm/src/sql/expressions/conditions.ts
+++ b/drizzle-orm/src/sql/expressions/conditions.ts
@@ -119,7 +119,7 @@ export function and(
 
 	return new SQL([
 		new StringChunk('('),
-		sql.join(conditions, new StringChunk(' and ')),
+		sql.join(conditions.map((c) => sql`(${c})`), new StringChunk(' and ')),
 		new StringChunk(')'),
 	]);
 }
@@ -158,7 +158,7 @@ export function or(
 
 	return new SQL([
 		new StringChunk('('),
-		sql.join(conditions, new StringChunk(' or ')),
+		sql.join(conditions.map((c) => sql`(${c})`), new StringChunk(' or ')),
 		new StringChunk(')'),
 	]);
 }
@@ -175,7 +175,7 @@ export function or(
  * ```
  */
 export function not(condition: SQLWrapper): SQL {
-	return sql`not ${condition}`;
+	return is(condition, SQL) ? sql`not (${condition})` : sql`not ${condition}`;
 }
 
 /**
@@ -350,7 +350,7 @@ export function notInArray(
  * @see isNotNull for the inverse of this test
  */
 export function isNull(value: SQLWrapper): SQL {
-	return sql`${value} is null`;
+	return sql`(${value} is null)`;
 }
 
 /**
@@ -370,7 +370,7 @@ export function isNull(value: SQLWrapper): SQL {
  * @see isNull for the inverse of this test
  */
 export function isNotNull(value: SQLWrapper): SQL {
-	return sql`${value} is not null`;
+	return sql`(${value} is not null)`;
 }
 
 /**
@@ -526,7 +526,7 @@ export function notBetween(
  *
  * @see ilike for a case-insensitive version of this condition
  */
-export function like(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL {
+export function like(column: Column | SQL.Aliased | SQL | SQLWrapper, value: string | SQLWrapper): SQL {
 	return sql`${column} like ${value}`;
 }
 
@@ -548,7 +548,7 @@ export function like(column: Column | SQL.Aliased | SQL, value: string | SQLWrap
  * @see like for the inverse condition
  * @see notIlike for a case-insensitive version of this condition
  */
-export function notLike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL {
+export function notLike(column: Column | SQL.Aliased | SQL | SQLWrapper, value: string | SQLWrapper): SQL {
 	return sql`${column} not like ${value}`;
 }
 
@@ -571,7 +571,7 @@ export function notLike(column: Column | SQL.Aliased | SQL, value: string | SQLW
  *
  * @see like for a case-sensitive version of this condition
  */
-export function ilike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL {
+export function ilike(column: Column | SQL.Aliased | SQL | SQLWrapper, value: string | SQLWrapper): SQL {
 	return sql`${column} ilike ${value}`;
 }
 
@@ -593,7 +593,7 @@ export function ilike(column: Column | SQL.Aliased | SQL, value: string | SQLWra
  * @see ilike for the inverse condition
  * @see notLike for a case-sensitive version of this condition
  */
-export function notIlike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL {
+export function notIlike(column: Column | SQL.Aliased | SQL | SQLWrapper, value: string | SQLWrapper): SQL {
 	return sql`${column} not ilike ${value}`;
 }
 
@@ -637,7 +637,8 @@ export function arrayContains(
 		if (values.length === 0) {
 			throw new Error('arrayContains requires at least one value');
 		}
-		const array = sql`${bindIfParam(values, column)}`;
+		const par = bindIfParam(values, column);
+		const array = sql`${Array.isArray(par) ? new Param(par) : par}`;
 		return sql`${column} @> ${array}`;
 	}
 
@@ -685,7 +686,8 @@ export function arrayContained(
 		if (values.length === 0) {
 			throw new Error('arrayContained requires at least one value');
 		}
-		const array = sql`${bindIfParam(values, column)}`;
+		const par = bindIfParam(values, column);
+		const array = sql`${Array.isArray(par) ? new Param(par) : par}`;
 		return sql`${column} <@ ${array}`;
 	}
 
@@ -732,7 +734,8 @@ export function arrayOverlaps(
 		if (values.length === 0) {
 			throw new Error('arrayOverlaps requires at least one value');
 		}
-		const array = sql`${bindIfParam(values, column)}`;
+		const par = bindIfParam(values, column);
+		const array = sql`${Array.isArray(par) ? new Param(par) : par}`;
 		return sql`${column} && ${array}`;
 	}
 
diff --git a/drizzle-orm/src/sql/sql.ts b/drizzle-orm/src/sql/sql.ts
index 994acf4faa..aae856b84d 100644
--- a/drizzle-orm/src/sql/sql.ts
+++ b/drizzle-orm/src/sql/sql.ts
@@ -1,14 +1,14 @@
-import type { CasingCache } from '~/casing.ts';
+import type { CodecsCollection } from '~/codecs.ts';
 import { entityKind, is } from '~/entity.ts';
-import { isPgEnum } from '~/pg-core/columns/enum.ts';
 import type { SelectResult } from '~/query-builders/select.types.ts';
 import { Subquery } from '~/subquery.ts';
+import { TableName } from '~/table.utils.ts';
 import { tracer } from '~/tracing.ts';
 import type { Assume, Equal } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { AnyColumn } from '../column.ts';
 import { Column } from '../column.ts';
-import { IsAlias, Table } from '../table.ts';
+import { IsAlias, OriginalName, Table, TableColumns, TableSchema } from '../table.ts';
 
 /**
  * This class is used to indicate a primitive param value that is used in `sql` tag.
@@ -30,25 +30,22 @@ export type Chunk =
 	| SQL;
 
 export interface BuildQueryConfig {
-	casing: CasingCache;
 	escapeName(name: string): string;
 	escapeParam(num: number, value: unknown): string;
 	escapeString(str: string): string;
-	prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
+	codecs?: CodecsCollection;
 	paramStartIndex?: { value: number };
 	inlineParams?: boolean;
-	invokeSource?: 'indexes' | undefined;
+	invokeSource?: 'indexes' | 'mssql-check' | 'mssql-view-with-schemabinding' | undefined;
+	tagged?: true;
 }
 
-export type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
-
 export interface Query {
 	sql: string;
 	params: unknown[];
-}
-
-export interface QueryWithTypings extends Query {
-	typings?: QueryTypingsValue[];
+	_sql?: TemplateStringsArray;
+	// ^ TODO: revisit
+	// for Bun.SQL cache performance
 }
 
 /**
@@ -62,8 +59,8 @@ export interface QueryWithTypings extends Query {
  * - `Placeholder`
  * - `Param`
  */
-export interface SQLWrapper {
-	getSQL(): SQL;
+export interface SQLWrapper<T = unknown> {
+	getSQL(): SQL<T>;
 	shouldOmitSQLParens?(): boolean;
 }
 
@@ -71,21 +68,26 @@ export function isSQLWrapper(value: unknown): value is SQLWrapper {
 	return value !== null && value !== undefined && typeof (value as any).getSQL === 'function';
 }
 
-function mergeQueries(queries: QueryWithTypings[]): QueryWithTypings {
-	const result: QueryWithTypings = { sql: '', params: [] };
+function mergeQueries(queries: Query[]): Query {
+	const result: Query = { sql: '', params: [] };
 	for (const query of queries) {
 		result.sql += query.sql;
 		result.params.push(...query.params);
-		if (query.typings?.length) {
-			if (!result.typings) {
-				result.typings = [];
-			}
-			result.typings.push(...query.typings);
-		}
 	}
 	return result;
 }
 
+function _mergeQueries(queries: Query[]): Query {
+	const result: Query = { sql: '', params: [] };
+	const sqls = [] as string[];
+	for (const query of queries) {
+		sqls.push(query.sql);
+		result.params.push(...query.params);
+	}
+	result._sql = Object.assign(sqls, { raw: sqls }) as unknown as TemplateStringsArray;
+	return result;
+}
+
 export class StringChunk implements SQLWrapper {
 	static readonly [entityKind]: string = 'StringChunk';
 
@@ -100,7 +102,7 @@ export class StringChunk implements SQLWrapper {
 	}
 }
 
-export class SQL<T = unknown> implements SQLWrapper {
+export class SQL<T = unknown> implements SQLWrapper<T> {
 	static readonly [entityKind]: string = 'SQL';
 
 	declare _: {
@@ -110,7 +112,8 @@ export class SQL<T = unknown> implements SQLWrapper {
 
 	/** @internal */
 	decoder: DriverValueDecoder<T, any> = noopDecoder;
-	private shouldInlineParams = false;
+	/** @internal */
+	public shouldInlineParams = false;
 
 	/** @internal */
 	usedTables: string[] = [];
@@ -134,7 +137,7 @@ export class SQL<T = unknown> implements SQLWrapper {
 		return this;
 	}
 
-	toQuery(config: BuildQueryConfig): QueryWithTypings {
+	toQuery(config: BuildQueryConfig): Query {
 		return tracer.startActiveSpan('drizzle.buildSQL', (span) => {
 			const query = this.buildQueryFromSourceParams(this.queryChunks, config);
 			span?.setAttributes({
@@ -152,15 +155,15 @@ export class SQL<T = unknown> implements SQLWrapper {
 		});
 
 		const {
-			casing,
 			escapeName,
 			escapeParam,
-			prepareTyping,
+			codecs,
 			inlineParams,
 			paramStartIndex,
+			invokeSource,
 		} = config;
 
-		return mergeQueries(chunks.map((chunk): QueryWithTypings => {
+		const mappedChunks = chunks.map((chunk): Query => {
 			if (is(chunk, StringChunk)) {
 				return { sql: chunk.value.join(''), params: [] };
 			}
@@ -195,6 +198,15 @@ export class SQL<T = unknown> implements SQLWrapper {
 			if (is(chunk, Table)) {
 				const schemaName = chunk[Table.Symbol.Schema];
 				const tableName = chunk[Table.Symbol.Name];
+
+				if (invokeSource === 'mssql-view-with-schemabinding') {
+					return {
+						sql: (schemaName === undefined ? escapeName('dbo') : escapeName(schemaName)) + '.'
+							+ escapeName(tableName),
+						params: [],
+					};
+				}
+
 				return {
 					sql: schemaName === undefined || chunk[IsAlias]
 						? escapeName(tableName)
@@ -204,14 +216,14 @@ export class SQL<T = unknown> implements SQLWrapper {
 			}
 
 			if (is(chunk, Column)) {
-				const columnName = casing.getColumnCasing(chunk);
+				const columnName = chunk.name;
 				if (_config.invokeSource === 'indexes') {
 					return { sql: escapeName(columnName), params: [] };
 				}
 
-				const schemaName = chunk.table[Table.Symbol.Schema];
+				const schemaName = invokeSource === 'mssql-check' ? undefined : chunk.table[Table.Symbol.Schema];
 				return {
-					sql: chunk.table[IsAlias] || schemaName === undefined
+					sql: chunk.isAlias ? escapeName(chunk.name) : chunk.table[IsAlias] || schemaName === undefined
 						? escapeName(chunk.table[Table.Symbol.Name]) + '.' + escapeName(columnName)
 						: escapeName(schemaName) + '.' + escapeName(chunk.table[Table.Symbol.Name]) + '.'
 							+ escapeName(columnName),
@@ -231,34 +243,68 @@ export class SQL<T = unknown> implements SQLWrapper {
 			}
 
 			if (is(chunk, Param)) {
+				if (is(chunk.value, SQL)) {
+					return this.buildQueryFromSourceParams([chunk.value], config);
+				}
+
+				const useCodecs = codecs && is(chunk.encoder, Column);
+
 				if (is(chunk.value, Placeholder)) {
-					return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ['none'] };
+					const escaped = escapeParam(paramStartIndex.value++, chunk);
+					chunk.codec = useCodecs
+						? (value) => codecs.apply(chunk.encoder as Column, 'normalizeParam', value)
+						: undefined;
+					return {
+						sql: useCodecs
+							? codecs.apply(chunk.encoder, 'castParam', escaped)
+							: escaped,
+						params: [chunk],
+					};
 				}
 
-				const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+				let mappedValue: any;
+				if (chunk.value === null) {
+					mappedValue = chunk.value;
+				} else {
+					mappedValue = chunk.encoder.mapToDriverValue.isNoop
+						? chunk.value
+						: chunk.encoder.mapToDriverValue(chunk.value);
 
-				if (is(mappedValue, SQL)) {
-					return this.buildQueryFromSourceParams([mappedValue], config);
+					if (is(mappedValue, SQL)) {
+						return this.buildQueryFromSourceParams([mappedValue], config);
+					}
+
+					if (useCodecs) {
+						mappedValue = codecs.apply(
+							chunk.encoder,
+							'normalizeParam',
+							mappedValue,
+						);
+					}
 				}
 
 				if (inlineParams) {
 					return { sql: this.mapInlineParam(mappedValue, config), params: [] };
 				}
 
-				let typings: QueryTypingsValue[] = ['none'];
-				if (prepareTyping) {
-					typings = [prepareTyping(chunk.encoder)];
-				}
-
-				return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+				const escaped = escapeParam(paramStartIndex.value++, mappedValue);
+				return {
+					sql: useCodecs
+						? codecs.apply(chunk.encoder, 'castParam', escaped)
+						: escaped,
+					params: [mappedValue],
+				};
 			}
 
 			if (is(chunk, Placeholder)) {
-				return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ['none'] };
+				return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
 			}
 
 			if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-				return { sql: escapeName(chunk.fieldAlias), params: [] };
+				return {
+					sql: (chunk.origin !== undefined ? escapeName(chunk.origin) + '.' : '') + escapeName(chunk.fieldAlias),
+					params: [],
+				};
 			}
 
 			if (is(chunk, Subquery)) {
@@ -273,11 +319,11 @@ export class SQL<T = unknown> implements SQLWrapper {
 				], config);
 			}
 
-			if (isPgEnum(chunk)) {
-				if (chunk.schema) {
-					return { sql: escapeName(chunk.schema) + '.' + escapeName(chunk.enumName), params: [] };
+			if (typeof chunk === 'function' && 'enumName' in chunk) {
+				if ('schema' in chunk && chunk.schema) {
+					return { sql: escapeName(chunk.schema as string) + '.' + escapeName(chunk.enumName as string), params: [] };
 				}
-				return { sql: escapeName(chunk.enumName), params: [] };
+				return { sql: escapeName(chunk.enumName as string), params: [] };
 			}
 
 			if (isSQLWrapper(chunk)) {
@@ -295,8 +341,14 @@ export class SQL<T = unknown> implements SQLWrapper {
 				return { sql: this.mapInlineParam(chunk, config), params: [] };
 			}
 
-			return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ['none'] };
-		}));
+			return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
+		});
+
+		if (_config.tagged) {
+			return _mergeQueries(mappedChunks);
+		}
+
+		return mergeQueries(mappedChunks);
 	}
 
 	private mapInlineParam(
@@ -306,7 +358,7 @@ export class SQL<T = unknown> implements SQLWrapper {
 		if (chunk === null) {
 			return 'null';
 		}
-		if (typeof chunk === 'number' || typeof chunk === 'boolean') {
+		if (typeof chunk === 'number' || typeof chunk === 'boolean' || typeof chunk === 'bigint') {
 			return chunk.toString();
 		}
 		if (typeof chunk === 'string') {
@@ -322,7 +374,7 @@ export class SQL<T = unknown> implements SQLWrapper {
 		throw new Error('Unexpected param value: ' + chunk);
 	}
 
-	getSQL(): SQL {
+	getSQL(): SQL<T> {
 		return this;
 	}
 
@@ -348,11 +400,20 @@ export class SQL<T = unknown> implements SQLWrapper {
 
 	mapWith<
 		TDecoder extends
-			| DriverValueDecoder<any, any>
-			| DriverValueDecoder<any, any>['mapFromDriverValue'],
-	>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>> {
+			| DriverValueDecoder<any, Exclude<T, null>>
+			| DriverValueDecoder<any, Exclude<T, null>>['mapFromDriverValue'],
+	>(
+		decoder: TDecoder,
+	): Equal<T, unknown> extends true ? SQL<GetDecoderResult<TDecoder>>
+		: Equal<T, any> extends true ? SQL<GetDecoderResult<TDecoder>>
+		: SQL<GetDecoderResult<TDecoder> | (null extends T ? null : never)>
+	{
 		this.decoder = typeof decoder === 'function' ? { mapFromDriverValue: decoder } : decoder;
-		return this as SQL<GetDecoderResult<TDecoder>>;
+		return this as SQL<any>;
+	}
+
+	nullable(): SQL<T | null> {
+		return this;
 	}
 
 	inlineParams(): this {
@@ -399,12 +460,24 @@ export function name(value: string): Name {
 	return new Name(value);
 }
 
+export interface DriverValueDecoderFn<TData, TDriverParam> {
+	(value: TDriverParam): TData;
+	/** @internal */
+	isNoop?: true | undefined;
+}
+
 export interface DriverValueDecoder<TData, TDriverParam> {
-	mapFromDriverValue(value: TDriverParam): TData;
+	mapFromDriverValue: DriverValueDecoderFn<TData, TDriverParam>;
+}
+
+export interface DriverValueEncoderFn<TData, TDriverParam> {
+	(value: TData): TDriverParam;
+	/** @internal */
+	isNoop?: true | undefined;
 }
 
 export interface DriverValueEncoder<TData, TDriverParam> {
-	mapToDriverValue(value: TData): TDriverParam | SQL;
+	mapToDriverValue: DriverValueEncoderFn<TData, TDriverParam>;
 }
 
 export function isDriverValueEncoder(value: unknown): value is DriverValueEncoder<any, any> {
@@ -416,21 +489,29 @@ export const noopDecoder: DriverValueDecoder<any, any> = {
 	mapFromDriverValue: (value) => value,
 };
 
+noopDecoder.mapFromDriverValue.isNoop = true;
+
 export const noopEncoder: DriverValueEncoder<any, any> = {
 	mapToDriverValue: (value) => value,
 };
 
+noopEncoder.mapToDriverValue.isNoop = true;
+
 export interface DriverValueMapper<TData, TDriverParam>
 	extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam>
 {}
 
+export function isNoop(mapper: DriverValueEncoderFn<any, any> | DriverValueDecoderFn<any, any>) {
+	return mapper.isNoop;
+}
+
 export const noopMapper: DriverValueMapper<any, any> = {
 	...noopDecoder,
 	...noopEncoder,
 };
 
 /** Parameter value that is optionally bound to an encoder (for example, a column). */
-export class Param<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
+export class Param<TDataType = any, TDriverParamType = TDataType> implements SQLWrapper {
 	static readonly [entityKind]: string = 'Param';
 
 	protected brand!: 'BoundParamValue';
@@ -440,8 +521,9 @@ export class Param<TDataType = unknown, TDriverParamType = TDataType> implements
 	 * @param encoder - Encoder to convert the value to a driver parameter
 	 */
 	constructor(
-		readonly value: TDataType,
+		readonly value: TDataType | Placeholder<string, TDataType>,
 		readonly encoder: DriverValueEncoder<TDataType, TDriverParamType> = noopEncoder,
+		public codec?: (value: any) => any,
 	) {}
 
 	getSQL(): SQL<unknown> {
@@ -475,6 +557,8 @@ export type SQLChunk =
 	| FakePrimitiveParam
 	| Placeholder;
 
+export type SQLGenerator<T = unknown> = typeof sql<T>;
+
 export function sql<T>(strings: TemplateStringsArray, ...params: any[]): SQL<T>;
 /*
 	The type of `params` is specified as `SQLChunk[]`, but that's slightly incorrect -
@@ -557,15 +641,92 @@ export namespace sql {
 	}
 
 	export function param<TData, TDriver>(
-		value: TData,
+		value: TData | Placeholder<string, TData>,
 		encoder?: DriverValueEncoder<TData, TDriver>,
 	): Param<TData, TDriver> {
 		return new Param(value, encoder);
 	}
+
+	/**
+	 * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+	 */
+	export function comment(input: CommentInput): SQL | undefined {
+		const encoded = sqlCommenter(input);
+		if (!encoded.length) return undefined;
+
+		return sql.raw(encoded);
+	}
+}
+
+export function sqlCommenter(input: CommentInput): string {
+	const encoded = sqlCommenter.encodeInput(input);
+	if (!encoded.length) return '';
+
+	return `/*${encoded}*/`;
+}
+
+export namespace sqlCommenter {
+	export function merge(input1: CommentInput | undefined, input2: CommentInput | undefined) {
+		let encoded: CommentInput;
+		if (typeof input1 === 'object' && typeof input2 === 'object') {
+			encoded = encodeInput({ ...input1, ...input2 });
+		} else if (input1 && input2) {
+			encoded = [encodeInput(input1), encodeInput(input2)].filter((i) => i.length).join(',');
+		} else if (input2) {
+			encoded = encodeInput(input2);
+		} else if (input1) {
+			encoded = encodeInput(input1);
+		} else {
+			return '';
+		}
+
+		if (!encoded.length) return '';
+
+		return `/*${encoded}*/`;
+	}
+
+	export function encodeInput(input: CommentInput): string {
+		if (typeof input === 'string') {
+			if (!input.length) return input;
+
+			return sanitizeStringInput(input);
+		}
+
+		const parts: string[] = [];
+
+		for (const [key, value] of Object.entries(input)) {
+			if (value === null || value === undefined || value === '') continue;
+
+			const encodedKey = sanitizeObjectElement(key);
+			const encodedValue = sanitizeObjectElement(String(value));
+
+			parts.push(`${encodedKey}='${encodedValue}'`);
+		}
+
+		if (!parts.length) return '';
+
+		return parts.sort().join(',');
+	}
+
+	export function sanitizeObjectElement(key: string): string {
+		const urlEncoded = encodeURIComponent(key);
+		return urlEncoded.replace(/'/g, `\\'`);
+	}
+
+	export function sanitizeStringInput(input: string): string {
+		return input.replace(/\/\*/g, '/ *').replace(/\*\//g, '* /');
+	}
 }
 
+export type CommentInput = string | SqlCommenterInput;
+
+export type SqlCommenterInput = Record<
+	string,
+	string | number | bigint | boolean | null | undefined
+>;
+
 export namespace SQL {
-	export class Aliased<T = unknown> implements SQLWrapper {
+	export class Aliased<T = unknown> implements SQLWrapper<T> {
 		static readonly [entityKind]: string = 'SQL.Aliased';
 
 		declare _: {
@@ -575,19 +736,21 @@ export namespace SQL {
 
 		/** @internal */
 		isSelectionField = false;
+		/** @internal */
+		origin?: string;
 
 		constructor(
-			readonly sql: SQL,
+			readonly sql: SQL<T>,
 			readonly fieldAlias: string,
 		) {}
 
-		getSQL(): SQL {
-			return this.sql;
+		getSQL(): SQL<T> {
+			return this.sql as SQL<T>;
 		}
 
 		/** @internal */
 		clone() {
-			return new Aliased(this.sql, this.fieldAlias);
+			return new Aliased<T>(this.sql, this.fieldAlias);
 		}
 	}
 }
@@ -624,7 +787,14 @@ export function fillPlaceholders(params: unknown[], values: Record<string, unkno
 				throw new Error(`No value for placeholder "${p.value.name}" was provided`);
 			}
 
-			return p.encoder.mapToDriverValue(values[p.value.name]);
+			const value = values[p.value.name];
+			if (value === null) return value;
+
+			const mapped = p.encoder.mapToDriverValue.isNoop
+				? value
+				: p.encoder.mapToDriverValue(value);
+
+			return p.codec ? p.codec(mapped) : mapped;
 		}
 
 		return p;
@@ -639,7 +809,7 @@ export abstract class View<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
 	TSelection extends ColumnsSelection = ColumnsSelection,
-> implements SQLWrapper {
+> {
 	static readonly [entityKind]: string = 'View';
 
 	declare _: {
@@ -664,6 +834,31 @@ export abstract class View<
 	/** @internal */
 	[IsDrizzleView] = true;
 
+	/** @internal */
+	public get [TableName]() {
+		return this[ViewBaseConfig].name;
+	}
+
+	/** @internal */
+	public get [TableSchema]() {
+		return this[ViewBaseConfig].schema;
+	}
+
+	/** @internal */
+	public get [IsAlias]() {
+		return this[ViewBaseConfig].isAlias;
+	}
+
+	/** @internal */
+	public get [OriginalName]() {
+		return this[ViewBaseConfig].originalName;
+	}
+
+	/** @internal */
+	public get [TableColumns]() {
+		return (this[ViewBaseConfig].selectedFields) as any as Record<string, unknown>;
+	}
+
 	declare readonly $inferSelect: InferSelectViewModel<View<Assume<TName, string>, TExisting, TSelection>>;
 
 	constructor(
@@ -684,10 +879,6 @@ export abstract class View<
 			isAlias: false,
 		};
 	}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
 }
 
 export function isView(view: unknown): view is View {
@@ -710,13 +901,9 @@ export type InferSelectViewModel<TView extends View> =
 Column.prototype.getSQL = function() {
 	return new SQL([this]);
 };
-
-// Defined separately from the Table class to resolve circular dependency
-Table.prototype.getSQL = function() {
-	return new SQL([this]);
-};
-
-// Defined separately from the Column class to resolve circular dependency
+// Defined separately from the Subquery class to resolve circular dependency
 Subquery.prototype.getSQL = function() {
 	return new SQL([this]);
 };
+
+export type SQLEntity = SQL | SQLWrapper | SQL.Aliased | Table | View;
diff --git a/drizzle-orm/src/sqlite-cloud/driver.ts b/drizzle-orm/src/sqlite-cloud/driver.ts
new file mode 100644
index 0000000000..b874bd4a49
--- /dev/null
+++ b/drizzle-orm/src/sqlite-cloud/driver.ts
@@ -0,0 +1,105 @@
+import { Database } from '@sqlitecloud/drivers';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { SQLiteCloudSession } from './session.ts';
+
+export type SQLiteCloudRunResult = unknown;
+
+export class SQLiteCloudDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', SQLiteCloudRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLiteCloudDatabase';
+
+	/** @internal */
+	declare readonly session: SQLiteCloudSession<TRelations>;
+}
+
+/** @internal */
+export function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: Database,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): SQLiteCloudDatabase<TRelations> & {
+	$client: Database;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new SQLiteCloudSession(
+		client,
+		dialect,
+		relations,
+		{ logger, cache: config.cache },
+	);
+	const db = new SQLiteCloudDatabase('async', dialect, session, relations);
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+	return db as any;
+}
+
+export type DatabaseOpts = (Database extends { new(path: string, opts: infer D): any } ? D : any) & {
+	path: string;
+};
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | DatabaseOpts;
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): SQLiteCloudDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new Database(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: DatabaseOpts; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
+
+	const instance = typeof connection === 'string'
+		? new Database(connection)
+		: new Database(connection.path, connection);
+
+	return construct(instance, DrizzleSQLiteConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): SQLiteCloudDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/sqlite-cloud/index.ts b/drizzle-orm/src/sqlite-cloud/index.ts
new file mode 100644
index 0000000000..b1b6a52e71
--- /dev/null
+++ b/drizzle-orm/src/sqlite-cloud/index.ts
@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/sqlite-cloud/migrator.ts b/drizzle-orm/src/sqlite-cloud/migrator.ts
new file mode 100644
index 0000000000..709e362b33
--- /dev/null
+++ b/drizzle-orm/src/sqlite-cloud/migrator.ts
@@ -0,0 +1,96 @@
+import type { MigrationConfig, MigratorInitFailResponse } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type SQL, sql } from '~/sql/sql.ts';
+import { upgradeAsyncIfNeeded } from '~/up-migrations/sqlite.ts';
+import type { SQLiteCloudDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: SQLiteCloudDatabase<TRelations>,
+	config: MigrationConfig,
+): Promise<void | MigratorInitFailResponse> {
+	const migrations = readMigrationFiles(config);
+	const { session } = db;
+
+	const migrationsTable = config === undefined
+		? '__drizzle_migrations'
+		: typeof config === 'string'
+		? '__drizzle_migrations'
+		: config.migrationsTable ?? '__drizzle_migrations';
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeAsyncIfNeeded(migrationsTable, db, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id INTEGER PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric,
+				name text,
+				applied_at TEXT
+		)
+		`;
+		await session.run(migrationTableCreate);
+	}
+
+	const dbMigrations = await session.objects<{ id: number; hash: string; created_at: string; name: string | null }>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await session.run(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`
+				.inlineParams(),
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	await session.run(sql`BEGIN TRANSACTION`);
+	try {
+		const stmts = sql.join(
+			migrationsToRun.reduce(
+				(statements, migration) => {
+					statements.push(
+						sql.raw(migration.sql.join('')),
+						sql`INSERT INTO ${
+							sql.identifier(migrationsTable)
+						} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+							new Date().toISOString()
+						});`
+							.inlineParams(),
+					);
+
+					return statements;
+				},
+				[] as SQL[],
+			),
+		);
+
+		await session.run(stmts);
+
+		await session.run(sql`COMMIT`);
+	} catch (error) {
+		await session.run(sql`ROLLBACK`);
+		throw error;
+	}
+}
diff --git a/drizzle-orm/src/sqlite-cloud/session.ts b/drizzle-orm/src/sqlite-cloud/session.ts
new file mode 100644
index 0000000000..c4ac2ebd79
--- /dev/null
+++ b/drizzle-orm/src/sqlite-cloud/session.ts
@@ -0,0 +1,188 @@
+import type { Database, SQLiteCloudRow, SQLiteCloudRowset } from '@sqlitecloud/drivers';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import { DrizzleQueryError } from '~/errors.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { SQLiteCloudRunResult } from './driver.ts';
+
+export interface SQLiteCloudSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class SQLiteCloudSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', SQLiteCloudRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLiteCloudSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		private client: Database,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: SQLiteCloudSessionOptions,
+	) {
+		super(dialect, 'async');
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<T & { run: SQLiteCloudRunResult }> {
+		let stmt: ReturnType<typeof this.client.prepare>;
+		try {
+			stmt = this.client.prepare(query.sql);
+		} catch (e) {
+			throw new DrizzleQueryError(query.sql, query.params, e as Error);
+		}
+
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) => {
+				if (mode === 'arrays') {
+					return new Promise<any>((resolve, reject) => {
+						(params.length ? stmt.bind(...params) : stmt).all((e: Error | null, d: SQLiteCloudRowset) => {
+							if (e) return reject(e);
+
+							return (resolve(d.map((v) => v.getData())));
+						});
+					});
+				}
+				return new Promise<any>((resolve, reject) => {
+					(params.length ? stmt.bind(...params) : stmt).all((e: Error | null, d: SQLiteCloudRowset) => {
+						if (e) return reject(e);
+
+						return resolve(d.map((v) => Object.fromEntries(Object.entries(v))));
+					});
+				});
+			},
+			get: (params) => {
+				if (mode === 'arrays') {
+					return new Promise<any>((resolve, reject) => {
+						(params.length ? stmt.bind(...params) : stmt).get((e: Error | null, d: SQLiteCloudRow | undefined) => {
+							if (e) return reject(e);
+
+							return resolve(d ? d.getData() : d);
+						});
+					});
+				}
+				return new Promise<any>((resolve, reject) => {
+					(params.length ? stmt.bind(...params) : stmt).get((e: Error | null, d: SQLiteCloudRow | undefined) => {
+						if (e) return reject(e);
+
+						return resolve(d ? Object.fromEntries(Object.entries(d)) : d);
+					});
+				});
+			},
+			run: (params) => {
+				return new Promise<any>((resolve, reject) => {
+					(params.length ? stmt.bind(...params) : stmt).run((e: Error | null, d: SQLiteCloudRowset) => {
+						if (e) return reject(e);
+
+						return resolve(d);
+					});
+				});
+			},
+			values: (params) => {
+				return new Promise<any>((resolve, reject) => {
+					(params.length ? stmt.bind(...params) : stmt).all((e: Error | null, d: SQLiteCloudRowset) => {
+						if (e) return reject(e);
+
+						return (resolve(d.map((v) => v.getData())));
+					});
+				});
+			},
+		};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (
+			tx: SQLiteCloudTransaction<TRelations>,
+		) => Promise<T>,
+		config?: SQLiteTransactionConfig,
+	): Promise<T> {
+		const tx = new SQLiteCloudTransaction(
+			'async',
+			this.dialect,
+			this,
+			this.relations,
+		);
+		await tx.run(sql`BEGIN${sql` ${sql.raw(config?.behavior ?? '')}`.if(config?.behavior)} TRANSACTION`);
+
+		try {
+			const result = await transaction(tx);
+			await tx.run(sql`COMMIT`);
+			return result;
+		} catch (err) {
+			await tx.run(sql`ROLLBACK`);
+			throw err;
+		}
+	}
+}
+
+export class SQLiteCloudTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', SQLiteCloudRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'SQLiteCloudTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: SQLiteCloudTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex}`;
+		const tx = new SQLiteCloudTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
+		await this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
diff --git a/drizzle-orm/src/sqlite-core/async/count.ts b/drizzle-orm/src/sqlite-core/async/count.ts
new file mode 100644
index 0000000000..fe79f7797e
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/count.ts
@@ -0,0 +1,64 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { ExecuteResultSync } from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteCountBuilder } from '~/sqlite-core/query-builders/count.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { SQLiteViewBase } from '~/sqlite-core/view-base.ts';
+import { applyMixins } from '~/utils.ts';
+import type { SQLiteAsyncSession } from './session.ts';
+
+export type SQLiteAsyncCountBuilderKind<TMode extends 'sync' | 'async'> = TMode extends 'async'
+	? SQLiteAsyncCountBuilder
+	: SQLiteSyncCountBuilder;
+
+// oxlint-disable-next-line no-unused-vars
+export interface SQLiteAsyncCountBuilder extends SQL<number>, SQLWrapper<number>, QueryPromise<number> {}
+
+export class SQLiteAsyncCountBuilder extends SQLiteCountBuilder {
+	static override readonly [entityKind]: string = 'SQLiteAsyncCountBuilder';
+
+	declare protected session: SQLiteAsyncSession<any, any, any>;
+
+	constructor(
+		countConfig: {
+			source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: SQLiteDialect;
+			session: SQLiteAsyncSession<any, any, any>;
+		},
+	) {
+		super(countConfig);
+	}
+
+	/** @internal */
+	executeRaw(placeholderValues?: Record<string, unknown>): Promise<number> | ExecuteResultSync<number> {
+		return this.session.prepareQuery(
+			this.build(),
+			'arrays',
+			false,
+			'all', // Do not use 'get' - mapper returns an item instead of an array, would break on session's destructuring; query itself is already aggregated into 1 item, so no performance overhead occurs.
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues) as any;
+	}
+
+	// async-await to avoid crashing when used on sync drivers with .then(), .catch() for compatibility
+	async execute(placeholderValues?: Record<string, unknown>): Promise<number> {
+		return await (this.executeRaw(placeholderValues));
+	}
+}
+
+applyMixins(SQLiteAsyncCountBuilder, [QueryPromise]);
+
+export class SQLiteSyncCountBuilder extends SQLiteAsyncCountBuilder {
+	static override readonly [entityKind]: string = 'SQLiteSyncCountBuilder';
+
+	sync(placeholderValues?: Record<string, unknown>): number {
+		return (this.executeRaw(placeholderValues) as ExecuteResultSync<number>).sync();
+	}
+}
diff --git a/drizzle-orm/src/sqlite-core/async/db.ts b/drizzle-orm/src/sqlite-core/async/db.ts
new file mode 100644
index 0000000000..bfe4d970cb
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/db.ts
@@ -0,0 +1,655 @@
+import type { Cache } from '~/cache/core/cache.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import { SQLiteAsyncDeleteBase } from '~/sqlite-core/async/delete.ts';
+import { SQLiteAsyncInsertBase, type SQLiteAsyncInsertBuilder } from '~/sqlite-core/async/insert.ts';
+import { type DBResult, SQLiteAsyncRaw } from '~/sqlite-core/async/raw.ts';
+import { SQLiteAsyncSelectBase, type SQLiteAsyncSelectBuilder } from '~/sqlite-core/async/select.ts';
+import type { Result, SQLiteAsyncSession, SQLiteAsyncTransaction } from '~/sqlite-core/async/session.ts';
+import { SQLiteAsyncUpdateBase, type SQLiteAsyncUpdateBuilder } from '~/sqlite-core/async/update.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	QueryBuilder,
+	SQLiteInsertBuilder,
+	SQLiteSelectBuilder,
+	SQLiteUpdateBuilder,
+} from '~/sqlite-core/query-builders/index.ts';
+import type { SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import { WithSubquery } from '~/subquery.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import { RelationalQueryBuilder } from '../query-builders/query.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
+import { SQLiteAsyncCountBuilder, type SQLiteAsyncCountBuilderKind, SQLiteSyncCountBuilder } from './count.ts';
+import { SQLiteAsyncRelationalQuery, type SQLiteAsyncRelationalQueryHKT, SQLiteSyncRelationalQuery } from './query.ts';
+
+export class SQLiteAsyncDatabase<
+	TResultKind extends 'sync' | 'async',
+	TRunResult,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'BaseSQLiteDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: SQLiteAsyncSession<TResultKind, TRunResult, TRelations>;
+		readonly resultKind: TResultKind;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			TResultKind,
+			TRelations,
+			TRelations[K],
+			SQLiteAsyncRelationalQueryHKT
+		>;
+	};
+
+	constructor(
+		private resultKind: TResultKind,
+		/** @internal */
+		readonly dialect: SQLiteDialect,
+		/** @internal */
+		readonly session: SQLiteAsyncSession<TResultKind, TRunResult, TRelations>,
+		relations: TRelations,
+		readonly forbidJsonb?: boolean,
+	) {
+		this._ = {
+			relations,
+			session,
+			resultKind,
+		};
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as SQLiteAsyncDatabase<
+				TResultKind,
+				TRunResult,
+				AnyRelations
+			>['query'])[tableName] = new RelationalQueryBuilder(
+				resultKind,
+				relations,
+				relations[relation.name]!.table as SQLiteTable,
+				relation,
+				dialect,
+				session as SQLiteAsyncSession<any, any, any>,
+				forbidJsonb,
+				resultKind === 'sync' ? SQLiteSyncRelationalQuery : SQLiteAsyncRelationalQuery,
+			);
+		}
+		this.$cache = { invalidate: async (_params: any) => {} };
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const self = this;
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(self.dialect));
+			}
+
+			return new Proxy(
+				new WithSubquery(
+					qb.getSQL(),
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	): SQLiteAsyncCountBuilderKind<TResultKind> {
+		return this.resultKind === 'async'
+			? new SQLiteAsyncCountBuilder({
+				source,
+				filters,
+				session: this.session,
+				dialect: this.dialect,
+			}) as SQLiteAsyncCountBuilderKind<TResultKind>
+			: new SQLiteSyncCountBuilder({
+				source,
+				filters,
+				session: this.session,
+				dialect: this.dialect,
+			});
+	}
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = await db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = await db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): SQLiteAsyncSelectBuilder<undefined, TResultKind, TRunResult>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): SQLiteAsyncSelectBuilder<TSelection, TResultKind, TRunResult>;
+		function select(
+			fields?: SelectedFields,
+		): SQLiteAsyncSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+			return new SQLiteSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			}, SQLiteAsyncSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * await db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * await db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): SQLiteAsyncSelectBuilder<undefined, TResultKind, TRunResult>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): SQLiteAsyncSelectBuilder<TSelection, TResultKind, TRunResult>;
+		function selectDistinct(
+			fields?: SelectedFields,
+		): SQLiteAsyncSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+			return new SQLiteSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			}, SQLiteAsyncSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * await db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 *
+		 * // Update with returning clause
+		 * const updatedCar: Car[] = await db.update(cars)
+		 *   .set({ color: 'red' })
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function update<TTable extends SQLiteTable>(
+			table: TTable,
+		): SQLiteAsyncUpdateBuilder<TTable, TResultKind, TRunResult> {
+			return new SQLiteUpdateBuilder(table, self.session, self.dialect, queries, SQLiteAsyncUpdateBase);
+		}
+
+		/**
+		 * Creates an insert query.
+		 *
+		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/insert}
+		 *
+		 * @param table The table to insert into.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Insert one row
+		 * await db.insert(cars).values({ brand: 'BMW' });
+		 *
+		 * // Insert multiple rows
+		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+		 *
+		 * // Insert with returning clause
+		 * const insertedCar: Car[] = await db.insert(cars)
+		 *   .values({ brand: 'BMW' })
+		 *   .returning();
+		 * ```
+		 */
+		function insert<TTable extends SQLiteTable>(
+			into: TTable,
+		): SQLiteAsyncInsertBuilder<TTable, TResultKind, TRunResult> {
+			return new SQLiteInsertBuilder(into, self.session, self.dialect, queries, SQLiteAsyncInsertBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * await db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * await db.delete(cars).where(eq(cars.color, 'green'));
+		 *
+		 * // Delete with returning clause
+		 * const deletedCar: Car[] = await db.delete(cars)
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function delete_<TTable extends SQLiteTable>(from: TTable): SQLiteAsyncDeleteBase<TTable, TResultKind, TRunResult> {
+			return new SQLiteAsyncDeleteBase(from, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, update, insert, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = await db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): SQLiteAsyncSelectBuilder<undefined, TResultKind, TRunResult>;
+	select<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SQLiteAsyncSelectBuilder<TSelection, TResultKind, TRunResult>;
+	select(fields?: SelectedFields): SQLiteAsyncSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+		return new SQLiteSelectBuilder(
+			{ fields: fields ?? undefined, session: this.session, dialect: this.dialect },
+			SQLiteAsyncSelectBase,
+		);
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * await db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * await db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): SQLiteAsyncSelectBuilder<undefined, TResultKind, TRunResult>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SQLiteAsyncSelectBuilder<TSelection, TResultKind, TRunResult>;
+	selectDistinct(
+		fields?: SelectedFields,
+	): SQLiteAsyncSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+		return new SQLiteSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		}, SQLiteAsyncSelectBase);
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * await db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 *
+	 * // Update with returning clause
+	 * const updatedCar: Car[] = await db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	update<TTable extends SQLiteTable>(table: TTable): SQLiteAsyncUpdateBuilder<TTable, TResultKind, TRunResult> {
+		return new SQLiteUpdateBuilder(table, this.session, this.dialect, undefined, SQLiteAsyncUpdateBase);
+	}
+
+	$cache: { invalidate: Cache['onMutate'] };
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * await db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 *
+	 * // Insert with returning clause
+	 * const insertedCar: Car[] = await db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 * ```
+	 */
+	insert<TTable extends SQLiteTable>(into: TTable): SQLiteAsyncInsertBuilder<TTable, TResultKind, TRunResult> {
+		return new SQLiteInsertBuilder(into, this.session, this.dialect, undefined, SQLiteAsyncInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * await db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * await db.delete(cars).where(eq(cars.color, 'green'));
+	 *
+	 * // Delete with returning clause
+	 * const deletedCar: Car[] = await db.delete(cars)
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	delete<TTable extends SQLiteTable>(from: TTable): SQLiteAsyncDeleteBase<TTable, TResultKind, TRunResult> {
+		return new SQLiteAsyncDeleteBase(from, this.session, this.dialect);
+	}
+
+	run(query: SQLWrapper | string): DBResult<TResultKind, TRunResult> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery(builtQuery, 'raw', false, 'run');
+		if (this.resultKind === 'async') {
+			return new SQLiteAsyncRaw(prepared, sequel, builtQuery) as DBResult<TResultKind, TRunResult>;
+		}
+		return this.session.run(sequel) as DBResult<TResultKind, TRunResult>;
+	}
+
+	all<T = unknown>(query: SQLWrapper | string): DBResult<TResultKind, T[]> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery(builtQuery, 'objects', false, 'all');
+		if (this.resultKind === 'async') {
+			return new SQLiteAsyncRaw(prepared, sequel, builtQuery) as DBResult<TResultKind, T[]>;
+		}
+		return this.session.objects(sequel) as DBResult<TResultKind, T[]>;
+	}
+
+	get<T = unknown>(query: SQLWrapper | string): DBResult<TResultKind, T> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery(builtQuery, 'objects', false, 'get');
+		if (this.resultKind === 'async') {
+			return new SQLiteAsyncRaw(prepared, sequel, builtQuery) as DBResult<TResultKind, T>;
+		}
+		return this.session.object(sequel) as DBResult<TResultKind, T>;
+	}
+
+	values<T extends unknown[] = unknown[]>(query: SQLWrapper | string): DBResult<TResultKind, T[]> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery(builtQuery, 'objects', false, 'values');
+		if (this.resultKind === 'async') {
+			return new SQLiteAsyncRaw(prepared, sequel, builtQuery) as DBResult<TResultKind, T[]>;
+		}
+		return this.session.arrays(sequel) as DBResult<TResultKind, T[]>;
+	}
+
+	transaction<T>(
+		transaction: (
+			tx: SQLiteAsyncTransaction<TResultKind, TRunResult, TRelations>,
+		) => TResultKind extends 'sync'
+			? T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T
+			: Result<TResultKind, T>,
+		config?: SQLiteTransactionConfig,
+	): Result<TResultKind, T> {
+		return this.session.transaction(
+			transaction as (
+				tx: SQLiteAsyncTransaction<TResultKind, TRunResult, TRelations>,
+			) => Result<TResultKind, T>,
+			config,
+		);
+	}
+}
+
+export type SQLiteWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	TResultKind extends 'sync' | 'async',
+	TRunResult,
+	TRelations extends AnyRelations,
+	Q extends SQLiteAsyncDatabase<
+		TResultKind,
+		TRunResult,
+		TRelations
+	>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): SQLiteWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const run: Q['run'] = (...args: [any]) => primary.run(...args);
+	const all: Q['all'] = (...args: [any]) => primary.all(...args);
+	const get: Q['get'] = (...args: [any]) => primary.get(...args);
+	const values: Q['values'] = (...args: [any]) => primary.values(...args);
+	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		run,
+		all,
+		get,
+		values,
+		transaction,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		$count,
+		with: $with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/sqlite-core/async/delete.ts b/drizzle-orm/src/sqlite-core/async/delete.ts
new file mode 100644
index 0000000000..e058d99581
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/delete.ts
@@ -0,0 +1,145 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteDeleteHKTBase } from '~/sqlite-core/query-builders/delete.ts';
+import { SQLiteDeleteBase } from '~/sqlite-core/query-builders/delete.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import { applyMixins, type Assume, type DrizzleTypeError } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession } from './session.ts';
+
+export interface SQLiteAsyncDeleteHKT extends SQLiteDeleteHKTBase {
+	_type: SQLiteAsyncDeleteBase<
+		Assume<this['table'], SQLiteTable>,
+		Assume<this['resultType'], 'sync' | 'async'>,
+		this['runResult'],
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnySQLiteAsyncDelete = SQLiteAsyncDeleteBase<any, any, any, any, any, any>;
+
+export type SQLiteAsyncDelete<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+> = SQLiteAsyncDeleteBase<TTable, TResultType, TRunResult, TReturning, true, never>;
+
+export type SQLiteAsyncDeleteExecute<T extends AnySQLiteAsyncDelete> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteAsyncDeletePrepare<T extends AnySQLiteAsyncDelete> = SQLiteAsyncPreparedQuery<
+	SQLiteAsyncPreparedQueryConfig & {
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'] | undefined;
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteAsyncDeleteExecute<T>;
+	}
+>;
+
+export interface SQLiteAsyncDeleteBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable,
+	// oxlint-disable-next-line no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+> extends
+	SQLiteDeleteBase<
+		SQLiteAsyncDeleteHKT & { resultType: TResultType },
+		TTable,
+		TRunResult,
+		TReturning,
+		TDynamic,
+		TExcludedMethods
+	>,
+	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+{
+	readonly _:
+		& SQLiteDeleteBase<
+			SQLiteAsyncDeleteHKT & { resultType: TResultType },
+			TTable,
+			TRunResult,
+			TReturning,
+			TDynamic,
+			TExcludedMethods
+		>['_']
+		& { readonly resultType: TResultType };
+}
+
+export class SQLiteAsyncDeleteBase<
+	TTable extends SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends SQLiteDeleteBase<
+	SQLiteAsyncDeleteHKT & { resultType: TResultType },
+	TTable,
+	TRunResult,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteAsyncDelete';
+
+	declare protected session: SQLiteAsyncSession<TResultType, TRunResult, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteAsyncDeletePrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'delete',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteAsyncDeletePrepare<this>;
+	}
+
+	prepare(): SQLiteAsyncDeletePrepare<this> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	async execute(placeholderValues?: Record<string, unknown>): Promise<SQLiteAsyncDeleteExecute<this>> {
+		return this._prepare().execute(placeholderValues) as SQLiteAsyncDeleteExecute<this>;
+	}
+}
+
+applyMixins(SQLiteAsyncDeleteBase, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/async/index.ts b/drizzle-orm/src/sqlite-core/async/index.ts
new file mode 100644
index 0000000000..98e8de2793
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/index.ts
@@ -0,0 +1,9 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
diff --git a/drizzle-orm/src/sqlite-core/async/insert.ts b/drizzle-orm/src/sqlite-core/async/insert.ts
new file mode 100644
index 0000000000..d530a1e93b
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/insert.ts
@@ -0,0 +1,153 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteInsertBuilder, SQLiteInsertHKTBase } from '~/sqlite-core/query-builders/insert.ts';
+import { SQLiteInsertBase } from '~/sqlite-core/query-builders/insert.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession } from './session.ts';
+
+export interface SQLiteAsyncInsertHKT extends SQLiteInsertHKTBase {
+	_type: SQLiteAsyncInsertBase<
+		Assume<this['table'], SQLiteTable>,
+		Assume<this['resultType'], 'sync' | 'async'>,
+		this['runResult'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnySQLiteAsyncInsert = SQLiteAsyncInsertBase<any, any, any, any, any, any>;
+
+export type SQLiteAsyncInsert<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TReturning = any,
+> = SQLiteAsyncInsertBase<TTable, TResultType, TRunResult, TReturning, true, never>;
+
+export type SQLiteAsyncInsertBuilder<
+	TTable extends SQLiteTable,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+> = SQLiteInsertBuilder<TTable, TRunResult, SQLiteAsyncInsertHKT & { resultType: TResultType }>;
+
+export type SQLiteAsyncInsertExecute<T extends AnySQLiteAsyncInsert> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteAsyncInsertPrepare<T extends AnySQLiteAsyncInsert> = SQLiteAsyncPreparedQuery<
+	SQLiteAsyncPreparedQueryConfig & {
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteAsyncInsertExecute<T>;
+	}
+>;
+
+export interface SQLiteAsyncInsertBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable,
+	// oxlint-disable-next-line no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TReturning = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+> extends
+	SQLiteInsertBase<
+		SQLiteAsyncInsertHKT & { resultType: TResultType },
+		TTable,
+		TRunResult,
+		TReturning,
+		TDynamic,
+		TExcludedMethods
+	>,
+	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+{
+	readonly _:
+		& SQLiteInsertBase<
+			SQLiteAsyncInsertHKT & { resultType: TResultType },
+			TTable,
+			TRunResult,
+			TReturning,
+			TDynamic,
+			TExcludedMethods
+		>['_']
+		& { readonly resultType: TResultType };
+}
+
+export class SQLiteAsyncInsertBase<
+	TTable extends SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends SQLiteInsertBase<
+	SQLiteAsyncInsertHKT & { resultType: TResultType },
+	TTable,
+	TRunResult,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteAsyncInsert';
+
+	declare protected session: SQLiteAsyncSession<TResultType, TRunResult, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteAsyncInsertPrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'insert',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteAsyncInsertPrepare<this>;
+	}
+
+	prepare(): SQLiteAsyncInsertPrepare<this> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	async execute(): Promise<SQLiteAsyncInsertExecute<this>> {
+		return this._prepare().execute() as SQLiteAsyncInsertExecute<this>;
+	}
+}
+
+applyMixins(SQLiteAsyncInsertBase, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/async/query.ts b/drizzle-orm/src/sqlite-core/async/query.ts
new file mode 100644
index 0000000000..fac1f43da9
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/query.ts
@@ -0,0 +1,81 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SQLiteRelationalQuery, type SQLiteRelationalQueryHKTBase } from '~/sqlite-core/query-builders/query.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncSession } from './session.ts';
+
+export interface SQLiteAsyncRelationalQueryHKT extends SQLiteRelationalQueryHKTBase {
+	_type: SQLiteAsyncRelationalQueryKind<Assume<this['type'], 'sync' | 'async'>, this['result']>;
+}
+
+export type SQLiteAsyncRelationalQueryKind<TType extends 'sync' | 'async', TResult> = TType extends 'async'
+	? SQLiteAsyncRelationalQuery<'async', TResult>
+	: SQLiteSyncRelationalQuery<TResult>;
+
+export type AnySQLiteAsyncRelationalQuery = SQLiteAsyncRelationalQuery<any, any>;
+
+// oxlint-disable-next-line no-unused-vars
+export interface SQLiteAsyncRelationalQuery<TType extends 'sync' | 'async', TResult> extends QueryPromise<TResult> {}
+
+export class SQLiteAsyncRelationalQuery<TType extends 'sync' | 'async', TResult>
+	extends SQLiteRelationalQuery<SQLiteAsyncRelationalQueryHKT, TResult>
+	implements RunnableQuery<TResult, 'sqlite'>
+{
+	static override readonly [entityKind]: string = 'SQLiteAsyncRelationalQueryV2';
+
+	declare readonly _: {
+		readonly dialect: 'sqlite';
+		readonly hkt: SQLiteAsyncRelationalQueryHKT;
+		readonly type: TType;
+		readonly result: TResult;
+	};
+
+	declare protected session: SQLiteAsyncSession<TType, any, any>;
+
+	/** @internal */
+	_prepare(
+		prepare = false,
+	): SQLiteAsyncPreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }> {
+		const { query, builtQuery } = this._toSQL();
+
+		const mapper = this.dialect.mapperGenerators.relationalRows({
+			isFirst: this.mode === 'first',
+			parseJson: true,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			selection: query.selection,
+			arrayModeRoot: true,
+		});
+
+		return this.session.prepareQuery(
+			builtQuery,
+			'arrays',
+			prepare,
+			// Do not use 'get' - mapper returns an item instead of an array, would break on session's destructuring; query itself is already limited to 1 item, so no performance overhead occurs.
+			'all',
+			mapper,
+		) as SQLiteAsyncPreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }>;
+	}
+
+	prepare(): SQLiteAsyncPreparedQuery<
+		PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }
+	> {
+		return this._prepare(true);
+	}
+
+	async execute(placeholderValues?: Record<string, unknown>): Promise<TResult> {
+		return this._prepare().execute(placeholderValues) as Promise<TResult>;
+	}
+}
+
+export class SQLiteSyncRelationalQuery<TResult> extends SQLiteAsyncRelationalQuery<'sync', TResult> {
+	static override readonly [entityKind]: string = 'SQLiteSyncRelationalQueryV2';
+
+	sync(placeholderValues?: Record<string, unknown>): TResult {
+		return this._prepare().execute(placeholderValues).sync() as TResult;
+	}
+}
+
+applyMixins(SQLiteAsyncRelationalQuery, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/async/raw.ts b/drizzle-orm/src/sqlite-core/async/raw.ts
new file mode 100644
index 0000000000..6a569c4ec7
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/raw.ts
@@ -0,0 +1,44 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
+import { applyMixins } from '~/utils.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig } from './session.ts';
+
+export interface SQLiteAsyncRaw<TResult>
+	extends SQLiteRaw<TResult>, QueryPromise<TResult>, RunnableQuery<TResult, 'sqlite'>, SQLWrapper
+{}
+
+export class SQLiteAsyncRaw<TResult> extends SQLiteRaw<TResult>
+	implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper
+{
+	static override readonly [entityKind]: string = 'SQLiteAsyncRaw';
+
+	declare protected prepared: SQLiteAsyncPreparedQuery<
+		SQLiteAsyncPreparedQueryConfig & {
+			execute: TResult;
+		}
+	>;
+
+	constructor(
+		prepared: SQLiteAsyncPreparedQuery<
+			SQLiteAsyncPreparedQueryConfig & {
+				execute: TResult;
+			}
+		>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, undefined>): Promise<TResult> {
+		return this.prepared.execute(placeholderValues) as Promise<TResult>;
+	}
+}
+
+applyMixins(SQLiteAsyncRaw, [QueryPromise]);
+
+export type DBResult<TKind extends 'sync' | 'async', TResult> = TKind extends 'async' ? SQLiteAsyncRaw<TResult>
+	: TResult;
diff --git a/drizzle-orm/src/sqlite-core/async/select.ts b/drizzle-orm/src/sqlite-core/async/select.ts
new file mode 100644
index 0000000000..7bb5c5a6e0
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/select.ts
@@ -0,0 +1,183 @@
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
+import { SQLiteSelectBase, type SQLiteSelectBuilder } from '~/sqlite-core/query-builders/select.ts';
+import type { SelectedFields, SQLiteSelectHKTBase } from '~/sqlite-core/query-builders/select.types.ts';
+import { applyMixins, type Assume } from '~/utils.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession } from './session.ts';
+
+export type SQLiteAsyncSelectExecute<T extends AnySQLiteAsyncSelect> = T['_']['result'];
+
+export type SQLiteAsyncSelectPrepare<T extends AnySQLiteAsyncSelect> = SQLiteAsyncPreparedQuery<
+	SQLiteAsyncPreparedQueryConfig & {
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['result'];
+		get: T['_']['result'][number] | undefined;
+		values: any[][];
+		execute: SQLiteAsyncSelectExecute<T>;
+	}
+>;
+
+export type SQLiteAsyncSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+> = SQLiteSelectBuilder<TSelection, TRunResult, SQLiteAsyncSelectHKT & { resultType: TResultType }>;
+
+export type SQLiteAsyncSelect<
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteAsyncSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export interface SQLiteAsyncSelectHKT extends SQLiteSelectHKTBase {
+	_type: SQLiteAsyncSelectBase<
+		this['tableName'],
+		Assume<this['resultType'], 'sync' | 'async'>,
+		this['runResult'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>
+	>;
+}
+
+export interface SQLiteAsyncSelectBase<
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode = 'single',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	// oxlint-disable-next-line no-unused-vars
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	SQLiteSelectBase<
+		SQLiteAsyncSelectHKT & { resultType: TResultType },
+		TTableName,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	QueryPromise<TResult>
+{
+	readonly _:
+		& SQLiteSelectBase<
+			SQLiteAsyncSelectHKT & { resultType: TResultType },
+			TTableName,
+			TRunResult,
+			TSelection,
+			TSelectMode,
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
+		>['_']
+		& { readonly resultType: TResultType };
+}
+
+export class SQLiteAsyncSelectBase<
+	TTableName extends string | undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection,
+	TSelectMode extends SelectMode = 'single',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends SQLiteSelectBase<
+	SQLiteAsyncSelectHKT & { resultType: TResultType },
+	TTableName,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteAsyncSelect';
+
+	declare protected session: SQLiteAsyncSession<TResultType, TRunResult, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteAsyncSelectPrepare<this> {
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+		const preparedQuery = this.session.prepareQuery(
+			query,
+			'arrays',
+			prepare,
+			'all',
+			mapper,
+			{
+				type: 'select',
+				tables: [...this.usedTables],
+			},
+			this.cacheConfig,
+		);
+		return preparedQuery as ReturnType<this['prepare']>;
+	}
+
+	prepare(): SQLiteAsyncSelectPrepare<this> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	async execute(): Promise<SQLiteAsyncSelectExecute<this>> {
+		return this._prepare().execute() as Promise<SQLiteAsyncSelectExecute<this>>;
+	}
+}
+
+applyMixins(SQLiteAsyncSelectBase, [QueryPromise]);
+
+export type AnySQLiteAsyncSelect = SQLiteAsyncSelectBase<any, any, any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/sqlite-core/async/session.ts b/drizzle-orm/src/sqlite-core/async/session.ts
new file mode 100644
index 0000000000..7a4bc23b51
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/session.ts
@@ -0,0 +1,542 @@
+import { type Cache, NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind, is } from '~/entity.ts';
+import { DrizzleQueryError, TransactionRollbackError } from '~/errors.ts';
+import type { Logger } from '~/logger.ts';
+import type { MigrationConfig, MigrationMeta, MigratorInitFailResponse } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	type PreparedQueryConfig as BasePreparedQueryConfig,
+	type SQLiteExecuteMethod,
+	SQLitePreparedQuery,
+	SQLiteSession,
+	type SQLiteTransactionConfig,
+} from '~/sqlite-core/session.ts';
+import { upgradeAsyncIfNeeded, upgradeSyncIfNeeded } from '~/up-migrations/sqlite.ts';
+import { assertUnreachable } from '~/utils.ts';
+import { SQLiteAsyncDatabase } from './db.ts';
+
+export interface SQLiteAsyncPreparedQueryConfig extends BasePreparedQueryConfig {
+	type: 'sync' | 'async';
+}
+
+export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult>
+	: ExecuteResultSync<TResult>;
+
+export class ExecuteResultSync<T> extends QueryPromise<T> {
+	static override readonly [entityKind]: string = 'ExecuteResultSync';
+
+	constructor(private resultCb: () => T) {
+		super();
+	}
+
+	override async execute(): Promise<T> {
+		return this.resultCb();
+	}
+
+	sync(): T {
+		return this.resultCb();
+	}
+}
+
+export type SQLiteQueryExecutors<TType extends 'sync' | 'async'> = Record<
+	SQLiteExecuteMethod,
+	(params: unknown[]) => Result<TType, any>
+>;
+
+export type Result<TKind extends 'sync' | 'async', TResult> = TKind extends 'async' ? Promise<TResult> : TResult;
+
+export class SQLiteAsyncPreparedQuery<T extends SQLiteAsyncPreparedQueryConfig> extends SQLitePreparedQuery {
+	static override readonly [entityKind]: string = 'SQLiteAsyncPreparedQuery';
+
+	private fastPath: boolean;
+
+	constructor(
+		private resultKind: 'sync' | 'async',
+		executeMethod: SQLiteExecuteMethod = 'all',
+		protected executors: SQLiteQueryExecutors<T['type']>,
+		query: Query,
+		mapper: ((rows: any[]) => any) | undefined,
+		mode: 'arrays' | 'objects' | 'raw',
+		protected logger: Logger,
+		// cache instance
+		protected cache: Cache | undefined,
+		// per query related metadata
+		protected queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		protected cacheConfig: WithCacheConfig | undefined,
+	) {
+		super(executeMethod, query, mapper, mode);
+
+		// it means that no $withCache options were passed and it should be just enabled
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+
+		this.fastPath = cacheConfig === undefined && (cache === undefined || is(cache, NoopCache));
+	}
+
+	/** @internal */
+	protected async queryWithCache<T>(
+		queryString: string,
+		params: any[],
+		executeMethod: SQLiteExecuteMethod,
+		query: () => Promise<T>,
+	): Promise<T> {
+		const cacheStrat = this.cache !== undefined && !is(this.cache, NoopCache)
+			? await strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)
+			: { type: 'skip' as const };
+
+		if (cacheStrat.type === 'skip') {
+			return query().catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		const cache = this.cache!;
+
+		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+		if (cacheStrat.type === 'invalidate') {
+			return Promise.all([
+				query(),
+				cache.onMutate({ tables: cacheStrat.tables }),
+			]).then((res) => res[0]).catch((e) => {
+				throw new DrizzleQueryError(queryString, params, e as Error);
+			});
+		}
+
+		if (cacheStrat.type === 'try') {
+			const { tables, key: _key, isTag, autoInvalidate, config } = cacheStrat;
+			const key = `${executeMethod}_${_key}`;
+
+			const fromCache = await cache.get(
+				key,
+				tables,
+				isTag,
+				autoInvalidate,
+			);
+
+			if (fromCache === undefined) {
+				const result = await query().catch((e) => {
+					throw new DrizzleQueryError(queryString, params, e as Error);
+				});
+				// put actual key
+				await cache.put(
+					key,
+					result,
+					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+				// put flag if we should invalidate or not
+				return result;
+			}
+
+			return fromCache as unknown as T;
+		}
+
+		assertUnreachable(cacheStrat);
+	}
+
+	override run(placeholderValues: Record<string, unknown> = {}): Result<T['type'], T['run']> {
+		const { query, logger, executors, fastPath, resultKind } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+
+		if (resultKind === 'sync') {
+			try {
+				return (<SQLiteQueryExecutors<'sync'>> executors).run(params);
+			} catch (e) {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			}
+		}
+
+		return fastPath
+			? (<SQLiteQueryExecutors<'async'>> executors).run(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, 'run', () => (<SQLiteQueryExecutors<'async'>> executors).run(params));
+	}
+
+	override all(placeholderValues: Record<string, unknown> = {}): Result<T['type'], T['all']> {
+		const { query, logger, executors, mapper, fastPath, resultKind } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+
+		if (resultKind === 'sync') {
+			let res: any;
+			try {
+				res = (<SQLiteQueryExecutors<'sync'>> executors).all(params);
+			} catch (e) {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			}
+
+			if (!mapper) return res;
+			return mapper(res);
+		}
+
+		const res = fastPath
+			? (<SQLiteQueryExecutors<'async'>> executors).all(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, 'all', () => (<SQLiteQueryExecutors<'async'>> executors).all(params));
+		if (!mapper) return res;
+
+		return res.then((rows) => mapper(rows)) as Result<T['type'], T['all']>;
+	}
+
+	override get(placeholderValues: Record<string, unknown> = {}): Result<T['type'], T['get']> {
+		const { query, logger, executors, mapper, fastPath, resultKind } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+
+		if (resultKind === 'sync') {
+			let res: any;
+			try {
+				res = (<SQLiteQueryExecutors<'sync'>> executors).get(params);
+			} catch (e) {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			}
+
+			if (!res) return undefined as Result<T['type'], T['get']>;
+			if (!mapper) return res;
+
+			return mapper([res])[0];
+		}
+
+		const res = fastPath
+			? (<SQLiteQueryExecutors<'async'>> executors).get(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, 'get', () => (<SQLiteQueryExecutors<'async'>> executors).get(params));
+
+		// Convert potential nulls from drivers to undefined
+		if (!mapper) return res.then((row) => row ? row : undefined);
+
+		return res.then((row) => row ? mapper([row])[0] : undefined) as Result<T['type'], T['get']>;
+	}
+
+	override values(placeholderValues: Record<string, unknown> = {}): Result<T['type'], T['values']> {
+		const { query, logger, executors, fastPath, resultKind } = this;
+		const sql = query._sql ? query._sql.join(' ') : query.sql;
+		const params = query.params.length === 0
+			? query.params
+			: fillPlaceholders(query.params, placeholderValues);
+		logger.logQuery(sql, params);
+
+		if (resultKind === 'sync') {
+			try {
+				return (<SQLiteQueryExecutors<'sync'>> executors).values(params);
+			} catch (e) {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			}
+		}
+
+		const res = fastPath
+			? (<SQLiteQueryExecutors<'async'>> executors).values(params).catch((e) => {
+				throw new DrizzleQueryError(sql, params, e as Error);
+			})
+			: this.queryWithCache(sql, params, 'values', () => (<SQLiteQueryExecutors<'async'>> executors).values(params));
+
+		return res;
+	}
+
+	override execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']> {
+		if (this.resultKind === 'async') {
+			return this[this.executeMethod](placeholderValues) as ExecuteResult<T['type'], T['execute']>;
+		}
+		return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues)) as ExecuteResult<
+			T['type'],
+			T['execute']
+		>;
+	}
+}
+
+export abstract class SQLiteAsyncSession<
+	TResultKind extends 'sync' | 'async',
+	TRunResult,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SQLiteSession<TRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'SQLiteAsyncSession';
+
+	declare readonly dialect: SQLiteDialect;
+
+	constructor(
+		dialect: SQLiteDialect,
+		protected resultKind: TResultKind,
+	) {
+		super(dialect);
+	}
+
+	abstract override prepareQuery(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<SQLiteAsyncPreparedQueryConfig & { type: TResultKind }>;
+
+	abstract transaction<T>(
+		transaction: (
+			tx: SQLiteAsyncTransaction<TResultKind, TRunResult, TRelations>,
+		) => Result<TResultKind, T>,
+		config?: SQLiteTransactionConfig,
+	): Result<TResultKind, T>;
+
+	run(query: SQL): Result<TResultKind, TRunResult> {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), 'raw', false).run() as Result<
+			TResultKind,
+			TRunResult
+		>;
+	}
+
+	objects<T = unknown>(query: SQL): Result<TResultKind, T[]> {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), 'objects', false).all() as Result<
+			TResultKind,
+			T[]
+		>;
+	}
+
+	object<T = unknown>(query: SQL): Result<TResultKind, T> {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), 'objects', false).get() as Result<
+			TResultKind,
+			T
+		>;
+	}
+
+	arrays<T extends any[] = unknown[]>(
+		query: SQL,
+	): Result<TResultKind, T[]> {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), 'arrays', false).all() as Result<
+			TResultKind,
+			T[]
+		>;
+	}
+
+	array<T extends any[] = unknown[]>(
+		query: SQL,
+	): Result<TResultKind, T> {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), 'arrays', false).get() as Result<
+			TResultKind,
+			T
+		>;
+	}
+}
+
+export abstract class SQLiteAsyncTransaction<
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SQLiteAsyncDatabase<TResultType, TRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'SQLiteAsyncTransaction';
+
+	constructor(
+		resultType: TResultType,
+		dialect: SQLiteDialect,
+		session: SQLiteAsyncSession<TResultType, TRunResult, TRelations>,
+		relations: TRelations,
+		protected readonly nestedIndex = 0,
+		forbidJsonb?: boolean,
+	) {
+		super(resultType, dialect, session, relations, forbidJsonb);
+	}
+
+	rollback(): never {
+		throw new TransactionRollbackError();
+	}
+}
+
+export function migrateSync(
+	migrations: MigrationMeta[],
+	session: SQLiteAsyncSession<'sync', unknown, AnyRelations>,
+	config?: string | Omit<MigrationConfig, 'migrationsFolder'>,
+): void | MigratorInitFailResponse {
+	const migrationsTable = config === undefined
+		? '__drizzle_migrations'
+		: typeof config === 'string'
+		? '__drizzle_migrations'
+		: (config.migrationsTable ?? '__drizzle_migrations');
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = upgradeSyncIfNeeded(migrationsTable, session, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id INTEGER PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric,
+				name text,
+				applied_at TEXT
+			)`;
+		session.run(migrationTableCreate);
+	}
+
+	const dbMigrations = session.objects<{
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		session.run(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({
+		localMigrations: migrations,
+		dbMigrations,
+	});
+	session.run(sql`BEGIN`);
+
+	try {
+		for (const migration of migrationsToRun) {
+			for (const stmt of migration.sql) {
+				session.run(sql.raw(stmt));
+			}
+			session.run(
+				sql`INSERT INTO ${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+					new Date().toISOString()
+				})`,
+			);
+		}
+
+		session.run(sql`COMMIT`);
+	} catch (e) {
+		session.run(sql`ROLLBACK`);
+		throw e;
+	}
+}
+
+export async function migrateAsync(
+	migrations: MigrationMeta[],
+	db: SQLiteAsyncDatabase<'async', unknown, AnyRelations>,
+	config?: string | Omit<MigrationConfig, 'migrationsFolder'>,
+): Promise<void | MigratorInitFailResponse> {
+	const migrationsTable = config === undefined
+		? '__drizzle_migrations'
+		: typeof config === 'string'
+		? '__drizzle_migrations'
+		: (config.migrationsTable ?? '__drizzle_migrations');
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeAsyncIfNeeded(
+		migrationsTable,
+		db,
+		migrations,
+	);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id INTEGER PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric,
+				name text,
+				applied_at TEXT
+			)
+		`;
+		await db.session.run(migrationTableCreate);
+	}
+
+	const dbMigrations = await db.session.objects<{
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)};`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await db.session.run(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({
+		localMigrations: migrations,
+		dbMigrations,
+	});
+	await db.session.transaction(async (tx) => {
+		for (const migration of migrationsToRun) {
+			for (const stmt of migration.sql) {
+				await tx.run(sql.raw(stmt));
+			}
+			await tx.run(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+					new Date().toISOString()
+				})`,
+			);
+		}
+	});
+}
diff --git a/drizzle-orm/src/sqlite-core/async/update.ts b/drizzle-orm/src/sqlite-core/async/update.ts
new file mode 100644
index 0000000000..584e35bcc2
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/async/update.ts
@@ -0,0 +1,162 @@
+import { entityKind } from '~/entity.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteUpdateBuilder, SQLiteUpdateHKTBase } from '~/sqlite-core/query-builders/update.ts';
+import { SQLiteUpdateBase } from '~/sqlite-core/query-builders/update.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { Subquery } from '~/subquery.ts';
+import { applyMixins, type Assume, type DrizzleTypeError } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
+import type { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession } from './session.ts';
+
+export interface SQLiteAsyncUpdateHKT extends SQLiteUpdateHKTBase {
+	_type: SQLiteAsyncUpdateBase<
+		Assume<this['table'], SQLiteTable>,
+		Assume<this['resultType'], 'sync' | 'async'>,
+		this['runResult'],
+		Assume<this['from'], SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined>,
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type AnySQLiteAsyncUpdate = SQLiteAsyncUpdateBase<any, any, any, any, any, any, any>;
+
+export type SQLiteAsyncUpdate<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = any,
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = SQLiteAsyncUpdateBase<TTable, TResultType, TRunResult, TFrom, TReturning, true, never>;
+
+export type SQLiteAsyncUpdateBuilder<
+	TTable extends SQLiteTable,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+> = SQLiteUpdateBuilder<TTable, TRunResult, SQLiteAsyncUpdateHKT & { resultType: TResultType }>;
+
+export type SQLiteAsyncUpdateExecute<T extends AnySQLiteAsyncUpdate> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteAsyncUpdatePrepare<T extends AnySQLiteAsyncUpdate> = SQLiteAsyncPreparedQuery<
+	SQLiteAsyncPreparedQueryConfig & {
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteAsyncUpdateExecute<T>;
+	}
+>;
+
+export interface SQLiteAsyncUpdateBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable = SQLiteTable,
+	// oxlint-disable-next-line no-unused-vars
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	// oxlint-disable-next-line no-unused-vars
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+> extends
+	SQLiteUpdateBase<
+		SQLiteAsyncUpdateHKT & { resultType: TResultType },
+		TTable,
+		TRunResult,
+		TFrom,
+		TReturning,
+		TDynamic,
+		TExcludedMethods
+	>,
+	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+{
+	readonly _:
+		& SQLiteUpdateBase<
+			SQLiteAsyncUpdateHKT & { resultType: TResultType },
+			TTable,
+			TRunResult,
+			TFrom,
+			TReturning,
+			TDynamic,
+			TExcludedMethods
+		>['_']
+		& { readonly resultType: TResultType };
+}
+
+export class SQLiteAsyncUpdateBase<
+	TTable extends SQLiteTable = SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends SQLiteUpdateBase<
+	SQLiteAsyncUpdateHKT & { resultType: TResultType },
+	TTable,
+	TRunResult,
+	TFrom,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteAsyncUpdate';
+
+	declare protected session: SQLiteAsyncSession<TResultType, TRunResult, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteAsyncUpdatePrepare<this> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'update',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteAsyncUpdatePrepare<this>;
+	}
+
+	prepare(): SQLiteAsyncUpdatePrepare<this> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	async execute(): Promise<SQLiteAsyncUpdateExecute<this>> {
+		return (this.config.returning ? this.all() : this.run()) as SQLiteAsyncUpdateExecute<this>;
+	}
+}
+
+applyMixins(SQLiteAsyncUpdateBase, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/casing.ts b/drizzle-orm/src/sqlite-core/casing.ts
new file mode 100644
index 0000000000..2bf3c0df26
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/casing.ts
@@ -0,0 +1,12 @@
+import { sqliteTableWithCasing } from './table.ts';
+import { sqliteViewWithCasing } from './view.ts';
+
+export const snakeCase = {
+	table: sqliteTableWithCasing('snake_case'),
+	view: sqliteViewWithCasing('snake_case'),
+};
+
+export const camelCase = {
+	table: sqliteTableWithCasing('camelCase'),
+	view: sqliteViewWithCasing('camelCase'),
+};
diff --git a/drizzle-orm/src/sqlite-core/columns/blob.ts b/drizzle-orm/src/sqlite-core/columns/blob.ts
index e42826c898..6789f91379 100644
--- a/drizzle-orm/src/sqlite-core/columns/blob.ts
+++ b/drizzle-orm/src/sqlite-core/columns/blob.ts
@@ -1,157 +1,156 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
-import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import { type Equal, getColumnNameAndConfig, textDecoder } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
 type BlobMode = 'buffer' | 'json' | 'bigint';
 
-export type SQLiteBigIntBuilderInitial<TName extends string> = SQLiteBigIntBuilder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'SQLiteBigInt';
+function hexToText(hexString: string) {
+	let result = '';
+	for (let i = 0; i < hexString.length; i += 2) {
+		const hexPair = hexString.slice(i, i + 2);
+		const decimalValue = Number.parseInt(hexPair, 16);
+		result += String.fromCodePoint(decimalValue);
+	}
+	return result;
+}
+
+export class SQLiteBigIntBuilder extends SQLiteColumnBuilder<{
+	dataType: 'bigint int64';
 	data: bigint;
 	driverParam: Buffer;
-	enumValues: undefined;
-}>;
-
-export class SQLiteBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'SQLiteBigInt'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteBigIntBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'bigint', 'SQLiteBigInt');
+	constructor(name: string) {
+		super(name, 'bigint int64', 'SQLiteBigInt');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteBigInt<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteBigInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any>);
+	override build(table: SQLiteTable) {
+		return new SQLiteBigInt(table, this.config as any);
 	}
 }
 
-export class SQLiteBigInt<T extends ColumnBaseConfig<'bigint', 'SQLiteBigInt'>> extends SQLiteColumn<T> {
+export class SQLiteBigInt<T extends ColumnBaseConfig<'bigint int64'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteBigInt';
 
 	getSQLType(): string {
 		return 'blob';
 	}
 
-	override mapFromDriverValue(value: Buffer | Uint8Array | ArrayBuffer): bigint {
-		if (Buffer.isBuffer(value)) {
-			return BigInt(value.toString());
+	override mapFromDriverValue = (value: Buffer | Uint8Array | ArrayBuffer | string): bigint => {
+		// For RQBv2
+		if (typeof value === 'string') {
+			return BigInt(hexToText(value));
 		}
 
-		// for sqlite durable objects
-		// eslint-disable-next-line no-instanceof/no-instanceof
-		if (value instanceof ArrayBuffer) {
-			const decoder = new TextDecoder();
-			return BigInt(decoder.decode(value));
+		if (typeof Buffer !== 'undefined' && Buffer.from) {
+			const buf = Buffer.isBuffer(value)
+				? value
+				// oxlint-disable-next-line drizzle-internal/no-instanceof
+				: value instanceof ArrayBuffer
+				? Buffer.from(value)
+				: value.buffer
+				? Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+				: Buffer.from(value);
+			return BigInt(buf.toString('utf8'));
 		}
 
-		return BigInt(String.fromCodePoint(...value));
-	}
+		return BigInt(textDecoder!.decode(value as ArrayBuffer));
+	};
 
-	override mapToDriverValue(value: bigint): Buffer {
+	override mapToDriverValue = (value: bigint): Buffer => {
 		return Buffer.from(value.toString());
-	}
+	};
 }
 
-export type SQLiteBlobJsonBuilderInitial<TName extends string> = SQLiteBlobJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'SQLiteBlobJson';
+export class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder<{
+	dataType: 'object json';
 	data: unknown;
 	driverParam: Buffer;
-	enumValues: undefined;
-}>;
-
-export class SQLiteBlobJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SQLiteBlobJson'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteBlobJsonBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'SQLiteBlobJson');
+	constructor(name: string) {
+		super(name, 'object json', 'SQLiteBlobJson');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteBlobJson<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteBlobJson<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteBlobJson(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteBlobJson<T extends ColumnBaseConfig<'json', 'SQLiteBlobJson'>> extends SQLiteColumn<T> {
+export class SQLiteBlobJson<T extends ColumnBaseConfig<'object json'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteBlobJson';
 
 	getSQLType(): string {
 		return 'blob';
 	}
 
-	override mapFromDriverValue(value: Buffer | Uint8Array | ArrayBuffer): T['data'] {
-		if (Buffer.isBuffer(value)) {
-			return JSON.parse(value.toString());
+	override mapFromDriverValue = (value: Buffer | Uint8Array | ArrayBuffer | string): T['data'] => {
+		// For RQBv2
+		if (typeof value === 'string') {
+			return JSON.parse(hexToText(value));
 		}
 
-		// for sqlite durable objects
-		// eslint-disable-next-line no-instanceof/no-instanceof
-		if (value instanceof ArrayBuffer) {
-			const decoder = new TextDecoder();
-			return JSON.parse(decoder.decode(value));
+		if (typeof Buffer !== 'undefined' && Buffer.from) {
+			const buf = Buffer.isBuffer(value)
+				? value
+				// oxlint-disable-next-line drizzle-internal/no-instanceof
+				: value instanceof ArrayBuffer
+				? Buffer.from(value)
+				: value.buffer
+				? Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+				: Buffer.from(value);
+			return JSON.parse(buf.toString('utf8'));
 		}
 
-		return JSON.parse(String.fromCodePoint(...value));
-	}
+		return JSON.parse(textDecoder!.decode(value as ArrayBuffer));
+	};
 
-	override mapToDriverValue(value: T['data']): Buffer {
+	override mapToDriverValue = (value: T['data']): Buffer => {
 		return Buffer.from(JSON.stringify(value));
-	}
+	};
 }
 
-export type SQLiteBlobBufferBuilderInitial<TName extends string> = SQLiteBlobBufferBuilder<{
-	name: TName;
-	dataType: 'buffer';
-	columnType: 'SQLiteBlobBuffer';
+export class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder<{
+	dataType: 'object buffer';
 	data: Buffer;
 	driverParam: Buffer;
-	enumValues: undefined;
-}>;
-
-export class SQLiteBlobBufferBuilder<T extends ColumnBuilderBaseConfig<'buffer', 'SQLiteBlobBuffer'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteBlobBufferBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'buffer', 'SQLiteBlobBuffer');
+	constructor(name: string) {
+		super(name, 'object buffer', 'SQLiteBlobBuffer');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteBlobBuffer<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteBlobBuffer<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any>);
+	override build(table: SQLiteTable) {
+		return new SQLiteBlobBuffer(table, this.config as any);
 	}
 }
 
-export class SQLiteBlobBuffer<T extends ColumnBaseConfig<'buffer', 'SQLiteBlobBuffer'>> extends SQLiteColumn<T> {
+export class SQLiteBlobBuffer<T extends ColumnBaseConfig<'object buffer'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteBlobBuffer';
 
-	override mapFromDriverValue(value: Buffer | Uint8Array | ArrayBuffer): T['data'] {
+	override mapFromDriverValue = (value: Buffer | Uint8Array | ArrayBuffer): T['data'] => {
 		if (Buffer.isBuffer(value)) {
 			return value;
 		}
 
+		// For RQBv2
+		if (typeof value === 'string') {
+			return Buffer.from(value, 'hex');
+		}
+
 		return Buffer.from(value as Uint8Array);
-	}
+	};
 
 	getSQLType(): string {
 		return 'blob';
@@ -168,25 +167,24 @@ export interface BlobConfig<TMode extends BlobMode = BlobMode> {
  *
  * https://www.sqlite.org/json1.html
  */
-export function blob(): SQLiteBlobJsonBuilderInitial<''>;
 export function blob<TMode extends BlobMode = BlobMode>(
 	config?: BlobConfig<TMode>,
-): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilderInitial<''>
-	: Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilderInitial<''>
-	: SQLiteBlobJsonBuilderInitial<''>;
-export function blob<TName extends string, TMode extends BlobMode = BlobMode>(
-	name: TName,
+): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilder
+	: Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilder
+	: SQLiteBlobJsonBuilder;
+export function blob<TMode extends BlobMode = BlobMode>(
+	name: string,
 	config?: BlobConfig<TMode>,
-): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilderInitial<TName>
-	: Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilderInitial<TName>
-	: SQLiteBlobJsonBuilderInitial<TName>;
+): Equal<TMode, 'bigint'> extends true ? SQLiteBigIntBuilder
+	: Equal<TMode, 'buffer'> extends true ? SQLiteBlobBufferBuilder
+	: SQLiteBlobJsonBuilder;
 export function blob(a?: string | BlobConfig, b?: BlobConfig) {
 	const { name, config } = getColumnNameAndConfig<BlobConfig | undefined>(a, b);
-	if (config?.mode === 'json') {
-		return new SQLiteBlobJsonBuilder(name);
-	}
 	if (config?.mode === 'bigint') {
 		return new SQLiteBigIntBuilder(name);
 	}
-	return new SQLiteBlobBufferBuilder(name);
+	if (config?.mode === 'buffer') {
+		return new SQLiteBlobBufferBuilder(name);
+	}
+	return new SQLiteBlobJsonBuilder(name);
 }
diff --git a/drizzle-orm/src/sqlite-core/columns/common.ts b/drizzle-orm/src/sqlite-core/columns/common.ts
index 8eacb8c937..1fbb0c0b92 100644
--- a/drizzle-orm/src/sqlite-core/columns/common.ts
+++ b/drizzle-orm/src/sqlite-core/columns/common.ts
@@ -1,11 +1,9 @@
 import type {
-	ColumnBuilderBase,
 	ColumnBuilderBaseConfig,
 	ColumnBuilderExtraConfig,
 	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
+	ColumnType,
 	HasGenerated,
-	MakeColumnConfig,
 } from '~/column-builder.ts';
 import { ColumnBuilder } from '~/column-builder.ts';
 import { Column } from '~/column.ts';
@@ -14,9 +12,10 @@ import { entityKind } from '~/entity.ts';
 import type { SQL } from '~/sql/sql.ts';
 import type { ForeignKey, UpdateDeleteAction } from '~/sqlite-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/sqlite-core/foreign-keys.ts';
-import type { AnySQLiteTable, SQLiteTable } from '~/sqlite-core/table.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import type { Update } from '~/utils.ts';
-import { uniqueKeyName } from '../unique-constraint.ts';
+
+export type SQLiteColumns = Record<string, SQLiteColumn<any>>;
 
 export interface ReferenceConfig {
 	ref: () => SQLiteColumn;
@@ -26,23 +25,15 @@ export interface ReferenceConfig {
 	};
 }
 
-export interface SQLiteColumnBuilderBase<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
-	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'sqlite' }> {}
-
 export interface SQLiteGeneratedColumnConfig {
 	mode?: 'virtual' | 'stored';
 }
 
 export abstract class SQLiteColumnBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType> = ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
-	TTypeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = object,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'sqlite' }, TExtraConfig>
-	implements SQLiteColumnBuilderBase<T, TTypeConfig>
-{
+> extends ColumnBuilder<T, TRuntimeConfig, TExtraConfig> {
 	static override readonly [entityKind]: string = 'SQLiteColumnBuilder';
 
 	private foreignKeyConfigs: ReferenceConfig[] = [];
@@ -63,7 +54,7 @@ export abstract class SQLiteColumnBuilder<
 		return this;
 	}
 
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: SQLiteGeneratedColumnConfig): HasGenerated<this, {
+	generatedAlwaysAs(as: SQL | (() => SQL), config?: SQLiteGeneratedColumnConfig): HasGenerated<this, {
 		type: 'always';
 	}> {
 		this.config.generated = {
@@ -94,30 +85,28 @@ export abstract class SQLiteColumnBuilder<
 	}
 
 	/** @internal */
-	abstract build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteColumn<MakeColumnConfig<T, TTableName>>;
+	abstract build(table: SQLiteTable): SQLiteColumn;
 }
 
 // To understand how to use `SQLiteColumn` and `AnySQLiteColumn`, see `Column` and `AnyColumn` documentation.
 export abstract class SQLiteColumn<
-	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType> = ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = {},
-	TTypeConfig extends object = {},
-> extends Column<T, TRuntimeConfig, TTypeConfig & { dialect: 'sqlite' }> {
+> extends Column<T, TRuntimeConfig> {
 	static override readonly [entityKind]: string = 'SQLiteColumn';
 
+	/** @internal */
+	override readonly table: SQLiteTable;
+
 	constructor(
-		override readonly table: SQLiteTable,
-		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
+		table: SQLiteTable,
+		config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig,
 	) {
-		if (!config.uniqueName) {
-			config.uniqueName = uniqueKeyName(table, [config.name]);
-		}
 		super(table, config);
+		this.table = table;
 	}
 }
 
-export type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = SQLiteColumn<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+export type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig<ColumnType>> = {}> = SQLiteColumn<
+	Required<Update<ColumnBaseConfig<ColumnType>, TPartial>>
 >;
diff --git a/drizzle-orm/src/sqlite-core/columns/custom.ts b/drizzle-orm/src/sqlite-core/columns/custom.ts
index b23d6442f2..f26be4e68d 100644
--- a/drizzle-orm/src/sqlite-core/columns/custom.ts
+++ b/drizzle-orm/src/sqlite-core/columns/custom.ts
@@ -1,19 +1,16 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/sql.ts';
-import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
+import type { SQL, SQLGenerator } from '~/sql/sql.ts';
+import type { AnySQLiteTable, SQLiteTable } from '~/sqlite-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
-export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
+export type ConvertCustomConfig<T extends Partial<CustomTypeValues>> =
 	& {
-		name: TName;
 		dataType: 'custom';
-		columnType: 'SQLiteCustomColumn';
 		data: T['data'];
 		driverParam: T['driverData'];
-		enumValues: undefined;
 	}
 	& (T['notNull'] extends true ? { notNull: true } : {})
 	& (T['default'] extends true ? { hasDefault: true } : {});
@@ -22,22 +19,17 @@ export interface SQLiteCustomColumnInnerConfig {
 	customTypeValues: CustomTypeValues;
 }
 
-export class SQLiteCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'SQLiteCustomColumn'>>
-	extends SQLiteColumnBuilder<
-		T,
-		{
-			fieldConfig: CustomTypeValues['config'];
-			customTypeParams: CustomTypeParams<any>;
-		},
-		{
-			sqliteColumnBuilderBrand: 'SQLiteCustomColumnBuilderBrand';
-		}
-	>
-{
+export class SQLiteCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom'>> extends SQLiteColumnBuilder<
+	T,
+	{
+		fieldConfig: CustomTypeValues['config'];
+		customTypeParams: CustomTypeParams<any>;
+	}
+> {
 	static override readonly [entityKind]: string = 'SQLiteCustomColumnBuilder';
 
 	constructor(
-		name: T['name'],
+		name: string,
 		fieldConfig: CustomTypeValues['config'],
 		customTypeParams: CustomTypeParams<any>,
 	) {
@@ -47,22 +39,22 @@ export class SQLiteCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom
 	}
 
 	/** @internal */
-	build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteCustomColumn<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteCustomColumn(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteCustomColumn<T extends ColumnBaseConfig<'custom', 'SQLiteCustomColumn'>> extends SQLiteColumn<T> {
+export class SQLiteCustomColumn<T extends ColumnBaseConfig<'custom'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteCustomColumn';
 
 	private sqlName: string;
 	private mapTo?: (value: T['data']) => T['driverParam'];
 	private mapFrom?: (value: T['driverParam']) => T['data'];
+	private mapJson?: (value: unknown) => T['data'];
+	private forJsonSelect?: (name: SQL, sql: SQLGenerator) => SQL;
 
 	constructor(
 		table: AnySQLiteTable<{ name: T['tableName'] }>,
@@ -72,22 +64,50 @@ export class SQLiteCustomColumn<T extends ColumnBaseConfig<'custom', 'SQLiteCust
 		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
 		this.mapTo = config.customTypeParams.toDriver;
 		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapJson = config.customTypeParams.fromJson;
+		this.forJsonSelect = config.customTypeParams.forJsonSelect;
 	}
 
 	getSQLType(): string {
 		return this.sqlName;
 	}
 
-	override mapFromDriverValue(value: T['driverParam']): T['data'] {
+	override mapFromDriverValue = (value: T['driverParam']): T['data'] => {
 		return typeof this.mapFrom === 'function' ? this.mapFrom(value) : value as T['data'];
+	};
+
+	mapFromJsonValue(value: unknown): T['data'] {
+		return typeof this.mapJson === 'function' ? this.mapJson(value) : this.mapFromDriverValue(value) as T['data'];
 	}
 
-	override mapToDriverValue(value: T['data']): T['driverParam'] {
-		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	jsonSelectIdentifier(identifier: SQL, sql: SQLGenerator): SQL {
+		if (typeof this.forJsonSelect === 'function') return this.forJsonSelect(identifier, sql);
+
+		const rawType = this.getSQLType().toLowerCase();
+		const parenPos = rawType.indexOf('(');
+		const type = (parenPos + 1) ? rawType.slice(0, parenPos) : rawType;
+
+		switch (type) {
+			case 'numeric':
+			case 'decimal':
+			case 'bigint': {
+				return sql`cast(${identifier} as text)`;
+			}
+			case 'blob': {
+				return sql`hex(${identifier})`;
+			}
+			default: {
+				return identifier;
+			}
+		}
 	}
+
+	override mapToDriverValue = (value: T['data']): T['driverParam'] => {
+		return typeof this.mapTo === 'function' ? this.mapTo(value) : value as T['data'];
+	};
 }
 
-export type CustomTypeValues = {
+export interface CustomTypeValues {
 	/**
 	 * Required type for custom column, that will infer proper type model
 	 *
@@ -104,6 +124,20 @@ export type CustomTypeValues = {
 	 */
 	driverData?: unknown;
 
+	/**
+	 * Type helper, that represents what type database driver is returning for specific database data type
+	 *
+	 * Needed only in case driver's output and input for type differ
+	 *
+	 * Defaults to {@link driverData}
+	 */
+	driverOutput?: unknown;
+
+	/**
+	 * Type helper, that represents what type field returns after being aggregated to JSON
+	 */
+	jsonData?: unknown;
+
 	/**
 	 * What config type should be used for {@link CustomTypeParams} `dataType` generation
 	 */
@@ -138,7 +172,7 @@ export type CustomTypeValues = {
 	 * });
 	 */
 	default?: boolean;
-};
+}
 
 export interface CustomTypeParams<T extends CustomTypeValues> {
 	/**
@@ -173,7 +207,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
 
 	/**
-	 * Optional mapping function, between user input and driver
+	 * Optional mapping function, that is used to transform inputs from desired to be used in code format to one suitable for driver
 	 * @example
 	 * For example, when using jsonb we need to map JS/TS object to string before writing to database
 	 * ```
@@ -185,16 +219,115 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 	toDriver?: (value: T['data']) => T['driverData'] | SQL;
 
 	/**
-	 * Optional mapping function, that is responsible for data mapping from database to JS/TS code
+	 * Optional mapping function, that is used for transforming data returned by driver to desired column's output format
 	 * @example
 	 * For example, when using timestamp we need to map string Date representation to JS Date
 	 * ```
 	 * fromDriver(value: string): Date {
 	 * 	return new Date(value);
+	 * }
+	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "2025-04-07T03:25:16.635Z";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: new Date("2025-04-07T03:25:16.635Z");
+	 * }
+	 * ```
+	 */
+	fromDriver?: (value: 'driverOutput' extends keyof T ? T['driverOutput'] : T['driverData']) => T['data'];
+
+	/**
+	 * Optional mapping function, that is used for transforming data returned by transofmed to JSON in database data to desired format
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Defaults to {@link fromDriver} function
+	 * @example
+	 * For example, when querying blob column via [RQB](https://orm.drizzle.team/docs/rqb-v2) or [JSON functions](https://orm.drizzle.team/docs/json-functions), the result field will be returned as it's hex string representation, as opposed to Buffer from regular query
+	 * To handle that, we need a separate function to handle such field's mapping:
+	 * ```
+	 * fromJson(value: string): Buffer {
+	 * 	return Buffer.from(value, 'hex');
 	 * },
 	 * ```
+	 *
+	 * It'll cause the returned data to change from:
+	 * ```
+	 * {
+	 * 	customField: "04A8...";
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	customField: Buffer([...]);
+	 * }
+	 * ```
+	 */
+	fromJson?: (value: T['jsonData']) => T['data'];
+
+	/**
+	 * Optional selection modifier function, that is used for modifying selection of column inside [JSON functions](https://orm.drizzle.team/docs/json-functions)
+	 *
+	 * Additional mapping that could be required for such scenarios can be handled using {@link fromJson} function
+	 *
+	 * Used by [relational queries](https://orm.drizzle.team/docs/rqb-v2)
+	 *
+	 * Following types are being casted to text by default: `numeric`, `decimal`, `bigint`, `blob` (via `hex()` function)
+	 * @example
+	 * For example, when using numeric field for bigint storage we need to cast field to text to preserve data integrity
+	 * ```
+	 * forJsonSelect(identifier: SQL, sql: SQLGenerator): SQL {
+	 * 	return sql`cast(${identifier} as text)`
+	 * },
+	 * ```
+	 *
+	 * This will change query from:
+	 * ```
+	 * SELECT
+	 * 	json_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		`table`.`custom_bigint` AS "bigint"
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 * to:
+	 * ```
+	 * SELECT
+	 * 	json_object('bigint', `t`.`bigint`)
+	 * 	FROM
+	 * 	(
+	 * 		SELECT
+	 * 		cast(`table`.`custom_bigint` as text) AS `bigint`
+	 * 		FROM
+	 * 		`table`
+	 * 	) AS `t`
+	 * ```
+	 *
+	 * Returned by query object will change from:
+	 * ```
+	 * {
+	 * 	bigint: 5044565289845416000; // Partial data loss due to direct conversion to JSON format
+	 * }
+	 * ```
+	 * to:
+	 * ```
+	 * {
+	 * 	bigint: "5044565289845416380"; // Data is preserved due to conversion of field to text before JSON-ification
+	 * }
+	 * ```
 	 */
-	fromDriver?: (value: T['driverData']) => T['data'];
+	forJsonSelect?: (identifier: SQL, sql: SQLGenerator) => SQL;
 }
 
 /**
@@ -205,30 +338,30 @@ export function customType<T extends CustomTypeValues = CustomTypeValues>(
 ): Equal<T['configRequired'], true> extends true ? {
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig: TConfig,
-		): SQLiteCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbname: string,
 			fieldConfig: T['config'],
-		): SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 	: {
-		(): SQLiteCustomColumnBuilder<ConvertCustomConfig<'', T>>;
+		(): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>>;
 		<TConfig extends Record<string, any> & T['config']>(
 			fieldConfig?: TConfig,
-		): SQLiteCustomColumnBuilder<ConvertCustomConfig<'', T>>;
-		<TName extends string>(
-			dbName: TName,
+		): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>>;
+		(
+			dbname: string,
 			fieldConfig?: T['config'],
-		): SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>>;
+		): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>>;
 	}
 {
-	return <TName extends string>(
-		a?: TName | T['config'],
+	return (
+		a?: string | T['config'],
 		b?: T['config'],
-	): SQLiteCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+	): SQLiteCustomColumnBuilder<ConvertCustomConfig<T>> => {
 		const { name, config } = getColumnNameAndConfig<T['config']>(a, b);
 		return new SQLiteCustomColumnBuilder(
-			name as ConvertCustomConfig<TName, T>['name'],
+			name,
 			config,
 			customTypeParams,
 		);
diff --git a/drizzle-orm/src/sqlite-core/columns/integer.ts b/drizzle-orm/src/sqlite-core/columns/integer.ts
index 13d52c0eaf..a7d8fb5b48 100644
--- a/drizzle-orm/src/sqlite-core/columns/integer.ts
+++ b/drizzle-orm/src/sqlite-core/columns/integer.ts
@@ -1,18 +1,10 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
-	HasDefault,
-	IsPrimaryKey,
-	MakeColumnConfig,
-	NotNull,
-} from '~/column-builder.ts';
+import type { ColumnBuilderBaseConfig, ColumnType, HasDefault, IsPrimaryKey, NotNull } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/sql.ts';
 import type { OnConflict } from '~/sqlite-core/utils.ts';
 import { type Equal, getColumnNameAndConfig, type Or } from '~/utils.ts';
-import type { AnySQLiteTable } from '../table.ts';
+import type { SQLiteTable } from '../table.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
 export interface PrimaryKeyConfig {
@@ -21,17 +13,16 @@ export interface PrimaryKeyConfig {
 }
 
 export abstract class SQLiteBaseIntegerBuilder<
-	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+	T extends ColumnBuilderBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends SQLiteColumnBuilder<
 	T,
 	TRuntimeConfig & { autoIncrement: boolean },
-	{},
 	{ primaryKeyHasDefault: true }
 > {
 	static override readonly [entityKind]: string = 'SQLiteBaseIntegerBuilder';
 
-	constructor(name: T['name'], dataType: T['dataType'], columnType: T['columnType']) {
+	constructor(name: string, dataType: T['dataType'], columnType: string) {
 		super(name, dataType, columnType);
 		this.config.autoIncrement = false;
 	}
@@ -43,15 +34,10 @@ export abstract class SQLiteBaseIntegerBuilder<
 		this.config.hasDefault = true;
 		return super.primaryKey() as IsPrimaryKey<HasDefault<NotNull<this>>>;
 	}
-
-	/** @internal */
-	abstract override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteBaseInteger<MakeColumnConfig<T, TTableName>>;
 }
 
 export abstract class SQLiteBaseInteger<
-	T extends ColumnBaseConfig<ColumnDataType, string>,
+	T extends ColumnBaseConfig<ColumnType>,
 	TRuntimeConfig extends object = object,
 > extends SQLiteColumn<T, TRuntimeConfig & { autoIncrement: boolean }> {
 	static override readonly [entityKind]: string = 'SQLiteBaseInteger';
@@ -63,54 +49,38 @@ export abstract class SQLiteBaseInteger<
 	}
 }
 
-export type SQLiteIntegerBuilderInitial<TName extends string> = SQLiteIntegerBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SQLiteInteger';
+export class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder<{
+	dataType: 'number int53';
 	data: number;
 	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class SQLiteIntegerBuilder<T extends ColumnBuilderBaseConfig<'number', 'SQLiteInteger'>>
-	extends SQLiteBaseIntegerBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteIntegerBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'SQLiteInteger');
+	constructor(name: string) {
+		super(name, 'number int53', 'SQLiteInteger');
 	}
 
-	build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteInteger<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteInteger<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteInteger(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteInteger<T extends ColumnBaseConfig<'number', 'SQLiteInteger'>> extends SQLiteBaseInteger<T> {
+export class SQLiteInteger<T extends ColumnBaseConfig<'number int53'>> extends SQLiteBaseInteger<T> {
 	static override readonly [entityKind]: string = 'SQLiteInteger';
 }
 
-export type SQLiteTimestampBuilderInitial<TName extends string> = SQLiteTimestampBuilder<{
-	name: TName;
-	dataType: 'date';
-	columnType: 'SQLiteTimestamp';
+export class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder<{
+	dataType: 'object date';
 	data: Date;
 	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class SQLiteTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'SQLiteTimestamp'>>
-	extends SQLiteBaseIntegerBuilder<T, { mode: 'timestamp' | 'timestamp_ms' }>
-{
+}, { mode: 'timestamp' | 'timestamp_ms' }> {
 	static override readonly [entityKind]: string = 'SQLiteTimestampBuilder';
 
-	constructor(name: T['name'], mode: 'timestamp' | 'timestamp_ms') {
-		super(name, 'date', 'SQLiteTimestamp');
+	constructor(name: string, mode: 'timestamp' | 'timestamp_ms') {
+		super(name, 'object date', 'SQLiteTimestamp');
 		this.config.mode = mode;
 	}
 
@@ -123,82 +93,73 @@ export class SQLiteTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'S
 		return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`) as any;
 	}
 
-	build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteTimestamp<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteTimestamp(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteTimestamp<T extends ColumnBaseConfig<'date', 'SQLiteTimestamp'>>
+export class SQLiteTimestamp<T extends ColumnBaseConfig<'object date'>>
 	extends SQLiteBaseInteger<T, { mode: 'timestamp' | 'timestamp_ms' }>
 {
 	static override readonly [entityKind]: string = 'SQLiteTimestamp';
 
 	readonly mode: 'timestamp' | 'timestamp_ms' = this.config.mode;
 
-	override mapFromDriverValue(value: number): Date {
+	override mapFromDriverValue = (value: number | string): Date => {
+		// legacy issue if integer had string date format
+		// old kit generated defaults as quoted strings "<string>"
+		if (typeof value === 'string') return new Date(value.replaceAll('"', ''));
 		if (this.config.mode === 'timestamp') {
 			return new Date(value * 1000);
 		}
 		return new Date(value);
-	}
+	};
 
-	override mapToDriverValue(value: Date): number {
+	override mapToDriverValue = (value: Date | number): number => {
+		if (typeof value === 'number') return value;
 		const unix = value.getTime();
 		if (this.config.mode === 'timestamp') {
 			return Math.floor(unix / 1000);
 		}
 		return unix;
-	}
+	};
 }
 
-export type SQLiteBooleanBuilderInitial<TName extends string> = SQLiteBooleanBuilder<{
-	name: TName;
+export class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder<{
 	dataType: 'boolean';
-	columnType: 'SQLiteBoolean';
 	data: boolean;
 	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class SQLiteBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'SQLiteBoolean'>>
-	extends SQLiteBaseIntegerBuilder<T, { mode: 'boolean' }>
-{
+}, { mode: 'boolean' }> {
 	static override readonly [entityKind]: string = 'SQLiteBooleanBuilder';
 
-	constructor(name: T['name'], mode: 'boolean') {
+	constructor(name: string, mode: 'boolean') {
 		super(name, 'boolean', 'SQLiteBoolean');
 		this.config.mode = mode;
 	}
 
-	build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteBoolean<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteBoolean<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteBoolean(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteBoolean<T extends ColumnBaseConfig<'boolean', 'SQLiteBoolean'>>
-	extends SQLiteBaseInteger<T, { mode: 'boolean' }>
-{
+export class SQLiteBoolean<T extends ColumnBaseConfig<'boolean'>> extends SQLiteBaseInteger<T, { mode: 'boolean' }> {
 	static override readonly [entityKind]: string = 'SQLiteBoolean';
 
 	readonly mode: 'boolean' = this.config.mode;
 
-	override mapFromDriverValue(value: number): boolean {
+	override mapFromDriverValue = (value: number): boolean => {
 		return Number(value) === 1;
-	}
+	};
 
-	override mapToDriverValue(value: boolean): number {
+	override mapToDriverValue = (value: boolean): number => {
 		return value ? 1 : 0;
-	}
+	};
 }
 
 export interface IntegerConfig<
@@ -211,18 +172,17 @@ export interface IntegerConfig<
 	mode: TMode;
 }
 
-export function integer(): SQLiteIntegerBuilderInitial<''>;
 export function integer<TMode extends IntegerConfig['mode']>(
 	config?: IntegerConfig<TMode>,
-): Or<Equal<TMode, 'timestamp'>, Equal<TMode, 'timestamp_ms'>> extends true ? SQLiteTimestampBuilderInitial<''>
-	: Equal<TMode, 'boolean'> extends true ? SQLiteBooleanBuilderInitial<''>
-	: SQLiteIntegerBuilderInitial<''>;
-export function integer<TName extends string, TMode extends IntegerConfig['mode']>(
-	name: TName,
+): Or<Equal<TMode, 'timestamp'>, Equal<TMode, 'timestamp_ms'>> extends true ? SQLiteTimestampBuilder
+	: Equal<TMode, 'boolean'> extends true ? SQLiteBooleanBuilder
+	: SQLiteIntegerBuilder;
+export function integer<TMode extends IntegerConfig['mode']>(
+	name: string,
 	config?: IntegerConfig<TMode>,
-): Or<Equal<TMode, 'timestamp'>, Equal<TMode, 'timestamp_ms'>> extends true ? SQLiteTimestampBuilderInitial<TName>
-	: Equal<TMode, 'boolean'> extends true ? SQLiteBooleanBuilderInitial<TName>
-	: SQLiteIntegerBuilderInitial<TName>;
+): Or<Equal<TMode, 'timestamp'>, Equal<TMode, 'timestamp_ms'>> extends true ? SQLiteTimestampBuilder
+	: Equal<TMode, 'boolean'> extends true ? SQLiteBooleanBuilder
+	: SQLiteIntegerBuilder;
 export function integer(a?: string | IntegerConfig, b?: IntegerConfig) {
 	const { name, config } = getColumnNameAndConfig<IntegerConfig | undefined>(a, b);
 	if (config?.mode === 'timestamp' || config?.mode === 'timestamp_ms') {
diff --git a/drizzle-orm/src/sqlite-core/columns/numeric.ts b/drizzle-orm/src/sqlite-core/columns/numeric.ts
index eb8d208a89..cdc12cb4c2 100644
--- a/drizzle-orm/src/sqlite-core/columns/numeric.ts
+++ b/drizzle-orm/src/sqlite-core/columns/numeric.ts
@@ -1,90 +1,70 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { type Equal, getColumnNameAndConfig } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
-export type SQLiteNumericBuilderInitial<TName extends string> = SQLiteNumericBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SQLiteNumeric';
+export class SQLiteNumericBuilder extends SQLiteColumnBuilder<{
+	dataType: 'string numeric';
 	data: string;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class SQLiteNumericBuilder<T extends ColumnBuilderBaseConfig<'string', 'SQLiteNumeric'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteNumericBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'string', 'SQLiteNumeric');
+	constructor(name: string) {
+		super(name, 'string numeric', 'SQLiteNumeric');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteNumeric<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteNumeric<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteNumeric(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteNumeric<T extends ColumnBaseConfig<'string', 'SQLiteNumeric'>> extends SQLiteColumn<T> {
+export class SQLiteNumeric<T extends ColumnBaseConfig<'string numeric'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteNumeric';
 
-	override mapFromDriverValue(value: unknown): string {
+	override mapFromDriverValue = (value: unknown): string => {
 		if (typeof value === 'string') return value;
 
 		return String(value);
-	}
+	};
 
 	getSQLType(): string {
 		return 'numeric';
 	}
 }
-
-export type SQLiteNumericNumberBuilderInitial<TName extends string> = SQLiteNumericNumberBuilder<{
-	name: TName;
+export class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder<{
 	dataType: 'number';
-	columnType: 'SQLiteNumericNumber';
 	data: number;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class SQLiteNumericNumberBuilder<T extends ColumnBuilderBaseConfig<'number', 'SQLiteNumericNumber'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteNumericNumberBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: string) {
 		super(name, 'number', 'SQLiteNumericNumber');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteNumericNumber<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteNumericNumber<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteNumericNumber(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteNumericNumber<T extends ColumnBaseConfig<'number', 'SQLiteNumericNumber'>> extends SQLiteColumn<T> {
+export class SQLiteNumericNumber<T extends ColumnBaseConfig<'number'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteNumericNumber';
 
-	override mapFromDriverValue(value: unknown): number {
+	override mapFromDriverValue = (value: unknown): number => {
 		if (typeof value === 'number') return value;
 
 		return Number(value);
-	}
+	};
 
 	override mapToDriverValue = String;
 
@@ -93,36 +73,27 @@ export class SQLiteNumericNumber<T extends ColumnBaseConfig<'number', 'SQLiteNum
 	}
 }
 
-export type SQLiteNumericBigIntBuilderInitial<TName extends string> = SQLiteNumericBigIntBuilder<{
-	name: TName;
-	dataType: 'bigint';
-	columnType: 'SQLiteNumericBigInt';
+export class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder<{
+	dataType: 'bigint int64';
 	data: bigint;
 	driverParam: string;
-	enumValues: undefined;
-}>;
-
-export class SQLiteNumericBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'SQLiteNumericBigInt'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteNumericBigIntBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'bigint', 'SQLiteNumericBigInt');
+	constructor(name: string) {
+		super(name, 'bigint int64', 'SQLiteNumericBigInt');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteNumericBigInt<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteNumericBigInt<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteNumericBigInt(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteNumericBigInt<T extends ColumnBaseConfig<'bigint', 'SQLiteNumericBigInt'>> extends SQLiteColumn<T> {
+export class SQLiteNumericBigInt<T extends ColumnBaseConfig<'bigint int64'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteNumericBigInt';
 
 	override mapFromDriverValue = BigInt;
@@ -140,15 +111,15 @@ export type SQLiteNumericConfig<T extends 'string' | 'number' | 'bigint' = 'stri
 
 export function numeric<TMode extends SQLiteNumericConfig['mode']>(
 	config?: SQLiteNumericConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? SQLiteNumericNumberBuilderInitial<''>
-	: Equal<TMode, 'bigint'> extends true ? SQLiteNumericBigIntBuilderInitial<''>
-	: SQLiteNumericBuilderInitial<''>;
-export function numeric<TName extends string, TMode extends SQLiteNumericConfig['mode']>(
-	name: TName,
+): Equal<TMode, 'number'> extends true ? SQLiteNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? SQLiteNumericBigIntBuilder
+	: SQLiteNumericBuilder;
+export function numeric<TMode extends SQLiteNumericConfig['mode']>(
+	name: string,
 	config?: SQLiteNumericConfig<TMode>,
-): Equal<TMode, 'number'> extends true ? SQLiteNumericNumberBuilderInitial<TName>
-	: Equal<TMode, 'bigint'> extends true ? SQLiteNumericBigIntBuilderInitial<TName>
-	: SQLiteNumericBuilderInitial<TName>;
+): Equal<TMode, 'number'> extends true ? SQLiteNumericNumberBuilder
+	: Equal<TMode, 'bigint'> extends true ? SQLiteNumericBigIntBuilder
+	: SQLiteNumericBuilder;
 export function numeric(a?: string | SQLiteNumericConfig, b?: SQLiteNumericConfig) {
 	const { name, config } = getColumnNameAndConfig<SQLiteNumericConfig>(a, b);
 	const mode = config?.mode;
diff --git a/drizzle-orm/src/sqlite-core/columns/real.ts b/drizzle-orm/src/sqlite-core/columns/real.ts
index 8821eb275a..5c7ec00f50 100644
--- a/drizzle-orm/src/sqlite-core/columns/real.ts
+++ b/drizzle-orm/src/sqlite-core/columns/real.ts
@@ -1,36 +1,26 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySQLiteTable } from '../table.ts';
+import type { SQLiteTable } from '../table.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
-export type SQLiteRealBuilderInitial<TName extends string> = SQLiteRealBuilder<{
-	name: TName;
-	dataType: 'number';
-	columnType: 'SQLiteReal';
+export class SQLiteRealBuilder extends SQLiteColumnBuilder<{
+	dataType: 'number double';
 	data: number;
 	driverParam: number;
-	enumValues: undefined;
-}>;
-
-export class SQLiteRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'SQLiteReal'>>
-	extends SQLiteColumnBuilder<T>
-{
+}> {
 	static override readonly [entityKind]: string = 'SQLiteRealBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'number', 'SQLiteReal');
+	constructor(name: string) {
+		super(name, 'number double', 'SQLiteReal');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteReal<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	override build(table: SQLiteTable) {
+		return new SQLiteReal(table, this.config as any);
 	}
 }
 
-export class SQLiteReal<T extends ColumnBaseConfig<'number', 'SQLiteReal'>> extends SQLiteColumn<T> {
+export class SQLiteReal<T extends ColumnBaseConfig<'number double'>> extends SQLiteColumn<T> {
 	static override readonly [entityKind]: string = 'SQLiteReal';
 
 	getSQLType(): string {
@@ -38,8 +28,6 @@ export class SQLiteReal<T extends ColumnBaseConfig<'number', 'SQLiteReal'>> exte
 	}
 }
 
-export function real(): SQLiteRealBuilderInitial<''>;
-export function real<TName extends string>(name: TName): SQLiteRealBuilderInitial<TName>;
-export function real(name?: string) {
+export function real(name?: string): SQLiteRealBuilder {
 	return new SQLiteRealBuilder(name ?? '');
 }
diff --git a/drizzle-orm/src/sqlite-core/columns/text.ts b/drizzle-orm/src/sqlite-core/columns/text.ts
index 0696b76f8e..dd994bd55e 100644
--- a/drizzle-orm/src/sqlite-core/columns/text.ts
+++ b/drizzle-orm/src/sqlite-core/columns/text.ts
@@ -1,62 +1,47 @@
-import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
-import { type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
+import type { AnySQLiteTable, SQLiteTable } from '~/sqlite-core/table.ts';
+import { type Assume, type Equal, getColumnNameAndConfig, type Writable } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
-export type SQLiteTextBuilderInitial<
-	TName extends string,
-	TEnum extends [string, ...string[]],
-	TLength extends number | undefined,
-> = SQLiteTextBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'SQLiteText';
-	data: TEnum[number];
-	driverParam: string;
-	enumValues: TEnum;
-	length: TLength;
-}>;
-
 export class SQLiteTextBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'SQLiteText'> & { length?: number | undefined },
+	TEnum extends [string, ...string[]],
 > extends SQLiteColumnBuilder<
-	T,
-	{ length: T['length']; enumValues: T['enumValues'] },
-	{ length: T['length'] }
+	{
+		dataType: Equal<TEnum, [string, ...string[]]> extends true ? 'string' : 'string enum';
+		data: TEnum[number];
+		driverParam: string;
+		enumValues: TEnum;
+	},
+	{ enumValues: TEnum; length: number | undefined }
 > {
 	static override readonly [entityKind]: string = 'SQLiteTextBuilder';
 
-	constructor(name: T['name'], config: SQLiteTextConfig<'text', T['enumValues'], T['length']>) {
-		super(name, 'string', 'SQLiteText');
-		this.config.enumValues = config.enum;
-		this.config.length = config.length;
+	constructor(name: string, config: SQLiteTextConfig<'text', TEnum>) {
+		super(name, config.enum?.length ? 'string enum' : 'string', 'SQLiteText');
+		this.config.enumValues = config.enum!;
+		this.config.length = config.length!;
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteText<MakeColumnConfig<T, TTableName> & { length: T['length'] }> {
-		return new SQLiteText<MakeColumnConfig<T, TTableName> & { length: T['length'] }>(
+	override build(table: SQLiteTable) {
+		return new SQLiteText(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteText<T extends ColumnBaseConfig<'string', 'SQLiteText'> & { length?: number | undefined }>
-	extends SQLiteColumn<T, { length: T['length']; enumValues: T['enumValues'] }>
+export class SQLiteText<T extends ColumnBaseConfig<'string' | 'string enum'>>
+	extends SQLiteColumn<T, { length: number | undefined; enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'SQLiteText';
 
 	override readonly enumValues = this.config.enumValues;
 
-	readonly length: T['length'] = this.config.length;
-
 	constructor(
 		table: AnySQLiteTable<{ name: T['tableName'] }>,
-		config: SQLiteTextBuilder<T>['config'],
+		config: SQLiteTextBuilder<Assume<T['enumValues'], [string, ...string[]]>>['config'],
 	) {
 		super(table, config);
 	}
@@ -66,37 +51,29 @@ export class SQLiteText<T extends ColumnBaseConfig<'string', 'SQLiteText'> & { l
 	}
 }
 
-export type SQLiteTextJsonBuilderInitial<TName extends string> = SQLiteTextJsonBuilder<{
-	name: TName;
-	dataType: 'json';
-	columnType: 'SQLiteTextJson';
+export class SQLiteTextJsonBuilder extends SQLiteColumnBuilder<{
+	dataType: 'object json';
 	data: unknown;
 	driverParam: string;
-	enumValues: undefined;
-	generated: undefined;
-}>;
 
-export class SQLiteTextJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SQLiteTextJson'>>
-	extends SQLiteColumnBuilder<T>
-{
+	generated: undefined;
+}> {
 	static override readonly [entityKind]: string = 'SQLiteTextJsonBuilder';
 
-	constructor(name: T['name']) {
-		super(name, 'json', 'SQLiteTextJson');
+	constructor(name: string) {
+		super(name, 'object json', 'SQLiteTextJson');
 	}
 
 	/** @internal */
-	override build<TTableName extends string>(
-		table: AnySQLiteTable<{ name: TTableName }>,
-	): SQLiteTextJson<MakeColumnConfig<T, TTableName>> {
-		return new SQLiteTextJson<MakeColumnConfig<T, TTableName>>(
+	override build(table: SQLiteTable) {
+		return new SQLiteTextJson(
 			table,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			this.config as any,
 		);
 	}
 }
 
-export class SQLiteTextJson<T extends ColumnBaseConfig<'json', 'SQLiteTextJson'>>
+export class SQLiteTextJson<T extends ColumnBaseConfig<'object json'>>
 	extends SQLiteColumn<T, { length: number | undefined; enumValues: T['enumValues'] }>
 {
 	static override readonly [entityKind]: string = 'SQLiteTextJson';
@@ -105,49 +82,44 @@ export class SQLiteTextJson<T extends ColumnBaseConfig<'json', 'SQLiteTextJson'>
 		return 'text';
 	}
 
-	override mapFromDriverValue(value: string): T['data'] {
+	override mapFromDriverValue = (value: string): T['data'] => {
 		return JSON.parse(value);
-	}
+	};
 
-	override mapToDriverValue(value: T['data']): string {
+	override mapToDriverValue = (value: T['data']): string => {
 		return JSON.stringify(value);
-	}
+	};
 }
 
 export type SQLiteTextConfig<
 	TMode extends 'text' | 'json' = 'text' | 'json',
 	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
-	TLength extends number | undefined = number | undefined,
 > = TMode extends 'text' ? {
 		mode?: TMode;
-		length?: TLength;
+		length?: number;
 		enum?: TEnum;
 	}
 	: {
 		mode?: TMode;
 	};
 
-export function text(): SQLiteTextBuilderInitial<'', [string, ...string[]], undefined>;
 export function text<
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 	TMode extends 'text' | 'json' = 'text' | 'json',
 >(
-	config?: SQLiteTextConfig<TMode, T | Writable<T>, L>,
-): Equal<TMode, 'json'> extends true ? SQLiteTextJsonBuilderInitial<''>
-	: SQLiteTextBuilderInitial<'', Writable<T>, L>;
+	config?: SQLiteTextConfig<TMode, T | Writable<T>>,
+): Equal<TMode, 'json'> extends true ? SQLiteTextJsonBuilder
+	: SQLiteTextBuilder<Writable<T>>;
 export function text<
-	TName extends string,
 	U extends string,
 	T extends Readonly<[U, ...U[]]>,
-	L extends number | undefined,
 	TMode extends 'text' | 'json' = 'text' | 'json',
 >(
-	name: TName,
-	config?: SQLiteTextConfig<TMode, T | Writable<T>, L>,
-): Equal<TMode, 'json'> extends true ? SQLiteTextJsonBuilderInitial<TName>
-	: SQLiteTextBuilderInitial<TName, Writable<T>, L>;
+	name: string,
+	config?: SQLiteTextConfig<TMode, T | Writable<T>>,
+): Equal<TMode, 'json'> extends true ? SQLiteTextJsonBuilder
+	: SQLiteTextBuilder<Writable<T>>;
 export function text(a?: string | SQLiteTextConfig, b: SQLiteTextConfig = {}): any {
 	const { name, config } = getColumnNameAndConfig<SQLiteTextConfig>(a, b);
 	if (config.mode === 'json') {
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
deleted file mode 100644
index 9b6a175e81..0000000000
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ /dev/null
@@ -1,648 +0,0 @@
-import type { Cache } from '~/cache/core/cache.ts';
-import { entityKind } from '~/entity.ts';
-import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { SelectionProxyHandler } from '~/selection-proxy.ts';
-import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import {
-	QueryBuilder,
-	SQLiteDeleteBase,
-	SQLiteInsertBuilder,
-	SQLiteSelectBuilder,
-	SQLiteUpdateBuilder,
-} from '~/sqlite-core/query-builders/index.ts';
-import type {
-	DBResult,
-	Result,
-	SQLiteSession,
-	SQLiteTransaction,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import type { SQLiteTable } from '~/sqlite-core/table.ts';
-import { WithSubquery } from '~/subquery.ts';
-import type { DrizzleTypeError } from '~/utils.ts';
-import { SQLiteCountBuilder } from './query-builders/count.ts';
-import { RelationalQueryBuilder } from './query-builders/query.ts';
-import { SQLiteRaw } from './query-builders/raw.ts';
-import type { SelectedFields } from './query-builders/select.types.ts';
-import type { WithBuilder } from './subquery.ts';
-import type { SQLiteViewBase } from './view-base.ts';
-
-export class BaseSQLiteDatabase<
-	TResultKind extends 'sync' | 'async',
-	TRunResult,
-	TFullSchema extends Record<string, unknown> = Record<string, never>,
-	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
-> {
-	static readonly [entityKind]: string = 'BaseSQLiteDatabase';
-
-	declare readonly _: {
-		readonly schema: TSchema | undefined;
-		readonly fullSchema: TFullSchema;
-		readonly tableNamesMap: Record<string, string>;
-	};
-
-	query: TFullSchema extends Record<string, never>
-		? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'>
-		: {
-			[K in keyof TSchema]: RelationalQueryBuilder<TResultKind, TFullSchema, TSchema, TSchema[K]>;
-		};
-
-	constructor(
-		private resultKind: TResultKind,
-		/** @internal */
-		readonly dialect: { sync: SQLiteSyncDialect; async: SQLiteAsyncDialect }[TResultKind],
-		/** @internal */
-		readonly session: SQLiteSession<TResultKind, TRunResult, TFullSchema, TSchema>,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
-	) {
-		this._ = schema
-			? {
-				schema: schema.schema,
-				fullSchema: schema.fullSchema as TFullSchema,
-				tableNamesMap: schema.tableNamesMap,
-			}
-			: {
-				schema: undefined,
-				fullSchema: {} as TFullSchema,
-				tableNamesMap: {},
-			};
-		this.query = {} as typeof this['query'];
-		const query = this.query as {
-			[K in keyof TSchema]: RelationalQueryBuilder<TResultKind, TFullSchema, TSchema, TSchema[K]>;
-		};
-		if (this._.schema) {
-			for (const [tableName, columns] of Object.entries(this._.schema)) {
-				query[tableName as keyof TSchema] = new RelationalQueryBuilder(
-					resultKind,
-					schema!.fullSchema,
-					this._.schema,
-					this._.tableNamesMap,
-					schema!.fullSchema[tableName] as SQLiteTable,
-					columns,
-					dialect,
-					session as SQLiteSession<any, any, any, any> as any,
-				) as typeof query[keyof TSchema];
-			}
-		}
-		this.$cache = { invalidate: async (_params: any) => {} };
-	}
-
-	/**
-	 * Creates a subquery that defines a temporary named result set as a CTE.
-	 *
-	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param alias The alias for the subquery.
-	 *
-	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Create a subquery with alias 'sq' and use it in the select query
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 *
-	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
-	 *
-	 * ```ts
-	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
-	 * const sq = db.$with('sq').as(db.select({
-	 *   name: sql<string>`upper(${users.name})`.as('name'),
-	 * })
-	 * .from(users));
-	 *
-	 * const result = await db.with(sq).select({ name: sq.name }).from(sq);
-	 * ```
-	 */
-	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
-		const self = this;
-		const as = (
-			qb:
-				| TypedQueryBuilder<ColumnsSelection | undefined>
-				| SQL
-				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
-		) => {
-			if (typeof qb === 'function') {
-				qb = qb(new QueryBuilder(self.dialect));
-			}
-
-			return new Proxy(
-				new WithSubquery(
-					qb.getSQL(),
-					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
-					alias,
-					true,
-				),
-				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-			);
-		};
-		return { as };
-	};
-
-	$count(
-		source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	) {
-		return new SQLiteCountBuilder({ source, filters, session: this.session });
-	}
-
-	/**
-	 * Incorporates a previously defined CTE (using `$with`) into the main query.
-	 *
-	 * This method allows the main query to reference a temporary named result set.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-	 *
-	 * @param queries The CTEs to incorporate into the main query.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Define a subquery 'sq' as a CTE using $with
-	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-	 *
-	 * // Incorporate the CTE 'sq' into the main query and select from it
-	 * const result = await db.with(sq).select().from(sq);
-	 * ```
-	 */
-	with(...queries: WithSubquery[]) {
-		const self = this;
-
-		/**
-		 * Creates a select query.
-		 *
-		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Select all columns and all rows from the 'cars' table
-		 * const allCars: Car[] = await db.select().from(cars);
-		 *
-		 * // Select specific columns and all rows from the 'cars' table
-		 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   brand: cars.brand
-		 * })
-		 *   .from(cars);
-		 * ```
-		 *
-		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-		 *
-		 * ```ts
-		 * // Select specific columns along with expression and all rows from the 'cars' table
-		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-		 *   id: cars.id,
-		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-		 * })
-		 *   .from(cars);
-		 * ```
-		 */
-		function select(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-		function select<TSelection extends SelectedFields>(
-			fields: TSelection,
-		): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-		function select(
-			fields?: SelectedFields,
-		): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
-			return new SQLiteSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-			});
-		}
-
-		/**
-		 * Adds `distinct` expression to the select query.
-		 *
-		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-		 *
-		 * Use `.from()` method to specify which table to select from.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-		 *
-		 * @param fields The selection object.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Select all unique rows from the 'cars' table
-		 * await db.selectDistinct()
-		 *   .from(cars)
-		 *   .orderBy(cars.id, cars.brand, cars.color);
-		 *
-		 * // Select all unique brands from the 'cars' table
-		 * await db.selectDistinct({ brand: cars.brand })
-		 *   .from(cars)
-		 *   .orderBy(cars.brand);
-		 * ```
-		 */
-		function selectDistinct(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-		function selectDistinct<TSelection extends SelectedFields>(
-			fields: TSelection,
-		): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-		function selectDistinct(
-			fields?: SelectedFields,
-		): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
-			return new SQLiteSelectBuilder({
-				fields: fields ?? undefined,
-				session: self.session,
-				dialect: self.dialect,
-				withList: queries,
-				distinct: true,
-			});
-		}
-
-		/**
-		 * Creates an update query.
-		 *
-		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-		 *
-		 * Use `.set()` method to specify which values to update.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/update}
-		 *
-		 * @param table The table to update.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Update all rows in the 'cars' table
-		 * await db.update(cars).set({ color: 'red' });
-		 *
-		 * // Update rows with filters and conditions
-		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-		 *
-		 * // Update with returning clause
-		 * const updatedCar: Car[] = await db.update(cars)
-		 *   .set({ color: 'red' })
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function update<TTable extends SQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, TResultKind, TRunResult> {
-			return new SQLiteUpdateBuilder(table, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates an insert query.
-		 *
-		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/insert}
-		 *
-		 * @param table The table to insert into.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Insert one row
-		 * await db.insert(cars).values({ brand: 'BMW' });
-		 *
-		 * // Insert multiple rows
-		 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-		 *
-		 * // Insert with returning clause
-		 * const insertedCar: Car[] = await db.insert(cars)
-		 *   .values({ brand: 'BMW' })
-		 *   .returning();
-		 * ```
-		 */
-		function insert<TTable extends SQLiteTable>(into: TTable): SQLiteInsertBuilder<TTable, TResultKind, TRunResult> {
-			return new SQLiteInsertBuilder(into, self.session, self.dialect, queries);
-		}
-
-		/**
-		 * Creates a delete query.
-		 *
-		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-		 *
-		 * See docs: {@link https://orm.drizzle.team/docs/delete}
-		 *
-		 * @param table The table to delete from.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * // Delete all rows in the 'cars' table
-		 * await db.delete(cars);
-		 *
-		 * // Delete rows with filters and conditions
-		 * await db.delete(cars).where(eq(cars.color, 'green'));
-		 *
-		 * // Delete with returning clause
-		 * const deletedCar: Car[] = await db.delete(cars)
-		 *   .where(eq(cars.id, 1))
-		 *   .returning();
-		 * ```
-		 */
-		function delete_<TTable extends SQLiteTable>(from: TTable): SQLiteDeleteBase<TTable, TResultKind, TRunResult> {
-			return new SQLiteDeleteBase(from, self.session, self.dialect, queries);
-		}
-
-		return { select, selectDistinct, update, insert, delete: delete_ };
-	}
-
-	/**
-	 * Creates a select query.
-	 *
-	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all columns and all rows from the 'cars' table
-	 * const allCars: Car[] = await db.select().from(cars);
-	 *
-	 * // Select specific columns and all rows from the 'cars' table
-	 * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   brand: cars.brand
-	 * })
-	 *   .from(cars);
-	 * ```
-	 *
-	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
-	 *
-	 * ```ts
-	 * // Select specific columns along with expression and all rows from the 'cars' table
-	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
-	 *   id: cars.id,
-	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
-	 * })
-	 *   .from(cars);
-	 * ```
-	 */
-	select(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-	select<TSelection extends SelectedFields>(
-		fields: TSelection,
-	): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-	select(fields?: SelectedFields): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
-		return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
-	}
-
-	/**
-	 * Adds `distinct` expression to the select query.
-	 *
-	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
-	 *
-	 * Use `.from()` method to specify which table to select from.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
-	 *
-	 * @param fields The selection object.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Select all unique rows from the 'cars' table
-	 * await db.selectDistinct()
-	 *   .from(cars)
-	 *   .orderBy(cars.id, cars.brand, cars.color);
-	 *
-	 * // Select all unique brands from the 'cars' table
-	 * await db.selectDistinct({ brand: cars.brand })
-	 *   .from(cars)
-	 *   .orderBy(cars.brand);
-	 * ```
-	 */
-	selectDistinct(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-	selectDistinct<TSelection extends SelectedFields>(
-		fields: TSelection,
-	): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-	selectDistinct(
-		fields?: SelectedFields,
-	): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
-		return new SQLiteSelectBuilder({
-			fields: fields ?? undefined,
-			session: this.session,
-			dialect: this.dialect,
-			distinct: true,
-		});
-	}
-
-	/**
-	 * Creates an update query.
-	 *
-	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-	 *
-	 * Use `.set()` method to specify which values to update.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/update}
-	 *
-	 * @param table The table to update.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Update all rows in the 'cars' table
-	 * await db.update(cars).set({ color: 'red' });
-	 *
-	 * // Update rows with filters and conditions
-	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-	 *
-	 * // Update with returning clause
-	 * const updatedCar: Car[] = await db.update(cars)
-	 *   .set({ color: 'red' })
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	update<TTable extends SQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, TResultKind, TRunResult> {
-		return new SQLiteUpdateBuilder(table, this.session, this.dialect);
-	}
-
-	$cache: { invalidate: Cache['onMutate'] };
-
-	/**
-	 * Creates an insert query.
-	 *
-	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/insert}
-	 *
-	 * @param table The table to insert into.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Insert one row
-	 * await db.insert(cars).values({ brand: 'BMW' });
-	 *
-	 * // Insert multiple rows
-	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-	 *
-	 * // Insert with returning clause
-	 * const insertedCar: Car[] = await db.insert(cars)
-	 *   .values({ brand: 'BMW' })
-	 *   .returning();
-	 * ```
-	 */
-	insert<TTable extends SQLiteTable>(into: TTable): SQLiteInsertBuilder<TTable, TResultKind, TRunResult> {
-		return new SQLiteInsertBuilder(into, this.session, this.dialect);
-	}
-
-	/**
-	 * Creates a delete query.
-	 *
-	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-	 *
-	 * See docs: {@link https://orm.drizzle.team/docs/delete}
-	 *
-	 * @param table The table to delete from.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * // Delete all rows in the 'cars' table
-	 * await db.delete(cars);
-	 *
-	 * // Delete rows with filters and conditions
-	 * await db.delete(cars).where(eq(cars.color, 'green'));
-	 *
-	 * // Delete with returning clause
-	 * const deletedCar: Car[] = await db.delete(cars)
-	 *   .where(eq(cars.id, 1))
-	 *   .returning();
-	 * ```
-	 */
-	delete<TTable extends SQLiteTable>(from: TTable): SQLiteDeleteBase<TTable, TResultKind, TRunResult> {
-		return new SQLiteDeleteBase(from, this.session, this.dialect);
-	}
-
-	run(query: SQLWrapper | string): DBResult<TResultKind, TRunResult> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		if (this.resultKind === 'async') {
-			return new SQLiteRaw(
-				async () => this.session.run(sequel),
-				() => sequel,
-				'run',
-				this.dialect as SQLiteAsyncDialect,
-				this.session.extractRawRunValueFromBatchResult.bind(this.session),
-			) as DBResult<TResultKind, TRunResult>;
-		}
-		return this.session.run(sequel) as DBResult<TResultKind, TRunResult>;
-	}
-
-	all<T = unknown>(query: SQLWrapper | string): DBResult<TResultKind, T[]> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		if (this.resultKind === 'async') {
-			return new SQLiteRaw(
-				async () => this.session.all(sequel),
-				() => sequel,
-				'all',
-				this.dialect as SQLiteAsyncDialect,
-				this.session.extractRawAllValueFromBatchResult.bind(this.session),
-			) as any;
-		}
-		return this.session.all(sequel) as DBResult<TResultKind, T[]>;
-	}
-
-	get<T = unknown>(query: SQLWrapper | string): DBResult<TResultKind, T> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		if (this.resultKind === 'async') {
-			return new SQLiteRaw(
-				async () => this.session.get(sequel),
-				() => sequel,
-				'get',
-				this.dialect as SQLiteAsyncDialect,
-				this.session.extractRawGetValueFromBatchResult.bind(this.session),
-			) as DBResult<TResultKind, T>;
-		}
-		return this.session.get(sequel) as DBResult<TResultKind, T>;
-	}
-
-	values<T extends unknown[] = unknown[]>(query: SQLWrapper | string): DBResult<TResultKind, T[]> {
-		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
-		if (this.resultKind === 'async') {
-			return new SQLiteRaw(
-				async () => this.session.values(sequel),
-				() => sequel,
-				'values',
-				this.dialect as SQLiteAsyncDialect,
-				this.session.extractRawValuesValueFromBatchResult.bind(this.session),
-			) as any;
-		}
-		return this.session.values(sequel) as DBResult<TResultKind, T[]>;
-	}
-
-	transaction<T>(
-		transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>,
-		config?: SQLiteTransactionConfig,
-	): Result<TResultKind, T> {
-		return this.session.transaction(transaction, config);
-	}
-}
-
-export type SQLiteWithReplicas<Q> = Q & { $primary: Q };
-
-export const withReplicas = <
-	TResultKind extends 'sync' | 'async',
-	TRunResult,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-	Q extends BaseSQLiteDatabase<
-		TResultKind,
-		TRunResult,
-		TFullSchema,
-		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
-	>,
->(
-	primary: Q,
-	replicas: [Q, ...Q[]],
-	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
-): SQLiteWithReplicas<Q> => {
-	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
-	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
-	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
-	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
-
-	const update: Q['update'] = (...args: [any]) => primary.update(...args);
-	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
-	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
-	const run: Q['run'] = (...args: [any]) => primary.run(...args);
-	const all: Q['all'] = (...args: [any]) => primary.all(...args);
-	const get: Q['get'] = (...args: [any]) => primary.get(...args);
-	const values: Q['values'] = (...args: [any]) => primary.values(...args);
-	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
-
-	return {
-		...primary,
-		update,
-		insert,
-		delete: $delete,
-		run,
-		all,
-		get,
-		values,
-		transaction,
-		$primary: primary,
-		select,
-		selectDistinct,
-		$count,
-		with: $with,
-		get query() {
-			return getReplica(replicas).query;
-		},
-	};
-};
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index 2f4a0c366d..1a43f5797d 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -1,26 +1,33 @@
-import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from '~/alias.ts';
-import { CasingCache } from '~/casing.ts';
+import { aliasedTable, getOriginalColumnFromAlias } from '~/alias.ts';
 import type { AnyColumn } from '~/column.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import { DrizzleError } from '~/errors.ts';
-import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import {
+	type AnyOne,
+	// AggregatedField,
 	type BuildRelationalQueryResult,
+	type ColumnWithTSName,
 	type DBQueryConfig,
-	getOperators,
-	getOrderByOperators,
-	Many,
-	normalizeRelation,
+	getTableAsAliasSQL,
+	makeDefaultRqbMapper,
+	makeJitRqbMapper,
 	One,
 	type Relation,
+	type RelationalRowsMapperGenerator,
+	relationExtrasToSQL,
+	relationsFilterToSQL,
+	relationsOrderToSQL,
+	relationToSQL,
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
+	type WithContainer,
 } from '~/relations.ts';
-import type { Name, Placeholder } from '~/sql/index.ts';
-import { and, eq } from '~/sql/index.ts';
-import { Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/sql.ts';
-import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
+import type { Name, Placeholder, SQLWrapper } from '~/sql/index.ts';
+import { and, isSQLWrapper } from '~/sql/index.ts';
+import { Param, type Query, SQL, sql, type SQLChunk, View } from '~/sql/sql.ts';
+import { SQLiteColumn, type SQLiteCustomColumn } from '~/sqlite-core/columns/index.ts';
 import type {
 	AnySQLiteSelectQueryBuilder,
 	SQLiteDeleteConfig,
@@ -29,33 +36,50 @@ import type {
 } from '~/sqlite-core/query-builders/index.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery } from '~/subquery.ts';
-import { getTableName, getTableUniqueName, Table } from '~/table.ts';
-import { type Casing, orderSelectedFields, type UpdateSet } from '~/utils.ts';
+import { getTableName, Table, TableColumns } from '~/table.ts';
+import {
+	makeDefaultQueryMapper,
+	makeJitQueryMapper,
+	orderSelectedFields,
+	type RowsMapperGenerator,
+	type UpdateSet,
+} from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type {
 	SelectedFieldsOrdered,
 	SQLiteSelectConfig,
 	SQLiteSelectJoinConfig,
 } from './query-builders/select.types.ts';
-import type { SQLiteSession } from './session.ts';
 import { SQLiteViewBase } from './view-base.ts';
+import type { SQLiteView } from './view.ts';
 
+// Will add codecs here, do not remove
 export interface SQLiteDialectConfig {
-	casing?: Casing;
+	useJitMappers?: boolean;
 }
 
-export abstract class SQLiteDialect {
+export class SQLiteDialect {
 	static readonly [entityKind]: string = 'SQLiteDialect';
 
-	/** @internal */
-	readonly casing: CasingCache;
+	readonly mapperGenerators: {
+		rows: RowsMapperGenerator;
+		relationalRows: RelationalRowsMapperGenerator;
+	};
 
 	constructor(config?: SQLiteDialectConfig) {
-		this.casing = new CasingCache(config?.casing);
+		this.mapperGenerators = config?.useJitMappers
+			? {
+				rows: makeJitQueryMapper,
+				relationalRows: makeJitRqbMapper,
+			}
+			: {
+				rows: makeDefaultQueryMapper,
+				relationalRows: makeDefaultRqbMapper,
+			};
 	}
 
 	escapeName(name: string): string {
-		return `"${name}"`;
+		return `"${name.replace(/"/g, '""')}"`;
 	}
 
 	escapeParam(_num: number): string {
@@ -80,7 +104,14 @@ export abstract class SQLiteDialect {
 		return sql.join(withSqlChunks);
 	}
 
-	buildDeleteQuery({ table, where, returning, withList, limit, orderBy }: SQLiteDeleteConfig): SQL {
+	buildDeleteQuery({
+		table,
+		where,
+		returning,
+		withList,
+		limit,
+		orderBy,
+	}: SQLiteDeleteConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const returningSql = returning
@@ -99,25 +130,43 @@ export abstract class SQLiteDialect {
 	buildUpdateSet(table: SQLiteTable, set: UpdateSet): SQL {
 		const tableColumns = table[Table.Symbol.Columns];
 
-		const columnNames = Object.keys(tableColumns).filter((colName) =>
-			set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined
+		const columnNames = Object.keys(tableColumns).filter(
+			(colName) =>
+				set[colName] !== undefined
+				|| tableColumns[colName]?.onUpdateFn !== undefined,
 		);
 
-		const setSize = columnNames.length;
-		return sql.join(columnNames.flatMap((colName, i) => {
-			const col = tableColumns[colName]!;
+		const setLength = columnNames.length;
+		return sql.join(
+			columnNames.flatMap((colName, i) => {
+				const col = tableColumns[colName]!;
 
-			const value = set[colName] ?? sql.param(col.onUpdateFn!(), col);
-			const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
+				const onUpdateFnResult = col.onUpdateFn?.();
+				const value = set[colName]
+					?? (is(onUpdateFnResult, SQL)
+						? onUpdateFnResult
+						: sql.param(onUpdateFnResult, col));
+				const res = sql`${sql.identifier(col.name)} = ${value}`;
 
-			if (i < setSize - 1) {
-				return [res, sql.raw(', ')];
-			}
-			return [res];
-		}));
+				if (i < setLength - 1) {
+					return [res, sql.raw(', ')];
+				}
+				return [res];
+			}),
+		);
 	}
 
-	buildUpdateQuery({ table, set, where, returning, withList, joins, from, limit, orderBy }: SQLiteUpdateConfig): SQL {
+	buildUpdateQuery({
+		table,
+		set,
+		where,
+		returning,
+		withList,
+		joins,
+		from,
+		limit,
+		orderBy,
+	}: SQLiteUpdateConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const setSql = this.buildUpdateSet(table, set);
@@ -156,63 +205,104 @@ export abstract class SQLiteDialect {
 	): SQL {
 		const columnsLen = fields.length;
 
-		const chunks = fields
-			.flatMap(({ field }, i) => {
-				const chunk: SQLChunk[] = [];
+		const chunks = fields.flatMap(({ field }, i) => {
+			const chunk: SQLChunk[] = [];
 
-				if (is(field, SQL.Aliased) && field.isSelectionField) {
+			if (is(field, SQL.Aliased)) {
+				if (field.isSelectionField) {
+					if (!isSingleTable && field.origin !== undefined) {
+						chunk.push(sql.identifier(field.origin), sql.raw('.'));
+					}
 					chunk.push(sql.identifier(field.fieldAlias));
-				} else if (is(field, SQL.Aliased) || is(field, SQL)) {
-					const query = is(field, SQL.Aliased) ? field.sql : field;
+				} else {
+					const query = field.sql;
 
 					if (isSingleTable) {
-						chunk.push(
-							new SQL(
-								query.queryChunks.map((c) => {
-									if (is(c, Column)) {
-										return sql.identifier(this.casing.getColumnCasing(c));
-									}
-									return c;
-								}),
-							),
+						const newSql = new SQL(
+							query.queryChunks.map((c) => {
+								if (is(c, Column)) {
+									return sql.identifier(c.name);
+								}
+								return c;
+							}),
 						);
+
+						chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
 					} else {
 						chunk.push(query);
 					}
 
-					if (is(field, SQL.Aliased)) {
-						chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+					chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
+				}
+			} else if (is(field, SQL)) {
+				const query = field;
+
+				if (isSingleTable) {
+					const newSql = new SQL(
+						query.queryChunks.map((c) => {
+							if (is(c, Column)) {
+								return sql.identifier(c.name);
+							}
+							return c;
+						}),
+					);
+
+					chunk.push(query.shouldInlineParams ? newSql.inlineParams() : newSql);
+				} else {
+					chunk.push(query);
+				}
+			} else if (is(field, Column)) {
+				// TODO: remove after implementing codecs
+				if (field.columnType === 'SQLiteNumericBigInt' || field.columnType === 'SQLiteNumeric') {
+					if (isSingleTable) {
+						chunk.push(
+							field.isAlias
+								? sql`cast(${sql.identifier(getOriginalColumnFromAlias(field).name)} as text) as ${field}`
+								: sql`cast(${sql.identifier(field.name)} as text)`,
+						);
+					} else {
+						chunk.push(
+							field.isAlias
+								? sql`cast(${getOriginalColumnFromAlias(field)} as text) as ${field}`
+								: sql`cast(${field} as text)`,
+						);
 					}
-				} else if (is(field, Column)) {
-					const tableName = field.table[Table.Symbol.Name];
-					if (field.columnType === 'SQLiteNumericBigInt') {
-						if (isSingleTable) {
-							chunk.push(sql`cast(${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
-						} else {
-							chunk.push(
-								sql`cast(${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))} as text)`,
-							);
-						}
+				} else {
+					if (isSingleTable) {
+						chunk.push(
+							field.isAlias
+								? sql`${sql.identifier(getOriginalColumnFromAlias(field).name)} as ${field}`
+								: sql.identifier(field.name),
+						);
 					} else {
-						if (isSingleTable) {
-							chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
-						} else {
-							chunk.push(sql`${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))}`);
-						}
+						chunk.push(
+							field.isAlias
+								? sql`${getOriginalColumnFromAlias(field)} as ${field}`
+								: field,
+						);
 					}
 				}
-
-				if (i < columnsLen - 1) {
-					chunk.push(sql`, `);
+			} else if (is(field, Subquery)) {
+				if (!field._.isWith) {
+					chunk.push(sql`(${field._.sql}) ${sql.identifier(field._.alias)}`);
+				} else {
+					chunk.push(field);
 				}
+			}
 
-				return chunk;
-			});
+			if (i < columnsLen - 1) {
+				chunk.push(sql`, `);
+			}
+
+			return chunk;
+		});
 
 		return sql.join(chunks);
 	}
 
-	private buildJoins(joins: SQLiteSelectJoinConfig[] | undefined): SQL | undefined {
+	private buildJoins(
+		joins: SQLiteSelectJoinConfig[] | undefined,
+	): SQL | undefined {
 		if (!joins || joins.length === 0) {
 			return undefined;
 		}
@@ -234,7 +324,9 @@ export abstract class SQLiteDialect {
 					const alias = tableName === origTableName ? undefined : joinMeta.alias;
 					joinsArray.push(
 						sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${
-							sql.identifier(origTableName)
+							sql.identifier(
+								origTableName,
+							)
 						}${alias && sql` ${sql.identifier(alias)}`}${onSql}`,
 					);
 				} else {
@@ -252,12 +344,15 @@ export abstract class SQLiteDialect {
 	}
 
 	private buildLimit(limit: number | Placeholder | undefined): SQL | undefined {
-		return typeof limit === 'object' || (typeof limit === 'number' && limit >= 0)
+		return typeof limit === 'object'
+				|| (typeof limit === 'number' && limit >= 0)
 			? sql` limit ${limit}`
 			: undefined;
 	}
 
-	private buildOrderBy(orderBy: (SQLiteColumn | SQL | SQL.Aliased)[] | undefined): SQL | undefined {
+	private buildOrderBy(
+		orderBy: (SQLiteColumn | SQL | SQL.Aliased)[] | undefined,
+	): SQL | undefined {
 		const orderByList: (SQLiteColumn | SQL | SQL.Aliased)[] = [];
 
 		if (orderBy) {
@@ -270,7 +365,9 @@ export abstract class SQLiteDialect {
 			}
 		}
 
-		return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : undefined;
+		return orderByList.length > 0
+			? sql` order by ${sql.join(orderByList)}`
+			: undefined;
 	}
 
 	private buildFromTable(
@@ -278,30 +375,38 @@ export abstract class SQLiteDialect {
 	): SQL | Subquery | SQLiteViewBase | SQLiteTable | undefined {
 		if (is(table, Table) && table[Table.Symbol.IsAlias]) {
 			return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? '')}.`.if(table[Table.Symbol.Schema])}${
-				sql.identifier(table[Table.Symbol.OriginalName])
+				sql.identifier(
+					table[Table.Symbol.OriginalName],
+				)
 			} ${sql.identifier(table[Table.Symbol.Name])}`;
 		}
 
+		if (is(table, View) && table[ViewBaseConfig].isAlias) {
+			let fullName = sql`${sql.identifier(table[ViewBaseConfig].originalName)}`;
+			if (table[ViewBaseConfig].schema) {
+				fullName = sql`${sql.identifier(table[ViewBaseConfig].schema)}.${fullName}`;
+			}
+			return sql`${fullName} ${sql.identifier(table[ViewBaseConfig].name)}`;
+		}
+
 		return table;
 	}
 
-	buildSelectQuery(
-		{
-			withList,
-			fields,
-			fieldsFlat,
-			where,
-			having,
-			table,
-			joins,
-			orderBy,
-			groupBy,
-			limit,
-			offset,
-			distinct,
-			setOperators,
-		}: SQLiteSelectConfig,
-	): SQL {
+	buildSelectQuery({
+		withList,
+		fields,
+		fieldsFlat,
+		where,
+		having,
+		table,
+		joins,
+		orderBy,
+		groupBy,
+		limit,
+		offset,
+		distinct,
+		setOperators,
+	}: SQLiteSelectConfig): SQL {
 		const fieldsList = fieldsFlat ?? orderSelectedFields<SQLiteColumn>(fields);
 		for (const f of fieldsList) {
 			if (
@@ -315,14 +420,20 @@ export abstract class SQLiteDialect {
 						? undefined
 						: getTableName(table))
 				&& !((table) =>
-					joins?.some(({ alias }) =>
-						alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])
+					joins?.some(
+						({ alias }) =>
+							alias
+								=== (table[Table.Symbol.IsAlias]
+									? getTableName(table)
+									: table[Table.Symbol.BaseName]),
 					))(f.field.table)
 			) {
 				const tableName = getTableName(f.field.table);
 				throw new Error(
 					`Your "${
-						f.path.join('->')
+						f.path.join(
+							'->',
+						)
 					}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`,
 				);
 			}
@@ -355,7 +466,9 @@ export abstract class SQLiteDialect {
 			}
 		}
 
-		const groupBySql = groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : undefined;
+		const groupBySql = groupByList.length > 0
+			? sql` group by ${sql.join(groupByList)}`
+			: undefined;
 
 		const orderBySql = this.buildOrderBy(orderBy);
 
@@ -373,7 +486,10 @@ export abstract class SQLiteDialect {
 		return finalQuery;
 	}
 
-	buildSetOperations(leftSelect: SQL, setOperators: SQLiteSelectConfig['setOperators']): SQL {
+	buildSetOperations(
+		leftSelect: SQL,
+		setOperators: SQLiteSelectConfig['setOperators'],
+	): SQL {
 		const [setOperator, ...rest] = setOperators;
 
 		if (!setOperator) {
@@ -394,7 +510,10 @@ export abstract class SQLiteDialect {
 	buildSetOperationQuery({
 		leftSelect,
 		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: SQLiteSelectConfig['setOperators'][number] }): SQL {
+	}: {
+		leftSelect: SQL;
+		setOperator: SQLiteSelectConfig['setOperators'][number];
+	}): SQL {
 		// SQLite doesn't support parenthesis in set operations
 		const leftChunk = sql`${leftSelect.getSQL()} `;
 		const rightChunk = sql`${rightSelect.getSQL()}`;
@@ -413,7 +532,7 @@ export abstract class SQLiteDialect {
 						const chunk = singleOrderBy.queryChunks[i];
 
 						if (is(chunk, SQLiteColumn)) {
-							singleOrderBy.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));
+							singleOrderBy.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
@@ -437,17 +556,26 @@ export abstract class SQLiteDialect {
 		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
-	buildInsertQuery(
-		{ table, values: valuesOrSelect, onConflict, returning, withList, select }: SQLiteInsertConfig,
-	): SQL {
+	buildInsertQuery({
+		table,
+		values: valuesOrSelect,
+		onConflict,
+		returning,
+		withList,
+		select,
+	}: SQLiteInsertConfig): SQL {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
 		const columns: Record<string, SQLiteColumn> = table[Table.Symbol.Columns];
 
-		const colEntries: [string, SQLiteColumn][] = Object.entries(columns).filter(([_, col]) =>
-			!col.shouldDisableInsert()
-		);
-		const insertOrder = colEntries.map(([, column]) => sql.identifier(this.casing.getColumnCasing(column)));
+		const colEntries: [string, SQLiteColumn][] = Object.entries(columns);
+		const colEntriesFiltered: [string, SQLiteColumn][] = select && !is(valuesOrSelect, SQL)
+			? Object
+				.keys((valuesOrSelect as TypedQueryBuilder<any>).getSelectedFields())
+				.map((key) => [key, columns[key]] as [string, SQLiteColumn])
+			: colEntries.filter(([_, col]) => !col.shouldDisableInsert());
+
+		const insertOrder = colEntriesFiltered.map(([, column]) => sql.identifier(column.name));
 
 		if (select) {
 			const select = valuesOrSelect as AnySQLiteSelectQueryBuilder | SQL;
@@ -463,20 +591,29 @@ export abstract class SQLiteDialect {
 
 			for (const [valueIndex, value] of values.entries()) {
 				const valueList: (SQLChunk | SQL)[] = [];
-				for (const [fieldName, col] of colEntries) {
+				for (const [fieldName, col] of colEntriesFiltered) {
 					const colValue = value[fieldName];
-					if (colValue === undefined || (is(colValue, Param) && colValue.value === undefined)) {
+					if (
+						colValue === undefined
+						|| (is(colValue, Param) && colValue.value === undefined)
+					) {
 						let defaultValue;
 						if (col.default !== null && col.default !== undefined) {
-							defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
+							defaultValue = is(col.default, SQL)
+								? col.default
+								: sql.param(col.default, col);
 							// eslint-disable-next-line unicorn/no-negated-condition
 						} else if (col.defaultFn !== undefined) {
 							const defaultFnResult = col.defaultFn();
-							defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
+							defaultValue = is(defaultFnResult, SQL)
+								? defaultFnResult
+								: sql.param(defaultFnResult, col);
 							// eslint-disable-next-line unicorn/no-negated-condition
 						} else if (!col.default && col.onUpdateFn !== undefined) {
 							const onUpdateFnResult = col.onUpdateFn();
-							defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
+							defaultValue = is(onUpdateFnResult, SQL)
+								? onUpdateFnResult
+								: sql.param(onUpdateFnResult, col);
 						} else {
 							defaultValue = sql`null`;
 						}
@@ -500,9 +637,7 @@ export abstract class SQLiteDialect {
 			? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}`
 			: undefined;
 
-		const onConflictSql = onConflict?.length
-			? sql.join(onConflict)
-			: undefined;
+		const onConflictSql = onConflict?.length ? sql.join(onConflict) : undefined;
 
 		// if (isSingleValue && valuesSqlList.length === 0){
 		// 	return sql`insert into ${table} default values ${onConflictSql}${returningSql}`;
@@ -511,9 +646,8 @@ export abstract class SQLiteDialect {
 		return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
 	}
 
-	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): QueryWithTypings {
+	sqlToQuery(sql: SQL, invokeSource?: 'indexes' | undefined): Query {
 		return sql.toQuery({
-			casing: this.casing,
 			escapeName: this.escapeName,
 			escapeParam: this.escapeParam,
 			escapeString: this.escapeString,
@@ -521,391 +655,323 @@ export abstract class SQLiteDialect {
 		});
 	}
 
-	buildRelationalQuery({
-		fullSchema,
-		schema,
-		tableNamesMap,
-		table,
-		tableConfig,
-		queryConfig: config,
-		tableAlias,
-		nestedQueryRelation,
-		joinOn,
-	}: {
-		fullSchema: Record<string, unknown>;
-		schema: TablesRelationalConfig;
-		tableNamesMap: Record<string, string>;
-		table: SQLiteTable;
-		tableConfig: TableRelationalConfig;
-		queryConfig: true | DBQueryConfig<'many', true>;
-		tableAlias: string;
-		nestedQueryRelation?: Relation;
-		joinOn?: SQL;
-	}): BuildRelationalQueryResult<SQLiteTable, SQLiteColumn> {
-		let selection: BuildRelationalQueryResult<SQLiteTable, SQLiteColumn>['selection'] = [];
-		let limit, offset, orderBy: SQLiteSelectConfig['orderBy'] = [], where;
-		const joins: SQLiteSelectJoinConfig[] = [];
-
-		if (config === true) {
-			const selectionEntries = Object.entries(tableConfig.columns);
-			selection = selectionEntries.map((
-				[key, value],
-			) => ({
-				dbKey: value.name,
-				tsKey: key,
-				field: aliasedTableColumn(value as SQLiteColumn, tableAlias),
-				relationTableTsKey: undefined,
-				isJson: false,
-				selection: [],
-			}));
-		} else {
-			const aliasedColumns = Object.fromEntries(
-				Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
-			);
-
-			if (config.where) {
-				const whereSql = typeof config.where === 'function'
-					? config.where(aliasedColumns, getOperators())
-					: config.where;
-				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-			}
-
-			const fieldsSelection: { tsKey: string; value: SQLiteColumn | SQL.Aliased }[] = [];
-			let selectedColumns: string[] = [];
-
-			// Figure out which columns to select
-			if (config.columns) {
-				let isIncludeMode = false;
+	private nestedSelectionerror() {
+		throw new DrizzleError({
+			message: `Views with nested selections are not supported by the relational query builder`,
+		});
+	}
 
-				for (const [field, value] of Object.entries(config.columns)) {
-					if (value === undefined) {
-						continue;
-					}
+	private buildRqbColumn(table: Table | View, column: unknown, key: string, inJson: boolean) {
+		if (is(column, Column)) {
+			const name = sql`${table}.${sql.identifier(column.name)}`;
 
-					if (field in tableConfig.columns) {
-						if (!isIncludeMode && value === true) {
-							isIncludeMode = true;
-						}
-						selectedColumns.push(field);
-					}
+			switch (column.columnType) {
+				case 'SQLiteBigInt':
+				case 'SQLiteBlobJson':
+				case 'SQLiteBlobBuffer': {
+					if (!inJson) return sql`${name} as ${sql.identifier(key)}`;
+					return sql`hex(${name}) as ${sql.identifier(key)}`;
 				}
 
-				if (selectedColumns.length > 0) {
-					selectedColumns = isIncludeMode
-						? selectedColumns.filter((c) => config.columns?.[c] === true)
-						: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+				case 'SQLiteNumeric':
+				case 'SQLiteNumericNumber':
+				case 'SQLiteNumericBigInt': {
+					// Special case - needs casting in root of query as well for drivers chop it down to number by default
+					// TODO: handle with codecs
+					return sql`cast(${name} as text) as ${sql.identifier(key)}`;
 				}
-			} else {
-				// Select all columns if selection is not specified
-				selectedColumns = Object.keys(tableConfig.columns);
-			}
-
-			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as SQLiteColumn;
-				fieldsSelection.push({ tsKey: field, value: column });
-			}
 
-			let selectedRelations: {
-				tsKey: string;
-				queryConfig: true | DBQueryConfig<'many', false>;
-				relation: Relation;
-			}[] = [];
-
-			// Figure out which relations to select
-			if (config.with) {
-				selectedRelations = Object.entries(config.with)
-					.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
-					.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
-			}
+				case 'SQLiteCustomColumn': {
+					if (!inJson) return sql`${name} as ${sql.identifier(key)}`;
+					return sql`${(<SQLiteCustomColumn<any>> column).jsonSelectIdentifier(name, sql)} as ${sql.identifier(key)}`;
+				}
 
-			let extras;
-
-			// Figure out which extras to select
-			if (config.extras) {
-				extras = typeof config.extras === 'function'
-					? config.extras(aliasedColumns, { sql })
-					: config.extras;
-				for (const [tsKey, value] of Object.entries(extras)) {
-					fieldsSelection.push({
-						tsKey,
-						value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-					});
+				default: {
+					return sql`${name} as ${sql.identifier(key)}`;
 				}
 			}
+		}
 
-			// Transform `fieldsSelection` into `selection`
-			// `fieldsSelection` shouldn't be used after this point
-			for (const { tsKey, value } of fieldsSelection) {
+		return sql`${table}.${
+			is(column, SQL.Aliased)
+				? sql.identifier(column.fieldAlias)
+				: isSQLWrapper(column)
+				? sql.identifier(key)
+				: this.nestedSelectionerror()
+		} as ${sql.identifier(key)}`;
+	}
+
+	private unwrapAllColumns = (
+		table: Table | View,
+		selection: BuildRelationalQueryResult['selection'],
+		inJson: boolean,
+	) => {
+		return sql.join(
+			Object.entries(table[TableColumns]).map(([k, v]) => {
 				selection.push({
-					dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
-					tsKey,
-					field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-					relationTableTsKey: undefined,
-					isJson: false,
-					selection: [],
+					key: k,
+					field: v as Column | SQL | SQLWrapper | SQL.Aliased,
 				});
-			}
 
-			let orderByOrig = typeof config.orderBy === 'function'
-				? config.orderBy(aliasedColumns, getOrderByOperators())
-				: config.orderBy ?? [];
-			if (!Array.isArray(orderByOrig)) {
-				orderByOrig = [orderByOrig];
+				return this.buildRqbColumn(table, v, k, inJson);
+			}),
+			sql`, `,
+		);
+	};
+
+	private getSelectedTableColumns = (
+		table: Table | View,
+		columns: Record<string, boolean | undefined>,
+	) => {
+		const selectedColumns: ColumnWithTSName[] = [];
+		const columnContainer = table[TableColumns];
+		const entries = Object.entries(columns);
+
+		let colSelectionMode: boolean | undefined;
+		for (const [k, v] of entries) {
+			if (v === undefined) continue;
+			colSelectionMode = colSelectionMode || v;
+
+			if (v) {
+				const column = columnContainer[k]!;
+
+				selectedColumns.push({
+					column: column as Column | SQL | SQLWrapper | SQL.Aliased,
+					tsName: k,
+				});
 			}
-			orderBy = orderByOrig.map((orderByValue) => {
-				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as SQLiteColumn;
-				}
-				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-			});
+		}
 
-			limit = config.limit;
-			offset = config.offset;
+		if (colSelectionMode === false) {
+			for (const [k, v] of Object.entries(columnContainer)) {
+				if (columns[k] === false) continue;
 
-			// Process all relations
-			for (
-				const {
-					tsKey: selectedRelationTsKey,
-					queryConfig: selectedRelationConfigValue,
-					relation,
-				} of selectedRelations
-			) {
-				const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-				const relationTableName = getTableUniqueName(relation.referencedTable);
-				const relationTableTsName = tableNamesMap[relationTableName]!;
-				const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
-				// const relationTable = schema[relationTableTsName]!;
-				const joinOn = and(
-					...normalizedRelation.fields.map((field, i) =>
-						eq(
-							aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
-							aliasedTableColumn(field, tableAlias),
-						)
-					),
-				);
-				const builtRelation = this.buildRelationalQuery({
-					fullSchema,
-					schema,
-					tableNamesMap,
-					table: fullSchema[relationTableTsName] as SQLiteTable,
-					tableConfig: schema[relationTableTsName]!,
-					queryConfig: is(relation, One)
-						? (selectedRelationConfigValue === true
-							? { limit: 1 }
-							: { ...selectedRelationConfigValue, limit: 1 })
-						: selectedRelationConfigValue,
-					tableAlias: relationTableAlias,
-					joinOn,
-					nestedQueryRelation: relation,
-				});
-				const field = (sql`(${builtRelation.sql})`).as(selectedRelationTsKey);
-				selection.push({
-					dbKey: selectedRelationTsKey,
-					tsKey: selectedRelationTsKey,
-					field,
-					relationTableTsKey: relationTableTsName,
-					isJson: true,
-					selection: builtRelation.selection,
+				selectedColumns.push({
+					column: v as Column | SQL | SQLWrapper | SQL.Aliased | Table,
+					tsName: k,
 				});
 			}
 		}
 
-		if (selection.length === 0) {
-			throw new DrizzleError({
-				message:
-					`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
-			});
-		}
+		return selectedColumns;
+	};
+
+	private buildColumns = (
+		table: SQLiteTable | SQLiteView,
+		selection: BuildRelationalQueryResult['selection'],
+		inJson: boolean,
+		params?: DBQueryConfig<'many'>,
+	) =>
+		params?.columns
+			? (() => {
+				const columnIdentifiers: SQL[] = [];
+
+				const selectedColumns = this.getSelectedTableColumns(
+					table,
+					params?.columns,
+				);
 
-		let result;
+				for (const { column, tsName } of selectedColumns) {
+					columnIdentifiers.push(this.buildRqbColumn(table, column, tsName, inJson));
+					selection.push({
+						key: tsName,
+						field: column,
+					});
+				}
 
-		where = and(joinOn, where);
+				return columnIdentifiers.length
+					? sql.join(columnIdentifiers, sql`, `)
+					: undefined;
+			})()
+			: this.unwrapAllColumns(table, selection, inJson);
 
-		if (nestedQueryRelation) {
-			let field = sql`json_array(${
-				sql.join(
-					selection.map(({ field }) =>
-						is(field, SQLiteColumn)
-							? sql.identifier(this.casing.getColumnCasing(field))
-							: is(field, SQL.Aliased)
-							? field.sql
-							: field
-					),
-					sql`, `,
-				)
-			})`;
-			if (is(nestedQueryRelation, Many)) {
-				field = sql`coalesce(json_group_array(${field}), json_array())`;
-			}
-			const nestedSelection = [{
-				dbKey: 'data',
-				tsKey: 'data',
-				field: field.as('data'),
-				isJson: true,
-				relationTableTsKey: tableConfig.tsName,
-				selection,
-			}];
-
-			const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
-
-			if (needsSubquery) {
-				result = this.buildSelectQuery({
-					table: aliasedTable(table, tableAlias),
-					fields: {},
-					fieldsFlat: [
-						{
-							path: [],
-							field: sql.raw('*'),
-						},
-					],
-					where,
-					limit,
-					offset,
-					orderBy,
-					setOperators: [],
-				});
+	buildRelationalQuery({
+		schema,
+		table,
+		tableConfig,
+		queryConfig: config,
+		relationWhere,
+		mode,
+		isNested,
+		errorPath,
+		depth,
+		throughJoin,
+		jsonb,
+	}: {
+		schema: TablesRelationalConfig;
+		table: SQLiteTable | SQLiteView;
+		tableConfig: TableRelationalConfig;
+		queryConfig?: DBQueryConfig<'many'> | true;
+		relationWhere?: SQL;
+		mode: 'first' | 'many';
+		isNested?: boolean;
+		errorPath?: string;
+		depth?: number;
+		throughJoin?: SQL;
+		jsonb: SQL;
+	}): BuildRelationalQueryResult {
+		const selection: BuildRelationalQueryResult['selection'] = [];
+		const isSingle = mode === 'first';
+		const params = config === true ? undefined : config;
+		const currentPath = errorPath ?? '';
+		const currentDepth = depth ?? 0;
+		if (!currentDepth) table = aliasedTable(table, `d${currentDepth}`);
+
+		const limit = isSingle ? 1 : params?.limit;
+		const offset = params?.offset;
+
+		const columns = this.buildColumns(table, selection, !!isNested, params);
+
+		const where: SQL | undefined = params?.where && relationWhere
+			? and(
+				relationsFilterToSQL(
+					table,
+					params.where,
+					tableConfig.relations,
+					schema,
+				),
+				relationWhere,
+			)
+			: params?.where
+			? relationsFilterToSQL(
+				table,
+				params.where,
+				tableConfig.relations,
+				schema,
+			)
+			: relationWhere;
+		const order = params?.orderBy
+			? relationsOrderToSQL(table, params.orderBy)
+			: undefined;
+		const extras = params?.extras
+			? relationExtrasToSQL(table, params.extras)
+			: undefined;
+		if (extras) selection.push(...extras.selection);
 
-				where = undefined;
-				limit = undefined;
-				offset = undefined;
-				orderBy = undefined;
-			} else {
-				result = aliasedTable(table, tableAlias);
-			}
+		const joins = params
+			? (() => {
+				const { with: joins } = params as WithContainer;
+				if (!joins) return;
 
-			result = this.buildSelectQuery({
-				table: is(result, SQLiteTable) ? result : new Subquery(result, {}, tableAlias),
-				fields: {},
-				fieldsFlat: nestedSelection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		} else {
-			result = this.buildSelectQuery({
-				table: aliasedTable(table, tableAlias),
-				fields: {},
-				fieldsFlat: selection.map(({ field }) => ({
-					path: [],
-					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-				})),
-				joins,
-				where,
-				limit,
-				offset,
-				orderBy,
-				setOperators: [],
-			});
-		}
+				const withEntries = Object.entries(joins).filter(([_, v]) => v);
+				if (!withEntries.length) return;
 
-		return {
-			tableTsKey: tableConfig.tsName,
-			sql: result,
-			selection,
-		};
-	}
-}
+				return sql.join(
+					withEntries.map(([k, join]) => {
+						// if (is(tableConfig.relations[k]!, AggregatedField)) {
+						// 	const relation = tableConfig.relations[k]!;
 
-export class SQLiteSyncDialect extends SQLiteDialect {
-	static override readonly [entityKind]: string = 'SQLiteSyncDialect';
-
-	migrate(
-		migrations: MigrationMeta[],
-		session: SQLiteSession<'sync', unknown, Record<string, unknown>, TablesRelationalConfig>,
-		config?: string | MigrationConfig,
-	): void {
-		const migrationsTable = config === undefined
-			? '__drizzle_migrations'
-			: typeof config === 'string'
-			? '__drizzle_migrations'
-			: config.migrationsTable ?? '__drizzle_migrations';
-
-		const migrationTableCreate = sql`
-			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-				id SERIAL PRIMARY KEY,
-				hash text NOT NULL,
-				created_at numeric
-			)
-		`;
-		session.run(migrationTableCreate);
+						// 	relation.onTable(table);
+						// 	const query = relation.getSQL();
 
-		const dbMigrations = session.values<[number, string, string]>(
-			sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
-		);
+						// 	selection.push({
+						// 		key: k,
+						// 		field: relation,
+						// 	});
 
-		const lastDbMigration = dbMigrations[0] ?? undefined;
-		session.run(sql`BEGIN`);
+						// 	return sql`(${query}) as ${sql.identifier(k)}`;
+						// }
 
-		try {
-			for (const migration of migrations) {
-				if (!lastDbMigration || Number(lastDbMigration[2])! < migration.folderMillis) {
-					for (const stmt of migration.sql) {
-						session.run(sql.raw(stmt));
-					}
-					session.run(
-						sql`INSERT INTO ${
-							sql.identifier(migrationsTable)
-						} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
-					);
-				}
-			}
+						const relation = tableConfig.relations[k]! as Relation;
+						const isSingle = is(relation, One);
+						const targetTable = aliasedTable(
+							relation.targetTable,
+							`d${currentDepth + 1}`,
+						);
+						const throughTable = relation.throughTable
+							? aliasedTable(relation.throughTable, `tr${currentDepth}`)
+							: undefined;
+						const { filter, joinCondition } = relationToSQL(
+							relation,
+							table,
+							targetTable,
+							throughTable,
+						);
 
-			session.run(sql`COMMIT`);
-		} catch (e) {
-			session.run(sql`ROLLBACK`);
-			throw e;
-		}
-	}
-}
+						const throughJoin = throughTable
+							? sql` inner join ${getTableAsAliasSQL(throughTable)} on ${joinCondition!}`
+							: undefined;
+
+						const innerQuery = this.buildRelationalQuery({
+							table: targetTable as SQLiteTable | SQLiteView,
+							mode: isSingle ? 'first' : 'many',
+							schema,
+							queryConfig: join as DBQueryConfig,
+							tableConfig: schema[relation.targetTableName]!,
+							relationWhere: filter,
+							isNested: true,
+							errorPath: `${currentPath.length ? `${currentPath}.` : ''}${k}`,
+							depth: currentDepth + 1,
+							throughJoin,
+							jsonb,
+						});
+
+						selection.push({
+							field: targetTable,
+							key: k,
+							selection: innerQuery.selection,
+							isArray: !isSingle,
+							isOptional: ((relation as AnyOne).optional ?? false)
+								|| (join !== true
+									&& !!(join as Exclude<typeof join, boolean | undefined>)
+										.where),
+						});
+
+						const jsonColumns = sql.join(
+							innerQuery.selection.map((s) => {
+								return sql`${sql.raw(this.escapeString(s.key))}, ${
+									s.selection
+										? sql`${jsonb}(${sql.identifier(s.key)})`
+										: sql.identifier(s.key)
+								}`;
+							}),
+							sql`, `,
+						);
 
-export class SQLiteAsyncDialect extends SQLiteDialect {
-	static override readonly [entityKind]: string = 'SQLiteAsyncDialect';
-
-	async migrate(
-		migrations: MigrationMeta[],
-		session: SQLiteSession<'async', any, any, any>,
-		config?: string | MigrationConfig,
-	): Promise<void> {
-		const migrationsTable = config === undefined
-			? '__drizzle_migrations'
-			: typeof config === 'string'
-			? '__drizzle_migrations'
-			: config.migrationsTable ?? '__drizzle_migrations';
-
-		const migrationTableCreate = sql`
-			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-				id SERIAL PRIMARY KEY,
-				hash text NOT NULL,
-				created_at numeric
-			)
-		`;
-		await session.run(migrationTableCreate);
+						const json = isNested ? jsonb : sql`json`;
+
+						const joinQuery = isSingle
+							? sql`(select ${json}_object(${jsonColumns}) as ${sql.identifier('r')} from (${innerQuery.sql}) as ${
+								sql.identifier(
+									't',
+								)
+							}) as ${sql.identifier(k)}`
+							: sql`coalesce((select ${json}_group_array(json_object(${jsonColumns})) as ${
+								sql.identifier(
+									'r',
+								)
+							} from (${innerQuery.sql}) as ${sql.identifier('t')}), ${jsonb}_array()) as ${sql.identifier(k)}`;
+
+						return joinQuery;
+					}),
+					sql`, `,
+				);
+			})()
+			: undefined;
 
-		const dbMigrations = await session.values<[number, string, string]>(
-			sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
+		const selectionArr = [columns, extras?.sql, joins].filter(
+			(e) => e !== undefined,
 		);
+		if (!selectionArr.length) {
+			throw new DrizzleError({
+				message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ''}`,
+			});
+		}
+		const selectionSet = sql.join(selectionArr, sql`, `);
 
-		const lastDbMigration = dbMigrations[0] ?? undefined;
+		const query = sql`select ${selectionSet} from ${getTableAsAliasSQL(table)}${throughJoin}${
+			sql` where ${where}`.if(
+				where,
+			)
+		}${sql` order by ${order}`.if(order)}${sql` limit ${limit}`.if(limit !== undefined)}${
+			sql` offset ${offset}`.if(
+				offset !== undefined,
+			)
+		}`;
 
-		await session.transaction(async (tx) => {
-			for (const migration of migrations) {
-				if (!lastDbMigration || Number(lastDbMigration[2])! < migration.folderMillis) {
-					for (const stmt of migration.sql) {
-						await tx.run(sql.raw(stmt));
-					}
-					await tx.run(
-						sql`INSERT INTO ${
-							sql.identifier(migrationsTable)
-						} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
-					);
-				}
-			}
-		});
+		return {
+			sql: query,
+			selection,
+		};
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/effect/count.ts b/drizzle-orm/src/sqlite-core/effect/count.ts
new file mode 100644
index 0000000000..a61652ac43
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/count.ts
@@ -0,0 +1,54 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteCountBuilder } from '~/sqlite-core/query-builders/count.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { SQLiteViewBase } from '~/sqlite-core/view-base.ts';
+import type { SQLiteEffectSession } from './session.ts';
+
+export interface SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteCountBuilder, QueryEffectKind<TEffectHKT, number>
+{}
+
+export class SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteCountBuilder
+{
+	static override readonly [entityKind]: string = 'SQLiteEffectCountBuilder';
+
+	declare protected session: SQLiteEffectSession<any, TEffectHKT, any>;
+
+	constructor(
+		countConfig: {
+			source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper;
+			filters?: SQL<unknown>;
+			dialect: SQLiteDialect;
+			session: SQLiteEffectSession<any, TEffectHKT, any>;
+		},
+	) {
+		super(countConfig);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.session.prepareQuery<{
+			type: unknown;
+			run: unknown;
+			all: number;
+			get: number;
+			values: unknown;
+			execute: number;
+		}>(
+			this.build(),
+			'arrays',
+			false,
+			'all',
+			(rows) => {
+				const v = rows[0]?.[0];
+				if (typeof v === 'number') return v;
+				return v ? Number(v) : 0;
+			},
+		).execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(SQLiteEffectCountBuilder);
diff --git a/drizzle-orm/src/sqlite-core/effect/db.ts b/drizzle-orm/src/sqlite-core/effect/db.ts
new file mode 100644
index 0000000000..89e3db1456
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/db.ts
@@ -0,0 +1,651 @@
+import { Effect } from 'effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import type { MutationOption } from '~/cache/core/cache.ts';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { type ColumnsSelection, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteEffectCountBuilder } from '~/sqlite-core/effect/count.ts';
+import { SQLiteEffectDeleteBase } from '~/sqlite-core/effect/delete.ts';
+import { SQLiteEffectInsertBase, type SQLiteEffectInsertBuilder } from '~/sqlite-core/effect/insert.ts';
+import { SQLiteEffectRelationalQuery, type SQLiteEffectRelationalQueryHKT } from '~/sqlite-core/effect/query.ts';
+import { SQLiteEffectRaw } from '~/sqlite-core/effect/raw.ts';
+import { SQLiteEffectSelectBase, type SQLiteEffectSelectBuilder } from '~/sqlite-core/effect/select.ts';
+import { SQLiteEffectUpdateBase, type SQLiteEffectUpdateBuilder } from '~/sqlite-core/effect/update.ts';
+import { SQLiteInsertBuilder } from '~/sqlite-core/query-builders/insert.ts';
+import { RelationalQueryBuilder } from '~/sqlite-core/query-builders/query.ts';
+import { SQLiteSelectBuilder } from '~/sqlite-core/query-builders/select.ts';
+import { SQLiteUpdateBuilder } from '~/sqlite-core/query-builders/update.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { QueryBuilder } from '../query-builders/query-builder.ts';
+import type { SelectedFields } from '../query-builders/select.types.ts';
+import type { PreparedQueryConfig, SQLiteTransactionConfig } from '../session.ts';
+import type { WithBuilder } from '../subquery.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
+import type { SQLiteEffectSession, SQLiteEffectTransaction } from './session.ts';
+
+export class SQLiteEffectDatabase<
+	TEffectHKT extends QueryEffectHKTBase,
+	TRunResult,
+	TRelations extends AnyRelations = EmptyRelations,
+> {
+	static readonly [entityKind]: string = 'SQLiteEffectDatabase';
+
+	declare readonly _: {
+		readonly relations: TRelations;
+		readonly session: SQLiteEffectSession<TRunResult, TEffectHKT, TRelations>;
+	};
+
+	// TO-DO: Figure out how to pass DrizzleTypeError without breaking withReplicas
+	query: {
+		[K in keyof TRelations]: RelationalQueryBuilder<
+			unknown,
+			TRelations,
+			TRelations[K],
+			SQLiteEffectRelationalQueryHKT<TEffectHKT>
+		>;
+	};
+
+	constructor(
+		/** @internal */
+		readonly dialect: SQLiteDialect,
+		/** @internal */
+		readonly session: SQLiteEffectSession<TRunResult, TEffectHKT, TRelations>,
+		relations: TRelations,
+		readonly forbidJsonb?: boolean,
+	) {
+		this._ = {
+			relations,
+			session,
+		};
+		this.query = {} as typeof this['query'];
+		for (const [tableName, relation] of Object.entries(relations)) {
+			(this.query as SQLiteEffectDatabase<
+				TEffectHKT,
+				TRunResult,
+				AnyRelations
+			>['query'])[tableName] = new RelationalQueryBuilder(
+				undefined,
+				relations,
+				relations[relation.name]!.table as SQLiteTable,
+				relation,
+				dialect,
+				session,
+				forbidJsonb,
+				SQLiteEffectRelationalQuery,
+			);
+		}
+		this.$cache = { invalidate: (_params: MutationOption) => Effect.void };
+	}
+
+	/**
+	 * Creates a subquery that defines a temporary named result set as a CTE.
+	 *
+	 * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param alias The alias for the subquery.
+	 *
+	 * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Create a subquery with alias 'sq' and use it in the select query
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 *
+	 * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	 *
+	 * ```ts
+	 * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	 * const sq = db.$with('sq').as(db.select({
+	 *   name: sql<string>`upper(${users.name})`.as('name'),
+	 * })
+	 * .from(users));
+	 *
+	 * const result = yield* db.with(sq).select({ name: sq.name }).from(sq);
+	 * ```
+	 */
+	$with: WithBuilder = (alias: string, selection?: ColumnsSelection) => {
+		const self = this;
+		const as = (
+			qb:
+				| TypedQueryBuilder<ColumnsSelection | undefined>
+				| SQL
+				| ((qb: QueryBuilder) => TypedQueryBuilder<ColumnsSelection | undefined> | SQL),
+		) => {
+			if (typeof qb === 'function') {
+				qb = qb(new QueryBuilder(self.dialect));
+			}
+
+			return new Proxy(
+				new WithSubquery(
+					qb.getSQL(),
+					selection ?? ('getSelectedFields' in qb ? qb.getSelectedFields() ?? {} : {}) as SelectedFields,
+					alias,
+					true,
+				),
+				new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+			);
+		};
+		return { as };
+	};
+
+	$count(
+		source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper,
+		filters?: SQL<unknown>,
+	): SQLiteEffectCountBuilder<TEffectHKT> {
+		return new SQLiteEffectCountBuilder({
+			source,
+			filters,
+			session: this.session,
+			dialect: this.dialect,
+		});
+	}
+
+	$cache: { invalidate: EffectCacheShape['onMutate'] };
+
+	/**
+	 * Incorporates a previously defined CTE (using `$with`) into the main query.
+	 *
+	 * This method allows the main query to reference a temporary named result set.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	 *
+	 * @param queries The CTEs to incorporate into the main query.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Define a subquery 'sq' as a CTE using $with
+	 * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	 *
+	 * // Incorporate the CTE 'sq' into the main query and select from it
+	 * const result = yield* db.with(sq).select().from(sq);
+	 * ```
+	 */
+	with(...queries: WithSubquery[]) {
+		const self = this;
+
+		/**
+		 * Creates a select query.
+		 *
+		 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all columns and all rows from the 'cars' table
+		 * const allCars: Car[] = yield* db.select().from(cars);
+		 *
+		 * // Select specific columns and all rows from the 'cars' table
+		 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   brand: cars.brand
+		 * })
+		 *   .from(cars);
+		 * ```
+		 *
+		 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+		 *
+		 * ```ts
+		 * // Select specific columns along with expression and all rows from the 'cars' table
+		 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+		 *   id: cars.id,
+		 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+		 * })
+		 *   .from(cars);
+		 * ```
+		 */
+		function select(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+		function select(
+			fields?: SelectedFields,
+		): SQLiteEffectSelectBuilder<SelectedFields | undefined, TRunResult, TEffectHKT> {
+			return new SQLiteSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+			}, SQLiteEffectSelectBase);
+		}
+
+		/**
+		 * Adds `distinct` expression to the select query.
+		 *
+		 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+		 *
+		 * Use `.from()` method to specify which table to select from.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+		 *
+		 * @param fields The selection object.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Select all unique rows from the 'cars' table
+		 * yield* db.selectDistinct()
+		 *   .from(cars)
+		 *   .orderBy(cars.id, cars.brand, cars.color);
+		 *
+		 * // Select all unique brands from the 'cars' table
+		 * yield* db.selectDistinct({ brand: cars.brand })
+		 *   .from(cars)
+		 *   .orderBy(cars.brand);
+		 * ```
+		 */
+		function selectDistinct(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+		function selectDistinct<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+		function selectDistinct(
+			fields?: SelectedFields,
+		): SQLiteEffectSelectBuilder<SelectedFields | undefined, TRunResult, TEffectHKT> {
+			return new SQLiteSelectBuilder({
+				fields: fields ?? undefined,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true,
+			}, SQLiteEffectSelectBase);
+		}
+
+		/**
+		 * Creates an update query.
+		 *
+		 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+		 *
+		 * Use `.set()` method to specify which values to update.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/update}
+		 *
+		 * @param table The table to update.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Update all rows in the 'cars' table
+		 * yield* db.update(cars).set({ color: 'red' });
+		 *
+		 * // Update rows with filters and conditions
+		 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+		 *
+		 * // Update with returning clause
+		 * const updatedCar: Car[] = yield* db.update(cars)
+		 *   .set({ color: 'red' })
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function update<TTable extends SQLiteTable>(
+			table: TTable,
+		): SQLiteEffectUpdateBuilder<TTable, TRunResult, TEffectHKT> {
+			return new SQLiteUpdateBuilder(table, self.session, self.dialect, queries, SQLiteEffectUpdateBase);
+		}
+
+		/**
+		 * Creates an insert query.
+		 *
+		 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/insert}
+		 *
+		 * @param table The table to insert into.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Insert one row
+		 * yield* db.insert(cars).values({ brand: 'BMW' });
+		 *
+		 * // Insert multiple rows
+		 * yield* db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+		 *
+		 * // Insert with returning clause
+		 * const insertedCar: Car[] = yield* db.insert(cars)
+		 *   .values({ brand: 'BMW' })
+		 *   .returning();
+		 * ```
+		 */
+		function insert<TTable extends SQLiteTable>(
+			into: TTable,
+		): SQLiteEffectInsertBuilder<TTable, TRunResult, TEffectHKT> {
+			return new SQLiteInsertBuilder(into, self.session, self.dialect, queries, SQLiteEffectInsertBase);
+		}
+
+		/**
+		 * Creates a delete query.
+		 *
+		 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+		 *
+		 * See docs: {@link https://orm.drizzle.team/docs/delete}
+		 *
+		 * @param table The table to delete from.
+		 *
+		 * @example
+		 *
+		 * ```ts
+		 * // Delete all rows in the 'cars' table
+		 * yield* db.delete(cars);
+		 *
+		 * // Delete rows with filters and conditions
+		 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+		 *
+		 * // Delete with returning clause
+		 * const deletedCar: Car[] = yield* db.delete(cars)
+		 *   .where(eq(cars.id, 1))
+		 *   .returning();
+		 * ```
+		 */
+		function delete_<TTable extends SQLiteTable>(
+			from: TTable,
+		): SQLiteEffectDeleteBase<TTable, TRunResult, undefined, false, never, TEffectHKT> {
+			return new SQLiteEffectDeleteBase(from, self.session, self.dialect, queries);
+		}
+
+		return { select, selectDistinct, update, insert, delete: delete_ };
+	}
+
+	/**
+	 * Creates a select query.
+	 *
+	 * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all columns and all rows from the 'cars' table
+	 * const allCars: Car[] = yield* db.select().from(cars);
+	 *
+	 * // Select specific columns and all rows from the 'cars' table
+	 * const carsIdsAndBrands: { id: number; brand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   brand: cars.brand
+	 * })
+	 *   .from(cars);
+	 * ```
+	 *
+	 * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+	 *
+	 * ```ts
+	 * // Select specific columns along with expression and all rows from the 'cars' table
+	 * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = yield* db.select({
+	 *   id: cars.id,
+	 *   lowerBrand: sql<string>`lower(${cars.brand})`,
+	 * })
+	 *   .from(cars);
+	 * ```
+	 */
+	select(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+	select<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+	select(fields?: SelectedFields): SQLiteEffectSelectBuilder<SelectedFields | undefined, TRunResult, TEffectHKT> {
+		return new SQLiteSelectBuilder(
+			{ fields: fields ?? undefined, session: this.session, dialect: this.dialect },
+			SQLiteEffectSelectBase,
+		);
+	}
+
+	/**
+	 * Adds `distinct` expression to the select query.
+	 *
+	 * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+	 *
+	 * Use `.from()` method to specify which table to select from.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+	 *
+	 * @param fields The selection object.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Select all unique rows from the 'cars' table
+	 * yield* db.selectDistinct()
+	 *   .from(cars)
+	 *   .orderBy(cars.id, cars.brand, cars.color);
+	 *
+	 * // Select all unique brands from the 'cars' table
+	 * yield* db.selectDistinct({ brand: cars.brand })
+	 *   .from(cars)
+	 *   .orderBy(cars.brand);
+	 * ```
+	 */
+	selectDistinct(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+	selectDistinct(
+		fields?: SelectedFields,
+	): SQLiteEffectSelectBuilder<SelectedFields | undefined, TRunResult, TEffectHKT> {
+		return new SQLiteSelectBuilder({
+			fields: fields ?? undefined,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true,
+		}, SQLiteEffectSelectBase);
+	}
+
+	/**
+	 * Creates an update query.
+	 *
+	 * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	 *
+	 * Use `.set()` method to specify which values to update.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/update}
+	 *
+	 * @param table The table to update.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Update all rows in the 'cars' table
+	 * yield* db.update(cars).set({ color: 'red' });
+	 *
+	 * // Update rows with filters and conditions
+	 * yield* db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	 *
+	 * // Update with returning clause
+	 * const updatedCar: Car[] = yield* db.update(cars)
+	 *   .set({ color: 'red' })
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	update<TTable extends SQLiteTable>(
+		table: TTable,
+	): SQLiteEffectUpdateBuilder<TTable, TRunResult, TEffectHKT> {
+		return new SQLiteUpdateBuilder(table, this.session, this.dialect, undefined, SQLiteEffectUpdateBase);
+	}
+
+	/**
+	 * Creates an insert query.
+	 *
+	 * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/insert}
+	 *
+	 * @param table The table to insert into.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Insert one row
+	 * yield* db.insert(cars).values({ brand: 'BMW' });
+	 *
+	 * // Insert multiple rows
+	 * yield* db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	 *
+	 * // Insert with returning clause
+	 * const insertedCar: Car[] = yield* db.insert(cars)
+	 *   .values({ brand: 'BMW' })
+	 *   .returning();
+	 * ```
+	 */
+	insert<TTable extends SQLiteTable>(
+		into: TTable,
+	): SQLiteEffectInsertBuilder<TTable, TRunResult, TEffectHKT> {
+		return new SQLiteInsertBuilder(into, this.session, this.dialect, undefined, SQLiteEffectInsertBase);
+	}
+
+	/**
+	 * Creates a delete query.
+	 *
+	 * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	 *
+	 * See docs: {@link https://orm.drizzle.team/docs/delete}
+	 *
+	 * @param table The table to delete from.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * // Delete all rows in the 'cars' table
+	 * yield* db.delete(cars);
+	 *
+	 * // Delete rows with filters and conditions
+	 * yield* db.delete(cars).where(eq(cars.color, 'green'));
+	 *
+	 * // Delete with returning clause
+	 * const deletedCar: Car[] = yield* db.delete(cars)
+	 *   .where(eq(cars.id, 1))
+	 *   .returning();
+	 * ```
+	 */
+	delete<TTable extends SQLiteTable>(
+		from: TTable,
+	): SQLiteEffectDeleteBase<TTable, TRunResult, undefined, false, never, TEffectHKT> {
+		return new SQLiteEffectDeleteBase(from, this.session, this.dialect);
+	}
+
+	run(query: SQLWrapper | string): SQLiteEffectRaw<TRunResult, TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<PreparedQueryConfig & { execute: TRunResult }>(
+			builtQuery,
+			'raw',
+			false,
+			'run',
+		);
+		return new SQLiteEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	all<T = unknown>(query: SQLWrapper | string): SQLiteEffectRaw<T[], TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+			builtQuery,
+			'objects',
+			false,
+			'all',
+		);
+		return new SQLiteEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	get<T = unknown>(query: SQLWrapper | string): SQLiteEffectRaw<T, TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<PreparedQueryConfig & { execute: T }>(
+			builtQuery,
+			'objects',
+			false,
+			'get',
+		);
+		return new SQLiteEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	values<T extends unknown[] = unknown[]>(query: SQLWrapper | string): SQLiteEffectRaw<T[], TEffectHKT> {
+		const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+		const builtQuery = this.dialect.sqlToQuery(sequel);
+		const prepared = this.session.prepareQuery<PreparedQueryConfig & { execute: T[] }>(
+			builtQuery,
+			'objects',
+			false,
+			'values',
+		);
+		return new SQLiteEffectRaw(prepared, sequel, builtQuery);
+	}
+
+	transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<TEffectHKT, TRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+		config?: SQLiteTransactionConfig,
+	): Effect.Effect<A, E | SqlError, R> {
+		return this.session.transaction(transaction, config);
+	}
+}
+
+export type SQLiteEffectWithReplicas<Q> = Q & { $primary: Q; $replicas: Q[] };
+
+export const withReplicas = <
+	TEffectHKT extends QueryEffectHKTBase,
+	TRunResult,
+	TRelations extends AnyRelations,
+	Q extends SQLiteEffectDatabase<TEffectHKT, TRunResult, TRelations>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): SQLiteEffectWithReplicas<Q> => {
+	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
+	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
+	const $count: Q['$count'] = (...args: [any]) => getReplica(replicas).$count(...args);
+	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
+
+	const update: Q['update'] = (...args: [any]) => primary.update(...args);
+	const insert: Q['insert'] = (...args: [any]) => primary.insert(...args);
+	const $delete: Q['delete'] = (...args: [any]) => primary.delete(...args);
+	const run: Q['run'] = (...args: [any]) => primary.run(...args);
+	const all: Q['all'] = (...args: [any]) => primary.all(...args);
+	const get: Q['get'] = (...args: [any]) => primary.get(...args);
+	const values: Q['values'] = (...args: [any]) => primary.values(...args);
+	const transaction: Q['transaction'] = (...args: [any]) => primary.transaction(...args);
+
+	return {
+		...primary,
+		update,
+		insert,
+		delete: $delete,
+		run,
+		all,
+		get,
+		values,
+		transaction,
+		$primary: primary,
+		$replicas: replicas,
+		select,
+		selectDistinct,
+		$count,
+		with: $with,
+		get query() {
+			return getReplica(replicas).query;
+		},
+	};
+};
diff --git a/drizzle-orm/src/sqlite-core/effect/delete.ts b/drizzle-orm/src/sqlite-core/effect/delete.ts
new file mode 100644
index 0000000000..08fbbb656a
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/delete.ts
@@ -0,0 +1,128 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteDeleteHKTBase } from '~/sqlite-core/query-builders/delete.ts';
+import { SQLiteDeleteBase } from '~/sqlite-core/query-builders/delete.ts';
+import type { PreparedQueryConfig } from '~/sqlite-core/session.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { Assume, DrizzleTypeError } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from './session.ts';
+
+export interface SQLiteEffectDeleteHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteDeleteHKTBase
+{
+	_type: SQLiteEffectDeleteBase<
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnySQLiteEffectDelete = SQLiteEffectDeleteBase<any, any, any, any, any, any>;
+
+export type SQLiteEffectDelete<
+	TTable extends SQLiteTable = SQLiteTable,
+	TRunResult = unknown,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectDeleteBase<TTable, TRunResult, TReturning, true, never, TEffectHKT>;
+
+export type SQLiteEffectDeleteExecute<T extends AnySQLiteEffectDelete> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteEffectDeletePrepare<
+	T extends AnySQLiteEffectDelete,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectPreparedQuery<
+	PreparedQueryConfig & {
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'] | undefined;
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteEffectDeleteExecute<T>;
+	},
+	TEffectHKT
+>;
+
+export interface SQLiteEffectDeleteBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends QueryEffectKind<TEffectHKT, TReturning extends undefined ? TRunResult : TReturning[]> {}
+
+export class SQLiteEffectDeleteBase<
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends SQLiteDeleteBase<
+	SQLiteEffectDeleteHKT<TEffectHKT>,
+	TTable,
+	TRunResult,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteEffectDelete';
+
+	declare protected session: SQLiteEffectSession<TRunResult, TEffectHKT, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteEffectDeletePrepare<this, TEffectHKT> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'delete',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteEffectDeletePrepare<this, TEffectHKT>;
+	}
+
+	prepare(): SQLiteEffectDeletePrepare<this, TEffectHKT> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(SQLiteEffectDeleteBase);
diff --git a/drizzle-orm/src/sqlite-core/effect/index.ts b/drizzle-orm/src/sqlite-core/effect/index.ts
new file mode 100644
index 0000000000..7a4d5c2e0e
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/index.ts
@@ -0,0 +1,10 @@
+export * from './count.ts';
+export * from './db.ts';
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query.ts';
+export * from './raw.ts';
+export * from './select.ts';
+export * from './session.ts';
+export * from './update.ts';
+export * from './utils.ts';
diff --git a/drizzle-orm/src/sqlite-core/effect/insert.ts b/drizzle-orm/src/sqlite-core/effect/insert.ts
new file mode 100644
index 0000000000..85cee55921
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/insert.ts
@@ -0,0 +1,135 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteInsertBuilder, SQLiteInsertHKTBase } from '~/sqlite-core/query-builders/insert.ts';
+import { SQLiteInsertBase } from '~/sqlite-core/query-builders/insert.ts';
+import type { PreparedQueryConfig } from '~/sqlite-core/session.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { Assume, DrizzleTypeError } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from './session.ts';
+
+export interface SQLiteEffectInsertHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteInsertHKTBase
+{
+	_type: SQLiteEffectInsertBase<
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnySQLiteEffectInsert = SQLiteEffectInsertBase<any, any, any, any, any, any>;
+
+export type SQLiteEffectInsert<
+	TTable extends SQLiteTable = SQLiteTable,
+	TRunResult = unknown,
+	TReturning = any,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectInsertBase<TTable, TRunResult, TReturning, true, never, TEffectHKT>;
+
+export type SQLiteEffectInsertBuilder<
+	TTable extends SQLiteTable,
+	TRunResult,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteInsertBuilder<TTable, TRunResult, SQLiteEffectInsertHKT<TEffectHKT>>;
+
+export type SQLiteEffectInsertExecute<T extends AnySQLiteEffectInsert> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteEffectInsertPrepare<
+	T extends AnySQLiteEffectInsert,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectPreparedQuery<
+	PreparedQueryConfig & {
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteEffectInsertExecute<T>;
+	},
+	TEffectHKT
+>;
+
+export interface SQLiteEffectInsertBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends QueryEffectKind<TEffectHKT, TReturning extends undefined ? TRunResult : TReturning[]> {}
+
+export class SQLiteEffectInsertBase<
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends SQLiteInsertBase<
+	SQLiteEffectInsertHKT<TEffectHKT>,
+	TTable,
+	TRunResult,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteEffectInsert';
+
+	declare protected session: SQLiteEffectSession<TRunResult, TEffectHKT, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteEffectInsertPrepare<this, TEffectHKT> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'insert',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteEffectInsertPrepare<this, TEffectHKT>;
+	}
+
+	prepare(): SQLiteEffectInsertPrepare<this, TEffectHKT> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(SQLiteEffectInsertBase);
diff --git a/drizzle-orm/src/sqlite-core/effect/query.ts b/drizzle-orm/src/sqlite-core/effect/query.ts
new file mode 100644
index 0000000000..f41e6f0a35
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/query.ts
@@ -0,0 +1,70 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import { SQLiteRelationalQuery, type SQLiteRelationalQueryHKTBase } from '~/sqlite-core/query-builders/query.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from './session.ts';
+
+export type AnySQLiteEffectRelationalQuery = SQLiteEffectRelationalQuery<any, any>;
+
+export interface SQLiteEffectRelationalQueryHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteRelationalQueryHKTBase
+{
+	_type: SQLiteEffectRelationalQuery<this['result'], TEffectHKT>;
+}
+
+export interface SQLiteEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends QueryEffectKind<TEffectHKT, TResult>
+{}
+
+export class SQLiteEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteRelationalQuery<SQLiteEffectRelationalQueryHKT<TEffectHKT>, TResult>
+	implements RunnableQuery<TResult, 'sqlite'>
+{
+	static override readonly [entityKind]: string = 'SQLiteEffectRelationalQueryV2';
+
+	declare protected session: SQLiteEffectSession<any, TEffectHKT, any>;
+
+	/** @internal */
+	_prepare(
+		prepare = false,
+	): SQLiteEffectPreparedQuery<
+		PreparedQueryConfig & { type: unknown; all: TResult; get: TResult; execute: TResult },
+		TEffectHKT
+	> {
+		const { query, builtQuery } = this._toSQL();
+
+		const mapper = this.dialect.mapperGenerators.relationalRows({
+			isFirst: this.mode === 'first',
+			parseJson: true,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			selection: query.selection,
+			arrayModeRoot: true,
+		});
+
+		return this.session.prepareQuery(
+			builtQuery,
+			'arrays',
+			prepare,
+			'all',
+			mapper,
+		) as SQLiteEffectPreparedQuery<
+			PreparedQueryConfig & { type: unknown; all: TResult; get: TResult; execute: TResult },
+			TEffectHKT
+		>;
+	}
+
+	prepare(): SQLiteEffectPreparedQuery<
+		PreparedQueryConfig & { type: unknown; all: TResult; get: TResult; execute: TResult },
+		TEffectHKT
+	> {
+		return this._prepare(true);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this._prepare().execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(SQLiteEffectRelationalQuery);
diff --git a/drizzle-orm/src/sqlite-core/effect/raw.ts b/drizzle-orm/src/sqlite-core/effect/raw.ts
new file mode 100644
index 0000000000..bd545598af
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/raw.ts
@@ -0,0 +1,44 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
+import type { PreparedQueryConfig } from '../session.ts';
+import type { SQLiteEffectPreparedQuery } from './session.ts';
+
+export interface SQLiteEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteRaw<TResult>, QueryEffectKind<TEffectHKT, TResult>, RunnableQuery<TResult, 'sqlite'>, SQLWrapper
+{}
+
+export class SQLiteEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteRaw<TResult>
+	implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper
+{
+	static override readonly [entityKind]: string = 'SQLiteEffectRaw';
+
+	declare protected prepared: SQLiteEffectPreparedQuery<
+		PreparedQueryConfig & {
+			execute: TResult;
+		},
+		TEffectHKT
+	>;
+
+	constructor(
+		prepared: SQLiteEffectPreparedQuery<
+			PreparedQueryConfig & {
+				execute: TResult;
+			},
+			TEffectHKT
+		>,
+		sql: SQL,
+		query: Query,
+	) {
+		super(prepared, sql, query);
+	}
+
+	execute(placeholderValues?: Record<string, unknown>) {
+		return this.prepared.execute(placeholderValues);
+	}
+}
+
+applyEffectWrapper(SQLiteEffectRaw);
diff --git a/drizzle-orm/src/sqlite-core/effect/select.ts b/drizzle-orm/src/sqlite-core/effect/select.ts
new file mode 100644
index 0000000000..87d893a015
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/select.ts
@@ -0,0 +1,158 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { SQLiteSelectBase, type SQLiteSelectBuilder } from '~/sqlite-core/query-builders/select.ts';
+import type { SelectedFields, SQLiteSelectHKTBase } from '~/sqlite-core/query-builders/select.types.ts';
+import type { PreparedQueryConfig } from '~/sqlite-core/session.ts';
+import type { Assume } from '~/utils.ts';
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from './session.ts';
+
+export type SQLiteEffectSelectExecute<T extends AnySQLiteEffectSelect> = T['_']['result'];
+
+export type SQLiteEffectSelectPrepare<
+	T extends AnySQLiteEffectSelect,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectPreparedQuery<
+	PreparedQueryConfig & {
+		run: T['_']['runResult'];
+		all: T['_']['result'];
+		get: T['_']['result'][number] | undefined;
+		values: any[][];
+		execute: SQLiteEffectSelectExecute<T>;
+	},
+	TEffectHKT
+>;
+
+export type SQLiteEffectSelectBuilder<
+	TSelection extends SelectedFields | undefined,
+	TRunResult,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteSelectBuilder<TSelection, TRunResult, SQLiteEffectSelectHKT<TEffectHKT>>;
+
+export type SQLiteEffectSelect<
+	TTableName extends string | undefined = string | undefined,
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteEffectSelectBase<TTableName, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export interface SQLiteEffectSelectHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteSelectHKTBase
+{
+	_type: SQLiteEffectSelectBase<
+		this['tableName'],
+		this['runResult'],
+		Assume<this['selection'], ColumnsSelection>,
+		this['selectMode'],
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		Assume<this['result'], any[]>,
+		Assume<this['selectedFields'], ColumnsSelection>,
+		TEffectHKT
+	>;
+}
+
+export interface SQLiteEffectSelectBase<
+	TTableName extends string | undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode = 'single',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	// oxlint-disable-next-line no-unused-vars
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends QueryEffectKind<TEffectHKT, TResult> {}
+
+export class SQLiteEffectSelectBase<
+	TTableName extends string | undefined,
+	TRunResult,
+	TSelection,
+	TSelectMode extends SelectMode = 'single',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends SQLiteSelectBase<
+	SQLiteEffectSelectHKT<TEffectHKT>,
+	TTableName,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
+	static override readonly [entityKind]: string = 'SQLiteEffectSelect';
+
+	declare protected session: SQLiteEffectSession<TRunResult, TEffectHKT, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteEffectSelectPrepare<this, TEffectHKT> {
+		// Build query before accessing `fieldsFlat` - build mutates it
+		const query = this.dialect.sqlToQuery(this.getSQL());
+		const fieldsList = this.config.fieldsFlat!;
+		const mapper = this.dialect.mapperGenerators.rows(fieldsList, this.joinsNotNullableMap);
+
+		const preparedQuery = this.session.prepareQuery(
+			query,
+			'arrays',
+			prepare,
+			'all',
+			mapper,
+			{
+				type: 'select',
+				tables: [...this.usedTables],
+			},
+			this.cacheConfig,
+		);
+		return preparedQuery as ReturnType<this['prepare']>;
+	}
+
+	prepare(): SQLiteEffectSelectPrepare<this, TEffectHKT> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(SQLiteEffectSelectBase);
+
+export type AnySQLiteEffectSelect = SQLiteEffectSelectBase<any, any, any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/sqlite-core/effect/session.ts b/drizzle-orm/src/sqlite-core/effect/session.ts
new file mode 100644
index 0000000000..9a71b555b8
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/session.ts
@@ -0,0 +1,377 @@
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import { EffectCache, type EffectCacheShape } from '~/cache/core/cache-effect.ts';
+import { NoopCache, strategyFor } from '~/cache/core/cache.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { EffectDrizzleQueryError, EffectTransactionRollbackError, MigratorInitError } from '~/effect-core/errors.ts';
+import type { EffectLoggerShape } from '~/effect-core/logger.ts';
+import type { QueryEffectHKTBase, QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind, is } from '~/entity.ts';
+import type { MigrationConfig, MigrationMeta } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import {
+	type PreparedQueryConfig,
+	type SQLiteExecuteMethod,
+	SQLitePreparedQuery,
+	SQLiteSession,
+	type SQLiteTransactionConfig,
+} from '~/sqlite-core/session.ts';
+import { upgradeIfNeeded } from '~/up-migrations/effect-sqlite.ts';
+import { assertUnreachable } from '~/utils.ts';
+import { SQLiteEffectDatabase } from './db.ts';
+
+export type SQLiteEffectQueryExecutors = Record<
+	SQLiteExecuteMethod,
+	(params: unknown[]) => Effect.Effect<any, unknown, unknown>
+>;
+
+export class SQLiteEffectPreparedQuery<
+	T extends PreparedQueryConfig,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends SQLitePreparedQuery {
+	static override readonly [entityKind]: string = 'SQLiteEffectPreparedQuery';
+
+	constructor(
+		executeMethod: SQLiteExecuteMethod = 'all',
+		protected executors: SQLiteEffectQueryExecutors,
+		query: Query,
+		mapper: ((rows: any[]) => any) | undefined,
+		mode: 'arrays' | 'objects' | 'raw',
+		private logger: EffectLoggerShape,
+		// cache instance
+		protected cache: EffectCacheShape,
+		// per query related metadata
+		protected queryMetadata: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		} | undefined,
+		// config that was passed through $withCache
+		protected cacheConfig: WithCacheConfig | undefined,
+	) {
+		super(executeMethod, query, mapper, mode);
+
+		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
+			this.cacheConfig = { enabled: true, autoInvalidate: true };
+		}
+		if (!this.cacheConfig?.enabled) {
+			this.cacheConfig = undefined;
+		}
+	}
+
+	override run(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['run']> {
+		return Effect.gen({ self: this }, function*() {
+			const { query, logger, executors } = this;
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+
+			yield* logger.logQuery(sql, params);
+
+			return yield* this.queryWithCache(sql, params, 'run', Effect.suspend(() => executors.run(params)));
+		}) as QueryEffectKind<TEffectHKT, T['run']>;
+	}
+
+	override all(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['all']> {
+		return Effect.gen({ self: this }, function*() {
+			const { query, logger, executors, mapper } = this;
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+
+			yield* logger.logQuery(sql, params);
+
+			const rows = yield* this.queryWithCache(sql, params, 'all', Effect.suspend(() => executors.all(params)));
+
+			return mapper ? mapper(rows as unknown[]) : rows;
+		}) as QueryEffectKind<TEffectHKT, T['all']>;
+	}
+
+	override get(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['get']> {
+		return Effect.gen({ self: this }, function*() {
+			const { query, logger, executors, mapper } = this;
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+
+			yield* logger.logQuery(sql, params);
+
+			const row = yield* this.queryWithCache(sql, params, 'get', Effect.suspend(() => executors.get(params)));
+
+			if (!row) return;
+			if (!mapper) return row;
+			return mapper([row])[0];
+		}) as QueryEffectKind<TEffectHKT, T['get']>;
+	}
+
+	override values(placeholderValues: Record<string, unknown> = {}): QueryEffectKind<TEffectHKT, T['values']> {
+		return Effect.gen({ self: this }, function*() {
+			const { query, logger, executors } = this;
+			const sql = query._sql ? query._sql.join(' ') : query.sql;
+			const params = query.params.length === 0
+				? query.params
+				: fillPlaceholders(query.params, placeholderValues);
+
+			yield* logger.logQuery(sql, params);
+
+			return yield* this.queryWithCache(sql, params, 'values', Effect.suspend(() => executors.values(params)));
+		}) as QueryEffectKind<TEffectHKT, T['values']>;
+	}
+
+	override execute(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T['execute']> {
+		return this[this.executeMethod](placeholderValues) as QueryEffectKind<TEffectHKT, T['execute']>;
+	}
+
+	/** @internal */
+	protected queryWithCache<A, E, R>(
+		queryString: string,
+		params: any[],
+		executeMethod: SQLiteExecuteMethod,
+		query: Effect.Effect<A, E, R>,
+	) {
+		return Effect.gen({ self: this }, function*() {
+			const { cacheConfig, queryMetadata } = this;
+			const cache = yield* EffectCache;
+
+			const cacheStrat: Awaited<ReturnType<typeof strategyFor>> = cache && !(cache.cache && is(cache.cache, NoopCache))
+				? yield* Effect.tryPromise(
+					() => strategyFor(queryString, params, queryMetadata, cacheConfig),
+				)
+				: { type: 'skip' as const };
+
+			if (cacheStrat.type === 'skip') {
+				return yield* query;
+			}
+
+			// For mutate queries, we should query the database, wait for a response, and then perform invalidation
+			if (cacheStrat.type === 'invalidate') {
+				const result = yield* query;
+				yield* cache!.onMutate({ tables: cacheStrat.tables });
+
+				return result;
+			}
+
+			if (cacheStrat.type === 'try') {
+				const { tables, key: _key, isTag, autoInvalidate, config } = cacheStrat;
+				const key = `${executeMethod}_${_key}`;
+
+				const fromCache: any[] | undefined = yield* cache!.get(
+					key,
+					tables,
+					isTag,
+					autoInvalidate,
+				);
+
+				if (typeof fromCache !== 'undefined') return fromCache as unknown as A;
+
+				const result = yield* query;
+
+				yield* cache.put(
+					key,
+					result,
+					autoInvalidate ? tables : [],
+					isTag,
+					config,
+				);
+
+				return result;
+			}
+
+			assertUnreachable(cacheStrat);
+		}).pipe(
+			Effect.provideService(EffectCache, this.cache),
+			Effect.catch((e) => {
+				return Effect.fail(new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) }));
+			}),
+		);
+	}
+}
+
+export abstract class SQLiteEffectSession<
+	TRunResult,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SQLiteSession<TRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'SQLiteEffectSession';
+
+	declare readonly dialect: SQLiteDialect;
+
+	constructor(dialect: SQLiteDialect) {
+		super(dialect);
+	}
+
+	abstract override prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteEffectPreparedQuery<T, TEffectHKT>;
+
+	run(query: SQL): QueryEffectKind<TEffectHKT, TRunResult> {
+		return this.prepareQuery<PreparedQueryConfig & { type: unknown; run: TRunResult }>(
+			this.dialect.sqlToQuery(query),
+			'raw',
+			false,
+			'run',
+		).run() as QueryEffectKind<TEffectHKT, TRunResult>;
+	}
+
+	objects<T = unknown>(query: SQL): QueryEffectKind<TEffectHKT, T[]> {
+		return this.prepareQuery<PreparedQueryConfig & { type: unknown; all: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'objects',
+			false,
+			'all',
+		).all() as QueryEffectKind<TEffectHKT, T[]>;
+	}
+
+	object<T = unknown>(query: SQL): QueryEffectKind<TEffectHKT, T> {
+		return this.prepareQuery<PreparedQueryConfig & { type: unknown; get: T }>(
+			this.dialect.sqlToQuery(query),
+			'objects',
+			false,
+			'get',
+		).get() as QueryEffectKind<TEffectHKT, T>;
+	}
+
+	arrays<T extends any[] = unknown[]>(query: SQL): QueryEffectKind<TEffectHKT, T[]> {
+		return this.prepareQuery<PreparedQueryConfig & { type: unknown; all: T[] }>(
+			this.dialect.sqlToQuery(query),
+			'arrays',
+			false,
+			'all',
+		).all() as QueryEffectKind<TEffectHKT, T[]>;
+	}
+
+	array<T extends any[] = unknown[]>(query: SQL): QueryEffectKind<TEffectHKT, T> {
+		return this.prepareQuery<PreparedQueryConfig & { type: unknown; get: T }>(
+			this.dialect.sqlToQuery(query),
+			'arrays',
+			false,
+			'get',
+		).get() as QueryEffectKind<TEffectHKT, T>;
+	}
+
+	abstract transaction<A, E, R>(
+		transaction: (
+			tx: SQLiteEffectTransaction<TEffectHKT, TRunResult, TRelations>,
+		) => Effect.Effect<A, E, R>,
+		config?: SQLiteTransactionConfig,
+	): Effect.Effect<A, E | SqlError, R>;
+}
+
+export abstract class SQLiteEffectTransaction<
+	TEffectHKT extends QueryEffectHKTBase,
+	TRunResult,
+	TRelations extends AnyRelations = EmptyRelations,
+> extends SQLiteEffectDatabase<TEffectHKT, TRunResult, TRelations> {
+	static override readonly [entityKind]: string = 'SQLiteEffectTransaction';
+
+	constructor(
+		dialect: SQLiteDialect,
+		session: SQLiteEffectSession<any, TEffectHKT, any>,
+		relations: TRelations,
+		protected readonly nestedIndex = 0,
+		forbidJsonb?: boolean,
+	) {
+		super(dialect, session, relations, forbidJsonb);
+	}
+
+	rollback() {
+		return new EffectTransactionRollbackError();
+	}
+}
+
+export const migrate = Effect.fn('migrate')(function*<TEffectHKT extends QueryEffectHKTBase>(
+	migrations: MigrationMeta[],
+	session: SQLiteEffectSession<any, TEffectHKT>,
+	config?: string | Omit<MigrationConfig, 'migrationsFolder'>,
+) {
+	const migrationsTable = config === undefined
+		? '__drizzle_migrations'
+		: typeof config === 'string'
+		? '__drizzle_migrations'
+		: (config.migrationsTable ?? '__drizzle_migrations');
+
+	const { newDb } = yield* upgradeIfNeeded(migrationsTable, session, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
+			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+				id INTEGER PRIMARY KEY,
+				hash text NOT NULL,
+				created_at numeric,
+				name text,
+				applied_at TEXT
+			)
+		`;
+		yield* session.run(migrationTableCreate);
+	}
+
+	const dbMigrations = yield* session.objects<{
+		id: number;
+		hash: string;
+		created_at: string;
+		name: string | null;
+	}>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)};`,
+	);
+
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return yield* new MigratorInitError({ exitCode: 'databaseMigrations' });
+		}
+
+		if (migrations.length > 1) {
+			return yield* new MigratorInitError({ exitCode: 'localMigrations' });
+		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		yield* session.run(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+				new Date().toISOString()
+			})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({
+		localMigrations: migrations,
+		dbMigrations,
+	});
+
+	yield* session.transaction((tx) =>
+		Effect.gen(function*() {
+			for (const migration of migrationsToRun) {
+				for (const stmt of migration.sql) {
+					yield* tx.run(sql.raw(stmt));
+				}
+				yield* tx.run(
+					sql`insert into ${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+						new Date().toISOString()
+					})`,
+				);
+			}
+		})
+	);
+});
diff --git a/drizzle-orm/src/sqlite-core/effect/update.ts b/drizzle-orm/src/sqlite-core/effect/update.ts
new file mode 100644
index 0000000000..0111e9099d
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/update.ts
@@ -0,0 +1,143 @@
+import { applyEffectWrapper, type QueryEffectHKTBase, type QueryEffectKind } from '~/effect-core/query-effect.ts';
+import { entityKind } from '~/entity.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteUpdateBuilder, SQLiteUpdateHKTBase } from '~/sqlite-core/query-builders/update.ts';
+import { SQLiteUpdateBase } from '~/sqlite-core/query-builders/update.ts';
+import type { PreparedQueryConfig } from '~/sqlite-core/session.ts';
+import type { SQLiteTable } from '~/sqlite-core/table.ts';
+import type { Subquery } from '~/subquery.ts';
+import type { Assume, DrizzleTypeError } from '~/utils.ts';
+import { extractUsedTable } from '../utils.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from './session.ts';
+
+export interface SQLiteEffectUpdateHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase>
+	extends SQLiteUpdateHKTBase
+{
+	_type: SQLiteEffectUpdateBase<
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		Assume<this['from'], SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined>,
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods'],
+		TEffectHKT
+	>;
+}
+
+export type AnySQLiteEffectUpdate = SQLiteEffectUpdateBase<any, any, any, any, any, any, any>;
+
+export type SQLiteEffectUpdate<
+	TTable extends SQLiteTable = SQLiteTable,
+	TRunResult = any,
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectUpdateBase<TTable, TRunResult, TFrom, TReturning, true, never, TEffectHKT>;
+
+export type SQLiteEffectUpdateBuilder<
+	TTable extends SQLiteTable,
+	TRunResult,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteUpdateBuilder<TTable, TRunResult, SQLiteEffectUpdateHKT<TEffectHKT>>;
+
+export type SQLiteEffectUpdateExecute<T extends AnySQLiteEffectUpdate> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteEffectUpdatePrepare<
+	T extends AnySQLiteEffectUpdate,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> = SQLiteEffectPreparedQuery<
+	PreparedQueryConfig & {
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteEffectUpdateExecute<T>;
+	},
+	TEffectHKT
+>;
+
+export interface SQLiteEffectUpdateBase<
+	// oxlint-disable-next-line no-unused-vars
+	TTable extends SQLiteTable = SQLiteTable,
+	TRunResult = unknown,
+	// oxlint-disable-next-line no-unused-vars
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning = undefined,
+	// oxlint-disable-next-line no-unused-vars
+	TDynamic extends boolean = false,
+	// oxlint-disable-next-line no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends QueryEffectKind<TEffectHKT, TReturning extends undefined ? TRunResult : TReturning[]> {}
+
+export class SQLiteEffectUpdateBase<
+	TTable extends SQLiteTable = SQLiteTable,
+	TRunResult = unknown,
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase,
+> extends SQLiteUpdateBase<
+	SQLiteEffectUpdateHKT<TEffectHKT>,
+	TTable,
+	TRunResult,
+	TFrom,
+	TReturning,
+	TDynamic,
+	TExcludedMethods
+> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper {
+	static override readonly [entityKind]: string = 'SQLiteEffectUpdate';
+
+	declare protected session: SQLiteEffectSession<TRunResult, TEffectHKT, any>;
+
+	/** @internal */
+	_prepare(prepare = false): SQLiteEffectUpdatePrepare<this, TEffectHKT> {
+		return this.session.prepareQuery(
+			this.dialect.sqlToQuery(this.getSQL()),
+			'arrays',
+			prepare,
+			this.config.returning ? 'all' : 'run',
+			this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, undefined) : undefined,
+			{
+				type: 'update',
+				tables: extractUsedTable(this.config.table),
+			},
+		) as SQLiteEffectUpdatePrepare<this, TEffectHKT>;
+	}
+
+	prepare(): SQLiteEffectUpdatePrepare<this, TEffectHKT> {
+		return this._prepare(true);
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().values(placeholderValues);
+	};
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues?: Record<string, unknown>) => {
+		return this._prepare().execute(placeholderValues);
+	};
+}
+
+applyEffectWrapper(SQLiteEffectUpdateBase);
diff --git a/drizzle-orm/src/sqlite-core/effect/utils.ts b/drizzle-orm/src/sqlite-core/effect/utils.ts
new file mode 100644
index 0000000000..94ad6d75db
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/effect/utils.ts
@@ -0,0 +1,6 @@
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '../utils.ts';
+
+export type EffectDrizzleSQLiteConfig<
+	TRelations extends AnyRelations = EmptyRelations,
+> = Omit<DrizzleSQLiteConfig<TRelations>, 'cache' | 'logger'>;
diff --git a/drizzle-orm/src/sqlite-core/foreign-keys.ts b/drizzle-orm/src/sqlite-core/foreign-keys.ts
index 1c947f7f59..7134478176 100644
--- a/drizzle-orm/src/sqlite-core/foreign-keys.ts
+++ b/drizzle-orm/src/sqlite-core/foreign-keys.ts
@@ -91,6 +91,10 @@ export class ForeignKey {
 		];
 		return name ?? `${chunks.join('_')}_fk`;
 	}
+
+	isNameExplicit() {
+		return !!this.reference().name;
+	}
 }
 
 type ColumnsWithTable<
@@ -98,22 +102,6 @@ type ColumnsWithTable<
 	TColumns extends SQLiteColumn[],
 > = { [Key in keyof TColumns]: AnySQLiteColumn<{ tableName: TTableName }> };
 
-/**
- * @deprecated please use `foreignKey({ columns: [], foreignColumns: [] })` syntax without callback
- * @param config
- * @returns
- */
-export function foreignKey<
-	TTableName extends string,
-	TForeignTableName extends string,
-	TColumns extends [AnySQLiteColumn<{ tableName: TTableName }>, ...AnySQLiteColumn<{ tableName: TTableName }>[]],
->(
-	config: () => {
-		name?: string;
-		columns: TColumns;
-		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
-	},
-): ForeignKeyBuilder;
 export function foreignKey<
 	TTableName extends string,
 	TForeignTableName extends string,
diff --git a/drizzle-orm/src/sqlite-core/index.ts b/drizzle-orm/src/sqlite-core/index.ts
index ac2a19f0a3..64e7f2bc56 100644
--- a/drizzle-orm/src/sqlite-core/index.ts
+++ b/drizzle-orm/src/sqlite-core/index.ts
@@ -1,7 +1,8 @@
 export * from './alias.ts';
+export * from './async/index.ts';
+export * from './casing.ts';
 export * from './checks.ts';
 export * from './columns/index.ts';
-export * from './db.ts';
 export * from './dialect.ts';
 export * from './foreign-keys.ts';
 export * from './indexes.ts';
diff --git a/drizzle-orm/src/sqlite-core/indexes.ts b/drizzle-orm/src/sqlite-core/indexes.ts
index 70ca62a8ca..6249a4f9f0 100644
--- a/drizzle-orm/src/sqlite-core/indexes.ts
+++ b/drizzle-orm/src/sqlite-core/indexes.ts
@@ -63,9 +63,11 @@ export class Index {
 	};
 
 	readonly config: IndexConfig & { table: SQLiteTable };
+	readonly isNameExplicit: boolean;
 
 	constructor(config: IndexConfig, table: SQLiteTable) {
 		this.config = { ...config, table };
+		this.isNameExplicit = !!config.name;
 	}
 }
 
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index ea2111c63a..96798880c6 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -53,10 +53,12 @@ export class PrimaryKey {
 
 	readonly columns: SQLiteColumn[];
 	readonly name?: string;
+	readonly isNameExplicit: boolean;
 
 	constructor(readonly table: SQLiteTable, columns: SQLiteColumn[], name?: string) {
 		this.columns = columns;
 		this.name = name;
+		this.isNameExplicit = !!name;
 	}
 
 	getName(): string {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/count.ts b/drizzle-orm/src/sqlite-core/query-builders/count.ts
index 1c1234034c..34762007c4 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/count.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/count.ts
@@ -1,76 +1,53 @@
 import { entityKind } from '~/entity.ts';
+import type { Query } from '~/sql/sql.ts';
 import { SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '../dialect.ts';
 import type { SQLiteSession } from '../session.ts';
 import type { SQLiteTable } from '../table.ts';
-import type { SQLiteView } from '../view.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
 
-export class SQLiteCountBuilder<
-	TSession extends SQLiteSession<any, any, any, any>,
-> extends SQL<number> implements Promise<number>, SQLWrapper {
-	private sql: SQL<number>;
+export class SQLiteCountBuilder extends SQL<number> implements SQLWrapper<number> {
+	static override readonly [entityKind]: string = 'SQLiteCountBuilder';
 
-	static override readonly [entityKind] = 'SQLiteCountBuilderAsync';
-	[Symbol.toStringTag] = 'SQLiteCountBuilderAsync';
-
-	private session: TSession;
-
-	private static buildEmbeddedCount(
-		source: SQLiteTable | SQLiteView | SQL | SQLWrapper,
-		filters?: SQL<unknown>,
-	): SQL<number> {
-		return sql<number>`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
-	}
+	protected dialect: SQLiteDialect;
+	protected session: SQLiteSession<any, any>;
 
 	private static buildCount(
-		source: SQLiteTable | SQLiteView | SQL | SQLWrapper,
+		source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper,
 		filters?: SQL<unknown>,
+		parens?: boolean,
 	): SQL<number> {
-		return sql<number>`select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters}`;
+		const where = sql` where ${filters}`.if(filters);
+		const query = sql<number>`select count(*) from ${source}${where}`;
+
+		return parens ? sql`(${query})` : query;
 	}
 
 	constructor(
-		readonly params: {
-			source: SQLiteTable | SQLiteView | SQL | SQLWrapper;
+		protected countConfig: {
+			source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper;
 			filters?: SQL<unknown>;
-			session: TSession;
+			dialect: SQLiteDialect;
+			session: SQLiteSession<any, any>;
 		},
 	) {
-		super(SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-
-		this.session = params.session;
-
-		this.sql = SQLiteCountBuilder.buildCount(
-			params.source,
-			params.filters,
-		);
+		super(SQLiteCountBuilder.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+		this.dialect = countConfig.dialect;
+		this.session = countConfig.session;
+		this.mapWith((e) => {
+			if (typeof e === 'number') return e;
+
+			return Number(e ?? 0);
+		});
 	}
 
-	then<TResult1 = number, TResult2 = never>(
-		onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined,
-		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined,
-	): Promise<TResult1 | TResult2> {
-		return Promise.resolve(this.session.count(this.sql)).then(
-			onfulfilled,
-			onrejected,
-		);
-	}
-
-	catch(
-		onRejected?: ((reason: any) => never | PromiseLike<never>) | null | undefined,
-	): Promise<number> {
-		return this.then(undefined, onRejected);
-	}
+	private executableSql: SQL<number> | undefined;
+	protected build(): Query {
+		if (!this.executableSql) {
+			const { source, filters } = this.countConfig;
+			this.executableSql = SQLiteCountBuilder.buildCount(source, filters);
+		}
 
-	finally(onFinally?: (() => void) | null | undefined): Promise<number> {
-		return this.then(
-			(value) => {
-				onFinally?.();
-				return value;
-			},
-			(reason) => {
-				onFinally?.();
-				throw reason;
-			},
-		);
+		return this.dialect.sqlToQuery(this.executableSql);
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/delete.ts b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
index 654d640661..def429645a 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/delete.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
@@ -1,28 +1,72 @@
 import { entityKind } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
-import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import type { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import { type DrizzleTypeError, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
+import { type Assume, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
 import type { SQLiteColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 
+export interface SQLiteDeleteConfig {
+	where?: SQL | undefined;
+	limit?: number | Placeholder;
+	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+	table: SQLiteTable;
+	returning?: SelectedFieldsOrdered;
+	withList?: Subquery[];
+}
+
+export interface SQLiteDeleteHKTBase {
+	table: unknown;
+	resultType: unknown;
+	runResult: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	_type: unknown;
+}
+
+export interface SQLiteDeleteQueryBuilderHKT extends SQLiteDeleteHKTBase {
+	_type: SQLiteDeleteBase<
+		SQLiteDeleteQueryBuilderHKT,
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		Assume<this['returning'], Record<string, unknown> | undefined>,
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type SQLiteDeleteKind<
+	T extends SQLiteDeleteHKTBase,
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	runResult: TRunResult;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TReturning extends undefined ? TRunResult : TReturning[];
+})['_type'];
+
 export type SQLiteDeleteWithout<
 	T extends AnySQLiteDeleteBase,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T
 	: Omit<
-		SQLiteDeleteBase<
+		SQLiteDeleteKind<
+			T['_']['hkt'],
 			T['_']['table'],
-			T['_']['resultType'],
 			T['_']['runResult'],
 			T['_']['returning'],
 			TDynamic,
@@ -33,27 +77,17 @@ export type SQLiteDeleteWithout<
 
 export type SQLiteDelete<
 	TTable extends SQLiteTable = SQLiteTable,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TReturning extends Record<string, unknown> | undefined = undefined,
-> = SQLiteDeleteBase<TTable, TResultType, TRunResult, TReturning, true, never>;
-
-export interface SQLiteDeleteConfig {
-	where?: SQL | undefined;
-	limit?: number | Placeholder;
-	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
-	table: SQLiteTable;
-	returning?: SelectedFieldsOrdered;
-	withList?: Subquery[];
-}
+> = SQLiteDeleteBase<SQLiteDeleteQueryBuilderHKT, TTable, TRunResult, TReturning, true, never>;
 
 export type SQLiteDeleteReturningAll<
 	T extends AnySQLiteDeleteBase,
 	TDynamic extends boolean,
 > = SQLiteDeleteWithout<
-	SQLiteDeleteBase<
+	SQLiteDeleteKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['table']['$inferSelect'],
 		T['_']['dynamic'],
@@ -68,9 +102,9 @@ export type SQLiteDeleteReturning<
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFieldsFlat,
 > = SQLiteDeleteWithout<
-	SQLiteDeleteBase<
+	SQLiteDeleteKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		SelectResultFields<TSelectedFields>,
 		T['_']['dynamic'],
@@ -80,47 +114,29 @@ export type SQLiteDeleteReturning<
 	'returning'
 >;
 
-export type SQLiteDeleteExecute<T extends AnySQLiteDeleteBase> = T['_']['returning'] extends undefined
-	? T['_']['runResult']
-	: T['_']['returning'][];
-
-export type SQLiteDeletePrepare<T extends AnySQLiteDeleteBase> = SQLitePreparedQuery<{
-	type: T['_']['resultType'];
-	run: T['_']['runResult'];
-	all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
-		: T['_']['returning'][];
-	get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
-		: T['_']['returning'] | undefined;
-	values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
-		: any[][];
-	execute: SQLiteDeleteExecute<T>;
-}>;
-
-export type SQLiteDeleteDynamic<T extends AnySQLiteDeleteBase> = SQLiteDelete<
+export type SQLiteDeleteDynamic<T extends AnySQLiteDeleteBase> = SQLiteDeleteKind<
+	T['_']['hkt'],
 	T['_']['table'],
-	T['_']['resultType'],
 	T['_']['runResult'],
-	T['_']['returning']
+	T['_']['returning'],
+	true,
+	never
 >;
 
 export type AnySQLiteDeleteBase = SQLiteDeleteBase<any, any, any, any, any, any>;
 
 export interface SQLiteDeleteBase<
+	THKT extends SQLiteDeleteHKTBase,
 	TTable extends SQLiteTable,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TReturning extends Record<string, unknown> | undefined = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends
-	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>,
-	SQLWrapper
-{
+> extends SQLWrapper {
 	readonly _: {
-		dialect: 'sqlite';
+		readonly dialect: 'sqlite';
+		readonly hkt: THKT;
 		readonly table: TTable;
-		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly returning: TReturning;
 		readonly dynamic: TDynamic;
@@ -130,29 +146,28 @@ export interface SQLiteDeleteBase<
 }
 
 export class SQLiteDeleteBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends SQLiteDeleteHKTBase,
 	TTable extends SQLiteTable,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async',
 	TRunResult,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TReturning extends Record<string, unknown> | undefined = undefined,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
-	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'SQLiteDelete';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SQLiteDelete';
 
 	/** @internal */
 	config: SQLiteDeleteConfig;
 
 	constructor(
 		private table: TTable,
-		private session: SQLiteSession<any, any, any, any>,
-		private dialect: SQLiteDialect,
+		protected session: SQLiteSession<any, any>,
+		protected dialect: SQLiteDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { table, withList };
 	}
 
@@ -247,58 +262,17 @@ export class SQLiteDeleteBase<
 	): SQLiteDeleteReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFieldsFlat = this.table[SQLiteTable.Symbol.Columns],
-	): SQLiteDeleteReturning<this, TDynamic, any> {
+	): SQLiteDeleteReturning<this, TDynamic, any> | SQLiteDeleteReturningAll<this, TDynamic> {
 		this.config.returning = orderSelectedFields<SQLiteColumn>(fields);
 		return this as any;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
 		return this.dialect.buildDeleteQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(isOneTimeQuery = true): SQLiteDeletePrepare<this> {
-		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			this.dialect.sqlToQuery(this.getSQL()),
-			this.config.returning,
-			this.config.returning ? 'all' : 'run',
-			true,
-			undefined,
-			{
-				type: 'delete',
-				tables: extractUsedTable(this.config.table),
-			},
-		) as SQLiteDeletePrepare<this>;
-	}
-
-	prepare(): SQLiteDeletePrepare<this> {
-		return this._prepare(false);
-	}
-
-	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
-		return this._prepare().run(placeholderValues);
-	};
-
-	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
-		return this._prepare().all(placeholderValues);
-	};
-
-	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
-		return this._prepare().get(placeholderValues);
-	};
-
-	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
-		return this._prepare().values(placeholderValues);
-	};
-
-	override async execute(placeholderValues?: Record<string, unknown>): Promise<SQLiteDeleteExecute<this>> {
-		return this._prepare().execute(placeholderValues) as SQLiteDeleteExecute<this>;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	$dynamic(): SQLiteDeleteDynamic<this> {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/insert.ts b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
index 96985dc834..3ca2ce5c9f 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/insert.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
@@ -1,61 +1,97 @@
 import { entityKind, is } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Param, SQL, sql } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { IndexColumn } from '~/sqlite-core/indexes.ts';
-import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import type { Subquery } from '~/subquery.ts';
-import { Columns, Table } from '~/table.ts';
-import { type DrizzleTypeError, haveSameKeys, mapUpdateSet, orderSelectedFields, type Simplify } from '~/utils.ts';
+import { type InferInsertModel, Table } from '~/table.ts';
+import { type Assume, type DrizzleTypeError, mapUpdateSet, orderSelectedFields } from '~/utils.ts';
 import type { AnySQLiteColumn, SQLiteColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import { QueryBuilder } from './query-builder.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 import type { SQLiteUpdateSetSource } from './update.ts';
 
 export interface SQLiteInsertConfig<TTable extends SQLiteTable = SQLiteTable> {
 	table: TTable;
-	values: Record<string, Param | SQL>[] | SQLiteInsertSelectQueryBuilder<TTable> | SQL;
+	values: Record<string, Param | SQL>[] | TypedQueryBuilder<SQLiteInsertSelection<TTable>> | SQL;
 	withList?: Subquery[];
 	onConflict?: SQL[];
 	returning?: SelectedFieldsOrdered;
 	select?: boolean;
 }
 
-export type SQLiteInsertValue<TTable extends SQLiteTable> = Simplify<
-	{
-		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
+export type SQLiteInsertValue<
+	TTable extends SQLiteTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
+	& {
+		[Key in keyof TModel]: TModel[Key] | SQL | Placeholder;
 	}
->;
+	& {};
 
-export type SQLiteInsertSelectQueryBuilder<TTable extends SQLiteTable> = TypedQueryBuilder<
-	{ [K in keyof TTable['$inferInsert']]: AnySQLiteColumn | SQL | SQL.Aliased | TTable['$inferInsert'][K] }
->;
+export type SQLiteInsertSelection<
+	TTable extends SQLiteTable,
+	TModel extends Record<string, unknown> = InferInsertModel<TTable>,
+> =
+	& {
+		[K in keyof TModel]:
+			| AnySQLiteColumn
+			| SQL
+			| SQL.Aliased
+			| TModel[K];
+	}
+	& {};
+
+export type NoUnknownKeysInInsertSelection<
+	TTable extends SQLiteTable,
+	TSelection extends SQLiteInsertSelection<any>,
+> = {
+	[K in keyof TSelection]: K extends keyof InferInsertModel<TTable> ? TSelection[K]
+		: K extends keyof InferInsertModel<TTable, { override: true }> ? DrizzleTypeError<
+				`Column "${
+					& K
+					& string}" in table "${TTable['_'][
+					'name'
+				]}" is a generated column - manual value insertion restricted`
+			>
+		: DrizzleTypeError<`Column "${K & string}" does not exist in table "${TTable['_']['name']}"`>;
+};
+
+export interface SQLiteInsertBuilderConstructor {
+	new(
+		table: SQLiteTable,
+		values: SQLiteInsertConfig['values'],
+		session: SQLiteSession<any, any>,
+		dialect: SQLiteDialect,
+		withList?: Subquery[],
+		select?: boolean,
+	): AnySQLiteInsert;
+}
 
 export class SQLiteInsertBuilder<
 	TTable extends SQLiteTable,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
+	THKT extends SQLiteInsertHKTBase = SQLiteInsertQueryBuilderHKT,
 > {
 	static readonly [entityKind]: string = 'SQLiteInsertBuilder';
 
 	constructor(
 		protected table: TTable,
-		protected session: SQLiteSession<any, any, any, any>,
+		protected session: SQLiteSession<any, any>,
 		protected dialect: SQLiteDialect,
 		private withList?: Subquery[],
+		private builder: SQLiteInsertBuilderConstructor = SQLiteInsertBase,
 	) {}
 
-	values(value: SQLiteInsertValue<TTable>): SQLiteInsertBase<TTable, TResultType, TRunResult>;
-	values(values: SQLiteInsertValue<TTable>[]): SQLiteInsertBase<TTable, TResultType, TRunResult>;
+	values(value: SQLiteInsertValue<TTable>): SQLiteInsertKind<THKT, TTable, TRunResult>;
+	values(values: SQLiteInsertValue<TTable>[]): SQLiteInsertKind<THKT, TTable, TRunResult>;
 	values(
 		values: SQLiteInsertValue<TTable> | SQLiteInsertValue<TTable>[],
-	): SQLiteInsertBase<TTable, TResultType, TRunResult> {
+	): SQLiteInsertKind<THKT, TTable, TRunResult> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -65,7 +101,7 @@ export class SQLiteInsertBuilder<
 			const cols = this.table[Table.Symbol.Columns];
 			for (const colKey of Object.keys(entry)) {
 				const colValue = entry[colKey as keyof typeof entry];
-				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue as any, cols[colKey]);
 			}
 			return result;
 		});
@@ -76,42 +112,87 @@ export class SQLiteInsertBuilder<
 		// 	);
 		// }
 
-		return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
+		return new this.builder(this.table, mappedValues, this.session, this.dialect, this.withList) as any;
 	}
 
-	select(
-		selectQuery: (qb: QueryBuilder) => SQLiteInsertSelectQueryBuilder<TTable>,
-	): SQLiteInsertBase<TTable, TResultType, TRunResult>;
-	select(selectQuery: (qb: QueryBuilder) => SQL): SQLiteInsertBase<TTable, TResultType, TRunResult>;
-	select(selectQuery: SQL): SQLiteInsertBase<TTable, TResultType, TRunResult>;
-	select(selectQuery: SQLiteInsertSelectQueryBuilder<TTable>): SQLiteInsertBase<TTable, TResultType, TRunResult>;
+	select<TSelection extends SQLiteInsertSelection<TTable>>(
+		selectQuery: (qb: QueryBuilder) => TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): SQLiteInsertKind<THKT, TTable, TRunResult>;
+	select(selectQuery: (qb: QueryBuilder) => SQL): SQLiteInsertKind<THKT, TTable, TRunResult>;
+	select(selectQuery: SQL): SQLiteInsertKind<THKT, TTable, TRunResult>;
+	select<TSelection extends SQLiteInsertSelection<TTable>>(
+		selectQuery: TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, TSelection>>,
+	): SQLiteInsertKind<THKT, TTable, TRunResult>;
 	select(
 		selectQuery:
 			| SQL
-			| SQLiteInsertSelectQueryBuilder<TTable>
-			| ((qb: QueryBuilder) => SQLiteInsertSelectQueryBuilder<TTable> | SQL),
-	): SQLiteInsertBase<TTable, TResultType, TRunResult> {
+			| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, SQLiteInsertSelection<TTable>>>
+			| ((qb: QueryBuilder) =>
+				| TypedQueryBuilder<NoUnknownKeysInInsertSelection<TTable, SQLiteInsertSelection<TTable>>>
+				| SQL),
+	): SQLiteInsertKind<THKT, TTable, TRunResult> {
 		const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
 
-		if (
-			!is(select, SQL)
-			&& !haveSameKeys(this.table[Columns], select._.selectedFields)
-		) {
-			throw new Error(
-				'Insert select error: selected fields are not the same or are in a different order compared to the table definition',
-			);
+		if (!is(select, SQL)) {
+			const insertCols = Object.keys(this.table[Table.Symbol.Columns]);
+			const selected = Object.keys(select._.selectedFields);
+
+			for (const col of selected) {
+				if (!insertCols.includes(col)) {
+					throw new Error(
+						`Insert select error: column "${col}" does not exist in table "${this.table[Table.Symbol.Name]}"`,
+					);
+				}
+			}
 		}
 
-		return new SQLiteInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+		return new this.builder(this.table, select, this.session, this.dialect, this.withList, true) as any;
 	}
 }
 
+export interface SQLiteInsertHKTBase {
+	table: unknown;
+	resultType: unknown;
+	runResult: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	_type: unknown;
+}
+
+export interface SQLiteInsertQueryBuilderHKT extends SQLiteInsertHKTBase {
+	_type: SQLiteInsertBase<
+		SQLiteInsertQueryBuilderHKT,
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type SQLiteInsertKind<
+	T extends SQLiteInsertHKTBase,
+	TTable extends SQLiteTable,
+	TRunResult,
+	TReturning = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	runResult: TRunResult;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+})['_type'];
+
 export type SQLiteInsertWithout<T extends AnySQLiteInsert, TDynamic extends boolean, K extends keyof T & string> =
 	TDynamic extends true ? T
 		: Omit<
-			SQLiteInsertBase<
+			SQLiteInsertKind<
+				T['_']['hkt'],
 				T['_']['table'],
-				T['_']['resultType'],
 				T['_']['runResult'],
 				T['_']['returning'],
 				TDynamic,
@@ -125,9 +206,9 @@ export type SQLiteInsertReturning<
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFieldsFlat,
 > = SQLiteInsertWithout<
-	SQLiteInsertBase<
+	SQLiteInsertKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		SelectResultFields<TSelectedFields>,
 		TDynamic,
@@ -141,9 +222,9 @@ export type SQLiteInsertReturningAll<
 	T extends AnySQLiteInsert,
 	TDynamic extends boolean,
 > = SQLiteInsertWithout<
-	SQLiteInsertBase<
+	SQLiteInsertKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['table']['$inferSelect'],
 		TDynamic,
@@ -163,55 +244,35 @@ export type SQLiteInsertOnConflictDoUpdateConfig<T extends AnySQLiteInsert> = {
 	set: SQLiteUpdateSetSource<T['_']['table']>;
 };
 
-export type SQLiteInsertDynamic<T extends AnySQLiteInsert> = SQLiteInsert<
+export type SQLiteInsertDynamic<T extends AnySQLiteInsert> = SQLiteInsertKind<
+	T['_']['hkt'],
 	T['_']['table'],
-	T['_']['resultType'],
 	T['_']['runResult'],
-	T['_']['returning']
->;
-
-export type SQLiteInsertExecute<T extends AnySQLiteInsert> = T['_']['returning'] extends undefined ? T['_']['runResult']
-	: T['_']['returning'][];
-
-export type SQLiteInsertPrepare<T extends AnySQLiteInsert> = SQLitePreparedQuery<
-	{
-		type: T['_']['resultType'];
-		run: T['_']['runResult'];
-		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
-			: T['_']['returning'][];
-		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
-			: T['_']['returning'];
-		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
-			: any[][];
-		execute: SQLiteInsertExecute<T>;
-	}
+	T['_']['returning'],
+	true,
+	never
 >;
 
 export type AnySQLiteInsert = SQLiteInsertBase<any, any, any, any, any, any>;
 
 export type SQLiteInsert<
 	TTable extends SQLiteTable = SQLiteTable,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TReturning = any,
-> = SQLiteInsertBase<TTable, TResultType, TRunResult, TReturning, true, never>;
+> = SQLiteInsertBase<SQLiteInsertQueryBuilderHKT, TTable, TRunResult, TReturning, true, never>;
 
 export interface SQLiteInsertBase<
+	THKT extends SQLiteInsertHKTBase,
 	TTable extends SQLiteTable,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TReturning = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends
-	SQLWrapper,
-	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>
-{
+> extends SQLWrapper {
 	readonly _: {
 		readonly dialect: 'sqlite';
+		readonly hkt: THKT;
 		readonly table: TTable;
-		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly returning: TReturning;
 		readonly dynamic: TDynamic;
@@ -221,19 +282,18 @@ export interface SQLiteInsertBase<
 }
 
 export class SQLiteInsertBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends SQLiteInsertHKTBase,
 	TTable extends SQLiteTable,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async',
 	TRunResult,
-	TReturning = undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TReturning = undefined,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
-	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'SQLiteInsert';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SQLiteInsert';
 
 	/** @internal */
 	config: SQLiteInsertConfig<TTable>;
@@ -241,12 +301,11 @@ export class SQLiteInsertBase<
 	constructor(
 		table: TTable,
 		values: SQLiteInsertConfig['values'],
-		private session: SQLiteSession<any, any, any, any>,
-		private dialect: SQLiteDialect,
+		protected session: SQLiteSession<any, any>,
+		protected dialect: SQLiteDialect,
 		withList?: Subquery[],
 		select?: boolean,
 	) {
-		super();
 		this.config = { table, values: values as any, withList, select };
 	}
 
@@ -365,53 +424,12 @@ export class SQLiteInsertBase<
 		return this;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
 		return this.dialect.buildInsertQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(isOneTimeQuery = true): SQLiteInsertPrepare<this> {
-		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			this.dialect.sqlToQuery(this.getSQL()),
-			this.config.returning,
-			this.config.returning ? 'all' : 'run',
-			true,
-			undefined,
-			{
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			},
-		) as SQLiteInsertPrepare<this>;
-	}
-
-	prepare(): SQLiteInsertPrepare<this> {
-		return this._prepare(false);
-	}
-
-	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
-		return this._prepare().run(placeholderValues);
-	};
-
-	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
-		return this._prepare().all(placeholderValues);
-	};
-
-	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
-		return this._prepare().get(placeholderValues);
-	};
-
-	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
-		return this._prepare().values(placeholderValues);
-	};
-
-	override async execute(): Promise<SQLiteInsertExecute<this>> {
-		return (this.config.returning ? this.all() : this.run()) as SQLiteInsertExecute<this>;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	$dynamic(): SQLiteInsertDynamic<this> {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
index 8aec660f07..d4b79ff5e1 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
@@ -3,7 +3,7 @@ import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import type { SQLiteDialectConfig } from '~/sqlite-core/dialect.ts';
-import { SQLiteDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { WithBuilder } from '~/sqlite-core/subquery.ts';
 import { WithSubquery } from '~/subquery.ts';
 import { SQLiteSelectBuilder } from './select.ts';
@@ -48,13 +48,13 @@ export class QueryBuilder {
 	with(...queries: WithSubquery[]) {
 		const self = this;
 
-		function select(): SQLiteSelectBuilder<undefined, 'sync', void, 'qb'>;
+		function select(): SQLiteSelectBuilder<undefined, void>;
 		function select<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
+		): SQLiteSelectBuilder<TSelection, void>;
 		function select<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): SQLiteSelectBuilder<TSelection | undefined, 'sync', void, 'qb'> {
+		): SQLiteSelectBuilder<TSelection | undefined, void> {
 			return new SQLiteSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -63,13 +63,13 @@ export class QueryBuilder {
 			});
 		}
 
-		function selectDistinct(): SQLiteSelectBuilder<undefined, 'sync', void, 'qb'>;
+		function selectDistinct(): SQLiteSelectBuilder<undefined, void>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
+		): SQLiteSelectBuilder<TSelection, void>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): SQLiteSelectBuilder<TSelection | undefined, 'sync', void, 'qb'> {
+		): SQLiteSelectBuilder<TSelection | undefined, void> {
 			return new SQLiteSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
@@ -82,23 +82,23 @@ export class QueryBuilder {
 		return { select, selectDistinct };
 	}
 
-	select(): SQLiteSelectBuilder<undefined, 'sync', void, 'qb'>;
+	select(): SQLiteSelectBuilder<undefined, void>;
 	select<TSelection extends SelectedFields>(
 		fields: TSelection,
-	): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
+	): SQLiteSelectBuilder<TSelection, void>;
 	select<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): SQLiteSelectBuilder<TSelection | undefined, 'sync', void, 'qb'> {
+	): SQLiteSelectBuilder<TSelection | undefined, void> {
 		return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
 	}
 
-	selectDistinct(): SQLiteSelectBuilder<undefined, 'sync', void, 'qb'>;
+	selectDistinct(): SQLiteSelectBuilder<undefined, void>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields: TSelection,
-	): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
+	): SQLiteSelectBuilder<TSelection, void>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): SQLiteSelectBuilder<TSelection | undefined, 'sync', void, 'qb'> {
+	): SQLiteSelectBuilder<TSelection | undefined, void> {
 		return new SQLiteSelectBuilder({
 			fields: fields ?? undefined,
 			session: undefined,
@@ -110,7 +110,7 @@ export class QueryBuilder {
 	// Lazy load dialect to avoid circular dependency
 	private getDialect() {
 		if (!this.dialect) {
-			this.dialect = new SQLiteSyncDialect(this.dialectConfig);
+			this.dialect = new SQLiteDialect(this.dialectConfig);
 		}
 
 		return this.dialect;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query.ts b/drizzle-orm/src/sqlite-core/query-builders/query.ts
index ef93e992aa..328c798050 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query.ts
@@ -1,182 +1,157 @@
 import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import {
-	type BuildQueryResult,
-	type BuildRelationalQueryResult,
-	type DBQueryConfig,
-	mapRelationalRow,
-	type TableRelationalConfig,
-	type TablesRelationalConfig,
+import type {
+	BuildQueryResult,
+	BuildRelationalQueryResult,
+	DBQueryConfig,
+	TableRelationalConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/sql.ts';
+import { type Query, type SQL, sql, type SQLWrapper } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { SQLiteDialect } from '../dialect.ts';
-import type { PreparedQueryConfig, SQLitePreparedQuery, SQLiteSession } from '../session.ts';
+import type { SQLiteSession } from '../session.ts';
 import type { SQLiteTable } from '../table.ts';
 
-export type SQLiteRelationalQueryKind<TMode extends 'sync' | 'async', TResult> = TMode extends 'async'
-	? SQLiteRelationalQuery<TMode, TResult>
-	: SQLiteSyncRelationalQuery<TResult>;
+export interface SQLiteRelationalQueryHKTBase {
+	type: unknown;
+	result: unknown;
+	_type: unknown;
+}
+
+export interface SQLiteRelationalQueryHKT extends SQLiteRelationalQueryHKTBase {
+	_type: SQLiteRelationalQuery<SQLiteRelationalQueryHKT, this['result']>;
+}
+
+export type SQLiteRelationalQueryKind<
+	T extends SQLiteRelationalQueryHKTBase,
+	TType,
+	TResult,
+> = (T & {
+	type: TType;
+	result: TResult;
+})['_type'];
+
+export interface SQLiteRelationalQueryConstructor {
+	new(
+		mode: unknown,
+		schema: TablesRelationalConfig,
+		table: SQLiteTable,
+		tableConfig: TableRelationalConfig,
+		dialect: SQLiteDialect,
+		session: SQLiteSession<any, any>,
+		config: DBQueryConfig<'many' | 'one'> | true,
+		queryMode: 'many' | 'first',
+		forbidJsonb: boolean | undefined,
+	): AnySQLiteRelationalQuery;
+}
+
+export type AnySQLiteRelationalQuery = SQLiteRelationalQuery<any, any>;
 
 export class RelationalQueryBuilder<
-	TMode extends 'sync' | 'async',
-	TFullSchema extends Record<string, unknown>,
+	TMode,
 	TSchema extends TablesRelationalConfig,
 	TFields extends TableRelationalConfig,
+	TBuilderHKT extends SQLiteRelationalQueryHKTBase = SQLiteRelationalQueryHKT,
 > {
-	static readonly [entityKind]: string = 'SQLiteAsyncRelationalQueryBuilder';
+	static readonly [entityKind]: string = 'SQLiteRelationalQueryBuilderV2';
 
 	constructor(
-		protected mode: TMode,
-		protected fullSchema: Record<string, unknown>,
-		protected schema: TSchema,
-		protected tableNamesMap: Record<string, string>,
-		protected table: SQLiteTable,
-		protected tableConfig: TableRelationalConfig,
-		protected dialect: SQLiteDialect,
-		protected session: SQLiteSession<'async', unknown, TFullSchema, TSchema>,
+		private mode: TMode,
+		private schema: TSchema,
+		private table: SQLiteTable,
+		private tableConfig: TableRelationalConfig,
+		private dialect: SQLiteDialect,
+		private session: SQLiteSession<any, any>,
+		private forbidJsonb: boolean | undefined,
+		private builder: SQLiteRelationalQueryConstructor = SQLiteRelationalQuery,
 	) {}
 
-	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
-		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
-	): SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TConfig>[]> {
-		return (this.mode === 'sync'
-			? new SQLiteSyncRelationalQuery(
-				this.fullSchema,
-				this.schema,
-				this.tableNamesMap,
-				this.table,
-				this.tableConfig,
-				this.dialect,
-				this.session,
-				config ? (config as DBQueryConfig<'many', true>) : {},
-				'many',
-			)
-			: new SQLiteRelationalQuery(
-				this.fullSchema,
-				this.schema,
-				this.tableNamesMap,
-				this.table,
-				this.tableConfig,
-				this.dialect,
-				this.session,
-				config ? (config as DBQueryConfig<'many', true>) : {},
-				'many',
-			)) as SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TConfig>[]>;
+	findMany<TConfig extends DBQueryConfig<'many', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', TSchema, TFields>>,
+	): SQLiteRelationalQueryKind<TBuilderHKT, TMode, BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new this.builder(
+			this.mode,
+			this.schema,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config as DBQueryConfig<'many'> | undefined ?? true,
+			'many',
+			this.forbidJsonb,
+		) as any;
 	}
 
-	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
-		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
-	): SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
-		return (this.mode === 'sync'
-			? new SQLiteSyncRelationalQuery(
-				this.fullSchema,
-				this.schema,
-				this.tableNamesMap,
-				this.table,
-				this.tableConfig,
-				this.dialect,
-				this.session,
-				config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
-				'first',
-			)
-			: new SQLiteRelationalQuery(
-				this.fullSchema,
-				this.schema,
-				this.tableNamesMap,
-				this.table,
-				this.tableConfig,
-				this.dialect,
-				this.session,
-				config ? { ...(config as DBQueryConfig<'many', true> | undefined), limit: 1 } : { limit: 1 },
-				'first',
-			)) as SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
+	findFirst<TConfig extends DBQueryConfig<'one', TSchema, TFields>>(
+		config?: KnownKeysOnly<TConfig, DBQueryConfig<'one', TSchema, TFields>>,
+	): SQLiteRelationalQueryKind<TBuilderHKT, TMode, BuildQueryResult<TSchema, TFields, TConfig> | undefined> {
+		return new this.builder(
+			this.mode,
+			this.schema,
+			this.table,
+			this.tableConfig,
+			this.dialect,
+			this.session,
+			config as DBQueryConfig<'one'> | undefined ?? true,
+			'first',
+			this.forbidJsonb,
+		) as any;
 	}
 }
 
-export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'SQLiteAsyncRelationalQuery';
+export class SQLiteRelationalQuery<THKT extends SQLiteRelationalQueryHKTBase, TResult> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SQLiteRelationalQueryV2';
 
 	declare readonly _: {
 		readonly dialect: 'sqlite';
-		readonly type: TType;
+		readonly hkt: THKT;
 		readonly result: TResult;
 	};
 
 	/** @internal */
 	mode: 'many' | 'first';
+	/** @internal */
+	table: SQLiteTable;
+	/** @internal */
+	resultKind: unknown;
 
 	constructor(
-		private fullSchema: Record<string, unknown>,
-		private schema: TablesRelationalConfig,
-		private tableNamesMap: Record<string, string>,
-		/** @internal */
-		public table: SQLiteTable,
-		private tableConfig: TableRelationalConfig,
-		private dialect: SQLiteDialect,
-		private session: SQLiteSession<'sync' | 'async', unknown, Record<string, unknown>, TablesRelationalConfig>,
-		private config: DBQueryConfig<'many', true> | true,
+		resultKind: unknown,
+		protected schema: TablesRelationalConfig,
+		table: SQLiteTable,
+		protected tableConfig: TableRelationalConfig,
+		protected dialect: SQLiteDialect,
+		protected session: SQLiteSession<any, any>,
+		protected config: DBQueryConfig<'many' | 'one'> | true,
 		mode: 'many' | 'first',
+		protected forbidJsonb?: boolean,
 	) {
-		super();
+		this.resultKind = resultKind;
 		this.mode = mode;
+		this.table = table;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
-		return this.dialect.buildRelationalQuery({
-			fullSchema: this.fullSchema,
-			schema: this.schema,
-			tableNamesMap: this.tableNamesMap,
-			table: this.table,
-			tableConfig: this.tableConfig,
-			queryConfig: this.config,
-			tableAlias: this.tableConfig.tsName,
-		}).sql as SQL;
-	}
-
-	/** @internal */
-	_prepare(
-		isOneTimeQuery = false,
-	): SQLitePreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }> {
-		const { query, builtQuery } = this._toSQL();
-
-		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			builtQuery,
-			undefined,
-			this.mode === 'first' ? 'get' : 'all',
-			true,
-			(rawRows, mapColumnValue) => {
-				const rows = rawRows.map((row) =>
-					mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
-				);
-				if (this.mode === 'first') {
-					return rows[0] as TResult;
-				}
-				return rows as TResult;
-			},
-		) as SQLitePreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }>;
+		return this._getQuery().sql;
 	}
 
-	prepare(): SQLitePreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }> {
-		return this._prepare(false);
-	}
+	protected _getQuery() {
+		const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
 
-	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
-		const query = this.dialect.buildRelationalQuery({
-			fullSchema: this.fullSchema,
+		return this.dialect.buildRelationalQuery({
 			schema: this.schema,
-			tableNamesMap: this.tableNamesMap,
 			table: this.table,
 			tableConfig: this.tableConfig,
 			queryConfig: this.config,
-			tableAlias: this.tableConfig.tsName,
+			mode: this.mode,
+			jsonb,
 		});
+	}
+
+	protected _toSQL(): { query: BuildRelationalQueryResult; builtQuery: Query } {
+		const query = this._getQuery();
 
-		const builtQuery = this.dialect.sqlToQuery(query.sql as SQL);
+		const builtQuery = this.dialect.sqlToQuery(query.sql);
 
 		return { query, builtQuery };
 	}
@@ -184,24 +159,4 @@ export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> exte
 	toSQL(): Query {
 		return this._toSQL().builtQuery;
 	}
-
-	/** @internal */
-	executeRaw(): TResult {
-		if (this.mode === 'first') {
-			return this._prepare(false).get() as TResult;
-		}
-		return this._prepare(false).all() as TResult;
-	}
-
-	override async execute(): Promise<TResult> {
-		return this.executeRaw();
-	}
-}
-
-export class SQLiteSyncRelationalQuery<TResult> extends SQLiteRelationalQuery<'sync', TResult> {
-	static override readonly [entityKind]: string = 'SQLiteSyncRelationalQuery';
-
-	sync(): TResult {
-		return this.executeRaw();
-	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/raw.ts b/drizzle-orm/src/sqlite-core/query-builders/raw.ts
index 488f45afe4..ca208f0849 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/raw.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/raw.ts
@@ -1,56 +1,35 @@
 import { entityKind } from '~/entity.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import type { PreparedQuery } from '~/session.ts';
-import type { SQL, SQLWrapper } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect } from '../dialect.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
+import type { SQLitePreparedQuery } from '../session.ts';
 
-type SQLiteRawAction = 'all' | 'get' | 'values' | 'run';
-export interface SQLiteRawConfig {
-	action: SQLiteRawAction;
-}
-
-export interface SQLiteRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'sqlite'>, SQLWrapper {}
-
-export class SQLiteRaw<TResult> extends QueryPromise<TResult>
-	implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper, PreparedQuery
-{
-	static override readonly [entityKind]: string = 'SQLiteRaw';
+// TODO: remove Raw builders & replace them with preparedQuery instances directly
+// oxlint-disable-next-line no-unused-vars
+export interface SQLiteRaw<TResult> extends SQLWrapper {}
+export class SQLiteRaw<TResult> implements SQLWrapper, PreparedQuery {
+	static readonly [entityKind]: string = 'SQLiteRaw';
 
 	declare readonly _: {
 		readonly dialect: 'sqlite';
 		readonly result: TResult;
 	};
 
-	/** @internal */
-	config: SQLiteRawConfig;
-
 	constructor(
-		public execute: () => Promise<TResult>,
-		/** @internal */
-		public getSQL: () => SQL,
-		action: SQLiteRawAction,
-		private dialect: SQLiteAsyncDialect,
-		private mapBatchResult: (result: unknown) => unknown,
+		protected prepared: SQLitePreparedQuery,
+		protected sql: SQL,
+		protected query: Query,
 	) {
-		super();
-		this.config = { action };
 	}
 
-	getQuery() {
-		return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };
+	getSQL() {
+		return this.sql;
 	}
 
-	mapResult(result: unknown, isFromBatch?: boolean) {
-		return isFromBatch ? this.mapBatchResult(result) : result;
+	getQuery() {
+		return this.query;
 	}
 
 	_prepare(): PreparedQuery {
-		return this;
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return false;
+		return this.prepared;
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index ce564b4453..518c49646e 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -11,11 +11,9 @@ import type {
 	SelectResult,
 	SetOperator,
 } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import { SQL, View } from '~/sql/sql.ts';
-import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import type { ColumnsSelection, Placeholder, Query } from '~/sql/sql.ts';
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { SQLiteSession } from '~/sqlite-core/session.ts';
@@ -23,46 +21,52 @@ import type { SubqueryWithSelection } from '~/sqlite-core/subquery.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import {
-	applyMixins,
-	getTableColumns,
-	getTableLikeName,
-	haveSameKeys,
-	orderSelectedFields,
-	type ValueOrArray,
-} from '~/utils.ts';
+import { getTableColumns, getTableLikeName, haveSameKeys, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { extractUsedTable } from '../utils.ts';
 import { SQLiteViewBase } from '../view-base.ts';
 import type {
 	AnySQLiteSelect,
-	CreateSQLiteSelectFromBuilderMode,
+	AnySQLiteSelectQueryBuilder,
 	GetSQLiteSetOperators,
 	SelectedFields,
 	SetOperatorRightSelect,
 	SQLiteCreateSetOperatorFn,
 	SQLiteSelectConfig,
+	SQLiteSelectCrossJoinFn,
 	SQLiteSelectDynamic,
-	SQLiteSelectExecute,
-	SQLiteSelectHKT,
 	SQLiteSelectHKTBase,
 	SQLiteSelectJoinFn,
-	SQLiteSelectPrepare,
+	SQLiteSelectKind,
+	SQLiteSelectQueryBuilderHKT,
 	SQLiteSelectWithout,
 	SQLiteSetOperatorExcludedMethods,
 	SQLiteSetOperatorWithResult,
 } from './select.types.ts';
 
+export interface SQLiteSelectBuilderConstructor {
+	new(
+		config: {
+			table: SQLiteSelectConfig['table'];
+			fields: SQLiteSelectConfig['fields'];
+			isPartialSelect: boolean;
+			session: SQLiteSession<any, any> | undefined;
+			dialect: SQLiteDialect;
+			withList: Subquery[];
+			distinct: boolean | undefined;
+		},
+	): AnySQLiteSelectQueryBuilder;
+}
+
 export class SQLiteSelectBuilder<
 	TSelection extends SelectedFields | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
-	TBuilderMode extends 'db' | 'qb' = 'db',
+	THKT extends SQLiteSelectHKTBase = SQLiteSelectQueryBuilderHKT,
 > {
 	static readonly [entityKind]: string = 'SQLiteSelectBuilder';
 
 	private fields: TSelection;
-	private session: SQLiteSession<any, any, any, any> | undefined;
+	private session: SQLiteSession<any, any> | undefined;
 	private dialect: SQLiteDialect;
 	private withList: Subquery[] | undefined;
 	private distinct: boolean | undefined;
@@ -70,11 +74,12 @@ export class SQLiteSelectBuilder<
 	constructor(
 		config: {
 			fields: TSelection;
-			session: SQLiteSession<any, any, any, any> | undefined;
+			session: SQLiteSession<any, any> | undefined;
 			dialect: SQLiteDialect;
 			withList?: Subquery[];
 			distinct?: boolean;
 		},
+		private builder: SQLiteSelectBuilderConstructor = SQLiteSelectBase,
 	) {
 		this.fields = config.fields;
 		this.session = config.session;
@@ -85,13 +90,15 @@ export class SQLiteSelectBuilder<
 
 	from<TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL>(
 		source: TFrom,
-	): CreateSQLiteSelectFromBuilderMode<
-		TBuilderMode,
+	): SQLiteSelectKind<
+		THKT,
 		GetSelectTableName<TFrom>,
-		TResultType,
 		TRunResult,
 		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
-		TSelection extends undefined ? 'single' : 'partial'
+		TSelection extends undefined ? 'single' : 'partial',
+		GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, 'not-null'> : {},
+		false,
+		never
 	> {
 		const isPartialSelect = !!this.fields;
 
@@ -113,22 +120,21 @@ export class SQLiteSelectBuilder<
 			fields = getTableColumns<SQLiteTable>(source);
 		}
 
-		return new SQLiteSelectBase({
+		return new this.builder({
 			table: source,
 			fields,
 			isPartialSelect,
 			session: this.session,
 			dialect: this.dialect,
-			withList: this.withList,
+			withList: this.withList ?? [],
 			distinct: this.distinct,
 		}) as any;
 	}
 }
 
-export abstract class SQLiteSelectQueryBuilderBase<
+export class SQLiteSelectBase<
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -145,7 +151,6 @@ export abstract class SQLiteSelectQueryBuilderBase<
 		readonly dialect: 'sqlite';
 		readonly hkt: THKT;
 		readonly tableName: TTableName;
-		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -162,7 +167,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 	protected joinsNotNullableMap: Record<string, boolean>;
 	private tableName: string | undefined;
 	private isPartialSelect: boolean;
-	protected session: SQLiteSession<any, any, any, any> | undefined;
+	protected session: SQLiteSession<any, any> | undefined;
 	protected dialect: SQLiteDialect;
 	protected cacheConfig?: WithCacheConfig = undefined;
 	protected usedTables: Set<string> = new Set();
@@ -172,7 +177,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 			table: SQLiteSelectConfig['table'];
 			fields: SQLiteSelectConfig['fields'];
 			isPartialSelect: boolean;
-			session: SQLiteSession<any, any, any, any> | undefined;
+			session: SQLiteSession<any, any> | undefined;
 			dialect: SQLiteDialect;
 			withList: Subquery[] | undefined;
 			distinct: boolean | undefined;
@@ -205,7 +210,9 @@ export abstract class SQLiteSelectQueryBuilderBase<
 
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
-	): SQLiteSelectJoinFn<this, TDynamic, TJoinType> {
+	): 'cross' extends TJoinType ? SQLiteSelectCrossJoinFn<this, TDynamic>
+		: SQLiteSelectJoinFn<this, TDynamic, TJoinType>
+	{
 		return (
 			table: SQLiteTable | Subquery | SQLiteViewBase | SQL,
 			on?: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -681,7 +688,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 	groupBy(
 		builder: (aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
 	): SQLiteSelectWithout<this, TDynamic, 'groupBy'>;
-	groupBy(...columns: (SQLiteColumn | SQL)[]): SQLiteSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteSelectWithout<this, TDynamic, 'groupBy'>;
 	groupBy(
 		...columns:
 			| [(aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
@@ -728,7 +735,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 	orderBy(
 		builder: (aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
 	): SQLiteSelectWithout<this, TDynamic, 'orderBy'>;
-	orderBy(...columns: (SQLiteColumn | SQL)[]): SQLiteSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteSelectWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
 			| [(aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
@@ -811,14 +818,22 @@ export abstract class SQLiteSelectQueryBuilderBase<
 		return this as any;
 	}
 
-	/** @internal */
+	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
+		this.cacheConfig = config === undefined
+			? { config: {}, enabled: true, autoInvalidate: true }
+			: config === false
+			? { enabled: false }
+			: { enabled: true, autoInvalidate: true, ...config };
+		return this;
+	}
+
 	getSQL(): SQL {
+		this.config.fieldsFlat = orderSelectedFields<SQLiteColumn>(this.config.fields);
 		return this.dialect.buildSelectQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	as<TAlias extends string>(
@@ -842,126 +857,16 @@ export abstract class SQLiteSelectQueryBuilderBase<
 		) as this['_']['selectedFields'];
 	}
 
-	$dynamic(): SQLiteSelectDynamic<this> {
-		return this;
-	}
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SQLiteSelectBase<
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode = 'single',
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	SQLiteSelectQueryBuilderBase<
-		SQLiteSelectHKT,
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	QueryPromise<TResult>
-{}
-
-export class SQLiteSelectBase<
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection,
-	TSelectMode extends SelectMode = 'single',
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends SQLiteSelectQueryBuilderBase<
-	SQLiteSelectHKT,
-	TTableName,
-	TResultType,
-	TRunResult,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper {
-	static override readonly [entityKind]: string = 'SQLiteSelect';
-
 	/** @internal */
-	_prepare(isOneTimeQuery = true): SQLiteSelectPrepare<this> {
-		if (!this.session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		const fieldsList = orderSelectedFields<SQLiteColumn>(this.config.fields);
-		const query = this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			this.dialect.sqlToQuery(this.getSQL()),
-			fieldsList,
-			'all',
-			true,
-			undefined,
-			{
-				type: 'select',
-				tables: [...this.usedTables],
-			},
-			this.cacheConfig,
-		);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as ReturnType<this['prepare']>;
-	}
-
-	$withCache(config?: { config?: CacheConfig; tag?: string; autoInvalidate?: boolean } | false) {
-		this.cacheConfig = config === undefined
-			? { config: {}, enable: true, autoInvalidate: true }
-			: config === false
-			? { enable: false }
-			: { enable: true, autoInvalidate: true, ...config };
+	override withoutSelectionCastCodecs(): this {
 		return this;
 	}
 
-	prepare(): SQLiteSelectPrepare<this> {
-		return this._prepare(false);
-	}
-
-	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
-		return this._prepare().run(placeholderValues);
-	};
-
-	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
-		return this._prepare().all(placeholderValues);
-	};
-
-	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
-		return this._prepare().get(placeholderValues);
-	};
-
-	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
-		return this._prepare().values(placeholderValues);
-	};
-
-	async execute(): Promise<SQLiteSelectExecute<this>> {
-		return this.all() as SQLiteSelectExecute<this>;
+	$dynamic(): SQLiteSelectDynamic<this> {
+		return this;
 	}
 }
 
-applyMixins(SQLiteSelectBase, [QueryPromise]);
-
 function createSetOperator(type: SetOperator, isAll: boolean): SQLiteCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		const setOperators = [rightSelect, ...restSelects].map((select) => ({
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 33cadb473d..3ac71f87dd 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -23,10 +23,9 @@ import type {
 } from '~/query-builders/select.types.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { SQLitePreparedQuery } from '../session.ts';
 import type { SQLiteViewBase } from '../view-base.ts';
 import type { SQLiteViewWithSelection } from '../view.ts';
-import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
+import type { SQLiteSelectBase } from './select.ts';
 
 export interface SQLiteSelectJoinConfig {
 	on: SQL | undefined;
@@ -37,7 +36,7 @@ export interface SQLiteSelectJoinConfig {
 
 export type BuildAliasTable<TTable extends SQLiteTable | View, TAlias extends string> = TTable extends Table
 	? SQLiteTableWithColumns<
-		UpdateTableConfig<TTable['_']['config'], {
+		UpdateTableConfig<TTable['_'], {
 			name: TAlias;
 			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'sqlite'>;
 		}>
@@ -82,7 +81,6 @@ export type SQLiteSelectJoin<
 		SQLiteSelectKind<
 			T['_']['hkt'],
 			T['_']['tableName'],
-			T['_']['resultType'],
 			T['_']['runResult'],
 			AppendToResult<
 				T['_']['tableName'],
@@ -107,17 +105,21 @@ export type SQLiteSelectJoinFn<
 	T extends AnySQLiteSelectQueryBuilder,
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
-> = 'cross' extends TJoinType ? <
-		TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(table: TJoinedTable) => SQLiteSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>
-	: <
-		TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
-		TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-	>(
-		table: TJoinedTable,
-		on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-	) => SQLiteSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+> = <
+	TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => SQLiteSelectJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+
+export type SQLiteSelectCrossJoinFn<
+	T extends AnySQLiteSelectQueryBuilder,
+	TDynamic extends boolean,
+> = <
+	TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+>(table: TJoinedTable) => SQLiteSelectJoin<T, TDynamic, 'cross', TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectFieldsFlatBase<SQLiteColumn>;
 
@@ -127,7 +129,7 @@ export type SelectedFieldsOrdered = SelectFieldsOrderedBase<SQLiteColumn>;
 
 export interface SQLiteSelectHKTBase {
 	tableName: string | undefined;
-	resultType: 'sync' | 'async';
+	resultType: unknown;
 	runResult: unknown;
 	selection: unknown;
 	selectMode: SelectMode;
@@ -142,7 +144,6 @@ export interface SQLiteSelectHKTBase {
 export type SQLiteSelectKind<
 	T extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -153,7 +154,6 @@ export type SQLiteSelectKind<
 	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > = (T & {
 	tableName: TTableName;
-	resultType: TResultType;
 	runResult: TRunResult;
 	selection: TSelection;
 	selectMode: TSelectMode;
@@ -165,25 +165,9 @@ export type SQLiteSelectKind<
 })['_type'];
 
 export interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
-	_type: SQLiteSelectQueryBuilderBase<
-		SQLiteSelectQueryBuilderHKT,
-		this['tableName'],
-		this['resultType'],
-		this['runResult'],
-		Assume<this['selection'], ColumnsSelection>,
-		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
-		this['dynamic'],
-		this['excludedMethods'],
-		Assume<this['result'], any[]>,
-		Assume<this['selectedFields'], ColumnsSelection>
-	>;
-}
-
-export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
 	_type: SQLiteSelectBase<
+		SQLiteSelectQueryBuilderHKT,
 		this['tableName'],
-		this['resultType'],
 		this['runResult'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
@@ -207,22 +191,24 @@ export type SQLiteSetOperatorExcludedMethods =
 
 export type CreateSQLiteSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
+	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-> = TBuilderMode extends 'db' ? SQLiteSelectBase<
+> = TBuilderMode extends 'db' ? SQLiteSelectKind<
+		THKT,
 		TTableName,
-		TResultType,
 		TRunResult,
 		TSelection,
-		TSelectMode
+		TSelectMode,
+		TTableName extends string ? Record<TTableName, 'not-null'> : {},
+		false,
+		never
 	>
-	: SQLiteSelectQueryBuilderBase<
+	: SQLiteSelectBase<
 		SQLiteSelectQueryBuilderHKT,
 		TTableName,
-		TResultType,
 		TRunResult,
 		TSelection,
 		TSelectMode
@@ -237,7 +223,6 @@ export type SQLiteSelectWithout<
 	SQLiteSelectKind<
 		T['_']['hkt'],
 		T['_']['tableName'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['selection'],
 		T['_']['selectMode'],
@@ -252,21 +237,9 @@ export type SQLiteSelectWithout<
 
 export type SQLiteSelectExecute<T extends AnySQLiteSelect> = T['_']['result'];
 
-export type SQLiteSelectPrepare<T extends AnySQLiteSelect> = SQLitePreparedQuery<
-	{
-		type: T['_']['resultType'];
-		run: T['_']['runResult'];
-		all: T['_']['result'];
-		get: T['_']['result'][number] | undefined;
-		values: any[][];
-		execute: SQLiteSelectExecute<T>;
-	}
->;
-
 export type SQLiteSelectDynamic<T extends AnySQLiteSelectQueryBuilder> = SQLiteSelectKind<
 	T['_']['hkt'],
 	T['_']['tableName'],
-	T['_']['resultType'],
 	T['_']['runResult'],
 	T['_']['selection'],
 	T['_']['selectMode'],
@@ -280,17 +253,15 @@ export type SQLiteSelectDynamic<T extends AnySQLiteSelectQueryBuilder> = SQLiteS
 export type SQLiteSelectQueryBuilder<
 	THKT extends SQLiteSelectHKTBase = SQLiteSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = SQLiteSelectQueryBuilderBase<
+> = SQLiteSelectBase<
 	THKT,
 	TTableName,
-	TResultType,
 	TRunResult,
 	TSelection,
 	TSelectMode,
@@ -301,8 +272,7 @@ export type SQLiteSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnySQLiteSelectQueryBuilder = SQLiteSelectQueryBuilderBase<
-	any,
+export type AnySQLiteSelectQueryBuilder = SQLiteSelectBase<
 	any,
 	any,
 	any,
@@ -315,11 +285,21 @@ export type AnySQLiteSelectQueryBuilder = SQLiteSelectQueryBuilderBase<
 	any
 >;
 
-export type AnySQLiteSetOperatorInterface = SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
+export type AnySQLiteSetOperatorInterface = SQLiteSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
 
 export interface SQLiteSetOperatorInterface<
+	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode = 'single',
@@ -331,9 +311,8 @@ export interface SQLiteSetOperatorInterface<
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > {
 	_: {
-		readonly hkt: SQLiteSelectHKTBase;
+		readonly hkt: THKT;
 		readonly tableName: TTableName;
-		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -359,26 +338,26 @@ export type SQLiteSetOperatorWithResult<TResult extends any[]> = SQLiteSetOperat
 >;
 
 export type SQLiteSelect<
+	THKT extends SQLiteSelectHKTBase = SQLiteSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = SQLiteSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+> = SQLiteSelectKind<THKT, TTableName, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
 
-export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
+export type AnySQLiteSelect = AnySQLiteSelectQueryBuilder;
 
 export type SQLiteSetOperator<
+	THKT extends SQLiteSelectHKTBase = SQLiteSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = SQLiteSelectBase<
+> = SQLiteSelectKind<
+	THKT,
 	TTableName,
-	TResultType,
 	TRunResult,
 	TSelection,
 	TSelectMode,
@@ -412,8 +391,8 @@ export type SetOperatorRestSelect<
 	: TValue;
 
 export type SQLiteCreateSetOperatorFn = <
+	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
 	TValue extends SQLiteSetOperatorWithResult<TResult>,
@@ -427,8 +406,8 @@ export type SQLiteCreateSetOperatorFn = <
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: SQLiteSetOperatorInterface<
+		THKT,
 		TTableName,
-		TResultType,
 		TRunResult,
 		TSelection,
 		TSelectMode,
@@ -442,8 +421,8 @@ export type SQLiteCreateSetOperatorFn = <
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
 ) => SQLiteSelectWithout<
 	SQLiteSelectBase<
+		THKT,
 		TTableName,
-		TResultType,
 		TRunResult,
 		TSelection,
 		TSelectMode,
diff --git a/drizzle-orm/src/sqlite-core/query-builders/update.ts b/drizzle-orm/src/sqlite-core/query-builders/update.ts
index a6b3c4ce3a..43ab487b9d 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/update.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/update.ts
@@ -1,17 +1,15 @@
 import type { GetColumnData } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { JoinType, SelectResultFields } from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { Placeholder, Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
-import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery } from '~/subquery.ts';
-import { Table } from '~/table.ts';
+import { type InferInsertModel, Table } from '~/table.ts';
 import {
-	type DrizzleTypeError,
+	type Assume,
 	getTableLikeName,
 	mapUpdateSet,
 	orderSelectedFields,
@@ -20,7 +18,6 @@ import {
 } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { SQLiteColumn } from '../columns/common.ts';
-import { extractUsedTable } from '../utils.ts';
 import { SQLiteViewBase } from '../view-base.ts';
 import type { SelectedFields, SelectedFieldsOrdered, SQLiteSelectJoinConfig } from './select.types.ts';
 
@@ -36,20 +33,34 @@ export interface SQLiteUpdateConfig {
 	withList?: Subquery[];
 }
 
-export type SQLiteUpdateSetSource<TTable extends SQLiteTable> =
+export type SQLiteUpdateSetSource<
+	TTable extends SQLiteTable,
+	TModel extends Record<string, any> = InferInsertModel<TTable>,
+> =
 	& {
-		[Key in keyof TTable['$inferInsert']]?:
+		[Key in keyof TModel & string]?:
 			| GetColumnData<TTable['_']['columns'][Key], 'query'>
 			| SQL
 			| SQLiteColumn
+			| Placeholder
 			| undefined;
 	}
 	& {};
 
+export interface SQLiteUpdateBuilderConstructor {
+	new(
+		table: SQLiteTable,
+		set: UpdateSet,
+		session: SQLiteSession<any, any>,
+		dialect: SQLiteDialect,
+		withList?: Subquery[],
+	): AnySQLiteUpdate;
+}
+
 export class SQLiteUpdateBuilder<
 	TTable extends SQLiteTable,
-	TResultType extends 'sync' | 'async',
 	TRunResult,
+	THKT extends SQLiteUpdateHKTBase = SQLiteUpdateQueryBuilderHKT,
 > {
 	static readonly [entityKind]: string = 'SQLiteUpdateBuilder';
 
@@ -59,19 +70,20 @@ export class SQLiteUpdateBuilder<
 
 	constructor(
 		protected table: TTable,
-		protected session: SQLiteSession<any, any, any, any>,
+		protected session: SQLiteSession<any, any>,
 		protected dialect: SQLiteDialect,
 		private withList?: Subquery[],
+		private builder: SQLiteUpdateBuilderConstructor = SQLiteUpdateBase,
 	) {}
 
 	set(
 		values: SQLiteUpdateSetSource<TTable>,
 	): SQLiteUpdateWithout<
-		SQLiteUpdateBase<TTable, TResultType, TRunResult>,
+		Assume<SQLiteUpdateKind<THKT, TTable, TRunResult>, AnySQLiteUpdate>,
 		false,
 		'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'
 	> {
-		return new SQLiteUpdateBase(
+		return new this.builder(
 			this.table,
 			mapUpdateSet(this.table, values),
 			this.session,
@@ -81,14 +93,56 @@ export class SQLiteUpdateBuilder<
 	}
 }
 
+export interface SQLiteUpdateHKTBase {
+	table: unknown;
+	resultType: unknown;
+	runResult: unknown;
+	from: unknown;
+	returning: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	_type: unknown;
+}
+
+export interface SQLiteUpdateQueryBuilderHKT extends SQLiteUpdateHKTBase {
+	_type: SQLiteUpdateBase<
+		SQLiteUpdateQueryBuilderHKT,
+		Assume<this['table'], SQLiteTable>,
+		this['runResult'],
+		Assume<this['from'], SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined>,
+		this['returning'],
+		this['dynamic'],
+		this['excludedMethods']
+	>;
+}
+
+export type SQLiteUpdateKind<
+	T extends SQLiteUpdateHKTBase,
+	TTable extends SQLiteTable,
+	TRunResult,
+	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
+	TReturning = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> = (T & {
+	table: TTable;
+	runResult: TRunResult;
+	from: TFrom;
+	returning: TReturning;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TReturning extends undefined ? TRunResult : TReturning[];
+})['_type'];
+
 export type SQLiteUpdateWithout<
 	T extends AnySQLiteUpdate,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T : Omit<
-	SQLiteUpdateBase<
+	SQLiteUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['from'],
 		T['_']['returning'],
@@ -103,9 +157,9 @@ export type SQLiteUpdateWithJoins<
 	TDynamic extends boolean,
 	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
 > = TDynamic extends true ? T : Omit<
-	SQLiteUpdateBase<
+	SQLiteUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		TFrom,
 		T['_']['returning'],
@@ -116,9 +170,9 @@ export type SQLiteUpdateWithJoins<
 >;
 
 export type SQLiteUpdateReturningAll<T extends AnySQLiteUpdate, TDynamic extends boolean> = SQLiteUpdateWithout<
-	SQLiteUpdateBase<
+	SQLiteUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['from'],
 		T['_']['table']['$inferSelect'],
@@ -134,9 +188,9 @@ export type SQLiteUpdateReturning<
 	TDynamic extends boolean,
 	TSelectedFields extends SelectedFields,
 > = SQLiteUpdateWithout<
-	SQLiteUpdateBase<
+	SQLiteUpdateKind<
+		T['_']['hkt'],
 		T['_']['table'],
-		T['_']['resultType'],
 		T['_']['runResult'],
 		T['_']['from'],
 		SelectResultFields<TSelectedFields>,
@@ -147,23 +201,6 @@ export type SQLiteUpdateReturning<
 	'returning'
 >;
 
-export type SQLiteUpdateExecute<T extends AnySQLiteUpdate> = T['_']['returning'] extends undefined ? T['_']['runResult']
-	: T['_']['returning'][];
-
-export type SQLiteUpdatePrepare<T extends AnySQLiteUpdate> = SQLitePreparedQuery<
-	{
-		type: T['_']['resultType'];
-		run: T['_']['runResult'];
-		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
-			: T['_']['returning'][];
-		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
-			: T['_']['returning'];
-		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
-			: any[][];
-		execute: SQLiteUpdateExecute<T>;
-	}
->;
-
 export type SQLiteUpdateJoinFn<
 	T extends AnySQLiteUpdate,
 > = <
@@ -183,36 +220,38 @@ export type SQLiteUpdateJoinFn<
 		| undefined,
 ) => T;
 
-export type SQLiteUpdateDynamic<T extends AnySQLiteUpdate> = SQLiteUpdate<
+export type SQLiteUpdateDynamic<T extends AnySQLiteUpdate> = SQLiteUpdateKind<
+	T['_']['hkt'],
 	T['_']['table'],
-	T['_']['resultType'],
 	T['_']['runResult'],
-	T['_']['returning']
+	T['_']['from'],
+	T['_']['returning'],
+	true,
+	never
 >;
 
 export type SQLiteUpdate<
 	TTable extends SQLiteTable = SQLiteTable,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = any,
 	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = SQLiteUpdateBase<TTable, TResultType, TRunResult, TFrom, TReturning, true, never>;
+> = SQLiteUpdateBase<SQLiteUpdateQueryBuilderHKT, TTable, TRunResult, TFrom, TReturning, true, never>;
 
 export type AnySQLiteUpdate = SQLiteUpdateBase<any, any, any, any, any, any, any>;
 
 export interface SQLiteUpdateBase<
+	THKT extends SQLiteUpdateHKTBase,
 	TTable extends SQLiteTable = SQLiteTable,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
 	TReturning = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
+> extends SQLWrapper {
 	readonly _: {
 		readonly dialect: 'sqlite';
+		readonly hkt: THKT;
 		readonly table: TTable;
-		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly from: TFrom;
 		readonly returning: TReturning;
@@ -223,20 +262,19 @@ export interface SQLiteUpdateBase<
 }
 
 export class SQLiteUpdateBase<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends SQLiteUpdateHKTBase,
 	TTable extends SQLiteTable = SQLiteTable,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
 	TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined,
-	TReturning = undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TReturning = undefined,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
-	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
-{
-	static override readonly [entityKind]: string = 'SQLiteUpdate';
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SQLiteUpdate';
 
 	/** @internal */
 	config: SQLiteUpdateConfig;
@@ -244,11 +282,10 @@ export class SQLiteUpdateBase<
 	constructor(
 		table: TTable,
 		set: UpdateSet,
-		private session: SQLiteSession<any, any, any, any>,
-		private dialect: SQLiteDialect,
+		protected session: SQLiteSession<any, any>,
+		protected dialect: SQLiteDialect,
 		withList?: Subquery[],
 	) {
-		super();
 		this.config = { set, table, withList, joins: [] };
 	}
 
@@ -410,53 +447,12 @@ export class SQLiteUpdateBase<
 		return this as any;
 	}
 
-	/** @internal */
 	getSQL(): SQL {
 		return this.dialect.buildUpdateQuery(this.config);
 	}
 
 	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	/** @internal */
-	_prepare(isOneTimeQuery = true): SQLiteUpdatePrepare<this> {
-		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			this.dialect.sqlToQuery(this.getSQL()),
-			this.config.returning,
-			this.config.returning ? 'all' : 'run',
-			true,
-			undefined,
-			{
-				type: 'insert',
-				tables: extractUsedTable(this.config.table),
-			},
-		) as SQLiteUpdatePrepare<this>;
-	}
-
-	prepare(): SQLiteUpdatePrepare<this> {
-		return this._prepare(false);
-	}
-
-	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
-		return this._prepare().run(placeholderValues);
-	};
-
-	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
-		return this._prepare().all(placeholderValues);
-	};
-
-	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
-		return this._prepare().get(placeholderValues);
-	};
-
-	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
-		return this._prepare().values(placeholderValues);
-	};
-
-	override async execute(): Promise<SQLiteUpdateExecute<this>> {
-		return (this.config.returning ? this.all() : this.run()) as SQLiteUpdateExecute<this>;
+		return this.dialect.sqlToQuery(this.getSQL());
 	}
 
 	$dynamic(): SQLiteUpdateDynamic<this> {
diff --git a/drizzle-orm/src/sqlite-core/session.ts b/drizzle-orm/src/sqlite-core/session.ts
index 13d002d768..6dd7a2a2a2 100644
--- a/drizzle-orm/src/sqlite-core/session.ts
+++ b/drizzle-orm/src/sqlite-core/session.ts
@@ -1,19 +1,11 @@
-import { type Cache, hashQuery, NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { entityKind, is } from '~/entity.ts';
-import { DrizzleError, TransactionRollbackError } from '~/errors.ts';
-import { DrizzleQueryError } from '~/errors/index.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { TablesRelationalConfig } from '~/relations.ts';
+import { entityKind } from '~/entity.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
-import type { Query, SQL } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { BaseSQLiteDatabase } from './db.ts';
-import type { SQLiteRaw } from './query-builders/raw.ts';
-import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
+import type { Query } from '~/sql/sql.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 
 export interface PreparedQueryConfig {
-	type: 'sync' | 'async';
 	run: unknown;
 	all: unknown;
 	get: unknown;
@@ -21,335 +13,67 @@ export interface PreparedQueryConfig {
 	execute: unknown;
 }
 
-export class ExecuteResultSync<T> extends QueryPromise<T> {
-	static override readonly [entityKind]: string = 'ExecuteResultSync';
-
-	constructor(private resultCb: () => T) {
-		super();
-	}
-
-	override async execute(): Promise<T> {
-		return this.resultCb();
-	}
-
-	sync(): T {
-		return this.resultCb();
-	}
+export interface SQLiteTransactionConfig {
+	behavior?: 'deferred' | 'immediate' | 'exclusive';
 }
 
-export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult>
-	: ExecuteResultSync<TResult>;
+export type SQLiteExecuteMethod = 'run' | 'all' | 'get' | 'values';
 
-export abstract class SQLitePreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
-	static readonly [entityKind]: string = 'PreparedQuery';
+export abstract class SQLitePreparedQuery implements PreparedQuery {
+	static readonly [entityKind]: string = 'SQLiteBasePreparedQuery';
 
 	/** @internal */
-	joinsNotNullableMap?: Record<string, boolean>;
+	readonly mapper: {
+		(rows: any[]): any;
+		body?: string;
+	} | undefined;
+	/** @internal */
+	readonly executeMethod: SQLiteExecuteMethod;
 
 	constructor(
-		private mode: 'sync' | 'async',
-		private executeMethod: SQLiteExecuteMethod,
+		executeMethod: SQLiteExecuteMethod,
 		protected query: Query,
-		private cache?: Cache,
-		// per query related metadata
-		private queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		// config that was passed through $withCache
-		private cacheConfig?: WithCacheConfig,
+		mapper: ((rows: any[]) => any) | undefined,
+		readonly mode: 'arrays' | 'objects' | 'raw',
 	) {
-		// it means that no $withCache options were passed and it should be just enabled
-		if (cache && cache.strategy() === 'all' && cacheConfig === undefined) {
-			this.cacheConfig = { enable: true, autoInvalidate: true };
-		}
-		if (!this.cacheConfig?.enable) {
-			this.cacheConfig = undefined;
-		}
-	}
-
-	/** @internal */
-	protected async queryWithCache<T>(
-		queryString: string,
-		params: any[],
-		query: () => Promise<T>,
-	): Promise<T> {
-		if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any mutations, if globally is false
-		if (this.cacheConfig && !this.cacheConfig.enable) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// For mutate queries, we should query the database, wait for a response, and then perform invalidation
-		if (
-			(
-				this.queryMetadata.type === 'insert' || this.queryMetadata.type === 'update'
-				|| this.queryMetadata.type === 'delete'
-			) && this.queryMetadata.tables.length > 0
-		) {
-			try {
-				const [res] = await Promise.all([
-					query(),
-					this.cache.onMutate({ tables: this.queryMetadata.tables }),
-				]);
-				return res;
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		// don't do any reads if globally disabled
-		if (!this.cacheConfig) {
-			try {
-				return await query();
-			} catch (e) {
-				throw new DrizzleQueryError(queryString, params, e as Error);
-			}
-		}
-
-		if (this.queryMetadata.type === 'select') {
-			const fromCache = await this.cache.get(
-				this.cacheConfig.tag ?? await hashQuery(queryString, params),
-				this.queryMetadata.tables,
-				this.cacheConfig.tag !== undefined,
-				this.cacheConfig.autoInvalidate,
-			);
-			if (fromCache === undefined) {
-				let result;
-				try {
-					result = await query();
-				} catch (e) {
-					throw new DrizzleQueryError(queryString, params, e as Error);
-				}
-
-				// put actual key
-				await this.cache.put(
-					this.cacheConfig.tag ?? await hashQuery(queryString, params),
-					result,
-					// make sure we send tables that were used in a query only if user wants to invalidate it on each write
-					this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
-					this.cacheConfig.tag !== undefined,
-					this.cacheConfig.config,
-				);
-				// put flag if we should invalidate or not
-				return result;
-			}
-
-			return fromCache as unknown as T;
-		}
-		try {
-			return await query();
-		} catch (e) {
-			throw new DrizzleQueryError(queryString, params, e as Error);
-		}
+		this.mapper = mapper;
+		this.executeMethod = executeMethod;
 	}
 
 	getQuery(): Query {
 		return this.query;
 	}
 
-	abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
-
-	mapRunResult(result: unknown, _isFromBatch?: boolean): unknown {
-		return result;
-	}
-
-	abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
-
-	mapAllResult(_result: unknown, _isFromBatch?: boolean): unknown {
-		throw new Error('Not implemented');
-	}
-
-	abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
-
-	mapGetResult(_result: unknown, _isFromBatch?: boolean): unknown {
-		throw new Error('Not implemented');
-	}
-
-	abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
-
-	execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']> {
-		if (this.mode === 'async') {
-			return this[this.executeMethod](placeholderValues) as ExecuteResult<T['type'], T['execute']>;
-		}
-		return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
-	}
-
-	mapResult(response: unknown, isFromBatch?: boolean) {
-		switch (this.executeMethod) {
-			case 'run': {
-				return this.mapRunResult(response, isFromBatch);
-			}
-			case 'all': {
-				return this.mapAllResult(response, isFromBatch);
-			}
-			case 'get': {
-				return this.mapGetResult(response, isFromBatch);
-			}
-		}
-	}
-
-	/** @internal */
-	abstract isResponseInArrayMode(): boolean;
-}
-
-export interface SQLiteTransactionConfig {
-	behavior?: 'deferred' | 'immediate' | 'exclusive';
+	abstract run(placeholderValues?: Record<string, unknown>): unknown;
+	abstract all(placeholderValues?: Record<string, unknown>): unknown;
+	abstract get(placeholderValues?: Record<string, unknown>): unknown;
+	abstract values(placeholderValues?: Record<string, unknown>): unknown;
+	abstract execute(placeholderValues?: Record<string, unknown>): unknown;
 }
 
-export type SQLiteExecuteMethod = 'run' | 'all' | 'get';
-
-export abstract class SQLiteSession<
-	TResultKind extends 'sync' | 'async',
-	TRunResult,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> {
+export abstract class SQLiteSession<TRunResult = unknown, TRelations extends AnyRelations = EmptyRelations> {
 	static readonly [entityKind]: string = 'SQLiteSession';
 
+	declare readonly _: {
+		readonly runResult: TRunResult;
+		readonly relations: TRelations;
+	};
+
 	constructor(
 		/** @internal */
-		readonly dialect: { sync: SQLiteSyncDialect; async: SQLiteAsyncDialect }[TResultKind],
+		readonly dialect: SQLiteDialect,
 	) {}
 
 	abstract prepareQuery(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
-		queryMetadata?: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		},
-		cacheConfig?: WithCacheConfig,
-	): SQLitePreparedQuery<PreparedQueryConfig & { type: TResultKind }>;
-
-	prepareOneTimeQuery(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): SQLitePreparedQuery<PreparedQueryConfig & { type: TResultKind }> {
-		return this.prepareQuery(
-			query,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
-			queryMetadata,
-			cacheConfig,
-		);
-	}
-
-	abstract transaction<T>(
-		transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>,
-		config?: SQLiteTransactionConfig,
-	): Result<TResultKind, T>;
-
-	run(query: SQL): Result<TResultKind, TRunResult> {
-		const staticQuery = this.dialect.sqlToQuery(query);
-		try {
-			return this.prepareOneTimeQuery(staticQuery, undefined, 'run', false).run() as Result<TResultKind, TRunResult>;
-		} catch (err) {
-			throw new DrizzleError({ cause: err, message: `Failed to run the query '${staticQuery.sql}'` });
-		}
-	}
-
-	/** @internal */
-	extractRawRunValueFromBatchResult(result: unknown) {
-		return result;
-	}
-
-	all<T = unknown>(query: SQL): Result<TResultKind, T[]> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run', false).all() as Result<
-			TResultKind,
-			T[]
-		>;
-	}
-
-	/** @internal */
-	extractRawAllValueFromBatchResult(_result: unknown): unknown {
-		throw new Error('Not implemented');
-	}
-
-	get<T = unknown>(query: SQL): Result<TResultKind, T> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run', false).get() as Result<
-			TResultKind,
-			T
-		>;
-	}
-
-	/** @internal */
-	extractRawGetValueFromBatchResult(_result: unknown): unknown {
-		throw new Error('Not implemented');
-	}
-
-	values<T extends any[] = unknown[]>(
-		query: SQL,
-	): Result<TResultKind, T[]> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run', false).values() as Result<
-			TResultKind,
-			T[]
-		>;
-	}
-
-	async count(sql: SQL) {
-		const result = await this.values(sql) as [[number]];
-
-		return result[0][0];
-	}
-
-	/** @internal */
-	extractRawValuesValueFromBatchResult(_result: unknown): unknown {
-		throw new Error('Not implemented');
-	}
-}
-
-export type Result<TKind extends 'sync' | 'async', TResult> = { sync: TResult; async: Promise<TResult> }[TKind];
-
-export type DBResult<TKind extends 'sync' | 'async', TResult> = { sync: TResult; async: SQLiteRaw<TResult> }[TKind];
-
-export abstract class SQLiteTransaction<
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends BaseSQLiteDatabase<TResultType, TRunResult, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'SQLiteTransaction';
-
-	constructor(
-		resultType: TResultType,
-		dialect: { sync: SQLiteSyncDialect; async: SQLiteAsyncDialect }[TResultType],
-		session: SQLiteSession<TResultType, TRunResult, TFullSchema, TSchema>,
-		protected schema: {
-			fullSchema: Record<string, unknown>;
-			schema: TSchema;
-			tableNamesMap: Record<string, string>;
-		} | undefined,
-		protected readonly nestedIndex = 0,
-	) {
-		super(resultType, dialect, session, schema);
-	}
-
-	rollback(): never {
-		throw new TransactionRollbackError();
-	}
+	): SQLitePreparedQuery;
 }
diff --git a/drizzle-orm/src/sqlite-core/table.ts b/drizzle-orm/src/sqlite-core/table.ts
index 290605b66c..d0c93c92ed 100644
--- a/drizzle-orm/src/sqlite-core/table.ts
+++ b/drizzle-orm/src/sqlite-core/table.ts
@@ -1,9 +1,15 @@
-import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts';
+import { type Casing, getCasingFn } from '~/casing.ts';
+import type { BuildColumns, BuildExtraConfigColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
-import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
+import {
+	type InferTableColumnsModels,
+	Table,
+	type TableConfig as TableConfigBase,
+	type UpdateTableConfig,
+} from '~/table.ts';
 import type { CheckBuilder } from './checks.ts';
 import { getSQLiteColumnBuilders, type SQLiteColumnBuilders } from './columns/all.ts';
-import type { SQLiteColumn, SQLiteColumnBuilder, SQLiteColumnBuilderBase } from './columns/common.ts';
+import type { SQLiteColumn, SQLiteColumnBuilder, SQLiteColumns } from './columns/common.ts';
 import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import type { IndexBuilder } from './indexes.ts';
 import type { PrimaryKeyBuilder } from './primary-keys.ts';
@@ -21,7 +27,7 @@ export type SQLiteTableExtraConfig = Record<
 	SQLiteTableExtraConfigValue
 >;
 
-export type TableConfig = TableConfigBase<SQLiteColumn<any>>;
+export type TableConfig = TableConfigBase<SQLiteColumns>;
 
 /** @internal */
 export const InlineForeignKeys = Symbol.for('drizzle:SQLiteInlineForeignKeys');
@@ -52,14 +58,13 @@ export type AnySQLiteTable<TPartial extends Partial<TableConfig> = {}> = SQLiteT
 
 export type SQLiteTableWithColumns<T extends TableConfig> =
 	& SQLiteTable<T>
-	& {
-		[Key in keyof T['columns']]: T['columns'][Key];
-	};
+	& T['columns']
+	& InferTableColumnsModels<T['columns']>;
 
 export interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SQLiteColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -75,7 +80,7 @@ export interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
 
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SQLiteColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: SQLiteColumnBuilders) => TColumnsMap,
@@ -110,7 +115,7 @@ export interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SQLiteColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
@@ -146,7 +151,7 @@ export interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
 	 */
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, SQLiteColumnBuilderBase>,
+		TColumnsMap extends Record<string, ColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: (columnTypes: SQLiteColumnBuilders) => TColumnsMap,
@@ -159,9 +164,10 @@ export interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
 	}>;
 }
 
-function sqliteTableBase<
+/** @internal */
+export function sqliteTableBase<
 	TTableName extends string,
-	TColumnsMap extends Record<string, SQLiteColumnBuilderBase>,
+	TColumnsMap extends Record<string, ColumnBuilderBase>,
 	TSchema extends string | undefined,
 >(
 	name: TTableName,
@@ -171,7 +177,8 @@ function sqliteTableBase<
 			self: BuildColumns<TTableName, TColumnsMap, 'sqlite'>,
 		) => SQLiteTableExtraConfig | SQLiteTableExtraConfigValue[])
 		| undefined,
-	schema?: TSchema,
+	schema: TSchema | undefined,
+	casing: Casing | undefined,
 	baseName = name,
 ): SQLiteTableWithColumns<{
 	name: TTableName;
@@ -179,6 +186,7 @@ function sqliteTableBase<
 	columns: BuildColumns<TTableName, TColumnsMap, 'sqlite'>;
 	dialect: 'sqlite';
 }> {
+	const casingFn = getCasingFn(casing);
 	const rawTable = new SQLiteTable<{
 		name: TTableName;
 		schema: TSchema;
@@ -191,8 +199,8 @@ function sqliteTableBase<
 	const builtColumns = Object.fromEntries(
 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
 			const colBuilder = colBuilderBase as SQLiteColumnBuilder;
-			colBuilder.setName(name);
-			const column = colBuilder.build(rawTable);
+			colBuilder.setName(name, casingFn);
+			const column = colBuilder.build(rawTable).postBuild();
 			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
 			return [name, column];
 		}),
@@ -213,15 +221,21 @@ function sqliteTableBase<
 		) => SQLiteTableExtraConfig;
 	}
 
-	return table;
+	return table as any;
+}
+
+/** @internal */
+export function sqliteTableWithCasing(casing: Casing | undefined): SQLiteTableFn {
+	return (name, columns, extraConfig) => sqliteTableBase(name, columns, extraConfig, undefined, casing);
 }
 
-export const sqliteTable: SQLiteTableFn = (name, columns, extraConfig) => {
-	return sqliteTableBase(name, columns, extraConfig);
-};
+export const sqliteTable = sqliteTableWithCasing(undefined);
 
-export function sqliteTableCreator(customizeTableName: (name: string) => string): SQLiteTableFn {
+export function sqliteTableCreator(
+	customizeTableName: (name: string) => string,
+	casing?: Casing | undefined,
+): SQLiteTableFn {
 	return (name, columns, extraConfig) => {
-		return sqliteTableBase(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+		return sqliteTableBase(customizeTableName(name) as typeof name, columns, extraConfig, undefined, casing, name);
 	};
 }
diff --git a/drizzle-orm/src/sqlite-core/unique-constraint.ts b/drizzle-orm/src/sqlite-core/unique-constraint.ts
index e9c47e7d3b..4153194889 100644
--- a/drizzle-orm/src/sqlite-core/unique-constraint.ts
+++ b/drizzle-orm/src/sqlite-core/unique-constraint.ts
@@ -51,10 +51,12 @@ export class UniqueConstraint {
 	static readonly [entityKind]: string = 'SQLiteUniqueConstraint';
 
 	readonly columns: SQLiteColumn[];
-	readonly name?: string;
+	readonly name: string;
+	readonly isNameExplicit: boolean;
 
 	constructor(readonly table: SQLiteTable, columns: SQLiteColumn[], name?: string) {
 		this.columns = columns;
+		this.isNameExplicit = !!name;
 		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
 	}
 
diff --git a/drizzle-orm/src/sqlite-core/utils.ts b/drizzle-orm/src/sqlite-core/utils.ts
index 361456c029..df32b58ea5 100644
--- a/drizzle-orm/src/sqlite-core/utils.ts
+++ b/drizzle-orm/src/sqlite-core/utils.ts
@@ -1,7 +1,9 @@
 import { is } from '~/entity.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { SQL } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
 import { Table } from '~/table.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import type { Check } from './checks.ts';
 import { CheckBuilder } from './checks.ts';
@@ -80,3 +82,8 @@ export function getViewConfig<
 		// ...view[SQLiteViewConfig],
 	};
 }
+
+export type DrizzleSQLiteConfig<TRelations extends AnyRelations> = Omit<
+	DrizzleConfig<Record<string, never>, TRelations>,
+	'schema'
+>;
diff --git a/drizzle-orm/src/sqlite-core/view.ts b/drizzle-orm/src/sqlite-core/view.ts
index 1caf211ce9..9da9ededb8 100644
--- a/drizzle-orm/src/sqlite-core/view.ts
+++ b/drizzle-orm/src/sqlite-core/view.ts
@@ -1,13 +1,14 @@
-import type { BuildColumns } from '~/column-builder.ts';
+import type { Casing } from '~/casing.ts';
+import type { BuildColumns, ColumnBuilderBase } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import type { SQLiteColumn, SQLiteColumnBuilderBase } from './columns/common.ts';
+import type { SQLiteColumn } from './columns/common.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
-import { sqliteTable } from './table.ts';
+import { sqliteTableBase } from './table.ts';
 import { SQLiteViewBase } from './view-base.ts';
 
 export interface ViewBuilderConfig {
@@ -68,7 +69,7 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 
 export class ManualViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, SQLiteColumnBuilderBase> = Record<string, SQLiteColumnBuilderBase>,
+	TColumns extends Record<string, ColumnBuilderBase> = Record<string, ColumnBuilderBase>,
 > extends ViewBuilderCore<
 	{ name: TName; columns: TColumns }
 > {
@@ -79,9 +80,14 @@ export class ManualViewBuilder<
 	constructor(
 		name: TName,
 		columns: TColumns,
+		casing: Casing | undefined,
 	) {
 		super(name);
-		this.columns = getTableColumns(sqliteTable(name, columns)) as BuildColumns<TName, TColumns, 'sqlite'>;
+		this.columns = getTableColumns(sqliteTableBase(name, columns, undefined, undefined, casing)) as BuildColumns<
+			TName,
+			TColumns,
+			'sqlite'
+		>;
 	}
 
 	existing(): SQLiteViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'sqlite'>> {
@@ -148,19 +154,23 @@ export type SQLiteViewWithSelection<
 	TSelection extends ColumnsSelection,
 > = SQLiteView<TName, TExisting, TSelection> & TSelection;
 
-export function sqliteView<TName extends string>(name: TName): ViewBuilder<TName>;
-export function sqliteView<TName extends string, TColumns extends Record<string, SQLiteColumnBuilderBase>>(
-	name: TName,
-	columns: TColumns,
-): ManualViewBuilder<TName, TColumns>;
-export function sqliteView(
-	name: string,
-	selection?: Record<string, SQLiteColumnBuilderBase>,
-): ViewBuilder | ManualViewBuilder {
-	if (selection) {
-		return new ManualViewBuilder(name, selection);
-	}
-	return new ViewBuilder(name);
+export interface SQLiteViewFn {
+	<TName extends string>(name: TName): ViewBuilder<TName>;
+	<TName extends string, TColumns extends Record<string, ColumnBuilderBase>>(
+		name: TName,
+		columns: TColumns,
+	): ManualViewBuilder<TName, TColumns>;
+}
+
+/** @internal */
+export function sqliteViewWithCasing(casing: Casing | undefined): SQLiteViewFn {
+	return ((name, columns) => {
+		if (columns) {
+			return new ManualViewBuilder(name, columns, casing);
+		}
+		return new ViewBuilder(name);
+	}) as SQLiteViewFn;
 }
 
+export const sqliteView = sqliteViewWithCasing(undefined);
 export const view = sqliteView;
diff --git a/drizzle-orm/src/sqlite-proxy/driver.ts b/drizzle-orm/src/sqlite-proxy/driver.ts
index 2e8663a30a..e43f5bca3a 100644
--- a/drizzle-orm/src/sqlite-proxy/driver.ts
+++ b/drizzle-orm/src/sqlite-proxy/driver.ts
@@ -1,24 +1,25 @@
 import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { createTableRelationsHelpers, extractTablesRelationalConfig } from '~/relations.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
-import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type { DrizzleConfig } from '~/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod } from '~/sqlite-core/session.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
 import { SQLiteRemoteSession } from './session.ts';
 
 export interface SqliteRemoteResult<T = unknown> {
 	rows?: T[];
 }
 
-export class SqliteRemoteDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends BaseSQLiteDatabase<'async', SqliteRemoteResult, TSchema> {
+export class SqliteRemoteDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', SqliteRemoteResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SqliteRemoteDatabase';
 
 	/** @internal */
-	declare readonly session: SQLiteRemoteSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+	declare readonly session: SQLiteRemoteSession<TRelations>;
 
 	async batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
@@ -30,36 +31,35 @@ export class SqliteRemoteDatabase<
 export type AsyncRemoteCallback = (
 	sql: string,
 	params: any[],
-	method: 'run' | 'all' | 'values' | 'get',
+	method: SQLiteExecuteMethod,
 ) => Promise<{ rows: any[] }>;
 
 export type AsyncBatchRemoteCallback = (batch: {
 	sql: string;
 	params: any[];
-	method: 'run' | 'all' | 'values' | 'get';
+	method: SQLiteExecuteMethod;
 }[]) => Promise<{ rows: any[] }[]>;
 
 export type RemoteCallback = AsyncRemoteCallback;
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	callback: RemoteCallback,
-	config?: DrizzleConfig<TSchema>,
-): SqliteRemoteDatabase<TSchema>;
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+	config?: DrizzleSQLiteConfig<TRelations>,
+): SqliteRemoteDatabase<TRelations>;
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	callback: RemoteCallback,
 	batchCallback?: AsyncBatchRemoteCallback,
-	config?: DrizzleConfig<TSchema>,
-): SqliteRemoteDatabase<TSchema>;
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+	config?: DrizzleSQLiteConfig<TRelations>,
+): SqliteRemoteDatabase<TRelations>;
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	callback: RemoteCallback,
-	batchCallback?: AsyncBatchRemoteCallback | DrizzleConfig<TSchema>,
-	config?: DrizzleConfig<TSchema>,
-): SqliteRemoteDatabase<TSchema> {
-	const dialect = new SQLiteAsyncDialect({ casing: config?.casing });
+	batchCallback?: AsyncBatchRemoteCallback | DrizzleSQLiteConfig<TRelations>,
+	config?: DrizzleSQLiteConfig<TRelations>,
+): SqliteRemoteDatabase<TRelations> {
 	let logger;
 	let cache;
 	let _batchCallback: AsyncBatchRemoteCallback | undefined;
-	let _config: DrizzleConfig<TSchema> = {};
+	let _config: DrizzleSQLiteConfig<TRelations> = {};
 
 	if (batchCallback) {
 		if (typeof batchCallback === 'function') {
@@ -67,7 +67,7 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 			_config = config ?? {};
 		} else {
 			_batchCallback = undefined;
-			_config = batchCallback as DrizzleConfig<TSchema>;
+			_config = batchCallback as DrizzleSQLiteConfig<TRelations>;
 		}
 
 		if (_config.logger === true) {
@@ -78,21 +78,21 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		}
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (_config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			_config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: _config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(_config.jit),
+	});
 
-	const session = new SQLiteRemoteSession(callback, dialect, schema, _batchCallback, { logger, cache });
-	const db = new SqliteRemoteDatabase('async', dialect, session, schema) as SqliteRemoteDatabase<TSchema>;
+	const relations = _config.relations ?? {} as TRelations;
+	const session = new SQLiteRemoteSession(callback, dialect, relations, _batchCallback, {
+		logger,
+		cache,
+	});
+	const db = new SqliteRemoteDatabase(
+		'async',
+		dialect,
+		session,
+		relations,
+	);
 	(<any> db).$cache = cache;
 	if ((<any> db).$cache) {
 		(<any> db).$cache['invalidate'] = cache?.onMutate;
diff --git a/drizzle-orm/src/sqlite-proxy/migrator.ts b/drizzle-orm/src/sqlite-proxy/migrator.ts
index cc4a7f71c3..167679ffa2 100644
--- a/drizzle-orm/src/sqlite-proxy/migrator.ts
+++ b/drizzle-orm/src/sqlite-proxy/migrator.ts
@@ -1,12 +1,15 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeAsyncIfNeeded } from '~/up-migrations/sqlite-proxy.ts';
 import type { SqliteRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: SqliteRemoteDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: SqliteRemoteDatabase<TRelations>,
 	callback: ProxyMigrator,
 	config: MigrationConfig,
 ) {
@@ -16,34 +19,72 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 		? '__drizzle_migrations'
 		: config.migrationsTable ?? '__drizzle_migrations';
 
-	const migrationTableCreate = sql`
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeAsyncIfNeeded(migrationsTable, db, callback, migrations);
+
+	if (newDb) {
+		const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
-			id SERIAL PRIMARY KEY,
+			id INTEGER PRIMARY KEY,
 			hash text NOT NULL,
-			created_at numeric
-		)
-	`;
+			created_at numeric,
+			name text,
+			applied_at TEXT
+		);`;
 
-	await db.run(migrationTableCreate);
+		await db.run(migrationTableCreate);
+	}
 
-	const dbMigrations = await db.values<[number, string, string]>(
-		sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`,
-	);
+	const dbMigrations = (await db.values<[number, string, string, string | null]>(
+		sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`,
+	)).map(([id, hash, created_at, name]) => ({ id, hash, created_at, name }));
 
-	const lastDbMigration = dbMigrations[0] ?? undefined;
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
 
-	const queriesToRun: string[] = [];
-	for (const migration of migrations) {
-		if (
-			!lastDbMigration
-			|| Number(lastDbMigration[2])! < migration.folderMillis
-		) {
-			queriesToRun.push(
-				...migration.sql,
-				`INSERT INTO \`${migrationsTable}\` ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`,
-			);
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
 		}
+
+		const [migration] = migrations;
+
+		if (!migration) return;
+
+		await callback(
+			[
+				db.dialect.sqlToQuery(
+					sql`insert into ${
+						sql.identifier(migrationsTable)
+					} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+						new Date().toISOString()
+					})`
+						.inlineParams(),
+				).sql,
+			],
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	const queriesToRun: string[] = [];
+	for (const migration of migrationsToRun) {
+		queriesToRun.push(
+			...migration.sql,
+			db.dialect.sqlToQuery(
+				sql`insert into ${
+					sql.identifier(migrationsTable)
+				} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${
+					new Date().toISOString()
+				})`
+					.inlineParams(),
+			).sql,
+		);
 	}
 
 	await callback(queriesToRun);
+
+	return;
 }
diff --git a/drizzle-orm/src/sqlite-proxy/session.ts b/drizzle-orm/src/sqlite-proxy/session.ts
index bdf94cc6cc..ea1c93c95f 100644
--- a/drizzle-orm/src/sqlite-proxy/session.ts
+++ b/drizzle-orm/src/sqlite-proxy/session.ts
@@ -1,23 +1,21 @@
-import type { BatchItem } from '~/batch.ts';
+import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { PreparedQuery } from '~/session.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
-import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import type {
-	PreparedQueryConfig as PreparedQueryConfigBase,
-	SQLiteExecuteMethod,
-	SQLiteTransactionConfig,
-} from '~/sqlite-core/session.ts';
-import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { mapResultRow } from '~/utils.ts';
-import type { AsyncBatchRemoteCallback, AsyncRemoteCallback, RemoteCallback, SqliteRemoteResult } from './driver.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, type SQL, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { AsyncBatchRemoteCallback, RemoteCallback, SqliteRemoteResult } from './driver.ts';
 
 export interface SQLiteRemoteSessionOptions {
 	logger?: Logger;
@@ -27,9 +25,8 @@ export interface SQLiteRemoteSessionOptions {
 export type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
 export class SQLiteRemoteSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteSession<'async', SqliteRemoteResult, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends SQLiteAsyncSession<'async', SqliteRemoteResult, TRelations> {
 	static override readonly [entityKind]: string = 'SQLiteRemoteSession';
 
 	private logger: Logger;
@@ -37,62 +34,94 @@ export class SQLiteRemoteSession<
 
 	constructor(
 		private client: RemoteCallback,
-		dialect: SQLiteAsyncDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
-		private batchCLient?: AsyncBatchRemoteCallback,
-		options: SQLiteRemoteSessionOptions = {},
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private batchClient?: AsyncBatchRemoteCallback,
+		private options: SQLiteRemoteSessionOptions = {},
 	) {
-		super(dialect);
+		super(dialect, 'async');
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => unknown,
+		mode: 'arrays' | 'objects' | 'raw',
+		_prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): RemotePreparedQuery<T> {
-		return new RemotePreparedQuery(
-			this.client,
+	): SQLiteAsyncPreparedQuery<T & { run: SqliteRemoteResult }> {
+		// TODO: client doesn't support object mode querying - revisit api
+		const executors: SQLiteQueryExecutors<'async'> = {
+			all: (params) => this.client(query.sql, params, 'all').then(({ rows }) => rows),
+			get: (params) => this.client(query.sql, params, 'get').then(({ rows }) => rows),
+			run: (params) => this.client(query.sql, params, 'run'),
+			values: (params) => this.client(query.sql, params, 'all').then(({ rows }) => rows),
+		};
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
 			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
-	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
-		const preparedQueries: PreparedQuery[] = [];
-		const builtQueries: { sql: string; params: any[]; method: 'run' | 'all' | 'values' | 'get' }[] = [];
+	override objects<T = unknown>(_query: SQL): Promise<T[]> {
+		throw new Error("Proxy driver doesn't support object-mode querying");
+	}
+
+	override object<T = unknown>(_query: SQL): Promise<T> {
+		throw new Error("Proxy driver doesn't support object-mode querying");
+	}
+
+	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T): Promise<BatchResponse<T>> {
+		const preparedQueries: SQLiteAsyncPreparedQuery<any>[] = [];
+		const builtQueries: { sql: string; params: any[]; method: SQLiteExecuteMethod }[] = [];
 
 		for (const query of queries) {
-			const preparedQuery = query._prepare();
-			const builtQuery = (preparedQuery as RemotePreparedQuery).getQuery();
+			const preparedQuery = query._prepare() as SQLiteAsyncPreparedQuery<any>;
+			const builtQuery = preparedQuery.getQuery();
 			preparedQueries.push(preparedQuery);
-			builtQueries.push({ sql: builtQuery.sql, params: builtQuery.params, method: builtQuery.method });
+			builtQueries.push({ sql: builtQuery.sql, params: builtQuery.params, method: preparedQuery.executeMethod });
 		}
 
-		const batchResults = await (this.batchCLient as AsyncBatchRemoteCallback)(builtQueries);
-		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
+		const batchResults = await (this.batchClient as AsyncBatchRemoteCallback)(builtQueries);
+		return batchResults.map((result, i) => {
+			const { executeMethod, mapper } = preparedQueries[i]!;
+
+			if (executeMethod === 'run') return result;
+			if (executeMethod === 'values') return result.rows;
+
+			const { rows } = result;
+			if (executeMethod === 'get') {
+				if (!rows) return;
+				if (!mapper) return rows;
+
+				return mapper([rows])[0];
+			}
+
+			if (!mapper) return rows;
+
+			return mapper(rows);
+		}) as BatchResponse<T>;
 	}
 
 	override async transaction<T>(
-		transaction: (tx: SQLiteProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: SQLiteProxyTransaction<TRelations>) => Promise<T>,
 		config?: SQLiteTransactionConfig,
 	): Promise<T> {
-		const tx = new SQLiteProxyTransaction('async', this.dialect, this, this.schema);
+		const tx = new SQLiteProxyTransaction('async', this.dialect, this, this.relations);
 		await this.run(sql.raw(`begin${config?.behavior ? ' ' + config.behavior : ''}`));
 		try {
 			const result = await transaction(tx);
@@ -103,31 +132,24 @@ export class SQLiteRemoteSession<
 			throw err;
 		}
 	}
-
-	override extractRawAllValueFromBatchResult(result: unknown): unknown {
-		return (result as SqliteRemoteResult).rows;
-	}
-
-	override extractRawGetValueFromBatchResult(result: unknown): unknown {
-		return (result as SqliteRemoteResult).rows![0];
-	}
-
-	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
-		return (result as SqliteRemoteResult).rows;
-	}
 }
 
-export class SQLiteProxyTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends SQLiteTransaction<'async', SqliteRemoteResult, TFullSchema, TSchema> {
+export class SQLiteProxyTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', SqliteRemoteResult, TRelations>
+{
 	static override readonly [entityKind]: string = 'SQLiteProxyTransaction';
 
 	override async transaction<T>(
-		transaction: (tx: SQLiteProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: SQLiteProxyTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex}`;
-		const tx = new SQLiteProxyTransaction('async', this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		const tx = new SQLiteProxyTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
 		await this.session.run(sql.raw(`savepoint ${savepointName}`));
 		try {
 			const result = await transaction(tx);
@@ -139,133 +161,3 @@ export class SQLiteProxyTransaction<
 		}
 	}
 }
-
-export class RemotePreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
-	{ type: 'async'; run: SqliteRemoteResult; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
-> {
-	static override readonly [entityKind]: string = 'SQLiteProxyPreparedQuery';
-
-	private method: SQLiteExecuteMethod;
-
-	constructor(
-		private client: RemoteCallback,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		executeMethod: SQLiteExecuteMethod,
-		private _isResponseInArrayMode: boolean,
-		/** @internal */ public customResultMapper?: (
-			rows: unknown[][],
-			mapColumnValue?: (value: unknown) => unknown,
-		) => unknown,
-	) {
-		super('async', executeMethod, query, cache, queryMetadata, cacheConfig);
-		this.customResultMapper = customResultMapper;
-		this.method = executeMethod;
-	}
-
-	override getQuery(): Query & { method: SQLiteExecuteMethod } {
-		return { ...this.query, method: this.method };
-	}
-
-	async run(placeholderValues?: Record<string, unknown>): Promise<SqliteRemoteResult> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		return await this.queryWithCache(this.query.sql, params, async () => {
-			return await (this.client as AsyncRemoteCallback)(this.query.sql, params, 'run');
-		});
-	}
-
-	override mapAllResult(rows: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			rows = (rows as SqliteRemoteResult).rows;
-		}
-
-		if (!this.fields && !this.customResultMapper) {
-			return rows;
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper(rows as unknown[][]) as T['all'];
-		}
-
-		return (rows as unknown[][]).map((row) => {
-			return mapResultRow(
-				this.fields!,
-				row,
-				this.joinsNotNullableMap,
-			);
-		});
-	}
-
-	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { query, logger, client } = this;
-
-		const params = fillPlaceholders(query.params, placeholderValues ?? {});
-		logger.logQuery(query.sql, params);
-
-		const { rows } = await this.queryWithCache(query.sql, params, async () => {
-			return await (client as AsyncRemoteCallback)(query.sql, params, 'all');
-		});
-		return this.mapAllResult(rows);
-	}
-
-	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { query, logger, client } = this;
-
-		const params = fillPlaceholders(query.params, placeholderValues ?? {});
-		logger.logQuery(query.sql, params);
-
-		const clientResult = await this.queryWithCache(query.sql, params, async () => {
-			return await (client as AsyncRemoteCallback)(query.sql, params, 'get');
-		});
-
-		return this.mapGetResult(clientResult.rows);
-	}
-
-	override mapGetResult(rows: unknown, isFromBatch?: boolean): unknown {
-		if (isFromBatch) {
-			rows = (rows as SqliteRemoteResult).rows;
-		}
-
-		const row = rows as unknown[];
-
-		if (!this.fields && !this.customResultMapper) {
-			return row;
-		}
-
-		if (!row) {
-			return undefined;
-		}
-
-		if (this.customResultMapper) {
-			return this.customResultMapper([rows] as unknown[][]) as T['get'];
-		}
-
-		return mapResultRow(
-			this.fields!,
-			row,
-			this.joinsNotNullableMap,
-		);
-	}
-
-	async values<T extends any[] = unknown[]>(placeholderValues?: Record<string, unknown>): Promise<T[]> {
-		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
-		this.logger.logQuery(this.query.sql, params);
-		const clientResult = await this.queryWithCache(this.query.sql, params, async () => {
-			return await (this.client as AsyncRemoteCallback)(this.query.sql, params, 'values');
-		});
-		return clientResult.rows as T[];
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
diff --git a/drizzle-orm/src/table.ts b/drizzle-orm/src/table.ts
index 99d5467164..80a11ade70 100644
--- a/drizzle-orm/src/table.ts
+++ b/drizzle-orm/src/table.ts
@@ -1,14 +1,14 @@
-import type { Column, GetColumnData } from './column.ts';
+import type { Column, Columns, GetColumnData } from './column.ts';
 import { entityKind } from './entity.ts';
 import type { OptionalKeyOnly, RequiredKeyOnly } from './operations.ts';
-import type { SQLWrapper } from './sql/sql.ts';
+import type { View } from './sql/sql.ts';
 import { TableName } from './table.utils.ts';
 import type { Simplify, Update } from './utils.ts';
 
-export interface TableConfig<TColumn extends Column = Column<any>> {
+export interface TableConfig<TColumns extends Columns = Columns> {
 	name: string;
 	schema: string | undefined;
-	columns: Record<string, TColumn>;
+	columns: TColumns;
 	dialect: string;
 }
 
@@ -17,10 +17,10 @@ export type UpdateTableConfig<T extends TableConfig, TUpdate extends Partial<Tab
 >;
 
 /** @internal */
-export const Schema = Symbol.for('drizzle:Schema');
+export const TableSchema = Symbol.for('drizzle:Schema');
 
 /** @internal */
-export const Columns = Symbol.for('drizzle:Columns');
+export const TableColumns = Symbol.for('drizzle:Columns');
 
 /** @internal */
 export const ExtraConfigColumns = Symbol.for('drizzle:ExtraConfigColumns');
@@ -39,35 +39,25 @@ export const ExtraConfigBuilder = Symbol.for('drizzle:ExtraConfigBuilder');
 
 const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
 
-export interface Table<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	T extends TableConfig = TableConfig,
-> extends SQLWrapper {
-	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+export interface TableTypeConfig<T extends TableConfig> {
+	readonly brand: 'Table';
+	readonly name: T['name'];
+	readonly schema: T['schema'];
+	readonly columns: T['columns'];
+	readonly dialect: T['dialect'];
 }
 
-export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
+export class Table<out T extends TableConfig = TableConfig> {
 	static readonly [entityKind]: string = 'Table';
 
-	declare readonly _: {
-		readonly brand: 'Table';
-		readonly config: T;
-		readonly name: T['name'];
-		readonly schema: T['schema'];
-		readonly columns: T['columns'];
-		readonly inferSelect: InferSelectModel<Table<T>>;
-		readonly inferInsert: InferInsertModel<Table<T>>;
-	};
-
-	declare readonly $inferSelect: InferSelectModel<Table<T>>;
-	declare readonly $inferInsert: InferInsertModel<Table<T>>;
+	declare readonly _: TableTypeConfig<T>;
 
 	/** @internal */
 	static readonly Symbol = {
 		Name: TableName as typeof TableName,
-		Schema: Schema as typeof Schema,
+		Schema: TableSchema as typeof TableSchema,
 		OriginalName: OriginalName as typeof OriginalName,
-		Columns: Columns as typeof Columns,
+		Columns: TableColumns as typeof TableColumns,
 		ExtraConfigColumns: ExtraConfigColumns as typeof ExtraConfigColumns,
 		BaseName: BaseName as typeof BaseName,
 		IsAlias: IsAlias as typeof IsAlias,
@@ -87,10 +77,10 @@ export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
 	[OriginalName]: string;
 
 	/** @internal */
-	[Schema]: string | undefined;
+	[TableSchema]: string | undefined;
 
 	/** @internal */
-	[Columns]!: T['columns'];
+	[TableColumns]!: T['columns'];
 
 	/** @internal */
 	[ExtraConfigColumns]!: Record<string, unknown>;
@@ -112,7 +102,7 @@ export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
 
 	constructor(name: string, schema: string | undefined, baseName: string) {
 		this[TableName] = this[OriginalName] = name;
-		this[Schema] = schema;
+		this[TableSchema] = schema;
 		this[BaseName] = baseName;
 	}
 }
@@ -144,8 +134,16 @@ export function getTableName<T extends Table>(table: T): T['_']['name'] {
 	return table[TableName];
 }
 
-export function getTableUniqueName<T extends Table>(table: T): `${T['_']['schema']}.${T['_']['name']}` {
-	return `${table[Schema] ?? 'public'}.${table[TableName]}`;
+export function getTableUniqueName<
+	T extends Table | View,
+	TResult extends string = T extends Table ? T['_']['schema'] extends undefined ? `public.${T['_']['name']}`
+		: `${T['_']['schema']}.${T['_']['name']}`
+		// Views don't have type-level schema names, to be added
+		: `${string}.${T['_']['name']}`,
+>(
+	table: T,
+): TResult {
+	return `${table[TableSchema] ?? 'public'}.${table[TableName]}` as TResult;
 }
 
 export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> =
@@ -153,15 +151,15 @@ export type MapColumnName<TName extends string, TColumn extends Column, TDBColum
 		: TName;
 
 export type InferModelFromColumns<
-	TColumns extends Record<string, Column>,
+	TColumns extends Columns,
 	TInferMode extends 'select' | 'insert' = 'select',
-	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+	TConfig extends { override?: boolean } = { dbColumnNames: false; override: false },
 > = Simplify<
 	TInferMode extends 'insert' ?
 			& {
 				[
 					Key in keyof TColumns & string as RequiredKeyOnly<
-						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						Key,
 						TColumns[Key]
 					>
 				]: GetColumnData<TColumns[Key], 'query'>;
@@ -169,7 +167,7 @@ export type InferModelFromColumns<
 			& {
 				[
 					Key in keyof TColumns & string as OptionalKeyOnly<
-						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						Key,
 						TColumns[Key],
 						TConfig['override']
 					>
@@ -177,11 +175,7 @@ export type InferModelFromColumns<
 			}
 		: {
 			[
-				Key in keyof TColumns & string as MapColumnName<
-					Key,
-					TColumns[Key],
-					TConfig['dbColumnNames']
-				>
+				Key in keyof TColumns & string
 			]: GetColumnData<TColumns[Key], 'query'>;
 		}
 >;
@@ -191,18 +185,21 @@ export type InferModelFromColumns<
 export type InferModel<
 	TTable extends Table,
 	TInferMode extends 'select' | 'insert' = 'select',
-	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
-> = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
+> = InferModelFromColumns<TTable['_']['columns'], TInferMode>;
 
 export type InferSelectModel<
 	TTable extends Table,
-	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
-> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+> = InferModelFromColumns<TTable['_']['columns'], 'select'>;
 
 export type InferInsertModel<
 	TTable extends Table,
-	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
-> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+	TOverride extends { override?: boolean } = { override: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'insert', TOverride>;
 
 export type InferEnum<T> = T extends { enumValues: readonly (infer U)[] } ? U
 	: never;
+
+export interface InferTableColumnsModels<TColumns extends Columns> {
+	readonly $inferSelect: InferModelFromColumns<TColumns, 'select'>;
+	readonly $inferInsert: InferModelFromColumns<TColumns, 'insert', { override: false }>;
+}
diff --git a/drizzle-orm/src/tidb-serverless/codecs.ts b/drizzle-orm/src/tidb-serverless/codecs.ts
new file mode 100644
index 0000000000..8530861c57
--- /dev/null
+++ b/drizzle-orm/src/tidb-serverless/codecs.ts
@@ -0,0 +1,78 @@
+import { refineGenericMySqlCodecs } from '~/mysql-core/codecs.ts';
+import { textDecoder } from '~/utils.ts';
+
+const bitStringFromBytes = (value: Uint8Array): string => {
+	const str: string[] = Array.from({ length: value.length });
+	for (let i = 0; i < value.length; ++i) {
+		str[i] = value[i] === 49 ? '1' : '0';
+	}
+	return str.join('');
+};
+
+export const tidbCodecs = refineGenericMySqlCodecs({
+	serial: {
+		normalize: Number,
+	},
+	bigint: {
+		normalize: BigInt,
+	},
+	'bigint:number': {
+		normalize: Number,
+	},
+	boolean: {
+		normalize: (value: number) => value === 1,
+	},
+	date: {
+		normalize: (value: string) => new Date(value),
+	},
+	datetime: {
+		normalize: (value: string) => new Date(value.replace(' ', 'T') + 'Z'),
+	},
+	timestamp: {
+		normalize: (value: string) => new Date(value + '+0000'),
+	},
+	'decimal:number': {
+		normalize: Number,
+	},
+	'decimal:bigint': {
+		normalize: BigInt,
+	},
+	binary: {
+		normalize: bitStringFromBytes,
+	},
+	varbinary: {
+		normalize: bitStringFromBytes,
+	},
+	blob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	tinyblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	mediumblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	longblob: {
+		normalize: typeof Buffer === 'undefined'
+			? textDecoder ? ((value: Uint8Array) => textDecoder!.decode(value)) : undefined
+			: (value: Uint8Array) => Buffer.from(value).toString('utf8'),
+	},
+	'blob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'tinyblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'mediumblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+	'longblob:buffer': {
+		normalize: typeof Buffer === 'undefined' ? undefined : (value: Uint8Array) => Buffer.from(value),
+	},
+});
diff --git a/drizzle-orm/src/tidb-serverless/driver.ts b/drizzle-orm/src/tidb-serverless/driver.ts
index 4ec77c6983..083ac26f51 100644
--- a/drizzle-orm/src/tidb-serverless/driver.ts
+++ b/drizzle-orm/src/tidb-serverless/driver.ts
@@ -1,37 +1,31 @@
 import { type Config, connect, type Connection } from '@tidbcloud/serverless';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { MySqlDatabase } from '~/mysql-core/db.ts';
+import { MySqlAsyncDatabase } from '~/mysql-core/async/db.ts';
 import { MySqlDialect } from '~/mysql-core/dialect.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import type { TiDBServerlessPreparedQueryHKT, TiDBServerlessQueryResultHKT } from './session.ts';
+import type { DrizzleMySqlConfig } from '~/mysql-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { tidbCodecs } from './codecs.ts';
+import type { TiDBServerlessQueryResultHKT } from './session.ts';
 import { TiDBServerlessSession } from './session.ts';
 
-export interface TiDBServerlessSDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class TiDBServerlessDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends MySqlDatabase<TiDBServerlessQueryResultHKT, TiDBServerlessPreparedQueryHKT, TSchema> {
+export class TiDBServerlessDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends MySqlAsyncDatabase<TiDBServerlessQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'TiDBServerlessDatabase';
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<TRelations extends AnyRelations = EmptyRelations>(
 	client: Connection,
-	config: DrizzleConfig<TSchema> = {},
-): TiDBServerlessDatabase<TSchema> & {
+	config: DrizzleMySqlConfig<TRelations> = {},
+): TiDBServerlessDatabase<TRelations> & {
 	$client: Connection;
 } {
-	const dialect = new MySqlDialect({ casing: config.casing });
+	const dialect = new MySqlDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? tidbCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -39,21 +33,12 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const session = new TiDBServerlessSession(client, dialect, undefined, schema, { logger, cache: config.cache });
-	const db = new TiDBServerlessDatabase(dialect, session, schema as any, 'default') as TiDBServerlessDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new TiDBServerlessSession(client, dialect, undefined, relations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new TiDBServerlessDatabase(dialect, session, relations);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -64,23 +49,23 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends Connection = Connection,
 >(
 	...params: [
-		TClient | string,
+		string,
 	] | [
-		TClient | string,
-		DrizzleConfig<TSchema>,
+		string,
+		DrizzleMySqlConfig<TRelations>,
 	] | [
 		& ({
 			connection: string | Config;
 		} | {
 			client: TClient;
 		})
-		& DrizzleConfig<TSchema>,
+		& DrizzleMySqlConfig<TRelations>,
 	]
-): TiDBServerlessDatabase<TSchema> & {
+): TiDBServerlessDatabase<TRelations> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -91,29 +76,25 @@ export function drizzle<
 		return construct(instance, params[1]) as any;
 	}
 
-	if (isConfig(params[0])) {
-		const { connection, client, ...drizzleConfig } = params[0] as
-			& { connection?: Config | string; client?: TClient }
-			& DrizzleConfig<TSchema>;
+	const { connection, client, ...DrizzleMySqlConfig } = params[0] as
+		& { connection?: Config | string; client?: TClient }
+		& DrizzleMySqlConfig<TRelations>;
 
-		if (client) return construct(client, drizzleConfig) as any;
+	if (client) return construct(client, DrizzleMySqlConfig) as any;
 
-		const instance = typeof connection === 'string'
-			? connect({
-				url: connection,
-			})
-			: connect(connection!);
-
-		return construct(instance, drizzleConfig) as any;
-	}
+	const instance = typeof connection === 'string'
+		? connect({
+			url: connection,
+		})
+		: connect(connection!);
 
-	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(instance, DrizzleMySqlConfig) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): TiDBServerlessDatabase<TSchema> & {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleMySqlConfig<TRelations>,
+	): TiDBServerlessDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/tidb-serverless/index.ts b/drizzle-orm/src/tidb-serverless/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/tidb-serverless/index.ts
+++ b/drizzle-orm/src/tidb-serverless/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/tidb-serverless/migrator.ts b/drizzle-orm/src/tidb-serverless/migrator.ts
index 7fa0729451..658c2443a2 100644
--- a/drizzle-orm/src/tidb-serverless/migrator.ts
+++ b/drizzle-orm/src/tidb-serverless/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/mysql-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { TiDBServerlessDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: TiDBServerlessDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: TiDBServerlessDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/tidb-serverless/session.ts b/drizzle-orm/src/tidb-serverless/session.ts
index bf555a5c7f..48b5915c5d 100644
--- a/drizzle-orm/src/tidb-serverless/session.ts
+++ b/drizzle-orm/src/tidb-serverless/session.ts
@@ -1,105 +1,14 @@
-import type { Connection, ExecuteOptions, FullResult, Tx } from '@tidbcloud/serverless';
+import type { Connection, FullResult, Tx } from '@tidbcloud/serverless';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
-import { Column } from '~/column.ts';
-
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { MySqlAsyncPreparedQuery, MySqlAsyncSession, MySqlAsyncTransaction } from '~/mysql-core/async/session.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
-import {
-	MySqlPreparedQuery,
-	type MySqlPreparedQueryConfig,
-	type MySqlPreparedQueryHKT,
-	type MySqlQueryResultHKT,
-	MySqlSession,
-	MySqlTransaction,
-} from '~/mysql-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
-
-const executeRawConfig = { fullResult: true } satisfies ExecuteOptions;
-const queryConfig = { arrayMode: true } satisfies ExecuteOptions;
-
-export class TiDBServerlessPreparedQuery<T extends MySqlPreparedQueryConfig> extends MySqlPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'TiDBPreparedQuery';
-
-	constructor(
-		private client: Tx | Connection,
-		private queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-		// Keys that were used in $default and the value that was generated for them
-		private generatedIds?: Record<string, unknown>[],
-		// Keys that should be returned, it has the column with all properries + key from object
-		private returningIds?: SelectedFieldsOrdered,
-	) {
-		super(cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.queryString, params);
-
-		const { fields, client, queryString, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } = this;
-		if (!fields && !customResultMapper) {
-			const res = await this.queryWithCache(queryString, params, async () => {
-				return await client.execute(queryString, params, executeRawConfig) as FullResult;
-			});
-			const insertId = res.lastInsertId ?? 0;
-			const affectedRows = res.rowsAffected ?? 0;
-			// for each row, I need to check keys from
-			if (returningIds) {
-				const returningResponse = [];
-				let j = 0;
-				for (let i = insertId; i < insertId + affectedRows; i++) {
-					for (const column of returningIds) {
-						const key = returningIds[0]!.path[0]!;
-						if (is(column.field, Column)) {
-							// @ts-ignore
-							if (column.field.primary && column.field.autoIncrement) {
-								returningResponse.push({ [key]: i });
-							}
-							if (column.field.defaultFn && generatedIds) {
-								// generatedIds[rowIdx][key]
-								returningResponse.push({ [key]: generatedIds[j]![key] });
-							}
-						}
-					}
-					j++;
-				}
-
-				return returningResponse;
-			}
-			return res;
-		}
-
-		const rows = await this.queryWithCache(queryString, params, async () => {
-			return await client.execute(queryString, params, queryConfig) as unknown[][];
-		});
-
-		if (customResultMapper) {
-			return customResultMapper(rows);
-		}
-
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	override iterator(_placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']> {
-		throw new Error('Streaming is not supported by the TiDB Cloud Serverless driver');
-	}
-}
+import type { MySqlPreparedQueryConfig, MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
 
 export interface TiDBServerlessSessionOptions {
 	logger?: Logger;
@@ -107,9 +16,11 @@ export interface TiDBServerlessSessionOptions {
 }
 
 export class TiDBServerlessSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlSession<TiDBServerlessQueryResultHKT, TiDBServerlessPreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncSession<
+	TiDBServerlessQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'TiDBServerlessSession';
 
 	private logger: Logger;
@@ -120,7 +31,7 @@ export class TiDBServerlessSession<
 		private baseClient: Connection,
 		dialect: MySqlDialect,
 		tx: Tx | undefined,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: TiDBServerlessSessionOptions = {},
 	) {
 		super(dialect);
@@ -131,55 +42,65 @@ export class TiDBServerlessSession<
 
 	prepareQuery<T extends MySqlPreparedQueryConfig = MySqlPreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
-		generatedIds?: Record<string, unknown>[],
-		returningIds?: SelectedFieldsOrdered,
+		mode: 'arrays' | 'objects' | 'raw',
+		mapper?: (response: Record<string, unknown>[] | unknown[][] | { insertId: number; affectedRows: number }) => any,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): MySqlPreparedQuery<T> {
-		return new TiDBServerlessPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	): MySqlAsyncPreparedQuery<T> {
+		const { client } = this;
+		const queryConfig = mode === 'arrays'
+			? { arrayMode: true }
+			: { fullResult: true };
+
+		const executor = async (params: any[] = []) => {
+			const raw = client.execute(
+				query.sql,
+				params,
+				queryConfig,
+			);
+
+			if (mode === 'arrays') return raw;
+			if (mode === 'objects') return raw.then((res) => (<FullResult> res).rows);
+			if (!mapper) return raw;
+
+			return raw.then((res) => ({
+				insertId: (<FullResult> res).lastInsertId ?? 0,
+				affectedRows: (<FullResult> res).rowsAffected ?? 0,
+			}));
+		};
+
+		return new MySqlAsyncPreparedQuery(
+			executor,
+			undefined,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			customResultMapper,
-			generatedIds,
-			returningIds,
-		);
-	}
-
-	override all<T = unknown>(query: SQL): Promise<T[]> {
-		const querySql = this.dialect.sqlToQuery(query);
-		this.logger.logQuery(querySql.sql, querySql.params);
-		return this.client.execute(querySql.sql, querySql.params) as Promise<T[]>;
-	}
-
-	override async count(sql: SQL): Promise<number> {
-		const res = await this.execute<{ rows: [{ count: string }] }>(sql);
-
-		return Number(
-			res['rows'][0]['count'],
 		);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: TiDBServerlessTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: TiDBServerlessTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const nativeTx = await this.baseClient.begin();
 		try {
-			const session = new TiDBServerlessSession(this.baseClient, this.dialect, nativeTx, this.schema, this.options);
-			const tx = new TiDBServerlessTransaction<TFullSchema, TSchema>(
+			const session = new TiDBServerlessSession(
+				this.baseClient,
 				this.dialect,
-				session as MySqlSession<any, any, any, any>,
-				this.schema,
+				nativeTx,
+				this.relations,
+				this.options,
+			);
+			const tx = new TiDBServerlessTransaction<TRelations>(
+				this.dialect,
+				session as MySqlAsyncSession<any, any>,
+				this.relations,
 			);
 			const result = await transaction(tx);
 			await nativeTx.commit();
@@ -192,28 +113,30 @@ export class TiDBServerlessSession<
 }
 
 export class TiDBServerlessTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends MySqlTransaction<TiDBServerlessQueryResultHKT, TiDBServerlessPreparedQueryHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends MySqlAsyncTransaction<
+	TiDBServerlessQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'TiDBServerlessTransaction';
 
 	constructor(
 		dialect: MySqlDialect,
-		session: MySqlSession,
-		schema: RelationalSchemaConfig<TSchema> | undefined,
+		session: MySqlAsyncSession,
+		relations: TRelations,
 		nestedIndex = 0,
 	) {
-		super(dialect, session, schema, nestedIndex, 'default');
+		super(dialect, session, relations, nestedIndex);
 	}
 
 	override async transaction<T>(
-		transaction: (tx: TiDBServerlessTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: TiDBServerlessTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new TiDBServerlessTransaction<TFullSchema, TSchema>(
+		const tx = new TiDBServerlessTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this.relations,
 			this.nestedIndex + 1,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
@@ -231,7 +154,3 @@ export class TiDBServerlessTransaction<
 export interface TiDBServerlessQueryResultHKT extends MySqlQueryResultHKT {
 	type: FullResult;
 }
-
-export interface TiDBServerlessPreparedQueryHKT extends MySqlPreparedQueryHKT {
-	type: TiDBServerlessPreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
-}
diff --git a/drizzle-orm/src/tracing.ts b/drizzle-orm/src/tracing.ts
index 7d5fd165bc..4e65986930 100644
--- a/drizzle-orm/src/tracing.ts
+++ b/drizzle-orm/src/tracing.ts
@@ -2,7 +2,7 @@ import type { Span, Tracer } from '@opentelemetry/api';
 import { iife } from '~/tracing-utils.ts';
 import { npmVersion } from '~/version.ts';
 
-let otel: typeof import('@opentelemetry/api') | undefined;
+let otel: typeof import('@opentelemetry/api') | undefined; // oxlint-disable-line
 let rawTracer: Tracer | undefined;
 // try {
 // 	otel = await import('@opentelemetry/api');
@@ -20,6 +20,8 @@ type SpanName =
 	| 'drizzle.driver.execute'
 	| 'drizzle.mapResponse';
 
+export const hasTelemetry = !!otel;
+
 /** @internal */
 export const tracer = {
 	startActiveSpan<F extends (span?: Span) => unknown>(name: SpanName, fn: F): ReturnType<F> {
@@ -41,7 +43,7 @@ export const tracer = {
 						} catch (e) {
 							span.setStatus({
 								code: otel.SpanStatusCode.ERROR,
-								message: e instanceof Error ? e.message : 'Unknown error', // eslint-disable-line no-instanceof/no-instanceof
+								message: e instanceof Error ? e.message : 'Unknown error', // oxlint-disable-line drizzle-internal/no-instanceof
 							});
 							throw e;
 						} finally {
diff --git a/drizzle-orm/src/tursodatabase-serverless/driver.ts b/drizzle-orm/src/tursodatabase-serverless/driver.ts
new file mode 100644
index 0000000000..12ac4230bc
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-serverless/driver.ts
@@ -0,0 +1,105 @@
+import { type Config, connect, type Connection, type Statement } from '@tursodatabase/serverless';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { TursoDatabaseServerlessSession } from './session.ts';
+
+export type TursoDatabaseServerlessRunResult = Awaited<ReturnType<Statement['run']>>;
+
+export class TursoDatabaseServerlessDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', TursoDatabaseServerlessRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseServerlessDatabase';
+
+	/** @internal */
+	declare readonly session: TursoDatabaseServerlessSession<TRelations>;
+}
+
+function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: Connection,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): TursoDatabaseServerlessDatabase<TRelations> & {
+	$client: Connection;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new TursoDatabaseServerlessSession(
+		client,
+		dialect,
+		relations,
+		{ logger, cache: config.cache },
+	);
+	const db = new TursoDatabaseServerlessDatabase(
+		'async',
+		dialect,
+		session,
+		relations,
+	) as TursoDatabaseServerlessDatabase<TRelations>;
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+	return db as any;
+}
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Connection = Connection>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | Config;
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): TursoDatabaseServerlessDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = connect({ url: params[0] });
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...drizzleConfig } = params[0] as
+		& { connection?: string | Config; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, drizzleConfig) as any;
+
+	const instance = typeof connection === 'string'
+		? connect({ url: connection })
+		: connect(connection!);
+
+	return construct(instance, drizzleConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): TursoDatabaseServerlessDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase-serverless/index.ts b/drizzle-orm/src/tursodatabase-serverless/index.ts
new file mode 100644
index 0000000000..b1b6a52e71
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-serverless/index.ts
@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/tursodatabase-serverless/migrator.ts b/drizzle-orm/src/tursodatabase-serverless/migrator.ts
new file mode 100644
index 0000000000..29c728e348
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-serverless/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
+import type { TursoDatabaseServerlessDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: TursoDatabaseServerlessDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return migrateAsync(migrations, db, config);
+}
diff --git a/drizzle-orm/src/tursodatabase-serverless/session.ts b/drizzle-orm/src/tursodatabase-serverless/session.ts
new file mode 100644
index 0000000000..043ca26720
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-serverless/session.ts
@@ -0,0 +1,168 @@
+import type { Connection, Statement } from '@tursodatabase/serverless';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { TursoDatabaseServerlessRunResult } from './driver.ts';
+
+export interface TursoDatabaseServerlessSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class TursoDatabaseServerlessSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', TursoDatabaseServerlessRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseServerlessSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		private client: Connection,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: TursoDatabaseServerlessSessionOptions,
+	) {
+		super(dialect, 'async');
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<T & { run: TursoDatabaseServerlessRunResult }> {
+		let stmt: Statement;
+		const executors: SQLiteQueryExecutors<'async'> = prepare
+			? {
+				all: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').all(params);
+				},
+				get: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').get(params);
+				},
+				run: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.run(params);
+				},
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(params);
+				},
+			}
+			: {
+				all: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').all(params);
+					}
+
+					return this.client.all(query.sql, ...params);
+				},
+				get: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').get(params);
+					}
+
+					return this.client.get(query.sql, ...params);
+				},
+				run: (params) => stmt ? stmt.run(params) : this.client.run(query.sql, ...params),
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(params);
+				},
+			};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (db: TursoDatabaseServerlessTransaction<TRelations>) => Promise<T>,
+		_config?: SQLiteTransactionConfig,
+	): Promise<T> {
+		const session = new TursoDatabaseServerlessSession<TRelations>(
+			this.client,
+			this.dialect,
+			this.relations,
+			this.options,
+		);
+		const tx = new TursoDatabaseServerlessTransaction<TRelations>(
+			'async',
+			this.dialect,
+			session,
+			this.relations,
+		);
+
+		const clientTx = this.client.transaction(async () => await transaction(tx));
+
+		const result = await clientTx();
+		return result;
+	}
+}
+
+export class TursoDatabaseServerlessTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', TursoDatabaseServerlessRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseServerlessTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: TursoDatabaseServerlessTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex}`;
+
+		const tx = new TursoDatabaseServerlessTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
+
+		await this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase-sync/driver.ts b/drizzle-orm/src/tursodatabase-sync/driver.ts
new file mode 100644
index 0000000000..fde2c4d854
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-sync/driver.ts
@@ -0,0 +1,107 @@
+import { Database, type DatabaseOpts } from '@tursodatabase/sync';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { TursoDatabaseSyncSession } from './session.ts';
+
+export type TursoDatabaseSyncRunResult = Awaited<ReturnType<Database['run']>>;
+
+export class TursoDatabaseSyncDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', TursoDatabaseSyncRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseSyncDatabase';
+
+	/** @internal */
+	declare readonly session: TursoDatabaseSyncSession<TRelations>;
+}
+
+function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: Database,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): TursoDatabaseSyncDatabase<TRelations> & {
+	$client: Database;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	const relations = config.relations ?? {} as TRelations;
+	const session = new TursoDatabaseSyncSession(
+		client,
+		dialect,
+		relations,
+		{ logger, cache: config.cache },
+	);
+	const db = new TursoDatabaseSyncDatabase(
+		'async',
+		dialect,
+		session,
+		relations,
+	) as TursoDatabaseSyncDatabase<TRelations>;
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+	return db as any;
+}
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | DatabaseOpts;
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): TursoDatabaseSyncDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new Database({
+			path: params[0],
+		});
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...drizzleConfig } = params[0] as
+		& { connection?: string | DatabaseOpts; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, drizzleConfig) as any;
+
+	const instance = typeof connection === 'string'
+		? new Database({ path: connection })
+		: new Database(connection!);
+
+	return construct(instance, drizzleConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): TursoDatabaseSyncDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase-sync/index.ts b/drizzle-orm/src/tursodatabase-sync/index.ts
new file mode 100644
index 0000000000..b1b6a52e71
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-sync/index.ts
@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/tursodatabase-sync/migrator.ts b/drizzle-orm/src/tursodatabase-sync/migrator.ts
new file mode 100644
index 0000000000..854d3c847b
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-sync/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
+import type { TursoDatabaseSyncDatabase } from './driver.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: TursoDatabaseSyncDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return migrateAsync(migrations, db, config);
+}
diff --git a/drizzle-orm/src/tursodatabase-sync/session.ts b/drizzle-orm/src/tursodatabase-sync/session.ts
new file mode 100644
index 0000000000..17fb48e64b
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase-sync/session.ts
@@ -0,0 +1,169 @@
+import type { Database } from '@tursodatabase/sync';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { TursoDatabaseSyncRunResult } from './driver.ts';
+
+export interface TursoDatabaseSyncSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class TursoDatabaseSyncSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', TursoDatabaseSyncRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseSyncSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		private client: Database,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: TursoDatabaseSyncSessionOptions,
+	) {
+		super(dialect, 'async');
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<T & { run: TursoDatabaseSyncRunResult }> {
+		// Incomplete types in driver
+		let stmt: any;
+		const executors: SQLiteQueryExecutors<'async'> = prepare
+			? {
+				all: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').all(params);
+				},
+				get: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').get(params);
+				},
+				run: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.run(params);
+				},
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(params);
+				},
+			}
+			: {
+				all: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').all(params);
+					}
+
+					return this.client.all(query.sql, ...params);
+				},
+				get: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').get(params);
+					}
+
+					return this.client.get(query.sql, ...params);
+				},
+				run: (params) => stmt ? stmt.run(params) : this.client.run(query.sql, ...params),
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(params);
+				},
+			};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (db: TursoDatabaseSyncTransaction<TRelations>) => Promise<T>,
+		_config?: SQLiteTransactionConfig,
+	): Promise<T> {
+		const session = new TursoDatabaseSyncSession<TRelations>(
+			this.client,
+			this.dialect,
+			this.relations,
+			this.options,
+		);
+		const tx = new TursoDatabaseSyncTransaction<TRelations>(
+			'async',
+			this.dialect,
+			session,
+			this.relations,
+		);
+
+		const clientTx = this.client.transaction(async () => await transaction(tx));
+
+		const result = await clientTx();
+		return result;
+	}
+}
+
+export class TursoDatabaseSyncTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', TursoDatabaseSyncRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseSyncTransaction';
+
+	override async transaction<T>(
+		transaction: (tx: TursoDatabaseSyncTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex}`;
+
+		const tx = new TursoDatabaseSyncTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
+
+		await this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase/database.ts b/drizzle-orm/src/tursodatabase/database.ts
new file mode 100644
index 0000000000..7306407e61
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/database.ts
@@ -0,0 +1,57 @@
+import { Database } from '@tursodatabase/database';
+import type { DatabaseOpts } from '@tursodatabase/database-common';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { construct, type TursoDatabaseDatabase } from './driver-core.ts';
+
+export type DatabaseOptions = DatabaseOpts & {
+	path: string;
+};
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | DatabaseOptions;
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): TursoDatabaseDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new Database(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: DatabaseOptions | string; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
+
+	const instance = typeof connection === 'string'
+		? new Database(connection)
+		: new Database(connection!.path, connection);
+
+	return construct(instance, DrizzleSQLiteConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): TursoDatabaseDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase/driver-core.ts b/drizzle-orm/src/tursodatabase/driver-core.ts
new file mode 100644
index 0000000000..170ad9dfcc
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/driver-core.ts
@@ -0,0 +1,47 @@
+import type { DatabasePromise, StatementPromise } from '@tursodatabase/database-common';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+import { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { TursoDatabaseSession } from './session.ts';
+
+export type TursoDatabaseRunResult = Awaited<ReturnType<StatementPromise['run']>>;
+
+export class TursoDatabaseDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends SQLiteAsyncDatabase<'async', TursoDatabaseRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseDatabase';
+
+	/** @internal */
+	declare readonly session: TursoDatabaseSession<TRelations>;
+}
+
+/** @internal */
+export function construct<TRelations extends AnyRelations = EmptyRelations>(
+	client: DatabasePromise,
+	config: DrizzleSQLiteConfig<TRelations> = {},
+): TursoDatabaseDatabase<TRelations> & {
+	$client: DatabasePromise;
+} {
+	const dialect = new SQLiteDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+	});
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+	const relations = config.relations ?? {} as TRelations;
+	const session = new TursoDatabaseSession(client, dialect, relations, { logger, cache: config.cache });
+	const db = new TursoDatabaseDatabase('async', dialect, session, relations);
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+	return db as any;
+}
diff --git a/drizzle-orm/src/tursodatabase/index.ts b/drizzle-orm/src/tursodatabase/index.ts
new file mode 100644
index 0000000000..f89ca5995b
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/index.ts
@@ -0,0 +1,2 @@
+export * from './driver-core.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/tursodatabase/migrator.ts b/drizzle-orm/src/tursodatabase/migrator.ts
new file mode 100644
index 0000000000..cebfa925de
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/migrator.ts
@@ -0,0 +1,13 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
+import type { TursoDatabaseDatabase } from './driver-core.ts';
+
+export async function migrate<TRelations extends AnyRelations>(
+	db: TursoDatabaseDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return migrateAsync(migrations, db, config);
+}
diff --git a/drizzle-orm/src/tursodatabase/session.ts b/drizzle-orm/src/tursodatabase/session.ts
new file mode 100644
index 0000000000..8434005e4f
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/session.ts
@@ -0,0 +1,170 @@
+import type { DatabasePromise, StatementPromise } from '@tursodatabase/database-common';
+import { type Cache, NoopCache } from '~/cache/core/index.ts';
+import type { WithCacheConfig } from '~/cache/core/types.ts';
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import {
+	SQLiteAsyncPreparedQuery,
+	type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteAsyncSession,
+	SQLiteAsyncTransaction,
+	type SQLiteQueryExecutors,
+} from '~/sqlite-core/async/session.ts';
+import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type { TursoDatabaseRunResult } from './driver-core';
+
+export interface TursoDatabaseSessionOptions {
+	logger?: Logger;
+	cache?: Cache;
+}
+
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+
+export class TursoDatabaseSession<TRelations extends AnyRelations>
+	extends SQLiteAsyncSession<'async', TursoDatabaseRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseSession';
+
+	private logger: Logger;
+	private cache: Cache;
+
+	constructor(
+		readonly client: DatabasePromise,
+		dialect: SQLiteDialect,
+		private relations: TRelations,
+		private options: TursoDatabaseSessionOptions,
+	) {
+		super(dialect, 'async');
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+
+	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
+		query: Query,
+		mode: 'arrays' | 'objects' | 'raw',
+		prepare: boolean,
+		executeMethod?: SQLiteExecuteMethod,
+		mapper?: (rows: any[]) => any,
+		queryMetadata?: {
+			type: 'select' | 'update' | 'delete' | 'insert';
+			tables: string[];
+		},
+		cacheConfig?: WithCacheConfig,
+	): SQLiteAsyncPreparedQuery<T & { run: TursoDatabaseRunResult }> {
+		let stmt: StatementPromise;
+		const executors: SQLiteQueryExecutors<'async'> = prepare
+			? {
+				all: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').all(...params);
+				},
+				get: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(mode === 'arrays').get(...params);
+				},
+				run: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.run(...params);
+				},
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(...params);
+				},
+			}
+			: {
+				all: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').all(...params);
+					}
+
+					return this.client.all(query.sql, ...params);
+				},
+				get: async (params) => {
+					if (stmt || mode === 'arrays') {
+						stmt ??= await this.client.prepare(query.sql);
+						return stmt.raw(mode === 'arrays').get(...params);
+					}
+
+					return this.client.get(query.sql, ...params);
+				},
+				run: (params) => stmt ? stmt.run(...params) : this.client.run(query.sql, ...params),
+				values: async (params) => {
+					stmt ??= await this.client.prepare(query.sql);
+					return stmt.raw(true).all(...params);
+				},
+			};
+
+		return new SQLiteAsyncPreparedQuery(
+			'async',
+			executeMethod,
+			executors,
+			query,
+			mapper,
+			mode,
+			this.logger,
+			this.cache,
+			queryMetadata,
+			cacheConfig,
+		);
+	}
+
+	override async transaction<T>(
+		transaction: (db: TursoDatabaseTransaction<TRelations>) => Promise<T>,
+		_config?: SQLiteTransactionConfig,
+	): Promise<T> {
+		const session = new TursoDatabaseSession<TRelations>(
+			this.client,
+			this.dialect,
+			this.relations,
+			this.options,
+		);
+		const tx = new TursoDatabaseTransaction<TRelations>(
+			'async',
+			this.dialect,
+			session,
+			this.relations,
+		);
+
+		const clientTx = this.client.transaction(async () => await transaction(tx));
+
+		const result = await clientTx();
+		return result;
+	}
+}
+
+export class TursoDatabaseTransaction<TRelations extends AnyRelations>
+	extends SQLiteAsyncTransaction<'async', TursoDatabaseRunResult, TRelations>
+{
+	static override readonly [entityKind]: string = 'TursoDatabaseTransaction';
+
+	declare readonly session: TursoDatabaseSession<TRelations>;
+
+	override async transaction<T>(
+		transaction: (tx: TursoDatabaseTransaction<TRelations>) => Promise<T>,
+	): Promise<T> {
+		const savepointName = `sp${this.nestedIndex}`;
+
+		const tx = new TursoDatabaseTransaction(
+			'async',
+			this.dialect,
+			this.session,
+			this._.relations,
+			this.nestedIndex + 1,
+		);
+
+		await this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+}
diff --git a/drizzle-orm/src/tursodatabase/wasm-migrator.ts b/drizzle-orm/src/tursodatabase/wasm-migrator.ts
new file mode 100644
index 0000000000..d8291db80c
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/wasm-migrator.ts
@@ -0,0 +1,54 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import { formatToMillis } from '~/migrator.utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { migrateAsync } from '~/sqlite-core/async/session.ts';
+import type { TursoDatabaseDatabase } from './driver-core.ts';
+
+interface MigrationConfig {
+	migrations: Record<string, string>;
+	migrationsTable?: string;
+	/** @internal */
+	init?: boolean;
+}
+
+function readMigrationFiles({ migrations }: MigrationConfig): MigrationMeta[] {
+	const migrationQueries: MigrationMeta[] = [];
+
+	const sortedMigrations = Object.keys(migrations).sort();
+
+	for (const key of sortedMigrations) {
+		const query = migrations[key];
+		if (!query) {
+			throw new Error(`Missing migration: ${key}`);
+		}
+
+		try {
+			const result = query.split('--> statement-breakpoint').map((it) => {
+				return it;
+			});
+
+			const migrationDate = formatToMillis(key.slice(0, 14));
+
+			migrationQueries.push({
+				sql: result,
+				bps: true,
+				folderMillis: migrationDate,
+				hash: '',
+				name: key,
+			});
+		} catch {
+			throw new Error(`Failed to parse migration: ${key}`);
+		}
+	}
+
+	return migrationQueries;
+}
+
+/** Filesystemless version of migrator for browser environments */
+export function migrate<TRelations extends AnyRelations>(
+	db: TursoDatabaseDatabase<TRelations>,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	return migrateAsync(migrations, db, config);
+}
diff --git a/drizzle-orm/src/tursodatabase/wasm.ts b/drizzle-orm/src/tursodatabase/wasm.ts
new file mode 100644
index 0000000000..67dfbb9869
--- /dev/null
+++ b/drizzle-orm/src/tursodatabase/wasm.ts
@@ -0,0 +1,57 @@
+import type { DatabaseOpts } from '@tursodatabase/database-common';
+import { Database } from '@tursodatabase/database-wasm';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import type { DrizzleSQLiteConfig } from '~/sqlite-core/utils.ts';
+import { construct, type TursoDatabaseDatabase } from './driver-core.ts';
+
+export type DatabaseOptions = DatabaseOpts & {
+	path: string;
+};
+
+export function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(
+	...params: [
+		string,
+	] | [
+		string,
+		DrizzleSQLiteConfig<TRelations>,
+	] | [
+		(
+			& DrizzleSQLiteConfig<TRelations>
+			& ({
+				connection: string | DatabaseOptions;
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): TursoDatabaseDatabase<TRelations> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new Database(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	const { connection, client, ...DrizzleSQLiteConfig } = params[0] as
+		& { connection?: DatabaseOptions | string; client?: TClient }
+		& DrizzleSQLiteConfig<TRelations>;
+
+	if (client) return construct(client, DrizzleSQLiteConfig) as any;
+
+	const instance = typeof connection === 'string'
+		? new Database(connection)
+		: new Database(connection!.path, connection);
+
+	return construct(instance, DrizzleSQLiteConfig) as any;
+}
+
+export namespace drizzle {
+	export function mock<TRelations extends AnyRelations = EmptyRelations>(
+		config?: DrizzleSQLiteConfig<TRelations>,
+	): TursoDatabaseDatabase<TRelations> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({} as any, config) as any;
+	}
+}
diff --git a/drizzle-orm/src/typebox-legacy/README.md b/drizzle-orm/src/typebox-legacy/README.md
new file mode 100644
index 0000000000..4b38a09760
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/README.md
@@ -0,0 +1,52 @@
+Allows you to generate [@sinclair/typebox](https://github.com/sinclairzx81/typebox) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/typebox-legacy';
+import { Type } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
+
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	role: text('role', { enum: ['admin', 'user'] }).notNull(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const insertUserSchema = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const updateUserSchema = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const selectUserSchema = createSelectSchema(users);
+
+// Overriding the fields
+const insertUserSchema = createInsertSchema(users, {
+	role: Type.String(),
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const insertUserSchema = createInsertSchema(users, {
+	id: (schema) => Type.Number({ ...schema, minimum: 0 }),
+	role: Type.String(),
+});
+
+// Usage
+
+const isUserValid: boolean = Value.Check(insertUserSchema, {
+	name: 'John Doe',
+	email: 'johndoe@test.com',
+	role: 'admin',
+});
+```
diff --git a/drizzle-orm/src/typebox-legacy/column.ts b/drizzle-orm/src/typebox-legacy/column.ts
new file mode 100644
index 0000000000..c7e7601e64
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/column.ts
@@ -0,0 +1,439 @@
+import { Kind, Type as t, TypeRegistry } from '@sinclair/typebox';
+import type { BigIntOptions, StringOptions, TSchema, Type as typebox } from '@sinclair/typebox';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS } from '../utils.ts';
+import type { BigIntStringModeSchema, BufferSchema, JsonSchema } from './column.types.ts';
+
+export const literalSchema = t.Union([t.String(), t.Number(), t.Boolean(), t.Null()]);
+export const jsonSchema: JsonSchema = t.Union([literalSchema, t.Array(t.Any()), t.Record(t.String(), t.Any())]) as any;
+TypeRegistry.Set('Buffer', (_, value) => value instanceof Buffer); // oxlint-disable-line no-instanceof-builtins drizzle-internal/no-instanceof
+export const bufferSchema: BufferSchema = { [Kind]: 'Buffer', type: 'buffer' } as any;
+
+export function mapEnumValues(values: string[]) {
+	return Object.fromEntries(values.map((value) => [value, value]));
+}
+
+export function columnToSchema(column: Column, t: typeof typebox): TSchema {
+	let schema!: TSchema;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions, t);
+	}
+
+	const { type, constraint } = extractExtendedColumnType(column);
+
+	switch (type) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'boolean': {
+			schema = t.Boolean();
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'custom': {
+			schema = t.Any();
+			break;
+		}
+		default: {
+			schema = t.Any();
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(
+	column: Column,
+	constraint: ColumnDataNumberConstraint | undefined,
+	t: typeof typebox,
+): TSchema {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	const key = integer ? 'Integer' : 'Number';
+	return t[key]({
+		minimum: min,
+		maximum: max,
+	});
+}
+
+TypeRegistry.Set('BigIntStringMode', (_, value) => {
+	if (typeof value !== 'string' || !(/^-?\d+$/.test(value))) {
+		return false;
+	}
+
+	const bigint = BigInt(value);
+	if (bigint < CONSTANTS.INT64_MIN || bigint > CONSTANTS.INT64_MAX) {
+		return false;
+	}
+
+	return true;
+});
+
+TypeRegistry.Set('UnsignedBigIntStringMode', (_, value) => {
+	if (typeof value !== 'string' || !(/^\d+$/.test(value))) {
+		return false;
+	}
+
+	const bigint = BigInt(value);
+	if (bigint < 0 || bigint > CONSTANTS.INT64_MAX) {
+		return false;
+	}
+
+	return true;
+});
+export const bigintStringModeSchema: BigIntStringModeSchema = {
+	[Kind]: 'BigIntStringMode',
+	type: 'string',
+} as any;
+
+export const unsignedBigintStringModeSchema: BigIntStringModeSchema = {
+	[Kind]: 'UnsignedBigIntStringMode',
+	type: 'string',
+} as any;
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+	t: typeof typebox,
+): TSchema {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: TSchema;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint, t);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint, t);
+			break;
+		case 'boolean':
+			baseSchema = t.Boolean();
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint, t);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint, t);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint, t);
+			break;
+		default:
+			baseSchema = t.Any();
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: TSchema = t.Array(baseSchema);
+	for (let i = 1; i < dimensions; i++) {
+		schema = t.Array(schema);
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(
+	column: Column,
+	constraint: ColumnDataArrayConstraint | undefined,
+	t: typeof typebox,
+): TSchema {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return t.Tuple([t.Number(), t.Number()]);
+		}
+		case 'line': {
+			return t.Tuple([t.Number(), t.Number(), t.Number()]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const length = column.length;
+			const sizeParam = length
+				? {
+					minItems: length,
+					maxItems: length,
+				}
+				: undefined;
+			return t.Array(t.Number(), sizeParam);
+		}
+		case 'int64vector': {
+			const length = column.length;
+			const sizeParam = length
+				? {
+					minItems: length,
+					maxItems: length,
+				}
+				: undefined;
+			return t.Array(
+				t.BigInt({
+					minimum: CONSTANTS.INT64_MIN,
+					maximum: CONSTANTS.INT64_MAX,
+				}),
+				sizeParam,
+			);
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const size = column.length;
+				const sizeParam = size
+					? {
+						minItems: size,
+						maxItems: size,
+					}
+					: undefined;
+				return t.Array(columnToSchema(baseColumn, t), sizeParam);
+			}
+			return t.Array(t.Any());
+		}
+		default: {
+			return t.Array(t.Any());
+		}
+	}
+}
+
+function objectColumnToSchema(
+	column: Column,
+	constraint: ColumnDataObjectConstraint | undefined,
+	t: typeof typebox,
+): TSchema {
+	switch (constraint) {
+		case 'buffer': {
+			return bufferSchema;
+		}
+		case 'date': {
+			return t.Date();
+		}
+		case 'geometry':
+		case 'point': {
+			return t.Object({
+				x: t.Number(),
+				y: t.Number(),
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return t.Object({
+				a: t.Number(),
+				b: t.Number(),
+				c: t.Number(),
+			});
+		}
+		default: {
+			return t.Object({});
+		}
+	}
+}
+
+function bigintColumnToSchema(
+	column: Column,
+	constraint: ColumnDataBigIntConstraint | undefined,
+	t: typeof typebox,
+): TSchema {
+	let min!: bigint | undefined;
+	let max!: bigint | undefined;
+
+	switch (constraint) {
+		case 'int64': {
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		}
+		case 'uint64': {
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+		}
+	}
+
+	const options: Partial<BigIntOptions> = {};
+
+	if (min !== undefined) {
+		options.minimum = min;
+	}
+	if (max !== undefined) {
+		options.maximum = max;
+	}
+
+	return t.BigInt(Object.keys(options).length > 0 ? options : undefined);
+}
+
+function stringColumnToSchema(
+	column: Column,
+	constraint: ColumnDataStringConstraint | undefined,
+	t: typeof typebox,
+): TSchema {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex: RegExp | undefined;
+
+	if (constraint === 'binary') {
+		regex = /^[01]*$/;
+	}
+	if (constraint === 'uuid') {
+		return t.String({
+			format: 'uuid',
+		});
+	}
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return t.Enum(mapEnumValues(enumValues));
+	}
+	if (constraint === 'int64') {
+		return bigintStringModeSchema;
+	}
+	if (constraint === 'uint64') {
+		return unsignedBigintStringModeSchema;
+	}
+
+	const options: Partial<StringOptions> = {};
+
+	if (length !== undefined && isLengthExact) {
+		options.minLength = length;
+		options.maxLength = length;
+	} else if (length !== undefined) {
+		options.maxLength = length;
+	}
+
+	return regex
+		? t.RegExp(regex, Object.keys(options).length > 0 ? options : undefined)
+		: t.String(Object.keys(options).length > 0 ? options : undefined);
+}
diff --git a/drizzle-orm/src/typebox-legacy/column.types.ts b/drizzle-orm/src/typebox-legacy/column.types.ts
new file mode 100644
index 0000000000..62241057a2
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/column.types.ts
@@ -0,0 +1,110 @@
+import type * as t from '@sinclair/typebox';
+import type { ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Assume } from '~/utils.ts';
+import type { Json } from '../utils.ts';
+import type { bigintStringModeSchema, unsignedBigintStringModeSchema } from './column.ts';
+
+export interface GenericSchema<T> extends t.TSchema { // oxlint-disable-line import/namespace false-positive
+	static: T;
+}
+
+export interface JsonSchema extends t.TSchema {
+	[t.Kind]: 'Union';
+	static: Json;
+	anyOf: Json;
+}
+export interface BufferSchema extends t.TSchema {
+	[t.Kind]: 'Buffer';
+	static: Buffer;
+	type: 'buffer';
+}
+
+export interface BigIntStringModeSchema extends t.TSchema {
+	[t.Kind]: 'BigIntStringMode';
+	static: string;
+	type: 'string';
+}
+
+type GetArrayDepth<T, Depth extends number = 0> = Depth extends 5 ? 5
+	: T extends readonly (infer U)[] ? GetArrayDepth<U, [1, 2, 3, 4, 5][Depth]>
+	: Depth;
+
+type WrapInTArray<TSchema extends t.TSchema, TDepth extends number> = TDepth extends 0 ? TSchema
+	: TDepth extends 1 ? t.TArray<TSchema>
+	: TDepth extends 2 ? t.TArray<t.TArray<TSchema>>
+	: TDepth extends 3 ? t.TArray<t.TArray<t.TArray<TSchema>>>
+	: TDepth extends 4 ? t.TArray<t.TArray<t.TArray<t.TArray<TSchema>>>>
+	: TDepth extends 5 ? t.TArray<t.TArray<t.TArray<t.TArray<t.TArray<TSchema>>>>>
+	: t.TArray<t.TAny>;
+
+type IsPgArrayColumn<TColumn extends Column, TType extends ColumnTypeData> = TType['type'] extends 'array' ? false // Already handled as explicit array type
+	: GetArrayDepth<TColumn['_']['data']> extends 0 ? false
+	: true;
+
+export type GetTypeboxType<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = IsPgArrayColumn<TColumn, TType> extends true
+	? WrapInTArray<GetBaseTypeboxType<TColumn, TType>, GetArrayDepth<TColumn['_']['data']>>
+	: GetBaseTypeboxType<TColumn, TType>;
+
+type GetBaseTypeboxType<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = TType['type'] extends 'array' ? TType['constraint'] extends 'basecolumn' ? t.TArray<
+			GetTypeboxType<Assume<TColumn['_'], { baseColumn: Column }>['baseColumn']>
+		>
+	: TType['constraint'] extends 'geometry' | 'point' ? t.TTuple<[t.TNumber, t.TNumber]>
+	: TType['constraint'] extends 'line' ? t.TTuple<[t.TNumber, t.TNumber, t.TNumber]>
+	: TType['constraint'] extends 'vector' | 'halfvector' ? t.TArray<t.TNumber>
+	: TType['constraint'] extends 'int64vector' ? t.TArray<t.TBigInt>
+	: t.TArray<t.TAny>
+	: TType['type'] extends 'object'
+		? TType['constraint'] extends 'geometry' | 'point' ? t.TObject<{ x: t.TNumber; y: t.TNumber }>
+		: TType['constraint'] extends 'line' ? t.TObject<{ a: t.TNumber; b: t.TNumber; c: t.TNumber }>
+		: TType['constraint'] extends 'date' ? t.TDate
+		: TType['constraint'] extends 'buffer' ? BufferSchema
+		: TType['constraint'] extends 'json' ? JsonSchema
+		: t.TObject
+	: TType['type'] extends 'custom' ? t.TAny
+	: TType['type'] extends 'number'
+		? TType['constraint'] extends
+			'int8' | 'int16' | 'int24' | 'int32' | 'int53' | 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint53' | 'year'
+			? t.TInteger
+		: t.TNumber
+	: TType['type'] extends 'bigint' ? t.TBigInt
+	: TType['type'] extends 'boolean' ? t.TBoolean
+	: TType['type'] extends 'string' ? TType['constraint'] extends 'binary' | 'varbinary' ? t.TRegExp
+		: TType['constraint'] extends 'int64' ? typeof bigintStringModeSchema
+		: TType['constraint'] extends 'uint64' ? typeof unsignedBigintStringModeSchema
+		: TType['constraint'] extends 'enum' ? t.TEnum<{ [K in Assume<TColumn['_']['enumValues'], string[]>[number]]: K }>
+		: t.TString
+	: t.TAny;
+
+type HandleSelectColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: t.Union<[TSchema, t.TNull]>;
+
+type HandleInsertColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? t.TOptional<TSchema>
+	: TSchema
+	: t.TOptional<t.Union<[TSchema, t.TNull]>>;
+
+type HandleUpdateColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? t.TOptional<TSchema>
+	: t.TOptional<t.Union<[TSchema, t.TNull]>>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+> = TType extends 'select' ? HandleSelectColumn<GetTypeboxType<TColumn>, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<GetTypeboxType<TColumn>, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<GetTypeboxType<TColumn>, TColumn>
+	: GetTypeboxType<TColumn>;
diff --git a/drizzle-orm/src/typebox-legacy/index.ts b/drizzle-orm/src/typebox-legacy/index.ts
new file mode 100644
index 0000000000..5d00169d6e
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/index.ts
@@ -0,0 +1,11 @@
+export {
+	bigintStringModeSchema,
+	bufferSchema,
+	jsonSchema,
+	literalSchema,
+	unsignedBigintStringModeSchema,
+} from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/typebox-legacy/schema.ts b/drizzle-orm/src/typebox-legacy/schema.ts
new file mode 100644
index 0000000000..7e4853df55
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/schema.ts
@@ -0,0 +1,147 @@
+import { Type as t } from '@sinclair/typebox';
+import type { TSchema } from '@sinclair/typebox';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema, mapEnumValues } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type {
+	CreateInsertSchema,
+	CreateSchemaFactoryOptions,
+	CreateSelectSchema,
+	CreateUpdateSchema,
+} from './schema.types.ts';
+
+export function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+	factory?: CreateSchemaFactoryOptions,
+): TSchema {
+	const columnSchemas: Record<string, TSchema> = {};
+
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
+			continue;
+		}
+
+		const refinement = refinements[key];
+		if (refinement !== undefined && typeof refinement !== 'function') {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column, factory?.typeboxInstance ?? t) : t.Any();
+		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = t.Union([columnSchemas[key]!, t.Null()]);
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = t.Optional(columnSchemas[key]!);
+			}
+		}
+	}
+
+	return t.Object(columnSchemas) as any;
+}
+
+export function handleEnum(enum_: PgEnum<any>, factory?: CreateSchemaFactoryOptions) {
+	const typebox: typeof t = factory?.typeboxInstance ?? t;
+	return typebox.Enum(mapEnumValues(enum_.enumValues));
+}
+
+const selectConditions: Conditions = {
+	never: () => false,
+	optional: () => false,
+	nullable: (column) => !column.notNull,
+};
+
+const insertConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+	nullable: (column) => !column.notNull,
+};
+
+const updateConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: () => true,
+	nullable: (column) => !column.notNull,
+};
+
+export const createSelectSchema: CreateSelectSchema = (
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return handleEnum(entity);
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, selectConditions) as any;
+};
+
+export const createInsertSchema: CreateInsertSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, insertConditions) as any;
+};
+
+export const createUpdateSchema: CreateUpdateSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, updateConditions) as any;
+};
+
+export function createSchemaFactory(options?: CreateSchemaFactoryOptions) {
+	const createSelectSchema: CreateSelectSchema = (
+		entity: Table | View | PgEnum<[string, ...string[]]>,
+		refine?: Record<string, any>,
+	) => {
+		if (isWithEnum(entity)) {
+			return handleEnum(entity, options);
+		}
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, selectConditions, options) as any;
+	};
+
+	const createInsertSchema: CreateInsertSchema = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, insertConditions, options) as any;
+	};
+
+	const createUpdateSchema: CreateUpdateSchema = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, updateConditions, options) as any;
+	};
+
+	return { createSelectSchema, createInsertSchema, createUpdateSchema };
+}
diff --git a/drizzle-orm/src/typebox-legacy/schema.types.internal.ts b/drizzle-orm/src/typebox-legacy/schema.types.internal.ts
new file mode 100644
index 0000000000..fe1ed9c2db
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/schema.types.internal.ts
@@ -0,0 +1,76 @@
+import type * as t from '@sinclair/typebox';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { GetTypeboxType, HandleColumn } from './column.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type BuildRefineField<T> = T extends t.TSchema ? ((schema: T) => t.TSchema) | t.TSchema : never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+> = {
+	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
+		TColumns[K] extends Column ? BuildRefineField<GetTypeboxType<TColumns[K]>>
+			: BuildRefine<GetSelection<TColumns[K]>>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (schema: any) => t.TSchema ? (TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
+		: t.TUnion<[ReturnType<TRefinement>, t.TNull]>) extends infer TSchema
+		? TType extends 'update' ? t.TOptional<Assume<TSchema, t.TSchema>> : TSchema
+	: t.TSchema
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object ? TRefinements[TKey] extends t.TSchema | ((schema: any) => any) ? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+> = t.TObject<
+	Simplify<
+		{
+			[
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column
+				? IsRefinementDefined<TRefinements, K> extends true
+					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, t.TSchema>
+				: HandleColumn<TType, TColumn>
+				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TObject>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
+					>
+				: t.TAny;
+		}
+	>
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare ? TRefinement[K] extends t.TSchema ? TRefinement[K]
+		: TRefinement[K] extends Record<string, t.TSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/typebox-legacy/schema.types.ts b/drizzle-orm/src/typebox-legacy/schema.types.ts
new file mode 100644
index 0000000000..7941ae4f93
--- /dev/null
+++ b/drizzle-orm/src/typebox-legacy/schema.types.ts
@@ -0,0 +1,57 @@
+import type * as t from '@sinclair/typebox';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { EnumValuesToEnum } from '../utils.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns']>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields']>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(
+		enum_: TEnum,
+	): t.TEnum<EnumValuesToEnum<TEnum['enumValues']>>;
+}
+
+export interface CreateInsertSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateUpdateSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateSchemaFactoryOptions {
+	typeboxInstance?: any;
+}
diff --git a/drizzle-orm/src/typebox/README.md b/drizzle-orm/src/typebox/README.md
new file mode 100644
index 0000000000..037b78fcba
--- /dev/null
+++ b/drizzle-orm/src/typebox/README.md
@@ -0,0 +1,52 @@
+Allows you to generate [typebox](https://sinclairzx81.github.io/typebox/#/) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/typebox';
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	role: text('role', { enum: ['admin', 'user'] }).notNull(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const insertUserSchema = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const updateUserSchema = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const selectUserSchema = createSelectSchema(users);
+
+// Overriding the fields
+const insertUserSchema = createInsertSchema(users, {
+	role: Type.String(),
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const insertUserSchema = createInsertSchema(users, {
+	id: (schema) => Type.Number({ ...schema, minimum: 0 }),
+	role: Type.String(),
+});
+
+// Usage
+
+const isUserValid: boolean = Value.Check(insertUserSchema, {
+	name: 'John Doe',
+	email: 'johndoe@test.com',
+	role: 'admin',
+});
+```
diff --git a/drizzle-orm/src/typebox/column.ts b/drizzle-orm/src/typebox/column.ts
new file mode 100644
index 0000000000..2c3b826a97
--- /dev/null
+++ b/drizzle-orm/src/typebox/column.ts
@@ -0,0 +1,487 @@
+import Type from 'typebox';
+import type { TNumberOptions, TSchema, TStringOptions } from 'typebox';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS } from '../utils.ts';
+import type { JsonSchema } from './column.types.ts';
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TBuffer extends Type.Base<Buffer> {
+	public override Check(value: unknown): value is Buffer {
+		// oxlint-disable-next-line drizzle-internal/no-instanceof
+		return value instanceof Buffer;
+	}
+
+	public override Errors(value: unknown): object[] {
+		return !this.Check(value) ? [{ message: 'not a Buffer' }] : [];
+	}
+
+	public override Clone(): TBuffer {
+		return new TBuffer();
+	}
+}
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TDate extends Type.Base<Date> {
+	public override Check(value: unknown): value is Date {
+		// oxlint-disable-next-line drizzle-internal/no-instanceof
+		return value instanceof Date;
+	}
+
+	public override Errors(value: unknown): object[] {
+		return !this.Check(value) ? [{ message: 'not a Date' }] : [];
+	}
+
+	public override Clone(): TDate {
+		return new TDate();
+	}
+}
+
+export const literalSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]);
+export const jsonSchema: JsonSchema = Type.Union([
+	literalSchema,
+	Type.Array(Type.Any()),
+	Type.Record(Type.String(), Type.Any()),
+]);
+
+export function mapEnumValues(values: string[]) {
+	return Object.fromEntries(values.map((value) => [value, value]));
+}
+
+export function columnToSchema(column: Column, t: typeof Type): TSchema {
+	let schema!: TSchema;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions, t);
+	}
+
+	const { type, constraint } = extractExtendedColumnType(column);
+
+	switch (type) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'boolean': {
+			schema = t.Boolean();
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint, t);
+			break;
+		}
+		case 'custom': {
+			schema = t.Any();
+			break;
+		}
+		default: {
+			schema = t.Any();
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(
+	column: Column,
+	constraint: ColumnDataNumberConstraint | undefined,
+	t: typeof Type,
+): TSchema {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	const key = integer ? 'Integer' : 'Number';
+	return t[key]({
+		minimum: min,
+		maximum: max,
+	});
+}
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TBigIntString extends Type.Base<string> {
+	override Check(value: unknown): value is string {
+		if (typeof value !== 'string' || !(/^-?\d+$/.test(value))) {
+			return false;
+		}
+
+		const bigint = BigInt(value);
+		if (bigint < CONSTANTS.INT64_MIN || bigint > CONSTANTS.INT64_MAX) {
+			return false;
+		}
+
+		return true;
+	}
+
+	public override Errors(value: unknown): object[] {
+		return !this.Check(value) ? [{ message: 'not a bigint string' }] : [];
+	}
+
+	override Clone() {
+		return new TBigIntString();
+	}
+}
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TUnsignedBigIntString extends Type.Base<string> {
+	override Check(value: unknown): value is string {
+		if (typeof value !== 'string' || !(/^\d+$/.test(value))) {
+			return false;
+		}
+
+		const bigint = BigInt(value);
+		if (bigint < 0 || bigint > CONSTANTS.INT64_MAX) {
+			return false;
+		}
+
+		return true;
+	}
+
+	public override Errors(value: unknown): object[] {
+		return !this.Check(value) ? [{ message: 'not an unsigned bigint string' }] : [];
+	}
+
+	override Clone() {
+		return new TUnsignedBigIntString();
+	}
+}
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+	t: typeof Type,
+): TSchema {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: TSchema;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint, t);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint, t);
+			break;
+		case 'boolean':
+			baseSchema = t.Boolean();
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint, t);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint, t);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint, t);
+			break;
+		default:
+			baseSchema = t.Any();
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: TSchema = t.Array(baseSchema);
+	for (let i = 1; i < dimensions; i++) {
+		schema = t.Array(schema);
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(
+	column: Column,
+	constraint: ColumnDataArrayConstraint | undefined,
+	t: typeof Type,
+): TSchema {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return t.Tuple([t.Number(), t.Number()]);
+		}
+		case 'line': {
+			return t.Tuple([t.Number(), t.Number(), t.Number()]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const length = column.length;
+			const sizeParam = length
+				? {
+					minItems: length,
+					maxItems: length,
+				}
+				: undefined;
+			return t.Array(t.Number(), sizeParam);
+		}
+		case 'int64vector': {
+			const length = column.length;
+			const sizeParam = length
+				? {
+					minItems: length,
+					maxItems: length,
+				}
+				: undefined;
+			return t.Array(
+				t.BigInt({
+					minimum: CONSTANTS.INT64_MIN,
+					maximum: CONSTANTS.INT64_MAX,
+				}),
+				sizeParam,
+			);
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const size = column.length;
+				const sizeParam = size
+					? {
+						minItems: size,
+						maxItems: size,
+					}
+					: undefined;
+				return t.Array(columnToSchema(baseColumn, t), sizeParam);
+			}
+			return t.Array(t.Any());
+		}
+		default: {
+			return t.Array(t.Any());
+		}
+	}
+}
+
+function objectColumnToSchema(
+	column: Column,
+	constraint: ColumnDataObjectConstraint | undefined,
+	t: typeof Type,
+): TSchema {
+	switch (constraint) {
+		case 'buffer': {
+			return new TBuffer();
+		}
+		case 'date': {
+			return new TDate();
+		}
+		case 'geometry':
+		case 'point': {
+			return t.Object({
+				x: t.Number(),
+				y: t.Number(),
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return t.Object({
+				a: t.Number(),
+				b: t.Number(),
+				c: t.Number(),
+			});
+		}
+		default: {
+			return t.Object({});
+		}
+	}
+}
+
+function bigintColumnToSchema(
+	column: Column,
+	constraint: ColumnDataBigIntConstraint | undefined,
+	t: typeof Type,
+): TSchema {
+	let min!: bigint | undefined;
+	let max!: bigint | undefined;
+
+	switch (constraint) {
+		case 'int64': {
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		}
+		case 'uint64': {
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+		}
+	}
+
+	const options: Partial<TNumberOptions> = {};
+
+	if (min !== undefined) {
+		options.minimum = min;
+	}
+	if (max !== undefined) {
+		options.maximum = max;
+	}
+
+	return t.BigInt(Object.keys(options).length > 0 ? options : undefined);
+}
+
+function stringColumnToSchema(
+	column: Column,
+	constraint: ColumnDataStringConstraint | undefined,
+	t: typeof Type,
+): TSchema {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex: RegExp | undefined;
+
+	if (constraint === 'binary') {
+		regex = /^[01]*$/;
+	}
+	if (constraint === 'uuid') {
+		return t.String({
+			format: 'uuid',
+		});
+	}
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return t.Enum(mapEnumValues(enumValues));
+	}
+	if (constraint === 'int64') {
+		return new TBigIntString();
+	}
+	if (constraint === 'uint64') {
+		return new TUnsignedBigIntString();
+	}
+
+	const options: Partial<TStringOptions> = {};
+
+	if (length !== undefined && isLengthExact) {
+		options.minLength = length;
+		options.maxLength = length;
+	} else if (length !== undefined) {
+		options.maxLength = length;
+	}
+	if (regex) {
+		options.pattern = regex;
+	}
+
+	return t.String(Object.keys(options).length > 0 ? options : undefined);
+}
diff --git a/drizzle-orm/src/typebox/column.types.ts b/drizzle-orm/src/typebox/column.types.ts
new file mode 100644
index 0000000000..1a8858d662
--- /dev/null
+++ b/drizzle-orm/src/typebox/column.types.ts
@@ -0,0 +1,97 @@
+import type * as t from 'typebox';
+import type { ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Assume } from '~/utils.ts';
+import type { jsonSchema, literalSchema, TBigIntString, TBuffer, TDate, TUnsignedBigIntString } from './column.ts';
+
+export interface GenericSchema<T> extends t.TSchema {
+	static: T;
+}
+
+export interface JsonSchema extends t.TSchema {
+	'~kind': 'Union';
+	anyOf: [typeof literalSchema, t.TArray<t.TAny>, t.TRecord<'^.*$', t.TAny>];
+}
+
+type GetArrayDepth<T, Depth extends number = 0> = Depth extends 5 ? 5
+	: T extends readonly (infer U)[] ? GetArrayDepth<U, [1, 2, 3, 4, 5][Depth]>
+	: Depth;
+
+type WrapInTArray<TSchema extends t.TSchema, TDepth extends number> = TDepth extends 0 ? TSchema
+	: TDepth extends 1 ? t.TArray<TSchema>
+	: TDepth extends 2 ? t.TArray<t.TArray<TSchema>>
+	: TDepth extends 3 ? t.TArray<t.TArray<t.TArray<TSchema>>>
+	: TDepth extends 4 ? t.TArray<t.TArray<t.TArray<t.TArray<TSchema>>>>
+	: TDepth extends 5 ? t.TArray<t.TArray<t.TArray<t.TArray<t.TArray<TSchema>>>>>
+	: t.TArray<t.TAny>;
+
+type IsPgArrayColumn<TColumn extends Column, TType extends ColumnTypeData> = TType['type'] extends 'array' ? false // Already handled as explicit array type
+	: GetArrayDepth<TColumn['_']['data']> extends 0 ? false
+	: true;
+
+export type GetTypeboxType<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = IsPgArrayColumn<TColumn, TType> extends true
+	? WrapInTArray<GetBaseTypeboxType<TColumn, TType>, GetArrayDepth<TColumn['_']['data']>>
+	: GetBaseTypeboxType<TColumn, TType>;
+
+type GetBaseTypeboxType<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = TType['type'] extends 'array' ? TType['constraint'] extends 'basecolumn' ? t.TArray<
+			GetTypeboxType<Assume<TColumn['_'], { baseColumn: Column }>['baseColumn']>
+		>
+	: TType['constraint'] extends 'geometry' | 'point' ? t.TTuple<[t.TNumber, t.TNumber]>
+	: TType['constraint'] extends 'line' ? t.TTuple<[t.TNumber, t.TNumber, t.TNumber]>
+	: TType['constraint'] extends 'vector' | 'halfvector' ? t.TArray<t.TNumber>
+	: TType['constraint'] extends 'int64vector' ? t.TArray<t.TBigInt>
+	: t.TArray<t.TAny>
+	: TType['type'] extends 'object'
+		? TType['constraint'] extends 'geometry' | 'point' ? t.TObject<{ x: t.TNumber; y: t.TNumber }>
+		: TType['constraint'] extends 'line' ? t.TObject<{ a: t.TNumber; b: t.TNumber; c: t.TNumber }>
+		: TType['constraint'] extends 'date' ? TDate
+		: TType['constraint'] extends 'buffer' ? TBuffer
+		: TType['constraint'] extends 'json' ? typeof jsonSchema
+		: t.TObject
+	: TType['type'] extends 'custom' ? t.TAny
+	: TType['type'] extends 'number'
+		? TType['constraint'] extends
+			'int8' | 'int16' | 'int24' | 'int32' | 'int53' | 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint53' | 'year'
+			? t.TInteger
+		: t.TNumber
+	: TType['type'] extends 'bigint' ? t.TBigInt
+	: TType['type'] extends 'boolean' ? t.TBoolean
+	: TType['type'] extends 'string' ? TType['constraint'] extends 'binary' | 'varbinary' ? t.TString
+		: TType['constraint'] extends 'int64' ? TBigIntString
+		: TType['constraint'] extends 'uint64' ? TUnsignedBigIntString
+		: TType['constraint'] extends 'enum' ? t.TEnum<Assume<TColumn['_']['enumValues'], string[]>>
+		: t.TString
+	: t.TAny;
+
+type HandleSelectColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: t.TUnion<[TSchema, t.TNull]>;
+
+type HandleInsertColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? t.TOptional<TSchema>
+	: TSchema
+	: t.TOptional<t.TUnion<[TSchema, t.TNull]>>;
+
+type HandleUpdateColumn<
+	TSchema extends t.TSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? t.TOptional<TSchema>
+	: t.TOptional<t.TUnion<[TSchema, t.TNull]>>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+> = TType extends 'select' ? HandleSelectColumn<GetTypeboxType<TColumn>, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<GetTypeboxType<TColumn>, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<GetTypeboxType<TColumn>, TColumn>
+	: GetTypeboxType<TColumn>;
diff --git a/drizzle-orm/src/typebox/index.ts b/drizzle-orm/src/typebox/index.ts
new file mode 100644
index 0000000000..c222c51cc3
--- /dev/null
+++ b/drizzle-orm/src/typebox/index.ts
@@ -0,0 +1,5 @@
+export { jsonSchema, literalSchema, TBigIntString, TBuffer, TDate, TUnsignedBigIntString } from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/typebox/schema.ts b/drizzle-orm/src/typebox/schema.ts
new file mode 100644
index 0000000000..9a414bb15d
--- /dev/null
+++ b/drizzle-orm/src/typebox/schema.ts
@@ -0,0 +1,147 @@
+import { Type as t } from 'typebox';
+import type { TSchema } from 'typebox';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema, mapEnumValues } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type {
+	CreateInsertSchema,
+	CreateSchemaFactoryOptions,
+	CreateSelectSchema,
+	CreateUpdateSchema,
+} from './schema.types.ts';
+
+export function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+	factory?: CreateSchemaFactoryOptions,
+): TSchema {
+	const columnSchemas: Record<string, TSchema> = {};
+
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
+			continue;
+		}
+
+		const refinement = refinements[key];
+		if (refinement !== undefined && typeof refinement !== 'function') {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column, factory?.typeboxInstance ?? t) : t.Any();
+		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = t.Union([columnSchemas[key]!, t.Null()]);
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = t.Optional(columnSchemas[key]!);
+			}
+		}
+	}
+
+	return t.Object(columnSchemas) as any;
+}
+
+export function handleEnum(enum_: PgEnum<any>, factory?: CreateSchemaFactoryOptions) {
+	const typebox: typeof t = factory?.typeboxInstance ?? t;
+	return typebox.Enum(mapEnumValues(enum_.enumValues));
+}
+
+const selectConditions: Conditions = {
+	never: () => false,
+	optional: () => false,
+	nullable: (column) => !column.notNull,
+};
+
+const insertConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+	nullable: (column) => !column.notNull,
+};
+
+const updateConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: () => true,
+	nullable: (column) => !column.notNull,
+};
+
+export const createSelectSchema: CreateSelectSchema = (
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return handleEnum(entity);
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, selectConditions) as any;
+};
+
+export const createInsertSchema: CreateInsertSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, insertConditions) as any;
+};
+
+export const createUpdateSchema: CreateUpdateSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, updateConditions) as any;
+};
+
+export function createSchemaFactory(options?: CreateSchemaFactoryOptions) {
+	const createSelectSchema: CreateSelectSchema = (
+		entity: Table | View | PgEnum<[string, ...string[]]>,
+		refine?: Record<string, any>,
+	) => {
+		if (isWithEnum(entity)) {
+			return handleEnum(entity, options);
+		}
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, selectConditions, options) as any;
+	};
+
+	const createInsertSchema: CreateInsertSchema = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, insertConditions, options) as any;
+	};
+
+	const createUpdateSchema: CreateUpdateSchema = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, updateConditions, options) as any;
+	};
+
+	return { createSelectSchema, createInsertSchema, createUpdateSchema };
+}
diff --git a/drizzle-orm/src/typebox/schema.types.internal.ts b/drizzle-orm/src/typebox/schema.types.internal.ts
new file mode 100644
index 0000000000..9bf8591091
--- /dev/null
+++ b/drizzle-orm/src/typebox/schema.types.internal.ts
@@ -0,0 +1,76 @@
+import type * as t from 'typebox';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { GetTypeboxType, HandleColumn } from './column.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type BuildRefineField<T> = T extends t.TSchema ? ((schema: T) => t.TSchema) | t.TSchema : never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+> = {
+	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
+		TColumns[K] extends Column ? BuildRefineField<GetTypeboxType<TColumns[K]>>
+			: BuildRefine<GetSelection<TColumns[K]>>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (schema: any) => t.TSchema ? (TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
+		: t.TUnion<[ReturnType<TRefinement>, t.TNull]>) extends infer TSchema
+		? TType extends 'update' ? t.TOptional<Assume<TSchema, t.TSchema>> : TSchema
+	: t.TSchema
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object ? TRefinements[TKey] extends t.TSchema | ((schema: any) => any) ? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+> = t.TObject<
+	Simplify<
+		{
+			[
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column
+				? IsRefinementDefined<TRefinements, K> extends true
+					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, t.TSchema>
+				: HandleColumn<TType, TColumn>
+				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TObject>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
+					>
+				: t.TAny;
+		}
+	>
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare ? TRefinement[K] extends t.TSchema ? TRefinement[K]
+		: TRefinement[K] extends Record<string, t.TSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/typebox/schema.types.ts b/drizzle-orm/src/typebox/schema.types.ts
new file mode 100644
index 0000000000..35ad38aa2a
--- /dev/null
+++ b/drizzle-orm/src/typebox/schema.types.ts
@@ -0,0 +1,56 @@
+import type * as t from 'typebox';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns']>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields']>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(
+		enum_: TEnum,
+	): t.TEnum<TEnum['enumValues']>;
+}
+
+export interface CreateInsertSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateUpdateSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateSchemaFactoryOptions {
+	typeboxInstance?: any;
+}
diff --git a/drizzle-orm/src/up-migrations/cockroach.ts b/drizzle-orm/src/up-migrations/cockroach.ts
new file mode 100644
index 0000000000..7460262028
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/cockroach.ts
@@ -0,0 +1,163 @@
+import type { CockroachSession } from '~/cockroach-core/session.ts';
+import type { MigrationMeta } from '~/migrator.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsSchema: string,
+		migrationsTable: string,
+		session: CockroachSession,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsSchema, migrationsTable, session, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await session.all<{ id: number; hash: string; created_at: string }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		await session.transaction(async (tx) => {
+			// 1. Add new columns
+			await tx.execute(sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${sql.identifier('name')} text`);
+			await tx.execute(
+				sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${
+					sql.identifier('applied_at')
+				} timestamp with time zone DEFAULT now()`,
+			);
+
+			for (const backfillEntry of toApply) {
+				await tx.execute(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+						sql.identifier('applied_at')
+					} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+				);
+			}
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsSchema: string,
+	migrationsTable: string,
+	session: CockroachSession,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const tableExists = await session.all<{ 1: '1' }>(
+		sql`SELECT 1 FROM information_schema.tables
+			WHERE table_schema = ${migrationsSchema}
+			AND table_name = ${migrationsTable}`,
+	);
+
+	if (tableExists.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await session.all<{ schema: string; table_name: string; column_name: string; type: string }>(
+		sql`SELECT
+            n.nspname AS "schema",
+            c.relname AS "table_name",
+            a.attname AS "column_name",
+            pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type"
+        FROM
+            pg_catalog.pg_attribute a
+            JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+            JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE
+            a.attnum > 0
+            AND NOT a.attisdropped
+            AND n.nspname = ${migrationsSchema}
+            AND c.relname = ${migrationsTable}
+        ORDER BY a.attnum;`,
+	);
+
+	let version = GET_VERSION_FOR.cockroach(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.cockroach; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsSchema, migrationsTable, session, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/effect-mysql.ts b/drizzle-orm/src/up-migrations/effect-mysql.ts
new file mode 100644
index 0000000000..5e5ba0f9d3
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/effect-mysql.ts
@@ -0,0 +1,156 @@
+import { Effect } from 'effect';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { MigrationMeta } from '~/migrator.ts';
+import type { MySqlEffectSession } from '~/mysql-core/effect/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsTable: string,
+		session: MySqlEffectSession<TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) => Effect.Effect<void, TEffectHKT['error'], TEffectHKT['context']>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: (migrationsTable, session, localMigrations) => {
+		return Effect.gen(function*() {
+			const table = sql`${sql.identifier(migrationsTable)}`;
+
+			// 1. Read all existing DB migrations
+			// Sort them by ids asc (order how they were applied)
+			const dbRows = yield* session.objects<{ id: number; hash: string; created_at: string }>(
+				sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+			);
+
+			// 2. Sort ASC by millis and if the same - sort by name
+			localMigrations.sort((a, b) =>
+				a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+			);
+
+			const byMillis = new Map<number, MigrationMeta[]>();
+			const byHash = new Map<string, MigrationMeta>();
+			for (const lm of localMigrations) {
+				if (!byMillis.has(lm.folderMillis)) {
+					byMillis.set(lm.folderMillis, []);
+				}
+				byMillis.get(lm.folderMillis)!.push(lm);
+				byHash.set(lm.hash, lm);
+			}
+
+			// 	3. Match each DB row to a local migration
+			// 	Priority: millis -> hash
+			const toApply: { id: number; name: string }[] = [];
+			let unmatchedIds: number[] = [];
+
+			for (const dbRow of dbRows) {
+				const stringified = String(dbRow.created_at);
+				const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+				const candidates = byMillis.get(millis);
+
+				let matched: MigrationMeta | undefined;
+
+				if (candidates && candidates.length === 1) {
+					matched = candidates[0];
+				} else if (candidates && candidates.length > 1) {
+					matched = candidates.find((c) => c.hash === dbRow.hash);
+				} else {
+					matched = byHash.get(dbRow.hash);
+				}
+
+				if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+				else unmatchedIds.push(dbRow.id);
+			}
+
+			// 4. Check for unmatched
+			// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+			// (if same seconds - fallback to hash, if hash fails - corner case)
+			// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+			// which can lead to inconsistencies and potential issues when running future migrations
+			if (unmatchedIds.length > 0) {
+				throw Error(
+					`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+						unmatchedIds.join(', ')
+					}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+				);
+			}
+
+			// 5. Create extra column and backfill names for matched migrations
+			yield* session.execute(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`);
+			yield* session.execute(
+				sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`,
+			);
+
+			for (const backfillEntry of toApply) {
+				yield* session.execute(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+						sql.identifier('applied_at')
+					} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+				);
+			}
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export const upgradeIfNeeded: <TEffectHKT extends QueryEffectHKTBase>(
+	migrationsTable: string,
+	session: MySqlEffectSession<TEffectHKT>,
+	localMigrations: MigrationMeta[],
+) => Effect.Effect<UpgradeResult, TEffectHKT['error'], TEffectHKT['context']> = Effect.fn('upgradeIfNeeded')(
+	function*<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsTable: string,
+		session: MySqlEffectSession<TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) {
+		// Check if the table exists at all
+		const result = yield* session.objects<{ '1': 1 }>(
+			sql`SELECT 1 FROM information_schema.tables
+				WHERE table_name = ${migrationsTable}
+				AND table_schema = DATABASE()`,
+		);
+
+		if (result.length === 0) {
+			return { newDb: true };
+		}
+
+		// Table exists, check table shape
+		const rows = yield* session.objects<{ column_name: string }>(
+			sql`SELECT column_name as \`column_name\`
+			FROM information_schema.columns
+			WHERE table_name = ${migrationsTable}
+			AND table_schema = DATABASE()
+			ORDER BY ordinal_position`,
+		);
+
+		const version = GET_VERSION_FOR.mysql(rows.map((r) => r.column_name));
+
+		for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.mysql; v++) {
+			const upgradeFn = upgradeFunctions[v];
+			if (!upgradeFn) {
+				throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+			}
+			yield* upgradeFn(migrationsTable, session, localMigrations);
+		}
+
+		return { newDb: false };
+	},
+);
diff --git a/drizzle-orm/src/up-migrations/effect-pg.ts b/drizzle-orm/src/up-migrations/effect-pg.ts
new file mode 100644
index 0000000000..2449001534
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/effect-pg.ts
@@ -0,0 +1,175 @@
+import { Effect } from 'effect';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { MigrationMeta } from '~/migrator.ts';
+import type { PgEffectSession } from '~/pg-core/effect/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsSchema: string,
+		migrationsTable: string,
+		session: PgEffectSession<TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) => Effect.Effect<void, TEffectHKT['error'], TEffectHKT['context']>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: (migrationsSchema, migrationsTable, session, localMigrations) => {
+		return Effect.gen(function*() {
+			const table = sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`;
+
+			// 1. Read all existing DB migrations
+			// Sort them by ids asc (order how they were applied)
+			const dbRows = yield* session.objects<{ id: number; hash: string; created_at: string }>(
+				sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+			);
+
+			// 2. Sort ASC by millis and if the same - sort by name
+			localMigrations.sort((a, b) =>
+				a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+			);
+
+			const byMillis = new Map<number, MigrationMeta[]>();
+			const byHash = new Map<string, MigrationMeta>();
+			for (const lm of localMigrations) {
+				if (!byMillis.has(lm.folderMillis)) {
+					byMillis.set(lm.folderMillis, []);
+				}
+				byMillis.get(lm.folderMillis)!.push(lm);
+				byHash.set(lm.hash, lm);
+			}
+
+			// 3. Match each DB row to a local migration
+			//    Priority: millis -> hash
+			const toApply: { id: number; name: string }[] = [];
+			let unmatchedIds: number[] = [];
+
+			for (const dbRow of dbRows) {
+				const stringified = String(dbRow.created_at);
+				const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+				const candidates = byMillis.get(millis);
+
+				let matched: MigrationMeta | undefined;
+
+				if (candidates && candidates.length === 1) {
+					matched = candidates[0];
+				} else if (candidates && candidates.length > 1) {
+					matched = candidates.find((c) => c.hash === dbRow.hash);
+				} else {
+					matched = byHash.get(dbRow.hash);
+				}
+
+				if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+				else unmatchedIds.push(dbRow.id);
+			}
+
+			// 4. Check for unmatched
+			// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+			// (if same seconds - fallback to hash, if hash fails - corner case)
+			// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+			// which can lead to inconsistencies and potential issues when running future migrations
+			if (unmatchedIds.length > 0) {
+				throw Error(
+					`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+						unmatchedIds.join(', ')
+					}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+				);
+			}
+
+			// 5. Create extra column and backfill names for matched migrations
+			yield* session.transaction((tx) =>
+				Effect.gen(function*() {
+					yield* tx.execute(sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${sql.identifier('name')} text`);
+					yield* tx.execute(
+						sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${
+							sql.identifier('applied_at')
+						} timestamp with time zone DEFAULT now()`,
+					);
+
+					for (const backfillEntry of toApply) {
+						yield* tx.execute(
+							sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+								sql.identifier('applied_at')
+							} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+						);
+					}
+				})
+			);
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export const upgradeIfNeeded: <TEffectHKT extends QueryEffectHKTBase>(
+	migrationsSchema: string,
+	migrationsTable: string,
+	session: PgEffectSession<TEffectHKT>,
+	localMigrations: MigrationMeta[],
+) => Effect.Effect<UpgradeResult, TEffectHKT['error'], TEffectHKT['context']> = Effect.fn('upgradeIfNeeded')(
+	function*<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsSchema: string,
+		migrationsTable: string,
+		session: PgEffectSession<TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) {
+		// Check if the table exists at all
+		const result = yield* session.objects(
+			sql`SELECT 1 FROM information_schema.tables
+			WHERE table_schema = ${migrationsSchema}
+			AND table_name = ${migrationsTable}`,
+		);
+
+		if (result.length === 0) {
+			return { newDb: true };
+		}
+
+		// Table exists, check table shape
+		const rows = yield* session.objects<{ schema: string; table_name: string; column_name: string; type: string }>(
+			sql`SELECT
+			n.nspname AS "schema",
+			c.relname AS "table_name",
+			a.attname AS "column_name",
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type"
+		FROM
+			pg_catalog.pg_attribute a
+			JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+			JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE
+			a.attnum > 0
+			AND NOT a.attisdropped
+			AND n.nspname = ${migrationsSchema}
+			AND c.relname = ${migrationsTable}
+		ORDER BY a.attnum;`,
+		);
+
+		const version = GET_VERSION_FOR.effect(rows.map((r) => r.column_name));
+
+		for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.effect; v++) {
+			const upgradeFn = upgradeFunctions[v];
+			if (!upgradeFn) {
+				throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+			}
+			yield* upgradeFn(migrationsSchema, migrationsTable, session, localMigrations);
+		}
+
+		return { newDb: false };
+	},
+);
diff --git a/drizzle-orm/src/up-migrations/effect-sqlite.ts b/drizzle-orm/src/up-migrations/effect-sqlite.ts
new file mode 100644
index 0000000000..c707353a8b
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/effect-sqlite.ts
@@ -0,0 +1,175 @@
+import { Effect } from 'effect';
+import type { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { MigrationMeta } from '~/migrator.ts';
+import { sql } from '~/sql/sql.ts';
+import type { SQLiteEffectSession } from '~/sqlite-core/effect/session.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsTable: string,
+		session: SQLiteEffectSession<any, TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) => Effect.Effect<void, TEffectHKT['error'], TEffectHKT['context']>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: (migrationsTable, session, localMigrations) => {
+		return Effect.gen(function*() {
+			const table = sql`${sql.identifier(migrationsTable)}`;
+
+			// 1. Read all existing DB migrations
+			// Sort them by ids asc (order how they were applied)
+			// this can be null from legacy implementation where id was serial
+			const dbRows = yield* session.objects<{ id: number | null; hash: string; created_at: number }>(
+				sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+			);
+
+			// 2. Sort ASC by millis and if the same - sort by name
+			localMigrations.sort((a, b) =>
+				a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+			);
+
+			const byMillis = new Map<number, MigrationMeta[]>();
+			const byHash = new Map<string, MigrationMeta>();
+			for (const lm of localMigrations) {
+				if (!byMillis.has(lm.folderMillis)) {
+					byMillis.set(lm.folderMillis, []);
+				}
+				byMillis.get(lm.folderMillis)!.push(lm);
+				byHash.set(lm.hash, lm);
+			}
+
+			// 	3. Match each DB row to a local migration
+			// 	Priority: millis -> hash
+
+			// id can be null from legacy implementation where id was serial
+			const toApply: {
+				id: number | null;
+				name: string;
+				hash: string;
+				created_at: string;
+				matchedBy: 'id' | 'hash' | 'millis';
+			}[] = [];
+
+			// id can be null from legacy implementation where id was serial
+			// hash can only be '' for bun-sqlite journal entries
+			let unmatched: { id: number | null; hash: string; created_at: number }[] = [];
+
+			for (const dbRow of dbRows) {
+				const stringified = String(dbRow.created_at);
+				const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+				const candidates = byMillis.get(millis);
+
+				let matched: MigrationMeta | undefined;
+				let matchedBy: 'hash' | 'millis' | null = null;
+				if (candidates && candidates.length === 1) {
+					matched = candidates[0];
+					matchedBy = 'millis';
+				} else if (candidates && candidates.length > 1) {
+					matched = candidates.find((c) => c.hash && dbRow.hash && c.hash === dbRow.hash);
+					if (matched) matchedBy = 'hash';
+				} else {
+					matched = byHash.get(dbRow.hash);
+					if (matched) matchedBy = 'hash';
+				}
+
+				if (matched) {
+					toApply.push({
+						id: dbRow.id,
+						name: matched.name,
+						hash: dbRow.hash,
+						created_at: stringified,
+						matchedBy: dbRow.id ? 'id' : matchedBy!,
+					});
+				} else unmatched.push(dbRow);
+			}
+
+			// 4. Check for unmatched
+			if (unmatched.length > 0) {
+				throw Error(
+					`While upgrading your database migrations table we found ${unmatched.length} (${
+						unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(', ')
+					}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+				);
+			}
+
+			// 5. Create extra column and backfill names for matched migrations
+			yield* session.transaction((tx) =>
+				Effect.gen(function*() {
+					yield* tx.run(sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('name')} text`);
+					yield* tx.run(
+						sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('applied_at')} TEXT`,
+					);
+
+					for (const backfillEntry of toApply) {
+						const updateQuery = sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+							sql.identifier('applied_at')
+						} = NULL WHERE`;
+
+						if (backfillEntry.id) updateQuery.append(sql` ${sql.identifier('id')} = ${backfillEntry.id}`);
+						else if (backfillEntry.matchedBy === 'millis') {
+							updateQuery.append(sql` ${sql.identifier('created_at')} = ${backfillEntry.created_at}`);
+						} else updateQuery.append(sql` ${sql.identifier('hash')} = ${backfillEntry.hash}`);
+
+						yield* tx.run(updateQuery);
+					}
+				})
+			);
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export const upgradeIfNeeded: <TEffectHKT extends QueryEffectHKTBase>(
+	migrationsTable: string,
+	session: SQLiteEffectSession<any, TEffectHKT>,
+	localMigrations: MigrationMeta[],
+) => Effect.Effect<UpgradeResult, TEffectHKT['error'], TEffectHKT['context']> = Effect.fn('upgradeIfNeeded')(
+	function*<TEffectHKT extends QueryEffectHKTBase>(
+		migrationsTable: string,
+		session: SQLiteEffectSession<any, TEffectHKT>,
+		localMigrations: MigrationMeta[],
+	) {
+		const tableExists = yield* session.objects(
+			sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`,
+		);
+
+		if (tableExists.length === 0) {
+			return { newDb: true };
+		}
+
+		const rows = yield* session.objects<{ column_name: string }>(
+			sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`,
+		);
+
+		const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+
+		for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+			const upgradeFn = upgradeFunctions[v];
+			if (!upgradeFn) {
+				throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+			}
+			yield* upgradeFn(migrationsTable, session, localMigrations);
+		}
+
+		return { newDb: false };
+	},
+);
diff --git a/drizzle-orm/src/up-migrations/mssql.ts b/drizzle-orm/src/up-migrations/mssql.ts
new file mode 100644
index 0000000000..7133897365
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/mssql.ts
@@ -0,0 +1,149 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { MsSqlSession } from '~/mssql-core/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsSchema: string,
+		migrationsTable: string,
+		session: MsSqlSession,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsSchema, migrationsTable, session, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await session.execute<{ recordset: { id: number; hash: string; created_at: string }[] }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows.recordset) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		await session.transaction(async (tx) => {
+			await tx.execute(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`);
+			await tx.execute(
+				sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} datetime2 DEFAULT GETUTCDATE()`,
+			);
+			for (const backfillEntry of toApply) {
+				await tx.execute(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+						sql.identifier('applied_at')
+					} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+				);
+			}
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsSchema: string,
+	migrationsTable: string,
+	session: MsSqlSession,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await session.execute<{ recordset: { [key: string]: unknown }[] }>(
+		sql`SELECT 1 FROM INFORMATION_SCHEMA.TABLES 
+			WHERE TABLE_SCHEMA = ${migrationsSchema} 
+			AND TABLE_NAME = ${migrationsTable}`,
+	);
+
+	if (result.recordset.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await session.execute<{ recordset: { column_name: string }[] }>(
+		sql`SELECT COLUMN_NAME as [column_name]
+		FROM INFORMATION_SCHEMA.COLUMNS
+		WHERE TABLE_SCHEMA = ${migrationsSchema}
+		AND TABLE_NAME = ${migrationsTable}
+		ORDER BY ORDINAL_POSITION`,
+	);
+
+	const version = GET_VERSION_FOR.mssql(rows.recordset.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.mssql; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsSchema, migrationsTable, session, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/mysql-proxy.ts b/drizzle-orm/src/up-migrations/mysql-proxy.ts
new file mode 100644
index 0000000000..e5f85ac78a
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/mysql-proxy.ts
@@ -0,0 +1,162 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { MySqlRemoteDatabase } from '~/mysql-proxy/index.ts';
+import type { ProxyMigrator } from '~/mysql-proxy/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		db: MySqlRemoteDatabase<AnyRelations>,
+		callback: ProxyMigrator,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, db, callback, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = (await db.session.arrays<[number, string, string]>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		)).map((it) => ({
+			id: it[0],
+			hash: it[1],
+			created_at: it[2],
+		}));
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const statements: string[] = [
+			db.dialect.sqlToQuery(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`.inlineParams()).sql,
+			db.dialect.sqlToQuery(
+				sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`
+					.inlineParams(),
+			).sql,
+		];
+
+		for (const backfillEntry of toApply) {
+			statements.push(
+				db.dialect.sqlToQuery(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+						sql.identifier('applied_at')
+					} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`.inlineParams(),
+				).sql,
+			);
+		}
+
+		await callback(statements);
+		return;
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsTable: string,
+	db: MySqlRemoteDatabase<AnyRelations>,
+	callback: ProxyMigrator,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await db.session.arrays<[1]>(
+		sql`SELECT 1 FROM information_schema.tables 
+			WHERE table_name = ${migrationsTable}
+			AND table_schema = DATABASE()`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await db.session.arrays<[string]>(
+		sql`SELECT column_name as \`column_name\`
+		FROM information_schema.columns
+		WHERE table_name = ${migrationsTable}
+		AND table_schema = DATABASE()
+		ORDER BY ordinal_position`,
+	);
+
+	const version = GET_VERSION_FOR.mysql(rows.map((r) => r[0]));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.mysql; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, db, callback, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/mysql.ts b/drizzle-orm/src/up-migrations/mysql.ts
new file mode 100644
index 0000000000..78c8d3134d
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/mysql.ts
@@ -0,0 +1,146 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { MySqlAsyncSession } from '~/mysql-core/async/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		session: MySqlAsyncSession,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, session, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await session.objects<{ id: number; hash: string; created_at: string }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		await session.execute(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`);
+		await session.execute(
+			sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`,
+		);
+
+		for (const backfillEntry of toApply) {
+			await session.execute(
+				sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+					sql.identifier('applied_at')
+				} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+			);
+		}
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsTable: string,
+	session: MySqlAsyncSession,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await session.objects<{ '1': 1 }>(
+		sql`SELECT 1 FROM information_schema.tables 
+			WHERE table_name = ${migrationsTable}
+			AND table_schema = DATABASE()`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await session.objects<{ column_name: string }>(
+		sql`SELECT column_name as \`column_name\`
+		FROM information_schema.columns
+		WHERE table_name = ${migrationsTable}
+		AND table_schema = DATABASE()
+		ORDER BY ordinal_position`,
+	);
+
+	const version = GET_VERSION_FOR.mysql(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.mysql; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, session, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/pg-proxy.ts b/drizzle-orm/src/up-migrations/pg-proxy.ts
new file mode 100644
index 0000000000..5c06628f85
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/pg-proxy.ts
@@ -0,0 +1,173 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { PgRemoteDatabase } from '~/pg-proxy/index.ts';
+import type { ProxyMigrator } from '~/pg-proxy/migrator.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsSchema: string,
+		migrationsTable: string,
+		db: PgRemoteDatabase,
+		callback: ProxyMigrator,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsSchema, migrationsTable, db, callback, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await db.session.objects<{ id: number; hash: string; created_at: string }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const sqls: string[] = [
+			db.dialect.sqlToQuery(
+				sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${sql.identifier('name')} text`.inlineParams(),
+			).sql,
+			db.dialect.sqlToQuery(
+				sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${
+					sql.identifier('applied_at')
+				} timestamp with time zone DEFAULT now()`.inlineParams(),
+			).sql,
+		];
+		for (const { id, name } of toApply) {
+			sqls.push(
+				db.dialect.sqlToQuery(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${name}, ${sql.identifier('applied_at')} = NULL WHERE ${
+						sql.identifier('id')
+					} = ${id}`.inlineParams(),
+				).sql,
+			);
+		}
+
+		await callback(sqls);
+		return;
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsSchema: string,
+	migrationsTable: string,
+	db: PgRemoteDatabase,
+	callback: ProxyMigrator,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await db.session.execute<{ '1': 1 }[]>(
+		sql`SELECT 1 FROM information_schema.tables
+			WHERE table_schema = ${migrationsSchema}
+			AND table_name = ${migrationsTable}`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await db.session.objects<
+		{ schema: string; table_name: string; column_name: string; type: string }
+	>(
+		sql`SELECT
+			n.nspname AS "schema",
+			c.relname AS "table_name",
+			a.attname AS "column_name",
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type"
+		FROM
+			pg_catalog.pg_attribute a
+			JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+			JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE
+			a.attnum > 0
+			AND NOT a.attisdropped
+			AND n.nspname = ${migrationsSchema}
+			AND c.relname = ${migrationsTable}
+		ORDER BY a.attnum;`,
+	);
+
+	let version = GET_VERSION_FOR.pg(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.pg; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsSchema, migrationsTable, db, callback, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/pg.ts b/drizzle-orm/src/up-migrations/pg.ts
new file mode 100644
index 0000000000..4e1ef1747c
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/pg.ts
@@ -0,0 +1,194 @@
+import type { BatchItem } from '~/batch.ts';
+import type { MigrationMeta } from '~/migrator.ts';
+import type { NeonHttpDatabase } from '~/neon-http/driver.ts';
+import type { PgAsyncDatabase } from '~/pg-core/async/db.ts';
+import type { PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgQueryResultHKT } from '~/pg-core/session.ts';
+import { type SQL, sql } from '~/sql/sql.ts';
+import { assertUnreachable } from '~/utils.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsSchema: string,
+		migrationsTable: string,
+		db: PgAsyncDatabase<PgQueryResultHKT, any>,
+		localMigrations: MigrationMeta[],
+		mode: 'transaction' | 'batch' | 'execute',
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsSchema, migrationsTable, db, localMigrations, mode) => {
+		const table = sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await db.session.objects<{ id: number; hash: string; created_at: string }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const sqls: SQL[] = [
+			sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${sql.identifier('name')} text`,
+			sql`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${
+				sql.identifier('applied_at')
+			} timestamp with time zone DEFAULT now()`,
+		];
+		for (const { id, name } of toApply) {
+			sqls.push(
+				sql`UPDATE ${table} SET ${sql.identifier('name')} = ${name}, ${sql.identifier('applied_at')} = NULL WHERE ${
+					sql.identifier('id')
+				} = ${id}`,
+			);
+		}
+
+		// batch - neon http
+		// execute - xata http
+		// transaction -> other
+		if (mode === 'transaction') {
+			await db.transaction(async (tx: PgAsyncTransaction<any, any>) => {
+				for (const sql of sqls) {
+					await tx.execute(sql);
+				}
+			});
+		} else if (mode === 'batch') {
+			const database = db as NeonHttpDatabase;
+
+			await database.batch(
+				sqls.map((s) => database.execute(s)) as unknown as [BatchItem<'pg'>, ...BatchItem<'pg'>[]],
+			);
+		} else if (mode === 'execute') {
+			for (const sql of sqls) {
+				await db.session.execute(sql);
+			}
+		} else {
+			assertUnreachable(mode);
+		}
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsSchema: string,
+	migrationsTable: string,
+	db: PgAsyncDatabase<PgQueryResultHKT, any>,
+	localMigrations: MigrationMeta[],
+	// batch - neon http
+	// execute - xata http
+	// transaction - all others
+	mode: 'transaction' | 'batch' | 'execute' = 'transaction',
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await db.session.objects<{ '1': 1 }>(
+		sql`SELECT 1 FROM information_schema.tables
+			WHERE table_schema = ${migrationsSchema}
+			AND table_name = ${migrationsTable}`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await db.session.objects<
+		{ schema: string; table_name: string; column_name: string; type: string }
+	>(
+		sql`SELECT
+			n.nspname AS "schema",
+			c.relname AS "table_name",
+			a.attname AS "column_name",
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS "type"
+		FROM
+			pg_catalog.pg_attribute a
+			JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+			JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE
+			a.attnum > 0
+			AND NOT a.attisdropped
+			AND n.nspname = ${migrationsSchema}
+			AND c.relname = ${migrationsTable}
+		ORDER BY a.attnum;`,
+	);
+
+	let version = GET_VERSION_FOR.pg(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.pg; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsSchema, migrationsTable, db, localMigrations, mode);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/singlestore-proxy.ts b/drizzle-orm/src/up-migrations/singlestore-proxy.ts
new file mode 100644
index 0000000000..47a11a0384
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/singlestore-proxy.ts
@@ -0,0 +1,161 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { SingleStoreRemoteDatabase } from '~/singlestore-proxy/index.ts';
+import type { ProxyMigrator } from '~/singlestore-proxy/migrator.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		db: SingleStoreRemoteDatabase<Record<string, unknown>>,
+		callback: ProxyMigrator,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, db, callback, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = (await db.session.all<[number, string, string]>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		)).map((it) => ({
+			id: it[0],
+			hash: it[1],
+			created_at: it[2],
+		}));
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const statements: string[] = [
+			db.dialect.sqlToQuery(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`.inlineParams()).sql,
+			db.dialect.sqlToQuery(
+				sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`
+					.inlineParams(),
+			).sql,
+		];
+
+		for (const backfillEntry of toApply) {
+			statements.push(
+				db.dialect.sqlToQuery(
+					sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+						sql.identifier('applied_at')
+					} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`.inlineParams(),
+				).sql,
+			);
+		}
+
+		await callback(statements);
+		return;
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsTable: string,
+	db: SingleStoreRemoteDatabase<Record<string, unknown>>,
+	callback: ProxyMigrator,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await db.session.all<[1]>(
+		sql`SELECT 1 FROM information_schema.tables 
+			WHERE table_name = ${migrationsTable}
+			AND table_schema = DATABASE()`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await db.session.all<[string]>(
+		sql`SELECT column_name as \`column_name\`
+		FROM information_schema.columns
+		WHERE table_name = ${migrationsTable}
+		AND table_schema = DATABASE()
+		ORDER BY ordinal_position`,
+	);
+
+	const version = GET_VERSION_FOR.singlestore(rows.map((r) => r[0]));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.singlestore; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, db, callback, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/singlestore.ts b/drizzle-orm/src/up-migrations/singlestore.ts
new file mode 100644
index 0000000000..f59ca1e7b3
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/singlestore.ts
@@ -0,0 +1,146 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { SingleStoreSession } from '~/singlestore-core/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Map of upgrade functions. Each key is the version being upgraded FROM,
+ * and the function upgrades the table to the next version.
+ */
+const upgradeFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		session: SingleStoreSession,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, session, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		const dbRows = await session.all<{ id: number; hash: string; created_at: string }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+		const toApply: { id: number; name: string }[] = [];
+		let unmatchedIds: number[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash === dbRow.hash);
+			} else {
+				matched = byHash.get(dbRow.hash);
+			}
+
+			if (matched) toApply.push({ id: dbRow.id, name: matched.name });
+			else unmatchedIds.push(dbRow.id);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatchedIds.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatchedIds.length} migrations (ids: ${
+					unmatchedIds.join(', ')
+				}) in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		await session.execute(sql`ALTER TABLE ${table} ADD ${sql.identifier('name')} text`);
+		await session.execute(
+			sql`ALTER TABLE ${table} ADD ${sql.identifier('applied_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`,
+		);
+
+		for (const backfillEntry of toApply) {
+			await session.execute(
+				sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+					sql.identifier('applied_at')
+				} = NULL WHERE ${sql.identifier('id')} = ${backfillEntry.id}`,
+			);
+		}
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeIfNeeded(
+	migrationsTable: string,
+	session: SingleStoreSession,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const result = await session.all<{ '1': 1 }>(
+		sql`SELECT 1 FROM information_schema.tables 
+			WHERE table_name = ${migrationsTable}
+			AND table_schema = DATABASE()`,
+	);
+
+	if (result.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await session.all<{ column_name: string }>(
+		sql`SELECT column_name as \`column_name\`
+		FROM information_schema.columns
+		WHERE table_name = ${migrationsTable}
+		AND table_schema = DATABASE()
+		ORDER BY ordinal_position`,
+	);
+
+	const version = GET_VERSION_FOR.singlestore(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.singlestore; v++) {
+		const upgradeFn = upgradeFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, session, localMigrations);
+	}
+
+	return { newDb: false };
+}
diff --git a/drizzle-orm/src/up-migrations/sqlite-proxy.ts b/drizzle-orm/src/up-migrations/sqlite-proxy.ts
new file mode 100644
index 0000000000..307c95ff26
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/sqlite-proxy.ts
@@ -0,0 +1,178 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { sql } from '~/sql/sql.ts';
+import type { SQLiteAsyncDatabase } from '~/sqlite-core/index.ts';
+import type { SqliteRemoteDatabase } from '~/sqlite-proxy/index.ts';
+import type { ProxyMigrator } from '~/sqlite-proxy/migrator.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeAsyncIfNeeded(
+	migrationsTable: string,
+	db: SqliteRemoteDatabase<AnyRelations>,
+	callback: ProxyMigrator,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const tableExists = await db.session.arrays<[1]>(
+		sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`,
+	);
+
+	if (tableExists.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = await db.session.arrays<[string]>(
+		sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`,
+	);
+
+	const version = GET_VERSION_FOR.sqlite(rows.map((r) => r[0]));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+		const upgradeFn = upgradeAsyncFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, db, callback, localMigrations);
+	}
+
+	return { newDb: false };
+}
+
+const upgradeAsyncFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		db: SQLiteAsyncDatabase<'async', unknown, AnyRelations>,
+		callback: ProxyMigrator,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, db, callback, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		// this can be null from legacy implementation where id was serial
+		const dbRows = (await db.session.arrays<[number | null, string, number]>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		)).map((row) => ({
+			id: row[0],
+			hash: row[1],
+			created_at: row[2],
+		}));
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+
+		// id can be null from legacy implementation where id was serial
+		const toApply: {
+			id: number | null;
+			name: string;
+			hash: string;
+			created_at: string;
+			matchedBy: 'id' | 'hash' | 'millis';
+		}[] = [];
+
+		// id can be null from legacy implementation where id was serial
+		// hash can only be '' for bun-sqlite journal entries
+		let unmatched: { id: number | null; hash: string; created_at: number }[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+			let matchedBy: 'hash' | 'millis' | null = null;
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+				matchedBy = 'millis';
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash && dbRow.hash && c.hash === dbRow.hash); // for bun-sqlite cases (journal had empty hash)
+				if (matched) matchedBy = 'hash';
+			} else {
+				matched = byHash.get(dbRow.hash);
+				if (matched) matchedBy = 'hash';
+			}
+
+			if (matched) {
+				toApply.push({
+					id: dbRow.id,
+					name: matched.name,
+					hash: dbRow.hash,
+					created_at: stringified,
+					matchedBy: dbRow.id ? 'id' : matchedBy!,
+				});
+			} else unmatched.push(dbRow);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatched.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatched.length} (${
+					unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(', ')
+				}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const statements: string[] = [
+			db.dialect.sqlToQuery(sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('name')} text`.inlineParams()).sql,
+			db.dialect.sqlToQuery(sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('applied_at')} TEXT`.inlineParams())
+				.sql,
+		];
+		for (const backfillEntry of toApply) {
+			const updateQuery = sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+				sql.identifier('applied_at')
+			} = NULL WHERE`;
+
+			// id
+			// created_at
+			// hash
+			if (backfillEntry.id) updateQuery.append(sql` ${sql.identifier('id')} = ${backfillEntry.id}`);
+			else if (backfillEntry.matchedBy === 'millis') {
+				updateQuery.append(sql` ${sql.identifier('created_at')} = ${backfillEntry.created_at}`);
+			} else updateQuery.append(sql` ${sql.identifier('hash')} = ${backfillEntry.hash}`);
+
+			statements.push(db.dialect.sqlToQuery(updateQuery.inlineParams()).sql);
+		}
+
+		await callback(statements);
+		return;
+	},
+};
diff --git a/drizzle-orm/src/up-migrations/sqlite.ts b/drizzle-orm/src/up-migrations/sqlite.ts
new file mode 100644
index 0000000000..6ea1624bdd
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/sqlite.ts
@@ -0,0 +1,343 @@
+import type { MigrationMeta } from '~/migrator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type SQL, sql } from '~/sql/sql.ts';
+import type { SQLiteAsyncSession } from '~/sqlite-core/async/session.ts';
+import type { SQLiteAsyncDatabase } from '~/sqlite-core/index.ts';
+import { GET_VERSION_FOR, MIGRATIONS_TABLE_VERSIONS, type UpgradeResult } from './utils.ts';
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export function upgradeSyncIfNeeded(
+	migrationsTable: string,
+	session: SQLiteAsyncSession<
+		'sync',
+		unknown,
+		AnyRelations
+	>,
+	localMigrations: MigrationMeta[],
+): UpgradeResult {
+	const tableExists = session.objects(
+		sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`,
+	);
+
+	if (tableExists.length === 0) {
+		return { newDb: true };
+	}
+
+	// Table exists, check table shape
+	const rows = session.objects<{ column_name: string }>(
+		sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`,
+	);
+
+	const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+		const upgradeFn = upgradeSyncFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		upgradeFn(migrationsTable, session, localMigrations);
+	}
+
+	return { newDb: false };
+}
+
+const upgradeSyncFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		session: SQLiteAsyncSession<
+			'sync',
+			unknown,
+			AnyRelations
+		>,
+		localMigrations: MigrationMeta[],
+	) => void
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: (migrationsTable, session, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		// this can be null from legacy implementation where id was serial
+		const dbRows = session.objects<{ id: number | null; hash: string; created_at: number }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+
+		// id can be null from legacy implementation where id was serial
+		const toApply: {
+			id: number | null;
+			name: string;
+			hash: string;
+			created_at: string;
+			matchedBy: 'id' | 'hash' | 'millis';
+		}[] = [];
+
+		// id can be null from legacy implementation where id was serial
+		// hash can only be '' for bun-sqlite journal entries
+		let unmatched: { id: number | null; hash: string; created_at: number }[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+			let matchedBy: 'hash' | 'millis' | null = null;
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+				matchedBy = 'millis';
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash && dbRow.hash && c.hash === dbRow.hash); // for bun-sqlite cases (journal had empty hash)
+				if (matched) matchedBy = 'hash';
+			} else {
+				matched = byHash.get(dbRow.hash);
+				if (matched) matchedBy = 'hash';
+			}
+
+			if (matched) {
+				toApply.push({
+					id: dbRow.id,
+					name: matched.name,
+					hash: dbRow.hash,
+					created_at: stringified,
+					matchedBy: dbRow.id ? 'id' : matchedBy!,
+				});
+			} else unmatched.push(dbRow);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatched.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatched.length} (${
+					unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(', ')
+				}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		session.transaction((tx) => {
+			tx.run(sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('name')} text`);
+			tx.run(
+				sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('applied_at')} TEXT`,
+			);
+
+			for (const backfillEntry of toApply) {
+				const updateQuery = sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+					sql.identifier('applied_at')
+				} = NULL WHERE`;
+
+				// id
+				// created_at
+				// hash
+				if (backfillEntry.id) updateQuery.append(sql` ${sql.identifier('id')} = ${backfillEntry.id}`);
+				else if (backfillEntry.matchedBy === 'millis') {
+					updateQuery.append(sql` ${sql.identifier('created_at')} = ${backfillEntry.created_at}`);
+				} else updateQuery.append(sql` ${sql.identifier('hash')} = ${backfillEntry.hash}`);
+
+				tx.run(updateQuery);
+			}
+		});
+	},
+};
+
+/**
+ * Detects the current version of the migrations table schema and upgrades it if needed.
+ *
+ * Version 0: Original schema (id, hash, created_at)
+ * Version 1: Extended schema (id, hash, created_at, name, applied_at)
+ */
+export async function upgradeAsyncIfNeeded(
+	migrationsTable: string,
+	db: SQLiteAsyncDatabase<'async', unknown, AnyRelations>,
+	localMigrations: MigrationMeta[],
+): Promise<UpgradeResult> {
+	// Check if the table exists at all
+	const tableExists = await db.session.objects(
+		sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`,
+	);
+
+	if (tableExists.length === 0) {
+		return { newDb: true };
+	}
+
+	const rows = await db.session.objects<{ column_name: string }>(
+		sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`,
+	);
+
+	const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+
+	for (let v = version; v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+		const upgradeFn = upgradeAsyncFunctions[v];
+		if (!upgradeFn) {
+			throw new Error(`No upgrade path from migration table version ${v} to ${v + 1}`);
+		}
+		await upgradeFn(migrationsTable, db, localMigrations);
+	}
+
+	return { newDb: false };
+}
+
+const upgradeAsyncFunctions: Record<
+	number,
+	(
+		migrationsTable: string,
+		db: SQLiteAsyncDatabase<'async', unknown, AnyRelations>,
+		localMigrations: MigrationMeta[],
+	) => Promise<void>
+> = {
+	/**
+	 * Upgrade from version 0 to version 1:
+	 * 1. Read all existing DB migrations
+	 * 2. Sort localMigrations ASC by millis and if the same - sort by name
+	 * 3. Match each DB row to a local migration
+	 * If multiple migrations share the same second, use hash matching as a tiebreaker
+	 * Not implemented for now -> If hash matching fails, fall back to serial id ordering
+	 * 5. Create extra column and backfill names for matched migrations
+	 */
+	0: async (migrationsTable, db, localMigrations) => {
+		const table = sql`${sql.identifier(migrationsTable)}`;
+
+		// 1. Read all existing DB migrations
+		// Sort them by ids asc (order how they were applied)
+		// this can be null from legacy implementation where id was serial
+		const dbRows = await db.session.objects<{ id: number | null; hash: string; created_at: number }>(
+			sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`,
+		);
+
+		// 2. Sort ASC by millis and if the same - sort by name
+		localMigrations.sort((a, b) =>
+			a.folderMillis !== b.folderMillis ? a.folderMillis - b.folderMillis : (a.name ?? '').localeCompare(b.name ?? '')
+		);
+
+		const byMillis = new Map<number, MigrationMeta[]>();
+		const byHash = new Map<string, MigrationMeta>();
+		for (const lm of localMigrations) {
+			if (!byMillis.has(lm.folderMillis)) {
+				byMillis.set(lm.folderMillis, []);
+			}
+			byMillis.get(lm.folderMillis)!.push(lm);
+			byHash.set(lm.hash, lm);
+		}
+
+		// 	3. Match each DB row to a local migration
+		// 	Priority: millis -> hash
+
+		// id can be null from legacy implementation where id was serial
+		const toApply: {
+			id: number | null;
+			name: string;
+			hash: string;
+			created_at: string;
+			matchedBy: 'id' | 'hash' | 'millis';
+		}[] = [];
+
+		// id can be null from legacy implementation where id was serial
+		// hash can only be '' for bun-sqlite journal entries
+		let unmatched: { id: number | null; hash: string; created_at: number }[] = [];
+
+		for (const dbRow of dbRows) {
+			const stringified = String(dbRow.created_at);
+			const millis = Number(stringified.substring(0, stringified.length - 3) + '000');
+			const candidates = byMillis.get(millis);
+
+			let matched: MigrationMeta | undefined;
+			let matchedBy: 'hash' | 'millis' | null = null;
+			if (candidates && candidates.length === 1) {
+				matched = candidates[0];
+				matchedBy = 'millis';
+			} else if (candidates && candidates.length > 1) {
+				matched = candidates.find((c) => c.hash && dbRow.hash && c.hash === dbRow.hash); // for bun-sqlite cases (journal had empty hash)
+				if (matched) matchedBy = 'hash';
+			} else {
+				matched = byHash.get(dbRow.hash);
+				if (matched) matchedBy = 'hash';
+			}
+
+			if (matched) {
+				toApply.push({
+					id: dbRow.id,
+					name: matched.name,
+					hash: dbRow.hash,
+					created_at: stringified,
+					matchedBy: dbRow.id ? 'id' : matchedBy!,
+				});
+			} else unmatched.push(dbRow);
+		}
+
+		// 4. Check for unmatched
+		// Our assumption on this migration flow is that all DB entries should be matched to a local migration
+		// (if same seconds - fallback to hash, if hash fails - corner case)
+		// If there are unmatched entries, it means that the local environment is missing migrations that have been applied to the DB,
+		// which can lead to inconsistencies and potential issues when running future migrations
+		if (unmatched.length > 0) {
+			throw Error(
+				`While upgrading your database migrations table we found ${unmatched.length} (${
+					unmatched.map((it) => `[id: ${it.id}, created_at: ${it.created_at}]`).join(', ')
+				}) migrations in the database that do not match any local migration. This means that some migrations were applied to the database but are missing from the local environment`,
+			);
+		}
+
+		// 5. Create extra column and backfill names for matched migrations
+		const statements: SQL[] = [
+			sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('name')} text`,
+			sql`ALTER TABLE ${table} ADD COLUMN ${sql.identifier('applied_at')} TEXT`,
+		];
+		for (const backfillEntry of toApply) {
+			const updateQuery = sql`UPDATE ${table} SET ${sql.identifier('name')} = ${backfillEntry.name}, ${
+				sql.identifier('applied_at')
+			} = NULL WHERE`;
+
+			// id
+			// created_at
+			// hash
+			if (backfillEntry.id) updateQuery.append(sql` ${sql.identifier('id')} = ${backfillEntry.id}`);
+			else if (backfillEntry.matchedBy === 'millis') {
+				updateQuery.append(sql` ${sql.identifier('created_at')} = ${backfillEntry.created_at}`);
+			} else updateQuery.append(sql` ${sql.identifier('hash')} = ${backfillEntry.hash}`);
+
+			statements.push(updateQuery);
+		}
+
+		await db.transaction(async (tx) => {
+			for (const statement of statements) {
+				await tx.run(statement);
+			}
+		});
+	},
+};
diff --git a/drizzle-orm/src/up-migrations/utils.ts b/drizzle-orm/src/up-migrations/utils.ts
new file mode 100644
index 0000000000..200d5d6923
--- /dev/null
+++ b/drizzle-orm/src/up-migrations/utils.ts
@@ -0,0 +1,44 @@
+export interface UpgradeResult {
+	newDb: boolean;
+}
+
+export const MIGRATIONS_TABLE_VERSIONS = {
+	sqlite: 1,
+	pg: 1,
+	effect: 1,
+	mysql: 1,
+	mssql: 1,
+	cockroach: 1,
+	singlestore: 1,
+} as const;
+
+export const GET_VERSION_FOR = {
+	mysql: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	pg: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	effect: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	mssql: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	cockroach: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	singlestore: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+	sqlite: (columns: string[]): number => {
+		if (columns.includes('name')) return 1;
+		return 0;
+	},
+} as const;
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index fb17dd6a85..e37c427ec3 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -1,12 +1,14 @@
 import type { Cache } from './cache/core/cache.ts';
+import type { CodecsCollection } from './codecs.ts';
 import type { AnyColumn } from './column.ts';
 import { Column } from './column.ts';
 import { is } from './entity.ts';
 import type { Logger } from './logger.ts';
-import type { SelectedFieldsOrdered } from './operations.ts';
+import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './operations.ts';
 import type { TableLike } from './query-builders/select.types.ts';
+import type { AnyRelations, EmptyRelations } from './relations.ts';
 import { Param, SQL, View } from './sql/sql.ts';
-import type { DriverValueDecoder } from './sql/sql.ts';
+import type { DriverValueDecoder, SQLWrapper } from './sql/sql.ts';
 import { Subquery } from './subquery.ts';
 import { getTableName, Table } from './table.ts';
 import { ViewBaseConfig } from './view-common.ts';
@@ -14,19 +16,21 @@ import { ViewBaseConfig } from './view-common.ts';
 /** @internal */
 export function mapResultRow<TResult>(
 	columns: SelectedFieldsOrdered<AnyColumn>,
-	row: unknown[],
+	row: unknown[] | (readonly unknown[]),
 	joinsNotNullableMap: Record<string, boolean> | undefined,
 ): TResult {
 	// Key -> nested object key, value -> table name if all fields in the nested object are from the same table, false otherwise
 	const nullifyMap: Record<string, string | false> = {};
 
 	const result = columns.reduce<Record<string, any>>(
-		(result, { path, field }, columnIndex) => {
+		(result, { path, field, codec, arrayDimensions }, columnIndex) => {
 			let decoder: DriverValueDecoder<unknown, unknown>;
 			if (is(field, Column)) {
 				decoder = field;
 			} else if (is(field, SQL)) {
 				decoder = field.decoder;
+			} else if (is(field, Subquery)) {
+				decoder = field._.sql.decoder;
 			} else {
 				decoder = field.sql.decoder;
 			}
@@ -39,7 +43,9 @@ export function mapResultRow<TResult>(
 					node = node[pathChunk];
 				} else {
 					const rawValue = row[columnIndex]!;
-					const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+					const value = node[pathChunk] = rawValue === null
+						? null
+						: decoder.mapFromDriverValue(codec ? codec(rawValue, arrayDimensions!) : rawValue);
 
 					if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
 						const objectName = path[0]!;
@@ -70,10 +76,294 @@ export function mapResultRow<TResult>(
 	return result as TResult;
 }
 
+/** @internal bypass bundle-time filtering */
+export const FnConstructor = Object.getPrototypeOf(() => null).constructor as typeof Function;
+
+/** @internal */
+function makeJitQueryMapperInner(
+	columns: SelectedFieldsOrdered<AnyColumn>,
+	joinsNotNullableMap: Record<string, boolean> = {},
+): string {
+	const preFn = [] as string[];
+	const fn = [] as string[];
+	fn.push(`const [ ${columns.map((_, i) => `c${i}`).join(', ')} ] = rows[i];`);
+
+	const nullifyMap: Record<string, string | false> = {};
+	const objectIds: Record<string, string[]> = {};
+	const decodes = Array.from<string>({ length: columns.length });
+
+	for (let idx = 0; idx < columns.length; ++idx) {
+		const { field, path, codec, arrayDimensions } = columns[idx]!;
+		let decoder: DriverValueDecoder<unknown, unknown>;
+		let decoderStr: string;
+		let decoderFieldDestructure: string;
+		let isColumn = false;
+		if (is(field, Column)) {
+			isColumn = true;
+			decoder = field;
+			decoderFieldDestructure = `field: decoder${idx}`;
+		} else if (is(field, SQL)) {
+			decoder = field.decoder;
+			decoderFieldDestructure = `field: { decoder: decoder${idx} }`;
+		} else if (is(field, Subquery)) {
+			decoder = field._.sql.decoder;
+			decoderFieldDestructure = `field: { _: { sql: { decoder: decoder${idx} } } }`;
+		} else {
+			decoder = field.sql.decoder;
+			decoderFieldDestructure = `field: { sql: { decoder: decoder${idx} } }`;
+		}
+		decoderStr = `decoder${idx}.mapFromDriverValue`;
+		if (decoder.mapFromDriverValue.isNoop) decoderStr = '';
+		if (decoderStr) {
+			preFn.push(`const { ${decoderFieldDestructure}${codec ? `, codec: codec${idx}` : ''} } = columns[${idx}];`);
+		} else if (codec) {
+			preFn.push(`const { codec: codec${idx} } = columns[${idx}];`);
+		}
+
+		const colStr = `c${idx}`;
+		let decodedValue = colStr;
+		if (codec) decodedValue = `codec${idx}(${decodedValue}, ${arrayDimensions})`;
+		if (decoderStr) decodedValue = `${decoderStr}(${decodedValue})`;
+		decodes[idx] = colStr === decodedValue
+			? `${colStr}`
+			: `${colStr} === null ? ${colStr} : ${decodedValue}`;
+
+		if (path.length !== 2 || !isColumn) continue;
+		if (objectIds[path[0]!] === undefined) objectIds[path[0]!] = [`c${idx}`];
+		else objectIds[path[0]!]?.push(`c${idx}`);
+		const [objectName] = path as [string];
+		const tableName = getTableName((<Column> field).table);
+		nullifyMap[objectName] = joinsNotNullableMap[tableName] ? false : typeof nullifyMap[objectName] === 'string'
+			? nullifyMap[objectName] === tableName ? tableName : false
+			: tableName;
+	}
+
+	fn.push(`mapped[i] = {`);
+	let currentObjectPath: string[] = [];
+	for (let idx = 0; idx < columns.length; ++idx) {
+		const { path } = columns[idx]!;
+		const jsonPath = path.map((e) => JSON.stringify(e));
+		const decodedValue = decodes[idx]!;
+
+		const objectPath = path.slice(0, -1);
+		let commonLen = 0;
+		while (
+			commonLen < currentObjectPath.length
+			&& commonLen < objectPath.length
+			&& currentObjectPath[commonLen] === objectPath[commonLen]
+		) commonLen++;
+
+		for (let d = currentObjectPath.length - 1; d >= commonLen; --d) {
+			fn.push(`${'\t'.repeat(d + 1)}},`);
+		}
+
+		for (let d = commonLen; d < objectPath.length; ++d) {
+			fn.push(
+				`${'\t'.repeat(d + 1)}${jsonPath[d]}: ${
+					d === 0 && objectPath.length === 1 && typeof nullifyMap[path[0]!] === 'string'
+						? `${objectIds[path[0]!]?.map((c) => `${c} === null`).join(' && ')} ? null : {`
+						: '{'
+				}`,
+			);
+		}
+
+		currentObjectPath = objectPath;
+		fn.push(`${'\t'.repeat(path.length)}${jsonPath[path.length - 1]}: ${decodedValue},`);
+	}
+
+	for (let d = currentObjectPath.length - 1; d >= 0; --d) {
+		fn.push(`${'\t'.repeat(d + 1)}},`);
+	}
+	fn.push(`};`);
+
+	return `${preFn.length ? `${preFn.join('\n\t')}\n\t` : ''}for (let i = 0; i < length; ++i) {
+		${fn.join('\n\t\t')}
+	}`;
+}
+
+export type RowsMapperGenerator = <TResult = any>(
+	columns: SelectedFieldsOrdered<AnyColumn>,
+	joinsNotNullableMap: Record<string, boolean> | undefined,
+) => RowsMapper<TResult>;
+export interface RowsMapper<TResult = Record<string, unknown>[]> {
+	(rows: unknown[][]): TResult;
+	/** @internal jit mapper's function body for debugging */
+	body?: string;
+}
+
+export function makeJitQueryMapper<TResult>(
+	columns: SelectedFieldsOrdered<AnyColumn>,
+	joinsNotNullableMap: Record<string, boolean> | undefined,
+): RowsMapper<TResult> {
+	const internals = `\t"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	${makeJitQueryMapperInner(columns, joinsNotNullableMap)}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper`;
+
+	const fn = Object.assign(
+		new FnConstructor(
+			'rows',
+			internals,
+		).bind({
+			columns,
+		}),
+		{ body: `function jitQueryMapper (rows) {\n${internals}\n}` },
+	) as RowsMapper<TResult>;
+
+	return fn;
+}
+
+/** @internal */
+export function jitCompatCheck(isEnabled?: boolean): boolean {
+	if (!isEnabled) return false;
+
+	try {
+		const res = new FnConstructor('input', '"use strict"; return input;')(true);
+		if (res !== true) {
+			// In case it's broken in runtime but not forbidden
+			console.warn(
+				'Unable to use jit mappers due to incompatibility: corrupted jit function output.\nFalling back to premade mappers.\nError details:',
+			);
+			console.error(`Expected to receive \`true\`, got: ${res}`);
+		}
+		return true;
+	} catch (e) {
+		console.warn(
+			'Unable to use jit mappers due to incompatibility.\nFalling back to premade mappers.\nError details:',
+		);
+		console.error(e);
+		return false;
+	}
+}
+
+export function makeDefaultQueryMapper<TResult>(
+	columns: SelectedFieldsOrdered<AnyColumn>,
+	joinsNotNullableMap: Record<string, boolean> | undefined,
+): RowsMapper<TResult> {
+	const interpretedData = columns.map(({ field, codec, arrayDimensions, path }) => {
+		let processNullifyMap: ((nullifyMap: Record<string, string | false>, value: any) => void) | undefined;
+		let decoderSrc: DriverValueDecoder<unknown, unknown>;
+		if (is(field, Column)) {
+			decoderSrc = field;
+
+			if (joinsNotNullableMap && path.length === 2) {
+				const objectName = path[0]!;
+				processNullifyMap = (nullifyMap, value) => {
+					if (!(objectName in nullifyMap)) {
+						nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+					} else if (
+						typeof nullifyMap[objectName] === 'string' && nullifyMap[objectName] !== getTableName(field.table)
+					) {
+						nullifyMap[objectName] = false;
+					}
+				};
+			}
+		} else if (is(field, SQL)) {
+			decoderSrc = field.decoder;
+		} else if (is(field, Subquery)) {
+			decoderSrc = field._.sql.decoder;
+		} else {
+			decoderSrc = field.sql.decoder;
+		}
+
+		let decoder: ((v: any) => any) | undefined;
+		if (decoderSrc.mapFromDriverValue.isNoop) {
+			decoder = codec ? (v: any) => codec(v, arrayDimensions!) : undefined;
+		} else {
+			decoder = codec
+				? (v: any) => decoderSrc.mapFromDriverValue(codec(v, arrayDimensions!))
+				: (v: any) => decoderSrc.mapFromDriverValue(v);
+		}
+
+		return [decoder, processNullifyMap] as const;
+	});
+
+	return ((rows) =>
+		rows.map((row) => {
+			// Key -> nested object key, value -> table name if all fields in the nested object are from the same table, false otherwise
+			const nullifyMap: Record<string, string | false> = {};
+
+			const result = columns.reduce<Record<string, any>>(
+				(result, { path }, columnIndex) => {
+					let node = result;
+					for (const [pathChunkIndex, pathChunk] of path.entries()) {
+						if (pathChunkIndex < path.length - 1) {
+							if (!(pathChunk in node)) {
+								node[pathChunk] = {};
+							}
+							node = node[pathChunk];
+						} else {
+							const [decoder, processNullifyMap] = interpretedData[columnIndex]!;
+
+							const rawValue = row[columnIndex]!;
+							const value = node[pathChunk] = rawValue === null
+								? null
+								: decoder
+								? decoder(rawValue)
+								: rawValue;
+
+							processNullifyMap?.(nullifyMap, value);
+						}
+					}
+					return result;
+				},
+				{},
+			);
+
+			// Nullify all nested objects from nullifyMap that are nullable
+			if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+				for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+					if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
+						result[objectName] = null;
+					}
+				}
+			}
+
+			return result as TResult;
+		})) as RowsMapper<TResult>;
+}
+
+export function make$ReturningResponseMapper(
+	returningIds: SelectedFieldsOrdered<Column> | undefined,
+	generatedIds?: Record<string, unknown>[],
+) {
+	if (!returningIds) return;
+
+	return ({ insertId, affectedRows }: {
+		insertId: number;
+		affectedRows: number;
+	}) => {
+		const returningResponse = [];
+		let j = 0;
+		for (let i = insertId; i < insertId + affectedRows; i++) {
+			for (const column of returningIds) {
+				const key = returningIds[0]!.path[0]!;
+				if (is(column.field, Column)) {
+					// @ts-ignore
+					if (column.field.primary && column.field.autoIncrement) {
+						returningResponse.push({ [key]: i });
+					}
+					if (column.field.defaultFn && generatedIds) {
+						// generatedIds[rowIdx][key]
+						returningResponse.push({ [key]: generatedIds[j]![key] });
+					}
+				}
+			}
+			j++;
+		}
+
+		return returningResponse;
+	};
+}
+
 /** @internal */
 export function orderSelectedFields<TColumn extends AnyColumn>(
 	fields: Record<string, unknown>,
 	pathPrefix?: string[],
+	codecs?: CodecsCollection,
 ): SelectedFieldsOrdered<TColumn> {
 	return Object.entries(fields).reduce<SelectedFieldsOrdered<AnyColumn>>((result, [name, field]) => {
 		if (typeof name !== 'string') {
@@ -81,17 +371,81 @@ export function orderSelectedFields<TColumn extends AnyColumn>(
 		}
 
 		const newPath = pathPrefix ? [...pathPrefix, name] : [name];
-		if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased)) {
-			result.push({ path: newPath, field });
+		if (is(field, Column)) {
+			result.push({
+				path: newPath,
+				field,
+				codec: codecs?.get(field, 'normalize'),
+				arrayDimensions: (<any> field).dimensions,
+				column: field,
+			});
+		} else if (is(field, SQL) || is(field, SQL.Aliased)) {
+			const col = getColumnFromDecoder(field);
+			result.push(
+				col
+					? {
+						path: newPath,
+						field,
+						codec: codecs?.get(col, 'normalize'),
+						arrayDimensions: (<any> col).dimensions,
+						column: col,
+					}
+					: {
+						path: newPath,
+						field,
+					},
+			);
+		} else if (is(field, Subquery)) {
+			let column: Column | undefined;
+			const entries = Object.values(field._.selectedFields) as (SQL.Aliased | Column | SQL)[];
+			const entry = entries[0]!;
+
+			let fieldDecoder: DriverValueDecoder<any, any>;
+			if (is(entry, Column)) {
+				column = entry;
+				fieldDecoder = entry;
+			} else if (is(entry, SQL)) {
+				column = getColumnFromDecoder(entry);
+				fieldDecoder = entry.decoder;
+			} else {
+				column = getColumnFromDecoder(entry);
+				fieldDecoder = entry.sql.decoder;
+			}
+
+			if (fieldDecoder) {
+				field._.sql.decoder = fieldDecoder;
+			}
+
+			result.push(
+				column
+					? {
+						path: newPath,
+						field,
+						codec: codecs?.get(column, 'normalize'),
+						arrayDimensions: (<any> column).dimensions,
+						column,
+					}
+					: {
+						path: newPath,
+						field,
+					},
+			);
 		} else if (is(field, Table)) {
-			result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+			result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath, codecs));
 		} else {
-			result.push(...orderSelectedFields(field as Record<string, unknown>, newPath));
+			result.push(...orderSelectedFields(field as Record<string, unknown>, newPath, codecs));
 		}
 		return result;
 	}, []) as SelectedFieldsOrdered<TColumn>;
 }
 
+export function getColumnFromDecoder(source: SQL | SQL.Aliased | SQLWrapper): Column | undefined {
+	const query = source.getSQL();
+
+	if (is(query.decoder, Column)) return query.decoder;
+	return undefined;
+}
+
 export function haveSameKeys(left: Record<string, unknown>, right: Record<string, unknown>) {
 	const leftKeys = Object.keys(left);
 	const rightKeys = Object.keys(right);
@@ -146,6 +500,21 @@ export type Simplify<T> =
 	}
 	& {};
 
+export type Not<T extends boolean> = T extends true ? false : true;
+
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+export type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false
+	: true;
+
+export type SingleKeyObject<T, TError extends string, K = keyof T> = IsNever<K> extends true ? never
+	: IsUnion<K> extends true ? DrizzleTypeError<TError>
+	: T;
+
+export type FromSingleKeyObject<T, Result, TError extends string, K = keyof T> = IsNever<K> extends true ? never
+	: IsUnion<K> extends true ? DrizzleTypeError<TError>
+	: Result;
+
 export type SimplifyMappedType<T> = [T] extends [unknown] ? T : never;
 
 export type ShallowRecord<K extends keyof any, T> = SimplifyMappedType<{ [P in K]: T }>;
@@ -187,6 +556,10 @@ export type Writable<T> = {
 
 export type NonArray<T> = T extends any[] ? never : T;
 
+/**
+ * @deprecated
+ * Use `getColumns` instead
+ */
 export function getTableColumns<T extends Table>(table: T): T['_']['columns'] {
 	return table[Table.Symbol.Columns];
 }
@@ -195,6 +568,20 @@ export function getViewSelectedFields<T extends View>(view: T): T['_']['selected
 	return view[ViewBaseConfig].selectedFields;
 }
 
+export function getColumns<T extends Table | View | Subquery>(
+	table: T,
+): T extends Table ? T['_']['columns']
+	: T extends View ? T['_']['selectedFields']
+	: T extends Subquery ? T['_']['selectedFields']
+	: never
+{
+	return (is(table, Table)
+		? table[Table.Symbol.Columns]
+		: is(table, View)
+		? table[ViewBaseConfig].selectedFields
+		: table._.selectedFields) as any;
+}
+
 /** @internal */
 export function getTableLikeName(table: TableLike): string | undefined {
 	return is(table, Subquery)
@@ -214,13 +601,15 @@ export type ColumnsWithTable<
 	TColumns extends AnyColumn<{ tableName: TTableName }>[],
 > = { [Key in keyof TColumns]: AnyColumn<{ tableName: TForeignTableName }> };
 
-export type Casing = 'snake_case' | 'camelCase';
-
-export interface DrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> {
-	logger?: boolean | Logger;
-	schema?: TSchema;
-	casing?: Casing;
-	cache?: Cache;
+export interface DrizzleConfig<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelationConfigs extends AnyRelations = EmptyRelations,
+> {
+	logger?: boolean | Logger | undefined;
+	schema?: TSchema | undefined;
+	relations?: TRelationConfigs | undefined;
+	cache?: Cache | undefined;
+	jit?: boolean | undefined;
 }
 export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
 	? Exclude<keyof T, keyof ValidShape> extends never ? TResult
@@ -257,13 +646,13 @@ export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Keys extends
 type ExpectedConfigShape = {
 	logger?: boolean | {
 		logQuery(query: string, params: unknown[]): void;
-	};
-	schema?: Record<string, never>;
-	casing?: 'snake_case' | 'camelCase';
+	} | undefined;
+	schema?: Record<string, never> | undefined;
+	relations?: AnyRelations | undefined;
 };
 
 // If this errors, you must update config shape checker function with new config specs
-const _: DrizzleConfig = {} as ExpectedConfigShape;
+const _: DrizzleConfig<any, any> = {} as ExpectedConfigShape;
 const __: ExpectedConfigShape = {} as DrizzleConfig;
 
 export function isConfig(data: any): boolean {
@@ -288,15 +677,9 @@ export function isConfig(data: any): boolean {
 		return true;
 	}
 
-	if ('casing' in data) {
-		const type = typeof data['casing'];
-		if (type !== 'string' && type !== 'undefined') return false;
-
-		return true;
-	}
-
-	if ('mode' in data) {
-		if (data['mode'] !== 'default' || data['mode'] !== 'planetscale' || data['mode'] !== undefined) return false;
+	if ('relations' in data) {
+		const type = typeof data['relations'];
+		if (type !== 'object' && type !== 'undefined') return false;
 
 		return true;
 	}
@@ -315,9 +698,106 @@ export function isConfig(data: any): boolean {
 		return true;
 	}
 
+	if ('jit' in data) {
+		const type = typeof data['jit'];
+		if (type !== 'boolean' && type !== 'undefined') return false;
+
+		return true;
+	}
+
+	if ('codecs' in data) {
+		const type = typeof data['connection'];
+		if (type !== 'object' && type !== 'undefined') return false;
+
+		return true;
+	}
+
 	if (Object.keys(data).length === 0) return true;
 
 	return false;
 }
 
 export type NeonAuthToken = string | (() => string | Promise<string>);
+
+export const textDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder();
+
+export function assertUnreachable(_x: never | undefined): never {
+	throw new Error("Didn't expect to get here");
+}
+
+export function isWithEnum(column: Column<any>): column is typeof column & { enumValues: [string, ...string[]] };
+export function isWithEnum(value: unknown): value is { enumValues: [string, ...string[]] };
+export function isWithEnum(value: unknown): boolean {
+	return ((typeof value === 'object' && value !== null) || typeof value === 'function') && 'enumValues' in value
+		&& Array.isArray(value.enumValues)
+		&& value.enumValues.length > 0;
+}
+
+export type Literal = string | number | boolean | null;
+export type Json = Literal | { [key: string]: any } | any[];
+
+export type ColumnIsGeneratedAlwaysAs<TColumn> = TColumn extends Column<any>
+	? TColumn['_']['identity'] extends 'always' ? true
+	: TColumn['_'] extends { generated: undefined } ? false
+	: TColumn['_']['generated'] extends { type: 'byDefault' } ? false
+	: true
+	: false;
+
+export type GetSelection<T extends SelectedFieldsFlat<Column<any>> | Table<any> | View> = T extends Table<any>
+	? T['_']['columns']
+	: T extends View ? T['_']['selectedFields']
+	: T;
+
+export type RemoveNeverElements<T extends any[]> = T extends [infer First, ...infer Rest]
+	? IsNever<First> extends true ? RemoveNeverElements<Rest>
+	: [First, ...RemoveNeverElements<Rest>]
+	: [];
+
+export type HasBaseColumn<TColumn> = TColumn extends { _: { baseColumn: Column | undefined } }
+	? IsNever<TColumn['_']['baseColumn']> extends false ? true
+	: false
+	: false;
+
+export type EnumValuesToEnum<TEnumValues extends [string, ...string[]]> = { [K in TEnumValues[number]]: K };
+
+export type EnumValuesToReadonlyEnum<TEnumValues extends [string, ...string[]]> = {
+	readonly [K in TEnumValues[number]]: K;
+};
+
+export const CONSTANTS = {
+	INT8_MIN: -128,
+	INT8_MAX: 127,
+	INT8_UNSIGNED_MAX: 255,
+	INT16_MIN: -32768,
+	INT16_MAX: 32767,
+	INT16_UNSIGNED_MAX: 65535,
+	INT24_MIN: -8388608,
+	INT24_MAX: 8388607,
+	INT24_UNSIGNED_MAX: 16777215,
+	INT32_MIN: -2147483648,
+	INT32_MAX: 2147483647,
+	INT32_UNSIGNED_MAX: 4294967295,
+	INT48_MIN: -140737488355328,
+	INT48_MAX: 140737488355327,
+	INT48_UNSIGNED_MAX: 281474976710655,
+	INT64_MIN: -9223372036854775808n,
+	INT64_MAX: 9223372036854775807n,
+	INT64_UNSIGNED_MAX: 18446744073709551615n,
+};
+
+export function base64ToUint8Array(base64: string): Uint8Array {
+	if (!base64) return new Uint8Array(0);
+	const binary = atob(base64);
+	const len = binary.length;
+	const bytes = new Uint8Array(len);
+
+	for (let i = 0; i < len; ++i) {
+		bytes[i] = binary.charCodeAt(i);
+	}
+
+	return bytes;
+}
+
+export type PartialWithUndefined<T> = {
+	[K in keyof T]?: T[K] | undefined;
+};
diff --git a/drizzle-orm/src/valibot/README.md b/drizzle-orm/src/valibot/README.md
new file mode 100644
index 0000000000..85f6cd8155
--- /dev/null
+++ b/drizzle-orm/src/valibot/README.md
@@ -0,0 +1,51 @@
+Allows you to generate [valibot](https://valibot.dev/) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { string, parse, number, pipe } from 'valibot';
+
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	role: text('role', { enum: ['admin', 'user'] }).notNull(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const insertUserSchema = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const updateUserSchema = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const selectUserSchema = createSelectSchema(users);
+
+// Overriding the fields
+const insertUserSchema = createInsertSchema(users, {
+	role: string(),
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const insertUserSchema = createInsertSchema(users, {
+	id: (schema) => pipe([schema, minValue(0)]),
+	role: string(),
+});
+
+// Usage
+
+const isUserValid = parse(insertUserSchema, {
+	name: 'John Doe',
+	email: 'johndoe@test.com',
+	role: 'admin',
+});
+```
diff --git a/drizzle-orm/src/valibot/column.ts b/drizzle-orm/src/valibot/column.ts
new file mode 100644
index 0000000000..04cdf40865
--- /dev/null
+++ b/drizzle-orm/src/valibot/column.ts
@@ -0,0 +1,378 @@
+import * as v from 'valibot';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS, type Json } from '../utils.ts';
+
+export const literalSchema = v.union([v.string(), v.number(), v.boolean(), v.null()]);
+export const jsonSchema: v.GenericSchema<Json> = v.union([
+	literalSchema,
+	v.array(v.any()),
+	v.record(v.string(), v.any()),
+]);
+export const bufferSchema: v.GenericSchema<Buffer> = v.custom<Buffer>((v) => v instanceof Buffer); // oxlint-disable-line no-instanceof-builtins drizzle-internal/no-instanceof
+
+export function mapEnumValues(values: string[]) {
+	return Object.fromEntries(values.map((value) => [value, value]));
+}
+
+export function columnToSchema(column: Column): v.GenericSchema {
+	let schema!: v.GenericSchema;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions);
+	}
+
+	const { type, constraint } = extractExtendedColumnType(column);
+
+	switch (type) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint);
+			break;
+		}
+		case 'boolean': {
+			schema = v.boolean();
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint);
+			break;
+		}
+		case 'custom': {
+			schema = v.any();
+			break;
+		}
+		default: {
+			schema = v.any();
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(column: Column, constraint: ColumnDataNumberConstraint | undefined): v.GenericSchema {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	const actions: any[] = [v.minValue(min), v.maxValue(max)];
+	if (integer) {
+		actions.push(v.integer());
+	}
+	return v.pipe(v.number(), ...actions);
+}
+
+export const bigintStringModeSchema = v.pipe(
+	v.string(),
+	v.regex(/^-?\d+$/),
+	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
+	v.transform((v) => BigInt(v)),
+	v.minValue(CONSTANTS.INT64_MIN),
+	v.maxValue(CONSTANTS.INT64_MAX),
+	v.transform((v) => v.toString()),
+);
+
+export const unsignedBigintStringModeSchema = v.pipe(
+	v.string(),
+	v.regex(/^\d+$/),
+	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
+	v.transform((v) => BigInt(v)),
+	v.minValue(0n),
+	v.maxValue(CONSTANTS.INT64_MAX),
+	v.transform((v) => v.toString()),
+);
+
+function bigintColumnToSchema(column: Column, constraint: ColumnDataBigIntConstraint | undefined): v.GenericSchema {
+	let min!: bigint | undefined;
+	let max!: bigint | undefined;
+
+	switch (constraint) {
+		case 'int64': {
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		}
+		case 'uint64': {
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+		}
+	}
+
+	const actions: any[] = [];
+	if (min !== undefined) actions.push(v.minValue(min));
+	if (max !== undefined) actions.push(v.maxValue(max));
+
+	return actions.length > 0 ? v.pipe(v.bigint(), ...actions) : v.bigint();
+}
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+): v.GenericSchema {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: v.GenericSchema;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint);
+			break;
+		case 'boolean':
+			baseSchema = v.boolean();
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint);
+			break;
+		default:
+			baseSchema = v.any();
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: v.GenericSchema = v.array(baseSchema);
+	for (let i = 1; i < dimensions; i++) {
+		schema = v.array(schema);
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(column: Column, constraint: ColumnDataArrayConstraint | undefined): v.GenericSchema {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return v.tuple([v.number(), v.number()]);
+		}
+		case 'line': {
+			return v.tuple([v.number(), v.number(), v.number()]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const { length } = column;
+			return length
+				? v.pipe(v.array(v.number()), v.length(length))
+				: v.array(v.number());
+		}
+		case 'int64vector': {
+			const length = column.length;
+			return length
+				? v.pipe(
+					v.array(v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX))),
+					v.length(length),
+				)
+				: v.array(v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)));
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const { length } = column;
+				const schema = v.array(columnToSchema(baseColumn));
+				if (length) return v.pipe(schema, v.length(length));
+				return schema;
+			}
+			return v.array(v.any());
+		}
+		default: {
+			return v.array(v.any());
+		}
+	}
+}
+
+function objectColumnToSchema(column: Column, constraint: ColumnDataObjectConstraint | undefined): v.GenericSchema {
+	switch (constraint) {
+		case 'buffer': {
+			return bufferSchema;
+		}
+		case 'date': {
+			return v.date();
+		}
+		case 'geometry':
+		case 'point': {
+			return v.object({
+				x: v.number(),
+				y: v.number(),
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return v.object({
+				a: v.number(),
+				b: v.number(),
+				c: v.number(),
+			});
+		}
+		default: {
+			return v.looseObject({});
+		}
+	}
+}
+
+function stringColumnToSchema(column: Column, constraint: ColumnDataStringConstraint | undefined): v.GenericSchema {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex: RegExp | undefined;
+
+	if (constraint === 'binary') {
+		regex = /^[01]*$/;
+	}
+	if (constraint === 'uuid') return v.pipe(v.string(), v.uuid());
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return v.enum(mapEnumValues(enumValues));
+	}
+	if (constraint === 'int64') {
+		return bigintStringModeSchema;
+	}
+	if (constraint === 'uint64') {
+		return unsignedBigintStringModeSchema;
+	}
+
+	const actions: any[] = [];
+	if (regex) {
+		actions.push(v.regex(regex));
+	}
+	if (length && isLengthExact) {
+		actions.push(v.length(length));
+	} else if (length) {
+		actions.push(v.maxLength(length));
+	}
+	return actions.length > 0 ? v.pipe(v.string(), ...actions) : v.string();
+}
diff --git a/drizzle-orm/src/valibot/column.types.ts b/drizzle-orm/src/valibot/column.types.ts
new file mode 100644
index 0000000000..a526df772d
--- /dev/null
+++ b/drizzle-orm/src/valibot/column.types.ts
@@ -0,0 +1,162 @@
+import type * as v from 'valibot';
+import type { ColumnDataConstraint, ColumnDataType, ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Assume } from '~/utils.ts';
+import type { HasBaseColumn, Json, RemoveNeverElements } from '../utils.ts';
+import type { bigintStringModeSchema, unsignedBigintStringModeSchema } from './column.ts';
+
+export type ExtractAdditionalProperties<
+	TColumn extends Column,
+> = {
+	// Broken - type-level length was removed
+	max: TColumn['length'];
+	// Broken - type-level isLengthExact was removed
+	fixedLength: TColumn['isLengthExact'] extends true ? true : false;
+};
+
+type GetLengthAction<T extends Record<string, any>, TType extends string | ArrayLike<unknown>> =
+	T['fixedLength'] extends true ? v.LengthAction<TType, number, undefined>
+		: v.MaxLengthAction<TType, number, undefined>;
+
+type GetArraySchema<
+	TColumn extends Column,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = GetValibotType<
+	TColumn['_']['data'],
+	TType['type'],
+	TType['constraint'],
+	TColumn['_']['enumValues'],
+	HasBaseColumn<TColumn> extends true ? Assume<TColumn['_'], { baseColumn: Column }>['baseColumn'] : undefined,
+	ExtractAdditionalProperties<TColumn>
+>;
+
+export type GetValibotType<
+	TData,
+	TColumnType extends ColumnDataType,
+	TConstraint extends ColumnDataConstraint | undefined,
+	TEnum extends string[] | undefined,
+	TBaseColumn extends Column | undefined,
+	TAdditionalProperties extends Record<string, any>,
+> = TColumnType extends 'array'
+	? TConstraint extends 'vector' | 'halfvector' ? TAdditionalProperties['max'] extends number ? v.SchemaWithPipe<
+				[v.ArraySchema<v.NumberSchema<undefined>, undefined>, GetLengthAction<TAdditionalProperties, number[]>]
+			>
+		: v.ArraySchema<v.NumberSchema<undefined>, undefined>
+	: TConstraint extends 'int64vector' ? v.ArraySchema<v.BigintSchema<undefined>, undefined>
+	: TConstraint extends 'geometry' | 'point'
+		? v.TupleSchema<[v.NumberSchema<undefined>, v.NumberSchema<undefined>], undefined>
+	: TConstraint extends 'line'
+		? v.TupleSchema<[v.NumberSchema<undefined>, v.NumberSchema<undefined>, v.NumberSchema<undefined>], undefined>
+	: TConstraint extends 'basecolumn'
+		? TBaseColumn extends Column
+			? (GetArraySchema<TBaseColumn> extends infer ArrInternals extends v.BaseSchema<any, any, v.BaseIssue<any>>
+				? TAdditionalProperties['max'] extends number ? v.SchemaWithPipe<
+						[
+							v.ArraySchema<ArrInternals, undefined>,
+							GetLengthAction<
+								TAdditionalProperties,
+								Assume<TData, string | ArrayLike<unknown>>
+							>,
+						]
+					>
+				: v.ArraySchema<ArrInternals, undefined>
+				: v.AnySchema)
+		: v.ArraySchema<v.AnySchema, undefined>
+	: v.ArraySchema<v.AnySchema, undefined>
+	: TColumnType extends 'object' ? TConstraint extends 'geometry' | 'point' ? v.ObjectSchema<
+				{ readonly x: v.NumberSchema<undefined>; readonly y: v.NumberSchema<undefined> },
+				undefined
+			>
+		: TConstraint extends 'line' ? v.ObjectSchema<
+				{
+					readonly a: v.NumberSchema<undefined>;
+					readonly b: v.NumberSchema<undefined>;
+					readonly c: v.NumberSchema<undefined>;
+				},
+				undefined
+			>
+		: TConstraint extends 'date' ? v.DateSchema<undefined>
+		: TConstraint extends 'buffer' ? v.GenericSchema<Buffer>
+		: TConstraint extends 'json' ? v.GenericSchema<Json>
+		: v.LooseObjectSchema<{}, undefined>
+	: TColumnType extends 'custom' ? v.AnySchema
+	: TColumnType extends 'number' ? v.SchemaWithPipe<
+			RemoveNeverElements<[
+				v.NumberSchema<undefined>,
+				v.MinValueAction<number, number, undefined>,
+				v.MaxValueAction<number, number, undefined>,
+				TConstraint extends
+					'int8' | 'int16' | 'int24' | 'int32' | 'int53' | 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint53' | 'year'
+					? v.IntegerAction<number, undefined>
+					: never,
+			]>
+		>
+	: TColumnType extends 'bigint' ? TConstraint extends 'int64' | 'uint64' ? v.SchemaWithPipe<[
+				v.BigintSchema<undefined>,
+				v.MinValueAction<bigint, bigint, undefined>,
+				v.MaxValueAction<bigint, bigint, undefined>,
+			]>
+		: v.BigintSchema<undefined>
+	: TColumnType extends 'boolean' ? v.BooleanSchema<undefined>
+	: TColumnType extends 'string'
+		? TConstraint extends 'uuid' ? v.SchemaWithPipe<[v.StringSchema<undefined>, v.UuidAction<string, undefined>]>
+		: TConstraint extends 'enum' ? v.EnumSchema<
+				{ readonly [K in Assume<TEnum, string[]>[number]]: K },
+				undefined
+			>
+		: TConstraint extends 'int64' ? typeof bigintStringModeSchema
+		: TConstraint extends 'uint64' ? typeof unsignedBigintStringModeSchema
+		: TConstraint extends 'binary' ? v.SchemaWithPipe<
+				RemoveNeverElements<[
+					v.StringSchema<undefined>,
+					v.RegexAction<string, undefined>,
+					TAdditionalProperties['max'] extends number ? GetLengthAction<TAdditionalProperties, string> : never,
+				]>
+			>
+		: TAdditionalProperties['max'] extends number
+			? v.SchemaWithPipe<[v.StringSchema<undefined>, GetLengthAction<TAdditionalProperties, string>]>
+		: v.StringSchema<undefined>
+	: v.AnySchema;
+
+export type GetValibotTypeFromColumn<
+	TColumn extends Column,
+	TDataType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+> = GetValibotType<
+	TColumn['_']['data'],
+	TDataType['type'],
+	TDataType['constraint'],
+	TColumn['_']['enumValues'],
+	HasBaseColumn<TColumn> extends true ? Assume<TColumn['_'], { baseColumn: Column }>['baseColumn'] : undefined,
+	ExtractAdditionalProperties<TColumn>
+>;
+
+type HandleSelectColumn<
+	TSchema extends v.GenericSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: v.NullableSchema<TSchema, undefined>;
+
+type HandleInsertColumn<
+	TSchema extends v.GenericSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true
+	? TColumn['_']['hasDefault'] extends true ? v.OptionalSchema<TSchema, undefined>
+	: TSchema
+	: v.OptionalSchema<v.NullableSchema<TSchema, undefined>, undefined>;
+
+type HandleUpdateColumn<
+	TSchema extends v.GenericSchema,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? v.OptionalSchema<TSchema, undefined>
+	: v.OptionalSchema<v.NullableSchema<TSchema, undefined>, undefined>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+> = GetValibotTypeFromColumn<TColumn> extends infer TSchema extends v.GenericSchema
+	? TSchema extends v.AnySchema ? v.AnySchema
+	: TType extends 'select' ? HandleSelectColumn<TSchema, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<TSchema, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<TSchema, TColumn>
+	: TSchema
+	: v.AnySchema;
diff --git a/drizzle-orm/src/valibot/index.ts b/drizzle-orm/src/valibot/index.ts
new file mode 100644
index 0000000000..5d00169d6e
--- /dev/null
+++ b/drizzle-orm/src/valibot/index.ts
@@ -0,0 +1,11 @@
+export {
+	bigintStringModeSchema,
+	bufferSchema,
+	jsonSchema,
+	literalSchema,
+	unsignedBigintStringModeSchema,
+} from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/valibot/schema.ts b/drizzle-orm/src/valibot/schema.ts
new file mode 100644
index 0000000000..41e9c78080
--- /dev/null
+++ b/drizzle-orm/src/valibot/schema.ts
@@ -0,0 +1,98 @@
+import * as v from 'valibot';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema, mapEnumValues } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type { CreateInsertSchema, CreateSelectSchema, CreateUpdateSchema } from './schema.types.ts';
+
+function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+): v.GenericSchema {
+	const columnSchemas: Record<string, v.GenericSchema> = {};
+
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
+			continue;
+		}
+
+		const refinement = refinements[key];
+		if (refinement !== undefined && typeof refinement !== 'function') {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column) : v.any();
+		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = v.nullable(columnSchemas[key]!);
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = v.optional(columnSchemas[key]!);
+			}
+		}
+	}
+
+	return v.object(columnSchemas) as any;
+}
+
+export const createSelectSchema: CreateSelectSchema = (
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return v.enum(mapEnumValues(entity.enumValues));
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: () => false,
+		optional: () => false,
+		nullable: (column) => !column.notNull,
+	}) as any;
+};
+
+export const createInsertSchema: CreateInsertSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: (column) =>
+			column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+			|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+		optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+		nullable: (column) => !column.notNull,
+	}) as any;
+};
+
+export const createUpdateSchema: CreateUpdateSchema = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, {
+		never: (column) =>
+			column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+			|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+		optional: () => true,
+		nullable: (column) => !column.notNull,
+	}) as any;
+};
diff --git a/drizzle-orm/src/valibot/schema.types.internal.ts b/drizzle-orm/src/valibot/schema.types.internal.ts
new file mode 100644
index 0000000000..d5a66b9fa4
--- /dev/null
+++ b/drizzle-orm/src/valibot/schema.types.internal.ts
@@ -0,0 +1,85 @@
+import type * as v from 'valibot';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { GetValibotTypeFromColumn, HandleColumn } from './column.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type BuildRefineField<T> = T extends v.GenericSchema ? ((schema: T) => v.GenericSchema) | v.GenericSchema : never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+> = {
+	[
+		K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K
+			: never
+	]?: TColumns[K] extends Column ? BuildRefineField<
+			GetValibotTypeFromColumn<
+				TColumns[K]
+			>
+		>
+		: BuildRefine<GetSelection<TColumns[K]>>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (schema: any) => v.GenericSchema ? (
+		TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
+			: v.NullableSchema<ReturnType<TRefinement>, undefined>
+	) extends infer TSchema ? TType extends 'update' ? v.OptionalSchema<Assume<TSchema, v.GenericSchema>, undefined>
+		: TSchema
+	: v.AnySchema
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object ? TRefinements[TKey] extends v.GenericSchema | ((schema: any) => any) ? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+> = v.ObjectSchema<
+	Simplify<
+		{
+			readonly [
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column
+				? IsRefinementDefined<TRefinements, Assume<K, string>> extends true
+					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, v.GenericSchema>
+				: HandleColumn<TType, TColumn>
+				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TObject>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
+					>
+				: v.AnySchema;
+		}
+	>,
+	undefined
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare
+		? TRefinement[K] extends Record<string, v.GenericSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/valibot/schema.types.ts b/drizzle-orm/src/valibot/schema.types.ts
new file mode 100644
index 0000000000..bc84d813f4
--- /dev/null
+++ b/drizzle-orm/src/valibot/schema.types.ts
@@ -0,0 +1,53 @@
+import type * as v from 'valibot';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { EnumValuesToReadonlyEnum } from '../utils.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns']>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields']>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(
+		enum_: TEnum,
+	): v.EnumSchema<EnumValuesToReadonlyEnum<TEnum['enumValues']>, undefined>;
+}
+
+export interface CreateInsertSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
+}
+
+export interface CreateUpdateSchema {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
+}
diff --git a/drizzle-orm/src/vercel-postgres/codecs.ts b/drizzle-orm/src/vercel-postgres/codecs.ts
new file mode 100644
index 0000000000..0c0275fe03
--- /dev/null
+++ b/drizzle-orm/src/vercel-postgres/codecs.ts
@@ -0,0 +1,89 @@
+import { parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const vercelPgCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+	},
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'date:string': {
+		castArray: castToTextArr,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+	},
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+	},
+	interval: {
+		castArray: castToTextArr,
+	},
+	// driver handles objects, other types need to be stringified
+	json: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	jsonb: {
+		normalizeParam: (v) => typeof v === 'object' && !Array.isArray(v) ? v : JSON.stringify(v),
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+	},
+	sparsevec: {
+		normalizeArray: parsePgArray,
+	},
+});
diff --git a/drizzle-orm/src/vercel-postgres/driver.ts b/drizzle-orm/src/vercel-postgres/driver.ts
index c7f18c7739..bc6501b1ed 100644
--- a/drizzle-orm/src/vercel-postgres/driver.ts
+++ b/drizzle-orm/src/vercel-postgres/driver.ts
@@ -1,57 +1,30 @@
 import { sql } from '@vercel/postgres';
-import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
-import { PgDialect } from '~/pg-core/index.ts';
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
-} from '~/relations.ts';
-import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { isConfig, jitCompatCheck } from '~/utils.ts';
+import { vercelPgCodecs } from './codecs.ts';
 import { type VercelPgClient, type VercelPgQueryResultHKT, VercelPgSession } from './session.ts';
 
-export interface VercelPgDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class VercelPgDriver {
-	static readonly [entityKind]: string = 'VercelPgDriver';
-
-	constructor(
-		private client: VercelPgClient,
-		private dialect: PgDialect,
-		private options: VercelPgDriverOptions = {},
-	) {
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): VercelPgSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new VercelPgSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-}
-
-export class VercelPgDatabase<
-	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<VercelPgQueryResultHKT, TSchema> {
+export class VercelPgDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<VercelPgQueryResultHKT, TRelations>
+{
 	static override readonly [entityKind]: string = 'VercelPgDatabase';
 }
 
-function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+function construct<TRelations extends AnyRelations = EmptyRelations>(
 	client: VercelPgClient,
-	config: DrizzleConfig<TSchema> = {},
-): VercelPgDatabase<TSchema> & {
+	config: DrizzlePgConfig<TRelations> = {},
+): VercelPgDatabase<TRelations> & {
 	$client: VercelPgClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? vercelPgCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -59,22 +32,16 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(
-			config.schema,
-			createTableRelationsHelpers,
-		);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new VercelPgDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
-	const db = new VercelPgDatabase(dialect, session, schema as any) as VercelPgDatabase<TSchema>;
+	const relations = config.relations ?? {} as TRelations;
+	const session = new VercelPgSession(client, dialect, relations ?? {} as EmptyRelations, {
+		logger,
+		cache: config.cache,
+	});
+	const db = new VercelPgDatabase(
+		dialect,
+		session,
+		relations,
+	) as VercelPgDatabase<TRelations>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -85,37 +52,42 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 }
 
 export function drizzle<
-	TSchema extends Record<string, unknown> = Record<string, never>,
+	TRelations extends AnyRelations = EmptyRelations,
 	TClient extends VercelPgClient = typeof sql,
 >(
 	...params: [] | [
 		TClient,
 	] | [
 		TClient,
-		DrizzleConfig<TSchema>,
+		DrizzlePgConfig<TRelations>,
 	] | [
 		(
-			& DrizzleConfig<TSchema>
+			& DrizzlePgConfig<TRelations>
 			& ({
 				client?: TClient;
 			})
 		),
 	]
-): VercelPgDatabase<TSchema> & {
-	$client: TClient;
+): VercelPgDatabase<TRelations> & {
+	$client: VercelPgClient extends TClient ? typeof sql : TClient;
 } {
 	if (isConfig(params[0])) {
-		const { client, ...drizzleConfig } = params[0] as ({ client?: TClient } & DrizzleConfig<TSchema>);
-		return construct(client ?? sql, drizzleConfig) as any;
+		const { client, ...DrizzlePgConfig } = params[0] as ({ client?: TClient } & DrizzlePgConfig<TRelations>);
+		return construct(client ?? sql, DrizzlePgConfig) as any;
 	}
 
-	return construct((params[0] ?? sql) as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+	return construct(
+		(params[0] ?? sql) as TClient,
+		params[1] as DrizzlePgConfig<TRelations> | undefined,
+	) as any;
 }
 
 export namespace drizzle {
-	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
-		config?: DrizzleConfig<TSchema>,
-	): VercelPgDatabase<TSchema> & {
+	export function mock<
+		TRelations extends AnyRelations = EmptyRelations,
+	>(
+		config?: DrizzlePgConfig<TRelations>,
+	): VercelPgDatabase<TRelations> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({} as any, config) as any;
diff --git a/drizzle-orm/src/vercel-postgres/index.ts b/drizzle-orm/src/vercel-postgres/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/vercel-postgres/index.ts
+++ b/drizzle-orm/src/vercel-postgres/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/vercel-postgres/migrator.ts b/drizzle-orm/src/vercel-postgres/migrator.ts
index 88c922271c..7d56454c38 100644
--- a/drizzle-orm/src/vercel-postgres/migrator.ts
+++ b/drizzle-orm/src/vercel-postgres/migrator.ts
@@ -1,11 +1,13 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
+import { migrate as coreMigrate } from '~/pg-core/async/session.ts';
+import type { AnyRelations } from '~/relations.ts';
 import type { VercelPgDatabase } from './driver.ts';
 
-export async function migrate<TSchema extends Record<string, unknown>>(
-	db: VercelPgDatabase<TSchema>,
+export async function migrate<TRelations extends AnyRelations>(
+	db: VercelPgDatabase<TRelations>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	await db.dialect.migrate(migrations, db.session, config);
+	return await coreMigrate(migrations, db, config);
 }
diff --git a/drizzle-orm/src/vercel-postgres/session.ts b/drizzle-orm/src/vercel-postgres/session.ts
index c20c0b223a..f825d994a5 100644
--- a/drizzle-orm/src/vercel-postgres/session.ts
+++ b/drizzle-orm/src/vercel-postgres/session.ts
@@ -1,6 +1,4 @@
 import {
-	type QueryArrayConfig,
-	type QueryConfig,
 	type QueryResult,
 	type QueryResultRow,
 	types,
@@ -8,187 +6,50 @@ import {
 	VercelPool,
 	type VercelPoolClient,
 } from '@vercel/postgres';
+import type { CustomTypesConfig } from 'pg';
 import type { Cache } from '~/cache/core/cache.ts';
 import { NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import { type Logger, NoopLogger } from '~/logger.ts';
-import { type PgDialect, PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, PgAsyncTransaction } from '~/pg-core/async/session.ts';
+import type { PgDialect } from '~/pg-core/index.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
-import { type Assume, mapResultRow } from '~/utils.ts';
+import { preparedStatementName } from '~/query-name-generator.ts';
+import type { AnyRelations } from '~/relations.ts';
+import { type Query, sql } from '~/sql/sql.ts';
+import type { Assume } from '~/utils.ts';
 
 export type VercelPgClient = VercelPool | VercelClient | VercelPoolClient;
 
-export class VercelPgPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'VercelPgPreparedQuery';
-
-	private rawQuery: QueryConfig;
-	private queryConfig: QueryArrayConfig;
-
-	constructor(
-		private client: VercelPgClient,
-		queryString: string,
-		private params: unknown[],
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
-		this.rawQuery = {
-			name,
-			text: queryString,
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val: any) => val;
-					}
-					// numeric[]
-					if (typeId === 1231 as any) {
-						return (val: any) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115 as any) {
-						return (val: any) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185 as any) {
-						return (val: any) => val;
-					}
-					// interval[]
-					if (typeId === 1187 as any) {
-						return (val: any) => val;
-					}
-					// date[]
-					if (typeId === 1182 as any) {
-						return (val: any) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-		this.queryConfig = {
-			name,
-			text: queryString,
-			rowMode: 'array',
-			types: {
-				// @ts-ignore
-				getTypeParser: (typeId, format) => {
-					if (typeId === types.builtins.TIMESTAMPTZ) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.TIMESTAMP) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.DATE) {
-						return (val: any) => val;
-					}
-					if (typeId === types.builtins.INTERVAL) {
-						return (val: any) => val;
-					}
-					// numeric[]
-					if (typeId === 1231 as any) {
-						return (val: any) => val;
-					}
-					// timestamp[]
-					if (typeId === 1115 as any) {
-						return (val: any) => val;
-					}
-					// timestamp with timezone[]
-					if (typeId === 1185 as any) {
-						return (val: any) => val;
-					}
-					// interval[]
-					if (typeId === 1187 as any) {
-						return (val: any) => val;
-					}
-					// date[]
-					if (typeId === 1182 as any) {
-						return (val: any) => val;
-					}
-					// @ts-ignore
-					return types.getTypeParser(typeId, format);
-				},
-			},
-		};
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-
-		this.logger.logQuery(this.rawQuery.text, params);
-
-		const { fields, rawQuery, client, queryConfig: query, joinsNotNullableMap, customResultMapper } = this;
-		if (!fields && !customResultMapper) {
-			return this.queryWithCache(rawQuery.text, params, async () => {
-				return await client.query(rawQuery, params);
-			});
-		}
-
-		const { rows } = await this.queryWithCache(query.text, params, async () => {
-			return await client.query(query, params);
-		});
-
-		if (customResultMapper) {
-			return customResultMapper(rows);
-		}
-
-		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		this.logger.logQuery(this.rawQuery.text, params);
-		return this.queryWithCache(this.rawQuery.text, params, async () => {
-			return await this.client.query(this.rawQuery, params);
-		}).then((result) => result.rows);
-	}
-
-	values(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['values']> {
-		const params = fillPlaceholders(this.params, placeholderValues);
-		this.logger.logQuery(this.rawQuery.text, params);
-		return this.queryWithCache(this.queryConfig.text, params, async () => {
-			return await this.client.query(this.queryConfig, params);
-		}).then((result) => result.rows);
-	}
-
-	/** @internal */
-	isResponseInArrayMode(): boolean {
-		return this._isResponseInArrayMode;
-	}
-}
-
 export interface VercelPgSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
+const noop = (val: any) => val;
+const typeConfig: CustomTypesConfig = {
+	getTypeParser: <CustomTypesConfig['getTypeParser']> ((typeId, format) => {
+		switch (typeId as number) {
+			case types.builtins.TIMESTAMPTZ:
+			case types.builtins.TIMESTAMP:
+			case types.builtins.DATE:
+			case types.builtins.INTERVAL:
+			case 1231: // numeric[]
+			case 1115: // timestamp[]
+			case 1185: // timestamp with timezone[]
+			case 1187: // interval[]
+			case 1182: // date[]
+				return noop;
+			default:
+				return types.getTypeParser(typeId, format);
+		}
+	}),
+};
+
 export class VercelPgSession<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgSession<VercelPgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncSession<VercelPgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'VercelPgSession';
 
 	private logger: Logger;
@@ -197,7 +58,7 @@ export class VercelPgSession<
 	constructor(
 		private client: VercelPgClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: VercelPgSessionOptions = {},
 	) {
 		super(dialect);
@@ -207,62 +68,56 @@ export class VercelPgSession<
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new VercelPgPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
+	) {
+		const queryName = typeof name === 'string'
+			? name
+			: name === true
+			? preparedStatementName(query.sql, query.params)
+			: undefined;
+
+		const executor = async (params?: unknown[]) => {
+			return this.client.query({
+				name: queryName,
+				rowMode: mode === 'arrays' ? 'array' : undefined as any,
+				text: query.sql,
+				types: typeConfig,
+			}, params).then((r) => mode === 'raw' ? r : r.rows);
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
+			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			name,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
-	async query(query: string, params: unknown[]): Promise<QueryResult> {
-		this.logger.logQuery(query, params);
-		const result = await this.client.query({
-			rowMode: 'array',
-			text: query,
-			values: params,
-		});
-		return result;
-	}
-
-	async queryObjects<T extends QueryResultRow>(
-		query: string,
-		params: unknown[],
-	): Promise<QueryResult<T>> {
-		return this.client.query<T>(query, params);
-	}
-
-	override async count(sql: SQL): Promise<number> {
-		const result = await this.execute(sql);
-
-		return Number((result as any)['rows'][0]['count']);
-	}
-
 	override async transaction<T>(
-		transaction: (tx: VercelPgTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: VercelPgTransaction<TRelations>) => Promise<T>,
 		config?: PgTransactionConfig | undefined,
 	): Promise<T> {
-		const session = this.client instanceof VercelPool // eslint-disable-line no-instanceof/no-instanceof
-			? new VercelPgSession(await this.client.connect(), this.dialect, this.schema, this.options)
+		const session = typeof this.client === 'function' || this.client instanceof VercelPool // oxlint-disable-line drizzle-internal/no-instanceof
+			? new VercelPgSession(await this.client.connect(), this.dialect, this.relations, this.options)
 			: this;
-		const tx = new VercelPgTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+		const tx = new VercelPgTransaction<TRelations>(
+			this.dialect,
+			session,
+			this.relations,
+			undefined,
+			false,
+		);
 		await tx.execute(sql`begin${config ? sql` ${tx.getTransactionConfigSQL(config)}` : undefined}`);
 		try {
 			const result = await transaction(tx);
@@ -272,7 +127,7 @@ export class VercelPgSession<
 			await tx.execute(sql`rollback`);
 			throw error;
 		} finally {
-			if (this.client instanceof VercelPool) { // eslint-disable-line no-instanceof/no-instanceof
+			if (typeof this.client === 'function' || this.client instanceof VercelPool) { // oxlint-disable-line drizzle-internal/no-instanceof
 				(session.client as VercelPoolClient).release();
 			}
 		}
@@ -280,20 +135,20 @@ export class VercelPgSession<
 }
 
 export class VercelPgTransaction<
-	TFullSchema extends Record<string, unknown>,
-	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<VercelPgQueryResultHKT, TFullSchema, TSchema> {
+	TRelations extends AnyRelations,
+> extends PgAsyncTransaction<VercelPgQueryResultHKT, TRelations> {
 	static override readonly [entityKind]: string = 'VercelPgTransaction';
 
 	override async transaction<T>(
-		transaction: (tx: VercelPgTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: VercelPgTransaction<TRelations>) => Promise<T>,
 	): Promise<T> {
 		const savepointName = `sp${this.nestedIndex + 1}`;
-		const tx = new VercelPgTransaction<TFullSchema, TSchema>(
+		const tx = new VercelPgTransaction<TRelations>(
 			this.dialect,
 			this.session,
-			this.schema,
+			this._.relations,
 			this.nestedIndex + 1,
+			false,
 		);
 		await tx.execute(sql.raw(`savepoint ${savepointName}`));
 		try {
diff --git a/drizzle-orm/src/version.ts b/drizzle-orm/src/version.ts
index 6f22d27b39..d4e88393ee 100644
--- a/drizzle-orm/src/version.ts
+++ b/drizzle-orm/src/version.ts
@@ -1,4 +1,7 @@
 // @ts-ignore - imported using Rollup json plugin
 export { version as npmVersion } from '../package.json';
 // In version 7, we changed the PostgreSQL indexes API
-export const compatibilityVersion = 10;
+// In version 12, we changed the migration folder structure and migrate function
+// In version 13, we added node-sqlite driver support in orm and kit
+// In version 14, we remade casing api (db instance's config => db entity constructors)
+export const compatibilityVersion = 14;
diff --git a/drizzle-orm/src/xata-http/codecs.ts b/drizzle-orm/src/xata-http/codecs.ts
new file mode 100644
index 0000000000..3224bcae10
--- /dev/null
+++ b/drizzle-orm/src/xata-http/codecs.ts
@@ -0,0 +1,173 @@
+import { makePgArray, parsePgArray } from '~/pg-core/array.ts';
+import {
+	arrayCompatNormalize,
+	arrayCompatNormalizeInput,
+	castToText,
+	castToTextArr,
+	parseGeometryTuple,
+	parseGeometryXY,
+	parsePgArrayAndNormalize,
+	refineGenericPgCodecs,
+	textToDate,
+	textToDateWithTz,
+} from '~/pg-core/codecs.ts';
+
+export const xataHttpCodecs = refineGenericPgCodecs({
+	bigint: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	bigserial: {
+		normalize: BigInt,
+		normalizeArray: arrayCompatNormalize(BigInt),
+		normalizeParamArray: makePgArray,
+	},
+	bit: {
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	json: {
+		castParam: (name) => `${name}::json`,
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	jsonb: {
+		castParam: (name) => `${name}::jsonb`,
+		normalizeParamArray: arrayCompatNormalizeInput((v) => JSON.stringify(v), true),
+	},
+	interval: {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	point: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'point:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	line: {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'line:tuple': {
+		cast: castToText,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	macaddr8: {
+		castArrayInJson: castToTextArr,
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	bool: { normalizeParamArray: makePgArray },
+	box: { normalizeParamArray: makePgArray },
+	box2d: { normalizeParamArray: makePgArray },
+	box3d: { normalizeParamArray: makePgArray },
+	char: { normalizeParamArray: makePgArray },
+	cidr: { normalizeParamArray: makePgArray },
+	circle: { normalizeParamArray: makePgArray },
+	datemultirange: { normalizeParamArray: makePgArray },
+	daterange: { normalizeParamArray: makePgArray },
+	float8: { normalizeParamArray: makePgArray },
+	'geography(point)': { normalizeParamArray: makePgArray },
+	'geography(point):tuple': { normalizeParamArray: makePgArray },
+	inet: { normalizeParamArray: makePgArray },
+	int4multirange: { normalizeParamArray: makePgArray },
+	int4range: { normalizeParamArray: makePgArray },
+	int8multirange: { normalizeParamArray: makePgArray },
+	int8range: { normalizeParamArray: makePgArray },
+	lseg: { normalizeParamArray: makePgArray },
+	macaddr: { normalizeParamArray: makePgArray },
+	money: { normalizeParamArray: makePgArray },
+	nummultirange: { normalizeParamArray: makePgArray },
+	numrange: { normalizeParamArray: makePgArray },
+	oid: { normalizeParamArray: makePgArray },
+	path: { normalizeParamArray: makePgArray },
+	polygon: { normalizeParamArray: makePgArray },
+	raster: { normalizeParamArray: makePgArray },
+	regclass: { normalizeParamArray: makePgArray },
+	regconfig: { normalizeParamArray: makePgArray },
+	regdictionary: { normalizeParamArray: makePgArray },
+	regnamespace: { normalizeParamArray: makePgArray },
+	regoper: { normalizeParamArray: makePgArray },
+	regoperator: { normalizeParamArray: makePgArray },
+	regproc: { normalizeParamArray: makePgArray },
+	regprocedure: { normalizeParamArray: makePgArray },
+	regrole: { normalizeParamArray: makePgArray },
+	regtype: { normalizeParamArray: makePgArray },
+	serial: { normalizeParamArray: makePgArray },
+	smallint: { normalizeParamArray: makePgArray },
+	smallserial: { normalizeParamArray: makePgArray },
+	text: { normalizeParamArray: makePgArray },
+	time: { normalizeParamArray: makePgArray },
+	timetz: { normalizeParamArray: makePgArray },
+	tsmultirange: { normalizeParamArray: makePgArray },
+	tsquery: { normalizeParamArray: makePgArray },
+	tsrange: { normalizeParamArray: makePgArray },
+	tstzmultirange: { normalizeParamArray: makePgArray },
+	tstzrange: { normalizeParamArray: makePgArray },
+	tsvector: { normalizeParamArray: makePgArray },
+	varbit: { normalizeParamArray: makePgArray },
+	varchar: { normalizeParamArray: makePgArray },
+	xml: { normalizeParamArray: makePgArray },
+	bytea: { normalizeParamArray: makePgArray },
+	enum: { normalizeParamArray: makePgArray },
+	'geometry(point)': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryXY),
+		normalizeParamArray: makePgArray,
+	},
+	'geometry(point):tuple': {
+		normalizeArray: parsePgArrayAndNormalize(parseGeometryTuple),
+		normalizeParamArray: makePgArray,
+	},
+	numeric: { normalizeParamArray: makePgArray },
+	'numeric:number': { normalizeParamArray: makePgArray },
+	'numeric:bigint': { normalizeParamArray: makePgArray },
+	'bigint:number': { normalizeParamArray: makePgArray },
+	'bigint:string': { normalizeParamArray: makePgArray },
+	'bigserial:number': { normalizeParamArray: makePgArray },
+	float4: { normalizeParamArray: makePgArray },
+	int: { normalizeParamArray: makePgArray },
+	uuid: { normalizeParamArray: makePgArray },
+	date: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'date:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	timestamp: {
+		castArray: castToTextArr,
+		normalize: textToDateWithTz,
+		normalizeArray: arrayCompatNormalize(textToDateWithTz),
+		normalizeParamArray: makePgArray,
+	},
+	timestamptz: {
+		castArray: castToTextArr,
+		normalize: textToDate,
+		normalizeArray: arrayCompatNormalize(textToDate),
+		normalizeParamArray: makePgArray,
+	},
+	'timestamp:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	'timestamptz:string': {
+		castArray: castToTextArr,
+		normalizeParamArray: makePgArray,
+	},
+	halfvec: { normalizeParamArray: makePgArray },
+	sparsevec: {
+		normalizeArray: parsePgArray,
+		normalizeParamArray: makePgArray,
+	},
+	vector: { normalizeParamArray: makePgArray },
+});
diff --git a/drizzle-orm/src/xata-http/driver.ts b/drizzle-orm/src/xata-http/driver.ts
index e878ae6a98..34c43c3a40 100644
--- a/drizzle-orm/src/xata-http/driver.ts
+++ b/drizzle-orm/src/xata-http/driver.ts
@@ -1,61 +1,33 @@
-import type { Cache } from '~/cache/core/cache.ts';
 import { entityKind } from '~/entity.ts';
-import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
-import { PgDatabase } from '~/pg-core/db.ts';
+import { PgAsyncDatabase } from '~/pg-core/async/db.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
-import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { createTableRelationsHelpers, extractTablesRelationalConfig } from '~/relations.ts';
-import type { DrizzleConfig } from '~/utils.ts';
+import type { DrizzlePgConfig } from '~/pg-core/utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
+import { jitCompatCheck } from '~/utils.ts';
+import { xataHttpCodecs } from './codecs.ts';
 import type { XataHttpClient, XataHttpQueryResultHKT } from './session.ts';
 import { XataHttpSession } from './session.ts';
 
-export interface XataDriverOptions {
-	logger?: Logger;
-	cache?: Cache;
-}
-
-export class XataHttpDriver {
-	static readonly [entityKind]: string = 'XataDriver';
-
-	constructor(
-		private client: XataHttpClient,
-		private dialect: PgDialect,
-		private options: XataDriverOptions = {},
-	) {
-		this.initMappers();
-	}
-
-	createSession(
-		schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined,
-	): XataHttpSession<Record<string, unknown>, TablesRelationalConfig> {
-		return new XataHttpSession(this.client, this.dialect, schema, {
-			logger: this.options.logger,
-			cache: this.options.cache,
-		});
-	}
-
-	initMappers() {
-		// TODO: Add custom type parsers
-	}
-}
-
-export class XataHttpDatabase<TSchema extends Record<string, unknown> = Record<string, never>>
-	extends PgDatabase<XataHttpQueryResultHKT, TSchema>
+export class XataHttpDatabase<TRelations extends AnyRelations = EmptyRelations>
+	extends PgAsyncDatabase<XataHttpQueryResultHKT, TRelations>
 {
 	static override readonly [entityKind]: string = 'XataHttpDatabase';
 
 	/** @internal */
-	declare readonly session: XataHttpSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+	declare readonly session: XataHttpSession<TRelations>;
 }
 
-export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+export function drizzle<TRelations extends AnyRelations = EmptyRelations>(
 	client: XataHttpClient,
-	config: DrizzleConfig<TSchema> = {},
-): XataHttpDatabase<TSchema> & {
+	config: DrizzlePgConfig<TRelations> = {},
+): XataHttpDatabase<TRelations> & {
 	$client: XataHttpClient;
 } {
-	const dialect = new PgDialect({ casing: config.casing });
+	const dialect = new PgDialect({
+		useJitMappers: jitCompatCheck(config.jit),
+		codecs: config.codecs ?? xataHttpCodecs,
+	});
 	let logger;
 	if (config.logger === true) {
 		logger = new DefaultLogger();
@@ -63,23 +35,16 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 		logger = config.logger;
 	}
 
-	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
-	if (config.schema) {
-		const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
-		schema = {
-			fullSchema: config.schema,
-			schema: tablesConfig.tables,
-			tableNamesMap: tablesConfig.tableNamesMap,
-		};
-	}
-
-	const driver = new XataHttpDriver(client, dialect, { logger, cache: config.cache });
-	const session = driver.createSession(schema);
+	const relations = config.relations ?? {} as TRelations;
+	const session = new XataHttpSession(client, dialect, relations ?? {} as EmptyRelations, {
+		logger,
+		cache: config.cache,
+	});
 
 	const db = new XataHttpDatabase(
 		dialect,
 		session,
-		schema as RelationalSchemaConfig<ExtractTablesWithRelations<TSchema>> | undefined,
+		relations,
 	);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
diff --git a/drizzle-orm/src/xata-http/index.ts b/drizzle-orm/src/xata-http/index.ts
index b1b6a52e71..703d940e26 100644
--- a/drizzle-orm/src/xata-http/index.ts
+++ b/drizzle-orm/src/xata-http/index.ts
@@ -1,2 +1,3 @@
+export * from './codecs.ts';
 export * from './driver.ts';
 export * from './session.ts';
diff --git a/drizzle-orm/src/xata-http/migrator.ts b/drizzle-orm/src/xata-http/migrator.ts
index 0eb261d88c..6ec2af2f2a 100644
--- a/drizzle-orm/src/xata-http/migrator.ts
+++ b/drizzle-orm/src/xata-http/migrator.ts
@@ -1,10 +1,15 @@
-import { readMigrationFiles } from '~/migrator.ts';
+import { type MigratorInitFailResponse, readMigrationFiles } from '~/migrator.ts';
+import { getMigrationsToRun } from '~/migrator.utils.ts';
+import type { AnyRelations, EmptyRelations } from '~/relations.ts';
 import { sql } from '~/sql/sql.ts';
+import { upgradeIfNeeded } from '~/up-migrations/pg.ts';
 import type { XataHttpDatabase } from './driver.ts';
 
 export interface MigrationConfig {
 	migrationsFolder: string;
 	migrationsTable?: string;
+	/** @internal */
+	init?: boolean;
 }
 
 /**
@@ -14,42 +19,72 @@ export interface MigrationConfig {
  * no rollback will be executed. Currently, you will need to handle unsuccessful migration yourself.
  * @param db - drizzle db instance
  * @param config - path to migration folder generated by drizzle-kit
- */ export async function migrate<TSchema extends Record<string, unknown>>(
-	db: XataHttpDatabase<TSchema>,
+ */ export async function migrate<
+	TRelations extends AnyRelations = EmptyRelations,
+>(
+	db: XataHttpDatabase<TRelations>,
 	config: MigrationConfig,
-) {
+): Promise<void | MigratorInitFailResponse> {
 	const migrations = readMigrationFiles(config);
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
-	const migrationTableCreate = sql`
+
+	// Detect DB version and upgrade table schema if needed
+	const { newDb } = await upgradeIfNeeded('public', migrationsTable, db, migrations, 'execute');
+
+	if (newDb) {
+		const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
 			id SERIAL PRIMARY KEY,
 			hash text NOT NULL,
-			created_at bigint
+			created_at bigint,
+			name text,
+			applied_at timestamp with time zone DEFAULT now()
 		)
 	`;
-	await db.session.execute(migrationTableCreate);
+		await db.session.execute(migrationTableCreate);
+	}
 
-	const dbMigrations = await db.session.all<{
+	const dbMigrations = await db.session.objects<{
 		id: number;
 		hash: string;
 		created_at: string;
+		name: string | null;
 	}>(
-		sql`select id, hash, created_at from ${sql.identifier(migrationsTable)} order by created_at desc limit 1`,
+		sql`select id, hash, created_at, name from ${sql.identifier(migrationsTable)}`,
 	);
 
-	const lastDbMigration = dbMigrations[0];
+	if (typeof config === 'object' && config.init) {
+		if (dbMigrations.length) {
+			return { exitCode: 'databaseMigrations' as const };
+		}
+
+		if (migrations.length > 1) {
+			return { exitCode: 'localMigrations' as const };
+		}
 
-	for await (const migration of migrations) {
-		if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
-			for (const stmt of migration.sql) {
-				await db.session.execute(sql.raw(stmt));
-			}
+		const [migration] = migrations;
 
-			await db.session.execute(
-				sql`insert into ${
-					sql.identifier(migrationsTable)
-				} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`,
-			);
+		if (!migration) return;
+
+		await db.session.execute(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
+
+		return;
+	}
+
+	const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+	for await (const migration of migrationsToRun) {
+		for (const stmt of migration.sql) {
+			await db.session.execute(sql.raw(stmt));
 		}
+
+		await db.session.execute(
+			sql`insert into ${
+				sql.identifier(migrationsTable)
+			} ("hash", "created_at", "name") values(${migration.hash}, ${migration.folderMillis}, ${migration.name})`,
+		);
 	}
 }
diff --git a/drizzle-orm/src/xata-http/session.ts b/drizzle-orm/src/xata-http/session.ts
index 34806be99e..1ba8e5c232 100644
--- a/drizzle-orm/src/xata-http/session.ts
+++ b/drizzle-orm/src/xata-http/session.ts
@@ -5,14 +5,11 @@ import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import { PgAsyncPreparedQuery, PgAsyncSession, type PgAsyncTransaction } from '~/pg-core/async/session.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import { PgTransaction } from '~/pg-core/index.ts';
-import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { PgPreparedQuery, PgSession } from '~/pg-core/session.ts';
-import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/sql.ts';
-import { mapResultRow } from '~/utils.ts';
+import type { AnyRelations } from '~/relations.ts';
+import type { Query } from '~/sql/sql.ts';
 
 export type XataHttpClient = {
 	sql: SQLPluginResult;
@@ -24,84 +21,15 @@ export interface QueryResults<ArrayMode extends 'json' | 'array'> {
 	rowAsArray: ArrayMode extends 'array' ? true : false;
 }
 
-export class XataHttpPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'XataHttpPreparedQuery';
-
-	constructor(
-		private client: XataHttpClient,
-		query: Query,
-		private logger: Logger,
-		cache: Cache,
-		queryMetadata: {
-			type: 'select' | 'update' | 'delete' | 'insert';
-			tables: string[];
-		} | undefined,
-		cacheConfig: WithCacheConfig | undefined,
-		private fields: SelectedFieldsOrdered | undefined,
-		private _isResponseInArrayMode: boolean,
-		private customResultMapper?: (rows: unknown[][]) => T['execute'],
-	) {
-		super(query, cache, queryMetadata, cacheConfig);
-	}
-
-	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-
-		this.logger.logQuery(this.query.sql, params);
-
-		const { fields, client, query, customResultMapper, joinsNotNullableMap } = this;
-
-		if (!fields && !customResultMapper) {
-			return this.queryWithCache(query.sql, params, async () => {
-				return await client.sql<Record<string, any>>({ statement: query.sql, params });
-			});
-		}
-
-		const { rows, warning } = await this.queryWithCache(query.sql, params, async () => {
-			return await client.sql({ statement: query.sql, params, responseType: 'array' });
-		});
-
-		if (warning) console.warn(warning);
-
-		return customResultMapper
-			? customResultMapper(rows as unknown[][])
-			: rows.map((row) => mapResultRow<T['execute']>(fields!, row as unknown[], joinsNotNullableMap));
-	}
-
-	all(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['all']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-		this.logger.logQuery(this.query.sql, params);
-		return this.queryWithCache(this.query.sql, params, async () => {
-			return this.client.sql({ statement: this.query.sql, params, responseType: 'array' });
-		}).then((result) => result.rows);
-	}
-
-	values(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['values']> {
-		const params = fillPlaceholders(this.query.params, placeholderValues);
-		this.logger.logQuery(this.query.sql, params);
-		return this.queryWithCache(this.query.sql, params, async () => {
-			return this.client.sql({ statement: this.query.sql, params });
-		}).then((result) => result.records);
-	}
-
-	/** @internal */
-	isResponseInArrayMode() {
-		return this._isResponseInArrayMode;
-	}
-}
-
 export interface XataHttpSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class XataHttpSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends PgSession<
-		XataHttpQueryResultHKT,
-		TFullSchema,
-		TSchema
-	>
-{
+export class XataHttpSession<TRelations extends AnyRelations> extends PgAsyncSession<
+	XataHttpQueryResultHKT,
+	TRelations
+> {
 	static override readonly [entityKind]: string = 'XataHttpSession';
 
 	private logger: Logger;
@@ -110,7 +38,7 @@ export class XataHttpSession<TFullSchema extends Record<string, unknown>, TSchem
 	constructor(
 		private client: XataHttpClient,
 		dialect: PgDialect,
-		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		private relations: TRelations,
 		private options: XataHttpSessionOptions = {},
 	) {
 		super(dialect);
@@ -120,52 +48,48 @@ export class XataHttpSession<TFullSchema extends Record<string, unknown>, TSchem
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		isResponseInArrayMode: boolean,
-		customResultMapper?: (rows: unknown[][]) => T['execute'],
+		mode: 'arrays' | 'objects' | 'raw',
+		_name: string | boolean,
+		mapper: ((rows: any[]) => any) | undefined,
 		queryMetadata?: {
 			type: 'select' | 'update' | 'delete' | 'insert';
 			tables: string[];
 		},
 		cacheConfig?: WithCacheConfig,
-	): PgPreparedQuery<T> {
-		return new XataHttpPreparedQuery(
-			this.client,
+	) {
+		const executor = async (params?: unknown[]) => {
+			if (mode === 'raw') return this.client.sql<Record<string, any>>({ statement: query.sql, params });
+			if (mode === 'objects') {
+				return this.client.sql<Record<string, any>>({
+					statement: query.sql,
+					params,
+					responseType: 'json',
+				}).then(({ warning, records }) => {
+					if (warning) console.warn(warning);
+					return records;
+				});
+			}
+
+			return this.client.sql({ statement: query.sql, params, responseType: 'array' }).then(({ warning, rows }) => {
+				if (warning) console.warn(warning);
+				return rows;
+			});
+		};
+
+		return new PgAsyncPreparedQuery<T>(
+			executor,
 			query,
+			mapper,
+			mode,
 			this.logger,
 			this.cache,
 			queryMetadata,
 			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
 		);
 	}
 
-	async query(query: string, params: unknown[]): Promise<QueryResults<'array'>> {
-		this.logger.logQuery(query, params);
-		const result = await this.client.sql({ statement: query, params, responseType: 'array' });
-
-		return {
-			rowCount: result.rows.length,
-			rows: result.rows,
-			rowAsArray: true,
-		};
-	}
-
-	async queryObjects(query: string, params: unknown[]): Promise<QueryResults<'json'>> {
-		const result = await this.client.sql<Record<string, any>>({ statement: query, params });
-
-		return {
-			rowCount: result.records.length,
-			rows: result.records,
-			rowAsArray: false,
-		};
-	}
-
 	override async transaction<T>(
-		_transaction: (tx: XataTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_transaction: (tx: PgAsyncTransaction<XataHttpQueryResultHKT, TRelations>) => Promise<T>,
 		// eslint-disable-next-line @typescript-eslint/no-unused-vars
 		_config: PgTransactionConfig = {},
 	): Promise<T> {
@@ -173,20 +97,6 @@ export class XataHttpSession<TFullSchema extends Record<string, unknown>, TSchem
 	}
 }
 
-export class XataTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig>
-	extends PgTransaction<
-		XataHttpQueryResultHKT,
-		TFullSchema,
-		TSchema
-	>
-{
-	static override readonly [entityKind]: string = 'XataHttpTransaction';
-
-	override async transaction<T>(_transaction: (tx: XataTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T> {
-		throw new Error('No transactions support in Xata Http driver');
-	}
-}
-
 export interface XataHttpQueryResultHKT extends PgQueryResultHKT {
 	type: SQLQueryResult<this['row']>;
 }
diff --git a/drizzle-orm/src/zod/README.md b/drizzle-orm/src/zod/README.md
new file mode 100644
index 0000000000..b46a79317d
--- /dev/null
+++ b/drizzle-orm/src/zod/README.md
@@ -0,0 +1,55 @@
+Allows you to generate [Zod](https://zod.dev/) schemas from Drizzle ORM schemas.
+
+**Features**
+
+- Create a select schema for tables, views and enums.
+- Create insert and update schemas for tables.
+- Supported dialects: CockroachDB, MSSQL, MySQL, PostgreSQL, SingleStore, SQLite.
+
+# Usage
+
+```ts
+import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { z } from 'zod';
+
+const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull(),
+  role: text('role', { enum: ['admin', 'user'] }).notNull(),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+// Schema for inserting a user - can be used to validate API requests
+const insertUserSchema = createInsertSchema(users);
+
+// Schema for updating a user - can be used to validate API requests
+const updateUserSchema = createUpdateSchema(users);
+
+// Schema for selecting a user - can be used to validate API responses
+const selectUserSchema = createSelectSchema(users);
+
+// Overriding the fields
+const insertUserSchema = createInsertSchema(users, {
+  role: z.string(),
+});
+
+// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
+const insertUserSchema = createInsertSchema(users, {
+  id: (schema) => schema.positive(),
+  email: (schema) => schema.email(),
+  role: z.string(),
+});
+
+// Usage
+
+const user = insertUserSchema.parse({
+  name: 'John Doe',
+  email: 'johndoe@test.com',
+  role: 'admin',
+});
+
+// Zod schema type is also inferred from the table schema, so you have full type safety
+const requestSchema = insertUserSchema.pick({ name: true, email: true });
+```
diff --git a/drizzle-orm/src/zod/column.ts b/drizzle-orm/src/zod/column.ts
new file mode 100644
index 0000000000..3dee5fc84f
--- /dev/null
+++ b/drizzle-orm/src/zod/column.ts
@@ -0,0 +1,394 @@
+import { z as zod } from 'zod/v4';
+import {
+	type ColumnDataArrayConstraint,
+	type ColumnDataBigIntConstraint,
+	type ColumnDataNumberConstraint,
+	type ColumnDataObjectConstraint,
+	type ColumnDataStringConstraint,
+	extractExtendedColumnType,
+} from '~/column-builder.ts';
+import { type Column, getColumnTable } from '~/column.ts';
+import { getTableName } from '~/table.ts';
+import { CONSTANTS, type Json } from '../utils.ts';
+import type { CoerceOptions, FactoryOptions } from './schema.types.ts';
+
+export const literalSchema = zod.union([zod.string(), zod.number(), zod.boolean(), zod.null()]);
+export const jsonSchema: zod.ZodType<Json> = zod.union([
+	literalSchema,
+	zod.record(zod.string(), zod.any()),
+	zod.array(zod.any()),
+]);
+export const bufferSchema: zod.ZodType<Buffer> = zod.custom<Buffer>((v) => v instanceof Buffer); // oxlint-disable-line no-instanceof-builtins drizzle-internal/no-instanceof
+
+export function columnToSchema(
+	column: Column,
+	factory:
+		| FactoryOptions
+		| undefined,
+): zod.ZodType {
+	const z: typeof zod = factory?.zodInstance ?? zod;
+	const coerce = factory?.coerce ?? {};
+	let schema!: zod.ZodType;
+
+	// Check for PG array columns (have dimensions property instead of changing dataType)
+	const dimensions = (<{ dimensions?: number }> column).dimensions;
+	if (typeof dimensions === 'number' && dimensions > 0) {
+		return pgArrayColumnToSchema(column, dimensions, z, coerce);
+	}
+
+	const { type, constraint } = extractExtendedColumnType(column);
+
+	switch (type) {
+		case 'array': {
+			schema = arrayColumnToSchema(column, constraint, z, coerce);
+			break;
+		}
+		case 'object': {
+			schema = objectColumnToSchema(column, constraint, z, coerce);
+			break;
+		}
+		case 'number': {
+			schema = numberColumnToSchema(column, constraint, z, coerce);
+			break;
+		}
+		case 'bigint': {
+			schema = bigintColumnToSchema(column, constraint, z, coerce);
+			break;
+		}
+		case 'boolean': {
+			schema = coerce === true || coerce.boolean ? z.coerce.boolean() : z.boolean();
+			break;
+		}
+		case 'string': {
+			schema = stringColumnToSchema(column, constraint, z, coerce);
+			break;
+		}
+		case 'custom': {
+			schema = z.any();
+			break;
+		}
+		default: {
+			schema = z.any();
+		}
+	}
+
+	return schema;
+}
+
+function numberColumnToSchema(
+	column: Column,
+	constraint: ColumnDataNumberConstraint | undefined,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	let min!: number;
+	let max!: number;
+	let integer = false;
+
+	switch (constraint) {
+		case 'int8': {
+			min = CONSTANTS.INT8_MIN;
+			max = CONSTANTS.INT8_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint8': {
+			min = 0;
+			max = CONSTANTS.INT8_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int16': {
+			min = CONSTANTS.INT16_MIN;
+			max = CONSTANTS.INT16_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint16': {
+			min = 0;
+			max = CONSTANTS.INT16_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int24': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint24': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int32': {
+			min = CONSTANTS.INT32_MIN;
+			max = CONSTANTS.INT32_MAX;
+			integer = true;
+			break;
+		}
+		case 'uint32': {
+			min = 0;
+			max = CONSTANTS.INT32_UNSIGNED_MAX;
+			integer = true;
+			break;
+		}
+		case 'int53': {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'uint53': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			integer = true;
+			break;
+		}
+		case 'float': {
+			min = CONSTANTS.INT24_MIN;
+			max = CONSTANTS.INT24_MAX;
+			break;
+		}
+		case 'ufloat': {
+			min = 0;
+			max = CONSTANTS.INT24_UNSIGNED_MAX;
+			break;
+		}
+		case 'double': {
+			min = CONSTANTS.INT48_MIN;
+			max = CONSTANTS.INT48_MAX;
+			break;
+		}
+		case 'udouble': {
+			min = 0;
+			max = CONSTANTS.INT48_UNSIGNED_MAX;
+			break;
+		}
+		case 'year': {
+			min = 1901;
+			max = 2155;
+			integer = true;
+			break;
+		}
+		case 'unsigned': {
+			min = 0;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+		default: {
+			min = Number.MIN_SAFE_INTEGER;
+			max = Number.MAX_SAFE_INTEGER;
+			break;
+		}
+	}
+
+	let schema = coerce === true || coerce?.number
+		? integer ? z.coerce.number().int() : z.coerce.number()
+		: integer
+		? z.int()
+		: z.number();
+	schema = schema.gte(min).lte(max);
+	return schema;
+}
+
+export const bigintStringModeSchema = zod.string().regex(/^-?\d+$/).transform(BigInt).pipe(
+	zod.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+).transform(String);
+
+export const unsignedBigintStringModeSchema = zod.string().regex(/^\d+$/).transform(BigInt).pipe(
+	zod.bigint().gte(0n).lte(CONSTANTS.INT64_MAX),
+).transform(String);
+
+function bigintColumnToSchema(
+	column: Column,
+	constraint: ColumnDataBigIntConstraint | undefined,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	let min!: bigint | undefined;
+	let max!: bigint | undefined;
+
+	switch (constraint) {
+		case 'int64': {
+			min = CONSTANTS.INT64_MIN;
+			max = CONSTANTS.INT64_MAX;
+			break;
+		}
+		case 'uint64': {
+			min = 0n;
+			max = CONSTANTS.INT64_UNSIGNED_MAX;
+			break;
+		}
+	}
+
+	let schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
+
+	if (min !== undefined) schema = schema.min(min);
+	if (max !== undefined) schema = schema.max(max);
+	return schema;
+}
+
+function pgArrayColumnToSchema(
+	column: Column,
+	dimensions: number,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	// PG style: the column IS the base type, with dimensions indicating array depth
+	// Get the base schema from the column's own dataType
+	const [baseType, baseConstraint] = column.dataType.split(' ');
+	let baseSchema: zod.ZodType;
+
+	switch (baseType) {
+		case 'number':
+			baseSchema = numberColumnToSchema(column, baseConstraint as ColumnDataNumberConstraint, z, coerce);
+			break;
+		case 'bigint':
+			baseSchema = bigintColumnToSchema(column, baseConstraint as ColumnDataBigIntConstraint, z, coerce);
+			break;
+		case 'boolean':
+			baseSchema = coerce === true || coerce?.boolean ? z.coerce.boolean() : z.boolean();
+			break;
+		case 'string':
+			baseSchema = stringColumnToSchema(column, baseConstraint as ColumnDataStringConstraint, z, coerce);
+			break;
+		case 'object':
+			baseSchema = objectColumnToSchema(column, baseConstraint as ColumnDataObjectConstraint, z, coerce);
+			break;
+		case 'array':
+			// Handle array types like point, line, etc.
+			baseSchema = arrayColumnToSchema(column, baseConstraint as ColumnDataArrayConstraint, z, coerce);
+			break;
+		default:
+			baseSchema = z.any();
+	}
+
+	// Wrap in arrays based on dimensions
+	// Note: For PG arrays, column.length is the base type's length (e.g., varchar(10)), not array size
+	let schema: zod.ZodType = z.array(baseSchema);
+	for (let i = 1; i < dimensions; i++) {
+		schema = z.array(schema);
+	}
+	return schema;
+}
+
+function arrayColumnToSchema(
+	column: Column,
+	constraint: ColumnDataArrayConstraint | undefined,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	switch (constraint) {
+		case 'geometry':
+		case 'point': {
+			return z.tuple([z.number(), z.number()]);
+		}
+		case 'line': {
+			return z.tuple([z.number(), z.number(), z.number()]);
+		}
+		case 'vector':
+		case 'halfvector': {
+			const length = column.length;
+			return length
+				? z.array(z.number()).length(length)
+				: z.array(z.number());
+		}
+		case 'int64vector': {
+			const length = column.length;
+			return length
+				? z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX)).length(length)
+				: z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX));
+		}
+		case 'basecolumn': {
+			// CockroachDB/GEL style: has a separate baseColumn
+			const baseColumn = (<{ baseColumn?: Column }> column).baseColumn;
+			if (baseColumn) {
+				const baseSchema = columnToSchema(baseColumn, {
+					zodInstance: z,
+					coerce,
+				});
+				// For CockroachDB style, column.length is the array size
+				const length = column.length;
+				const schema: zod.ZodType = z.array(baseSchema);
+				if (length) return (schema as zod.ZodArray<any>).length(length);
+				return schema;
+			}
+			return z.array(z.any());
+		}
+		default: {
+			return z.array(z.any());
+		}
+	}
+}
+
+function objectColumnToSchema(
+	column: Column,
+	constraint: ColumnDataObjectConstraint | undefined,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	switch (constraint) {
+		case 'buffer': {
+			return bufferSchema;
+		}
+		case 'date': {
+			return coerce === true || coerce?.date ? z.coerce.date() : z.date();
+		}
+		case 'geometry':
+		case 'point': {
+			return z.object({
+				x: z.number(),
+				y: z.number(),
+			});
+		}
+		case 'json': {
+			return jsonSchema;
+		}
+		case 'line': {
+			return z.object({
+				a: z.number(),
+				b: z.number(),
+				c: z.number(),
+			});
+		}
+		default: {
+			return z.looseObject({});
+		}
+	}
+}
+
+function stringColumnToSchema(
+	column: Column<any>,
+	constraint: ColumnDataStringConstraint | undefined,
+	z: typeof zod,
+	coerce: CoerceOptions,
+): zod.ZodType {
+	const { name: columnName, length, isLengthExact } = column;
+	let regex: RegExp | undefined;
+
+	if (constraint === 'binary') {
+		regex = /^[01]*$/;
+	}
+	if (constraint === 'uuid') return z.uuid();
+	if (constraint === 'enum') {
+		const enumValues = column.enumValues;
+		if (!enumValues) {
+			throw new Error(
+				`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`,
+			);
+		}
+		return z.enum(enumValues);
+	}
+	if (constraint === 'int64') {
+		return bigintStringModeSchema;
+	}
+	if (constraint === 'uint64') {
+		return unsignedBigintStringModeSchema;
+	}
+
+	let schema = coerce === true || coerce?.string ? z.coerce.string() : z.string();
+	schema = regex ? schema.regex(regex) : schema;
+	return length && isLengthExact ? schema.length(length) : length ? schema.max(length) : schema;
+}
diff --git a/drizzle-orm/src/zod/column.types.ts b/drizzle-orm/src/zod/column.types.ts
new file mode 100644
index 0000000000..c9591255be
--- /dev/null
+++ b/drizzle-orm/src/zod/column.types.ts
@@ -0,0 +1,110 @@
+import type { z } from 'zod/v4';
+import type { ColumnTypeData, ExtractColumnTypeData } from '~/column-builder.ts';
+import type { Column } from '~/column.ts';
+import type { Assume } from '~/utils.ts';
+import type { Json } from '../utils.ts';
+import type { bigintStringModeSchema, unsignedBigintStringModeSchema } from './column.ts';
+import type { CoerceOptions } from './schema.types.ts';
+
+type GetArrayDepth<T, Depth extends number = 0> = Depth extends 5 ? 5
+	: T extends readonly (infer U)[] ? GetArrayDepth<U, [1, 2, 3, 4, 5][Depth]>
+	: Depth;
+
+type WrapInZodArray<TSchema extends z.ZodType, TDepth extends number> = TDepth extends 0 ? TSchema
+	: TDepth extends 1 ? z.ZodArray<TSchema>
+	: TDepth extends 2 ? z.ZodArray<z.ZodArray<TSchema>>
+	: TDepth extends 3 ? z.ZodArray<z.ZodArray<z.ZodArray<TSchema>>>
+	: TDepth extends 4 ? z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<TSchema>>>>
+	: TDepth extends 5 ? z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<TSchema>>>>>
+	: z.ZodArray<z.ZodAny>;
+
+type IsPgArrayColumn<TColumn extends Column<any>, TType extends ColumnTypeData> = TType['type'] extends 'array' ? false // Already handled as explicit array type
+	: GetArrayDepth<TColumn['_']['data']> extends 0 ? false
+	: true;
+
+export type GetZodType<
+	TColumn extends Column<any>,
+	TCoerce extends CoerceOptions,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+	TCanCoerce extends boolean = CanCoerce<TCoerce, ColumnTypeDataToCoerceKey<TType>>,
+> = IsPgArrayColumn<TColumn, TType> extends true
+	? WrapInZodArray<GetBaseZodType<TColumn, TCoerce, TType, TCanCoerce>, GetArrayDepth<TColumn['_']['data']>>
+	: GetBaseZodType<TColumn, TCoerce, TType, TCanCoerce>;
+
+type GetBaseZodType<
+	TColumn extends Column<any>,
+	TCoerce extends CoerceOptions,
+	TType extends ColumnTypeData = ExtractColumnTypeData<TColumn['_']['dataType']>,
+	TCanCoerce extends boolean = CanCoerce<TCoerce, ColumnTypeDataToCoerceKey<TType>>,
+> = TType['type'] extends 'array'
+	? TType['constraint'] extends 'geometry' | 'point' ? z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>
+	: TType['constraint'] extends 'line' ? z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>
+	: TType['constraint'] extends 'vector' | 'halfvector' ? z.ZodArray<z.ZodNumber>
+	: TType['constraint'] extends 'int64vector' ? z.ZodArray<z.ZodBigInt>
+	: TType['constraint'] extends 'basecolumn'
+		? z.ZodArray<GetZodType<Assume<TColumn['_'], { baseColumn: Column<any> }>['baseColumn'], TCoerce>>
+	: z.ZodArray<z.ZodAny>
+	: TType['type'] extends 'object'
+		? TType['constraint'] extends 'date' ? CanCoerce<TCoerce, 'date'> extends true ? z.coerce.ZodCoercedDate : z.ZodDate
+		: TType['constraint'] extends 'buffer' ? z.ZodType<Buffer>
+		: TType['constraint'] extends 'point' | 'geometry' ? z.ZodObject<{ x: z.ZodNumber; y: z.ZodNumber }, z.core.$strip>
+		: TType['constraint'] extends 'line'
+			? z.ZodObject<{ a: z.ZodNumber; b: z.ZodNumber; c: z.ZodNumber }, z.core.$strip>
+		: TType['constraint'] extends 'json' ? z.ZodType<Json>
+		: z.ZodObject<{}, z.core.$loose>
+	: TType['type'] extends 'custom' ? z.ZodType
+	: TType['type'] extends 'number' ? TCanCoerce extends true ? z.coerce.ZodCoercedNumber
+		: (TType['constraint'] extends
+			'int8' | 'int16' | 'int24' | 'int32' | 'int53' | 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint53' | 'year'
+			? z.ZodInt
+			: z.ZodNumber)
+	: TType['type'] extends 'bigint' ? TCanCoerce extends true ? z.coerce.ZodCoercedBigInt : z.ZodBigInt
+	: TType['type'] extends 'boolean' ? TCanCoerce extends true ? z.coerce.ZodCoercedBoolean : z.ZodBoolean
+	: TType['type'] extends 'string'
+		? TType['constraint'] extends 'uuid' ? z.ZodUUID : TCanCoerce extends true ? z.coerce.ZodCoercedString
+		: TType['constraint'] extends 'enum' ? z.ZodEnum<{ [K in Assume<TColumn['_']['enumValues'], string[]>[number]]: K }>
+		: TType['constraint'] extends 'int64' ? typeof bigintStringModeSchema
+		: TType['constraint'] extends 'uint64' ? typeof unsignedBigintStringModeSchema
+		: z.ZodString
+	: z.ZodType;
+
+type ColumnTypeDataToCoerceKey<TType extends ColumnTypeData> = TType['type'] extends
+	'bigint' | 'boolean' | 'number' | 'string' ? TType['type']
+	: TType['type'] extends 'object' ? TType['constraint'] extends 'date' ? TType['constraint'] : 'none'
+	: 'none';
+
+type CanCoerce<
+	TCoerce extends CoerceOptions,
+	TTo extends 'bigint' | 'boolean' | 'date' | 'number' | 'string' | 'none',
+> = TCoerce extends true ? true
+	: TCoerce extends Record<string, any> ? TCoerce[TTo] extends true ? true
+		: false
+	: false;
+
+type HandleSelectColumn<
+	TSchema extends z.ZodType,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TSchema
+	: z.ZodNullable<TSchema>;
+
+type HandleInsertColumn<
+	TSchema extends z.ZodType,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? z.ZodOptional<TSchema>
+	: TSchema
+	: z.ZodOptional<z.ZodNullable<TSchema>>;
+
+type HandleUpdateColumn<
+	TSchema extends z.ZodType,
+	TColumn extends Column,
+> = TColumn['_']['notNull'] extends true ? z.ZodOptional<TSchema>
+	: z.ZodOptional<z.ZodNullable<TSchema>>;
+
+export type HandleColumn<
+	TType extends 'select' | 'insert' | 'update',
+	TColumn extends Column,
+	TCoerce extends CoerceOptions,
+> = TType extends 'select' ? HandleSelectColumn<GetZodType<TColumn, TCoerce>, TColumn>
+	: TType extends 'insert' ? HandleInsertColumn<GetZodType<TColumn, TCoerce>, TColumn>
+	: TType extends 'update' ? HandleUpdateColumn<GetZodType<TColumn, TCoerce>, TColumn>
+	: GetZodType<TColumn, TCoerce>;
diff --git a/drizzle-orm/src/zod/index.ts b/drizzle-orm/src/zod/index.ts
new file mode 100644
index 0000000000..5d00169d6e
--- /dev/null
+++ b/drizzle-orm/src/zod/index.ts
@@ -0,0 +1,11 @@
+export {
+	bigintStringModeSchema,
+	bufferSchema,
+	jsonSchema,
+	literalSchema,
+	unsignedBigintStringModeSchema,
+} from './column.ts';
+export * from './column.types.ts';
+export * from './schema.ts';
+export * from './schema.types.internal.ts';
+export * from './schema.types.ts';
diff --git a/drizzle-orm/src/zod/schema.ts b/drizzle-orm/src/zod/schema.ts
new file mode 100644
index 0000000000..dd1618f9c3
--- /dev/null
+++ b/drizzle-orm/src/zod/schema.ts
@@ -0,0 +1,153 @@
+import { z } from 'zod/v4';
+import { Column } from '~/column.ts';
+import { is } from '~/entity.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import { isView, SQL, type View } from '~/sql/sql.ts';
+import { isTable, type Table } from '~/table.ts';
+import { getColumns } from '~/utils.ts';
+import { isWithEnum } from '../utils.ts';
+import { columnToSchema } from './column.ts';
+import type { Conditions } from './schema.types.internal.ts';
+import type {
+	CoerceOptions,
+	CreateInsertSchema,
+	CreateSchemaFactoryOptions,
+	CreateSelectSchema,
+	CreateUpdateSchema,
+	FactoryOptions,
+} from './schema.types.ts';
+
+function handleColumns(
+	columns: Record<string, any>,
+	refinements: Record<string, any>,
+	conditions: Conditions,
+	factory?: FactoryOptions,
+): z.ZodType {
+	const columnSchemas: Record<string, z.ZodType> = {};
+
+	for (const [key, selected] of Object.entries(columns)) {
+		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
+			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
+			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
+			continue;
+		}
+
+		const refinement = refinements[key];
+		if (refinement !== undefined && typeof refinement !== 'function') {
+			columnSchemas[key] = refinement;
+			continue;
+		}
+
+		const column = is(selected, Column) ? selected : undefined;
+		const schema = column ? columnToSchema(column, factory) : z.any();
+		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
+
+		if (conditions.never(column)) {
+			continue;
+		} else {
+			columnSchemas[key] = refined;
+		}
+
+		if (column) {
+			if (conditions.nullable(column)) {
+				columnSchemas[key] = columnSchemas[key]!.nullable();
+			}
+
+			if (conditions.optional(column)) {
+				columnSchemas[key] = columnSchemas[key]!.optional();
+			}
+		}
+	}
+
+	return z.object(columnSchemas) as any;
+}
+
+function handleEnum(
+	enum_: PgEnum<any>,
+	factory?: FactoryOptions,
+) {
+	const zod: typeof z = factory?.zodInstance ?? z;
+	return zod.enum(enum_.enumValues);
+}
+
+const selectConditions: Conditions = {
+	never: () => false,
+	optional: () => false,
+	nullable: (column) => !column.notNull,
+};
+
+const insertConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
+	nullable: (column) => !column.notNull,
+};
+
+const updateConditions: Conditions = {
+	never: (column) =>
+		column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always'
+		|| ('identity' in (column ?? {}) && typeof (column as any)?.identity !== 'undefined'),
+	optional: () => true,
+	nullable: (column) => !column.notNull,
+};
+
+export const createSelectSchema: CreateSelectSchema<undefined> = (
+	entity: Table | View | PgEnum<[string, ...string[]]>,
+	refine?: Record<string, any>,
+) => {
+	if (isWithEnum(entity)) {
+		return handleEnum(entity);
+	}
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, selectConditions) as any;
+};
+
+export const createInsertSchema: CreateInsertSchema<undefined> = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, insertConditions) as any;
+};
+
+export const createUpdateSchema: CreateUpdateSchema<undefined> = (
+	entity: Table,
+	refine?: Record<string, any>,
+) => {
+	const columns = getColumns(entity);
+	return handleColumns(columns, refine ?? {}, updateConditions) as any;
+};
+
+export function createSchemaFactory<
+	TCoerce extends CoerceOptions,
+>(options?: CreateSchemaFactoryOptions<TCoerce>) {
+	const createSelectSchema: CreateSelectSchema<TCoerce> = (
+		entity: Table | View | PgEnum<[string, ...string[]]>,
+		refine?: Record<string, any>,
+	) => {
+		if (isWithEnum(entity)) {
+			return handleEnum(entity, options);
+		}
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, selectConditions, options) as any;
+	};
+
+	const createInsertSchema: CreateInsertSchema<TCoerce> = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, insertConditions, options) as any;
+	};
+
+	const createUpdateSchema: CreateUpdateSchema<TCoerce> = (
+		entity: Table,
+		refine?: Record<string, any>,
+	) => {
+		const columns = getColumns(entity);
+		return handleColumns(columns, refine ?? {}, updateConditions, options) as any;
+	};
+
+	return { createSelectSchema, createInsertSchema, createUpdateSchema };
+}
diff --git a/drizzle-orm/src/zod/schema.types.internal.ts b/drizzle-orm/src/zod/schema.types.internal.ts
new file mode 100644
index 0000000000..e3921d7dfb
--- /dev/null
+++ b/drizzle-orm/src/zod/schema.types.internal.ts
@@ -0,0 +1,81 @@
+import type { z } from 'zod/v4';
+import type { Column } from '~/column.ts';
+import type { SelectedFieldsFlat } from '~/operations.ts';
+import type { View } from '~/sql/sql.ts';
+import type { Table } from '~/table.ts';
+import type { Assume, DrizzleTypeError, Simplify } from '~/utils.ts';
+import type { ColumnIsGeneratedAlwaysAs, GetSelection } from '../utils.ts';
+import type { GetZodType, HandleColumn } from './column.types.ts';
+import type { CoerceOptions } from './schema.types.ts';
+
+export interface Conditions {
+	never: (column?: Column) => boolean;
+	optional: (column: Column) => boolean;
+	nullable: (column: Column) => boolean;
+}
+
+type BuildRefineField<T> = T extends z.ZodType ? ((schema: T) => z.ZodType) | z.ZodType : never;
+
+export type BuildRefine<
+	TColumns extends Record<string, any>,
+	TCoerce extends CoerceOptions,
+> = {
+	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
+		TColumns[K] extends Column ? BuildRefineField<GetZodType<TColumns[K], TCoerce>>
+			: BuildRefine<GetSelection<TColumns[K]>, TCoerce>;
+};
+
+type HandleRefinement<
+	TType extends 'select' | 'insert' | 'update',
+	TRefinement,
+	TColumn extends Column,
+> = TRefinement extends (schema: any) => z.ZodType ? (TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
+		: z.ZodNullable<ReturnType<TRefinement>>) extends infer TSchema extends z.ZodType
+		? TType extends 'update' ? z.ZodOptional<TSchema> : TSchema
+	: z.ZodType
+	: TRefinement;
+
+type IsRefinementDefined<
+	TRefinements extends Record<string | symbol | number, any> | undefined,
+	TKey extends string | symbol | number,
+> = TRefinements extends object ? TRefinements[TKey] extends z.ZodType | ((schema: any) => any) ? true
+	: false
+	: false;
+
+export type BuildSchema<
+	TType extends 'select' | 'insert' | 'update',
+	TColumns extends Record<string, any>,
+	TRefinements extends Record<string, any> | undefined,
+	TCoerce extends CoerceOptions,
+> = z.ZodObject<
+	Simplify<
+		{
+			[
+				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
+					: never
+					: K
+			]: TColumns[K] extends infer TColumn extends Column
+				? IsRefinementDefined<TRefinements, K> extends true
+					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, z.ZodType>
+				: HandleColumn<TType, TColumn, TCoerce>
+				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
+						TType,
+						GetSelection<TObject>,
+						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined,
+						TCoerce
+					>
+				: z.ZodAny;
+		}
+	>,
+	{ out: {}; in: {} }
+>;
+
+export type NoUnknownKeys<
+	TRefinement extends Record<string, any>,
+	TCompare extends Record<string, any>,
+> = {
+	[K in keyof TRefinement]: K extends keyof TCompare
+		? TRefinement[K] extends Record<string, z.ZodType> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
+		: TRefinement[K]
+		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
+};
diff --git a/drizzle-orm/src/zod/schema.types.ts b/drizzle-orm/src/zod/schema.types.ts
new file mode 100644
index 0000000000..8c46761f79
--- /dev/null
+++ b/drizzle-orm/src/zod/schema.types.ts
@@ -0,0 +1,70 @@
+import type { z } from 'zod/v4';
+import type { CockroachEnum } from '~/cockroach-core/columns/enum.ts';
+import type { PgEnum } from '~/pg-core/columns/enum.ts';
+import type { View } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel, Table } from '~/table.ts';
+import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
+
+export interface CreateSelectSchema<
+	TCoerce extends CoerceOptions,
+> {
+	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined, TCoerce>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<TTable['_']['columns'], TCoerce>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferSelectModel<TTable>>,
+	): BuildSchema<'select', TTable['_']['columns'], TRefine, TCoerce>;
+
+	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined, TCoerce>;
+	<
+		TView extends View,
+		TRefine extends BuildRefine<TView['_']['selectedFields'], TCoerce>,
+	>(
+		view: TView,
+		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
+	): BuildSchema<'select', TView['_']['selectedFields'], TRefine, TCoerce>;
+
+	<TEnum extends PgEnum<any> | CockroachEnum<any>>(enum_: TEnum): z.ZodEnum<{ [K in TEnum['enumValues'][number]]: K }>;
+}
+
+export interface CreateInsertSchema<
+	TCoerce extends CoerceOptions,
+> {
+	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined, TCoerce>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>, TCoerce>,
+	>(
+		table: TTable,
+		refine?: NoUnknownKeys<TRefine, InferInsertModel<TTable>>,
+	): BuildSchema<'insert', TTable['_']['columns'], TRefine, TCoerce>;
+}
+
+export interface CreateUpdateSchema<
+	TCoerce extends CoerceOptions,
+> {
+	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined, TCoerce>;
+	<
+		TTable extends Table,
+		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof InferInsertModel<TTable>>, TCoerce>,
+	>(
+		table: TTable,
+		refine?: TRefine,
+	): BuildSchema<'update', TTable['_']['columns'], TRefine, TCoerce>;
+}
+
+export interface CreateSchemaFactoryOptions<
+	TCoerce extends CoerceOptions,
+> {
+	zodInstance?: any;
+	coerce?: TCoerce;
+}
+
+export type CoerceOptions =
+	| Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>>
+	| true
+	| undefined;
+
+export type FactoryOptions = CreateSchemaFactoryOptions<CoerceOptions>;
diff --git a/drizzle-orm/tests/casing/cockroach-to-camel.test.ts b/drizzle-orm/tests/casing/cockroach-to-camel.test.ts
new file mode 100644
index 0000000000..931a972012
--- /dev/null
+++ b/drizzle-orm/tests/casing/cockroach-to-camel.test.ts
@@ -0,0 +1,278 @@
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { drizzle } from '~/cockroach';
+import { alias, boolean, camelCase, int4, text, union } from '~/cockroach-core';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = camelCase.schema('test');
+const users = camelCase.table('users', {
+	id: int4().primaryKey().generatedByDefaultAsIdentity(),
+	first_name: text().notNull(),
+	last_name: text().notNull(),
+	// Test that custom aliases remain
+	age: int4('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	user_id: int4().primaryKey().generatedByDefaultAsIdentity().references(() => users.id),
+	uses_drizzle_orm: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.user_id],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle.mock({ schema });
+
+const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
+
+describe('cockroach to camel case', () => {
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.user_id));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."userId"',
+			params: [],
+		});
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ first_name: users.first_name })
+			.from(users)
+			.union(db.select({ first_name: users.first_name }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
+			params: [],
+		});
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ first_name: users.first_name }).from(users),
+			db.select({ first_name: users.first_name }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
+			params: [],
+		});
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db._query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
+			params: [1, 1, 1],
+		});
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db._query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						uses_drizzle_orm: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
+			params: [1, 1],
+		});
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.first_name })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do nothing returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name, set: { age: 31 } })
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do update set "AGE" = $4 returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = $1, "lastName" = $2, "AGE" = $3 where "users"."id" = $4 returning "firstName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ first_name: users.first_name, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "firstName", "AGE"',
+			params: [1],
+		});
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "test"."developers" on "userId" = "test"."developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.first_name, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("userFirstName") do update set "AGE" = $4 returning "firstName", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = $1, "lastName" = $2, "AGE" = $3 where "users"."id" = $4 returning "firstName" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "firstName", "AGE" as "usersAge"',
+			params: [1],
+		});
+	});
+});
diff --git a/drizzle-orm/tests/casing/cockroach-to-snake.test.ts b/drizzle-orm/tests/casing/cockroach-to-snake.test.ts
new file mode 100644
index 0000000000..fe48024019
--- /dev/null
+++ b/drizzle-orm/tests/casing/cockroach-to-snake.test.ts
@@ -0,0 +1,280 @@
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { drizzle } from '~/cockroach';
+import { alias, boolean, int4, snakeCase, text, union } from '~/cockroach-core';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = snakeCase.schema('test');
+const users = snakeCase.table('users', {
+	id: int4().primaryKey().generatedByDefaultAsIdentity(),
+	firstName: text().notNull(),
+	lastName: text().notNull(),
+	// Test that custom aliases remain
+	age: int4('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	userId: int4().primaryKey().generatedByDefaultAsIdentity().references(() => users.id),
+	usesDrizzleORM: boolean().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.userId],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle.mock({ schema });
+
+const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
+
+describe('cockroach to snake case', () => {
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.userId));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."user_id"',
+			params: [],
+		});
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
+			params: [],
+		});
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.union(db.select({ firstName: users.firstName }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
+			params: [],
+		});
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.firstName }).from(users),
+			db.select({ firstName: users.firstName }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
+			params: [],
+		});
+	});
+
+	it('query (find first)', ({ expect }) => {
+		const query = db._query.users.findFirst({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
+			params: [1, 1, 1],
+		});
+	});
+
+	it('query (find many)', ({ expect }) => {
+		const query = db._query.users.findMany({
+			columns: {
+				id: true,
+				age: true,
+			},
+			extras: {
+				fullName,
+			},
+			where: eq(users.id, 1),
+			with: {
+				developers: {
+					columns: {
+						usesDrizzleORM: true,
+					},
+				},
+			},
+		});
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
+			params: [1, 1],
+		});
+	});
+
+	it('insert (on conflict do nothing)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoNothing({ target: users.firstName })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do nothing returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('insert (on conflict do update)', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName, set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do update set "AGE" = $4 returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = $1, "last_name" = $2, "AGE" = $3 where "users"."id" = $4 returning "first_name", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "first_name", "AGE"',
+			params: [1],
+		});
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "test"."developers" on "userId" = "test"."developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("userFirstName") do update set "AGE" = $4 returning "first_name", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = $1, "last_name" = $2, "AGE" = $3 where "users"."id" = $4 returning "first_name" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "first_name", "AGE" as "usersAge"',
+			params: [1],
+		});
+	});
+});
diff --git a/drizzle-orm/tests/casing/mssql-to-camel.test.ts b/drizzle-orm/tests/casing/mssql-to-camel.test.ts
new file mode 100644
index 0000000000..c7b32e7b0e
--- /dev/null
+++ b/drizzle-orm/tests/casing/mssql-to-camel.test.ts
@@ -0,0 +1,231 @@
+import mssql from 'mssql';
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { alias, bit, camelCase, int, text, union } from '~/mssql-core';
+import { drizzle } from '~/node-mssql';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = camelCase.schema('test');
+const users = camelCase.table('users', {
+	// TODO: Investigate reasons for existence of next commented line
+	// id: int().primaryKey().identity(1, 1),
+	id: int().primaryKey().identity({
+		seed: 1,
+		increment: 1,
+	}),
+	first_name: text().notNull(),
+	last_name: text().notNull(),
+	// Test that custom aliases remain
+	age: int('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	// TODO: Investigate reasons for existence of next commented line
+	// user_id: int().primaryKey().primaryKey().references('name1', () => users.id),
+	user_id: int().primaryKey().primaryKey().references(() => users.id),
+	uses_drizzle_orm: bit().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.user_id],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle({ client: new mssql.ConnectionPool({ server: '' }), schema });
+
+const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
+
+describe('mssql to camel case', () => {
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select [users].[firstName] || ' ' || [users].[lastName] as [name], [users].[AGE] from [users] left join [test].[developers] on [users].[id] = [test].[developers].[userId] order by [users].[firstName] asc",
+			params: [],
+		});
+	});
+
+	it('select #2', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.user_id))
+			.where(eq(users.id, 15))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select [users].[firstName] || ' ' || [users].[lastName] as [name], [users].[AGE] from [users] left join [test].[developers] on [users].[id] = [test].[developers].[userId] where [users].[id] = @par0 order by [users].[firstName] asc",
+			params: [15],
+		});
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.first_name })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.user_id));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select [users].[firstName] from [users] left join [test].[developers] [devs] on [users].[id] = [devs].[userId]',
+			params: [],
+		});
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with [cte] as (select [firstName] || ' ' || [lastName] as [name] from [users]) select [name] from [cte]",
+			params: [],
+		});
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with [cte] as (select [firstName] || ' ' || [lastName] as [name] from [users]) select [name] from [cte]",
+			params: [],
+		});
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.first_name })
+			.from(users)
+			.union(db.select({ firstName: users.first_name }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select [firstName] from [users]) union (select [firstName] from [users])',
+			params: [],
+		});
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.first_name }).from(users),
+			db.select({ firstName: users.first_name }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select [firstName] from [users]) union (select [firstName] from [users])',
+			params: [],
+		});
+	});
+
+	it('insert', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'insert into [users] ([firstName], [lastName], [AGE]) values (@par0, @par1, @par2)',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'update [users] set [firstName] = @par0, [lastName] = @par1, [AGE] = @par2 where [users].[id] = @par3',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from [users] where [users].[id] = @par0',
+			params: [1],
+		});
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select [AGE] as [ageOfUser], [id] as [userId] from [users] order by [userId] asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select [users].[firstName] || ' ' || [users].[lastName] as [name], [users].[AGE] as [ageOfUser], [users].[id] as [userId] from [users] left join [test].[developers] on [userId] = [test].[developers].[userId] order by [users].[firstName] asc",
+			params: [],
+		});
+	});
+
+	it('insert output as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.output({ firstName: users.first_name, age: users.age.as('userAge') })
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into [users] ([firstName], [lastName], [AGE]) output INSERTED.[firstName], INSERTED.[AGE] as [userAge] values (@par0, @par1, @par2)',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('update output as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.output({
+				inserted: { firstName: users.first_name.as('usersNameIn'), age: users.age.as('ageIn') },
+				deleted: { firstName: users.first_name.as('usersNameOut'), age: users.age.as('ageOut') },
+			})
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update [users] set [firstName] = @par0, [lastName] = @par1, [AGE] = @par2 output INSERTED.[firstName] as [usersNameIn], INSERTED.[AGE] as [ageIn], DELETED.[firstName] as [usersNameOut], DELETED.[AGE] as [ageOut] where [users].[id] = @par3',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete output as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.output({ firstName: users.first_name, age: users.age.as('usersAge') })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from [users] output DELETED.[firstName], DELETED.[AGE] as [usersAge] where [users].[id] = @par0',
+			params: [1],
+		});
+	});
+});
diff --git a/drizzle-orm/tests/casing/mssql-to-snake.test.ts b/drizzle-orm/tests/casing/mssql-to-snake.test.ts
new file mode 100644
index 0000000000..ef6472789c
--- /dev/null
+++ b/drizzle-orm/tests/casing/mssql-to-snake.test.ts
@@ -0,0 +1,216 @@
+import mssql from 'mssql';
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { alias, bit, int, snakeCase, text, union } from '~/mssql-core';
+import { drizzle } from '~/node-mssql';
+import { asc, eq, sql } from '~/sql';
+
+const testSchema = snakeCase.schema('test');
+const users = snakeCase.table('users', {
+	// TODO: Investigate reasons for existence of next commented line
+	// id: int().primaryKey().identity(1, 1),
+	id: int().primaryKey().identity({
+		seed: 1,
+		increment: 1,
+	}),
+	firstName: text().notNull(),
+	lastName: text().notNull(),
+	// Test that custom aliases remain
+	age: int('AGE'),
+});
+const usersRelations = relations(users, ({ one }) => ({
+	developers: one(developers),
+}));
+const developers = testSchema.table('developers', {
+	// TODO: Investigate reasons for existence of next commented line
+	// userId: int().primaryKey().references('name1', () => users.id),
+	userId: int().primaryKey().references(() => users.id),
+	usesDrizzleORM: bit().notNull(),
+});
+const developersRelations = relations(developers, ({ one }) => ({
+	user: one(users, {
+		fields: [developers.userId],
+		references: [users.id],
+	}),
+}));
+const devs = alias(developers, 'devs');
+const schema = { users, usersRelations, developers, developersRelations };
+
+const db = drizzle({ client: new mssql.ConnectionPool({ server: '' }), schema });
+
+const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
+
+describe('mssql to snake case', () => {
+	it('select', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age })
+			.from(users)
+			.leftJoin(developers, eq(users.id, developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select [users].[first_name] || ' ' || [users].[last_name] as [name], [users].[AGE] from [users] left join [test].[developers] on [users].[id] = [test].[developers].[user_id] order by [users].[first_name] asc",
+			params: [],
+		});
+	});
+
+	it('select (with alias)', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.leftJoin(devs, eq(users.id, devs.userId));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select [users].[first_name] from [users] left join [test].[developers] [devs] on [users].[id] = [devs].[user_id]',
+			params: [],
+		});
+	});
+
+	it('with CTE', ({ expect }) => {
+		const cte = db.$with('cte').as(db.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with [cte] as (select [first_name] || ' ' || [last_name] as [name] from [users]) select [name] from [cte]",
+			params: [],
+		});
+	});
+
+	it('with CTE (with query builder)', ({ expect }) => {
+		const cte = db.$with('cte').as((qb) => qb.select({ name: fullName }).from(users));
+		const query = db.with(cte).select().from(cte);
+
+		expect(query.toSQL()).toEqual({
+			sql: "with [cte] as (select [first_name] || ' ' || [last_name] as [name] from [users]) select [name] from [cte]",
+			params: [],
+		});
+	});
+
+	it('set operator', ({ expect }) => {
+		const query = db
+			.select({ firstName: users.firstName })
+			.from(users)
+			.union(db.select({ firstName: users.firstName }).from(users));
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select [first_name] from [users]) union (select [first_name] from [users])',
+			params: [],
+		});
+	});
+
+	it('set operator (function)', ({ expect }) => {
+		const query = union(
+			db.select({ firstName: users.firstName }).from(users),
+			db.select({ firstName: users.firstName }).from(users),
+		);
+
+		expect(query.toSQL()).toEqual({
+			sql: '(select [first_name] from [users]) union (select [first_name] from [users])',
+			params: [],
+		});
+	});
+
+	it('insert', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'insert into [users] ([first_name], [last_name], [AGE]) values (@par0, @par1, @par2)',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('update', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'update [users] set [first_name] = @par0, [last_name] = @par1, [AGE] = @par2 where [users].[id] = @par3',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from [users] where [users].[id] = @par0',
+			params: [1],
+		});
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select [AGE] as [ageOfUser], [id] as [userId] from [users] order by [userId] asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select [users].[first_name] || ' ' || [users].[last_name] as [name], [users].[AGE] as [ageOfUser], [users].[id] as [userId] from [users] left join [test].[developers] on [userId] = [test].[developers].[user_id] order by [users].[first_name] asc",
+			params: [],
+		});
+	});
+
+	it('insert output as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.output({ firstName: users.firstName, age: users.age.as('userAge') })
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into [users] ([first_name], [last_name], [AGE]) output INSERTED.[first_name], INSERTED.[AGE] as [userAge] values (@par0, @par1, @par2)',
+			params: ['John', 'Doe', 30],
+		});
+	});
+
+	it('update output as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.output({
+				inserted: { firstName: users.firstName.as('usersNameIn'), age: users.age.as('ageIn') },
+				deleted: { firstName: users.firstName.as('usersNameOut'), age: users.age.as('ageOut') },
+			})
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update [users] set [first_name] = @par0, [last_name] = @par1, [AGE] = @par2 output INSERTED.[first_name] as [usersNameIn], INSERTED.[AGE] as [ageIn], DELETED.[first_name] as [usersNameOut], DELETED.[AGE] as [ageOut] where [users].[id] = @par3',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete output as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.output({ firstName: users.firstName, age: users.age.as('usersAge') })
+			.where(eq(users.id, 1));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from [users] output DELETED.[first_name], DELETED.[AGE] as [usersAge] where [users].[id] = @par0',
+			params: [1],
+		});
+	});
+});
diff --git a/drizzle-orm/tests/casing/mysql-to-camel.test.ts b/drizzle-orm/tests/casing/mysql-to-camel.test.ts
index 27467154c5..df98c877e6 100644
--- a/drizzle-orm/tests/casing/mysql-to-camel.test.ts
+++ b/drizzle-orm/tests/casing/mysql-to-camel.test.ts
@@ -1,62 +1,30 @@
-import { Client } from '@planetscale/database';
 import { connect } from '@tidbcloud/serverless';
-import { beforeEach, describe, it } from 'vitest';
-import { alias, boolean, int, mysqlSchema, mysqlTable, serial, text, union } from '~/mysql-core';
-import { drizzle as planetscale } from '~/planetscale-serverless';
-import { relations } from '~/relations';
+import { describe, it } from 'vitest';
+import { alias, boolean, camelCase, int, serial, text, union } from '~/mysql-core';
 import { asc, eq, sql } from '~/sql';
 import { drizzle as mysql } from '~/tidb-serverless';
 
-const testSchema = mysqlSchema('test');
-const users = mysqlTable('users', {
+const testSchema = camelCase.schema('test');
+const users = camelCase.table('users', {
 	id: serial().primaryKey(),
 	first_name: text().notNull(),
 	last_name: text().notNull(),
 	// Test that custom aliases remain
 	age: int('AGE'),
 });
-const usersRelations = relations(users, ({ one }) => ({
-	developers: one(developers),
-}));
+
 const developers = testSchema.table('developers', {
 	user_id: serial().primaryKey().references(() => users.id),
 	uses_drizzle_orm: boolean().notNull(),
 });
-const developersRelations = relations(developers, ({ one }) => ({
-	user: one(users, {
-		fields: [developers.user_id],
-		references: [users.id],
-	}),
-}));
-const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
 
-const db = mysql(connect({}), { schema, casing: 'camelCase' });
-const ps = planetscale(new Client({}), { schema, casing: 'camelCase' });
+const devs = alias(developers, 'devs');
 
-const usersCache = {
-	'public.users.id': 'id',
-	'public.users.first_name': 'firstName',
-	'public.users.last_name': 'lastName',
-	'public.users.AGE': 'age',
-};
-const developersCache = {
-	'test.developers.user_id': 'userId',
-	'test.developers.uses_drizzle_orm': 'usesDrizzleOrm',
-};
-const cache = {
-	...usersCache,
-	...developersCache,
-};
+const db = mysql({ client: connect({}) });
 
 const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
 
 describe('mysql to snake case', () => {
-	beforeEach(() => {
-		ps.dialect.casing.clearCache();
-		db.dialect.casing.clearCache();
-	});
-
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -69,7 +37,6 @@ describe('mysql to snake case', () => {
 				"select `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users`.`AGE` from `users` left join `test`.`developers` on `users`.`id` = `test`.`developers`.`userId` order by `users`.`firstName` asc",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -83,7 +50,6 @@ describe('mysql to snake case', () => {
 				'select `users`.`firstName` from `users` left join `test`.`developers` `devs` on `users`.`id` = `devs`.`userId`',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -94,7 +60,6 @@ describe('mysql to snake case', () => {
 			sql: "with `cte` as (select `firstName` || ' ' || `lastName` as `name` from `users`) select `name` from `cte`",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -105,7 +70,6 @@ describe('mysql to snake case', () => {
 			sql: "with `cte` as (select `firstName` || ' ' || `lastName` as `name` from `users`) select `name` from `cte`",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -115,10 +79,10 @@ describe('mysql to snake case', () => {
 			.union(db.select({ firstName: users.first_name }).from(users));
 
 		expect(query.toSQL()).toEqual({
-			sql: '(select `firstName` from `users`) union (select `firstName` from `users`)',
+			sql:
+				'select `firstName` from ((select `firstName` from `users`) union (select `firstName` from `users`)) `drizzle_union`',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -127,123 +91,11 @@ describe('mysql to snake case', () => {
 			db.select({ firstName: users.first_name }).from(users),
 		);
 
-		expect(query.toSQL()).toEqual({
-			sql: '(select `firstName` from `users`) union (select `firstName` from `users`)',
-			params: [],
-		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `users`.`id`, `users`.`AGE`, `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`usesDrizzleOrm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ? limit ?",
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find first, planetscale)', ({ expect }) => {
-		const query = ps.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `id`, `AGE`, `firstName` || ' ' || `lastName` as `name`, (select json_array(`usesDrizzleOrm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ? limit ?",
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(ps.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
 		expect(query.toSQL()).toEqual({
 			sql:
-				"select `users`.`id`, `users`.`AGE`, `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`usesDrizzleOrm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ?",
-			params: [1, 1],
-			typings: ['none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many, planetscale)', ({ expect }) => {
-		const query = ps.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `id`, `AGE`, `firstName` || ' ' || `lastName` as `name`, (select json_array(`usesDrizzleOrm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`userId` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ?",
-			params: [1, 1],
-			typings: ['none', 'none'],
+				'select `firstName` from ((select `firstName` from `users`) union (select `firstName` from `users`)) `drizzle_union`',
+			params: [],
 		});
-		expect(ps.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert', ({ expect }) => {
@@ -255,7 +107,6 @@ describe('mysql to snake case', () => {
 			sql: 'insert into `users` (`id`, `firstName`, `lastName`, `AGE`) values (default, ?, ?, ?)',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on duplicate key update)', ({ expect }) => {
@@ -269,7 +120,6 @@ describe('mysql to snake case', () => {
 				'insert into `users` (`id`, `firstName`, `lastName`, `AGE`) values (default, ?, ?, ?) on duplicate key update `AGE` = ?',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -282,7 +132,6 @@ describe('mysql to snake case', () => {
 			sql: 'update `users` set `firstName` = ?, `lastName` = ?, `AGE` = ? where `users`.`id` = ?',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -294,6 +143,31 @@ describe('mysql to snake case', () => {
 			sql: 'delete from `users` where `users`.`id` = ?',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select `AGE` as `ageOfUser`, `id` as `userId` from `users` order by `userId` asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`firstName` || ' ' || `users`.`lastName` as `name`, `users`.`AGE` as `ageOfUser`, `users`.`id` as `userId` from `users` left join `test`.`developers` on `userId` = `test`.`developers`.`userId` order by `users`.`firstName` asc",
+			params: [],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/casing/mysql-to-snake.test.ts b/drizzle-orm/tests/casing/mysql-to-snake.test.ts
index 8ec228f2d6..4a37dcd246 100644
--- a/drizzle-orm/tests/casing/mysql-to-snake.test.ts
+++ b/drizzle-orm/tests/casing/mysql-to-snake.test.ts
@@ -1,62 +1,33 @@
 import { Client } from '@planetscale/database';
 import { connect } from '@tidbcloud/serverless';
-import { beforeEach, describe, it } from 'vitest';
-import { alias, boolean, int, mysqlSchema, mysqlTable, serial, text, union } from '~/mysql-core';
+import { describe, it } from 'vitest';
+import { alias, boolean, int, serial, snakeCase, text, union } from '~/mysql-core';
 import { drizzle as planetscale } from '~/planetscale-serverless';
-import { relations } from '~/relations';
 import { asc, eq, sql } from '~/sql';
 import { drizzle as mysql } from '~/tidb-serverless';
 
-const testSchema = mysqlSchema('test');
-const users = mysqlTable('users', {
+const testSchema = snakeCase.schema('test');
+const users = snakeCase.table('users', {
 	id: serial().primaryKey(),
 	firstName: text().notNull(),
 	lastName: text().notNull(),
 	// Test that custom aliases remain
 	age: int('AGE'),
 });
-const usersRelations = relations(users, ({ one }) => ({
-	developers: one(developers),
-}));
+
 const developers = testSchema.table('developers', {
 	userId: serial().primaryKey().references(() => users.id),
 	usesDrizzleORM: boolean().notNull(),
 });
-const developersRelations = relations(developers, ({ one }) => ({
-	user: one(users, {
-		fields: [developers.userId],
-		references: [users.id],
-	}),
-}));
-const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
 
-const db = mysql(connect({}), { schema, casing: 'snake_case' });
-const ps = planetscale(new Client({}), { schema, casing: 'snake_case' });
+const devs = alias(developers, 'devs');
 
-const usersCache = {
-	'public.users.id': 'id',
-	'public.users.firstName': 'first_name',
-	'public.users.lastName': 'last_name',
-	'public.users.AGE': 'age',
-};
-const developersCache = {
-	'test.developers.userId': 'user_id',
-	'test.developers.usesDrizzleORM': 'uses_drizzle_orm',
-};
-const cache = {
-	...usersCache,
-	...developersCache,
-};
+const db = mysql({ client: connect({}) });
+const ps = planetscale({ client: new Client({}) });
 
 const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
 
 describe('mysql to snake case', () => {
-	beforeEach(() => {
-		db.dialect.casing.clearCache();
-		ps.dialect.casing.clearCache();
-	});
-
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -69,7 +40,6 @@ describe('mysql to snake case', () => {
 				"select `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users`.`AGE` from `users` left join `test`.`developers` on `users`.`id` = `test`.`developers`.`user_id` order by `users`.`first_name` asc",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -83,7 +53,6 @@ describe('mysql to snake case', () => {
 				'select `users`.`first_name` from `users` left join `test`.`developers` `devs` on `users`.`id` = `devs`.`user_id`',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -94,7 +63,6 @@ describe('mysql to snake case', () => {
 			sql: "with `cte` as (select `first_name` || ' ' || `last_name` as `name` from `users`) select `name` from `cte`",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -105,7 +73,6 @@ describe('mysql to snake case', () => {
 			sql: "with `cte` as (select `first_name` || ' ' || `last_name` as `name` from `users`) select `name` from `cte`",
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -115,10 +82,10 @@ describe('mysql to snake case', () => {
 			.union(db.select({ firstName: users.firstName }).from(users));
 
 		expect(query.toSQL()).toEqual({
-			sql: '(select `first_name` from `users`) union (select `first_name` from `users`)',
+			sql:
+				'select `first_name` from ((select `first_name` from `users`) union (select `first_name` from `users`)) `drizzle_union`',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -127,123 +94,11 @@ describe('mysql to snake case', () => {
 			db.select({ firstName: users.firstName }).from(users),
 		);
 
-		expect(query.toSQL()).toEqual({
-			sql: '(select `first_name` from `users`) union (select `first_name` from `users`)',
-			params: [],
-		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `users`.`id`, `users`.`AGE`, `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`uses_drizzle_orm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ? limit ?",
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find first, planetscale)', ({ expect }) => {
-		const query = ps.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `id`, `AGE`, `first_name` || ' ' || `last_name` as `name`, (select json_array(`uses_drizzle_orm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ? limit ?",
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(ps.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
 		expect(query.toSQL()).toEqual({
 			sql:
-				"select `users`.`id`, `users`.`AGE`, `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users_developers`.`data` as `developers` from `users` `users` left join lateral (select json_array(`users_developers`.`uses_drizzle_orm`) as `data` from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) `users_developers` on true where `users`.`id` = ?",
-			params: [1, 1],
-			typings: ['none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many, planetscale)', ({ expect }) => {
-		const query = ps.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				"select `id`, `AGE`, `first_name` || ' ' || `last_name` as `name`, (select json_array(`uses_drizzle_orm`) from (select * from `test`.`developers` `users_developers` where `users_developers`.`user_id` = `users`.`id` limit ?) `users_developers`) as `developers` from `users` `users` where `users`.`id` = ?",
-			params: [1, 1],
-			typings: ['none', 'none'],
+				'select `first_name` from ((select `first_name` from `users`) union (select `first_name` from `users`)) `drizzle_union`',
+			params: [],
 		});
-		expect(ps.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert', ({ expect }) => {
@@ -255,7 +110,6 @@ describe('mysql to snake case', () => {
 			sql: 'insert into `users` (`id`, `first_name`, `last_name`, `AGE`) values (default, ?, ?, ?)',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on duplicate key update)', ({ expect }) => {
@@ -269,7 +123,6 @@ describe('mysql to snake case', () => {
 				'insert into `users` (`id`, `first_name`, `last_name`, `AGE`) values (default, ?, ?, ?) on duplicate key update `AGE` = ?',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -282,7 +135,6 @@ describe('mysql to snake case', () => {
 			sql: 'update `users` set `first_name` = ?, `last_name` = ?, `AGE` = ? where `users`.`id` = ?',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -294,6 +146,31 @@ describe('mysql to snake case', () => {
 			sql: 'delete from `users` where `users`.`id` = ?',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select `AGE` as `ageOfUser`, `id` as `userId` from `users` order by `userId` asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				"select `users`.`first_name` || ' ' || `users`.`last_name` as `name`, `users`.`AGE` as `ageOfUser`, `users`.`id` as `userId` from `users` left join `test`.`developers` on `userId` = `test`.`developers`.`user_id` order by `users`.`first_name` asc",
+			params: [],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/casing/pg-to-camel.test.ts b/drizzle-orm/tests/casing/pg-to-camel.test.ts
index c377b92c82..a9340aec76 100644
--- a/drizzle-orm/tests/casing/pg-to-camel.test.ts
+++ b/drizzle-orm/tests/casing/pg-to-camel.test.ts
@@ -1,12 +1,12 @@
 import postgres from 'postgres';
-import { beforeEach, describe, it } from 'vitest';
-import { alias, boolean, integer, pgSchema, pgTable, serial, text, union } from '~/pg-core';
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { alias, boolean, camelCase, integer, serial, text, union } from '~/pg-core';
 import { drizzle } from '~/postgres-js';
-import { relations } from '~/relations';
 import { asc, eq, sql } from '~/sql';
 
-const testSchema = pgSchema('test');
-const users = pgTable('users', {
+const testSchema = camelCase.schema('test');
+const users = camelCase.table('users', {
 	id: serial().primaryKey(),
 	first_name: text().notNull(),
 	last_name: text().notNull(),
@@ -27,32 +27,12 @@ const developersRelations = relations(developers, ({ one }) => ({
 	}),
 }));
 const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
-
-const db = drizzle(postgres(''), { schema, casing: 'camelCase' });
-
-const usersCache = {
-	'public.users.id': 'id',
-	'public.users.first_name': 'firstName',
-	'public.users.last_name': 'lastName',
-	'public.users.AGE': 'age',
-};
-const developersCache = {
-	'test.developers.user_id': 'userId',
-	'test.developers.uses_drizzle_orm': 'usesDrizzleOrm',
-};
-const cache = {
-	...usersCache,
-	...developersCache,
-};
+
+const db = drizzle({ client: postgres('') });
 
 const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
 
 describe('postgres to camel case', () => {
-	beforeEach(() => {
-		db.dialect.casing.clearCache();
-	});
-
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -65,7 +45,6 @@ describe('postgres to camel case', () => {
 				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."userId" order by "users"."firstName" asc',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -79,7 +58,6 @@ describe('postgres to camel case', () => {
 				'select "users"."firstName" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."userId"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -90,7 +68,6 @@ describe('postgres to camel case', () => {
 			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -101,7 +78,6 @@ describe('postgres to camel case', () => {
 			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -111,10 +87,10 @@ describe('postgres to camel case', () => {
 			.union(db.select({ first_name: users.first_name }).from(users));
 
 		expect(query.toSQL()).toEqual({
-			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
+			sql:
+				'select "firstName" from ((select "firstName" from "users") union (select "firstName" from "users")) "drizzle_union"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -123,67 +99,11 @@ describe('postgres to camel case', () => {
 			db.select({ first_name: users.first_name }).from(users),
 		);
 
-		expect(query.toSQL()).toEqual({
-			sql: '(select "firstName" from "users") union (select "firstName" from "users")',
-			params: [],
-		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
 		expect(query.toSQL()).toEqual({
 			sql:
-				'select "users"."id", "users"."AGE", "users"."firstName" || \' \' || "users"."lastName" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."usesDrizzleOrm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."userId" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
-			params: [1, 1],
-			typings: ['none', 'none'],
+				'select "firstName" from ((select "firstName" from "users") union (select "firstName" from "users")) "drizzle_union"',
+			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert (on conflict do nothing)', ({ expect }) => {
@@ -198,7 +118,6 @@ describe('postgres to camel case', () => {
 				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do nothing returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on conflict do update)', ({ expect }) => {
@@ -213,7 +132,6 @@ describe('postgres to camel case', () => {
 				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("firstName") do update set "AGE" = $4 returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -228,7 +146,6 @@ describe('postgres to camel case', () => {
 				'update "users" set "firstName" = $1, "lastName" = $2, "AGE" = $3 where "users"."id" = $4 returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -241,6 +158,71 @@ describe('postgres to camel case', () => {
 			sql: 'delete from "users" where "users"."id" = $1 returning "firstName", "AGE"',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "test"."developers" on "userId" = "test"."developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.first_name, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (default, $1, $2, $3) on conflict ("userFirstName") do update set "AGE" = $4 returning "firstName", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = $1, "lastName" = $2, "AGE" = $3 where "users"."id" = $4 returning "firstName" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "firstName", "AGE" as "usersAge"',
+			params: [1],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/casing/pg-to-snake.test.ts b/drizzle-orm/tests/casing/pg-to-snake.test.ts
index 034be0453b..caa02ab997 100644
--- a/drizzle-orm/tests/casing/pg-to-snake.test.ts
+++ b/drizzle-orm/tests/casing/pg-to-snake.test.ts
@@ -1,12 +1,12 @@
 import postgres from 'postgres';
-import { beforeEach, describe, it } from 'vitest';
-import { alias, boolean, integer, pgSchema, pgTable, serial, text, union } from '~/pg-core';
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
+import { alias, boolean, integer, serial, snakeCase, text, union } from '~/pg-core';
 import { drizzle } from '~/postgres-js';
-import { relations } from '~/relations';
 import { asc, eq, sql } from '~/sql';
 
-const testSchema = pgSchema('test');
-const users = pgTable('users', {
+const testSchema = snakeCase.schema('test');
+const users = snakeCase.table('users', {
 	id: serial().primaryKey(),
 	firstName: text().notNull(),
 	lastName: text().notNull(),
@@ -27,9 +27,8 @@ const developersRelations = relations(developers, ({ one }) => ({
 	}),
 }));
 const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
 
-const db = drizzle(postgres(''), { schema, casing: 'snake_case' });
+const db = drizzle({ client: postgres('') });
 
 const usersCache = {
 	'public.users.id': 'id',
@@ -49,10 +48,6 @@ const cache = {
 const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
 
 describe('postgres to snake case', () => {
-	beforeEach(() => {
-		db.dialect.casing.clearCache();
-	});
-
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -65,7 +60,6 @@ describe('postgres to snake case', () => {
 				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" from "users" left join "test"."developers" on "users"."id" = "test"."developers"."user_id" order by "users"."first_name" asc',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -79,7 +73,6 @@ describe('postgres to snake case', () => {
 				'select "users"."first_name" from "users" left join "test"."developers" "devs" on "users"."id" = "devs"."user_id"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -91,7 +84,6 @@ describe('postgres to snake case', () => {
 				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -103,7 +95,6 @@ describe('postgres to snake case', () => {
 				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -113,10 +104,10 @@ describe('postgres to snake case', () => {
 			.union(db.select({ firstName: users.firstName }).from(users));
 
 		expect(query.toSQL()).toEqual({
-			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
+			sql:
+				'select "first_name" from ((select "first_name" from "users") union (select "first_name" from "users")) "drizzle_union"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -125,67 +116,11 @@ describe('postgres to snake case', () => {
 			db.select({ firstName: users.firstName }).from(users),
 		);
 
-		expect(query.toSQL()).toEqual({
-			sql: '(select "first_name" from "users") union (select "first_name" from "users")',
-			params: [],
-		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2 limit $3',
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
 		expect(query.toSQL()).toEqual({
 			sql:
-				'select "users"."id", "users"."AGE", "users"."first_name" || \' \' || "users"."last_name" as "name", "users_developers"."data" as "developers" from "users" "users" left join lateral (select json_build_array("users_developers"."uses_drizzle_orm") as "data" from (select * from "test"."developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit $1) "users_developers") "users_developers" on true where "users"."id" = $2',
-			params: [1, 1],
-			typings: ['none', 'none'],
+				'select "first_name" from ((select "first_name" from "users") union (select "first_name" from "users")) "drizzle_union"',
+			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert (on conflict do nothing)', ({ expect }) => {
@@ -200,7 +135,6 @@ describe('postgres to snake case', () => {
 				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do nothing returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on conflict do update)', ({ expect }) => {
@@ -215,7 +149,6 @@ describe('postgres to snake case', () => {
 				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("first_name") do update set "AGE" = $4 returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -230,7 +163,6 @@ describe('postgres to snake case', () => {
 				'update "users" set "first_name" = $1, "last_name" = $2, "AGE" = $3 where "users"."id" = $4 returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -243,6 +175,71 @@ describe('postgres to snake case', () => {
 			sql: 'delete from "users" where "users"."id" = $1 returning "first_name", "AGE"',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "test"."developers" on "userId" = "test"."developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (default, $1, $2, $3) on conflict ("userFirstName") do update set "AGE" = $4 returning "first_name", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = $1, "last_name" = $2, "AGE" = $3 where "users"."id" = $4 returning "first_name" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = $1 returning "first_name", "AGE" as "usersAge"',
+			params: [1],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/casing/sqlite-to-camel.test.ts b/drizzle-orm/tests/casing/sqlite-to-camel.test.ts
index 43990296e1..0e69b8e693 100644
--- a/drizzle-orm/tests/casing/sqlite-to-camel.test.ts
+++ b/drizzle-orm/tests/casing/sqlite-to-camel.test.ts
@@ -1,57 +1,29 @@
 import Database from 'better-sqlite3';
-import { beforeEach, describe, it } from 'vitest';
+import { describe, it } from 'vitest';
 import { drizzle } from '~/better-sqlite3';
-import { relations } from '~/relations';
 import { asc, eq, sql } from '~/sql';
-import { alias, integer, sqliteTable, text, union } from '~/sqlite-core';
+import { alias, camelCase, integer, text, union } from '~/sqlite-core';
 
-const users = sqliteTable('users', {
+const users = camelCase.table('users', {
 	id: integer().primaryKey({ autoIncrement: true }),
 	first_name: text().notNull(),
 	last_name: text().notNull(),
 	// Test that custom aliases remain
 	age: integer('AGE'),
 });
-const usersRelations = relations(users, ({ one }) => ({
-	developers: one(developers),
-}));
-const developers = sqliteTable('developers', {
+
+const developers = camelCase.table('developers', {
 	user_id: integer().primaryKey().references(() => users.id),
 	uses_drizzle_orm: integer({ mode: 'boolean' }).notNull(),
 });
-const developersRelations = relations(developers, ({ one }) => ({
-	user: one(users, {
-		fields: [developers.user_id],
-		references: [users.id],
-	}),
-}));
+
 const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
-
-const db = drizzle(new Database(':memory:'), { schema, casing: 'camelCase' });
-
-const usersCache = {
-	'public.users.id': 'id',
-	'public.users.first_name': 'firstName',
-	'public.users.last_name': 'lastName',
-	'public.users.AGE': 'age',
-};
-const developersCache = {
-	'public.developers.user_id': 'userId',
-	'public.developers.uses_drizzle_orm': 'usesDrizzleOrm',
-};
-const cache = {
-	...usersCache,
-	...developersCache,
-};
+
+const db = drizzle({ client: new Database(':memory:') });
 
 const fullName = sql`${users.first_name} || ' ' || ${users.last_name}`.as('name');
 
 describe('sqlite to camel case', () => {
-	beforeEach(() => {
-		db.dialect.casing.clearCache();
-	});
-
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -64,7 +36,6 @@ describe('sqlite to camel case', () => {
 				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" from "users" left join "developers" on "users"."id" = "developers"."userId" order by "users"."firstName" asc',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -77,7 +48,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "users"."firstName" from "users" left join "developers" "devs" on "users"."id" = "devs"."userId"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -88,7 +58,6 @@ describe('sqlite to camel case', () => {
 			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -99,7 +68,6 @@ describe('sqlite to camel case', () => {
 			sql: 'with "cte" as (select "firstName" || \' \' || "lastName" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -112,7 +80,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "firstName" from "users" union select "firstName" from "users"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -125,63 +92,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "firstName" from "users" union select "firstName" from "users"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "id", "AGE", "firstName" || \' \' || "lastName" as "name", (select json_array("usesDrizzleOrm") as "data" from (select * from "developers" "users_developers" where "users_developers"."userId" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ? limit ?',
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						uses_drizzle_orm: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "id", "AGE", "firstName" || \' \' || "lastName" as "name", (select json_array("usesDrizzleOrm") as "data" from (select * from "developers" "users_developers" where "users_developers"."userId" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ?',
-			params: [1, 1],
-			typings: ['none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert (on conflict do nothing)', ({ expect }) => {
@@ -196,7 +106,6 @@ describe('sqlite to camel case', () => {
 				'insert into "users" ("id", "firstName", "lastName", "AGE") values (null, ?, ?, ?) on conflict ("users"."firstName") do nothing returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on conflict do update)', ({ expect }) => {
@@ -211,7 +120,6 @@ describe('sqlite to camel case', () => {
 				'insert into "users" ("id", "firstName", "lastName", "AGE") values (null, ?, ?, ?) on conflict ("users"."firstName") do update set "AGE" = ? returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -226,7 +134,6 @@ describe('sqlite to camel case', () => {
 				'update "users" set "firstName" = ?, "lastName" = ?, "AGE" = ? where "users"."id" = ? returning "firstName", "AGE"',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -239,6 +146,71 @@ describe('sqlite to camel case', () => {
 			sql: 'delete from "users" where "users"."id" = ? returning "firstName", "AGE"',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.user_id))
+			.orderBy(asc(users.first_name));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."firstName" || \' \' || "users"."lastName" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "developers" on "userId" = "developers"."userId" order by "users"."firstName" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.first_name.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.first_name, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "firstName", "lastName", "AGE") values (null, ?, ?, ?) on conflict ("userFirstName") do update set "AGE" = ? returning "firstName", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ first_name: 'John', last_name: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "firstName" = ?, "lastName" = ?, "AGE" = ? where "users"."id" = ? returning "firstName" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.first_name, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = ? returning "firstName", "AGE" as "usersAge"',
+			params: [1],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/casing/sqlite-to-snake.test.ts b/drizzle-orm/tests/casing/sqlite-to-snake.test.ts
index 38d92e6897..d7c302847c 100644
--- a/drizzle-orm/tests/casing/sqlite-to-snake.test.ts
+++ b/drizzle-orm/tests/casing/sqlite-to-snake.test.ts
@@ -1,34 +1,26 @@
 import Database from 'better-sqlite3';
-import { beforeEach, describe, it } from 'vitest';
+import { describe, it } from 'vitest';
+import { relations } from '~/_relations';
 import { drizzle } from '~/better-sqlite3';
-import { relations } from '~/relations';
 import { asc, eq, sql } from '~/sql';
-import { alias, integer, sqliteTable, text, union } from '~/sqlite-core';
+import { alias, integer, snakeCase, text, union } from '~/sqlite-core';
 
-const users = sqliteTable('users', {
+const users = snakeCase.table('users', {
 	id: integer().primaryKey({ autoIncrement: true }),
 	firstName: text().notNull(),
 	lastName: text().notNull(),
 	// Test that custom aliases remain
 	age: integer('AGE'),
 });
-const usersRelations = relations(users, ({ one }) => ({
-	developers: one(developers),
-}));
-const developers = sqliteTable('developers', {
+
+const developers = snakeCase.table('developers', {
 	userId: integer().primaryKey().references(() => users.id),
 	usesDrizzleORM: integer({ mode: 'boolean' }).notNull(),
 });
-const developersRelations = relations(developers, ({ one }) => ({
-	user: one(users, {
-		fields: [developers.userId],
-		references: [users.id],
-	}),
-}));
+
 const devs = alias(developers, 'devs');
-const schema = { users, usersRelations, developers, developersRelations };
 
-const db = drizzle(new Database(':memory:'), { schema, casing: 'snake_case' });
+const db = drizzle({ client: new Database(':memory:') });
 
 const usersCache = {
 	'public.users.id': 'id',
@@ -47,11 +39,7 @@ const cache = {
 
 const fullName = sql`${users.firstName} || ' ' || ${users.lastName}`.as('name');
 
-describe('sqlite to camel case', () => {
-	beforeEach(() => {
-		db.dialect.casing.clearCache();
-	});
-
+describe('sqlite to snake case', () => {
 	it('select', ({ expect }) => {
 		const query = db
 			.select({ name: fullName, age: users.age })
@@ -64,7 +52,6 @@ describe('sqlite to camel case', () => {
 				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" from "users" left join "developers" on "users"."id" = "developers"."user_id" order by "users"."first_name" asc',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('select (with alias)', ({ expect }) => {
@@ -77,7 +64,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "users"."first_name" from "users" left join "developers" "devs" on "users"."id" = "devs"."user_id"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('with CTE', ({ expect }) => {
@@ -89,7 +75,6 @@ describe('sqlite to camel case', () => {
 				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('with CTE (with query builder)', ({ expect }) => {
@@ -101,7 +86,6 @@ describe('sqlite to camel case', () => {
 				'with "cte" as (select "first_name" || \' \' || "last_name" as "name" from "users") select "name" from "cte"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator', ({ expect }) => {
@@ -114,7 +98,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "first_name" from "users" union select "first_name" from "users"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('set operator (function)', ({ expect }) => {
@@ -127,63 +110,6 @@ describe('sqlite to camel case', () => {
 			sql: 'select "first_name" from "users" union select "first_name" from "users"',
 			params: [],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
-	});
-
-	it('query (find first)', ({ expect }) => {
-		const query = db.query.users.findFirst({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "id", "AGE", "first_name" || \' \' || "last_name" as "name", (select json_array("uses_drizzle_orm") as "data" from (select * from "developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ? limit ?',
-			params: [1, 1, 1],
-			typings: ['none', 'none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
-	});
-
-	it('query (find many)', ({ expect }) => {
-		const query = db.query.users.findMany({
-			columns: {
-				id: true,
-				age: true,
-			},
-			extras: {
-				fullName,
-			},
-			where: eq(users.id, 1),
-			with: {
-				developers: {
-					columns: {
-						usesDrizzleORM: true,
-					},
-				},
-			},
-		});
-
-		expect(query.toSQL()).toEqual({
-			sql:
-				'select "id", "AGE", "first_name" || \' \' || "last_name" as "name", (select json_array("uses_drizzle_orm") as "data" from (select * from "developers" "users_developers" where "users_developers"."user_id" = "users"."id" limit ?) "users_developers") as "developers" from "users" "users" where "users"."id" = ?',
-			params: [1, 1],
-			typings: ['none', 'none'],
-		});
-		expect(db.dialect.casing.cache).toEqual(cache);
 	});
 
 	it('insert (on conflict do nothing)', ({ expect }) => {
@@ -198,7 +124,6 @@ describe('sqlite to camel case', () => {
 				'insert into "users" ("id", "first_name", "last_name", "AGE") values (null, ?, ?, ?) on conflict ("users"."first_name") do nothing returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('insert (on conflict do update)', ({ expect }) => {
@@ -213,7 +138,6 @@ describe('sqlite to camel case', () => {
 				'insert into "users" ("id", "first_name", "last_name", "AGE") values (null, ?, ?, ?) on conflict ("users"."first_name") do update set "AGE" = ? returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30, 31],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('update', ({ expect }) => {
@@ -228,7 +152,6 @@ describe('sqlite to camel case', () => {
 				'update "users" set "first_name" = ?, "last_name" = ?, "AGE" = ? where "users"."id" = ? returning "first_name", "AGE"',
 			params: ['John', 'Doe', 30, 1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
 	});
 
 	it('delete', ({ expect }) => {
@@ -241,6 +164,71 @@ describe('sqlite to camel case', () => {
 			sql: 'delete from "users" where "users"."id" = ? returning "first_name", "AGE"',
 			params: [1],
 		});
-		expect(db.dialect.casing.cache).toEqual(usersCache);
+	});
+
+	it('select columns as', ({ expect }) => {
+		const query = db
+			.select({ age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.orderBy(asc(users.id.as('userId')));
+
+		expect(query.toSQL()).toEqual({
+			sql: 'select "AGE" as "ageOfUser", "id" as "userId" from "users" order by "userId" asc',
+			params: [],
+		});
+	});
+
+	it('select join columns as', ({ expect }) => {
+		const query = db
+			.select({ name: fullName, age: users.age.as('ageOfUser'), id: users.id.as('userId') })
+			.from(users)
+			.leftJoin(developers, eq(users.id.as('userId'), developers.userId))
+			.orderBy(asc(users.firstName));
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'select "users"."first_name" || \' \' || "users"."last_name" as "name", "users"."AGE" as "ageOfUser", "users"."id" as "userId" from "users" left join "developers" on "userId" = "developers"."user_id" order by "users"."first_name" asc',
+			params: [],
+		});
+	});
+
+	it('insert (on conflict do update) returning as', ({ expect }) => {
+		const query = db
+			.insert(users)
+			.values({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.onConflictDoUpdate({ target: users.firstName.as('userFirstName'), set: { age: 31 } })
+			.returning({ firstName: users.firstName, age: users.age.as('userAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'insert into "users" ("id", "first_name", "last_name", "AGE") values (null, ?, ?, ?) on conflict ("userFirstName") do update set "AGE" = ? returning "first_name", "AGE" as "userAge"',
+			params: ['John', 'Doe', 30, 31],
+		});
+	});
+
+	it('update returning as', ({ expect }) => {
+		const query = db
+			.update(users)
+			.set({ firstName: 'John', lastName: 'Doe', age: 30 })
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName.as('usersName'), age: users.age });
+
+		expect(query.toSQL()).toEqual({
+			sql:
+				'update "users" set "first_name" = ?, "last_name" = ?, "AGE" = ? where "users"."id" = ? returning "first_name" as "usersName", "AGE"',
+			params: ['John', 'Doe', 30, 1],
+		});
+	});
+
+	it('delete returning as', ({ expect }) => {
+		const query = db
+			.delete(users)
+			.where(eq(users.id, 1))
+			.returning({ firstName: users.firstName, age: users.age.as('usersAge') });
+
+		expect(query.toSQL()).toEqual({
+			sql: 'delete from "users" where "users"."id" = ? returning "first_name", "AGE" as "usersAge"',
+			params: [1],
+		});
 	});
 });
diff --git a/drizzle-orm/tests/effect-query-effect.test.ts b/drizzle-orm/tests/effect-query-effect.test.ts
new file mode 100644
index 0000000000..1654cbed3c
--- /dev/null
+++ b/drizzle-orm/tests/effect-query-effect.test.ts
@@ -0,0 +1,25 @@
+import * as Effect from 'effect/Effect';
+import { describe, test } from 'vitest';
+import { applyEffectWrapper } from '~/effect-core/query-effect.ts';
+
+interface TestQuery extends Effect.Effect<number, never, never> {}
+
+class TestQuery {
+	execute() {
+		return Effect.succeed(1);
+	}
+}
+
+applyEffectWrapper(TestQuery);
+
+describe.concurrent('applyEffectWrapper', () => {
+	test('makes wrapped queries usable as real Effect values', async ({ expect }) => {
+		const query = new TestQuery();
+
+		await expect(Effect.runPromise(query.pipe(Effect.map((value) => value + 1)))).resolves.toBe(2);
+		await expect(Effect.runPromise(Effect.map(query, (value) => value + 2))).resolves.toBe(3);
+		await expect(Effect.runPromise(Effect.gen(function*() {
+			return yield* query;
+		}))).resolves.toBe(1);
+	});
+});
diff --git a/drizzle-orm/tests/is.test.ts b/drizzle-orm/tests/is.test.ts
index 180f3bf884..030105021c 100644
--- a/drizzle-orm/tests/is.test.ts
+++ b/drizzle-orm/tests/is.test.ts
@@ -1,6 +1,6 @@
 import { describe, test } from 'vitest';
 import { Column, is } from '~/index.ts';
-import { PgArray, PgColumn, PgSerial, pgTable, serial } from '~/pg-core/index.ts';
+import { PgColumn, PgSerial, pgTable, serial } from '~/pg-core/index.ts';
 
 const pgExampleTable = pgTable('test', {
 	a: serial('a').array(),
@@ -10,7 +10,9 @@ describe.concurrent('is', () => {
 	test('Column', ({ expect }) => {
 		expect(is(pgExampleTable.a, Column)).toBe(true);
 		expect(is(pgExampleTable.a, PgColumn)).toBe(true);
-		expect(is(pgExampleTable.a, PgArray)).toBe(true);
-		expect(is(pgExampleTable.a, PgSerial)).toBe(false);
+		// With the new array approach, array columns are still the base column type (e.g., PgSerial)
+		// with dimensions set, not a separate PgArray class
+		expect(is(pgExampleTable.a, PgSerial)).toBe(true);
+		expect(pgExampleTable.a.dimensions).toBe(1);
 	});
 });
diff --git a/drizzle-orm/tests/makePgArray.test.ts b/drizzle-orm/tests/makePgArray.test.ts
index b7b27d7a51..7957064125 100644
--- a/drizzle-orm/tests/makePgArray.test.ts
+++ b/drizzle-orm/tests/makePgArray.test.ts
@@ -1,21 +1,10 @@
 import { describe, it } from 'vitest';
-import { customType, pgTable } from '~/pg-core/index.ts';
-
-const anyColumn = customType<{ data: any }>({
-	dataType() {
-		return 'any';
-	},
-});
-
-const table = pgTable('test', {
-	a: anyColumn('a').array(),
-	b: anyColumn('a').array().array(),
-});
+import { makePgArray } from '~/pg-core/array.ts';
 
 describe.concurrent('makePgArray', () => {
 	it('parses simple 1D array', ({ expect }) => {
 		const input = ['1', '2', '3'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","2","3"}');
 	});
 
@@ -25,13 +14,13 @@ describe.concurrent('makePgArray', () => {
 			['4', '5', '6'],
 			['7', '8', '9'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{"1","2","3"},{"4","5","6"},{"7","8","9"}}');
 	});
 
 	it('parses array with quoted values', ({ expect }) => {
 		const input = ['1', '2,3', '4'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","2,3","4"}');
 	});
 
@@ -40,13 +29,13 @@ describe.concurrent('makePgArray', () => {
 			['1', '2,3', '4'],
 			['5', '6,7', '8'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{"1","2,3","4"},{"5","6,7","8"}}');
 	});
 
 	it('parses array with empty values', ({ expect }) => {
 		const input = ['1', '', '3'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","","3"}');
 	});
 
@@ -56,43 +45,43 @@ describe.concurrent('makePgArray', () => {
 			['', '5', '6'],
 			['7', '8', '9'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{"1","2","3"},{"","5","6"},{"7","8","9"}}');
 	});
 
 	it('parses empty array', ({ expect }) => {
 		const input: string[] = [];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{}');
 	});
 
 	it('parses empty nested array', ({ expect }) => {
 		const input = [[]];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{}}');
 	});
 
 	it('parses single-level array with strings', ({ expect }) => {
 		const input = ['one', 'two', 'three'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"one","two","three"}');
 	});
 
 	it('parses single-level array with mixed values', ({ expect }) => {
 		const input = ['1', 'two', '3'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","two","3"}');
 	});
 
 	it('parses single-level array with commas inside quotes', ({ expect }) => {
 		const input = ['1', 'two, three', '4'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","two, three","4"}');
 	});
 
 	it('parses single-level array with escaped quotes inside quotes', ({ expect }) => {
 		const input = ['1', 'two "three", four', '5'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","two \\"three\\", four","5"}');
 	});
 
@@ -102,7 +91,7 @@ describe.concurrent('makePgArray', () => {
 			['four', 'five', 'six'],
 			['seven', 'eight', 'nine'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{"one","two","three"},{"four","five","six"},{"seven","eight","nine"}}');
 	});
 
@@ -112,7 +101,7 @@ describe.concurrent('makePgArray', () => {
 			['four', 'five "and a half", six', '6'],
 			['seven', 'eight', 'nine'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual(
 			'{{"1","two \\"and a half\\", three","3"},{"four","five \\"and a half\\", six","6"},{"seven","eight","nine"}}',
 		);
@@ -120,7 +109,7 @@ describe.concurrent('makePgArray', () => {
 
 	it('parses an array with null values', ({ expect }) => {
 		const input = ['1', null, '3'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1",null,"3"}');
 	});
 
@@ -130,19 +119,19 @@ describe.concurrent('makePgArray', () => {
 			[null, '5', '6'],
 			['7', '8', '9'],
 		];
-		const output = table.b.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{{"1","2","3"},{null,"5","6"},{"7","8","9"}}');
 	});
 
 	it('parses string array with empty strings', ({ expect }) => {
 		const input = ['1', '', '3'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","","3"}');
 	});
 
 	it('parses string array with backlash strings', ({ expect }) => {
 		const input = ['1', '\n', '3\\'];
-		const output = table.a.mapToDriverValue(input);
+		const output = makePgArray(input);
 		expect(output).toEqual('{"1","\n","3\\\\"}');
 	});
 });
diff --git a/drizzle-orm/tests/parsePgArray.test.ts b/drizzle-orm/tests/parsePgArray.test.ts
index c89da8f95e..ee03552d1b 100644
--- a/drizzle-orm/tests/parsePgArray.test.ts
+++ b/drizzle-orm/tests/parsePgArray.test.ts
@@ -1,27 +1,16 @@
 import { describe, it } from 'vitest';
-import { customType, pgTable } from '~/pg-core/index.ts';
-
-const anyColumn = customType<{ data: any }>({
-	dataType() {
-		return 'any';
-	},
-});
-
-const table = pgTable('test', {
-	a: anyColumn('a').array(),
-	b: anyColumn('a').array().array(),
-});
+import { parsePgArray } from '~/pg-core/array.ts';
 
 describe.concurrent('parsePgArray', () => {
 	it('parses simple 1D array', ({ expect }) => {
 		const input = '{1,2,3}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', '2', '3']);
 	});
 
 	it('parses simple 2D array', ({ expect }) => {
 		const input = '{{1,2,3},{4,5,6},{7,8,9}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([
 			['1', '2', '3'],
 			['4', '5', '6'],
@@ -31,13 +20,13 @@ describe.concurrent('parsePgArray', () => {
 
 	it('parses array with quoted values', ({ expect }) => {
 		const input = '{1,"2,3",4}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', '2,3', '4']);
 	});
 
 	it('parses array with nested quoted values', ({ expect }) => {
 		const input = '{{1,"2,3",4},{5,"6,7",8}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([
 			['1', '2,3', '4'],
 			['5', '6,7', '8'],
@@ -46,13 +35,13 @@ describe.concurrent('parsePgArray', () => {
 
 	it('parses array with empty values', ({ expect }) => {
 		const input = '{1,"",3}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', '', '3']);
 	});
 
 	it('parses array with empty nested values', ({ expect }) => {
 		const input = '{{1,2,3},{,5,6},{7,8,9}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([
 			['1', '2', '3'],
 			['', '5', '6'],
@@ -62,43 +51,43 @@ describe.concurrent('parsePgArray', () => {
 
 	it('parses empty array', ({ expect }) => {
 		const input = '{}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([]);
 	});
 
 	it('parses empty nested array', ({ expect }) => {
 		const input = '{{}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([[]]);
 	});
 
 	it('parses single-level array with strings', ({ expect }) => {
 		const input = '{"one","two","three"}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['one', 'two', 'three']);
 	});
 
 	it('parses single-level array with mixed values', ({ expect }) => {
 		const input = '{1,"two",3}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', 'two', '3']);
 	});
 
 	it('parses single-level array with commas inside quotes', ({ expect }) => {
 		const input = '{1,"two, three",4}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', 'two, three', '4']);
 	});
 
 	it('parses single-level array with escaped quotes inside quotes', ({ expect }) => {
 		const input = '{1,"two \\"three\\", four",5}';
-		const output = table.a.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual(['1', 'two "three", four', '5']);
 	});
 
 	it('parses two-dimensional array with strings', ({ expect }) => {
 		const input = '{{"one","two",three},{"four",five,"six"},{seven,eight,"nine"}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([
 			['one', 'two', 'three'],
 			['four', 'five', 'six'],
@@ -109,7 +98,7 @@ describe.concurrent('parsePgArray', () => {
 	it('parses two-dimensional array with mixed values and escaped quotes', ({ expect }) => {
 		const input =
 			'{{1,"two \\"and a half\\", three",3},{"four","five \\"and a half\\", six",6},{"seven","eight","nine"}}';
-		const output = table.b.mapFromDriverValue(input);
+		const output = parsePgArray(input);
 		expect(output).toEqual([
 			['1', 'two "and a half", three', '3'],
 			['four', 'five "and a half", six', '6'],
diff --git a/drizzle-orm/tests/pg-ignore-select-cast-codecs.test.ts b/drizzle-orm/tests/pg-ignore-select-cast-codecs.test.ts
new file mode 100644
index 0000000000..2f4c47f6e7
--- /dev/null
+++ b/drizzle-orm/tests/pg-ignore-select-cast-codecs.test.ts
@@ -0,0 +1,222 @@
+import { expect, test } from 'vitest';
+import { refineCodecs } from '~/codecs';
+import { getMaterializedViewConfig, getViewConfig, pgMaterializedView, pgTable, pgView } from '~/pg-core';
+import { castToText } from '~/pg-core/codecs';
+import { drizzle, pgliteCodecs } from '~/pglite';
+import { gte, sql } from '~/sql';
+
+const db = drizzle('memory://', {
+	codecs: refineCodecs(pgliteCodecs, {
+		date: {
+			cast: castToText,
+			castParam: (p) => `${p}::date`,
+		},
+		timestamp: {
+			cast: castToText,
+			castParam: (p) => `${p}::timestamp`,
+		},
+	}),
+});
+
+const t1 = pgTable('t1', (t) => ({
+	id: t.serial('id').primaryKey(),
+	date: t.date('date', { mode: 'date' }).notNull(),
+}));
+
+const t2 = pgTable('t2', (t) => ({
+	id: t.serial('id').primaryKey(),
+	timestamp: t.timestamp('timestamp', { mode: 'date' }).notNull(),
+}));
+
+test('view selection', () => {
+	const v1 = pgView('v1').as(
+		db.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0))),
+	);
+
+	const v2 = pgView('v1').as((qb) =>
+		qb.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0)))
+	);
+
+	expect(db.dialect.sqlToQuery(getViewConfig(v1).query).sql).toStrictEqual(
+		`select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= '1970-01-01T00:00:00.000Z'`,
+	);
+	expect(db.dialect.sqlToQuery(getViewConfig(v2).query).sql).toStrictEqual(
+		`select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= '1970-01-01T00:00:00.000Z'`,
+	);
+});
+
+test('materialized view selection', () => {
+	const v1 = pgMaterializedView('v1').as(
+		db.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0))),
+	);
+
+	const v2 = pgMaterializedView('v1').as((qb) =>
+		qb.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0)))
+	);
+
+	expect(db.dialect.sqlToQuery(getMaterializedViewConfig(v1).query!).sql).toStrictEqual(
+		`select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= '1970-01-01T00:00:00.000Z'`,
+	);
+	expect(db.dialect.sqlToQuery(getMaterializedViewConfig(v2).query!).sql).toStrictEqual(
+		`select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= '1970-01-01T00:00:00.000Z'`,
+	);
+});
+
+test('insert from select', () => {
+	const q1 = db.insert(t1).select((qb) => qb.select().from(t1)).returning();
+	const q2 = db.insert(t1).select(db.select().from(t1)).returning();
+
+	expect(db.dialect.sqlToQuery(q1.getSQL()).sql).toStrictEqual(
+		`insert into "t1" ("id", "date") select "id", "date" from "t1" returning "id", "date"::text`,
+	);
+	expect(db.dialect.sqlToQuery(q2.getSQL()).sql).toStrictEqual(
+		`insert into "t1" ("id", "date") select "id", "date" from "t1" returning "id", "date"::text`,
+	);
+});
+
+test('update from subquery', () => {
+	const sq = db.select().from(t1).limit(1).as('sq');
+
+	const q1 = db.update(t1).set({
+		id: sq.id,
+		date: sq.date,
+	}).where(gte(t1.date, new Date(0))).from(sq).returning();
+
+	expect(db.dialect.sqlToQuery(q1.getSQL()).sql).toStrictEqual(
+		`update "t1" set "id" = "sq"."id", "date" = "sq"."date" from (select "id", "date" from "t1" limit $1) "sq" where "t1"."date" >= $2::date returning "t1"."id", "t1"."date"::text, "sq"."id", "sq"."date"::text`,
+	);
+});
+
+test('$with select', () => {
+	const w1 = db.$with('w1').as(
+		db.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0))),
+	);
+
+	const w2 = db.$with('w1').as((qb) =>
+		qb.select({
+			id: t1.id.as('id1'),
+			date: t1.date.as('d1'),
+			jId: t2.id.as('id2'),
+			ts: t2.timestamp.as('d2'),
+		}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0)))
+	);
+
+	const s1 = db.with(w1).select().from(w1);
+	const s2 = db.with(w2).select().from(w2);
+
+	expect(db.dialect.sqlToQuery(s1.getSQL()).sql).toStrictEqual(
+		`with "w1" as (select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= $1::date) select "id1", "d1"::text, "id2", "d2"::text from "w1"`,
+	);
+	expect(db.dialect.sqlToQuery(s2.getSQL()).sql).toStrictEqual(
+		`with "w1" as (select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= $1::date) select "id1", "d1"::text, "id2", "d2"::text from "w1"`,
+	);
+});
+
+test('$with insert returning', () => {
+	const w1 = db.$with('w1').as(
+		db.insert(t1).values({
+			id: 1,
+			date: new Date(0),
+		}).returning(),
+	);
+
+	const s1 = db.with(w1).select().from(w1);
+
+	expect(db.dialect.sqlToQuery(s1.getSQL()).sql).toStrictEqual(
+		`with "w1" as (insert into "t1" ("id", "date") values ($1, $2::date) returning "id", "date") select "id", "date"::text from "w1"`,
+	);
+});
+
+test('$with update returning', () => {
+	const w1 = db.$with('w1').as(
+		db.update(t1).set({
+			id: 1,
+			date: new Date(0),
+		}).where(gte(t1.date, new Date(0))).returning(),
+	);
+
+	const s1 = db.with(w1).select().from(w1);
+
+	expect(db.dialect.sqlToQuery(s1.getSQL()).sql).toStrictEqual(
+		`with "w1" as (update "t1" set "id" = $1, "date" = $2::date where "t1"."date" >= $3::date returning "id", "date") select "id", "date"::text from "w1"`,
+	);
+});
+
+test('$with delete returning', () => {
+	const w1 = db.$with('w1').as(
+		db.delete(t1).where(gte(t1.date, new Date(0))).returning(),
+	);
+
+	const s1 = db.with(w1).select().from(w1);
+
+	expect(db.dialect.sqlToQuery(s1.getSQL()).sql).toStrictEqual(
+		`with "w1" as (delete from "t1" where "t1"."date" >= $1::date returning "id", "date") select "id", "date"::text from "w1"`,
+	);
+});
+
+test('$with nested', () => {
+	const w1 = db.$with('w1').as(
+		(qb) => {
+			const wn = db.$with('wn').as((qb) =>
+				qb.select({
+					id: t1.id.as('id1'),
+					date: t1.date.as('d1'),
+					jId: t2.id.as('id2'),
+					ts: t2.timestamp.as('d2'),
+				}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0)))
+			);
+
+			return qb.with(wn).select().from(wn);
+		},
+	);
+
+	const w2 = db.$with('w1').as(
+		(qb) => {
+			const wn = db.$with('wn').as(
+				db.select({
+					id: t1.id.as('id1'),
+					date: t1.date.as('d1'),
+					jId: t2.id.as('id2'),
+					ts: t2.timestamp.as('d2'),
+				}).from(t1).crossJoin(t2).where(gte(t1.date, new Date(0))),
+			);
+
+			return qb.with(wn).select().from(wn);
+		},
+	);
+
+	const s1 = db.with(w1).select().from(w1);
+	const s2 = db.with(w2).select().from(w2);
+
+	expect(db.dialect.sqlToQuery(s1.getSQL()).sql).toStrictEqual(
+		`with "w1" as (with "wn" as (select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= $1::date) select "id1", "d1", "id2", "d2" from "wn") select "id1", "d1"::text, "id2", "d2"::text from "w1"`,
+	);
+	expect(db.dialect.sqlToQuery(s2.getSQL()).sql).toStrictEqual(
+		`with "w1" as (with "wn" as (select "t1"."id" as "id1", "t1"."date" as "d1", "t2"."id" as "id2", "t2"."timestamp" as "d2" from "t1" cross join "t2" where "t1"."date" >= $1::date) select "id1", "d1", "id2", "d2" from "wn") select "id1", "d1"::text, "id2", "d2"::text from "w1"`,
+	);
+});
diff --git a/drizzle-orm/tests/pg-jit-mappers.test.ts b/drizzle-orm/tests/pg-jit-mappers.test.ts
new file mode 100644
index 0000000000..5a43742047
--- /dev/null
+++ b/drizzle-orm/tests/pg-jit-mappers.test.ts
@@ -0,0 +1,1382 @@
+import { expect, test } from 'vitest';
+import { customType, integer, pgTable, pgView } from '~/pg-core';
+import { drizzle, PgliteDatabase } from '~/pglite';
+import {
+	AnyRelationsBuilderConfig,
+	defineRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	makeJitRqbMapper,
+	RelationsBuilder,
+} from '~/relations';
+import { eq, max, sql } from '~/sql';
+import { getColumns, getTableColumns } from '~/utils';
+
+function createDB<S extends Record<string, unknown>, TConfig extends AnyRelationsBuilderConfig>(
+	schema: S,
+	cb: (helpers: RelationsBuilder<ExtractTablesFromSchema<S>>) => TConfig,
+): PgliteDatabase<ExtractTablesWithRelations<TConfig, ExtractTablesFromSchema<S>>> {
+	return drizzle('memory://', {
+		relations: defineRelations(schema, cb),
+		jit: true,
+	});
+}
+
+const users = pgTable('users', (t) => ({
+	id: t.bigint('id', { mode: 'number' }).primaryKey(),
+	name: t.text('name').notNull(),
+	createdAt: t.timestamp('created_at', {
+		withTimezone: true,
+		mode: 'date',
+	}).notNull(),
+	isBanned: t.boolean('is_banned'),
+}));
+
+const posts = pgTable('posts', (t) => ({
+	id: t.integer('id').primaryKey(),
+	authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+	content: t.text('content'),
+}));
+
+const internalStaff = pgTable('internal_staff_jqm1', {
+	userId: integer('user_id').notNull().primaryKey(),
+});
+
+const ticket = pgTable('ticket_jqm1', {
+	staffId: integer('staff_id').notNull(),
+});
+
+const db = createDB({ users, posts }, (r) => ({
+	users: {
+		post: r.one.posts({
+			from: r.users.id,
+			to: r.posts.authorId,
+		}),
+		posts: r.one.posts({
+			from: r.users.id,
+			to: r.posts.authorId,
+		}),
+	},
+	posts: {
+		author: r.one.users({
+			from: r.posts.authorId,
+			to: r.users.id,
+		}),
+		authors: r.many.users({
+			from: r.posts.authorId,
+			to: r.users.id,
+		}),
+	},
+}));
+
+test('Jit mappers: simple select', async () => {
+	expect(db.select().from(users).prepare().mapper?.body).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3 ] = rows[i];
+		mapped[i] = {
+			"id": c0 === null ? c0 : codec0(c0, 0),
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"isBanned": c3,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+});
+
+test('Jit mappers: select - nothing to decode - text', async () => {
+	expect(db.select({ name: users.name }).from(users).prepare().mapper?.body).toStrictEqual(
+		`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const [ c0 ] = rows[i];
+		mapped[i] = {
+			"name": c0,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`,
+	);
+});
+
+test('Jit mappers: select - nothing to decode - null', async () => {
+	expect(db.select({ isBanned: users.isBanned }).from(users).prepare().mapper?.body).toStrictEqual(
+		`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const [ c0 ] = rows[i];
+		mapped[i] = {
+			"isBanned": c0,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`,
+	);
+});
+
+test('Jit mappers: insert returning all, select, update returning, delete returning', async () => {
+	const inserted = db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: new Date(),
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: new Date(),
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: new Date(),
+	}]).returning().prepare().mapper?.body;
+
+	const selected = db.select().from(users).prepare().mapper?.body;
+
+	const updated = db.update(users).set({
+		isBanned: false,
+	}).where(eq(users.id, 2)).returning().prepare().mapper?.body;
+
+	const deleted = db.delete(users).returning().prepare().mapper?.body;
+
+	expect(inserted).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3 ] = rows[i];
+		mapped[i] = {
+			"id": c0 === null ? c0 : codec0(c0, 0),
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"isBanned": c3,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3 ] = rows[i];
+		mapped[i] = {
+			"id": c0 === null ? c0 : codec0(c0, 0),
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"isBanned": c3,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(updated).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3 ] = rows[i];
+		mapped[i] = {
+			"id": c0 === null ? c0 : codec0(c0, 0),
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"isBanned": c3,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(deleted).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3 ] = rows[i];
+		mapped[i] = {
+			"id": c0 === null ? c0 : codec0(c0, 0),
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"isBanned": c3,
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+});
+
+test('Jit mappers: select complex selections', async () => {
+	const selected1 = db.select({ user: users, post: posts }).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	).prepare().mapper?.body;
+	const selected2 = db.select({ user: users, post: posts }).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	).prepare().mapper?.body;
+	const selected3 = db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	).prepare().mapper?.body;
+	const selected4 = db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	).prepare().mapper?.body;
+	const selected5 = db.select({
+		user: {
+			...getTableColumns(users),
+			extra: sql`1`.mapWith(Number).as('extra_1'),
+		},
+		post: {
+			...getTableColumns(posts),
+			extra: sql`1`.mapWith(Number).as('extra_1'),
+		},
+	}).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	).prepare().mapper?.body;
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(users, eq(internalStaff.userId, users.id))
+		.as('internal_staff');
+	const selected6 = db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff_jqm1.userId, ticket.staffId))
+		.prepare().mapper?.body;
+
+	expect(selected1).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	const { codec: codec5 } = columns[5];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5, c6 ] = rows[i];
+		mapped[i] = {
+			"user": {
+				"id": c0 === null ? c0 : codec0(c0, 0),
+				"name": c1,
+				"createdAt": c2 === null ? c2 : codec2(c2, 0),
+				"isBanned": c3,
+			},
+			"post": c4 === null && c5 === null && c6 === null ? null : {
+				"id": c4,
+				"authorId": c5 === null ? c5 : codec5(c5, 0),
+				"content": c6,
+			},
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected2).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	const { codec: codec5 } = columns[5];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5, c6 ] = rows[i];
+		mapped[i] = {
+			"user": {
+				"id": c0 === null ? c0 : codec0(c0, 0),
+				"name": c1,
+				"createdAt": c2 === null ? c2 : codec2(c2, 0),
+				"isBanned": c3,
+			},
+			"post": {
+				"id": c4,
+				"authorId": c5 === null ? c5 : codec5(c5, 0),
+				"content": c6,
+			},
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected3).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec5 } = columns[5];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5 ] = rows[i];
+		mapped[i] = {
+			"userId": c0 === null ? c0 : codec0(c0, 0),
+			"postId": c1,
+			"name": c2,
+			"isBanned": c3,
+			"content": c4,
+			"createdAt": c5 === null ? c5 : codec5(c5, 0),
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected4).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec5 } = columns[5];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5 ] = rows[i];
+		mapped[i] = {
+			"userId": c0 === null ? c0 : codec0(c0, 0),
+			"postId": c1,
+			"name": c2,
+			"isBanned": c3,
+			"content": c4,
+			"createdAt": c5 === null ? c5 : codec5(c5, 0),
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected5).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec0 } = columns[0];
+	const { codec: codec2 } = columns[2];
+	const { field: { sql: { decoder: decoder4 } } } = columns[4];
+	const { codec: codec6 } = columns[6];
+	const { field: { sql: { decoder: decoder8 } } } = columns[8];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5, c6, c7, c8 ] = rows[i];
+		mapped[i] = {
+			"user": {
+				"id": c0 === null ? c0 : codec0(c0, 0),
+				"name": c1,
+				"createdAt": c2 === null ? c2 : codec2(c2, 0),
+				"isBanned": c3,
+				"extra": c4 === null ? c4 : decoder4.mapFromDriverValue(c4),
+			},
+			"post": c5 === null && c6 === null && c7 === null ? null : {
+				"id": c5,
+				"authorId": c6 === null ? c6 : codec6(c6, 0),
+				"content": c7,
+				"extra": c8 === null ? c8 : decoder8.mapFromDriverValue(c8),
+			},
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+	expect(selected6).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec2 } = columns[2];
+	const { codec: codec4 } = columns[4];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5 ] = rows[i];
+		mapped[i] = {
+			"ticket_jqm1": {
+				"staffId": c0,
+			},
+			"internal_staff": {
+				"internal_staff_jqm1": {
+					"userId": c1,
+				},
+				"users": {
+					"id": c2 === null ? c2 : codec2(c2, 0),
+					"name": c3,
+					"createdAt": c4 === null ? c4 : codec4(c4, 0),
+					"isBanned": c5,
+				},
+			},
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+});
+
+test('Jit mappers: relational - object mode', async () => {
+	const bodyForObjectRoot = (q: unknown, isFirst: boolean) => {
+		const selection = (q as any)._toSQL().query.selection;
+		return makeJitRqbMapper({
+			selection,
+			isFirst,
+			parseJson: false,
+			parseJsonIfString: false,
+			rootJsonMappers: false,
+			arrayModeRoot: false,
+		}).body;
+	};
+
+	const empty1 = bodyForObjectRoot(db.query.users.findFirst(), true);
+	const empty2 = bodyForObjectRoot(db.query.users.findMany(), false);
+
+	expect(empty1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3 } = row;
+	rows[0] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(empty2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	for (let i = 0; i < rows.length; ++i) {
+		const row = rows[i];
+		let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3 } = row;
+		rows[i] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	}
+	return rows;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const simple1 = bodyForObjectRoot(db.query.users.findFirst(), true);
+	const simple2 = bodyForObjectRoot(db.query.users.findMany(), false);
+
+	expect(simple1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3 } = row;
+	rows[0] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(simple2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	for (let i = 0; i < rows.length; ++i) {
+		const row = rows[i];
+		let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3 } = row;
+		rows[i] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	}
+	return rows;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const extra1 = bodyForObjectRoot(
+		db.query.users.findFirst({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		}),
+		true,
+	);
+	const extra2 = bodyForObjectRoot(
+		db.query.users.findMany({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		}),
+		false,
+	);
+
+	expect(extra1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { field: { decoder: dec9 } } = selection[5];
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3, "sql": c4, "sqlWrapper": c5 } = row;
+	rows[0] = { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec9.mapFromDriverValue(c5) };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(extra2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { field: { decoder: dec9 } } = selection[5];
+	for (let i = 0; i < rows.length; ++i) {
+		const row = rows[i];
+		let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3, "sql": c4, "sqlWrapper": c5 } = row;
+		rows[i] = { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec9.mapFromDriverValue(c5) };
+	}
+	return rows;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const nested1 = bodyForObjectRoot(
+		db.query.users.findFirst({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		}),
+		true,
+	);
+	const nested2 = bodyForObjectRoot(
+		db.query.users.findMany({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		}),
+		false,
+	);
+
+	expect(nested1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec8 } = selection[0];
+	const { codec: codec9 } = selection[2];
+	const { field: { decoder: dec10 } } = selection[4];
+	const { field: { decoder: dec11 } } = selection[5];
+	const { selection: s12 } = selection[6];
+	const { codec: codec20 } = s12[1];
+	const { field: { decoder: dec21 } } = s12[3];
+	const { field: { decoder: dec22 } } = s12[4];
+	const { selection: s23 } = s12[5];
+	const { codec: codec30 } = s23[0];
+	const { codec: codec31 } = s23[2];
+	const { field: { decoder: dec32 } } = s23[4];
+	const { field: { decoder: dec33 } } = s23[5];
+	const { selection: s34 } = s12[6];
+	const { codec: codec42 } = s34[0];
+	const { codec: codec43 } = s34[2];
+	const { field: { decoder: dec44 } } = s34[4];
+	const { field: { decoder: dec45 } } = s34[5];
+	const { selection: s46 } = selection[7];
+	const { codec: codec54 } = s46[1];
+	const { field: { decoder: dec55 } } = s46[3];
+	const { field: { decoder: dec56 } } = s46[4];
+	const { selection: s57 } = s46[5];
+	const { codec: codec64 } = s57[0];
+	const { codec: codec65 } = s57[2];
+	const { field: { decoder: dec66 } } = s57[4];
+	const { field: { decoder: dec67 } } = s57[5];
+	const { selection: s68 } = s46[6];
+	const { codec: codec76 } = s68[0];
+	const { codec: codec77 } = s68[2];
+	const { field: { decoder: dec78 } } = s68[4];
+	const { field: { decoder: dec79 } } = s68[5];
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3, "sql": c4, "sqlWrapper": c5, "post": c6, "posts": c7 } = row;
+	if (c6 !== null) {
+		let { "id": c13, "authorId": c14, "content": c15, "sql": c16, "sqlWrapper": c17, "author": c18, "authors": c19 } = c6;
+		if (c18 !== null) {
+			let { "id": c24, "name": c25, "createdAt": c26, "isBanned": c27, "sql": c28, "sqlWrapper": c29 } = c18;
+			c18 = { "id": c24 === null ? null : codec30(c24, 0), "name": c25, "createdAt": c26 === null ? null : codec31(c26, 0), "isBanned": c27, "sql": c28 === null ? null : dec32.mapFromDriverValue(c28), "sqlWrapper": c29 === null ? null : dec33.mapFromDriverValue(c29) };
+		}
+		if (c19 !== null) {
+			for (let j35 = 0; j35 < c19.length; ++j35) {
+				let { "id": c36, "name": c37, "createdAt": c38, "isBanned": c39, "sql": c40, "sqlWrapper": c41 } = c19[j35];
+				c19[j35] = { "id": c36 === null ? null : codec42(c36, 0), "name": c37, "createdAt": c38 === null ? null : codec43(c38, 0), "isBanned": c39, "sql": c40 === null ? null : dec44.mapFromDriverValue(c40), "sqlWrapper": c41 === null ? null : dec45.mapFromDriverValue(c41) };
+			}
+		}
+		c6 = { "id": c13, "authorId": c14 === null ? null : codec20(c14, 0), "content": c15, "sql": c16 === null ? null : dec21.mapFromDriverValue(c16), "sqlWrapper": c17 === null ? null : dec22.mapFromDriverValue(c17), "author": c18, "authors": c19 };
+	}
+	if (c7 !== null) {
+		let { "id": c47, "authorId": c48, "content": c49, "sql": c50, "sqlWrapper": c51, "author": c52, "authors": c53 } = c7;
+		if (c52 !== null) {
+			let { "id": c58, "name": c59, "createdAt": c60, "isBanned": c61, "sql": c62, "sqlWrapper": c63 } = c52;
+			c52 = { "id": c58 === null ? null : codec64(c58, 0), "name": c59, "createdAt": c60 === null ? null : codec65(c60, 0), "isBanned": c61, "sql": c62 === null ? null : dec66.mapFromDriverValue(c62), "sqlWrapper": c63 === null ? null : dec67.mapFromDriverValue(c63) };
+		}
+		if (c53 !== null) {
+			for (let j69 = 0; j69 < c53.length; ++j69) {
+				let { "id": c70, "name": c71, "createdAt": c72, "isBanned": c73, "sql": c74, "sqlWrapper": c75 } = c53[j69];
+				c53[j69] = { "id": c70 === null ? null : codec76(c70, 0), "name": c71, "createdAt": c72 === null ? null : codec77(c72, 0), "isBanned": c73, "sql": c74 === null ? null : dec78.mapFromDriverValue(c74), "sqlWrapper": c75 === null ? null : dec79.mapFromDriverValue(c75) };
+			}
+		}
+		c7 = { "id": c47, "authorId": c48 === null ? null : codec54(c48, 0), "content": c49, "sql": c50 === null ? null : dec55.mapFromDriverValue(c50), "sqlWrapper": c51 === null ? null : dec56.mapFromDriverValue(c51), "author": c52, "authors": c53 };
+	}
+	rows[0] = { "id": c0 === null ? null : codec8(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec9(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec10.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec11.mapFromDriverValue(c5), "post": c6, "posts": c7 };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(nested2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec8 } = selection[0];
+	const { codec: codec9 } = selection[2];
+	const { field: { decoder: dec10 } } = selection[4];
+	const { field: { decoder: dec11 } } = selection[5];
+	const { selection: s12 } = selection[6];
+	const { codec: codec20 } = s12[1];
+	const { field: { decoder: dec21 } } = s12[3];
+	const { field: { decoder: dec22 } } = s12[4];
+	const { selection: s23 } = s12[5];
+	const { codec: codec30 } = s23[0];
+	const { codec: codec31 } = s23[2];
+	const { field: { decoder: dec32 } } = s23[4];
+	const { field: { decoder: dec33 } } = s23[5];
+	const { selection: s34 } = s12[6];
+	const { codec: codec42 } = s34[0];
+	const { codec: codec43 } = s34[2];
+	const { field: { decoder: dec44 } } = s34[4];
+	const { field: { decoder: dec45 } } = s34[5];
+	const { selection: s46 } = selection[7];
+	const { codec: codec54 } = s46[1];
+	const { field: { decoder: dec55 } } = s46[3];
+	const { field: { decoder: dec56 } } = s46[4];
+	const { selection: s57 } = s46[5];
+	const { codec: codec64 } = s57[0];
+	const { codec: codec65 } = s57[2];
+	const { field: { decoder: dec66 } } = s57[4];
+	const { field: { decoder: dec67 } } = s57[5];
+	const { selection: s68 } = s46[6];
+	const { codec: codec76 } = s68[0];
+	const { codec: codec77 } = s68[2];
+	const { field: { decoder: dec78 } } = s68[4];
+	const { field: { decoder: dec79 } } = s68[5];
+	for (let i = 0; i < rows.length; ++i) {
+		const row = rows[i];
+		let { "id": c0, "name": c1, "createdAt": c2, "isBanned": c3, "sql": c4, "sqlWrapper": c5, "post": c6, "posts": c7 } = row;
+		if (c6 !== null) {
+			let { "id": c13, "authorId": c14, "content": c15, "sql": c16, "sqlWrapper": c17, "author": c18, "authors": c19 } = c6;
+			if (c18 !== null) {
+				let { "id": c24, "name": c25, "createdAt": c26, "isBanned": c27, "sql": c28, "sqlWrapper": c29 } = c18;
+				c18 = { "id": c24 === null ? null : codec30(c24, 0), "name": c25, "createdAt": c26 === null ? null : codec31(c26, 0), "isBanned": c27, "sql": c28 === null ? null : dec32.mapFromDriverValue(c28), "sqlWrapper": c29 === null ? null : dec33.mapFromDriverValue(c29) };
+			}
+			if (c19 !== null) {
+				for (let j35 = 0; j35 < c19.length; ++j35) {
+					let { "id": c36, "name": c37, "createdAt": c38, "isBanned": c39, "sql": c40, "sqlWrapper": c41 } = c19[j35];
+					c19[j35] = { "id": c36 === null ? null : codec42(c36, 0), "name": c37, "createdAt": c38 === null ? null : codec43(c38, 0), "isBanned": c39, "sql": c40 === null ? null : dec44.mapFromDriverValue(c40), "sqlWrapper": c41 === null ? null : dec45.mapFromDriverValue(c41) };
+				}
+			}
+			c6 = { "id": c13, "authorId": c14 === null ? null : codec20(c14, 0), "content": c15, "sql": c16 === null ? null : dec21.mapFromDriverValue(c16), "sqlWrapper": c17 === null ? null : dec22.mapFromDriverValue(c17), "author": c18, "authors": c19 };
+		}
+		if (c7 !== null) {
+			let { "id": c47, "authorId": c48, "content": c49, "sql": c50, "sqlWrapper": c51, "author": c52, "authors": c53 } = c7;
+			if (c52 !== null) {
+				let { "id": c58, "name": c59, "createdAt": c60, "isBanned": c61, "sql": c62, "sqlWrapper": c63 } = c52;
+				c52 = { "id": c58 === null ? null : codec64(c58, 0), "name": c59, "createdAt": c60 === null ? null : codec65(c60, 0), "isBanned": c61, "sql": c62 === null ? null : dec66.mapFromDriverValue(c62), "sqlWrapper": c63 === null ? null : dec67.mapFromDriverValue(c63) };
+			}
+			if (c53 !== null) {
+				for (let j69 = 0; j69 < c53.length; ++j69) {
+					let { "id": c70, "name": c71, "createdAt": c72, "isBanned": c73, "sql": c74, "sqlWrapper": c75 } = c53[j69];
+					c53[j69] = { "id": c70 === null ? null : codec76(c70, 0), "name": c71, "createdAt": c72 === null ? null : codec77(c72, 0), "isBanned": c73, "sql": c74 === null ? null : dec78.mapFromDriverValue(c74), "sqlWrapper": c75 === null ? null : dec79.mapFromDriverValue(c75) };
+				}
+			}
+			c7 = { "id": c47, "authorId": c48 === null ? null : codec54(c48, 0), "content": c49, "sql": c50 === null ? null : dec55.mapFromDriverValue(c50), "sqlWrapper": c51 === null ? null : dec56.mapFromDriverValue(c51), "author": c52, "authors": c53 };
+		}
+		rows[i] = { "id": c0 === null ? null : codec8(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec9(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec10.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec11.mapFromDriverValue(c5), "post": c6, "posts": c7 };
+	}
+	return rows;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+});
+
+test('Jit mappers: relational - array mode', async () => {
+	const empty1 = db.query.users.findFirst().prepare().mapper?.body;
+	const empty2 = db.query.users.findMany().prepare().mapper?.body;
+
+	expect(empty1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3 ] = row;
+	return { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(empty2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const row = rows[i];
+		let [ c0, c1, c2, c3 ] = row;
+		mapped[i] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const simple1 = db.query.users.findFirst().prepare().mapper?.body;
+	const simple2 = db.query.users.findMany().prepare().mapper?.body;
+
+	expect(simple1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3 ] = row;
+	return { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(simple2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec4 } = selection[0];
+	const { codec: codec5 } = selection[2];
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const row = rows[i];
+		let [ c0, c1, c2, c3 ] = row;
+		mapped[i] = { "id": c0 === null ? null : codec4(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec5(c2, 0), "isBanned": c3 };
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const extras1 = db.query.users.findFirst({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	}).prepare().mapper?.body;
+	const extras2 = db.query.users.findMany({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	}).prepare().mapper?.body;
+
+	expect(extras1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { field: { decoder: dec9 } } = selection[5];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3, c4, c5 ] = row;
+	return { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec9.mapFromDriverValue(c5) };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(extras2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { field: { decoder: dec9 } } = selection[5];
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const row = rows[i];
+		let [ c0, c1, c2, c3, c4, c5 ] = row;
+		mapped[i] = { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "sqlWrapper": c5 === null ? null : dec9.mapFromDriverValue(c5) };
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+
+	const nested1 = db.query.users.findFirst({
+		with: {
+			post: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+		},
+	}).prepare().mapper?.body;
+	const nested2 = db.query.users.findMany({
+		with: {
+			post: {
+				with: {
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+		},
+	}).prepare().mapper?.body;
+
+	expect(nested1).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { selection: s9 } = selection[5];
+	const { codec: codec16 } = s9[1];
+	const { field: { decoder: dec17 } } = s9[3];
+	const { selection: s18 } = s9[4];
+	const { codec: codec24 } = s18[0];
+	const { codec: codec25 } = s18[2];
+	const { field: { decoder: dec26 } } = s18[4];
+	const { selection: s27 } = s9[5];
+	const { codec: codec34 } = s27[0];
+	const { codec: codec35 } = s27[2];
+	const { field: { decoder: dec36 } } = s27[4];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3, c4, c5 ] = row;
+	if (c5 !== null) {
+		let { "id": c10, "authorId": c11, "content": c12, "sql": c13, "author": c14, "authors": c15 } = c5;
+		if (c14 !== null) {
+			let { "id": c19, "name": c20, "createdAt": c21, "isBanned": c22, "sql": c23 } = c14;
+			c14 = { "id": c19 === null ? null : codec24(c19, 0), "name": c20, "createdAt": c21 === null ? null : codec25(c21, 0), "isBanned": c22, "sql": c23 === null ? null : dec26.mapFromDriverValue(c23) };
+		}
+		if (c15 !== null) {
+			for (let j28 = 0; j28 < c15.length; ++j28) {
+				let { "id": c29, "name": c30, "createdAt": c31, "isBanned": c32, "sql": c33 } = c15[j28];
+				c15[j28] = { "id": c29 === null ? null : codec34(c29, 0), "name": c30, "createdAt": c31 === null ? null : codec35(c31, 0), "isBanned": c32, "sql": c33 === null ? null : dec36.mapFromDriverValue(c33) };
+			}
+		}
+		c5 = { "id": c10, "authorId": c11 === null ? null : codec16(c11, 0), "content": c12, "sql": c13 === null ? null : dec17.mapFromDriverValue(c13), "author": c14, "authors": c15 };
+	}
+	return { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "post": c5 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(nested2).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec6 } = selection[0];
+	const { codec: codec7 } = selection[2];
+	const { field: { decoder: dec8 } } = selection[4];
+	const { selection: s9 } = selection[5];
+	const { codec: codec15 } = s9[1];
+	const { field: { decoder: dec16 } } = s9[3];
+	const { selection: s17 } = s9[4];
+	const { codec: codec24 } = s17[0];
+	const { codec: codec25 } = s17[2];
+	const { field: { decoder: dec26 } } = s17[4];
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	for (let i = 0; i < length; ++i) {
+		const row = rows[i];
+		let [ c0, c1, c2, c3, c4, c5 ] = row;
+		if (c5 !== null) {
+			let { "id": c10, "authorId": c11, "content": c12, "sql": c13, "authors": c14 } = c5;
+			if (c14 !== null) {
+				for (let j18 = 0; j18 < c14.length; ++j18) {
+					let { "id": c19, "name": c20, "createdAt": c21, "isBanned": c22, "sql": c23 } = c14[j18];
+					c14[j18] = { "id": c19 === null ? null : codec24(c19, 0), "name": c20, "createdAt": c21 === null ? null : codec25(c21, 0), "isBanned": c22, "sql": c23 === null ? null : dec26.mapFromDriverValue(c23) };
+				}
+			}
+			c5 = { "id": c10, "authorId": c11 === null ? null : codec15(c11, 0), "content": c12, "sql": c13 === null ? null : dec16.mapFromDriverValue(c13), "authors": c14 };
+		}
+		mapped[i] = { "id": c0 === null ? null : codec6(c0, 0), "name": c1, "createdAt": c2 === null ? null : codec7(c2, 0), "isBanned": c3, "sql": c4 === null ? null : dec8.mapFromDriverValue(c4), "post": c5 };
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+});
+
+test('Jit mappers: SQLWrapper', () => {
+	const cus = customType<{ data: Date; driverData: string; jsonData: string }>({
+		codec: 'timestamptz',
+		dataType: () => 'timestamptz',
+		forJsonSelect: (id, s) => s`${id}::text`,
+		fromJson: (v) => new Date(v as string),
+		toDriver: (v) => v.toISOString(),
+	});
+	const t = pgTable('jit_sqlw_regression', {
+		id: integer('id').primaryKey(),
+		c: cus('c').notNull(),
+	});
+
+	const jsonWrapper = { getSQL: () => sql`select 1`.mapWith(t.c) };
+	const numberWrapper = { getSQL: () => sql`select 1`.mapWith(Number) };
+	const noopWrapper = { getSQL: () => sql`select 1` };
+
+	const jsonFirst = makeJitRqbMapper({
+		selection: [{ key: 'val', field: jsonWrapper }],
+		isFirst: true,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: true,
+		arrayModeRoot: false,
+	});
+	expect(jsonFirst.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const dec1 = selection[0].field.getSQL().decoder;
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "val": c0 } = row;
+	rows[0] = { "val": c0 === null ? null : dec1.mapFromJsonValue(c0) };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(jsonFirst([{ val: '2024-01-02T03:04:05.000Z' }])).toStrictEqual({
+		val: new Date('2024-01-02T03:04:05.000Z'),
+	});
+	expect(jsonFirst([{ val: null }])).toStrictEqual({ val: null });
+	expect(jsonFirst([])).toBeUndefined();
+
+	const jsonMany = makeJitRqbMapper({
+		selection: [{ key: 'val', field: jsonWrapper as any }],
+		isFirst: false,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: true,
+		arrayModeRoot: false,
+	});
+	expect(jsonMany.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const dec1 = selection[0].field.getSQL().decoder;
+	for (let i = 0; i < rows.length; ++i) {
+		const row = rows[i];
+		let { "val": c0 } = row;
+		rows[i] = { "val": c0 === null ? null : dec1.mapFromJsonValue(c0) };
+	}
+	return rows;
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(jsonMany([{ val: '2024-01-02T03:04:05.000Z' }, { val: null }])).toStrictEqual([
+		{ val: new Date('2024-01-02T03:04:05.000Z') },
+		{ val: null },
+	]);
+
+	const driverFirst = makeJitRqbMapper({
+		selection: [{ key: 'val', field: numberWrapper }],
+		isFirst: true,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: false,
+		arrayModeRoot: false,
+	});
+	expect(driverFirst.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const dec1 = selection[0].field.getSQL().decoder;
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "val": c0 } = row;
+	rows[0] = { "val": c0 === null ? null : dec1.mapFromDriverValue(c0) };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(driverFirst([{ val: '42' }])).toStrictEqual({ val: 42 });
+	expect(driverFirst([{ val: null }])).toStrictEqual({ val: null });
+
+	const noopMapper = makeJitRqbMapper({
+		selection: [{ key: 'val', field: noopWrapper }],
+		isFirst: true,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: true,
+		arrayModeRoot: false,
+	});
+	expect(noopMapper.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(noopMapper([{ val: 'raw' }])).toStrictEqual({ val: 'raw' });
+
+	const mixed = makeJitRqbMapper({
+		selection: [
+			{ key: 'id', field: t.id },
+			{ key: 'val', field: jsonWrapper },
+		],
+		isFirst: true,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: true,
+		arrayModeRoot: false,
+	});
+	expect(mixed.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const dec2 = selection[1].field.getSQL().decoder;
+	const row = rows[0];
+	if (!row) return undefined;
+	let { "id": c0, "val": c1 } = row;
+	rows[0] = { "id": c0, "val": c1 === null ? null : dec2.mapFromJsonValue(c1) };
+	return rows[0];
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(mixed([{ id: 7, val: '2024-01-02T03:04:05.000Z' }])).toStrictEqual({
+		id: 7,
+		val: new Date('2024-01-02T03:04:05.000Z'),
+	});
+
+	const arrayMode = makeJitRqbMapper({
+		selection: [{ key: 'val', field: jsonWrapper }],
+		isFirst: true,
+		parseJson: false,
+		parseJsonIfString: false,
+		rootJsonMappers: true,
+		arrayModeRoot: true,
+	});
+	expect(arrayMode.body).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0 ] = row;
+	return { "val": c0 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+	expect(arrayMode([['raw']])).toStrictEqual({ val: 'raw' });
+});
+
+const codecBypass = customType<{ data: Date; driverData: string; jsonData: string }>({
+	codec: 'timestamptz',
+	dataType: () => 'timestamptz(3)',
+	forJsonSelect: (id, s, arrayDimensions) =>
+		s`${id}::text${arrayDimensions ? s.raw('[]'.repeat(arrayDimensions)) : undefined}`,
+	fromJson: (v) => new Date(v as string),
+	toDriver: (v) => v.toISOString(),
+});
+
+const codecUsers = pgTable('codec_users_jit', (t) => ({
+	id: t.integer().primaryKey(),
+	name: t.text().notNull(),
+	createdAt: t.timestamp('created_at').notNull(),
+	createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+	arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+	cus: codecBypass('cus').notNull(),
+	arrCus: codecBypass('arr_cus').notNull().array(),
+}));
+
+const codecUsersView = pgView('codec_users_v_jit').as((qb) =>
+	qb.select({
+		...getColumns(codecUsers),
+		max: max(codecUsers.createdAt).as('max'),
+		maxStr: max(codecUsers.createdAtStr).as('max_str'),
+		arrMax: max(codecUsers.arrCreatedAt).as('arr_max'),
+		sq: qb.select({ createdAt: codecUsers.createdAt }).from(codecUsers).as('sq'),
+	}).from(codecUsers).groupBy(codecUsers.id)
+);
+
+const codecDb = createDB({ codecUsers, codecUsersView }, (r) => ({
+	codecUsers: { self: r.one.codecUsers({ from: r.codecUsers.id, to: r.codecUsers.id }) },
+	codecUsersView: { self: r.one.codecUsersView({ from: r.codecUsersView.id, to: r.codecUsersView.id }) },
+}));
+
+test('Jit mappers: codecs from columns as SQL decoders', () => {
+	const tableBody = codecDb.select({
+		...getColumns(codecUsers),
+		max: max(codecUsers.createdAt).as('max'),
+		maxStr: max(codecUsers.createdAtStr).as('max_str'),
+		arrMax: max(codecUsers.arrCreatedAt).as('arr_max'),
+		sq: codecDb.select({ createdAt: codecUsers.createdAt }).from(codecUsers).as('sq'),
+	}).from(codecUsers).groupBy(codecUsers.id).prepare().mapper?.body;
+
+	expect(tableBody).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec2 } = columns[2];
+	const { codec: codec4 } = columns[4];
+	const { codec: codec5 } = columns[5];
+	const { codec: codec6 } = columns[6];
+	const { codec: codec7 } = columns[7];
+	const { codec: codec9 } = columns[9];
+	const { codec: codec10 } = columns[10];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ] = rows[i];
+		mapped[i] = {
+			"id": c0,
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"createdAtStr": c3,
+			"arrCreatedAt": c4 === null ? c4 : codec4(c4, 1),
+			"cus": c5 === null ? c5 : codec5(c5, 0),
+			"arrCus": c6 === null ? c6 : codec6(c6, 1),
+			"max": c7 === null ? c7 : codec7(c7, 0),
+			"maxStr": c8,
+			"arrMax": c9 === null ? c9 : codec9(c9, 1),
+			"sq": c10 === null ? c10 : codec10(c10, 0),
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+});
+
+test('Jit mappers: codecs from columns as SQL decoders - view', () => {
+	const viewBody = codecDb.select().from(codecUsersView).prepare().mapper?.body;
+
+	expect(viewBody).toStrictEqual(`function jitQueryMapper (rows) {
+	"use strict";
+	const { columns } = this;
+	const { length } = rows;
+	const mapped = Array.from({ length });
+	const { codec: codec2 } = columns[2];
+	const { codec: codec4 } = columns[4];
+	const { codec: codec5 } = columns[5];
+	const { codec: codec6 } = columns[6];
+	const { codec: codec7 } = columns[7];
+	const { codec: codec9 } = columns[9];
+	const { codec: codec10 } = columns[10];
+	for (let i = 0; i < length; ++i) {
+		const [ c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ] = rows[i];
+		mapped[i] = {
+			"id": c0,
+			"name": c1,
+			"createdAt": c2 === null ? c2 : codec2(c2, 0),
+			"createdAtStr": c3,
+			"arrCreatedAt": c4 === null ? c4 : codec4(c4, 1),
+			"cus": c5 === null ? c5 : codec5(c5, 0),
+			"arrCus": c6 === null ? c6 : codec6(c6, 1),
+			"max": c7 === null ? c7 : codec7(c7, 0),
+			"maxStr": c8,
+			"arrMax": c9 === null ? c9 : codec9(c9, 1),
+			"sq": c10 === null ? c10 : codec10(c10, 0),
+		};
+	}
+	return mapped;
+	//# sourceURL=drizzle:jit-query-mapper
+}`);
+});
+
+test('Jit mappers: codecs from columns as SQL decoders, codec bypass - RQB', () => {
+	const tableBody = codecDb.query.codecUsers.findFirst({
+		with: {
+			self: {
+				extras: {
+					max: () => sql`select max(${codecUsers.createdAt}) from ${codecUsers}`.mapWith(codecUsers.createdAt),
+				},
+			},
+		},
+		extras: {
+			max: () => sql`select max(${codecUsers.createdAt}) from ${codecUsers}`.mapWith(codecUsers.createdAt),
+		},
+	}).prepare().mapper?.body;
+
+	expect(tableBody).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec9 } = selection[2];
+	const { codec: codec10 } = selection[4];
+	const { codec: codec11 } = selection[5];
+	const { codec: codec12 } = selection[6];
+	const { codec: codec13 } = selection[7];
+	const { selection: s14 } = selection[8];
+	const { codec: codec23 } = s14[2];
+	const { codec: codec24 } = s14[4];
+	const { field: dec25 } = s14[5];
+	const { field: dec26 } = s14[6];
+	const { codec: codec27 } = s14[7];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3, c4, c5, c6, c7, c8 ] = row;
+	if (c8 !== null) {
+		let { "id": c15, "name": c16, "createdAt": c17, "createdAtStr": c18, "arrCreatedAt": c19, "cus": c20, "arrCus": c21, "max": c22 } = c8;
+		c8 = { "id": c15, "name": c16, "createdAt": c17 === null ? null : codec23(c17, 0), "createdAtStr": c18, "arrCreatedAt": c19 === null ? null : codec24(c19, 1), "cus": c20 === null ? null : dec25.mapFromJsonValue(c20), "arrCus": c21 === null ? null : dec26.mapFromJsonValue(c21), "max": c22 === null ? null : codec27(c22, 0) };
+	}
+	return { "id": c0, "name": c1, "createdAt": c2 === null ? null : codec9(c2, 0), "createdAtStr": c3, "arrCreatedAt": c4 === null ? null : codec10(c4, 1), "cus": c5 === null ? null : codec11(c5, 0), "arrCus": c6 === null ? null : codec12(c6, 1), "max": c7 === null ? null : codec13(c7, 0), "self": c8 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+});
+
+test('Jit mappers: codecs from columns as SQL decoders, codec bypass - view, RQB', () => {
+	const viewNestedBody = codecDb.query.codecUsersView.findFirst({
+		columns: { sq: false }, // TODO: re-enable after supporting Subquery in RQB
+		with: { self: { columns: { sq: false } } }, // TODO: re-enable after supporting Subquery in RQB
+	}).prepare().mapper?.body;
+
+	expect(viewNestedBody).toStrictEqual(`function jitRqbMapper (rows) {
+	"use strict";
+	const { selection } = this;
+	const { codec: codec11 } = selection[2];
+	const { codec: codec12 } = selection[4];
+	const { codec: codec13 } = selection[5];
+	const { codec: codec14 } = selection[6];
+	const { codec: codec15 } = selection[7];
+	const { codec: codec16 } = selection[9];
+	const { selection: s17 } = selection[10];
+	const { codec: codec28 } = s17[2];
+	const { codec: codec29 } = s17[4];
+	const { field: dec30 } = s17[5];
+	const { field: dec31 } = s17[6];
+	const { codec: codec32 } = s17[7];
+	const { codec: codec33 } = s17[9];
+	const row = rows[0];
+	if (!row) return undefined;
+	let [ c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ] = row;
+	if (c10 !== null) {
+		let { "id": c18, "name": c19, "createdAt": c20, "createdAtStr": c21, "arrCreatedAt": c22, "cus": c23, "arrCus": c24, "max": c25, "maxStr": c26, "arrMax": c27 } = c10;
+		c10 = { "id": c18, "name": c19, "createdAt": c20 === null ? null : codec28(c20, 0), "createdAtStr": c21, "arrCreatedAt": c22 === null ? null : codec29(c22, 1), "cus": c23 === null ? null : dec30.mapFromJsonValue(c23), "arrCus": c24 === null ? null : dec31.mapFromJsonValue(c24), "max": c25 === null ? null : codec32(c25, 0), "maxStr": c26, "arrMax": c27 === null ? null : codec33(c27, 1) };
+	}
+	return { "id": c0, "name": c1, "createdAt": c2 === null ? null : codec11(c2, 0), "createdAtStr": c3, "arrCreatedAt": c4 === null ? null : codec12(c4, 1), "cus": c5 === null ? null : codec13(c5, 0), "arrCus": c6 === null ? null : codec14(c6, 1), "max": c7 === null ? null : codec15(c7, 0), "maxStr": c8, "arrMax": c9 === null ? null : codec16(c9, 1), "self": c10 };
+	//# sourceURL=drizzle:jit-relational-query-mapper
+}`);
+});
diff --git a/drizzle-orm/tests/relation.test.ts b/drizzle-orm/tests/relation.test.ts
index 0fe054812b..19b5fa1c2a 100644
--- a/drizzle-orm/tests/relation.test.ts
+++ b/drizzle-orm/tests/relation.test.ts
@@ -1,7 +1,7 @@
 import { expect, test } from 'vitest';
 
+import { createTableRelationsHelpers, extractTablesRelationalConfig } from '~/_relations.ts';
 import { pgSchema, pgTable } from '~/pg-core/index.ts';
-import { createTableRelationsHelpers, extractTablesRelationalConfig } from '~/relations.ts';
 
 test('tables with same name in different schemas', () => {
 	const folder = pgSchema('folder');
@@ -14,20 +14,18 @@ test('tables with same name in different schemas', () => {
 		},
 	};
 
-	const relationalSchema = {
-		...Object.fromEntries(
-			Object.entries(schema)
-				.flatMap(([key, val]) => {
-					// have unique keys across schemas
+	const relationalSchema = Object.fromEntries(
+		Object.entries(schema)
+			.flatMap(([key, val]) => {
+				// have unique keys across schemas
 
-					const mappedTableEntries = Object.entries(val).map((tableEntry) => {
-						return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
-					});
+				const mappedTableEntries = Object.entries(val).map((tableEntry) => {
+					return [`__${key}__.${tableEntry[0]}`, tableEntry[1]];
+				});
 
-					return mappedTableEntries;
-				}),
-		),
-	};
+				return mappedTableEntries;
+			}),
+	);
 
 	const relationsConfig = extractTablesRelationalConfig(
 		relationalSchema,
diff --git a/drizzle-orm/tests/rqb-builders.test.ts b/drizzle-orm/tests/rqb-builders.test.ts
new file mode 100644
index 0000000000..1f4ba2a648
--- /dev/null
+++ b/drizzle-orm/tests/rqb-builders.test.ts
@@ -0,0 +1,342 @@
+import { describe, expect, test } from 'vitest';
+import type { AnyColumn } from '~/column';
+import { date, integer, pgTable, text } from '~/pg-core';
+import { defineRelations, relationsFilterToSQL, relationsOrderToSQL } from '~/relations';
+import type { OrderBy, OrderByOperators, TableFilter } from '~/relations';
+import {
+	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
+	asc,
+	desc,
+	eq,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNotNull,
+	isNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notIlike,
+	notInArray,
+	notLike,
+	or,
+	type SQL,
+	sql,
+} from '~/sql';
+import type { AnyTable, Table } from '~/table';
+import type { Simplify, ValueOrArray } from '~/utils';
+
+const table = pgTable('test', {
+	string: text(),
+	number: integer(),
+	arr: integer().array(),
+	date: date('date', {
+		mode: 'date',
+	}),
+});
+
+const buildFilter = <TTable extends Table>(table: TTable, filter: TableFilter<TTable>) =>
+	relationsFilterToSQL(table, filter as TableFilter);
+
+describe('Filters', () => {
+	test('No shortcuts for object-type data', () => {
+		try {
+			buildFilter(table, {
+				// @ts-expect-error
+				date: new Date(),
+			});
+			buildFilter(table, {
+				date: sql.placeholder('date'),
+			});
+			buildFilter(table, {
+				date: {
+					eq: new Date(),
+				},
+			});
+			buildFilter(table, {
+				date: {
+					eq: sql.placeholder('date'),
+				},
+			});
+		} catch {
+			return;
+		}
+	});
+
+	test('eq shortcut', () => {
+		expect(buildFilter(table, {
+			number: 1,
+		})).toStrictEqual(and(eq(table.number, 1)));
+	});
+
+	test('eq', () => {
+		expect(buildFilter(table, {
+			number: {
+				eq: 2,
+			},
+			date: undefined,
+		})).toStrictEqual(and(and(eq(table.number, 2))));
+	});
+
+	test('ne', () => {
+		expect(buildFilter(table, {
+			number: {
+				ne: 2,
+			},
+			date: undefined,
+		})).toStrictEqual(and(and(ne(table.number, 2))));
+	});
+
+	test('gt', () => {
+		expect(buildFilter(table, {
+			number: {
+				gt: 2,
+			},
+		})).toStrictEqual(and(and(gt(table.number, 2))));
+	});
+
+	test('gte', () => {
+		expect(buildFilter(table, {
+			number: {
+				gte: 2,
+			},
+		})).toStrictEqual(and(and(gte(table.number, 2))));
+	});
+
+	test('lt', () => {
+		expect(buildFilter(table, {
+			number: {
+				lt: 2,
+			},
+		})).toStrictEqual(and(and(lt(table.number, 2))));
+	});
+
+	test('lte', () => {
+		expect(buildFilter(table, {
+			number: {
+				lte: 2,
+			},
+		})).toStrictEqual(and(and(lte(table.number, 2))));
+	});
+
+	test('ilike', () => {
+		expect(buildFilter(table, {
+			string: {
+				ilike: '%I',
+			},
+		})).toStrictEqual(and(and(ilike(table.string, '%I'))));
+	});
+
+	test('like', () => {
+		expect(buildFilter(table, {
+			string: {
+				like: '%I',
+			},
+		})).toStrictEqual(and(and(like(table.string, '%I'))));
+	});
+
+	test('notIlike', () => {
+		expect(buildFilter(table, {
+			string: {
+				notIlike: '%I',
+			},
+		})).toStrictEqual(and(and(notIlike(table.string, '%I'))));
+	});
+
+	test('notLike', () => {
+		expect(buildFilter(table, {
+			string: {
+				notLike: '%I',
+			},
+		})).toStrictEqual(and(and(notLike(table.string, '%I'))));
+	});
+
+	test('in', () => {
+		expect(buildFilter(table, {
+			number: {
+				in: [2, 3],
+			},
+		})).toStrictEqual(and(and(inArray(table.number, [2, 3]))));
+	});
+
+	test('notIn', () => {
+		expect(buildFilter(table, {
+			number: {
+				notIn: [2, 3],
+			},
+		})).toStrictEqual(and(and(notInArray(table.number, [2, 3]))));
+	});
+
+	test('arrayContains', () => {
+		expect(buildFilter(table, {
+			arr: {
+				arrayContains: [2, 3],
+			},
+		})).toStrictEqual(and(and(arrayContains(table.arr, [2, 3]))));
+	});
+
+	test('arrayContained', () => {
+		expect(buildFilter(table, {
+			arr: {
+				arrayContained: [2, 3],
+			},
+		})).toStrictEqual(and(and(arrayContained(table.arr, [2, 3]))));
+	});
+
+	test('arrayOverlaps', () => {
+		expect(buildFilter(table, {
+			arr: {
+				arrayOverlaps: [2, 3],
+			},
+		})).toStrictEqual(and(and(arrayOverlaps(table.arr, [2, 3]))));
+	});
+
+	test('isNotNull', () => {
+		expect(buildFilter(table, {
+			number: {
+				isNotNull: true,
+			},
+		})).toStrictEqual(and(and(isNotNull(table.number))));
+	});
+
+	test('isNull', () => {
+		expect(buildFilter(table, {
+			number: {
+				isNull: true,
+			},
+		})).toStrictEqual(and(and(isNull(table.number))));
+	});
+
+	test('column NOT', () => {
+		expect(buildFilter(table, {
+			number: {
+				NOT: {
+					isNull: true,
+				},
+			},
+		})).toStrictEqual(and(and(not(and(isNull(table.number))!))));
+	});
+
+	test('column OR', () => {
+		expect(buildFilter(table, {
+			number: {
+				OR: [{
+					isNull: true,
+				}, {
+					isNotNull: true,
+				}],
+			},
+		})).toStrictEqual(and(and(or(and(isNull(table.number)), and(isNotNull(table.number))!))));
+	});
+
+	test('RAW', () => {
+		expect(buildFilter(table, {
+			RAW: (t, { sql }) => sql`${t} ${t.string} ${t.date} ${t.number}`,
+		})).toStrictEqual(and(sql`${table} ${table.string} ${table.date} ${table.number}`));
+	});
+
+	test('NOT', () => {
+		expect(buildFilter(table, {
+			NOT: {
+				number: {
+					eq: 2,
+				},
+			},
+		})).toStrictEqual(and(not(and(and(eq(table.number, 2)))!)));
+	});
+
+	test('NOT', () => {
+		expect(buildFilter(table, {
+			OR: [{
+				number: {
+					eq: 2,
+				},
+			}, {
+				string: 'str',
+			}],
+		})).toStrictEqual(and(
+			or(
+				and(and(eq(table.number, 2))),
+				and(eq(table.string, 'str')),
+			)!,
+		));
+	});
+
+	test('AND', () => {
+		expect(buildFilter(table, {
+			number: {
+				OR: [1, 2],
+			},
+			string: 'str',
+		})).toStrictEqual(and(
+			and(or(eq(table.number, 1), eq(table.number, 2))),
+			eq(table.string, 'str'),
+		));
+	});
+});
+
+const buildOrder = <TTable extends Table>(
+	table: TTable,
+	order:
+		| {
+			[K in keyof TTable['_']['columns']]?: 'asc' | 'desc' | undefined;
+		}
+		| ((
+			fields: Simplify<
+				AnyTable<TTable['_']> & TTable['_']['columns']
+			>,
+			operators: OrderByOperators,
+		) => ValueOrArray<AnyColumn | SQL>),
+) => relationsOrderToSQL(table, order as OrderBy);
+
+describe('Orders', () => {
+	test('Callback column', () => {
+		expect(buildOrder(table, ({ date }) => date)).toStrictEqual(asc(table.date));
+	});
+
+	test('Callback SQL', () => {
+		expect(buildOrder(table, ({ date }, { desc }) => desc(date))).toStrictEqual(desc(table.date));
+	});
+
+	test('Callback array', () => {
+		expect(buildOrder(table, ({ date, number, string }, { asc, desc }) => [desc(date), asc(number), string]))
+			.toStrictEqual(sql.join([desc(table.date), asc(table.number), asc(table.string)], sql`, `));
+	});
+
+	test('Object', () => {
+		expect(buildOrder(table, {
+			string: 'desc',
+			number: undefined,
+			date: 'asc',
+		})).toStrictEqual(sql.join([desc(table.string), asc(table.date)], sql`, `));
+	});
+
+	test('Undefined object', () => {
+		expect(buildOrder(table, {
+			number: undefined,
+			date: undefined,
+		})).toStrictEqual(undefined);
+	});
+
+	test('Empty object', () => {
+		expect(buildOrder(table, {})).toStrictEqual(undefined);
+	});
+});
+
+test('Relation & colum names collision', () => {
+	expect(() =>
+		defineRelations({ table }, (r) => ({
+			table: {
+				string: r.one.table(),
+			},
+		}))
+	).toThrowError(
+		`relations -> table: { string: r.one.table(...) }: relation name collides with column "string" of table "table"`,
+	);
+});
diff --git a/drizzle-orm/tests/sql-builder.test.ts b/drizzle-orm/tests/sql-builder.test.ts
new file mode 100644
index 0000000000..882009a91b
--- /dev/null
+++ b/drizzle-orm/tests/sql-builder.test.ts
@@ -0,0 +1,67 @@
+import { expect, test } from 'vitest';
+import { PgDialect, pgTable, serial, text } from '~/pg-core';
+import { and, eq, not, or, sql } from '~/sql';
+
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+// Dialect type is irrelevant
+const dialect = new PgDialect();
+
+test('OR conditions wrapped in parentheses', () => {
+	const query = or(eq(users.id, 1), sql`never`.if(false), sql`users.id = post.user_id AND posts.is_deleted = false`);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`(("users"."id" = 1) or (users.id = post.user_id AND posts.is_deleted = false))`);
+});
+
+test('AND conditions wrapped in parentheses', () => {
+	const query = and(eq(users.id, 1), sql`never`.if(false), sql`users.id = post.user_id AND posts.is_deleted = false`);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`(("users"."id" = 1) and (users.id = post.user_id AND posts.is_deleted = false))`);
+});
+
+test('NOT conditions wrapped in parentheses for SQL', () => {
+	const query = not(sql`users.id = post.user_id AND posts.is_deleted = false`);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`not (users.id = post.user_id AND posts.is_deleted = false)`);
+});
+
+test('NOT conditions not wrapped in parentheses for non-SQL', () => {
+	const query = not(users.id);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`not "users"."id"`);
+});
+
+test.skipIf(Date.now() < +new Date('2026-07-01'))('OR conditions deep filter empty queries', () => {
+	const query = or(
+		eq(users.id, 1),
+		sql`${sql`never`.if(false)}`,
+		sql`users.id = post.user_id AND posts.is_deleted = false`,
+	);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`(("users"."id" = 1) or (users.id = post.user_id AND posts.is_deleted = false))`);
+});
+
+test.skipIf(Date.now() < +new Date('2026-07-01'))('AND conditions deep filter empty queries', () => {
+	const query = and(
+		eq(users.id, 1),
+		sql`${sql`never`.if(false)}`,
+		sql`users.id = post.user_id AND posts.is_deleted = false`,
+	);
+	const { sql: text } = dialect.sqlToQuery(query!.inlineParams());
+
+	expect(text).toStrictEqual(`(("users"."id" = 1) and (users.id = post.user_id AND posts.is_deleted = false))`);
+});
+
+test.skipIf(Date.now() < +new Date('2026-07-01'))('NOT conditions deep filter empty queries', () => {
+	const query = not(sql`${sql`never`.if(false)}`);
+
+	expect(query).toBeUndefined();
+});
diff --git a/drizzle-orm/tests/sqlcommenter.test.ts b/drizzle-orm/tests/sqlcommenter.test.ts
new file mode 100644
index 0000000000..5bcaa1ca74
--- /dev/null
+++ b/drizzle-orm/tests/sqlcommenter.test.ts
@@ -0,0 +1,223 @@
+import { expect, test } from 'vitest';
+import { sqlCommenter } from '~/sql/sql.ts';
+
+test('simple encode', () => {
+	const result = sqlCommenter({
+		route: '/users',
+	});
+
+	expect(result).toBe("/*route='%2Fusers'*/");
+});
+
+test('sort keys lexicographically', () => {
+	const result = sqlCommenter({
+		b: '2',
+		a: '1',
+	});
+
+	expect(result).toBe("/*a='1',b='2'*/");
+});
+
+test('skip null, undefined and empty string values', () => {
+	const result = sqlCommenter({
+		a: '1',
+		b: null,
+		c: undefined,
+		d: 0,
+		e: '',
+	});
+
+	expect(result).toBe("/*a='1',d='0'*/");
+});
+
+test('encode special characters', () => {
+	const result = sqlCommenter({
+		email: 'john@example.com',
+	});
+
+	expect(result).toBe("/*email='john%40example.com'*/");
+});
+
+test('escape single quotes', () => {
+	const result = sqlCommenter({
+		name: "O'Reilly",
+	});
+
+	expect(result).toBe("/*name='O\\'Reilly'*/");
+});
+
+test('encode slashes', () => {
+	const result = sqlCommenter({
+		test: '*/',
+	});
+
+	expect(result).toBe("/*test='*%2F'*/");
+});
+
+test('prevent comment closure injection', () => {
+	const result = sqlCommenter({
+		attack: 'abc*/DROP TABLE users--',
+	});
+
+	expect(result).not.toContain('*/DROP');
+	expect(result).toContain('*%2FDROP');
+});
+
+test('encode commas and equals signs', () => {
+	const result = sqlCommenter({
+		tricky: 'a,b=c',
+	});
+
+	expect(result).toBe("/*tricky='a%2Cb%3Dc'*/");
+});
+
+test('encode keys', () => {
+	const result = sqlCommenter({
+		'user id': '123',
+	});
+
+	expect(result).toBe("/*user%20id='123'*/");
+});
+
+test('handle boolean and number values', () => {
+	const result = sqlCommenter({
+		flag: true,
+		count: 42,
+		bigint: 25n,
+	});
+
+	expect(result).toBe("/*bigint='25',count='42',flag='true'*/");
+});
+
+test('return empty string for empty input', () => {
+	const result = sqlCommenter({});
+	expect(result).toBe('');
+});
+
+test('never emit raw single quote', () => {
+	const result = sqlCommenter({
+		test: "a'b",
+	});
+
+	expect(result).not.toContain("'a'b'");
+	expect(result).toContain("'a\\'b'");
+});
+
+test('never emit comment terminator', () => {
+	const result = sqlCommenter({
+		test: '*/',
+	}).slice(2, -2);
+
+	expect(result).not.toContain('*/');
+	expect(result).toContain('*%2F');
+});
+
+test('decode', () => {
+	const input = {
+		key: "a'b*/c",
+	};
+
+	const encoded = sqlCommenter(input);
+
+	const match = encoded.match(/key='(.*)'/);
+	expect(match).not.toBeNull();
+
+	const decoded = decodeURIComponent(match?.[1] ?? '');
+	expect(decoded).toBe("a\\'b*/c");
+});
+
+test('merge strings', () => {
+	const encoded = sqlCommenter.merge('somestr*/', 'str2');
+
+	expect(encoded).toStrictEqual(`/*somestr* /,str2*/`);
+});
+
+test('merge objects', () => {
+	const encoded = sqlCommenter.merge({ a: 1, c: '3' }, {
+		b: 2,
+		x: 9,
+	});
+
+	expect(encoded).toStrictEqual(`/*a='1',b='2',c='3',x='9'*/`);
+});
+
+test('merge string with object', () => {
+	const encoded = sqlCommenter.merge('somestr*/', {
+		b: 2,
+		x: 9,
+	});
+
+	expect(encoded).toStrictEqual(`/*somestr* /,b='2',x='9'*/`);
+});
+
+test('merge object with string', () => {
+	const encoded = sqlCommenter.merge({ a: 1, c: '3' }, 'str2');
+
+	expect(encoded).toStrictEqual(`/*a='1',c='3',str2*/`);
+});
+
+test('merge undefined with string', () => {
+	const encoded = sqlCommenter.merge(undefined, 'str2');
+
+	expect(encoded).toStrictEqual(`/*str2*/`);
+});
+
+test('merge undefined with object', () => {
+	const encoded = sqlCommenter.merge(undefined, {
+		b: 2,
+		x: 9,
+	});
+
+	expect(encoded).toStrictEqual(`/*b='2',x='9'*/`);
+});
+
+test('merge empty string with object', () => {
+	const encoded = sqlCommenter.merge('', {
+		b: 2,
+		x: 9,
+	});
+
+	expect(encoded).toStrictEqual(`/*b='2',x='9'*/`);
+});
+
+test('merge empty string with string', () => {
+	const encoded = sqlCommenter.merge('', 'str2');
+
+	expect(encoded).toStrictEqual(`/*str2*/`);
+});
+
+test('merge string with undefined', () => {
+	const encoded = sqlCommenter.merge('str2', undefined);
+
+	expect(encoded).toStrictEqual(`/*str2*/`);
+});
+
+test('merge object with undefined', () => {
+	const encoded = sqlCommenter.merge({
+		b: 2,
+		x: 9,
+	}, undefined);
+
+	expect(encoded).toStrictEqual(`/*b='2',x='9'*/`);
+});
+
+test('merge object with empty string', () => {
+	const encoded = sqlCommenter.merge({
+		b: 2,
+		x: 9,
+	}, '');
+
+	expect(encoded).toStrictEqual(`/*b='2',x='9'*/`);
+});
+
+test('merge string with empty string', () => {
+	const encoded = sqlCommenter.merge('str2', '');
+
+	expect(encoded).toStrictEqual(`/*str2*/`);
+});
+
+test('escape comments in string', () => {
+	const encoded = sqlCommenter('com*/*//*ment');
+
+	expect(encoded).toStrictEqual('/*com* / * // *ment*/');
+});
diff --git a/drizzle-orm/tests/type-hints.test.ts b/drizzle-orm/tests/type-hints.test.ts
deleted file mode 100644
index 40b40b9586..0000000000
--- a/drizzle-orm/tests/type-hints.test.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import { RDSDataClient } from '@aws-sdk/client-rds-data';
-import crypto from 'crypto';
-import { expect, test } from 'vitest';
-
-import { drizzle } from '~/aws-data-api/pg';
-import { customType, json, PgDialect, pgTable, text, timestamp, uuid, varchar } from '~/pg-core';
-import { sql } from '~/sql/sql';
-
-const db = drizzle(new RDSDataClient(), {
-	database: '',
-	resourceArn: '',
-	secretArn: '',
-});
-
-test('type hints - case #1', () => {
-	const t = pgTable('t', {
-		id: varchar('id', { length: 255 }).primaryKey(),
-		workspaceID: varchar('workspace_id', { length: 255 }).notNull(),
-		description: text('description').notNull(),
-		enrichment: json('enrichment').notNull(),
-		category: text('category'),
-		tags: text('tags').array().notNull(),
-		counterpartyName: text('counterparty_name'),
-		timePlaced: timestamp('time_placed').notNull(),
-		timeSynced: timestamp('time_synced').notNull(),
-	});
-
-	const q = db.insert(t).values({
-		id: 'id',
-		tags: [],
-		workspaceID: 'workspaceID',
-		enrichment: {},
-		category: 'category',
-		description: 'description',
-		timePlaced: new Date(),
-		timeSynced: sql<string>`CURRENT_TIMESTAMP(6)`,
-		counterpartyName: 'counterpartyName',
-	});
-
-	const query = new PgDialect().sqlToQuery(q.getSQL());
-
-	expect(query.typings).toEqual(['none', 'none', 'none', 'json', 'none', 'none', 'none', 'timestamp']);
-});
-
-test('type hints - case #2', () => {
-	const prefixedUlid = <Prefix extends string, PrefixedUlid = `${Prefix}_${string}`>(
-		name: string,
-		opts: { prefix: Prefix },
-	) =>
-		customType<{ data: PrefixedUlid; driverData: string }>({
-			dataType: () => 'uuid',
-			toDriver: (value) => {
-				return value as string;
-			},
-			fromDriver: (value) => {
-				return `${opts.prefix}_${value}` as PrefixedUlid;
-			},
-		})(name);
-
-	const calendars = pgTable('calendars', {
-		id: uuid('id').primaryKey().default(sql`gen_random_uuid()`),
-		orgMembershipId: prefixedUlid('om_id', { prefix: 'om' }).notNull(),
-		platform: text('platform').notNull(),
-		externalId: text('external_id').notNull(),
-		externalData: json('external_data').notNull(),
-		updatedAt: timestamp('updated_at').notNull().default(sql`now()`),
-		createdAt: timestamp('created_at').notNull().default(sql`now()`),
-	});
-
-	const q = db
-		.insert(calendars)
-		.values({
-			id: crypto.randomUUID(),
-			orgMembershipId: 'om_id',
-			platform: 'platform',
-			externalId: 'externalId',
-			externalData: {},
-		})
-		.returning();
-
-	const query = new PgDialect().sqlToQuery(q.getSQL());
-
-	expect(query.typings).toEqual(['uuid', 'none', 'none', 'none', 'json']);
-});
diff --git a/drizzle-orm/tests/utils.test.ts b/drizzle-orm/tests/utils.test.ts
new file mode 100644
index 0000000000..09c3f4290e
--- /dev/null
+++ b/drizzle-orm/tests/utils.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'vitest';
+import type { MigrationMeta } from '~/migrator';
+import { getMigrationsToRun } from '~/migrator.utils';
+
+describe('filter migrations to run: util function test', () => {
+	test('normal chronological migrations', async () => {
+		const localMigrations: MigrationMeta[] = [
+			{ folderMillis: 1700000000000, hash: 'hash1', sql: ['stmt1'], bps: true, name: '1' },
+			{ folderMillis: 1700000001000, hash: 'hash2', sql: ['stmt2'], bps: true, name: '2' },
+			{ folderMillis: 1700000002000, hash: 'hash3', sql: ['stmt3'], bps: true, name: '3' },
+		];
+		const dbMigrations = [
+			{ id: 1, created_at: '1700000000000', hash: 'hash1', name: '1' },
+		];
+
+		const migrationsToRun = getMigrationsToRun({ localMigrations, dbMigrations });
+
+		expect(migrationsToRun).toStrictEqual([
+			{ folderMillis: 1700000001000, hash: 'hash2', sql: ['stmt2'], bps: true, name: '2' },
+			{ folderMillis: 1700000002000, hash: 'hash3', sql: ['stmt3'], bps: true, name: '3' },
+		]);
+	});
+
+	test('db and local migrations are the same', async () => {
+		const localMigrations: MigrationMeta[] = [
+			{ folderMillis: 1700000000000, hash: 'hash1', sql: ['stmt1'], bps: true, name: '1' },
+			{ folderMillis: 1700000001000, hash: 'hash2', sql: ['stmt2'], bps: true, name: '2' },
+			{ folderMillis: 1700000002000, hash: 'hash3', sql: ['stmt3'], bps: true, name: '3' },
+		];
+		const dbMigrations = [
+			{ id: 1, created_at: '1700000000000', hash: 'hash1', name: '1' },
+			{ id: 2, created_at: '1700000001000', hash: 'hash2', name: '2' },
+			{ id: 3, created_at: '1700000002000', hash: 'hash3', name: '3' },
+		];
+
+		const migrationsToRun = getMigrationsToRun({ localMigrations, dbMigrations });
+
+		expect(migrationsToRun).toStrictEqual([]);
+	});
+
+	test('local has migration before last db migration', async () => {
+		const localMigrations: MigrationMeta[] = [
+			{ folderMillis: 100, hash: 'hash1', sql: ['stmt1'], bps: true, name: '1' },
+			{ folderMillis: 200, hash: 'hash2', sql: ['stmt2'], bps: true, name: '2' },
+			{ folderMillis: 300, hash: 'hash3', sql: ['stmt3'], bps: true, name: '3' },
+		];
+		const dbMigrations = [
+			{ id: 1, created_at: '100', hash: 'hash1', name: '1' },
+			{ id: 2, created_at: '300', hash: 'hash3', name: '3' },
+		];
+
+		const migrationsToRun = getMigrationsToRun({ localMigrations, dbMigrations });
+
+		expect(migrationsToRun).toStrictEqual([
+			{ folderMillis: 200, hash: 'hash2', sql: ['stmt2'], bps: true, name: '2' },
+		]);
+	});
+});
diff --git a/drizzle-orm/tsconfig.dts.json b/drizzle-orm/tsconfig.dts.json
deleted file mode 100644
index 4627d6a2c3..0000000000
--- a/drizzle-orm/tsconfig.dts.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"extends": "./tsconfig.build.json",
-	"compilerOptions": {
-		"composite": false,
-		"rootDir": "src",
-		"outDir": "dist-dts",
-		"declaration": true,
-		"noEmit": false,
-		"emitDeclarationOnly": true,
-		"incremental": false
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-orm/tsconfig.json b/drizzle-orm/tsconfig.json
index 6be05cc9e5..42af07e2ed 100644
--- a/drizzle-orm/tsconfig.json
+++ b/drizzle-orm/tsconfig.json
@@ -7,7 +7,8 @@
 		},
 		"declaration": true,
 		"outDir": "dist",
-		"noEmit": true
+		"noEmit": true,
+		"allowImportingTsExtensions": true
 	},
-	"include": ["src", "scripts"]
+	"include": ["src", "scripts", "types-bench.ts"]
 }
diff --git a/drizzle-orm/tsup.config.ts b/drizzle-orm/tsup.config.ts
deleted file mode 100644
index 4825964858..0000000000
--- a/drizzle-orm/tsup.config.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { globSync } from 'glob';
-import { defineConfig } from 'tsup';
-
-const entries = globSync('src/**/*.ts');
-
-export default defineConfig({
-	entry: entries,
-	outDir: 'dist.new',
-	format: ['cjs', 'esm'],
-	bundle: false,
-	splitting: false,
-	sourcemap: true,
-	outExtension({ format }) {
-		return {
-			js: format === 'cjs' ? '.cjs' : '.js',
-		};
-	},
-	tsconfig: 'tsconfig.build.json',
-});
diff --git a/drizzle-orm/type-tests/cockroach/1-to-1-fk.ts b/drizzle-orm/type-tests/cockroach/1-to-1-fk.ts
new file mode 100644
index 0000000000..8e5248865a
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/1-to-1-fk.ts
@@ -0,0 +1,28 @@
+import { type CockroachColumn, int4 } from '~/cockroach-core/columns/index.ts';
+import { cockroachTable } from '~/cockroach-core/table.ts';
+
+{
+	const test1 = cockroachTable('test1_table', {
+		id: int4('id').primaryKey(),
+		test2Id: int4('test2_id').references(() => test2.id),
+	});
+
+	const test1Id = int4('test1_id').references(() => test1.id);
+
+	const test2 = cockroachTable('test2_table', {
+		id: int4('id').primaryKey(),
+		test1Id,
+	});
+}
+
+{
+	const test1 = cockroachTable('test1_table', {
+		id: int4('id').primaryKey(),
+		test2Id: int4('test2_id').references((): CockroachColumn => test2.id),
+	});
+
+	const test2 = cockroachTable('test2_table', {
+		id: int4('id').primaryKey(),
+		test1Id: int4('test1_id').references(() => test1.id),
+	});
+}
diff --git a/drizzle-orm/type-tests/cockroach/array.ts b/drizzle-orm/type-tests/cockroach/array.ts
new file mode 100644
index 0000000000..bfdf883e42
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/array.ts
@@ -0,0 +1,7 @@
+import { cockroachTable, int4 } from '~/cockroach-core/index.ts';
+
+{
+	const _table = cockroachTable('table', {
+		a: int4('a').array().notNull(),
+	});
+}
diff --git a/drizzle-orm/type-tests/cockroach/count.ts b/drizzle-orm/type-tests/cockroach/count.ts
new file mode 100644
index 0000000000..70c6f696af
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/count.ts
@@ -0,0 +1,61 @@
+import { Expect } from 'type-tests/utils.ts';
+import { cockroachTable, int4, text } from '~/cockroach-core/index.ts';
+import { and, gt, ne } from '~/sql/expressions/index.ts';
+import type { Equal } from '~/utils.ts';
+import { db } from './db.ts';
+
+const names = cockroachTable('names', {
+	id: int4('id').primaryKey(),
+	name: text('name'),
+	authorId: int4('author_id'),
+});
+
+const separate = await db.$count(names);
+
+const separateFilters = await db.$count(names, and(gt(names.id, 1), ne(names.name, 'forbidden')));
+
+const embedded = await db
+	.select({
+		id: names.id,
+		name: names.name,
+		authorId: names.authorId,
+		count1: db.$count(names).as('count1'),
+	})
+	.from(names);
+
+const embeddedFilters = await db
+	.select({
+		id: names.id,
+		name: names.name,
+		authorId: names.authorId,
+		count1: db.$count(names, and(gt(names.id, 1), ne(names.name, 'forbidden'))).as('count1'),
+	})
+	.from(names);
+
+Expect<Equal<number, typeof separate>>;
+
+Expect<Equal<number, typeof separateFilters>>;
+
+Expect<
+	Equal<
+		{
+			id: number;
+			name: string | null;
+			authorId: number | null;
+			count1: number;
+		}[],
+		typeof embedded
+	>
+>;
+
+Expect<
+	Equal<
+		{
+			id: number;
+			name: string | null;
+			authorId: number | null;
+			count1: number;
+		}[],
+		typeof embeddedFilters
+	>
+>;
diff --git a/drizzle-orm/type-tests/cockroach/db-rel.ts b/drizzle-orm/type-tests/cockroach/db-rel.ts
new file mode 100644
index 0000000000..66b90be6d1
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/db-rel.ts
@@ -0,0 +1,122 @@
+import pg from 'pg';
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { drizzle } from '~/cockroach/index.ts';
+import { sql } from '~/sql/sql.ts';
+import * as schema from './tables-rel.ts';
+
+const { Pool } = pg;
+
+const pdb = new Pool({ connectionString: process.env['COCKROACH_CONNECTION_STRING'] });
+const db = drizzle({ client: pdb, schema });
+
+{
+	const result = await db._query.users.findMany({
+		where: (users, { sql }) => sql`char_length(${users.name} > 1)`,
+		limit: sql.placeholder('l'),
+		orderBy: (users, { asc, desc }) => [asc(users.name), desc(users.id)],
+		with: {
+			posts: {
+				where: (posts, { sql }) => sql`char_length(${posts.title} > 1)`,
+				limit: sql.placeholder('l'),
+				columns: {
+					id: false,
+					title: undefined,
+				},
+				with: {
+					author: true,
+					comments: {
+						where: (comments, { sql }) => sql`char_length(${comments.text} > 1)`,
+						limit: sql.placeholder('l'),
+						columns: {
+							text: true,
+						},
+						with: {
+							author: {
+								columns: {
+									id: undefined,
+								},
+								with: {
+									city: {
+										with: {
+											users: true,
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	});
+
+	Expect<
+		Equal<{
+			id: number;
+			name: string;
+			cityId: number;
+			homeCityId: number | null;
+			createdAt: Date;
+			posts: {
+				title: string;
+				authorId: number | null;
+				comments: {
+					text: string;
+					author: {
+						city: {
+							id: number;
+							name: string;
+							users: {
+								id: number;
+								name: string;
+								cityId: number;
+								homeCityId: number | null;
+								createdAt: Date;
+							}[];
+						};
+					} | null;
+				}[];
+				author: {
+					id: number;
+					name: string;
+					cityId: number;
+					homeCityId: number | null;
+					createdAt: Date;
+				} | null;
+			}[];
+		}[], typeof result>
+	>;
+}
+
+{
+	const result = await db._query.users.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					authorId: true,
+				},
+				extras: {
+					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
+				},
+			},
+		},
+	});
+
+	Expect<
+		Equal<
+			{
+				id: number;
+				name: string;
+				posts: {
+					authorId: number | null;
+					lower: string;
+				}[];
+			}[],
+			typeof result
+		>
+	>;
+}
diff --git a/drizzle-orm/type-tests/cockroach/db.ts b/drizzle-orm/type-tests/cockroach/db.ts
new file mode 100644
index 0000000000..e75d78a57f
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/db.ts
@@ -0,0 +1,6 @@
+import pg from 'pg';
+import { drizzle } from '~/cockroach/index.ts';
+
+const { Client } = pg;
+
+export const db = drizzle({ client: new Client() });
diff --git a/drizzle-orm/type-tests/cockroach/delete.ts b/drizzle-orm/type-tests/cockroach/delete.ts
new file mode 100644
index 0000000000..36509ff6b5
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/delete.ts
@@ -0,0 +1,78 @@
+import type { QueryResult } from 'pg';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { CockroachDelete } from '~/cockroach-core/index.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+import { users } from './tables.ts';
+
+const deleteAll = await db.delete(users);
+Expect<Equal<QueryResult<never>, typeof deleteAll>>;
+
+const deleteAllStmt = db.delete(users).prepare('deleteAllStmt');
+const deleteAllPrepared = await deleteAllStmt.execute();
+Expect<Equal<QueryResult<never>, typeof deleteAllPrepared>>;
+
+const deleteWhere = await db.delete(users).where(eq(users.id, 1));
+Expect<Equal<QueryResult<never>, typeof deleteWhere>>;
+
+const deleteWhereStmt = db.delete(users).where(eq(users.id, 1)).prepare('deleteWhereStmt');
+const deleteWherePrepared = await deleteWhereStmt.execute();
+Expect<Equal<QueryResult<never>, typeof deleteWherePrepared>>;
+
+const deleteReturningAll = await db.delete(users).returning();
+Expect<Equal<typeof users.$inferSelect[], typeof deleteReturningAll>>;
+
+const deleteReturningAllStmt = db.delete(users).returning().prepare('deleteReturningAllStmt');
+const deleteReturningAllPrepared = await deleteReturningAllStmt.execute();
+Expect<Equal<typeof users.$inferSelect[], typeof deleteReturningAllPrepared>>;
+
+const deleteReturningPartial = await db.delete(users).returning({
+	myId: users.id,
+	myHomeCity: users.homeCity,
+});
+Expect<Equal<{ myId: number; myHomeCity: number }[], typeof deleteReturningPartial>>;
+
+const deleteReturningPartialStmt = db.delete(users).returning({
+	myId: users.id,
+	myHomeCity: users.homeCity,
+}).prepare('deleteReturningPartialStmt');
+const deleteReturningPartialPrepared = await deleteReturningPartialStmt.execute();
+Expect<Equal<{ myId: number; myHomeCity: number }[], typeof deleteReturningPartialPrepared>>;
+
+{
+	function dynamic<T extends CockroachDelete>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends CockroachDelete>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.delete(users)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.delete(users)
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
diff --git a/drizzle-orm/type-tests/geldb/generated-columns.ts b/drizzle-orm/type-tests/cockroach/generated-columns.ts
similarity index 82%
rename from drizzle-orm/type-tests/geldb/generated-columns.ts
rename to drizzle-orm/type-tests/cockroach/generated-columns.ts
index 265d8fbbbe..11e028bbd3 100644
--- a/drizzle-orm/type-tests/geldb/generated-columns.ts
+++ b/drizzle-orm/type-tests/cockroach/generated-columns.ts
@@ -1,15 +1,15 @@
 import { type Equal, Expect } from 'type-tests/utils';
-import { gelTable, integer, text } from '~/gel-core';
+import { drizzle } from '~/cockroach';
+import { cockroachTable, int4, text, varchar } from '~/cockroach-core';
 import { type InferInsertModel, type InferSelectModel, sql } from '~/index';
-import { drizzle } from '~/node-postgres';
 import { db } from './db';
 
-const users = gelTable(
+const users = cockroachTable(
 	'users',
 	{
-		id: integer('id').primaryKey(),
-		firstName: text('first_name'),
-		lastName: text('last_name'),
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		firstName: varchar('first_name', { length: 255 }),
+		lastName: varchar('last_name', { length: 255 }),
 		email: text('email').notNull(),
 		fullName: text('full_name').generatedAlwaysAs(sql`concat_ws(first_name, ' ', last_name)`).notNull(),
 		upperName: text('upper_name').generatedAlwaysAs(
@@ -39,7 +39,6 @@ const users = gelTable(
 		Equal<
 			{
 				email: string;
-				id: number;
 				firstName?: string | null | undefined;
 				lastName?: string | null | undefined;
 			},
@@ -70,7 +69,6 @@ const users = gelTable(
 		Equal<
 			{
 				email: string;
-				id: number;
 				firstName?: string | null | undefined;
 				lastName?: string | null | undefined;
 			},
@@ -100,7 +98,7 @@ const users = gelTable(
 {
 	const db = drizzle({} as any, { schema: { users } });
 
-	const dbUser = await db.query.users.findFirst();
+	const dbUser = await db._query.users.findFirst();
 
 	Expect<
 		Equal<
@@ -120,7 +118,7 @@ const users = gelTable(
 {
 	const db = drizzle({} as any, { schema: { users } });
 
-	const dbUser = await db.query.users.findMany();
+	const dbUser = await db._query.users.findMany();
 
 	Expect<
 		Equal<
@@ -157,11 +155,11 @@ const users = gelTable(
 	});
 }
 
-const users2 = gelTable(
+const users2 = cockroachTable(
 	'users',
 	{
-		id: integer('id').generatedByDefaultAsIdentity(),
-		id2: integer('id').generatedAlwaysAsIdentity(),
+		id: int4('id').generatedByDefaultAsIdentity(),
+		id2: int4('id').generatedAlwaysAsIdentity(),
 	},
 );
 
@@ -189,11 +187,11 @@ const users2 = gelTable(
 	>();
 }
 
-const usersSeq = gelTable(
+const usersSeq = cockroachTable(
 	'users',
 	{
-		id: integer('id').generatedByDefaultAsIdentity(),
-		id2: integer('id').generatedAlwaysAsIdentity(),
+		id: int4('id').generatedByDefaultAsIdentity(),
+		id2: int4('id').generatedAlwaysAsIdentity(),
 	},
 );
 
diff --git a/drizzle-orm/type-tests/cockroach/insert.ts b/drizzle-orm/type-tests/cockroach/insert.ts
new file mode 100644
index 0000000000..ea7a72bd97
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/insert.ts
@@ -0,0 +1,301 @@
+import type { QueryResult } from 'pg';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { bool, cockroachTable, int4, QueryBuilder, text } from '~/cockroach-core/index.ts';
+import type { CockroachInsert } from '~/cockroach-core/query-builders/insert.ts';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+import { identityColumnsTable, users } from './tables.ts';
+
+const insert = await db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	});
+Expect<Equal<QueryResult<never>, typeof insert>>;
+
+const insertStmt = db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.prepare('insertStmt');
+const insertPrepared = await insertStmt.execute();
+Expect<Equal<QueryResult<never>, typeof insertPrepared>>;
+
+const insertSql = await db.insert(users).values({
+	homeCity: sql`123`,
+	class: 'A',
+	age1: 1,
+	enumCol: sql`foobar`,
+	arrayCol: [''],
+});
+Expect<Equal<QueryResult<never>, typeof insertSql>>;
+
+const insertSqlStmt = db
+	.insert(users)
+	.values({
+		homeCity: sql`123`,
+		class: 'A',
+		age1: 1,
+		enumCol: sql`foobar`,
+		arrayCol: [''],
+	})
+	.prepare('insertSqlStmt');
+const insertSqlPrepared = await insertSqlStmt.execute();
+Expect<Equal<QueryResult<never>, typeof insertSqlPrepared>>;
+
+const insertReturning = await db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning();
+Expect<Equal<typeof users.$inferSelect[], typeof insertReturning>>;
+
+const insertReturningStmt = db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning()
+	.prepare('insertReturningStmt');
+const insertReturningPrepared = await insertReturningStmt.execute();
+Expect<Equal<typeof users.$inferSelect[], typeof insertReturningPrepared>>;
+
+const insertReturningPartial = await db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning({
+		id: users.id,
+		homeCity: users.homeCity,
+		mySubclass: users.subClass,
+	});
+Expect<
+	Equal<{
+		id: number;
+		homeCity: number;
+		mySubclass: 'B' | 'D' | null;
+	}[], typeof insertReturningPartial>
+>;
+
+const insertReturningPartialStmt = db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: 1,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning({
+		id: users.id,
+		homeCity: users.homeCity,
+		mySubclass: users.subClass,
+	})
+	.prepare('insertReturningPartialStmt');
+const insertReturningPartialPrepared = await insertReturningPartialStmt.execute();
+Expect<
+	Equal<{
+		id: number;
+		homeCity: number;
+		mySubclass: 'B' | 'D' | null;
+	}[], typeof insertReturningPartialPrepared>
+>;
+
+const insertReturningSql = await db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: sql`2 + 2`,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning({
+		id: users.id,
+		homeCity: users.homeCity,
+		subclassLower: sql`lower(${users.subClass})`,
+		classLower: sql<string>`lower(${users.class})`,
+	});
+Expect<
+	Equal<{
+		id: number;
+		homeCity: number;
+		subclassLower: unknown;
+		classLower: string;
+	}[], typeof insertReturningSql>
+>;
+
+const insertReturningSqlStmt = db
+	.insert(users)
+	.values({
+		homeCity: 1,
+		class: 'A',
+		age1: sql`2 + 2`,
+		enumCol: 'a',
+		arrayCol: [''],
+	})
+	.returning({
+		id: users.id,
+		homeCity: users.homeCity,
+		subclassLower: sql`lower(${users.subClass})`,
+		classLower: sql<string>`lower(${users.class})`,
+	})
+	.prepare('insertReturningSqlStmt');
+const insertReturningSqlPrepared = await insertReturningSqlStmt.execute();
+Expect<
+	Equal<{
+		id: number;
+		homeCity: number;
+		subclassLower: unknown;
+		classLower: string;
+	}[], typeof insertReturningSqlPrepared>
+>;
+
+{
+	function dynamic<T extends CockroachInsert>(qb: T) {
+		return qb.returning().onConflictDoNothing().onConflictDoUpdate({ set: {}, target: users.id, where: sql`` });
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] }).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends CockroachInsert>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] }).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.insert(users)
+		.values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] })
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
+
+{
+	const users1 = cockroachTable('users1', {
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		name: text('name').notNull(),
+		admin: bool('admin').notNull().default(false),
+	});
+	const users2 = cockroachTable('users2', {
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		firstName: text('first_name').notNull(),
+		lastName: text('last_name').notNull(),
+		admin: bool('admin').notNull().default(false),
+		phoneNumber: text('phone_number'),
+	});
+
+	const qb = new QueryBuilder();
+
+	db.insert(users1).select(sql`select * from users1`);
+	db.insert(users1).select(() => sql`select * from users1`);
+
+	db
+		.insert(users1)
+		.select(
+			qb.select({
+				name: users2.firstName,
+				admin: users2.admin,
+			}).from(users2),
+		);
+
+	db
+		.insert(users1)
+		.select(
+			qb.select({
+				name: users2.firstName,
+				admin: users2.admin,
+			}).from(users2).where(sql``),
+		);
+
+	db
+		.insert(users2)
+		.select(
+			qb.select({
+				firstName: users2.firstName,
+				lastName: users2.lastName,
+				admin: users2.admin,
+			}).from(users2),
+		);
+
+	db
+		.insert(users1)
+		.select(
+			qb.select({
+				name: sql`${users2.firstName} || ' ' || ${users2.lastName}`.as('name'),
+				admin: users2.admin,
+			}).from(users2),
+		);
+
+	db
+		.insert(users1)
+		.select(
+			// @ts-expect-error name is undefined
+			qb.select({ admin: users1.admin }).from(users1),
+		);
+
+	db.insert(users1).select(db.select({ name: users1.name, admin: users1.admin }).from(users1));
+	db.insert(users1).select(() => db.select({ name: users1.name, admin: users1.admin }).from(users1));
+	db.insert(users1).select((qb) => qb.select({ name: users1.name, admin: users1.admin }).from(users1));
+	// @ts-expect-error selecting generated always key
+	db.insert(users1).select(db.select().from(users1));
+	// @ts-expect-error selecting generated always key
+	db.insert(users1).select(() => db.select().from(users1));
+	// @ts-expect-error selecting generated always key
+	db.insert(users1).select((qb) => qb.select().from(users1));
+	// @ts-expect-error tables have different keys
+	db.insert(users1).select(db.select().from(users2));
+	// @ts-expect-error tables have different keys
+	db.insert(users1).select(() => db.select().from(users2));
+}
+
+{
+	db.insert(identityColumnsTable).values([
+		{ byDefaultAsIdentity: 4, name: 'fdf' },
+	]);
+
+	// @ts-expect-error
+	db.insert(identityColumnsTable).values([
+		{ alwaysAsIdentity: 2 },
+	]);
+
+	// @ts-expect-error
+	db.insert(identityColumnsTable).values([
+		{ generatedCol: 2 },
+	]);
+}
diff --git a/drizzle-orm/type-tests/geldb/other.ts b/drizzle-orm/type-tests/cockroach/other.ts
similarity index 79%
rename from drizzle-orm/type-tests/geldb/other.ts
rename to drizzle-orm/type-tests/cockroach/other.ts
index 23076c5825..82d6b5d8da 100644
--- a/drizzle-orm/type-tests/geldb/other.ts
+++ b/drizzle-orm/type-tests/cockroach/other.ts
@@ -1,7 +1,9 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
+import type { QueryResult } from 'pg';
 import { eq, inArray } from '~/sql/expressions/index.ts';
 import { sql } from '~/sql/sql.ts';
+
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
@@ -11,4 +13,4 @@ const rawQuery = await db.execute(
 	}`,
 );
 
-Expect<Equal<Record<string, unknown>[], typeof rawQuery>>;
+Expect<Equal<QueryResult<Record<string, unknown>>, typeof rawQuery>>;
diff --git a/drizzle-orm/type-tests/cockroach/select.ts b/drizzle-orm/type-tests/cockroach/select.ts
new file mode 100644
index 0000000000..bffb252a4a
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/select.ts
@@ -0,0 +1,1509 @@
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+
+import { alias } from '~/cockroach-core/alias.ts';
+import {
+	bool,
+	cockroachMaterializedView,
+	type CockroachSelect,
+	type CockroachSelectQueryBuilder,
+	cockroachTable,
+	cockroachView,
+	int4,
+	QueryBuilder,
+	text,
+} from '~/cockroach-core/index.ts';
+import {
+	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
+	between,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNotNull,
+	isNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notIlike,
+	notInArray,
+	notLike,
+	or,
+} from '~/sql/expressions/index.ts';
+import { type InferSelectViewModel, type SQL, sql } from '~/sql/sql.ts';
+
+import { db } from './db.ts';
+import {
+	cities,
+	classes,
+	newYorkers,
+	newYorkers2,
+	newYorkersWithSubquery,
+	newYorkersWithSubquery2,
+	users,
+} from './tables.ts';
+
+const city = alias(cities, 'city');
+const city1 = alias(cities, 'city1');
+
+const leftJoinFull = await db.select().from(users).leftJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<
+		{
+			users_table: typeof users.$inferSelect;
+			city: typeof cities.$inferSelect | null;
+		}[],
+		typeof leftJoinFull
+	>
+>;
+
+const rightJoinFull = await db.select().from(users).rightJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<
+		{
+			users_table: typeof users.$inferSelect | null;
+			city: typeof city.$inferSelect;
+		}[],
+		typeof rightJoinFull
+	>
+>;
+
+const innerJoinFull = await db.select().from(users).innerJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<
+		{
+			users_table: typeof users.$inferSelect;
+			city: typeof city.$inferSelect;
+		}[],
+		typeof innerJoinFull
+	>
+>;
+
+const fullJoinFull = await db.select().from(users).fullJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<
+		{
+			users_table: typeof users.$inferSelect | null;
+			city: typeof city.$inferSelect | null;
+		}[],
+		typeof fullJoinFull
+	>
+>;
+
+const crossJoinFull = await db.select().from(users).crossJoin(city);
+
+Expect<
+	Equal<
+		{
+			users_table: typeof users.$inferSelect;
+			city: typeof city.$inferSelect;
+		}[],
+		typeof crossJoinFull
+	>
+>;
+
+const leftJoinFlat = await db
+	.select({
+		userId: users.id,
+		userText: users.text,
+		cityId: city.id,
+		cityName: city.name,
+	})
+	.from(users)
+	.leftJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<{
+		userId: number;
+		userText: string | null;
+		cityId: number | null;
+		cityName: string | null;
+	}[], typeof leftJoinFlat>
+>;
+
+const rightJoinFlat = await db
+	.select({
+		userId: users.id,
+		userText: users.text,
+		cityId: city.id,
+		cityName: city.name,
+	})
+	.from(users)
+	.rightJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<{
+		userId: number | null;
+		userText: string | null;
+		cityId: number;
+		cityName: string;
+	}[], typeof rightJoinFlat>
+>;
+
+const innerJoinFlat = await db
+	.select({
+		userId: users.id,
+		userText: users.text,
+		cityId: city.id,
+		cityName: city.name,
+	})
+	.from(users)
+	.innerJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<{
+		userId: number;
+		userText: string | null;
+		cityId: number;
+		cityName: string;
+	}[], typeof innerJoinFlat>
+>;
+
+const fullJoinFlat = await db
+	.select({
+		userId: users.id,
+		userText: users.text,
+		cityId: city.id,
+		cityName: city.name,
+	})
+	.from(users)
+	.fullJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<{
+		userId: number | null;
+		userText: string | null;
+		cityId: number | null;
+		cityName: string | null;
+	}[], typeof fullJoinFlat>
+>;
+
+const crossJoinFlat = await db
+	.select({
+		userId: users.id,
+		userText: users.text,
+		cityId: city.id,
+		cityName: city.name,
+	})
+	.from(users)
+	.crossJoin(city);
+
+Expect<
+	Equal<{
+		userId: number;
+		userText: string | null;
+		cityId: number;
+		cityName: string;
+	}[], typeof crossJoinFlat>
+>;
+
+const leftJoinMixed = await db
+	.select({
+		id: users.id,
+		text: users.text,
+		textUpper: sql<string | null>`upper(${users.text})`,
+		idComplex: sql<string | null>`${users.id}::text || ${city.id}::text`,
+		city: {
+			id: city.id,
+			name: city.name,
+		},
+	})
+	.from(users)
+	.leftJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<
+		{
+			id: number;
+			text: string | null;
+			textUpper: string | null;
+			idComplex: string | null;
+			city: {
+				id: number;
+				name: string;
+			} | null;
+		}[],
+		typeof leftJoinMixed
+	>
+>;
+
+const leftJoinMixed2 = await db
+	.select({
+		id: users.id,
+		text: users.text,
+		foo: {
+			bar: users.uuid,
+			baz: cities.id,
+		},
+	})
+	.from(users)
+	.leftJoin(cities, eq(users.id, cities.id));
+
+Expect<
+	Equal<
+		{
+			id: number;
+			text: string | null;
+			foo: {
+				bar: string;
+				baz: number | null;
+			};
+		}[],
+		typeof leftJoinMixed2
+	>
+>;
+
+const join1 = await db
+	.select({
+		user: {
+			id: users.id,
+			text: users.text,
+		},
+		city: {
+			id: city.id,
+			name: city.name,
+			nameUpper: sql<string>`upper(${city.name})`,
+		},
+	})
+	.from(users)
+	.leftJoin(city, eq(users.id, city.id));
+
+Expect<
+	Equal<{
+		user: {
+			id: number;
+			text: string | null;
+		};
+		city: {
+			id: number;
+			name: string;
+			nameUpper: string;
+		} | null;
+	}[], typeof join1>
+>;
+
+const join = await db
+	.select({
+		users,
+		cities,
+		city,
+		city1: {
+			id: city1.id,
+		},
+	})
+	.from(users)
+	.leftJoin(cities, eq(users.id, cities.id))
+	.rightJoin(city, eq(city.id, users.id))
+	.rightJoin(city1, eq(city1.id, users.id));
+
+Expect<
+	Equal<
+		{
+			users: {
+				id: number;
+				uuid: string;
+				homeCity: number;
+				currentCity: number | null;
+				int4Nullable: number | null;
+				int4NotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+				arrayCol: string[];
+			} | null;
+			cities: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			city: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			city1: {
+				id: number;
+			};
+		}[],
+		typeof join
+	>
+>;
+
+const join2 = await db
+	.select({
+		user: {
+			id: users.id,
+		},
+		city: {
+			id: cities.id,
+		},
+	})
+	.from(users)
+	.fullJoin(cities, eq(users.id, cities.id));
+
+Expect<
+	Equal<
+		{
+			user: {
+				id: number;
+			} | null;
+			city: {
+				id: number;
+			} | null;
+		}[],
+		typeof join2
+	>
+>;
+
+const join3 = await db
+	.select({
+		user: {
+			id: users.id,
+		},
+		city: {
+			id: cities.id,
+		},
+		class: {
+			id: classes.id,
+		},
+	})
+	.from(users)
+	.fullJoin(cities, eq(users.id, cities.id))
+	.rightJoin(classes, eq(users.id, classes.id));
+
+Expect<
+	Equal<
+		{
+			user: {
+				id: number;
+			} | null;
+			city: {
+				id: number;
+			} | null;
+			class: {
+				id: number;
+			};
+		}[],
+		typeof join3
+	>
+>;
+
+db.select()
+	.from(users)
+	.where(exists(db.select().from(cities).where(eq(users.homeCity, cities.id))));
+
+function mapFunkyFuncResult(valueFromDriver: unknown) {
+	return {
+		foo: (valueFromDriver as Record<string, any>)['foo'],
+	};
+}
+
+const age = 1;
+
+const allOperators = await db
+	.select({
+		col2: sql`5 - ${users.id} + 1`, // unknown
+		col3: sql<number>`${users.id} + 1`, // number
+		col33: sql`${users.id} + 1`.mapWith(users.id), // number
+		col34: sql`${users.id} + 1`.mapWith(mapFunkyFuncResult), // number
+		col4: sql<string | number>`one_or_another(${users.id}, ${users.class})`, // string | number
+		col5: sql`true`, // unknown
+		col6: sql<boolean>`true`, // boolean
+		col7: sql<number>`random()`, // number
+		col8: sql`some_funky_func(${users.id})`.mapWith(mapFunkyFuncResult), // { foo: string }
+		col9: sql`greatest(${users.createdAt}, ${sql.param(new Date(), users.createdAt)})`, // unknown
+		col10: sql<Date | boolean>`date_or_false(${users.createdAt}, ${
+			sql.param(
+				new Date(),
+				users.createdAt,
+			)
+		})`, // Date | boolean
+		col11: sql`${users.age1} + ${age}`, // unknown
+		col12: sql`${users.age1} + ${sql.param(age, users.age1)}`, // unknown
+		col13: sql`lower(${users.class})`, // unknown
+		col14: sql<number>`length(${users.class})`, // number
+		count: sql<number>`count(*)::int`, // number
+	})
+	.from(users)
+	.where(
+		and(
+			eq(users.id, 1),
+			ne(users.id, 1),
+			or(eq(users.id, 1), ne(users.id, 1)),
+			not(eq(users.id, 1)),
+			gt(users.id, 1),
+			gte(users.id, 1),
+			lt(users.id, 1),
+			lte(users.id, 1),
+			inArray(users.id, [1, 2, 3]),
+			inArray(users.id, db.select({ id: users.id }).from(users)),
+			inArray(users.id, sql`select id from ${users}`),
+			notInArray(users.id, [1, 2, 3]),
+			notInArray(users.id, db.select({ id: users.id }).from(users)),
+			notInArray(users.id, sql`select id from ${users}`),
+			isNull(users.subClass),
+			isNotNull(users.id),
+			exists(db.select({ id: users.id }).from(users)),
+			exists(sql`select id from ${users}`),
+			notExists(db.select({ id: users.id }).from(users)),
+			notExists(sql`select id from ${users}`),
+			between(users.id, 1, 2),
+			notBetween(users.id, 1, 2),
+			like(users.id, '%1%'),
+			notLike(users.id, '%1%'),
+			ilike(users.id, '%1%'),
+			notIlike(users.id, '%1%'),
+			arrayContains(users.arrayCol, ['abc']),
+			arrayContains(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
+			arrayContains(users.arrayCol, sql`select array_col from ${users}`),
+			arrayContained(users.arrayCol, ['abc']),
+			arrayContained(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
+			arrayContained(users.arrayCol, sql`select array_col from ${users}`),
+			arrayOverlaps(users.arrayCol, ['abc']),
+			arrayOverlaps(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
+			arrayOverlaps(users.arrayCol, sql`select array_col from ${users}`),
+		),
+	);
+
+Expect<
+	Equal<{
+		col2: unknown;
+		col3: number;
+		col33: number;
+		col34: { foo: any };
+		col4: string | number;
+		col5: unknown;
+		col6: boolean;
+		col7: number;
+		col8: {
+			foo: any;
+		};
+		col9: unknown;
+		col10: boolean | Date;
+		col11: unknown;
+		col12: unknown;
+		col13: unknown;
+		col14: number;
+		count: number;
+	}[], typeof allOperators>
+>;
+
+const textSelect = await db
+	.select({
+		t: users.text,
+	})
+	.from(users);
+
+Expect<Equal<{ t: string | null }[], typeof textSelect>>;
+
+const homeCity = alias(cities, 'homeCity');
+const c = alias(classes, 'c');
+const otherClass = alias(classes, 'otherClass');
+const anotherClass = alias(classes, 'anotherClass');
+const friend = alias(users, 'friend');
+const currentCity = alias(cities, 'currentCity');
+const subscriber = alias(users, 'subscriber');
+const closestCity = alias(cities, 'closestCity');
+const closestCity2 = alias(cities, 'closestCity2');
+const closestCity3 = alias(cities, 'closestCity3');
+const closestCity4 = alias(cities, 'closestCity4');
+const closestCity5 = alias(cities, 'closestCity5');
+const closestCity6 = alias(cities, 'closestCity6');
+const closestCity7 = alias(cities, 'closestCity7');
+
+const megaJoin = await db
+	.select({
+		user: {
+			id: users.id,
+			maxAge: sql`max(${users.age1})`,
+		},
+		city: {
+			id: cities.id,
+		},
+		homeCity,
+		c,
+		otherClass,
+		anotherClass,
+		friend,
+		currentCity,
+		subscriber,
+		closestCity,
+	})
+	.from(users)
+	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
+	.innerJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
+	.innerJoin(c, eq(c.id, users.class))
+	.innerJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
+	.innerJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
+	.innerJoin(friend, sql`${users.id} = ${friend.id}`)
+	.innerJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
+	.innerJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
+	.innerJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
+	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
+	.limit(1)
+	.offset(1);
+
+Expect<
+	Equal<
+		{
+			user: {
+				id: number;
+				maxAge: unknown;
+			};
+			city: {
+				id: number;
+			};
+			homeCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+			c: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			otherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			anotherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			friend: {
+				id: number;
+				uuid: string;
+				homeCity: number;
+				currentCity: number | null;
+				int4Nullable: number | null;
+				int4NotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+				arrayCol: string[];
+			};
+			currentCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+			subscriber: {
+				id: number;
+				uuid: string;
+				homeCity: number;
+				currentCity: number | null;
+				int4Nullable: number | null;
+				int4NotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+				arrayCol: string[];
+			};
+			closestCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+		}[],
+		typeof megaJoin
+	>
+>;
+
+const megaLeftJoin = await db
+	.select({
+		user: {
+			id: users.id,
+			maxAge: sql`max(${users.age1})`,
+		},
+		city: {
+			id: cities.id,
+		},
+		homeCity,
+		c,
+		otherClass,
+		anotherClass,
+		friend,
+		currentCity,
+		subscriber,
+		closestCity,
+		closestCity2,
+		closestCity3,
+		closestCity4,
+		closestCity5,
+		closestCity6,
+		closestCity7,
+	})
+	.from(users)
+	.leftJoin(cities, sql`${users.id} = ${cities.id}`)
+	.leftJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
+	.leftJoin(c, eq(c.id, users.class))
+	.leftJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
+	.leftJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
+	.leftJoin(friend, sql`${users.id} = ${friend.id}`)
+	.leftJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
+	.leftJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
+	.leftJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity2, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity3, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity4, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity5, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity6, sql`${users.currentCity} = ${closestCity.id}`)
+	.leftJoin(closestCity7, sql`${users.currentCity} = ${closestCity.id}`)
+	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
+	.limit(1)
+	.offset(1);
+
+Expect<
+	Equal<
+		{
+			user: {
+				id: number;
+				maxAge: unknown;
+			};
+			city: {
+				id: number;
+			} | null;
+			homeCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			c: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			} | null;
+			otherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			} | null;
+			anotherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			} | null;
+			friend: {
+				id: number;
+				uuid: string;
+				homeCity: number;
+				currentCity: number | null;
+				int4Nullable: number | null;
+				int4NotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+				arrayCol: string[];
+			} | null;
+			currentCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			subscriber: {
+				id: number;
+				uuid: string;
+				homeCity: number;
+				currentCity: number | null;
+				int4Nullable: number | null;
+				int4NotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+				arrayCol: string[];
+			} | null;
+			closestCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity2: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity3: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity4: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity5: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity6: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			closestCity7: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+		}[],
+		typeof megaLeftJoin
+	>
+>;
+
+await db
+	.select({
+		user: {
+			id: users.id,
+			maxAge: sql`max(${users.age1})`,
+		},
+		city: {
+			id: cities.id,
+		},
+		homeCity,
+		c,
+		otherClass,
+		anotherClass,
+		friend,
+		currentCity,
+		subscriber,
+		closestCity,
+		closestCity2,
+		closestCity3,
+		closestCity4,
+		closestCity5,
+		closestCity6,
+		closestCity7,
+	})
+	.from(users)
+	.fullJoin(cities, sql`${users.id} = ${cities.id}`)
+	.fullJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
+	.fullJoin(c, eq(c.id, users.class))
+	.fullJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
+	.fullJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
+	.fullJoin(friend, sql`${users.id} = ${friend.id}`)
+	.fullJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
+	.fullJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
+	.fullJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity2, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity3, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity4, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity5, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity6, sql`${users.currentCity} = ${closestCity.id}`)
+	.fullJoin(closestCity7, sql`${users.currentCity} = ${closestCity.id}`)
+	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
+	.limit(1)
+	.offset(1);
+
+const friends = alias(users, 'friends');
+
+const join4 = await db
+	.select({
+		user: {
+			id: users.id,
+		},
+		city: {
+			id: cities.id,
+		},
+		class: classes,
+		friend: friends,
+	})
+	.from(users)
+	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
+	.innerJoin(classes, sql`${cities.id} = ${classes.id}`)
+	.innerJoin(friends, sql`${friends.id} = ${users.id}`)
+	.where(sql`${users.age1} > 0`);
+
+Expect<
+	Equal<{
+		user: {
+			id: number;
+		};
+		city: {
+			id: number;
+		};
+		class: {
+			id: number;
+			class: 'A' | 'C' | null;
+			subClass: 'B' | 'D';
+		};
+		friend: {
+			id: number;
+			uuid: string;
+			homeCity: number;
+			currentCity: number | null;
+			int4Nullable: number | null;
+			int4NotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+			arrayCol: string[];
+		};
+	}[], typeof join4>
+>;
+
+{
+	const authenticated = false as boolean;
+
+	const result = await db
+		.select({
+			id: users.id,
+			...(authenticated ? { city: users.homeCity } : {}),
+		})
+		.from(users);
+
+	Expect<
+		Equal<
+			{
+				id: number;
+				city?: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+await db
+	.select()
+	.from(users)
+	.for('update');
+
+await db
+	.select()
+	.from(users)
+	.for('no key update', { of: users });
+
+await db
+	.select()
+	.from(users)
+	.for('no key update', { of: users, skipLocked: true });
+
+await db
+	.select()
+	.from(users)
+	.for('share', { of: users, noWait: true });
+
+await db
+	.select()
+	.from(users)
+	// @ts-expect-error - can't use both skipLocked and noWait
+	.for('share', { of: users, noWait: true, skipLocked: true });
+
+await db
+	.select({
+		id: cities.id,
+		name: sql<string>`upper(${cities.name})`.as('name'),
+		usersCount: sql<number>`count(${users.id})`.as('users'),
+	})
+	.from(cities)
+	.leftJoin(users, eq(users.homeCity, cities.id))
+	.where(({ name }) => sql`length(${name}) >= 3`)
+	.groupBy(cities.id)
+	.having(({ usersCount }) => sql`${usersCount} > 0`);
+
+{
+	const result = await db.select().from(newYorkers);
+	Expect<
+		Equal<
+			{
+				userId: number;
+				cityId: number | null;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select({ userId: newYorkers.userId }).from(newYorkers);
+	Expect<
+		Equal<
+			{
+				userId: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select().from(newYorkers2);
+	Expect<
+		Equal<
+			{
+				userId: number;
+				cityId: number | null;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select({ userId: newYorkers.userId }).from(newYorkers2);
+	Expect<
+		Equal<
+			{
+				userId: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select().from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				id: number;
+				class: 'A' | 'C';
+				cityCount: number;
+				lastCityId: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery>[]>>;
+}
+
+{
+	const result = await db.select({ cityCount: newYorkersWithSubquery.cityCount }).from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select().from(newYorkersWithSubquery2);
+	Expect<
+		Equal<
+			{
+				id: number;
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery2.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery2>[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.limit(10)
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+}
+
+{
+	function withFriends<T extends CockroachSelect>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function withFriends<T extends CockroachSelectQueryBuilder>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function dynamic<T extends CockroachSelect>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	// TODO: add to docs
+	function dynamic<T extends CockroachSelectQueryBuilder>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const query = new QueryBuilder().select().from(users).$dynamic();
+	dynamic(query);
+}
+
+{
+	// TODO: add to docs
+	function paginated<T extends CockroachSelect>(qb: T, page: number) {
+		return qb.limit(10).offset((page - 1) * 10);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await paginated(qb, 1);
+
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.select()
+		.from(users)
+		.having(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.having(sql``);
+
+	db
+		.select()
+		.from(users)
+		.groupBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.groupBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.orderBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.orderBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.limit(10)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.limit(10);
+
+	db
+		.select()
+		.from(users)
+		.offset(10)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.offset(10);
+
+	db
+		.select()
+		.from(users)
+		.for('update')
+		.limit(10)
+		// @ts-expect-error method was already called
+		.for('update');
+}
+
+{
+	const users = cockroachTable('users', {
+		developer: bool('developer'),
+		application: text('application', { enum: ['pending', 'approved'] }),
+	});
+
+	const startIt = (whereCallback: (condition: SQL) => SQL | undefined = (c) => c) => {
+		return db.select().from(users).where(whereCallback(eq(users.developer, true)));
+	};
+
+	startIt((c) => and(c, eq(users.application, 'approved')));
+}
+
+{
+	const school = cockroachTable('school', {
+		faculty: int4('faculty'),
+		studentid: int4('studentid'),
+	});
+
+	const student = cockroachTable('student', {
+		id: int4('id'),
+		email: text('email'),
+	});
+
+	await db
+		.select()
+		.from(school)
+		.where(
+			and(
+				eq(school.faculty, 2),
+				eq(
+					school.studentid,
+					db.select({ id: student.id }).from(student).where(eq(student.email, 'foo@demo.com')),
+				),
+			),
+		);
+}
+
+{
+	const table1 = cockroachTable('table1', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const table2 = cockroachTable('table2', {
+		id: int4().primaryKey(),
+		age: int4().notNull(),
+	});
+	const table3 = cockroachTable('table3', {
+		id: int4().primaryKey(),
+		phone: text().notNull(),
+	});
+	const view = cockroachView('view').as((qb) =>
+		qb.select({
+			table: table1,
+			column: table2.age,
+			nested: {
+				column: table3.phone,
+			},
+		}).from(table1).innerJoin(table2, sql``).leftJoin(table3, sql``)
+	);
+	const result = await db.select().from(view);
+
+	Expect<
+		Equal<typeof result, {
+			table: typeof table1.$inferSelect;
+			column: number;
+			nested: {
+				column: string | null;
+			};
+		}[]>
+	>;
+	Expect<Equal<typeof result, typeof view.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof view>[]>>;
+}
+
+{
+	const table1 = cockroachTable('table1', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const table2 = cockroachTable('table2', {
+		id: int4().primaryKey(),
+		age: int4().notNull(),
+	});
+	const table3 = cockroachTable('table3', {
+		id: int4().primaryKey(),
+		phone: text().notNull(),
+	});
+	const view = cockroachMaterializedView('view').as((qb) =>
+		qb.select({
+			table: table1,
+			column: table2.age,
+			nested: {
+				column: table3.phone,
+			},
+		}).from(table1).innerJoin(table2, sql``).leftJoin(table3, sql``)
+	);
+	const result = await db.select().from(view);
+
+	Expect<
+		Equal<typeof result, {
+			table: typeof table1.$inferSelect;
+			column: number;
+			nested: {
+				column: string | null;
+			};
+		}[]>
+	>;
+	Expect<Equal<typeof result, typeof view.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof view>[]>>;
+}
+
+{
+	const table1 = cockroachTable('table1', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const table2 = cockroachTable('table2', {
+		id: int4().primaryKey(),
+		age: int4().notNull(),
+		table1Id: int4().references(() => table1.id).notNull(),
+	});
+
+	const view = cockroachView('view').as((qb) => qb.select().from(table2));
+
+	const leftLateralRawRes = await db.select({
+		table1,
+		sqId: sql<number | null>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
+	}).from(table1).leftJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`, sql`true`);
+
+	Expect<
+		Equal<typeof leftLateralRawRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sqId: number | null;
+		}[]>
+	>;
+
+	const leftLateralSubRes = await db.select().from(table1).leftJoinLateral(
+		db.select().from(table2).as('sub'),
+		sql`true`,
+	);
+
+	Expect<
+		Equal<typeof leftLateralSubRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sub: {
+				id: number;
+				age: number;
+				table1Id: number;
+			} | null;
+		}[]>
+	>;
+
+	const sqLeftLateral = db.select().from(table2).as('sub');
+
+	const leftLateralSubSelectionRes = await db.select(
+		{
+			id: table1.id,
+			sId: sqLeftLateral.id,
+		},
+	).from(table1).leftJoinLateral(
+		sqLeftLateral,
+		sql`true`,
+	);
+
+	Expect<
+		Equal<typeof leftLateralSubSelectionRes, {
+			id: number;
+			sId: number | null;
+		}[]>
+	>;
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.leftJoinLateral(table2, sql`true`);
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.leftJoinLateral(view, sql`true`);
+
+	const innerLateralRawRes = await db.select({
+		table1,
+		sqId: sql<number>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
+	}).from(table1).innerJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`, sql`true`);
+
+	Expect<
+		Equal<typeof innerLateralRawRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sqId: number;
+		}[]>
+	>;
+
+	const innerLateralSubRes = await db.select().from(table1).innerJoinLateral(
+		db.select().from(table2).as('sub'),
+		sql`true`,
+	);
+
+	Expect<
+		Equal<typeof innerLateralSubRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sub: {
+				id: number;
+				age: number;
+				table1Id: number;
+			};
+		}[]>
+	>;
+
+	const sqInnerLateral = db.select().from(table2).as('sub');
+
+	const innerLateralSubSelectionRes = await db.select(
+		{
+			id: table1.id,
+			sId: sqLeftLateral.id,
+		},
+	).from(table1).innerJoinLateral(
+		sqInnerLateral,
+		sql`true`,
+	);
+
+	Expect<
+		Equal<typeof innerLateralSubSelectionRes, {
+			id: number;
+			sId: number;
+		}[]>
+	>;
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.innerJoinLateral(table2, sql`true`);
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.innerJoinLateral(view, sql`true`);
+
+	const crossLateralRawRes = await db.select({
+		table1,
+		sqId: sql<number>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
+	}).from(table1).crossJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`);
+
+	Expect<
+		Equal<typeof crossLateralRawRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sqId: number;
+		}[]>
+	>;
+
+	const crossLateralSubRes = await db.select().from(table1).crossJoinLateral(
+		db.select().from(table2).as('sub'),
+	);
+
+	Expect<
+		Equal<typeof crossLateralSubRes, {
+			table1: {
+				id: number;
+				name: string;
+			};
+			sub: {
+				id: number;
+				age: number;
+				table1Id: number;
+			};
+		}[]>
+	>;
+
+	const sqCrossLateral = db.select().from(table2).as('sub');
+
+	const crossLateralSubSelectionRes = await db.select(
+		{
+			id: table1.id,
+			sId: sqCrossLateral.id,
+		},
+	).from(table1).crossJoinLateral(
+		sqInnerLateral,
+	);
+
+	Expect<
+		Equal<typeof crossLateralSubSelectionRes, {
+			id: number;
+			sId: number;
+		}[]>
+	>;
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.crossJoinLateral(table2);
+
+	await db.select().from(table1)
+		// @ts-expect-error
+		.crossJoinLateral(view);
+}
diff --git a/drizzle-orm/type-tests/cockroach/set-operators.ts b/drizzle-orm/type-tests/cockroach/set-operators.ts
new file mode 100644
index 0000000000..c14de2ab2f
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/set-operators.ts
@@ -0,0 +1,288 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import {
+	type CockroachSetOperator,
+	except,
+	exceptAll,
+	intersect,
+	intersectAll,
+	union,
+	unionAll,
+} from '~/cockroach-core/index.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { desc, sql } from '~/sql/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, users } from './tables.ts';
+
+const unionTest = await db
+	.select({ id: users.id })
+	.from(users)
+	.union(
+		db
+			.select({ id: users.id })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number }[], typeof unionTest>>;
+
+const unionAllTest = await db
+	.select({ id: users.id, age: users.age1 })
+	.from(users)
+	.unionAll(
+		db.select({ id: users.id, age: users.age1 })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; age: number }[], typeof unionAllTest>>;
+
+const intersectTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select({ id: users.id, homeCity: users.homeCity })
+				.from(users),
+			db
+				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+				.from(users),
+		)
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
+
+const intersectAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.intersect(
+		db
+			.select({ id: users.id, homeCity: users.class })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof intersectAllTest>>;
+
+const exceptTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
+
+const exceptAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
+
+const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
+
+const unionAll2Test = await unionAll(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select().from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
+
+const intersect2Test = await intersect(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
+
+const intersectAll2Test = await intersectAll(
+	union(
+		db.select({
+			id: cities.id,
+		}).from(cities),
+		db.select({
+			id: cities.id,
+		})
+			.from(cities).where(sql``),
+	),
+	db.select({
+		id: cities.id,
+	})
+		.from(cities),
+).orderBy(desc(cities.id)).limit(23);
+
+Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
+
+const except2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number }[], typeof except2Test>>;
+
+const exceptAll2Test = await exceptAll(
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	})
+		.from(newYorkers).where(sql``),
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	}).from(newYorkers).leftJoin(users, sql``),
+);
+
+Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
+
+const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).limit(1).offset(2);
+
+Expect<
+	Equal<{
+		id: number;
+		uuid: string;
+		homeCity: number;
+		currentCity: number | null;
+		int4Nullable: number | null;
+		int4NotNull: number;
+		class: 'A' | 'C';
+		subClass: 'B' | 'D' | null;
+		text: string | null;
+		age1: number;
+		createdAt: Date;
+		enumCol: 'a' | 'b' | 'c';
+		arrayCol: string[];
+	}[], typeof unionfull>
+>;
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+union(db.select().from(users), db.select().from(users))
+	.offset(1)
+	// @ts-expect-error - method was already called
+	.offset(2);
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+{
+	function dynamic<T extends CockroachSetOperator>(qb: T) {
+		return qb.orderBy(sql``).limit(1).offset(2);
+	}
+
+	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select().from(cities),
+);
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).limit(3).$dynamic(),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: newYorkers.userId }).from(newYorkers),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities).where(sql``),
+	db.select({ id: sql<number>`${cities.id}` }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
+);
diff --git a/drizzle-orm/type-tests/cockroach/subquery.ts b/drizzle-orm/type-tests/cockroach/subquery.ts
new file mode 100644
index 0000000000..31aff14a8d
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/subquery.ts
@@ -0,0 +1,97 @@
+import { Expect } from 'type-tests/utils.ts';
+import { alias, cockroachTable, int4, text } from '~/cockroach-core/index.ts';
+import { and, eq } from '~/sql/expressions/index.ts';
+import { sql } from '~/sql/sql.ts';
+import type { DrizzleTypeError, Equal } from '~/utils.ts';
+import { db } from './db.ts';
+
+const names = cockroachTable('names', {
+	id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+	name: text('name'),
+	authorId: int4('author_id'),
+});
+
+const n1 = db
+	.select({
+		id: names.id,
+		name: names.name,
+		authorId: names.authorId,
+		count1: sql<number>`count(1)::int`.as('count1'),
+	})
+	.from(names)
+	.groupBy(names.id, names.name, names.authorId)
+	.as('n1');
+
+const n2 = db
+	.select({
+		id: names.id,
+		authorId: names.authorId,
+		totalCount: sql<number>`count(1)::int`.as('totalCount'),
+	})
+	.from(names)
+	.groupBy(names.id, names.authorId)
+	.as('n2');
+
+const result = await db
+	.select({
+		name: n1.name,
+		authorId: n1.authorId,
+		count1: n1.count1,
+		totalCount: n2.totalCount,
+	})
+	.from(n1)
+	.innerJoin(n2, and(eq(n2.id, n1.id), eq(n2.authorId, n1.authorId)));
+
+Expect<
+	Equal<
+		{
+			name: string | null;
+			authorId: number | null;
+			count1: number;
+			totalCount: number;
+		}[],
+		typeof result
+	>
+>;
+
+const names2 = alias(names, 'names2');
+
+const sq1 = db
+	.select({
+		id: names.id,
+		name: names.name,
+		id2: names2.id,
+	})
+	.from(names)
+	.leftJoin(names2, eq(names.name, names2.name))
+	.as('sq1');
+
+const res = await db.select().from(sq1);
+
+Expect<
+	Equal<
+		{
+			id: number;
+			name: string | null;
+			id2: number | null;
+		}[],
+		typeof res
+	>
+>;
+
+{
+	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
+	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
+}
+
+const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+
+const resUnion = await db.select().from(sqUnion);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		authorId: number | null;
+	}[], typeof resUnion>
+>;
diff --git a/drizzle-orm/type-tests/cockroach/tables-rel.ts b/drizzle-orm/type-tests/cockroach/tables-rel.ts
new file mode 100644
index 0000000000..e5bce4870c
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/tables-rel.ts
@@ -0,0 +1,79 @@
+import { relations } from '~/_relations.ts';
+import { cockroachTable, foreignKey, int4, text, timestamp } from '~/cockroach-core/index.ts';
+
+export const users = cockroachTable('users', {
+	id: int4('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int4('city_id').references(() => cities.id).notNull(),
+	homeCityId: int4('home_city_id').references(() => cities.id),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull(),
+});
+export const usersConfig = relations(users, ({ one, many }) => ({
+	city: one(cities, { relationName: 'UsersInCity', fields: [users.cityId], references: [cities.id] }),
+	homeCity: one(cities, { fields: [users.homeCityId], references: [cities.id] }),
+	posts: many(posts),
+	comments: many(comments),
+}));
+
+export const cities = cockroachTable('cities', {
+	id: int4('id').primaryKey(),
+	name: text('name').notNull(),
+});
+export const citiesConfig = relations(cities, ({ many }) => ({
+	users: many(users, { relationName: 'UsersInCity' }),
+}));
+
+export const posts = cockroachTable('posts', {
+	id: int4('id').primaryKey(),
+	title: text('title').notNull(),
+	authorId: int4('author_id').references(() => users.id),
+});
+export const postsConfig = relations(posts, ({ one, many }) => ({
+	author: one(users, { fields: [posts.authorId], references: [users.id] }),
+	comments: many(comments),
+}));
+
+export const comments = cockroachTable('comments', {
+	id: int4('id').primaryKey(),
+	postId: int4('post_id').references(() => posts.id).notNull(),
+	authorId: int4('author_id').references(() => users.id),
+	text: text('text').notNull(),
+});
+export const commentsConfig = relations(comments, ({ one }) => ({
+	post: one(posts, { fields: [comments.postId], references: [posts.id] }),
+	author: one(users, { fields: [comments.authorId], references: [users.id] }),
+}));
+
+export const books = cockroachTable('books', {
+	id: int4('id').primaryKey(),
+	name: text('name').notNull(),
+});
+export const booksConfig = relations(books, ({ many }) => ({
+	authors: many(bookAuthors),
+}));
+
+export const bookAuthors = cockroachTable('book_authors', {
+	bookId: int4('book_id').references(() => books.id).notNull(),
+	authorId: int4('author_id').references(() => users.id).notNull(),
+	role: text('role').notNull(),
+});
+export const bookAuthorsConfig = relations(bookAuthors, ({ one }) => ({
+	book: one(books, { fields: [bookAuthors.bookId], references: [books.id] }),
+	author: one(users, { fields: [bookAuthors.authorId], references: [users.id] }),
+}));
+
+export const node = cockroachTable('node', {
+	id: int4('id').primaryKey(),
+	parentId: int4('parent_id'),
+	leftId: int4('left_id'),
+	rightId: int4('right_id'),
+}, (node) => [
+	foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
+]);
+export const nodeRelations = relations(node, ({ one }) => ({
+	parent: one(node, { fields: [node.parentId], references: [node.id] }),
+	left: one(node, { fields: [node.leftId], references: [node.id] }),
+	right: one(node, { fields: [node.rightId], references: [node.id] }),
+}));
diff --git a/drizzle-orm/type-tests/cockroach/tables.ts b/drizzle-orm/type-tests/cockroach/tables.ts
new file mode 100644
index 0000000000..14f0d2db60
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/tables.ts
@@ -0,0 +1,708 @@
+import crypto from 'node:crypto';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { z } from 'zod';
+import {
+	bigint,
+	bit,
+	bool,
+	char,
+	check,
+	cockroachEnum,
+	cockroachTable,
+	customType,
+	date,
+	decimal,
+	doublePrecision,
+	foreignKey,
+	geometry,
+	index,
+	inet,
+	int2,
+	int4,
+	int8,
+	jsonb,
+	numeric,
+	primaryKey,
+	real,
+	smallint,
+	string,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	uuid,
+	varchar,
+	vector,
+} from '~/cockroach-core/index.ts';
+import { cockroachSchema } from '~/cockroach-core/schema.ts';
+import { cockroachMaterializedView, cockroachView } from '~/cockroach-core/view.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { sql } from '~/sql/sql.ts';
+import type { InferInsertModel, InferSelectModel } from '~/table.ts';
+import type { Simplify } from '~/utils.ts';
+import { db } from './db.ts';
+
+export const myEnum = cockroachEnum('my_enum', ['a', 'b', 'c']);
+
+export const identityColumnsTable = cockroachTable('identity_columns_table', {
+	generatedCol: int4('generated_col').generatedAlwaysAs(sql`1`),
+	alwaysAsIdentity: int4('always_as_identity').generatedAlwaysAsIdentity(),
+	byDefaultAsIdentity: int4('by_default_as_identity').generatedByDefaultAsIdentity(),
+	name: text('name'),
+});
+
+Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferSelect']>>;
+Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferInsert']>>;
+Expect<
+	Equal<
+		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
+		Simplify<typeof identityColumnsTable['$inferInsert'] & { alwaysAsIdentity?: number | undefined }>
+	>
+>;
+
+export const users = cockroachTable(
+	'users_table',
+	{
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		uuid: uuid('uuid').defaultRandom().notNull(),
+		homeCity: int4('home_city')
+			.notNull()
+			.references(() => cities.id),
+		currentCity: int4('current_city').references(() => cities.id),
+		int4Nullable: int4('int41'),
+		int4NotNull: int4('int42').generatedAlwaysAsIdentity(),
+		class: text('class', { enum: ['A', 'C'] }).notNull(),
+		subClass: text('sub_class', { enum: ['B', 'D'] }),
+		text: text('text'),
+		age1: int4('age1').notNull(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+		enumCol: myEnum('enum_col').notNull(),
+		arrayCol: text('array_col').array().notNull(),
+	},
+	(users) => [
+		uniqueIndex('usersAge1Idx').on(users.class.asc(), sql``),
+		index('usersAge2Idx').on(sql``),
+		uniqueIndex('uniqueClass')
+			.using('btree', users.class.desc(), users.subClass)
+			.where(sql`${users.class} is not null`),
+		check('legalAge', sql`${users.age1} > 18`),
+		foreignKey({ columns: [users.subClass], foreignColumns: [classes.subClass] })
+			.onUpdate('cascade')
+			.onDelete('cascade'),
+		foreignKey({
+			columns: [users.class, users.subClass],
+			foreignColumns: [classes.class, classes.subClass],
+		}),
+		primaryKey({ columns: [users.age1, users.class] }),
+	],
+);
+
+Expect<Equal<InferSelectModel<typeof users>, typeof users['$inferSelect']>>;
+Expect<Equal<InferInsertModel<typeof users>, typeof users['$inferInsert']>>;
+
+export const cities = cockroachTable('cities_table', {
+	id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+	name: text('name').notNull(),
+	population: int4('population').default(0),
+}, (cities) => [index().on(cities.id)]);
+
+export const smallintTest = cockroachTable('cities_table', {
+	id: smallint('id').primaryKey(),
+	name: text('name').notNull(),
+	population: int4('population').default(0),
+});
+
+Expect<
+	Equal<{
+		id: number;
+		name: string;
+		population?: number | null;
+	}, typeof smallintTest.$inferInsert>
+>;
+
+export const classes = cockroachTable('classes_table', {
+	id: int4('id').primaryKey(),
+	class: text('class', { enum: ['A', 'C'] }),
+	subClass: text('sub_class', { enum: ['B', 'D'] }).notNull(),
+});
+
+Expect<
+	Equal<{
+		id: number;
+		class?: 'A' | 'C' | null;
+		subClass: 'B' | 'D';
+	}, typeof classes.$inferInsert>
+>;
+
+export const network = cockroachTable('network_table', {
+	inet: inet('inet').notNull(),
+});
+
+Expect<
+	Equal<{
+		inet: string;
+	}, typeof network.$inferSelect>
+>;
+
+export const salEmp = cockroachTable('sal_emp', {
+	name: text('name').notNull(),
+	payByQuarter: int4('pay_by_quarter').array().notNull(),
+	schedule: text('schedule').array().notNull(),
+});
+
+export const customSchema = cockroachSchema('custom');
+
+export const citiesCustom = customSchema.table('cities_table', {
+	id: int4('id').primaryKey(),
+	name: text('name').notNull(),
+	population: int4('population').default(0),
+}, (cities) => [index().on(cities.id)]);
+
+export const newYorkers = cockroachView('new_yorkers')
+	.as((qb) => {
+		const sq = qb
+			.$with('sq')
+			.as(
+				qb.select({ userId: users.id, cityId: cities.id })
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.homeCity))
+					.where(sql`${users.age1} > 18`),
+			);
+		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+	});
+
+export const newYorkers2 = cockroachMaterializedView('new_yorkers')
+	.withNoData()
+	.as((qb) => {
+		const sq = qb
+			.$with('sq')
+			.as(
+				qb.select({ userId: users.id, cityId: cities.id })
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.homeCity))
+					.where(sql`${users.age1} > 18`),
+			);
+		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+	});
+
+await db.refreshMaterializedView(newYorkers2).concurrently();
+await db.refreshMaterializedView(newYorkers2).withNoData();
+await db.refreshMaterializedView(newYorkers2).concurrently().withNoData();
+await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
+
+export const newYorkersWithSubquery = cockroachView('new_yorkers_with_sq')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				class: users.class,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+				lastCityId: qb
+					.select({ id: cities.id })
+					.from(cities)
+					.orderBy(cities.id)
+					.limit(1)
+					.as('last_city'),
+			})
+			.from(users)
+	);
+
+export const newYorkersWithSubquery2 = cockroachMaterializedView('new_yorkers_with_sq_mv')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+			})
+			.from(users)
+	);
+
+// await migrate(db, {
+// 	migrationsFolder: './drizzle/cockroach',
+// 	onMigrationError(error) {
+// 		if (['0001_drizli_klaud', '0002_beep_boop'].includes(error.migration.name)) {
+// 			return;
+// 		}
+// 		throw error;
+// 	},
+// });
+
+{
+	const customTextRequired = customType<{
+		data: string;
+		driverData: string;
+		config: { length: number };
+		configRequired: true;
+	}>({
+		dataType(config) {
+			Expect<Equal<{ length: number }, typeof config>>;
+			return `varchar(${config.length})`;
+		},
+
+		toDriver(value) {
+			Expect<Equal<string, typeof value>>();
+			return value;
+		},
+
+		fromDriver(value) {
+			Expect<Equal<string, typeof value>>();
+			return value;
+		},
+	});
+
+	customTextRequired('t', { length: 10 });
+	customTextRequired({ length: 10 });
+	// @ts-expect-error - config is required
+	customTextRequired('t');
+	// @ts-expect-error - config is required
+	customTextRequired();
+}
+
+{
+	const customTextOptional = customType<{
+		data: string;
+		driverData: string;
+		config: { length: number };
+	}>({
+		dataType(config) {
+			Expect<Equal<{ length: number } | undefined, typeof config>>;
+			return config ? `varchar(${config.length})` : `text`;
+		},
+
+		toDriver(value) {
+			Expect<Equal<string, typeof value>>();
+			return value;
+		},
+
+		fromDriver(value) {
+			Expect<Equal<string, typeof value>>();
+			return value;
+		},
+	});
+
+	customTextOptional('t', { length: 10 });
+	customTextOptional('t');
+	customTextOptional({ length: 10 });
+	customTextOptional();
+}
+
+{
+	cockroachTable('cities_table', {
+		id: int4('id').primaryKey(),
+		name: text('name').notNull().primaryKey(),
+		role: text('role', { enum: ['admin', 'user'] }).default('user').notNull(),
+		role1: string('role1', { enum: ['admin', 'user'], length: 200 }).default('user').notNull(),
+		population: int4('population').default(0),
+	});
+	cockroachTable('cities_table', ({ int4, text }) => ({
+		id: int4('id').primaryKey(),
+		name: text('name').notNull().primaryKey(),
+		role: text('role', { enum: ['admin', 'user'] }).default('user').notNull(),
+		role1: string('role1', { enum: ['admin', 'user'], length: 200 }).default('user').notNull(),
+		population: int4('population').default(0),
+	}));
+}
+
+{
+	cockroachTable('test', {
+		bigint: bigint('bigint', { mode: 'bigint' }).default(BigInt(10)),
+		bigintNumber: bigint('bigintNumber', { mode: 'number' }),
+		timestamp: timestamp('timestamp').default(new Date()),
+		timestamp2: timestamp('timestamp2', { mode: 'date' }).default(new Date()),
+		timestamp3: timestamp('timestamp3', { mode: undefined }).default(new Date()),
+		timestamp4: timestamp('timestamp4', { mode: 'string' }).default('2020-01-01'),
+	});
+}
+
+{
+	const test = cockroachTable('test', {
+		col1: decimal('col1', { precision: 10, scale: 2 }).notNull().default('10.2'),
+	});
+	Expect<Equal<{ col1: string }, typeof test.$inferSelect>>;
+}
+
+{
+	const a = ['a', 'b', 'c'] as const;
+	const b = cockroachEnum('test', a);
+	z.enum(b.enumValues);
+}
+
+{
+	const b = cockroachEnum('test', ['a', 'b', 'c']);
+	z.enum(b.enumValues);
+}
+
+{
+	const getUsersTable = <TSchema extends string>(schemaName: TSchema) => {
+		return cockroachSchema(schemaName).table('users', {
+			id: int4('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+	};
+
+	const users1 = getUsersTable('id1');
+	Expect<Equal<'id1', typeof users1._.schema>>;
+
+	const users2 = getUsersTable('id2');
+	Expect<Equal<'id2', typeof users2._.schema>>;
+}
+
+{
+	const internalStaff = cockroachTable('internal_staff', {
+		userId: int4('user_id').notNull(),
+	});
+
+	const customUser = cockroachTable('custom_user', {
+		id: int4('id').notNull(),
+	});
+
+	const ticket = cockroachTable('ticket', {
+		staffId: int4('staff_id').notNull(),
+	});
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(
+			customUser,
+			eq(internalStaff.userId, customUser.id),
+		).as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	Expect<
+		Equal<{
+			internal_staff: {
+				internal_staff: {
+					userId: number;
+				};
+				custom_user: {
+					id: number | null;
+				};
+			} | null;
+			ticket: {
+				staffId: number;
+			};
+		}[], typeof mainQuery>
+	>;
+}
+
+{
+	const newYorkers = cockroachView('new_yorkers')
+		.as((qb) => {
+			const sq = qb
+				.$with('sq')
+				.as(
+					qb.select({ userId: users.id, cityId: cities.id })
+						.from(users)
+						.leftJoin(cities, eq(cities.id, users.homeCity))
+						.where(sql`${users.age1} > 18`),
+				);
+			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+		});
+
+	await db.select().from(newYorkers).leftJoin(newYorkers, eq(newYorkers.userId, newYorkers.userId));
+}
+
+{
+	const testSchema = cockroachSchema('test');
+
+	const e1 = cockroachEnum('test', ['a', 'b', 'c']);
+	const e2 = cockroachEnum('test', ['a', 'b', 'c'] as const);
+	const e3 = testSchema.enum('test', ['a', 'b', 'c']);
+	const e4 = testSchema.enum('test', ['a', 'b', 'c'] as const);
+
+	const test = cockroachTable('test', {
+		col1: char('col1', { enum: ['a', 'b', 'c'] as const }),
+		col2: char('col2', { enum: ['a', 'b', 'c'] }),
+		col3: char('col3'),
+		col4: e1('col4'),
+		col5: e2('col5'),
+		col6: text('col6', { enum: ['a', 'b', 'c'] as const }),
+		col7: text('col7', { enum: ['a', 'b', 'c'] }),
+		col8: text('col8'),
+		col9: varchar('col9', { enum: ['a', 'b', 'c'] as const }),
+		col10: varchar('col10', { enum: ['a', 'b', 'c'] }),
+		col11: varchar('col11'),
+		col12: e3('col4'),
+		col13: e4('col5'),
+	});
+
+	Expect<Equal<['a', 'b', 'c'], typeof test.col1.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col2.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col3.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col4.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col5.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col6.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col7.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col8.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col9.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col10.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col11.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col12.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col13.enumValues>>;
+}
+
+{
+	const testSchema = cockroachSchema('test');
+
+	const e1 = cockroachEnum('test', ['a', 'b', 'c']);
+	const e2 = cockroachEnum('test', ['a', 'b', 'c'] as const);
+	const e3 = testSchema.enum('test', ['a', 'b', 'c']);
+	const e4 = testSchema.enum('test', ['a', 'b', 'c'] as const);
+
+	const test = cockroachTable('test', {
+		col1: char('col1', { enum: ['a', 'b', 'c'] as const }).generatedAlwaysAs(sql``),
+		col2: char('col2', { enum: ['a', 'b', 'c'] }).generatedAlwaysAs(sql``),
+		col3: char('col3').generatedAlwaysAs(sql``),
+		col4: e1('col4').generatedAlwaysAs(sql``),
+		col5: e2('col5').generatedAlwaysAs(sql``),
+		col6: text('col6', { enum: ['a', 'b', 'c'] as const }).generatedAlwaysAs(sql``),
+		col7: text('col7', { enum: ['a', 'b', 'c'] }).generatedAlwaysAs(sql``),
+		col8: text('col8').generatedAlwaysAs(sql``),
+		col9: varchar('col9', { enum: ['a', 'b', 'c'] as const }).generatedAlwaysAs(sql``),
+		col10: varchar('col10', { enum: ['a', 'b', 'c'] }).generatedAlwaysAs(sql``),
+		col11: varchar('col11').generatedAlwaysAs(sql``),
+		col12: e3('col4').generatedAlwaysAs(sql``),
+		col13: e4('col5').generatedAlwaysAs(sql``),
+	});
+
+	Expect<Equal<['a', 'b', 'c'], typeof test.col1.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col2.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col3.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col4.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col5.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col6.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col7.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col8.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col9.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col10.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.col11.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col12.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.col13.enumValues>>;
+}
+
+{
+	const test = cockroachTable('test', {
+		id: text('id').$defaultFn(() => crypto.randomUUID()).primaryKey(),
+	});
+
+	Expect<
+		Equal<{
+			id?: string;
+		}, typeof test.$inferInsert>
+	>;
+}
+
+{
+	cockroachTable('test', {
+		id: int4('id').$default(() => 1),
+		id2: int4('id').$defaultFn(() => 1),
+		// @ts-expect-error - should be number
+		id3: int4('id').$default(() => '1'),
+		// @ts-expect-error - should be number
+		id4: int4('id').$defaultFn(() => '1'),
+	});
+}
+
+{
+	const enum_ = cockroachEnum('enum', ['a', 'b', 'c']);
+
+	cockroachTable('all_columns', {
+		enum: enum_('enum'),
+		enumdef: enum_('enumdef').default('a'),
+		sm: smallint('smallint'), // same as int2
+		smdef: smallint('smallint_def').default(10), // same as int2
+		int2col: int2('int2col'),
+		int2colDef: int2('int2col_dev').default(10),
+		int: int4('int4'),
+		intdef: int4('int4_def').default(10),
+		numeric: numeric('numeric'),
+		numeric2: numeric('numeric2', { precision: 5 }),
+		numeric3: numeric('numeric3', { scale: 2 }),
+		numeric4: numeric('numeric4', { precision: 5, scale: 2 }),
+		numericdef: numeric('numeridef').default('100'),
+		bigint: bigint('bigint', { mode: 'number' }),
+		bigintdef: bigint('bigintdef', { mode: 'number' }).default(100),
+		bool: bool('boolean'),
+		booldef: bool('boolean_def').default(true),
+		text: text('text'),
+		textdef: text('textdef').default('text'),
+		varchar: varchar('varchar'),
+		varchardef: varchar('varchardef').default('text'),
+		int4: int4('int4'),
+		decimal: decimal('decimal', { precision: 100, scale: 2 }),
+		decimaldef: decimal('decimaldef', { precision: 100, scale: 2 }).default('100.0'),
+		doublePrecision: doublePrecision('doublePrecision'),
+		doublePrecisiondef: doublePrecision('doublePrecisiondef').default(100),
+		real: real('real'),
+		realdef: real('realdef').default(100),
+		jsonb: jsonb('jsonb').$type<{ attr: string }>(),
+		jsonbdef: jsonb('jsonbdef').$type<{ attr: string }>().default({ attr: 'value' }),
+		time: time('time'),
+		time2: time('time2', { precision: 6, withTimezone: true }),
+		timedef: time('timedef').default('00:00:00'),
+		timestamp: timestamp('timestamp'),
+		timestamp2: timestamp('timestamp2', { precision: 6, withTimezone: true }),
+		timestamp3: timestamp('timestamp3', { withTimezone: true }),
+		timestamp4: timestamp('timestamp4', { precision: 4 }),
+		timestampdef: timestamp('timestampdef').default(new Date()),
+		date: date('date', { mode: 'date' }),
+		datedef: date('datedef').default('2024-01-01'),
+		datedefnow: date('datedefnow').defaultNow(),
+	});
+
+	cockroachTable('all_postgis_columns', {
+		geometry: geometry('geometry'),
+		geometry2: geometry('geometry2', { srid: 2, mode: 'xy' }),
+		geometry3: geometry('geometry3', { srid: 3, mode: 'tuple' }),
+		geometry4: geometry('geometry4', { mode: 'tuple' }),
+		geometrydef: geometry('geometrydef').default([1, 2]),
+	});
+
+	cockroachTable('all_vector_columns', {
+		bit: bit('bit', { length: 1 }),
+		bitdef: bit('bitdef', { length: 1 }).default('1'),
+		vector: vector('vector', { dimensions: 1 }),
+		vectordef: vector('vectordef', { dimensions: 1 }).default([1]),
+	});
+}
+
+{
+	const keysAsColumnNames = cockroachTable('test', {
+		id: int4(),
+		name: text(),
+	});
+
+	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], string>>;
+	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], string>>;
+}
+
+{
+	const enum_ = cockroachEnum('enum', ['a', 'b', 'c']);
+
+	cockroachTable('all_columns_without_name', {
+		enum: enum_(),
+		enumdef: enum_().default('a'),
+		sm: smallint(),
+		smdef: smallint().default(10),
+		int: int4(),
+		intdef: int4().default(10),
+		numeric: numeric(),
+		numeric2: numeric({ precision: 5 }),
+		numeric3: numeric({ scale: 2 }),
+		numeric4: numeric({ precision: 5, scale: 2 }),
+		numericdef: numeric().default('100'),
+		bigint: bigint({ mode: 'number' }),
+		bigintdef: bigint({ mode: 'number' }).default(100),
+		int8column: int8({ mode: 'number' }),
+		int8columndef: int8({ mode: 'number' }).default(100),
+		bool: bool(),
+		booldef: bool().default(true),
+		text: text(),
+		textdef: text().default('text'),
+		varchar: varchar(),
+		varchardef: varchar().default('text'),
+		int4: int4(),
+		decimal: decimal({ precision: 100, scale: 2 }),
+		decimaldef: decimal({ precision: 100, scale: 2 }).default('100.0'),
+		doublePrecision: doublePrecision(),
+		doublePrecisiondef: doublePrecision().default(100),
+		real: real(),
+		realdef: real().default(100),
+		jsonb: jsonb().$type<{ attr: string }>(),
+		jsonbdef: jsonb().$type<{ attr: string }>().default({ attr: 'value' }),
+		time: time(),
+		time2: time({ precision: 6, withTimezone: true }),
+		timedef: time().default('00:00:00'),
+		timedefnow: time(),
+		timestamp: timestamp(),
+		timestamp2: timestamp({ precision: 6, withTimezone: true }),
+		timestamp3: timestamp({ withTimezone: true }),
+		timestamp4: timestamp({ precision: 4 }),
+		timestampdef: timestamp().default(new Date()),
+		date: date({ mode: 'date' }),
+		datedef: date().default('2024-01-01'),
+		datedefnow: date().defaultNow(),
+	});
+
+	cockroachTable('all_postgis_columns', {
+		geometry: geometry(),
+		geometry2: geometry({ srid: 2, mode: 'xy' }),
+		geometry3: geometry({ srid: 3, mode: 'tuple' }),
+		geometry4: geometry({ mode: 'tuple' }),
+		geometrydef: geometry().default([1, 2]),
+	});
+
+	cockroachTable('all_vector_columns', {
+		bit: bit({ length: 1 }),
+		bitdef: bit({ length: 1 }).default('1'),
+		vector: vector({ dimensions: 1 }),
+		vectordef: vector({ dimensions: 1 }).default([1]),
+	});
+}
+
+// ts enums test
+{
+	enum Role {
+		admin = 'admin',
+		user = 'user',
+		guest = 'guest',
+	}
+
+	const role = cockroachEnum('role', Role);
+
+	enum RoleNonString {
+		admin,
+		user,
+		guest,
+	}
+
+	// @ts-expect-error
+	cockroachEnum('role', RoleNonString);
+
+	enum RolePartiallyString {
+		admin,
+		user = 'user',
+		guest = 'guest',
+	}
+
+	// @ts-expect-error
+	cockroachEnum('role', RolePartiallyString);
+
+	const table = cockroachTable('table', {
+		enum: role('enum'),
+	});
+
+	const res = await db.select().from(table);
+
+	Expect<Equal<{ enum: Role | null }[], typeof res>>;
+
+	const mySchema = cockroachSchema('my_schema');
+
+	const schemaRole = mySchema.enum('role', Role);
+
+	// @ts-expect-error
+	mySchema.enum('role', RoleNonString);
+
+	// @ts-expect-error
+	mySchema.enum('role', RolePartiallyString);
+
+	const schemaTable = mySchema.table('table', {
+		enum: schemaRole('enum'),
+	});
+
+	const schemaRes = await db.select().from(schemaTable);
+
+	Expect<Equal<{ enum: Role | null }[], typeof schemaRes>>;
+}
diff --git a/drizzle-orm/type-tests/cockroach/update.ts b/drizzle-orm/type-tests/cockroach/update.ts
new file mode 100644
index 0000000000..25d5e6e776
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/update.ts
@@ -0,0 +1,278 @@
+import type { QueryResult } from 'pg';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { CockroachUpdate } from '~/cockroach-core/index.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { sql } from '~/sql/sql.ts';
+import type { Simplify } from '~/utils.ts';
+import { db } from './db.ts';
+import { cities, salEmp, users } from './tables.ts';
+
+const update = await db.update(users)
+	.set({
+		text: 'John',
+		age1: 30,
+	})
+	.where(eq(users.id, 1));
+Expect<Equal<QueryResult<never>, typeof update>>;
+
+const updateStmt = db.update(users)
+	.set({
+		text: 'John',
+		age1: 30,
+	})
+	.where(eq(users.id, 1))
+	.prepare('updateStmt');
+const updatePrepared = await updateStmt.execute();
+Expect<Equal<QueryResult<never>, typeof updatePrepared>>;
+
+const updateReturning = await db.update(users)
+	.set({
+		text: 'John',
+		age1: 30,
+	})
+	.where(eq(users.id, 1))
+	.returning({
+		text: users.text,
+	});
+Expect<Equal<{ text: string | null }[], typeof updateReturning>>;
+
+const updateReturningStmt = db.update(users)
+	.set({
+		text: 'John',
+		age1: 30,
+	})
+	.where(eq(users.id, 1))
+	.returning({
+		text: users.text,
+	})
+	.prepare('updateReturningStmt');
+const updateReturningPrepared = await updateReturningStmt.execute();
+Expect<Equal<{ text: string | null }[], typeof updateReturningPrepared>>;
+
+{
+	function dynamic<T extends CockroachUpdate>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends CockroachUpdate>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+
+	db
+		.update(users)
+		.set({})
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.from(sql``)
+		.leftJoin(sql``, (table, from) => {
+			Expect<Equal<typeof users['_']['columns'], typeof table>>;
+			Expect<Equal<never, typeof from>>;
+			return sql``;
+		});
+
+	db
+		.update(users)
+		.set({})
+		.from(cities)
+		.leftJoin(sql``, (table, from) => {
+			Expect<Equal<typeof users['_']['columns'], typeof table>>;
+			Expect<Equal<typeof cities['_']['columns'], typeof from>>;
+			return sql``;
+		});
+
+	const citiesSq = db.$with('cities_sq').as(db.select({ id: cities.id }).from(cities));
+
+	db
+		.with(citiesSq)
+		.update(users)
+		.set({})
+		.from(citiesSq)
+		.leftJoin(sql``, (table, from) => {
+			Expect<Equal<typeof users['_']['columns'], typeof table>>;
+			Expect<Equal<typeof citiesSq['_']['selectedFields'], typeof from>>;
+			return sql``;
+		});
+
+	db
+		.with(citiesSq)
+		.update(users)
+		.set({
+			homeCity: citiesSq.id,
+		})
+		.from(citiesSq);
+}
+
+{
+	const result = await db.update(users).set({}).from(cities).returning();
+	Expect<
+		Equal<Simplify<
+			typeof users.$inferSelect & {
+				cities_table: typeof cities.$inferSelect;
+			}
+		>[], typeof result>
+	>;
+}
+
+{
+	const result1 = await db.update(users).set({}).from(cities).leftJoin(salEmp, sql``).returning();
+	Expect<
+		Equal<Simplify<
+			typeof users.$inferSelect & {
+				cities_table: typeof cities.$inferSelect;
+				sal_emp: typeof salEmp.$inferSelect | null;
+			}
+		>[], typeof result1>
+	>;
+
+	const result2 = await db.update(users).set({}).from(cities).rightJoin(salEmp, sql``).returning();
+	Expect<
+		Equal<Simplify<
+			{ [K in keyof typeof users.$inferSelect]: typeof users.$inferSelect[K] | null } & {
+				cities_table: typeof cities.$inferSelect | null;
+				sal_emp: typeof salEmp.$inferSelect;
+			}
+		>[], typeof result2>
+	>;
+
+	const result3 = await db.update(users).set({}).from(cities).innerJoin(salEmp, sql``).returning();
+	Expect<
+		Equal<Simplify<
+			typeof users.$inferSelect & {
+				cities_table: typeof cities.$inferSelect;
+				sal_emp: typeof salEmp.$inferSelect;
+			}
+		>[], typeof result3>
+	>;
+
+	const result4 = await db.update(users).set({}).from(cities).fullJoin(salEmp, sql``).returning();
+	Expect<
+		Equal<Simplify<
+			{ [K in keyof typeof users.$inferSelect]: typeof users.$inferSelect[K] | null } & {
+				cities_table: typeof cities.$inferSelect | null;
+				sal_emp: typeof salEmp.$inferSelect | null;
+			}
+		>[], typeof result4>
+	>;
+}
+
+{
+	const result = await db.update(users).set({}).from(cities).returning({
+		id: users.id,
+		cities: cities,
+		cityName: cities.name,
+	});
+	Expect<
+		Equal<Simplify<{
+			id: number;
+			cities: typeof cities.$inferSelect;
+			cityName: string;
+		}>[], typeof result>
+	>;
+}
+
+{
+	const result1 = await db.update(users).set({}).from(cities).leftJoin(salEmp, sql``).returning({
+		id: users.id,
+		cities: cities,
+		cityName: cities.name,
+		salEmp: salEmp,
+		salEmpName: salEmp.name,
+	});
+	Expect<
+		Equal<Simplify<{
+			id: number;
+			cities: typeof cities.$inferSelect;
+			cityName: string;
+			salEmp: typeof salEmp.$inferSelect | null;
+			salEmpName: string | null;
+		}>[], typeof result1>
+	>;
+
+	const result2 = await db.update(users).set({}).from(cities).rightJoin(salEmp, sql``).returning({
+		id: users.id,
+		cities: cities,
+		cityName: cities.name,
+		salEmp: salEmp,
+		salEmpName: salEmp.name,
+	});
+	Expect<
+		Equal<Simplify<{
+			id: number | null;
+			cities: typeof cities.$inferSelect | null;
+			cityName: string | null;
+			salEmp: typeof salEmp.$inferSelect;
+			salEmpName: string;
+		}>[], typeof result2>
+	>;
+
+	const result3 = await db.update(users).set({}).from(cities).innerJoin(salEmp, sql``).returning({
+		id: users.id,
+		cities: cities,
+		cityName: cities.name,
+		salEmp: salEmp,
+		salEmpName: salEmp.name,
+	});
+	Expect<
+		Equal<Simplify<{
+			id: number;
+			cities: typeof cities.$inferSelect;
+			cityName: string;
+			salEmp: typeof salEmp.$inferSelect;
+			salEmpName: string;
+		}>[], typeof result3>
+	>;
+
+	const result4 = await db.update(users).set({}).from(cities).fullJoin(salEmp, sql``).returning({
+		id: users.id,
+		cities: cities,
+		cityName: cities.name,
+		salEmp: salEmp,
+		salEmpName: salEmp.name,
+	});
+	Expect<
+		Equal<Simplify<{
+			id: number | null;
+			cities: typeof cities.$inferSelect | null;
+			cityName: string | null;
+			salEmp: typeof salEmp.$inferSelect | null;
+			salEmpName: string | null;
+		}>[], typeof result4>
+	>;
+}
+
+{
+	await db
+		.update(users)
+		.set({})
+		// @ts-expect-error can't use joins before from
+		.fullJoin(salEmp, sql``);
+}
diff --git a/drizzle-orm/type-tests/cockroach/with.ts b/drizzle-orm/type-tests/cockroach/with.ts
new file mode 100644
index 0000000000..5a962d5851
--- /dev/null
+++ b/drizzle-orm/type-tests/cockroach/with.ts
@@ -0,0 +1,329 @@
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { cockroachTable, int4, text } from '~/cockroach-core/index.ts';
+import { gt, inArray, like } from '~/sql/expressions/index.ts';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+
+{
+	const orders = cockroachTable('orders', {
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		region: text('region').notNull(),
+		product: text('product').notNull(),
+		amount: int4('amount').notNull(),
+		quantity: int4('quantity').notNull(),
+		generated: text('generatedText').generatedAlwaysAs(sql``),
+	});
+
+	const regionalSales = db
+		.$with('regional_sales')
+		.as((qb) =>
+			qb
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region)
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as((qb) =>
+			qb
+				.select({
+					region: orders.region,
+					totalSales: orders.amount,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				)
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`sum(${orders.quantity})`,
+			productSales: sql<number>`sum(${orders.amount})`,
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)));
+
+	Expect<
+		Equal<{
+			region: string;
+			product: string;
+			productUnits: number;
+			productSales: number;
+		}[], typeof result>
+	>;
+
+	const allOrdersWith = db.$with('all_orders_with').as(db.select().from(orders));
+	const allFromWith = await db.with(allOrdersWith).select().from(allOrdersWith);
+
+	Expect<
+		Equal<{
+			id: number;
+			region: string;
+			product: string;
+			amount: number;
+			quantity: number;
+			generated: string | null;
+		}[], typeof allFromWith>
+	>;
+
+	const regionalSalesWith = db.$with('regional_sales_with').as(db.select().from(regionalSales));
+	db.with(regionalSalesWith).select().from(regionalSalesWith).where(like(regionalSalesWith.totalSales, 'abc'));
+}
+
+{
+	const providers = cockroachTable('providers', {
+		id: int4().primaryKey().generatedAlwaysAsIdentity(),
+		providerName: text().notNull(),
+	});
+	const products = cockroachTable('products', {
+		id: int4().primaryKey().generatedAlwaysAsIdentity(),
+		productName: text().notNull(),
+	});
+
+	const sq1 = db.$with('inserted_products').as(
+		db.insert(products).values({ productName: sql`` }),
+	);
+	const sq2 = db.$with('inserted_products').as(
+		db.insert(products).values({ productName: sql`` }).returning(),
+	);
+	const sq3 = db.$with('inserted_products').as(
+		db.insert(products).values({ productName: sql`` }).returning({ productName: products.productName }),
+	);
+
+	// @ts-expect-error
+	db.with(sq1).select().from(sq1);
+	// @ts-expect-error
+	db.with(sq1).select().from(providers).leftJoin(sq1, sql``);
+
+	const q3 = await db.with(sq2).select().from(sq2);
+	Expect<
+		Equal<typeof q3, {
+			id: number;
+			productName: string;
+		}[]>
+	>;
+	const q4 = await db.with(sq3).select().from(providers).leftJoin(sq2, sql``);
+	Expect<
+		Equal<typeof q4, {
+			providers: {
+				id: number;
+				providerName: string;
+			};
+			inserted_products: {
+				id: number;
+				productName: string;
+			} | null;
+		}[]>
+	>;
+
+	const q5 = await db.with(sq3).select().from(sq3);
+	Expect<Equal<typeof q5, { productName: string }[]>>;
+	const q6 = await db.with(sq3).select().from(providers).leftJoin(sq3, sql``);
+	Expect<
+		Equal<
+			typeof q6,
+			{ providers: { id: number; providerName: string }; inserted_products: { productName: string } | null }[]
+		>
+	>;
+}
+
+{
+	const providers = cockroachTable('providers', {
+		id: int4().primaryKey(),
+		providerName: text().notNull(),
+	});
+	const products = cockroachTable('products', {
+		id: int4().primaryKey(),
+		productName: text().notNull(),
+	});
+	const otherProducts = cockroachTable('other_products', {
+		id: int4().primaryKey(),
+		productName: text().notNull(),
+	});
+
+	const sq1 = db.$with('updated_products').as(
+		db.update(products).set({ productName: sql`` }),
+	);
+	const sq2 = db.$with('updated_products').as(
+		db.update(products).set({ productName: sql`` }).returning(),
+	);
+	const sq3 = db.$with('updated_products').as(
+		db.update(products).set({ productName: sql`` }).returning({ productName: products.productName }),
+	);
+	const sq4 = db.$with('updated_products').as(
+		db.update(products).set({ productName: sql`` }).from(otherProducts).returning(),
+	);
+
+	// @ts-expect-error
+	db.with(sq1).select().from(sq1);
+	// @ts-expect-error
+	db.with(sq1).select().from(providers).leftJoin(sq1, sql``);
+
+	const q3 = await db.with(sq2).select().from(sq2);
+	Expect<
+		Equal<typeof q3, {
+			id: number;
+			productName: string;
+		}[]>
+	>;
+	const q4 = await db.with(sq3).select().from(providers).leftJoin(sq2, sql``);
+	Expect<
+		Equal<typeof q4, {
+			providers: {
+				id: number;
+				providerName: string;
+			};
+			updated_products: {
+				id: number;
+				productName: string;
+			} | null;
+		}[]>
+	>;
+
+	const q5 = await db.with(sq3).select().from(sq3);
+	Expect<
+		Equal<typeof q5, {
+			productName: string;
+		}[]>
+	>;
+	const q6 = await db.with(sq3).select().from(providers).leftJoin(sq3, sql``);
+	Expect<
+		Equal<typeof q6, {
+			providers: {
+				id: number;
+				providerName: string;
+			};
+			updated_products: {
+				productName: string;
+			} | null;
+		}[]>
+	>;
+
+	const q7 = await db.with(sq4).select().from(sq4);
+	Expect<
+		Equal<typeof q7, {
+			products: {
+				id: number;
+				productName: string;
+			};
+			other_products: {
+				id: number;
+				productName: string;
+			};
+		}[]>
+	>;
+	const q8 = await db.with(sq4).select().from(providers).leftJoin(sq4, sql``);
+	Expect<
+		Equal<typeof q8, {
+			providers: {
+				id: number;
+				providerName: string;
+			};
+			updated_products: {
+				products: {
+					id: number;
+					productName: string;
+				};
+				other_products: {
+					id: number;
+					productName: string;
+				};
+			} | null;
+		}[]>
+	>;
+}
+
+{
+	const providers = cockroachTable('providers', {
+		id: int4().primaryKey(),
+		providerName: text().notNull(),
+	});
+	const products = cockroachTable('products', {
+		id: int4().primaryKey(),
+		productName: text().notNull(),
+	});
+
+	const sq1 = db.$with('inserted_products').as(
+		db.delete(products),
+	);
+	const sq2 = db.$with('inserted_products').as(
+		db.delete(products).returning(),
+	);
+	const sq3 = db.$with('inserted_products').as(
+		db.delete(products).returning({ productName: products.productName }),
+	);
+
+	// @ts-expect-error
+	db.with(sq1).select().from(sq1);
+	// @ts-expect-error
+	db.with(sq1).select().from(providers).leftJoin(sq1, sql``);
+
+	const q3 = await db.with(sq2).select().from(sq2);
+	Expect<
+		Equal<typeof q3, {
+			id: number;
+			productName: string;
+		}[]>
+	>;
+	const q4 = await db.with(sq3).select().from(providers).leftJoin(sq2, sql``);
+	Expect<
+		Equal<typeof q4, {
+			providers: {
+				id: number;
+				providerName: string;
+			};
+			inserted_products: {
+				id: number;
+				productName: string;
+			} | null;
+		}[]>
+	>;
+
+	const q5 = await db.with(sq3).select().from(sq3);
+	Expect<Equal<typeof q5, { productName: string }[]>>;
+	const q6 = await db.with(sq3).select().from(providers).leftJoin(sq3, sql``);
+	Expect<
+		Equal<
+			typeof q6,
+			{ providers: { id: number; providerName: string }; inserted_products: { productName: string } | null }[]
+		>
+	>;
+}
+
+{
+	const providers = cockroachTable('providers', {
+		id: int4().primaryKey(),
+		providerName: text().notNull(),
+	});
+
+	const sq1 = db.$with('providers_sq', {
+		name: providers.providerName,
+	}).as(sql`select provider_name as name from providers`);
+	const q1 = await db.with(sq1).select().from(sq1);
+	Expect<Equal<typeof q1, { name: string }[]>>;
+
+	const sq2 = db.$with('providers_sq', {
+		nested: {
+			id: providers.id,
+		},
+	}).as(() => sql`select id from providers`);
+	const q2 = await db.with(sq2).select().from(sq2);
+	Expect<Equal<typeof q2, { nested: { id: number } }[]>>;
+
+	// @ts-expect-error
+	db.$with('providers_sq', { name: providers.providerName }).as(db.select().from(providers));
+	// @ts-expect-error
+	db.$with('providers_sq', { name: providers.providerName }).as((qb) => qb.select().from(providers));
+}
diff --git a/drizzle-orm/type-tests/common/aliased-table.ts b/drizzle-orm/type-tests/common/aliased-table.ts
index 9c2be8c5fa..3c21bd8dbf 100644
--- a/drizzle-orm/type-tests/common/aliased-table.ts
+++ b/drizzle-orm/type-tests/common/aliased-table.ts
@@ -1,4 +1,7 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
+import { alias as cockroachAliasFn } from '~/cockroach-core/alias.ts';
+import { cockroachView } from '~/cockroach-core/view.ts';
+import { drizzle as cockroachd } from '~/cockroach/index.ts';
 import { eq } from '~/index.ts';
 import { drizzle as sqlited } from '~/libsql/index.ts';
 import { alias as mysqlAliasFn } from '~/mysql-core/alias.ts';
@@ -9,6 +12,7 @@ import { pgView } from '~/pg-core/view.ts';
 import { drizzle as pgd } from '~/postgres-js/index.ts';
 import { alias as sqliteAliasFn } from '~/sqlite-core/alias.ts';
 import { sqliteView } from '~/sqlite-core/view.ts';
+import { users as cockroachUsers } from '../cockroach/tables.ts';
 import { users as mysqlUsers } from '../mysql/tables.ts';
 import { users as pgUsers } from '../pg/tables.ts';
 import { users as sqliteUsers } from '../sqlite/tables.ts';
@@ -16,24 +20,36 @@ import { users as sqliteUsers } from '../sqlite/tables.ts';
 const pg = pgd.mock();
 const sqlite = sqlited.mock();
 const mysql = mysqld.mock();
+const cockroach = cockroachd.mock();
 
 const pgvUsers = pgView('users_view').as((qb) => qb.select().from(pgUsers));
+const cockroachvUsers = cockroachView('users_view').as((qb) => qb.select().from(cockroachUsers));
 const sqlitevUsers = sqliteView('users_view').as((qb) => qb.select().from(sqliteUsers));
 const mysqlvUsers = mysqlView('users_view').as((qb) => qb.select().from(mysqlUsers));
 
 const pgAlias = pgAliasFn(pgUsers, 'usersAlias');
+const cockroachAlias = cockroachAliasFn(cockroachUsers, 'usersAlias');
 const sqliteAlias = sqliteAliasFn(sqliteUsers, 'usersAlias');
 const mysqlAlias = mysqlAliasFn(mysqlUsers, 'usersAlias');
 
 const pgvAlias = pgAliasFn(pgvUsers, 'usersvAlias');
+const cockroachvAlias = cockroachAliasFn(cockroachvUsers, 'usersvAlias');
 const sqlitevAlias = sqliteAliasFn(sqlitevUsers, 'usersvAlias');
 const mysqlvAlias = mysqlAliasFn(mysqlvUsers, 'usersvAlias');
 
 const pgRes = await pg.select().from(pgUsers).leftJoin(pgAlias, eq(pgAlias.id, pgUsers.id));
+const cockroachRes = await cockroach.select().from(cockroachUsers).leftJoin(
+	cockroachAlias,
+	eq(pgAlias.id, pgUsers.id),
+);
 const sqliteRes = await sqlite.select().from(sqliteUsers).leftJoin(sqliteAlias, eq(sqliteAlias.id, sqliteUsers.id));
 const mysqlRes = await mysql.select().from(mysqlUsers).leftJoin(mysqlAlias, eq(mysqlAlias.id, mysqlUsers.id));
 
 const pgvRes = await pg.select().from(pgUsers).leftJoin(pgvAlias, eq(pgvAlias.id, pgUsers.id));
+const cockroachvRes = await cockroach.select().from(cockroachUsers).leftJoin(
+	cockroachvAlias,
+	eq(cockroachvAlias.id, cockroachUsers.id),
+);
 const sqlitevRes = await sqlite.select().from(sqliteUsers).leftJoin(sqlitevAlias, eq(sqlitevAlias.id, sqliteUsers.id));
 const mysqlvRes = await mysql.select().from(mysqlUsers).leftJoin(mysqlvAlias, eq(mysqlvAlias.id, mysqlUsers.id));
 
@@ -72,6 +88,41 @@ Expect<
 	}[]>
 >;
 
+Expect<
+	Equal<typeof cockroachRes, {
+		users_table: {
+			id: number;
+			uuid: string;
+			homeCity: number;
+			currentCity: number | null;
+			int4Nullable: number | null;
+			int4NotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+			arrayCol: string[];
+		};
+		usersAlias: {
+			id: number;
+			uuid: string;
+			homeCity: number;
+			currentCity: number | null;
+			int4Nullable: number | null;
+			int4NotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+			arrayCol: string[];
+		} | null;
+	}[]>
+>;
+
 Expect<
 	Equal<typeof sqliteRes, {
 		users_table: {
@@ -169,6 +220,41 @@ Expect<
 	}[]>
 >;
 
+Expect<
+	Equal<typeof cockroachvRes, {
+		users_table: {
+			id: number;
+			uuid: string;
+			homeCity: number;
+			currentCity: number | null;
+			int4Nullable: number | null;
+			int4NotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+			arrayCol: string[];
+		};
+		usersvAlias: {
+			id: number;
+			uuid: string;
+			homeCity: number;
+			currentCity: number | null;
+			int4Nullable: number | null;
+			int4NotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+			arrayCol: string[];
+		} | null;
+	}[]>
+>;
+
 Expect<
 	Equal<typeof sqlitevRes, {
 		users_table: {
diff --git a/drizzle-orm/type-tests/geldb/1-to-1-fk.ts b/drizzle-orm/type-tests/geldb/1-to-1-fk.ts
deleted file mode 100644
index 1ba6d7f361..0000000000
--- a/drizzle-orm/type-tests/geldb/1-to-1-fk.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { type GelColumn, integer } from '~/gel-core/columns/index.ts';
-import { gelTable } from '~/gel-core/table.ts';
-
-{
-	const test1 = gelTable('test1_table', {
-		id: integer('id').primaryKey(),
-		test2Id: integer('test2_id').references(() => test2.id),
-	});
-
-	const test1Id = integer('test1_id').references(() => test1.id);
-
-	const test2 = gelTable('test2_table', {
-		id: integer('id').primaryKey(),
-		test1Id,
-	});
-}
-
-{
-	const test1 = gelTable('test1_table', {
-		id: integer('id').primaryKey(),
-		test2Id: integer('test2_id').references((): GelColumn => test2.id),
-	});
-
-	const test2 = gelTable('test2_table', {
-		id: integer('id').primaryKey(),
-		test1Id: integer('test1_id').references(() => test1.id),
-	});
-}
diff --git a/drizzle-orm/type-tests/geldb/array.ts b/drizzle-orm/type-tests/geldb/array.ts
deleted file mode 100644
index bdb5969a6f..0000000000
--- a/drizzle-orm/type-tests/geldb/array.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import type { Column } from '~/column.ts';
-import { gelTable, integer } from '~/gel-core/index.ts';
-
-{
-	const table = gelTable('table', {
-		a: integer('a').array().notNull(),
-	});
-	Expect<
-		Equal<
-			Column<
-				{
-					name: 'a';
-					tableName: 'table';
-					dataType: 'number';
-					columnType: 'GelInteger';
-					data: number;
-					driverParam: number;
-					notNull: false;
-					hasDefault: false;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{}
-			>,
-			typeof table['a']['_']['baseColumn']
-		>
-	>;
-}
diff --git a/drizzle-orm/type-tests/geldb/count.ts b/drizzle-orm/type-tests/geldb/count.ts
deleted file mode 100644
index 0dd535be4f..0000000000
--- a/drizzle-orm/type-tests/geldb/count.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { Expect } from 'type-tests/utils.ts';
-import { gelTable, integer, text } from '~/gel-core/index.ts';
-import { and, gt, ne } from '~/sql/expressions/index.ts';
-import type { Equal } from '~/utils.ts';
-import { db } from './db.ts';
-
-const names = gelTable('names', {
-	id: integer('id').primaryKey(),
-	name: text('name'),
-	authorId: integer('author_id'),
-});
-
-const separate = await db.$count(names);
-
-const separateFilters = await db.$count(names, and(gt(names.id, 1), ne(names.name, 'forbidden')));
-
-const embedded = await db
-	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
-		count1: db.$count(names).as('count1'),
-	})
-	.from(names);
-
-const embeddedFilters = await db
-	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
-		count1: db.$count(names, and(gt(names.id, 1), ne(names.name, 'forbidden'))).as('count1'),
-	})
-	.from(names);
-
-Expect<Equal<number, typeof separate>>;
-
-Expect<Equal<number, typeof separateFilters>>;
-
-Expect<
-	Equal<
-		{
-			id: number;
-			name: string | null;
-			authorId: number | null;
-			count1: number;
-		}[],
-		typeof embedded
-	>
->;
-
-Expect<
-	Equal<
-		{
-			id: number;
-			name: string | null;
-			authorId: number | null;
-			count1: number;
-		}[],
-		typeof embeddedFilters
-	>
->;
diff --git a/drizzle-orm/type-tests/geldb/db-rel.ts b/drizzle-orm/type-tests/geldb/db-rel.ts
deleted file mode 100644
index 3ff0e36ad6..0000000000
--- a/drizzle-orm/type-tests/geldb/db-rel.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import * as gel from 'gel';
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import { drizzle } from '~/gel/index.ts';
-import { sql } from '~/sql/sql.ts';
-import * as schema from './tables-rel.ts';
-
-const db = drizzle(gel.createClient(), { schema });
-
-{
-	const result = await db.query.users.findMany({
-		where: (users, { sql }) => sql`char_length(${users.name} > 1)`,
-		limit: sql.placeholder('l'),
-		orderBy: (users, { asc, desc }) => [asc(users.name), desc(users.id)],
-		with: {
-			posts: {
-				where: (posts, { sql }) => sql`char_length(${posts.title} > 1)`,
-				limit: sql.placeholder('l'),
-				columns: {
-					id: false,
-					title: undefined,
-				},
-				with: {
-					author: true,
-					comments: {
-						where: (comments, { sql }) => sql`char_length(${comments.text} > 1)`,
-						limit: sql.placeholder('l'),
-						columns: {
-							text: true,
-						},
-						with: {
-							author: {
-								columns: {
-									id: undefined,
-								},
-								with: {
-									city: {
-										with: {
-											users: true,
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<{
-			id: number;
-			name: string;
-			cityId: number;
-			homeCityId: number | null;
-			createdAt: Date;
-			posts: {
-				title: string;
-				authorId: number | null;
-				comments: {
-					text: string;
-					author: {
-						city: {
-							id: number;
-							name: string;
-							users: {
-								id: number;
-								name: string;
-								cityId: number;
-								homeCityId: number | null;
-								createdAt: Date;
-							}[];
-						};
-					} | null;
-				}[];
-				author: {
-					id: number;
-					name: string;
-					cityId: number;
-					homeCityId: number | null;
-					createdAt: Date;
-				} | null;
-			}[];
-		}[], typeof result>
-	>;
-}
-
-{
-	const result = await db.query.users.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					authorId: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				name: string;
-				posts: {
-					authorId: number | null;
-					lower: string;
-				}[];
-			}[],
-			typeof result
-		>
-	>;
-}
diff --git a/drizzle-orm/type-tests/geldb/db.ts b/drizzle-orm/type-tests/geldb/db.ts
deleted file mode 100644
index 8547d351e1..0000000000
--- a/drizzle-orm/type-tests/geldb/db.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import * as gel from 'gel';
-import { drizzle } from '~/gel/index.ts';
-
-export const db = drizzle(gel.createClient());
diff --git a/drizzle-orm/type-tests/geldb/delete.ts b/drizzle-orm/type-tests/geldb/delete.ts
deleted file mode 100644
index 3b712a5597..0000000000
--- a/drizzle-orm/type-tests/geldb/delete.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-import type { GelDelete } from '~/gel-core/index.ts';
-import { eq } from '~/sql/expressions/index.ts';
-import { sql } from '~/sql/sql.ts';
-import { db } from './db.ts';
-import { users } from './tables.ts';
-
-const deleteAll = await db.delete(users);
-Expect<Equal<unknown, typeof deleteAll>>;
-
-const deleteAllStmt = db.delete(users).prepare('deleteAllStmt');
-const deleteAllPrepared = await deleteAllStmt.execute();
-Expect<Equal<unknown, typeof deleteAllPrepared>>;
-
-const deleteWhere = await db.delete(users).where(eq(users.id, 1));
-Expect<Equal<unknown, typeof deleteWhere>>;
-
-const deleteWhereStmt = db.delete(users).where(eq(users.id, 1)).prepare('deleteWhereStmt');
-const deleteWherePrepared = await deleteWhereStmt.execute();
-Expect<Equal<unknown, typeof deleteWherePrepared>>;
-
-const deleteReturningAll = await db.delete(users).returning();
-Expect<Equal<(typeof users.$inferSelect)[], typeof deleteReturningAll>>;
-
-const deleteReturningAllStmt = db.delete(users).returning().prepare('deleteReturningAllStmt');
-const deleteReturningAllPrepared = await deleteReturningAllStmt.execute();
-Expect<Equal<(typeof users.$inferSelect)[], typeof deleteReturningAllPrepared>>;
-
-const deleteReturningPartial = await db.delete(users).returning({
-	myId: users.id,
-	myHomeCity: users.homeCity,
-});
-Expect<Equal<{ myId: number; myHomeCity: number }[], typeof deleteReturningPartial>>;
-
-const deleteReturningPartialStmt = db
-	.delete(users)
-	.returning({
-		myId: users.id,
-		myHomeCity: users.homeCity,
-	})
-	.prepare('deleteReturningPartialStmt');
-const deleteReturningPartialPrepared = await deleteReturningPartialStmt.execute();
-Expect<Equal<{ myId: number; myHomeCity: number }[], typeof deleteReturningPartialPrepared>>;
-
-{
-	function dynamic<T extends GelDelete>(qb: T) {
-		return qb.where(sql``).returning();
-	}
-
-	const qbBase = db.delete(users).$dynamic();
-	const qb = dynamic(qbBase);
-	const result = await qb;
-	Expect<Equal<(typeof users.$inferSelect)[], typeof result>>;
-}
-
-{
-	function withReturning<T extends GelDelete>(qb: T) {
-		return qb.returning();
-	}
-
-	const qbBase = db.delete(users).$dynamic();
-	const qb = withReturning(qbBase);
-	const result = await qb;
-	Expect<Equal<(typeof users.$inferSelect)[], typeof result>>;
-}
-
-{
-	db.delete(users)
-		.where(sql``)
-		// @ts-expect-error method was already called
-		.where(sql``);
-
-	db.delete(users)
-		.returning()
-		// @ts-expect-error method was already called
-		.returning();
-}
diff --git a/drizzle-orm/type-tests/geldb/insert.ts b/drizzle-orm/type-tests/geldb/insert.ts
deleted file mode 100644
index 6fd14a86a1..0000000000
--- a/drizzle-orm/type-tests/geldb/insert.ts
+++ /dev/null
@@ -1,338 +0,0 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-import { boolean, gelTable, integer, QueryBuilder, text } from '~/gel-core/index.ts';
-import type { GelInsert } from '~/gel-core/query-builders/insert.ts';
-import { sql } from '~/sql/sql.ts';
-import { db } from './db.ts';
-import { identityColumnsTable, users } from './tables.ts';
-
-const insert = await db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		createdAt: new Date(),
-		uuid: '',
-		age1: 1,
-		arrayCol: [''],
-	});
-Expect<Equal<unknown, typeof insert>>;
-
-const insertStmt = db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		createdAt: new Date(),
-		uuid: '',
-		age1: 1,
-		arrayCol: [''],
-	})
-	.prepare('insertStmt');
-const insertPrepared = await insertStmt.execute();
-Expect<Equal<unknown, typeof insertPrepared>>;
-
-const insertSql = await db.insert(users).values({
-	id: 1,
-	homeCity: sql`123`,
-	class: 'A',
-	age1: 1,
-	createdAt: new Date(),
-	uuid: '',
-	arrayCol: [''],
-});
-Expect<Equal<unknown, typeof insertSql>>;
-
-const insertSqlStmt = db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: sql`123`,
-		class: 'A',
-		age1: 1,
-		createdAt: new Date(),
-		uuid: '',
-		arrayCol: [''],
-	})
-	.prepare('insertSqlStmt');
-const insertSqlPrepared = await insertSqlStmt.execute();
-Expect<Equal<unknown, typeof insertSqlPrepared>>;
-
-const insertReturning = await db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		age1: 1,
-		createdAt: new Date(),
-		uuid: '',
-		arrayCol: [''],
-	})
-	.returning();
-Expect<Equal<typeof users.$inferSelect[], typeof insertReturning>>;
-
-const insertReturningStmt = db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		createdAt: new Date(),
-		uuid: '',
-		age1: 1,
-		arrayCol: [''],
-	})
-	.returning()
-	.prepare('insertReturningStmt');
-const insertReturningPrepared = await insertReturningStmt.execute();
-Expect<Equal<typeof users.$inferSelect[], typeof insertReturningPrepared>>;
-
-const insertReturningPartial = await db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		createdAt: new Date(),
-		uuid: '',
-		class: 'A',
-		age1: 1,
-		arrayCol: [''],
-	})
-	.returning({
-		id: users.id,
-		homeCity: users.homeCity,
-		mySubclass: users.subClass,
-	});
-Expect<
-	Equal<{
-		id: number;
-		homeCity: number;
-		mySubclass: string | null;
-	}[], typeof insertReturningPartial>
->;
-
-const insertReturningPartialStmt = db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		createdAt: new Date(),
-		uuid: '',
-		age1: 1,
-		arrayCol: [''],
-	})
-	.returning({
-		id: users.id,
-		homeCity: users.homeCity,
-		mySubclass: users.subClass,
-	})
-	.prepare('insertReturningPartialStmt');
-const insertReturningPartialPrepared = await insertReturningPartialStmt.execute();
-Expect<
-	Equal<{
-		id: number;
-		homeCity: number;
-		mySubclass: string | null;
-	}[], typeof insertReturningPartialPrepared>
->;
-
-const insertReturningSql = await db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		age1: sql`2 + 2`,
-		createdAt: new Date(),
-		uuid: '',
-		arrayCol: [''],
-	})
-	.returning({
-		id: users.id,
-		homeCity: users.homeCity,
-		subclassLower: sql`lower(${users.subClass})`,
-		classLower: sql<string>`lower(${users.class})`,
-	});
-Expect<
-	Equal<{
-		id: number;
-		homeCity: number;
-		subclassLower: unknown;
-		classLower: string;
-	}[], typeof insertReturningSql>
->;
-
-const insertReturningSqlStmt = db
-	.insert(users)
-	.values({
-		id: 1,
-		homeCity: 1,
-		class: 'A',
-		createdAt: new Date(),
-		uuid: '',
-		age1: sql`2 + 2`,
-		arrayCol: [''],
-	})
-	.returning({
-		id: users.id,
-		homeCity: users.homeCity,
-		subclassLower: sql`lower(${users.subClass})`,
-		classLower: sql<string>`lower(${users.class})`,
-	})
-	.prepare('insertReturningSqlStmt');
-const insertReturningSqlPrepared = await insertReturningSqlStmt.execute();
-Expect<
-	Equal<{
-		id: number;
-		homeCity: number;
-		subclassLower: unknown;
-		classLower: string;
-	}[], typeof insertReturningSqlPrepared>
->;
-
-{
-	function dynamic<T extends GelInsert>(qb: T) {
-		return qb.returning();
-	}
-
-	const qbBase = db.insert(users).values({
-		id: 1,
-		age1: 0,
-		class: 'A',
-		homeCity: 0,
-		arrayCol: [],
-		createdAt: new Date(),
-		uuid: '',
-	}).$dynamic();
-	const qb = dynamic(qbBase);
-	const result = await qb;
-	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
-}
-
-{
-	function withReturning<T extends GelInsert>(qb: T) {
-		return qb.returning();
-	}
-
-	const qbBase = db.insert(users).values({
-		id: 1,
-		age1: 0,
-		class: 'A',
-		homeCity: 0,
-		arrayCol: [],
-		createdAt: new Date(),
-		uuid: '',
-	}).$dynamic();
-	const qb = withReturning(qbBase);
-	const result = await qb;
-	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
-}
-
-{
-	db
-		.insert(users)
-		.values({ id: 1, age1: 0, class: 'A', homeCity: 0, arrayCol: [], createdAt: new Date(), uuid: '' })
-		.returning()
-		// @ts-expect-error method was already called
-		.returning();
-}
-
-{
-	const users1 = gelTable('users1', {
-		id: integer('id').primaryKey(),
-		name: text('name').notNull(),
-		admin: boolean('admin').notNull().default(false),
-	});
-	const users2 = gelTable('users2', {
-		id: integer('id').primaryKey(),
-		firstName: text('first_name').notNull(),
-		lastName: text('last_name').notNull(),
-		admin: boolean('admin').notNull().default(false),
-		phoneNumber: text('phone_number'),
-	});
-
-	const qb = new QueryBuilder();
-
-	db.insert(users1).select(sql`select * from users1`);
-	db.insert(users1).select(() => sql`select * from users1`);
-
-	db
-		.insert(users1)
-		.select(
-			qb.select({
-				id: users2.id,
-				name: users2.firstName,
-				admin: users2.admin,
-			}).from(users2),
-		);
-
-	db
-		.insert(users1)
-		.select(
-			qb.select({
-				id: users2.id,
-				name: users2.firstName,
-				admin: users2.admin,
-			}).from(users2).where(sql``),
-		);
-
-	db
-		.insert(users2)
-		.select(
-			qb.select({
-				id: users2.id,
-				firstName: users2.firstName,
-				lastName: users2.lastName,
-				admin: users2.admin,
-			}).from(users2),
-		);
-
-	db
-		.insert(users1)
-		.select(
-			qb.select({
-				id: users2.id,
-				name: sql`${users2.firstName} || ' ' || ${users2.lastName}`.as('name'),
-				admin: users2.admin,
-			}).from(users2),
-		);
-
-	db
-		.insert(users1)
-		.select(
-			// @ts-expect-error name is undefined
-			qb.select({ admin: users1.admin }).from(users1),
-		);
-
-	db.insert(users1).select(db.select().from(users1));
-	db.insert(users1).select(() => db.select().from(users1));
-	db.insert(users1).select((qb) => qb.select().from(users1));
-	// @ts-expect-error tables have different keys
-	db.insert(users1).select(db.select().from(users2));
-	// @ts-expect-error tables have different keys
-	db.insert(users1).select(() => db.select().from(users2));
-}
-
-{
-	db.insert(identityColumnsTable).values([
-		{ byDefaultAsIdentity: 4, name: 'fdf' },
-	]);
-
-	// @ts-expect-error
-	db.insert(identityColumnsTable).values([
-		{ alwaysAsIdentity: 2 },
-	]);
-
-	db.insert(identityColumnsTable).overridingSystemValue().values([
-		{ alwaysAsIdentity: 2 },
-	]);
-
-	// @ts-expect-error
-	db.insert(identityColumnsTable).values([
-		{ generatedCol: 2 },
-	]);
-}
diff --git a/drizzle-orm/type-tests/geldb/no-strict-null-checks/test.ts b/drizzle-orm/type-tests/geldb/no-strict-null-checks/test.ts
deleted file mode 100644
index 8300580552..0000000000
--- a/drizzle-orm/type-tests/geldb/no-strict-null-checks/test.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { drizzle } from '~/gel';
-import { gelTable, integer, text } from '~/gel-core';
-
-export const test = gelTable(
-	'test',
-	{
-		id: text('id')
-			.primaryKey()
-			.generatedAlwaysAs('genstr'),
-		intId: integer('int_id')
-			.primaryKey()
-			.generatedAlwaysAsIdentity(),
-		int2Id: integer('int2_id').generatedByDefaultAsIdentity(),
-		name: text('name').$defaultFn(() => '' as string),
-		title: text('title').notNull(),
-		description: text('description'),
-		dbdef: text('dbdef').default('dbdefval'),
-	},
-);
-
-const db = drizzle.mock();
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		id: '1',
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		intId: 1,
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		int2Id: 1,
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.insert(test).values({
-	// @ts-expect-error
-	id: '1',
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	// @ts-expect-error
-	intId: 1,
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	int2Id: 1,
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-});
-
-db.insert(test).values({
-	title: 'title',
-});
diff --git a/drizzle-orm/type-tests/geldb/no-strict-null-checks/tsconfig.json b/drizzle-orm/type-tests/geldb/no-strict-null-checks/tsconfig.json
deleted file mode 100644
index 6d5a4b7c0c..0000000000
--- a/drizzle-orm/type-tests/geldb/no-strict-null-checks/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"noEmit": true,
-		"strictNullChecks": false,
-		"strictPropertyInitialization": false,
-		"exactOptionalPropertyTypes": false
-	},
-	"include": ["./test.ts"]
-}
diff --git a/drizzle-orm/type-tests/geldb/select.ts b/drizzle-orm/type-tests/geldb/select.ts
deleted file mode 100644
index e18b74c4b5..0000000000
--- a/drizzle-orm/type-tests/geldb/select.ts
+++ /dev/null
@@ -1,1311 +0,0 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-
-import { alias } from '~/gel-core/alias.ts';
-import {
-	boolean,
-	// gelMaterializedView,
-	type GelSelect,
-	type GelSelectQueryBuilder,
-	gelTable,
-	// gelView,
-	integer,
-	QueryBuilder,
-	text,
-} from '~/gel-core/index.ts';
-import {
-	and,
-	arrayContained,
-	arrayContains,
-	arrayOverlaps,
-	between,
-	eq,
-	exists,
-	gt,
-	gte,
-	ilike,
-	inArray,
-	isNotNull,
-	isNull,
-	like,
-	lt,
-	lte,
-	ne,
-	not,
-	notBetween,
-	notExists,
-	notIlike,
-	notInArray,
-	notLike,
-	or,
-} from '~/sql/expressions/index.ts';
-import { type SQL, sql } from '~/sql/sql.ts';
-
-import { db } from './db.ts';
-import { cities, classes, users } from './tables.ts';
-
-const city = alias(cities, 'city');
-const city1 = alias(cities, 'city1');
-
-const leftJoinFull = await db.select().from(users).leftJoin(city, eq(users.id, city.id));
-
-{
-	await db.select().from(users).leftJoin(city, eq(users.id, city.id));
-}
-
-Expect<
-	Equal<
-		{
-			users_table: typeof users.$inferSelect;
-			city: typeof cities.$inferSelect | null;
-		}[],
-		typeof leftJoinFull
-	>
->;
-
-const rightJoinFull = await db.select().from(users).rightJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<
-		{
-			users_table: typeof users.$inferSelect | null;
-			city: typeof city.$inferSelect;
-		}[],
-		typeof rightJoinFull
-	>
->;
-
-const innerJoinFull = await db.select().from(users).innerJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<
-		{
-			users_table: typeof users.$inferSelect;
-			city: typeof city.$inferSelect;
-		}[],
-		typeof innerJoinFull
-	>
->;
-
-const fullJoinFull = await db.select().from(users).fullJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<
-		{
-			users_table: typeof users.$inferSelect | null;
-			city: typeof city.$inferSelect | null;
-		}[],
-		typeof fullJoinFull
-	>
->;
-
-const crossJoinFull = await db.select().from(users).crossJoin(city);
-
-Expect<
-	Equal<
-		{
-			users_table: typeof users.$inferSelect;
-			city: typeof city.$inferSelect;
-		}[],
-		typeof crossJoinFull
-	>
->;
-
-const leftJoinFlat = await db
-	.select({
-		userId: users.id,
-		userText: users.text,
-		cityId: city.id,
-		cityName: city.name,
-	})
-	.from(users)
-	.leftJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<{
-		userId: number;
-		userText: string | null;
-		cityId: number | null;
-		cityName: string | null;
-	}[], typeof leftJoinFlat>
->;
-
-const rightJoinFlat = await db
-	.select({
-		userId: users.id,
-		userText: users.text,
-		cityId: city.id,
-		cityName: city.name,
-	})
-	.from(users)
-	.rightJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<{
-		userId: number | null;
-		userText: string | null;
-		cityId: number;
-		cityName: string;
-	}[], typeof rightJoinFlat>
->;
-
-const innerJoinFlat = await db
-	.select({
-		userId: users.id,
-		userText: users.text,
-		cityId: city.id,
-		cityName: city.name,
-	})
-	.from(users)
-	.innerJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<{
-		userId: number;
-		userText: string | null;
-		cityId: number;
-		cityName: string;
-	}[], typeof innerJoinFlat>
->;
-
-const fullJoinFlat = await db
-	.select({
-		userId: users.id,
-		userText: users.text,
-		cityId: city.id,
-		cityName: city.name,
-	})
-	.from(users)
-	.fullJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<{
-		userId: number | null;
-		userText: string | null;
-		cityId: number | null;
-		cityName: string | null;
-	}[], typeof fullJoinFlat>
->;
-
-const crossJoinFlat = await db
-	.select({
-		userId: users.id,
-		userText: users.text,
-		cityId: city.id,
-		cityName: city.name,
-	})
-	.from(users)
-	.crossJoin(city);
-
-Expect<
-	Equal<{
-		userId: number;
-		userText: string | null;
-		cityId: number;
-		cityName: string;
-	}[], typeof crossJoinFlat>
->;
-
-const leftJoinMixed = await db
-	.select({
-		id: users.id,
-		text: users.text,
-		textUpper: sql<string | null>`upper(${users.text})`,
-		idComplex: sql<string | null>`${users.id}::text || ${city.id}::text`,
-		city: {
-			id: city.id,
-			name: city.name,
-		},
-	})
-	.from(users)
-	.leftJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<
-		{
-			id: number;
-			text: string | null;
-			textUpper: string | null;
-			idComplex: string | null;
-			city: {
-				id: number;
-				name: string;
-			} | null;
-		}[],
-		typeof leftJoinMixed
-	>
->;
-
-const leftJoinMixed2 = await db
-	.select({
-		id: users.id,
-		text: users.text,
-		foo: {
-			bar: users.uuid,
-			baz: cities.id,
-		},
-	})
-	.from(users)
-	.leftJoin(cities, eq(users.id, cities.id));
-
-Expect<
-	Equal<
-		{
-			id: number;
-			text: string | null;
-			foo: {
-				bar: string;
-				baz: number | null;
-			};
-		}[],
-		typeof leftJoinMixed2
-	>
->;
-
-const join1 = await db
-	.select({
-		user: {
-			id: users.id,
-			text: users.text,
-		},
-		city: {
-			id: city.id,
-			name: city.name,
-			nameUpper: sql<string>`upper(${city.name})`,
-		},
-	})
-	.from(users)
-	.leftJoin(city, eq(users.id, city.id));
-
-Expect<
-	Equal<{
-		user: {
-			id: number;
-			text: string | null;
-		};
-		city: {
-			id: number;
-			name: string;
-			nameUpper: string;
-		} | null;
-	}[], typeof join1>
->;
-
-const join = await db
-	.select({
-		users,
-		cities,
-		city,
-		city1: {
-			id: city1.id,
-		},
-	})
-	.from(users)
-	.leftJoin(cities, eq(users.id, cities.id))
-	.rightJoin(city, eq(city.id, users.id))
-	.rightJoin(city1, eq(city1.id, users.id));
-
-Expect<
-	Equal<
-		{
-			users: {
-				id: number;
-				uuid: string;
-				homeCity: number;
-				currentCity: number | null;
-				class: string;
-				subClass: string | null;
-				text: string | null;
-				age1: number;
-				createdAt: Date;
-				arrayCol: string[];
-			} | null;
-			cities: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			city: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			city1: {
-				id: number;
-			};
-		}[],
-		typeof join
-	>
->;
-
-const join2 = await db
-	.select({
-		user: {
-			id: users.id,
-		},
-		city: {
-			id: cities.id,
-		},
-	})
-	.from(users)
-	.fullJoin(cities, eq(users.id, cities.id));
-
-Expect<
-	Equal<
-		{
-			user: {
-				id: number;
-			} | null;
-			city: {
-				id: number;
-			} | null;
-		}[],
-		typeof join2
-	>
->;
-
-const join3 = await db
-	.select({
-		user: {
-			id: users.id,
-		},
-		city: {
-			id: cities.id,
-		},
-		class: {
-			id: classes.id,
-		},
-	})
-	.from(users)
-	.fullJoin(cities, eq(users.id, cities.id))
-	.rightJoin(classes, eq(users.id, classes.id));
-
-Expect<
-	Equal<
-		{
-			user: {
-				id: number;
-			} | null;
-			city: {
-				id: number;
-			} | null;
-			class: {
-				id: number;
-			};
-		}[],
-		typeof join3
-	>
->;
-
-db.select()
-	.from(users)
-	.where(exists(db.select().from(cities).where(eq(users.homeCity, cities.id))));
-
-function mapFunkyFuncResult(valueFromDriver: unknown) {
-	return {
-		foo: (valueFromDriver as Record<string, any>)['foo'],
-	};
-}
-
-const age = 1;
-
-const allOperators = await db
-	.select({
-		col2: sql`5 - ${users.id} + 1`, // unknown
-		col3: sql<number>`${users.id} + 1`, // number
-		col33: sql`${users.id} + 1`.mapWith(users.id), // number
-		col34: sql`${users.id} + 1`.mapWith(mapFunkyFuncResult), // number
-		col4: sql<string | number>`one_or_another(${users.id}, ${users.class})`, // string | number
-		col5: sql`true`, // unknown
-		col6: sql<boolean>`true`, // boolean
-		col7: sql<number>`random()`, // number
-		col8: sql`some_funky_func(${users.id})`.mapWith(mapFunkyFuncResult), // { foo: string }
-		col9: sql`greatest(${users.createdAt}, ${sql.param(new Date(), users.createdAt)})`, // unknown
-		col10: sql<Date | boolean>`date_or_false(${users.createdAt}, ${
-			sql.param(
-				new Date(),
-				users.createdAt,
-			)
-		})`, // Date | boolean
-		col11: sql`${users.age1} + ${age}`, // unknown
-		col12: sql`${users.age1} + ${sql.param(age, users.age1)}`, // unknown
-		col13: sql`lower(${users.class})`, // unknown
-		col14: sql<number>`length(${users.class})`, // number
-		count: sql<number>`count(*)::int`, // number
-	})
-	.from(users)
-	.where(
-		and(
-			eq(users.id, 1),
-			ne(users.id, 1),
-			or(eq(users.id, 1), ne(users.id, 1)),
-			not(eq(users.id, 1)),
-			gt(users.id, 1),
-			gte(users.id, 1),
-			lt(users.id, 1),
-			lte(users.id, 1),
-			inArray(users.id, [1, 2, 3]),
-			inArray(users.id, db.select({ id: users.id }).from(users)),
-			inArray(users.id, sql`select id from ${users}`),
-			notInArray(users.id, [1, 2, 3]),
-			notInArray(users.id, db.select({ id: users.id }).from(users)),
-			notInArray(users.id, sql`select id from ${users}`),
-			isNull(users.subClass),
-			isNotNull(users.id),
-			exists(db.select({ id: users.id }).from(users)),
-			exists(sql`select id from ${users}`),
-			notExists(db.select({ id: users.id }).from(users)),
-			notExists(sql`select id from ${users}`),
-			between(users.id, 1, 2),
-			notBetween(users.id, 1, 2),
-			like(users.id, '%1%'),
-			notLike(users.id, '%1%'),
-			ilike(users.id, '%1%'),
-			notIlike(users.id, '%1%'),
-			arrayContains(users.arrayCol, ['abc']),
-			arrayContains(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
-			arrayContains(users.arrayCol, sql`select array_col from ${users}`),
-			arrayContained(users.arrayCol, ['abc']),
-			arrayContained(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
-			arrayContained(users.arrayCol, sql`select array_col from ${users}`),
-			arrayOverlaps(users.arrayCol, ['abc']),
-			arrayOverlaps(users.arrayCol, db.select({ arrayCol: users.arrayCol }).from(users)),
-			arrayOverlaps(users.arrayCol, sql`select array_col from ${users}`),
-		),
-	);
-
-Expect<
-	Equal<{
-		col2: unknown;
-		col3: number;
-		col33: number;
-		col34: { foo: any };
-		col4: string | number;
-		col5: unknown;
-		col6: boolean;
-		col7: number;
-		col8: {
-			foo: any;
-		};
-		col9: unknown;
-		col10: boolean | Date;
-		col11: unknown;
-		col12: unknown;
-		col13: unknown;
-		col14: number;
-		count: number;
-	}[], typeof allOperators>
->;
-
-const textSelect = await db
-	.select({
-		t: users.text,
-	})
-	.from(users);
-
-Expect<Equal<{ t: string | null }[], typeof textSelect>>;
-
-const homeCity = alias(cities, 'homeCity');
-const c = alias(classes, 'c');
-const otherClass = alias(classes, 'otherClass');
-const anotherClass = alias(classes, 'anotherClass');
-const friend = alias(users, 'friend');
-const currentCity = alias(cities, 'currentCity');
-const subscriber = alias(users, 'subscriber');
-const closestCity = alias(cities, 'closestCity');
-const closestCity2 = alias(cities, 'closestCity2');
-const closestCity3 = alias(cities, 'closestCity3');
-const closestCity4 = alias(cities, 'closestCity4');
-const closestCity5 = alias(cities, 'closestCity5');
-const closestCity6 = alias(cities, 'closestCity6');
-const closestCity7 = alias(cities, 'closestCity7');
-
-const megaJoin = await db
-	.select({
-		user: {
-			id: users.id,
-			maxAge: sql`max(${users.age1})`,
-		},
-		city: {
-			id: cities.id,
-		},
-		homeCity,
-		c,
-		otherClass,
-		anotherClass,
-		friend,
-		currentCity,
-		subscriber,
-		closestCity,
-	})
-	.from(users)
-	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
-	.innerJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
-	.innerJoin(c, eq(c.id, users.class))
-	.innerJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
-	.innerJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
-	.innerJoin(friend, sql`${users.id} = ${friend.id}`)
-	.innerJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
-	.innerJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
-	.innerJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
-	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
-	.limit(1)
-	.offset(1);
-
-Expect<
-	Equal<
-		{
-			user: {
-				id: number;
-				maxAge: unknown;
-			};
-			city: {
-				id: number;
-			};
-			homeCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			};
-			c: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			};
-			otherClass: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			};
-			anotherClass: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			};
-			friend: {
-				id: number;
-				uuid: string;
-				homeCity: number;
-				currentCity: number | null;
-				class: string;
-				subClass: string | null;
-				text: string | null;
-				age1: number;
-				createdAt: Date;
-				arrayCol: string[];
-			};
-			currentCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			};
-			subscriber: {
-				id: number;
-				uuid: string;
-				homeCity: number;
-				currentCity: number | null;
-				class: string;
-				subClass: string | null;
-				text: string | null;
-				age1: number;
-				createdAt: Date;
-				arrayCol: string[];
-			};
-			closestCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			};
-		}[],
-		typeof megaJoin
-	>
->;
-
-const megaLeftJoin = await db
-	.select({
-		user: {
-			id: users.id,
-			maxAge: sql`max(${users.age1})`,
-		},
-		city: {
-			id: cities.id,
-		},
-		homeCity,
-		c,
-		otherClass,
-		anotherClass,
-		friend,
-		currentCity,
-		subscriber,
-		closestCity,
-		closestCity2,
-		closestCity3,
-		closestCity4,
-		closestCity5,
-		closestCity6,
-		closestCity7,
-	})
-	.from(users)
-	.leftJoin(cities, sql`${users.id} = ${cities.id}`)
-	.leftJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
-	.leftJoin(c, eq(c.id, users.class))
-	.leftJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
-	.leftJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
-	.leftJoin(friend, sql`${users.id} = ${friend.id}`)
-	.leftJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
-	.leftJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
-	.leftJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity2, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity3, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity4, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity5, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity6, sql`${users.currentCity} = ${closestCity.id}`)
-	.leftJoin(closestCity7, sql`${users.currentCity} = ${closestCity.id}`)
-	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
-	.limit(1)
-	.offset(1);
-
-Expect<
-	Equal<
-		{
-			user: {
-				id: number;
-				maxAge: unknown;
-			};
-			city: {
-				id: number;
-			} | null;
-			homeCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			c: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			} | null;
-			otherClass: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			} | null;
-			anotherClass: {
-				id: number;
-				class: string | null;
-				subClass: string;
-			} | null;
-			friend: {
-				id: number;
-				uuid: string;
-				homeCity: number;
-				currentCity: number | null;
-
-				class: string;
-				subClass: string | null;
-				text: string | null;
-				age1: number;
-				createdAt: Date;
-
-				arrayCol: string[];
-			} | null;
-			currentCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			subscriber: {
-				id: number;
-				uuid: string;
-				homeCity: number;
-				currentCity: number | null;
-
-				class: string;
-				subClass: string | null;
-				text: string | null;
-				age1: number;
-				createdAt: Date;
-
-				arrayCol: string[];
-			} | null;
-			closestCity: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity2: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity3: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity4: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity5: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity6: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-			closestCity7: {
-				id: number;
-				name: string;
-				population: number | null;
-			} | null;
-		}[],
-		typeof megaLeftJoin
-	>
->;
-
-await db
-	.select({
-		user: {
-			id: users.id,
-			maxAge: sql`max(${users.age1})`,
-		},
-		city: {
-			id: cities.id,
-		},
-		homeCity,
-		c,
-		otherClass,
-		anotherClass,
-		friend,
-		currentCity,
-		subscriber,
-		closestCity,
-		closestCity2,
-		closestCity3,
-		closestCity4,
-		closestCity5,
-		closestCity6,
-		closestCity7,
-	})
-	.from(users)
-	.fullJoin(cities, sql`${users.id} = ${cities.id}`)
-	.fullJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
-	.fullJoin(c, eq(c.id, users.class))
-	.fullJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
-	.fullJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
-	.fullJoin(friend, sql`${users.id} = ${friend.id}`)
-	.fullJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
-	.fullJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
-	.fullJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity2, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity3, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity4, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity5, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity6, sql`${users.currentCity} = ${closestCity.id}`)
-	.fullJoin(closestCity7, sql`${users.currentCity} = ${closestCity.id}`)
-	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
-	.limit(1)
-	.offset(1);
-
-const friends = alias(users, 'friends');
-
-const join4 = await db
-	.select({
-		user: {
-			id: users.id,
-		},
-		city: {
-			id: cities.id,
-		},
-		class: classes,
-		friend: friends,
-	})
-	.from(users)
-	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
-	.innerJoin(classes, sql`${cities.id} = ${classes.id}`)
-	.innerJoin(friends, sql`${friends.id} = ${users.id}`)
-	.where(sql`${users.age1} > 0`);
-
-Expect<
-	Equal<{
-		user: {
-			id: number;
-		};
-		city: {
-			id: number;
-		};
-		class: {
-			id: number;
-			class: string | null;
-			subClass: string;
-		};
-		friend: {
-			id: number;
-			uuid: string;
-			homeCity: number;
-			currentCity: number | null;
-
-			class: string;
-			subClass: string | null;
-			text: string | null;
-			age1: number;
-			createdAt: Date;
-
-			arrayCol: string[];
-		};
-	}[], typeof join4>
->;
-
-{
-	const authenticated = false as boolean;
-
-	const result = await db
-		.select({
-			id: users.id,
-			...(authenticated ? { city: users.homeCity } : {}),
-		})
-		.from(users);
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				city?: number;
-			}[],
-			typeof result
-		>
-	>;
-}
-
-await db
-	.select()
-	.from(users)
-	.for('update');
-
-await db
-	.select()
-	.from(users)
-	.for('no key update', { of: users });
-
-await db
-	.select()
-	.from(users)
-	.for('no key update', { of: users, skipLocked: true });
-
-await db
-	.select()
-	.from(users)
-	.for('share', { of: users, noWait: true });
-
-await db
-	.select()
-	.from(users)
-	// @ts-expect-error - can't use both skipLocked and noWait
-	.for('share', { of: users, noWait: true, skipLocked: true });
-
-await db
-	.select({
-		id: cities.id,
-		name: sql<string>`upper(${cities.name})`.as('name'),
-		usersCount: sql<number>`count(${users.id})`.as('users'),
-	})
-	.from(cities)
-	.leftJoin(users, eq(users.homeCity, cities.id))
-	.where(({ name }) => sql`length(${name}) >= 3`)
-	.groupBy(cities.id)
-	.having(({ usersCount }) => sql`${usersCount} > 0`);
-
-{
-	db
-		.select()
-		.from(users)
-		.where(eq(users.id, 1));
-
-	db
-		.select()
-		.from(users)
-		.where(eq(users.id, 1))
-		// @ts-expect-error - can't use where twice
-		.where(eq(users.id, 1));
-
-	db
-		.select()
-		.from(users)
-		.where(eq(users.id, 1))
-		.limit(10)
-		// @ts-expect-error - can't use where twice
-		.where(eq(users.id, 1));
-}
-
-{
-	function withFriends<T extends GelSelect>(qb: T) {
-		const friends = alias(users, 'friends');
-		const friends2 = alias(users, 'friends2');
-		const friends3 = alias(users, 'friends3');
-		const friends4 = alias(users, 'friends4');
-		const friends5 = alias(users, 'friends5');
-		return qb
-			.leftJoin(friends, sql`true`)
-			.leftJoin(friends2, sql`true`)
-			.leftJoin(friends3, sql`true`)
-			.leftJoin(friends4, sql`true`)
-			.leftJoin(friends5, sql`true`);
-	}
-
-	const qb = db.select().from(users).$dynamic();
-	const result = await withFriends(qb);
-	Expect<
-		Equal<typeof result, {
-			users_table: typeof users.$inferSelect;
-			friends: typeof users.$inferSelect | null;
-			friends2: typeof users.$inferSelect | null;
-			friends3: typeof users.$inferSelect | null;
-			friends4: typeof users.$inferSelect | null;
-			friends5: typeof users.$inferSelect | null;
-		}[]>
-	>;
-}
-
-{
-	function withFriends<T extends GelSelectQueryBuilder>(qb: T) {
-		const friends = alias(users, 'friends');
-		const friends2 = alias(users, 'friends2');
-		const friends3 = alias(users, 'friends3');
-		const friends4 = alias(users, 'friends4');
-		const friends5 = alias(users, 'friends5');
-		return qb
-			.leftJoin(friends, sql`true`)
-			.leftJoin(friends2, sql`true`)
-			.leftJoin(friends3, sql`true`)
-			.leftJoin(friends4, sql`true`)
-			.leftJoin(friends5, sql`true`);
-	}
-
-	const qb = db.select().from(users).$dynamic();
-	const result = await withFriends(qb);
-	Expect<
-		Equal<typeof result, {
-			users_table: typeof users.$inferSelect;
-			friends: typeof users.$inferSelect | null;
-			friends2: typeof users.$inferSelect | null;
-			friends3: typeof users.$inferSelect | null;
-			friends4: typeof users.$inferSelect | null;
-			friends5: typeof users.$inferSelect | null;
-		}[]>
-	>;
-}
-
-{
-	function dynamic<T extends GelSelect>(qb: T) {
-		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
-	}
-
-	const qb = db.select().from(users).$dynamic();
-	const result = await dynamic(qb);
-	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
-}
-
-{
-	// TODO: add to docs
-	function dynamic<T extends GelSelectQueryBuilder>(qb: T) {
-		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
-	}
-
-	const query = new QueryBuilder().select().from(users).$dynamic();
-	dynamic(query);
-}
-
-{
-	// TODO: add to docs
-	function paginated<T extends GelSelect>(qb: T, page: number) {
-		return qb.limit(10).offset((page - 1) * 10);
-	}
-
-	const qb = db.select().from(users).$dynamic();
-	const result = await paginated(qb, 1);
-
-	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
-}
-
-{
-	db
-		.select()
-		.from(users)
-		.where(sql``)
-		.limit(10)
-		// @ts-expect-error method was already called
-		.where(sql``);
-
-	db
-		.select()
-		.from(users)
-		.having(sql``)
-		.limit(10)
-		// @ts-expect-error method was already called
-		.having(sql``);
-
-	db
-		.select()
-		.from(users)
-		.groupBy(sql``)
-		.limit(10)
-		// @ts-expect-error method was already called
-		.groupBy(sql``);
-
-	db
-		.select()
-		.from(users)
-		.orderBy(sql``)
-		.limit(10)
-		// @ts-expect-error method was already called
-		.orderBy(sql``);
-
-	db
-		.select()
-		.from(users)
-		.limit(10)
-		.where(sql``)
-		// @ts-expect-error method was already called
-		.limit(10);
-
-	db
-		.select()
-		.from(users)
-		.offset(10)
-		.limit(10)
-		// @ts-expect-error method was already called
-		.offset(10);
-
-	db
-		.select()
-		.from(users)
-		.for('update')
-		.limit(10)
-		// @ts-expect-error method was already called
-		.for('update');
-}
-
-{
-	const users = gelTable('users', {
-		developer: boolean('developer'),
-		application: text('application'),
-	});
-
-	const startIt = (whereCallback: (condition: SQL) => SQL | undefined = (c) => c) => {
-		return db.select().from(users).where(whereCallback(eq(users.developer, true)));
-	};
-
-	startIt((c) => and(c, eq(users.application, 'approved')));
-}
-
-{
-	const school = gelTable('school', {
-		faculty: integer('faculty'),
-		studentid: integer('studentid'),
-	});
-
-	const student = gelTable('student', {
-		id: integer('id'),
-		email: text('email'),
-	});
-
-	await db
-		.select()
-		.from(school)
-		.where(
-			and(
-				eq(school.faculty, 2),
-				eq(
-					school.studentid,
-					db.select({ id: student.id }).from(student).where(eq(student.email, 'foo@demo.com')),
-				),
-			),
-		);
-}
-
-{
-	const table1 = gelTable('table1', {
-		id: integer().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const table2 = gelTable('table2', {
-		id: integer().primaryKey(),
-		age: integer().notNull(),
-		table1Id: integer().references(() => table1.id).notNull(),
-	});
-
-	const leftLateralRawRes = await db.select({
-		table1,
-		sqId: sql<number | null>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
-	}).from(table1).leftJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`, sql`true`);
-
-	Expect<
-		Equal<typeof leftLateralRawRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sqId: number | null;
-		}[]>
-	>;
-
-	const leftLateralSubRes = await db.select().from(table1).leftJoinLateral(
-		db.select().from(table2).as('sub'),
-		sql`true`,
-	);
-
-	Expect<
-		Equal<typeof leftLateralSubRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sub: {
-				id: number;
-				age: number;
-				table1Id: number;
-			} | null;
-		}[]>
-	>;
-
-	const sqLeftLateral = db.select().from(table2).as('sub');
-
-	const leftLateralSubSelectionRes = await db.select(
-		{
-			id: table1.id,
-			sId: sqLeftLateral.id,
-		},
-	).from(table1).leftJoinLateral(
-		sqLeftLateral,
-		sql`true`,
-	);
-
-	Expect<
-		Equal<typeof leftLateralSubSelectionRes, {
-			id: number;
-			sId: number | null;
-		}[]>
-	>;
-
-	await db.select().from(table1)
-		// @ts-expect-error
-		.leftJoinLateral(table2, sql`true`);
-
-	const innerLateralRawRes = await db.select({
-		table1,
-		sqId: sql<number>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
-	}).from(table1).innerJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`, sql`true`);
-
-	Expect<
-		Equal<typeof innerLateralRawRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sqId: number;
-		}[]>
-	>;
-
-	const innerLateralSubRes = await db.select().from(table1).innerJoinLateral(
-		db.select().from(table2).as('sub'),
-		sql`true`,
-	);
-
-	Expect<
-		Equal<typeof innerLateralSubRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sub: {
-				id: number;
-				age: number;
-				table1Id: number;
-			};
-		}[]>
-	>;
-
-	const sqInnerLateral = db.select().from(table2).as('sub');
-
-	const innerLateralSubSelectionRes = await db.select(
-		{
-			id: table1.id,
-			sId: sqLeftLateral.id,
-		},
-	).from(table1).innerJoinLateral(
-		sqInnerLateral,
-		sql`true`,
-	);
-
-	Expect<
-		Equal<typeof innerLateralSubSelectionRes, {
-			id: number;
-			sId: number;
-		}[]>
-	>;
-
-	await db.select().from(table1)
-		// @ts-expect-error
-		.innerJoinLateral(table2, sql`true`);
-
-	const crossLateralRawRes = await db.select({
-		table1,
-		sqId: sql<number>`${sql.identifier('t2')}.${sql.identifier('id')}`.as('sqId'),
-	}).from(table1).crossJoinLateral(sql`(SELECT * FROM ${table2}) as ${sql.identifier('t2')}`);
-
-	Expect<
-		Equal<typeof crossLateralRawRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sqId: number;
-		}[]>
-	>;
-
-	const crossLateralSubRes = await db.select().from(table1).crossJoinLateral(
-		db.select().from(table2).as('sub'),
-	);
-
-	Expect<
-		Equal<typeof crossLateralSubRes, {
-			table1: {
-				id: number;
-				name: string;
-			};
-			sub: {
-				id: number;
-				age: number;
-				table1Id: number;
-			};
-		}[]>
-	>;
-
-	const sqCrossLateral = db.select().from(table2).as('sub');
-
-	const crossLateralSubSelectionRes = await db.select(
-		{
-			id: table1.id,
-			sId: sqCrossLateral.id,
-		},
-	).from(table1).crossJoinLateral(
-		sqInnerLateral,
-	);
-
-	Expect<
-		Equal<typeof crossLateralSubSelectionRes, {
-			id: number;
-			sId: number;
-		}[]>
-	>;
-
-	await db.select().from(table1)
-		// @ts-expect-error
-		.crossJoinLateral(table2);
-}
diff --git a/drizzle-orm/type-tests/geldb/set-operators.ts b/drizzle-orm/type-tests/geldb/set-operators.ts
deleted file mode 100644
index dfe257d757..0000000000
--- a/drizzle-orm/type-tests/geldb/set-operators.ts
+++ /dev/null
@@ -1,276 +0,0 @@
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import { except, exceptAll, type GelSetOperator, intersect, intersectAll, union, unionAll } from '~/gel-core/index.ts';
-import { eq } from '~/sql/expressions/index.ts';
-import { desc, sql } from '~/sql/index.ts';
-import { db } from './db.ts';
-import { cities, classes, users } from './tables.ts';
-
-const except2Test = await except(
-	db.select({
-		userId: users.id,
-	})
-		.from(users),
-	db.select({
-		userId: users.id,
-	}).from(users),
-);
-
-Expect<Equal<{ userId: number }[], typeof except2Test>>;
-
-const exceptAll2Test = await exceptAll(
-	db.select({
-		id: users.id,
-		age1: users.age1,
-	})
-		.from(users).where(sql``),
-	db.select({
-		id: users.id,
-		age1: users.age1,
-	}).from(users),
-);
-
-Expect<Equal<{ id: number; age1: number }[], typeof exceptAll2Test>>;
-
-const unionTest = await db
-	.select({ id: users.id })
-	.from(users)
-	.union(
-		db
-			.select({ id: users.id })
-			.from(users),
-	);
-
-Expect<Equal<{ id: number }[], typeof unionTest>>;
-
-const unionAllTest = await db
-	.select({ id: users.id, age: users.age1 })
-	.from(users)
-	.unionAll(
-		db.select({ id: users.id, age: users.age1 })
-			.from(users)
-			.leftJoin(cities, eq(users.id, cities.id)),
-	);
-
-Expect<Equal<{ id: number; age: number }[], typeof unionAllTest>>;
-
-const intersectTest = await db
-	.select({ id: users.id, homeCity: users.homeCity })
-	.from(users)
-	.intersect(({ intersect }) =>
-		intersect(
-			db
-				.select({ id: users.id, homeCity: users.homeCity })
-				.from(users),
-			db
-				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
-				.from(users),
-		)
-	);
-
-Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
-
-const intersectAllTest = await db
-	.select({ id: users.id, homeCity: users.class })
-	.from(users)
-	.intersect(
-		db
-			.select({ id: users.id, homeCity: users.class })
-			.from(users)
-			.leftJoin(cities, eq(users.id, cities.id)),
-	);
-
-Expect<Equal<{ id: number; homeCity: string }[], typeof intersectAllTest>>;
-
-const exceptTest = await db
-	.select({ id: users.id, homeCity: users.homeCity })
-	.from(users)
-	.except(
-		db
-			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
-			.from(users),
-	);
-
-Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
-
-const exceptAllTest = await db
-	.select({ id: users.id, homeCity: users.class })
-	.from(users)
-	.except(
-		db
-			.select({ id: users.id, homeCity: sql<string>`${users.class}` })
-			.from(users),
-	);
-
-Expect<Equal<{ id: number; homeCity: string }[], typeof exceptAllTest>>;
-
-const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
-
-Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
-
-const unionAll2Test = await unionAll(
-	db.select({
-		id: cities.id,
-		name: cities.name,
-		population: cities.population,
-	}).from(cities),
-	db.select().from(cities),
-);
-
-Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
-
-const intersect2Test = await intersect(
-	db.select({
-		id: cities.id,
-		name: cities.name,
-		population: cities.population,
-	}).from(cities),
-	db.select({
-		id: cities.id,
-		name: cities.name,
-		population: cities.population,
-	}).from(cities),
-	db.select({
-		id: cities.id,
-		name: cities.name,
-		population: cities.population,
-	}).from(cities),
-);
-
-Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
-
-const intersectAll2Test = await intersectAll(
-	union(
-		db.select({
-			id: cities.id,
-		}).from(cities),
-		db.select({
-			id: cities.id,
-		})
-			.from(cities).where(sql``),
-	),
-	db.select({
-		id: cities.id,
-	})
-		.from(cities),
-).orderBy(desc(cities.id)).limit(23);
-
-Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
-
-const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).limit(1).offset(2);
-
-Expect<
-	Equal<{
-		id: number;
-		uuid: string;
-		homeCity: number;
-		currentCity: number | null;
-		class: string;
-		subClass: string | null;
-		text: string | null;
-		age1: number;
-		createdAt: Date;
-		arrayCol: string[];
-	}[], typeof unionfull>
->;
-
-union(db.select().from(users), db.select().from(users))
-	.orderBy(sql``)
-	// @ts-expect-error - method was already called
-	.orderBy(sql``);
-
-union(db.select().from(users), db.select().from(users))
-	.offset(1)
-	// @ts-expect-error - method was already called
-	.offset(2);
-
-union(db.select().from(users), db.select().from(users))
-	.orderBy(sql``)
-	// @ts-expect-error - method was already called
-	.orderBy(sql``);
-
-{
-	function dynamic<T extends GelSetOperator>(qb: T) {
-		return qb.orderBy(sql``).limit(1).offset(2);
-	}
-
-	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
-	const result = await dynamic(qb);
-	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
-}
-
-await db
-	.select({ id: users.id, homeCity: users.homeCity })
-	.from(users)
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
-
-// All queries in combining statements should return the same number of columns
-// and the corresponding columns should have compatible data type
-// @ts-expect-error
-db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
-
-// All queries in combining statements should return the same number of columns
-// and the corresponding columns should have compatible data type
-// @ts-expect-error
-db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
-
-// All queries in combining statements should return the same number of columns
-// and the corresponding columns should have compatible data type
-// @ts-expect-error
-db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
-
-union(
-	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
-	db.select({ id: cities.id, name: cities.name }).from(cities),
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	db.select().from(cities),
-);
-
-union(
-	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
-	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).limit(3).$dynamic(),
-	db.select({ id: cities.id, name: cities.name }).from(cities),
-);
-
-union(
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-);
-
-union(
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-);
-
-union(
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities).where(sql``),
-	db.select({ id: sql<number>`${cities.id}` }).from(cities),
-	db.select({ id: cities.id }).from(cities),
-	// All queries in combining statements should return the same number of columns
-	// and the corresponding columns should have compatible data type
-	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
-);
diff --git a/drizzle-orm/type-tests/geldb/subquery.ts b/drizzle-orm/type-tests/geldb/subquery.ts
deleted file mode 100644
index 077525ed26..0000000000
--- a/drizzle-orm/type-tests/geldb/subquery.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Expect } from 'type-tests/utils.ts';
-import { alias, gelTable, integer, text } from '~/gel-core/index.ts';
-import { and, eq } from '~/sql/expressions/index.ts';
-import { sql } from '~/sql/sql.ts';
-import type { DrizzleTypeError, Equal } from '~/utils.ts';
-import { db } from './db.ts';
-
-const names = gelTable('names', {
-	id: integer('id').primaryKey(),
-	name: text('name'),
-	authorId: integer('author_id'),
-});
-
-const n1 = db
-	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
-		count1: sql<number>`count(1)::int`.as('count1'),
-	})
-	.from(names)
-	.groupBy(names.id, names.name, names.authorId)
-	.as('n1');
-
-const n2 = db
-	.select({
-		id: names.id,
-		authorId: names.authorId,
-		totalCount: sql<number>`count(1)::int`.as('totalCount'),
-	})
-	.from(names)
-	.groupBy(names.id, names.authorId)
-	.as('n2');
-
-const result = await db
-	.select({
-		name: n1.name,
-		authorId: n1.authorId,
-		count1: n1.count1,
-		totalCount: n2.totalCount,
-	})
-	.from(n1)
-	.innerJoin(n2, and(eq(n2.id, n1.id), eq(n2.authorId, n1.authorId)));
-
-Expect<
-	Equal<
-		{
-			name: string | null;
-			authorId: number | null;
-			count1: number;
-			totalCount: number;
-		}[],
-		typeof result
-	>
->;
-
-const names2 = alias(names, 'names2');
-
-const sq1 = db
-	.select({
-		id: names.id,
-		name: names.name,
-		id2: names2.id,
-	})
-	.from(names)
-	.leftJoin(names2, eq(names.name, names2.name))
-	.as('sq1');
-
-const res = await db.select().from(sq1);
-
-Expect<
-	Equal<
-		{
-			id: number;
-			name: string | null;
-			id2: number | null;
-		}[],
-		typeof res
-	>
->;
-
-{
-	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
-	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
-}
-
-const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
-
-const resUnion = await db.select().from(sqUnion);
-
-Expect<
-	Equal<{
-		id: number;
-		name: string | null;
-		authorId: number | null;
-	}[], typeof resUnion>
->;
diff --git a/drizzle-orm/type-tests/geldb/tables-rel.ts b/drizzle-orm/type-tests/geldb/tables-rel.ts
deleted file mode 100644
index 11e4e007d6..0000000000
--- a/drizzle-orm/type-tests/geldb/tables-rel.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { foreignKey, gelTable, integer, text, timestamptz } from '~/gel-core/index.ts';
-import { relations } from '~/relations.ts';
-
-export const users = gelTable('users', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: integer('city_id').references(() => cities.id).notNull(),
-	homeCityId: integer('home_city_id').references(() => cities.id),
-	createdAt: timestamptz('created_at').notNull(),
-});
-export const usersConfig = relations(users, ({ one, many }) => ({
-	city: one(cities, { relationName: 'UsersInCity', fields: [users.cityId], references: [cities.id] }),
-	homeCity: one(cities, { fields: [users.homeCityId], references: [cities.id] }),
-	posts: many(posts),
-	comments: many(comments),
-}));
-
-export const cities = gelTable('cities', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-});
-export const citiesConfig = relations(cities, ({ many }) => ({
-	users: many(users, { relationName: 'UsersInCity' }),
-}));
-
-export const posts = gelTable('posts', {
-	id: integer('id').primaryKey(),
-	title: text('title').notNull(),
-	authorId: integer('author_id').references(() => users.id),
-});
-export const postsConfig = relations(posts, ({ one, many }) => ({
-	author: one(users, { fields: [posts.authorId], references: [users.id] }),
-	comments: many(comments),
-}));
-
-export const comments = gelTable('comments', {
-	id: integer('id').primaryKey(),
-	postId: integer('post_id').references(() => posts.id).notNull(),
-	authorId: integer('author_id').references(() => users.id),
-	text: text('text').notNull(),
-});
-export const commentsConfig = relations(comments, ({ one }) => ({
-	post: one(posts, { fields: [comments.postId], references: [posts.id] }),
-	author: one(users, { fields: [comments.authorId], references: [users.id] }),
-}));
-
-export const books = gelTable('books', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-});
-export const booksConfig = relations(books, ({ many }) => ({
-	authors: many(bookAuthors),
-}));
-
-export const bookAuthors = gelTable('book_authors', {
-	bookId: integer('book_id').references(() => books.id).notNull(),
-	authorId: integer('author_id').references(() => users.id).notNull(),
-	role: text('role').notNull(),
-});
-export const bookAuthorsConfig = relations(bookAuthors, ({ one }) => ({
-	book: one(books, { fields: [bookAuthors.bookId], references: [books.id] }),
-	author: one(users, { fields: [bookAuthors.authorId], references: [users.id] }),
-}));
-
-export const node = gelTable('node', {
-	id: integer('id').primaryKey(),
-	parentId: integer('parent_id'),
-	leftId: integer('left_id'),
-	rightId: integer('right_id'),
-}, (node) => ({
-	fk1: foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
-	fk2: foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
-	fk3: foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
-}));
-export const nodeRelations = relations(node, ({ one }) => ({
-	parent: one(node, { fields: [node.parentId], references: [node.id] }),
-	left: one(node, { fields: [node.leftId], references: [node.id] }),
-	right: one(node, { fields: [node.rightId], references: [node.id] }),
-}));
diff --git a/drizzle-orm/type-tests/geldb/tables.ts b/drizzle-orm/type-tests/geldb/tables.ts
deleted file mode 100644
index 1a2ff6c9cc..0000000000
--- a/drizzle-orm/type-tests/geldb/tables.ts
+++ /dev/null
@@ -1,945 +0,0 @@
-import { DateDuration, Duration, LocalDate, LocalDateTime, RelativeDuration } from 'gel';
-import crypto from 'node:crypto';
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-import { relDuration } from '~/gel-core/columns/relative-duration.ts';
-import {
-	bigint,
-	bigintT,
-	boolean,
-	check,
-	dateDuration,
-	decimal,
-	doublePrecision,
-	duration,
-	foreignKey,
-	type GelColumn,
-	gelTable,
-	type GelTableWithColumns,
-	index,
-	integer,
-	json,
-	localDate,
-	primaryKey,
-	real,
-	smallint,
-	text,
-	timestamp,
-	timestamptz,
-	uniqueIndex,
-	uuid,
-} from '~/gel-core/index.ts';
-import { gelSchema } from '~/gel-core/schema.ts';
-import { eq } from '~/sql/expressions/index.ts';
-import { sql } from '~/sql/sql.ts';
-import type { InferInsertModel, InferSelectModel } from '~/table.ts';
-import type { Simplify } from '~/utils.ts';
-import { db } from './db.ts';
-
-// export const myEnum = gelEnum('my_enum', ['a', 'b', 'c']);
-
-export const identityColumnsTable = gelTable('identity_columns_table', {
-	generatedCol: integer('generated_col').generatedAlwaysAs(1),
-	alwaysAsIdentity: integer('always_as_identity').generatedAlwaysAsIdentity(),
-	byDefaultAsIdentity: integer('by_default_as_identity').generatedByDefaultAsIdentity(),
-	name: text('name'),
-});
-
-Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferSelect']>>;
-Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferSelect']>>;
-Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferInsert']>>;
-Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferInsert']>>;
-Expect<
-	Equal<
-		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
-		Simplify<typeof identityColumnsTable['$inferInsert'] & { alwaysAsIdentity?: number | undefined }>
-	>
->;
-Expect<
-	Equal<
-		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
-		Simplify<typeof identityColumnsTable['_']['inferInsert'] & { alwaysAsIdentity?: number | undefined }>
-	>
->;
-
-export const users = gelTable(
-	'users_table',
-	{
-		id: integer('id').primaryKey(),
-		uuid: uuid('uuid').notNull(),
-		homeCity: integer('home_city')
-			.notNull()
-			.references(() => cities.id),
-		currentCity: integer('current_city').references(() => cities.id),
-		class: text('class').notNull(),
-		subClass: text('sub_class'),
-		text: text('text'),
-		age1: integer('age1').notNull(),
-		createdAt: timestamptz('created_at').notNull(),
-		arrayCol: text('array_col').array().notNull(),
-	},
-	(users) => [
-		uniqueIndex('usersAge1Idx').on(users.class.asc().nullsFirst(), sql``),
-		index('usersAge2Idx').on(sql``),
-		uniqueIndex('uniqueClass')
-			.using('btree', users.class.desc().op('text_ops'), users.subClass.nullsLast())
-			.where(sql`${users.class} is not null`)
-			.concurrently(),
-		check('legalAge', sql`${users.age1} > 18`),
-		foreignKey({ columns: [users.subClass], foreignColumns: [classes.subClass] })
-			.onUpdate('cascade')
-			.onDelete('cascade'),
-		foreignKey({
-			columns: [users.class, users.subClass],
-			foreignColumns: [classes.class, classes.subClass],
-		}),
-		primaryKey({ columns: [users.age1, users.class] }),
-	],
-);
-
-Expect<Equal<InferSelectModel<typeof users>, typeof users['$inferSelect']>>;
-Expect<Equal<InferSelectModel<typeof users>, typeof users['_']['inferSelect']>>;
-Expect<Equal<InferInsertModel<typeof users>, typeof users['$inferInsert']>>;
-Expect<Equal<InferInsertModel<typeof users>, typeof users['_']['inferInsert']>>;
-
-export const cities = gelTable('cities_table', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-	population: integer('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index().on(cities.id),
-}));
-
-export const classes = gelTable('classes_table', {
-	id: integer('id').primaryKey(),
-	class: text('class'),
-	subClass: text('sub_class').notNull(),
-});
-
-Expect<
-	Equal<{
-		id: number;
-		class?: string | null;
-		subClass: string;
-	}, typeof classes.$inferInsert>
->;
-
-export const salEmp = gelTable('sal_emp', {
-	name: text('name').notNull(),
-	payByQuarter: integer('pay_by_quarter').array().notNull(),
-	schedule: text('schedule').array().array().notNull(),
-});
-
-export const tictactoe = gelTable('tictactoe', {
-	squares: integer('squares').array(3).array(3).notNull(),
-});
-
-export const customSchema = gelSchema('custom');
-
-export const citiesCustom = customSchema.table('cities_table', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-	population: integer('population').default(0),
-}, (cities) => [index().on(cities.id)]);
-
-// TODO not exists
-// {
-// 	const newYorkers = gelView('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	}).existing();
-
-// 	Expect<
-// 		Equal<
-// 			GelViewWithSelection<'new_yorkers', true, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: string | number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam: string | number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers
-// 		>
-// 	>;
-// }
-
-// {
-// 	const newYorkers = customSchema.view('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	}).existing();
-
-// 	Expect<
-// 		Equal<
-// 			GelViewWithSelection<'new_yorkers', true, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam:  number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers
-// 		>
-// 	>;
-// }
-
-// export const newYorkers2 = gelMaterializedView('new_yorkers')
-// 	.using('btree')
-// 	.with({
-// 		fillfactor: 90,
-// 		toastTupleTarget: 0.5,
-// 		autovacuumEnabled: true,
-// 	})
-// 	.tablespace('custom_tablespace')
-// 	.withNoData()
-// 	.as((qb) => {
-// 		const sq = qb
-// 			.$with('sq')
-// 			.as(
-// 				qb.select({ userId: users.id, cityId: cities.id })
-// 					.from(users)
-// 					.leftJoin(cities, eq(cities.id, users.homeCity))
-// 					.where(sql`${users.age1} > 18`),
-// 			);
-// 		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
-// 	});
-
-// Expect<
-// 	Equal<
-// 		GelMaterializedViewWithSelection<'new_yorkers', false, {
-// 			userId: GelColumn<{
-// 				tableName: 'new_yorkers';
-// 				name: 'id';
-// 				dataType: 'number';
-// 				columnType: 'GelSerial';
-// 				data: number;
-// 				driverParam: number;
-// 				notNull: true;
-// 				hasDefault: true;
-// 				enumValues: undefined;
-// 				baseColumn: never;
-// 				generated: undefined;
-// 				identity: undefined;
-// 				isPrimaryKey: true;
-// 				isAutoincrement: false;
-// 				hasRuntimeDefault: false;
-// 			}>;
-// 			cityId: GelColumn<{
-// 				tableName: 'new_yorkers';
-// 				name: 'id';
-// 				dataType: 'number';
-// 				columnType: 'GelSerial';
-// 				data: number;
-// 				driverParam: number;
-// 				notNull: false;
-// 				hasDefault: true;
-// 				enumValues: undefined;
-// 				baseColumn: never;
-// 				generated: undefined;
-// 				identity: undefined;
-// 				isPrimaryKey: true;
-// 				isAutoincrement: false;
-// 				hasRuntimeDefault: false;
-// 			}>;
-// 		}>,
-// 		typeof newYorkers2
-// 	>
-// >;
-
-// {
-// 	const newYorkers2 = customSchema.materializedView('new_yorkers')
-// 		.using('btree')
-// 		.with({
-// 			fillfactor: 90,
-// 			toastTupleTarget: 0.5,
-// 			autovacuumEnabled: true,
-// 		})
-// 		.tablespace('custom_tablespace')
-// 		.withNoData()
-// 		.as((qb) => {
-// 			const sq = qb
-// 				.$with('sq')
-// 				.as(
-// 					qb.select({ userId: users.id, cityId: cities.id })
-// 						.from(users)
-// 						.leftJoin(cities, eq(cities.id, users.homeCity))
-// 						.where(sql`${users.age1} > 18`),
-// 				);
-// 			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
-// 		});
-
-// 	Expect<
-// 		Equal<
-// 			GelMaterializedViewWithSelection<'new_yorkers', false, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'id';
-// 					dataType: 'number';
-// 					columnType: 'GelSerial';
-// 					data: number;
-// 					driverParam: number;
-// 					notNull: true;
-// 					hasDefault: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: true;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'id';
-// 					dataType: 'number';
-// 					columnType: 'GelSerial';
-// 					data: number;
-// 					driverParam: number;
-// 					notNull: false;
-// 					hasDefault: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: true;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers2
-// 		>
-// 	>;
-// }
-
-// {
-// 	const newYorkers2 = gelMaterializedView('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	})
-// 		.using('btree')
-// 		.with({
-// 			fillfactor: 90,
-// 			toastTupleTarget: 0.5,
-// 			autovacuumEnabled: true,
-// 		})
-// 		.tablespace('custom_tablespace')
-// 		.withNoData()
-// 		.as(
-// 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
-// 				eq(cities.id, users.homeCity)
-// 			} where ${gt(users.age1, 18)}`,
-// 		);
-
-// 	Expect<
-// 		Equal<
-// 			GelMaterializedViewWithSelection<'new_yorkers', false, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: string | number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam: string | number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers2
-// 		>
-// 	>;
-// }
-
-// {
-// 	const newYorkers2 = customSchema.materializedView('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	})
-// 		.using('btree')
-// 		.with({
-// 			fillfactor: 90,
-// 			toastTupleTarget: 0.5,
-// 			autovacuumEnabled: true,
-// 		})
-// 		.tablespace('custom_tablespace')
-// 		.withNoData()
-// 		.as(
-// 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
-// 				eq(cities.id, users.homeCity)
-// 			} where ${gt(users.age1, 18)}`,
-// 		);
-
-// 	Expect<
-// 		Equal<
-// 			GelMaterializedViewWithSelection<'new_yorkers', false, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: string | number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam: string | number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers2
-// 		>
-// 	>;
-// }
-
-// {
-// 	const newYorkers2 = gelMaterializedView('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	}).existing();
-
-// 	Expect<
-// 		Equal<
-// 			GelMaterializedViewWithSelection<'new_yorkers', true, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: string | number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam: string | number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers2
-// 		>
-// 	>;
-// }
-
-// {
-// 	const newYorkers2 = customSchema.materializedView('new_yorkers', {
-// 		userId: integer('user_id').notNull(),
-// 		cityId: integer('city_id'),
-// 	}).existing();
-
-// 	Expect<
-// 		Equal<
-// 			GelMaterializedViewWithSelection<'new_yorkers', true, {
-// 				userId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'user_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					data: number;
-// 					driverParam: string | number;
-// 					hasDefault: false;
-// 					notNull: true;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 				cityId: GelColumn<{
-// 					tableName: 'new_yorkers';
-// 					name: 'city_id';
-// 					dataType: 'number';
-// 					columnType: 'GelInteger';
-// 					notNull: false;
-// 					hasDefault: false;
-// 					data: number;
-// 					driverParam: string | number;
-// 					enumValues: undefined;
-// 					baseColumn: never;
-// 					generated: undefined;
-// 					identity: undefined;
-// 					isPrimaryKey: false;
-// 					isAutoincrement: false;
-// 					hasRuntimeDefault: false;
-// 				}>;
-// 			}>,
-// 			typeof newYorkers2
-// 		>
-// 	>;
-// }
-
-// await db.refreshMaterializedView(newYorkers2).concurrently();
-// await db.refreshMaterializedView(newYorkers2).withNoData();
-// await db.refreshMaterializedView(newYorkers2).concurrently().withNoData();
-// await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
-
-// await migrate(db, {
-// 	migrationsFolder: './drizzle/gel',
-// 	onMigrationError(error) {
-// 		if (['0001_drizli_klaud', '0002_beep_boop'].includes(error.migration.name)) {
-// 			return;
-// 		}
-// 		throw error;
-// 	},
-// });
-
-// TODO not sure that this should be implemented now
-// {
-// 	const customTextRequired = customType<{
-// 		data: string;
-// 		driverData: string;
-// 		config: { length: number };
-// 		configRequired: true;
-// 	}>({
-// 		dataType(config) {
-// 			Expect<Equal<{ length: number }, typeof config>>;
-// 			return `varchar(${config.length})`;
-// 		},
-
-// 		toDriver(value) {
-// 			Expect<Equal<string, typeof value>>();
-// 			return value;
-// 		},
-
-// 		fromDriver(value) {
-// 			Expect<Equal<string, typeof value>>();
-// 			return value;
-// 		},
-// 	});
-
-// 	customTextRequired('t', { length: 10 });
-// 	customTextRequired({ length: 10 });
-// 	// @ts-expect-error - config is required
-// 	customTextRequired('t');
-// 	// @ts-expect-error - config is required
-// 	customTextRequired();
-// }
-
-// {
-// 	const customTextOptional = customType<{
-// 		data: string;
-// 		driverData: string;
-// 		config: { length: number };
-// 	}>({
-// 		dataType(config) {
-// 			Expect<Equal<{ length: number } | undefined, typeof config>>;
-// 			return config ? `varchar(${config.length})` : `text`;
-// 		},
-
-// 		toDriver(value) {
-// 			Expect<Equal<string, typeof value>>();
-// 			return value;
-// 		},
-
-// 		fromDriver(value) {
-// 			Expect<Equal<string, typeof value>>();
-// 			return value;
-// 		},
-// 	});
-
-// 	customTextOptional('t', { length: 10 });
-// 	customTextOptional('t');
-// 	customTextOptional({ length: 10 });
-// 	customTextOptional();
-// }
-
-{
-	const cities1 = gelTable('cities_table', {
-		id: integer('id').primaryKey(),
-		name: text('name').notNull().primaryKey(),
-		role: text('role').$type<'admin' | 'user'>().default('user').notNull(),
-		population: integer('population').default(0),
-	});
-	const cities2 = gelTable('cities_table', ({ text, integer }) => ({
-		id: integer('id').primaryKey(),
-		name: text('name').notNull().primaryKey(),
-		role: text('role').$type<'admin' | 'user'>().default('user').notNull(),
-		population: integer('population').default(0),
-	}));
-
-	type Expected = GelTableWithColumns<{
-		name: 'cities_table';
-		schema: undefined;
-		dialect: 'gel';
-		columns: {
-			id: GelColumn<{
-				tableName: 'cities_table';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'GelInteger';
-				data: number;
-				driverParam: number;
-				hasDefault: false;
-				notNull: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			name: GelColumn<{
-				tableName: 'cities_table';
-				name: 'name';
-				dataType: 'string';
-				columnType: 'GelText';
-				data: string;
-				driverParam: string;
-				hasDefault: false;
-				enumValues: undefined;
-				notNull: true;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			role: GelColumn<
-				{
-					tableName: 'cities_table';
-					name: 'role';
-					dataType: 'string';
-					columnType: 'GelText';
-					data: 'admin' | 'user';
-					driverParam: string;
-					hasDefault: true;
-					enumValues: undefined;
-					notNull: true;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{ $type: 'admin' | 'user' }
-			>;
-			population: GelColumn<{
-				tableName: 'cities_table';
-				name: 'population';
-				dataType: 'number';
-				columnType: 'GelInteger';
-				data: number;
-				driverParam: number;
-				notNull: false;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: false;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-		};
-	}>;
-
-	Expect<Equal<Expected, typeof cities1>>;
-	Expect<Equal<Expected, typeof cities2>>;
-}
-
-{
-	gelTable('test', {
-		bigint: bigintT('bigintT').default(BigInt(10)),
-		timestamp: timestamp('timestamp').default(new LocalDateTime(2023, 12, 3, 12, 3, 12)),
-		timestamptz: timestamptz('timestamp2').default(new Date()),
-	});
-}
-
-{
-	const test = gelTable('test', {
-		col1: decimal('col1').notNull().default('10.2'),
-	});
-	Expect<Equal<{ col1: string }, typeof test.$inferSelect>>;
-}
-
-{
-	const getUsersTable = <TSchema extends string>(schemaName: TSchema) => {
-		return gelSchema(schemaName).table('users', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull(),
-		});
-	};
-
-	const users1 = getUsersTable('id1');
-	Expect<Equal<'id1', typeof users1._.schema>>;
-
-	const users2 = getUsersTable('id2');
-	Expect<Equal<'id2', typeof users2._.schema>>;
-}
-
-{
-	const internalStaff = gelTable('internal_staff', {
-		userId: integer('user_id').notNull(),
-	});
-
-	const customUser = gelTable('custom_user', {
-		id: integer('id').notNull(),
-	});
-
-	const ticket = gelTable('ticket', {
-		staffId: integer('staff_id').notNull(),
-	});
-
-	const subq = db
-		.select()
-		.from(internalStaff)
-		.leftJoin(
-			customUser,
-			eq(internalStaff.userId, customUser.id),
-		).as('internal_staff');
-
-	const mainQuery = await db
-		.select()
-		.from(ticket)
-		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-	Expect<
-		Equal<{
-			internal_staff: {
-				internal_staff: {
-					userId: number;
-				};
-				custom_user: {
-					id: number | null;
-				};
-			} | null;
-			ticket: {
-				staffId: number;
-			};
-		}[], typeof mainQuery>
-	>;
-}
-
-{
-	const test = gelTable('test', {
-		id: text('id').$defaultFn(() => crypto.randomUUID()).primaryKey(),
-	});
-
-	Expect<
-		Equal<{
-			id?: string;
-		}, typeof test.$inferInsert>
-	>;
-}
-
-{
-	gelTable('test', {
-		id: integer('id').$default(() => 1),
-		id2: integer('id').$defaultFn(() => 1),
-		// @ts-expect-error - should be number
-		id3: integer('id').$default(() => '1'),
-		// @ts-expect-error - should be number
-		id4: integer('id').$defaultFn(() => '1'),
-	});
-}
-
-{
-	gelTable('all_columns', {
-		sm: smallint('smallint'),
-		smdef: smallint('smallint_def').default(10),
-		int: integer('integer'),
-		intdef: integer('integer_def').default(10),
-		bigint: bigint('bigint'),
-		bigintT: bigintT('bigintT').default(BigInt(100)),
-		bool: boolean('boolean'),
-		booldef: boolean('boolean_def').default(true),
-		text: text('text'),
-		textdef: text('textdef').default('text'),
-		decimal: decimal('decimal'),
-		decimaldef: decimal('decimaldef').default('100.0'),
-		doublePrecision: doublePrecision('doublePrecision'),
-		doublePrecisiondef: doublePrecision('doublePrecisiondef').default(100),
-		real: real('real'),
-		realdef: real('realdef').default(100),
-		json: json('json').$type<{ attr: string }>(),
-		jsondef: json('jsondef').$type<{ attr: string }>().default({ attr: 'value' }),
-		jsonb: json('json').$type<{ attr: string }>(),
-		jsonbdef: json('json').$type<{ attr: string }>().default({ attr: 'value' }),
-		localDate: localDate('localDate'),
-		localDate2: localDate('local_date_def').default(new LocalDate(2023, 12, 1)),
-		duration: duration('duration'),
-		durationdef: duration('durationdef').default(new Duration(12, 523, 0, 9, 0, 0, 0, 0, 0, 0)),
-		relDuration: relDuration('relDuration'),
-		relDurationdef: relDuration('relDurationdef').default(new RelativeDuration(12, 523, 0, 9, 0, 0, 0, 0, 0)),
-		dateDuration: dateDuration('dateDuration'),
-		dateDurationdef: dateDuration('relDurationdef').default(new DateDuration(12, 12, 12, 6)),
-		timestamp: timestamp('timestamp'),
-		timestampdef: timestamp('timestamp_def').default(new LocalDateTime(2023, 1, 1, 1, 1, 14, 0, 0, 0)),
-		timestamptz: timestamptz('timestamp3'),
-		timestamptz2: timestamptz('timestampdef').default(new Date()),
-	});
-}
-
-{
-	const keysAsColumnNames = gelTable('test', {
-		id: integer(),
-		name: text(),
-	});
-
-	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], 'id'>>;
-	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], 'name'>>;
-}
-
-{
-	gelTable('all_columns_without_name', {
-		sm: smallint(),
-		smdef: smallint().default(10),
-		int: integer(),
-		intdef: integer().default(10),
-		bigint: bigint(),
-		bigintT: bigintT().default(BigInt(100)),
-		bool: boolean(),
-		booldef: boolean().default(true),
-		text: text(),
-		textdef: text().default('text'),
-		decimal: decimal(),
-		decimaldef: decimal().default('100.0'),
-		doublePrecision: doublePrecision(),
-		doublePrecisiondef: doublePrecision().default(100),
-		real: real(),
-		realdef: real().default(100),
-		json: json().$type<{ attr: string }>(),
-		jsondef: json().$type<{ attr: string }>().default({ attr: 'value' }),
-		jsonb: json().$type<{ attr: string }>(),
-		jsonbdef: json().$type<{ attr: string }>().default({ attr: 'value' }),
-		localDate: localDate(),
-		localDate2: localDate().default(new LocalDate(2023, 12, 1)),
-		duration: duration(),
-		durationdef: duration().default(new Duration(12, 523, 0, 9, 0, 0, 0, 0, 0, 0)),
-		relDuration: relDuration(),
-		relDurationdef: relDuration().default(new RelativeDuration(12, 523, 0, 9, 0, 0, 0, 0, 0)),
-		dateDuration: dateDuration(),
-		dateDurationdef: dateDuration().default(new DateDuration(12, 12, 12, 6)),
-		timestamp: timestamp(),
-		timestampdef: timestamp().default(new LocalDateTime(2023, 1, 1, 1, 1, 14, 0, 0, 0)),
-		timestamptz: timestamptz(),
-		timestamptz2: timestamptz().default(new Date()),
-	});
-}
diff --git a/drizzle-orm/type-tests/geldb/update.ts b/drizzle-orm/type-tests/geldb/update.ts
deleted file mode 100644
index 1f6361ea87..0000000000
--- a/drizzle-orm/type-tests/geldb/update.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-import type { GelUpdate } from '~/gel-core/index.ts';
-import { eq } from '~/sql/expressions/index.ts';
-import { sql } from '~/sql/sql.ts';
-import type { Simplify } from '~/utils.ts';
-import { db } from './db.ts';
-import { cities, salEmp, users } from './tables.ts';
-
-const update = await db.update(users)
-	.set({
-		text: 'John',
-		age1: 30,
-	})
-	.where(eq(users.id, 1));
-Expect<Equal<unknown, typeof update>>;
-
-const updateStmt = db.update(users)
-	.set({
-		text: 'John',
-		age1: 30,
-	})
-	.where(eq(users.id, 1))
-	.prepare('updateStmt');
-const updatePrepared = await updateStmt.execute();
-Expect<Equal<unknown, typeof updatePrepared>>;
-
-const updateReturning = await db.update(users)
-	.set({
-		text: 'John',
-		age1: 30,
-	})
-	.where(eq(users.id, 1))
-	.returning({
-		text: users.text,
-	});
-Expect<Equal<{ text: string | null }[], typeof updateReturning>>;
-
-const updateReturningStmt = db.update(users)
-	.set({
-		text: 'John',
-		age1: 30,
-	})
-	.where(eq(users.id, 1))
-	.returning({
-		text: users.text,
-	})
-	.prepare('updateReturningStmt');
-const updateReturningPrepared = await updateReturningStmt.execute();
-Expect<Equal<{ text: string | null }[], typeof updateReturningPrepared>>;
-
-{
-	function dynamic<T extends GelUpdate>(qb: T) {
-		return qb.where(sql``).returning();
-	}
-
-	const qbBase = db.update(users).set({}).$dynamic();
-	const qb = dynamic(qbBase);
-	const result = await qb;
-	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
-}
-
-{
-	function withReturning<T extends GelUpdate>(qb: T) {
-		return qb.returning();
-	}
-
-	const qbBase = db.update(users).set({}).$dynamic();
-	const qb = withReturning(qbBase);
-	const result = await qb;
-	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
-}
-
-{
-	db
-		.update(users)
-		.set({})
-		.returning()
-		// @ts-expect-error method was already called
-		.returning();
-
-	db
-		.update(users)
-		.set({})
-		.where(sql``)
-		// @ts-expect-error method was already called
-		.where(sql``);
-}
-
-{
-	db
-		.update(users)
-		.set({})
-		.from(sql``)
-		.leftJoin(sql``, (table, from) => {
-			Expect<Equal<typeof users['_']['columns'], typeof table>>;
-			Expect<Equal<never, typeof from>>;
-			return sql``;
-		});
-
-	db
-		.update(users)
-		.set({})
-		.from(cities)
-		.leftJoin(sql``, (table, from) => {
-			Expect<Equal<typeof users['_']['columns'], typeof table>>;
-			Expect<Equal<typeof cities['_']['columns'], typeof from>>;
-			return sql``;
-		});
-
-	const citiesSq = db.$with('cities_sq').as(db.select({ id: cities.id }).from(cities));
-
-	db
-		.with(citiesSq)
-		.update(users)
-		.set({})
-		.from(citiesSq)
-		.leftJoin(sql``, (table, from) => {
-			Expect<Equal<typeof users['_']['columns'], typeof table>>;
-			Expect<Equal<typeof citiesSq['_']['selectedFields'], typeof from>>;
-			return sql``;
-		});
-
-	db
-		.with(citiesSq)
-		.update(users)
-		.set({
-			homeCity: citiesSq.id,
-		})
-		.from(citiesSq);
-}
-
-{
-	const result = await db.update(users).set({}).from(cities).returning();
-	Expect<
-		Equal<Simplify<
-			typeof users.$inferSelect & {
-				cities_table: typeof cities.$inferSelect;
-			}
-		>[], typeof result>
-	>;
-}
-
-{
-	const result1 = await db.update(users).set({}).from(cities).leftJoin(salEmp, sql``).returning();
-	Expect<
-		Equal<Simplify<
-			typeof users.$inferSelect & {
-				cities_table: typeof cities.$inferSelect;
-				sal_emp: typeof salEmp.$inferSelect | null;
-			}
-		>[], typeof result1>
-	>;
-
-	const result2 = await db.update(users).set({}).from(cities).rightJoin(salEmp, sql``).returning();
-	Expect<
-		Equal<Simplify<
-			{ [K in keyof typeof users.$inferSelect]: typeof users.$inferSelect[K] | null } & {
-				cities_table: typeof cities.$inferSelect | null;
-				sal_emp: typeof salEmp.$inferSelect;
-			}
-		>[], typeof result2>
-	>;
-
-	const result3 = await db.update(users).set({}).from(cities).innerJoin(salEmp, sql``).returning();
-	Expect<
-		Equal<Simplify<
-			typeof users.$inferSelect & {
-				cities_table: typeof cities.$inferSelect;
-				sal_emp: typeof salEmp.$inferSelect;
-			}
-		>[], typeof result3>
-	>;
-
-	const result4 = await db.update(users).set({}).from(cities).fullJoin(salEmp, sql``).returning();
-	Expect<
-		Equal<Simplify<
-			{ [K in keyof typeof users.$inferSelect]: typeof users.$inferSelect[K] | null } & {
-				cities_table: typeof cities.$inferSelect | null;
-				sal_emp: typeof salEmp.$inferSelect | null;
-			}
-		>[], typeof result4>
-	>;
-}
-
-{
-	const result = await db.update(users).set({}).from(cities).returning({
-		id: users.id,
-		cities: cities,
-		cityName: cities.name,
-	});
-	Expect<
-		Equal<Simplify<{
-			id: number;
-			cities: typeof cities.$inferSelect;
-			cityName: string;
-		}>[], typeof result>
-	>;
-}
-
-{
-	const result1 = await db.update(users).set({}).from(cities).leftJoin(salEmp, sql``).returning({
-		id: users.id,
-		cities: cities,
-		cityName: cities.name,
-		salEmp: salEmp,
-		salEmpName: salEmp.name,
-	});
-	Expect<
-		Equal<Simplify<{
-			id: number;
-			cities: typeof cities.$inferSelect;
-			cityName: string;
-			salEmp: typeof salEmp.$inferSelect | null;
-			salEmpName: string | null;
-		}>[], typeof result1>
-	>;
-
-	const result2 = await db.update(users).set({}).from(cities).rightJoin(salEmp, sql``).returning({
-		id: users.id,
-		cities: cities,
-		cityName: cities.name,
-		salEmp: salEmp,
-		salEmpName: salEmp.name,
-	});
-	Expect<
-		Equal<Simplify<{
-			id: number | null;
-			cities: typeof cities.$inferSelect | null;
-			cityName: string | null;
-			salEmp: typeof salEmp.$inferSelect;
-			salEmpName: string;
-		}>[], typeof result2>
-	>;
-
-	const result3 = await db.update(users).set({}).from(cities).innerJoin(salEmp, sql``).returning({
-		id: users.id,
-		cities: cities,
-		cityName: cities.name,
-		salEmp: salEmp,
-		salEmpName: salEmp.name,
-	});
-	Expect<
-		Equal<Simplify<{
-			id: number;
-			cities: typeof cities.$inferSelect;
-			cityName: string;
-			salEmp: typeof salEmp.$inferSelect;
-			salEmpName: string;
-		}>[], typeof result3>
-	>;
-
-	const result4 = await db.update(users).set({}).from(cities).fullJoin(salEmp, sql``).returning({
-		id: users.id,
-		cities: cities,
-		cityName: cities.name,
-		salEmp: salEmp,
-		salEmpName: salEmp.name,
-	});
-	Expect<
-		Equal<Simplify<{
-			id: number | null;
-			cities: typeof cities.$inferSelect | null;
-			cityName: string | null;
-			salEmp: typeof salEmp.$inferSelect | null;
-			salEmpName: string | null;
-		}>[], typeof result4>
-	>;
-}
-
-{
-	await db
-		.update(users)
-		.set({})
-		// @ts-expect-error can't use joins before from
-		.fullJoin(salEmp, sql``);
-}
diff --git a/drizzle-orm/type-tests/geldb/with.ts b/drizzle-orm/type-tests/geldb/with.ts
deleted file mode 100644
index 8678a784f4..0000000000
--- a/drizzle-orm/type-tests/geldb/with.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import type { Equal } from 'type-tests/utils.ts';
-import { Expect } from 'type-tests/utils.ts';
-import { gelTable, integer, text } from '~/gel-core/index.ts';
-import { gt, inArray, like } from '~/sql/expressions/index.ts';
-import { sql } from '~/sql/sql.ts';
-import { db } from './db.ts';
-
-const orders = gelTable('orders', {
-	id: integer('id').primaryKey(),
-	region: text('region').notNull(),
-	product: text('product').notNull(),
-	amount: integer('amount').notNull(),
-	quantity: integer('quantity').notNull(),
-	generated: text('generatedText').generatedAlwaysAs(sql``),
-});
-
-{
-	const regionalSales = db
-		.$with('regional_sales')
-		.as((qb) =>
-			qb
-				.select({
-					region: orders.region,
-					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-				})
-				.from(orders)
-				.groupBy(orders.region)
-		);
-
-	const topRegions = db
-		.$with('top_regions')
-		.as((qb) =>
-			qb
-				.select({
-					region: orders.region,
-					totalSales: orders.amount,
-				})
-				.from(regionalSales)
-				.where(
-					gt(
-						regionalSales.totalSales,
-						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-					),
-				)
-		);
-
-	const result = await db
-		.with(regionalSales, topRegions)
-		.select({
-			region: orders.region,
-			product: orders.product,
-			productUnits: sql<number>`sum(${orders.quantity})`,
-			productSales: sql<number>`sum(${orders.amount})`,
-		})
-		.from(orders)
-		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)));
-
-	Expect<
-		Equal<{
-			region: string;
-			product: string;
-			productUnits: number;
-			productSales: number;
-		}[], typeof result>
-	>;
-
-	const allOrdersWith = db.$with('all_orders_with').as(db.select().from(orders));
-	const allFromWith = await db.with(allOrdersWith).select().from(allOrdersWith);
-
-	Expect<
-		Equal<{
-			id: number;
-			region: string;
-			product: string;
-			amount: number;
-			quantity: number;
-			generated: string | null;
-		}[], typeof allFromWith>
-	>;
-
-	const regionalSalesWith = db.$with('regional_sales_with').as(db.select().from(regionalSales));
-	db.with(regionalSalesWith).select().from(regionalSalesWith).where(like(regionalSalesWith.totalSales, 'abc'));
-}
diff --git a/drizzle-orm/type-tests/knex/index.ts b/drizzle-orm/type-tests/knex/index.ts
deleted file mode 100644
index 222247ea34..0000000000
--- a/drizzle-orm/type-tests/knex/index.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { knex } from 'knex';
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import { pgTable, serial, text } from '~/pg-core/index.ts';
-import type { PromiseOf } from '~/utils.ts';
-import '~/knex';
-
-const test = pgTable('test', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-declare module 'knex/types/tables.ts' {
-	interface Tables {
-		test: Knexify<typeof test>;
-	}
-}
-
-const db = knex({});
-
-{
-	const res = db('test').select();
-	Expect<Equal<PromiseOf<typeof res>, typeof test.$inferSelect[]>>;
-}
diff --git a/drizzle-orm/type-tests/kysely/index.ts b/drizzle-orm/type-tests/kysely/index.ts
deleted file mode 100644
index c6a56f5729..0000000000
--- a/drizzle-orm/type-tests/kysely/index.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { Kysely, PostgresDialect } from 'kysely';
-import pg from 'pg';
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import type { Kyselify } from '~/kysely/index.ts';
-import { char, mysqlTable, timestamp as mysqlTimestamp, varchar as mysqlVarchar } from '~/mysql-core/index.ts';
-import { integer, pgEnum, pgTable, serial, text, timestamp, varchar } from '~/pg-core/index.ts';
-import type { PromiseOf } from '~/utils.ts';
-
-const { Pool } = pg;
-
-const test = pgTable('test', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-interface Database {
-	test: Kyselify<typeof test>;
-}
-
-const db = new Kysely<Database>({
-	dialect: new PostgresDialect({
-		pool: new Pool(),
-	}),
-});
-
-const result = db.selectFrom('test').selectAll().execute();
-Expect<Equal<PromiseOf<typeof result>, typeof test.$inferSelect[]>>();
-
-{
-	const units = mysqlTable('units', {
-		id: char('id', { length: 16 }).primaryKey(),
-		name: mysqlVarchar('name', { length: 255 }).notNull(),
-		abbreviation: mysqlVarchar('abbreviation', { length: 10 }).notNull(),
-		created_at: mysqlTimestamp('created_at').defaultNow().notNull(),
-		updated_at: mysqlTimestamp('updated_at').defaultNow().notNull().onUpdateNow(),
-	});
-
-	type UnitModel = typeof units;
-
-	interface Database {
-		units: Kyselify<UnitModel>;
-	}
-
-	const db = new Kysely<Database>({
-		dialect: new PostgresDialect({
-			pool: new Pool(),
-		}),
-	});
-
-	await db
-		.insertInto('units')
-		.values({
-			id: 'my-unique-id',
-			abbreviation: 'foo',
-			name: 'bar',
-		})
-		.execute();
-}
-
-{
-	const uploadStateEnum = pgEnum('upload_state', ['uploading', 'uploaded', 'failed']);
-	const uploadTypeEnum = pgEnum('upload_type', ['image', 'video']);
-
-	const uploads = pgTable('uploads', {
-		id: varchar('id', { length: 100 }).primaryKey(),
-		state: uploadStateEnum('state').notNull().default('uploading'),
-		type: uploadTypeEnum('type').notNull(),
-		fileName: varchar('file_name', { length: 100 }).notNull(),
-		fileType: varchar('file_type', { length: 100 }).notNull(),
-		fileSize: integer('file_size').notNull(),
-		createdAt: timestamp('created_at').notNull().defaultNow(),
-		uploadedAt: timestamp('uploaded_at'),
-	});
-
-	interface Database {
-		uploads: Kyselify<typeof uploads>;
-	}
-
-	const db = new Kysely<Database>({
-		dialect: new PostgresDialect({
-			pool: new Pool(),
-		}),
-	});
-
-	await db
-		.insertInto('uploads')
-		.values({
-			id: '1',
-			file_name: 'fileName',
-			file_type: 'contentType',
-			type: 'image',
-			file_size: 1,
-		})
-		.returning('id')
-		.executeTakeFirst();
-}
diff --git a/drizzle-orm/type-tests/mssql/1-to-1-fk.ts b/drizzle-orm/type-tests/mssql/1-to-1-fk.ts
new file mode 100644
index 0000000000..8a712ad2ec
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/1-to-1-fk.ts
@@ -0,0 +1,14 @@
+import { int } from '~/mssql-core/columns/index.ts';
+import { mssqlTable } from '~/mssql-core/table.ts';
+
+const test1 = mssqlTable('test1_table', {
+	id: int('id').identity().primaryKey(),
+	test2Id: int('test2_id').references(() => test2.id),
+});
+
+const test1Id = int('test1_id').references(() => test1.id);
+
+const test2 = mssqlTable('test2_table', {
+	id: int('id').identity().primaryKey(),
+	test1Id,
+});
diff --git a/drizzle-orm/type-tests/mssql/1000columns.ts b/drizzle-orm/type-tests/mssql/1000columns.ts
new file mode 100644
index 0000000000..5fc3db821f
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/1000columns.ts
@@ -0,0 +1,904 @@
+import { bigint, int, mssqlTable, varchar } from '~/mssql-core/index.ts';
+
+mssqlTable('test', {
+	col0: int('col1').primaryKey().identity(),
+	col1: int('col1').primaryKey().identity(),
+	col2: int('col1').primaryKey().identity(),
+	col3: int('col1').primaryKey().identity(),
+	col4: int('col1').primaryKey().identity(),
+	col5: int('col1').primaryKey().identity(),
+	col6: int('col1').primaryKey().identity(),
+	col8: int('col1').primaryKey().identity(),
+	col9: int('col1').primaryKey().identity(),
+	col10: int('col1').primaryKey().identity(),
+	col11: int('col1').primaryKey().identity(),
+	col12: int('col1').primaryKey().identity(),
+	col13: int('col1').primaryKey().identity(),
+	col14: int('col1').primaryKey().identity(),
+	col15: int('col1').primaryKey().identity(),
+	col16: int('col1').primaryKey().identity(),
+	col18: int('col1').primaryKey().identity(),
+	col19: int('col1').primaryKey().identity(),
+	col20: int('col1').primaryKey().identity(),
+	col21: int('col1').primaryKey().identity(),
+	col22: int('col1').primaryKey().identity(),
+	col23: int('col1').primaryKey().identity(),
+	col24: int('col1').primaryKey().identity(),
+	col25: int('col1').primaryKey().identity(),
+	col26: int('col1').primaryKey().identity(),
+	col28: int('col1').primaryKey().identity(),
+	col29: int('col1').primaryKey().identity(),
+	col30: int('col1').primaryKey().identity(),
+	col31: int('col1').primaryKey().identity(),
+	col32: int('col1').primaryKey().identity(),
+	col33: int('col1').primaryKey().identity(),
+	col34: int('col1').primaryKey().identity(),
+	col35: int('col1').primaryKey().identity(),
+	col36: int('col1').primaryKey().identity(),
+	col38: int('col1').primaryKey().identity(),
+	col39: int('col1').primaryKey().identity(),
+	col40: int('col1').primaryKey().identity(),
+	col41: int('col1').primaryKey().identity(),
+	col42: int('col1').primaryKey().identity(),
+	col43: int('col1').primaryKey().identity(),
+	col44: int('col1').primaryKey().identity(),
+	col45: int('col1').primaryKey().identity(),
+	col46: int('col1').primaryKey().identity(),
+	col48: int('col1').primaryKey().identity(),
+	col49: int('col1').primaryKey().identity(),
+	col50: int('col1').primaryKey().identity(),
+	col51: int('col1').primaryKey().identity(),
+	col52: int('col1').primaryKey().identity(),
+	col53: int('col1').primaryKey().identity(),
+	col54: int('col1').primaryKey().identity(),
+	col55: int('col1').primaryKey().identity(),
+	col56: int('col1').primaryKey().identity(),
+	col58: int('col1').primaryKey().identity(),
+	col59: int('col1').primaryKey().identity(),
+	col60: int('col1').primaryKey().identity(),
+	col61: int('col1').primaryKey().identity(),
+	col62: int('col1').primaryKey().identity(),
+	col63: int('col1').primaryKey().identity(),
+	col64: int('col1').primaryKey().identity(),
+	col65: int('col1').primaryKey().identity(),
+	col66: int('col1').primaryKey().identity(),
+	col68: int('col1').primaryKey().identity(),
+	col69: int('col1').primaryKey().identity(),
+	col70: int('col1').primaryKey().identity(),
+	col71: int('col1').primaryKey().identity(),
+	col72: int('col1').primaryKey().identity(),
+	col73: int('col1').primaryKey().identity(),
+	col74: int('col1').primaryKey().identity(),
+	col75: int('col1').primaryKey().identity(),
+	col76: int('col1').primaryKey().identity(),
+	col78: int('col1').primaryKey().identity(),
+	col79: int('col1').primaryKey().identity(),
+	col80: int('col1').primaryKey().identity(),
+	col81: int('col1').primaryKey().identity(),
+	col82: int('col1').primaryKey().identity(),
+	col83: int('col1').primaryKey().identity(),
+	col84: int('col1').primaryKey().identity(),
+	col85: int('col1').primaryKey().identity(),
+	col86: int('col1').primaryKey().identity(),
+	col88: int('col1').primaryKey().identity(),
+	col89: int('col1').primaryKey().identity(),
+	col90: int('col1').primaryKey().identity(),
+	col91: int('col1').primaryKey().identity(),
+	col92: int('col1').primaryKey().identity(),
+	col93: int('col1').primaryKey().identity(),
+	col94: int('col1').primaryKey().identity(),
+	col95: int('col1').primaryKey().identity(),
+	col96: int('col1').primaryKey().identity(),
+	col98: int('col1').primaryKey().identity(),
+	col99: int('col1').primaryKey().identity(),
+	col100: int('col1').primaryKey().identity(),
+	col101: int('col1').primaryKey().identity(),
+	col102: int('col1').primaryKey().identity(),
+	col103: int('col1').primaryKey().identity(),
+	col104: int('col1').primaryKey().identity(),
+	col105: int('col1').primaryKey().identity(),
+	col106: int('col1').primaryKey().identity(),
+	col108: int('col1').primaryKey().identity(),
+	col109: int('col1').primaryKey().identity(),
+	col110: int('col11').primaryKey().identity(),
+	col111: int('col11').primaryKey().identity(),
+	col112: int('col11').primaryKey().identity(),
+	col113: int('col11').primaryKey().identity(),
+	col114: int('col11').primaryKey().identity(),
+	col115: int('col11').primaryKey().identity(),
+	col116: int('col11').primaryKey().identity(),
+	col118: int('col11').primaryKey().identity(),
+	col119: int('col11').primaryKey().identity(),
+	col120: int('col11').primaryKey().identity(),
+	col121: int('col11').primaryKey().identity(),
+	col122: int('col11').primaryKey().identity(),
+	col123: int('col11').primaryKey().identity(),
+	col124: int('col11').primaryKey().identity(),
+	col125: int('col11').primaryKey().identity(),
+	col126: int('col11').primaryKey().identity(),
+	col128: int('col11').primaryKey().identity(),
+	col129: int('col11').primaryKey().identity(),
+	col130: int('col11').primaryKey().identity(),
+	col131: int('col11').primaryKey().identity(),
+	col132: int('col11').primaryKey().identity(),
+	col133: int('col11').primaryKey().identity(),
+	col134: int('col11').primaryKey().identity(),
+	col135: int('col11').primaryKey().identity(),
+	col136: int('col11').primaryKey().identity(),
+	col138: int('col11').primaryKey().identity(),
+	col139: int('col11').primaryKey().identity(),
+	col140: int('col11').primaryKey().identity(),
+	col141: int('col11').primaryKey().identity(),
+	col142: int('col11').primaryKey().identity(),
+	col143: int('col11').primaryKey().identity(),
+	col144: int('col11').primaryKey().identity(),
+	col145: int('col11').primaryKey().identity(),
+	col146: int('col11').primaryKey().identity(),
+	col148: int('col11').primaryKey().identity(),
+	col149: int('col11').primaryKey().identity(),
+	col150: int('col11').primaryKey().identity(),
+	col151: int('col11').primaryKey().identity(),
+	col152: int('col11').primaryKey().identity(),
+	col153: int('col11').primaryKey().identity(),
+	col154: int('col11').primaryKey().identity(),
+	col155: int('col11').primaryKey().identity(),
+	col156: int('col11').primaryKey().identity(),
+	col158: int('col11').primaryKey().identity(),
+	col159: int('col11').primaryKey().identity(),
+	col160: int('col11').primaryKey().identity(),
+	col161: int('col11').primaryKey().identity(),
+	col162: int('col11').primaryKey().identity(),
+	col163: int('col11').primaryKey().identity(),
+	col164: int('col11').primaryKey().identity(),
+	col165: int('col11').primaryKey().identity(),
+	col166: int('col11').primaryKey().identity(),
+	col168: int('col11').primaryKey().identity(),
+	col169: int('col11').primaryKey().identity(),
+	col170: int('col11').primaryKey().identity(),
+	col171: int('col11').primaryKey().identity(),
+	col172: int('col11').primaryKey().identity(),
+	col173: int('col11').primaryKey().identity(),
+	col174: int('col11').primaryKey().identity(),
+	col175: int('col11').primaryKey().identity(),
+	col176: int('col11').primaryKey().identity(),
+	col178: int('col11').primaryKey().identity(),
+	col179: int('col11').primaryKey().identity(),
+	col180: int('col11').primaryKey().identity(),
+	col181: int('col11').primaryKey().identity(),
+	col182: int('col11').primaryKey().identity(),
+	col183: int('col11').primaryKey().identity(),
+	col184: int('col11').primaryKey().identity(),
+	col185: int('col11').primaryKey().identity(),
+	col186: int('col11').primaryKey().identity(),
+	col188: int('col11').primaryKey().identity(),
+	col189: int('col11').primaryKey().identity(),
+	col190: int('col11').primaryKey().identity(),
+	col191: int('col11').primaryKey().identity(),
+	col192: int('col11').primaryKey().identity(),
+	col193: int('col11').primaryKey().identity(),
+	col194: int('col11').primaryKey().identity(),
+	col195: int('col11').primaryKey().identity(),
+	col196: int('col11').primaryKey().identity(),
+	col198: int('col11').primaryKey().identity(),
+	col199: int('col11').primaryKey().identity(),
+	col200: int('col2').primaryKey().identity(),
+	col201: int('col2').primaryKey().identity(),
+	col202: int('col2').primaryKey().identity(),
+	col203: int('col2').primaryKey().identity(),
+	col204: int('col2').primaryKey().identity(),
+	col205: int('col2').primaryKey().identity(),
+	col206: int('col2').primaryKey().identity(),
+	col208: int('col2').primaryKey().identity(),
+	col209: int('col2').primaryKey().identity(),
+	col210: int('col21').primaryKey().identity(),
+	col211: int('col21').primaryKey().identity(),
+	col212: int('col21').primaryKey().identity(),
+	col213: int('col21').primaryKey().identity(),
+	col214: int('col21').primaryKey().identity(),
+	col215: int('col21').primaryKey().identity(),
+	col216: int('col21').primaryKey().identity(),
+	col218: int('col21').primaryKey().identity(),
+	col219: int('col21').primaryKey().identity(),
+	col220: int('col21').primaryKey().identity(),
+	col221: int('col21').primaryKey().identity(),
+	col222: int('col21').primaryKey().identity(),
+	col223: int('col21').primaryKey().identity(),
+	col224: int('col21').primaryKey().identity(),
+	col225: int('col21').primaryKey().identity(),
+	col226: int('col21').primaryKey().identity(),
+	col228: int('col21').primaryKey().identity(),
+	col229: int('col21').primaryKey().identity(),
+	col230: int('col21').primaryKey().identity(),
+	col231: int('col21').primaryKey().identity(),
+	col232: int('col21').primaryKey().identity(),
+	col233: int('col21').primaryKey().identity(),
+	col234: int('col21').primaryKey().identity(),
+	col235: int('col21').primaryKey().identity(),
+	col236: int('col21').primaryKey().identity(),
+	col238: int('col21').primaryKey().identity(),
+	col239: int('col21').primaryKey().identity(),
+	col240: int('col21').primaryKey().identity(),
+	col241: int('col21').primaryKey().identity(),
+	col242: int('col21').primaryKey().identity(),
+	col243: int('col21').primaryKey().identity(),
+	col244: int('col21').primaryKey().identity(),
+	col245: int('col21').primaryKey().identity(),
+	col246: int('col21').primaryKey().identity(),
+	col248: int('col21').primaryKey().identity(),
+	col249: int('col21').primaryKey().identity(),
+	col250: int('col21').primaryKey().identity(),
+	col251: int('col21').primaryKey().identity(),
+	col252: int('col21').primaryKey().identity(),
+	col253: int('col21').primaryKey().identity(),
+	col254: int('col21').primaryKey().identity(),
+	col255: int('col21').primaryKey().identity(),
+	col256: int('col21').primaryKey().identity(),
+	col258: int('col21').primaryKey().identity(),
+	col259: int('col21').primaryKey().identity(),
+	col260: int('col21').primaryKey().identity(),
+	col261: int('col21').primaryKey().identity(),
+	col262: int('col21').primaryKey().identity(),
+	col263: int('col21').primaryKey().identity(),
+	col264: int('col21').primaryKey().identity(),
+	col265: int('col21').primaryKey().identity(),
+	col266: int('col21').primaryKey().identity(),
+	col268: int('col21').primaryKey().identity(),
+	col269: int('col21').primaryKey().identity(),
+	col270: int('col21').primaryKey().identity(),
+	col271: int('col21').primaryKey().identity(),
+	col272: int('col21').primaryKey().identity(),
+	col273: int('col21').primaryKey().identity(),
+	col274: int('col21').primaryKey().identity(),
+	col275: int('col21').primaryKey().identity(),
+	col276: int('col21').primaryKey().identity(),
+	col278: int('col21').primaryKey().identity(),
+	col279: int('col21').primaryKey().identity(),
+	col280: int('col21').primaryKey().identity(),
+	col281: int('col21').primaryKey().identity(),
+	col282: int('col21').primaryKey().identity(),
+	col283: int('col21').primaryKey().identity(),
+	col284: int('col21').primaryKey().identity(),
+	col285: int('col21').primaryKey().identity(),
+	col286: int('col21').primaryKey().identity(),
+	col288: int('col21').primaryKey().identity(),
+	col289: int('col21').primaryKey().identity(),
+	col290: int('col21').primaryKey().identity(),
+	col291: int('col21').primaryKey().identity(),
+	col292: int('col21').primaryKey().identity(),
+	col293: int('col21').primaryKey().identity(),
+	col294: int('col21').primaryKey().identity(),
+	col295: int('col21').primaryKey().identity(),
+	col296: int('col21').primaryKey().identity(),
+	col298: int('col21').primaryKey().identity(),
+	col299: int('col21').primaryKey().identity(),
+	col300: int('col3').primaryKey().identity(),
+	col301: int('col3').primaryKey().identity(),
+	col302: int('col3').primaryKey().identity(),
+	col303: int('col3').primaryKey().identity(),
+	col304: int('col3').primaryKey().identity(),
+	col305: int('col3').primaryKey().identity(),
+	col306: int('col3').primaryKey().identity(),
+	col308: int('col3').primaryKey().identity(),
+	col309: int('col3').primaryKey().identity(),
+	col310: int('col31').primaryKey().identity(),
+	col311: int('col31').primaryKey().identity(),
+	col312: int('col31').primaryKey().identity(),
+	col313: int('col31').primaryKey().identity(),
+	col314: int('col31').primaryKey().identity(),
+	col315: int('col31').primaryKey().identity(),
+	col316: int('col31').primaryKey().identity(),
+	col318: int('col31').primaryKey().identity(),
+	col319: int('col31').primaryKey().identity(),
+	col320: int('col31').primaryKey().identity(),
+	col321: int('col31').primaryKey().identity(),
+	col322: int('col31').primaryKey().identity(),
+	col323: int('col31').primaryKey().identity(),
+	col324: int('col31').primaryKey().identity(),
+	col325: int('col31').primaryKey().identity(),
+	col326: int('col31').primaryKey().identity(),
+	col328: int('col31').primaryKey().identity(),
+	col329: int('col31').primaryKey().identity(),
+	col330: int('col31').primaryKey().identity(),
+	col331: int('col31').primaryKey().identity(),
+	col332: int('col31').primaryKey().identity(),
+	col333: int('col31').primaryKey().identity(),
+	col334: int('col31').primaryKey().identity(),
+	col335: int('col31').primaryKey().identity(),
+	col336: int('col31').primaryKey().identity(),
+	col338: int('col31').primaryKey().identity(),
+	col339: int('col31').primaryKey().identity(),
+	col340: int('col31').primaryKey().identity(),
+	col341: int('col31').primaryKey().identity(),
+	col342: int('col31').primaryKey().identity(),
+	col343: int('col31').primaryKey().identity(),
+	col344: int('col31').primaryKey().identity(),
+	col345: int('col31').primaryKey().identity(),
+	col346: int('col31').primaryKey().identity(),
+	col348: int('col31').primaryKey().identity(),
+	col349: int('col31').primaryKey().identity(),
+	col350: int('col31').primaryKey().identity(),
+	col351: int('col31').primaryKey().identity(),
+	col352: int('col31').primaryKey().identity(),
+	col353: int('col31').primaryKey().identity(),
+	col354: int('col31').primaryKey().identity(),
+	col355: int('col31').primaryKey().identity(),
+	col356: int('col31').primaryKey().identity(),
+	col358: int('col31').primaryKey().identity(),
+	col359: int('col31').primaryKey().identity(),
+	col360: int('col31').primaryKey().identity(),
+	col361: int('col31').primaryKey().identity(),
+	col362: int('col31').primaryKey().identity(),
+	col363: int('col31').primaryKey().identity(),
+	col364: int('col31').primaryKey().identity(),
+	col365: int('col31').primaryKey().identity(),
+	col366: int('col31').primaryKey().identity(),
+	col368: int('col31').primaryKey().identity(),
+	col369: int('col31').primaryKey().identity(),
+	col370: int('col31').primaryKey().identity(),
+	col371: int('col31').primaryKey().identity(),
+	col372: int('col31').primaryKey().identity(),
+	col373: int('col31').primaryKey().identity(),
+	col374: int('col31').primaryKey().identity(),
+	col375: int('col31').primaryKey().identity(),
+	col376: int('col31').primaryKey().identity(),
+	col378: int('col31').primaryKey().identity(),
+	col379: int('col31').primaryKey().identity(),
+	col380: int('col31').primaryKey().identity(),
+	col381: int('col31').primaryKey().identity(),
+	col382: int('col31').primaryKey().identity(),
+	col383: int('col31').primaryKey().identity(),
+	col384: int('col31').primaryKey().identity(),
+	col385: int('col31').primaryKey().identity(),
+	col386: int('col31').primaryKey().identity(),
+	col388: int('col31').primaryKey().identity(),
+	col389: int('col31').primaryKey().identity(),
+	col390: int('col31').primaryKey().identity(),
+	col391: int('col31').primaryKey().identity(),
+	col392: int('col31').primaryKey().identity(),
+	col393: int('col31').primaryKey().identity(),
+	col394: int('col31').primaryKey().identity(),
+	col395: int('col31').primaryKey().identity(),
+	col396: int('col31').primaryKey().identity(),
+	col398: int('col31').primaryKey().identity(),
+	col399: int('col31').primaryKey().identity(),
+	col400: int('col4').primaryKey().identity(),
+	col401: int('col4').primaryKey().identity(),
+	col402: int('col4').primaryKey().identity(),
+	col403: int('col4').primaryKey().identity(),
+	col404: int('col4').primaryKey().identity(),
+	col405: int('col4').primaryKey().identity(),
+	col406: int('col4').primaryKey().identity(),
+	col408: int('col4').primaryKey().identity(),
+	col409: int('col4').primaryKey().identity(),
+	col410: int('col41').primaryKey().identity(),
+	col411: int('col41').primaryKey().identity(),
+	col412: int('col41').primaryKey().identity(),
+	col413: int('col41').primaryKey().identity(),
+	col414: int('col41').primaryKey().identity(),
+	col415: int('col41').primaryKey().identity(),
+	col416: int('col41').primaryKey().identity(),
+	col418: int('col41').primaryKey().identity(),
+	col419: int('col41').primaryKey().identity(),
+	col420: int('col41').primaryKey().identity(),
+	col421: int('col41').primaryKey().identity(),
+	col422: int('col41').primaryKey().identity(),
+	col423: int('col41').primaryKey().identity(),
+	col424: int('col41').primaryKey().identity(),
+	col425: int('col41').primaryKey().identity(),
+	col426: int('col41').primaryKey().identity(),
+	col428: int('col41').primaryKey().identity(),
+	col429: int('col41').primaryKey().identity(),
+	col430: int('col41').primaryKey().identity(),
+	col431: int('col41').primaryKey().identity(),
+	col432: int('col41').primaryKey().identity(),
+	col433: int('col41').primaryKey().identity(),
+	col434: int('col41').primaryKey().identity(),
+	col435: int('col41').primaryKey().identity(),
+	col436: int('col41').primaryKey().identity(),
+	col438: int('col41').primaryKey().identity(),
+	col439: int('col41').primaryKey().identity(),
+	col440: int('col41').primaryKey().identity(),
+	col441: int('col41').primaryKey().identity(),
+	col442: int('col41').primaryKey().identity(),
+	col443: int('col41').primaryKey().identity(),
+	col444: int('col41').primaryKey().identity(),
+	col445: int('col41').primaryKey().identity(),
+	col446: int('col41').primaryKey().identity(),
+	col448: int('col41').primaryKey().identity(),
+	col449: int('col41').primaryKey().identity(),
+	col450: int('col41').primaryKey().identity(),
+	col451: int('col41').primaryKey().identity(),
+	col452: int('col41').primaryKey().identity(),
+	col453: int('col41').primaryKey().identity(),
+	col454: int('col41').primaryKey().identity(),
+	col455: int('col41').primaryKey().identity(),
+	col456: int('col41').primaryKey().identity(),
+	col458: int('col41').primaryKey().identity(),
+	col459: int('col41').primaryKey().identity(),
+	col460: int('col41').primaryKey().identity(),
+	col461: int('col41').primaryKey().identity(),
+	col462: int('col41').primaryKey().identity(),
+	col463: int('col41').primaryKey().identity(),
+	col464: int('col41').primaryKey().identity(),
+	col465: int('col41').primaryKey().identity(),
+	col466: int('col41').primaryKey().identity(),
+	col468: int('col41').primaryKey().identity(),
+	col469: int('col41').primaryKey().identity(),
+	col470: int('col41').primaryKey().identity(),
+	col471: int('col41').primaryKey().identity(),
+	col472: int('col41').primaryKey().identity(),
+	col473: int('col41').primaryKey().identity(),
+	col474: int('col41').primaryKey().identity(),
+	col475: int('col41').primaryKey().identity(),
+	col476: int('col41').primaryKey().identity(),
+	col478: int('col41').primaryKey().identity(),
+	col479: int('col41').primaryKey().identity(),
+	col480: int('col41').primaryKey().identity(),
+	col481: int('col41').primaryKey().identity(),
+	col482: int('col41').primaryKey().identity(),
+	col483: int('col41').primaryKey().identity(),
+	col484: int('col41').primaryKey().identity(),
+	col485: int('col41').primaryKey().identity(),
+	col486: int('col41').primaryKey().identity(),
+	col488: int('col41').primaryKey().identity(),
+	col489: int('col41').primaryKey().identity(),
+	col490: int('col41').primaryKey().identity(),
+	col491: int('col41').primaryKey().identity(),
+	col492: int('col41').primaryKey().identity(),
+	col493: int('col41').primaryKey().identity(),
+	col494: int('col41').primaryKey().identity(),
+	col495: int('col41').primaryKey().identity(),
+	col496: int('col41').primaryKey().identity(),
+	col498: int('col41').primaryKey().identity(),
+	col499: int('col41').primaryKey().identity(),
+	col500: int('col5').primaryKey().identity(),
+	col501: int('col5').primaryKey().identity(),
+	col502: int('col5').primaryKey().identity(),
+	col503: int('col5').primaryKey().identity(),
+	col504: int('col5').primaryKey().identity(),
+	col505: int('col5').primaryKey().identity(),
+	col506: int('col5').primaryKey().identity(),
+	col508: int('col5').primaryKey().identity(),
+	col509: int('col5').primaryKey().identity(),
+	col510: int('col51').primaryKey().identity(),
+	col511: int('col51').primaryKey().identity(),
+	col512: int('col51').primaryKey().identity(),
+	col513: int('col51').primaryKey().identity(),
+	col514: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col515: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col516: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col518: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col519: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col520: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col521: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col522: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col523: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col524: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col525: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col526: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col528: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col529: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col530: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col531: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col532: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col533: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col534: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col535: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col536: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col538: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col539: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col540: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col541: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col542: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col543: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col544: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col545: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col546: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col548: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col549: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col550: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col551: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col552: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col553: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col554: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col555: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col556: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col558: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col559: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col560: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col561: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col562: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col563: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col564: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col565: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col566: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col568: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col569: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col570: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col571: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col572: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col573: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col574: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col575: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col576: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col578: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col579: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col580: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col581: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col582: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col583: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col584: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col585: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col586: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col588: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col589: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col590: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col591: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col592: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col593: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col594: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col595: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col596: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col598: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col599: bigint('col51', { mode: 'number' }).primaryKey().identity(),
+	col600: bigint('col6', { mode: 'number' }).primaryKey().identity(),
+	col601: int('col6').primaryKey().identity(),
+	col602: int('col6').primaryKey().identity(),
+	col603: int('col6').primaryKey().identity(),
+	col604: int('col6').primaryKey().identity(),
+	col605: int('col6').primaryKey().identity(),
+	col606: int('col6').primaryKey().identity(),
+	col608: int('col6').primaryKey().identity(),
+	col609: int('col6').primaryKey().identity(),
+	col610: int('col61').primaryKey().identity(),
+	col611: int('col61').primaryKey().identity(),
+	col612: int('col61').primaryKey().identity(),
+	col613: int('col61').primaryKey().identity(),
+	col614: int('col61').primaryKey().identity(),
+	col615: int('col61').primaryKey().identity(),
+	col616: int('col61').primaryKey().identity(),
+	col618: int('col61').primaryKey().identity(),
+	col619: int('col61').primaryKey().identity(),
+	col620: int('col61').primaryKey().identity(),
+	col621: int('col61').primaryKey().identity(),
+	col622: int('col61').primaryKey().identity(),
+	col623: int('col61').primaryKey().identity(),
+	col624: int('col61').primaryKey().identity(),
+	col625: int('col61').primaryKey().identity(),
+	col626: int('col61').primaryKey().identity(),
+	col628: int('col61').primaryKey().identity(),
+	col629: int('col61').primaryKey().identity(),
+	col630: int('col61').primaryKey().identity(),
+	col631: int('col61').primaryKey().identity(),
+	col632: int('col61').primaryKey().identity(),
+	col633: int('col61').primaryKey().identity(),
+	col634: int('col61').primaryKey().identity(),
+	col635: int('col61').primaryKey().identity(),
+	col636: int('col61').primaryKey().identity(),
+	col638: int('col61').primaryKey().identity(),
+	col639: int('col61').primaryKey().identity(),
+	col640: int('col61').primaryKey().identity(),
+	col641: int('col61').primaryKey().identity(),
+	col642: int('col61').primaryKey().identity(),
+	col643: int('col61').primaryKey().identity(),
+	col644: int('col61').primaryKey().identity(),
+	col645: int('col61').primaryKey().identity(),
+	col646: int('col61').primaryKey().identity(),
+	col648: int('col61').primaryKey().identity(),
+	col649: int('col61').primaryKey().identity(),
+	col650: int('col61').primaryKey().identity(),
+	col651: int('col61').primaryKey().identity(),
+	col652: int('col61').primaryKey().identity(),
+	col653: int('col61').primaryKey().identity(),
+	col654: int('col61').primaryKey().identity(),
+	col655: int('col61').primaryKey().identity(),
+	col656: int('col61').primaryKey().identity(),
+	col658: int('col61').primaryKey().identity(),
+	col659: int('col61').primaryKey().identity(),
+	col660: int('col61').primaryKey().identity(),
+	col661: int('col61').primaryKey().identity(),
+	col662: int('col61').primaryKey().identity(),
+	col663: int('col61').primaryKey().identity(),
+	col664: int('col61').primaryKey().identity(),
+	col665: int('col61').primaryKey().identity(),
+	col666: int('col61').primaryKey().identity(),
+	col668: int('col61').primaryKey().identity(),
+	col669: int('col61').primaryKey().identity(),
+	col670: int('col61').primaryKey().identity(),
+	col671: int('col61').primaryKey().identity(),
+	col672: int('col61').primaryKey().identity(),
+	col673: int('col61').primaryKey().identity(),
+	col674: int('col61').primaryKey().identity(),
+	col675: int('col61').primaryKey().identity(),
+	col676: int('col61').primaryKey().identity(),
+	col678: int('col61').primaryKey().identity(),
+	col679: int('col61').primaryKey().identity(),
+	col680: int('col61').primaryKey().identity(),
+	col681: int('col61').primaryKey().identity(),
+	col682: int('col61').primaryKey().identity(),
+	col683: int('col61').primaryKey().identity(),
+	col684: int('col61').primaryKey().identity(),
+	col685: int('col61').primaryKey().identity(),
+	col686: int('col61').primaryKey().identity(),
+	col688: int('col61').primaryKey().identity(),
+	col689: int('col61').primaryKey().identity(),
+	col690: int('col61').primaryKey().identity(),
+	col691: int('col61').primaryKey().identity(),
+	col692: int('col61').primaryKey().identity(),
+	col693: int('col61').primaryKey().identity(),
+	col694: int('col61').primaryKey().identity(),
+	col695: int('col61').primaryKey().identity(),
+	col696: int('col61').primaryKey().identity(),
+	col698: int('col61').primaryKey().identity(),
+	col699: int('col61').primaryKey().identity(),
+	col700: int('col7').primaryKey().identity(),
+	col701: int('col7').primaryKey().identity(),
+	col702: int('col7').primaryKey().identity(),
+	col703: int('col7').primaryKey().identity(),
+	col704: int('col7').primaryKey().identity(),
+	col705: int('col7').primaryKey().identity(),
+	col706: int('col7').primaryKey().identity(),
+	col708: int('col7').primaryKey().identity(),
+	col709: int('col7').primaryKey().identity(),
+	col710: int('col71').primaryKey().identity(),
+	col711: int('col71').primaryKey().identity(),
+	col712: int('col71').primaryKey().identity(),
+	col713: int('col71').primaryKey().identity(),
+	col714: int('col71').primaryKey().identity(),
+	col715: int('col71').primaryKey().identity(),
+	col716: int('col71').primaryKey().identity(),
+	col718: int('col71').primaryKey().identity(),
+	col719: int('col71').primaryKey().identity(),
+	col720: int('col71').primaryKey().identity(),
+	col721: int('col71').primaryKey().identity(),
+	col722: int('col71').primaryKey().identity(),
+	col723: int('col71').primaryKey().identity(),
+	col724: int('col71').primaryKey().identity(),
+	col725: int('col71').primaryKey().identity(),
+	col726: int('col71').primaryKey().identity(),
+	col728: int('col71').primaryKey().identity(),
+	col729: int('col71').primaryKey().identity(),
+	col730: int('col71').primaryKey().identity(),
+	col731: int('col71').primaryKey().identity(),
+	col732: int('col71').primaryKey().identity(),
+	col733: int('col71').primaryKey().identity(),
+	col734: int('col71').primaryKey().identity(),
+	col735: int('col71').primaryKey().identity(),
+	col736: int('col71').primaryKey().identity(),
+	col738: int('col71').primaryKey().identity(),
+	col739: int('col71').primaryKey().identity(),
+	col740: int('col71').primaryKey().identity(),
+	col741: int('col71').primaryKey().identity(),
+	col742: int('col71').primaryKey().identity(),
+	col743: int('col71').primaryKey().identity(),
+	col744: int('col71').primaryKey().identity(),
+	col745: int('col71').primaryKey().identity(),
+	col746: int('col71').primaryKey().identity(),
+	col748: int('col71').primaryKey().identity(),
+	col749: int('col71').primaryKey().identity(),
+	col750: int('col71').primaryKey().identity(),
+	col751: int('col71').primaryKey().identity(),
+	col752: int('col71').primaryKey().identity(),
+	col753: int('col71').primaryKey().identity(),
+	col754: int('col71').primaryKey().identity(),
+	col755: int('col71').primaryKey().identity(),
+	col756: int('col71').primaryKey().identity(),
+	col758: int('col71').primaryKey().identity(),
+	col759: int('col71').primaryKey().identity(),
+	col760: int('col71').primaryKey().identity(),
+	col761: int('col71').primaryKey().identity(),
+	col762: int('col71').primaryKey().identity(),
+	col763: int('col71').primaryKey().identity(),
+	col764: int('col71').primaryKey().identity(),
+	col765: int('col71').primaryKey().identity(),
+	col766: int('col71').primaryKey().identity(),
+	col768: int('col71').primaryKey().identity(),
+	col769: int('col71').primaryKey().identity(),
+	col770: int('col71').primaryKey().identity(),
+	col771: int('col71').primaryKey().identity(),
+	col772: int('col71').primaryKey().identity(),
+	col773: int('col71').primaryKey().identity(),
+	col774: int('col71').primaryKey().identity(),
+	col775: int('col71').primaryKey().identity(),
+	col776: int('col71').primaryKey().identity(),
+	col778: int('col71').primaryKey().identity(),
+	col779: int('col71').primaryKey().identity(),
+	col780: int('col71').primaryKey().identity(),
+	col781: int('col71').primaryKey().identity(),
+	col782: int('col71').primaryKey().identity(),
+	col783: int('col71').primaryKey().identity(),
+	col784: int('col71').primaryKey().identity(),
+	col785: int('col71').primaryKey().identity(),
+	col786: int('col71').primaryKey().identity(),
+	col788: int('col71').primaryKey().identity(),
+	col789: int('col71').primaryKey().identity(),
+	col790: int('col71').primaryKey().identity(),
+	col791: int('col71').primaryKey().identity(),
+	col792: int('col71').primaryKey().identity(),
+	col793: int('col71').primaryKey().identity(),
+	col794: int('col71').primaryKey().identity(),
+	col795: int('col71').primaryKey().identity(),
+	col796: int('col71').primaryKey().identity(),
+	col798: int('col71').primaryKey().identity(),
+	col799: int('col71').primaryKey().identity(),
+	col800: int('col8').primaryKey().identity(),
+	col801: int('col8').primaryKey().identity(),
+	col802: int('col8').primaryKey().identity(),
+	col803: int('col8').primaryKey().identity(),
+	col804: int('col8').primaryKey().identity(),
+	col805: int('col8').primaryKey().identity(),
+	col806: int('col8').primaryKey().identity(),
+	col808: int('col8').primaryKey().identity(),
+	col809: int('col8').primaryKey().identity(),
+	col810: int('col81').primaryKey().identity(),
+	col811: int('col81').primaryKey().identity(),
+	col812: int('col81').primaryKey().identity(),
+	col813: int('col81').primaryKey().identity(),
+	col814: int('col81').primaryKey().identity(),
+	col815: int('col81').primaryKey().identity(),
+	col816: int('col81').primaryKey().identity(),
+	col818: int('col81').primaryKey().identity(),
+	col819: int('col81').primaryKey().identity(),
+	col820: int('col81').primaryKey().identity(),
+	col821: int('col81').primaryKey().identity(),
+	col822: int('col81').primaryKey().identity(),
+	col823: int('col81').primaryKey().identity(),
+	col824: int('col81').primaryKey().identity(),
+	col825: int('col81').primaryKey().identity(),
+	col826: int('col81').primaryKey().identity(),
+	col828: int('col81').primaryKey().identity(),
+	col829: int('col81').primaryKey().identity(),
+	col830: int('col81').primaryKey().identity(),
+	col831: int('col81').primaryKey().identity(),
+	col832: int('col81').primaryKey().identity(),
+	col833: int('col81').primaryKey().identity(),
+	col834: int('col81').primaryKey().identity(),
+	col835: int('col81').primaryKey().identity(),
+	col836: int('col81').primaryKey().identity(),
+	col838: int('col81').primaryKey().identity(),
+	col839: int('col81').primaryKey().identity(),
+	col840: int('col81').primaryKey().identity(),
+	col841: int('col81').primaryKey().identity(),
+	col842: int('col81').primaryKey().identity(),
+	col843: int('col81').primaryKey().identity(),
+	col844: int('col81').primaryKey().identity(),
+	col845: int('col81').primaryKey().identity(),
+	col846: int('col81').primaryKey().identity(),
+	col848: int('col81').primaryKey().identity(),
+	col849: int('col81').primaryKey().identity(),
+	col850: int('col81').primaryKey().identity(),
+	col851: int('col81').primaryKey().identity(),
+	col852: int('col81').primaryKey().identity(),
+	col853: int('col81').primaryKey().identity(),
+	col854: int('col81').primaryKey().identity(),
+	col855: int('col81').primaryKey().identity(),
+	col856: int('col81').primaryKey().identity(),
+	col858: int('col81').primaryKey().identity(),
+	col859: int('col81').primaryKey().identity(),
+	col860: int('col81').primaryKey().identity(),
+	col861: int('col81').primaryKey().identity(),
+	col862: int('col81').primaryKey().identity(),
+	col863: int('col81').primaryKey().identity(),
+	col864: int('col81').primaryKey().identity(),
+	col865: int('col81').primaryKey().identity(),
+	col866: int('col81').primaryKey().identity(),
+	col868: int('col81').primaryKey().identity(),
+	col869: int('col81').primaryKey().identity(),
+	col870: int('col81').primaryKey().identity(),
+	col871: int('col81').primaryKey().identity(),
+	col872: int('col81').primaryKey().identity(),
+	col873: int('col81').primaryKey().identity(),
+	col874: int('col81').primaryKey().identity(),
+	col875: int('col81').primaryKey().identity(),
+	col876: int('col81').primaryKey().identity(),
+	col878: int('col81').primaryKey().identity(),
+	col879: int('col81').primaryKey().identity(),
+	col880: int('col81').primaryKey().identity(),
+	col881: int('col81').primaryKey().identity(),
+	col882: int('col81').primaryKey().identity(),
+	col883: int('col81').primaryKey().identity(),
+	col884: int('col81').primaryKey().identity(),
+	col885: int('col81').primaryKey().identity(),
+	col886: int('col81').primaryKey().identity(),
+	col888: int('col81').primaryKey().identity(),
+	col889: int('col81').primaryKey().identity(),
+	col890: int('col81').primaryKey().identity(),
+	col891: int('col81').primaryKey().identity(),
+	col892: int('col81').primaryKey().identity(),
+	col893: int('col81').primaryKey().identity(),
+	col894: int('col81').primaryKey().identity(),
+	col895: int('col81').primaryKey().identity(),
+	col896: int('col81').primaryKey().identity(),
+	col898: int('col81').primaryKey().identity(),
+	col899: int('col81').primaryKey().identity(),
+	col900: int('col9').primaryKey().identity(),
+	col901: int('col9').primaryKey().identity(),
+	col902: int('col9').primaryKey().identity(),
+	col903: int('col9').primaryKey().identity(),
+	col904: int('col9').primaryKey().identity(),
+	col905: int('col9').primaryKey().identity(),
+	col906: int('col9').primaryKey().identity(),
+	col908: int('col9').primaryKey().identity(),
+	col909: int('col9').primaryKey().identity(),
+	col910: int('col91').primaryKey().identity(),
+	col911: int('col91').primaryKey().identity(),
+	col912: int('col91').primaryKey().identity(),
+	col913: int('col91').primaryKey().identity(),
+	col914: int('col91').primaryKey().identity(),
+	col915: int('col91').primaryKey().identity(),
+	col916: int('col91').primaryKey().identity(),
+	col918: int('col91').primaryKey().identity(),
+	col919: int('col91').primaryKey().identity(),
+	col920: int('col91').primaryKey().identity(),
+	col921: int('col91').primaryKey().identity(),
+	col922: int('col91').primaryKey().identity(),
+	col923: int('col91').primaryKey().identity(),
+	col924: int('col91').primaryKey().identity(),
+	col925: int('col91').primaryKey().identity(),
+	col926: int('col91').primaryKey().identity(),
+	col928: int('col91').primaryKey().identity(),
+	col929: int('col91').primaryKey().identity(),
+	col930: int('col91').primaryKey().identity(),
+	col931: int('col91').primaryKey().identity(),
+	col932: int('col91').primaryKey().identity(),
+	col933: int('col91').primaryKey().identity(),
+	col934: int('col91').primaryKey().identity(),
+	col935: int('col91').primaryKey().identity(),
+	col936: int('col91').primaryKey().identity(),
+	col938: int('col91').primaryKey().identity(),
+	col939: int('col91').primaryKey().identity(),
+	col940: int('col91').primaryKey().identity(),
+	col941: int('col91').primaryKey().identity(),
+	col942: int('col91').primaryKey().identity(),
+	col943: int('col91').primaryKey().identity(),
+	col944: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col945: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col946: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col948: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col949: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col950: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col951: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col952: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col953: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col954: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col955: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col956: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col958: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col959: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col960: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col961: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col962: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col963: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col964: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col965: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col966: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col968: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col969: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col970: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col971: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col972: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col973: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col974: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col975: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col976: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col978: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col979: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col980: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col981: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col982: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col983: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col984: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col985: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col986: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col988: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col989: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col990: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col991: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col992: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col993: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col994: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col995: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col996: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col998: varchar('col91', { length: 200 }).primaryKey().default('0'),
+	col999: varchar('col91', { length: 200 }).primaryKey().default('0'),
+});
diff --git a/drizzle-orm/type-tests/mssql/db-rel.ts b/drizzle-orm/type-tests/mssql/db-rel.ts
new file mode 100644
index 0000000000..b5c92da690
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/db-rel.ts
@@ -0,0 +1,117 @@
+import mssql from 'mssql';
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { drizzle } from '~/node-mssql/index.ts';
+import { sql } from '~/sql/sql.ts';
+import * as schema from './tables-rel.ts';
+
+const conn = new mssql.ConnectionPool(process.env['MSSQL_CONNECTION_STRING']!);
+const db = drizzle({ client: conn, schema });
+
+{
+	const result = await db._query.users.findMany({
+		where: (users, { sql }) => sql`char_length(${users.name} > 1)`,
+		limit: sql.placeholder('l'),
+		orderBy: (users, { asc, desc }) => [asc(users.name), desc(users.id)],
+		with: {
+			posts: {
+				where: (posts, { sql }) => sql`char_length(${posts.title} > 1)`,
+				limit: sql.placeholder('l'),
+				columns: {
+					id: false,
+				},
+				with: {
+					author: true,
+					comments: {
+						where: (comments, { sql }) => sql`char_length(${comments.text} > 1)`,
+						limit: sql.placeholder('l'),
+						columns: {
+							text: true,
+						},
+						with: {
+							author: {
+								columns: {},
+								with: {
+									city: {
+										with: {
+											users: true,
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	});
+
+	Expect<
+		Equal<{
+			id: number;
+			name: string;
+			cityId: number;
+			homeCityId: number | null;
+			createdAt: Date;
+			posts: {
+				title: string;
+				authorId: number | null;
+				comments: {
+					text: string;
+					author: {
+						city: {
+							id: number;
+							name: string;
+							users: {
+								id: number;
+								name: string;
+								cityId: number;
+								homeCityId: number | null;
+								createdAt: Date;
+							}[];
+						};
+					} | null;
+				}[];
+				author: {
+					id: number;
+					name: string;
+					cityId: number;
+					homeCityId: number | null;
+					createdAt: Date;
+				} | null;
+			}[];
+		}[], typeof result>
+	>;
+}
+
+{
+	const result = await db._query.users.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					authorId: true,
+				},
+				extras: {
+					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
+				},
+			},
+		},
+	});
+
+	Expect<
+		Equal<
+			{
+				id: number;
+				name: string;
+				posts: {
+					authorId: number | null;
+					lower: string;
+				}[];
+			}[],
+			typeof result
+		>
+	>;
+}
diff --git a/drizzle-orm/type-tests/mssql/db.ts b/drizzle-orm/type-tests/mssql/db.ts
new file mode 100644
index 0000000000..36ca948794
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/db.ts
@@ -0,0 +1,11 @@
+import mssql from 'mssql';
+import { drizzle } from '~/node-mssql/index.ts';
+
+const pool = await mssql.connect({} as mssql.config);
+
+export const db = drizzle({ client: pool });
+
+{
+	drizzle({ client: pool });
+	drizzle({ client: pool, schema: {} });
+}
diff --git a/drizzle-orm/type-tests/mssql/delete.ts b/drizzle-orm/type-tests/mssql/delete.ts
new file mode 100644
index 0000000000..7ede4176bb
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/delete.ts
@@ -0,0 +1,63 @@
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { MsSqlDelete } from '~/mssql-core/index.ts';
+import { drizzle } from '~/node-mssql';
+import type { MsSqlQueryResult } from '~/node-mssql';
+import { eq } from '~/sql/expressions';
+import { sql } from '~/sql/sql.ts';
+import { users } from './tables.ts';
+
+const db = drizzle.mock();
+
+const deleteAll = await db.delete(users);
+Expect<Equal<MsSqlQueryResult, typeof deleteAll>>;
+
+const deleteAllStmt = db.delete(users).prepare();
+const deleteAllPrepared = await deleteAllStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof deleteAllPrepared>>;
+
+const deleteWhere = await db.delete(users).where(eq(users.id, 1));
+Expect<Equal<MsSqlQueryResult, typeof deleteWhere>>;
+
+const deleteWhereStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+const deleteWherePrepared = await deleteWhereStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof deleteWherePrepared>>;
+
+const deleteOutputAll = await db.delete(users).output();
+Expect<Equal<typeof users.$inferSelect[], typeof deleteOutputAll>>;
+
+const deleteOutputAllStmt = db.delete(users).output().prepare();
+const deleteOutputAllPrepared = await deleteOutputAllStmt.execute();
+Expect<Equal<typeof users.$inferSelect[], typeof deleteOutputAllPrepared>>;
+
+const deleteOutputPartial = await db.delete(users).output({ cityHome: users.homeCity });
+Expect<Equal<{ cityHome: number }[], typeof deleteOutputPartial>>;
+
+const deleteOutputPartialStmt = db.delete(users).output({ cityHome: users.homeCity }).prepare();
+const deleteOutputPartialPrepared = await deleteOutputPartialStmt.execute();
+Expect<Equal<{ cityHome: number }[], typeof deleteOutputPartialPrepared>>;
+
+{
+	function dynamic<T extends MsSqlDelete>(qb: T) {
+		return qb.where(sql``);
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<MsSqlQueryResult, typeof result>>;
+}
+
+{
+	db
+		.delete(users)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.delete(users)
+		.$dynamic()
+		.where(sql``)
+		.where(sql``);
+}
diff --git a/drizzle-orm/type-tests/mssql/insert.ts b/drizzle-orm/type-tests/mssql/insert.ts
new file mode 100644
index 0000000000..abc359d135
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/insert.ts
@@ -0,0 +1,122 @@
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { int, mssqlTable, text } from '~/mssql-core/index.ts';
+import type { MsSqlQueryResult } from '~/node-mssql';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+import { users } from './tables.ts';
+
+const insert = await db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+});
+Expect<Equal<MsSqlQueryResult, typeof insert>>;
+
+const insertStmt = db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).prepare();
+const insertPrepared = await insertStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof insertPrepared>>;
+
+const insertSql = await db.insert(users).values({
+	homeCity: sql`123`,
+	class: 'A',
+	age1: 1,
+	enumCol: sql`foobar`,
+});
+Expect<Equal<MsSqlQueryResult, typeof insertSql>>;
+
+const insertSqlStmt = db.insert(users).values({
+	homeCity: sql`123`,
+	class: 'A',
+	age1: 1,
+	enumCol: sql`foobar`,
+}).prepare();
+const insertSqlPrepared = await insertSqlStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof insertSqlPrepared>>;
+
+const insertReturning = await db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+});
+Expect<Equal<MsSqlQueryResult, typeof insertReturning>>;
+
+const insertReturningStmt = db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).prepare();
+const insertReturningPrepared = await insertReturningStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof insertReturningPrepared>>;
+
+const insertReturningPartial = await db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+});
+Expect<Equal<MsSqlQueryResult, typeof insertReturningPartial>>;
+
+const insertReturningPartialStmt = db.insert(users).values({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).prepare();
+const insertReturningPartialPrepared = await insertReturningPartialStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof insertReturningPartialPrepared>>;
+
+const insertOutputSql = await db.insert(users).output().values({
+	homeCity: 1,
+	class: 'A',
+	age1: sql`2 + 2`,
+	enumCol: 'a',
+});
+Expect<Equal<typeof users.$inferSelect[], typeof insertOutputSql>>;
+
+const insertOutputSqlStmt = db.insert(users).output().values({
+	homeCity: 1,
+	class: 'A',
+	age1: sql`2 + 2`,
+	enumCol: 'a',
+}).prepare();
+const insertReturningSqlPrepared = await insertOutputSqlStmt.execute();
+Expect<Equal<typeof users.$inferSelect[], typeof insertReturningSqlPrepared>>;
+
+const insertOutputPartialSql = await db.insert(users).output({ cityHome: users.homeCity }).values({
+	homeCity: 1,
+	class: 'A',
+	age1: sql`2 + 2`,
+	enumCol: 'a',
+});
+Expect<Equal<{ cityHome: number }[], typeof insertOutputPartialSql>>;
+
+const insertOutputPartialSqlStmt = db.insert(users).output({ cityHome: users.homeCity }).values({
+	homeCity: 1,
+	class: 'A',
+	age1: sql`2 + 2`,
+	enumCol: 'a',
+}).prepare();
+const insertOutputPartialSqlPrepared = await insertOutputPartialSqlStmt.execute();
+Expect<Equal<{ cityHome: number }[], typeof insertOutputPartialSqlPrepared>>;
+
+{
+	const users = mssqlTable('users', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		age: int('age'),
+		occupation: text('occupation'),
+	});
+
+	await db.insert(users).values({ name: 'John Wick', age: 58, occupation: 'housekeeper' });
+	// @ts-expect-error id is an identity column MsSql doesn't allow to write to it
+	await db.insert(users).values({ name: 'John Wick', age: 58, occupation: 'housekeeper', id: 1 });
+}
diff --git a/drizzle-orm/type-tests/mssql/select.ts b/drizzle-orm/type-tests/mssql/select.ts
new file mode 100644
index 0000000000..0692cc12a5
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/select.ts
@@ -0,0 +1,645 @@
+import { alias } from '~/mssql-core/alias.ts';
+import {
+	and,
+	between,
+	eq,
+	exists,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	isNotNull,
+	isNull,
+	like,
+	lt,
+	lte,
+	ne,
+	not,
+	notBetween,
+	notExists,
+	notIlike,
+	notInArray,
+	notLike,
+	or,
+} from '~/sql/expressions';
+import { type InferSelectViewModel, sql } from '~/sql/sql.ts';
+
+import type { IRecordSet } from 'mssql';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { type MsSqlSelect, type MsSqlSelectQueryBuilder, QueryBuilder } from '~/mssql-core/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, newYorkersWithSubquery, users } from './tables.ts';
+
+const city = alias(cities, 'city');
+const city1 = alias(cities, 'city1');
+
+const join = await db
+	.select({
+		users,
+		cities,
+		city,
+		city1: {
+			id: city1.id,
+		},
+	})
+	.from(users)
+	.leftJoin(cities, eq(users.id, cities.id))
+	.rightJoin(city, eq(city.id, users.id))
+	.rightJoin(city1, eq(city1.id, users.id));
+
+Expect<
+	Equal<
+		{
+			users: {
+				id: number;
+				text: string | null;
+				homeCity: number;
+				currentCity: number | null;
+				serialNullable: number;
+				serialNotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+			} | null;
+			cities: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			city: {
+				id: number;
+				name: string;
+				population: number | null;
+			} | null;
+			city1: {
+				id: number;
+			};
+		}[],
+		typeof join
+	>
+>;
+
+const join2 = await db
+	.select({
+		userId: users.id,
+		cityId: cities.id,
+	})
+	.from(users)
+	.fullJoin(cities, eq(users.id, cities.id));
+
+Expect<
+	Equal<
+		{
+			userId: number | null;
+			cityId: number | null;
+		}[],
+		typeof join2
+	>
+>;
+
+const join3 = await db
+	.select({
+		userId: users.id,
+		cityId: cities.id,
+		classId: classes.id,
+	})
+	.from(users)
+	.fullJoin(cities, eq(users.id, cities.id))
+	.rightJoin(classes, eq(users.id, classes.id));
+
+Expect<
+	Equal<
+		{
+			userId: number | null;
+			cityId: number | null;
+			classId: number;
+		}[],
+		typeof join3
+	>
+>;
+
+db
+	.select()
+	.from(users)
+	.where(exists(db.select().from(cities).where(eq(users.homeCity, cities.id))));
+
+function mapFunkyFuncResult(valueFromDriver: unknown) {
+	return {
+		foo: (valueFromDriver as Record<string, any>)['foo'],
+	};
+}
+
+const age = 1;
+
+const allOperators = await db
+	.select({
+		col2: sql`5 - ${users.id} + 1`, // unknown
+		col3: sql<number>`${users.id} + 1`, // number
+		col33: sql`${users.id} + 1`.mapWith(users.id), // number
+		col34: sql`${users.id} + 1`.mapWith(mapFunkyFuncResult), // number
+		col4: sql<string | number>`one_or_another(${users.id}, ${users.class})`, // string | number
+		col5: sql`true`, // unknown
+		col6: sql<boolean>`true`, // boolean
+		col7: sql<number>`random()`, // number
+		col8: sql`some_funky_func(${users.id})`.mapWith(mapFunkyFuncResult), // { foo: string }
+		col9: sql`greatest(${users.createdAt}, ${sql.param(new Date(), users.createdAt)})`, // unknown
+		col10: sql<Date | boolean>`date_or_false(${users.createdAt}, ${sql.param(new Date(), users.createdAt)})`, // Date | boolean
+		col11: sql`${users.age1} + ${age}`, // unknown
+		col12: sql`${users.age1} + ${sql.param(age, users.age1)}`, // unknown
+		col13: sql`lower(${users.class})`, // unknown
+		col14: sql<number>`length(${users.class})`, // number
+		count: sql<number>`count(*)::int`, // number
+	})
+	.from(users)
+	.where(and(
+		eq(users.id, 1),
+		ne(users.id, 1),
+		or(eq(users.id, 1), ne(users.id, 1)),
+		not(eq(users.id, 1)),
+		gt(users.id, 1),
+		gte(users.id, 1),
+		lt(users.id, 1),
+		lte(users.id, 1),
+		inArray(users.id, [1, 2, 3]),
+		inArray(users.id, db.select({ id: users.id }).from(users)),
+		inArray(users.id, sql`select id from ${users}`),
+		notInArray(users.id, [1, 2, 3]),
+		notInArray(users.id, db.select({ id: users.id }).from(users)),
+		notInArray(users.id, sql`select id from ${users}`),
+		isNull(users.subClass),
+		isNotNull(users.id),
+		exists(db.select({ id: users.id }).from(users)),
+		exists(sql`select id from ${users}`),
+		notExists(db.select({ id: users.id }).from(users)),
+		notExists(sql`select id from ${users}`),
+		between(users.id, 1, 2),
+		notBetween(users.id, 1, 2),
+		like(users.id, '%1%'),
+		notLike(users.id, '%1%'),
+		ilike(users.id, '%1%'),
+		notIlike(users.id, '%1%'),
+	));
+
+Expect<
+	Equal<{
+		col2: unknown;
+		col3: number;
+		col33: number;
+		col34: { foo: any };
+		col4: string | number;
+		col5: unknown;
+		col6: boolean;
+		col7: number;
+		col8: {
+			foo: any;
+		};
+		col9: unknown;
+		col10: boolean | Date;
+		col11: unknown;
+		col12: unknown;
+		col13: unknown;
+		col14: number;
+		count: number;
+	}[], typeof allOperators>
+>;
+
+const textSelect = await db
+	.select({
+		t: users.text,
+	})
+	.from(users);
+
+Expect<Equal<{ t: string | null }[], typeof textSelect>>;
+
+const homeCity = alias(cities, 'homeCity');
+const c = alias(classes, 'c');
+const otherClass = alias(classes, 'otherClass');
+const anotherClass = alias(classes, 'anotherClass');
+const friend = alias(users, 'friend');
+const currentCity = alias(cities, 'currentCity');
+const subscriber = alias(users, 'subscriber');
+const closestCity = alias(cities, 'closestCity');
+
+const megaJoin = await db
+	.select({
+		user: {
+			id: users.id,
+			maxAge: sql`max(${users.age1})`,
+		},
+		city: {
+			id: cities.id,
+		},
+		homeCity,
+		c,
+		otherClass,
+		anotherClass,
+		friend,
+		currentCity,
+		subscriber,
+		closestCity,
+	})
+	.from(users)
+	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
+	.innerJoin(homeCity, sql`${users.homeCity} = ${homeCity.id}`)
+	.innerJoin(c, eq(c.id, users.class))
+	.innerJoin(otherClass, sql`${c.id} = ${otherClass.id}`)
+	.innerJoin(anotherClass, sql`${users.class} = ${anotherClass.id}`)
+	.innerJoin(friend, sql`${users.id} = ${friend.id}`)
+	.innerJoin(currentCity, sql`${homeCity.id} = ${currentCity.id}`)
+	.innerJoin(subscriber, sql`${users.class} = ${subscriber.id}`)
+	.innerJoin(closestCity, sql`${users.currentCity} = ${closestCity.id}`)
+	.where(and(sql`${users.age1} > 0`, eq(cities.id, 1)))
+	.orderBy(users.id)
+	.offset(1)
+	.fetch(1);
+
+Expect<
+	Equal<
+		{
+			user: {
+				id: number;
+				maxAge: unknown;
+			};
+			city: {
+				id: number;
+			};
+			homeCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+			c: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			otherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			anotherClass: {
+				id: number;
+				class: 'A' | 'C' | null;
+				subClass: 'B' | 'D';
+			};
+			friend: {
+				id: number;
+				homeCity: number;
+				currentCity: number | null;
+				serialNullable: number;
+				serialNotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+			};
+			currentCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+			subscriber: {
+				id: number;
+				homeCity: number;
+				currentCity: number | null;
+				serialNullable: number;
+				serialNotNull: number;
+				class: 'A' | 'C';
+				subClass: 'B' | 'D' | null;
+				text: string | null;
+				age1: number;
+				createdAt: Date;
+				enumCol: 'a' | 'b' | 'c';
+			};
+			closestCity: {
+				id: number;
+				name: string;
+				population: number | null;
+			};
+		}[],
+		typeof megaJoin
+	>
+>;
+
+const friends = alias(users, 'friends');
+
+const join4 = await db
+	.select({
+		user: {
+			id: users.id,
+		},
+		city: {
+			id: cities.id,
+		},
+		class: classes,
+		friend: friends,
+	})
+	.from(users)
+	.innerJoin(cities, sql`${users.id} = ${cities.id}`)
+	.innerJoin(classes, sql`${cities.id} = ${classes.id}`)
+	.innerJoin(friends, sql`${friends.id} = ${users.id}`)
+	.where(sql`${users.age1} > 0`);
+
+Expect<
+	Equal<{
+		user: {
+			id: number;
+		};
+		city: {
+			id: number;
+		};
+		class: {
+			id: number;
+			class: 'A' | 'C' | null;
+			subClass: 'B' | 'D';
+		};
+		friend: {
+			id: number;
+			homeCity: number;
+			currentCity: number | null;
+			serialNullable: number;
+			serialNotNull: number;
+			class: 'A' | 'C';
+			subClass: 'B' | 'D' | null;
+			text: string | null;
+			age1: number;
+			createdAt: Date;
+			enumCol: 'a' | 'b' | 'c';
+		};
+	}[], typeof join4>
+>;
+
+{
+	const authenticated = false as boolean;
+
+	const result = await db
+		.select({
+			id: users.id,
+			...(authenticated ? { city: users.homeCity } : {}),
+		})
+		.from(users);
+
+	Expect<
+		Equal<
+			{
+				id: number;
+				city?: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+await db.select().from(users);
+
+{
+	const result = await db.select().from(newYorkers);
+	Expect<
+		Equal<
+			{
+				userId: number;
+				cityId: number | null;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select({ userId: newYorkers.userId }).from(newYorkers);
+	Expect<
+		Equal<
+			{
+				userId: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select().from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				id: number;
+				class: 'A' | 'C';
+				cityCount: number;
+				lastCityId: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery>[]>>;
+}
+
+{
+	const result = await db.select({ cityCount: newYorkersWithSubquery.cityCount }).from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const query = db.select().from(users).prepare().iterator();
+	for await (const row of query) {
+		Expect<Equal<typeof users.$inferSelect, typeof row>>();
+	}
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.orderBy(users.id)
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+}
+
+{
+	function withFriends<T extends MsSqlSelect>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function withFriends<T extends MsSqlSelectQueryBuilder>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function dynamic<T extends MsSqlSelect>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).offset(1).fetch(10);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	// TODO: add to docs
+	function dynamic<T extends MsSqlSelectQueryBuilder>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).offset(1);
+	}
+
+	const query = new QueryBuilder().select().from(users).$dynamic();
+	dynamic(query);
+}
+
+{
+	// TODO: add to docs
+	function paginated<T extends MsSqlSelect>(qb: T, page: number) {
+		return qb.orderBy(sql`1`).offset((page - 1) * 10).fetch(10);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await paginated(qb, 1);
+
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		.orderBy(users.id)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.select()
+		.from(users)
+		.having(sql``)
+		.orderBy(users.id)
+		// @ts-expect-error method was already called
+		.having(sql``);
+
+	db
+		.select()
+		.from(users)
+		.groupBy(sql``)
+		// @ts-expect-error method was already called
+		.groupBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.orderBy(sql``)
+		// @ts-expect-error method was already called
+		.orderBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		// @ts-expect-error method doesn't actually exists
+		.limit(10);
+
+	db
+		.select()
+		.from(users)
+		// @ts-expect-error method can not be called before order by
+		.offset();
+
+	db
+		.select()
+		.from(users)
+		.orderBy()
+		.offset(5)
+		.fetch(2);
+
+	db
+		.select()
+		.top(2)
+		.from(users)
+		.orderBy()
+		// @ts-expect-error method can not be called if top method used
+		.offset(10);
+}
+
+{
+	const result = await db.execute<{ name: string | null }[]>(sql`select name from users`);
+
+	Expect<
+		Equal<typeof result, {
+			recordset: IRecordSet<{ name: string | null }>;
+			recordsets: IRecordSet<{ name: string | null }>[];
+			output: { [key: string]: any };
+			rowsAffected: number[];
+		}>
+	>;
+}
diff --git a/drizzle-orm/type-tests/mssql/set-operators.ts b/drizzle-orm/type-tests/mssql/set-operators.ts
new file mode 100644
index 0000000000..6aa0fafe22
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/set-operators.ts
@@ -0,0 +1,274 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { except, intersect, type MsSqlSetOperator, union, unionAll } from '~/mssql-core/index.ts';
+import { eq } from '~/sql/expressions';
+import { desc, sql } from '~/sql/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, users } from './tables.ts';
+
+const unionTest = await db
+	.select({ id: users.id })
+	.from(users)
+	.union(
+		db
+			.select({ id: users.id })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number }[], typeof unionTest>>;
+
+const unionAllTest = await db
+	.select({ id: users.id, age: users.age1 })
+	.from(users)
+	.unionAll(
+		db.select({ id: users.id, age: users.age1 })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; age: number }[], typeof unionAllTest>>;
+
+const intersectTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select({ id: users.id, homeCity: users.homeCity })
+				.from(users),
+			db
+				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+				.from(users),
+		)
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
+
+const intersectAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.intersect(
+		db
+			.select({ id: users.id, homeCity: users.class })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof intersectAllTest>>;
+
+const exceptTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
+
+const exceptAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
+
+const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
+
+const unionAll2Test = await unionAll(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select().from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
+
+const intersect2Test = await intersect(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
+
+const intersectAll2Test = await intersect(
+	union(
+		db.select({
+			id: cities.id,
+		}).from(cities),
+		db.select({
+			id: cities.id,
+		})
+			.from(cities).where(sql``),
+	),
+	db.select({
+		id: cities.id,
+	})
+		.from(cities),
+).orderBy(desc(cities.id)).offset(0).fetch(23);
+
+Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
+
+const except2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number }[], typeof except2Test>>;
+
+const exceptAll2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	})
+		.from(newYorkers).where(sql``),
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	}).from(newYorkers).leftJoin(users, sql``),
+);
+
+Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
+
+const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).offset(0).fetch(23);
+
+Expect<
+	Equal<{
+		id: number;
+		text: string | null;
+		homeCity: number;
+		currentCity: number | null;
+		serialNullable: number;
+		serialNotNull: number;
+		class: 'A' | 'C';
+		subClass: 'B' | 'D' | null;
+		age1: number;
+		createdAt: Date;
+		enumCol: 'a' | 'b' | 'c';
+	}[], typeof unionfull>
+>;
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	.offset(0)
+	// @ts-expect-error - method was already called
+	.offset(0);
+
+{
+	function dynamic<T extends MsSqlSetOperator>(qb: T) {
+		return qb.orderBy(sql``).offset(1).offset(2);
+	}
+
+	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
+
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select().from(cities),
+);
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).orderBy(users.id).$dynamic(),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: newYorkers.userId }).from(newYorkers),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities).where(sql``),
+	db.select({ id: sql<number>`${cities.id}` }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
+);
diff --git a/drizzle-orm/type-tests/mssql/subquery.ts b/drizzle-orm/type-tests/mssql/subquery.ts
new file mode 100644
index 0000000000..a5000f4048
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/subquery.ts
@@ -0,0 +1,97 @@
+import { Expect } from 'type-tests/utils.ts';
+import { alias, int, mssqlTable, text } from '~/mssql-core/index.ts';
+import { and, eq } from '~/sql/expressions';
+import { sql } from '~/sql/sql.ts';
+import type { DrizzleTypeError, Equal } from '~/utils.ts';
+import { db } from './db.ts';
+
+const names = mssqlTable('names', {
+	id: int('id').identity().primaryKey(),
+	name: text('name'),
+	authorId: int('author_id'),
+});
+
+const n1 = db
+	.select({
+		id: names.id,
+		name: names.name,
+		authorId: names.authorId,
+		count1: sql<number>`count(1)::int`.as('count1'),
+	})
+	.from(names)
+	.groupBy(names.id, names.name, names.authorId)
+	.as('n1');
+
+const n2 = db
+	.select({
+		id: names.id,
+		authorId: names.authorId,
+		totalCount: sql<number>`count(1)::int`.as('totalCount'),
+	})
+	.from(names)
+	.groupBy(names.id, names.authorId)
+	.as('n2');
+
+const result = await db
+	.select({
+		name: n1.name,
+		authorId: n1.authorId,
+		count1: n1.count1,
+		totalCount: n2.totalCount,
+	})
+	.from(n1)
+	.innerJoin(n2, and(eq(n2.id, n1.id), eq(n2.authorId, n1.authorId)));
+
+Expect<
+	Equal<
+		{
+			name: string | null;
+			authorId: number | null;
+			count1: number;
+			totalCount: number;
+		}[],
+		typeof result
+	>
+>;
+
+const names2 = alias(names, 'names2');
+
+const sq1 = db
+	.select({
+		id: names.id,
+		name: names.name,
+		id2: names2.id,
+	})
+	.from(names)
+	.leftJoin(names2, eq(names.name, names2.name))
+	.as('sq1');
+
+const res = await db.select().from(sq1);
+
+Expect<
+	Equal<
+		{
+			id: number;
+			name: string | null;
+			id2: number | null;
+		}[],
+		typeof res
+	>
+>;
+
+{
+	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
+	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
+}
+
+const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+
+const resUnion = await db.select().from(sqUnion);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		authorId: number | null;
+	}[], typeof resUnion>
+>;
diff --git a/drizzle-orm/type-tests/mssql/tables-rel.ts b/drizzle-orm/type-tests/mssql/tables-rel.ts
new file mode 100644
index 0000000000..9428466a4f
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/tables-rel.ts
@@ -0,0 +1,79 @@
+import { relations } from '~/_relations.ts';
+import { datetime, foreignKey, int, mssqlTable, text } from '~/mssql-core/index.ts';
+
+export const users = mssqlTable('users', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id').references(() => cities.id).notNull(),
+	homeCityId: int('home_city_id').references(() => cities.id),
+	createdAt: datetime('created_at').notNull(),
+});
+export const usersConfig = relations(users, ({ one, many }) => ({
+	city: one(cities, { relationName: 'UsersInCity', fields: [users.cityId], references: [cities.id] }),
+	homeCity: one(cities, { fields: [users.homeCityId], references: [cities.id] }),
+	posts: many(posts),
+	comments: many(comments),
+}));
+
+export const cities = mssqlTable('cities', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+});
+export const citiesConfig = relations(cities, ({ many }) => ({
+	users: many(users, { relationName: 'UsersInCity' }),
+}));
+
+export const posts = mssqlTable('posts', {
+	id: int('id').identity().primaryKey(),
+	title: text('title').notNull(),
+	authorId: int('author_id').references(() => users.id),
+});
+export const postsConfig = relations(posts, ({ one, many }) => ({
+	author: one(users, { fields: [posts.authorId], references: [users.id] }),
+	comments: many(comments),
+}));
+
+export const comments = mssqlTable('comments', {
+	id: int('id').identity().primaryKey(),
+	postId: int('post_id').references(() => posts.id).notNull(),
+	authorId: int('author_id').references(() => users.id),
+	text: text('text').notNull(),
+});
+export const commentsConfig = relations(comments, ({ one }) => ({
+	post: one(posts, { fields: [comments.postId], references: [posts.id] }),
+	author: one(users, { fields: [comments.authorId], references: [users.id] }),
+}));
+
+export const books = mssqlTable('books', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+});
+export const booksConfig = relations(books, ({ many }) => ({
+	authors: many(bookAuthors),
+}));
+
+export const bookAuthors = mssqlTable('book_authors', {
+	bookId: int('book_id').references(() => books.id).notNull(),
+	authorId: int('author_id').references(() => users.id).notNull(),
+	role: text('role').notNull(),
+});
+export const bookAuthorsConfig = relations(bookAuthors, ({ one }) => ({
+	book: one(books, { fields: [bookAuthors.bookId], references: [books.id] }),
+	author: one(users, { fields: [bookAuthors.authorId], references: [users.id] }),
+}));
+
+export const node = mssqlTable('node', {
+	id: int('id').identity().primaryKey(),
+	parentId: int('parent_id'),
+	leftId: int('left_id'),
+	rightId: int('right_id'),
+}, (node) => [
+	foreignKey({ name: 'name8', columns: [node.parentId], foreignColumns: [node.id] }),
+	foreignKey({ name: 'name9', columns: [node.leftId], foreignColumns: [node.id] }),
+	foreignKey({ name: 'name10', columns: [node.rightId], foreignColumns: [node.id] }),
+]);
+export const nodeRelations = relations(node, ({ one }) => ({
+	parent: one(node, { fields: [node.parentId], references: [node.id] }),
+	left: one(node, { fields: [node.leftId], references: [node.id] }),
+	right: one(node, { fields: [node.rightId], references: [node.id] }),
+}));
diff --git a/drizzle-orm/type-tests/mssql/tables.ts b/drizzle-orm/type-tests/mssql/tables.ts
new file mode 100644
index 0000000000..f225ab9732
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/tables.ts
@@ -0,0 +1,286 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import type { InferSelectModel } from '~/index.ts';
+import {
+	bigint,
+	char,
+	check,
+	customType,
+	date,
+	datetime,
+	decimal,
+	foreignKey,
+	index,
+	int,
+	mssqlTable,
+	nchar,
+	nvarchar,
+	primaryKey,
+	text,
+	uniqueIndex,
+	varchar,
+} from '~/mssql-core/index.ts';
+import { mssqlSchema } from '~/mssql-core/schema.ts';
+import { mssqlView } from '~/mssql-core/view.ts';
+import { eq } from '~/sql/expressions';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+
+export const users = mssqlTable(
+	'users_table',
+	{
+		id: int('id').identity().primaryKey(),
+		homeCity: int('home_city')
+			.notNull()
+			.references(() => cities.id),
+		currentCity: int('current_city').references(() => cities.id),
+		serialNullable: int('serial1').identity(),
+		serialNotNull: int('serial2').identity(),
+		class: text('class', { enum: ['A', 'C'] }).notNull(),
+		subClass: text('sub_class', { enum: ['B', 'D'] }),
+		text: text('text'),
+		age1: int('age1').notNull(),
+		createdAt: datetime('created_at', { mode: 'date' }).default(sql`current_timestamp`).notNull(),
+		enumCol: text('enum_col', { enum: ['a', 'b', 'c'] }).notNull(),
+	},
+	(users) => [
+		uniqueIndex('usersAge1Idx').on(users.class),
+		index('usersAge2Idx').on(users.class),
+		uniqueIndex('uniqueClass')
+			.on(users.class, users.subClass),
+		check('legalAge', sql`${users.age1} > 18`),
+		foreignKey({ name: 'fk_1', columns: [users.subClass], foreignColumns: [classes.subClass] }),
+		foreignKey({
+			name: 'fk_2',
+			columns: [users.class, users.subClass],
+			foreignColumns: [classes.class, classes.subClass],
+		}),
+		primaryKey({ columns: [users.age1, users.class], name: 'custom_name' }),
+	],
+);
+
+export const cities = mssqlTable('cities_table', {
+	id: int('id').identity().primaryKey(),
+	name: text('name_db').notNull(),
+	population: int('population').default(0),
+}, (cities) => [
+	index('citiesNameIdx').on(cities.id),
+]);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string;
+		population: number | null;
+	}, InferSelectModel<typeof cities>>
+>;
+
+export const customSchema = mssqlSchema('custom_schema');
+
+export const citiesCustom = customSchema.table('cities_table', {
+	id: int('id').identity().primaryKey(),
+	name: text('name_db').notNull(),
+	population: int('population').default(0),
+}, (cities) => [
+	index('citiesNameIdx').on(cities.id),
+]);
+
+export const classes = mssqlTable('classes_table', {
+	id: int('id').identity().primaryKey(),
+	class: text('class', { enum: ['A', 'C'] }),
+	subClass: text('sub_class', { enum: ['B', 'D'] }).notNull(),
+});
+
+/* export const classes2 = mssqlTable('classes_table', {
+	id: serial().primaryKey(),
+	class: text({ enum: ['A', 'C'] }).$dbName('class_db'),
+	subClass: text({ enum: ['B', 'D'] }).notNull(),
+}); */
+
+export const newYorkers = mssqlView('new_yorkers')
+	.with({ checkOption: true, encryption: false, schemaBinding: true, viewMetadata: false })
+	.as((qb) => {
+		const sq = qb
+			.$with('sq')
+			.as(
+				qb.select({ userId: users.id, cityId: cities.id })
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.homeCity))
+					.where(sql`${users.age1} > 18`),
+			);
+		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+	});
+
+export const newYorkersWithSubquery = mssqlView('new_yorkers_with_sq')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				class: users.class,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+				lastCityId: qb
+					.select({ id: cities.id })
+					.from(cities)
+					.orderBy(cities.id)
+					.offset(0)
+					.fetch(1)
+					.as('last_city'),
+			})
+			.from(users)
+	);
+
+{
+	mssqlTable('test', {
+		bigint: bigint('bigint', { mode: 'bigint' }),
+		number: bigint('number', { mode: 'number' }),
+		date: date('date').default(new Date()),
+		date2: date('date2', { mode: 'date' }).default(new Date()),
+		date3: date('date3', { mode: 'string' }).default('2020-01-01'),
+		date4: date('date4', { mode: undefined }).default(new Date()),
+		datetime: datetime('datetime').default(new Date()),
+		datetime2: datetime('datetime2', { mode: 'date' }).default(new Date()),
+		datetime3: datetime('datetime3', { mode: 'string' }).default('2020-01-01'),
+		datetime4: datetime('datetime4', { mode: undefined }).default(new Date()),
+	});
+}
+
+{
+	mssqlTable('test', {
+		col1: decimal('col1').default('1'),
+	});
+}
+
+{
+	const test = mssqlTable('test', {
+		test1: text('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test2: varchar('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test3: varchar('test', { length: 255, enum: ['a', 'b', 'c'] as const }).notNull(),
+		test4: varchar('test', { length: 255, enum: ['a', 'b', 'c'] }).notNull(),
+		test5: text('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test6: text('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test7: nvarchar('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test8: nvarchar('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test9: char('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test10: char('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test11: nchar('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test12: nchar('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test13: char('test', { enum: ['a', 'b', 'c'] as const }).notNull(),
+		test14: char('test', { enum: ['a', 'b', 'c'] }).notNull(),
+		test15: text('test').notNull(),
+	});
+	Expect<Equal<['a', 'b', 'c'], typeof test.test1.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test2.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test3.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test4.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test5.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test6.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test7.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test8.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test9.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test10.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test11.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test12.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test13.enumValues>>;
+	Expect<Equal<['a', 'b', 'c'], typeof test.test14.enumValues>>;
+	Expect<Equal<[string, ...string[]], typeof test.test15.enumValues>>;
+}
+
+{
+	const getUsersTable = <TSchema extends string>(schemaName: TSchema) => {
+		return mssqlSchema(schemaName).table('users', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+	};
+
+	const users1 = getUsersTable('id1');
+	Expect<Equal<'id1', typeof users1._.schema>>;
+
+	const users2 = getUsersTable('id2');
+	Expect<Equal<'id2', typeof users2._.schema>>;
+}
+
+{
+	const internalStaff = mssqlTable('internal_staff', {
+		userId: int('user_id').notNull(),
+	});
+
+	const customUser = mssqlTable('custom_user', {
+		id: int('id').notNull(),
+	});
+
+	const ticket = mssqlTable('ticket', {
+		staffId: int('staff_id').notNull(),
+	});
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(
+			customUser,
+			eq(internalStaff.userId, customUser.id),
+		).as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	Expect<
+		Equal<{
+			internal_staff: {
+				internal_staff: {
+					userId: number;
+				};
+				custom_user: {
+					id: number | null;
+				};
+			} | null;
+			ticket: {
+				staffId: number;
+			};
+		}[], typeof mainQuery>
+	>;
+}
+
+{
+	const newYorkers = mssqlView('new_yorkers')
+		.as((qb) => {
+			const sq = qb
+				.$with('sq')
+				.as(
+					qb.select({ userId: users.id, cityId: cities.id })
+						.from(users)
+						.leftJoin(cities, eq(cities.id, users.homeCity))
+						.where(sql`${users.age1} > 18`),
+				);
+			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+		});
+
+	await db.select().from(newYorkers).leftJoin(newYorkers, eq(newYorkers.userId, newYorkers.userId));
+}
+
+{
+	const test = mssqlTable('test', {
+		id: text('id').$defaultFn(() => crypto.randomUUID()).primaryKey(),
+	});
+
+	Expect<
+		Equal<{
+			id?: string;
+		}, typeof test.$inferInsert>
+	>;
+}
+
+{
+	mssqlTable('test', {
+		id: int('id').$default(() => 1),
+		id2: int('id').$defaultFn(() => 1),
+		// @ts-expect-error - should be number
+		id3: int('id').$default(() => '1'),
+		// @ts-expect-error - should be number
+		id4: int('id').$defaultFn(() => '1'),
+	});
+}
diff --git a/drizzle-orm/type-tests/mssql/update.ts b/drizzle-orm/type-tests/mssql/update.ts
new file mode 100644
index 0000000000..ff7847020e
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/update.ts
@@ -0,0 +1,145 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import type { MsSqlUpdate } from '~/mssql-core/index.ts';
+import type { MsSqlQueryResult } from '~/node-mssql/session.ts';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+import { users } from './tables.ts';
+
+const update = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+});
+Expect<Equal<MsSqlQueryResult, typeof update>>;
+
+const updateStmt = db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).prepare();
+const updatePrepared = await updateStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof updatePrepared>>;
+
+const updateSql = await db.update(users).set({
+	homeCity: sql`123`,
+	class: 'A',
+	age1: 1,
+	enumCol: sql`foobar`,
+});
+Expect<Equal<MsSqlQueryResult, typeof updateSql>>;
+
+const updateSqlStmt = db.update(users).set({
+	homeCity: sql`123`,
+	class: 'A',
+	age1: 1,
+	enumCol: sql`foobar`,
+}).prepare();
+const updateSqlPrepared = await updateSqlStmt.execute();
+Expect<Equal<MsSqlQueryResult, typeof updateSqlPrepared>>;
+
+const updateOutput = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output();
+Expect<Equal<typeof users.$inferSelect[], typeof updateOutput>>;
+
+const updateOutputWithTrue = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output({ deleted: true, inserted: true });
+Expect<
+	Equal<{
+		inserted: typeof users.$inferSelect;
+		deleted: typeof users.$inferSelect;
+	}[], typeof updateOutputWithTrue>
+>;
+
+const updateOutputWithTrue2 = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output({ deleted: true });
+Expect<
+	Equal<{
+		deleted: typeof users.$inferSelect;
+	}[], typeof updateOutputWithTrue2>
+>;
+
+const updateOutputWithTrue3 = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output({ inserted: true });
+Expect<
+	Equal<{
+		inserted: typeof users.$inferSelect;
+	}[], typeof updateOutputWithTrue3>
+>;
+
+const updateOutputStmt = db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output().prepare();
+const updateOutputPrepared = await updateOutputStmt.execute();
+Expect<Equal<typeof users.$inferSelect[], typeof updateOutputPrepared>>;
+
+const updateOutputPartial = await db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output({ inserted: { cityHome: users.homeCity } });
+Expect<Equal<{ inserted: { cityHome: number } }[], typeof updateOutputPartial>>;
+
+const updateOutputPartialStmt = db.update(users).set({
+	homeCity: 1,
+	class: 'A',
+	age1: 1,
+	enumCol: 'a',
+}).output({ deleted: { cityHome: users.homeCity } }).prepare();
+const updateOutputPartialPrepared = await updateOutputPartialStmt.execute();
+Expect<Equal<{ deleted: { cityHome: number } }[], typeof updateOutputPartialPrepared>>;
+
+{
+	function dynamic<T extends MsSqlUpdate>(qb: T) {
+		return qb.where(sql``);
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<MsSqlQueryResult, typeof result>>;
+}
+
+{
+	function dynamic<T extends MsSqlUpdate>(qb: T) {
+		return qb.output().where(sql``);
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	// @ts-expect-error Can't update and identity column
+	db.update(users).set({ id: 2 });
+}
diff --git a/drizzle-orm/type-tests/mssql/with.ts b/drizzle-orm/type-tests/mssql/with.ts
new file mode 100644
index 0000000000..049787dccf
--- /dev/null
+++ b/drizzle-orm/type-tests/mssql/with.ts
@@ -0,0 +1,65 @@
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import { int, mssqlTable, text } from '~/mssql-core/index.ts';
+import { gt, inArray } from '~/sql/expressions';
+import { sql } from '~/sql/sql.ts';
+import { db } from './db.ts';
+
+const orders = mssqlTable('orders', {
+	id: int('id').identity().primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull(),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+{
+	const regionalSales = db
+		.$with('regional_sales')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region),
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: orders.amount,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				),
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`sum(${orders.quantity})`,
+			productSales: sql<number>`sum(${orders.amount})`,
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)));
+
+	Expect<
+		Equal<{
+			region: string;
+			product: string;
+			productUnits: number;
+			productSales: number;
+		}[], typeof result>
+	>;
+}
diff --git a/drizzle-orm/type-tests/mysql/db-rel.ts b/drizzle-orm/type-tests/mysql/db-rel.ts
deleted file mode 100644
index 957e6c9ce5..0000000000
--- a/drizzle-orm/type-tests/mysql/db-rel.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import pg from 'pg';
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import { drizzle } from '~/node-postgres/index.ts';
-import { placeholder, sql } from '~/sql/sql.ts';
-import * as schema from './tables-rel.ts';
-
-const { Pool } = pg;
-
-const pdb = new Pool({ connectionString: process.env['PG_CONNECTION_STRING'] });
-const db = drizzle(pdb, { schema });
-
-{
-	const result = await db.query.users.findMany({
-		where: (users, { sql }) => sql`char_length(${users.name} > 1)`,
-		limit: placeholder('l'),
-		orderBy: (users, { asc, desc }) => [asc(users.name), desc(users.id)],
-		with: {
-			posts: {
-				where: (posts, { sql }) => sql`char_length(${posts.title} > 1)`,
-				limit: placeholder('l'),
-				columns: {
-					id: false,
-				},
-				with: {
-					author: true,
-					comments: {
-						where: (comments, { sql }) => sql`char_length(${comments.text} > 1)`,
-						limit: placeholder('l'),
-						columns: {
-							text: true,
-						},
-						with: {
-							author: {
-								columns: {},
-								with: {
-									city: {
-										with: {
-											users: true,
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<{
-			id: number;
-			name: string;
-			cityId: number;
-			homeCityId: number | null;
-			createdAt: Date;
-			posts: {
-				title: string;
-				authorId: number | null;
-				comments: {
-					text: string;
-					author: {
-						city: {
-							id: number;
-							name: string;
-							users: {
-								id: number;
-								name: string;
-								cityId: number;
-								homeCityId: number | null;
-								createdAt: Date;
-							}[];
-						};
-					} | null;
-				}[];
-				author: {
-					id: number;
-					name: string;
-					cityId: number;
-					homeCityId: number | null;
-					createdAt: Date;
-				} | null;
-			}[];
-		}[], typeof result>
-	>;
-}
-
-{
-	const result = await db.query.users.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					authorId: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				name: string;
-				posts: {
-					authorId: number | null;
-					lower: string;
-				}[];
-			}[],
-			typeof result
-		>
-	>;
-}
diff --git a/drizzle-orm/type-tests/mysql/db.ts b/drizzle-orm/type-tests/mysql/db.ts
index ac32f645ed..fa28b4c0b7 100644
--- a/drizzle-orm/type-tests/mysql/db.ts
+++ b/drizzle-orm/type-tests/mysql/db.ts
@@ -3,14 +3,4 @@ import { drizzle } from '~/mysql2/index.ts';
 
 const pool = createPool({});
 
-export const db = drizzle(pool);
-
-{
-	drizzle(pool);
-	// @ts-expect-error - missing mode
-	drizzle(pool, { schema: {} });
-	drizzle(pool, { schema: {}, mode: 'default' });
-	drizzle(pool, { schema: {}, mode: 'planetscale' });
-	drizzle(pool, { mode: 'default' });
-	drizzle(pool, { mode: 'planetscale' });
-}
+export const db = drizzle({ client: pool });
diff --git a/drizzle-orm/type-tests/mysql/effect.ts b/drizzle-orm/type-tests/mysql/effect.ts
new file mode 100644
index 0000000000..ccda964111
--- /dev/null
+++ b/drizzle-orm/type-tests/mysql/effect.ts
@@ -0,0 +1,292 @@
+import type { MysqlClient } from '@effect/sql-mysql2/MysqlClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { EffectDrizzleQueryError, MigratorInitError } from '~/effect-core/errors.ts';
+import { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { EffectMysql2Database } from '~/effect-mysql2/index.ts';
+import { make, makeWithDefaults } from '~/effect-mysql2/index.ts';
+import { migrate } from '~/effect-mysql2/migrator.ts';
+import { MySqlEffectDatabase } from '~/mysql-core/effect/db.ts';
+import { MySqlQueryResultHKT } from '~/mysql-core/session.ts';
+import type { EmptyRelations } from '~/relations.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { cities, users } from './tables.ts';
+
+type AsEffect<T> = T extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, R> : T;
+
+{
+	const dbEffect = makeWithDefaults();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<EffectMysql2Database<EmptyRelations> & { $client: MysqlClient }, never, MysqlClient>
+		>
+	>;
+}
+
+{
+	const dbEffect = make();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<
+				EffectMysql2Database<EmptyRelations> & { $client: MysqlClient },
+				never,
+				| import('~/effect-core/logger.ts').EffectLogger
+				| import('~/cache/core/cache-effect.ts').EffectCache
+				| MysqlClient
+			>
+		>
+	>;
+}
+
+declare const db: EffectMysql2Database<Record<string, never>>;
+
+{
+	const selectAll = db.select().from(users);
+	type SelectAllEffect = AsEffect<typeof selectAll>;
+
+	Expect<Equal<SelectAllEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const selectColumns = db.select({
+		id: users.id,
+		name: users.text,
+	}).from(users);
+	type SelectColumnsEffect = AsEffect<typeof selectColumns>;
+
+	Expect<
+		Equal<
+			SelectColumnsEffect,
+			Effect.Effect<{ id: number; name: string | null }[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const selectWithJoin = db
+		.select()
+		.from(users)
+		.leftJoin(cities, eq(users.homeCity, cities.id));
+	type SelectWithJoinEffect = AsEffect<typeof selectWithJoin>;
+
+	Expect<
+		Equal<
+			SelectWithJoinEffect,
+			Effect.Effect<
+				{
+					users_table: typeof users.$inferSelect;
+					cities_table: typeof cities.$inferSelect | null;
+				}[],
+				EffectDrizzleQueryError,
+				never
+			>
+		>
+	>;
+}
+
+{
+	const insertOne = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	});
+	type InsertOneEffect = AsEffect<typeof insertOne>;
+
+	Expect<Equal<InsertOneEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const insertReturning = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).$returningId();
+
+	type InsertReturningEffect = AsEffect<typeof insertReturning>;
+
+	Expect<
+		Equal<
+			InsertReturningEffect,
+			Effect.Effect<
+				{
+					id: number;
+					serialNullable: number;
+					serialNotNull: number;
+				}[],
+				EffectDrizzleQueryError,
+				never
+			>
+		>
+	>;
+}
+
+{
+	const insertReturningColumns = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).$returningId();
+	type InsertReturningColumnsEffect = AsEffect<typeof insertReturningColumns>;
+
+	Expect<
+		Equal<
+			InsertReturningColumnsEffect,
+			Effect.Effect<
+				{
+					id: number;
+					serialNullable: number;
+					serialNotNull: number;
+				}[],
+				EffectDrizzleQueryError,
+				never
+			>
+		>
+	>;
+}
+
+{
+	const updateAll = db.update(users).set({ text: 'updated' });
+	type UpdateAllEffect = AsEffect<typeof updateAll>;
+
+	Expect<Equal<UpdateAllEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const deleteAll = db.delete(users);
+	type DeleteAllEffect = AsEffect<typeof deleteAll>;
+
+	Expect<Equal<DeleteAllEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const txResult = db.transaction((tx) => tx.select().from(users));
+	type TxResultType = typeof txResult;
+
+	Expect<
+		Equal<TxResultType, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError | SqlError, never>>
+	>;
+}
+
+{
+	const count = db.$count(users);
+	type CountEffect = AsEffect<typeof count>;
+
+	Expect<Equal<CountEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const countFiltered = db.$count(users, eq(users.class, 'A'));
+	type CountFilteredEffect = AsEffect<typeof countFiltered>;
+
+	Expect<Equal<CountFilteredEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.execute();
+	type ExecutedEffect = AsEffect<typeof executed>;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const migrateResult = migrate(db, { migrationsFolder: './migrations' });
+	type MigrateEffect = typeof migrateResult;
+
+	Expect<
+		Equal<
+			MigrateEffect,
+			Effect.Effect<undefined, SqlError | EffectDrizzleQueryError | MigratorInitError, never>
+		>
+	>;
+}
+
+{
+	type RawExecuteType = { $brand: 'EXECUTED' };
+	const db = {} as MySqlEffectDatabase<
+		QueryEffectHKTBase & {
+			readonly error: EffectDrizzleQueryError;
+			readonly context: never;
+		},
+		MySqlQueryResultHKT & {
+			type: RawExecuteType;
+		},
+		EmptyRelations
+	>;
+
+	const p1 = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).prepare()
+		.execute();
+	const p2 = db.update(users).set({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).prepare()
+		.execute();
+	const p3 = db.delete(users).prepare()
+		.execute();
+
+	const r1 = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).execute();
+	const r2 = db.update(users).set({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).execute();
+	const r3 = db.delete(users).execute();
+
+	const d1 = Effect.suspend(() =>
+		db.insert(users).values({
+			homeCity: 1,
+			class: 'A',
+			age1: 25,
+			enumCol: 'a',
+		})
+	);
+	const d2 = Effect.suspend(() =>
+		db.update(users).set({
+			homeCity: 1,
+			class: 'A',
+			age1: 25,
+			enumCol: 'a',
+		})
+	);
+	const d3 = Effect.suspend(() => db.delete(users));
+	const d4 = Effect.suspend(() => db.execute(`somequery`));
+
+	type Expected = Effect.Effect<RawExecuteType, EffectDrizzleQueryError, never>;
+
+	Expect<Equal<typeof p1, Expected>>;
+	Expect<Equal<typeof p2, Expected>>;
+	Expect<Equal<typeof p3, Expected>>;
+
+	Expect<Equal<typeof r1, Expected>>;
+	Expect<Equal<typeof r2, Expected>>;
+	Expect<Equal<typeof r3, Expected>>;
+
+	Expect<Equal<typeof d1, Expected>>;
+	Expect<Equal<typeof d2, Expected>>;
+	Expect<Equal<typeof d3, Expected>>;
+	Expect<Equal<typeof d4, Expected>>;
+}
diff --git a/drizzle-orm/type-tests/mysql/generated-columns.ts b/drizzle-orm/type-tests/mysql/generated-columns.ts
index 56b9d44124..0f29a3d51f 100644
--- a/drizzle-orm/type-tests/mysql/generated-columns.ts
+++ b/drizzle-orm/type-tests/mysql/generated-columns.ts
@@ -1,7 +1,6 @@
 import { type Equal, Expect } from 'type-tests/utils';
 import { type InferInsertModel, type InferSelectModel, sql } from '~/index';
 import { mysqlTable, serial, text, varchar } from '~/mysql-core';
-import { drizzle } from '~/mysql2';
 import { db } from './db';
 
 const users = mysqlTable(
@@ -98,46 +97,6 @@ const users = mysqlTable(
 	>();
 }
 
-{
-	const db = drizzle({} as any, { schema: { users }, mode: 'default' });
-
-	const dbUser = await db.query.users.findFirst();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string | null;
-				upperName: string | null;
-			} | undefined,
-			typeof dbUser
-		>
-	>();
-}
-
-{
-	const db = drizzle({} as any, { schema: { users }, mode: 'default' });
-
-	const dbUser = await db.query.users.findMany();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string | null;
-				upperName: string | null;
-			}[],
-			typeof dbUser
-		>
-	>();
-}
-
 {
 	// @ts-expect-error - Can't use the fullName because it's a generated column
 	await db.insert(users).values({
diff --git a/drizzle-orm/type-tests/mysql/no-strict-null-checks/test.ts b/drizzle-orm/type-tests/mysql/no-strict-null-checks/test.ts
deleted file mode 100644
index db5a9e9505..0000000000
--- a/drizzle-orm/type-tests/mysql/no-strict-null-checks/test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { mysqlTable, text } from '~/mysql-core';
-import { drizzle } from '~/mysql2';
-
-export const test = mysqlTable(
-	'test',
-	{
-		id: text('id')
-			.primaryKey()
-			.generatedAlwaysAs('genstr'),
-		name: text('name').$defaultFn(() => '' as string),
-		title: text('title').notNull(),
-		description: text('description'),
-		dbdef: text('dbdef').default('dbdefval'),
-	},
-);
-
-const db = drizzle.mock();
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		id: '1',
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.insert(test).values({
-	// @ts-expect-error
-	id: '1',
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-});
-
-db.insert(test).values({
-	title: 'title',
-});
diff --git a/drizzle-orm/type-tests/mysql/no-strict-null-checks/tsconfig.json b/drizzle-orm/type-tests/mysql/no-strict-null-checks/tsconfig.json
deleted file mode 100644
index 6d5a4b7c0c..0000000000
--- a/drizzle-orm/type-tests/mysql/no-strict-null-checks/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"noEmit": true,
-		"strictNullChecks": false,
-		"strictPropertyInitialization": false,
-		"exactOptionalPropertyTypes": false
-	},
-	"include": ["./test.ts"]
-}
diff --git a/drizzle-orm/type-tests/mysql/select.ts b/drizzle-orm/type-tests/mysql/select.ts
index 2dc826af73..f24a8b51f6 100644
--- a/drizzle-orm/type-tests/mysql/select.ts
+++ b/drizzle-orm/type-tests/mysql/select.ts
@@ -36,8 +36,9 @@ import {
 	QueryBuilder,
 	text,
 } from '~/mysql-core/index.ts';
+import { unique } from '~/mysql-core/unique-constraint.ts';
 import { db } from './db.ts';
-import { cities, classes, newYorkers, users } from './tables.ts';
+import { cities, classes, newYorkers, newYorkersWithSubquery, users } from './tables.ts';
 
 const city = alias(cities, 'city');
 const city1 = alias(cities, 'city1');
@@ -578,6 +579,35 @@ await db
 	>;
 }
 
+{
+	const result = await db.select().from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				id: number;
+				class: 'A' | 'C';
+				cityCount: number;
+				lastCityId: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery>[]>>;
+}
+
+{
+	const result = await db.select({ cityCount: newYorkersWithSubquery.cityCount }).from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
 {
 	const query = db.select().from(users).prepare().iterator();
 	for await (const row of query) {
@@ -1186,3 +1216,28 @@ await db
 		// @ts-expect-error
 		.crossJoinLateral(view);
 }
+
+{
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	}, () => [idx]);
+	const idx = index('name_index').on(users.name);
+	const unq = unique('name_unique').on(users.name);
+	const unq_without_name = unique().on(users.name);
+
+	db.select().from(users, { useIndex: [idx, unq], forceIndex: [idx, unq], ignoreIndex: [idx, unq] });
+	db.select().from(users, { useIndex: idx, forceIndex: idx, ignoreIndex: idx });
+	db.select().from(users, { useIndex: unq, forceIndex: unq, ignoreIndex: unq });
+
+	db.select().from(users, {
+		// @ts-expect-error
+		useIndex: [unq_without_name],
+		// @ts-expect-error
+		forceIndex: [unq_without_name],
+		// @ts-expect-error
+		ignoreIndex: [unq_without_name],
+	});
+	// @ts-expect-error
+	db.select().from(users, { useIndex: unq_without_name, forceIndex: unq_without_name, ignoreIndex: unq_without_name });
+}
diff --git a/drizzle-orm/type-tests/mysql/subquery.ts b/drizzle-orm/type-tests/mysql/subquery.ts
index 1a3b64ea24..e223bf8cc7 100644
--- a/drizzle-orm/type-tests/mysql/subquery.ts
+++ b/drizzle-orm/type-tests/mysql/subquery.ts
@@ -1,35 +1,42 @@
 import { Expect } from 'type-tests/utils.ts';
 import { alias, int, mysqlTable, serial, text } from '~/mysql-core/index.ts';
 import { and, eq } from '~/sql/expressions/index.ts';
+import { count } from '~/sql/functions/aggregate.ts';
 import { sql } from '~/sql/sql.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
 
-const names = mysqlTable('names', {
+const users = mysqlTable('names', {
 	id: serial('id').primaryKey(),
 	name: text('name'),
+	managerId: int('author_id'),
+});
+
+const posts = mysqlTable('posts', {
+	id: serial('id').primaryKey(),
 	authorId: int('author_id'),
+	title: text('title'),
 });
 
 const n1 = db
 	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
+		id: users.id,
+		name: users.name,
+		authorId: users.managerId,
 		count1: sql<number>`count(1)::int`.as('count1'),
 	})
-	.from(names)
-	.groupBy(names.id, names.name, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.name, users.managerId)
 	.as('n1');
 
 const n2 = db
 	.select({
-		id: names.id,
-		authorId: names.authorId,
+		id: users.id,
+		authorId: users.managerId,
 		totalCount: sql<number>`count(1)::int`.as('totalCount'),
 	})
-	.from(names)
-	.groupBy(names.id, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.managerId)
 	.as('n2');
 
 const result = await db
@@ -54,16 +61,16 @@ Expect<
 	>
 >;
 
-const names2 = alias(names, 'names2');
+const names2 = alias(users, 'names2');
 
 const sq1 = db
 	.select({
-		id: names.id,
-		name: names.name,
+		id: users.id,
+		name: users.name,
 		id2: names2.id,
 	})
-	.from(names)
-	.leftJoin(names2, eq(names.name, names2.name))
+	.from(users)
+	.leftJoin(names2, eq(users.name, names2.name))
 	.as('sq1');
 
 const res = await db.select().from(sq1);
@@ -80,11 +87,11 @@ Expect<
 >;
 
 {
-	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
+	const sq = db.select({ count: sql<number>`count(1)::int` }).from(users).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
 
-const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+const sqUnion = db.select().from(users).union(db.select().from(names2)).as('sqUnion');
 
 const resUnion = await db.select().from(sqUnion);
 
@@ -92,6 +99,26 @@ Expect<
 	Equal<{
 		id: number;
 		name: string | null;
-		authorId: number | null;
+		managerId: number | null;
 	}[], typeof resUnion>
 >;
+
+const fromSubquery = await db.select({
+	count: db.select({ count: count().as('c') }).from(posts).where(eq(posts.authorId, users.id)).as('count'),
+}).from(users);
+
+Expect<Equal<typeof fromSubquery, { count: number }[]>>;
+
+const fromSubquery2 = await db.select({
+	name: db.select({ name: users.name }).from(users).where(eq(users.id, posts.authorId)).as('name'),
+}).from(posts);
+
+Expect<Equal<typeof fromSubquery2, { name: string | null }[]>>;
+
+const errorSubquery = await db.select({
+	name: db.select({ name: users.name, managerId: users.managerId }).from(users).where(eq(users.id, posts.authorId)).as(
+		'name',
+	),
+}).from(posts);
+
+Expect<Equal<typeof errorSubquery, { name: DrizzleTypeError<'You can only select one column in the subquery'> }[]>>;
diff --git a/drizzle-orm/type-tests/mysql/tables-rel.ts b/drizzle-orm/type-tests/mysql/tables-rel.ts
index 28c2f0191e..ac26616bb8 100644
--- a/drizzle-orm/type-tests/mysql/tables-rel.ts
+++ b/drizzle-orm/type-tests/mysql/tables-rel.ts
@@ -1,5 +1,5 @@
+import { relations } from '~/_relations.ts';
 import { foreignKey, int, mysqlTable, serial, text, timestamp } from '~/mysql-core/index.ts';
-import { relations } from '~/relations.ts';
 
 export const users = mysqlTable('users', {
 	id: serial('id').primaryKey(),
@@ -67,11 +67,11 @@ export const node = mysqlTable('node', {
 	parentId: int('parent_id'),
 	leftId: int('left_id'),
 	rightId: int('right_id'),
-}, (node) => ({
-	fk1: foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
-	fk2: foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
-	fk3: foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
-}));
+}, (node) => [
+	foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
+]);
 export const nodeRelations = relations(node, ({ one }) => ({
 	parent: one(node, { fields: [node.parentId], references: [node.id] }),
 	left: one(node, { fields: [node.leftId], references: [node.id] }),
diff --git a/drizzle-orm/type-tests/mysql/tables.ts b/drizzle-orm/type-tests/mysql/tables.ts
index 9874357fc9..2288db2087 100644
--- a/drizzle-orm/type-tests/mysql/tables.ts
+++ b/drizzle-orm/type-tests/mysql/tables.ts
@@ -1,6 +1,5 @@
 import * as crypto from 'node:crypto';
 import { type Equal, Expect } from 'type-tests/utils.ts';
-import type { BuildColumn } from '~/column-builder.ts';
 import {
 	bigint,
 	binary,
@@ -39,11 +38,10 @@ import {
 	year,
 } from '~/mysql-core/index.ts';
 import { mysqlSchema } from '~/mysql-core/schema.ts';
-import { mysqlView, type MySqlViewWithSelection } from '~/mysql-core/view.ts';
-import { eq, gt } from '~/sql/expressions/index.ts';
+import { mysqlView } from '~/mysql-core/view.ts';
+import { eq } from '~/sql/expressions/index.ts';
 import { sql } from '~/sql/sql.ts';
 import type { InferSelectModel } from '~/table.ts';
-import type { Simplify } from '~/utils.ts';
 import { db } from './db.ts';
 
 export const users = mysqlTable(
@@ -63,109 +61,38 @@ export const users = mysqlTable(
 		createdAt: timestamp('created_at', { mode: 'date' }).notNull().defaultNow(),
 		enumCol: mysqlEnum('enum_col', ['a', 'b', 'c']).notNull(),
 	},
-	(users) => ({
-		usersAge1Idx: uniqueIndex('usersAge1Idx').on(users.class),
-		usersAge2Idx: index('usersAge2Idx').on(users.class),
-		uniqueClass: uniqueIndex('uniqueClass')
+	(users) => [
+		uniqueIndex('usersAge1Idx').on(users.class),
+		index('usersAge2Idx').on(users.class),
+		uniqueIndex('uniqueClass')
 			.on(users.class, users.subClass)
 			.lock('default')
-			.algorythm('copy')
+			.algorithm('copy')
 			.using(`btree`),
-		legalAge: check('legalAge', sql`${users.age1} > 18`),
-		usersClassFK: foreignKey({ columns: [users.subClass], foreignColumns: [classes.subClass] }),
-		usersClassComplexFK: foreignKey({
+		check('legalAge', sql`${users.age1} > 18`),
+		foreignKey({ columns: [users.subClass], foreignColumns: [classes.subClass] }),
+		foreignKey({
 			columns: [users.class, users.subClass],
 			foreignColumns: [classes.class, classes.subClass],
 		}),
-		pk: primaryKey(users.age1, users.class),
-	}),
+		primaryKey({ columns: [users.age1, users.class] }),
+	],
 );
 
 export const cities = mysqlTable('cities_table', {
 	id: serial('id').primaryKey(),
 	name: text('name_db').notNull(),
 	population: int('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index('citiesNameIdx').on(cities.id),
-}));
-
-Expect<
-	Equal<
-		{
-			id: MySqlColumn<
-				{
-					name: 'id';
-					tableName: 'cities_table';
-					dataType: 'number';
-					columnType: 'MySqlSerial';
-					data: number;
-					driverParam: number;
-					notNull: true;
-					hasDefault: true;
-					isPrimaryKey: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: true;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{}
-			>;
-			name: MySqlColumn<
-				{
-					name: 'name_db';
-					tableName: 'cities_table';
-					dataType: 'string';
-					columnType: 'MySqlText';
-					data: string;
-					driverParam: string;
-					notNull: true;
-					hasDefault: false;
-					isPrimaryKey: false;
-					enumValues: [string, ...string[]];
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{}
-			>;
-			population: MySqlColumn<
-				{
-					name: 'population';
-					tableName: 'cities_table';
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					notNull: false;
-					hasDefault: true;
-					isPrimaryKey: false;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{}
-			>;
-		},
-		typeof cities._.columns
-	>
->;
+}, (cities) => [
+	index('citiesNameIdx').on(cities.id),
+]);
 
 Expect<
 	Equal<{
 		id: number;
-		name_db: string;
+		name: string;
 		population: number | null;
-	}, InferSelectModel<typeof cities, { dbColumnNames: true }>>
+	}, InferSelectModel<typeof cities>>
 >;
 
 Expect<
@@ -182,11 +109,9 @@ export const citiesCustom = customSchema.table('cities_table', {
 	id: serial('id').primaryKey(),
 	name: text('name_db').notNull(),
 	population: int('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index('citiesNameIdx').on(cities.id),
-}));
-
-Expect<Equal<typeof cities._.columns, typeof citiesCustom._.columns>>;
+}, (cities) => [
+	index('citiesNameIdx').on(cities.id),
+]);
 
 export const classes = mysqlTable('classes_table', ({ serial, text }) => ({
 	id: serial('id').primaryKey(),
@@ -215,355 +140,31 @@ export const newYorkers = mysqlView('new_yorkers')
 		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 	});
 
-Expect<
-	Equal<
-		MySqlViewWithSelection<'new_yorkers', false, {
-			userId: MySqlColumn<{
-				name: 'id';
-				dataType: 'number';
-				columnType: 'MySqlSerial';
-				data: number;
-				driverParam: number;
-				notNull: true;
-				hasDefault: true;
-				tableName: 'new_yorkers';
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: true;
-				hasRuntimeDefault: false;
-			}>;
-			cityId: MySqlColumn<{
-				name: 'id';
-				dataType: 'number';
-				columnType: 'MySqlSerial';
-				data: number;
-				driverParam: number;
-				notNull: false;
-				hasDefault: true;
-				tableName: 'new_yorkers';
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: true;
-				hasRuntimeDefault: false;
-			}>;
-		}>,
-		typeof newYorkers
-	>
->;
-
-{
-	const newYorkers = customSchema.view('new_yorkers')
-		.algorithm('merge')
-		.sqlSecurity('definer')
-		.as((qb) => {
-			const sq = qb
-				.$with('sq')
-				.as(
-					qb.select({ userId: users.id, cityId: cities.id })
-						.from(users)
-						.leftJoin(cities, eq(cities.id, users.homeCity))
-						.where(sql`${users.age1} > 18`),
-				);
-			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
-		});
-
-	Expect<
-		Equal<
-			MySqlViewWithSelection<'new_yorkers', false, {
-				userId: MySqlColumn<{
-					name: 'id';
-					dataType: 'number';
-					columnType: 'MySqlSerial';
-					data: number;
-					driverParam: number;
-					notNull: true;
-					hasDefault: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: true;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: MySqlColumn<{
-					name: 'id';
-					dataType: 'number';
-					columnType: 'MySqlSerial';
-					data: number;
-					driverParam: number;
-					notNull: false;
-					hasDefault: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: true;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
-}
-
-{
-	const newYorkers = mysqlView('new_yorkers', {
-		userId: int('user_id').notNull(),
-		cityId: int('city_id'),
-	})
-		.algorithm('merge')
-		.sqlSecurity('definer')
-		.as(
-			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
-				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
-		);
-
-	Expect<
-		Equal<
-			MySqlViewWithSelection<'new_yorkers', false, {
-				userId: MySqlColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: MySqlColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
-}
-
-{
-	const newYorkers = customSchema.view('new_yorkers', {
-		userId: int('user_id').notNull(),
-		cityId: int('city_id'),
-	})
-		.algorithm('merge')
-		.sqlSecurity('definer')
-		.as(
-			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
-				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
-		);
-
-	Expect<
-		Equal<
-			MySqlViewWithSelection<'new_yorkers', false, {
-				userId: MySqlColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: MySqlColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
-}
-
-{
-	const newYorkers = mysqlView('new_yorkers', {
-		userId: int('user_id').notNull(),
-		cityId: int('city_id'),
-	}).existing();
-
-	Expect<
-		Equal<
-			MySqlViewWithSelection<'new_yorkers', true, {
-				userId: MySqlColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: MySqlColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
-}
-
-{
-	const newYorkers = customSchema.view('new_yorkers', {
-		userId: int('user_id').notNull(),
-		cityId: int('city_id'),
-	}).existing();
-
-	Expect<
-		Equal<
-			MySqlViewWithSelection<'new_yorkers', true, {
-				userId: MySqlColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: MySqlColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'MySqlInt';
-					data: number;
-					driverParam: string | number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
-}
-
-{
-	const customText = customType<{ data: string }>({
-		dataType() {
-			return 'text';
-		},
-	});
-
-	const t = customText('name').notNull();
-	Expect<
-		Equal<
-			{
-				brand: 'Column';
-				name: 'name';
-				tableName: 'table';
-				dataType: 'custom';
-				columnType: 'MySqlCustomColumn';
-				data: string;
-				driverParam: unknown;
-				notNull: true;
-				hasDefault: false;
-				enumValues: undefined;
-				baseColumn: never;
-				dialect: 'mysql';
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: false;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			},
-			Simplify<BuildColumn<'table', typeof t, 'mysql'>['_']>
-		>
-	>;
-}
+export const newYorkersWithSubquery = mysqlView('new_yorkers_with_sq')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				class: users.class,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+				lastCityId: qb
+					.select({ id: cities.id })
+					.from(cities)
+					.orderBy(cities.id)
+					.limit(1)
+					.as('last_city'),
+			})
+			.from(users)
+	);
 
 {
 	mysqlTable('test', {
-		bigint: bigint('bigint', { mode: 'bigint' }),
-		number: bigint('number', { mode: 'number' }),
+		bigint: bigint('bigint', { mode: 'bigint' }).default(100n),
+		bigintNumber: bigint('bigint_number', { mode: 'number' }).default(100),
+		bigintString: bigint('bigint_string', { mode: 'string' }).default('100'),
 		date: date('date').default(new Date()),
 		date2: date('date2', { mode: 'date' }).default(new Date()),
 		date3: date('date3', { mode: 'string' }).default('2020-01-01'),
@@ -770,12 +371,10 @@ Expect<
 			createdAt: timestamp('created_at', { mode: 'string' }).defaultNow().notNull(),
 			updatedAt: timestamp('updated_at', { mode: 'string' }).defaultNow().onUpdateNow(),
 		},
-		(table) => {
-			return {
-				emailLogId: primaryKey({ columns: [table.id], name: 'email_log_id' }),
-				emailLogMessageIdUnique: unique('email_log_message_id_unique').on(table.messageId),
-			};
-		},
+		(table) => [
+			primaryKey({ columns: [table.id] }),
+			unique('email_log_message_id_unique').on(table.messageId),
+		],
 	);
 
 	Expect<
@@ -954,8 +553,8 @@ Expect<
 		name: text(),
 	});
 
-	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], 'id'>>;
-	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], 'name'>>;
+	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], string>>;
+	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], string>>;
 }
 
 {
diff --git a/drizzle-orm/type-tests/pg/array-dimensions.ts b/drizzle-orm/type-tests/pg/array-dimensions.ts
new file mode 100644
index 0000000000..581732bfe0
--- /dev/null
+++ b/drizzle-orm/type-tests/pg/array-dimensions.ts
@@ -0,0 +1,84 @@
+// Test: array column types with new dimension notation
+import { integer, pgTable, text } from '~/pg-core/index.ts';
+import type { InferInsertModel, InferSelectModel } from '~/table.ts';
+import type { Equal } from '../utils.ts';
+import { Expect } from '../utils.ts';
+
+// Test 1D array
+const table1D = pgTable('table_1d', {
+	id: integer().primaryKey(),
+	tags: text().array('[]').notNull(),
+	scores: integer().array('[]'),
+});
+
+// Test 2D array
+const table2D = pgTable('table_2d', {
+	id: integer().primaryKey(),
+	matrix: integer().array('[][]').notNull(),
+});
+
+// Test 3D array
+const table3D = pgTable('table_3d', {
+	id: integer().primaryKey(),
+	cube: integer().array('[][][]'),
+});
+
+// Infer types
+type Table1DSelect = InferSelectModel<typeof table1D>;
+type Table1DInsert = InferInsertModel<typeof table1D>;
+
+type Table2DSelect = InferSelectModel<typeof table2D>;
+type Table2DInsert = InferInsertModel<typeof table2D>;
+
+type Table3DSelect = InferSelectModel<typeof table3D>;
+type _Table3DInsert = InferInsertModel<typeof table3D>;
+
+// 1D array assertions
+Expect<Equal<Table1DSelect['tags'], string[]>>();
+Expect<Equal<Table1DSelect['scores'], number[] | null>>();
+
+// Insert model - tags should be required (notNull), scores should be optional
+Expect<Equal<Table1DInsert['tags'], string[]>>();
+
+// 2D array assertions
+Expect<Equal<Table2DSelect['matrix'], number[][]>>();
+Expect<Equal<Table2DInsert['matrix'], number[][]>>();
+
+// 3D array assertions (nullable)
+Expect<Equal<Table3DSelect['cube'], number[][][] | null>>();
+
+// Test chaining with other modifiers
+const tableChained = pgTable('table_chained', {
+	id: integer().primaryKey(),
+	// array + notNull
+	tags: text().array('[]').notNull(),
+	// notNull + array (different order) - should still work
+	tags2: text().notNull().array('[]'),
+});
+
+type TableChainedSelect = InferSelectModel<typeof tableChained>;
+
+// Both should be string[] (not null)
+Expect<Equal<TableChainedSelect['tags'], string[]>>();
+Expect<Equal<TableChainedSelect['tags2'], string[]>>();
+
+// Test with $type modifier
+const tableWithType = pgTable('table_with_type', {
+	id: integer().primaryKey(),
+	// Should be MyTag[] not string[]
+	customTags: text().$type<'tag1' | 'tag2'>().array('[]').notNull(),
+});
+
+type TableWithTypeSelect = InferSelectModel<typeof tableWithType>;
+Expect<Equal<TableWithTypeSelect['customTags'], ('tag1' | 'tag2')[]>>();
+
+// Test 4D and 5D arrays
+const tableHighDim = pgTable('table_high_dim', {
+	id: integer().primaryKey(),
+	dim4: integer().array('[][][][]').notNull(),
+	dim5: integer().array('[][][][][]').notNull(),
+});
+
+type TableHighDimSelect = InferSelectModel<typeof tableHighDim>;
+Expect<Equal<TableHighDimSelect['dim4'], number[][][][]>>();
+Expect<Equal<TableHighDimSelect['dim5'], number[][][][][]>>();
diff --git a/drizzle-orm/type-tests/pg/array.ts b/drizzle-orm/type-tests/pg/array.ts
index d7a34cb2b7..d00c46b580 100644
--- a/drizzle-orm/type-tests/pg/array.ts
+++ b/drizzle-orm/type-tests/pg/array.ts
@@ -1,35 +1,7 @@
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import type { Column } from '~/column.ts';
 import { integer, pgTable } from '~/pg-core/index.ts';
 
 {
-	const table = pgTable('table', {
+	const _table = pgTable('table', {
 		a: integer('a').array().notNull(),
 	});
-	Expect<
-		Equal<
-			Column<
-				{
-					name: 'a';
-					tableName: 'table';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					notNull: false;
-					hasDefault: false;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				},
-				{},
-				{}
-			>,
-			typeof table['a']['_']['baseColumn']
-		>
-	>;
 }
diff --git a/drizzle-orm/type-tests/pg/db-rel.ts b/drizzle-orm/type-tests/pg/db-rel.ts
deleted file mode 100644
index c8cc63c7fe..0000000000
--- a/drizzle-orm/type-tests/pg/db-rel.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import pg from 'pg';
-import { type Equal, Expect } from 'type-tests/utils.ts';
-import { drizzle } from '~/node-postgres/index.ts';
-import { sql } from '~/sql/sql.ts';
-import * as schema from './tables-rel.ts';
-
-const { Pool } = pg;
-
-const pdb = new Pool({ connectionString: process.env['PG_CONNECTION_STRING'] });
-const db = drizzle(pdb, { schema });
-
-{
-	const result = await db.query.users.findMany({
-		where: (users, { sql }) => sql`char_length(${users.name} > 1)`,
-		limit: sql.placeholder('l'),
-		orderBy: (users, { asc, desc }) => [asc(users.name), desc(users.id)],
-		with: {
-			posts: {
-				where: (posts, { sql }) => sql`char_length(${posts.title} > 1)`,
-				limit: sql.placeholder('l'),
-				columns: {
-					id: false,
-					title: undefined,
-				},
-				with: {
-					author: true,
-					comments: {
-						where: (comments, { sql }) => sql`char_length(${comments.text} > 1)`,
-						limit: sql.placeholder('l'),
-						columns: {
-							text: true,
-						},
-						with: {
-							author: {
-								columns: {
-									id: undefined,
-								},
-								with: {
-									city: {
-										with: {
-											users: true,
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<{
-			id: number;
-			name: string;
-			cityId: number;
-			homeCityId: number | null;
-			createdAt: Date;
-			posts: {
-				title: string;
-				authorId: number | null;
-				comments: {
-					text: string;
-					author: {
-						city: {
-							id: number;
-							name: string;
-							users: {
-								id: number;
-								name: string;
-								cityId: number;
-								homeCityId: number | null;
-								createdAt: Date;
-							}[];
-						};
-					} | null;
-				}[];
-				author: {
-					id: number;
-					name: string;
-					cityId: number;
-					homeCityId: number | null;
-					createdAt: Date;
-				} | null;
-			}[];
-		}[], typeof result>
-	>;
-}
-
-{
-	const result = await db.query.users.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					authorId: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				name: string;
-				posts: {
-					authorId: number | null;
-					lower: string;
-				}[];
-			}[],
-			typeof result
-		>
-	>;
-}
diff --git a/drizzle-orm/type-tests/pg/db.ts b/drizzle-orm/type-tests/pg/db.ts
index 8cdd301166..f1603f11d2 100644
--- a/drizzle-orm/type-tests/pg/db.ts
+++ b/drizzle-orm/type-tests/pg/db.ts
@@ -3,4 +3,4 @@ import { drizzle } from '~/node-postgres/index.ts';
 
 const { Client } = pg;
 
-export const db = drizzle(new Client());
+export const db = drizzle({ client: new Client() });
diff --git a/drizzle-orm/type-tests/pg/effect.ts b/drizzle-orm/type-tests/pg/effect.ts
new file mode 100644
index 0000000000..72a0d445b3
--- /dev/null
+++ b/drizzle-orm/type-tests/pg/effect.ts
@@ -0,0 +1,308 @@
+import type { PgClient } from '@effect/sql-pg/PgClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { EffectDrizzleQueryError, MigratorInitError } from '~/effect-core/errors.ts';
+import { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { EffectPgDatabase } from '~/effect-postgres/index.ts';
+import { make, makeWithDefaults } from '~/effect-postgres/index.ts';
+import { migrate } from '~/effect-postgres/migrator.ts';
+import { PgEffectDatabase } from '~/pg-core/effect/db.ts';
+import { PgQueryResultHKT } from '~/pg-core/session.ts';
+import type { EmptyRelations } from '~/relations.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { cities, users } from './tables.ts';
+
+type AsEffect<T> = T extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, R> : T;
+
+{
+	const dbEffect = makeWithDefaults();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<EffectPgDatabase<EmptyRelations> & { $client: PgClient }, never, PgClient>
+		>
+	>;
+}
+
+{
+	const dbEffect = make();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<
+				EffectPgDatabase<EmptyRelations> & { $client: PgClient },
+				never,
+				import('~/effect-core/logger.ts').EffectLogger | import('~/cache/core/cache-effect.ts').EffectCache | PgClient
+			>
+		>
+	>;
+}
+
+declare const db: EffectPgDatabase<Record<string, never>>;
+
+{
+	const selectAll = db.select().from(users);
+	type SelectAllEffect = AsEffect<typeof selectAll>;
+
+	Expect<Equal<SelectAllEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const selectColumns = db.select({
+		id: users.id,
+		name: users.text,
+	}).from(users);
+	type SelectColumnsEffect = AsEffect<typeof selectColumns>;
+
+	Expect<
+		Equal<
+			SelectColumnsEffect,
+			Effect.Effect<{ id: number; name: string | null }[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const selectWithJoin = db
+		.select()
+		.from(users)
+		.leftJoin(cities, eq(users.homeCity, cities.id));
+	type SelectWithJoinEffect = AsEffect<typeof selectWithJoin>;
+
+	Expect<
+		Equal<
+			SelectWithJoinEffect,
+			Effect.Effect<
+				{
+					users_table: typeof users.$inferSelect;
+					cities_table: typeof cities.$inferSelect | null;
+				}[],
+				EffectDrizzleQueryError,
+				never
+			>
+		>
+	>;
+}
+
+{
+	const insertOne = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	});
+	type InsertOneEffect = AsEffect<typeof insertOne>;
+
+	Expect<Equal<InsertOneEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const insertReturning = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).returning();
+	type InsertReturningEffect = AsEffect<typeof insertReturning>;
+
+	Expect<
+		Equal<InsertReturningEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>
+	>;
+}
+
+{
+	const insertReturningColumns = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).returning({ id: users.id, text: users.text });
+	type InsertReturningColumnsEffect = AsEffect<typeof insertReturningColumns>;
+
+	Expect<
+		Equal<
+			InsertReturningColumnsEffect,
+			Effect.Effect<{ id: number; text: string | null }[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const updateAll = db.update(users).set({ text: 'updated' });
+	type UpdateAllEffect = AsEffect<typeof updateAll>;
+
+	Expect<Equal<UpdateAllEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const updateWithReturning = db.update(users)
+		.set({ text: 'updated' })
+		.where(eq(users.id, 1))
+		.returning();
+	type UpdateWithReturningEffect = AsEffect<typeof updateWithReturning>;
+
+	Expect<
+		Equal<
+			UpdateWithReturningEffect,
+			Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const deleteAll = db.delete(users);
+	type DeleteAllEffect = AsEffect<typeof deleteAll>;
+
+	Expect<Equal<DeleteAllEffect, Effect.Effect<readonly never[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const deleteWithReturning = db.delete(users)
+		.where(eq(users.id, 1))
+		.returning();
+	type DeleteWithReturningEffect = AsEffect<typeof deleteWithReturning>;
+
+	Expect<
+		Equal<
+			DeleteWithReturningEffect,
+			Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const txResult = db.transaction((tx) => tx.select().from(users));
+	type TxResultType = typeof txResult;
+
+	Expect<
+		Equal<TxResultType, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError | SqlError, never>>
+	>;
+}
+
+{
+	const count = db.$count(users);
+	type CountEffect = AsEffect<typeof count>;
+
+	Expect<Equal<CountEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const countFiltered = db.$count(users, eq(users.class, 'A'));
+	type CountFilteredEffect = AsEffect<typeof countFiltered>;
+
+	Expect<Equal<CountFilteredEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare('get_users');
+	const executed = prepared.execute();
+	type ExecutedEffect = AsEffect<typeof executed>;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const migrateResult = migrate(db, { migrationsFolder: './migrations' });
+	type MigrateEffect = typeof migrateResult;
+
+	Expect<
+		Equal<
+			MigrateEffect,
+			Effect.Effect<undefined, SqlError | EffectDrizzleQueryError | MigratorInitError, never>
+		>
+	>;
+}
+
+{
+	type RunResult = { $brand: 'RUN' };
+	const db = {} as PgEffectDatabase<
+		QueryEffectHKTBase & {
+			readonly error: EffectDrizzleQueryError;
+			readonly context: never;
+		},
+		PgQueryResultHKT & {
+			type: RunResult;
+		},
+		EmptyRelations
+	>;
+
+	const p1 = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).prepare()
+		.execute();
+	const p2 = db.update(users).set({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).prepare()
+		.execute();
+	const p3 = db.delete(users).prepare()
+		.execute();
+
+	const r1 = db.insert(users).values({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).execute();
+	const r2 = db.update(users).set({
+		homeCity: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+		arrayCol: ['test'],
+	}).execute();
+	const r3 = db.delete(users).execute();
+
+	const d1 = Effect.suspend(() =>
+		db.insert(users).values({
+			homeCity: 1,
+			class: 'A',
+			age1: 25,
+			enumCol: 'a',
+			arrayCol: ['test'],
+		})
+	);
+	const d2 = Effect.suspend(() =>
+		db.update(users).set({
+			homeCity: 1,
+			class: 'A',
+			age1: 25,
+			enumCol: 'a',
+			arrayCol: ['test'],
+		})
+	);
+	const d3 = Effect.suspend(() => db.delete(users));
+	const d4 = Effect.suspend(() => db.execute(`somequery`));
+
+	type Expected = Effect.Effect<RunResult, EffectDrizzleQueryError, never>;
+
+	Expect<Equal<typeof p1, Expected>>;
+	Expect<Equal<typeof p2, Expected>>;
+	Expect<Equal<typeof p3, Expected>>;
+
+	Expect<Equal<typeof r1, Expected>>;
+	Expect<Equal<typeof r2, Expected>>;
+	Expect<Equal<typeof r3, Expected>>;
+
+	Expect<Equal<typeof d1, Expected>>;
+	Expect<Equal<typeof d2, Expected>>;
+	Expect<Equal<typeof d3, Expected>>;
+	Expect<Equal<typeof d4, Expected>>;
+}
diff --git a/drizzle-orm/type-tests/pg/generated-columns.ts b/drizzle-orm/type-tests/pg/generated-columns.ts
index afe84def6e..001f2f24fd 100644
--- a/drizzle-orm/type-tests/pg/generated-columns.ts
+++ b/drizzle-orm/type-tests/pg/generated-columns.ts
@@ -1,6 +1,5 @@
 import { type Equal, Expect } from 'type-tests/utils';
 import { type InferInsertModel, type InferSelectModel, sql } from '~/index';
-import { drizzle } from '~/node-postgres';
 import { integer, pgTable, serial, text, varchar } from '~/pg-core';
 import { db } from './db';
 
@@ -97,46 +96,6 @@ const users = pgTable(
 	>();
 }
 
-{
-	const db = drizzle({} as any, { schema: { users } });
-
-	const dbUser = await db.query.users.findFirst();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string;
-				upperName: string | null;
-			} | undefined,
-			typeof dbUser
-		>
-	>();
-}
-
-{
-	const db = drizzle({} as any, { schema: { users } });
-
-	const dbUser = await db.query.users.findMany();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string;
-				upperName: string | null;
-			}[],
-			typeof dbUser
-		>
-	>();
-}
-
 {
 	// @ts-expect-error - Can't use the fullName because it's a generated column
 	await db.insert(users).values({
diff --git a/drizzle-orm/type-tests/pg/no-strict-null-checks/test.ts b/drizzle-orm/type-tests/pg/no-strict-null-checks/test.ts
deleted file mode 100644
index f4fe2fa4a7..0000000000
--- a/drizzle-orm/type-tests/pg/no-strict-null-checks/test.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { drizzle } from '~/node-postgres';
-import { integer, pgTable, text } from '~/pg-core';
-
-export const test = pgTable(
-	'test',
-	{
-		id: text('id')
-			.primaryKey()
-			.generatedAlwaysAs('genstr'),
-		intId: integer('int_id')
-			.primaryKey()
-			.generatedAlwaysAsIdentity(),
-		int2Id: integer('int2_id').generatedByDefaultAsIdentity(),
-		name: text('name').$defaultFn(() => '' as string),
-		title: text('title').notNull(),
-		description: text('description'),
-		dbdef: text('dbdef').default('dbdefval'),
-	},
-);
-
-const db = drizzle.mock();
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		id: '1',
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		intId: 1,
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		int2Id: 1,
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.insert(test).values({
-	// @ts-expect-error
-	id: '1',
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	// @ts-expect-error
-	intId: 1,
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	int2Id: 1,
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-});
-
-db.insert(test).values({
-	title: 'title',
-});
diff --git a/drizzle-orm/type-tests/pg/no-strict-null-checks/tsconfig.json b/drizzle-orm/type-tests/pg/no-strict-null-checks/tsconfig.json
deleted file mode 100644
index 6d5a4b7c0c..0000000000
--- a/drizzle-orm/type-tests/pg/no-strict-null-checks/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"noEmit": true,
-		"strictNullChecks": false,
-		"strictPropertyInitialization": false,
-		"exactOptionalPropertyTypes": false
-	},
-	"include": ["./test.ts"]
-}
diff --git a/drizzle-orm/type-tests/pg/select.ts b/drizzle-orm/type-tests/pg/select.ts
index dcf99428a6..4ce9f5a553 100644
--- a/drizzle-orm/type-tests/pg/select.ts
+++ b/drizzle-orm/type-tests/pg/select.ts
@@ -2,17 +2,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 
 import { alias } from '~/pg-core/alias.ts';
-import {
-	boolean,
-	integer,
-	pgMaterializedView,
-	type PgSelect,
-	type PgSelectQueryBuilder,
-	pgTable,
-	pgView,
-	QueryBuilder,
-	text,
-} from '~/pg-core/index.ts';
+import { boolean, integer, pgMaterializedView, pgTable, pgView, QueryBuilder, text } from '~/pg-core/index.ts';
 import {
 	and,
 	arrayContained,
@@ -41,8 +31,17 @@ import {
 } from '~/sql/expressions/index.ts';
 import { type InferSelectViewModel, type SQL, sql } from '~/sql/sql.ts';
 
+import { PgSelect } from '~/pg-core/query-builders/select.ts';
 import { db } from './db.ts';
-import { cities, classes, newYorkers, newYorkers2, users } from './tables.ts';
+import {
+	cities,
+	classes,
+	newYorkers,
+	newYorkers2,
+	newYorkersWithSubquery,
+	newYorkersWithSubquery2,
+	users,
+} from './tables.ts';
 
 const city = alias(cities, 'city');
 const city1 = alias(cities, 'city1');
@@ -978,6 +977,50 @@ await db
 	>;
 }
 
+{
+	const result = await db.select().from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				id: number;
+				class: 'A' | 'C';
+				cityCount: number;
+				lastCityId: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery>[]>>;
+}
+
+{
+	const result = await db.select({ cityCount: newYorkersWithSubquery.cityCount }).from(newYorkersWithSubquery);
+	Expect<
+		Equal<
+			{
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
+{
+	const result = await db.select().from(newYorkersWithSubquery2);
+	Expect<
+		Equal<
+			{
+				id: number;
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery2.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery2>[]>>;
+}
+
 {
 	db
 		.select()
@@ -1030,7 +1073,7 @@ await db
 }
 
 {
-	function withFriends<T extends PgSelectQueryBuilder>(qb: T) {
+	function withFriends<T extends PgSelect>(qb: T) {
 		const friends = alias(users, 'friends');
 		const friends2 = alias(users, 'friends2');
 		const friends3 = alias(users, 'friends3');
@@ -1046,6 +1089,7 @@ await db
 
 	const qb = db.select().from(users).$dynamic();
 	const result = await withFriends(qb);
+
 	Expect<
 		Equal<typeof result, {
 			users_table: typeof users.$inferSelect;
@@ -1070,7 +1114,7 @@ await db
 
 {
 	// TODO: add to docs
-	function dynamic<T extends PgSelectQueryBuilder>(qb: T) {
+	function dynamic<T extends PgSelect>(qb: T) {
 		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
 	}
 
@@ -1455,3 +1499,44 @@ await db
 		// @ts-expect-error
 		.crossJoinLateral(view);
 }
+
+// Dialect-agnostic test - do not duplicate
+{
+	const res = await db.select({
+		preNull: sql<number | null>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).as('sq1'),
+		postNull: sql<number>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).nullable().as('sq2'),
+		prePostNull: sql<number | null>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).nullable().as('sq3'),
+		default: sql`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, unknown>>;
+			return String(v);
+		}).as('sq4'),
+		unknown: sql<unknown>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, unknown>>;
+			return String(v);
+		}).as('sq5'),
+		any: sql<any>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, any>>;
+			return String(v);
+		}).as('sq6'),
+	}).from(users);
+
+	Expect<
+		Equal<typeof res, {
+			preNull: string | null;
+			postNull: string | null;
+			prePostNull: string | null;
+			default: string;
+			unknown: string;
+			any: string;
+		}[]>
+	>;
+}
diff --git a/drizzle-orm/type-tests/pg/subquery.ts b/drizzle-orm/type-tests/pg/subquery.ts
index cdcbd08874..e24cd05212 100644
--- a/drizzle-orm/type-tests/pg/subquery.ts
+++ b/drizzle-orm/type-tests/pg/subquery.ts
@@ -1,35 +1,42 @@
 import { Expect } from 'type-tests/utils.ts';
 import { alias, integer, pgTable, serial, text } from '~/pg-core/index.ts';
 import { and, eq } from '~/sql/expressions/index.ts';
+import { count } from '~/sql/functions/aggregate.ts';
 import { sql } from '~/sql/sql.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
 
-const names = pgTable('names', {
+const users = pgTable('names', {
 	id: serial('id').primaryKey(),
 	name: text('name'),
+	managerId: integer('author_id'),
+});
+
+const posts = pgTable('posts', {
+	id: serial('id').primaryKey(),
 	authorId: integer('author_id'),
+	title: text('title'),
 });
 
 const n1 = db
 	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
+		id: users.id,
+		name: users.name,
+		authorId: users.managerId,
 		count1: sql<number>`count(1)::int`.as('count1'),
 	})
-	.from(names)
-	.groupBy(names.id, names.name, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.name, users.managerId)
 	.as('n1');
 
 const n2 = db
 	.select({
-		id: names.id,
-		authorId: names.authorId,
+		id: users.id,
+		authorId: users.managerId,
 		totalCount: sql<number>`count(1)::int`.as('totalCount'),
 	})
-	.from(names)
-	.groupBy(names.id, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.managerId)
 	.as('n2');
 
 const result = await db
@@ -54,16 +61,16 @@ Expect<
 	>
 >;
 
-const names2 = alias(names, 'names2');
+const names2 = alias(users, 'names2');
 
 const sq1 = db
 	.select({
-		id: names.id,
-		name: names.name,
+		id: users.id,
+		name: users.name,
 		id2: names2.id,
 	})
-	.from(names)
-	.leftJoin(names2, eq(names.name, names2.name))
+	.from(users)
+	.leftJoin(names2, eq(users.name, names2.name))
 	.as('sq1');
 
 const res = await db.select().from(sq1);
@@ -80,11 +87,11 @@ Expect<
 >;
 
 {
-	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
+	const sq = db.select({ count: sql<number>`count(1)::int` }).from(users).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
 
-const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+const sqUnion = db.select().from(users).union(db.select().from(names2)).as('sqUnion');
 
 const resUnion = await db.select().from(sqUnion);
 
@@ -92,6 +99,26 @@ Expect<
 	Equal<{
 		id: number;
 		name: string | null;
-		authorId: number | null;
+		managerId: number | null;
 	}[], typeof resUnion>
 >;
+
+const fromSubquery = await db.select({
+	count: db.select({ count: count().as('c') }).from(posts).where(eq(posts.authorId, users.id)).as('count'),
+}).from(users);
+
+Expect<Equal<typeof fromSubquery, { count: number }[]>>;
+
+const fromSubquery2 = await db.select({
+	name: db.select({ name: users.name }).from(users).where(eq(users.id, posts.authorId)).as('name'),
+}).from(posts);
+
+Expect<Equal<typeof fromSubquery2, { name: string | null }[]>>;
+
+const errorSubquery = await db.select({
+	name: db.select({ name: users.name, managerId: users.managerId }).from(users).where(eq(users.id, posts.authorId)).as(
+		'name',
+	),
+}).from(posts);
+
+Expect<Equal<typeof errorSubquery, { name: DrizzleTypeError<'You can only select one column in the subquery'> }[]>>;
diff --git a/drizzle-orm/type-tests/pg/tables-rel.ts b/drizzle-orm/type-tests/pg/tables-rel.ts
index 9be999a335..ef742ae4b4 100644
--- a/drizzle-orm/type-tests/pg/tables-rel.ts
+++ b/drizzle-orm/type-tests/pg/tables-rel.ts
@@ -1,5 +1,5 @@
+import { relations } from '~/_relations.ts';
 import { foreignKey, integer, pgTable, serial, text, timestamp } from '~/pg-core/index.ts';
-import { relations } from '~/relations.ts';
 
 export const users = pgTable('users', {
 	id: serial('id').primaryKey(),
@@ -67,11 +67,11 @@ export const node = pgTable('node', {
 	parentId: integer('parent_id'),
 	leftId: integer('left_id'),
 	rightId: integer('right_id'),
-}, (node) => ({
-	fk1: foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
-	fk2: foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
-	fk3: foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
-}));
+}, (node) => [
+	foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
+]);
 export const nodeRelations = relations(node, ({ one }) => ({
 	parent: one(node, { fields: [node.parentId], references: [node.id] }),
 	left: one(node, { fields: [node.leftId], references: [node.id] }),
diff --git a/drizzle-orm/type-tests/pg/tables.ts b/drizzle-orm/type-tests/pg/tables.ts
index d47aefceb4..3f945b4d33 100644
--- a/drizzle-orm/type-tests/pg/tables.ts
+++ b/drizzle-orm/type-tests/pg/tables.ts
@@ -26,10 +26,8 @@ import {
 	macaddr,
 	macaddr8,
 	numeric,
-	type PgColumn,
 	pgEnum,
 	pgTable,
-	type PgTableWithColumns,
 	point,
 	primaryKey,
 	real,
@@ -46,13 +44,8 @@ import {
 	vector,
 } from '~/pg-core/index.ts';
 import { pgSchema } from '~/pg-core/schema.ts';
-import {
-	pgMaterializedView,
-	type PgMaterializedViewWithSelection,
-	pgView,
-	type PgViewWithSelection,
-} from '~/pg-core/view.ts';
-import { eq, gt } from '~/sql/expressions/index.ts';
+import { pgMaterializedView, pgView } from '~/pg-core/view.ts';
+import { eq } from '~/sql/expressions/index.ts';
 import { sql } from '~/sql/sql.ts';
 import type { InferInsertModel, InferSelectModel } from '~/table.ts';
 import type { Simplify } from '~/utils.ts';
@@ -61,28 +54,28 @@ import { db } from './db.ts';
 export const myEnum = pgEnum('my_enum', ['a', 'b', 'c']);
 
 export const identityColumnsTable = pgTable('identity_columns_table', {
-	generatedCol: integer('generated_col').generatedAlwaysAs(1),
+	generatedCol: integer('generated_col').generatedAlwaysAs(sql`1`),
 	alwaysAsIdentity: integer('always_as_identity').generatedAlwaysAsIdentity(),
 	byDefaultAsIdentity: integer('by_default_as_identity').generatedByDefaultAsIdentity(),
 	name: text('name'),
 });
 
 Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferSelect']>>;
-Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferSelect']>>;
+// Expect<Equal<InferSelectModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferSelect']>>;
 Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['$inferInsert']>>;
-Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferInsert']>>;
+// Expect<Equal<InferInsertModel<typeof identityColumnsTable>, typeof identityColumnsTable['_']['inferInsert']>>;
 Expect<
 	Equal<
 		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
 		Simplify<typeof identityColumnsTable['$inferInsert'] & { alwaysAsIdentity?: number | undefined }>
 	>
 >;
-Expect<
-	Equal<
-		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
-		Simplify<typeof identityColumnsTable['_']['inferInsert'] & { alwaysAsIdentity?: number | undefined }>
-	>
->;
+// Expect<
+// 	Equal<
+// 		InferInsertModel<typeof identityColumnsTable, { dbColumnNames: false; override: true }>,
+// 		Simplify<typeof identityColumnsTable['_']['inferInsert'] & { alwaysAsIdentity?: number | undefined }>
+// 	>
+// >;
 
 export const users = pgTable(
 	'users_table',
@@ -123,17 +116,15 @@ export const users = pgTable(
 );
 
 Expect<Equal<InferSelectModel<typeof users>, typeof users['$inferSelect']>>;
-Expect<Equal<InferSelectModel<typeof users>, typeof users['_']['inferSelect']>>;
+// Expect<Equal<InferSelectModel<typeof users>, typeof users['_']['inferSelect']>>;
 Expect<Equal<InferInsertModel<typeof users>, typeof users['$inferInsert']>>;
-Expect<Equal<InferInsertModel<typeof users>, typeof users['_']['inferInsert']>>;
+// Expect<Equal<InferInsertModel<typeof users>, typeof users['_']['inferInsert']>>;
 
 export const cities = pgTable('cities_table', {
 	id: serial('id').primaryKey(),
 	name: text('name').notNull(),
 	population: integer('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index().on(cities.id),
-}));
+}, (cities) => [index().on(cities.id)]);
 
 export const smallSerialTest = pgTable('cities_table', {
 	id: smallserial('id').primaryKey(),
@@ -182,11 +173,11 @@ Expect<
 export const salEmp = pgTable('sal_emp', {
 	name: text('name').notNull(),
 	payByQuarter: integer('pay_by_quarter').array().notNull(),
-	schedule: text('schedule').array().array().notNull(),
+	schedule: text('schedule').array('[][]').notNull(),
 });
 
 export const tictactoe = pgTable('tictactoe', {
-	squares: integer('squares').array(3).array(3).notNull(),
+	squares: integer('squares').array('[][]').notNull(),
 });
 
 export const customSchema = pgSchema('custom');
@@ -215,50 +206,8 @@ export const newYorkers = pgView('new_yorkers')
 		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 	});
 
-Expect<
-	Equal<
-		PgViewWithSelection<'new_yorkers', false, {
-			userId: PgColumn<{
-				tableName: 'new_yorkers';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'PgSerial';
-				data: number;
-				driverParam: number;
-				notNull: true;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			cityId: PgColumn<{
-				tableName: 'new_yorkers';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'PgSerial';
-				data: number;
-				driverParam: number;
-				notNull: false;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-		}>,
-		typeof newYorkers
-	>
->;
-
 {
-	const newYorkers = customSchema.view('new_yorkers')
+	const _newYorkers = customSchema.view('new_yorkers')
 		.with({
 			checkOption: 'cascaded',
 			securityBarrier: true,
@@ -275,52 +224,10 @@ Expect<
 				);
 			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 		});
-
-	Expect<
-		Equal<
-			PgViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'id';
-					dataType: 'number';
-					columnType: 'PgSerial';
-					data: number;
-					driverParam: number;
-					notNull: true;
-					hasDefault: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'id';
-					dataType: 'number';
-					columnType: 'PgSerial';
-					data: number;
-					driverParam: number;
-					notNull: false;
-					hasDefault: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
-	const newYorkers = pgView('new_yorkers', {
+	const _newYorkers = pgView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	})
@@ -332,54 +239,12 @@ Expect<
 		.as(
 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
 				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
+			} where ${users.age1} > 18`,
 		);
-
-	Expect<
-		Equal<
-			PgViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
-	const newYorkers = customSchema.view('new_yorkers', {
+	const _newYorkers = customSchema.view('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	})
@@ -391,148 +256,22 @@ Expect<
 		.as(
 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
 				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
+			} where ${users.age1} > 18`,
 		);
-
-	Expect<
-		Equal<
-			PgViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
-	const newYorkers = pgView('new_yorkers', {
+	const _newYorkers = pgView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	}).existing();
-
-	Expect<
-		Equal<
-			PgViewWithSelection<'new_yorkers', true, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
-	const newYorkers = customSchema.view('new_yorkers', {
+	const _newYorkers = customSchema.view('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	}).existing();
-
-	Expect<
-		Equal<
-			PgViewWithSelection<'new_yorkers', true, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 export const newYorkers2 = pgMaterializedView('new_yorkers')
@@ -556,50 +295,8 @@ export const newYorkers2 = pgMaterializedView('new_yorkers')
 		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 	});
 
-Expect<
-	Equal<
-		PgMaterializedViewWithSelection<'new_yorkers', false, {
-			userId: PgColumn<{
-				tableName: 'new_yorkers';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'PgSerial';
-				data: number;
-				driverParam: number;
-				notNull: true;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			cityId: PgColumn<{
-				tableName: 'new_yorkers';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'PgSerial';
-				data: number;
-				driverParam: number;
-				notNull: false;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-		}>,
-		typeof newYorkers2
-	>
->;
-
 {
-	const newYorkers2 = customSchema.materializedView('new_yorkers')
+	const _newYorkers2 = customSchema.materializedView('new_yorkers')
 		.using('btree')
 		.with({
 			fillfactor: 90,
@@ -619,52 +316,10 @@ Expect<
 				);
 			return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 		});
-
-	Expect<
-		Equal<
-			PgMaterializedViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'id';
-					dataType: 'number';
-					columnType: 'PgSerial';
-					data: number;
-					driverParam: number;
-					notNull: true;
-					hasDefault: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'id';
-					dataType: 'number';
-					columnType: 'PgSerial';
-					data: number;
-					driverParam: number;
-					notNull: false;
-					hasDefault: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: true;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers2
-		>
-	>;
 }
 
 {
-	const newYorkers2 = pgMaterializedView('new_yorkers', {
+	const _newYorkers2 = pgMaterializedView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	})
@@ -679,54 +334,12 @@ Expect<
 		.as(
 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
 				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
+			} where ${users.age1} > 18`,
 		);
-
-	Expect<
-		Equal<
-			PgMaterializedViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers2
-		>
-	>;
 }
 
 {
-	const newYorkers2 = customSchema.materializedView('new_yorkers', {
+	const _newYorkers2 = customSchema.materializedView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	})
@@ -741,148 +354,22 @@ Expect<
 		.as(
 			sql`select ${users.id} as user_id, ${cities.id} as city_id from ${users} left join ${cities} on ${
 				eq(cities.id, users.homeCity)
-			} where ${gt(users.age1, 18)}`,
+			} where ${users.age1} > 18`,
 		);
-
-	Expect<
-		Equal<
-			PgMaterializedViewWithSelection<'new_yorkers', false, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers2
-		>
-	>;
 }
 
 {
-	const newYorkers2 = pgMaterializedView('new_yorkers', {
+	const _newYorkers2 = pgMaterializedView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	}).existing();
-
-	Expect<
-		Equal<
-			PgMaterializedViewWithSelection<'new_yorkers', true, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers2
-		>
-	>;
 }
 
 {
-	const newYorkers2 = customSchema.materializedView('new_yorkers', {
+	const _newYorkers2 = customSchema.materializedView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	}).existing();
-
-	Expect<
-		Equal<
-			PgMaterializedViewWithSelection<'new_yorkers', true, {
-				userId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					data: number;
-					driverParam: string | number;
-					hasDefault: false;
-					notNull: true;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-				cityId: PgColumn<{
-					tableName: 'new_yorkers';
-					name: 'city_id';
-					dataType: 'number';
-					columnType: 'PgInteger';
-					notNull: false;
-					hasDefault: false;
-					data: number;
-					driverParam: string | number;
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-				}>;
-			}>,
-			typeof newYorkers2
-		>
-	>;
 }
 
 await db.refreshMaterializedView(newYorkers2).concurrently();
@@ -890,6 +377,39 @@ await db.refreshMaterializedView(newYorkers2).withNoData();
 await db.refreshMaterializedView(newYorkers2).concurrently().withNoData();
 await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 
+export const newYorkersWithSubquery = pgView('new_yorkers_with_sq')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				class: users.class,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+				lastCityId: qb
+					.select({ id: cities.id })
+					.from(cities)
+					.orderBy(cities.id)
+					.limit(1)
+					.as('last_city'),
+			})
+			.from(users)
+	);
+
+export const newYorkersWithSubquery2 = pgMaterializedView('new_yorkers_with_sq_mv')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+			})
+			.from(users)
+	);
+
 // await migrate(db, {
 // 	migrationsFolder: './drizzle/pg',
 // 	onMigrationError(error) {
@@ -907,6 +427,7 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 		config: { length: number };
 		configRequired: true;
 	}>({
+		codec: 'varchar',
 		dataType(config) {
 			Expect<Equal<{ length: number }, typeof config>>;
 			return `varchar(${config.length})`;
@@ -937,6 +458,7 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 		driverData: string;
 		config: { length: number };
 	}>({
+		codec: (config) => config ? 'varchar' : 'text',
 		dataType(config) {
 			Expect<Equal<{ length: number } | undefined, typeof config>>;
 			return config ? `varchar(${config.length})` : `text`;
@@ -960,103 +482,25 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 }
 
 {
-	const cities1 = pgTable('cities_table', {
+	pgTable('cities_table', {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull().primaryKey(),
 		role: text('role', { enum: ['admin', 'user'] }).default('user').notNull(),
 		population: integer('population').default(0),
 	});
-	const cities2 = pgTable('cities_table', ({ serial, text, integer }) => ({
+	pgTable('cities_table', ({ serial, text, integer }) => ({
 		id: serial('id').primaryKey(),
 		name: text('name').notNull().primaryKey(),
 		role: text('role', { enum: ['admin', 'user'] }).default('user').notNull(),
 		population: integer('population').default(0),
 	}));
-
-	type Expected = PgTableWithColumns<{
-		name: 'cities_table';
-		schema: undefined;
-		dialect: 'pg';
-		columns: {
-			id: PgColumn<{
-				tableName: 'cities_table';
-				name: 'id';
-				dataType: 'number';
-				columnType: 'PgSerial';
-				data: number;
-				driverParam: number;
-				hasDefault: true;
-				notNull: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			name: PgColumn<{
-				tableName: 'cities_table';
-				name: 'name';
-				dataType: 'string';
-				columnType: 'PgText';
-				data: string;
-				driverParam: string;
-				hasDefault: false;
-				enumValues: [string, ...string[]];
-				notNull: true;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: true;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			role: PgColumn<{
-				tableName: 'cities_table';
-				name: 'role';
-				dataType: 'string';
-				columnType: 'PgText';
-				data: 'admin' | 'user';
-				driverParam: string;
-				hasDefault: true;
-				enumValues: ['admin', 'user'];
-				notNull: true;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: false;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-			population: PgColumn<{
-				tableName: 'cities_table';
-				name: 'population';
-				dataType: 'number';
-				columnType: 'PgInteger';
-				data: number;
-				driverParam: string | number;
-				notNull: false;
-				hasDefault: true;
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isPrimaryKey: false;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-			}>;
-		};
-	}>;
-
-	Expect<Equal<Expected, typeof cities1>>;
-	Expect<Equal<Expected, typeof cities2>>;
 }
 
 {
 	pgTable('test', {
 		bigint: bigint('bigint', { mode: 'bigint' }).default(BigInt(10)),
-		bigintNumber: bigint('bigintNumber', { mode: 'number' }),
+		bigintNumber: bigint('bigint_number', { mode: 'number' }).default(10),
+		bigintString: bigint('bigint_string', { mode: 'string' }).default('10'),
 		bigserial: bigserial('bigserial', { mode: 'bigint' }).default(BigInt(10)),
 		bigserialNumber: bigserial('bigserialNumber', { mode: 'number' }),
 		timestamp: timestamp('timestamp').default(new Date()),
@@ -1185,15 +629,15 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 
 	Expect<Equal<['a', 'b', 'c'], typeof test.col1.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col2.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col3.enumValues>>;
+	Expect<Equal<undefined, typeof test.col3.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col4.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col5.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col6.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col7.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col8.enumValues>>;
+	Expect<Equal<undefined, typeof test.col8.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col9.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col10.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col11.enumValues>>;
+	Expect<Equal<undefined, typeof test.col11.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col12.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col13.enumValues>>;
 }
@@ -1224,15 +668,15 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 
 	Expect<Equal<['a', 'b', 'c'], typeof test.col1.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col2.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col3.enumValues>>;
+	Expect<Equal<undefined, typeof test.col3.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col4.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col5.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col6.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col7.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col8.enumValues>>;
+	Expect<Equal<undefined, typeof test.col8.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col9.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col10.enumValues>>;
-	Expect<Equal<[string, ...string[]], typeof test.col11.enumValues>>;
+	Expect<Equal<undefined, typeof test.col11.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col12.enumValues>>;
 	Expect<Equal<['a', 'b', 'c'], typeof test.col13.enumValues>>;
 }
@@ -1275,8 +719,12 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 		numeric3: numeric('numeric3', { scale: 2 }),
 		numeric4: numeric('numeric4', { precision: 5, scale: 2 }),
 		numericdef: numeric('numeridef').default('100'),
-		bigint: bigint('bigint', { mode: 'number' }),
-		bigintdef: bigint('bigintdef', { mode: 'number' }).default(100),
+		bigint: bigint('bigint', { mode: 'bigint' }),
+		bigintDef: bigint('bigint_def', { mode: 'bigint' }).default(BigInt(100)),
+		bigintNumber: bigint('bigint_number', { mode: 'number' }),
+		bigintNumberDef: bigint('bigint_number_def', { mode: 'number' }).default(100),
+		bigintString: bigint('bigint_string', { mode: 'string' }),
+		bigintStringDef: bigint('bigint_string_def', { mode: 'string' }).default('100'),
 		bool: boolean('boolean'),
 		booldef: boolean('boolean_def').default(true),
 		text: text('text'),
@@ -1341,8 +789,8 @@ await db.refreshMaterializedView(newYorkers2).withNoData().concurrently();
 		name: text(),
 	});
 
-	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], 'id'>>;
-	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], 'name'>>;
+	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], string>>;
+	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], string>>;
 }
 
 {
diff --git a/drizzle-orm/type-tests/pg/with.ts b/drizzle-orm/type-tests/pg/with.ts
index 08f079688c..7795cfa6d1 100644
--- a/drizzle-orm/type-tests/pg/with.ts
+++ b/drizzle-orm/type-tests/pg/with.ts
@@ -3,7 +3,6 @@ import { Expect } from 'type-tests/utils.ts';
 import { integer, pgTable, serial, text } from '~/pg-core/index.ts';
 import { gt, inArray, like } from '~/sql/expressions/index.ts';
 import { sql } from '~/sql/sql.ts';
-import { DrizzleTypeError } from '~/utils.ts';
 import { db } from './db.ts';
 
 {
diff --git a/drizzle-orm/type-tests/singlestore/db.ts b/drizzle-orm/type-tests/singlestore/db.ts
index b314e504d7..5eed69d193 100644
--- a/drizzle-orm/type-tests/singlestore/db.ts
+++ b/drizzle-orm/type-tests/singlestore/db.ts
@@ -3,11 +3,11 @@ import { drizzle } from '~/singlestore/index.ts';
 
 const pool = createPool({});
 
-export const db = drizzle(pool);
+export const db = drizzle({ client: pool });
 
 {
-	drizzle(pool);
-	drizzle(pool, { schema: {} });
-	drizzle(pool, { schema: {} });
-	drizzle(pool, {});
+	drizzle({ client: pool });
+	drizzle({ client: pool, schema: {} });
+	drizzle({ client: pool, schema: {} });
+	drizzle({ client: pool });
 }
diff --git a/drizzle-orm/type-tests/singlestore/no-strict-null-checks/test.ts b/drizzle-orm/type-tests/singlestore/no-strict-null-checks/test.ts
deleted file mode 100644
index 62d3ea1908..0000000000
--- a/drizzle-orm/type-tests/singlestore/no-strict-null-checks/test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { drizzle } from '~/singlestore';
-import { singlestoreTable, text } from '~/singlestore-core';
-
-export const test = singlestoreTable(
-	'test',
-	{
-		id: text('id')
-			.primaryKey()
-			.generatedAlwaysAs('genstr'),
-		name: text('name').$defaultFn(() => '' as string),
-		title: text('title').notNull(),
-		description: text('description'),
-		dbdef: text('dbdef').default('dbdefval'),
-	},
-);
-
-const db = drizzle.mock();
-
-// Enable after `.generatedAlwaysAs()` is implemented
-// db.update(test)
-// 	.set({
-// 		// @ts-expect-error
-// 		id: '1',
-// 		name: 'name',
-// 		title: 'title',
-// 		description: 'desc',
-// 		dbdef: 'upddef',
-// 	});
-
-db.update(test)
-	.set({
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-// Enable after `.generatedAlwaysAs()` is implemented
-// db.insert(test).values({
-// 	// @ts-expect-error
-// 	id: '1',
-// 	name: 'name',
-// 	title: 'title',
-// 	description: 'desc',
-// 	dbdef: 'upddef',
-// });
-
-db.insert(test).values({
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-});
-
-db.insert(test).values({
-	title: 'title',
-});
diff --git a/drizzle-orm/type-tests/singlestore/no-strict-null-checks/tsconfig.json b/drizzle-orm/type-tests/singlestore/no-strict-null-checks/tsconfig.json
deleted file mode 100644
index 6d5a4b7c0c..0000000000
--- a/drizzle-orm/type-tests/singlestore/no-strict-null-checks/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"noEmit": true,
-		"strictNullChecks": false,
-		"strictPropertyInitialization": false,
-		"exactOptionalPropertyTypes": false
-	},
-	"include": ["./test.ts"]
-}
diff --git a/drizzle-orm/type-tests/singlestore/tables.ts b/drizzle-orm/type-tests/singlestore/tables.ts
index 7c8cb35a7b..078b8f5cb1 100644
--- a/drizzle-orm/type-tests/singlestore/tables.ts
+++ b/drizzle-orm/type-tests/singlestore/tables.ts
@@ -1,6 +1,5 @@
 import * as crypto from 'node:crypto';
 import { type Equal, Expect } from 'type-tests/utils.ts';
-import type { BuildColumn } from '~/column-builder.ts';
 import {
 	bigint,
 	binary,
@@ -21,7 +20,6 @@ import {
 	primaryKey,
 	real,
 	serial,
-	type SingleStoreColumn,
 	singlestoreEnum,
 	singlestoreTable,
 	smallint,
@@ -41,7 +39,6 @@ import { singlestoreSchema } from '~/singlestore-core/schema.ts';
 import { eq } from '~/sql/expressions/index.ts';
 /* import { singlestoreView, type SingleStoreViewWithSelection } from '~/singlestore-core/view.ts'; */
 import type { InferSelectModel } from '~/table.ts';
-import type { Simplify } from '~/utils.ts';
 import { db } from './db.ts';
 
 export const users = singlestoreTable(
@@ -60,103 +57,30 @@ export const users = singlestoreTable(
 		createdAt: timestamp('created_at', { mode: 'date' }).notNull().defaultNow(),
 		enumCol: singlestoreEnum('enum_col', ['a', 'b', 'c']).notNull(),
 	},
-	(users) => ({
-		usersAge1Idx: uniqueIndex('usersAge1Idx').on(users.class),
-		usersAge2Idx: index('usersAge2Idx').on(users.class),
-		uniqueClass: uniqueIndex('uniqueClass')
+	(users) => [
+		uniqueIndex('usersAge1Idx').on(users.class),
+		index('usersAge2Idx').on(users.class),
+		uniqueIndex('uniqueClass')
 			.on(users.class, users.subClass)
 			.lock('default')
-			.algorythm('copy')
+			.algorithm('copy')
 			.using(`btree`),
-		pk: primaryKey(users.age1, users.class),
-	}),
+		primaryKey({ columns: [users.age1, users.class] }),
+	],
 );
 
 export const cities = singlestoreTable('cities_table', {
 	id: serial('id').primaryKey(),
 	name: text('name_db').notNull(),
 	population: int('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index('citiesNameIdx').on(cities.id),
-}));
-
-Expect<
-	Equal<
-		{
-			id: SingleStoreColumn<
-				{
-					name: 'id';
-					tableName: 'cities_table';
-					dataType: 'number';
-					columnType: 'SingleStoreSerial';
-					data: number;
-					driverParam: number;
-					notNull: true;
-					hasDefault: true;
-					isPrimaryKey: true;
-					isAutoincrement: true;
-					hasRuntimeDefault: false;
-					enumValues: undefined;
-					baseColumn: never;
-					identity: undefined;
-					generated: undefined;
-				},
-				{},
-				{}
-			>;
-			name: SingleStoreColumn<
-				{
-					name: 'name_db';
-					tableName: 'cities_table';
-					dataType: 'string';
-					columnType: 'SingleStoreText';
-					data: string;
-					driverParam: string;
-					notNull: true;
-					hasDefault: false;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					enumValues: [string, ...string[]];
-					baseColumn: never;
-					identity: undefined;
-					generated: undefined;
-				},
-				{},
-				{}
-			>;
-			population: SingleStoreColumn<
-				{
-					name: 'population';
-					tableName: 'cities_table';
-					dataType: 'number';
-					columnType: 'SingleStoreInt';
-					data: number;
-					driverParam: string | number;
-					notNull: false;
-					hasDefault: true;
-					isPrimaryKey: false;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					enumValues: undefined;
-					baseColumn: never;
-					identity: undefined;
-					generated: undefined;
-				},
-				{},
-				{}
-			>;
-		},
-		typeof cities._.columns
-	>
->;
+}, (cities) => [index('citiesNameIdx').on(cities.id)]);
 
 Expect<
 	Equal<{
 		id: number;
-		name_db: string;
+		name: string;
 		population: number | null;
-	}, InferSelectModel<typeof cities, { dbColumnNames: true }>>
+	}, InferSelectModel<typeof cities>>
 >;
 
 Expect<
@@ -173,11 +97,7 @@ export const citiesCustom = customSchema.table('cities_table', {
 	id: serial('id').primaryKey(),
 	name: text('name_db').notNull(),
 	population: int('population').default(0),
-}, (cities) => ({
-	citiesNameIdx: index('citiesNameIdx').on(cities.id),
-}));
-
-Expect<Equal<typeof cities._.columns, typeof citiesCustom._.columns>>;
+}, (cities) => [index('citiesNameIdx').on(cities.id)]);
 
 export const classes = singlestoreTable('classes_table', ({ serial, text }) => ({
 	id: serial('id').primaryKey(),
@@ -211,7 +131,7 @@ Expect<
 	Equal<
 		SingleStoreViewWithSelection<'new_yorkers', false, {
 			userId: SingleStoreColumn<{
-				name: 'id';
+				name: string;
 				dataType: 'number';
 				columnType: 'SingleStoreSerial';
 				data: number;
@@ -227,7 +147,7 @@ Expect<
 				hasRuntimeDefault: false;
 			}>;
 			cityId: SingleStoreColumn<{
-				name: 'id';
+				name: string;
 				dataType: 'number';
 				columnType: 'SingleStoreSerial';
 				data: number;
@@ -267,7 +187,7 @@ Expect<
 		Equal<
 			SingleStoreViewWithSelection<'new_yorkers', false, {
 				userId: SingleStoreColumn<{
-					name: 'id';
+					name: string;
 					dataType: 'number';
 					columnType: 'SingleStoreSerial';
 					data: number;
@@ -283,7 +203,7 @@ Expect<
 					hasRuntimeDefault: false;
 				}>;
 				cityId: SingleStoreColumn<{
-					name: 'id';
+					name: string;
 					dataType: 'number';
 					columnType: 'SingleStoreSerial';
 					data: number;
@@ -506,40 +426,6 @@ Expect<
 	>;
 } */
 
-{
-	const customText = customType<{ data: string }>({
-		dataType() {
-			return 'text';
-		},
-	});
-
-	const t = customText('name').notNull();
-	Expect<
-		Equal<
-			{
-				name: 'name';
-				tableName: 'table';
-				dataType: 'custom';
-				columnType: 'SingleStoreCustomColumn';
-				data: string;
-				driverParam: unknown;
-				notNull: true;
-				hasDefault: false;
-				isPrimaryKey: false;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-				enumValues: undefined;
-				baseColumn: never;
-				identity: undefined;
-				generated: undefined;
-				brand: 'Column';
-				dialect: 'singlestore';
-			},
-			Simplify<BuildColumn<'table', typeof t, 'singlestore'>['_']>
-		>
-	>;
-}
-
 {
 	singlestoreTable('test', {
 		bigint: bigint('bigint', { mode: 'bigint' }),
@@ -748,12 +634,10 @@ Expect<
 			createdAt: timestamp('created_at', { mode: 'string' }).defaultNow().notNull(),
 			updatedAt: timestamp('updated_at', { mode: 'string' }).defaultNow().onUpdateNow(),
 		},
-		(table) => {
-			return {
-				emailLogId: primaryKey({ columns: [table.id], name: 'email_log_id' }),
-				emailLogMessageIdUnique: unique('email_log_message_id_unique').on(table.messageId),
-			};
-		},
+		(table) => [
+			primaryKey({ columns: [table.id], name: 'email_log_id' }),
+			unique('email_log_message_id_unique').on(table.messageId),
+		],
 	);
 
 	Expect<
@@ -932,8 +816,8 @@ Expect<
 		name: text(),
 	});
 
-	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], 'id'>>;
-	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], 'name'>>;
+	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], string>>;
+	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], string>>;
 }
 
 {
diff --git a/drizzle-orm/type-tests/sqlite/db.ts b/drizzle-orm/type-tests/sqlite/db.ts
index 1950c7435d..f039592dcf 100644
--- a/drizzle-orm/type-tests/sqlite/db.ts
+++ b/drizzle-orm/type-tests/sqlite/db.ts
@@ -10,7 +10,7 @@ const bunClient = new BunDatabase(':memory:');
 declare const d1: D1Database;
 declare const durableSql: DurableObjectStorage;
 
-export const db = drizzleBetterSqlite3(client);
-export const bunDb = drizzleBun(bunClient);
+export const db = drizzleBetterSqlite3({ client });
+export const bunDb = drizzleBun({ client: bunClient });
 export const d1Db = drizzleD1(d1);
 export const durableSqliteDb = durableSqlite(durableSql);
diff --git a/drizzle-orm/type-tests/sqlite/delete.ts b/drizzle-orm/type-tests/sqlite/delete.ts
index da19eecba0..33d36ea4fc 100644
--- a/drizzle-orm/type-tests/sqlite/delete.ts
+++ b/drizzle-orm/type-tests/sqlite/delete.ts
@@ -1,6 +1,7 @@
 import type { RunResult } from 'better-sqlite3';
 import { eq } from '~/sql/expressions/index.ts';
 
+import type { Changes } from 'bun:sqlite';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { sql } from '~/sql/sql.ts';
@@ -22,7 +23,7 @@ const deleteValues = db.delete(users).values();
 Expect<Equal<DrizzleTypeError<'.values() cannot be used without .returning()'>, typeof deleteValues>>;
 
 const deleteRunBun = bunDb.delete(users).run();
-Expect<Equal<void, typeof deleteRunBun>>;
+Expect<Equal<Changes, typeof deleteRunBun>>;
 
 const deleteAllBun = bunDb.delete(users).all();
 Expect<Equal<DrizzleTypeError<'.all() cannot be used without .returning()'>, typeof deleteAllBun>>;
@@ -46,7 +47,7 @@ const deleteValuesWhere = db.delete(users).where(eq(users.id, 1)).values();
 Expect<Equal<DrizzleTypeError<'.values() cannot be used without .returning()'>, typeof deleteValuesWhere>>;
 
 const deleteRunBunWhere = bunDb.delete(users).where(eq(users.id, 1)).run();
-Expect<Equal<void, typeof deleteRunBunWhere>>;
+Expect<Equal<Changes, typeof deleteRunBunWhere>>;
 
 const deleteAllBunWhere = bunDb.delete(users).where(eq(users.id, 1)).all();
 Expect<Equal<DrizzleTypeError<'.all() cannot be used without .returning()'>, typeof deleteAllBunWhere>>;
@@ -70,7 +71,7 @@ const deleteValuesReturning = db.delete(users).returning().values();
 Expect<Equal<any[][], typeof deleteValuesReturning>>;
 
 const deleteRunBunReturning = bunDb.delete(users).returning().run();
-Expect<Equal<void, typeof deleteRunBunReturning>>;
+Expect<Equal<Changes, typeof deleteRunBunReturning>>;
 
 const deleteAllBunReturning = bunDb.delete(users).returning().all();
 Expect<Equal<typeof users.$inferSelect[], typeof deleteAllBunReturning>>;
diff --git a/drizzle-orm/type-tests/sqlite/effect.ts b/drizzle-orm/type-tests/sqlite/effect.ts
new file mode 100644
index 0000000000..e3257fa9e5
--- /dev/null
+++ b/drizzle-orm/type-tests/sqlite/effect.ts
@@ -0,0 +1,339 @@
+import type { SqliteClient } from '@effect/sql-sqlite-node/SqliteClient';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { Equal } from 'type-tests/utils.ts';
+import { Expect } from 'type-tests/utils.ts';
+import type { EffectDrizzleQueryError, MigratorInitError } from '~/effect-core/errors.ts';
+import { QueryEffectHKTBase } from '~/effect-core/query-effect.ts';
+import type { EffectSQLiteNodeDatabase } from '~/effect-sqlite-node/index.ts';
+import { make, makeWithDefaults } from '~/effect-sqlite-node/index.ts';
+import { migrate } from '~/effect-sqlite-node/migrator.ts';
+import type { EmptyRelations } from '~/relations.ts';
+import { eq } from '~/sql/expressions/index.ts';
+import { SQLiteEffectDatabase } from '~/sqlite-core/effect/db.ts';
+import { cities, users } from './tables.ts';
+
+type AsEffect<T> = T extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, R> : T;
+
+{
+	const dbEffect = makeWithDefaults();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<EffectSQLiteNodeDatabase<EmptyRelations> & { $client: SqliteClient }, never, SqliteClient>
+		>
+	>;
+}
+
+{
+	const dbEffect = make();
+	type DbEffect = typeof dbEffect;
+
+	Expect<
+		Equal<
+			DbEffect,
+			Effect.Effect<
+				EffectSQLiteNodeDatabase<EmptyRelations> & { $client: SqliteClient },
+				never,
+				| import('~/effect-core/logger.ts').EffectLogger
+				| import('~/cache/core/cache-effect.ts').EffectCache
+				| SqliteClient
+			>
+		>
+	>;
+}
+
+declare const db: EffectSQLiteNodeDatabase<Record<string, never>>;
+
+{
+	const selectAll = db.select().from(users);
+	type SelectAllEffect = AsEffect<typeof selectAll>;
+
+	Expect<Equal<SelectAllEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const selectColumns = db.select({
+		id: users.id,
+		name: users.name,
+	}).from(users);
+	type SelectColumnsEffect = AsEffect<typeof selectColumns>;
+
+	Expect<
+		Equal<
+			SelectColumnsEffect,
+			Effect.Effect<{ id: number; name: string | null }[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const selectWithJoin = db
+		.select()
+		.from(users)
+		.leftJoin(cities, eq(users.homeCity, cities.id));
+	type SelectWithJoinEffect = AsEffect<typeof selectWithJoin>;
+
+	Expect<
+		Equal<
+			SelectWithJoinEffect,
+			Effect.Effect<
+				{
+					users_table: typeof users.$inferSelect;
+					cities_table: typeof cities.$inferSelect | null;
+				}[],
+				EffectDrizzleQueryError,
+				never
+			>
+		>
+	>;
+}
+
+{
+	const insertOne = db.insert(users).values({
+		homeCity: 1,
+		serialNotNull: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	});
+	type InsertOneEffect = AsEffect<typeof insertOne>;
+
+	Expect<Equal<InsertOneEffect, Effect.Effect<unknown, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const insertReturning = db.insert(users).values({
+		homeCity: 1,
+		serialNotNull: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).returning();
+	type InsertReturningEffect = AsEffect<typeof insertReturning>;
+
+	Expect<
+		Equal<InsertReturningEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>
+	>;
+}
+
+{
+	const insertReturningColumns = db.insert(users).values({
+		homeCity: 1,
+		serialNotNull: 1,
+		class: 'A',
+		age1: 25,
+		enumCol: 'a',
+	}).returning({ id: users.id, name: users.name });
+	type InsertReturningColumnsEffect = AsEffect<typeof insertReturningColumns>;
+
+	Expect<
+		Equal<
+			InsertReturningColumnsEffect,
+			Effect.Effect<{ id: number; name: string | null }[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const updateAll = db.update(users).set({ name: 'updated' });
+	type UpdateAllEffect = AsEffect<typeof updateAll>;
+
+	Expect<Equal<UpdateAllEffect, Effect.Effect<unknown, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const updateWithReturning = db.update(users)
+		.set({ name: 'updated' })
+		.where(eq(users.id, 1))
+		.returning();
+	type UpdateWithReturningEffect = AsEffect<typeof updateWithReturning>;
+
+	Expect<
+		Equal<
+			UpdateWithReturningEffect,
+			Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const deleteAll = db.delete(users);
+	type DeleteAllEffect = AsEffect<typeof deleteAll>;
+
+	Expect<Equal<DeleteAllEffect, Effect.Effect<unknown, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const deleteWithReturning = db.delete(users)
+		.where(eq(users.id, 1))
+		.returning();
+	type DeleteWithReturningEffect = AsEffect<typeof deleteWithReturning>;
+
+	Expect<
+		Equal<
+			DeleteWithReturningEffect,
+			Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>
+		>
+	>;
+}
+
+{
+	const txResult = db.transaction((tx) => tx.select().from(users));
+	type TxResultType = typeof txResult;
+
+	Expect<
+		Equal<TxResultType, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError | SqlError, never>>
+	>;
+}
+
+{
+	const count = db.$count(users);
+	type CountEffect = AsEffect<typeof count>;
+
+	Expect<Equal<CountEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const countFiltered = db.$count(users, eq(users.class, 'A'));
+	type CountFilteredEffect = AsEffect<typeof countFiltered>;
+
+	Expect<Equal<CountFilteredEffect, Effect.Effect<number, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.execute();
+	type ExecutedEffect = typeof executed;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.all();
+	type ExecutedEffect = typeof executed;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<(typeof users.$inferSelect)[], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.get();
+	type ExecutedEffect = typeof executed;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<(typeof users.$inferSelect) | undefined, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.values();
+	type ExecutedEffect = typeof executed;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<any[][], EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const prepared = db.select().from(users).prepare();
+	const executed = prepared.run();
+	type ExecutedEffect = typeof executed;
+
+	Expect<Equal<ExecutedEffect, Effect.Effect<unknown, EffectDrizzleQueryError, never>>>;
+}
+
+{
+	const migrateResult = migrate(db, { migrationsFolder: './migrations' });
+	type MigrateEffect = typeof migrateResult;
+
+	Expect<
+		Equal<
+			MigrateEffect,
+			Effect.Effect<undefined, SqlError | EffectDrizzleQueryError | MigratorInitError, never>
+		>
+	>;
+}
+
+{
+	type RunResult = { $brand: 'RUN' };
+	const db = {} as SQLiteEffectDatabase<
+		QueryEffectHKTBase & {
+			readonly error: EffectDrizzleQueryError;
+			readonly context: never;
+		},
+		RunResult,
+		EmptyRelations
+	>;
+
+	const p1 = db.select().from(users).prepare().run();
+	const p2 = db.selectDistinct().from(users).prepare().run();
+	const p3 = db.with(db.$with('sq').as((qb) => qb.select().from(users))).select().from(users).prepare().run();
+	const p4 = db.selectDistinct().from(users).prepare().run();
+	const p5 = db.insert(users).values({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).prepare()
+		.run();
+	const p6 = db.insert(users).values({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).returning()
+		.prepare()
+		.run();
+	const p7 = db.update(users).set({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).prepare()
+		.run();
+	const p8 = db.update(users).set({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).returning()
+		.prepare()
+		.run();
+	const p9 = db.delete(users).prepare()
+		.run();
+	const p10 = db.delete(users).returning()
+		.prepare()
+		.run();
+
+	const r1 = db.select().from(users).run();
+	const r2 = db.selectDistinct().from(users).run();
+	const r3 = db.with(db.$with('sq').as((qb) => qb.select().from(users))).select().from(users).run();
+	const r4 = db.selectDistinct().from(users).run();
+	const r5 = db.insert(users).values({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).run();
+	const r6 = db.insert(users).values({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).returning()
+		.run();
+	const r7 = db.update(users).set({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).run();
+	const r8 = db.update(users).set({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' }).returning()
+		.run();
+	const r9 = db.delete(users).run();
+	const r10 = db.delete(users).returning().run();
+
+	const d1 = Effect.suspend(() =>
+		db.insert(users).values({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' })
+	);
+	const d2 = Effect.suspend(() =>
+		db.update(users).set({ homeCity: 1, serialNotNull: 1, class: 'A', age1: 25, enumCol: 'a' })
+	);
+	const d3 = Effect.suspend(() => db.delete(users));
+	const d4 = Effect.suspend(() => db.run(`somequery`));
+
+	type Expected = Effect.Effect<RunResult, EffectDrizzleQueryError, never>;
+
+	Expect<Equal<typeof p1, Expected>>;
+	Expect<Equal<typeof p2, Expected>>;
+	Expect<Equal<typeof p3, Expected>>;
+	Expect<Equal<typeof p4, Expected>>;
+	Expect<Equal<typeof p5, Expected>>;
+	Expect<Equal<typeof p6, Expected>>;
+	Expect<Equal<typeof p7, Expected>>;
+	Expect<Equal<typeof p8, Expected>>;
+	Expect<Equal<typeof p9, Expected>>;
+	Expect<Equal<typeof p10, Expected>>;
+
+	Expect<Equal<typeof r1, Expected>>;
+	Expect<Equal<typeof r2, Expected>>;
+	Expect<Equal<typeof r3, Expected>>;
+	Expect<Equal<typeof r4, Expected>>;
+	Expect<Equal<typeof r5, Expected>>;
+	Expect<Equal<typeof r6, Expected>>;
+	Expect<Equal<typeof r7, Expected>>;
+	Expect<Equal<typeof r8, Expected>>;
+	Expect<Equal<typeof r9, Expected>>;
+	Expect<Equal<typeof r10, Expected>>;
+
+	Expect<Equal<typeof d1, Expected>>;
+	Expect<Equal<typeof d2, Expected>>;
+	Expect<Equal<typeof d3, Expected>>;
+	Expect<Equal<typeof d4, Expected>>;
+}
diff --git a/drizzle-orm/type-tests/sqlite/generated-columns.ts b/drizzle-orm/type-tests/sqlite/generated-columns.ts
index f1474baeda..2d86c2aaa0 100644
--- a/drizzle-orm/type-tests/sqlite/generated-columns.ts
+++ b/drizzle-orm/type-tests/sqlite/generated-columns.ts
@@ -99,46 +99,6 @@ const users = sqliteTable(
 	>();
 }
 
-{
-	const db = drizzle({} as any, { schema: { users } });
-
-	const dbUser = await db.query.users.findFirst();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string | null;
-				upperName: string | null;
-			} | undefined,
-			typeof dbUser
-		>
-	>();
-}
-
-{
-	const db = drizzle({} as any, { schema: { users } });
-
-	const dbUser = await db.query.users.findMany();
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				firstName: string | null;
-				lastName: string | null;
-				email: string;
-				fullName: string | null;
-				upperName: string | null;
-			}[],
-			typeof dbUser
-		>
-	>();
-}
-
 {
 	// @ts-expect-error - Can't use the fullName because it's a generated column
 	await db.insert(users).values({
diff --git a/drizzle-orm/type-tests/sqlite/insert.ts b/drizzle-orm/type-tests/sqlite/insert.ts
index 2092049a1e..adcf650620 100644
--- a/drizzle-orm/type-tests/sqlite/insert.ts
+++ b/drizzle-orm/type-tests/sqlite/insert.ts
@@ -1,4 +1,5 @@
 import type { RunResult } from 'better-sqlite3';
+import type { Changes } from 'bun:sqlite';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/sql/expressions/index.ts';
@@ -22,7 +23,7 @@ const insertRun = db.insert(users).values(newUser).run();
 Expect<Equal<RunResult, typeof insertRun>>;
 
 const insertRunBun = bunDb.insert(users).values(newUser).run();
-Expect<Equal<void, typeof insertRunBun>>;
+Expect<Equal<Changes, typeof insertRunBun>>;
 
 const insertAll = db.insert(users).values(newUser).all();
 Expect<Equal<DrizzleTypeError<'.all() cannot be used without .returning()'>, typeof insertAll>>;
@@ -46,7 +47,7 @@ const insertRunReturningAll = db.insert(users).values(newUser).returning().run()
 Expect<Equal<RunResult, typeof insertRunReturningAll>>;
 
 const insertRunReturningAllBun = bunDb.insert(users).values(newUser).returning().run();
-Expect<Equal<void, typeof insertRunReturningAllBun>>;
+Expect<Equal<Changes, typeof insertRunReturningAllBun>>;
 
 const insertAllReturningAll = db.insert(users).values(newUser).returning().all();
 Expect<Equal<typeof users.$inferSelect[], typeof insertAllReturningAll>>;
@@ -78,7 +79,7 @@ const insertRunReturningPartialBun = bunDb.insert(users).values(newUser).returni
 	homeCity: users.homeCity,
 	mySubclass: users.subClass,
 }).run();
-Expect<Equal<void, typeof insertRunReturningPartialBun>>;
+Expect<Equal<Changes, typeof insertRunReturningPartialBun>>;
 
 const insertAllReturningPartial = db.insert(users).values(newUser).returning({
 	id: users.id,
diff --git a/drizzle-orm/type-tests/sqlite/no-strict-null-checks/test.ts b/drizzle-orm/type-tests/sqlite/no-strict-null-checks/test.ts
deleted file mode 100644
index fa5ee58dd3..0000000000
--- a/drizzle-orm/type-tests/sqlite/no-strict-null-checks/test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { drizzle } from '~/better-sqlite3';
-import { sqliteTable, text } from '~/sqlite-core';
-
-export const test = sqliteTable(
-	'test',
-	{
-		id: text('id')
-			.primaryKey()
-			.generatedAlwaysAs('genstr'),
-		name: text('name').$defaultFn(() => '' as string),
-		title: text('title').notNull(),
-		description: text('description'),
-		dbdef: text('dbdef').default('dbdefval'),
-	},
-);
-
-const db = drizzle.mock();
-
-db.update(test)
-	.set({
-		// @ts-expect-error
-		id: '1',
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.update(test)
-	.set({
-		name: 'name',
-		title: 'title',
-		description: 'desc',
-		dbdef: 'upddef',
-	});
-
-db.insert(test).values({
-	// @ts-expect-error
-	id: '1',
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	name: 'name',
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-	dbdef: 'upddef',
-});
-
-db.insert(test).values({
-	title: 'title',
-	description: 'desc',
-});
-
-db.insert(test).values({
-	title: 'title',
-});
diff --git a/drizzle-orm/type-tests/sqlite/no-strict-null-checks/tsconfig.json b/drizzle-orm/type-tests/sqlite/no-strict-null-checks/tsconfig.json
deleted file mode 100644
index 6d5a4b7c0c..0000000000
--- a/drizzle-orm/type-tests/sqlite/no-strict-null-checks/tsconfig.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"noEmit": true,
-		"strictNullChecks": false,
-		"strictPropertyInitialization": false,
-		"exactOptionalPropertyTypes": false
-	},
-	"include": ["./test.ts"]
-}
diff --git a/drizzle-orm/type-tests/sqlite/select.ts b/drizzle-orm/type-tests/sqlite/select.ts
index 0140fc19bb..ebcb9ec91f 100644
--- a/drizzle-orm/type-tests/sqlite/select.ts
+++ b/drizzle-orm/type-tests/sqlite/select.ts
@@ -31,7 +31,7 @@ import type { SQLiteSelect, SQLiteSelectQueryBuilder } from '~/sqlite-core/query
 import { sqliteTable } from '~/sqlite-core/table.ts';
 import { sqliteView } from '~/sqlite-core/view.ts';
 import { db } from './db.ts';
-import { cities, classes, newYorkers, users } from './tables.ts';
+import { cities, classes, newYorkers, newYorkersWithSubquery, users } from './tables.ts';
 
 const city = alias(cities, 'city');
 const city1 = alias(cities, 'city1');
@@ -661,6 +661,35 @@ Expect<
 	>;
 }
 
+{
+	const result = db.select().from(newYorkersWithSubquery).all();
+	Expect<
+		Equal<
+			{
+				id: number;
+				class: 'A' | 'C';
+				cityCount: number;
+				lastCityId: number;
+			}[],
+			typeof result
+		>
+	>;
+	Expect<Equal<typeof result, typeof newYorkersWithSubquery.$inferSelect[]>>;
+	Expect<Equal<typeof result, InferSelectViewModel<typeof newYorkersWithSubquery>[]>>;
+}
+
+{
+	const result = db.select({ cityCount: newYorkersWithSubquery.cityCount }).from(newYorkersWithSubquery).all();
+	Expect<
+		Equal<
+			{
+				cityCount: number;
+			}[],
+			typeof result
+		>
+	>;
+}
+
 {
 	db
 		.select()
diff --git a/drizzle-orm/type-tests/sqlite/subquery.ts b/drizzle-orm/type-tests/sqlite/subquery.ts
index 573cfdf804..4c8c3d4e45 100644
--- a/drizzle-orm/type-tests/sqlite/subquery.ts
+++ b/drizzle-orm/type-tests/sqlite/subquery.ts
@@ -1,35 +1,42 @@
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/sql/expressions/index.ts';
+import { count } from '~/sql/functions/aggregate.ts';
 import { sql } from '~/sql/sql.ts';
 import { alias, integer, sqliteTable, text } from '~/sqlite-core/index.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
 
-const names = sqliteTable('names', {
+const users = sqliteTable('names', {
 	id: integer('id').primaryKey(),
 	name: text('name'),
+	managerId: integer('author_id'),
+});
+
+const posts = sqliteTable('posts', {
+	id: integer('id').primaryKey(),
 	authorId: integer('author_id'),
+	title: text('title'),
 });
 
 const n1 = db
 	.select({
-		id: names.id,
-		name: names.name,
-		authorId: names.authorId,
+		id: users.id,
+		name: users.name,
+		authorId: users.managerId,
 		count1: sql<number>`count(1)::int`.as('count1'),
 	})
-	.from(names)
-	.groupBy(names.id, names.name, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.name, users.managerId)
 	.as('n1');
 
 const n2 = db
 	.select({
-		id: names.id,
-		authorId: names.authorId,
+		id: users.id,
+		authorId: users.managerId,
 		totalCount: sql<number>`count(1)::int`.as('totalCount'),
 	})
-	.from(names)
-	.groupBy(names.id, names.authorId)
+	.from(users)
+	.groupBy(users.id, users.managerId)
 	.as('n2');
 
 const result = db
@@ -55,16 +62,16 @@ Expect<
 	>
 >;
 
-const names2 = alias(names, 'names2');
+const names2 = alias(users, 'names2');
 
 const sq1 = db
 	.select({
-		id: names.id,
-		name: names.name,
+		id: users.id,
+		name: users.name,
 		id2: names2.id,
 	})
-	.from(names)
-	.leftJoin(names2, eq(names.name, names2.name))
+	.from(users)
+	.leftJoin(names2, eq(users.name, names2.name))
 	.as('sq1');
 
 const res = db.select().from(sq1).all();
@@ -81,11 +88,11 @@ Expect<
 >;
 
 {
-	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
+	const sq = db.select({ count: sql<number>`count(1)::int` }).from(users).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
 
-const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+const sqUnion = db.select().from(users).union(db.select().from(names2)).as('sqUnion');
 
 const resUnion = await db.select().from(sqUnion);
 
@@ -93,6 +100,26 @@ Expect<
 	Equal<{
 		id: number;
 		name: string | null;
-		authorId: number | null;
+		managerId: number | null;
 	}[], typeof resUnion>
 >;
+
+const fromSubquery = await db.select({
+	count: db.select({ count: count().as('c') }).from(posts).where(eq(posts.authorId, users.id)).as('count'),
+}).from(users);
+
+Expect<Equal<typeof fromSubquery, { count: number }[]>>;
+
+const fromSubquery2 = await db.select({
+	name: db.select({ name: users.name }).from(users).where(eq(users.id, posts.authorId)).as('name'),
+}).from(posts);
+
+Expect<Equal<typeof fromSubquery2, { name: string | null }[]>>;
+
+const errorSubquery = await db.select({
+	name: db.select({ name: users.name, managerId: users.managerId }).from(users).where(eq(users.id, posts.authorId)).as(
+		'name',
+	),
+}).from(posts);
+
+Expect<Equal<typeof errorSubquery, { name: DrizzleTypeError<'You can only select one column in the subquery'> }[]>>;
diff --git a/drizzle-orm/type-tests/sqlite/sync-tx-no-promise.ts b/drizzle-orm/type-tests/sqlite/sync-tx-no-promise.ts
new file mode 100644
index 0000000000..e80905f497
--- /dev/null
+++ b/drizzle-orm/type-tests/sqlite/sync-tx-no-promise.ts
@@ -0,0 +1,14 @@
+import type { SQLiteAsyncDatabase } from '~/sqlite-core/async/db.ts';
+
+const syncDb = {} as SQLiteAsyncDatabase<'sync', never>;
+
+// @ts-expect-error
+syncDb.transaction(async (tx) => tx.get<{ one: 1 }>('SELECT 1 as one;'));
+
+syncDb.transaction((tx) => tx.get<{ one: 1 }>('SELECT 1 as one;'));
+
+const asyncDb = {} as SQLiteAsyncDatabase<'async', never>;
+
+asyncDb.transaction(async (tx) => tx.get<{ one: 1 }>('SELECT 1 as one;'));
+
+asyncDb.transaction((tx) => tx.get<{ one: 1 }>('SELECT 1 as one;'));
diff --git a/drizzle-orm/type-tests/sqlite/tables.ts b/drizzle-orm/type-tests/sqlite/tables.ts
index 55eefcab07..c1fd74b7dc 100644
--- a/drizzle-orm/type-tests/sqlite/tables.ts
+++ b/drizzle-orm/type-tests/sqlite/tables.ts
@@ -14,12 +14,11 @@ import {
 	numeric,
 	primaryKey,
 	real,
-	type SQLiteColumn,
 	sqliteTable,
 	text,
 	uniqueIndex,
 } from '~/sqlite-core/index.ts';
-import { sqliteView, type SQLiteViewWithSelection } from '~/sqlite-core/view.ts';
+import { sqliteView } from '~/sqlite-core/view.ts';
 import { db } from './db.ts';
 
 export const users = sqliteTable(
@@ -39,27 +38,27 @@ export const users = sqliteTable(
 		createdAt: integer('created_at', { mode: 'timestamp' }).notNull().defaultNow(),
 		enumCol: text('enum_col', { enum: ['a', 'b', 'c'] }).notNull(),
 	},
-	(users) => ({
-		usersAge1Idx: uniqueIndex('usersAge1Idx').on(users.class),
-		usersAge2Idx: index('usersAge2Idx').on(users.class),
-		uniqueClass: uniqueIndex('uniqueClass')
+	(users) => [
+		uniqueIndex('usersAge1Idx').on(users.class),
+		index('usersAge2Idx').on(users.class),
+		uniqueIndex('uniqueClass')
 			.on(users.class, users.subClass)
 			.where(
 				sql`${users.class} is not null`,
 			),
-		uniqueClassEvenBetterThanPrisma: uniqueIndex('uniqueClass')
+		uniqueIndex('uniqueClass')
 			.on(users.class, users.subClass)
 			.where(
 				sql`${users.class} is not null`,
 			),
-		legalAge: check('legalAge', sql`${users.age1} > 18`),
-		usersClassFK: foreignKey(() => ({ columns: [users.subClass], foreignColumns: [classes.subClass] })),
-		usersClassComplexFK: foreignKey(() => ({
+		check('legalAge', sql`${users.age1} > 18`),
+		foreignKey({ columns: [users.subClass], foreignColumns: [classes.subClass] }),
+		foreignKey({
 			columns: [users.class, users.subClass],
 			foreignColumns: [classes.class, classes.subClass],
-		})),
-		pk: primaryKey(users.age1, users.class),
-	}),
+		}),
+		primaryKey({ columns: [users.age1, users.class] }),
+	],
 );
 
 export type User = typeof users.$inferSelect;
@@ -157,50 +156,28 @@ export const newYorkers = sqliteView('new_yorkers')
 		return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
 	});
 
-Expect<
-	Equal<
-		SQLiteViewWithSelection<'new_yorkers', false, {
-			userId: SQLiteColumn<{
-				name: 'id';
-				dataType: 'number';
-				columnType: 'SQLiteInteger';
-				data: number;
-				driverParam: number;
-				notNull: true;
-				hasDefault: true;
-				tableName: 'new_yorkers';
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-				isPrimaryKey: true;
-			}>;
-			cityId: SQLiteColumn<{
-				name: 'id';
-				dataType: 'number';
-				columnType: 'SQLiteInteger';
-				data: number;
-				driverParam: number;
-				notNull: false;
-				hasDefault: true;
-				tableName: 'new_yorkers';
-				enumValues: undefined;
-				baseColumn: never;
-				generated: undefined;
-				identity: undefined;
-				isAutoincrement: false;
-				hasRuntimeDefault: false;
-				isPrimaryKey: true;
-			}>;
-		}>,
-		typeof newYorkers
-	>
->;
+export const newYorkersWithSubquery = sqliteView('new_yorkers_with_sq')
+	.as((qb) =>
+		qb
+			.select({
+				id: users.id,
+				class: users.class,
+				cityCount: qb
+					.select({ count: sql<number>`count(*)`.as('count') })
+					.from(cities)
+					.as('city_count'),
+				lastCityId: qb
+					.select({ id: cities.id })
+					.from(cities)
+					.orderBy(cities.id)
+					.limit(1)
+					.as('last_city'),
+			})
+			.from(users)
+	);
 
 {
-	const newYorkers = sqliteView('new_yorkers', {
+	const _newYorkers = sqliteView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	})
@@ -209,97 +186,13 @@ Expect<
 				eq(cities.id, users.homeCity)
 			} where ${gt(users.age1, 18)}`,
 		);
-
-	Expect<
-		Equal<
-			SQLiteViewWithSelection<'new_yorkers', false, {
-				userId: SQLiteColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'SQLiteInteger';
-					data: number;
-					driverParam: number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					isPrimaryKey: false;
-				}>;
-				cityId: SQLiteColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'SQLiteInteger';
-					data: number;
-					driverParam: number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					isPrimaryKey: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
-	const newYorkers = sqliteView('new_yorkers', {
+	const _newYorkers = sqliteView('new_yorkers', {
 		userId: integer('user_id').notNull(),
 		cityId: integer('city_id'),
 	}).existing();
-
-	Expect<
-		Equal<
-			SQLiteViewWithSelection<'new_yorkers', true, {
-				userId: SQLiteColumn<{
-					name: 'user_id';
-					dataType: 'number';
-					columnType: 'SQLiteInteger';
-					data: number;
-					driverParam: number;
-					hasDefault: false;
-					notNull: true;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					isPrimaryKey: false;
-				}>;
-				cityId: SQLiteColumn<{
-					name: 'city_id';
-					notNull: false;
-					hasDefault: false;
-					dataType: 'number';
-					columnType: 'SQLiteInteger';
-					data: number;
-					driverParam: number;
-					tableName: 'new_yorkers';
-					enumValues: undefined;
-					baseColumn: never;
-					generated: undefined;
-					identity: undefined;
-					isAutoincrement: false;
-					hasRuntimeDefault: false;
-					isPrimaryKey: false;
-				}>;
-			}>,
-			typeof newYorkers
-		>
-	>;
 }
 
 {
@@ -558,8 +451,8 @@ Expect<
 		name: text(),
 	});
 
-	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], 'id'>>;
-	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], 'name'>>;
+	Expect<Equal<typeof keysAsColumnNames['id']['_']['name'], string>>;
+	Expect<Equal<typeof keysAsColumnNames['name']['_']['name'], string>>;
 }
 
 {
diff --git a/drizzle-orm/type-tests/sqlite/update.ts b/drizzle-orm/type-tests/sqlite/update.ts
index 0cbdd464a0..9e6bef4423 100644
--- a/drizzle-orm/type-tests/sqlite/update.ts
+++ b/drizzle-orm/type-tests/sqlite/update.ts
@@ -1,4 +1,5 @@
 import type { RunResult } from 'better-sqlite3';
+import type { Changes } from 'bun:sqlite';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/sql/expressions/index.ts';
@@ -24,7 +25,7 @@ const updateRunBun = bunDb.update(users)
 	})
 	.where(eq(users.id, 1))
 	.run();
-Expect<Equal<void, typeof updateRunBun>>;
+Expect<Equal<Changes, typeof updateRunBun>>;
 
 const updateAll = db.update(users)
 	.set({
diff --git a/drizzle-orm/types-bench.ts b/drizzle-orm/types-bench.ts
new file mode 100644
index 0000000000..8c18abb9c4
--- /dev/null
+++ b/drizzle-orm/types-bench.ts
@@ -0,0 +1,1024 @@
+import { bench, setup } from '@arktype/attest';
+import { defineRelations as defy } from './src/relations.js';
+import * as schema from './tmp/big-schema.js';
+// import { defy } from "./src/relations2.js";
+// import * as schema from "./big-schema";
+
+setup({
+	skipTypes: true,
+});
+
+bench('relations', () => {
+	defy(schema, (r) => ({
+		user: {
+			workspacesViaApiWebhook: r.many.workspace({
+				from: r.user.id.through(r.apiWebhook.createdByUserId),
+				to: r.workspace.id.through(r.apiWebhook.workspaceId),
+				alias: 'user_id_workspace_id_via_apiWebhook',
+			}),
+			blockingTimeslots: r.many.blockingTimeslot(),
+			bookingLinksCreatedByUserId: r.many.bookingLink({
+				alias: 'bookingLink_createdByUserId_user_id',
+			}),
+			bookingSettings: r.one.bookingSettings(),
+			emailAccounts: r.many.emailAccount(),
+			apiKeys: r.many.apiKey(),
+			threadsViaComment: r.many.thread({
+				from: r.user.id.through(r.comment.createdByUserId),
+				to: r.thread.id.through(r.comment.threadId),
+				alias: 'user_id_thread_id_via_comment',
+			}),
+			calendarWebhooks: r.many.calendarWebhook(),
+			bookingLinksViaInviteeBooking: r.many.bookingLink({
+				alias: 'bookingLink_id_user_id_via_inviteeBooking',
+			}),
+			meetingActionItems: r.many.meetingActionItem(),
+			notesCreatedByUserId: r.many.notes({
+				alias: 'notes_createdByUserId_user_id',
+			}),
+			notesPublishedByUserId: r.many.notes({
+				alias: 'notes_publishedByUserId_user_id',
+			}),
+			motionSubscriptions: r.one.motionSubscription(),
+			notesViaNoteDataSnapshot: r.many.notes({
+				from: r.user.id.through(r.noteDataSnapshot.createdByUserId),
+				to: r.notes.id.through(r.noteDataSnapshot.noteId),
+				alias: 'user_id_notes_id_via_noteDataSnapshot',
+			}),
+			notesViaNoteMention: r.many.notes({
+				from: r.user.id.through(r.noteMention.createdByUserId),
+				to: r.notes.id.through(r.noteMention.noteId),
+				alias: 'user_id_notes_id_via_noteMention',
+			}),
+			notesViaNoteUserLastViewed: r.many.notes({
+				alias: 'notes_id_user_id_via_noteUserLastViewed',
+			}),
+			projectDefinitionsCreatedByUserId: r.many.projectDefinition({
+				alias: 'projectDefinition_createdByUserId_user_id',
+			}),
+			projectDefinitionsManagerId: r.many.projectDefinition({
+				alias: 'projectDefinition_managerId_user_id',
+			}),
+			projectsCreatedByUserId: r.many.project({
+				alias: 'project_createdByUserId_user_id',
+			}),
+			projectsManagerId: r.many.project({
+				alias: 'project_managerId_user_id',
+			}),
+			reactions: r.many.reaction(),
+			referrals: r.many.referral(),
+			recurringTasksAssigneeUserId: r.many.recurringTask({
+				alias: 'recurringTask_assigneeUserId_user_id',
+			}),
+			recurringTasksCreatedByUserId: r.many.recurringTask({
+				alias: 'recurringTask_createdByUserId_user_id',
+			}),
+			projectManagementViews: r.many.projectManagementView(),
+			taskDefinitions: r.many.taskDefinition(),
+			teamsViaTeamInvite: r.many.team({
+				from: r.user.id.through(r.teamInvite.inviterId),
+				to: r.team.id.through(r.teamInvite.teamId),
+				alias: 'user_id_team_id_via_teamInvite',
+			}),
+			teamTasksAssigneeUserId: r.many.teamTask({
+				alias: 'teamTask_assigneeUserId_user_id',
+			}),
+			teamTasksCreatedByUserId: r.many.teamTask({
+				alias: 'teamTask_createdByUserId_user_id',
+			}),
+			teamsViaTeamMember: r.many.team({
+				alias: 'team_id_user_id_via_teamMember',
+			}),
+			uploadedFiles: r.many.uploadedFile(),
+			threadsCreatedByUserId: r.many.thread({
+				alias: 'thread_createdByUserId_user_id',
+			}),
+			userNotificationPreferences: r.many.userNotificationPreferences(),
+			userOauthCodes: r.many.userOauthCode(),
+			featurePermissionTiers: r.many.featurePermissionTiers(),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings(),
+			userTutorials: r.one.userTutorials(),
+			workspacesViaWorkspaceMember: r.many.workspace({
+				from: r.user.id.through(r.workspaceMember.userId),
+				to: r.workspace.id.through(r.workspaceMember.workspaceId),
+				alias: 'user_id_workspace_id_via_workspaceMember',
+			}),
+			userSettings: r.one.userSettings(),
+			teamTasksViaTaskSubscribedUsers: r.many.teamTask({
+				alias: 'teamTask_id_user_id_via_taskSubscribedUsers',
+			}),
+		},
+		workspace: {
+			usersViaApiWebhook: r.many.user({
+				alias: 'user_id_workspace_id_via_apiWebhook',
+			}),
+			customFieldInstances: r.many.customFieldInstance(),
+			labels: r.many.label(),
+			notes: r.many.notes(),
+			projectDefinitionsWorkspaceId: r.many.projectDefinition({
+				alias: 'projectDefinition_workspaceId_workspace_id',
+			}),
+			projectsWorkspaceId: r.many.project({
+				alias: 'project_workspaceId_workspace_id',
+			}),
+			projectDefinitionsViaStageDefinition: r.many.projectDefinition({
+				alias: 'projectDefinition_id_workspace_id_via_stageDefinition',
+			}),
+			recurringTasks: r.many.recurringTask(),
+			taskDefinitions: r.many.taskDefinition(),
+			teamTasksWorkspaceId: r.many.teamTask({
+				alias: 'teamTask_workspaceId_workspace_id',
+			}),
+			taskStatuses: r.many.taskStatus(),
+			projectsViaTemplateProject: r.many.project({
+				alias: 'project_id_workspace_id_via_templateProject',
+			}),
+			teamTasksViaTemplateTask: r.many.teamTask({
+				alias: 'teamTask_id_workspace_id_via_templateTask',
+			}),
+			uploadedFiles: r.many.uploadedFile(),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings(),
+			usersViaWorkspaceMember: r.many.user({
+				alias: 'user_id_workspace_id_via_workspaceMember',
+			}),
+			team: r.one.team({
+				from: r.workspace.teamId,
+				to: r.team.id,
+			}),
+			workspaceTaskSequencers: r.one.workspaceTaskSequencer(),
+		},
+		blockingTimeslot: {
+			user: r.one.user({
+				from: r.blockingTimeslot.userId,
+				to: r.user.id,
+			}),
+		},
+		bookingLink: {
+			user: r.one.user({
+				from: r.bookingLink.createdByUserId,
+				to: r.user.id,
+				alias: 'bookingLink_createdByUserId_user_id',
+			}),
+			bookingLink: r.one.bookingLink({
+				from: r.bookingLink.parentTemplateId,
+				to: r.bookingLink.id,
+				alias: 'bookingLink_parentTemplateId_bookingLink_id',
+			}),
+			bookingLinks: r.many.bookingLink({
+				alias: 'bookingLink_parentTemplateId_bookingLink_id',
+			}),
+			team: r.one.team({
+				from: r.bookingLink.teamId,
+				to: r.team.id,
+			}),
+			bookingConflictCalendars: r.many.bookingConflictCalendar(),
+			bookingQuestions: r.many.bookingQuestion(),
+			users: r.many.user({
+				from: r.bookingLink.id.through(r.inviteeBooking.bookingLinkId),
+				to: r.user.id.through(r.inviteeBooking.linkCreatorId),
+				alias: 'bookingLink_id_user_id_via_inviteeBooking',
+			}),
+			bookingAvailabilitySlots: r.many.bookingAvailabilitySlot(),
+		},
+		team: {
+			bookingLinks: r.many.bookingLink(),
+			integrations: r.many.integration(),
+			meetingInsightsTeamSettings: r.one.meetingInsightsTeamSettings(),
+			motionSubscriptions: r.one.motionSubscription(),
+			meetingInsights: r.many.meetingInsights(),
+			permissionRoles: r.many.permissionRole(),
+			teamPaymentMethods: r.one.teamPaymentMethod(),
+			usersViaTeamInvite: r.many.user({
+				alias: 'user_id_team_id_via_teamInvite',
+			}),
+			teamSettings: r.one.teamSettings(),
+			usersViaTeamMember: r.many.user({
+				from: r.team.id.through(r.teamMember.teamId),
+				to: r.user.id.through(r.teamMember.userId),
+				alias: 'team_id_user_id_via_teamMember',
+			}),
+			featurePermissionTiers: r.many.featurePermissionTiers(),
+			workspaces: r.many.workspace(),
+			permissionPolicies: r.many.permissionPolicy(),
+		},
+		bookingConflictCalendar: {
+			bookingLink: r.one.bookingLink({
+				from: r.bookingConflictCalendar.bookingLinkId,
+				to: r.bookingLink.id,
+			}),
+		},
+		bookingQuestion: {
+			bookingLink: r.one.bookingLink({
+				from: r.bookingQuestion.bookingLinkId,
+				to: r.bookingLink.id,
+			}),
+		},
+		bookingSettings: {
+			user: r.one.user({
+				from: r.bookingSettings.userId,
+				to: r.user.id,
+			}),
+		},
+		emailAccount: {
+			users: r.many.user({
+				from: r.emailAccount.id.through(r.calendar.emailAccountId),
+				to: r.user.id.through(r.calendar.userId),
+			}),
+		},
+		calendarEventExtensions: {
+			calendar: r.one.calendar({
+				from: r.calendarEventExtensions.calendarId,
+				to: r.calendar.id,
+			}),
+		},
+		calendar: {
+			calendarEventExtensions: r.many.calendarEventExtensions(),
+		},
+		calendarEvent: {
+			syncSession: r.one.syncSession({
+				from: r.calendarEvent.syncSessionId,
+				to: r.syncSession.id,
+			}),
+			meetingTaskRelations: r.one.meetingTaskRelation(),
+		},
+		syncSession: {
+			calendarEvents: r.many.calendarEvent(),
+		},
+		apiKey: {
+			user: r.one.user({
+				from: r.apiKey.userId,
+				to: r.user.id,
+			}),
+		},
+		customFieldInstance: {
+			workspace: r.one.workspace({
+				from: r.customFieldInstance.workspaceId,
+				to: r.workspace.id,
+			}),
+			customFieldValues: r.many.customFieldValue(),
+			projects: r.many.project({
+				from: r.customFieldInstance.id.through(
+					r.projectTaskSyncedCustomField.customFieldInstanceId,
+				),
+				to: r.project.id.through(r.projectTaskSyncedCustomField.projectId),
+			}),
+		},
+		customFieldValue: {
+			customFieldInstance: r.one.customFieldInstance({
+				from: r.customFieldValue.instanceId,
+				to: r.customFieldInstance.id,
+			}),
+		},
+		thread: {
+			users: r.many.user({
+				alias: 'user_id_thread_id_via_comment',
+			}),
+			user: r.one.user({
+				from: r.thread.createdByUserId,
+				to: r.user.id,
+				alias: 'thread_createdByUserId_user_id',
+			}),
+		},
+		calendarWebhook: {
+			user: r.one.user({
+				from: r.calendarWebhook.userId,
+				to: r.user.id,
+			}),
+		},
+		integrationImport: {
+			integration: r.one.integration({
+				from: r.integrationImport.integrationId,
+				to: r.integration.id,
+			}),
+			importMappings: r.many.importMapping(),
+			syncedEntities: r.many.syncedEntity(),
+		},
+		integration: {
+			integrationImports: r.many.integrationImport(),
+			team: r.one.team({
+				from: r.integration.teamId,
+				to: r.team.id,
+			}),
+		},
+		importMapping: {
+			integrationImport: r.one.integrationImport({
+				from: r.importMapping.integrationImportId,
+				to: r.integrationImport.id,
+			}),
+		},
+		label: {
+			workspace: r.one.workspace({
+				from: r.label.workspaceId,
+				to: r.workspace.id,
+			}),
+			projectDefinitions: r.many.projectDefinition({
+				from: r.label.id.through(r.projectDefinitionLabel.labelId),
+				to: r.projectDefinition.id.through(
+					r.projectDefinitionLabel.projectDefinitionId,
+				),
+			}),
+			recurringTasks: r.many.recurringTask({
+				from: r.label.id.through(r.recurringTaskLabel.labelId),
+				to: r.recurringTask.id.through(r.recurringTaskLabel.recurringTaskId),
+			}),
+			projects: r.many.project({
+				from: r.label.id.through(r.projectLabel.labelId),
+				to: r.project.id.through(r.projectLabel.projectId),
+			}),
+			taskDefinitions: r.many.taskDefinition({
+				from: r.label.id.through(r.taskDefinitionLabel.labelId),
+				to: r.taskDefinition.id.through(r.taskDefinitionLabel.taskDefinitionId),
+			}),
+			teamTasks: r.many.teamTask({
+				from: r.label.id.through(r.teamTaskLabel.labelId),
+				to: r.teamTask.id.through(r.teamTaskLabel.taskId),
+			}),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings({
+				from: r.label.id.through(r.userTaskDefaultSettingsLabel.labelId),
+				to: r.userTaskDefaultSettings.id.through(
+					r.userTaskDefaultSettingsLabel.userTaskDefaultSettingsId,
+				),
+			}),
+		},
+		meetingActionItem: {
+			meetingInsight: r.one.meetingInsights({
+				from: r.meetingActionItem.meetingInsightsId,
+				to: r.meetingInsights.id,
+			}),
+			teamTaskPotentialDuplicateTaskId: r.one.teamTask({
+				from: r.meetingActionItem.potentialDuplicateTaskId,
+				to: r.teamTask.id,
+				alias: 'meetingActionItem_potentialDuplicateTaskId_teamTask_id',
+			}),
+			teamTaskTaskId: r.one.teamTask({
+				from: r.meetingActionItem.taskId,
+				to: r.teamTask.id,
+				alias: 'meetingActionItem_taskId_teamTask_id',
+			}),
+			user: r.one.user({
+				from: r.meetingActionItem.triagedByUserId,
+				to: r.user.id,
+			}),
+		},
+		meetingInsights: {
+			meetingActionItems: r.many.meetingActionItem(),
+			note: r.one.notes({
+				from: r.meetingInsights.noteId,
+				to: r.notes.id,
+			}),
+			recurringMeetingInsight: r.one.recurringMeetingInsights({
+				from: r.meetingInsights.parentId,
+				to: r.recurringMeetingInsights.id,
+			}),
+			team: r.one.team({
+				from: r.meetingInsights.teamId,
+				to: r.team.id,
+			}),
+		},
+		teamTask: {
+			meetingActionItemsPotentialDuplicateTaskId: r.many.meetingActionItem({
+				alias: 'meetingActionItem_potentialDuplicateTaskId_teamTask_id',
+			}),
+			meetingActionItemsTaskId: r.one.meetingActionItem({
+				alias: 'meetingActionItem_taskId_teamTask_id',
+			}),
+			taskScheduledEntities: r.many.taskScheduledEntity(),
+			userAssigneeUserId: r.one.user({
+				from: r.teamTask.assigneeUserId,
+				to: r.user.id,
+				alias: 'teamTask_assigneeUserId_user_id',
+			}),
+			userCreatedByUserId: r.one.user({
+				from: r.teamTask.createdByUserId,
+				to: r.user.id,
+				alias: 'teamTask_createdByUserId_user_id',
+			}),
+			meetingTaskRelation: r.one.meetingTaskRelation({
+				from: r.teamTask.meetingRelationId,
+				to: r.meetingTaskRelation.id,
+			}),
+			teamTaskMeetingTaskId: r.one.teamTask({
+				from: r.teamTask.meetingTaskId,
+				to: r.teamTask.id,
+				alias: 'teamTask_meetingTaskId_teamTask_id',
+			}),
+			teamTasksMeetingTaskId: r.one.teamTask({
+				alias: 'teamTask_meetingTaskId_teamTask_id',
+			}),
+			teamTaskParentChunkTaskId: r.one.teamTask({
+				from: r.teamTask.parentChunkTaskId,
+				to: r.teamTask.id,
+				alias: 'teamTask_parentChunkTaskId_teamTask_id',
+			}),
+			teamTasksParentChunkTaskId: r.many.teamTask({
+				alias: 'teamTask_parentChunkTaskId_teamTask_id',
+			}),
+			recurringTask: r.one.recurringTask({
+				from: r.teamTask.parentRecurringTaskId,
+				to: r.recurringTask.id,
+			}),
+			project: r.one.project({
+				from: r.teamTask.projectId,
+				to: r.project.id,
+			}),
+			stage: r.one.stage({
+				from: [r.teamTask.projectId, r.teamTask.stageDefinitionId],
+				to: [r.stage.projectId, r.stage.stageDefinitionId],
+			}),
+			stageDefinition: r.one.stageDefinition({
+				from: r.teamTask.stageDefinitionId,
+				to: r.stageDefinition.id,
+			}),
+			taskStatus: r.one.taskStatus({
+				from: r.teamTask.statusId,
+				to: r.taskStatus.id,
+			}),
+			taskDefinition: r.one.taskDefinition({
+				from: r.teamTask.taskDefinitionId,
+				to: r.taskDefinition.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.teamTask.workspaceId,
+				to: r.workspace.id,
+				alias: 'teamTask_workspaceId_workspace_id',
+			}),
+			workspaces: r.many.workspace({
+				from: r.teamTask.id.through(r.templateTask.taskId),
+				to: r.workspace.id.through(r.templateTask.workspaceId),
+				alias: 'teamTask_id_workspace_id_via_templateTask',
+			}),
+			uploadedFiles: r.many.uploadedFile(),
+			labels: r.many.label(),
+			users: r.many.user({
+				from: r.teamTask.id.through(r.taskSubscribedUsers.taskId),
+				to: r.user.id.through(r.taskSubscribedUsers.userId),
+				alias: 'teamTask_id_user_id_via_taskSubscribedUsers',
+			}),
+		},
+		meetingInsightsTeamSettings: {
+			team: r.one.team({
+				from: r.meetingInsightsTeamSettings.teamId,
+				to: r.team.id,
+			}),
+		},
+		notes: {
+			userCreatedByUserId: r.one.user({
+				from: r.notes.createdByUserId,
+				to: r.user.id,
+				alias: 'notes_createdByUserId_user_id',
+			}),
+			note: r.one.notes({
+				from: r.notes.parentNoteId,
+				to: r.notes.id,
+				alias: 'notes_parentNoteId_notes_id',
+			}),
+			notes: r.many.notes({
+				alias: 'notes_parentNoteId_notes_id',
+			}),
+			userPublishedByUserId: r.one.user({
+				from: r.notes.publishedByUserId,
+				to: r.user.id,
+				alias: 'notes_publishedByUserId_user_id',
+			}),
+			workspace: r.one.workspace({
+				from: r.notes.workspaceId,
+				to: r.workspace.id,
+			}),
+			usersViaNoteDataSnapshot: r.many.user({
+				alias: 'user_id_notes_id_via_noteDataSnapshot',
+			}),
+			usersViaNoteMention: r.many.user({
+				alias: 'user_id_notes_id_via_noteMention',
+			}),
+			usersViaNoteUserLastViewed: r.many.user({
+				from: r.notes.id.through(r.noteUserLastViewed.noteId),
+				to: r.user.id.through(r.noteUserLastViewed.userId),
+				alias: 'notes_id_user_id_via_noteUserLastViewed',
+			}),
+			meetingInsights: r.many.meetingInsights(),
+			recurringMeetingInsights: r.one.recurringMeetingInsights(),
+		},
+		motionSubscription: {
+			featurePermissionTier: r.one.featurePermissionTiers({
+				from: r.motionSubscription.featurePermissionTierId,
+				to: r.featurePermissionTiers.id,
+			}),
+			team: r.one.team({
+				from: r.motionSubscription.teamId,
+				to: r.team.id,
+			}),
+			user: r.one.user({
+				from: r.motionSubscription.userId,
+				to: r.user.id,
+			}),
+			userSubscriptions: r.many.userSubscription({
+				from: r.motionSubscription.id.through(
+					r.stripeSubscription.motionSubscriptionId,
+				),
+				to: r.userSubscription.id.through(
+					r.stripeSubscription.userSubscriptionId,
+				),
+			}),
+		},
+		featurePermissionTiers: {
+			motionSubscriptions: r.many.motionSubscription(),
+			teams: r.many.team({
+				from: r.featurePermissionTiers.id.through(
+					r.teamSubscription.featurePermissionTierId,
+				),
+				to: r.team.id.through(r.teamSubscription.teamId),
+			}),
+			users: r.many.user({
+				from: r.featurePermissionTiers.id.through(
+					r.userSubscription.featurePermissionTierId,
+				),
+				to: r.user.id.through(r.userSubscription.userId),
+			}),
+		},
+		permission: {
+			permissionRole: r.one.permissionRole({
+				from: r.permission.permissionRoleId,
+				to: r.permissionRole.id,
+			}),
+		},
+		permissionRole: {
+			permissions: r.many.permission(),
+			team: r.one.team({
+				from: r.permissionRole.teamId,
+				to: r.team.id,
+			}),
+			permissionRoleAssignments: r.many.permissionRoleAssignment(),
+		},
+		meetingTaskRelation: {
+			calendarEvent: r.one.calendarEvent({
+				from: r.meetingTaskRelation.calendarEventId,
+				to: r.calendarEvent.id,
+			}),
+			teamTasks: r.one.teamTask(),
+		},
+		recurringMeetingInsights: {
+			meetingInsights: r.many.meetingInsights(),
+			note: r.one.notes({
+				from: r.recurringMeetingInsights.noteId,
+				to: r.notes.id,
+			}),
+		},
+		meetingInsightsSettings: {
+			userSetting: r.one.userSettings({
+				from: r.meetingInsightsSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userSettings: {
+			meetingInsightsSettings: r.one.meetingInsightsSettings(),
+			userAutoScheduleSettings: r.one.userAutoScheduleSettings(),
+			userCalendarDisplaySettings: r.one.userCalendarDisplaySettings(),
+			userConferenceSettings: r.one.userConferenceSettings(),
+			folderItems: r.many.folderItem(),
+			folders: r.many.folder(),
+			userMeetingInsightsSettings: r.one.userMeetingInsightsSettings(),
+			userSidebarDisplaySettings: r.one.userSidebarDisplaySettings(),
+			userOnboardingSettings: r.one.userOnboardingSettings(),
+			userTimezoneSettings: r.one.userTimezoneSettings(),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings(),
+			user: r.one.user({
+				from: r.userSettings.userId,
+				to: r.user.id,
+			}),
+			userPageViewSettings: r.many.userPageViewSettings(),
+		},
+		projectDefinition: {
+			labels: r.many.label(),
+			stageDefinitionsViaProjectDefinitionStageDefinition: r.many.stageDefinition({
+				from: r.projectDefinition.id.through(
+					r.projectDefinitionStageDefinition.projectDefinitionId,
+				),
+				to: r.stageDefinition.id.through(
+					r.projectDefinitionStageDefinition.stageDefinitionId,
+				),
+				alias: 'projectDefinition_id_stageDefinition_id_via_projectDefinitionStageDefinition',
+			}),
+			userCreatedByUserId: r.one.user({
+				from: r.projectDefinition.createdByUserId,
+				to: r.user.id,
+				alias: 'projectDefinition_createdByUserId_user_id',
+			}),
+			folder: r.one.folder({
+				from: r.projectDefinition.folderId,
+				to: r.folder.id,
+			}),
+			userManagerId: r.one.user({
+				from: r.projectDefinition.managerId,
+				to: r.user.id,
+				alias: 'projectDefinition_managerId_user_id',
+			}),
+			workspace: r.one.workspace({
+				from: r.projectDefinition.workspaceId,
+				to: r.workspace.id,
+				alias: 'projectDefinition_workspaceId_workspace_id',
+			}),
+			projects: r.many.project(),
+			workspaces: r.many.workspace({
+				from: r.projectDefinition.id.through(
+					r.stageDefinition.projectDefinitionId,
+				),
+				to: r.workspace.id.through(r.stageDefinition.workspaceId),
+				alias: 'projectDefinition_id_workspace_id_via_stageDefinition',
+			}),
+			taskDefinitions: r.many.taskDefinition(),
+			stageDefinitionsViaVariableDefinition: r.many.stageDefinition({
+				from: r.projectDefinition.id.through(
+					r.variableDefinition.projectDefinitionId,
+				),
+				to: r.stageDefinition.id.through(
+					r.variableDefinition.stageDefinitionId,
+				),
+				alias: 'projectDefinition_id_stageDefinition_id_via_variableDefinition',
+			}),
+		},
+		stageDefinition: {
+			projectDefinitionsViaProjectDefinitionStageDefinition: r.many.projectDefinition({
+				alias: 'projectDefinition_id_stageDefinition_id_via_projectDefinitionStageDefinition',
+			}),
+			projects: r.many.project(),
+			stages: r.many.stage(),
+			taskDefinitions: r.many.taskDefinition(),
+			teamTasks: r.many.teamTask(),
+			projectDefinitionsViaVariableDefinition: r.many.projectDefinition({
+				alias: 'projectDefinition_id_stageDefinition_id_via_variableDefinition',
+			}),
+		},
+		folder: {
+			projectDefinitions: r.many.projectDefinition(),
+			userSettings: r.many.userSettings({
+				from: r.folder.id.through(r.userFolderSettings.folderId),
+				to: r.userSettings.id.through(r.userFolderSettings.userSettingsId),
+			}),
+			folderItems: r.many.folderItem(),
+		},
+		project: {
+			stageDefinition: r.one.stageDefinition({
+				from: r.project.activeStageDefinitionId,
+				to: r.stageDefinition.id,
+			}),
+			userCreatedByUserId: r.one.user({
+				from: r.project.createdByUserId,
+				to: r.user.id,
+				alias: 'project_createdByUserId_user_id',
+			}),
+			userManagerId: r.one.user({
+				from: r.project.managerId,
+				to: r.user.id,
+				alias: 'project_managerId_user_id',
+			}),
+			projectDefinition: r.one.projectDefinition({
+				from: r.project.projectDefinitionId,
+				to: r.projectDefinition.id,
+			}),
+			taskStatus: r.one.taskStatus({
+				from: r.project.statusId,
+				to: r.taskStatus.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.project.workspaceId,
+				to: r.workspace.id,
+				alias: 'project_workspaceId_workspace_id',
+			}),
+			customFieldInstances: r.many.customFieldInstance(),
+			stages: r.many.stage(),
+			labels: r.many.label(),
+			teamTasks: r.many.teamTask(),
+			workspaces: r.many.workspace({
+				from: r.project.id.through(r.templateProject.projectId),
+				to: r.workspace.id.through(r.templateProject.workspaceId),
+				alias: 'project_id_workspace_id_via_templateProject',
+			}),
+			uploadedFiles: r.many.uploadedFile(),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings(),
+			variableInstances: r.many.variableInstance(),
+		},
+		taskStatus: {
+			projects: r.many.project(),
+			recurringTasks: r.many.recurringTask(),
+			taskDefinitions: r.many.taskDefinition(),
+			teamTasks: r.many.teamTask(),
+			workspace: r.one.workspace({
+				from: r.taskStatus.workspaceId,
+				to: r.workspace.id,
+			}),
+			userTaskDefaultSettings: r.many.userTaskDefaultSettings(),
+		},
+		reaction: {
+			user: r.one.user({
+				from: r.reaction.userId,
+				to: r.user.id,
+			}),
+		},
+		recurringTask: {
+			labels: r.many.label(),
+			userAssigneeUserId: r.one.user({
+				from: r.recurringTask.assigneeUserId,
+				to: r.user.id,
+				alias: 'recurringTask_assigneeUserId_user_id',
+			}),
+			userCreatedByUserId: r.one.user({
+				from: r.recurringTask.createdByUserId,
+				to: r.user.id,
+				alias: 'recurringTask_createdByUserId_user_id',
+			}),
+			taskStatus: r.one.taskStatus({
+				from: r.recurringTask.statusId,
+				to: r.taskStatus.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.recurringTask.workspaceId,
+				to: r.workspace.id,
+			}),
+			teamTasks: r.many.teamTask(),
+			uploadedFiles: r.many.uploadedFile(),
+		},
+		referral: {
+			user: r.one.user({
+				from: r.referral.referrerId,
+				to: r.user.id,
+			}),
+		},
+		stage: {
+			projectDefinitionStageDefinition: r.one.projectDefinitionStageDefinition({
+				from: r.stage.projectDefinitionStageDefinitionId,
+				to: r.projectDefinitionStageDefinition.id,
+			}),
+			project: r.one.project({
+				from: r.stage.projectId,
+				to: r.project.id,
+			}),
+			stageDefinition: r.one.stageDefinition({
+				from: r.stage.stageDefinitionId,
+				to: r.stageDefinition.id,
+			}),
+			teamTasks: r.many.teamTask(),
+			variableInstances: r.many.variableInstance(),
+		},
+		projectDefinitionStageDefinition: {
+			stages: r.many.stage(),
+		},
+		userSubscription: {
+			motionSubscriptions: r.many.motionSubscription(),
+		},
+		syncedEntity: {
+			integrationImport: r.one.integrationImport({
+				from: r.syncedEntity.integrationImportId,
+				to: r.integrationImport.id,
+			}),
+		},
+		projectManagementView: {
+			user: r.one.user({
+				from: r.projectManagementView.creatorUserId,
+				to: r.user.id,
+			}),
+		},
+		taskDefinition: {
+			labels: r.many.label(),
+			user: r.one.user({
+				from: r.taskDefinition.assigneeUserId,
+				to: r.user.id,
+			}),
+			taskDefinition: r.one.taskDefinition({
+				from: r.taskDefinition.blockerId,
+				to: r.taskDefinition.id,
+				alias: 'taskDefinition_blockerId_taskDefinition_id',
+			}),
+			taskDefinitions: r.many.taskDefinition({
+				alias: 'taskDefinition_blockerId_taskDefinition_id',
+			}),
+			projectDefinition: r.one.projectDefinition({
+				from: r.taskDefinition.projectDefinitionId,
+				to: r.projectDefinition.id,
+			}),
+			stageDefinition: r.one.stageDefinition({
+				from: r.taskDefinition.stageDefinitionId,
+				to: r.stageDefinition.id,
+			}),
+			taskStatus: r.one.taskStatus({
+				from: r.taskDefinition.statusId,
+				to: r.taskStatus.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.taskDefinition.workspaceId,
+				to: r.workspace.id,
+			}),
+			teamTasks: r.many.teamTask(),
+		},
+		teamPaymentMethod: {
+			team: r.one.team({
+				from: r.teamPaymentMethod.teamId,
+				to: r.team.id,
+			}),
+		},
+		taskScheduledEntity: {
+			teamTask: r.one.teamTask({
+				from: r.taskScheduledEntity.parentTaskId,
+				to: r.teamTask.id,
+			}),
+		},
+		teamSettings: {
+			team: r.one.team({
+				from: r.teamSettings.teamId,
+				to: r.team.id,
+			}),
+			teamMeetingInsightsSettings: r.one.teamMeetingInsightsSettings(),
+		},
+		teamMeetingInsightsSettings: {
+			teamSetting: r.one.teamSettings({
+				from: r.teamMeetingInsightsSettings.teamSettingsId,
+				to: r.teamSettings.id,
+			}),
+		},
+		uploadedFile: {
+			comment: r.one.comment({
+				from: r.uploadedFile.commentId,
+				to: r.comment.id,
+			}),
+			user: r.one.user({
+				from: r.uploadedFile.createdByUserId,
+				to: r.user.id,
+			}),
+			project: r.one.project({
+				from: r.uploadedFile.projectId,
+				to: r.project.id,
+			}),
+			recurringTask: r.one.recurringTask({
+				from: r.uploadedFile.recurringTaskId,
+				to: r.recurringTask.id,
+			}),
+			teamTask: r.one.teamTask({
+				from: r.uploadedFile.taskId,
+				to: r.teamTask.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.uploadedFile.workspaceId,
+				to: r.workspace.id,
+			}),
+		},
+		comment: {
+			uploadedFiles: r.many.uploadedFile(),
+		},
+		userAutoScheduleSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userAutoScheduleSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userCalendarDisplaySettings: {
+			userSetting: r.one.userSettings({
+				from: r.userCalendarDisplaySettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userConferenceSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userConferenceSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		folderItem: {
+			userSettings: r.many.userSettings({
+				from: r.folderItem.id.through(r.userFolderItemSettings.folderItemId),
+				to: r.userSettings.id.through(r.userFolderItemSettings.userSettingsId),
+			}),
+			folder: r.one.folder({
+				from: r.folderItem.folderId,
+				to: r.folder.id,
+			}),
+			folderItemOriginalFolderItemId: r.one.folderItem({
+				from: r.folderItem.originalFolderItemId,
+				to: r.folderItem.id,
+				alias: 'folderItem_originalFolderItemId_folderItem_id',
+			}),
+			folderItemsOriginalFolderItemId: r.many.folderItem({
+				alias: 'folderItem_originalFolderItemId_folderItem_id',
+			}),
+			folderItemParentFolderItemId: r.one.folderItem({
+				from: r.folderItem.parentFolderItemId,
+				to: r.folderItem.id,
+				alias: 'folderItem_parentFolderItemId_folderItem_id',
+			}),
+			folderItemsParentFolderItemId: r.many.folderItem({
+				alias: 'folderItem_parentFolderItemId_folderItem_id',
+			}),
+		},
+		userMeetingInsightsSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userMeetingInsightsSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userNotificationPreferences: {
+			user: r.one.user({
+				from: r.userNotificationPreferences.userId,
+				to: r.user.id,
+			}),
+		},
+		userOauthCode: {
+			user: r.one.user({
+				from: r.userOauthCode.userId,
+				to: r.user.id,
+			}),
+		},
+		userSidebarDisplaySettings: {
+			userSetting: r.one.userSettings({
+				from: r.userSidebarDisplaySettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userTaskDefaultSettings: {
+			labels: r.many.label(),
+			user: r.one.user({
+				from: r.userTaskDefaultSettings.assigneeUserId,
+				to: r.user.id,
+			}),
+			project: r.one.project({
+				from: r.userTaskDefaultSettings.projectId,
+				to: r.project.id,
+			}),
+			taskStatus: r.one.taskStatus({
+				from: r.userTaskDefaultSettings.statusId,
+				to: r.taskStatus.id,
+			}),
+			userSetting: r.one.userSettings({
+				from: r.userTaskDefaultSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+			workspace: r.one.workspace({
+				from: r.userTaskDefaultSettings.workspaceId,
+				to: r.workspace.id,
+			}),
+		},
+		userOnboardingSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userOnboardingSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userTimezoneSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userTimezoneSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		userTutorials: {
+			user: r.one.user({
+				from: r.userTutorials.userId,
+				to: r.user.id,
+			}),
+		},
+		variableInstance: {
+			project: r.one.project({
+				from: r.variableInstance.projectId,
+				to: r.project.id,
+			}),
+			stage: r.one.stage({
+				from: r.variableInstance.stageId,
+				to: r.stage.id,
+			}),
+			variableDefinition: r.one.variableDefinition({
+				from: r.variableInstance.variableId,
+				to: r.variableDefinition.id,
+			}),
+		},
+		variableDefinition: {
+			variableInstances: r.many.variableInstance(),
+		},
+		userPageViewSettings: {
+			userSetting: r.one.userSettings({
+				from: r.userPageViewSettings.userSettingsId,
+				to: r.userSettings.id,
+			}),
+		},
+		bookingAvailabilitySlot: {
+			bookingLink: r.one.bookingLink({
+				from: r.bookingAvailabilitySlot.bookingLinkId,
+				to: r.bookingLink.id,
+			}),
+		},
+		permissionPolicy: {
+			team: r.one.team({
+				from: r.permissionPolicy.teamId,
+				to: r.team.id,
+			}),
+		},
+		permissionRoleAssignment: {
+			permissionRole: r.one.permissionRole({
+				from: r.permissionRoleAssignment.permissionRoleId,
+				to: r.permissionRole.id,
+			}),
+		},
+		workspaceTaskSequencer: {
+			workspace: r.one.workspace({
+				from: r.workspaceTaskSequencer.workspaceId,
+				to: r.workspace.id,
+			}),
+		},
+	}));
+}).types([103199, 'instantiations']);
+// .mark({ mean: [3.44, "ns"], median: [3.33, "ns"] })
diff --git a/drizzle-orm/vitest.config.ts b/drizzle-orm/vitest.config.ts
index 4a9a7e6599..945b92f298 100644
--- a/drizzle-orm/vitest.config.ts
+++ b/drizzle-orm/vitest.config.ts
@@ -1,5 +1,6 @@
 import { viteCommonjs } from '@originjs/vite-plugin-commonjs';
 import tsconfigPaths from 'vite-tsconfig-paths';
+// oxlint-disable-next-line extensions
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
diff --git a/drizzle-seed/.gitignore b/drizzle-seed/.gitignore
new file mode 100644
index 0000000000..2eea525d88
--- /dev/null
+++ b/drizzle-seed/.gitignore
@@ -0,0 +1 @@
+.env
\ No newline at end of file
diff --git a/drizzle-seed/package.json b/drizzle-seed/package.json
index 57ea7fa86c..2a48332ec9 100644
--- a/drizzle-seed/package.json
+++ b/drizzle-seed/package.json
@@ -1,13 +1,17 @@
 {
 	"name": "drizzle-seed",
-	"version": "0.3.1",
-	"main": "index.js",
+	"version": "1.0.0-rc.4",
+	"main": "./index.cjs",
+	"module": "./index.mjs",
+	"types": "./index.d.ts",
 	"type": "module",
 	"scripts": {
-		"build": "tsx scripts/build.ts",
+		"build": "bun --bun run scripts/build.ts",
+		"build:artifact": "pnpm run build",
 		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
+		"pack:artifact": "pnpm run pack",
 		"test": "vitest --config ./vitest.config.ts",
-		"test:types": "cd type-tests && tsc",
+		"test:types": "cd type-tests && tsc -p ./../tsconfig.json",
 		"generate-for-tests:pg": "drizzle-kit generate --config=./src/tests/pg/drizzle.config.ts",
 		"generate-for-tests:mysql": "drizzle-kit generate --config=./src/tests/mysql/drizzle.config.ts",
 		"generate-for-tests:sqlite": "drizzle-kit generate --config=./src/tests/sqlite/drizzle.config.ts",
@@ -65,38 +69,39 @@
 		}
 	},
 	"peerDependencies": {
-		"drizzle-orm": ">=0.36.4"
+		"drizzle-orm": ">=1.0.0-beta.2"
 	},
 	"peerDependenciesMeta": {
 		"drizzle-orm": {
-			"optional": true
+			"optional": false
 		}
 	},
 	"devDependencies": {
 		"@arethetypeswrong/cli": "^0.16.1",
-		"@electric-sql/pglite": "^0.2.12",
-		"@rollup/plugin-terser": "^0.4.4",
-		"@rollup/plugin-typescript": "^11.1.6",
+		"@electric-sql/pglite": "^0.4.6",
+		"@types/async-retry": "^1.4.8",
 		"@types/better-sqlite3": "^7.6.11",
 		"@types/dockerode": "^3.3.31",
+		"@types/mssql": "^9.1.4",
 		"@types/node": "^22.5.4",
 		"@types/pg": "^8.11.6",
 		"@types/uuid": "^10.0.0",
+		"async-retry": "^1.3.3",
 		"better-sqlite3": "^11.1.2",
 		"cpy": "^11.1.0",
 		"dockerode": "^4.0.6",
 		"dotenv": "^16.4.5",
-		"drizzle-kit": "workspace:./drizzle-kit/dist",
-		"drizzle-orm": "workspace:./drizzle-orm/dist",
+		"drizzle-kit": "workspace:../drizzle-kit/dist",
+		"drizzle-orm": "workspace:../drizzle-orm/dist",
 		"get-port": "^7.1.0",
+		"mssql": "^11.0.1",
 		"mysql2": "^3.14.1",
 		"pg": "^8.12.0",
-		"resolve-tspaths": "^0.8.19",
-		"rollup": "^3.29.5",
 		"tslib": "^2.7.0",
 		"tsx": "^4.19.0",
 		"uuid": "^10.0.0",
-		"vitest": "^3.1.3",
+		"vite-tsconfig-paths": "^4.3.2",
+		"zod": "^4.0.0",
 		"zx": "^8.1.5"
 	},
 	"dependencies": {
diff --git a/drizzle-seed/rollup.config.ts b/drizzle-seed/rollup.config.ts
deleted file mode 100644
index c5874a54ac..0000000000
--- a/drizzle-seed/rollup.config.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-export default defineConfig([
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				format: 'esm',
-				dir: 'dist',
-				entryFileNames: '[name].mjs',
-				chunkFileNames: '[name]-[hash].mjs',
-				sourcemap: true,
-			},
-			{
-				format: 'cjs',
-				dir: 'dist',
-				entryFileNames: '[name].cjs',
-				chunkFileNames: '[name]-[hash].cjs',
-				sourcemap: true,
-			},
-		],
-		external: [/^drizzle-orm\/?/, 'pure-rand'],
-		plugins: [
-			typescript({
-				tsconfig: 'tsconfig.build.json',
-			}),
-		],
-	},
-]);
diff --git a/drizzle-seed/scripts/build.ts b/drizzle-seed/scripts/build.ts
index 1910feac6a..23ed071e6b 100644
--- a/drizzle-seed/scripts/build.ts
+++ b/drizzle-seed/scripts/build.ts
@@ -1,15 +1,12 @@
-#!/usr/bin/env -S pnpm tsx
+#!/usr/bin/env bun
 import 'zx/globals';
 import cpy from 'cpy';
 
 await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
+await $`tsdown`;
+// Create .d.ts fallback for the `types` field in exports
+await cpy('dist/**/*.d.mts', 'dist', {
+	rename: (basename) => basename.replace(/\.d\.mts$/, '.d.ts'),
 });
+await fs.copy('README.md', 'dist/README.md');
 await fs.copy('package.json', 'dist/package.json');
diff --git a/drizzle-seed/src/SeedService.ts b/drizzle-seed/src/SeedService.ts
new file mode 100644
index 0000000000..358c8fa530
--- /dev/null
+++ b/drizzle-seed/src/SeedService.ts
@@ -0,0 +1,1239 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import type { AnyColumn, AnyTable } from 'drizzle-orm';
+import { entityKind, eq, is, sql } from 'drizzle-orm';
+import type { MySqlTable, MySqlTableWithColumns } from 'drizzle-orm/mysql-core';
+import { MySqlAsyncDatabase } from 'drizzle-orm/mysql-core';
+import type { PgTable, PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { getTableConfig as getTableConfigPg, type PgDialect } from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async';
+import type { SQLiteTable, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import { SQLiteAsyncDatabase } from 'drizzle-orm/sqlite-core';
+import { generatorsMap } from './generators/GeneratorFuncs.ts';
+import type {
+	AbstractGenerator,
+	GenerateArray,
+	GenerateCompositeUniqueKey,
+	GenerateHashFromString,
+	GenerateWeightedCount,
+	WeightedRandomGenerator,
+} from './generators/Generators.ts';
+import type {
+	DbType,
+	GeneratedValueType,
+	GeneratePossibleGeneratorsColumnType,
+	GeneratePossibleGeneratorsTableType,
+	RefinementsType,
+	TableGeneratorsType,
+	TableType,
+} from './types/seedService.ts';
+import type { Prettify, Relation, Table } from './types/tables.ts';
+
+import type { CockroachTable, CockroachTableWithColumns } from 'drizzle-orm/cockroach-core';
+import { CockroachDatabase } from 'drizzle-orm/cockroach-core';
+import type { MsSqlTable, MsSqlTableWithColumns } from 'drizzle-orm/mssql-core';
+import { getTableConfig as getTableConfigMsSql, MsSqlDatabase } from 'drizzle-orm/mssql-core';
+import type { SingleStoreTable, SingleStoreTableWithColumns } from 'drizzle-orm/singlestore-core';
+import { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
+import { selectGeneratorForCockroachColumn } from './cockroach-core/selectGensForColumn.ts';
+import { latestVersion } from './generators/apiVersion.ts';
+import { selectGeneratorForMssqlColumn } from './mssql-core/selectGensForColumn.ts';
+import { selectGeneratorForMysqlColumn } from './mysql-core/selectGensForColumn.ts';
+import { selectGeneratorForPostgresColumn } from './pg-core/selectGensForColumn.ts';
+import { selectGeneratorForSingleStoreColumn } from './singlestore-core/selectGensForColumn.ts';
+import { selectGeneratorForSqlite } from './sqlite-core/selectGensForColumn.ts';
+import { equalSets, intMax, isPostgresColumnIntLike } from './utils.ts';
+
+export class SeedService {
+	static readonly entityKind: string = 'SeedService';
+
+	private defaultCountForTable = 10;
+	private postgresPgLiteMaxParametersNumber = 32740;
+	private postgresMaxParametersNumber = 65535;
+	// there is no max parameters number in mysql, so you can increase mysqlMaxParametersNumber if it's needed.
+	private mysqlMaxParametersNumber = 100000;
+	//  SQLITE_MAX_VARIABLE_NUMBER, which by default equals to 999 for SQLite versions prior to 3.32.0 (2020-05-22) or 32766 for SQLite versions after 3.32.0.
+	private sqliteMaxParametersNumber = 32766;
+	private mssqlMaxParametersNumber = 2100;
+	private version?: number;
+	private hashFromStringGenerator: GenerateHashFromString | undefined;
+
+	generatePossibleGenerators = (
+		connectionType: 'postgresql' | 'mysql' | 'sqlite' | 'mssql' | 'cockroach' | 'singlestore',
+		tables: Table[],
+		relations: (Relation & { isCyclic: boolean })[],
+		refinements?: RefinementsType,
+		options?: { count?: number; seed?: number; version?: number },
+	) => {
+		let columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>;
+		let tablePossibleGenerators: Prettify<GeneratePossibleGeneratorsTableType>;
+		const customSeed = options?.seed === undefined ? 0 : options.seed;
+		this.version = options?.version === undefined ? latestVersion : options.version;
+		if (Number.isNaN(this.version) || this.version < 1 || this.version > latestVersion) {
+			throw new Error(`Version should be in range [1, ${latestVersion}].`);
+		}
+		this.hashFromStringGenerator = this.selectVersionOfGenerator(
+			new generatorsMap.GenerateHashFromString[0](),
+		) as GenerateHashFromString;
+
+		// sorting table in order which they will be filled up (tables with foreign keys case)
+		const { tablesInOutRelations } = this.getInfoFromRelations(relations);
+		const orderedTablesNames = this.getOrderedTablesList(tablesInOutRelations);
+		tables = tables.sort((table1, table2) => {
+			const rel = relations.find((rel) => rel.table === table1.name && rel.refTable === table2.name);
+
+			if (rel?.isCyclic === true) {
+				const reverseRel = relations.find((rel) => rel.table === table2.name && rel.refTable === table1.name);
+				return this.cyclicTablesCompare(table1, table2, rel, reverseRel);
+			}
+
+			const table1Order = orderedTablesNames.indexOf(
+					table1.name,
+				),
+				table2Order = orderedTablesNames.indexOf(
+					table2.name,
+				);
+			return table1Order - table2Order;
+		});
+
+		const tableNamesSet = new Set(tables.map((table) => table.name));
+		const tablesPossibleGenerators: Prettify<
+			(typeof tablePossibleGenerators)[]
+		> = tables.map((table) => ({
+			tableName: table.name,
+			columnsPossibleGenerators: [],
+			withFromTable: {},
+		}));
+
+		for (const [i, table] of tables.entries()) {
+			const compositeUniqueKeyGenMap: { [key: string]: GenerateCompositeUniqueKey } = {};
+			// get foreignKey columns relations
+			const foreignKeyColumns: {
+				[columnName: string]: { table: string; column: string };
+			} = {};
+
+			for (
+				const rel of relations
+					.filter((rel) => rel.table === table.name)
+			) {
+				for (const [idx, col] of rel.columns.entries()) {
+					foreignKeyColumns[col] = {
+						table: rel.refTable,
+						column: rel.refColumns[idx] as string,
+					};
+				}
+			}
+
+			// handling refinements (count, with)
+			if (refinements !== undefined && refinements[table.name] !== undefined) {
+				if (refinements[table.name]!.count !== undefined) {
+					tablesPossibleGenerators[i]!.count = refinements[table.name]!.count;
+				}
+
+				if (refinements[table.name]!.with !== undefined) {
+					tablesPossibleGenerators[i]!.count = refinements[table.name]!.count
+						|| options?.count
+						|| this.defaultCountForTable;
+					let idx: number;
+					for (
+						const fkTableName of Object.keys(
+							refinements[table.name]!.with as {},
+						)
+					) {
+						if (!tablesInOutRelations[table.name]?.dependantTableNames.has(fkTableName)) {
+							const reason = tablesInOutRelations[table.name]?.selfRelation === true
+								? `"${table.name}" table has self reference`
+								: `"${fkTableName}" table doesn't have a reference to "${table.name}" table or`
+									+ `\nyou didn't include your one-to-many relation in the seed function schema`;
+							throw new Error(
+								`${reason}.` + `\nYou can't specify "${fkTableName}" as parameter in ${table.name}.with object.`
+									+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-using-with-option`,
+							);
+						}
+
+						idx = tablesPossibleGenerators.findIndex(
+							(table) => table.tableName === fkTableName,
+						);
+						if (idx !== -1) {
+							let newTableWithCount: number,
+								weightedCountSeed: number | undefined;
+							if (
+								typeof refinements![table.name]!.with![fkTableName] === 'number'
+							) {
+								newTableWithCount = (tablesPossibleGenerators[i]!.withCount
+									|| tablesPossibleGenerators[i]!.count)!
+									* (refinements[table.name]!.with![fkTableName] as number);
+							} else {
+								const weightedRepeatedValuesCount = refinements[table.name]!
+									.with![fkTableName] as {
+										weight: number;
+										count: number | number[];
+									}[];
+
+								weightedCountSeed = customSeed
+									+ this.hashFromStringGenerator.generate({ input: `${table.name}.${fkTableName}` });
+
+								newTableWithCount = this.getWeightedWithCount(
+									weightedRepeatedValuesCount,
+									(tablesPossibleGenerators[i]!.withCount
+										|| tablesPossibleGenerators[i]!.count)!,
+									weightedCountSeed,
+								);
+							}
+
+							if (
+								tablesPossibleGenerators[idx]!.withCount === undefined
+								|| newTableWithCount > tablesPossibleGenerators[idx]!.withCount!
+							) {
+								tablesPossibleGenerators[idx]!.withCount = newTableWithCount;
+							}
+
+							tablesPossibleGenerators[idx]!.withFromTable[table.name] = {
+								repeatedValuesCount: refinements[table.name]!.with![fkTableName]!,
+								weightedCountSeed,
+							};
+						}
+					}
+				}
+			}
+			tablePossibleGenerators = tablesPossibleGenerators[i]!;
+			for (const col of table.columns) {
+				// col.myType = typeMap[col._type as keyof typeof typeMap];
+				columnPossibleGenerator = {
+					columnName: col.name,
+					isUnique: col.isUnique,
+					notNull: col.notNull,
+					primary: col.primary,
+					generatedIdentityType: col.generatedIdentityType,
+					identity: col.identity,
+					generator: undefined,
+					isCyclic: false,
+					wasDefinedBefore: false,
+					wasRefined: false,
+				};
+
+				// handling refinements (columnGenerator)
+				if (
+					refinements !== undefined
+					&& refinements[table.name] !== undefined
+					&& refinements[table.name]!.columns !== undefined
+					&& refinements[table.name]!.columns[col.name] !== undefined
+				) {
+					const genObj = refinements[table.name]!.columns[col.name]!;
+					if (genObj === false) {
+						if (col.notNull === true && col.hasDefault === false) {
+							throw new Error(
+								`You cannot set the '${col.name}' column in the '${table.name}' table to false in your refinements.`
+									+ `\nDoing so will result in a null value being inserted into the '${col.name}' column,`
+									+ `\nwhich will cause an error because the column has a not null constraint and no default value.`,
+							);
+						}
+
+						// Generating undefined as a value for a column and then inserting it via drizzle-orm
+						// will result in null of default value being inserted into that column.
+						columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: undefined });
+						columnPossibleGenerator.wasRefined = true;
+
+						continue;
+					}
+
+					if (
+						(col.typeParams.dimensions && col.typeParams.dimensions > 1)
+						|| (col.typeParams.dimensions !== undefined && col.typeParams.dimensions > 1)
+					) {
+						throw new Error("for now you can't specify generators for columns of dimension greater than 1.");
+					}
+
+					genObj.columnDataType = col.dataType;
+
+					columnPossibleGenerator.generator = genObj;
+					columnPossibleGenerator.wasRefined = true;
+				} else if (Object.hasOwn(foreignKeyColumns, col.name)) {
+					// TODO: I might need to assign repeatedValuesCount to column there instead of doing so in generateTablesValues
+					const cyclicRelation = relations.find((rel) =>
+						rel.table === table.name
+						&& rel.isCyclic === true
+						&& rel.columns.includes(col.name)
+					);
+
+					if (cyclicRelation !== undefined) {
+						columnPossibleGenerator.isCyclic = true;
+					}
+
+					if (
+						(foreignKeyColumns[col.name]?.table === undefined || !tableNamesSet.has(foreignKeyColumns[col.name]!.table))
+						&& col.notNull === true
+					) {
+						throw new Error(
+							`Column '${col.name}' has not null contraint,`
+								+ `\nand you didn't specify a table for foreign key on column '${col.name}' in '${table.name}' table.`
+								+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-1`,
+						);
+					}
+
+					const predicate = (
+						cyclicRelation !== undefined
+						|| (
+							foreignKeyColumns[col.name]?.table === undefined
+							|| !tableNamesSet.has(foreignKeyColumns[col.name]!.table)
+						)
+					)
+						&& col.notNull === false;
+					// TODO: revise this part
+					if (predicate === true) {
+						if (
+							(foreignKeyColumns[col.name]?.table === undefined
+								|| !tableNamesSet.has(foreignKeyColumns[col.name]!.table)) && col.notNull === false
+						) {
+							console.warn(
+								`Column '${col.name}' in '${table.name}' table will be filled with Null values`
+									+ `\nbecause you specified neither a table for foreign key on column '${col.name}'`
+									+ `\nnor a function for '${col.name}' column in refinements.`
+									+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-2`,
+							);
+						}
+						columnPossibleGenerator.generator = new generatorsMap.GenerateValuesFromArray[0]({ values: [null] });
+						columnPossibleGenerator.wasDefinedBefore = true;
+					} else {
+						// self relation
+						if (foreignKeyColumns[col.name]!.table === table.name) {
+							columnPossibleGenerator.generator = new generatorsMap.GenerateSelfRelationsValuesFromArray[0]();
+						} else columnPossibleGenerator.generator = new generatorsMap.GenerateValuesFromArray[0]();
+					}
+				} // TODO: rewrite pickGeneratorFor... using new col properties: isUnique and notNull
+				else if (connectionType === 'postgresql') {
+					columnPossibleGenerator.generator = selectGeneratorForPostgresColumn(
+						col,
+						table.primaryKeys.includes(col.name),
+					);
+				} else if (connectionType === 'mysql') {
+					columnPossibleGenerator.generator = selectGeneratorForMysqlColumn(table, col);
+				} else if (connectionType === 'sqlite') {
+					columnPossibleGenerator.generator = selectGeneratorForSqlite(table, col);
+				} else if (connectionType === 'mssql') {
+					columnPossibleGenerator.generator = selectGeneratorForMssqlColumn(table, col);
+				} else if (connectionType === 'cockroach') {
+					columnPossibleGenerator.generator = selectGeneratorForCockroachColumn(table, col);
+				} else if (connectionType === 'singlestore') {
+					columnPossibleGenerator.generator = selectGeneratorForSingleStoreColumn(table, col);
+				}
+
+				if (columnPossibleGenerator.generator === undefined) {
+					throw new Error(
+						`column with type ${col.columnType} is not supported for now.`,
+					);
+				}
+
+				columnPossibleGenerator.generator.typeParams = col.typeParams ?? columnPossibleGenerator.generator.typeParams;
+				const arrayGen = columnPossibleGenerator.generator.replaceIfArray();
+				if (arrayGen !== undefined) {
+					columnPossibleGenerator.generator = arrayGen;
+				}
+
+				columnPossibleGenerator.generator.isUnique = col.isUnique;
+
+				// composite unique keys handling
+				let compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+				if (compositeKeyColumnNames.some((colNames) => colNames.length === 1)) {
+					// composite unique key contains only one column, therefore it equals to just unique column
+					columnPossibleGenerator.generator.isUnique = true;
+				}
+
+				// removing column from composite unique keys if current column is unique
+				if (columnPossibleGenerator.generator.isUnique && compositeKeyColumnNames.length > 0) {
+					const newUniqueConstraints: string[][] = [];
+					for (const colNames of table.uniqueConstraints) {
+						if (colNames.includes(col.name)) {
+							const newColNames = colNames.filter((colName) => colName !== col.name);
+							if (newColNames.length === 0) continue;
+							newUniqueConstraints.push(newColNames);
+						} else {
+							newUniqueConstraints.push(colNames);
+						}
+					}
+
+					table.uniqueConstraints = newUniqueConstraints;
+				}
+
+				compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+				if (compositeKeyColumnNames.length > 1) {
+					throw new Error('Currently, multiple composite unique keys that share the same column are not supported.');
+				}
+
+				// to handle composite unique key generation, I will need a unique generator for each column in the composite key
+				if (compositeKeyColumnNames.length === 1) {
+					// params.isUnique = false can only be set by the user; by default, it is undefined
+					if (columnPossibleGenerator.generator.params.isUnique === false) {
+						throw new Error(
+							`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+								+ `column: ${col.name} should either be assigned a generator with isUnique set to true, or have isUnique omitted.`,
+						);
+					}
+					columnPossibleGenerator.generator.params.isUnique = true;
+				}
+
+				const uniqueGen = columnPossibleGenerator.generator.replaceIfUnique();
+				if (uniqueGen !== undefined) {
+					columnPossibleGenerator.generator = uniqueGen;
+				}
+
+				if (
+					compositeKeyColumnNames.length === 1 && !columnPossibleGenerator.generator.isGeneratorUnique
+					&& !(columnPossibleGenerator.generator.getEntityKind() === 'GenerateValuesFromArray')
+				) {
+					throw new Error(
+						`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+							+ `column: ${col.name} should be assigned a generator with its own unique version.`,
+					);
+				}
+
+				// selecting version of generator
+				columnPossibleGenerator.generator = this.selectVersionOfGenerator(columnPossibleGenerator.generator);
+
+				// TODO: for now only GenerateValuesFromArray support notNull property
+				columnPossibleGenerator.generator.notNull = col.notNull;
+				columnPossibleGenerator.generator.dataType = col.dataType;
+
+				// assigning composite key generator
+				if (compositeKeyColumnNames.length === 1) {
+					const key = compositeKeyColumnNames[0]!.join('_');
+					if (compositeUniqueKeyGenMap[key] === undefined) {
+						let compositeUniqueKeyGen = new generatorsMap.GenerateCompositeUniqueKey[0]();
+						compositeUniqueKeyGen.uniqueKey = key;
+						compositeUniqueKeyGen = this.selectVersionOfGenerator(compositeUniqueKeyGen) as GenerateCompositeUniqueKey;
+						compositeUniqueKeyGenMap[key] = compositeUniqueKeyGen;
+					}
+
+					compositeUniqueKeyGenMap[key].addGenerator(col.name, columnPossibleGenerator.generator);
+					columnPossibleGenerator.generator = compositeUniqueKeyGenMap[key];
+				}
+
+				tablePossibleGenerators.columnsPossibleGenerators.push(
+					columnPossibleGenerator,
+				);
+			}
+		}
+
+		return tablesPossibleGenerators;
+	};
+
+	selectVersionOfGenerator = (generator: AbstractGenerator<any>) => {
+		const entityKind = generator.getEntityKind();
+		if (entityKind === 'GenerateArray') {
+			const oldBaseColumnGen = (generator as GenerateArray).params.baseColumnGen;
+
+			const newBaseColumnGen = this.selectVersionOfGenerator(oldBaseColumnGen);
+			newBaseColumnGen.typeParams = oldBaseColumnGen.typeParams;
+
+			(generator as GenerateArray).params.baseColumnGen = newBaseColumnGen;
+		}
+
+		if (entityKind === 'WeightedRandomGenerator') {
+			for (const param of (generator as WeightedRandomGenerator).params) {
+				param.value = this.selectVersionOfGenerator(param.value);
+			}
+		}
+
+		const possibleGeneratorConstructors = generatorsMap[entityKind as keyof typeof generatorsMap];
+
+		const possibleGeneratorConstructorsFiltered = possibleGeneratorConstructors?.filter((possGenCon) =>
+			possGenCon.version <= this.version! // sorting in ascending order by version
+		).sort((a, b) => a.version - b.version);
+		const generatorConstructor = possibleGeneratorConstructorsFiltered?.at(-1) as
+			| (new(params: any) => AbstractGenerator<any>)
+			| undefined;
+		if (generatorConstructor === undefined) {
+			throw new Error(`Can't select ${entityKind} generator for ${this.version} version.`);
+		}
+
+		const newGenerator = new generatorConstructor(generator.params);
+		newGenerator.columnDataType = generator.columnDataType;
+		newGenerator.isUnique = generator.isUnique;
+		// TODO: for now only GenerateValuesFromArray support notNull property
+		newGenerator.notNull = generator.notNull;
+		newGenerator.dataType = generator.dataType;
+		// newGenerator.stringLength = generator.stringLength;
+		newGenerator.typeParams = generator.typeParams ?? newGenerator.typeParams;
+		newGenerator.uniqueKey = generator.uniqueKey;
+
+		return newGenerator;
+	};
+
+	cyclicTablesCompare = (
+		table1: Table,
+		table2: Table,
+		relation: Relation & { isCyclic: boolean },
+		reverseRelation: Relation & { isCyclic: boolean } | undefined,
+	) => {
+		// TODO: revise
+		const hasTable1NotNullColumns = relation.columns.some((colIName) =>
+			table1.columns.find((colJ) => colJ.name === colIName)?.notNull === true
+		);
+
+		if (reverseRelation !== undefined) {
+			const hasTable2NotNullColumns = reverseRelation.columns.some((colIName) =>
+				table2.columns.find((colJ) => colJ.name === colIName)?.notNull === true
+			);
+
+			if (hasTable1NotNullColumns && hasTable2NotNullColumns) {
+				throw new Error(
+					`The '${table1.name}' and '${table2.name}' tables have not null foreign keys. You can't seed cyclic tables with not null foreign key columns.`,
+				);
+			}
+
+			if (hasTable1NotNullColumns) return 1;
+			else if (hasTable2NotNullColumns) return -1;
+			return 0;
+		}
+
+		if (hasTable1NotNullColumns) {
+			return 1;
+		}
+		return 0;
+
+		// if (hasTable1NotNullColumns) return 1;
+		// else if (hasTable2NotNullColumns) return -1;
+	};
+
+	getOrderedTablesList = (
+		tablesInOutRelations: ReturnType<typeof this.getInfoFromRelations>['tablesInOutRelations'],
+	): string[] => {
+		const leafTablesNames = Object.entries(tablesInOutRelations)
+			.filter(
+				(tableRel) =>
+					tableRel[1].out === 0
+					|| (tableRel[1].out !== 0
+						&& tableRel[1].selfRelCount === tableRel[1].out),
+			)
+			.map((tableRel) => tableRel[0]);
+
+		const orderedTablesNames: string[] = [];
+		let parent: string, children: string[];
+		for (let i = 0; leafTablesNames.length !== 0; i++) {
+			parent = leafTablesNames.shift() as string;
+
+			if (orderedTablesNames.includes(parent)) {
+				continue;
+			}
+
+			if (tablesInOutRelations[parent] === undefined) {
+				orderedTablesNames.push(parent);
+				continue;
+			}
+
+			for (const orderedTableName of orderedTablesNames) {
+				tablesInOutRelations[parent]!.requiredTableNames.delete(orderedTableName);
+			}
+
+			if (
+				tablesInOutRelations[parent]!.requiredTableNames.size === 0
+				|| equalSets(
+					tablesInOutRelations[parent]!.requiredTableNames,
+					tablesInOutRelations[parent]!.dependantTableNames,
+				)
+			) {
+				orderedTablesNames.push(parent);
+			} else {
+				leafTablesNames.push(...tablesInOutRelations[parent]!.requiredTableNames, parent);
+				continue;
+			}
+
+			children = [...tablesInOutRelations[parent]!.dependantTableNames];
+			leafTablesNames.push(...children);
+		}
+		return orderedTablesNames;
+	};
+
+	getInfoFromRelations = (relations: (Relation & { isCyclic: boolean })[]) => {
+		const tablesInOutRelations: {
+			[tableName: string]: {
+				out: number;
+				in: number;
+				selfRelation: boolean;
+				selfRelCount: number;
+				requiredTableNames: Set<string>;
+				dependantTableNames: Set<string>;
+			};
+		} = {};
+
+		// const cyclicRelations: { [cyclicTableName: string]: Relation & { isCyclic: boolean } } = {};
+
+		for (const rel of relations) {
+			// if (rel.isCyclic) {
+			// 	cyclicRelations[rel.table] = rel;
+			// }
+
+			if (tablesInOutRelations[rel.table] === undefined) {
+				tablesInOutRelations[rel.table] = {
+					out: 0,
+					in: 0,
+					selfRelation: false,
+					selfRelCount: 0,
+					requiredTableNames: new Set(),
+					dependantTableNames: new Set(),
+				};
+			}
+
+			if (
+				rel.refTable !== undefined
+				&& tablesInOutRelations[rel.refTable] === undefined
+			) {
+				tablesInOutRelations[rel.refTable] = {
+					out: 0,
+					in: 0,
+					selfRelation: false,
+					selfRelCount: 0,
+					requiredTableNames: new Set(),
+					dependantTableNames: new Set(),
+				};
+			}
+
+			if (rel.refTable !== undefined) {
+				tablesInOutRelations[rel.table]!.out += 1;
+				tablesInOutRelations[rel.refTable]!.in += 1;
+			}
+
+			if (rel.refTable === rel.table) {
+				tablesInOutRelations[rel.table]!.selfRelation = true;
+				tablesInOutRelations[rel.table]!.selfRelCount = rel.columns.length;
+			} else if (rel.refTable !== undefined) {
+				tablesInOutRelations[rel.table]!.requiredTableNames.add(rel.refTable);
+				tablesInOutRelations[rel.refTable]!.dependantTableNames.add(rel.table);
+			}
+		}
+
+		return { tablesInOutRelations };
+	};
+
+	getWeightedWithCount = (
+		weightedCount: { weight: number; count: number | number[] }[],
+		count: number,
+		seed: number,
+	) => {
+		let gen = new generatorsMap.GenerateWeightedCount[0]();
+		gen = this.selectVersionOfGenerator(gen) as GenerateWeightedCount;
+		// const gen = new GenerateWeightedCount({});
+		gen.init({ count: weightedCount, seed });
+		let weightedWithCount = 0;
+		for (let i = 0; i < count; i++) {
+			weightedWithCount += gen.generate();
+		}
+
+		return weightedWithCount;
+	};
+
+	filterCyclicTables = (tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>) => {
+		const filteredTablesGenerators = tablesGenerators.filter((tableGen) =>
+			tableGen.columnsPossibleGenerators.some((columnGen) =>
+				columnGen.isCyclic === true && columnGen.wasDefinedBefore === true
+			)
+		);
+
+		const tablesUniqueNotNullColumn: { [tableName: string]: { uniqueNotNullColName: string } } = {};
+
+		for (const [idx, tableGen] of filteredTablesGenerators.entries()) {
+			const uniqueNotNullColName = filteredTablesGenerators[idx]!.columnsPossibleGenerators.find((colGen) =>
+				colGen.primary === true
+				|| (colGen.isUnique === true
+					&& colGen.notNull === true)
+			)?.columnName;
+			if (uniqueNotNullColName === undefined) {
+				throw new Error(
+					`Table '${tableGen.tableName}' does not have primary or (unique and notNull) column. Can't seed table with cyclic relation.`,
+				);
+			}
+			tablesUniqueNotNullColumn[tableGen.tableName] = { uniqueNotNullColName };
+
+			filteredTablesGenerators[idx]!.columnsPossibleGenerators = tableGen.columnsPossibleGenerators.filter((
+				colGen,
+			) => (colGen.isCyclic === true && colGen.wasDefinedBefore === true) || colGen.columnName === uniqueNotNullColName)
+				.map((colGen) => {
+					const newColGen = { ...colGen };
+					newColGen.wasDefinedBefore = false;
+					return newColGen;
+				});
+		}
+
+		return { filteredTablesGenerators, tablesUniqueNotNullColumn };
+	};
+
+	generateTablesValues = async (
+		relations: (Relation & { isCyclic: boolean })[],
+		tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>,
+		db?: DbType,
+		schema?: { [key: string]: TableType },
+		options?: {
+			count?: number;
+			seed?: number;
+			preserveData?: boolean;
+			preserveCyclicTablesData?: boolean;
+			insertDataInDb?: boolean;
+			updateDataInDb?: boolean;
+			tablesValues?: {
+				tableName: string;
+				rows: {
+					[columnName: string]: GeneratedValueType;
+				}[];
+			}[];
+			tablesUniqueNotNullColumn?: { [tableName: string]: { uniqueNotNullColName: string } };
+		},
+	) => {
+		const customSeed = options?.seed === undefined ? 0 : options.seed;
+		let tableCount: number | undefined;
+		let columnsGenerators: Prettify<GeneratePossibleGeneratorsColumnType>[];
+		let tableGenerators: Prettify<TableGeneratorsType>;
+
+		let tableValues: {
+			[columnName: string]: GeneratedValueType;
+		}[];
+
+		let tablesValues: {
+			tableName: string;
+			rows: typeof tableValues;
+		}[] = options?.tablesValues === undefined ? [] : options.tablesValues;
+
+		let pRNGSeed: number;
+		let filteredRelations: typeof relations;
+
+		let preserveData: boolean, insertDataInDb: boolean = true, updateDataInDb: boolean = false;
+		if (options?.preserveData !== undefined) preserveData = options.preserveData;
+		if (options?.insertDataInDb !== undefined) insertDataInDb = options.insertDataInDb;
+		if (options?.updateDataInDb !== undefined) updateDataInDb = options.updateDataInDb;
+		if (updateDataInDb === true) insertDataInDb = false;
+
+		// TODO: now I'm generating tablesInOutRelations twice, first time in generatePossibleGenerators and second time here. maybe should generate it once instead.
+		const { tablesInOutRelations } = this.getInfoFromRelations(relations);
+		for (const table of tablesGenerators) {
+			tableCount = table.count === undefined ? options?.count || this.defaultCountForTable : table.count;
+
+			tableGenerators = {};
+			columnsGenerators = table.columnsPossibleGenerators;
+
+			filteredRelations = relations.filter(
+				(rel) => rel.table === table.tableName,
+			);
+
+			// adding pRNG seed to column
+			for (const col of columnsGenerators) {
+				const columnRelations = filteredRelations.filter((rel) => rel.columns.includes(col.columnName));
+				pRNGSeed = (columnRelations.length !== 0
+						&& columnRelations[0]!.columns.length >= 2)
+					? (customSeed
+						+ this.hashFromStringGenerator!.generate({
+							input: `${columnRelations[0]!.table}.${columnRelations[0]!.columns.join('_')}`,
+						}))
+					: col.generator?.uniqueKey === undefined
+					? (customSeed + this.hashFromStringGenerator!.generate({ input: `${table.tableName}.${col.columnName}` }))
+					: (customSeed + this.hashFromStringGenerator!.generate({ input: col.generator.uniqueKey }));
+
+				tableGenerators[col.columnName] = {
+					pRNGSeed,
+					...col,
+				};
+			}
+
+			// get values to generate columns with foreign key
+
+			// if table posts contains foreign key to table users, then rel.table === 'posts' and rel.refTable === 'users',
+			// because table posts has reference to table users.
+			if (filteredRelations.length !== 0) {
+				for (const rel of filteredRelations) {
+					if (
+						table.withFromTable[rel.refTable] !== undefined
+						&& table.withCount !== undefined
+					) {
+						tableCount = table.withCount;
+					}
+
+					for (let colIdx = 0; colIdx < rel.columns.length; colIdx++) {
+						let refColumnValues: GeneratedValueType[];
+						let hasSelfRelation: boolean = false;
+						let repeatedValuesCount:
+								| number
+								| { weight: number; count: number | number[] }[]
+								| undefined,
+							weightedCountSeed: number | undefined;
+						let genObj: AbstractGenerator<any> | undefined;
+
+						if (
+							rel.table === rel.refTable
+							&& tableGenerators[rel.columns[colIdx]!]?.wasRefined === false
+						) {
+							const refColName = rel.refColumns[colIdx] as string;
+							pRNGSeed = this.hashFromStringGenerator!.generate({
+								input: `${table.tableName}.${refColName}`,
+							});
+
+							const refColumnGenerator: typeof tableGenerators = {};
+							refColumnGenerator[refColName] = {
+								...tableGenerators[refColName]!,
+								pRNGSeed,
+							};
+
+							refColumnValues = (await this.generateColumnsValuesByGenerators({
+								tableGenerators: refColumnGenerator,
+								count: tableCount,
+								preserveData: true,
+								insertDataInDb: false,
+							}))!.map((rows) => rows[refColName]);
+
+							hasSelfRelation = true;
+							genObj = tableGenerators[rel.columns[colIdx]!]!.generator!;
+							genObj.updateParams({ columnName: rel.columns[colIdx]!, paramsToUpdate: { values: refColumnValues } });
+						} else if (
+							tableGenerators[rel.columns[colIdx]!]?.wasDefinedBefore === false
+							&& tableGenerators[rel.columns[colIdx]!]?.wasRefined === false
+						) {
+							refColumnValues = tablesValues
+								.find((val) => val.tableName === rel.refTable)!
+								.rows!.map((row) => row[rel.refColumns[colIdx]!]!);
+
+							if (
+								table.withFromTable[rel.refTable] !== undefined
+								&& table.withFromTable[rel.refTable]!.repeatedValuesCount
+									!== undefined
+							) {
+								repeatedValuesCount = table.withFromTable[rel.refTable]!.repeatedValuesCount;
+								weightedCountSeed = table.withFromTable[rel.refTable]!.weightedCountSeed;
+							}
+
+							// TODO: revise maybe need to select version of generator here too
+							genObj = tableGenerators[rel.columns[colIdx]!]!.generator!;
+							genObj.updateParams({ columnName: rel.columns[colIdx]!, paramsToUpdate: { values: refColumnValues } });
+
+							genObj.notNull = tableGenerators[rel.columns[colIdx]!]!.notNull;
+							genObj.weightedCountSeed = weightedCountSeed;
+							genObj.maxRepeatedValuesCount = repeatedValuesCount;
+						}
+
+						if (genObj !== undefined) {
+							tableGenerators[rel.columns[colIdx]!]!.generator = genObj;
+						}
+						tableGenerators[rel.columns[colIdx]!] = {
+							...tableGenerators[rel.columns[colIdx]!]!,
+							hasSelfRelation,
+							hasRelation: true,
+						};
+					}
+				}
+			}
+
+			preserveData = (
+					options?.preserveData === undefined
+					&& tablesInOutRelations[table.tableName]?.in === 0
+				)
+				? false
+				: true;
+
+			preserveData = preserveData || (options?.preserveCyclicTablesData === true
+				&& table.columnsPossibleGenerators.some((colGen) => colGen.isCyclic === true));
+
+			tableValues = await this.generateColumnsValuesByGenerators({
+				tableGenerators,
+				db,
+				schema,
+				tableName: table.tableName,
+				count: tableCount,
+				preserveData,
+				insertDataInDb,
+				updateDataInDb,
+				uniqueNotNullColName: options?.tablesUniqueNotNullColumn === undefined
+					? undefined
+					: options?.tablesUniqueNotNullColumn[table.tableName]?.uniqueNotNullColName,
+			});
+
+			if (preserveData === true) {
+				tablesValues.push({
+					tableName: table.tableName,
+					rows: tableValues,
+				});
+			}
+
+			// removing "link" from table that was required to generate current table
+			if (tablesInOutRelations[table.tableName] !== undefined) {
+				for (const tableName of tablesInOutRelations[table.tableName]!.requiredTableNames) {
+					tablesInOutRelations[tableName]!.in -= 1;
+				}
+			}
+
+			if (preserveData === false) {
+				tablesValues = tablesValues.filter(
+					(table) =>
+						tablesInOutRelations[table.tableName] !== undefined && tablesInOutRelations[table.tableName]!.in > 0,
+				);
+			}
+		}
+
+		return tablesValues;
+	};
+
+	generateColumnsValuesByGenerators = async ({
+		tableGenerators,
+		db,
+		schema,
+		tableName,
+		count,
+		preserveData = true,
+		insertDataInDb = true,
+		updateDataInDb = false,
+		uniqueNotNullColName,
+		batchSize = 10000,
+	}: {
+		tableGenerators: Prettify<TableGeneratorsType>;
+		db?: DbType;
+		schema?: { [key: string]: TableType };
+		tableName?: string;
+		count?: number;
+		preserveData?: boolean;
+		insertDataInDb?: boolean;
+		updateDataInDb?: boolean;
+		uniqueNotNullColName?: string;
+		batchSize?: number;
+	}) => {
+		if (count === undefined) {
+			count = this.defaultCountForTable;
+		}
+
+		if (updateDataInDb === true) {
+			batchSize = 1;
+		}
+
+		let columnGenerator: (typeof tableGenerators)[string];
+		const columnsGenerators: {
+			[columnName: string]: AbstractGenerator<any>;
+		} = {};
+		let generatedValues: { [columnName: string]: GeneratedValueType }[] = [];
+
+		let columnsNumber = 0;
+		let override = false;
+		for (const columnName of Object.keys(tableGenerators)) {
+			columnsNumber += 1;
+			columnGenerator = tableGenerators[columnName]!;
+			// postgres identity columns
+			override = tableGenerators[columnName]?.generatedIdentityType === 'always' ? true : override;
+			// mssql identity columns
+			override = tableGenerators[columnName]?.identity === true ? true : override;
+
+			columnsGenerators[columnName] = columnGenerator.generator!;
+			columnsGenerators[columnName]!.init({
+				count,
+				seed: columnGenerator.pRNGSeed,
+			});
+
+			// const arrayGen = columnsGenerators[columnName]!.replaceIfArray({ count, seed: columnGenerator.pRNGSeed });
+			// if (arrayGen !== undefined) {
+			// 	columnsGenerators[columnName] = arrayGen;
+			// }
+
+			// const uniqueGen = columnsGenerators[columnName]!.replaceIfUnique({ count, seed: columnGenerator.pRNGSeed });
+			// if (uniqueGen !== undefined) {
+			// 	columnsGenerators[columnName] = uniqueGen;
+			// }
+		}
+
+		// sequence updates will only be performed for PostgreSQL, since MySQL and SQLite already update their sequences correctly on their own.
+		const columnsToUpdateSeq: Map<
+			string,
+			{
+				schemaName: string | undefined;
+				tableName: string;
+				columnName: string;
+				valueToUpdate?: number | bigint;
+				table: AnyTable<any>;
+				column: AnyColumn<any>;
+			}
+		> = new Map();
+		if (
+			count > 0 && is(db, PgAsyncDatabase) && schema !== undefined && tableName !== undefined
+			&& schema[tableName] !== undefined
+		) {
+			const tableConfig = getTableConfigPg(schema[tableName] as PgTable);
+			for (const column of tableConfig.columns) {
+				// TODO should I filter only primary key columns?
+				// should I filter column by dataType or by column drizzle type?
+				// column.dataType === 'number' || column.dataType === 'bigint'
+				if (isPostgresColumnIntLike(column)) {
+					columnsToUpdateSeq.set(column.name, {
+						schemaName: tableConfig.schema,
+						tableName: tableConfig.name,
+						columnName: column.name,
+						valueToUpdate: undefined,
+						table: schema[tableName],
+						column: (schema[tableName] as PgTableWithColumns<any>)[column.name],
+					});
+				}
+			}
+		}
+
+		let maxParametersNumber: number;
+		if (is(db, PgAsyncDatabase<any>)) {
+			// @ts-ignore
+			maxParametersNumber = db.constructor[entityKind] === 'PgliteDatabase'
+				? this.postgresPgLiteMaxParametersNumber
+				: this.postgresMaxParametersNumber;
+		} else if (is(db, MySqlAsyncDatabase<any, any>)) {
+			maxParametersNumber = this.mysqlMaxParametersNumber;
+		} else if (is(db, SQLiteAsyncDatabase<any, any>)) {
+			maxParametersNumber = this.sqliteMaxParametersNumber;
+		} else {
+			// is(db, MsSqlDatabase<any, any>)
+			maxParametersNumber = this.mssqlMaxParametersNumber;
+		}
+		const maxBatchSize = Math.floor(maxParametersNumber / columnsNumber);
+		batchSize = batchSize > maxBatchSize ? maxBatchSize : batchSize;
+
+		if (
+			(insertDataInDb === true || updateDataInDb === true)
+			&& (db === undefined || schema === undefined || tableName === undefined)
+		) {
+			throw new Error('db or schema or tableName is undefined.');
+		}
+
+		let row: { [columnName: string]: string | Buffer | bigint | number | boolean },
+			generatedValue,
+			i: number;
+
+		for (i = 0; i < count; i++) {
+			row = {};
+			generatedValues.push(row);
+
+			for (const columnName of Object.keys(columnsGenerators)) {
+				generatedValue = columnsGenerators[columnName]!.generate({ i, columnName }) as
+					| string
+					| number
+					| boolean;
+				row[columnName as keyof typeof row] = generatedValue;
+
+				const colToUpdateSeq = columnsToUpdateSeq.get(columnName);
+				if (columnsToUpdateSeq.size !== 0 && colToUpdateSeq !== undefined) {
+					colToUpdateSeq.valueToUpdate = colToUpdateSeq?.valueToUpdate === undefined
+						? generatedValue as number | bigint
+						: intMax([colToUpdateSeq!.valueToUpdate, generatedValue as number | bigint]);
+				}
+			}
+
+			if (
+				(insertDataInDb === true || updateDataInDb === true)
+				&& ((i + 1) % batchSize === 0 || i === count - 1)
+			) {
+				if (preserveData === false) {
+					if (insertDataInDb === true) {
+						await this.insertInDb({
+							generatedValues,
+							db: db as DbType,
+							schema: schema as {
+								[key: string]: TableType;
+							},
+							tableName: tableName as string,
+							override,
+						});
+					} else if (updateDataInDb === true) {
+						await this.updateDb({
+							generatedValues,
+							db: db as DbType,
+							schema: schema as {
+								[key: string]: TableType;
+							},
+							tableName: tableName as string,
+							uniqueNotNullColName: uniqueNotNullColName as string,
+						});
+					}
+
+					generatedValues = [];
+				} else {
+					const batchCount = Math.floor(i / batchSize);
+
+					if (insertDataInDb === true) {
+						await this.insertInDb({
+							generatedValues: generatedValues.slice(
+								batchSize * batchCount,
+								batchSize * (batchCount + 1),
+							),
+							db: db as DbType,
+							schema: schema as {
+								[key: string]: TableType;
+							},
+							tableName: tableName as string,
+							override,
+						});
+					} else if (updateDataInDb === true) {
+						await this.updateDb({
+							generatedValues: generatedValues.slice(
+								batchSize * batchCount,
+								batchSize * (batchCount + 1),
+							),
+							db: db as DbType,
+							schema: schema as {
+								[key: string]: TableType;
+							},
+							tableName: tableName as string,
+							uniqueNotNullColName: uniqueNotNullColName as string,
+						});
+					}
+				}
+			}
+
+			const columnsToUpdateSeqFiltered = [...columnsToUpdateSeq.values()].filter((col) =>
+				col.valueToUpdate !== undefined
+			);
+			if (
+				i === count - 1
+				&& columnsToUpdateSeqFiltered.length !== 0 && db !== undefined
+			) {
+				for (const columnConfig of columnsToUpdateSeq.values()) {
+					if (columnConfig) {
+						await this.updateColumnSequence({ db, columnConfig });
+					}
+				}
+			}
+		}
+
+		return preserveData === true ? generatedValues : [];
+	};
+
+	updateColumnSequence = async (
+		{ db, columnConfig: { valueToUpdate, table, column } }: {
+			db: DbType;
+			columnConfig: {
+				schemaName?: string;
+				tableName: string;
+				columnName: string;
+				valueToUpdate?: number | bigint;
+				table: AnyTable<any>;
+				column: AnyColumn<any>;
+			};
+		},
+	) => {
+		if (is(db, PgAsyncDatabase)) {
+			// const fullTableName = schemaName ? `"${schemaName}"."${tableName}"` : `"${tableName}"`;
+			const dialect = (<any> db).dialect as PgDialect;
+			// const columnCasing = (<any> dialect).casing as CasingCache;
+			// const columnName = columnCasing.getColumnCasing(column as any);
+			const fullTableName = dialect.sqlToQuery(sql`${table}`).sql;
+			const columnName = dialect.sqlToQuery(sql`${column}`).sql.replace(`${fullTableName}.`, '').replaceAll('"', '');
+
+			const rawQuery = `SELECT setval(pg_get_serial_sequence('${fullTableName}', '${columnName}'), ${
+				(valueToUpdate ?? 'null').toString()
+			}, true);`;
+			await db.execute(rawQuery);
+		}
+		// mysql updates auto_increment or serial column by itself
+		// sqlite updates autoincrement  column by itself
+		return;
+	};
+
+	insertInDb = async ({
+		generatedValues,
+		db,
+		schema,
+		tableName,
+		override,
+	}: {
+		generatedValues: {
+			[columnName: string]: GeneratedValueType;
+		}[];
+		db: DbType;
+		schema: {
+			[key: string]: TableType;
+		};
+		tableName: string;
+		override: boolean;
+	}) => {
+		if (is(db, PgAsyncDatabase<any>)) {
+			const query = db.insert((schema as { [key: string]: PgTable })[tableName]!);
+			if (override === true) {
+				return await query.overridingSystemValue().values(generatedValues);
+			}
+			await query.values(generatedValues);
+		} else if (is(db, MySqlAsyncDatabase<any, any>)) {
+			await db
+				.insert((schema as { [key: string]: MySqlTable })[tableName]!)
+				.values(generatedValues);
+		} else if (is(db, SQLiteAsyncDatabase<any, any>)) {
+			await db
+				.insert((schema as { [key: string]: SQLiteTable })[tableName]!)
+				.values(generatedValues);
+		} else if (is(db, MsSqlDatabase<any, any>)) {
+			let schemaDbName: string | undefined;
+			let tableDbName: string | undefined;
+			if (override === true) {
+				const tableConfig = getTableConfigMsSql(schema[tableName]! as MsSqlTable);
+				schemaDbName = tableConfig.schema ?? 'dbo';
+				tableDbName = tableConfig.name;
+				await db.execute(sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] ON;`));
+			}
+
+			await db
+				.insert((schema as { [key: string]: MsSqlTable })[tableName]!)
+				.values(generatedValues);
+
+			if (override === true) {
+				await db.execute(sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] OFF;`));
+			}
+		} else if (is(db, CockroachDatabase<any, any>)) {
+			const query = db
+				.insert((schema as { [key: string]: CockroachTable })[tableName]!)
+				.values(generatedValues);
+			await query;
+		} else if (is(db, SingleStoreDatabase<any, any>)) {
+			const query = db
+				.insert((schema as { [key: string]: SingleStoreTable })[tableName]!)
+				.values(generatedValues);
+			await query;
+		}
+	};
+
+	updateDb = async ({
+		generatedValues,
+		db,
+		schema,
+		tableName,
+		uniqueNotNullColName,
+	}: {
+		generatedValues: {
+			[columnName: string]: GeneratedValueType;
+		}[];
+		db: DbType;
+		schema: {
+			[key: string]: TableType;
+		};
+		tableName: string;
+		uniqueNotNullColName: string;
+	}) => {
+		let values = generatedValues[0]!;
+		const uniqueNotNullColValue = values[uniqueNotNullColName];
+		values = Object.fromEntries(Object.entries(values).filter(([colName]) => colName !== uniqueNotNullColName));
+
+		if (is(db, PgAsyncDatabase<any>)) {
+			const table = (schema as { [key: string]: PgTableWithColumns<any> })[tableName]!;
+			const uniqueNotNullCol = table[uniqueNotNullColName];
+			await db.update(table).set(values).where(
+				eq(uniqueNotNullCol, uniqueNotNullColValue),
+			);
+		} else if (is(db, MySqlAsyncDatabase<any, any>)) {
+			const table = (schema as { [key: string]: MySqlTableWithColumns<any> })[tableName]!;
+			await db.update(table).set(values).where(
+				eq(table[uniqueNotNullColName], uniqueNotNullColValue),
+			);
+		} else if (is(db, SQLiteAsyncDatabase<any, any>)) {
+			const table = (schema as { [key: string]: SQLiteTableWithColumns<any> })[tableName]!;
+			await db.update(table).set(values).where(
+				eq(table[uniqueNotNullColName], uniqueNotNullColValue),
+			);
+		} else if (is(db, MsSqlDatabase<any, any>)) {
+			const table = (schema as { [key: string]: MsSqlTableWithColumns<any> })[tableName]!;
+			await db.update(table).set(values).where(
+				eq(table[uniqueNotNullColName], uniqueNotNullColValue),
+			);
+		} else if (is(db, CockroachDatabase<any, any>)) {
+			const table = (schema as { [key: string]: CockroachTableWithColumns<any> })[tableName]!;
+			await db.update(table).set(values).where(
+				eq(table[uniqueNotNullColName], uniqueNotNullColValue),
+			);
+		} else if (is(db, SingleStoreDatabase<any, any>)) {
+			const table = (schema as { [key: string]: SingleStoreTableWithColumns<any> })[tableName]!;
+			await db.update(table).set(values).where(
+				eq(table[uniqueNotNullColName], uniqueNotNullColValue),
+			);
+		}
+	};
+}
diff --git a/drizzle-seed/src/cockroach-core/index.ts b/drizzle-seed/src/cockroach-core/index.ts
new file mode 100644
index 0000000000..46d8a0b581
--- /dev/null
+++ b/drizzle-seed/src/cockroach-core/index.ts
@@ -0,0 +1,178 @@
+import { type AnyColumn, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { CockroachArray, CockroachDatabase, CockroachSchema } from 'drizzle-orm/cockroach-core';
+import { CockroachTable, getTableConfig } from 'drizzle-orm/cockroach-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+// Cockroach-----------------------------------------------------------------------------------------------------------
+export const resetCockroach = async (
+	db: CockroachDatabase<any, any>,
+	cockroachTables: { [key: string]: CockroachTable },
+) => {
+	const tablesToTruncate = Object.entries(cockroachTables).map(([_, table]) => {
+		const config = getTableConfig(table);
+		config.schema = config.schema === undefined ? 'public' : config.schema;
+
+		return `"${config.schema}"."${config.name}"`;
+	});
+
+	await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
+};
+
+export const filterCockroachSchema = (schema: {
+	[key: string]:
+		| CockroachTable
+		| CockroachSchema
+		| Relations
+		| any;
+}) => {
+	const cockroachSchema = Object.fromEntries(
+		Object.entries(schema).filter((keyValue): keyValue is [string, CockroachTable | Relations] =>
+			is(keyValue[1], CockroachTable) || is(keyValue[1], Relations)
+		),
+	);
+
+	const cockroachTables = Object.fromEntries(
+		Object.entries(schema).filter((keyValue): keyValue is [string, CockroachTable] => is(keyValue[1], CockroachTable)),
+	);
+
+	return { cockroachSchema, cockroachTables };
+};
+
+export const seedCockroach = async (
+	db: CockroachDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| CockroachTable
+			| CockroachSchema
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const seedService = new SeedService();
+
+	const { cockroachSchema, cockroachTables } = filterCockroachSchema(schema);
+	const { tables, relations } = getSchemaInfo(cockroachSchema, cockroachTables, mapCockroachColumns);
+
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'cockroach',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		cockroachTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		cockroachTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+const getTypeParams = (sqlType: string) => {
+	// get type params
+	const typeParams: Column['typeParams'] = {};
+
+	// handle dimensions
+	if (sqlType.includes('[')) {
+		const match = sqlType.match(/\[\w*]/g);
+		if (match) {
+			typeParams['dimensions'] = match.length;
+		}
+	}
+
+	if (
+		sqlType.startsWith('numeric')
+		|| sqlType.startsWith('decimal')
+		|| sqlType.startsWith('double precision')
+		|| sqlType.startsWith('real')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('varchar')
+		|| sqlType.startsWith('char')
+		|| sqlType.startsWith('bit')
+		|| sqlType.startsWith('vector')
+		|| sqlType.startsWith('time')
+		|| sqlType.startsWith('timestamp')
+		|| sqlType.startsWith('interval')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	}
+
+	return typeParams;
+};
+
+const getAllBaseColumns = (
+	baseColumn: CockroachArray<any, any>['baseColumn'] & { baseColumn?: CockroachArray<any, any>['baseColumn'] },
+): Column['baseColumn'] => {
+	const baseColumnResult: Column['baseColumn'] = {
+		name: baseColumn.name,
+		columnType: baseColumn.getSQLType(),
+		typeParams: getTypeParams(baseColumn.getSQLType()),
+		dataType: baseColumn.dataType.split(' ')[0]!,
+		size: (baseColumn as CockroachArray<any, any>).length,
+		hasDefault: baseColumn.hasDefault,
+		enumValues: baseColumn.enumValues,
+		default: baseColumn.default,
+		isUnique: baseColumn.isUnique,
+		notNull: baseColumn.notNull,
+		primary: baseColumn.primary,
+		baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
+	};
+
+	return baseColumnResult;
+};
+
+export const mapCockroachColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	const mappedColumns = columns.map((column) => ({
+		name: dbToTsColumnNamesMap[column.name] as string,
+		columnType: column.getSQLType(),
+		typeParams: getTypeParams(column.getSQLType()),
+		dataType: column.dataType.split(' ')[0]!,
+		size: (column as CockroachArray<any, any>).length,
+		hasDefault: column.hasDefault,
+		default: column.default,
+		enumValues: column.enumValues,
+		isUnique: column.isUnique,
+		notNull: column.notNull,
+		primary: column.primary,
+		generatedIdentityType: column.generatedIdentity?.type,
+		baseColumn: ((column as CockroachArray<any, any>).baseColumn === undefined)
+			? undefined
+			: getAllBaseColumns((column as CockroachArray<any, any>).baseColumn),
+	}));
+
+	return mappedColumns;
+};
diff --git a/drizzle-seed/src/cockroach-core/selectGensForColumn.ts b/drizzle-seed/src/cockroach-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..71c7a6544d
--- /dev/null
+++ b/drizzle-seed/src/cockroach-core/selectGensForColumn.ts
@@ -0,0 +1,294 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { AbstractGenerator, GenerateInterval } from '../generators/Generators.ts';
+import type { Column, Table } from '../types/tables.ts';
+
+// TODO: revise serial part generators
+export const selectGeneratorForCockroachColumn = (
+	table: Table,
+	col: Column,
+) => {
+	const pickGenerator = (table: Table, col: Column) => {
+		// ARRAY
+		if (col.columnType.match(/\[\w*]/g) !== null && col.baseColumn !== undefined) {
+			const baseColumnGen = selectGeneratorForCockroachColumn(
+				table,
+				col.baseColumn!,
+			) as AbstractGenerator;
+			if (baseColumnGen === undefined) {
+				throw new Error(`column with type ${col.baseColumn!.columnType} is not supported for now.`);
+			}
+
+			// const getBaseColumnDataType = (baseColumn: Column) => {
+			// 	if (baseColumn.baseColumn !== undefined) {
+			// 		return getBaseColumnDataType(baseColumn.baseColumn);
+			// 	}
+
+			// 	return baseColumn.dataType;
+			// };
+			// const baseColumnDataType = getBaseColumnDataType(col.baseColumn);
+
+			const generator = new generatorsMap.GenerateArray[0]({ baseColumnGen, size: col.size });
+			// generator.baseColumnDataType = baseColumnDataType;
+
+			return generator;
+		}
+
+		// ARRAY for studio
+		if (col.columnType.match(/\[\w*]/g) !== null) {
+			// remove dimensions from type
+			const baseColumnType = col.columnType.replace(/\[\w*]/g, '');
+			const baseColumn: Column = {
+				...col,
+			};
+			baseColumn.columnType = baseColumnType;
+
+			const baseColumnGen = selectGeneratorForCockroachColumn(table, baseColumn) as AbstractGenerator;
+			if (baseColumnGen === undefined) {
+				throw new Error(`column with type ${col.baseColumn!.columnType} is not supported for now.`);
+			}
+
+			let generator = new generatorsMap.GenerateArray[0]({ baseColumnGen });
+
+			for (let i = 0; i < col.typeParams.dimensions! - 1; i++) {
+				generator = new generatorsMap.GenerateArray[0]({ baseColumnGen: generator });
+			}
+
+			return generator;
+		}
+
+		// INT ------------------------------------------------------------------------------------------------------------
+		if (
+			(
+				col.columnType === 'int2'
+				|| col.columnType === 'int4'
+				|| col.columnType.includes('int8')
+			)
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+
+			return generator;
+		}
+
+		let minValue: number | bigint | undefined;
+		let maxValue: number | bigint | undefined;
+		if (col.columnType.startsWith('int')) {
+			if (col.columnType === 'int2') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -32768;
+				maxValue = 32767;
+			} else if (col.columnType === 'int4') {
+				// 2^32 / 2 - 1, 4 bytes
+				minValue = -2147483648;
+				maxValue = 2147483647;
+			} else if (col.columnType.includes('int8')) {
+				if (col.dataType === 'bigint') {
+					// 2^64 / 2 - 1, 8 bytes
+					minValue = BigInt('-9223372036854775808');
+					maxValue = BigInt('9223372036854775807');
+				} else {
+					// if (col.dataType === 'number')
+					// if you’re expecting values above 2^31 but below 2^53
+					minValue = -9007199254740991;
+					maxValue = 9007199254740991;
+				}
+			}
+		}
+
+		if (
+			col.columnType.startsWith('int')
+			&& !col.columnType.includes('interval')
+		) {
+			const generator = new generatorsMap.GenerateInt[0]({
+				minValue,
+				maxValue,
+			});
+
+			return generator;
+		}
+
+		// NUMBER(real, double, decimal, numeric)
+		if (
+			col.columnType.startsWith('real')
+			|| col.columnType.startsWith('float')
+			|| col.columnType.startsWith('decimal')
+			|| col.columnType.startsWith('numeric')
+		) {
+			if (col.typeParams.precision !== undefined) {
+				const precision = col.typeParams.precision;
+				const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+				const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+				const generator = new generatorsMap.GenerateNumber[0]({
+					minValue: -maxAbsoluteValue,
+					maxValue: maxAbsoluteValue,
+					precision: Math.pow(10, scale),
+				});
+				return generator;
+			}
+			const generator = new generatorsMap.GenerateNumber[0]();
+
+			return generator;
+		}
+
+		// STRING
+		if (
+			(col.columnType === 'string'
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('char'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateUniqueString[0]();
+
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'string'
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('char'))
+			&& col.name.toLowerCase().includes('name')
+		) {
+			const generator = new generatorsMap.GenerateFirstName[0]();
+
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'string'
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('char'))
+			&& col.name.toLowerCase().includes('email')
+		) {
+			const generator = new generatorsMap.GenerateEmail[0]();
+
+			return generator;
+		}
+
+		if (
+			col.columnType === 'string'
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('char')
+		) {
+			const generator = new generatorsMap.GenerateString[0]();
+
+			return generator;
+		}
+
+		// BIT
+		if (col.columnType.startsWith('bit')) {
+			const generator = new generatorsMap.GenerateBitString[0]();
+
+			return generator;
+		}
+
+		// INET
+		if (col.columnType === 'inet') {
+			const generator = new generatorsMap.GenerateInet[0]();
+
+			return generator;
+		}
+
+		// geometry(point)
+		if (col.columnType.startsWith('geometry')) {
+			const generator = new generatorsMap.GenerateGeometry[0]();
+
+			return generator;
+		}
+
+		// vector
+		if (col.columnType.startsWith('vector')) {
+			const generator = new generatorsMap.GenerateVector[0]();
+
+			return generator;
+		}
+
+		// UUID
+		if (col.columnType === 'uuid') {
+			const generator = new generatorsMap.GenerateUUID[0]();
+
+			return generator;
+		}
+
+		// BOOL
+		if (col.columnType === 'bool') {
+			const generator = new generatorsMap.GenerateBoolean[0]();
+
+			return generator;
+		}
+
+		// DATE, TIME, TIMESTAMP
+		if (col.columnType.includes('date')) {
+			const generator = new generatorsMap.GenerateDate[0]();
+
+			return generator;
+		}
+
+		if (col.columnType === 'time') {
+			const generator = new generatorsMap.GenerateTime[0]();
+
+			return generator;
+		}
+
+		if (col.columnType.includes('timestamp')) {
+			const generator = new generatorsMap.GenerateTimestamp[0]();
+
+			return generator;
+		}
+
+		// JSON, JSONB
+		if (col.columnType === 'json' || col.columnType === 'jsonb') {
+			const generator = new generatorsMap.GenerateJson[0]();
+
+			return generator;
+		}
+
+		// if (col.columnType === "jsonb") {
+		//   const generator = new GenerateJsonb({});
+		//   return generator;
+		// }
+
+		// ENUM
+		if (col.enumValues !== undefined) {
+			const generator = new generatorsMap.GenerateEnum[0]({
+				enumValues: col.enumValues,
+			});
+
+			return generator;
+		}
+
+		// INTERVAL
+		if (col.columnType.startsWith('interval')) {
+			if (col.columnType === 'interval') {
+				const generator = new generatorsMap.GenerateInterval[0]();
+
+				return generator;
+			}
+
+			const fields = col.columnType.replace('interval ', '') as GenerateInterval['params']['fields'];
+			const generator = new generatorsMap.GenerateInterval[0]({ fields });
+
+			return generator;
+		}
+
+		if (col.hasDefault && col.default !== undefined) {
+			const generator = new generatorsMap.GenerateDefault[0]({
+				defaultValue: col.default,
+			});
+			return generator;
+		}
+
+		return;
+	};
+
+	const generator = pickGenerator(table, col);
+	// set params for base column
+	if (generator !== undefined) {
+		generator.isUnique = col.isUnique;
+		generator.dataType = col.dataType;
+		// generator.stringLength = col.typeParams.length;
+		generator.typeParams = col.typeParams;
+	}
+
+	return generator;
+};
diff --git a/drizzle-seed/src/common.ts b/drizzle-seed/src/common.ts
new file mode 100644
index 0000000000..410508737d
--- /dev/null
+++ b/drizzle-seed/src/common.ts
@@ -0,0 +1,225 @@
+import { type AnyColumn, Column as DrizzleColumn, getColumnTable, getTableName, is } from 'drizzle-orm';
+import {
+	createTableRelationsHelpers,
+	extractTablesRelationalConfig,
+	One,
+	type Relations,
+} from 'drizzle-orm/_relations';
+import { CockroachTable, getTableConfig as getCockroachTableConfig } from 'drizzle-orm/cockroach-core';
+import { getTableConfig as getMsSqlTableConfig, MsSqlTable } from 'drizzle-orm/mssql-core';
+import { getTableConfig as getMySqlTableConfig, MySqlTable } from 'drizzle-orm/mysql-core';
+import { getTableConfig as getPgTableConfig, PgTable } from 'drizzle-orm/pg-core';
+import { getTableConfig as getSingleStoreTableConfig } from 'drizzle-orm/singlestore-core';
+import { getTableConfig as getSQLiteTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { Column, DrizzleTable, RelationWithReferences, Table, TableConfigT } from './types/tables.ts';
+import { isRelationCyclic } from './utils.ts';
+
+const getTableConfig = (
+	table: DrizzleTable,
+): TableConfigT => {
+	if (is(table, PgTable)) return getPgTableConfig(table);
+	else if (is(table, MySqlTable)) return getMySqlTableConfig(table);
+	else if (is(table, SQLiteTable)) return getSQLiteTableConfig(table);
+	else if (is(table, CockroachTable)) return getCockroachTableConfig(table);
+	else if (is(table, MsSqlTable)) return getMsSqlTableConfig(table);
+	else return getSingleStoreTableConfig(table); // if (is(table, SingleStoreTable))
+};
+
+const transformFromDrizzleRelation = (
+	schema: Record<string, DrizzleTable | Relations>,
+	getDbToTsColumnNamesMap: (table: DrizzleTable) => {
+		[dbColName: string]: string;
+	},
+	tableRelations: {
+		[tableName: string]: RelationWithReferences[];
+	},
+) => {
+	const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+	const relations: RelationWithReferences[] = [];
+	for (const table of Object.values(schemaConfig.tables)) {
+		if (table.relations === undefined) continue;
+
+		for (const drizzleRel of Object.values(table.relations)) {
+			if (!is(drizzleRel, One)) continue;
+
+			const tableConfig = getTableConfig(drizzleRel.sourceTable as DrizzleTable);
+			const tableDbSchema = tableConfig.schema ?? 'public';
+			const tableDbName = tableConfig.name;
+			const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
+
+			const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+			const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name] as string)
+				?? [];
+
+			const refTableConfig = getTableConfig(drizzleRel.referencedTable as DrizzleTable);
+			const refTableDbSchema = refTableConfig.schema ?? 'public';
+			const refTableDbName = refTableConfig.name;
+			const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
+				?? refTableDbName;
+
+			const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+			const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name] as string)
+				?? [];
+
+			if (tableRelations[refTableTsName] === undefined) {
+				tableRelations[refTableTsName] = [];
+			}
+
+			const relation: RelationWithReferences = {
+				table: tableTsName,
+				columns,
+				refTable: refTableTsName,
+				refColumns,
+				refTableRels: tableRelations[refTableTsName],
+				type: 'one',
+			};
+
+			// do not add duplicate relation
+			if (
+				tableRelations[tableTsName]?.some((rel) =>
+					rel.table === relation.table
+					&& rel.refTable === relation.refTable
+				)
+			) {
+				console.warn(
+					`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
+						+ `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
+						+ `In this case, the foreign key constraint will be used.\n`,
+				);
+				continue;
+			}
+
+			relations.push(relation);
+			tableRelations[tableTsName]!.push(relation);
+		}
+	}
+	return relations;
+};
+
+export const getSchemaInfo = (
+	drizzleTablesAndRelations: { [key: string]: DrizzleTable | Relations },
+	drizzleTables: { [key: string]: DrizzleTable },
+	mapColumns: (
+		tableConfig: AnyColumn[],
+		dbToTsColumnNamesMap: { [key: string]: string },
+	) => Column[],
+) => {
+	let tableConfig: ReturnType<typeof getTableConfig>;
+	let dbToTsColumnNamesMap: { [key: string]: string };
+	const dbToTsTableNamesMap: { [key: string]: string } = Object.fromEntries(
+		Object.entries(drizzleTables).map(([key, value]) => [getTableName(value), key]),
+	);
+
+	const tables: Table[] = [];
+	const relations: RelationWithReferences[] = [];
+	const dbToTsColumnNamesMapGlobal: {
+		[tableName: string]: { [dbColumnName: string]: string };
+	} = {};
+	const tableRelations: { [tableName: string]: RelationWithReferences[] } = {};
+
+	const getDbToTsColumnNamesMap = (table: DrizzleTable) => {
+		let dbToTsColumnNamesMap: { [dbColName: string]: string } = {};
+
+		const tableName = getTableName(table);
+		if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+			dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName]!;
+			return dbToTsColumnNamesMap;
+		}
+
+		const tableConfig = getTableConfig(table);
+		for (const [tsCol, col] of Object.entries(getColumnTable(tableConfig.columns[0]!))) {
+			if (is(col, DrizzleColumn)) dbToTsColumnNamesMap[col.name] = tsCol;
+		}
+		dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
+
+		return dbToTsColumnNamesMap;
+	};
+
+	for (const table of Object.values(drizzleTables)) {
+		tableConfig = getTableConfig(table);
+
+		dbToTsColumnNamesMap = getDbToTsColumnNamesMap(table);
+
+		// might be empty list
+		const newRelations = tableConfig.foreignKeys === undefined ? [] : tableConfig.foreignKeys.map((fk) => {
+			const table = dbToTsTableNamesMap[tableConfig.name] as string;
+			const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
+
+			const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
+				fk.reference().foreignTable,
+			);
+
+			if (tableRelations[refTable] === undefined) {
+				tableRelations[refTable] = [];
+			}
+			return {
+				table,
+				columns: fk
+					.reference()
+					.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
+				refTable,
+				refColumns: fk
+					.reference()
+					.foreignColumns.map(
+						(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
+					),
+				refTableRels: tableRelations[refTable],
+			};
+		});
+
+		relations.push(
+			...newRelations,
+		);
+
+		if (tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] === undefined) {
+			tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] = [];
+		}
+		tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
+
+		const stringsSet: string[] = [];
+		const uniqueConstraints: string[][] = [];
+		for (const uniCon of tableConfig.uniqueConstraints) {
+			const uniConColumns = uniCon.columns.map((col) => dbToTsColumnNamesMap[col.name] as string);
+			const uniConColumnsStr = JSON.stringify(uniConColumns);
+
+			if (!stringsSet.includes(uniConColumnsStr)) {
+				stringsSet.push(uniConColumnsStr);
+				uniqueConstraints.push(uniConColumns);
+			}
+		}
+
+		const mappedTable: Table = {
+			name: dbToTsTableNamesMap[tableConfig.name] as string,
+			uniqueConstraints,
+			primaryKeys: tableConfig.columns
+				.filter((column) => column.primary)
+				.map((column) => dbToTsColumnNamesMap[column.name] as string),
+			columns: mapColumns(tableConfig.columns, dbToTsColumnNamesMap),
+		};
+		tables.push(mappedTable);
+	}
+
+	const transformedDrizzleRelations = transformFromDrizzleRelation(
+		drizzleTablesAndRelations,
+		getDbToTsColumnNamesMap,
+		tableRelations,
+	);
+	relations.push(
+		...transformedDrizzleRelations,
+	);
+
+	const isCyclicRelations = relations.map(
+		(relI) => {
+			// if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
+			const tableRel = tableRelations[relI.table]!.find((relJ) => relJ.refTable === relI.refTable)!;
+			if (isRelationCyclic(relI)) {
+				tableRel['isCyclic'] = true;
+				return { ...relI, isCyclic: true };
+			}
+			tableRel['isCyclic'] = false;
+			return { ...relI, isCyclic: false };
+		},
+	);
+
+	return { tables, relations: isCyclicRelations, tableRelations };
+};
diff --git a/drizzle-seed/src/services/GeneratorFuncs.ts b/drizzle-seed/src/generators/GeneratorFuncs.ts
similarity index 80%
rename from drizzle-seed/src/services/GeneratorFuncs.ts
rename to drizzle-seed/src/generators/GeneratorFuncs.ts
index 10d0d10f75..4a61adf15f 100644
--- a/drizzle-seed/src/services/GeneratorFuncs.ts
+++ b/drizzle-seed/src/generators/GeneratorFuncs.ts
@@ -1,9 +1,11 @@
 import type { AbstractGenerator } from './Generators.ts';
 import {
 	GenerateArray,
+	GenerateBitString,
 	GenerateBoolean,
 	GenerateCity,
 	GenerateCompanyName,
+	GenerateCompositeUniqueKey,
 	GenerateCountry,
 	GenerateDate,
 	GenerateDatetime,
@@ -12,6 +14,9 @@ import {
 	GenerateEnum,
 	GenerateFirstName,
 	GenerateFullName,
+	GenerateGeometry,
+	GenerateHashFromString,
+	GenerateInet,
 	GenerateInt,
 	GenerateInterval,
 	GenerateIntPrimaryKey,
@@ -30,11 +35,14 @@ import {
 	GenerateString,
 	GenerateTime,
 	GenerateTimestamp,
+	GenerateUniqueBitString,
 	GenerateUniqueCity,
 	GenerateUniqueCompanyName,
 	GenerateUniqueCountry,
 	GenerateUniqueFirstName,
 	GenerateUniqueFullName,
+	GenerateUniqueGeometry,
+	GenerateUniqueInet,
 	GenerateUniqueInt,
 	GenerateUniqueInterval,
 	GenerateUniqueLastName,
@@ -44,14 +52,18 @@ import {
 	GenerateUniquePostcode,
 	GenerateUniqueStreetAddress,
 	GenerateUniqueString,
+	GenerateUniqueVector,
 	GenerateUUID,
 	GenerateValuesFromArray,
+	GenerateVector,
 	GenerateWeightedCount,
 	GenerateYear,
 	HollowGenerator,
 	WeightedRandomGenerator,
 } from './Generators.ts';
 import { GenerateStringV2, GenerateUniqueIntervalV2, GenerateUniqueStringV2 } from './versioning/v2.ts';
+import { GenerateHashFromStringV3 } from './versioning/v3.ts';
+import { GenerateUUIDV4 } from './versioning/v4.ts';
 
 function createGenerator<GeneratorType extends AbstractGenerator<T>, T>(
 	generatorConstructor: new(params?: T) => GeneratorType,
@@ -230,6 +242,8 @@ export const generatorsFuncs = {
 
 	/**
 	 * generates time in 24 hours style.
+	 * @param minTime - lower border of range.
+	 * @param maxTime - upper border of range.
 	 * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
 	 *
 	 * @example
@@ -237,7 +251,7 @@ export const generatorsFuncs = {
 	 *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
 	 *    users: {
 	 *      columns: {
-	 *        birthTime: funcs.time()
+	 *        birthTime: funcs.time({ minTime: "11:12:13.141", maxTime: "15:16:17.181" })
 	 *      },
 	 *    },
 	 *  }));
@@ -248,6 +262,8 @@ export const generatorsFuncs = {
 
 	/**
 	 * generates timestamps.
+	 * @param minTimestamp - lower border of range.
+	 * @param maxTimestamp - upper border of range.
 	 * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
 	 *
 	 * @example
@@ -255,7 +271,7 @@ export const generatorsFuncs = {
 	 *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
 	 *    orders: {
 	 *      columns: {
-	 *        shippedDate: funcs.timestamp()
+	 *        shippedDate: funcs.timestamp({ minTimestamp: "2025-03-07T11:12:13.141", maxTimestamp: "2025-03-08T15:16:17.181" })
 	 *      },
 	 *    },
 	 *  }));
@@ -266,6 +282,8 @@ export const generatorsFuncs = {
 
 	/**
 	 * generates datetime objects.
+	 * @param minDatetime - lower border of range.
+	 * @param maxDatetime - upper border of range.
 	 * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
 	 *
 	 * @example
@@ -273,7 +291,7 @@ export const generatorsFuncs = {
 	 *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
 	 *    orders: {
 	 *      columns: {
-	 *        shippedDate: funcs.datetime()
+	 *        shippedDate: funcs.datetime({ minDatetime: "2025-03-07T11:12:13.141", maxDatetime: "2025-03-08T15:16:17.181" })
 	 *      },
 	 *    },
 	 *  }));
@@ -754,14 +772,154 @@ export const generatorsFuncs = {
 	 * ```
 	 */
 	weightedRandom: createGenerator(WeightedRandomGenerator),
+
+	/**
+	 * generates bit strings based on specified parameters
+	 *
+	 * @param isUnique - property that controls if generated values gonna be unique or not.
+	 * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+	 * @param dimensions - desired length of each bit string (e.g., `dimensions = 3` produces values like `'010'`).
+	 *
+	 * Defaults to the value of the database column bit-length.
+	 *
+	 * @example
+	 * ```ts
+	 *  await seed(db, { bitStringTable: schema.bitStringTable }).refine((funcs) => ({
+	 * 		bitStringTable: {
+	 * 			count,
+	 * 			columns: {
+	 * 				bit: funcs.bitString({
+	 * 					dimensions: 12,
+	 * 					isUnique: true
+	 * 				}),
+	 * 			},
+	 * 		},
+	 * 	}));
+	 * ```
+	 */
+	bitString: createGenerator(GenerateBitString),
+
+	/**
+	 * generates ip addresses based on specified parameters
+	 *
+	 * @param isUnique - property that controls if generated values gonna be unique or not.
+	 * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+	 * @param ipAddress - type of IP address to generate — either "ipv4" or "ipv6".
+	 *
+	 * Defaults to `'ipv4'`.
+	 * @param includeCidr - determines whether generated IPs include a CIDR suffix.
+	 *
+	 * Defaults to `true`.
+	 *
+	 * @example
+	 * ```ts
+	 *  await seed(db, { inetTable: schema.inetTable }).refine((funcs) => ({
+	 * 		inetTable: {
+	 * 			count,
+	 * 			columns: {
+	 * 				inet: funcs.inet({
+	 * 					ipAddress: 'ipv4',
+	 * 					includeCidr: true,
+	 * 					isUnique: true
+	 * 				}),
+	 * 			},
+	 * 		},
+	 * 	}));
+	 * ```
+	 */
+	inet: createGenerator(GenerateInet),
+
+	/**
+	 * generates PostGIS geometry objects based on the given parameters.
+	 *
+	 * @param isUnique - property that controls if generated values gonna be unique or not.
+	 * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+	 * @param type - geometry type to generate; currently only `'point'` is supported.
+	 *
+	 * Defaults to `'point'`.
+	 * @param srid - Spatial Reference System Identifier: determines what type of point will be generated - either `4326` or `3857`.
+	 *
+	 * Defaults to `4326`.
+	 * @param decimalPlaces - number of decimal places for points when `srid` is `4326` (e.g., `decimalPlaces = 3` produces values like `'point(30.723 46.482)'`).
+	 *
+	 * Defaults to `6`.
+	 *
+	 * @example
+	 * ```ts
+	 *  await seed(db, { geometryTable: schema.geometryTable }).refine((funcs) => ({
+	 * 		geometryTable: {
+	 * 			count,
+	 * 			columns: {
+	 * 				geometryPointTuple: funcs.geometry({
+	 * 					type: 'point',
+	 * 					srid: 4326,
+	 * 					decimalPlaces: 5,
+	 * 					isUnique: true
+	 * 				})
+	 * 			},
+	 * 		},
+	 * 	}));
+	 * ```
+	 */
+	geometry: createGenerator(GenerateGeometry),
+
+	/**
+	 * generates vectors based on the provided parameters.
+	 *
+	 * @param isUnique - property that controls if generated values gonna be unique or not.
+	 * @param arraySize - number of elements in each one-dimensional array (If specified, arrays will be generated).
+	 * @param decimalPlaces - number of decimal places for each vector element (e.g., `decimalPlaces = 3` produces values like `1.123`).
+	 *
+	 * Defaults to `2`.
+	 * @param dimensions - number of elements in each generated vector (e.g., `dimensions = 3` produces values like `[1,2,3]`).
+	 *
+	 * Defaults to the value of the database column’s dimensions.
+	 * @param minValue - minimum allowed value for each vector element.
+	 *
+	 * Defaults to `-1000`.
+	 * @param maxValue - maximum allowed value for each vector element.
+	 *
+	 * Defaults to `1000`.
+	 *
+	 * @example
+	 * ```ts
+	 *  await seed(db, { vectorTable: schema.vectorTable }).refine((funcs) => ({
+	 * 		vectorTable: {
+	 * 			count,
+	 * 			columns: {
+	 * 				vector: funcs.vector({
+	 * 					decimalPlaces: 5,
+	 * 					dimensions: 12,
+	 * 					minValue: -100,
+	 * 					maxValue: 100,
+	 * 					isUnique: true
+	 * 				}),
+	 * 			},
+	 * 		},
+	 * 	}));
+	 * ```
+	 */
+	vector: createGenerator(GenerateVector),
 };
 
-// so far, version changes don’t affect generator parameters.
+// so far, version changes don’t change generator parameters.
 export const generatorsFuncsV2 = {
 	...generatorsFuncs,
 };
 
+export const generatorsFuncsV3 = {
+	...generatorsFuncs,
+};
+
+export const generatorsFuncsV4 = {
+	...generatorsFuncs,
+};
+
 export const generatorsMap = {
+	GenerateHashFromString: [
+		GenerateHashFromString,
+		GenerateHashFromStringV3,
+	],
 	HollowGenerator: [
 		HollowGenerator,
 	],
@@ -830,6 +988,7 @@ export const generatorsMap = {
 	],
 	GenerateUUID: [
 		GenerateUUID,
+		GenerateUUIDV4,
 	],
 	GenerateFirstName: [
 		GenerateFirstName,
@@ -915,4 +1074,31 @@ export const generatorsMap = {
 	GenerateWeightedCount: [
 		GenerateWeightedCount,
 	],
+	GenerateBitString: [
+		GenerateBitString,
+	],
+	GenerateUniqueBitString: [
+		GenerateUniqueBitString,
+	],
+	GenerateInet: [
+		GenerateInet,
+	],
+	GenerateUniqueInet: [
+		GenerateUniqueInet,
+	],
+	GenerateGeometry: [
+		GenerateGeometry,
+	],
+	GenerateUniqueGeometry: [
+		GenerateUniqueGeometry,
+	],
+	GenerateVector: [
+		GenerateVector,
+	],
+	GenerateUniqueVector: [
+		GenerateUniqueVector,
+	],
+	GenerateCompositeUniqueKey: [
+		GenerateCompositeUniqueKey,
+	],
 } as const;
diff --git a/drizzle-seed/src/generators/Generators.ts b/drizzle-seed/src/generators/Generators.ts
new file mode 100644
index 0000000000..3d302e435e
--- /dev/null
+++ b/drizzle-seed/src/generators/Generators.ts
@@ -0,0 +1,4496 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import prand from 'pure-rand';
+import adjectives, { maxStringLength as maxAdjectiveLength } from '../datasets/adjectives.ts';
+import cityNames, { maxStringLength as maxCityNameLength } from '../datasets/cityNames.ts';
+import companyNameSuffixes, { maxStringLength as maxCompanyNameSuffixLength } from '../datasets/companyNameSuffixes.ts';
+import countries, { maxStringLength as maxCountryLength } from '../datasets/countries.ts';
+import emailDomains, { maxStringLength as maxEmailDomainLength } from '../datasets/emailDomains.ts';
+import firstNames, { maxStringLength as maxFirstNameLength } from '../datasets/firstNames.ts';
+import jobsTitles, { maxStringLength as maxJobTitleLength } from '../datasets/jobsTitles.ts';
+import lastNames, { maxStringLength as maxLastNameLength } from '../datasets/lastNames.ts';
+import loremIpsumSentences, { maxStringLength as maxLoremIpsumLength } from '../datasets/loremIpsumSentences.ts';
+import phonesInfo from '../datasets/phonesInfo.ts';
+import states, { maxStringLength as maxStateLength } from '../datasets/states.ts';
+import streetSuffix, { maxStringLength as maxStreetSuffixLength } from '../datasets/streetSuffix.ts';
+import type { GeneratedValueType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+import {
+	abs,
+	fastCartesianProduct,
+	fastCartesianProductForBigint,
+	fillTemplate,
+	getWeightedIndices,
+	isObject,
+	isValidDate,
+	OrderedNumberRange,
+} from './utils.ts';
+
+export abstract class AbstractGenerator<T = {}> {
+	static readonly entityKind: string = 'AbstractGenerator';
+	static readonly version: number = 1;
+	public isGeneratorUnique = false;
+
+	public isUnique = false;
+	public notNull = false;
+
+	// param for generators which have a unique version of themselves
+	public uniqueVersionOfGen?: new(params: T) => AbstractGenerator<T>;
+	public maxUniqueCount: number = -1;
+
+	public dataType?: string;
+	public timeSpent?: number;
+
+	//
+	public arraySize?: number;
+	public columnDataType?: string;
+
+	// param for text-like generators
+	// public stringLength?: number;
+
+	// params for GenerateValuesFromArray
+	public weightedCountSeed?: number | undefined;
+	public maxRepeatedValuesCount?: number | { weight: number; count: number | number[] }[] | undefined;
+
+	public typeParams: Column['typeParams'] = {};
+	public uniqueKey?: string;
+
+	public params: T;
+
+	constructor(params?: T) {
+		this.params = params === undefined ? {} as T : params as T;
+	}
+
+	init(params: { count: number | { weight: number; count: number | number[] }[]; seed: number }): void;
+	init() {
+		this.updateProperties();
+	}
+
+	updateProperties() {
+		if ((this.params as any).arraySize !== undefined) {
+			this.arraySize = (this.params as any).arraySize;
+		}
+
+		if ((this.params as any).isUnique !== undefined) {
+			if ((this.params as any).isUnique === false && this.isUnique === true) {
+				throw new Error('specifying non unique generator to unique column.');
+			}
+
+			this.isUnique = (this.params as any).isUnique;
+		}
+	}
+
+	updateParams(config: { columnName: string; paramsToUpdate: Record<string, any> }): void;
+	updateParams() {}
+
+	abstract generate(
+		params: { i?: number; columnName?: string; input?: string },
+	): number | string | boolean | unknown | undefined | void;
+
+	getEntityKind(): string {
+		const constructor = this.constructor as typeof AbstractGenerator;
+		return constructor.entityKind;
+	}
+
+	getMaxUniqueCount() {
+		// override if you need to initialize this.maxUniqueCount after constructor
+		return this.maxUniqueCount;
+	}
+
+	replaceIfUnique() {
+		this.updateProperties();
+		if (
+			(this.uniqueVersionOfGen !== undefined)
+			&& this.isUnique === true
+		) {
+			const uniqueGen = new this.uniqueVersionOfGen({
+				...this.params,
+			});
+
+			uniqueGen.isUnique = this.isUnique;
+			uniqueGen.dataType = this.dataType;
+			uniqueGen.typeParams = this.typeParams;
+
+			return uniqueGen;
+		}
+		return;
+	}
+
+	replaceIfArray() {
+		this.updateProperties();
+		if (!(this.getEntityKind() === 'GenerateArray') && this.arraySize !== undefined) {
+			const uniqueGen = this.replaceIfUnique();
+			const baseColumnGen = uniqueGen === undefined ? this : uniqueGen;
+
+			baseColumnGen.dataType = this.columnDataType; // ????
+
+			const { dimensions, ...rest } = baseColumnGen.typeParams;
+			baseColumnGen.typeParams = rest;
+
+			const arrayGen = new GenerateArray(
+				{
+					baseColumnGen,
+					size: this.arraySize,
+				},
+			);
+			arrayGen.typeParams = { dimensions };
+
+			return arrayGen as AbstractGenerator<any>;
+		}
+
+		return;
+	}
+}
+
+// Generators Classes -----------------------------------------------------------------------------------------------------------------------
+export class GenerateHashFromString extends AbstractGenerator<{}> {
+	static override readonly entityKind: string = 'GenerateHashFromString';
+	override init() {}
+	generate({ input }: { input: string }): number {
+		let hash = 0;
+		// p and m are prime numbers
+		const p = 53;
+		const m = 28871271685163;
+
+		for (let i = 0; i < input.length; i++) {
+			hash += ((input.codePointAt(i) || 0) * Math.pow(p, i)) % m;
+		}
+
+		return hash;
+	}
+}
+export class GenerateArray extends AbstractGenerator<{ baseColumnGen: AbstractGenerator<any>; size?: number }> {
+	static override readonly entityKind: string = 'GenerateArray';
+	public override arraySize = 10;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+		this.arraySize = this.params.size === undefined ? this.arraySize : this.params.size;
+		this.params.baseColumnGen.init({ count: count * this.arraySize, seed });
+	}
+
+	generate() {
+		const array = [];
+		for (let i = 0; i < this.arraySize; i++) {
+			array.push(this.params.baseColumnGen.generate({ i }));
+		}
+
+		return array;
+	}
+}
+
+export class GenerateWeightedCount extends AbstractGenerator<{}> {
+	static override readonly entityKind: string = 'GenerateWeightedCount';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		weightedIndices: number[];
+		weightedCount: { weight: number; count: number | number[] }[];
+	} | undefined;
+
+	override init({ seed, count }: { count: { weight: number; count: number | number[] }[]; seed: number }) {
+		const rng = prand.xoroshiro128plus(seed);
+		const weightedIndices = getWeightedIndices(count.map((val) => val.weight));
+		this.state = { rng, weightedIndices, weightedCount: count };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		// logic for this generator
+		let idx: number;
+		const weightedCount = this.state.weightedCount;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
+		const objIdx = this.state.weightedIndices[idx] as number;
+
+		if (typeof weightedCount[objIdx]!.count === 'number') {
+			return weightedCount[objIdx]!.count as number;
+		} else {
+			// typeof weightedCount[objIdx]!.count === 'object' // number[]
+			const possCounts = weightedCount[objIdx]!.count as number[];
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, possCounts.length - 1, this.state.rng);
+			return possCounts[idx]!;
+		}
+	}
+}
+
+export class HollowGenerator extends AbstractGenerator<{}> {
+	static override readonly entityKind: string = 'HollowGenerator';
+
+	override init() {}
+
+	generate() {}
+}
+
+export class GenerateDefault extends AbstractGenerator<{
+	defaultValue: unknown;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateDefault';
+
+	generate() {
+		return this.params.defaultValue;
+	}
+}
+
+// TODO split GenerateValuesFromArray into GenerateValuesFromArray and GenerateUniqueValuesFromArray;
+// TODO make all unique generators extend from new UniqueGenerator class
+export type GenerateValuesFromArrayT = {
+	values:
+		| GeneratedValueType[]
+		| { weight: number; values: GeneratedValueType[] }[];
+	isUnique?: boolean;
+	arraySize?: number;
+};
+export class GenerateValuesFromArray extends AbstractGenerator<GenerateValuesFromArrayT> {
+	static override readonly entityKind: string = 'GenerateValuesFromArray';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		values:
+			| GeneratedValueType[]
+			| { weight: number; values: GeneratedValueType[] }[];
+		genIndicesObj: GenerateUniqueInt | undefined;
+		genIndicesObjList: GenerateUniqueInt[] | undefined;
+		valuesWeightedIndices: number[] | undefined;
+		genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
+	} | undefined;
+	public override timeSpent: number = 0;
+	// TODO rewrite generator
+
+	constructor(params?: GenerateValuesFromArrayT) {
+		super(params);
+	}
+
+	override updateParams({ paramsToUpdate }: { paramsToUpdate: Record<string, any> }) {
+		Object.assign(this.params, paramsToUpdate);
+	}
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== -1) return this.maxUniqueCount;
+
+		this.maxUniqueCount = this.params.values.length;
+		if (isObject(this.params.values[0])) {
+			this.maxUniqueCount = (this.params.values as { values: any[] }[]).reduce(
+				(acc, currVal) => acc + currVal.values.length,
+				0,
+			);
+		}
+		return this.maxUniqueCount;
+	}
+
+	checks({ count }: { count: number }) {
+		this.getMaxUniqueCount();
+		const { values } = this.params;
+		const { maxRepeatedValuesCount, notNull, isUnique } = this;
+		if (values.length === 0) {
+			throw new Error('Values length equals zero.');
+		}
+
+		if (
+			isObject(values[0])
+			&& !(values as { weight: number; values: any[] }[]).every((val) => val.values.length !== 0)
+		) {
+			throw new Error('One of weighted values length equals zero.');
+		}
+
+		if (
+			maxRepeatedValuesCount !== undefined && (
+				(typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount <= 0)
+				|| (typeof maxRepeatedValuesCount === 'object' && !maxRepeatedValuesCount
+					.every((obj) =>
+						(typeof obj.count) === 'number'
+							? (obj.count as number) > 0
+							: (obj.count as number[]).every((count) => count > 0)
+					))
+			)
+		) {
+			throw new Error('maxRepeatedValuesCount should be greater than zero.');
+		}
+
+		if (
+			notNull === true
+			&& maxRepeatedValuesCount !== undefined
+			&& (
+				(!isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
+					&& maxRepeatedValuesCount * values.length < count)
+				|| (isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
+					// eslint-disable-next-line unicorn/consistent-destructuring
+					&& maxRepeatedValuesCount * this.maxUniqueCount < count)
+			)
+		) {
+			throw new Error("Can't fill notNull column with null values.");
+		}
+
+		if (
+			isUnique === true && maxRepeatedValuesCount !== undefined && (
+				(typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount > 1)
+				|| (typeof maxRepeatedValuesCount === 'object' && !maxRepeatedValuesCount
+					.every((obj) =>
+						(typeof obj.count) === 'number'
+							? obj.count === 1
+							: (obj.count as number[]).every((count) => count === 1)
+					))
+			)
+		) {
+			throw new Error("Can't be greater than 1 if column is unique.");
+		}
+
+		if (
+			isUnique === true && notNull === true && (
+				(!isObject(values[0]) && values.length < count)
+				// eslint-disable-next-line unicorn/consistent-destructuring
+				|| (isObject(values[0]) && this.maxUniqueCount < count)
+			)
+		) {
+			// console.log(maxRepeatedValuesCount, values.length, allValuesCount, count)
+			throw new Error('There are no enough values to fill unique column.');
+		}
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		this.checks({ count });
+
+		let { maxRepeatedValuesCount } = this;
+		const { params, isUnique, notNull, weightedCountSeed } = this;
+
+		const values = params.values;
+
+		let valuesWeightedIndices;
+		if (isObject(values[0])) {
+			valuesWeightedIndices = getWeightedIndices((values as { weight: number }[]).map((val) => val.weight));
+			if (isUnique === true && notNull === true) {
+				let idx: number, valueIdx: number, rng = prand.xoroshiro128plus(seed);
+				const indicesCounter: { [key: number]: number } = {};
+				for (let i = 0; i < count; i++) {
+					[idx, rng] = prand.uniformIntDistribution(0, valuesWeightedIndices.length - 1, rng);
+					valueIdx = valuesWeightedIndices[idx]!;
+					if (!Object.hasOwn(indicesCounter, valueIdx)) indicesCounter[valueIdx] = 0;
+					indicesCounter[valueIdx]! += 1;
+				}
+
+				for (const [idx, value] of values.entries()) {
+					if ((value as { values: (number | string | boolean | undefined)[] }).values.length < indicesCounter[idx]!) {
+						throw new Error(
+							'weighted values arrays is too small to generate values with specified probability for unique not null column.'
+								+ `it's planned to generate: ${
+									Object.entries(indicesCounter).map(([idx, count]) => {
+										return `${count} values with probability ${(values as { weight: number }[])[Number(idx)]?.weight}`;
+									}).join(',')
+								}`,
+						);
+					}
+				}
+			}
+		}
+		if (isUnique === true && maxRepeatedValuesCount === undefined) {
+			maxRepeatedValuesCount = 1;
+		}
+		let genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
+		if (typeof maxRepeatedValuesCount === 'number') {
+			genMaxRepeatedValuesCount = new GenerateDefault({ defaultValue: maxRepeatedValuesCount });
+		} else if (typeof maxRepeatedValuesCount === 'object') {
+			genMaxRepeatedValuesCount = new GenerateWeightedCount({});
+			(genMaxRepeatedValuesCount as GenerateWeightedCount).init(
+				{
+					count: maxRepeatedValuesCount,
+					seed: weightedCountSeed === undefined ? seed : weightedCountSeed,
+				},
+			);
+		}
+
+		let genIndicesObj: GenerateUniqueInt | undefined;
+		let genIndicesObjList: GenerateUniqueInt[] | undefined;
+
+		if (maxRepeatedValuesCount !== undefined) {
+			if (!isObject(values[0])) {
+				genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: values.length - 1 });
+				genIndicesObj.genMaxRepeatedValuesCount = genMaxRepeatedValuesCount;
+				genIndicesObj.skipCheck = true;
+				genIndicesObj.init({ count, seed });
+			} else if (isObject(values[0])) {
+				genIndicesObjList = [];
+				for (const obj of values as { weight: number; values: (number | string | boolean | undefined)[] }[]) {
+					const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: obj.values.length - 1 });
+					genIndicesObj.genMaxRepeatedValuesCount = genMaxRepeatedValuesCount;
+					genIndicesObj.skipCheck = true;
+					genIndicesObj.init({ count, seed });
+					genIndicesObjList.push(genIndicesObj);
+				}
+			}
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng, values, valuesWeightedIndices, genMaxRepeatedValuesCount, genIndicesObj, genIndicesObjList };
+	}
+
+	generate() {
+		const t0 = new Date();
+
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number,
+			value: string | number | boolean | undefined;
+		let valueIdx: number;
+
+		if (this.state.valuesWeightedIndices === undefined) {
+			if (this.state.genIndicesObj === undefined) {
+				[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.values.length - 1, this.state.rng);
+			} else {
+				idx = this.state.genIndicesObj.generate() as number;
+			}
+
+			value = (this.state.values as (number | string | boolean | undefined)[])[idx];
+		} else {
+			// weighted values
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				this.state.valuesWeightedIndices.length - 1,
+				this.state.rng,
+			);
+			valueIdx = this.state.valuesWeightedIndices[idx] as number;
+			const currValues =
+				(this.state.values![valueIdx] as { weight: number; values: (number | string | boolean | undefined)[] }).values;
+			if (this.state.genIndicesObjList === undefined) {
+				// isUnique !== true
+				[idx, this.state.rng] = prand.uniformIntDistribution(0, currValues.length - 1, this.state.rng);
+			} else {
+				// isUnique === true
+				idx = this.state.genIndicesObjList[valueIdx]!.generate() as number;
+			}
+			value = currValues[idx];
+		}
+
+		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
+		return value;
+	}
+}
+
+export class GenerateSelfRelationsValuesFromArray extends AbstractGenerator<{ values: (number | string | bigint)[] }> {
+	static override readonly entityKind: string = 'GenerateSelfRelationsValuesFromArray';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		firstValuesCount: number;
+		firstValues: (string | number | bigint)[];
+	} | undefined;
+
+	override updateParams({ paramsToUpdate }: { paramsToUpdate: Record<string, any> }) {
+		Object.assign(this.params, paramsToUpdate);
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+		let rng = prand.xoroshiro128plus(seed);
+
+		// generate 15-40 % values with the same value as reference column
+		let percent = 30;
+		[percent, rng] = prand.uniformIntDistribution(20, 40, rng);
+		const firstValuesCount = Math.floor((percent / 100) * count), firstValues: (string | number | bigint)[] = [];
+
+		this.state = { rng, firstValuesCount, firstValues };
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const { values } = this.params;
+		let idx: number;
+
+		if (i < this.state.firstValuesCount) {
+			this.state.firstValues.push(values[i]!);
+			return values[i];
+		} else {
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.firstValues.length - 1, this.state.rng);
+			return this.state.firstValues[idx];
+		}
+	}
+}
+
+export class GenerateIntPrimaryKey extends AbstractGenerator<{}> {
+	static override readonly entityKind: string = 'GenerateIntPrimaryKey';
+
+	public maxValue?: number | bigint;
+	public override maxUniqueCount: number = Number.POSITIVE_INFINITY;
+	public override isGeneratorUnique = true;
+
+	override init({ count }: { count: number; seed: number }) {
+		if (this.maxValue !== undefined && count > this.maxValue) {
+			throw new Error('count exceeds max number for this column type.');
+		}
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.dataType === 'bigint') {
+			return BigInt(i + 1);
+		}
+
+		return i + 1;
+	}
+}
+
+export class GenerateNumber extends AbstractGenerator<
+	{
+		minValue?: number;
+		maxValue?: number;
+		precision?: number;
+		isUnique?: boolean;
+		arraySize?: number;
+	}
+> {
+	static override readonly entityKind: string = 'GenerateNumber';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minValue: number;
+		maxValue: number;
+		precision: number;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueNumber;
+
+	// TODO rewrite precision to decimalPlaces
+	override init({ count, seed }: { seed: number; count: number }) {
+		super.init({ count, seed });
+
+		let { minValue, maxValue, precision } = this.params;
+		if (precision === undefined) {
+			precision = 100;
+		}
+
+		if (maxValue === undefined) {
+			maxValue = precision * 1000;
+		} else {
+			maxValue *= precision;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		} else {
+			minValue *= precision;
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng, minValue, maxValue, precision };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let value: number;
+
+		[value, this.state.rng] = prand.uniformIntDistribution(this.state.minValue, this.state.maxValue, this.state.rng);
+		return value / this.state.precision;
+	}
+}
+
+export type GenerateUniqueNumberT = {
+	minValue?: number;
+	maxValue?: number;
+	precision?: number;
+	isUnique?: boolean;
+};
+export class GenerateUniqueNumber extends AbstractGenerator<GenerateUniqueNumberT> {
+	static override readonly entityKind: string = 'GenerateUniqueNumber';
+
+	private state: {
+		genUniqueIntObj: GenerateUniqueInt;
+		minValue: number;
+		maxValue: number;
+		precision: number;
+	} | undefined;
+	public precision: number;
+
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniqueNumberT) {
+		super(params);
+		let { minValue, maxValue } = this.params;
+		const { precision } = this.params;
+
+		this.precision = precision ?? 100;
+
+		if (maxValue === undefined) {
+			this.maxUniqueCount = Number.POSITIVE_INFINITY;
+			return;
+		} else {
+			maxValue *= this.precision;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		} else {
+			minValue *= this.precision;
+		}
+
+		this.maxUniqueCount = maxValue - minValue + 1;
+	}
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		let { minValue, maxValue, precision } = this.params;
+
+		if (precision === undefined) {
+			precision = 100;
+		}
+
+		if (maxValue === undefined) {
+			this.maxUniqueCount = Number.POSITIVE_INFINITY;
+			return this.maxUniqueCount;
+		} else {
+			maxValue *= precision;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		} else {
+			minValue *= precision;
+		}
+
+		this.maxUniqueCount = maxValue - minValue + 1;
+
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		let { minValue, maxValue } = this.params;
+
+		if (maxValue === undefined) {
+			maxValue = count * this.precision;
+		} else {
+			maxValue *= this.precision;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		} else {
+			minValue *= this.precision;
+		}
+
+		const genUniqueIntObj = new GenerateUniqueInt({ minValue, maxValue });
+		genUniqueIntObj.init({ count, seed });
+
+		this.state = { genUniqueIntObj, minValue, maxValue, precision: this.precision };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const value = this.state.genUniqueIntObj.generate() as number / this.state.precision;
+
+		return value;
+	}
+}
+
+export class GenerateInt extends AbstractGenerator<{
+	minValue?: number | bigint;
+	maxValue?: number | bigint;
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateInt';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minValue: number | bigint;
+		maxValue: number | bigint;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueInt;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		let { minValue, maxValue } = this.params;
+
+		if (maxValue === undefined) {
+			maxValue = 1000;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		}
+
+		if (typeof minValue === 'number' && typeof maxValue === 'number') {
+			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng, minValue, maxValue };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let value: number | bigint;
+		if (typeof this.state.minValue === 'bigint' && typeof this.state.maxValue === 'bigint') {
+			[value, this.state.rng] = prand.uniformBigIntDistribution(
+				this.state.minValue,
+				this.state.maxValue,
+				this.state.rng,
+			);
+		} else {
+			[value, this.state.rng] = prand.uniformIntDistribution(
+				this.state.minValue as number,
+				this.state.maxValue as number,
+				this.state.rng,
+			);
+		}
+
+		if (this.dataType === 'string') {
+			return String(value);
+		}
+
+		if (this.dataType === 'bigint') {
+			value = BigInt(value);
+		}
+		return value;
+	}
+}
+
+export type GenerateUniqueIntT = {
+	minValue?: number | bigint;
+	maxValue?: number | bigint;
+	isUnique?: boolean;
+};
+export class GenerateUniqueInt extends AbstractGenerator<GenerateUniqueIntT> {
+	static override readonly entityKind: string = 'GenerateUniqueInt';
+
+	public genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
+	public skipCheck?: boolean = false;
+	public state: {
+		rng: prand.RandomGenerator;
+		minValue: number | bigint;
+		maxValue: number | bigint;
+		intervals: (number | bigint)[][];
+		integersCount: Map<number | bigint, number>;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override timeSpent = 0;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniqueIntT) {
+		super(params);
+
+		let minValue = this.params.minValue, maxValue = this.params.maxValue;
+
+		if (maxValue === undefined) {
+			this.maxUniqueCount = Number.POSITIVE_INFINITY;
+			return;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		}
+
+		if (typeof minValue === 'number' && typeof maxValue === 'number') {
+			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+			this.maxUniqueCount = Number(maxValue! - minValue!) + 1;
+		} else if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
+			this.maxUniqueCount = Number((maxValue as bigint) - (minValue as bigint)) + 1;
+		} else this.maxUniqueCount = Number(Number(maxValue) - Number(minValue)) + 1; // error should be triggered in init method
+	}
+
+	override getMaxUniqueCount<T extends number | bigint>(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		let minValue = this.params.minValue as T, maxValue = this.params.maxValue as T;
+
+		if (maxValue === undefined) {
+			this.maxUniqueCount = Number.POSITIVE_INFINITY;
+			return this.maxUniqueCount;
+		}
+
+		if (minValue === undefined) {
+			minValue = -maxValue as T;
+		}
+
+		if (typeof minValue === 'number' && typeof maxValue === 'number') {
+			minValue = minValue >= 0 ? Math.ceil(minValue) as T : Math.floor(minValue) as T;
+			maxValue = maxValue >= 0 ? Math.floor(maxValue) as T : Math.ceil(maxValue) as T;
+		}
+
+		this.maxUniqueCount = Number(maxValue - minValue) + 1;
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const rng = prand.xoroshiro128plus(seed);
+		let { minValue, maxValue } = this.params;
+
+		if (maxValue === undefined) {
+			maxValue = count * 10;
+		}
+		if (minValue === undefined) {
+			minValue = -maxValue;
+		}
+
+		const intervals = [[minValue, maxValue]];
+
+		const integersCount = new Map();
+
+		if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
+			if (this.skipCheck === false && maxValue - minValue + BigInt(1) < count) {
+				throw new Error(
+					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
+				);
+			}
+		} else if (typeof minValue === 'number' && typeof maxValue === 'number') {
+			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+			if (this.skipCheck === false && maxValue - minValue + 1 < count) {
+				throw new Error(
+					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
+				);
+			}
+		} else {
+			throw new Error(
+				'minValue and maxValue should be the same type.',
+			);
+		}
+
+		this.state = { rng, minValue, maxValue, intervals, integersCount };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let intervalIdx: number,
+			numb: number | bigint | undefined;
+
+		const intervalsToAdd: (number | bigint)[][] = [];
+
+		if (this.state.intervals.length === 0) {
+			if (this.skipCheck === false) {
+				throw new RangeError(
+					'generateUniqueInt: count exceeds max number of unique integers in given range(min, max), try to increase range.',
+				);
+			} else {
+				return;
+			}
+		}
+
+		[intervalIdx, this.state.rng] = prand.uniformIntDistribution(
+			0,
+			this.state.intervals.length - 1,
+			this.state.rng,
+		);
+
+		const interval = this.state.intervals[intervalIdx] as (number | bigint)[];
+		const [currMinNumb, currMaxNumb] = [interval[0] as number | bigint, interval[1] as number | bigint];
+
+		if (typeof currMinNumb === 'number' && typeof currMaxNumb === 'number') {
+			numb = this.generateNumber(currMinNumb, currMaxNumb, intervalsToAdd as number[][], intervalIdx);
+		} else if (typeof currMinNumb === 'bigint' && typeof currMaxNumb === 'bigint') {
+			numb = this.generateBigint(
+				currMinNumb as bigint,
+				currMaxNumb as bigint,
+				intervalsToAdd as bigint[][],
+				intervalIdx,
+			);
+		}
+
+		if (this.dataType === 'string') {
+			return String(numb);
+		}
+
+		if (this.dataType === 'bigint' && numb !== undefined) {
+			numb = BigInt(numb);
+		}
+		return numb;
+	}
+
+	generateNumber(currMinNumb: number, currMaxNumb: number, intervalsToAdd: number[][], intervalIdx: number) {
+		let numb: number;
+
+		[numb, this.state!.rng] = prand.uniformIntDistribution(currMinNumb, currMaxNumb, this.state!.rng);
+
+		if (this.genMaxRepeatedValuesCount !== undefined) {
+			if (this.state!.integersCount.get(numb) === undefined) {
+				this.state!.integersCount.set(numb, this.genMaxRepeatedValuesCount.generate() as number);
+			}
+			this.state!.integersCount.set(numb, this.state!.integersCount.get(numb)! - 1);
+		}
+
+		if (this.state!.integersCount.get(numb) === undefined || this.state!.integersCount.get(numb) === 0) {
+			if (numb === currMinNumb) {
+				intervalsToAdd = numb + 1 <= currMaxNumb ? [[numb + 1, currMaxNumb]] : [];
+			} else if (numb === currMaxNumb) {
+				intervalsToAdd = [[currMinNumb, numb - 1]];
+			} else {
+				intervalsToAdd = [
+					[currMinNumb, numb - 1],
+					[numb + 1, currMaxNumb],
+				];
+			}
+
+			const t0 = new Date();
+			this.state!.intervals[intervalIdx] = this.state!.intervals[this.state!.intervals.length - 1]!;
+			this.state?.intervals.pop();
+			this.timeSpent += (Date.now() - t0.getTime()) / 1000;
+			this.state!.intervals.push(...intervalsToAdd);
+		}
+
+		return numb;
+	}
+
+	generateBigint(currMinNumb: bigint, currMaxNumb: bigint, intervalsToAdd: bigint[][], intervalIdx: number) {
+		let numb: bigint;
+		[numb, this.state!.rng] = prand.uniformBigIntDistribution(currMinNumb, currMaxNumb, this.state!.rng);
+		if (this.genMaxRepeatedValuesCount !== undefined) {
+			if (this.state!.integersCount.get(numb) === undefined) {
+				this.state!.integersCount.set(numb, this.genMaxRepeatedValuesCount.generate() as number);
+			}
+			this.state!.integersCount.set(numb, this.state!.integersCount.get(numb)! - 1);
+		}
+
+		if (this.state!.integersCount.get(numb) === undefined || this.state!.integersCount.get(numb) === 0) {
+			if (numb === currMinNumb) {
+				intervalsToAdd = numb + BigInt(1) <= currMaxNumb ? [[numb + BigInt(1), currMaxNumb]] : [];
+			} else if (numb === currMaxNumb) {
+				intervalsToAdd = [[currMinNumb, numb - BigInt(1)]];
+			} else {
+				intervalsToAdd = [
+					[currMinNumb, numb - BigInt(1)],
+					[numb + BigInt(1), currMaxNumb],
+				];
+			}
+
+			this.state!.intervals[intervalIdx] = this.state!.intervals[this.state!.intervals.length - 1]!;
+			this.state?.intervals.pop();
+			this.state!.intervals.push(...intervalsToAdd);
+		}
+
+		return numb;
+	}
+}
+
+export class GenerateBoolean extends AbstractGenerator<{ arraySize?: number }> {
+	static override readonly entityKind: string = 'GenerateBoolean';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let value: number;
+
+		[value, this.state.rng] = prand.uniformIntDistribution(0, 1, this.state.rng);
+		return value === 1;
+	}
+}
+
+export class GenerateDate extends AbstractGenerator<{
+	minDate?: string | Date;
+	maxDate?: string | Date;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateDate';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minDate: Date;
+		maxDate: Date;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+		const rng = prand.xoroshiro128plus(seed);
+
+		let { minDate, maxDate } = this.params;
+
+		const anchorDate = new Date('2024-05-08');
+		// 4 years in milliseconds
+		const deltaMilliseconds = 4 * 31536000000;
+
+		if (typeof minDate === 'string') {
+			minDate = new Date(minDate);
+		}
+
+		if (typeof minDate === 'object' && !isValidDate(minDate)) {
+			throw new Error('Invalid Date was provided for the minDate parameter.');
+		}
+
+		if (typeof maxDate === 'string') {
+			maxDate = new Date(maxDate);
+		}
+
+		if (typeof maxDate === 'object' && !isValidDate(maxDate)) {
+			throw new Error('Invalid Date was provided for the maxDate parameter.');
+		}
+
+		if (minDate === undefined) {
+			if (maxDate === undefined) {
+				minDate = new Date(anchorDate.getTime() - deltaMilliseconds);
+				maxDate = new Date(anchorDate.getTime() + deltaMilliseconds);
+			} else {
+				minDate = new Date(maxDate.getTime() - (2 * deltaMilliseconds));
+			}
+		}
+
+		if (maxDate === undefined) {
+			maxDate = new Date(minDate.getTime() + (2 * deltaMilliseconds));
+		}
+
+		if (minDate > maxDate) {
+			throw new Error(`The minDate parameter must be less than or equal to the maxDate parameter.`);
+		}
+
+		this.state = { rng, minDate, maxDate };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let milliseconds: number;
+
+		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
+			this.state.minDate.getTime(),
+			this.state.maxDate.getTime(),
+			this.state.rng,
+		);
+		const date = new Date(milliseconds);
+
+		if (this.dataType === 'string') {
+			return date.toISOString().replace(/T.+/, '');
+		}
+		return date;
+	}
+}
+export class GenerateTime extends AbstractGenerator<{
+	min?: string | Date;
+	max?: string | Date;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateTime';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		min: Date;
+		max: Date;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+		const rng = prand.xoroshiro128plus(seed);
+
+		let { min, max } = this.params;
+
+		if (min === undefined && max === undefined) {
+			// TODO: maybe need to change in major version release
+			// This is required to ensure that this generator remains deterministic when used without min, max parameters.
+			const oneDayInMilliseconds = 86400000;
+			min = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() - oneDayInMilliseconds);
+			max = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() + oneDayInMilliseconds);
+
+			this.state = { rng, min, max };
+			return;
+		}
+
+		if (min === undefined) {
+			if (max === undefined) {
+				min = '00:00:00.000Z';
+				max = '23:59:59.999Z';
+			} else {
+				min = '00:00:00.000Z';
+			}
+		}
+
+		if (max === undefined) {
+			max = '23:59:59.999Z';
+			new Date().toISOString();
+		}
+		const anchorDate = new Date('2024-05-08');
+		const anchorDateString0 = anchorDate.toISOString().replace(/T\d{2}:\d{2}:\d{2}.\d{3}Z/, '');
+
+		if (typeof min === 'string') {
+			// const timeMatch0 = min.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
+			const timeMatch1 = min.match(/^\d{2}:\d{2}:\d{2}Z?$/);
+			const timeMatch2 = min.match(/^\d{2}:\d{2}Z?$/);
+
+			if (
+				// timeMatch0 === null
+				timeMatch1 === null
+				&& timeMatch2 === null
+			) {
+				throw new Error(
+					`You're using the wrong format for the min parameter.`
+						+ `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z')`,
+				);
+			}
+
+			min = min.at(-1) === 'Z' ? min : min + 'Z';
+			min = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, min));
+		}
+
+		if (typeof min === 'object') {
+			if (!isValidDate(min)) {
+				throw new Error('Invalid Date was provided for the min parameter.');
+			}
+			min = new Date(min.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
+		}
+
+		if (typeof max === 'string') {
+			// const timeMatch0 = max.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
+			const timeMatch1 = max.match(/^\d{2}:\d{2}:\d{2}Z?$/);
+			const timeMatch2 = max.match(/^\d{2}:\d{2}Z?$/);
+			if (
+				// timeMatch0 === null
+				timeMatch1 === null
+				&& timeMatch2 === null
+			) {
+				throw new Error(
+					`You're using the wrong format for the max parameter.`
+						+ `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z').`,
+				);
+			}
+
+			max = max.at(-1) === 'Z' ? max : max + 'Z';
+			max = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, max));
+		}
+
+		if (typeof max === 'object') {
+			if (!isValidDate(max)) {
+				throw new Error('Invalid Date was provided for the max parameter.');
+			}
+			max = new Date(max.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
+		}
+
+		if (min > max) {
+			throw new Error(`The min parameter must be less than or equal to the max parameter.`);
+		}
+
+		this.state = { rng, min, max };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let milliseconds: number;
+
+		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
+			this.state.min.getTime(),
+			this.state.max.getTime(),
+			this.state.rng,
+		);
+		const date = new Date(milliseconds);
+
+		return date.toISOString().replace(/(\d{4}-\d{2}-\d{2}T)|(\.\d{3}Z)/g, '');
+	}
+}
+export class GenerateTimestampInt extends AbstractGenerator<{ unitOfTime?: 'seconds' | 'milliseconds' }> {
+	static override readonly entityKind: string = 'GenerateTimestampInt';
+
+	private state: {
+		generateTimestampObj: GenerateTimestamp;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const generateTimestampObj = new GenerateTimestamp({});
+		generateTimestampObj.dataType = 'date';
+		generateTimestampObj.init({ count, seed });
+
+		this.state = { generateTimestampObj };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const date = this.state.generateTimestampObj.generate() as Date;
+
+		if (this.params.unitOfTime === 'seconds') {
+			return Math.floor(date.getTime() / 1000);
+		} else if (this.params.unitOfTime === 'milliseconds') {
+			return date.getTime();
+		} else {
+			// this.params.unitOfTime === undefined
+			return Math.floor(date.getTime() / 1000);
+		}
+	}
+}
+
+export class GenerateTimestamp extends AbstractGenerator<{
+	min?: string | Date;
+	max?: string | Date;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateTimestamp';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		min: Date;
+		max: Date;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		let { min, max } = this.params;
+
+		const anchorDate = new Date('2024-05-08');
+		// 2 years in milliseconds
+		const deltaMilliseconds = 2 * 31536000000;
+
+		// ideally use util function that checks for date, etc.
+		if (typeof min === 'string') {
+			min = new Date(min);
+		}
+
+		if (typeof min === 'object' && !isValidDate(min)) {
+			throw new Error('Invalid Date was provided for the "min" parameter.');
+		}
+
+		if (typeof max === 'string') {
+			max = new Date(max);
+		}
+
+		if (typeof max === 'object' && !isValidDate(max)) {
+			throw new Error('Invalid Date was provided for the "max" parameter.');
+		}
+
+		if (min === undefined) {
+			if (max === undefined) {
+				min = new Date(anchorDate.getTime() - deltaMilliseconds);
+				max = new Date(anchorDate.getTime() + deltaMilliseconds);
+			} else {
+				min = new Date(max.getTime() - (2 * deltaMilliseconds));
+			}
+		}
+
+		if (max === undefined) {
+			max = new Date(min.getTime() + (2 * deltaMilliseconds));
+		}
+
+		if (min > max) {
+			throw new Error(`The "min" parameter must be less than or equal to the "max" parameter.`);
+		}
+
+		this.state = { rng, min, max };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		let milliseconds: number;
+
+		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
+			this.state.min.getTime(),
+			this.state.max.getTime(),
+			this.state.rng,
+		);
+		const date = new Date(milliseconds);
+
+		if (this.dataType === 'string') {
+			return date
+				.toISOString()
+				.replace('T', ' ')
+				.replace(/\.\d{3}Z/, '');
+		}
+
+		return date;
+	}
+}
+
+export class GenerateDatetime extends AbstractGenerator<{
+	min?: string | Date;
+	max?: string | Date;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateDatetime';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		min: Date;
+		max: Date;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		let { min, max } = this.params;
+
+		const anchorDate = new Date('2024-05-08');
+		// 2 years in milliseconds
+		const deltaMilliseconds = 2 * 31536000000;
+
+		// same here. a lot of code duplicates
+		if (typeof min === 'string') {
+			min = new Date(min);
+		}
+
+		if (typeof min === 'object' && !isValidDate(min)) {
+			throw new Error('Invalid Date was provided for the min parameter.');
+		}
+
+		if (typeof max === 'string') {
+			max = new Date(max);
+		}
+
+		if (typeof max === 'object' && !isValidDate(max)) {
+			throw new Error('Invalid Date was provided for the max parameter.');
+		}
+
+		if (min === undefined) {
+			if (max === undefined) {
+				min = new Date(anchorDate.getTime() - deltaMilliseconds);
+				max = new Date(anchorDate.getTime() + deltaMilliseconds);
+			} else {
+				min = new Date(max.getTime() - (2 * deltaMilliseconds));
+			}
+		}
+
+		if (max === undefined) {
+			max = new Date(min.getTime() + (2 * deltaMilliseconds));
+		}
+
+		if (min > max) {
+			throw new Error(`The min parameter must be less than or equal to the max parameter.`);
+		}
+
+		this.state = { rng, min, max };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let milliseconds: number;
+
+		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
+			this.state.min.getTime(),
+			this.state.max.getTime(),
+			this.state.rng,
+		);
+		const date = new Date(milliseconds);
+
+		if (this.dataType === 'string') {
+			return date
+				.toISOString()
+				.replace('T', ' ')
+				.replace(/\.\d{3}Z/, '');
+		}
+
+		return date;
+	}
+}
+
+export class GenerateYear extends AbstractGenerator<{ arraySize?: number }> {
+	static override readonly entityKind: string = 'GenerateYear';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const anchorDate = new Date('2024-05-08');
+		const tenYears = 10;
+
+		let date = new Date();
+		let years: number;
+
+		[years, this.state.rng] = prand.uniformIntDistribution(-tenYears, tenYears, this.state.rng);
+		date = new Date(date.setFullYear(anchorDate.getFullYear() + years));
+
+		return date
+			.toISOString()
+			.replace(/(-\d{2}-\d{2}T)|(\d{2}:\d{2}:\d{2}\.\d{3}Z)/g, '');
+	}
+}
+
+export class GenerateJson extends AbstractGenerator<{ arraySize?: number }> {
+	static override readonly entityKind: string = 'GenerateJson';
+
+	private state: {
+		emailGeneratorObj: GenerateEmail;
+		nameGeneratorObj: GenerateFirstName;
+		booleanGeneratorObj: GenerateBoolean;
+		salaryGeneratorObj: GenerateInt;
+		dateGeneratorObj: GenerateDate;
+		visitedCountriesNumberGeneratorObj: GenerateInt;
+		seed: number;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const emailGeneratorObj = new GenerateEmail({});
+		emailGeneratorObj.init({ count, seed });
+
+		const nameGeneratorObj = new GenerateFirstName({});
+		nameGeneratorObj.init({ count, seed });
+
+		const booleanGeneratorObj = new GenerateBoolean({});
+		booleanGeneratorObj.init({
+			count,
+			seed,
+		});
+
+		const salaryGeneratorObj = new GenerateInt({ minValue: 200, maxValue: 4000 });
+		salaryGeneratorObj.init({
+			count,
+			seed,
+			...salaryGeneratorObj.params,
+		});
+
+		const dateGeneratorObj = new GenerateDate({});
+		dateGeneratorObj.dataType = 'string';
+		dateGeneratorObj.init({ count, seed });
+
+		const visitedCountriesNumberGeneratorObj = new GenerateInt({ minValue: 0, maxValue: 4 });
+		visitedCountriesNumberGeneratorObj.init(
+			{ count, seed, ...visitedCountriesNumberGeneratorObj.params },
+		);
+
+		this.state = {
+			emailGeneratorObj,
+			nameGeneratorObj,
+			booleanGeneratorObj,
+			salaryGeneratorObj,
+			dateGeneratorObj,
+			visitedCountriesNumberGeneratorObj,
+			seed,
+		};
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const visitedCountries: string[] = [];
+		const email = this.state.emailGeneratorObj.generate();
+		const name = this.state.nameGeneratorObj.generate();
+		const isGraduated = this.state.booleanGeneratorObj.generate();
+		const hasJob = this.state.booleanGeneratorObj.generate();
+		const salary = this.state.salaryGeneratorObj.generate() as number;
+		const startedWorking = this.state.dateGeneratorObj.generate() as string;
+		const visitedCountriesNumber = this.state.visitedCountriesNumberGeneratorObj.generate() as number;
+
+		const uniqueCountriesGeneratorObj = new GenerateUniqueCountry({});
+		uniqueCountriesGeneratorObj.init({
+			count: visitedCountriesNumber,
+			seed: this.state.seed + i,
+		});
+		for (let j = 0; j < visitedCountriesNumber; j++) {
+			visitedCountries.push(uniqueCountriesGeneratorObj.generate());
+		}
+
+		const returnJson = hasJob
+			? {
+				email,
+				name,
+				isGraduated,
+				hasJob,
+				salary,
+				startedWorking,
+				visitedCountries,
+			}
+			: {
+				email,
+				name,
+				isGraduated,
+				hasJob,
+				visitedCountries,
+			};
+
+		if (this.dataType === 'string') {
+			return JSON.stringify(returnJson);
+		}
+
+		return returnJson;
+	}
+}
+
+export class GenerateEnum extends AbstractGenerator<{ enumValues: (string | number | boolean)[] }> {
+	static override readonly entityKind: string = 'GenerateEnum';
+
+	private state: {
+		enumValuesGenerator: GenerateValuesFromArray;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const { enumValues } = this.params;
+		const enumValuesGenerator = new GenerateValuesFromArray({ values: enumValues });
+		enumValuesGenerator.init({ count, seed });
+		this.state = { enumValuesGenerator };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		// logic for this generator
+		return this.state.enumValuesGenerator.generate();
+	}
+}
+
+export class GenerateInterval extends AbstractGenerator<{
+	fields?:
+		| 'year'
+		| 'month'
+		| 'day'
+		| 'hour'
+		| 'minute'
+		| 'second'
+		| 'year to month'
+		| 'day to hour'
+		| 'day to minute'
+		| 'day to second'
+		| 'hour to minute'
+		| 'hour to second'
+		| 'minute to second';
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateInterval';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		fieldsToGenerate: string[];
+	} | undefined;
+	override uniqueVersionOfGen: new(params: any) => AbstractGenerator<any> = GenerateUniqueInterval;
+	private config: { [key: string]: { from: number; to: number } } = {
+		year: {
+			from: 0,
+			to: 5,
+		},
+		month: {
+			from: 0,
+			to: 12,
+		},
+		day: {
+			from: 1,
+			to: 29,
+		},
+		hour: {
+			from: 0,
+			to: 24,
+		},
+		minute: {
+			from: 0,
+			to: 60,
+		},
+		second: {
+			from: 0,
+			to: 60,
+		},
+	};
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+		let fieldsToGenerate: string[] = allFields;
+
+		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+			const tokens = this.params.fields.split(' to ');
+			const endIdx = allFields.indexOf(tokens[1]!);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		} else if (this.params.fields !== undefined) {
+			const endIdx = allFields.indexOf(this.params.fields);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng, fieldsToGenerate };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let interval = '', numb: number;
+
+		for (const field of this.state.fieldsToGenerate) {
+			const from = this.config[field]!.from, to = this.config[field]!.to;
+			[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
+			interval += `${numb} ${field} `;
+		}
+
+		return interval;
+	}
+}
+
+// has a newer version
+export type GenerateUniqueIntervalT = {
+	fields?:
+		| 'year'
+		| 'month'
+		| 'day'
+		| 'hour'
+		| 'minute'
+		| 'second'
+		| 'year to month'
+		| 'day to hour'
+		| 'day to minute'
+		| 'day to second'
+		| 'hour to minute'
+		| 'hour to second'
+		| 'minute to second';
+	isUnique?: boolean;
+};
+export class GenerateUniqueInterval extends AbstractGenerator<GenerateUniqueIntervalT> {
+	static override readonly 'entityKind': string = 'GenerateUniqueInterval';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		fieldsToGenerate: string[];
+		intervalSet: Set<string>;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	private config: { [key: string]: { from: number; to: number } } = {
+		year: {
+			from: 0,
+			to: 5,
+		},
+		month: {
+			from: 0,
+			to: 12,
+		},
+		day: {
+			from: 1,
+			to: 29,
+		},
+		hour: {
+			from: 0,
+			to: 24,
+		},
+		minute: {
+			from: 0,
+			to: 60,
+		},
+		second: {
+			from: 0,
+			to: 60,
+		},
+	};
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniqueIntervalT) {
+		super(params);
+
+		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+		let fieldsToGenerate: string[] = allFields;
+
+		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+			const tokens = this.params.fields.split(' to ');
+			const endIdx = allFields.indexOf(tokens[1]!);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		} else if (this.params.fields !== undefined) {
+			const endIdx = allFields.indexOf(this.params.fields);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		}
+
+		this.maxUniqueCount = 1;
+		for (const field of fieldsToGenerate) {
+			const from = this.config[field]!.from, to = this.config[field]!.to;
+			this.maxUniqueCount *= from - to + 1;
+		}
+	}
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+		let fieldsToGenerate: string[] = allFields;
+
+		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+			const tokens = this.params.fields.split(' to ');
+			const endIdx = allFields.indexOf(tokens[1]!);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		} else if (this.params.fields !== undefined) {
+			const endIdx = allFields.indexOf(this.params.fields);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		}
+
+		this.maxUniqueCount = 1;
+		for (const field of fieldsToGenerate) {
+			const from = this.config[field]!.from, to = this.config[field]!.to;
+			this.maxUniqueCount *= from - to + 1;
+		}
+
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+		let fieldsToGenerate: string[] = allFields;
+
+		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+			const tokens = this.params.fields.split(' to ');
+			const endIdx = allFields.indexOf(tokens[1]!);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		} else if (this.params.fields !== undefined) {
+			const endIdx = allFields.indexOf(this.params.fields);
+			fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		}
+
+		let maxUniqueIntervalsNumber = 1;
+		for (const field of fieldsToGenerate) {
+			const from = this.config[field]!.from, to = this.config[field]!.to;
+			maxUniqueIntervalsNumber *= from - to + 1;
+		}
+
+		if (count > maxUniqueIntervalsNumber) {
+			throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		const intervalSet = new Set<string>();
+		this.state = { rng, fieldsToGenerate, intervalSet };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let interval, numb: number;
+
+		for (;;) {
+			interval = '';
+
+			for (const field of this.state.fieldsToGenerate) {
+				const from = this.config[field]!.from, to = this.config[field]!.to;
+				[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
+				interval += `${numb} ${field} `;
+			}
+
+			if (!this.state.intervalSet.has(interval)) {
+				this.state.intervalSet.add(interval);
+				break;
+			}
+		}
+
+		return interval;
+	}
+}
+
+// has a newer version
+export class GenerateString extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateString';
+
+	private state: { rng: prand.RandomGenerator } | undefined;
+	override uniqueVersionOfGen = GenerateUniqueString;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const minStringLength = 7;
+		const maxStringLength = 20;
+		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+		let idx: number,
+			strLength: number,
+			currStr: string;
+
+		currStr = '';
+		[strLength, this.state.rng] = prand.uniformIntDistribution(
+			minStringLength,
+			maxStringLength,
+			this.state.rng,
+		);
+		for (let j = 0; j < strLength; j++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+			currStr += stringChars[idx];
+		}
+
+		if (this.dataType === 'object') return Buffer.from(currStr);
+		return currStr;
+	}
+}
+
+// has a newer version
+export class GenerateUniqueString extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueString';
+
+	private state: { rng: prand.RandomGenerator } | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = Number.POSITIVE_INFINITY;
+
+	override getMaxUniqueCount(): number {
+		return Number.POSITIVE_INFINITY;
+	}
+
+	override init({ seed }: { seed: number }) {
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng };
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const minStringLength = 7;
+		const maxStringLength = 20;
+		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+		let idx: number,
+			strLength: number;
+		let currStr: string;
+
+		currStr = '';
+		const uniqueStr = i.toString(16);
+		[strLength, this.state.rng] = prand.uniformIntDistribution(
+			minStringLength,
+			maxStringLength - uniqueStr.length,
+			this.state.rng,
+		);
+		for (let j = 0; j < strLength - uniqueStr.length; j++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+			currStr += stringChars[idx];
+		}
+
+		currStr = currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
+
+		if (this.dataType === 'object') return Buffer.from(currStr);
+		return currStr;
+	}
+}
+
+export class GenerateUUID extends AbstractGenerator<{
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateUUID';
+
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = Number.POSITIVE_INFINITY;
+
+	private state: { rng: prand.RandomGenerator } | undefined;
+
+	override getMaxUniqueCount(): number {
+		return Number.POSITIVE_INFINITY;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		// TODO generate uuid using string generator
+		const stringChars = '1234567890abcdef';
+		let idx: number,
+			currStr: string;
+		const strLength = 36;
+
+		// uuid v4
+		const uuidTemplate = '########-####-4###-####-############';
+		currStr = '';
+		for (let i = 0; i < strLength; i++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+
+			if (uuidTemplate[i] === '#') {
+				currStr += stringChars[idx];
+				continue;
+			}
+			currStr += uuidTemplate[i];
+		}
+		return currStr;
+	}
+}
+
+export class GenerateFirstName extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateFirstName';
+
+	override timeSpent: number = 0;
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueFirstName;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxFirstNameLength) {
+			throw new Error(
+				`You can't use first name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxFirstNameLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		// logic for this generator
+		// names dataset contains about 30000 unique names.
+		let idx: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
+		return firstNames[idx] as string;
+	}
+}
+
+export class GenerateUniqueFirstName extends AbstractGenerator<{
+	isUnique?: boolean;
+}> {
+	static override readonly entityKind: string = 'GenerateUniqueFirstName';
+
+	private state: {
+		genIndicesObj: GenerateUniqueInt;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = firstNames.length;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		this.maxUniqueCount = firstNames.length;
+		return firstNames.length;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.getMaxUniqueCount()) {
+			throw new Error('count exceeds max number of unique first names.');
+		}
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxFirstNameLength) {
+			throw new Error(
+				`You can't use first name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxFirstNameLength}.`,
+			);
+		}
+
+		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: firstNames.length - 1 });
+		genIndicesObj.init({ count, seed });
+
+		this.state = { genIndicesObj };
+	}
+
+	generate() {
+		// names dataset contains about 30000 unique names.
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const nameIdx = this.state.genIndicesObj.generate() as number;
+		const name = firstNames[nameIdx] as string;
+
+		return name;
+	}
+}
+
+export class GenerateLastName extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateLastName';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueLastName;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxLastNameLength) {
+			throw new Error(
+				`You can't use last name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxLastNameLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
+		return lastNames[idx];
+	}
+}
+
+export class GenerateUniqueLastName extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueLastName';
+
+	private state: {
+		genIndicesObj: GenerateUniqueInt;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = lastNames.length;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		this.maxUniqueCount = lastNames.length;
+		return lastNames.length;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.getMaxUniqueCount()) {
+			throw new Error('count exceeds max number of unique last names.');
+		}
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxLastNameLength) {
+			throw new Error(
+				`You can't use last name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxLastNameLength}.`,
+			);
+		}
+
+		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: lastNames.length - 1 });
+		genIndicesObj.init({ count, seed });
+
+		this.state = { genIndicesObj };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const surnameIdx = this.state.genIndicesObj.generate() as number;
+		const surname = lastNames[surnameIdx] as string;
+
+		return surname;
+	}
+}
+
+export class GenerateFullName extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateFullName';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueFullName;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (
+			this.typeParams?.length !== undefined && this.typeParams?.length < (maxFirstNameLength + maxLastNameLength + 1)
+		) {
+			throw new Error(
+				`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${
+					maxFirstNameLength + maxLastNameLength + 1
+				}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
+		const name = firstNames[idx] as string;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
+		const surname = lastNames[idx] as string;
+
+		const fullName = `${name} ${surname}`;
+
+		return fullName;
+	}
+}
+
+export class GenerateUniqueFullName extends AbstractGenerator<{
+	isUnique?: boolean;
+}> {
+	static override readonly entityKind: string = 'GenerateUniqueFullName';
+
+	private state: {
+		fullnameSet: Set<string>;
+		rng: prand.RandomGenerator;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override timeSpent = 0;
+	public override maxUniqueCount: number = firstNames.length * lastNames.length;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		this.maxUniqueCount = firstNames.length * lastNames.length;
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const t0 = new Date();
+
+		if (count > this.getMaxUniqueCount()) {
+			throw new RangeError(
+				`count exceeds max number of unique full names(${this.getMaxUniqueCount()}).`,
+			);
+		}
+
+		if (
+			this.typeParams?.length !== undefined && this.typeParams?.length < (maxFirstNameLength + maxLastNameLength + 1)
+		) {
+			throw new Error(
+				`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${
+					maxFirstNameLength + maxLastNameLength + 1
+				}.`,
+			);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		const fullnameSet = new Set<string>();
+
+		this.state = { rng, fullnameSet };
+		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let fullname: string, name: string, surname: string, idx: number;
+
+		const t0 = new Date();
+		for (;;) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
+			name = firstNames[idx] as string;
+
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
+			surname = lastNames[idx] as string;
+
+			fullname = `${name} ${surname}`;
+
+			if (!this.state.fullnameSet.has(fullname)) {
+				this.state.fullnameSet.add(fullname);
+				break;
+			}
+		}
+
+		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
+		return fullname;
+	}
+}
+
+export class GenerateEmail extends AbstractGenerator<{
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateEmail';
+
+	private state: {
+		genIndicesObj: GenerateUniqueInt;
+		arraysToGenerateFrom: string[][];
+	} | undefined;
+	public override timeSpent: number = 0;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = adjectives.length * firstNames.length * emailDomains.length;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		this.maxUniqueCount = adjectives.length * firstNames.length * emailDomains.length;
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const maxUniqueEmailsNumber = adjectives.length * firstNames.length * emailDomains.length;
+		if (count > maxUniqueEmailsNumber) {
+			throw new RangeError(
+				`count exceeds max number of unique emails(${maxUniqueEmailsNumber}).`,
+			);
+		}
+
+		const maxEmailLength = maxAdjectiveLength + maxFirstNameLength + maxEmailDomainLength + 2;
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxEmailLength) {
+			throw new Error(
+				`You can't use email generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxEmailLength}.`,
+			);
+		}
+
+		const arraysToGenerateFrom = [adjectives, firstNames, emailDomains];
+		const genIndicesObj = new GenerateUniqueInt({
+			minValue: 0,
+			maxValue: maxUniqueEmailsNumber - 1,
+		});
+		genIndicesObj.init({ count, seed });
+
+		this.state = { genIndicesObj, arraysToGenerateFrom };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const t0 = new Date();
+		const emailIndex = this.state.genIndicesObj.generate() as number;
+		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
+		const tokens = fastCartesianProduct(
+			this.state.arraysToGenerateFrom,
+			emailIndex,
+		) as string[];
+
+		const [adjective, name, domain] = [tokens[0] as string, tokens[1] as string, tokens[2] as string];
+
+		const email = `${adjective}_${name.toLowerCase()}@${domain}`;
+
+		return email;
+	}
+}
+
+export type GeneratePhoneNumberT = {
+	template?: string;
+	prefixes?: string[];
+	generatedDigitsNumbers?: number | number[];
+	arraySize?: number;
+};
+export class GeneratePhoneNumber extends AbstractGenerator<GeneratePhoneNumberT> {
+	static override readonly entityKind: string = 'GeneratePhoneNumber';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		placeholdersCount?: number;
+		prefixesArray: string[];
+		generatedDigitsNumbers: number[];
+		generatorsMap: Map<string, GenerateUniqueInt>;
+		phoneNumbersSet: Set<string>;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GeneratePhoneNumberT) {
+		super(params);
+
+		const { template } = this.params;
+		if (template === undefined) {
+			const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+			this.maxUniqueCount = generatedDigitsNumbers.reduce(
+				(a, b) => a + Math.pow(10, b),
+				0,
+			);
+		} else {
+			const { placeholdersCount } = this.prepareWithTemplate();
+
+			this.maxUniqueCount = Math.pow(10, placeholdersCount);
+		}
+	}
+
+	prepareWithTemplate(): { placeholdersCount: number } {
+		const { template } = this.params;
+
+		const iterArray = [...template!.matchAll(/#/g)];
+		const placeholdersCount = iterArray.length;
+		return { placeholdersCount };
+	}
+
+	prepareWithoutTemplate(): { generatedDigitsNumbers: number[]; prefixes: string[] } {
+		let { generatedDigitsNumbers, prefixes } = this.params;
+		if (prefixes === undefined || prefixes.length === 0) {
+			prefixes = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
+			generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
+				// tokens = ["380","99","9"] =
+				// = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
+				const tokens = phoneInfo.split(',');
+				const operatorPrefixLength = tokens[1]!.replaceAll(' ', '').length;
+
+				return Number(tokens[2]) - operatorPrefixLength;
+			});
+		} else {
+			if (typeof generatedDigitsNumbers === 'number') {
+				generatedDigitsNumbers = Array.from<number>({ length: prefixes.length }).fill(
+					generatedDigitsNumbers,
+				);
+			} else if (
+				generatedDigitsNumbers === undefined
+				|| generatedDigitsNumbers.length === 0
+			) {
+				generatedDigitsNumbers = Array.from<number>({ length: prefixes.length }).fill(7);
+			}
+		}
+
+		return { prefixes, generatedDigitsNumbers };
+	}
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		const { template } = this.params;
+		if (template === undefined) {
+			const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+			this.maxUniqueCount = generatedDigitsNumbers.reduce(
+				(a, b) => a + Math.pow(10, b),
+				0,
+			);
+
+			return this.maxUniqueCount;
+		} else {
+			const { placeholdersCount } = this.prepareWithTemplate();
+
+			this.maxUniqueCount = Math.pow(10, placeholdersCount);
+			return this.maxUniqueCount;
+		}
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const { template } = this.params;
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (template !== undefined) {
+			if (this.typeParams?.length !== undefined && this.typeParams?.length < template.length) {
+				throw new Error(
+					`Length of phone number template is shorter than db column length restriction: ${this.typeParams?.length}. 
+					Set the maximum string length to at least ${template.length}.`,
+				);
+			}
+
+			const { placeholdersCount } = this.prepareWithTemplate();
+
+			const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
+			if (maxUniquePhoneNumbersCount < count) {
+				throw new RangeError(
+					`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`,
+				);
+			}
+
+			const generatorsMap = new Map<string, GenerateUniqueInt>();
+			const genObj = new GenerateUniqueInt({ minValue: 0, maxValue: maxUniquePhoneNumbersCount - 1 });
+			genObj.init({
+				count,
+				seed,
+			});
+
+			generatorsMap.set(
+				template,
+				genObj,
+			);
+
+			const prefixesArray: string[] = [];
+			const generatedDigitsNumbers: number[] = [];
+			const phoneNumbersSet = new Set<string>();
+
+			this.state = { rng, placeholdersCount, generatorsMap, prefixesArray, generatedDigitsNumbers, phoneNumbersSet };
+			return;
+		}
+
+		const { generatedDigitsNumbers, prefixes } = this.prepareWithoutTemplate();
+		const prefixesArray = [...prefixes];
+
+		const maxPrefixLength = Math.max(...prefixesArray.map((prefix) => prefix.length));
+		const maxGeneratedDigits = Math.max(...generatedDigitsNumbers);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxPrefixLength + maxGeneratedDigits)) {
+			throw new Error(
+				`You can't use phone number generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${
+					maxPrefixLength + maxGeneratedDigits
+				}.`,
+			);
+		}
+
+		if (new Set(prefixesArray).size !== prefixesArray.length) {
+			throw new Error('prefixes are not unique.');
+		}
+
+		const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
+		if (maxUniquePhoneNumbersCount < count) {
+			throw new RangeError(
+				`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`,
+			);
+		}
+
+		const generatorsMap = new Map<string, GenerateUniqueInt>();
+		let maxValue: number, prefix: string, generatedDigitsNumber: number;
+		for (const [i, element] of prefixesArray.entries()) {
+			prefix = element as string;
+			generatedDigitsNumber = generatedDigitsNumbers[i] as number;
+			maxValue = Math.pow(10, generatedDigitsNumber) - 1;
+
+			if (!generatorsMap.has(prefix)) {
+				const genObj = new GenerateUniqueInt({ minValue: 0, maxValue });
+				genObj.init({
+					count: Math.min(count, maxValue + 1),
+					seed,
+				});
+				genObj.skipCheck = true;
+				generatorsMap.set(
+					prefix,
+					genObj,
+				);
+			}
+		}
+		const phoneNumbersSet = new Set<string>();
+
+		this.state = { rng, prefixesArray, generatedDigitsNumbers, generatorsMap, phoneNumbersSet };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let prefix: string, generatedDigitsNumber: number, numberBody: string, phoneNumber: string, idx: number;
+
+		if (this.params.template === undefined) {
+			for (;;) {
+				[idx, this.state.rng] = prand.uniformIntDistribution(
+					0,
+					this.state.prefixesArray.length - 1,
+					this.state.rng,
+				);
+				prefix = this.state.prefixesArray[idx] as string;
+				generatedDigitsNumber = this.state.generatedDigitsNumbers[idx] as number;
+
+				numberBody = String(this.state.generatorsMap.get(prefix)?.generate());
+				if (numberBody === 'undefined') {
+					this.state.prefixesArray!.splice(idx, 1);
+					this.state.generatedDigitsNumbers.splice(idx, 1);
+
+					this.state.generatorsMap.delete(prefix);
+
+					continue;
+				}
+
+				if (this.state.phoneNumbersSet.has(numberBody)) {
+					continue;
+				}
+				this.state.phoneNumbersSet.add(numberBody);
+
+				break;
+			}
+
+			const digitsNumberDiff = generatedDigitsNumber - numberBody.length;
+			if (digitsNumberDiff > 0) {
+				numberBody = '0'.repeat(digitsNumberDiff) + numberBody;
+			}
+
+			phoneNumber = prefix + '' + numberBody;
+
+			return phoneNumber;
+		} else {
+			numberBody = String(this.state.generatorsMap.get(this.params.template)?.generate());
+			phoneNumber = fillTemplate({
+				template: this.params.template,
+				values: [...numberBody],
+				defaultValue: '0',
+				placeholdersCount: this.state.placeholdersCount,
+			});
+
+			return phoneNumber;
+		}
+	}
+}
+
+export class GenerateCountry extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateCountry';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueCountry;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCountryLength) {
+			throw new Error(
+				`You can't use country generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCountryLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, countries.length - 1, this.state.rng);
+		const country = countries[idx] as string;
+
+		return country;
+	}
+}
+
+export class GenerateUniqueCountry extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueCountry';
+
+	private state: {
+		genIndicesObj: GenerateUniqueInt;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = countries.length;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount !== undefined) return this.maxUniqueCount;
+
+		this.maxUniqueCount = countries.length;
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.getMaxUniqueCount()) {
+			throw new Error('count exceeds max number of unique countries.');
+		}
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCountryLength) {
+			throw new Error(
+				`You can't use country generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCountryLength}.`,
+			);
+		}
+
+		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: countries.length - 1 });
+		genIndicesObj.init({ count, seed });
+
+		this.state = { genIndicesObj };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const countryIdx = this.state.genIndicesObj.generate() as number;
+		const country = countries[countryIdx] as string;
+
+		return country;
+	}
+}
+
+export class GenerateJobTitle extends AbstractGenerator<{
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateJobTitle';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxJobTitleLength) {
+			throw new Error(
+				`You can't use job title generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxJobTitleLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		let idx;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, jobsTitles.length - 1, this.state.rng);
+
+		return jobsTitles[idx];
+	}
+}
+
+export class GenerateStreetAddress extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateStreetAddress';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		possStreetNames: string[][];
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueStreetAddress;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		const possStreetNames = [firstNames, lastNames];
+
+		const maxStreetAddressLength = 4 + Math.max(maxFirstNameLength, maxLastNameLength) + 1 + maxStreetSuffixLength;
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStreetAddressLength) {
+			throw new Error(
+				`You can't use street address generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStreetAddressLength}.`,
+			);
+		}
+
+		this.state = { rng, possStreetNames };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx, streetBaseNameIdx, streetSuffixIdx, streetNumber;
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.possStreetNames.length - 1, this.state.rng);
+
+		[streetBaseNameIdx, this.state.rng] = prand.uniformIntDistribution(
+			0,
+			this.state.possStreetNames[idx]!.length - 1,
+			this.state.rng,
+		);
+		[streetSuffixIdx, this.state.rng] = prand.uniformIntDistribution(0, streetSuffix.length - 1, this.state.rng);
+		const streetName = `${this.state.possStreetNames[idx]![streetBaseNameIdx]} ${streetSuffix[streetSuffixIdx]}`;
+
+		[streetNumber, this.state.rng] = prand.uniformIntDistribution(1, 999, this.state.rng);
+
+		return `${streetNumber} ${streetName}`;
+	}
+}
+
+export class GenerateUniqueStreetAddress extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueStreetAddress';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		possStreetNameObjs: {
+			indicesGen: GenerateUniqueInt;
+			maxUniqueStreetNamesNumber: number;
+			count: number;
+			arraysToChooseFrom: string[][];
+		}[];
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public streetNumbersCount = 999;
+	public override maxUniqueCount = this.streetNumbersCount * (firstNames.length + lastNames.length)
+		* streetSuffix.length;
+
+	override getMaxUniqueCount(): number {
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const streetNumberStrs = Array.from({ length: this.streetNumbersCount }, (_, i) => String(i + 1));
+		const maxUniqueStreetnamesNumber = streetNumberStrs.length * (firstNames.length + lastNames.length)
+			* streetSuffix.length;
+
+		if (count > maxUniqueStreetnamesNumber) {
+			throw new RangeError(
+				`count exceeds max number of unique street names(${maxUniqueStreetnamesNumber}).`,
+			);
+		}
+
+		const maxStreetAddressLength = 4 + Math.max(maxFirstNameLength, maxLastNameLength) + 1 + maxStreetSuffixLength;
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStreetAddressLength) {
+			throw new Error(
+				`You can't use street address generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStreetAddressLength}.`,
+			);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		// ["1", "2", ..., "999"]
+
+		const possStreetNameObjs = [
+			{
+				indicesGen: new GenerateUniqueInt({
+					minValue: 0,
+					maxValue: streetNumberStrs.length * firstNames.length * streetSuffix.length - 1,
+				}),
+				maxUniqueStreetNamesNumber: streetNumberStrs.length * firstNames.length * streetSuffix.length,
+				count: 0,
+				arraysToChooseFrom: [streetNumberStrs, firstNames, streetSuffix],
+			},
+			{
+				indicesGen: new GenerateUniqueInt({
+					minValue: 0,
+					maxValue: streetNumberStrs.length * lastNames.length * streetSuffix.length - 1,
+				}),
+				maxUniqueStreetNamesNumber: streetNumberStrs.length * lastNames.length * streetSuffix.length,
+				count: 0,
+				arraysToChooseFrom: [streetNumberStrs, lastNames, streetSuffix],
+			},
+		];
+
+		for (const possStreetNameObj of possStreetNameObjs) {
+			possStreetNameObj.indicesGen.skipCheck = true;
+			possStreetNameObj.indicesGen.init({ count, seed });
+		}
+
+		this.state = { rng, possStreetNameObjs };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let streetNameObjIdx;
+		[streetNameObjIdx, this.state.rng] = prand.uniformIntDistribution(
+			0,
+			this.state.possStreetNameObjs.length - 1,
+			this.state.rng,
+		);
+		const streetNameObj = this.state.possStreetNameObjs[streetNameObjIdx]!;
+
+		const idx = streetNameObj.indicesGen.generate() as number;
+		const values = fastCartesianProduct(streetNameObj.arraysToChooseFrom, idx) as string[];
+
+		streetNameObj.count += 1;
+		if (streetNameObj.count === streetNameObj.maxUniqueStreetNamesNumber) {
+			this.state.possStreetNameObjs[streetNameObjIdx] = this.state
+				.possStreetNameObjs.at(-1)!;
+			this.state.possStreetNameObjs.pop();
+		}
+
+		const streetName = fillTemplate({ template: '# # #', values, placeholdersCount: 3 });
+
+		return streetName;
+	}
+}
+
+export class GenerateCity extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateCity';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueCity;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCityNameLength) {
+			throw new Error(
+				`You can't use city generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCityNameLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx;
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, cityNames.length - 1, this.state.rng);
+
+		return cityNames[idx];
+	}
+}
+
+export class GenerateUniqueCity extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueCity';
+
+	private state: {
+		genIndicesObj: GenerateUniqueInt;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = cityNames.length;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.maxUniqueCount) {
+			throw new Error('count exceeds max number of unique cities.');
+		}
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCityNameLength) {
+			throw new Error(
+				`You can't use city generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCityNameLength}.`,
+			);
+		}
+
+		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: cityNames.length - 1 });
+		genIndicesObj.init({ count, seed });
+
+		this.state = { genIndicesObj };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const cityIdx = this.state.genIndicesObj.generate() as number;
+		const city = cityNames[cityIdx] as string;
+
+		return city;
+	}
+}
+
+export class GeneratePostcode extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GeneratePostcode';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		templates: string[];
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniquePostcode;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		const templates = ['#####', '#####-####'];
+
+		const maxPostcodeLength = Math.max(...templates.map((template) => template.length));
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxPostcodeLength) {
+			throw new Error(
+				`You can't use postcode generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxPostcodeLength}.`,
+			);
+		}
+
+		this.state = { rng, templates };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number, postcodeNumber: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
+		const template = this.state.templates[idx]!;
+
+		const iterArray = [...template.matchAll(/#/g)];
+		const placeholdersCount = iterArray.length;
+
+		[postcodeNumber, this.state.rng] = prand.uniformIntDistribution(
+			0,
+			Math.pow(10, placeholdersCount) - 1,
+			this.state.rng,
+		);
+		const postcode = fillTemplate({
+			template,
+			placeholdersCount,
+			values: [...String(postcodeNumber)],
+			defaultValue: '0',
+		});
+
+		return postcode;
+	}
+}
+
+export class GenerateUniquePostcode extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniquePostcode';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		templates: {
+			template: string;
+			indicesGen: GenerateUniqueInt;
+			placeholdersCount: number;
+			count: number;
+			maxUniquePostcodeNumber: number;
+		}[];
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = Math.pow(10, 5) + Math.pow(10, 9);
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.maxUniqueCount) {
+			throw new RangeError(
+				`count exceeds max number of unique postcodes(${this.maxUniqueCount}).`,
+			);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		const templates = [
+			{
+				template: '#####',
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(10, 5) - 1 }),
+				placeholdersCount: 5,
+				count: 0,
+				maxUniquePostcodeNumber: Math.pow(10, 5),
+			},
+			{
+				template: '#####-####',
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(10, 9) - 1 }),
+				placeholdersCount: 9,
+				count: 0,
+				maxUniquePostcodeNumber: Math.pow(10, 9),
+			},
+		];
+
+		const maxPostcodeLength = Math.max(...templates.map((template) => template.template.length));
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxPostcodeLength) {
+			throw new Error(
+				`You can't use postcode generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxPostcodeLength}.`,
+			);
+		}
+
+		for (const templateObj of templates) {
+			templateObj.indicesGen.skipCheck = true;
+			templateObj.indicesGen.init({ count, seed });
+		}
+
+		this.state = { rng, templates };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number;
+
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
+		const templateObj = this.state.templates[idx]!;
+
+		const postcodeNumber = templateObj.indicesGen.generate() as number;
+
+		templateObj.count += 1;
+		if (templateObj.count === templateObj.maxUniquePostcodeNumber) {
+			this.state.templates[idx] = this.state.templates.at(-1)!;
+			this.state.templates.pop();
+		}
+
+		const postcode = fillTemplate({
+			template: templateObj.template,
+			placeholdersCount: templateObj.placeholdersCount,
+			values: [...String(postcodeNumber)],
+			defaultValue: '0',
+		});
+
+		return postcode;
+	}
+}
+
+export class GenerateState extends AbstractGenerator<{
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateState';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStateLength) {
+			throw new Error(
+				`You can't use state generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStateLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx;
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, states.length - 1, this.state.rng);
+
+		return states[idx];
+	}
+}
+
+export class GenerateCompanyName extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateCompanyName';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		templates: { template: string; placeholdersCount: number }[];
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueCompanyName;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		const templates = [
+			{ template: '#', placeholdersCount: 1 },
+			{ template: '# - #', placeholdersCount: 2 },
+			{ template: '# and #', placeholdersCount: 2 },
+			{ template: '#, # and #', placeholdersCount: 3 },
+		];
+
+		// max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
+		const maxCompanyNameLength = Math.max(
+			maxLastNameLength + maxCompanyNameSuffixLength + 1,
+			3 * maxLastNameLength + 7,
+		);
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCompanyNameLength) {
+			throw new Error(
+				`You can't use company name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCompanyNameLength}.`,
+			);
+		}
+
+		this.state = { rng, templates };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let templateIdx, idx, lastName, companyNameSuffix, companyName;
+		[templateIdx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
+		const templateObj = this.state.templates[templateIdx]!;
+
+		if (templateObj.template === '#') {
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
+			lastName = lastNames[idx];
+
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, companyNameSuffixes.length - 1, this.state.rng);
+			companyNameSuffix = companyNameSuffixes[idx];
+
+			companyName = `${lastName} ${companyNameSuffix}`;
+			return companyName;
+		}
+
+		const values = [];
+		for (let i = 0; i < templateObj.placeholdersCount; i++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
+			values.push(lastNames[idx]!);
+		}
+
+		companyName = fillTemplate({
+			template: templateObj.template,
+			values,
+			placeholdersCount: templateObj.placeholdersCount,
+		});
+		return companyName;
+	}
+}
+
+export class GenerateUniqueCompanyName extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly entityKind: string = 'GenerateUniqueCompanyName';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		templates: {
+			template: string;
+			placeholdersCount: number;
+			indicesGen: GenerateUniqueInt;
+			maxUniqueCompanyNameNumber: number;
+			count: number;
+			arraysToChooseFrom: string[][];
+		}[];
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
+		+ Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.maxUniqueCount) {
+			throw new RangeError(
+				`count exceeds max number of unique company names(${this.maxUniqueCount}).`,
+			);
+		}
+
+		// max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
+		const maxCompanyNameLength = Math.max(
+			maxLastNameLength + maxCompanyNameSuffixLength + 1,
+			3 * maxLastNameLength + 7,
+		);
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxCompanyNameLength) {
+			throw new Error(
+				`You can't use company name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxCompanyNameLength}.`,
+			);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		// when count reach maxUniqueCompanyNameNumber template will be deleted from array
+		const templates = [
+			{
+				template: '# - #',
+				placeholdersCount: 1,
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: lastNames.length * companyNameSuffixes.length - 1 }),
+				maxUniqueCompanyNameNumber: lastNames.length * companyNameSuffixes.length,
+				count: 0,
+				arraysToChooseFrom: [lastNames, companyNameSuffixes],
+			},
+			{
+				template: '# - #',
+				placeholdersCount: 2,
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 2) - 1 }),
+				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 2),
+				count: 0,
+				arraysToChooseFrom: [lastNames, lastNames],
+			},
+			{
+				template: '# and #',
+				placeholdersCount: 2,
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 2) - 1 }),
+				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 2),
+				count: 0,
+				arraysToChooseFrom: [lastNames, lastNames],
+			},
+			{
+				template: '#, # and #',
+				placeholdersCount: 3,
+				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 3) - 1 }),
+				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 3),
+				count: 0,
+				arraysToChooseFrom: [lastNames, lastNames, lastNames],
+			},
+		];
+
+		for (const templateObj of templates) {
+			templateObj.indicesGen.skipCheck = true;
+			templateObj.indicesGen.init({ count, seed });
+		}
+
+		this.state = { rng, templates };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let templateIdx;
+		[templateIdx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
+		const templateObj = this.state.templates[templateIdx]!;
+
+		const idx = templateObj.indicesGen.generate() as number;
+		const values = fastCartesianProduct(templateObj.arraysToChooseFrom, idx) as string[];
+
+		templateObj.count += 1;
+		if (templateObj.count === templateObj.maxUniqueCompanyNameNumber) {
+			this.state.templates[templateIdx] = this.state.templates.at(-1)!;
+			this.state.templates.pop();
+		}
+
+		const companyName = fillTemplate({
+			template: templateObj.template,
+			values,
+			placeholdersCount: templateObj.placeholdersCount,
+		});
+		return companyName;
+	}
+}
+
+export class GenerateLoremIpsum extends AbstractGenerator<{
+	sentencesCount?: number;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateLoremIpsum';
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		if (this.params.sentencesCount === undefined) this.params.sentencesCount = 1;
+
+		const maxLoremIpsumSentencesLength = maxLoremIpsumLength * this.params.sentencesCount + this.params.sentencesCount
+			- 1;
+		if (this.typeParams?.length !== undefined && this.typeParams?.length < maxLoremIpsumSentencesLength) {
+			throw new Error(
+				`You can't use lorem ipsum generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxLoremIpsumSentencesLength}.`,
+			);
+		}
+
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx, resultText: string = '';
+		for (let i = 0; i < this.params.sentencesCount!; i++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(0, loremIpsumSentences.length - 1, this.state.rng);
+			resultText += loremIpsumSentences[idx] + ' ';
+		}
+
+		return resultText;
+	}
+}
+
+export class WeightedRandomGenerator extends AbstractGenerator<{ weight: number; value: AbstractGenerator<any> }[]> {
+	static override readonly entityKind: string = 'WeightedRandomGenerator';
+
+	private state: {
+		rng: prand.RandomGenerator;
+		weightedIndices: number[];
+	} | undefined;
+
+	override replaceIfArray() {
+		for (const param of this.params) {
+			const arrayGen = param.value.replaceIfArray();
+			if (arrayGen) param.value = arrayGen;
+		}
+		return this;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		const weights = this.params.map((weightedGen) => weightedGen.weight);
+		const weightedIndices = getWeightedIndices(weights);
+
+		let idx: number, valueIdx: number, tempRng = prand.xoroshiro128plus(seed);
+		const indicesCounter: { [key: number]: number } = {};
+		for (let i = 0; i < count; i++) {
+			[idx, tempRng] = prand.uniformIntDistribution(0, weightedIndices.length - 1, tempRng);
+			valueIdx = weightedIndices[idx]!;
+			if (!Object.hasOwn(indicesCounter, valueIdx)) indicesCounter[valueIdx] = 0;
+			indicesCounter[valueIdx]! += 1;
+		}
+
+		for (const [idx, weightedGen] of this.params.entries()) {
+			weightedGen.value.isUnique = this.isUnique;
+			weightedGen.value.dataType = this.dataType;
+			weightedGen.value.init({ count: indicesCounter[idx]!, seed });
+
+			if (
+				weightedGen.value.uniqueVersionOfGen !== undefined
+				&& weightedGen.value.isUnique === true
+			) {
+				const uniqueGen = new weightedGen.value.uniqueVersionOfGen({
+					...weightedGen.value.params,
+				});
+				uniqueGen.init({
+					count: indicesCounter[idx]!,
+					seed,
+				});
+				uniqueGen.isUnique = weightedGen.value.isUnique;
+				uniqueGen.dataType = weightedGen.value.dataType;
+
+				weightedGen.value = uniqueGen;
+			}
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { weightedIndices, rng };
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let idx: number;
+		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
+		const generatorIdx = this.state.weightedIndices[idx] as number;
+		const value = this.params[generatorIdx]!.value.generate({ i });
+
+		return value;
+	}
+}
+
+export class GeneratePoint extends AbstractGenerator<{
+	isUnique?: boolean;
+	minXValue?: number;
+	maxXValue?: number;
+	minYValue?: number;
+	maxYValue?: number;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GeneratePoint';
+
+	private state: {
+		xCoordinateGen: GenerateNumber;
+		yCoordinateGen: GenerateNumber;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniquePoint;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const xCoordinateGen = new GenerateNumber({
+			minValue: this.params.minXValue,
+			maxValue: this.params.maxXValue,
+			precision: 10,
+		});
+		xCoordinateGen.init({ count, seed });
+
+		const yCoordinateGen = new GenerateNumber({
+			minValue: this.params.minYValue,
+			maxValue: this.params.maxYValue,
+			precision: 10,
+		});
+		yCoordinateGen.init({ count, seed });
+
+		this.state = { xCoordinateGen, yCoordinateGen };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const x = this.state.xCoordinateGen.generate();
+		const y = this.state.yCoordinateGen.generate();
+
+		if (this.dataType === 'object') {
+			return { x, y };
+		} else if (this.dataType === 'string') {
+			return `[${x}, ${y}]`;
+		} else {
+			// if (this.dataType === "array")
+			return [x, y];
+		}
+	}
+}
+
+export class GeneratePoint2 extends AbstractGenerator<{
+	isUnique?: boolean;
+	minXValue?: number;
+	maxXValue?: number;
+	minYValue?: number;
+	maxYValue?: number;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GeneratePoint';
+
+	private state: {
+		xCoordinateGen: GenerateNumber;
+		yCoordinateGen: GenerateNumber;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniquePoint;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const xCoordinateGen = new GenerateNumber({
+			minValue: this.params.minXValue,
+			maxValue: this.params.maxXValue,
+			precision: 10,
+		});
+		xCoordinateGen.init({ count, seed });
+
+		const yCoordinateGen = new GenerateNumber({
+			minValue: this.params.minYValue,
+			maxValue: this.params.maxYValue,
+			precision: 10,
+		});
+		yCoordinateGen.init({ count, seed });
+
+		this.state = { xCoordinateGen, yCoordinateGen };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const x = this.state.xCoordinateGen.generate();
+		const y = this.state.yCoordinateGen.generate();
+
+		if (this.dataType === 'object') {
+			return { x, y };
+		} else if (this.dataType === 'string') {
+			return `[${x}, ${y}]`;
+		} else {
+			// if (this.dataType === "array")
+			return [x, y];
+		}
+	}
+}
+
+export type GenerateUniquePointT = {
+	minXValue?: number;
+	maxXValue?: number;
+	minYValue?: number;
+	maxYValue?: number;
+	isUnique?: boolean;
+};
+export class GenerateUniquePoint extends AbstractGenerator<GenerateUniquePointT> {
+	static override readonly entityKind: string = 'GenerateUniquePoint';
+
+	private state: {
+		xCoordinateGen: GenerateUniqueNumber;
+		yCoordinateGen: GenerateUniqueNumber;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public xCoordinateGen: GenerateUniqueNumber;
+	public yCoordinateGen: GenerateUniqueNumber;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniquePointT) {
+		super(params);
+
+		this.xCoordinateGen = new GenerateUniqueNumber({
+			minValue: this.params.minXValue,
+			maxValue: this.params.maxXValue,
+			precision: 10,
+		});
+
+		this.yCoordinateGen = new GenerateUniqueNumber({
+			minValue: this.params.minYValue,
+			maxValue: this.params.maxYValue,
+			precision: 10,
+		});
+
+		this.maxUniqueCount = Math.min(this.xCoordinateGen.maxUniqueCount, this.yCoordinateGen.maxUniqueCount);
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		// TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
+
+		this.xCoordinateGen.init({ count, seed });
+		this.yCoordinateGen.init({ count, seed });
+
+		this.state = { xCoordinateGen: this.xCoordinateGen, yCoordinateGen: this.yCoordinateGen };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const x = this.state.xCoordinateGen.generate();
+		const y = this.state.yCoordinateGen.generate();
+
+		if (this.dataType === 'object') {
+			return { x, y };
+		} else if (this.dataType === 'string') {
+			return `[${x}, ${y}]`;
+		} else {
+			// if (this.dataType === "array")
+			return [x, y];
+		}
+	}
+}
+
+export class GenerateLine extends AbstractGenerator<{
+	isUnique?: boolean;
+	minAValue?: number;
+	maxAValue?: number;
+	minBValue?: number;
+	maxBValue?: number;
+	minCValue?: number;
+	maxCValue?: number;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateLine';
+
+	private state: {
+		aCoefficientGen: GenerateNumber;
+		bCoefficientGen: GenerateNumber;
+		cCoefficientGen: GenerateNumber;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueLine;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const aCoefficientGen = new GenerateNumber({
+			minValue: this.params.minAValue,
+			maxValue: this.params.maxAValue,
+			precision: 10,
+		});
+		aCoefficientGen.init({ count, seed });
+
+		const bCoefficientGen = new GenerateNumber({
+			minValue: this.params.minBValue,
+			maxValue: this.params.maxBValue,
+			precision: 10,
+		});
+		bCoefficientGen.init({ count, seed });
+
+		const cCoefficientGen = new GenerateNumber({
+			minValue: this.params.minCValue,
+			maxValue: this.params.maxCValue,
+			precision: 10,
+		});
+		cCoefficientGen.init({ count, seed });
+
+		this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let b: number;
+		const a = this.state.aCoefficientGen.generate();
+
+		b = this.state.bCoefficientGen.generate();
+		while (a === 0 && b === 0) {
+			b = this.state.bCoefficientGen.generate();
+		}
+
+		const c = this.state.cCoefficientGen.generate();
+
+		if (this.dataType === 'object') {
+			return { a, b, c };
+		} else if (this.dataType === 'string') {
+			return `[${a}, ${b}, ${c}]`;
+		} else {
+			// if (this.dataType === "array")
+			return [a, b, c];
+		}
+	}
+}
+
+export type GenerateUniqueLineT = {
+	minAValue?: number;
+	maxAValue?: number;
+	minBValue?: number;
+	maxBValue?: number;
+	minCValue?: number;
+	maxCValue?: number;
+	isUnique?: boolean;
+};
+export class GenerateUniqueLine extends AbstractGenerator<GenerateUniqueLineT> {
+	static override readonly entityKind: string = 'GenerateUniqueLine';
+
+	private state: {
+		aCoefficientGen: GenerateUniqueNumber;
+		bCoefficientGen: GenerateUniqueNumber;
+		cCoefficientGen: GenerateUniqueNumber;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+	public aCoefficientGen: GenerateUniqueNumber;
+	public bCoefficientGen: GenerateUniqueNumber;
+	public cCoefficientGen: GenerateUniqueNumber;
+
+	constructor(params?: GenerateUniqueLineT) {
+		super(params);
+		this.aCoefficientGen = new GenerateUniqueNumber({
+			minValue: this.params.minAValue,
+			maxValue: this.params.maxAValue,
+			precision: 10,
+		});
+
+		this.bCoefficientGen = new GenerateUniqueNumber({
+			minValue: this.params.minBValue,
+			maxValue: this.params.maxBValue,
+			precision: 10,
+		});
+
+		this.cCoefficientGen = new GenerateUniqueNumber({
+			minValue: this.params.minCValue,
+			maxValue: this.params.maxCValue,
+			precision: 10,
+		});
+
+		this.maxUniqueCount = Math.min(
+			this.aCoefficientGen.maxUniqueCount,
+			this.bCoefficientGen.maxUniqueCount,
+			this.cCoefficientGen.maxUniqueCount,
+		);
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		// TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
+		this.aCoefficientGen.init({ count, seed });
+		this.bCoefficientGen.init({ count, seed });
+		this.cCoefficientGen.init({ count, seed });
+
+		this.state = {
+			aCoefficientGen: this.aCoefficientGen,
+			bCoefficientGen: this.bCoefficientGen,
+			cCoefficientGen: this.cCoefficientGen,
+		};
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let b: number;
+		const a = this.state.aCoefficientGen.generate();
+
+		b = this.state.bCoefficientGen.generate();
+		while (a === 0 && b === 0) {
+			b = this.state.bCoefficientGen.generate();
+		}
+
+		const c = this.state.cCoefficientGen.generate();
+
+		if (this.dataType === 'object') {
+			return { a, b, c };
+		} else if (this.dataType === 'string') {
+			return `[${a}, ${b}, ${c}]`;
+		} else {
+			// if (this.dataType === "array")
+			return [a, b, c];
+		}
+	}
+}
+
+export class CustomGenerator<StateT extends Record<string, any> = {}> extends AbstractGenerator<{
+	generate: (params: { this_: CustomGenerator; i: number }) => any;
+	init?: (params: { this_: CustomGenerator; count: number; seed: number }) => void;
+}> {
+	public state: StateT = {} as StateT;
+
+	static override readonly entityKind: string = 'CustomGenerator';
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (this.params.init !== undefined) this.params.init({ this_: this, count, seed });
+	}
+
+	generate({ i }: { i: number }): any {
+		return this.params.generate({ this_: this, i });
+	}
+}
+export class GenerateBitString extends AbstractGenerator<{
+	dimensions?: number;
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateBitString';
+	dimensions: number = 11;
+
+	private state: {
+		intGen: GenerateInt;
+	} | undefined;
+
+	override uniqueVersionOfGen = GenerateUniqueBitString;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+		let intGen: GenerateInt;
+
+		if (this.dimensions > 53) {
+			const maxValue = (BigInt(2) ** BigInt(this.dimensions)) - BigInt(1);
+			intGen = new GenerateInt({ minValue: BigInt(0), maxValue });
+		} else {
+			// dimensions <= 53
+			const maxValue = Math.pow(2, this.dimensions) - 1;
+			intGen = new GenerateInt({ minValue: 0, maxValue });
+		}
+
+		intGen.init({ count, seed });
+
+		this.state = { intGen };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const bitString = this.state.intGen.generate().toString(2);
+		return bitString.padStart(this.dimensions!, '0');
+	}
+}
+
+export class GenerateUniqueBitString
+	extends AbstractGenerator<{ dimensions?: number; isUnique?: boolean; arraySize?: number }>
+{
+	static override readonly entityKind: string = 'GenerateUniqueBitString';
+	dimensions: number = 11;
+
+	private state: {
+		intGen: GenerateUniqueInt;
+	} | undefined;
+
+	public override isGeneratorUnique = true;
+
+	override getMaxUniqueCount() {
+		if (this.maxUniqueCount >= 0) return this.maxUniqueCount;
+
+		this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+		this.maxUniqueCount = Math.pow(2, this.dimensions);
+		// TODO revise: will work incorrect with this.dimensions > 53, due to node js number limitations
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+		let intGen: GenerateUniqueInt;
+
+		if (this.dimensions > 53) {
+			const maxValue = (BigInt(2) ** BigInt(this.dimensions)) - BigInt(1);
+			intGen = new GenerateUniqueInt({ minValue: BigInt(0), maxValue });
+		} else {
+			// dimensions <= 53
+			const maxValue = Math.pow(2, this.dimensions) - 1;
+			intGen = new GenerateUniqueInt({ minValue: 0, maxValue });
+		}
+
+		intGen.init({ count, seed });
+
+		this.state = { intGen };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const bitString = this.state.intGen.generate()!.toString(2);
+		return bitString.padStart(this.dimensions!, '0');
+	}
+}
+
+export class GenerateInet extends AbstractGenerator<
+	{ ipAddress?: 'ipv4' | 'ipv6'; includeCidr?: boolean; isUnique?: boolean; arraySize?: number }
+> {
+	static override readonly entityKind: string = 'GenerateInet';
+	ipAddress: 'ipv4' | 'ipv6' = 'ipv4';
+	includeCidr: boolean = true;
+
+	private state: {
+		rng: prand.RandomGenerator;
+	} | undefined;
+
+	override uniqueVersionOfGen = GenerateUniqueInet;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+		this.ipAddress = this.params.ipAddress ?? this.ipAddress;
+		this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let value: number;
+		const values: string[] = [];
+		let inetVal = '';
+		if (this.ipAddress === 'ipv4') {
+			for (let octet = 0; octet < 4; octet++) {
+				[value, this.state.rng] = prand.uniformIntDistribution(
+					0,
+					255,
+					this.state.rng,
+				);
+				values.push(value.toString());
+			}
+
+			inetVal += values.join('.');
+
+			if (this.includeCidr) {
+				[value, this.state.rng] = prand.uniformIntDistribution(
+					0,
+					32,
+					this.state.rng,
+				);
+				inetVal += `/${value}`;
+			}
+			return inetVal;
+		} else {
+			// this.ipAddress === 'ipv6'
+			for (let hextet = 0; hextet < 8; hextet++) {
+				[value, this.state.rng] = prand.uniformIntDistribution(
+					0,
+					65535,
+					this.state.rng,
+				);
+				values.push(value.toString(16));
+			}
+
+			inetVal += values.join(':');
+
+			if (this.includeCidr) {
+				[value, this.state.rng] = prand.uniformIntDistribution(
+					0,
+					128,
+					this.state.rng,
+				);
+				inetVal += `/${value}`;
+			}
+			return inetVal;
+		}
+	}
+}
+
+// TODO: add defaults to js doc
+export type GenerateUniqueInetT = {
+	ipAddress?: 'ipv4' | 'ipv6';
+	includeCidr?: boolean;
+	isUnique?: boolean;
+	arraySize?: number;
+};
+export class GenerateUniqueInet extends AbstractGenerator<GenerateUniqueInetT> {
+	static override readonly entityKind: string = 'GenerateUniqueInet';
+	ipAddress: 'ipv4' | 'ipv6' = 'ipv4';
+	includeCidr: boolean = true;
+	delimiter: '.' | ':' = '.';
+
+	private state: {
+		indexGen: GenerateUniqueInt;
+		octetSet: string[];
+		ipv4PrefixSet: string[];
+		hextetSet: string[];
+		ipv6PrefixSet: string[];
+	} | undefined;
+
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniqueInetT) {
+		super(params);
+
+		this.ipAddress = this.params.ipAddress ?? this.ipAddress;
+		this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+
+		if (this.ipAddress === 'ipv4') {
+			this.maxUniqueCount = 256 ** 4;
+			if (this.includeCidr) {
+				this.maxUniqueCount *= 33;
+			}
+		} else {
+			// this.ipAddress === 'ipv6'
+			// TODO revise: this.maxUniqueCount can exceed Number.MAX_SAFE_INTEGER
+			this.maxUniqueCount = 65535 ** 8;
+			if (this.includeCidr) {
+				this.maxUniqueCount *= 129;
+			}
+		}
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
+
+		// maxValue - number of combinations for cartesian product: {0…255} × {0…255} × {0…255} × {0…255} × {0…32}
+		// where pattern for ipv4 ip is {0–255}.{0–255}.{0–255}.{0–255}[/{0–32}?]
+		// or number of combinations for cartesian product: {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…128}
+		// where pattern for ipv6 ip is {0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}:{0-65535}[/0-128?]
+		let minValue: number | bigint, maxValue: number | bigint;
+
+		if (this.ipAddress === 'ipv4') {
+			minValue = 0;
+			maxValue = 256 ** 4;
+			if (this.includeCidr) {
+				maxValue = maxValue * 33;
+			}
+		} else {
+			// this.ipAddress === 'ipv6'
+			minValue = BigInt(0);
+			maxValue = BigInt(65535) ** BigInt(8);
+			if (this.includeCidr) {
+				maxValue = maxValue * BigInt(129);
+			}
+		}
+
+		const indexGen = new GenerateUniqueInt({ minValue, maxValue });
+		indexGen.init({ count, seed });
+
+		const octetSet = Array.from({ length: 256 }, (_, i) => i.toString());
+		const ipv4PrefixSet = Array.from({ length: 33 }, (_, i) => i.toString());
+		const hextetSet = Array.from({ length: 65536 }, (_, i) => i.toString(16));
+		const ipv6PrefixSet = Array.from({ length: 129 }, (_, i) => i.toString());
+
+		this.state = { indexGen, octetSet, ipv4PrefixSet, hextetSet, ipv6PrefixSet };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		let inetVal = '';
+		let tokens: string[] = [];
+
+		if (this.ipAddress === 'ipv4') {
+			const sets = Array.from({ length: 4 }).fill(this.state.octetSet) as string[][];
+			if (this.includeCidr) sets.push(this.state.ipv4PrefixSet);
+
+			const index = this.state.indexGen.generate() as number;
+			tokens = fastCartesianProduct(sets, index) as string[];
+		} else {
+			// this.ipAddress === 'ipv6'
+			const sets = Array.from({ length: 8 }).fill(this.state.hextetSet) as string[][];
+			if (this.includeCidr) sets.push(this.state.ipv6PrefixSet);
+
+			const idx = this.state.indexGen.generate() as bigint;
+			tokens = fastCartesianProductForBigint(sets, idx) as string[];
+		}
+
+		inetVal = this.includeCidr
+			? tokens.slice(0, -1).join(this.delimiter) + `/${tokens.at(-1)}`
+			: tokens.join(this.delimiter);
+
+		return inetVal;
+	}
+}
+
+export class GenerateGeometry extends AbstractGenerator<
+	{
+		type?: 'point';
+		srid?: 4326 | 3857;
+		decimalPlaces?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+		isUnique?: boolean;
+		arraySize?: number;
+	}
+> {
+	static override readonly entityKind: string = 'GenerateGeometry';
+	type = 'point' as const;
+	srid: 4326 | 3857 = 4326;
+	decimalPlaces: 1 | 2 | 3 | 4 | 5 | 6 | 7 = 6;
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minXValue: number;
+		maxXValue: number;
+		minYValue: number;
+		maxYValue: number;
+		denominator: number;
+	} | undefined;
+
+	override uniqueVersionOfGen = GenerateUniqueGeometry;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		this.type = this.params.type ?? this.type;
+		this.srid = this.params.srid ?? this.srid;
+		this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+
+		let minXValue: number, maxXValue: number, minYValue: number, maxYValue: number, denominator: number;
+		if (this.type === 'point') {
+			if (this.srid === 4326) {
+				// Degrees (latitude / longitude)
+				denominator = 10 ** this.decimalPlaces;
+				minXValue = -180 * denominator;
+				maxXValue = 180 * denominator;
+				minYValue = -90 * denominator;
+				maxYValue = 90 * denominator;
+			} else {
+				// this.srid === 3857
+				// Meters (projected X / Y)
+				denominator = 1;
+				minXValue = -20026376;
+				maxXValue = 20026376;
+				minYValue = -20048966;
+				maxYValue = 20048966;
+			}
+		} else {
+			throw new Error('geometry generator currently supports only the point type.');
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+
+		this.state = { rng, minXValue, maxXValue, minYValue, maxYValue, denominator };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let x: number, y: number;
+		[x, this.state.rng] = prand.uniformIntDistribution(
+			this.state.minXValue,
+			this.state.maxXValue,
+			this.state.rng,
+		);
+		x = x / this.state.denominator;
+
+		[y, this.state.rng] = prand.uniformIntDistribution(
+			this.state.minYValue,
+			this.state.maxYValue,
+			this.state.rng,
+		);
+		y = y / this.state.denominator;
+
+		if (this.dataType === 'array') {
+			return [x, y];
+		}
+
+		// this.dataType === 'object'
+		return { x, y };
+	}
+}
+
+export type GenerateUniqueGeometryT = {
+	type?: 'point';
+	srid?: 4326 | 3857;
+	decimalPlaces?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+	isUnique?: boolean;
+	arraySize?: number;
+};
+export class GenerateUniqueGeometry extends AbstractGenerator<GenerateUniqueGeometryT> {
+	static override readonly entityKind: string = 'GenerateUniqueGeometry';
+	type = 'point' as const;
+	srid: 4326 | 3857 = 4326;
+	decimalPlaces: 1 | 2 | 3 | 4 | 5 | 6 | 7 = 6;
+
+	private state: {
+		denominator: number;
+		indexGen: GenerateUniqueInt;
+		xySets: OrderedNumberRange[];
+	} | undefined;
+
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+
+	constructor(params?: GenerateUniqueGeometryT) {
+		super(params);
+
+		this.type = this.params.type ?? this.type;
+		this.srid = this.params.srid ?? this.srid;
+		this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+
+		let minXValue: number, maxXValue: number, minYValue: number, maxYValue: number, denominator: number;
+		if (this.type === 'point') {
+			if (this.srid === 4326) {
+				// Degrees (latitude / longitude)
+				denominator = 10 ** this.decimalPlaces;
+				minXValue = -180 * denominator;
+				maxXValue = 180 * denominator;
+				minYValue = -90 * denominator;
+				maxYValue = 90 * denominator;
+			} else {
+				// this.srid === 3857
+				// Meters (projected X / Y)
+				denominator = 1;
+				minXValue = -20026376;
+				maxXValue = 20026376;
+				minYValue = -20048966;
+				maxYValue = 20048966;
+			}
+		} else {
+			// error should be triggered in init method
+			this.maxUniqueCount = -1;
+			return;
+		}
+
+		// TODO revise: can lose accuracy due to exceeding Number.MAX_SAFE_INTEGER
+		this.maxUniqueCount = Number(BigInt(maxXValue - minXValue + 1) * BigInt(maxYValue - minYValue + 1));
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		let minXValue: number, maxXValue: number, minYValue: number, maxYValue: number, denominator: number;
+		if (this.type === 'point') {
+			if (this.srid === 4326) {
+				// Degrees (latitude / longitude)
+				denominator = 10 ** this.decimalPlaces;
+				minXValue = -180 * denominator;
+				maxXValue = 180 * denominator;
+				minYValue = -90 * denominator;
+				maxYValue = 90 * denominator;
+			} else {
+				// this.srid === 3857
+				// Meters (projected X / Y)
+				denominator = 1;
+				minXValue = -20026376;
+				maxXValue = 20026376;
+				minYValue = -20048966;
+				maxYValue = 20048966;
+			}
+		} else {
+			throw new Error('geometry generator currently supports only the point type.');
+		}
+
+		const xRange = new OrderedNumberRange(minXValue, maxXValue, 1);
+		const yRange = new OrderedNumberRange(minYValue, maxYValue, 1);
+		const xySets = [xRange, yRange];
+
+		const maxCombIdx = BigInt(maxXValue - minXValue + 1) * BigInt(maxYValue - minYValue + 1) - BigInt(1);
+		const indexGen = maxCombIdx <= 2 ** 53
+			? new GenerateUniqueInt({ minValue: 0, maxValue: Number(maxCombIdx) })
+			: new GenerateUniqueInt({ minValue: BigInt(0), maxValue: maxCombIdx });
+		indexGen.init({ count, seed });
+
+		this.state = { denominator, indexGen, xySets };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const idx = this.state.indexGen.generate();
+		let x: number, y: number;
+		if (typeof idx === 'number') {
+			[x, y] = fastCartesianProduct(this.state.xySets, idx) as [number, number];
+		} else {
+			// typeof idx === 'bigint'
+			[x, y] = fastCartesianProductForBigint(this.state.xySets, idx as bigint) as [number, number];
+		}
+
+		if (this.dataType === 'array') {
+			return [x, y];
+		}
+
+		// this.dataType === 'object'
+		return { x, y };
+	}
+}
+
+export class GenerateVector extends AbstractGenerator<
+	{
+		dimensions?: number;
+		minValue?: number;
+		maxValue?: number;
+		decimalPlaces?: number;
+		isUnique?: boolean;
+		arraySize?: number;
+	}
+> {
+	static override readonly entityKind: string = 'GenerateVector';
+	// property below should be overridden in init
+	dimensions: number = 3;
+	minValue: number = -1000;
+	maxValue: number = 1000;
+	decimalPlaces: number = 2;
+
+	private state: {
+		vectorGen: GenerateArray;
+	} | undefined;
+
+	override uniqueVersionOfGen = GenerateUniqueVector;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+		this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+		this.minValue = this.params.minValue ?? this.minValue;
+		this.maxValue = this.params.maxValue ?? this.maxValue;
+		if (this.minValue > this.maxValue) {
+			throw new Error(
+				`minValue ( ${this.minValue} ) cannot be greater than maxValue ( ${this.maxValue} ).\n`
+					+ `Did you forget to pass both minValue and maxValue to the generator's properties?`,
+			);
+		}
+
+		if (this.decimalPlaces < 0) {
+			throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
+		}
+
+		if (
+			abs(BigInt(this.minValue) * BigInt(10 ** this.decimalPlaces)) > Number.MAX_SAFE_INTEGER
+			|| abs(BigInt(this.maxValue) * BigInt(10 ** this.decimalPlaces)) > Number.MAX_SAFE_INTEGER
+		) {
+			console.warn(
+				`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
+					+ `This overflow may result in less accurate values being generated.`,
+			);
+		}
+
+		// `numberGen` is initialized in the `init` method of `GenerateArray`
+		const numberGen = new GenerateNumber({
+			minValue: this.minValue,
+			maxValue: this.maxValue as number,
+			precision: 10 ** this.decimalPlaces,
+		});
+		const vectorGen = new GenerateArray({ baseColumnGen: numberGen, size: this.dimensions });
+		vectorGen.init({ count, seed });
+
+		this.state = { vectorGen };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const vectorVal = this.state.vectorGen.generate();
+		return vectorVal;
+	}
+}
+
+export type GenerateUniqueVectorT = {
+	dimensions?: number;
+	minValue?: number;
+	maxValue?: number;
+	decimalPlaces?: number;
+	isUnique?: boolean;
+	arraySize?: number;
+};
+export class GenerateUniqueVector extends AbstractGenerator<GenerateUniqueVectorT> {
+	static override readonly entityKind: string = 'GenerateUniqueVector';
+	// property below should be overridden in init
+	dimensions: number = 3;
+	minValue: number = -1000;
+	maxValue: number = 1000;
+	decimalPlaces: number = 2;
+
+	private state: {
+		denominator: number;
+		indexGen: GenerateUniqueInt;
+		vectorSets: OrderedNumberRange[];
+		transformVector: (vector: number[], denominator: number) => void;
+	} | undefined;
+
+	public override isGeneratorUnique = true;
+
+	constructor(params?: GenerateUniqueVectorT) {
+		super(params);
+
+		this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+		this.minValue = this.params.minValue ?? this.minValue;
+		this.maxValue = this.params.maxValue ?? this.maxValue;
+
+		if (this.minValue > this.maxValue) {
+			throw new Error(
+				`minValue ( ${this.minValue} ) cannot be greater than maxValue ( ${this.maxValue} ).\n`
+					+ `Did you forget to pass both minValue and maxValue to the generator's properties?`,
+			);
+		}
+
+		if (this.decimalPlaces < 0) {
+			throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
+		}
+	}
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount >= 0) return this.maxUniqueCount;
+
+		this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+		const denominator = 10 ** this.decimalPlaces;
+
+		this.maxUniqueCount = (this.maxValue * denominator - this.minValue * denominator + 1) ** this.dimensions;
+		return this.maxUniqueCount;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+		const denominator = 10 ** this.decimalPlaces;
+
+		if (
+			abs(BigInt(this.minValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER
+			|| abs(BigInt(this.maxValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER
+		) {
+			console.warn(
+				`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
+					+ `This overflow may result in less accurate values being generated.`,
+			);
+		}
+
+		const dimensionRange = new OrderedNumberRange(this.minValue * denominator, this.maxValue * denominator, 1);
+		const vectorSets = Array.from({ length: this.dimensions }).fill(dimensionRange) as OrderedNumberRange[];
+
+		const maxCombIdx = vectorSets.reduce((acc, curr) => acc * BigInt(curr.length), BigInt(1)) - BigInt(1);
+		const indexGen = maxCombIdx <= Number.MAX_SAFE_INTEGER
+			? new GenerateUniqueInt({ minValue: 0, maxValue: Number(maxCombIdx) })
+			: new GenerateUniqueInt({ minValue: BigInt(0), maxValue: maxCombIdx });
+		indexGen.init({ count, seed });
+
+		const transformVector = denominator === 1
+			? (_vector: (number)[], _denominator: number) => {}
+			: (vector: number[], denominator: number) => {
+				for (let i = 0; i < vector.length; i++) {
+					vector[i] = vector[i]! / denominator;
+				}
+				return;
+			};
+
+		this.state = { indexGen, vectorSets, denominator, transformVector };
+	}
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const idx = this.state.indexGen.generate();
+		const vector = typeof idx === 'number'
+			? fastCartesianProduct(this.state.vectorSets, idx)
+			// typeof idx === 'bigint'
+			: fastCartesianProductForBigint(this.state.vectorSets, idx as bigint);
+
+		this.state.transformVector(vector as number[], this.state.denominator);
+
+		return vector;
+	}
+}
+
+export class GenerateCompositeUniqueKey extends AbstractGenerator {
+	static override readonly entityKind: string = 'GenerateCompositeUniqueKey';
+	columnGenerators: {
+		columnName: string;
+		generator: AbstractGenerator<any>;
+		maxUniqueCount?: number;
+		count?: number;
+	}[] = [];
+
+	private isInitialized: boolean = false;
+	private state: {
+		sets: any[][];
+		currI: number;
+		currValue: { [columnName: string]: any };
+	} | undefined;
+
+	addGenerator(columnName: string, generator: AbstractGenerator<any>) {
+		this.columnGenerators.push({ columnName, generator });
+	}
+
+	override updateParams({ columnName, paramsToUpdate }: { columnName: string; paramsToUpdate: Record<string, any> }) {
+		const genIdx = this.columnGenerators.findIndex((val) => val.columnName === columnName);
+		if (genIdx !== -1) Object.assign(this.columnGenerators[genIdx]!.generator.params, paramsToUpdate);
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (this.isInitialized) return;
+
+		if (this.columnGenerators.length === 0) {
+			throw new Error(`composite unique key generator has no generators to work with.`);
+		}
+		let countPerGen = Math.ceil(count ** (1 / this.columnGenerators.length));
+		// const gensMaxUniqueCount: { columnName: string; count: number; maxUniqueCount: number }[] = [];
+		for (const colGen of this.columnGenerators) {
+			colGen.maxUniqueCount = colGen.generator.getMaxUniqueCount();
+		}
+
+		this.columnGenerators.sort((a, b) => a.maxUniqueCount! - b.maxUniqueCount!);
+		let currCount = count;
+		let canGenerate: boolean = false;
+		for (const [idx, colGen] of this.columnGenerators.entries()) {
+			if (colGen.maxUniqueCount! < countPerGen) {
+				colGen.count = colGen.maxUniqueCount;
+				currCount /= colGen.count!;
+				countPerGen = Math.ceil(currCount ** (1 / (this.columnGenerators.length - idx - 1)));
+				canGenerate = false;
+			} else {
+				colGen.count = countPerGen;
+				canGenerate = true;
+			}
+		}
+
+		if (!canGenerate) {
+			const colGensCountInfo = this.columnGenerators.map((colGen) =>
+				`generator:${colGen.generator.getEntityKind()};count:${colGen.count}`
+			).join('\n');
+			throw new Error(
+				`There are no enough unique values in each generator to generate ${count} values; \n${colGensCountInfo}`,
+			);
+		}
+
+		const sets: any[][] = [];
+		for (const colGen of this.columnGenerators) {
+			colGen.generator.init({ count: colGen.count!, seed });
+			const setI = [];
+			for (let i = 0; i < countPerGen; i++) {
+				setI.push(colGen.generator.generate({ i }));
+			}
+			sets.push(setI);
+		}
+
+		this.state = { sets, currI: -1, currValue: {} };
+		this.isInitialized = true;
+	}
+
+	override generate({ i, columnName }: { i: number; columnName: string }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		if (i > this.state.currI) {
+			const rowI = fastCartesianProduct(this.state.sets, i);
+			const newCurrValue: typeof this.state.currValue = {};
+			for (const [idx, colGen] of this.columnGenerators.entries()) {
+				newCurrValue[colGen.columnName] = rowI[idx];
+			}
+			this.state.currValue = newCurrValue;
+			this.state.currI = i;
+		}
+
+		return this.state.currValue[columnName];
+	}
+}
diff --git a/drizzle-seed/src/generators/apiVersion.ts b/drizzle-seed/src/generators/apiVersion.ts
new file mode 100644
index 0000000000..819d3ffd69
--- /dev/null
+++ b/drizzle-seed/src/generators/apiVersion.ts
@@ -0,0 +1 @@
+export const latestVersion = 4;
diff --git a/drizzle-seed/src/generators/utils.ts b/drizzle-seed/src/generators/utils.ts
new file mode 100644
index 0000000000..5b93a41ff4
--- /dev/null
+++ b/drizzle-seed/src/generators/utils.ts
@@ -0,0 +1,216 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+
+export const fastCartesianProduct = <
+	SetsT extends ((number | string | boolean | object)[] | OrderedNumberRange | OrderedBigintRange)[],
+>(
+	sets: SetsT,
+	index: number,
+) => {
+	const resultList: SetsT[number][number][] = [];
+	let currSet: (typeof sets)[number];
+	let element: (typeof sets)[number][number];
+
+	for (let i = sets.length - 1; i >= 0; i--) {
+		currSet = sets[i]!;
+		element = currSet[index % Number(currSet.length)]!;
+		resultList.unshift(element);
+		index = Math.floor(index / Number(currSet.length));
+	}
+
+	return resultList;
+};
+
+export const fastCartesianProductForBigint = <
+	SetsT extends ((number | string | boolean | object)[] | OrderedNumberRange | OrderedBigintRange)[],
+>(
+	sets: SetsT,
+	index: bigint,
+) => {
+	const resultList: SetsT[number][number][] = [];
+	let currSet: (typeof sets)[number];
+	let element: (typeof sets)[number][number];
+
+	for (let i = sets.length - 1; i >= 0; i--) {
+		currSet = sets[i]!;
+		const remainder = index % BigInt(currSet.length);
+
+		// TODO check how it works
+		// remainder = remainder <= Number.MAX_SAFE_INTEGER ? Number(remainder) : remainder;
+		element = currSet[remainder as any]!;
+		resultList.unshift(element);
+		index = index / BigInt(currSet.length);
+	}
+
+	return resultList;
+};
+
+export class OrderedNumberRange<T extends number = number> {
+	// Tell TS “obj[n]” will be a T:
+	[index: number]: T;
+	public readonly length: number;
+
+	constructor(
+		private readonly min: T,
+		private readonly max: T,
+		private readonly step: T,
+	) {
+		this.length = Math.floor((this.max - this.min) / this.step) + 1;
+
+		const handler: ProxyHandler<OrderedNumberRange<T>> = {
+			get(
+				target: OrderedNumberRange<T>,
+				prop: PropertyKey,
+				receiver: any,
+			): T | unknown {
+				if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+					const idx = Number(prop);
+					if (idx >= target.length) return undefined;
+					return (target.min + idx * target.step) as T;
+				}
+				// fallback to normal lookup (and TS knows this has the right signature)
+				return Reflect.get(target, prop, receiver);
+			},
+		};
+
+		return new Proxy(this, handler);
+	}
+}
+
+export class OrderedBigintRange<T extends bigint = bigint> {
+	// Tell TS “obj[n]” will be a T:
+	[index: number]: T;
+	public readonly length: bigint;
+
+	constructor(
+		private readonly min: T,
+		private readonly max: T,
+		private readonly step: T,
+	) {
+		this.length = BigInt((this.max - this.min) / this.step) + BigInt(1);
+
+		const handler: ProxyHandler<OrderedBigintRange<T>> = {
+			get(
+				target: OrderedBigintRange<T>,
+				prop: PropertyKey,
+				receiver: any,
+			): T | string | unknown {
+				if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+					const idx = BigInt(prop);
+					if (idx >= target.length) return undefined;
+					return (target.min + idx * target.step).toString();
+				}
+				// fallback to normal lookup (and TS knows this has the right signature)
+				return Reflect.get(target, prop, receiver);
+			},
+		};
+
+		return new Proxy(this, handler);
+	}
+}
+
+export const abs = (n: number | bigint) => (n < 0n) ? -n : n;
+
+const sumArray = (weights: number[]) => {
+	const scale = 1e10;
+	const scaledSum = weights.reduce((acc, currVal) => acc + Math.round(currVal * scale), 0);
+	return scaledSum / scale;
+};
+
+/**
+ * @param weights positive number in range [0, 1], that represents probabilities to choose index of array. Example: weights = [0.2, 0.8]
+ * @param [accuracy=100] approximate number of elements in returning array
+ * @returns Example: with weights = [0.2, 0.8] and accuracy = 10 returning array of indices gonna equal this: [0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
+ */
+export const getWeightedIndices = (weights: number[], accuracy = 100) => {
+	const weightsSum = sumArray(weights);
+	if (weightsSum !== 1) {
+		throw new Error(
+			`The weights for the Weighted Random feature must add up to exactly 1. Please review your weights to ensure they total 1 before proceeding`,
+		);
+	}
+
+	// const accuracy = 100;
+	const weightedIndices: number[] = [];
+	for (const [index, weight] of weights.entries()) {
+		const ticketsNumb = Math.floor(weight * accuracy);
+		weightedIndices.push(...Array.from<number>({ length: ticketsNumb }).fill(index));
+	}
+
+	return weightedIndices;
+};
+
+/**
+ * @param param0.template example: "#####" or "#####-####"
+ * @param param0.values example: ["3", "2", "h"]
+ * @param param0.defaultValue example: "0"
+ * @returns
+ */
+export const fillTemplate = ({ template, placeholdersCount, values, defaultValue = ' ' }: {
+	template: string;
+	placeholdersCount?: number;
+	values: string[];
+	defaultValue?: string;
+}) => {
+	if (placeholdersCount === undefined) {
+		const iterArray = [...template.matchAll(/#/g)];
+		placeholdersCount = iterArray.length;
+	}
+
+	const diff = placeholdersCount - values.length;
+	if (diff > 0) {
+		values.unshift(...Array.from<string>({ length: diff }).fill(defaultValue));
+	}
+
+	let resultStr = '', valueIdx = 0;
+	for (const si of template) {
+		if (si === '#') {
+			resultStr += values[valueIdx];
+			valueIdx += 1;
+			continue;
+		}
+		resultStr += si;
+	}
+
+	return resultStr;
+};
+
+// is variable is object-like.
+// Example:
+// isObject({f: 4}) === true;
+// isObject([1,2,3]) === false;
+// isObject(new Set()) === false;
+export const isObject = (value: any) => {
+	if (value !== null && value !== undefined && value.constructor === Object) return true;
+	return false;
+};
+
+export const isValidDate = (date: Date) => {
+	return !Number.isNaN(date.getTime());
+};
+
+// const main = () => {
+// 	console.time('range');
+// 	const range = new OrderedBigintRange(BigInt(-10), BigInt(10), BigInt(1));
+
+// 	console.log(range.length);
+// 	for (let i = 0; i < Number(range.length) + 1; i++) {
+// 		console.log(range[i]);
+// 	}
+// 	console.timeEnd('range');
+
+// 	const list = Array.from({ length: 2e6 + 1 }, (_, idx) => idx);
+
+// 	console.time('list');
+// 	console.log(list.length);
+// 	for (let i = 0; i < 2e6 + 1; i++) {
+// 		list[i];
+// 	}
+// 	console.timeEnd('list');
+
+// 	// const n = 5;
+// 	// for (let i = 0; i < n; i++) {
+// 	// 	console.log(fastCartesianProduct([[1, 2], [1, 2]], i));
+// 	// }
+// };
+
+// main();
diff --git a/drizzle-seed/src/generators/versioning/v2.ts b/drizzle-seed/src/generators/versioning/v2.ts
new file mode 100644
index 0000000000..4347b8b599
--- /dev/null
+++ b/drizzle-seed/src/generators/versioning/v2.ts
@@ -0,0 +1,253 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import prand from 'pure-rand';
+import { AbstractGenerator } from '../Generators.ts';
+
+export type GenerateUniqueIntervalV2T = {
+	fields?:
+		| 'year'
+		| 'month'
+		| 'day'
+		| 'hour'
+		| 'minute'
+		| 'second'
+		| 'year to month'
+		| 'day to hour'
+		| 'day to minute'
+		| 'day to second'
+		| 'hour to minute'
+		| 'hour to second'
+		| 'minute to second';
+	isUnique?: boolean;
+};
+export class GenerateUniqueIntervalV2 extends AbstractGenerator<GenerateUniqueIntervalV2T> {
+	static override readonly 'entityKind': string = 'GenerateUniqueInterval';
+	static override readonly version: number = 2;
+
+	private state: {
+		rng: prand.RandomGenerator;
+		fieldsToGenerate: string[];
+		intervalSet: Set<string>;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number;
+
+	private config: { [key: string]: { from: number; to: number } } = {
+		year: {
+			from: 0,
+			to: 5,
+		},
+		month: {
+			from: 0,
+			to: 11,
+		},
+		day: {
+			from: 0,
+			to: 29,
+		},
+		hour: {
+			from: 0,
+			to: 23,
+		},
+		minute: {
+			from: 0,
+			to: 59,
+		},
+		second: {
+			from: 0,
+			to: 59,
+		},
+	};
+
+	public fieldsToGenerate: string[];
+
+	constructor(params?: GenerateUniqueIntervalV2T) {
+		super(params);
+
+		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+		this.fieldsToGenerate = allFields;
+
+		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+			const tokens = this.params.fields.split(' to ');
+			const endIdx = allFields.indexOf(tokens[1]!);
+			this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		} else if (this.params.fields !== undefined) {
+			const endIdx = allFields.indexOf(this.params.fields);
+			this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
+		}
+
+		this.maxUniqueCount = 1;
+		for (const field of this.fieldsToGenerate) {
+			const from = this.config[field]!.from, to = this.config[field]!.to;
+			this.maxUniqueCount *= from - to + 1;
+		}
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		if (count > this.maxUniqueCount) {
+			throw new RangeError(`count exceeds max number of unique intervals(${this.maxUniqueCount})`);
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		const intervalSet = new Set<string>();
+		this.state = { rng, fieldsToGenerate: this.fieldsToGenerate, intervalSet };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		let interval, numb: number;
+
+		for (;;) {
+			interval = '';
+
+			for (const field of this.state.fieldsToGenerate) {
+				const from = this.config[field]!.from, to = this.config[field]!.to;
+				[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
+				interval += `${numb} ${field} `;
+			}
+
+			if (!this.state.intervalSet.has(interval)) {
+				this.state.intervalSet.add(interval);
+				break;
+			}
+		}
+
+		return interval;
+	}
+}
+
+// TODO need to rework this generator
+export class GenerateStringV2 extends AbstractGenerator<{
+	isUnique?: boolean;
+	arraySize?: number;
+}> {
+	static override readonly 'entityKind': string = 'GenerateString';
+	static override readonly version: number = 2;
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minStringLength: number;
+		maxStringLength: number;
+	} | undefined;
+	override uniqueVersionOfGen = GenerateUniqueStringV2;
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		let minStringLength = 7;
+		let maxStringLength = 20;
+		if (this.typeParams?.length !== undefined) {
+			maxStringLength = this.typeParams?.length;
+			if (maxStringLength === 1) minStringLength = maxStringLength;
+			if (maxStringLength < minStringLength) minStringLength = 1;
+		}
+
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng, minStringLength, maxStringLength };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const minStringLength = this.state.minStringLength,
+			maxStringLength = this.state.maxStringLength;
+		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+		let idx: number,
+			strLength: number,
+			currStr: string;
+
+		currStr = '';
+		[strLength, this.state.rng] = prand.uniformIntDistribution(
+			minStringLength,
+			maxStringLength,
+			this.state.rng,
+		);
+		for (let j = 0; j < strLength; j++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+			currStr += stringChars[idx];
+		}
+
+		if (this.dataType === 'object') return Buffer.from(currStr);
+		return currStr;
+	}
+}
+
+export class GenerateUniqueStringV2 extends AbstractGenerator<{ isUnique?: boolean }> {
+	static override readonly 'entityKind': string = 'GenerateUniqueString';
+	static override readonly version: number = 2;
+
+	private state: {
+		rng: prand.RandomGenerator;
+		minStringLength: number;
+		maxStringLength: number;
+	} | undefined;
+	public override isGeneratorUnique = true;
+	public maxStringLength: number = 20;
+	public minStringLength: number = 7;
+
+	override getMaxUniqueCount(): number {
+		if (this.maxUniqueCount >= 0) return this.maxUniqueCount;
+
+		this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+		this.maxUniqueCount = Number.parseInt('f'.repeat(this.maxStringLength), 16);
+		return this.maxUniqueCount;
+	}
+
+	override init({ seed, count }: { seed: number; count: number }) {
+		const rng = prand.xoroshiro128plus(seed);
+
+		// TODO: revise later
+		this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+		if (this.maxStringLength === 1 || this.maxStringLength < this.minStringLength) {
+			this.minStringLength = this.maxStringLength;
+		}
+
+		if (count > this.getMaxUniqueCount()) {
+			throw new Error(
+				`You can't generate ${count} unique strings, with a maximum string length of ${this.maxStringLength}.`,
+			);
+		}
+
+		this.state = { rng, minStringLength: this.minStringLength, maxStringLength: this.maxStringLength };
+	}
+
+	generate({ i }: { i: number }) {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+
+		const minStringLength = this.state.minStringLength,
+			maxStringLength = this.state.maxStringLength;
+		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+		let idx: number,
+			strLength: number;
+		let currStr: string;
+
+		currStr = '';
+		const uniqueStr = i.toString(16);
+		[strLength, this.state.rng] = prand.uniformIntDistribution(
+			minStringLength,
+			maxStringLength - uniqueStr.length,
+			this.state.rng,
+		);
+		for (let j = 0; j < strLength - uniqueStr.length; j++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+			currStr += stringChars[idx];
+		}
+
+		if (this.dataType === 'object') return Buffer.from(uniqueStr + currStr);
+		return uniqueStr + currStr;
+	}
+}
diff --git a/drizzle-seed/src/generators/versioning/v3.ts b/drizzle-seed/src/generators/versioning/v3.ts
new file mode 100644
index 0000000000..4b3ec45219
--- /dev/null
+++ b/drizzle-seed/src/generators/versioning/v3.ts
@@ -0,0 +1,24 @@
+import { AbstractGenerator } from '../Generators.ts';
+
+/* eslint-disable drizzle-internal/require-entity-kind */
+export class GenerateHashFromStringV3 extends AbstractGenerator<{}> {
+	static override readonly entityKind: string = 'GenerateHashFromString';
+	static override readonly version: number = 3;
+
+	override init() {}
+	generate({ input }: { i: number; input: string }) {
+		let hash = 0n;
+		// p and m are prime numbers
+		const p = 53n;
+		const m = 28871271685163n; // < 2^53
+
+		let power = 1n; // will track p^i, where i is character index
+
+		for (const ch of input) {
+			hash = (hash + (BigInt(ch.codePointAt(0) || 0) * power)) % m;
+			power = (power * p) % m;
+		}
+
+		return Number(hash);
+	}
+}
diff --git a/drizzle-seed/src/generators/versioning/v4.ts b/drizzle-seed/src/generators/versioning/v4.ts
new file mode 100644
index 0000000000..df2f17f4f3
--- /dev/null
+++ b/drizzle-seed/src/generators/versioning/v4.ts
@@ -0,0 +1,62 @@
+import prand from 'pure-rand';
+import { AbstractGenerator } from '../Generators.ts';
+
+/* eslint-disable drizzle-internal/require-entity-kind */
+export class GenerateUUIDV4 extends AbstractGenerator<{
+	arraySize?: number;
+}> {
+	static override readonly entityKind: string = 'GenerateUUID';
+	static override readonly version: number = 4;
+
+	public override isGeneratorUnique = true;
+	public override maxUniqueCount: number = Number.POSITIVE_INFINITY;
+
+	private state: { rng: prand.RandomGenerator } | undefined;
+
+	override getMaxUniqueCount(): number {
+		return Number.POSITIVE_INFINITY;
+	}
+
+	override init({ count, seed }: { count: number; seed: number }) {
+		super.init({ count, seed });
+
+		const rng = prand.xoroshiro128plus(seed);
+		this.state = { rng };
+	}
+
+	generate() {
+		if (this.state === undefined) {
+			throw new Error('state is not defined.');
+		}
+		// TODO generate uuid using string generator
+		const stringChars = '1234567890abcdef';
+		let idx: number,
+			currStr: string;
+		const strLength = 36;
+
+		// uuid v4
+		const uuidTemplate = '########-####-4###-N###-############';
+		currStr = '';
+		for (let i = 0; i < strLength; i++) {
+			[idx, this.state.rng] = prand.uniformIntDistribution(
+				0,
+				stringChars.length - 1,
+				this.state.rng,
+			);
+
+			if (uuidTemplate[i] === '#') {
+				currStr += stringChars[idx];
+				continue;
+			}
+
+			// used this pr -> https://github.com/drizzle-team/drizzle-orm/pull/4503
+			if (uuidTemplate[i] === 'N') {
+				currStr += '89ab'[idx % 4];
+				continue;
+			}
+
+			currStr += uuidTemplate[i];
+		}
+		return currStr;
+	}
+}
diff --git a/drizzle-seed/src/index.ts b/drizzle-seed/src/index.ts
index a56134ac32..c307365d7a 100644
--- a/drizzle-seed/src/index.ts
+++ b/drizzle-seed/src/index.ts
@@ -1,146 +1,103 @@
 /* eslint-disable drizzle-internal/require-entity-kind */
-import {
-	createTableRelationsHelpers,
-	extractTablesRelationalConfig,
-	getTableName,
-	is,
-	One,
-	Relations,
-	sql,
-} from 'drizzle-orm';
+import { is } from 'drizzle-orm';
+import type { Relations } from 'drizzle-orm/_relations';
 
-import type { MySqlColumn, MySqlSchema } from 'drizzle-orm/mysql-core';
-import { getTableConfig as getMysqlTableConfig, MySqlDatabase, MySqlTable } from 'drizzle-orm/mysql-core';
+import type { MySqlColumn, MySqlSchema, MySqlTable } from 'drizzle-orm/mysql-core';
+import { MySqlAsyncDatabase } from 'drizzle-orm/mysql-core';
 
-import type { PgArray, PgColumn, PgSchema } from 'drizzle-orm/pg-core';
-import { getTableConfig as getPgTableConfig, PgDatabase, PgTable } from 'drizzle-orm/pg-core';
+import type { PgColumn, PgSchema, PgTable } from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async';
 
-import type { SQLiteColumn } from 'drizzle-orm/sqlite-core';
-import { BaseSQLiteDatabase, getTableConfig as getSqliteTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SQLiteColumn, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { SQLiteAsyncDatabase } from 'drizzle-orm/sqlite-core';
 
-import { generatorsFuncs, generatorsFuncsV2 } from './services/GeneratorFuncs.ts';
-import type { AbstractGenerator } from './services/Generators.ts';
-import { SeedService } from './services/SeedService.ts';
-import type { DrizzleStudioObjectType, DrizzleStudioRelationType } from './types/drizzleStudio.ts';
-import type { RefinementsType } from './types/seedService.ts';
-import type { Column, Relation, RelationWithReferences, Table } from './types/tables.ts';
+import type { MsSqlColumn, MsSqlSchema, MsSqlTable } from 'drizzle-orm/mssql-core';
+import { MsSqlDatabase } from 'drizzle-orm/mssql-core';
 
-type InferCallbackType<
-	DB extends
-		| PgDatabase<any, any>
-		| MySqlDatabase<any, any>
-		| BaseSQLiteDatabase<any, any>,
-	SCHEMA extends {
-		[key: string]: PgTable | PgSchema | MySqlTable | MySqlSchema | SQLiteTable | Relations;
-	},
-> = DB extends PgDatabase<any, any> ? SCHEMA extends {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations;
-	} ? {
-			// iterates through schema fields. example -> schema: {"tableName": PgTable}
-			[
-				table in keyof SCHEMA as SCHEMA[table] extends PgTable ? table
-					: never
-			]?: {
-				count?: number;
-				columns?: {
-					// iterates through table fields. example -> table: {"columnName": PgColumn}
-					[
-						column in keyof SCHEMA[table] as SCHEMA[table][column] extends PgColumn ? column
-							: never
-					]?: AbstractGenerator<any>;
-				};
-				with?: {
-					[
-						refTable in keyof SCHEMA as SCHEMA[refTable] extends PgTable ? refTable
-							: never
-					]?:
-						| number
-						| { weight: number; count: number | number[] }[];
-				};
-			};
-		}
-	: {}
-	: DB extends MySqlDatabase<any, any> ? SCHEMA extends {
-			[key: string]:
-				| PgTable
-				| PgSchema
-				| MySqlTable
-				| MySqlSchema
-				| SQLiteTable
-				| Relations;
-		} ? {
-				// iterates through schema fields. example -> schema: {"tableName": MySqlTable}
+import type { CockroachColumn, CockroachSchema, CockroachTable } from 'drizzle-orm/cockroach-core';
+import { CockroachDatabase } from 'drizzle-orm/cockroach-core';
+
+import type { SingleStoreColumn, SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
+
+import { filterCockroachSchema, resetCockroach, seedCockroach } from './cockroach-core/index.ts';
+import {
+	generatorsFuncs,
+	generatorsFuncsV2,
+	type generatorsFuncsV3,
+	type generatorsFuncsV4,
+} from './generators/GeneratorFuncs.ts';
+import type { AbstractGenerator } from './generators/Generators.ts';
+import { filterMsSqlTables, resetMsSql, seedMsSql } from './mssql-core/index.ts';
+import { filterMysqlTables, resetMySql, seedMySql } from './mysql-core/index.ts';
+import { filterPgSchema, resetPostgres, seedPostgres } from './pg-core/index.ts';
+import { SeedService } from './SeedService.ts';
+import { filterSingleStoreTables, resetSingleStore, seedSingleStore } from './singlestore-core/index.ts';
+import { filterSqliteTables, resetSqlite, seedSqlite } from './sqlite-core/index.ts';
+import type { DrizzleStudioObjectType, DrizzleStudioRelationType } from './types/drizzleStudio.ts';
+import type { DbType, RefinementsType } from './types/seedService.ts';
+import type { Relation, Table } from './types/tables.ts';
+
+type SchemaValuesType =
+	| PgTable
+	| PgSchema
+	| MySqlTable
+	| MySqlSchema
+	| SQLiteTable
+	| MsSqlTable
+	| MsSqlSchema
+	| CockroachTable
+	| CockroachSchema
+	| SingleStoreTable
+	| SingleStoreSchema
+	| Relations
+	| any;
+
+export type RefineTypes<SCHEMA, TableT, ColumnT> = SCHEMA extends {
+	[key: string]: SchemaValuesType;
+} ? {
+		// iterates through schema fields. example -> schema: {"tableName": PgTable}
+		[
+			fieldName in keyof SCHEMA as SCHEMA[fieldName] extends TableT ? fieldName
+				: never
+		]?: {
+			count?: number;
+			columns?: {
+				// iterates through table fields. example -> table: {"columnName": PgColumn}
 				[
-					table in keyof SCHEMA as SCHEMA[table] extends MySqlTable ? table
+					column in keyof SCHEMA[fieldName] as SCHEMA[fieldName][column] extends ColumnT ? column
 						: never
-				]?: {
-					count?: number;
-					columns?: {
-						// iterates through table fields. example -> table: {"columnName": MySqlColumn}
-						[
-							column in keyof SCHEMA[table] as SCHEMA[table][column] extends MySqlColumn ? column
-								: never
-						]?: AbstractGenerator<any>;
-					};
-					with?: {
-						[
-							refTable in keyof SCHEMA as SCHEMA[refTable] extends MySqlTable ? refTable
-								: never
-						]?:
-							| number
-							| { weight: number; count: number | number[] }[];
-					};
-				};
-			}
-		: {}
-	: DB extends BaseSQLiteDatabase<any, any> ? SCHEMA extends {
-			[key: string]:
-				| PgTable
-				| PgSchema
-				| MySqlTable
-				| MySqlSchema
-				| SQLiteTable
-				| Relations;
-		} ? {
-				// iterates through schema fields. example -> schema: {"tableName": SQLiteTable}
+				]?: AbstractGenerator<any> | false;
+			};
+			with?: {
 				[
-					table in keyof SCHEMA as SCHEMA[table] extends SQLiteTable ? table
+					refTable in keyof SCHEMA as SCHEMA[refTable] extends TableT ? refTable
 						: never
-				]?: {
-					count?: number;
-					columns?: {
-						// iterates through table fields. example -> table: {"columnName": SQLiteColumn}
-						[
-							column in keyof SCHEMA[table] as SCHEMA[table][column] extends SQLiteColumn ? column
-								: never
-						]?: AbstractGenerator<any>;
-					};
-					with?: {
-						[
-							refTable in keyof SCHEMA as SCHEMA[refTable] extends SQLiteTable ? refTable
-								: never
-						]?:
-							| number
-							| { weight: number; count: number | number[] }[];
-					};
-				};
-			}
-		: {}
+				]?:
+					| number
+					| { weight: number; count: number | number[] }[];
+			};
+		};
+	}
+	: {};
+
+export type InferCallbackType<
+	DB extends DbType,
+	SCHEMA extends {
+		[key: string]: SchemaValuesType;
+	},
+> = DB extends PgAsyncDatabase<any, any> ? RefineTypes<SCHEMA, PgTable, PgColumn>
+	: DB extends MySqlAsyncDatabase<any, any> ? RefineTypes<SCHEMA, MySqlTable, MySqlColumn>
+	: DB extends SQLiteAsyncDatabase<any, any> ? RefineTypes<SCHEMA, SQLiteTable, SQLiteColumn>
+	: DB extends MsSqlDatabase<any, any> ? RefineTypes<SCHEMA, MsSqlTable, MsSqlColumn>
+	: DB extends CockroachDatabase<any, any> ? RefineTypes<SCHEMA, CockroachTable, CockroachColumn>
+	: DB extends SingleStoreDatabase<any, any> ? RefineTypes<SCHEMA, SingleStoreTable, SingleStoreColumn>
 	: {};
 
 class SeedPromise<
-	DB extends
-		| PgDatabase<any, any>
-		| MySqlDatabase<any, any>
-		| BaseSQLiteDatabase<any, any>,
+	DB extends DbType,
 	SCHEMA extends {
-		[key: string]: PgTable | PgSchema | MySqlTable | MySqlSchema | SQLiteTable | Relations;
+		[key: string]: SchemaValuesType;
 	},
 	VERSION extends string | undefined,
 > implements Promise<void> {
@@ -205,9 +162,12 @@ class SeedPromise<
 	}
 }
 
-type FunctionsVersioning<VERSION extends string | undefined> = VERSION extends `1` ? typeof generatorsFuncs
+export type FunctionsVersioning<VERSION extends string | undefined = undefined> = VERSION extends `1`
+	? typeof generatorsFuncs
 	: VERSION extends `2` ? typeof generatorsFuncsV2
-	: typeof generatorsFuncsV2;
+	: VERSION extends `3` ? typeof generatorsFuncsV3
+	: VERSION extends `4` ? typeof generatorsFuncsV4
+	: typeof generatorsFuncsV4;
 
 export function getGeneratorsFunctions() {
 	return generatorsFuncs;
@@ -215,7 +175,7 @@ export function getGeneratorsFunctions() {
 
 export async function seedForDrizzleStudio(
 	{ sqlDialect, drizzleStudioObject, drizzleStudioRelations, schemasRefinements, options }: {
-		sqlDialect: 'postgresql' | 'mysql' | 'sqlite';
+		sqlDialect: 'postgresql' | 'mysql' | 'sqlite' | 'mssql' | 'cockroach' | 'singlestore';
 		drizzleStudioObject: DrizzleStudioObjectType;
 		drizzleStudioRelations: DrizzleStudioRelationType[];
 		schemasRefinements?: { [schemaName: string]: RefinementsType };
@@ -256,6 +216,7 @@ export async function seedForDrizzleStudio(
 					name: tableName,
 					columns,
 					primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
+					uniqueConstraints: [], // TODO change later
 				},
 			);
 		}
@@ -290,7 +251,12 @@ export async function seedForDrizzleStudio(
 			undefined,
 			undefined,
 			{ ...options, preserveData: true, insertDataInDb: false },
-		);
+		) as {
+			tableName: string;
+			rows: {
+				[columnName: string]: string | number | boolean | undefined;
+			}[];
+		}[];
 
 		generatedSchemas[schemaName] = { tables: generatedTables };
 	}
@@ -320,7 +286,7 @@ export async function seedForDrizzleStudio(
  * // seeding with count and seed specified
  * await seed(db, schema, { count: 100000, seed: 1 });
  *
- * //seeding using refine
+ * // seeding using refine
  * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  *   users: {
  *     columns: {
@@ -341,39 +307,33 @@ export async function seedForDrizzleStudio(
  *   },
  * }));
  *
+ * // seeding while ignoring column
+ * await seed(db, schema).refine((funcs) => ({
+ *   users: {
+ *     count: 5,
+ *     columns: {
+ *       name: funcs.fullName(),
+ *       photo: false, // the photo column will not be seeded, allowing the database to use its default value.
+ *     },
+ *   },
+ * }));
+ *
  * ```
  */
 export function seed<
-	DB extends
-		| PgDatabase<any, any>
-		| MySqlDatabase<any, any, any, any>
-		| BaseSQLiteDatabase<any, any>,
+	DB extends DbType,
 	SCHEMA extends {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations
-			| any;
+		[key: string]: SchemaValuesType;
 	},
-	VERSION extends '2' | '1' | undefined,
+	VERSION extends '4' | '3' | '2' | '1' | undefined,
 >(db: DB, schema: SCHEMA, options?: { count?: number; seed?: number; version?: VERSION }) {
 	return new SeedPromise<typeof db, typeof schema, VERSION>(db, schema, options);
 }
 
 const seedFunc = async (
-	db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>,
+	db: DbType,
 	schema: {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations
-			| any;
+		[key: string]: SchemaValuesType;
 	},
 	options: { count?: number; seed?: number; version?: string } = {},
 	refinements?: RefinementsType,
@@ -383,15 +343,21 @@ const seedFunc = async (
 		version = Number(options?.version);
 	}
 
-	if (is(db, PgDatabase<any, any>)) {
+	if (is(db, PgAsyncDatabase<any, any>)) {
 		await seedPostgres(db, schema, { ...options, version }, refinements);
-	} else if (is(db, MySqlDatabase<any, any>)) {
+	} else if (is(db, MySqlAsyncDatabase<any, any>)) {
 		await seedMySql(db, schema, { ...options, version }, refinements);
-	} else if (is(db, BaseSQLiteDatabase<any, any>)) {
+	} else if (is(db, SQLiteAsyncDatabase<any, any>)) {
 		await seedSqlite(db, schema, { ...options, version }, refinements);
+	} else if (is(db, MsSqlDatabase<any, any>)) {
+		await seedMsSql(db, schema, { ...options, version }, refinements);
+	} else if (is(db, CockroachDatabase<any, any>)) {
+		await seedCockroach(db, schema, { ...options, version }, refinements);
+	} else if (is(db, SingleStoreDatabase<any, any>)) {
+		await seedSingleStore(db, schema, { ...options, version }, refinements);
 	} else {
 		throw new Error(
-			'The drizzle-seed package currently supports only PostgreSQL, MySQL, and SQLite databases. Please ensure your database is one of these supported types',
+			'The drizzle-seed package currently supports only PostgreSQL, MySQL, SQLite, Ms Sql, CockroachDB and SingleStore databases. Please ensure your database is one of these supported types',
 		);
 	}
 
@@ -409,7 +375,7 @@ const seedFunc = async (
  * truncate tableName1, tableName2, ... cascade;
  * ```
  *
- * `If db is a MySqlDatabase object`, we will execute sql queries and delete data from your tables the following way:
+ * `If db is a MySqlAsyncDatabase object`, we will execute sql queries and delete data from your tables the following way:
  * ```sql
  * SET FOREIGN_KEY_CHECKS = 0;
  * truncate tableName1;
@@ -421,7 +387,7 @@ const seedFunc = async (
  * SET FOREIGN_KEY_CHECKS = 1;
  * ```
  *
- * `If db is a BaseSQLiteDatabase object`, we will execute sql queries and delete data from your tables the following way:
+ * `If db is a SQLiteAsyncDatabase object`, we will execute sql queries and delete data from your tables the following way:
  * ```sql
  * PRAGMA foreign_keys = OFF;
  * delete from tableName1;
@@ -436,1073 +402,63 @@ const seedFunc = async (
  * @example
  * ```ts
  * await reset(db, schema);
+ *
+ * // Alternatively, you can provide an object containing your tables
+ * // as the `schema` parameter when calling `reset`.
+ * await reset(db, { users });
  * ```
  */
 export async function reset<
-	DB extends
-		| PgDatabase<any, any>
-		| MySqlDatabase<any, any, any, any>
-		| BaseSQLiteDatabase<any, any>,
+	DB extends DbType,
 	SCHEMA extends {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| any;
+		[key: string]: SchemaValuesType;
 	},
 >(db: DB, schema: SCHEMA) {
-	if (is(db, PgDatabase<any, any>)) {
+	if (is(db, PgAsyncDatabase<any, any>)) {
 		const { pgTables } = filterPgSchema(schema);
 
 		if (Object.entries(pgTables).length > 0) {
 			await resetPostgres(db, pgTables);
 		}
-	} else if (is(db, MySqlDatabase<any, any>)) {
+	} else if (is(db, MySqlAsyncDatabase<any, any>)) {
 		const { mysqlTables } = filterMysqlTables(schema);
 
 		if (Object.entries(mysqlTables).length > 0) {
 			await resetMySql(db, mysqlTables);
 		}
-	} else if (is(db, BaseSQLiteDatabase<any, any>)) {
+	} else if (is(db, SQLiteAsyncDatabase<any, any>)) {
 		const { sqliteTables } = filterSqliteTables(schema);
 
 		if (Object.entries(sqliteTables).length > 0) {
 			await resetSqlite(db, sqliteTables);
 		}
-	} else {
-		throw new Error(
-			'The drizzle-seed package currently supports only PostgreSQL, MySQL, and SQLite databases. Please ensure your database is one of these supported types',
-		);
-	}
-}
-
-// Postgres-----------------------------------------------------------------------------------------------------------
-const resetPostgres = async (
-	db: PgDatabase<any, any>,
-	pgTables: { [key: string]: PgTable },
-) => {
-	const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
-		const config = getPgTableConfig(table);
-		config.schema = config.schema === undefined ? 'public' : config.schema;
-
-		return `"${config.schema}"."${config.name}"`;
-	});
-
-	await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
-};
-
-const filterPgSchema = (schema: {
-	[key: string]:
-		| PgTable
-		| PgSchema
-		| MySqlTable
-		| MySqlSchema
-		| SQLiteTable
-		| Relations
-		| any;
-}) => {
-	const pgSchema = Object.fromEntries(
-		Object.entries(schema).filter((keyValue): keyValue is [string, PgTable | Relations] =>
-			is(keyValue[1], PgTable) || is(keyValue[1], Relations)
-		),
-	);
-
-	const pgTables = Object.fromEntries(
-		Object.entries(schema).filter((keyValue): keyValue is [string, PgTable] => is(keyValue[1], PgTable)),
-	);
-
-	return { pgSchema, pgTables };
-};
-
-const seedPostgres = async (
-	db: PgDatabase<any, any>,
-	schema: {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations
-			| any;
-	},
-	options: { count?: number; seed?: number; version?: number } = {},
-	refinements?: RefinementsType,
-) => {
-	const seedService = new SeedService();
-
-	const { pgSchema, pgTables } = filterPgSchema(schema);
-
-	const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
-	const generatedTablesGenerators = seedService.generatePossibleGenerators(
-		'postgresql',
-		tables,
-		relations,
-		refinements,
-		options,
-	);
-
-	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-
-	const tablesValues = await seedService.generateTablesValues(
-		relations,
-		generatedTablesGenerators,
-		db,
-		pgTables,
-		{ ...options, preserveCyclicTablesData },
-	);
-
-	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
-		generatedTablesGenerators,
-	);
-	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-
-	await seedService.generateTablesValues(
-		relations,
-		filteredTablesGenerators,
-		db,
-		pgTables,
-		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
-	);
-};
-
-const getPostgresInfo = (
-	pgSchema: { [key: string]: PgTable | Relations },
-	pgTables: { [key: string]: PgTable },
-) => {
-	let tableConfig: ReturnType<typeof getPgTableConfig>;
-	let dbToTsColumnNamesMap: { [key: string]: string };
-	const dbToTsTableNamesMap: { [key: string]: string } = Object.fromEntries(
-		Object.entries(pgTables).map(([key, value]) => [getTableName(value), key]),
-	);
-
-	const tables: Table[] = [];
-	const relations: RelationWithReferences[] = [];
-	const dbToTsColumnNamesMapGlobal: {
-		[tableName: string]: { [dbColumnName: string]: string };
-	} = {};
-	const tableRelations: { [tableName: string]: RelationWithReferences[] } = {};
-
-	const getDbToTsColumnNamesMap = (table: PgTable) => {
-		let dbToTsColumnNamesMap: { [dbColName: string]: string } = {};
-
-		const tableName = getTableName(table);
-		if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-			dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName]!;
-			return dbToTsColumnNamesMap;
-		}
-
-		const tableConfig = getPgTableConfig(table);
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
-		dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-
-		return dbToTsColumnNamesMap;
-	};
-
-	const transformFromDrizzleRelation = (
-		schema: Record<string, PgTable | Relations>,
-		getDbToTsColumnNamesMap: (table: PgTable) => {
-			[dbColName: string]: string;
-		},
-		tableRelations: {
-			[tableName: string]: RelationWithReferences[];
-		},
-	) => {
-		const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-		const relations: RelationWithReferences[] = [];
-		for (const table of Object.values(schemaConfig.tables)) {
-			if (table.relations === undefined) continue;
-
-			for (const drizzleRel of Object.values(table.relations)) {
-				if (!is(drizzleRel, One)) continue;
-
-				const tableConfig = getPgTableConfig(drizzleRel.sourceTable as PgTable);
-				const tableDbSchema = tableConfig.schema ?? 'public';
-				const tableDbName = tableConfig.name;
-				const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-
-				const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-				const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name] as string)
-					?? [];
-
-				const refTableConfig = getPgTableConfig(drizzleRel.referencedTable as PgTable);
-				const refTableDbSchema = refTableConfig.schema ?? 'public';
-				const refTableDbName = refTableConfig.name;
-				const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-					?? refTableDbName;
-
-				const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-				const refColumns = drizzleRel.config?.references.map((ref) =>
-					dbToTsColumnNamesMapForRefTable[ref.name] as string
-				)
-					?? [];
-
-				if (tableRelations[refTableTsName] === undefined) {
-					tableRelations[refTableTsName] = [];
-				}
-
-				const relation: RelationWithReferences = {
-					table: tableTsName,
-					columns,
-					refTable: refTableTsName,
-					refColumns,
-					refTableRels: tableRelations[refTableTsName],
-					type: 'one',
-				};
-
-				// do not add duplicate relation
-				if (
-					tableRelations[tableTsName]?.some((rel) =>
-						rel.table === relation.table
-						&& rel.refTable === relation.refTable
-					)
-				) {
-					console.warn(
-						`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-							+ `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-							+ `In this case, the foreign key constraint will be used.\n`,
-					);
-					continue;
-				}
-
-				relations.push(relation);
-				tableRelations[tableTsName]!.push(relation);
-			}
-		}
-		return relations;
-	};
-
-	for (const table of Object.values(pgTables)) {
-		tableConfig = getPgTableConfig(table);
-
-		dbToTsColumnNamesMap = {};
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
+	} else if (is(db, MsSqlDatabase<any, any>)) {
+		const { mssqlTables } = filterMsSqlTables(schema);
 
-		// might be empty list
-		const newRelations = tableConfig.foreignKeys.map((fk) => {
-			const table = dbToTsTableNamesMap[tableConfig.name] as string;
-			const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
-
-			const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
-				fk.reference().foreignTable,
-			);
-
-			if (tableRelations[refTable] === undefined) {
-				tableRelations[refTable] = [];
-			}
-			return {
-				table,
-				columns: fk
-					.reference()
-					.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
-				refTable,
-				refColumns: fk
-					.reference()
-					.foreignColumns.map(
-						(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
-					),
-				refTableRels: tableRelations[refTable],
-			};
-		});
-
-		relations.push(
-			...newRelations,
-		);
-
-		if (tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] === undefined) {
-			tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] = [];
+		if (Object.entries(mssqlTables).length > 0) {
+			await resetMsSql(db, mssqlTables);
 		}
-		tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
-
-		const getAllBaseColumns = (
-			baseColumn: PgArray<any, any>['baseColumn'] & { baseColumn?: PgArray<any, any>['baseColumn'] },
-		): Column['baseColumn'] => {
-			const baseColumnResult: Column['baseColumn'] = {
-				name: baseColumn.name,
-				columnType: baseColumn.getSQLType(),
-				typeParams: getTypeParams(baseColumn.getSQLType()),
-				dataType: baseColumn.dataType,
-				size: (baseColumn as PgArray<any, any>).size,
-				hasDefault: baseColumn.hasDefault,
-				enumValues: baseColumn.enumValues,
-				default: baseColumn.default,
-				isUnique: baseColumn.isUnique,
-				notNull: baseColumn.notNull,
-				primary: baseColumn.primary,
-				baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
-			};
-
-			return baseColumnResult;
-		};
-
-		const getTypeParams = (sqlType: string) => {
-			// get type params
-			const typeParams: Column['typeParams'] = {};
-
-			// handle dimensions
-			if (sqlType.includes('[')) {
-				const match = sqlType.match(/\[\w*]/g);
-				if (match) {
-					typeParams['dimensions'] = match.length;
-				}
-			}
-
-			if (
-				sqlType.startsWith('numeric')
-				|| sqlType.startsWith('decimal')
-				|| sqlType.startsWith('double precision')
-				|| sqlType.startsWith('real')
-			) {
-				const match = sqlType.match(/\((\d+), *(\d+)\)/);
-				if (match) {
-					typeParams['precision'] = Number(match[1]);
-					typeParams['scale'] = Number(match[2]);
-				}
-			} else if (
-				sqlType.startsWith('varchar')
-				|| sqlType.startsWith('bpchar')
-				|| sqlType.startsWith('char')
-				|| sqlType.startsWith('bit')
-				|| sqlType.startsWith('time')
-				|| sqlType.startsWith('timestamp')
-				|| sqlType.startsWith('interval')
-			) {
-				const match = sqlType.match(/\((\d+)\)/);
-				if (match) {
-					typeParams['length'] = Number(match[1]);
-				}
-			}
-
-			return typeParams;
-		};
-
-		// console.log(tableConfig.columns);
-		tables.push({
-			name: dbToTsTableNamesMap[tableConfig.name] as string,
-			columns: tableConfig.columns.map((column) => ({
-				name: dbToTsColumnNamesMap[column.name] as string,
-				columnType: column.getSQLType(),
-				typeParams: getTypeParams(column.getSQLType()),
-				dataType: column.dataType,
-				size: (column as PgArray<any, any>).size,
-				hasDefault: column.hasDefault,
-				default: column.default,
-				enumValues: column.enumValues,
-				isUnique: column.isUnique,
-				notNull: column.notNull,
-				primary: column.primary,
-				generatedIdentityType: column.generatedIdentity?.type,
-				baseColumn: ((column as PgArray<any, any>).baseColumn === undefined)
-					? undefined
-					: getAllBaseColumns((column as PgArray<any, any>).baseColumn),
-			})),
-			primaryKeys: tableConfig.columns
-				.filter((column) => column.primary)
-				.map((column) => dbToTsColumnNamesMap[column.name] as string),
-		});
-	}
-
-	const transformedDrizzleRelations = transformFromDrizzleRelation(pgSchema, getDbToTsColumnNamesMap, tableRelations);
-	relations.push(
-		...transformedDrizzleRelations,
-	);
-
-	const isCyclicRelations = relations.map(
-		(relI) => {
-			// if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
-			const tableRel = tableRelations[relI.table]!.find((relJ) => relJ.refTable === relI.refTable)!;
-			if (isRelationCyclic(relI)) {
-				tableRel['isCyclic'] = true;
-				return { ...relI, isCyclic: true };
-			}
-			tableRel['isCyclic'] = false;
-			return { ...relI, isCyclic: false };
-		},
-	);
-
-	return { tables, relations: isCyclicRelations, tableRelations };
-};
-
-const isRelationCyclic = (
-	startRel: RelationWithReferences,
-) => {
-	// self relation
-	if (startRel.table === startRel.refTable) return false;
-
-	// DFS
-	const targetTable = startRel.table;
-	const queue = [startRel];
-	let path: string[] = [];
-	while (queue.length !== 0) {
-		const currRel = queue.shift();
+	} else if (is(db, CockroachDatabase<any, any>)) {
+		const { cockroachTables } = filterCockroachSchema(schema);
 
-		if (path.includes(currRel!.table)) {
-			const idx = path.indexOf(currRel!.table);
-			path = path.slice(0, idx);
+		if (Object.entries(cockroachTables).length > 0) {
+			await resetCockroach(db, cockroachTables);
 		}
-		path.push(currRel!.table);
+	} else if (is(db, SingleStoreDatabase<any, any>)) {
+		const { singleStoreTables } = filterSingleStoreTables(schema);
 
-		for (const rel of currRel!.refTableRels) {
-			// self relation
-			if (rel.table === rel.refTable) continue;
-
-			if (rel.refTable === targetTable) return true;
-
-			// found cycle, but not the one we are looking for
-			if (path.includes(rel.refTable)) continue;
-			queue.unshift(rel);
+		if (Object.entries(singleStoreTables).length > 0) {
+			await resetSingleStore(db, singleStoreTables);
 		}
-	}
-
-	return false;
-};
-
-// MySql-----------------------------------------------------------------------------------------------------
-const resetMySql = async (
-	db: MySqlDatabase<any, any>,
-	schema: { [key: string]: MySqlTable },
-) => {
-	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
-		const dbTableName = getTableName(table);
-		return dbTableName;
-	});
-
-	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
-
-	for (const tableName of tablesToTruncate) {
-		const sqlQuery = `truncate \`${tableName}\`;`;
-		await db.execute(sql.raw(sqlQuery));
-	}
-
-	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
-};
-
-const filterMysqlTables = (schema: {
-	[key: string]:
-		| PgTable
-		| PgSchema
-		| MySqlTable
-		| MySqlSchema
-		| SQLiteTable
-		| any;
-}) => {
-	const mysqlSchema = Object.fromEntries(
-		Object.entries(schema).filter(
-			(keyValue): keyValue is [string, MySqlTable | Relations] =>
-				is(keyValue[1], MySqlTable) || is(keyValue[1], Relations),
-		),
-	);
-
-	const mysqlTables = Object.fromEntries(
-		Object.entries(schema).filter(
-			(keyValue): keyValue is [string, MySqlTable] => is(keyValue[1], MySqlTable),
-		),
-	);
-
-	return { mysqlSchema, mysqlTables };
-};
-
-const seedMySql = async (
-	db: MySqlDatabase<any, any>,
-	schema: {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations
-			| any;
-	},
-	options: { count?: number; seed?: number; version?: number } = {},
-	refinements?: RefinementsType,
-) => {
-	const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-	const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
-
-	const seedService = new SeedService();
-
-	const generatedTablesGenerators = seedService.generatePossibleGenerators(
-		'mysql',
-		tables,
-		relations,
-		refinements,
-		options,
-	);
-
-	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-
-	const tablesValues = await seedService.generateTablesValues(
-		relations,
-		generatedTablesGenerators,
-		db,
-		mysqlTables,
-		{ ...options, preserveCyclicTablesData },
-	);
-
-	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
-		generatedTablesGenerators,
-	);
-	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-
-	await seedService.generateTablesValues(
-		relations,
-		filteredTablesGenerators,
-		db,
-		mysqlTables,
-		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
-	);
-};
-
-const getMySqlInfo = (
-	mysqlSchema: { [key: string]: MySqlTable | Relations },
-	mysqlTables: { [key: string]: MySqlTable },
-) => {
-	let tableConfig: ReturnType<typeof getMysqlTableConfig>;
-	let dbToTsColumnNamesMap: { [key: string]: string };
-
-	const dbToTsTableNamesMap: { [key: string]: string } = Object.fromEntries(
-		Object.entries(mysqlTables).map(([key, value]) => [getTableName(value), key]),
-	);
-
-	const tables: Table[] = [];
-	const relations: RelationWithReferences[] = [];
-	const dbToTsColumnNamesMapGlobal: {
-		[tableName: string]: { [dbColumnName: string]: string };
-	} = {};
-	const tableRelations: { [tableName: string]: RelationWithReferences[] } = {};
-
-	const getDbToTsColumnNamesMap = (table: MySqlTable) => {
-		let dbToTsColumnNamesMap: { [dbColName: string]: string } = {};
-
-		const tableName = getTableName(table);
-		if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-			dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName]!;
-			return dbToTsColumnNamesMap;
-		}
-
-		const tableConfig = getMysqlTableConfig(table);
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
-		dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-
-		return dbToTsColumnNamesMap;
-	};
-
-	const transformFromDrizzleRelation = (
-		schema: Record<string, MySqlTable | Relations>,
-		getDbToTsColumnNamesMap: (table: MySqlTable) => {
-			[dbColName: string]: string;
-		},
-		tableRelations: {
-			[tableName: string]: RelationWithReferences[];
-		},
-	) => {
-		const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-		const relations: RelationWithReferences[] = [];
-		for (const table of Object.values(schemaConfig.tables)) {
-			if (table.relations === undefined) continue;
-
-			for (const drizzleRel of Object.values(table.relations)) {
-				if (!is(drizzleRel, One)) continue;
-
-				const tableConfig = getMysqlTableConfig(drizzleRel.sourceTable as MySqlTable);
-				const tableDbSchema = tableConfig.schema ?? 'public';
-				const tableDbName = tableConfig.name;
-				const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-
-				const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable as MySqlTable);
-				const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name] as string)
-					?? [];
-
-				const refTableConfig = getMysqlTableConfig(drizzleRel.referencedTable as MySqlTable);
-				const refTableDbSchema = refTableConfig.schema ?? 'public';
-				const refTableDbName = refTableConfig.name;
-				const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-					?? refTableDbName;
-
-				const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable as MySqlTable);
-				const refColumns = drizzleRel.config?.references.map((ref) =>
-					dbToTsColumnNamesMapForRefTable[ref.name] as string
-				)
-					?? [];
-
-				if (tableRelations[refTableTsName] === undefined) {
-					tableRelations[refTableTsName] = [];
-				}
-
-				const relation: RelationWithReferences = {
-					table: tableTsName,
-					columns,
-					refTable: refTableTsName,
-					refColumns,
-					refTableRels: tableRelations[refTableTsName],
-					type: 'one',
-				};
-
-				// do not add duplicate relation
-				if (
-					tableRelations[tableTsName]?.some((rel) =>
-						rel.table === relation.table
-						&& rel.refTable === relation.refTable
-					)
-				) {
-					console.warn(
-						`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-							+ `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-							+ `In this case, the foreign key constraint will be used.\n`,
-					);
-					continue;
-				}
-
-				relations.push(relation);
-				tableRelations[tableTsName]!.push(relation);
-			}
-		}
-		return relations;
-	};
-
-	for (const table of Object.values(mysqlTables)) {
-		tableConfig = getMysqlTableConfig(table);
-
-		dbToTsColumnNamesMap = {};
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
-
-		const newRelations = tableConfig.foreignKeys.map((fk) => {
-			const table = dbToTsTableNamesMap[tableConfig.name] as string;
-			const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
-			const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
-				fk.reference().foreignTable,
-			);
-
-			if (tableRelations[refTable] === undefined) {
-				tableRelations[refTable] = [];
-			}
-			return {
-				table,
-				columns: fk
-					.reference()
-					.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
-				refTable,
-				refColumns: fk
-					.reference()
-					.foreignColumns.map(
-						(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
-					),
-				refTableRels: tableRelations[refTable],
-			};
-		});
-		relations.push(
-			...newRelations,
-		);
-
-		if (tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] === undefined) {
-			tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] = [];
-		}
-		tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
-
-		const getTypeParams = (sqlType: string) => {
-			// get type params and set only type
-			const typeParams: Column['typeParams'] = {};
-
-			if (
-				sqlType.startsWith('decimal')
-				|| sqlType.startsWith('real')
-				|| sqlType.startsWith('double')
-				|| sqlType.startsWith('float')
-			) {
-				const match = sqlType.match(/\((\d+), *(\d+)\)/);
-				if (match) {
-					typeParams['precision'] = Number(match[1]);
-					typeParams['scale'] = Number(match[2]);
-				}
-			} else if (
-				sqlType.startsWith('char')
-				|| sqlType.startsWith('varchar')
-				|| sqlType.startsWith('binary')
-				|| sqlType.startsWith('varbinary')
-			) {
-				const match = sqlType.match(/\((\d+)\)/);
-				if (match) {
-					typeParams['length'] = Number(match[1]);
-				}
-			}
-
-			return typeParams;
-		};
-
-		tables.push({
-			name: dbToTsTableNamesMap[tableConfig.name] as string,
-			columns: tableConfig.columns.map((column) => ({
-				name: dbToTsColumnNamesMap[column.name] as string,
-				columnType: column.getSQLType(),
-				typeParams: getTypeParams(column.getSQLType()),
-				dataType: column.dataType,
-				hasDefault: column.hasDefault,
-				default: column.default,
-				enumValues: column.enumValues,
-				isUnique: column.isUnique,
-				notNull: column.notNull,
-				primary: column.primary,
-			})),
-			primaryKeys: tableConfig.columns
-				.filter((column) => column.primary)
-				.map((column) => dbToTsColumnNamesMap[column.name] as string),
-		});
-	}
-
-	const transformedDrizzleRelations = transformFromDrizzleRelation(
-		mysqlSchema,
-		getDbToTsColumnNamesMap,
-		tableRelations,
-	);
-	relations.push(
-		...transformedDrizzleRelations,
-	);
-
-	const isCyclicRelations = relations.map(
-		(relI) => {
-			const tableRel = tableRelations[relI.table]!.find((relJ) => relJ.refTable === relI.refTable)!;
-			if (isRelationCyclic(relI)) {
-				tableRel['isCyclic'] = true;
-				return { ...relI, isCyclic: true };
-			}
-			tableRel['isCyclic'] = false;
-			return { ...relI, isCyclic: false };
-		},
-	);
-
-	return { tables, relations: isCyclicRelations, tableRelations };
-};
-
-// Sqlite------------------------------------------------------------------------------------------------------------------------
-const resetSqlite = async (
-	db: BaseSQLiteDatabase<any, any>,
-	schema: { [key: string]: SQLiteTable },
-) => {
-	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
-		const dbTableName = getTableName(table);
-		return dbTableName;
-	});
-
-	await db.run(sql.raw('PRAGMA foreign_keys = OFF'));
-
-	for (const tableName of tablesToTruncate) {
-		const sqlQuery = `delete from \`${tableName}\`;`;
-		await db.run(sql.raw(sqlQuery));
-	}
-
-	await db.run(sql.raw('PRAGMA foreign_keys = ON'));
-};
-
-const filterSqliteTables = (schema: {
-	[key: string]:
-		| PgTable
-		| PgSchema
-		| MySqlTable
-		| MySqlSchema
-		| SQLiteTable
-		| any;
-}) => {
-	const sqliteSchema = Object.fromEntries(
-		Object.entries(schema).filter(
-			(keyValue): keyValue is [string, SQLiteTable | Relations] =>
-				is(keyValue[1], SQLiteTable) || is(keyValue[1], Relations),
-		),
-	);
-
-	const sqliteTables = Object.fromEntries(
-		Object.entries(schema).filter(
-			(keyValue): keyValue is [string, SQLiteTable] => is(keyValue[1], SQLiteTable),
-		),
-	);
-
-	return { sqliteSchema, sqliteTables };
-};
-
-const seedSqlite = async (
-	db: BaseSQLiteDatabase<any, any>,
-	schema: {
-		[key: string]:
-			| PgTable
-			| PgSchema
-			| MySqlTable
-			| MySqlSchema
-			| SQLiteTable
-			| Relations
-			| any;
-	},
-	options: { count?: number; seed?: number; version?: number } = {},
-	refinements?: RefinementsType,
-) => {
-	const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
-
-	const { tables, relations } = getSqliteInfo(sqliteSchema, sqliteTables);
-
-	const seedService = new SeedService();
-
-	const generatedTablesGenerators = seedService.generatePossibleGenerators(
-		'sqlite',
-		tables,
-		relations,
-		refinements,
-		options,
-	);
-
-	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-
-	const tablesValues = await seedService.generateTablesValues(
-		relations,
-		generatedTablesGenerators,
-		db,
-		sqliteTables,
-		{ ...options, preserveCyclicTablesData },
-	);
-
-	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
-		generatedTablesGenerators,
-	);
-	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-
-	await seedService.generateTablesValues(
-		relations,
-		filteredTablesGenerators,
-		db,
-		sqliteTables,
-		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
-	);
-};
-
-const getSqliteInfo = (
-	sqliteSchema: { [key: string]: SQLiteTable | Relations },
-	sqliteTables: { [key: string]: SQLiteTable },
-) => {
-	let tableConfig: ReturnType<typeof getSqliteTableConfig>;
-	let dbToTsColumnNamesMap: { [key: string]: string };
-	const dbToTsTableNamesMap: { [key: string]: string } = Object.fromEntries(
-		Object.entries(sqliteTables).map(([key, value]) => [getTableName(value), key]),
-	);
-
-	const tables: Table[] = [];
-	const relations: RelationWithReferences[] = [];
-	const dbToTsColumnNamesMapGlobal: {
-		[tableName: string]: { [dbColumnName: string]: string };
-	} = {};
-	const tableRelations: { [tableName: string]: RelationWithReferences[] } = {};
-
-	const getDbToTsColumnNamesMap = (table: SQLiteTable) => {
-		let dbToTsColumnNamesMap: { [dbColName: string]: string } = {};
-
-		const tableName = getTableName(table);
-		if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-			dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName]!;
-			return dbToTsColumnNamesMap;
-		}
-
-		const tableConfig = getSqliteTableConfig(table);
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
-		dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-
-		return dbToTsColumnNamesMap;
-	};
-
-	const transformFromDrizzleRelation = (
-		schema: Record<string, SQLiteTable | Relations>,
-		getDbToTsColumnNamesMap: (table: SQLiteTable) => {
-			[dbColName: string]: string;
-		},
-		tableRelations: {
-			[tableName: string]: RelationWithReferences[];
-		},
-	) => {
-		const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-		const relations: RelationWithReferences[] = [];
-		for (const table of Object.values(schemaConfig.tables)) {
-			if (table.relations === undefined) continue;
-
-			for (const drizzleRel of Object.values(table.relations)) {
-				if (!is(drizzleRel, One)) continue;
-
-				const tableConfig = getSqliteTableConfig(drizzleRel.sourceTable as SQLiteTable);
-				const tableDbName = tableConfig.name;
-				// TODO: tableNamesMap: have {public.customer: 'customer'} structure in sqlite
-				const tableTsName = schemaConfig.tableNamesMap[`public.${tableDbName}`] ?? tableDbName;
-
-				const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable as SQLiteTable);
-				const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name] as string)
-					?? [];
-
-				const refTableConfig = getSqliteTableConfig(drizzleRel.referencedTable as SQLiteTable);
-				const refTableDbName = refTableConfig.name;
-				const refTableTsName = schemaConfig.tableNamesMap[`public.${refTableDbName}`]
-					?? refTableDbName;
-
-				const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable as SQLiteTable);
-				const refColumns = drizzleRel.config?.references.map((ref) =>
-					dbToTsColumnNamesMapForRefTable[ref.name] as string
-				)
-					?? [];
-
-				if (tableRelations[refTableTsName] === undefined) {
-					tableRelations[refTableTsName] = [];
-				}
-
-				const relation: RelationWithReferences = {
-					table: tableTsName,
-					columns,
-					refTable: refTableTsName,
-					refColumns,
-					refTableRels: tableRelations[refTableTsName],
-					type: 'one',
-				};
-
-				// do not add duplicate relation
-				if (
-					tableRelations[tableTsName]?.some((rel) =>
-						rel.table === relation.table
-						&& rel.refTable === relation.refTable
-					)
-				) {
-					console.warn(
-						`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-							+ `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-							+ `In this case, the foreign key constraint will be used.\n`,
-					);
-					continue;
-				}
-
-				relations.push(relation);
-				tableRelations[tableTsName]!.push(relation);
-			}
-		}
-		return relations;
-	};
-
-	for (const table of Object.values(sqliteTables)) {
-		tableConfig = getSqliteTableConfig(table);
-
-		dbToTsColumnNamesMap = {};
-		for (const [tsCol, col] of Object.entries(tableConfig.columns[0]!.table)) {
-			dbToTsColumnNamesMap[col.name] = tsCol;
-		}
-
-		const newRelations = tableConfig.foreignKeys.map((fk) => {
-			const table = dbToTsTableNamesMap[tableConfig.name] as string;
-			const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
-			const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
-				fk.reference().foreignTable,
-			);
-
-			if (tableRelations[refTable] === undefined) {
-				tableRelations[refTable] = [];
-			}
-			return {
-				table,
-				columns: fk
-					.reference()
-					.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
-				refTable,
-				refColumns: fk
-					.reference()
-					.foreignColumns.map(
-						(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
-					),
-				refTableRels: tableRelations[refTable],
-			};
-		});
-
-		relations.push(
-			...newRelations,
+	} else {
+		throw new Error(
+			'The drizzle-seed package currently supports only PostgreSQL, MySQL, SQLite, Ms Sql, CockroachDB and SingleStore databases. Please ensure your database is one of these supported types',
 		);
-
-		if (tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] === undefined) {
-			tableRelations[dbToTsTableNamesMap[tableConfig.name] as string] = [];
-		}
-		tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
-
-		const getTypeParams = (sqlType: string) => {
-			// get type params and set only type
-			const typeParams: Column['typeParams'] = {};
-
-			if (
-				sqlType.startsWith('decimal')
-			) {
-				const match = sqlType.match(/\((\d+), *(\d+)\)/);
-				if (match) {
-					typeParams['precision'] = Number(match[1]);
-					typeParams['scale'] = Number(match[2]);
-				}
-			} else if (
-				sqlType.startsWith('char')
-				|| sqlType.startsWith('varchar')
-				|| sqlType.startsWith('text')
-			) {
-				const match = sqlType.match(/\((\d+)\)/);
-				if (match) {
-					typeParams['length'] = Number(match[1]);
-				}
-			}
-
-			return typeParams;
-		};
-
-		tables.push({
-			name: dbToTsTableNamesMap[tableConfig.name] as string,
-			columns: tableConfig.columns.map((column) => ({
-				name: dbToTsColumnNamesMap[column.name] as string,
-				columnType: column.getSQLType(),
-				typeParams: getTypeParams(column.getSQLType()),
-				dataType: column.dataType,
-				hasDefault: column.hasDefault,
-				default: column.default,
-				enumValues: column.enumValues,
-				isUnique: column.isUnique,
-				notNull: column.notNull,
-				primary: column.primary,
-			})),
-			primaryKeys: tableConfig.columns
-				.filter((column) => column.primary)
-				.map((column) => dbToTsColumnNamesMap[column.name] as string),
-		});
 	}
-
-	const transformedDrizzleRelations = transformFromDrizzleRelation(
-		sqliteSchema,
-		getDbToTsColumnNamesMap,
-		tableRelations,
-	);
-	relations.push(
-		...transformedDrizzleRelations,
-	);
-
-	const isCyclicRelations = relations.map(
-		(relI) => {
-			const tableRel = tableRelations[relI.table]!.find((relJ) => relJ.refTable === relI.refTable)!;
-			if (isRelationCyclic(relI)) {
-				tableRel['isCyclic'] = true;
-				return { ...relI, isCyclic: true };
-			}
-			tableRel['isCyclic'] = false;
-			return { ...relI, isCyclic: false };
-		},
-	);
-
-	return { tables, relations: isCyclicRelations, tableRelations };
-};
+}
 
 export { default as cities } from './datasets/cityNames.ts';
 export { default as countries } from './datasets/countries.ts';
 export { default as firstNames } from './datasets/firstNames.ts';
 export { default as lastNames } from './datasets/lastNames.ts';
-export { SeedService } from './services/SeedService.ts';
+export { SeedService } from './SeedService.ts';
diff --git a/drizzle-seed/src/mssql-core/index.ts b/drizzle-seed/src/mssql-core/index.ts
new file mode 100644
index 0000000000..0a81a70fc8
--- /dev/null
+++ b/drizzle-seed/src/mssql-core/index.ts
@@ -0,0 +1,255 @@
+import { type AnyColumn, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { MsSqlDatabase, MsSqlInt, MsSqlSchema } from 'drizzle-orm/mssql-core';
+import { getTableConfig, MsSqlTable } from 'drizzle-orm/mssql-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+type TableRelatedFkConstraintsT = {
+	[fkName: string]: {
+		fkName: string;
+		parentSchema: string;
+		parentTable: string;
+		referencedSchema: string;
+		referencedTable: string;
+		parentColumns: string[];
+		referencedColumns: string[];
+		onDeleteAction: string;
+		onUpdateAction: string;
+		relation: 'inbound' | 'outbound';
+	};
+};
+
+type AllFkConstraintsT = {
+	[tableIdentifier: string]: TableRelatedFkConstraintsT;
+};
+
+// MySql-----------------------------------------------------------------------------------------------------
+export const resetMsSql = async (
+	db: MsSqlDatabase<any, any>,
+	schema: { [key: string]: MsSqlTable },
+) => {
+	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+		const tableConfig = getTableConfig(table);
+		return { dbName: tableConfig.name, dbSchema: tableConfig.schema ?? 'dbo' };
+	});
+
+	const allFkConstraints: AllFkConstraintsT = {};
+
+	for (const table of tablesToTruncate) {
+		const gatherTableRelatedFkConstraints = `
+			DECLARE @objectId INT
+  			= OBJECT_ID( QUOTENAME('${table.dbSchema}') + '.' + QUOTENAME('${table.dbName}') );
+
+			SELECT
+			    fk.name                             AS fkName,
+			    OBJECT_SCHEMA_NAME(fk.parent_object_id)   AS parentSchema,
+			    OBJECT_NAME(fk.parent_object_id)         AS parentTable,
+			    OBJECT_SCHEMA_NAME(fk.referenced_object_id) AS referencedSchema,
+			    OBJECT_NAME(fk.referenced_object_id)       AS referencedTable,
+			--     fkc.constraint_column_id       AS Column_Ordinal,
+			    pc.name                        AS parentColumn,
+			    rc.name                        AS referencedColumn,
+			    fk.delete_referential_action_desc AS onDeleteAction,
+			    fk.update_referential_action_desc AS onUpdateAction,
+			    CASE
+			        WHEN fk.parent_object_id     = @objectId THEN 'outbound'  -- your table → another table
+			        ELSE 'inbound'                                           -- another table → your table
+			    END                                 AS relation
+			FROM sys.foreign_keys AS fk
+			JOIN sys.foreign_key_columns fkc
+			  ON fk.object_id = fkc.constraint_object_id
+			JOIN sys.columns             pc
+			  ON fkc.parent_object_id   = pc.object_id
+			 AND fkc.parent_column_id   = pc.column_id
+			JOIN sys.columns             rc
+			  ON fkc.referenced_object_id = rc.object_id
+			 AND fkc.referenced_column_id = rc.column_id
+			WHERE fk.parent_object_id     = @objectId
+			   OR fk.referenced_object_id = @objectId
+			ORDER BY relation, fkName;
+		`;
+		const rawRes = await db.execute(sql.raw(gatherTableRelatedFkConstraints));
+		const res: {
+			fkName: string;
+			parentSchema: string;
+			parentTable: string;
+			referencedSchema: string;
+			referencedTable: string;
+			parentColumn: string;
+			referencedColumn: string;
+			onDeleteAction: string;
+			onUpdateAction: string;
+			relation: 'inbound' | 'outbound';
+		}[] = rawRes.recordset;
+
+		const tableRelatedFkConstraints: TableRelatedFkConstraintsT = {};
+		for (const fkInfo of res) {
+			if (tableRelatedFkConstraints[fkInfo.fkName] === undefined) {
+				const { parentColumn: _, referencedColumn: __, ...filteredFkInfo } = fkInfo;
+				tableRelatedFkConstraints[fkInfo.fkName] = {
+					...filteredFkInfo,
+					parentColumns: res.filter(({ fkName }) => fkName === fkInfo.fkName).map(({ parentColumn }) => parentColumn),
+					referencedColumns: res.filter(({ fkName }) => fkName === fkInfo.fkName).map(({ referencedColumn }) =>
+						referencedColumn
+					),
+				};
+			}
+		}
+
+		allFkConstraints[`${table.dbSchema}.${table.dbName}`] = tableRelatedFkConstraints;
+
+		// drop all table related fk constraints
+		for (const fkInfo of Object.values(tableRelatedFkConstraints)) {
+			const dropFkConstraints =
+				`ALTER TABLE [${fkInfo.parentSchema}].[${fkInfo.parentTable}] DROP CONSTRAINT [${fkInfo.fkName}];`;
+			await db.execute(sql.raw(dropFkConstraints));
+		}
+
+		// truncating
+		const truncateTable = `truncate table [${table.dbSchema}].[${table.dbName}];`;
+		await db.execute(sql.raw(truncateTable));
+	}
+
+	// add all table related fk constraints
+	for (const table of tablesToTruncate) {
+		const tableRelatedFkConstraints = allFkConstraints[`${table.dbSchema}.${table.dbName}`]!;
+
+		for (const fkInfo of Object.values(tableRelatedFkConstraints)) {
+			const addFkConstraints = `
+				ALTER TABLE [${fkInfo.parentSchema}].[${fkInfo.parentTable}] 
+				ADD CONSTRAINT [${fkInfo.fkName}] 
+				FOREIGN KEY(${fkInfo.parentColumns.map((colName) => `[${colName}]`).join(',')})
+				REFERENCES [${fkInfo.referencedSchema}].[${fkInfo.referencedTable}] (${
+				fkInfo.referencedColumns.map((colName) => `[${colName}]`).join(',')
+			})
+				ON DELETE ${fkInfo.onDeleteAction.split('_').join(' ')}
+				ON UPDATE ${fkInfo.onUpdateAction.split('_').join(' ')};
+				`;
+			await db.execute(sql.raw(addFkConstraints));
+		}
+	}
+};
+
+export const filterMsSqlTables = (schema: {
+	[key: string]:
+		| MsSqlTable
+		| MsSqlSchema
+		| Relations
+		| any;
+}) => {
+	const mssqlSchema = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, MsSqlTable | Relations] =>
+				is(keyValue[1], MsSqlTable) || is(keyValue[1], Relations),
+		),
+	);
+
+	const mssqlTables = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, MsSqlTable] => is(keyValue[1], MsSqlTable),
+		),
+	);
+
+	return { mssqlSchema, mssqlTables };
+};
+
+export const seedMsSql = async (
+	db: MsSqlDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| MsSqlTable
+			| MsSqlSchema
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
+	const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlColumns);
+
+	const seedService = new SeedService();
+
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'mssql',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		mssqlTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		mssqlTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+
+const getTypeParams = (sqlType: string) => {
+	// get type params and set only type
+	const typeParams: Column['typeParams'] = {};
+
+	if (
+		sqlType.startsWith('decimal')
+		|| sqlType.startsWith('real')
+		|| sqlType.startsWith('float')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('char')
+		|| sqlType.startsWith('varchar')
+		|| sqlType.startsWith('binary')
+		|| sqlType.startsWith('varbinary')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	}
+
+	return typeParams;
+};
+
+const mapMsSqlColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	const mappedColumns = columns.map((column) => ({
+		name: dbToTsColumnNamesMap[column.name] as string,
+		columnType: column.getSQLType(),
+		typeParams: getTypeParams(column.getSQLType()),
+		dataType: column.dataType.split(' ')[0]!,
+		hasDefault: column.hasDefault,
+		default: column.default,
+		enumValues: column.enumValues,
+		isUnique: column.isUnique,
+		notNull: column.notNull,
+		primary: column.primary,
+		identity: (column as MsSqlInt<any>).identity ? true : false,
+	}));
+	return mappedColumns;
+};
diff --git a/drizzle-seed/src/mssql-core/selectGensForColumn.ts b/drizzle-seed/src/mssql-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..02296393d0
--- /dev/null
+++ b/drizzle-seed/src/mssql-core/selectGensForColumn.ts
@@ -0,0 +1,159 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { Column, Table } from '../types/tables.ts';
+
+export const selectGeneratorForMssqlColumn = (
+	table: Table,
+	col: Column,
+) => {
+	const pickGenerator = (table: Table, col: Column) => {
+		// INT ------------------------------------------------------------------------------------------------------------
+		if (
+			col.columnType.includes('int') && table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			return generator;
+		}
+
+		let minValue: number | bigint | undefined;
+		let maxValue: number | bigint | undefined;
+		if (col.columnType.includes('int')) {
+			if (col.columnType === 'tinyint') {
+				// 2^8 / 2 - 1, 1 bytes
+				// more like unsigned tinyint
+				minValue = 0;
+				maxValue = 255;
+			} else if (col.columnType === 'smallint') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -32768;
+				maxValue = 32767;
+			} else if (col.columnType === 'int') {
+				// 2^32 / 2 - 1, 4 bytes
+				minValue = -2147483648;
+				maxValue = 2147483647;
+			} else if (col.columnType === 'bigint') {
+				// 2^64 / 2 - 1, 8 bytes
+				minValue = BigInt('-9223372036854775808');
+				maxValue = BigInt('9223372036854775807');
+			}
+
+			const generator = new generatorsMap.GenerateInt[0]({
+				minValue,
+				maxValue,
+			});
+			return generator;
+		}
+
+		// NUMBER(real, decimal, numeric, float)
+		if (
+			col.columnType.startsWith('real')
+			|| col.columnType.startsWith('decimal')
+			|| col.columnType.startsWith('float')
+			|| col.columnType.startsWith('numeric')
+		) {
+			if (col.typeParams.precision !== undefined) {
+				const precision = col.typeParams.precision;
+				const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+				const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+				const generator = new generatorsMap.GenerateNumber[0]({
+					minValue: -maxAbsoluteValue,
+					maxValue: maxAbsoluteValue,
+					precision: Math.pow(10, scale),
+				});
+				return generator;
+			}
+
+			const generator = new generatorsMap.GenerateNumber[0]();
+			return generator;
+		}
+
+		// STRING
+		if (
+			(col.columnType === 'text'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateUniqueString[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'text'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('name')
+		) {
+			const generator = new generatorsMap.GenerateFirstName[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'text'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('email')
+		) {
+			const generator = new generatorsMap.GenerateEmail[0]();
+			return generator;
+		}
+
+		if (
+			col.columnType === 'text'
+			|| col.columnType.startsWith('char')
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('binary')
+			|| col.columnType.startsWith('varbinary')
+		) {
+			const generator = new generatorsMap.GenerateString[0]();
+			return generator;
+		}
+
+		// bit
+		if (col.columnType === 'bit') {
+			const generator = new generatorsMap.GenerateBoolean[0]();
+			return generator;
+		}
+
+		// DATE, TIME, TIMESTAMP, DATETIME, YEAR
+		if (col.columnType.includes('datetime')) {
+			const generator = new generatorsMap.GenerateDatetime[0]();
+			return generator;
+		}
+
+		if (col.columnType.includes('date')) {
+			const generator = new generatorsMap.GenerateDate[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'time') {
+			const generator = new generatorsMap.GenerateTime[0]();
+			return generator;
+		}
+
+		// JSON
+		if (col.columnType === 'json') {
+			const generator = new generatorsMap.GenerateJson[0]();
+			return generator;
+		}
+
+		if (col.hasDefault && col.default !== undefined) {
+			const generator = new generatorsMap.GenerateDefault[0]({
+				defaultValue: col.default,
+			});
+			return generator;
+		}
+
+		return;
+	};
+
+	const generator = pickGenerator(table, col);
+
+	return generator;
+};
diff --git a/drizzle-seed/src/mysql-core/index.ts b/drizzle-seed/src/mysql-core/index.ts
new file mode 100644
index 0000000000..b12e22ff3b
--- /dev/null
+++ b/drizzle-seed/src/mysql-core/index.ts
@@ -0,0 +1,149 @@
+import { type AnyColumn, getTableName, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { MySqlAsyncDatabase, MySqlSchema } from 'drizzle-orm/mysql-core';
+import { MySqlTable } from 'drizzle-orm/mysql-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+// MySql-----------------------------------------------------------------------------------------------------
+export const resetMySql = async (
+	db: MySqlAsyncDatabase<any, any>,
+	schema: { [key: string]: MySqlTable },
+) => {
+	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+		const dbTableName = getTableName(table);
+		return dbTableName;
+	});
+
+	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
+
+	for (const tableName of tablesToTruncate) {
+		const sqlQuery = `truncate \`${tableName}\`;`;
+		await db.execute(sql.raw(sqlQuery));
+	}
+
+	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
+};
+
+export const filterMysqlTables = (schema: {
+	[key: string]:
+		| MySqlTable
+		| MySqlSchema
+		| Relations
+		| any;
+}) => {
+	const mysqlSchema = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, MySqlTable | Relations] =>
+				is(keyValue[1], MySqlTable) || is(keyValue[1], Relations),
+		),
+	);
+
+	const mysqlTables = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, MySqlTable] => is(keyValue[1], MySqlTable),
+		),
+	);
+
+	return { mysqlSchema, mysqlTables };
+};
+
+export const seedMySql = async (
+	db: MySqlAsyncDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| MySqlTable
+			| MySqlSchema
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
+	const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlColumns);
+
+	const seedService = new SeedService();
+
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'mysql',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		mysqlTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		mysqlTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+const getTypeParams = (sqlType: string) => {
+	// get type params and set only type
+	const typeParams: Column['typeParams'] = {};
+
+	if (
+		sqlType.startsWith('decimal')
+		|| sqlType.startsWith('real')
+		|| sqlType.startsWith('double')
+		|| sqlType.startsWith('float')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('char')
+		|| sqlType.startsWith('varchar')
+		|| sqlType.startsWith('binary')
+		|| sqlType.startsWith('varbinary')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	}
+
+	return typeParams;
+};
+
+export const mapMySqlColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	const mappedColumns = columns.map((column) => ({
+		name: dbToTsColumnNamesMap[column.name] as string,
+		columnType: column.getSQLType(),
+		typeParams: getTypeParams(column.getSQLType()),
+		dataType: column.dataType.split(' ')[0]!,
+		hasDefault: column.hasDefault,
+		default: column.default,
+		enumValues: column.enumValues,
+		isUnique: column.isUnique,
+		notNull: column.notNull,
+		primary: column.primary,
+	}));
+
+	return mappedColumns;
+};
diff --git a/drizzle-seed/src/mysql-core/selectGensForColumn.ts b/drizzle-seed/src/mysql-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..cbc51c82a8
--- /dev/null
+++ b/drizzle-seed/src/mysql-core/selectGensForColumn.ts
@@ -0,0 +1,198 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { Column, Table } from '../types/tables.ts';
+
+export const selectGeneratorForMysqlColumn = (
+	table: Table,
+	col: Column,
+) => {
+	const pickGenerator = (table: Table, col: Column) => {
+		// INT ------------------------------------------------------------------------------------------------------------
+		if (
+			(col.columnType.includes('serial') || col.columnType.includes('int'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			return generator;
+		}
+
+		let minValue: number | bigint | undefined;
+		let maxValue: number | bigint | undefined;
+		if (col.columnType === 'serial') {
+			// 2^64 % 2 - 1, 8 bytes
+			minValue = BigInt(0);
+			maxValue = BigInt('9223372036854775807');
+		} else if (col.columnType.includes('int')) {
+			if (col.columnType === 'tinyint') {
+				// 2^8 / 2 - 1, 1 bytes
+				minValue = -128;
+				maxValue = 127;
+			} else if (col.columnType === 'smallint') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -32768;
+				maxValue = 32767;
+			} else if (col.columnType === 'mediumint') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -8388608;
+				maxValue = 8388607;
+			} else if (col.columnType === 'int') {
+				// 2^32 / 2 - 1, 4 bytes
+				minValue = -2147483648;
+				maxValue = 2147483647;
+			} else if (col.columnType === 'bigint') {
+				// 2^64 / 2 - 1, 8 bytes
+				minValue = BigInt('-9223372036854775808');
+				maxValue = BigInt('9223372036854775807');
+			}
+		}
+
+		if (col.columnType.includes('int')) {
+			const generator = new generatorsMap.GenerateInt[0]({
+				minValue,
+				maxValue,
+			});
+			return generator;
+		}
+
+		if (col.columnType.includes('serial')) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			generator.maxValue = maxValue;
+			return generator;
+		}
+
+		// NUMBER(real, double, decimal, float)
+		if (
+			col.columnType.startsWith('real')
+			|| col.columnType.startsWith('double')
+			|| col.columnType.startsWith('decimal')
+			|| col.columnType.startsWith('float')
+			|| col.columnType.startsWith('numeric')
+		) {
+			if (col.typeParams.precision !== undefined) {
+				const precision = col.typeParams.precision;
+				const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+				const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+				const generator = new generatorsMap.GenerateNumber[0]({
+					minValue: -maxAbsoluteValue,
+					maxValue: maxAbsoluteValue,
+					precision: Math.pow(10, scale),
+				});
+				return generator;
+			}
+
+			const generator = new generatorsMap.GenerateNumber[0]();
+			return generator;
+		}
+
+		// STRING
+		if (
+			(col.columnType === 'text'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateUniqueString[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'text'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('name')
+		) {
+			const generator = new generatorsMap.GenerateFirstName[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'text'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('email')
+		) {
+			const generator = new generatorsMap.GenerateEmail[0]();
+			return generator;
+		}
+
+		if (
+			col.columnType === 'text'
+			|| col.columnType === 'blob'
+			|| col.columnType.startsWith('char')
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('binary')
+			|| col.columnType.startsWith('varbinary')
+		) {
+			const generator = new generatorsMap.GenerateString[0]();
+			return generator;
+		}
+
+		// BOOLEAN
+		if (col.columnType === 'boolean') {
+			const generator = new generatorsMap.GenerateBoolean[0]();
+			return generator;
+		}
+
+		// DATE, TIME, TIMESTAMP, DATETIME, YEAR
+		if (col.columnType.includes('datetime')) {
+			const generator = new generatorsMap.GenerateDatetime[0]();
+			return generator;
+		}
+
+		if (col.columnType.includes('date')) {
+			const generator = new generatorsMap.GenerateDate[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'time') {
+			const generator = new generatorsMap.GenerateTime[0]();
+			return generator;
+		}
+
+		if (col.columnType.includes('timestamp')) {
+			const generator = new generatorsMap.GenerateTimestamp[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'year') {
+			const generator = new generatorsMap.GenerateYear[0]();
+			return generator;
+		}
+
+		// JSON
+		if (col.columnType === 'json') {
+			const generator = new generatorsMap.GenerateJson[0]();
+			return generator;
+		}
+
+		// ENUM
+		if (col.enumValues !== undefined) {
+			const generator = new generatorsMap.GenerateEnum[0]({
+				enumValues: col.enumValues,
+			});
+			return generator;
+		}
+
+		if (col.hasDefault && col.default !== undefined) {
+			const generator = new generatorsMap.GenerateDefault[0]({
+				defaultValue: col.default,
+			});
+			return generator;
+		}
+
+		return;
+	};
+
+	const generator = pickGenerator(table, col);
+
+	return generator;
+};
diff --git a/drizzle-seed/src/pg-core/index.ts b/drizzle-seed/src/pg-core/index.ts
new file mode 100644
index 0000000000..5d899209da
--- /dev/null
+++ b/drizzle-seed/src/pg-core/index.ts
@@ -0,0 +1,162 @@
+import { type AnyColumn, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { PgAsyncDatabase, PgColumn, PgSchema } from 'drizzle-orm/pg-core';
+import { getTableConfig, PgTable } from 'drizzle-orm/pg-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+// Postgres-----------------------------------------------------------------------------------------------------------
+export const resetPostgres = async (
+	db: PgAsyncDatabase<any, any>,
+	pgTables: { [key: string]: PgTable },
+) => {
+	const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
+		const config = getTableConfig(table);
+		config.schema = config.schema === undefined ? 'public' : config.schema;
+
+		return `"${config.schema}"."${config.name}"`;
+	});
+
+	await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
+};
+
+export const filterPgSchema = (schema: {
+	[key: string]:
+		| PgTable
+		| PgSchema
+		| Relations
+		| any;
+}) => {
+	const pgSchema = Object.fromEntries(
+		Object.entries(schema).filter((keyValue): keyValue is [string, PgTable | Relations] =>
+			is(keyValue[1], PgTable) || is(keyValue[1], Relations)
+		),
+	);
+
+	const pgTables = Object.fromEntries(
+		Object.entries(schema).filter((keyValue): keyValue is [string, PgTable] => is(keyValue[1], PgTable)),
+	);
+
+	return { pgSchema, pgTables };
+};
+
+export const seedPostgres = async (
+	db: PgAsyncDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| PgTable
+			| PgSchema
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const seedService = new SeedService();
+
+	const { pgSchema, pgTables } = filterPgSchema(schema);
+
+	const { tables, relations } = getSchemaInfo(pgSchema, pgTables, mapPgColumns);
+	// const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'postgresql',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		pgTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		pgTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+
+const getTypeParams = (sqlType: string) => {
+	// get type params
+	const typeParams: Column['typeParams'] = {};
+
+	if (
+		sqlType.startsWith('numeric')
+		|| sqlType.startsWith('decimal')
+		|| sqlType.startsWith('double precision')
+		|| sqlType.startsWith('real')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('varchar')
+		|| sqlType.startsWith('bpchar')
+		|| sqlType.startsWith('char')
+		|| sqlType.startsWith('bit')
+		|| sqlType.startsWith('vector')
+		|| sqlType.startsWith('time')
+		|| sqlType.startsWith('timestamp')
+		|| sqlType.startsWith('interval')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	}
+
+	return typeParams;
+};
+
+export const mapPgColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	return columns.map((column) => {
+		const pgCol = column as PgColumn;
+		const sqlType = column.getSQLType();
+
+		return {
+			name: dbToTsColumnNamesMap[column.name] as string,
+			columnType: sqlType,
+			typeParams: { ...getTypeParams(sqlType), dimensions: pgCol.dimensions },
+			dataType: column.dataType.split(' ')[0]!,
+			size: undefined, // we no longer support length for arrays
+			hasDefault: column.hasDefault,
+			default: column.default,
+			enumValues: column.enumValues,
+			isUnique: column.isUnique,
+			notNull: column.notNull,
+			primary: column.primary,
+			generatedIdentityType: column.generatedIdentity?.type,
+		} satisfies Column;
+	});
+};
+
+// const t = pgTable('a', { id: point('id', {mode: "xy"}).array() });
+// const config = getTableConfig(t);
+
+// const columns = mapPgColumns(config.columns, {});
+// console.log(columns)
+// const gen = selectGeneratorForPostgresColumn(columns[0]!, false);
+// gen.init({ count: 10, seed: 0 });
+
+// console.log(gen.generate({ i: 0 }));
diff --git a/drizzle-seed/src/pg-core/selectGensForColumn.ts b/drizzle-seed/src/pg-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..5577a006c8
--- /dev/null
+++ b/drizzle-seed/src/pg-core/selectGensForColumn.ts
@@ -0,0 +1,288 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { AbstractGenerator, GenerateInterval } from '../generators/Generators.ts';
+import type { Column } from '../types/tables.ts';
+
+const pickGenerator = (col: Column, isPrimaryKey: boolean) => {
+	// INT ------------------------------------------------------------------------------------------------------------
+	if (
+		(col.columnType.includes('serial')
+			|| col.columnType === 'integer'
+			|| col.columnType === 'smallint'
+			|| col.columnType.includes('bigint'))
+		&& isPrimaryKey
+	) {
+		const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+		return generator;
+	}
+
+	let minValue: number | bigint | undefined;
+	let maxValue: number | bigint | undefined;
+	if (col.columnType.includes('serial')) {
+		minValue = 1;
+		if (col.columnType === 'smallserial') {
+			// 2^16 / 2 - 1, 2 bytes
+			maxValue = 32767;
+		} else if (col.columnType === 'serial') {
+			// 2^32 / 2 - 1, 4 bytes
+			maxValue = 2147483647;
+		} else if (col.columnType === 'bigserial') {
+			// 2^64 / 2 - 1, 8 bytes
+			minValue = BigInt(1);
+			maxValue = BigInt('9223372036854775807');
+		}
+	} else if (col.columnType.includes('int')) {
+		if (col.columnType === 'smallint') {
+			// 2^16 / 2 - 1, 2 bytes
+			minValue = -32768;
+			maxValue = 32767;
+		} else if (col.columnType === 'integer') {
+			// 2^32 / 2 - 1, 4 bytes
+			minValue = -2147483648;
+			maxValue = 2147483647;
+		} else if (col.columnType.includes('bigint')) {
+			if (col.dataType === 'bigint') {
+				// 2^64 / 2 - 1, 8 bytes
+				minValue = BigInt('-9223372036854775808');
+				maxValue = BigInt('9223372036854775807');
+			} else {
+				// if (col.dataType === 'number')
+				// if you’re expecting values above 2^31 but below 2^53
+				minValue = -9007199254740991;
+				maxValue = 9007199254740991;
+			}
+		}
+	}
+
+	if (
+		col.columnType.includes('int')
+		&& !col.columnType.includes('interval')
+		&& !col.columnType.includes('point')
+	) {
+		const generator = new generatorsMap.GenerateInt[0]({
+			minValue,
+			maxValue,
+		});
+
+		return generator;
+	}
+
+	if (col.columnType.includes('serial')) {
+		const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+
+		generator.maxValue = maxValue;
+
+		return generator;
+	}
+
+	// NUMBER(real, double, decimal, numeric)
+	if (
+		col.columnType.startsWith('real')
+		|| col.columnType.startsWith('double precision')
+		|| col.columnType.startsWith('decimal')
+		|| col.columnType.startsWith('numeric')
+	) {
+		if (col.typeParams.precision !== undefined) {
+			const precision = col.typeParams.precision;
+			const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+			const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+			const generator = new generatorsMap.GenerateNumber[0]({
+				minValue: -maxAbsoluteValue,
+				maxValue: maxAbsoluteValue,
+				precision: Math.pow(10, scale),
+			});
+			return generator;
+		}
+		const generator = new generatorsMap.GenerateNumber[0]();
+
+		return generator;
+	}
+
+	// STRING
+	if (
+		(col.columnType === 'text'
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('char'))
+		&& isPrimaryKey
+	) {
+		const generator = new generatorsMap.GenerateUniqueString[0]();
+
+		return generator;
+	}
+
+	if (
+		(col.columnType === 'text'
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('char'))
+		&& col.name.toLowerCase().includes('name')
+	) {
+		const generator = new generatorsMap.GenerateFirstName[0]();
+
+		return generator;
+	}
+
+	if (
+		(col.columnType === 'text'
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('char'))
+		&& col.name.toLowerCase().includes('email')
+	) {
+		const generator = new generatorsMap.GenerateEmail[0]();
+
+		return generator;
+	}
+
+	if (
+		col.columnType === 'text'
+		|| col.columnType.startsWith('varchar')
+		|| col.columnType.startsWith('char')
+	) {
+		const generator = new generatorsMap.GenerateString[0]();
+
+		return generator;
+	}
+
+	// BIT
+	if (col.columnType.startsWith('bit')) {
+		const generator = new generatorsMap.GenerateBitString[0]();
+
+		return generator;
+	}
+
+	// INET
+	if (col.columnType === 'inet') {
+		const generator = new generatorsMap.GenerateInet[0]();
+
+		return generator;
+	}
+
+	// geometry(point)
+	if (col.columnType.startsWith('geometry')) {
+		const generator = new generatorsMap.GenerateGeometry[0]();
+
+		return generator;
+	}
+
+	// vector
+	if (col.columnType.startsWith('vector')) {
+		const generator = new generatorsMap.GenerateVector[0]();
+
+		return generator;
+	}
+
+	// UUID
+	if (col.columnType === 'uuid') {
+		const generator = new generatorsMap.GenerateUUID[0]();
+
+		return generator;
+	}
+
+	// BOOLEAN
+	if (col.columnType === 'boolean') {
+		const generator = new generatorsMap.GenerateBoolean[0]();
+
+		return generator;
+	}
+
+	// DATE, TIME, TIMESTAMP
+	if (col.columnType.includes('date')) {
+		const generator = new generatorsMap.GenerateDate[0]();
+
+		return generator;
+	}
+
+	if (col.columnType === 'time') {
+		const generator = new generatorsMap.GenerateTime[0]();
+
+		return generator;
+	}
+
+	if (col.columnType.includes('timestamp')) {
+		const generator = new generatorsMap.GenerateTimestamp[0]();
+
+		return generator;
+	}
+
+	// JSON, JSONB
+	if (col.columnType === 'json' || col.columnType === 'jsonb') {
+		const generator = new generatorsMap.GenerateJson[0]();
+
+		return generator;
+	}
+
+	// if (col.columnType === "jsonb") {
+	//   const generator = new GenerateJsonb({});
+	//   return generator;
+	// }
+
+	// ENUM
+	if (col.enumValues !== undefined) {
+		const generator = new generatorsMap.GenerateEnum[0]({
+			enumValues: col.enumValues,
+		});
+
+		return generator;
+	}
+
+	// INTERVAL
+	if (col.columnType.startsWith('interval')) {
+		if (col.columnType === 'interval') {
+			const generator = new generatorsMap.GenerateInterval[0]();
+
+			return generator;
+		}
+
+		const fields = col.columnType.replace('interval ', '') as GenerateInterval['params']['fields'];
+		const generator = new generatorsMap.GenerateInterval[0]({ fields });
+
+		return generator;
+	}
+
+	// POINT, LINE
+	if (col.columnType.includes('point')) {
+		const generator = new generatorsMap.GeneratePoint[0]();
+		return generator;
+	}
+
+	if (col.columnType.includes('line')) {
+		const generator = new generatorsMap.GenerateLine[0]();
+
+		return generator;
+	}
+
+	if (col.hasDefault && col.default !== undefined) {
+		const generator = new generatorsMap.GenerateDefault[0]({
+			defaultValue: col.default,
+		});
+		return generator;
+	}
+
+	return;
+};
+
+// TODO: revise serial part generators
+export const selectGeneratorForPostgresColumn = (
+	col: Column,
+	isPrimaryKey: boolean,
+) => {
+	const dimensions = col.typeParams.dimensions ?? 0;
+	const generator = pickGenerator(col, isPrimaryKey) as AbstractGenerator;
+
+	// Assign dataType to inner generator before wrapping
+	if (generator !== undefined) {
+		generator.dataType = col.dataType;
+	}
+
+	const result = dimensions
+		? new generatorsMap.GenerateArray[0]({ baseColumnGen: generator, size: col.size })
+		: generator;
+
+	if (result !== undefined) {
+		result.isUnique = col.isUnique;
+		result.dataType = col.dataType;
+		result.typeParams = col.typeParams;
+		// generator.stringLength = col.typeParams.length;
+	}
+
+	return result;
+};
diff --git a/drizzle-seed/src/services/Generators.ts b/drizzle-seed/src/services/Generators.ts
deleted file mode 100644
index 0d285540ee..0000000000
--- a/drizzle-seed/src/services/Generators.ts
+++ /dev/null
@@ -1,3119 +0,0 @@
-/* eslint-disable drizzle-internal/require-entity-kind */
-import prand from 'pure-rand';
-import adjectives, { maxStringLength as maxAdjectiveLength } from '../datasets/adjectives.ts';
-import cityNames, { maxStringLength as maxCityNameLength } from '../datasets/cityNames.ts';
-import companyNameSuffixes, { maxStringLength as maxCompanyNameSuffixLength } from '../datasets/companyNameSuffixes.ts';
-import countries, { maxStringLength as maxCountryLength } from '../datasets/countries.ts';
-import emailDomains, { maxStringLength as maxEmailDomainLength } from '../datasets/emailDomains.ts';
-import firstNames, { maxStringLength as maxFirstNameLength } from '../datasets/firstNames.ts';
-import jobsTitles, { maxStringLength as maxJobTitleLength } from '../datasets/jobsTitles.ts';
-import lastNames, { maxStringLength as maxLastNameLength } from '../datasets/lastNames.ts';
-import loremIpsumSentences, { maxStringLength as maxLoremIpsumLength } from '../datasets/loremIpsumSentences.ts';
-import phonesInfo from '../datasets/phonesInfo.ts';
-import states, { maxStringLength as maxStateLength } from '../datasets/states.ts';
-import streetSuffix, { maxStringLength as maxStreetSuffixLength } from '../datasets/streetSuffix.ts';
-import { fastCartesianProduct, fillTemplate, getWeightedIndices, isObject } from './utils.ts';
-
-export abstract class AbstractGenerator<T = {}> {
-	static readonly entityKind: string = 'AbstractGenerator';
-	static readonly version: number = 1;
-
-	public isUnique = false;
-	public notNull = false;
-
-	// param for generators which have a unique version of themselves
-	public uniqueVersionOfGen?: new(params: T) => AbstractGenerator<T>;
-
-	public dataType?: string;
-	public timeSpent?: number;
-
-	//
-	public arraySize?: number;
-	public baseColumnDataType?: string;
-
-	// param for text-like generators
-	public stringLength?: number;
-
-	// params for GenerateValuesFromArray
-	public weightedCountSeed?: number | undefined;
-	public maxRepeatedValuesCount?: number | { weight: number; count: number | number[] }[] | undefined;
-
-	public params: T;
-
-	constructor(params?: T) {
-		this.params = params === undefined ? {} as T : params as T;
-	}
-
-	init(params: { count: number | { weight: number; count: number | number[] }[]; seed: number }): void;
-	init() {
-		this.updateParams();
-	}
-
-	updateParams() {
-		if ((this.params as any).arraySize !== undefined) {
-			this.arraySize = (this.params as any).arraySize;
-		}
-
-		if ((this.params as any).isUnique !== undefined) {
-			if ((this.params as any).isUnique === false && this.isUnique === true) {
-				throw new Error('specifying non unique generator to unique column.');
-			}
-
-			this.isUnique = (this.params as any).isUnique;
-		}
-	}
-
-	abstract generate(params: { i: number }): number | string | boolean | unknown | undefined | void;
-
-	getEntityKind(): string {
-		const constructor = this.constructor as typeof AbstractGenerator;
-		return constructor.entityKind;
-	}
-
-	replaceIfUnique() {
-		this.updateParams();
-		if (
-			this.uniqueVersionOfGen !== undefined
-			&& this.isUnique === true
-		) {
-			const uniqueGen = new this.uniqueVersionOfGen({
-				...this.params,
-			});
-
-			uniqueGen.isUnique = this.isUnique;
-			uniqueGen.dataType = this.dataType;
-
-			return uniqueGen;
-		}
-		return;
-	}
-
-	replaceIfArray() {
-		this.updateParams();
-		if (!(this.getEntityKind() === 'GenerateArray') && this.arraySize !== undefined) {
-			const uniqueGen = this.replaceIfUnique();
-			const baseColumnGen = uniqueGen === undefined ? this : uniqueGen;
-			baseColumnGen.dataType = this.baseColumnDataType;
-			const arrayGen = new GenerateArray(
-				{
-					baseColumnGen,
-					size: this.arraySize,
-				},
-			);
-
-			return arrayGen;
-		}
-
-		return;
-	}
-}
-
-// Generators Classes -----------------------------------------------------------------------------------------------------------------------
-export class GenerateArray extends AbstractGenerator<{ baseColumnGen: AbstractGenerator<any>; size?: number }> {
-	static override readonly entityKind: string = 'GenerateArray';
-	public override arraySize = 10;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-		this.arraySize = this.params.size === undefined ? this.arraySize : this.params.size;
-		this.params.baseColumnGen.init({ count: count * this.arraySize, seed });
-	}
-
-	generate() {
-		const array = [];
-		for (let i = 0; i < this.arraySize; i++) {
-			array.push(this.params.baseColumnGen.generate({ i }));
-		}
-
-		return array;
-	}
-}
-
-export class GenerateWeightedCount extends AbstractGenerator<{}> {
-	static override readonly entityKind: string = 'GenerateWeightedCount';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		weightedIndices: number[];
-		weightedCount: { weight: number; count: number | number[] }[];
-	} | undefined;
-
-	override init({ seed, count }: { count: { weight: number; count: number | number[] }[]; seed: number }) {
-		const rng = prand.xoroshiro128plus(seed);
-		const weightedIndices = getWeightedIndices(count.map((val) => val.weight));
-		this.state = { rng, weightedIndices, weightedCount: count };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		// logic for this generator
-		let idx: number;
-		const weightedCount = this.state.weightedCount;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
-		const objIdx = this.state.weightedIndices[idx] as number;
-
-		if (typeof weightedCount[objIdx]!.count === 'number') {
-			return weightedCount[objIdx]!.count as number;
-		} else {
-			// typeof weightedCount[objIdx]!.count === 'object' // number[]
-			const possCounts = weightedCount[objIdx]!.count as number[];
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, possCounts.length - 1, this.state.rng);
-			return possCounts[idx]!;
-		}
-	}
-}
-
-export class HollowGenerator extends AbstractGenerator<{}> {
-	static override readonly entityKind: string = 'HollowGenerator';
-
-	override init() {}
-
-	generate() {}
-}
-
-export class GenerateDefault extends AbstractGenerator<{
-	defaultValue: unknown;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateDefault';
-
-	generate() {
-		return this.params.defaultValue;
-	}
-}
-
-export class GenerateValuesFromArray extends AbstractGenerator<
-	{
-		values:
-			| (number | string | boolean | undefined)[]
-			| { weight: number; values: (number | string | boolean | undefined)[] }[];
-		isUnique?: boolean;
-		arraySize?: number;
-	}
-> {
-	static override readonly entityKind: string = 'GenerateValuesFromArray';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		values:
-			| (number | string | boolean | undefined)[]
-			| { weight: number; values: (number | string | boolean | undefined)[] }[];
-		genIndicesObj: GenerateUniqueInt | undefined;
-		genIndicesObjList: GenerateUniqueInt[] | undefined;
-		valuesWeightedIndices: number[] | undefined;
-		genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
-	} | undefined;
-	public override timeSpent: number = 0;
-
-	checks({ count }: { count: number }) {
-		const { values } = this.params;
-		const { maxRepeatedValuesCount, notNull, isUnique } = this;
-		if (values.length === 0) {
-			throw new Error('Values length equals zero.');
-		}
-
-		if (
-			isObject(values[0])
-			&& !(values as { weight: number; values: any[] }[]).every((val) => val.values.length !== 0)
-		) {
-			throw new Error('One of weighted values length equals zero.');
-		}
-
-		if (
-			maxRepeatedValuesCount !== undefined && (
-				(typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount <= 0)
-				|| (typeof maxRepeatedValuesCount === 'object' && !maxRepeatedValuesCount
-					.every((obj) =>
-						(typeof obj.count) === 'number'
-							? (obj.count as number) > 0
-							: (obj.count as number[]).every((count) => count > 0)
-					))
-			)
-		) {
-			throw new Error('maxRepeatedValuesCount should be greater than zero.');
-		}
-
-		let allValuesCount = values.length;
-		if (isObject(values[0])) {
-			allValuesCount = (values as { values: any[] }[]).reduce((acc, currVal) => acc + currVal.values.length, 0);
-		}
-
-		if (
-			notNull === true
-			&& maxRepeatedValuesCount !== undefined
-			&& (
-				(!isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
-					&& maxRepeatedValuesCount * values.length < count)
-				|| (isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
-					&& maxRepeatedValuesCount * allValuesCount < count)
-			)
-		) {
-			throw new Error("Can't fill notNull column with null values.");
-		}
-
-		if (
-			isUnique === true && maxRepeatedValuesCount !== undefined && (
-				(typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount > 1)
-				|| (typeof maxRepeatedValuesCount === 'object' && !maxRepeatedValuesCount
-					.every((obj) =>
-						(typeof obj.count) === 'number'
-							? obj.count === 1
-							: (obj.count as number[]).every((count) => count === 1)
-					))
-			)
-		) {
-			throw new Error("Can't be greater than 1 if column is unique.");
-		}
-
-		if (
-			isUnique === true && notNull === true && (
-				(!isObject(values[0]) && values.length < count)
-				|| (isObject(values[0]) && allValuesCount < count)
-			)
-		) {
-			// console.log(maxRepeatedValuesCount, values.length, allValuesCount, count)
-			throw new Error('There are no enough values to fill unique column.');
-		}
-	}
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		this.checks({ count });
-
-		let { maxRepeatedValuesCount } = this;
-		const { params, isUnique, notNull, weightedCountSeed } = this;
-
-		const values = params.values;
-
-		let valuesWeightedIndices;
-		if (isObject(values[0])) {
-			valuesWeightedIndices = getWeightedIndices((values as { weight: number }[]).map((val) => val.weight));
-			if (isUnique === true && notNull === true) {
-				let idx: number, valueIdx: number, rng = prand.xoroshiro128plus(seed);
-				const indicesCounter: { [key: number]: number } = {};
-				for (let i = 0; i < count; i++) {
-					[idx, rng] = prand.uniformIntDistribution(0, valuesWeightedIndices.length - 1, rng);
-					valueIdx = valuesWeightedIndices[idx]!;
-					if (!Object.hasOwn(indicesCounter, valueIdx)) indicesCounter[valueIdx] = 0;
-					indicesCounter[valueIdx]! += 1;
-				}
-
-				for (const [idx, value] of values.entries()) {
-					if ((value as { values: (number | string | boolean | undefined)[] }).values.length < indicesCounter[idx]!) {
-						throw new Error(
-							'weighted values arrays is too small to generate values with specified probability for unique not null column.'
-								+ `it's planned to generate: ${
-									Object.entries(indicesCounter).map(([idx, count]) => {
-										return `${count} values with probability ${(values as { weight: number }[])[Number(idx)]?.weight}`;
-									}).join(',')
-								}`,
-						);
-					}
-				}
-			}
-		}
-		if (isUnique === true && maxRepeatedValuesCount === undefined) {
-			maxRepeatedValuesCount = 1;
-		}
-		let genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
-		if (typeof maxRepeatedValuesCount === 'number') {
-			genMaxRepeatedValuesCount = new GenerateDefault({ defaultValue: maxRepeatedValuesCount });
-		} else if (typeof maxRepeatedValuesCount === 'object') {
-			genMaxRepeatedValuesCount = new GenerateWeightedCount({});
-			(genMaxRepeatedValuesCount as GenerateWeightedCount).init(
-				{
-					count: maxRepeatedValuesCount,
-					seed: weightedCountSeed === undefined ? seed : weightedCountSeed,
-				},
-			);
-		}
-
-		let genIndicesObj: GenerateUniqueInt | undefined;
-		let genIndicesObjList: GenerateUniqueInt[] | undefined;
-
-		if (maxRepeatedValuesCount !== undefined) {
-			if (!isObject(values[0])) {
-				genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: values.length - 1 });
-				genIndicesObj.genMaxRepeatedValuesCount = genMaxRepeatedValuesCount;
-				genIndicesObj.skipCheck = true;
-				genIndicesObj.init({ count, seed });
-			} else if (isObject(values[0])) {
-				genIndicesObjList = [];
-				for (const obj of values as { weight: number; values: (number | string | boolean | undefined)[] }[]) {
-					const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: obj.values.length - 1 });
-					genIndicesObj.genMaxRepeatedValuesCount = genMaxRepeatedValuesCount;
-					genIndicesObj.skipCheck = true;
-					genIndicesObj.init({ count, seed });
-					genIndicesObjList.push(genIndicesObj);
-				}
-			}
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng, values, valuesWeightedIndices, genMaxRepeatedValuesCount, genIndicesObj, genIndicesObjList };
-	}
-
-	generate() {
-		const t0 = new Date();
-
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number,
-			value: string | number | boolean | undefined;
-		let valueIdx: number;
-
-		if (this.state.valuesWeightedIndices === undefined) {
-			if (this.state.genIndicesObj === undefined) {
-				[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.values.length - 1, this.state.rng);
-			} else {
-				idx = this.state.genIndicesObj.generate() as number;
-			}
-
-			value = (this.state.values as (number | string | boolean | undefined)[])[idx];
-		} else {
-			// weighted values
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				this.state.valuesWeightedIndices.length - 1,
-				this.state.rng,
-			);
-			valueIdx = this.state.valuesWeightedIndices[idx] as number;
-			const currValues =
-				(this.state.values![valueIdx] as { weight: number; values: (number | string | boolean | undefined)[] }).values;
-			if (this.state.genIndicesObjList === undefined) {
-				// isUnique !== true
-				[idx, this.state.rng] = prand.uniformIntDistribution(0, currValues.length - 1, this.state.rng);
-			} else {
-				// isUnique === true
-				idx = this.state.genIndicesObjList[valueIdx]!.generate() as number;
-			}
-			value = currValues[idx];
-		}
-
-		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
-		return value;
-	}
-}
-
-export class GenerateSelfRelationsValuesFromArray extends AbstractGenerator<{ values: (number | string | boolean)[] }> {
-	static override readonly entityKind: string = 'GenerateSelfRelationsValuesFromArray';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		firstValuesCount: number;
-		firstValues: (string | number | boolean)[];
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		let rng = prand.xoroshiro128plus(seed);
-
-		// generate 15-40 % values with the same value as reference column
-		let percent = 30;
-		[percent, rng] = prand.uniformIntDistribution(20, 40, rng);
-		const firstValuesCount = Math.floor((percent / 100) * count), firstValues: (string | number | boolean)[] = [];
-
-		this.state = { rng, firstValuesCount, firstValues };
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const { values } = this.params;
-		let idx: number;
-
-		if (i < this.state.firstValuesCount) {
-			this.state.firstValues.push(values[i]!);
-			return values[i];
-		} else {
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.firstValues.length - 1, this.state.rng);
-			return this.state.firstValues[idx];
-		}
-	}
-}
-
-export class GenerateIntPrimaryKey extends AbstractGenerator<{}> {
-	static override readonly entityKind: string = 'GenerateIntPrimaryKey';
-
-	public maxValue?: number | bigint;
-
-	override init({ count }: { count: number; seed: number }) {
-		if (this.maxValue !== undefined && count > this.maxValue) {
-			throw new Error('count exceeds max number for this column type.');
-		}
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.dataType === 'bigint') {
-			return BigInt(i + 1);
-		}
-
-		return i + 1;
-	}
-}
-
-export class GenerateNumber extends AbstractGenerator<
-	{
-		minValue?: number;
-		maxValue?: number;
-		precision?: number;
-		isUnique?: boolean;
-		arraySize?: number;
-	}
-> {
-	static override readonly entityKind: string = 'GenerateNumber';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		minValue: number;
-		maxValue: number;
-		precision: number;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueNumber;
-
-	override init({ count, seed }: { seed: number; count: number }) {
-		super.init({ count, seed });
-
-		let { minValue, maxValue, precision } = this.params;
-		if (precision === undefined) {
-			precision = 100;
-		}
-
-		if (maxValue === undefined) {
-			maxValue = precision * 1000;
-		} else {
-			maxValue *= precision;
-		}
-
-		if (minValue === undefined) {
-			minValue = -maxValue;
-		} else {
-			minValue *= precision;
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng, minValue, maxValue, precision };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let value: number;
-
-		[value, this.state.rng] = prand.uniformIntDistribution(this.state.minValue, this.state.maxValue, this.state.rng);
-		return value / this.state.precision;
-	}
-}
-
-export class GenerateUniqueNumber extends AbstractGenerator<
-	{
-		minValue?: number;
-		maxValue?: number;
-		precision?: number;
-		isUnique?: boolean;
-	}
-> {
-	static override readonly entityKind: string = 'GenerateUniqueNumber';
-
-	private state: {
-		genUniqueIntObj: GenerateUniqueInt;
-		minValue: number;
-		maxValue: number;
-		precision: number;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		let { minValue, maxValue, precision } = this.params;
-
-		if (precision === undefined) {
-			precision = 100;
-		}
-
-		if (maxValue === undefined) {
-			maxValue = count * precision;
-		} else {
-			maxValue *= precision;
-		}
-
-		if (minValue === undefined) {
-			minValue = -maxValue;
-		} else {
-			minValue *= precision;
-		}
-
-		const genUniqueIntObj = new GenerateUniqueInt({ minValue, maxValue });
-		genUniqueIntObj.init({ count, seed });
-
-		this.state = { genUniqueIntObj, minValue, maxValue, precision };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const value = this.state.genUniqueIntObj.generate() as number / this.state.precision;
-
-		return value;
-	}
-}
-
-export class GenerateInt extends AbstractGenerator<{
-	minValue?: number | bigint;
-	maxValue?: number | bigint;
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateInt';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		minValue: number | bigint;
-		maxValue: number | bigint;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueInt;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		let { minValue, maxValue } = this.params;
-
-		if (maxValue === undefined) {
-			maxValue = 1000;
-		}
-
-		if (minValue === undefined) {
-			minValue = -maxValue;
-		}
-
-		if (typeof minValue === 'number' && typeof maxValue === 'number') {
-			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
-			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng, minValue, maxValue };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let value: number | bigint;
-		if (typeof this.state.minValue === 'bigint' && typeof this.state.maxValue === 'bigint') {
-			[value, this.state.rng] = prand.uniformBigIntDistribution(
-				this.state.minValue,
-				this.state.maxValue,
-				this.state.rng,
-			);
-		} else {
-			[value, this.state.rng] = prand.uniformIntDistribution(
-				this.state.minValue as number,
-				this.state.maxValue as number,
-				this.state.rng,
-			);
-		}
-
-		if (this.dataType === 'string') {
-			return String(value);
-		}
-
-		if (this.dataType === 'bigint') {
-			value = BigInt(value);
-		}
-		return value;
-	}
-}
-
-export class GenerateUniqueInt extends AbstractGenerator<{
-	minValue?: number | bigint;
-	maxValue?: number | bigint;
-	isUnique?: boolean;
-}> {
-	static override readonly entityKind: string = 'GenerateUniqueInt';
-
-	public genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
-	public skipCheck?: boolean = false;
-	public state: {
-		rng: prand.RandomGenerator;
-		minValue: number | bigint;
-		maxValue: number | bigint;
-		intervals: (number | bigint)[][];
-		integersCount: Map<number | bigint, number>;
-	} | undefined;
-	public override isUnique = true;
-	public override timeSpent = 0;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const rng = prand.xoroshiro128plus(seed);
-		let { minValue, maxValue } = this.params;
-
-		if (maxValue === undefined) {
-			maxValue = count * 10;
-		}
-		if (minValue === undefined) {
-			minValue = -maxValue;
-		}
-
-		const intervals = [[minValue, maxValue]];
-
-		const integersCount = new Map();
-
-		if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
-			if (this.skipCheck === false && maxValue - minValue + BigInt(1) < count) {
-				throw new Error(
-					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
-				);
-			}
-		} else if (typeof minValue === 'number' && typeof maxValue === 'number') {
-			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
-			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
-			if (this.skipCheck === false && maxValue - minValue + 1 < count) {
-				throw new Error(
-					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
-				);
-			}
-		} else {
-			throw new Error(
-				'minValue and maxValue should be the same type.',
-			);
-		}
-
-		this.state = { rng, minValue, maxValue, intervals, integersCount };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let intervalIdx: number,
-			numb: number | bigint | undefined;
-
-		const intervalsToAdd: (number | bigint)[][] = [];
-
-		if (this.state.intervals.length === 0) {
-			if (this.skipCheck === false) {
-				throw new RangeError(
-					'generateUniqueInt: count exceeds max number of unique integers in given range(min, max), try to increase range.',
-				);
-			} else {
-				return;
-			}
-		}
-
-		[intervalIdx, this.state.rng] = prand.uniformIntDistribution(
-			0,
-			this.state.intervals.length - 1,
-			this.state.rng,
-		);
-
-		const interval = this.state.intervals[intervalIdx] as (number | bigint)[];
-		const [currMinNumb, currMaxNumb] = [interval[0] as number | bigint, interval[1] as number | bigint];
-
-		if (typeof currMinNumb === 'number' && typeof currMaxNumb === 'number') {
-			numb = this.generateNumber(currMinNumb, currMaxNumb, intervalsToAdd as number[][], intervalIdx);
-		} else if (typeof currMinNumb === 'bigint' && typeof currMaxNumb === 'bigint') {
-			numb = this.generateBigint(
-				currMinNumb as bigint,
-				currMaxNumb as bigint,
-				intervalsToAdd as bigint[][],
-				intervalIdx,
-			);
-		}
-
-		if (this.dataType === 'string') {
-			return String(numb);
-		}
-
-		if (this.dataType === 'bigint' && numb !== undefined) {
-			numb = BigInt(numb);
-		}
-		return numb;
-	}
-
-	generateNumber(currMinNumb: number, currMaxNumb: number, intervalsToAdd: number[][], intervalIdx: number) {
-		let numb: number;
-
-		[numb, this.state!.rng] = prand.uniformIntDistribution(currMinNumb, currMaxNumb, this.state!.rng);
-
-		if (this.genMaxRepeatedValuesCount !== undefined) {
-			if (this.state!.integersCount.get(numb) === undefined) {
-				this.state!.integersCount.set(numb, this.genMaxRepeatedValuesCount.generate() as number);
-			}
-			this.state!.integersCount.set(numb, this.state!.integersCount.get(numb)! - 1);
-		}
-
-		if (this.state!.integersCount.get(numb) === undefined || this.state!.integersCount.get(numb) === 0) {
-			if (numb === currMinNumb) {
-				intervalsToAdd = numb + 1 <= currMaxNumb ? [[numb + 1, currMaxNumb]] : [];
-			} else if (numb === currMaxNumb) {
-				intervalsToAdd = [[currMinNumb, numb - 1]];
-			} else {
-				intervalsToAdd = [
-					[currMinNumb, numb - 1],
-					[numb + 1, currMaxNumb],
-				];
-			}
-
-			const t0 = new Date();
-			this.state!.intervals[intervalIdx] = this.state!.intervals[this.state!.intervals.length - 1]!;
-			this.state?.intervals.pop();
-			this.timeSpent += (Date.now() - t0.getTime()) / 1000;
-			this.state!.intervals.push(...intervalsToAdd);
-		}
-
-		return numb;
-	}
-
-	generateBigint(currMinNumb: bigint, currMaxNumb: bigint, intervalsToAdd: bigint[][], intervalIdx: number) {
-		let numb: bigint;
-		[numb, this.state!.rng] = prand.uniformBigIntDistribution(currMinNumb, currMaxNumb, this.state!.rng);
-		if (this.genMaxRepeatedValuesCount !== undefined) {
-			if (this.state!.integersCount.get(numb) === undefined) {
-				this.state!.integersCount.set(numb, this.genMaxRepeatedValuesCount.generate() as number);
-			}
-			this.state!.integersCount.set(numb, this.state!.integersCount.get(numb)! - 1);
-		}
-
-		if (this.state!.integersCount.get(numb) === undefined || this.state!.integersCount.get(numb) === 0) {
-			if (numb === currMinNumb) {
-				intervalsToAdd = numb + BigInt(1) <= currMaxNumb ? [[numb + BigInt(1), currMaxNumb]] : [];
-			} else if (numb === currMaxNumb) {
-				intervalsToAdd = [[currMinNumb, numb - BigInt(1)]];
-			} else {
-				intervalsToAdd = [
-					[currMinNumb, numb - BigInt(1)],
-					[numb + BigInt(1), currMaxNumb],
-				];
-			}
-
-			this.state!.intervals[intervalIdx] = this.state!.intervals[this.state!.intervals.length - 1]!;
-			this.state?.intervals.pop();
-			this.state!.intervals.push(...intervalsToAdd);
-		}
-
-		return numb;
-	}
-}
-
-export class GenerateBoolean extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateBoolean';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let value: number;
-
-		[value, this.state.rng] = prand.uniformIntDistribution(0, 1, this.state.rng);
-		return value === 1;
-	}
-}
-
-export class GenerateDate extends AbstractGenerator<{
-	minDate?: string | Date;
-	maxDate?: string | Date;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateDate';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		minDate: Date;
-		maxDate: Date;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-		const rng = prand.xoroshiro128plus(seed);
-
-		let { minDate, maxDate } = this.params;
-
-		const anchorDate = new Date('2024-05-08');
-		const deltaMilliseconds = 4 * 31536000000;
-
-		if (typeof minDate === 'string') {
-			minDate = new Date(minDate);
-		}
-
-		if (typeof maxDate === 'string') {
-			maxDate = new Date(maxDate);
-		}
-
-		if (minDate === undefined) {
-			if (maxDate === undefined) {
-				minDate = new Date(anchorDate.getTime() - deltaMilliseconds);
-				maxDate = new Date(anchorDate.getTime() + deltaMilliseconds);
-			} else {
-				minDate = new Date(maxDate.getTime() - (2 * deltaMilliseconds));
-			}
-		}
-
-		if (maxDate === undefined) {
-			maxDate = new Date(minDate.getTime() + (2 * deltaMilliseconds));
-		}
-
-		this.state = { rng, minDate, maxDate };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let milliseconds: number;
-
-		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
-			this.state.minDate.getTime(),
-			this.state.maxDate.getTime(),
-			this.state.rng,
-		);
-		const date = new Date(milliseconds);
-
-		if (this.dataType === 'string') {
-			return date.toISOString().replace(/T.+/, '');
-		}
-		return date;
-	}
-}
-export class GenerateTime extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateTime';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const anchorDateTime = new Date('2024-05-08T12:00:00.000Z');
-		const oneDayInMilliseconds = 86400000;
-
-		let date = new Date();
-		let milliseconds: number;
-
-		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
-			-oneDayInMilliseconds,
-			oneDayInMilliseconds,
-			this.state.rng,
-		);
-		date = new Date(date.setTime(anchorDateTime.getTime() + milliseconds));
-
-		return date.toISOString().replace(/(\d{4}-\d{2}-\d{2}T)|(\.\d{3}Z)/g, '');
-	}
-}
-export class GenerateTimestampInt extends AbstractGenerator<{ unitOfTime?: 'seconds' | 'milliseconds' }> {
-	static override readonly entityKind: string = 'GenerateTimestampInt';
-
-	private state: {
-		generateTimestampObj: GenerateTimestamp;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const generateTimestampObj = new GenerateTimestamp({});
-		generateTimestampObj.dataType = 'date';
-		generateTimestampObj.init({ count, seed });
-
-		this.state = { generateTimestampObj };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const date = this.state.generateTimestampObj.generate() as Date;
-
-		if (this.params.unitOfTime === 'seconds') {
-			return Math.floor(date.getTime() / 1000);
-		} else if (this.params.unitOfTime === 'milliseconds') {
-			return date.getTime();
-		} else {
-			// this.params.unitOfTime === undefined
-			return Math.floor(date.getTime() / 1000);
-		}
-	}
-}
-
-export class GenerateTimestamp extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateTimestamp';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const anchorTimestamp = new Date('2024-05-08');
-		const twoYearsInMilliseconds = 2 * 31536000000;
-
-		let date = new Date();
-		let milliseconds: number;
-
-		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
-			-twoYearsInMilliseconds,
-			twoYearsInMilliseconds,
-			this.state.rng,
-		);
-		date = new Date(date.setTime(anchorTimestamp.getTime() + milliseconds));
-
-		if (this.dataType === 'string') {
-			return date
-				.toISOString()
-				.replace('T', ' ')
-				.replace(/\.\d{3}Z/, '');
-		}
-
-		return date;
-	}
-}
-
-export class GenerateDatetime extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateDatetime';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const anchorDate = new Date('2024-05-08');
-		const twoYearsInMilliseconds = 2 * 31536000000;
-
-		let date = new Date();
-		let milliseconds: number;
-
-		[milliseconds, this.state.rng] = prand.uniformIntDistribution(
-			-twoYearsInMilliseconds,
-			twoYearsInMilliseconds,
-			this.state.rng,
-		);
-		date = new Date(date.setTime(anchorDate.getTime() + milliseconds));
-
-		if (this.dataType === 'string') {
-			return date
-				.toISOString()
-				.replace('T', ' ')
-				.replace(/\.\d{3}Z/, '');
-		}
-
-		return date;
-	}
-}
-
-export class GenerateYear extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateYear';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const anchorDate = new Date('2024-05-08');
-		const tenYears = 10;
-
-		let date = new Date();
-		let years: number;
-
-		[years, this.state.rng] = prand.uniformIntDistribution(-tenYears, tenYears, this.state.rng);
-		date = new Date(date.setFullYear(anchorDate.getFullYear() + years));
-
-		return date
-			.toISOString()
-			.replace(/(-\d{2}-\d{2}T)|(\d{2}:\d{2}:\d{2}\.\d{3}Z)/g, '');
-	}
-}
-
-export class GenerateJson extends AbstractGenerator<{ arraySize?: number }> {
-	static override readonly entityKind: string = 'GenerateJson';
-
-	private state: {
-		emailGeneratorObj: GenerateEmail;
-		nameGeneratorObj: GenerateFirstName;
-		booleanGeneratorObj: GenerateBoolean;
-		salaryGeneratorObj: GenerateInt;
-		dateGeneratorObj: GenerateDate;
-		visitedCountriesNumberGeneratorObj: GenerateInt;
-		seed: number;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const emailGeneratorObj = new GenerateEmail({});
-		emailGeneratorObj.init({ count, seed });
-
-		const nameGeneratorObj = new GenerateFirstName({});
-		nameGeneratorObj.init({ count, seed });
-
-		const booleanGeneratorObj = new GenerateBoolean({});
-		booleanGeneratorObj.init({
-			count,
-			seed,
-		});
-
-		const salaryGeneratorObj = new GenerateInt({ minValue: 200, maxValue: 4000 });
-		salaryGeneratorObj.init({
-			count,
-			seed,
-			...salaryGeneratorObj.params,
-		});
-
-		const dateGeneratorObj = new GenerateDate({});
-		dateGeneratorObj.dataType = 'string';
-		dateGeneratorObj.init({ count, seed });
-
-		const visitedCountriesNumberGeneratorObj = new GenerateInt({ minValue: 0, maxValue: 4 });
-		visitedCountriesNumberGeneratorObj.init(
-			{ count, seed, ...visitedCountriesNumberGeneratorObj.params },
-		);
-
-		this.state = {
-			emailGeneratorObj,
-			nameGeneratorObj,
-			booleanGeneratorObj,
-			salaryGeneratorObj,
-			dateGeneratorObj,
-			visitedCountriesNumberGeneratorObj,
-			seed,
-		};
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const visitedCountries: string[] = [];
-		const email = this.state.emailGeneratorObj.generate();
-		const name = this.state.nameGeneratorObj.generate();
-		const isGraduated = this.state.booleanGeneratorObj.generate();
-		const hasJob = this.state.booleanGeneratorObj.generate();
-		const salary = this.state.salaryGeneratorObj.generate() as number;
-		const startedWorking = this.state.dateGeneratorObj.generate() as string;
-		const visitedCountriesNumber = this.state.visitedCountriesNumberGeneratorObj.generate() as number;
-
-		const uniqueCountriesGeneratorObj = new GenerateUniqueCountry({});
-		uniqueCountriesGeneratorObj.init({
-			count: visitedCountriesNumber,
-			seed: this.state.seed + i,
-		});
-		for (let j = 0; j < visitedCountriesNumber; j++) {
-			visitedCountries.push(uniqueCountriesGeneratorObj.generate());
-		}
-
-		const returnJson = hasJob
-			? {
-				email,
-				name,
-				isGraduated,
-				hasJob,
-				salary,
-				startedWorking,
-				visitedCountries,
-			}
-			: {
-				email,
-				name,
-				isGraduated,
-				hasJob,
-				visitedCountries,
-			};
-
-		if (this.dataType === 'string') {
-			return JSON.stringify(returnJson);
-		}
-
-		return returnJson;
-	}
-}
-
-export class GenerateEnum extends AbstractGenerator<{ enumValues: (string | number | boolean)[] }> {
-	static override readonly entityKind: string = 'GenerateEnum';
-
-	private state: {
-		enumValuesGenerator: GenerateValuesFromArray;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const { enumValues } = this.params;
-		const enumValuesGenerator = new GenerateValuesFromArray({ values: enumValues });
-		enumValuesGenerator.init({ count, seed });
-		this.state = { enumValuesGenerator };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-		// logic for this generator
-		return this.state.enumValuesGenerator.generate();
-	}
-}
-
-export class GenerateInterval extends AbstractGenerator<{
-	fields?:
-		| 'year'
-		| 'month'
-		| 'day'
-		| 'hour'
-		| 'minute'
-		| 'second'
-		| 'year to month'
-		| 'day to hour'
-		| 'day to minute'
-		| 'day to second'
-		| 'hour to minute'
-		| 'hour to second'
-		| 'minute to second';
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateInterval';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		fieldsToGenerate: string[];
-	} | undefined;
-	override uniqueVersionOfGen: new(params: any) => AbstractGenerator<any> = GenerateUniqueInterval;
-	private config: { [key: string]: { from: number; to: number } } = {
-		year: {
-			from: 0,
-			to: 5,
-		},
-		month: {
-			from: 0,
-			to: 12,
-		},
-		day: {
-			from: 1,
-			to: 29,
-		},
-		hour: {
-			from: 0,
-			to: 24,
-		},
-		minute: {
-			from: 0,
-			to: 60,
-		},
-		second: {
-			from: 0,
-			to: 60,
-		},
-	};
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
-		let fieldsToGenerate: string[] = allFields;
-
-		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
-			const tokens = this.params.fields.split(' to ');
-			const endIdx = allFields.indexOf(tokens[1]!);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		} else if (this.params.fields !== undefined) {
-			const endIdx = allFields.indexOf(this.params.fields);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		this.state = { rng, fieldsToGenerate };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let interval = '', numb: number;
-
-		for (const field of this.state.fieldsToGenerate) {
-			const from = this.config[field]!.from, to = this.config[field]!.to;
-			[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
-			interval += `${numb} ${field} `;
-		}
-
-		return interval;
-	}
-}
-
-// has a newer version
-export class GenerateUniqueInterval extends AbstractGenerator<{
-	fields?:
-		| 'year'
-		| 'month'
-		| 'day'
-		| 'hour'
-		| 'minute'
-		| 'second'
-		| 'year to month'
-		| 'day to hour'
-		| 'day to minute'
-		| 'day to second'
-		| 'hour to minute'
-		| 'hour to second'
-		| 'minute to second';
-	isUnique?: boolean;
-}> {
-	static override readonly 'entityKind': string = 'GenerateUniqueInterval';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		fieldsToGenerate: string[];
-		intervalSet: Set<string>;
-	} | undefined;
-	public override isUnique = true;
-	private config: { [key: string]: { from: number; to: number } } = {
-		year: {
-			from: 0,
-			to: 5,
-		},
-		month: {
-			from: 0,
-			to: 12,
-		},
-		day: {
-			from: 1,
-			to: 29,
-		},
-		hour: {
-			from: 0,
-			to: 24,
-		},
-		minute: {
-			from: 0,
-			to: 60,
-		},
-		second: {
-			from: 0,
-			to: 60,
-		},
-	};
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
-		let fieldsToGenerate: string[] = allFields;
-
-		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
-			const tokens = this.params.fields.split(' to ');
-			const endIdx = allFields.indexOf(tokens[1]!);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		} else if (this.params.fields !== undefined) {
-			const endIdx = allFields.indexOf(this.params.fields);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		}
-
-		let maxUniqueIntervalsNumber = 1;
-		for (const field of fieldsToGenerate) {
-			const from = this.config[field]!.from, to = this.config[field]!.to;
-			maxUniqueIntervalsNumber *= from - to + 1;
-		}
-
-		if (count > maxUniqueIntervalsNumber) {
-			throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		const intervalSet = new Set<string>();
-		this.state = { rng, fieldsToGenerate, intervalSet };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let interval, numb: number;
-
-		for (;;) {
-			interval = '';
-
-			for (const field of this.state.fieldsToGenerate) {
-				const from = this.config[field]!.from, to = this.config[field]!.to;
-				[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
-				interval += `${numb} ${field} `;
-			}
-
-			if (!this.state.intervalSet.has(interval)) {
-				this.state.intervalSet.add(interval);
-				break;
-			}
-		}
-
-		return interval;
-	}
-}
-
-// has a newer version
-export class GenerateString extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateString';
-
-	private state: { rng: prand.RandomGenerator } | undefined;
-	override uniqueVersionOfGen = GenerateUniqueString;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const minStringLength = 7;
-		const maxStringLength = 20;
-		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-		let idx: number,
-			strLength: number,
-			currStr: string;
-
-		currStr = '';
-		[strLength, this.state.rng] = prand.uniformIntDistribution(
-			minStringLength,
-			maxStringLength,
-			this.state.rng,
-		);
-		for (let j = 0; j < strLength; j++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				stringChars.length - 1,
-				this.state.rng,
-			);
-			currStr += stringChars[idx];
-		}
-		return currStr;
-	}
-}
-
-// has a newer version
-export class GenerateUniqueString extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueString';
-
-	private state: { rng: prand.RandomGenerator } | undefined;
-	public override isUnique = true;
-
-	override init({ seed }: { seed: number }) {
-		const rng = prand.xoroshiro128plus(seed);
-		this.state = { rng };
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const minStringLength = 7;
-		const maxStringLength = 20;
-		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-		let idx: number,
-			strLength: number;
-		let currStr: string;
-
-		currStr = '';
-		const uniqueStr = i.toString(16);
-		[strLength, this.state.rng] = prand.uniformIntDistribution(
-			minStringLength,
-			maxStringLength - uniqueStr.length,
-			this.state.rng,
-		);
-		for (let j = 0; j < strLength - uniqueStr.length; j++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				stringChars.length - 1,
-				this.state.rng,
-			);
-			currStr += stringChars[idx];
-		}
-
-		return currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
-	}
-}
-
-export class GenerateUUID extends AbstractGenerator<{
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateUUID';
-
-	public override isUnique = true;
-
-	private state: { rng: prand.RandomGenerator } | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-		// TODO generate uuid using string generator
-		const stringChars = '1234567890abcdef';
-		let idx: number,
-			currStr: string;
-		const strLength = 36;
-
-		// uuid v4
-		const uuidTemplate = '########-####-4###-####-############';
-		currStr = '';
-		for (let i = 0; i < strLength; i++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				stringChars.length - 1,
-				this.state.rng,
-			);
-
-			if (uuidTemplate[i] === '#') {
-				currStr += stringChars[idx];
-				continue;
-			}
-			currStr += uuidTemplate[i];
-		}
-		return currStr;
-	}
-}
-
-export class GenerateFirstName extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateFirstName';
-
-	override timeSpent: number = 0;
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueFirstName;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxFirstNameLength) {
-			throw new Error(
-				`You can't use first name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxFirstNameLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		// logic for this generator
-		// names dataset contains about 30000 unique names.
-		let idx: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
-		return firstNames[idx] as string;
-	}
-}
-
-export class GenerateUniqueFirstName extends AbstractGenerator<{
-	isUnique?: boolean;
-}> {
-	static override readonly entityKind: string = 'GenerateUniqueFirstName';
-
-	private state: {
-		genIndicesObj: GenerateUniqueInt;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		if (count > firstNames.length) {
-			throw new Error('count exceeds max number of unique first names.');
-		}
-
-		if (this.stringLength !== undefined && this.stringLength < maxFirstNameLength) {
-			throw new Error(
-				`You can't use first name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxFirstNameLength}.`,
-			);
-		}
-
-		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: firstNames.length - 1 });
-		genIndicesObj.init({ count, seed });
-
-		this.state = { genIndicesObj };
-	}
-
-	generate() {
-		// names dataset contains about 30000 unique names.
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const nameIdx = this.state.genIndicesObj.generate() as number;
-		const name = firstNames[nameIdx] as string;
-
-		return name;
-	}
-}
-
-export class GenerateLastName extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateLastName';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueLastName;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxLastNameLength) {
-			throw new Error(
-				`You can't use last name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxLastNameLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
-		return lastNames[idx];
-	}
-}
-
-export class GenerateUniqueLastName extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueLastName';
-
-	private state: {
-		genIndicesObj: GenerateUniqueInt;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		if (count > lastNames.length) {
-			throw new Error('count exceeds max number of unique last names.');
-		}
-
-		if (this.stringLength !== undefined && this.stringLength < maxLastNameLength) {
-			throw new Error(
-				`You can't use last name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxLastNameLength}.`,
-			);
-		}
-
-		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: lastNames.length - 1 });
-		genIndicesObj.init({ count, seed });
-
-		this.state = { genIndicesObj };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const surnameIdx = this.state.genIndicesObj.generate() as number;
-		const surname = lastNames[surnameIdx] as string;
-
-		return surname;
-	}
-}
-
-export class GenerateFullName extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateFullName';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueFullName;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < (maxFirstNameLength + maxLastNameLength + 1)) {
-			throw new Error(
-				`You can't use full name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${
-					maxFirstNameLength + maxLastNameLength + 1
-				}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
-		const name = firstNames[idx] as string;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
-		const surname = lastNames[idx] as string;
-
-		const fullName = `${name} ${surname}`;
-
-		return fullName;
-	}
-}
-
-export class GenerateUniqueFullName extends AbstractGenerator<{
-	isUnique?: boolean;
-}> {
-	static override readonly entityKind: string = 'GenerateUniqueFullName';
-
-	private state: {
-		fullnameSet: Set<string>;
-		rng: prand.RandomGenerator;
-	} | undefined;
-	public override isUnique = true;
-	public override timeSpent = 0;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const t0 = new Date();
-
-		const maxUniqueFullNamesNumber = firstNames.length * lastNames.length;
-		if (count > maxUniqueFullNamesNumber) {
-			throw new RangeError(
-				`count exceeds max number of unique full names(${maxUniqueFullNamesNumber}).`,
-			);
-		}
-
-		if (this.stringLength !== undefined && this.stringLength < (maxFirstNameLength + maxLastNameLength + 1)) {
-			throw new Error(
-				`You can't use full name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${
-					maxFirstNameLength + maxLastNameLength + 1
-				}.`,
-			);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		const fullnameSet = new Set<string>();
-
-		this.state = { rng, fullnameSet };
-		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let fullname: string, name: string, surname: string, idx: number;
-
-		const t0 = new Date();
-		for (;;) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, firstNames.length - 1, this.state.rng);
-			name = firstNames[idx] as string;
-
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
-			surname = lastNames[idx] as string;
-
-			fullname = `${name} ${surname}`;
-
-			if (!this.state.fullnameSet.has(fullname)) {
-				this.state.fullnameSet.add(fullname);
-				break;
-			}
-		}
-
-		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
-		return fullname;
-	}
-}
-
-export class GenerateEmail extends AbstractGenerator<{
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateEmail';
-
-	private state: {
-		genIndicesObj: GenerateUniqueInt;
-		arraysToGenerateFrom: string[][];
-	} | undefined;
-	public override timeSpent: number = 0;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const domainsArray = emailDomains;
-		const adjectivesArray = adjectives;
-		const namesArray = firstNames;
-
-		const maxUniqueEmailsNumber = adjectivesArray.length * namesArray.length * domainsArray.length;
-		if (count > maxUniqueEmailsNumber) {
-			throw new RangeError(
-				`count exceeds max number of unique emails(${maxUniqueEmailsNumber}).`,
-			);
-		}
-
-		const maxEmailLength = maxAdjectiveLength + maxFirstNameLength + maxEmailDomainLength + 2;
-		if (this.stringLength !== undefined && this.stringLength < maxEmailLength) {
-			throw new Error(
-				`You can't use email generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxEmailLength}.`,
-			);
-		}
-
-		const arraysToGenerateFrom = [adjectivesArray, namesArray, domainsArray];
-		const genIndicesObj = new GenerateUniqueInt({
-			minValue: 0,
-			maxValue: maxUniqueEmailsNumber - 1,
-		});
-		genIndicesObj.init({ count, seed });
-
-		this.state = { genIndicesObj, arraysToGenerateFrom };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const t0 = new Date();
-		const emailIndex = this.state.genIndicesObj.generate() as number;
-		this.timeSpent += (Date.now() - t0.getTime()) / 1000;
-		const tokens = fastCartesianProduct(
-			this.state.arraysToGenerateFrom,
-			emailIndex,
-		) as string[];
-
-		const [adjective, name, domain] = [tokens[0] as string, tokens[1] as string, tokens[2] as string];
-
-		const email = `${adjective}_${name.toLowerCase()}@${domain}`;
-
-		return email;
-	}
-}
-
-export class GeneratePhoneNumber extends AbstractGenerator<{
-	template?: string;
-	prefixes?: string[];
-	generatedDigitsNumbers?: number | number[];
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GeneratePhoneNumber';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		placeholdersCount?: number;
-		prefixesArray: string[];
-		generatedDigitsNumbers: number[];
-		generatorsMap: Map<string, GenerateUniqueInt>;
-		phoneNumbersSet: Set<string>;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		let { generatedDigitsNumbers } = this.params;
-		const { prefixes, template } = this.params;
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (template !== undefined) {
-			if (this.stringLength !== undefined && this.stringLength < template.length) {
-				throw new Error(
-					`Length of phone number template is shorter than db column length restriction: ${this.stringLength}. 
-					Set the maximum string length to at least ${template.length}.`,
-				);
-			}
-
-			const iterArray = [...template.matchAll(/#/g)];
-			const placeholdersCount = iterArray.length;
-
-			const maxUniquePhoneNumbersCount = Math.pow(10, placeholdersCount);
-			if (maxUniquePhoneNumbersCount < count) {
-				throw new RangeError(
-					`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`,
-				);
-			}
-
-			const generatorsMap = new Map<string, GenerateUniqueInt>();
-			const genObj = new GenerateUniqueInt({ minValue: 0, maxValue: maxUniquePhoneNumbersCount - 1 });
-			genObj.init({
-				count,
-				seed,
-			});
-
-			generatorsMap.set(
-				template,
-				genObj,
-			);
-
-			const prefixesArray: string[] = [];
-			const generatedDigitsNumbers: number[] = [];
-			const phoneNumbersSet = new Set<string>();
-
-			this.state = { rng, placeholdersCount, generatorsMap, prefixesArray, generatedDigitsNumbers, phoneNumbersSet };
-			return;
-		}
-
-		let prefixesArray: string[];
-		if (prefixes === undefined || prefixes.length === 0) {
-			prefixesArray = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
-			generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
-				// tokens = ["380","99","9"] =
-				// = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
-				const tokens = phoneInfo.split(',');
-				const operatorPrefixLength = tokens[1]!.replaceAll(' ', '').length;
-
-				return Number(tokens[2]) - operatorPrefixLength;
-			});
-		} else {
-			prefixesArray = prefixes;
-			if (typeof generatedDigitsNumbers === 'number') {
-				generatedDigitsNumbers = Array.from<number>({ length: prefixes.length }).fill(
-					generatedDigitsNumbers,
-				);
-			} else if (
-				generatedDigitsNumbers === undefined
-				|| generatedDigitsNumbers.length === 0
-			) {
-				generatedDigitsNumbers = Array.from<number>({ length: prefixes.length }).fill(7);
-			}
-		}
-
-		const maxPrefixLength = Math.max(...prefixesArray.map((prefix) => prefix.length));
-		const maxGeneratedDigits = Math.max(...generatedDigitsNumbers);
-
-		if (this.stringLength !== undefined && this.stringLength < (maxPrefixLength + maxGeneratedDigits)) {
-			throw new Error(
-				`You can't use phone number generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${
-					maxPrefixLength + maxGeneratedDigits
-				}.`,
-			);
-		}
-
-		if (new Set(prefixesArray).size !== prefixesArray.length) {
-			throw new Error('prefixes are not unique.');
-		}
-
-		const maxUniquePhoneNumbersCount = generatedDigitsNumbers.reduce(
-			(a, b) => a + Math.pow(10, b),
-			0,
-		);
-		if (maxUniquePhoneNumbersCount < count) {
-			throw new RangeError(
-				`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`,
-			);
-		}
-
-		const generatorsMap = new Map<string, GenerateUniqueInt>();
-		let maxValue: number, prefix: string, generatedDigitsNumber: number;
-		for (const [i, element] of prefixesArray.entries()) {
-			prefix = element as string;
-			generatedDigitsNumber = generatedDigitsNumbers[i] as number;
-			maxValue = Math.pow(10, generatedDigitsNumber) - 1;
-
-			if (!generatorsMap.has(prefix)) {
-				const genObj = new GenerateUniqueInt({ minValue: 0, maxValue });
-				genObj.init({
-					count: Math.min(count, maxValue + 1),
-					seed,
-				});
-				genObj.skipCheck = true;
-				generatorsMap.set(
-					prefix,
-					genObj,
-				);
-			}
-		}
-		const phoneNumbersSet = new Set<string>();
-
-		this.state = { rng, prefixesArray, generatedDigitsNumbers, generatorsMap, phoneNumbersSet };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let prefix: string, generatedDigitsNumber: number, numberBody: string, phoneNumber: string, idx: number;
-
-		if (this.params.template === undefined) {
-			for (;;) {
-				[idx, this.state.rng] = prand.uniformIntDistribution(
-					0,
-					this.state.prefixesArray.length - 1,
-					this.state.rng,
-				);
-				prefix = this.state.prefixesArray[idx] as string;
-				generatedDigitsNumber = this.state.generatedDigitsNumbers[idx] as number;
-
-				numberBody = String(this.state.generatorsMap.get(prefix)?.generate());
-				if (numberBody === 'undefined') {
-					this.state.prefixesArray!.splice(idx, 1);
-					this.state.generatedDigitsNumbers.splice(idx, 1);
-
-					this.state.generatorsMap.delete(prefix);
-
-					continue;
-				}
-
-				if (this.state.phoneNumbersSet.has(numberBody)) {
-					continue;
-				}
-				this.state.phoneNumbersSet.add(numberBody);
-
-				break;
-			}
-
-			const digitsNumberDiff = generatedDigitsNumber - numberBody.length;
-			if (digitsNumberDiff > 0) {
-				numberBody = '0'.repeat(digitsNumberDiff) + numberBody;
-			}
-
-			phoneNumber = prefix + '' + numberBody;
-
-			return phoneNumber;
-		} else {
-			numberBody = String(this.state.generatorsMap.get(this.params.template)?.generate());
-			phoneNumber = fillTemplate({
-				template: this.params.template,
-				values: [...numberBody],
-				defaultValue: '0',
-				placeholdersCount: this.state.placeholdersCount,
-			});
-
-			return phoneNumber;
-		}
-	}
-}
-
-export class GenerateCountry extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateCountry';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueCountry;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxCountryLength) {
-			throw new Error(
-				`You can't use country generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCountryLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, countries.length - 1, this.state.rng);
-		const country = countries[idx] as string;
-
-		return country;
-	}
-}
-
-export class GenerateUniqueCountry extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueCountry';
-
-	private state: {
-		genIndicesObj: GenerateUniqueInt;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		if (count > countries.length) {
-			throw new Error('count exceeds max number of unique countries.');
-		}
-
-		if (this.stringLength !== undefined && this.stringLength < maxCountryLength) {
-			throw new Error(
-				`You can't use country generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCountryLength}.`,
-			);
-		}
-
-		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: countries.length - 1 });
-		genIndicesObj.init({ count, seed });
-
-		this.state = { genIndicesObj };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const countryIdx = this.state.genIndicesObj.generate() as number;
-		const country = countries[countryIdx] as string;
-
-		return country;
-	}
-}
-
-export class GenerateJobTitle extends AbstractGenerator<{
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateJobTitle';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxJobTitleLength) {
-			throw new Error(
-				`You can't use job title generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxJobTitleLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-		let idx;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, jobsTitles.length - 1, this.state.rng);
-
-		return jobsTitles[idx];
-	}
-}
-
-export class GenerateStreetAddress extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateStreetAddress';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		possStreetNames: string[][];
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueStreetAddress;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		const possStreetNames = [firstNames, lastNames];
-
-		const maxStreetAddressLength = 4 + Math.max(maxFirstNameLength, maxLastNameLength) + 1 + maxStreetSuffixLength;
-		if (this.stringLength !== undefined && this.stringLength < maxStreetAddressLength) {
-			throw new Error(
-				`You can't use street address generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStreetAddressLength}.`,
-			);
-		}
-
-		this.state = { rng, possStreetNames };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx, streetBaseNameIdx, streetSuffixIdx, streetNumber;
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.possStreetNames.length - 1, this.state.rng);
-
-		[streetBaseNameIdx, this.state.rng] = prand.uniformIntDistribution(
-			0,
-			this.state.possStreetNames[idx]!.length - 1,
-			this.state.rng,
-		);
-		[streetSuffixIdx, this.state.rng] = prand.uniformIntDistribution(0, streetSuffix.length - 1, this.state.rng);
-		const streetName = `${this.state.possStreetNames[idx]![streetBaseNameIdx]} ${streetSuffix[streetSuffixIdx]}`;
-
-		[streetNumber, this.state.rng] = prand.uniformIntDistribution(1, 999, this.state.rng);
-
-		return `${streetNumber} ${streetName}`;
-	}
-}
-
-export class GenerateUniqueStreetAddress extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueStreetAddress';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		possStreetNameObjs: {
-			indicesGen: GenerateUniqueInt;
-			maxUniqueStreetNamesNumber: number;
-			count: number;
-			arraysToChooseFrom: string[][];
-		}[];
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const streetNumberStrs = Array.from({ length: 999 }, (_, i) => String(i + 1));
-		const maxUniqueStreetnamesNumber = streetNumberStrs.length * firstNames.length * streetSuffix.length
-			+ streetNumberStrs.length * firstNames.length * streetSuffix.length;
-
-		if (count > maxUniqueStreetnamesNumber) {
-			throw new RangeError(
-				`count exceeds max number of unique street names(${maxUniqueStreetnamesNumber}).`,
-			);
-		}
-
-		const maxStreetAddressLength = 4 + Math.max(maxFirstNameLength, maxLastNameLength) + 1 + maxStreetSuffixLength;
-		if (this.stringLength !== undefined && this.stringLength < maxStreetAddressLength) {
-			throw new Error(
-				`You can't use street address generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStreetAddressLength}.`,
-			);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		// ["1", "2", ..., "999"]
-
-		const possStreetNameObjs = [
-			{
-				indicesGen: new GenerateUniqueInt({
-					minValue: 0,
-					maxValue: streetNumberStrs.length * firstNames.length * streetSuffix.length - 1,
-				}),
-				maxUniqueStreetNamesNumber: streetNumberStrs.length * firstNames.length * streetSuffix.length,
-				count: 0,
-				arraysToChooseFrom: [streetNumberStrs, firstNames, streetSuffix],
-			},
-			{
-				indicesGen: new GenerateUniqueInt({
-					minValue: 0,
-					maxValue: streetNumberStrs.length * lastNames.length * streetSuffix.length - 1,
-				}),
-				maxUniqueStreetNamesNumber: streetNumberStrs.length * firstNames.length * streetSuffix.length,
-				count: 0,
-				arraysToChooseFrom: [streetNumberStrs, lastNames, streetSuffix],
-			},
-		];
-
-		for (const possStreetNameObj of possStreetNameObjs) {
-			possStreetNameObj.indicesGen.skipCheck = true;
-			possStreetNameObj.indicesGen.init({ count, seed });
-		}
-
-		this.state = { rng, possStreetNameObjs };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let streetNameObjIdx;
-		[streetNameObjIdx, this.state.rng] = prand.uniformIntDistribution(
-			0,
-			this.state.possStreetNameObjs.length - 1,
-			this.state.rng,
-		);
-		const streetNameObj = this.state.possStreetNameObjs[streetNameObjIdx]!;
-
-		const idx = streetNameObj.indicesGen.generate() as number;
-		const values = fastCartesianProduct(streetNameObj.arraysToChooseFrom, idx) as string[];
-
-		streetNameObj.count += 1;
-		if (streetNameObj.count === streetNameObj.maxUniqueStreetNamesNumber) {
-			this.state.possStreetNameObjs[streetNameObjIdx] = this.state
-				.possStreetNameObjs.at(-1)!;
-			this.state.possStreetNameObjs.pop();
-		}
-
-		const streetName = fillTemplate({ template: '# # #', values, placeholdersCount: 3 });
-
-		return streetName;
-	}
-}
-
-export class GenerateCity extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateCity';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueCity;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxCityNameLength) {
-			throw new Error(
-				`You can't use city generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCityNameLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx;
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, cityNames.length - 1, this.state.rng);
-
-		return cityNames[idx];
-	}
-}
-
-export class GenerateUniqueCity extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueCity';
-
-	private state: {
-		genIndicesObj: GenerateUniqueInt;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		if (count > cityNames.length) {
-			throw new Error('count exceeds max number of unique cities.');
-		}
-
-		if (this.stringLength !== undefined && this.stringLength < maxCityNameLength) {
-			throw new Error(
-				`You can't use city generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCityNameLength}.`,
-			);
-		}
-
-		const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: cityNames.length - 1 });
-		genIndicesObj.init({ count, seed });
-
-		this.state = { genIndicesObj };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const cityIdx = this.state.genIndicesObj.generate() as number;
-		const city = cityNames[cityIdx] as string;
-
-		return city;
-	}
-}
-
-export class GeneratePostcode extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GeneratePostcode';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		templates: string[];
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniquePostcode;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		const templates = ['#####', '#####-####'];
-
-		const maxPostcodeLength = Math.max(...templates.map((template) => template.length));
-		if (this.stringLength !== undefined && this.stringLength < maxPostcodeLength) {
-			throw new Error(
-				`You can't use postcode generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxPostcodeLength}.`,
-			);
-		}
-
-		this.state = { rng, templates };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number, postcodeNumber: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
-		const template = this.state.templates[idx]!;
-
-		const iterArray = [...template.matchAll(/#/g)];
-		const placeholdersCount = iterArray.length;
-
-		[postcodeNumber, this.state.rng] = prand.uniformIntDistribution(
-			0,
-			Math.pow(10, placeholdersCount) - 1,
-			this.state.rng,
-		);
-		const postcode = fillTemplate({
-			template,
-			placeholdersCount,
-			values: [...String(postcodeNumber)],
-			defaultValue: '0',
-		});
-
-		return postcode;
-	}
-}
-
-export class GenerateUniquePostcode extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniquePostcode';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		templates: {
-			template: string;
-			indicesGen: GenerateUniqueInt;
-			placeholdersCount: number;
-			count: number;
-			maxUniquePostcodeNumber: number;
-		}[];
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const maxUniquePostcodeNumber = Math.pow(10, 5) + Math.pow(10, 9);
-		if (count > maxUniquePostcodeNumber) {
-			throw new RangeError(
-				`count exceeds max number of unique postcodes(${maxUniquePostcodeNumber}).`,
-			);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		const templates = [
-			{
-				template: '#####',
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(10, 5) - 1 }),
-				placeholdersCount: 5,
-				count: 0,
-				maxUniquePostcodeNumber: Math.pow(10, 5),
-			},
-			{
-				template: '#####-####',
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(10, 9) - 1 }),
-				placeholdersCount: 9,
-				count: 0,
-				maxUniquePostcodeNumber: Math.pow(10, 9),
-			},
-		];
-
-		const maxPostcodeLength = Math.max(...templates.map((template) => template.template.length));
-		if (this.stringLength !== undefined && this.stringLength < maxPostcodeLength) {
-			throw new Error(
-				`You can't use postcode generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxPostcodeLength}.`,
-			);
-		}
-
-		for (const templateObj of templates) {
-			templateObj.indicesGen.skipCheck = true;
-			templateObj.indicesGen.init({ count, seed });
-		}
-
-		this.state = { rng, templates };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number;
-
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
-		const templateObj = this.state.templates[idx]!;
-
-		const postcodeNumber = templateObj.indicesGen.generate() as number;
-
-		templateObj.count += 1;
-		if (templateObj.count === templateObj.maxUniquePostcodeNumber) {
-			this.state.templates[idx] = this.state.templates.at(-1)!;
-			this.state.templates.pop();
-		}
-
-		const postcode = fillTemplate({
-			template: templateObj.template,
-			placeholdersCount: templateObj.placeholdersCount,
-			values: [...String(postcodeNumber)],
-			defaultValue: '0',
-		});
-
-		return postcode;
-	}
-}
-
-export class GenerateState extends AbstractGenerator<{
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateState';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		if (this.stringLength !== undefined && this.stringLength < maxStateLength) {
-			throw new Error(
-				`You can't use state generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxStateLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx;
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, states.length - 1, this.state.rng);
-
-		return states[idx];
-	}
-}
-
-export class GenerateCompanyName extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateCompanyName';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		templates: { template: string; placeholdersCount: number }[];
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueCompanyName;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		const templates = [
-			{ template: '#', placeholdersCount: 1 },
-			{ template: '# - #', placeholdersCount: 2 },
-			{ template: '# and #', placeholdersCount: 2 },
-			{ template: '#, # and #', placeholdersCount: 3 },
-		];
-
-		// max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
-		const maxCompanyNameLength = Math.max(
-			maxLastNameLength + maxCompanyNameSuffixLength + 1,
-			3 * maxLastNameLength + 7,
-		);
-		if (this.stringLength !== undefined && this.stringLength < maxCompanyNameLength) {
-			throw new Error(
-				`You can't use company name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCompanyNameLength}.`,
-			);
-		}
-
-		this.state = { rng, templates };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let templateIdx, idx, lastName, companyNameSuffix, companyName;
-		[templateIdx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
-		const templateObj = this.state.templates[templateIdx]!;
-
-		if (templateObj.template === '#') {
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
-			lastName = lastNames[idx];
-
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, companyNameSuffixes.length - 1, this.state.rng);
-			companyNameSuffix = companyNameSuffixes[idx];
-
-			companyName = `${lastName} ${companyNameSuffix}`;
-			return companyName;
-		}
-
-		const values = [];
-		for (let i = 0; i < templateObj.placeholdersCount; i++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, lastNames.length - 1, this.state.rng);
-			values.push(lastNames[idx]!);
-		}
-
-		companyName = fillTemplate({
-			template: templateObj.template,
-			values,
-			placeholdersCount: templateObj.placeholdersCount,
-		});
-		return companyName;
-	}
-}
-
-export class GenerateUniqueCompanyName extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly entityKind: string = 'GenerateUniqueCompanyName';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		templates: {
-			template: string;
-			placeholdersCount: number;
-			indicesGen: GenerateUniqueInt;
-			maxUniqueCompanyNameNumber: number;
-			count: number;
-			arraysToChooseFrom: string[][];
-		}[];
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const maxUniqueCompanyNameNumber = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
-			+ Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
-		if (count > maxUniqueCompanyNameNumber) {
-			throw new RangeError(
-				`count exceeds max number of unique company names(${maxUniqueCompanyNameNumber}).`,
-			);
-		}
-
-		// max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
-		const maxCompanyNameLength = Math.max(
-			maxLastNameLength + maxCompanyNameSuffixLength + 1,
-			3 * maxLastNameLength + 7,
-		);
-		if (this.stringLength !== undefined && this.stringLength < maxCompanyNameLength) {
-			throw new Error(
-				`You can't use company name generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxCompanyNameLength}.`,
-			);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		// when count reach maxUniqueCompanyNameNumber template will be deleted from array
-		const templates = [
-			{
-				template: '# - #',
-				placeholdersCount: 1,
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: lastNames.length * companyNameSuffixes.length - 1 }),
-				maxUniqueCompanyNameNumber: lastNames.length * companyNameSuffixes.length,
-				count: 0,
-				arraysToChooseFrom: [lastNames, companyNameSuffixes],
-			},
-			{
-				template: '# - #',
-				placeholdersCount: 2,
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 2) - 1 }),
-				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 2),
-				count: 0,
-				arraysToChooseFrom: [lastNames, lastNames],
-			},
-			{
-				template: '# and #',
-				placeholdersCount: 2,
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 2) - 1 }),
-				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 2),
-				count: 0,
-				arraysToChooseFrom: [lastNames, lastNames],
-			},
-			{
-				template: '#, # and #',
-				placeholdersCount: 3,
-				indicesGen: new GenerateUniqueInt({ minValue: 0, maxValue: Math.pow(lastNames.length, 3) - 1 }),
-				maxUniqueCompanyNameNumber: Math.pow(lastNames.length, 3),
-				count: 0,
-				arraysToChooseFrom: [lastNames, lastNames, lastNames],
-			},
-		];
-
-		for (const templateObj of templates) {
-			templateObj.indicesGen.skipCheck = true;
-			templateObj.indicesGen.init({ count, seed });
-		}
-
-		this.state = { rng, templates };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let templateIdx;
-		[templateIdx, this.state.rng] = prand.uniformIntDistribution(0, this.state.templates.length - 1, this.state.rng);
-		const templateObj = this.state.templates[templateIdx]!;
-
-		const idx = templateObj.indicesGen.generate() as number;
-		const values = fastCartesianProduct(templateObj.arraysToChooseFrom, idx) as string[];
-
-		templateObj.count += 1;
-		if (templateObj.count === templateObj.maxUniqueCompanyNameNumber) {
-			this.state.templates[templateIdx] = this.state.templates.at(-1)!;
-			this.state.templates.pop();
-		}
-
-		const companyName = fillTemplate({
-			template: templateObj.template,
-			values,
-			placeholdersCount: templateObj.placeholdersCount,
-		});
-		return companyName;
-	}
-}
-
-export class GenerateLoremIpsum extends AbstractGenerator<{
-	sentencesCount?: number;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateLoremIpsum';
-
-	private state: {
-		rng: prand.RandomGenerator;
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const rng = prand.xoroshiro128plus(seed);
-		if (this.params.sentencesCount === undefined) this.params.sentencesCount = 1;
-
-		const maxLoremIpsumSentencesLength = maxLoremIpsumLength * this.params.sentencesCount + this.params.sentencesCount
-			- 1;
-		if (this.stringLength !== undefined && this.stringLength < maxLoremIpsumSentencesLength) {
-			throw new Error(
-				`You can't use lorem ipsum generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxLoremIpsumSentencesLength}.`,
-			);
-		}
-
-		this.state = { rng };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx, resultText: string = '';
-		for (let i = 0; i < this.params.sentencesCount!; i++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(0, loremIpsumSentences.length - 1, this.state.rng);
-			resultText += loremIpsumSentences[idx] + ' ';
-		}
-
-		return resultText;
-	}
-}
-
-export class WeightedRandomGenerator extends AbstractGenerator<{ weight: number; value: AbstractGenerator<any> }[]> {
-	static override readonly entityKind: string = 'WeightedRandomGenerator';
-
-	private state: {
-		rng: prand.RandomGenerator;
-		weightedIndices: number[];
-	} | undefined;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const weights = this.params.map((weightedGen) => weightedGen.weight);
-		const weightedIndices = getWeightedIndices(weights);
-
-		let idx: number, valueIdx: number, tempRng = prand.xoroshiro128plus(seed);
-		const indicesCounter: { [key: number]: number } = {};
-		for (let i = 0; i < count; i++) {
-			[idx, tempRng] = prand.uniformIntDistribution(0, weightedIndices.length - 1, tempRng);
-			valueIdx = weightedIndices[idx]!;
-			if (!Object.hasOwn(indicesCounter, valueIdx)) indicesCounter[valueIdx] = 0;
-			indicesCounter[valueIdx]! += 1;
-		}
-
-		for (const [idx, weightedGen] of this.params.entries()) {
-			weightedGen.value.isUnique = this.isUnique;
-			weightedGen.value.dataType = this.dataType;
-			weightedGen.value.init({ count: indicesCounter[idx]!, seed });
-
-			if (
-				weightedGen.value.uniqueVersionOfGen !== undefined
-				&& weightedGen.value.isUnique === true
-			) {
-				const uniqueGen = new weightedGen.value.uniqueVersionOfGen({
-					...weightedGen.value.params,
-				});
-				uniqueGen.init({
-					count: indicesCounter[idx]!,
-					seed,
-				});
-				uniqueGen.isUnique = weightedGen.value.isUnique;
-				uniqueGen.dataType = weightedGen.value.dataType;
-
-				weightedGen.value = uniqueGen;
-			}
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-
-		this.state = { weightedIndices, rng };
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let idx: number;
-		[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
-		const generatorIdx = this.state.weightedIndices[idx] as number;
-		const value = this.params[generatorIdx]!.value.generate({ i });
-
-		return value;
-	}
-}
-
-export class GeneratePoint extends AbstractGenerator<{
-	isUnique?: boolean;
-	minXValue?: number;
-	maxXValue?: number;
-	minYValue?: number;
-	maxYValue?: number;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GeneratePoint';
-
-	private state: {
-		xCoordinateGen: GenerateNumber;
-		yCoordinateGen: GenerateNumber;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniquePoint;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const xCoordinateGen = new GenerateNumber({
-			minValue: this.params.minXValue,
-			maxValue: this.params.maxXValue,
-			precision: 10,
-		});
-		xCoordinateGen.init({ count, seed });
-
-		const yCoordinateGen = new GenerateNumber({
-			minValue: this.params.minYValue,
-			maxValue: this.params.maxYValue,
-			precision: 10,
-		});
-		yCoordinateGen.init({ count, seed });
-
-		this.state = { xCoordinateGen, yCoordinateGen };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const x = this.state.xCoordinateGen.generate();
-		const y = this.state.yCoordinateGen.generate();
-
-		if (this.dataType === 'json') {
-			return { x, y };
-		} else if (this.dataType === 'string') {
-			return `[${x}, ${y}]`;
-		} else {
-			// if (this.dataType === "array")
-			return [x, y];
-		}
-	}
-}
-
-export class GenerateUniquePoint extends AbstractGenerator<{
-	minXValue?: number;
-	maxXValue?: number;
-	minYValue?: number;
-	maxYValue?: number;
-	isUnique?: boolean;
-}> {
-	static override readonly entityKind: string = 'GenerateUniquePoint';
-
-	private state: {
-		xCoordinateGen: GenerateUniqueNumber;
-		yCoordinateGen: GenerateUniqueNumber;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const xCoordinateGen = new GenerateUniqueNumber({
-			minValue: this.params.minXValue,
-			maxValue: this.params.maxXValue,
-			precision: 10,
-		});
-		xCoordinateGen.init({ count, seed });
-
-		const yCoordinateGen = new GenerateUniqueNumber({
-			minValue: this.params.minYValue,
-			maxValue: this.params.maxYValue,
-			precision: 10,
-		});
-		yCoordinateGen.init({ count, seed });
-
-		this.state = { xCoordinateGen, yCoordinateGen };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const x = this.state.xCoordinateGen.generate();
-		const y = this.state.yCoordinateGen.generate();
-
-		if (this.dataType === 'json') {
-			return { x, y };
-		} else if (this.dataType === 'string') {
-			return `[${x}, ${y}]`;
-		} else {
-			// if (this.dataType === "array")
-			return [x, y];
-		}
-	}
-}
-
-export class GenerateLine extends AbstractGenerator<{
-	isUnique?: boolean;
-	minAValue?: number;
-	maxAValue?: number;
-	minBValue?: number;
-	maxBValue?: number;
-	minCValue?: number;
-	maxCValue?: number;
-	arraySize?: number;
-}> {
-	static override readonly entityKind: string = 'GenerateLine';
-
-	private state: {
-		aCoefficientGen: GenerateNumber;
-		bCoefficientGen: GenerateNumber;
-		cCoefficientGen: GenerateNumber;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueLine;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		const aCoefficientGen = new GenerateNumber({
-			minValue: this.params.minAValue,
-			maxValue: this.params.maxAValue,
-			precision: 10,
-		});
-		aCoefficientGen.init({ count, seed });
-
-		const bCoefficientGen = new GenerateNumber({
-			minValue: this.params.minBValue,
-			maxValue: this.params.maxBValue,
-			precision: 10,
-		});
-		bCoefficientGen.init({ count, seed });
-
-		const cCoefficientGen = new GenerateNumber({
-			minValue: this.params.minCValue,
-			maxValue: this.params.maxCValue,
-			precision: 10,
-		});
-		cCoefficientGen.init({ count, seed });
-
-		this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let b: number;
-		const a = this.state.aCoefficientGen.generate();
-
-		b = this.state.bCoefficientGen.generate();
-		while (a === 0 && b === 0) {
-			b = this.state.bCoefficientGen.generate();
-		}
-
-		const c = this.state.cCoefficientGen.generate();
-
-		if (this.dataType === 'json') {
-			return { a, b, c };
-		} else if (this.dataType === 'string') {
-			return `[${a}, ${b}, ${c}]`;
-		} else {
-			// if (this.dataType === "array")
-			return [a, b, c];
-		}
-	}
-}
-
-export class GenerateUniqueLine extends AbstractGenerator<{
-	minAValue?: number;
-	maxAValue?: number;
-	minBValue?: number;
-	maxBValue?: number;
-	minCValue?: number;
-	maxCValue?: number;
-	isUnique?: boolean;
-}> {
-	static override readonly entityKind: string = 'GenerateUniqueLine';
-
-	private state: {
-		aCoefficientGen: GenerateUniqueNumber;
-		bCoefficientGen: GenerateUniqueNumber;
-		cCoefficientGen: GenerateUniqueNumber;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const aCoefficientGen = new GenerateUniqueNumber({
-			minValue: this.params.minAValue,
-			maxValue: this.params.maxAValue,
-			precision: 10,
-		});
-		aCoefficientGen.init({ count, seed });
-
-		const bCoefficientGen = new GenerateUniqueNumber({
-			minValue: this.params.minBValue,
-			maxValue: this.params.maxBValue,
-			precision: 10,
-		});
-		bCoefficientGen.init({ count, seed });
-
-		const cCoefficientGen = new GenerateUniqueNumber({
-			minValue: this.params.minCValue,
-			maxValue: this.params.maxCValue,
-			precision: 10,
-		});
-		cCoefficientGen.init({ count, seed });
-
-		this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let b: number;
-		const a = this.state.aCoefficientGen.generate();
-
-		b = this.state.bCoefficientGen.generate();
-		while (a === 0 && b === 0) {
-			b = this.state.bCoefficientGen.generate();
-		}
-
-		const c = this.state.cCoefficientGen.generate();
-
-		if (this.dataType === 'json') {
-			return { a, b, c };
-		} else if (this.dataType === 'string') {
-			return `[${a}, ${b}, ${c}]`;
-		} else {
-			// if (this.dataType === "array")
-			return [a, b, c];
-		}
-	}
-}
diff --git a/drizzle-seed/src/services/SeedService.ts b/drizzle-seed/src/services/SeedService.ts
deleted file mode 100644
index 22d92655cd..0000000000
--- a/drizzle-seed/src/services/SeedService.ts
+++ /dev/null
@@ -1,1611 +0,0 @@
-/* eslint-disable drizzle-internal/require-entity-kind */
-import { entityKind, eq, is } from 'drizzle-orm';
-import type { MySqlTable, MySqlTableWithColumns } from 'drizzle-orm/mysql-core';
-import { MySqlDatabase } from 'drizzle-orm/mysql-core';
-import type { PgTable, PgTableWithColumns } from 'drizzle-orm/pg-core';
-import { PgDatabase } from 'drizzle-orm/pg-core';
-import type { SQLiteTable, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import type {
-	GeneratePossibleGeneratorsColumnType,
-	GeneratePossibleGeneratorsTableType,
-	RefinementsType,
-	TableGeneratorsType,
-} from '../types/seedService.ts';
-import type { Column, Prettify, Relation, Table } from '../types/tables.ts';
-import { generatorsMap } from './GeneratorFuncs.ts';
-import type { AbstractGenerator, GenerateArray, GenerateInterval, GenerateWeightedCount } from './Generators.ts';
-
-import { latestVersion } from './apiVersion.ts';
-import { equalSets, generateHashFromString } from './utils.ts';
-
-export class SeedService {
-	static readonly entityKind: string = 'SeedService';
-
-	private defaultCountForTable = 10;
-	private postgresPgLiteMaxParametersNumber = 32740;
-	private postgresMaxParametersNumber = 65535;
-	// there is no max parameters number in mysql, so you can increase mysqlMaxParametersNumber if it's needed.
-	private mysqlMaxParametersNumber = 100000;
-	//  SQLITE_MAX_VARIABLE_NUMBER, which by default equals to 999 for SQLite versions prior to 3.32.0 (2020-05-22) or 32766 for SQLite versions after 3.32.0.
-	private sqliteMaxParametersNumber = 32766;
-	private version?: number;
-
-	generatePossibleGenerators = (
-		connectionType: 'postgresql' | 'mysql' | 'sqlite',
-		tables: Table[],
-		relations: (Relation & { isCyclic: boolean })[],
-		refinements?: RefinementsType,
-		options?: { count?: number; seed?: number; version?: number },
-	) => {
-		let columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>;
-		let tablePossibleGenerators: Prettify<GeneratePossibleGeneratorsTableType>;
-		const customSeed = options?.seed === undefined ? 0 : options.seed;
-		this.version = options?.version === undefined ? latestVersion : options.version;
-		if (Number.isNaN(this.version) || this.version < 1 || this.version > latestVersion) {
-			throw new Error(`Version should be in range [1, ${latestVersion}].`);
-		}
-
-		// sorting table in order which they will be filled up (tables with foreign keys case)
-		const { tablesInOutRelations } = this.getInfoFromRelations(relations);
-		const orderedTablesNames = this.getOrderedTablesList(tablesInOutRelations);
-		tables = tables.sort((table1, table2) => {
-			const rel = relations.find((rel) => rel.table === table1.name && rel.refTable === table2.name);
-
-			if (rel?.isCyclic === true) {
-				const reverseRel = relations.find((rel) => rel.table === table2.name && rel.refTable === table1.name);
-				return this.cyclicTablesCompare(table1, table2, rel, reverseRel);
-			}
-
-			const table1Order = orderedTablesNames.indexOf(
-					table1.name,
-				),
-				table2Order = orderedTablesNames.indexOf(
-					table2.name,
-				);
-			return table1Order - table2Order;
-		});
-
-		const tableNamesSet = new Set(tables.map((table) => table.name));
-		const tablesPossibleGenerators: Prettify<
-			(typeof tablePossibleGenerators)[]
-		> = tables.map((table) => ({
-			tableName: table.name,
-			columnsPossibleGenerators: [],
-			withFromTable: {},
-		}));
-
-		for (const [i, table] of tables.entries()) {
-			// get foreignKey columns relations
-			const foreignKeyColumns: {
-				[columnName: string]: { table: string; column: string };
-			} = {};
-
-			for (
-				const rel of relations
-					.filter((rel) => rel.table === table.name)
-			) {
-				for (const [idx, col] of rel.columns.entries()) {
-					foreignKeyColumns[col] = {
-						table: rel.refTable,
-						column: rel.refColumns[idx] as string,
-					};
-				}
-			}
-
-			if (refinements !== undefined && refinements[table.name] !== undefined) {
-				if (refinements[table.name]!.count !== undefined) {
-					tablesPossibleGenerators[i]!.count = refinements[table.name]!.count;
-				}
-
-				if (refinements[table.name]!.with !== undefined) {
-					tablesPossibleGenerators[i]!.count = refinements[table.name]!.count
-						|| options?.count
-						|| this.defaultCountForTable;
-					let idx: number;
-					for (
-						const fkTableName of Object.keys(
-							refinements[table.name]!.with as {},
-						)
-					) {
-						if (!tablesInOutRelations[table.name]?.dependantTableNames.has(fkTableName)) {
-							const reason = tablesInOutRelations[table.name]?.selfRelation === true
-								? `"${table.name}" table has self reference`
-								: `"${fkTableName}" table doesn't have a reference to "${table.name}" table or`
-									+ `\nyou didn't include your one-to-many relation in the seed function schema`;
-							throw new Error(
-								`${reason}.` + `\nYou can't specify "${fkTableName}" as parameter in ${table.name}.with object.`
-									+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-using-with-option`,
-							);
-						}
-
-						idx = tablesPossibleGenerators.findIndex(
-							(table) => table.tableName === fkTableName,
-						);
-						if (idx !== -1) {
-							let newTableWithCount: number,
-								weightedCountSeed: number | undefined;
-							if (
-								typeof refinements![table.name]!.with![fkTableName] === 'number'
-							) {
-								newTableWithCount = (tablesPossibleGenerators[i]!.withCount
-									|| tablesPossibleGenerators[i]!.count)!
-									* (refinements[table.name]!.with![fkTableName] as number);
-							} else {
-								const weightedRepeatedValuesCount = refinements[table.name]!
-									.with![fkTableName] as {
-										weight: number;
-										count: number | number[];
-									}[];
-
-								weightedCountSeed = customSeed
-									+ generateHashFromString(`${table.name}.${fkTableName}`);
-
-								newTableWithCount = this.getWeightedWithCount(
-									weightedRepeatedValuesCount,
-									(tablesPossibleGenerators[i]!.withCount
-										|| tablesPossibleGenerators[i]!.count)!,
-									weightedCountSeed,
-								);
-							}
-
-							if (
-								tablesPossibleGenerators[idx]!.withCount === undefined
-								|| newTableWithCount > tablesPossibleGenerators[idx]!.withCount!
-							) {
-								tablesPossibleGenerators[idx]!.withCount = newTableWithCount;
-							}
-
-							tablesPossibleGenerators[idx]!.withFromTable[table.name] = {
-								repeatedValuesCount: refinements[table.name]!.with![fkTableName]!,
-								weightedCountSeed,
-							};
-						}
-					}
-				}
-			}
-			tablePossibleGenerators = tablesPossibleGenerators[i]!;
-			for (const col of table.columns) {
-				// col.myType = typeMap[col._type as keyof typeof typeMap];
-				columnPossibleGenerator = {
-					columnName: col.name,
-					isUnique: col.isUnique,
-					notNull: col.notNull,
-					primary: col.primary,
-					generatedIdentityType: col.generatedIdentityType,
-					generator: undefined,
-					isCyclic: false,
-					wasDefinedBefore: false,
-					wasRefined: false,
-				};
-
-				if (
-					refinements !== undefined
-					&& refinements[table.name] !== undefined
-					&& refinements[table.name]!.columns !== undefined
-					&& refinements[table.name]!.columns[col.name] !== undefined
-				) {
-					const genObj = refinements[table.name]!.columns[col.name]!;
-
-					if (col.columnType.match(/\[\w*]/g) !== null) {
-						if (
-							(col.baseColumn?.dataType === 'array' && col.baseColumn.columnType.match(/\[\w*]/g) !== null)
-							// studio case
-							|| (col.typeParams.dimensions !== undefined && col.typeParams.dimensions > 1)
-						) {
-							throw new Error("for now you can't specify generators for columns of dimension greater than 1.");
-						}
-
-						genObj.baseColumnDataType = col.baseColumn?.dataType;
-					}
-
-					columnPossibleGenerator.generator = genObj;
-					columnPossibleGenerator.wasRefined = true;
-				} else if (Object.hasOwn(foreignKeyColumns, col.name)) {
-					// TODO: I might need to assign repeatedValuesCount to column there instead of doing so in generateTablesValues
-					const cyclicRelation = relations.find((rel) =>
-						rel.table === table.name
-						&& rel.isCyclic === true
-						&& rel.columns.includes(col.name)
-					);
-
-					if (cyclicRelation !== undefined) {
-						columnPossibleGenerator.isCyclic = true;
-					}
-
-					if (
-						(foreignKeyColumns[col.name]?.table === undefined || !tableNamesSet.has(foreignKeyColumns[col.name]!.table))
-						&& col.notNull === true
-					) {
-						throw new Error(
-							`Column '${col.name}' has not null contraint,`
-								+ `\nand you didn't specify a table for foreign key on column '${col.name}' in '${table.name}' table.`
-								+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-1`,
-						);
-					}
-
-					const predicate = (
-						cyclicRelation !== undefined
-						|| (
-							foreignKeyColumns[col.name]?.table === undefined
-							|| !tableNamesSet.has(foreignKeyColumns[col.name]!.table)
-						)
-					)
-						&& col.notNull === false;
-
-					if (predicate === true) {
-						if (
-							(foreignKeyColumns[col.name]?.table === undefined
-								|| !tableNamesSet.has(foreignKeyColumns[col.name]!.table)) && col.notNull === false
-						) {
-							console.warn(
-								`Column '${col.name}' in '${table.name}' table will be filled with Null values`
-									+ `\nbecause you specified neither a table for foreign key on column '${col.name}'`
-									+ `\nnor a function for '${col.name}' column in refinements.`
-									+ `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-2`,
-							);
-						}
-						columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: null });
-						columnPossibleGenerator.wasDefinedBefore = true;
-					} else {
-						columnPossibleGenerator.generator = new generatorsMap.HollowGenerator[0]();
-					}
-				} // TODO: rewrite pickGeneratorFor... using new col properties: isUnique and notNull
-				else if (connectionType === 'postgresql') {
-					columnPossibleGenerator.generator = this.selectGeneratorForPostgresColumn(
-						table,
-						col,
-					);
-				} else if (connectionType === 'mysql') {
-					columnPossibleGenerator.generator = this.selectGeneratorForMysqlColumn(
-						table,
-						col,
-					);
-				} else if (connectionType === 'sqlite') {
-					columnPossibleGenerator.generator = this.selectGeneratorForSqlite(
-						table,
-						col,
-					);
-				}
-
-				if (columnPossibleGenerator.generator === undefined) {
-					throw new Error(
-						`column with type ${col.columnType} is not supported for now.`,
-					);
-				}
-
-				const arrayGen = columnPossibleGenerator.generator.replaceIfArray();
-				if (arrayGen !== undefined) {
-					columnPossibleGenerator.generator = arrayGen;
-				}
-
-				columnPossibleGenerator.generator.isUnique = col.isUnique;
-				const uniqueGen = columnPossibleGenerator.generator.replaceIfUnique();
-				if (uniqueGen !== undefined) {
-					columnPossibleGenerator.generator = uniqueGen;
-				}
-
-				// selecting version of generator
-				columnPossibleGenerator.generator = this.selectVersionOfGenerator(columnPossibleGenerator.generator);
-
-				// TODO: for now only GenerateValuesFromArray support notNull property
-				columnPossibleGenerator.generator.notNull = col.notNull;
-				columnPossibleGenerator.generator.dataType = col.dataType;
-				columnPossibleGenerator.generator.stringLength = col.typeParams.length;
-
-				tablePossibleGenerators.columnsPossibleGenerators.push(
-					columnPossibleGenerator,
-				);
-			}
-		}
-
-		return tablesPossibleGenerators;
-	};
-
-	selectVersionOfGenerator = (generator: AbstractGenerator<any>) => {
-		const entityKind = generator.getEntityKind();
-		if (entityKind === 'GenerateArray') {
-			const oldBaseColumnGen = (generator as GenerateArray).params.baseColumnGen;
-
-			const newBaseColumnGen = this.selectVersionOfGenerator(oldBaseColumnGen);
-			// newGenerator.baseColumnDataType = oldGenerator.baseColumnDataType;
-
-			(generator as GenerateArray).params.baseColumnGen = newBaseColumnGen;
-		}
-
-		const possibleGeneratorConstructors = generatorsMap[entityKind as keyof typeof generatorsMap];
-
-		const possibleGeneratorConstructorsFiltered = possibleGeneratorConstructors?.filter((possGenCon) =>
-			possGenCon.version <= this.version! // sorting in ascending order by version
-		).sort((a, b) => a.version - b.version);
-		const generatorConstructor = possibleGeneratorConstructorsFiltered?.at(-1) as
-			| (new(params: any) => AbstractGenerator<any>)
-			| undefined;
-		if (generatorConstructor === undefined) {
-			throw new Error(`Can't select ${entityKind} generator for ${this.version} version.`);
-		}
-
-		const newGenerator = new generatorConstructor(generator.params);
-		newGenerator.baseColumnDataType = generator.baseColumnDataType;
-		newGenerator.isUnique = generator.isUnique;
-		// TODO: for now only GenerateValuesFromArray support notNull property
-		newGenerator.notNull = generator.notNull;
-		newGenerator.dataType = generator.dataType;
-		newGenerator.stringLength = generator.stringLength;
-
-		return newGenerator;
-	};
-
-	cyclicTablesCompare = (
-		table1: Table,
-		table2: Table,
-		relation: Relation & { isCyclic: boolean },
-		reverseRelation: Relation & { isCyclic: boolean } | undefined,
-	) => {
-		// TODO: revise
-		const hasTable1NotNullColumns = relation.columns.some((colIName) =>
-			table1.columns.find((colJ) => colJ.name === colIName)?.notNull === true
-		);
-
-		if (reverseRelation !== undefined) {
-			const hasTable2NotNullColumns = reverseRelation.columns.some((colIName) =>
-				table2.columns.find((colJ) => colJ.name === colIName)?.notNull === true
-			);
-
-			if (hasTable1NotNullColumns && hasTable2NotNullColumns) {
-				throw new Error(
-					`The '${table1.name}' and '${table2.name}' tables have not null foreign keys. You can't seed cyclic tables with not null foreign key columns.`,
-				);
-			}
-
-			if (hasTable1NotNullColumns) return 1;
-			else if (hasTable2NotNullColumns) return -1;
-			return 0;
-		}
-
-		if (hasTable1NotNullColumns) {
-			return 1;
-		}
-		return 0;
-
-		// if (hasTable1NotNullColumns) return 1;
-		// else if (hasTable2NotNullColumns) return -1;
-	};
-
-	getOrderedTablesList = (
-		tablesInOutRelations: ReturnType<typeof this.getInfoFromRelations>['tablesInOutRelations'],
-	): string[] => {
-		const leafTablesNames = Object.entries(tablesInOutRelations)
-			.filter(
-				(tableRel) =>
-					tableRel[1].out === 0
-					|| (tableRel[1].out !== 0
-						&& tableRel[1].selfRelCount === tableRel[1].out),
-			)
-			.map((tableRel) => tableRel[0]);
-
-		const orderedTablesNames: string[] = [];
-		let parent: string, children: string[];
-		for (let i = 0; leafTablesNames.length !== 0; i++) {
-			parent = leafTablesNames.shift() as string;
-
-			if (orderedTablesNames.includes(parent)) {
-				continue;
-			}
-
-			if (tablesInOutRelations[parent] === undefined) {
-				orderedTablesNames.push(parent);
-				continue;
-			}
-
-			for (const orderedTableName of orderedTablesNames) {
-				tablesInOutRelations[parent]!.requiredTableNames.delete(orderedTableName);
-			}
-
-			if (
-				tablesInOutRelations[parent]!.requiredTableNames.size === 0
-				|| equalSets(
-					tablesInOutRelations[parent]!.requiredTableNames,
-					tablesInOutRelations[parent]!.dependantTableNames,
-				)
-			) {
-				orderedTablesNames.push(parent);
-			} else {
-				leafTablesNames.push(...tablesInOutRelations[parent]!.requiredTableNames, parent);
-				continue;
-			}
-
-			children = [...tablesInOutRelations[parent]!.dependantTableNames];
-			leafTablesNames.push(...children);
-		}
-		return orderedTablesNames;
-	};
-
-	getInfoFromRelations = (relations: (Relation & { isCyclic: boolean })[]) => {
-		const tablesInOutRelations: {
-			[tableName: string]: {
-				out: number;
-				in: number;
-				selfRelation: boolean;
-				selfRelCount: number;
-				requiredTableNames: Set<string>;
-				dependantTableNames: Set<string>;
-			};
-		} = {};
-
-		// const cyclicRelations: { [cyclicTableName: string]: Relation & { isCyclic: boolean } } = {};
-
-		for (const rel of relations) {
-			// if (rel.isCyclic) {
-			// 	cyclicRelations[rel.table] = rel;
-			// }
-
-			if (tablesInOutRelations[rel.table] === undefined) {
-				tablesInOutRelations[rel.table] = {
-					out: 0,
-					in: 0,
-					selfRelation: false,
-					selfRelCount: 0,
-					requiredTableNames: new Set(),
-					dependantTableNames: new Set(),
-				};
-			}
-
-			if (
-				rel.refTable !== undefined
-				&& tablesInOutRelations[rel.refTable] === undefined
-			) {
-				tablesInOutRelations[rel.refTable] = {
-					out: 0,
-					in: 0,
-					selfRelation: false,
-					selfRelCount: 0,
-					requiredTableNames: new Set(),
-					dependantTableNames: new Set(),
-				};
-			}
-
-			if (rel.refTable !== undefined) {
-				tablesInOutRelations[rel.table]!.out += 1;
-				tablesInOutRelations[rel.refTable]!.in += 1;
-			}
-
-			if (rel.refTable === rel.table) {
-				tablesInOutRelations[rel.table]!.selfRelation = true;
-				tablesInOutRelations[rel.table]!.selfRelCount = rel.columns.length;
-			} else if (rel.refTable !== undefined) {
-				tablesInOutRelations[rel.table]!.requiredTableNames.add(rel.refTable);
-				tablesInOutRelations[rel.refTable]!.dependantTableNames.add(rel.table);
-			}
-		}
-
-		return { tablesInOutRelations };
-	};
-
-	getWeightedWithCount = (
-		weightedCount: { weight: number; count: number | number[] }[],
-		count: number,
-		seed: number,
-	) => {
-		let gen = new generatorsMap.GenerateWeightedCount[0]();
-		gen = this.selectVersionOfGenerator(gen) as GenerateWeightedCount;
-		// const gen = new GenerateWeightedCount({});
-		gen.init({ count: weightedCount, seed });
-		let weightedWithCount = 0;
-		for (let i = 0; i < count; i++) {
-			weightedWithCount += gen.generate();
-		}
-
-		return weightedWithCount;
-	};
-
-	// TODO: revise serial part generators
-	selectGeneratorForPostgresColumn = (
-		table: Table,
-		col: Column,
-	) => {
-		const pickGenerator = (table: Table, col: Column) => {
-			// ARRAY
-			if (col.columnType.match(/\[\w*]/g) !== null && col.baseColumn !== undefined) {
-				const baseColumnGen = this.selectGeneratorForPostgresColumn(
-					table,
-					col.baseColumn!,
-				) as AbstractGenerator;
-				if (baseColumnGen === undefined) {
-					throw new Error(`column with type ${col.baseColumn!.columnType} is not supported for now.`);
-				}
-
-				// const getBaseColumnDataType = (baseColumn: Column) => {
-				// 	if (baseColumn.baseColumn !== undefined) {
-				// 		return getBaseColumnDataType(baseColumn.baseColumn);
-				// 	}
-
-				// 	return baseColumn.dataType;
-				// };
-				// const baseColumnDataType = getBaseColumnDataType(col.baseColumn);
-
-				const generator = new generatorsMap.GenerateArray[0]({ baseColumnGen, size: col.size });
-				// generator.baseColumnDataType = baseColumnDataType;
-
-				return generator;
-			}
-
-			// ARRAY for studio
-			if (col.columnType.match(/\[\w*]/g) !== null) {
-				// remove dimensions from type
-				const baseColumnType = col.columnType.replace(/\[\w*]/g, '');
-				const baseColumn: Column = {
-					...col,
-				};
-				baseColumn.columnType = baseColumnType;
-
-				const baseColumnGen = this.selectGeneratorForPostgresColumn(table, baseColumn) as AbstractGenerator;
-				if (baseColumnGen === undefined) {
-					throw new Error(`column with type ${col.baseColumn!.columnType} is not supported for now.`);
-				}
-
-				let generator = new generatorsMap.GenerateArray[0]({ baseColumnGen });
-
-				for (let i = 0; i < col.typeParams.dimensions! - 1; i++) {
-					generator = new generatorsMap.GenerateArray[0]({ baseColumnGen: generator });
-				}
-
-				return generator;
-			}
-
-			// INT ------------------------------------------------------------------------------------------------------------
-			if (
-				(col.columnType.includes('serial')
-					|| col.columnType === 'integer'
-					|| col.columnType === 'smallint'
-					|| col.columnType.includes('bigint'))
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-
-				return generator;
-			}
-
-			let minValue: number | bigint | undefined;
-			let maxValue: number | bigint | undefined;
-			if (col.columnType.includes('serial')) {
-				minValue = 1;
-				if (col.columnType === 'smallserial') {
-					// 2^16 / 2 - 1, 2 bytes
-					maxValue = 32767;
-				} else if (col.columnType === 'serial') {
-					// 2^32 / 2 - 1, 4 bytes
-					maxValue = 2147483647;
-				} else if (col.columnType === 'bigserial') {
-					// 2^64 / 2 - 1, 8 bytes
-					minValue = BigInt(1);
-					maxValue = BigInt('9223372036854775807');
-				}
-			} else if (col.columnType.includes('int')) {
-				if (col.columnType === 'smallint') {
-					// 2^16 / 2 - 1, 2 bytes
-					minValue = -32768;
-					maxValue = 32767;
-				} else if (col.columnType === 'integer') {
-					// 2^32 / 2 - 1, 4 bytes
-					minValue = -2147483648;
-					maxValue = 2147483647;
-				} else if (col.columnType.includes('bigint')) {
-					if (col.dataType === 'bigint') {
-						// 2^64 / 2 - 1, 8 bytes
-						minValue = BigInt('-9223372036854775808');
-						maxValue = BigInt('9223372036854775807');
-					} else {
-						// if (col.dataType === 'number')
-						// if you’re expecting values above 2^31 but below 2^53
-						minValue = -9007199254740991;
-						maxValue = 9007199254740991;
-					}
-				}
-			}
-
-			if (
-				col.columnType.includes('int')
-				&& !col.columnType.includes('interval')
-				&& !col.columnType.includes('point')
-			) {
-				const generator = new generatorsMap.GenerateInt[0]({
-					minValue,
-					maxValue,
-				});
-
-				return generator;
-			}
-
-			if (col.columnType.includes('serial')) {
-				const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-
-				generator.maxValue = maxValue;
-
-				return generator;
-			}
-
-			// NUMBER(real, double, decimal, numeric)
-			if (
-				col.columnType.startsWith('real')
-				|| col.columnType.startsWith('double precision')
-				|| col.columnType.startsWith('decimal')
-				|| col.columnType.startsWith('numeric')
-			) {
-				if (col.typeParams.precision !== undefined) {
-					const precision = col.typeParams.precision;
-					const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-
-					const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-					const generator = new generatorsMap.GenerateNumber[0]({
-						minValue: -maxAbsoluteValue,
-						maxValue: maxAbsoluteValue,
-						precision: Math.pow(10, scale),
-					});
-					return generator;
-				}
-				const generator = new generatorsMap.GenerateNumber[0]();
-
-				return generator;
-			}
-
-			// STRING
-			if (
-				(col.columnType === 'text'
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('char'))
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateUniqueString[0]();
-
-				return generator;
-			}
-
-			if (
-				(col.columnType === 'text'
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('char'))
-				&& col.name.toLowerCase().includes('name')
-			) {
-				const generator = new generatorsMap.GenerateFirstName[0]();
-
-				return generator;
-			}
-
-			if (
-				(col.columnType === 'text'
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('char'))
-				&& col.name.toLowerCase().includes('email')
-			) {
-				const generator = new generatorsMap.GenerateEmail[0]();
-
-				return generator;
-			}
-
-			if (
-				col.columnType === 'text'
-				|| col.columnType.startsWith('varchar')
-				|| col.columnType.startsWith('char')
-			) {
-				const generator = new generatorsMap.GenerateString[0]();
-
-				return generator;
-			}
-
-			// UUID
-			if (col.columnType === 'uuid') {
-				const generator = new generatorsMap.GenerateUUID[0]();
-
-				return generator;
-			}
-
-			// BOOLEAN
-			if (col.columnType === 'boolean') {
-				const generator = new generatorsMap.GenerateBoolean[0]();
-
-				return generator;
-			}
-
-			// DATE, TIME, TIMESTAMP
-			if (col.columnType.includes('date')) {
-				const generator = new generatorsMap.GenerateDate[0]();
-
-				return generator;
-			}
-
-			if (col.columnType === 'time') {
-				const generator = new generatorsMap.GenerateTime[0]();
-
-				return generator;
-			}
-
-			if (col.columnType.includes('timestamp')) {
-				const generator = new generatorsMap.GenerateTimestamp[0]();
-
-				return generator;
-			}
-
-			// JSON, JSONB
-			if (col.columnType === 'json' || col.columnType === 'jsonb') {
-				const generator = new generatorsMap.GenerateJson[0]();
-
-				return generator;
-			}
-
-			// if (col.columnType === "jsonb") {
-			//   const generator = new GenerateJsonb({});
-			//   return generator;
-			// }
-
-			// ENUM
-			if (col.enumValues !== undefined) {
-				const generator = new generatorsMap.GenerateEnum[0]({
-					enumValues: col.enumValues,
-				});
-
-				return generator;
-			}
-
-			// INTERVAL
-			if (col.columnType.startsWith('interval')) {
-				if (col.columnType === 'interval') {
-					const generator = new generatorsMap.GenerateInterval[0]();
-
-					return generator;
-				}
-
-				const fields = col.columnType.replace('interval ', '') as GenerateInterval['params']['fields'];
-				const generator = new generatorsMap.GenerateInterval[0]({ fields });
-
-				return generator;
-			}
-
-			// POINT, LINE
-			if (col.columnType.includes('point')) {
-				const generator = new generatorsMap.GeneratePoint[0]();
-
-				return generator;
-			}
-
-			if (col.columnType.includes('line')) {
-				const generator = new generatorsMap.GenerateLine[0]();
-
-				return generator;
-			}
-
-			if (col.hasDefault && col.default !== undefined) {
-				const generator = new generatorsMap.GenerateDefault[0]({
-					defaultValue: col.default,
-				});
-				return generator;
-			}
-
-			return;
-		};
-
-		const generator = pickGenerator(table, col);
-		if (generator !== undefined) {
-			generator.isUnique = col.isUnique;
-			generator.dataType = col.dataType;
-			generator.stringLength = col.typeParams.length;
-		}
-
-		return generator;
-	};
-
-	selectGeneratorForMysqlColumn = (
-		table: Table,
-		col: Column,
-	) => {
-		const pickGenerator = (table: Table, col: Column) => {
-			// INT ------------------------------------------------------------------------------------------------------------
-			if (
-				(col.columnType.includes('serial') || col.columnType.includes('int'))
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-				return generator;
-			}
-
-			let minValue: number | bigint | undefined;
-			let maxValue: number | bigint | undefined;
-			if (col.columnType === 'serial') {
-				// 2^64 % 2 - 1, 8 bytes
-				minValue = BigInt(0);
-				maxValue = BigInt('9223372036854775807');
-			} else if (col.columnType.includes('int')) {
-				if (col.columnType === 'tinyint') {
-					// 2^8 / 2 - 1, 1 bytes
-					minValue = -128;
-					maxValue = 127;
-				} else if (col.columnType === 'smallint') {
-					// 2^16 / 2 - 1, 2 bytes
-					minValue = -32768;
-					maxValue = 32767;
-				} else if (col.columnType === 'mediumint') {
-					// 2^16 / 2 - 1, 2 bytes
-					minValue = -8388608;
-					maxValue = 8388607;
-				} else if (col.columnType === 'int') {
-					// 2^32 / 2 - 1, 4 bytes
-					minValue = -2147483648;
-					maxValue = 2147483647;
-				} else if (col.columnType === 'bigint') {
-					// 2^64 / 2 - 1, 8 bytes
-					minValue = BigInt('-9223372036854775808');
-					maxValue = BigInt('9223372036854775807');
-				}
-			}
-
-			if (col.columnType.includes('int')) {
-				const generator = new generatorsMap.GenerateInt[0]({
-					minValue,
-					maxValue,
-				});
-				return generator;
-			}
-
-			if (col.columnType.includes('serial')) {
-				const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-				generator.maxValue = maxValue;
-				return generator;
-			}
-
-			// NUMBER(real, double, decimal, float)
-			if (
-				col.columnType.startsWith('real')
-				|| col.columnType.startsWith('double')
-				|| col.columnType.startsWith('decimal')
-				|| col.columnType.startsWith('float')
-				|| col.columnType.startsWith('numeric')
-			) {
-				if (col.typeParams.precision !== undefined) {
-					const precision = col.typeParams.precision;
-					const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-
-					const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-					const generator = new generatorsMap.GenerateNumber[0]({
-						minValue: -maxAbsoluteValue,
-						maxValue: maxAbsoluteValue,
-						precision: Math.pow(10, scale),
-					});
-					return generator;
-				}
-
-				const generator = new generatorsMap.GenerateNumber[0]();
-				return generator;
-			}
-
-			// STRING
-			if (
-				(col.columnType === 'text'
-					|| col.columnType === 'blob'
-					|| col.columnType.startsWith('char')
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('binary')
-					|| col.columnType.startsWith('varbinary'))
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateUniqueString[0]();
-				return generator;
-			}
-
-			if (
-				(col.columnType === 'text'
-					|| col.columnType === 'blob'
-					|| col.columnType.startsWith('char')
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('binary')
-					|| col.columnType.startsWith('varbinary'))
-				&& col.name.toLowerCase().includes('name')
-			) {
-				const generator = new generatorsMap.GenerateFirstName[0]();
-				return generator;
-			}
-
-			if (
-				(col.columnType === 'text'
-					|| col.columnType === 'blob'
-					|| col.columnType.startsWith('char')
-					|| col.columnType.startsWith('varchar')
-					|| col.columnType.startsWith('binary')
-					|| col.columnType.startsWith('varbinary'))
-				&& col.name.toLowerCase().includes('email')
-			) {
-				const generator = new generatorsMap.GenerateEmail[0]();
-				return generator;
-			}
-
-			if (
-				col.columnType === 'text'
-				|| col.columnType === 'blob'
-				|| col.columnType.startsWith('char')
-				|| col.columnType.startsWith('varchar')
-				|| col.columnType.startsWith('binary')
-				|| col.columnType.startsWith('varbinary')
-			) {
-				const generator = new generatorsMap.GenerateString[0]();
-				return generator;
-			}
-
-			// BOOLEAN
-			if (col.columnType === 'boolean') {
-				const generator = new generatorsMap.GenerateBoolean[0]();
-				return generator;
-			}
-
-			// DATE, TIME, TIMESTAMP, DATETIME, YEAR
-			if (col.columnType.includes('datetime')) {
-				const generator = new generatorsMap.GenerateDatetime[0]();
-				return generator;
-			}
-
-			if (col.columnType.includes('date')) {
-				const generator = new generatorsMap.GenerateDate[0]();
-				return generator;
-			}
-
-			if (col.columnType === 'time') {
-				const generator = new generatorsMap.GenerateTime[0]();
-				return generator;
-			}
-
-			if (col.columnType.includes('timestamp')) {
-				const generator = new generatorsMap.GenerateTimestamp[0]();
-				return generator;
-			}
-
-			if (col.columnType === 'year') {
-				const generator = new generatorsMap.GenerateYear[0]();
-				return generator;
-			}
-
-			// JSON
-			if (col.columnType === 'json') {
-				const generator = new generatorsMap.GenerateJson[0]();
-				return generator;
-			}
-
-			// ENUM
-			if (col.enumValues !== undefined) {
-				const generator = new generatorsMap.GenerateEnum[0]({
-					enumValues: col.enumValues,
-				});
-				return generator;
-			}
-
-			if (col.hasDefault && col.default !== undefined) {
-				const generator = new generatorsMap.GenerateDefault[0]({
-					defaultValue: col.default,
-				});
-				return generator;
-			}
-
-			return;
-		};
-
-		const generator = pickGenerator(table, col);
-
-		return generator;
-	};
-
-	selectGeneratorForSqlite = (
-		table: Table,
-		col: Column,
-	) => {
-		const pickGenerator = (table: Table, col: Column) => {
-			// int section ---------------------------------------------------------------------------------------
-			if (
-				(col.columnType === 'integer' || col.columnType === 'numeric')
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
-				return generator;
-			}
-
-			if (col.columnType === 'integer' && col.dataType === 'boolean') {
-				const generator = new generatorsMap.GenerateBoolean[0]();
-				return generator;
-			}
-
-			if ((col.columnType === 'integer' && col.dataType === 'date')) {
-				const generator = new generatorsMap.GenerateTimestamp[0]();
-				return generator;
-			}
-
-			if (
-				col.columnType === 'integer'
-				|| (col.dataType === 'bigint' && col.columnType === 'blob')
-			) {
-				const generator = new generatorsMap.GenerateInt[0]();
-				return generator;
-			}
-
-			// number section ------------------------------------------------------------------------------------
-			if (col.columnType.startsWith('real') || col.columnType.startsWith('numeric')) {
-				if (col.typeParams.precision !== undefined) {
-					const precision = col.typeParams.precision;
-					const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
-
-					const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
-					const generator = new generatorsMap.GenerateNumber[0]({
-						minValue: -maxAbsoluteValue,
-						maxValue: maxAbsoluteValue,
-						precision: Math.pow(10, scale),
-					});
-					return generator;
-				}
-
-				const generator = new generatorsMap.GenerateNumber[0]();
-				return generator;
-			}
-
-			// string section ------------------------------------------------------------------------------------
-			if (
-				(col.columnType.startsWith('text')
-					|| col.columnType.startsWith('numeric')
-					|| col.columnType.startsWith('blob'))
-				&& table.primaryKeys.includes(col.name)
-			) {
-				const generator = new generatorsMap.GenerateUniqueString[0]();
-				return generator;
-			}
-
-			if (
-				(col.columnType.startsWith('text')
-					|| col.columnType.startsWith('numeric')
-					|| col.columnType.startsWith('blob'))
-				&& col.name.toLowerCase().includes('name')
-			) {
-				const generator = new generatorsMap.GenerateFirstName[0]();
-				return generator;
-			}
-
-			if (
-				(col.columnType.startsWith('text')
-					|| col.columnType.startsWith('numeric')
-					|| col.columnType.startsWith('blob'))
-				&& col.name.toLowerCase().includes('email')
-			) {
-				const generator = new generatorsMap.GenerateEmail[0]();
-				return generator;
-			}
-
-			if (
-				col.columnType.startsWith('text')
-				|| col.columnType.startsWith('numeric')
-				|| col.columnType.startsWith('blob')
-				|| col.columnType.startsWith('blobbuffer')
-			) {
-				const generator = new generatorsMap.GenerateString[0]();
-				return generator;
-			}
-
-			if (
-				(col.columnType.startsWith('text') && col.dataType === 'json')
-				|| (col.columnType.startsWith('blob') && col.dataType === 'json')
-			) {
-				const generator = new generatorsMap.GenerateJson[0]();
-				return generator;
-			}
-
-			if (col.hasDefault && col.default !== undefined) {
-				const generator = new generatorsMap.GenerateDefault[0]({
-					defaultValue: col.default,
-				});
-				return generator;
-			}
-
-			return;
-		};
-
-		const generator = pickGenerator(table, col);
-
-		return generator;
-	};
-
-	filterCyclicTables = (tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>) => {
-		const filteredTablesGenerators = tablesGenerators.filter((tableGen) =>
-			tableGen.columnsPossibleGenerators.some((columnGen) =>
-				columnGen.isCyclic === true && columnGen.wasDefinedBefore === true
-			)
-		);
-
-		const tablesUniqueNotNullColumn: { [tableName: string]: { uniqueNotNullColName: string } } = {};
-
-		for (const [idx, tableGen] of filteredTablesGenerators.entries()) {
-			const uniqueNotNullColName = filteredTablesGenerators[idx]!.columnsPossibleGenerators.find((colGen) =>
-				colGen.primary === true
-				|| (colGen.isUnique === true
-					&& colGen.notNull === true)
-			)?.columnName;
-			if (uniqueNotNullColName === undefined) {
-				throw new Error(
-					`Table '${tableGen.tableName}' does not have primary or (unique and notNull) column. Can't seed table with cyclic relation.`,
-				);
-			}
-			tablesUniqueNotNullColumn[tableGen.tableName] = { uniqueNotNullColName };
-
-			filteredTablesGenerators[idx]!.columnsPossibleGenerators = tableGen.columnsPossibleGenerators.filter((colGen) =>
-				(colGen.isCyclic === true && colGen.wasDefinedBefore === true) || colGen.columnName === uniqueNotNullColName
-			).map((colGen) => {
-				const newColGen = { ...colGen };
-				newColGen.wasDefinedBefore = false;
-				return newColGen;
-			});
-		}
-
-		return { filteredTablesGenerators, tablesUniqueNotNullColumn };
-	};
-
-	generateTablesValues = async (
-		relations: (Relation & { isCyclic: boolean })[],
-		tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>,
-		db?:
-			| PgDatabase<any>
-			| MySqlDatabase<any, any>
-			| BaseSQLiteDatabase<any, any>,
-		schema?: { [key: string]: PgTable | MySqlTable | SQLiteTable },
-		options?: {
-			count?: number;
-			seed?: number;
-			preserveData?: boolean;
-			preserveCyclicTablesData?: boolean;
-			insertDataInDb?: boolean;
-			updateDataInDb?: boolean;
-			tablesValues?: {
-				tableName: string;
-				rows: {
-					[columnName: string]: string | number | boolean | undefined;
-				}[];
-			}[];
-			tablesUniqueNotNullColumn?: { [tableName: string]: { uniqueNotNullColName: string } };
-		},
-	) => {
-		const customSeed = options?.seed === undefined ? 0 : options.seed;
-		let tableCount: number | undefined;
-		let columnsGenerators: Prettify<GeneratePossibleGeneratorsColumnType>[];
-		let tableGenerators: Prettify<TableGeneratorsType>;
-
-		let tableValues: {
-			[columnName: string]: string | number | boolean | undefined;
-		}[];
-
-		let tablesValues: {
-			tableName: string;
-			rows: typeof tableValues;
-		}[] = options?.tablesValues === undefined ? [] : options.tablesValues;
-
-		let pRNGSeed: number;
-		let filteredRelations: typeof relations;
-
-		let preserveData: boolean, insertDataInDb: boolean = true, updateDataInDb: boolean = false;
-		if (options?.preserveData !== undefined) preserveData = options.preserveData;
-		if (options?.insertDataInDb !== undefined) insertDataInDb = options.insertDataInDb;
-		if (options?.updateDataInDb !== undefined) updateDataInDb = options.updateDataInDb;
-		if (updateDataInDb === true) insertDataInDb = false;
-
-		// TODO: now I'm generating tablesInOutRelations twice, first time in generatePossibleGenerators and second time here. maybe should generate it once instead.
-		const { tablesInOutRelations } = this.getInfoFromRelations(relations);
-		for (const table of tablesGenerators) {
-			tableCount = table.count === undefined ? options?.count || this.defaultCountForTable : table.count;
-
-			tableGenerators = {};
-			columnsGenerators = table.columnsPossibleGenerators;
-
-			filteredRelations = relations.filter(
-				(rel) => rel.table === table.tableName,
-			);
-
-			// adding pRNG seed to column
-			for (const col of columnsGenerators) {
-				const columnRelations = filteredRelations.filter((rel) => rel.columns.includes(col.columnName));
-				pRNGSeed = (columnRelations.length !== 0
-						&& columnRelations[0]!.columns.length >= 2)
-					? (customSeed + generateHashFromString(
-						`${columnRelations[0]!.table}.${columnRelations[0]!.columns.join('_')}`,
-					))
-					: (customSeed + generateHashFromString(`${table.tableName}.${col.columnName}`));
-
-				tableGenerators[col.columnName] = {
-					pRNGSeed,
-					...col,
-				};
-			}
-
-			// get values to generate columns with foreign key
-
-			// if table posts contains foreign key to table users, then rel.table === 'posts' and rel.refTable === 'users', because table posts has reference to table users.
-			if (filteredRelations.length !== 0) {
-				for (const rel of filteredRelations) {
-					if (
-						table.withFromTable[rel.refTable] !== undefined
-						&& table.withCount !== undefined
-					) {
-						tableCount = table.withCount;
-					}
-
-					for (let colIdx = 0; colIdx < rel.columns.length; colIdx++) {
-						let refColumnValues: (string | number | boolean)[];
-						let hasSelfRelation: boolean = false;
-						let repeatedValuesCount:
-								| number
-								| { weight: number; count: number | number[] }[]
-								| undefined,
-							weightedCountSeed: number | undefined;
-						let genObj: AbstractGenerator<any> | undefined;
-
-						if (
-							rel.table === rel.refTable
-							&& tableGenerators[rel.columns[colIdx]!]?.wasRefined === false
-						) {
-							const refColName = rel.refColumns[colIdx] as string;
-							pRNGSeed = generateHashFromString(
-								`${table.tableName}.${refColName}`,
-							);
-
-							const refColumnGenerator: typeof tableGenerators = {};
-							refColumnGenerator[refColName] = {
-								...tableGenerators[refColName]!,
-								pRNGSeed,
-							};
-
-							refColumnValues = (await this.generateColumnsValuesByGenerators({
-								tableGenerators: refColumnGenerator,
-								count: tableCount,
-								preserveData: true,
-								insertDataInDb: false,
-							}))!.map((rows) => rows[refColName]) as (string | number | boolean)[];
-
-							hasSelfRelation = true;
-							genObj = new generatorsMap.GenerateSelfRelationsValuesFromArray[0]({
-								values: refColumnValues,
-							});
-							genObj = this.selectVersionOfGenerator(genObj);
-							// genObj = new GenerateSelfRelationsValuesFromArray({
-							// 	values: refColumnValues,
-							// });
-						} else if (
-							tableGenerators[rel.columns[colIdx]!]?.wasDefinedBefore === false
-							&& tableGenerators[rel.columns[colIdx]!]?.wasRefined === false
-						) {
-							refColumnValues = tablesValues
-								.find((val) => val.tableName === rel.refTable)!
-								.rows!.map((row) => row[rel.refColumns[colIdx]!]!);
-
-							if (
-								table.withFromTable[rel.refTable] !== undefined
-								&& table.withFromTable[rel.refTable]!.repeatedValuesCount
-									!== undefined
-							) {
-								repeatedValuesCount = table.withFromTable[rel.refTable]!.repeatedValuesCount;
-								weightedCountSeed = table.withFromTable[rel.refTable]!.weightedCountSeed;
-							}
-
-							// TODO: revise maybe need to select version of generator here too
-							genObj = new generatorsMap.GenerateValuesFromArray[0]({ values: refColumnValues });
-							genObj.notNull = tableGenerators[rel.columns[colIdx]!]!.notNull;
-							genObj.weightedCountSeed = weightedCountSeed;
-							genObj.maxRepeatedValuesCount = repeatedValuesCount;
-						}
-
-						if (genObj !== undefined) {
-							tableGenerators[rel.columns[colIdx]!]!.generator = genObj;
-						}
-						tableGenerators[rel.columns[colIdx]!] = {
-							...tableGenerators[rel.columns[colIdx]!]!,
-							hasSelfRelation,
-							hasRelation: true,
-						};
-					}
-				}
-			}
-
-			preserveData = (
-					options?.preserveData === undefined
-					&& tablesInOutRelations[table.tableName]?.in === 0
-				)
-				? false
-				: true;
-
-			preserveData = preserveData || (options?.preserveCyclicTablesData === true
-				&& table.columnsPossibleGenerators.some((colGen) => colGen.isCyclic === true));
-
-			tableValues = await this.generateColumnsValuesByGenerators({
-				tableGenerators,
-				db,
-				schema,
-				tableName: table.tableName,
-				count: tableCount,
-				preserveData,
-				insertDataInDb,
-				updateDataInDb,
-				uniqueNotNullColName: options?.tablesUniqueNotNullColumn === undefined
-					? undefined
-					: options?.tablesUniqueNotNullColumn[table.tableName]?.uniqueNotNullColName,
-			});
-
-			if (preserveData === true) {
-				tablesValues.push({
-					tableName: table.tableName,
-					rows: tableValues,
-				});
-			}
-
-			// removing "link" from table that was required to generate current table
-			if (tablesInOutRelations[table.tableName] !== undefined) {
-				for (const tableName of tablesInOutRelations[table.tableName]!.requiredTableNames) {
-					tablesInOutRelations[tableName]!.in -= 1;
-				}
-			}
-
-			if (preserveData === false) {
-				tablesValues = tablesValues.filter(
-					(table) =>
-						tablesInOutRelations[table.tableName] !== undefined && tablesInOutRelations[table.tableName]!.in > 0,
-				);
-			}
-		}
-
-		return tablesValues;
-	};
-
-	generateColumnsValuesByGenerators = async ({
-		tableGenerators,
-		db,
-		schema,
-		tableName,
-		count,
-		preserveData = true,
-		insertDataInDb = true,
-		updateDataInDb = false,
-		uniqueNotNullColName,
-		batchSize = 10000,
-	}: {
-		tableGenerators: Prettify<TableGeneratorsType>;
-		db?:
-			| PgDatabase<any>
-			| MySqlDatabase<any, any>
-			| BaseSQLiteDatabase<any, any>;
-		schema?: { [key: string]: PgTable | MySqlTable | SQLiteTable };
-		tableName?: string;
-		count?: number;
-		preserveData?: boolean;
-		insertDataInDb?: boolean;
-		updateDataInDb?: boolean;
-		uniqueNotNullColName?: string;
-		batchSize?: number;
-	}) => {
-		if (count === undefined) {
-			count = this.defaultCountForTable;
-		}
-
-		if (updateDataInDb === true) {
-			batchSize = 1;
-		}
-
-		let columnGenerator: (typeof tableGenerators)[string];
-		const columnsGenerators: {
-			[columnName: string]: AbstractGenerator<any>;
-		} = {};
-		let generatedValues: { [columnName: string]: number | string | boolean | undefined }[] = [];
-
-		let columnsNumber = 0;
-		let override = false;
-		for (const columnName of Object.keys(tableGenerators)) {
-			columnsNumber += 1;
-			columnGenerator = tableGenerators[columnName]!;
-			override = tableGenerators[columnName]?.generatedIdentityType === 'always' ? true : override;
-
-			columnsGenerators[columnName] = columnGenerator.generator!;
-			columnsGenerators[columnName]!.init({
-				count,
-				seed: columnGenerator.pRNGSeed,
-			});
-
-			// const arrayGen = columnsGenerators[columnName]!.replaceIfArray({ count, seed: columnGenerator.pRNGSeed });
-			// if (arrayGen !== undefined) {
-			// 	columnsGenerators[columnName] = arrayGen;
-			// }
-
-			// const uniqueGen = columnsGenerators[columnName]!.replaceIfUnique({ count, seed: columnGenerator.pRNGSeed });
-			// if (uniqueGen !== undefined) {
-			// 	columnsGenerators[columnName] = uniqueGen;
-			// }
-		}
-		let maxParametersNumber: number;
-		if (is(db, PgDatabase<any>)) {
-			// @ts-ignore
-			maxParametersNumber = db.constructor[entityKind] === 'PgliteDatabase'
-				? this.postgresPgLiteMaxParametersNumber
-				: this.postgresMaxParametersNumber;
-		} else if (is(db, MySqlDatabase<any, any>)) {
-			maxParametersNumber = this.mysqlMaxParametersNumber;
-		} else {
-			// is(db, BaseSQLiteDatabase<any, any>)
-			maxParametersNumber = this.sqliteMaxParametersNumber;
-		}
-		const maxBatchSize = Math.floor(maxParametersNumber / columnsNumber);
-		batchSize = batchSize > maxBatchSize ? maxBatchSize : batchSize;
-
-		if (
-			(insertDataInDb === true || updateDataInDb === true)
-			&& (db === undefined || schema === undefined || tableName === undefined)
-		) {
-			throw new Error('db or schema or tableName is undefined.');
-		}
-
-		let row: { [columnName: string]: string | number | boolean },
-			generatedValue,
-			i: number;
-
-		for (i = 0; i < count; i++) {
-			row = {};
-			generatedValues.push(row);
-
-			for (const columnName of Object.keys(columnsGenerators)) {
-				// generatedValue = columnsGenerators[columnName].next().value as
-				//   | string
-				//   | number
-				//   | boolean;
-				generatedValue = columnsGenerators[columnName]!.generate({ i }) as
-					| string
-					| number
-					| boolean;
-				row[columnName as keyof typeof row] = generatedValue;
-			}
-
-			if (
-				(insertDataInDb === true || updateDataInDb === true)
-				&& ((i + 1) % batchSize === 0 || i === count - 1)
-			) {
-				if (preserveData === false) {
-					if (insertDataInDb === true) {
-						await this.insertInDb({
-							generatedValues,
-							db: db as
-								| PgDatabase<any, any>
-								| MySqlDatabase<any, any>
-								| BaseSQLiteDatabase<any, any>,
-							schema: schema as {
-								[key: string]: PgTable | MySqlTable | SQLiteTable;
-							},
-							tableName: tableName as string,
-							override,
-						});
-					} else if (updateDataInDb === true) {
-						await this.updateDb({
-							generatedValues,
-							db: db as
-								| PgDatabase<any, any>
-								| MySqlDatabase<any, any>
-								| BaseSQLiteDatabase<any, any>,
-							schema: schema as {
-								[key: string]: PgTable | MySqlTable | SQLiteTable;
-							},
-							tableName: tableName as string,
-							uniqueNotNullColName: uniqueNotNullColName as string,
-						});
-					}
-
-					generatedValues = [];
-				} else {
-					const batchCount = Math.floor(i / batchSize);
-
-					if (insertDataInDb === true) {
-						await this.insertInDb({
-							generatedValues: generatedValues.slice(
-								batchSize * batchCount,
-								batchSize * (batchCount + 1),
-							),
-							db: db as
-								| PgDatabase<any, any>
-								| MySqlDatabase<any, any>
-								| BaseSQLiteDatabase<any, any>,
-							schema: schema as {
-								[key: string]: PgTable | MySqlTable | SQLiteTable;
-							},
-							tableName: tableName as string,
-							override,
-						});
-					} else if (updateDataInDb === true) {
-						await this.updateDb({
-							generatedValues: generatedValues.slice(
-								batchSize * batchCount,
-								batchSize * (batchCount + 1),
-							),
-							db: db as
-								| PgDatabase<any, any>
-								| MySqlDatabase<any, any>
-								| BaseSQLiteDatabase<any, any>,
-							schema: schema as {
-								[key: string]: PgTable | MySqlTable | SQLiteTable;
-							},
-							tableName: tableName as string,
-							uniqueNotNullColName: uniqueNotNullColName as string,
-						});
-					}
-				}
-			}
-		}
-
-		return preserveData === true ? generatedValues : [];
-	};
-
-	insertInDb = async ({
-		generatedValues,
-		db,
-		schema,
-		tableName,
-		override,
-	}: {
-		generatedValues: {
-			[columnName: string]: number | string | boolean | undefined;
-		}[];
-		db:
-			| PgDatabase<any, any>
-			| MySqlDatabase<any, any>
-			| BaseSQLiteDatabase<any, any>;
-		schema: {
-			[key: string]: PgTable | MySqlTable | SQLiteTable;
-		};
-		tableName: string;
-		override: boolean;
-	}) => {
-		if (is(db, PgDatabase<any>)) {
-			const query = db.insert((schema as { [key: string]: PgTable })[tableName]!);
-			if (override === true) {
-				return await query.overridingSystemValue().values(generatedValues);
-			}
-			await query.values(generatedValues);
-		} else if (is(db, MySqlDatabase<any, any>)) {
-			await db
-				.insert((schema as { [key: string]: MySqlTable })[tableName]!)
-				.values(generatedValues);
-		} else if (is(db, BaseSQLiteDatabase<any, any>)) {
-			await db
-				.insert((schema as { [key: string]: SQLiteTable })[tableName]!)
-				.values(generatedValues);
-		}
-	};
-
-	updateDb = async ({
-		generatedValues,
-		db,
-		schema,
-		tableName,
-		uniqueNotNullColName,
-	}: {
-		generatedValues: {
-			[columnName: string]: number | string | boolean | undefined;
-		}[];
-		db:
-			| PgDatabase<any, any>
-			| MySqlDatabase<any, any>
-			| BaseSQLiteDatabase<any, any>;
-		schema: {
-			[key: string]: PgTable | MySqlTable | SQLiteTable;
-		};
-		tableName: string;
-		uniqueNotNullColName: string;
-	}) => {
-		if (is(db, PgDatabase<any>)) {
-			const table = (schema as { [key: string]: PgTableWithColumns<any> })[tableName]!;
-			const uniqueNotNullCol = table[uniqueNotNullColName];
-			await db.update(table).set(generatedValues[0]!).where(
-				eq(uniqueNotNullCol, generatedValues[0]![uniqueNotNullColName]),
-			);
-		} else if (is(db, MySqlDatabase<any, any>)) {
-			const table = (schema as { [key: string]: MySqlTableWithColumns<any> })[tableName]!;
-			await db.update(table).set(generatedValues[0]!).where(
-				eq(table[uniqueNotNullColName], generatedValues[0]![uniqueNotNullColName]),
-			);
-		} else if (is(db, BaseSQLiteDatabase<any, any>)) {
-			const table = (schema as { [key: string]: SQLiteTableWithColumns<any> })[tableName]!;
-			await db.update(table).set(generatedValues[0]!).where(
-				eq(table[uniqueNotNullColName], generatedValues[0]![uniqueNotNullColName]),
-			);
-		}
-	};
-}
diff --git a/drizzle-seed/src/services/apiVersion.ts b/drizzle-seed/src/services/apiVersion.ts
deleted file mode 100644
index 6cda0267e6..0000000000
--- a/drizzle-seed/src/services/apiVersion.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const latestVersion = 2;
diff --git a/drizzle-seed/src/services/utils.ts b/drizzle-seed/src/services/utils.ts
deleted file mode 100644
index c972e7bd1e..0000000000
--- a/drizzle-seed/src/services/utils.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-export const fastCartesianProduct = (sets: (number | string | boolean | object)[][], index: number) => {
-	const resultList = [];
-	let currSet: (typeof sets)[number];
-	let element: (typeof sets)[number][number];
-
-	for (let i = sets.length - 1; i >= 0; i--) {
-		currSet = sets[i]!;
-		element = currSet[index % currSet.length]!;
-		resultList.unshift(element);
-		index = Math.floor(index / currSet.length);
-	}
-
-	return resultList;
-};
-
-const sumArray = (weights: number[]) => {
-	const scale = 1e10;
-	const scaledSum = weights.reduce((acc, currVal) => acc + Math.round(currVal * scale), 0);
-	return scaledSum / scale;
-};
-
-/**
- * @param weights positive number in range [0, 1], that represents probabilities to choose index of array. Example: weights = [0.2, 0.8]
- * @param [accuracy=100] approximate number of elements in returning array
- * @returns Example: with weights = [0.2, 0.8] and accuracy = 10 returning array of indices gonna equal this: [0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
- */
-export const getWeightedIndices = (weights: number[], accuracy = 100) => {
-	const weightsSum = sumArray(weights);
-	if (weightsSum !== 1) {
-		throw new Error(
-			`The weights for the Weighted Random feature must add up to exactly 1. Please review your weights to ensure they total 1 before proceeding`,
-		);
-	}
-
-	// const accuracy = 100;
-	const weightedIndices: number[] = [];
-	for (const [index, weight] of weights.entries()) {
-		const ticketsNumb = Math.floor(weight * accuracy);
-		weightedIndices.push(...Array.from<number>({ length: ticketsNumb }).fill(index));
-	}
-
-	return weightedIndices;
-};
-
-export const generateHashFromString = (s: string) => {
-	let hash = 0;
-	// p and m are prime numbers
-	const p = 53;
-	const m = 28871271685163;
-
-	for (let i = 0; i < s.length; i++) {
-		hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
-	}
-
-	return hash;
-};
-
-/**
- * @param param0.template example: "#####" or "#####-####"
- * @param param0.values example: ["3", "2", "h"]
- * @param param0.defaultValue example: "0"
- * @returns
- */
-export const fillTemplate = ({ template, placeholdersCount, values, defaultValue = ' ' }: {
-	template: string;
-	placeholdersCount?: number;
-	values: string[];
-	defaultValue?: string;
-}) => {
-	if (placeholdersCount === undefined) {
-		const iterArray = [...template.matchAll(/#/g)];
-		placeholdersCount = iterArray.length;
-	}
-
-	const diff = placeholdersCount - values.length;
-	if (diff > 0) {
-		values.unshift(...Array.from<string>({ length: diff }).fill(defaultValue));
-	}
-
-	let resultStr = '', valueIdx = 0;
-	for (const si of template) {
-		if (si === '#') {
-			resultStr += values[valueIdx];
-			valueIdx += 1;
-			continue;
-		}
-		resultStr += si;
-	}
-
-	return resultStr;
-};
-
-// is variable is object-like.
-// Example:
-// isObject({f: 4}) === true;
-// isObject([1,2,3]) === false;
-// isObject(new Set()) === false;
-export const isObject = (value: any) => {
-	if (value !== null && value !== undefined && value.constructor === Object) return true;
-	return false;
-};
-
-export const equalSets = (set1: Set<any>, set2: Set<any>) => {
-	return set1.size === set2.size && [...set1].every((si) => set2.has(si));
-};
diff --git a/drizzle-seed/src/services/versioning/v2.ts b/drizzle-seed/src/services/versioning/v2.ts
deleted file mode 100644
index f4dbf32f4b..0000000000
--- a/drizzle-seed/src/services/versioning/v2.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-/* eslint-disable drizzle-internal/require-entity-kind */
-import prand from 'pure-rand';
-import { AbstractGenerator } from '../Generators.ts';
-
-export class GenerateUniqueIntervalV2 extends AbstractGenerator<{
-	fields?:
-		| 'year'
-		| 'month'
-		| 'day'
-		| 'hour'
-		| 'minute'
-		| 'second'
-		| 'year to month'
-		| 'day to hour'
-		| 'day to minute'
-		| 'day to second'
-		| 'hour to minute'
-		| 'hour to second'
-		| 'minute to second';
-	isUnique?: boolean;
-}> {
-	static override readonly 'entityKind': string = 'GenerateUniqueInterval';
-	static override readonly version: number = 2;
-
-	private state: {
-		rng: prand.RandomGenerator;
-		fieldsToGenerate: string[];
-		intervalSet: Set<string>;
-	} | undefined;
-	public override isUnique = true;
-	private config: { [key: string]: { from: number; to: number } } = {
-		year: {
-			from: 0,
-			to: 5,
-		},
-		month: {
-			from: 0,
-			to: 11,
-		},
-		day: {
-			from: 0,
-			to: 29,
-		},
-		hour: {
-			from: 0,
-			to: 23,
-		},
-		minute: {
-			from: 0,
-			to: 59,
-		},
-		second: {
-			from: 0,
-			to: 59,
-		},
-	};
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
-		let fieldsToGenerate: string[] = allFields;
-
-		if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
-			const tokens = this.params.fields.split(' to ');
-			const endIdx = allFields.indexOf(tokens[1]!);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		} else if (this.params.fields !== undefined) {
-			const endIdx = allFields.indexOf(this.params.fields);
-			fieldsToGenerate = allFields.slice(0, endIdx + 1);
-		}
-
-		let maxUniqueIntervalsNumber = 1;
-		for (const field of fieldsToGenerate) {
-			const from = this.config[field]!.from, to = this.config[field]!.to;
-			maxUniqueIntervalsNumber *= from - to + 1;
-		}
-
-		if (count > maxUniqueIntervalsNumber) {
-			throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		const intervalSet = new Set<string>();
-		this.state = { rng, fieldsToGenerate, intervalSet };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		let interval, numb: number;
-
-		for (;;) {
-			interval = '';
-
-			for (const field of this.state.fieldsToGenerate) {
-				const from = this.config[field]!.from, to = this.config[field]!.to;
-				[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
-				interval += `${numb} ${field} `;
-			}
-
-			if (!this.state.intervalSet.has(interval)) {
-				this.state.intervalSet.add(interval);
-				break;
-			}
-		}
-
-		return interval;
-	}
-}
-
-export class GenerateStringV2 extends AbstractGenerator<{
-	isUnique?: boolean;
-	arraySize?: number;
-}> {
-	static override readonly 'entityKind': string = 'GenerateString';
-	static override readonly version: number = 2;
-
-	private state: {
-		rng: prand.RandomGenerator;
-		minStringLength: number;
-		maxStringLength: number;
-	} | undefined;
-	override uniqueVersionOfGen = GenerateUniqueStringV2;
-
-	override init({ count, seed }: { count: number; seed: number }) {
-		super.init({ count, seed });
-
-		let minStringLength = 7;
-		let maxStringLength = 20;
-		if (this.stringLength !== undefined) {
-			maxStringLength = this.stringLength;
-			if (maxStringLength === 1) minStringLength = maxStringLength;
-			if (maxStringLength < minStringLength) minStringLength = 1;
-		}
-
-		const rng = prand.xoroshiro128plus(seed);
-		this.state = { rng, minStringLength, maxStringLength };
-	}
-
-	generate() {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const minStringLength = this.state.minStringLength,
-			maxStringLength = this.state.maxStringLength;
-		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-		let idx: number,
-			strLength: number,
-			currStr: string;
-
-		currStr = '';
-		[strLength, this.state.rng] = prand.uniformIntDistribution(
-			minStringLength,
-			maxStringLength,
-			this.state.rng,
-		);
-		for (let j = 0; j < strLength; j++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				stringChars.length - 1,
-				this.state.rng,
-			);
-			currStr += stringChars[idx];
-		}
-		return currStr;
-	}
-}
-
-export class GenerateUniqueStringV2 extends AbstractGenerator<{ isUnique?: boolean }> {
-	static override readonly 'entityKind': string = 'GenerateUniqueString';
-	static override readonly version: number = 2;
-
-	private state: {
-		rng: prand.RandomGenerator;
-		minStringLength: number;
-		maxStringLength: number;
-	} | undefined;
-	public override isUnique = true;
-
-	override init({ seed, count }: { seed: number; count: number }) {
-		const rng = prand.xoroshiro128plus(seed);
-
-		let minStringLength = 7;
-		let maxStringLength = 20;
-		// TODO: revise later
-		if (this.stringLength !== undefined) {
-			maxStringLength = this.stringLength;
-			if (maxStringLength === 1 || maxStringLength < minStringLength) minStringLength = maxStringLength;
-		}
-
-		if (maxStringLength < count.toString(16).length) {
-			throw new Error(
-				`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`,
-			);
-		}
-
-		this.state = { rng, minStringLength, maxStringLength };
-	}
-
-	generate({ i }: { i: number }) {
-		if (this.state === undefined) {
-			throw new Error('state is not defined.');
-		}
-
-		const minStringLength = this.state.minStringLength,
-			maxStringLength = this.state.maxStringLength;
-		const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-		let idx: number,
-			strLength: number;
-		let currStr: string;
-
-		currStr = '';
-		const uniqueStr = i.toString(16);
-		[strLength, this.state.rng] = prand.uniformIntDistribution(
-			minStringLength,
-			maxStringLength - uniqueStr.length,
-			this.state.rng,
-		);
-		for (let j = 0; j < strLength - uniqueStr.length; j++) {
-			[idx, this.state.rng] = prand.uniformIntDistribution(
-				0,
-				stringChars.length - 1,
-				this.state.rng,
-			);
-			currStr += stringChars[idx];
-		}
-
-		return uniqueStr + currStr;
-	}
-}
diff --git a/drizzle-seed/src/singlestore-core/index.ts b/drizzle-seed/src/singlestore-core/index.ts
new file mode 100644
index 0000000000..8511772ef7
--- /dev/null
+++ b/drizzle-seed/src/singlestore-core/index.ts
@@ -0,0 +1,156 @@
+import { type AnyColumn, getTableName, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { SingleStoreDatabase, SingleStoreSchema } from 'drizzle-orm/singlestore-core';
+import { SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+// SingleStore-----------------------------------------------------------------------------------------------------
+export const resetSingleStore = async (
+	db: SingleStoreDatabase<any, any>,
+	schema: { [key: string]: SingleStoreTable },
+) => {
+	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+		const dbTableName = getTableName(table);
+		return dbTableName;
+	});
+
+	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 0;'));
+
+	for (const tableName of tablesToTruncate) {
+		const sqlQuery = `truncate \`${tableName}\`;`;
+		await db.execute(sql.raw(sqlQuery));
+	}
+
+	await db.execute(sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
+};
+
+export const filterSingleStoreTables = (schema: {
+	[key: string]:
+		| SingleStoreTable
+		| SingleStoreSchema
+		| Relations
+		| any;
+}) => {
+	const singleStoreSchema = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, SingleStoreTable | Relations] =>
+				is(keyValue[1], SingleStoreTable) || is(keyValue[1], Relations),
+		),
+	);
+
+	const singleStoreTables = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, SingleStoreTable] => is(keyValue[1], SingleStoreTable),
+		),
+	);
+
+	return { singleStoreSchema, singleStoreTables };
+};
+
+export const seedSingleStore = async (
+	db: SingleStoreDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| SingleStoreTable
+			| SingleStoreSchema
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
+	const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreColumns);
+
+	const seedService = new SeedService();
+
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'singlestore',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		singleStoreTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		singleStoreTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+const getTypeParams = (sqlType: string) => {
+	// get type params and set only type
+	const typeParams: Column['typeParams'] = {};
+
+	if (
+		sqlType.startsWith('decimal')
+		|| sqlType.startsWith('real')
+		|| sqlType.startsWith('double')
+		|| sqlType.startsWith('float')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('char')
+		|| sqlType.startsWith('varchar')
+		|| sqlType.startsWith('text')
+		|| sqlType.startsWith('binary')
+		|| sqlType.startsWith('varbinary')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	} else if (sqlType.startsWith('vector')) {
+		const match = sqlType.match(/\((\d+),? ?((F|I)\d{1,2})?\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+			typeParams['vectorValueType'] = match[2] as typeof typeParams['vectorValueType'];
+		}
+	}
+
+	return typeParams;
+};
+
+export const mapSingleStoreColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	const mappedColumns = columns.map((column) => ({
+		name: dbToTsColumnNamesMap[column.name] as string,
+		columnType: column.getSQLType(),
+		typeParams: getTypeParams(column.getSQLType()),
+		dataType: column.dataType.split(' ')[0]!,
+		hasDefault: column.hasDefault,
+		default: column.default,
+		enumValues: column.enumValues,
+		isUnique: column.isUnique,
+		notNull: column.notNull,
+		primary: column.primary,
+	}));
+
+	return mappedColumns;
+};
diff --git a/drizzle-seed/src/singlestore-core/selectGensForColumn.ts b/drizzle-seed/src/singlestore-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..0455dc698f
--- /dev/null
+++ b/drizzle-seed/src/singlestore-core/selectGensForColumn.ts
@@ -0,0 +1,247 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { Column, Table } from '../types/tables.ts';
+
+export const selectGeneratorForSingleStoreColumn = (
+	table: Table,
+	col: Column,
+) => {
+	const pickGenerator = (table: Table, col: Column) => {
+		// INT ------------------------------------------------------------------------------------------------------------
+		if (
+			(col.columnType.includes('serial') || col.columnType.includes('int'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			return generator;
+		}
+
+		let minValue: number | bigint | undefined;
+		let maxValue: number | bigint | undefined;
+		if (col.columnType === 'serial') {
+			// 2^64 % 2 - 1, 8 bytes
+			minValue = BigInt(0);
+			maxValue = BigInt('9223372036854775807');
+		} else if (col.columnType.includes('int')) {
+			if (col.columnType === 'tinyint') {
+				// 2^8 / 2 - 1, 1 bytes
+				minValue = -128;
+				maxValue = 127;
+			} else if (col.columnType === 'smallint') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -32768;
+				maxValue = 32767;
+			} else if (col.columnType === 'mediumint') {
+				// 2^16 / 2 - 1, 2 bytes
+				minValue = -8388608;
+				maxValue = 8388607;
+			} else if (col.columnType === 'int') {
+				// 2^32 / 2 - 1, 4 bytes
+				minValue = -2147483648;
+				maxValue = 2147483647;
+			} else if (col.columnType === 'bigint') {
+				// 2^64 / 2 - 1, 8 bytes
+				minValue = BigInt('-9223372036854775808');
+				maxValue = BigInt('9223372036854775807');
+			}
+		}
+
+		if (col.columnType.includes('int')) {
+			const generator = new generatorsMap.GenerateInt[0]({
+				minValue,
+				maxValue,
+			});
+			return generator;
+		}
+
+		if (col.columnType.includes('serial')) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			generator.maxValue = maxValue;
+			return generator;
+		}
+
+		// NUMBER(real, double, decimal, float)
+		if (
+			col.columnType.startsWith('real')
+			|| col.columnType.startsWith('double')
+			|| col.columnType.startsWith('decimal')
+			|| col.columnType.startsWith('float')
+			|| col.columnType.startsWith('numeric')
+		) {
+			if (col.typeParams.precision !== undefined) {
+				const precision = col.typeParams.precision;
+				const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+				const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+				const generator = new generatorsMap.GenerateNumber[0]({
+					minValue: -maxAbsoluteValue,
+					maxValue: maxAbsoluteValue,
+					precision: Math.pow(10, scale),
+				});
+				return generator;
+			}
+
+			const generator = new generatorsMap.GenerateNumber[0]();
+			return generator;
+		}
+
+		// STRING
+		if (
+			(col.columnType === 'tinytext'
+				|| col.columnType === 'mediumtext'
+				|| col.columnType === 'text'
+				|| col.columnType === 'longtext'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateUniqueString[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'tinytext'
+				|| col.columnType === 'mediumtext'
+				|| col.columnType === 'text'
+				|| col.columnType === 'longtext'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('name')
+		) {
+			const generator = new generatorsMap.GenerateFirstName[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType === 'tinytext'
+				|| col.columnType === 'mediumtext'
+				|| col.columnType === 'text'
+				|| col.columnType === 'longtext'
+				|| col.columnType === 'blob'
+				|| col.columnType.startsWith('char')
+				|| col.columnType.startsWith('varchar')
+				|| col.columnType.startsWith('binary')
+				|| col.columnType.startsWith('varbinary'))
+			&& col.name.toLowerCase().includes('email')
+		) {
+			const generator = new generatorsMap.GenerateEmail[0]();
+			return generator;
+		}
+
+		if (
+			col.columnType === 'tinytext'
+			|| col.columnType === 'mediumtext'
+			|| col.columnType === 'text'
+			|| col.columnType === 'longtext'
+			|| col.columnType === 'blob'
+			|| col.columnType.startsWith('char')
+			|| col.columnType.startsWith('varchar')
+			|| col.columnType.startsWith('binary')
+			|| col.columnType.startsWith('varbinary')
+		) {
+			const generator = new generatorsMap.GenerateString[0]();
+			return generator;
+		}
+
+		// BOOLEAN
+		if (col.columnType === 'boolean') {
+			const generator = new generatorsMap.GenerateBoolean[0]();
+			return generator;
+		}
+
+		// DATE, TIME, TIMESTAMP, DATETIME, YEAR
+		if (col.columnType.includes('datetime')) {
+			const generator = new generatorsMap.GenerateDatetime[0]();
+			return generator;
+		}
+
+		if (col.columnType.includes('date')) {
+			const generator = new generatorsMap.GenerateDate[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'time') {
+			const generator = new generatorsMap.GenerateTime[0]();
+			return generator;
+		}
+
+		if (col.columnType.includes('timestamp')) {
+			const generator = new generatorsMap.GenerateTimestamp[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'year') {
+			const generator = new generatorsMap.GenerateYear[0]();
+			return generator;
+		}
+
+		// JSON
+		if (col.columnType === 'json') {
+			const generator = new generatorsMap.GenerateJson[0]();
+			return generator;
+		}
+
+		// ENUM
+		if (col.enumValues !== undefined) {
+			const generator = new generatorsMap.GenerateEnum[0]({
+				enumValues: col.enumValues,
+			});
+			return generator;
+		}
+
+		// vector
+		if (col.columnType.startsWith('vector')) {
+			let minValue: number | undefined,
+				maxValue: number | undefined,
+				decimalPlaces: number | undefined;
+			if (col.typeParams.vectorValueType === 'I8') {
+				minValue = -128;
+				maxValue = 127;
+				decimalPlaces = 0;
+			} else if (col.typeParams.vectorValueType === 'I16') {
+				minValue = -32768;
+				maxValue = 32767;
+				decimalPlaces = 0;
+			} else if (col.typeParams.vectorValueType === 'I32') {
+				minValue = -2147483648;
+				maxValue = 2147483647;
+				decimalPlaces = 0;
+			} else if (col.typeParams.vectorValueType === 'I64') {
+				minValue = Number.MIN_SAFE_INTEGER;
+				maxValue = Number.MAX_SAFE_INTEGER;
+				// minValue = -BigInt('9223372036854775808');
+				// maxValue = BigInt('9223372036854775807');
+				decimalPlaces = 0;
+			} else if (col.typeParams.vectorValueType === 'F32') {
+				minValue = -2147483648;
+				maxValue = 2147483647;
+				decimalPlaces = 6;
+			} else if (col.typeParams.vectorValueType === 'F64') {
+				minValue = -524288;
+				maxValue = 524287;
+				decimalPlaces = 10;
+			}
+
+			const generator = new generatorsMap.GenerateVector[0]({ minValue, maxValue, decimalPlaces });
+			return generator;
+		}
+
+		if (col.hasDefault && col.default !== undefined) {
+			const generator = new generatorsMap.GenerateDefault[0]({
+				defaultValue: col.default,
+			});
+			return generator;
+		}
+
+		return;
+	};
+
+	const generator = pickGenerator(table, col);
+
+	return generator;
+};
diff --git a/drizzle-seed/src/sqlite-core/index.ts b/drizzle-seed/src/sqlite-core/index.ts
new file mode 100644
index 0000000000..167203098b
--- /dev/null
+++ b/drizzle-seed/src/sqlite-core/index.ts
@@ -0,0 +1,144 @@
+import { type AnyColumn, getTableName, is, sql } from 'drizzle-orm';
+import { Relations } from 'drizzle-orm/_relations';
+import type { SQLiteAsyncDatabase } from 'drizzle-orm/sqlite-core';
+import { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { getSchemaInfo } from '../common.ts';
+import { SeedService } from '../SeedService.ts';
+import type { RefinementsType } from '../types/seedService.ts';
+import type { Column } from '../types/tables.ts';
+
+// Sqlite------------------------------------------------------------------------------------------------------------------------
+export const resetSqlite = async (
+	db: SQLiteAsyncDatabase<any, any>,
+	schema: { [key: string]: SQLiteTable },
+) => {
+	const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
+		const dbTableName = getTableName(table);
+		return dbTableName;
+	});
+
+	await db.run(sql.raw('PRAGMA foreign_keys = OFF'));
+
+	for (const tableName of tablesToTruncate) {
+		const sqlQuery = `delete from \`${tableName}\`;`;
+		await db.run(sql.raw(sqlQuery));
+	}
+
+	await db.run(sql.raw('PRAGMA foreign_keys = ON'));
+};
+
+export const filterSqliteTables = (schema: {
+	[key: string]:
+		| SQLiteTable
+		| Relations
+		| any;
+}) => {
+	const sqliteSchema = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, SQLiteTable | Relations] =>
+				is(keyValue[1], SQLiteTable) || is(keyValue[1], Relations),
+		),
+	);
+
+	const sqliteTables = Object.fromEntries(
+		Object.entries(schema).filter(
+			(keyValue): keyValue is [string, SQLiteTable] => is(keyValue[1], SQLiteTable),
+		),
+	);
+
+	return { sqliteSchema, sqliteTables };
+};
+
+export const seedSqlite = async (
+	db: SQLiteAsyncDatabase<any, any>,
+	schema: {
+		[key: string]:
+			| SQLiteTable
+			| Relations
+			| any;
+	},
+	options: { count?: number; seed?: number; version?: number } = {},
+	refinements?: RefinementsType,
+) => {
+	const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
+	const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteColumns);
+
+	const seedService = new SeedService();
+
+	const generatedTablesGenerators = seedService.generatePossibleGenerators(
+		'sqlite',
+		tables,
+		relations,
+		refinements,
+		options,
+	);
+
+	const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+
+	const tablesValues = await seedService.generateTablesValues(
+		relations,
+		generatedTablesGenerators,
+		db,
+		sqliteTables,
+		{ ...options, preserveCyclicTablesData },
+	);
+
+	const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(
+		generatedTablesGenerators,
+	);
+	const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+
+	await seedService.generateTablesValues(
+		relations,
+		filteredTablesGenerators,
+		db,
+		sqliteTables,
+		{ ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn },
+	);
+};
+
+const getTypeParams = (sqlType: string) => {
+	// get type params and set only type
+	const typeParams: Column['typeParams'] = {};
+
+	if (
+		sqlType.startsWith('decimal')
+	) {
+		const match = sqlType.match(/\((\d+), *(\d+)\)/);
+		if (match) {
+			typeParams['precision'] = Number(match[1]);
+			typeParams['scale'] = Number(match[2]);
+		}
+	} else if (
+		sqlType.startsWith('char')
+		|| sqlType.startsWith('varchar')
+		|| sqlType.startsWith('text')
+	) {
+		const match = sqlType.match(/\((\d+)\)/);
+		if (match) {
+			typeParams['length'] = Number(match[1]);
+		}
+	}
+
+	return typeParams;
+};
+
+export const mapSqliteColumns = (
+	columns: AnyColumn[],
+	dbToTsColumnNamesMap: { [key: string]: string },
+): Column[] => {
+	const mappedColumns = columns.map((column) => ({
+		name: dbToTsColumnNamesMap[column.name] as string,
+		columnType: column.getSQLType(),
+		typeParams: getTypeParams(column.getSQLType()),
+		dataType: column.dataType.split(' ')[0]!,
+		hasDefault: column.hasDefault,
+		default: column.default,
+		enumValues: column.enumValues,
+		isUnique: column.isUnique,
+		notNull: column.notNull,
+		primary: column.primary,
+	}));
+
+	return mappedColumns;
+};
diff --git a/drizzle-seed/src/sqlite-core/selectGensForColumn.ts b/drizzle-seed/src/sqlite-core/selectGensForColumn.ts
new file mode 100644
index 0000000000..f68cbdf5a8
--- /dev/null
+++ b/drizzle-seed/src/sqlite-core/selectGensForColumn.ts
@@ -0,0 +1,117 @@
+import { generatorsMap } from '../generators/GeneratorFuncs.ts';
+import type { Column, Table } from '../types/tables.ts';
+
+export const selectGeneratorForSqlite = (
+	table: Table,
+	col: Column,
+) => {
+	const pickGenerator = (table: Table, col: Column) => {
+		// int section ---------------------------------------------------------------------------------------
+		if (
+			(col.columnType === 'integer' || col.columnType === 'numeric')
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateIntPrimaryKey[0]();
+			return generator;
+		}
+
+		if (col.columnType === 'integer' && col.dataType === 'boolean') {
+			const generator = new generatorsMap.GenerateBoolean[0]();
+			return generator;
+		}
+
+		if ((col.columnType === 'integer' && col.dataType === 'object')) {
+			const generator = new generatorsMap.GenerateTimestamp[0]();
+			return generator;
+		}
+
+		if (
+			col.columnType === 'integer'
+			|| (col.dataType === 'bigint' && col.columnType === 'blob')
+		) {
+			const generator = new generatorsMap.GenerateInt[0]();
+			return generator;
+		}
+
+		// number section ------------------------------------------------------------------------------------
+		if (col.columnType.startsWith('real') || col.columnType.startsWith('numeric')) {
+			if (col.typeParams.precision !== undefined) {
+				const precision = col.typeParams.precision;
+				const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
+
+				const maxAbsoluteValue = Math.pow(10, precision - scale) - Math.pow(10, -scale);
+				const generator = new generatorsMap.GenerateNumber[0]({
+					minValue: -maxAbsoluteValue,
+					maxValue: maxAbsoluteValue,
+					precision: Math.pow(10, scale),
+				});
+				return generator;
+			}
+
+			const generator = new generatorsMap.GenerateNumber[0]();
+			return generator;
+		}
+
+		// string section ------------------------------------------------------------------------------------
+		if (
+			(col.columnType.startsWith('text')
+				|| col.columnType.startsWith('numeric')
+				|| col.columnType.startsWith('blob'))
+			&& table.primaryKeys.includes(col.name)
+		) {
+			const generator = new generatorsMap.GenerateUniqueString[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType.startsWith('text')
+				|| col.columnType.startsWith('numeric')
+				|| col.columnType.startsWith('blob'))
+			&& col.name.toLowerCase().includes('name')
+		) {
+			const generator = new generatorsMap.GenerateFirstName[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType.startsWith('text')
+				|| col.columnType.startsWith('numeric')
+				|| col.columnType.startsWith('blob'))
+			&& col.name.toLowerCase().includes('email')
+		) {
+			const generator = new generatorsMap.GenerateEmail[0]();
+			return generator;
+		}
+
+		if (
+			col.columnType.startsWith('text')
+			|| col.columnType.startsWith('numeric')
+			|| col.columnType.startsWith('blob')
+			|| col.columnType.startsWith('blobbuffer')
+		) {
+			const generator = new generatorsMap.GenerateString[0]();
+			return generator;
+		}
+
+		if (
+			(col.columnType.startsWith('text') && col.dataType === 'json')
+			|| (col.columnType.startsWith('blob') && col.dataType === 'json')
+		) {
+			const generator = new generatorsMap.GenerateJson[0]();
+			return generator;
+		}
+
+		if (col.hasDefault && col.default !== undefined) {
+			const generator = new generatorsMap.GenerateDefault[0]({
+				defaultValue: col.default,
+			});
+			return generator;
+		}
+
+		return;
+	};
+
+	const generator = pickGenerator(table, col);
+
+	return generator;
+};
diff --git a/drizzle-seed/src/types/seedService.ts b/drizzle-seed/src/types/seedService.ts
index 1ae06f44c6..ba1ab70e54 100644
--- a/drizzle-seed/src/types/seedService.ts
+++ b/drizzle-seed/src/types/seedService.ts
@@ -1,6 +1,25 @@
-import type { AbstractGenerator } from '../services/Generators.ts';
+import type { CockroachDatabase, CockroachTable } from 'drizzle-orm/cockroach-core';
+import type { MsSqlDatabase, MsSqlTable } from 'drizzle-orm/mssql-core';
+import type { MySqlAsyncDatabase, MySqlTable } from 'drizzle-orm/mysql-core';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { PgAsyncDatabase } from 'drizzle-orm/pg-core/async';
+import type { SingleStoreDatabase, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import type { SQLiteAsyncDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { AbstractGenerator } from '../generators/Generators.ts';
 import type { Prettify } from './tables.ts';
 
+export type GeneratedValueType = number | bigint | string | Buffer | boolean | undefined | null;
+
+export type DbType =
+	| PgAsyncDatabase<any, any>
+	| MySqlAsyncDatabase<any, any>
+	| SQLiteAsyncDatabase<any, any, any>
+	| MsSqlDatabase<any, any, any, any>
+	| CockroachDatabase<any, any, any>
+	| SingleStoreDatabase<any, any, any, any>;
+
+export type TableType = PgTable | MySqlTable | SQLiteTable | MsSqlTable | CockroachTable | SingleStoreTable;
+
 export type TableGeneratorsType = {
 	[columnName: string]: Prettify<
 		{
@@ -18,6 +37,7 @@ export type GeneratePossibleGeneratorsColumnType = {
 	notNull: boolean;
 	primary: boolean;
 	generatedIdentityType?: 'always' | 'byDefault' | undefined;
+	identity?: boolean;
 	wasRefined: boolean;
 	wasDefinedBefore: boolean;
 	isCyclic: boolean;
@@ -43,7 +63,7 @@ export type GeneratePossibleGeneratorsTableType = Prettify<{
 export type RefinementsType = Prettify<{
 	[tableName: string]: {
 		count?: number;
-		columns: { [columnName: string]: AbstractGenerator<{}> };
+		columns: { [columnName: string]: AbstractGenerator<{}> | false };
 		with?: { [tableName: string]: number | { weight: number; count: number | number[] }[] };
 	};
 }>;
diff --git a/drizzle-seed/src/types/tables.ts b/drizzle-seed/src/types/tables.ts
index 2fadd23f00..0603263ced 100644
--- a/drizzle-seed/src/types/tables.ts
+++ b/drizzle-seed/src/types/tables.ts
@@ -1,5 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import type { AnyColumn } from 'drizzle-orm';
+import type {
+	CockroachTable,
+	ForeignKey as CockroachFK,
+	UniqueConstraint as CockroachUniCon,
+} from 'drizzle-orm/cockroach-core';
+import type { ForeignKey as MsSqlFK, MsSqlTable, UniqueConstraint as MsSqlUniCon } from 'drizzle-orm/mssql-core';
+import type { ForeignKey as MySqlFK, MySqlTable, UniqueConstraint as MySqlUniCon } from 'drizzle-orm/mysql-core';
+import type { ForeignKey as PgFK, PgTable, UniqueConstraint as PgUniCon } from 'drizzle-orm/pg-core';
+import type { SingleStoreTable, UniqueConstraint as SingleStoreUniCon } from 'drizzle-orm/singlestore-core';
+import type { ForeignKey as SQLiteFK, SQLiteTable, UniqueConstraint as SQLiteUniCon } from 'drizzle-orm/sqlite-core';
+
 export type Column = {
 	name: string;
 	dataType: string;
@@ -9,6 +21,7 @@ export type Column = {
 		scale?: number;
 		length?: number;
 		dimensions?: number;
+		vectorValueType?: 'I8' | 'I16' | 'I32' | 'I64' | 'F32' | 'F64';
 	};
 	size?: number;
 	default?: any;
@@ -18,12 +31,14 @@ export type Column = {
 	notNull: boolean;
 	primary: boolean;
 	generatedIdentityType?: 'always' | 'byDefault' | undefined;
+	identity?: boolean;
 	baseColumn?: Omit<Column, 'generatedIdentityType'>;
 };
 
 export type Table = {
 	name: string;
 	columns: Column[];
+	uniqueConstraints: string[][];
 	primaryKeys: string[];
 };
 
@@ -45,3 +60,21 @@ export type Prettify<T> =
 		[K in keyof T]: T[K];
 	}
 	& {};
+
+export type DrizzleTable = PgTable | MySqlTable | SQLiteTable | CockroachTable | MsSqlTable | SingleStoreTable;
+export type DrizzleForeignKey = PgFK | MySqlFK | SQLiteFK | CockroachFK | MsSqlFK;
+export type DrizzleUniqueConstraint =
+	| PgUniCon
+	| MySqlUniCon
+	| SQLiteUniCon
+	| CockroachUniCon
+	| MsSqlUniCon
+	| SingleStoreUniCon;
+
+export type TableConfigT = {
+	name: string;
+	schema?: string;
+	columns: AnyColumn[];
+	uniqueConstraints: DrizzleUniqueConstraint[];
+	foreignKeys?: DrizzleForeignKey[];
+};
diff --git a/drizzle-seed/src/utils.ts b/drizzle-seed/src/utils.ts
new file mode 100644
index 0000000000..886d463666
--- /dev/null
+++ b/drizzle-seed/src/utils.ts
@@ -0,0 +1,65 @@
+import { is } from 'drizzle-orm';
+import type { PgColumn } from 'drizzle-orm/pg-core';
+import {
+	PgBigInt53,
+	PgBigInt64,
+	PgBigSerial53,
+	PgBigSerial64,
+	PgInteger,
+	PgSerial,
+	PgSmallInt,
+	PgSmallSerial,
+} from 'drizzle-orm/pg-core';
+import type { RelationWithReferences } from './types/tables';
+
+export const isRelationCyclic = (
+	startRel: RelationWithReferences,
+) => {
+	// self relation
+	if (startRel.table === startRel.refTable) return false;
+
+	// DFS
+	const targetTable = startRel.table;
+	const queue = [startRel];
+	let path: string[] = [];
+	while (queue.length !== 0) {
+		const currRel = queue.shift();
+
+		if (path.includes(currRel!.table)) {
+			const idx = path.indexOf(currRel!.table);
+			path = path.slice(0, idx);
+		}
+		path.push(currRel!.table);
+
+		for (const rel of currRel!.refTableRels) {
+			// self relation
+			if (rel.table === rel.refTable) continue;
+
+			if (rel.refTable === targetTable) return true;
+
+			// found cycle, but not the one we are looking for
+			if (path.includes(rel.refTable)) continue;
+			queue.unshift(rel);
+		}
+	}
+
+	return false;
+};
+
+export const equalSets = (set1: Set<any>, set2: Set<any>) => {
+	return set1.size === set2.size && [...set1].every((si) => set2.has(si));
+};
+
+export const intMax = (args: (number | bigint)[]) => args.reduce((m, e) => e > m ? e : m);
+
+export const isPostgresColumnIntLike = (column: PgColumn) => {
+	if (column.dimensions > 0) return false;
+	return is(column, PgSmallInt)
+		|| is(column, PgInteger)
+		|| is(column, PgBigInt53)
+		|| is(column, PgBigInt64)
+		|| is(column, PgSmallSerial)
+		|| is(column, PgSerial)
+		|| is(column, PgBigSerial53)
+		|| is(column, PgBigSerial64);
+};
diff --git a/drizzle-seed/tests/benchmarks/generatorsBenchmark.ts b/drizzle-seed/tests/benchmarks/generatorsBenchmark.ts
index 23fca0c6c0..7147287993 100644
--- a/drizzle-seed/tests/benchmarks/generatorsBenchmark.ts
+++ b/drizzle-seed/tests/benchmarks/generatorsBenchmark.ts
@@ -40,7 +40,7 @@ import {
 	GenerateValuesFromArray,
 	GenerateYear,
 	WeightedRandomGenerator,
-} from '../../src/services/Generators.ts';
+} from '../../src/generators/Generators.ts';
 
 const benchmark = ({ generatorName, generator, count = 100000, seed = 1 }: {
 	generatorName: string;
diff --git a/drizzle-seed/tests/cockroach/allDataTypesTest/cockroachSchema.ts b/drizzle-seed/tests/cockroach/allDataTypesTest/cockroachSchema.ts
new file mode 100644
index 0000000000..921c7ae162
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/allDataTypesTest/cockroachSchema.ts
@@ -0,0 +1,97 @@
+import {
+	bit,
+	bool,
+	char,
+	cockroachEnum,
+	cockroachTable,
+	date,
+	decimal,
+	float,
+	geometry,
+	inet,
+	int2,
+	int4,
+	int8,
+	interval,
+	jsonb,
+	numeric,
+	real,
+	string,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+	vector,
+} from 'drizzle-orm/cockroach-core';
+
+export const moodEnum = cockroachEnum('mood_enum', ['sad', 'ok', 'happy']);
+
+export const allDataTypes = cockroachTable('all_data_types', {
+	int4: int4('int4'),
+	int2: int2('int2'),
+	int8: int8('int8', { mode: 'bigint' }),
+	int8Number: int8('int8_number', { mode: 'number' }),
+	numeric: numeric('numeric'),
+	decimal: decimal('decimal'),
+	real: real('real'),
+	doublePrecision: float('double_precision'),
+	boolean: bool('boolean'),
+	char: char('char', { length: 256 }),
+	varchar: varchar('varchar', { length: 256 }),
+	string: string('string'),
+	bit: bit('bit', { length: 11 }),
+	jsonb: jsonb('jsonb'),
+	time: time('time'),
+	timestampDate: timestamp('timestamp_date', { mode: 'date' }),
+	timestampString: timestamp('timestamp_string', { mode: 'string' }),
+	dateString: date('date_string', { mode: 'string' }),
+	date: date('date', { mode: 'date' }),
+	interval: interval('interval'),
+	moodEnum: moodEnum('mood_enum'),
+	uuid: uuid('uuid'),
+	inet: inet('inet'),
+	geometry: geometry('geometry', { type: 'point', mode: 'tuple', srid: 0 }),
+	vector: vector('vector', { dimensions: 3 }),
+});
+
+export const allArrayDataTypes = cockroachTable('all_array_data_types', {
+	int4Array: int4('int4_array').array(),
+	int2Array: int2('int2_array').array(),
+	int8Array: int8('int8_array', { mode: 'bigint' }).array(),
+	int8NumberArray: int8('int8_number_array', { mode: 'number' }).array(),
+	numericArray: numeric('numeric_array').array(),
+	decimalArray: decimal('decimal_array').array(),
+	realArray: real('real_array').array(),
+	doublePrecisionArray: float('double_precision_array').array(),
+	booleanArray: bool('boolean_array').array(),
+	charArray: char('char_array', { length: 256 }).array(),
+	varcharArray: varchar('varchar_array', { length: 256 }).array(),
+	stringArray: string('string_array').array(),
+	bitArray: bit('bit_array', { length: 11 }).array(),
+	timeArray: time('time_array').array(),
+	timestampDateArray: timestamp('timestamp_date_array', { mode: 'date' }).array(),
+	timestampStringArray: timestamp('timestamp_string_array', { mode: 'string' }).array(),
+	dateStringArray: date('date_string_array', { mode: 'string' }).array(),
+	dateArray: date('date_array', { mode: 'date' }).array(),
+	intervalArray: interval('interval_array').array(),
+	moodEnumArray: moodEnum('mood_enum_array').array(),
+	uuidArray: uuid('uuid_array').array(),
+	inetArray: inet('inet_array').array(),
+	geometryArray: geometry('geometry_array', { type: 'point', mode: 'tuple', srid: 0 }).array(1),
+});
+
+export const intervals = cockroachTable('intervals', {
+	intervalYear: interval({ fields: 'year' }),
+	intervalYearToMonth: interval({ fields: 'year to month' }),
+	intervalMonth: interval({ fields: 'month' }),
+	intervalDay: interval({ fields: 'day' }),
+	intervalDayToHour: interval({ fields: 'day to hour' }),
+	intervalDayToMinute: interval({ fields: 'day to minute' }),
+	intervalDayToSecond: interval({ fields: 'day to second' }),
+	intervalHour: interval({ fields: 'hour' }),
+	intervalHourToMinute: interval({ fields: 'hour to minute' }),
+	intervalHourToSecond: interval({ fields: 'hour to second' }),
+	intervalMinute: interval({ fields: 'minute' }),
+	intervalMinuteToSecond: interval({ fields: 'minute to second' }),
+	intervalSecond: interval({ fields: 'second' }),
+});
diff --git a/drizzle-seed/tests/cockroach/allDataTypesTest/cockroach_all_data_types.test.ts b/drizzle-seed/tests/cockroach/allDataTypesTest/cockroach_all_data_types.test.ts
new file mode 100644
index 0000000000..a69c197676
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/allDataTypesTest/cockroach_all_data_types.test.ts
@@ -0,0 +1,144 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { cockroachTest as test } from '../instrumentation.ts';
+import * as schema from './cockroachSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			CREATE TYPE "mood_enum" AS ENUM('sad', 'ok', 'happy');
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "all_data_types" (
+				"int2" int2,
+				"int4" int4,
+				"int8" int8,
+				"int8_number" int8,
+				"numeric" numeric,
+				"decimal" numeric,
+				"real" real,
+				"double_precision" double precision,
+				"boolean" boolean,
+				"char" char(256),
+				"varchar" varchar(256),
+				"string" string,
+				"bit" bit(11),
+				"jsonb" jsonb,
+				"time" time,
+				"timestamp_date" timestamp,
+				"timestamp_string" timestamp,
+				"date_string" date,
+				"date" date,
+				"interval" interval,
+				"mood_enum" "mood_enum",
+				"uuid" uuid,
+				"inet" inet,
+				"geometry" geometry(point, 0),
+				"vector" vector(3)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "all_array_data_types" (
+				"int2_array" int2[],
+				"int4_array" int4[],
+				"int8_array" int8[],
+				"int8_number_array" int8[],
+				"numeric_array" numeric[],
+				"decimal_array" numeric[],
+				"real_array" real[],
+				"double_precision_array" double precision[],
+				"boolean_array" boolean[],
+				"char_array" char(256)[],
+				"varchar_array" varchar(256)[],
+				"string_array" string[],
+				"bit_array" bit(11)[],
+				"time_array" time[],
+				"timestamp_date_array" timestamp[],
+				"timestamp_string_array" timestamp[],
+				"date_string_array" date[],
+				"date_array" date[],
+				"interval_array" interval[],
+				"mood_enum_array" "mood_enum"[],
+				"uuid_array" uuid[],
+				"inet_array" inet[],
+				"geometry_array" geometry(point, 0)[]
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "intervals" (
+				"intervalYear" interval year,
+				"intervalYearToMonth" interval year to month,
+				"intervalMonth" interval month,
+				"intervalDay" interval day,
+				"intervalDayToHour" interval day to hour,
+				"intervalDayToMinute" interval day to minute,
+				"intervalDayToSecond" interval day to second,
+				"intervalHour" interval hour,
+				"intervalHourToMinute" interval hour to minute,
+				"intervalHourToSecond" interval hour to second,
+				"intervalMinute" interval minute,
+				"intervalMinuteToSecond" interval minute to second,
+				"intervalSecond" interval second
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('all data types test', async ({ db }) => {
+	await seed(db, { allDataTypes: schema.allDataTypes }, { count: 10000 });
+
+	const allDataTypes = await db.select().from(schema.allDataTypes);
+	// every value in each rows does not equal undefined.
+	const predicate = allDataTypes.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+
+	expect(predicate).toBe(true);
+});
+
+test('all array data types test', async ({ db }) => {
+	await seed(db, { allArrayDataTypes: schema.allArrayDataTypes }, { count: 1 });
+
+	const allArrayDataTypes = await db.select().from(schema.allArrayDataTypes);
+	// every value in each rows does not equal undefined.
+	const predicate = allArrayDataTypes.every((row) =>
+		Object.values(row).every((val) => val !== undefined && val !== null && (val.length === 10 || val.length === 1))
+	);
+
+	expect(predicate).toBe(true);
+});
+
+test('intervals test', async ({ db }) => {
+	await seed(db, { intervals: schema.intervals }, { count: 1000 });
+
+	const intervals = await db.select().from(schema.intervals);
+	// every value in each rows does not equal undefined.
+	const predicate = intervals.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/cockroach/cockroach.test.ts b/drizzle-seed/tests/cockroach/cockroach.test.ts
new file mode 100644
index 0000000000..70eb497f15
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/cockroach.test.ts
@@ -0,0 +1,411 @@
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
+import { expect, vi } from 'vitest';
+import { reset, seed } from '../../src/index.ts';
+import * as schema from './cockroachSchema.ts';
+import { cockroachTest as test } from './instrumentation.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "customer" (
+				"id" varchar(256) PRIMARY KEY NOT NULL,
+				"company_name" text NOT NULL,
+				"contact_name" text NOT NULL,
+				"contact_title" text NOT NULL,
+				"address" text NOT NULL,
+				"city" text NOT NULL,
+				"postal_code" text,
+				"region" text,
+				"country" text NOT NULL,
+				"phone" text NOT NULL,
+				"fax" text
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "order_detail" (
+				"unit_price" numeric NOT NULL,
+				"quantity" integer NOT NULL,
+				"discount" numeric NOT NULL,
+				"order_id" integer NOT NULL,
+				"product_id" integer NOT NULL
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "employee" (
+				"id" integer PRIMARY KEY NOT NULL,
+				"last_name" text NOT NULL,
+				"first_name" text,
+				"title" text NOT NULL,
+				"title_of_courtesy" text NOT NULL,
+				"birth_date" timestamp NOT NULL,
+				"hire_date" timestamp NOT NULL,
+				"address" text NOT NULL,
+				"city" text NOT NULL,
+				"postal_code" text NOT NULL,
+				"country" text NOT NULL,
+				"home_phone" text NOT NULL,
+				"extension" integer NOT NULL,
+				"notes" text NOT NULL,
+				"reports_to" integer,
+				"photo_path" text
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "order" (
+				"id" integer PRIMARY KEY NOT NULL,
+				"order_date" timestamp NOT NULL,
+				"required_date" timestamp NOT NULL,
+				"shipped_date" timestamp,
+				"ship_via" integer NOT NULL,
+				"freight" numeric NOT NULL,
+				"ship_name" text NOT NULL,
+				"ship_city" text NOT NULL,
+				"ship_region" text,
+				"ship_postal_code" text,
+				"ship_country" text NOT NULL,
+				"customer_id" text NOT NULL,
+				"employee_id" integer NOT NULL
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "product" (
+				"id" integer PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"quantity_per_unit" text NOT NULL,
+				"unit_price" numeric NOT NULL,
+				"units_in_stock" integer NOT NULL,
+				"units_on_order" integer NOT NULL,
+				"reorder_level" integer NOT NULL,
+				"discontinued" integer NOT NULL,
+				"supplier_id" integer NOT NULL
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "supplier" (
+				"id" integer PRIMARY KEY NOT NULL,
+				"company_name" text NOT NULL,
+				"contact_name" text NOT NULL,
+				"contact_title" text NOT NULL,
+				"address" text NOT NULL,
+				"city" text NOT NULL,
+				"region" text,
+				"postal_code" text NOT NULL,
+				"country" text NOT NULL,
+				"phone" text NOT NULL
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "order_detail" ADD CONSTRAINT "order_detail_order_id_order_id_fk" FOREIGN KEY ("order_id") REFERENCES "order"("id") ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "order_detail" ADD CONSTRAINT "order_detail_product_id_product_id_fk" FOREIGN KEY ("product_id") REFERENCES "product"("id") ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "employee" ADD CONSTRAINT "employee_reports_to_employee_id_fk" FOREIGN KEY ("reports_to") REFERENCES "employee"("id") ON DELETE no action ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "order" ADD CONSTRAINT "order_customer_id_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "customer"("id") ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "order" ADD CONSTRAINT "order_employee_id_employee_id_fk" FOREIGN KEY ("employee_id") REFERENCES "employee"("id") ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE "product" ADD CONSTRAINT "product_supplier_id_supplier_id_fk" FOREIGN KEY ("supplier_id") REFERENCES "supplier"("id") ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "identity_columns_table" (
+				"id" integer generated always as identity,
+				"id1" integer generated by default as identity,
+				"name" text
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table "users"
+			(
+			    id          serial
+			        primary key,
+			    name        text,
+			    "invitedBy" integer
+			        constraint "users_invitedBy_user_id_fk"
+			            references "users"
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table "posts"
+			(
+			    id          serial
+			        primary key,
+			    name        text,
+				content     text,
+			    "userId" integer
+			        constraint "users_userId_user_id_fk"
+			            references "users"
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	await seed(db, schema);
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(10);
+	expect(details.length).toBe(10);
+	expect(employees.length).toBe(10);
+	expect(orders.length).toBe(10);
+	expect(products.length).toBe(10);
+	expect(suppliers.length).toBe(10);
+});
+
+test('seed with options.count:11 test', async ({ db }) => {
+	await seed(db, schema, { count: 11 });
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(11);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('redefine(refine) customers count', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('redefine(refine) all tables count', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+		details: {
+			count: 13,
+		},
+		employees: {
+			count: 14,
+		},
+		orders: {
+			count: 15,
+		},
+		products: {
+			count: 16,
+		},
+		suppliers: {
+			count: 17,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(13);
+	expect(employees.length).toBe(14);
+	expect(orders.length).toBe(15);
+	expect(products.length).toBe(16);
+	expect(suppliers.length).toBe(17);
+});
+
+test("redefine(refine) orders count using 'with' in customers", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 13,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test("sequential using of 'with'", async ({ db }) => {
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 12,
+			with: {
+				details: 3,
+			},
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(24);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('seeding with identity columns', async ({ db }) => {
+	await seed(db, { identityColumnsTable: schema.identityColumnsTable });
+
+	const result = await db.select().from(schema.identityColumnsTable);
+
+	expect(result.length).toBe(10);
+});
+
+test('seeding with self relation', async ({ db }) => {
+	await seed(db, { users: schema.users });
+
+	const result = await db.select().from(schema.users);
+
+	expect(result.length).toBe(10);
+	const predicate = result.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('overlapping a foreign key constraint with a one-to-many relation', async ({ db }) => {
+	const postsRelation = relations(schema.posts, ({ one }) => ({
+		user: one(schema.users, { fields: [schema.posts.userId], references: [schema.users.id] }),
+	}));
+
+	const consoleMock = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+	await reset(db, { users: schema.users, posts: schema.posts, postsRelation });
+	await seed(db, { users: schema.users, posts: schema.posts, postsRelation });
+	// expecting to get a warning
+	expect(consoleMock).toBeCalled();
+	expect(consoleMock).toBeCalledWith(expect.stringMatching(/^You are providing a one-to-many relation.+/));
+
+	const users = await db.select().from(schema.users);
+	const posts = await db.select().from(schema.posts);
+
+	expect(users.length).toBe(10);
+	let predicate = users.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(posts.length).toBe(10);
+	predicate = posts.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/cockroach/cockroachSchema.ts b/drizzle-seed/tests/cockroach/cockroachSchema.ts
new file mode 100644
index 0000000000..056ac79252
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/cockroachSchema.ts
@@ -0,0 +1,127 @@
+import type { AnyCockroachColumn } from 'drizzle-orm/cockroach-core';
+import { cockroachTable, int4, numeric, text, timestamp, varchar } from 'drizzle-orm/cockroach-core';
+
+export const customers = cockroachTable('customer', {
+	id: varchar('id', { length: 256 }).primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	postalCode: text('postal_code'),
+	region: text('region'),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+	fax: text('fax'),
+});
+
+export const employees = cockroachTable(
+	'employee',
+	{
+		id: int4('id').primaryKey(),
+		lastName: text('last_name').notNull(),
+		firstName: text('first_name'),
+		title: text('title').notNull(),
+		titleOfCourtesy: text('title_of_courtesy').notNull(),
+		birthDate: timestamp('birth_date').notNull(),
+		hireDate: timestamp('hire_date').notNull(),
+		address: text('address').notNull(),
+		city: text('city').notNull(),
+		postalCode: text('postal_code').notNull(),
+		country: text('country').notNull(),
+		homePhone: text('home_phone').notNull(),
+		extension: int4('extension').notNull(),
+		notes: text('notes').notNull(),
+		reportsTo: int4('reports_to').references((): AnyCockroachColumn => employees.id),
+		photoPath: text('photo_path'),
+	},
+);
+
+export const orders = cockroachTable('order', {
+	id: int4('id').primaryKey(),
+	orderDate: timestamp('order_date').notNull(),
+	requiredDate: timestamp('required_date').notNull(),
+	shippedDate: timestamp('shipped_date'),
+	shipVia: int4('ship_via').notNull(),
+	freight: numeric('freight').notNull(),
+	shipName: text('ship_name').notNull(),
+	shipCity: text('ship_city').notNull(),
+	shipRegion: text('ship_region'),
+	shipPostalCode: text('ship_postal_code'),
+	shipCountry: text('ship_country').notNull(),
+
+	customerId: text('customer_id')
+		.notNull()
+		.references(() => customers.id, { onDelete: 'cascade' }),
+
+	employeeId: int4('employee_id')
+		.notNull()
+		.references(() => employees.id, { onDelete: 'cascade' }),
+});
+
+export const suppliers = cockroachTable('supplier', {
+	id: int4('id').primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	region: text('region'),
+	postalCode: text('postal_code').notNull(),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+});
+
+export const products = cockroachTable('product', {
+	id: int4('id').primaryKey(),
+	name: text('name').notNull(),
+	quantityPerUnit: text('quantity_per_unit').notNull(),
+	unitPrice: numeric('unit_price').notNull(),
+	unitsInStock: int4('units_in_stock').notNull(),
+	unitsOnOrder: int4('units_on_order').notNull(),
+	reorderLevel: int4('reorder_level').notNull(),
+	discontinued: int4('discontinued').notNull(),
+
+	supplierId: int4('supplier_id')
+		.notNull()
+		.references(() => suppliers.id, { onDelete: 'cascade' }),
+});
+
+export const details = cockroachTable('order_detail', {
+	unitPrice: numeric('unit_price').notNull(),
+	quantity: int4('quantity').notNull(),
+	discount: numeric('discount').notNull(),
+
+	orderId: int4('order_id')
+		.notNull()
+		.references(() => orders.id, { onDelete: 'cascade' }),
+
+	productId: int4('product_id')
+		.notNull()
+		.references(() => products.id, { onDelete: 'cascade' }),
+});
+
+export const identityColumnsTable = cockroachTable('identity_columns_table', {
+	id: int4().generatedAlwaysAsIdentity(),
+	id1: int4().generatedByDefaultAsIdentity(),
+	name: text(),
+});
+
+export const users = cockroachTable(
+	'users',
+	{
+		id: int4().primaryKey(),
+		name: text(),
+		invitedBy: int4().references((): AnyCockroachColumn => users.id),
+	},
+);
+
+export const posts = cockroachTable(
+	'posts',
+	{
+		id: int4().primaryKey(),
+		name: text(),
+		content: text(),
+		userId: int4().references(() => users.id),
+	},
+);
diff --git a/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroach.test.ts b/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroach.test.ts
new file mode 100644
index 0000000000..f6700f8b80
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroach.test.ts
@@ -0,0 +1,202 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { cockroachTest as test } from '../instrumentation.ts';
+import * as schema from './cockroachSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "composite_example" (
+				"id" int4 not null,
+				"name" text not null,
+				CONSTRAINT "composite_example_id_name_unique" UNIQUE("id","name"),
+				CONSTRAINT "custom_name" UNIQUE("id","name")
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "unique_column_in_composite_of_two_0" (
+				"id" int4 not null unique,
+				"name" text not null,
+				CONSTRAINT "custom_name0" UNIQUE("id","name")
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "unique_column_in_composite_of_two_1" (
+				"id" int4 not null,
+				"name" text not null,
+				CONSTRAINT "custom_name1" UNIQUE("id","name"),
+				CONSTRAINT "custom_name1_id" UNIQUE("id")
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "unique_column_in_composite_of_three_0" (
+				"id" int4 not null unique,
+				"name" text not null,
+				"slug" text not null,
+				CONSTRAINT "custom_name2" UNIQUE("id","name","slug")
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "unique_column_in_composite_of_three_1" (
+				"id" int4 not null,
+				"name" text not null,
+				"slug" text not null,
+				CONSTRAINT "custom_name3" UNIQUE("id","name","slug"),
+				CONSTRAINT "custom_name3_id" UNIQUE("id")
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	const currSchema = { composite: schema.composite };
+	await seed(db, currSchema, { count: 16 });
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------------
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------------
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------------
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	// ------------------------------------------------------------------
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	// ------------------------------------------------------------------
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
diff --git a/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroachSchema.ts b/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroachSchema.ts
new file mode 100644
index 0000000000..c949d5b6e1
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/compositeUniqueKey/cockroachSchema.ts
@@ -0,0 +1,40 @@
+import { cockroachTable, int4, text, unique, varchar } from 'drizzle-orm/cockroach-core';
+
+export const composite = cockroachTable('composite_example', {
+	id: int4('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = cockroachTable('unique_column_in_composite_of_two_0', {
+	id: int4('id').notNull().unique(),
+	name: varchar('name', { length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = cockroachTable('unique_column_in_composite_of_two_1', {
+	id: int4('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = cockroachTable('unique_column_in_composite_of_three_0', {
+	id: int4('id').notNull().unique(),
+	name: text('name').notNull(),
+	slug: varchar('slug').notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = cockroachTable('unique_column_in_composite_of_three_1', {
+	id: int4('id').notNull(),
+	name: text('name').notNull(),
+	slug: varchar('slug').notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/cockroach/cyclicTables/cockroachSchema.ts b/drizzle-seed/tests/cockroach/cyclicTables/cockroachSchema.ts
new file mode 100644
index 0000000000..d57a61cc58
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/cyclicTables/cockroachSchema.ts
@@ -0,0 +1,88 @@
+import { relations } from 'drizzle-orm/_relations';
+import type { AnyCockroachColumn } from 'drizzle-orm/cockroach-core';
+import { cockroachTable, foreignKey, int4, string, varchar } from 'drizzle-orm/cockroach-core';
+
+// MODEL
+export const modelTable = cockroachTable(
+	'model',
+	{
+		id: int4().primaryKey().generatedByDefaultAsIdentity(),
+		name: varchar().notNull(),
+		defaultImageId: int4(),
+	},
+	(t) => [
+		foreignKey({
+			columns: [t.defaultImageId],
+			foreignColumns: [modelImageTable.id],
+		}),
+	],
+);
+
+export const modelRelations = relations(modelTable, ({ one, many }) => ({
+	images: many(modelImageTable),
+	defaultImage: one(modelImageTable, {
+		fields: [modelTable.defaultImageId],
+		references: [modelImageTable.id],
+	}),
+}));
+
+// MODEL IMAGE
+export const modelImageTable = cockroachTable(
+	'model_image',
+	{
+		id: int4().primaryKey(),
+		url: varchar().notNull(),
+		caption: varchar(),
+		modelId: int4()
+			.notNull()
+			.references((): AnyCockroachColumn => modelTable.id),
+	},
+);
+
+export const modelImageRelations = relations(modelImageTable, ({ one }) => ({
+	model: one(modelTable, {
+		fields: [modelImageTable.modelId],
+		references: [modelTable.id],
+	}),
+}));
+
+// 3 tables case
+export const modelTable1 = cockroachTable(
+	'model1',
+	{
+		id: int4().primaryKey(),
+		name: varchar().notNull(),
+		userId: int4()
+			.references(() => user.id),
+		defaultImageId: int4(),
+	},
+	(t) => [
+		foreignKey({
+			columns: [t.defaultImageId],
+			foreignColumns: [modelImageTable1.id],
+		}),
+	],
+);
+
+export const modelImageTable1 = cockroachTable(
+	'model_image1',
+	{
+		id: int4().primaryKey(),
+		url: varchar().notNull(),
+		caption: varchar(),
+		modelId: int4().notNull()
+			.references((): AnyCockroachColumn => modelTable1.id),
+	},
+);
+
+export const user = cockroachTable(
+	'user',
+	{
+		id: int4().primaryKey(),
+		name: string(),
+		invitedBy: int4().references((): AnyCockroachColumn => user.id),
+		imageId: int4()
+			.notNull()
+			.references((): AnyCockroachColumn => modelImageTable1.id),
+	},
+);
diff --git a/drizzle-seed/tests/cockroach/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/cockroach/cyclicTables/cyclicTables.test.ts
new file mode 100644
index 0000000000..d0619686c5
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/cyclicTables/cyclicTables.test.ts
@@ -0,0 +1,157 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { cockroachTest as test } from '../instrumentation.ts';
+import * as schema from './cockroachSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			create table model_image
+			(
+			    id        int4 generated by default as identity
+			        primary key,
+			    url       varchar not null,
+			    caption   varchar,
+			    "modelId" int4 not null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table model
+			      (
+			          id               int4 generated by default as identity
+			              primary key,
+			          name             varchar not null,
+			          "defaultImageId" int4
+			              constraint "model_defaultImageId_model_image_id_fk"
+			                  references model_image
+			      );
+		`,
+		);
+
+		await db.execute(
+			sql`
+			alter table model_image
+						    add constraint "model_image_modelId_model_id_fk"
+						        foreign key ("modelId") references model;
+		`,
+		);
+
+		// 3 tables case
+		await db.execute(
+			sql`
+			create table model_image1
+			(
+			    id        int4 generated by default as identity
+			        primary key,
+			    url       varchar not null,
+			    caption   varchar,
+			    "modelId" int4 not null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table "user"
+			(
+			    id          int4 generated by default as identity
+			        primary key,
+			    name        string,
+			    "invitedBy" int4
+			        constraint "user_invitedBy_user_id_fk"
+			            references "user",
+			    "imageId"   int4 not null
+			        constraint "user_imageId_model_image1_id_fk"
+			            references model_image1
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table model1
+			(
+			    id               int4 generated by default as identity
+			        primary key,
+			    name             varchar not null,
+			    "userId"         int4
+			        constraint "model1_userId_user_id_fk"
+			            references "user",
+			    "defaultImageId" int4
+			        constraint "model1_defaultImageId_model_image1_id_fk"
+			            references model_image1
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			alter table model_image1
+			 add constraint "model_image1_modelId_model1_id_fk"
+			     foreign key ("modelId") references model1;
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('2 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable: schema.modelTable,
+		modelImageTable: schema.modelImageTable,
+	});
+
+	const modelTable = await db.select().from(schema.modelTable);
+	const modelImageTable = await db.select().from(schema.modelImageTable);
+
+	expect(modelTable.length).toBe(10);
+	let predicate = modelTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable.length).toBe(10);
+	predicate = modelImageTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('3 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable1: schema.modelTable1,
+		modelImageTable1: schema.modelImageTable1,
+		user: schema.user,
+	});
+
+	const modelTable1 = await db.select().from(schema.modelTable1);
+	const modelImageTable1 = await db.select().from(schema.modelImageTable1);
+	const user = await db.select().from(schema.user);
+
+	expect(modelTable1.length).toBe(10);
+	let predicate = modelTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable1.length).toBe(10);
+	predicate = modelImageTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(user.length).toBe(10);
+	predicate = user.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/cockroach/instrumentation.ts b/drizzle-seed/tests/cockroach/instrumentation.ts
new file mode 100644
index 0000000000..c14d30fb90
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/instrumentation.ts
@@ -0,0 +1,80 @@
+import { drizzle } from 'drizzle-orm/cockroach';
+import type { CockroachDatabase } from 'drizzle-orm/cockroach-core';
+import { Client } from 'pg';
+import { test as base } from 'vitest';
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/cockroach/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+const prepareTest = () => {
+	return base.extend<
+		{
+			client: {
+				client: Client;
+				query: (sql: string, params: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<void>;
+			};
+			db: CockroachDatabase<any, any, any>;
+			push: (schema: any) => Promise<void>;
+		}
+	>({
+		client: [
+			// oxlint-disable-next-line
+			async ({}, use) => {
+				const envurl = process.env['COCKROACH_CONNECTION_STRING'];
+				if (!envurl) throw new Error('No cockroach url provided');
+
+				const client = new Client(envurl);
+				await client.connect();
+
+				const query = async (sql: string, params: any[] = []) => {
+					const res = await client.query(sql, params);
+					return res.rows as any[];
+				};
+				const batch = async (statements: string[]) => {
+					return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+				};
+
+				await batch(['drop database if exists drizzle;', 'create database drizzle;', 'use drizzle;']);
+
+				await use({ client, query, batch });
+				await client.end();
+			},
+			{ scope: 'worker' },
+		],
+		db: [
+			async ({ client }, use) => {
+				const db = drizzle({ client: client.client });
+				await use(db as any);
+			},
+			{ scope: 'worker' },
+		],
+		push: [
+			async ({ client }, use) => {
+				const { query } = client;
+				const push = (
+					schema: any,
+				) => _push(query, schema);
+
+				await use(push);
+			},
+			{ scope: 'worker' },
+		],
+	});
+};
+
+export const cockroachTest = prepareTest();
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/drizzle-seed/tests/cockroach/softRelationsTest/cockroachSchema.ts b/drizzle-seed/tests/cockroach/softRelationsTest/cockroachSchema.ts
new file mode 100644
index 0000000000..c05fe41226
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/softRelationsTest/cockroachSchema.ts
@@ -0,0 +1,128 @@
+import { relations } from 'drizzle-orm/_relations';
+import { cockroachTable, int4, numeric, string, timestamp, varchar } from 'drizzle-orm/cockroach-core';
+
+export const customers = cockroachTable('customer', {
+	id: varchar('id', { length: 256 }).primaryKey(),
+	companyName: string('company_name').notNull(),
+	contactName: string('contact_name').notNull(),
+	contactTitle: string('contact_title').notNull(),
+	address: string('address').notNull(),
+	city: string('city').notNull(),
+	postalCode: string('postal_code'),
+	region: string('region'),
+	country: string('country').notNull(),
+	phone: string('phone').notNull(),
+	fax: string('fax'),
+});
+
+export const employees = cockroachTable(
+	'employee',
+	{
+		id: int4('id').primaryKey(),
+		lastName: string('last_name').notNull(),
+		firstName: string('first_name'),
+		title: string('title').notNull(),
+		titleOfCourtesy: string('title_of_courtesy').notNull(),
+		birthDate: timestamp('birth_date').notNull(),
+		hireDate: timestamp('hire_date').notNull(),
+		address: string('address').notNull(),
+		city: string('city').notNull(),
+		postalCode: string('postal_code').notNull(),
+		country: string('country').notNull(),
+		homePhone: string('home_phone').notNull(),
+		extension: int4('extension').notNull(),
+		notes: string('notes').notNull(),
+		reportsTo: int4('reports_to'),
+		photoPath: string('photo_path'),
+	},
+);
+
+export const employeesRelations = relations(employees, ({ one }) => ({
+	employee: one(employees, {
+		fields: [employees.reportsTo],
+		references: [employees.id],
+	}),
+}));
+
+export const orders = cockroachTable('order', {
+	id: int4('id').primaryKey(),
+	orderDate: timestamp('order_date').notNull(),
+	requiredDate: timestamp('required_date').notNull(),
+	shippedDate: timestamp('shipped_date'),
+	shipVia: int4('ship_via').notNull(),
+	freight: numeric('freight').notNull(),
+	shipName: string('ship_name').notNull(),
+	shipCity: string('ship_city').notNull(),
+	shipRegion: string('ship_region'),
+	shipPostalCode: string('ship_postal_code'),
+	shipCountry: string('ship_country').notNull(),
+
+	customerId: string('customer_id').notNull(),
+
+	employeeId: int4('employee_id').notNull(),
+});
+
+export const ordersRelations = relations(orders, ({ one }) => ({
+	customer: one(customers, {
+		fields: [orders.customerId],
+		references: [customers.id],
+	}),
+	employee: one(employees, {
+		fields: [orders.employeeId],
+		references: [employees.id],
+	}),
+}));
+
+export const suppliers = cockroachTable('supplier', {
+	id: int4('id').primaryKey(),
+	companyName: string('company_name').notNull(),
+	contactName: string('contact_name').notNull(),
+	contactTitle: string('contact_title').notNull(),
+	address: string('address').notNull(),
+	city: string('city').notNull(),
+	region: string('region'),
+	postalCode: string('postal_code').notNull(),
+	country: string('country').notNull(),
+	phone: string('phone').notNull(),
+});
+
+export const products = cockroachTable('product', {
+	id: int4('id').primaryKey(),
+	name: string('name').notNull(),
+	quantityPerUnit: string('quantity_per_unit').notNull(),
+	unitPrice: numeric('unit_price').notNull(),
+	unitsInStock: int4('units_in_stock').notNull(),
+	unitsOnOrder: int4('units_on_order').notNull(),
+	reorderLevel: int4('reorder_level').notNull(),
+	discontinued: int4('discontinued').notNull(),
+
+	supplierId: int4('supplier_id').notNull(),
+});
+
+export const productsRelations = relations(products, ({ one }) => ({
+	supplier: one(suppliers, {
+		fields: [products.supplierId],
+		references: [suppliers.id],
+	}),
+}));
+
+export const details = cockroachTable('order_detail', {
+	unitPrice: numeric('unit_price').notNull(),
+	quantity: int4('quantity').notNull(),
+	discount: numeric('discount').notNull(),
+
+	orderId: int4('order_id').notNull(),
+
+	productId: int4('product_id').notNull(),
+});
+
+export const detailsRelations = relations(details, ({ one }) => ({
+	order: one(orders, {
+		fields: [details.orderId],
+		references: [orders.id],
+	}),
+	product: one(products, {
+		fields: [details.productId],
+		references: [products.id],
+	}),
+}));
diff --git a/drizzle-seed/tests/cockroach/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/cockroach/softRelationsTest/softRelations.test.ts
new file mode 100644
index 0000000000..e2712e8d9d
--- /dev/null
+++ b/drizzle-seed/tests/cockroach/softRelationsTest/softRelations.test.ts
@@ -0,0 +1,253 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { cockroachTest as test } from '../instrumentation.ts';
+import * as schema from './cockroachSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "customer" (
+				"id" varchar(256) PRIMARY KEY NOT NULL,
+				"company_name" string NOT NULL,
+				"contact_name" string NOT NULL,
+				"contact_title" string NOT NULL,
+				"address" string NOT NULL,
+				"city" string NOT NULL,
+				"postal_code" string,
+				"region" string,
+				"country" string NOT NULL,
+				"phone" string NOT NULL,
+				"fax" string
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "order_detail" (
+				"unit_price" numeric NOT NULL,
+				"quantity" int4 NOT NULL,
+				"discount" numeric NOT NULL,
+				"order_id" int4 NOT NULL,
+				"product_id" int4 NOT NULL
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "employee" (
+				"id" int4 PRIMARY KEY NOT NULL,
+				"last_name" string NOT NULL,
+				"first_name" string,
+				"title" string NOT NULL,
+				"title_of_courtesy" string NOT NULL,
+				"birth_date" timestamp NOT NULL,
+				"hire_date" timestamp NOT NULL,
+				"address" string NOT NULL,
+				"city" string NOT NULL,
+				"postal_code" string NOT NULL,
+				"country" string NOT NULL,
+				"home_phone" string NOT NULL,
+				"extension" int4 NOT NULL,
+				"notes" string NOT NULL,
+				"reports_to" int4,
+				"photo_path" string
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "order" (
+				"id" int4 PRIMARY KEY NOT NULL,
+				"order_date" timestamp NOT NULL,
+				"required_date" timestamp NOT NULL,
+				"shipped_date" timestamp,
+				"ship_via" int4 NOT NULL,
+				"freight" numeric NOT NULL,
+				"ship_name" string NOT NULL,
+				"ship_city" string NOT NULL,
+				"ship_region" string,
+				"ship_postal_code" string,
+				"ship_country" string NOT NULL,
+				"customer_id" string NOT NULL,
+				"employee_id" int4 NOT NULL
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "product" (
+				"id" int4 PRIMARY KEY NOT NULL,
+				"name" string NOT NULL,
+				"quantity_per_unit" string NOT NULL,
+				"unit_price" numeric NOT NULL,
+				"units_in_stock" int4 NOT NULL,
+				"units_on_order" int4 NOT NULL,
+				"reorder_level" int4 NOT NULL,
+				"discontinued" int4 NOT NULL,
+				"supplier_id" int4 NOT NULL
+			);    
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "supplier" (
+				"id" int4 PRIMARY KEY NOT NULL,
+				"company_name" string NOT NULL,
+				"contact_name" string NOT NULL,
+				"contact_title" string NOT NULL,
+				"address" string NOT NULL,
+				"city" string NOT NULL,
+				"region" string,
+				"postal_code" string NOT NULL,
+				"country" string NOT NULL,
+				"phone" string NOT NULL
+			);    
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+const checkSoftRelations = (
+	customers: (typeof schema.customers.$inferSelect)[],
+	details: (typeof schema.details.$inferSelect)[],
+	employees: (typeof schema.employees.$inferSelect)[],
+	orders: (typeof schema.orders.$inferSelect)[],
+	products: (typeof schema.products.$inferSelect)[],
+	suppliers: (typeof schema.suppliers.$inferSelect)[],
+) => {
+	// employees soft relations check
+	const employeeIds = new Set(employees.map((employee) => employee.id));
+	const employeesPredicate = employees.every((employee) =>
+		employee.reportsTo !== null && employeeIds.has(employee.reportsTo)
+	);
+	expect(employeesPredicate).toBe(true);
+
+	// orders soft relations check
+	const customerIds = new Set(customers.map((customer) => customer.id));
+	const ordersPredicate1 = orders.every((order) => order.customerId !== null && customerIds.has(order.customerId));
+	expect(ordersPredicate1).toBe(true);
+
+	const ordersPredicate2 = orders.every((order) => order.employeeId !== null && employeeIds.has(order.employeeId));
+	expect(ordersPredicate2).toBe(true);
+
+	// product soft relations check
+	const supplierIds = new Set(suppliers.map((supplier) => supplier.id));
+	const productsPredicate = products.every((product) =>
+		product.supplierId !== null && supplierIds.has(product.supplierId)
+	);
+	expect(productsPredicate).toBe(true);
+
+	// details soft relations check
+	const orderIds = new Set(orders.map((order) => order.id));
+	const detailsPredicate1 = details.every((detail) => detail.orderId !== null && orderIds.has(detail.orderId));
+	expect(detailsPredicate1).toBe(true);
+
+	const productIds = new Set(products.map((product) => product.id));
+	const detailsPredicate2 = details.every((detail) => detail.productId !== null && productIds.has(detail.productId));
+	expect(detailsPredicate2).toBe(true);
+};
+
+test('basic seed, soft relations test', async ({ db }) => {
+	await seed(db, schema);
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(10);
+	expect(details.length).toBe(10);
+	expect(employees.length).toBe(10);
+	expect(orders.length).toBe(10);
+	expect(products.length).toBe(10);
+	expect(suppliers.length).toBe(10);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("redefine(refine) orders count using 'with' in customers, soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 13,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("sequential using of 'with', soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 12,
+			with: {
+				details: 3,
+			},
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(24);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
diff --git a/drizzle-seed/tests/mssql/allDataTypesTest/mssqlSchema.ts b/drizzle-seed/tests/mssql/allDataTypesTest/mssqlSchema.ts
new file mode 100644
index 0000000000..9aaccfe656
--- /dev/null
+++ b/drizzle-seed/tests/mssql/allDataTypesTest/mssqlSchema.ts
@@ -0,0 +1,50 @@
+import {
+	bigint,
+	binary,
+	bit,
+	char,
+	date,
+	datetime,
+	datetime2,
+	datetimeoffset,
+	decimal,
+	float,
+	int,
+	mssqlTable,
+	numeric,
+	real,
+	smallint,
+	text,
+	time,
+	tinyint,
+	varbinary,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+
+export const allDataTypes = mssqlTable('all_data_types', {
+	int: int('integer'),
+	tinyint: tinyint('tinyint'),
+	smallint: smallint('smallint'),
+	biginteger: bigint('bigint', { mode: 'bigint' }),
+	bigintNumber: bigint('bigint_number', { mode: 'number' }),
+	real: real('real'),
+	decimal: decimal('decimal'),
+	numeric: numeric('numeric'),
+	float: float('float'),
+	binary: binary('binary', { length: 5 }),
+	varbinary: varbinary('varbinary', { length: 5 }),
+	char: char('char', { length: 5 }),
+	varchar: varchar('varchar', { length: 5 }),
+	text: text('text'),
+	bit: bit('bit'),
+	dateString: date('date_string', { mode: 'string' }),
+	date: date('date', { mode: 'date' }),
+	datetime: datetime('datetime', { mode: 'date' }),
+	datetimeString: datetime('datetime_string', { mode: 'string' }),
+	datetime2: datetime2('datetime2', { mode: 'date' }),
+	datetime2String: datetime2('datetime2_string', { mode: 'string' }),
+	datetimeOffset: datetimeoffset('datetime_offset', { mode: 'date' }),
+	datetimeOffsetString: datetimeoffset('datetime_offset_string', { mode: 'string' }),
+	time: time('time'),
+	// json: json('json'),
+});
diff --git a/drizzle-seed/tests/mssql/allDataTypesTest/mssql_all_data_types.test.ts b/drizzle-seed/tests/mssql/allDataTypesTest/mssql_all_data_types.test.ts
new file mode 100644
index 0000000000..a414abbfa4
--- /dev/null
+++ b/drizzle-seed/tests/mssql/allDataTypesTest/mssql_all_data_types.test.ts
@@ -0,0 +1,65 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mssqlTest as test } from '../instrumentation.ts';
+import * as schema from './mssqlSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+				CREATE TABLE [all_data_types] (
+				[integer] int,
+				[tinyint] tinyint,
+				[smallint] smallint,
+				[bigint] bigint,
+				[bigint_number] bigint,
+				[real] real,
+				[decimal] decimal,
+				[numeric] numeric,
+				[float] float,
+				[binary] binary(5),
+				[varbinary] varbinary(5),
+				[char] char(5),
+				[varchar] varchar(5),
+				[text] text,
+				[bit] bit,
+				[date_string] date,
+				[date] date,
+				[datetime] datetime,
+				[datetime_string] datetime,
+				[datetime2] datetime2,
+				[datetime2_string] datetime2,
+				[datetime_offset] datetimeoffset,
+				[datetime_offset_string] datetimeoffset,
+				[time] time
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	await seed(db, schema, { count: 10000 });
+
+	const allDataTypes = await db.select().from(schema.allDataTypes);
+
+	// every value in each 10 rows does not equal undefined.
+	const predicate = allDataTypes.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/mssql/compositeUniqueKey/mssql.test.ts b/drizzle-seed/tests/mssql/compositeUniqueKey/mssql.test.ts
new file mode 100644
index 0000000000..26d21fa576
--- /dev/null
+++ b/drizzle-seed/tests/mssql/compositeUniqueKey/mssql.test.ts
@@ -0,0 +1,196 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mssqlTest as test } from '../instrumentation.ts';
+import * as schema from './mssqlSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			CREATE TABLE [composite_example] (
+				[id] int not null,
+				[name] varchar(256) not null,
+				CONSTRAINT [composite_example_id_name_unique] UNIQUE([id],[name]),
+				CONSTRAINT [custom_name] UNIQUE([id],[name])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE [unique_column_in_composite_of_two_0] (
+				[id] int not null unique,
+				[name] varchar(256) not null,
+				CONSTRAINT [custom_name0] UNIQUE([id],[name])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE [unique_column_in_composite_of_two_1] (
+				[id] int not null,
+				[name] varchar(256) not null,
+				CONSTRAINT [custom_name1] UNIQUE([id],[name]),
+				CONSTRAINT [custom_name1_id] UNIQUE([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE [unique_column_in_composite_of_three_0] (
+				[id] int not null unique,
+				[name] varchar(256) not null,
+				[slug] varchar(256) not null,
+				CONSTRAINT [custom_name2] UNIQUE([id],[name],[slug])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE [unique_column_in_composite_of_three_1] (
+				[id] int not null,
+				[name] varchar(256) not null,
+				[slug] varchar(256) not null,
+				CONSTRAINT [custom_name3] UNIQUE([id],[name],[slug]),
+				CONSTRAINT [custom_name3_id] UNIQUE([id])
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	const currSchema = { composite: schema.composite };
+	await seed(db, currSchema, { count: 16 });
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
diff --git a/drizzle-seed/tests/mssql/compositeUniqueKey/mssqlSchema.ts b/drizzle-seed/tests/mssql/compositeUniqueKey/mssqlSchema.ts
new file mode 100644
index 0000000000..62cb304f95
--- /dev/null
+++ b/drizzle-seed/tests/mssql/compositeUniqueKey/mssqlSchema.ts
@@ -0,0 +1,40 @@
+import { int, mssqlTable, unique, varchar } from 'drizzle-orm/mssql-core';
+
+export const composite = mssqlTable('composite_example', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = mssqlTable('unique_column_in_composite_of_two_0', {
+	id: int('id').notNull().unique(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = mssqlTable('unique_column_in_composite_of_two_1', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = mssqlTable('unique_column_in_composite_of_three_0', {
+	id: int('id').notNull().unique(),
+	name: varchar('name', { length: 256 }).notNull(),
+	slug: varchar('slug', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = mssqlTable('unique_column_in_composite_of_three_1', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+	slug: varchar('slug', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/mssql/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/mssql/cyclicTables/cyclicTables.test.ts
new file mode 100644
index 0000000000..1414e60b4c
--- /dev/null
+++ b/drizzle-seed/tests/mssql/cyclicTables/cyclicTables.test.ts
@@ -0,0 +1,154 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mssqlTest as test } from '../instrumentation.ts';
+import * as schema from './mssqlSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+		await db.execute(
+			sql`
+			create table [model]
+			(
+				[id]             int identity not null
+					primary key,
+				[name]           varchar(256) not null,
+				[defaultImageId] int          null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table [model_image]
+			(
+				[id]      int identity not null
+					primary key,
+				[url]     varchar(256) not null,
+				[caption] varchar(256) null,
+				[modelId] int          not null,
+				constraint [model_image_modelId_model_id_fk]
+					foreign key ([modelId]) references [model] ([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			alter table [model]
+			 add constraint [model_defaultImageId_model_image_id_fk]
+				 foreign key ([defaultImageId]) references [model_image] ([id]);
+		`,
+		);
+
+		// 3 tables case
+		await db.execute(
+			sql`
+			create table [model1]
+			(
+				[id]             int identity not null
+					primary key,
+				[name]           varchar(256) not null,
+				[userId]         int          null,
+				[defaultImageId] int          null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table [model_image1]
+			(
+				[id]      int identity not null
+					primary key,
+				[url]     varchar(256) not null,
+				[caption] varchar(256) null,
+				[modelId] int          not null,
+				constraint [model_image1_modelId_model1_id_fk]
+					foreign key ([modelId]) references [model1] ([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table [user]
+			(
+				[id]        int identity not null
+					primary key,
+				[name]      text 		   null,
+				[invitedBy] int  		   null,
+				[imageId]   int  		   not null,
+				constraint [user_imageId_model_image1_id_fk]
+					foreign key ([imageId]) references [model_image1] ([id]),
+				constraint [user_invitedBy_user_id_fk]
+					foreign key ([invitedBy]) references [user] ([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			alter table [model1]
+			 add constraint [model1_userId_user_id_fk]
+				 foreign key ([userId]) references [user] ([id]);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('2 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable: schema.modelTable,
+		modelImageTable: schema.modelImageTable,
+	});
+
+	const modelTable = await db.select().from(schema.modelTable);
+	const modelImageTable = await db.select().from(schema.modelImageTable);
+
+	expect(modelTable.length).toBe(10);
+	let predicate = modelTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable.length).toBe(10);
+	predicate = modelImageTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('3 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable1: schema.modelTable1,
+		modelImageTable1: schema.modelImageTable1,
+		user: schema.user,
+	});
+
+	const modelTable1 = await db.select().from(schema.modelTable1);
+	const modelImageTable1 = await db.select().from(schema.modelImageTable1);
+	const user = await db.select().from(schema.user);
+
+	expect(modelTable1.length).toBe(10);
+	let predicate = modelTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable1.length).toBe(10);
+	predicate = modelImageTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(user.length).toBe(10);
+	predicate = user.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/mssql/cyclicTables/mssqlSchema.ts b/drizzle-seed/tests/mssql/cyclicTables/mssqlSchema.ts
new file mode 100644
index 0000000000..b0c869b1f0
--- /dev/null
+++ b/drizzle-seed/tests/mssql/cyclicTables/mssqlSchema.ts
@@ -0,0 +1,76 @@
+import { relations } from 'drizzle-orm/_relations';
+import type { AnyMsSqlColumn } from 'drizzle-orm/mssql-core';
+import { int, mssqlTable, text, varchar } from 'drizzle-orm/mssql-core';
+
+// MODEL
+export const modelTable = mssqlTable(
+	'model',
+	{
+		id: int().identity().primaryKey(),
+		name: varchar({ length: 256 }).notNull(),
+		defaultImageId: int().references(() => modelImageTable.id),
+	},
+);
+
+export const modelRelations = relations(modelTable, ({ one, many }) => ({
+	images: many(modelImageTable),
+	defaultImage: one(modelImageTable, {
+		fields: [modelTable.defaultImageId],
+		references: [modelImageTable.id],
+	}),
+}));
+
+// MODEL IMAGE
+export const modelImageTable = mssqlTable(
+	'model_image',
+	{
+		id: int().identity().primaryKey(),
+		url: varchar({ length: 256 }).notNull(),
+		caption: varchar({ length: 256 }),
+		modelId: int()
+			.notNull()
+			.references((): AnyMsSqlColumn => modelTable.id),
+	},
+);
+
+export const modelImageRelations = relations(modelImageTable, ({ one }) => ({
+	model: one(modelTable, {
+		fields: [modelImageTable.modelId],
+		references: [modelTable.id],
+	}),
+}));
+
+// 3 tables case
+export const modelTable1 = mssqlTable(
+	'model1',
+	{
+		id: int().identity().primaryKey(),
+		name: varchar({ length: 256 }).notNull(),
+		userId: int()
+			.references(() => user.id),
+		defaultImageId: int(),
+	},
+);
+
+export const modelImageTable1 = mssqlTable(
+	'model_image1',
+	{
+		id: int().identity().primaryKey(),
+		url: varchar({ length: 256 }).notNull(),
+		caption: varchar({ length: 256 }),
+		modelId: int().notNull()
+			.references((): AnyMsSqlColumn => modelTable1.id),
+	},
+);
+
+export const user = mssqlTable(
+	'user',
+	{
+		id: int().identity().primaryKey(),
+		name: text(),
+		invitedBy: int().references((): AnyMsSqlColumn => user.id),
+		imageId: int()
+			.notNull()
+			.references((): AnyMsSqlColumn => modelImageTable1.id),
+	},
+);
diff --git a/drizzle-seed/tests/mssql/instrumentation.ts b/drizzle-seed/tests/mssql/instrumentation.ts
new file mode 100644
index 0000000000..4c544d2cb3
--- /dev/null
+++ b/drizzle-seed/tests/mssql/instrumentation.ts
@@ -0,0 +1,88 @@
+import { drizzle, MsSqlDatabase } from 'drizzle-orm/node-mssql';
+import mssql from 'mssql';
+import { test as base } from 'vitest';
+import { parseMssqlUrl } from './utils';
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/mssql/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+const prepareTest = () => {
+	return base.extend<
+		{
+			client: {
+				client: mssql.ConnectionPool;
+				query: (sql: string, params: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<void>;
+			};
+			db: MsSqlDatabase<any, any, any, any>;
+			push: (schema: any) => Promise<void>;
+		}
+	>({
+		client: [
+			// oxlint-disable-next-line
+			async ({}, use) => {
+				const envurl = process.env['MSSQL_CONNECTION_STRING'];
+				if (!envurl) throw new Error('No mssql url provided');
+
+				const options = parseMssqlUrl(envurl);
+				const client = await mssql.connect(options);
+				await client.connect();
+
+				const query = async (sql: string, params: any[] = []) => {
+					const request = client.request();
+					for (const [index, param] of params.entries()) {
+						request.input(`par${index}`, param);
+					}
+
+					const res = await request.query(sql);
+					return res.recordset as any[];
+				};
+				const batch = async (statements: string[]) => {
+					return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+				};
+
+				await client.query('drop database if exists drizzle;');
+				await client.query('create database drizzle;');
+				await client.query('use drizzle;');
+
+				await use({ client, query, batch });
+				await client.close();
+			},
+			{ scope: 'worker' },
+		],
+		db: [
+			async ({ client }, use) => {
+				const db = drizzle({ client: client.client });
+				await use(db as any);
+			},
+			{ scope: 'worker' },
+		],
+		push: [
+			async ({ client }, use) => {
+				const { query } = client;
+				const push = (
+					schema: any,
+				) => _push(query, schema);
+
+				await use(push);
+			},
+			{ scope: 'worker' },
+		],
+	});
+};
+
+export const mssqlTest = prepareTest();
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/drizzle-seed/tests/mssql/mssql.test.ts b/drizzle-seed/tests/mssql/mssql.test.ts
new file mode 100644
index 0000000000..6525cf9212
--- /dev/null
+++ b/drizzle-seed/tests/mssql/mssql.test.ts
@@ -0,0 +1,386 @@
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
+import { expect, vi } from 'vitest';
+import { reset, seed } from '../../src/index.ts';
+import { mssqlTest as test } from './instrumentation.ts';
+import * as schema from './mssqlSchema.ts';
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+				CREATE TABLE [customer] (
+				[id] varchar(256) NOT NULL,
+				[company_name] varchar(max) NOT NULL,
+				[contact_name] varchar(max) NOT NULL,
+				[contact_title] varchar(max) NOT NULL,
+				[address] varchar(max) NOT NULL,
+				[city] varchar(max) NOT NULL,
+				[postal_code] varchar(max),
+				[region] varchar(max),
+				[country] varchar(max) NOT NULL,
+				[phone] varchar(max) NOT NULL,
+				[fax] varchar(max),
+				CONSTRAINT [customer_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [order_detail] (
+				[unit_price] float NOT NULL,
+				[quantity] int NOT NULL,
+				[discount] float NOT NULL,
+				[order_id] int NOT NULL,
+				[product_id] int NOT NULL
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [employee] (
+				[id] int NOT NULL,
+				[last_name] varchar(max) NOT NULL,
+				[first_name] varchar(max),
+				[title] varchar(max) NOT NULL,
+				[title_of_courtesy] varchar(max) NOT NULL,
+				[birth_date] datetime NOT NULL,
+				[hire_date] datetime NOT NULL,
+				[address] varchar(max) NOT NULL,
+				[city] varchar(max) NOT NULL,
+				[postal_code] varchar(max) NOT NULL,
+				[country] varchar(max) NOT NULL,
+				[home_phone] varchar(max) NOT NULL,
+				[extension] int NOT NULL,
+				[notes] varchar(max) NOT NULL,
+				[reports_to] int,
+				[photo_path] varchar(max),
+				CONSTRAINT [employee_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [order] (
+				[id] int NOT NULL,
+				[order_date] datetime NOT NULL,
+				[required_date] datetime NOT NULL,
+				[shipped_date] datetime,
+				[ship_via] int NOT NULL,
+				[freight] float NOT NULL,
+				[ship_name] varchar(max) NOT NULL,
+				[ship_city] varchar(max) NOT NULL,
+				[ship_region] varchar(max),
+				[ship_postal_code] varchar(max),
+				[ship_country] varchar(max) NOT NULL,
+				[customer_id] varchar(256) NOT NULL,
+				[employee_id] int NOT NULL,
+				CONSTRAINT [order_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [product] (
+				[id] int NOT NULL,
+				[name] varchar(max) NOT NULL,
+				[quantity_per_unit] varchar(max) NOT NULL,
+				[unit_price] float NOT NULL,
+				[units_in_stock] int NOT NULL,
+				[units_on_order] int NOT NULL,
+				[reorder_level] int NOT NULL,
+				[discontinued] int NOT NULL,
+				[supplier_id] int NOT NULL,
+				CONSTRAINT [product_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [supplier] (
+				[id] int NOT NULL,
+				[company_name] varchar(max) NOT NULL,
+				[contact_name] varchar(max) NOT NULL,
+				[contact_title] varchar(max) NOT NULL,
+				[address] varchar(max) NOT NULL,
+				[city] varchar(max) NOT NULL,
+				[region] varchar(max),
+				[postal_code] varchar(max) NOT NULL,
+				[country] varchar(max) NOT NULL,
+				[phone] varchar(max) NOT NULL,
+				CONSTRAINT [supplier_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [users] (
+				[id] int,
+				[name] varchar(max),
+				[invitedBy] int,
+				CONSTRAINT [users_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [posts] (
+				[id] int,
+				[name] varchar(max),
+				[content] varchar(max),
+				[userId] int,
+				CONSTRAINT [posts_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [order_detail] ADD CONSTRAINT [order_detail_order_id_order_id_fk] FOREIGN KEY ([order_id]) REFERENCES [order]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [order_detail] ADD CONSTRAINT [order_detail_product_id_product_id_fk] FOREIGN KEY ([product_id]) REFERENCES [product]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [employee] ADD CONSTRAINT [employee_reports_to_employee_id_fk] FOREIGN KEY ([reports_to]) REFERENCES [employee]([id]) ON DELETE no action ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [order] ADD CONSTRAINT [order_customer_id_customer_id_fk] FOREIGN KEY ([customer_id]) REFERENCES [customer]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [order] ADD CONSTRAINT [order_employee_id_employee_id_fk] FOREIGN KEY ([employee_id]) REFERENCES [employee]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [product] ADD CONSTRAINT [product_supplier_id_supplier_id_fk] FOREIGN KEY ([supplier_id]) REFERENCES [supplier]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [users] ADD CONSTRAINT [users_invitedBy_users_id_fk] FOREIGN KEY ([invitedBy]) REFERENCES [users]([id]) ON DELETE no action ON UPDATE no action;
+		`,
+		);
+
+		await db.execute(
+			sql`
+			ALTER TABLE [posts] ADD CONSTRAINT [posts_userId_users_id_fk] FOREIGN KEY ([userId]) REFERENCES [users]([id]) ON DELETE cascade ON UPDATE no action;
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test('basic seed test', async ({ db }) => {
+	await seed(db, schema);
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(10);
+	expect(details.length).toBe(10);
+	expect(employees.length).toBe(10);
+	expect(orders.length).toBe(10);
+	expect(products.length).toBe(10);
+	expect(suppliers.length).toBe(10);
+});
+
+test('seed with options.count:11 test', async ({ db }) => {
+	await seed(db, schema, { count: 11 });
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(11);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('redefine(refine) customers count', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('redefine(refine) all tables count', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+		details: {
+			count: 13,
+		},
+		employees: {
+			count: 14,
+		},
+		orders: {
+			count: 15,
+		},
+		products: {
+			count: 16,
+		},
+		suppliers: {
+			count: 17,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(13);
+	expect(employees.length).toBe(14);
+	expect(orders.length).toBe(15);
+	expect(products.length).toBe(16);
+	expect(suppliers.length).toBe(17);
+});
+
+test("redefine(refine) orders count using 'with' in customers", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 13,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test("sequential using of 'with'", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 12,
+			with: {
+				details: 3,
+			},
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(24);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+});
+
+test('overlapping a foreign key constraint with a one-to-many relation', async ({ db }) => {
+	const postsRelation = relations(schema.posts, ({ one }) => ({
+		user: one(schema.users, { fields: [schema.posts.userId], references: [schema.users.id] }),
+	}));
+
+	const consoleMock = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+	await reset(db, { users: schema.users, posts: schema.posts, postsRelation });
+	await seed(db, { users: schema.users, posts: schema.posts, postsRelation });
+	// expecting to get a warning
+	expect(consoleMock).toBeCalled();
+	expect(consoleMock).toBeCalledWith(expect.stringMatching(/^You are providing a one-to-many relation.+/));
+
+	const users = await db.select().from(schema.users);
+	const posts = await db.select().from(schema.posts);
+
+	expect(users.length).toBe(10);
+	let predicate = users.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(posts.length).toBe(10);
+	predicate = posts.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/mssql/mssqlSchema.ts b/drizzle-seed/tests/mssql/mssqlSchema.ts
new file mode 100644
index 0000000000..f1f836978d
--- /dev/null
+++ b/drizzle-seed/tests/mssql/mssqlSchema.ts
@@ -0,0 +1,121 @@
+import type { AnyMsSqlColumn } from 'drizzle-orm/mssql-core';
+import { datetime, float, int, mssqlTable, text, varchar } from 'drizzle-orm/mssql-core';
+
+export const customers = mssqlTable('customer', {
+	id: varchar('id', { length: 256 }).primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	postalCode: text('postal_code'),
+	region: text('region'),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+	fax: text('fax'),
+});
+
+export const employees = mssqlTable(
+	'employee',
+	{
+		id: int('id').primaryKey(),
+		lastName: text('last_name').notNull(),
+		firstName: text('first_name'),
+		title: text('title').notNull(),
+		titleOfCourtesy: text('title_of_courtesy').notNull(),
+		birthDate: datetime('birth_date').notNull(),
+		hireDate: datetime('hire_date').notNull(),
+		address: text('address').notNull(),
+		city: text('city').notNull(),
+		postalCode: text('postal_code').notNull(),
+		country: text('country').notNull(),
+		homePhone: text('home_phone').notNull(),
+		extension: int('extension').notNull(),
+		notes: text('notes').notNull(),
+		reportsTo: int('reports_to').references((): AnyMsSqlColumn => employees.id),
+		photoPath: text('photo_path'),
+	},
+);
+
+export const orders = mssqlTable('order', {
+	id: int('id').primaryKey(),
+	orderDate: datetime('order_date').notNull(),
+	requiredDate: datetime('required_date').notNull(),
+	shippedDate: datetime('shipped_date'),
+	shipVia: int('ship_via').notNull(),
+	freight: float('freight').notNull(),
+	shipName: text('ship_name').notNull(),
+	shipCity: text('ship_city').notNull(),
+	shipRegion: text('ship_region'),
+	shipPostalCode: text('ship_postal_code'),
+	shipCountry: text('ship_country').notNull(),
+
+	customerId: varchar('customer_id', { length: 256 })
+		.notNull()
+		.references(() => customers.id, { onDelete: 'cascade' }),
+
+	employeeId: int('employee_id')
+		.notNull()
+		.references(() => employees.id, { onDelete: 'cascade' }),
+});
+
+export const suppliers = mssqlTable('supplier', {
+	id: int('id').primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	region: text('region'),
+	postalCode: text('postal_code').notNull(),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+});
+
+export const products = mssqlTable('product', {
+	id: int('id').primaryKey(),
+	name: text('name').notNull(),
+	quantityPerUnit: text('quantity_per_unit').notNull(),
+	unitPrice: float('unit_price').notNull(),
+	unitsInStock: int('units_in_stock').notNull(),
+	unitsOnOrder: int('units_on_order').notNull(),
+	reorderLevel: int('reorder_level').notNull(),
+	discontinued: int('discontinued').notNull(),
+
+	supplierId: int('supplier_id')
+		.notNull()
+		.references(() => suppliers.id, { onDelete: 'cascade' }),
+});
+
+export const details = mssqlTable('order_detail', {
+	unitPrice: float('unit_price').notNull(),
+	quantity: int('quantity').notNull(),
+	discount: float('discount').notNull(),
+
+	orderId: int('order_id')
+		.notNull()
+		.references(() => orders.id, { onDelete: 'cascade' }),
+
+	productId: int('product_id')
+		.notNull()
+		.references(() => products.id, { onDelete: 'cascade' }),
+});
+
+export const users = mssqlTable(
+	'users',
+	{
+		id: int().primaryKey(),
+		name: text(),
+		invitedBy: int().references((): AnyMsSqlColumn => users.id),
+	},
+);
+
+export const posts = mssqlTable(
+	'posts',
+	{
+		id: int().primaryKey(),
+		name: text(),
+		content: text(),
+		userId: int().references(() => users.id),
+	},
+);
diff --git a/drizzle-seed/tests/mssql/softRelationsTest/mssqlSchema.ts b/drizzle-seed/tests/mssql/softRelationsTest/mssqlSchema.ts
new file mode 100644
index 0000000000..823da6727a
--- /dev/null
+++ b/drizzle-seed/tests/mssql/softRelationsTest/mssqlSchema.ts
@@ -0,0 +1,128 @@
+import { relations } from 'drizzle-orm/_relations';
+import { datetime, float, int, mssqlTable, text, varchar } from 'drizzle-orm/mssql-core';
+
+export const customers = mssqlTable('customer', {
+	id: varchar('id', { length: 256 }).primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	postalCode: text('postal_code'),
+	region: text('region'),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+	fax: text('fax'),
+});
+
+export const employees = mssqlTable(
+	'employee',
+	{
+		id: int('id').primaryKey(),
+		lastName: text('last_name').notNull(),
+		firstName: text('first_name'),
+		title: text('title').notNull(),
+		titleOfCourtesy: text('title_of_courtesy').notNull(),
+		birthDate: datetime('birth_date').notNull(),
+		hireDate: datetime('hire_date').notNull(),
+		address: text('address').notNull(),
+		city: text('city').notNull(),
+		postalCode: text('postal_code').notNull(),
+		country: text('country').notNull(),
+		homePhone: text('home_phone').notNull(),
+		extension: int('extension').notNull(),
+		notes: text('notes').notNull(),
+		reportsTo: int('reports_to'),
+		photoPath: text('photo_path'),
+	},
+);
+
+export const employeesRelations = relations(employees, ({ one }) => ({
+	employee: one(employees, {
+		fields: [employees.reportsTo],
+		references: [employees.id],
+	}),
+}));
+
+export const orders = mssqlTable('order', {
+	id: int('id').primaryKey(),
+	orderDate: datetime('order_date').notNull(),
+	requiredDate: datetime('required_date').notNull(),
+	shippedDate: datetime('shipped_date'),
+	shipVia: int('ship_via').notNull(),
+	freight: float('freight').notNull(),
+	shipName: text('ship_name').notNull(),
+	shipCity: text('ship_city').notNull(),
+	shipRegion: text('ship_region'),
+	shipPostalCode: text('ship_postal_code'),
+	shipCountry: text('ship_country').notNull(),
+
+	customerId: varchar('customer_id', { length: 256 }).notNull(),
+
+	employeeId: int('employee_id').notNull(),
+});
+
+export const ordersRelations = relations(orders, ({ one }) => ({
+	customer: one(customers, {
+		fields: [orders.customerId],
+		references: [customers.id],
+	}),
+	employee: one(employees, {
+		fields: [orders.employeeId],
+		references: [employees.id],
+	}),
+}));
+
+export const suppliers = mssqlTable('supplier', {
+	id: int('id').primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	region: text('region'),
+	postalCode: text('postal_code').notNull(),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+});
+
+export const products = mssqlTable('product', {
+	id: int('id').primaryKey(),
+	name: text('name').notNull(),
+	quantityPerUnit: text('quantity_per_unit').notNull(),
+	unitPrice: float('unit_price').notNull(),
+	unitsInStock: int('units_in_stock').notNull(),
+	unitsOnOrder: int('units_on_order').notNull(),
+	reorderLevel: int('reorder_level').notNull(),
+	discontinued: int('discontinued').notNull(),
+
+	supplierId: int('supplier_id').notNull(),
+});
+
+export const productsRelations = relations(products, ({ one }) => ({
+	supplier: one(suppliers, {
+		fields: [products.supplierId],
+		references: [suppliers.id],
+	}),
+}));
+
+export const details = mssqlTable('order_detail', {
+	unitPrice: float('unit_price').notNull(),
+	quantity: int('quantity').notNull(),
+	discount: float('discount').notNull(),
+
+	orderId: int('order_id').notNull(),
+
+	productId: int('product_id').notNull(),
+});
+
+export const detailsRelations = relations(details, ({ one }) => ({
+	order: one(orders, {
+		fields: [details.orderId],
+		references: [orders.id],
+	}),
+	product: one(products, {
+		fields: [details.productId],
+		references: [products.id],
+	}),
+}));
diff --git a/drizzle-seed/tests/mssql/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/mssql/softRelationsTest/softRelations.test.ts
new file mode 100644
index 0000000000..d5ceac6f45
--- /dev/null
+++ b/drizzle-seed/tests/mssql/softRelationsTest/softRelations.test.ts
@@ -0,0 +1,258 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mssqlTest as test } from '../instrumentation.ts';
+import * as schema from './mssqlSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+				CREATE TABLE [customer] (
+				[id] varchar(256) NOT NULL,
+				[company_name] text NOT NULL,
+				[contact_name] text NOT NULL,
+				[contact_title] text NOT NULL,
+				[address] text NOT NULL,
+				[city] text NOT NULL,
+				[postal_code] text,
+				[region] text,
+				[country] text NOT NULL,
+				[phone] text NOT NULL,
+				[fax] text,
+				CONSTRAINT [customer_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [order_detail] (
+				[unit_price] float NOT NULL,
+				[quantity] int NOT NULL,
+				[discount] float NOT NULL,
+				[order_id] int NOT NULL,
+				[product_id] int NOT NULL
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [employee] (
+				[id] int NOT NULL,
+				[last_name] text NOT NULL,
+				[first_name] text,
+				[title] text NOT NULL,
+				[title_of_courtesy] text NOT NULL,
+				[birth_date] datetime NOT NULL,
+				[hire_date] datetime NOT NULL,
+				[address] text NOT NULL,
+				[city] text NOT NULL,
+				[postal_code] text NOT NULL,
+				[country] text NOT NULL,
+				[home_phone] text NOT NULL,
+				[extension] int NOT NULL,
+				[notes] text NOT NULL,
+				[reports_to] int,
+				[photo_path] text,
+				CONSTRAINT [employee_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [order] (
+				[id] int NOT NULL,
+				[order_date] datetime NOT NULL,
+				[required_date] datetime NOT NULL,
+				[shipped_date] datetime,
+				[ship_via] int NOT NULL,
+				[freight] float NOT NULL,
+				[ship_name] text NOT NULL,
+				[ship_city] text NOT NULL,
+				[ship_region] text,
+				[ship_postal_code] text,
+				[ship_country] text NOT NULL,
+				[customer_id] varchar(256) NOT NULL,
+				[employee_id] int NOT NULL,
+				CONSTRAINT [order_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [product] (
+				[id] int NOT NULL,
+				[name] text NOT NULL,
+				[quantity_per_unit] text NOT NULL,
+				[unit_price] float NOT NULL,
+				[units_in_stock] int NOT NULL,
+				[units_on_order] int NOT NULL,
+				[reorder_level] int NOT NULL,
+				[discontinued] int NOT NULL,
+				[supplier_id] int NOT NULL,
+				CONSTRAINT [product_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+				CREATE TABLE [supplier] (
+				[id] int NOT NULL,
+				[company_name] text NOT NULL,
+				[contact_name] text NOT NULL,
+				[contact_title] text NOT NULL,
+				[address] text NOT NULL,
+				[city] text NOT NULL,
+				[region] text,
+				[postal_code] text NOT NULL,
+				[country] text NOT NULL,
+				[phone] text NOT NULL,
+				CONSTRAINT [supplier_id] PRIMARY KEY([id])
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+const checkSoftRelations = (
+	customers: (typeof schema.customers.$inferSelect)[],
+	details: (typeof schema.details.$inferSelect)[],
+	employees: (typeof schema.employees.$inferSelect)[],
+	orders: (typeof schema.orders.$inferSelect)[],
+	products: (typeof schema.products.$inferSelect)[],
+	suppliers: (typeof schema.suppliers.$inferSelect)[],
+) => {
+	// employees soft relations check
+	const employeeIds = new Set(employees.map((employee) => employee.id));
+	const employeesPredicate = employees.every((employee) =>
+		employee.reportsTo !== null && employeeIds.has(employee.reportsTo)
+	);
+	expect(employeesPredicate).toBe(true);
+
+	// orders soft relations check
+	const customerIds = new Set(customers.map((customer) => customer.id));
+	const ordersPredicate1 = orders.every((order) => order.customerId !== null && customerIds.has(order.customerId));
+	expect(ordersPredicate1).toBe(true);
+
+	const ordersPredicate2 = orders.every((order) => order.employeeId !== null && employeeIds.has(order.employeeId));
+	expect(ordersPredicate2).toBe(true);
+
+	// product soft relations check
+	const supplierIds = new Set(suppliers.map((supplier) => supplier.id));
+	const productsPredicate = products.every((product) =>
+		product.supplierId !== null && supplierIds.has(product.supplierId)
+	);
+	expect(productsPredicate).toBe(true);
+
+	// details soft relations check
+	const orderIds = new Set(orders.map((order) => order.id));
+	const detailsPredicate1 = details.every((detail) => detail.orderId !== null && orderIds.has(detail.orderId));
+	expect(detailsPredicate1).toBe(true);
+
+	const productIds = new Set(products.map((product) => product.id));
+	const detailsPredicate2 = details.every((detail) => detail.productId !== null && productIds.has(detail.productId));
+	expect(detailsPredicate2).toBe(true);
+};
+
+test('basic seed, soft relations test', async ({ db }) => {
+	await seed(db, schema);
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(10);
+	expect(details.length).toBe(10);
+	expect(employees.length).toBe(10);
+	expect(orders.length).toBe(10);
+	expect(products.length).toBe(10);
+	expect(suppliers.length).toBe(10);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("redefine(refine) orders count using 'with' in customers, soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 13,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("sequential using of 'with', soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 12,
+			with: {
+				details: 3,
+			},
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(24);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
diff --git a/drizzle-seed/tests/mssql/utils.ts b/drizzle-seed/tests/mssql/utils.ts
new file mode 100644
index 0000000000..1f0fb5be35
--- /dev/null
+++ b/drizzle-seed/tests/mssql/utils.ts
@@ -0,0 +1,16 @@
+import type { config } from 'mssql';
+
+export const parseMssqlUrl = (urlString: string): config => {
+	const url = new URL(urlString);
+	return {
+		user: url.username,
+		password: url.password,
+		server: url.hostname,
+		port: Number.parseInt(url.port, 10),
+		database: url.pathname.replace(/^\//, ''),
+		options: {
+			encrypt: url.searchParams.get('encrypt') === 'true',
+			trustServerCertificate: url.searchParams.get('trustServerCertificate') === 'true',
+		},
+	};
+};
diff --git a/drizzle-seed/tests/mysql/allDataTypesTest/mysql_all_data_types.test.ts b/drizzle-seed/tests/mysql/allDataTypesTest/mysql_all_data_types.test.ts
index f39a55fef1..a01793fa47 100644
--- a/drizzle-seed/tests/mysql/allDataTypesTest/mysql_all_data_types.test.ts
+++ b/drizzle-seed/tests/mysql/allDataTypesTest/mysql_all_data_types.test.ts
@@ -1,76 +1,20 @@
-import Docker from 'dockerode';
 import { sql } from 'drizzle-orm';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import type { Connection } from 'mysql2/promise';
-import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
+import { expect } from 'vitest';
 import { seed } from '../../../src/index.ts';
+import { mysqlTest as test } from '../instrumentation.ts';
 import * as schema from './mysqlSchema.ts';
 
-let mysqlContainer: Docker.Container;
-let client: Connection | undefined;
-let db: MySql2Database;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 40000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			const client = await createConnection(connectionString);
-			await client.connect();
-			db = drizzle(client);
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`all_data_types\` (
 				\`integer\` int,
 				\`tinyint\` tinyint,
@@ -101,15 +45,15 @@ beforeAll(async () => {
 				\`popularity\` enum('unknown','known','popular')
 			);
 		`,
-	);
-});
+		);
+
+		resolveFunc('');
+	}
 
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
+	await promise;
 });
 
-test('basic seed test', async () => {
+test('basic seed test', async ({ db }) => {
 	await seed(db, schema, { count: 10000 });
 
 	const allDataTypes = await db.select().from(schema.allDataTypes);
diff --git a/drizzle-seed/tests/mysql/compositeUniqueKey/mysql.test.ts b/drizzle-seed/tests/mysql/compositeUniqueKey/mysql.test.ts
new file mode 100644
index 0000000000..2d815c56e8
--- /dev/null
+++ b/drizzle-seed/tests/mysql/compositeUniqueKey/mysql.test.ts
@@ -0,0 +1,190 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mysqlTest as test } from '../instrumentation.ts';
+import * as schema from './mysqlSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS composite_example (
+			    id integer not null,
+			    name varchar(8) not null,
+			    CONSTRAINT composite_example_id_name_unique UNIQUE(id,name),
+			    CONSTRAINT custom_name UNIQUE(id,name)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS unique_column_in_composite_of_two_0 (
+			    id integer not null unique,
+			    name varchar(8) not null,
+			    CONSTRAINT custom_name0 UNIQUE(id,name)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS unique_column_in_composite_of_two_1 (
+			    id integer not null,
+			    name varchar(8) not null,
+			    CONSTRAINT custom_name1 UNIQUE(id,name),
+				CONSTRAINT custom_name1_id UNIQUE(id)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS unique_column_in_composite_of_three_0 (
+			    id integer not null unique,
+			    name varchar(8) not null,
+				slug varchar(8) not null,
+			    CONSTRAINT custom_name2 UNIQUE(id,name,slug)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS unique_column_in_composite_of_three_1 (
+			    id integer not null,
+			    name varchar(8) not null,
+				slug varchar(8) not null,
+			    CONSTRAINT custom_name3 UNIQUE(id,name,slug),
+				CONSTRAINT custom_name3_id UNIQUE(id)
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	const currSchema = { composite: schema.composite };
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
diff --git a/drizzle-seed/tests/mysql/compositeUniqueKey/mysqlSchema.ts b/drizzle-seed/tests/mysql/compositeUniqueKey/mysqlSchema.ts
new file mode 100644
index 0000000000..18affec4cc
--- /dev/null
+++ b/drizzle-seed/tests/mysql/compositeUniqueKey/mysqlSchema.ts
@@ -0,0 +1,40 @@
+import { int, mysqlTable, unique, varchar } from 'drizzle-orm/mysql-core';
+
+export const composite = mysqlTable('composite_example', {
+	id: int().notNull(),
+	name: varchar({ length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = mysqlTable('unique_column_in_composite_of_two_0', {
+	id: int().notNull().unique(),
+	name: varchar({ length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = mysqlTable('unique_column_in_composite_of_two_1', {
+	id: int().notNull(),
+	name: varchar({ length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = mysqlTable('unique_column_in_composite_of_three_0', {
+	id: int().notNull().unique(),
+	name: varchar({ length: 8 }).notNull(),
+	slug: varchar({ length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = mysqlTable('unique_column_in_composite_of_three_1', {
+	id: int().notNull(),
+	name: varchar({ length: 8 }).notNull(),
+	slug: varchar({ length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/mysql/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/mysql/cyclicTables/cyclicTables.test.ts
index 08fb7a0fe9..7483fa5205 100644
--- a/drizzle-seed/tests/mysql/cyclicTables/cyclicTables.test.ts
+++ b/drizzle-seed/tests/mysql/cyclicTables/cyclicTables.test.ts
@@ -1,76 +1,20 @@
-import Docker from 'dockerode';
 import { sql } from 'drizzle-orm';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import type { Connection } from 'mysql2/promise';
-import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
+import { expect } from 'vitest';
 import { reset, seed } from '../../../src/index.ts';
+import { mysqlTest as test } from '../instrumentation.ts';
 import * as schema from './mysqlSchema.ts';
 
-let mysqlContainer: Docker.Container;
-let client: Connection;
-let db: MySql2Database;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 40000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			db = drizzle(client);
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			create table model
 			(
 			    id             int          not null
@@ -79,10 +23,10 @@ beforeAll(async () => {
 			    defaultImageId int          null
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			create table model_image
 			(
 			    id      int          not null
@@ -94,19 +38,19 @@ beforeAll(async () => {
 			        foreign key (modelId) references model (id)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			alter table model
 			 add constraint model_defaultImageId_model_image_id_fk
 			     foreign key (defaultImageId) references model_image (id);
 		`,
-	);
+		);
 
-	// 3 tables case
-	await db.execute(
-		sql`
+		// 3 tables case
+		await db.execute(
+			sql`
 			create table model1
 			(
 			    id             int          not null
@@ -116,10 +60,10 @@ beforeAll(async () => {
 			    defaultImageId int          null
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			create table model_image1
 			(
 			    id      int          not null
@@ -131,10 +75,10 @@ beforeAll(async () => {
 			        foreign key (modelId) references model1 (id)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			create table user
 			(
 			    id        int  not null
@@ -148,27 +92,27 @@ beforeAll(async () => {
 			        foreign key (invitedBy) references user (id)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			alter table model1
 			 add constraint model1_userId_user_id_fk
 			     foreign key (userId) references user (id);
 		`,
-	);
-});
+		);
+
+		resolveFunc('');
+	}
 
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
+	await promise;
 });
 
-afterEach(async () => {
+test.afterEach(async ({ db }) => {
 	await reset(db, schema);
 });
 
-test('2 cyclic tables test', async () => {
+test('2 cyclic tables test', async ({ db }) => {
 	await seed(db, {
 		modelTable: schema.modelTable,
 		modelImageTable: schema.modelImageTable,
@@ -186,7 +130,7 @@ test('2 cyclic tables test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('3 cyclic tables test', async () => {
+test('3 cyclic tables test', async ({ db }) => {
 	await seed(db, {
 		modelTable1: schema.modelTable1,
 		modelImageTable1: schema.modelImageTable1,
diff --git a/drizzle-seed/tests/mysql/cyclicTables/mysqlSchema.ts b/drizzle-seed/tests/mysql/cyclicTables/mysqlSchema.ts
index ff8149a814..b1569690ee 100644
--- a/drizzle-seed/tests/mysql/cyclicTables/mysqlSchema.ts
+++ b/drizzle-seed/tests/mysql/cyclicTables/mysqlSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { AnyMySqlColumn } from 'drizzle-orm/mysql-core';
 import { int, mysqlTable, serial, text, varchar } from 'drizzle-orm/mysql-core';
 
diff --git a/drizzle-seed/tests/mysql/generatorsTest/generators.test.ts b/drizzle-seed/tests/mysql/generatorsTest/generators.test.ts
index 2bef885daf..45c68b4ff3 100644
--- a/drizzle-seed/tests/mysql/generatorsTest/generators.test.ts
+++ b/drizzle-seed/tests/mysql/generatorsTest/generators.test.ts
@@ -1,99 +1,42 @@
-import Docker from 'dockerode';
 import { sql } from 'drizzle-orm';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import type { Connection } from 'mysql2/promise';
-import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, expect, test } from 'vitest';
-import { seed } from '../../../src/index.ts';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { mysqlTest as test } from '../instrumentation.ts';
 import * as schema from './mysqlSchema.ts';
 
-let mysqlContainer: Docker.Container;
-let client: Connection;
-let db: MySql2Database;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 40000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			db = drizzle(client);
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`datetime_table\` (
 				\`datetime\` datetime
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`year_table\` (
 				\`year\` year
 			);
 		`,
-	);
-});
+		);
+
+		resolveFunc('');
+	}
 
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
+	await promise;
 });
 
 const count = 10000;
-
-test('datetime generator test', async () => {
+test('datetime generator test', async ({ db }) => {
 	await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
 		datetimeTable: {
 			count,
@@ -103,14 +46,85 @@ test('datetime generator test', async () => {
 		},
 	}));
 
-	const data = await db.select().from(schema.datetimeTable);
+	let data = await db.select().from(schema.datetimeTable);
 	// every value in each row does not equal undefined.
-	const predicate = data.length !== 0
+	let predicate = data.length !== 0
 		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
 	expect(predicate).toBe(true);
+
+	const min = '2025-03-07 13:12:13Z';
+	const max = '2025-03-09 15:12:13Z';
+	await reset(db, { datetimeTable: schema.datetimeTable });
+	await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
+		datetimeTable: {
+			count,
+			columns: {
+				datetime: funcs.datetime({
+					min,
+					max,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.datetimeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) =>
+				val !== null && val >= new Date(min)
+				&& val <= new Date(max)
+			)
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { datetimeTable: schema.datetimeTable });
+	await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
+		datetimeTable: {
+			count,
+			columns: {
+				datetime: funcs.datetime({
+					min,
+					max: min,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.datetimeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(min).getTime())
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { datetimeTable: schema.datetimeTable });
+	await seed(db, { datetimeTable: schema.datetimeTable }).refine((funcs) => ({
+		datetimeTable: {
+			count,
+			columns: {
+				datetime: funcs.datetime({
+					min: new Date(min),
+					max: new Date(min),
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.datetimeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(min).getTime())
+		);
+
+	expect(predicate).toBe(true);
 });
 
-test('year generator test', async () => {
+test('year generator test', async ({ db }) => {
 	await seed(db, { yearTable: schema.yearTable }).refine((funcs) => ({
 		yearTable: {
 			count,
diff --git a/drizzle-seed/tests/mysql/instrumentation.ts b/drizzle-seed/tests/mysql/instrumentation.ts
new file mode 100644
index 0000000000..7244058eb7
--- /dev/null
+++ b/drizzle-seed/tests/mysql/instrumentation.ts
@@ -0,0 +1,84 @@
+import type { MySqlAsyncDatabase } from 'drizzle-orm/mysql-core';
+import type { AnyMySql2Connection } from 'drizzle-orm/mysql2';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { createConnection } from 'mysql2/promise';
+import { test as base } from 'vitest';
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/mysql/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+const prepareTest = () => {
+	return base.extend<
+		{
+			client: {
+				client: AnyMySql2Connection;
+				query: (sql: string, params: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<void>;
+			};
+			db: MySqlAsyncDatabase<any, any>;
+			push: (schema: any) => Promise<void>;
+		}
+	>({
+		client: [
+			// oxlint-disable-next-line
+			async ({}, use) => {
+				const envurl = process.env['MYSQL_CONNECTION_STRING'];
+				if (!envurl) throw new Error('No mysql url provided');
+				const client = await createConnection({
+					uri: envurl,
+					supportBigNumbers: true,
+					multipleStatements: true,
+				});
+				await client.connect();
+				await client.query('drop database if exists drizzle; create database drizzle; use drizzle;');
+
+				const query = async (sql: string, params: any[] = []) => {
+					const res = await client.query(sql, params);
+					return res[0] as any[];
+				};
+				const batch = async (statements: string[]) => {
+					return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+				};
+
+				await use({ client, query, batch });
+				await client.end();
+				client.destroy();
+			},
+			{ scope: 'worker' },
+		],
+		db: [
+			async ({ client }, use) => {
+				const db = drizzle({ client: client.client as AnyMySql2Connection });
+				await use(db as any);
+			},
+			{ scope: 'worker' },
+		],
+		push: [
+			async ({ client }, use) => {
+				const { query } = client;
+				const push = (
+					schema: any,
+				) => _push(query, schema);
+
+				await use(push);
+			},
+			{ scope: 'worker' },
+		],
+	});
+};
+
+export const mysqlTest = prepareTest();
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/drizzle-seed/tests/mysql/mysql.test.ts b/drizzle-seed/tests/mysql/mysql.test.ts
index 4d25171ea2..eac341b410 100644
--- a/drizzle-seed/tests/mysql/mysql.test.ts
+++ b/drizzle-seed/tests/mysql/mysql.test.ts
@@ -1,76 +1,21 @@
-import Docker from 'dockerode';
-import { relations, sql } from 'drizzle-orm';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import type { Connection } from 'mysql2/promise';
-import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, afterEach, beforeAll, expect, test, vi } from 'vitest';
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
+import { expect, vi } from 'vitest';
 import { reset, seed } from '../../src/index.ts';
+import { mysqlTest as test } from './instrumentation.ts';
 import * as schema from './mysqlSchema.ts';
 
-let mysqlContainer: Docker.Container;
-let client: Connection;
-let db: MySql2Database;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 40000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			db = drizzle(client);
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`customer\` (
 				\`id\` varchar(256) NOT NULL,
 				\`company_name\` text NOT NULL,
@@ -86,10 +31,10 @@ beforeAll(async () => {
 				CONSTRAINT \`customer_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`order_detail\` (
 				\`unit_price\` float NOT NULL,
 				\`quantity\` int NOT NULL,
@@ -98,10 +43,10 @@ beforeAll(async () => {
 				\`product_id\` int NOT NULL
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`employee\` (
 				\`id\` int NOT NULL,
 				\`last_name\` text NOT NULL,
@@ -122,10 +67,10 @@ beforeAll(async () => {
 				CONSTRAINT \`employee_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`order\` (
 				\`id\` int NOT NULL,
 				\`order_date\` timestamp NOT NULL,
@@ -143,10 +88,10 @@ beforeAll(async () => {
 				CONSTRAINT \`order_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`product\` (
 				\`id\` int NOT NULL,
 				\`name\` text NOT NULL,
@@ -160,10 +105,10 @@ beforeAll(async () => {
 				CONSTRAINT \`product_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`supplier\` (
 				\`id\` int NOT NULL,
 				\`company_name\` text NOT NULL,
@@ -178,10 +123,10 @@ beforeAll(async () => {
 				CONSTRAINT \`supplier_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`users\` (
 				\`id\` int,
 				\`name\` text,
@@ -189,10 +134,10 @@ beforeAll(async () => {
 				CONSTRAINT \`users_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`posts\` (
 				\`id\` int,
 				\`name\` text,
@@ -201,67 +146,67 @@ beforeAll(async () => {
 				CONSTRAINT \`posts_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`order_detail\` ADD CONSTRAINT \`order_detail_order_id_order_id_fk\` FOREIGN KEY (\`order_id\`) REFERENCES \`order\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`order_detail\` ADD CONSTRAINT \`order_detail_product_id_product_id_fk\` FOREIGN KEY (\`product_id\`) REFERENCES \`product\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`employee\` ADD CONSTRAINT \`employee_reports_to_employee_id_fk\` FOREIGN KEY (\`reports_to\`) REFERENCES \`employee\`(\`id\`) ON DELETE no action ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`order\` ADD CONSTRAINT \`order_customer_id_customer_id_fk\` FOREIGN KEY (\`customer_id\`) REFERENCES \`customer\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`order\` ADD CONSTRAINT \`order_employee_id_employee_id_fk\` FOREIGN KEY (\`employee_id\`) REFERENCES \`employee\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`product\` ADD CONSTRAINT \`product_supplier_id_supplier_id_fk\` FOREIGN KEY (\`supplier_id\`) REFERENCES \`supplier\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`users\` ADD CONSTRAINT \`users_invitedBy_users_id_fk\` FOREIGN KEY (\`invitedBy\`) REFERENCES \`users\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			ALTER TABLE \`posts\` ADD CONSTRAINT \`posts_userId_users_id_fk\` FOREIGN KEY (\`userId\`) REFERENCES \`users\`(\`id\`) ON DELETE cascade ON UPDATE no action;
 		`,
-	);
-});
+		);
+
+		resolveFunc('');
+	}
 
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
+	await promise;
 });
 
-afterEach(async () => {
+test.afterEach(async ({ db }) => {
 	await reset(db, schema);
 });
 
-test('basic seed test', async () => {
+test('basic seed test', async ({ db }) => {
 	await seed(db, schema);
 
 	const customers = await db.select().from(schema.customers);
@@ -279,7 +224,7 @@ test('basic seed test', async () => {
 	expect(suppliers.length).toBe(10);
 });
 
-test('seed with options.count:11 test', async () => {
+test('seed with options.count:11 test', async ({ db }) => {
 	await seed(db, schema, { count: 11 });
 
 	const customers = await db.select().from(schema.customers);
@@ -297,7 +242,7 @@ test('seed with options.count:11 test', async () => {
 	expect(suppliers.length).toBe(11);
 });
 
-test('redefine(refine) customers count', async () => {
+test('redefine(refine) customers count', async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 12,
@@ -319,7 +264,7 @@ test('redefine(refine) customers count', async () => {
 	expect(suppliers.length).toBe(11);
 });
 
-test('redefine(refine) all tables count', async () => {
+test('redefine(refine) all tables count', async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 12,
@@ -356,7 +301,7 @@ test('redefine(refine) all tables count', async () => {
 	expect(suppliers.length).toBe(17);
 });
 
-test("redefine(refine) orders count using 'with' in customers", async () => {
+test("redefine(refine) orders count using 'with' in customers", async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 4,
@@ -384,7 +329,7 @@ test("redefine(refine) orders count using 'with' in customers", async () => {
 	expect(suppliers.length).toBe(11);
 });
 
-test("sequential using of 'with'", async () => {
+test("sequential using of 'with'", async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 4,
@@ -415,7 +360,7 @@ test("sequential using of 'with'", async () => {
 	expect(suppliers.length).toBe(11);
 });
 
-test('overlapping a foreign key constraint with a one-to-many relation', async () => {
+test('overlapping a foreign key constraint with a one-to-many relation', async ({ db }) => {
 	const postsRelation = relations(schema.posts, ({ one }) => ({
 		user: one(schema.users, { fields: [schema.posts.userId], references: [schema.users.id] }),
 	}));
diff --git a/drizzle-seed/tests/mysql/softRelationsTest/mysqlSchema.ts b/drizzle-seed/tests/mysql/softRelationsTest/mysqlSchema.ts
index 7f0fc17df9..b20cb8f8ea 100644
--- a/drizzle-seed/tests/mysql/softRelationsTest/mysqlSchema.ts
+++ b/drizzle-seed/tests/mysql/softRelationsTest/mysqlSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import { float, int, mysqlTable, text, timestamp, varchar } from 'drizzle-orm/mysql-core';
 
 export const customers = mysqlTable('customer', {
diff --git a/drizzle-seed/tests/mysql/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/mysql/softRelationsTest/softRelations.test.ts
index 7f61b80eb0..28a31a398e 100644
--- a/drizzle-seed/tests/mysql/softRelationsTest/softRelations.test.ts
+++ b/drizzle-seed/tests/mysql/softRelationsTest/softRelations.test.ts
@@ -1,76 +1,20 @@
-import Docker from 'dockerode';
 import { sql } from 'drizzle-orm';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import type { Connection } from 'mysql2/promise';
-import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
+import { expect } from 'vitest';
 import { reset, seed } from '../../../src/index.ts';
+import { mysqlTest as test } from '../instrumentation.ts';
 import * as schema from './mysqlSchema.ts';
 
-let mysqlContainer: Docker.Container;
-let client: Connection;
-let db: MySql2Database;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 40000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await createConnection(connectionString);
-			await client.connect();
-			db = drizzle(client);
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`customer\` (
 				\`id\` varchar(256) NOT NULL,
 				\`company_name\` text NOT NULL,
@@ -86,10 +30,10 @@ beforeAll(async () => {
 				CONSTRAINT \`customer_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`order_detail\` (
 				\`unit_price\` float NOT NULL,
 				\`quantity\` int NOT NULL,
@@ -98,10 +42,10 @@ beforeAll(async () => {
 				\`product_id\` int NOT NULL
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`employee\` (
 				\`id\` int NOT NULL,
 				\`last_name\` text NOT NULL,
@@ -122,10 +66,10 @@ beforeAll(async () => {
 				CONSTRAINT \`employee_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`order\` (
 				\`id\` int NOT NULL,
 				\`order_date\` timestamp NOT NULL,
@@ -143,10 +87,10 @@ beforeAll(async () => {
 				CONSTRAINT \`order_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`product\` (
 				\`id\` int NOT NULL,
 				\`name\` text NOT NULL,
@@ -160,10 +104,10 @@ beforeAll(async () => {
 				CONSTRAINT \`product_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
+		);
 
-	await db.execute(
-		sql`
+		await db.execute(
+			sql`
 			    CREATE TABLE \`supplier\` (
 				\`id\` int NOT NULL,
 				\`company_name\` text NOT NULL,
@@ -178,15 +122,15 @@ beforeAll(async () => {
 				CONSTRAINT \`supplier_id\` PRIMARY KEY(\`id\`)
 			);
 		`,
-	);
-});
+		);
+
+		resolveFunc('');
+	}
 
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
+	await promise;
 });
 
-afterEach(async () => {
+test.afterEach(async ({ db }) => {
 	await reset(db, schema);
 });
 
@@ -230,7 +174,7 @@ const checkSoftRelations = (
 	expect(detailsPredicate2).toBe(true);
 };
 
-test('basic seed, soft relations test', async () => {
+test('basic seed, soft relations test', async ({ db }) => {
 	await seed(db, schema);
 
 	const customers = await db.select().from(schema.customers);
@@ -250,7 +194,7 @@ test('basic seed, soft relations test', async () => {
 	checkSoftRelations(customers, details, employees, orders, products, suppliers);
 });
 
-test("redefine(refine) orders count using 'with' in customers, soft relations test", async () => {
+test("redefine(refine) orders count using 'with' in customers, soft relations test", async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 4,
@@ -280,7 +224,7 @@ test("redefine(refine) orders count using 'with' in customers, soft relations te
 	checkSoftRelations(customers, details, employees, orders, products, suppliers);
 });
 
-test("sequential using of 'with', soft relations test", async () => {
+test("sequential using of 'with', soft relations test", async ({ db }) => {
 	await seed(db, schema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 4,
diff --git a/drizzle-seed/tests/northwind/mysqlTest.ts b/drizzle-seed/tests/northwind/mysqlTest.ts
index 1cbdb77044..848ee8d6fd 100644
--- a/drizzle-seed/tests/northwind/mysqlTest.ts
+++ b/drizzle-seed/tests/northwind/mysqlTest.ts
@@ -20,7 +20,7 @@ const mysqlPool = mysql.createPool({
 	// ssl: { rejectUnauthorized: false }
 });
 
-const db = drizzle(mysqlPool);
+const db = drizzle({ client: mysqlPool });
 
 console.log('database connection was established successfully.');
 
diff --git a/drizzle-seed/tests/northwind/pgTest.ts b/drizzle-seed/tests/northwind/pgTest.ts
index 84c366b6c9..ac56dbb308 100644
--- a/drizzle-seed/tests/northwind/pgTest.ts
+++ b/drizzle-seed/tests/northwind/pgTest.ts
@@ -19,7 +19,7 @@ const pgPool = new PgPool({
 	// ssl: true
 });
 
-const db = drizzle(pgPool);
+const db = drizzle({ client: pgPool });
 
 console.log('database connection was established successfully.');
 
diff --git a/drizzle-seed/tests/northwind/sqliteSchema.ts b/drizzle-seed/tests/northwind/sqliteSchema.ts
index fa00dd3651..494893ea05 100644
--- a/drizzle-seed/tests/northwind/sqliteSchema.ts
+++ b/drizzle-seed/tests/northwind/sqliteSchema.ts
@@ -34,12 +34,10 @@ export const employees = sqliteTable(
 		reportsTo: integer('reports_to'),
 		photoPath: text('photo_path'),
 	},
-	(table) => ({
-		reportsToFk: foreignKey(() => ({
-			columns: [table.reportsTo],
-			foreignColumns: [table.id],
-		})),
-	}),
+	(table) => [foreignKey({
+		columns: [table.reportsTo],
+		foreignColumns: [table.id],
+	})],
 );
 
 export const orders = sqliteTable('order', {
diff --git a/drizzle-seed/tests/northwind/sqliteTest.ts b/drizzle-seed/tests/northwind/sqliteTest.ts
index 0267bc2887..096ab896f8 100644
--- a/drizzle-seed/tests/northwind/sqliteTest.ts
+++ b/drizzle-seed/tests/northwind/sqliteTest.ts
@@ -10,7 +10,7 @@ import * as schema from './sqliteSchema.ts';
 
 const { Sqlite_PATH } = process.env;
 const sqliteDb = betterSqlite3(Sqlite_PATH);
-const db = drizzle(sqliteDb);
+const db = drizzle({ client: sqliteDb });
 
 console.log('database connection was established successfully.');
 
diff --git a/drizzle-seed/tests/pg/allDataTypesTest/pgPostgisSchema.ts b/drizzle-seed/tests/pg/allDataTypesTest/pgPostgisSchema.ts
new file mode 100644
index 0000000000..a67d3ac575
--- /dev/null
+++ b/drizzle-seed/tests/pg/allDataTypesTest/pgPostgisSchema.ts
@@ -0,0 +1,9 @@
+import { geometry, pgTable } from 'drizzle-orm/pg-core';
+
+export const allDataTypes = pgTable('postgis_data_types', {
+	geometry: geometry('geometry', { type: 'point', mode: 'tuple', srid: 0 }),
+});
+
+export const allArrayDataTypes = pgTable('postgis_array_data_types', {
+	geometryArray: geometry('geometry_array', { type: 'point', mode: 'tuple', srid: 0 }).array(),
+});
diff --git a/drizzle-seed/tests/pg/allDataTypesTest/pgSchema.ts b/drizzle-seed/tests/pg/allDataTypesTest/pgSchema.ts
index 16a55baf4d..69a6eb68d5 100644
--- a/drizzle-seed/tests/pg/allDataTypesTest/pgSchema.ts
+++ b/drizzle-seed/tests/pg/allDataTypesTest/pgSchema.ts
@@ -1,11 +1,13 @@
 import {
 	bigint,
 	bigserial,
+	bit,
 	boolean,
 	char,
 	date,
 	decimal,
 	doublePrecision,
+	inet,
 	integer,
 	interval,
 	json,
@@ -13,7 +15,7 @@ import {
 	line,
 	numeric,
 	pgEnum,
-	pgSchema,
+	pgTable,
 	point,
 	real,
 	serial,
@@ -24,13 +26,12 @@ import {
 	timestamp,
 	uuid,
 	varchar,
+	vector,
 } from 'drizzle-orm/pg-core';
 
-export const schema = pgSchema('seeder_lib_pg');
-
 export const moodEnum = pgEnum('mood_enum', ['sad', 'ok', 'happy']);
 
-export const allDataTypes = schema.table('all_data_types', {
+export const allDataTypes = pgTable('all_data_types', {
 	integer: integer('integer'),
 	smallint: smallint('smallint'),
 	biginteger: bigint('bigint', { mode: 'bigint' }),
@@ -39,14 +40,15 @@ export const allDataTypes = schema.table('all_data_types', {
 	smallserial: smallserial('smallserial'),
 	bigserial: bigserial('bigserial', { mode: 'bigint' }),
 	bigserialNumber: bigserial('bigserial_number', { mode: 'number' }),
-	boolean: boolean('boolean'),
-	text: text('text'),
-	varchar: varchar('varchar', { length: 256 }),
-	char: char('char', { length: 256 }),
 	numeric: numeric('numeric'),
 	decimal: decimal('decimal'),
 	real: real('real'),
 	doublePrecision: doublePrecision('double_precision'),
+	boolean: boolean('boolean'),
+	text: text('text'),
+	char: char('char', { length: 256 }),
+	varchar: varchar('varchar', { length: 256 }),
+	bit: bit('bit', { dimensions: 11 }),
 	json: json('json'),
 	jsonb: jsonb('jsonb'),
 	time: time('time'),
@@ -61,21 +63,25 @@ export const allDataTypes = schema.table('all_data_types', {
 	lineTuple: line('line_tuple', { mode: 'tuple' }),
 	moodEnum: moodEnum('mood_enum'),
 	uuid: uuid('uuid'),
+	inet: inet('inet'),
+	// geometry: geometry('geometry', { type: 'point', mode: 'tuple', srid: 0 }),
+	vector: vector('vector', { dimensions: 3 }),
 });
 
-export const allArrayDataTypes = schema.table('all_array_data_types', {
+export const allArrayDataTypes = pgTable('all_array_data_types', {
 	integerArray: integer('integer_array').array(),
 	smallintArray: smallint('smallint_array').array(),
 	bigintegerArray: bigint('bigint_array', { mode: 'bigint' }).array(),
 	bigintNumberArray: bigint('bigint_number_array', { mode: 'number' }).array(),
-	booleanArray: boolean('boolean_array').array(),
-	textArray: text('text_array').array(),
-	varcharArray: varchar('varchar_array', { length: 256 }).array(),
-	charArray: char('char_array', { length: 256 }).array(),
 	numericArray: numeric('numeric_array').array(),
 	decimalArray: decimal('decimal_array').array(),
 	realArray: real('real_array').array(),
 	doublePrecisionArray: doublePrecision('double_precision_array').array(),
+	booleanArray: boolean('boolean_array').array(),
+	charArray: char('char_array', { length: 256 }).array(),
+	varcharArray: varchar('varchar_array', { length: 256 }).array(),
+	textArray: text('text_array').array(),
+	bitArray: bit('bit_array', { dimensions: 11 }).array(),
 	jsonArray: json('json_array').array(),
 	jsonbArray: jsonb('jsonb_array').array(),
 	timeArray: time('time_array').array(),
@@ -89,16 +95,19 @@ export const allArrayDataTypes = schema.table('all_array_data_types', {
 	lineArray: line('line_array', { mode: 'abc' }).array(),
 	lineTupleArray: line('line_tuple_array', { mode: 'tuple' }).array(),
 	moodEnumArray: moodEnum('mood_enum_array').array(),
+	uuidArray: uuid('uuid_array').array(),
+	inetArray: inet('inet_array').array(),
+	// geometryArray: geometry('geometry_array', { type: 'point', mode: 'tuple', srid: 0 }).array(1),
 });
 
-export const ndArrays = schema.table('nd_arrays', {
-	integer1DArray: integer('integer_1d_array').array(3),
-	integer2DArray: integer('integer_2d_array').array(3).array(4),
-	integer3DArray: integer('integer_3d_array').array(3).array(4).array(5),
-	integer4DArray: integer('integer_4d_array').array(3).array(4).array(5).array(6),
+export const ndArrays = pgTable('nd_arrays', {
+	integer1DArray: integer('integer_1d_array').array(),
+	integer2DArray: integer('integer_2d_array').array('[][]'),
+	integer3DArray: integer('integer_3d_array').array('[][][]'),
+	integer4DArray: integer('integer_4d_array').array('[][][][]'),
 });
 
-export const intervals = schema.table('intervals', {
+export const intervals = pgTable('intervals', {
 	intervalYear: interval({ fields: 'year' }),
 	intervalYearToMonth: interval({ fields: 'year to month' }),
 	intervalMonth: interval({ fields: 'month' }),
diff --git a/drizzle-seed/tests/pg/allDataTypesTest/pg_all_data_types.test.ts b/drizzle-seed/tests/pg/allDataTypesTest/pg_all_data_types.test.ts
index 62d0895c0e..b888d04607 100644
--- a/drizzle-seed/tests/pg/allDataTypesTest/pg_all_data_types.test.ts
+++ b/drizzle-seed/tests/pg/allDataTypesTest/pg_all_data_types.test.ts
@@ -1,4 +1,5 @@
 import { PGlite } from '@electric-sql/pglite';
+import { vector } from '@electric-sql/pglite/vector';
 import { sql } from 'drizzle-orm';
 import type { PgliteDatabase } from 'drizzle-orm/pglite';
 import { drizzle } from 'drizzle-orm/pglite';
@@ -10,16 +11,18 @@ let client: PGlite;
 let db: PgliteDatabase;
 
 beforeAll(async () => {
-	client = new PGlite();
+	client = new PGlite({
+		extensions: { vector },
+	});
 
-	db = drizzle(client);
+	await client.query(`CREATE EXTENSION vector;`);
 
-	await db.execute(sql`CREATE SCHEMA if not exists "seeder_lib_pg";`);
+	db = drizzle({ client });
 
 	await db.execute(
 		sql`
 			    DO $$ BEGIN
-			 CREATE TYPE "seeder_lib_pg"."mood_enum" AS ENUM('sad', 'ok', 'happy');
+			 CREATE TYPE "mood_enum" AS ENUM('sad', 'ok', 'happy');
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
 			END $$;
@@ -28,7 +31,7 @@ beforeAll(async () => {
 
 	await db.execute(
 		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."all_data_types" (
+			    CREATE TABLE IF NOT EXISTS "all_data_types" (
 				"integer" integer,
 				"smallint" smallint,
 				"bigint" bigint,
@@ -37,14 +40,15 @@ beforeAll(async () => {
 				"smallserial" smallserial,
 				"bigserial" bigserial,
 				"bigserial_number" bigserial,
-				"boolean" boolean,
-				"text" text,
-				"varchar" varchar(256),
-				"char" char(256),
 				"numeric" numeric,
 				"decimal" numeric,
 				"real" real,
 				"double_precision" double precision,
+				"boolean" boolean,
+				"char" char(256),
+				"varchar" varchar(256),
+				"text" text,
+				"bit" bit(11),
 				"json" json,
 				"jsonb" jsonb,
 				"time" time,
@@ -57,27 +61,30 @@ beforeAll(async () => {
 				"point_tuple" "point",
 				"line" "line",
 				"line_tuple" "line",
-				"mood_enum" "seeder_lib_pg"."mood_enum",
-				"uuid" "uuid"
+				"mood_enum" "mood_enum",
+				"uuid" "uuid",
+				"inet" inet,
+				"vector" vector(3)
 			);
 		`,
 	);
 
 	await db.execute(
 		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."all_array_data_types" (
+			    CREATE TABLE IF NOT EXISTS "all_array_data_types" (
 				"integer_array" integer[],
 				"smallint_array" smallint[],
 				"bigint_array" bigint[],
 				"bigint_number_array" bigint[],
-				"boolean_array" boolean[],
-				"text_array" text[],
-				"varchar_array" varchar(256)[],
-				"char_array" char(256)[],
 				"numeric_array" numeric[],
 				"decimal_array" numeric[],
 				"real_array" real[],
 				"double_precision_array" double precision[],
+				"boolean_array" boolean[],
+				"char_array" char(256)[],
+				"varchar_array" varchar(256)[],
+				"text_array" text[],
+				"bit_array" bit(11)[],
 				"json_array" json[],
 				"jsonb_array" jsonb[],
 				"time_array" time[],
@@ -90,14 +97,16 @@ beforeAll(async () => {
 				"point_tuple_array" "point"[],
 				"line_array" "line"[],
 				"line_tuple_array" "line"[],
-				"mood_enum_array" "seeder_lib_pg"."mood_enum"[]
+				"mood_enum_array" "mood_enum"[],
+				"uuid_array" uuid[],
+				"inet_array" inet[]
 			);
 		`,
 	);
 
 	await db.execute(
 		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."nd_arrays" (
+			    CREATE TABLE IF NOT EXISTS "nd_arrays" (
 				"integer_1d_array" integer[3],
 				"integer_2d_array" integer[3][4],
 				"integer_3d_array" integer[3][4][5],
@@ -108,7 +117,7 @@ beforeAll(async () => {
 
 	await db.execute(
 		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."intervals" (
+			    CREATE TABLE IF NOT EXISTS "intervals" (
 				"intervalYear" interval year,
 				"intervalYearToMonth" interval year to month,
 				"intervalMonth" interval month,
@@ -142,7 +151,7 @@ test('all data types test', async () => {
 });
 
 test('all array data types test', async () => {
-	await seed(db, { allArrayDataTypes: schema.allArrayDataTypes }, { count: 1000 });
+	await seed(db, { allArrayDataTypes: schema.allArrayDataTypes }, { count: 1 });
 
 	const allArrayDataTypes = await db.select().from(schema.allArrayDataTypes);
 	// every value in each rows does not equal undefined.
@@ -154,28 +163,17 @@ test('all array data types test', async () => {
 });
 
 test('nd arrays', async () => {
-	await seed(db, { ndArrays: schema.ndArrays }, { count: 1000 });
+	// Reduced from 1000 to 100 to avoid PGLite WASM memory limits
+	// when inserting large multi-dimensional arrays
+	await seed(db, { ndArrays: schema.ndArrays }, { count: 100 });
 
 	const ndArrays = await db.select().from(schema.ndArrays);
 	// every value in each rows does not equal undefined.
 	const predicate0 = ndArrays.every((row) =>
 		Object.values(row).every((val) => val !== undefined && val !== null && val.length !== 0)
 	);
-	let predicate1 = true, predicate2 = true, predicate3 = true, predicate4 = true;
-
-	for (const row of ndArrays) {
-		predicate1 = predicate1 && (row.integer1DArray?.length === 3);
-
-		predicate2 = predicate2 && (row.integer2DArray?.length === 4) && (row.integer2DArray[0]?.length === 3);
-
-		predicate3 = predicate3 && (row.integer3DArray?.length === 5) && (row.integer3DArray[0]?.length === 4)
-			&& (row.integer3DArray[0][0]?.length === 3);
-
-		predicate4 = predicate4 && (row.integer4DArray?.length === 6) && (row.integer4DArray[0]?.length === 5)
-			&& (row.integer4DArray[0][0]?.length === 4) && (row.integer4DArray[0][0][0]?.length === 3);
-	}
 
-	expect(predicate0 && predicate1 && predicate2 && predicate3 && predicate4).toBe(true);
+	expect(predicate0).toBe(true);
 });
 
 test('intervals test', async () => {
diff --git a/drizzle-seed/tests/pg/allDataTypesTest/postgis_data_types.test.ts b/drizzle-seed/tests/pg/allDataTypesTest/postgis_data_types.test.ts
new file mode 100644
index 0000000000..0454079410
--- /dev/null
+++ b/drizzle-seed/tests/pg/allDataTypesTest/postgis_data_types.test.ts
@@ -0,0 +1,47 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { seed } from '../../../src/index.ts';
+import { pgPostgisTest as test } from '../instrumentation.ts';
+import * as schema from './pgPostgisSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "postgis_data_types" (
+				"geometry" geometry(point, 0)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "postgis_array_data_types" (
+				"geometry_array" geometry(point, 0)[]
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+	await promise;
+});
+
+test('postgis data types test', async ({ db }) => {
+	await seed(db, { allDataTypes: schema.allDataTypes }, { count: 10000 });
+
+	const allDataTypes = await db.select().from(schema.allDataTypes);
+	// every value in each rows does not equal undefined.
+	const predicate = allDataTypes.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/pg/compositeUniqueKey/pg.test.ts b/drizzle-seed/tests/pg/compositeUniqueKey/pg.test.ts
new file mode 100644
index 0000000000..59350d6fa8
--- /dev/null
+++ b/drizzle-seed/tests/pg/compositeUniqueKey/pg.test.ts
@@ -0,0 +1,167 @@
+import { integer, pgTable, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { pgliteTest as test } from '../instrumentation.ts';
+import * as schema from './pgSchema.ts';
+
+test('basic seed test', async ({ db, push }) => {
+	const currSchema = { composite: schema.composite };
+	await push(currSchema);
+	await seed(db, currSchema, { count: 16 });
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async ({ db, push }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await push(currSchema0);
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await push(currSchema1);
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async ({ db, push }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await push(currSchema0);
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await push(currSchema1);
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4354
+test('composite unique includes a fk column', async ({ db, push }) => {
+	const user = pgTable('user', { id: text().primaryKey() });
+	const paints = pgTable('paints', { id: uuid().primaryKey() });
+
+	const inventory = pgTable(
+		'inventory',
+		{
+			id: uuid().primaryKey().defaultRandom(),
+			userId: text()
+				.notNull()
+				.references(() => user.id),
+			paintId: uuid()
+				.notNull()
+				.references(() => paints.id),
+			amount: integer().default(1),
+		},
+		(table) => [unique().on(table.userId, table.paintId)],
+	);
+
+	const schema = { user, paints, inventory };
+	await push(schema);
+	await seed(db, schema).refine((f) => ({
+		user: { count: 100 },
+		paints: { count: 10 },
+		inventory: {
+			columns: {
+				amount: f.int({ minValue: 1, maxValue: 100 }),
+			},
+			count: 1000,
+		},
+	}));
+
+	const composite = await db.select().from(inventory);
+
+	expect(composite.length).toBe(1000);
+});
+// TODO add test with composite foreign key
diff --git a/drizzle-seed/tests/pg/compositeUniqueKey/pgSchema.ts b/drizzle-seed/tests/pg/compositeUniqueKey/pgSchema.ts
new file mode 100644
index 0000000000..8e70ca4c6a
--- /dev/null
+++ b/drizzle-seed/tests/pg/compositeUniqueKey/pgSchema.ts
@@ -0,0 +1,40 @@
+import { integer, pgTable, text, unique, varchar } from 'drizzle-orm/pg-core';
+
+export const composite = pgTable('composite_example', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = pgTable('unique_column_in_composite_of_two_0', {
+	id: integer('id').notNull().unique(),
+	name: varchar('name', { length: 8 }).notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = pgTable('unique_column_in_composite_of_two_1', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = pgTable('unique_column_in_composite_of_three_0', {
+	id: integer('id').notNull().unique(),
+	name: text('name').notNull(),
+	slug: varchar('slug').notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = pgTable('unique_column_in_composite_of_three_1', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+	slug: varchar('slug').notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/pg/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/pg/cyclicTables/cyclicTables.test.ts
index c4be3509e8..eaf57f209e 100644
--- a/drizzle-seed/tests/pg/cyclicTables/cyclicTables.test.ts
+++ b/drizzle-seed/tests/pg/cyclicTables/cyclicTables.test.ts
@@ -12,7 +12,7 @@ let db: PgliteDatabase;
 beforeAll(async () => {
 	client = new PGlite();
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	await db.execute(
 		sql`
diff --git a/drizzle-seed/tests/pg/cyclicTables/pgSchema.ts b/drizzle-seed/tests/pg/cyclicTables/pgSchema.ts
index 7615470b02..33eac1fdbf 100644
--- a/drizzle-seed/tests/pg/cyclicTables/pgSchema.ts
+++ b/drizzle-seed/tests/pg/cyclicTables/pgSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { AnyPgColumn } from 'drizzle-orm/pg-core';
 import { foreignKey, integer, pgTable, serial, text, varchar } from 'drizzle-orm/pg-core';
 
diff --git a/drizzle-seed/tests/pg/generatorsTest/generators.test.ts b/drizzle-seed/tests/pg/generatorsTest/generators.test.ts
index 3de2ce99ec..db5d0893d8 100644
--- a/drizzle-seed/tests/pg/generatorsTest/generators.test.ts
+++ b/drizzle-seed/tests/pg/generatorsTest/generators.test.ts
@@ -1,645 +1,33 @@
-import { afterAll, beforeAll, expect, test } from 'vitest';
-
-import { PGlite } from '@electric-sql/pglite';
-import type { PgliteDatabase } from 'drizzle-orm/pglite';
-import { drizzle } from 'drizzle-orm/pglite';
+import { expect } from 'vitest';
+import { pgliteTest as test } from '../instrumentation.ts';
 
 import { reset, seed } from '../../../src/index.ts';
 import * as schema from './pgSchema.ts';
 
-import { sql } from 'drizzle-orm';
+import { pgTable, text } from 'drizzle-orm/pg-core';
 import cities from '../../../src/datasets/cityNames.ts';
 import countries from '../../../src/datasets/countries.ts';
 import firstNames from '../../../src/datasets/firstNames.ts';
 import lastNames from '../../../src/datasets/lastNames.ts';
 
-let client: PGlite;
-let db: PgliteDatabase;
-
-beforeAll(async () => {
-	client = new PGlite();
-
-	db = drizzle(client);
-
-	await db.execute(sql`CREATE SCHEMA "seeder_lib_pg";`);
-
-	await db.execute(
-		sql`
-			    DO $$ BEGIN
-			 CREATE TYPE "seeder_lib_pg"."enum" AS ENUM('sad', 'ok', 'happy');
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;  
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_table" (
-				"default_string" text
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_array_table" (
-				"default_string" text[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_table" (
-				"boolean" boolean
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_array_table" (
-				"boolean" boolean[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_table" (
-				"city" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_unique_table" (
-				"city_unique" varchar(256),
-				CONSTRAINT "city_unique_table_city_unique_unique" UNIQUE("city_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_array_table" (
-				"city" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_table" (
-				"company_name" text
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_unique_table" (
-				"company_name_unique" varchar(256),
-				CONSTRAINT "company_name_unique_table_company_name_unique_unique" UNIQUE("company_name_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_array_table" (
-				"company_name" text[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_table" (
-				"country" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_unique_table" (
-				"country_unique" varchar(256),
-				CONSTRAINT "country_unique_table_country_unique_unique" UNIQUE("country_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_array_table" (
-				"country" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_table" (
-				"date" date
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_array_table" (
-				"date" date[],
-				"date_string" date[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_table" (
-				"email" varchar(256),
-				CONSTRAINT "email_table_email_unique" UNIQUE("email")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_array_table" (
-				"email" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."enum_table" (
-				"mood_enum" "seeder_lib_pg"."enum"
-			);  
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_table" (
-				"first_name" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_unique_table" (
-				"first_name_unique" varchar(256),
-				CONSTRAINT "first_name_unique_table_first_name_unique_unique" UNIQUE("first_name_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_array_table" (
-				"first_name" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name__table" (
-				"full_name_" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_unique_table" (
-				"full_name_unique" varchar(256),
-				CONSTRAINT "full_name_unique_table_full_name_unique_unique" UNIQUE("full_name_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_array_table" (
-				"full_name" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_primary_key_table" (
-				"int_primary_key" integer,
-				CONSTRAINT "int_primary_key_table_int_primary_key_unique" UNIQUE("int_primary_key")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_table" (
-				"int" integer
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_unique_table" (
-				"int_unique" integer,
-				CONSTRAINT "int_unique_table_int_unique_unique" UNIQUE("int_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_array_table" (
-				"int" integer[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_table" (
-				"interval" interval
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_unique_table" (
-				"interval_unique" interval,
-				CONSTRAINT "interval_unique_table_interval_unique_unique" UNIQUE("interval_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_array_table" (
-				"interval" interval[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_Title_table" (
-				"job_title" text
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_title_array_table" (
-				"job_title" text[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_table" (
-				"json" json
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_array_table" (
-				"json" json[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_table" (
-				"last_name" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_unique_table" (
-				"last_name_unique" varchar(256),
-				CONSTRAINT "last_name_unique_table_last_name_unique_unique" UNIQUE("last_name_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_array_table" (
-				"last_name" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_table" (
-				"line" "line"
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_array_table" (
-				"line" "line"[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_table" (
-				"lorem_ipsum" text
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_array_table" (
-				"lorem_ipsum" text[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_table" (
-				"number" real
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_unique_table" (
-				"number_unique" real,
-				CONSTRAINT "number_unique_table_number_unique_unique" UNIQUE("number_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_array_table" (
-				"number" real[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."phone_number_table" (
-				"phoneNumber" varchar(256),
-				"phone_number_template" varchar(256),
-				"phone_number_prefixes" varchar(256),
-				CONSTRAINT "phone_number_table_phoneNumber_unique" UNIQUE("phoneNumber"),
-				CONSTRAINT "phone_number_table_phone_number_template_unique" UNIQUE("phone_number_template"),
-				CONSTRAINT "phone_number_table_phone_number_prefixes_unique" UNIQUE("phone_number_prefixes")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."phone_number_array_table" (
-				"phoneNumber" varchar(256)[],
-				"phone_number_template" varchar(256)[],
-				"phone_number_prefixes" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_table" (
-				"point" "point"
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_array_table" (
-				"point" "point"[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_table" (
-				"postcode" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_unique_table" (
-				"postcode_unique" varchar(256),
-				CONSTRAINT "postcode_unique_table_postcode_unique_unique" UNIQUE("postcode_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_array_table" (
-				"postcode" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_table" (
-				"state" text
-			);   
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_array_table" (
-				"state" text[]
-			);   
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_table" (
-				"street_address" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_unique_table" (
-				"street_address_unique" varchar(256),
-				CONSTRAINT "street_address_unique_table_street_address_unique_unique" UNIQUE("street_address_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_array_table" (
-				"street_address" varchar(256)[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_table" (
-				"string" text
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_unique_table" (
-				"string_unique" varchar(256),
-				CONSTRAINT "string_unique_table_string_unique_unique" UNIQUE("string_unique")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_array_table" (
-				"string" text[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_table" (
-				"time" time
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_array_table" (
-				"time" time[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_table" (
-				"timestamp" timestamp
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_array_table" (
-				"timestamp" timestamp[]
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_table" (
-				"values_from_array_not_null" varchar(256) NOT NULL,
-				"values_from_array_weighted_not_null" varchar(256) NOT NULL
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_unique_table" (
-				"values_from_array" varchar(256),
-				"values_from_array_not_null" varchar(256) NOT NULL,
-				"values_from_array_weighted" varchar(256),
-				"values_from_array_weighted_not_null" varchar(256) NOT NULL,
-				CONSTRAINT "values_from_array_unique_table_values_from_array_unique" UNIQUE("values_from_array"),
-				CONSTRAINT "values_from_array_unique_table_values_from_array_not_null_unique" UNIQUE("values_from_array_not_null"),
-				CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_unique" UNIQUE("values_from_array_weighted"),
-				CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_not_null_unique" UNIQUE("values_from_array_weighted_not_null")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_array_table" (
-				"values_from_array" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_table" (
-				"weighted_random" varchar(256)
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_with_unique_gens_table" (
-				"weighted_random_with_unique_gens" varchar(256),
-				CONSTRAINT "weighted_random_with_unique_gens_table_weighted_random_with_unique_gens_unique" UNIQUE("weighted_random_with_unique_gens")
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."uuid_table" (
-				"uuid" uuid
-			);    
-		`,
-	);
-
-	await db.execute(
-		sql`
-			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."uuid_array_table" (
-				"uuid" uuid[]
-			);    
-		`,
-	);
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
 });
 
-afterAll(async () => {
-	await client.close();
+test.beforeEach(async ({ push }) => {
+	if (firstTime) {
+		firstTime = false;
+		await push(schema);
+		resolveFunc('');
+	}
+	await promise;
 });
 
 const count = 1000;
 
-test('enum generator test', async () => {
+test('enum generator test', async ({ db }) => {
 	await seed(db, { enumTable: schema.enumTable }).refine(() => ({
 		enumTable: {
 			count,
@@ -653,7 +41,7 @@ test('enum generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('default generator test', async () => {
+test('default generator test', async ({ db }) => {
 	await seed(db, { defaultTable: schema.defaultTable }).refine((funcs) => ({
 		defaultTable: {
 			count,
@@ -670,7 +58,7 @@ test('default generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('default array generator test', async () => {
+test('default array generator test', async ({ db }) => {
 	await seed(db, { defaultTable: schema.defaultArrayTable }).refine((funcs) => ({
 		defaultTable: {
 			count,
@@ -687,7 +75,7 @@ test('default array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('valuesFromArray generator test', async () => {
+test('valuesFromArray generator test', async ({ db }) => {
 	await seed(db, { valuesFromArrayTable: schema.valuesFromArrayTable }).refine((funcs) => ({
 		valuesFromArrayTable: {
 			count,
@@ -710,7 +98,7 @@ test('valuesFromArray generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('valuesFromArray unique generator test', async () => {
+test('valuesFromArray unique generator test', async ({ db }) => {
 	// valuesFromArrayUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { valuesFromArrayUniqueTable: schema.valuesFromArrayUniqueTable }, { seed: 1 }).refine((funcs) => ({
 		valuesFromArrayUniqueTable: {
@@ -727,8 +115,8 @@ test('valuesFromArray unique generator test', async () => {
 				}),
 				valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
 					values: [
-						{ values: lastNames.slice(0, 14920), weight: 0.3 },
-						{ values: lastNames.slice(14920), weight: 0.7 },
+						{ values: lastNames.slice(0, 14894), weight: 0.3 },
+						{ values: lastNames.slice(14894), weight: 0.7 },
 					],
 					isUnique: true,
 				}),
@@ -799,7 +187,7 @@ test('valuesFromArray unique generator test', async () => {
 	).rejects.toThrow('There are no enough values to fill unique column.');
 });
 
-test('valuesFromArray array generator test', async () => {
+test('valuesFromArray array generator test', async ({ db }) => {
 	await seed(db, { valuesFromArrayTable: schema.valuesFromArrayArrayTable }).refine((funcs) => ({
 		valuesFromArrayTable: {
 			count,
@@ -816,7 +204,7 @@ test('valuesFromArray array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('intPrimaryKey generator test', async () => {
+test('intPrimaryKey generator test', async ({ db }) => {
 	await seed(db, { intPrimaryKeyTable: schema.intPrimaryKeyTable }).refine((funcs) => ({
 		intPrimaryKeyTable: {
 			count,
@@ -833,7 +221,7 @@ test('intPrimaryKey generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('number generator test', async () => {
+test('number generator test', async ({ db }) => {
 	await seed(db, { numberTable: schema.numberTable }).refine((funcs) => ({
 		numberTable: {
 			count,
@@ -850,7 +238,7 @@ test('number generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('number unique generator test', async () => {
+test('number unique generator test', async ({ db }) => {
 	// numberUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { numberUniqueTable: schema.numberUniqueTable }).refine((funcs) => ({
 		numberUniqueTable: {
@@ -880,7 +268,7 @@ test('number unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique integers in given range(min, max), try to make range wider.');
 });
 
-test('number array generator test', async () => {
+test('number array generator test', async ({ db }) => {
 	await seed(db, { numberTable: schema.numberArrayTable }).refine((funcs) => ({
 		numberTable: {
 			count,
@@ -897,7 +285,7 @@ test('number array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('int generator test', async () => {
+test('int generator test', async ({ db }) => {
 	await seed(db, { intTable: schema.intTable }).refine((funcs) => ({
 		intTable: {
 			count,
@@ -914,7 +302,7 @@ test('int generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('int unique generator test', async () => {
+test('int unique generator test', async ({ db }) => {
 	// intUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { intUniqueTable: schema.intUniqueTable }).refine((funcs) => ({
 		intUniqueTable: {
@@ -942,7 +330,7 @@ test('int unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique integers in given range(min, max), try to make range wider.');
 });
 
-test('int array generator test', async () => {
+test('int array generator test', async ({ db }) => {
 	await seed(db, { intTable: schema.intArrayTable }).refine((funcs) => ({
 		intTable: {
 			count,
@@ -959,7 +347,7 @@ test('int array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('boolean generator test', async () => {
+test('boolean generator test', async ({ db }) => {
 	await seed(db, { booleanTable: schema.booleanTable }).refine((funcs) => ({
 		booleanTable: {
 			count,
@@ -976,7 +364,7 @@ test('boolean generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('boolean array generator test', async () => {
+test('boolean array generator test', async ({ db }) => {
 	await seed(db, { booleanTable: schema.booleanArrayTable }).refine((funcs) => ({
 		booleanTable: {
 			count,
@@ -993,7 +381,7 @@ test('boolean array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('date generator test', async () => {
+test('date generator test', async ({ db }) => {
 	await seed(db, { dateTable: schema.dateTable }).refine((funcs) => ({
 		dateTable: {
 			count,
@@ -1003,14 +391,81 @@ test('date generator test', async () => {
 		},
 	}));
 
-	const data = await db.select().from(schema.dateTable);
+	let data = await db.select().from(schema.dateTable);
 	// every value in each row does not equal undefined.
-	const predicate = data.length !== 0
-		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	let predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== null));
+	expect(predicate).toBe(true);
+
+	// seed with parameters
+	const minDate = '2025-03-07';
+	const maxDate = '2025-03-09';
+	await reset(db, { dateTable: schema.dateTable });
+	await seed(db, { dateTable: schema.dateTable }).refine((funcs) => ({
+		dateTable: {
+			count,
+			columns: {
+				date: funcs.date({
+					minDate,
+					maxDate,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.dateTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val >= new Date(minDate) && val <= new Date(maxDate))
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { dateTable: schema.dateTable });
+	await seed(db, { dateTable: schema.dateTable }).refine((funcs) => ({
+		dateTable: {
+			count,
+			columns: {
+				date: funcs.date({
+					minDate,
+					maxDate: minDate,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.dateTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(minDate).getTime())
+		);
+	expect(predicate).toBe(true);
+
+	await reset(db, { dateTable: schema.dateTable });
+	await seed(db, { dateTable: schema.dateTable }).refine((funcs) => ({
+		dateTable: {
+			count,
+			columns: {
+				date: funcs.date({
+					minDate: new Date(minDate),
+					maxDate: new Date(minDate),
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.dateTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(minDate).getTime())
+		);
 	expect(predicate).toBe(true);
 });
 
-test('date array generator test', async () => {
+test('date array generator test', async ({ db }) => {
 	await seed(db, { dateTable: schema.dateArrayTable }).refine((funcs) => ({
 		dateTable: {
 			count,
@@ -1030,7 +485,7 @@ test('date array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('time generator test', async () => {
+test('time generator test', async ({ db }) => {
 	await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
 		timeTable: {
 			count,
@@ -1040,14 +495,90 @@ test('time generator test', async () => {
 		},
 	}));
 
-	const data = await db.select().from(schema.timeTable);
+	let data = await db.select().from(schema.timeTable);
 	// every value in each row does not equal undefined.
-	const predicate = data.length !== 0
+	let predicate = data.length !== 0
 		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
 	expect(predicate).toBe(true);
+
+	// seed with parameters
+	const min = '13:12:13';
+	const max = '15:12:13';
+	await reset(db, { timeTable: schema.timeTable });
+	await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
+		timeTable: {
+			count,
+			columns: {
+				time: funcs.time({
+					min,
+					max,
+				}),
+			},
+		},
+	}));
+
+	const anchorDate = new Date();
+	const getDateFromTime = (val: string) => new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}/, val));
+	data = await db.select().from(schema.timeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) =>
+				val !== null && getDateFromTime(val) >= getDateFromTime(min)
+				&& getDateFromTime(val) <= getDateFromTime(max)
+			)
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { timeTable: schema.timeTable });
+	await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
+		timeTable: {
+			count,
+			columns: {
+				time: funcs.time({
+					min,
+					max: min,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.timeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) =>
+				val !== null && getDateFromTime(val).getTime() === getDateFromTime(min).getTime()
+			)
+		);
+	expect(predicate).toBe(true);
+
+	await reset(db, { timeTable: schema.timeTable });
+	await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
+		timeTable: {
+			count,
+			columns: {
+				time: funcs.time({
+					min: getDateFromTime(min),
+					max: getDateFromTime(min),
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.timeTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) =>
+				val !== null && getDateFromTime(val).getTime() === getDateFromTime(min).getTime()
+			)
+		);
+	expect(predicate).toBe(true);
 });
 
-test('time array generator test', async () => {
+test('time array generator test', async ({ db }) => {
 	await seed(db, { timeTable: schema.timeArrayTable }).refine((funcs) => ({
 		timeTable: {
 			count,
@@ -1064,7 +595,7 @@ test('time array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('timestamp generator test', async () => {
+test('timestamp generator test', async ({ db }) => {
 	await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
 		timestampTable: {
 			count,
@@ -1074,14 +605,86 @@ test('timestamp generator test', async () => {
 		},
 	}));
 
-	const data = await db.select().from(schema.timestampTable);
+	let data = await db.select().from(schema.timestampTable);
 	// every value in each row does not equal undefined.
-	const predicate = data.length !== 0
+	let predicate = data.length !== 0
 		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
 	expect(predicate).toBe(true);
+
+	// seed with parameters
+	const min = '2025-03-07 13:12:13.123Z';
+	const max = '2025-03-09 15:12:13.456Z';
+	await reset(db, { timestampTable: schema.timestampTable });
+	await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
+		timestampTable: {
+			count,
+			columns: {
+				timestamp: funcs.timestamp({
+					min,
+					max,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.timestampTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) =>
+				val !== null && val >= new Date(min)
+				&& val <= new Date(max)
+			)
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { timestampTable: schema.timestampTable });
+	await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
+		timestampTable: {
+			count,
+			columns: {
+				timestamp: funcs.timestamp({
+					min,
+					max: min,
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.timestampTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(min).getTime())
+		);
+
+	expect(predicate).toBe(true);
+
+	await reset(db, { timestampTable: schema.timestampTable });
+	await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
+		timestampTable: {
+			count,
+			columns: {
+				timestamp: funcs.timestamp({
+					min: new Date(min),
+					max: new Date(min),
+				}),
+			},
+		},
+	}));
+
+	data = await db.select().from(schema.timestampTable);
+	// every value in each row does not equal undefined.
+	predicate = data.length !== 0
+		&& data.every((row) =>
+			Object.values(row).every((val) => val !== null && val.getTime() === new Date(min).getTime())
+		);
+
+	expect(predicate).toBe(true);
 });
 
-test('timestamp array generator test', async () => {
+test('timestamp array generator test', async ({ db }) => {
 	await seed(db, { timestampTable: schema.timestampArrayTable }).refine((funcs) => ({
 		timestampTable: {
 			count,
@@ -1098,7 +701,7 @@ test('timestamp array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('json generator test', async () => {
+test('json generator test', async ({ db }) => {
 	await seed(db, { jsonTable: schema.jsonTable }).refine((funcs) => ({
 		jsonTable: {
 			count,
@@ -1115,7 +718,7 @@ test('json generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('json array generator test', async () => {
+test('json array generator test', async ({ db }) => {
 	await seed(db, { jsonTable: schema.jsonArrayTable }).refine((funcs) => ({
 		jsonTable: {
 			count,
@@ -1132,7 +735,7 @@ test('json array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('interval generator test', async () => {
+test('interval generator test', async ({ db }) => {
 	await seed(db, { intervalTable: schema.intervalTable }).refine((funcs) => ({
 		intervalTable: {
 			count,
@@ -1149,7 +752,7 @@ test('interval generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('interval unique generator test', async () => {
+test('interval unique generator test', async ({ db }) => {
 	// intervalUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { intervalUniqueTable: schema.intervalUniqueTable }).refine((funcs) => ({
 		intervalUniqueTable: {
@@ -1166,7 +769,7 @@ test('interval unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('interval array generator test', async () => {
+test('interval array generator test', async ({ db }) => {
 	await seed(db, { intervalTable: schema.intervalArrayTable }).refine((funcs) => ({
 		intervalTable: {
 			count,
@@ -1183,7 +786,7 @@ test('interval array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('string generator test', async () => {
+test('string generator test', async ({ db }) => {
 	await seed(db, { stringTable: schema.stringTable }).refine((funcs) => ({
 		stringTable: {
 			count,
@@ -1200,7 +803,7 @@ test('string generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('string unique generator test', async () => {
+test('string unique generator test', async ({ db }) => {
 	await seed(db, { stringUniqueTable: schema.stringUniqueTable }).refine((funcs) => ({
 		stringUniqueTable: {
 			count,
@@ -1216,7 +819,7 @@ test('string unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('string array generator test', async () => {
+test('string array generator test', async ({ db }) => {
 	await seed(db, { stringTable: schema.stringArrayTable }).refine((funcs) => ({
 		stringTable: {
 			count,
@@ -1233,7 +836,7 @@ test('string array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('email generator test', async () => {
+test('email generator test', async ({ db }) => {
 	await seed(db, { emailTable: schema.emailTable }).refine((funcs) => ({
 		emailTable: {
 			count,
@@ -1250,7 +853,7 @@ test('email generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('email array generator test', async () => {
+test('email array generator test', async ({ db }) => {
 	await seed(db, { emailTable: schema.emailArrayTable }).refine((funcs) => ({
 		emailTable: {
 			count,
@@ -1267,7 +870,7 @@ test('email array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('firstName generator test', async () => {
+test('firstName generator test', async ({ db }) => {
 	await seed(db, { firstNameTable: schema.firstNameTable }).refine((funcs) => ({
 		firstNameTable: {
 			count,
@@ -1284,7 +887,7 @@ test('firstName generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('firstName unique generator test', async () => {
+test('firstName unique generator test', async ({ db }) => {
 	// firstNameUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { firstNameUniqueTable: schema.firstNameUniqueTable }).refine((funcs) => ({
 		firstNameUniqueTable: {
@@ -1312,7 +915,7 @@ test('firstName unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique first names.');
 });
 
-test('firstName array generator test', async () => {
+test('firstName array generator test', async ({ db }) => {
 	await seed(db, { firstNameTable: schema.firstNameArrayTable }).refine((funcs) => ({
 		firstNameTable: {
 			count,
@@ -1329,7 +932,7 @@ test('firstName array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('lastName generator test', async () => {
+test('lastName generator test', async ({ db }) => {
 	await seed(db, { lastNameTable: schema.lastNameTable }).refine((funcs) => ({
 		lastNameTable: {
 			count,
@@ -1346,7 +949,7 @@ test('lastName generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('lastName unique generator test', async () => {
+test('lastName unique generator test', async ({ db }) => {
 	// lastNameUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { lastNameUniqueTable: schema.lastNameUniqueTable }).refine((funcs) => ({
 		lastNameUniqueTable: {
@@ -1374,7 +977,7 @@ test('lastName unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique last names.');
 });
 
-test('lastName array generator test', async () => {
+test('lastName array generator test', async ({ db }) => {
 	await seed(db, { lastNameTable: schema.lastNameArrayTable }).refine((funcs) => ({
 		lastNameTable: {
 			count,
@@ -1391,7 +994,7 @@ test('lastName array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('fullName generator test', async () => {
+test('fullName generator test', async ({ db }) => {
 	await seed(db, { fullNameTable: schema.fullNameTable }).refine((funcs) => ({
 		fullNameTable: {
 			count,
@@ -1408,7 +1011,7 @@ test('fullName generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('fullName unique generator test', async () => {
+test('fullName unique generator test', async ({ db }) => {
 	// fullNameUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { fullNameUniqueTable: schema.fullNameUniqueTable }).refine((funcs) => ({
 		fullNameUniqueTable: {
@@ -1426,7 +1029,7 @@ test('fullName unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('fullName array generator test', async () => {
+test('fullName array generator test', async ({ db }) => {
 	await seed(db, { fullNameTable: schema.fullNameArrayTable }).refine((funcs) => ({
 		fullNameTable: {
 			count,
@@ -1443,7 +1046,7 @@ test('fullName array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('country generator test', async () => {
+test('country generator test', async ({ db }) => {
 	await seed(db, { countryTable: schema.countryTable }).refine((funcs) => ({
 		countryTable: {
 			count,
@@ -1460,7 +1063,7 @@ test('country generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('country unique generator test', async () => {
+test('country unique generator test', async ({ db }) => {
 	// countryUniqueTable-----------------------------------------------------------------------------------
 	await seed(db, { countryUniqueTable: schema.countryUniqueTable }).refine((funcs) => ({
 		countryUniqueTable: {
@@ -1488,7 +1091,7 @@ test('country unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique countries.');
 });
 
-test('country array generator test', async () => {
+test('country array generator test', async ({ db }) => {
 	await seed(db, { countryTable: schema.countryArrayTable }).refine((funcs) => ({
 		countryTable: {
 			count,
@@ -1505,7 +1108,7 @@ test('country array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('city generator test', async () => {
+test('city generator test', async ({ db }) => {
 	await seed(db, { cityTable: schema.cityTable }).refine((funcs) => ({
 		cityTable: {
 			count,
@@ -1522,7 +1125,7 @@ test('city generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('city unique generator test', async () => {
+test('city unique generator test', async ({ db }) => {
 	// cityUniqueTable-----------------------------------------------------------------------------------
 	await reset(db, { cityUniqueTable: schema.cityUniqueTable });
 	await seed(db, { cityUniqueTable: schema.cityUniqueTable }).refine((funcs) => ({
@@ -1551,7 +1154,7 @@ test('city unique generator test', async () => {
 	).rejects.toThrow('count exceeds max number of unique cities.');
 });
 
-test('city array generator test', async () => {
+test('city array generator test', async ({ db }) => {
 	await seed(db, { cityTable: schema.cityArrayTable }).refine((funcs) => ({
 		cityTable: {
 			count,
@@ -1568,7 +1171,7 @@ test('city array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('streetAddress generator test', async () => {
+test('streetAddress generator test', async ({ db }) => {
 	await seed(db, { streetAddressTable: schema.streetAddressTable }).refine((funcs) => ({
 		streetAddressTable: {
 			count,
@@ -1585,7 +1188,7 @@ test('streetAddress generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('streetAddress unique generator test', async () => {
+test('streetAddress unique generator test', async ({ db }) => {
 	await seed(db, { streetAddressUniqueTable: schema.streetAddressUniqueTable }).refine((funcs) => ({
 		streetAddressUniqueTable: {
 			count,
@@ -1602,7 +1205,7 @@ test('streetAddress unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('streetAddress array generator test', async () => {
+test('streetAddress array generator test', async ({ db }) => {
 	await seed(db, { streetAddressTable: schema.streetAddressArrayTable }).refine((funcs) => ({
 		streetAddressTable: {
 			count,
@@ -1619,7 +1222,7 @@ test('streetAddress array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('jobTitle generator test', async () => {
+test('jobTitle generator test', async ({ db }) => {
 	await seed(db, { jobTitleTable: schema.jobTitleTable }).refine((funcs) => ({
 		jobTitleTable: {
 			count,
@@ -1636,7 +1239,7 @@ test('jobTitle generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('jobTitle array generator test', async () => {
+test('jobTitle array generator test', async ({ db }) => {
 	await seed(db, { jobTitleTable: schema.jobTitleArrayTable }).refine((funcs) => ({
 		jobTitleTable: {
 			count,
@@ -1653,7 +1256,7 @@ test('jobTitle array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('postcode generator test', async () => {
+test('postcode generator test', async ({ db }) => {
 	await seed(db, { postcodeTable: schema.postcodeTable }).refine((funcs) => ({
 		postcodeTable: {
 			count,
@@ -1670,7 +1273,7 @@ test('postcode generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('postcode unique generator test', async () => {
+test('postcode unique generator test', async ({ db }) => {
 	await seed(db, { postcodeUniqueTable: schema.postcodeUniqueTable }).refine((funcs) => ({
 		postcodeUniqueTable: {
 			count,
@@ -1687,7 +1290,7 @@ test('postcode unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('postcode array generator test', async () => {
+test('postcode array generator test', async ({ db }) => {
 	await seed(db, { postcodeTable: schema.postcodeArrayTable }).refine((funcs) => ({
 		postcodeTable: {
 			count,
@@ -1704,7 +1307,7 @@ test('postcode array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('state generator test', async () => {
+test('state generator test', async ({ db }) => {
 	await seed(db, { stateTable: schema.stateTable }).refine((funcs) => ({
 		stateTable: {
 			count,
@@ -1721,7 +1324,7 @@ test('state generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('state array generator test', async () => {
+test('state array generator test', async ({ db }) => {
 	await seed(db, { stateTable: schema.stateArrayTable }).refine((funcs) => ({
 		stateTable: {
 			count,
@@ -1738,7 +1341,7 @@ test('state array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('companyName generator test', async () => {
+test('companyName generator test', async ({ db }) => {
 	await seed(db, { companyNameTable: schema.companyNameTable }).refine((funcs) => ({
 		companyNameTable: {
 			count,
@@ -1755,7 +1358,7 @@ test('companyName generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('companyName unique generator test', async () => {
+test('companyName unique generator test', async ({ db }) => {
 	await seed(db, { companyNameUniqueTable: schema.companyNameUniqueTable }).refine((funcs) => ({
 		companyNameUniqueTable: {
 			count,
@@ -1772,7 +1375,7 @@ test('companyName unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('companyName array generator test', async () => {
+test('companyName array generator test', async ({ db }) => {
 	await seed(db, { companyNameTable: schema.companyNameArrayTable }).refine((funcs) => ({
 		companyNameTable: {
 			count,
@@ -1789,7 +1392,7 @@ test('companyName array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('loremIpsum generator test', async () => {
+test('loremIpsum generator test', async ({ db }) => {
 	await seed(db, { loremIpsumTable: schema.loremIpsumTable }).refine((funcs) => ({
 		loremIpsumTable: {
 			count,
@@ -1806,7 +1409,7 @@ test('loremIpsum generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('loremIpsum array generator test', async () => {
+test('loremIpsum array generator test', async ({ db }) => {
 	await seed(db, { loremIpsumTable: schema.loremIpsumArrayTable }).refine((funcs) => ({
 		loremIpsumTable: {
 			count,
@@ -1823,7 +1426,7 @@ test('loremIpsum array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('point generator test', async () => {
+test('point generator test', async ({ db }) => {
 	await seed(db, { pointTable: schema.pointTable }).refine((funcs) => ({
 		pointTable: {
 			count,
@@ -1840,7 +1443,7 @@ test('point generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('point unique generator test', async () => {
+test('point unique generator test', async ({ db }) => {
 	await reset(db, { pointTable: schema.pointTable });
 	await seed(db, { pointTable: schema.pointTable }).refine((funcs) => ({
 		pointTable: {
@@ -1863,7 +1466,7 @@ test('point unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('point array generator test', async () => {
+test('point array generator test', async ({ db }) => {
 	await seed(db, { pointTable: schema.pointArrayTable }).refine((funcs) => ({
 		pointTable: {
 			count,
@@ -1880,7 +1483,7 @@ test('point array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('line generator test', async () => {
+test('line generator test', async ({ db }) => {
 	await seed(db, { lineTable: schema.lineTable }).refine((funcs) => ({
 		lineTable: {
 			count,
@@ -1897,7 +1500,7 @@ test('line generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('line unique generator test', async () => {
+test('line unique generator test', async ({ db }) => {
 	await reset(db, { lineTable: schema.lineTable });
 	await seed(db, { lineTable: schema.lineTable }).refine((funcs) => ({
 		lineTable: {
@@ -1920,7 +1523,7 @@ test('line unique generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('line array generator test', async () => {
+test('line array generator test', async ({ db }) => {
 	await seed(db, { lineTable: schema.lineArrayTable }).refine((funcs) => ({
 		lineTable: {
 			count,
@@ -1937,7 +1540,7 @@ test('line array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('phoneNumber generator test', async () => {
+test('phoneNumber generator test', async ({ db }) => {
 	await seed(db, { phoneNumberTable: schema.phoneNumberTable }).refine((funcs) => ({
 		phoneNumberTable: {
 			count,
@@ -1959,7 +1562,7 @@ test('phoneNumber generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('phoneNumber array generator test', async () => {
+test('phoneNumber array generator test', async ({ db }) => {
 	await seed(db, { phoneNumberTable: schema.phoneNumberArrayTable }).refine((funcs) => ({
 		phoneNumberTable: {
 			count,
@@ -1987,7 +1590,7 @@ test('phoneNumber array generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('weightedRandom generator test', async () => {
+test('weightedRandom generator test', async ({ db }) => {
 	await seed(db, { weightedRandomTable: schema.weightedRandomTable }).refine((funcs) => ({
 		weightedRandomTable: {
 			count,
@@ -2007,7 +1610,7 @@ test('weightedRandom generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('weightedRandom with unique gens generator test', async () => {
+test('weightedRandom with unique gens generator test', async ({ db }) => {
 	await seed(db, { weightedRandomWithUniqueGensTable: schema.weightedRandomWithUniqueGensTable }).refine((funcs) => ({
 		weightedRandomWithUniqueGensTable: {
 			count: 10000,
@@ -2056,7 +1659,70 @@ test('weightedRandom with unique gens generator test', async () => {
 	);
 });
 
-test('uuid generator test', async () => {
+test('weightedRandom with array generators', async ({ db, push }) => {
+	const schema = {
+		lead: pgTable('lead', {
+			branch: text(),
+			fields: text().array(),
+		}),
+	};
+
+	const alphaFields = Array.from({ length: 20 }, (val, idx) => `alpha_field_${idx}`);
+	const betaFields = Array.from({ length: 20 }, (val, idx) => `beta_field_${idx}`);
+	const gammaFields = Array.from({ length: 20 }, (val, idx) => `gamma_field_${idx}`);
+
+	await push(schema);
+	await reset(db, schema);
+	await seed(db, schema).refine((f) => ({
+		lead: {
+			columns: {
+				branch: f.weightedRandom([
+					{
+						weight: 0.4,
+						value: f.default({ defaultValue: 'branch_a' }),
+					},
+					{
+						weight: 0.4,
+						value: f.default({ defaultValue: 'branch_b' }),
+					},
+					{
+						weight: 0.1,
+						value: f.default({ defaultValue: 'branch_c' }),
+					},
+					{
+						weight: 0.1,
+						value: f.default({ defaultValue: undefined }),
+					},
+				]),
+				fields: f.weightedRandom([
+					{
+						weight: 0.4,
+						value: f.valuesFromArray({ values: alphaFields, arraySize: 20 }),
+					},
+					{
+						weight: 0.4,
+						value: f.valuesFromArray({ values: betaFields, arraySize: 20 }),
+					},
+					{
+						weight: 0.1,
+						value: f.valuesFromArray({ values: gammaFields, arraySize: 20 }),
+					},
+					{
+						weight: 0.1,
+						value: f.default({ defaultValue: undefined }),
+					},
+				]),
+			},
+			count: 40,
+		},
+	}));
+
+	const result = await db.select().from(schema.lead);
+
+	expect(result.length).toEqual(40);
+});
+
+test('uuid generator test', async ({ db }) => {
 	await reset(db, { uuidTable: schema.uuidTable });
 	await seed(db, { uuidTable: schema.uuidTable }).refine((funcs) => ({
 		uuidTable: {
@@ -2078,7 +1744,7 @@ test('uuid generator test', async () => {
 	expect(predicate).toBe(true);
 });
 
-test('uuid array generator test', async () => {
+test('uuid array generator test', async ({ db }) => {
 	await reset(db, { uuidArrayTable: schema.uuidArrayTable });
 	await seed(db, { uuidArrayTable: schema.uuidArrayTable }).refine((funcs) => ({
 		uuidArrayTable: {
@@ -2095,3 +1761,238 @@ test('uuid array generator test', async () => {
 		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
 	expect(predicate).toBe(true);
 });
+
+test('bitString generator test', async ({ db }) => {
+	await reset(db, { bitStringTable: schema.bitStringTable });
+	await seed(db, { bitStringTable: schema.bitStringTable }).refine((funcs) => ({
+		bitStringTable: {
+			count,
+			columns: {
+				bit: funcs.bitString({
+					dimensions: 12,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.bitStringTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('bitString unique generator test', async ({ db }) => {
+	await reset(db, { bitStringUniqueTable: schema.bitStringUniqueTable });
+	await seed(db, { bitStringUniqueTable: schema.bitStringUniqueTable }).refine((funcs) => ({
+		bitStringUniqueTable: {
+			count,
+			columns: {
+				bit: funcs.bitString({
+					isUnique: true,
+					dimensions: 12,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.bitStringUniqueTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('bitString array generator test', async ({ db }) => {
+	await reset(db, { bitStringArrayTable: schema.bitStringArrayTable });
+	await seed(db, { bitStringArrayTable: schema.bitStringArrayTable }).refine((funcs) => ({
+		bitStringArrayTable: {
+			count,
+			columns: {
+				bit: funcs.bitString({
+					arraySize: 4,
+					dimensions: 12,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.bitStringArrayTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('inet generator test', async ({ db }) => {
+	await reset(db, { inetTable: schema.inetTable });
+	await seed(db, { inetTable: schema.inetTable }).refine((funcs) => ({
+		inetTable: {
+			count,
+			columns: {
+				inet: funcs.inet({
+					ipAddress: 'ipv4',
+					includeCidr: true,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.inetTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('inet unique generator test', async ({ db }) => {
+	await reset(db, { inetUniqueTable: schema.inetUniqueTable });
+	await seed(db, { inetUniqueTable: schema.inetUniqueTable }).refine((funcs) => ({
+		inetUniqueTable: {
+			count,
+			columns: {
+				inet: funcs.inet({
+					isUnique: true,
+					ipAddress: 'ipv4',
+					includeCidr: true,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.inetUniqueTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('inet array generator test', async ({ db }) => {
+	await reset(db, { inetArrayTable: schema.inetArrayTable });
+	await seed(db, { inetArrayTable: schema.inetArrayTable }).refine((funcs) => ({
+		inetArrayTable: {
+			count,
+			columns: {
+				inet: funcs.inet({
+					arraySize: 4,
+					ipAddress: 'ipv4',
+					includeCidr: true,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.inetArrayTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('vector generator test', async ({ db }) => {
+	await reset(db, { vectorTable: schema.vectorTable });
+	await seed(db, { vectorTable: schema.vectorTable }).refine((funcs) => ({
+		vectorTable: {
+			count,
+			columns: {
+				vector: funcs.vector({
+					decimalPlaces: 5,
+					dimensions: 12,
+					minValue: -100,
+					maxValue: 100,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.vectorTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('vector unique generator test', async ({ db }) => {
+	await reset(db, { vectorUniqueTable: schema.vectorUniqueTable });
+	await seed(db, { vectorUniqueTable: schema.vectorUniqueTable }).refine((funcs) => ({
+		vectorUniqueTable: {
+			count,
+			columns: {
+				vector: funcs.vector({
+					isUnique: true,
+					decimalPlaces: 5,
+					dimensions: 12,
+					minValue: -100,
+					maxValue: 100,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.vectorUniqueTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('vector array generator test', async ({ db }) => {
+	await reset(db, { vectorArrayTable: schema.vectorArrayTable });
+	await seed(db, { vectorArrayTable: schema.vectorArrayTable }).refine((funcs) => ({
+		vectorArrayTable: {
+			count,
+			columns: {
+				vector: funcs.vector({
+					arraySize: 4,
+					decimalPlaces: 5,
+					dimensions: 12,
+					minValue: -100,
+					maxValue: 100,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.vectorArrayTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('composite unique key generator test', async ({ db }) => {
+	await reset(db, { compositeUniqueKeyTable: schema.compositeUniqueKeyTable });
+	await seed(db, { compositeUniqueKeyTable: schema.compositeUniqueKeyTable }, { count: 10000 }).refine((funcs) => ({
+		compositeUniqueKeyTable: {
+			columns: {
+				number: funcs.number(),
+				int: funcs.int(),
+				interval: funcs.interval(),
+				string: funcs.string(),
+				firstName: funcs.firstName(),
+				lastName: funcs.lastName(),
+				fullName: funcs.fullName(),
+				country: funcs.country(),
+				city: funcs.city(),
+				streetAddress: funcs.streetAddress(),
+				postcode: funcs.postcode(),
+				companyName: funcs.companyName(),
+				phoneNumber: funcs.phoneNumber(),
+				email: funcs.email(),
+				uuid: funcs.uuid(),
+				bit: funcs.bitString(),
+				inet: funcs.inet(),
+				vector: funcs.vector(),
+				valuesFromArray: funcs.valuesFromArray({ values: Array.from({ length: 20 }, (_, i) => String(i + 1)) }),
+				// point: funcs.point(),
+				// line: funcs.line(),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.compositeUniqueKeyTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/pg/generatorsTest/pgPostgisSchema.ts b/drizzle-seed/tests/pg/generatorsTest/pgPostgisSchema.ts
new file mode 100644
index 0000000000..b150c3f1de
--- /dev/null
+++ b/drizzle-seed/tests/pg/generatorsTest/pgPostgisSchema.ts
@@ -0,0 +1,24 @@
+import { geometry, integer, pgTable, unique } from 'drizzle-orm/pg-core';
+
+export const geometryTable = pgTable('geometry_table', {
+	geometryPointTuple: geometry('geometry_point_tuple', { type: 'point', mode: 'tuple', srid: 0 }),
+	geometryPointXy: geometry('geometry_point_xy', { type: 'point', mode: 'xy', srid: 0 }),
+});
+export const geometryUniqueTable = pgTable('geometry_unique_table', {
+	geometryPointTuple: geometry('geometry_point_tuple', { type: 'point', mode: 'tuple', srid: 0 }).unique(),
+	geometryPointXy: geometry('geometry_point_xy', { type: 'point', mode: 'xy', srid: 0 }).unique(),
+});
+export const geometryArrayTable = pgTable('geometry_array_table', {
+	geometryPointTuple: geometry('geometry_point_tuple', { type: 'point', mode: 'tuple', srid: 0 }).array(),
+	geometryPointXy: geometry('geometry_point_xy', { type: 'point', mode: 'xy', srid: 0 }).array(),
+});
+
+export const compositeUniqueKeyTable = pgTable('composite_unique_key_table', {
+	id: integer('id'),
+	geometryPoint: geometry('geometry_point', { type: 'point' }),
+}, (table) => [
+	unique().on(
+		table.id,
+		table.geometryPoint,
+	),
+]);
diff --git a/drizzle-seed/tests/pg/generatorsTest/pgSchema.ts b/drizzle-seed/tests/pg/generatorsTest/pgSchema.ts
index 48902ac6e3..92cf85687b 100644
--- a/drizzle-seed/tests/pg/generatorsTest/pgSchema.ts
+++ b/drizzle-seed/tests/pg/generatorsTest/pgSchema.ts
@@ -1,6 +1,8 @@
 import {
+	bit,
 	boolean,
 	date,
+	inet,
 	integer,
 	interval,
 	json,
@@ -11,8 +13,10 @@ import {
 	text,
 	time,
 	timestamp,
+	unique,
 	uuid,
 	varchar,
+	vector,
 } from 'drizzle-orm/pg-core';
 
 export const schema = pgSchema('seeder_lib_pg');
@@ -84,7 +88,7 @@ export const booleanArrayTable = schema.table('boolean_array_table', {
 });
 
 export const dateTable = schema.table('date_table', {
-	date: date('date'),
+	date: date('date', { mode: 'date' }),
 });
 
 // TODO: add tests for data type with different modes
@@ -320,3 +324,81 @@ export const uuidTable = schema.table('uuid_table', {
 export const uuidArrayTable = schema.table('uuid_array_table', {
 	uuid: uuid('uuid').array(),
 });
+
+export const bitStringTable = schema.table('bit_string_table', {
+	bit: bit('bit', { dimensions: 12 }),
+});
+export const bitStringUniqueTable = schema.table('bit_string_unique_table', {
+	bit: bit('bit', { dimensions: 12 }).unique(),
+});
+export const bitStringArrayTable = schema.table('bit_string_array_table', {
+	bit: bit('bit', { dimensions: 12 }).array(),
+});
+
+export const inetTable = schema.table('inet_table', {
+	inet: inet('inet'),
+});
+export const inetUniqueTable = schema.table('inet_unique_table', {
+	inet: inet('inet').unique(),
+});
+export const inetArrayTable = schema.table('inet_array_table', {
+	inet: inet('inet').array(),
+});
+
+export const vectorTable = schema.table('vector_table', {
+	vector: vector('vector', { dimensions: 12 }),
+});
+export const vectorUniqueTable = schema.table('vector_unique_table', {
+	vector: vector('vector', { dimensions: 12 }).unique(),
+});
+export const vectorArrayTable = schema.table('vector_array_table', {
+	vector: vector('vector', { dimensions: 12 }).array(),
+});
+
+export const compositeUniqueKeyTable = schema.table('composite_unique_key_table', {
+	number: real('number'),
+	int: integer('int'),
+	interval: interval('interval'),
+	string: varchar('string', { length: 256 }),
+	firstName: varchar('first_name', { length: 256 }),
+	lastName: varchar('last_name', { length: 256 }),
+	fullName: varchar('full_name', { length: 256 }),
+	country: varchar('country', { length: 256 }),
+	city: varchar('city', { length: 256 }),
+	streetAddress: varchar('street_address', { length: 256 }),
+	postcode: varchar('postcode', { length: 256 }),
+	companyName: varchar('company_name', { length: 256 }),
+	phoneNumber: varchar('phone_number', { length: 256 }),
+	email: varchar('email', { length: 256 }),
+	uuid: uuid('uuid'),
+	bit: bit('bit', { dimensions: 12 }),
+	inet: inet('inet'),
+	vector: vector('vector', { dimensions: 12 }),
+	valuesFromArray: varchar('values_from_array', { length: 256 }),
+	// point: point('point'),
+	// line: line('line'),
+}, (table) => [
+	unique().on(
+		table.number,
+		table.int,
+		table.interval,
+		table.string,
+		table.firstName,
+		table.lastName,
+		table.fullName,
+		table.country,
+		table.city,
+		table.streetAddress,
+		table.postcode,
+		table.companyName,
+		table.phoneNumber,
+		table.email,
+		table.uuid,
+		table.bit,
+		table.inet,
+		table.vector,
+		table.valuesFromArray,
+		// table.point,
+		// table.line,
+	),
+]);
diff --git a/drizzle-seed/tests/pg/generatorsTest/postgisGenerators.test.ts b/drizzle-seed/tests/pg/generatorsTest/postgisGenerators.test.ts
new file mode 100644
index 0000000000..322abab317
--- /dev/null
+++ b/drizzle-seed/tests/pg/generatorsTest/postgisGenerators.test.ts
@@ -0,0 +1,162 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { pgPostgisTest as test } from '../instrumentation.ts';
+import * as schema from './pgPostgisSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "geometry_table" (
+				"geometry_point_tuple" geometry(point, 0),
+				"geometry_point_xy" geometry(point, 0)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "geometry_unique_table" (
+				"geometry_point_tuple" geometry(point, 0) unique,
+				"geometry_point_xy" geometry(point, 0) unique
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE IF NOT EXISTS "geometry_array_table" (
+				"geometry_point_tuple" geometry(point, 0)[],
+				"geometry_point_xy" geometry(point, 0)[]
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE TABLE IF NOT EXISTS "composite_unique_key_table" (
+			"id" integer,
+			"geometry_point" geometry(point, 0),
+			CONSTRAINT "custom_name" UNIQUE("id","geometry_point")
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+const count = 1000;
+
+test('geometry generator test', async ({ db }) => {
+	await reset(db, { geometryTable: schema.geometryTable });
+	await seed(db, { geometryTable: schema.geometryTable }).refine((funcs) => ({
+		geometryTable: {
+			count,
+			columns: {
+				geometryPointTuple: funcs.geometry({
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+				geometryPointXy: funcs.geometry({
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.geometryTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('geometry unique generator test', async ({ db }) => {
+	await reset(db, { geometryUniqueTable: schema.geometryUniqueTable });
+	await seed(db, { geometryUniqueTable: schema.geometryUniqueTable }).refine((funcs) => ({
+		geometryUniqueTable: {
+			count,
+			columns: {
+				geometryPointTuple: funcs.geometry({
+					isUnique: true,
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+				geometryPointXy: funcs.geometry({
+					isUnique: true,
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.geometryUniqueTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('geometry array generator test', async ({ db }) => {
+	await reset(db, { geometryArrayTable: schema.geometryArrayTable });
+	await seed(db, { geometryArrayTable: schema.geometryArrayTable }).refine((funcs) => ({
+		geometryArrayTable: {
+			count,
+			columns: {
+				geometryPointTuple: funcs.geometry({
+					arraySize: 1,
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+				geometryPointXy: funcs.geometry({
+					arraySize: 1,
+					type: 'point',
+					srid: 4326,
+					decimalPlaces: 5,
+				}),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.geometryArrayTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('composite unique key generator test', async ({ db }) => {
+	await reset(db, { compositeUniqueKeyTable: schema.compositeUniqueKeyTable });
+	await seed(db, { compositeUniqueKeyTable: schema.compositeUniqueKeyTable }, { count: 10000 }).refine((funcs) => ({
+		compositeUniqueKeyTable: {
+			columns: {
+				id: funcs.int(),
+				geometryPoint: funcs.geometry({ type: 'point', srid: 4326 }),
+			},
+		},
+	}));
+
+	const data = await db.select().from(schema.compositeUniqueKeyTable);
+	// every value in each row does not equal undefined.
+	const predicate = data.length !== 0
+		&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/pg/instrumentation.ts b/drizzle-seed/tests/pg/instrumentation.ts
new file mode 100644
index 0000000000..5dd63039a2
--- /dev/null
+++ b/drizzle-seed/tests/pg/instrumentation.ts
@@ -0,0 +1,175 @@
+import { PGlite } from '@electric-sql/pglite';
+import { vector } from '@electric-sql/pglite/vector';
+import { drizzle as drizzleNodePostgres } from 'drizzle-orm/node-postgres';
+import type { PgAsyncDatabase } from 'drizzle-orm/pg-core/async';
+import { drizzle as drizzlePglite } from 'drizzle-orm/pglite';
+import { Client } from 'pg';
+import { test as base } from 'vitest';
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/postgres/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+export const preparePglite = async () => {
+	const client = new PGlite({ extensions: { vector } });
+	await client.query('CREATE EXTENSION IF NOT EXISTS vector;');
+	await client.query('create schema "mySchema";');
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareNodePostgres = async (db: string = 'drizzle') => {
+	const envUrl = process.env['PG_POSTGIS_CONNECTION_STRING'];
+	if (!envUrl) throw new Error('PG_POSTGIS_CONNECTION_STRING env is not set.');
+	const url = new URL(envUrl);
+	url.pathname = `/${db}`;
+
+	const client = new Client(url.toString());
+	await client.connect();
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows as any[];
+	};
+	const batch = async (statements: string[]) => {
+		return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+	};
+
+	await query('drop schema if exists public cascade;');
+	await query('create schema public;');
+	await query('create extension if not exists postgis;');
+
+	return { client, query, batch };
+};
+
+const providerClosure = async <T>(items: T[]) => {
+	return async () => {
+		while (true) {
+			const c = items.shift();
+			if (!c) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				continue;
+			}
+			return {
+				...c,
+				release: () => {
+					items.push(c);
+				},
+			};
+		}
+	};
+};
+
+export const provideForPglite = async () => {
+	const clients = [
+		await preparePglite(),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForNodePostgres = async () => {
+	const clients = [
+		await prepareNodePostgres(),
+	];
+
+	return providerClosure(clients);
+};
+
+type ProvideForPglite = Awaited<ReturnType<typeof provideForPglite>>;
+type ProvideForNodePostgres = Awaited<ReturnType<typeof provideForNodePostgres>>;
+
+type Provider =
+	| ProvideForPglite
+	| ProvideForNodePostgres;
+
+const prepareTest = (dbType: 'pglite' | 'postgis') => {
+	return base.extend<
+		{
+			provider: Provider;
+			kit: {
+				client: any;
+				query: (sql: string, params?: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<any>;
+			};
+			client: any;
+			db: PgAsyncDatabase<any, any>;
+			push: (schema: any) => Promise<void>;
+		}
+	>({
+		provider: [
+			// oxlint-disable-next-line no-empty-pattern
+			async ({}, use) => {
+				const provider = dbType === 'postgis'
+					? await provideForNodePostgres()
+					: dbType === 'pglite'
+					? await provideForPglite()
+					: '' as never;
+
+				await use(provider);
+			},
+			{ scope: 'file' },
+		],
+		kit: [
+			async ({ provider }, use) => {
+				const { client, batch, query, release } = await provider();
+				await use({ client: client as any, query, batch });
+				release();
+			},
+			{ scope: 'test' },
+		],
+		client: [
+			async ({ kit }, use) => {
+				await use(kit.client);
+			},
+			{ scope: 'test' },
+		],
+		db: [
+			async ({ kit }, use) => {
+				const db = dbType === 'postgis'
+					? drizzleNodePostgres({ client: kit.client })
+					: dbType === 'pglite'
+					? drizzlePglite({ client: kit.client })
+					: '' as never;
+
+				await use(db);
+			},
+			{ scope: 'test' },
+		],
+		push: [
+			async ({ kit }, use) => {
+				const push = (
+					schema: any,
+				) => _push(kit.query, schema);
+
+				await use(push);
+			},
+			{ scope: 'test' },
+		],
+	});
+};
+
+export const pgPostgisTest = prepareTest('postgis');
+export const pgliteTest = prepareTest('pglite');
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/drizzle-seed/tests/pg/pg.test.ts b/drizzle-seed/tests/pg/pg.test.ts
index 08fa5133db..c72245e8be 100644
--- a/drizzle-seed/tests/pg/pg.test.ts
+++ b/drizzle-seed/tests/pg/pg.test.ts
@@ -1,7 +1,9 @@
 import { PGlite } from '@electric-sql/pglite';
-import { relations, sql } from 'drizzle-orm';
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { PgliteDatabase } from 'drizzle-orm/pglite';
 import { drizzle } from 'drizzle-orm/pglite';
+import { createSelectSchema } from 'drizzle-orm/zod';
 import { afterAll, afterEach, beforeAll, expect, test, vi } from 'vitest';
 import { reset, seed } from '../../src/index.ts';
 import * as schema from './pgSchema.ts';
@@ -12,7 +14,7 @@ let db: PgliteDatabase;
 beforeAll(async () => {
 	client = new PGlite();
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	await db.execute(sql`CREATE SCHEMA "seeder_lib_pg";`);
 	await db.execute(
@@ -219,6 +221,51 @@ beforeAll(async () => {
 			);
 		`,
 	);
+
+	await db.execute(
+		sql`
+			create table "seeder_lib_pg"."test_sequences"
+			(
+			    col1 integer generated always as identity,
+			    col2 bigint generated by default as identity,
+				col3 bigint generated by default as identity,
+			    col4 smallint,
+			    col5 serial,
+			    col6 bigserial,
+				col7 bigserial,
+			    col8 smallserial
+			);
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table "seeder_lib_pg"."uuid_test"
+			(
+			    col1 uuid
+			);
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table "seeder_lib_pg"."casing_test"
+			(
+			    column_name1 integer,
+			    column_name2 integer
+			);
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table "casing_test"
+			(
+			    column_name1 integer,
+			    column_name2 integer
+			);
+		`,
+	);
 });
 
 afterEach(async () => {
@@ -230,7 +277,15 @@ afterAll(async () => {
 });
 
 test('basic seed test', async () => {
-	await seed(db, schema);
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema);
 
 	const customers = await db.select().from(schema.customers);
 	const details = await db.select().from(schema.details);
@@ -248,7 +303,15 @@ test('basic seed test', async () => {
 });
 
 test('seed with options.count:11 test', async () => {
-	await seed(db, schema, { count: 11 });
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema, { count: 11 });
 
 	const customers = await db.select().from(schema.customers);
 	const details = await db.select().from(schema.details);
@@ -266,7 +329,15 @@ test('seed with options.count:11 test', async () => {
 });
 
 test('redefine(refine) customers count', async () => {
-	await seed(db, schema, { count: 11 }).refine(() => ({
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 12,
 		},
@@ -288,7 +359,15 @@ test('redefine(refine) customers count', async () => {
 });
 
 test('redefine(refine) all tables count', async () => {
-	await seed(db, schema, { count: 11 }).refine(() => ({
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 12,
 		},
@@ -325,7 +404,15 @@ test('redefine(refine) all tables count', async () => {
 });
 
 test("redefine(refine) orders count using 'with' in customers", async () => {
-	await seed(db, schema, { count: 11 }).refine(() => ({
+	const currSchema = {
+		customers: schema.customers,
+		details: schema.details,
+		employees: schema.employees,
+		orders: schema.orders,
+		products: schema.products,
+		suppliers: schema.suppliers,
+	};
+	await seed(db, currSchema, { count: 11 }).refine(() => ({
 		customers: {
 			count: 4,
 			with: {
@@ -433,3 +520,104 @@ test('overlapping a foreign key constraint with a one-to-many relation', async (
 	predicate = posts.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
 	expect(predicate).toBe(true);
 });
+
+test('seeding while ignoring column', async () => {
+	await seed(db, { users: schema.users }).refine(() => ({
+		users: {
+			columns: {
+				name: false,
+			},
+		},
+	}));
+
+	const result = await db.select().from(schema.users);
+
+	expect(result.length).toBe(10);
+	const predicate = result.every((row) =>
+		Object.entries(row).every(([colName, colVal]) =>
+			(colName === 'name' && colVal === null) || (colName !== 'name' && colVal !== null)
+		)
+	);
+	expect(predicate).toBe(true);
+});
+
+test('seeding table with sequences', async () => {
+	await seed(db, { testSequences: schema.testSequences }, { count: 10 }).refine((funcs) => ({
+		testSequences: {
+			columns: {
+				col1: funcs.intPrimaryKey(),
+				col2: funcs.intPrimaryKey(),
+				col3: funcs.intPrimaryKey(),
+				col4: funcs.intPrimaryKey(),
+				col5: funcs.intPrimaryKey(),
+				col6: funcs.intPrimaryKey(),
+				col7: funcs.intPrimaryKey(),
+				col8: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+
+	await db.insert(schema.testSequences).values([{}]);
+	const res = await db.select().from(schema.testSequences);
+
+	expect(res.at(-1)).toStrictEqual({
+		col1: 11,
+		col2: 11,
+		col3: 11n,
+		col4: null,
+		col5: 11,
+		col6: 11,
+		col7: 11n,
+		col8: 11,
+	});
+});
+
+test('uuid with drizzle-validations/zod check', async () => {
+	await seed(db, { uuidTest: schema.uuidTest }, { count: 1 }).refine((funcs) => ({
+		uuidTest: {
+			columns: {
+				col1: funcs.uuid(),
+			},
+		},
+	}));
+
+	const uuidSelectSchema = createSelectSchema(schema.uuidTest);
+	const res = await db.select().from(schema.uuidTest);
+	uuidSelectSchema.parse(res[0]);
+
+	expect(res).toStrictEqual([{ col1: 'caf44ec1-e98c-4d92-8ed5-beb2074f1460' }]);
+	const possibleUuids = [
+		'caf44ec1-e98c-4d92-8ed5-beb2074f1460',
+		'caf44ec1-e98c-4d92-9ed5-beb2074f1460',
+		'caf44ec1-e98c-4d92-aed5-beb2074f1460',
+		'caf44ec1-e98c-4d92-bed5-beb2074f1460',
+	];
+	for (const uuid of possibleUuids) {
+		uuidSelectSchema.parse({ col1: uuid });
+	}
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5470
+test('seed using db with casing', async () => {
+	const currSchema = { schemaCasingTest: schema.schemaCasingTest, casingTest: schema.casingTest };
+	const db = drizzle({ client });
+	for (let i = 0; i < 2; i++) {
+		await seed(db, { schemaCasingTest: schema.schemaCasingTest });
+
+		const res = await db.select().from(schema.schemaCasingTest);
+		expect(res.length).toBe(10);
+		let predicate = res.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+		expect(predicate).toBe(true);
+		await reset(db, { schemaCasingTest: schema.schemaCasingTest });
+	}
+
+	for (let i = 0; i < 2; i++) {
+		await seed(db, { casingTest: schema.casingTest });
+
+		const res2 = await db.select().from(schema.casingTest);
+		expect(res2.length).toBe(10);
+		let predicate2 = res2.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+		expect(predicate2).toBe(true);
+		await reset(db, { casingTest: schema.casingTest });
+	}
+});
diff --git a/drizzle-seed/tests/pg/pgSchema.ts b/drizzle-seed/tests/pg/pgSchema.ts
index 05608ab141..e955a95ac5 100644
--- a/drizzle-seed/tests/pg/pgSchema.ts
+++ b/drizzle-seed/tests/pg/pgSchema.ts
@@ -1,5 +1,20 @@
 import type { AnyPgColumn } from 'drizzle-orm/pg-core';
-import { integer, numeric, pgSchema, serial, text, timestamp, varchar } from 'drizzle-orm/pg-core';
+import {
+	bigint,
+	bigserial,
+	integer,
+	numeric,
+	pgSchema,
+	pgTable,
+	serial,
+	smallint,
+	smallserial,
+	snakeCase,
+	text,
+	timestamp,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
 
 export const schema = pgSchema('seeder_lib_pg');
 
@@ -127,3 +142,33 @@ export const posts = schema.table(
 		userId: integer().references(() => users.id),
 	},
 );
+
+export const testSequences = schema.table(
+	'test_sequences',
+	{
+		col1: integer().generatedAlwaysAsIdentity(),
+		col2: bigint({ mode: 'number' }).generatedByDefaultAsIdentity(),
+		col3: bigint({ mode: 'bigint' }).generatedByDefaultAsIdentity(),
+		col4: smallint(),
+		col5: serial(),
+		col6: bigserial({ mode: 'number' }),
+		col7: bigserial({ mode: 'bigint' }),
+		col8: smallserial(),
+	},
+);
+
+export const uuidTest = schema.table('uuid_test', {
+	col1: uuid(),
+});
+
+const casingSchema = snakeCase.schema('seeder_lib_pg');
+
+export const schemaCasingTest = casingSchema.table('casing_test', {
+	columnName1: integer(),
+	columnName2: integer(),
+});
+
+export const casingTest = snakeCase.table('casing_test', {
+	columnName1: integer(),
+	columnName2: integer(),
+});
diff --git a/drizzle-seed/tests/pg/softRelationsTest/pgSchema.ts b/drizzle-seed/tests/pg/softRelationsTest/pgSchema.ts
index 357ea23cff..73566aa592 100644
--- a/drizzle-seed/tests/pg/softRelationsTest/pgSchema.ts
+++ b/drizzle-seed/tests/pg/softRelationsTest/pgSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import { integer, numeric, pgSchema, text, timestamp, varchar } from 'drizzle-orm/pg-core';
 
 export const schema = pgSchema('seeder_lib_pg');
diff --git a/drizzle-seed/tests/pg/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/pg/softRelationsTest/softRelations.test.ts
index 2056478120..9f116c9575 100644
--- a/drizzle-seed/tests/pg/softRelationsTest/softRelations.test.ts
+++ b/drizzle-seed/tests/pg/softRelationsTest/softRelations.test.ts
@@ -12,7 +12,7 @@ let db: PgliteDatabase;
 beforeAll(async () => {
 	client = new PGlite();
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	await db.execute(sql`CREATE SCHEMA "seeder_lib_pg";`);
 	await db.execute(
diff --git a/drizzle-seed/tests/singlestore/allDataTypesTest/singlestoreSchema.ts b/drizzle-seed/tests/singlestore/allDataTypesTest/singlestoreSchema.ts
new file mode 100644
index 0000000000..088692e325
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/allDataTypesTest/singlestoreSchema.ts
@@ -0,0 +1,69 @@
+import {
+	bigint,
+	binary,
+	boolean,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	int,
+	json,
+	longtext,
+	mediumint,
+	mediumtext,
+	real,
+	serial,
+	singlestoreEnum,
+	singlestoreTable,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	tinytext,
+	varbinary,
+	varchar,
+	vector,
+	year,
+} from 'drizzle-orm/singlestore-core';
+
+export const allDataTypes = singlestoreTable('all_data_types', {
+	int: int('int'),
+	tinyint: tinyint('tinyint'),
+	smallint: smallint('smallint'),
+	mediumint: mediumint('mediumint'),
+	biginteger: bigint('bigint', { mode: 'bigint' }),
+	bigintNumber: bigint('bigint_number', { mode: 'number' }),
+	real: real('real'),
+	decimal: decimal('decimal'),
+	double: double('double'),
+	float: float('float'),
+	serial: serial('serial'),
+	binary: binary('binary', { length: 255 }),
+	varbinary: varbinary('varbinary', { length: 256 }),
+	char: char('char', { length: 255 }),
+	varchar: varchar('varchar', { length: 256 }),
+	tinytext: tinytext('tinytext'),
+	mediumtext: mediumtext('mediumtext'),
+	longtext: longtext('longtext'),
+	text: text('text'),
+	boolean: boolean('boolean'),
+	dateString: date('date_string', { mode: 'string' }),
+	date: date('date', { mode: 'date' }),
+	datetime: datetime('datetime', { mode: 'date' }),
+	datetimeString: datetime('datetimeString', { mode: 'string' }),
+	time: time('time'),
+	year: year('year'),
+	timestampDate: timestamp('timestamp_date', { mode: 'date' }),
+	timestampString: timestamp('timestamp_string', { mode: 'string' }),
+	json: json('json'),
+	mysqlEnum: singlestoreEnum('popularity', ['unknown', 'known', 'popular']),
+	vectorF32: vector('vector_f32', { dimensions: 12, elementType: 'F32' }),
+	vectorF64: vector('vector_f64', { dimensions: 12, elementType: 'F64' }),
+	vectorI8: vector('vector_i8', { dimensions: 12, elementType: 'I8' }),
+	vectorI16: vector('vector_i16', { dimensions: 12, elementType: 'I16' }),
+	vectorI32: vector('vector_i32', { dimensions: 12, elementType: 'I32' }),
+	vectorI64: vector('vector_i64', { dimensions: 12, elementType: 'I64' }),
+});
diff --git a/drizzle-seed/tests/singlestore/allDataTypesTest/singlestore_all_data_types.test.ts b/drizzle-seed/tests/singlestore/allDataTypesTest/singlestore_all_data_types.test.ts
new file mode 100644
index 0000000000..2e370834f8
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/allDataTypesTest/singlestore_all_data_types.test.ts
@@ -0,0 +1,76 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { seed } from '../../../src/index.ts';
+import { singlestoreTest as test } from '../instrumentation.ts';
+
+import * as schema from './singlestoreSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`all_data_types\` (
+				\`int\` int,
+				\`tinyint\` tinyint,
+				\`smallint\` smallint,
+				\`mediumint\` mediumint,
+				\`bigint\` bigint,
+				\`bigint_number\` bigint,
+				\`real\` real,
+				\`decimal\` decimal,
+				\`double\` double,
+				\`float\` float,
+				\`serial\` serial,
+				\`binary\` binary(255),
+				\`varbinary\` varbinary(256),
+				\`char\` char(255),
+				\`varchar\` varchar(256),
+				\`tinytext\` tinytext,
+				\`mediumtext\` mediumtext,
+				\`text\` text,
+				\`longtext\` longtext,
+				\`boolean\` boolean,
+				\`date_string\` date,
+				\`date\` date,
+				\`datetime\` datetime,
+				\`datetimeString\` datetime,
+				\`time\` time,
+				\`year\` year,
+				\`timestamp_date\` timestamp,
+				\`timestamp_string\` timestamp,
+				\`json\` json,
+				\`popularity\` enum('unknown','known','popular'),
+				\`vector_f32\` vector(12, F32),
+				\`vector_f64\` vector(12, F64),
+				\`vector_i8\` vector(12, I8),
+				\`vector_i16\` vector(12, I16),
+				\`vector_i32\` vector(12, I32),
+				\`vector_i64\` vector(12, I64),
+				shard key (\`serial\`)
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test('basic seed test', async ({ db }) => {
+	await seed(db, schema, { count: 1 });
+
+	const allDataTypes = await db.select().from(schema.allDataTypes);
+
+	// every value in each 10 rows does not equal undefined.
+	const predicate = allDataTypes.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestore.test.ts b/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestore.test.ts
new file mode 100644
index 0000000000..f2755c8c9b
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestore.test.ts
@@ -0,0 +1,227 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { singlestoreTest as test } from '../instrumentation.ts';
+import * as schema from './singlestoreSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			CREATE TABLE \`composite_example0\` (
+				\`id\` integer not null,
+				\`name\` varchar(256) not null,
+				SHARD(\`id\`,\`name\`),
+				CONSTRAINT \`composite_example_id_name_unique\` UNIQUE(\`id\`,\`name\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE ROWSTORE TABLE \`composite_example\` (
+				\`id\` integer not null,
+				\`name\` varchar(256) not null,
+			    SHARD(\`id\`,\`name\`),
+				CONSTRAINT \`composite_example_id_name_unique\` UNIQUE(\`id\`,\`name\`),
+				CONSTRAINT \`custom_name\` UNIQUE(\`id\`,\`name\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE ROWSTORE TABLE \`unique_column_in_composite_of_two_0\` (
+				\`id\` integer not null unique,
+				\`name\` varchar(256) not null,
+			    SHARD(\`id\`),
+				CONSTRAINT \`custom_name0\` UNIQUE(\`id\`,\`name\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE ROWSTORE TABLE \`unique_column_in_composite_of_two_1\` (
+				\`id\` integer not null,
+				\`name\` varchar(256) not null,
+			    SHARD(\`id\`),
+				CONSTRAINT \`custom_name1\` UNIQUE(\`id\`,\`name\`),
+				CONSTRAINT \`custom_name1_id\` UNIQUE(\`id\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE ROWSTORE TABLE \`unique_column_in_composite_of_three_0\` (
+				\`id\` integer not null unique,
+				\`name\` varchar(256) not null,
+				\`slug\` varchar(256) not null,
+			    SHARD(\`id\`),
+				CONSTRAINT \`custom_name2\` UNIQUE(\`id\`,\`name\`,\`slug\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			CREATE ROWSTORE TABLE \`unique_column_in_composite_of_three_1\` (
+				\`id\` integer not null,
+				\`name\` varchar(256) not null,
+				\`slug\` varchar(256) not null,
+			    SHARD(\`id\`),
+				CONSTRAINT \`custom_name3\` UNIQUE(\`id\`,\`name\`,\`slug\`),
+				CONSTRAINT \`custom_name3_id\` UNIQUE(\`id\`)
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async ({ db }) => {
+	const currSchema0 = { composite0: schema.composite0 };
+	await seed(db, currSchema0, { count: 16 });
+
+	const composite0 = await db.select().from(schema.composite0);
+
+	expect(composite0.length).toBe(16);
+	await reset(db, currSchema0);
+
+	// ------------------------------------------------------------
+	const currSchema = { composite: schema.composite };
+	await seed(db, currSchema, { count: 16 });
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	// ------------------------------------------------------------
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	// ------------------------------------------------------------
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async ({ db }) => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	// ------------------------------------------------------------
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
diff --git a/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestoreSchema.ts b/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestoreSchema.ts
new file mode 100644
index 0000000000..0ee724f124
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/compositeUniqueKey/singlestoreSchema.ts
@@ -0,0 +1,47 @@
+import { int, singlestoreTable, unique, varchar } from 'drizzle-orm/singlestore-core';
+
+export const composite0 = singlestoreTable('composite_example0', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('composite_example_id_name_unique').on(t.id, t.name),
+]);
+
+export const composite = singlestoreTable('composite_example', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = singlestoreTable('unique_column_in_composite_of_two_0', {
+	id: int('id').notNull().unique(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = singlestoreTable('unique_column_in_composite_of_two_1', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = singlestoreTable('unique_column_in_composite_of_three_0', {
+	id: int('id').notNull().unique(),
+	name: varchar('name', { length: 256 }).notNull(),
+	slug: varchar('slug', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = singlestoreTable('unique_column_in_composite_of_three_1', {
+	id: int('id').notNull(),
+	name: varchar('name', { length: 256 }).notNull(),
+	slug: varchar('slug', { length: 256 }).notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/singlestore/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/singlestore/cyclicTables/cyclicTables.test.ts
new file mode 100644
index 0000000000..5b52b72c31
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/cyclicTables/cyclicTables.test.ts
@@ -0,0 +1,131 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { singlestoreTest as test } from '../instrumentation.ts';
+import * as schema from './singlestoreSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			create table model
+			(
+			    id             int          not null
+			        primary key,
+			    name           varchar(256) not null,
+			    defaultImageId int          null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table model_image
+			(
+			    id      int          not null
+			        primary key,
+			    url     varchar(256) not null,
+			    caption varchar(256) null,
+			    modelId int          not null
+			);
+		`,
+		);
+
+		// 3 tables case
+		await db.execute(
+			sql`
+			create table model1
+			(
+			    id             int          not null
+			        primary key,
+			    name           varchar(256) not null,
+			    userId         int          null,
+			    defaultImageId int          null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table model_image1
+			(
+			    id      int          not null
+			        primary key,
+			    url     varchar(256) not null,
+			    caption varchar(256) null,
+			    modelId int          not null
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			create table user
+			(
+			    id        int  not null
+			        primary key,
+			    name      text null,
+			    invitedBy int  null,
+			    imageId   int  not null
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+test('2 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable: schema.modelTable,
+		modelImageTable: schema.modelImageTable,
+	});
+
+	const modelTable = await db.select().from(schema.modelTable);
+	const modelImageTable = await db.select().from(schema.modelImageTable);
+
+	expect(modelTable.length).toBe(10);
+	let predicate = modelTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable.length).toBe(10);
+	predicate = modelImageTable.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
+
+test('3 cyclic tables test', async ({ db }) => {
+	await seed(db, {
+		modelTable1: schema.modelTable1,
+		modelImageTable1: schema.modelImageTable1,
+		user: schema.user,
+	});
+
+	const modelTable1 = await db.select().from(schema.modelTable1);
+	const modelImageTable1 = await db.select().from(schema.modelImageTable1);
+	const user = await db.select().from(schema.user);
+
+	expect(modelTable1.length).toBe(10);
+	let predicate = modelTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(modelImageTable1.length).toBe(10);
+	predicate = modelImageTable1.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+
+	expect(user.length).toBe(10);
+	predicate = user.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
+	expect(predicate).toBe(true);
+});
diff --git a/drizzle-seed/tests/singlestore/cyclicTables/singlestoreSchema.ts b/drizzle-seed/tests/singlestore/cyclicTables/singlestoreSchema.ts
new file mode 100644
index 0000000000..62b55a30d6
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/cyclicTables/singlestoreSchema.ts
@@ -0,0 +1,94 @@
+import { relations } from 'drizzle-orm/_relations';
+import { int, serial, singlestoreTable, text, varchar } from 'drizzle-orm/singlestore-core';
+
+// MODEL
+export const modelTable = singlestoreTable(
+	'model',
+	{
+		id: serial().primaryKey(),
+		name: varchar({ length: 256 }).notNull(),
+		defaultImageId: int(),
+	},
+);
+
+export const modelRelations = relations(modelTable, ({ one, many }) => ({
+	images: many(modelImageTable),
+	defaultImage: one(modelImageTable, {
+		fields: [modelTable.defaultImageId],
+		references: [modelImageTable.id],
+	}),
+}));
+
+// MODEL IMAGE
+export const modelImageTable = singlestoreTable(
+	'model_image',
+	{
+		id: serial().primaryKey(),
+		url: varchar({ length: 256 }).notNull(),
+		caption: varchar({ length: 256 }),
+		modelId: int().notNull(),
+	},
+);
+
+export const modelImageRelations = relations(modelImageTable, ({ one }) => ({
+	model: one(modelTable, {
+		fields: [modelImageTable.modelId],
+		references: [modelTable.id],
+	}),
+}));
+
+// 3 tables case
+export const modelTable1 = singlestoreTable(
+	'model1',
+	{
+		id: serial().primaryKey(),
+		name: varchar({ length: 256 }).notNull(),
+		userId: int(),
+		defaultImageId: int(),
+	},
+);
+
+export const modelTable1Relations = relations(modelTable1, ({ one }) => ({
+	user: one(user, {
+		fields: [modelTable1.userId],
+		references: [user.id],
+	}),
+}));
+
+export const modelImageTable1 = singlestoreTable(
+	'model_image1',
+	{
+		id: serial().primaryKey(),
+		url: varchar({ length: 256 }).notNull(),
+		caption: varchar({ length: 256 }),
+		modelId: int().notNull(),
+	},
+);
+
+export const modelImageTable1Relations = relations(modelImageTable1, ({ one }) => ({
+	user: one(modelTable1, {
+		fields: [modelImageTable1.modelId],
+		references: [modelTable1.id],
+	}),
+}));
+
+export const user = singlestoreTable(
+	'user',
+	{
+		id: serial().primaryKey(),
+		name: text(),
+		invitedBy: int(),
+		imageId: int().notNull(),
+	},
+);
+
+export const userRelations = relations(user, ({ one }) => ({
+	intvitedByUser: one(user, {
+		fields: [user.invitedBy],
+		references: [user.id],
+	}),
+	image: one(modelImageTable1, {
+		fields: [user.imageId],
+		references: [modelImageTable1.id],
+	}),
+}));
diff --git a/drizzle-seed/tests/singlestore/instrumentation.ts b/drizzle-seed/tests/singlestore/instrumentation.ts
new file mode 100644
index 0000000000..6d7af755a3
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/instrumentation.ts
@@ -0,0 +1,84 @@
+import type { AnyMySql2Connection } from 'drizzle-orm/mysql2';
+import { drizzle, SingleStoreDatabase } from 'drizzle-orm/singlestore';
+import { createConnection } from 'mysql2/promise';
+import { test as base } from 'vitest';
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/singlestore/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+const prepareTest = () => {
+	return base.extend<
+		{
+			client: {
+				client: AnyMySql2Connection;
+				query: (sql: string, params: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<void>;
+			};
+			db: SingleStoreDatabase<any, any, any, any>;
+			push: (schema: any) => Promise<void>;
+		}
+	>({
+		client: [
+			// oxlint-disable-next-line
+			async ({}, use) => {
+				const envurl = process.env['SINGLESTORE_CONNECTION_STRING'];
+				if (!envurl) throw new Error('No singlestore url provided');
+				const client = await createConnection({
+					uri: envurl,
+					supportBigNumbers: true,
+					multipleStatements: true,
+				});
+				await client.connect();
+
+				const query = async (sql: string, params: any[] = []) => {
+					const res = await client.query(sql, params);
+					return res[0] as any[];
+				};
+				const batch = async (statements: string[]) => {
+					return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+				};
+
+				await batch(['drop database if exists drizzle;', 'create database drizzle;', 'use drizzle;']);
+
+				await use({ client, query, batch });
+				await client.end();
+				client.destroy();
+			},
+			{ scope: 'worker' },
+		],
+		db: [
+			async ({ client }, use) => {
+				const db = drizzle({ client: client.client as AnyMySql2Connection });
+				await use(db as any);
+			},
+			{ scope: 'worker' },
+		],
+		push: [
+			async ({ client }, use) => {
+				const { query } = client;
+				const push = (
+					schema: any,
+				) => _push(query, schema);
+
+				await use(push);
+			},
+			{ scope: 'worker' },
+		],
+	});
+};
+
+export const singlestoreTest = prepareTest();
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/drizzle-seed/tests/singlestore/softRelationsTest/singlestoreSchema.ts b/drizzle-seed/tests/singlestore/softRelationsTest/singlestoreSchema.ts
new file mode 100644
index 0000000000..284e4a5b04
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/softRelationsTest/singlestoreSchema.ts
@@ -0,0 +1,128 @@
+import { relations } from 'drizzle-orm/_relations';
+import { float, int, singlestoreTable, text, timestamp, varchar } from 'drizzle-orm/singlestore-core';
+
+export const customers = singlestoreTable('customer', {
+	id: varchar('id', { length: 256 }).primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	postalCode: text('postal_code'),
+	region: text('region'),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+	fax: text('fax'),
+});
+
+export const employees = singlestoreTable(
+	'employee',
+	{
+		id: int('id').primaryKey(),
+		lastName: text('last_name').notNull(),
+		firstName: text('first_name'),
+		title: text('title').notNull(),
+		titleOfCourtesy: text('title_of_courtesy').notNull(),
+		birthDate: timestamp('birth_date').notNull(),
+		hireDate: timestamp('hire_date').notNull(),
+		address: text('address').notNull(),
+		city: text('city').notNull(),
+		postalCode: text('postal_code').notNull(),
+		country: text('country').notNull(),
+		homePhone: text('home_phone').notNull(),
+		extension: int('extension').notNull(),
+		notes: text('notes').notNull(),
+		reportsTo: int('reports_to'),
+		photoPath: text('photo_path'),
+	},
+);
+
+export const employeesRelations = relations(employees, ({ one }) => ({
+	employee: one(employees, {
+		fields: [employees.reportsTo],
+		references: [employees.id],
+	}),
+}));
+
+export const orders = singlestoreTable('order', {
+	id: int('id').primaryKey(),
+	orderDate: timestamp('order_date').notNull(),
+	requiredDate: timestamp('required_date').notNull(),
+	shippedDate: timestamp('shipped_date'),
+	shipVia: int('ship_via').notNull(),
+	freight: float('freight').notNull(),
+	shipName: text('ship_name').notNull(),
+	shipCity: text('ship_city').notNull(),
+	shipRegion: text('ship_region'),
+	shipPostalCode: text('ship_postal_code'),
+	shipCountry: text('ship_country').notNull(),
+
+	customerId: varchar('customer_id', { length: 256 }).notNull(),
+
+	employeeId: int('employee_id').notNull(),
+});
+
+export const ordersRelations = relations(orders, ({ one }) => ({
+	customer: one(customers, {
+		fields: [orders.customerId],
+		references: [customers.id],
+	}),
+	employee: one(employees, {
+		fields: [orders.employeeId],
+		references: [employees.id],
+	}),
+}));
+
+export const suppliers = singlestoreTable('supplier', {
+	id: int('id').primaryKey(),
+	companyName: text('company_name').notNull(),
+	contactName: text('contact_name').notNull(),
+	contactTitle: text('contact_title').notNull(),
+	address: text('address').notNull(),
+	city: text('city').notNull(),
+	region: text('region'),
+	postalCode: text('postal_code').notNull(),
+	country: text('country').notNull(),
+	phone: text('phone').notNull(),
+});
+
+export const products = singlestoreTable('product', {
+	id: int('id').primaryKey(),
+	name: text('name').notNull(),
+	quantityPerUnit: text('quantity_per_unit').notNull(),
+	unitPrice: float('unit_price').notNull(),
+	unitsInStock: int('units_in_stock').notNull(),
+	unitsOnOrder: int('units_on_order').notNull(),
+	reorderLevel: int('reorder_level').notNull(),
+	discontinued: int('discontinued').notNull(),
+
+	supplierId: int('supplier_id').notNull(),
+});
+
+export const productsRelations = relations(products, ({ one }) => ({
+	supplier: one(suppliers, {
+		fields: [products.supplierId],
+		references: [suppliers.id],
+	}),
+}));
+
+export const details = singlestoreTable('order_detail', {
+	unitPrice: float('unit_price').notNull(),
+	quantity: int('quantity').notNull(),
+	discount: float('discount').notNull(),
+
+	orderId: int('order_id').notNull(),
+
+	productId: int('product_id').notNull(),
+});
+
+export const detailsRelations = relations(details, ({ one }) => ({
+	order: one(orders, {
+		fields: [details.orderId],
+		references: [orders.id],
+	}),
+	product: one(products, {
+		fields: [details.productId],
+		references: [products.id],
+	}),
+}));
diff --git a/drizzle-seed/tests/singlestore/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/singlestore/softRelationsTest/softRelations.test.ts
new file mode 100644
index 0000000000..85673ab4ed
--- /dev/null
+++ b/drizzle-seed/tests/singlestore/softRelationsTest/softRelations.test.ts
@@ -0,0 +1,341 @@
+import { sql } from 'drizzle-orm';
+import { expect } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import { singlestoreTest as test } from '../instrumentation.ts';
+import * as schema from './singlestoreSchema.ts';
+
+let firstTime = true;
+let resolveFunc: (val: any) => void;
+const promise = new Promise((resolve) => {
+	resolveFunc = resolve;
+});
+test.beforeEach(async ({ db }) => {
+	if (firstTime) {
+		firstTime = false;
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`customer\` (
+				\`id\` varchar(256) NOT NULL,
+				\`company_name\` text NOT NULL,
+				\`contact_name\` text NOT NULL,
+				\`contact_title\` text NOT NULL,
+				\`address\` text NOT NULL,
+				\`city\` text NOT NULL,
+				\`postal_code\` text,
+				\`region\` text,
+				\`country\` text NOT NULL,
+				\`phone\` text NOT NULL,
+				\`fax\` text,
+				CONSTRAINT \`customer_id\` PRIMARY KEY(\`id\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`order_detail\` (
+				\`unit_price\` float NOT NULL,
+				\`quantity\` int NOT NULL,
+				\`discount\` float NOT NULL,
+				\`order_id\` int NOT NULL,
+				\`product_id\` int NOT NULL
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`employee\` (
+				\`id\` int NOT NULL,
+				\`last_name\` text NOT NULL,
+				\`first_name\` text,
+				\`title\` text NOT NULL,
+				\`title_of_courtesy\` text NOT NULL,
+				\`birth_date\` timestamp NOT NULL,
+				\`hire_date\` timestamp NOT NULL,
+				\`address\` text NOT NULL,
+				\`city\` text NOT NULL,
+				\`postal_code\` text NOT NULL,
+				\`country\` text NOT NULL,
+				\`home_phone\` text NOT NULL,
+				\`extension\` int NOT NULL,
+				\`notes\` text NOT NULL,
+				\`reports_to\` int,
+				\`photo_path\` text,
+				CONSTRAINT \`employee_id\` PRIMARY KEY(\`id\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`order\` (
+				\`id\` int NOT NULL,
+				\`order_date\` timestamp NOT NULL,
+				\`required_date\` timestamp NOT NULL,
+				\`shipped_date\` timestamp,
+				\`ship_via\` int NOT NULL,
+				\`freight\` float NOT NULL,
+				\`ship_name\` text NOT NULL,
+				\`ship_city\` text NOT NULL,
+				\`ship_region\` text,
+				\`ship_postal_code\` text,
+				\`ship_country\` text NOT NULL,
+				\`customer_id\` varchar(256) NOT NULL,
+				\`employee_id\` int NOT NULL,
+				CONSTRAINT \`order_id\` PRIMARY KEY(\`id\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`product\` (
+				\`id\` int NOT NULL,
+				\`name\` text NOT NULL,
+				\`quantity_per_unit\` text NOT NULL,
+				\`unit_price\` float NOT NULL,
+				\`units_in_stock\` int NOT NULL,
+				\`units_on_order\` int NOT NULL,
+				\`reorder_level\` int NOT NULL,
+				\`discontinued\` int NOT NULL,
+				\`supplier_id\` int NOT NULL,
+				CONSTRAINT \`product_id\` PRIMARY KEY(\`id\`)
+			);
+		`,
+		);
+
+		await db.execute(
+			sql`
+			    CREATE TABLE \`supplier\` (
+				\`id\` int NOT NULL,
+				\`company_name\` text NOT NULL,
+				\`contact_name\` text NOT NULL,
+				\`contact_title\` text NOT NULL,
+				\`address\` text NOT NULL,
+				\`city\` text NOT NULL,
+				\`region\` text,
+				\`postal_code\` text NOT NULL,
+				\`country\` text NOT NULL,
+				\`phone\` text NOT NULL,
+				CONSTRAINT \`supplier_id\` PRIMARY KEY(\`id\`)
+			);
+		`,
+		);
+
+		resolveFunc('');
+	}
+
+	await promise;
+});
+
+test.afterEach(async ({ db }) => {
+	await reset(db, schema);
+});
+
+const checkSoftRelations = (
+	customers: (typeof schema.customers.$inferSelect)[],
+	details: (typeof schema.details.$inferSelect)[],
+	employees: (typeof schema.employees.$inferSelect)[],
+	orders: (typeof schema.orders.$inferSelect)[],
+	products: (typeof schema.products.$inferSelect)[],
+	suppliers: (typeof schema.suppliers.$inferSelect)[],
+) => {
+	// employees soft relations check
+	const employeeIds = new Set(employees.map((employee) => employee.id));
+	const employeesPredicate = employees.every((employee) =>
+		employee.reportsTo !== null && employeeIds.has(employee.reportsTo)
+	);
+	expect(employeesPredicate).toBe(true);
+
+	// orders soft relations check
+	const customerIds = new Set(customers.map((customer) => customer.id));
+	const ordersPredicate1 = orders.every((order) => order.customerId !== null && customerIds.has(order.customerId));
+	expect(ordersPredicate1).toBe(true);
+
+	const ordersPredicate2 = orders.every((order) => order.employeeId !== null && employeeIds.has(order.employeeId));
+	expect(ordersPredicate2).toBe(true);
+
+	// product soft relations check
+	const supplierIds = new Set(suppliers.map((supplier) => supplier.id));
+	const productsPredicate = products.every((product) =>
+		product.supplierId !== null && supplierIds.has(product.supplierId)
+	);
+	expect(productsPredicate).toBe(true);
+
+	// details soft relations check
+	const orderIds = new Set(orders.map((order) => order.id));
+	const detailsPredicate1 = details.every((detail) => detail.orderId !== null && orderIds.has(detail.orderId));
+	expect(detailsPredicate1).toBe(true);
+
+	const productIds = new Set(products.map((product) => product.id));
+	const detailsPredicate2 = details.every((detail) => detail.productId !== null && productIds.has(detail.productId));
+	expect(detailsPredicate2).toBe(true);
+};
+
+test('basic seed, soft relations test', async ({ db }) => {
+	await seed(db, schema);
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(10);
+	expect(details.length).toBe(10);
+	expect(employees.length).toBe(10);
+	expect(orders.length).toBe(10);
+	expect(products.length).toBe(10);
+	expect(suppliers.length).toBe(10);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test('seed with options.count:11, soft relations test', async ({ db }) => {
+	await seed(db, schema, { count: 11 });
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(11);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test('redefine(refine) customers count, soft relations test', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(11);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test('redefine(refine) all tables count, soft relations test', async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 12,
+		},
+		details: {
+			count: 13,
+		},
+		employees: {
+			count: 14,
+		},
+		orders: {
+			count: 15,
+		},
+		products: {
+			count: 16,
+		},
+		suppliers: {
+			count: 17,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(12);
+	expect(details.length).toBe(13);
+	expect(employees.length).toBe(14);
+	expect(orders.length).toBe(15);
+	expect(products.length).toBe(16);
+	expect(suppliers.length).toBe(17);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("redefine(refine) orders count using 'with' in customers, soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 13,
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(11);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
+
+test("sequential using of 'with', soft relations test", async ({ db }) => {
+	await seed(db, schema, { count: 11 }).refine(() => ({
+		customers: {
+			count: 4,
+			with: {
+				orders: 2,
+			},
+		},
+		orders: {
+			count: 12,
+			with: {
+				details: 3,
+			},
+		},
+	}));
+
+	const customers = await db.select().from(schema.customers);
+	const details = await db.select().from(schema.details);
+	const employees = await db.select().from(schema.employees);
+	const orders = await db.select().from(schema.orders);
+	const products = await db.select().from(schema.products);
+	const suppliers = await db.select().from(schema.suppliers);
+
+	expect(customers.length).toBe(4);
+	expect(details.length).toBe(24);
+	expect(employees.length).toBe(11);
+	expect(orders.length).toBe(8);
+	expect(products.length).toBe(11);
+	expect(suppliers.length).toBe(11);
+
+	checkSoftRelations(customers, details, employees, orders, products, suppliers);
+});
diff --git a/drizzle-seed/tests/sqlite/allDataTypesTest/sqlite_all_data_types.test.ts b/drizzle-seed/tests/sqlite/allDataTypesTest/sqlite_all_data_types.test.ts
index 8282f921d4..aa1241dc03 100644
--- a/drizzle-seed/tests/sqlite/allDataTypesTest/sqlite_all_data_types.test.ts
+++ b/drizzle-seed/tests/sqlite/allDataTypesTest/sqlite_all_data_types.test.ts
@@ -12,7 +12,7 @@ let db: BetterSQLite3Database;
 beforeAll(async () => {
 	client = new BetterSqlite3(':memory:');
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	db.run(
 		sql.raw(`
diff --git a/drizzle-seed/tests/sqlite/compositeUniqueKey/sqlite.test.ts b/drizzle-seed/tests/sqlite/compositeUniqueKey/sqlite.test.ts
new file mode 100644
index 0000000000..b4aee225ce
--- /dev/null
+++ b/drizzle-seed/tests/sqlite/compositeUniqueKey/sqlite.test.ts
@@ -0,0 +1,197 @@
+import BetterSqlite3 from 'better-sqlite3';
+import { sql } from 'drizzle-orm';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
+import { reset, seed } from '../../../src/index.ts';
+import * as schema from './sqliteSchema.ts';
+
+let client: BetterSqlite3.Database;
+let db: BetterSQLite3Database;
+
+beforeAll(async () => {
+	client = new BetterSqlite3(':memory:');
+
+	db = drizzle({ client });
+
+	db.run(
+		sql`
+			CREATE TABLE IF NOT EXISTS \`composite_example\` (
+				\`id\` integer not null,
+				\`name\` text not null,
+				CONSTRAINT \`composite_example_id_name_unique\` UNIQUE(\`id\`,\`name\`),
+				CONSTRAINT \`custom_name\` UNIQUE(\`id\`,\`name\`)
+			);
+		`,
+	);
+
+	db.run(
+		sql`
+			CREATE TABLE IF NOT EXISTS \`unique_column_in_composite_of_two_0\` (
+				\`id\` integer not null unique,
+				\`name\` text not null,
+				CONSTRAINT \`custom_name0\` UNIQUE(\`id\`,\`name\`)
+			);
+		`,
+	);
+
+	db.run(
+		sql`
+			CREATE TABLE IF NOT EXISTS \`unique_column_in_composite_of_two_1\` (
+				\`id\` integer not null,
+				\`name\` text not null,
+				CONSTRAINT \`custom_name1\` UNIQUE(\`id\`,\`name\`),
+				CONSTRAINT \`custom_name1_id\` UNIQUE(\`id\`)
+			);
+		`,
+	);
+
+	db.run(
+		sql`
+			CREATE TABLE IF NOT EXISTS \`unique_column_in_composite_of_three_0\` (
+				\`id\` integer not null unique,
+				\`name\` text not null,
+				\`slug\` text not null,
+				CONSTRAINT \`custom_name2\` UNIQUE(\`id\`,\`name\`,\`slug\`)
+			);
+		`,
+	);
+
+	db.run(
+		sql`
+			CREATE TABLE IF NOT EXISTS \`unique_column_in_composite_of_three_1\` (
+				\`id\` integer not null,
+				\`name\` text not null,
+				\`slug\` text not null,
+				CONSTRAINT \`custom_name3\` UNIQUE(\`id\`,\`name\`,\`slug\`),
+				CONSTRAINT \`custom_name3_id\` UNIQUE(\`id\`)
+			);
+		`,
+	);
+});
+
+afterAll(async () => {
+	client.close();
+});
+
+afterEach(async () => {
+	await reset(db, schema);
+});
+
+test('basic seed test', async () => {
+	const currSchema = { composite: schema.composite };
+	await seed(db, currSchema, { count: 16 });
+
+	let composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 16 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema);
+
+	await seed(db, currSchema, { count: 17 }).refine((funcs) => ({
+		composite: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.composite);
+
+	expect(composite.length).toBe(17);
+	await reset(db, currSchema);
+});
+
+test('unique column in composite of 2 columns', async () => {
+	const currSchema0 = { uniqueColumnInCompositeOfTwo0: schema.uniqueColumnInCompositeOfTwo0 };
+	await seed(db, currSchema0, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo0);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfTwo1: schema.uniqueColumnInCompositeOfTwo1 };
+	await seed(db, currSchema1, { count: 4 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfTwo1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfTwo1);
+
+	expect(composite.length).toBe(4);
+	await reset(db, currSchema1);
+});
+
+test('unique column in composite of 3 columns', async () => {
+	const currSchema0 = { uniqueColumnInCompositeOfThree0: schema.uniqueColumnInCompositeOfThree0 };
+	await seed(db, currSchema0, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree0: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	let composite = await db.select().from(schema.uniqueColumnInCompositeOfThree0);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema0);
+
+	const currSchema1 = { uniqueColumnInCompositeOfThree1: schema.uniqueColumnInCompositeOfThree1 };
+	await seed(db, currSchema1, { count: 16 }).refine((funcs) => ({
+		uniqueColumnInCompositeOfThree1: {
+			columns: {
+				id: funcs.valuesFromArray({ values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }),
+				name: funcs.valuesFromArray({ values: ['a', 'b'] }),
+				slug: funcs.valuesFromArray({ values: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] }),
+			},
+		},
+	}));
+
+	composite = await db.select().from(schema.uniqueColumnInCompositeOfThree1);
+
+	expect(composite.length).toBe(16);
+	await reset(db, currSchema1);
+});
diff --git a/drizzle-seed/tests/sqlite/compositeUniqueKey/sqliteSchema.ts b/drizzle-seed/tests/sqlite/compositeUniqueKey/sqliteSchema.ts
new file mode 100644
index 0000000000..549c987550
--- /dev/null
+++ b/drizzle-seed/tests/sqlite/compositeUniqueKey/sqliteSchema.ts
@@ -0,0 +1,40 @@
+import { integer, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core';
+
+export const composite = sqliteTable('composite_example', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo0 = sqliteTable('unique_column_in_composite_of_two_0', {
+	id: integer('id').notNull().unique(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name0').on(t.id, t.name),
+]);
+
+export const uniqueColumnInCompositeOfTwo1 = sqliteTable('unique_column_in_composite_of_two_1', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+}, (t) => [
+	unique('custom_name1').on(t.id, t.name),
+	unique('custom_name1_id').on(t.id),
+]);
+
+export const uniqueColumnInCompositeOfThree0 = sqliteTable('unique_column_in_composite_of_three_0', {
+	id: integer('id').notNull().unique(),
+	name: text('name').notNull(),
+	slug: text('slug').notNull(),
+}, (t) => [
+	unique('custom_name2').on(t.id, t.name, t.slug),
+]);
+
+export const uniqueColumnInCompositeOfThree1 = sqliteTable('unique_column_in_composite_of_three_1', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+	slug: text('slug').notNull(),
+}, (t) => [
+	unique('custom_name3').on(t.id, t.name, t.slug),
+	unique('custom_name3_id').on(t.id),
+]);
diff --git a/drizzle-seed/tests/sqlite/cyclicTables/cyclicTables.test.ts b/drizzle-seed/tests/sqlite/cyclicTables/cyclicTables.test.ts
index d404072ebf..18af62b852 100644
--- a/drizzle-seed/tests/sqlite/cyclicTables/cyclicTables.test.ts
+++ b/drizzle-seed/tests/sqlite/cyclicTables/cyclicTables.test.ts
@@ -12,7 +12,7 @@ let db: BetterSQLite3Database;
 beforeAll(async () => {
 	client = new BetterSqlite3(':memory:');
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	db.run(
 		sql`
diff --git a/drizzle-seed/tests/sqlite/cyclicTables/sqliteSchema.ts b/drizzle-seed/tests/sqlite/cyclicTables/sqliteSchema.ts
index c9babadde7..10962560ad 100644
--- a/drizzle-seed/tests/sqlite/cyclicTables/sqliteSchema.ts
+++ b/drizzle-seed/tests/sqlite/cyclicTables/sqliteSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
 
diff --git a/drizzle-seed/tests/sqlite/softRelationsTest/softRelations.test.ts b/drizzle-seed/tests/sqlite/softRelationsTest/softRelations.test.ts
index 124ac8ee15..23b5148087 100644
--- a/drizzle-seed/tests/sqlite/softRelationsTest/softRelations.test.ts
+++ b/drizzle-seed/tests/sqlite/softRelationsTest/softRelations.test.ts
@@ -12,7 +12,7 @@ let db: BetterSQLite3Database;
 beforeAll(async () => {
 	client = new BetterSqlite3(':memory:');
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	db.run(
 		sql.raw(`
diff --git a/drizzle-seed/tests/sqlite/softRelationsTest/sqliteSchema.ts b/drizzle-seed/tests/sqlite/softRelationsTest/sqliteSchema.ts
index 75572c63a0..4930606843 100644
--- a/drizzle-seed/tests/sqlite/softRelationsTest/sqliteSchema.ts
+++ b/drizzle-seed/tests/sqlite/softRelationsTest/sqliteSchema.ts
@@ -1,4 +1,4 @@
-import { relations } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import { integer, numeric, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 
 export const customers = sqliteTable('customer', {
diff --git a/drizzle-seed/tests/sqlite/sqlite.test.ts b/drizzle-seed/tests/sqlite/sqlite.test.ts
index bf89284d57..3bdfb953d0 100644
--- a/drizzle-seed/tests/sqlite/sqlite.test.ts
+++ b/drizzle-seed/tests/sqlite/sqlite.test.ts
@@ -1,5 +1,6 @@
 import BetterSqlite3 from 'better-sqlite3';
-import { relations, sql } from 'drizzle-orm';
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { drizzle } from 'drizzle-orm/better-sqlite3';
 import { afterAll, afterEach, beforeAll, expect, test, vi } from 'vitest';
@@ -12,7 +13,7 @@ let db: BetterSQLite3Database;
 beforeAll(async () => {
 	client = new BetterSqlite3(':memory:');
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	db.run(
 		sql.raw(`
diff --git a/drizzle-seed/tests/sqlite/sqliteSchema.ts b/drizzle-seed/tests/sqlite/sqliteSchema.ts
index fe508321b5..ea88228c41 100644
--- a/drizzle-seed/tests/sqlite/sqliteSchema.ts
+++ b/drizzle-seed/tests/sqlite/sqliteSchema.ts
@@ -34,12 +34,10 @@ export const employees = sqliteTable(
 		reportsTo: integer('reports_to'),
 		photoPath: text('photo_path'),
 	},
-	(table) => ({
-		reportsToFk: foreignKey(() => ({
-			columns: [table.reportsTo],
-			foreignColumns: [table.id],
-		})),
-	}),
+	(table) => [foreignKey({
+		columns: [table.reportsTo],
+		foreignColumns: [table.id],
+	})],
 );
 
 export const orders = sqliteTable('order', {
@@ -113,12 +111,10 @@ export const users = sqliteTable(
 		name: text(),
 		invitedBy: integer(),
 	},
-	(table) => ({
-		reportsToFk: foreignKey(() => ({
-			columns: [table.invitedBy],
-			foreignColumns: [table.id],
-		})),
-	}),
+	(table) => [foreignKey({
+		columns: [table.invitedBy],
+		foreignColumns: [table.id],
+	})],
 );
 
 export const posts = sqliteTable(
diff --git a/drizzle-seed/tsconfig.build.json b/drizzle-seed/tsconfig.build.json
index 3377281baa..712ab85e0c 100644
--- a/drizzle-seed/tsconfig.build.json
+++ b/drizzle-seed/tsconfig.build.json
@@ -3,5 +3,5 @@
 	"compilerOptions": {
 		"rootDir": "src"
 	},
-	"include": ["src"]
+	"include": ["src", "!src/dev"]
 }
diff --git a/drizzle-seed/tsconfig.json b/drizzle-seed/tsconfig.json
index f32902e108..20dbe7ef9c 100644
--- a/drizzle-seed/tsconfig.json
+++ b/drizzle-seed/tsconfig.json
@@ -37,12 +37,8 @@
 		"noEmit": true,
 		"allowImportingTsExtensions": true,
 		"outDir": "dist",
-		"baseUrl": ".",
-		"declaration": true,
-		"paths": {
-			"~/*": ["src/*"]
-		}
+		"declaration": true
 	},
 	"exclude": ["**/dist", "src/dev"],
-	"include": ["src", "*.ts", "tests"]
+	"include": ["src", "tests", "type-tests"]
 }
diff --git a/drizzle-seed/tsdown.config.ts b/drizzle-seed/tsdown.config.ts
new file mode 100644
index 0000000000..eccf8e5513
--- /dev/null
+++ b/drizzle-seed/tsdown.config.ts
@@ -0,0 +1,24 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig([
+	{
+		entry: ['src/index.ts'],
+		outDir: 'dist',
+		format: ['esm'],
+		dts: true,
+		sourcemap: true,
+		clean: true,
+		external: [/^drizzle-orm\/?/, 'pure-rand'],
+		outExtensions: () => ({ js: '.mjs', dts: '.d.mts' }),
+	},
+	{
+		entry: ['src/index.ts'],
+		outDir: 'dist',
+		format: ['cjs'],
+		dts: true,
+		sourcemap: true,
+		clean: false,
+		external: [/^drizzle-orm\/?/, 'pure-rand'],
+		outExtensions: () => ({ js: '.cjs', dts: '.d.cts' }),
+	},
+]);
diff --git a/drizzle-seed/type-tests/cockroach.ts b/drizzle-seed/type-tests/cockroach.ts
new file mode 100644
index 0000000000..caf60929ad
--- /dev/null
+++ b/drizzle-seed/type-tests/cockroach.ts
@@ -0,0 +1,36 @@
+import { drizzle } from 'drizzle-orm/cockroach';
+import type { CockroachColumn } from 'drizzle-orm/cockroach-core';
+import { cockroachTable, int4, text } from 'drizzle-orm/cockroach-core';
+import { reset, seed } from '../src/index.ts';
+
+const cockroachUsers = cockroachTable('users', {
+	id: int4().primaryKey(),
+	name: text(),
+	inviteId: int4('invite_id').references((): CockroachColumn => cockroachUsers.id),
+});
+
+{
+	const db0 = drizzle('', { schema: { users: cockroachUsers } });
+
+	await seed(db0, { users: cockroachUsers });
+	await seed(db0, { users: cockroachUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: cockroachUsers });
+
+	const db1 = drizzle('');
+
+	await seed(db1, { users: cockroachUsers });
+	await seed(db1, { users: cockroachUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: cockroachUsers });
+}
diff --git a/drizzle-seed/type-tests/mssql.ts b/drizzle-seed/type-tests/mssql.ts
new file mode 100644
index 0000000000..a34cc56f1e
--- /dev/null
+++ b/drizzle-seed/type-tests/mssql.ts
@@ -0,0 +1,36 @@
+import type { MsSqlColumn } from 'drizzle-orm/mssql-core';
+import { int, mssqlTable, text } from 'drizzle-orm/mssql-core';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import { reset, seed } from '../src/index.ts';
+
+const mssqlUsers = mssqlTable('users', {
+	id: int().primaryKey(),
+	name: text(),
+	inviteId: int('invite_id').references((): MsSqlColumn => mssqlUsers.id),
+});
+
+{
+	const db0 = drizzle('', { schema: { users: mssqlUsers } });
+
+	await seed(db0, { users: mssqlUsers });
+	await seed(db0, { users: mssqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: mssqlUsers });
+
+	const db1 = drizzle('');
+
+	await seed(db1, { users: mssqlUsers });
+	await seed(db1, { users: mssqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: mssqlUsers });
+}
diff --git a/drizzle-seed/type-tests/mysql.ts b/drizzle-seed/type-tests/mysql.ts
index ffd42726de..7c1a958b38 100644
--- a/drizzle-seed/type-tests/mysql.ts
+++ b/drizzle-seed/type-tests/mysql.ts
@@ -1,6 +1,7 @@
 import type { MySqlColumn } from 'drizzle-orm/mysql-core';
 import { int, mysqlTable, text } from 'drizzle-orm/mysql-core';
 import { drizzle as mysql2Drizzle } from 'drizzle-orm/mysql2';
+import { drizzle as planetscaleDrizzle } from 'drizzle-orm/planetscale-serverless';
 import { reset, seed } from '../src/index.ts';
 
 const mysqlUsers = mysqlTable('users', {
@@ -9,9 +10,68 @@ const mysqlUsers = mysqlTable('users', {
 	inviteId: int('invite_id').references((): MySqlColumn => mysqlUsers.id),
 });
 
+// mysql2
 {
-	const db = mysql2Drizzle('');
+	const db0 = mysql2Drizzle('');
 
-	await seed(db, { users: mysqlUsers });
-	await reset(db, { users: mysqlUsers });
+	await seed(db0, { users: mysqlUsers });
+	await seed(db0, { users: mysqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: mysqlUsers });
+
+	const db1 = mysql2Drizzle('');
+
+	await seed(db1, { users: mysqlUsers });
+	await seed(db1, { users: mysqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: mysqlUsers });
+
+	const db2 = mysql2Drizzle('');
+
+	await seed(db2, { users: mysqlUsers });
+	await seed(db2, { users: mysqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db2, { users: mysqlUsers });
+}
+
+// planetscale
+{
+	const db0 = planetscaleDrizzle('');
+
+	await seed(db0, { users: mysqlUsers });
+	await seed(db0, { users: mysqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: mysqlUsers });
+
+	const db1 = planetscaleDrizzle('');
+
+	await seed(db1, { users: mysqlUsers });
+	await seed(db1, { users: mysqlUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: mysqlUsers });
 }
diff --git a/drizzle-seed/type-tests/pg.ts b/drizzle-seed/type-tests/pg.ts
index 3bec9989ff..077d56d1e2 100644
--- a/drizzle-seed/type-tests/pg.ts
+++ b/drizzle-seed/type-tests/pg.ts
@@ -11,38 +11,83 @@ const pgUsers = pgTable('users', {
 	inviteId: integer('invite_id').references((): PgColumn => pgUsers.id),
 });
 
+// node-postgres
 {
-	const db0 = nodePostgresDrizzle('', { schema: { users: pgUsers } });
+	const db0 = nodePostgresDrizzle('');
 
 	await seed(db0, { users: pgUsers });
+	await seed(db0, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db0, { users: pgUsers });
 
 	const db1 = nodePostgresDrizzle('');
 
 	await seed(db1, { users: pgUsers });
+	await seed(db1, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db1, { users: pgUsers });
 }
 
+// pglite
 {
-	const db0 = pgliteDrizzle('', { schema: { users: pgUsers } });
+	const db0 = pgliteDrizzle('');
 
 	await seed(db0, { users: pgUsers });
+	await seed(db0, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db0, { users: pgUsers });
 
 	const db1 = pgliteDrizzle('');
 
 	await seed(db1, { users: pgUsers });
+	await seed(db1, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db1, { users: pgUsers });
 }
 
+// postgres-js
 {
-	const db0 = postgresJsDrizzle('', { schema: { users: pgUsers } });
+	const db0 = postgresJsDrizzle('');
 
 	await seed(db0, { users: pgUsers });
+	await seed(db0, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db0, { users: pgUsers });
 
 	const db1 = postgresJsDrizzle('');
 
 	await seed(db1, { users: pgUsers });
+	await seed(db1, { users: pgUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
 	await reset(db1, { users: pgUsers });
 }
diff --git a/drizzle-seed/type-tests/singlestore.ts b/drizzle-seed/type-tests/singlestore.ts
new file mode 100644
index 0000000000..0085c8adfa
--- /dev/null
+++ b/drizzle-seed/type-tests/singlestore.ts
@@ -0,0 +1,35 @@
+import { drizzle } from 'drizzle-orm/singlestore';
+import { int, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { reset, seed } from '../src/index.ts';
+
+const singlestoreUsers = singlestoreTable('users', {
+	id: int().primaryKey(),
+	name: text(),
+	inviteId: int('invite_id'),
+});
+
+{
+	const db0 = drizzle('', { schema: { users: singlestoreUsers } });
+
+	await seed(db0, { users: singlestoreUsers });
+	await seed(db0, { users: singlestoreUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: singlestoreUsers });
+
+	const db1 = drizzle('');
+
+	await seed(db1, { users: singlestoreUsers });
+	await seed(db1, { users: singlestoreUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: singlestoreUsers });
+}
diff --git a/drizzle-seed/type-tests/sqlite.ts b/drizzle-seed/type-tests/sqlite.ts
index c9fa3d23bc..1565bb98d1 100644
--- a/drizzle-seed/type-tests/sqlite.ts
+++ b/drizzle-seed/type-tests/sqlite.ts
@@ -1,17 +1,82 @@
 import { drizzle as betterSqlite3Drizzle } from 'drizzle-orm/better-sqlite3';
+import { drizzle as libsqlDrizzle } from 'drizzle-orm/libsql';
 import type { SQLiteColumn } from 'drizzle-orm/sqlite-core';
 import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { reset, seed } from '../src/index.ts';
 
-const mysqlUsers = sqliteTable('users', {
+const sqliteUsers = sqliteTable('users', {
 	id: int().primaryKey(),
 	name: text(),
-	inviteId: int('invite_id').references((): SQLiteColumn => mysqlUsers.id),
+	inviteId: int('invite_id').references((): SQLiteColumn => sqliteUsers.id),
 });
 
 {
 	const db = betterSqlite3Drizzle('');
 
-	await seed(db, { users: mysqlUsers });
-	await reset(db, { users: mysqlUsers });
+	await seed(db, { users: sqliteUsers });
+	await reset(db, { users: sqliteUsers });
+}
+
+{
+	const db = libsqlDrizzle({
+		connection: {
+			url: 'libsql://testturso-oleksiikh0240.turso.io',
+		},
+	});
+
+	await reset(db, { sqliteUsers });
+
+	await seed(db, { sqliteUsers });
+}
+
+{
+	const db0 = betterSqlite3Drizzle('');
+
+	await seed(db0, { users: sqliteUsers });
+	await seed(db0, { users: sqliteUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: sqliteUsers });
+
+	const db1 = betterSqlite3Drizzle('');
+
+	await seed(db1, { users: sqliteUsers });
+	await seed(db1, { users: sqliteUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: sqliteUsers });
+}
+
+{
+	const db0 = libsqlDrizzle('');
+
+	await seed(db0, { users: sqliteUsers });
+	await seed(db0, { users: sqliteUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db0, { users: sqliteUsers });
+
+	const db1 = libsqlDrizzle('');
+
+	await seed(db1, { users: sqliteUsers });
+	await seed(db1, { users: sqliteUsers }).refine((funcs) => ({
+		users: {
+			columns: {
+				id: funcs.intPrimaryKey(),
+			},
+		},
+	}));
+	await reset(db1, { users: sqliteUsers });
 }
diff --git a/drizzle-seed/vitest.config.ts b/drizzle-seed/vitest.config.ts
index 5489010bde..23be3e2115 100644
--- a/drizzle-seed/vitest.config.ts
+++ b/drizzle-seed/vitest.config.ts
@@ -1,25 +1,28 @@
+import tsconfigPaths from 'vite-tsconfig-paths';
+// oxlint-disable-next-line extensions
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
 	test: {
 		include: [
+			'./tests/singlestore/**/*.test.ts',
+			'./tests/cockroach/**/*.test.ts',
+			'./tests/mssql/**/*.test.ts',
 			'./tests/pg/**/*.test.ts',
 			'./tests/mysql/**/*.test.ts',
 			'./tests/sqlite/**/*.test.ts',
 		],
-		exclude: [],
+		exclude: [
+			'./tests/singlestore/**/*.test.ts',
+		],
 		typecheck: {
 			tsconfig: 'tsconfig.json',
 		},
 		testTimeout: 100000,
 		hookTimeout: 100000,
 		isolate: true,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
 		maxWorkers: 1,
 		fileParallelism: false,
 	},
+	plugins: [tsconfigPaths()],
 });
diff --git a/drizzle-typebox/README.md b/drizzle-typebox/README.md
deleted file mode 100644
index 72d85e684b..0000000000
--- a/drizzle-typebox/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-`drizzle-typebox` is a plugin for [Drizzle ORM](https://github.com/drizzle-team/drizzle-orm) that allows you to generate [@sinclair/typebox](https://github.com/sinclairzx81/typebox) schemas from Drizzle ORM schemas.
-
-**Features**
-
-- Create a select schema for tables, views and enums.
-- Create insert and update schemas for tables.
-- Supports all dialects: PostgreSQL, MySQL and SQLite.
-
-# Usage
-
-```ts
-import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import { createInsertSchema, createSelectSchema } from 'drizzle-typebox';
-import { Type } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
-
-const users = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-	role: text('role', { enum: ['admin', 'user'] }).notNull(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-// Schema for inserting a user - can be used to validate API requests
-const insertUserSchema = createInsertSchema(users);
-
-// Schema for updating a user - can be used to validate API requests
-const updateUserSchema = createUpdateSchema(users);
-
-// Schema for selecting a user - can be used to validate API responses
-const selectUserSchema = createSelectSchema(users);
-
-// Overriding the fields
-const insertUserSchema = createInsertSchema(users, {
-	role: Type.String(),
-});
-
-// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
-const insertUserSchema = createInsertSchema(users, {
-	id: (schema) => Type.Number({ ...schema, minimum: 0 }),
-	role: Type.String(),
-});
-
-// Usage
-
-const isUserValid: boolean = Value.Check(insertUserSchema, {
-	name: 'John Doe',
-	email: 'johndoe@test.com',
-	role: 'admin',
-});
-```
diff --git a/drizzle-typebox/package.json b/drizzle-typebox/package.json
deleted file mode 100644
index 59a4b7662b..0000000000
--- a/drizzle-typebox/package.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-	"name": "drizzle-typebox",
-	"version": "0.3.3",
-	"description": "Generate Typebox schemas from Drizzle ORM schemas",
-	"type": "module",
-	"scripts": {
-		"build": "tsx scripts/build.ts",
-		"b": "pnpm build",
-		"test:types": "cd tests && tsc",
-		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
-		"publish": "npm publish package.tgz",
-		"test": "vitest run"
-	},
-	"exports": {
-		".": {
-			"import": {
-				"types": "./index.d.mts",
-				"default": "./index.mjs"
-			},
-			"require": {
-				"types": "./index.d.cjs",
-				"default": "./index.cjs"
-			},
-			"types": "./index.d.ts",
-			"default": "./index.mjs"
-		}
-	},
-	"main": "./index.cjs",
-	"module": "./index.mjs",
-	"types": "./index.d.ts",
-	"publishConfig": {
-		"provenance": true
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/drizzle-team/drizzle-orm.git"
-	},
-	"keywords": [
-		"typebox",
-		"validate",
-		"validation",
-		"schema",
-		"drizzle",
-		"orm",
-		"pg",
-		"mysql",
-		"postgresql",
-		"postgres",
-		"sqlite",
-		"database",
-		"sql",
-		"typescript",
-		"ts"
-	],
-	"author": "Drizzle Team",
-	"license": "Apache-2.0",
-	"peerDependencies": {
-		"@sinclair/typebox": ">=0.34.8",
-		"drizzle-orm": ">=0.36.0"
-	},
-	"devDependencies": {
-		"@rollup/plugin-typescript": "^11.1.0",
-		"@sinclair/typebox": "^0.34.8",
-		"@types/node": "^18.15.10",
-		"cpy": "^10.1.0",
-		"drizzle-orm": "link:../drizzle-orm/dist",
-		"json-rules-engine": "^7.3.1",
-		"rimraf": "^5.0.0",
-		"rollup": "^3.29.5",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
-		"zx": "^7.2.2"
-	}
-}
diff --git a/drizzle-typebox/rollup.config.ts b/drizzle-typebox/rollup.config.ts
deleted file mode 100644
index a29fdd38a8..0000000000
--- a/drizzle-typebox/rollup.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-export default defineConfig([
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				format: 'esm',
-				dir: 'dist',
-				entryFileNames: '[name].mjs',
-				chunkFileNames: '[name]-[hash].mjs',
-				sourcemap: true,
-			},
-			{
-				format: 'cjs',
-				dir: 'dist',
-				entryFileNames: '[name].cjs',
-				chunkFileNames: '[name]-[hash].cjs',
-				sourcemap: true,
-			},
-		],
-		external: [
-			/^drizzle-orm\/?/,
-			'@sinclair/typebox',
-		],
-		plugins: [
-			typescript({
-				tsconfig: 'tsconfig.build.json',
-			}),
-		],
-	},
-]);
diff --git a/drizzle-typebox/scripts/build.ts b/drizzle-typebox/scripts/build.ts
deleted file mode 100644
index 07330ffd0a..0000000000
--- a/drizzle-typebox/scripts/build.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
-
-await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await fs.copy('package.json', 'dist/package.json');
-await $`scripts/fix-imports.ts`;
diff --git a/drizzle-typebox/scripts/fix-imports.ts b/drizzle-typebox/scripts/fix-imports.ts
deleted file mode 100755
index a90057c5b9..0000000000
--- a/drizzle-typebox/scripts/fix-imports.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-
-import path from 'node:path';
-import { parse, print, visit } from 'recast';
-import parser from 'recast/parsers/typescript';
-
-function resolvePathAlias(importPath: string, file: string) {
-	if (importPath.startsWith('~/')) {
-		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
-		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
-	}
-
-	return importPath;
-}
-
-function fixImportPath(importPath: string, file: string, ext: string) {
-	importPath = resolvePathAlias(importPath, file);
-
-	if (!/\..*\.(js|ts)$/.test(importPath)) {
-		return importPath;
-	}
-
-	return importPath.replace(/\.(js|ts)$/, ext);
-}
-
-const cjsFiles = await glob('dist/**/*.{cjs,d.cts}');
-
-await Promise.all(cjsFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitCallExpression(path) {
-			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
-				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-let esmFiles = await glob('dist/**/*.{js,d.ts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.js');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-esmFiles = await glob('dist/**/*.{mjs,d.mts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
diff --git a/drizzle-typebox/src/column.ts b/drizzle-typebox/src/column.ts
deleted file mode 100644
index 56466eaad5..0000000000
--- a/drizzle-typebox/src/column.ts
+++ /dev/null
@@ -1,314 +0,0 @@
-import { Kind, Type as t, TypeRegistry } from '@sinclair/typebox';
-import type { StringOptions, TSchema, Type as typebox } from '@sinclair/typebox';
-import type { Column, ColumnBaseConfig } from 'drizzle-orm';
-import type {
-	MySqlBigInt53,
-	MySqlChar,
-	MySqlDouble,
-	MySqlFloat,
-	MySqlInt,
-	MySqlMediumInt,
-	MySqlReal,
-	MySqlSerial,
-	MySqlSmallInt,
-	MySqlText,
-	MySqlTinyInt,
-	MySqlVarChar,
-	MySqlYear,
-} from 'drizzle-orm/mysql-core';
-import type {
-	PgArray,
-	PgBigInt53,
-	PgBigSerial53,
-	PgBinaryVector,
-	PgChar,
-	PgDoublePrecision,
-	PgGeometry,
-	PgGeometryObject,
-	PgHalfVector,
-	PgInteger,
-	PgLineABC,
-	PgLineTuple,
-	PgPointObject,
-	PgPointTuple,
-	PgReal,
-	PgSerial,
-	PgSmallInt,
-	PgSmallSerial,
-	PgUUID,
-	PgVarchar,
-	PgVector,
-} from 'drizzle-orm/pg-core';
-import type {
-	SingleStoreBigInt53,
-	SingleStoreChar,
-	SingleStoreDouble,
-	SingleStoreFloat,
-	SingleStoreInt,
-	SingleStoreMediumInt,
-	SingleStoreReal,
-	SingleStoreSerial,
-	SingleStoreSmallInt,
-	SingleStoreText,
-	SingleStoreTinyInt,
-	SingleStoreVarChar,
-	SingleStoreYear,
-} from 'drizzle-orm/singlestore-core';
-import type { SQLiteInteger, SQLiteReal, SQLiteText } from 'drizzle-orm/sqlite-core';
-import { CONSTANTS } from './constants.ts';
-import { isColumnType, isWithEnum } from './utils.ts';
-import type { BufferSchema, JsonSchema } from './utils.ts';
-
-export const literalSchema = t.Union([t.String(), t.Number(), t.Boolean(), t.Null()]);
-export const jsonSchema: JsonSchema = t.Union([literalSchema, t.Array(t.Any()), t.Record(t.String(), t.Any())]) as any;
-TypeRegistry.Set('Buffer', (_, value) => value instanceof Buffer); // eslint-disable-line no-instanceof/no-instanceof
-export const bufferSchema: BufferSchema = { [Kind]: 'Buffer', type: 'buffer' } as any;
-
-export function mapEnumValues(values: string[]) {
-	return Object.fromEntries(values.map((value) => [value, value]));
-}
-
-export function columnToSchema(column: Column, t: typeof typebox): TSchema {
-	let schema!: TSchema;
-
-	if (isWithEnum(column)) {
-		schema = column.enumValues.length ? t.Enum(mapEnumValues(column.enumValues)) : t.String();
-	}
-
-	if (!schema) {
-		// Handle specific types
-		if (isColumnType<PgGeometry<any> | PgPointTuple<any>>(column, ['PgGeometry', 'PgPointTuple'])) {
-			schema = t.Tuple([t.Number(), t.Number()]);
-		} else if (
-			isColumnType<PgPointObject<any> | PgGeometryObject<any>>(column, ['PgGeometryObject', 'PgPointObject'])
-		) {
-			schema = t.Object({ x: t.Number(), y: t.Number() });
-		} else if (isColumnType<PgHalfVector<any> | PgVector<any>>(column, ['PgHalfVector', 'PgVector'])) {
-			schema = t.Array(
-				t.Number(),
-				column.dimensions
-					? {
-						minItems: column.dimensions,
-						maxItems: column.dimensions,
-					}
-					: undefined,
-			);
-		} else if (isColumnType<PgLineTuple<any>>(column, ['PgLine'])) {
-			schema = t.Tuple([t.Number(), t.Number(), t.Number()]);
-		} else if (isColumnType<PgLineABC<any>>(column, ['PgLineABC'])) {
-			schema = t.Object({
-				a: t.Number(),
-				b: t.Number(),
-				c: t.Number(),
-			});
-		} // Handle other types
-		else if (isColumnType<PgArray<any, any>>(column, ['PgArray'])) {
-			schema = t.Array(
-				columnToSchema(column.baseColumn, t),
-				column.size
-					? {
-						minItems: column.size,
-						maxItems: column.size,
-					}
-					: undefined,
-			);
-		} else if (column.dataType === 'array') {
-			schema = t.Array(t.Any());
-		} else if (column.dataType === 'number') {
-			schema = numberColumnToSchema(column, t);
-		} else if (column.dataType === 'bigint') {
-			schema = bigintColumnToSchema(column, t);
-		} else if (column.dataType === 'boolean') {
-			schema = t.Boolean();
-		} else if (column.dataType === 'date') {
-			schema = t.Date();
-		} else if (column.dataType === 'string') {
-			schema = stringColumnToSchema(column, t);
-		} else if (column.dataType === 'json') {
-			schema = jsonSchema;
-		} else if (column.dataType === 'custom') {
-			schema = t.Any();
-		} else if (column.dataType === 'buffer') {
-			schema = bufferSchema;
-		}
-	}
-
-	if (!schema) {
-		schema = t.Any();
-	}
-
-	return schema;
-}
-
-function numberColumnToSchema(column: Column, t: typeof typebox): TSchema {
-	let unsigned = column.getSQLType().includes('unsigned');
-	let min!: number;
-	let max!: number;
-	let integer = false;
-
-	if (isColumnType<MySqlTinyInt<any> | SingleStoreTinyInt<any>>(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
-		min = unsigned ? 0 : CONSTANTS.INT8_MIN;
-		max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
-		integer = true;
-	} else if (
-		isColumnType<PgSmallInt<any> | PgSmallSerial<any> | MySqlSmallInt<any> | SingleStoreSmallInt<any>>(column, [
-			'PgSmallInt',
-			'PgSmallSerial',
-			'MySqlSmallInt',
-			'SingleStoreSmallInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT16_MIN;
-		max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			PgReal<any> | MySqlFloat<any> | MySqlMediumInt<any> | SingleStoreFloat<any> | SingleStoreMediumInt<any>
-		>(column, [
-			'PgReal',
-			'MySqlFloat',
-			'MySqlMediumInt',
-			'SingleStoreFloat',
-			'SingleStoreMediumInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT24_MIN;
-		max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
-		integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
-	} else if (
-		isColumnType<PgInteger<any> | PgSerial<any> | MySqlInt<any> | SingleStoreInt<any>>(column, [
-			'PgInteger',
-			'PgSerial',
-			'MySqlInt',
-			'SingleStoreInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT32_MIN;
-		max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			| PgDoublePrecision<any>
-			| MySqlReal<any>
-			| MySqlDouble<any>
-			| SingleStoreReal<any>
-			| SingleStoreDouble<any>
-			| SQLiteReal<any>
-		>(column, [
-			'PgDoublePrecision',
-			'MySqlReal',
-			'MySqlDouble',
-			'SingleStoreReal',
-			'SingleStoreDouble',
-			'SQLiteReal',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT48_MIN;
-		max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
-	} else if (
-		isColumnType<
-			| PgBigInt53<any>
-			| PgBigSerial53<any>
-			| MySqlBigInt53<any>
-			| MySqlSerial<any>
-			| SingleStoreBigInt53<any>
-			| SingleStoreSerial<any>
-			| SQLiteInteger<any>
-		>(
-			column,
-			[
-				'PgBigInt53',
-				'PgBigSerial53',
-				'MySqlBigInt53',
-				'MySqlSerial',
-				'SingleStoreBigInt53',
-				'SingleStoreSerial',
-				'SQLiteInteger',
-			],
-		)
-	) {
-		unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
-		min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-		integer = true;
-	} else if (isColumnType<MySqlYear<any> | SingleStoreYear<any>>(column, ['MySqlYear', 'SingleStoreYear'])) {
-		min = 1901;
-		max = 2155;
-		integer = true;
-	} else {
-		min = Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-	}
-
-	const key = integer ? 'Integer' : 'Number';
-	return t[key]({
-		minimum: min,
-		maximum: max,
-	});
-}
-
-function bigintColumnToSchema(column: Column, t: typeof typebox): TSchema {
-	const unsigned = column.getSQLType().includes('unsigned');
-	const min = unsigned ? 0n : CONSTANTS.INT64_MIN;
-	const max = unsigned ? CONSTANTS.INT64_UNSIGNED_MAX : CONSTANTS.INT64_MAX;
-
-	return t.BigInt({
-		minimum: min,
-		maximum: max,
-	});
-}
-
-function stringColumnToSchema(column: Column, t: typeof typebox): TSchema {
-	if (isColumnType<PgUUID<ColumnBaseConfig<'string', 'PgUUID'>>>(column, ['PgUUID'])) {
-		return t.String({ format: 'uuid' });
-	} else if (
-		isColumnType<PgBinaryVector<ColumnBaseConfig<'string', 'PgBinaryVector'> & { dimensions: number }>>(column, [
-			'PgBinaryVector',
-		])
-	) {
-		return t.RegExp(/^[01]+$/, column.dimensions ? { maxLength: column.dimensions } : undefined);
-	}
-
-	let max: number | undefined;
-	let fixed = false;
-
-	if (isColumnType<PgVarchar<any> | SQLiteText<any>>(column, ['PgVarchar', 'SQLiteText'])) {
-		max = column.length;
-	} else if (
-		isColumnType<MySqlVarChar<any> | SingleStoreVarChar<any>>(column, ['MySqlVarChar', 'SingleStoreVarChar'])
-	) {
-		max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
-	} else if (isColumnType<MySqlText<any> | SingleStoreText<any>>(column, ['MySqlText', 'SingleStoreText'])) {
-		if (column.textType === 'longtext') {
-			max = CONSTANTS.INT32_UNSIGNED_MAX;
-		} else if (column.textType === 'mediumtext') {
-			max = CONSTANTS.INT24_UNSIGNED_MAX;
-		} else if (column.textType === 'text') {
-			max = CONSTANTS.INT16_UNSIGNED_MAX;
-		} else {
-			max = CONSTANTS.INT8_UNSIGNED_MAX;
-		}
-	}
-
-	if (
-		isColumnType<PgChar<any> | MySqlChar<any> | SingleStoreChar<any>>(column, [
-			'PgChar',
-			'MySqlChar',
-			'SingleStoreChar',
-		])
-	) {
-		max = column.length;
-		fixed = true;
-	}
-
-	const options: Partial<StringOptions> = {};
-
-	if (max !== undefined && fixed) {
-		options.minLength = max;
-		options.maxLength = max;
-	} else if (max !== undefined) {
-		options.maxLength = max;
-	}
-
-	return t.String(Object.keys(options).length > 0 ? options : undefined);
-}
diff --git a/drizzle-typebox/src/column.types.ts b/drizzle-typebox/src/column.types.ts
deleted file mode 100644
index 5ff9b4bcf7..0000000000
--- a/drizzle-typebox/src/column.types.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import type * as t from '@sinclair/typebox';
-import type { Assume, Column } from 'drizzle-orm';
-import type { BufferSchema, IsEnumDefined, IsNever, JsonSchema } from './utils.ts';
-
-type HasBaseColumn<TColumn> = TColumn extends { _: { baseColumn: Column | undefined } }
-	? IsNever<TColumn['_']['baseColumn']> extends false ? true
-	: false
-	: false;
-
-export type EnumValuesToEnum<TEnumValues extends [string, ...string[]]> = { [K in TEnumValues[number]]: K };
-
-export interface GenericSchema<T> extends t.TSchema {
-	static: T;
-}
-
-export type GetTypeboxType<
-	TColumn extends Column,
-> = TColumn['_']['columnType'] extends
-	| 'MySqlTinyInt'
-	| 'SingleStoreTinyInt'
-	| 'PgSmallInt'
-	| 'PgSmallSerial'
-	| 'MySqlSmallInt'
-	| 'MySqlMediumInt'
-	| 'SingleStoreSmallInt'
-	| 'SingleStoreMediumInt'
-	| 'PgInteger'
-	| 'PgSerial'
-	| 'MySqlInt'
-	| 'SingleStoreInt'
-	| 'PgBigInt53'
-	| 'PgBigSerial53'
-	| 'MySqlBigInt53'
-	| 'MySqlSerial'
-	| 'SingleStoreBigInt53'
-	| 'SingleStoreSerial'
-	| 'SQLiteInteger'
-	| 'MySqlYear'
-	| 'SingleStoreYear' ? t.TInteger
-	: TColumn['_']['columnType'] extends 'PgBinaryVector' ? t.TRegExp
-	: HasBaseColumn<TColumn> extends true ? t.TArray<
-			GetTypeboxType<Assume<TColumn['_']['baseColumn'], Column>>
-		>
-	: IsEnumDefined<TColumn['_']['enumValues']> extends true
-		? t.TEnum<{ [K in Assume<TColumn['_']['enumValues'], string[]>[number]]: K }>
-	: TColumn['_']['columnType'] extends 'PgGeometry' | 'PgPointTuple' ? t.TTuple<[t.TNumber, t.TNumber]>
-	: TColumn['_']['columnType'] extends 'PgLine' ? t.TTuple<[t.TNumber, t.TNumber, t.TNumber]>
-	: TColumn['_']['data'] extends Date ? t.TDate
-	: TColumn['_']['data'] extends Buffer ? BufferSchema
-	: TColumn['_']['dataType'] extends 'array'
-		? t.TArray<GetTypeboxPrimitiveType<Assume<TColumn['_']['data'], any[]>[number]>>
-	: TColumn['_']['data'] extends Record<string, any>
-		? TColumn['_']['columnType'] extends
-			'PgJson' | 'PgJsonb' | 'MySqlJson' | 'SingleStoreJson' | 'SQLiteTextJson' | 'SQLiteBlobJson'
-			? GenericSchema<TColumn['_']['data']>
-		: t.TObject<{ [K in keyof TColumn['_']['data']]: GetTypeboxPrimitiveType<TColumn['_']['data'][K]> }>
-	: TColumn['_']['dataType'] extends 'json' ? JsonSchema
-	: GetTypeboxPrimitiveType<TColumn['_']['data']>;
-
-type GetTypeboxPrimitiveType<TData> = TData extends number ? t.TNumber
-	: TData extends bigint ? t.TBigInt
-	: TData extends boolean ? t.TBoolean
-	: TData extends string ? t.TString
-	: t.TAny;
-
-type HandleSelectColumn<
-	TSchema extends t.TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TSchema
-	: t.Union<[TSchema, t.TNull]>;
-
-type HandleInsertColumn<
-	TSchema extends t.TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? t.TOptional<TSchema>
-	: TSchema
-	: t.TOptional<t.Union<[TSchema, t.TNull]>>;
-
-type HandleUpdateColumn<
-	TSchema extends t.TSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? t.TOptional<TSchema>
-	: t.TOptional<t.Union<[TSchema, t.TNull]>>;
-
-export type HandleColumn<
-	TType extends 'select' | 'insert' | 'update',
-	TColumn extends Column,
-> = TType extends 'select' ? HandleSelectColumn<GetTypeboxType<TColumn>, TColumn>
-	: TType extends 'insert' ? HandleInsertColumn<GetTypeboxType<TColumn>, TColumn>
-	: TType extends 'update' ? HandleUpdateColumn<GetTypeboxType<TColumn>, TColumn>
-	: GetTypeboxType<TColumn>;
diff --git a/drizzle-typebox/src/constants.ts b/drizzle-typebox/src/constants.ts
deleted file mode 100644
index 99f5d7a422..0000000000
--- a/drizzle-typebox/src/constants.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-export const CONSTANTS = {
-	INT8_MIN: -128,
-	INT8_MAX: 127,
-	INT8_UNSIGNED_MAX: 255,
-	INT16_MIN: -32768,
-	INT16_MAX: 32767,
-	INT16_UNSIGNED_MAX: 65535,
-	INT24_MIN: -8388608,
-	INT24_MAX: 8388607,
-	INT24_UNSIGNED_MAX: 16777215,
-	INT32_MIN: -2147483648,
-	INT32_MAX: 2147483647,
-	INT32_UNSIGNED_MAX: 4294967295,
-	INT48_MIN: -140737488355328,
-	INT48_MAX: 140737488355327,
-	INT48_UNSIGNED_MAX: 281474976710655,
-	INT64_MIN: -9223372036854775808n,
-	INT64_MAX: 9223372036854775807n,
-	INT64_UNSIGNED_MAX: 18446744073709551615n,
-};
diff --git a/drizzle-typebox/src/index.ts b/drizzle-typebox/src/index.ts
deleted file mode 100644
index 225d3e880f..0000000000
--- a/drizzle-typebox/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export { bufferSchema, jsonSchema, literalSchema } from './column.ts';
-export * from './column.types.ts';
-export * from './schema.ts';
-export * from './schema.types.internal.ts';
-export * from './schema.types.ts';
-export * from './utils.ts';
diff --git a/drizzle-typebox/src/schema.ts b/drizzle-typebox/src/schema.ts
deleted file mode 100644
index 266fe77400..0000000000
--- a/drizzle-typebox/src/schema.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { Type as t } from '@sinclair/typebox';
-import type { TSchema } from '@sinclair/typebox';
-import { Column, getTableColumns, getViewSelectedFields, is, isTable, isView, SQL } from 'drizzle-orm';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import { columnToSchema, mapEnumValues } from './column.ts';
-import type { Conditions } from './schema.types.internal.ts';
-import type {
-	CreateInsertSchema,
-	CreateSchemaFactoryOptions,
-	CreateSelectSchema,
-	CreateUpdateSchema,
-} from './schema.types.ts';
-import { isPgEnum } from './utils.ts';
-
-export function getColumns(tableLike: Table | View) {
-	return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
-}
-
-export function handleColumns(
-	columns: Record<string, any>,
-	refinements: Record<string, any>,
-	conditions: Conditions,
-	factory?: CreateSchemaFactoryOptions,
-): TSchema {
-	const columnSchemas: Record<string, TSchema> = {};
-
-	for (const [key, selected] of Object.entries(columns)) {
-		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
-			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
-			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
-			continue;
-		}
-
-		const refinement = refinements[key];
-		if (refinement !== undefined && typeof refinement !== 'function') {
-			columnSchemas[key] = refinement;
-			continue;
-		}
-
-		const column = is(selected, Column) ? selected : undefined;
-		const schema = column ? columnToSchema(column, factory?.typeboxInstance ?? t) : t.Any();
-		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
-
-		if (conditions.never(column)) {
-			continue;
-		} else {
-			columnSchemas[key] = refined;
-		}
-
-		if (column) {
-			if (conditions.nullable(column)) {
-				columnSchemas[key] = t.Union([columnSchemas[key]!, t.Null()]);
-			}
-
-			if (conditions.optional(column)) {
-				columnSchemas[key] = t.Optional(columnSchemas[key]!);
-			}
-		}
-	}
-
-	return t.Object(columnSchemas) as any;
-}
-
-export function handleEnum(enum_: PgEnum<any>, factory?: CreateSchemaFactoryOptions) {
-	const typebox: typeof t = factory?.typeboxInstance ?? t;
-	return typebox.Enum(mapEnumValues(enum_.enumValues));
-}
-
-const selectConditions: Conditions = {
-	never: () => false,
-	optional: () => false,
-	nullable: (column) => !column.notNull,
-};
-
-const insertConditions: Conditions = {
-	never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
-	nullable: (column) => !column.notNull,
-};
-
-const updateConditions: Conditions = {
-	never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-	optional: () => true,
-	nullable: (column) => !column.notNull,
-};
-
-export const createSelectSchema: CreateSelectSchema = (
-	entity: Table | View | PgEnum<[string, ...string[]]>,
-	refine?: Record<string, any>,
-) => {
-	if (isPgEnum(entity)) {
-		return handleEnum(entity);
-	}
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, selectConditions) as any;
-};
-
-export const createInsertSchema: CreateInsertSchema = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, insertConditions) as any;
-};
-
-export const createUpdateSchema: CreateUpdateSchema = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, updateConditions) as any;
-};
-
-export function createSchemaFactory(options?: CreateSchemaFactoryOptions) {
-	const createSelectSchema: CreateSelectSchema = (
-		entity: Table | View | PgEnum<[string, ...string[]]>,
-		refine?: Record<string, any>,
-	) => {
-		if (isPgEnum(entity)) {
-			return handleEnum(entity, options);
-		}
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, selectConditions, options) as any;
-	};
-
-	const createInsertSchema: CreateInsertSchema = (
-		entity: Table,
-		refine?: Record<string, any>,
-	) => {
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, insertConditions, options) as any;
-	};
-
-	const createUpdateSchema: CreateUpdateSchema = (
-		entity: Table,
-		refine?: Record<string, any>,
-	) => {
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, updateConditions, options) as any;
-	};
-
-	return { createSelectSchema, createInsertSchema, createUpdateSchema };
-}
diff --git a/drizzle-typebox/src/schema.types.internal.ts b/drizzle-typebox/src/schema.types.internal.ts
deleted file mode 100644
index 9cd1b9a7c9..0000000000
--- a/drizzle-typebox/src/schema.types.internal.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import type * as t from '@sinclair/typebox';
-import type { Assume, Column, DrizzleTypeError, SelectedFieldsFlat, Simplify, Table, View } from 'drizzle-orm';
-import type { GetTypeboxType, HandleColumn } from './column.types.ts';
-import type { ColumnIsGeneratedAlwaysAs, GetSelection } from './utils.ts';
-
-export interface Conditions {
-	never: (column?: Column) => boolean;
-	optional: (column: Column) => boolean;
-	nullable: (column: Column) => boolean;
-}
-
-type BuildRefineField<T> = T extends t.TSchema ? ((schema: T) => t.TSchema) | t.TSchema : never;
-
-export type BuildRefine<
-	TColumns extends Record<string, any>,
-> = {
-	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
-		TColumns[K] extends Column ? BuildRefineField<GetTypeboxType<TColumns[K]>>
-			: BuildRefine<GetSelection<TColumns[K]>>;
-};
-
-type HandleRefinement<
-	TType extends 'select' | 'insert' | 'update',
-	TRefinement,
-	TColumn extends Column,
-> = TRefinement extends (schema: any) => t.TSchema ? (TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
-		: t.TUnion<[ReturnType<TRefinement>, t.TNull]>) extends infer TSchema
-		? TType extends 'update' ? t.TOptional<Assume<TSchema, t.TSchema>> : TSchema
-	: t.TSchema
-	: TRefinement;
-
-type IsRefinementDefined<
-	TRefinements extends Record<string | symbol | number, any> | undefined,
-	TKey extends string | symbol | number,
-> = TRefinements extends object ? TRefinements[TKey] extends t.TSchema | ((schema: any) => any) ? true
-	: false
-	: false;
-
-export type BuildSchema<
-	TType extends 'select' | 'insert' | 'update',
-	TColumns extends Record<string, any>,
-	TRefinements extends Record<string, any> | undefined,
-> = t.TObject<
-	Simplify<
-		{
-			[K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? never : K]: TColumns[K] extends
-				infer TColumn extends Column
-				? IsRefinementDefined<TRefinements, K> extends true
-					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, t.TSchema>
-				: HandleColumn<TType, TColumn>
-				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
-						TType,
-						GetSelection<TObject>,
-						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
-					>
-				: t.TAny;
-		}
-	>
->;
-
-export type NoUnknownKeys<
-	TRefinement extends Record<string, any>,
-	TCompare extends Record<string, any>,
-> = {
-	[K in keyof TRefinement]: K extends keyof TCompare ? TRefinement[K] extends t.TSchema ? TRefinement[K]
-		: TRefinement[K] extends Record<string, t.TSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
-		: TRefinement[K]
-		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
-};
diff --git a/drizzle-typebox/src/schema.types.ts b/drizzle-typebox/src/schema.types.ts
deleted file mode 100644
index abbb4f8ebb..0000000000
--- a/drizzle-typebox/src/schema.types.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type * as t from '@sinclair/typebox';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { EnumValuesToEnum } from './column.types.ts';
-import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
-
-export interface CreateSelectSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<TTable['_']['columns']>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferSelect']>,
-	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
-
-	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
-	<
-		TView extends View,
-		TRefine extends BuildRefine<TView['_']['selectedFields']>,
-	>(
-		view: TView,
-		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
-	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
-
-	<TEnum extends PgEnum<any>>(enum_: TEnum): t.TEnum<EnumValuesToEnum<TEnum['enumValues']>>;
-}
-
-export interface CreateInsertSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferInsert']>,
-	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
-}
-
-export interface CreateUpdateSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: TRefine,
-	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
-}
-
-export interface CreateSchemaFactoryOptions {
-	typeboxInstance?: any;
-}
diff --git a/drizzle-typebox/src/utils.ts b/drizzle-typebox/src/utils.ts
deleted file mode 100644
index 36e8d1aef1..0000000000
--- a/drizzle-typebox/src/utils.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import type { Kind, Static, TSchema } from '@sinclair/typebox';
-import type { Column, SelectedFieldsFlat, Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { literalSchema } from './column.ts';
-
-export function isColumnType<T extends Column>(column: Column, columnTypes: string[]): column is T {
-	return columnTypes.includes(column.columnType);
-}
-
-export function isWithEnum(column: Column): column is typeof column & { enumValues: [string, ...string[]] } {
-	return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
-}
-
-export const isPgEnum: (entity: any) => entity is PgEnum<[string, ...string[]]> = isWithEnum as any;
-
-type Literal = Static<typeof literalSchema>;
-export type Json = Literal | { [key: string]: any } | any[];
-export interface JsonSchema extends TSchema {
-	[Kind]: 'Union';
-	static: Json;
-	anyOf: Json;
-}
-export interface BufferSchema extends TSchema {
-	[Kind]: 'Buffer';
-	static: Buffer;
-	type: 'buffer';
-}
-
-export type IsNever<T> = [T] extends [never] ? true : false;
-
-export type IsEnumDefined<TEnum extends string[] | undefined> = [string, ...string[]] extends TEnum ? false
-	: undefined extends TEnum ? false
-	: true;
-
-export type ColumnIsGeneratedAlwaysAs<TColumn> = TColumn extends Column
-	? TColumn['_']['identity'] extends 'always' ? true
-	: TColumn['_']['generated'] extends { type: 'byDefault' } | undefined ? false
-	: true
-	: false;
-
-export type GetSelection<T extends SelectedFieldsFlat<Column> | Table | View> = T extends Table ? T['_']['columns']
-	: T extends View ? T['_']['selectedFields']
-	: T;
diff --git a/drizzle-typebox/tests/mysql.test.ts b/drizzle-typebox/tests/mysql.test.ts
deleted file mode 100644
index 8b01255f4d..0000000000
--- a/drizzle-typebox/tests/mysql.test.ts
+++ /dev/null
@@ -1,508 +0,0 @@
-import { type Static, Type as t } from '@sinclair/typebox';
-import { type Equal, sql } from 'drizzle-orm';
-import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema, type GenericSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = t.Integer({
-	minimum: CONSTANTS.INT32_MIN,
-	maximum: CONSTANTS.INT32_MAX,
-});
-const serialNumberModeSchema = t.Integer({
-	minimum: 0,
-	maximum: Number.MAX_SAFE_INTEGER,
-});
-const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
-
-test('table - select', (tc) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = mysqlSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (tc) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		id: t.Optional(serialNumberModeSchema),
-		name: textSchema,
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (tc) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		id: t.Optional(serialNumberModeSchema),
-		name: t.Optional(textSchema),
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (tc) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: serialNumberModeSchema, age: t.Any() });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (tc) => {
-	const view = mysqlView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (tc) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({
-		id: serialNumberModeSchema,
-		nested: t.Object({ name: textSchema, age: t.Any() }),
-		table: t.Object({ id: serialNumberModeSchema, name: textSchema }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: intSchema,
-		c3: t.Union([intSchema, t.Null()]),
-		c4: intSchema,
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: intSchema,
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(intSchema),
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (tc) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 })),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (tc) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: {
-			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-		table: {
-			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: t.Object({
-			c4: t.Union([intSchema, t.Null()]),
-			c5: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		}),
-		table: t.Object({
-			c1: t.Union([intSchema, t.Null()]),
-			c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-			c4: t.Union([intSchema, t.Null()]),
-			c5: t.Union([intSchema, t.Null()]),
-			c6: t.Union([intSchema, t.Null()]),
-		}),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (tc) => {
-	const table = mysqlTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		mysqlEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
-		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
-		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
-		binary: t.String(),
-		boolean: t.Boolean(),
-		char1: t.String({ minLength: 10, maxLength: 10 }),
-		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		date1: t.Date(),
-		date2: t.String(),
-		datetime1: t.Date(),
-		datetime2: t.String(),
-		decimal1: t.String(),
-		decimal2: t.String(),
-		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
-		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
-		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
-		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
-		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
-		json: jsonSchema,
-		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
-		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
-		enum: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
-		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
-		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
-		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		time: t.String(),
-		timestamp1: t.Date(),
-		timestamp2: t.String(),
-		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
-		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
-		varchar1: t.String({ maxLength: 10 }),
-		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		varbinary: t.String(),
-		year: t.Integer({ minimum: 1901, maximum: 2155 }),
-		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
-		longtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
-		mediumtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
-		tinytext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
-	const table = mysqlTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		json: t.Union([TopLevelCondition, t.Null()]),
-	});
-	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = mysqlTable('test', { id: int() });
-	const view = mysqlView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = mysqlView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-}
diff --git a/drizzle-typebox/tests/pg.test.ts b/drizzle-typebox/tests/pg.test.ts
deleted file mode 100644
index 7b05a04353..0000000000
--- a/drizzle-typebox/tests/pg.test.ts
+++ /dev/null
@@ -1,557 +0,0 @@
-import { type Static, Type as t } from '@sinclair/typebox';
-import { type Equal, sql } from 'drizzle-orm';
-import {
-	customType,
-	integer,
-	json,
-	jsonb,
-	pgEnum,
-	pgMaterializedView,
-	pgSchema,
-	pgTable,
-	pgView,
-	serial,
-	text,
-} from 'drizzle-orm/pg-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema, type GenericSchema } from '../src';
-import { Expect, expectEnumValues, expectSchemaShape } from './utils.ts';
-
-const integerSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX });
-const textSchema = t.String();
-
-test('table - select', (tc) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = pgSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (tc) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({ name: textSchema, age: t.Optional(t.Union([integerSchema, t.Null()])) });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (tc) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		name: t.Optional(textSchema),
-		age: t.Optional(t.Union([integerSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (tc) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: integerSchema, age: t.Any() });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (tc) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view qb - select', (tc) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: integerSchema, age: t.Any() });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view columns - select', (tc) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (tc) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({
-		id: integerSchema,
-		nested: t.Object({ name: textSchema, age: t.Any() }),
-		table: t.Object({ id: integerSchema, name: textSchema }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('enum - select', (tc) => {
-	const enum_ = pgEnum('test', ['a', 'b', 'c']);
-
-	const result = createSelectSchema(enum_);
-	const expected = t.Enum({ a: 'a', b: 'b', c: 'c' });
-	expectEnumValues(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		c1: t.Union([integerSchema, t.Null()]),
-		c2: integerSchema,
-		c3: t.Union([integerSchema, t.Null()]),
-		c4: integerSchema,
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([integerSchema, t.Null()])),
-		c2: integerSchema,
-		c3: t.Optional(t.Union([integerSchema, t.Null()])),
-		c4: t.Optional(integerSchema),
-		c7: t.Optional(integerSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-});
-
-test('nullability - update', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([integerSchema, t.Null()])),
-		c2: t.Optional(integerSchema),
-		c3: t.Optional(t.Union([integerSchema, t.Null()])),
-		c4: t.Optional(integerSchema),
-		c7: t.Optional(integerSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Union([integerSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (tc) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-	const expected = t.Object({
-		c1: t.Union([integerSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([integerSchema, t.Null()])),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([integerSchema, t.Null()])),
-		c2: t.Optional(t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 })),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (tc) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer(),
-		c3: integer(),
-		c4: integer(),
-		c5: integer(),
-		c6: integer(),
-	});
-	const view = pgView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: {
-			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-		table: {
-			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-	});
-	const expected = t.Object({
-		c1: t.Union([integerSchema, t.Null()]),
-		c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: t.Object({
-			c4: t.Union([integerSchema, t.Null()]),
-			c5: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		}),
-		table: t.Object({
-			c1: t.Union([integerSchema, t.Null()]),
-			c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-			c4: t.Union([integerSchema, t.Null()]),
-			c5: t.Union([integerSchema, t.Null()]),
-			c6: t.Union([integerSchema, t.Null()]),
-		}),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (tc) => {
-	const table = pgTable('test', ({
-		bigint,
-		bigserial,
-		bit,
-		boolean,
-		date,
-		char,
-		cidr,
-		doublePrecision,
-		geometry,
-		halfvec,
-		inet,
-		integer,
-		interval,
-		json,
-		jsonb,
-		line,
-		macaddr,
-		macaddr8,
-		numeric,
-		point,
-		real,
-		serial,
-		smallint,
-		smallserial,
-		text,
-		sparsevec,
-		time,
-		timestamp,
-		uuid,
-		varchar,
-		vector,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigserial1: bigserial({ mode: 'number' }).notNull(),
-		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
-		bit: bit({ dimensions: 5 }).notNull(),
-		boolean: boolean().notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		cidr: cidr().notNull(),
-		doublePrecision: doublePrecision().notNull(),
-		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
-		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
-		halfvec: halfvec({ dimensions: 3 }).notNull(),
-		inet: inet().notNull(),
-		integer: integer().notNull(),
-		interval: interval().notNull(),
-		json: json().notNull(),
-		jsonb: jsonb().notNull(),
-		line1: line({ mode: 'abc' }).notNull(),
-		line2: line({ mode: 'tuple' }).notNull(),
-		macaddr: macaddr().notNull(),
-		macaddr8: macaddr8().notNull(),
-		numeric: numeric().notNull(),
-		point1: point({ mode: 'xy' }).notNull(),
-		point2: point({ mode: 'tuple' }).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint: smallint().notNull(),
-		smallserial: smallserial().notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		uuid: uuid().notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		vector: vector({ dimensions: 3 }).notNull(),
-		array1: integer().array().notNull(),
-		array2: integer().array().array(2).notNull(),
-		array3: varchar({ length: 10 }).array().array(2).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
-		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
-		bigserial1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
-		bigserial2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
-		bit: t.RegExp(/^[01]+$/, { maxLength: 5 }),
-		boolean: t.Boolean(),
-		date1: t.Date(),
-		date2: t.String(),
-		char1: t.String({ minLength: 10, maxLength: 10 }),
-		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		cidr: t.String(),
-		doublePrecision: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		geometry1: t.Tuple([t.Number(), t.Number()]),
-		geometry2: t.Object({ x: t.Number(), y: t.Number() }),
-		halfvec: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
-		inet: t.String(),
-		integer: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
-		interval: t.String(),
-		json: jsonSchema,
-		jsonb: jsonSchema,
-		line1: t.Object({ a: t.Number(), b: t.Number(), c: t.Number() }),
-		line2: t.Tuple([t.Number(), t.Number(), t.Number()]),
-		macaddr: t.String(),
-		macaddr8: t.String(),
-		numeric: t.String(),
-		point1: t.Object({ x: t.Number(), y: t.Number() }),
-		point2: t.Tuple([t.Number(), t.Number()]),
-		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
-		serial: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
-		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
-		smallserial: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
-		text1: t.String(),
-		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		sparsevec: t.String(),
-		time: t.String(),
-		timestamp1: t.Date(),
-		timestamp2: t.String(),
-		uuid: t.String({ format: 'uuid' }),
-		varchar1: t.String({ maxLength: 10 }),
-		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
-		array1: t.Array(integerSchema),
-		array2: t.Array(t.Array(integerSchema), { minItems: 2, maxItems: 2 }),
-		array3: t.Array(t.Array(t.String({ maxLength: 10 })), { minItems: 2, maxItems: 2 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
-	const table = pgTable('test', {
-		json: json().$type<TopLevelCondition>().notNull(),
-		jsonb: jsonb().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		json: TopLevelCondition,
-		jsonb: t.Union([TopLevelCondition, t.Null()]),
-	});
-	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = pgTable('test', { id: integer() });
-	const view = pgView('test').as((qb) => qb.select().from(table));
-	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: t.String() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = pgView('test', { id: integer() }).as(sql``);
-	const mView = pgView('test', { id: integer() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: t.String() });
-}
diff --git a/drizzle-typebox/tests/singlestore.test.ts b/drizzle-typebox/tests/singlestore.test.ts
deleted file mode 100644
index 13a1a673c6..0000000000
--- a/drizzle-typebox/tests/singlestore.test.ts
+++ /dev/null
@@ -1,510 +0,0 @@
-import { type Static, Type as t } from '@sinclair/typebox';
-import { type Equal } from 'drizzle-orm';
-import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema, type GenericSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = t.Integer({
-	minimum: CONSTANTS.INT32_MIN,
-	maximum: CONSTANTS.INT32_MAX,
-});
-const serialNumberModeSchema = t.Integer({
-	minimum: 0,
-	maximum: Number.MAX_SAFE_INTEGER,
-});
-const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
-
-test('table - select', (tc) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = singlestoreSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (tc) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		id: t.Optional(serialNumberModeSchema),
-		name: textSchema,
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (tc) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		id: t.Optional(serialNumberModeSchema),
-		name: t.Optional(textSchema),
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// TODO: SingleStore doesn't support views yet. Add these tests when they're added
-
-// test('view qb - select', (tc) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-// 	const result = createSelectSchema(view);
-// 	const expected = t.Object({ id: serialNumberModeSchema, age: t.Any() });
-// 	expectSchemaShape(tc, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view columns - select', (tc) => {
-// 	const view = mysqlView('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	}).as(sql``);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = t.Object({ id: serialNumberModeSchema, name: textSchema });
-// 	expectSchemaShape(tc, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view with nested fields - select', (tc) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			id: table.id,
-// 			nested: {
-// 				name: table.name,
-// 				age: sql``.as('age'),
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = t.Object({
-// 		id: serialNumberModeSchema,
-// 		nested: t.Object({ name: textSchema, age: t.Any() }),
-// 		table: t.Object({ id: serialNumberModeSchema, name: textSchema }),
-// 	});
-// 	expectSchemaShape(tc, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('nullability - select', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: intSchema,
-		c3: t.Union([intSchema, t.Null()]),
-		c4: intSchema,
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: intSchema,
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(intSchema),
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (tc) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (tc) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 })),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// test('refine view - select', (tc) => {
-// 	const table = singlestoreTable('test', {
-// 		c1: int(),
-// 		c2: int(),
-// 		c3: int(),
-// 		c4: int(),
-// 		c5: int(),
-// 		c6: int(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			c1: table.c1,
-// 			c2: table.c2,
-// 			c3: table.c3,
-// 			nested: {
-// 				c4: table.c4,
-// 				c5: table.c5,
-// 				c6: table.c6,
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view, {
-// 		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-// 		c3: t.Integer({ minimum: 1, maximum: 10 }),
-// 		nested: {
-// 			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-// 			c6: t.Integer({ minimum: 1, maximum: 10 }),
-// 		},
-// 		table: {
-// 			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-// 			c3: t.Integer({ minimum: 1, maximum: 10 }),
-// 		},
-// 	});
-// 	const expected = t.Object({
-// 		c1: t.Union([intSchema, t.Null()]),
-// 		c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-// 		c3: t.Integer({ minimum: 1, maximum: 10 }),
-// 		nested: t.Object({
-// 			c4: t.Union([intSchema, t.Null()]),
-// 			c5: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-// 			c6: t.Integer({ minimum: 1, maximum: 10 }),
-// 		}),
-// 		table: t.Object({
-// 			c1: t.Union([intSchema, t.Null()]),
-// 			c2: t.Union([t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }), t.Null()]),
-// 			c3: t.Integer({ minimum: 1, maximum: 10 }),
-// 			c4: t.Union([intSchema, t.Null()]),
-// 			c5: t.Union([intSchema, t.Null()]),
-// 			c6: t.Union([intSchema, t.Null()]),
-// 		}),
-// 	});
-// 	expectSchemaShape(tc, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('all data types', (tc) => {
-	const table = singlestoreTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		singlestoreEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
-		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
-		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
-		binary: t.String(),
-		boolean: t.Boolean(),
-		char1: t.String({ minLength: 10, maxLength: 10 }),
-		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		date1: t.Date(),
-		date2: t.String(),
-		datetime1: t.Date(),
-		datetime2: t.String(),
-		decimal1: t.String(),
-		decimal2: t.String(),
-		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
-		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
-		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
-		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
-		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
-		json: jsonSchema,
-		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
-		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
-		enum: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
-		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
-		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
-		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		time: t.String(),
-		timestamp1: t.Date(),
-		timestamp2: t.String(),
-		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
-		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
-		varchar1: t.String({ maxLength: 10 }),
-		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		varbinary: t.String(),
-		year: t.Integer({ minimum: 1901, maximum: 2155 }),
-		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
-		longtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
-		mediumtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
-		tinytext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
-	const table = singlestoreTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		json: t.Union([TopLevelCondition, t.Null()]),
-	});
-	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: t.String() });
-}
-
-// /* Disallow unknown keys in view qb - select */ {
-// 	const table = singlestoreTable('test', { id: int() });
-// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
-// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: t.String() });
-// 	// @ts-expect-error
-// 	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
-// }
-
-// /* Disallow unknown keys in view columns - select */ {
-// 	const view = mysqlView('test', { id: int() }).as(sql``);
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: t.String() });
-// }
diff --git a/drizzle-typebox/tests/sqlite.test.ts b/drizzle-typebox/tests/sqlite.test.ts
deleted file mode 100644
index b4db9b90ec..0000000000
--- a/drizzle-typebox/tests/sqlite.test.ts
+++ /dev/null
@@ -1,404 +0,0 @@
-import { type Static, Type as t } from '@sinclair/typebox';
-import { type Equal, sql } from 'drizzle-orm';
-import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { bufferSchema, jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema, type GenericSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
-const textSchema = t.String();
-
-test('table - select', (tc) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({ id: intSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (tc) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		id: t.Optional(intSchema),
-		name: textSchema,
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (tc) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		id: t.Optional(intSchema),
-		name: t.Optional(textSchema),
-		age: t.Optional(t.Union([intSchema, t.Null()])),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (tc) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: intSchema, age: t.Any() });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (tc) => {
-	const view = sqliteView('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({ id: intSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (tc) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = t.Object({
-		id: intSchema,
-		nested: t.Object({ name: textSchema, age: t.Any() }),
-		table: t.Object({ id: intSchema, name: textSchema }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: intSchema,
-		c3: t.Union([intSchema, t.Null()]),
-		c4: intSchema,
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: intSchema,
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(intSchema),
-		c3: t.Optional(t.Union([intSchema, t.Null()])),
-		c4: t.Optional(intSchema),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (tc) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
-	const result = createSelectSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	const expected = t.Object({
-		c1: t.Optional(t.Union([intSchema, t.Null()])),
-		c2: t.Optional(t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 })),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (tc) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: {
-			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-		table: {
-			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-		},
-	});
-	const expected = t.Object({
-		c1: t.Union([intSchema, t.Null()]),
-		c2: t.Union([t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }), t.Null()]),
-		c3: t.Integer({ minimum: 1, maximum: 10 }),
-		nested: t.Object({
-			c4: t.Union([intSchema, t.Null()]),
-			c5: t.Union([t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }), t.Null()]),
-			c6: t.Integer({ minimum: 1, maximum: 10 }),
-		}),
-		table: t.Object({
-			c1: t.Union([intSchema, t.Null()]),
-			c2: t.Union([t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: 1000 }), t.Null()]),
-			c3: t.Integer({ minimum: 1, maximum: 10 }),
-			c4: t.Union([intSchema, t.Null()]),
-			c5: t.Union([intSchema, t.Null()]),
-			c6: t.Union([intSchema, t.Null()]),
-		}),
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (tc) => {
-	const table = sqliteTable('test', ({
-		blob,
-		integer,
-		numeric,
-		real,
-		text,
-	}) => ({
-		blob1: blob({ mode: 'buffer' }).notNull(),
-		blob2: blob({ mode: 'bigint' }).notNull(),
-		blob3: blob({ mode: 'json' }).notNull(),
-		integer1: integer({ mode: 'number' }).notNull(),
-		integer2: integer({ mode: 'boolean' }).notNull(),
-		integer3: integer({ mode: 'timestamp' }).notNull(),
-		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
-		numeric: numeric().notNull(),
-		real: real().notNull(),
-		text1: text({ mode: 'text' }).notNull(),
-		text2: text({ mode: 'text', length: 10 }).notNull(),
-		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
-		text4: text({ mode: 'json' }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		blob1: bufferSchema,
-		blob2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
-		blob3: jsonSchema,
-		integer1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
-		integer2: t.Boolean(),
-		integer3: t.Date(),
-		integer4: t.Date(),
-		numeric: t.String(),
-		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
-		text1: t.String(),
-		text2: t.String({ maxLength: 10 }),
-		text3: t.Enum({ a: 'a', b: 'b', c: 'c' }),
-		text4: jsonSchema,
-	});
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
-	const table = sqliteTable('test', {
-		json1: text({ mode: 'json' }).$type<TopLevelCondition>().notNull(),
-		json2: blob({ mode: 'json' }).$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = t.Object({
-		json1: TopLevelCondition,
-		json2: t.Union([TopLevelCondition, t.Null()]),
-	});
-	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: t.String() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = sqliteTable('test', { id: int() });
-	const view = sqliteView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = sqliteView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: t.String() });
-}
diff --git a/drizzle-typebox/tests/tsconfig.json b/drizzle-typebox/tests/tsconfig.json
deleted file mode 100644
index 18f5dee497..0000000000
--- a/drizzle-typebox/tests/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"noEmit": true,
-		"rootDir": "..",
-		"outDir": "./.cache"
-	},
-	"include": [".", "../src"]
-}
diff --git a/drizzle-typebox/tests/utils.ts b/drizzle-typebox/tests/utils.ts
deleted file mode 100644
index 46cd16a32f..0000000000
--- a/drizzle-typebox/tests/utils.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import type * as t from '@sinclair/typebox';
-import { expect, type TaskContext } from 'vitest';
-
-function removeKeysFromObject(obj: Record<string, any>, keys: string[]) {
-	for (const key of keys) {
-		delete obj[key];
-	}
-	return obj;
-}
-
-export function expectSchemaShape<T extends t.TObject>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(Object.keys(actual.properties)).toStrictEqual(Object.keys(expected.properties));
-			const keys = ['$id', '$schema', 'title', 'description', 'default', 'examples', 'readOnly', 'writeOnly'];
-
-			for (const key of Object.keys(actual.properties)) {
-				expect(removeKeysFromObject(actual.properties[key]!, keys)).toStrictEqual(
-					removeKeysFromObject(expected.properties[key]!, keys),
-				);
-			}
-		},
-	};
-}
-
-export function expectEnumValues<T extends t.TEnum<any>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(actual.anyOf).toStrictEqual(expected.anyOf);
-		},
-	};
-}
-
-export function Expect<_ extends true>() {}
diff --git a/drizzle-typebox/tsconfig.build.json b/drizzle-typebox/tsconfig.build.json
deleted file mode 100644
index 3377281baa..0000000000
--- a/drizzle-typebox/tsconfig.build.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"extends": "./tsconfig.json",
-	"compilerOptions": {
-		"rootDir": "src"
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-typebox/tsconfig.json b/drizzle-typebox/tsconfig.json
deleted file mode 100644
index c25379c37b..0000000000
--- a/drizzle-typebox/tsconfig.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"baseUrl": ".",
-		"declaration": true,
-		"noEmit": true,
-		"paths": {
-			"~/*": ["src/*"]
-		}
-	},
-	"include": ["src", "*.ts"]
-}
diff --git a/drizzle-typebox/vitest.config.ts b/drizzle-typebox/vitest.config.ts
deleted file mode 100644
index 1f0eb7ad9a..0000000000
--- a/drizzle-typebox/vitest.config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-	test: {
-		include: [
-			'tests/**/*.test.ts',
-		],
-		exclude: [
-			'tests/bun/**/*',
-		],
-		typecheck: {
-			tsconfig: 'tsconfig.json',
-		},
-		testTimeout: 100000,
-		hookTimeout: 100000,
-		isolate: false,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-	},
-	plugins: [tsconfigPaths()],
-});
diff --git a/drizzle-valibot/README.md b/drizzle-valibot/README.md
deleted file mode 100644
index cc4182a137..0000000000
--- a/drizzle-valibot/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-`drizzle-valibot` is a plugin for [Drizzle ORM](https://github.com/drizzle-team/drizzle-orm) that allows you to generate [valibot](https://valibot.dev/) schemas from Drizzle ORM schemas.
-
-**Features**
-
-- Create a select schema for tables, views and enums.
-- Create insert and update schemas for tables.
-- Supports all dialects: PostgreSQL, MySQL and SQLite.
-
-# Usage
-
-```ts
-import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import { createInsertSchema, createSelectSchema } from 'drizzle-valibot';
-import { string, parse, number, pipe } from 'valibot';
-
-const users = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-	role: text('role', { enum: ['admin', 'user'] }).notNull(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-// Schema for inserting a user - can be used to validate API requests
-const insertUserSchema = createInsertSchema(users);
-
-// Schema for updating a user - can be used to validate API requests
-const updateUserSchema = createUpdateSchema(users);
-
-// Schema for selecting a user - can be used to validate API responses
-const selectUserSchema = createSelectSchema(users);
-
-// Overriding the fields
-const insertUserSchema = createInsertSchema(users, {
-	role: string(),
-});
-
-// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
-const insertUserSchema = createInsertSchema(users, {
-	id: (schema) => pipe([schema, minValue(0)]),
-	role: string(),
-});
-
-// Usage
-
-const isUserValid = parse(insertUserSchema, {
-	name: 'John Doe',
-	email: 'johndoe@test.com',
-	role: 'admin',
-});
-```
diff --git a/drizzle-valibot/package.json b/drizzle-valibot/package.json
deleted file mode 100644
index c3c6da1826..0000000000
--- a/drizzle-valibot/package.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
-	"name": "drizzle-valibot",
-	"version": "0.4.2",
-	"description": "Generate valibot schemas from Drizzle ORM schemas",
-	"type": "module",
-	"scripts": {
-		"build": "tsx scripts/build.ts",
-		"b": "pnpm build",
-		"test:types": "cd tests && tsc",
-		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
-		"publish": "npm publish package.tgz",
-		"test": "vitest run"
-	},
-	"exports": {
-		".": {
-			"import": {
-				"types": "./index.d.mts",
-				"default": "./index.mjs"
-			},
-			"require": {
-				"types": "./index.d.cjs",
-				"default": "./index.cjs"
-			},
-			"types": "./index.d.ts",
-			"default": "./index.mjs"
-		}
-	},
-	"main": "./index.cjs",
-	"module": "./index.mjs",
-	"types": "./index.d.ts",
-	"publishConfig": {
-		"provenance": true
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/drizzle-team/drizzle-orm.git"
-	},
-	"keywords": [
-		"valibot",
-		"validate",
-		"validation",
-		"schema",
-		"drizzle",
-		"orm",
-		"pg",
-		"mysql",
-		"postgresql",
-		"postgres",
-		"sqlite",
-		"database",
-		"sql",
-		"typescript",
-		"ts"
-	],
-	"author": "Drizzle Team",
-	"license": "Apache-2.0",
-	"peerDependencies": {
-		"drizzle-orm": ">=0.36.0",
-		"valibot": ">=1.0.0-beta.7"
-	},
-	"devDependencies": {
-		"@rollup/plugin-typescript": "^11.1.0",
-		"@types/node": "^18.15.10",
-		"cpy": "^10.1.0",
-		"drizzle-orm": "link:../drizzle-orm/dist",
-		"json-rules-engine": "^7.3.1",
-		"rimraf": "^5.0.0",
-		"rollup": "^3.29.5",
-		"valibot": "1.0.0-beta.7",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
-		"zx": "^7.2.2"
-	}
-}
diff --git a/drizzle-valibot/rollup.config.ts b/drizzle-valibot/rollup.config.ts
deleted file mode 100644
index 986da48832..0000000000
--- a/drizzle-valibot/rollup.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-export default defineConfig([
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				format: 'esm',
-				dir: 'dist',
-				entryFileNames: '[name].mjs',
-				chunkFileNames: '[name]-[hash].mjs',
-				sourcemap: true,
-			},
-			{
-				format: 'cjs',
-				dir: 'dist',
-				entryFileNames: '[name].cjs',
-				chunkFileNames: '[name]-[hash].cjs',
-				sourcemap: true,
-			},
-		],
-		external: [
-			/^drizzle-orm\/?/,
-			'valibot',
-		],
-		plugins: [
-			typescript({
-				tsconfig: 'tsconfig.build.json',
-			}),
-		],
-	},
-]);
diff --git a/drizzle-valibot/scripts/build.ts b/drizzle-valibot/scripts/build.ts
deleted file mode 100755
index 07330ffd0a..0000000000
--- a/drizzle-valibot/scripts/build.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
-
-await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await fs.copy('package.json', 'dist/package.json');
-await $`scripts/fix-imports.ts`;
diff --git a/drizzle-valibot/scripts/fix-imports.ts b/drizzle-valibot/scripts/fix-imports.ts
deleted file mode 100755
index a90057c5b9..0000000000
--- a/drizzle-valibot/scripts/fix-imports.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-
-import path from 'node:path';
-import { parse, print, visit } from 'recast';
-import parser from 'recast/parsers/typescript';
-
-function resolvePathAlias(importPath: string, file: string) {
-	if (importPath.startsWith('~/')) {
-		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
-		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
-	}
-
-	return importPath;
-}
-
-function fixImportPath(importPath: string, file: string, ext: string) {
-	importPath = resolvePathAlias(importPath, file);
-
-	if (!/\..*\.(js|ts)$/.test(importPath)) {
-		return importPath;
-	}
-
-	return importPath.replace(/\.(js|ts)$/, ext);
-}
-
-const cjsFiles = await glob('dist/**/*.{cjs,d.cts}');
-
-await Promise.all(cjsFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitCallExpression(path) {
-			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
-				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-let esmFiles = await glob('dist/**/*.{js,d.ts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.js');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-esmFiles = await glob('dist/**/*.{mjs,d.mts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
diff --git a/drizzle-valibot/src/column.ts b/drizzle-valibot/src/column.ts
deleted file mode 100644
index aa03bef409..0000000000
--- a/drizzle-valibot/src/column.ts
+++ /dev/null
@@ -1,296 +0,0 @@
-import type { Column, ColumnBaseConfig } from 'drizzle-orm';
-import type {
-	MySqlBigInt53,
-	MySqlChar,
-	MySqlDouble,
-	MySqlFloat,
-	MySqlInt,
-	MySqlMediumInt,
-	MySqlReal,
-	MySqlSerial,
-	MySqlSmallInt,
-	MySqlText,
-	MySqlTinyInt,
-	MySqlVarChar,
-	MySqlYear,
-} from 'drizzle-orm/mysql-core';
-import type {
-	PgArray,
-	PgBigInt53,
-	PgBigSerial53,
-	PgBinaryVector,
-	PgChar,
-	PgDoublePrecision,
-	PgGeometry,
-	PgGeometryObject,
-	PgHalfVector,
-	PgInteger,
-	PgLineABC,
-	PgLineTuple,
-	PgPointObject,
-	PgPointTuple,
-	PgReal,
-	PgSerial,
-	PgSmallInt,
-	PgSmallSerial,
-	PgUUID,
-	PgVarchar,
-	PgVector,
-} from 'drizzle-orm/pg-core';
-import type {
-	SingleStoreBigInt53,
-	SingleStoreChar,
-	SingleStoreDouble,
-	SingleStoreFloat,
-	SingleStoreInt,
-	SingleStoreMediumInt,
-	SingleStoreReal,
-	SingleStoreSerial,
-	SingleStoreSmallInt,
-	SingleStoreText,
-	SingleStoreTinyInt,
-	SingleStoreVarChar,
-	SingleStoreYear,
-} from 'drizzle-orm/singlestore-core';
-import type { SQLiteInteger, SQLiteReal, SQLiteText } from 'drizzle-orm/sqlite-core';
-import * as v from 'valibot';
-import { CONSTANTS } from './constants.ts';
-import { isColumnType, isWithEnum } from './utils.ts';
-import type { Json } from './utils.ts';
-
-export const literalSchema = v.union([v.string(), v.number(), v.boolean(), v.null()]);
-export const jsonSchema: v.GenericSchema<Json> = v.union([
-	literalSchema,
-	v.array(v.any()),
-	v.record(v.string(), v.any()),
-]);
-export const bufferSchema: v.GenericSchema<Buffer> = v.custom<Buffer>((v) => v instanceof Buffer); // eslint-disable-line no-instanceof/no-instanceof
-
-export function mapEnumValues(values: string[]) {
-	return Object.fromEntries(values.map((value) => [value, value]));
-}
-
-export function columnToSchema(column: Column): v.GenericSchema {
-	let schema!: v.GenericSchema;
-
-	if (isWithEnum(column)) {
-		schema = column.enumValues.length ? v.enum(mapEnumValues(column.enumValues)) : v.string();
-	}
-
-	if (!schema) {
-		// Handle specific types
-		if (isColumnType<PgGeometry<any> | PgPointTuple<any>>(column, ['PgGeometry', 'PgPointTuple'])) {
-			schema = v.tuple([v.number(), v.number()]);
-		} else if (
-			isColumnType<PgPointObject<any> | PgGeometryObject<any>>(column, ['PgGeometryObject', 'PgPointObject'])
-		) {
-			schema = v.object({ x: v.number(), y: v.number() });
-		} else if (isColumnType<PgHalfVector<any> | PgVector<any>>(column, ['PgHalfVector', 'PgVector'])) {
-			schema = v.array(v.number());
-			schema = column.dimensions ? v.pipe(schema as v.ArraySchema<any, any>, v.length(column.dimensions)) : schema;
-		} else if (isColumnType<PgLineTuple<any>>(column, ['PgLine'])) {
-			schema = v.tuple([v.number(), v.number(), v.number()]);
-			v.array(v.array(v.number()));
-		} else if (isColumnType<PgLineABC<any>>(column, ['PgLineABC'])) {
-			schema = v.object({ a: v.number(), b: v.number(), c: v.number() });
-		} // Handle other types
-		else if (isColumnType<PgArray<any, any>>(column, ['PgArray'])) {
-			schema = v.array(columnToSchema(column.baseColumn));
-			schema = column.size ? v.pipe(schema as v.ArraySchema<any, any>, v.length(column.size)) : schema;
-		} else if (column.dataType === 'array') {
-			schema = v.array(v.any());
-		} else if (column.dataType === 'number') {
-			schema = numberColumnToSchema(column);
-		} else if (column.dataType === 'bigint') {
-			schema = bigintColumnToSchema(column);
-		} else if (column.dataType === 'boolean') {
-			schema = v.boolean();
-		} else if (column.dataType === 'date') {
-			schema = v.date();
-		} else if (column.dataType === 'string') {
-			schema = stringColumnToSchema(column);
-		} else if (column.dataType === 'json') {
-			schema = jsonSchema;
-		} else if (column.dataType === 'custom') {
-			schema = v.any();
-		} else if (column.dataType === 'buffer') {
-			schema = bufferSchema;
-		}
-	}
-
-	if (!schema) {
-		schema = v.any();
-	}
-
-	return schema;
-}
-
-function numberColumnToSchema(column: Column): v.GenericSchema {
-	let unsigned = column.getSQLType().includes('unsigned');
-	let min!: number;
-	let max!: number;
-	let integer = false;
-
-	if (isColumnType<MySqlTinyInt<any> | SingleStoreTinyInt<any>>(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
-		min = unsigned ? 0 : CONSTANTS.INT8_MIN;
-		max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
-		integer = true;
-	} else if (
-		isColumnType<PgSmallInt<any> | PgSmallSerial<any> | MySqlSmallInt<any> | SingleStoreSmallInt<any>>(column, [
-			'PgSmallInt',
-			'PgSmallSerial',
-			'MySqlSmallInt',
-			'SingleStoreSmallInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT16_MIN;
-		max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			PgReal<any> | MySqlFloat<any> | MySqlMediumInt<any> | SingleStoreFloat<any> | SingleStoreMediumInt<any>
-		>(column, [
-			'PgReal',
-			'MySqlFloat',
-			'MySqlMediumInt',
-			'SingleStoreFloat',
-			'SingleStoreMediumInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT24_MIN;
-		max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
-		integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
-	} else if (
-		isColumnType<PgInteger<any> | PgSerial<any> | MySqlInt<any> | SingleStoreInt<any>>(column, [
-			'PgInteger',
-			'PgSerial',
-			'MySqlInt',
-			'SingleStoreInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT32_MIN;
-		max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			| PgDoublePrecision<any>
-			| MySqlReal<any>
-			| MySqlDouble<any>
-			| SingleStoreReal<any>
-			| SingleStoreDouble<any>
-			| SQLiteReal<any>
-		>(column, [
-			'PgDoublePrecision',
-			'MySqlReal',
-			'MySqlDouble',
-			'SingleStoreReal',
-			'SingleStoreDouble',
-			'SQLiteReal',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT48_MIN;
-		max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
-	} else if (
-		isColumnType<
-			| PgBigInt53<any>
-			| PgBigSerial53<any>
-			| MySqlBigInt53<any>
-			| MySqlSerial<any>
-			| SingleStoreBigInt53<any>
-			| SingleStoreSerial<any>
-			| SQLiteInteger<any>
-		>(
-			column,
-			[
-				'PgBigInt53',
-				'PgBigSerial53',
-				'MySqlBigInt53',
-				'MySqlSerial',
-				'SingleStoreBigInt53',
-				'SingleStoreSerial',
-				'SQLiteInteger',
-			],
-		)
-	) {
-		unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
-		min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-		integer = true;
-	} else if (isColumnType<MySqlYear<any> | SingleStoreYear<any>>(column, ['MySqlYear', 'SingleStoreYear'])) {
-		min = 1901;
-		max = 2155;
-		integer = true;
-	} else {
-		min = Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-	}
-
-	const actions: any[] = [v.minValue(min), v.maxValue(max)];
-	if (integer) {
-		actions.push(v.integer());
-	}
-	return v.pipe(v.number(), ...actions);
-}
-
-function bigintColumnToSchema(column: Column): v.GenericSchema {
-	const unsigned = column.getSQLType().includes('unsigned');
-	const min = unsigned ? 0n : CONSTANTS.INT64_MIN;
-	const max = unsigned ? CONSTANTS.INT64_UNSIGNED_MAX : CONSTANTS.INT64_MAX;
-
-	return v.pipe(v.bigint(), v.minValue(min), v.maxValue(max));
-}
-
-function stringColumnToSchema(column: Column): v.GenericSchema {
-	if (isColumnType<PgUUID<ColumnBaseConfig<'string', 'PgUUID'>>>(column, ['PgUUID'])) {
-		return v.pipe(v.string(), v.uuid());
-	}
-
-	let max: number | undefined;
-	let regex: RegExp | undefined;
-	let fixed = false;
-
-	if (isColumnType<PgVarchar<any> | SQLiteText<any>>(column, ['PgVarchar', 'SQLiteText'])) {
-		max = column.length;
-	} else if (
-		isColumnType<MySqlVarChar<any> | SingleStoreVarChar<any>>(column, ['MySqlVarChar', 'SingleStoreVarChar'])
-	) {
-		max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
-	} else if (isColumnType<MySqlText<any> | SingleStoreText<any>>(column, ['MySqlText', 'SingleStoreText'])) {
-		if (column.textType === 'longtext') {
-			max = CONSTANTS.INT32_UNSIGNED_MAX;
-		} else if (column.textType === 'mediumtext') {
-			max = CONSTANTS.INT24_UNSIGNED_MAX;
-		} else if (column.textType === 'text') {
-			max = CONSTANTS.INT16_UNSIGNED_MAX;
-		} else {
-			max = CONSTANTS.INT8_UNSIGNED_MAX;
-		}
-	}
-
-	if (
-		isColumnType<PgChar<any> | MySqlChar<any> | SingleStoreChar<any>>(column, [
-			'PgChar',
-			'MySqlChar',
-			'SingleStoreChar',
-		])
-	) {
-		max = column.length;
-		fixed = true;
-	}
-
-	if (isColumnType<PgBinaryVector<any>>(column, ['PgBinaryVector'])) {
-		regex = /^[01]+$/;
-		max = column.dimensions;
-	}
-
-	const actions: any[] = [];
-	if (regex) {
-		actions.push(v.regex(regex));
-	}
-	if (max && fixed) {
-		actions.push(v.length(max));
-	} else if (max) {
-		actions.push(v.maxLength(max));
-	}
-	return actions.length > 0 ? v.pipe(v.string(), ...actions) : v.string();
-}
diff --git a/drizzle-valibot/src/column.types.ts b/drizzle-valibot/src/column.types.ts
deleted file mode 100644
index ae41dbc8c5..0000000000
--- a/drizzle-valibot/src/column.types.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-import type { Assume, Column } from 'drizzle-orm';
-import type * as v from 'valibot';
-import type { ColumnIsGeneratedAlwaysAs, IsEnumDefined, IsNever, Json, RemoveNeverElements } from './utils.ts';
-
-export type HasBaseColumn<TColumn> = TColumn extends { _: { baseColumn: Column | undefined } }
-	? IsNever<TColumn['_']['baseColumn']> extends false ? true
-	: false
-	: false;
-
-export type EnumValuesToEnum<TEnumValues extends [string, ...string[]]> = { readonly [K in TEnumValues[number]]: K };
-
-export type ExtractAdditionalProperties<TColumn extends Column> = {
-	max: TColumn['_']['columnType'] extends 'PgVarchar' | 'SQLiteText' | 'PgChar' | 'MySqlChar' | 'SingleStoreChar'
-		? Assume<TColumn['_'], { length: number | undefined }>['length']
-		: TColumn['_']['columnType'] extends 'MySqlText' | 'MySqlVarChar' | 'SingleStoreText' | 'SingleStoreVarChar'
-			? number
-		: TColumn['_']['columnType'] extends 'PgBinaryVector' | 'PgHalfVector' | 'PgVector'
-			? Assume<TColumn['_'], { dimensions: number }>['dimensions']
-		: TColumn['_']['columnType'] extends 'PgArray' ? Assume<TColumn['_'], { size: number | undefined }>['size']
-		: undefined;
-	fixedLength: TColumn['_']['columnType'] extends
-		'PgChar' | 'PgHalfVector' | 'PgVector' | 'PgArray' | 'MySqlChar' | 'SingleStoreChar' ? true
-		: false;
-};
-
-type GetLengthAction<T extends Record<string, any>, TType extends string | ArrayLike<unknown>> =
-	T['fixedLength'] extends true ? v.LengthAction<TType, number, undefined>
-		: v.MaxLengthAction<TType, number, undefined>;
-
-type GetArraySchema<T extends Column> = v.ArraySchema<
-	GetValibotType<
-		T['_']['data'],
-		T['_']['dataType'],
-		T['_']['columnType'],
-		T['_']['enumValues'],
-		HasBaseColumn<T> extends true ? Assume<T['_']['baseColumn'], Column> : undefined,
-		ExtractAdditionalProperties<T>
-	>,
-	undefined
->;
-
-export type GetValibotType<
-	TData,
-	TDataType extends string,
-	TColumnType extends string,
-	TEnumValues extends string[] | undefined,
-	TBaseColumn extends Column | undefined,
-	TAdditionalProperties extends Record<string, any>,
-> = TColumnType extends 'PgHalfVector' | 'PgVector' ? TAdditionalProperties['max'] extends number ? v.SchemaWithPipe<
-			[v.ArraySchema<v.NumberSchema<undefined>, undefined>, GetLengthAction<TAdditionalProperties, number[]>]
-		>
-	: v.ArraySchema<v.NumberSchema<undefined>, undefined>
-	: TColumnType extends 'PgUUID' ? v.SchemaWithPipe<[v.StringSchema<undefined>, v.UuidAction<string, undefined>]>
-	: TColumnType extends 'PgBinaryVector' ? v.SchemaWithPipe<
-			RemoveNeverElements<[
-				v.StringSchema<undefined>,
-				v.RegexAction<string, undefined>,
-				TAdditionalProperties['max'] extends number ? GetLengthAction<TAdditionalProperties, string> : never,
-			]>
-		>
-	: TBaseColumn extends Column ? TAdditionalProperties['max'] extends number ? v.SchemaWithPipe<
-				[
-					GetArraySchema<Assume<TBaseColumn, Column>>,
-					GetLengthAction<TAdditionalProperties, Assume<TBaseColumn, Column>['_']['data'][]>,
-				]
-			>
-		: GetArraySchema<Assume<TBaseColumn, Column>>
-	: IsEnumDefined<TEnumValues> extends true
-		? v.EnumSchema<{ readonly [K in Assume<TEnumValues, [string, ...string[]]>[number]]: K }, undefined>
-	: TColumnType extends 'PgGeometry' | 'PgPointTuple'
-		? v.TupleSchema<[v.NumberSchema<undefined>, v.NumberSchema<undefined>], undefined>
-	: TColumnType extends 'PgLine'
-		? v.TupleSchema<[v.NumberSchema<undefined>, v.NumberSchema<undefined>, v.NumberSchema<undefined>], undefined>
-	: TData extends Date ? v.DateSchema<undefined>
-	: TData extends Buffer ? v.GenericSchema<Buffer>
-	: TDataType extends 'array' ? v.ArraySchema<
-			GetValibotPrimitiveType<Assume<TData, any[]>[number], '', { noPipe: true }>,
-			undefined
-		>
-	: TData extends Record<string, any>
-		? TColumnType extends 'PgJson' | 'PgJsonb' | 'MySqlJson' | 'SingleStoreJson' | 'SQLiteTextJson' | 'SQLiteBlobJson'
-			? v.GenericSchema<TData>
-		: v.ObjectSchema<
-			{ readonly [K in keyof TData]: GetValibotPrimitiveType<TData[K], '', { noPipe: true }> },
-			undefined
-		>
-	: TDataType extends 'json' ? v.GenericSchema<Json>
-	: GetValibotPrimitiveType<TData, TColumnType, TAdditionalProperties>;
-
-type GetValibotPrimitiveType<TData, TColumnType, TAdditionalProperties extends Record<string, any>> = TData extends
-	number ? TAdditionalProperties['noPipe'] extends true ? v.NumberSchema<undefined> : v.SchemaWithPipe<
-		RemoveNeverElements<[
-			v.NumberSchema<undefined>,
-			v.MinValueAction<number, number, undefined>,
-			v.MaxValueAction<number, number, undefined>,
-			TColumnType extends
-				| 'MySqlTinyInt'
-				| 'SingleStoreTinyInt'
-				| 'PgSmallInt'
-				| 'PgSmallSerial'
-				| 'MySqlSmallInt'
-				| 'MySqlMediumInt'
-				| 'SingleStoreSmallInt'
-				| 'SingleStoreMediumInt'
-				| 'PgInteger'
-				| 'PgSerial'
-				| 'MySqlInt'
-				| 'SingleStoreInt'
-				| 'PgBigInt53'
-				| 'PgBigSerial53'
-				| 'MySqlBigInt53'
-				| 'MySqlSerial'
-				| 'SingleStoreBigInt53'
-				| 'SingleStoreSerial'
-				| 'SQLiteInteger'
-				| 'MySqlYear'
-				| 'SingleStoreYear' ? v.IntegerAction<number, undefined>
-				: never,
-		]>
-	>
-	: TData extends bigint ? TAdditionalProperties['noPipe'] extends true ? v.BigintSchema<undefined> : v.SchemaWithPipe<[
-			v.BigintSchema<undefined>,
-			v.MinValueAction<bigint, bigint, undefined>,
-			v.MaxValueAction<bigint, bigint, undefined>,
-		]>
-	: TData extends boolean ? v.BooleanSchema<undefined>
-	: TData extends string
-		? TAdditionalProperties['max'] extends number
-			? v.SchemaWithPipe<[v.StringSchema<undefined>, GetLengthAction<TAdditionalProperties, string>]>
-		: v.StringSchema<undefined>
-	: v.AnySchema;
-
-type HandleSelectColumn<
-	TSchema extends v.GenericSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TSchema
-	: v.NullableSchema<TSchema, undefined>;
-
-type HandleInsertColumn<
-	TSchema extends v.GenericSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true
-	? TColumn['_']['hasDefault'] extends true ? v.OptionalSchema<TSchema, undefined>
-	: TSchema
-	: v.OptionalSchema<v.NullableSchema<TSchema, undefined>, undefined>;
-
-type HandleUpdateColumn<
-	TSchema extends v.GenericSchema,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? v.OptionalSchema<TSchema, undefined>
-	: v.OptionalSchema<v.NullableSchema<TSchema, undefined>, undefined>;
-
-export type HandleColumn<
-	TType extends 'select' | 'insert' | 'update',
-	TColumn extends Column,
-> = GetValibotType<
-	TColumn['_']['data'],
-	TColumn['_']['dataType'],
-	TColumn['_']['columnType'],
-	TColumn['_']['enumValues'],
-	HasBaseColumn<TColumn> extends true ? Assume<TColumn['_']['baseColumn'], Column> : undefined,
-	ExtractAdditionalProperties<TColumn>
-> extends infer TSchema extends v.GenericSchema ? TSchema extends v.AnySchema ? v.AnySchema
-	: TType extends 'select' ? HandleSelectColumn<TSchema, TColumn>
-	: TType extends 'insert' ? HandleInsertColumn<TSchema, TColumn>
-	: TType extends 'update' ? HandleUpdateColumn<TSchema, TColumn>
-	: TSchema
-	: v.AnySchema;
diff --git a/drizzle-valibot/src/constants.ts b/drizzle-valibot/src/constants.ts
deleted file mode 100644
index 99f5d7a422..0000000000
--- a/drizzle-valibot/src/constants.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-export const CONSTANTS = {
-	INT8_MIN: -128,
-	INT8_MAX: 127,
-	INT8_UNSIGNED_MAX: 255,
-	INT16_MIN: -32768,
-	INT16_MAX: 32767,
-	INT16_UNSIGNED_MAX: 65535,
-	INT24_MIN: -8388608,
-	INT24_MAX: 8388607,
-	INT24_UNSIGNED_MAX: 16777215,
-	INT32_MIN: -2147483648,
-	INT32_MAX: 2147483647,
-	INT32_UNSIGNED_MAX: 4294967295,
-	INT48_MIN: -140737488355328,
-	INT48_MAX: 140737488355327,
-	INT48_UNSIGNED_MAX: 281474976710655,
-	INT64_MIN: -9223372036854775808n,
-	INT64_MAX: 9223372036854775807n,
-	INT64_UNSIGNED_MAX: 18446744073709551615n,
-};
diff --git a/drizzle-valibot/src/index.ts b/drizzle-valibot/src/index.ts
deleted file mode 100644
index 225d3e880f..0000000000
--- a/drizzle-valibot/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export { bufferSchema, jsonSchema, literalSchema } from './column.ts';
-export * from './column.types.ts';
-export * from './schema.ts';
-export * from './schema.types.internal.ts';
-export * from './schema.types.ts';
-export * from './utils.ts';
diff --git a/drizzle-valibot/src/schema.ts b/drizzle-valibot/src/schema.ts
deleted file mode 100644
index 30a6f77ece..0000000000
--- a/drizzle-valibot/src/schema.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { Column, getTableColumns, getViewSelectedFields, is, isTable, isView, SQL } from 'drizzle-orm';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import * as v from 'valibot';
-import { columnToSchema, mapEnumValues } from './column.ts';
-import type { Conditions } from './schema.types.internal.ts';
-import type { CreateInsertSchema, CreateSelectSchema, CreateUpdateSchema } from './schema.types.ts';
-import { isPgEnum } from './utils.ts';
-
-function getColumns(tableLike: Table | View) {
-	return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
-}
-
-function handleColumns(
-	columns: Record<string, any>,
-	refinements: Record<string, any>,
-	conditions: Conditions,
-): v.GenericSchema {
-	const columnSchemas: Record<string, v.GenericSchema> = {};
-
-	for (const [key, selected] of Object.entries(columns)) {
-		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
-			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
-			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions);
-			continue;
-		}
-
-		const refinement = refinements[key];
-		if (refinement !== undefined && typeof refinement !== 'function') {
-			columnSchemas[key] = refinement;
-			continue;
-		}
-
-		const column = is(selected, Column) ? selected : undefined;
-		const schema = column ? columnToSchema(column) : v.any();
-		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
-
-		if (conditions.never(column)) {
-			continue;
-		} else {
-			columnSchemas[key] = refined;
-		}
-
-		if (column) {
-			if (conditions.nullable(column)) {
-				columnSchemas[key] = v.nullable(columnSchemas[key]!);
-			}
-
-			if (conditions.optional(column)) {
-				columnSchemas[key] = v.optional(columnSchemas[key]!);
-			}
-		}
-	}
-
-	return v.object(columnSchemas) as any;
-}
-
-export const createSelectSchema: CreateSelectSchema = (
-	entity: Table | View | PgEnum<[string, ...string[]]>,
-	refine?: Record<string, any>,
-) => {
-	if (isPgEnum(entity)) {
-		return v.enum(mapEnumValues(entity.enumValues));
-	}
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: () => false,
-		optional: () => false,
-		nullable: (column) => !column.notNull,
-	}) as any;
-};
-
-export const createInsertSchema: CreateInsertSchema = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-		optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
-		nullable: (column) => !column.notNull,
-	}) as any;
-};
-
-export const createUpdateSchema: CreateUpdateSchema = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, {
-		never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-		optional: () => true,
-		nullable: (column) => !column.notNull,
-	}) as any;
-};
diff --git a/drizzle-valibot/src/schema.types.internal.ts b/drizzle-valibot/src/schema.types.internal.ts
deleted file mode 100644
index 04dd499403..0000000000
--- a/drizzle-valibot/src/schema.types.internal.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import type { Assume, Column, DrizzleTypeError, SelectedFieldsFlat, Simplify, Table, View } from 'drizzle-orm';
-import type * as v from 'valibot';
-import type { ExtractAdditionalProperties, GetValibotType, HandleColumn, HasBaseColumn } from './column.types.ts';
-import type { ColumnIsGeneratedAlwaysAs, GetSelection } from './utils.ts';
-
-export interface Conditions {
-	never: (column?: Column) => boolean;
-	optional: (column: Column) => boolean;
-	nullable: (column: Column) => boolean;
-}
-
-type BuildRefineField<T> = T extends v.GenericSchema ? ((schema: T) => v.GenericSchema) | v.GenericSchema : never;
-
-export type BuildRefine<
-	TColumns extends Record<string, any>,
-> = {
-	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
-		TColumns[K] extends Column ? BuildRefineField<
-				GetValibotType<
-					TColumns[K]['_']['data'],
-					TColumns[K]['_']['dataType'],
-					TColumns[K]['_']['columnType'],
-					TColumns[K]['_']['enumValues'],
-					HasBaseColumn<TColumns[K]> extends true ? Assume<TColumns[K]['_']['baseColumn'], Column> : undefined,
-					ExtractAdditionalProperties<TColumns[K]>
-				>
-			>
-			: BuildRefine<GetSelection<TColumns[K]>>;
-};
-
-type HandleRefinement<
-	TType extends 'select' | 'insert' | 'update',
-	TRefinement,
-	TColumn extends Column,
-> = TRefinement extends (schema: any) => v.GenericSchema ? (
-		TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
-			: v.NullableSchema<ReturnType<TRefinement>, undefined>
-	) extends infer TSchema ? TType extends 'update' ? v.OptionalSchema<Assume<TSchema, v.GenericSchema>, undefined>
-		: TSchema
-	: v.AnySchema
-	: TRefinement;
-
-type IsRefinementDefined<
-	TRefinements extends Record<string | symbol | number, any> | undefined,
-	TKey extends string | symbol | number,
-> = TRefinements extends object ? TRefinements[TKey] extends v.GenericSchema | ((schema: any) => any) ? true
-	: false
-	: false;
-
-export type BuildSchema<
-	TType extends 'select' | 'insert' | 'update',
-	TColumns extends Record<string, any>,
-	TRefinements extends Record<string, any> | undefined,
-> = v.ObjectSchema<
-	Simplify<
-		{
-			readonly [K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? never : K]:
-				TColumns[K] extends infer TColumn extends Column
-					? IsRefinementDefined<TRefinements, Assume<K, string>> extends true
-						? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, v.GenericSchema>
-					: HandleColumn<TType, TColumn>
-					: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
-							TType,
-							GetSelection<TObject>,
-							TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined
-						>
-					: v.AnySchema;
-		}
-	>,
-	undefined
->;
-
-export type NoUnknownKeys<
-	TRefinement extends Record<string, any>,
-	TCompare extends Record<string, any>,
-> = {
-	[K in keyof TRefinement]: K extends keyof TCompare
-		? TRefinement[K] extends Record<string, v.GenericSchema> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
-		: TRefinement[K]
-		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
-};
diff --git a/drizzle-valibot/src/schema.types.ts b/drizzle-valibot/src/schema.types.ts
deleted file mode 100644
index c0b2ef82c5..0000000000
--- a/drizzle-valibot/src/schema.types.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type * as v from 'valibot';
-import type { EnumValuesToEnum } from './column.types.ts';
-import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
-
-export interface CreateSelectSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<TTable['_']['columns']>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferSelect']>,
-	): BuildSchema<'select', TTable['_']['columns'], TRefine>;
-
-	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined>;
-	<
-		TView extends View,
-		TRefine extends BuildRefine<TView['_']['selectedFields']>,
-	>(
-		view: TView,
-		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
-	): BuildSchema<'select', TView['_']['selectedFields'], TRefine>;
-
-	<TEnum extends PgEnum<any>>(enum_: TEnum): v.EnumSchema<EnumValuesToEnum<TEnum['enumValues']>, undefined>;
-}
-
-export interface CreateInsertSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferInsert']>,
-	): BuildSchema<'insert', TTable['_']['columns'], TRefine>;
-}
-
-export interface CreateUpdateSchema {
-	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>>,
-	>(
-		table: TTable,
-		refine?: TRefine,
-	): BuildSchema<'update', TTable['_']['columns'], TRefine>;
-}
diff --git a/drizzle-valibot/src/utils.ts b/drizzle-valibot/src/utils.ts
deleted file mode 100644
index 2f2cd0bb78..0000000000
--- a/drizzle-valibot/src/utils.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { Column, SelectedFieldsFlat, Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type * as v from 'valibot';
-import type { literalSchema } from './column.ts';
-
-export function isColumnType<T extends Column>(column: Column, columnTypes: string[]): column is T {
-	return columnTypes.includes(column.columnType);
-}
-
-export function isWithEnum(column: Column): column is typeof column & { enumValues: [string, ...string[]] } {
-	return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
-}
-
-export const isPgEnum: (entity: any) => entity is PgEnum<[string, ...string[]]> = isWithEnum as any;
-
-type Literal = v.InferOutput<typeof literalSchema>;
-export type Json = Literal | { [key: string]: any } | any[];
-
-export type IsNever<T> = [T] extends [never] ? true : false;
-
-export type IsEnumDefined<TEnum extends string[] | undefined> = [string, ...string[]] extends TEnum ? false
-	: undefined extends TEnum ? false
-	: true;
-
-export type ColumnIsGeneratedAlwaysAs<TColumn> = TColumn extends Column
-	? TColumn['_']['identity'] extends 'always' ? true
-	: TColumn['_']['generated'] extends { type: 'byDefault' } | undefined ? false
-	: true
-	: false;
-
-export type RemoveNever<T> = {
-	[K in keyof T as T[K] extends never ? never : K]: T[K];
-};
-
-export type RemoveNeverElements<T extends any[]> = T extends [infer First, ...infer Rest]
-	? IsNever<First> extends true ? RemoveNeverElements<Rest>
-	: [First, ...RemoveNeverElements<Rest>]
-	: [];
-
-export type GetSelection<T extends SelectedFieldsFlat<Column> | Table | View> = T extends Table ? T['_']['columns']
-	: T extends View ? T['_']['selectedFields']
-	: T;
diff --git a/drizzle-valibot/tests/mysql.test.ts b/drizzle-valibot/tests/mysql.test.ts
deleted file mode 100644
index a01f53de56..0000000000
--- a/drizzle-valibot/tests/mysql.test.ts
+++ /dev/null
@@ -1,511 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import * as v from 'valibot';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = v.pipe(
-	v.number(),
-	v.minValue(CONSTANTS.INT32_MIN as number),
-	v.maxValue(CONSTANTS.INT32_MAX as number),
-	v.integer(),
-);
-const serialNumberModeSchema = v.pipe(
-	v.number(),
-	v.minValue(0 as number),
-	v.maxValue(Number.MAX_SAFE_INTEGER as number),
-	v.integer(),
-);
-const textSchema = v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX as number));
-
-test('table - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = mysqlSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		id: v.optional(serialNumberModeSchema),
-		name: textSchema,
-		age: v.optional(v.nullable(intSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		id: v.optional(serialNumberModeSchema),
-		name: v.optional(textSchema),
-		age: v.optional(v.nullable(intSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: serialNumberModeSchema, age: v.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = mysqlView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({
-		id: serialNumberModeSchema,
-		nested: v.object({ name: textSchema, age: v.any() }),
-		table: v.object({ id: serialNumberModeSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: intSchema,
-		c3: v.nullable(intSchema),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: intSchema,
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(intSchema),
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(v.pipe(intSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: {
-			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		},
-		table: {
-			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c3: v.pipe(v.string(), v.transform(Number)),
-		},
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: v.object({
-			c4: v.nullable(intSchema),
-			c5: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		}),
-		table: v.object({
-			c1: v.nullable(intSchema),
-			c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-			c3: v.pipe(v.string(), v.transform(Number)),
-			c4: v.nullable(intSchema),
-			c5: v.nullable(intSchema),
-			c6: v.nullable(intSchema),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = mysqlTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		mysqlEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
-		bigint3: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		bigint4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
-		binary: v.string(),
-		boolean: v.boolean(),
-		char1: v.pipe(v.string(), v.length(10 as number)),
-		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		date1: v.date(),
-		date2: v.string(),
-		datetime1: v.date(),
-		datetime2: v.string(),
-		decimal1: v.string(),
-		decimal2: v.string(),
-		double1: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		double2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT48_UNSIGNED_MAX)),
-		float1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
-		float2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX)),
-		int1: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
-		int2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT32_UNSIGNED_MAX), v.integer()),
-		json: jsonSchema,
-		mediumint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX), v.integer()),
-		mediumint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX), v.integer()),
-		enum: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		serial: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		smallint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
-		smallint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT16_UNSIGNED_MAX), v.integer()),
-		text1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
-		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		time: v.string(),
-		timestamp1: v.date(),
-		timestamp2: v.string(),
-		tinyint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT8_MIN), v.maxValue(CONSTANTS.INT8_MAX), v.integer()),
-		tinyint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT8_UNSIGNED_MAX), v.integer()),
-		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
-		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		varbinary: v.string(),
-		year: v.pipe(v.number(), v.minValue(1901 as number), v.maxValue(2155 as number), v.integer()),
-		longtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
-		longtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		mediumtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
-		mediumtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		tinytext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
-		tinytext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
-	const table = mysqlTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		json: v.nullable(TopLevelCondition),
-	});
-	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = mysqlTable('test', { id: int() });
-	const view = mysqlView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = mysqlView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-}
diff --git a/drizzle-valibot/tests/pg.test.ts b/drizzle-valibot/tests/pg.test.ts
deleted file mode 100644
index 021aebe499..0000000000
--- a/drizzle-valibot/tests/pg.test.ts
+++ /dev/null
@@ -1,563 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import {
-	customType,
-	integer,
-	json,
-	jsonb,
-	pgEnum,
-	pgMaterializedView,
-	pgSchema,
-	pgTable,
-	pgView,
-	serial,
-	text,
-} from 'drizzle-orm/pg-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import * as v from 'valibot';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectEnumValues, expectSchemaShape } from './utils.ts';
-
-const integerSchema = v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer());
-const textSchema = v.string();
-
-test('table - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = pgSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({ name: textSchema, age: v.optional(v.nullable(integerSchema)) });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		name: v.optional(textSchema),
-		age: v.optional(v.nullable(integerSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: integerSchema, age: v.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: integerSchema, age: v.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({
-		id: integerSchema,
-		nested: v.object({ name: textSchema, age: v.any() }),
-		table: v.object({ id: integerSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('enum - select', (t) => {
-	const enum_ = pgEnum('test', ['a', 'b', 'c']);
-
-	const result = createSelectSchema(enum_);
-	const expected = v.enum({ a: 'a', b: 'b', c: 'c' });
-	expectEnumValues(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		c1: v.nullable(integerSchema),
-		c2: integerSchema,
-		c3: v.nullable(integerSchema),
-		c4: integerSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(integerSchema)),
-		c2: integerSchema,
-		c3: v.optional(v.nullable(integerSchema)),
-		c4: v.optional(integerSchema),
-		c7: v.optional(integerSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-});
-
-test('nullability - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(integerSchema)),
-		c2: v.optional(integerSchema),
-		c3: v.optional(v.nullable(integerSchema)),
-		c4: v.optional(integerSchema),
-		c7: v.optional(integerSchema),
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.nullable(integerSchema),
-		c2: v.pipe(integerSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-	const expected = v.object({
-		c1: v.nullable(integerSchema),
-		c2: v.pipe(integerSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(integerSchema)),
-		c2: v.pipe(integerSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(integerSchema)),
-		c2: v.optional(v.pipe(integerSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer(),
-		c3: integer(),
-		c4: integer(),
-		c5: integer(),
-		c6: integer(),
-	});
-	const view = pgView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: {
-			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		},
-		table: {
-			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c3: v.pipe(v.string(), v.transform(Number)),
-		},
-	});
-	const expected = v.object({
-		c1: v.nullable(integerSchema),
-		c2: v.nullable(v.pipe(integerSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: v.object({
-			c4: v.nullable(integerSchema),
-			c5: v.nullable(v.pipe(integerSchema, v.maxValue(1000))),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		}),
-		table: v.object({
-			c1: v.nullable(integerSchema),
-			c2: v.nullable(v.pipe(integerSchema, v.maxValue(1000))),
-			c3: v.pipe(v.string(), v.transform(Number)),
-			c4: v.nullable(integerSchema),
-			c5: v.nullable(integerSchema),
-			c6: v.nullable(integerSchema),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = pgTable('test', ({
-		bigint,
-		bigserial,
-		bit,
-		boolean,
-		date,
-		char,
-		cidr,
-		doublePrecision,
-		geometry,
-		halfvec,
-		inet,
-		integer,
-		interval,
-		json,
-		jsonb,
-		line,
-		macaddr,
-		macaddr8,
-		numeric,
-		point,
-		real,
-		serial,
-		smallint,
-		smallserial,
-		text,
-		sparsevec,
-		time,
-		timestamp,
-		uuid,
-		varchar,
-		vector,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigserial1: bigserial({ mode: 'number' }).notNull(),
-		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
-		bit: bit({ dimensions: 5 }).notNull(),
-		boolean: boolean().notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		cidr: cidr().notNull(),
-		doublePrecision: doublePrecision().notNull(),
-		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
-		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
-		halfvec: halfvec({ dimensions: 3 }).notNull(),
-		inet: inet().notNull(),
-		integer: integer().notNull(),
-		interval: interval().notNull(),
-		json: json().notNull(),
-		jsonb: jsonb().notNull(),
-		line1: line({ mode: 'abc' }).notNull(),
-		line2: line({ mode: 'tuple' }).notNull(),
-		macaddr: macaddr().notNull(),
-		macaddr8: macaddr8().notNull(),
-		numeric: numeric().notNull(),
-		point1: point({ mode: 'xy' }).notNull(),
-		point2: point({ mode: 'tuple' }).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint: smallint().notNull(),
-		smallserial: smallserial().notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		uuid: uuid().notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		vector: vector({ dimensions: 3 }).notNull(),
-		array1: integer().array().notNull(),
-		array2: integer().array().array(2).notNull(),
-		array3: varchar({ length: 10 }).array().array(2).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
-		bigserial1: v.pipe(
-			v.number(),
-			v.minValue(Number.MIN_SAFE_INTEGER),
-			v.maxValue(Number.MAX_SAFE_INTEGER),
-			v.integer(),
-		),
-		bigserial2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
-		bit: v.pipe(v.string(), v.regex(/^[01]+$/), v.maxLength(5 as number)),
-		boolean: v.boolean(),
-		date1: v.date(),
-		date2: v.string(),
-		char1: v.pipe(v.string(), v.length(10 as number)),
-		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		cidr: v.string(),
-		doublePrecision: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		geometry1: v.tuple([v.number(), v.number()]),
-		geometry2: v.object({ x: v.number(), y: v.number() }),
-		halfvec: v.pipe(v.array(v.number()), v.length(3 as number)),
-		inet: v.string(),
-		integer: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
-		interval: v.string(),
-		json: jsonSchema,
-		jsonb: jsonSchema,
-		line1: v.object({ a: v.number(), b: v.number(), c: v.number() }),
-		line2: v.tuple([v.number(), v.number(), v.number()]),
-		macaddr: v.string(),
-		macaddr8: v.string(),
-		numeric: v.string(),
-		point1: v.object({ x: v.number(), y: v.number() }),
-		point2: v.tuple([v.number(), v.number()]),
-		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
-		serial: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
-		smallint: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
-		smallserial: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
-		text1: v.string(),
-		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		sparsevec: v.string(),
-		time: v.string(),
-		timestamp1: v.date(),
-		timestamp2: v.string(),
-		uuid: v.pipe(v.string(), v.uuid()),
-		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
-		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		vector: v.pipe(v.array(v.number()), v.length(3 as number)),
-		array1: v.array(integerSchema),
-		array2: v.pipe(v.array(v.array(integerSchema)), v.length(2 as number)),
-		array3: v.pipe(v.array(v.array(v.pipe(v.string(), v.maxLength(10 as number)))), v.length(2 as number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
-	const table = pgTable('test', {
-		json: json().$type<TopLevelCondition>().notNull(),
-		jsonb: jsonb().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		json: TopLevelCondition,
-		jsonb: v.nullable(TopLevelCondition),
-	});
-	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = pgTable('test', { id: integer() });
-	const view = pgView('test').as((qb) => qb.select().from(table));
-	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: v.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = pgView('test', { id: integer() }).as(sql``);
-	const mView = pgView('test', { id: integer() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: v.string() });
-}
diff --git a/drizzle-valibot/tests/singlestore.test.ts b/drizzle-valibot/tests/singlestore.test.ts
deleted file mode 100644
index 1ddb5e8563..0000000000
--- a/drizzle-valibot/tests/singlestore.test.ts
+++ /dev/null
@@ -1,513 +0,0 @@
-import { type Equal } from 'drizzle-orm';
-import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import * as v from 'valibot';
-import { test } from 'vitest';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = v.pipe(
-	v.number(),
-	v.minValue(CONSTANTS.INT32_MIN as number),
-	v.maxValue(CONSTANTS.INT32_MAX as number),
-	v.integer(),
-);
-const serialNumberModeSchema = v.pipe(
-	v.number(),
-	v.minValue(0 as number),
-	v.maxValue(Number.MAX_SAFE_INTEGER as number),
-	v.integer(),
-);
-const textSchema = v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX as number));
-
-test('table - select', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = singlestoreSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		id: v.optional(serialNumberModeSchema),
-		name: textSchema,
-		age: v.optional(v.nullable(intSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		id: v.optional(serialNumberModeSchema),
-		name: v.optional(textSchema),
-		age: v.optional(v.nullable(intSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// TODO: SingleStore doesn't support views yet. Add these tests when they're added
-
-// test('view qb - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({ id: serialNumberModeSchema, age: v.any() });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view columns - select', (t) => {
-// 	const view = mysqlView('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	}).as(sql``);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({ id: serialNumberModeSchema, name: textSchema });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view with nested fields - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			id: table.id,
-// 			nested: {
-// 				name: table.name,
-// 				age: sql``.as('age'),
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = v.object({
-// 		id: serialNumberModeSchema,
-// 		nested: v.object({ name: textSchema, age: v.any() }),
-// 		table: v.object({ id: serialNumberModeSchema, name: textSchema }),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('nullability - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: intSchema,
-		c3: v.nullable(intSchema),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: intSchema,
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(intSchema),
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(v.pipe(intSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// test('refine view - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		c1: int(),
-// 		c2: int(),
-// 		c3: int(),
-// 		c4: int(),
-// 		c5: int(),
-// 		c6: int(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			c1: table.c1,
-// 			c2: table.c2,
-// 			c3: table.c3,
-// 			nested: {
-// 				c4: table.c4,
-// 				c5: table.c5,
-// 				c6: table.c6,
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view, {
-// 		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 		c3: v.pipe(v.string(), v.transform(Number)),
-// 		nested: {
-// 			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 			c6: v.pipe(v.string(), v.transform(Number)),
-// 		},
-// 		table: {
-// 			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-// 			c3: v.pipe(v.string(), v.transform(Number)),
-// 		},
-// 	});
-// 	const expected = v.object({
-// 		c1: v.nullable(intSchema),
-// 		c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 		c3: v.pipe(v.string(), v.transform(Number)),
-// 		nested: v.object({
-// 			c4: v.nullable(intSchema),
-// 			c5: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 			c6: v.pipe(v.string(), v.transform(Number)),
-// 		}),
-// 		table: v.object({
-// 			c1: v.nullable(intSchema),
-// 			c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-// 			c3: v.pipe(v.string(), v.transform(Number)),
-// 			c4: v.nullable(intSchema),
-// 			c5: v.nullable(intSchema),
-// 			c6: v.nullable(intSchema),
-// 		}),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('all data types', (t) => {
-	const table = singlestoreTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		singlestoreEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
-		bigint3: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		bigint4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
-		binary: v.string(),
-		boolean: v.boolean(),
-		char1: v.pipe(v.string(), v.length(10 as number)),
-		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		date1: v.date(),
-		date2: v.string(),
-		datetime1: v.date(),
-		datetime2: v.string(),
-		decimal1: v.string(),
-		decimal2: v.string(),
-		double1: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		double2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT48_UNSIGNED_MAX)),
-		float1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
-		float2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX)),
-		int1: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
-		int2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT32_UNSIGNED_MAX), v.integer()),
-		json: jsonSchema,
-		mediumint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX), v.integer()),
-		mediumint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX), v.integer()),
-		enum: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		serial: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		smallint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
-		smallint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT16_UNSIGNED_MAX), v.integer()),
-		text1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
-		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		time: v.string(),
-		timestamp1: v.date(),
-		timestamp2: v.string(),
-		tinyint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT8_MIN), v.maxValue(CONSTANTS.INT8_MAX), v.integer()),
-		tinyint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT8_UNSIGNED_MAX), v.integer()),
-		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
-		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		varbinary: v.string(),
-		year: v.pipe(v.number(), v.minValue(1901 as number), v.maxValue(2155 as number), v.integer()),
-		longtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
-		longtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		mediumtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
-		mediumtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		tinytext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
-		tinytext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
-	const table = singlestoreTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		json: v.nullable(TopLevelCondition),
-	});
-	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: v.string() });
-}
-
-// /* Disallow unknown keys in view qb - select */ {
-// 	const table = singlestoreTable('test', { id: int() });
-// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
-// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: v.string() });
-// 	// @ts-expect-error
-// 	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
-// }
-
-// /* Disallow unknown keys in view columns - select */ {
-// 	const view = mysqlView('test', { id: int() }).as(sql``);
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: v.string() });
-// }
diff --git a/drizzle-valibot/tests/sqlite.test.ts b/drizzle-valibot/tests/sqlite.test.ts
deleted file mode 100644
index e0af4bd462..0000000000
--- a/drizzle-valibot/tests/sqlite.test.ts
+++ /dev/null
@@ -1,405 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import * as v from 'valibot';
-import { test } from 'vitest';
-import { bufferSchema, jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = v.pipe(
-	v.number(),
-	v.minValue(Number.MIN_SAFE_INTEGER),
-	v.maxValue(Number.MAX_SAFE_INTEGER),
-	v.integer(),
-);
-const textSchema = v.string();
-
-test('table - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({ id: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({ id: v.optional(intSchema), name: textSchema, age: v.optional(v.nullable(intSchema)) });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		id: v.optional(intSchema),
-		name: v.optional(textSchema),
-		age: v.optional(v.nullable(intSchema)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: intSchema, age: v.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = sqliteView('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({ id: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = v.object({
-		id: intSchema,
-		nested: v.object({ name: textSchema, age: v.any() }),
-		table: v.object({ id: intSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: intSchema,
-		c3: v.nullable(intSchema),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: intSchema,
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(intSchema),
-		c3: v.optional(v.nullable(intSchema)),
-		c4: v.optional(intSchema),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
-	const result = createSelectSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.pipe(intSchema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	const expected = v.object({
-		c1: v.optional(v.nullable(intSchema)),
-		c2: v.optional(v.pipe(intSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: {
-			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		},
-		table: {
-			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
-			c3: v.pipe(v.string(), v.transform(Number)),
-		},
-	});
-	const expected = v.object({
-		c1: v.nullable(intSchema),
-		c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-		c3: v.pipe(v.string(), v.transform(Number)),
-		nested: v.object({
-			c4: v.nullable(intSchema),
-			c5: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-			c6: v.pipe(v.string(), v.transform(Number)),
-		}),
-		table: v.object({
-			c1: v.nullable(intSchema),
-			c2: v.nullable(v.pipe(intSchema, v.maxValue(1000))),
-			c3: v.pipe(v.string(), v.transform(Number)),
-			c4: v.nullable(intSchema),
-			c5: v.nullable(intSchema),
-			c6: v.nullable(intSchema),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = sqliteTable('test', ({
-		blob,
-		integer,
-		numeric,
-		real,
-		text,
-	}) => ({
-		blob1: blob({ mode: 'buffer' }).notNull(),
-		blob2: blob({ mode: 'bigint' }).notNull(),
-		blob3: blob({ mode: 'json' }).notNull(),
-		integer1: integer({ mode: 'number' }).notNull(),
-		integer2: integer({ mode: 'boolean' }).notNull(),
-		integer3: integer({ mode: 'timestamp' }).notNull(),
-		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
-		numeric: numeric().notNull(),
-		real: real().notNull(),
-		text1: text({ mode: 'text' }).notNull(),
-		text2: text({ mode: 'text', length: 10 }).notNull(),
-		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
-		text4: text({ mode: 'json' }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		blob1: bufferSchema,
-		blob2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
-		blob3: jsonSchema,
-		integer1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
-		integer2: v.boolean(),
-		integer3: v.date(),
-		integer4: v.date(),
-		numeric: v.string(),
-		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
-		text1: v.string(),
-		text2: v.pipe(v.string(), v.maxLength(10 as number)),
-		text3: v.enum({ a: 'a', b: 'b', c: 'c' }),
-		text4: jsonSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
-	const table = sqliteTable('test', {
-		json1: text({ mode: 'json' }).$type<TopLevelCondition>().notNull(),
-		json2: blob({ mode: 'json' }).$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = v.object({
-		json1: TopLevelCondition,
-		json2: v.nullable(TopLevelCondition),
-	});
-	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: v.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = sqliteTable('test', { id: int() });
-	const view = sqliteView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = sqliteView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: v.string() });
-}
diff --git a/drizzle-valibot/tests/tsconfig.json b/drizzle-valibot/tests/tsconfig.json
deleted file mode 100644
index 18f5dee497..0000000000
--- a/drizzle-valibot/tests/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"noEmit": true,
-		"rootDir": "..",
-		"outDir": "./.cache"
-	},
-	"include": [".", "../src"]
-}
diff --git a/drizzle-valibot/tests/utils.ts b/drizzle-valibot/tests/utils.ts
deleted file mode 100644
index 7e1eae7570..0000000000
--- a/drizzle-valibot/tests/utils.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import type * as v from 'valibot';
-import { expect, type TaskContext } from 'vitest';
-
-function onlySpecifiedKeys(obj: Record<string, any>, keys: string[]) {
-	return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
-}
-
-export function expectSchemaShape<T extends v.ObjectSchema<v.ObjectEntries, undefined>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(Object.keys(actual.entries)).toStrictEqual(Object.keys(expected.entries));
-
-			for (const key of Object.keys(actual.entries)) {
-				const actualEntry = actual.entries[key] as any;
-				const expectedEntry = expected.entries[key] as any;
-				const keys = ['kind', 'type', 'expects', 'async', 'message'];
-				actualEntry.pipe ??= [];
-				expectedEntry.pipe ??= [];
-
-				expect(onlySpecifiedKeys(actualEntry, keys)).toStrictEqual(onlySpecifiedKeys(expectedEntry, keys));
-				expect(actualEntry.pipe.length).toStrictEqual(expectedEntry.pipe.length);
-
-				for (let i = 0; i < actualEntry.pipe.length; i++) {
-					const actualPipeElement = actualEntry.pipe[i];
-					const expectedPipeElement = expectedEntry.pipe[i];
-					expect(onlySpecifiedKeys(actualPipeElement, keys)).toStrictEqual(
-						onlySpecifiedKeys(expectedPipeElement, keys),
-					);
-				}
-			}
-		},
-	};
-}
-
-export function expectEnumValues<T extends v.EnumSchema<any, undefined>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(actual.enum).toStrictEqual(expected.enum);
-		},
-	};
-}
-
-export function Expect<_ extends true>() {}
diff --git a/drizzle-valibot/tsconfig.build.json b/drizzle-valibot/tsconfig.build.json
deleted file mode 100644
index 3377281baa..0000000000
--- a/drizzle-valibot/tsconfig.build.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"extends": "./tsconfig.json",
-	"compilerOptions": {
-		"rootDir": "src"
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-valibot/tsconfig.json b/drizzle-valibot/tsconfig.json
deleted file mode 100644
index c25379c37b..0000000000
--- a/drizzle-valibot/tsconfig.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"baseUrl": ".",
-		"declaration": true,
-		"noEmit": true,
-		"paths": {
-			"~/*": ["src/*"]
-		}
-	},
-	"include": ["src", "*.ts"]
-}
diff --git a/drizzle-valibot/vitest.config.ts b/drizzle-valibot/vitest.config.ts
deleted file mode 100644
index 1f0eb7ad9a..0000000000
--- a/drizzle-valibot/vitest.config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-	test: {
-		include: [
-			'tests/**/*.test.ts',
-		],
-		exclude: [
-			'tests/bun/**/*',
-		],
-		typecheck: {
-			tsconfig: 'tsconfig.json',
-		},
-		testTimeout: 100000,
-		hookTimeout: 100000,
-		isolate: false,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-	},
-	plugins: [tsconfigPaths()],
-});
diff --git a/drizzle-zod/README.md b/drizzle-zod/README.md
deleted file mode 100644
index 46eced0344..0000000000
--- a/drizzle-zod/README.md
+++ /dev/null
@@ -1,65 +0,0 @@
-<div align='center'>
-<h1>drizzle-zod <a href=''><img alt='npm' src='https://img.shields.io/npm/v/drizzle-zod?label='></a></h1>
-<img alt='npm' src='https://img.shields.io/npm/dm/drizzle-zod'>
-<img alt='npm bundle size' src='https://img.shields.io/bundlephobia/min/drizzle-zod'>
-<a href='https://discord.gg/yfjTbVXMW4'><img alt='Discord' src='https://img.shields.io/discord/1043890932593987624'></a>
-<img alt='License' src='https://img.shields.io/npm/l/drizzle-zod'>
-<h6><i>If you know SQL, you know Drizzle ORM</i></h6>
-<hr />
-</div>
-
-`drizzle-zod` is a plugin for [Drizzle ORM](https://github.com/drizzle-team/drizzle-orm) that allows you to generate [Zod](https://zod.dev/) schemas from Drizzle ORM schemas.
-
-**Features**
-
-- Create a select schema for tables, views and enums.
-- Create insert and update schemas for tables.
-- Supports all dialects: PostgreSQL, MySQL and SQLite.
-
-# Usage
-
-```ts
-import { pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import { createInsertSchema, createSelectSchema } from 'drizzle-zod';
-import { z } from 'zod';
-
-const users = pgTable('users', {
-  id: serial('id').primaryKey(),
-  name: text('name').notNull(),
-  email: text('email').notNull(),
-  role: text('role', { enum: ['admin', 'user'] }).notNull(),
-  createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-// Schema for inserting a user - can be used to validate API requests
-const insertUserSchema = createInsertSchema(users);
-
-// Schema for updating a user - can be used to validate API requests
-const updateUserSchema = createUpdateSchema(users);
-
-// Schema for selecting a user - can be used to validate API responses
-const selectUserSchema = createSelectSchema(users);
-
-// Overriding the fields
-const insertUserSchema = createInsertSchema(users, {
-  role: z.string(),
-});
-
-// Refining the fields - useful if you want to change the fields before they become nullable/optional in the final schema
-const insertUserSchema = createInsertSchema(users, {
-  id: (schema) => schema.positive(),
-  email: (schema) => schema.email(),
-  role: z.string(),
-});
-
-// Usage
-
-const user = insertUserSchema.parse({
-  name: 'John Doe',
-  email: 'johndoe@test.com',
-  role: 'admin',
-});
-
-// Zod schema type is also inferred from the table schema, so you have full type safety
-const requestSchema = insertUserSchema.pick({ name: true, email: true });
-```
diff --git a/drizzle-zod/package.json b/drizzle-zod/package.json
deleted file mode 100644
index 316cc1d118..0000000000
--- a/drizzle-zod/package.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
-	"name": "drizzle-zod",
-	"version": "0.8.2",
-	"description": "Generate Zod schemas from Drizzle ORM schemas",
-	"type": "module",
-	"scripts": {
-		"build": "tsx scripts/build.ts",
-		"b": "pnpm build",
-		"test:types": "cd tests && tsc",
-		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
-		"publish": "npm publish package.tgz",
-		"test": "vitest run"
-	},
-	"exports": {
-		".": {
-			"import": {
-				"types": "./index.d.mts",
-				"default": "./index.mjs"
-			},
-			"require": {
-				"types": "./index.d.cjs",
-				"default": "./index.cjs"
-			},
-			"types": "./index.d.ts",
-			"default": "./index.mjs"
-		}
-	},
-	"main": "./index.cjs",
-	"module": "./index.mjs",
-	"types": "./index.d.ts",
-	"publishConfig": {
-		"provenance": true
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/drizzle-team/drizzle-orm.git"
-	},
-	"ava": {
-		"files": [
-			"tests/**/*.test.ts",
-			"!tests/bun/**/*"
-		],
-		"extensions": {
-			"ts": "module"
-		}
-	},
-	"keywords": [
-		"zod",
-		"validate",
-		"validation",
-		"schema",
-		"drizzle",
-		"orm",
-		"pg",
-		"mysql",
-		"postgresql",
-		"postgres",
-		"sqlite",
-		"database",
-		"sql",
-		"typescript",
-		"ts"
-	],
-	"author": "Drizzle Team",
-	"license": "Apache-2.0",
-	"peerDependencies": {
-		"drizzle-orm": ">=0.36.0",
-		"zod": "^3.25.1"
-	},
-	"devDependencies": {
-		"@rollup/plugin-typescript": "^11.1.0",
-		"@types/node": "^18.15.10",
-		"cpy": "^10.1.0",
-		"drizzle-orm": "link:../drizzle-orm/dist",
-		"json-rules-engine": "^7.3.1",
-		"rimraf": "^5.0.0",
-		"rollup": "^3.29.5",
-		"vite-tsconfig-paths": "^4.3.2",
-		"vitest": "^3.1.3",
-		"zod": "3.25.1",
-		"zx": "^7.2.2"
-	}
-}
diff --git a/drizzle-zod/rollup.config.ts b/drizzle-zod/rollup.config.ts
deleted file mode 100644
index 2049cc5ad8..0000000000
--- a/drizzle-zod/rollup.config.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-export default defineConfig([
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				format: 'esm',
-				dir: 'dist',
-				entryFileNames: '[name].mjs',
-				chunkFileNames: '[name]-[hash].mjs',
-				sourcemap: true,
-			},
-			{
-				format: 'cjs',
-				dir: 'dist',
-				entryFileNames: '[name].cjs',
-				chunkFileNames: '[name]-[hash].cjs',
-				sourcemap: true,
-			},
-		],
-		external: [
-			/^drizzle-orm\/?/,
-			'zod',
-		],
-		plugins: [
-			typescript({
-				tsconfig: 'tsconfig.build.json',
-			}),
-		],
-	},
-]);
diff --git a/drizzle-zod/scripts/build.ts b/drizzle-zod/scripts/build.ts
deleted file mode 100755
index 07330ffd0a..0000000000
--- a/drizzle-zod/scripts/build.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
-
-await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await fs.copy('package.json', 'dist/package.json');
-await $`scripts/fix-imports.ts`;
diff --git a/drizzle-zod/scripts/fix-imports.ts b/drizzle-zod/scripts/fix-imports.ts
deleted file mode 100755
index a90057c5b9..0000000000
--- a/drizzle-zod/scripts/fix-imports.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-
-import path from 'node:path';
-import { parse, print, visit } from 'recast';
-import parser from 'recast/parsers/typescript';
-
-function resolvePathAlias(importPath: string, file: string) {
-	if (importPath.startsWith('~/')) {
-		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
-		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
-	}
-
-	return importPath;
-}
-
-function fixImportPath(importPath: string, file: string, ext: string) {
-	importPath = resolvePathAlias(importPath, file);
-
-	if (!/\..*\.(js|ts)$/.test(importPath)) {
-		return importPath;
-	}
-
-	return importPath.replace(/\.(js|ts)$/, ext);
-}
-
-const cjsFiles = await glob('dist/**/*.{cjs,d.cts}');
-
-await Promise.all(cjsFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitCallExpression(path) {
-			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
-				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.cjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-let esmFiles = await glob('dist/**/*.{js,d.ts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.js');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
-
-esmFiles = await glob('dist/**/*.{mjs,d.mts}');
-
-await Promise.all(esmFiles.map(async (file) => {
-	const code = parse(await fs.readFile(file, 'utf8'), { parser });
-
-	visit(code, {
-		visitImportDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportAllDeclaration(path) {
-			path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitExportNamedDeclaration(path) {
-			if (path.value.source) {
-				path.value.source.value = fixImportPath(path.value.source.value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-		visitTSImportType(path) {
-			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.mjs');
-			this.traverse(path);
-		},
-		visitAwaitExpression(path) {
-			if (print(path.value).code.startsWith(`await import("./`)) {
-				path.value.argument.arguments[0].value = fixImportPath(path.value.argument.arguments[0].value, file, '.mjs');
-			}
-			this.traverse(path);
-		},
-	});
-
-	await fs.writeFile(file, print(code).code);
-}));
diff --git a/drizzle-zod/src/column.ts b/drizzle-zod/src/column.ts
deleted file mode 100644
index 996bd97720..0000000000
--- a/drizzle-zod/src/column.ts
+++ /dev/null
@@ -1,319 +0,0 @@
-import type { Column, ColumnBaseConfig } from 'drizzle-orm';
-import type {
-	MySqlBigInt53,
-	MySqlChar,
-	MySqlDouble,
-	MySqlFloat,
-	MySqlInt,
-	MySqlMediumInt,
-	MySqlReal,
-	MySqlSerial,
-	MySqlSmallInt,
-	MySqlText,
-	MySqlTinyInt,
-	MySqlVarChar,
-	MySqlYear,
-} from 'drizzle-orm/mysql-core';
-import type {
-	PgArray,
-	PgBigInt53,
-	PgBigSerial53,
-	PgBinaryVector,
-	PgChar,
-	PgDoublePrecision,
-	PgGeometry,
-	PgGeometryObject,
-	PgHalfVector,
-	PgInteger,
-	PgLineABC,
-	PgLineTuple,
-	PgPointObject,
-	PgPointTuple,
-	PgReal,
-	PgSerial,
-	PgSmallInt,
-	PgSmallSerial,
-	PgUUID,
-	PgVarchar,
-	PgVector,
-} from 'drizzle-orm/pg-core';
-import type {
-	SingleStoreBigInt53,
-	SingleStoreChar,
-	SingleStoreDouble,
-	SingleStoreFloat,
-	SingleStoreInt,
-	SingleStoreMediumInt,
-	SingleStoreReal,
-	SingleStoreSerial,
-	SingleStoreSmallInt,
-	SingleStoreText,
-	SingleStoreTinyInt,
-	SingleStoreVarChar,
-	SingleStoreYear,
-} from 'drizzle-orm/singlestore-core';
-import type { SQLiteInteger, SQLiteReal, SQLiteText } from 'drizzle-orm/sqlite-core';
-import { z as zod } from 'zod/v4';
-import { CONSTANTS } from './constants.ts';
-import type { CreateSchemaFactoryOptions } from './schema.types.ts';
-import { isColumnType, isWithEnum } from './utils.ts';
-import type { Json } from './utils.ts';
-
-export const literalSchema = zod.union([zod.string(), zod.number(), zod.boolean(), zod.null()]);
-export const jsonSchema: zod.ZodType<Json> = zod.union([
-	literalSchema,
-	zod.record(zod.string(), zod.any()),
-	zod.array(zod.any()),
-]);
-export const bufferSchema: zod.ZodType<Buffer> = zod.custom<Buffer>((v) => v instanceof Buffer); // eslint-disable-line no-instanceof/no-instanceof
-
-export function columnToSchema(
-	column: Column,
-	factory:
-		| CreateSchemaFactoryOptions<
-			Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-		>
-		| undefined,
-): zod.ZodType {
-	const z: typeof zod = factory?.zodInstance ?? zod;
-	const coerce = factory?.coerce ?? {};
-	let schema!: zod.ZodType;
-
-	if (isWithEnum(column)) {
-		schema = column.enumValues.length ? z.enum(column.enumValues) : z.string();
-	}
-
-	if (!schema) {
-		// Handle specific types
-		if (isColumnType<PgGeometry<any> | PgPointTuple<any>>(column, ['PgGeometry', 'PgPointTuple'])) {
-			schema = z.tuple([z.number(), z.number()]);
-		} else if (
-			isColumnType<PgPointObject<any> | PgGeometryObject<any>>(column, ['PgGeometryObject', 'PgPointObject'])
-		) {
-			schema = z.object({ x: z.number(), y: z.number() });
-		} else if (isColumnType<PgHalfVector<any> | PgVector<any>>(column, ['PgHalfVector', 'PgVector'])) {
-			schema = z.array(z.number());
-			schema = column.dimensions ? (schema as zod.ZodArray<any>).length(column.dimensions) : schema;
-		} else if (isColumnType<PgLineTuple<any>>(column, ['PgLine'])) {
-			schema = z.tuple([z.number(), z.number(), z.number()]);
-		} else if (isColumnType<PgLineABC<any>>(column, ['PgLineABC'])) {
-			schema = z.object({
-				a: z.number(),
-				b: z.number(),
-				c: z.number(),
-			});
-		} // Handle other types
-		else if (isColumnType<PgArray<any, any>>(column, ['PgArray'])) {
-			schema = z.array(columnToSchema(column.baseColumn, factory));
-			schema = column.size ? (schema as zod.ZodArray<any>).length(column.size) : schema;
-		} else if (column.dataType === 'array') {
-			schema = z.array(z.any());
-		} else if (column.dataType === 'number') {
-			schema = numberColumnToSchema(column, z, coerce);
-		} else if (column.dataType === 'bigint') {
-			schema = bigintColumnToSchema(column, z, coerce);
-		} else if (column.dataType === 'boolean') {
-			schema = coerce === true || coerce.boolean ? z.coerce.boolean() : z.boolean();
-		} else if (column.dataType === 'date') {
-			schema = coerce === true || coerce.date ? z.coerce.date() : z.date();
-		} else if (column.dataType === 'string') {
-			schema = stringColumnToSchema(column, z, coerce);
-		} else if (column.dataType === 'json') {
-			schema = jsonSchema;
-		} else if (column.dataType === 'custom') {
-			schema = z.any();
-		} else if (column.dataType === 'buffer') {
-			schema = bufferSchema;
-		}
-	}
-
-	if (!schema) {
-		schema = z.any();
-	}
-
-	return schema;
-}
-
-function numberColumnToSchema(
-	column: Column,
-	z: typeof zod,
-	coerce: CreateSchemaFactoryOptions<
-		Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-	>['coerce'],
-): zod.ZodType {
-	let unsigned = column.getSQLType().includes('unsigned');
-	let min!: number;
-	let max!: number;
-	let integer = false;
-
-	if (isColumnType<MySqlTinyInt<any> | SingleStoreTinyInt<any>>(column, ['MySqlTinyInt', 'SingleStoreTinyInt'])) {
-		min = unsigned ? 0 : CONSTANTS.INT8_MIN;
-		max = unsigned ? CONSTANTS.INT8_UNSIGNED_MAX : CONSTANTS.INT8_MAX;
-		integer = true;
-	} else if (
-		isColumnType<PgSmallInt<any> | PgSmallSerial<any> | MySqlSmallInt<any> | SingleStoreSmallInt<any>>(column, [
-			'PgSmallInt',
-			'PgSmallSerial',
-			'MySqlSmallInt',
-			'SingleStoreSmallInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT16_MIN;
-		max = unsigned ? CONSTANTS.INT16_UNSIGNED_MAX : CONSTANTS.INT16_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			PgReal<any> | MySqlFloat<any> | MySqlMediumInt<any> | SingleStoreMediumInt<any> | SingleStoreFloat<any>
-		>(column, [
-			'PgReal',
-			'MySqlFloat',
-			'MySqlMediumInt',
-			'SingleStoreMediumInt',
-			'SingleStoreFloat',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT24_MIN;
-		max = unsigned ? CONSTANTS.INT24_UNSIGNED_MAX : CONSTANTS.INT24_MAX;
-		integer = isColumnType(column, ['MySqlMediumInt', 'SingleStoreMediumInt']);
-	} else if (
-		isColumnType<PgInteger<any> | PgSerial<any> | MySqlInt<any> | SingleStoreInt<any>>(column, [
-			'PgInteger',
-			'PgSerial',
-			'MySqlInt',
-			'SingleStoreInt',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT32_MIN;
-		max = unsigned ? CONSTANTS.INT32_UNSIGNED_MAX : CONSTANTS.INT32_MAX;
-		integer = true;
-	} else if (
-		isColumnType<
-			| PgDoublePrecision<any>
-			| MySqlReal<any>
-			| MySqlDouble<any>
-			| SingleStoreReal<any>
-			| SingleStoreDouble<any>
-			| SQLiteReal<any>
-		>(column, [
-			'PgDoublePrecision',
-			'MySqlReal',
-			'MySqlDouble',
-			'SingleStoreReal',
-			'SingleStoreDouble',
-			'SQLiteReal',
-		])
-	) {
-		min = unsigned ? 0 : CONSTANTS.INT48_MIN;
-		max = unsigned ? CONSTANTS.INT48_UNSIGNED_MAX : CONSTANTS.INT48_MAX;
-	} else if (
-		isColumnType<
-			| PgBigInt53<any>
-			| PgBigSerial53<any>
-			| MySqlBigInt53<any>
-			| MySqlSerial<any>
-			| SingleStoreBigInt53<any>
-			| SingleStoreSerial<any>
-			| SQLiteInteger<any>
-		>(
-			column,
-			[
-				'PgBigInt53',
-				'PgBigSerial53',
-				'MySqlBigInt53',
-				'MySqlSerial',
-				'SingleStoreBigInt53',
-				'SingleStoreSerial',
-				'SQLiteInteger',
-			],
-		)
-	) {
-		unsigned = unsigned || isColumnType(column, ['MySqlSerial', 'SingleStoreSerial']);
-		min = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-		integer = true;
-	} else if (isColumnType<MySqlYear<any> | SingleStoreYear<any>>(column, ['MySqlYear', 'SingleStoreYear'])) {
-		min = 1901;
-		max = 2155;
-		integer = true;
-	} else {
-		min = Number.MIN_SAFE_INTEGER;
-		max = Number.MAX_SAFE_INTEGER;
-	}
-
-	let schema = coerce === true || coerce?.number
-		? integer ? z.coerce.number() : z.coerce.number().int()
-		: integer
-		? z.int()
-		: z.number();
-	schema = schema.gte(min).lte(max);
-	return schema;
-}
-
-function bigintColumnToSchema(
-	column: Column,
-	z: typeof zod,
-	coerce: CreateSchemaFactoryOptions<
-		Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-	>['coerce'],
-): zod.ZodType {
-	const unsigned = column.getSQLType().includes('unsigned');
-	const min = unsigned ? 0n : CONSTANTS.INT64_MIN;
-	const max = unsigned ? CONSTANTS.INT64_UNSIGNED_MAX : CONSTANTS.INT64_MAX;
-
-	const schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
-	return schema.gte(min).lte(max);
-}
-
-function stringColumnToSchema(
-	column: Column,
-	z: typeof zod,
-	coerce: CreateSchemaFactoryOptions<
-		Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-	>['coerce'],
-): zod.ZodType {
-	if (isColumnType<PgUUID<ColumnBaseConfig<'string', 'PgUUID'>>>(column, ['PgUUID'])) {
-		return z.uuid();
-	}
-
-	let max: number | undefined;
-	let regex: RegExp | undefined;
-	let fixed = false;
-
-	if (isColumnType<PgVarchar<any> | SQLiteText<any>>(column, ['PgVarchar', 'SQLiteText'])) {
-		max = column.length;
-	} else if (
-		isColumnType<MySqlVarChar<any> | SingleStoreVarChar<any>>(column, ['MySqlVarChar', 'SingleStoreVarChar'])
-	) {
-		max = column.length ?? CONSTANTS.INT16_UNSIGNED_MAX;
-	} else if (isColumnType<MySqlText<any> | SingleStoreText<any>>(column, ['MySqlText', 'SingleStoreText'])) {
-		if (column.textType === 'longtext') {
-			max = CONSTANTS.INT32_UNSIGNED_MAX;
-		} else if (column.textType === 'mediumtext') {
-			max = CONSTANTS.INT24_UNSIGNED_MAX;
-		} else if (column.textType === 'text') {
-			max = CONSTANTS.INT16_UNSIGNED_MAX;
-		} else {
-			max = CONSTANTS.INT8_UNSIGNED_MAX;
-		}
-	}
-
-	if (
-		isColumnType<PgChar<any> | MySqlChar<any> | SingleStoreChar<any>>(column, [
-			'PgChar',
-			'MySqlChar',
-			'SingleStoreChar',
-		])
-	) {
-		max = column.length;
-		fixed = true;
-	}
-
-	if (isColumnType<PgBinaryVector<any>>(column, ['PgBinaryVector'])) {
-		regex = /^[01]+$/;
-		max = column.dimensions;
-	}
-
-	let schema = coerce === true || coerce?.string ? z.coerce.string() : z.string();
-	schema = regex ? schema.regex(regex) : schema;
-	return max && fixed ? schema.length(max) : max ? schema.max(max) : schema;
-}
diff --git a/drizzle-zod/src/column.types.ts b/drizzle-zod/src/column.types.ts
deleted file mode 100644
index 8f775b1354..0000000000
--- a/drizzle-zod/src/column.types.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import type { Assume, Column } from 'drizzle-orm';
-import type { z } from 'zod/v4';
-import type { IsEnumDefined, IsNever, Json } from './utils.ts';
-
-type HasBaseColumn<TColumn> = TColumn extends { _: { baseColumn: Column | undefined } }
-	? IsNever<TColumn['_']['baseColumn']> extends false ? true
-	: false
-	: false;
-
-export type GetZodType<
-	TColumn extends Column,
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> = HasBaseColumn<TColumn> extends true ? z.ZodArray<
-		GetZodType<Assume<TColumn['_']['baseColumn'], Column>, TCoerce>
-	>
-	: TColumn['_']['columnType'] extends 'PgUUID' ? z.ZodUUID
-	: IsEnumDefined<TColumn['_']['enumValues']> extends true
-		? z.ZodEnum<{ [K in Assume<TColumn['_']['enumValues'], [string, ...string[]]>[number]]: K }>
-	: TColumn['_']['columnType'] extends 'PgGeometry' | 'PgPointTuple' ? z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>
-	: TColumn['_']['columnType'] extends 'PgLine' ? z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>
-	: TColumn['_']['data'] extends Date ? CanCoerce<TCoerce, 'date'> extends true ? z.coerce.ZodCoercedDate : z.ZodDate
-	: TColumn['_']['data'] extends Buffer ? z.ZodType<Buffer>
-	: TColumn['_']['dataType'] extends 'array'
-		? z.ZodArray<GetZodPrimitiveType<Assume<TColumn['_']['data'], any[]>[number], '', TCoerce>>
-	: TColumn['_']['data'] extends Record<string, any>
-		? TColumn['_']['columnType'] extends
-			'PgJson' | 'PgJsonb' | 'MySqlJson' | 'SingleStoreJson' | 'SQLiteTextJson' | 'SQLiteBlobJson'
-			? z.ZodType<TColumn['_']['data'], TColumn['_']['data']>
-		: z.ZodObject<
-			{ [K in keyof TColumn['_']['data']]: GetZodPrimitiveType<TColumn['_']['data'][K], '', TCoerce> },
-			{ out: {}; in: {} }
-		>
-	: TColumn['_']['dataType'] extends 'json' ? z.ZodType<Json>
-	: GetZodPrimitiveType<TColumn['_']['data'], TColumn['_']['columnType'], TCoerce>;
-
-type CanCoerce<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-	TTo extends 'bigint' | 'boolean' | 'date' | 'number' | 'string',
-> = TCoerce extends true ? true
-	: TCoerce extends Record<string, any> ? TCoerce[TTo] extends true ? true
-		: false
-	: false;
-
-type GetZodPrimitiveType<
-	TData,
-	TColumnType,
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> = TColumnType extends
-	| 'MySqlTinyInt'
-	| 'SingleStoreTinyInt'
-	| 'PgSmallInt'
-	| 'PgSmallSerial'
-	| 'MySqlSmallInt'
-	| 'MySqlMediumInt'
-	| 'SingleStoreSmallInt'
-	| 'SingleStoreMediumInt'
-	| 'PgInteger'
-	| 'PgSerial'
-	| 'MySqlInt'
-	| 'SingleStoreInt'
-	| 'PgBigInt53'
-	| 'PgBigSerial53'
-	| 'MySqlBigInt53'
-	| 'MySqlSerial'
-	| 'SingleStoreBigInt53'
-	| 'SingleStoreSerial'
-	| 'SQLiteInteger'
-	| 'MySqlYear'
-	| 'SingleStoreYear' ? CanCoerce<TCoerce, 'number'> extends true ? z.coerce.ZodCoercedNumber : z.ZodInt
-	: TData extends number ? CanCoerce<TCoerce, 'number'> extends true ? z.coerce.ZodCoercedNumber : z.ZodNumber
-	: TData extends bigint ? CanCoerce<TCoerce, 'bigint'> extends true ? z.coerce.ZodCoercedBigInt : z.ZodBigInt
-	: TData extends boolean ? CanCoerce<TCoerce, 'boolean'> extends true ? z.coerce.ZodCoercedBoolean : z.ZodBoolean
-	: TData extends string ? CanCoerce<TCoerce, 'string'> extends true ? z.coerce.ZodCoercedString : z.ZodString
-	: z.ZodType;
-
-type HandleSelectColumn<
-	TSchema extends z.ZodType,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TSchema
-	: z.ZodNullable<TSchema>;
-
-type HandleInsertColumn<
-	TSchema extends z.ZodType,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? z.ZodOptional<TSchema>
-	: TSchema
-	: z.ZodOptional<z.ZodNullable<TSchema>>;
-
-type HandleUpdateColumn<
-	TSchema extends z.ZodType,
-	TColumn extends Column,
-> = TColumn['_']['notNull'] extends true ? z.ZodOptional<TSchema>
-	: z.ZodOptional<z.ZodNullable<TSchema>>;
-
-export type HandleColumn<
-	TType extends 'select' | 'insert' | 'update',
-	TColumn extends Column,
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> = TType extends 'select' ? HandleSelectColumn<GetZodType<TColumn, TCoerce>, TColumn>
-	: TType extends 'insert' ? HandleInsertColumn<GetZodType<TColumn, TCoerce>, TColumn>
-	: TType extends 'update' ? HandleUpdateColumn<GetZodType<TColumn, TCoerce>, TColumn>
-	: GetZodType<TColumn, TCoerce>;
diff --git a/drizzle-zod/src/constants.ts b/drizzle-zod/src/constants.ts
deleted file mode 100644
index 99f5d7a422..0000000000
--- a/drizzle-zod/src/constants.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-export const CONSTANTS = {
-	INT8_MIN: -128,
-	INT8_MAX: 127,
-	INT8_UNSIGNED_MAX: 255,
-	INT16_MIN: -32768,
-	INT16_MAX: 32767,
-	INT16_UNSIGNED_MAX: 65535,
-	INT24_MIN: -8388608,
-	INT24_MAX: 8388607,
-	INT24_UNSIGNED_MAX: 16777215,
-	INT32_MIN: -2147483648,
-	INT32_MAX: 2147483647,
-	INT32_UNSIGNED_MAX: 4294967295,
-	INT48_MIN: -140737488355328,
-	INT48_MAX: 140737488355327,
-	INT48_UNSIGNED_MAX: 281474976710655,
-	INT64_MIN: -9223372036854775808n,
-	INT64_MAX: 9223372036854775807n,
-	INT64_UNSIGNED_MAX: 18446744073709551615n,
-};
diff --git a/drizzle-zod/src/index.ts b/drizzle-zod/src/index.ts
deleted file mode 100644
index 225d3e880f..0000000000
--- a/drizzle-zod/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export { bufferSchema, jsonSchema, literalSchema } from './column.ts';
-export * from './column.types.ts';
-export * from './schema.ts';
-export * from './schema.types.internal.ts';
-export * from './schema.types.ts';
-export * from './utils.ts';
diff --git a/drizzle-zod/src/schema.ts b/drizzle-zod/src/schema.ts
deleted file mode 100644
index 43eb1c2469..0000000000
--- a/drizzle-zod/src/schema.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { Column, getTableColumns, getViewSelectedFields, is, isTable, isView, SQL } from 'drizzle-orm';
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import { z } from 'zod/v4';
-import { columnToSchema } from './column.ts';
-import type { Conditions } from './schema.types.internal.ts';
-import type {
-	CreateInsertSchema,
-	CreateSchemaFactoryOptions,
-	CreateSelectSchema,
-	CreateUpdateSchema,
-} from './schema.types.ts';
-import { isPgEnum } from './utils.ts';
-
-function getColumns(tableLike: Table | View) {
-	return isTable(tableLike) ? getTableColumns(tableLike) : getViewSelectedFields(tableLike);
-}
-
-function handleColumns(
-	columns: Record<string, any>,
-	refinements: Record<string, any>,
-	conditions: Conditions,
-	factory?: CreateSchemaFactoryOptions<
-		Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-	>,
-): z.ZodType {
-	const columnSchemas: Record<string, z.ZodType> = {};
-
-	for (const [key, selected] of Object.entries(columns)) {
-		if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === 'object') {
-			const columns = isTable(selected) || isView(selected) ? getColumns(selected) : selected;
-			columnSchemas[key] = handleColumns(columns, refinements[key] ?? {}, conditions, factory);
-			continue;
-		}
-
-		const refinement = refinements[key];
-		if (refinement !== undefined && typeof refinement !== 'function') {
-			columnSchemas[key] = refinement;
-			continue;
-		}
-
-		const column = is(selected, Column) ? selected : undefined;
-		const schema = column ? columnToSchema(column, factory) : z.any();
-		const refined = typeof refinement === 'function' ? refinement(schema) : schema;
-
-		if (conditions.never(column)) {
-			continue;
-		} else {
-			columnSchemas[key] = refined;
-		}
-
-		if (column) {
-			if (conditions.nullable(column)) {
-				columnSchemas[key] = columnSchemas[key]!.nullable();
-			}
-
-			if (conditions.optional(column)) {
-				columnSchemas[key] = columnSchemas[key]!.optional();
-			}
-		}
-	}
-
-	return z.object(columnSchemas) as any;
-}
-
-function handleEnum(
-	enum_: PgEnum<any>,
-	factory?: CreateSchemaFactoryOptions<
-		Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined
-	>,
-) {
-	const zod: typeof z = factory?.zodInstance ?? z;
-	return zod.enum(enum_.enumValues);
-}
-
-const selectConditions: Conditions = {
-	never: () => false,
-	optional: () => false,
-	nullable: (column) => !column.notNull,
-};
-
-const insertConditions: Conditions = {
-	never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-	optional: (column) => !column.notNull || (column.notNull && column.hasDefault),
-	nullable: (column) => !column.notNull,
-};
-
-const updateConditions: Conditions = {
-	never: (column) => column?.generated?.type === 'always' || column?.generatedIdentity?.type === 'always',
-	optional: () => true,
-	nullable: (column) => !column.notNull,
-};
-
-export const createSelectSchema: CreateSelectSchema<undefined> = (
-	entity: Table | View | PgEnum<[string, ...string[]]>,
-	refine?: Record<string, any>,
-) => {
-	if (isPgEnum(entity)) {
-		return handleEnum(entity);
-	}
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, selectConditions) as any;
-};
-
-export const createInsertSchema: CreateInsertSchema<undefined> = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, insertConditions) as any;
-};
-
-export const createUpdateSchema: CreateUpdateSchema<undefined> = (
-	entity: Table,
-	refine?: Record<string, any>,
-) => {
-	const columns = getColumns(entity);
-	return handleColumns(columns, refine ?? {}, updateConditions) as any;
-};
-
-export function createSchemaFactory<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
->(options?: CreateSchemaFactoryOptions<TCoerce>) {
-	const createSelectSchema: CreateSelectSchema<TCoerce> = (
-		entity: Table | View | PgEnum<[string, ...string[]]>,
-		refine?: Record<string, any>,
-	) => {
-		if (isPgEnum(entity)) {
-			return handleEnum(entity, options);
-		}
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, selectConditions, options) as any;
-	};
-
-	const createInsertSchema: CreateInsertSchema<TCoerce> = (
-		entity: Table,
-		refine?: Record<string, any>,
-	) => {
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, insertConditions, options) as any;
-	};
-
-	const createUpdateSchema: CreateUpdateSchema<TCoerce> = (
-		entity: Table,
-		refine?: Record<string, any>,
-	) => {
-		const columns = getColumns(entity);
-		return handleColumns(columns, refine ?? {}, updateConditions, options) as any;
-	};
-
-	return { createSelectSchema, createInsertSchema, createUpdateSchema };
-}
diff --git a/drizzle-zod/src/schema.types.internal.ts b/drizzle-zod/src/schema.types.internal.ts
deleted file mode 100644
index 1acee0803c..0000000000
--- a/drizzle-zod/src/schema.types.internal.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import type { Assume, Column, DrizzleTypeError, SelectedFieldsFlat, Simplify, Table, View } from 'drizzle-orm';
-import type { z } from 'zod/v4';
-import type { GetZodType, HandleColumn } from './column.types.ts';
-import type { ColumnIsGeneratedAlwaysAs, GetSelection } from './utils.ts';
-
-export interface Conditions {
-	never: (column?: Column) => boolean;
-	optional: (column: Column) => boolean;
-	nullable: (column: Column) => boolean;
-}
-
-type BuildRefineField<T> = T extends z.ZodType ? ((schema: T) => z.ZodType) | z.ZodType : never;
-
-export type BuildRefine<
-	TColumns extends Record<string, any>,
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> = {
-	[K in keyof TColumns as TColumns[K] extends Column | SelectedFieldsFlat<Column> | Table | View ? K : never]?:
-		TColumns[K] extends Column ? BuildRefineField<GetZodType<TColumns[K], TCoerce>>
-			: BuildRefine<GetSelection<TColumns[K]>, TCoerce>;
-};
-
-type HandleRefinement<
-	TType extends 'select' | 'insert' | 'update',
-	TRefinement,
-	TColumn extends Column,
-> = TRefinement extends (schema: any) => z.ZodType ? (TColumn['_']['notNull'] extends true ? ReturnType<TRefinement>
-		: z.ZodNullable<ReturnType<TRefinement>>) extends infer TSchema extends z.ZodType
-		? TType extends 'update' ? z.ZodOptional<TSchema> : TSchema
-	: z.ZodType
-	: TRefinement;
-
-type IsRefinementDefined<
-	TRefinements extends Record<string | symbol | number, any> | undefined,
-	TKey extends string | symbol | number,
-> = TRefinements extends object ? TRefinements[TKey] extends z.ZodType | ((schema: any) => any) ? true
-	: false
-	: false;
-
-export type BuildSchema<
-	TType extends 'select' | 'insert' | 'update',
-	TColumns extends Record<string, any>,
-	TRefinements extends Record<string, any> | undefined,
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> = z.ZodObject<
-	Simplify<
-		{
-			[
-				K in keyof TColumns as ColumnIsGeneratedAlwaysAs<TColumns[K]> extends true ? TType extends 'select' ? K
-					: never
-					: K
-			]: TColumns[K] extends infer TColumn extends Column
-				? IsRefinementDefined<TRefinements, K> extends true
-					? Assume<HandleRefinement<TType, TRefinements[K & keyof TRefinements], TColumn>, z.ZodType>
-				: HandleColumn<TType, TColumn, TCoerce>
-				: TColumns[K] extends infer TObject extends SelectedFieldsFlat<Column> | Table | View ? BuildSchema<
-						TType,
-						GetSelection<TObject>,
-						TRefinements extends object ? TRefinements[K & keyof TRefinements] : undefined,
-						TCoerce
-					>
-				: z.ZodAny;
-		}
-	>,
-	{ out: {}; in: {} }
->;
-
-export type NoUnknownKeys<
-	TRefinement extends Record<string, any>,
-	TCompare extends Record<string, any>,
-> = {
-	[K in keyof TRefinement]: K extends keyof TCompare
-		? TRefinement[K] extends Record<string, z.ZodType> ? NoUnknownKeys<TRefinement[K], TCompare[K]>
-		: TRefinement[K]
-		: DrizzleTypeError<`Found unknown key in refinement: "${K & string}"`>;
-};
diff --git a/drizzle-zod/src/schema.types.ts b/drizzle-zod/src/schema.types.ts
deleted file mode 100644
index da7fede874..0000000000
--- a/drizzle-zod/src/schema.types.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import type { Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { z } from 'zod/v4';
-import type { BuildRefine, BuildSchema, NoUnknownKeys } from './schema.types.internal.ts';
-
-export interface CreateSelectSchema<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> {
-	<TTable extends Table>(table: TTable): BuildSchema<'select', TTable['_']['columns'], undefined, TCoerce>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<TTable['_']['columns'], TCoerce>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferSelect']>,
-	): BuildSchema<'select', TTable['_']['columns'], TRefine, TCoerce>;
-
-	<TView extends View>(view: TView): BuildSchema<'select', TView['_']['selectedFields'], undefined, TCoerce>;
-	<
-		TView extends View,
-		TRefine extends BuildRefine<TView['_']['selectedFields'], TCoerce>,
-	>(
-		view: TView,
-		refine: NoUnknownKeys<TRefine, TView['$inferSelect']>,
-	): BuildSchema<'select', TView['_']['selectedFields'], TRefine, TCoerce>;
-
-	<TEnum extends PgEnum<any>>(enum_: TEnum): z.ZodEnum<{ [K in TEnum['enumValues'][number]]: K }>;
-}
-
-export interface CreateInsertSchema<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> {
-	<TTable extends Table>(table: TTable): BuildSchema<'insert', TTable['_']['columns'], undefined, TCoerce>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>, TCoerce>,
-	>(
-		table: TTable,
-		refine?: NoUnknownKeys<TRefine, TTable['$inferInsert']>,
-	): BuildSchema<'insert', TTable['_']['columns'], TRefine, TCoerce>;
-}
-
-export interface CreateUpdateSchema<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> {
-	<TTable extends Table>(table: TTable): BuildSchema<'update', TTable['_']['columns'], undefined, TCoerce>;
-	<
-		TTable extends Table,
-		TRefine extends BuildRefine<Pick<TTable['_']['columns'], keyof TTable['$inferInsert']>, TCoerce>,
-	>(
-		table: TTable,
-		refine?: TRefine,
-	): BuildSchema<'update', TTable['_']['columns'], TRefine, TCoerce>;
-}
-
-export interface CreateSchemaFactoryOptions<
-	TCoerce extends Partial<Record<'bigint' | 'boolean' | 'date' | 'number' | 'string', true>> | true | undefined,
-> {
-	zodInstance?: any;
-	coerce?: TCoerce;
-}
diff --git a/drizzle-zod/src/utils.ts b/drizzle-zod/src/utils.ts
deleted file mode 100644
index 1c991ad523..0000000000
--- a/drizzle-zod/src/utils.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import type { Column, SelectedFieldsFlat, Table, View } from 'drizzle-orm';
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { z } from 'zod/v4';
-import type { literalSchema } from './column.ts';
-
-export function isColumnType<T extends Column>(column: Column, columnTypes: string[]): column is T {
-	return columnTypes.includes(column.columnType);
-}
-
-export function isWithEnum(column: Column): column is typeof column & { enumValues: [string, ...string[]] } {
-	return 'enumValues' in column && Array.isArray(column.enumValues) && column.enumValues.length > 0;
-}
-
-export const isPgEnum: (entity: any) => entity is PgEnum<[string, ...string[]]> = isWithEnum as any;
-
-type Literal = z.infer<typeof literalSchema>;
-export type Json = Literal | { [key: string]: any } | any[];
-
-export type IsNever<T> = [T] extends [never] ? true : false;
-
-export type IsEnumDefined<TEnum extends string[] | undefined> = [string, ...string[]] extends TEnum ? false
-	: undefined extends TEnum ? false
-	: true;
-
-export type ColumnIsGeneratedAlwaysAs<TColumn> = TColumn extends Column
-	? TColumn['_']['identity'] extends 'always' ? true
-	: TColumn['_']['generated'] extends { type: 'byDefault' } | undefined ? false
-	: true
-	: false;
-
-export type GetSelection<T extends SelectedFieldsFlat<Column> | Table | View> = T extends Table ? T['_']['columns']
-	: T extends View ? T['_']['selectedFields']
-	: T;
diff --git a/drizzle-zod/tests/mysql.test.ts b/drizzle-zod/tests/mysql.test.ts
deleted file mode 100644
index 17bcecdf5b..0000000000
--- a/drizzle-zod/tests/mysql.test.ts
+++ /dev/null
@@ -1,556 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { z } from 'zod/v4';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
-const serialNumberModeSchema = z.int().gte(0).lte(Number.MAX_SAFE_INTEGER);
-const textSchema = z.string().max(CONSTANTS.INT16_UNSIGNED_MAX);
-
-test('table - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		generated: int().generatedAlwaysAs(1).notNull(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: serialNumberModeSchema, generated: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = mysqlSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema,
-		age: intSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: serialNumberModeSchema, age: z.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = mysqlView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = mysqlTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({
-		id: serialNumberModeSchema,
-		nested: z.object({ name: textSchema, age: z.any() }),
-		table: z.object({ id: serialNumberModeSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema,
-		c3: intSchema.nullable(),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema,
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = z.string().min(1).max(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000).optional(),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = mysqlTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = mysqlView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		nested: {
-			c5: (schema) => schema.lte(1000),
-			c6: z.string().transform(Number),
-		},
-		table: {
-			c2: (schema) => schema.lte(1000),
-			c3: z.string().transform(Number),
-		},
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000).nullable(),
-		c3: z.string().transform(Number),
-		nested: z.object({
-			c4: intSchema.nullable(),
-			c5: intSchema.lte(1000).nullable(),
-			c6: z.string().transform(Number),
-		}),
-		table: z.object({
-			c1: intSchema.nullable(),
-			c2: intSchema.lte(1000).nullable(),
-			c3: z.string().transform(Number),
-			c4: intSchema.nullable(),
-			c5: intSchema.nullable(),
-			c6: intSchema.nullable(),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = mysqlTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		mysqlEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		bigint3: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
-		bigint4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
-		binary: z.string(),
-		boolean: z.boolean(),
-		char1: z.string().length(10),
-		char2: z.enum(['a', 'b', 'c']),
-		date1: z.date(),
-		date2: z.string(),
-		datetime1: z.date(),
-		datetime2: z.string(),
-		decimal1: z.string(),
-		decimal2: z.string(),
-		double1: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		double2: z.number().gte(0).lte(CONSTANTS.INT48_UNSIGNED_MAX),
-		float1: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
-		float2: z.number().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
-		int1: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-		int2: z.int().gte(0).lte(CONSTANTS.INT32_UNSIGNED_MAX),
-		json: jsonSchema,
-		mediumint1: z.int().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
-		mediumint2: z.int().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
-		enum: z.enum(['a', 'b', 'c']),
-		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		serial: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
-		smallint1: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
-		smallint2: z.int().gte(0).lte(CONSTANTS.INT16_UNSIGNED_MAX),
-		text1: z.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
-		text2: z.enum(['a', 'b', 'c']),
-		time: z.string(),
-		timestamp1: z.date(),
-		timestamp2: z.string(),
-		tinyint1: z.int().gte(CONSTANTS.INT8_MIN).lte(CONSTANTS.INT8_MAX),
-		tinyint2: z.int().gte(0).lte(CONSTANTS.INT8_UNSIGNED_MAX),
-		varchar1: z.string().max(10),
-		varchar2: z.enum(['a', 'b', 'c']),
-		varbinary: z.string(),
-		year: z.int().gte(1901).lte(2155),
-		longtext1: z.string().max(CONSTANTS.INT32_UNSIGNED_MAX),
-		longtext2: z.enum(['a', 'b', 'c']),
-		mediumtext1: z.string().max(CONSTANTS.INT24_UNSIGNED_MAX),
-		mediumtext2: z.enum(['a', 'b', 'c']),
-		tinytext1: z.string().max(CONSTANTS.INT8_UNSIGNED_MAX),
-		tinytext2: z.enum(['a', 'b', 'c']),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - all', (t) => {
-	const table = mysqlTable('test', ({
-		bigint,
-		boolean,
-		timestamp,
-		int,
-		text,
-	}) => ({
-		bigint: bigint({ mode: 'bigint' }).notNull(),
-		boolean: boolean().notNull(),
-		timestamp: timestamp().notNull(),
-		int: int().notNull(),
-		text: text().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: true,
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		boolean: z.coerce.boolean(),
-		timestamp: z.coerce.date(),
-		int: z.coerce.number().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX).int(),
-		text: z.coerce.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - mixed', (t) => {
-	const table = mysqlTable('test', ({
-		timestamp,
-		int,
-	}) => ({
-		timestamp: timestamp().notNull(),
-		int: int().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: {
-			date: true,
-		},
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		timestamp: z.coerce.date(),
-		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
-	const table = mysqlTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		json: z.nullable(TopLevelCondition),
-	});
-	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = mysqlTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = mysqlTable('test', { id: int() });
-	const view = mysqlView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = mysqlView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-}
diff --git a/drizzle-zod/tests/pg.test.ts b/drizzle-zod/tests/pg.test.ts
deleted file mode 100644
index f982e1a31b..0000000000
--- a/drizzle-zod/tests/pg.test.ts
+++ /dev/null
@@ -1,612 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import {
-	customType,
-	integer,
-	json,
-	jsonb,
-	pgEnum,
-	pgMaterializedView,
-	pgSchema,
-	pgTable,
-	pgView,
-	serial,
-	text,
-} from 'drizzle-orm/pg-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { z } from 'zod/v4';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectEnumValues, expectSchemaShape } from './utils.ts';
-
-const integerSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
-const textSchema = z.string();
-
-test('table - select', (t) => {
-	const table = pgTable('test', {
-		id: integer().primaryKey(),
-		generated: integer().generatedAlwaysAsIdentity(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: integerSchema, generated: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = pgSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({ name: textSchema, age: integerSchema.nullable().optional() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = pgTable('test', {
-		id: integer().generatedAlwaysAsIdentity().primaryKey(),
-		name: text().notNull(),
-		age: integer(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		name: textSchema.optional(),
-		age: integerSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: integerSchema, age: z.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view qb - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: integerSchema, age: z.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('materialized view columns - select', (t) => {
-	const view = pgView('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: integerSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = pgTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-	const view = pgMaterializedView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({
-		id: integerSchema,
-		nested: z.object({ name: textSchema, age: z.any() }),
-		table: z.object({ id: integerSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('enum - select', (t) => {
-	const enum_ = pgEnum('test', ['a', 'b', 'c']);
-
-	const result = createSelectSchema(enum_);
-	const expected = z.enum(['a', 'b', 'c']);
-	expectEnumValues(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		c1: integerSchema.nullable(),
-		c2: integerSchema,
-		c3: integerSchema.nullable(),
-		c4: integerSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		c1: integerSchema.nullable().optional(),
-		c2: integerSchema,
-		c3: integerSchema.nullable().optional(),
-		c4: integerSchema.optional(),
-		c7: integerSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-});
-
-test('nullability - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().default(1),
-		c4: integer().notNull().default(1),
-		c5: integer().generatedAlwaysAs(1),
-		c6: integer().generatedAlwaysAsIdentity(),
-		c7: integer().generatedByDefaultAsIdentity(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		c1: integerSchema.nullable().optional(),
-		c2: integerSchema.optional(),
-		c3: integerSchema.nullable().optional(),
-		c4: integerSchema.optional(),
-		c7: integerSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: integerSchema.nullable(),
-		c2: integerSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = z.string().min(1).max(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-	const expected = z.object({
-		c1: integerSchema.nullable(),
-		c2: integerSchema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: integerSchema.nullable().optional(),
-		c2: integerSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer().notNull(),
-		c3: integer().notNull(),
-		c4: integer().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: integerSchema.nullable().optional(),
-		c2: integerSchema.lte(1000).optional(),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = pgTable('test', {
-		c1: integer(),
-		c2: integer(),
-		c3: integer(),
-		c4: integer(),
-		c5: integer(),
-		c6: integer(),
-	});
-	const view = pgView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		nested: {
-			c5: (schema) => schema.lte(1000),
-			c6: z.string().transform(Number),
-		},
-		table: {
-			c2: (schema) => schema.lte(1000),
-			c3: z.string().transform(Number),
-		},
-	});
-	const expected = z.object({
-		c1: integerSchema.nullable(),
-		c2: integerSchema.lte(1000).nullable(),
-		c3: z.string().transform(Number),
-		nested: z.object({
-			c4: integerSchema.nullable(),
-			c5: integerSchema.lte(1000).nullable(),
-			c6: z.string().transform(Number),
-		}),
-		table: z.object({
-			c1: integerSchema.nullable(),
-			c2: integerSchema.lte(1000).nullable(),
-			c3: z.string().transform(Number),
-			c4: integerSchema.nullable(),
-			c5: integerSchema.nullable(),
-			c6: integerSchema.nullable(),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = pgTable('test', ({
-		bigint,
-		bigserial,
-		bit,
-		boolean,
-		date,
-		char,
-		cidr,
-		doublePrecision,
-		geometry,
-		halfvec,
-		inet,
-		integer,
-		interval,
-		json,
-		jsonb,
-		line,
-		macaddr,
-		macaddr8,
-		numeric,
-		point,
-		real,
-		serial,
-		smallint,
-		smallserial,
-		text,
-		sparsevec,
-		time,
-		timestamp,
-		uuid,
-		varchar,
-		vector,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigserial1: bigserial({ mode: 'number' }).notNull(),
-		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
-		bit: bit({ dimensions: 5 }).notNull(),
-		boolean: boolean().notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		cidr: cidr().notNull(),
-		doublePrecision: doublePrecision().notNull(),
-		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
-		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
-		halfvec: halfvec({ dimensions: 3 }).notNull(),
-		inet: inet().notNull(),
-		integer: integer().notNull(),
-		interval: interval().notNull(),
-		json: json().notNull(),
-		jsonb: jsonb().notNull(),
-		line1: line({ mode: 'abc' }).notNull(),
-		line2: line({ mode: 'tuple' }).notNull(),
-		macaddr: macaddr().notNull(),
-		macaddr8: macaddr8().notNull(),
-		numeric: numeric().notNull(),
-		point1: point({ mode: 'xy' }).notNull(),
-		point2: point({ mode: 'tuple' }).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint: smallint().notNull(),
-		smallserial: smallserial().notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		uuid: uuid().notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		vector: vector({ dimensions: 3 }).notNull(),
-		array1: integer().array().notNull(),
-		array2: integer().array().array(2).notNull(),
-		array3: varchar({ length: 10 }).array().array(2).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		bigserial1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-		bigserial2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		bit: z.string().regex(/^[01]+$/).max(5),
-		boolean: z.boolean(),
-		date1: z.date(),
-		date2: z.string(),
-		char1: z.string().length(10),
-		char2: z.enum(['a', 'b', 'c']),
-		cidr: z.string(),
-		doublePrecision: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		geometry1: z.tuple([z.number(), z.number()]),
-		geometry2: z.object({ x: z.number(), y: z.number() }),
-		halfvec: z.array(z.number()).length(3),
-		inet: z.string(),
-		integer: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-		interval: z.string(),
-		json: jsonSchema,
-		jsonb: jsonSchema,
-		line1: z.object({ a: z.number(), b: z.number(), c: z.number() }),
-		line2: z.tuple([z.number(), z.number(), z.number()]),
-		macaddr: z.string(),
-		macaddr8: z.string(),
-		numeric: z.string(),
-		point1: z.object({ x: z.number(), y: z.number() }),
-		point2: z.tuple([z.number(), z.number()]),
-		real: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
-		serial: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-		smallint: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
-		smallserial: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
-		text1: z.string(),
-		text2: z.enum(['a', 'b', 'c']),
-		sparsevec: z.string(),
-		time: z.string(),
-		timestamp1: z.date(),
-		timestamp2: z.string(),
-		uuid: z.uuid(),
-		varchar1: z.string().max(10),
-		varchar2: z.enum(['a', 'b', 'c']),
-		vector: z.array(z.number()).length(3),
-		array1: z.array(integerSchema),
-		array2: z.array(z.array(integerSchema).length(2)),
-		array3: z.array(z.array(z.string().max(10)).length(2)),
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - all', (t) => {
-	const table = pgTable('test', ({
-		bigint,
-		boolean,
-		timestamp,
-		integer,
-		text,
-	}) => ({
-		bigint: bigint({ mode: 'bigint' }).notNull(),
-		boolean: boolean().notNull(),
-		timestamp: timestamp().notNull(),
-		integer: integer().notNull(),
-		text: text().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: true,
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		boolean: z.coerce.boolean(),
-		timestamp: z.coerce.date(),
-		integer: z.coerce.number().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX).int(),
-		text: z.coerce.string(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - mixed', (t) => {
-	const table = pgTable('test', ({
-		timestamp,
-		integer,
-	}) => ({
-		timestamp: timestamp().notNull(),
-		integer: integer().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: {
-			date: true,
-		},
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		timestamp: z.coerce.date(),
-		integer: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
-	const table = pgTable('test', {
-		json: json().$type<TopLevelCondition>().notNull(),
-		jsonb: jsonb().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		json: TopLevelCondition,
-		jsonb: z.nullable(TopLevelCondition),
-	});
-	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = pgTable('test', { id: integer() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = pgTable('test', { id: integer() });
-	const view = pgView('test').as((qb) => qb.select().from(table));
-	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: z.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = pgView('test', { id: integer() }).as(sql``);
-	const mView = pgView('test', { id: integer() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-	// @ts-expect-error
-	createSelectSchema(mView, { unknown: z.string() });
-}
diff --git a/drizzle-zod/tests/singlestore.test.ts b/drizzle-zod/tests/singlestore.test.ts
deleted file mode 100644
index 51c4817925..0000000000
--- a/drizzle-zod/tests/singlestore.test.ts
+++ /dev/null
@@ -1,558 +0,0 @@
-import type { Equal } from 'drizzle-orm';
-import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { z } from 'zod/v4';
-import { jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
-const serialNumberModeSchema = z.int().gte(0).lte(Number.MAX_SAFE_INTEGER);
-const textSchema = z.string().max(CONSTANTS.INT16_UNSIGNED_MAX);
-
-test('table - select', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		generated: int().generatedAlwaysAs(1).notNull(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: serialNumberModeSchema, generated: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table in schema - select', (tc) => {
-	const schema = singlestoreSchema('test');
-	const table = schema.table('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: serialNumberModeSchema, name: textSchema });
-	expectSchemaShape(tc, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema,
-		age: intSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = singlestoreTable('test', {
-		id: serial().primaryKey(),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		id: serialNumberModeSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// TODO: SingleStore doesn't support views yet. Add these tests when they're added
-
-// test('view qb - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-// 	const result = createSelectSchema(view);
-// 	const expected = z.object({ id: serialNumberModeSchema, age: z.any() });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view columns - select', (t) => {
-// 	const view = mysqlView('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	}).as(sql``);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = z.object({ id: serialNumberModeSchema, name: textSchema });
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-// test('view with nested fields - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		id: serial().primaryKey(),
-// 		name: text().notNull(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			id: table.id,
-// 			nested: {
-// 				name: table.name,
-// 				age: sql``.as('age'),
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view);
-// 	const expected = z.object({
-// 		id: serialNumberModeSchema,
-// 		nested: z.object({ name: textSchema, age: z.any() }),
-// 		table: z.object({ id: serialNumberModeSchema, name: textSchema }),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('nullability - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema,
-		c3: intSchema.nullable(),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema,
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = z.string().min(1).max(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = singlestoreTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000).optional(),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-// test('refine view - select', (t) => {
-// 	const table = singlestoreTable('test', {
-// 		c1: int(),
-// 		c2: int(),
-// 		c3: int(),
-// 		c4: int(),
-// 		c5: int(),
-// 		c6: int(),
-// 	});
-// 	const view = mysqlView('test').as((qb) =>
-// 		qb.select({
-// 			c1: table.c1,
-// 			c2: table.c2,
-// 			c3: table.c3,
-// 			nested: {
-// 				c4: table.c4,
-// 				c5: table.c5,
-// 				c6: table.c6,
-// 			},
-// 			table,
-// 		}).from(table)
-// 	);
-
-// 	const result = createSelectSchema(view, {
-// 		c2: (schema) => schema.lte(1000),
-// 		c3: z.string().transform(Number),
-// 		nested: {
-// 			c5: (schema) => schema.lte(1000),
-// 			c6: z.string().transform(Number),
-// 		},
-// 		table: {
-// 			c2: (schema) => schema.lte(1000),
-// 			c3: z.string().transform(Number),
-// 		},
-// 	});
-// 	const expected = z.object({
-// 		c1: intSchema.nullable(),
-// 		c2: intSchema.lte(1000).nullable(),
-// 		c3: z.string().transform(Number),
-// 		nested: z.object({
-// 			c4: intSchema.nullable(),
-// 			c5: intSchema.lte(1000).nullable(),
-// 			c6: z.string().transform(Number),
-// 		}),
-// 		table: z.object({
-// 			c1: intSchema.nullable(),
-// 			c2: intSchema.lte(1000).nullable(),
-// 			c3: z.string().transform(Number),
-// 			c4: intSchema.nullable(),
-// 			c5: intSchema.nullable(),
-// 			c6: intSchema.nullable(),
-// 		}),
-// 	});
-// 	expectSchemaShape(t, expected).from(result);
-// 	Expect<Equal<typeof result, typeof expected>>();
-// });
-
-test('all data types', (t) => {
-	const table = singlestoreTable('test', ({
-		bigint,
-		binary,
-		boolean,
-		char,
-		date,
-		datetime,
-		decimal,
-		double,
-		float,
-		int,
-		json,
-		mediumint,
-		singlestoreEnum,
-		real,
-		serial,
-		smallint,
-		text,
-		time,
-		timestamp,
-		tinyint,
-		varchar,
-		varbinary,
-		year,
-		longtext,
-		mediumtext,
-		tinytext,
-	}) => ({
-		bigint1: bigint({ mode: 'number' }).notNull(),
-		bigint2: bigint({ mode: 'bigint' }).notNull(),
-		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
-		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
-		binary: binary({ length: 10 }).notNull(),
-		boolean: boolean().notNull(),
-		char1: char({ length: 10 }).notNull(),
-		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		date1: date({ mode: 'date' }).notNull(),
-		date2: date({ mode: 'string' }).notNull(),
-		datetime1: datetime({ mode: 'date' }).notNull(),
-		datetime2: datetime({ mode: 'string' }).notNull(),
-		decimal1: decimal().notNull(),
-		decimal2: decimal({ unsigned: true }).notNull(),
-		double1: double().notNull(),
-		double2: double({ unsigned: true }).notNull(),
-		float1: float().notNull(),
-		float2: float({ unsigned: true }).notNull(),
-		int1: int().notNull(),
-		int2: int({ unsigned: true }).notNull(),
-		json: json().notNull(),
-		mediumint1: mediumint().notNull(),
-		mediumint2: mediumint({ unsigned: true }).notNull(),
-		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
-		real: real().notNull(),
-		serial: serial().notNull(),
-		smallint1: smallint().notNull(),
-		smallint2: smallint({ unsigned: true }).notNull(),
-		text1: text().notNull(),
-		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
-		time: time().notNull(),
-		timestamp1: timestamp({ mode: 'date' }).notNull(),
-		timestamp2: timestamp({ mode: 'string' }).notNull(),
-		tinyint1: tinyint().notNull(),
-		tinyint2: tinyint({ unsigned: true }).notNull(),
-		varchar1: varchar({ length: 10 }).notNull(),
-		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
-		varbinary: varbinary({ length: 10 }).notNull(),
-		year: year().notNull(),
-		longtext1: longtext().notNull(),
-		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		mediumtext1: mediumtext().notNull(),
-		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
-		tinytext1: tinytext().notNull(),
-		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		bigint3: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
-		bigint4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
-		binary: z.string(),
-		boolean: z.boolean(),
-		char1: z.string().length(10),
-		char2: z.enum(['a', 'b', 'c']),
-		date1: z.date(),
-		date2: z.string(),
-		datetime1: z.date(),
-		datetime2: z.string(),
-		decimal1: z.string(),
-		decimal2: z.string(),
-		double1: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		double2: z.number().gte(0).lte(CONSTANTS.INT48_UNSIGNED_MAX),
-		float1: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
-		float2: z.number().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
-		int1: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-		int2: z.int().gte(0).lte(CONSTANTS.INT32_UNSIGNED_MAX),
-		json: jsonSchema,
-		mediumint1: z.int().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
-		mediumint2: z.int().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
-		enum: z.enum(['a', 'b', 'c']),
-		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		serial: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
-		smallint1: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
-		smallint2: z.int().gte(0).lte(CONSTANTS.INT16_UNSIGNED_MAX),
-		text1: z.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
-		text2: z.enum(['a', 'b', 'c']),
-		time: z.string(),
-		timestamp1: z.date(),
-		timestamp2: z.string(),
-		tinyint1: z.int().gte(CONSTANTS.INT8_MIN).lte(CONSTANTS.INT8_MAX),
-		tinyint2: z.int().gte(0).lte(CONSTANTS.INT8_UNSIGNED_MAX),
-		varchar1: z.string().max(10),
-		varchar2: z.enum(['a', 'b', 'c']),
-		varbinary: z.string(),
-		year: z.int().gte(1901).lte(2155),
-		longtext1: z.string().max(CONSTANTS.INT32_UNSIGNED_MAX),
-		longtext2: z.enum(['a', 'b', 'c']),
-		mediumtext1: z.string().max(CONSTANTS.INT24_UNSIGNED_MAX),
-		mediumtext2: z.enum(['a', 'b', 'c']),
-		tinytext1: z.string().max(CONSTANTS.INT8_UNSIGNED_MAX),
-		tinytext2: z.enum(['a', 'b', 'c']),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - all', (t) => {
-	const table = singlestoreTable('test', ({
-		bigint,
-		boolean,
-		timestamp,
-		int,
-		text,
-	}) => ({
-		bigint: bigint({ mode: 'bigint' }).notNull(),
-		boolean: boolean().notNull(),
-		timestamp: timestamp().notNull(),
-		int: int().notNull(),
-		text: text().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: true,
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		boolean: z.coerce.boolean(),
-		timestamp: z.coerce.date(),
-		int: z.coerce.number().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX).int(),
-		text: z.coerce.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - mixed', (t) => {
-	const table = singlestoreTable('test', ({
-		timestamp,
-		int,
-	}) => ({
-		timestamp: timestamp().notNull(),
-		int: int().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: {
-			date: true,
-		},
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		timestamp: z.coerce.date(),
-		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
-	const table = singlestoreTable('test', {
-		json: json().$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		json: z.nullable(TopLevelCondition),
-	});
-	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = singlestoreTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: z.string() });
-}
-
-// /* Disallow unknown keys in view qb - select */ {
-// 	const table = singlestoreTable('test', { id: int() });
-// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
-// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: z.string() });
-// 	// @ts-expect-error
-// 	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
-// }
-
-// /* Disallow unknown keys in view columns - select */ {
-// 	const view = mysqlView('test', { id: int() }).as(sql``);
-// 	// @ts-expect-error
-// 	createSelectSchema(view, { unknown: z.string() });
-// }
diff --git a/drizzle-zod/tests/sqlite.test.ts b/drizzle-zod/tests/sqlite.test.ts
deleted file mode 100644
index eff9536686..0000000000
--- a/drizzle-zod/tests/sqlite.test.ts
+++ /dev/null
@@ -1,451 +0,0 @@
-import { type Equal, sql } from 'drizzle-orm';
-import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
-import type { TopLevelCondition } from 'json-rules-engine';
-import { test } from 'vitest';
-import { z } from 'zod/v4';
-import { bufferSchema, jsonSchema } from '~/column.ts';
-import { CONSTANTS } from '~/constants.ts';
-import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from '../src';
-import { Expect, expectSchemaShape } from './utils.ts';
-
-const intSchema = z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER);
-const textSchema = z.string();
-
-test('table - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		generated: int().generatedAlwaysAs(1).notNull(),
-		name: text().notNull(),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({ id: intSchema, generated: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - insert', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({ id: intSchema.optional(), name: textSchema, age: intSchema.nullable().optional() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('table - update', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-		age: int(),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		id: intSchema.optional(),
-		name: textSchema.optional(),
-		age: intSchema.nullable().optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view qb - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: intSchema, age: z.any() });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view columns - select', (t) => {
-	const view = sqliteView('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	}).as(sql``);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({ id: intSchema, name: textSchema });
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('view with nested fields - select', (t) => {
-	const table = sqliteTable('test', {
-		id: int().primaryKey({ autoIncrement: true }),
-		name: text().notNull(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			id: table.id,
-			nested: {
-				name: table.name,
-				age: sql``.as('age'),
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view);
-	const expected = z.object({
-		id: intSchema,
-		nested: z.object({ name: textSchema, age: z.any() }),
-		table: z.object({ id: intSchema, name: textSchema }),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-	});
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema,
-		c3: intSchema.nullable(),
-		c4: intSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema,
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('nullability - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().default(1),
-		c4: int().notNull().default(1),
-		c5: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table);
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.optional(),
-		c3: intSchema.nullable().optional(),
-		c4: intSchema.optional(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-	});
-
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - select with custom data type', (t) => {
-	const customText = customType({ dataType: () => 'text' });
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: customText(),
-	});
-
-	const customTextSchema = z.string().min(1).max(100);
-	const result = createSelectSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-		c4: customTextSchema,
-	});
-
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - insert', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createInsertSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine table - update', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int().notNull(),
-		c3: int().notNull(),
-		c4: int().generatedAlwaysAs(1),
-	});
-
-	const result = createUpdateSchema(table, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-	});
-	const expected = z.object({
-		c1: intSchema.nullable().optional(),
-		c2: intSchema.lte(1000).optional(),
-		c3: z.string().transform(Number),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('refine view - select', (t) => {
-	const table = sqliteTable('test', {
-		c1: int(),
-		c2: int(),
-		c3: int(),
-		c4: int(),
-		c5: int(),
-		c6: int(),
-	});
-	const view = sqliteView('test').as((qb) =>
-		qb.select({
-			c1: table.c1,
-			c2: table.c2,
-			c3: table.c3,
-			nested: {
-				c4: table.c4,
-				c5: table.c5,
-				c6: table.c6,
-			},
-			table,
-		}).from(table)
-	);
-
-	const result = createSelectSchema(view, {
-		c2: (schema) => schema.lte(1000),
-		c3: z.string().transform(Number),
-		nested: {
-			c5: (schema) => schema.lte(1000),
-			c6: z.string().transform(Number),
-		},
-		table: {
-			c2: (schema) => schema.lte(1000),
-			c3: z.string().transform(Number),
-		},
-	});
-	const expected = z.object({
-		c1: intSchema.nullable(),
-		c2: intSchema.lte(1000).nullable(),
-		c3: z.string().transform(Number),
-		nested: z.object({
-			c4: intSchema.nullable(),
-			c5: intSchema.lte(1000).nullable(),
-			c6: z.string().transform(Number),
-		}),
-		table: z.object({
-			c1: intSchema.nullable(),
-			c2: intSchema.lte(1000).nullable(),
-			c3: z.string().transform(Number),
-			c4: intSchema.nullable(),
-			c5: intSchema.nullable(),
-			c6: intSchema.nullable(),
-		}),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('all data types', (t) => {
-	const table = sqliteTable('test', ({
-		blob,
-		integer,
-		numeric,
-		real,
-		text,
-	}) => ({
-		blob1: blob({ mode: 'buffer' }).notNull(),
-		blob2: blob({ mode: 'bigint' }).notNull(),
-		blob3: blob({ mode: 'json' }).notNull(),
-		integer1: integer({ mode: 'number' }).notNull(),
-		integer2: integer({ mode: 'boolean' }).notNull(),
-		integer3: integer({ mode: 'timestamp' }).notNull(),
-		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
-		numeric: numeric().notNull(),
-		real: real().notNull(),
-		text1: text({ mode: 'text' }).notNull(),
-		text2: text({ mode: 'text', length: 10 }).notNull(),
-		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
-		text4: text({ mode: 'json' }).notNull(),
-	}));
-
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		blob1: bufferSchema,
-		blob2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		blob3: jsonSchema,
-		integer1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-		integer2: z.boolean(),
-		integer3: z.date(),
-		integer4: z.date(),
-		numeric: z.string(),
-		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
-		text1: z.string(),
-		text2: z.string().max(10),
-		text3: z.enum(['a', 'b', 'c']),
-		text4: jsonSchema,
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - all', (t) => {
-	const table = sqliteTable('test', ({
-		blob,
-		integer,
-		text,
-	}) => ({
-		blob: blob({ mode: 'bigint' }).notNull(),
-		integer1: integer({ mode: 'boolean' }).notNull(),
-		integer2: integer({ mode: 'timestamp' }).notNull(),
-		integer3: integer().notNull(),
-		text: text().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: true,
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		blob: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
-		integer1: z.coerce.boolean(),
-		integer2: z.coerce.date(),
-		integer3: z.coerce.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER).int(),
-		text: z.coerce.string(),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-test('type coercion - mixed', (t) => {
-	const table = sqliteTable('test', ({
-		integer,
-	}) => ({
-		integer1: integer({ mode: 'timestamp' }).notNull(),
-		integer2: integer().notNull(),
-	}));
-
-	const { createSelectSchema } = createSchemaFactory({
-		coerce: {
-			date: true,
-		},
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		integer1: z.coerce.date(),
-		integer2: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
-	});
-	expectSchemaShape(t, expected).from(result);
-	Expect<Equal<typeof result, typeof expected>>();
-});
-
-/* Infinitely recursive type */ {
-	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
-	const table = sqliteTable('test', {
-		json1: text({ mode: 'json' }).$type<TopLevelCondition>().notNull(),
-		json2: blob({ mode: 'json' }).$type<TopLevelCondition>(),
-	});
-	const result = createSelectSchema(table);
-	const expected = z.object({
-		json1: TopLevelCondition,
-		json2: z.nullable(TopLevelCondition),
-	});
-	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
-}
-
-/* Disallow unknown keys in table refinement - select */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createSelectSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - insert */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createInsertSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in table refinement - update */ {
-	const table = sqliteTable('test', { id: int() });
-	// @ts-expect-error
-	createUpdateSchema(table, { unknown: z.string() });
-}
-
-/* Disallow unknown keys in view qb - select */ {
-	const table = sqliteTable('test', { id: int() });
-	const view = sqliteView('test').as((qb) => qb.select().from(table));
-	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-	// @ts-expect-error
-	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
-}
-
-/* Disallow unknown keys in view columns - select */ {
-	const view = sqliteView('test', { id: int() }).as(sql``);
-	// @ts-expect-error
-	createSelectSchema(view, { unknown: z.string() });
-}
diff --git a/drizzle-zod/tests/tsconfig.json b/drizzle-zod/tests/tsconfig.json
deleted file mode 100644
index 18f5dee497..0000000000
--- a/drizzle-zod/tests/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"noEmit": true,
-		"rootDir": "..",
-		"outDir": "./.cache"
-	},
-	"include": [".", "../src"]
-}
diff --git a/drizzle-zod/tests/utils.ts b/drizzle-zod/tests/utils.ts
deleted file mode 100644
index 7f947c50bf..0000000000
--- a/drizzle-zod/tests/utils.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { expect, type TaskContext } from 'vitest';
-import type { z } from 'zod/v4';
-
-export function expectSchemaShape<T extends z.ZodObject<z.ZodRawShape>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(Object.keys(actual.shape)).toStrictEqual(Object.keys(expected.shape));
-			for (const key in Object.keys(actual.shape)) {
-				expect(actual.shape[key]?._zod.def).toStrictEqual(expected.shape[key]?._zod.def);
-			}
-		},
-	};
-}
-
-export function expectEnumValues<T extends z.ZodEnum<any>>(t: TaskContext, expected: T) {
-	return {
-		from(actual: T) {
-			expect(actual.def).toStrictEqual(expected.def);
-		},
-	};
-}
-
-export function Expect<_ extends true>() {}
diff --git a/drizzle-zod/tsconfig.build.json b/drizzle-zod/tsconfig.build.json
deleted file mode 100644
index 1af9f8b40b..0000000000
--- a/drizzle-zod/tsconfig.build.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-	"extends": "./tsconfig.json",
-	"compilerOptions": {
-		"rootDir": "src",
-		"stripInternal": true
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-zod/tsconfig.json b/drizzle-zod/tsconfig.json
deleted file mode 100644
index c25379c37b..0000000000
--- a/drizzle-zod/tsconfig.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"baseUrl": ".",
-		"declaration": true,
-		"noEmit": true,
-		"paths": {
-			"~/*": ["src/*"]
-		}
-	},
-	"include": ["src", "*.ts"]
-}
diff --git a/drizzle-zod/vitest.config.ts b/drizzle-zod/vitest.config.ts
deleted file mode 100644
index 1f0eb7ad9a..0000000000
--- a/drizzle-zod/vitest.config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-	test: {
-		include: [
-			'tests/**/*.test.ts',
-		],
-		exclude: [
-			'tests/bun/**/*',
-		],
-		typecheck: {
-			tsconfig: 'tsconfig.json',
-		},
-		testTimeout: 100000,
-		hookTimeout: 100000,
-		isolate: false,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-	},
-	plugins: [tsconfigPaths()],
-});
diff --git a/eslint-plugin-drizzle/package.json b/eslint-plugin-drizzle/package.json
index 354c6e2b85..8e6ab454a1 100644
--- a/eslint-plugin-drizzle/package.json
+++ b/eslint-plugin-drizzle/package.json
@@ -1,12 +1,14 @@
 {
 	"name": "eslint-plugin-drizzle",
-	"version": "0.2.3",
+	"version": "1.0.0-rc.4",
 	"description": "Eslint plugin for drizzle users to avoid common pitfalls",
 	"main": "src/index.js",
 	"scripts": {
 		"test": "vitest run",
+		"build:artifact": "pnpm run build",
 		"build": "tsc -b && pnpm cpy readme.md dist/",
 		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
+		"pack:artifact": "pnpm run pack",
 		"publish": "npm publish package.tgz"
 	},
 	"keywords": [
@@ -28,8 +30,7 @@
 		"@typescript-eslint/utils": "^6.10.0",
 		"cpy-cli": "^5.0.0",
 		"eslint": "^8.53.0",
-		"typescript": "^5.2.2",
-		"vitest": "^3.1.3"
+		"typescript": "5.9.3"
 	},
 	"peerDependencies": {
 		"eslint": ">=8.0.0"
diff --git a/eslint/eslint-plugin-drizzle-internal/index.js b/eslint/eslint-plugin-drizzle-internal/index.js
deleted file mode 100644
index 754fc0e8f0..0000000000
--- a/eslint/eslint-plugin-drizzle-internal/index.js
+++ /dev/null
@@ -1,81 +0,0 @@
-// @ts-nocheck
-const { ESLintUtils } = require('@typescript-eslint/experimental-utils');
-const ts = require('typescript');
-
-module.exports = {
-	rules: {
-		'require-entity-kind': ESLintUtils.RuleCreator((name) => name)({
-			meta: {
-				type: 'problem',
-				docs: {
-					description: 'Enforce the usage of a static readonly [entityKind] property on Drizzle classes',
-					recommended: 'error',
-				},
-				messages: {
-					missingEntityKind:
-						"Class '{{name}}' doesn't have a static readonly [entityKind] property defined with a string value.",
-				},
-				schema: [],
-				fixable: 'code',
-			},
-			defaultOptions: [],
-			create(context) {
-				const parserServices = ESLintUtils.getParserServices(context);
-				const checker = parserServices.program.getTypeChecker();
-
-				return {
-					ClassDeclaration(node) {
-						const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-						const className = tsNode.name
-							? tsNode.name.text
-							: undefined;
-
-						ts.SyntaxKind.PropertyDeclaration;
-
-						for (const prop of tsNode.members) {
-							if (
-								prop.kind
-									=== ts.SyntaxKind.PropertyDeclaration
-								&& prop.modifiers?.some(
-									(m) => m.kind === ts.SyntaxKind.StaticKeyword,
-								)
-								&& prop.modifiers?.some(
-									(m) =>
-										m.kind
-											=== ts.SyntaxKind.ReadonlyKeyword,
-								)
-								&& ts.isComputedPropertyName(prop.name)
-								&& ts.isIdentifier(prop.name.expression)
-								&& prop.name.expression.escapedText
-									=== 'entityKind'
-								&& checker
-									.getTypeAtLocation(prop.initializer)
-									.isStringLiteral()
-							) {
-								return;
-							}
-						}
-
-						context.report({
-							node,
-							messageId: 'missingEntityKind',
-							data: {
-								name: className,
-							},
-							fix(fixer) {
-								const classBodyOpeningCurlyToken = context
-									.getSourceCode()
-									.getFirstToken(node.body);
-								const insertionPoint = classBodyOpeningCurlyToken.range[1];
-								return fixer.insertTextAfterRange(
-									[insertionPoint, insertionPoint],
-									`\n\tstatic readonly [entityKind]: string = '${className}';\n`,
-								);
-							},
-						});
-					},
-				};
-			},
-		}),
-	},
-};
diff --git a/eslint/eslint-plugin-drizzle-internal/index.mjs b/eslint/eslint-plugin-drizzle-internal/index.mjs
new file mode 100644
index 0000000000..89be4fe840
--- /dev/null
+++ b/eslint/eslint-plugin-drizzle-internal/index.mjs
@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { definePlugin, defineRule } from 'oxlint';
+
+export default definePlugin({
+	meta: { name: 'drizzle-internal' },
+	rules: {
+		'no-instanceof': defineRule({
+			meta: {
+				messages: {
+					noInstanceof: 'Use of "instanceof" operator is forbidden',
+				},
+				fixable: 'code',
+			},
+			create: (context) => ({
+				BinaryExpression: (node) => {
+					if (node.type === 'BinaryExpression' && node.operator === 'instanceof') {
+						context.report({
+							node: node,
+							message: 'Use of "instanceof" operator is forbidden',
+						});
+					}
+				},
+			}),
+		}),
+		'require-entity-kind': defineRule({
+			meta: {
+				messages: {
+					missingEntityKind:
+						"Class '{{name}}' doesn't have a static readonly [entityKind] property defined with a string value.",
+				},
+				fixable: 'code',
+			},
+			create: (context) => ({
+				ClassDeclaration: (node) => {
+					const sourceCode = context.sourceCode.getText(node);
+
+					if (
+						!(sourceCode.includes('static override readonly [entityKind]: string')
+							|| sourceCode.includes('static readonly [entityKind]: string'))
+					) {
+						context.report({
+							node: node,
+							message:
+								`Class '${node.id.name}' doesn't have a static readonly [entityKind] property defined with a string value.`,
+						});
+					}
+				},
+			}),
+		}),
+	},
+});
diff --git a/flake.lock b/flake.lock
deleted file mode 100644
index 68b7fbf809..0000000000
--- a/flake.lock
+++ /dev/null
@@ -1,61 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1755315522,
-        "narHash": "sha256-n94kNRZQUMi4MdsgmVo5DpjVFrXBn4m6ODEmbjUuys0=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "71a314ae4e39880e2248cb9bb52b61728c792c0a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "master",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
diff --git a/flake.nix b/flake.nix
deleted file mode 100644
index 5e93d9c518..0000000000
--- a/flake.nix
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/master";
-  inputs.flake-utils.url = "github:numtide/flake-utils";
-
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system: let
-      pkgs = nixpkgs.legacyPackages.${system};
-    in {
-      devShell = pkgs.mkShell {
-        nativeBuildInputs = [ pkgs.bashInteractive ];
-        buildInputs = with pkgs; [
-          nodejs
-          pnpm
-          typescript
-        ];
-      };
-    });
-}
diff --git a/integration-tests/.env.example b/integration-tests/.env.example
index 1651f84074..d5d3339113 100644
--- a/integration-tests/.env.example
+++ b/integration-tests/.env.example
@@ -4,7 +4,7 @@ SINGLESTORE_CONNECTION_STRING="singlestore://root:singlestore@localhost:3306/dri
 PLANETSCALE_CONNECTION_STRING=
 TIDB_CONNECTION_STRING=
 NEON_HTTP_CONNECTION_STRING=postgres://postgres:postgres@db.localtest.me:5432/postgres
-NEON_SERVERLESS_CONNECTION_STRING=postgres://postgres:postgres@localhost:5445/postgres
+NEON_CONNECTION_STRING=postgres://postgres:postgres@localhost:5445/postgres
 LIBSQL_URL="file:local.db"
 LIBSQL_AUTH_TOKEN="ey..." # For Turso only
 LIBSQL_REMOTE_URL="libsql://..."
@@ -14,3 +14,5 @@ AWS_DATA_API_SECRET_ARN=
 AWS_DATA_API_RESOURCE_ARN=
 AWS_TEST_PROFILE=
 VERCEL_CONNECTION_STRING= # For driver-init, utils/is-config tests. Must not be local DB - breaks with Vercel drivers
+SQLITE_CLOUD_CONNECTION_STRING=
+NETLIFY_DB_URL=
\ No newline at end of file
diff --git a/integration-tests/.gitignore b/integration-tests/.gitignore
index f543b6b5bc..e48c194a29 100644
--- a/integration-tests/.gitignore
+++ b/integration-tests/.gitignore
@@ -4,3 +4,4 @@ trace
 tests/imports/imports.cjs
 tests/imports/imports.mjs
 .sst
+test.ts
\ No newline at end of file
diff --git a/integration-tests/bunfig.toml b/integration-tests/bunfig.toml
new file mode 100644
index 0000000000..b3697f8d4e
--- /dev/null
+++ b/integration-tests/bunfig.toml
@@ -0,0 +1 @@
+coverage = false
\ No newline at end of file
diff --git a/integration-tests/docker-neon.yml b/integration-tests/docker-neon.yml
deleted file mode 100644
index 72deb13be1..0000000000
--- a/integration-tests/docker-neon.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-services:
-  postgres:
-      image: 'postgres:latest'
-      environment:
-        POSTGRES_USER: postgres
-        POSTGRES_PASSWORD: postgres
-        POSTGRES_DB: postgres
-      ports:
-      - '5432:5441'
-      healthcheck:
-        test: ['CMD-SHELL', 'pg_isready -U postgres']
-        interval: 10s
-        timeout: 5s
-        retries: 5
-  neon-proxy:
-    image: ghcr.io/timowilhelm/local-neon-http-proxy:main
-    environment:
-      - PG_CONNECTION_STRING=postgres://postgres:postgres@postgres:5432/postgres
-    ports:
-      - '4444:4444'
-    depends_on:
-      postgres:
-        condition: service_healthy
-  pg_proxy:
-      image: ghcr.io/neondatabase/wsproxy:latest
-      environment:
-        APPEND_PORT: 'postgres:5432'
-        ALLOW_ADDR_REGEX: '.*'
-        LOG_TRAFFIC: 'true'
-      ports:
-      - '5446:80'
-      depends_on:
-      - postgres
diff --git a/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/migration.sql b/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/migration.sql
new file mode 100644
index 0000000000..20f0c1ec37
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/migration.sql
@@ -0,0 +1,11 @@
+CREATE TABLE "users12" (
+	"id" int4 PRIMARY KEY GENERATED ALWAYS AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),
+	"name" string NOT NULL,
+	"email" string NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "users13" (
+	"id" int4 PRIMARY KEY GENERATED ALWAYS AS IDENTITY (INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),
+	"name" string NOT NULL,
+	"email" string NOT NULL
+);
diff --git a/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/snapshot.json b/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/snapshot.json
new file mode 100644
index 0000000000..73070f4230
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach-init/20251120194306_misty_albert_cleary/snapshot.json
@@ -0,0 +1,135 @@
+{
+  "version": "1",
+  "dialect": "cockroach",
+  "id": "a6989e29-6373-4ce5-b3d1-2a5ada54dcfc",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "users13",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "type": "int4",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": {
+        "type": "always",
+        "increment": "1",
+        "startWith": "1",
+        "minValue": "1",
+        "maxValue": "2147483647",
+        "cache": 1
+      },
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "int4",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": {
+        "type": "always",
+        "increment": "1",
+        "startWith": "1",
+        "minValue": "1",
+        "maxValue": "2147483647",
+        "cache": 1
+      },
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users13"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users13"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users13"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pkey",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users13_pkey",
+      "schema": "public",
+      "table": "users13",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/migration.sql b/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/migration.sql
new file mode 100644
index 0000000000..64f9507ee2
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/migration.sql
@@ -0,0 +1 @@
+DROP TABLE "users13";
\ No newline at end of file
diff --git a/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/snapshot.json b/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/snapshot.json
new file mode 100644
index 0000000000..e8c13cff08
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach-init/20251120194310_flashy_nebula/snapshot.json
@@ -0,0 +1,73 @@
+{
+  "version": "1",
+  "dialect": "cockroach",
+  "id": "603be25f-26a8-425f-9248-47230b99bd2e",
+  "prevIds": [
+    "a6989e29-6373-4ce5-b3d1-2a5ada54dcfc"
+  ],
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "type": "int4",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": {
+        "type": "always",
+        "increment": "1",
+        "startWith": "1",
+        "minValue": "1",
+        "maxValue": "2147483647",
+        "cache": 1
+      },
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pkey",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/migration.sql b/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/migration.sql
new file mode 100644
index 0000000000..f93ff0625d
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/migration.sql
@@ -0,0 +1,7 @@
+CREATE TABLE "users12" (
+	"id" int4 GENERATED ALWAYS AS IDENTITY (
+		INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1
+	),
+	"name" string,
+	"email" string NOT NULL
+);
\ No newline at end of file
diff --git a/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/snapshot.json b/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/snapshot.json
new file mode 100644
index 0000000000..b167127efd
--- /dev/null
+++ b/integration-tests/drizzle2/cockroach/20251120194306_misty_albert_cleary/snapshot.json
@@ -0,0 +1,61 @@
+{
+  "version": "1",
+  "dialect": "cockroach",
+  "id": "cd7bca85-fda1-4129-a13c-4c08c82c0ec4",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "type": "int4",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": {
+        "type": "always",
+        "increment": "1",
+        "startWith": "1",
+        "minValue": "1",
+        "maxValue": "2147483647",
+        "cache": 1
+      },
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "string",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    }
+  ],
+  "renames": []
+}
diff --git a/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/migration.sql b/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/migration.sql
new file mode 100644
index 0000000000..68b1bf2e38
--- /dev/null
+++ b/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/migration.sql
@@ -0,0 +1,13 @@
+CREATE TABLE [users12] (
+	[id] int IDENTITY(1, 1),
+	[name] text NOT NULL,
+	[email] text NOT NULL,
+	CONSTRAINT [users12_pkey] PRIMARY KEY([id])
+);
+--> statement-breakpoint
+CREATE TABLE [users13] (
+	[id] int IDENTITY(1, 1),
+	[name] text NOT NULL,
+	[email] text NOT NULL,
+	CONSTRAINT [users13_pkey] PRIMARY KEY([id])
+);
diff --git a/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/snapshot.json b/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/snapshot.json
new file mode 100644
index 0000000000..2a3dd8ccd1
--- /dev/null
+++ b/integration-tests/drizzle2/mssql-init/20251120231500_parched_boomerang/snapshot.json
@@ -0,0 +1,107 @@
+{
+  "version": "1",
+  "dialect": "mssql",
+  "id": "4a793769-8ce6-4179-bbf5-cea1ba3de5ef",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "dbo"
+    },
+    {
+      "name": "users13",
+      "entityType": "tables",
+      "schema": "dbo"
+    },
+    {
+      "type": "int",
+      "notNull": true,
+      "generated": null,
+      "identity": {
+        "seed": 1,
+        "increment": 1
+      },
+      "name": "id",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "int",
+      "notNull": true,
+      "generated": null,
+      "identity": {
+        "seed": 1,
+        "increment": 1
+      },
+      "name": "id",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "nameExplicit": false,
+      "columns": [
+        "id"
+      ],
+      "name": "users12_pkey",
+      "table": "users12",
+      "schema": "dbo",
+      "entityType": "pks"
+    },
+    {
+      "nameExplicit": false,
+      "columns": [
+        "id"
+      ],
+      "name": "users13_pkey",
+      "table": "users13",
+      "schema": "dbo",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/migration.sql b/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/migration.sql
new file mode 100644
index 0000000000..a5520ba63b
--- /dev/null
+++ b/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/migration.sql
@@ -0,0 +1 @@
+DROP TABLE [users13];
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/snapshot.json b/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/snapshot.json
new file mode 100644
index 0000000000..7387f5dded
--- /dev/null
+++ b/integration-tests/drizzle2/mssql-init/20251120231510_sharp_loners/snapshot.json
@@ -0,0 +1,59 @@
+{
+  "version": "1",
+  "dialect": "mssql",
+  "id": "0c15c859-9a9b-491f-b3e1-4bb0ee502afb",
+  "prevIds": [
+    "4a793769-8ce6-4179-bbf5-cea1ba3de5ef"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "dbo"
+    },
+    {
+      "type": "int",
+      "notNull": true,
+      "generated": null,
+      "identity": {
+        "seed": 1,
+        "increment": 1
+      },
+      "name": "id",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "schema": "dbo",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "nameExplicit": false,
+      "columns": [
+        "id"
+      ],
+      "name": "users12_pkey",
+      "table": "users12",
+      "schema": "dbo",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mssql/20251120194306_misty_albert_cleary/migration.sql b/integration-tests/drizzle2/mssql/20251120194306_misty_albert_cleary/migration.sql
new file mode 100644
index 0000000000..bb3978502e
--- /dev/null
+++ b/integration-tests/drizzle2/mssql/20251120194306_misty_albert_cleary/migration.sql
@@ -0,0 +1,22 @@
+CREATE TABLE [cities_migration] (
+	[id] int,
+	[fullname_name] text,
+	[state] text
+);
+
+--> statement-breakpoint
+CREATE TABLE [users_migration] (
+	[id] int PRIMARY KEY NOT NULL,
+	[full_name] text,
+	[phone] int,
+	[invited_by] int,
+	[city_id] int,
+	[date] timestamp
+);
+
+--> statement-breakpoint
+CREATE TABLE [users12] (
+	[id] int identity PRIMARY KEY NOT NULL,
+	[name] text NOT NULL,
+	[email] text NOT NULL
+);
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql/meta/0000_snapshot.json b/integration-tests/drizzle2/mssql/20251120194306_misty_albert_cleary/snapshot.json
similarity index 100%
rename from integration-tests/drizzle2/mysql/meta/0000_snapshot.json
rename to integration-tests/drizzle2/mssql/20251120194306_misty_albert_cleary/snapshot.json
diff --git a/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/migration.sql b/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/migration.sql
new file mode 100644
index 0000000000..5ea6f38b8f
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/migration.sql
@@ -0,0 +1,11 @@
+CREATE TABLE `users12` (
+	`id` serial PRIMARY KEY,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `users13` (
+	`id` serial PRIMARY KEY,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
diff --git a/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/snapshot.json b/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/snapshot.json
new file mode 100644
index 0000000000..d7b0f12bfd
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-init/20251120204726_swift_wendell_rand/snapshot.json
@@ -0,0 +1,119 @@
+{
+  "version": "6",
+  "dialect": "mysql",
+  "id": "39891942-6c9a-43fd-84df-f53a9b256e21",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "name": "users13",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "name": "PRIMARY",
+      "table": "users12",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "name": "PRIMARY",
+      "table": "users13",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/migration.sql b/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/migration.sql
new file mode 100644
index 0000000000..842cd9005e
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/migration.sql
@@ -0,0 +1 @@
+DROP TABLE `users13`;
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/snapshot.json b/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/snapshot.json
new file mode 100644
index 0000000000..b1feed1d9d
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-init/20251120204734_slimy_phil_sheldon/snapshot.json
@@ -0,0 +1,65 @@
+{
+  "version": "6",
+  "dialect": "mysql",
+  "id": "c9e80830-642e-4b79-8410-190d8984f1d7",
+  "prevIds": [
+    "39891942-6c9a-43fd-84df-f53a9b256e21"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "name": "PRIMARY",
+      "table": "users12",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-proxy/first/0000_nostalgic_carnage.sql b/integration-tests/drizzle2/mysql-proxy/first/20230331135521_nostalgic_carnage/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/mysql-proxy/first/0000_nostalgic_carnage.sql
rename to integration-tests/drizzle2/mysql-proxy/first/20230331135521_nostalgic_carnage/migration.sql
diff --git a/integration-tests/drizzle2/mysql-proxy/first/20230331135521_nostalgic_carnage/snapshot.json b/integration-tests/drizzle2/mysql-proxy/first/20230331135521_nostalgic_carnage/snapshot.json
new file mode 100644
index 0000000000..b879fa125b
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-proxy/first/20230331135521_nostalgic_carnage/snapshot.json
@@ -0,0 +1,85 @@
+{
+  "version": "6",
+  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "dialect": "mysql",
+  "ddl": [
+    {
+      "name": "userstest",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": false,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "false",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "verified",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "json",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "jsonb",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "now()",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "created_at",
+      "table": "userstest",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-proxy/first/meta/0000_snapshot.json b/integration-tests/drizzle2/mysql-proxy/first/meta/0000_snapshot.json
deleted file mode 100644
index 1d01f3bcff..0000000000
--- a/integration-tests/drizzle2/mysql-proxy/first/meta/0000_snapshot.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "userstest": {
-      "name": "userstest",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false,
-          "autoincrement": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "json",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()",
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/mysql-proxy/first/meta/_journal.json b/integration-tests/drizzle2/mysql-proxy/first/meta/_journal.json
deleted file mode 100644
index 708471cf51..0000000000
--- a/integration-tests/drizzle2/mysql-proxy/first/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680270921944,
-      "tag": "0000_nostalgic_carnage",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-proxy/second/0000_nostalgic_carnage.sql b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_nostalgic_carnage/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/mysql-proxy/second/0000_nostalgic_carnage.sql
rename to integration-tests/drizzle2/mysql-proxy/second/20230331135521_nostalgic_carnage/migration.sql
diff --git a/integration-tests/drizzle2/mysql-proxy/second/20230331135521_nostalgic_carnage/snapshot.json b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_nostalgic_carnage/snapshot.json
new file mode 100644
index 0000000000..b879fa125b
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_nostalgic_carnage/snapshot.json
@@ -0,0 +1,85 @@
+{
+  "version": "6",
+  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "dialect": "mysql",
+  "ddl": [
+    {
+      "name": "userstest",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": false,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "false",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "verified",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "json",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "jsonb",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "now()",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "created_at",
+      "table": "userstest",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-proxy/second/0001_test.sql b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_test/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/mysql-proxy/second/0001_test.sql
rename to integration-tests/drizzle2/mysql-proxy/second/20230331135521_test/migration.sql
diff --git a/integration-tests/drizzle2/mysql-proxy/second/20230331135521_test/snapshot.json b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_test/snapshot.json
new file mode 100644
index 0000000000..770052555a
--- /dev/null
+++ b/integration-tests/drizzle2/mysql-proxy/second/20230331135521_test/snapshot.json
@@ -0,0 +1,147 @@
+{
+  "version": "6",
+  "id": "47362df0-c353-4bd1-8107-fcc36f0e61bd",
+  "prevIds": [
+    "8e8c8378-0496-40f6-88e3-98aab8282b1f"
+  ],
+  "dialect": "mysql",
+  "ddl": [
+    {
+      "name": "userstest",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": false,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "false",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "verified",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "json",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "jsonb",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": "now()",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "created_at",
+      "table": "userstest",
+      "entityType": "columns"
+    },
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        {
+          "value": "name",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "using": "btree",
+      "algorithm": null,
+      "lock": null,
+      "nameExplicit": true,
+      "name": "my_unique_index",
+      "table": "users12",
+      "entityType": "indexes"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql-proxy/second/meta/0000_snapshot.json b/integration-tests/drizzle2/mysql-proxy/second/meta/0000_snapshot.json
deleted file mode 100644
index 1d01f3bcff..0000000000
--- a/integration-tests/drizzle2/mysql-proxy/second/meta/0000_snapshot.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "userstest": {
-      "name": "userstest",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false,
-          "autoincrement": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "json",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()",
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/mysql-proxy/second/meta/0001_snapshot.json b/integration-tests/drizzle2/mysql-proxy/second/meta/0001_snapshot.json
deleted file mode 100644
index bda94226a7..0000000000
--- a/integration-tests/drizzle2/mysql-proxy/second/meta/0001_snapshot.json
+++ /dev/null
@@ -1,96 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "id": "47362df0-c353-4bd1-8107-fcc36f0e61bd",
-  "prevId": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
-  "tables": {
-    "userstest": {
-      "name": "userstest",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false,
-          "autoincrement": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "json",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()",
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    },
-    "users12": {
-      "name": "users12",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "email": {
-          "name": "email",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "my_unique_index": {
-          "name": "my_unique_index",
-          "columns": ["name"],
-          "isUnique": true,
-          "using": "btree"
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/mysql-proxy/second/meta/_journal.json b/integration-tests/drizzle2/mysql-proxy/second/meta/_journal.json
deleted file mode 100644
index fdd1a2ee3b..0000000000
--- a/integration-tests/drizzle2/mysql-proxy/second/meta/_journal.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680270921944,
-      "tag": "0000_nostalgic_carnage",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "5",
-      "when": 1680270921945,
-      "tag": "0001_test",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql/0000_nostalgic_carnage.sql b/integration-tests/drizzle2/mysql/20230331135521_nostalgic_carnage/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/mysql/0000_nostalgic_carnage.sql
rename to integration-tests/drizzle2/mysql/20230331135521_nostalgic_carnage/migration.sql
diff --git a/integration-tests/drizzle2/mysql/20230331135521_nostalgic_carnage/snapshot.json b/integration-tests/drizzle2/mysql/20230331135521_nostalgic_carnage/snapshot.json
new file mode 100644
index 0000000000..c2362e9b32
--- /dev/null
+++ b/integration-tests/drizzle2/mysql/20230331135521_nostalgic_carnage/snapshot.json
@@ -0,0 +1,207 @@
+{
+  "version": "6",
+  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "dialect": "mysql",
+  "ddl": [
+    {
+      "name": "cities_migration",
+      "entityType": "tables"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "fullname_name",
+      "table": "cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "state",
+      "table": "cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "name": "users_migration",
+      "entityType": "tables"
+    },
+    {
+      "type": "int",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "full_name",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "phone",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "invited_by",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "city_id",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": "(now())",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "date",
+      "table": "users_migration",
+      "entityType": "columns"
+    },
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        {
+          "value": "name",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "using": "btree",
+      "algorithm": null,
+      "lock": null,
+      "nameExplicit": true,
+      "name": "my_unique_index",
+      "table": "users12",
+      "entityType": "indexes"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/mysql/meta/_journal.json b/integration-tests/drizzle2/mysql/meta/_journal.json
deleted file mode 100644
index 708471cf51..0000000000
--- a/integration-tests/drizzle2/mysql/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680270921944,
-      "tag": "0000_nostalgic_carnage",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/migration.sql b/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/migration.sql
new file mode 100644
index 0000000000..de1ab7c10c
--- /dev/null
+++ b/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/migration.sql
@@ -0,0 +1,5 @@
+CREATE TABLE "users12" (
+	"id" serial PRIMARY KEY,
+	"name" text NOT NULL,
+	"email" text NOT NULL
+);
diff --git a/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/snapshot.json b/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/snapshot.json
new file mode 100644
index 0000000000..1765ae3a92
--- /dev/null
+++ b/integration-tests/drizzle2/pg-init/20251120153629_exotic_eternals/snapshot.json
@@ -0,0 +1,66 @@
+{
+  "dialect": "postgres",
+  "id": "d8fbcab5-bce3-40b6-9ee0-92e30bc4cc4a",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "8",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "users12"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": true,
+      "name": "users12_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "users12"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-proxy/first/0000_puzzling_flatman.sql b/integration-tests/drizzle2/pg-proxy/first/20230331141203_puzzling_flatman/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/pg-proxy/first/0000_puzzling_flatman.sql
rename to integration-tests/drizzle2/pg-proxy/first/20230331141203_puzzling_flatman/migration.sql
diff --git a/integration-tests/drizzle2/pg-proxy/first/20230331141203_puzzling_flatman/snapshot.json b/integration-tests/drizzle2/pg-proxy/first/20230331141203_puzzling_flatman/snapshot.json
new file mode 100644
index 0000000000..d3fa94ffa9
--- /dev/null
+++ b/integration-tests/drizzle2/pg-proxy/first/20230331141203_puzzling_flatman/snapshot.json
@@ -0,0 +1,92 @@
+{
+  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "8",
+  "dialect": "postgres",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users_pkey",
+      "schema": "public",
+      "table": "users",
+      "entityType": "pks"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "false",
+      "generated": null,
+      "identity": null,
+      "name": "verified",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "jsonb",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamptz",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-proxy/first/meta/0000_snapshot.json b/integration-tests/drizzle2/pg-proxy/first/meta/0000_snapshot.json
deleted file mode 100644
index 4bb618d409..0000000000
--- a/integration-tests/drizzle2/pg-proxy/first/meta/0000_snapshot.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "users": {
-      "name": "users",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamptz",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/pg-proxy/first/meta/_journal.json b/integration-tests/drizzle2/pg-proxy/first/meta/_journal.json
deleted file mode 100644
index 6b2a35b4ae..0000000000
--- a/integration-tests/drizzle2/pg-proxy/first/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680271923328,
-      "tag": "0000_puzzling_flatman",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-proxy/second/0000_puzzling_flatman.sql b/integration-tests/drizzle2/pg-proxy/second/20230331141203_puzzling_flatman/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/pg-proxy/second/0000_puzzling_flatman.sql
rename to integration-tests/drizzle2/pg-proxy/second/20230331141203_puzzling_flatman/migration.sql
diff --git a/integration-tests/drizzle2/pg-proxy/second/20230331141203_puzzling_flatman/snapshot.json b/integration-tests/drizzle2/pg-proxy/second/20230331141203_puzzling_flatman/snapshot.json
new file mode 100644
index 0000000000..d3fa94ffa9
--- /dev/null
+++ b/integration-tests/drizzle2/pg-proxy/second/20230331141203_puzzling_flatman/snapshot.json
@@ -0,0 +1,92 @@
+{
+  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "8",
+  "dialect": "postgres",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users_pkey",
+      "schema": "public",
+      "table": "users",
+      "entityType": "pks"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "false",
+      "generated": null,
+      "identity": null,
+      "name": "verified",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "jsonb",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamptz",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-proxy/second/0001_test.sql b/integration-tests/drizzle2/pg-proxy/second/20230331141203_test/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/pg-proxy/second/0001_test.sql
rename to integration-tests/drizzle2/pg-proxy/second/20230331141203_test/migration.sql
diff --git a/integration-tests/drizzle2/pg-proxy/second/20230331141203_test/snapshot.json b/integration-tests/drizzle2/pg-proxy/second/20230331141203_test/snapshot.json
new file mode 100644
index 0000000000..2f21424b44
--- /dev/null
+++ b/integration-tests/drizzle2/pg-proxy/second/20230331141203_test/snapshot.json
@@ -0,0 +1,92 @@
+{
+  "id": "f2a88b25-f2da-4973-879e-60b57f24e7b9",
+  "prevIds": [
+    "cb1644bb-c5da-465a-8d70-f63d81e34514"
+  ],
+  "version": "8",
+  "dialect": "postgres",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "users",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users_pkey",
+      "schema": "public",
+      "table": "users",
+      "entityType": "pks"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "false",
+      "generated": null,
+      "identity": null,
+      "name": "verified",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "jsonb",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamptz",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "schema": "public",
+      "table": "users",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg-proxy/second/meta/0000_snapshot.json b/integration-tests/drizzle2/pg-proxy/second/meta/0000_snapshot.json
deleted file mode 100644
index 4bb618d409..0000000000
--- a/integration-tests/drizzle2/pg-proxy/second/meta/0000_snapshot.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "users": {
-      "name": "users",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamptz",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/pg-proxy/second/meta/0001_snapshot.json b/integration-tests/drizzle2/pg-proxy/second/meta/0001_snapshot.json
deleted file mode 100644
index c5d4b7cfec..0000000000
--- a/integration-tests/drizzle2/pg-proxy/second/meta/0001_snapshot.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "id": "f2a88b25-f2da-4973-879e-60b57f24e7b9",
-  "prevId": "cb1644bb-c5da-465a-8d70-f63d81e34514",
-  "tables": {
-    "users": {
-      "name": "users",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": false
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "verified": {
-          "name": "verified",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": true,
-          "default": false
-        },
-        "jsonb": {
-          "name": "jsonb",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamptz",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/pg-proxy/second/meta/_journal.json b/integration-tests/drizzle2/pg-proxy/second/meta/_journal.json
deleted file mode 100644
index de7a2ac566..0000000000
--- a/integration-tests/drizzle2/pg-proxy/second/meta/_journal.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680271923328,
-      "tag": "0000_puzzling_flatman",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "5",
-      "when": 1680271923329,
-      "tag": "0001_test",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg/0000_puzzling_flatman.sql b/integration-tests/drizzle2/pg/20230331141203_puzzling_flatman/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/pg/0000_puzzling_flatman.sql
rename to integration-tests/drizzle2/pg/20230331141203_puzzling_flatman/migration.sql
diff --git a/integration-tests/drizzle2/pg/20230331141203_puzzling_flatman/snapshot.json b/integration-tests/drizzle2/pg/20230331141203_puzzling_flatman/snapshot.json
new file mode 100644
index 0000000000..36b2ae3500
--- /dev/null
+++ b/integration-tests/drizzle2/pg/20230331141203_puzzling_flatman/snapshot.json
@@ -0,0 +1,527 @@
+{
+  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "8",
+  "dialect": "postgres",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "all_columns",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "type": "smallint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "smallint",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "smallint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "10",
+      "generated": null,
+      "identity": null,
+      "name": "smallint_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "integer",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "10",
+      "generated": null,
+      "identity": null,
+      "name": "integer_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric3",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(7,7)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric4",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'100'",
+      "generated": null,
+      "identity": null,
+      "name": "numeridef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "bigint",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "bigintdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "boolean",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "true",
+      "generated": null,
+      "identity": null,
+      "name": "boolean_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "text",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'text'",
+      "generated": null,
+      "identity": null,
+      "name": "textdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "varchar",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "varchar",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "varchar",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'text'",
+      "generated": null,
+      "identity": null,
+      "name": "varchardef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "serial",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigserial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "bigserial",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(100,2)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "decimal",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(100,2)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'100.0'",
+      "generated": null,
+      "identity": null,
+      "name": "decimaldef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "double precision",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "doublePrecision",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "double precision",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "doublePrecisiondef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "real",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "real",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "real",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "realdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "time(6) with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "time2",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "time",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "timedefnow",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp (6) with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp2",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp3",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp (4)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp4",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "timestampdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "date",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "date",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "date",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "datedef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "interval",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "interval",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "interval",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'10 days'",
+      "generated": null,
+      "identity": null,
+      "name": "intervaldef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pkey",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "pks"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg/0001_test.sql b/integration-tests/drizzle2/pg/20230331141203_test/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/pg/0001_test.sql
rename to integration-tests/drizzle2/pg/20230331141203_test/migration.sql
diff --git a/integration-tests/drizzle2/pg/20230331141203_test/snapshot.json b/integration-tests/drizzle2/pg/20230331141203_test/snapshot.json
new file mode 100644
index 0000000000..36b2ae3500
--- /dev/null
+++ b/integration-tests/drizzle2/pg/20230331141203_test/snapshot.json
@@ -0,0 +1,527 @@
+{
+  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "8",
+  "dialect": "postgres",
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "all_columns",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "type": "smallint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "smallint",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "smallint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "10",
+      "generated": null,
+      "identity": null,
+      "name": "smallint_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "integer",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "10",
+      "generated": null,
+      "identity": null,
+      "name": "integer_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric3",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(7,7)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "numeric4",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'100'",
+      "generated": null,
+      "identity": null,
+      "name": "numeridef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "bigint",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigint",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "bigintdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "boolean",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "true",
+      "generated": null,
+      "identity": null,
+      "name": "boolean_def",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "text",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'text'",
+      "generated": null,
+      "identity": null,
+      "name": "textdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "varchar",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "varchar",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "varchar",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'text'",
+      "generated": null,
+      "identity": null,
+      "name": "varchardef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "serial",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "bigserial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "bigserial",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(100,2)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "decimal",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "numeric(100,2)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'100.0'",
+      "generated": null,
+      "identity": null,
+      "name": "decimaldef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "double precision",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "doublePrecision",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "double precision",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "doublePrecisiondef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "real",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "real",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "real",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "100",
+      "generated": null,
+      "identity": null,
+      "name": "realdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "time(6) with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "time2",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "time",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "timedefnow",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp (6) with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp2",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp with time zone",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp3",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp (4)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "timestamp4",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "timestampdef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "date",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "date",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "date",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "now()",
+      "generated": null,
+      "identity": null,
+      "name": "datedef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "interval",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "interval",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "type": "interval",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": "'10 days'",
+      "generated": null,
+      "identity": null,
+      "name": "intervaldef",
+      "schema": "public",
+      "table": "all_columns",
+      "entityType": "columns"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "users12",
+      "schema": "public",
+      "entityType": "tables"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pkey",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "pks"
+    },
+    {
+      "type": "serial",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "name",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "email",
+      "schema": "public",
+      "table": "users12",
+      "entityType": "columns"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg/meta/0000_snapshot.json b/integration-tests/drizzle2/pg/meta/0000_snapshot.json
deleted file mode 100644
index 978de799a7..0000000000
--- a/integration-tests/drizzle2/pg/meta/0000_snapshot.json
+++ /dev/null
@@ -1,275 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "id": "cb1644bb-c5da-465a-8d70-f63d81e34514",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "all_columns": {
-      "name": "all_columns",
-      "schema": "",
-      "columns": {
-        "smallint": {
-          "name": "smallint",
-          "type": "smallint",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "smallint_def": {
-          "name": "smallint_def",
-          "type": "smallint",
-          "primaryKey": false,
-          "notNull": false,
-          "default": 10
-        },
-        "integer": {
-          "name": "integer",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "integer_def": {
-          "name": "integer_def",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "default": 10
-        },
-        "numeric": {
-          "name": "numeric",
-          "type": "numeric",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "numeric3": {
-          "name": "numeric3",
-          "type": "numeric",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "numeric4": {
-          "name": "numeric4",
-          "type": "numeric(7, 7)",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "numeridef": {
-          "name": "numeridef",
-          "type": "numeric",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'100'"
-        },
-        "bigint": {
-          "name": "bigint",
-          "type": "bigint",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "bigintdef": {
-          "name": "bigintdef",
-          "type": "bigint",
-          "primaryKey": false,
-          "notNull": false,
-          "default": 100
-        },
-        "boolean": {
-          "name": "boolean",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "boolean_def": {
-          "name": "boolean_def",
-          "type": "boolean",
-          "primaryKey": false,
-          "notNull": false,
-          "default": true
-        },
-        "text": {
-          "name": "text",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "textdef": {
-          "name": "textdef",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'text'"
-        },
-        "varchar": {
-          "name": "varchar",
-          "type": "varchar",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "varchardef": {
-          "name": "varchardef",
-          "type": "varchar",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'text'"
-        },
-        "serial": {
-          "name": "serial",
-          "type": "serial",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "bigserial": {
-          "name": "bigserial",
-          "type": "bigserial",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "decimal": {
-          "name": "decimal",
-          "type": "numeric(100, 2)",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "decimaldef": {
-          "name": "decimaldef",
-          "type": "numeric(100, 2)",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'100.0'"
-        },
-        "doublePrecision": {
-          "name": "doublePrecision",
-          "type": "double precision",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "doublePrecisiondef": {
-          "name": "doublePrecisiondef",
-          "type": "double precision",
-          "primaryKey": false,
-          "notNull": false,
-          "default": 100
-        },
-        "real": {
-          "name": "real",
-          "type": "real",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "realdef": {
-          "name": "realdef",
-          "type": "real",
-          "primaryKey": false,
-          "notNull": false,
-          "default": 100
-        },
-        "time2": {
-          "name": "time2",
-          "type": "time(6) with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "timedefnow": {
-          "name": "timedefnow",
-          "type": "time",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "now()"
-        },
-        "timestamp": {
-          "name": "timestamp",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "timestamp2": {
-          "name": "timestamp2",
-          "type": "timestamp (6) with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "timestamp3": {
-          "name": "timestamp3",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "timestamp4": {
-          "name": "timestamp4",
-          "type": "timestamp (4)",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "timestampdef": {
-          "name": "timestampdef",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "now()"
-        },
-        "date": {
-          "name": "date",
-          "type": "date",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "datedef": {
-          "name": "datedef",
-          "type": "date",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "now()"
-        },
-        "interval": {
-          "name": "interval",
-          "type": "interval",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "intervaldef": {
-          "name": "intervaldef",
-          "type": "interval",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'10 days'"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    },
-    "users12": {
-      "name": "users12",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "email": {
-          "name": "email",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/pg/meta/_journal.json b/integration-tests/drizzle2/pg/meta/_journal.json
deleted file mode 100644
index de7a2ac566..0000000000
--- a/integration-tests/drizzle2/pg/meta/_journal.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "version": "5",
-  "dialect": "pg",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680271923328,
-      "tag": "0000_puzzling_flatman",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "5",
-      "when": 1680271923329,
-      "tag": "0001_test",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/planetscale/0000_nostalgic_carnage.sql b/integration-tests/drizzle2/planetscale/20230331135521_nostalgic_carnage/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/planetscale/0000_nostalgic_carnage.sql
rename to integration-tests/drizzle2/planetscale/20230331135521_nostalgic_carnage/migration.sql
diff --git a/integration-tests/drizzle2/planetscale/20230331135521_nostalgic_carnage/snapshot.json b/integration-tests/drizzle2/planetscale/20230331135521_nostalgic_carnage/snapshot.json
new file mode 100644
index 0000000000..548b1a4359
--- /dev/null
+++ b/integration-tests/drizzle2/planetscale/20230331135521_nostalgic_carnage/snapshot.json
@@ -0,0 +1,207 @@
+{
+  "version": "6",
+  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "dialect": "mysql",
+  "ddl": [
+    {
+      "name": "drizzle_tests_cities_migration",
+      "entityType": "tables"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "drizzle_tests_cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "fullname_name",
+      "table": "drizzle_tests_cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "state",
+      "table": "drizzle_tests_cities_migration",
+      "entityType": "columns"
+    },
+    {
+      "name": "drizzle_tests_users_migration",
+      "entityType": "tables"
+    },
+    {
+      "type": "int",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "full_name",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "phone",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "invited_by",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "int",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "city_id",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "type": "timestamp",
+      "notNull": false,
+      "autoIncrement": false,
+      "default": "(now())",
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "date",
+      "table": "drizzle_tests_users_migration",
+      "entityType": "columns"
+    },
+    {
+      "name": "drizzle_tests_users12",
+      "entityType": "tables"
+    },
+    {
+      "type": "serial",
+      "notNull": true,
+      "autoIncrement": true,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "id",
+      "table": "drizzle_tests_users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "name",
+      "table": "drizzle_tests_users12",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoIncrement": false,
+      "default": null,
+      "onUpdateNow": false,
+      "onUpdateNowFsp": null,
+      "charSet": null,
+      "collation": null,
+      "generated": null,
+      "name": "email",
+      "table": "drizzle_tests_users12",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        {
+          "value": "name",
+          "isExpression": false
+        }
+      ],
+      "isUnique": true,
+      "using": "btree",
+      "algorithm": null,
+      "lock": null,
+      "nameExplicit": true,
+      "name": "my_unique_index",
+      "table": "drizzle_tests_users12",
+      "entityType": "indexes"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/planetscale/meta/0000_snapshot.json b/integration-tests/drizzle2/planetscale/meta/0000_snapshot.json
deleted file mode 100644
index 4218831c02..0000000000
--- a/integration-tests/drizzle2/planetscale/meta/0000_snapshot.json
+++ /dev/null
@@ -1,132 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "id": "8e8c8378-0496-40f6-88e3-98aab8282b1f",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "drizzle_tests_cities_migration": {
-      "name": "drizzle_tests_cities_migration",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "int",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "fullname_name": {
-          "name": "fullname_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "state": {
-          "name": "state",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    },
-    "drizzle_tests_users_migration": {
-      "name": "drizzle_tests_users_migration",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "int",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "full_name": {
-          "name": "full_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "phone": {
-          "name": "phone",
-          "type": "int",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "invited_by": {
-          "name": "invited_by",
-          "type": "int",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "city_id": {
-          "name": "city_id",
-          "type": "int",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "date": {
-          "name": "date",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false,
-          "default": "(now())"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    },
-    "drizzle_tests_users12": {
-      "name": "drizzle_tests_users12",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": true
-        },
-        "name": {
-          "name": "name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "email": {
-          "name": "email",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "autoincrement": false
-        }
-      },
-      "indexes": {
-        "my_unique_index": {
-          "name": "my_unique_index",
-          "columns": [
-            "name"
-          ],
-          "isUnique": true,
-          "using": "btree"
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    }
-  },
-  "schemas": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
diff --git a/integration-tests/drizzle2/planetscale/meta/_journal.json b/integration-tests/drizzle2/planetscale/meta/_journal.json
deleted file mode 100644
index 708471cf51..0000000000
--- a/integration-tests/drizzle2/planetscale/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "5",
-  "dialect": "mysql",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680270921944,
-      "tag": "0000_nostalgic_carnage",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/singlestore/0000_nostalgic_carnage.sql b/integration-tests/drizzle2/singlestore/20230331135521_nostalgic_carnage/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/singlestore/0000_nostalgic_carnage.sql
rename to integration-tests/drizzle2/singlestore/20230331135521_nostalgic_carnage/migration.sql
diff --git a/integration-tests/drizzle2/singlestore/meta/0000_snapshot.json b/integration-tests/drizzle2/singlestore/20230331135521_nostalgic_carnage/snapshot.json
similarity index 100%
rename from integration-tests/drizzle2/singlestore/meta/0000_snapshot.json
rename to integration-tests/drizzle2/singlestore/20230331135521_nostalgic_carnage/snapshot.json
diff --git a/integration-tests/drizzle2/singlestore/meta/_journal.json b/integration-tests/drizzle2/singlestore/meta/_journal.json
deleted file mode 100644
index 49e74f169e..0000000000
--- a/integration-tests/drizzle2/singlestore/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "1",
-  "dialect": "singlestore",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "1",
-      "when": 1680270921944,
-      "tag": "0000_nostalgic_carnage",
-      "breakpoints": true
-    }
-  ]
-}
diff --git a/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/migration.sql b/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/migration.sql
new file mode 100644
index 0000000000..690fee9d13
--- /dev/null
+++ b/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/migration.sql
@@ -0,0 +1,11 @@
+CREATE TABLE `users12` (
+	`id` integer PRIMARY KEY,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `users13` (
+	`id` integer PRIMARY KEY,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
diff --git a/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/snapshot.json b/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/snapshot.json
new file mode 100644
index 0000000000..94aaa4732b
--- /dev/null
+++ b/integration-tests/drizzle2/sqlite-init/20251121133136_even_frog_thor/snapshot.json
@@ -0,0 +1,97 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "id": "3536f101-e83a-4dd1-a7d5-149121fd2abf",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "name": "users13",
+      "entityType": "tables"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users13"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pk",
+      "table": "users12",
+      "entityType": "pks"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users13_pk",
+      "table": "users13",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/migration.sql b/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/migration.sql
new file mode 100644
index 0000000000..842cd9005e
--- /dev/null
+++ b/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/migration.sql
@@ -0,0 +1 @@
+DROP TABLE `users13`;
\ No newline at end of file
diff --git a/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/snapshot.json b/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/snapshot.json
new file mode 100644
index 0000000000..eb4264d956
--- /dev/null
+++ b/integration-tests/drizzle2/sqlite-init/20251121133143_perpetual_whizzer/snapshot.json
@@ -0,0 +1,54 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "id": "b2c3faaa-48ee-49b8-a938-a133e9b40269",
+  "prevIds": [
+    "3536f101-e83a-4dd1-a7d5-149121fd2abf"
+  ],
+  "ddl": [
+    {
+      "name": "users12",
+      "entityType": "tables"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "email",
+      "entityType": "columns",
+      "table": "users12"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users12_pk",
+      "table": "users12",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/sqlite/0000_fancy_bug.sql b/integration-tests/drizzle2/sqlite/20230330185056_fancy_bug/migration.sql
similarity index 100%
rename from integration-tests/drizzle2/sqlite/0000_fancy_bug.sql
rename to integration-tests/drizzle2/sqlite/20230330185056_fancy_bug/migration.sql
diff --git a/integration-tests/drizzle2/sqlite/20230330185056_fancy_bug/snapshot.json b/integration-tests/drizzle2/sqlite/20230330185056_fancy_bug/snapshot.json
new file mode 100644
index 0000000000..0274f3efeb
--- /dev/null
+++ b/integration-tests/drizzle2/sqlite/20230330185056_fancy_bug/snapshot.json
@@ -0,0 +1,166 @@
+{
+  "dialect": "sqlite",
+  "id": "b6793a90-b553-4a5d-9d2f-b48e56ef2a2a",
+  "prevIds": [
+    "00000000-0000-0000-0000-000000000000"
+  ],
+  "version": "7",
+  "ddl": [
+    {
+      "name": "cities",
+      "entityType": "tables"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "table": "cities",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": null,
+      "default": null,
+      "generated": null,
+      "name": "fullname_name",
+      "table": "cities",
+      "entityType": "columns"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": null,
+      "default": null,
+      "generated": null,
+      "name": "state",
+      "table": "cities",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        "id",
+        "fullname_name"
+      ],
+      "nameExplicit": true,
+      "name": null,
+      "table": "cities",
+      "entityType": "pks"
+    },
+    {
+      "name": "test_get",
+      "entityType": "tables"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "table": "test_get",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "test_get_pk",
+      "table": "test_get",
+      "entityType": "pks"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": null,
+      "default": null,
+      "generated": null,
+      "name": "full_name",
+      "table": "test_get",
+      "entityType": "columns"
+    },
+    {
+      "name": "users",
+      "entityType": "tables"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        "id"
+      ],
+      "nameExplicit": false,
+      "name": "users_pk",
+      "table": "users",
+      "entityType": "pks"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": null,
+      "default": null,
+      "generated": null,
+      "name": "full_name",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "phone",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "invited_by",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "type": "integer",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "city_id",
+      "table": "users",
+      "entityType": "columns"
+    },
+    {
+      "columns": [
+        "city_id"
+      ],
+      "tableTo": "cities",
+      "columnsTo": [
+        "id"
+      ],
+      "onUpdate": "NO ACTION",
+      "onDelete": "NO ACTION",
+      "nameExplicit": false,
+      "name": "users_city_id_cities_id_fk",
+      "table": "users",
+      "entityType": "fks"
+    }
+  ],
+  "renames": []
+}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/sqlite/meta/0000_snapshot.json b/integration-tests/drizzle2/sqlite/meta/0000_snapshot.json
deleted file mode 100644
index 09ac2198b8..0000000000
--- a/integration-tests/drizzle2/sqlite/meta/0000_snapshot.json
+++ /dev/null
@@ -1,123 +0,0 @@
-{
-  "version": "5",
-  "dialect": "sqlite",
-  "id": "b6793a90-b553-4a5d-9d2f-b48e56ef2a2a",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "tables": {
-    "cities": {
-      "name": "cities",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "fullname_name": {
-          "name": "fullname_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "state": {
-          "name": "state",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {
-        "cities_id_fullname_name_pk": {
-          "columns": [
-            "id",
-            "fullname_name"
-          ]
-        }
-      }
-    },
-    "test_get": {
-      "name": "test_get",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "full_name": {
-          "name": "full_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {}
-    },
-    "users": {
-      "name": "users",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "integer",
-          "primaryKey": true,
-          "notNull": true,
-          "autoincrement": false
-        },
-        "full_name": {
-          "name": "full_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "phone": {
-          "name": "phone",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "invited_by": {
-          "name": "invited_by",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "city_id": {
-          "name": "city_id",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "users_city_id_cities_id_fk": {
-          "name": "users_city_id_cities_id_fk",
-          "tableFrom": "users",
-          "tableTo": "cities",
-          "columnsFrom": [
-            "city_id"
-          ],
-          "columnsTo": [
-            "id"
-          ]
-        }
-      },
-      "compositePrimaryKeys": {}
-    }
-  },
-  "enums": {},
-  "_meta": {
-    "schemas": {},
-    "tables": {},
-    "columns": {}
-  }
-}
\ No newline at end of file
diff --git a/integration-tests/drizzle2/sqlite/meta/_journal.json b/integration-tests/drizzle2/sqlite/meta/_journal.json
deleted file mode 100644
index 013ef4788a..0000000000
--- a/integration-tests/drizzle2/sqlite/meta/_journal.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "version": "5",
-  "dialect": "sqlite",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "5",
-      "when": 1680202256473,
-      "tag": "0000_fancy_bug",
-      "breakpoints": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/integration-tests/js-tests/driver-init/commonjs/better-sqlite3.test.cjs b/integration-tests/js-tests/driver-init/commonjs/better-sqlite3.test.cjs
index 1a9941e300..feb368b477 100644
--- a/integration-tests/js-tests/driver-init/commonjs/better-sqlite3.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/better-sqlite3.test.cjs
@@ -30,7 +30,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -43,7 +43,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -58,7 +58,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: {}, ...config})', async () => {
@@ -71,7 +71,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -83,31 +83,18 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Database(':memory:');
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.exec('SELECT 1;');
 
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Database(':memory:');
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.exec('SELECT 1;');
-
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Database(':memory:');
 		const db = drizzle({
@@ -119,6 +106,6 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/libsql.test.cjs b/integration-tests/js-tests/driver-init/commonjs/libsql.test.cjs
index e070af1bc0..333bfdccd0 100644
--- a/integration-tests/js-tests/driver-init/commonjs/libsql.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/libsql.test.cjs
@@ -22,7 +22,7 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -35,7 +35,7 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -50,35 +50,20 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createClient({
 			url: ':memory:',
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createClient({
-			url: ':memory:',
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createClient({
 			url: ':memory:',
@@ -92,6 +77,6 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/mysql2.test.cjs b/integration-tests/js-tests/driver-init/commonjs/mysql2.test.cjs
index 44a0987d1c..234985054c 100644
--- a/integration-tests/js-tests/driver-init/commonjs/mysql2.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/mysql2.test.cjs
@@ -24,12 +24,11 @@ describe('mysql2', async (it) => {
 			process.env['MYSQL_CONNECTION_STRING'],
 			{
 				schema,
-				mode: 'default',
 			},
 		);
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
@@ -37,12 +36,11 @@ describe('mysql2', async (it) => {
 		const db = drizzle({
 			connection: process.env['MYSQL_CONNECTION_STRING'],
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
@@ -52,42 +50,26 @@ describe('mysql2', async (it) => {
 				uri: process.env['MYSQL_CONNECTION_STRING'],
 			},
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createPool({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createPool({
-			uri: process.env['MYSQL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-			mode: 'default',
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client.getConnection).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createPool({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
@@ -96,41 +78,25 @@ describe('mysql2', async (it) => {
 		const db = drizzle({
 			client,
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 });
 
 describe('mysql2:connection', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createConnection({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.$client.getConnection).toStrictEqual(undefined);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const client = createConnection({
-			uri: process.env['MYSQL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-			mode: 'default',
-		});
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).toStrictEqual(undefined);
 	});
 
@@ -142,12 +108,11 @@ describe('mysql2:connection', async (it) => {
 		const db = drizzle({
 			client,
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/neon-http.test.cjs b/integration-tests/js-tests/driver-init/commonjs/neon-http.test.cjs
index ad68b96a33..b5aaff0954 100644
--- a/integration-tests/js-tests/driver-init/commonjs/neon-http.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/neon-http.test.cjs
@@ -27,7 +27,7 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -38,7 +38,7 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -51,31 +51,18 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = pg(
 			process.env['NEON_CONNECTION_STRING'],
 		);
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = pg(
-			process.env['NEON_CONNECTION_STRING'],
-		);
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = pg(
 			process.env['NEON_CONNECTION_STRING'],
@@ -87,6 +74,6 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/neon-ws.test.cjs b/integration-tests/js-tests/driver-init/commonjs/neon-ws.test.cjs
index 28b5026c60..5f2f692d77 100644
--- a/integration-tests/js-tests/driver-init/commonjs/neon-ws.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/neon-ws.test.cjs
@@ -30,7 +30,7 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
@@ -42,7 +42,7 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
@@ -56,35 +56,21 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Pool({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client).toBeInstanceOf(Pool);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -96,20 +82,20 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 });
 
 describe('neon-ws:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
 
 		await client.connect();
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
@@ -117,23 +103,6 @@ describe('neon-ws:Client', async (it) => {
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.$client).not.toBeInstanceOf(Pool);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -147,44 +116,25 @@ describe('neon-ws:Client', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
 });
 
 describe('neon-ws:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
-		const pool = new Pool({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-
-		client.release();
-
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.$client).not.toBeInstanceOf(Pool);
-	});
-
-	it('drizzle(client, config)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
 
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		client.release();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
@@ -204,7 +154,7 @@ describe('neon-ws:PoolClient', async (it) => {
 
 		client.release();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
diff --git a/integration-tests/js-tests/driver-init/commonjs/node-mssql.test.cjs b/integration-tests/js-tests/driver-init/commonjs/node-mssql.test.cjs
new file mode 100644
index 0000000000..f14ec95652
--- /dev/null
+++ b/integration-tests/js-tests/driver-init/commonjs/node-mssql.test.cjs
@@ -0,0 +1,91 @@
+require('dotenv/config');
+const { drizzle } = require('drizzle-orm/node-mssql');
+const mssql = require('mssql');
+const { mssql: schema } = require('./schema.cjs');
+import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { createDockerDB } from '../../../tests/mssql/mssql-common.ts';
+
+const Pool = mssql.ConnectionPool;
+let container;
+let connectionString;
+
+describe('node-mssql', async (it) => {
+	beforeAll(async () => {
+		if (process.env['MSSQL_CONNECTION_STRING']) {
+			connectionString = process.env['MSSQL_CONNECTION_STRING'];
+		} else {
+			const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
+			container = contrainerObj;
+			connectionString = conStr;
+		}
+
+		while (true) {
+			try {
+				await mssql.connect(connectionString);
+				break;
+			} catch (e) {
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+			}
+		}
+	});
+
+	afterAll(async () => {
+		await container?.stop();
+	});
+
+	it('drizzle(string)', async () => {
+		const db = drizzle(connectionString);
+
+		const awaitedPool = await db.$client;
+
+		await awaitedPool.query('SELECT 1;');
+
+		expect(awaitedPool).toBeInstanceOf(Pool);
+	});
+
+	it('drizzle(string, config)', async () => {
+		const db = drizzle(connectionString, {
+			schema,
+		});
+
+		const awaitedPool = await db.$client;
+
+		await awaitedPool.query('SELECT 1;');
+
+		expect(awaitedPool).toBeInstanceOf(Pool);
+		// expect(db.query.User).not.toStrictEqual(undefined);
+	});
+
+	it('drizzle({connection: string, ...config})', async () => {
+		const db = drizzle({
+			connection: connectionString,
+			schema,
+		});
+
+		const awaitedPool = await db.$client;
+
+		await awaitedPool.query('SELECT 1;');
+
+		expect(awaitedPool).toBeInstanceOf(Pool);
+		// expect(db.query.User).not.toStrictEqual(undefined);
+	});
+
+	it('drizzle({ client })', async () => {
+		const client = await mssql.connect(connectionString);
+		const db = drizzle({ client });
+
+		await db.$client.query('SELECT 1;');
+
+		expect(db.$client).toBeInstanceOf(Pool);
+	});
+
+	it('drizzle({ client, ...config })', async () => {
+		const client = await mssql.connect(connectionString);
+		const db = drizzle({ client, schema });
+
+		await db.$client.query('SELECT 1;');
+
+		expect(db.$client).toBeInstanceOf(Pool);
+		// expect(db.query.User).not.toStrictEqual(undefined);
+	});
+});
diff --git a/integration-tests/js-tests/driver-init/commonjs/node-pg.test.cjs b/integration-tests/js-tests/driver-init/commonjs/node-pg.test.cjs
index 53338d0616..9960a11cd3 100644
--- a/integration-tests/js-tests/driver-init/commonjs/node-pg.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/node-pg.test.cjs
@@ -28,7 +28,7 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -40,7 +40,7 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -54,34 +54,20 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Pool({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
@@ -94,16 +80,16 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('node-pg:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await client.connect();
 
@@ -113,23 +99,6 @@ describe('node-pg:Client', async (it) => {
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			connectionString: process.env['PG_CONNECTION_STRING'],
@@ -145,40 +114,23 @@ describe('node-pg:Client', async (it) => {
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('node-pg:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-		client.release();
-
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const pool = new Pool({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 		client.release();
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -196,6 +148,6 @@ describe('node-pg:PoolClient', async (it) => {
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/pglite.test.cjs b/integration-tests/js-tests/driver-init/commonjs/pglite.test.cjs
index a00afb0418..4ddfd9e7b6 100644
--- a/integration-tests/js-tests/driver-init/commonjs/pglite.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/pglite.test.cjs
@@ -27,7 +27,7 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: {}, ...config})', async () => {
@@ -39,7 +39,7 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -50,29 +50,17 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Database('memory://');
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Database('memory://');
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.exec('SELECT 1;');
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Database('memory://');
 		const db = drizzle({
@@ -83,6 +71,6 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/planetscale.test.cjs b/integration-tests/js-tests/driver-init/commonjs/planetscale.test.cjs
index 0894d30c2e..ecc28aef6b 100644
--- a/integration-tests/js-tests/driver-init/commonjs/planetscale.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/planetscale.test.cjs
@@ -30,7 +30,7 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -42,7 +42,7 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -56,34 +56,20 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			url: process.env['PLANETSCALE_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			url: process.env['PLANETSCALE_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			url: process.env['PLANETSCALE_CONNECTION_STRING'],
@@ -96,6 +82,6 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/postgres-js.test.cjs b/integration-tests/js-tests/driver-init/commonjs/postgres-js.test.cjs
index da79953f3c..3c5319f826 100644
--- a/integration-tests/js-tests/driver-init/commonjs/postgres-js.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/postgres-js.test.cjs
@@ -22,7 +22,7 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -33,7 +33,7 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -46,27 +46,16 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = pg(process.env['PG_CONNECTION_STRING']);
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.unsafe('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = pg(process.env['PG_CONNECTION_STRING']);
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.unsafe('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = pg(process.env['PG_CONNECTION_STRING']);
 		const db = drizzle({
@@ -76,6 +65,6 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/schema.cjs b/integration-tests/js-tests/driver-init/commonjs/schema.cjs
index 7015a068de..6be9f0563e 100644
--- a/integration-tests/js-tests/driver-init/commonjs/schema.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/schema.cjs
@@ -1,6 +1,7 @@
 const { int: mysqlInt, mysqlTable } = require('drizzle-orm/mysql-core');
 const { integer: pgInt, pgTable } = require('drizzle-orm/pg-core');
 const { integer: sqliteInt, sqliteTable } = require('drizzle-orm/sqlite-core');
+const { int: mssqlInt, mssqlTable } = require('drizzle-orm/mssql-core');
 
 module.exports.sqlite = {
 	User: sqliteTable('test', {
@@ -19,3 +20,9 @@ module.exports.mysql = {
 		id: mysqlInt('id').primaryKey().notNull(),
 	}),
 };
+
+module.exports.pg = {
+	User: mssqlTable('test', {
+		id: pgInt('id').primaryKey(),
+	}),
+};
diff --git a/integration-tests/js-tests/driver-init/commonjs/tidb.test.cjs b/integration-tests/js-tests/driver-init/commonjs/tidb.test.cjs
index a64588b8a5..c1dce14c6f 100644
--- a/integration-tests/js-tests/driver-init/commonjs/tidb.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/tidb.test.cjs
@@ -26,7 +26,7 @@ describe('tidb', async (it) => {
 		);
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -36,7 +36,7 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -48,31 +48,19 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = connect({
 			url: process.env['TIDB_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = connect({
-			url: process.env['TIDB_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = connect({
 			url: process.env['TIDB_CONNECTION_STRING'],
@@ -83,6 +71,6 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/commonjs/vercel.test.cjs b/integration-tests/js-tests/driver-init/commonjs/vercel.test.cjs
index ad418a26ea..69fb0305ef 100644
--- a/integration-tests/js-tests/driver-init/commonjs/vercel.test.cjs
+++ b/integration-tests/js-tests/driver-init/commonjs/vercel.test.cjs
@@ -29,7 +29,7 @@ describe('vercel:sql', async (it) => {
 		expect(db.$client).toBeTypeOf('function');
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const db = drizzle(sql);
 
 		await db.$client.query('SELECT 1;');
@@ -37,17 +37,6 @@ describe('vercel:sql', async (it) => {
 		expect(db.$client).toBeTypeOf('function');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const db = drizzle(sql, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const db = drizzle({
 			client: sql,
@@ -57,7 +46,7 @@ describe('vercel:sql', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -68,36 +57,21 @@ describe('vercel:sql', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:Pool', async (it) => {
-	it('drizzle(client)', async () => {
-		const client = createPool({
-			connectionString: process.env['VERCEL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).toBeInstanceOf(Pool);
-	});
-
-	it('drizzle(client, config)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createPool({
 			connectionString: process.env['VERCEL_CONNECTION_STRING'],
 		});
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -113,16 +87,16 @@ describe('vercel:Pool', async (it) => {
 
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createClient({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await client.connect();
 
@@ -133,24 +107,6 @@ describe('vercel:Client', async (it) => {
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createClient({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createClient({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -167,36 +123,18 @@ describe('vercel:Client', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = createPool({
 			connectionString: process.env['VERCEL_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
 
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-		client.release();
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const pool = createPool({
-			connectionString: process.env['VERCEL_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 		client.release();
@@ -204,7 +142,6 @@ describe('vercel:PoolClient', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -224,6 +161,6 @@ describe('vercel:PoolClient', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/better-sqlite3.test.mjs b/integration-tests/js-tests/driver-init/module/better-sqlite3.test.mjs
index 063eb958fb..8e95d0d3e2 100644
--- a/integration-tests/js-tests/driver-init/module/better-sqlite3.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/better-sqlite3.test.mjs
@@ -30,7 +30,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -43,7 +43,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -58,7 +58,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: {}, ...config})', async () => {
@@ -71,7 +71,7 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -83,31 +83,18 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Database(':memory:');
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.exec('SELECT 1;');
 
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Database(':memory:');
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.exec('SELECT 1;');
-
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Database(':memory:');
 		const db = drizzle({
@@ -119,6 +106,6 @@ describe('better-sqlite3', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/libsql.test.mjs b/integration-tests/js-tests/driver-init/module/libsql.test.mjs
index 816d0eb0e8..e0b5a8b5a1 100644
--- a/integration-tests/js-tests/driver-init/module/libsql.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/libsql.test.mjs
@@ -22,7 +22,7 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -35,7 +35,7 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -50,35 +50,20 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createClient({
 			url: ':memory:',
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createClient({
-			url: ':memory:',
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createClient({
 			url: ':memory:',
@@ -92,6 +77,6 @@ describe('libsql', async (it) => {
 
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/mysql2.test.mjs b/integration-tests/js-tests/driver-init/module/mysql2.test.mjs
index 1a1565c675..b6c321da51 100644
--- a/integration-tests/js-tests/driver-init/module/mysql2.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/mysql2.test.mjs
@@ -24,12 +24,11 @@ describe('mysql2', async (it) => {
 			process.env['MYSQL_CONNECTION_STRING'],
 			{
 				schema,
-				mode: 'default',
 			},
 		);
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
@@ -37,12 +36,11 @@ describe('mysql2', async (it) => {
 		const db = drizzle({
 			connection: process.env['MYSQL_CONNECTION_STRING'],
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
@@ -52,42 +50,26 @@ describe('mysql2', async (it) => {
 				uri: process.env['MYSQL_CONNECTION_STRING'],
 			},
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createPool({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createPool({
-			uri: process.env['MYSQL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-			mode: 'default',
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client.getConnection).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createPool({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
@@ -96,41 +78,25 @@ describe('mysql2', async (it) => {
 		const db = drizzle({
 			client,
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).not.toStrictEqual(undefined);
 	});
 });
 
 describe('mysql2:connection', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createConnection({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.$client.getConnection).toStrictEqual(undefined);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const client = createConnection({
-			uri: process.env['MYSQL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-			mode: 'default',
-		});
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).toStrictEqual(undefined);
 	});
 
@@ -142,12 +108,11 @@ describe('mysql2:connection', async (it) => {
 		const db = drizzle({
 			client,
 			schema,
-			mode: 'default',
 		});
 
 		await db.$client.execute('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client.getConnection).toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/neon-http.test.mjs b/integration-tests/js-tests/driver-init/module/neon-http.test.mjs
index b9c07f4d91..36c899a673 100644
--- a/integration-tests/js-tests/driver-init/module/neon-http.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/neon-http.test.mjs
@@ -27,7 +27,7 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -38,7 +38,7 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -51,31 +51,18 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = pg(
 			process.env['NEON_CONNECTION_STRING'],
 		);
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = pg(
-			process.env['NEON_CONNECTION_STRING'],
-		);
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = pg(
 			process.env['NEON_CONNECTION_STRING'],
@@ -87,6 +74,6 @@ describe('neon-http', async (it) => {
 
 		await db.$client('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/neon-ws.test.mjs b/integration-tests/js-tests/driver-init/module/neon-ws.test.mjs
index 5a045b76a5..d2faeb9593 100644
--- a/integration-tests/js-tests/driver-init/module/neon-ws.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/neon-ws.test.mjs
@@ -30,7 +30,7 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
@@ -42,7 +42,7 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
@@ -56,35 +56,21 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Pool({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client).toBeInstanceOf(Pool);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -96,20 +82,20 @@ describe('neon-ws', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 });
 
 describe('neon-ws:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
 
 		await client.connect();
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
@@ -117,23 +103,6 @@ describe('neon-ws:Client', async (it) => {
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.$client).not.toBeInstanceOf(Pool);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -147,44 +116,25 @@ describe('neon-ws:Client', async (it) => {
 
 		await db.$client.query('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
 });
 
 describe('neon-ws:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
-		const pool = new Pool({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-
-		client.release();
-
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.$client).not.toBeInstanceOf(Pool);
-	});
-
-	it('drizzle(client, config)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = new Pool({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
 
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		client.release();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
@@ -204,7 +154,7 @@ describe('neon-ws:PoolClient', async (it) => {
 
 		client.release();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 		expect(db.$client).toBeInstanceOf(Client);
 		expect(db.$client).not.toBeInstanceOf(Pool);
 	});
diff --git a/integration-tests/js-tests/driver-init/module/node-mssql.test.mjs b/integration-tests/js-tests/driver-init/module/node-mssql.test.mjs
new file mode 100644
index 0000000000..5dbaccd150
--- /dev/null
+++ b/integration-tests/js-tests/driver-init/module/node-mssql.test.mjs
@@ -0,0 +1,62 @@
+import 'dotenv/config';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import { ConnectionPool as Pool } from 'mssql';
+import { expect } from 'vitest';
+import { test } from '../../../tests/mssql/instrumentation';
+import * as schema from './schema.mjs';
+
+test('mssql:drizzle(string)', async ({ url2 }) => {
+	const db = drizzle(url2);
+
+	const awaitedPool = await db.$client;
+
+	await awaitedPool.query('SELECT 1;');
+
+	expect(awaitedPool).toBeInstanceOf(Pool);
+});
+
+test('mssql:drizzle(string, config)', async ({ url2 }) => {
+	const db = drizzle(url2, {
+		schema,
+	});
+
+	const awaitedPool = await db.$client;
+
+	await awaitedPool.query('SELECT 1;');
+
+	expect(awaitedPool).toBeInstanceOf(Pool);
+	// expect(db.query.User).not.toStrictEqual(undefined);
+});
+
+test('mssql:drizzle({connection: string, ...config})', async ({ url2 }) => {
+	const db = drizzle({
+		connection: url2,
+		schema,
+	});
+
+	const awaitedPool = await db.$client;
+
+	await awaitedPool.query('SELECT 1;');
+
+	expect(awaitedPool).toBeInstanceOf(Pool);
+	// expect(db.query.User).not.toStrictEqual(undefined);
+});
+
+test('mssql:drizzle(client)', async ({ url, client }) => {
+	const db = drizzle(client);
+
+	await db.$client.query('SELECT 1;');
+
+	expect(db.$client).toBeInstanceOf(Pool);
+});
+
+test('mssql:drizzle(client, config)', async ({ url, client }) => {
+	const db = drizzle(client, {
+		schema,
+	});
+
+	await db.$client.query('SELECT 1;');
+
+	expect(db.$client).toBeInstanceOf(Pool);
+	// expect(db.query.User).not.toStrictEqual(undefined);
+});
diff --git a/integration-tests/js-tests/driver-init/module/node-pg.test.mjs b/integration-tests/js-tests/driver-init/module/node-pg.test.mjs
index 75dd391f11..54b27739c7 100644
--- a/integration-tests/js-tests/driver-init/module/node-pg.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/node-pg.test.mjs
@@ -28,7 +28,7 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -40,7 +40,7 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -54,34 +54,20 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Pool({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
@@ -94,16 +80,16 @@ describe('node-pg', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('node-pg:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await client.connect();
 
@@ -113,23 +99,6 @@ describe('node-pg:Client', async (it) => {
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			connectionString: process.env['PG_CONNECTION_STRING'],
@@ -145,40 +114,23 @@ describe('node-pg:Client', async (it) => {
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('node-pg:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = new Pool({
 			connectionString: process.env['PG_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-		client.release();
-
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const pool = new Pool({
-			connectionString: process.env['PG_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 		client.release();
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -196,6 +148,6 @@ describe('node-pg:PoolClient', async (it) => {
 
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/pglite.test.mjs b/integration-tests/js-tests/driver-init/module/pglite.test.mjs
index bb67f383b1..4e4b12deab 100644
--- a/integration-tests/js-tests/driver-init/module/pglite.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/pglite.test.mjs
@@ -27,7 +27,7 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: {}, ...config})', async () => {
@@ -39,7 +39,7 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -50,29 +50,17 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Database('memory://');
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Database('memory://');
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.exec('SELECT 1;');
-		await db.$client.close();
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Database('memory://');
 		const db = drizzle({
@@ -83,6 +71,6 @@ describe('pglite', async (it) => {
 		await db.$client.exec('SELECT 1;');
 		await db.$client.close();
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/planetscale.test.mjs b/integration-tests/js-tests/driver-init/module/planetscale.test.mjs
index 0a68b7e9fc..142b8aadd4 100644
--- a/integration-tests/js-tests/driver-init/module/planetscale.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/planetscale.test.mjs
@@ -30,7 +30,7 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -42,7 +42,7 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -56,34 +56,20 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = new Client({
 			url: process.env['PLANETSCALE_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = new Client({
-			url: process.env['PLANETSCALE_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = new Client({
 			url: process.env['PLANETSCALE_CONNECTION_STRING'],
@@ -96,6 +82,6 @@ describe('planetscale', async (it) => {
 		await db.$client.execute('SELECT 1;');
 
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/postgres-js.test.mjs b/integration-tests/js-tests/driver-init/module/postgres-js.test.mjs
index 40925aceb7..305f9069f5 100644
--- a/integration-tests/js-tests/driver-init/module/postgres-js.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/postgres-js.test.mjs
@@ -22,7 +22,7 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -33,7 +33,7 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -46,27 +46,16 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = pg(process.env['PG_CONNECTION_STRING']);
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.unsafe('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = pg(process.env['PG_CONNECTION_STRING']);
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.unsafe('SELECT 1;');
-
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = pg(process.env['PG_CONNECTION_STRING']);
 		const db = drizzle({
@@ -76,6 +65,6 @@ describe('postgres-js', async (it) => {
 
 		await db.$client.unsafe('SELECT 1;');
 
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/tidb.test.mjs b/integration-tests/js-tests/driver-init/module/tidb.test.mjs
index 0cd62f00a3..9ea64b210a 100644
--- a/integration-tests/js-tests/driver-init/module/tidb.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/tidb.test.mjs
@@ -26,7 +26,7 @@ describe('tidb', async (it) => {
 		);
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: string, ...config})', async () => {
@@ -36,7 +36,7 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({connection: params, ...config})', async () => {
@@ -48,31 +48,19 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = connect({
 			url: process.env['TIDB_CONNECTION_STRING'],
 		});
 
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await db.$client.execute('SELECT 1;');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = connect({
-			url: process.env['TIDB_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = connect({
 			url: process.env['TIDB_CONNECTION_STRING'],
@@ -83,6 +71,6 @@ describe('tidb', async (it) => {
 		});
 
 		await db.$client.execute('SELECT 1;');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/js-tests/driver-init/module/vercel.test.mjs b/integration-tests/js-tests/driver-init/module/vercel.test.mjs
index 0ef7c460e3..cc7fe45761 100644
--- a/integration-tests/js-tests/driver-init/module/vercel.test.mjs
+++ b/integration-tests/js-tests/driver-init/module/vercel.test.mjs
@@ -29,7 +29,7 @@ describe('vercel:sql', async (it) => {
 		expect(db.$client).toBeTypeOf('function');
 	});
 
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const db = drizzle(sql);
 
 		await db.$client.query('SELECT 1;');
@@ -37,17 +37,6 @@ describe('vercel:sql', async (it) => {
 		expect(db.$client).toBeTypeOf('function');
 	});
 
-	it('drizzle(client, config)', async () => {
-		const db = drizzle(sql, {
-			schema,
-		});
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const db = drizzle({
 			client: sql,
@@ -57,7 +46,7 @@ describe('vercel:sql', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({...config})', async () => {
@@ -68,36 +57,21 @@ describe('vercel:sql', async (it) => {
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).toBeTypeOf('function');
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:Pool', async (it) => {
-	it('drizzle(client)', async () => {
-		const client = createPool({
-			connectionString: process.env['VERCEL_CONNECTION_STRING'],
-		});
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).toBeInstanceOf(Pool);
-	});
-
-	it('drizzle(client, config)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createPool({
 			connectionString: process.env['VERCEL_CONNECTION_STRING'],
 		});
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -113,16 +87,16 @@ describe('vercel:Pool', async (it) => {
 
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).toBeInstanceOf(Pool);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:Client', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const client = createClient({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
 		});
-		const db = drizzle(client);
+		const db = drizzle({ client });
 
 		await client.connect();
 
@@ -133,24 +107,6 @@ describe('vercel:Client', async (it) => {
 		expect(db.$client).toBeInstanceOf(Client);
 	});
 
-	it('drizzle(client, config)', async () => {
-		const client = createClient({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
-		});
-		const db = drizzle(client, {
-			schema,
-		});
-
-		await client.connect();
-
-		await db.$client.query('SELECT 1;');
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
-	});
-
 	it('drizzle({client, ...config})', async () => {
 		const client = createClient({
 			connectionString: process.env['NEON_CONNECTION_STRING'],
@@ -167,36 +123,18 @@ describe('vercel:Client', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
 
 describe('vercel:PoolClient', async (it) => {
-	it('drizzle(client)', async () => {
+	it('drizzle({ client })', async () => {
 		const pool = createPool({
 			connectionString: process.env['VERCEL_CONNECTION_STRING'],
 		});
 		const client = await pool.connect();
 
-		const db = drizzle(client);
-
-		await db.$client.query('SELECT 1;');
-		client.release();
-
-		expect(db.$client).not.toBeTypeOf('function');
-		expect(db.$client).not.toBeInstanceOf(Pool);
-		expect(db.$client).toBeInstanceOf(Client);
-	});
-
-	it('drizzle(client, config)', async () => {
-		const pool = createPool({
-			connectionString: process.env['VERCEL_CONNECTION_STRING'],
-		});
-		const client = await pool.connect();
-
-		const db = drizzle(client, {
-			schema,
-		});
+		const db = drizzle({ client });
 
 		await db.$client.query('SELECT 1;');
 		client.release();
@@ -204,7 +142,6 @@ describe('vercel:PoolClient', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
 	});
 
 	it('drizzle({client, ...config})', async () => {
@@ -224,6 +161,6 @@ describe('vercel:PoolClient', async (it) => {
 		expect(db.$client).not.toBeTypeOf('function');
 		expect(db.$client).not.toBeInstanceOf(Pool);
 		expect(db.$client).toBeInstanceOf(Client);
-		expect(db.query.User).not.toStrictEqual(undefined);
+		expect(db._query.User).not.toStrictEqual(undefined);
 	});
 });
diff --git a/integration-tests/package.json b/integration-tests/package.json
index 151a8429f8..f704c3de93 100644
--- a/integration-tests/package.json
+++ b/integration-tests/package.json
@@ -4,11 +4,18 @@
 	"description": "",
 	"type": "module",
 	"scripts": {
-		"test:types": "tsc",
+		"test:types": "tsc && cd type-tests/join-nodenext && tsc && cd ../../type-tests-no-strict-null-checks && tsc",
 		"test": "pnpm test:vitest",
-		"test:vitest": "vitest run --pass-with-no-tests",
+		"test:vitest": "vitest run --printConsoleTrace=true --silent=false --pass-with-no-tests",
 		"test:esm": "node tests/imports.test.mjs && node tests/imports.test.cjs",
-		"test:data-api": "sst shell vitest run tests/pg/awsdatapi.test.ts"
+		"test:data-api": "sst shell vitest run tests/pg/awsdatapi.test.ts",
+		"test:postgres": "vitest --reporter=verbose --silent=false run tests/pg/",
+		"test:mysql": "vitest run --reporter=verbose --silent=false run tests/mysql/default tests/relational/mysql.test.ts tests/relational/mysql-v1.test.ts",
+		"test:sqlite": "vitest run --reporter=verbose --silent=false run tests/sqlite --exclude tests/sqlite/tursodatabase-serverless.test.ts",
+		"test:planetscale": "vitest run --reporter=verbose --silent=false run tests/mysql/planetscale.test.ts tests/relational/mysql.planetscale",
+		"test:other": "vitest run tests/utils tests/extensions",
+		"test:seeder": "vitest run tests/seeder",
+		"test:imports": "vitest run tests/imports"
 	},
 	"keywords": [],
 	"author": "Drizzle Team",
@@ -23,17 +30,18 @@
 		"@types/async-retry": "^1.4.8",
 		"@types/better-sqlite3": "^7.6.4",
 		"@types/dockerode": "^3.3.18",
-		"@types/node": "^20.2.5",
+		"@types/mssql": "^9.1.4",
+		"@types/node": "^25.4.0",
 		"@types/pg": "^8.10.1",
 		"@types/sql.js": "^1.4.4",
 		"@types/uuid": "^9.0.1",
 		"@types/ws": "^8.5.10",
 		"@upstash/redis": "^1.34.3",
-		"@vitest/ui": "^1.6.0",
 		"ava": "^5.3.0",
+		"bun-types": "^1.2.23",
 		"cross-env": "^7.0.3",
-		"keyv": "^5.2.3",
 		"import-in-the-middle": "^1.13.1",
+		"keyv": "^5.2.3",
 		"ts-node": "^10.9.2",
 		"tsx": "^4.14.0",
 		"vite-tsconfig-paths": "^4.3.2",
@@ -42,27 +50,49 @@
 	"dependencies": {
 		"@aws-sdk/client-rds-data": "^3.549.0",
 		"@aws-sdk/credential-providers": "^3.549.0",
-		"@electric-sql/pglite": "0.2.12",
-		"@libsql/client": "^0.10.0",
+		"@effect/sql-d1": "4.0.0-beta.83",
+		"@effect/sql-libsql": "4.0.0-beta.83",
+		"@effect/sql-mysql2": "4.0.0-beta.83",
+		"@effect/sql-pg": "4.0.0-beta.83",
+		"@effect/sql-pglite": "4.0.0-beta.83",
+		"@effect/sql-sqlite-bun": "4.0.0-beta.83",
+		"@effect/sql-sqlite-do": "4.0.0-beta.83",
+		"@effect/sql-sqlite-node": "4.0.0-beta.83",
+		"@effect/sql-sqlite-wasm": "4.0.0-beta.83",
+		"@effect/vitest": "4.0.0-beta.58",
+		"@electric-sql/pglite": "0.4.6",
+		"@electric-sql/pglite-postgis": "^0.0.8",
 		"@miniflare/d1": "^2.14.4",
 		"@miniflare/shared": "^2.14.4",
 		"@planetscale/database": "^1.16.0",
 		"@prisma/client": "5.14.0",
+		"@sinclair/typebox": "^0.34.48",
+		"@sqlitecloud/drivers": "^1.0.653",
 		"@tidbcloud/serverless": "^0.1.1",
+		"@tursodatabase/database": "0.6.0-pre.28",
+		"@tursodatabase/database-wasm": "0.6.0-pre.28",
+		"@tursodatabase/serverless": "1.2.0-pre.1",
+		"@tursodatabase/sync": "0.6.0",
+		"@types/chai": "^5.2.2",
 		"@typescript/analyze-trace": "^0.10.0",
 		"@vercel/postgres": "^0.8.0",
 		"@xata.io/client": "^0.29.3",
+		"arktype": "^2.1.10",
 		"async-retry": "^1.3.3",
 		"better-sqlite3": "11.9.1",
+		"chai": "^5.2.1",
 		"dockerode": "^4.0.6",
 		"dotenv": "^16.1.4",
+		"drizzle-kit": "workspace:../drizzle-kit/dist",
 		"drizzle-prisma-generator": "^0.1.2",
 		"drizzle-seed": "workspace:../drizzle-seed/dist",
 		"drizzle-typebox": "workspace:../drizzle-typebox/dist",
 		"drizzle-valibot": "workspace:../drizzle-valibot/dist",
 		"drizzle-zod": "workspace:../drizzle-zod/dist",
-		"gel": "^2.0.0",
+		"effect": "4.0.0-beta.83",
 		"get-port": "^7.0.0",
+		"json-rules-engine": "^7.3.1",
+		"mssql": "^11.0.1",
 		"mysql2": "^3.14.1",
 		"pg": "^8.11.0",
 		"postgres": "^3.3.5",
@@ -71,9 +101,10 @@
 		"sql.js": "^1.8.0",
 		"sqlite3": "^5.1.4",
 		"sst": "^3.14.24",
+		"typebox": "^1.0.80",
 		"uuid": "^9.0.0",
 		"uvu": "^0.5.6",
-		"vitest": "^3.1.3",
+		"valibot": "1.0.0-beta.7",
 		"ws": "^8.18.2",
 		"zod": "^3.20.2"
 	}
diff --git a/integration-tests/tests/awsdatapi.alltypes.test.ts b/integration-tests/tests/awsdatapi.alltypes.test.ts
index 16c49c05f9..94bc75aab6 100644
--- a/integration-tests/tests/awsdatapi.alltypes.test.ts
+++ b/integration-tests/tests/awsdatapi.alltypes.test.ts
@@ -6,7 +6,7 @@
 // import type { TestFn } from 'ava';
 // import anyTest from 'ava';
 // import * as dotenv from 'dotenv';
-// import { name, sql } from 'drizzle-orm';
+// import { name, sql  , type BuildRelations } from 'drizzle-orm';
 // import type { AwsDataApiPgDatabase } from 'drizzle-orm/aws-data-api/pg';
 // import { drizzle } from 'drizzle-orm/aws-data-api/pg';
 // import {
diff --git a/integration-tests/tests/bun/bun-mysql.test.ts b/integration-tests/tests/bun/bun-mysql.test.ts
new file mode 100644
index 0000000000..738d34dfa1
--- /dev/null
+++ b/integration-tests/tests/bun/bun-mysql.test.ts
@@ -0,0 +1,9962 @@
+/// <reference types="bun-types" />
+
+import retry from 'async-retry';
+import { SQL } from 'bun';
+import { afterAll, beforeAll, beforeEach, describe, expect, expectTypeOf, spyOn, test } from 'bun:test';
+import {
+	and,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	defineRelations,
+	eq,
+	exists,
+	getColumns,
+	getTableColumns,
+	getTableName,
+	gt,
+	gte,
+	inArray,
+	is,
+	like,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	max,
+	min,
+	Name,
+	not,
+	notInArray,
+	sql,
+	sum,
+	sumDistinct,
+	Table,
+	TransactionRollbackError,
+} from 'drizzle-orm';
+import { migrate } from 'drizzle-orm/bun-sql/migrator';
+import { drizzle } from 'drizzle-orm/bun-sql/mysql';
+import type { BunMySqlDatabase } from 'drizzle-orm/bun-sql/mysql';
+import type { MutationOption } from 'drizzle-orm/cache/core';
+import { Cache } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import {
+	alias,
+	bigint,
+	binary,
+	boolean,
+	char,
+	customType,
+	date,
+	datetime,
+	decimal,
+	double,
+	except,
+	exceptAll,
+	float,
+	foreignKey,
+	getTableConfig,
+	getViewConfig,
+	index,
+	int,
+	intersect,
+	intersectAll,
+	json,
+	mediumint,
+	type MySqlAsyncDatabase,
+	MySqlAsyncSession,
+	MySqlDialect,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	mysqlTableCreator,
+	MySqlView,
+	mysqlView,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	union,
+	unionAll,
+	unique,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import Keyv from 'keyv';
+import { v4 as uuid } from 'uuid';
+import { allTypesCodecsTable } from '~/mysql/schema2';
+import { normalizeDataWithDbCodecs } from '~/mysql/utils';
+import { type Equal, Expect, toLocalDate } from '~/utils';
+
+export const rqbUser = mysqlTable('user_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
+
+export const rqbPost = mysqlTable('post_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	userId: bigint('user_id', {
+		mode: 'number',
+	}).notNull(),
+	content: text(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
+
+export const relations = defineRelations({ rqbUser, rqbPost }, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
+
+const allTypesTable = mysqlTable('all_types', {
+	serial: serial('serial'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	binary: binary('binary'),
+	boolean: boolean('boolean'),
+	char: char('char'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	datetime: datetime('datetime', {
+		mode: 'date',
+	}),
+	datetimeStr: datetime('datetime_str', {
+		mode: 'string',
+	}),
+	decimal: decimal('decimal'),
+	decimalNum: decimal('decimal_num', {
+		scale: 30,
+		mode: 'number',
+	}),
+	decimalBig: decimal('decimal_big', {
+		scale: 30,
+		mode: 'bigint',
+	}),
+	double: double('double'),
+	float: float('float'),
+	int: int('int'),
+	json: json('json'),
+	medInt: mediumint('med_int'),
+	smallInt: smallint('small_int'),
+	real: real('real'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	tinyInt: tinyint('tiny_int'),
+	varbin: varbinary('varbin', {
+		length: 16,
+	}),
+	varchar: varchar('varchar', {
+		length: 255,
+	}),
+	year: year('year'),
+	enum: mysqlEnum('enum', ['enV1', 'enV2']),
+});
+
+const usersTable = mysqlTable('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+});
+
+const users2Table = mysqlTable('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: bigint('city_id', { unsigned: true, mode: 'number' }).references(() => citiesTable.id),
+});
+
+const citiesTable = mysqlTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const usersOnUpdate = mysqlTable('users_on_update', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	updateCounter: int('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: datetime('updated_at', { mode: 'date', fsp: 3 }).$onUpdate(() => new Date()),
+	uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper(name)`),
+	alwaysNull: text('always_null').$type<string | null>().$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
+});
+
+const datesTable = mysqlTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time', { fsp: 1 }),
+	datetime: datetime('datetime', { fsp: 2 }),
+	datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
+	timestamp: timestamp('timestamp', { fsp: 3 }),
+	timestampAsString: timestamp('timestamp_as_string', { fsp: 3, mode: 'string' }),
+	year: year('year'),
+});
+
+const coursesTable = mysqlTable('courses', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: bigint('category_id', { unsigned: true, mode: 'number' }).references(() => courseCategoriesTable.id),
+});
+
+const courseCategoriesTable = mysqlTable('course_categories', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const orders = mysqlTable('orders', {
+	id: serial('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+const usersMigratorTable = mysqlTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => {
+	return {
+		name: uniqueIndex('').on(table.name).using('btree'),
+	};
+});
+
+// To test aggregate functions
+const aggregateTable = mysqlTable('aggregate_table', {
+	id: serial('id').notNull(),
+	name: text('name').notNull(),
+	a: int('a'),
+	b: int('b'),
+	c: int('c'),
+	nullOnly: int('null_only'),
+});
+
+// To test another schema and multischema
+const mySchema = mysqlSchema(`mySchema`);
+
+const usersMySchemaTable = mySchema.table('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+});
+
+const users2MySchemaTable = mySchema.table('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id').references(() => citiesTable.id),
+});
+
+const citiesMySchemaTable = mySchema.table('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const ENABLE_LOGGING = false;
+
+let db: BunMySqlDatabase<typeof relations> & { $client: SQL };
+let dbGlobalCached: BunMySqlDatabase & { $client: SQL };
+let cachedDb: BunMySqlDatabase & { $client: SQL };
+let client: SQL;
+
+beforeAll(async () => {
+	const connectionString = process.env['MYSQL_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mysql` and export the connection string before running tests.',
+		);
+	}
+	client = await retry(async () => {
+		client = await new SQL({
+			url: connectionString,
+			adapter: 'mysql',
+			bigint: true,
+		}).connect();
+		return client;
+	}, {
+		retries: 20,
+		factor: 1,
+		minTimeout: 250,
+		maxTimeout: 250,
+		randomize: false,
+		onRetry() {
+			client?.end();
+		},
+	});
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations });
+	cachedDb = drizzle({ client, logger: ENABLE_LOGGING, cache: new TestCache() });
+	dbGlobalCached = drizzle({ client, logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
+});
+
+afterAll(async () => {
+	await client?.end();
+	await cachedDb?.$client.end();
+	await dbGlobalCached?.$client.end();
+});
+
+// bun can't import drizzle-kit's diff helper, so create the schema entities directly from their
+// drizzle definitions instead of relying on the shared `push`. Only the column shapes used by the
+// carried-over mapper / codec tests are needed (column-level PK / NOT NULL / AUTO_INCREMENT, plus
+// `.as(...)` views); FKs are intentionally omitted since the tests rely on RQB relations, not DB FKs.
+const push = async (schema: Record<string, any>) => {
+	// Disable FK checks so a referenced table can be dropped/recreated even if leftover tables from a
+	// previous run still carry FK constraints against it.
+	await db.execute(sql.raw('set foreign_key_checks = 0'));
+	for (const entity of Object.values(schema)) {
+		if (is(entity, MySqlView)) {
+			const { name, query } = getViewConfig(entity);
+			await db.execute(sql.raw(`drop view if exists \`${name}\``));
+			await db.execute(sql`create view ${sql.identifier(name)} as ${query!}`);
+			continue;
+		}
+
+		const { name, columns } = getTableConfig(entity);
+		const cols = columns.map((c) => {
+			let def = `\`${c.name}\` ${c.getSQLType()}`;
+			if (c.notNull) def += ' not null';
+			if ((c as any).autoIncrement) def += ' auto_increment';
+			if (c.primary) def += ' primary key';
+			return def;
+		});
+		await db.execute(sql.raw(`drop table if exists \`${name}\``));
+		await db.execute(sql.raw(`create table \`${name}\` (${cols.join(', ')})`));
+	}
+	await db.execute(sql.raw('set foreign_key_checks = 1'));
+};
+
+const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+describe('common', () => {
+	beforeEach(async () => {
+		await db.execute(sql`drop table if exists ${rqbUser} CASCADE;`);
+		await db.execute(sql`drop table if exists ${rqbPost} CASCADE;`);
+		await db.execute(sql`drop table if exists userstest`);
+		await db.execute(sql`drop table if exists users2`);
+		await db.execute(sql`drop table if exists cities`);
+		await db.execute(sql`drop table if exists \`all_types\``);
+		await db.execute(sql`drop schema if exists \`mySchema\``);
+		await db.execute(sql`create schema if not exists \`mySchema\``);
+
+		await db.execute(
+			sql`
+				create table userstest (
+					id serial primary key,
+					name text not null,
+					verified boolean not null default false,
+					jsonb json,
+					created_at timestamp not null default now()
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table cities (
+					id serial primary key,
+					name text not null
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table users2 (
+					id serial primary key,
+					name text not null,
+					city_id bigint unsigned references cities(id)
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table \`mySchema\`.\`userstest\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`verified\` boolean not null default false,
+					\`jsonb\` json,
+					\`created_at\` timestamp not null default now()
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table \`mySchema\`.\`cities\` (
+					\`id\` serial primary key,
+					\`name\` text not null
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table \`mySchema\`.\`users2\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`city_id\` bigint unsigned references \`mySchema\`.\`cities\`(\`id\`)
+				)
+			`,
+		);
+
+		await db.execute(sql`
+			CREATE TABLE ${rqbUser} (
+					\`id\` SERIAL PRIMARY KEY NOT NULL,
+					\`name\` TEXT NOT NULL,
+					\`created_at\` TIMESTAMP NOT NULL
+				 )
+		`);
+		await db.execute(sql`
+			CREATE TABLE ${rqbPost} ( 
+					\`id\` SERIAL PRIMARY KEY NOT NULL,
+					\`user_id\` BIGINT(20) UNSIGNED NOT NULL,
+					\`content\` TEXT,
+					\`created_at\` TIMESTAMP NOT NULL
+			)
+		`);
+	});
+
+	async function setupReturningFunctionsTest(db: MySqlAsyncDatabase<any, any>) {
+		await db.execute(sql`drop table if exists \`users_default_fn\``);
+		await db.execute(
+			sql`
+				create table \`users_default_fn\` (
+					\`id\` varchar(256) primary key,
+					\`name\` text not null
+				);
+			`,
+		);
+	}
+
+	async function setupSetOperationTest(db: MySqlAsyncDatabase<any, any>) {
+		await db.execute(sql`drop table if exists \`users2\``);
+		await db.execute(sql`drop table if exists \`cities\``);
+
+		await db.execute(
+			sql`
+				create table \`cities\` (
+					\`id\` serial primary key,
+					\`name\` text not null
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table \`users2\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`city_id\` bigint unsigned references \`cities\`(\`id\`)
+				)
+			`,
+		);
+
+		await db.insert(citiesTable).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await db.insert(users2Table).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+	}
+
+	async function setupAggregateFunctionsTest(db: MySqlAsyncDatabase<any, any>) {
+		await db.execute(sql`drop table if exists \`aggregate_table\``);
+		await db.execute(
+			sql`
+				create table \`aggregate_table\` (
+					\`id\` integer primary key auto_increment not null,
+					\`name\` text not null,
+					\`a\` integer,
+					\`b\` integer,
+					\`c\` integer,
+					\`null_only\` integer
+				);
+			`,
+		);
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+	}
+
+	test('table config: unsigned ints', async () => {
+		const unsignedInts = mysqlTable('cities1', {
+			bigint: bigint('bigint', { mode: 'number', unsigned: true }),
+			int: int('int', { unsigned: true }),
+			smallint: smallint('smallint', { unsigned: true }),
+			mediumint: mediumint('mediumint', { unsigned: true }),
+			tinyint: tinyint('tinyint', { unsigned: true }),
+		});
+
+		const tableConfig = getTableConfig(unsignedInts);
+
+		const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+		const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+		const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+		const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+		const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+		expect(bigintColumn.getSQLType()).toStrictEqual('bigint unsigned');
+		expect(intColumn.getSQLType()).toStrictEqual('int unsigned');
+		expect(smallintColumn.getSQLType()).toStrictEqual('smallint unsigned');
+		expect(mediumintColumn.getSQLType()).toStrictEqual('mediumint unsigned');
+		expect(tinyintColumn.getSQLType()).toStrictEqual('tinyint unsigned');
+	});
+
+	test('table config: signed ints', async () => {
+		const unsignedInts = mysqlTable('cities1', {
+			bigint: bigint('bigint', { mode: 'number' }),
+			int: int('int'),
+			smallint: smallint('smallint'),
+			mediumint: mediumint('mediumint'),
+			tinyint: tinyint('tinyint'),
+		});
+
+		const tableConfig = getTableConfig(unsignedInts);
+
+		const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+		const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+		const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+		const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+		const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+		expect(bigintColumn.getSQLType()).toStrictEqual('bigint');
+		expect(intColumn.getSQLType()).toStrictEqual('int');
+		expect(smallintColumn.getSQLType()).toStrictEqual('smallint');
+		expect(mediumintColumn.getSQLType()).toStrictEqual('mediumint');
+		expect(tinyintColumn.getSQLType()).toStrictEqual('tinyint');
+	});
+
+	test('table config: foreign keys name', async () => {
+		const table = mysqlTable('cities', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		}, (t) => ({
+			f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
+		}));
+
+		const tableConfig = getTableConfig(table);
+
+		expect(tableConfig.foreignKeys).toHaveLength(1);
+		expect(tableConfig.foreignKeys[0]!.getName()).toStrictEqual('custom_fk');
+	});
+
+	test('table configs: unique third param', async () => {
+		const cities1Table = mysqlTable('cities1', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		}, (t) => ({
+			f: unique('custom_name').on(t.name, t.state),
+			f1: unique('custom_name1').on(t.name, t.state),
+		}));
+
+		const tableConfig = getTableConfig(cities1Table);
+
+		expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+		expect(tableConfig.uniqueConstraints[0]?.name).toStrictEqual('custom_name');
+		expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toStrictEqual(['name', 'state']);
+
+		expect(tableConfig.uniqueConstraints[1]?.name).toStrictEqual('custom_name1');
+		expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toStrictEqual(['name', 'state']);
+	});
+
+	test('table configs: unique in column', async () => {
+		const cities1Table = mysqlTable('cities1', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull().unique(),
+			state: text('state').unique('custom'),
+			field: text('field').unique('custom_field'),
+		});
+
+		const tableConfig = getTableConfig(cities1Table);
+
+		const columnName = tableConfig.columns.find((it) => it.name === 'name');
+		expect(columnName?.uniqueName).toStrictEqual(undefined);
+		expect(columnName?.isUnique).toBeTruthy();
+
+		const columnState = tableConfig.columns.find((it) => it.name === 'state');
+		expect(columnState?.uniqueName).toStrictEqual('custom');
+		expect(columnState?.isUnique).toBeTruthy();
+
+		const columnField = tableConfig.columns.find((it) => it.name === 'field');
+		expect(columnField?.uniqueName).toStrictEqual('custom_field');
+		expect(columnField?.isUnique).toBeTruthy();
+	});
+
+	test('select all fields', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const result = await db.select().from(usersTable);
+
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		// not timezone based timestamp, thats why it should not work here
+		// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('select sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db.select({
+			name: sql`upper(${usersTable.name})`,
+		}).from(usersTable);
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('select typed sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db.select({
+			name: sql<string>`upper(${usersTable.name})`,
+		}).from(usersTable);
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('select with empty array in inArray', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		const result = await db
+			.select({
+				name: sql`upper(${usersTable.name})`,
+			})
+			.from(usersTable)
+			.where(inArray(usersTable.id, []));
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test('select with empty array in notInArray', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		const result = await db
+			.select({
+				name: sql`upper(${usersTable.name})`,
+			})
+			.from(usersTable)
+			.where(notInArray(usersTable.id, []));
+
+		expect(result).toStrictEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+	});
+
+	test('select distinct', async () => {
+		const usersDistinctTable = mysqlTable('users_distinct', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+		await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
+
+		await db.insert(usersDistinctTable).values([
+			{ id: 1, name: 'John' },
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'John' },
+			{ id: 1, name: 'Jane' },
+		]);
+		const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+			usersDistinctTable.id,
+			usersDistinctTable.name,
+		);
+
+		await db.execute(sql`drop table ${usersDistinctTable}`);
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+	});
+
+	test('insert returning sql', async () => {
+		const result = await db.insert(usersTable).values({ name: 'John' });
+
+		expect(result['lastInsertRowid']).toStrictEqual(1);
+	});
+
+	test('delete returning sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+		expect(users['affectedRows']).toStrictEqual(1);
+	});
+
+	test('update returning sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+		expect(users['affectedRows']).toStrictEqual(1);
+	});
+
+	test('update with returning all fields', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+		const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+		expect(updatedUsers['affectedRows']).toStrictEqual(1);
+
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		// not timezone based timestamp, thats why it should not work here
+		// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+		expect(users).toStrictEqual([{
+			id: 1,
+			name: 'Jane',
+			verified: false,
+			jsonb: null,
+			createdAt: users[0]!.createdAt,
+		}]);
+	});
+
+	test('update with returning partial', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+		const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+			eq(usersTable.id, 1),
+		);
+
+		expect(updatedUsers['affectedRows']).toStrictEqual(1);
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }]);
+	});
+
+	test('delete with returning all fields', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+		expect(deletedUser['affectedRows']).toStrictEqual(1);
+	});
+
+	test('delete with returning partial', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+		expect(deletedUser['affectedRows']).toStrictEqual(1);
+	});
+
+	test('insert + select', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const result = await db.select().from(usersTable);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+
+		await db.insert(usersTable).values({ name: 'Jane' });
+		const result2 = await db.select().from(usersTable);
+		expect(result2).toStrictEqual([
+			{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+			{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+		]);
+	});
+
+	test('json insert', async () => {
+		await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+		}).from(usersTable);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+	});
+
+	test('insert with overridden default values', async () => {
+		await db.insert(usersTable).values({ name: 'John', verified: true });
+		const result = await db.select().from(usersTable);
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: true,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('insert many', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+			verified: usersTable.verified,
+		}).from(usersTable);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', jsonb: null, verified: false },
+			{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+			{ id: 3, name: 'Jane', jsonb: null, verified: false },
+			{ id: 4, name: 'Austin', jsonb: null, verified: true },
+		]);
+	});
+
+	test('insert many with returning', async () => {
+		const result = await db.insert(usersTable).values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+
+		expect(result['affectedRows']).toStrictEqual(4);
+	});
+
+	test('select with group by as field', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.name);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }]);
+	});
+
+	test('select with exists', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const user = alias(usersTable, 'user');
+		const result = await db.select({ name: usersTable.name }).from(usersTable).where(
+			exists(
+				db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
+			),
+		);
+
+		expect(result).toStrictEqual([{ name: 'John' }]);
+	});
+
+	test('select with group by as sql', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(sql`${usersTable.name}`);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }]);
+	});
+
+	test('$default function', async () => {
+		await db.execute(sql`drop table if exists \`orders\``);
+		await db.execute(
+			sql`
+				create table \`orders\` (
+					\`id\` serial primary key,
+					\`region\` text not null,
+					\`product\` text not null,
+					\`amount\` int not null,
+					\`quantity\` int not null
+				)
+			`,
+		);
+
+		await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+		const selectedOrder = await db.select().from(orders);
+
+		expect(selectedOrder).toStrictEqual([{
+			id: 1,
+			amount: 1,
+			quantity: 1,
+			region: 'Ukraine',
+			product: 'random_string',
+		}]);
+	});
+
+	test('$default with empty array', async () => {
+		await db.execute(sql`drop table if exists \`s_orders\``);
+		await db.execute(
+			sql`
+				create table \`s_orders\` (
+					\`id\` serial primary key,
+					\`region\` text default ('Ukraine'),
+					\`product\` text not null
+				)
+			`,
+		);
+
+		const users = mysqlTable('s_orders', {
+			id: serial('id').primaryKey(),
+			region: text('region').default('Ukraine'),
+			product: text('product').$defaultFn(() => 'random_string'),
+		});
+
+		await db.insert(users).values({});
+		const selectedOrder = await db.select().from(users);
+
+		expect(selectedOrder).toStrictEqual([{
+			id: 1,
+			region: 'Ukraine',
+			product: 'random_string',
+		}]);
+	});
+
+	test('select with group by as sql + column', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+	});
+
+	test('select with group by as column + sql', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+	});
+
+	test('select with group by complex query', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, sql`${usersTable.name}`)
+			.orderBy(asc(usersTable.name))
+			.limit(1);
+
+		expect(result).toStrictEqual([{ name: 'Jane' }]);
+	});
+
+	test('build query', async () => {
+		const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, usersTable.name)
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql: `select \`id\`, \`name\` from \`userstest\` group by \`userstest\`.\`id\`, \`userstest\`.\`name\``,
+			params: [],
+		});
+	});
+
+	test('Query check: Insert all defaults in 1 row', async () => {
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		const query = db
+			.insert(users)
+			.values({})
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
+			params: [],
+		});
+	});
+
+	test('Query check: Insert all defaults in multiple rows', async () => {
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state').default('UA'),
+		});
+
+		const query = db
+			.insert(users)
+			.values([{}, {}])
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql:
+				'insert into `users` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
+			params: [],
+		});
+	});
+
+	test('Insert all defaults in 1 row', async () => {
+		const users = mysqlTable('empty_insert_single', {
+			id: serial('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
+		);
+
+		await db.insert(users).values({});
+
+		const res = await db.select().from(users);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'Dan', state: null }]);
+	});
+
+	test('Insert all defaults in multiple rows', async () => {
+		const users = mysqlTable('empty_insert_multiple', {
+			id: serial('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
+		);
+
+		await db.insert(users).values([{}, {}]);
+
+		const res = await db.select().from(users);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+	});
+
+	test('build query insert with onDuplicate', async () => {
+		const query = db.insert(usersTable)
+			.values({ name: 'John', jsonb: ['foo', 'bar'] })
+			.onDuplicateKeyUpdate({ set: { name: 'John1' } })
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql:
+				'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
+			params: ['John', '["foo","bar"]', 'John1'],
+		});
+	});
+
+	test('insert with onDuplicate', async () => {
+		await db.insert(usersTable)
+			.values({ name: 'John' });
+
+		await db.insert(usersTable)
+			.values({ id: 1, name: 'John' })
+			.onDuplicateKeyUpdate({ set: { name: 'John1' } });
+
+		const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+			eq(usersTable.id, 1),
+		);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John1' }]);
+	});
+
+	test('insert conflict', async () => {
+		await db.insert(usersTable)
+			.values({ name: 'John' });
+
+		await expect((async () => {
+			await db.insert(usersTable).values({ id: 1, name: 'John1' });
+		})()).rejects.toThrowError();
+	});
+
+	test('insert conflict with ignore', async () => {
+		await db.insert(usersTable)
+			.values({ name: 'John' });
+
+		await db.insert(usersTable)
+			.ignore()
+			.values({ id: 1, name: 'John1' });
+
+		const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+			eq(usersTable.id, 1),
+		);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert sql', async () => {
+		await db.insert(usersTable).values({ name: sql`${'John'}` });
+		const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('partial join with alias', async () => {
+		const customerAlias = alias(usersTable, 'customer');
+
+		await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+		const result = await db
+			.select({
+				user: {
+					id: usersTable.id,
+					name: usersTable.name,
+				},
+				customer: {
+					id: customerAlias.id,
+					name: customerAlias.name,
+				},
+			}).from(usersTable)
+			.leftJoin(customerAlias, eq(customerAlias.id, 11))
+			.where(eq(usersTable.id, 10));
+
+		expect(result).toStrictEqual([{
+			user: { id: 10, name: 'Ivan' },
+			customer: { id: 11, name: 'Hans' },
+		}]);
+	});
+
+	test('full join with alias', async () => {
+		const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+		const result = await db
+			.select().from(users)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(users.id, 10));
+
+		expect(result).toStrictEqual([{
+			users: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		}]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('select from alias', async () => {
+		const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+		const user = alias(users, 'user');
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+		const result = await db
+			.select()
+			.from(user)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(user.id, 10));
+
+		expect(result).toStrictEqual([{
+			user: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		}]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('insert with spaces', async () => {
+		await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+		const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'Jo   h     n' }]);
+	});
+
+	test('prepared statement', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const statement = db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).from(usersTable)
+			.prepare();
+		const result = await statement.execute();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert: placeholders on columns with encoder', async () => {
+		const date = new Date('2024-08-07T15:30:00Z');
+
+		const statement = db.insert(usersTable).values({
+			name: 'John',
+			createdAt: sql.placeholder('createdAt'),
+		}).prepare();
+
+		await statement.execute({ createdAt: date });
+
+		const result = await db
+			.select({
+				id: usersTable.id,
+				createdAt: usersTable.createdAt,
+			})
+			.from(usersTable);
+
+		expect(result).toStrictEqual([
+			{ id: 1, createdAt: date },
+		]);
+	});
+
+	test('prepared statement reuse', async () => {
+		const stmt = db.insert(usersTable).values({
+			verified: true,
+			name: sql.placeholder('name'),
+		}).prepare();
+
+		for (let i = 0; i < 10; i++) {
+			await stmt.execute({ name: `John ${i}` });
+		}
+
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			verified: usersTable.verified,
+		}).from(usersTable);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John 0', verified: true },
+			{ id: 2, name: 'John 1', verified: true },
+			{ id: 3, name: 'John 2', verified: true },
+			{ id: 4, name: 'John 3', verified: true },
+			{ id: 5, name: 'John 4', verified: true },
+			{ id: 6, name: 'John 5', verified: true },
+			{ id: 7, name: 'John 6', verified: true },
+			{ id: 8, name: 'John 7', verified: true },
+			{ id: 9, name: 'John 8', verified: true },
+			{ id: 10, name: 'John 9', verified: true },
+		]);
+	});
+
+	test('prepared statement with placeholder in .where', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const stmt = db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).from(usersTable)
+			.where(eq(usersTable.id, sql.placeholder('id')))
+			.prepare();
+		const result = await stmt.execute({ id: 1 });
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('prepared statement with placeholder in .limit', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.where(eq(usersTable.id, sql.placeholder('id')))
+			.limit(sql.placeholder('limit'))
+			.prepare();
+
+		const result = await stmt.execute({ id: 1, limit: 1 });
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+		expect(result).toHaveLength(1);
+	});
+
+	test('prepared statement with placeholder in .offset', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.limit(sql.placeholder('limit'))
+			.offset(sql.placeholder('offset'))
+			.prepare();
+
+		const result = await stmt.execute({ limit: 1, offset: 1 });
+
+		expect(result).toStrictEqual([{ id: 2, name: 'John1' }]);
+	});
+
+	test('prepared statement built using $dynamic', async () => {
+		function withLimitOffset(qb: any) {
+			return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+		}
+
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.$dynamic();
+		withLimitOffset(stmt).prepare('stmt_limit');
+
+		const result = await stmt.execute({ limit: 1, offset: 1 });
+
+		expect(result).toStrictEqual([{ id: 2, name: 'John1' }]);
+		expect(result).toHaveLength(1);
+	});
+
+	test('migrator', async () => {
+		await db.execute(sql`drop table if exists cities_migration`);
+		await db.execute(sql`drop table if exists users_migration`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists __drizzle_migrations`);
+
+		await migrate.mysql(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+		await db.execute(sql`drop table cities_migration`);
+		await db.execute(sql`drop table users_migration`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table __drizzle_migrations`);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async () => {
+		const users = mysqlTable('migration_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: int(),
+		});
+
+		const users2 = mysqlTable('migration_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: int(),
+		});
+
+		await db.execute(sql`drop table if exists \`__drizzle_migrations\`;`);
+		await db.execute(sql`drop table if exists ${users};`);
+		await db.execute(sql`drop table if exists ${users2};`);
+
+		// create migration directory
+		const migrationDir = './migrations/bun-mysql';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			'CREATE TABLE `migration_users` (\n`id` serial PRIMARY KEY NOT NULL,\n`name` text NOT NULL,\n`email` text NOT NULL\n);',
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			'ALTER TABLE `migration_users` ADD COLUMN `age` INT;',
+		);
+
+		await migrate.mysql(db, { migrationsFolder: migrationDir });
+		await db.insert(users).values({ name: 'John', email: '', age: 30 });
+		const res1 = await db.select().from(users);
+
+		// second migration was not applied yet
+		expect((async () => await db.insert(users2).values({ name: 'John', email: '', age: 30 }))()).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			'CREATE TABLE `migration_users2` (\n`id` serial PRIMARY KEY NOT NULL,\n`name` text NOT NULL,\n`email` text NOT NULL\n,`age` INT\n);',
+		);
+		await migrate.mysql(db, { migrationsFolder: migrationDir });
+
+		await db.insert(users2).values({ name: 'John', email: '', age: 30 });
+		const res2 = await db.select().from(users2);
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
+
+	// TODO: Breaks further tests
+	test.todo('managing multiple databases #1', async () => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		await db.execute(`use drizzle1`);
+		await migrate.mysql(db, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle1
+		// session.transaction(), which calls client.begin(), spawns a new connection that resets the database context back to the default db from connection string
+		// After the migration completes, subsequent queries on db are running against the default db from connection string, not drizzle1
+		await db.execute(`use drizzle1`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db.select().from(usersMigratorTable);
+
+		await db.execute(`use drizzle2`);
+		await migrate.mysql(db, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle2
+		// session.transaction(), which calls client.begin(), spawns a new connection that resets the database context back to the default db from connection string
+		// After the migration completes, subsequent queries on db are running against the default db from connection string, not drizzle2
+		await db.execute(`use drizzle2`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db.select().from(usersMigratorTable);
+
+		await db.execute('drop database drizzle1;');
+		await db.execute('drop database drizzle2;');
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	// TODO: Breaks further tests
+	test.skip('managing multiple databases #2', async () => {
+		await db.execute('create database if not exists drizzle1;');
+		await db.execute('create database if not exists drizzle2;');
+
+		const client1 = await new SQL({
+			url: process.env['MYSQL_CONNECTION_STRING'],
+			adapter: 'mysql',
+			bigint: true,
+			database: 'drizzle1',
+		}).connect();
+
+		const client2 = await new SQL({
+			url: process.env['MYSQL_CONNECTION_STRING'],
+			adapter: 'mysql',
+			bigint: true,
+			database: 'drizzle2',
+		}).connect();
+
+		const db1 = drizzle({ client: client1 });
+		const db2 = drizzle({ client: client2 });
+
+		await migrate.mysql(db1, { migrationsFolder: './drizzle2/mysql' });
+		await migrate.mysql(db2, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle1
+		await db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db1.select().from(usersMigratorTable);
+
+		// drizzle2
+		await db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db2.select().from(usersMigratorTable);
+
+		await client1.unsafe('drop database drizzle1;');
+		await client2.unsafe('drop database drizzle2;');
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('insert via db.execute + select via db.execute', async () => {
+		await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+		const result: Record<string, unknown>[] = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from ${usersTable}`,
+		);
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert via db.execute w/ query builder', async () => {
+		const inserted = await db.execute(
+			db.insert(usersTable).values({ name: 'John' }),
+		);
+		expect(inserted['affectedRows']).toStrictEqual(1);
+	});
+
+	test('insert + select all possible dates', async () => {
+		await db.execute(sql`drop table if exists \`datestable\``);
+		await db.execute(
+			sql`
+				create table \`datestable\` (
+					\`date\` date,
+					\`date_as_string\` date,
+					\`time\` time,
+					\`datetime\` datetime,
+					\`datetime_as_string\` datetime,
+					\`timestamp\` timestamp(3),
+					\`timestamp_as_string\` timestamp(3),
+					\`year\` year
+				)
+			`,
+		);
+
+		const date = new Date('2022-11-11');
+		const dateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
+
+		await db.insert(datesTable).values({
+			date: date,
+			dateAsString: '2022-11-11',
+			time: '12:12:12',
+			datetime: date,
+			year: 22,
+			datetimeAsString: '2022-11-11 12:12:12',
+			timestamp: dateWithMilliseconds,
+			timestampAsString: '2022-11-11 12:12:12.123',
+		});
+
+		const res = await db.select().from(datesTable);
+
+		expect(res[0]?.date).toBeInstanceOf(Date);
+		expect(res[0]?.datetime).toBeInstanceOf(Date);
+		expect(typeof res[0]?.dateAsString).toStrictEqual('string');
+		expect(typeof res[0]?.datetimeAsString).toStrictEqual('string');
+
+		expect(res).toStrictEqual([{
+			date: toLocalDate(new Date('2022-11-11')),
+			dateAsString: '2022-11-11',
+			time: '12:12:12',
+			datetime: new Date('2022-11-11'),
+			year: 2022,
+			datetimeAsString: '2022-11-11 12:12:12.000',
+			timestamp: new Date('2022-11-11 12:12:12.123'),
+			timestampAsString: '2022-11-11 12:12:12.123',
+		}]);
+
+		await db.execute(sql`drop table if exists \`datestable\``);
+	});
+
+	const tableWithEnums = mysqlTable('enums_test_case', {
+		id: serial('id').primaryKey(),
+		enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
+		enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
+		enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
+	});
+
+	test('Mysql enum as ts enum', async () => {
+		enum Test {
+			a = 'a',
+			b = 'b',
+			c = 'c',
+		}
+
+		const tableWithTsEnums = mysqlTable('enums_test_case', {
+			id: serial('id').primaryKey(),
+			enum1: mysqlEnum('enum1', Test).notNull(),
+			enum2: mysqlEnum('enum2', Test).default(Test.a),
+			enum3: mysqlEnum('enum3', Test).notNull().default(Test.b),
+		});
+
+		await db.execute(sql`drop table if exists \`enums_test_case\``);
+
+		await db.execute(sql`
+			create table \`enums_test_case\` (
+				\`id\` serial primary key,
+				\`enum1\` ENUM('a', 'b', 'c') not null,
+				\`enum2\` ENUM('a', 'b', 'c') default 'a',
+				\`enum3\` ENUM('a', 'b', 'c') not null default 'b'
+			)
+		`);
+
+		await db.insert(tableWithTsEnums).values([
+			{ id: 1, enum1: Test.a, enum2: Test.b, enum3: Test.c },
+			{ id: 2, enum1: Test.a, enum3: Test.c },
+			{ id: 3, enum1: Test.a },
+		]);
+
+		const res = await db.select().from(tableWithTsEnums);
+
+		await db.execute(sql`drop table \`enums_test_case\``);
+
+		expect(res).toStrictEqual([
+			{ id: 1, enum1: 'a' as Test, enum2: 'b' as Test, enum3: 'c' as Test },
+			{ id: 2, enum1: 'a' as Test, enum2: 'a' as Test, enum3: 'c' as Test },
+			{ id: 3, enum1: 'a' as Test, enum2: 'a' as Test, enum3: 'b' as Test },
+		]);
+	});
+
+	test('Mysql enum test case #1', async () => {
+		await db.execute(sql`drop table if exists \`enums_test_case\``);
+
+		await db.execute(sql`
+			create table \`enums_test_case\` (
+				\`id\` serial primary key,
+				\`enum1\` ENUM('a', 'b', 'c') not null,
+				\`enum2\` ENUM('a', 'b', 'c') default 'a',
+				\`enum3\` ENUM('a', 'b', 'c') not null default 'b'
+			)
+		`);
+
+		await db.insert(tableWithEnums).values([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a' },
+		]);
+
+		const res = await db.select().from(tableWithEnums);
+
+		await db.execute(sql`drop table \`enums_test_case\``);
+
+		expect(res).toStrictEqual([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+		]);
+	});
+
+	test('left join (flat object fields)', async () => {
+		await db.insert(citiesTable)
+			.values([{ name: 'Paris' }, { name: 'London' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const res = await db.select({
+			userId: users2Table.id,
+			userName: users2Table.name,
+			cityId: citiesTable.id,
+			cityName: citiesTable.name,
+		}).from(users2Table)
+			.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+		expect(res).toStrictEqual([
+			{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+			{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+		]);
+	});
+
+	test('left join (grouped fields)', async () => {
+		await db.insert(citiesTable)
+			.values([{ name: 'Paris' }, { name: 'London' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const res = await db.select({
+			id: users2Table.id,
+			user: {
+				name: users2Table.name,
+				nameUpper: sql<string>`upper(${users2Table.name})`,
+			},
+			city: {
+				id: citiesTable.id,
+				name: citiesTable.name,
+				nameUpper: sql<string>`upper(${citiesTable.name})`,
+			},
+		}).from(users2Table)
+			.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+		expect(res).toStrictEqual([
+			{
+				id: 1,
+				user: { name: 'John', nameUpper: 'JOHN' },
+				city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+			},
+			{
+				id: 2,
+				user: { name: 'Jane', nameUpper: 'JANE' },
+				city: null,
+			},
+		]);
+	});
+
+	test('left join (all fields)', async () => {
+		await db.insert(citiesTable)
+			.values([{ name: 'Paris' }, { name: 'London' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const res = await db.select().from(users2Table)
+			.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+		expect(res).toStrictEqual([
+			{
+				users2: {
+					id: 1,
+					name: 'John',
+					cityId: 1,
+				},
+				cities: {
+					id: 1,
+					name: 'Paris',
+				},
+			},
+			{
+				users2: {
+					id: 2,
+					name: 'Jane',
+					cityId: null,
+				},
+				cities: null,
+			},
+		]);
+	});
+
+	test('join subquery', async () => {
+		await db.execute(sql`drop table if exists \`courses\``);
+		await db.execute(sql`drop table if exists \`course_categories\``);
+
+		await db.execute(
+			sql`
+				create table \`course_categories\` (
+					\`id\` serial primary key,
+					\`name\` text not null
+				)
+			`,
+		);
+
+		await db.execute(
+			sql`
+				create table \`courses\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`category_id\` bigint unsigned references \`course_categories\`(\`id\`)
+				)
+			`,
+		);
+
+		await db.insert(courseCategoriesTable).values([
+			{ name: 'Category 1' },
+			{ name: 'Category 2' },
+			{ name: 'Category 3' },
+			{ name: 'Category 4' },
+		]);
+
+		await db.insert(coursesTable).values([
+			{ name: 'Development', categoryId: 2 },
+			{ name: 'IT & Software', categoryId: 3 },
+			{ name: 'Marketing', categoryId: 4 },
+			{ name: 'Design', categoryId: 1 },
+		]);
+
+		const sq2 = db
+			.select({
+				categoryId: courseCategoriesTable.id,
+				category: courseCategoriesTable.name,
+				total: sql<number>`count(${courseCategoriesTable.id})`,
+			})
+			.from(courseCategoriesTable)
+			.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+			.as('sq2');
+
+		const res = await db
+			.select({
+				courseName: coursesTable.name,
+				categoryId: sq2.categoryId,
+			})
+			.from(coursesTable)
+			.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+			.orderBy(coursesTable.name);
+
+		expect(res).toStrictEqual([
+			{ courseName: 'Design', categoryId: 1 },
+			{ courseName: 'Development', categoryId: 2 },
+			{ courseName: 'IT & Software', categoryId: 3 },
+			{ courseName: 'Marketing', categoryId: 4 },
+		]);
+
+		await db.execute(sql`drop table if exists \`courses\``);
+		await db.execute(sql`drop table if exists \`course_categories\``);
+	});
+
+	test('with ... select', async () => {
+		await db.execute(sql`drop table if exists \`orders\``);
+		await db.execute(
+			sql`
+				create table \`orders\` (
+					\`id\` serial primary key,
+					\`region\` text not null,
+					\`product\` text not null,
+					\`amount\` int not null,
+					\`quantity\` int not null
+				)
+			`,
+		);
+
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]);
+
+		const regionalSales = db
+			.$with('regional_sales')
+			.as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+		const topRegions = db
+			.$with('top_regions')
+			.as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+						),
+					),
+			);
+
+		const result = await db
+			.with(regionalSales, topRegions)
+			.select({
+				region: orders.region,
+				product: orders.product,
+				productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+				productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+			})
+			.from(orders)
+			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+			.groupBy(orders.region, orders.product)
+			.orderBy(orders.region, orders.product);
+
+		expect(result).toStrictEqual([
+			{
+				region: 'Europe',
+				product: 'A',
+				productUnits: 3,
+				productSales: 30,
+			},
+			{
+				region: 'Europe',
+				product: 'B',
+				productUnits: 5,
+				productSales: 50,
+			},
+			{
+				region: 'US',
+				product: 'A',
+				productUnits: 7,
+				productSales: 70,
+			},
+			{
+				region: 'US',
+				product: 'B',
+				productUnits: 9,
+				productSales: 90,
+			},
+		]);
+	});
+
+	test('with ... update', async () => {
+		const products = mysqlTable('products', {
+			id: serial('id').primaryKey(),
+			price: decimal('price', {
+				precision: 15,
+				scale: 2,
+			}).notNull(),
+			cheap: boolean('cheap').notNull().default(false),
+		});
+
+		await db.execute(sql`drop table if exists ${products}`);
+		await db.execute(sql`
+			create table ${products} (
+				id serial primary key,
+				price decimal(15, 2) not null,
+				cheap boolean not null default false
+			)
+		`);
+
+		await db.insert(products).values([
+			{ price: '10.99' },
+			{ price: '25.85' },
+			{ price: '32.99' },
+			{ price: '2.50' },
+			{ price: '4.59' },
+		]);
+
+		const averagePrice = db
+			.$with('average_price')
+			.as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+		await db
+			.with(averagePrice)
+			.update(products)
+			.set({
+				cheap: true,
+			})
+			.where(lt(products.price, sql`(select * from ${averagePrice})`));
+
+		const result = await db
+			.select({
+				id: products.id,
+			})
+			.from(products)
+			.where(eq(products.cheap, true));
+
+		expect(result).toStrictEqual([
+			{ id: 1 },
+			{ id: 4 },
+			{ id: 5 },
+		]);
+	});
+
+	test('with ... delete', async () => {
+		await db.execute(sql`drop table if exists \`orders\``);
+		await db.execute(
+			sql`
+				create table \`orders\` (
+					\`id\` serial primary key,
+					\`region\` text not null,
+					\`product\` text not null,
+					\`amount\` int not null,
+					\`quantity\` int not null
+				)
+			`,
+		);
+
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]);
+
+		const averageAmount = db
+			.$with('average_amount')
+			.as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+		await db
+			.with(averageAmount)
+			.delete(orders)
+			.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
+
+		const result = await db
+			.select({
+				id: orders.id,
+			})
+			.from(orders);
+
+		expect(result).toStrictEqual([
+			{ id: 1 },
+			{ id: 2 },
+			{ id: 3 },
+			{ id: 4 },
+			{ id: 5 },
+		]);
+	});
+
+	test('select from subquery sql', async () => {
+		await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+		const sq = db
+			.select({ name: sql<string>`concat(${users2Table.name}, " modified")`.as('name') })
+			.from(users2Table)
+			.as('sq');
+
+		const res = await db.select({ name: sq.name }).from(sq);
+
+		expect(res).toStrictEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+	});
+
+	test('select a field without joining its table', () => {
+		expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+	});
+
+	test('select all fields from subquery without alias', () => {
+		const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+		expect(() => db.select().from(sq).prepare()).toThrowError();
+	});
+
+	test('select count()', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+		const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+		expect(res).toStrictEqual([{ count: 2 }]);
+	});
+
+	test('select for ...', () => {
+		{
+			const query = db.select().from(users2Table).for('update').toSQL();
+			expect(query.sql).toMatch(/ for update$/);
+		}
+		{
+			const query = db.select().from(users2Table).for('share', { skipLocked: true }).toSQL();
+			expect(query.sql).toMatch(/ for share skip locked$/);
+		}
+		{
+			const query = db.select().from(users2Table).for('update', { noWait: true }).toSQL();
+			expect(query.sql).toMatch(/ for update nowait$/);
+		}
+	});
+
+	test('having', async () => {
+		await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
+			name: 'Jack',
+			cityId: 2,
+		}]);
+
+		const result = await db
+			.select({
+				id: citiesTable.id,
+				name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+				usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+			})
+			.from(citiesTable)
+			.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+			.where(({ name }) => sql`length(${name}) >= 3`)
+			.groupBy(citiesTable.id)
+			.having(({ usersCount }) => sql`${usersCount} > 0`)
+			.orderBy(({ name }) => name);
+
+		expect(result).toStrictEqual([
+			{
+				id: 1,
+				name: 'LONDON',
+				usersCount: 2,
+			},
+			{
+				id: 2,
+				name: 'PARIS',
+				usersCount: 1,
+			},
+		]);
+	});
+
+	test('view', async () => {
+		const newYorkers1 = mysqlView('new_yorkers')
+			.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+		const newYorkers2 = mysqlView('new_yorkers', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+		const newYorkers3 = mysqlView('new_yorkers', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).existing();
+
+		await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+		await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+		await db.insert(users2Table).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 1 },
+			{ name: 'Jack', cityId: 2 },
+		]);
+
+		{
+			const result = await db.select().from(newYorkers1);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers2);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers3);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+			expect(result).toStrictEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+			]);
+		}
+
+		await db.execute(sql`drop view ${newYorkers1}`);
+	});
+
+	test('select from raw sql', async () => {
+		const result = await db.select({
+			id: sql<number>`id`,
+			name: sql<string>`name`,
+		}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+		Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+		]);
+	});
+
+	test('select from raw sql with joins', async () => {
+		const result = await db
+			.select({
+				id: sql<number>`users.id`,
+				name: sql<string>`users.name`,
+				userCity: sql<string>`users.city`,
+				cityName: sql<string>`cities.name`,
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+		Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+		]);
+	});
+
+	test('join on aliased sql from select', async () => {
+		const result = await db
+			.select({
+				userId: sql<number>`users.id`.as('userId'),
+				name: sql<string>`users.name`,
+				userCity: sql<string>`users.city`,
+				cityId: sql<number>`cities.id`.as('cityId'),
+				cityName: sql<string>`cities.name`,
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toStrictEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test('join on aliased sql from with clause', async () => {
+		const users = db.$with('users').as(
+			db.select({
+				id: sql<number>`id`.as('userId'),
+				name: sql<string>`name`.as('userName'),
+				city: sql<string>`city`.as('city'),
+			}).from(
+				sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+			),
+		);
+
+		const cities = db.$with('cities').as(
+			db.select({
+				id: sql<number>`id`.as('cityId'),
+				name: sql<string>`name`.as('cityName'),
+			}).from(
+				sql`(select 1 as id, 'Paris' as name) as cities`,
+			),
+		);
+
+		const result = await db
+			.with(users, cities)
+			.select({
+				userId: users.id,
+				name: users.name,
+				userCity: users.city,
+				cityId: cities.id,
+				cityName: cities.name,
+			})
+			.from(users)
+			.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toStrictEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test('prefixed table', async () => {
+		const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
+
+		const users = mysqlTable('test_prefixed_table_with_unique_name', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
+		);
+
+		await db.insert(users).values({ id: 1, name: 'John' });
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('orderBy with aliased column', () => {
+		const query = db.select({
+			test: sql`something`.as('test'),
+		}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+		expect(query.sql).toStrictEqual('select something as `test` from `users2` order by `test`');
+	});
+
+	test('timestamp timezone', async () => {
+		const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+		await db.insert(usersTable).values({ name: 'With default times' });
+		await db.insert(usersTable).values({
+			name: 'Without default times',
+			createdAt: date,
+		});
+		const users = await db.select().from(usersTable);
+
+		// check that the timestamps are set correctly for default times
+		expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
+
+		// check that the timestamps are set correctly for non default times
+		expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
+	});
+
+	test('transaction', async () => {
+		const users = mysqlTable('users_transactions', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+		const products = mysqlTable('products_transactions', {
+			id: serial('id').primaryKey(),
+			price: int('price').notNull(),
+			stock: int('stock').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${products}`);
+
+		await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
+		await db.execute(
+			sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
+		);
+
+		const { lastInsertRowid: userId } = await db.insert(users).values({ balance: 100 });
+		const user = await db.select().from(users).where(eq(users.id, userId as number)).then((rows) => rows[0]!);
+		const { lastInsertRowid: productId } = await db.insert(products).values({ price: 10, stock: 10 });
+		const product = await db.select().from(products).where(eq(products.id, productId as number)).then((rows) =>
+			rows[0]!
+		);
+
+		await db.transaction(async (tx) => {
+			await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+			await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([{ id: 1, balance: 90 }]);
+
+		await db.execute(sql`drop table ${users}`);
+		await db.execute(sql`drop table ${products}`);
+	});
+
+	test.skip(
+		'transaction with options (set isolationLevel)',
+		async () => {
+			const users = mysqlTable('users_transactions', {
+				id: serial('id').primaryKey(),
+				balance: int('balance').notNull(),
+			});
+			const products = mysqlTable('products_transactions', {
+				id: serial('id').primaryKey(),
+				price: int('price').notNull(),
+				stock: int('stock').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop table if exists ${products}`);
+
+			await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
+			await db.execute(
+				sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
+			);
+
+			const { lastInsertRowid: userId } = await db.insert(users).values({ balance: 100 });
+			const user = await db.select().from(users).where(eq(users.id, userId as number)).then((rows) => rows[0]!);
+			const { lastInsertRowid: productId } = await db.insert(products).values({ price: 10, stock: 10 });
+			const product = await db.select().from(products).where(eq(products.id, productId as number)).then((rows) =>
+				rows[0]!
+			);
+
+			await db.transaction(async (tx) => {
+				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+			}, { isolationLevel: 'serializable' });
+
+			const result = await db.select().from(users);
+
+			expect(result).toStrictEqual([{ id: 1, balance: 90 }]);
+
+			await db.execute(sql`drop table ${users}`);
+			await db.execute(sql`drop table ${products}`);
+		},
+	);
+
+	test('transaction rollback', async () => {
+		const users = mysqlTable('users_transactions_rollback', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table users_transactions_rollback (id serial not null primary key, balance int not null)`,
+		);
+
+		await expect((async () => {
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 });
+				tx.rollback();
+			});
+		})()).rejects.toThrowError(TransactionRollbackError);
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('nested transaction', async () => {
+		const users = mysqlTable('users_nested_transactions', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table users_nested_transactions (id serial not null primary key, balance int not null)`,
+		);
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+
+			await tx.transaction(async (tx) => {
+				await tx.update(users).set({ balance: 200 });
+			});
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([{ id: 1, balance: 200 }]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('nested transaction rollback', async () => {
+		const users = mysqlTable('users_nested_transactions_rollback', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table users_nested_transactions_rollback (id serial not null primary key, balance int not null)`,
+		);
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+
+			await expect((async () => {
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 });
+					tx.rollback();
+				});
+			})()).rejects.toThrowError(TransactionRollbackError);
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([{ id: 1, balance: 100 }]);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('join subquery with join', async () => {
+		const internalStaff = mysqlTable('internal_staff', {
+			userId: int('user_id').notNull(),
+		});
+
+		const customUser = mysqlTable('custom_user', {
+			id: int('id').notNull(),
+		});
+
+		const ticket = mysqlTable('ticket', {
+			staffId: int('staff_id').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${internalStaff}`);
+		await db.execute(sql`drop table if exists ${customUser}`);
+		await db.execute(sql`drop table if exists ${ticket}`);
+
+		await db.execute(sql`create table internal_staff (user_id integer not null)`);
+		await db.execute(sql`create table custom_user (id integer not null)`);
+		await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+		await db.insert(internalStaff).values({ userId: 1 });
+		await db.insert(customUser).values({ id: 1 });
+		await db.insert(ticket).values({ staffId: 1 });
+
+		const subq = db
+			.select()
+			.from(internalStaff)
+			.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+			.as('internal_staff');
+
+		const mainQuery = await db
+			.select()
+			.from(ticket)
+			.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+		expect(mainQuery).toStrictEqual([{
+			ticket: { staffId: 1 },
+			internal_staff: {
+				internal_staff: { userId: 1 },
+				custom_user: { id: 1 },
+			},
+		}]);
+
+		await db.execute(sql`drop table ${internalStaff}`);
+		await db.execute(sql`drop table ${customUser}`);
+		await db.execute(sql`drop table ${ticket}`);
+	});
+
+	test('subquery with view', async () => {
+		const users = mysqlTable('users_subquery_view', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		});
+
+		const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop view if exists ${newYorkers}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+		);
+		await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+		await db.insert(users).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 1 },
+			{ name: 'Jill', cityId: 2 },
+		]);
+
+		const sq = db.$with('sq').as(db.select().from(newYorkers));
+		const result = await db.with(sq).select().from(sq);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 3, name: 'Jack', cityId: 1 },
+		]);
+
+		await db.execute(sql`drop view ${newYorkers}`);
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('join view as subquery', async () => {
+		const users = mysqlTable('users_join_view', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		});
+
+		const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop view if exists ${newYorkers}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+		);
+		await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+		await db.insert(users).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 1 },
+			{ name: 'Jill', cityId: 2 },
+		]);
+
+		const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+		const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+		expect(result).toStrictEqual([
+			{
+				users_join_view: { id: 1, name: 'John', cityId: 1 },
+				new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+			{
+				users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+				new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+		]);
+
+		await db.execute(sql`drop view ${newYorkers}`);
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('select iterator', async () => {
+		const users = mysqlTable('users_iterator', {
+			id: serial('id').primaryKey(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`create table ${users} (id serial not null primary key)`);
+
+		await db.insert(users).values([{}, {}, {}]);
+
+		const iter = db.select().from(users).iterator();
+
+		const result: typeof users.$inferSelect[] = [];
+
+		for await (const row of iter) {
+			result.push(row);
+		}
+
+		expect(result).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+	});
+
+	test('select iterator w/ prepared statement', async () => {
+		const users = mysqlTable('users_iterator', {
+			id: serial('id').primaryKey(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`create table ${users} (id serial not null primary key)`);
+
+		await db.insert(users).values([{}, {}, {}]);
+
+		const prepared = db.select().from(users).prepare();
+		const iter = prepared.iterator();
+		const result: typeof users.$inferSelect[] = [];
+
+		for await (const row of iter) {
+			result.push(row);
+		}
+
+		expect(result).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+	});
+
+	test('insert undefined', async () => {
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial not null primary key, name text)`,
+		);
+
+		expect((async () => {
+			await db.insert(users).values({ name: undefined });
+		})()).resolves.toStrictEqual(undefined);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('update undefined', async () => {
+		const users = mysqlTable('users', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+
+		await db.execute(
+			sql`create table ${users} (id serial not null primary key, name text)`,
+		);
+
+		await expect((async () => {
+			await db.update(users).set({ name: undefined });
+		})()).rejects.toThrowError();
+
+		await expect((async () => {
+			await db.update(users).set({ id: 1, name: undefined });
+		})()).resolves.toStrictEqual(undefined);
+
+		await db.execute(sql`drop table ${users}`);
+	});
+
+	test('utc config for datetime', async () => {
+		await db.execute(sql`drop table if exists \`datestable\``);
+		await db.execute(
+			sql`
+				create table \`datestable\` (
+					\`datetime_utc\` datetime(3),
+					\`datetime\` datetime(3),
+					\`datetime_as_string\` datetime
+				)
+			`,
+		);
+		const datesTable = mysqlTable('datestable', {
+			datetimeUTC: datetime('datetime_utc', { fsp: 3, mode: 'date' }),
+			datetime: datetime('datetime', { fsp: 3 }),
+			datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+		});
+
+		const dateObj = new Date('2022-11-11');
+		const dateUtc = new Date('2022-11-11T12:12:12.122Z');
+
+		await db.insert(datesTable).values({
+			datetimeUTC: dateUtc,
+			datetime: dateObj,
+			datetimeAsString: '2022-11-11 12:12:12',
+		});
+
+		const res = await db.select().from(datesTable);
+
+		const rawSelect = await db.execute(sql`select \`datetime_utc\` from \`datestable\``);
+		const selectedRow = (rawSelect as unknown as [{ datetime_utc: Date }])[0];
+
+		expect(selectedRow.datetime_utc).toStrictEqual(new Date('2022-11-11 12:12:12.122'));
+		expect(new Date(selectedRow.datetime_utc.toISOString())).toStrictEqual(dateUtc);
+
+		expect(res[0]?.datetime).toBeInstanceOf(Date);
+		expect(res[0]?.datetimeUTC).toBeInstanceOf(Date);
+		expect(typeof res[0]?.datetimeAsString).toStrictEqual('string');
+
+		expect(res).toStrictEqual([{
+			datetimeUTC: dateUtc,
+			datetime: new Date('2022-11-11'),
+			datetimeAsString: '2022-11-11 12:12:12.000',
+		}]);
+
+		await db.execute(sql`drop table if exists \`datestable\``);
+	});
+
+	test('set operations (union) from query builder with subquery', async () => {
+		await setupSetOperationTest(db);
+		const sq = db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).as('sq');
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).union(
+				db.select().from(sq),
+			).limit(8);
+
+		expect(result).toHaveLength(8);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+		]);
+
+		// union should throw if selected fields are not in the same order
+		await expect((async () => {
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).union(
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await union(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 1, name: 'John' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union all) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).limit(2).unionAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).limit(2),
+			).orderBy(asc(sql`id`)).limit(3);
+
+		expect(result).toHaveLength(3);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).limit(2).unionAll(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable).limit(2),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union all) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).limit(1);
+
+		expect(result).toHaveLength(1);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+		]);
+
+		await expect((async () => {
+			unionAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).limit(1);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable).intersect(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).limit(1);
+
+		expect(result).toHaveLength(0);
+
+		expect(result).toStrictEqual([]);
+
+		await expect((async () => {
+			intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).limit(1);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect all) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).limit(2).intersectAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).limit(2),
+			).orderBy(asc(sql`id`));
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).limit(2).intersectAll(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable).limit(2),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect all) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await intersectAll(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+
+		expect(result).toHaveLength(1);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+		]);
+
+		await expect((async () => {
+			intersectAll(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (except) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select()
+			.from(citiesTable).except(
+				db
+					.select()
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+
+		expect(result).toHaveLength(1);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+		]);
+	});
+
+	test('set operations (except) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await except(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable),
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).limit(3);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			except(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable),
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).limit(3);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (except all) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select()
+			.from(citiesTable).exceptAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(citiesTable).exceptAll(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable).where(eq(citiesTable.id, 1)),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (except all) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await exceptAll(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gt(users2Table.id, 7)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).limit(6).orderBy(asc(sql.identifier('id')));
+
+		expect(result).toHaveLength(6);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+			{ id: 6, name: 'Jill' },
+			{ id: 7, name: 'Mary' },
+		]);
+
+		await expect((async () => {
+			exceptAll(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(gt(users2Table.id, 7)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).limit(6);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (mixed) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select()
+			.from(citiesTable).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select()
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+						db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+					).orderBy(asc(citiesTable.id)).limit(1).offset(1),
+			);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(citiesTable).except(
+					({ unionAll }) =>
+						unionAll(
+							db
+								.select({ name: citiesTable.name, id: citiesTable.id })
+								.from(citiesTable).where(gt(citiesTable.id, 1)),
+							db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+						),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (mixed all) as function with subquery', async () => {
+		await setupSetOperationTest(db);
+
+		const sq = except(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gte(users2Table.id, 5)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 7)),
+		).orderBy(asc(sql.identifier('id'))).as('sq');
+
+		const result = await union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db.select().from(sq).limit(1),
+			db
+				.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+		);
+
+		expect(result).toHaveLength(4);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+			{ id: 5, name: 'Ben' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				except(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(gte(users2Table.id, 5)),
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table).where(eq(users2Table.id, 7)),
+				).limit(1),
+				db
+					.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('aggregate function: count', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: count() }).from(table);
+		const result2 = await db.select({ value: count(table.a) }).from(table);
+		const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(7);
+		expect(result2[0]?.value).toStrictEqual(5);
+		expect(result3[0]?.value).toStrictEqual(6);
+	});
+
+	test('aggregate function: avg', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: avg(table.b) }).from(table);
+		const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
+		const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual('33.3333');
+		expect(result2[0]?.value).toStrictEqual(null);
+		expect(result3[0]?.value).toStrictEqual('42.5000');
+	});
+
+	test('aggregate function: sum', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: sum(table.b) }).from(table);
+		const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
+		const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual('200');
+		expect(result2[0]?.value).toStrictEqual(null);
+		expect(result3[0]?.value).toStrictEqual('170');
+	});
+
+	test('aggregate function: max', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: max(table.b) }).from(table);
+		const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(90);
+		expect(result2[0]?.value).toStrictEqual(null);
+	});
+
+	test('aggregate function: min', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: min(table.b) }).from(table);
+		const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(10);
+		expect(result2[0]?.value).toStrictEqual(null);
+	});
+
+	test('test $onUpdateFn and $onUpdate works as $default', async () => {
+		await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+		await db.execute(
+			sql`
+				create table ${usersOnUpdate} (
+				id serial not null primary key,
+				name text not null,
+				update_counter integer default 1 not null,
+				updated_at datetime(3),
+				uppercase_name text,
+				always_null text
+				)
+			`,
+		);
+
+		await db.insert(usersOnUpdate).values([
+			{ name: 'John' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+		const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+		const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+		const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+		expect(response).toStrictEqual([
+			{ name: 'John', id: 1, updateCounter: 1, uppercaseName: 'JOHN', alwaysNull: null },
+			{ name: 'Jane', id: 2, updateCounter: 1, uppercaseName: 'JANE', alwaysNull: null },
+			{ name: 'Jack', id: 3, updateCounter: 1, uppercaseName: 'JACK', alwaysNull: null },
+			{ name: 'Jill', id: 4, updateCounter: 1, uppercaseName: 'JILL', alwaysNull: null },
+		]);
+		const msDelay = 750;
+
+		for (const eachUser of justDates) {
+			expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+		}
+	});
+
+	test('test $onUpdateFn and $onUpdate works updating', async () => {
+		await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+		await db.execute(
+			sql`
+				create table ${usersOnUpdate} (
+				id serial not null primary key,
+				name text not null,
+				update_counter integer default 1 not null,
+				updated_at datetime(3),
+				uppercase_name text,
+				always_null text
+				)
+			`,
+		);
+
+		await db.insert(usersOnUpdate).values([
+			{ name: 'John', alwaysNull: 'this will will be null after updating' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+		const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+		const initial = await db.select({ updatedAt }).from(usersOnUpdate);
+
+		await db.update(usersOnUpdate).set({ name: 'Angel', uppercaseName: null }).where(eq(usersOnUpdate.id, 1));
+
+		const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+		const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+		expect(response).toStrictEqual([
+			{ name: 'Angel', id: 1, updateCounter: 2, uppercaseName: null, alwaysNull: null },
+			{ name: 'Jane', id: 2, updateCounter: 1, uppercaseName: 'JANE', alwaysNull: null },
+			{ name: 'Jack', id: 3, updateCounter: 1, uppercaseName: 'JACK', alwaysNull: null },
+			{ name: 'Jill', id: 4, updateCounter: 1, uppercaseName: 'JILL', alwaysNull: null },
+		]);
+		const msDelay = 750;
+
+		expect(initial[0]?.updatedAt?.valueOf()).not.toStrictEqual(justDates[0]?.updatedAt?.valueOf());
+
+		for (const eachUser of justDates) {
+			expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+		}
+	});
+
+	// mySchema tests
+	test('mySchema :: select all fields', async () => {
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const result = await db.select().from(usersMySchemaTable);
+
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		// not timezone based timestamp, thats why it should not work here
+		// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('mySchema :: select sql', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const users = await db.select({
+			name: sql`upper(${usersMySchemaTable.name})`,
+		}).from(usersMySchemaTable);
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('mySchema :: select typed sql', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const users = await db.select({
+			name: sql<string>`upper(${usersMySchemaTable.name})`,
+		}).from(usersMySchemaTable);
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('mySchema :: select distinct', async () => {
+		const usersDistinctTable = mysqlTable('users_distinct', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+		await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
+
+		await db.insert(usersDistinctTable).values([
+			{ id: 1, name: 'John' },
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'John' },
+			{ id: 1, name: 'Jane' },
+		]);
+		const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+			usersDistinctTable.id,
+			usersDistinctTable.name,
+		);
+
+		await db.execute(sql`drop table ${usersDistinctTable}`);
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+	});
+
+	test('mySchema :: insert returning sql', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		const result = await db.insert(usersMySchemaTable).values({ name: 'John' });
+
+		expect(result['lastInsertRowid']).toStrictEqual(1);
+	});
+
+	test('mySchema :: delete returning sql', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
+
+		expect(users['affectedRows']).toStrictEqual(1);
+	});
+
+	test('mySchema :: update with returning partial', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const updatedUsers = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(
+			eq(usersMySchemaTable.name, 'John'),
+		);
+
+		const users = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
+			usersMySchemaTable,
+		)
+			.where(
+				eq(usersMySchemaTable.id, 1),
+			);
+
+		expect(updatedUsers['affectedRows']).toStrictEqual(1);
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }]);
+	});
+
+	test('mySchema :: delete with returning all fields', async () => {
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const deletedUser = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
+
+		expect(deletedUser['affectedRows']).toStrictEqual(1);
+	});
+
+	test('mySchema :: insert + select', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const result = await db.select().from(usersMySchemaTable);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+
+		await db.insert(usersMySchemaTable).values({ name: 'Jane' });
+		const result2 = await db.select().from(usersMySchemaTable);
+		expect(result2).toStrictEqual([
+			{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+			{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+		]);
+	});
+
+	test('mySchema :: insert with overridden default values', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John', verified: true });
+		const result = await db.select().from(usersMySchemaTable);
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: true,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('mySchema :: insert many', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+		const result = await db.select({
+			id: usersMySchemaTable.id,
+			name: usersMySchemaTable.name,
+			jsonb: usersMySchemaTable.jsonb,
+			verified: usersMySchemaTable.verified,
+		}).from(usersMySchemaTable);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', jsonb: null, verified: false },
+			{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+			{ id: 3, name: 'Jane', jsonb: null, verified: false },
+			{ id: 4, name: 'Austin', jsonb: null, verified: true },
+		]);
+	});
+
+	test('mySchema :: select with group by as field', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
+			.groupBy(usersMySchemaTable.name);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }]);
+	});
+
+	test('mySchema :: select with group by as column + sql', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+		const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
+			.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`);
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+	});
+
+	test('mySchema :: build query', async () => {
+		const query = db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(usersMySchemaTable)
+			.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql:
+				`select \`id\`, \`name\` from \`mySchema\`.\`userstest\` group by \`mySchema\`.\`userstest\`.\`id\`, \`mySchema\`.\`userstest\`.\`name\``,
+			params: [],
+		});
+	});
+
+	test('mySchema :: insert with spaces', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: sql`'Jo   h     n'` });
+		const result = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
+			usersMySchemaTable,
+		);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'Jo   h     n' }]);
+	});
+
+	test('mySchema :: prepared statement with placeholder in .where', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const stmt = db.select({
+			id: usersMySchemaTable.id,
+			name: usersMySchemaTable.name,
+		}).from(usersMySchemaTable)
+			.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
+			.prepare();
+		const result = await stmt.execute({ id: 1 });
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('mySchema :: select from tables with same name from different schema using alias', async () => {
+		await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+		await db.execute(sql`drop table if exists \`userstest\``);
+		await db.execute(
+			sql`
+				create table \`userstest\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`verified\` boolean not null default false,
+					\`jsonb\` json,
+					\`created_at\` timestamp not null default now()
+				)
+			`,
+		);
+
+		await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
+		await db.insert(usersTable).values({ id: 11, name: 'Hans' });
+
+		const customerAlias = alias(usersTable, 'customer');
+
+		const result = await db
+			.select().from(usersMySchemaTable)
+			.leftJoin(customerAlias, eq(customerAlias.id, 11))
+			.where(eq(usersMySchemaTable.id, 10));
+
+		expect(result).toStrictEqual([{
+			userstest: {
+				id: 10,
+				name: 'Ivan',
+				verified: false,
+				jsonb: null,
+				createdAt: result[0]!.userstest.createdAt,
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+				verified: false,
+				jsonb: null,
+				createdAt: result[0]!.customer!.createdAt,
+			},
+		}]);
+	});
+
+	test('insert $returningId: serial as id', async () => {
+		const result = await db.insert(usersTable).values({ name: 'John' }).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }]);
+	});
+
+	test('insert $returningId: serial as id, not first column', async () => {
+		const usersTableDefNotFirstColumn = mysqlTable('users2', {
+			name: text('name').notNull(),
+			id: serial('id').primaryKey(),
+		});
+
+		const result = await db.insert(usersTableDefNotFirstColumn).values({ name: 'John' }).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }]);
+	});
+
+	test('insert $returningId: serial as id, batch insert', async () => {
+		const result = await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }, { id: 2 }]);
+	});
+
+	test('insert $returningId: $default as primary key', async () => {
+		const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
+		let iterator = 0;
+
+		const usersTableDefFn = mysqlTable('users_default_fn', {
+			customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
+				const value = uniqueKeys[iterator]!;
+				iterator++;
+				return value;
+			}),
+			name: text('name').notNull(),
+		});
+
+		await setupReturningFunctionsTest(db);
+
+		const result = await db.insert(usersTableDefFn).values([{ name: 'John' }, { name: 'John1' }])
+			.$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			customId: string;
+		}[]>();
+
+		expect(result).toStrictEqual([{ customId: 'ao865jf3mcmkfkk8o5ri495z' }, {
+			customId: 'dyqs529eom0iczo2efxzbcut',
+		}]);
+	});
+
+	test('insert $returningId: $default as primary key with value', async () => {
+		const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
+		let iterator = 0;
+
+		const usersTableDefFn = mysqlTable('users_default_fn', {
+			customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
+				const value = uniqueKeys[iterator]!;
+				iterator++;
+				return value;
+			}),
+			name: text('name').notNull(),
+		});
+
+		await setupReturningFunctionsTest(db);
+
+		const result = await db.insert(usersTableDefFn).values([{ name: 'John', customId: 'test' }, { name: 'John1' }])
+			//    ^?
+			.$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			customId: string;
+		}[]>();
+
+		expect(result).toStrictEqual([{ customId: 'test' }, { customId: 'ao865jf3mcmkfkk8o5ri495z' }]);
+	});
+
+	test('mySchema :: view', async () => {
+		const newYorkers1 = mySchema.view('new_yorkers')
+			.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
+
+		const newYorkers2 = mySchema.view('new_yorkers', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
+
+		const newYorkers3 = mySchema.view('new_yorkers', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).existing();
+
+		await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
+
+		await db.insert(citiesMySchemaTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+		await db.insert(users2MySchemaTable).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 1 },
+			{ name: 'Jack', cityId: 2 },
+		]);
+
+		{
+			const result = await db.select().from(newYorkers1);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers2);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers3);
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+			expect(result).toStrictEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+			]);
+		}
+
+		await db.execute(sql`drop view ${newYorkers1}`);
+	});
+
+	test('$count separate', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable);
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual(4);
+	});
+
+	test('$count embedded', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+	});
+
+	test('$count separate reuse', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.$count(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count1).toStrictEqual(4);
+		expect(count2).toStrictEqual(5);
+		expect(count3).toStrictEqual(6);
+	});
+
+	test('$count embedded reuse', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count1).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+		expect(count2).toStrictEqual([
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+		]);
+		expect(count3).toStrictEqual([
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+		]);
+	});
+
+	test('$count separate with filters', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual(3);
+	});
+
+	test('$count embedded with filters', async () => {
+		const countTestTable = mysqlTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${countTestTable}`);
+		await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+		}).from(countTestTable);
+
+		await db.execute(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual([
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+		]);
+	});
+
+	test('limit 0', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db
+			.select()
+			.from(usersTable)
+			.limit(0);
+
+		expect(users).toStrictEqual([]);
+	});
+
+	test('limit -1', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db
+			.select()
+			.from(usersTable)
+			.limit(-1);
+
+		expect(users.length).toBeGreaterThan(0);
+	});
+
+	test('define constraints as array', async () => {
+		const table = mysqlTable('name', {
+			id: int(),
+		}, (t) => [
+			index('name').on(t.id),
+			primaryKey({ columns: [t.id] }),
+		]);
+
+		const { indexes, primaryKeys } = getTableConfig(table);
+
+		expect(indexes.length).toStrictEqual(1);
+		expect(primaryKeys.length).toStrictEqual(1);
+	});
+
+	test('define constraints as array inside third param', async () => {
+		const table = mysqlTable('name', {
+			id: int(),
+		}, (t) => [
+			[index('name').on(t.id), primaryKey({ columns: [t.id] })],
+		]);
+
+		const { indexes, primaryKeys } = getTableConfig(table);
+
+		expect(indexes.length).toStrictEqual(1);
+		expect(primaryKeys.length).toStrictEqual(1);
+	});
+
+	test('update with limit and order by', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db.update(usersTable).set({ verified: true }).limit(2).orderBy(asc(usersTable.name));
+
+		const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
+			asc(usersTable.name),
+		);
+		expect(result).toStrictEqual([
+			{ name: 'Alan', verified: true },
+			{ name: 'Barry', verified: true },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test('delete with limit and order by', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db.delete(usersTable).where(eq(usersTable.verified, false)).limit(1).orderBy(asc(usersTable.name));
+
+		const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
+			asc(usersTable.name),
+		);
+		expect(result).toStrictEqual([
+			{ name: 'Barry', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test('Object keys as column names', async () => {
+		// Tests the following:
+		// Column with required config
+		// Column with optional config without providing a value
+		// Column with optional config providing a value
+		// Column without config
+		const users = mysqlTable('users', {
+			id: bigint({ mode: 'number' }).autoincrement().primaryKey(),
+			createdAt: timestamp(),
+			updatedAt: timestamp({ fsp: 3 }),
+			admin: boolean(),
+		});
+
+		await db.execute(sql`drop table if exists users`);
+		await db.execute(
+			sql`
+				create table users (
+					\`id\` bigint auto_increment primary key,
+					\`createdAt\` timestamp,
+					\`updatedAt\` timestamp(3),
+					\`admin\` boolean
+				)
+			`,
+		);
+
+		await db.insert(users).values([
+			{ createdAt: sql`now() - interval 30 day`, updatedAt: sql`now() - interval 1 day`, admin: true },
+			{ createdAt: sql`now() - interval 1 day`, updatedAt: sql`now() - interval 30 day`, admin: true },
+			{ createdAt: sql`now() - interval 1 day`, updatedAt: sql`now() - interval 1 day`, admin: false },
+		]);
+		const result = await db
+			.select({ id: users.id, admin: users.admin })
+			.from(users)
+			.where(
+				and(
+					gt(users.createdAt, sql`now() - interval 7 day`),
+					gt(users.updatedAt, sql`now() - interval 7 day`),
+				),
+			);
+
+		expect(result).toStrictEqual([
+			{ id: 3, admin: false },
+		]);
+
+		await db.execute(sql`drop table users`);
+	});
+
+	test('cross join', async () => {
+		await db
+			.insert(usersTable)
+			.values([
+				{ name: 'John' },
+				{ name: 'Jane' },
+			]);
+
+		await db
+			.insert(citiesTable)
+			.values([
+				{ name: 'Seattle' },
+				{ name: 'New York City' },
+			]);
+
+		const result = await db
+			.select({
+				user: usersTable.name,
+				city: citiesTable.name,
+			})
+			.from(usersTable)
+			.crossJoin(citiesTable)
+			.orderBy(usersTable.name, citiesTable.name);
+
+		expect(result).toStrictEqual([
+			{ city: 'New York City', user: 'Jane' },
+			{ city: 'Seattle', user: 'Jane' },
+			{ city: 'New York City', user: 'John' },
+			{ city: 'Seattle', user: 'John' },
+		]);
+	});
+
+	test('left join (lateral)', async () => {
+		await db
+			.insert(citiesTable)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const sq = db
+			.select({
+				userId: users2Table.id,
+				userName: users2Table.name,
+				cityId: users2Table.cityId,
+			})
+			.from(users2Table)
+			.where(eq(users2Table.cityId, citiesTable.id))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: citiesTable.id,
+				cityName: citiesTable.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(citiesTable)
+			.leftJoinLateral(sq, sql`true`);
+
+		expect(res).toStrictEqual([
+			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+			{ cityId: 2, cityName: 'London', userId: null, userName: null },
+		]);
+	});
+
+	test('inner join (lateral)', async () => {
+		await db
+			.insert(citiesTable)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const sq = db
+			.select({
+				userId: users2Table.id,
+				userName: users2Table.name,
+				cityId: users2Table.cityId,
+			})
+			.from(users2Table)
+			.where(eq(users2Table.cityId, citiesTable.id))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: citiesTable.id,
+				cityName: citiesTable.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(citiesTable)
+			.innerJoinLateral(sq, sql`true`);
+
+		expect(res).toStrictEqual([
+			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+		]);
+	});
+
+	test('cross join (lateral)', async () => {
+		await db
+			.insert(citiesTable)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }, { id: 3, name: 'Berlin' }]);
+
+		await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }, {
+			name: 'Patrick',
+			cityId: 2,
+		}]);
+
+		const sq = db
+			.select({
+				userId: users2Table.id,
+				userName: users2Table.name,
+				cityId: users2Table.cityId,
+			})
+			.from(users2Table)
+			.where(not(like(citiesTable.name, 'L%')))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: citiesTable.id,
+				cityName: citiesTable.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(citiesTable)
+			.crossJoinLateral(sq)
+			.orderBy(citiesTable.id, sq.userId);
+
+		expect(res).toStrictEqual([
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 1,
+				userName: 'John',
+			},
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 2,
+				userName: 'Jane',
+			},
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 3,
+				userName: 'Patrick',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 1,
+				userName: 'John',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 2,
+				userName: 'Jane',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 3,
+				userName: 'Patrick',
+			},
+		]);
+	});
+
+	test('RQB v2 simple find first - no rows', async () => {
+		const result = await db.query.rqbUser.findFirst();
+
+		expect(result).toStrictEqual(undefined);
+	});
+
+	test('RQB v2 simple find first - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+
+	test('RQB v2 simple find first - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 1,
+			createdAt: date,
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}],
+		});
+	});
+
+	test('RQB v2 simple find first - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+
+	test('RQB v2 simple find many - no rows', async () => {
+		const result = await db.query.rqbUser.findMany();
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test('RQB v2 simple find many - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}]);
+	});
+
+	test('RQB v2 simple find many - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}]);
+	});
+
+	test('RQB v2 simple find many - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+	});
+
+	test('RQB v2 transaction find first - no rows', async () => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst();
+
+			expect(result).toStrictEqual(undefined);
+		});
+	});
+
+	test('RQB v2 transaction find first - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find many - no rows', async () => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+	});
+
+	test('RQB v2 transaction find many - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+	});
+
+	test('all types', async () => {
+		await db.execute(sql`
+			CREATE TABLE \`all_types\` (
+					\`serial\` serial AUTO_INCREMENT,
+					\`bigint53\` bigint,
+					\`bigint64\` bigint,
+					\`binary\` binary,
+					\`boolean\` boolean,
+					\`char\` char,
+					\`date\` date,
+					\`date_str\` date,
+					\`datetime\` datetime,
+					\`datetime_str\` datetime,
+					\`decimal\` decimal,
+					\`decimal_num\` decimal(30),
+					\`decimal_big\` decimal(30),
+					\`double\` double,
+					\`float\` float,
+					\`int\` int,
+					\`json\` json,
+					\`med_int\` mediumint,
+					\`small_int\` smallint,
+					\`real\` real,
+					\`text\` text,
+					\`time\` time,
+					\`timestamp\` timestamp,
+					\`timestamp_str\` timestamp,
+					\`tiny_int\` tinyint,
+					\`varbin\` varbinary(16),
+					\`varchar\` varchar(255),
+					\`year\` year,
+					\`enum\` enum('enV1','enV2')
+				);
+		`);
+
+		await db.insert(allTypesTable).values({
+			serial: 1,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date(1741743161623),
+			dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+			datetime: new Date(1741743161623),
+			datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+			decimal: '47521',
+			decimalNum: 9007199254740991,
+			decimalBig: 5044565289845416380n,
+			double: 15.35325689124218,
+			enum: 'enV1',
+			float: 1.048596,
+			real: 1.048596,
+			text: 'C4-',
+			int: 621,
+			json: {
+				str: 'strval',
+				arr: ['str', 10],
+			},
+			medInt: 560,
+			smallInt: 14,
+			time: '04:13:22',
+			timestamp: new Date(1741743161623),
+			timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+			tinyInt: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+		});
+
+		const rawRes = await db.select().from(allTypesTable);
+
+		type ExpectedType = {
+			serial: number;
+			bigint53: number | null;
+			bigint64: bigint | null;
+			binary: string | null;
+			boolean: boolean | null;
+			char: string | null;
+			date: Date | null;
+			dateStr: string | null;
+			datetime: Date | null;
+			datetimeStr: string | null;
+			decimal: string | null;
+			decimalNum: number | null;
+			decimalBig: bigint | null;
+			double: number | null;
+			float: number | null;
+			int: number | null;
+			json: unknown;
+			medInt: number | null;
+			smallInt: number | null;
+			real: number | null;
+			text: string | null;
+			time: string | null;
+			timestamp: Date | null;
+			timestampStr: string | null;
+			tinyInt: number | null;
+			varbin: string | null;
+			varchar: string | null;
+			year: number | null;
+			enum: 'enV1' | 'enV2' | null;
+		}[];
+
+		const expectedRes: ExpectedType = [
+			{
+				serial: 1,
+				bigint53: 9007199254740991,
+				bigint64: 5044565289845416380n,
+				binary: '1',
+				boolean: true,
+				char: 'c',
+				date: new Date('2025-03-12T00:00:00.000Z'),
+				dateStr: '2025-03-12',
+				datetime: new Date('2025-03-12T01:32:42.000Z'),
+				datetimeStr: '2025-03-12 01:32:41.000',
+				decimal: '47521',
+				decimalNum: 9007199254740991,
+				decimalBig: 5044565289845416380n,
+				double: 15.35325689124218,
+				float: 1.048596,
+				int: 621,
+				json: { arr: ['str', 10], str: 'strval' },
+				medInt: 560,
+				smallInt: 14,
+				real: 1.048596,
+				text: 'C4-',
+				time: '04:13:22',
+				timestamp: new Date('2025-03-12T01:32:42.000Z'),
+				timestampStr: '2025-03-12 01:32:41',
+				tinyInt: 7,
+				varbin: '1010110101001101',
+				varchar: 'VCHAR',
+				year: 2025,
+				enum: 'enV1',
+			},
+		];
+
+		expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+		expect(rawRes).toStrictEqual(expectedRes);
+	});
+});
+
+test('insert into ... select', async () => {
+	const notifications = mysqlTable('notifications', {
+		id: serial('id').primaryKey(),
+		sentAt: timestamp('sent_at').notNull().defaultNow(),
+		message: text('message').notNull(),
+	});
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+	const userNotications = mysqlTable('user_notifications', {
+		userId: int('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+		notificationId: int('notification_id').notNull().references(() => notifications.id, { onDelete: 'cascade' }),
+	}, (t) => ({
+		pk: primaryKey({ columns: [t.userId, t.notificationId] }),
+	}));
+
+	await db.execute(sql`drop table if exists ${userNotications} cascade`);
+	await db.execute(sql`drop table if exists ${users} cascade`);
+	await db.execute(sql`drop table if exists ${notifications} cascade`);
+	await db.execute(sql`
+		create table ${notifications} (
+			\`id\` serial primary key,
+			\`sent_at\` timestamp not null default now(),
+			\`message\` text not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` text not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${userNotications} (
+			\`user_id\` int references users(id) on delete cascade,
+			\`notification_id\` int references notifications(id) on delete cascade,
+			primary key (user_id, notification_id)
+		)
+	`);
+
+	await db
+		.insert(notifications)
+		.values({ message: 'You are one of the 3 lucky winners!' });
+	const newNotification = await db
+		.select({ id: notifications.id })
+		.from(notifications)
+		.then((result) => result[0]);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await db
+		.insert(userNotications)
+		.select(
+			db
+				.select({
+					userId: users.id,
+					notificationId: sql`(${newNotification!.id})`.as('notification_id'),
+				})
+				.from(users)
+				.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+				.orderBy(asc(users.id)),
+		);
+	const sentNotifications = await db.select().from(userNotications);
+
+	expect(sentNotifications).toStrictEqual([
+		{ userId: 1, notificationId: newNotification!.id },
+		{ userId: 3, notificationId: newNotification!.id },
+		{ userId: 5, notificationId: newNotification!.id },
+	]);
+});
+
+test('insert into ... select with keys in different order', async () => {
+	const users1 = mysqlTable('users1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+	const users2 = mysqlTable('users2', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users1}`);
+	await db.execute(sql`drop table if exists ${users2}`);
+	await db.execute(sql`
+		create table ${users1} (
+			\`id\` serial primary key,
+			\`name\` text not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${users2} (
+			\`id\` serial primary key,
+			\`name\` text not null
+		)
+	`);
+
+	expect(
+		() =>
+			db
+				.insert(users1)
+				.select(
+					db
+						.select({
+							name: users2.name,
+							id: users2.id,
+						})
+						.from(users2),
+				),
+	).toThrowError();
+});
+
+test('MySqlTable :: select with `use index` hint', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	}, () => [usersTableNameIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	const result = await db.select()
+		.from(users, {
+			useIndex: [usersTableNameIndex],
+		})
+		.where(eq(users.name, 'David'));
+
+	expect(result).toHaveLength(1);
+	expect(result).toStrictEqual([{ id: 4, name: 'David' }]);
+});
+
+test('MySqlTable :: select with `use index` hint on 1 index', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	}, () => [usersTableNameIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+
+	const query = db.select()
+		.from(users, {
+			useIndex: usersTableNameIndex,
+		})
+		.where(eq(users.name, 'David'))
+		.toSQL();
+
+	expect(query.sql).toInclude('USE INDEX (`users_name_index`)');
+});
+
+test('MySqlTable :: select with `use index` hint on multiple indexes', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+		age: int('age').notNull(),
+	}, () => [usersTableNameIndex, usersTableAgeIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+	const usersTableAgeIndex = index('users_age_index').on(users.age);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null,
+			\`age\` int not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+	await db.execute(sql`create index users_age_index ON users(age)`);
+
+	const query = db.select()
+		.from(users, {
+			useIndex: [usersTableNameIndex, usersTableAgeIndex],
+		})
+		.where(eq(users.name, 'David'))
+		.toSQL();
+
+	expect(query.sql).toInclude('USE INDEX (`users_name_index`, `users_age_index`)');
+});
+
+test('MySqlTable :: select with `use index` hint on not existed index', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	}, () => [usersTableNameIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await expect((async () => {
+		return await db.select()
+			.from(users, {
+				useIndex: ['some_other_index'],
+			})
+			.where(eq(users.name, 'David'));
+	})()).rejects.toThrowError();
+});
+
+test('MySqlTable :: select with `use index` + `force index` incompatible hints', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+		age: int('age').notNull(),
+	}, () => [usersTableNameIndex, usersTableAgeIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+	const usersTableAgeIndex = index('users_age_index').on(users.age);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null,
+			\`age\` int not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+	await db.execute(sql`create index users_age_index ON users(age)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice', age: 18 },
+		{ name: 'Bob', age: 19 },
+		{ name: 'Charlie', age: 20 },
+		{ name: 'David', age: 21 },
+		{ name: 'Eve', age: 22 },
+	]);
+
+	await expect((async () => {
+		return await db.select()
+			.from(users, {
+				useIndex: [usersTableNameIndex],
+				forceIndex: [usersTableAgeIndex],
+			})
+			.where(eq(users.name, 'David'));
+	})()).rejects.toThrowError();
+});
+
+test('MySqlTable :: select with join `use index` hint', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await db.insert(posts).values([
+		{ text: 'Alice post', userId: 1 },
+		{ text: 'Bob post', userId: 2 },
+		{ text: 'Charlie post', userId: 3 },
+		{ text: 'David post', userId: 4 },
+		{ text: 'Eve post', userId: 5 },
+	]);
+
+	const result = await db.select({
+		userId: users.id,
+		name: users.name,
+		postId: posts.id,
+		text: posts.text,
+	})
+		.from(users)
+		.leftJoin(posts, eq(users.id, posts.userId), {
+			useIndex: [postsTableUserIdIndex],
+		})
+		.where(and(
+			eq(users.name, 'David'),
+			eq(posts.text, 'David post'),
+		));
+
+	expect(result).toHaveLength(1);
+	expect(result).toStrictEqual([{ userId: 4, name: 'David', postId: 4, text: 'David post' }]);
+});
+
+test('MySqlTable :: select with join `use index` hint on 1 index', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	const query = db.select({
+		userId: users.id,
+		name: users.name,
+		postId: posts.id,
+		text: posts.text,
+	})
+		.from(users)
+		.leftJoin(posts, eq(users.id, posts.userId), {
+			useIndex: postsTableUserIdIndex,
+		})
+		.where(and(
+			eq(users.name, 'David'),
+			eq(posts.text, 'David post'),
+		)).toSQL();
+
+	expect(query.sql).toInclude('USE INDEX (`posts_user_id_index`)');
+});
+
+test('MySqlTable :: select with cross join `use index` hint', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	await db.insert(users).values([
+		{ id: 1, name: 'Alice' },
+		{ id: 2, name: 'Bob' },
+	]);
+
+	await db.insert(posts).values([
+		{ id: 1, text: 'Alice post', userId: 1 },
+		{ id: 2, text: 'Bob post', userId: 2 },
+	]);
+
+	const result = await db.select()
+		.from(users)
+		.crossJoin(posts, {
+			useIndex: [postsTableUserIdIndex],
+		})
+		.orderBy(users.id, posts.id);
+
+	expect(result).toStrictEqual([{
+		users: { id: 1, name: 'Alice' },
+		posts: { id: 1, text: 'Alice post', userId: 1 },
+	}, {
+		users: { id: 1, name: 'Alice' },
+		posts: { id: 2, text: 'Bob post', userId: 2 },
+	}, {
+		users: { id: 2, name: 'Bob' },
+		posts: { id: 1, text: 'Alice post', userId: 1 },
+	}, {
+		users: { id: 2, name: 'Bob' },
+		posts: { id: 2, text: 'Bob post', userId: 2 },
+	}]);
+});
+
+test('MySqlTable :: select with cross join `use index` hint on 1 index', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	const query = db.select({
+		userId: users.id,
+		name: users.name,
+		postId: posts.id,
+		text: posts.text,
+	})
+		.from(users)
+		.crossJoin(posts, {
+			useIndex: postsTableUserIdIndex,
+		})
+		.where(and(
+			eq(users.name, 'David'),
+			eq(posts.text, 'David post'),
+		)).toSQL();
+
+	expect(query.sql).toInclude('USE INDEX (`posts_user_id_index`)');
+});
+
+test('MySqlTable :: select with join `use index` hint on multiple indexes', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex, postsTableTextIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+	const postsTableTextIndex = index('posts_text_index').on(posts.text);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+	await db.execute(sql`create index posts_text_index ON posts(text)`);
+
+	const query = db.select({
+		userId: users.id,
+		name: users.name,
+		postId: posts.id,
+		text: posts.text,
+	})
+		.from(users)
+		.leftJoin(posts, eq(users.id, posts.userId), {
+			useIndex: [postsTableUserIdIndex, postsTableTextIndex],
+		})
+		.where(and(
+			eq(users.name, 'David'),
+			eq(posts.text, 'David post'),
+		)).toSQL();
+
+	expect(query.sql).toInclude('USE INDEX (`posts_user_id_index`, `posts_text_index`)');
+});
+
+test('MySqlTable :: select with join `use index` hint on not existed index', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await db.insert(posts).values([
+		{ text: 'Alice post', userId: 1 },
+		{ text: 'Bob post', userId: 2 },
+		{ text: 'Charlie post', userId: 3 },
+		{ text: 'David post', userId: 4 },
+		{ text: 'Eve post', userId: 5 },
+	]);
+
+	await expect((async () => {
+		return await db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.leftJoin(posts, eq(users.id, posts.userId), {
+				useIndex: ['some_other_index'],
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			));
+	})()).rejects.toThrowError();
+});
+
+test('MySqlTable :: select with join `use index` + `force index` incompatible hints', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex, postsTableTextIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+	const postsTableTextIndex = index('posts_text_index').on(posts.text);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+	await db.execute(sql`create index posts_text_index ON posts(text)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await db.insert(posts).values([
+		{ text: 'Alice post', userId: 1 },
+		{ text: 'Bob post', userId: 2 },
+		{ text: 'Charlie post', userId: 3 },
+		{ text: 'David post', userId: 4 },
+		{ text: 'Eve post', userId: 5 },
+	]);
+
+	await expect((async () => {
+		return await db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.leftJoin(posts, eq(users.id, posts.userId), {
+				useIndex: [postsTableUserIdIndex],
+				forceIndex: [postsTableTextIndex],
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			));
+	})()).rejects.toThrowError();
+});
+
+test('MySqlTable :: select with Subquery join `use index`', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	await db.insert(posts).values([
+		{ text: 'Alice post', userId: 1 },
+		{ text: 'Bob post', userId: 2 },
+		{ text: 'Charlie post', userId: 3 },
+		{ text: 'David post', userId: 4 },
+		{ text: 'Eve post', userId: 5 },
+	]);
+
+	const sq = db.select().from(posts, { useIndex: [postsTableUserIdIndex] }).where(eq(posts.userId, 1)).as('sq');
+
+	const result = await db.select({
+		userId: users.id,
+		name: users.name,
+		postId: sq.id,
+		text: sq.text,
+	})
+		.from(users)
+		.leftJoin(sq, eq(users.id, sq.userId))
+		.where(eq(users.name, 'Alice'));
+
+	expect(result).toHaveLength(1);
+	expect(result).toStrictEqual([{ userId: 1, name: 'Alice', postId: 1, text: 'Alice post' }]);
+});
+
+test('MySqlTable :: select with Subquery join with `use index` in join', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	const posts = mysqlTable('posts', {
+		id: serial('id').primaryKey(),
+		text: varchar('text', { length: 100 }).notNull(),
+		userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
+	}, () => [postsTableUserIdIndex]);
+	const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
+
+	await db.execute(sql`drop table if exists ${posts}`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`
+		create table ${posts} (
+			\`id\` serial primary key,
+			\`text\` varchar(100) not null,
+			\`user_id\` int not null references users(id) on delete cascade
+		)
+	`);
+	await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
+
+	const sq = db.select().from(posts).where(eq(posts.userId, 1)).as('sq');
+
+	const query = db.select({
+		userId: users.id,
+		name: users.name,
+		postId: sq.id,
+		text: sq.text,
+	})
+		.from(users)
+		// @ts-expect-error
+		.leftJoin(sq, eq(users.id, sq.userId, { useIndex: [postsTableUserIdIndex] }))
+		.where(eq(users.name, 'Alice'))
+		.toSQL();
+
+	expect(query.sql).not.toInclude('USE INDEX');
+});
+
+test('View :: select with `use index` hint', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	}, () => [usersTableNameIndex]);
+
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+
+	const usersView = mysqlView('users_view').as((qb) => qb.select().from(users));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+	await db.execute(sql`create view ${usersView} as select * from ${users}`);
+
+	// @ts-expect-error
+	const query = db.select().from(usersView, {
+		useIndex: [usersTableNameIndex],
+	}).toSQL();
+
+	expect(query.sql).not.toInclude('USE INDEX');
+
+	await db.execute(sql`drop view ${usersView}`);
+});
+
+test('Subquery :: select with `use index` hint', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+	}, () => [usersTableNameIndex]);
+	const usersTableNameIndex = index('users_name_index').on(users.name);
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`
+		create table ${users} (
+			\`id\` serial primary key,
+			\`name\` varchar(100) not null
+		)
+	`);
+	await db.execute(sql`create index users_name_index ON users(name)`);
+
+	const sq = db.select().from(users).as('sq');
+
+	// @ts-expect-error
+	const query = db.select().from(sq, {
+		useIndex: [usersTableNameIndex],
+	}).toSQL();
+
+	expect(query.sql).not.toInclude('USE INDEX');
+});
+
+test('sql operator as cte', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
+	await db.insert(users).values([
+		{ name: 'John' },
+		{ name: 'Jane' },
+	]);
+
+	const sq1 = db.$with('sq', {
+		userId: users.id,
+		data: {
+			name: users.name,
+		},
+	}).as(sql`select * from ${users} where ${users.name} = 'John'`);
+	const result1 = await db.with(sq1).select().from(sq1);
+
+	const sq2 = db.$with('sq', {
+		userId: users.id,
+		data: {
+			name: users.name,
+		},
+	}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+	const result2 = await db.with(sq2).select().from(sq1);
+
+	expect(result1).toStrictEqual([{ userId: 1, data: { name: 'John' } }]);
+	expect(result2).toStrictEqual([{ userId: 2, data: { name: 'Jane' } }]);
+});
+
+test('all types ~codecs~', async () => {
+	const db = drizzle({
+		client,
+		relations: defineRelations({ allTypesTable: allTypesCodecsTable }, (r) => ({
+			allTypesTable: {
+				self: r.many.allTypesTable({
+					from: r.allTypesTable.serial,
+					to: r.allTypesTable.serial,
+				}),
+			},
+		})),
+	});
+
+	await db.execute(sql`DROP TABLE IF EXISTS ${allTypesCodecsTable} CASCADE;`);
+	await db.execute(
+		sql`CREATE TABLE ${allTypesCodecsTable} (${
+			sql.join(
+				Object.values(getTableColumns(allTypesCodecsTable)).map((c) =>
+					sql`${sql.identifier(c.name)} ${sql.raw(c.getSQLType())}`
+				),
+				sql`, `,
+			)
+		})`,
+	);
+
+	type ExpectedType = {
+		serial: number;
+		bigint53: number;
+		bigint64: bigint;
+		bigintstr: string;
+		binary: string;
+		boolean: boolean;
+		char: string;
+		date: Date;
+		datestr: string;
+		datetime: Date;
+		datetimestr: string;
+		decimal: string;
+		decimalnum: number;
+		decimalbig: bigint;
+		double: number;
+		float: number;
+		int: number;
+		json1: unknown;
+		json2: unknown;
+		json3: unknown;
+		json4: unknown;
+		medint: number;
+		smallint: number;
+		real: number;
+		text: string;
+		tinytext: string;
+		mediumtext: string;
+		longtext: string;
+		time: string;
+		timestamp: Date;
+		timestampstr: string;
+		tinyint: number;
+		varbin: string;
+		varchar: string;
+		year: number;
+		enum: 'enV1' | 'enV2';
+		blob: Buffer;
+		tinyblob: Buffer;
+		mediumblob: Buffer;
+		longblob: Buffer;
+		stringblob: string;
+		stringtinyblob: string;
+		stringmediumblob: string;
+		stringlongblob: string;
+	};
+
+	const testData: ExpectedType = {
+		serial: 1,
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintstr: '5044565289845416380',
+		binary: '1',
+		boolean: true,
+		char: 'c',
+		date: new Date('2025-03-12'),
+		datestr: '2025-03-12',
+		datetime: new Date(1741743161623),
+		datetimestr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+		decimal: '47521',
+		decimalnum: 9007199254740991,
+		decimalbig: 5044565289845416380n,
+		double: 15.35325689124218,
+		enum: 'enV1',
+		float: 1.048596,
+		real: 1.048596,
+		text: 'C4-',
+		tinytext: 'tiny text',
+		mediumtext: 'medium text',
+		longtext: 'long text',
+		int: 621,
+		json1: { str: 'strval', arr: ['str', 10] },
+		json2: [{ key: 'value', num: 7 }, 'v', '11', 5],
+		json3: 5,
+		json4: '5',
+		medint: 560,
+		smallint: 14,
+		time: '04:13:22',
+		timestamp: new Date(1741743161623),
+		timestampstr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+		tinyint: 7,
+		varbin: '1010110101001101',
+		varchar: 'VCHAR',
+		year: 2025,
+		blob: Buffer.from('string'),
+		longblob: Buffer.from('string'),
+		mediumblob: Buffer.from('string'),
+		tinyblob: Buffer.from('string'),
+		stringblob: 'string',
+		stringlongblob: 'string',
+		stringmediumblob: 'string',
+		stringtinyblob: 'string',
+	};
+
+	await db.insert(allTypesCodecsTable).values(testData);
+
+	const session = (<any> db).session as MySqlAsyncSession;
+
+	const queryRes = await session.objects<ExpectedType>(
+		db.select(
+			Object.fromEntries(Object.entries(getTableColumns(allTypesCodecsTable)).map(([k, v]) => [k, v.as(v.name)])),
+		).from(allTypesCodecsTable).getSQL(),
+	).then((e) =>
+		normalizeDataWithDbCodecs({
+			db,
+			columns: getColumns(allTypesCodecsTable),
+			data: e,
+			mode: 'query',
+		})[0]
+	);
+
+	expect(queryRes).toStrictEqual(testData);
+
+	const { relationRes, rootRes } = await session.objects(
+		db.query.allTypesTable.findFirst({
+			with: {
+				self: true,
+			},
+		}).getSQL(),
+	).then((e) => {
+		const [{ self: relationRaw, ...rootRaw }] = e as [Record<string, any>];
+
+		return {
+			relationRes: normalizeDataWithDbCodecs({
+				db,
+				columns: getColumns(allTypesCodecsTable),
+				data: relationRaw,
+				mode: 'json',
+			})[0]!,
+			rootRes: normalizeDataWithDbCodecs({
+				db,
+				columns: getColumns(allTypesCodecsTable),
+				data: [rootRaw],
+				mode: 'query',
+			})[0]!,
+		};
+	});
+
+	expect(relationRes).toStrictEqual(testData);
+	expect(rootRes).toStrictEqual(testData);
+
+	// ---- numbers ----
+	expect(
+		await unionAll(
+			db.select({
+				'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+				'serial ∪ bigint53': allTypesCodecsTable.serial.as('serial ∪ bigint53'),
+				'serial ∪ decimalnum': allTypesCodecsTable.serial.as('serial ∪ decimalnum'),
+				'serial ∪ double': allTypesCodecsTable.serial.as('serial ∪ double'),
+				'serial ∪ float': allTypesCodecsTable.serial.as('serial ∪ float'),
+				'serial ∪ int': allTypesCodecsTable.serial.as('serial ∪ int'),
+				'serial ∪ medint': allTypesCodecsTable.serial.as('serial ∪ medint'),
+				'serial ∪ smallint': allTypesCodecsTable.serial.as('serial ∪ smallint'),
+				'serial ∪ real': allTypesCodecsTable.serial.as('serial ∪ real'),
+				'serial ∪ tinyint': allTypesCodecsTable.serial.as('serial ∪ tinyint'),
+				'serial ∪ year': allTypesCodecsTable.serial.as('serial ∪ year'),
+				'bigint53 ∪ serial': allTypesCodecsTable.bigint53.as('bigint53 ∪ serial'),
+				'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+				'bigint53 ∪ decimalnum': allTypesCodecsTable.bigint53.as('bigint53 ∪ decimalnum'),
+				'bigint53 ∪ double': allTypesCodecsTable.bigint53.as('bigint53 ∪ double'),
+				'bigint53 ∪ float': allTypesCodecsTable.bigint53.as('bigint53 ∪ float'),
+				'bigint53 ∪ int': allTypesCodecsTable.bigint53.as('bigint53 ∪ int'),
+				'bigint53 ∪ medint': allTypesCodecsTable.bigint53.as('bigint53 ∪ medint'),
+				'bigint53 ∪ smallint': allTypesCodecsTable.bigint53.as('bigint53 ∪ smallint'),
+				'bigint53 ∪ real': allTypesCodecsTable.bigint53.as('bigint53 ∪ real'),
+				'bigint53 ∪ tinyint': allTypesCodecsTable.bigint53.as('bigint53 ∪ tinyint'),
+				'bigint53 ∪ year': allTypesCodecsTable.bigint53.as('bigint53 ∪ year'),
+				'decimalnum ∪ serial': allTypesCodecsTable.decimalnum.as('decimalnum ∪ serial'),
+				'decimalnum ∪ bigint53': allTypesCodecsTable.decimalnum.as('decimalnum ∪ bigint53'),
+				'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+				'decimalnum ∪ double': allTypesCodecsTable.decimalnum.as('decimalnum ∪ double'),
+				'decimalnum ∪ float': allTypesCodecsTable.decimalnum.as('decimalnum ∪ float'),
+				'decimalnum ∪ int': allTypesCodecsTable.decimalnum.as('decimalnum ∪ int'),
+				'decimalnum ∪ medint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ medint'),
+				'decimalnum ∪ smallint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ smallint'),
+				'decimalnum ∪ real': allTypesCodecsTable.decimalnum.as('decimalnum ∪ real'),
+				'decimalnum ∪ tinyint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ tinyint'),
+				'decimalnum ∪ year': allTypesCodecsTable.decimalnum.as('decimalnum ∪ year'),
+				'double ∪ serial': allTypesCodecsTable.double.as('double ∪ serial'),
+				'double ∪ bigint53': allTypesCodecsTable.double.as('double ∪ bigint53'),
+				'double ∪ decimalnum': allTypesCodecsTable.double.as('double ∪ decimalnum'),
+				'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+				'double ∪ float': allTypesCodecsTable.double.as('double ∪ float'),
+				'double ∪ int': allTypesCodecsTable.double.as('double ∪ int'),
+				'double ∪ medint': allTypesCodecsTable.double.as('double ∪ medint'),
+				'double ∪ smallint': allTypesCodecsTable.double.as('double ∪ smallint'),
+				'double ∪ real': allTypesCodecsTable.double.as('double ∪ real'),
+				'double ∪ tinyint': allTypesCodecsTable.double.as('double ∪ tinyint'),
+				'double ∪ year': allTypesCodecsTable.double.as('double ∪ year'),
+				'float ∪ serial': allTypesCodecsTable.float.as('float ∪ serial'),
+				'float ∪ bigint53': allTypesCodecsTable.float.as('float ∪ bigint53'),
+				'float ∪ decimalnum': allTypesCodecsTable.float.as('float ∪ decimalnum'),
+				'float ∪ double': allTypesCodecsTable.float.as('float ∪ double'),
+				'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+				'float ∪ int': allTypesCodecsTable.float.as('float ∪ int'),
+				'float ∪ medint': allTypesCodecsTable.float.as('float ∪ medint'),
+				'float ∪ smallint': allTypesCodecsTable.float.as('float ∪ smallint'),
+				'float ∪ real': allTypesCodecsTable.float.as('float ∪ real'),
+				'float ∪ tinyint': allTypesCodecsTable.float.as('float ∪ tinyint'),
+				'float ∪ year': allTypesCodecsTable.float.as('float ∪ year'),
+				'int ∪ serial': allTypesCodecsTable.int.as('int ∪ serial'),
+				'int ∪ bigint53': allTypesCodecsTable.int.as('int ∪ bigint53'),
+				'int ∪ decimalnum': allTypesCodecsTable.int.as('int ∪ decimalnum'),
+				'int ∪ double': allTypesCodecsTable.int.as('int ∪ double'),
+				'int ∪ float': allTypesCodecsTable.int.as('int ∪ float'),
+				'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+				'int ∪ medint': allTypesCodecsTable.int.as('int ∪ medint'),
+				'int ∪ smallint': allTypesCodecsTable.int.as('int ∪ smallint'),
+				'int ∪ real': allTypesCodecsTable.int.as('int ∪ real'),
+				'int ∪ tinyint': allTypesCodecsTable.int.as('int ∪ tinyint'),
+				'int ∪ year': allTypesCodecsTable.int.as('int ∪ year'),
+				'medint ∪ serial': allTypesCodecsTable.medint.as('medint ∪ serial'),
+				'medint ∪ bigint53': allTypesCodecsTable.medint.as('medint ∪ bigint53'),
+				'medint ∪ decimalnum': allTypesCodecsTable.medint.as('medint ∪ decimalnum'),
+				'medint ∪ double': allTypesCodecsTable.medint.as('medint ∪ double'),
+				'medint ∪ float': allTypesCodecsTable.medint.as('medint ∪ float'),
+				'medint ∪ int': allTypesCodecsTable.medint.as('medint ∪ int'),
+				'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+				'medint ∪ smallint': allTypesCodecsTable.medint.as('medint ∪ smallint'),
+				'medint ∪ real': allTypesCodecsTable.medint.as('medint ∪ real'),
+				'medint ∪ tinyint': allTypesCodecsTable.medint.as('medint ∪ tinyint'),
+				'medint ∪ year': allTypesCodecsTable.medint.as('medint ∪ year'),
+				'smallint ∪ serial': allTypesCodecsTable.smallint.as('smallint ∪ serial'),
+				'smallint ∪ bigint53': allTypesCodecsTable.smallint.as('smallint ∪ bigint53'),
+				'smallint ∪ decimalnum': allTypesCodecsTable.smallint.as('smallint ∪ decimalnum'),
+				'smallint ∪ double': allTypesCodecsTable.smallint.as('smallint ∪ double'),
+				'smallint ∪ float': allTypesCodecsTable.smallint.as('smallint ∪ float'),
+				'smallint ∪ int': allTypesCodecsTable.smallint.as('smallint ∪ int'),
+				'smallint ∪ medint': allTypesCodecsTable.smallint.as('smallint ∪ medint'),
+				'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+				'smallint ∪ real': allTypesCodecsTable.smallint.as('smallint ∪ real'),
+				'smallint ∪ tinyint': allTypesCodecsTable.smallint.as('smallint ∪ tinyint'),
+				'smallint ∪ year': allTypesCodecsTable.smallint.as('smallint ∪ year'),
+				'real ∪ serial': allTypesCodecsTable.real.as('real ∪ serial'),
+				'real ∪ bigint53': allTypesCodecsTable.real.as('real ∪ bigint53'),
+				'real ∪ decimalnum': allTypesCodecsTable.real.as('real ∪ decimalnum'),
+				'real ∪ double': allTypesCodecsTable.real.as('real ∪ double'),
+				'real ∪ float': allTypesCodecsTable.real.as('real ∪ float'),
+				'real ∪ int': allTypesCodecsTable.real.as('real ∪ int'),
+				'real ∪ medint': allTypesCodecsTable.real.as('real ∪ medint'),
+				'real ∪ smallint': allTypesCodecsTable.real.as('real ∪ smallint'),
+				'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+				'real ∪ tinyint': allTypesCodecsTable.real.as('real ∪ tinyint'),
+				'real ∪ year': allTypesCodecsTable.real.as('real ∪ year'),
+				'tinyint ∪ serial': allTypesCodecsTable.tinyint.as('tinyint ∪ serial'),
+				'tinyint ∪ bigint53': allTypesCodecsTable.tinyint.as('tinyint ∪ bigint53'),
+				'tinyint ∪ decimalnum': allTypesCodecsTable.tinyint.as('tinyint ∪ decimalnum'),
+				'tinyint ∪ double': allTypesCodecsTable.tinyint.as('tinyint ∪ double'),
+				'tinyint ∪ float': allTypesCodecsTable.tinyint.as('tinyint ∪ float'),
+				'tinyint ∪ int': allTypesCodecsTable.tinyint.as('tinyint ∪ int'),
+				'tinyint ∪ medint': allTypesCodecsTable.tinyint.as('tinyint ∪ medint'),
+				'tinyint ∪ smallint': allTypesCodecsTable.tinyint.as('tinyint ∪ smallint'),
+				'tinyint ∪ real': allTypesCodecsTable.tinyint.as('tinyint ∪ real'),
+				'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+				'tinyint ∪ year': allTypesCodecsTable.tinyint.as('tinyint ∪ year'),
+				'year ∪ serial': allTypesCodecsTable.year.as('year ∪ serial'),
+				'year ∪ bigint53': allTypesCodecsTable.year.as('year ∪ bigint53'),
+				'year ∪ decimalnum': allTypesCodecsTable.year.as('year ∪ decimalnum'),
+				'year ∪ double': allTypesCodecsTable.year.as('year ∪ double'),
+				'year ∪ float': allTypesCodecsTable.year.as('year ∪ float'),
+				'year ∪ int': allTypesCodecsTable.year.as('year ∪ int'),
+				'year ∪ medint': allTypesCodecsTable.year.as('year ∪ medint'),
+				'year ∪ smallint': allTypesCodecsTable.year.as('year ∪ smallint'),
+				'year ∪ real': allTypesCodecsTable.year.as('year ∪ real'),
+				'year ∪ tinyint': allTypesCodecsTable.year.as('year ∪ tinyint'),
+				'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+				'serial ∪ bigint53': allTypesCodecsTable.bigint53.as('serial ∪ bigint53'),
+				'serial ∪ decimalnum': allTypesCodecsTable.decimalnum.as('serial ∪ decimalnum'),
+				'serial ∪ double': allTypesCodecsTable.double.as('serial ∪ double'),
+				'serial ∪ float': allTypesCodecsTable.float.as('serial ∪ float'),
+				'serial ∪ int': allTypesCodecsTable.int.as('serial ∪ int'),
+				'serial ∪ medint': allTypesCodecsTable.medint.as('serial ∪ medint'),
+				'serial ∪ smallint': allTypesCodecsTable.smallint.as('serial ∪ smallint'),
+				'serial ∪ real': allTypesCodecsTable.real.as('serial ∪ real'),
+				'serial ∪ tinyint': allTypesCodecsTable.tinyint.as('serial ∪ tinyint'),
+				'serial ∪ year': allTypesCodecsTable.year.as('serial ∪ year'),
+				'bigint53 ∪ serial': allTypesCodecsTable.serial.as('bigint53 ∪ serial'),
+				'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+				'bigint53 ∪ decimalnum': allTypesCodecsTable.decimalnum.as('bigint53 ∪ decimalnum'),
+				'bigint53 ∪ double': allTypesCodecsTable.double.as('bigint53 ∪ double'),
+				'bigint53 ∪ float': allTypesCodecsTable.float.as('bigint53 ∪ float'),
+				'bigint53 ∪ int': allTypesCodecsTable.int.as('bigint53 ∪ int'),
+				'bigint53 ∪ medint': allTypesCodecsTable.medint.as('bigint53 ∪ medint'),
+				'bigint53 ∪ smallint': allTypesCodecsTable.smallint.as('bigint53 ∪ smallint'),
+				'bigint53 ∪ real': allTypesCodecsTable.real.as('bigint53 ∪ real'),
+				'bigint53 ∪ tinyint': allTypesCodecsTable.tinyint.as('bigint53 ∪ tinyint'),
+				'bigint53 ∪ year': allTypesCodecsTable.year.as('bigint53 ∪ year'),
+				'decimalnum ∪ serial': allTypesCodecsTable.serial.as('decimalnum ∪ serial'),
+				'decimalnum ∪ bigint53': allTypesCodecsTable.bigint53.as('decimalnum ∪ bigint53'),
+				'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+				'decimalnum ∪ double': allTypesCodecsTable.double.as('decimalnum ∪ double'),
+				'decimalnum ∪ float': allTypesCodecsTable.float.as('decimalnum ∪ float'),
+				'decimalnum ∪ int': allTypesCodecsTable.int.as('decimalnum ∪ int'),
+				'decimalnum ∪ medint': allTypesCodecsTable.medint.as('decimalnum ∪ medint'),
+				'decimalnum ∪ smallint': allTypesCodecsTable.smallint.as('decimalnum ∪ smallint'),
+				'decimalnum ∪ real': allTypesCodecsTable.real.as('decimalnum ∪ real'),
+				'decimalnum ∪ tinyint': allTypesCodecsTable.tinyint.as('decimalnum ∪ tinyint'),
+				'decimalnum ∪ year': allTypesCodecsTable.year.as('decimalnum ∪ year'),
+				'double ∪ serial': allTypesCodecsTable.serial.as('double ∪ serial'),
+				'double ∪ bigint53': allTypesCodecsTable.bigint53.as('double ∪ bigint53'),
+				'double ∪ decimalnum': allTypesCodecsTable.decimalnum.as('double ∪ decimalnum'),
+				'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+				'double ∪ float': allTypesCodecsTable.float.as('double ∪ float'),
+				'double ∪ int': allTypesCodecsTable.int.as('double ∪ int'),
+				'double ∪ medint': allTypesCodecsTable.medint.as('double ∪ medint'),
+				'double ∪ smallint': allTypesCodecsTable.smallint.as('double ∪ smallint'),
+				'double ∪ real': allTypesCodecsTable.real.as('double ∪ real'),
+				'double ∪ tinyint': allTypesCodecsTable.tinyint.as('double ∪ tinyint'),
+				'double ∪ year': allTypesCodecsTable.year.as('double ∪ year'),
+				'float ∪ serial': allTypesCodecsTable.serial.as('float ∪ serial'),
+				'float ∪ bigint53': allTypesCodecsTable.bigint53.as('float ∪ bigint53'),
+				'float ∪ decimalnum': allTypesCodecsTable.decimalnum.as('float ∪ decimalnum'),
+				'float ∪ double': allTypesCodecsTable.double.as('float ∪ double'),
+				'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+				'float ∪ int': allTypesCodecsTable.int.as('float ∪ int'),
+				'float ∪ medint': allTypesCodecsTable.medint.as('float ∪ medint'),
+				'float ∪ smallint': allTypesCodecsTable.smallint.as('float ∪ smallint'),
+				'float ∪ real': allTypesCodecsTable.real.as('float ∪ real'),
+				'float ∪ tinyint': allTypesCodecsTable.tinyint.as('float ∪ tinyint'),
+				'float ∪ year': allTypesCodecsTable.year.as('float ∪ year'),
+				'int ∪ serial': allTypesCodecsTable.serial.as('int ∪ serial'),
+				'int ∪ bigint53': allTypesCodecsTable.bigint53.as('int ∪ bigint53'),
+				'int ∪ decimalnum': allTypesCodecsTable.decimalnum.as('int ∪ decimalnum'),
+				'int ∪ double': allTypesCodecsTable.double.as('int ∪ double'),
+				'int ∪ float': allTypesCodecsTable.float.as('int ∪ float'),
+				'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+				'int ∪ medint': allTypesCodecsTable.medint.as('int ∪ medint'),
+				'int ∪ smallint': allTypesCodecsTable.smallint.as('int ∪ smallint'),
+				'int ∪ real': allTypesCodecsTable.real.as('int ∪ real'),
+				'int ∪ tinyint': allTypesCodecsTable.tinyint.as('int ∪ tinyint'),
+				'int ∪ year': allTypesCodecsTable.year.as('int ∪ year'),
+				'medint ∪ serial': allTypesCodecsTable.serial.as('medint ∪ serial'),
+				'medint ∪ bigint53': allTypesCodecsTable.bigint53.as('medint ∪ bigint53'),
+				'medint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('medint ∪ decimalnum'),
+				'medint ∪ double': allTypesCodecsTable.double.as('medint ∪ double'),
+				'medint ∪ float': allTypesCodecsTable.float.as('medint ∪ float'),
+				'medint ∪ int': allTypesCodecsTable.int.as('medint ∪ int'),
+				'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+				'medint ∪ smallint': allTypesCodecsTable.smallint.as('medint ∪ smallint'),
+				'medint ∪ real': allTypesCodecsTable.real.as('medint ∪ real'),
+				'medint ∪ tinyint': allTypesCodecsTable.tinyint.as('medint ∪ tinyint'),
+				'medint ∪ year': allTypesCodecsTable.year.as('medint ∪ year'),
+				'smallint ∪ serial': allTypesCodecsTable.serial.as('smallint ∪ serial'),
+				'smallint ∪ bigint53': allTypesCodecsTable.bigint53.as('smallint ∪ bigint53'),
+				'smallint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('smallint ∪ decimalnum'),
+				'smallint ∪ double': allTypesCodecsTable.double.as('smallint ∪ double'),
+				'smallint ∪ float': allTypesCodecsTable.float.as('smallint ∪ float'),
+				'smallint ∪ int': allTypesCodecsTable.int.as('smallint ∪ int'),
+				'smallint ∪ medint': allTypesCodecsTable.medint.as('smallint ∪ medint'),
+				'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+				'smallint ∪ real': allTypesCodecsTable.real.as('smallint ∪ real'),
+				'smallint ∪ tinyint': allTypesCodecsTable.tinyint.as('smallint ∪ tinyint'),
+				'smallint ∪ year': allTypesCodecsTable.year.as('smallint ∪ year'),
+				'real ∪ serial': allTypesCodecsTable.serial.as('real ∪ serial'),
+				'real ∪ bigint53': allTypesCodecsTable.bigint53.as('real ∪ bigint53'),
+				'real ∪ decimalnum': allTypesCodecsTable.decimalnum.as('real ∪ decimalnum'),
+				'real ∪ double': allTypesCodecsTable.double.as('real ∪ double'),
+				'real ∪ float': allTypesCodecsTable.float.as('real ∪ float'),
+				'real ∪ int': allTypesCodecsTable.int.as('real ∪ int'),
+				'real ∪ medint': allTypesCodecsTable.medint.as('real ∪ medint'),
+				'real ∪ smallint': allTypesCodecsTable.smallint.as('real ∪ smallint'),
+				'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+				'real ∪ tinyint': allTypesCodecsTable.tinyint.as('real ∪ tinyint'),
+				'real ∪ year': allTypesCodecsTable.year.as('real ∪ year'),
+				'tinyint ∪ serial': allTypesCodecsTable.serial.as('tinyint ∪ serial'),
+				'tinyint ∪ bigint53': allTypesCodecsTable.bigint53.as('tinyint ∪ bigint53'),
+				'tinyint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('tinyint ∪ decimalnum'),
+				'tinyint ∪ double': allTypesCodecsTable.double.as('tinyint ∪ double'),
+				'tinyint ∪ float': allTypesCodecsTable.float.as('tinyint ∪ float'),
+				'tinyint ∪ int': allTypesCodecsTable.int.as('tinyint ∪ int'),
+				'tinyint ∪ medint': allTypesCodecsTable.medint.as('tinyint ∪ medint'),
+				'tinyint ∪ smallint': allTypesCodecsTable.smallint.as('tinyint ∪ smallint'),
+				'tinyint ∪ real': allTypesCodecsTable.real.as('tinyint ∪ real'),
+				'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+				'tinyint ∪ year': allTypesCodecsTable.year.as('tinyint ∪ year'),
+				'year ∪ serial': allTypesCodecsTable.serial.as('year ∪ serial'),
+				'year ∪ bigint53': allTypesCodecsTable.bigint53.as('year ∪ bigint53'),
+				'year ∪ decimalnum': allTypesCodecsTable.decimalnum.as('year ∪ decimalnum'),
+				'year ∪ double': allTypesCodecsTable.double.as('year ∪ double'),
+				'year ∪ float': allTypesCodecsTable.float.as('year ∪ float'),
+				'year ∪ int': allTypesCodecsTable.int.as('year ∪ int'),
+				'year ∪ medint': allTypesCodecsTable.medint.as('year ∪ medint'),
+				'year ∪ smallint': allTypesCodecsTable.smallint.as('year ∪ smallint'),
+				'year ∪ real': allTypesCodecsTable.real.as('year ∪ real'),
+				'year ∪ tinyint': allTypesCodecsTable.tinyint.as('year ∪ tinyint'),
+				'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'serial ∪ serial': 1,
+			'serial ∪ bigint53': 1,
+			'serial ∪ decimalnum': 1,
+			'serial ∪ double': 1,
+			'serial ∪ float': 1,
+			'serial ∪ int': 1,
+			'serial ∪ medint': 1,
+			'serial ∪ smallint': 1,
+			'serial ∪ real': 1,
+			'serial ∪ tinyint': 1,
+			'serial ∪ year': 1,
+			'bigint53 ∪ serial': 9007199254740991,
+			'bigint53 ∪ bigint53': 9007199254740991,
+			'bigint53 ∪ decimalnum': 9007199254740991,
+			'bigint53 ∪ double': 9007199254740991,
+			'bigint53 ∪ float': 9007199254740991,
+			'bigint53 ∪ int': 9007199254740991,
+			'bigint53 ∪ medint': 9007199254740991,
+			'bigint53 ∪ smallint': 9007199254740991,
+			'bigint53 ∪ real': 9007199254740991,
+			'bigint53 ∪ tinyint': 9007199254740991,
+			'bigint53 ∪ year': 9007199254740991,
+			'decimalnum ∪ serial': 9007199254740991,
+			'decimalnum ∪ bigint53': 9007199254740991,
+			'decimalnum ∪ decimalnum': 9007199254740991,
+			'decimalnum ∪ double': 9007199254740991,
+			'decimalnum ∪ float': 9007199254740991,
+			'decimalnum ∪ int': 9007199254740991,
+			'decimalnum ∪ medint': 9007199254740991,
+			'decimalnum ∪ smallint': 9007199254740991,
+			'decimalnum ∪ real': 9007199254740991,
+			'decimalnum ∪ tinyint': 9007199254740991,
+			'decimalnum ∪ year': 9007199254740991,
+			'double ∪ serial': 15.35325689124218,
+			'double ∪ bigint53': 15.35325689124218,
+			'double ∪ decimalnum': 15.35325689124218,
+			'double ∪ double': 15.35325689124218,
+			'double ∪ float': 15.35325689124218,
+			'double ∪ int': 15.35325689124218,
+			'double ∪ medint': 15.35325689124218,
+			'double ∪ smallint': 15.35325689124218,
+			'double ∪ real': 15.35325689124218,
+			'double ∪ tinyint': 15.35325689124218,
+			'double ∪ year': 15.35325689124218,
+			'float ∪ serial': 1.048596,
+			'float ∪ bigint53': 1.048596,
+			'float ∪ decimalnum': 1.0485960245132446,
+			'float ∪ double': 1.0485960245132446,
+			'float ∪ float': 1.048596,
+			'float ∪ int': 1.0485960245132446,
+			'float ∪ medint': 1.048596,
+			'float ∪ smallint': 1.048596,
+			'float ∪ real': 1.0485960245132446,
+			'float ∪ tinyint': 1.048596,
+			'float ∪ year': 1.048596,
+			'int ∪ serial': 621,
+			'int ∪ bigint53': 621,
+			'int ∪ decimalnum': 621,
+			'int ∪ double': 621,
+			'int ∪ float': 621,
+			'int ∪ int': 621,
+			'int ∪ medint': 621,
+			'int ∪ smallint': 621,
+			'int ∪ real': 621,
+			'int ∪ tinyint': 621,
+			'int ∪ year': 621,
+			'medint ∪ serial': 560,
+			'medint ∪ bigint53': 560,
+			'medint ∪ decimalnum': 560,
+			'medint ∪ double': 560,
+			'medint ∪ float': 560,
+			'medint ∪ int': 560,
+			'medint ∪ medint': 560,
+			'medint ∪ smallint': 560,
+			'medint ∪ real': 560,
+			'medint ∪ tinyint': 560,
+			'medint ∪ year': 560,
+			'smallint ∪ serial': 14,
+			'smallint ∪ bigint53': 14,
+			'smallint ∪ decimalnum': 14,
+			'smallint ∪ double': 14,
+			'smallint ∪ float': 14,
+			'smallint ∪ int': 14,
+			'smallint ∪ medint': 14,
+			'smallint ∪ smallint': 14,
+			'smallint ∪ real': 14,
+			'smallint ∪ tinyint': 14,
+			'smallint ∪ year': 14,
+			'real ∪ serial': 1.048596,
+			'real ∪ bigint53': 1.048596,
+			'real ∪ decimalnum': 1.048596,
+			'real ∪ double': 1.048596,
+			'real ∪ float': 1.048596,
+			'real ∪ int': 1.048596,
+			'real ∪ medint': 1.048596,
+			'real ∪ smallint': 1.048596,
+			'real ∪ real': 1.048596,
+			'real ∪ tinyint': 1.048596,
+			'real ∪ year': 1.048596,
+			'tinyint ∪ serial': 7,
+			'tinyint ∪ bigint53': 7,
+			'tinyint ∪ decimalnum': 7,
+			'tinyint ∪ double': 7,
+			'tinyint ∪ float': 7,
+			'tinyint ∪ int': 7,
+			'tinyint ∪ medint': 7,
+			'tinyint ∪ smallint': 7,
+			'tinyint ∪ real': 7,
+			'tinyint ∪ tinyint': 7,
+			'tinyint ∪ year': 7,
+			'year ∪ serial': 2025,
+			'year ∪ bigint53': 2025,
+			'year ∪ decimalnum': 2025,
+			'year ∪ double': 2025,
+			'year ∪ float': 2025,
+			'year ∪ int': 2025,
+			'year ∪ medint': 2025,
+			'year ∪ smallint': 2025,
+			'year ∪ real': 2025,
+			'year ∪ tinyint': 127,
+			'year ∪ year': 2025,
+		},
+		{
+			'serial ∪ serial': 1,
+			'serial ∪ bigint53': 9007199254740991,
+			'serial ∪ decimalnum': 9007199254740991,
+			'serial ∪ double': 15.35325689124218,
+			'serial ∪ float': 1.0485960245132446,
+			'serial ∪ int': 621,
+			'serial ∪ medint': 560,
+			'serial ∪ smallint': 14,
+			'serial ∪ real': 1.048596,
+			'serial ∪ tinyint': 7,
+			'serial ∪ year': 2025,
+			'bigint53 ∪ serial': 1,
+			'bigint53 ∪ bigint53': 9007199254740991,
+			'bigint53 ∪ decimalnum': 9007199254740991,
+			'bigint53 ∪ double': 15.35325689124218,
+			'bigint53 ∪ float': 1.0485960245132446,
+			'bigint53 ∪ int': 621,
+			'bigint53 ∪ medint': 560,
+			'bigint53 ∪ smallint': 14,
+			'bigint53 ∪ real': 1.048596,
+			'bigint53 ∪ tinyint': 7,
+			'bigint53 ∪ year': 2025,
+			'decimalnum ∪ serial': 1,
+			'decimalnum ∪ bigint53': 9007199254740991,
+			'decimalnum ∪ decimalnum': 9007199254740991,
+			'decimalnum ∪ double': 15.35325689124218,
+			'decimalnum ∪ float': 1.0485960245132446,
+			'decimalnum ∪ int': 621,
+			'decimalnum ∪ medint': 560,
+			'decimalnum ∪ smallint': 14,
+			'decimalnum ∪ real': 1.048596,
+			'decimalnum ∪ tinyint': 7,
+			'decimalnum ∪ year': 2025,
+			'double ∪ serial': 1,
+			'double ∪ bigint53': 9007199254740991,
+			'double ∪ decimalnum': 9007199254740991,
+			'double ∪ double': 15.35325689124218,
+			'double ∪ float': 1.0485960245132446,
+			'double ∪ int': 621,
+			'double ∪ medint': 560,
+			'double ∪ smallint': 14,
+			'double ∪ real': 1.048596,
+			'double ∪ tinyint': 7,
+			'double ∪ year': 2025,
+			'float ∪ serial': 1,
+			'float ∪ bigint53': 9007199000000000,
+			'float ∪ decimalnum': 9007199254740991,
+			'float ∪ double': 15.35325689124218,
+			'float ∪ float': 1.048596,
+			'float ∪ int': 621,
+			'float ∪ medint': 560,
+			'float ∪ smallint': 14,
+			'float ∪ real': 1.048596,
+			'float ∪ tinyint': 7,
+			'float ∪ year': 2025,
+			'int ∪ serial': 1,
+			'int ∪ bigint53': 9007199254740991,
+			'int ∪ decimalnum': 9007199254740991,
+			'int ∪ double': 15.35325689124218,
+			'int ∪ float': 1.0485960245132446,
+			'int ∪ int': 621,
+			'int ∪ medint': 560,
+			'int ∪ smallint': 14,
+			'int ∪ real': 1.048596,
+			'int ∪ tinyint': 7,
+			'int ∪ year': 2025,
+			'medint ∪ serial': 1,
+			'medint ∪ bigint53': 9007199254740991,
+			'medint ∪ decimalnum': 9007199254740991,
+			'medint ∪ double': 15.35325689124218,
+			'medint ∪ float': 1.048596,
+			'medint ∪ int': 621,
+			'medint ∪ medint': 560,
+			'medint ∪ smallint': 14,
+			'medint ∪ real': 1.048596,
+			'medint ∪ tinyint': 7,
+			'medint ∪ year': 2025,
+			'smallint ∪ serial': 1,
+			'smallint ∪ bigint53': 9007199254740991,
+			'smallint ∪ decimalnum': 9007199254740991,
+			'smallint ∪ double': 15.35325689124218,
+			'smallint ∪ float': 1.048596,
+			'smallint ∪ int': 621,
+			'smallint ∪ medint': 560,
+			'smallint ∪ smallint': 14,
+			'smallint ∪ real': 1.048596,
+			'smallint ∪ tinyint': 7,
+			'smallint ∪ year': 2025,
+			'real ∪ serial': 1,
+			'real ∪ bigint53': 9007199254740991,
+			'real ∪ decimalnum': 9007199254740991,
+			'real ∪ double': 15.35325689124218,
+			'real ∪ float': 1.0485960245132446,
+			'real ∪ int': 621,
+			'real ∪ medint': 560,
+			'real ∪ smallint': 14,
+			'real ∪ real': 1.048596,
+			'real ∪ tinyint': 7,
+			'real ∪ year': 2025,
+			'tinyint ∪ serial': 1,
+			'tinyint ∪ bigint53': 9007199254740991,
+			'tinyint ∪ decimalnum': 9007199254740991,
+			'tinyint ∪ double': 15.35325689124218,
+			'tinyint ∪ float': 1.048596,
+			'tinyint ∪ int': 621,
+			'tinyint ∪ medint': 560,
+			'tinyint ∪ smallint': 14,
+			'tinyint ∪ real': 1.048596,
+			'tinyint ∪ tinyint': 7,
+			'tinyint ∪ year': 127,
+			'year ∪ serial': 1,
+			'year ∪ bigint53': 9007199254740991,
+			'year ∪ decimalnum': 9007199254740991,
+			'year ∪ double': 15.35325689124218,
+			'year ∪ float': 1.048596,
+			'year ∪ int': 621,
+			'year ∪ medint': 560,
+			'year ∪ smallint': 14,
+			'year ∪ real': 1.048596,
+			'year ∪ tinyint': 7,
+			'year ∪ year': 2025,
+		},
+	]));
+
+	// ---- strings ----
+	expect(
+		await unionAll(
+			db.select({
+				'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+				'bigintstr ∪ char': allTypesCodecsTable.bigintstr.as('bigintstr ∪ char'),
+				'bigintstr ∪ decimal': allTypesCodecsTable.bigintstr.as('bigintstr ∪ decimal'),
+				'bigintstr ∪ text': allTypesCodecsTable.bigintstr.as('bigintstr ∪ text'),
+				'bigintstr ∪ tinytext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ tinytext'),
+				'bigintstr ∪ mediumtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ mediumtext'),
+				'bigintstr ∪ longtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ longtext'),
+				'bigintstr ∪ varchar': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varchar'),
+				'bigintstr ∪ varbin': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varbin'),
+				'bigintstr ∪ stringblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringblob'),
+				'bigintstr ∪ stringtinyblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringtinyblob'),
+				'bigintstr ∪ stringmediumblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringmediumblob'),
+				'bigintstr ∪ stringlongblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringlongblob'),
+				'bigintstr ∪ datestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datestr'),
+				'bigintstr ∪ datetimestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datetimestr'),
+				'bigintstr ∪ timestampstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ timestampstr'),
+				'bigintstr ∪ time': allTypesCodecsTable.bigintstr.as('bigintstr ∪ time'),
+				'char ∪ bigintstr': allTypesCodecsTable.char.as('char ∪ bigintstr'),
+				'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+				'char ∪ decimal': allTypesCodecsTable.char.as('char ∪ decimal'),
+				'char ∪ text': allTypesCodecsTable.char.as('char ∪ text'),
+				'char ∪ tinytext': allTypesCodecsTable.char.as('char ∪ tinytext'),
+				'char ∪ mediumtext': allTypesCodecsTable.char.as('char ∪ mediumtext'),
+				'char ∪ longtext': allTypesCodecsTable.char.as('char ∪ longtext'),
+				'char ∪ varchar': allTypesCodecsTable.char.as('char ∪ varchar'),
+				'char ∪ varbin': allTypesCodecsTable.char.as('char ∪ varbin'),
+				'char ∪ stringblob': allTypesCodecsTable.char.as('char ∪ stringblob'),
+				'char ∪ stringtinyblob': allTypesCodecsTable.char.as('char ∪ stringtinyblob'),
+				'char ∪ stringmediumblob': allTypesCodecsTable.char.as('char ∪ stringmediumblob'),
+				'char ∪ stringlongblob': allTypesCodecsTable.char.as('char ∪ stringlongblob'),
+				'char ∪ datestr': allTypesCodecsTable.char.as('char ∪ datestr'),
+				'char ∪ datetimestr': allTypesCodecsTable.char.as('char ∪ datetimestr'),
+				'char ∪ timestampstr': allTypesCodecsTable.char.as('char ∪ timestampstr'),
+				'char ∪ time': allTypesCodecsTable.char.as('char ∪ time'),
+				'decimal ∪ bigintstr': allTypesCodecsTable.decimal.as('decimal ∪ bigintstr'),
+				'decimal ∪ char': allTypesCodecsTable.decimal.as('decimal ∪ char'),
+				'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+				'decimal ∪ text': allTypesCodecsTable.decimal.as('decimal ∪ text'),
+				'decimal ∪ tinytext': allTypesCodecsTable.decimal.as('decimal ∪ tinytext'),
+				'decimal ∪ mediumtext': allTypesCodecsTable.decimal.as('decimal ∪ mediumtext'),
+				'decimal ∪ longtext': allTypesCodecsTable.decimal.as('decimal ∪ longtext'),
+				'decimal ∪ varchar': allTypesCodecsTable.decimal.as('decimal ∪ varchar'),
+				'decimal ∪ varbin': allTypesCodecsTable.decimal.as('decimal ∪ varbin'),
+				'decimal ∪ stringblob': allTypesCodecsTable.decimal.as('decimal ∪ stringblob'),
+				'decimal ∪ stringtinyblob': allTypesCodecsTable.decimal.as('decimal ∪ stringtinyblob'),
+				'decimal ∪ stringmediumblob': allTypesCodecsTable.decimal.as('decimal ∪ stringmediumblob'),
+				'decimal ∪ stringlongblob': allTypesCodecsTable.decimal.as('decimal ∪ stringlongblob'),
+				'decimal ∪ datestr': allTypesCodecsTable.decimal.as('decimal ∪ datestr'),
+				'decimal ∪ datetimestr': allTypesCodecsTable.decimal.as('decimal ∪ datetimestr'),
+				'decimal ∪ timestampstr': allTypesCodecsTable.decimal.as('decimal ∪ timestampstr'),
+				'decimal ∪ time': allTypesCodecsTable.decimal.as('decimal ∪ time'),
+				'text ∪ bigintstr': allTypesCodecsTable.text.as('text ∪ bigintstr'),
+				'text ∪ char': allTypesCodecsTable.text.as('text ∪ char'),
+				'text ∪ decimal': allTypesCodecsTable.text.as('text ∪ decimal'),
+				'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+				'text ∪ tinytext': allTypesCodecsTable.text.as('text ∪ tinytext'),
+				'text ∪ mediumtext': allTypesCodecsTable.text.as('text ∪ mediumtext'),
+				'text ∪ longtext': allTypesCodecsTable.text.as('text ∪ longtext'),
+				'text ∪ varchar': allTypesCodecsTable.text.as('text ∪ varchar'),
+				'text ∪ varbin': allTypesCodecsTable.text.as('text ∪ varbin'),
+				'text ∪ stringblob': allTypesCodecsTable.text.as('text ∪ stringblob'),
+				'text ∪ stringtinyblob': allTypesCodecsTable.text.as('text ∪ stringtinyblob'),
+				'text ∪ stringmediumblob': allTypesCodecsTable.text.as('text ∪ stringmediumblob'),
+				'text ∪ stringlongblob': allTypesCodecsTable.text.as('text ∪ stringlongblob'),
+				'text ∪ datestr': allTypesCodecsTable.text.as('text ∪ datestr'),
+				'text ∪ datetimestr': allTypesCodecsTable.text.as('text ∪ datetimestr'),
+				'text ∪ timestampstr': allTypesCodecsTable.text.as('text ∪ timestampstr'),
+				'text ∪ time': allTypesCodecsTable.text.as('text ∪ time'),
+				'tinytext ∪ bigintstr': allTypesCodecsTable.tinytext.as('tinytext ∪ bigintstr'),
+				'tinytext ∪ char': allTypesCodecsTable.tinytext.as('tinytext ∪ char'),
+				'tinytext ∪ decimal': allTypesCodecsTable.tinytext.as('tinytext ∪ decimal'),
+				'tinytext ∪ text': allTypesCodecsTable.tinytext.as('tinytext ∪ text'),
+				'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+				'tinytext ∪ mediumtext': allTypesCodecsTable.tinytext.as('tinytext ∪ mediumtext'),
+				'tinytext ∪ longtext': allTypesCodecsTable.tinytext.as('tinytext ∪ longtext'),
+				'tinytext ∪ varchar': allTypesCodecsTable.tinytext.as('tinytext ∪ varchar'),
+				'tinytext ∪ varbin': allTypesCodecsTable.tinytext.as('tinytext ∪ varbin'),
+				'tinytext ∪ stringblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringblob'),
+				'tinytext ∪ stringtinyblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringtinyblob'),
+				'tinytext ∪ stringmediumblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringmediumblob'),
+				'tinytext ∪ stringlongblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringlongblob'),
+				'tinytext ∪ datestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datestr'),
+				'tinytext ∪ datetimestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datetimestr'),
+				'tinytext ∪ timestampstr': allTypesCodecsTable.tinytext.as('tinytext ∪ timestampstr'),
+				'tinytext ∪ time': allTypesCodecsTable.tinytext.as('tinytext ∪ time'),
+				'mediumtext ∪ bigintstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ bigintstr'),
+				'mediumtext ∪ char': allTypesCodecsTable.mediumtext.as('mediumtext ∪ char'),
+				'mediumtext ∪ decimal': allTypesCodecsTable.mediumtext.as('mediumtext ∪ decimal'),
+				'mediumtext ∪ text': allTypesCodecsTable.mediumtext.as('mediumtext ∪ text'),
+				'mediumtext ∪ tinytext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ tinytext'),
+				'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+				'mediumtext ∪ longtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ longtext'),
+				'mediumtext ∪ varchar': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varchar'),
+				'mediumtext ∪ varbin': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varbin'),
+				'mediumtext ∪ stringblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringblob'),
+				'mediumtext ∪ stringtinyblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringtinyblob'),
+				'mediumtext ∪ stringmediumblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringmediumblob'),
+				'mediumtext ∪ stringlongblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringlongblob'),
+				'mediumtext ∪ datestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datestr'),
+				'mediumtext ∪ datetimestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datetimestr'),
+				'mediumtext ∪ timestampstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ timestampstr'),
+				'mediumtext ∪ time': allTypesCodecsTable.mediumtext.as('mediumtext ∪ time'),
+				'longtext ∪ bigintstr': allTypesCodecsTable.longtext.as('longtext ∪ bigintstr'),
+				'longtext ∪ char': allTypesCodecsTable.longtext.as('longtext ∪ char'),
+				'longtext ∪ decimal': allTypesCodecsTable.longtext.as('longtext ∪ decimal'),
+				'longtext ∪ text': allTypesCodecsTable.longtext.as('longtext ∪ text'),
+				'longtext ∪ tinytext': allTypesCodecsTable.longtext.as('longtext ∪ tinytext'),
+				'longtext ∪ mediumtext': allTypesCodecsTable.longtext.as('longtext ∪ mediumtext'),
+				'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+				'longtext ∪ varchar': allTypesCodecsTable.longtext.as('longtext ∪ varchar'),
+				'longtext ∪ varbin': allTypesCodecsTable.longtext.as('longtext ∪ varbin'),
+				'longtext ∪ stringblob': allTypesCodecsTable.longtext.as('longtext ∪ stringblob'),
+				'longtext ∪ stringtinyblob': allTypesCodecsTable.longtext.as('longtext ∪ stringtinyblob'),
+				'longtext ∪ stringmediumblob': allTypesCodecsTable.longtext.as('longtext ∪ stringmediumblob'),
+				'longtext ∪ stringlongblob': allTypesCodecsTable.longtext.as('longtext ∪ stringlongblob'),
+				'longtext ∪ datestr': allTypesCodecsTable.longtext.as('longtext ∪ datestr'),
+				'longtext ∪ datetimestr': allTypesCodecsTable.longtext.as('longtext ∪ datetimestr'),
+				'longtext ∪ timestampstr': allTypesCodecsTable.longtext.as('longtext ∪ timestampstr'),
+				'longtext ∪ time': allTypesCodecsTable.longtext.as('longtext ∪ time'),
+				'varchar ∪ bigintstr': allTypesCodecsTable.varchar.as('varchar ∪ bigintstr'),
+				'varchar ∪ char': allTypesCodecsTable.varchar.as('varchar ∪ char'),
+				'varchar ∪ decimal': allTypesCodecsTable.varchar.as('varchar ∪ decimal'),
+				'varchar ∪ text': allTypesCodecsTable.varchar.as('varchar ∪ text'),
+				'varchar ∪ tinytext': allTypesCodecsTable.varchar.as('varchar ∪ tinytext'),
+				'varchar ∪ mediumtext': allTypesCodecsTable.varchar.as('varchar ∪ mediumtext'),
+				'varchar ∪ longtext': allTypesCodecsTable.varchar.as('varchar ∪ longtext'),
+				'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+				'varchar ∪ varbin': allTypesCodecsTable.varchar.as('varchar ∪ varbin'),
+				'varchar ∪ stringblob': allTypesCodecsTable.varchar.as('varchar ∪ stringblob'),
+				'varchar ∪ stringtinyblob': allTypesCodecsTable.varchar.as('varchar ∪ stringtinyblob'),
+				'varchar ∪ stringmediumblob': allTypesCodecsTable.varchar.as('varchar ∪ stringmediumblob'),
+				'varchar ∪ stringlongblob': allTypesCodecsTable.varchar.as('varchar ∪ stringlongblob'),
+				'varchar ∪ datestr': allTypesCodecsTable.varchar.as('varchar ∪ datestr'),
+				'varchar ∪ datetimestr': allTypesCodecsTable.varchar.as('varchar ∪ datetimestr'),
+				'varchar ∪ timestampstr': allTypesCodecsTable.varchar.as('varchar ∪ timestampstr'),
+				'varchar ∪ time': allTypesCodecsTable.varchar.as('varchar ∪ time'),
+				'varbin ∪ bigintstr': allTypesCodecsTable.varbin.as('varbin ∪ bigintstr'),
+				'varbin ∪ char': allTypesCodecsTable.varbin.as('varbin ∪ char'),
+				'varbin ∪ decimal': allTypesCodecsTable.varbin.as('varbin ∪ decimal'),
+				'varbin ∪ text': allTypesCodecsTable.varbin.as('varbin ∪ text'),
+				'varbin ∪ tinytext': allTypesCodecsTable.varbin.as('varbin ∪ tinytext'),
+				'varbin ∪ mediumtext': allTypesCodecsTable.varbin.as('varbin ∪ mediumtext'),
+				'varbin ∪ longtext': allTypesCodecsTable.varbin.as('varbin ∪ longtext'),
+				'varbin ∪ varchar': allTypesCodecsTable.varbin.as('varbin ∪ varchar'),
+				'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+				'varbin ∪ stringblob': allTypesCodecsTable.varbin.as('varbin ∪ stringblob'),
+				'varbin ∪ stringtinyblob': allTypesCodecsTable.varbin.as('varbin ∪ stringtinyblob'),
+				'varbin ∪ stringmediumblob': allTypesCodecsTable.varbin.as('varbin ∪ stringmediumblob'),
+				'varbin ∪ stringlongblob': allTypesCodecsTable.varbin.as('varbin ∪ stringlongblob'),
+				'varbin ∪ datestr': allTypesCodecsTable.varbin.as('varbin ∪ datestr'),
+				'varbin ∪ datetimestr': allTypesCodecsTable.varbin.as('varbin ∪ datetimestr'),
+				'varbin ∪ timestampstr': allTypesCodecsTable.varbin.as('varbin ∪ timestampstr'),
+				'varbin ∪ time': allTypesCodecsTable.varbin.as('varbin ∪ time'),
+				'stringblob ∪ bigintstr': allTypesCodecsTable.stringblob.as('stringblob ∪ bigintstr'),
+				'stringblob ∪ char': allTypesCodecsTable.stringblob.as('stringblob ∪ char'),
+				'stringblob ∪ decimal': allTypesCodecsTable.stringblob.as('stringblob ∪ decimal'),
+				'stringblob ∪ text': allTypesCodecsTable.stringblob.as('stringblob ∪ text'),
+				'stringblob ∪ tinytext': allTypesCodecsTable.stringblob.as('stringblob ∪ tinytext'),
+				'stringblob ∪ mediumtext': allTypesCodecsTable.stringblob.as('stringblob ∪ mediumtext'),
+				'stringblob ∪ longtext': allTypesCodecsTable.stringblob.as('stringblob ∪ longtext'),
+				'stringblob ∪ varchar': allTypesCodecsTable.stringblob.as('stringblob ∪ varchar'),
+				'stringblob ∪ varbin': allTypesCodecsTable.stringblob.as('stringblob ∪ varbin'),
+				'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+				'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringtinyblob'),
+				'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringmediumblob'),
+				'stringblob ∪ stringlongblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringlongblob'),
+				'stringblob ∪ datestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datestr'),
+				'stringblob ∪ datetimestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datetimestr'),
+				'stringblob ∪ timestampstr': allTypesCodecsTable.stringblob.as('stringblob ∪ timestampstr'),
+				'stringblob ∪ time': allTypesCodecsTable.stringblob.as('stringblob ∪ time'),
+				'stringtinyblob ∪ bigintstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ bigintstr'),
+				'stringtinyblob ∪ char': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ char'),
+				'stringtinyblob ∪ decimal': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ decimal'),
+				'stringtinyblob ∪ text': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ text'),
+				'stringtinyblob ∪ tinytext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ tinytext'),
+				'stringtinyblob ∪ mediumtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ mediumtext'),
+				'stringtinyblob ∪ longtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ longtext'),
+				'stringtinyblob ∪ varchar': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varchar'),
+				'stringtinyblob ∪ varbin': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varbin'),
+				'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringblob'),
+				'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringtinyblob'),
+				'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringmediumblob'),
+				'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringlongblob'),
+				'stringtinyblob ∪ datestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datestr'),
+				'stringtinyblob ∪ datetimestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datetimestr'),
+				'stringtinyblob ∪ timestampstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ timestampstr'),
+				'stringtinyblob ∪ time': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ time'),
+				'stringmediumblob ∪ bigintstr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ bigintstr'),
+				'stringmediumblob ∪ char': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ char'),
+				'stringmediumblob ∪ decimal': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ decimal'),
+				'stringmediumblob ∪ text': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ text'),
+				'stringmediumblob ∪ tinytext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ tinytext'),
+				'stringmediumblob ∪ mediumtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ mediumtext'),
+				'stringmediumblob ∪ longtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ longtext'),
+				'stringmediumblob ∪ varchar': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varchar'),
+				'stringmediumblob ∪ varbin': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varbin'),
+				'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ stringblob'),
+				'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringmediumblob ∪ stringtinyblob',
+				),
+				'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringmediumblob ∪ stringmediumblob',
+				),
+				'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringmediumblob ∪ stringlongblob',
+				),
+				'stringmediumblob ∪ datestr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ datestr'),
+				'stringmediumblob ∪ datetimestr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ datetimestr'),
+				'stringmediumblob ∪ timestampstr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ timestampstr'),
+				'stringmediumblob ∪ time': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ time'),
+				'stringlongblob ∪ bigintstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ bigintstr'),
+				'stringlongblob ∪ char': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ char'),
+				'stringlongblob ∪ decimal': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ decimal'),
+				'stringlongblob ∪ text': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ text'),
+				'stringlongblob ∪ tinytext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ tinytext'),
+				'stringlongblob ∪ mediumtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ mediumtext'),
+				'stringlongblob ∪ longtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ longtext'),
+				'stringlongblob ∪ varchar': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varchar'),
+				'stringlongblob ∪ varbin': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varbin'),
+				'stringlongblob ∪ stringblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringblob'),
+				'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringtinyblob'),
+				'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringmediumblob'),
+				'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringlongblob'),
+				'stringlongblob ∪ datestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datestr'),
+				'stringlongblob ∪ datetimestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datetimestr'),
+				'stringlongblob ∪ timestampstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ timestampstr'),
+				'stringlongblob ∪ time': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ time'),
+				'datestr ∪ bigintstr': allTypesCodecsTable.datestr.as('datestr ∪ bigintstr'),
+				'datestr ∪ char': allTypesCodecsTable.datestr.as('datestr ∪ char'),
+				'datestr ∪ decimal': allTypesCodecsTable.datestr.as('datestr ∪ decimal'),
+				'datestr ∪ text': allTypesCodecsTable.datestr.as('datestr ∪ text'),
+				'datestr ∪ tinytext': allTypesCodecsTable.datestr.as('datestr ∪ tinytext'),
+				'datestr ∪ mediumtext': allTypesCodecsTable.datestr.as('datestr ∪ mediumtext'),
+				'datestr ∪ longtext': allTypesCodecsTable.datestr.as('datestr ∪ longtext'),
+				'datestr ∪ varchar': allTypesCodecsTable.datestr.as('datestr ∪ varchar'),
+				'datestr ∪ varbin': allTypesCodecsTable.datestr.as('datestr ∪ varbin'),
+				'datestr ∪ stringblob': allTypesCodecsTable.datestr.as('datestr ∪ stringblob'),
+				'datestr ∪ stringtinyblob': allTypesCodecsTable.datestr.as('datestr ∪ stringtinyblob'),
+				'datestr ∪ stringmediumblob': allTypesCodecsTable.datestr.as('datestr ∪ stringmediumblob'),
+				'datestr ∪ stringlongblob': allTypesCodecsTable.datestr.as('datestr ∪ stringlongblob'),
+				'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+				'datestr ∪ datetimestr': allTypesCodecsTable.datestr.as('datestr ∪ datetimestr'),
+				'datestr ∪ timestampstr': allTypesCodecsTable.datestr.as('datestr ∪ timestampstr'),
+				'datetimestr ∪ bigintstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ bigintstr'),
+				'datetimestr ∪ char': allTypesCodecsTable.datetimestr.as('datetimestr ∪ char'),
+				'datetimestr ∪ decimal': allTypesCodecsTable.datetimestr.as('datetimestr ∪ decimal'),
+				'datetimestr ∪ text': allTypesCodecsTable.datetimestr.as('datetimestr ∪ text'),
+				'datetimestr ∪ tinytext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ tinytext'),
+				'datetimestr ∪ mediumtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ mediumtext'),
+				'datetimestr ∪ longtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ longtext'),
+				'datetimestr ∪ varchar': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varchar'),
+				'datetimestr ∪ varbin': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varbin'),
+				'datetimestr ∪ stringblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringblob'),
+				'datetimestr ∪ stringtinyblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringtinyblob'),
+				'datetimestr ∪ stringmediumblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringmediumblob'),
+				'datetimestr ∪ stringlongblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringlongblob'),
+				'datetimestr ∪ datestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datestr'),
+				'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+				'datetimestr ∪ timestampstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ timestampstr'),
+				'timestampstr ∪ bigintstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ bigintstr'),
+				'timestampstr ∪ char': allTypesCodecsTable.timestampstr.as('timestampstr ∪ char'),
+				'timestampstr ∪ decimal': allTypesCodecsTable.timestampstr.as('timestampstr ∪ decimal'),
+				'timestampstr ∪ text': allTypesCodecsTable.timestampstr.as('timestampstr ∪ text'),
+				'timestampstr ∪ tinytext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ tinytext'),
+				'timestampstr ∪ mediumtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ mediumtext'),
+				'timestampstr ∪ longtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ longtext'),
+				'timestampstr ∪ varchar': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varchar'),
+				'timestampstr ∪ varbin': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varbin'),
+				'timestampstr ∪ stringblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringblob'),
+				'timestampstr ∪ stringtinyblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringtinyblob'),
+				'timestampstr ∪ stringmediumblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringmediumblob'),
+				'timestampstr ∪ stringlongblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringlongblob'),
+				'timestampstr ∪ datestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datestr'),
+				'timestampstr ∪ datetimestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datetimestr'),
+				'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+				'time ∪ bigintstr': allTypesCodecsTable.time.as('time ∪ bigintstr'),
+				'time ∪ char': allTypesCodecsTable.time.as('time ∪ char'),
+				'time ∪ decimal': allTypesCodecsTable.time.as('time ∪ decimal'),
+				'time ∪ text': allTypesCodecsTable.time.as('time ∪ text'),
+				'time ∪ tinytext': allTypesCodecsTable.time.as('time ∪ tinytext'),
+				'time ∪ mediumtext': allTypesCodecsTable.time.as('time ∪ mediumtext'),
+				'time ∪ longtext': allTypesCodecsTable.time.as('time ∪ longtext'),
+				'time ∪ varchar': allTypesCodecsTable.time.as('time ∪ varchar'),
+				'time ∪ varbin': allTypesCodecsTable.time.as('time ∪ varbin'),
+				'time ∪ stringblob': allTypesCodecsTable.time.as('time ∪ stringblob'),
+				'time ∪ stringtinyblob': allTypesCodecsTable.time.as('time ∪ stringtinyblob'),
+				'time ∪ stringmediumblob': allTypesCodecsTable.time.as('time ∪ stringmediumblob'),
+				'time ∪ stringlongblob': allTypesCodecsTable.time.as('time ∪ stringlongblob'),
+				'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+				'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+				'bigintstr ∪ char': allTypesCodecsTable.char.as('bigintstr ∪ char'),
+				'bigintstr ∪ decimal': allTypesCodecsTable.decimal.as('bigintstr ∪ decimal'),
+				'bigintstr ∪ text': allTypesCodecsTable.text.as('bigintstr ∪ text'),
+				'bigintstr ∪ tinytext': allTypesCodecsTable.tinytext.as('bigintstr ∪ tinytext'),
+				'bigintstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('bigintstr ∪ mediumtext'),
+				'bigintstr ∪ longtext': allTypesCodecsTable.longtext.as('bigintstr ∪ longtext'),
+				'bigintstr ∪ varchar': allTypesCodecsTable.varchar.as('bigintstr ∪ varchar'),
+				'bigintstr ∪ varbin': allTypesCodecsTable.varbin.as('bigintstr ∪ varbin'),
+				'bigintstr ∪ stringblob': allTypesCodecsTable.stringblob.as('bigintstr ∪ stringblob'),
+				'bigintstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('bigintstr ∪ stringtinyblob'),
+				'bigintstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('bigintstr ∪ stringmediumblob'),
+				'bigintstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('bigintstr ∪ stringlongblob'),
+				'bigintstr ∪ datestr': allTypesCodecsTable.datestr.as('bigintstr ∪ datestr'),
+				'bigintstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('bigintstr ∪ datetimestr'),
+				'bigintstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('bigintstr ∪ timestampstr'),
+				'bigintstr ∪ time': allTypesCodecsTable.time.as('bigintstr ∪ time'),
+				'char ∪ bigintstr': allTypesCodecsTable.bigintstr.as('char ∪ bigintstr'),
+				'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+				'char ∪ decimal': allTypesCodecsTable.decimal.as('char ∪ decimal'),
+				'char ∪ text': allTypesCodecsTable.text.as('char ∪ text'),
+				'char ∪ tinytext': allTypesCodecsTable.tinytext.as('char ∪ tinytext'),
+				'char ∪ mediumtext': allTypesCodecsTable.mediumtext.as('char ∪ mediumtext'),
+				'char ∪ longtext': allTypesCodecsTable.longtext.as('char ∪ longtext'),
+				'char ∪ varchar': allTypesCodecsTable.varchar.as('char ∪ varchar'),
+				'char ∪ varbin': allTypesCodecsTable.varbin.as('char ∪ varbin'),
+				'char ∪ stringblob': allTypesCodecsTable.stringblob.as('char ∪ stringblob'),
+				'char ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('char ∪ stringtinyblob'),
+				'char ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('char ∪ stringmediumblob'),
+				'char ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('char ∪ stringlongblob'),
+				'char ∪ datestr': allTypesCodecsTable.datestr.as('char ∪ datestr'),
+				'char ∪ datetimestr': allTypesCodecsTable.datetimestr.as('char ∪ datetimestr'),
+				'char ∪ timestampstr': allTypesCodecsTable.timestampstr.as('char ∪ timestampstr'),
+				'char ∪ time': allTypesCodecsTable.time.as('char ∪ time'),
+				'decimal ∪ bigintstr': allTypesCodecsTable.bigintstr.as('decimal ∪ bigintstr'),
+				'decimal ∪ char': allTypesCodecsTable.char.as('decimal ∪ char'),
+				'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+				'decimal ∪ text': allTypesCodecsTable.text.as('decimal ∪ text'),
+				'decimal ∪ tinytext': allTypesCodecsTable.tinytext.as('decimal ∪ tinytext'),
+				'decimal ∪ mediumtext': allTypesCodecsTable.mediumtext.as('decimal ∪ mediumtext'),
+				'decimal ∪ longtext': allTypesCodecsTable.longtext.as('decimal ∪ longtext'),
+				'decimal ∪ varchar': allTypesCodecsTable.varchar.as('decimal ∪ varchar'),
+				'decimal ∪ varbin': allTypesCodecsTable.varbin.as('decimal ∪ varbin'),
+				'decimal ∪ stringblob': allTypesCodecsTable.stringblob.as('decimal ∪ stringblob'),
+				'decimal ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('decimal ∪ stringtinyblob'),
+				'decimal ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('decimal ∪ stringmediumblob'),
+				'decimal ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('decimal ∪ stringlongblob'),
+				'decimal ∪ datestr': allTypesCodecsTable.datestr.as('decimal ∪ datestr'),
+				'decimal ∪ datetimestr': allTypesCodecsTable.datetimestr.as('decimal ∪ datetimestr'),
+				'decimal ∪ timestampstr': allTypesCodecsTable.timestampstr.as('decimal ∪ timestampstr'),
+				'decimal ∪ time': allTypesCodecsTable.time.as('decimal ∪ time'),
+				'text ∪ bigintstr': allTypesCodecsTable.bigintstr.as('text ∪ bigintstr'),
+				'text ∪ char': allTypesCodecsTable.char.as('text ∪ char'),
+				'text ∪ decimal': allTypesCodecsTable.decimal.as('text ∪ decimal'),
+				'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+				'text ∪ tinytext': allTypesCodecsTable.tinytext.as('text ∪ tinytext'),
+				'text ∪ mediumtext': allTypesCodecsTable.mediumtext.as('text ∪ mediumtext'),
+				'text ∪ longtext': allTypesCodecsTable.longtext.as('text ∪ longtext'),
+				'text ∪ varchar': allTypesCodecsTable.varchar.as('text ∪ varchar'),
+				'text ∪ varbin': allTypesCodecsTable.varbin.as('text ∪ varbin'),
+				'text ∪ stringblob': allTypesCodecsTable.stringblob.as('text ∪ stringblob'),
+				'text ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('text ∪ stringtinyblob'),
+				'text ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('text ∪ stringmediumblob'),
+				'text ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('text ∪ stringlongblob'),
+				'text ∪ datestr': allTypesCodecsTable.datestr.as('text ∪ datestr'),
+				'text ∪ datetimestr': allTypesCodecsTable.datetimestr.as('text ∪ datetimestr'),
+				'text ∪ timestampstr': allTypesCodecsTable.timestampstr.as('text ∪ timestampstr'),
+				'text ∪ time': allTypesCodecsTable.time.as('text ∪ time'),
+				'tinytext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('tinytext ∪ bigintstr'),
+				'tinytext ∪ char': allTypesCodecsTable.char.as('tinytext ∪ char'),
+				'tinytext ∪ decimal': allTypesCodecsTable.decimal.as('tinytext ∪ decimal'),
+				'tinytext ∪ text': allTypesCodecsTable.text.as('tinytext ∪ text'),
+				'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+				'tinytext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('tinytext ∪ mediumtext'),
+				'tinytext ∪ longtext': allTypesCodecsTable.longtext.as('tinytext ∪ longtext'),
+				'tinytext ∪ varchar': allTypesCodecsTable.varchar.as('tinytext ∪ varchar'),
+				'tinytext ∪ varbin': allTypesCodecsTable.varbin.as('tinytext ∪ varbin'),
+				'tinytext ∪ stringblob': allTypesCodecsTable.stringblob.as('tinytext ∪ stringblob'),
+				'tinytext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('tinytext ∪ stringtinyblob'),
+				'tinytext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('tinytext ∪ stringmediumblob'),
+				'tinytext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('tinytext ∪ stringlongblob'),
+				'tinytext ∪ datestr': allTypesCodecsTable.datestr.as('tinytext ∪ datestr'),
+				'tinytext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('tinytext ∪ datetimestr'),
+				'tinytext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('tinytext ∪ timestampstr'),
+				'tinytext ∪ time': allTypesCodecsTable.time.as('tinytext ∪ time'),
+				'mediumtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('mediumtext ∪ bigintstr'),
+				'mediumtext ∪ char': allTypesCodecsTable.char.as('mediumtext ∪ char'),
+				'mediumtext ∪ decimal': allTypesCodecsTable.decimal.as('mediumtext ∪ decimal'),
+				'mediumtext ∪ text': allTypesCodecsTable.text.as('mediumtext ∪ text'),
+				'mediumtext ∪ tinytext': allTypesCodecsTable.tinytext.as('mediumtext ∪ tinytext'),
+				'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+				'mediumtext ∪ longtext': allTypesCodecsTable.longtext.as('mediumtext ∪ longtext'),
+				'mediumtext ∪ varchar': allTypesCodecsTable.varchar.as('mediumtext ∪ varchar'),
+				'mediumtext ∪ varbin': allTypesCodecsTable.varbin.as('mediumtext ∪ varbin'),
+				'mediumtext ∪ stringblob': allTypesCodecsTable.stringblob.as('mediumtext ∪ stringblob'),
+				'mediumtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('mediumtext ∪ stringtinyblob'),
+				'mediumtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('mediumtext ∪ stringmediumblob'),
+				'mediumtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('mediumtext ∪ stringlongblob'),
+				'mediumtext ∪ datestr': allTypesCodecsTable.datestr.as('mediumtext ∪ datestr'),
+				'mediumtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('mediumtext ∪ datetimestr'),
+				'mediumtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('mediumtext ∪ timestampstr'),
+				'mediumtext ∪ time': allTypesCodecsTable.time.as('mediumtext ∪ time'),
+				'longtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('longtext ∪ bigintstr'),
+				'longtext ∪ char': allTypesCodecsTable.char.as('longtext ∪ char'),
+				'longtext ∪ decimal': allTypesCodecsTable.decimal.as('longtext ∪ decimal'),
+				'longtext ∪ text': allTypesCodecsTable.text.as('longtext ∪ text'),
+				'longtext ∪ tinytext': allTypesCodecsTable.tinytext.as('longtext ∪ tinytext'),
+				'longtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('longtext ∪ mediumtext'),
+				'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+				'longtext ∪ varchar': allTypesCodecsTable.varchar.as('longtext ∪ varchar'),
+				'longtext ∪ varbin': allTypesCodecsTable.varbin.as('longtext ∪ varbin'),
+				'longtext ∪ stringblob': allTypesCodecsTable.stringblob.as('longtext ∪ stringblob'),
+				'longtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('longtext ∪ stringtinyblob'),
+				'longtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('longtext ∪ stringmediumblob'),
+				'longtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('longtext ∪ stringlongblob'),
+				'longtext ∪ datestr': allTypesCodecsTable.datestr.as('longtext ∪ datestr'),
+				'longtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('longtext ∪ datetimestr'),
+				'longtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('longtext ∪ timestampstr'),
+				'longtext ∪ time': allTypesCodecsTable.time.as('longtext ∪ time'),
+				'varchar ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varchar ∪ bigintstr'),
+				'varchar ∪ char': allTypesCodecsTable.char.as('varchar ∪ char'),
+				'varchar ∪ decimal': allTypesCodecsTable.decimal.as('varchar ∪ decimal'),
+				'varchar ∪ text': allTypesCodecsTable.text.as('varchar ∪ text'),
+				'varchar ∪ tinytext': allTypesCodecsTable.tinytext.as('varchar ∪ tinytext'),
+				'varchar ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varchar ∪ mediumtext'),
+				'varchar ∪ longtext': allTypesCodecsTable.longtext.as('varchar ∪ longtext'),
+				'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+				'varchar ∪ varbin': allTypesCodecsTable.varbin.as('varchar ∪ varbin'),
+				'varchar ∪ stringblob': allTypesCodecsTable.stringblob.as('varchar ∪ stringblob'),
+				'varchar ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varchar ∪ stringtinyblob'),
+				'varchar ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varchar ∪ stringmediumblob'),
+				'varchar ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varchar ∪ stringlongblob'),
+				'varchar ∪ datestr': allTypesCodecsTable.datestr.as('varchar ∪ datestr'),
+				'varchar ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varchar ∪ datetimestr'),
+				'varchar ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varchar ∪ timestampstr'),
+				'varchar ∪ time': allTypesCodecsTable.time.as('varchar ∪ time'),
+				'varbin ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varbin ∪ bigintstr'),
+				'varbin ∪ char': allTypesCodecsTable.char.as('varbin ∪ char'),
+				'varbin ∪ decimal': allTypesCodecsTable.decimal.as('varbin ∪ decimal'),
+				'varbin ∪ text': allTypesCodecsTable.text.as('varbin ∪ text'),
+				'varbin ∪ tinytext': allTypesCodecsTable.tinytext.as('varbin ∪ tinytext'),
+				'varbin ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varbin ∪ mediumtext'),
+				'varbin ∪ longtext': allTypesCodecsTable.longtext.as('varbin ∪ longtext'),
+				'varbin ∪ varchar': allTypesCodecsTable.varchar.as('varbin ∪ varchar'),
+				'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+				'varbin ∪ stringblob': allTypesCodecsTable.stringblob.as('varbin ∪ stringblob'),
+				'varbin ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varbin ∪ stringtinyblob'),
+				'varbin ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varbin ∪ stringmediumblob'),
+				'varbin ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varbin ∪ stringlongblob'),
+				'varbin ∪ datestr': allTypesCodecsTable.datestr.as('varbin ∪ datestr'),
+				'varbin ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varbin ∪ datetimestr'),
+				'varbin ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varbin ∪ timestampstr'),
+				'varbin ∪ time': allTypesCodecsTable.time.as('varbin ∪ time'),
+				'stringblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringblob ∪ bigintstr'),
+				'stringblob ∪ char': allTypesCodecsTable.char.as('stringblob ∪ char'),
+				'stringblob ∪ decimal': allTypesCodecsTable.decimal.as('stringblob ∪ decimal'),
+				'stringblob ∪ text': allTypesCodecsTable.text.as('stringblob ∪ text'),
+				'stringblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringblob ∪ tinytext'),
+				'stringblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringblob ∪ mediumtext'),
+				'stringblob ∪ longtext': allTypesCodecsTable.longtext.as('stringblob ∪ longtext'),
+				'stringblob ∪ varchar': allTypesCodecsTable.varchar.as('stringblob ∪ varchar'),
+				'stringblob ∪ varbin': allTypesCodecsTable.varbin.as('stringblob ∪ varbin'),
+				'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+				'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringblob ∪ stringtinyblob'),
+				'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('stringblob ∪ stringmediumblob'),
+				'stringblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringblob ∪ stringlongblob'),
+				'stringblob ∪ datestr': allTypesCodecsTable.datestr.as('stringblob ∪ datestr'),
+				'stringblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringblob ∪ datetimestr'),
+				'stringblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringblob ∪ timestampstr'),
+				'stringblob ∪ time': allTypesCodecsTable.time.as('stringblob ∪ time'),
+				'stringtinyblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringtinyblob ∪ bigintstr'),
+				'stringtinyblob ∪ char': allTypesCodecsTable.char.as('stringtinyblob ∪ char'),
+				'stringtinyblob ∪ decimal': allTypesCodecsTable.decimal.as('stringtinyblob ∪ decimal'),
+				'stringtinyblob ∪ text': allTypesCodecsTable.text.as('stringtinyblob ∪ text'),
+				'stringtinyblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringtinyblob ∪ tinytext'),
+				'stringtinyblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringtinyblob ∪ mediumtext'),
+				'stringtinyblob ∪ longtext': allTypesCodecsTable.longtext.as('stringtinyblob ∪ longtext'),
+				'stringtinyblob ∪ varchar': allTypesCodecsTable.varchar.as('stringtinyblob ∪ varchar'),
+				'stringtinyblob ∪ varbin': allTypesCodecsTable.varbin.as('stringtinyblob ∪ varbin'),
+				'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringtinyblob ∪ stringblob'),
+				'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringtinyblob'),
+				'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringtinyblob ∪ stringmediumblob',
+				),
+				'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringtinyblob ∪ stringlongblob'),
+				'stringtinyblob ∪ datestr': allTypesCodecsTable.datestr.as('stringtinyblob ∪ datestr'),
+				'stringtinyblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringtinyblob ∪ datetimestr'),
+				'stringtinyblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringtinyblob ∪ timestampstr'),
+				'stringtinyblob ∪ time': allTypesCodecsTable.time.as('stringtinyblob ∪ time'),
+				'stringmediumblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringmediumblob ∪ bigintstr'),
+				'stringmediumblob ∪ char': allTypesCodecsTable.char.as('stringmediumblob ∪ char'),
+				'stringmediumblob ∪ decimal': allTypesCodecsTable.decimal.as('stringmediumblob ∪ decimal'),
+				'stringmediumblob ∪ text': allTypesCodecsTable.text.as('stringmediumblob ∪ text'),
+				'stringmediumblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringmediumblob ∪ tinytext'),
+				'stringmediumblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringmediumblob ∪ mediumtext'),
+				'stringmediumblob ∪ longtext': allTypesCodecsTable.longtext.as('stringmediumblob ∪ longtext'),
+				'stringmediumblob ∪ varchar': allTypesCodecsTable.varchar.as('stringmediumblob ∪ varchar'),
+				'stringmediumblob ∪ varbin': allTypesCodecsTable.varbin.as('stringmediumblob ∪ varbin'),
+				'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringmediumblob ∪ stringblob'),
+				'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringmediumblob ∪ stringtinyblob'),
+				'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringmediumblob ∪ stringmediumblob',
+				),
+				'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringmediumblob ∪ stringlongblob'),
+				'stringmediumblob ∪ datestr': allTypesCodecsTable.datestr.as('stringmediumblob ∪ datestr'),
+				'stringmediumblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringmediumblob ∪ datetimestr'),
+				'stringmediumblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringmediumblob ∪ timestampstr'),
+				'stringmediumblob ∪ time': allTypesCodecsTable.time.as('stringmediumblob ∪ time'),
+				'stringlongblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringlongblob ∪ bigintstr'),
+				'stringlongblob ∪ char': allTypesCodecsTable.char.as('stringlongblob ∪ char'),
+				'stringlongblob ∪ decimal': allTypesCodecsTable.decimal.as('stringlongblob ∪ decimal'),
+				'stringlongblob ∪ text': allTypesCodecsTable.text.as('stringlongblob ∪ text'),
+				'stringlongblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringlongblob ∪ tinytext'),
+				'stringlongblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringlongblob ∪ mediumtext'),
+				'stringlongblob ∪ longtext': allTypesCodecsTable.longtext.as('stringlongblob ∪ longtext'),
+				'stringlongblob ∪ varchar': allTypesCodecsTable.varchar.as('stringlongblob ∪ varchar'),
+				'stringlongblob ∪ varbin': allTypesCodecsTable.varbin.as('stringlongblob ∪ varbin'),
+				'stringlongblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringlongblob ∪ stringblob'),
+				'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringlongblob ∪ stringtinyblob'),
+				'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+					'stringlongblob ∪ stringmediumblob',
+				),
+				'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringlongblob'),
+				'stringlongblob ∪ datestr': allTypesCodecsTable.datestr.as('stringlongblob ∪ datestr'),
+				'stringlongblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringlongblob ∪ datetimestr'),
+				'stringlongblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringlongblob ∪ timestampstr'),
+				'stringlongblob ∪ time': allTypesCodecsTable.time.as('stringlongblob ∪ time'),
+				'datestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datestr ∪ bigintstr'),
+				'datestr ∪ char': allTypesCodecsTable.char.as('datestr ∪ char'),
+				'datestr ∪ decimal': allTypesCodecsTable.decimal.as('datestr ∪ decimal'),
+				'datestr ∪ text': allTypesCodecsTable.text.as('datestr ∪ text'),
+				'datestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datestr ∪ tinytext'),
+				'datestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datestr ∪ mediumtext'),
+				'datestr ∪ longtext': allTypesCodecsTable.longtext.as('datestr ∪ longtext'),
+				'datestr ∪ varchar': allTypesCodecsTable.varchar.as('datestr ∪ varchar'),
+				'datestr ∪ varbin': allTypesCodecsTable.varbin.as('datestr ∪ varbin'),
+				'datestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datestr ∪ stringblob'),
+				'datestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datestr ∪ stringtinyblob'),
+				'datestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('datestr ∪ stringmediumblob'),
+				'datestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datestr ∪ stringlongblob'),
+				'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+				'datestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datestr ∪ datetimestr'),
+				'datestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datestr ∪ timestampstr'),
+				'datetimestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datetimestr ∪ bigintstr'),
+				'datetimestr ∪ char': allTypesCodecsTable.char.as('datetimestr ∪ char'),
+				'datetimestr ∪ decimal': allTypesCodecsTable.decimal.as('datetimestr ∪ decimal'),
+				'datetimestr ∪ text': allTypesCodecsTable.text.as('datetimestr ∪ text'),
+				'datetimestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datetimestr ∪ tinytext'),
+				'datetimestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datetimestr ∪ mediumtext'),
+				'datetimestr ∪ longtext': allTypesCodecsTable.longtext.as('datetimestr ∪ longtext'),
+				'datetimestr ∪ varchar': allTypesCodecsTable.varchar.as('datetimestr ∪ varchar'),
+				'datetimestr ∪ varbin': allTypesCodecsTable.varbin.as('datetimestr ∪ varbin'),
+				'datetimestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datetimestr ∪ stringblob'),
+				'datetimestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datetimestr ∪ stringtinyblob'),
+				'datetimestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('datetimestr ∪ stringmediumblob'),
+				'datetimestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datetimestr ∪ stringlongblob'),
+				'datetimestr ∪ datestr': allTypesCodecsTable.datestr.as('datetimestr ∪ datestr'),
+				'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+				'datetimestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datetimestr ∪ timestampstr'),
+				'timestampstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('timestampstr ∪ bigintstr'),
+				'timestampstr ∪ char': allTypesCodecsTable.char.as('timestampstr ∪ char'),
+				'timestampstr ∪ decimal': allTypesCodecsTable.decimal.as('timestampstr ∪ decimal'),
+				'timestampstr ∪ text': allTypesCodecsTable.text.as('timestampstr ∪ text'),
+				'timestampstr ∪ tinytext': allTypesCodecsTable.tinytext.as('timestampstr ∪ tinytext'),
+				'timestampstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('timestampstr ∪ mediumtext'),
+				'timestampstr ∪ longtext': allTypesCodecsTable.longtext.as('timestampstr ∪ longtext'),
+				'timestampstr ∪ varchar': allTypesCodecsTable.varchar.as('timestampstr ∪ varchar'),
+				'timestampstr ∪ varbin': allTypesCodecsTable.varbin.as('timestampstr ∪ varbin'),
+				'timestampstr ∪ stringblob': allTypesCodecsTable.stringblob.as('timestampstr ∪ stringblob'),
+				'timestampstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('timestampstr ∪ stringtinyblob'),
+				'timestampstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('timestampstr ∪ stringmediumblob'),
+				'timestampstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('timestampstr ∪ stringlongblob'),
+				'timestampstr ∪ datestr': allTypesCodecsTable.datestr.as('timestampstr ∪ datestr'),
+				'timestampstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('timestampstr ∪ datetimestr'),
+				'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+				'time ∪ bigintstr': allTypesCodecsTable.bigintstr.as('time ∪ bigintstr'),
+				'time ∪ char': allTypesCodecsTable.char.as('time ∪ char'),
+				'time ∪ decimal': allTypesCodecsTable.decimal.as('time ∪ decimal'),
+				'time ∪ text': allTypesCodecsTable.text.as('time ∪ text'),
+				'time ∪ tinytext': allTypesCodecsTable.tinytext.as('time ∪ tinytext'),
+				'time ∪ mediumtext': allTypesCodecsTable.mediumtext.as('time ∪ mediumtext'),
+				'time ∪ longtext': allTypesCodecsTable.longtext.as('time ∪ longtext'),
+				'time ∪ varchar': allTypesCodecsTable.varchar.as('time ∪ varchar'),
+				'time ∪ varbin': allTypesCodecsTable.varbin.as('time ∪ varbin'),
+				'time ∪ stringblob': allTypesCodecsTable.stringblob.as('time ∪ stringblob'),
+				'time ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('time ∪ stringtinyblob'),
+				'time ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('time ∪ stringmediumblob'),
+				'time ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('time ∪ stringlongblob'),
+				'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+				'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'bigintstr ∪ bigintstr': '5044565289845416380',
+			'bigintstr ∪ char': '5044565289845416380',
+			'bigintstr ∪ decimal': '5044565289845416380',
+			'bigintstr ∪ text': '5044565289845416380',
+			'bigintstr ∪ tinytext': '5044565289845416380',
+			'bigintstr ∪ mediumtext': '5044565289845416380',
+			'bigintstr ∪ longtext': '5044565289845416380',
+			'bigintstr ∪ varchar': '5044565289845416380',
+			'bigintstr ∪ varbin': '5044565289845416380',
+			'bigintstr ∪ stringblob': '5044565289845416380',
+			'bigintstr ∪ stringtinyblob': '5044565289845416380',
+			'bigintstr ∪ stringmediumblob': '5044565289845416380',
+			'bigintstr ∪ stringlongblob': '5044565289845416380',
+			'bigintstr ∪ datestr': '5044565289845416380',
+			'bigintstr ∪ datetimestr': '5044565289845416380',
+			'bigintstr ∪ timestampstr': '5044565289845416380',
+			'bigintstr ∪ time': '5044565289845416380',
+			'char ∪ bigintstr': 'c',
+			'char ∪ char': 'c',
+			'char ∪ decimal': 'c',
+			'char ∪ text': 'c',
+			'char ∪ tinytext': 'c',
+			'char ∪ mediumtext': 'c',
+			'char ∪ longtext': 'c',
+			'char ∪ varchar': 'c',
+			'char ∪ varbin': 'c',
+			'char ∪ stringblob': 'c',
+			'char ∪ stringtinyblob': 'c',
+			'char ∪ stringmediumblob': 'c',
+			'char ∪ stringlongblob': 'c',
+			'char ∪ datestr': 'c',
+			'char ∪ datetimestr': 'c',
+			'char ∪ timestampstr': 'c',
+			'char ∪ time': 'c',
+			'decimal ∪ bigintstr': '47521',
+			'decimal ∪ char': '47521',
+			'decimal ∪ decimal': '47521',
+			'decimal ∪ text': '47521',
+			'decimal ∪ tinytext': '47521',
+			'decimal ∪ mediumtext': '47521',
+			'decimal ∪ longtext': '47521',
+			'decimal ∪ varchar': '47521',
+			'decimal ∪ varbin': '47521',
+			'decimal ∪ stringblob': '47521',
+			'decimal ∪ stringtinyblob': '47521',
+			'decimal ∪ stringmediumblob': '47521',
+			'decimal ∪ stringlongblob': '47521',
+			'decimal ∪ datestr': '47521',
+			'decimal ∪ datetimestr': '47521',
+			'decimal ∪ timestampstr': '47521',
+			'decimal ∪ time': '47521',
+			'text ∪ bigintstr': 'C4-',
+			'text ∪ char': 'C4-',
+			'text ∪ decimal': 'C4-',
+			'text ∪ text': 'C4-',
+			'text ∪ tinytext': 'C4-',
+			'text ∪ mediumtext': 'C4-',
+			'text ∪ longtext': 'C4-',
+			'text ∪ varchar': 'C4-',
+			'text ∪ varbin': 'C4-',
+			'text ∪ stringblob': 'C4-',
+			'text ∪ stringtinyblob': 'C4-',
+			'text ∪ stringmediumblob': 'C4-',
+			'text ∪ stringlongblob': 'C4-',
+			'text ∪ datestr': 'C4-',
+			'text ∪ datetimestr': 'C4-',
+			'text ∪ timestampstr': 'C4-',
+			'text ∪ time': 'C4-',
+			'tinytext ∪ bigintstr': 'tiny text',
+			'tinytext ∪ char': 'tiny text',
+			'tinytext ∪ decimal': 'tiny text',
+			'tinytext ∪ text': 'tiny text',
+			'tinytext ∪ tinytext': 'tiny text',
+			'tinytext ∪ mediumtext': 'tiny text',
+			'tinytext ∪ longtext': 'tiny text',
+			'tinytext ∪ varchar': 'tiny text',
+			'tinytext ∪ varbin': 'tiny text',
+			'tinytext ∪ stringblob': 'tiny text',
+			'tinytext ∪ stringtinyblob': 'tiny text',
+			'tinytext ∪ stringmediumblob': 'tiny text',
+			'tinytext ∪ stringlongblob': 'tiny text',
+			'tinytext ∪ datestr': 'tiny text',
+			'tinytext ∪ datetimestr': 'tiny text',
+			'tinytext ∪ timestampstr': 'tiny text',
+			'tinytext ∪ time': 'tiny text',
+			'mediumtext ∪ bigintstr': 'medium text',
+			'mediumtext ∪ char': 'medium text',
+			'mediumtext ∪ decimal': 'medium text',
+			'mediumtext ∪ text': 'medium text',
+			'mediumtext ∪ tinytext': 'medium text',
+			'mediumtext ∪ mediumtext': 'medium text',
+			'mediumtext ∪ longtext': 'medium text',
+			'mediumtext ∪ varchar': 'medium text',
+			'mediumtext ∪ varbin': 'medium text',
+			'mediumtext ∪ stringblob': 'medium text',
+			'mediumtext ∪ stringtinyblob': 'medium text',
+			'mediumtext ∪ stringmediumblob': 'medium text',
+			'mediumtext ∪ stringlongblob': 'medium text',
+			'mediumtext ∪ datestr': 'medium text',
+			'mediumtext ∪ datetimestr': 'medium text',
+			'mediumtext ∪ timestampstr': 'medium text',
+			'mediumtext ∪ time': 'medium text',
+			'longtext ∪ bigintstr': 'long text',
+			'longtext ∪ char': 'long text',
+			'longtext ∪ decimal': 'long text',
+			'longtext ∪ text': 'long text',
+			'longtext ∪ tinytext': 'long text',
+			'longtext ∪ mediumtext': 'long text',
+			'longtext ∪ longtext': 'long text',
+			'longtext ∪ varchar': 'long text',
+			'longtext ∪ varbin': 'long text',
+			'longtext ∪ stringblob': 'long text',
+			'longtext ∪ stringtinyblob': 'long text',
+			'longtext ∪ stringmediumblob': 'long text',
+			'longtext ∪ stringlongblob': 'long text',
+			'longtext ∪ datestr': 'long text',
+			'longtext ∪ datetimestr': 'long text',
+			'longtext ∪ timestampstr': 'long text',
+			'longtext ∪ time': 'long text',
+			'varchar ∪ bigintstr': 'VCHAR',
+			'varchar ∪ char': 'VCHAR',
+			'varchar ∪ decimal': 'VCHAR',
+			'varchar ∪ text': 'VCHAR',
+			'varchar ∪ tinytext': 'VCHAR',
+			'varchar ∪ mediumtext': 'VCHAR',
+			'varchar ∪ longtext': 'VCHAR',
+			'varchar ∪ varchar': 'VCHAR',
+			'varchar ∪ varbin': 'VCHAR',
+			'varchar ∪ stringblob': 'VCHAR',
+			'varchar ∪ stringtinyblob': 'VCHAR',
+			'varchar ∪ stringmediumblob': 'VCHAR',
+			'varchar ∪ stringlongblob': 'VCHAR',
+			'varchar ∪ datestr': 'VCHAR',
+			'varchar ∪ datetimestr': 'VCHAR',
+			'varchar ∪ timestampstr': 'VCHAR',
+			'varchar ∪ time': 'VCHAR',
+			'varbin ∪ bigintstr': '1010110101001101',
+			'varbin ∪ char': '1010110101001101',
+			'varbin ∪ decimal': '1010110101001101',
+			'varbin ∪ text': '1010110101001101',
+			'varbin ∪ tinytext': '1010110101001101',
+			'varbin ∪ mediumtext': '1010110101001101',
+			'varbin ∪ longtext': '1010110101001101',
+			'varbin ∪ varchar': '1010110101001101',
+			'varbin ∪ varbin': '1010110101001101',
+			'varbin ∪ stringblob': '1010110101001101',
+			'varbin ∪ stringtinyblob': '1010110101001101',
+			'varbin ∪ stringmediumblob': '1010110101001101',
+			'varbin ∪ stringlongblob': '1010110101001101',
+			'varbin ∪ datestr': '1010110101001101',
+			'varbin ∪ datetimestr': '1010110101001101',
+			'varbin ∪ timestampstr': '1010110101001101',
+			'varbin ∪ time': '1010110101001101',
+			'stringblob ∪ bigintstr': 'string',
+			'stringblob ∪ char': 'string',
+			'stringblob ∪ decimal': 'string',
+			'stringblob ∪ text': 'string',
+			'stringblob ∪ tinytext': 'string',
+			'stringblob ∪ mediumtext': 'string',
+			'stringblob ∪ longtext': 'string',
+			'stringblob ∪ varchar': 'string',
+			'stringblob ∪ varbin': 'string',
+			'stringblob ∪ stringblob': 'string',
+			'stringblob ∪ stringtinyblob': 'string',
+			'stringblob ∪ stringmediumblob': 'string',
+			'stringblob ∪ stringlongblob': 'string',
+			'stringblob ∪ datestr': 'string',
+			'stringblob ∪ datetimestr': 'string',
+			'stringblob ∪ timestampstr': 'string',
+			'stringblob ∪ time': 'string',
+			'stringtinyblob ∪ bigintstr': 'string',
+			'stringtinyblob ∪ char': 'string',
+			'stringtinyblob ∪ decimal': 'string',
+			'stringtinyblob ∪ text': 'string',
+			'stringtinyblob ∪ tinytext': 'string',
+			'stringtinyblob ∪ mediumtext': 'string',
+			'stringtinyblob ∪ longtext': 'string',
+			'stringtinyblob ∪ varchar': 'string',
+			'stringtinyblob ∪ varbin': 'string',
+			'stringtinyblob ∪ stringblob': 'string',
+			'stringtinyblob ∪ stringtinyblob': 'string',
+			'stringtinyblob ∪ stringmediumblob': 'string',
+			'stringtinyblob ∪ stringlongblob': 'string',
+			'stringtinyblob ∪ datestr': 'string',
+			'stringtinyblob ∪ datetimestr': 'string',
+			'stringtinyblob ∪ timestampstr': 'string',
+			'stringtinyblob ∪ time': 'string',
+			'stringmediumblob ∪ bigintstr': 'string',
+			'stringmediumblob ∪ char': 'string',
+			'stringmediumblob ∪ decimal': 'string',
+			'stringmediumblob ∪ text': 'string',
+			'stringmediumblob ∪ tinytext': 'string',
+			'stringmediumblob ∪ mediumtext': 'string',
+			'stringmediumblob ∪ longtext': 'string',
+			'stringmediumblob ∪ varchar': 'string',
+			'stringmediumblob ∪ varbin': 'string',
+			'stringmediumblob ∪ stringblob': 'string',
+			'stringmediumblob ∪ stringtinyblob': 'string',
+			'stringmediumblob ∪ stringmediumblob': 'string',
+			'stringmediumblob ∪ stringlongblob': 'string',
+			'stringmediumblob ∪ datestr': 'string',
+			'stringmediumblob ∪ datetimestr': 'string',
+			'stringmediumblob ∪ timestampstr': 'string',
+			'stringmediumblob ∪ time': 'string',
+			'stringlongblob ∪ bigintstr': 'string',
+			'stringlongblob ∪ char': 'string',
+			'stringlongblob ∪ decimal': 'string',
+			'stringlongblob ∪ text': 'string',
+			'stringlongblob ∪ tinytext': 'string',
+			'stringlongblob ∪ mediumtext': 'string',
+			'stringlongblob ∪ longtext': 'string',
+			'stringlongblob ∪ varchar': 'string',
+			'stringlongblob ∪ varbin': 'string',
+			'stringlongblob ∪ stringblob': 'string',
+			'stringlongblob ∪ stringtinyblob': 'string',
+			'stringlongblob ∪ stringmediumblob': 'string',
+			'stringlongblob ∪ stringlongblob': 'string',
+			'stringlongblob ∪ datestr': 'string',
+			'stringlongblob ∪ datetimestr': 'string',
+			'stringlongblob ∪ timestampstr': 'string',
+			'stringlongblob ∪ time': 'string',
+			'datestr ∪ bigintstr': '2025-03-12',
+			'datestr ∪ char': '2025-03-12',
+			'datestr ∪ decimal': '2025-03-12',
+			'datestr ∪ text': '2025-03-12',
+			'datestr ∪ tinytext': '2025-03-12',
+			'datestr ∪ mediumtext': '2025-03-12',
+			'datestr ∪ longtext': '2025-03-12',
+			'datestr ∪ varchar': '2025-03-12',
+			'datestr ∪ varbin': '2025-03-12',
+			'datestr ∪ stringblob': '2025-03-12',
+			'datestr ∪ stringtinyblob': '2025-03-12',
+			'datestr ∪ stringmediumblob': '2025-03-12',
+			'datestr ∪ stringlongblob': '2025-03-12',
+			'datestr ∪ datestr': '2025-03-12',
+			'datestr ∪ datetimestr': '2025-03-12 00:00:00.000',
+			'datestr ∪ timestampstr': '2025-03-12 00:00:00.000',
+			'datetimestr ∪ bigintstr': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ char': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ decimal': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ text': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ tinytext': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ mediumtext': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ longtext': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ varchar': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ varbin': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ stringblob': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ datestr': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ bigintstr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ char': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ decimal': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ text': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ tinytext': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ mediumtext': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ longtext': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ varchar': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ varbin': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ stringblob': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ datestr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'time ∪ bigintstr': '04:13:22',
+			'time ∪ char': '04:13:22',
+			'time ∪ decimal': '04:13:22',
+			'time ∪ text': '04:13:22',
+			'time ∪ tinytext': '04:13:22',
+			'time ∪ mediumtext': '04:13:22',
+			'time ∪ longtext': '04:13:22',
+			'time ∪ varchar': '04:13:22',
+			'time ∪ varbin': '04:13:22',
+			'time ∪ stringblob': '04:13:22',
+			'time ∪ stringtinyblob': '04:13:22',
+			'time ∪ stringmediumblob': '04:13:22',
+			'time ∪ stringlongblob': '04:13:22',
+			'time ∪ time': '04:13:22',
+			'binary ∪ binary': '1',
+		},
+		{
+			'bigintstr ∪ bigintstr': '5044565289845416380',
+			'bigintstr ∪ char': 'c',
+			'bigintstr ∪ decimal': '47521',
+			'bigintstr ∪ text': 'C4-',
+			'bigintstr ∪ tinytext': 'tiny text',
+			'bigintstr ∪ mediumtext': 'medium text',
+			'bigintstr ∪ longtext': 'long text',
+			'bigintstr ∪ varchar': 'VCHAR',
+			'bigintstr ∪ varbin': '1010110101001101',
+			'bigintstr ∪ stringblob': 'string',
+			'bigintstr ∪ stringtinyblob': 'string',
+			'bigintstr ∪ stringmediumblob': 'string',
+			'bigintstr ∪ stringlongblob': 'string',
+			'bigintstr ∪ datestr': '2025-03-12',
+			'bigintstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'bigintstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'bigintstr ∪ time': '04:13:22',
+			'char ∪ bigintstr': '5044565289845416380',
+			'char ∪ char': 'c',
+			'char ∪ decimal': '47521',
+			'char ∪ text': 'C4-',
+			'char ∪ tinytext': 'tiny text',
+			'char ∪ mediumtext': 'medium text',
+			'char ∪ longtext': 'long text',
+			'char ∪ varchar': 'VCHAR',
+			'char ∪ varbin': '1010110101001101',
+			'char ∪ stringblob': 'string',
+			'char ∪ stringtinyblob': 'string',
+			'char ∪ stringmediumblob': 'string',
+			'char ∪ stringlongblob': 'string',
+			'char ∪ datestr': '2025-03-12',
+			'char ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'char ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'char ∪ time': '04:13:22',
+			'decimal ∪ bigintstr': '5044565289845416380',
+			'decimal ∪ char': 'c',
+			'decimal ∪ decimal': '47521',
+			'decimal ∪ text': 'C4-',
+			'decimal ∪ tinytext': 'tiny text',
+			'decimal ∪ mediumtext': 'medium text',
+			'decimal ∪ longtext': 'long text',
+			'decimal ∪ varchar': 'VCHAR',
+			'decimal ∪ varbin': '1010110101001101',
+			'decimal ∪ stringblob': 'string',
+			'decimal ∪ stringtinyblob': 'string',
+			'decimal ∪ stringmediumblob': 'string',
+			'decimal ∪ stringlongblob': 'string',
+			'decimal ∪ datestr': '2025-03-12',
+			'decimal ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'decimal ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'decimal ∪ time': '04:13:22',
+			'text ∪ bigintstr': '5044565289845416380',
+			'text ∪ char': 'c',
+			'text ∪ decimal': '47521',
+			'text ∪ text': 'C4-',
+			'text ∪ tinytext': 'tiny text',
+			'text ∪ mediumtext': 'medium text',
+			'text ∪ longtext': 'long text',
+			'text ∪ varchar': 'VCHAR',
+			'text ∪ varbin': '1010110101001101',
+			'text ∪ stringblob': 'string',
+			'text ∪ stringtinyblob': 'string',
+			'text ∪ stringmediumblob': 'string',
+			'text ∪ stringlongblob': 'string',
+			'text ∪ datestr': '2025-03-12',
+			'text ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'text ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'text ∪ time': '04:13:22',
+			'tinytext ∪ bigintstr': '5044565289845416380',
+			'tinytext ∪ char': 'c',
+			'tinytext ∪ decimal': '47521',
+			'tinytext ∪ text': 'C4-',
+			'tinytext ∪ tinytext': 'tiny text',
+			'tinytext ∪ mediumtext': 'medium text',
+			'tinytext ∪ longtext': 'long text',
+			'tinytext ∪ varchar': 'VCHAR',
+			'tinytext ∪ varbin': '1010110101001101',
+			'tinytext ∪ stringblob': 'string',
+			'tinytext ∪ stringtinyblob': 'string',
+			'tinytext ∪ stringmediumblob': 'string',
+			'tinytext ∪ stringlongblob': 'string',
+			'tinytext ∪ datestr': '2025-03-12',
+			'tinytext ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'tinytext ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'tinytext ∪ time': '04:13:22',
+			'mediumtext ∪ bigintstr': '5044565289845416380',
+			'mediumtext ∪ char': 'c',
+			'mediumtext ∪ decimal': '47521',
+			'mediumtext ∪ text': 'C4-',
+			'mediumtext ∪ tinytext': 'tiny text',
+			'mediumtext ∪ mediumtext': 'medium text',
+			'mediumtext ∪ longtext': 'long text',
+			'mediumtext ∪ varchar': 'VCHAR',
+			'mediumtext ∪ varbin': '1010110101001101',
+			'mediumtext ∪ stringblob': 'string',
+			'mediumtext ∪ stringtinyblob': 'string',
+			'mediumtext ∪ stringmediumblob': 'string',
+			'mediumtext ∪ stringlongblob': 'string',
+			'mediumtext ∪ datestr': '2025-03-12',
+			'mediumtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'mediumtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'mediumtext ∪ time': '04:13:22',
+			'longtext ∪ bigintstr': '5044565289845416380',
+			'longtext ∪ char': 'c',
+			'longtext ∪ decimal': '47521',
+			'longtext ∪ text': 'C4-',
+			'longtext ∪ tinytext': 'tiny text',
+			'longtext ∪ mediumtext': 'medium text',
+			'longtext ∪ longtext': 'long text',
+			'longtext ∪ varchar': 'VCHAR',
+			'longtext ∪ varbin': '1010110101001101',
+			'longtext ∪ stringblob': 'string',
+			'longtext ∪ stringtinyblob': 'string',
+			'longtext ∪ stringmediumblob': 'string',
+			'longtext ∪ stringlongblob': 'string',
+			'longtext ∪ datestr': '2025-03-12',
+			'longtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'longtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'longtext ∪ time': '04:13:22',
+			'varchar ∪ bigintstr': '5044565289845416380',
+			'varchar ∪ char': 'c',
+			'varchar ∪ decimal': '47521',
+			'varchar ∪ text': 'C4-',
+			'varchar ∪ tinytext': 'tiny text',
+			'varchar ∪ mediumtext': 'medium text',
+			'varchar ∪ longtext': 'long text',
+			'varchar ∪ varchar': 'VCHAR',
+			'varchar ∪ varbin': '1010110101001101',
+			'varchar ∪ stringblob': 'string',
+			'varchar ∪ stringtinyblob': 'string',
+			'varchar ∪ stringmediumblob': 'string',
+			'varchar ∪ stringlongblob': 'string',
+			'varchar ∪ datestr': '2025-03-12',
+			'varchar ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'varchar ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'varchar ∪ time': '04:13:22',
+			'varbin ∪ bigintstr': '5044565289845416380',
+			'varbin ∪ char': 'c',
+			'varbin ∪ decimal': '47521',
+			'varbin ∪ text': 'C4-',
+			'varbin ∪ tinytext': 'tiny text',
+			'varbin ∪ mediumtext': 'medium text',
+			'varbin ∪ longtext': 'long text',
+			'varbin ∪ varchar': 'VCHAR',
+			'varbin ∪ varbin': '1010110101001101',
+			'varbin ∪ stringblob': 'string',
+			'varbin ∪ stringtinyblob': 'string',
+			'varbin ∪ stringmediumblob': 'string',
+			'varbin ∪ stringlongblob': 'string',
+			'varbin ∪ datestr': '2025-03-12',
+			'varbin ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'varbin ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'varbin ∪ time': '04:13:22',
+			'stringblob ∪ bigintstr': '5044565289845416380',
+			'stringblob ∪ char': 'c',
+			'stringblob ∪ decimal': '47521',
+			'stringblob ∪ text': 'C4-',
+			'stringblob ∪ tinytext': 'tiny text',
+			'stringblob ∪ mediumtext': 'medium text',
+			'stringblob ∪ longtext': 'long text',
+			'stringblob ∪ varchar': 'VCHAR',
+			'stringblob ∪ varbin': '1010110101001101',
+			'stringblob ∪ stringblob': 'string',
+			'stringblob ∪ stringtinyblob': 'string',
+			'stringblob ∪ stringmediumblob': 'string',
+			'stringblob ∪ stringlongblob': 'string',
+			'stringblob ∪ datestr': '2025-03-12',
+			'stringblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'stringblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'stringblob ∪ time': '04:13:22',
+			'stringtinyblob ∪ bigintstr': '5044565289845416380',
+			'stringtinyblob ∪ char': 'c',
+			'stringtinyblob ∪ decimal': '47521',
+			'stringtinyblob ∪ text': 'C4-',
+			'stringtinyblob ∪ tinytext': 'tiny text',
+			'stringtinyblob ∪ mediumtext': 'medium text',
+			'stringtinyblob ∪ longtext': 'long text',
+			'stringtinyblob ∪ varchar': 'VCHAR',
+			'stringtinyblob ∪ varbin': '1010110101001101',
+			'stringtinyblob ∪ stringblob': 'string',
+			'stringtinyblob ∪ stringtinyblob': 'string',
+			'stringtinyblob ∪ stringmediumblob': 'string',
+			'stringtinyblob ∪ stringlongblob': 'string',
+			'stringtinyblob ∪ datestr': '2025-03-12',
+			'stringtinyblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'stringtinyblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'stringtinyblob ∪ time': '04:13:22',
+			'stringmediumblob ∪ bigintstr': '5044565289845416380',
+			'stringmediumblob ∪ char': 'c',
+			'stringmediumblob ∪ decimal': '47521',
+			'stringmediumblob ∪ text': 'C4-',
+			'stringmediumblob ∪ tinytext': 'tiny text',
+			'stringmediumblob ∪ mediumtext': 'medium text',
+			'stringmediumblob ∪ longtext': 'long text',
+			'stringmediumblob ∪ varchar': 'VCHAR',
+			'stringmediumblob ∪ varbin': '1010110101001101',
+			'stringmediumblob ∪ stringblob': 'string',
+			'stringmediumblob ∪ stringtinyblob': 'string',
+			'stringmediumblob ∪ stringmediumblob': 'string',
+			'stringmediumblob ∪ stringlongblob': 'string',
+			'stringmediumblob ∪ datestr': '2025-03-12',
+			'stringmediumblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'stringmediumblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'stringmediumblob ∪ time': '04:13:22',
+			'stringlongblob ∪ bigintstr': '5044565289845416380',
+			'stringlongblob ∪ char': 'c',
+			'stringlongblob ∪ decimal': '47521',
+			'stringlongblob ∪ text': 'C4-',
+			'stringlongblob ∪ tinytext': 'tiny text',
+			'stringlongblob ∪ mediumtext': 'medium text',
+			'stringlongblob ∪ longtext': 'long text',
+			'stringlongblob ∪ varchar': 'VCHAR',
+			'stringlongblob ∪ varbin': '1010110101001101',
+			'stringlongblob ∪ stringblob': 'string',
+			'stringlongblob ∪ stringtinyblob': 'string',
+			'stringlongblob ∪ stringmediumblob': 'string',
+			'stringlongblob ∪ stringlongblob': 'string',
+			'stringlongblob ∪ datestr': '2025-03-12',
+			'stringlongblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'stringlongblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'stringlongblob ∪ time': '04:13:22',
+			'datestr ∪ bigintstr': '5044565289845416380',
+			'datestr ∪ char': 'c',
+			'datestr ∪ decimal': '47521',
+			'datestr ∪ text': 'C4-',
+			'datestr ∪ tinytext': 'tiny text',
+			'datestr ∪ mediumtext': 'medium text',
+			'datestr ∪ longtext': 'long text',
+			'datestr ∪ varchar': 'VCHAR',
+			'datestr ∪ varbin': '1010110101001101',
+			'datestr ∪ stringblob': 'string',
+			'datestr ∪ stringtinyblob': 'string',
+			'datestr ∪ stringmediumblob': 'string',
+			'datestr ∪ stringlongblob': 'string',
+			'datestr ∪ datestr': '2025-03-12',
+			'datestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'datestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ bigintstr': '5044565289845416380',
+			'datetimestr ∪ char': 'c',
+			'datetimestr ∪ decimal': '47521',
+			'datetimestr ∪ text': 'C4-',
+			'datetimestr ∪ tinytext': 'tiny text',
+			'datetimestr ∪ mediumtext': 'medium text',
+			'datetimestr ∪ longtext': 'long text',
+			'datetimestr ∪ varchar': 'VCHAR',
+			'datetimestr ∪ varbin': '1010110101001101',
+			'datetimestr ∪ stringblob': 'string',
+			'datetimestr ∪ stringtinyblob': 'string',
+			'datetimestr ∪ stringmediumblob': 'string',
+			'datetimestr ∪ stringlongblob': 'string',
+			'datetimestr ∪ datestr': '2025-03-12 00:00:00.000',
+			'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ bigintstr': '5044565289845416380',
+			'timestampstr ∪ char': 'c',
+			'timestampstr ∪ decimal': '47521',
+			'timestampstr ∪ text': 'C4-',
+			'timestampstr ∪ tinytext': 'tiny text',
+			'timestampstr ∪ mediumtext': 'medium text',
+			'timestampstr ∪ longtext': 'long text',
+			'timestampstr ∪ varchar': 'VCHAR',
+			'timestampstr ∪ varbin': '1010110101001101',
+			'timestampstr ∪ stringblob': 'string',
+			'timestampstr ∪ stringtinyblob': 'string',
+			'timestampstr ∪ stringmediumblob': 'string',
+			'timestampstr ∪ stringlongblob': 'string',
+			'timestampstr ∪ datestr': '2025-03-12 00:00:00.000',
+			'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+			'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'time ∪ bigintstr': '5044565289845416380',
+			'time ∪ char': 'c',
+			'time ∪ decimal': '47521',
+			'time ∪ text': 'C4-',
+			'time ∪ tinytext': 'tiny text',
+			'time ∪ mediumtext': 'medium text',
+			'time ∪ longtext': 'long text',
+			'time ∪ varchar': 'VCHAR',
+			'time ∪ varbin': '1010110101001101',
+			'time ∪ stringblob': 'string',
+			'time ∪ stringtinyblob': 'string',
+			'time ∪ stringmediumblob': 'string',
+			'time ∪ stringlongblob': 'string',
+			'time ∪ time': '04:13:22',
+			'binary ∪ binary': '1',
+		},
+	]));
+
+	// ---- bigint ----
+	expect(
+		await unionAll(
+			db.select({
+				'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+				'bigint64 ∪ decimalbig': allTypesCodecsTable.bigint64.as('bigint64 ∪ decimalbig'),
+				'decimalbig ∪ bigint64': allTypesCodecsTable.decimalbig.as('decimalbig ∪ bigint64'),
+				'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+				'bigint64 ∪ decimalbig': allTypesCodecsTable.decimalbig.as('bigint64 ∪ decimalbig'),
+				'decimalbig ∪ bigint64': allTypesCodecsTable.bigint64.as('decimalbig ∪ bigint64'),
+				'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'bigint64 ∪ bigint64': 5044565289845416380n,
+			'bigint64 ∪ decimalbig': 5044565289845416380n,
+			'decimalbig ∪ bigint64': 5044565289845416380n,
+			'decimalbig ∪ decimalbig': 5044565289845416380n,
+		},
+		{
+			'bigint64 ∪ bigint64': 5044565289845416380n,
+			'bigint64 ∪ decimalbig': 5044565289845416380n,
+			'decimalbig ∪ bigint64': 5044565289845416380n,
+			'decimalbig ∪ decimalbig': 5044565289845416380n,
+		},
+	]));
+
+	// ---- boolean ----
+	expect(
+		await unionAll(
+			db.select({
+				'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'boolean ∪ boolean': true,
+		},
+		{
+			'boolean ∪ boolean': true,
+		},
+	]));
+
+	// ---- date ----
+	expect(
+		await unionAll(
+			db.select({
+				'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+				'date ∪ datetime': allTypesCodecsTable.date.as('date ∪ datetime'),
+				'date ∪ timestamp': allTypesCodecsTable.date.as('date ∪ timestamp'),
+				'datetime ∪ date': allTypesCodecsTable.datetime.as('datetime ∪ date'),
+				'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+				'datetime ∪ timestamp': allTypesCodecsTable.datetime.as('datetime ∪ timestamp'),
+				'timestamp ∪ date': allTypesCodecsTable.timestamp.as('timestamp ∪ date'),
+				'timestamp ∪ datetime': allTypesCodecsTable.timestamp.as('timestamp ∪ datetime'),
+				'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+				'date ∪ datetime': allTypesCodecsTable.datetime.as('date ∪ datetime'),
+				'date ∪ timestamp': allTypesCodecsTable.timestamp.as('date ∪ timestamp'),
+				'datetime ∪ date': allTypesCodecsTable.date.as('datetime ∪ date'),
+				'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+				'datetime ∪ timestamp': allTypesCodecsTable.timestamp.as('datetime ∪ timestamp'),
+				'timestamp ∪ date': allTypesCodecsTable.date.as('timestamp ∪ date'),
+				'timestamp ∪ datetime': allTypesCodecsTable.datetime.as('timestamp ∪ datetime'),
+				'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'date ∪ date': new Date('2025-03-12'),
+			'date ∪ datetime': new Date('2025-03-12'),
+			'date ∪ timestamp': new Date('2025-03-12'),
+			'datetime ∪ date': new Date(1741743161623),
+			'datetime ∪ datetime': new Date(1741743161623),
+			'datetime ∪ timestamp': new Date(1741743161623),
+			'timestamp ∪ date': new Date(1741743161623),
+			'timestamp ∪ datetime': new Date(1741743161623),
+			'timestamp ∪ timestamp': new Date(1741743161623),
+		},
+		{
+			'date ∪ date': new Date('2025-03-12'),
+			'date ∪ datetime': new Date(1741743161623),
+			'date ∪ timestamp': new Date(1741743161623),
+			'datetime ∪ date': new Date('2025-03-12'),
+			'datetime ∪ datetime': new Date(1741743161623),
+			'datetime ∪ timestamp': new Date(1741743161623),
+			'timestamp ∪ date': new Date('2025-03-12'),
+			'timestamp ∪ datetime': new Date(1741743161623),
+			'timestamp ∪ timestamp': new Date(1741743161623),
+		},
+	]));
+
+	// ---- buffer ----
+	expect(
+		await unionAll(
+			db.select({
+				'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+				'blob ∪ tinyblob': allTypesCodecsTable.blob.as('blob ∪ tinyblob'),
+				'blob ∪ mediumblob': allTypesCodecsTable.blob.as('blob ∪ mediumblob'),
+				'blob ∪ longblob': allTypesCodecsTable.blob.as('blob ∪ longblob'),
+				'tinyblob ∪ blob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ blob'),
+				'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+				'tinyblob ∪ mediumblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ mediumblob'),
+				'tinyblob ∪ longblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ longblob'),
+				'mediumblob ∪ blob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ blob'),
+				'mediumblob ∪ tinyblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ tinyblob'),
+				'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+				'mediumblob ∪ longblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ longblob'),
+				'longblob ∪ blob': allTypesCodecsTable.longblob.as('longblob ∪ blob'),
+				'longblob ∪ tinyblob': allTypesCodecsTable.longblob.as('longblob ∪ tinyblob'),
+				'longblob ∪ mediumblob': allTypesCodecsTable.longblob.as('longblob ∪ mediumblob'),
+				'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+				'blob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('blob ∪ tinyblob'),
+				'blob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('blob ∪ mediumblob'),
+				'blob ∪ longblob': allTypesCodecsTable.longblob.as('blob ∪ longblob'),
+				'tinyblob ∪ blob': allTypesCodecsTable.blob.as('tinyblob ∪ blob'),
+				'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+				'tinyblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('tinyblob ∪ mediumblob'),
+				'tinyblob ∪ longblob': allTypesCodecsTable.longblob.as('tinyblob ∪ longblob'),
+				'mediumblob ∪ blob': allTypesCodecsTable.blob.as('mediumblob ∪ blob'),
+				'mediumblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('mediumblob ∪ tinyblob'),
+				'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+				'mediumblob ∪ longblob': allTypesCodecsTable.longblob.as('mediumblob ∪ longblob'),
+				'longblob ∪ blob': allTypesCodecsTable.blob.as('longblob ∪ blob'),
+				'longblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('longblob ∪ tinyblob'),
+				'longblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('longblob ∪ mediumblob'),
+				'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'blob ∪ blob': Buffer.from('string'),
+			'blob ∪ tinyblob': Buffer.from('string'),
+			'blob ∪ mediumblob': Buffer.from('string'),
+			'blob ∪ longblob': Buffer.from('string'),
+			'tinyblob ∪ blob': Buffer.from('string'),
+			'tinyblob ∪ tinyblob': Buffer.from('string'),
+			'tinyblob ∪ mediumblob': Buffer.from('string'),
+			'tinyblob ∪ longblob': Buffer.from('string'),
+			'mediumblob ∪ blob': Buffer.from('string'),
+			'mediumblob ∪ tinyblob': Buffer.from('string'),
+			'mediumblob ∪ mediumblob': Buffer.from('string'),
+			'mediumblob ∪ longblob': Buffer.from('string'),
+			'longblob ∪ blob': Buffer.from('string'),
+			'longblob ∪ tinyblob': Buffer.from('string'),
+			'longblob ∪ mediumblob': Buffer.from('string'),
+			'longblob ∪ longblob': Buffer.from('string'),
+		},
+		{
+			'blob ∪ blob': Buffer.from('string'),
+			'blob ∪ tinyblob': Buffer.from('string'),
+			'blob ∪ mediumblob': Buffer.from('string'),
+			'blob ∪ longblob': Buffer.from('string'),
+			'tinyblob ∪ blob': Buffer.from('string'),
+			'tinyblob ∪ tinyblob': Buffer.from('string'),
+			'tinyblob ∪ mediumblob': Buffer.from('string'),
+			'tinyblob ∪ longblob': Buffer.from('string'),
+			'mediumblob ∪ blob': Buffer.from('string'),
+			'mediumblob ∪ tinyblob': Buffer.from('string'),
+			'mediumblob ∪ mediumblob': Buffer.from('string'),
+			'mediumblob ∪ longblob': Buffer.from('string'),
+			'longblob ∪ blob': Buffer.from('string'),
+			'longblob ∪ tinyblob': Buffer.from('string'),
+			'longblob ∪ mediumblob': Buffer.from('string'),
+			'longblob ∪ longblob': Buffer.from('string'),
+		},
+	]));
+
+	// ---- enum ----
+	expect(
+		await unionAll(
+			db.select({
+				'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'enum ∪ enum': 'enV1',
+		},
+		{
+			'enum ∪ enum': 'enV1',
+		},
+	]));
+
+	// ---- json ----
+	expect(
+		await unionAll(
+			db.select({
+				'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+				'json1 ∪ json2': allTypesCodecsTable.json1.as('json1 ∪ json2'),
+				'json1 ∪ json3': allTypesCodecsTable.json1.as('json1 ∪ json3'),
+				'json1 ∪ json4': allTypesCodecsTable.json1.as('json1 ∪ json4'),
+				'json2 ∪ json1': allTypesCodecsTable.json2.as('json2 ∪ json1'),
+				'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+				'json2 ∪ json3': allTypesCodecsTable.json2.as('json2 ∪ json3'),
+				'json2 ∪ json4': allTypesCodecsTable.json2.as('json2 ∪ json4'),
+				'json3 ∪ json1': allTypesCodecsTable.json3.as('json3 ∪ json1'),
+				'json3 ∪ json2': allTypesCodecsTable.json3.as('json3 ∪ json2'),
+				'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+				'json3 ∪ json4': allTypesCodecsTable.json3.as('json3 ∪ json4'),
+				'json4 ∪ json1': allTypesCodecsTable.json4.as('json4 ∪ json1'),
+				'json4 ∪ json2': allTypesCodecsTable.json4.as('json4 ∪ json2'),
+				'json4 ∪ json3': allTypesCodecsTable.json4.as('json4 ∪ json3'),
+				'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+			}).from(allTypesCodecsTable),
+			db.select({
+				'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+				'json1 ∪ json2': allTypesCodecsTable.json2.as('json1 ∪ json2'),
+				'json1 ∪ json3': allTypesCodecsTable.json3.as('json1 ∪ json3'),
+				'json1 ∪ json4': allTypesCodecsTable.json4.as('json1 ∪ json4'),
+				'json2 ∪ json1': allTypesCodecsTable.json1.as('json2 ∪ json1'),
+				'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+				'json2 ∪ json3': allTypesCodecsTable.json3.as('json2 ∪ json3'),
+				'json2 ∪ json4': allTypesCodecsTable.json4.as('json2 ∪ json4'),
+				'json3 ∪ json1': allTypesCodecsTable.json1.as('json3 ∪ json1'),
+				'json3 ∪ json2': allTypesCodecsTable.json2.as('json3 ∪ json2'),
+				'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+				'json3 ∪ json4': allTypesCodecsTable.json4.as('json3 ∪ json4'),
+				'json4 ∪ json1': allTypesCodecsTable.json1.as('json4 ∪ json1'),
+				'json4 ∪ json2': allTypesCodecsTable.json2.as('json4 ∪ json2'),
+				'json4 ∪ json3': allTypesCodecsTable.json3.as('json4 ∪ json3'),
+				'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+			}).from(allTypesCodecsTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json2': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json3': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json4': { str: 'strval', arr: ['str', 10] },
+			'json2 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json2 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json2 ∪ json4': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json3 ∪ json1': 5,
+			'json3 ∪ json2': 5,
+			'json3 ∪ json3': 5,
+			'json3 ∪ json4': 5,
+			'json4 ∪ json1': '5',
+			'json4 ∪ json2': '5',
+			'json4 ∪ json3': '5',
+			'json4 ∪ json4': '5',
+		},
+		{
+			'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json1 ∪ json3': 5,
+			'json1 ∪ json4': '5',
+			'json2 ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json2 ∪ json3': 5,
+			'json2 ∪ json4': '5',
+			'json3 ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json3 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json3 ∪ json3': 5,
+			'json3 ∪ json4': '5',
+			'json4 ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json4 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json4 ∪ json3': 5,
+			'json4 ∪ json4': '5',
+		},
+	]));
+});
+
+test('Mappers: correct mappers enabled', async () => {
+	const jitDb = drizzle({ client, jit: true });
+
+	const dialect: MySqlDialect = (db as any).dialect;
+	const jitDialect: MySqlDialect = (jitDb as any).dialect;
+
+	expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+	expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+	expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+	expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+});
+
+test('Mappers: simple select - no rows', async () => {
+	const users = mysqlTable('mappers_users_1', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	await push({ users });
+
+	const result = await db.select().from(users);
+
+	expect(result).toStrictEqual([]);
+});
+
+test('Mappers: select - nothing to decode - text', async () => {
+	const users = mysqlTable('mappers_users_2', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	const selected = await db.select({ name: users.name }).from(users);
+
+	expect(selected).toStrictEqual([{ name: 'First' }]);
+});
+
+test('Mappers: select - nothing to decode - null', async () => {
+	const users = mysqlTable('mappers_users_3', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+	expect(selected).toStrictEqual([{ isBanned: null }]);
+});
+
+test('Mappers: insert $returningId + select', async () => {
+	const users = mysqlTable('mappers_users_4', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+	const selected = await db.select().from(users);
+
+	expect(selected).toStrictEqual([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+		isBanned: null,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+		isBanned: null,
+	}]);
+});
+
+test('Mappers: select complex selections', async () => {
+	const users = mysqlTable('mappers_users_5', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const posts = mysqlTable('mappers_posts_1', (t) => ({
+		id: t.int('id').primaryKey(),
+		authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+		content: t.text('content'),
+	}));
+
+	await push({ users, posts });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	await db.insert(posts).values({
+		id: 1,
+		authorId: 1,
+		content: 'p1',
+	});
+
+	const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected3 = await db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected4 = await db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+
+	expect(selected1).toStrictEqual([{
+		user: {
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: {
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		},
+	}, {
+		user: {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		},
+		post: null,
+	}, {
+		user: {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: null,
+	}]);
+	expect(selected2).toStrictEqual([{
+		user: {
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: {
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		},
+	}]);
+	expect(selected3).toStrictEqual([
+		{
+			content: 'p1',
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'First',
+			postId: 1,
+			userId: 1,
+		},
+		{
+			content: null,
+			createdAt: mappersDate,
+			isBanned: true,
+			name: 'Second',
+			postId: null,
+			userId: 2,
+		},
+		{
+			content: null,
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'Third',
+			postId: null,
+			userId: 3,
+		},
+	]);
+	expect(selected4).toStrictEqual([
+		{
+			content: 'p1',
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'First',
+			postId: 1,
+			userId: 1,
+		},
+	]);
+});
+
+test('Mappers: relational', async () => {
+	const users = mysqlTable('mappers_users_6', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const posts = mysqlTable('mappers_posts_2', (t) => ({
+		id: t.int('id').primaryKey(),
+		authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+		content: t.text('content'),
+	}));
+
+	await push({ users, posts });
+	const db = drizzle({
+		client,
+		relations: defineRelations({ users, posts }, (r) => ({
+			users: {
+				post: r.one.posts({
+					from: r.users.id,
+					to: r.posts.authorId,
+				}),
+				posts: r.one.posts({
+					from: r.users.id,
+					to: r.posts.authorId,
+				}),
+			},
+			posts: {
+				author: r.one.users({
+					from: r.posts.authorId,
+					to: r.users.id,
+				}),
+				authors: r.many.users({
+					from: r.posts.authorId,
+					to: r.users.id,
+				}),
+			},
+		})),
+	});
+
+	const empty1 = await db.query.users.findFirst();
+	const empty2 = await db.query.users.findMany();
+
+	expect(empty1).toStrictEqual(undefined);
+	expect(empty2).toStrictEqual([]);
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	await db.insert(posts).values({
+		id: 1,
+		authorId: 1,
+		content: 'p1',
+	});
+
+	const simple1 = await db.query.users.findFirst();
+	const simple2 = await db.query.users.findMany();
+
+	expect(simple1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+		},
+	);
+	expect(simple2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+		},
+	]);
+
+	const extra1 = await db.query.users.findFirst({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+	const extra2 = await db.query.users.findMany({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+
+	expect(extra1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	);
+	expect(extra2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	]);
+
+	const nested1 = await db.query.users.findFirst({
+		with: {
+			post: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+			posts: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+	const nested2 = await db.query.users.findMany({
+		with: {
+			post: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+			posts: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+
+	expect(nested1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			post: {
+				author: null,
+				authorId: 1,
+				authors: [],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			posts: {
+				author: {
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				authorId: 1,
+				authors: [
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	);
+	expect(nested2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			post: {
+				author: null,
+				authorId: 1,
+				authors: [],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			posts: {
+				author: {
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				authorId: 1,
+				authors: [
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+			post: null,
+			posts: null,
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+			post: null,
+			posts: null,
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	]);
+});
+
+test('Jit mappers: simple select - no rows', async () => {
+	const users = mysqlTable('jit_mappers_users_1', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const db = drizzle({ client, jit: true });
+	await push({ users });
+
+	const result = await db.select().from(users);
+
+	expect(result).toStrictEqual([]);
+});
+
+test('Jit mappers: select - nothing to decode - text', async () => {
+	const users = mysqlTable('jit_mappers_users_2', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const db = drizzle({ client, jit: true });
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	const selected = await db.select({ name: users.name }).from(users);
+
+	expect(selected).toStrictEqual([{ name: 'First' }]);
+});
+
+test('Jit mappers: select - nothing to decode - null', async () => {
+	const users = mysqlTable('jit_mappers_users_3', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const db = drizzle({ client, jit: true });
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+	expect(selected).toStrictEqual([{ isBanned: null }]);
+});
+
+test('Jit mappers: insert $returningId + select', async () => {
+	const users = mysqlTable('jit_mappers_users_4', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const db = drizzle({ client, jit: true });
+	await push({ users });
+
+	const insertedIds = await db.insert(users).values([{
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+	const selected = await db.select().from(users);
+
+	expect(selected).toStrictEqual([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+		isBanned: null,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+		isBanned: null,
+	}]);
+});
+
+test('Jit mappers: select complex selections', async () => {
+	const users = mysqlTable('jit_mappers_users_5', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const posts = mysqlTable('jit_mappers_posts_1', (t) => ({
+		id: t.int('id').primaryKey(),
+		authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+		content: t.text('content'),
+	}));
+
+	const db = drizzle({ client, jit: true });
+	await push({ users, posts });
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	await db.insert(posts).values({
+		id: 1,
+		authorId: 1,
+		content: 'p1',
+	});
+
+	const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected3 = await db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).leftJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+	const selected4 = await db.select({
+		userId: users.id,
+		postId: posts.id,
+		name: users.name,
+		isBanned: users.isBanned,
+		content: posts.content,
+		createdAt: users.createdAt,
+	}).from(users).innerJoin(
+		posts,
+		eq(users.id, posts.authorId),
+	);
+
+	expect(selected1).toStrictEqual([{
+		user: {
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: {
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		},
+	}, {
+		user: {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		},
+		post: null,
+	}, {
+		user: {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: null,
+	}]);
+	expect(selected2).toStrictEqual([{
+		user: {
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		},
+		post: {
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		},
+	}]);
+	expect(selected3).toStrictEqual([
+		{
+			content: 'p1',
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'First',
+			postId: 1,
+			userId: 1,
+		},
+		{
+			content: null,
+			createdAt: mappersDate,
+			isBanned: true,
+			name: 'Second',
+			postId: null,
+			userId: 2,
+		},
+		{
+			content: null,
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'Third',
+			postId: null,
+			userId: 3,
+		},
+	]);
+	expect(selected4).toStrictEqual([
+		{
+			content: 'p1',
+			createdAt: mappersDate,
+			isBanned: null,
+			name: 'First',
+			postId: 1,
+			userId: 1,
+		},
+	]);
+});
+
+test('Jit mappers: relational', async () => {
+	const users = mysqlTable('jit_mappers_users_6', (t) => ({
+		id: t.bigint('id', { mode: 'number' }).primaryKey(),
+		name: t.text('name').notNull(),
+		createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+		isBanned: t.boolean('is_banned'),
+	}));
+
+	const posts = mysqlTable('jit_mappers_posts_2', (t) => ({
+		id: t.int('id').primaryKey(),
+		authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+		content: t.text('content'),
+	}));
+
+	await push({ users, posts });
+	const db = drizzle({
+		client,
+		jit: true,
+		relations: defineRelations({ users, posts }, (r) => ({
+			users: {
+				post: r.one.posts({
+					from: r.users.id,
+					to: r.posts.authorId,
+				}),
+				posts: r.one.posts({
+					from: r.users.id,
+					to: r.posts.authorId,
+				}),
+			},
+			posts: {
+				author: r.one.users({
+					from: r.posts.authorId,
+					to: r.users.id,
+				}),
+				authors: r.many.users({
+					from: r.posts.authorId,
+					to: r.users.id,
+				}),
+			},
+		})),
+	});
+
+	const empty1 = await db.query.users.findFirst();
+	const empty2 = await db.query.users.findMany();
+
+	expect(empty1).toStrictEqual(undefined);
+	expect(empty2).toStrictEqual([]);
+
+	const insertedIds = await db.insert(users).values([{
+		id: 1,
+		name: 'First',
+		createdAt: mappersDate,
+	}, {
+		id: 2,
+		name: 'Second',
+		createdAt: mappersDate,
+		isBanned: true,
+	}, {
+		id: 3,
+		name: 'Third',
+		createdAt: mappersDate,
+	}]).$returningId();
+
+	expect(insertedIds).toStrictEqual([]);
+
+	await db.insert(posts).values({
+		id: 1,
+		authorId: 1,
+		content: 'p1',
+	});
+
+	const simple1 = await db.query.users.findFirst();
+	const simple2 = await db.query.users.findMany();
+
+	expect(simple1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+		},
+	);
+	expect(simple2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+		},
+	]);
+
+	const extra1 = await db.query.users.findFirst({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+	const extra2 = await db.query.users.findMany({
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+
+	expect(extra1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	);
+	expect(extra2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	]);
+
+	const nested1 = await db.query.users.findFirst({
+		with: {
+			post: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+			posts: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+	const nested2 = await db.query.users.findMany({
+		with: {
+			post: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+						where: {
+							RAW: sql`false`,
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+			posts: {
+				with: {
+					author: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					authors: {
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			},
+		},
+		extras: {
+			sql: sql`SELECT 1`.mapWith(Number),
+			sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+		},
+	});
+
+	expect(nested1).toStrictEqual(
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			post: {
+				author: null,
+				authorId: 1,
+				authors: [],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			posts: {
+				author: {
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				authorId: 1,
+				authors: [
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	);
+	expect(nested2).toStrictEqual([
+		{
+			createdAt: mappersDate,
+			id: 1,
+			isBanned: null,
+			name: 'First',
+			post: {
+				author: null,
+				authorId: 1,
+				authors: [],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			posts: {
+				author: {
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				authorId: 1,
+				authors: [
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				],
+				content: 'p1',
+				id: 1,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 2,
+			isBanned: true,
+			name: 'Second',
+			post: null,
+			posts: null,
+			sql: 1,
+			sqlWrapper: 2,
+		},
+		{
+			createdAt: mappersDate,
+			id: 3,
+			isBanned: null,
+			name: 'Third',
+			post: null,
+			posts: null,
+			sql: 1,
+			sqlWrapper: 2,
+		},
+	]);
+});
+
+test('Column as decoder applies codecs', async () => {
+	let customCast = false;
+	let customMap = false;
+
+	const codecBypass = customType<{
+		data: Date;
+		driverData: string;
+		jsonData: string;
+	}>({
+		codec: 'timestamp',
+		dataType: () => 'timestamp(3)',
+		forJsonSelect: (identifier, sql) => {
+			customCast = true;
+			return sql`cast(${identifier} as char)`;
+		},
+		fromJson: (v) => {
+			customMap = true;
+			return new Date(v + '+0000');
+		},
+		toDriver: (v) => v.toISOString().replace('T', ' ').replace('Z', ''),
+	});
+
+	const users = mysqlTable('users_823', (t) => ({
+		id: t.int().primaryKey(),
+		name: t.text().notNull(),
+		createdAt: t.timestamp('created_at', { fsp: 3 }).notNull(),
+		createdAtStr: t.timestamp('created_at_str', { fsp: 3, mode: 'string' }).notNull(),
+		cus: codecBypass('custom').notNull(),
+	}));
+
+	const usersView = mysqlView('users_823_v').as((qb) =>
+		qb.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id)
+	);
+
+	await push({ users, usersView });
+
+	const db = drizzle({
+		client,
+		relations: defineRelations({ users, usersView }, (r) => ({
+			users: {
+				self: r.one.users({
+					from: r.users.id,
+					to: r.users.id,
+				}),
+			},
+			usersView: {
+				self: r.one.usersView({
+					from: r.usersView.id,
+					to: r.usersView.id,
+				}),
+			},
+		})),
+	});
+
+	const exDateStr = '1970-01-16 16:45:46.351';
+	const exDate = new Date(exDateStr);
+
+	await db.insert(users).values({
+		id: 1,
+		name: 'First',
+		createdAt: exDate,
+		createdAtStr: exDateStr,
+		cus: exDate,
+	});
+
+	const res = await db.select({
+		...getColumns(users),
+		max: max(users.createdAt).as('max'),
+		maxStr: max(users.createdAtStr).as('max_str'),
+		sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+	}).from(users).groupBy(users.id);
+
+	const viewRes = await db.select().from(usersView);
+
+	const nested = await db.query.users.findFirst({
+		with: {
+			self: {
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+				},
+			},
+		},
+		extras: {
+			max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+			maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+		},
+	});
+
+	const viewNested = await db.query.usersView.findFirst({
+		columns: {
+			sq: false, // TODO: re-enable when supported in RQBv2
+		},
+		with: {
+			self: {
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+			},
+		},
+	});
+
+	expect(res).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			sq: exDate,
+			cus: exDate,
+		},
+	]);
+	expect(viewRes).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			sq: exDate,
+			cus: exDate,
+		},
+	]);
+
+	expect(customCast).toBeTruthy();
+	expect(customMap).toBeTruthy();
+
+	expect(nested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			cus: exDate,
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+			},
+		},
+	);
+	expect(viewNested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			cus: exDate,
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+			},
+		},
+	);
+});
+
+test('Column as decoder applies codecs - Jit mappers', async () => {
+	let customCast = false;
+	let customMap = false;
+
+	const codecBypass = customType<{
+		data: Date;
+		driverData: string;
+		jsonData: string;
+	}>({
+		codec: 'timestamp',
+		dataType: () => 'timestamp(3)',
+		forJsonSelect: (identifier, sql) => {
+			customCast = true;
+			return sql`cast(${identifier} as char)`;
+		},
+		fromJson: (v) => {
+			customMap = true;
+			return new Date(v + '+0000');
+		},
+		toDriver: (v) => v.toISOString().replace('T', ' ').replace('Z', ''),
+	});
+
+	const users = mysqlTable('users_823_jit', (t) => ({
+		id: t.int().primaryKey(),
+		name: t.text().notNull(),
+		createdAt: t.timestamp('created_at', { fsp: 3 }).notNull(),
+		createdAtStr: t.timestamp('created_at_str', { fsp: 3, mode: 'string' }).notNull(),
+		cus: codecBypass('custom').notNull(),
+	}));
+
+	const usersView = mysqlView('users_823_v_jit').as((qb) =>
+		qb.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id)
+	);
+
+	await push({ users, usersView });
+
+	const db = drizzle({
+		client,
+		jit: true,
+		relations: defineRelations({ users, usersView }, (r) => ({
+			users: {
+				self: r.one.users({
+					from: r.users.id,
+					to: r.users.id,
+				}),
+			},
+			usersView: {
+				self: r.one.usersView({
+					from: r.usersView.id,
+					to: r.usersView.id,
+				}),
+			},
+		})),
+	});
+
+	const exDateStr = '1970-01-16 16:45:46.351';
+	const exDate = new Date(exDateStr);
+
+	await db.insert(users).values({
+		id: 1,
+		name: 'First',
+		createdAt: exDate,
+		createdAtStr: exDateStr,
+		cus: exDate,
+	});
+
+	const res = await db.select({
+		...getColumns(users),
+		max: max(users.createdAt).as('max'),
+		maxStr: max(users.createdAtStr).as('max_str'),
+		sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+	}).from(users).groupBy(users.id);
+
+	const viewRes = await db.select().from(usersView);
+
+	const nested = await db.query.users.findFirst({
+		with: {
+			self: {
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+				},
+			},
+		},
+		extras: {
+			max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+			maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+		},
+	});
+
+	const viewNested = await db.query.usersView.findFirst({
+		columns: {
+			sq: false, // TODO: re-enable when supported in RQBv2
+		},
+		with: {
+			self: {
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+			},
+		},
+	});
+
+	expect(res).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			sq: exDate,
+			cus: exDate,
+		},
+	]);
+	expect(viewRes).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			sq: exDate,
+			cus: exDate,
+		},
+	]);
+
+	expect(customCast).toBeTruthy();
+	expect(customMap).toBeTruthy();
+
+	expect(nested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			cus: exDate,
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+			},
+		},
+	);
+	expect(viewNested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			max: exDate,
+			maxStr: exDateStr,
+			cus: exDate,
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+			},
+		},
+	);
+});
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class TestGlobalCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy(): 'explicit' | 'all' {
+		return 'all';
+	}
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends TestGlobalCache {
+	override strategy(): 'explicit' | 'all' {
+		return 'explicit';
+	}
+}
+
+declare module 'vitest' {
+	interface TestContext {
+		cachedMySQL: {
+			db: MySqlAsyncDatabase<any, any>;
+			dbGlobalCached: MySqlAsyncDatabase<any, any>;
+		};
+	}
+}
+
+const usersTableCache = mysqlTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+});
+
+const postsTableCache = mysqlTable('posts', {
+	id: serial().primaryKey(),
+	description: text().notNull(),
+	userId: int('city_id').references(() => usersTable.id),
+});
+
+describe('common_cache', () => {
+	beforeEach(async () => {
+		const db = cachedDb;
+		await db.execute(sql`drop table if exists users`);
+		await db.execute(sql`drop table if exists posts`);
+		await db.$cache?.invalidate({ tables: 'users' });
+		await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
+		// public users
+		await db.execute(
+			sql`
+				create table users (
+					id serial primary key,
+					name text not null,
+					verified boolean not null default false,
+					jsonb json,
+					created_at timestamp not null default now()
+				)
+			`,
+		);
+		await db.execute(
+			sql`
+				create table posts (
+					id serial primary key,
+					description text not null,
+					user_id int
+				)
+			`,
+		);
+	});
+
+	test('test force invalidate', async () => {
+		const db = cachedDb;
+
+		const spyInvalidate = spyOn(db.$cache, 'invalidate');
+		await db.$cache?.invalidate({ tables: 'users' });
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('default global config - no cache should be hit', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('default global config + enable cache on select: get, put', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache();
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('default global config + enable cache on select + write: get, put, onMutate', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ config: { ex: 1 } });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		spyPut.mockClear();
+		spyGet.mockClear();
+		spyInvalidate.mockClear();
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('default global config + enable cache on select + disable invalidate: get, put', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		// invalidate force
+		await db.$cache?.invalidate({ tags: ['custom'] });
+	});
+
+	test('global: true + disable cache', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache(false);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - cache should be hit', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache);
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - cache: false on select - no cache hit', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache(false);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - disable invalidate - cache hit + no invalidate', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ autoInvalidate: false });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		spyPut.mockClear();
+		spyGet.mockClear();
+		spyInvalidate.mockClear();
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('global: true - with custom tag', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ tag: 'custom', autoInvalidate: false });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		// invalidate force
+		await db.$cache?.invalidate({ tags: ['custom'] });
+	});
+
+	// check select used tables
+	test('check simple select used tables', () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		expect(db.select().from(usersTableCache).getUsedTables()).toStrictEqual(['users']);
+		// @ts-expect-error
+		expect(db.select().from(sql`${usersTableCache}`).getUsedTables()).toStrictEqual(['users']);
+	});
+	// check select+join used tables
+	test('select+join', () => {
+		const db = cachedDb;
+
+		expect(
+			db.select().from(usersTableCache).leftJoin(postsTableCache, eq(usersTableCache.id, postsTableCache.userId))
+				// @ts-expect-error
+				.getUsedTables(),
+		)
+			.toStrictEqual(['users', 'posts']);
+		expect(
+			db.select().from(sql`${usersTableCache}`).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+				// @ts-expect-error
+			).getUsedTables(),
+		).toStrictEqual(['users', 'posts']);
+	});
+	// check select+2join used tables
+	test('select+2joins', () => {
+		const db = cachedDb;
+
+		expect(
+			db.select().from(usersTableCache).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+			).leftJoin(
+				alias(postsTableCache, 'post2'),
+				eq(usersTableCache.id, postsTableCache.userId),
+			)
+				// @ts-expect-error
+				.getUsedTables(),
+		)
+			.toStrictEqual(['users', 'posts']);
+		expect(
+			db.select().from(sql`${usersTableCache}`).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+			).leftJoin(
+				alias(postsTableCache, 'post2'),
+				eq(usersTableCache.id, postsTableCache.userId),
+				// @ts-expect-error
+			).getUsedTables(),
+		).toStrictEqual(['users', 'posts']);
+	});
+	// select subquery used tables
+	test('select+join', () => {
+		const db = cachedDb;
+
+		const sq = db.select().from(usersTableCache).where(eq(usersTableCache.id, 42)).as('sq');
+		db.select().from(sq);
+
+		// @ts-expect-error
+		expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
+	});
+});
diff --git a/integration-tests/tests/bun/bun-sql.test.ts b/integration-tests/tests/bun/bun-sql.test.ts
index ad79755915..490f938db7 100644
--- a/integration-tests/tests/bun/bun-sql.test.ts
+++ b/integration-tests/tests/bun/bun-sql.test.ts
@@ -1,7 +1,5 @@
-import retry from 'async-retry';
 import { SQL as BunSQL } from 'bun';
-import { afterAll, afterEach, beforeAll, beforeEach, expect, test } from 'bun:test';
-import type Docker from 'dockerode';
+import { afterEach, beforeAll, beforeEach, expect, test } from 'bun:test';
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import {
 	and,
@@ -13,9 +11,12 @@ import {
 	avgDistinct,
 	count,
 	countDistinct,
+	defineRelations,
+	DrizzleQueryError,
 	eq,
 	Equal,
 	exists,
+	getColumns,
 	getTableColumns,
 	gt,
 	gte,
@@ -34,18 +35,22 @@ import {
 	sumDistinct,
 	TransactionRollbackError,
 } from 'drizzle-orm';
-import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
 import { drizzle } from 'drizzle-orm/bun-sql';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql/postgres';
 import { authenticatedRole, crudPolicy } from 'drizzle-orm/neon';
-import { usersSync } from 'drizzle-orm/neon/neon-identity';
-import type { PgColumn, PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
+import { usersSync } from 'drizzle-orm/neon/neon-auth';
+import type { PgColumn } from 'drizzle-orm/pg-core';
 import {
 	alias,
+	bigint,
 	bigserial,
 	boolean,
+	bytea,
 	char,
 	cidr,
+	customType,
 	date,
+	doublePrecision,
 	except,
 	exceptAll,
 	foreignKey,
@@ -60,6 +65,7 @@ import {
 	interval,
 	json,
 	jsonb,
+	line,
 	macaddr,
 	macaddr8,
 	numeric,
@@ -72,8 +78,12 @@ import {
 	pgTable,
 	pgTableCreator,
 	pgView,
+	point,
 	primaryKey,
+	real,
 	serial,
+	smallint,
+	smallserial,
 	text,
 	time,
 	timestamp,
@@ -81,9 +91,16 @@ import {
 	unionAll,
 	unique,
 	uniqueKeyName,
+	uuid,
+	uuid as pgUuid,
 	varchar,
 } from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async/db';
+import { PgQueryResultHKT } from 'drizzle-orm/pg-core/session';
+import { clear, init, rqbPost, rqbUser } from '~/pg/schema';
+import { normalizeDataWithDbCodecs } from '~/pg/utils';
 import { Expect } from '~/utils';
+import { relations } from '../pg/relations';
 
 export const usersTable = pgTable('users', {
 	id: serial('id' as string).primaryKey(),
@@ -147,11 +164,11 @@ const network = pgTable('network_table', {
 const salEmp = pgTable('sal_emp', {
 	name: text('name'),
 	payByQuarter: integer('pay_by_quarter').array(),
-	schedule: text('schedule').array().array(),
+	schedule: text('schedule').array('[][]'),
 });
 
 const _tictactoe = pgTable('tictactoe', {
-	squares: integer('squares').array(3).array(3),
+	squares: integer('squares').array('[][]'),
 });
 
 export const usersMigratorTable = pgTable('users12', {
@@ -199,38 +216,158 @@ const jsonTestTable = pgTable('jsontest', {
 	jsonb: jsonb('jsonb').$type<{ string: string; number: number }>(),
 });
 
-let pgContainer: Docker.Container;
-
-afterAll(async () => {
-	await pgContainer?.stop().catch(console.error);
-});
-
-let db: BunSQLDatabase;
-let client: BunSQL;
+const en = pgEnum('en', ['enVal1', 'enVal2']);
+
+const allTypesTable = pgTable('all_types', {
+	serial: serial('serial'),
+	bigserial53: bigserial('bigserial53', {
+		mode: 'number',
+	}),
+	bigserial64: bigserial('bigserial64', {
+		mode: 'bigint',
+	}),
+	int: integer('int'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	bool: boolean('bool'),
+	char: char('char'),
+	cidr: cidr('cidr'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	double: doublePrecision('double'),
+	enum: en('enum'),
+	inet: inet('inet'),
+	interval: interval('interval'),
+	json: json('json'),
+	jsonb: jsonb('jsonb'),
+	line: line('line', {
+		mode: 'abc',
+	}),
+	lineTuple: line('line_tuple', {
+		mode: 'tuple',
+	}),
+	macaddr: macaddr('macaddr'),
+	macaddr8: macaddr8('macaddr8'),
+	numeric: numeric('numeric'),
+	numericNum: numeric('numeric_num', {
+		mode: 'number',
+	}),
+	numericBig: numeric('numeric_big', {
+		mode: 'bigint',
+	}),
+	point: point('point', {
+		mode: 'xy',
+	}),
+	pointTuple: point('point_tuple', {
+		mode: 'tuple',
+	}),
+	real: real('real'),
+	smallint: smallint('smallint'),
+	smallserial: smallserial('smallserial'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampTz: timestamp('timestamp_tz', {
+		mode: 'date',
+		withTimezone: true,
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	timestampTzStr: timestamp('timestamp_tz_str', {
+		mode: 'string',
+		withTimezone: true,
+	}),
+	uuid: uuid('uuid'),
+	varchar: varchar('varchar'),
+	arrint: integer('arrint').array(),
+	arrbigint53: bigint('arrbigint53', {
+		mode: 'number',
+	}).array(),
+	arrbigint64: bigint('arrbigint64', {
+		mode: 'bigint',
+	}).array(),
+	arrbool: boolean('arrbool').array(),
+	arrchar: char('arrchar').array(),
+	arrcidr: cidr('arrcidr').array(),
+	arrdate: date('arrdate', {
+		mode: 'date',
+	}).array(),
+	arrdateStr: date('arrdate_str', {
+		mode: 'string',
+	}).array(),
+	arrdouble: doublePrecision('arrdouble').array(),
+	arrenum: en('arrenum').array(),
+	arrinet: inet('arrinet').array(),
+	arrinterval: interval('arrinterval').array(),
+	arrjson: json('arrjson').array(),
+	arrjsonb: jsonb('arrjsonb').array(),
+	arrline: line('arrline', {
+		mode: 'abc',
+	}).array(),
+	arrlineTuple: line('arrline_tuple', {
+		mode: 'tuple',
+	}).array(),
+	arrmacaddr: macaddr('arrmacaddr').array(),
+	arrmacaddr8: macaddr8('arrmacaddr8').array(),
+	arrnumeric: numeric('arrnumeric').array(),
+	arrnumericNum: numeric('arrnumeric_num', {
+		mode: 'number',
+	}).array(),
+	arrnumericBig: numeric('arrnumeric_big', {
+		mode: 'bigint',
+	}).array(),
+	arrpoint: point('arrpoint', {
+		mode: 'xy',
+	}).array(),
+	arrpointTuple: point('arrpoint_tuple', {
+		mode: 'tuple',
+	}).array(),
+	arrreal: real('arrreal').array(),
+	arrsmallint: smallint('arrsmallint').array(),
+	arrtext: text('arrtext').array(),
+	arrtime: time('arrtime').array(),
+	arrtimestamp: timestamp('arrtimestamp', {
+		mode: 'date',
+	}).array(),
+	arrtimestampTz: timestamp('arrtimestamp_tz', {
+		mode: 'date',
+		withTimezone: true,
+	}).array(),
+	arrtimestampStr: timestamp('arrtimestamp_str', {
+		mode: 'string',
+	}).array(),
+	arrtimestampTzStr: timestamp('arrtimestamp_tz_str', {
+		mode: 'string',
+		withTimezone: true,
+	}).array(),
+	arruuid: uuid('arruuid').array(),
+	arrvarchar: varchar('arrvarchar').array(),
+});
+
+let db: BunSQLDatabase<typeof relations>;
 
 beforeAll(async () => {
-	console.log('here');
 	const connectionString = process.env['PG_CONNECTION_STRING'];
-	client = await retry(async () => {
-		// @ts-expect-error
-		const connClient = new BunSQL(connectionString, { max: 1 });
-		await connClient.unsafe(`select 1`);
-		return connClient;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: false });
-});
+	if (!connectionString) {
+		throw new Error(
+			'PG_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up postgres` and export the connection string before running tests.',
+		);
+	}
+	const connClient = new BunSQL(connectionString, { max: 1 });
+	await connClient.unsafe(`select 1`);
 
-afterAll(async () => {
-	await client?.end();
+	db = drizzle({ client: connClient, logger: false, relations });
 });
 
 beforeEach(async () => {
@@ -373,7 +510,7 @@ afterEach(async () => {
 	await db.execute(sql`drop schema if exists custom_migrations cascade`);
 });
 
-async function setupSetOperationTest(db: PgDatabase<PgQueryResultHKT>) {
+async function setupSetOperationTest(db: PgAsyncDatabase<PgQueryResultHKT, any>) {
 	await db.execute(sql`drop table if exists users2`);
 	await db.execute(sql`drop table if exists cities`);
 	await db.execute(
@@ -412,7 +549,7 @@ async function setupSetOperationTest(db: PgDatabase<PgQueryResultHKT>) {
 	]);
 }
 
-async function setupAggregateFunctionsTest(db: PgDatabase<PgQueryResultHKT>) {
+async function setupAggregateFunctionsTest(db: PgAsyncDatabase<PgQueryResultHKT, any>) {
 	await db.execute(sql`drop table if exists "aggregate_table"`);
 	await db.execute(
 		sql`
@@ -442,10 +579,7 @@ test('table configs: unique third param', async () => {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull(),
 		state: char('state', { length: 2 }),
-	}, (t) => ({
-		f: unique('custom_name').on(t.name, t.state).nullsNotDistinct(),
-		f1: unique('custom_name1').on(t.name, t.state),
-	}));
+	}, (t) => [unique('custom_name').on(t.name, t.state).nullsNotDistinct(), unique('custom_name1').on(t.name, t.state)]);
 
 	const tableConfig = getTableConfig(cities1Table);
 
@@ -472,7 +606,7 @@ test('table configs: unique in column', async () => {
 
 	const columnName = tableConfig.columns.find((it) => it.name === 'name');
 
-	expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
+	expect(columnName?.uniqueName).toBe(undefined);
 	expect(columnName?.isUnique).toBe(true);
 
 	const columnState = tableConfig.columns.find((it) => it.name === 'state');
@@ -490,9 +624,7 @@ test('table config: foreign keys name', async () => {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull(),
 		state: text('state'),
-	}, (t) => ({
-		f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
-	}));
+	}, (t) => [foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' })]);
 
 	const tableConfig = getTableConfig(table);
 
@@ -505,9 +637,9 @@ test('table config: primary keys name', async () => {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull(),
 		state: text('state'),
-	}, (t) => ({
-		f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-	}));
+	}, (t) => [
+		primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
+	]);
 
 	const tableConfig = getTableConfig(table);
 
@@ -937,7 +1069,7 @@ test('build query', async () => {
 	});
 });
 
-test.only('insert sql', async () => {
+test('insert sql', async () => {
 	await db.insert(usersTable).values({ name: sql`${'John'}` });
 	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
@@ -1272,7 +1404,7 @@ test('build query insert with onConflict do update', async () => {
 	expect(query).toEqual({
 		sql:
 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
-		params: ['John', '["foo","bar"]', 'John1'],
+		params: ['John', ['foo', 'bar'], 'John1'],
 	});
 });
 
@@ -1286,7 +1418,7 @@ test('build query insert with onConflict do update / multiple columns', async ()
 	expect(query).toEqual({
 		sql:
 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
-		params: ['John', '["foo","bar"]', 'John1'],
+		params: ['John', ['foo', 'bar'], 'John1'],
 	});
 });
 
@@ -1300,7 +1432,7 @@ test('build query insert with onConflict do nothing', async () => {
 	expect(query).toEqual({
 		sql:
 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
-		params: ['John', '["foo","bar"]'],
+		params: ['John', ['foo', 'bar']],
 	});
 });
 
@@ -1314,7 +1446,7 @@ test('build query insert with onConflict do nothing + target', async () => {
 	expect(query).toEqual({
 		sql:
 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
-		params: ['John', '["foo","bar"]'],
+		params: ['John', ['foo', 'bar']],
 	});
 });
 
@@ -1777,7 +1909,7 @@ test('select count()', async () => {
 
 	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
 
-	expect(res).toEqual([{ count: '2' }]);
+	expect(res).toEqual([{ count: 2n }]);
 });
 
 test('select count w/ custom mapper', async () => {
@@ -2078,6 +2210,7 @@ test('select from raw sql', async () => {
 		name: sql<string>`name`,
 	}).from(sql`(select 1 as id, 'John' as name) as users`);
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<Equal<{ id: number; name: string }[], typeof result>>;
 	expect(result).toEqual([
 		{ id: 1, name: 'John' },
@@ -2095,6 +2228,7 @@ test('select from raw sql with joins', async () => {
 		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
 		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
 
 	expect(result).toEqual([
@@ -2114,6 +2248,7 @@ test('join on aliased sql from select', async () => {
 		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
 		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<
 		Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
 	>;
@@ -2155,6 +2290,7 @@ test('join on aliased sql from with clause', async () => {
 		.from(users)
 		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<
 		Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
 	>;
@@ -2327,6 +2463,7 @@ test('select from enum', async () => {
 	await db.execute(sql`drop type ${sql.identifier(categoryEnum.enumName)}`);
 });
 
+// https://github.com/drizzle-team/drizzle-orm/issues/4311s
 test.skip('all date and time columns', async () => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
@@ -2373,6 +2510,7 @@ test.skip('all date and time columns', async () => {
 
 	const result = await db.select().from(table);
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<
 		Equal<{
 			id: number;
@@ -2387,6 +2525,7 @@ test.skip('all date and time columns', async () => {
 		}[], typeof result>
 	>;
 
+	// oxlint-disable-next-line no-unused-expressions
 	Expect<
 		Equal<{
 			dateString: string;
@@ -3462,7 +3601,7 @@ test.skip('array mapping and parsing', async () => {
 	const arrays = pgTable('arrays_tests', {
 		id: serial('id').primaryKey(),
 		tags: text('tags').array(),
-		nested: text('nested').array().array(),
+		nested: text('nested').array('[][]'),
 		numbers: integer('numbers').notNull().array(),
 	});
 
@@ -4015,7 +4154,7 @@ test('mySchema :: build query insert with onConflict do update / multiple column
 	expect(query).toEqual({
 		sql:
 			'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
-		params: ['John', '["foo","bar"]', 'John1'],
+		params: ['John', ['foo', 'bar'], 'John1'],
 	});
 });
 
@@ -4028,7 +4167,7 @@ test('mySchema :: build query insert with onConflict do nothing + target', async
 	expect(query).toEqual({
 		sql:
 			'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
-		params: ['John', '["foo","bar"]'],
+		params: ['John', ['foo', 'bar']],
 	});
 });
 
@@ -4285,7 +4424,7 @@ test.skip('proper json and jsonb handling', async () => {
 	]);
 });
 
-test.todo('set json/jsonb fields with objects and retrieve with the ->> operator', async () => {
+test.skip('set json/jsonb fields with objects and retrieve with the ->> operator', async () => {
 	const obj = { string: 'test', number: 123 };
 	const { string: testString, number: testNumber } = obj;
 
@@ -4309,7 +4448,7 @@ test.todo('set json/jsonb fields with objects and retrieve with the ->> operator
 	}]);
 });
 
-test.todo('set json/jsonb fields with strings and retrieve with the ->> operator', async () => {
+test.skip('set json/jsonb fields with strings and retrieve with the ->> operator', async () => {
 	const obj = { string: 'test', number: 123 };
 	const { string: testString, number: testNumber } = obj;
 
@@ -4333,7 +4472,7 @@ test.todo('set json/jsonb fields with strings and retrieve with the ->> operator
 	}]);
 });
 
-test.todo('set json/jsonb fields with objects and retrieve with the -> operator', async () => {
+test.skip('set json/jsonb fields with objects and retrieve with the -> operator', async () => {
 	const obj = { string: 'test', number: 123 };
 	const { string: testString, number: testNumber } = obj;
 
@@ -4357,7 +4496,7 @@ test.todo('set json/jsonb fields with objects and retrieve with the -> operator'
 	}]);
 });
 
-test.todo('set json/jsonb fields with strings and retrieve with the -> operator', async () => {
+test.skip('set json/jsonb fields with strings and retrieve with the -> operator', async () => {
 	const obj = { string: 'test', number: 123 };
 	const { string: testString, number: testNumber } = obj;
 
@@ -4710,10 +4849,10 @@ test('policy', () => {
 		const table = pgTable('table_with_policy', {
 			id: serial('id').primaryKey(),
 			name: text('name').notNull(),
-		}, () => ({
+		}, () => [
 			p1,
 			p2,
-		}));
+		]);
 		const config = getTableConfig(table);
 		expect(config.policies).toHaveLength(2);
 		expect(config.policies[0]).toBe(p1);
@@ -4732,8 +4871,13 @@ test('neon: policy', () => {
 		for (const it of Object.values(policy)) {
 			expect(is(it, PgPolicy)).toBe(true);
 			expect(it?.to).toStrictEqual(authenticatedRole);
-			it?.using ? expect(it.using).toStrictEqual(sql`true`) : '';
-			it?.withCheck ? expect(it.withCheck).toStrictEqual(sql`true`) : '';
+
+			if (it?.using) {
+				expect(it.using).toStrictEqual(sql`true`);
+			}
+			if (it?.withCheck) {
+				expect(it.withCheck).toStrictEqual(sql`true`);
+			}
 		}
 	}
 
@@ -4768,13 +4912,13 @@ test('neon: neon_auth', () => {
 
 	expect(name).toBe('users_sync');
 	expect(schema).toBe('neon_auth');
-	expect(columns).toHaveLength(6);
+	expect(columns).toHaveLength(7);
 });
 
 test('Enable RLS function', () => {
-	const usersWithRLS = pgTable('users', {
+	const usersWithRLS = pgTable.withRLS('users', {
 		id: integer(),
-	}).enableRLS();
+	});
 
 	const config1 = getTableConfig(usersWithRLS);
 
@@ -5176,3 +5320,2673 @@ test('sql operator as cte', async () => {
 	expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
 	expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
 });
+
+test('RQB v2 simple find first - no rows', async () => {
+	try {
+		await init(db);
+
+		const result = await db.query.rqbUser.findFirst();
+
+		expect(result === undefined).toStrictEqual(true);
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find first - multiple rows', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find first - with relation', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 1,
+			createdAt: date,
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}],
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find first - placeholders', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare('rqb_v2_find_first_placeholders');
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find many - no rows', async () => {
+	try {
+		await init(db);
+
+		const result = await db.query.rqbUser.findMany();
+
+		expect(result).toStrictEqual([]);
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find many - multiple rows', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}]);
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find many - with relation', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}]);
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 simple find many - placeholders', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare('rqb_v2_find_many_placeholders');
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find first - no rows', async () => {
+	try {
+		await init(db);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst();
+
+			expect(result === undefined).toStrictEqual(true);
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find first - multiple rows', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find first - with relation', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find first - placeholders', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare('rqb_v2_find_first_tx_placeholders');
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find many - no rows', async () => {
+	try {
+		await init(db);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find many - multiple rows', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find many - with relation', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('RQB v2 transaction find many - placeholders', async () => {
+	try {
+		await init(db);
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare('rqb_v2_find_many_placeholders');
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+	} finally {
+		await clear(db);
+	}
+});
+
+test('all types', async () => {
+	await db.execute(sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`);
+	await db.execute(sql`
+				CREATE TABLE "all_types" (
+					"serial" serial NOT NULL,
+					"bigserial53" bigserial NOT NULL,
+					"bigserial64" bigserial,
+					"int" integer,
+					"bigint53" bigint,
+					"bigint64" bigint,
+					"bool" boolean,
+					"char" char,
+					"cidr" "cidr",
+					"date" date,
+					"date_str" date,
+					"double" double precision,
+					"enum" "en",
+					"inet" "inet",
+					"interval" interval,
+					"json" json,
+					"jsonb" jsonb,
+					"line" "line",
+					"line_tuple" "line",
+					"macaddr" "macaddr",
+					"macaddr8" "macaddr8",
+					"numeric" numeric,
+					"numeric_num" numeric,
+					"numeric_big" numeric,
+					"point" "point",
+					"point_tuple" "point",
+					"real" real,
+					"smallint" smallint,
+					"smallserial" "smallserial" NOT NULL,
+					"text" text,
+					"time" time,
+					"timestamp" timestamp,
+					"timestamp_tz" timestamp with time zone,
+					"timestamp_str" timestamp,
+					"timestamp_tz_str" timestamp with time zone,
+					"uuid" uuid,
+					"varchar" varchar,
+					"arrint" integer[],
+					"arrbigint53" bigint[],
+					"arrbigint64" bigint[],
+					"arrbool" boolean[],
+					"arrchar" char[],
+					"arrcidr" "cidr"[],
+					"arrdate" date[],
+					"arrdate_str" date[],
+					"arrdouble" double precision[],
+					"arrenum" "en"[],
+					"arrinet" "inet"[],
+					"arrinterval" interval[],
+					"arrjson" json[],
+					"arrjsonb" jsonb[],
+					"arrline" "line"[],
+					"arrline_tuple" "line"[],
+					"arrmacaddr" "macaddr"[],
+					"arrmacaddr8" "macaddr8"[],
+					"arrnumeric" numeric[],
+					"arrnumeric_num" numeric[],
+					"arrnumeric_big" numeric[],
+					"arrpoint" "point"[],
+					"arrpoint_tuple" "point"[],
+					"arrreal" real[],
+					"arrsmallint" smallint[],
+					"arrtext" text[],
+					"arrtime" time[],
+					"arrtimestamp" timestamp[],
+					"arrtimestamp_tz" timestamp with time zone[],
+					"arrtimestamp_str" timestamp[],
+					"arrtimestamp_tz_str" timestamp with time zone[],
+					"arruuid" uuid[],
+					"arrvarchar" varchar[]
+				);
+			`);
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		smallserial: 15,
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigserial53: 9007199254740991,
+		bigserial64: 5044565289845416380n,
+		bool: true,
+		char: 'c',
+		cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+		inet: '192.168.0.1/24',
+		macaddr: '08:00:2b:01:02:03',
+		macaddr8: '08:00:2b:01:02:03:04:05',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString(),
+		double: 15.35325689124218,
+		enum: 'enVal1',
+		int: 621,
+		interval: '2 months ago',
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		jsonb: {
+			str: 'strvalb',
+			arr: ['strb', 11],
+		},
+		line: {
+			a: 1,
+			b: 2,
+			c: 3,
+		},
+		lineTuple: [1, 2, 3],
+		numeric: '475452353476',
+		numericNum: 9007199254740991,
+		numericBig: 5044565289845416380n,
+		point: {
+			x: 24.5,
+			y: 49.6,
+		},
+		pointTuple: [57.2, 94.3],
+		real: 1.048596,
+		smallint: 10,
+		text: 'TEXT STRING',
+		time: '13:59:28',
+		timestamp: new Date(1741743161623),
+		timestampTz: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString(),
+		timestampTzStr: new Date(1741743161623).toISOString(),
+		uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+		varchar: 'C4-',
+		arrbigint53: [9007199254740991],
+		arrbigint64: [5044565289845416380n],
+		arrbool: [true],
+		arrchar: ['c'],
+		arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+		arrinet: ['192.168.0.1/24'],
+		arrmacaddr: ['08:00:2b:01:02:03'],
+		arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+		arrdate: [new Date(1741743161623)],
+		arrdateStr: [new Date(1741743161623).toISOString()],
+		arrdouble: [15.35325689124218],
+		arrenum: ['enVal1'],
+		arrint: [621],
+		arrinterval: ['2 months ago'],
+		arrjson: [{
+			str: 'strval',
+			arr: ['str', 10],
+		}],
+		arrjsonb: [{
+			str: 'strvalb',
+			arr: ['strb', 11],
+		}],
+		arrline: [{
+			a: 1,
+			b: 2,
+			c: 3,
+		}],
+		arrlineTuple: [[1, 2, 3]],
+		arrnumeric: ['475452353476'],
+		arrnumericNum: [9007199254740991],
+		arrnumericBig: [5044565289845416380n],
+		arrpoint: [{
+			x: 24.5,
+			y: 49.6,
+		}],
+		arrpointTuple: [[57.2, 94.3]],
+		arrreal: [1.048596],
+		arrsmallint: [10],
+		arrtext: ['TEXT STRING'],
+		arrtime: ['13:59:28'],
+		arrtimestamp: [new Date(1741743161623)],
+		arrtimestampTz: [new Date(1741743161623)],
+		arrtimestampStr: [new Date(1741743161623).toISOString()],
+		arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+		arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+		arrvarchar: ['C4-'],
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+
+	type ExpectedType = {
+		serial: number;
+		bigserial53: number;
+		bigserial64: bigint;
+		int: number | null;
+		bigint53: number | null;
+		bigint64: bigint | null;
+		bool: boolean | null;
+		char: string | null;
+		cidr: string | null;
+		date: Date | null;
+		dateStr: string | null;
+		double: number | null;
+		enum: 'enVal1' | 'enVal2' | null;
+		inet: string | null;
+		interval: string | null;
+		json: unknown;
+		jsonb: unknown;
+		line: {
+			a: number;
+			b: number;
+			c: number;
+		} | null;
+		lineTuple: [number, number, number] | null;
+		macaddr: string | null;
+		macaddr8: string | null;
+		numeric: string | null;
+		numericNum: number | null;
+		numericBig: bigint | null;
+		point: {
+			x: number;
+			y: number;
+		} | null;
+		pointTuple: [number, number] | null;
+		real: number | null;
+		smallint: number | null;
+		smallserial: number;
+		text: string | null;
+		time: string | null;
+		timestamp: Date | null;
+		timestampTz: Date | null;
+		timestampStr: string | null;
+		timestampTzStr: string | null;
+		uuid: string | null;
+		varchar: string | null;
+		arrint: number[] | null;
+		arrbigint53: number[] | null;
+		arrbigint64: bigint[] | null;
+		arrbool: boolean[] | null;
+		arrchar: string[] | null;
+		arrcidr: string[] | null;
+		arrdate: Date[] | null;
+		arrdateStr: string[] | null;
+		arrdouble: number[] | null;
+		arrenum: ('enVal1' | 'enVal2')[] | null;
+		arrinet: string[] | null;
+		arrinterval: string[] | null;
+		arrjson: unknown[] | null;
+		arrjsonb: unknown[] | null;
+		arrline: {
+			a: number;
+			b: number;
+			c: number;
+		}[] | null;
+		arrlineTuple: [number, number, number][] | null;
+		arrmacaddr: string[] | null;
+		arrmacaddr8: string[] | null;
+		arrnumeric: string[] | null;
+		arrnumericNum: number[] | null;
+		arrnumericBig: bigint[] | null;
+		arrpoint: { x: number; y: number }[] | null;
+		arrpointTuple: [number, number][] | null;
+		arrreal: number[] | null;
+		arrsmallint: number[] | null;
+		arrtext: string[] | null;
+		arrtime: string[] | null;
+		arrtimestamp: Date[] | null;
+		arrtimestampTz: Date[] | null;
+		arrtimestampStr: string[] | null;
+		arrtimestampTzStr: string[] | null;
+		arruuid: string[] | null;
+		arrvarchar: string[] | null;
+	}[];
+
+	const expectedRes: ExpectedType = [
+		{
+			serial: 1,
+			bigserial53: 9007199254740991,
+			bigserial64: 5044565289845416380n,
+			int: 621,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bool: true,
+			char: 'c',
+			cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			double: 15.35325689124218,
+			enum: 'enVal1',
+			inet: '192.168.0.1/24',
+			interval: '-2 mons',
+			json: { str: 'strval', arr: ['str', 10] },
+			jsonb: { arr: ['strb', 11], str: 'strvalb' },
+			line: { a: 1, b: 2, c: 3 },
+			lineTuple: [1, 2, 3],
+			macaddr: '08:00:2b:01:02:03',
+			macaddr8: '08:00:2b:01:02:03:04:05',
+			numeric: '475452353476',
+			numericNum: 9007199254740991,
+			numericBig: 5044565289845416380n,
+			point: { x: 24.5, y: 49.6 },
+			pointTuple: [57.2, 94.3],
+			real: 1.048596,
+			smallint: 10,
+			smallserial: 15,
+			text: 'TEXT STRING',
+			time: '13:59:28',
+			timestamp: new Date('2025-03-12T01:32:41.623Z'),
+			timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+			timestampStr: '2025-03-12 01:32:41.623',
+			timestampTzStr: '2025-03-12 01:32:41.623+00',
+			uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+			varchar: 'C4-',
+			arrint: [621],
+			arrbigint53: [9007199254740991],
+			arrbigint64: [5044565289845416380n],
+			arrbool: [true],
+			arrchar: ['c'],
+			arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+			arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+			arrdateStr: ['2025-03-12'],
+			arrdouble: [15.35325689124218],
+			arrenum: ['enVal1'],
+			arrinet: ['192.168.0.1/24'],
+			arrinterval: ['-2 mons'],
+			arrjson: [{ str: 'strval', arr: ['str', 10] }],
+			arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+			arrline: [{ a: 1, b: 2, c: 3 }],
+			arrlineTuple: [[1, 2, 3]],
+			arrmacaddr: ['08:00:2b:01:02:03'],
+			arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+			arrnumeric: ['475452353476'],
+			arrnumericNum: [9007199254740991],
+			arrnumericBig: [5044565289845416380n],
+			arrpoint: [{ x: 24.5, y: 49.6 }],
+			arrpointTuple: [[57.2, 94.3]],
+			arrreal: [1.048596],
+			arrsmallint: [10],
+			arrtext: ['TEXT STRING'],
+			arrtime: ['13:59:28'],
+			arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampStr: ['2025-03-12 01:32:41.623'],
+			arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+			arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+			arrvarchar: ['C4-'],
+		},
+	];
+
+	Expect<Equal<typeof rawRes, ExpectedType>>;
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5287
+test('raw jsons', async () => {
+	const allTypesTable = pgTable('all_types', {
+		json: json('json'),
+		jsonb: jsonb('jsonb'),
+		arrjson: json('arrjson').array(),
+		arrjsonb: jsonb('arrjsonb').array(),
+	});
+
+	await db.execute(sql`
+				CREATE TABLE "all_types" (
+					"json" json,
+					"jsonb" jsonb,
+					"arrjson" json[],
+					"arrjsonb" jsonb[]
+				);
+			`);
+
+	await db.insert(allTypesTable).values({
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		jsonb: {
+			str: 'strvalb',
+			arr: ['strb', 11],
+		},
+		arrjson: [{
+			str: 'strval',
+			arr: ['str', 10],
+		}],
+		arrjsonb: [{
+			str: 'strvalb',
+			arr: ['strb', 11],
+		}],
+	});
+
+	const queryRes1 = await db.execute(sql`select * from ${allTypesTable};`);
+	const rawData1 = [queryRes1[0]];
+
+	const expectedRes1 = [
+		{
+			json: { str: 'strval', arr: ['str', 10] },
+			jsonb: { arr: ['strb', 11], str: 'strvalb' },
+
+			arrjson: [{ str: 'strval', arr: ['str', 10] }],
+			arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+		},
+	];
+
+	expect(rawData1).toStrictEqual(expectedRes1);
+
+	await db.update(allTypesTable).set({
+		json: {
+			str: 'strval',
+			arr: ['str', 100],
+		},
+		jsonb: {
+			str: 'strvalb',
+			arr: ['strb', 110],
+		},
+		arrjson: [{
+			str: 'strval',
+			arr: ['str', 100],
+		}],
+		arrjsonb: [{
+			str: 'strvalb',
+			arr: ['strb', 110],
+		}],
+	});
+
+	const queryRes2 = await db.execute(sql`select * from ${allTypesTable};`);
+	const rawData2 = [queryRes2[0]];
+
+	const expectedRes2 = [
+		{
+			json: { str: 'strval', arr: ['str', 100] },
+			jsonb: { arr: ['strb', 110], str: 'strvalb' },
+
+			arrjson: [{ str: 'strval', arr: ['str', 100] }],
+			arrjsonb: [{ arr: ['strb', 110], str: 'strvalb' }],
+		},
+	];
+
+	expect(rawData2).toStrictEqual(expectedRes2);
+});
+
+test('all types ~codecs~', async () => {
+	const en = pgEnum('en_48', ['enVal1', 'enVal2']);
+	const allTypesTable = pgTable('all_types', {
+		serial: serial('serial').notNull(),
+		bigserial: bigserial('bigserial', {
+			mode: 'bigint',
+		}).notNull(),
+		bigserialnum: bigserial('bigserialnum', {
+			mode: 'number',
+		}).notNull(),
+		int: integer('int').notNull(),
+		bigint: bigint('bigint', {
+			mode: 'bigint',
+		}).notNull(),
+		bigintnum: bigint('bigintnum', {
+			mode: 'number',
+		}).notNull(),
+		bigintstr: bigint('bigintstr', {
+			mode: 'string',
+		}).notNull(),
+		bool: boolean('bool').notNull(),
+		bytea: bytea('bytea').notNull(),
+		char: char('char').notNull(),
+		cidr: cidr('cidr').notNull(),
+		date: date('date', {
+			mode: 'date',
+		}).notNull(),
+		datestr: date('datestr', {
+			mode: 'string',
+		}).notNull(),
+		double: doublePrecision('double').notNull(),
+		enum: en('enum').notNull(),
+		inet: inet('inet').notNull(),
+		interval: interval('interval').notNull(),
+		json: json('json').notNull(),
+		jsonb: jsonb('jsonb').notNull(),
+		json1: json('json1').notNull(),
+		jsonb1: jsonb('jsonb1').notNull(),
+		// Scenarios aren't supported by driver
+		// json2: json('json2'),
+		// jsonb2: jsonb('jsonb2'),
+		json3: json('json3').notNull(),
+		jsonb3: jsonb('jsonb3').notNull(),
+		line: line('line', {
+			mode: 'abc',
+		}).notNull(),
+		linetuple: line('linetuple', {
+			mode: 'tuple',
+		}).notNull(),
+		macaddr: macaddr('macaddr').notNull(),
+		macaddr8: macaddr8('macaddr8').notNull(),
+		numeric: numeric('numeric').notNull(),
+		numericnum: numeric('numericnum', {
+			mode: 'number',
+		}).notNull(),
+		numericbig: numeric('numericbig', {
+			mode: 'bigint',
+		}).notNull(),
+		point: point('point', {
+			mode: 'xy',
+		}).notNull(),
+		pointtuple: point('pointtuple', {
+			mode: 'tuple',
+		}).notNull(),
+		real: real('real').notNull(),
+		smallint: smallint('smallint').notNull(),
+		smallserial: smallserial('smallserial').notNull(),
+		text: text('text').notNull(),
+		time: time('time').notNull(),
+		timestamp: timestamp('timestamp', {
+			mode: 'date',
+		}).notNull(),
+		timestampTz: timestamp('timestampTz', {
+			mode: 'date',
+			withTimezone: true,
+		}).notNull(),
+		timestampstr: timestamp('timestampstr', {
+			mode: 'string',
+		}).notNull(),
+		timestampTzstr: timestamp('timestampTzstr', {
+			mode: 'string',
+			withTimezone: true,
+		}).notNull(),
+		uuid: uuid('uuid').notNull(),
+		varchar: varchar('varchar').notNull(),
+		arrint: integer('arrint').array().notNull(),
+		arrbigint: bigint('arrbigint', {
+			mode: 'bigint',
+		}).array().notNull(),
+		arrbigintnum: bigint('arrbigintnum', {
+			mode: 'number',
+		}).array().notNull(),
+		arrbigintstr: bigint('arrbigintstr', {
+			mode: 'string',
+		}).array().notNull(),
+		arrbool: boolean('arrbool').array().notNull(),
+		arrbytea: bytea('arrbytea').array().notNull(),
+		mtxbytea: bytea('mtxbytea').array('[][]').notNull(),
+		arrchar: char('arrchar').array().notNull(),
+		arrcidr: cidr('arrcidr').array().notNull(),
+		arrdate: date('arrdate', {
+			mode: 'date',
+		}).array().notNull(),
+		arrdatestr: date('arrdatestr', {
+			mode: 'string',
+		}).array().notNull(),
+		arrdouble: doublePrecision('arrdouble').array().notNull(),
+		arrenum: en('arrenum').array().notNull(),
+		arrinet: inet('arrinet').array().notNull(),
+		arrinterval: interval('arrinterval').array().notNull(),
+		arrjson: json('arrjson').array().notNull(),
+		arrjsonb: jsonb('arrjsonb').array().notNull(),
+		arrjson1: json('arrjson1').array().notNull(),
+		arrjsonb1: jsonb('arrjsonb1').array().notNull(),
+		arrjson2: json('arrjson2').array().notNull(),
+		arrjsonb2: jsonb('arrjsonb2').array().notNull(),
+		arrjson3: json('arrjson3').array().notNull(),
+		arrjsonb3: jsonb('arrjsonb3').array().notNull(),
+		arrline: line('arrline', {
+			mode: 'abc',
+		}).array().notNull(),
+		arrlinetuple: line('arrlinetuple', {
+			mode: 'tuple',
+		}).array().notNull(),
+		arrmacaddr: macaddr('arrmacaddr').array().notNull(),
+		arrmacaddr8: macaddr8('arrmacaddr8').array().notNull(),
+		arrnumeric: numeric('arrnumeric').array().notNull(),
+		arrnumericnum: numeric('arrnumericnum', { mode: 'number' }).array().notNull(),
+		arrnumericbig: numeric('arrnumericbig', { mode: 'bigint' }).array().notNull(),
+		arrpoint: point('arrpoint', {
+			mode: 'xy',
+		}).array().notNull(),
+		arrpointtuple: point('arrpointtuple', {
+			mode: 'tuple',
+		}).array().notNull(),
+		arrreal: real('arrreal').array().notNull(),
+		// mtxreal: real('mtxreal').array('[][]'), // MULTIDIMENSIONAL ARRAYS NOT SUPPORTED YET BY DRIVER
+		arrsmallint: smallint('arrsmallint').array().notNull(),
+		arrtext: text('arrtext').array().notNull(),
+		arrtime: time('arrtime').array().notNull(),
+		arrtimestamp: timestamp('arrtimestamp', {
+			mode: 'date',
+		}).array().notNull(),
+		arrtimestampTz: timestamp('arrtimestampTz', {
+			mode: 'date',
+			withTimezone: true,
+		}).array().notNull(),
+		arrtimestampstr: timestamp('arrtimestampstr', {
+			mode: 'string',
+		}).array().notNull(),
+		arrtimestampTzstr: timestamp('arrtimestampTzstr', {
+			mode: 'string',
+			withTimezone: true,
+		}).array().notNull(),
+		arruuid: uuid('arruuid').array().notNull(),
+		arrvarchar: varchar('arrvarchar').array().notNull(),
+	});
+
+	const db = drizzle(process.env['PG_CONNECTION_STRING']!, {
+		relations: defineRelations({ allTypesTable }, (r) => ({
+			allTypesTable: {
+				self: r.many.allTypesTable({
+					from: r.allTypesTable.serial,
+					to: r.allTypesTable.serial,
+				}),
+			},
+		})),
+	});
+
+	await db.execute(sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`);
+	await db.execute(sql`
+				CREATE TABLE "all_types" (
+					"serial" serial NOT NULL,
+					"bigserial" bigserial,
+					"bigserialnum" bigserial,
+					"int" integer,
+					"bigint" bigint,
+					"bigintnum" bigint,
+					"bigintstr" bigint,
+					"bool" boolean,
+					"bytea" bytea,
+					"char" char,
+					"cidr" "cidr",
+					"date" date,
+					"datestr" date,
+					"double" double precision,
+					"enum" "en",
+					"inet" "inet",
+					"interval" interval,
+					"json" json,
+					"jsonb" jsonb,
+					"json1" json,
+					"jsonb1" jsonb,
+					"json2" json,
+					"jsonb2" jsonb,
+					"json3" json,
+					"jsonb3" jsonb,
+					"line" "line",
+					"linetuple" "line",
+					"macaddr" "macaddr",
+					"macaddr8" "macaddr8",
+					"numeric" numeric,
+					"numericnum" numeric,
+					"numericbig" numeric,
+					"point" "point",
+					"pointtuple" "point",
+					"real" real,
+					"smallint" smallint,
+					"smallserial" "smallserial" NOT NULL,
+					"text" text,
+					"time" time,
+					"timestamp" timestamp,
+					"timestampTz" timestamp with time zone,
+					"timestampstr" timestamp,
+					"timestampTzstr" timestamp with time zone,
+					"uuid" uuid,
+					"varchar" varchar,
+					"arrint" integer[],
+					"mtxint" integer[][],
+					"arrbigint" bigint[],
+					"arrbigintnum" bigint[],
+					"arrbigintstr" bigint[],
+					"arrbool" boolean[],
+					"arrbytea" bytea[],
+					"mtxbytea" bytea[][],
+					"arrchar" char[],
+					"arrcidr" "cidr"[],
+					"arrdate" date[],
+					"arrdatestr" date[],
+					"arrdouble" double precision[],
+					"arrenum" "en"[],
+					"arrinet" "inet"[],
+					"arrinterval" interval[],
+					"arrjson" json[],
+					"arrjsonb" jsonb[],
+					"arrjson1" json[],
+					"arrjsonb1" jsonb[],
+					"arrjson2" json[],
+					"arrjsonb2" jsonb[],
+					"arrjson3" json[],
+					"arrjsonb3" jsonb[],
+					"arrline" "line"[],
+					"arrlinetuple" "line"[],
+					"arrmacaddr" "macaddr"[],
+					"arrmacaddr8" "macaddr8"[],
+					"arrnumeric" numeric[],
+					"arrnumericnum" numeric[],
+					"arrnumericbig" numeric[],
+					"arrpoint" "point"[],
+					"arrpointtuple" "point"[],
+					"mtxreal" real[][],
+					"arrreal" real[],
+					"arrsmallint" smallint[],
+					"arrtext" text[],
+					"arrtime" time[],
+					"arrtimestamp" timestamp[],
+					"arrtimestampTz" timestamp with time zone[],
+					"arrtimestampstr" timestamp[],
+					"arrtimestampTzstr" timestamp with time zone[],
+					"arruuid" uuid[],
+					"arrvarchar" varchar[]
+				);
+			`);
+
+	type ExpectedType = {
+		serial: number;
+		bigserial: bigint;
+		bigserialnum: number;
+		int: number;
+		bigint: bigint;
+		bigintnum: number;
+		bigintstr: string;
+		bool: boolean;
+		bytea: Buffer;
+		char: string;
+		cidr: string;
+		date: Date;
+		datestr: string;
+		double: number;
+		enum: 'enVal1' | 'enVal2';
+		inet: string;
+		interval: string;
+		json: unknown;
+		jsonb: unknown;
+		json1: unknown;
+		jsonb1: unknown;
+		// json2: unknown;
+		// jsonb2: unknown;
+		json3: unknown;
+		jsonb3: unknown;
+		line: { a: number; b: number; c: number };
+		linetuple: [number, number, number];
+		macaddr: string;
+		macaddr8: string;
+		numeric: string;
+		numericnum: number;
+		numericbig: bigint;
+		point: { x: number; y: number };
+		pointtuple: [number, number];
+		real: number;
+		smallint: number;
+		smallserial: number;
+		text: string;
+		time: string;
+		timestamp: Date;
+		timestampTz: Date;
+		timestampstr: string;
+		timestampTzstr: string;
+		uuid: string;
+		varchar: string;
+		arrint: number[];
+		arrbigint: bigint[];
+		arrbigintnum: number[];
+		arrbigintstr: string[];
+		arrbool: boolean[];
+		arrbytea: (Buffer)[];
+		mtxbytea: (Buffer)[][];
+		arrchar: string[];
+		arrcidr: string[];
+		arrdate: Date[];
+		arrdatestr: string[];
+		arrdouble: number[];
+		arrenum: ('enVal1' | 'enVal2')[];
+		arrinet: string[];
+		arrinterval: string[];
+		arrjson: unknown[];
+		arrjsonb: unknown[];
+		arrjson1: unknown[];
+		arrjsonb1: unknown[];
+		arrjson2: unknown[];
+		arrjsonb2: unknown[];
+		arrjson3: unknown[];
+		arrjsonb3: unknown[];
+		arrline: { a: number; b: number; c: number }[];
+		arrlinetuple: [number, number, number][];
+		arrmacaddr: string[];
+		arrmacaddr8: string[];
+		arrnumeric: string[];
+		arrnumericnum: number[];
+		arrnumericbig: bigint[];
+		arrpoint: { x: number; y: number }[];
+		arrpointtuple: [number, number][];
+		arrreal: number[];
+		arrsmallint: number[];
+		arrtext: string[];
+		arrtime: string[];
+		arrtimestamp: Date[];
+		arrtimestampTz: Date[];
+		arrtimestampstr: string[];
+		arrtimestampTzstr: string[];
+		arruuid: string[];
+		arrvarchar: string[];
+	};
+
+	const testData: ExpectedType = {
+		serial: 1,
+		bigserial: 5044565289845416380n,
+		bigserialnum: 9007199254740991,
+		int: 621,
+		bigint: 5044565289845416380n,
+		bigintnum: 9007199254740991,
+		bigintstr: '5044565289845416380',
+		bool: true,
+		bytea: Buffer.from('BYTES'),
+		char: 'c',
+		cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+		date: new Date('2025-03-12'),
+		datestr: '2025-03-12',
+		double: 15.35325689124218,
+		enum: 'enVal1',
+		inet: '192.168.0.1/24',
+		interval: '-2 mons',
+		json: { str: 'strval', arr: ['str', 10] },
+		jsonb: { arr: ['strb', 11], str: 'strvalb' },
+		json1: [{ key: 'value', num: 7 }, 'v', '11', 5],
+		jsonb1: [{ key: 'value', num: 8 }, 'x', '10', 3],
+		json3: '5',
+		jsonb3: '7',
+		line: { a: 1, b: 2, c: 3 },
+		linetuple: [1, 2, 3],
+		macaddr: '08:00:2b:01:02:03',
+		macaddr8: '08:00:2b:01:02:03:04:05',
+		numeric: '5044565289845416380',
+		numericnum: 9007199254740991,
+		numericbig: 5044565289845416380n,
+		point: { x: 24.5, y: 49.6 },
+		pointtuple: [24.5, 49.6],
+		real: 1.048596,
+		smallint: 10,
+		smallserial: 15,
+		text: 'TEXT STRING',
+		time: '13:59:28',
+		timestamp: new Date('2025-03-12 01:32:41.623'),
+		timestampTz: new Date('2025-03-12 01:32:41.623+00'),
+		timestampstr: '2025-03-12 01:32:41.623',
+		timestampTzstr: '2025-03-12 01:32:41.623+00',
+		uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+		varchar: 'C4-',
+		arrint: [621],
+		arrbigint: [5044565289845416380n],
+		arrbigintnum: [9007199254740991],
+		arrbigintstr: ['5044565289845416380'],
+		arrbool: [true],
+		arrbytea: [Buffer.from('BYTES')],
+		mtxbytea: [[Buffer.from('BYTES'), Buffer.from('BYTES2')], [
+			Buffer.from('OTHERBYTES'),
+			Buffer.from('OTHERBYTES2'),
+		]],
+		arrchar: ['c'],
+		arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+		arrdate: [new Date('2025-03-12')],
+		arrdatestr: ['2025-03-12'],
+		arrdouble: [15.35325689124218],
+		arrenum: ['enVal1'],
+		arrinet: ['192.168.0.1/24'],
+		arrinterval: ['-2 mons'],
+		arrjson: [{ str: 'strval', arr: ['str', 10] }],
+		arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+		arrjson1: [[{ key: 'value', num: 7 }, 'v', '11', 5]],
+		arrjsonb1: [[{ key: 'value', num: 8 }, 'x', '10', 3]],
+		arrjson2: [5],
+		arrjsonb2: [7],
+		arrjson3: ['5'],
+		arrjsonb3: ['7'],
+		arrline: [{ a: 1, b: 2, c: 3 }],
+		arrlinetuple: [[1, 2, 3]],
+		arrmacaddr: ['08:00:2b:01:02:03'],
+		arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+		arrnumeric: ['5044565289845416380'],
+		arrnumericnum: [9007199254740991],
+		arrnumericbig: [5044565289845416380n],
+		arrpoint: [{ x: 24.5, y: 49.6 }],
+		arrpointtuple: [[24.5, 49.6]],
+		arrreal: [1.048596],
+		arrsmallint: [10],
+		arrtext: ['TEXT STRING'],
+		arrtime: ['13:59:28'],
+		arrtimestamp: [new Date('2025-03-12 01:32:41.623')],
+		arrtimestampTz: [new Date('2025-03-12 01:32:41.623+00')],
+		arrtimestampstr: ['2025-03-12 01:32:41.623'],
+		arrtimestampTzstr: ['2025-03-12 01:32:41.623+00'],
+		arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+		arrvarchar: ['C4-'],
+	};
+
+	await db.insert(allTypesTable).values(testData);
+
+	const queryRes = await db.execute<ExpectedType>(db.select().from(allTypesTable)).then((e) =>
+		normalizeDataWithDbCodecs({
+			db,
+			columns: getColumns(allTypesTable),
+			data: e,
+			mode: 'query',
+		})[0]
+	);
+
+	const { relationRes, rootRes } = await db.execute(db.query.allTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	})).then((e) => {
+		const { self: relationRaw, ...rootRaw } = e[0]!;
+
+		return {
+			relationRes: normalizeDataWithDbCodecs({
+				db,
+				columns: getColumns(allTypesTable),
+				data: relationRaw as any,
+				mode: 'json',
+			})[0]!,
+			rootRes: normalizeDataWithDbCodecs({
+				db,
+				columns: getColumns(allTypesTable),
+				data: [rootRaw],
+				mode: 'query',
+			})[0]!,
+		};
+	});
+
+	expect(queryRes).toStrictEqual(testData);
+	expect(relationRes).toStrictEqual(testData);
+	expect(rootRes).toStrictEqual(testData);
+
+	// ---- numbers ----
+	expect(
+		await unionAll(
+			db.select({
+				'int ∪ int': allTypesTable.int.as('int ∪ int'),
+				'int ∪ smallint': allTypesTable.int.as('int ∪ smallint'),
+				'int ∪ double': allTypesTable.int.as('int ∪ double'),
+				'int ∪ real': allTypesTable.int.as('int ∪ real'),
+				'int ∪ smallserial': allTypesTable.int.as('int ∪ smallserial'),
+				'int ∪ serial': allTypesTable.int.as('int ∪ serial'),
+				'int ∪ bigserialnum': allTypesTable.int.as('int ∪ bigserialnum'),
+				'int ∪ bigintnum': allTypesTable.int.as('int ∪ bigintnum'),
+				'int ∪ numericnum': allTypesTable.int.as('int ∪ numericnum'),
+				'smallint ∪ int': allTypesTable.smallint.as('smallint ∪ int'),
+				'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+				'smallint ∪ double': allTypesTable.smallint.as('smallint ∪ double'),
+				'smallint ∪ real': allTypesTable.smallint.as('smallint ∪ real'),
+				'smallint ∪ smallserial': allTypesTable.smallint.as('smallint ∪ smallserial'),
+				'smallint ∪ serial': allTypesTable.smallint.as('smallint ∪ serial'),
+				'smallint ∪ bigserialnum': allTypesTable.smallint.as('smallint ∪ bigserialnum'),
+				'smallint ∪ bigintnum': allTypesTable.smallint.as('smallint ∪ bigintnum'),
+				'smallint ∪ numericnum': allTypesTable.smallint.as('smallint ∪ numericnum'),
+				'double ∪ int': allTypesTable.double.as('double ∪ int'),
+				'double ∪ smallint': allTypesTable.double.as('double ∪ smallint'),
+				'double ∪ double': allTypesTable.double.as('double ∪ double'),
+				'double ∪ real': allTypesTable.double.as('double ∪ real'),
+				'double ∪ smallserial': allTypesTable.double.as('double ∪ smallserial'),
+				'double ∪ serial': allTypesTable.double.as('double ∪ serial'),
+				'double ∪ bigserialnum': allTypesTable.double.as('double ∪ bigserialnum'),
+				'double ∪ bigintnum': allTypesTable.double.as('double ∪ bigintnum'),
+				'double ∪ numericnum': allTypesTable.double.as('double ∪ numericnum'),
+				'real ∪ int': allTypesTable.real.as('real ∪ int'),
+				'real ∪ smallint': allTypesTable.real.as('real ∪ smallint'),
+				'real ∪ double': allTypesTable.real.as('real ∪ double'),
+				'real ∪ real': allTypesTable.real.as('real ∪ real'),
+				'real ∪ smallserial': allTypesTable.real.as('real ∪ smallserial'),
+				'real ∪ serial': allTypesTable.real.as('real ∪ serial'),
+				'smallserial ∪ int': allTypesTable.smallserial.as('smallserial ∪ int'),
+				'smallserial ∪ smallint': allTypesTable.smallserial.as('smallserial ∪ smallint'),
+				'smallserial ∪ double': allTypesTable.smallserial.as('smallserial ∪ double'),
+				'smallserial ∪ real': allTypesTable.smallserial.as('smallserial ∪ real'),
+				'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+				'smallserial ∪ serial': allTypesTable.smallserial.as('smallserial ∪ serial'),
+				'smallserial ∪ bigserialnum': allTypesTable.smallserial.as('smallserial ∪ bigserialnum'),
+				'smallserial ∪ bigintnum': allTypesTable.smallserial.as('smallserial ∪ bigintnum'),
+				'smallserial ∪ numericnum': allTypesTable.smallserial.as('smallserial ∪ numericnum'),
+				'serial ∪ int': allTypesTable.serial.as('serial ∪ int'),
+				'serial ∪ smallint': allTypesTable.serial.as('serial ∪ smallint'),
+				'serial ∪ double': allTypesTable.serial.as('serial ∪ double'),
+				'serial ∪ real': allTypesTable.serial.as('serial ∪ real'),
+				'serial ∪ smallserial': allTypesTable.serial.as('serial ∪ smallserial'),
+				'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+				'serial ∪ bigserialnum': allTypesTable.serial.as('serial ∪ bigserialnum'),
+				'serial ∪ bigintnum': allTypesTable.serial.as('serial ∪ bigintnum'),
+				'serial ∪ numericnum': allTypesTable.serial.as('serial ∪ numericnum'),
+				'bigserialnum ∪ int': allTypesTable.bigserialnum.as('bigserialnum ∪ int'),
+				'bigserialnum ∪ smallint': allTypesTable.bigserialnum.as('bigserialnum ∪ smallint'),
+				'bigserialnum ∪ double': allTypesTable.bigserialnum.as('bigserialnum ∪ double'),
+				'bigserialnum ∪ smallserial': allTypesTable.bigserialnum.as('bigserialnum ∪ smallserial'),
+				'bigserialnum ∪ serial': allTypesTable.bigserialnum.as('bigserialnum ∪ serial'),
+				'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+				'bigserialnum ∪ bigintnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigintnum'),
+				'bigserialnum ∪ numericnum': allTypesTable.bigserialnum.as('bigserialnum ∪ numericnum'),
+				'bigintnum ∪ int': allTypesTable.bigintnum.as('bigintnum ∪ int'),
+				'bigintnum ∪ smallint': allTypesTable.bigintnum.as('bigintnum ∪ smallint'),
+				'bigintnum ∪ double': allTypesTable.bigintnum.as('bigintnum ∪ double'),
+				'bigintnum ∪ smallserial': allTypesTable.bigintnum.as('bigintnum ∪ smallserial'),
+				'bigintnum ∪ serial': allTypesTable.bigintnum.as('bigintnum ∪ serial'),
+				'bigintnum ∪ bigserialnum': allTypesTable.bigintnum.as('bigintnum ∪ bigserialnum'),
+				'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+				'bigintnum ∪ numericnum': allTypesTable.bigintnum.as('bigintnum ∪ numericnum'),
+				'numericnum ∪ int': allTypesTable.numericnum.as('numericnum ∪ int'),
+				'numericnum ∪ smallint': allTypesTable.numericnum.as('numericnum ∪ smallint'),
+				'numericnum ∪ double': allTypesTable.numericnum.as('numericnum ∪ double'),
+				'numericnum ∪ smallserial': allTypesTable.numericnum.as('numericnum ∪ smallserial'),
+				'numericnum ∪ serial': allTypesTable.numericnum.as('numericnum ∪ serial'),
+				'numericnum ∪ bigserialnum': allTypesTable.numericnum.as('numericnum ∪ bigserialnum'),
+				'numericnum ∪ bigintnum': allTypesTable.numericnum.as('numericnum ∪ bigintnum'),
+				'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+			}).from(allTypesTable),
+			db.select({
+				'int ∪ int': allTypesTable.int.as('int ∪ int'),
+				'int ∪ smallint': allTypesTable.smallint.as('int ∪ smallint'),
+				'int ∪ double': allTypesTable.double.as('int ∪ double'),
+				'int ∪ real': allTypesTable.real.as('int ∪ real'),
+				'int ∪ smallserial': allTypesTable.smallserial.as('int ∪ smallserial'),
+				'int ∪ serial': allTypesTable.serial.as('int ∪ serial'),
+				'int ∪ bigserialnum': allTypesTable.bigserialnum.as('int ∪ bigserialnum'),
+				'int ∪ bigintnum': allTypesTable.bigintnum.as('int ∪ bigintnum'),
+				'int ∪ numericnum': allTypesTable.numericnum.as('int ∪ numericnum'),
+				'smallint ∪ int': allTypesTable.int.as('smallint ∪ int'),
+				'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+				'smallint ∪ double': allTypesTable.double.as('smallint ∪ double'),
+				'smallint ∪ real': allTypesTable.real.as('smallint ∪ real'),
+				'smallint ∪ smallserial': allTypesTable.smallserial.as('smallint ∪ smallserial'),
+				'smallint ∪ serial': allTypesTable.serial.as('smallint ∪ serial'),
+				'smallint ∪ bigserialnum': allTypesTable.bigserialnum.as('smallint ∪ bigserialnum'),
+				'smallint ∪ bigintnum': allTypesTable.bigintnum.as('smallint ∪ bigintnum'),
+				'smallint ∪ numericnum': allTypesTable.numericnum.as('smallint ∪ numericnum'),
+				'double ∪ int': allTypesTable.int.as('double ∪ int'),
+				'double ∪ smallint': allTypesTable.smallint.as('double ∪ smallint'),
+				'double ∪ double': allTypesTable.double.as('double ∪ double'),
+				'double ∪ real': allTypesTable.real.as('double ∪ real'),
+				'double ∪ smallserial': allTypesTable.smallserial.as('double ∪ smallserial'),
+				'double ∪ serial': allTypesTable.serial.as('double ∪ serial'),
+				'double ∪ bigserialnum': allTypesTable.bigserialnum.as('double ∪ bigserialnum'),
+				'double ∪ bigintnum': allTypesTable.bigintnum.as('double ∪ bigintnum'),
+				'double ∪ numericnum': allTypesTable.numericnum.as('double ∪ numericnum'),
+				'real ∪ int': allTypesTable.int.as('real ∪ int'),
+				'real ∪ smallint': allTypesTable.smallint.as('real ∪ smallint'),
+				'real ∪ double': allTypesTable.double.as('real ∪ double'),
+				'real ∪ real': allTypesTable.real.as('real ∪ real'),
+				'real ∪ smallserial': allTypesTable.smallserial.as('real ∪ smallserial'),
+				'real ∪ serial': allTypesTable.serial.as('real ∪ serial'),
+				'smallserial ∪ int': allTypesTable.int.as('smallserial ∪ int'),
+				'smallserial ∪ smallint': allTypesTable.smallint.as('smallserial ∪ smallint'),
+				'smallserial ∪ double': allTypesTable.double.as('smallserial ∪ double'),
+				'smallserial ∪ real': allTypesTable.real.as('smallserial ∪ real'),
+				'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+				'smallserial ∪ serial': allTypesTable.serial.as('smallserial ∪ serial'),
+				'smallserial ∪ bigserialnum': allTypesTable.bigserialnum.as('smallserial ∪ bigserialnum'),
+				'smallserial ∪ bigintnum': allTypesTable.bigintnum.as('smallserial ∪ bigintnum'),
+				'smallserial ∪ numericnum': allTypesTable.numericnum.as('smallserial ∪ numericnum'),
+				'serial ∪ int': allTypesTable.int.as('serial ∪ int'),
+				'serial ∪ smallint': allTypesTable.smallint.as('serial ∪ smallint'),
+				'serial ∪ double': allTypesTable.double.as('serial ∪ double'),
+				'serial ∪ real': allTypesTable.real.as('serial ∪ real'),
+				'serial ∪ smallserial': allTypesTable.smallserial.as('serial ∪ smallserial'),
+				'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+				'serial ∪ bigserialnum': allTypesTable.bigserialnum.as('serial ∪ bigserialnum'),
+				'serial ∪ bigintnum': allTypesTable.bigintnum.as('serial ∪ bigintnum'),
+				'serial ∪ numericnum': allTypesTable.numericnum.as('serial ∪ numericnum'),
+				'bigserialnum ∪ int': allTypesTable.int.as('bigserialnum ∪ int'),
+				'bigserialnum ∪ smallint': allTypesTable.smallint.as('bigserialnum ∪ smallint'),
+				'bigserialnum ∪ double': allTypesTable.double.as('bigserialnum ∪ double'),
+				'bigserialnum ∪ smallserial': allTypesTable.smallserial.as('bigserialnum ∪ smallserial'),
+				'bigserialnum ∪ serial': allTypesTable.serial.as('bigserialnum ∪ serial'),
+				'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+				'bigserialnum ∪ bigintnum': allTypesTable.bigintnum.as('bigserialnum ∪ bigintnum'),
+				'bigserialnum ∪ numericnum': allTypesTable.numericnum.as('bigserialnum ∪ numericnum'),
+				'bigintnum ∪ int': allTypesTable.int.as('bigintnum ∪ int'),
+				'bigintnum ∪ smallint': allTypesTable.smallint.as('bigintnum ∪ smallint'),
+				'bigintnum ∪ double': allTypesTable.double.as('bigintnum ∪ double'),
+				'bigintnum ∪ smallserial': allTypesTable.smallserial.as('bigintnum ∪ smallserial'),
+				'bigintnum ∪ serial': allTypesTable.serial.as('bigintnum ∪ serial'),
+				'bigintnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigintnum ∪ bigserialnum'),
+				'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+				'bigintnum ∪ numericnum': allTypesTable.numericnum.as('bigintnum ∪ numericnum'),
+				'numericnum ∪ int': allTypesTable.int.as('numericnum ∪ int'),
+				'numericnum ∪ smallint': allTypesTable.smallint.as('numericnum ∪ smallint'),
+				'numericnum ∪ double': allTypesTable.double.as('numericnum ∪ double'),
+				'numericnum ∪ smallserial': allTypesTable.smallserial.as('numericnum ∪ smallserial'),
+				'numericnum ∪ serial': allTypesTable.serial.as('numericnum ∪ serial'),
+				'numericnum ∪ bigserialnum': allTypesTable.bigserialnum.as('numericnum ∪ bigserialnum'),
+				'numericnum ∪ bigintnum': allTypesTable.bigintnum.as('numericnum ∪ bigintnum'),
+				'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'int ∪ int': 621,
+			'int ∪ smallint': 621,
+			'int ∪ double': 621,
+			'int ∪ real': 621,
+			'int ∪ smallserial': 621,
+			'int ∪ serial': 621,
+			'int ∪ bigserialnum': 621,
+			'int ∪ bigintnum': 621,
+			'int ∪ numericnum': 621,
+			'smallint ∪ int': 10,
+			'smallint ∪ smallint': 10,
+			'smallint ∪ double': 10,
+			'smallint ∪ real': 10,
+			'smallint ∪ smallserial': 10,
+			'smallint ∪ serial': 10,
+			'smallint ∪ bigserialnum': 10,
+			'smallint ∪ bigintnum': 10,
+			'smallint ∪ numericnum': 10,
+			'double ∪ int': 15.35325689124218,
+			'double ∪ smallint': 15.35325689124218,
+			'double ∪ double': 15.35325689124218,
+			'double ∪ real': 15.35325689124218,
+			'double ∪ smallserial': 15.35325689124218,
+			'double ∪ serial': 15.35325689124218,
+			'double ∪ bigserialnum': 15.35325689124218,
+			'double ∪ bigintnum': 15.35325689124218,
+			'double ∪ numericnum': 15.35325689124218,
+			'real ∪ int': 1.048596,
+			'real ∪ smallint': 1.048596,
+			'real ∪ double': 1.0485960245132446,
+			'real ∪ real': 1.048596,
+			'real ∪ smallserial': 1.048596,
+			'real ∪ serial': 1.048596,
+			'smallserial ∪ int': 15,
+			'smallserial ∪ smallint': 15,
+			'smallserial ∪ double': 15,
+			'smallserial ∪ real': 15,
+			'smallserial ∪ smallserial': 15,
+			'smallserial ∪ serial': 15,
+			'smallserial ∪ bigserialnum': 15,
+			'smallserial ∪ bigintnum': 15,
+			'smallserial ∪ numericnum': 15,
+			'serial ∪ int': 1,
+			'serial ∪ smallint': 1,
+			'serial ∪ double': 1,
+			'serial ∪ real': 1,
+			'serial ∪ smallserial': 1,
+			'serial ∪ serial': 1,
+			'serial ∪ bigserialnum': 1,
+			'serial ∪ bigintnum': 1,
+			'serial ∪ numericnum': 1,
+			'bigserialnum ∪ int': 9007199254740991,
+			'bigserialnum ∪ smallint': 9007199254740991,
+			'bigserialnum ∪ double': 9007199254740991,
+			'bigserialnum ∪ smallserial': 9007199254740991,
+			'bigserialnum ∪ serial': 9007199254740991,
+			'bigserialnum ∪ bigserialnum': 9007199254740991,
+			'bigserialnum ∪ bigintnum': 9007199254740991,
+			'bigserialnum ∪ numericnum': 9007199254740991,
+			'bigintnum ∪ int': 9007199254740991,
+			'bigintnum ∪ smallint': 9007199254740991,
+			'bigintnum ∪ double': 9007199254740991,
+			'bigintnum ∪ smallserial': 9007199254740991,
+			'bigintnum ∪ serial': 9007199254740991,
+			'bigintnum ∪ bigserialnum': 9007199254740991,
+			'bigintnum ∪ bigintnum': 9007199254740991,
+			'bigintnum ∪ numericnum': 9007199254740991,
+			'numericnum ∪ int': 9007199254740991,
+			'numericnum ∪ smallint': 9007199254740991,
+			'numericnum ∪ double': 9007199254740991,
+			'numericnum ∪ smallserial': 9007199254740991,
+			'numericnum ∪ serial': 9007199254740991,
+			'numericnum ∪ bigserialnum': 9007199254740991,
+			'numericnum ∪ bigintnum': 9007199254740991,
+			'numericnum ∪ numericnum': 9007199254740991,
+		},
+		{
+			'int ∪ int': 621,
+			'int ∪ smallint': 10,
+			'int ∪ double': 15.35325689124218,
+			'int ∪ real': 1.048596,
+			'int ∪ smallserial': 15,
+			'int ∪ serial': 1,
+			'int ∪ bigserialnum': 9007199254740991,
+			'int ∪ bigintnum': 9007199254740991,
+			'int ∪ numericnum': 9007199254740991,
+			'smallint ∪ int': 621,
+			'smallint ∪ smallint': 10,
+			'smallint ∪ double': 15.35325689124218,
+			'smallint ∪ real': 1.048596,
+			'smallint ∪ smallserial': 15,
+			'smallint ∪ serial': 1,
+			'smallint ∪ bigserialnum': 9007199254740991,
+			'smallint ∪ bigintnum': 9007199254740991,
+			'smallint ∪ numericnum': 9007199254740991,
+			'double ∪ int': 621,
+			'double ∪ smallint': 10,
+			'double ∪ double': 15.35325689124218,
+			'double ∪ real': 1.0485960245132446,
+			'double ∪ smallserial': 15,
+			'double ∪ serial': 1,
+			'double ∪ bigserialnum': 9007199254740991,
+			'double ∪ bigintnum': 9007199254740991,
+			'double ∪ numericnum': 9007199254740991,
+			'real ∪ int': 621,
+			'real ∪ smallint': 10,
+			'real ∪ double': 15.35325689124218,
+			'real ∪ real': 1.048596,
+			'real ∪ smallserial': 15,
+			'real ∪ serial': 1,
+			'smallserial ∪ int': 621,
+			'smallserial ∪ smallint': 10,
+			'smallserial ∪ double': 15.35325689124218,
+			'smallserial ∪ real': 1.048596,
+			'smallserial ∪ smallserial': 15,
+			'smallserial ∪ serial': 1,
+			'smallserial ∪ bigserialnum': 9007199254740991,
+			'smallserial ∪ bigintnum': 9007199254740991,
+			'smallserial ∪ numericnum': 9007199254740991,
+			'serial ∪ int': 621,
+			'serial ∪ smallint': 10,
+			'serial ∪ double': 15.35325689124218,
+			'serial ∪ real': 1.048596,
+			'serial ∪ smallserial': 15,
+			'serial ∪ serial': 1,
+			'serial ∪ bigserialnum': 9007199254740991,
+			'serial ∪ bigintnum': 9007199254740991,
+			'serial ∪ numericnum': 9007199254740991,
+			'bigserialnum ∪ int': 621,
+			'bigserialnum ∪ smallint': 10,
+			'bigserialnum ∪ double': 15.35325689124218,
+			'bigserialnum ∪ smallserial': 15,
+			'bigserialnum ∪ serial': 1,
+			'bigserialnum ∪ bigserialnum': 9007199254740991,
+			'bigserialnum ∪ bigintnum': 9007199254740991,
+			'bigserialnum ∪ numericnum': 9007199254740991,
+			'bigintnum ∪ int': 621,
+			'bigintnum ∪ smallint': 10,
+			'bigintnum ∪ double': 15.35325689124218,
+			'bigintnum ∪ smallserial': 15,
+			'bigintnum ∪ serial': 1,
+			'bigintnum ∪ bigserialnum': 9007199254740991,
+			'bigintnum ∪ bigintnum': 9007199254740991,
+			'bigintnum ∪ numericnum': 9007199254740991,
+			'numericnum ∪ int': 621,
+			'numericnum ∪ smallint': 10,
+			'numericnum ∪ double': 15.35325689124218,
+			'numericnum ∪ smallserial': 15,
+			'numericnum ∪ serial': 1,
+			'numericnum ∪ bigserialnum': 9007199254740991,
+			'numericnum ∪ bigintnum': 9007199254740991,
+			'numericnum ∪ numericnum': 9007199254740991,
+		},
+	]));
+
+	// ---- bigint ----
+	expect(
+		await unionAll(
+			db.select({
+				'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+				'bigint ∪ bigserial': allTypesTable.bigint.as('bigint ∪ bigserial'),
+				'bigint ∪ numericbig': allTypesTable.bigint.as('bigint ∪ numericbig'),
+				'bigserial ∪ bigint': allTypesTable.bigserial.as('bigserial ∪ bigint'),
+				'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+				'bigserial ∪ numericbig': allTypesTable.bigserial.as('bigserial ∪ numericbig'),
+				'numericbig ∪ bigint': allTypesTable.numericbig.as('numericbig ∪ bigint'),
+				'numericbig ∪ bigserial': allTypesTable.numericbig.as('numericbig ∪ bigserial'),
+				'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+			}).from(allTypesTable),
+			db.select({
+				'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+				'bigint ∪ bigserial': allTypesTable.bigserial.as('bigint ∪ bigserial'),
+				'bigint ∪ numericbig': allTypesTable.numericbig.as('bigint ∪ numericbig'),
+				'bigserial ∪ bigint': allTypesTable.bigint.as('bigserial ∪ bigint'),
+				'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+				'bigserial ∪ numericbig': allTypesTable.numericbig.as('bigserial ∪ numericbig'),
+				'numericbig ∪ bigint': allTypesTable.bigint.as('numericbig ∪ bigint'),
+				'numericbig ∪ bigserial': allTypesTable.bigserial.as('numericbig ∪ bigserial'),
+				'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'bigint ∪ bigint': 5044565289845416380n,
+			'bigint ∪ bigserial': 5044565289845416380n,
+			'bigint ∪ numericbig': 5044565289845416380n,
+			'bigserial ∪ bigint': 5044565289845416380n,
+			'bigserial ∪ bigserial': 5044565289845416380n,
+			'bigserial ∪ numericbig': 5044565289845416380n,
+			'numericbig ∪ bigint': 5044565289845416380n,
+			'numericbig ∪ bigserial': 5044565289845416380n,
+			'numericbig ∪ numericbig': 5044565289845416380n,
+		},
+		{
+			'bigint ∪ bigint': 5044565289845416380n,
+			'bigint ∪ bigserial': 5044565289845416380n,
+			'bigint ∪ numericbig': 5044565289845416380n,
+			'bigserial ∪ bigint': 5044565289845416380n,
+			'bigserial ∪ bigserial': 5044565289845416380n,
+			'bigserial ∪ numericbig': 5044565289845416380n,
+			'numericbig ∪ bigint': 5044565289845416380n,
+			'numericbig ∪ bigserial': 5044565289845416380n,
+			'numericbig ∪ numericbig': 5044565289845416380n,
+		},
+	]));
+
+	// ---- text ----
+	expect(
+		await unionAll(
+			db.select({
+				'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+				'varchar ∪ text': allTypesTable.varchar.as('varchar ∪ text'),
+				'text ∪ varchar': allTypesTable.text.as('text ∪ varchar'),
+				'text ∪ text': allTypesTable.text.as('text ∪ text'),
+			}).from(allTypesTable),
+			db.select({
+				'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+				'varchar ∪ text': allTypesTable.text.as('varchar ∪ text'),
+				'text ∪ varchar': allTypesTable.varchar.as('text ∪ varchar'),
+				'text ∪ text': allTypesTable.text.as('text ∪ text'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'varchar ∪ varchar': 'C4-',
+			'varchar ∪ text': 'C4-',
+			'text ∪ varchar': 'TEXT STRING',
+			'text ∪ text': 'TEXT STRING',
+		},
+		{
+			'varchar ∪ varchar': 'C4-',
+			'varchar ∪ text': 'TEXT STRING',
+			'text ∪ varchar': 'C4-',
+			'text ∪ text': 'TEXT STRING',
+		},
+	]));
+
+	// ---- numstr ----
+	expect(
+		await unionAll(
+			db.select({
+				'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+				'bigintstr ∪ numeric': allTypesTable.bigintstr.as('bigintstr ∪ numeric'),
+				'numeric ∪ bigintstr': allTypesTable.numeric.as('numeric ∪ bigintstr'),
+				'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+			}).from(allTypesTable),
+			db.select({
+				'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+				'bigintstr ∪ numeric': allTypesTable.numeric.as('bigintstr ∪ numeric'),
+				'numeric ∪ bigintstr': allTypesTable.bigintstr.as('numeric ∪ bigintstr'),
+				'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'bigintstr ∪ bigintstr': '5044565289845416380',
+			'bigintstr ∪ numeric': '5044565289845416380',
+			'numeric ∪ bigintstr': '5044565289845416380',
+			'numeric ∪ numeric': '5044565289845416380',
+		},
+		{
+			'bigintstr ∪ bigintstr': '5044565289845416380',
+			'bigintstr ∪ numeric': '5044565289845416380',
+			'numeric ∪ bigintstr': '5044565289845416380',
+			'numeric ∪ numeric': '5044565289845416380',
+		},
+	]));
+
+	// ---- date ----
+	expect(
+		await unionAll(
+			db.select({
+				'date ∪ date': allTypesTable.date.as('date ∪ date'),
+				'date ∪ timestamp': allTypesTable.date.as('date ∪ timestamp'),
+				'date ∪ timestampTz': allTypesTable.date.as('date ∪ timestampTz'),
+				'timestamp ∪ date': allTypesTable.timestamp.as('timestamp ∪ date'),
+				'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+				'timestamp ∪ timestampTz': allTypesTable.timestamp.as('timestamp ∪ timestampTz'),
+				'timestampTz ∪ date': allTypesTable.timestampTz.as('timestampTz ∪ date'),
+				'timestampTz ∪ timestamp': allTypesTable.timestampTz.as('timestampTz ∪ timestamp'),
+				'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+			}).from(allTypesTable),
+			db.select({
+				'date ∪ date': allTypesTable.date.as('date ∪ date'),
+				'date ∪ timestamp': allTypesTable.timestamp.as('date ∪ timestamp'),
+				'date ∪ timestampTz': allTypesTable.timestampTz.as('date ∪ timestampTz'),
+				'timestamp ∪ date': allTypesTable.date.as('timestamp ∪ date'),
+				'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+				'timestamp ∪ timestampTz': allTypesTable.timestampTz.as('timestamp ∪ timestampTz'),
+				'timestampTz ∪ date': allTypesTable.date.as('timestampTz ∪ date'),
+				'timestampTz ∪ timestamp': allTypesTable.timestamp.as('timestampTz ∪ timestamp'),
+				'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'date ∪ date': new Date('2025-03-12'),
+			'date ∪ timestamp': new Date('2025-03-12'),
+			'date ∪ timestampTz': new Date('2025-03-12'),
+			'timestamp ∪ date': new Date('2025-03-12 01:32:41.623'),
+			'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+			'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623'),
+			'timestampTz ∪ date': new Date('2025-03-12 01:32:41.623+00'),
+			'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623+00'),
+			'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+		},
+		{
+			'date ∪ date': new Date('2025-03-12'),
+			'date ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+			'date ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+			'timestamp ∪ date': new Date('2025-03-12'),
+			'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+			'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+			'timestampTz ∪ date': new Date('2025-03-12'),
+			'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+			'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+		},
+	]));
+
+	// ---- json ----
+	expect(
+		await unionAll(
+			db.select({
+				'json ∪ json': allTypesTable.json.as('json ∪ json'),
+				'json ∪ json1': allTypesTable.json.as('json ∪ json1'),
+				'json ∪ json3': allTypesTable.json.as('json ∪ json3'),
+				'json1 ∪ json': allTypesTable.json1.as('json1 ∪ json'),
+				'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+				'json1 ∪ json3': allTypesTable.json1.as('json1 ∪ json3'),
+				'json3 ∪ json': allTypesTable.json3.as('json3 ∪ json'),
+				'json3 ∪ json1': allTypesTable.json3.as('json3 ∪ json1'),
+				'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+			}).from(allTypesTable),
+			db.select({
+				'json ∪ json': allTypesTable.json.as('json ∪ json'),
+				'json ∪ json1': allTypesTable.json1.as('json ∪ json1'),
+				'json ∪ json3': allTypesTable.json3.as('json ∪ json3'),
+				'json1 ∪ json': allTypesTable.json.as('json1 ∪ json'),
+				'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+				'json1 ∪ json3': allTypesTable.json3.as('json1 ∪ json3'),
+				'json3 ∪ json': allTypesTable.json.as('json3 ∪ json'),
+				'json3 ∪ json1': allTypesTable.json1.as('json3 ∪ json1'),
+				'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'json ∪ json': { str: 'strval', arr: ['str', 10] },
+			'json ∪ json1': { str: 'strval', arr: ['str', 10] },
+			'json ∪ json3': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json1 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json3 ∪ json': '5',
+			'json3 ∪ json1': '5',
+			'json3 ∪ json3': '5',
+		},
+		{
+			'json ∪ json': { str: 'strval', arr: ['str', 10] },
+			'json ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json ∪ json3': '5',
+			'json1 ∪ json': { str: 'strval', arr: ['str', 10] },
+			'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json1 ∪ json3': '5',
+			'json3 ∪ json': { str: 'strval', arr: ['str', 10] },
+			'json3 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+			'json3 ∪ json3': '5',
+		},
+	]));
+
+	// ---- jsonb ----
+	expect(
+		await unionAll(
+			db.select({
+				'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+				'jsonb ∪ jsonb1': allTypesTable.jsonb.as('jsonb ∪ jsonb1'),
+				'jsonb ∪ jsonb3': allTypesTable.jsonb.as('jsonb ∪ jsonb3'),
+				'jsonb1 ∪ jsonb': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb'),
+				'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+				'jsonb1 ∪ jsonb3': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb3'),
+				'jsonb3 ∪ jsonb': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb'),
+				'jsonb3 ∪ jsonb1': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb1'),
+				'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+			}).from(allTypesTable),
+			db.select({
+				'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+				'jsonb ∪ jsonb1': allTypesTable.jsonb1.as('jsonb ∪ jsonb1'),
+				'jsonb ∪ jsonb3': allTypesTable.jsonb3.as('jsonb ∪ jsonb3'),
+				'jsonb1 ∪ jsonb': allTypesTable.jsonb.as('jsonb1 ∪ jsonb'),
+				'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+				'jsonb1 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb1 ∪ jsonb3'),
+				'jsonb3 ∪ jsonb': allTypesTable.jsonb.as('jsonb3 ∪ jsonb'),
+				'jsonb3 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb3 ∪ jsonb1'),
+				'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb ∪ jsonb1': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb ∪ jsonb3': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb1 ∪ jsonb': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb1 ∪ jsonb3': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb3 ∪ jsonb': '7',
+			'jsonb3 ∪ jsonb1': '7',
+			'jsonb3 ∪ jsonb3': '7',
+		},
+		{
+			'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb ∪ jsonb3': '7',
+			'jsonb1 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb1 ∪ jsonb3': '7',
+			'jsonb3 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+			'jsonb3 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+			'jsonb3 ∪ jsonb3': '7',
+		},
+	]));
+
+	// ---- self-only ----
+	expect(
+		await unionAll(
+			db.select({
+				'char ∪ char': allTypesTable.char.as('char ∪ char'),
+				'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+				'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+				'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+				'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+				'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+				'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+				'time ∪ time': allTypesTable.time.as('time ∪ time'),
+				'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+				'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+				'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+				'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+				'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+				'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+				'line ∪ line': allTypesTable.line.as('line ∪ line'),
+				'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+				'point ∪ point': allTypesTable.point.as('point ∪ point'),
+				'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+			}).from(allTypesTable),
+			db.select({
+				'char ∪ char': allTypesTable.char.as('char ∪ char'),
+				'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+				'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+				'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+				'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+				'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+				'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+				'time ∪ time': allTypesTable.time.as('time ∪ time'),
+				'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+				'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+				'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+				'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+				'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+				'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+				'line ∪ line': allTypesTable.line.as('line ∪ line'),
+				'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+				'point ∪ point': allTypesTable.point.as('point ∪ point'),
+				'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+			}).from(allTypesTable),
+		),
+	).toEqual(expect.arrayContaining([
+		{
+			'char ∪ char': 'c',
+			'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+			'inet ∪ inet': '192.168.0.1/24',
+			'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+			'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+			'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+			'interval ∪ interval': '-2 mons',
+			'time ∪ time': '13:59:28',
+			'datestr ∪ datestr': '2025-03-12',
+			'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+			'bool ∪ bool': true,
+			'bytea ∪ bytea': Buffer.from('BYTES'),
+			'enum ∪ enum': 'enVal1',
+			'line ∪ line': { a: 1, b: 2, c: 3 },
+			'linetuple ∪ linetuple': [1, 2, 3],
+			'point ∪ point': { x: 24.5, y: 49.6 },
+			'pointtuple ∪ pointtuple': [24.5, 49.6],
+		},
+		{
+			'char ∪ char': 'c',
+			'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+			'inet ∪ inet': '192.168.0.1/24',
+			'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+			'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+			'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+			'interval ∪ interval': '-2 mons',
+			'time ∪ time': '13:59:28',
+			'datestr ∪ datestr': '2025-03-12',
+			'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+			'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+			'bool ∪ bool': true,
+			'bytea ∪ bytea': Buffer.from('BYTES'),
+			'enum ∪ enum': 'enVal1',
+			'line ∪ line': { a: 1, b: 2, c: 3 },
+			'linetuple ∪ linetuple': [1, 2, 3],
+			'point ∪ point': { x: 24.5, y: 49.6 },
+			'pointtuple ∪ pointtuple': [24.5, 49.6],
+		},
+	]));
+});
+
+test('Query error wrapping', async () => {
+	let err: any;
+	// expect(...).rejects is broken
+	await (db.insert(usersTable).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]).catch((e) => err = e));
+	expect(err).toBeInstanceOf(DrizzleQueryError);
+});
+
+test('Column as decoder applies codecs', async () => {
+	let customCast = false;
+	let customMap = false;
+
+	const codecBypass = customType<{
+		data: Date;
+		driverData: string;
+		jsonData: string;
+	}>({
+		codec: 'timestamptz',
+		dataType: () => 'timestamptz(3)',
+		forJsonSelect: (identifier, sql, arrayDimensions) => {
+			customCast = true;
+			return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+		},
+		fromJson: (v) => {
+			customMap = true;
+			return new Date(v);
+		},
+		toDriver: (v) => v.toISOString(),
+	});
+
+	const users = pgTable('users_823', (t) => ({
+		id: t.integer().primaryKey(),
+		name: t.text().notNull(),
+		createdAt: t.timestamp('created_at').notNull(),
+		createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+		arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+		arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+		cus: codecBypass('custom').notNull(),
+		arrCus: codecBypass('arr_custom').notNull().array(),
+	}));
+
+	const usersView = pgView('users_823_v').as((qb) =>
+		qb.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			arrMax: max(users.arrCreatedAt).as('arr_max'),
+			arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+			sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id)
+	);
+
+	const db = drizzle({
+		connection: process.env['PG_CONNECTION_STRING']!,
+		relations: defineRelations({ users, usersView }, (r) => ({
+			users: {
+				self: r.one.users({
+					from: r.users.id,
+					to: r.users.id,
+				}),
+			},
+			usersView: {
+				self: r.one.usersView({
+					from: r.usersView.id,
+					to: r.usersView.id,
+				}),
+			},
+		})),
+	});
+
+	await db.execute(sql`CREATE TABLE ${users} (
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		created_at TIMESTAMP NOT NULL,
+		created_at_str TIMESTAMP NOT NULL,
+		arr_created_at TIMESTAMP[] NOT NULL,
+		arr_created_at_str TIMESTAMP[] NOT NULL,
+		custom TIMESTAMPTZ NOT NULL,
+		arr_custom TIMESTAMPTZ[] NOT NULL
+	)`);
+
+	await db.execute(
+		sql`CREATE VIEW ${usersView} AS SELECT *, max(${users.createdAt}) as max, max(${users.createdAtStr}) as max_str, max(${users.arrCreatedAt}) as arr_max, max(${users.arrCreatedAtStr}) as arr_max_str, (select created_at from users) as sq FROM ${users} GROUP BY ${users.id}`,
+	);
+
+	const exDateStr = '1970-01-16 16:45:46.351';
+	const exDate = new Date(exDateStr);
+
+	await db.insert(users).values({
+		id: 1,
+		name: 'First',
+		createdAt: exDate,
+		createdAtStr: exDateStr,
+		arrCreatedAt: [exDate],
+		arrCreatedAtStr: [exDateStr],
+		cus: exDate,
+		arrCus: [exDate],
+	});
+
+	const res = await db.select({
+		...getColumns(users),
+		max: max(users.createdAt).as('max'),
+		maxStr: max(users.createdAtStr).as('max_str'),
+		arrMax: max(users.arrCreatedAt).as('arr_max'),
+		arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+		sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+	}).from(users).groupBy(users.id);
+
+	const viewRes = await db.select().from(usersView);
+
+	const nested = await db.query.users.findFirst({
+		with: {
+			self: {
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+					arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+				},
+			},
+		},
+		extras: {
+			max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+			maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+			arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+			arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+		},
+	});
+
+	const viewNested = await db.query.usersView.findFirst({
+		columns: {
+			sq: false, // TODO: re-enable when supported in RQBv2
+		},
+		with: {
+			self: {
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+			},
+		},
+	});
+
+	expect(res).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			sq: exDate,
+			cus: exDate,
+			arrCus: [exDate],
+		},
+	]);
+	expect(viewRes).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			sq: exDate,
+			cus: exDate,
+			arrCus: [exDate],
+		},
+	]);
+
+	expect(customCast).toBeTruthy();
+	expect(customMap).toBeTruthy();
+
+	expect(nested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			cus: exDate,
+			arrCus: [exDate],
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				max: exDate,
+				maxStr: exDateStr,
+				arrMax: [exDate],
+				arrMaxStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			},
+		},
+	);
+	expect(viewNested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			cus: exDate,
+			arrCus: [exDate],
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				max: exDate,
+				maxStr: exDateStr,
+				arrMax: [exDate],
+				arrMaxStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			},
+		},
+	);
+});
+
+test('Column as decoder applies codecs - Jit mappers', async () => {
+	let customCast = false;
+	let customMap = false;
+
+	const codecBypass = customType<{
+		data: Date;
+		driverData: string;
+		jsonData: string;
+	}>({
+		codec: 'timestamptz',
+		dataType: () => 'timestamptz(3)',
+		forJsonSelect: (identifier, sql, arrayDimensions) => {
+			customCast = true;
+			return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+		},
+		fromJson: (v) => {
+			customMap = true;
+			return new Date(v);
+		},
+		toDriver: (v) => v.toISOString(),
+	});
+
+	const users = pgTable('users_823', (t) => ({
+		id: t.integer().primaryKey(),
+		name: t.text().notNull(),
+		createdAt: t.timestamp('created_at').notNull(),
+		createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+		arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+		arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+		cus: codecBypass('custom').notNull(),
+		arrCus: codecBypass('arr_custom').notNull().array(),
+	}));
+
+	const usersView = pgView('users_823_v').as((qb) =>
+		qb.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			arrMax: max(users.arrCreatedAt).as('arr_max'),
+			arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+			sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id)
+	);
+
+	const db = drizzle({
+		connection: process.env['PG_CONNECTION_STRING']!,
+		relations: defineRelations({ users, usersView }, (r) => ({
+			users: {
+				self: r.one.users({
+					from: r.users.id,
+					to: r.users.id,
+				}),
+			},
+			usersView: {
+				self: r.one.usersView({
+					from: r.usersView.id,
+					to: r.usersView.id,
+				}),
+			},
+		})),
+		jit: true,
+	});
+
+	await db.execute(sql`CREATE TABLE ${users} (
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		created_at TIMESTAMP NOT NULL,
+		created_at_str TIMESTAMP NOT NULL,
+		arr_created_at TIMESTAMP[] NOT NULL,
+		arr_created_at_str TIMESTAMP[] NOT NULL,
+		custom TIMESTAMPTZ NOT NULL,
+		arr_custom TIMESTAMPTZ[] NOT NULL
+	)`);
+
+	await db.execute(
+		sql`CREATE VIEW ${usersView} AS SELECT *, max(${users.createdAt}) as max, max(${users.createdAtStr}) as max_str, max(${users.arrCreatedAt}) as arr_max, max(${users.arrCreatedAtStr}) as arr_max_str, (select created_at from users) as sq FROM ${users} GROUP BY ${users.id}`,
+	);
+
+	const exDateStr = '1970-01-16 16:45:46.351';
+	const exDate = new Date(exDateStr);
+
+	await db.insert(users).values({
+		id: 1,
+		name: 'First',
+		createdAt: exDate,
+		createdAtStr: exDateStr,
+		arrCreatedAt: [exDate],
+		arrCreatedAtStr: [exDateStr],
+		cus: exDate,
+		arrCus: [exDate],
+	});
+
+	const res = await db.select({
+		...getColumns(users),
+		max: max(users.createdAt).as('max'),
+		maxStr: max(users.createdAtStr).as('max_str'),
+		arrMax: max(users.arrCreatedAt).as('arr_max'),
+		arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+		sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+	}).from(users).groupBy(users.id);
+
+	const viewRes = await db.select().from(usersView);
+
+	const nested = await db.query.users.findFirst({
+		with: {
+			self: {
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+					arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+				},
+			},
+		},
+		extras: {
+			max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+			maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+			arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+			arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+		},
+	});
+
+	const viewNested = await db.query.usersView.findFirst({
+		columns: {
+			sq: false, // TODO: re-enable when supported in RQBv2
+		},
+		with: {
+			self: {
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+			},
+		},
+	});
+
+	expect(res).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			sq: exDate,
+			cus: exDate,
+			arrCus: [exDate],
+		},
+	]);
+	expect(viewRes).toStrictEqual([
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			sq: exDate,
+			cus: exDate,
+			arrCus: [exDate],
+		},
+	]);
+
+	expect(customCast).toBeTruthy();
+	expect(customMap).toBeTruthy();
+
+	expect(nested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			cus: exDate,
+			arrCus: [exDate],
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				max: exDate,
+				maxStr: exDateStr,
+				arrMax: [exDate],
+				arrMaxStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			},
+		},
+	);
+	expect(viewNested).toStrictEqual(
+		{
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			arrCreatedAt: [exDate],
+			arrCreatedAtStr: [exDateStr],
+			max: exDate,
+			maxStr: exDateStr,
+			arrMax: [exDate],
+			arrMaxStr: [exDateStr],
+			cus: exDate,
+			arrCus: [exDate],
+			self: {
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				max: exDate,
+				maxStr: exDateStr,
+				arrMax: [exDate],
+				arrMaxStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			},
+		},
+	);
+});
diff --git a/integration-tests/tests/bun/bun-sqlite.test.ts b/integration-tests/tests/bun/bun-sqlite.test.ts
new file mode 100644
index 0000000000..87dd55198d
--- /dev/null
+++ b/integration-tests/tests/bun/bun-sqlite.test.ts
@@ -0,0 +1,4696 @@
+/// <reference types="bun-types" />
+
+import { SQL } from 'bun';
+import { afterAll, beforeAll, beforeEach, describe, expect, expectTypeOf, spyOn, test } from 'bun:test';
+import {
+	and,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	defineRelations,
+	eq,
+	exists,
+	getTableColumns,
+	getTableName,
+	gt,
+	gte,
+	inArray,
+	is,
+	lt,
+	max,
+	min,
+	Name,
+	notInArray,
+	sql,
+	sum,
+	sumDistinct,
+	Table,
+	TransactionRollbackError,
+} from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/bun-sql';
+import { migrate } from 'drizzle-orm/bun-sql/migrator';
+import type { BunSQLiteDatabase } from 'drizzle-orm/bun-sql/sqlite';
+import type { MutationOption } from 'drizzle-orm/cache/core';
+import { Cache } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import {
+	alias,
+	blob,
+	except,
+	foreignKey,
+	getTableConfig,
+	getViewConfig,
+	index,
+	int,
+	integer,
+	intersect,
+	numeric,
+	primaryKey,
+	real,
+	type SQLiteAsyncDatabase,
+	sqliteTable,
+	sqliteTableCreator,
+	sqliteView,
+	text,
+	union,
+	unionAll,
+	unique,
+	uniqueKeyName,
+} from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import Keyv from 'keyv';
+import type { Equal } from '~/utils';
+import { Expect } from '~/utils';
+
+export const rqbUser = sqliteTable('user_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const rqbPost = sqliteTable('post_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const relations = defineRelations({
+	rqbUser,
+	rqbPost,
+}, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
+
+const allTypesTable = sqliteTable('all_types', {
+	int: integer('int', {
+		mode: 'number',
+	}),
+	bool: integer('bool', {
+		mode: 'boolean',
+	}),
+	time: integer('time', {
+		mode: 'timestamp',
+	}),
+	timeMs: integer('time_ms', {
+		mode: 'timestamp_ms',
+	}),
+	bigint: blob('bigint', {
+		mode: 'bigint',
+	}),
+	buffer: blob('buffer', {
+		mode: 'buffer',
+	}),
+	json: blob('json', {
+		mode: 'json',
+	}),
+	numeric: numeric('numeric'),
+	numericNum: numeric('numeric_num', {
+		mode: 'number',
+	}),
+	numericBig: numeric('numeric_big', {
+		mode: 'bigint',
+	}),
+	real: real('real'),
+	text: text('text', {
+		mode: 'text',
+	}),
+	jsonText: text('json_text', {
+		mode: 'json',
+	}),
+});
+
+export const usersTable = sqliteTable('users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+	json: blob('json', { mode: 'json' }).$type<string[]>(),
+	createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`strftime('%s', 'now')`),
+});
+
+export const usersOnUpdate = sqliteTable('users_on_update', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	name: text('name').notNull(),
+	updateCounter: integer('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).$onUpdate(() => new Date()),
+	alwaysNull: text('always_null').$type<string | null>().$onUpdate(() => null),
+	// uppercaseName: text('uppercase_name').$onUpdateFn(() =>
+	// 	sql`upper(s.name)`
+	// ),  This doesn't seem to be supported in sqlite
+});
+
+export const users2Table = sqliteTable('users2', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: integer('city_id').references(() => citiesTable.id),
+});
+
+export const citiesTable = sqliteTable('cities', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const coursesTable = sqliteTable('courses', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: integer('category_id').references(() => courseCategoriesTable.id),
+});
+
+const courseCategoriesTable = sqliteTable('course_categories', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const orders = sqliteTable('orders', {
+	id: integer('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: integer('amount').notNull(),
+	quantity: integer('quantity').notNull(),
+});
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+const pkExampleTable = sqliteTable('pk_example', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => ({
+	compositePk: primaryKey({ columns: [table.id, table.name] }),
+}));
+
+const conflictChainExampleTable = sqliteTable('conflict_chain_example', {
+	id: integer('id').notNull().unique(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => ({
+	compositePk: primaryKey({ columns: [table.id, table.name] }),
+}));
+
+const bigIntExample = sqliteTable('big_int_example', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	bigInt: blob('big_int', { mode: 'bigint' }).notNull(),
+});
+
+// To test aggregate functions
+const aggregateTable = sqliteTable('aggregate_table', {
+	id: integer('id').primaryKey({ autoIncrement: true }).notNull(),
+	name: text('name').notNull(),
+	a: integer('a'),
+	b: integer('b'),
+	c: integer('c'),
+	nullOnly: integer('null_only'),
+});
+
+const ENABLE_LOGGING = false;
+
+let db: BunSQLiteDatabase<typeof relations> & { $client: SQL };
+let dbGlobalCached: BunSQLiteDatabase & { $client: SQL };
+let cachedDb: BunSQLiteDatabase & { $client: SQL };
+let client: SQL;
+
+beforeAll(async () => {
+	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
+	client = new SQL(dbPath);
+	db = drizzle.sqlite({ client, logger: ENABLE_LOGGING, relations });
+	cachedDb = drizzle.sqlite({ client, logger: ENABLE_LOGGING, cache: new TestCache() });
+	dbGlobalCached = drizzle.sqlite({ client, logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
+});
+
+afterAll(async () => {
+	await client?.close();
+	await cachedDb?.$client.end();
+	await dbGlobalCached?.$client.end();
+});
+
+test('migrator', async () => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate.sqlite(db, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
+
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toStrictEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toStrictEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async () => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists "__drizzle_migrations";`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/bun-sqlite';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" INTEGER PRIMARY KEY NOT NULL,\n"name" TEXT NOT NULL,\n"email" TEXT NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" INTEGER;`,
+	);
+
+	await migrate.sqlite(db, { migrationsFolder: migrationDir });
+	await db.insert(users).values({ name: 'John', email: '', age: 30 });
+	const res1 = await db.select().from(users);
+
+	// second migration was not applied yet
+	expect((async () => await db.insert(users2).values({ name: 'John', email: '', age: 30 }))()).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" INTEGER PRIMARY KEY NOT NULL,\n"name" TEXT NOT NULL,\n"email" TEXT NOT NULL\n,"age" INTEGER\n);`,
+	);
+	await migrate.sqlite(db, { migrationsFolder: migrationDir });
+
+	await db.insert(users2).values({ name: 'John', email: '', age: 30 });
+	const res2 = await db.select().from(users2);
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+describe('common', () => {
+	beforeEach(async () => {
+		await db.run(sql`drop table if exists ${usersTable}`);
+		await db.run(sql`drop table if exists ${users2Table}`);
+		await db.run(sql`drop table if exists ${citiesTable}`);
+		await db.run(sql`drop table if exists ${coursesTable}`);
+		await db.run(sql`drop table if exists ${courseCategoriesTable}`);
+		await db.run(sql`drop table if exists ${orders}`);
+		await db.run(sql`drop table if exists ${bigIntExample}`);
+		await db.run(sql`drop table if exists ${pkExampleTable}`);
+		await db.run(sql`drop table if exists ${conflictChainExampleTable}`);
+		await db.run(sql`drop table if exists ${allTypesTable}`);
+		await db.run(sql`drop table if exists user_notifications_insert_into`);
+		await db.run(sql`drop table if exists users_insert_into`);
+		await db.run(sql`drop table if exists notifications_insert_into`);
+		await db.run(sql`drop table if exists ${rqbUser};`);
+		await db.run(sql`drop table if exists ${rqbPost};`);
+
+		await db.run(sql`
+			create table ${usersTable} (
+				id integer primary key,
+				name text not null,
+				verified integer not null default 0,
+				json blob,
+				created_at integer not null default (strftime('%s', 'now'))
+			)
+		`);
+
+		await db.run(sql`
+			create table ${citiesTable} (
+				id integer primary key,
+				name text not null
+			)
+		`);
+		await db.run(sql`
+			create table ${courseCategoriesTable} (
+				id integer primary key,
+				name text not null
+			)
+		`);
+
+		await db.run(sql`
+			create table ${users2Table} (
+				id integer primary key,
+				name text not null,
+				city_id integer references ${citiesTable}(${sql.identifier(citiesTable.id.name)})
+			)
+		`);
+		await db.run(sql`
+			create table ${coursesTable} (
+				id integer primary key,
+				name text not null,
+				category_id integer references ${courseCategoriesTable}(${sql.identifier(courseCategoriesTable.id.name)})
+			)
+		`);
+		await db.run(sql`
+			create table ${orders} (
+				id integer primary key,
+				region text not null,
+				product text not null,
+				amount integer not null,
+				quantity integer not null
+			)
+		`);
+		await db.run(sql`
+			create table ${pkExampleTable} (
+				id integer not null,
+				name text not null,
+				email text not null,
+				primary key (id, name)
+			)
+		`);
+		await db.run(sql`
+			create table ${conflictChainExampleTable} (
+				id integer not null unique,
+				name text not null,
+				email text not null,
+				primary key (id, name)
+			)
+		`);
+		await db.run(sql`
+			create table ${bigIntExample} (
+			  id integer primary key,
+			  name text not null,
+			  big_int blob not null
+			)
+		`);
+		await db.run(sql`
+			CREATE TABLE ${rqbUser} (
+					"id" INT PRIMARY KEY NOT NULL,
+					"name" TEXT NOT NULL,
+					"created_at" INT NOT NULL
+				 )
+		`);
+		await db.run(sql`
+			CREATE TABLE ${rqbPost} ( 
+					"id" INT PRIMARY KEY NOT NULL,
+					"user_id" INT NOT NULL,
+					"content" TEXT,
+					"created_at" INT NOT NULL
+			)
+		`);
+	});
+
+	async function setupSetOperationTest(db: SQLiteAsyncDatabase<any, any, any>) {
+		await db.run(sql`drop table if exists users2`);
+		await db.run(sql`drop table if exists cities`);
+		await db.run(sql`
+			create table \`cities\` (
+				id integer primary key,
+				name text not null
+			)
+		`);
+
+		await db.run(sql`
+			create table \`users2\` (
+				id integer primary key,
+				name text not null,
+				city_id integer references ${citiesTable}(${sql.identifier(citiesTable.id.name)})
+			)
+		`);
+
+		await db.insert(citiesTable).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await db.insert(users2Table).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+	}
+
+	async function setupAggregateFunctionsTest(db: SQLiteAsyncDatabase<any, any, any>) {
+		await db.run(sql`drop table if exists "aggregate_table"`);
+		await db.run(
+			sql`
+				create table "aggregate_table" (
+					"id" integer primary key autoincrement not null,
+					"name" text not null,
+					"a" integer,
+					"b" integer,
+					"c" integer,
+					"null_only" integer
+				);
+			`,
+		);
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+	}
+
+	test('table config: foreign keys name', async () => {
+		const table = sqliteTable('cities', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		}, (t) => ({
+			f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
+			f1: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk_deprecated' }),
+		}));
+
+		const tableConfig = getTableConfig(table);
+
+		expect(tableConfig.foreignKeys).toHaveLength(2);
+		expect(tableConfig.foreignKeys[0]!.getName()).toStrictEqual('custom_fk');
+		expect(tableConfig.foreignKeys[1]!.getName()).toStrictEqual('custom_fk_deprecated');
+	});
+
+	test('table config: primary keys name', async () => {
+		const table = sqliteTable('cities', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		}, (t) => ({
+			f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
+		}));
+
+		const tableConfig = getTableConfig(table);
+
+		expect(tableConfig.primaryKeys).toHaveLength(1);
+		expect(tableConfig.primaryKeys[0]!.getName()).toStrictEqual('custom_pk');
+	});
+
+	test('insert bigint values', async () => {
+		await db.insert(bigIntExample).values({ name: 'one', bigInt: BigInt('0') }).run();
+		await db.insert(bigIntExample).values({ name: 'two', bigInt: BigInt('127') }).run();
+		await db.insert(bigIntExample).values({ name: 'three', bigInt: BigInt('32767') }).run();
+		await db.insert(bigIntExample).values({ name: 'four', bigInt: BigInt('1234567890') }).run();
+		await db.insert(bigIntExample).values({ name: 'five', bigInt: BigInt('12345678900987654321') }).run();
+
+		const result = await db.select().from(bigIntExample).all();
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'one', bigInt: BigInt('0') },
+			{ id: 2, name: 'two', bigInt: BigInt('127') },
+			{ id: 3, name: 'three', bigInt: BigInt('32767') },
+			{ id: 4, name: 'four', bigInt: BigInt('1234567890') },
+			{ id: 5, name: 'five', bigInt: BigInt('12345678900987654321') },
+		]);
+	});
+
+	test('select all fields', async () => {
+		const now = Date.now();
+
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const result = await db.select().from(usersTable).all();
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			json: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('select partial', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const result = await db.select({ name: usersTable.name }).from(usersTable).all();
+
+		expect(result).toStrictEqual([{ name: 'John' }]);
+	});
+
+	test('select sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.select({
+			name: sql`upper(${usersTable.name})`,
+		}).from(usersTable).all();
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('select typed sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.select({
+			name: sql<string>`upper(${usersTable.name})`,
+		}).from(usersTable).all();
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('select with empty array in inArray', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		const result = await db
+			.select({
+				name: sql`upper(${usersTable.name})`,
+			})
+			.from(usersTable)
+			.where(inArray(usersTable.id, []));
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test('select with empty array in notInArray', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		const result = await db
+			.select({
+				name: sql`upper(${usersTable.name})`,
+			})
+			.from(usersTable)
+			.where(notInArray(usersTable.id, []));
+
+		expect(result).toStrictEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+	});
+
+	test('select distinct', async () => {
+		const usersDistinctTable = sqliteTable('users_distinct', {
+			id: integer('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${usersDistinctTable}`);
+		await db.run(sql`create table ${usersDistinctTable} (id integer, name text)`);
+
+		await db.insert(usersDistinctTable).values([
+			{ id: 1, name: 'John' },
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'John' },
+			{ id: 1, name: 'Jane' },
+		]).run();
+		const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+			usersDistinctTable.id,
+			usersDistinctTable.name,
+		).all();
+
+		await db.run(sql`drop table ${usersDistinctTable}`);
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+	});
+
+	test('insert returning sql', async () => {
+		const users = await db.insert(usersTable).values({ name: 'John' }).returning({
+			name: sql`upper(${usersTable.name})`,
+		}).all();
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('$default function', async () => {
+		await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+		const selectedOrder = await db.select().from(orders);
+
+		expect(selectedOrder).toStrictEqual([{
+			id: 1,
+			amount: 1,
+			quantity: 1,
+			region: 'Ukraine',
+			product: 'random_string',
+		}]);
+	});
+
+	test('delete returning sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+			name: sql`upper(${usersTable.name})`,
+		}).all();
+
+		expect(users).toStrictEqual([{ name: 'JOHN' }]);
+	});
+
+	test('query check: insert single empty row', () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		const query = db
+			.insert(users)
+			.values({})
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql: 'insert into "users" ("id", "name", "state") values (null, ?, null)',
+			params: ['Dan'],
+		});
+	});
+
+	test('query check: insert multiple empty rows', () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		const query = db
+			.insert(users)
+			.values([{}, {}])
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql: 'insert into "users" ("id", "name", "state") values (null, ?, null), (null, ?, null)',
+			params: ['Dan', 'Dan'],
+		});
+	});
+
+	test('Insert all defaults in 1 row', async () => {
+		const users = sqliteTable('empty_insert_single', {
+			id: integer('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table ${users} (id integer primary key, name text default 'Dan', state text)`,
+		);
+
+		await db.insert(users).values({}).run();
+
+		const res = await db.select().from(users).all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'Dan', state: null }]);
+	});
+
+	test('Insert all defaults in multiple rows', async () => {
+		const users = sqliteTable('empty_insert_multiple', {
+			id: integer('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table ${users} (id integer primary key, name text default 'Dan', state text)`,
+		);
+
+		await db.insert(users).values([{}, {}]).run();
+
+		const res = await db.select().from(users).all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+	});
+
+	test('update returning sql', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
+			name: sql`upper(${usersTable.name})`,
+		}).all();
+
+		expect(users).toStrictEqual([{ name: 'JANE' }]);
+	});
+
+	test('insert with auto increment', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'John' },
+			{ name: 'Jane' },
+			{ name: 'George' },
+			{ name: 'Austin' },
+		]).run();
+		const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'George' },
+			{ id: 4, name: 'Austin' },
+		]);
+	});
+
+	test('insert with default values', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const result = await db.select().from(usersTable).all();
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: false,
+			json: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('insert with overridden default values', async () => {
+		await db.insert(usersTable).values({ name: 'John', verified: true }).run();
+		const result = await db.select().from(usersTable).all();
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'John',
+			verified: true,
+			json: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test('update with returning all fields', async () => {
+		const now = Date.now();
+
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning()
+			.all();
+
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+	});
+
+	test('update with returning partial', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).all();
+
+		expect(users).toStrictEqual([{ id: 1, name: 'Jane' }]);
+	});
+
+	test('delete with returning all fields', async () => {
+		const now = Date.now();
+
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning().all();
+
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
+		expect(users).toStrictEqual([{ id: 1, name: 'John', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+	});
+
+	test('delete with returning partial', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).all();
+
+		expect(users).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert + select', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		await db.insert(usersTable).values({ name: 'Jane' }).run();
+		const result2 = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+		expect(result2).toStrictEqual([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+	});
+
+	test('json insert', async () => {
+		await db.insert(usersTable).values({ name: 'John', json: ['foo', 'bar'] }).run();
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			json: usersTable.json,
+		}).from(usersTable).all();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John', json: ['foo', 'bar'] }]);
+	});
+
+	test('insert many', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'John' },
+			{ name: 'Bruce', json: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]).run();
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			json: usersTable.json,
+			verified: usersTable.verified,
+		}).from(usersTable).all();
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', json: null, verified: false },
+			{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
+			{ id: 3, name: 'Jane', json: null, verified: false },
+			{ id: 4, name: 'Austin', json: null, verified: true },
+		]);
+	});
+
+	test('insert many with returning', async () => {
+		const result = await db.insert(usersTable).values([
+			{ name: 'John' },
+			{ name: 'Bruce', json: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		])
+			.returning({
+				id: usersTable.id,
+				name: usersTable.name,
+				json: usersTable.json,
+				verified: usersTable.verified,
+			})
+			.all();
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', json: null, verified: false },
+			{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
+			{ id: 3, name: 'Jane', json: null, verified: false },
+			{ id: 4, name: 'Austin', json: null, verified: true },
+		]);
+	});
+
+	test('partial join with alias', async () => {
+		const customerAlias = alias(usersTable, 'customer');
+
+		await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+
+		const result = await db
+			.select({
+				user: {
+					id: usersTable.id,
+					name: usersTable.name,
+				},
+				customer: {
+					id: customerAlias.id,
+					name: customerAlias.name,
+				},
+			}).from(usersTable)
+			.leftJoin(customerAlias, eq(customerAlias.id, 11))
+			.where(eq(usersTable.id, 10));
+
+		expect(result).toStrictEqual([{
+			user: { id: 10, name: 'Ivan' },
+			customer: { id: 11, name: 'Hans' },
+		}]);
+	});
+
+	test('full join with alias', async () => {
+		const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
+
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+		await db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]).run();
+		const result = await db
+			.select().from(users)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(users.id, 10))
+			.all();
+
+		expect(result).toStrictEqual([{
+			users: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		}]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('select from alias', async () => {
+		const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
+
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+		await db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+
+		const user = alias(users, 'user');
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]).run();
+		const result = await db
+			.select()
+			.from(user)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(user.id, 10))
+			.all();
+
+		expect(result).toStrictEqual([{
+			user: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		}]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('insert with spaces', async () => {
+		await db.insert(usersTable).values({ name: sql`'Jo   h     n'` }).run();
+		const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'Jo   h     n' }]);
+	});
+
+	test('prepared statement', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const statement = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).prepare();
+		const result = await statement.all();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('prepared statement reuse', async () => {
+		const stmt = db.insert(usersTable).values({ name: sql.placeholder('name') }).prepare();
+
+		for (let i = 0; i < 10; i++) {
+			await stmt.run({ name: `John ${i}` });
+		}
+
+		const result = await db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).from(usersTable).all();
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John 0' },
+			{ id: 2, name: 'John 1' },
+			{ id: 3, name: 'John 2' },
+			{ id: 4, name: 'John 3' },
+			{ id: 5, name: 'John 4' },
+			{ id: 6, name: 'John 5' },
+			{ id: 7, name: 'John 6' },
+			{ id: 8, name: 'John 7' },
+			{ id: 9, name: 'John 8' },
+			{ id: 10, name: 'John 9' },
+		]);
+	});
+
+	test('insert: placeholders on columns with encoder', async () => {
+		const stmt = db.insert(usersTable).values({
+			name: 'John',
+			verified: sql.placeholder('verified'),
+		}).prepare();
+
+		await stmt.run({ verified: true });
+		await stmt.run({ verified: false });
+
+		const result = await db.select({
+			id: usersTable.id,
+			verified: usersTable.verified,
+		}).from(usersTable).all();
+
+		expect(result).toStrictEqual([
+			{ id: 1, verified: true },
+			{ id: 2, verified: false },
+		]);
+	});
+
+	test('prepared statement with placeholder in .where', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const stmt = db.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		}).from(usersTable)
+			.where(eq(usersTable.id, sql.placeholder('id')))
+			.prepare();
+		const result = await stmt.all({ id: 1 });
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('prepared statement with placeholder in .limit', async () => {
+		await db.insert(usersTable).values({ name: 'John' }).run();
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.where(eq(usersTable.id, sql.placeholder('id')))
+			.limit(sql.placeholder('limit'))
+			.prepare();
+
+		const result = await stmt.all({ id: 1, limit: 1 });
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+		expect(result).toHaveLength(1);
+	});
+
+	test('prepared statement with placeholder in .offset', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).run();
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.limit(sql.placeholder('limit'))
+			.offset(sql.placeholder('offset'))
+			.prepare();
+
+		const result = await stmt.all({ limit: 1, offset: 1 });
+
+		expect(result).toStrictEqual([{ id: 2, name: 'John1' }]);
+	});
+
+	test('prepared statement built using $dynamic', async () => {
+		function withLimitOffset(qb: any) {
+			return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+		}
+
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).run();
+		const stmt = db
+			.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			})
+			.from(usersTable)
+			.$dynamic();
+		withLimitOffset(stmt).prepare('stmt_limit');
+
+		const result = await stmt.all({ limit: 1, offset: 1 });
+
+		expect(result).toStrictEqual([{ id: 2, name: 'John1' }]);
+		expect(result).toHaveLength(1);
+	});
+
+	test('select with group by as field', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.name)
+			.all();
+
+		expect(result).toStrictEqual([{ name: 'Jane' }, { name: 'John' }]);
+	});
+
+	test('select with exists', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const user = alias(usersTable, 'user');
+		const result = await db.select({ name: usersTable.name }).from(usersTable).where(
+			exists(
+				db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
+			),
+		).all();
+
+		expect(result).toStrictEqual([{ name: 'John' }]);
+	});
+
+	test('select with group by as sql', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(sql`${usersTable.name}`)
+			.all();
+
+		expect(result).toStrictEqual([{ name: 'Jane' }, { name: 'John' }]);
+	});
+
+	test('select with group by as sql + column', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(sql`${usersTable.name}`, usersTable.id)
+			.all();
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+	});
+
+	test('select with group by as column + sql', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, sql`${usersTable.name}`)
+			.all();
+
+		expect(result).toStrictEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+	});
+
+	test('select with group by complex query', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+
+		const result = await db.select({ name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, sql`${usersTable.name}`)
+			.orderBy(asc(usersTable.name))
+			.limit(1)
+			.all();
+
+		expect(result).toStrictEqual([{ name: 'Jane' }]);
+	});
+
+	test('build query', async () => {
+		const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+			.groupBy(usersTable.id, usersTable.name)
+			.toSQL();
+
+		expect(query).toStrictEqual({
+			sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+			params: [],
+		});
+	});
+
+	test('insert via db.run + select via db.all', async () => {
+		await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+		const result = await db.all<{ id: number; name: string }>(sql`select id, name from "users"`);
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert via db.get', async () => {
+		const inserted = await db.get<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${new Name(
+				usersTable.name.name,
+			)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(inserted).toStrictEqual({ id: 1, name: 'John' });
+	});
+
+	test('insert via db.run + select via db.get', async () => {
+		await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+		const result = await db.get<{ id: number; name: string }>(
+			sql`select ${usersTable.id}, ${usersTable.name} from ${usersTable}`,
+		);
+		expect(result).toStrictEqual({ id: 1, name: 'John' });
+	});
+
+	test('insert via db.get w/ query builder', async () => {
+		const inserted = await db.get<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(inserted).toStrictEqual({ id: 1, name: 'John' });
+	});
+
+	test('join subquery', async () => {
+		await db.insert(courseCategoriesTable).values([
+			{ name: 'Category 1' },
+			{ name: 'Category 2' },
+			{ name: 'Category 3' },
+			{ name: 'Category 4' },
+		]).run();
+
+		await db.insert(coursesTable).values([
+			{ name: 'Development', categoryId: 2 },
+			{ name: 'IT & Software', categoryId: 3 },
+			{ name: 'Marketing', categoryId: 4 },
+			{ name: 'Design', categoryId: 1 },
+		]).run();
+
+		const sq2 = db
+			.select({
+				categoryId: courseCategoriesTable.id,
+				category: courseCategoriesTable.name,
+				total: sql<number>`count(${courseCategoriesTable.id})`,
+			})
+			.from(courseCategoriesTable)
+			.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+			.as('sq2');
+
+		const res = await db
+			.select({
+				courseName: coursesTable.name,
+				categoryId: sq2.categoryId,
+			})
+			.from(coursesTable)
+			.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+			.orderBy(coursesTable.name)
+			.all();
+
+		expect(res).toStrictEqual([
+			{ courseName: 'Design', categoryId: 1 },
+			{ courseName: 'Development', categoryId: 2 },
+			{ courseName: 'IT & Software', categoryId: 3 },
+			{ courseName: 'Marketing', categoryId: 4 },
+		]);
+	});
+
+	test('with ... select', async () => {
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]).run();
+
+		const regionalSales = await db
+			.$with('regional_sales')
+			.as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+		const topRegions = await db
+			.$with('top_regions')
+			.as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+						),
+					),
+			);
+
+		const result = await db
+			.with(regionalSales, topRegions)
+			.select({
+				region: orders.region,
+				product: orders.product,
+				productUnits: sql<number>`cast(sum(${orders.quantity}) as int)`,
+				productSales: sql<number>`cast(sum(${orders.amount}) as int)`,
+			})
+			.from(orders)
+			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+			.groupBy(orders.region, orders.product)
+			.orderBy(orders.region, orders.product)
+			.all();
+
+		expect(result).toStrictEqual([
+			{
+				region: 'Europe',
+				product: 'A',
+				productUnits: 3,
+				productSales: 30,
+			},
+			{
+				region: 'Europe',
+				product: 'B',
+				productUnits: 5,
+				productSales: 50,
+			},
+			{
+				region: 'US',
+				product: 'A',
+				productUnits: 7,
+				productSales: 70,
+			},
+			{
+				region: 'US',
+				product: 'B',
+				productUnits: 9,
+				productSales: 90,
+			},
+		]);
+	});
+
+	test('with ... update', async () => {
+		const products = sqliteTable('products', {
+			id: integer('id').primaryKey(),
+			price: numeric('price').notNull(),
+			cheap: integer('cheap', { mode: 'boolean' }).notNull().default(false),
+		});
+
+		await db.run(sql`drop table if exists ${products}`);
+		await db.run(sql`
+			create table ${products} (
+				id integer primary key,
+				price numeric not null,
+				cheap integer not null default 0
+			)
+		`);
+
+		await db.insert(products).values([
+			{ price: '10.99' },
+			{ price: '25.85' },
+			{ price: '32.99' },
+			{ price: '2.50' },
+			{ price: '4.59' },
+		]);
+
+		const averagePrice = db
+			.$with('average_price')
+			.as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+		const result = await db
+			.with(averagePrice)
+			.update(products)
+			.set({
+				cheap: true,
+			})
+			.where(lt(products.price, sql`(select * from ${averagePrice})`))
+			.returning({
+				id: products.id,
+			});
+
+		expect(result).toStrictEqual([
+			{ id: 1 },
+			{ id: 4 },
+			{ id: 5 },
+		]);
+	});
+
+	test('with ... insert', async () => {
+		const users = sqliteTable('users', {
+			username: text('username').notNull(),
+			admin: integer('admin', { mode: 'boolean' }).notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+		await db.run(sql`create table ${users} (username text not null, admin integer not null default 0)`);
+
+		const userCount = db
+			.$with('user_count')
+			.as(
+				db
+					.select({
+						value: sql`count(*)`.as('value'),
+					})
+					.from(users),
+			);
+
+		const result = await db
+			.with(userCount)
+			.insert(users)
+			.values([
+				{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+			])
+			.returning({
+				admin: users.admin,
+			});
+
+		expect(result).toStrictEqual([{ admin: true }]);
+	});
+
+	test('with ... delete', async () => {
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]);
+
+		const averageAmount = db
+			.$with('average_amount')
+			.as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+		const result = await db
+			.with(averageAmount)
+			.delete(orders)
+			.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+			.returning({
+				id: orders.id,
+			});
+
+		expect(result).toStrictEqual([
+			{ id: 6 },
+			{ id: 7 },
+			{ id: 8 },
+		]);
+	});
+
+	test('select from subquery sql', async () => {
+		await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]).run();
+
+		const sq = db
+			.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+			.from(users2Table)
+			.as('sq');
+
+		const res = await db.select({ name: sq.name }).from(sq).all();
+
+		expect(res).toStrictEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+	});
+
+	test('select a field without joining its table', () => {
+		expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+	});
+
+	test('select all fields from subquery without alias', () => {
+		const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+		expect(() => db.select().from(sq).prepare()).toThrowError();
+	});
+
+	test('select count()', async () => {
+		await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]).run();
+
+		const res = await db.select({ count: sql`count(*)` }).from(usersTable).all();
+
+		expect(res).toStrictEqual([{ count: 2 }]);
+	});
+
+	test('having', async () => {
+		await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]).run();
+
+		await db.insert(users2Table).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 1 },
+			{ name: 'Jack', cityId: 2 },
+		]).run();
+
+		const result = await db
+			.select({
+				id: citiesTable.id,
+				name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+				usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+			})
+			.from(citiesTable)
+			.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+			.where(({ name }) => sql`length(${name}) >= 3`)
+			.groupBy(citiesTable.id)
+			.having(({ usersCount }) => sql`${usersCount} > 0`)
+			.orderBy(({ name }) => name)
+			.all();
+
+		expect(result).toStrictEqual([
+			{
+				id: 1,
+				name: 'LONDON',
+				usersCount: 2,
+			},
+			{
+				id: 2,
+				name: 'PARIS',
+				usersCount: 1,
+			},
+		]);
+	});
+
+	test('view', async () => {
+		const newYorkers1 = sqliteView('new_yorkers')
+			.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+		const newYorkers2 = sqliteView('new_yorkers', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: integer('city_id').notNull(),
+		}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+		const newYorkers3 = sqliteView('new_yorkers', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: integer('city_id').notNull(),
+		}).existing();
+
+		await db.run(sql`create view if not exists new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+		await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]).run();
+
+		await db.insert(users2Table).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 1 },
+			{ name: 'Jack', cityId: 2 },
+		]).run();
+
+		{
+			const result = await db.select().from(newYorkers1).all();
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers2).all();
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers3).all();
+			expect(result).toStrictEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).all();
+			expect(result).toStrictEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+			]);
+		}
+
+		await db.run(sql`drop view ${newYorkers1}`);
+	});
+
+	test('insert null timestamp', async () => {
+		const test = sqliteTable('test', {
+			t: integer('t', { mode: 'timestamp' }),
+		});
+
+		await db.run(sql`create table ${test} (t timestamp)`);
+
+		await db.insert(test).values({ t: null }).run();
+		const res = await db.select().from(test).all();
+		expect(res).toStrictEqual([{ t: null }]);
+
+		await db.run(sql`drop table ${test}`);
+	});
+
+	test('select from raw sql', async () => {
+		const result = await db.select({
+			id: sql<number>`id`,
+			name: sql<string>`name`,
+		}).from(sql`(select 1 as id, 'John' as name) as users`).all();
+
+		Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+		]);
+	});
+
+	test('select from raw sql with joins', async () => {
+		const result = await db
+			.select({
+				id: sql<number>`users.id`,
+				name: sql<string>`users.name`.as('userName'),
+				userCity: sql<string>`users.city`,
+				cityName: sql<string>`cities.name`.as('cityName'),
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`)
+			.all();
+
+		Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+		]);
+	});
+
+	test('join on aliased sql from select', async () => {
+		const result = await db
+			.select({
+				userId: sql<number>`users.id`.as('userId'),
+				name: sql<string>`users.name`.as('userName'),
+				userCity: sql<string>`users.city`,
+				cityId: sql<number>`cities.id`.as('cityId'),
+				cityName: sql<string>`cities.name`.as('cityName'),
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId))
+			.all();
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toStrictEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test('join on aliased sql from with clause', async () => {
+		const users = db.$with('users').as(
+			db.select({
+				id: sql<number>`id`.as('userId'),
+				name: sql<string>`name`.as('userName'),
+				city: sql<string>`city`.as('city'),
+			}).from(
+				sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+			),
+		);
+
+		const cities = db.$with('cities').as(
+			db.select({
+				id: sql<number>`id`.as('cityId'),
+				name: sql<string>`name`.as('cityName'),
+			}).from(
+				sql`(select 1 as id, 'Paris' as name) as cities`,
+			),
+		);
+
+		const result = await db
+			.with(users, cities)
+			.select({
+				userId: users.id,
+				name: users.name,
+				userCity: users.city,
+				cityId: cities.id,
+				cityName: cities.name,
+			})
+			.from(users)
+			.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId))
+			.all();
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toStrictEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test('prefixed table', async () => {
+		const sqliteTable = sqliteTableCreator((name) => `myprefix_${name}`);
+
+		const users = sqliteTable('test_prefixed_table_with_unique_name', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table myprefix_test_prefixed_table_with_unique_name (id integer not null primary key, name text not null)`,
+		);
+
+		await db.insert(users).values({ id: 1, name: 'John' }).run();
+
+		const result = await db.select().from(users).all();
+
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('orderBy with aliased column', () => {
+		const query = db.select({
+			test: sql`something`.as('test'),
+		}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+		expect(query.sql).toStrictEqual('select something as "test" from "users2" order by "test"');
+	});
+
+	test('transaction', async () => {
+		const users = sqliteTable('users_transactions', {
+			id: integer('id').primaryKey(),
+			balance: integer('balance').notNull(),
+		});
+		const products = sqliteTable('products_transactions', {
+			id: integer('id').primaryKey(),
+			price: integer('price').notNull(),
+			stock: integer('stock').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+		await db.run(sql`drop table if exists ${products}`);
+
+		await db.run(sql`create table users_transactions (id integer not null primary key, balance integer not null)`);
+		await db.run(
+			sql`create table products_transactions (id integer not null primary key, price integer not null, stock integer not null)`,
+		);
+
+		const user = await db.insert(users).values({ balance: 100 }).returning().get();
+		const product = await db.insert(products).values({ price: 10, stock: 10 }).returning().get();
+
+		await db.transaction(async (tx) => {
+			await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id)).run();
+			await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id)).run();
+		});
+
+		const result = await db.select().from(users).all();
+
+		expect(result).toStrictEqual([{ id: 1, balance: 90 }]);
+
+		await db.run(sql`drop table ${users}`);
+		await db.run(sql`drop table ${products}`);
+	});
+
+	test('transaction rollback', async () => {
+		const users = sqliteTable('users_transactions_rollback', {
+			id: integer('id').primaryKey(),
+			balance: integer('balance').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table users_transactions_rollback (id integer not null primary key, balance integer not null)`,
+		);
+		await expect((async () => {
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 }).run();
+				tx.rollback();
+			});
+		})()).rejects.toThrowError(TransactionRollbackError);
+
+		const result = await db.select().from(users).all();
+
+		expect(result).toStrictEqual([]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('nested transaction', async () => {
+		const users = sqliteTable('users_nested_transactions', {
+			id: integer('id').primaryKey(),
+			balance: integer('balance').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table users_nested_transactions (id integer not null primary key, balance integer not null)`,
+		);
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 }).run();
+
+			await tx.transaction(async (tx) => {
+				await tx.update(users).set({ balance: 200 }).run();
+			});
+		});
+
+		const result = await db.select().from(users).all();
+
+		expect(result).toStrictEqual([{ id: 1, balance: 200 }]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('nested transaction rollback', async () => {
+		const users = sqliteTable('users_nested_transactions_rollback', {
+			id: integer('id').primaryKey(),
+			balance: integer('balance').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table users_nested_transactions_rollback (id integer not null primary key, balance integer not null)`,
+		);
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 }).run();
+
+			await expect((async () => {
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 }).run();
+					tx.rollback();
+				});
+			})()).rejects.toThrowError(TransactionRollbackError);
+		});
+
+		const result = await db.select().from(users).all();
+
+		expect(result).toStrictEqual([{ id: 1, balance: 100 }]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('join subquery with join', async () => {
+		const internalStaff = sqliteTable('internal_staff', {
+			userId: integer('user_id').notNull(),
+		});
+
+		const customUser = sqliteTable('custom_user', {
+			id: integer('id').notNull(),
+		});
+
+		const ticket = sqliteTable('ticket', {
+			staffId: integer('staff_id').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${internalStaff}`);
+		await db.run(sql`drop table if exists ${customUser}`);
+		await db.run(sql`drop table if exists ${ticket}`);
+
+		await db.run(sql`create table internal_staff (user_id integer not null)`);
+		await db.run(sql`create table custom_user (id integer not null)`);
+		await db.run(sql`create table ticket (staff_id integer not null)`);
+
+		await db.insert(internalStaff).values({ userId: 1 }).run();
+		await db.insert(customUser).values({ id: 1 }).run();
+		await db.insert(ticket).values({ staffId: 1 }).run();
+
+		const subq = await db
+			.select()
+			.from(internalStaff)
+			.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+			.as('internal_staff');
+
+		const mainQuery = await db
+			.select()
+			.from(ticket)
+			.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId))
+			.all();
+
+		expect(mainQuery).toStrictEqual([{
+			ticket: { staffId: 1 },
+			internal_staff: {
+				internal_staff: { userId: 1 },
+				custom_user: { id: 1 },
+			},
+		}]);
+
+		await db.run(sql`drop table ${internalStaff}`);
+		await db.run(sql`drop table ${customUser}`);
+		await db.run(sql`drop table ${ticket}`);
+	});
+
+	test('join view as subquery', async () => {
+		const users = sqliteTable('users_join_view', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: integer('city_id').notNull(),
+		});
+
+		const newYorkers = sqliteView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		await db.run(sql`drop table if exists ${users}`);
+		await db.run(sql`drop view if exists ${newYorkers}`);
+
+		await db.run(
+			sql`create table ${users} (id integer not null primary key, name text not null, city_id integer not null)`,
+		);
+		await db.run(sql`create view if not exists ${newYorkers} as ${getViewConfig(newYorkers).query}`);
+
+		db.insert(users).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 1 },
+			{ name: 'Jill', cityId: 2 },
+		]).run();
+
+		const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+		const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id)).all();
+
+		expect(result).toStrictEqual([
+			{
+				users_join_view: { id: 1, name: 'John', cityId: 1 },
+				new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+			{
+				users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+				new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+		]);
+
+		await db.run(sql`drop view ${newYorkers}`);
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('insert with onConflict do nothing', async () => {
+		await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+		await db
+			.insert(usersTable)
+			.values({ id: 1, name: 'John' })
+			.onConflictDoNothing()
+			.run();
+
+		const res = await db
+			.select({ id: usersTable.id, name: usersTable.name })
+			.from(usersTable)
+			.where(eq(usersTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert with onConflict do nothing using composite pk', async () => {
+		await db
+			.insert(pkExampleTable)
+			.values({ id: 1, name: 'John', email: 'john@example.com' })
+			.run();
+
+		await db
+			.insert(pkExampleTable)
+			.values({ id: 1, name: 'John', email: 'john1@example.com' })
+			.onConflictDoNothing()
+			.run();
+
+		const res = await db
+			.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+			.from(pkExampleTable)
+			.where(eq(pkExampleTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john@example.com' }]);
+	});
+
+	test('insert with onConflict do nothing using target', async () => {
+		await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+		await db
+			.insert(usersTable)
+			.values({ id: 1, name: 'John' })
+			.onConflictDoNothing({ target: usersTable.id })
+			.run();
+
+		const res = await db
+			.select({ id: usersTable.id, name: usersTable.name })
+			.from(usersTable)
+			.where(eq(usersTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert with onConflict do nothing using composite pk as target', async () => {
+		await db
+			.insert(pkExampleTable)
+			.values({ id: 1, name: 'John', email: 'john@example.com' })
+			.run();
+
+		await db
+			.insert(pkExampleTable)
+			.values({ id: 1, name: 'John', email: 'john1@example.com' })
+			.onConflictDoNothing({ target: [pkExampleTable.id, pkExampleTable.name] })
+			.run();
+
+		const res = await db
+			.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+			.from(pkExampleTable)
+			.where(eq(pkExampleTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john@example.com' }]);
+	});
+
+	test('insert with onConflict do update', async () => {
+		await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+		await db
+			.insert(usersTable)
+			.values({ id: 1, name: 'John' })
+			.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+			.run();
+
+		const res = await db
+			.select({ id: usersTable.id, name: usersTable.name })
+			.from(usersTable)
+			.where(eq(usersTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John1' }]);
+	});
+
+	test('insert with onConflict do update where', async () => {
+		await db
+			.insert(usersTable)
+			.values([{ id: 1, name: 'John', verified: false }])
+			.run();
+
+		await db
+			.insert(usersTable)
+			.values({ id: 1, name: 'John1', verified: true })
+			.onConflictDoUpdate({
+				target: usersTable.id,
+				set: { name: 'John1', verified: true },
+				where: eq(usersTable.verified, false),
+			})
+			.run();
+
+		const res = await db
+			.select({ id: usersTable.id, name: usersTable.name, verified: usersTable.verified })
+			.from(usersTable)
+			.where(eq(usersTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John1', verified: true }]);
+	});
+
+	test('insert with onConflict do update using composite pk', async () => {
+		await db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john@example.com' }).run();
+
+		await db
+			.insert(pkExampleTable)
+			.values({ id: 1, name: 'John', email: 'john@example.com' })
+			.onConflictDoUpdate({ target: [pkExampleTable.id, pkExampleTable.name], set: { email: 'john1@example.com' } })
+			.run();
+
+		const res = await db
+			.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+			.from(pkExampleTable)
+			.where(eq(pkExampleTable.id, 1))
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john1@example.com' }]);
+	});
+
+	test('insert with onConflict chained (.update -> .nothing)', async () => {
+		await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]).run();
+
+		await db
+			.insert(conflictChainExampleTable)
+			.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+				id: 2,
+				name: 'Anthony',
+				email: 'idthief@example.com',
+			}])
+			.onConflictDoUpdate({
+				target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
+				set: { email: 'john1@example.com' },
+			})
+			.onConflictDoNothing({ target: conflictChainExampleTable.id })
+			.run();
+
+		const res = await db
+			.select({
+				id: conflictChainExampleTable.id,
+				name: conflictChainExampleTable.name,
+				email: conflictChainExampleTable.email,
+			})
+			.from(conflictChainExampleTable)
+			.orderBy(conflictChainExampleTable.id)
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]);
+	});
+
+	test('insert with onConflict chained (.nothing -> .update)', async () => {
+		await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]).run();
+
+		await db
+			.insert(conflictChainExampleTable)
+			.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+				id: 2,
+				name: 'Anthony',
+				email: 'idthief@example.com',
+			}])
+			.onConflictDoUpdate({
+				target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
+				set: { email: 'john1@example.com' },
+			})
+			.onConflictDoNothing({ target: conflictChainExampleTable.id })
+			.run();
+
+		const res = await db
+			.select({
+				id: conflictChainExampleTable.id,
+				name: conflictChainExampleTable.name,
+				email: conflictChainExampleTable.email,
+			})
+			.from(conflictChainExampleTable)
+			.orderBy(conflictChainExampleTable.id)
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]);
+	});
+
+	test('insert with onConflict chained (.update -> .update)', async () => {
+		await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]).run();
+
+		await db
+			.insert(conflictChainExampleTable)
+			.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+				id: 2,
+				name: 'Anthony',
+				email: 'idthief@example.com',
+			}])
+			.onConflictDoUpdate({
+				target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
+				set: { email: 'john1@example.com' },
+			})
+			.onConflictDoUpdate({ target: conflictChainExampleTable.id, set: { email: 'john2@example.com' } })
+			.run();
+
+		const res = await db
+			.select({
+				id: conflictChainExampleTable.id,
+				name: conflictChainExampleTable.name,
+				email: conflictChainExampleTable.email,
+			})
+			.from(conflictChainExampleTable)
+			.orderBy(conflictChainExampleTable.id)
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: 'john2@example.com',
+		}]);
+	});
+
+	test('insert with onConflict chained (.nothing -> .nothing)', async () => {
+		await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]).run();
+
+		await db
+			.insert(conflictChainExampleTable)
+			.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
+				id: 2,
+				name: 'Anthony',
+				email: 'idthief@example.com',
+			}])
+			.onConflictDoNothing({
+				target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
+			})
+			.onConflictDoNothing({ target: conflictChainExampleTable.id })
+			.run();
+
+		const res = await db
+			.select({
+				id: conflictChainExampleTable.id,
+				name: conflictChainExampleTable.name,
+				email: conflictChainExampleTable.email,
+			})
+			.from(conflictChainExampleTable)
+			.orderBy(conflictChainExampleTable.id)
+			.all();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John', email: 'john@example.com' }, {
+			id: 2,
+			name: 'John Second',
+			email: '2john@example.com',
+		}]);
+	});
+
+	test('insert undefined', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		await expect((async () => {
+			await db.insert(users).values({ name: undefined }).run();
+		})()).resolves.toStrictEqual(undefined);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('update undefined', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await db.run(sql`drop table if exists ${users}`);
+
+		await db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		await expect((async () => {
+			await db.update(users).set({ name: undefined }).run();
+		})()).rejects.toThrowError();
+		await expect((async () => {
+			await db.update(users).set({ id: 1, name: undefined }).run();
+		})()).resolves.toStrictEqual(undefined);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('async api - CRUD', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		db.run(sql`drop table if exists ${users}`);
+
+		db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		await db.insert(users).values({ id: 1, name: 'John' });
+
+		const res = await db.select().from(users);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		await db.update(users).set({ name: 'John1' }).where(eq(users.id, 1));
+
+		const res1 = await db.select().from(users);
+
+		expect(res1).toStrictEqual([{ id: 1, name: 'John1' }]);
+
+		await db.delete(users).where(eq(users.id, 1));
+
+		const res2 = await db.select().from(users);
+
+		expect(res2).toStrictEqual([]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('async api - insert + select w/ prepare + async execute', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		db.run(sql`drop table if exists ${users}`);
+
+		db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
+		await insertStmt.execute();
+
+		const selectStmt = db.select().from(users).prepare();
+		const res = await selectStmt.execute();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
+		await updateStmt.execute();
+
+		const res1 = await selectStmt.execute();
+
+		expect(res1).toStrictEqual([{ id: 1, name: 'John1' }]);
+
+		const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+		await deleteStmt.execute();
+
+		const res2 = await selectStmt.execute();
+
+		expect(res2).toStrictEqual([]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('async api - insert + select w/ prepare + sync execute', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		db.run(sql`drop table if exists ${users}`);
+
+		db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
+		await insertStmt.execute();
+
+		const selectStmt = db.select().from(users).prepare();
+		const res = await selectStmt.execute();
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+
+		const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
+		await updateStmt.execute();
+
+		const res1 = await selectStmt.execute();
+
+		expect(res1).toStrictEqual([{ id: 1, name: 'John1' }]);
+
+		const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+		await deleteStmt.execute();
+
+		const res2 = await selectStmt.execute();
+
+		expect(res2).toStrictEqual([]);
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('select + .get() for empty result', async () => {
+		const users = sqliteTable('users', {
+			id: integer('id').primaryKey(),
+			name: text('name'),
+		});
+
+		db.run(sql`drop table if exists ${users}`);
+
+		db.run(
+			sql`create table ${users} (id integer primary key, name text)`,
+		);
+
+		const res = await db.select().from(users).where(eq(users.id, 1)).get();
+
+		expect(res).toBeUndefined();
+
+		await db.run(sql`drop table ${users}`);
+	});
+
+	test('set operations (union) from query builder with subquery', async () => {
+		await setupSetOperationTest(db);
+
+		const sq = db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table),
+			).orderBy(asc(sql`name`)).as('sq');
+
+		const result = await db.select().from(sq).limit(5).offset(5);
+
+		expect(result).toHaveLength(5);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 7, name: 'Mary' },
+			{ id: 1, name: 'New York' },
+			{ id: 4, name: 'Peter' },
+			{ id: 8, name: 'Sally' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable).union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table),
+				).orderBy(asc(sql`name`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await union(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`name`));
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John' },
+			{ id: 1, name: 'New York' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).orderBy(asc(sql`name`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union all) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).unionAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable),
+			).orderBy(asc(citiesTable.id)).limit(5).offset(1);
+
+		expect(result).toHaveLength(5);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).unionAll(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable),
+				).orderBy(asc(citiesTable.id)).limit(5).offset(1);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union all) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+
+		expect(result).toHaveLength(3);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 1, name: 'John' },
+			{ id: 1, name: 'John' },
+		]);
+
+		await expect((async () => {
+			unionAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`name`));
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable).intersect(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+				).orderBy(asc(sql`name`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (intersect) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+
+		expect(result).toHaveLength(0);
+
+		expect(result).toStrictEqual([]);
+
+		await expect((async () => {
+			intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (except) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select()
+			.from(citiesTable).except(
+				db
+					.select()
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+
+		expect(result).toHaveLength(1);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(citiesTable).except(
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (except) as function', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await except(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable),
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`id`));
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			except(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable),
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+			).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (mixed) from query builder', async () => {
+		await setupSetOperationTest(db);
+
+		const result = await db
+			.select()
+			.from(citiesTable).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select()
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+						db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+					),
+			);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(citiesTable).except(
+					({ unionAll }) =>
+						unionAll(
+							db
+								.select()
+								.from(citiesTable).where(gt(citiesTable.id, 1)),
+							db.select({ name: citiesTable.name, id: citiesTable.id })
+								.from(citiesTable).where(eq(citiesTable.id, 2)),
+						),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (mixed all) as function with subquery', async () => {
+		await setupSetOperationTest(db);
+
+		const sq = union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			except(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(gte(users2Table.id, 5)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 7)),
+			),
+			db
+				.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+		).orderBy(asc(sql`id`)).as('sq');
+
+		const result = await db.select().from(sq).limit(4).offset(1);
+
+		expect(result).toHaveLength(4);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+			{ id: 5, name: 'Ben' },
+			{ id: 6, name: 'Jill' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 1)),
+				except(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(gte(users2Table.id, 5)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 7)),
+				),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test('define constraints as array', async (_ctx) => {
+		const table = sqliteTable('name', {
+			id: int(),
+		}, (t) => [
+			index('name').on(t.id),
+			primaryKey({ columns: [t.id], name: 'custom' }),
+		]);
+
+		const { indexes, primaryKeys } = getTableConfig(table);
+
+		expect(indexes.length).toStrictEqual(1);
+		expect(primaryKeys.length).toStrictEqual(1);
+	});
+
+	test('define constraints as array inside third param', async (_ctx) => {
+		const table = sqliteTable('name', {
+			id: int(),
+		}, (t) => [
+			index('name').on(t.id),
+			primaryKey({ columns: [t.id], name: 'custom' }),
+		]);
+
+		const { indexes, primaryKeys } = getTableConfig(table);
+
+		expect(indexes.length).toStrictEqual(1);
+		expect(primaryKeys.length).toStrictEqual(1);
+	});
+
+	test('aggregate function: count', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: count() }).from(table);
+		const result2 = await db.select({ value: count(table.a) }).from(table);
+		const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(7);
+		expect(result2[0]?.value).toStrictEqual(5);
+		expect(result3[0]?.value).toStrictEqual(6);
+	});
+
+	test('aggregate function: avg', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: avg(table.a) }).from(table);
+		const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
+		const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual('24');
+		expect(result2[0]?.value).toBeNull();
+		expect(result3[0]?.value).toStrictEqual('42.5');
+	});
+
+	test('aggregate function: sum', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: sum(table.b) }).from(table);
+		const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
+		const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual('200');
+		expect(result2[0]?.value).toBeNull();
+		expect(result3[0]?.value).toStrictEqual('170');
+	});
+
+	test('aggregate function: max', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: max(table.b) }).from(table);
+		const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(90);
+		expect(result2[0]?.value).toBeNull();
+	});
+
+	test('aggregate function: min', async () => {
+		const table = aggregateTable;
+		await setupAggregateFunctionsTest(db);
+
+		const result1 = await db.select({ value: min(table.b) }).from(table);
+		const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
+
+		expect(result1[0]?.value).toStrictEqual(10);
+		expect(result2[0]?.value).toBeNull();
+	});
+
+	test('test $onUpdateFn and $onUpdate works as $default', async () => {
+		await db.run(sql`drop table if exists ${usersOnUpdate}`);
+
+		await db.run(
+			sql`
+				create table ${usersOnUpdate} (
+				id integer primary key autoincrement,
+				name text not null,
+				update_counter integer default 1 not null,
+				updated_at integer,
+				always_null text
+				)
+			`,
+		);
+
+		await db.insert(usersOnUpdate).values([
+			{ name: 'John' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+		const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+		const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+		const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+		expect(response).toStrictEqual([
+			{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+			{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+			{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+			{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+		]);
+		const msDelay = 250;
+
+		for (const eachUser of justDates) {
+			expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+		}
+	});
+
+	test('test $onUpdateFn and $onUpdate works updating', async () => {
+		await db.run(sql`drop table if exists ${usersOnUpdate}`);
+
+		await db.run(
+			sql`
+				create table ${usersOnUpdate} (
+				id integer primary key autoincrement,
+				name text not null,
+				update_counter integer default 1,
+				updated_at integer,
+				always_null text
+				)
+			`,
+		);
+
+		await db.insert(usersOnUpdate).values([
+			{ name: 'John', alwaysNull: 'this will be null after updating' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+		const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+		await db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id, 1));
+		await db.update(usersOnUpdate).set({ updateCounter: null }).where(eq(usersOnUpdate.id, 2));
+
+		const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+		const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+		expect(response).toStrictEqual([
+			{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+			{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
+			{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+			{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+		]);
+		const msDelay = 250;
+
+		for (const eachUser of justDates) {
+			expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+		}
+	});
+
+	test('$count separate', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable);
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual(4);
+	});
+
+	test('$count embedded', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+	});
+
+	test('$count separate reuse', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.$count(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count1).toStrictEqual(4);
+		expect(count2).toStrictEqual(5);
+		expect(count3).toStrictEqual(6);
+	});
+
+	test('$count embedded reuse', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count1).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+		expect(count2).toStrictEqual([
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+		]);
+		expect(count3).toStrictEqual([
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+		]);
+	});
+
+	test('$count separate with filters', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual(3);
+	});
+
+	test('$count embedded with filters', async () => {
+		const countTestTable = sqliteTable('count_test', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+
+		await db.run(sql`drop table if exists ${countTestTable}`);
+		await db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+		}).from(countTestTable);
+
+		await db.run(sql`drop table ${countTestTable}`);
+
+		expect(count).toStrictEqual([
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+		]);
+	});
+
+	test('update with limit and order by', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db.update(usersTable).set({ verified: true }).limit(2).orderBy(asc(usersTable.name));
+
+		const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
+			asc(usersTable.name),
+		);
+
+		expect(result).toStrictEqual([
+			{ name: 'Alan', verified: true },
+			{ name: 'Barry', verified: true },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test('delete with limit and order by', async () => {
+		await db.insert(usersTable).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db.delete(usersTable).where(eq(usersTable.verified, false)).limit(1).orderBy(asc(usersTable.name));
+
+		const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
+			asc(usersTable.name),
+		);
+		expect(result).toStrictEqual([
+			{ name: 'Barry', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test('cross join', async () => {
+		await db
+			.insert(usersTable)
+			.values([
+				{ name: 'John' },
+				{ name: 'Jane' },
+			]);
+
+		await db
+			.insert(citiesTable)
+			.values([
+				{ name: 'Seattle' },
+				{ name: 'New York City' },
+			]);
+
+		const result = await db
+			.select({
+				user: usersTable.name,
+				city: citiesTable.name,
+			})
+			.from(usersTable)
+			.crossJoin(citiesTable)
+			.orderBy(usersTable.name, citiesTable.name);
+
+		expect(result).toStrictEqual([
+			{ city: 'New York City', user: 'Jane' },
+			{ city: 'Seattle', user: 'Jane' },
+			{ city: 'New York City', user: 'John' },
+			{ city: 'Seattle', user: 'John' },
+		]);
+	});
+
+	test('RQB v2 simple find first - no rows', async () => {
+		const result = await db.query.rqbUser.findFirst();
+
+		expect(result).toStrictEqual(undefined);
+	});
+
+	test('RQB v2 simple find first - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+
+	test('RQB v2 simple find first - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 1,
+			createdAt: date,
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}],
+		});
+	});
+
+	test('RQB v2 simple find first - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+
+	test('RQB v2 simple find many - no rows', async () => {
+		const result = await db.query.rqbUser.findMany();
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test('RQB v2 simple find many - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}]);
+	});
+
+	test('RQB v2 simple find many - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}]);
+	});
+
+	test('RQB v2 simple find many - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+	});
+
+	test('RQB v2 transaction find first - no rows', async () => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst();
+
+			expect(result).toStrictEqual(undefined);
+		});
+	});
+
+	test('RQB v2 transaction find first - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find many - no rows', async () => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+	});
+
+	test('RQB v2 transaction find many - multiple rows', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - with relation', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - placeholders', async () => {
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+	});
+
+	test('limit 0', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db
+			.select()
+			.from(usersTable)
+			.limit(0);
+
+		expect(users).toStrictEqual([]);
+	});
+
+	test('limit -1', async () => {
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db
+			.select()
+			.from(usersTable)
+			.limit(-1);
+
+		expect(users.length).toBeGreaterThan(0);
+	});
+
+	test('all types', async () => {
+		await db.run(sql`
+			CREATE TABLE \`all_types\`(
+				\`int\` integer,
+				\`bool\` integer,
+				\`time\` integer,
+				\`time_ms\` integer,
+				\`bigint\` blob,
+				\`buffer\` blob,
+				\`json\` blob,
+				\`numeric\` numeric,
+				\`numeric_num\` numeric,
+				\`numeric_big\` numeric,
+				\`real\` real,
+				\`text\` text,
+				\`json_text\` text
+				);
+		`);
+
+		await db.insert(allTypesTable).values({
+			int: 1,
+			bool: true,
+			bigint: 5044565289845416380n,
+			buffer: Buffer.from([
+				0x44,
+				0x65,
+				0x73,
+				0x70,
+				0x61,
+				0x69,
+				0x72,
+				0x20,
+				0x6F,
+				0x20,
+				0x64,
+				0x65,
+				0x73,
+				0x70,
+				0x61,
+				0x69,
+				0x72,
+				0x2E,
+				0x2E,
+				0x2E,
+			]),
+			json: {
+				str: 'strval',
+				arr: ['str', 10],
+			},
+			jsonText: {
+				str: 'strvalb',
+				arr: ['strb', 11],
+			},
+			numeric: '475452353476',
+			numericNum: 9007199254740991,
+			numericBig: 5044565289845416380n,
+			real: 1.048596,
+			text: 'TEXT STRING',
+			time: new Date(1741743161623),
+			timeMs: new Date(1741743161623),
+		});
+
+		const rawRes = await db.select().from(allTypesTable);
+
+		expect(typeof rawRes[0]?.numericBig).toStrictEqual('bigint');
+
+		type ExpectedType = {
+			int: number | null;
+			bool: boolean | null;
+			time: Date | null;
+			timeMs: Date | null;
+			bigint: bigint | null;
+			buffer: Buffer | null;
+			json: unknown;
+			numeric: string | null;
+			numericNum: number | null;
+			numericBig: bigint | null;
+			real: number | null;
+			text: string | null;
+			jsonText: unknown;
+		}[];
+
+		const expectedRes: ExpectedType = [
+			{
+				int: 1,
+				bool: true,
+				time: new Date('2025-03-12T01:32:41.000Z'),
+				timeMs: new Date('2025-03-12T01:32:41.623Z'),
+				bigint: 5044565289845416380n,
+				buffer: Buffer.from([
+					0x44,
+					0x65,
+					0x73,
+					0x70,
+					0x61,
+					0x69,
+					0x72,
+					0x20,
+					0x6F,
+					0x20,
+					0x64,
+					0x65,
+					0x73,
+					0x70,
+					0x61,
+					0x69,
+					0x72,
+					0x2E,
+					0x2E,
+					0x2E,
+				]),
+				json: { str: 'strval', arr: ['str', 10] },
+				numeric: '475452353476',
+				numericNum: 9007199254740991,
+				numericBig: 5044565289845416380n,
+				real: 1.048596,
+				text: 'TEXT STRING',
+				jsonText: { str: 'strvalb', arr: ['strb', 11] },
+			},
+		];
+
+		expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+		expect(rawRes).toStrictEqual(expectedRes);
+	});
+});
+
+test('table configs: unique third param', () => {
+	const cities1Table = sqliteTable('cities1', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: unique().on(t.name, t.state),
+		f1: unique('custom').on(t.name, t.state),
+	}));
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+	expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toStrictEqual(['name', 'state']);
+	expect(
+		tableConfig.uniqueConstraints[0]?.name,
+	).toStrictEqual(
+		uniqueKeyName(cities1Table, tableConfig.uniqueConstraints[0]?.columns?.map((column) => column.name) ?? []),
+	);
+
+	expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toStrictEqual(['name', 'state']);
+	expect(tableConfig.uniqueConstraints[1]?.name).toStrictEqual('custom');
+});
+
+test('table configs: unique in column', () => {
+	const cities1Table = sqliteTable('cities1', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull().unique(),
+		state: text('state').unique('custom'),
+		field: text('field').unique(),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+	expect(columnName?.isUnique).toBeTruthy();
+	expect(columnName?.uniqueName).toStrictEqual(undefined);
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	expect(columnState?.isUnique).toBeTruthy();
+	expect(columnState?.uniqueName).toStrictEqual('custom');
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	expect(columnField?.isUnique).toBeTruthy();
+	expect(columnField?.uniqueName).toStrictEqual(undefined);
+});
+
+test('update ... from', async () => {
+	await db.run(sql`drop table if exists \`cities\``);
+	await db.run(sql`drop table if exists \`users2\``);
+	await db.run(sql`
+		create table \`cities\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null
+		)
+	`);
+	await db.run(sql`
+		create table \`users2\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null,
+			\`city_id\` integer references \`cities\`(\`id\`)
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ name: 'New York City' },
+		{ name: 'Seattle' },
+	]);
+	await db.insert(users2Table).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+	]);
+
+	const result = await db
+		.update(users2Table)
+		.set({
+			cityId: citiesTable.id,
+		})
+		.from(citiesTable)
+		.where(and(eq(citiesTable.name, 'Seattle'), eq(users2Table.name, 'John')))
+		.returning();
+
+	expect(result).toStrictEqual([{
+		id: 1,
+		name: 'John',
+		cityId: 2,
+	}]);
+});
+
+test('update ... from with alias', async () => {
+	await db.run(sql`drop table if exists \`users2\``);
+	await db.run(sql`drop table if exists \`cities\``);
+	await db.run(sql`
+		create table \`cities\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null
+		)
+	`);
+	await db.run(sql`
+		create table \`users2\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null,
+			\`city_id\` integer references \`cities\`(\`id\`)
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ name: 'New York City' },
+		{ name: 'Seattle' },
+	]);
+	await db.insert(users2Table).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+	]);
+
+	const cities = alias(citiesTable, 'c');
+	const result = await db
+		.update(users2Table)
+		.set({
+			cityId: cities.id,
+		})
+		.from(cities)
+		.where(and(eq(cities.name, 'Seattle'), eq(users2Table.name, 'John')))
+		.returning();
+
+	expect(result).toStrictEqual([{
+		id: 1,
+		name: 'John',
+		cityId: 2,
+	}]);
+
+	await db.run(sql`drop table if exists \`users2\``);
+});
+
+test('update ... from with join', async () => {
+	const states = sqliteTable('states', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+	const cities = sqliteTable('cities', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+		stateId: integer('state_id').references(() => states.id),
+	});
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull().references(() => cities.id),
+	});
+
+	await db.run(sql`drop table if exists \`states\``);
+	await db.run(sql`drop table if exists \`cities\``);
+	await db.run(sql`drop table if exists \`users\``);
+	await db.run(sql`
+		create table \`states\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null
+		)
+	`);
+	await db.run(sql`
+		create table \`cities\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null,
+			\`state_id\` integer references \`states\`(\`id\`)
+		)
+	`);
+	await db.run(sql`
+		create table \`users\` (
+			\`id\` integer primary key autoincrement,
+			\`name\` text not null,
+			\`city_id\` integer not null references \`cities\`(\`id\`)
+		)
+	`);
+
+	await db.insert(states).values([
+		{ name: 'New York' },
+		{ name: 'Washington' },
+	]);
+	await db.insert(cities).values([
+		{ name: 'New York City', stateId: 1 },
+		{ name: 'Seattle', stateId: 2 },
+		{ name: 'London' },
+	]);
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 3 },
+	]);
+
+	const result1 = await db
+		.update(users)
+		.set({
+			cityId: cities.id,
+		})
+		.from(cities)
+		.leftJoin(states, eq(cities.stateId, states.id))
+		.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+		.returning();
+	const result2 = await db
+		.update(users)
+		.set({
+			cityId: cities.id,
+		})
+		.from(cities)
+		.leftJoin(states, eq(cities.stateId, states.id))
+		.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+		.returning();
+
+	expect(result1).toStrictEqual([{
+		id: 1,
+		name: 'John',
+		cityId: 2,
+	}]);
+	expect(result2).toStrictEqual([{
+		id: 3,
+		name: 'Jack',
+		cityId: 3,
+	}]);
+});
+
+test('insert into ... select', async () => {
+	const notifications = sqliteTable('notifications_insert_into', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		sentAt: integer('sent_at', { mode: 'timestamp' }).notNull().default(sql`current_timestamp`),
+		message: text('message').notNull(),
+	});
+	const users = sqliteTable('users_insert_into', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+	const userNotications = sqliteTable('user_notifications_insert_into', {
+		userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+		notificationId: integer('notification_id').notNull().references(() => notifications.id, { onDelete: 'cascade' }),
+	}, (t) => ({
+		pk: primaryKey({ columns: [t.userId, t.notificationId] }),
+	}));
+
+	await db.run(sql`drop table if exists notifications_insert_into`);
+	await db.run(sql`drop table if exists users_insert_into`);
+	await db.run(sql`drop table if exists user_notifications_insert_into`);
+	await db.run(sql`
+		create table notifications_insert_into (
+			id integer primary key autoincrement,
+			sent_at integer not null default (current_timestamp),
+			message text not null
+		)
+	`);
+	await db.run(sql`
+		create table users_insert_into (
+			id integer primary key autoincrement,
+			name text not null
+		)
+	`);
+	await db.run(sql`
+		create table user_notifications_insert_into (
+			user_id integer references users_insert_into(id) on delete cascade,
+			notification_id integer references notifications_insert_into(id) on delete cascade,
+			primary key (user_id, notification_id)
+		)
+	`);
+
+	const newNotification = await db
+		.insert(notifications)
+		.values({ message: 'You are one of the 3 lucky winners!' })
+		.returning({ id: notifications.id })
+		.then((result) => result[0]);
+	await db.insert(users).values([
+		{ name: 'Alice' },
+		{ name: 'Bob' },
+		{ name: 'Charlie' },
+		{ name: 'David' },
+		{ name: 'Eve' },
+	]);
+
+	const sentNotifications = await db
+		.insert(userNotications)
+		.select(
+			db
+				.select({
+					userId: users.id,
+					notificationId: sql`${newNotification!.id}`.as('notification_id'),
+				})
+				.from(users)
+				.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+				.orderBy(asc(users.id)),
+		)
+		.returning();
+
+	expect(sentNotifications).toStrictEqual([
+		{ userId: 1, notificationId: newNotification!.id },
+		{ userId: 3, notificationId: newNotification!.id },
+		{ userId: 5, notificationId: newNotification!.id },
+	]);
+});
+
+test('insert into ... select with keys in different order', async () => {
+	const users1 = sqliteTable('users1', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+	const users2 = sqliteTable('users2', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+
+	await db.run(sql`drop table if exists users1`);
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`
+		create table users1 (
+			id integer primary key autoincrement,
+			name text not null
+		)
+	`);
+	await db.run(sql`
+		create table users2 (
+			id integer primary key autoincrement,
+			name text not null
+		)
+	`);
+
+	await expect((async () => {
+		db
+			.insert(users1)
+			.select(
+				db
+					.select({
+						name: users2.name,
+						id: users2.id,
+					})
+					.from(users2),
+			);
+	})()).rejects.toThrowError();
+});
+
+test('Object keys as column names', async () => {
+	// Tests the following:
+	// Column with optional config without providing a value
+	// Column with optional config providing a value
+	// Column without config
+	const users = sqliteTable('users', {
+		id: integer().primaryKey({ autoIncrement: true }),
+		createdAt: integer({ mode: 'timestamp' }),
+		name: text(),
+	});
+
+	await db.run(sql`drop table if exists users`);
+	await db.run(
+		sql`
+			create table users (
+				\`id\` integer primary key autoincrement,
+				\`createdAt\` integer,
+				\`name\` text
+			)
+		`,
+	);
+
+	await db.insert(users).values([
+		{ createdAt: new Date(Date.now() - 2592000000), name: 'John' },
+		{ createdAt: new Date(Date.now() - 86400000), name: 'Jane' },
+	]);
+	const result = await db
+		.select({ id: users.id, name: users.name })
+		.from(users)
+		.where(gt(users.createdAt, new Date(Date.now() - 2592000000)));
+
+	expect(result).toStrictEqual([
+		{ id: 2, name: 'Jane' },
+	]);
+
+	await db.run(sql`drop table users`);
+});
+
+test('sql operator as cte', async () => {
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`create table ${users} (id integer not null primary key autoincrement, name text not null)`);
+	await db.insert(users).values([
+		{ name: 'John' },
+		{ name: 'Jane' },
+	]);
+
+	const sq1 = db.$with('sq', {
+		userId: users.id,
+		data: {
+			name: users.name,
+		},
+	}).as(sql`select * from ${users} where ${users.name} = 'John'`);
+	const result1 = await db.with(sq1).select().from(sq1);
+
+	const sq2 = db.$with('sq', {
+		userId: users.id,
+		data: {
+			name: users.name,
+		},
+	}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+	const result2 = await db.with(sq2).select().from(sq1);
+
+	expect(result1).toStrictEqual([{ userId: 1, data: { name: 'John' } }]);
+	expect(result2).toStrictEqual([{ userId: 2, data: { name: 'Jane' } }]);
+});
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class TestGlobalCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy(): 'explicit' | 'all' {
+		return 'all';
+	}
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends TestGlobalCache {
+	override strategy(): 'explicit' | 'all' {
+		return 'explicit';
+	}
+}
+const usersTableCache = sqliteTable('users', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	name: text('name').notNull(),
+	verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+	jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+	createdAt: integer('created_at', { mode: 'timestamp' }),
+});
+
+const postsTableCache = sqliteTable('posts', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	description: text().notNull(),
+	userId: integer('user_id').references(() => usersTableCache.id),
+});
+
+describe('common_cache', () => {
+	beforeEach(async () => {
+		const db = cachedDb;
+		await db.run(sql`drop table if exists users`);
+		await db.run(sql`drop table if exists posts`);
+		await db.$cache?.invalidate({ tables: 'users' });
+		await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
+		// public users
+		await db.run(
+			sql`
+				create table users (
+					id integer primary key AUTOINCREMENT,
+					name text not null,
+					verified integer not null default 0,
+					jsonb text,
+					created_at integer
+				)
+			`,
+		);
+		await db.run(
+			sql`
+				create table posts (
+					id integer primary key AUTOINCREMENT,
+					description text not null,
+					user_id int
+				)
+			`,
+		);
+	});
+
+	test('test force invalidate', async () => {
+		const db = cachedDb;
+
+		const spyInvalidate = spyOn(db.$cache, 'invalidate');
+		await db.$cache?.invalidate({ tables: 'users' });
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('default global config - no cache should be hit', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('default global config + enable cache on select: get, put', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache();
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('default global config + enable cache on select + write: get, put, onMutate', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ config: { ex: 1 } });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		spyPut.mockClear();
+		spyGet.mockClear();
+		spyInvalidate.mockClear();
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('default global config + enable cache on select + disable invalidate: get, put', async () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		// invalidate force
+		await db.$cache?.invalidate({ tags: ['custom'] });
+	});
+
+	test('global: true + disable cache', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache(false);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - cache should be hit', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache);
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - cache: false on select - no cache hit', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache(false);
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+	});
+
+	test('global: true - disable invalidate - cache hit + no invalidate', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ autoInvalidate: false });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		spyPut.mockClear();
+		spyGet.mockClear();
+		spyInvalidate.mockClear();
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		expect(spyPut).toHaveBeenCalledTimes(0);
+		expect(spyGet).toHaveBeenCalledTimes(0);
+		expect(spyInvalidate).toHaveBeenCalledTimes(1);
+	});
+
+	test('global: true - with custom tag', async () => {
+		const db = dbGlobalCached;
+
+		// @ts-expect-error
+		const spyPut = spyOn(db.$cache, 'put');
+		// @ts-expect-error
+		const spyGet = spyOn(db.$cache, 'get');
+		// @ts-expect-error
+		const spyInvalidate = spyOn(db.$cache, 'onMutate');
+
+		spyPut.mockReset();
+		spyGet.mockReset();
+		spyInvalidate.mockReset();
+
+		await db.select().from(usersTableCache).$withCache({ tag: 'custom', autoInvalidate: false });
+
+		expect(spyPut).toHaveBeenCalledTimes(1);
+		expect(spyGet).toHaveBeenCalledTimes(1);
+		expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+		await db.insert(usersTableCache).values({ name: 'John' });
+
+		// invalidate force
+		await db.$cache?.invalidate({ tags: ['custom'] });
+	});
+
+	// check select used tables
+	test('check simple select used tables', () => {
+		const db = cachedDb;
+
+		// @ts-expect-error
+		expect(db.select().from(usersTableCache).getUsedTables()).toStrictEqual(['users']);
+		// @ts-expect-error
+		expect(db.select().from(sql`${usersTableCache}`).getUsedTables()).toStrictEqual(['users']);
+	});
+	// check select+join used tables
+	test('select+join', () => {
+		const db = cachedDb;
+
+		expect(
+			db.select().from(usersTableCache).leftJoin(postsTableCache, eq(usersTableCache.id, postsTableCache.userId))
+				// @ts-expect-error
+				.getUsedTables(),
+		)
+			.toStrictEqual(['users', 'posts']);
+		expect(
+			db.select().from(sql`${usersTableCache}`).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+				// @ts-expect-error
+			).getUsedTables(),
+		).toStrictEqual(['users', 'posts']);
+	});
+	// check select+2join used tables
+	test('select+2joins', () => {
+		const db = cachedDb;
+
+		expect(
+			db.select().from(usersTableCache).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+			).leftJoin(
+				alias(postsTableCache, 'post2'),
+				eq(usersTableCache.id, postsTableCache.userId),
+			)
+				// @ts-expect-error
+				.getUsedTables(),
+		)
+			.toStrictEqual(['users', 'posts']);
+		expect(
+			db.select().from(sql`${usersTableCache}`).leftJoin(
+				postsTableCache,
+				eq(usersTableCache.id, postsTableCache.userId),
+			).leftJoin(
+				alias(postsTableCache, 'post2'),
+				eq(usersTableCache.id, postsTableCache.userId),
+				// @ts-expect-error
+			).getUsedTables(),
+		).toStrictEqual(['users', 'posts']);
+	});
+	// select subquery used tables
+	test('select+join', () => {
+		const db = cachedDb;
+
+		const sq = db.select().from(usersTableCache).where(eq(usersTableCache.id, 42)).as('sq');
+
+		// @ts-expect-error
+		expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
+	});
+});
diff --git a/integration-tests/tests/bun/effect-sqlite-bun.test.ts b/integration-tests/tests/bun/effect-sqlite-bun.test.ts
new file mode 100644
index 0000000000..e2891a7b33
--- /dev/null
+++ b/integration-tests/tests/bun/effect-sqlite-bun.test.ts
@@ -0,0 +1,260 @@
+/// <reference types="bun-types" />
+
+import { SqliteClient } from '@effect/sql-sqlite-bun';
+import { expect } from 'bun:test';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite-bun';
+import { migrate } from 'drizzle-orm/effect-sqlite-bun/migrator';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { strict as assert } from 'node:assert';
+import relations from '../sqlite/relations';
+import { anotherUsersMigratorTable, usersMigratorTable } from '../sqlite/sqlite-common';
+import { DB, runCommonEffectSQLiteTests } from './effect-sqlite-common';
+
+const SQLiteClientLive = SqliteClient.layer({
+	filename: ':memory:',
+});
+
+const dbEffect = SQLiteDrizzle.make({ relations }).pipe(Effect.provide(SQLiteDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	SQLiteDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(SQLiteDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(SQLiteClientLive, DBLive.pipe(Layer.provide(SQLiteClientLive)));
+
+runCommonEffectSQLiteTests({
+	testLayer: TestLive,
+	SQLiteDrizzle: SQLiteDrizzle,
+	createDB,
+	skipTests: Date.now() < +new Date('2026-07-01')
+		? ['migrator : local migration is unapplied. Migrations timestamp is less than last db migration']
+		: [],
+	addTests: (it) => {
+		it.effect('migrator', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* db.run(sql`drop table if exists another_users`);
+				yield* db.run(sql`drop table if exists users12`);
+				yield* db.run(sql`drop table if exists __drizzle_migrations`);
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result = yield* db.select().from(usersMigratorTable).all();
+
+				yield* db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result2 = yield* db.select().from(anotherUsersMigratorTable).all();
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.run(sql`drop table another_users`);
+				yield* db.run(sql`drop table users12`);
+				yield* db.run(sql`drop table __drizzle_migrations`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(0);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(true);
+			}));
+
+		// Driver bug - misplaced trycatch throws an error past the effect
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const users = sqliteTable('migration_users', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				const users2 = sqliteTable('migration_users2', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				yield* db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+				yield* db.run(sql`drop table if exists ${users}`);
+				yield* db.run(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/sql-js';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrationsFolder: migrationDir });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrationsFolder: migrationDir });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+	},
+});
diff --git a/integration-tests/tests/bun/effect-sqlite-common.ts b/integration-tests/tests/bun/effect-sqlite-common.ts
new file mode 100644
index 0000000000..296e576b36
--- /dev/null
+++ b/integration-tests/tests/bun/effect-sqlite-common.ts
@@ -0,0 +1,3890 @@
+/// <reference types="bun-types" />
+
+import { afterAll, beforeAll, describe, expect, expectTypeOf, test } from 'bun:test';
+import { assert } from 'chai';
+import {
+	and,
+	asc,
+	eq,
+	gt,
+	gte,
+	inArray,
+	is,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	SQL,
+	sql,
+} from 'drizzle-orm';
+import { EffectCache, type EffectCacheShape } from 'drizzle-orm/cache/core/cache-effect';
+import { EffectLogger, type EffectLoggerShape, QueryEffectHKTBase } from 'drizzle-orm/effect-core';
+import {
+	EmptyRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+} from 'drizzle-orm/relations';
+import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
+import {
+	alias,
+	blob,
+	except,
+	getTableConfig,
+	getViewConfig,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	SQLiteDialect,
+	SQLiteTable,
+	sqliteTable,
+	SQLiteView,
+	text,
+	union,
+} from 'drizzle-orm/sqlite-core';
+import type { SQLiteEffectDatabase } from 'drizzle-orm/sqlite-core/effect/db';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Ref from 'effect/Ref';
+import * as Result from 'effect/Result';
+import * as Scope from 'effect/Scope';
+import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlError } from 'effect/unstable/sql/SqlError';
+import relations from '../sqlite/relations';
+import { rqbPost, rqbUser } from '../sqlite/schema';
+
+export class DB
+	extends Context.Service<DB, SQLiteEffectDatabase<any, any, typeof relations>>()('CommonEffectSQLiteDB')
+{}
+
+/**
+ * Minimal replica of drizzle-kit's `diff`, just enough for `push` to create and
+ * drop `SQLiteTable`s and `SQLiteView`s. drizzle-kit's mocks can't be imported
+ * under `bun test` (its `drizzle-orm` dependency fails to resolve), so we render
+ * the DDL directly from the drizzle table/view metadata instead.
+ */
+const dialect = new SQLiteDialect();
+const sqlToString = (chunk: SQL) => dialect.sqlToQuery(chunk.inlineParams()).sql;
+const { escapeName } = dialect;
+
+const buildColumn = (column: AnySQLiteColumn): string => {
+	const parts = [escapeName(column.name), column.getSQLType()];
+
+	if (column.primary) {
+		parts.push('PRIMARY KEY');
+		if ((column as { autoIncrement?: boolean }).autoIncrement) parts.push('AUTOINCREMENT');
+	}
+	if (column.notNull) parts.push('NOT NULL');
+	if (column.default !== undefined) {
+		const value = sqlToString(sql`${column.default}`);
+		parts.push(`DEFAULT ${value}`);
+	}
+	if (column.isUnique) parts.push('UNIQUE');
+	if (column.generated) {
+		const { as, mode } = column.generated;
+		const expr = typeof as === 'function' ? as() : as;
+		parts.push(`GENERATED ALWAYS AS (${sqlToString(expr as SQL)}) ${mode === 'stored' ? 'STORED' : 'VIRTUAL'}`);
+	}
+
+	return parts.join(' ');
+};
+
+const buildCreateTable = (table: SQLiteTable): string => {
+	const config = getTableConfig(table);
+	const defs = config.columns.map(buildColumn);
+
+	for (const pk of config.primaryKeys) {
+		defs.push(`PRIMARY KEY (${pk.columns.map((c) => escapeName(c.name)).join(', ')})`);
+	}
+	for (const uq of config.uniqueConstraints) {
+		defs.push(`UNIQUE (${uq.columns.map((c) => escapeName(c.name)).join(', ')})`);
+	}
+	for (const fk of config.foreignKeys) {
+		const ref = fk.reference();
+		const cols = ref.columns.map((c) => escapeName(c.name)).join(', ');
+		const fcols = ref.foreignColumns.map((c) => escapeName(c.name)).join(', ');
+		let clause = `FOREIGN KEY (${cols}) REFERENCES ${escapeName(getTableConfig(ref.foreignTable).name)} (${fcols})`;
+		if (fk.onUpdate) clause += ` ON UPDATE ${fk.onUpdate}`;
+		if (fk.onDelete) clause += ` ON DELETE ${fk.onDelete}`;
+		defs.push(clause);
+	}
+	for (const check of config.checks) {
+		defs.push(`CONSTRAINT ${escapeName(check.name)} CHECK (${sqlToString(check.value)})`);
+	}
+
+	return `CREATE TABLE ${escapeName(config.name)} (${defs.join(', ')})`;
+};
+
+const buildCreateView = (view: SQLiteView): string => {
+	const { name, query } = getViewConfig(view);
+	return `CREATE VIEW ${escapeName(name)} AS ${sqlToString(query!)}`;
+};
+
+export const push = (db: SQLiteEffectDatabase<any, any, any>, schema: Record<string, any>) =>
+	Effect.gen(function*() {
+		const tables: SQLiteTable[] = [];
+		const views: SQLiteView[] = [];
+		for (const value of Object.values(schema)) {
+			if (is(value, SQLiteTable)) tables.push(value);
+			else if (is(value, SQLiteView)) views.push(value);
+		}
+
+		for (const view of views) {
+			yield* db.run(sql.raw(`DROP VIEW IF EXISTS ${escapeName(getViewConfig(view).name)}`));
+		}
+		for (const table of tables) {
+			yield* db.run(sql.raw(`DROP TABLE IF EXISTS ${escapeName(getTableConfig(table).name)}`));
+		}
+		for (const table of tables) {
+			yield* db.run(sql.raw(buildCreateTable(table)));
+		}
+		for (const view of views) {
+			yield* db.run(sql.raw(buildCreateView(view)));
+		}
+	});
+
+export interface EffectBunIt {
+	effect: ((name: string, body: () => Effect.Effect<unknown, unknown, DB | SqlClient>) => void) & {
+		skip: (name: string, body: () => Effect.Effect<unknown, unknown, DB | SqlClient>) => void;
+	};
+}
+
+export interface RunCommonEffectSQLiteTestsOptions {
+	testLayer: Layer.Layer<DB | SqlClient, SqlError, never>;
+	SQLiteDrizzle: {
+		make: (config?: any) => Effect.Effect<SQLiteEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		makeWithDefaults: (
+			config?: any,
+		) => Effect.Effect<SQLiteEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		DefaultServices: Layer.Layer<any, never, any>;
+	};
+	createDB: <
+		TSchema extends Record<string, any>,
+		TConfig extends RelationsBuilderConfig<TTables>,
+		TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+	>(
+		schema: TSchema,
+		relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+		useJitMappers?: boolean,
+	) => Effect.Effect<
+		SQLiteEffectDatabase<QueryEffectHKTBase, any, ExtractTablesWithRelations<TConfig, TTables>>,
+		never,
+		any
+	>;
+	skipTests?: string[];
+	addTests?: (it: EffectBunIt) => void;
+}
+
+export const runCommonEffectSQLiteTests = (opts: RunCommonEffectSQLiteTestsOptions): void => {
+	const { testLayer, addTests, skipTests = [], SQLiteDrizzle, createDB } = opts;
+
+	const scope = Effect.runSync(Scope.make());
+	const contextEffect = Layer.buildWithMemoMap(testLayer, Effect.runSync(Layer.makeMemoMap), scope).pipe(
+		Effect.orDie,
+		Effect.cached,
+		Effect.runSync,
+	);
+
+	const run = (body: () => Effect.Effect<unknown, unknown, DB | SqlClient>) =>
+		Effect.runPromise(
+			Effect.flatMap(contextEffect, (context) => Effect.suspend(body).pipe(Effect.scoped, Effect.provide(context))),
+		);
+
+	const it: EffectBunIt = {
+		effect: Object.assign(
+			(name: string, body: () => Effect.Effect<unknown, unknown, DB | SqlClient>) => {
+				if (skipTests.includes(name)) return test.skip(name, () => {});
+				return test(name, () => run(body));
+			},
+			{
+				skip: (name: string, _body: () => Effect.Effect<unknown, unknown, DB | SqlClient>) => test.skip(name, () => {}),
+			},
+		),
+	};
+
+	describe('common', () => {
+		beforeAll(() => Effect.runPromise(Effect.asVoid(contextEffect)));
+		afterAll(() => Effect.runPromise(Scope.close(scope, Exit.void)));
+
+		it.effect('execute - all', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.all<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual([{ '1': 1 }]);
+			}));
+
+		it.effect('execute - get', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.get<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual({ '1': 1 });
+			}));
+
+		it.effect('execute - values', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.values<[number]>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual([[1]]);
+			}));
+
+		it.effect('all types', () =>
+			Effect.gen(function*() {
+				const allTypesTable = sqliteTable('all_types', {
+					int: integer('int', {
+						mode: 'number',
+					}),
+					bool: integer('bool', {
+						mode: 'boolean',
+					}),
+					time: integer('time', {
+						mode: 'timestamp',
+					}),
+					timeMs: integer('time_ms', {
+						mode: 'timestamp_ms',
+					}),
+					bigint: blob('bigint', {
+						mode: 'bigint',
+					}),
+					buffer: blob('buffer', {
+						mode: 'buffer',
+					}),
+					json: blob('json', {
+						mode: 'json',
+					}),
+					numeric: numeric('numeric'),
+					numericNum: numeric('numeric_num', {
+						mode: 'number',
+					}),
+					numericBig: numeric('numeric_big', {
+						mode: 'bigint',
+					}),
+					real: real('real'),
+					text: text('text', {
+						mode: 'text',
+					}),
+					jsonText: text('json_text', {
+						mode: 'json',
+					}),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { allTypesTable });
+
+				yield* db.insert(allTypesTable).values({
+					int: 1,
+					bool: true,
+					bigint: 5044565289845416380n,
+					buffer: Buffer.from([
+						0x44,
+						0x65,
+						0x73,
+						0x70,
+						0x61,
+						0x69,
+						0x72,
+						0x20,
+						0x6f,
+						0x20,
+						0x64,
+						0x65,
+						0x73,
+						0x70,
+						0x61,
+						0x69,
+						0x72,
+						0x2e,
+						0x2e,
+						0x2e,
+					]),
+					json: {
+						str: 'strval',
+						arr: ['str', 10],
+					},
+					jsonText: {
+						str: 'strvalb',
+						arr: ['strb', 11],
+					},
+					numeric: '475452353476',
+					numericNum: 9007199254740991,
+					numericBig: 5044565289845416380n,
+					real: 1.048596,
+					text: 'TEXT STRING',
+					time: new Date(1741743161623),
+					timeMs: new Date(1741743161623),
+				});
+
+				const rawRes = yield* db.select().from(allTypesTable);
+
+				expect(typeof rawRes[0]?.numericBig).toStrictEqual('bigint');
+
+				type ExpectedType = {
+					int: number | null;
+					bool: boolean | null;
+					time: Date | null;
+					timeMs: Date | null;
+					bigint: bigint | null;
+					buffer: Buffer | null;
+					json: unknown;
+					numeric: string | null;
+					numericNum: number | null;
+					numericBig: bigint | null;
+					real: number | null;
+					text: string | null;
+					jsonText: unknown;
+				}[];
+
+				const expectedRes: ExpectedType = [
+					{
+						int: 1,
+						bool: true,
+						time: new Date('2025-03-12T01:32:41.000Z'),
+						timeMs: new Date('2025-03-12T01:32:41.623Z'),
+						bigint: 5044565289845416380n,
+						buffer: Buffer.from([
+							0x44,
+							0x65,
+							0x73,
+							0x70,
+							0x61,
+							0x69,
+							0x72,
+							0x20,
+							0x6f,
+							0x20,
+							0x64,
+							0x65,
+							0x73,
+							0x70,
+							0x61,
+							0x69,
+							0x72,
+							0x2e,
+							0x2e,
+							0x2e,
+						]),
+						json: { str: 'strval', arr: ['str', 10] },
+						numeric: '475452353476',
+						numericNum: 9007199254740991,
+						numericBig: 5044565289845416380n,
+						real: 1.048596,
+						text: 'TEXT STRING',
+						jsonText: { str: 'strvalb', arr: ['strb', 11] },
+					},
+				];
+
+				expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+				expect(rawRes).toStrictEqual(expectedRes);
+			}));
+
+		it.effect('RQB v2 simple find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 simple find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 simple find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbPost.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst();
+
+						expect(result).toStrictEqual(undefined);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 transaction find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							with: {
+								posts: {
+									orderBy: {
+										id: 'asc',
+									},
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 1,
+							createdAt: date,
+							name: 'First',
+							posts: [{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+							}, {
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+							}],
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findFirst({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany();
+
+						expect(result).toStrictEqual([]);
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 transaction find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}, {
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbPost.findMany({
+							with: {
+								author: true,
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}, {
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findMany({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}]);
+
+						return result;
+					})
+				);
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_transactions', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+				const products = sqliteTable('products_transactions', {
+					id: integer('id').primaryKey(),
+					price: integer('price').notNull(),
+					stock: integer('stock').notNull(),
+				});
+
+				yield* push(db, { users, products });
+
+				const [user] = yield* db.insert(users).values({ balance: 100 }).returning();
+				const [product] = yield* db.insert(products).values({ price: 10, stock: 10 }).returning();
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.update(users).set({ balance: user!.balance - product!.price }).where(eq(users.id, user!.id));
+						yield* tx.update(products).set({ stock: product!.stock - 1 }).where(eq(products.id, product!.id));
+
+						// Regardless if `db` or `tx` is used, every query within the transaction effect is completed in transaction
+						const nonTxRes = yield* db.select().from(users);
+						expect(nonTxRes).toStrictEqual([{ id: 1, balance: 90 }]);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 90 }]);
+			}));
+
+		it.effect('transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_transactions_rollback', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				const res = yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+						yield* tx.rollback();
+					})
+				).pipe(Effect.result);
+
+				assert(Result.isFailure(res));
+				assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([]);
+			}));
+
+		it.effect('nested transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_nested_transactions', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+							})
+						);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 200 }]);
+			}));
+
+		it.effect('nested transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_nested_transactions_rollback', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						const res = yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+								yield* tx.rollback();
+							})
+						).pipe(Effect.result);
+
+						assert(Result.isFailure(res));
+						assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 100 }]);
+			}));
+
+		it.effect('update ... from with join', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const states = sqliteTable('states_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const cities = sqliteTable('cities_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					stateId: integer('state_id').references(() => states.id),
+				});
+				const users = sqliteTable('users_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull().references(() => cities.id),
+				});
+
+				yield* push(db, { states, cities, users });
+
+				yield* db.insert(states).values([
+					{ name: 'New York' },
+					{ name: 'Washington' },
+				]);
+				yield* db.insert(cities).values([
+					{ name: 'New York City', stateId: 1 },
+					{ name: 'Seattle', stateId: 2 },
+					{ name: 'London' },
+				]);
+				yield* db.insert(users).values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 2 },
+					{ name: 'Jack', cityId: 3 },
+				]);
+
+				const result1 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+					.returning();
+				const result2 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+					.returning();
+
+				expect(result1).toStrictEqual([{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+				}]);
+				expect(result2).toStrictEqual([{
+					id: 3,
+					name: 'Jack',
+					cityId: 3,
+				}]);
+			}));
+
+		it.effect('insert into ... select', () =>
+			Effect.gen(function*() {
+				const notifications = sqliteTable('notifications_31', {
+					id: integer('id').primaryKey(),
+					sentAt: integer('sent_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+					message: text('message').notNull(),
+				});
+				const users = sqliteTable('users_31', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const userNotications = sqliteTable('user_notifications_31', {
+					userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: integer('notification_id').notNull().references(() => notifications.id, {
+						onDelete: 'cascade',
+					}),
+				}, (t) => [primaryKey({ columns: [t.userId, t.notificationId] })]);
+
+				const db = yield* DB;
+
+				yield* push(db, { notifications, users, userNotications });
+
+				const newNotification = (yield* db
+					.insert(notifications)
+					.values({ message: 'You are one of the 3 lucky winners!' })
+					.returning({ id: notifications.id }))[0]!;
+
+				yield* db.insert(users).values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+				const sentNotifications = yield* db
+					.insert(userNotications)
+					.select(
+						db
+							.select({
+								userId: users.id,
+								notificationId: sql`${newNotification!.id}`.as('notification_id'),
+							})
+							.from(users)
+							.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+							.orderBy(asc(users.id)),
+					)
+					.returning();
+
+				expect(sentNotifications).toStrictEqual([
+					{ userId: 1, notificationId: newNotification!.id },
+					{ userId: 3, notificationId: newNotification!.id },
+					{ userId: 5, notificationId: newNotification!.id },
+				]);
+			}));
+
+		it.effect('$count separate', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_33', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable);
+
+				expect(count).toStrictEqual(4);
+			}));
+
+		it.effect('$count embedded', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_34', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+			}));
+
+		it.effect('$count separate reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_35', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.$count(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual(4);
+				expect(count2).toStrictEqual(5);
+				expect(count3).toStrictEqual(6);
+			}));
+
+		it.effect('$count embedded reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_36', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+				expect(count2).toStrictEqual([
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+				]);
+				expect(count3).toStrictEqual([
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+				]);
+			}));
+
+		it.effect('$count separate with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_37', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable, gt(countTestTable.id, 1));
+				expect(count).toStrictEqual(3);
+			}));
+
+		it.effect('$count embedded with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_38', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+				]);
+			}));
+
+		it.effect('select distinct', () =>
+			Effect.gen(function*() {
+				const usersDistinctTable = sqliteTable('users_distinct_101', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+					age: integer('age').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersDistinctTable });
+
+				yield* db.insert(usersDistinctTable).values([
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+				]);
+				const users = yield* db.selectDistinct().from(usersDistinctTable).orderBy(
+					usersDistinctTable.id,
+					usersDistinctTable.name,
+				);
+
+				expect(users).toEqual([
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+				]);
+			}));
+
+		it.effect('update with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_9', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+					createdAt: integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('update with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_10', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning({
+						id: users.id,
+						name: users.name,
+					});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'Jane' }]);
+			}));
+
+		it.effect('delete with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_11', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+					createdAt: integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('delete with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_12', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning({
+					id: users.id,
+					name: users.name,
+				});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('insert many', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_19', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_20', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					});
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_20', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement reuse', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_35', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						verified: true,
+						name: sql.placeholder('name'),
+					})
+					.prepare();
+
+				for (let i = 0; i < 10; i++) {
+					yield* stmt.execute({ name: `John ${i}` });
+				}
+
+				const result = yield* db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+						verified: usersTable.verified,
+					})
+					.from(usersTable);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John 0', verified: true },
+					{ id: 2, name: 'John 1', verified: true },
+					{ id: 3, name: 'John 2', verified: true },
+					{ id: 4, name: 'John 3', verified: true },
+					{ id: 5, name: 'John 4', verified: true },
+					{ id: 6, name: 'John 5', verified: true },
+					{ id: 7, name: 'John 6', verified: true },
+					{ id: 8, name: 'John 7', verified: true },
+					{ id: 9, name: 'John 8', verified: true },
+					{ id: 10, name: 'John 9', verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement with placeholder in .where', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_36', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.prepare();
+				const result = yield* stmt.execute({ id: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('prepared statement with placeholder in .limit', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_37', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ id: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('prepared statement with placeholder in .offset', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_38', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.offset(sql.placeholder('offset'))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ offset: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			}));
+
+		it.effect('prepared statement built using $dynamic', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_39', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				function withLimitOffset(qb: any) {
+					return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+				}
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.$dynamic();
+				withLimitOffset(stmt).prepare();
+
+				const result = yield* stmt.execute({ limit: 1, offset: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('with ... select', () =>
+			Effect.gen(function*() {
+				const orders = sqliteTable('orders_55', {
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const regionalSales = db
+					.$with('regional_sales')
+					.as(
+						db
+							.select({
+								region: orders.region,
+								totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+							})
+							.from(orders)
+							.groupBy(orders.region),
+					);
+
+				const topRegions = db
+					.$with('top_regions')
+					.as(
+						db
+							.select({
+								region: regionalSales.region,
+							})
+							.from(regionalSales)
+							.where(
+								gt(
+									regionalSales.totalSales,
+									db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+								),
+							),
+					);
+
+				const result1 = yield* db
+					.with(regionalSales, topRegions)
+					.select({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result2 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result3 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region)
+					.orderBy(orders.region);
+
+				expect(result1).toEqual([
+					{
+						region: 'Europe',
+						product: 'A',
+						productUnits: 3,
+						productSales: 30,
+					},
+					{
+						region: 'Europe',
+						product: 'B',
+						productUnits: 5,
+						productSales: 50,
+					},
+					{
+						region: 'US',
+						product: 'A',
+						productUnits: 7,
+						productSales: 70,
+					},
+					{
+						region: 'US',
+						product: 'B',
+						productUnits: 9,
+						productSales: 90,
+					},
+				]);
+				expect(result2).toEqual(result1);
+				expect(result3).toEqual([
+					{
+						region: 'Europe',
+						productUnits: 8,
+						productSales: 80,
+					},
+					{
+						region: 'US',
+						productUnits: 16,
+						productSales: 160,
+					},
+				]);
+			}));
+
+		it.effect('with ... update', () =>
+			Effect.gen(function*() {
+				const products = sqliteTable('products_56', {
+					id: integer('id').primaryKey(),
+					price: numeric('price').notNull(),
+					cheap: integer('cheap', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { products });
+
+				yield* db.insert(products).values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
+
+				const averagePrice = db
+					.$with('average_price')
+					.as(
+						db
+							.select({
+								value: sql`avg(${products.price})`.as('value'),
+							})
+							.from(products),
+					);
+
+				const result = yield* db
+					.with(averagePrice)
+					.update(products)
+					.set({
+						cheap: true,
+					})
+					.where(lt(products.price, sql`(select * from ${averagePrice})`))
+					.returning({
+						id: products.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 1 },
+					{ id: 4 },
+					{ id: 5 },
+				]);
+			}));
+
+		it.effect('with ... insert', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_57', {
+					username: text('username').notNull(),
+					admin: integer('admin', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const userCount = db
+					.$with('user_count')
+					.as(
+						db
+							.select({
+								value: sql`count(*)`.as('value'),
+							})
+							.from(users),
+					);
+
+				const result = yield* db
+					.with(userCount)
+					.insert(users)
+					.values([
+						{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+					])
+					.returning({
+						admin: users.admin,
+					});
+
+				expect(result).toEqual([{ admin: true }]);
+			}));
+
+		it.effect('with ... delete', () =>
+			Effect.gen(function*() {
+				const orders = sqliteTable('orders_58', {
+					id: integer('id').primaryKey(),
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const averageAmount = db
+					.$with('average_amount')
+					.as(
+						db
+							.select({
+								value: sql`avg(${orders.amount})`.as('value'),
+							})
+							.from(orders),
+					);
+
+				const result = yield* db
+					.with(averageAmount)
+					.delete(orders)
+					.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+					.returning({
+						id: orders.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 6 },
+					{ id: 7 },
+					{ id: 8 },
+				]);
+			}));
+
+		it.effect('partial join with alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_29', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customerAlias = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user: {
+							id: users.id,
+							name: users.name,
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			}));
+
+		it.effect('full join with alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(users)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([{
+					prefixed_users_30: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('select from alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_31', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const user = alias(users, 'user');
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(user)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(user.id, 10));
+
+				expect(result).toEqual([{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('set operations (mixed) from query builder with subquery', () =>
+			Effect.gen(function*() {
+				const cities2Table = sqliteTable('cities_1', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = sqliteTable('users2_1', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const sq = db
+					.select()
+					.from(cities2Table).where(gt(cities2Table.id, 1)).as('sq');
+
+				const result = yield* db
+					.select()
+					.from(cities2Table).except(
+						({ unionAll }) =>
+							unionAll(
+								db.select().from(sq),
+								db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+							),
+					);
+
+				expect(result).toHaveLength(2);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* db
+						.select()
+						.from(cities2Table).except(
+							({ unionAll }) =>
+								unionAll(
+									db
+										.select({ name: cities2Table.name, id: cities2Table.id })
+										.from(cities2Table).where(gt(cities2Table.id, 1)),
+									db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+								),
+						);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('set operations (mixed all) as function', () =>
+			Effect.gen(function*() {
+				const cities2Table = sqliteTable('cities_2', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = sqliteTable('users2_2', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const result = yield* union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 7)),
+					),
+					db
+						.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+				).orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(6);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+					{ id: 8, name: 'Sally' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table).where(gte(users2Table.id, 5)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table).where(eq(users2Table.id, 7)),
+						),
+						db
+							.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+					);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('custom EffectLogger override - user provided logger takes precedence over default', () =>
+			Effect.gen(function*() {
+				const loggedQueries: Array<{ query: string; params: unknown[] }> = [];
+
+				const customLogger: EffectLoggerShape = {
+					logQuery: (query: string, params: unknown[]) =>
+						Effect.sync(() => {
+							loggedQueries.push({ query, params });
+						}),
+				};
+				const customLoggerLayer = Layer.succeed(EffectLogger, customLogger);
+
+				const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+					Effect.provide(customLoggerLayer),
+					Effect.provide(SQLiteDrizzle.DefaultServices),
+				);
+
+				const users = sqliteTable('users_custom_logger', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users);
+
+				expect(loggedQueries.length).toBeGreaterThanOrEqual(2);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('insert'))).toBe(true);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('select'))).toBe(true);
+			}));
+
+		it.effect('custom EffectCache override - user provided cache takes precedence over default', () =>
+			Effect.gen(function*() {
+				const cacheOperations = yield* Ref.make<Array<{ op: 'get' | 'put' | 'mutate'; key?: string }>>([]);
+
+				const customCacheService: EffectCacheShape = {
+					strategy: () => 'all' as const,
+					get: (key: string, _tables: string[], _isTag: boolean, _isAutoInvalidate?: boolean) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'get' as const, key }]);
+							// oxlint-disable-next-line no-useless-undefined
+							return undefined;
+						}),
+					put: (key: string, _response: any, _tables: string[], _isTag: boolean, _config?: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'put' as const, key }]);
+						}),
+					onMutate: (_params: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'mutate' as const }]);
+						}),
+					cache: {
+						strategy: () => 'all' as const,
+						// oxlint-disable-next-line no-useless-undefined
+						get: async () => undefined,
+						put: async () => {},
+						onMutate: async () => {},
+					},
+				};
+				const customCacheLayer = Layer.succeed(EffectCache, customCacheService);
+
+				const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+					Effect.provide(customCacheLayer),
+					Effect.provide(SQLiteDrizzle.DefaultServices),
+				);
+
+				const users = sqliteTable('users_custom_cache', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users).$withCache();
+
+				const ops = yield* Ref.get(cacheOperations);
+				expect(ops.some((o) => o.op === 'mutate')).toBe(true);
+				expect(ops.some((o) => o.op === 'get')).toBe(true);
+			}));
+
+		it.effect('makeWithDefaults - convenience function that includes DefaultServices', () =>
+			Effect.gen(function*() {
+				const db = yield* SQLiteDrizzle.makeWithDefaults({ relations });
+
+				const users = sqliteTable('users_make_with_defaults', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'Alice' });
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, name: 'Alice' }]);
+			}));
+
+		it.effect('Mappers: - correct mappers enabled', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const jitDb = yield* createDB({}, () => ({}), true);
+
+				const dialect: SQLiteDialect = (<any> db).dialect;
+				const jitDialect: SQLiteDialect = (<any> jitDb).dialect;
+
+				expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+				expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+			}));
+
+		const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+		it.effect('Mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_1', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_2', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_3', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Mappers: insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_4', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_5', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_6', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					false,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: - simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_1', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Jit mappers: - select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_2', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Jit mappers: - select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_3', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Jit mappers: - insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_4', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Jit mappers: - select complex selections', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_5', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('jit_mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: - relational', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_6', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('jit_mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					true,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		addTests?.(it);
+	});
+};
diff --git a/integration-tests/tests/bun/sqlite-nw.test.ts b/integration-tests/tests/bun/sqlite-nw.test.ts
index d61d1ab4e4..7ed6676642 100644
--- a/integration-tests/tests/bun/sqlite-nw.test.ts
+++ b/integration-tests/tests/bun/sqlite-nw.test.ts
@@ -1,7 +1,7 @@
 /// <reference types="bun-types" />
 import { Database } from 'bun:sqlite';
 import { DefaultLogger, sql } from 'drizzle-orm';
-import type { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';
+import type { SQLiteBunDatabase } from 'drizzle-orm/bun-sqlite';
 import { drizzle } from 'drizzle-orm/bun-sqlite';
 import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { suite } from 'uvu';
@@ -24,7 +24,7 @@ const order = sqliteTable('Order', {
 });
 
 interface Context {
-	db: BunSQLiteDatabase;
+	db: SQLiteBunDatabase;
 }
 
 const test = suite<Context>('sqlite-bun');
@@ -34,7 +34,7 @@ test.before((ctx) => {
 		const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
 
 		const client = new Database(dbPath);
-		ctx.db = drizzle(client, { logger: new DefaultLogger() });
+		ctx.db = drizzle({ client, logger: new DefaultLogger() });
 	} catch (e) {
 		console.error(e);
 	}
diff --git a/integration-tests/tests/bun/sqlite.test.ts b/integration-tests/tests/bun/sqlite.test.ts
index c6ce9d4d13..83e8cf9688 100644
--- a/integration-tests/tests/bun/sqlite.test.ts
+++ b/integration-tests/tests/bun/sqlite.test.ts
@@ -1,7 +1,7 @@
 import { Database } from 'bun:sqlite';
 import { beforeAll, beforeEach, expect, test } from 'bun:test';
-import { sql } from 'drizzle-orm';
-import type { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';
+import { defineRelations, sql } from 'drizzle-orm';
+import type { SQLiteBunDatabase } from 'drizzle-orm/bun-sqlite';
 import { drizzle } from 'drizzle-orm/bun-sqlite';
 import { blob, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 
@@ -11,17 +11,49 @@ const usersTable = sqliteTable('users', {
 	verified: integer('verified').notNull().default(0),
 	json: blob('json', { mode: 'json' }).$type<string[]>(),
 	bigInt: blob('big_int', { mode: 'bigint' }),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull().default(sql`strftime('%s', 'now')`),
+	createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`strftime('%s', 'now')`),
 });
 
-let db: BunSQLiteDatabase;
+export const rqbUser = sqliteTable('user_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const rqbPost = sqliteTable('post_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const relations = defineRelations({
+	rqbUser,
+	rqbPost,
+}, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
+
+let db: SQLiteBunDatabase<typeof relations>;
 
 beforeAll(async () => {
 	try {
 		const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
 
 		const client = new Database(dbPath);
-		db = drizzle(client);
+		db = drizzle({ client, relations });
 	} catch (e) {
 		console.error(e);
 	}
@@ -30,6 +62,8 @@ beforeAll(async () => {
 beforeEach(async () => {
 	try {
 		db.run(sql`drop table if exists ${usersTable}`);
+		db.run(sql`drop table if exists ${rqbUser}`);
+		db.run(sql`drop table if exists ${rqbPost}`);
 		db.run(sql`
 			create table ${usersTable} (
 				id integer primary key,
@@ -40,6 +74,21 @@ beforeEach(async () => {
 				created_at integer not null default (strftime('%s', 'now'))
 			)
 		`);
+		await db.run(sql`
+			CREATE TABLE ${rqbUser} (
+					"id" INT PRIMARY KEY NOT NULL,
+					"name" TEXT NOT NULL,
+					"created_at" INT NOT NULL
+				 )
+		`);
+		await db.run(sql`
+			CREATE TABLE ${rqbPost} ( 
+					"id" INT PRIMARY KEY NOT NULL,
+					"user_id" INT NOT NULL,
+					"content" TEXT,
+					"created_at" INT NOT NULL
+			)
+		`);
 	} catch (e) {
 		console.error(e);
 	}
@@ -59,7 +108,7 @@ test('select all fields', () => {
 	const result = db.select().from(usersTable).all()[0]!;
 
 	expect(result.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(result.createdAt.getTime() - now)).toBeLessThan(100);
+	expect(Math.abs(result.createdAt.getTime() - now)).toBeLessThan(1000);
 	expect(result).toEqual({ id: 1, name: 'John', verified: 0, json: null, createdAt: result.createdAt, bigInt: null });
 });
 
@@ -281,3 +330,543 @@ test('select bigint', () => {
 // 	const ctx = t.context;
 // 	ctx.client?.close();
 // });
+
+test('RQB v2 simple find first - no rows', async () => {
+	const result = await db.query.rqbUser.findFirst();
+
+	expect(result).toStrictEqual(undefined);
+});
+
+test('RQB v2 simple find first - multiple rows', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	const result = await db.query.rqbUser.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expect(result).toStrictEqual({
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	});
+});
+
+test('RQB v2 simple find first - with relation', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.insert(rqbPost).values([{
+		id: 1,
+		userId: 1,
+		createdAt: date,
+		content: null,
+	}, {
+		id: 2,
+		userId: 1,
+		createdAt: date,
+		content: 'Has message this time',
+	}]);
+
+	const result = await db.query.rqbUser.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expect(result).toStrictEqual({
+		id: 1,
+		createdAt: date,
+		name: 'First',
+		posts: [{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}],
+	});
+});
+
+test('RQB v2 simple find first - placeholders', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	const query = db.query.rqbUser.findFirst({
+		where: {
+			id: {
+				eq: sql.placeholder('filter'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const result = await query.execute({
+		filter: 2,
+	});
+
+	expect(result).toStrictEqual({
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	});
+});
+
+test('RQB v2 simple find many - no rows', async () => {
+	const result = await db.query.rqbUser.findMany();
+
+	expect(result).toStrictEqual([]);
+});
+
+test('RQB v2 simple find many - multiple rows', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	const result = await db.query.rqbUser.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expect(result).toStrictEqual([{
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}, {
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}]);
+});
+
+test('RQB v2 simple find many - with relation', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.insert(rqbPost).values([{
+		id: 1,
+		userId: 1,
+		createdAt: date,
+		content: null,
+	}, {
+		id: 2,
+		userId: 1,
+		createdAt: date,
+		content: 'Has message this time',
+	}]);
+
+	const result = await db.query.rqbPost.findMany({
+		with: {
+			author: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expect(result).toStrictEqual([{
+		id: 1,
+		userId: 1,
+		createdAt: date,
+		content: null,
+		author: {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		},
+	}, {
+		id: 2,
+		userId: 1,
+		createdAt: date,
+		content: 'Has message this time',
+		author: {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		},
+	}]);
+});
+
+test('RQB v2 simple find many - placeholders', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	const query = db.query.rqbUser.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('filter'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const result = await query.execute({
+		filter: 2,
+	});
+
+	expect(result).toStrictEqual([{
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+});
+
+test('RQB v2 transaction find first - no rows', async () => {
+	db.transaction((db) => {
+		const result = db.query.rqbUser.findFirst().sync();
+
+		expect(result).toStrictEqual(undefined);
+	});
+});
+
+test('RQB v2 transaction find first - multiple rows', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.transaction((db) => {
+		const result = db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		}).sync();
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+});
+
+test('RQB v2 transaction find first - with relation', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.insert(rqbPost).values([{
+		id: 1,
+		userId: 1,
+		createdAt: date,
+		content: null,
+	}, {
+		id: 2,
+		userId: 1,
+		createdAt: date,
+		content: 'Has message this time',
+	}]);
+
+	await db.transaction((db) => {
+		const result = db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).sync();
+
+		expect(result).toStrictEqual({
+			id: 1,
+			createdAt: date,
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}],
+		});
+	});
+});
+
+test('RQB v2 transaction find first - placeholders', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.transaction((db) => {
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = query.execute({
+			filter: 2,
+		}).sync();
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	});
+});
+
+test('RQB v2 transaction find many - no rows', async () => {
+	await db.transaction((db) => {
+		const result = db.query.rqbUser.findMany().sync();
+
+		expect(result).toStrictEqual([]);
+	});
+});
+
+test('RQB v2 transaction find many - multiple rows', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.transaction((db) => {
+		const result = db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		}).sync();
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}]);
+	});
+});
+
+test('RQB v2 transaction find many - with relation', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.insert(rqbPost).values([{
+		id: 1,
+		userId: 1,
+		createdAt: date,
+		content: null,
+	}, {
+		id: 2,
+		userId: 1,
+		createdAt: date,
+		content: 'Has message this time',
+	}]);
+
+	await db.transaction((db) => {
+		const result = db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).sync();
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}]);
+	});
+});
+
+test('RQB v2 transaction find many - placeholders', async () => {
+	const date = new Date(120000);
+
+	await db.insert(rqbUser).values([{
+		id: 1,
+		createdAt: date,
+		name: 'First',
+	}, {
+		id: 2,
+		createdAt: date,
+		name: 'Second',
+	}]);
+
+	await db.transaction((db) => {
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = query.execute({
+			filter: 2,
+		}).sync();
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+	});
+});
+
+test('db.get', async () => {
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	const result = db.get<{ id: number; name: string }>(sql`SELECT id, name FROM ${usersTable};`);
+
+	expect(result).toStrictEqual({ id: 1, name: 'First' });
+});
+
+test('db.all', async () => {
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	const result = db.all<{ id: number; name: string }>(sql`SELECT id, name FROM ${usersTable};`);
+
+	expect(result).toStrictEqual([{ id: 1, name: 'First' }]);
+});
diff --git a/integration-tests/tests/cockroach/cockroach.test.ts b/integration-tests/tests/cockroach/cockroach.test.ts
new file mode 100644
index 0000000000..3a324cde94
--- /dev/null
+++ b/integration-tests/tests/cockroach/cockroach.test.ts
@@ -0,0 +1,626 @@
+import retry from 'async-retry';
+import { sql } from 'drizzle-orm';
+import type { NodeCockroachDatabase } from 'drizzle-orm/cockroach';
+import { drizzle } from 'drizzle-orm/cockroach';
+import { cockroachTable, getTableConfig, int4, text, timestamp } from 'drizzle-orm/cockroach-core';
+import { migrate } from 'drizzle-orm/cockroach/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { Client } from 'pg';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { skipTests } from '~/common';
+import { randomString } from '~/utils';
+import { requireCockroachConnectionString, tests, usersMigratorTable, usersTable } from './common';
+
+const ENABLE_LOGGING = false;
+
+let db: NodeCockroachDatabase;
+let client: Client;
+
+beforeAll(async () => {
+	const connectionString = requireCockroachConnectionString();
+	client = await retry(async () => {
+		client = new Client(connectionString);
+		await client.connect();
+		return client;
+	}, {
+		retries: 20,
+		factor: 1,
+		minTimeout: 250,
+		maxTimeout: 250,
+		randomize: false,
+		onRetry() {
+			client?.end();
+		},
+	});
+	db = drizzle({ client, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end();
+});
+
+beforeEach((ctx) => {
+	ctx.cockroach = {
+		db,
+	};
+});
+
+test('migrator : default migration strategy', async () => {
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+});
+
+test('migrator : migrate with custom schema', async () => {
+	const customSchema = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach', migrationsSchema: customSchema });
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
+	expect(rowCount && rowCount > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
+});
+
+test('migrator : migrate with custom table', async () => {
+	const customTable = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach', migrationsTable: customTable });
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+	expect(rowCount && rowCount > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
+});
+
+test('migrator : migrate with custom table and custom schema', async () => {
+	const customTable = randomString();
+	const customSchema = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach',
+		migrationsTable: customTable,
+		migrationsSchema: customSchema,
+	});
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(
+		sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
+	);
+	expect(rowCount && rowCount > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
+});
+
+test('migrator : --init', async () => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM information_schema.tables
+				WHERE table_schema = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND table_name = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(res.rows[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async () => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach-init',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM information_schema.tables
+				WHERE table_schema = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND table_name = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(res.rows[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async () => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+
+	await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach-init',
+		migrationsSchema,
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM information_schema.tables
+				WHERE table_schema = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND table_name = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(2);
+	expect(res.rows[0]?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async () => {
+	const users = cockroachTable('migration_users', {
+		id: int4('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int4(),
+	});
+
+	const users2 = cockroachTable('migration_users2', {
+		id: int4('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int4(),
+	});
+
+	await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/cockroach';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" INT4 PRIMARY KEY,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db, { migrationsFolder: migrationDir });
+	await db.insert(users).values({ id: 1, name: 'John', email: '', age: 30 });
+	const res1 = await db.select().from(users);
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" INT4 PRIMARY KEY,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db, { migrationsFolder: migrationDir });
+
+	await db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 });
+	const res2 = await db.select().from(users2);
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${users2}`);
+});
+
+test('all date and time columns without timezone first case mode string', async () => {
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey(),
+		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key,
+					timestamp_string timestamp(6) not null
+			)
+	`);
+
+	// 1. Insert date in string format without timezone in it
+	await db.insert(table).values([
+		{ id: 1, timestamp: '2022-01-01 02:00:00.123456' },
+	]);
+
+	// 2, Select in string format and check that values are the same
+	const result = await db.select().from(table);
+
+	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+
+	// 3. Select as raw query and check that values are the same
+	const result2 = await db.execute<{
+		id: number;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('all date and time columns without timezone second case mode string', async () => {
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated by default as identity,
+					timestamp_string timestamp(6) not null
+			)
+	`);
+
+	// 1. Insert date in string format with timezone in it
+	await db.insert(table).values([
+		{ timestamp: '2022-01-01T02:00:00.123456-02' },
+	]);
+
+	// 2, Select as raw query and check that values are the same
+	const result = await db.execute<{
+		id: number;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('all date and time columns without timezone third case mode date', async () => {
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated always as identity,
+					timestamp_string timestamp(3) not null
+			)
+	`);
+
+	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+
+	// 1. Insert date as new date
+	await db.insert(table).values([
+		{ timestamp: insertedDate },
+	]);
+
+	// 2, Select as raw query as string
+	const result = await db.execute<{
+		id: string;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+	expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('test mode string for timestamp with timezone', async () => {
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated by default as identity,
+					timestamp_string timestamp(6) with time zone not null
+			)
+	`);
+
+	const timestampString = '2022-01-01 00:00:00.123456-0200';
+
+	// 1. Insert date in string format with timezone in it
+	await db.insert(table).values([
+		{ timestamp: timestampString },
+	]);
+
+	// 2. Select date in string format and check that the values are the same
+	const result = await db.select().from(table);
+
+	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+
+	// 3. Select as raw query and checke that values are the same
+	const result2 = await db.execute<{
+		id: string;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('test mode date for timestamp with timezone', async () => {
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated by default as identity,
+					timestamp_string timestamp(3) with time zone not null
+			)
+	`);
+
+	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+
+	await db.insert(table).values([
+		{ timestamp: timestampString },
+	]);
+
+	const result = await db.select().from(table);
+
+	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+
+	const result2 = await db.execute<{
+		id: string;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('test mode string for timestamp with timezone in UTC timezone', async () => {
+	// get current timezone from db
+	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+
+	// set timezone to UTC
+	await db.execute(sql`set time zone 'UTC'`);
+
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated by default as identity,
+					timestamp_string timestamp(6) with time zone not null
+			)
+	`);
+
+	const timestampString = '2022-01-01 00:00:00.123456-0200';
+
+	await db.insert(table).values([
+		{ timestamp: timestampString },
+	]);
+
+	const result = await db.select().from(table);
+
+	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+
+	const result2 = await db.execute<{
+		id: string;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+
+	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+test('test mode string for timestamp with timezone in different timezone', async () => {
+	// get current timezone from db
+	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+
+	// set timezone to HST (UTC - 10)
+	await db.execute(sql`set time zone 'HST'`);
+
+	const table = cockroachTable('all_columns', {
+		id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${table}`);
+
+	await db.execute(sql`
+		create table ${table} (
+					id int4 primary key generated by default as identity,
+					timestamp_string timestamp(6) with time zone not null
+			)
+	`);
+
+	const timestampString = '2022-01-01 00:00:00.123456-1000';
+
+	// 1. Insert date in string format with timezone in it
+	await db.insert(table).values([
+		{ timestamp: timestampString },
+	]);
+
+	// 2. Select date in string format and check that the values are the same
+	const result = await db.select().from(table);
+
+	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+
+	// 3. Select as raw query and checke that values are the same
+	const result2 = await db.execute<{
+		id: string;
+		timestamp_string: string;
+	}>(sql`select * from ${table}`);
+
+	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
+
+	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+
+	await db.execute(sql`drop table if exists ${table}`);
+});
+
+skipTests([
+	'migrator : default migration strategy',
+	'migrator : migrate with custom schema',
+	'migrator : migrate with custom table',
+	'migrator : migrate with custom table and custom schema',
+	'insert via db.execute + select via db.execute',
+	'insert via db.execute + returning',
+	'insert via db.execute w/ query builder',
+	'all date and time columns without timezone first case mode string',
+	'all date and time columns without timezone third case mode date',
+	'test mode string for timestamp with timezone',
+	'test mode date for timestamp with timezone',
+	'test mode string for timestamp with timezone in UTC timezone',
+	'test mode string for timestamp with timezone in different timezone',
+]);
+tests();
+
+beforeEach(async () => {
+	await db.execute(sql`drop database defaultdb;`);
+	await db.execute(sql`create database defaultdb;`);
+	await db.execute(
+		sql`
+			create table users (
+				id int4 primary key generated by default as identity,
+				name text not null,
+				verified boolean not null default false, 
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+	);
+});
+
+test('insert via db.execute + select via db.execute', async () => {
+	await db.execute(
+		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+	);
+
+	const result = await db.execute<{ id: string; name: string }>(
+		sql`select id, name from "users"`,
+	);
+	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('insert via db.execute + returning', async () => {
+	const inserted = await db.execute<{ id: string; name: string }>(
+		sql`insert into ${usersTable} (${
+			sql.identifier(
+				usersTable.name.name,
+			)
+		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+	);
+	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('insert via db.execute w/ query builder', async () => {
+	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+		db
+			.insert(usersTable)
+			.values({ name: 'John' })
+			.returning({ id: usersTable.id, name: usersTable.name }),
+	);
+	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+});
diff --git a/integration-tests/tests/cockroach/common.ts b/integration-tests/tests/cockroach/common.ts
new file mode 100644
index 0000000000..4853f50416
--- /dev/null
+++ b/integration-tests/tests/cockroach/common.ts
@@ -0,0 +1,7673 @@
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import {
+	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	DrizzleQueryError,
+	eq,
+	Equal,
+	exists,
+	getTableColumns,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	is,
+	isNull,
+	like,
+	lt,
+	max,
+	min,
+	not,
+	notInArray,
+	or,
+	SQL,
+	sql,
+	SQLWrapper,
+	sum,
+	sumDistinct,
+	TransactionRollbackError,
+} from 'drizzle-orm';
+import type { CockroachColumn, CockroachDatabase, CockroachQueryResultHKT } from 'drizzle-orm/cockroach-core';
+import {
+	alias,
+	bigint,
+	bit,
+	bool,
+	boolean,
+	char,
+	CockroachDialect,
+	cockroachEnum,
+	cockroachMaterializedView,
+	CockroachPolicy,
+	cockroachPolicy,
+	cockroachSchema,
+	cockroachTable,
+	cockroachTableCreator,
+	cockroachView,
+	date,
+	doublePrecision,
+	except,
+	exceptAll,
+	float,
+	foreignKey,
+	getMaterializedViewConfig,
+	getTableConfig,
+	getViewConfig,
+	inet,
+	int4,
+	intersect,
+	intersectAll,
+	interval,
+	jsonb,
+	numeric,
+	primaryKey,
+	real,
+	smallint,
+	string,
+	text,
+	time,
+	timestamp,
+	union,
+	unionAll,
+	unique,
+	uuid,
+	uuid as cockroachUuid,
+	varbit,
+	varchar,
+} from 'drizzle-orm/cockroach-core';
+import { v4 as uuidV4 } from 'uuid';
+import { afterAll, afterEach, beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
+import { Expect } from '~/utils';
+
+declare module 'vitest' {
+	interface TestContext {
+		cockroach: {
+			db: CockroachDatabase<any>;
+		};
+	}
+}
+
+const en = cockroachEnum('en', ['enVal1', 'enVal2']);
+
+const allTypesTable = cockroachTable('all_types', {
+	int4: int4('int4'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	bool: bool('bool'),
+	boolean: bool('boolean'),
+	char: char('char'),
+	string: string('string'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	double: doublePrecision('double'),
+	enum: en('enum'),
+	inet: inet('inet'),
+	interval: interval('interval'),
+	jsonb: jsonb('jsonb'),
+	numeric: numeric('numeric'),
+	numericNum: numeric('numeric_num', {
+		mode: 'number',
+	}),
+	numericBig: numeric('numeric_big', {
+		mode: 'bigint',
+	}),
+	real: real('real'),
+	float: float('float'),
+	smallint: smallint('smallint'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampTz: timestamp('timestamp_tz', {
+		mode: 'date',
+		withTimezone: true,
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	timestampTzStr: timestamp('timestamp_tz_str', {
+		mode: 'string',
+		withTimezone: true,
+	}),
+	uuid: uuid('uuid'),
+	varchar: varchar('varchar'),
+	arrint: int4('arrint').array(),
+	arrbigint53: bigint('arrbigint53', {
+		mode: 'number',
+	}).array(),
+	arrbigint64: bigint('arrbigint64', {
+		mode: 'bigint',
+	}).array(),
+	arrbool: bool('arrbool').array(),
+	arrboolean: boolean('arrboolean').array(),
+	arrchar: char('arrchar').array(),
+	arrstring: string('arrstring').array(),
+	arrdate: date('arrdate', {
+		mode: 'date',
+	}).array(),
+	arrdateStr: date('arrdate_str', {
+		mode: 'string',
+	}).array(),
+	arrdouble: doublePrecision('arrdouble').array(),
+	arrfloat: float('arrfloat').array(),
+	arrenum: en('arrenum').array(),
+	arrinet: inet('arrinet').array(),
+	arrinterval: interval('arrinterval').array(),
+	arrnumeric: numeric('arrnumeric').array(),
+	arrnumericNum: numeric('arrnumeric_num', {
+		mode: 'number',
+	}).array(),
+	arrnumericBig: numeric('arrnumeric_big', {
+		mode: 'bigint',
+	}).array(),
+	arrreal: real('arrreal').array(),
+	arrsmallint: smallint('arrsmallint').array(),
+	arrtext: text('arrtext').array(),
+	arrtime: time('arrtime').array(),
+	arrtimestamp: timestamp('arrtimestamp', {
+		mode: 'date',
+	}).array(),
+	arrtimestampTz: timestamp('arrtimestamp_tz', {
+		mode: 'date',
+		withTimezone: true,
+	}).array(),
+	arrtimestampStr: timestamp('arrtimestamp_str', {
+		mode: 'string',
+	}).array(),
+	arrtimestampTzStr: timestamp('arrtimestamp_tz_str', {
+		mode: 'string',
+		withTimezone: true,
+	}).array(),
+	arruuid: uuid('arruuid').array(),
+	arrvarchar: varchar('arrvarchar').array(),
+	bit: bit('bit'),
+	varbit: varbit('varbit'),
+	arrbit: bit('arrbit').array(),
+	arrvarbit: varbit('arrvarbit').array(),
+});
+
+export const usersTable = cockroachTable('users', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	verified: bool('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true })
+		.notNull()
+		.defaultNow(),
+});
+
+const usersOnUpdate = cockroachTable('users_on_update', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	updateCounter: int4('update_counter')
+		.default(sql`1`)
+		.$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: timestamp('updated_at', { mode: 'date', precision: 3 }).$onUpdate(
+		() => new Date(),
+	),
+	alwaysNull: text('always_null')
+		.$type<string | null>()
+		.$onUpdate(() => null),
+	// uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper("name")`),
+});
+
+const citiesTable = cockroachTable('cities', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	state: char('state', { length: 2 }),
+});
+
+const cities2Table = cockroachTable('cities', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+});
+
+const users2Table = cockroachTable('users2', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	cityId: int4('city_id').references(() => citiesTable.id),
+});
+
+const coursesTable = cockroachTable('courses', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	categoryId: int4('category_id').references(() => courseCategoriesTable.id),
+});
+
+const courseCategoriesTable = cockroachTable('course_categories', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+});
+
+const orders = cockroachTable('orders', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	region: text('region').notNull(),
+	product: text('product')
+		.notNull()
+		.$default(() => 'random_string'),
+	amount: int4('amount').notNull(),
+	quantity: int4('quantity').notNull(),
+});
+
+const network = cockroachTable('network_table', {
+	inet: inet('inet').notNull(),
+});
+
+const salEmp = cockroachTable('sal_emp', {
+	name: text('name'),
+	payByQuarter: int4('pay_by_quarter').array(),
+});
+
+export const usersMigratorTable = cockroachTable('users12', {
+	id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+// To test aggregate functions
+const aggregateTable = cockroachTable('aggregate_table', {
+	id: int4('id').notNull().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	a: int4('a'),
+	b: int4('b'),
+	c: int4('c'),
+	nullOnly: int4('null_only'),
+});
+
+// To test another schema and multischema
+export const mySchema = cockroachSchema('mySchema');
+
+export const usersMySchemaTable = mySchema.table('users', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	verified: bool('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true })
+		.notNull()
+		.defaultNow(),
+});
+
+const citiesMySchemaTable = mySchema.table('cities', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	state: char('state', { length: 2 }),
+});
+
+const users2MySchemaTable = mySchema.table('users2', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	name: text('name').notNull(),
+	cityId: int4('city_id').references(() => citiesTable.id),
+});
+
+const jsonTestTable = cockroachTable('jsontest', {
+	id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+	jsonb: jsonb('jsonb').$type<{ string: string; number: number }>(),
+});
+
+export function requireCockroachConnectionString(): string {
+	const url = process.env['COCKROACH_CONNECTION_STRING'];
+	if (!url) {
+		throw new Error(
+			'COCKROACH_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up cockroach` and export the connection string before running tests.',
+		);
+	}
+	return url;
+}
+
+export function tests() {
+	describe('common', () => {
+		beforeEach(async (ctx) => {
+			const { db } = ctx.cockroach;
+			await db.execute(sql`drop database defaultdb;`);
+			await db.execute(sql`create database defaultdb;`);
+			await db.execute(sql`create schema if not exists custom_migrations`);
+			await db.execute(sql`create schema ${mySchema}`);
+			// public users
+			await db.execute(
+				sql`
+					create table users (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						verified bool not null default false,
+						jsonb jsonb,
+						created_at timestamptz not null default now()
+					)
+				`,
+			);
+			// public cities
+			await db.execute(
+				sql`
+					create table cities (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						state char(2)
+					)
+				`,
+			);
+			// public users2
+			await db.execute(
+				sql`
+					create table users2 (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						city_id int4 references cities(id)
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table course_categories (
+						id int4 primary key generated by default as identity,
+						name text not null
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table courses (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						category_id int4 references course_categories(id)
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table orders (
+						id int4 primary key generated by default as identity,
+						region text not null,
+						product text not null,
+						amount int4 not null,
+						quantity int4 not null
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table network_table (
+						inet inet not null
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table sal_emp (
+						name text not null,
+						pay_by_quarter int4[] not null
+					)
+				`,
+			);
+			// // mySchema users
+			await db.execute(
+				sql`
+					create table ${usersMySchemaTable} (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						verified bool not null default false,
+						jsonb jsonb,
+						created_at timestamptz not null default now()
+					)
+				`,
+			);
+			// mySchema cities
+			await db.execute(
+				sql`
+					create table ${citiesMySchemaTable} (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						state char(2)
+					)
+				`,
+			);
+			// mySchema users2
+			await db.execute(
+				sql`
+					create table ${users2MySchemaTable} (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						city_id int4 references "mySchema".cities(id)
+					)
+				`,
+			);
+
+			await db.execute(
+				sql`
+					create table jsontest (
+						id int4 primary key generated by default as identity,
+						json json,
+						jsonb jsonb
+					)
+				`,
+			);
+		});
+
+		afterEach(async (ctx) => {
+			const { db } = ctx.cockroach;
+			await db.execute(sql`drop schema if exists custom_migrations cascade`);
+		});
+
+		async function setupSetOperationTest(
+			db: CockroachDatabase<CockroachQueryResultHKT>,
+		) {
+			await db.execute(sql`drop table if exists users2`);
+			await db.execute(sql`drop table if exists cities`);
+			await db.execute(
+				sql`
+					create table cities (
+						id int4 primary key generated by default as identity,
+						name text not null
+					)
+				`,
+			);
+			await db.execute(
+				sql`
+					create table users2 (
+						id int4 primary key generated by default as identity,
+						name text not null,
+						city_id int4 references cities(id)
+					)
+				`,
+			);
+
+			await db.insert(cities2Table).values([
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			await db.insert(users2Table).values([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 2 },
+				{ id: 3, name: 'Jack', cityId: 3 },
+				{ id: 4, name: 'Peter', cityId: 3 },
+				{ id: 5, name: 'Ben', cityId: 2 },
+				{ id: 6, name: 'Jill', cityId: 1 },
+				{ id: 7, name: 'Mary', cityId: 2 },
+				{ id: 8, name: 'Sally', cityId: 1 },
+			]);
+		}
+
+		async function setupAggregateFunctionsTest(
+			db: CockroachDatabase<CockroachQueryResultHKT>,
+		) {
+			await db.execute(sql`drop table if exists "aggregate_table"`);
+			await db.execute(
+				sql`
+					create table "aggregate_table" (
+						"id" int4 not null generated by default as identity,
+						"name" text not null,
+						"a" int4,
+						"b" int4,
+						"c" int4,
+						"null_only" int4
+					);
+				`,
+			);
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', a: 5, b: 10, c: 20 },
+				{ name: 'value 1', a: 5, b: 20, c: 30 },
+				{ name: 'value 2', a: 10, b: 50, c: 60 },
+				{ name: 'value 3', a: 20, b: 20, c: null },
+				{ name: 'value 4', a: null, b: 90, c: 120 },
+				{ name: 'value 5', a: 80, b: 10, c: null },
+				{ name: 'value 6', a: null, b: null, c: 150 },
+			]);
+		}
+
+		test('table configs: unique third param', async () => {
+			const cities1Table = cockroachTable(
+				'cities1',
+				{
+					id: int4('id').primaryKey(),
+					name: text('name').notNull(),
+					state: char('state', { length: 2 }),
+				},
+				(t) => [
+					unique('custom_name').on(t.name, t.state),
+					unique('custom_name1').on(t.name, t.state),
+				],
+			);
+
+			const tableConfig = getTableConfig(cities1Table);
+
+			expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+			expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
+			expect(
+				tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name),
+			).toEqual(['name', 'state']);
+
+			expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
+			expect(
+				tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name),
+			).toEqual(['name', 'state']);
+		});
+
+		test('table configs: unique in column', async () => {
+			const cities1Table = cockroachTable('cities1', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull().unique(),
+				state: char('state', { length: 2 }).unique('custom'),
+				field: char('field', { length: 2 }).unique('custom_field'),
+			});
+
+			const tableConfig = getTableConfig(cities1Table);
+
+			const columnName = tableConfig.columns.find((it) => it.name === 'name');
+
+			expect(columnName?.uniqueName).toBe(undefined);
+			expect(columnName?.isUnique).toBe(true);
+
+			const columnState = tableConfig.columns.find((it) => it.name === 'state');
+			expect(columnState?.uniqueName).toBe('custom');
+			expect(columnState?.isUnique).toBe(true);
+
+			const columnField = tableConfig.columns.find((it) => it.name === 'field');
+			expect(columnField?.uniqueName).toBe('custom_field');
+			expect(columnField?.isUnique).toBe(true);
+			expect(columnField?.uniqueType).toBe(undefined);
+		});
+
+		test('table config: foreign keys name', async () => {
+			const table = cockroachTable(
+				'cities',
+				{
+					id: int4('id'),
+					name: text('name').notNull(),
+					state: text('state'),
+				},
+				(t) => [
+					foreignKey({
+						foreignColumns: [t.id],
+						columns: [t.id],
+						name: 'custom_fk',
+					}),
+				],
+			);
+
+			const tableConfig = getTableConfig(table);
+
+			expect(tableConfig.foreignKeys).toHaveLength(1);
+			expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
+		});
+
+		test('table config: primary keys name', async () => {
+			const table = cockroachTable(
+				'cities',
+				{
+					id: int4('id'),
+					name: text('name').notNull(),
+					state: text('state'),
+				},
+				(t) => [primaryKey({ columns: [t.id, t.name], name: 'custom_pk' })],
+			);
+
+			const tableConfig = getTableConfig(table);
+
+			expect(tableConfig.primaryKeys).toHaveLength(1);
+			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
+		});
+
+		test('select all fields', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const now = Date.now();
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const result = await db.select().from(usersTable);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('select sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('select typed sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			const users = await db
+				.select({
+					name: sql<string>`upper(${usersTable.name})`,
+				})
+				.from(usersTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('select with empty array in inArray', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(inArray(usersTable.id, []));
+
+			expect(result).toEqual([]);
+		});
+
+		test('select with empty array in notInArray', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(notInArray(usersTable.id, []));
+
+			expect(result).toEqual([
+				{ name: 'JOHN' },
+				{ name: 'JANE' },
+				{ name: 'JANE' },
+			]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4878
+		test.concurrent('.where with isNull in it', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const table = cockroachTable('table_where_is_null', {
+				col1: boolean(),
+				col2: text(),
+			});
+
+			await db.execute(sql`drop table if exists table_where_is_null;`);
+			await db.execute(
+				sql`create table table_where_is_null (col1 boolean, col2 text);`,
+			);
+			await db
+				.insert(table)
+				.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+			const query = db
+				.select()
+				.from(table)
+				.where(eq(table.col1, isNull(table.col2)));
+			expect(query.toSQL()).toStrictEqual({
+				sql:
+					'select "col1", "col2" from "table_where_is_null" where "table_where_is_null"."col1" = ("table_where_is_null"."col2" is null)',
+				params: [],
+			});
+			const res = await query;
+			expect(res).toStrictEqual([
+				{ col1: true, col2: null },
+				{ col1: false, col2: 'qwerty' },
+			]);
+		});
+
+		test('$default function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const insertedOrder = await db
+				.insert(orders)
+				.values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 })
+				.returning();
+			const selectedOrder = await db.select().from(orders);
+
+			expect(insertedOrder).toEqual([
+				{
+					id: 1,
+					amount: 1,
+					quantity: 1,
+					region: 'Ukraine',
+					product: 'random_string',
+				},
+			]);
+
+			expect(selectedOrder).toEqual([
+				{
+					id: 1,
+					amount: 1,
+					quantity: 1,
+					region: 'Ukraine',
+					product: 'random_string',
+				},
+			]);
+		});
+
+		test('select distinct', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const usersDistinctTable = cockroachTable('users_distinct', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+				age: int4('age').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+			await db.execute(
+				sql`create table ${usersDistinctTable} (id int4, name text, age int4)`,
+			);
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 2, name: 'John', age: 25 },
+				{ id: 1, name: 'Jane', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+			]);
+			const users1 = await db
+				.selectDistinct()
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+			const users2 = await db
+				.selectDistinctOn([usersDistinctTable.id])
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id);
+			const users3 = await db
+				.selectDistinctOn([usersDistinctTable.name], {
+					name: usersDistinctTable.name,
+				})
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.name);
+			const users4 = await db
+				.selectDistinctOn([usersDistinctTable.id, usersDistinctTable.age])
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.age);
+
+			await db.execute(sql`drop table ${usersDistinctTable}`);
+
+			expect(users1).toEqual([
+				{ id: 1, name: 'Jane', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 2, name: 'John', age: 25 },
+			]);
+
+			expect(users2).toHaveLength(2);
+			expect(users2[0]?.id).toBe(1);
+			expect(users2[1]?.id).toBe(2);
+
+			expect(users3).toHaveLength(2);
+			expect(users3[0]?.name).toBe('Jane');
+			expect(users3[1]?.name).toBe('John');
+
+			expect(users4).toEqual([
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+				{ id: 2, name: 'John', age: 25 },
+			]);
+		});
+
+		test('insert returning sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = await db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				});
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('delete returning sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				});
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('update returning sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				});
+
+			expect(users).toEqual([{ name: 'JANE' }]);
+		});
+
+		test('update with returning all fields', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const now = Date.now();
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning();
+
+			expect(users[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(users).toEqual([
+				{
+					id: 1,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: users[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('update with returning partial', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				});
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+		});
+
+		test('delete with returning all fields', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const now = Date.now();
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning();
+
+			expect(users[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(users).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: users[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('delete with returning partial', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				});
+
+			expect(users).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('insert + select', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const result = await db.select().from(usersTable);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+
+			await db.insert(usersTable).values({ name: 'Jane' });
+			const result2 = await db.select().from(usersTable);
+			expect(result2).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[0]!.createdAt,
+				},
+				{
+					id: 2,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[1]!.createdAt,
+				},
+			]);
+		});
+
+		test('json insert', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] });
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					jsonb: usersTable.jsonb,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+		});
+
+		test('char insert', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: citiesTable.name,
+					state: citiesTable.state,
+				})
+				.from(citiesTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Austin', state: 'TX' }]);
+		});
+
+		test('char update', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+			await db
+				.update(citiesTable)
+				.set({ name: 'Atlanta', state: 'GA' })
+				.where(eq(citiesTable.id, 1));
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: citiesTable.name,
+					state: citiesTable.state,
+				})
+				.from(citiesTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Atlanta', state: 'GA' }]);
+		});
+
+		test('char delete', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+			await db.delete(citiesTable).where(eq(citiesTable.state, 'TX'));
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: citiesTable.name,
+					state: citiesTable.state,
+				})
+				.from(citiesTable);
+
+			expect(result).toEqual([]);
+		});
+
+		test('insert with overridden default values', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John', verified: true });
+			const result = await db.select().from(usersTable);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: true,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('insert many', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				]);
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					jsonb: usersTable.jsonb,
+					verified: usersTable.verified,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test('insert many with returning', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const result = await db
+				.insert(usersTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				])
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+					jsonb: usersTable.jsonb,
+					verified: usersTable.verified,
+				});
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test('select with group by as field', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.name);
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test('select with exists', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const user = alias(usersTable, 'user');
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.where(
+					exists(
+						db
+							.select({ one: sql`1` })
+							.from(user)
+							.where(
+								and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id)),
+							),
+					),
+				);
+
+			expect(result).toEqual([{ name: 'John' }]);
+		});
+
+		test('select with group by as sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(sql`${usersTable.name}`);
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test('select with group by as sql + column', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+			expect(result).toEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+				{ name: 'Jane' },
+			]);
+		});
+
+		test('select with group by as column + sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+			expect(result).toEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+				{ name: 'Jane' },
+			]);
+		});
+
+		test('select with group by complex query', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`)
+				.orderBy(asc(usersTable.name))
+				.limit(1);
+
+			expect(result).toEqual([{ name: 'Jane' }]);
+		});
+
+		test('build query', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, usersTable.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+				params: [],
+			});
+		});
+
+		test('insert sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: sql`${'John'}` });
+			const result = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable);
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('partial join with alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const customerAlias = alias(usersTable, 'customer');
+
+			await db.insert(usersTable).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
+			const result = await db
+				.select({
+					user: {
+						id: usersTable.id,
+						name: usersTable.name,
+					},
+					customer: {
+						id: customerAlias.id,
+						name: customerAlias.name,
+					},
+				})
+				.from(usersTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(usersTable.id, 10));
+
+			expect(result).toEqual([
+				{
+					user: { id: 10, name: 'Ivan' },
+					customer: { id: 11, name: 'Hans' },
+				},
+			]);
+		});
+
+		test('full join with alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const cockroachTable = cockroachTableCreator(
+				(name) => `prefixed_${name}`,
+			);
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 primary key, name text not null)`,
+			);
+
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
+			const result = await db
+				.select()
+				.from(users)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(users.id, 10));
+
+			expect(result).toEqual([
+				{
+					users: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				},
+			]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('select from alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const cockroachTable = cockroachTableCreator(
+				(name) => `prefixed_${name}`,
+			);
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 primary key, name text not null)`,
+			);
+
+			const user = alias(users, 'user');
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
+			const result = await db
+				.select()
+				.from(user)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(user.id, 10));
+
+			expect(result).toEqual([
+				{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				},
+			]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('insert with spaces', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+			const result = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test('prepared statement', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const statement = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.prepare('statement1');
+			const result = await statement.execute();
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('nameless prepared statement', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const statement = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.prepare();
+			const result1 = await statement.execute();
+			const result2 = await statement.execute();
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('insert: placeholders on columns with encoder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const statement = db
+				.insert(usersTable)
+				.values({
+					name: 'John',
+					jsonb: sql.placeholder('jsonb'),
+				})
+				.prepare('encoder_statement');
+
+			await statement.execute({ jsonb: ['foo', 'bar'] });
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+					jsonb: usersTable.jsonb,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([{ id: 1, jsonb: ['foo', 'bar'] }]);
+		});
+
+		test('prepared statement reuse', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const stmt = db
+				.insert(usersTable)
+				.values({
+					verified: true,
+					name: sql.placeholder('name'),
+				})
+				.prepare('stmt2');
+
+			for (let i = 0; i < 10; i++) {
+				await stmt.execute({ name: `John ${i}` });
+			}
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					verified: usersTable.verified,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John 0', verified: true },
+				{ id: 2, name: 'John 1', verified: true },
+				{ id: 3, name: 'John 2', verified: true },
+				{ id: 4, name: 'John 3', verified: true },
+				{ id: 5, name: 'John 4', verified: true },
+				{ id: 6, name: 'John 5', verified: true },
+				{ id: 7, name: 'John 6', verified: true },
+				{ id: 8, name: 'John 7', verified: true },
+				{ id: 9, name: 'John 8', verified: true },
+				{ id: 10, name: 'John 9', verified: true },
+			]);
+		});
+
+		test('prepared statement with placeholder in .where', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.prepare('stmt3');
+			const result = await stmt.execute({ id: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('prepared statement with placeholder in .limit', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.limit(sql.placeholder('limit'))
+				.prepare('stmt_limit');
+
+			const result = await stmt.execute({ id: 1, limit: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+			expect(result).toHaveLength(1);
+		});
+
+		test('prepared statement with placeholder in .offset', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.offset(sql.placeholder('offset'))
+				.prepare('stmt_offset');
+
+			const result = await stmt.execute({ offset: 1 });
+
+			expect(result).toEqual([{ id: 2, name: 'John1' }]);
+		});
+
+		test('prepared statement built using $dynamic', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			function withLimitOffset(qb: any) {
+				return qb
+					.limit(sql.placeholder('limit'))
+					.offset(sql.placeholder('offset'));
+			}
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.$dynamic();
+			withLimitOffset(stmt).prepare('stmt_limit');
+
+			const result = await stmt.execute({ limit: 1, offset: 1 });
+
+			expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			expect(result).toHaveLength(1);
+		});
+
+		test('Query check: Insert all defaults in 1 row', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			const query = db.insert(users).values({}).toSQL();
+
+			expect(query).toEqual({
+				sql: 'insert into "users" ("id", "name", "state") values (default, default, default)',
+				params: [],
+			});
+		});
+
+		test('Query check: Insert all defaults in multiple rows', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').default('Dan'),
+				state: text('state').default('UA'),
+			});
+
+			const query = db.insert(users).values([{}, {}]).toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "users" ("id", "name", "state") values (default, default, default), (default, default, default)',
+				params: [],
+			});
+		});
+
+		test('Insert all defaults in 1 row', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('empty_insert_single', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 primary key generated by default as identity, name text default 'Dan', state text)`,
+			);
+
+			await db.insert(users).values({});
+
+			const res = await db.select().from(users);
+
+			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
+		});
+
+		test('Insert all defaults in multiple rows', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('empty_insert_multiple', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 primary key generated by default as identity, name text default 'Dan', state text)`,
+			);
+
+			await db.insert(users).values([{}, {}]);
+
+			const res = await db.select().from(users);
+
+			expect(res).toEqual([
+				{ id: 1, name: 'Dan', state: null },
+				{ id: 2, name: 'Dan', state: null },
+			]);
+		});
+
+		test('build query insert with onConflict do update', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
+				params: ['John', '["foo","bar"]', 'John1'],
+			});
+		});
+
+		test('build query insert with onConflict do update / multiple columns', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoUpdate({
+					target: [usersTable.id, usersTable.name],
+					set: { name: 'John1' },
+				})
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+				params: ['John', '["foo","bar"]', 'John1'],
+			});
+		});
+
+		test('build query insert with onConflict do nothing', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoNothing()
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
+				params: ['John', '["foo","bar"]'],
+			});
+		});
+
+		test('build query insert with onConflict do nothing + target', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoNothing({ target: usersTable.id })
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+				params: ['John', '["foo","bar"]'],
+			});
+		});
+
+		test('insert with onConflict do update', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John1' }]);
+		});
+
+		test('insert with onConflict do nothing', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoNothing();
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('insert with onConflict do nothing + target', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoNothing({ target: usersTable.id });
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('left join (flat object fields)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+				})
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{ userId: 1, userName: 'John', cityId, cityName: 'Paris' },
+				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+			]);
+		});
+
+		test('left join (grouped fields)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select({
+					id: users2Table.id,
+					user: {
+						name: users2Table.name,
+						nameUpper: sql<string>`upper(${users2Table.name})`,
+					},
+					city: {
+						id: citiesTable.id,
+						name: citiesTable.name,
+						nameUpper: sql<string>`upper(${citiesTable.name})`,
+					},
+				})
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{
+					id: 1,
+					user: { name: 'John', nameUpper: 'JOHN' },
+					city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
+				},
+				{
+					id: 2,
+					user: { name: 'Jane', nameUpper: 'JANE' },
+					city: null,
+				},
+			]);
+		});
+
+		test('left join (all fields)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select()
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{
+					users2: {
+						id: 1,
+						name: 'John',
+						cityId,
+					},
+					cities: {
+						id: cityId,
+						name: 'Paris',
+						state: null,
+					},
+				},
+				{
+					users2: {
+						id: 2,
+						name: 'Jane',
+						cityId: null,
+					},
+					cities: null,
+				},
+			]);
+		});
+
+		test('join subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(courseCategoriesTable)
+				.values([
+					{ name: 'Category 1' },
+					{ name: 'Category 2' },
+					{ name: 'Category 3' },
+					{ name: 'Category 4' },
+				]);
+
+			await db.insert(coursesTable).values([
+				{ name: 'Development', categoryId: 2 },
+				{ name: 'IT & Software', categoryId: 3 },
+				{ name: 'Marketing', categoryId: 4 },
+				{ name: 'Design', categoryId: 1 },
+			]);
+
+			const sq2 = db
+				.select({
+					categoryId: courseCategoriesTable.id,
+					category: courseCategoriesTable.name,
+					total: sql<number>`count(${courseCategoriesTable.id})`,
+				})
+				.from(courseCategoriesTable)
+				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+				.as('sq2');
+
+			const res = await db
+				.select({
+					courseName: coursesTable.name,
+					categoryId: sq2.categoryId,
+				})
+				.from(coursesTable)
+				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+				.orderBy(coursesTable.name);
+
+			expect(res).toEqual([
+				{ courseName: 'Design', categoryId: 1 },
+				{ courseName: 'Development', categoryId: 2 },
+				{ courseName: 'IT & Software', categoryId: 3 },
+				{ courseName: 'Marketing', categoryId: 4 },
+			]);
+		});
+
+		test('with ... select', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const regionalSales = db.$with('regional_sales').as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<string>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+			const topRegions = db.$with('top_regions').as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db
+								.select({ sales: sql`sum(${regionalSales.totalSales})/10` })
+								.from(regionalSales),
+						),
+					),
+			);
+
+			const result1 = await db
+				.with(regionalSales, topRegions)
+				.select({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`sum(${orders.quantity})::int4`,
+					productSales: sql<number>`sum(${orders.amount})::int4`,
+				})
+				.from(orders)
+				.where(
+					inArray(
+						orders.region,
+						db.select({ region: topRegions.region }).from(topRegions),
+					),
+				)
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product);
+			const result2 = await db
+				.with(regionalSales, topRegions)
+				.selectDistinct({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`sum(${orders.quantity})::int4`,
+					productSales: sql<number>`sum(${orders.amount})::int4`,
+				})
+				.from(orders)
+				.where(
+					inArray(
+						orders.region,
+						db.select({ region: topRegions.region }).from(topRegions),
+					),
+				)
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product);
+			const result3 = await db
+				.with(regionalSales, topRegions)
+				.selectDistinctOn([orders.region], {
+					region: orders.region,
+					productUnits: sql<string>`sum(${orders.quantity})::int4`,
+					productSales: sql<string>`sum(${orders.amount})::int4`.mapWith(
+						Number,
+					),
+				})
+				.from(orders)
+				.where(
+					inArray(
+						orders.region,
+						db.select({ region: topRegions.region }).from(topRegions),
+					),
+				)
+				.groupBy(orders.region)
+				.orderBy(orders.region);
+
+			expect(result1).toEqual([
+				{
+					region: 'Europe',
+					product: 'A',
+					productUnits: 3,
+					productSales: 30,
+				},
+				{
+					region: 'Europe',
+					product: 'B',
+					productUnits: 5,
+					productSales: 50,
+				},
+				{
+					region: 'US',
+					product: 'A',
+					productUnits: 7,
+					productSales: 70,
+				},
+				{
+					region: 'US',
+					product: 'B',
+					productUnits: 9,
+					productSales: 90,
+				},
+			]);
+			expect(result2).toEqual(result1);
+			expect(result3).toEqual([
+				{
+					region: 'Europe',
+					productUnits: 8,
+					productSales: 80,
+				},
+				{
+					region: 'US',
+					productUnits: 16,
+					productSales: 160,
+				},
+			]);
+		});
+
+		test('with ... update', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const products = cockroachTable('products', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				price: numeric('price').notNull(),
+				cheap: bool('cheap').notNull().default(false),
+			});
+
+			await db.execute(sql`drop table if exists ${products}`);
+			await db.execute(sql`
+				create table ${products} (
+					id int4 primary key generated by default as identity,
+					price numeric not null,
+					cheap bool not null default false
+				)
+			`);
+
+			await db
+				.insert(products)
+				.values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
+
+			const averagePrice = db.$with('average_price').as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+			const result = await db
+				.with(averagePrice)
+				.update(products)
+				.set({
+					cheap: true,
+				})
+				.where(lt(products.price, sql`(select * from ${averagePrice})`))
+				.returning({
+					id: products.id,
+				});
+
+			expect(result).toEqual([{ id: 1 }, { id: 4 }, { id: 5 }]);
+		});
+
+		test('with ... insert', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				username: text('username').notNull(),
+				admin: bool('admin').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (username text not null, admin bool not null default false)`,
+			);
+
+			const userCount = db.$with('user_count').as(
+				db
+					.select({
+						value: sql`count(*)`.as('value'),
+					})
+					.from(users),
+			);
+
+			const result = await db
+				.with(userCount)
+				.insert(users)
+				.values([
+					{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+				])
+				.returning({
+					admin: users.admin,
+				});
+
+			expect(result).toEqual([{ admin: true }]);
+		});
+
+		test('with ... delete', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const averageAmount = db.$with('average_amount').as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+			const result = await db
+				.with(averageAmount)
+				.delete(orders)
+				.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+				.returning({
+					id: orders.id,
+				});
+
+			expect(result).toEqual([{ id: 6 }, { id: 7 }, { id: 8 }]);
+		});
+
+		test('select from subquery sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					name: sql<string>`${users2Table.name} || ' modified'`.as('name'),
+				})
+				.from(users2Table)
+				.as('sq');
+
+			const res = await db.select({ name: sq.name }).from(sq);
+
+			expect(res).toEqual([
+				{ name: 'John modified' },
+				{ name: 'Jane modified' },
+			]);
+		});
+
+		test('select a field without joining its table', (ctx) => {
+			const { db } = ctx.cockroach;
+
+			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare('query')).toThrowError();
+		});
+
+		test('select all fields from subquery without alias', (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const sq = db
+				.$with('sq')
+				.as(
+					db
+						.select({ name: sql<string>`upper(${users2Table.name})` })
+						.from(users2Table),
+				);
+
+			expect(() => db.select().from(sq).prepare('query')).toThrowError();
+		});
+
+		test('sql.Aliased in cte', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_109_sqla', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`DROP TABLE IF EXISTS ${users}`);
+			await db.execute(sql`CREATE TABLE ${users} (
+				id INT4 PRIMARY KEY,
+				name TEXT NOT NULL
+			)`);
+			await db.insert(users).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			const sq1 = db.$with('sq1').as((qb) =>
+				qb
+					.select({
+						aliased: sql`count(*)`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+			const sq2 = db.$with('sq2').as((qb) =>
+				qb
+					.select({
+						aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+
+			const result = await db
+				.with(sq1, sq2)
+				.select({
+					count: sq1.aliased,
+					sum: sq2.aliased,
+				})
+				.from(sq1)
+				.crossJoin(sq2);
+
+			expect(result).toEqual([{ count: 2, sum: 3 }]);
+
+			const result2 = await db
+				.with(sq1)
+				.select({
+					count: sq1.aliased,
+				})
+				.from(sq1)
+				.groupBy(sq1.aliased)
+				.orderBy(sq1.aliased);
+
+			expect(result2).toEqual([{ count: 2 }]);
+		});
+
+		test('select count()', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+			expect(res).toEqual([{ count: '2' }]);
+		});
+
+		test('select count w/ custom mapper', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			function count(value: CockroachColumn | SQLWrapper): SQL<number>;
+			function count(
+				value: CockroachColumn | SQLWrapper,
+				alias: string,
+			): SQL.Aliased<number>;
+			function count(
+				value: CockroachColumn | SQLWrapper,
+				alias?: string,
+			): SQL<number> | SQL.Aliased<number> {
+				const result = sql`count(${value})`.mapWith(Number);
+				if (!alias) {
+					return result;
+				}
+				return result.as(alias);
+			}
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const res = await db.select({ count: count(sql`*`) }).from(usersTable);
+
+			expect(res).toEqual([{ count: 2 }]);
+		});
+
+		test('network types', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const value: typeof network.$inferSelect = {
+				inet: '127.0.0.1',
+			};
+
+			await db.insert(network).values(value);
+
+			const res = await db.select().from(network);
+
+			expect(res).toEqual([value]);
+		});
+
+		test('array types', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const values: (typeof salEmp.$inferSelect)[] = [
+				{
+					name: 'John',
+					payByQuarter: [10000, 10000, 10000, 10000],
+				},
+				{
+					name: 'Carol',
+					payByQuarter: [20000, 25000, 25000, 25000],
+				},
+			];
+
+			await db.insert(salEmp).values(values);
+
+			const res = await db.select().from(salEmp);
+
+			expect(res).toEqual(values);
+		});
+
+		test('select for ...', (ctx) => {
+			const { db } = ctx.cockroach;
+
+			{
+				const query = db.select().from(users2Table).for('update').toSQL();
+
+				expect(query.sql).toMatch(/ for update$/);
+			}
+
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('update', { of: [users2Table, coursesTable] })
+					.toSQL();
+
+				expect(query.sql).toMatch(/ for update of "users2", "courses"$/);
+			}
+
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('no key update', { of: users2Table })
+					.toSQL();
+
+				expect(query.sql).toMatch(/for no key update of "users2"$/);
+			}
+
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('no key update', { of: users2Table, skipLocked: true })
+					.toSQL();
+
+				expect(query.sql).toMatch(
+					/ for no key update of "users2" skip locked$/,
+				);
+			}
+
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('share', { of: users2Table, noWait: true })
+					.toSQL();
+
+				expect(query.sql).toMatch(/for share of "users2" nowait$/);
+			}
+		});
+
+		test('having', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{
+					name: 'Jack',
+					cityId: 2,
+				},
+			]);
+
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+					usersCount: sql<number>`count(${users2Table.id})::int4`.as(
+						'users_count',
+					),
+				})
+				.from(citiesTable)
+				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+				.where(({ name }) => sql`length(${name}) >= 3`)
+				.groupBy(citiesTable.id)
+				.having(({ usersCount }) => sql`${usersCount} > 0`)
+				.orderBy(({ name }) => name);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'LONDON',
+					usersCount: 2,
+				},
+				{
+					id: 2,
+					name: 'PARIS',
+					usersCount: 1,
+				},
+			]);
+		});
+
+		test('view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const newYorkers1 = cockroachView('new_yorkers').as((qb) =>
+				qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+			);
+
+			const newYorkers2 = cockroachView('new_yorkers', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			}).as(
+				sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`,
+			);
+
+			const newYorkers3 = cockroachView('new_yorkers', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			}).existing();
+
+			await db.execute(
+				sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`,
+			);
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop view ${newYorkers1}`);
+		});
+
+		// NEXT
+		test('materialized view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const newYorkers1 = cockroachMaterializedView('new_yorkers').as((qb) =>
+				qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+			);
+
+			const newYorkers2 = cockroachMaterializedView('new_yorkers', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			}).as(
+				sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`,
+			);
+
+			const newYorkers3 = cockroachMaterializedView('new_yorkers', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			}).existing();
+
+			await db.execute(
+				sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`,
+			);
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([]);
+			}
+
+			await db.refreshMaterializedView(newYorkers1);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop materialized view ${newYorkers1}`);
+		});
+
+		test('select from existing view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const schema = cockroachSchema('test_schema');
+
+			const newYorkers = schema
+				.view('new_yorkers', {
+					id: int4('id').notNull(),
+				})
+				.existing();
+
+			await db.execute(sql`drop schema if exists ${schema} cascade`);
+			await db.execute(sql`create schema ${schema}`);
+			await db.execute(
+				sql`create view ${newYorkers} as select id from ${usersTable}`,
+			);
+
+			await db.insert(usersTable).values({ id: 100, name: 'John' });
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+				})
+				.from(usersTable)
+				.innerJoin(newYorkers, eq(newYorkers.id, usersTable.id));
+
+			expect(result).toEqual([{ id: 100 }]);
+		});
+
+		test('select from raw sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const result = await db
+				.select({
+					id: sql<string>`id`,
+					name: sql<string>`name`,
+				})
+				.from(sql`(select 1 as id, 'John' as name) as users`);
+
+			Expect<Equal<{ id: string; name: string }[], typeof result>>;
+			expect(result).toEqual([{ id: '1', name: 'John' }]);
+		});
+
+		test('select from raw sql with joins', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const result = await db
+				.select({
+					id: sql<string>`users.id`,
+					name: sql<string>`users.name`,
+					userCity: sql<string>`users.city`,
+					cityName: sql<string>`cities.name`,
+				})
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
+				.leftJoin(
+					sql`(select 1 as id, 'Paris' as name) as cities`,
+					sql`cities.id = users.id`,
+				);
+
+			Expect<
+				Equal<
+					{ id: string; name: string; userCity: string; cityName: string }[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{ id: '1', name: 'John', userCity: 'New York', cityName: 'Paris' },
+			]);
+		});
+
+		test('join on aliased sql from select', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const result = await db
+				.select({
+					userId: sql<string>`users.id`.as('userId'),
+					name: sql<string>`users.name`,
+					userCity: sql<string>`users.city`,
+					cityId: sql<number>`cities.id`.as('cityId'),
+					cityName: sql<string>`cities.name`,
+				})
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
+				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+			Expect<
+				Equal<
+					{
+						userId: string;
+						name: string;
+						userCity: string;
+						cityId: number;
+						cityName: string;
+					}[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{
+					userId: '1',
+					name: 'John',
+					userCity: 'New York',
+					cityId: '1',
+					cityName: 'Paris',
+				},
+			]);
+		});
+
+		test('join on aliased sql from with clause', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = db.$with('users').as(
+				db
+					.select({
+						id: sql<string>`id`.as('userId'),
+						name: sql<string>`name`.as('userName'),
+						city: sql<string>`city`.as('city'),
+					})
+					.from(
+						sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+					),
+			);
+
+			const cities = db.$with('cities').as(
+				db
+					.select({
+						id: sql<string>`id`.as('cityId'),
+						name: sql<string>`name`.as('cityName'),
+					})
+					.from(sql`(select 1 as id, 'Paris' as name) as cities`),
+			);
+
+			const result = await db
+				.with(users, cities)
+				.select({
+					userId: users.id,
+					name: users.name,
+					userCity: users.city,
+					cityId: cities.id,
+					cityName: cities.name,
+				})
+				.from(users)
+				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+			Expect<
+				Equal<
+					{
+						userId: string;
+						name: string;
+						userCity: string;
+						cityId: string;
+						cityName: string;
+					}[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{
+					userId: '1',
+					name: 'John',
+					userCity: 'New York',
+					cityId: '1',
+					cityName: 'Paris',
+				},
+			]);
+		});
+
+		test('prefixed table', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const cockroachTable = cockroachTableCreator(
+				(name) => `myprefix_${name}`,
+			);
+
+			const users = cockroachTable('test_prefixed_table_with_unique_name', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table myprefix_test_prefixed_table_with_unique_name (id int4 not null primary key, name text not null)`,
+			);
+
+			await db.insert(users).values({ id: 1, name: 'John' });
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('select from enum as ts enum', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			enum Muscle {
+				abdominals = 'abdominals',
+				hamstrings = 'hamstrings',
+				adductors = 'adductors',
+				quadriceps = 'quadriceps',
+				biceps = 'biceps',
+				shoulders = 'shoulders',
+				chest = 'chest',
+				middle_back = 'middle_back',
+				calves = 'calves',
+				glutes = 'glutes',
+				lower_back = 'lower_back',
+				lats = 'lats',
+				triceps = 'triceps',
+				traps = 'traps',
+				forearms = 'forearms',
+				neck = 'neck',
+				abductors = 'abductors',
+			}
+
+			enum Force {
+				isometric = 'isometric',
+				isotonic = 'isotonic',
+				isokinetic = 'isokinetic',
+			}
+
+			enum Level {
+				beginner = 'beginner',
+				intermediate = 'intermediate',
+				advanced = 'advanced',
+			}
+
+			enum Mechanic {
+				compound = 'compound',
+				isolation = 'isolation',
+			}
+
+			enum Equipment {
+				barbell = 'barbell',
+				dumbbell = 'dumbbell',
+				bodyweight = 'bodyweight',
+				machine = 'machine',
+				cable = 'cable',
+				kettlebell = 'kettlebell',
+			}
+
+			enum Category {
+				upper_body = 'upper_body',
+				lower_body = 'lower_body',
+				full_body = 'full_body',
+			}
+
+			const muscleEnum = cockroachEnum('muscle', Muscle);
+
+			const forceEnum = cockroachEnum('force', Force);
+
+			const levelEnum = cockroachEnum('level', Level);
+
+			const mechanicEnum = cockroachEnum('mechanic', Mechanic);
+
+			const equipmentEnum = cockroachEnum('equipment', Equipment);
+
+			const categoryEnum = cockroachEnum('category', Category);
+
+			const exercises = cockroachTable('exercises', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: varchar('name').notNull(),
+				force: forceEnum('force'),
+				level: levelEnum('level'),
+				mechanic: mechanicEnum('mechanic'),
+				equipment: equipmentEnum('equipment'),
+				instructions: text('instructions'),
+				category: categoryEnum('category'),
+				primaryMuscles: muscleEnum('primary_muscles').array(),
+				secondaryMuscles: muscleEnum('secondary_muscles').array(),
+				createdAt: timestamp('created_at')
+					.notNull()
+					.default(sql`now()`),
+				updatedAt: timestamp('updated_at')
+					.notNull()
+					.default(sql`now()`),
+			});
+
+			await db.execute(sql`drop table if exists ${exercises}`);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(muscleEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(forceEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(levelEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(mechanicEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(equipmentEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(categoryEnum.enumName)}`,
+			);
+
+			await db.execute(
+				sql`create type ${
+					sql.identifier(
+						muscleEnum.enumName,
+					)
+				} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(mechanicEnum.enumName)} as enum ('compound', 'isolation')`,
+			);
+			await db.execute(
+				sql`create type ${
+					sql.identifier(
+						equipmentEnum.enumName,
+					)
+				} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`,
+			);
+			await db.execute(sql`
+				create table ${exercises} (
+					id int4 primary key generated by default as identity,
+					name varchar not null,
+					force force,
+					level level,
+					mechanic mechanic,
+					equipment equipment,
+					instructions text,
+					category category,
+					primary_muscles muscle[],
+					secondary_muscles muscle[],
+					created_at timestamp not null default now(),
+					updated_at timestamp not null default now()
+				)
+			`);
+
+			await db.insert(exercises).values({
+				name: 'Bench Press',
+				force: Force.isotonic,
+				level: Level.beginner,
+				mechanic: Mechanic.compound,
+				equipment: Equipment.barbell,
+				instructions:
+					'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+				category: Category.upper_body,
+				primaryMuscles: [Muscle.chest, Muscle.triceps],
+				secondaryMuscles: [Muscle.shoulders, Muscle.traps],
+			});
+
+			const result = await db.select().from(exercises);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'Bench Press',
+					force: 'isotonic',
+					level: 'beginner',
+					mechanic: 'compound',
+					equipment: 'barbell',
+					instructions:
+						'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+					category: 'upper_body',
+					primaryMuscles: ['chest', 'triceps'],
+					secondaryMuscles: ['shoulders', 'traps'],
+					createdAt: result[0]!.createdAt,
+					updatedAt: result[0]!.updatedAt,
+				},
+			]);
+
+			await db.execute(sql`drop table ${exercises}`);
+			await db.execute(sql`drop type ${sql.identifier(muscleEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(forceEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(levelEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(mechanicEnum.enumName)}`);
+			await db.execute(
+				sql`drop type ${sql.identifier(equipmentEnum.enumName)}`,
+			);
+			await db.execute(sql`drop type ${sql.identifier(categoryEnum.enumName)}`);
+		});
+
+		test('select from enum', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const muscleEnum = cockroachEnum('muscle', [
+				'abdominals',
+				'hamstrings',
+				'adductors',
+				'quadriceps',
+				'biceps',
+				'shoulders',
+				'chest',
+				'middle_back',
+				'calves',
+				'glutes',
+				'lower_back',
+				'lats',
+				'triceps',
+				'traps',
+				'forearms',
+				'neck',
+				'abductors',
+			]);
+
+			const forceEnum = cockroachEnum('force', [
+				'isometric',
+				'isotonic',
+				'isokinetic',
+			]);
+
+			const levelEnum = cockroachEnum('level', [
+				'beginner',
+				'intermediate',
+				'advanced',
+			]);
+
+			const mechanicEnum = cockroachEnum('mechanic', ['compound', 'isolation']);
+
+			const equipmentEnum = cockroachEnum('equipment', [
+				'barbell',
+				'dumbbell',
+				'bodyweight',
+				'machine',
+				'cable',
+				'kettlebell',
+			]);
+
+			const categoryEnum = cockroachEnum('category', [
+				'upper_body',
+				'lower_body',
+				'full_body',
+			]);
+
+			const exercises = cockroachTable('exercises', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: varchar('name').notNull(),
+				force: forceEnum('force'),
+				level: levelEnum('level'),
+				mechanic: mechanicEnum('mechanic'),
+				equipment: equipmentEnum('equipment'),
+				instructions: text('instructions'),
+				category: categoryEnum('category'),
+				primaryMuscles: muscleEnum('primary_muscles').array(),
+				secondaryMuscles: muscleEnum('secondary_muscles').array(),
+				createdAt: timestamp('created_at')
+					.notNull()
+					.default(sql`now()`),
+				updatedAt: timestamp('updated_at')
+					.notNull()
+					.default(sql`now()`),
+			});
+
+			await db.execute(sql`drop table if exists ${exercises}`);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(muscleEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(forceEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(levelEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(mechanicEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(equipmentEnum.enumName)}`,
+			);
+			await db.execute(
+				sql`drop type if exists ${sql.identifier(categoryEnum.enumName)}`,
+			);
+
+			await db.execute(
+				sql`create type ${
+					sql.identifier(
+						muscleEnum.enumName,
+					)
+				} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(mechanicEnum.enumName)} as enum ('compound', 'isolation')`,
+			);
+			await db.execute(
+				sql`create type ${
+					sql.identifier(
+						equipmentEnum.enumName,
+					)
+				} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`,
+			);
+			await db.execute(
+				sql`create type ${sql.identifier(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`,
+			);
+			await db.execute(sql`
+				create table ${exercises} (
+					id int4 primary key generated by default as identity,
+					name varchar not null,
+					force force,
+					level level,
+					mechanic mechanic,
+					equipment equipment,
+					instructions text,
+					category category,
+					primary_muscles muscle[],
+					secondary_muscles muscle[],
+					created_at timestamp not null default now(),
+					updated_at timestamp not null default now()
+				)
+			`);
+
+			await db.insert(exercises).values({
+				name: 'Bench Press',
+				force: 'isotonic',
+				level: 'beginner',
+				mechanic: 'compound',
+				equipment: 'barbell',
+				instructions:
+					'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+				category: 'upper_body',
+				primaryMuscles: ['chest', 'triceps'],
+				secondaryMuscles: ['shoulders', 'traps'],
+			});
+
+			const result = await db.select().from(exercises);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'Bench Press',
+					force: 'isotonic',
+					level: 'beginner',
+					mechanic: 'compound',
+					equipment: 'barbell',
+					instructions:
+						'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+					category: 'upper_body',
+					primaryMuscles: ['chest', 'triceps'],
+					secondaryMuscles: ['shoulders', 'traps'],
+					createdAt: result[0]!.createdAt,
+					updatedAt: result[0]!.updatedAt,
+				},
+			]);
+
+			await db.execute(sql`drop table ${exercises}`);
+			await db.execute(sql`drop type ${sql.identifier(muscleEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(forceEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(levelEnum.enumName)}`);
+			await db.execute(sql`drop type ${sql.identifier(mechanicEnum.enumName)}`);
+			await db.execute(
+				sql`drop type ${sql.identifier(equipmentEnum.enumName)}`,
+			);
+			await db.execute(sql`drop type ${sql.identifier(categoryEnum.enumName)}`);
+		});
+
+		test('all date and time columns', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const table = cockroachTable('all_columns', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				dateString: date('date_string', { mode: 'string' }).notNull(),
+				time: time('time', { precision: 3 }).notNull(),
+				datetime: timestamp('datetime').notNull(),
+				datetimeWTZ: timestamp('datetime_wtz', {
+					withTimezone: true,
+				}).notNull(),
+				datetimeString: timestamp('datetime_string', {
+					mode: 'string',
+				}).notNull(),
+				datetimeFullPrecision: timestamp('datetime_full_precision', {
+					precision: 6,
+					mode: 'string',
+				}).notNull(),
+				datetimeWTZString: timestamp('datetime_wtz_string', {
+					withTimezone: true,
+					mode: 'string',
+				}).notNull(),
+				interval: interval('interval').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${table}`);
+
+			await db.execute(sql`
+				create table ${table} (
+							id int4 primary key generated by default as identity,
+							date_string date not null,
+							time time(3) not null,
+							datetime timestamp not null,
+							datetime_wtz timestamp with time zone not null,
+							datetime_string timestamp not null,
+							datetime_full_precision timestamp(6) not null,
+							datetime_wtz_string timestamp with time zone not null,
+							interval interval not null
+					)
+			`);
+
+			const someDatetime = new Date('2022-01-01T00:00:00.123Z');
+			const fullPrecision = '2022-01-01T00:00:00.123456Z';
+			const someTime = '23:23:12.432';
+
+			await db.insert(table).values({
+				dateString: '2022-01-01',
+				time: someTime,
+				datetime: someDatetime,
+				datetimeWTZ: someDatetime,
+				datetimeString: '2022-01-01T00:00:00.123Z',
+				datetimeFullPrecision: fullPrecision,
+				datetimeWTZString: '2022-01-01T00:00:00.123Z',
+				interval: '1 day',
+			});
+
+			const result = await db.select().from(table);
+
+			Expect<
+				Equal<
+					{
+						id: number;
+						dateString: string;
+						time: string;
+						datetime: Date;
+						datetimeWTZ: Date;
+						datetimeString: string;
+						datetimeFullPrecision: string;
+						datetimeWTZString: string;
+						interval: string;
+					}[],
+					typeof result
+				>
+			>;
+
+			Expect<
+				Equal<
+					{
+						dateString: string;
+						time: string;
+						datetime: Date;
+						datetimeWTZ: Date;
+						datetimeString: string;
+						datetimeFullPrecision: string;
+						datetimeWTZString: string;
+						interval: string;
+						id?: number | undefined;
+					},
+					typeof table.$inferInsert
+				>
+			>;
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					dateString: '2022-01-01',
+					time: someTime,
+					datetime: someDatetime,
+					datetimeWTZ: someDatetime,
+					datetimeString: '2022-01-01 00:00:00.123',
+					datetimeFullPrecision: fullPrecision
+						.replace('T', ' ')
+						.replace('Z', ''),
+					datetimeWTZString: '2022-01-01 00:00:00.123+00',
+					interval: '1 day',
+				},
+			]);
+
+			await db.execute(sql`drop table if exists ${table}`);
+		});
+
+		test('all date and time columns with timezone second case mode date', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const table = cockroachTable('all_columns', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				timestamp: timestamp('timestamp_string', {
+					mode: 'date',
+					withTimezone: true,
+					precision: 3,
+				}).notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${table}`);
+
+			await db.execute(sql`
+				create table ${table} (
+							id int4 primary key generated by default as identity,
+							timestamp_string timestamp(3) with time zone not null
+					)
+			`);
+
+			const insertedDate = new Date();
+
+			// 1. Insert date as new date
+			await db.insert(table).values([{ timestamp: insertedDate }]);
+
+			// 2, Select as date and check that timezones are the same
+			// There is no way to check timezone in Date object, as it is always represented internally in UTC
+			const result = await db.select().from(table);
+
+			expect(result).toEqual([{ id: 1, timestamp: insertedDate }]);
+
+			// 3. Compare both dates
+			expect(insertedDate.getTime()).toBe(result[0]?.timestamp.getTime());
+
+			await db.execute(sql`drop table if exists ${table}`);
+		});
+
+		test('all date and time columns with timezone third case mode date', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const table = cockroachTable('all_columns', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				timestamp: timestamp('timestamp_string', {
+					mode: 'date',
+					withTimezone: true,
+					precision: 3,
+				}).notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${table}`);
+
+			await db.execute(sql`
+				create table ${table} (
+							id int4 primary key generated by default as identity,
+							timestamp_string timestamp(3) with time zone not null
+					)
+			`);
+
+			const insertedDate = new Date('2022-01-01 20:00:00.123-04'); // used different time zones, internally is still UTC
+			const insertedDate2 = new Date('2022-01-02 04:00:00.123+04'); // They are both the same date in different time zones
+
+			// 1. Insert date as new dates with different time zones
+			await db
+				.insert(table)
+				.values([{ timestamp: insertedDate }, { timestamp: insertedDate2 }]);
+
+			// 2, Select and compare both dates
+			const result = await db.select().from(table);
+
+			expect(result[0]?.timestamp.getTime()).toBe(
+				result[1]?.timestamp.getTime(),
+			);
+
+			await db.execute(sql`drop table if exists ${table}`);
+		});
+
+		test('orderBy with aliased column', (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.select({
+					test: sql`something`.as('test'),
+				})
+				.from(users2Table)
+				.orderBy((fields) => fields.test)
+				.toSQL();
+
+			expect(query.sql).toBe(
+				'select something as "test" from "users2" order by "test"',
+			);
+		});
+
+		test('select from sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const metricEntry = cockroachTable('metric_entry', {
+				id: cockroachUuid('id').notNull(),
+				createdAt: timestamp('created_at').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${metricEntry}`);
+			await db.execute(
+				sql`create table ${metricEntry} (id uuid not null, created_at timestamp not null)`,
+			);
+
+			const metricId = uuidV4();
+
+			const intervals = db.$with('intervals').as(
+				db
+					.select({
+						startTime: sql<string>`(date'2023-03-01'+ x * '1 day'::interval)`.as(
+							'start_time',
+						),
+						endTime: sql<string>`(date'2023-03-01'+ (x+1) *'1 day'::interval)`.as(
+							'end_time',
+						),
+					})
+					.from(sql`generate_series(0, 29, 1) as t(x)`),
+			);
+
+			const func = () =>
+				db
+					.with(intervals)
+					.select({
+						startTime: intervals.startTime,
+						endTime: intervals.endTime,
+						count: sql<number>`count(${metricEntry})`,
+					})
+					.from(metricEntry)
+					.rightJoin(
+						intervals,
+						and(
+							eq(metricEntry.id, metricId),
+							gte(metricEntry.createdAt, intervals.startTime),
+							lt(metricEntry.createdAt, intervals.endTime),
+						),
+					)
+					.groupBy(intervals.startTime, intervals.endTime)
+					.orderBy(asc(intervals.startTime));
+
+			await expect(
+				(async () => {
+					func();
+				})(),
+			).resolves.not.toThrowError();
+		});
+
+		test('timestamp timezone', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const usersTableWithAndWithoutTimezone = cockroachTable(
+				'users_test_with_and_without_timezone',
+				{
+					id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+					name: text('name').notNull(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+					updatedAt: timestamp('updated_at', { withTimezone: false })
+						.notNull()
+						.defaultNow(),
+				},
+			);
+
+			await db.execute(
+				sql`drop table if exists ${usersTableWithAndWithoutTimezone}`,
+			);
+
+			await db.execute(
+				sql`
+					create table users_test_with_and_without_timezone (
+						id int4 not null primary key generated by default as identity,
+						name text not null,
+						created_at timestamptz not null default now(),
+						updated_at timestamp not null default now()
+					)
+				`,
+			);
+
+			const date = new Date(Date.parse('2020-01-01T00:00:00+04:00'));
+
+			await db
+				.insert(usersTableWithAndWithoutTimezone)
+				.values({ name: 'With default times' });
+			await db.insert(usersTableWithAndWithoutTimezone).values({
+				name: 'Without default times',
+				createdAt: date,
+				updatedAt: date,
+			});
+			const users = await db.select().from(usersTableWithAndWithoutTimezone);
+
+			// check that the timestamps are set correctly for default times
+			expect(Math.abs(users[0]!.updatedAt.getTime() - Date.now())).toBeLessThan(
+				2000,
+			);
+			expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(
+				2000,
+			);
+
+			// check that the timestamps are set correctly for non default times
+			expect(
+				Math.abs(users[1]!.updatedAt.getTime() - date.getTime()),
+			).toBeLessThan(2000);
+			expect(
+				Math.abs(users[1]!.createdAt.getTime() - date.getTime()),
+			).toBeLessThan(2000);
+		});
+
+		test('transaction', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_transactions', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				balance: int4('balance').notNull(),
+			});
+			const products = cockroachTable('products_transactions', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				price: int4('price').notNull(),
+				stock: int4('stock').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop table if exists ${products}`);
+
+			await db.execute(
+				sql`create table users_transactions (id int4 not null primary key generated by default as identity, balance int4 not null)`,
+			);
+			await db.execute(
+				sql`create table products_transactions (id int4 not null primary key generated by default as identity, price int4 not null, stock int4 not null)`,
+			);
+
+			const user = await db
+				.insert(users)
+				.values({ balance: 100 })
+				.returning()
+				.then((rows) => rows[0]!);
+			const product = await db
+				.insert(products)
+				.values({ price: 10, stock: 10 })
+				.returning()
+				.then((rows) => rows[0]!);
+
+			await db.transaction(async (tx) => {
+				await tx
+					.update(users)
+					.set({ balance: user.balance - product.price })
+					.where(eq(users.id, user.id));
+				await tx
+					.update(products)
+					.set({ stock: product.stock - 1 })
+					.where(eq(products.id, product.id));
+			});
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, balance: 90 }]);
+
+			await db.execute(sql`drop table ${users}`);
+			await db.execute(sql`drop table ${products}`);
+		});
+
+		test('transaction rollback', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_transactions_rollback', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				balance: int4('balance').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table users_transactions_rollback (id int4 not null primary key generated by default as identity, balance int4 not null)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.transaction(async (tx) => {
+						await tx.insert(users).values({ balance: 100 });
+						tx.rollback();
+					});
+				})(),
+			).rejects.toThrowError(TransactionRollbackError);
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('nested transaction', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_nested_transactions', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				balance: int4('balance').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table users_nested_transactions (id int4 not null primary key generated by default as identity, balance int4 not null)`,
+			);
+
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 });
+
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 });
+				});
+			});
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, balance: 200 }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('nested transaction rollback', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_nested_transactions_rollback', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				balance: int4('balance').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table users_nested_transactions_rollback (id int4 not null primary key generated by default as identity, balance int4 not null)`,
+			);
+
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 });
+
+				await expect(
+					(async () => {
+						await tx.transaction(async (tx) => {
+							await tx.update(users).set({ balance: 200 });
+							tx.rollback();
+						});
+					})(),
+				).rejects.toThrowError(TransactionRollbackError);
+			});
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, balance: 100 }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('join subquery with join', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const internalStaff = cockroachTable('internal_staff', {
+				userId: int4('user_id').notNull(),
+			});
+
+			const customUser = cockroachTable('custom_user', {
+				id: int4('id').notNull(),
+			});
+
+			const ticket = cockroachTable('ticket', {
+				staffId: int4('staff_id').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${internalStaff}`);
+			await db.execute(sql`drop table if exists ${customUser}`);
+			await db.execute(sql`drop table if exists ${ticket}`);
+
+			await db.execute(
+				sql`create table internal_staff (user_id int4 not null)`,
+			);
+			await db.execute(sql`create table custom_user (id int4 not null)`);
+			await db.execute(sql`create table ticket (staff_id int4 not null)`);
+
+			await db.insert(internalStaff).values({ userId: 1 });
+			await db.insert(customUser).values({ id: 1 });
+			await db.insert(ticket).values({ staffId: 1 });
+
+			const subq = db
+				.select()
+				.from(internalStaff)
+				.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+				.as('internal_staff');
+
+			const mainQuery = await db
+				.select()
+				.from(ticket)
+				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+			expect(mainQuery).toEqual([
+				{
+					ticket: { staffId: 1 },
+					internal_staff: {
+						internal_staff: { userId: 1 },
+						custom_user: { id: 1 },
+					},
+				},
+			]);
+
+			await db.execute(sql`drop table ${internalStaff}`);
+			await db.execute(sql`drop table ${customUser}`);
+			await db.execute(sql`drop table ${ticket}`);
+		});
+
+		test('subquery with view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_subquery_view', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			});
+
+			const newYorkers = cockroachView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop view if exists ${newYorkers}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null, city_id int4 not null)`,
+			);
+			await db.execute(
+				sql`create view ${newYorkers} as select * from ${users} where city_id = 1`,
+			);
+
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 1 },
+				{ name: 'Jill', cityId: 2 },
+			]);
+
+			const sq = db.$with('sq').as(db.select().from(newYorkers));
+			const result = await db.with(sq).select().from(sq);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 3, name: 'Jack', cityId: 1 },
+			]);
+
+			await db.execute(sql`drop view ${newYorkers}`);
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('join view as subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_join_view', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			});
+
+			const newYorkers = cockroachView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop view if exists ${newYorkers}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null, city_id int4 not null)`,
+			);
+			await db.execute(
+				sql`create view ${newYorkers} as select * from ${users} where city_id = 1`,
+			);
+
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 1 },
+				{ name: 'Jill', cityId: 2 },
+			]);
+
+			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+			const result = await db
+				.select()
+				.from(users)
+				.leftJoin(sq, eq(users.id, sq.id));
+
+			expect(result).toEqual([
+				{
+					users_join_view: { id: 1, name: 'John', cityId: 1 },
+					new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+				},
+				{
+					users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+					new_yorkers_sq: null,
+				},
+				{
+					users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+					new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+				},
+				{
+					users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+					new_yorkers_sq: null,
+				},
+			]);
+
+			await db.execute(sql`drop view ${newYorkers}`);
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('table selection with single table', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null, city_id int4 not null)`,
+			);
+
+			await db.insert(users).values({ name: 'John', cityId: 1 });
+
+			const result = await db.select({ users }).from(users);
+
+			expect(result).toEqual([{ users: { id: 1, name: 'John', cityId: 1 } }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('set null to jsonb field', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				jsonb: jsonb('jsonb'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, jsonb jsonb)`,
+			);
+
+			const result = await db.insert(users).values({ jsonb: null }).returning();
+
+			expect(result).toEqual([{ id: 1, jsonb: null }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('insert undefined', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.insert(users).values({ name: undefined });
+				})(),
+			).resolves.not.toThrowError();
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('update undefined', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.update(users).set({ name: undefined });
+				})(),
+			).rejects.toThrowError();
+			await expect(
+				(async () => {
+					db.update(users).set({ name: undefined });
+				})(),
+			).rejects.toThrowError();
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test('array operators', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const posts = cockroachTable('posts', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				tags: text('tags').array(),
+			});
+
+			await db.execute(sql`drop table if exists ${posts}`);
+
+			await db.execute(
+				sql`create table ${posts} (id int4 primary key generated by default as identity, tags text[])`,
+			);
+
+			await db.insert(posts).values([
+				{
+					tags: ['ORM'],
+				},
+				{
+					tags: ['Typescript'],
+				},
+				{
+					tags: ['Typescript', 'ORM'],
+				},
+				{
+					tags: ['Typescript', 'Frontend', 'React'],
+				},
+				{
+					tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
+				},
+				{
+					tags: ['Java', 'Spring', 'OOP'],
+				},
+			]);
+
+			const contains = await db
+				.select({ id: posts.id })
+				.from(posts)
+				.where(arrayContains(posts.tags, ['Typescript', 'ORM']));
+			const contained = await db
+				.select({ id: posts.id })
+				.from(posts)
+				.where(arrayContained(posts.tags, ['Typescript', 'ORM']));
+			const overlaps = await db
+				.select({ id: posts.id })
+				.from(posts)
+				.where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']));
+			const withSubQuery = await db
+				.select({ id: posts.id })
+				.from(posts)
+				.where(
+					arrayContains(
+						posts.tags,
+						db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
+					),
+				);
+
+			expect(contains).toEqual([{ id: 3 }, { id: 5 }]);
+			expect(contained).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+			expect(overlaps).toEqual([
+				{ id: 1 },
+				{ id: 2 },
+				{ id: 3 },
+				{ id: 4 },
+				{ id: 5 },
+			]);
+			expect(withSubQuery).toEqual([{ id: 1 }, { id: 3 }, { id: 5 }]);
+		});
+
+		test('set operations (union) from query builder with subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const sq = db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table)
+				.as('sq');
+
+			const result = await db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table)
+				.union(db.select().from(sq))
+				.orderBy(asc(sql`name`))
+				.limit(2)
+				.offset(1);
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 3, name: 'Jack' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select({
+						id: cities2Table.id,
+						name: citiesTable.name,
+						name2: users2Table.name,
+					})
+						.from(cities2Table)
+						.union(
+							// @ts-expect-error
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table),
+						)
+						.orderBy(asc(sql`name`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (union) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await union(
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			)
+				.orderBy(asc(sql`name`))
+				.limit(1)
+				.offset(1);
+
+			expect(result).toHaveLength(1);
+
+			expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+			await expect(
+				(async () => {
+					union(
+						db
+							.select({ name: citiesTable.name, id: cities2Table.id })
+							.from(cities2Table)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					).orderBy(asc(sql`name`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (union all) from query builder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table)
+				.limit(2)
+				.unionAll(
+					db
+						.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.limit(2),
+				)
+				.orderBy(asc(sql`id`));
+
+			expect(result).toHaveLength(4);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'New York' },
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.limit(2)
+						.unionAll(
+							db
+								.select({ name: citiesTable.name, id: cities2Table.id })
+								.from(cities2Table)
+								.limit(2),
+						)
+						.orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (union all) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await unionAll(
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			);
+
+			expect(result).toHaveLength(3);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'New York' },
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+			]);
+
+			await expect(
+				(async () => {
+					unionAll(
+						db
+							.select({ id: cities2Table.id, name: citiesTable.name })
+							.from(cities2Table)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (intersect) from query builder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table)
+				.intersect(
+					db
+						.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.where(gt(citiesTable.id, 1)),
+				)
+				.orderBy(asc(sql`name`));
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.intersect(
+							// @ts-expect-error
+							db
+								.select({
+									id: cities2Table.id,
+									name: citiesTable.name,
+									id2: cities2Table.id,
+								})
+								.from(cities2Table)
+								.where(gt(citiesTable.id, 1)),
+						)
+						.orderBy(asc(sql`name`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (intersect) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await intersect(
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			);
+
+			expect(result).toHaveLength(0);
+
+			expect(result).toEqual([]);
+
+			await expect(
+				(async () => {
+					intersect(
+						db
+							.select({ id: cities2Table.id, name: citiesTable.name })
+							.from(cities2Table)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (intersect all) from query builder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table)
+				.limit(2)
+				.intersectAll(
+					db
+						.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.limit(2),
+				)
+				.orderBy(asc(sql`id`));
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.limit(2)
+						.intersectAll(
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(cities2Table)
+								.limit(2),
+						)
+						.orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (intersect all) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await intersectAll(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			);
+
+			expect(result).toHaveLength(1);
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+			await expect(
+				(async () => {
+					intersectAll(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (except) from query builder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await db
+				.select()
+				.from(cities2Table)
+				.except(db.select().from(cities2Table).where(gt(citiesTable.id, 1)));
+
+			expect(result).toHaveLength(1);
+
+			expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+			await expect(
+				(async () => {
+					db.select()
+						.from(cities2Table)
+						.except(
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(cities2Table)
+								.where(gt(citiesTable.id, 1)),
+						);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (except) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await except(
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table),
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			).orderBy(asc(sql`id`));
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			await expect(
+				(async () => {
+					except(
+						db
+							.select({ id: cities2Table.id, name: citiesTable.name })
+							.from(cities2Table),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(cities2Table)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					).orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (except all) from query builder', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await db
+				.select()
+				.from(cities2Table)
+				.exceptAll(
+					db
+						.select({ id: cities2Table.id, name: citiesTable.name })
+						.from(cities2Table)
+						.where(eq(citiesTable.id, 1)),
+				)
+				.orderBy(asc(sql`id`));
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select({ name: cities2Table.name, id: cities2Table.id })
+						.from(cities2Table)
+						.exceptAll(
+							db
+								.select({ id: cities2Table.id, name: citiesTable.name })
+								.from(cities2Table)
+								.where(eq(citiesTable.id, 1)),
+						)
+						.orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (except all) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await exceptAll(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(gt(users2Table.id, 7)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			)
+				.orderBy(asc(sql`id`))
+				.limit(5)
+				.offset(2);
+
+			expect(result).toHaveLength(4);
+
+			expect(result).toEqual([
+				{ id: 4, name: 'Peter' },
+				{ id: 5, name: 'Ben' },
+				{ id: 6, name: 'Jill' },
+				{ id: 7, name: 'Mary' },
+			]);
+
+			await expect(
+				(async () => {
+					exceptAll(
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(gt(users2Table.id, 7)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					).orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (mixed) from query builder with subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+			const sq = db
+				.select()
+				.from(cities2Table)
+				.where(gt(citiesTable.id, 1))
+				.as('sq');
+
+			const result = await db
+				.select()
+				.from(cities2Table)
+				.except(({ unionAll }) =>
+					unionAll(
+						db.select().from(sq),
+						db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
+					)
+				);
+
+			expect(result).toHaveLength(1);
+
+			expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+			await expect(
+				(async () => {
+					db.select()
+						.from(cities2Table)
+						.except(({ unionAll }) =>
+							unionAll(
+								db
+									.select({ name: cities2Table.name, id: cities2Table.id })
+									.from(cities2Table)
+									.where(gt(citiesTable.id, 1)),
+								db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
+							)
+						);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('set operations (mixed all) as function', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await setupSetOperationTest(db);
+
+			const result = await union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				except(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(gte(users2Table.id, 5)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 7)),
+				),
+				db.select().from(cities2Table).where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+
+			expect(result).toHaveLength(6);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+				{ id: 5, name: 'Ben' },
+				{ id: 6, name: 'Jill' },
+				{ id: 8, name: 'Sally' },
+			]);
+
+			await expect(
+				(async () => {
+					union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(gte(users2Table.id, 5)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table)
+								.where(eq(users2Table.id, 7)),
+						),
+						db.select().from(cities2Table).where(gt(citiesTable.id, 1)),
+					).orderBy(asc(sql`id`));
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test('aggregate function: count', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: count() }).from(table);
+			const result2 = await db.select({ value: count(table.a) }).from(table);
+			const result3 = await db
+				.select({ value: countDistinct(table.name) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(7);
+			expect(result2[0]?.value).toBe(5);
+			expect(result3[0]?.value).toBe(6);
+		});
+
+		test('aggregate function: avg', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: avg(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: avg(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: avgDistinct(table.b) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe('33.333333333333333333');
+			expect(result2[0]?.value).toBeNull();
+			expect(result3[0]?.value).toBe('42.500000000000000000');
+		});
+
+		test('aggregate function: sum', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: sum(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: sum(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: sumDistinct(table.b) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe('200');
+			expect(result2[0]?.value).toBeNull();
+			expect(result3[0]?.value).toBe('170');
+		});
+
+		test('aggregate function: max', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: max(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: max(table.nullOnly) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(90);
+			expect(result2[0]?.value).toBeNull();
+		});
+
+		test('aggregate function: min', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: min(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: min(table.nullOnly) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(10);
+			expect(result2[0]?.value).toBeNull();
+		});
+
+		test('array mapping and parsing', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const arrays = cockroachTable('arrays_tests', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				tags: text('tags').array(),
+				numbers: int4('numbers').notNull().array(),
+			});
+
+			await db.execute(sql`drop table if exists ${arrays}`);
+			await db.execute(sql`
+				 create table ${arrays} (
+				 id int4 primary key generated by default as identity,
+				 tags text[],
+				 numbers int4[]
+				)
+			`);
+
+			await db.insert(arrays).values({
+				tags: ['', 'b', 'c'],
+				numbers: [1, 2, 3],
+			});
+
+			const result = await db.select().from(arrays);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					tags: ['', 'b', 'c'],
+					numbers: [1, 2, 3],
+				},
+			]);
+
+			await db.execute(sql`drop table ${arrays}`);
+		});
+
+		test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+			await db.execute(
+				sql`
+					create table ${usersOnUpdate} (
+					id int4 primary key generated by default as identity,
+					name text not null,
+					update_counter int4 default 1 not null,
+					updated_at timestamp(3),
+					always_null text
+					)
+				`,
+			);
+
+			await db
+				.insert(usersOnUpdate)
+				.values([
+					{ name: 'John' },
+					{ name: 'Jane' },
+					{ name: 'Jack' },
+					{ name: 'Jill' },
+				]);
+
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+			const justDates = await db
+				.select({ updatedAt })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			const response = await db
+				.select({ ...rest })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			expect(response).toEqual([
+				{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+			]);
+			const msDelay = 250;
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+					Date.now() - msDelay,
+				);
+			}
+		});
+
+		test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+			await db.execute(
+				sql`
+					create table ${usersOnUpdate} (
+					id int4 primary key generated by default as identity,
+					name text not null,
+					update_counter int4 default 1,
+					updated_at timestamp(3),
+					always_null text
+					)
+				`,
+			);
+
+			await db
+				.insert(usersOnUpdate)
+				.values([
+					{ name: 'John', alwaysNull: 'this will be null after updating' },
+					{ name: 'Jane' },
+					{ name: 'Jack' },
+					{ name: 'Jill' },
+				]);
+
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+			await db
+				.select({ updatedAt })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			await db
+				.update(usersOnUpdate)
+				.set({ name: 'Angel' })
+				.where(eq(usersOnUpdate.id, 1));
+			await db
+				.update(usersOnUpdate)
+				.set({ updateCounter: null })
+				.where(eq(usersOnUpdate.id, 2));
+
+			const justDates = await db
+				.select({ updatedAt })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			const response = await db
+				.select({ ...rest })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			expect(response).toEqual([
+				{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+				{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
+				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+			]);
+			const msDelay = 15000;
+
+			// expect(initial[0]?.updatedAt?.valueOf()).not.toBe(justDates[0]?.updatedAt?.valueOf());
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+					Date.now() - msDelay,
+				);
+			}
+		});
+
+		test('test if method with sql operators', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+				age: int4('age').notNull(),
+				city: text('city').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(sql`
+				create table ${users} (
+				id int4 primary key,
+				name text not null,
+				age int4 not null,
+				city text not null
+				)
+			`);
+
+			await db.insert(users).values([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition1 = true;
+
+			const [result1] = await db
+				.select()
+				.from(users)
+				.where(eq(users.id, 1).if(condition1));
+
+			expect(result1).toEqual({
+				id: 1,
+				name: 'John',
+				age: 20,
+				city: 'New York',
+			});
+
+			const condition2 = 1;
+
+			const [result2] = await db
+				.select()
+				.from(users)
+				.where(sql`${users.id} = 1`.if(condition2));
+
+			expect(result2).toEqual({
+				id: 1,
+				name: 'John',
+				age: 20,
+				city: 'New York',
+			});
+
+			const condition3 = 'non-empty string';
+
+			const result3 = await db
+				.select()
+				.from(users)
+				.where(
+					or(eq(users.id, 1).if(condition3), eq(users.id, 2).if(condition3)),
+				);
+
+			expect(result3).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{
+					id: 2,
+					name: 'Alice',
+					age: 21,
+					city: 'New York',
+				},
+			]);
+
+			const condtition4 = false;
+
+			const result4 = await db
+				.select()
+				.from(users)
+				.where(eq(users.id, 1).if(condtition4));
+
+			expect(result4).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition5 = undefined;
+
+			const result5 = await db
+				.select()
+				.from(users)
+				.where(sql`${users.id} = 1`.if(condition5));
+
+			expect(result5).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition6 = null;
+
+			const result6 = await db
+				.select()
+				.from(users)
+				.where(
+					or(eq(users.id, 1).if(condition6), eq(users.id, 2).if(condition6)),
+				);
+
+			expect(result6).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition7 = {
+				term1: 0,
+				term2: 1,
+			};
+
+			const result7 = await db
+				.select()
+				.from(users)
+				.where(
+					and(
+						gt(users.age, 20).if(condition7.term1),
+						eq(users.city, 'New York').if(condition7.term2),
+					),
+				);
+
+			expect(result7).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+			]);
+
+			const condition8 = {
+				term1: '',
+				term2: 'non-empty string',
+			};
+
+			const result8 = await db
+				.select()
+				.from(users)
+				.where(
+					or(
+						lt(users.age, 21).if(condition8.term1),
+						eq(users.city, 'London').if(condition8.term2),
+					),
+				);
+
+			expect(result8).toEqual([
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition9 = {
+				term1: 1,
+				term2: true,
+			};
+
+			const result9 = await db
+				.select()
+				.from(users)
+				.where(
+					and(
+						inArray(users.city, ['New York', 'London']).if(condition9.term1),
+						ilike(users.name, 'a%').if(condition9.term2),
+					),
+				);
+
+			expect(result9).toEqual([
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+			]);
+
+			const condition10 = {
+				term1: 4,
+				term2: 19,
+			};
+
+			const result10 = await db
+				.select()
+				.from(users)
+				.where(
+					and(
+						sql`length(${users.name}) <= ${condition10.term1}`.if(
+							condition10.term1,
+						),
+						gt(users.age, condition10.term2).if(condition10.term2 > 20),
+					),
+				);
+
+			expect(result10).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition11 = true;
+
+			const result11 = await db
+				.select()
+				.from(users)
+				.where(
+					or(eq(users.city, 'New York'), gte(users.age, 22))!.if(condition11),
+				);
+
+			expect(result11).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition12 = false;
+
+			const result12 = await db
+				.select()
+				.from(users)
+				.where(
+					and(eq(users.city, 'London'), gte(users.age, 23))!.if(condition12),
+				);
+
+			expect(result12).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition13 = true;
+
+			const result13 = await db
+				.select()
+				.from(users)
+				.where(sql`(city = 'New York' or age >= 22)`.if(condition13));
+
+			expect(result13).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			const condition14 = false;
+
+			const result14 = await db
+				.select()
+				.from(users)
+				.where(sql`(city = 'London' and age >= 23)`.if(condition14));
+
+			expect(result14).toEqual([
+				{ id: 1, name: 'John', age: 20, city: 'New York' },
+				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				{ id: 3, name: 'Nick', age: 22, city: 'London' },
+				{ id: 4, name: 'Lina', age: 23, city: 'London' },
+			]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		// MySchema tests
+		test('mySchema :: select all fields', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const now = Date.now();
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('mySchema :: select sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.select({
+					name: sql`upper(${usersMySchemaTable.name})`,
+				})
+				.from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: select typed sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.select({
+					name: sql<string>`upper(${usersMySchemaTable.name})`,
+				})
+				.from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: select distinct', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const usersDistinctTable = cockroachTable('users_distinct', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+			await db.execute(
+				sql`create table ${usersDistinctTable} (id int4, name text)`,
+			);
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+				{ id: 1, name: 'Jane' },
+			]);
+			const users1 = await db
+				.selectDistinct()
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+			const users2 = await db
+				.selectDistinctOn([usersDistinctTable.id])
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id);
+			const users3 = await db
+				.selectDistinctOn([usersDistinctTable.name], {
+					name: usersDistinctTable.name,
+				})
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.name);
+
+			await db.execute(sql`drop table ${usersDistinctTable}`);
+
+			expect(users1).toEqual([
+				{ id: 1, name: 'Jane' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+			]);
+
+			expect(users2).toHaveLength(2);
+			expect(users2[0]?.id).toBe(1);
+			expect(users2[1]?.id).toBe(2);
+
+			expect(users3).toHaveLength(2);
+			expect(users3[0]?.name).toBe('Jane');
+			expect(users3[1]?.name).toBe('John');
+		});
+
+		test('mySchema :: insert returning sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = await db
+				.insert(usersMySchemaTable)
+				.values({ name: 'John' })
+				.returning({
+					name: sql`upper(${usersMySchemaTable.name})`,
+				});
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: delete returning sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersMySchemaTable)
+				.where(eq(usersMySchemaTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersMySchemaTable.name})`,
+				});
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: update with returning partial', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.update(usersMySchemaTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersMySchemaTable.name, 'John'))
+				.returning({
+					id: usersMySchemaTable.id,
+					name: usersMySchemaTable.name,
+				});
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+		});
+
+		test('mySchema :: delete with returning all fields', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const now = Date.now();
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersMySchemaTable)
+				.where(eq(usersMySchemaTable.name, 'John'))
+				.returning();
+
+			expect(users[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(users).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: users[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('mySchema :: insert + select', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+
+			await db.insert(usersMySchemaTable).values({ name: 'Jane' });
+			const result2 = await db.select().from(usersMySchemaTable);
+			expect(result2).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[0]!.createdAt,
+				},
+				{
+					id: 2,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[1]!.createdAt,
+				},
+			]);
+		});
+
+		test('mySchema :: insert with overridden default values', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersMySchemaTable)
+				.values({ name: 'John', verified: true });
+			const result = await db.select().from(usersMySchemaTable);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: true,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test('mySchema :: insert many', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersMySchemaTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				]);
+			const result = await db
+				.select({
+					id: usersMySchemaTable.id,
+					name: usersMySchemaTable.name,
+					jsonb: usersMySchemaTable.jsonb,
+					verified: usersMySchemaTable.verified,
+				})
+				.from(usersMySchemaTable);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test('mySchema :: select with group by as field', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersMySchemaTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersMySchemaTable.name })
+				.from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.name);
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test('mySchema :: select with group by as column + sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(usersMySchemaTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: usersMySchemaTable.name })
+				.from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`);
+
+			expect(result).toEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+				{ name: 'Jane' },
+			]);
+		});
+
+		test('mySchema :: build query', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name })
+				.from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql: 'select "id", "name" from "mySchema"."users" group by "mySchema"."users"."id", "mySchema"."users"."name"',
+				params: [],
+			});
+		});
+
+		test('mySchema :: partial join with alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const customerAlias = alias(usersMySchemaTable, 'customer');
+
+			await db.insert(usersMySchemaTable).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
+			const result = await db
+				.select({
+					user: {
+						id: usersMySchemaTable.id,
+						name: usersMySchemaTable.name,
+					},
+					customer: {
+						id: customerAlias.id,
+						name: customerAlias.name,
+					},
+				})
+				.from(usersMySchemaTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(usersMySchemaTable.id, 10));
+
+			expect(result).toEqual([
+				{
+					user: { id: 10, name: 'Ivan' },
+					customer: { id: 11, name: 'Hans' },
+				},
+			]);
+		});
+
+		test('mySchema :: insert with spaces', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: sql`'Jo   h     n'` });
+			const result = await db
+				.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name })
+				.from(usersMySchemaTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test('mySchema :: prepared statement with placeholder in .limit', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const stmt = db
+				.select({
+					id: usersMySchemaTable.id,
+					name: usersMySchemaTable.name,
+				})
+				.from(usersMySchemaTable)
+				.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
+				.limit(sql.placeholder('limit'))
+				.prepare('mySchema_stmt_limit');
+
+			const result = await stmt.execute({ id: 1, limit: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+			expect(result).toHaveLength(1);
+		});
+
+		test('mySchema :: build query insert with onConflict do update / multiple columns', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersMySchemaTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoUpdate({
+					target: [usersMySchemaTable.id, usersMySchemaTable.name],
+					set: { name: 'John1' },
+				})
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+				params: ['John', '["foo","bar"]', 'John1'],
+			});
+		});
+
+		test('mySchema :: build query insert with onConflict do nothing + target', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const query = db
+				.insert(usersMySchemaTable)
+				.values({ name: 'John', jsonb: ['foo', 'bar'] })
+				.onConflictDoNothing({ target: usersMySchemaTable.id })
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+				params: ['John', '["foo","bar"]'],
+			});
+		});
+
+		test('mySchema :: select from tables with same name from different schema using alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
+			await db.insert(usersTable).values({ id: 11, name: 'Hans' });
+
+			const customerAlias = alias(usersTable, 'customer');
+
+			const result = await db
+				.select()
+				.from(usersMySchemaTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(customerAlias.id, 11));
+
+			expect(result).toEqual([
+				{
+					users: {
+						id: 10,
+						name: 'Ivan',
+						verified: false,
+						jsonb: null,
+						createdAt: result[0]!.users.createdAt,
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+						verified: false,
+						jsonb: null,
+						createdAt: result[0]!.customer!.createdAt,
+					},
+				},
+			]);
+		});
+
+		test('mySchema :: view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const newYorkers1 = mySchema
+				.view('new_yorkers')
+				.as((qb) =>
+					qb
+						.select()
+						.from(users2MySchemaTable)
+						.where(eq(users2MySchemaTable.cityId, 1))
+				);
+
+			const newYorkers2 = mySchema
+				.view('new_yorkers', {
+					id: int4('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int4('city_id').notNull(),
+				})
+				.as(
+					sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`,
+				);
+
+			const newYorkers3 = mySchema
+				.view('new_yorkers', {
+					id: int4('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int4('city_id').notNull(),
+				})
+				.existing();
+
+			await db.execute(
+				sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`,
+			);
+
+			await db
+				.insert(citiesMySchemaTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users2MySchemaTable).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop view ${newYorkers1}`);
+		});
+
+		test('mySchema :: materialized view', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const newYorkers1 = mySchema
+				.materializedView('new_yorkers')
+				.as((qb) =>
+					qb
+						.select()
+						.from(users2MySchemaTable)
+						.where(eq(users2MySchemaTable.cityId, 1))
+				);
+
+			const newYorkers2 = mySchema
+				.materializedView('new_yorkers', {
+					id: int4('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int4('city_id').notNull(),
+				})
+				.as(
+					sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`,
+				);
+
+			const newYorkers3 = mySchema
+				.materializedView('new_yorkers', {
+					id: int4('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int4('city_id').notNull(),
+				})
+				.existing();
+
+			await db.execute(
+				sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`,
+			);
+
+			await db
+				.insert(citiesMySchemaTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users2MySchemaTable).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([]);
+			}
+
+			await db.refreshMaterializedView(newYorkers1);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop materialized view ${newYorkers1}`);
+		});
+
+		test('limit 0', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(0);
+
+			expect(users).toEqual([]);
+		});
+
+		test('limit -1', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(-1);
+
+			expect(users.length).toBeGreaterThan(0);
+		});
+
+		test('Object keys as column names', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			// Tests the following:
+			// Column with required config
+			// Column with optional config without providing a value
+			// Column with optional config providing a value
+			// Column without config
+			const users = cockroachTable('users', {
+				id: bigint({ mode: 'number' })
+					.primaryKey()
+					.generatedByDefaultAsIdentity(),
+				firstName: varchar(),
+				lastName: varchar({ length: 50 }),
+				admin: bool(),
+			});
+
+			await db.execute(sql`drop table if exists users`);
+			await db.execute(
+				sql`
+					create table users (
+						"id" bigint primary key generated by default as identity,
+						"firstName" varchar,
+						"lastName" varchar(50),
+						"admin" bool
+					)
+				`,
+			);
+
+			await db.insert(users).values([
+				{ firstName: 'John', lastName: 'Doe', admin: true },
+				{ firstName: 'Jane', lastName: 'Smith', admin: false },
+			]);
+			const result = await db
+				.select({
+					id: users.id,
+					firstName: users.firstName,
+					lastName: users.lastName,
+				})
+				.from(users)
+				.where(eq(users.admin, true));
+
+			expect(result).toEqual([{ id: 1, firstName: 'John', lastName: 'Doe' }]);
+
+			await db.execute(sql`drop table users`);
+		});
+
+		test('proper json and jsonb handling', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const jsonTable = cockroachTable('json_table', {
+				jsonb: jsonb('jsonb').$type<{ name: string; age: number }>(),
+			});
+
+			await db.execute(sql`drop table if exists ${jsonTable}`);
+
+			await db.execute(sql`create table ${jsonTable} (json json, jsonb jsonb)`);
+
+			await db.insert(jsonTable).values({ jsonb: { name: 'Pete', age: 23 } });
+
+			const result = await db.select().from(jsonTable);
+
+			const justNames = await db
+				.select({
+					name2: sql<string>`${jsonTable.jsonb}->>'name'`.as('name2'),
+				})
+				.from(jsonTable);
+
+			expect(result).toStrictEqual([
+				{
+					jsonb: { name: 'Pete', age: 23 },
+				},
+			]);
+
+			expect(justNames).toStrictEqual([
+				{
+					name2: 'Pete',
+				},
+			]);
+		});
+
+		test('set json/jsonb fields with objects and retrieve with the ->> operator', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const obj = { string: 'test', number: 123 };
+			const { string: testString, number: testNumber } = obj;
+
+			await db.insert(jsonTestTable).values({
+				jsonb: obj,
+			});
+
+			const result = await db
+				.select({
+					jsonbStringField: sql<string>`${jsonTestTable.jsonb}->>'string'`,
+					jsonbNumberField: sql<string>`${jsonTestTable.jsonb}->>'number'`,
+				})
+				.from(jsonTestTable);
+
+			expect(result).toStrictEqual([
+				{
+					jsonbStringField: testString,
+					jsonbNumberField: String(testNumber),
+				},
+			]);
+		});
+
+		test('set json/jsonb fields with strings and retrieve with the ->> operator', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const obj = { string: 'test', number: 123 };
+			const { string: testString, number: testNumber } = obj;
+
+			await db.insert(jsonTestTable).values({
+				jsonb: sql`${JSON.stringify(obj)}`,
+			});
+
+			const result = await db
+				.select({
+					jsonbStringField: sql<string>`${jsonTestTable.jsonb}->>'string'`,
+					jsonbNumberField: sql<string>`${jsonTestTable.jsonb}->>'number'`,
+				})
+				.from(jsonTestTable);
+
+			expect(result).toStrictEqual([
+				{
+					jsonbStringField: testString,
+					jsonbNumberField: String(testNumber),
+				},
+			]);
+		});
+
+		test('set json/jsonb fields with objects and retrieve with the -> operator', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const obj = { string: 'test', number: 123 };
+			const { string: testString, number: testNumber } = obj;
+
+			await db.insert(jsonTestTable).values({
+				jsonb: obj,
+			});
+
+			const result = await db
+				.select({
+					jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
+					jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
+				})
+				.from(jsonTestTable);
+
+			expect(result).toStrictEqual([
+				{
+					jsonbStringField: testString,
+					jsonbNumberField: testNumber,
+				},
+			]);
+		});
+
+		test('set json/jsonb fields with strings and retrieve with the -> operator', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const obj = { string: 'test', number: 123 };
+			const { string: testString, number: testNumber } = obj;
+
+			await db.insert(jsonTestTable).values({
+				jsonb: sql`${JSON.stringify(obj)}`,
+			});
+
+			const result = await db
+				.select({
+					jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
+					jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
+				})
+				.from(jsonTestTable);
+
+			expect(result).toStrictEqual([
+				{
+					jsonbStringField: testString,
+					jsonbNumberField: testNumber,
+				},
+			]);
+		});
+
+		test('update ... from', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(cities2Table)
+				.values([{ name: 'New York City' }, { name: 'Seattle' }]);
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+			]);
+
+			const result = await db
+				.update(users2Table)
+				.set({
+					cityId: cities2Table.id,
+				})
+				.from(cities2Table)
+				.where(
+					and(eq(cities2Table.name, 'Seattle'), eq(users2Table.name, 'John')),
+				)
+				.returning();
+
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					cities: {
+						id: 2,
+						name: 'Seattle',
+					},
+				},
+			]);
+		});
+
+		test('update ... from with alias', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(cities2Table)
+				.values([{ name: 'New York City' }, { name: 'Seattle' }]);
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+			]);
+
+			const users = alias(users2Table, 'u');
+			const cities = alias(cities2Table, 'c');
+			const result = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+				.returning();
+
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					c: {
+						id: 2,
+						name: 'Seattle',
+					},
+				},
+			]);
+		});
+
+		test('update ... from with join', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const states = cockroachTable('states', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+			});
+			const cities = cockroachTable('cities', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				stateId: int4('state_id').references(() => states.id),
+			});
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				cityId: int4('city_id')
+					.notNull()
+					.references(() => cities.id),
+			});
+
+			await db.execute(sql`drop table if exists "states" cascade`);
+			await db.execute(sql`drop table if exists "cities" cascade`);
+			await db.execute(sql`drop table if exists "users" cascade`);
+			await db.execute(sql`
+				create table "states" (
+					"id" int4 primary key generated by default as identity,
+					"name" text not null
+				)
+			`);
+			await db.execute(sql`
+				create table "cities" (
+					"id" int4 primary key generated by default as identity,
+					"name" text not null,
+					"state_id" int4 references "states"("id")
+				)
+			`);
+			await db.execute(sql`
+				create table "users" (
+					"id" int4 primary key generated by default as identity,
+					"name" text not null,
+					"city_id" int4 not null references "cities"("id")
+				)
+			`);
+
+			await db
+				.insert(states)
+				.values([{ name: 'New York' }, { name: 'Washington' }]);
+			await db
+				.insert(cities)
+				.values([
+					{ name: 'New York City', stateId: 1 },
+					{ name: 'Seattle', stateId: 2 },
+					{ name: 'London' },
+				]);
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 3 },
+			]);
+
+			const result1 = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.leftJoin(states, eq(cities.stateId, states.id))
+				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+				.returning();
+			const result2 = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.leftJoin(states, eq(cities.stateId, states.id))
+				.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+				.returning();
+
+			expect(result1).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					cities: {
+						id: 2,
+						name: 'Seattle',
+						stateId: 2,
+					},
+					states: {
+						id: 2,
+						name: 'Washington',
+					},
+				},
+			]);
+			expect(result2).toStrictEqual([
+				{
+					id: 3,
+					name: 'Jack',
+					cityId: 3,
+					cities: {
+						id: 3,
+						name: 'London',
+						stateId: null,
+					},
+					states: null,
+				},
+			]);
+		});
+
+		test('insert into ... select', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const notifications = cockroachTable('notifications', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				sentAt: timestamp('sent_at').notNull().defaultNow(),
+				message: text('message').notNull(),
+			});
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+			});
+			const userNotications = cockroachTable(
+				'user_notifications',
+				{
+					userId: int4('user_id')
+						.notNull()
+						.references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: int4('notification_id')
+						.notNull()
+						.references(() => notifications.id, {
+							onDelete: 'cascade',
+						}),
+				},
+				(t) => [primaryKey({ columns: [t.userId, t.notificationId] })],
+			);
+
+			await db.execute(sql`drop table if exists notifications`);
+			await db.execute(sql`drop table if exists users`);
+			await db.execute(sql`drop table if exists user_notifications`);
+			await db.execute(sql`
+				create table notifications (
+					id int4 primary key generated by default as identity,
+					sent_at timestamp not null default now(),
+					message text not null
+				)
+			`);
+			await db.execute(sql`
+				create table users (
+					id int4 primary key generated by default as identity,
+					name text not null
+				)
+			`);
+			await db.execute(sql`
+				create table user_notifications (
+					user_id int references users(id) on delete cascade,
+					notification_id int references notifications(id) on delete cascade,
+					primary key (user_id, notification_id)
+				)
+			`);
+
+			const newNotification = await db
+				.insert(notifications)
+				.values({ message: 'You are one of the 3 lucky winners!' })
+				.returning({ id: notifications.id })
+				.then((result) => result[0]);
+			await db
+				.insert(users)
+				.values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+			const sentNotifications = await db
+				.insert(userNotications)
+				.select(
+					db
+						.select({
+							userId: users.id,
+							notificationId: sql`${newNotification!.id}`.as('notification_id'),
+						})
+						.from(users)
+						.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+						.orderBy(asc(users.id)),
+				)
+				.returning();
+
+			expect(sentNotifications).toStrictEqual([
+				{ userId: 1, notificationId: newNotification!.id },
+				{ userId: 3, notificationId: newNotification!.id },
+				{ userId: 5, notificationId: newNotification!.id },
+			]);
+		});
+
+		test('insert into ... select with keys in different order', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users1 = cockroachTable('users1', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2 = cockroachTable('users2', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists users1`);
+			await db.execute(sql`drop table if exists users2`);
+			await db.execute(sql`
+				create table users1 (
+					id int4 primary key,
+					name text not null
+				)
+			`);
+			await db.execute(sql`
+				create table users2 (
+					id int4 primary key,
+					name text not null
+				)
+			`);
+
+			await db.insert(users2).values({ id: 1, name: 'First' });
+			const res = await db.insert(users1).select(
+				db
+					.select({
+						name: users2.name,
+						id: users2.id,
+					})
+					.from(users2),
+			).returning();
+
+			expect(res).toStrictEqual([{
+				id: 1,
+				name: 'First',
+			}]);
+		});
+
+		test('insert into ... select with generated column', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users1 = cockroachTable('users1_iswgc', {
+				id: int4('id').generatedAlwaysAsIdentity().primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2 = cockroachTable('users2_iswgc', {
+				id: int4('id').generatedAlwaysAsIdentity().primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists users1_iswgc`);
+			await db.execute(sql`drop table if exists users2_iswgc`);
+			await db.execute(sql`
+				create table users1_iswgc (
+					id int4 primary key generated always as identity,
+					name text not null
+				)
+			`);
+			await db.execute(sql`
+				create table users2_iswgc (
+					id int4 primary key generated always as identity,
+					name text not null
+				)
+			`);
+
+			await db.insert(users1).values([
+				{ name: 'Alice' },
+				{ name: 'Bob' },
+				{ name: 'Charlie' },
+			]);
+
+			const result1 = await db.insert(users2).select(db.select({ name: users1.name }).from(users1))
+				.returning();
+
+			expect(result1).toStrictEqual([
+				{ id: 1, name: 'Alice' },
+				{ id: 2, name: 'Bob' },
+				{ id: 3, name: 'Charlie' },
+			]);
+
+			// @ts-expect-error
+			db.insert(users2).select(db.select({ name: users1.name, id: users1.id }).from(users1));
+			// @ts-expect-error
+			expect(() => db.insert(users2).select(db.select({ name: users1.name, unknown: users1.id }).from(users1)))
+				.toThrowError();
+		});
+
+		test('policy', () => {
+			{
+				const policy = cockroachPolicy('test policy');
+
+				expect(is(policy, CockroachPolicy)).toBe(true);
+				expect(policy.name).toBe('test policy');
+			}
+
+			{
+				const policy = cockroachPolicy('test policy', {
+					as: 'permissive',
+					for: 'all',
+					to: 'public',
+					using: sql`1=1`,
+					withCheck: sql`1=1`,
+				});
+
+				expect(is(policy, CockroachPolicy)).toBe(true);
+				expect(policy.name).toBe('test policy');
+				expect(policy.as).toBe('permissive');
+				expect(policy.for).toBe('all');
+				expect(policy.to).toBe('public');
+				const dialect = new CockroachDialect();
+				expect(is(policy.using, SQL)).toBe(true);
+				expect(dialect.sqlToQuery(policy.using!).sql).toBe('1=1');
+				expect(is(policy.withCheck, SQL)).toBe(true);
+				expect(dialect.sqlToQuery(policy.withCheck!).sql).toBe('1=1');
+			}
+
+			{
+				const policy = cockroachPolicy('test policy', {
+					to: 'custom value',
+				});
+
+				expect(policy.to).toBe('custom value');
+			}
+
+			{
+				const p1 = cockroachPolicy('test policy');
+				const p2 = cockroachPolicy('test policy 2', {
+					as: 'permissive',
+					for: 'all',
+					to: 'public',
+					using: sql`1=1`,
+					withCheck: sql`1=1`,
+				});
+				const table = cockroachTable(
+					'table_with_policy',
+					{
+						id: int4('id').primaryKey(),
+						name: text('name').notNull(),
+					},
+					() => [p1, p2],
+				);
+				const config = getTableConfig(table);
+				expect(config.policies).toHaveLength(2);
+				expect(config.policies[0]).toBe(p1);
+				expect(config.policies[1]).toBe(p2);
+			}
+		});
+
+		test('Enable RLS function', () => {
+			const usersWithRLS = cockroachTable('users', {
+				id: int4(),
+			}).enableRLS();
+
+			const config1 = getTableConfig(usersWithRLS);
+
+			const usersNoRLS = cockroachTable('users', {
+				id: int4(),
+			});
+
+			const config2 = getTableConfig(usersNoRLS);
+
+			expect(config1.enableRLS).toBeTruthy();
+			expect(config2.enableRLS).toBeFalsy();
+		});
+
+		test('$count separate', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db.$count(countTestTable);
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count).toStrictEqual(4);
+		});
+
+		test('$count embedded', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count).toStrictEqual([
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+			]);
+		});
+
+		test('$count separate reuse', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db.$count(countTestTable);
+
+			const count1 = await count;
+
+			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = await count;
+
+			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = await count;
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count1).toStrictEqual(4);
+			expect(count2).toStrictEqual(5);
+			expect(count3).toStrictEqual(6);
+		});
+
+		test('$count embedded reuse', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			const count1 = await count;
+
+			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = await count;
+
+			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = await count;
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count1).toStrictEqual([
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+			]);
+			expect(count2).toStrictEqual([
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+			]);
+			expect(count3).toStrictEqual([
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+			]);
+		});
+
+		test('$count separate with filters', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count).toStrictEqual(3);
+		});
+
+		test('$count embedded with filters', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const countTestTable = cockroachTable('count_test', {
+				id: int4('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${countTestTable}`);
+			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db
+				.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				})
+				.from(countTestTable);
+
+			await db.execute(sql`drop table ${countTestTable}`);
+
+			expect(count).toStrictEqual([
+				{ count: 3 },
+				{ count: 3 },
+				{ count: 3 },
+				{ count: 3 },
+			]);
+		});
+
+		test('insert multiple rows into table with generated identity column', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const identityColumnsTable = cockroachTable('identity_columns_table', {
+				id: int4('id').generatedAlwaysAsIdentity(),
+				id1: int4('id1').generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			// not passing identity columns
+			await db.execute(sql`drop table if exists ${identityColumnsTable}`);
+			await db.execute(
+				sql`create table ${identityColumnsTable} ("id" int4 generated always as identity, "id1" int4 generated by default as identity, "name" text)`,
+			);
+
+			let result = await db
+				.insert(identityColumnsTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Bob' }])
+				.returning();
+
+			expect(result).toEqual([
+				{ id: 1, id1: 1, name: 'John' },
+				{ id: 2, id1: 2, name: 'Jane' },
+				{ id: 3, id1: 3, name: 'Bob' },
+			]);
+
+			// passing generated by default as identity column
+			await db.execute(sql`drop table if exists ${identityColumnsTable}`);
+			await db.execute(
+				sql`create table ${identityColumnsTable} ("id" int4 generated always as identity, "id1" int4 generated by default as identity, "name" text)`,
+			);
+
+			result = await db
+				.insert(identityColumnsTable)
+				.values([
+					{ name: 'John', id1: 3 },
+					{ name: 'Jane', id1: 5 },
+					{ name: 'Bob', id1: 5 },
+				])
+				.returning();
+
+			expect(result).toEqual([
+				{ id: 1, id1: 3, name: 'John' },
+				{ id: 2, id1: 5, name: 'Jane' },
+				{ id: 3, id1: 5, name: 'Bob' },
+			]);
+		});
+
+		test('insert as cte', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null)`,
+			);
+
+			const sq1 = db
+				.$with('sq')
+				.as(db.insert(users).values({ name: 'John' }).returning());
+			const result1 = await db.with(sq1).select().from(sq1);
+			const result2 = await db.with(sq1).select({ id: sq1.id }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.insert(users)
+						.values({ name: 'Jane' })
+						.returning({ id: users.id, name: users.name }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ id: 2 }]);
+			expect(result3).toEqual([{ id: 3, name: 'Jane' }]);
+			expect(result4).toEqual([{ name: 'Jane' }]);
+		});
+
+		test('update as cte', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				name: text('name').notNull(),
+				age: int4('age').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null, age int4 not null)`,
+			);
+
+			await db.insert(users).values([
+				{ name: 'John', age: 30 },
+				{ name: 'Jane', age: 30 },
+			]);
+
+			const sq1 = db
+				.$with('sq')
+				.as(
+					db
+						.update(users)
+						.set({ age: 25 })
+						.where(eq(users.name, 'John'))
+						.returning(),
+				);
+			const result1 = await db.with(sq1).select().from(sq1);
+			await db.update(users).set({ age: 30 });
+			const result2 = await db.with(sq1).select({ age: sq1.age }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.update(users)
+						.set({ age: 20 })
+						.where(eq(users.name, 'Jane'))
+						.returning({ name: users.name, age: users.age }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			await db.update(users).set({ age: 30 });
+			const result4 = await db.with(sq2).select({ age: sq2.age }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John', age: 25 }]);
+			expect(result2).toEqual([{ age: 25 }]);
+			expect(result3).toEqual([{ name: 'Jane', age: 20 }]);
+			expect(result4).toEqual([{ age: 20 }]);
+		});
+
+		test('delete as cte', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null)`,
+			);
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq1 = db
+				.$with('sq')
+				.as(db.delete(users).where(eq(users.name, 'John')).returning());
+			const result1 = await db.with(sq1).select().from(sq1);
+			await db.insert(users).values({ name: 'John' });
+			const result2 = await db.with(sq1).select({ name: sq1.name }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.delete(users)
+						.where(eq(users.name, 'Jane'))
+						.returning({ id: users.id, name: users.name }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			await db.insert(users).values({ name: 'Jane' });
+			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ name: 'John' }]);
+			expect(result3).toEqual([{ id: 2, name: 'Jane' }]);
+			expect(result4).toEqual([{ name: 'Jane' }]);
+		});
+
+		test('sql operator as cte', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users', {
+				id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id int4 not null primary key generated by default as identity, name text not null)`,
+			);
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq1 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(sql`select * from ${users} where ${users.name} = 'John'`);
+			const result1 = await db.with(sq1).select().from(sq1);
+
+			const sq2 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+			const result2 = await db.with(sq2).select().from(sq1);
+
+			expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
+			expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+		});
+
+		test('cross join', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Seattle' }, { name: 'New York City' }]);
+
+			const result = await db
+				.select({
+					user: usersTable.name,
+					city: citiesTable.name,
+				})
+				.from(usersTable)
+				.crossJoin(citiesTable)
+				.orderBy(usersTable.name, citiesTable.name);
+
+			expect(result).toStrictEqual([
+				{ city: 'New York City', user: 'Jane' },
+				{ city: 'Seattle', user: 'Jane' },
+				{ city: 'New York City', user: 'John' },
+				{ city: 'Seattle', user: 'John' },
+			]);
+		});
+
+		test('left join (lateral)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.leftJoinLateral(sq, sql`true`);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+				{ cityId: 2, cityName: 'London', userId: null, userName: null },
+			]);
+		});
+
+		test('inner join (lateral)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.innerJoinLateral(sq, sql`true`);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+			]);
+		});
+
+		test('cross join (lateral)', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Berlin' },
+			]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane' },
+				{
+					name: 'Patrick',
+					cityId: 2,
+				},
+			]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(not(like(citiesTable.name, 'L%')))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.crossJoinLateral(sq)
+				.orderBy(citiesTable.id, sq.userId);
+
+			expect(res).toStrictEqual([
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 1,
+					userName: 'John',
+				},
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 2,
+					userName: 'Jane',
+				},
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 3,
+					userName: 'Patrick',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 1,
+					userName: 'John',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 2,
+					userName: 'Jane',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 3,
+					userName: 'Patrick',
+				},
+			]);
+		});
+
+		test('column.as', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_column_as', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				cityId: int4('city_id').references(() => cities.id),
+			});
+
+			const cities = cockroachTable('cities_column_as', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			const ucView = cockroachView('cities_users_column_as_view').as((qb) =>
+				qb
+					.select({
+						userId: users.id.as('user_id'),
+						cityId: cities.id.as('city_id'),
+						userName: users.name.as('user_name'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.cityId))
+			);
+
+			await db.execute(sql`CREATE TABLE ${cities} (
+				"id" INT4 PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+				"name" TEXT NOT NULL
+			);`);
+
+			await db.execute(sql`CREATE TABLE ${users} (
+				"id" INT4 GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+				"name" TEXT NOT NULL,
+				"city_id"  INT4 REFERENCES ${cities}("id") 
+			);`);
+
+			await db.execute(
+				sql`CREATE VIEW ${ucView} AS SELECT ${users.id} as "user_id", ${cities.id} as "city_id", ${users.name} as "user_name", ${cities.name} as "city_name" FROM ${users} LEFT JOIN ${cities} ON ${
+					eq(
+						cities.id,
+						users.cityId,
+					)
+				};`,
+			);
+
+			const citiesInsRet = await db
+				.insert(cities)
+				.values([
+					{
+						id: 1,
+						name: 'Firstistan',
+					},
+					{
+						id: 2,
+						name: 'Secondaria',
+					},
+				])
+				.returning({
+					cityId: cities.id.as('city_id'),
+					cityName: cities.name.as('city_name'),
+				});
+
+			expect(citiesInsRet).toStrictEqual(
+				expect.arrayContaining([
+					{
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+				]),
+			);
+
+			const usersInsRet = await db
+				.insert(users)
+				.values([
+					{ id: 1, name: 'First', cityId: 1 },
+					{
+						id: 2,
+						name: 'Second',
+						cityId: 2,
+					},
+					{
+						id: 3,
+						name: 'Third',
+					},
+				])
+				.returning({
+					userId: users.id.as('user_id'),
+					userName: users.name.as('users_name'),
+					userCityId: users.cityId,
+				});
+
+			expect(usersInsRet).toStrictEqual(
+				expect.arrayContaining([
+					{ userId: 1, userName: 'First', userCityId: 1 },
+					{
+						userId: 2,
+						userName: 'Second',
+						userCityId: 2,
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						userCityId: null,
+					},
+				]),
+			);
+
+			const joinSelectReturn = await db
+				.select({
+					userId: users.id.as('user_id'),
+					cityId: cities.id.as('city_id'),
+					userName: users.name.as('user_name'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(users)
+				.leftJoin(cities, eq(cities.id, users.cityId));
+
+			expect(joinSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewSelectReturn = await db.select().from(ucView);
+
+			expect(viewSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewJoinReturn = await db
+				.select({
+					userId: ucView.userId.as('user_id_ucv'),
+					cityId: cities.id.as('city_id'),
+					userName: ucView.userName.as('user_name_ucv'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(ucView)
+				.leftJoin(cities, eq(cities.id, ucView.cityId));
+
+			expect(viewJoinReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+		});
+
+		test('select from a many subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					population: db
+						.select({ count: count().as('count') })
+						.from(users2Table)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('population'),
+					name: citiesTable.name,
+				})
+				.from(citiesTable);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					population: number;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					population: 1,
+					name: 'Paris',
+				},
+				{
+					population: 2,
+					name: 'London',
+				},
+			]);
+		});
+
+		test('select from a one subquery', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					cityName: db
+						.select({ name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('cityName'),
+					name: users2Table.name,
+				})
+				.from(users2Table);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					cityName: string;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					cityName: 'Paris',
+					name: 'John',
+				},
+				{
+					cityName: 'London',
+					name: 'Jane',
+				},
+				{
+					cityName: 'London',
+					name: 'Jack',
+				},
+			]);
+		});
+
+		test('test $onUpdateFn and $onUpdate works with sql value', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const users = cockroachTable('users_on_update', {
+				id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+				updatedAt: timestamp('updated_at', { mode: 'date' })
+					.notNull()
+					.$onUpdate(() => sql`now()`),
+			});
+
+			await db.execute(sql`DROP TABLE IF EXISTS ${users}`);
+			await db.execute(sql`CREATE TABLE ${users} (
+				id INT4 PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
+				name TEXT NOT NULL,
+				updated_at TIMESTAMPTZ NOT NULL
+			);`);
+
+			const insertResp = await db
+				.insert(users)
+				.values({
+					name: 'John',
+				})
+				.returning({
+					updatedAt: users.updatedAt,
+				});
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+
+			const now = Date.now();
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+			const updateResp = await db
+				.update(users)
+				.set({
+					name: 'John',
+				})
+				.returning({
+					updatedAt: users.updatedAt,
+				});
+
+			expect(insertResp[0]?.updatedAt.getTime() ?? 0).lessThan(now);
+			expect(updateResp[0]?.updatedAt.getTime() ?? 0).greaterThan(now);
+		});
+
+		test('placeholder + sql dates', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			const dateTable = cockroachTable('dates_placeholder_test', (t) => ({
+				id: t.int4('id').primaryKey().notNull(),
+				date: t.date('date', { mode: 'date' }).notNull(),
+				dateStr: t.date('date_str', { mode: 'string' }).notNull(),
+				timestamp: t.timestamp('timestamp', { mode: 'date' }).notNull(),
+				timestampStr: t
+					.timestamp('timestamp_str', { mode: 'string' })
+					.notNull(),
+			}));
+
+			await db.execute(sql`DROP TABLE IF EXISTS ${dateTable};`);
+			await db.execute(sql`CREATE TABLE ${dateTable} (
+			${sql.identifier('id')} INT4 PRIMARY KEY NOT NULL,
+			${sql.identifier('date')} DATE NOT NULL,
+			${sql.identifier('date_str')} DATE NOT NULL,
+			${sql.identifier('timestamp')} TIMESTAMP NOT NULL,
+			${sql.identifier('timestamp_str')} TIMESTAMP NOT NULL
+		);`);
+
+			const date = new Date('2025-12-10T00:00:00.000Z');
+			const timestamp = new Date('2025-12-10T01:01:01.111Z');
+			const dateStr = date.toISOString().slice(0, -14);
+			const timestampStr = timestamp
+				.toISOString()
+				.slice(0, -1)
+				.replace('T', ' ');
+
+			const initial = await db
+				.insert(dateTable)
+				.values([
+					{
+						id: 1,
+						date: date,
+						dateStr: dateStr,
+						timestamp: timestamp,
+						timestampStr: timestampStr,
+					},
+					{
+						id: 2,
+						date: sql.placeholder('dateAsDate'),
+						dateStr: sql.placeholder('dateStrAsDate'),
+						timestamp: sql.placeholder('timestampAsDate'),
+						timestampStr: sql.placeholder('timestampStrAsDate'),
+					},
+					{
+						id: 3,
+						date: sql.placeholder('dateAsString'),
+						dateStr: sql.placeholder('dateStrAsString'),
+						timestamp: sql.placeholder('timestampAsString'),
+						timestampStr: sql.placeholder('timestampStrAsString'),
+					},
+					{
+						id: 4,
+						date: sql`${dateStr}`,
+						dateStr: sql`${dateStr}`,
+						timestamp: sql`${timestampStr}`,
+						timestampStr: sql`${timestampStr}`,
+					},
+				])
+				.returning()
+				.execute({
+					dateAsDate: date,
+					dateAsString: dateStr,
+					dateStrAsDate: date,
+					dateStrAsString: dateStr,
+					timestampAsDate: timestamp,
+					timestampAsString: timestampStr,
+					timestampStrAsDate: timestamp,
+					timestampStrAsString: timestampStr,
+				});
+
+			const updated = await db
+				.update(dateTable)
+				.set({
+					date: sql`${dateStr}`,
+					dateStr: sql`${dateStr}`,
+					timestamp: sql`${timestampStr}`,
+					timestampStr: sql`${timestampStr}`,
+				})
+				.returning();
+
+			expect(initial).toStrictEqual([
+				{
+					id: 1,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 2,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 3,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 4,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+			]);
+
+			expect(updated).toStrictEqual(initial);
+		});
+
+		test('all types', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.execute(
+				sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`,
+			);
+			await db.execute(sql`
+				CREATE TABLE "all_types" (
+					"int4" int4 NOT NULL,
+					"bigint53" bigint NOT NULL,
+					"bigint64" bigint,
+					"bool" bool,
+					"boolean" bool,
+					"char" char,
+					"date" date,
+					"date_str" date,
+					"string" string,
+					"double" double precision,
+					"float" float,
+					"enum" "en",
+					"inet" "inet",
+					"interval" interval,
+					"jsonb" jsonb,
+					"numeric" numeric,
+					"numeric_num" numeric,
+					"numeric_big" numeric,
+					"real" real,
+					"smallint" smallint,
+					"text" text,
+					"time" time,
+					"timestamp" timestamp,
+					"timestamp_tz" timestamp with time zone,
+					"timestamp_str" timestamp,
+					"timestamp_tz_str" timestamp with time zone,
+					"uuid" uuid,
+					"varchar" varchar,
+					"arrint" int4[],
+					"arrbigint53" bigint[],
+					"arrbigint64" bigint[],
+					"arrbool" bool[],
+					"arrchar" char[],
+					"arrdate" date[],
+					"arrdate_str" date[],
+					"arrdouble" double precision[],
+					"arrenum" "en"[],
+					"arrinet" "inet"[],
+					"arrinterval" interval[],
+					"arrnumeric" numeric[],
+					"arrnumeric_num" numeric[],
+					"arrnumeric_big" numeric[],
+					"arrreal" real[],
+					"arrsmallint" smallint[],
+					"arrtext" text[],
+					"arrtime" time[],
+					"arrtimestamp" timestamp[],
+					"arrtimestamp_tz" timestamp with time zone[],
+					"arrtimestamp_str" timestamp[],
+					"arrtimestamp_tz_str" timestamp with time zone[],
+					"arruuid" uuid[],
+					"arrstring" string[],
+					"arrfloat" float[],
+					"arrvarchar" varchar[],
+					"bit" bit,
+					"varbit" varbit,
+					"arrbit" bit[],
+					"arrvarbit" varbit[],
+					"arrboolean" bool[]
+				);
+			`);
+
+			await db.insert(allTypesTable).values({
+				int4: 1,
+				bigint53: 9007199254740991,
+				bigint64: 5044565289845416380n,
+				bool: true,
+				char: 'c',
+				date: new Date(1741743161623),
+				dateStr: new Date(1741743161623).toISOString(),
+				double: 15.35325689124218,
+				enum: 'enVal1',
+				inet: '192.168.0.1/24',
+				interval: '-2 months',
+				jsonb: {
+					str: 'strvalb',
+					arr: ['strb', 11],
+				},
+				numeric: '475452353476',
+				numericNum: 9007199254740991,
+				numericBig: 5044565289845416380n,
+				real: 1.048596,
+				smallint: 15,
+				text: 'TEXT STRING',
+				time: '13:59:28',
+				timestamp: new Date(1741743161623),
+				timestampTz: new Date(1741743161623),
+				timestampStr: new Date(1741743161623).toISOString(),
+				timestampTzStr: new Date(1741743161623).toISOString(),
+				uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+				varchar: 'C4-',
+				arrbigint53: [9007199254740991],
+				arrbigint64: [5044565289845416380n],
+				arrbool: [true],
+				arrchar: ['c'],
+				arrinet: ['192.168.0.1/24'],
+				arrdate: [new Date(1741743161623)],
+				arrdateStr: [new Date(1741743161623).toISOString()],
+				arrdouble: [15.35325689124218],
+				arrenum: ['enVal1'],
+				arrint: [621],
+				arrinterval: ['-2 months'],
+				arrnumeric: ['475452353476'],
+				arrnumericNum: [9007199254740991],
+				arrnumericBig: [5044565289845416380n],
+				arrreal: [1.048596],
+				arrsmallint: [10],
+				arrtext: ['TEXT STRING'],
+				arrtime: ['13:59:28'],
+				arrtimestamp: [new Date(1741743161623)],
+				arrtimestampTz: [new Date(1741743161623)],
+				arrtimestampStr: [new Date(1741743161623).toISOString()],
+				arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+				arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+				arrvarchar: ['C4-'],
+				string: 'TEXT STRING',
+				arrfloat: [1.12, 1.13],
+				arrstring: ['TEXT STRING', 'TEXT STRING1'],
+				float: 1.12,
+				arrbit: ['1'],
+				arrvarbit: ['1'],
+				arrboolean: [true, false],
+				boolean: true,
+				varbit: '1',
+				bit: '1',
+			});
+
+			const rawRes = await db.select().from(allTypesTable);
+
+			type ExpectedType = {
+				int4: number | null;
+				bigint53: number | null;
+				bigint64: bigint | null;
+				bool: boolean | null;
+				char: string | null;
+				date: Date | null;
+				dateStr: string | null;
+				double: number | null;
+				enum: 'enVal1' | 'enVal2' | null;
+				inet: string | null;
+				interval: string | null;
+				jsonb: unknown;
+				numeric: string | null;
+				numericNum: number | null;
+				numericBig: bigint | null;
+				real: number | null;
+				smallint: number | null;
+				text: string | null;
+				time: string | null;
+				timestamp: Date | null;
+				timestampTz: Date | null;
+				timestampStr: string | null;
+				timestampTzStr: string | null;
+				uuid: string | null;
+				varchar: string | null;
+				arrint: number[] | null;
+				arrbigint53: number[] | null;
+				arrbigint64: bigint[] | null;
+				arrbool: boolean[] | null;
+				arrchar: string[] | null;
+				arrdate: Date[] | null;
+				arrdateStr: string[] | null;
+				arrdouble: number[] | null;
+				arrenum: ('enVal1' | 'enVal2')[] | null;
+				arrinet: string[] | null;
+				arrinterval: string[] | null;
+				arrnumeric: string[] | null;
+				arrnumericNum: number[] | null;
+				arrnumericBig: bigint[] | null;
+				arrreal: number[] | null;
+				arrsmallint: number[] | null;
+				arrtext: string[] | null;
+				arrtime: string[] | null;
+				arrtimestamp: Date[] | null;
+				arrtimestampTz: Date[] | null;
+				arrtimestampStr: string[] | null;
+				arrtimestampTzStr: string[] | null;
+				arruuid: string[] | null;
+				arrvarchar: string[] | null;
+				string: string | null;
+				arrfloat: number[] | null;
+				arrstring: string[] | null;
+				float: number | null;
+				arrbit: string[] | null;
+				arrvarbit: string[] | null;
+				arrboolean: boolean[] | null;
+				boolean: boolean | null;
+				varbit: string | null;
+				bit: string | null;
+			}[];
+
+			const expectedRes: ExpectedType = [
+				{
+					int4: 1,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bool: true,
+					char: 'c',
+					date: new Date('2025-03-12T00:00:00.000Z'),
+					dateStr: '2025-03-12',
+					double: 15.35325689124218,
+					enum: 'enVal1',
+					inet: '192.168.0.1/24',
+					interval: '-2 mons',
+					jsonb: { arr: ['strb', 11], str: 'strvalb' },
+					numeric: '475452353476',
+					numericNum: 9007199254740991,
+					numericBig: 5044565289845416380n,
+					real: 1.048596,
+					smallint: 15,
+					text: 'TEXT STRING',
+					time: '13:59:28',
+					timestamp: new Date('2025-03-12T01:32:41.623Z'),
+					timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+					timestampStr: '2025-03-12 01:32:41.623',
+					timestampTzStr: '2025-03-12 01:32:41.623+00',
+					uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+					varchar: 'C4-',
+					arrint: [621],
+					arrbigint53: [9007199254740991],
+					arrbigint64: [5044565289845416380n],
+					arrbool: [true],
+					arrchar: ['c'],
+					arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+					arrdateStr: ['2025-03-12'],
+					arrdouble: [15.35325689124218],
+					arrenum: ['enVal1'],
+					arrinet: ['192.168.0.1/24'],
+					arrinterval: ['-2 mons'],
+					arrnumeric: ['475452353476'],
+					arrnumericNum: [9007199254740991],
+					arrnumericBig: [5044565289845416380n],
+					arrreal: [1.048596],
+					arrsmallint: [10],
+					arrtext: ['TEXT STRING'],
+					arrtime: ['13:59:28'],
+					arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+					arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+					arrtimestampStr: ['2025-03-12 01:32:41.623'],
+					arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+					arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+					arrvarchar: ['C4-'],
+					arrfloat: [1.12, 1.13],
+					arrstring: ['TEXT STRING', 'TEXT STRING1'],
+					float: 1.12,
+					string: 'TEXT STRING',
+					arrbit: ['1'],
+					arrboolean: [true, false],
+					arrvarbit: ['1'],
+					bit: '1',
+					boolean: true,
+					varbit: '1',
+				},
+			];
+
+			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+			expect(rawRes).toStrictEqual(expectedRes);
+		});
+
+		test('generated always columns', async (ctx) => {
+			const { db } = ctx.cockroach;
+
+			await db.execute(sql`
+				CREATE TABLE "gen_columns" (
+					id int4,
+					gen1 int4 generated always as (1) stored
+				);
+			`);
+
+			const genColumns = cockroachTable('gen_columns', {
+				id: int4(),
+				gen1: int4().generatedAlwaysAs(sql`1`),
+			});
+
+			expect(db.insert(genColumns).values({ id: 1 })).resolves;
+		});
+
+		test('sql.identifier escape', async () => {
+			const dialect = new CockroachDialect();
+			const userInput = 'id" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+			const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+			const str = dialect.sqlToQuery(query);
+			expect(str.sql).toBe(
+				'SELECT * FROM "users" ORDER BY "id"" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--" ASC',
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4612
+		test('select with inline params in sql', async (ctx) => {
+			const { db } = ctx.cockroach;
+			const users = cockroachTable('users_115', {
+				id: int4('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const query = db
+				.select({ sum: sql`sum(${3})`.inlineParams() })
+				.from(users);
+
+			expect(query.toSQL()).toStrictEqual({
+				sql: 'select sum(3) from "users_115"',
+				params: [],
+			});
+		});
+
+		test.skipIf(Date.now() < +new Date('2026-07-01'))('Query error wrapping', async ({ cockroach: { db } }) => {
+			await expect(db.insert(users2Table).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]))
+				.rejects.toBeInstanceOf(DrizzleQueryError);
+		});
+	});
+}
diff --git a/integration-tests/tests/cockroach/custom.test.ts b/integration-tests/tests/cockroach/custom.test.ts
new file mode 100644
index 0000000000..305dec6a7c
--- /dev/null
+++ b/integration-tests/tests/cockroach/custom.test.ts
@@ -0,0 +1,816 @@
+import retry from 'async-retry';
+import { asc, eq, sql } from 'drizzle-orm';
+import type { NodeCockroachDatabase } from 'drizzle-orm/cockroach';
+import { drizzle } from 'drizzle-orm/cockroach';
+import { alias, cockroachTable, cockroachTableCreator, customType, int4, text } from 'drizzle-orm/cockroach-core';
+import { migrate } from 'drizzle-orm/cockroach/migrator';
+import { Client } from 'pg';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { randomString } from '~/utils';
+import { requireCockroachConnectionString } from './common';
+
+const ENABLE_LOGGING = false;
+
+let db: NodeCockroachDatabase;
+let client: Client;
+
+beforeAll(async () => {
+	const connectionString = requireCockroachConnectionString();
+	client = await retry(async () => {
+		client = new Client(connectionString);
+		await client.connect();
+		return client;
+	}, {
+		retries: 20,
+		factor: 1,
+		minTimeout: 250,
+		maxTimeout: 250,
+		randomize: false,
+		onRetry() {
+			client?.end();
+		},
+	});
+	db = drizzle({ client, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end();
+});
+
+beforeEach((ctx) => {
+	ctx.cockroach = {
+		db,
+	};
+});
+
+const customInt = customType<{ data: number; notNull: true; default: true; driverData: number | string }>({
+	dataType() {
+		return 'integer';
+	},
+	fromDriver(value: number | string): number {
+		if (typeof value === 'string') {
+			return Number.parseInt(value);
+		}
+
+		return value;
+	},
+});
+
+const customText = customType<{ data: string }>({
+	dataType() {
+		return 'text';
+	},
+});
+
+const customBoolean = customType<{ data: boolean }>({
+	dataType() {
+		return 'boolean';
+	},
+});
+
+const customJsonb = <TData>(name: string) =>
+	customType<{ data: TData; driverData: string }>({
+		dataType() {
+			return 'jsonb';
+		},
+		toDriver(value: TData): string {
+			return JSON.stringify(value);
+		},
+	})(name);
+
+const customTimestamp = customType<
+	{ data: Date; driverData: string; config: { withTimezone: boolean; precision?: number } }
+>({
+	dataType(config) {
+		const precision = config?.precision === undefined ? '' : ` (${config.precision})`;
+		return `timestamp${precision}${config?.withTimezone ? ' with time zone' : ''}`;
+	},
+	fromDriver(value: string): Date {
+		return new Date(value);
+	},
+});
+
+const usersTable = cockroachTable('users', {
+	id: customInt('id').primaryKey(), // generated
+	name: customText('name').notNull(),
+	verified: customBoolean('verified').notNull().default(false),
+	jsonb: customJsonb<string[]>('jsonb'),
+	createdAt: customTimestamp('created_at', { withTimezone: true }).notNull().default(sql`now()`),
+});
+
+const usersMigratorTable = cockroachTable('users12', {
+	id: int4('id').primaryKey().generatedAlwaysAsIdentity(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+beforeEach(async (ctx) => {
+	const { db } = ctx.cockroach;
+	await db.execute(sql`drop database defaultdb;`);
+	await db.execute(sql`create database defaultdb;`);
+	await db.execute(
+		sql`
+			create table users (
+				id integer primary key generated by default as identity,
+				name text not null,
+				verified boolean not null default false, 
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+	);
+});
+
+test('select all fields', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+	expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(100);
+
+	expect(result).toEqual([{
+		id: 1,
+		name: 'John',
+		verified: false,
+		jsonb: null,
+		createdAt: result[0]!.createdAt,
+	}]);
+});
+
+test('select sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select typed sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql<string>`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('insert returning sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const users = await db.insert(usersTable).values({ name: 'John' }).returning({
+		name: sql`upper(${usersTable.name})`,
+	});
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('delete returning sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+		name: sql`upper(${usersTable.name})`,
+	});
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('update returning sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
+		name: sql`upper(${usersTable.name})`,
+	});
+
+	expect(users).toEqual([{ name: 'JANE' }]);
+});
+
+test('update with returning all fields', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning();
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+	expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(100);
+
+	expect(users).toEqual([{
+		id: 1,
+		name: 'Jane',
+		verified: false,
+		jsonb: null,
+		createdAt: users[0]!.createdAt,
+	}]);
+});
+
+test('update with returning partial', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
+		name: usersTable.name,
+	});
+
+	expect(users).toEqual([{ name: 'Jane' }]);
+});
+
+test('delete with returning all fields', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+	expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(100);
+
+	expect(users).toEqual([{
+		id: 1,
+		name: 'John',
+		verified: false,
+		jsonb: null,
+		createdAt: users[0]!.createdAt,
+	}]);
+});
+
+test('delete with returning partial', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+		name: usersTable.name,
+	});
+
+	expect(users).toEqual([{ name: 'John' }]);
+});
+
+test('insert + select', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	expect(result).toEqual([{
+		id: 1,
+		name: 'John',
+		verified: false,
+		jsonb: null,
+		createdAt: result[0]!.createdAt,
+	}]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	expect(result2).toEqual([
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test('json insert', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db.select({
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+	}).from(usersTable);
+
+	expect(result).toEqual([{ name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test('insert with overridden default values', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ id: 1, name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	expect(result).toEqual([{
+		id: 1,
+		name: 'John',
+		verified: true,
+		jsonb: null,
+		createdAt: result[0]!.createdAt,
+	}]);
+});
+
+test('insert many', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+	const result = await db.select({
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ name: 'John', jsonb: null, verified: false },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ name: 'Jane', jsonb: null, verified: false },
+		{ name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('insert many with returning', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const result = await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	])
+		.returning({
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+			verified: usersTable.verified,
+		});
+
+	expect(result).toEqual([
+		{ name: 'John', jsonb: null, verified: false },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ name: 'Jane', jsonb: null, verified: false },
+		{ name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('select with group by as field', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.name);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test('select with group by as sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test('select with group by as sql + column', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by as column + sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by complex query', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.limit(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test('build query', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+		params: [],
+	});
+});
+
+test('insert sql', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('partial join with alias', async (ctx) => {
+	const { db } = ctx.cockroach;
+	const customerAlias = alias(usersTable, 'customer');
+
+	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersTable.id,
+				name: usersTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		}).from(usersTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+		.where(eq(usersTable.id, 10));
+
+	expect(result).toEqual([{
+		user: { id: 10, name: 'Ivan' },
+		customer: { id: 11, name: 'Hans' },
+	}]);
+});
+
+test('full join with alias', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const cockroachTable = cockroachTableCreator((name) => `prefixed_${name}`);
+
+	const users = cockroachTable('users', {
+		id: int4('id').primaryKey().generatedByDefaultAsIdentity(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int4 generated by default as identity primary key, name text not null)`,
+	);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+
+	const result = await db
+		.select().from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([{
+		users: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('insert with spaces', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ name: usersTable.name }).from(usersTable);
+
+	expect(result).toEqual([{ name: 'Jo   h     n' }]);
+});
+
+test('prepared statement', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db.select({
+		name: usersTable.name,
+	}).from(usersTable)
+		.prepare('statement1');
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ name: 'John' }]);
+});
+
+test('prepared statement reuse', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const stmt = db.insert(usersTable).values({
+		verified: true,
+		name: sql.placeholder('name'),
+	}).prepare('stmt2');
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db.select({
+		name: usersTable.name,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ name: 'John 0', verified: true },
+		{ name: 'John 1', verified: true },
+		{ name: 'John 2', verified: true },
+		{ name: 'John 3', verified: true },
+		{ name: 'John 4', verified: true },
+		{ name: 'John 5', verified: true },
+		{ name: 'John 6', verified: true },
+		{ name: 'John 7', verified: true },
+		{ name: 'John 8', verified: true },
+		{ name: 'John 9', verified: true },
+	]);
+});
+
+test('prepared statement with placeholder in .where', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values({ id: 1, name: 'John' });
+	const stmt = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.where(eq(usersTable.id, sql.placeholder('id')))
+		.prepare('stmt3');
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('prepared statement with placeholder in .limit', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'John2' }]);
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.where(eq(usersTable.id, sql.placeholder('id')))
+		.limit(sql.placeholder('limit'))
+		.prepare('stmt_limit');
+
+	const result = await stmt.execute({ id: 1, limit: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+	expect(result).toHaveLength(1);
+});
+
+test('prepared statement with placeholder in .offset', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'John1' }]);
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.offset(sql.placeholder('offset'))
+		.prepare('stmt_offset');
+
+	const result = await stmt.execute({ offset: 1 });
+
+	expect(result).toEqual([{ id: 2, name: 'John1' }]);
+});
+
+test('migrator : default migration strategy', async () => {
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+});
+
+test('migrator : migrate with custom schema', async () => {
+	const customSchema = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach', migrationsSchema: customSchema });
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
+	expect(rowCount! > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
+});
+
+test('migrator : migrate with custom table', async () => {
+	const customTable = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/cockroach', migrationsTable: customTable });
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+	expect(rowCount! > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
+});
+
+test('migrator : migrate with custom table and custom schema', async () => {
+	const customTable = randomString();
+	const customSchema = randomString();
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+	await migrate(db, {
+		migrationsFolder: './drizzle2/cockroach',
+		migrationsTable: customTable,
+		migrationsSchema: customSchema,
+	});
+
+	// test if the custom migrations table was created
+	const { rowCount } = await db.execute(
+		sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
+	);
+	expect(rowCount! > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
+});
+
+test('insert via db.execute + select via db.execute', async () => {
+	await db.execute(sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`);
+
+	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
+	expect(result.rows).toEqual([{ id: '1', name: 'John' }]);
+});
+
+test('insert via db.execute + returning', async () => {
+	const inserted = await db.execute<{ id: number; name: string }>(
+		sql`insert into ${usersTable} (${
+			sql.identifier(usersTable.name.name)
+		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+	);
+	expect(inserted.rows).toEqual([{ id: '1', name: 'John' }]);
+});
+
+test('insert via db.execute w/ query builder', async () => {
+	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+		db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+	);
+	expect(inserted.rows).toEqual([{ id: '1', name: 'John' }]);
+});
+
+test('build query insert with onConflict do update', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const query = db.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test('build query insert with onConflict do update / multiple columns', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const query = db.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test('build query insert with onConflict do nothing', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const query = db.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing()
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test('build query insert with onConflict do nothing + target', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	const query = db.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing({ target: usersTable.id })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test('insert with onConflict do update', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await db.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	expect(res).toEqual([{ id: 1, name: 'John1' }]);
+});
+
+test('insert with onConflict do nothing', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await db.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onConflictDoNothing();
+
+	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	expect(res).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('insert with onConflict do nothing + target', async (ctx) => {
+	const { db } = ctx.cockroach;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await db.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onConflictDoNothing({ target: usersTable.id });
+
+	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	expect(res).toEqual([{ id: 1, name: 'John' }]);
+});
diff --git a/integration-tests/tests/extensions/postgis/pg.test.ts b/integration-tests/tests/extensions/postgis/pg.test.ts
index 45d6f19b3d..b5a77be38f 100644
--- a/integration-tests/tests/extensions/postgis/pg.test.ts
+++ b/integration-tests/tests/extensions/postgis/pg.test.ts
@@ -1,83 +1,16 @@
-import Docker from 'dockerode';
-import { sql } from 'drizzle-orm';
+import { defineRelations, sql } from 'drizzle-orm';
 import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { drizzle } from 'drizzle-orm/node-postgres';
-import { bigserial, geometry, line, pgTable, point } from 'drizzle-orm/pg-core';
-import getPort from 'get-port';
+import { bigserial, customType, geometry, integer, line, pgTable, point } from 'drizzle-orm/pg-core';
 import pg from 'pg';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
 
 const { Client } = pg;
 
 const ENABLE_LOGGING = false;
 
-let pgContainer: Docker.Container;
-let docker: Docker;
 let client: pg.Client;
-let db: NodePgDatabase;
-
-async function createDockerDB(): Promise<string> {
-	const inDocker = (docker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'postgis/postgis:16-3.4';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		inDocker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_POSTGIS_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = new Client(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-
-	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
+let db: NodePgDatabase<typeof relations>;
 
 const items = pgTable('items', {
 	id: bigserial('id', { mode: 'number' }).primaryKey(),
@@ -90,8 +23,33 @@ const items = pgTable('items', {
 	geoSrid: geometry('geo_options', { type: 'point', mode: 'xy', srid: 4000 }),
 });
 
+const relations = defineRelations({ items }, (r) => ({
+	items: {
+		self: r.many.items({
+			from: r.items.id,
+			to: r.items.id,
+		}),
+	},
+}));
+
+beforeAll(async () => {
+	const connectionString = process.env['PG_POSTGIS_CONNECTION_STRING'];
+	if (!connectionString) throw new Error('PG_POSTGIS_CONNECTION_STRING is not set in env variables');
+
+	client = new Client(connectionString);
+	await client.connect();
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations });
+
+	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
 beforeEach(async () => {
 	await db.execute(sql`drop table if exists items cascade`);
+	await db.execute(sql`drop table if exists geofences cascade`);
 	await db.execute(sql`
 		CREATE TABLE items (
 		          id bigserial PRIMARY KEY, 
@@ -141,3 +99,115 @@ test('insert + select', async () => {
 		geoSrid: { x: 1, y: 2 },
 	}]);
 });
+
+test('RQBv2', async () => {
+	await db.insert(items).values([{
+		point: [1, 2],
+		pointObj: { x: 1, y: 2 },
+		line: [1, 2, 3],
+		lineObj: { a: 1, b: 2, c: 3 },
+		geo: [1, 2],
+		geoObj: { x: 1, y: 2 },
+		geoSrid: { x: 1, y: 2 },
+	}]).returning();
+
+	const rawResponse = await db.select().from(items);
+	const rootRqbResponse = await db.query.items.findMany();
+	const { self: nestedRqbResponse } = (await db.query.items.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	expectTypeOf(rootRqbResponse).toEqualTypeOf(rawResponse);
+	expectTypeOf(nestedRqbResponse).toEqualTypeOf(rawResponse);
+
+	expect(rootRqbResponse).toStrictEqual(rawResponse);
+	expect(nestedRqbResponse).toStrictEqual(rawResponse);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5711
+test('No wrong codec autoresolution', async () => {
+	const polygon = customType<{ data: [number, number][][]; driverData: string }>({
+		dataType() {
+			return 'geometry(Polygon, 4326)';
+		},
+		toDriver(value) {
+			return sql`ST_GeomFromText(
+				'POLYGON(${
+				sql.raw(
+					value.map((v) => `(${v.map((v1) => `${v1[0]!} ${v1[1]!}`).join(', ')})`).join(', '),
+				)
+			})',
+				4326
+			)`;
+		},
+		fromDriver(ewkb: string) {
+			const buffer = Buffer.from(ewkb, 'hex');
+			const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+
+			let offset = 0;
+
+			const littleEndian = view.getUint8(offset) === 1;
+			offset += 1;
+
+			const getUint32 = () => {
+				const val = view.getUint32(offset, littleEndian);
+				offset += 4;
+				return val;
+			};
+
+			const getFloat64 = () => {
+				const val = view.getFloat64(offset, littleEndian);
+				offset += 8;
+				return val;
+			};
+
+			const typeWithFlags = getUint32();
+			const hasSRID = (typeWithFlags & 0x20000000) !== 0;
+			if (hasSRID) {
+				const srid = getUint32();
+			}
+
+			const numRings = getUint32();
+			const rings: [number, number][][] = [];
+
+			for (let i = 0; i < numRings; i++) {
+				const numPoints = getUint32();
+				const ring: [number, number][] = [];
+
+				for (let j = 0; j < numPoints; j++) {
+					const x = getFloat64();
+					const y = getFloat64();
+					ring.push([x, y]);
+				}
+
+				rings.push(ring);
+			}
+
+			return rings;
+		},
+	});
+
+	const Geofence = pgTable('geofences', {
+		id: integer().primaryKey(),
+		polygon: polygon('polygon').notNull(),
+	});
+
+	await db.execute(sql`CREATE TABLE IF NOT EXISTS geofences (
+		id INTEGER PRIMARY KEY,
+		polygon geometry(Polygon, 4326)
+	)`);
+
+	await db.insert(Geofence).values({
+		id: 1,
+		polygon: [[[30.0, 50.0], [30.1, 50.0], [30.1, 50.1], [30.0, 50.1], [30.0, 50.0]]],
+	});
+
+	const res = await db.select().from(Geofence);
+
+	expect(res).toStrictEqual([{
+		id: 1,
+		polygon: [[[30.0, 50.0], [30.1, 50.0], [30.1, 50.1], [30.0, 50.1], [30.0, 50.0]]],
+	}]);
+});
diff --git a/integration-tests/tests/extensions/postgis/postgres.test.ts b/integration-tests/tests/extensions/postgis/postgres.test.ts
index 071ea2532f..f6c0e7b5e7 100644
--- a/integration-tests/tests/extensions/postgis/postgres.test.ts
+++ b/integration-tests/tests/extensions/postgis/postgres.test.ts
@@ -1,85 +1,13 @@
-import Docker from 'dockerode';
-import { sql } from 'drizzle-orm';
-import { bigserial, geometry, line, pgTable, point } from 'drizzle-orm/pg-core';
+import { defineRelations, sql } from 'drizzle-orm';
+import { bigserial, customType, geometry, integer, line, pgTable, point } from 'drizzle-orm/pg-core';
 import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import getPort from 'get-port';
 import postgres, { type Sql } from 'postgres';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
 
 const ENABLE_LOGGING = false;
 
-let pgContainer: Docker.Container;
-let docker: Docker;
 let client: Sql;
-let db: PostgresJsDatabase;
-
-async function createDockerDB(): Promise<string> {
-	const inDocker = (docker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'postgis/postgis:16-3.4';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		inDocker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_POSTGIS_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 1000;
-	let timeLeft = 20000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = postgres(connectionString, {
-				max: 1,
-				onnotice: () => {
-					// disable notices
-				},
-			});
-			await client`select 1`;
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-
-	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
+let db: PostgresJsDatabase<typeof relations>;
 
 const items = pgTable('items', {
 	id: bigserial('id', { mode: 'number' }).primaryKey(),
@@ -92,8 +20,38 @@ const items = pgTable('items', {
 	geoSrid: geometry('geo_options', { type: 'point', mode: 'xy', srid: 4000 }),
 });
 
+const relations = defineRelations({ items }, (r) => ({
+	items: {
+		self: r.many.items({
+			from: r.items.id,
+			to: r.items.id,
+		}),
+	},
+}));
+
+beforeAll(async () => {
+	const connectionString = process.env['PG_POSTGIS_CONNECTION_STRING'];
+	if (!connectionString) throw new Error('PG_POSTGIS_CONNECTION_STRING is not set in env variables');
+
+	client = postgres(connectionString, {
+		max: 1,
+		onnotice: () => {
+			// disable notices
+		},
+	});
+	await client`select 1`;
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations });
+
+	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
 beforeEach(async () => {
 	await db.execute(sql`drop table if exists items cascade`);
+	await db.execute(sql`drop table if exists geofences cascade`);
 	await db.execute(sql`
 		CREATE TABLE items (
 		          id bigserial PRIMARY KEY, 
@@ -143,3 +101,115 @@ test('insert + select', async () => {
 		geoSrid: { x: 1, y: 2 },
 	}]);
 });
+
+test('RQBv2', async () => {
+	await db.insert(items).values([{
+		point: [1, 2],
+		pointObj: { x: 1, y: 2 },
+		line: [1, 2, 3],
+		lineObj: { a: 1, b: 2, c: 3 },
+		geo: [1, 2],
+		geoObj: { x: 1, y: 2 },
+		geoSrid: { x: 1, y: 2 },
+	}]).returning();
+
+	const rawResponse = await db.select().from(items);
+	const rootRqbResponse = await db.query.items.findMany();
+	const { self: nestedRqbResponse } = (await db.query.items.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	expectTypeOf(rootRqbResponse).toEqualTypeOf(rawResponse);
+	expectTypeOf(nestedRqbResponse).toEqualTypeOf(rawResponse);
+
+	expect(rootRqbResponse).toStrictEqual(rawResponse);
+	expect(nestedRqbResponse).toStrictEqual(rawResponse);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5711
+test('No wrong codec autoresolution', async () => {
+	const polygon = customType<{ data: [number, number][][]; driverData: string }>({
+		dataType() {
+			return 'geometry(Polygon, 4326)';
+		},
+		toDriver(value) {
+			return sql`ST_GeomFromText(
+				'POLYGON(${
+				sql.raw(
+					value.map((v) => `(${v.map((v1) => `${v1[0]!} ${v1[1]!}`).join(', ')})`).join(', '),
+				)
+			})',
+				4326
+			)`;
+		},
+		fromDriver(ewkb: string) {
+			const buffer = Buffer.from(ewkb, 'hex');
+			const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+
+			let offset = 0;
+
+			const littleEndian = view.getUint8(offset) === 1;
+			offset += 1;
+
+			const getUint32 = () => {
+				const val = view.getUint32(offset, littleEndian);
+				offset += 4;
+				return val;
+			};
+
+			const getFloat64 = () => {
+				const val = view.getFloat64(offset, littleEndian);
+				offset += 8;
+				return val;
+			};
+
+			const typeWithFlags = getUint32();
+			const hasSRID = (typeWithFlags & 0x20000000) !== 0;
+			if (hasSRID) {
+				const srid = getUint32();
+			}
+
+			const numRings = getUint32();
+			const rings: [number, number][][] = [];
+
+			for (let i = 0; i < numRings; i++) {
+				const numPoints = getUint32();
+				const ring: [number, number][] = [];
+
+				for (let j = 0; j < numPoints; j++) {
+					const x = getFloat64();
+					const y = getFloat64();
+					ring.push([x, y]);
+				}
+
+				rings.push(ring);
+			}
+
+			return rings;
+		},
+	});
+
+	const Geofence = pgTable('geofences', {
+		id: integer().primaryKey(),
+		polygon: polygon('polygon').notNull(),
+	});
+
+	await db.execute(sql`CREATE TABLE IF NOT EXISTS geofences (
+		id INTEGER PRIMARY KEY,
+		polygon geometry(Polygon, 4326)
+	)`);
+
+	await db.insert(Geofence).values({
+		id: 1,
+		polygon: [[[30.0, 50.0], [30.1, 50.0], [30.1, 50.1], [30.0, 50.1], [30.0, 50.0]]],
+	});
+
+	const res = await db.select().from(Geofence);
+
+	expect(res).toStrictEqual([{
+		id: 1,
+		polygon: [[[30.0, 50.0], [30.1, 50.0], [30.1, 50.1], [30.0, 50.1], [30.0, 50.0]]],
+	}]);
+});
diff --git a/integration-tests/tests/extensions/vectors/pg.test.ts b/integration-tests/tests/extensions/vectors/pg.test.ts
index f849cce0be..7b59cc018b 100644
--- a/integration-tests/tests/extensions/vectors/pg.test.ts
+++ b/integration-tests/tests/extensions/vectors/pg.test.ts
@@ -1,90 +1,47 @@
-import Docker from 'dockerode';
-import { eq, hammingDistance, jaccardDistance, l2Distance, not, sql } from 'drizzle-orm';
+import { defineRelations, eq, hammingDistance, jaccardDistance, l2Distance, not, sql } from 'drizzle-orm';
 import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { bigserial, bit, halfvec, pgTable, sparsevec, vector } from 'drizzle-orm/pg-core';
-import getPort from 'get-port';
 import pg from 'pg';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
 
 const { Client } = pg;
 
 const ENABLE_LOGGING = false;
 
-let pgContainer: Docker.Container;
-let docker: Docker;
 let client: pg.Client;
-let db: NodePgDatabase;
-
-async function createDockerDB(): Promise<string> {
-	const inDocker = (docker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'pgvector/pgvector:pg16';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		inDocker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
+let db: NodePgDatabase<typeof relations>;
 
-	await pgContainer.start();
+const items = pgTable('items', {
+	id: bigserial('id', { mode: 'number' }).primaryKey(),
+	vector: vector('vector', { dimensions: 3 }),
+	bit: bit('bit', { dimensions: 3 }),
+	halfvec: halfvec('halfvec', { dimensions: 3 }),
+	sparsevec: sparsevec('sparsevec', { dimensions: 5 }),
+});
 
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
+const relations = defineRelations({ items }, (r) => ({
+	items: {
+		self: r.many.items({
+			from: r.items.id,
+			to: r.items.id,
+		}),
+	},
+}));
 
 beforeAll(async () => {
-	const connectionString = process.env['PG_VECTOR_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = new Client(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { logger: ENABLE_LOGGING });
+	const connectionString = process.env['PG_VECTOR_CONNECTION_STRING'];
+	if (!connectionString) throw new Error('PG_VECTOR_CONNECTION_STRING is not set in env variables');
+
+	client = new Client(connectionString);
+	await client.connect();
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations });
 
 	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS vector;`);
 });
 
 afterAll(async () => {
 	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-const items = pgTable('items', {
-	id: bigserial('id', { mode: 'number' }).primaryKey(),
-	vector: vector('vector', { dimensions: 3 }),
-	bit: bit('bit', { dimensions: 3 }),
-	halfvec: halfvec('halfvec', { dimensions: 3 }),
-	sparsevec: sparsevec('sparsevec', { dimensions: 5 }),
 });
 
 beforeEach(async () => {
@@ -187,7 +144,7 @@ test('insert + order by subquery', async () => {
 
 	expect(query.toSQL()).toStrictEqual({
 		sql:
-			'select "id", "vector", "bit", "halfvec", "sparsevec" from "items" where not "items"."id" = $1 order by "items"."vector" <-> (select "vector" from "items" where "items"."id" = $2) limit $3',
+			'select "id", "vector", "bit", "halfvec", "sparsevec" from "items" where not ("items"."id" = $1) order by "items"."vector" <-> (select "vector" from "items" where "items"."id" = $2) limit $3',
 		params: [1, 1, 5],
 	});
 	const res = await query;
@@ -379,3 +336,26 @@ test('select + insert all vectors', async () => {
 		sparsevec: '{1:1,3:2,5:3}/5',
 	}]);
 });
+
+test('RQBv2', async () => {
+	await db.insert(items).values([{
+		vector: [3, 1, 2],
+		bit: '000',
+		halfvec: [1, 2, 3],
+		sparsevec: '{1:1,3:2,5:3}/5',
+	}]).returning();
+
+	const rawResponse = await db.select().from(items);
+	const rootRqbResponse = await db.query.items.findMany();
+	const { self: nestedRqbResponse } = (await db.query.items.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	expectTypeOf(rootRqbResponse).toEqualTypeOf(rawResponse);
+	expectTypeOf(nestedRqbResponse).toEqualTypeOf(rawResponse);
+
+	expect(rootRqbResponse).toStrictEqual(rawResponse);
+	expect(nestedRqbResponse).toStrictEqual(rawResponse);
+});
diff --git a/integration-tests/tests/extensions/vectors/postgres.test.ts b/integration-tests/tests/extensions/vectors/postgres.test.ts
index b6f5884cf6..cd7010685d 100644
--- a/integration-tests/tests/extensions/vectors/postgres.test.ts
+++ b/integration-tests/tests/extensions/vectors/postgres.test.ts
@@ -1,92 +1,86 @@
-import Docker from 'dockerode';
-import { eq, hammingDistance, jaccardDistance, l2Distance, not, sql } from 'drizzle-orm';
-import { bigserial, bit, halfvec, pgTable, sparsevec, vector } from 'drizzle-orm/pg-core';
+import {
+	defineRelations,
+	desc,
+	eq,
+	getColumns,
+	hammingDistance,
+	jaccardDistance,
+	l2Distance,
+	not,
+	SQL,
+	sql,
+} from 'drizzle-orm';
+import { bigserial, bit, customType, halfvec, pgTable, sparsevec, text, vector } from 'drizzle-orm/pg-core';
 import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import getPort from 'get-port';
 import postgres, { type Sql } from 'postgres';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
 
 const ENABLE_LOGGING = false;
 
-let pgContainer: Docker.Container;
-let docker: Docker;
 let client: Sql;
-let db: PostgresJsDatabase;
+let db: PostgresJsDatabase<typeof relations>;
 
-async function createDockerDB(): Promise<string> {
-	const inDocker = (docker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'pgvector/pgvector:pg16';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		inDocker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
+const items = pgTable('items', {
+	id: bigserial('id', { mode: 'number' }).primaryKey(),
+	vector: vector('vector', { dimensions: 3 }),
+	bit: bit('bit', { dimensions: 3 }),
+	halfvec: halfvec('halfvec', { dimensions: 3 }),
+	sparsevec: sparsevec('sparsevec', { dimensions: 5 }),
+});
 
-	await pgContainer.start();
+const relations = defineRelations({ items }, (r) => ({
+	items: {
+		self: r.many.items({
+			from: r.items.id,
+			to: r.items.id,
+		}),
+	},
+}));
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+	log?: 'statements',
+) => {
+	const { diff } = await import('../../../../drizzle-kit/tests/postgres/mocks' as string);
+
+	const res = await diff({}, schema, []);
+
+	for (const s of res.sqlStatements) {
+		if (log === 'statements') console.log(s);
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
 
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
+let push: (schema: any, options?: { log: 'statements' }) => Promise<void>;
 
 beforeAll(async () => {
-	const connectionString = process.env['PG_VECTOR_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = postgres(connectionString, {
-				max: 1,
-				onnotice: () => {
-					// disable notices
-				},
-			});
-			await client`select 1`;
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { logger: ENABLE_LOGGING });
+	const connectionString = process.env['PG_VECTOR_CONNECTION_STRING'];
+	if (!connectionString) throw new Error('PG_VECTOR_CONNECTION_STRING is not set in env variables');
+
+	client = postgres(connectionString, {
+		max: 1,
+		onnotice: () => {
+			// disable notices
+		},
+	});
+	await client`select 1`;
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations });
 
 	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS vector;`);
+
+	push = async (
+		schema: any,
+		options?: { log: 'statements' },
+	) => await _push(client.unsafe, schema, options?.log);
 });
 
 afterAll(async () => {
 	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-const items = pgTable('items', {
-	id: bigserial('id', { mode: 'number' }).primaryKey(),
-	vector: vector('vector', { dimensions: 3 }),
-	bit: bit('bit', { dimensions: 3 }),
-	halfvec: halfvec('halfvec', { dimensions: 3 }),
-	sparsevec: sparsevec('sparsevec', { dimensions: 5 }),
 });
 
 beforeEach(async () => {
@@ -189,7 +183,7 @@ test('insert + order by subquery', async () => {
 
 	expect(query.toSQL()).toStrictEqual({
 		sql:
-			'select "id", "vector", "bit", "halfvec", "sparsevec" from "items" where not "items"."id" = $1 order by "items"."vector" <-> (select "vector" from "items" where "items"."id" = $2) limit $3',
+			'select "id", "vector", "bit", "halfvec", "sparsevec" from "items" where not ("items"."id" = $1) order by "items"."vector" <-> (select "vector" from "items" where "items"."id" = $2) limit $3',
 		params: [1, 1, 5],
 	});
 	const res = await query;
@@ -381,3 +375,104 @@ test('select + insert all vectors', async () => {
 		sparsevec: '{1:1,3:2,5:3}/5',
 	}]);
 });
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5358
+test('select with getColumns spread containing custom type', async () => {
+	const vector = customType<{
+		data: number[];
+		driverData: string;
+		config: { dimensions: number };
+	}>({
+		codec: 'vector',
+		dataType(config) {
+			return `vector(${config?.dimensions ?? 3})`;
+		},
+		toDriver(value: number[]): string {
+			return `[${value.join(',')}]`;
+		},
+	});
+
+	const tsvector = customType<{ data: string }>({
+		codec: 'tsvector',
+		dataType() {
+			return 'tsvector';
+		},
+	});
+
+	const items = pgTable('items1', {
+		name: text('name').notNull(),
+		embedding: vector('embedding', { dimensions: 3 }),
+		searchVector: tsvector('search_vector').generatedAlwaysAs(
+			(): SQL => sql`to_tsvector('english', coalesce(${items.name}, ''))`,
+		),
+	});
+
+	const schema = { items };
+	await db.execute(sql`drop table if exists items1`);
+	await push(schema);
+
+	await db
+		.insert(schema.items)
+		.values({ name: 'hello world', embedding: [0.3, 0.2, 0.1] });
+
+	const queryVec = '[0.1, 0.2, 0.3]';
+
+	const distanceExpr = sql<number>`(${schema.items.embedding} <=> ${queryVec}::vector)`.as(
+		'distance',
+	);
+
+	const result1 = await db
+		.select({
+			...getColumns(schema.items),
+			distance: distanceExpr,
+		})
+		.from(schema.items)
+		.orderBy(sql`${schema.items.embedding} <=> ${queryVec}::vector`)
+		.limit(5);
+
+	expect(result1[0]?.distance).toBeCloseTo(0.2857, 4);
+
+	const queryText = 'hello';
+	const rankExpr = sql<
+		number
+	>`ts_rank_cd(${schema.items.searchVector}, websearch_to_tsquery('english', ${queryText}))`.as(
+		'rank',
+	);
+
+	const result2 = await db
+		.select({
+			...getColumns(schema.items),
+			rank: rankExpr,
+		})
+		.from(schema.items)
+		.where(
+			sql`${schema.items.searchVector} @@ websearch_to_tsquery('english', ${queryText})`,
+		)
+		.orderBy(desc(rankExpr))
+		.limit(5);
+
+	expect(result2[0]?.rank).toBeCloseTo(0.1);
+});
+
+test('RQBv2', async () => {
+	await db.insert(items).values([{
+		vector: [3, 1, 2],
+		bit: '000',
+		halfvec: [1, 2, 3],
+		sparsevec: '{1:1,3:2,5:3}/5',
+	}]).returning();
+
+	const rawResponse = await db.select().from(items);
+	const rootRqbResponse = await db.query.items.findMany();
+	const { self: nestedRqbResponse } = (await db.query.items.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	expectTypeOf(rootRqbResponse).toEqualTypeOf(rawResponse);
+	expectTypeOf(nestedRqbResponse).toEqualTypeOf(rawResponse);
+
+	expect(rootRqbResponse).toStrictEqual(rawResponse);
+	expect(nestedRqbResponse).toStrictEqual(rawResponse);
+});
diff --git a/integration-tests/tests/gel/cache.ts b/integration-tests/tests/gel/cache.ts
deleted file mode 100644
index b8436aaaae..0000000000
--- a/integration-tests/tests/gel/cache.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { getTableName, is, Table } from 'drizzle-orm';
-import type { MutationOption } from 'drizzle-orm/cache/core';
-import { Cache } from 'drizzle-orm/cache/core';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import Keyv from 'keyv';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestGlobalCache extends Cache {
-	private globalTtl: number = 1000;
-	private usedTablesPerKey: Record<string, string[]> = {};
-
-	constructor(private kv: Keyv = new Keyv()) {
-		super();
-	}
-
-	override strategy(): 'explicit' | 'all' {
-		return 'all';
-	}
-	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
-		const res = await this.kv.get(key) ?? undefined;
-		return res;
-	}
-	override async put(
-		key: string,
-		response: any,
-		tables: string[],
-		isTag: boolean,
-		config?: CacheConfig,
-	): Promise<void> {
-		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
-		for (const table of tables) {
-			const keys = this.usedTablesPerKey[table];
-			if (keys === undefined) {
-				this.usedTablesPerKey[table] = [key];
-			} else {
-				keys.push(key);
-			}
-		}
-	}
-	override async onMutate(params: MutationOption): Promise<void> {
-		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
-		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
-
-		const keysToDelete = new Set<string>();
-
-		for (const table of tablesArray) {
-			const tableName = is(table, Table) ? getTableName(table) : table as string;
-			const keys = this.usedTablesPerKey[tableName] ?? [];
-			for (const key of keys) keysToDelete.add(key);
-		}
-
-		if (keysToDelete.size > 0 || tagsArray.length > 0) {
-			for (const tag of tagsArray) {
-				await this.kv.delete(tag);
-			}
-
-			for (const key of keysToDelete) {
-				await this.kv.delete(key);
-				for (const table of tablesArray) {
-					const tableName = is(table, Table) ? getTableName(table) : table as string;
-					this.usedTablesPerKey[tableName] = [];
-				}
-			}
-		}
-	}
-}
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestCache extends TestGlobalCache {
-	override strategy(): 'explicit' | 'all' {
-		return 'explicit';
-	}
-}
diff --git a/integration-tests/tests/gel/createInstance.ts b/integration-tests/tests/gel/createInstance.ts
deleted file mode 100644
index b7f0159564..0000000000
--- a/integration-tests/tests/gel/createInstance.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import Docker from 'dockerode';
-import getPort from 'get-port';
-import { v4 as uuidV4 } from 'uuid';
-import 'zx/globals';
-
-export async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5656 });
-	const image = 'geldata/gel:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	const gelContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'GEL_CLIENT_SECURITY=insecure_dev_mode',
-			'GEL_SERVER_SECURITY=insecure_dev_mode',
-			'GEL_CLIENT_TLS_SECURITY=no_host_verification',
-			'GEL_SERVER_PASSWORD=password',
-		],
-		name: `drizzle-integration-tests-${uuidV4()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5656/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await gelContainer.start();
-
-	return { connectionString: `gel://admin:password@localhost:${port}/main`, container: gelContainer };
-}
diff --git a/integration-tests/tests/gel/gel-custom.test.ts b/integration-tests/tests/gel/gel-custom.test.ts
deleted file mode 100644
index 7fd9fef289..0000000000
--- a/integration-tests/tests/gel/gel-custom.test.ts
+++ /dev/null
@@ -1,679 +0,0 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
-import { asc, eq, sql } from 'drizzle-orm';
-import { drizzle, type GelJsDatabase } from 'drizzle-orm/gel';
-import { alias, customType, gelTable, gelTableCreator } from 'drizzle-orm/gel-core';
-import * as gel from 'gel';
-import { afterAll, afterEach, beforeAll, beforeEach, expect, test } from 'vitest';
-import { createDockerDB } from './createInstance';
-import 'zx/globals';
-
-$.quiet = true;
-
-const ENABLE_LOGGING = false;
-
-let db: GelJsDatabase;
-let client: gel.Client;
-let container: Docker.Container | undefined;
-
-let dsn: string;
-const tlsSecurity = '--tls-security=insecure';
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['GEL_CONNECTION_STRING']) {
-		connectionString = process.env['GEL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	await sleep(15 * 1000);
-	client = await retry(async () => {
-		client = gel.createClient({ dsn: connectionString, tlsSecurity: 'insecure' });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-
-	dsn = connectionString;
-	await $`gel query "CREATE TYPE default::users_custom {
-		create property id1: int16 {
-			create constraint exclusive;
-		};
-		create required property name: str;
-		create property verified: bool {
-		  SET default := false;
-		};
-		create property json: json;
-	};" ${tlsSecurity} --dsn=${dsn}`;
-
-	await $`gel query "CREATE TYPE default::prefixed_users_custom {
-		create property id1: int16 {
-			create constraint exclusive;
-		};
-		create required property name: str;
-};" ${tlsSecurity} --dsn=${dsn}`;
-});
-
-afterAll(async () => {
-	await $`gel query "DROP TYPE default::users_custom;" ${tlsSecurity} --dsn=${dsn}`;
-	await $`gel query "DROP TYPE default::prefixed_users_custom;" ${tlsSecurity} --dsn=${dsn}`;
-
-	await client?.close();
-	await container?.stop().catch(console.error);
-});
-
-beforeEach((ctx) => {
-	ctx.gel = {
-		db,
-	};
-});
-
-afterEach(async () => {
-	await $`gel query "DELETE default::users_custom;" ${tlsSecurity} --dsn=${dsn}`;
-	await $`gel query "DELETE default::prefixed_users_custom;" ${tlsSecurity} --dsn=${dsn}`;
-});
-
-const customInteger = customType<{ data: number; notNull: false; default: false }>({
-	dataType() {
-		return 'integer';
-	},
-});
-
-const customText = customType<{ data: string }>({
-	dataType() {
-		return 'text';
-	},
-});
-
-const customBoolean = customType<{ data: boolean }>({
-	dataType() {
-		return 'boolean';
-	},
-});
-
-const customJson = <TData>(name: string) =>
-	customType<{ data: TData; driverData: string }>({
-		dataType() {
-			return 'json';
-		},
-	})(name);
-
-const usersTable = gelTable('users_custom', {
-	id1: customInteger('id1'),
-	name: customText('name').notNull(),
-	verified: customBoolean('verified').notNull().default(false),
-	json: customJson<string[]>('json'),
-});
-
-test('select all fields', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const result = await db.select().from(usersTable);
-
-	expect(result).toEqual([{ id1: 1, name: 'John', verified: false, json: null }]);
-});
-
-test('select sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.select({
-		name: sql`upper(${usersTable.name})`,
-	}).from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('select typed sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.select({
-		name: sql<string>`upper(${usersTable.name})`,
-	}).from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('insert returning sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	const users = await db.insert(usersTable).values({ id1: 1, name: 'John' }).returning({
-		name: sql`upper(${usersTable.name})`,
-	});
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('delete returning sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-		name: sql`upper(${usersTable.name})`,
-	});
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('update returning sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
-		name: sql`upper(${usersTable.name})`,
-	});
-
-	expect(users).toEqual([{ name: 'JANE' }]);
-});
-
-test('update with returning all fields', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning();
-
-	expect(users).toEqual([{ id1: 1, name: 'Jane', verified: false, json: null }]);
-});
-
-test('update with returning partial', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
-		id1: usersTable.id1,
-		name: usersTable.name,
-	});
-
-	expect(users).toEqual([{ id1: 1, name: 'Jane' }]);
-});
-
-test('delete with returning all fields', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
-
-	expect(users).toEqual([{ id1: 1, name: 'John', verified: false, json: null }]);
-});
-
-test('delete with returning partial', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-		id1: usersTable.id1,
-		name: usersTable.name,
-	});
-
-	expect(users).toEqual([{ id1: 1, name: 'John' }]);
-});
-
-test('insert + select', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const result = await db.select().from(usersTable);
-	expect(result).toEqual([{ id1: 1, name: 'John', verified: false, json: null }]);
-
-	await db.insert(usersTable).values({ id1: 2, name: 'Jane' });
-	const result2 = await db.select().from(usersTable);
-	expect(result2).toEqual([
-		{ id1: 1, name: 'John', verified: false, json: null },
-		{ id1: 2, name: 'Jane', verified: false, json: null },
-	]);
-});
-
-test('insert with overridden default values', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John', verified: true });
-	const result = await db.select().from(usersTable);
-
-	expect(result).toEqual([{ id1: 1, name: 'John', verified: true, json: null }]);
-});
-
-test('insert many', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([
-		{ id1: 1, name: 'John' },
-		{ id1: 2, name: 'Bruce', json: ['foo', 'bar'] },
-		{ id1: 3, name: 'Jane' },
-		{ id1: 4, name: 'Austin', verified: true },
-	]);
-	const result = await db.select({
-		id: usersTable.id1,
-		name: usersTable.name,
-		json: usersTable.json,
-		verified: usersTable.verified,
-	}).from(usersTable);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', json: null, verified: false },
-		{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
-		{ id: 3, name: 'Jane', json: null, verified: false },
-		{ id: 4, name: 'Austin', json: null, verified: true },
-	]);
-});
-
-test('insert many with returning', async (ctx) => {
-	const { db } = ctx.gel;
-
-	const result = await db.insert(usersTable).values([
-		{ id1: 1, name: 'John' },
-		{ id1: 2, name: 'Bruce', json: ['foo', 'bar'] },
-		{ id1: 3, name: 'Jane' },
-		{ id1: 4, name: 'Austin', verified: true },
-	])
-		.returning({
-			id: usersTable.id1,
-			name: usersTable.name,
-			json: usersTable.json,
-			verified: usersTable.verified,
-		});
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', json: null, verified: false },
-		{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
-		{ id: 3, name: 'Jane', json: null, verified: false },
-		{ id: 4, name: 'Austin', json: null, verified: true },
-	]);
-});
-
-test('select with group by as field', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'Jane' }, { id1: 3, name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.name);
-
-	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-});
-
-test('select with group by as sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'Jane' }, { id1: 3, name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(sql`${usersTable.name}`);
-
-	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-});
-
-test('select with group by as sql + column', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'Jane' }, { id1: 3, name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(sql`${usersTable.name}`, usersTable.id1);
-
-	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }, { name: 'Jane' }]);
-});
-
-test('select with group by as column + sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'Jane' }, { id1: 3, name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id1, sql`${usersTable.name}`);
-
-	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-});
-
-test('select with group by complex query', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'Jane' }, { id1: 3, name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id1, sql`${usersTable.name}`)
-		.orderBy(asc(usersTable.name))
-		.limit(1);
-
-	expect(result).toEqual([{ name: 'Jane' }]);
-});
-
-test('build query', async (ctx) => {
-	const { db } = ctx.gel;
-
-	const query = db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id1, usersTable.name)
-		.toSQL();
-
-	expect(query).toEqual({
-		sql:
-			'select "users_custom"."id1", "users_custom"."name" from "users_custom" group by "users_custom"."id1", "users_custom"."name"',
-		params: [],
-	});
-});
-
-test('insert sql', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: sql`${'John'}` });
-	const result = await db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable);
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('partial join with alias', async (ctx) => {
-	const { db } = ctx.gel;
-	const customerAlias = alias(usersTable, 'customer');
-
-	await db.insert(usersTable).values([{ id1: 10, name: 'Ivan' }, { id1: 11, name: 'Hans' }]);
-	const result = await db
-		.select({
-			user: {
-				id: usersTable.id1,
-				name: usersTable.name,
-			},
-			customer: {
-				id: customerAlias.id1,
-				name: customerAlias.name,
-			},
-		}).from(usersTable)
-		.leftJoin(customerAlias, eq(customerAlias.id1, 11))
-		.where(eq(usersTable.id1, 10));
-
-	expect(result).toEqual([{
-		user: { id: 10, name: 'Ivan' },
-		customer: { id: 11, name: 'Hans' },
-	}]);
-});
-
-test('full join with alias', async (ctx) => {
-	const { db } = ctx.gel;
-
-	const gelTable = gelTableCreator((name) => `prefixed_${name}`);
-
-	const users = gelTable('users_custom', {
-		id1: customInteger('id1'),
-		name: customText('name').notNull(),
-	});
-
-	const customers = alias(users, 'customer');
-
-	await db.insert(users).values([{ id1: 10, name: 'Ivan' }, { id1: 11, name: 'Hans' }]);
-	const result = await db
-		.select().from(users)
-		.leftJoin(customers, eq(customers.id1, 11))
-		.where(eq(users.id1, 10));
-
-	expect(result).toEqual([{
-		users_custom: {
-			id1: 10,
-			name: 'Ivan',
-		},
-		customer: {
-			id1: 11,
-			name: 'Hans',
-		},
-	}]);
-});
-
-test('insert with spaces', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: sql`'Jo   h     n'` });
-	const result = await db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-});
-
-test('prepared statement', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const statement = db.select({
-		id: usersTable.id1,
-		name: usersTable.name,
-	}).from(usersTable)
-		.prepare('statement1');
-	const result = await statement.execute();
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('prepared statement reuse', async (ctx) => {
-	const { db } = ctx.gel;
-
-	const stmt = db.insert(usersTable).values({
-		id1: sql.placeholder('id1'),
-		verified: true,
-		name: sql.placeholder('name'),
-	}).prepare('stmt2');
-
-	for (let i = 1; i < 11; i++) {
-		await stmt.execute({ id1: i, name: `John ${i}` });
-	}
-
-	const result = await db.select({
-		id1: usersTable.id1,
-		name: usersTable.name,
-		verified: usersTable.verified,
-	}).from(usersTable);
-
-	expect(result).toEqual([
-		{ id1: 1, name: 'John 1', verified: true },
-		{ id1: 2, name: 'John 2', verified: true },
-		{ id1: 3, name: 'John 3', verified: true },
-		{ id1: 4, name: 'John 4', verified: true },
-		{ id1: 5, name: 'John 5', verified: true },
-		{ id1: 6, name: 'John 6', verified: true },
-		{ id1: 7, name: 'John 7', verified: true },
-		{ id1: 8, name: 'John 8', verified: true },
-		{ id1: 9, name: 'John 9', verified: true },
-		{ id1: 10, name: 'John 10', verified: true },
-	]);
-});
-
-test('prepared statement with placeholder in .where', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const stmt = db.select({
-		id: usersTable.id1,
-		name: usersTable.name,
-	}).from(usersTable)
-		.where(eq(usersTable.id1, sql.placeholder('id')))
-		.prepare('stmt3');
-	const result = await stmt.execute({ id: 1 });
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('prepared statement with placeholder in .limit', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values({ id1: 1, name: 'John' });
-	const stmt = db
-		.select({
-			id: usersTable.id1,
-			name: usersTable.name,
-		})
-		.from(usersTable)
-		.where(eq(usersTable.id1, sql.placeholder('id')))
-		.limit(sql.placeholder('limit'))
-		.prepare('stmt_limit');
-
-	const result = await stmt.execute({ id: 1, limit: 1 });
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-	expect(result).toHaveLength(1);
-});
-
-test('prepared statement with placeholder in .offset', async (ctx) => {
-	const { db } = ctx.gel;
-
-	await db.insert(usersTable).values([{ id1: 1, name: 'John' }, { id1: 2, name: 'John1' }]);
-	const stmt = db
-		.select({
-			id: usersTable.id1,
-			name: usersTable.name,
-		})
-		.from(usersTable)
-		.offset(sql.placeholder('offset'))
-		.prepare('stmt_offset');
-
-	const result = await stmt.execute({ offset: 1 });
-
-	expect(result).toEqual([{ id: 2, name: 'John1' }]);
-});
-
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`);
-
-	const result = await db.execute<{ id1: number; name: string }>(sql`select id1, name from "users_custom"`);
-	expect(result).toEqual([{ id1: null, name: 'John' }]);
-});
-
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(usersTable.name.name)
-		}) values (${'John'}) returning ${usersTable.id1}, ${usersTable.name}`,
-	);
-	expect(inserted).toEqual([{ id1: null, name: 'John' }]);
-});
-
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id1' | 'name'>>(
-		db.insert(usersTable).values({ id1: 1, name: 'John' }).returning({ id: usersTable.id1, name: usersTable.name }),
-	);
-	expect(inserted).toEqual([{ id1: 1, name: 'John' }]);
-});
-
-// TODO on conflict does not work
-// test.todo('build query insert with onConflict do update', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	const query = db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John', jsonb: ['foo', 'bar'] })
-// 		.onConflictDoUpdate({ target: usersTable.id1, set: { name: 'John1' } })
-// 		.toSQL();
-
-// 	expect(query).toEqual({
-// 		sql:
-// 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
-// 		params: ['John', '["foo","bar"]', 'John1'],
-// 	});
-// });
-
-// // TODO on conflict does not work
-// test.todo('build query insert with onConflict do update / multiple columns', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	const query = db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John', jsonb: ['foo', 'bar'] })
-// 		.onConflictDoUpdate({ target: [usersTable.id1, usersTable.name], set: { name: 'John1' } })
-// 		.toSQL();
-
-// 	expect(query).toEqual({
-// 		sql:
-// 			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
-// 		params: ['John', '["foo","bar"]', 'John1'],
-// 	});
-// });
-
-// // TODO on conflict does not work
-// test.todo('build query insert with onConflict do nothing', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	const query = db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' })
-// 		.onConflictDoNothing()
-// 		.toSQL();
-
-// 	expect(query).toEqual({
-// 		sql: 'insert into "users" ("id1", "name", "verified") values ($1, $2, default) on conflict do nothing',
-// 		params: [1, 'John'],
-// 	});
-// });
-
-// // TODO on conflict does not work
-// test.todo('build query insert with onConflict do nothing + target', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	const query = db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' })
-// 		.onConflictDoNothing({ target: usersTable.id1 })
-// 		.toSQL();
-
-// 	expect(query).toEqual({
-// 		sql: 'insert into "users" ("id1", "name", "verified") values ($1, $2, default) on conflict ("id1") do nothing',
-// 		params: [1, 'John'],
-// 	});
-// });
-
-// // TODO on conflict does not work
-// test.todo('insert with onConflict do update', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' });
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' })
-// 		.onConflictDoUpdate({ target: usersTable.id1, set: { name: 'John1' } });
-
-// 	const res = await db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-// 		eq(usersTable.id1, 1),
-// 	);
-
-// 	expect(res).toEqual([{ id: 1, name: 'John1' }]);
-// });
-
-// // TODO on conflict does not work
-// test.todo('insert with onConflict do nothing', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' });
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' })
-// 		.onConflictDoNothing();
-
-// 	const res = await db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-// 		eq(usersTable.id1, 1),
-// 	);
-
-// 	expect(res).toEqual([{ id: 1, name: 'John' }]);
-// });
-
-// // TODO on conflict does not work
-// test.todo('insert with onConflict do nothing + target', async (ctx) => {
-// 	const { db } = ctx.gel;
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' });
-
-// 	await db.insert(usersTable)
-// 		.values({ id1: 1, name: 'John' })
-// 		.onConflictDoNothing({ target: usersTable.id1 });
-
-// 	const res = await db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-// 		eq(usersTable.id1, 1),
-// 	);
-
-// 	expect(res).toEqual([{ id: 1, name: 'John' }]);
-// });
diff --git a/integration-tests/tests/gel/gel-ext.test.ts b/integration-tests/tests/gel/gel-ext.test.ts
deleted file mode 100644
index b68c853199..0000000000
--- a/integration-tests/tests/gel/gel-ext.test.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
-import { relations, sql } from 'drizzle-orm';
-import { drizzle, type GelJsDatabase } from 'drizzle-orm/gel';
-import { foreignKey, gelSchema, gelTable, text, timestamptz, uniqueIndex, uuid } from 'drizzle-orm/gel-core';
-import createClient, { type Client } from 'gel';
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
-import 'zx/globals';
-import { createDockerDB } from './createInstance';
-
-$.quiet = true;
-
-const ENABLE_LOGGING = false;
-
-export const extauth = gelSchema('ext::auth');
-
-export const identityInExtauth = extauth.table('Identity', {
-	id: uuid().default(sql`uuid_generate_v4()`).primaryKey().notNull(),
-	createdAt: timestamptz('created_at').default(sql`(clock_timestamp())`).notNull(),
-	issuer: text().notNull(),
-	modifiedAt: timestamptz('modified_at').notNull(),
-	subject: text().notNull(),
-}, (table) => [
-	uniqueIndex('6bc2dd19-bce4-5810-bb1b-7007afe97a11;schemaconstr').using(
-		'btree',
-		table.id.asc().nullsLast().op('uuid_ops'),
-	),
-]);
-
-export const user = gelTable('User', {
-	id: uuid().default(sql`uuid_generate_v4()`).primaryKey().notNull(),
-	email: text().notNull(),
-	identityId: uuid('identity_id').notNull(),
-	username: text().notNull(),
-}, (table) => [
-	uniqueIndex('d504514c-26a7-11f0-b836-81aa188c0abe;schemaconstr').using(
-		'btree',
-		table.id.asc().nullsLast().op('uuid_ops'),
-	),
-	foreignKey({
-		columns: [table.identityId],
-		foreignColumns: [identityInExtauth.id],
-		name: 'User_fk_identity',
-	}),
-]);
-
-export const userRelations = relations(user, ({ one }) => ({
-	identity: one(identityInExtauth, { references: [identityInExtauth.id], fields: [user.identityId] }),
-}));
-
-const schema = { user, identityInExtauth, userRelations };
-
-let client: Client;
-let db: GelJsDatabase<typeof schema>;
-const tlsSecurity: string = 'insecure';
-let dsn: string;
-let container: Docker.Container | undefined;
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['GEL_CONNECTION_STRING']) {
-		connectionString = process.env['GEL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	await sleep(15 * 1000);
-	client = await retry(() => {
-		client = createClient({ dsn: connectionString, tlsSecurity: 'insecure' });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING, schema: { user, identityInExtauth, userRelations } });
-
-	dsn = connectionString;
-});
-
-afterAll(async () => {
-	await client?.close().catch(console.error);
-	await container?.stop().catch(console.error);
-});
-
-describe('extensions tests group', async () => {
-	beforeAll(async () => {
-		await $`gel query 'CREATE EXTENSION pgcrypto VERSION "1.3";
-  CREATE EXTENSION auth VERSION "1.0";
-  CREATE TYPE default::User {
-      CREATE REQUIRED LINK identity: ext::auth::Identity;
-      CREATE REQUIRED PROPERTY email: std::str;
-      CREATE REQUIRED PROPERTY username: std::str;
-  };
-  CREATE GLOBAL default::current_user := (std::assert_single((SELECT
-      default::User {
-          id,
-          username,
-          email
-      }
-  FILTER
-      (.identity = GLOBAL ext::auth::ClientTokenIdentity)
-  )));' --tls-security=${tlsSecurity} --dsn=${dsn}`;
-	});
-
-	afterEach(async () => {
-		await $`gel query "DELETE default::User;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-	});
-
-	test('check that you can query from ext::auth schema in gel', async () => {
-		const [response] = await db.insert(identityInExtauth).values({
-			issuer: 'issuer',
-			subject: 'subject',
-			modifiedAt: new Date(),
-		}).returning();
-		await db.insert(user).values({ identityId: response!.id, username: 'username', email: 'email' });
-
-		const userResponse = await db.select().from(user);
-		const authResponse = await db.select().from(identityInExtauth);
-		const relationsResponse = await db.query.user.findMany({
-			columns: {
-				id: false,
-				identityId: false,
-			},
-			with: {
-				identity: {
-					columns: {
-						id: false,
-						modifiedAt: false,
-						createdAt: false,
-					},
-				},
-			},
-		});
-
-		expect(relationsResponse).toStrictEqual([{
-			email: 'email',
-			identity: { issuer: 'issuer', subject: 'subject' },
-			username: 'username',
-		}]);
-		expect(userResponse.length).toBe(1);
-		expect(authResponse.length).toBe(1);
-
-		expect(userResponse[0]!.username).toBe('username');
-		expect(userResponse[0]!.email).toBe('email');
-
-		expect(authResponse[0]!.issuer).toBe('issuer');
-		expect(authResponse[0]!.subject).toBe('subject');
-	});
-});
diff --git a/integration-tests/tests/gel/gel.test.ts b/integration-tests/tests/gel/gel.test.ts
deleted file mode 100644
index 858a1d21ce..0000000000
--- a/integration-tests/tests/gel/gel.test.ts
+++ /dev/null
@@ -1,5254 +0,0 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
-import {
-	and,
-	arrayContained,
-	arrayContains,
-	arrayOverlaps,
-	asc,
-	avg,
-	avgDistinct,
-	count,
-	countDistinct,
-	eq,
-	type Equal,
-	exists,
-	getTableColumns,
-	gt,
-	gte,
-	ilike,
-	inArray,
-	is,
-	like,
-	lt,
-	max,
-	min,
-	not,
-	notInArray,
-	or,
-	SQL,
-	sql,
-	type SQLWrapper,
-	sum,
-	sumDistinct,
-} from 'drizzle-orm';
-import { drizzle, type GelJsDatabase } from 'drizzle-orm/gel';
-import type { GelColumn } from 'drizzle-orm/gel-core';
-import {
-	alias,
-	boolean,
-	dateDuration,
-	decimal,
-	duration,
-	except,
-	exceptAll,
-	foreignKey,
-	GelDialect,
-	GelPolicy,
-	gelPolicy,
-	gelSchema,
-	gelTable,
-	gelTableCreator,
-	getTableConfig,
-	integer,
-	intersect,
-	intersectAll,
-	json,
-	localDate,
-	localTime,
-	primaryKey,
-	relDuration,
-	text,
-	timestamp,
-	timestamptz,
-	union,
-	unionAll,
-	unique,
-	uniqueKeyName,
-	uuid as gelUuid,
-} from 'drizzle-orm/gel-core';
-import createClient, {
-	type Client,
-	DateDuration,
-	Duration,
-	LocalDate,
-	LocalDateTime,
-	LocalTime,
-	RelativeDuration,
-} from 'gel';
-import { v4 as uuidV4 } from 'uuid';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { Expect } from '~/utils';
-import 'zx/globals';
-import { TestCache, TestGlobalCache } from './cache';
-import { createDockerDB } from './createInstance';
-
-$.quiet = true;
-
-const ENABLE_LOGGING = false;
-
-let client: Client;
-let db: GelJsDatabase;
-let dbGlobalCached: GelJsDatabase;
-let cachedDb: GelJsDatabase;
-const tlsSecurity: string = 'insecure';
-let dsn: string;
-let container: Docker.Container | undefined;
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-declare module 'vitest' {
-	interface TestContext {
-		gel: {
-			db: GelJsDatabase;
-		};
-		cachedGel: {
-			db: GelJsDatabase;
-			dbGlobalCached: GelJsDatabase;
-		};
-	}
-}
-
-const usersTable = gelTable('users', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	json: json('json').$type<string[]>(),
-	createdAt: timestamptz('created_at').notNull().defaultNow(),
-});
-
-const postsTable = gelTable('posts', {
-	id: integer().primaryKey(),
-	description: text().notNull(),
-	userId: integer('city_id').references(() => usersTable.id1),
-});
-
-const usersOnUpdate = gelTable('users_on_update', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	updateCounter: integer('update_counter')
-		.default(sql`1`)
-		.$onUpdateFn(() => sql`update_counter + 1`),
-	updatedAt: timestamptz('updated_at').$onUpdate(() => new Date()),
-	alwaysNull: text('always_null')
-		.$type<string | null>()
-		.$onUpdate(() => null),
-});
-
-const citiesTable = gelTable('cities', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	state: text('state'),
-});
-
-const cities2Table = gelTable('cities', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-});
-
-const users2Table = gelTable('some_new_users', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	cityId: integer('cityId'),
-});
-
-const users3Table = gelTable('users3', {
-	id1: integer('id1'),
-	name: text('name').notNull(),
-});
-
-const coursesTable = gelTable('courses', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	categoryId: integer('categoryId').references(() => courseCategoriesTable.id1),
-});
-
-const courseCategoriesTable = gelTable('course_categories', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-});
-
-const orders = gelTable('orders', {
-	id1: integer('id1'),
-	region: text('region').notNull(),
-	product: text('product')
-		.notNull()
-		.$default(() => 'random_string'),
-	amount: integer('amount').notNull(),
-	quantity: integer('quantity').notNull(),
-});
-
-const salEmp = gelTable('sal_emp', {
-	name: text('name'),
-	payByQuarter: integer('pay_by_quarter').array(),
-});
-
-const jsonTestTable = gelTable('jsontest', {
-	id1: integer('id1').primaryKey(),
-	json: json('json').$type<{ string: string; number: number }>(),
-});
-
-// To test aggregate functions
-const aggregateTable = gelTable('aggregate_table', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	a: integer('a'),
-	b: integer('b'),
-	c: integer('c'),
-	nullOnly: integer('nullOnly'),
-});
-
-// To test another schema and multischema
-const mySchema = gelSchema('mySchema');
-
-const usersMySchemaTable = mySchema.table('users', {
-	id1: integer('id1').notNull(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	json: json('json').$type<string[]>(),
-	createdAt: timestamptz('created_at').notNull().defaultNow(),
-});
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['GEL_CONNECTION_STRING']) {
-		connectionString = process.env['GEL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	await sleep(15 * 1000);
-	client = await retry(() => {
-		client = createClient({ dsn: connectionString, tlsSecurity: 'insecure' });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestCache(),
-	});
-	dbGlobalCached = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestGlobalCache(),
-	});
-
-	dsn = connectionString;
-});
-
-afterAll(async () => {
-	await client?.close().catch(console.error);
-	await container?.stop().catch(console.error);
-});
-
-beforeEach((ctx) => {
-	ctx.gel = {
-		db,
-	};
-	ctx.cachedGel = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-describe('some', async () => {
-	beforeEach(async (ctx) => {
-		await ctx.cachedGel.db.$cache?.invalidate({ tables: 'users' });
-		await ctx.cachedGel.dbGlobalCached.$cache?.invalidate({ tables: 'users' });
-	});
-	beforeAll(async () => {
-		await $`gel query "CREATE TYPE default::users {
-            create property id1: int16 {
-                create constraint exclusive;
-            };
-            create required property name: str;
-      create required property verified: bool {
-          SET default := false;
-      };
-      create PROPERTY json: json;
-      create required property  created_at: datetime {
-          SET default := datetime_of_statement();
-      };
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_with_cities {
-    create property id1: int16 {
-        create constraint exclusive;
-    };
-    create required property name: str;
-    create required property cityId: int32;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_with_undefined {
-        create property id1: int16 {
-            create constraint exclusive;
-        };
-        create property name: str;
-        };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_insert_select {
-            create property id1: int16 {
-                create constraint exclusive;
-            };
-            create property name: str;
-            };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE MODULE mySchema;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE mySchema::users {
-            create property id1: int16;
-            create required property name: str;
-      create required property verified: bool {
-          SET default := false;
-      };
-      create PROPERTY json: json;
-      create required property  created_at: datetime {
-          SET default := datetime_of_statement();
-      };
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::orders {
-    CREATE PROPERTY id1 -> int16;
-    CREATE REQUIRED PROPERTY region -> str;
-    CREATE REQUIRED PROPERTY product -> str;
-    CREATE REQUIRED PROPERTY amount -> int64;
-    CREATE REQUIRED PROPERTY quantity -> int64;
-    };
-    " --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_distinct {
-    create required property id1 -> int16;
-    create required property name -> str;
-    create required property age -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users3 {
-    create property id1 -> int16;
-    create required property name -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::cities {
-    create required property id1 -> int16;
-    create required property name -> str;
-    create property state -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::courses {
-    create required property id1 -> int16;
-    create required property name -> str;
-    create property categoryId -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::course_categories {
-    create required property id1 -> int16;
-    create required property name -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::jsontest {
-    create property id1 -> int16;
-    create required property json -> json;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::sal_emp {
-    create property name -> str;
-    create property pay_by_quarter -> array<int16>;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::some_new_users {
-    create required property id1 -> int16;
-    create required property name -> str;
-    create property cityId -> int32;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::aggregate_table {
-    create property id1: int16;
-    create required property name: str;
-    create property a: int16;
-    create property b: int16;
-    create property c: int16;
-    create PROPERTY nullOnly: int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::prefixed_users {
-    CREATE PROPERTY id1 -> int16;
-    CREATE REQUIRED PROPERTY name -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::empty_insert_single {
-    CREATE PROPERTY id1 -> int16;
-    CREATE REQUIRED PROPERTY name -> str {
-    SET default := 'Dan';
-    };
-    CREATE PROPERTY state -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::empty_insert_multiple {
-    CREATE PROPERTY id1 -> int16;
-    CREATE REQUIRED PROPERTY name -> str {
-    SET default := 'Dan';
-    };
-    CREATE PROPERTY state -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::products {
-    CREATE PROPERTY id1 -> int16;
-    CREATE REQUIRED PROPERTY price -> decimal;
-    CREATE REQUIRED PROPERTY cheap -> bool {
-    SET default := false
-    };
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::myprefix_test_prefixed_table_with_unique_name {
-    create property id1 -> int16;
-    create required property name -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::metric_entry {
-    create required property id1 -> uuid;
-    create required property createdAt -> datetime;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_transactions {
-    create required property id1 -> int16;
-    create required property balance -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::products_transactions {
-    create required property id1 -> int16;
-    create required property price -> int16;
-    create required property stock -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_transactions_rollback {
-    create required property id1 -> int16;
-    create required property balance -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_nested_transactions {
-    create required property id1 -> int16;
-    create required property balance -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::internal_staff {
-    create required property userId -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::custom_user {
-    create required property id1 -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::ticket {
-    create required property staffId -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::posts {
-    create required property id1 -> int16;
-    create property tags -> array<str>;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE dates_column {
-    create property datetimeColumn -> datetime;
-    create property local_datetimeColumn -> cal::local_datetime;
-    create property local_dateColumn -> cal::local_date;
-    create property local_timeColumn -> cal::local_time;
-    
-    create property durationColumn -> duration;
-    create property relative_durationColumn -> cal::relative_duration;
-    create property dateDurationColumn -> cal::date_duration;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE users_with_insert {
-    create required property username -> str;
-    create required property admin -> bool;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE users_test_with_and_without_timezone {
-    create required property username -> str;
-    create required property admin -> bool;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::arrays_tests {
-    create property id1: int16 {
-        create constraint exclusive;
-    };
-    create property tags: array<str>;
-    create required property numbers: array<int32>;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_on_update {
-    create required property id1 -> int16;
-    create required property name -> str;
-    create property update_counter -> int16 {
-        SET default := 1
-    };
-    create property always_null -> str;
-    create property updated_at -> datetime;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::json_table {
-    create PROPERTY json: json;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::notifications {
-    create required property id1 -> int16;
-     create required property  sentAt: datetime {
-          SET default := datetime_of_statement();
-      };
-    create property message -> str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "CREATE TYPE default::user_notifications {
-    create required property userId -> int16;
-    create required property notificationId -> int16;
-    create property categoryId -> int16;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users1 {
-    create required property id1: int16;
-    create required property name: str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "CREATE TYPE default::users2 {
-    create required property id1: int16;
-    create required property name: str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::count_test {
-    create required property id1: int16;
-    create required property name: str;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_with_names {
-    create required property id1: int16;
-    create required property firstName: str;
-    create required property lastName: str;
-    create required property admin: bool;
-    };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-
-		await $`gel query "CREATE TYPE default::users_with_age {
-        create required property id1: int16;
-        create required property name: str;
-        create required property age: int32;
-        create required property city: str;
-        };" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-	});
-
-	afterEach(async () => {
-		await $`gel query "DELETE default::users;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::prefixed_users;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::some_new_users;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::orders;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::cities;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::users_on_update;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::aggregate_table;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE mySchema::users;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::count_test;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::users1;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::users2;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DELETE default::jsontest;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-	});
-
-	afterAll(async () => {
-		await $`gel query "DROP TYPE default::users" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_with_cities" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_with_undefined " --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_insert_select" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE mySchema::users" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::orders" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_distinct" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users3" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::cities" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::courses" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::course_categories" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::jsontest" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::sal_emp" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::some_new_users" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::aggregate_table" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::prefixed_users" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::empty_insert_single" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::empty_insert_multiple" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::products" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::myprefix_test_prefixed_table_with_unique_name" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::metric_entry" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_transactions" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::products_transactions" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_transactions_rollback" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_nested_transactions" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::internal_staff" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::custom_user" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::ticket" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::posts" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE dates_column" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE users_with_insert" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE users_test_with_and_without_timezone" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::arrays_tests" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_on_update" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::json_table" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::notifications" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::user_notifications" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users1" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users2" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::count_test" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE default::users_with_names" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP MODULE mySchema;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-		await $`gel query "DROP TYPE users_with_age;" --tls-security=${tlsSecurity} --dsn=${dsn}`;
-	});
-
-	async function setupSetOperationTest(db: GelJsDatabase) {
-		await db.insert(cities2Table).values([
-			{ id1: 1, name: 'New York' },
-			{ id1: 2, name: 'London' },
-			{ id1: 3, name: 'Tampa' },
-		]);
-
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId: 1 },
-			{ id1: 2, name: 'Jane', cityId: 2 },
-			{ id1: 3, name: 'Jack', cityId: 3 },
-			{ id1: 4, name: 'Peter', cityId: 3 },
-			{ id1: 5, name: 'Ben', cityId: 2 },
-			{ id1: 6, name: 'Jill', cityId: 1 },
-			{ id1: 7, name: 'Mary', cityId: 2 },
-			{ id1: 8, name: 'Sally', cityId: 1 },
-		]);
-	}
-
-	async function setupAggregateFunctionsTest(db: GelJsDatabase) {
-		await db.insert(aggregateTable).values([
-			{ id1: 1, name: 'value 1', a: 5, b: 10, c: 20 },
-			{ id1: 2, name: 'value 1', a: 5, b: 20, c: 30 },
-			{ id1: 3, name: 'value 2', a: 10, b: 50, c: 60 },
-			{ id1: 4, name: 'value 3', a: 20, b: 20, c: null },
-			{ id1: 5, name: 'value 4', a: null, b: 90, c: 120 },
-			{ id1: 6, name: 'value 5', a: 80, b: 10, c: null },
-			{ id1: 7, name: 'value 6', a: null, b: null, c: 150 },
-		]);
-	}
-
-	test('table configs: unique third param', async () => {
-		const cities1Table = gelTable(
-			'cities1',
-			{
-				id: integer('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			},
-			(t) => ({
-				f: unique('custom_name').on(t.name, t.state).nullsNotDistinct(),
-				f1: unique('custom_name1').on(t.name, t.state),
-			}),
-		);
-
-		const tableConfig = getTableConfig(cities1Table);
-
-		expect(tableConfig.uniqueConstraints).toHaveLength(2);
-
-		expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
-		expect(tableConfig.uniqueConstraints[0]?.nullsNotDistinct).toBe(true);
-		expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-
-		expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
-		expect(tableConfig.uniqueConstraints[1]?.nullsNotDistinct).toBe(false);
-		expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-	});
-
-	test('table configs: unique in column', async () => {
-		const cities1Table = gelTable('cities1', {
-			id: integer('id').primaryKey(),
-			name: text('name').notNull().unique(),
-			state: text('state').unique('custom'),
-			field: text('field').unique('custom_field', { nulls: 'not distinct' }),
-		});
-
-		const tableConfig = getTableConfig(cities1Table);
-
-		const columnName = tableConfig.columns.find((it) => it.name === 'name');
-
-		expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
-		expect(columnName?.isUnique).toBe(true);
-
-		const columnState = tableConfig.columns.find((it) => it.name === 'state');
-		expect(columnState?.uniqueName).toBe('custom');
-		expect(columnState?.isUnique).toBe(true);
-
-		const columnField = tableConfig.columns.find((it) => it.name === 'field');
-		expect(columnField?.uniqueName).toBe('custom_field');
-		expect(columnField?.isUnique).toBe(true);
-		expect(columnField?.uniqueType).toBe('not distinct');
-	});
-
-	test('table config: foreign keys name', async () => {
-		const table = gelTable(
-			'cities',
-			{
-				id1: integer('id1').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			},
-			(t) => ({
-				f: foreignKey({ foreignColumns: [t.id1], columns: [t.id1], name: 'custom_fk' }),
-			}),
-		);
-
-		const tableConfig = getTableConfig(table);
-
-		expect(tableConfig.foreignKeys).toHaveLength(1);
-		expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
-	});
-
-	test('table config: primary keys name', async () => {
-		const table = gelTable(
-			'cities',
-			{
-				id: integer('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			},
-			(t) => ({
-				f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-			}),
-		);
-
-		const tableConfig = getTableConfig(table);
-
-		expect(tableConfig.primaryKeys).toHaveLength(1);
-		expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
-	});
-
-	test('select all fields', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const now = Date.now();
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		const result = await db.select().from(usersTable);
-
-		expect(result[0]!.createdAt).toBeInstanceOf(Date);
-		// TODO 100 ms
-		expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(500);
-		expect(result.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{
-				id: undefined,
-				id1: 1,
-				name: 'John',
-				verified: false,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('select sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.select({
-				name: sql`upper(${usersTable.name})`,
-			})
-			.from(usersTable);
-
-		expect(users.map((it) => ({ ...it, id: undefined }))).toStrictEqual([{ id: undefined, name: 'JOHN' }]);
-	});
-
-	test('select typed sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		const users = await db
-			.select({
-				name: sql<string>`upper(${usersTable.name})`,
-			})
-			.from(usersTable);
-
-		expect(users.map((it) => ({ ...it, id: undefined }))).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('select with empty array in inArray', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-		const result = await db
-			.select({
-				name: sql`upper(${usersTable.name})`,
-			})
-			.from(usersTable)
-			.where(inArray(usersTable.id1, []));
-
-		expect(result.map((it) => ({ ...it, id: undefined }))).toEqual([]);
-	});
-
-	test('select with empty array in notInArray', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-		const result = await db
-			.select({
-				name: sql`upper(${usersTable.name})`,
-			})
-			.from(usersTable)
-			.where(notInArray(usersTable.id1, []));
-
-		expect(result.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ name: 'JOHN' },
-			{ name: 'JANE' },
-			{
-				name: 'JANE',
-			},
-		]);
-	});
-
-	test('$default function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const insertedOrder = await db.insert(orders).values({ id1: 1, region: 'Ukraine', amount: 1, quantity: 1 })
-			.returning();
-		const selectedOrder = await db.select().from(orders);
-
-		expect(insertedOrder.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{
-				id: undefined,
-				amount: 1,
-				id1: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			},
-		]);
-
-		expect(selectedOrder.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{
-				id: undefined,
-				id1: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			},
-		]);
-	});
-
-	test('select distinct', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const usersDistinctTable = gelTable('users_distinct', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-		});
-
-		await db.insert(usersDistinctTable).values([
-			{ id1: 1, name: 'John', age: 24 },
-			{ id1: 1, name: 'John', age: 24 },
-			{ id1: 2, name: 'John', age: 25 },
-			{ id1: 1, name: 'Jane', age: 24 },
-			{ id1: 1, name: 'Jane', age: 26 },
-		]);
-
-		const users1 = await db.selectDistinct().from(usersDistinctTable).orderBy(
-			usersDistinctTable.id1,
-			usersDistinctTable.name,
-		);
-
-		const users2 = await db.selectDistinctOn([usersDistinctTable.id1]).from(usersDistinctTable).orderBy(
-			usersDistinctTable.id1,
-		);
-
-		const users3 = await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
-			usersDistinctTable,
-		).orderBy(usersDistinctTable.name);
-
-		const users4 = await db.selectDistinctOn([usersDistinctTable.id1, usersDistinctTable.age]).from(
-			usersDistinctTable,
-		).orderBy(usersDistinctTable.id1, usersDistinctTable.age);
-
-		expect(users1).toEqual([
-			{ id1: 1, name: 'Jane', age: 24 },
-			{ id1: 1, name: 'Jane', age: 26 },
-			{ id1: 1, name: 'John', age: 24 },
-			{ id1: 2, name: 'John', age: 25 },
-		]);
-
-		expect(users2).toHaveLength(2);
-		expect(users2[0]?.id1).toBe(1);
-		expect(users2[1]?.id1).toBe(2);
-
-		expect(users3).toHaveLength(2);
-		expect(users3[0]?.name).toBe('Jane');
-		expect(users3[1]?.name).toBe('John');
-
-		expect(users4).toEqual([
-			{ id1: 1, name: 'John', age: 24 },
-			{ id1: 1, name: 'Jane', age: 26 },
-			{ id1: 2, name: 'John', age: 25 },
-		]);
-	});
-
-	test('insert returning sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = await db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John' })
-			.returning({
-				name: sql`upper(${usersTable.name})`,
-			});
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('delete returning sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.delete(usersTable)
-			.where(eq(usersTable.name, 'John'))
-			.returning({
-				name: sql`upper(${usersTable.name})`,
-			});
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('update returning sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.update(usersTable)
-			.set({ name: 'Jane' })
-			.where(eq(usersTable.name, 'John'))
-			.returning({
-				name: sql`upper(${usersTable.name})`,
-			});
-
-		expect(users).toEqual([{ name: 'JANE' }]);
-	});
-
-	test('update with returning all fields', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const now = Date.now();
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning();
-
-		expect(users[0]!.createdAt).toBeInstanceOf(Date);
-		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(500);
-		expect(users).toEqual([
-			{
-				id1: 1,
-				name: 'Jane',
-				verified: false,
-				json: null,
-				createdAt: users[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('update with returning partial', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
-			id1: usersTable.id1,
-			name: usersTable.name,
-		});
-
-		expect(users).toEqual([{ id1: 1, name: 'Jane' }]);
-	});
-
-	test('delete with returning all fields', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const now = Date.now();
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
-
-		expect(users[0]!.createdAt).toBeInstanceOf(Date);
-		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(500);
-		expect(users.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{
-				name: 'John',
-				id1: 1,
-				id: undefined,
-				verified: false,
-				json: null,
-				createdAt: users[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('delete with returning partial', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-			id1: usersTable.id1,
-			name: usersTable.name,
-		});
-
-		expect(users.map((it) => ({ ...it, id: undefined }))).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('insert + select', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const result = await db.select().from(usersTable);
-		expect(result).toEqual([
-			{
-				name: 'John',
-				id1: 1,
-				verified: false,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-
-		await db.insert(usersTable).values({ id1: 2, name: 'Jane' });
-		const result2 = await db.select().from(usersTable);
-		expect(result2).toEqual([
-			{ id1: 1, name: 'John', verified: false, json: null, createdAt: result2[0]!.createdAt },
-			{ id1: 2, name: 'Jane', verified: false, json: null, createdAt: result2[1]!.createdAt },
-		]);
-	});
-
-	test('json insert', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John', json: ['foo', 'bar'] });
-		const result = await db
-			.select({
-				id1: usersTable.id1,
-				name: usersTable.name,
-				json: usersTable.json,
-			})
-			.from(usersTable);
-
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				json: ['foo', 'bar'],
-			},
-		]);
-	});
-
-	test('insert with overridden default values', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John', verified: true });
-		const result = await db.select().from(usersTable);
-
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				verified: true,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('insert many', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Bruce', json: ['foo', 'bar'], verified: true },
-			{ id1: 3, name: 'Jane' },
-			{ id1: 4, name: 'Austin', verified: true },
-		]);
-		const result = await db
-			.select({
-				name: usersTable.name,
-				json: usersTable.json,
-				verified: usersTable.verified,
-			})
-			.from(usersTable);
-
-		expect(result).toEqual([
-			{ name: 'John', json: null, verified: false },
-			{ name: 'Bruce', json: ['foo', 'bar'], verified: true },
-			{ name: 'Jane', json: null, verified: false },
-			{ name: 'Austin', json: null, verified: true },
-		]);
-	});
-
-	test('insert many with returning', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const result = await db
-			.insert(usersTable)
-			.values([
-				{ id1: 1, name: 'John' },
-				{ id1: 2, name: 'Bruce', json: ['foo', 'bar'] },
-				{ id1: 3, name: 'Jane' },
-				{
-					id1: 4,
-					name: 'Austin',
-					verified: true,
-				},
-			])
-			.returning({
-				name: usersTable.name,
-				json: usersTable.json,
-				verified: usersTable.verified,
-			});
-
-		expect(result).toEqual([
-			{ name: 'John', json: null, verified: false },
-			{ name: 'Bruce', json: ['foo', 'bar'], verified: false },
-			{ name: 'Jane', json: null, verified: false },
-			{ name: 'Austin', json: null, verified: true },
-		]);
-	});
-
-	test('select with group by as field', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db.select({ name: usersTable.name }).from(usersTable).groupBy(usersTable.name);
-
-		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-	});
-
-	test('select with exists', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const user = alias(usersTable, 'user');
-		const result = await db
-			.select({ name: usersTable.name })
-			.from(usersTable)
-			.where(
-				exists(
-					db
-						.select({ one: sql`1` })
-						.from(user)
-						.where(and(eq(usersTable.name, 'John'), eq(user.id1, usersTable.id1))),
-				),
-			);
-
-		expect(result).toEqual([{ name: 'John' }]);
-	});
-
-	test('select with group by as sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db
-			.select({ name: usersTable.name })
-			.from(usersTable)
-			.groupBy(sql`${usersTable.name}`);
-
-		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-	});
-
-	test.skip('select with group by as sql + column', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db
-			.select({ name: usersTable.name })
-			.from(usersTable)
-			.groupBy(sql`${usersTable.name}`, usersTable.id1);
-
-		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }, { name: 'Jane' }]);
-	});
-
-	test('select with group by as column + sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db
-			.select({ name: usersTable.name })
-			.from(usersTable)
-			.groupBy(usersTable.id1, sql`${usersTable.name}`);
-
-		expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-	});
-
-	test('select with group by complex query', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db
-			.select({ name: usersTable.name })
-			.from(usersTable)
-			.groupBy(usersTable.id1, sql`${usersTable.name}`)
-			.orderBy(asc(usersTable.name))
-			.limit(1);
-
-		expect(result).toEqual([{ name: 'Jane' }]);
-	});
-
-	test('build query', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db.select({ id: usersTable.id1, name: usersTable.name }).from(usersTable).groupBy(
-			usersTable.id1,
-			usersTable.name,
-		).toSQL();
-
-		expect(query).toEqual({
-			sql: 'select "users"."id1", "users"."name" from "users" group by "users"."id1", "users"."name"',
-			params: [],
-		});
-	});
-
-	test('insert sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: sql`${'John'}` });
-		const result = await db.select({ name: usersTable.name }).from(usersTable);
-		expect(result).toEqual([{ name: 'John' }]);
-	});
-
-	test('partial join with alias', async (ctx) => {
-		const { db } = ctx.gel;
-		const customerAlias = alias(usersTable, 'customer');
-
-		await db.insert(usersTable).values([
-			{ id1: 10, name: 'Ivan' },
-			{ id1: 11, name: 'Hans' },
-		]);
-		const result = await db
-			.select({
-				user: {
-					id1: usersTable.id1,
-					name: usersTable.name,
-				},
-				customer: {
-					id1: customerAlias.id1,
-					name: customerAlias.name,
-				},
-			})
-			.from(usersTable)
-			.leftJoin(customerAlias, eq(customerAlias.id1, 11))
-			.where(eq(usersTable.id1, 10));
-
-		expect(result).toEqual([
-			{
-				user: { id1: 10, name: 'Ivan' },
-				customer: { id1: 11, name: 'Hans' },
-			},
-		]);
-	});
-
-	test('full join with alias', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const gelTable = gelTableCreator((name) => `prefixed_${name}`);
-
-		const users = gelTable('users', {
-			id1: integer('id1').primaryKey(),
-			name: text('name').notNull(),
-		});
-
-		const customers = alias(users, 'customer');
-
-		await db.insert(users).values([
-			{ id1: 10, name: 'Ivan' },
-			{ id1: 11, name: 'Hans' },
-		]);
-		const result = await db.select().from(users).leftJoin(customers, eq(customers.id1, 11)).where(
-			eq(users.id1, 10),
-		);
-
-		expect(result).toEqual([
-			{
-				users: {
-					id1: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id1: 11,
-					name: 'Hans',
-				},
-			},
-		]);
-	});
-
-	test('select from alias', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const gelTable = gelTableCreator((name) => `prefixed_${name}`);
-
-		const users = gelTable('users', {
-			id1: integer('id1'),
-			name: text('name').notNull(),
-		});
-
-		const user = alias(users, 'user');
-		const customers = alias(users, 'customer');
-
-		await db.insert(users).values([
-			{ id1: 10, name: 'Ivan' },
-			{ id1: 11, name: 'Hans' },
-		]);
-		const result = await db.select().from(user).leftJoin(customers, eq(customers.id1, 11)).where(eq(user.id1, 10));
-
-		expect(result).toEqual([
-			{
-				user: {
-					id1: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id1: 11,
-					name: 'Hans',
-				},
-			},
-		]);
-	});
-
-	test('insert with spaces', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: sql`'Jo   h     n'` });
-		const result = await db.select({ id1: usersTable.id1, name: usersTable.name }).from(usersTable);
-
-		expect(result).toEqual([{ id1: 1, name: 'Jo   h     n' }]);
-	});
-
-	test('prepared statement', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const statement = db
-			.select({
-				name: usersTable.name,
-			})
-			.from(usersTable)
-			.prepare('statement1');
-		const result = await statement.execute();
-
-		expect(result).toEqual([{ name: 'John' }]);
-	});
-
-	test('insert: placeholders on columns with encoder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const statement = db
-			.insert(usersTable)
-			.values({
-				id1: 1,
-				name: 'John',
-				json: sql.placeholder('json'),
-			})
-			.prepare('encoder_statement');
-
-		await statement.execute({ json: ['foo', 'bar'] });
-
-		const result = await db
-			.select({
-				json: usersTable.json,
-			})
-			.from(usersTable);
-
-		expect(result).toEqual([{ json: ['foo', 'bar'] }]);
-	});
-
-	test('prepared statement reuse', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const stmt = db
-			.insert(usersTable)
-			.values({
-				id1: sql.placeholder('id1'),
-				verified: true,
-				name: sql.placeholder('name'),
-			})
-			.prepare('stmt2');
-
-		for (let i = 1; i < 11; i++) {
-			await stmt.execute({ id1: i, name: `John ${i}` });
-		}
-
-		const result = await db
-			.select({
-				name: usersTable.name,
-				verified: usersTable.verified,
-			})
-			.from(usersTable);
-
-		expect(result).toEqual([
-			{ name: 'John 1', verified: true },
-			{ name: 'John 2', verified: true },
-			{ name: 'John 3', verified: true },
-			{ name: 'John 4', verified: true },
-			{ name: 'John 5', verified: true },
-			{ name: 'John 6', verified: true },
-			{ name: 'John 7', verified: true },
-			{ name: 'John 8', verified: true },
-			{ name: 'John 9', verified: true },
-			{ name: 'John 10', verified: true },
-		]);
-	});
-
-	test('prepared statement with placeholder in .where', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const stmt = db
-			.select({
-				id1: usersTable.id1,
-				name: usersTable.name,
-			})
-			.from(usersTable)
-			.where(eq(usersTable.id1, sql.placeholder('id1')))
-			.prepare('stmt3');
-		const result = await stmt.execute({ id1: 1 });
-
-		expect(result).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('prepared statement with placeholder in .limit', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const stmt = db
-			.select({
-				id1: usersTable.id1,
-				name: usersTable.name,
-			})
-			.from(usersTable)
-			.where(eq(usersTable.id1, sql.placeholder('id1')))
-			.limit(sql.placeholder('limit'))
-			.prepare('stmt_limit');
-
-		const result = await stmt.execute({ id1: 1, limit: 1 });
-
-		expect(result).toEqual([{ id1: 1, name: 'John' }]);
-		expect(result).toHaveLength(1);
-	});
-
-	test('prepared statement with placeholder in .offset', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'John1' },
-		]);
-		const stmt = db
-			.select({
-				id1: usersTable.id1,
-				name: usersTable.name,
-			})
-			.from(usersTable)
-			.offset(sql.placeholder('offset'))
-			.prepare('stmt_offset');
-
-		const result = await stmt.execute({ offset: 1 });
-
-		expect(result).toEqual([{ id1: 2, name: 'John1' }]);
-	});
-
-	test('prepared statement built using $dynamic', async (ctx) => {
-		const { db } = ctx.gel;
-
-		function withLimitOffset(qb: any) {
-			return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
-		}
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'John1' },
-		]);
-		const stmt = db
-			.select({
-				id1: usersTable.id1,
-				name: usersTable.name,
-			})
-			.from(usersTable)
-			.$dynamic();
-		withLimitOffset(stmt).prepare('stmt_limit');
-
-		const result = await stmt.execute({ limit: 1, offset: 1 });
-
-		expect(result).toEqual([{ id1: 2, name: 'John1' }]);
-		expect(result).toHaveLength(1);
-	});
-
-	test('Query check: Insert all defaults in 1 row', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users', {
-			id: integer('id'),
-			name: text('name').default('Dan'),
-			state: text('state'),
-		});
-
-		const query = db.insert(users).values({}).toSQL();
-
-		expect(query).toEqual({
-			sql: 'insert into "users" ("id", "name", "state") values (default, default, default)',
-			params: [],
-		});
-	});
-
-	test('Query check: Insert all defaults in multiple rows', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users', {
-			id: integer('id'),
-			name: text('name').default('Dan'),
-			state: text('state').default('UA'),
-		});
-
-		const query = db.insert(users).values([{}, {}]).toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "users" ("id", "name", "state") values (default, default, default), (default, default, default)',
-			params: [],
-		});
-	});
-
-	test('Insert all defaults in 1 row', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('empty_insert_single', {
-			id1: integer('id1'),
-			name: text('name').default('Dan'),
-			state: text('state'),
-		});
-
-		await db.insert(users).values({});
-
-		const res = await db.select().from(users);
-
-		expect(res).toEqual([{ id1: null, name: 'Dan', state: null }]);
-	});
-
-	test('Insert all defaults in multiple rows', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('empty_insert_multiple', {
-			id: integer('id'),
-			name: text('name').default('Dan'),
-			state: text('state'),
-		});
-
-		await db.insert(users).values([{}, {}]);
-
-		const res = await db.select().from(users);
-
-		expect(res.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id: undefined, name: 'Dan', state: null },
-			{ id: undefined, name: 'Dan', state: null },
-		]);
-	});
-
-	// TODO not supported in gel
-	test.todo('build query insert with onConflict do update', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoUpdate({ target: usersTable.id1, set: { name: 'John1' } })
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, $3, default) on conflict ("id1") do update set "name" = $4',
-			params: [1, 'John', ['foo', 'bar'], 'John1'],
-		});
-	});
-
-	// TODO on conflict not supported in gel
-	test.todo('build query insert with onConflict do update / multiple columns', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoUpdate({ target: [usersTable.id1, usersTable.name], set: { name: 'John1' } })
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, $3, default) on conflict ("id1","name") do update set "name" = $4',
-			params: [1, 'John', ['foo', 'bar'], 'John1'],
-		});
-	});
-
-	// TODO on conflict not supported in gel
-	test.todo('build query insert with onConflict do nothing', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoNothing()
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, 32, default) on conflict do nothing',
-			params: [1, 'John', ['foo', 'bar']],
-		});
-	});
-
-	// TODO on conflict not supported
-	test.todo('build query insert with onConflict do nothing + target', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoNothing({ target: usersTable.id1 })
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, $3, default) on conflict ("id1") do nothing',
-			params: [1, 'John', ['foo', 'bar']],
-		});
-	});
-
-	// TODO on conflict not supported in gel
-	test.todo('insert with onConflict do update', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		await db
-			.insert(usersTable)
-			.values({ id1: 1, name: 'John' });
-		// .onConflictDoUpdate({ target: usersTable.id1, set: { name: 'John1' } });
-
-		const res = await db.select({ id1: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-			eq(usersTable.id1, 1),
-		);
-
-		expect(res).toEqual([{ id1: 1, name: 'John1' }]);
-	});
-
-	// TODO on conflict does not supported
-	test.todo('insert with onConflict do nothing', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		// await db.insert(usersTable).values({ id1: 1, name: 'John' }).onConflictDoNothing();
-
-		const res = await db.select({ id1: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-			eq(usersTable.id1, 1),
-		);
-
-		expect(res).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	// TODO on conflict does not supported
-	test.todo('insert with onConflict do nothing + target', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		// await db.insert(usersTable).values({ id1: 1, name: 'John' }).onConflictDoNothing({
-		// target: usersTable.id1,
-		// });
-
-		const res = await db.select({ id1: usersTable.id1, name: usersTable.name }).from(usersTable).where(
-			eq(usersTable.id1, 1),
-		);
-
-		expect(res).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('left join (flat object fields)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const { id1: cityId } = await db
-			.insert(citiesTable)
-			.values([
-				{ id1: 1, name: 'Paris', state: 'Unknown' },
-				{ id1: 2, name: 'London', state: 'Unknown' },
-			])
-			.returning({ id1: citiesTable.id1 })
-			.then((rows) => rows[0]!);
-
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId },
-			{ id1: 2, name: 'Jane', cityId },
-		]);
-
-		const res = await db
-			.select({
-				userId: users2Table.id1,
-				userName: users2Table.name,
-				cityId: citiesTable.id1,
-				cityName: citiesTable.name,
-			})
-			.from(users2Table)
-			.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id1));
-
-		expect(res).toEqual([
-			{ userId: 1, userName: 'John', cityId, cityName: 'Paris' },
-			{ userId: 2, userName: 'Jane', cityId, cityName: 'Paris' },
-		]);
-	});
-
-	test('left join (grouped fields)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const { id1: cityId } = await db
-			.insert(citiesTable)
-			.values([
-				{ id1: 1, name: 'Paris' },
-				{ id1: 2, name: 'London' },
-			])
-			.returning({ id1: citiesTable.id1 })
-			.then((rows) => rows[0]!);
-
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId },
-			{ id1: 2, name: 'Jane', cityId },
-		]);
-
-		const res = await db
-			.select({
-				id: users2Table.id1,
-				user: {
-					name: users2Table.name,
-					nameUpper: sql<string>`upper(${users2Table.name})`,
-				},
-				city: {
-					id: citiesTable.id1,
-					name: citiesTable.name,
-					nameUpper: sql<string>`upper(${citiesTable.name})`,
-				},
-			})
-			.from(users2Table)
-			.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id1));
-
-		expect(res).toEqual([
-			{
-				id: 1,
-				user: { name: 'John', nameUpper: 'JOHN' },
-				city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
-			},
-			{
-				id: 2,
-				user: { name: 'Jane', nameUpper: 'JANE' },
-				city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
-			},
-		]);
-	});
-
-	test('left join (all fields)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const { id1: cityId } = await db
-			.insert(citiesTable)
-			.values([
-				{ id1: 1, name: 'Paris' },
-				{ id1: 2, name: 'London' },
-			])
-			.returning({ id1: citiesTable.id1 })
-			.then((rows) => rows[0]!);
-
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId },
-			{ id1: 2, name: 'Jane', cityId },
-		]);
-
-		const res = await db.select().from(users2Table).leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id1));
-
-		expect(res).toEqual([
-			{
-				some_new_users: {
-					id1: 1,
-					name: 'John',
-					cityId,
-				},
-				cities: {
-					id1: cityId,
-					name: 'Paris',
-					state: null,
-				},
-			},
-			{
-				some_new_users: {
-					id1: 2,
-					name: 'Jane',
-					cityId,
-				},
-				cities: {
-					id1: cityId,
-					name: 'Paris',
-					state: null,
-				},
-			},
-		]);
-	});
-
-	test('join subquery', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(courseCategoriesTable).values([
-			{ id1: 1, name: 'Category 1' },
-			{ id1: 2, name: 'Category 2' },
-			{
-				id1: 3,
-				name: 'Category 3',
-			},
-			{ id1: 4, name: 'Category 4' },
-		]);
-
-		await db.insert(coursesTable).values([
-			{ id1: 1, name: 'Development', categoryId: 2 },
-			{ id1: 2, name: 'IT & Software', categoryId: 3 },
-			{ id1: 3, name: 'Marketing', categoryId: 4 },
-			{ id1: 4, name: 'Design', categoryId: 1 },
-		]);
-
-		const sq2 = db
-			.select({
-				categoryId: courseCategoriesTable.id1,
-				category: courseCategoriesTable.name,
-				total: sql<number>`count(${courseCategoriesTable.id1})`,
-			})
-			.from(courseCategoriesTable)
-			.groupBy(courseCategoriesTable.id1, courseCategoriesTable.name)
-			.as('sq2');
-
-		const res = await db
-			.select({
-				courseName: coursesTable.name,
-				categoryId: sq2.categoryId,
-			})
-			.from(coursesTable)
-			.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
-			.orderBy(coursesTable.name);
-
-		expect(res).toEqual([
-			{ courseName: 'Design', categoryId: 1 },
-			{ courseName: 'Development', categoryId: 2 },
-			{ courseName: 'IT & Software', categoryId: 3 },
-			{ courseName: 'Marketing', categoryId: 4 },
-		]);
-	});
-
-	test('with ... select', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(orders).values([
-			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-		]);
-
-		const regionalSales = db.$with('regional_sales').as(
-			db
-				.select({
-					region: orders.region,
-					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-				})
-				.from(orders)
-				.groupBy(orders.region),
-		);
-
-		const topRegions = db.$with('top_regions').as(
-			db
-				.select({
-					region: regionalSales.region,
-				})
-				.from(regionalSales)
-				.where(
-					gt(
-						regionalSales.totalSales,
-						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-					),
-				),
-		);
-
-		const result1 = await db
-			.with(regionalSales, topRegions)
-			.select({
-				region: orders.region,
-				product: orders.product,
-				productUnits: sql<number>`sum(${orders.quantity})::int`,
-				productSales: sql<number>`sum(${orders.amount})::int`,
-			})
-			.from(orders)
-			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-			.groupBy(orders.region, orders.product)
-			.orderBy(orders.region, orders.product);
-		const result2 = await db
-			.with(regionalSales, topRegions)
-			.selectDistinct({
-				region: orders.region,
-				product: orders.product,
-				productUnits: sql<number>`sum(${orders.quantity})::int`,
-				productSales: sql<number>`sum(${orders.amount})::int`,
-			})
-			.from(orders)
-			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-			.groupBy(orders.region, orders.product)
-			.orderBy(orders.region, orders.product);
-		const result3 = await db
-			.with(regionalSales, topRegions)
-			.selectDistinctOn([orders.region], {
-				region: orders.region,
-				productUnits: sql<number>`sum(${orders.quantity})::int`,
-				productSales: sql<number>`sum(${orders.amount})::int`,
-			})
-			.from(orders)
-			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-			.groupBy(orders.region)
-			.orderBy(orders.region);
-
-		expect(result1).toEqual([
-			{
-				region: 'Europe',
-				product: 'A',
-				productUnits: 3,
-				productSales: 30,
-			},
-			{
-				region: 'Europe',
-				product: 'B',
-				productUnits: 5,
-				productSales: 50,
-			},
-			{
-				region: 'US',
-				product: 'A',
-				productUnits: 7,
-				productSales: 70,
-			},
-			{
-				region: 'US',
-				product: 'B',
-				productUnits: 9,
-				productSales: 90,
-			},
-		]);
-		expect(result2).toEqual(result1);
-		expect(result3).toEqual([
-			{
-				region: 'Europe',
-				productUnits: 8,
-				productSales: 80,
-			},
-			{
-				region: 'US',
-				productUnits: 16,
-				productSales: 160,
-			},
-		]);
-	});
-
-	test('with ... update', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const products = gelTable('products', {
-			id1: integer('id1'),
-			price: decimal('price').notNull(),
-			cheap: boolean('cheap').notNull().default(false),
-		});
-
-		await db.insert(products).values([
-			{ id1: 1, price: '10.99' },
-			{ id1: 2, price: '25.85' },
-			{ id1: 3, price: '32.99' },
-			{ id1: 4, price: '2.50' },
-			{ id1: 5, price: '4.59' },
-		]);
-
-		const averagePrice = db.$with('average_price').as(
-			db
-				.select({
-					value: sql`avg(${products.price})`.as('value'),
-				})
-				.from(products),
-		);
-
-		const result = await db
-			.with(averagePrice)
-			.update(products)
-			.set({
-				cheap: true,
-			})
-			.where(lt(products.price, sql`(select * from ${averagePrice})`))
-			.returning({
-				id1: products.id1,
-			});
-
-		expect(result).toEqual([{ id1: 1 }, { id1: 4 }, { id1: 5 }]);
-	});
-
-	test('with ... insert', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_with_insert', {
-			username: text('username').notNull(),
-			admin: boolean('admin').notNull(),
-		});
-
-		const userCount = db.$with('user_count').as(
-			db
-				.select({
-					value: sql`count(*)`.as('value'),
-				})
-				.from(users),
-		);
-
-		const result = await db
-			.with(userCount)
-			.insert(users)
-			.values([{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` }])
-			.returning({
-				admin: users.admin,
-			});
-
-		expect(result).toEqual([{ admin: true }]);
-	});
-
-	test('with ... delete', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(orders).values([
-			{ id1: 1, region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-			{ id1: 2, region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-			{ id1: 3, region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-			{ id1: 4, region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-			{ id1: 5, region: 'US', product: 'A', amount: 30, quantity: 3 },
-			{ id1: 6, region: 'US', product: 'A', amount: 40, quantity: 4 },
-			{ id1: 7, region: 'US', product: 'B', amount: 40, quantity: 4 },
-			{ id1: 8, region: 'US', product: 'B', amount: 50, quantity: 5 },
-		]);
-
-		const averageAmount = db.$with('average_amount').as(
-			db
-				.select({
-					value: sql`avg(${orders.amount})`.as('value'),
-				})
-				.from(orders),
-		);
-
-		const result = await db
-			.with(averageAmount)
-			.delete(orders)
-			.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
-			.returning({
-				id1: orders.id1,
-			});
-
-		expect(result).toEqual([{ id1: 6 }, { id1: 7 }, { id1: 8 }]);
-	});
-
-	test('select from subquery sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(users3Table).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-		]);
-
-		const sq = db
-			.select({ name: sql<string>`${users3Table.name} || ' modified'`.as('name') })
-			.from(users3Table)
-			.as('sq');
-
-		const res = await db.select({ name: sq.name }).from(sq);
-
-		expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
-	});
-
-	test('select a field without joining its table', (ctx) => {
-		const { db } = ctx.gel;
-
-		expect(() => db.select({ name: users3Table.name }).from(usersTable).prepare('query')).toThrowError();
-	});
-
-	test('select all fields from subquery without alias', (ctx) => {
-		const { db } = ctx.gel;
-
-		const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users3Table.name})` }).from(users3Table));
-
-		expect(() => db.select().from(sq).prepare('query')).toThrowError();
-	});
-
-	test('select count()', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-		]);
-
-		const res = await db.select({ count: sql`count(*)` }).from(usersTable);
-
-		expect(res).toEqual([{ count: 2 }]);
-	});
-
-	test('select count w/ custom mapper', async (ctx) => {
-		const { db } = ctx.gel;
-
-		function count(value: GelColumn | SQLWrapper): SQL<number>;
-		function count(value: GelColumn | SQLWrapper, alias: string): SQL.Aliased<number>;
-		function count(value: GelColumn | SQLWrapper, alias?: string): SQL<number> | SQL.Aliased<number> {
-			const result = sql`count(${value})`.mapWith(Number);
-			if (!alias) {
-				return result;
-			}
-			return result.as(alias);
-		}
-
-		await db.insert(usersTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-		]);
-
-		const res = await db.select({ count: count(sql`*`) }).from(usersTable);
-
-		expect(res).toEqual([{ count: 2 }]);
-	});
-
-	test('array types', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const values: (typeof salEmp.$inferSelect)[] = [
-			{
-				name: 'John',
-				payByQuarter: [10000, 10000, 10000, 10000],
-			},
-			{
-				name: 'Carol',
-				payByQuarter: [20000, 25000, 25000, 25000],
-			},
-		];
-
-		await db.insert(salEmp).values(values);
-
-		const res = await db.select().from(salEmp);
-
-		expect(res.map((it) => ({ ...it, id: undefined }))).toEqual(values);
-	});
-
-	test('select for ...', (ctx) => {
-		const { db } = ctx.gel;
-
-		{
-			const query = db.select().from(users3Table).for('update').toSQL();
-
-			expect(query.sql).toMatch(/ for update$/);
-		}
-
-		{
-			const query = db
-				.select()
-				.from(users2Table)
-				.for('update', { of: [users3Table, coursesTable] })
-				.toSQL();
-
-			expect(query.sql).toMatch(/ for update of "users3", "courses"$/);
-		}
-
-		{
-			const query = db.select().from(users3Table).for('no key update', { of: users3Table }).toSQL();
-
-			expect(query.sql).toMatch(/for no key update of "users3"$/);
-		}
-
-		{
-			const query = db.select().from(users3Table).for('no key update', { of: users3Table, skipLocked: true })
-				.toSQL();
-
-			expect(query.sql).toMatch(/ for no key update of "users3" skip locked$/);
-		}
-
-		{
-			const query = db.select().from(users3Table).for('share', { of: users3Table, noWait: true }).toSQL();
-
-			expect(query.sql).toMatch(/for share of "users3" nowait$/);
-		}
-	});
-
-	// TODO
-	// column "rel~1.0e3b7152-d977-11ef-a173-530b4c6088b1" must appear in the GROUP BY
-	test.todo('having', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(citiesTable).values([
-			{ id1: 1, name: 'London' },
-			{ id1: 2, name: 'Paris' },
-			{
-				id1: 3,
-				name: 'New York',
-			},
-		]);
-
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId: 1 },
-			{ id1: 2, name: 'Jane', cityId: 1 },
-			{
-				id1: 3,
-				name: 'Jack',
-				cityId: 2,
-			},
-		]);
-
-		const result = await db
-			.select({
-				id1: citiesTable.id1,
-				name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
-				usersCount: sql<number>`count(${users2Table.id1})::int`.as('users_count'),
-			})
-			.from(citiesTable)
-			.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id1))
-			.where(({ name }) => sql`length(${name}) >= 3`)
-			.groupBy(citiesTable.id1)
-			.having(({ usersCount }) => sql`${usersCount} > 0`)
-			.orderBy(({ name }) => name);
-
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'LONDON',
-				usersCount: 2,
-			},
-			{
-				id1: 2,
-				name: 'PARIS',
-				usersCount: 1,
-			},
-		]);
-	});
-
-	test('select from raw sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const result = await db
-			.select({
-				id: sql<number>`id`,
-				name: sql<string>`name`,
-			})
-			.from(sql`(select 1 as id, 'John' as name) as users`);
-
-		Expect<Equal<{ id: number; name: string }[], typeof result>>;
-		expect(result).toEqual([{ id: 1, name: 'John' }]);
-	});
-
-	test('select from raw sql with joins', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const result = await db
-			.select({
-				id: sql<number>`users.id`,
-				name: sql<string>`users.name`,
-				userCity: sql<string>`users.city`,
-				cityName: sql<string>`cities.name`,
-			})
-			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
-
-		Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
-
-		expect(result).toEqual([{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' }]);
-	});
-
-	test('join on aliased sql from select', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const result = await db
-			.select({
-				userId: sql<number>`users.id`.as('userId'),
-				name: sql<string>`users.name`,
-				userCity: sql<string>`users.city`,
-				cityId: sql<number>`cities.id`.as('cityId'),
-				cityName: sql<string>`cities.name`,
-			})
-			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
-
-		Expect<
-			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-		>;
-
-		expect(result).toEqual([{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
-	});
-
-	test('join on aliased sql from with clause', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = db.$with('users').as(
-			db
-				.select({
-					id: sql<number>`id`.as('userId'),
-					name: sql<string>`name`.as('userName'),
-					city: sql<string>`city`.as('city'),
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`),
-		);
-
-		const cities = db.$with('cities').as(
-			db
-				.select({
-					id: sql<number>`id`.as('cityId'),
-					name: sql<string>`name`.as('cityName'),
-				})
-				.from(sql`(select 1 as id, 'Paris' as name) as cities`),
-		);
-
-		const result = await db
-			.with(users, cities)
-			.select({
-				userId: users.id,
-				name: users.name,
-				userCity: users.city,
-				cityId: cities.id,
-				cityName: cities.name,
-			})
-			.from(users)
-			.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
-
-		Expect<
-			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-		>;
-
-		expect(result).toEqual([{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
-	});
-
-	test('prefixed table', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const gelTable = gelTableCreator((name) => `myprefix_${name}`);
-
-		const users = gelTable('test_prefixed_table_with_unique_name', {
-			id1: integer('id1').primaryKey(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(users).values({ id1: 1, name: 'John' });
-
-		const result = await db.select().from(users);
-
-		expect(result.map((it) => ({ ...it, id: undefined }))).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('all date and time columns', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const table = gelTable('dates_column', {
-			datetimeColumn: timestamptz().notNull(),
-			local_datetimeColumn: timestamp().notNull(),
-			local_dateColumn: localDate().notNull(),
-			local_timeColumn: localTime().notNull(),
-
-			durationColumn: duration().notNull(),
-			relative_durationColumn: relDuration().notNull(),
-			dateDurationColumn: dateDuration().notNull(),
-		});
-
-		await db.insert(table).values({
-			datetimeColumn: new Date('2022-01-01T00:00:00.123Z'),
-			local_datetimeColumn: new LocalDateTime(2014, 2, 1, 4, 1, 6, 2, 0, 0),
-			local_dateColumn: new LocalDate(2013, 2, 1),
-			local_timeColumn: new LocalTime(12, 42, 2, 3, 1, 0),
-			durationColumn: new Duration(0, 0, 0, 0, 12, 3, 0, 0, 1, 3),
-			relative_durationColumn: new RelativeDuration(2014, 2, 1, 4, 1, 6, 2, 0, 0),
-			dateDurationColumn: new DateDuration(2032, 2, 1, 5),
-		});
-
-		const result = await db.select().from(table);
-
-		Expect<
-			Equal<
-				{
-					datetimeColumn: Date;
-					local_datetimeColumn: LocalDateTime;
-					local_dateColumn: LocalDate;
-					local_timeColumn: LocalTime;
-					durationColumn: Duration;
-					relative_durationColumn: RelativeDuration;
-					dateDurationColumn: DateDuration;
-				}[],
-				typeof result
-			>
-		>;
-
-		Expect<
-			Equal<
-				{
-					datetimeColumn: Date;
-					local_datetimeColumn: LocalDateTime;
-					local_dateColumn: LocalDate;
-					local_timeColumn: LocalTime;
-					durationColumn: Duration;
-					relative_durationColumn: RelativeDuration;
-					dateDurationColumn: DateDuration;
-				},
-				typeof table.$inferInsert
-			>
-		>;
-	});
-
-	test('orderBy with aliased column', (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.select({
-				test: sql`something`.as('test'),
-			})
-			.from(users3Table)
-			.orderBy((fields) => fields.test)
-			.toSQL();
-
-		expect(query.sql).toBe('select something as "test" from "users3" order by "test"');
-	});
-
-	test('select from sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const metricEntry = gelTable('metric_entry', {
-			id1: gelUuid('id1').notNull(),
-			createdAt: timestamptz('created_at').notNull(),
-		});
-
-		const metricId = uuidV4();
-
-		const intervals = db.$with('intervals').as(
-			db
-				.select({
-					startTime: sql<string>`(date'2023-03-01'+ x * '1 day'::interval)`.as('start_time'),
-					endTime: sql<string>`(date'2023-03-01'+ (x+1) *'1 day'::interval)`.as('end_time'),
-				})
-				.from(sql`generate_series(0, 29, 1) as t(x)`),
-		);
-
-		const func = () =>
-			db
-				.with(intervals)
-				.select({
-					startTime: intervals.startTime,
-					endTime: intervals.endTime,
-					count: sql<number>`count(${metricEntry})`,
-				})
-				.from(metricEntry)
-				.rightJoin(
-					intervals,
-					and(
-						eq(metricEntry.id1, metricId),
-						gte(metricEntry.createdAt, intervals.startTime),
-						lt(metricEntry.createdAt, intervals.endTime),
-					),
-				)
-				.groupBy(intervals.startTime, intervals.endTime)
-				.orderBy(asc(intervals.startTime));
-
-		await expect(
-			(async () => {
-				func();
-			})(),
-		).resolves.not.toThrowError();
-	});
-
-	test('transaction', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_transactions', {
-			id1: integer('id1').notNull(),
-			balance: integer('balance').notNull(),
-		});
-		const products = gelTable('products_transactions', {
-			id1: integer('id1').notNull(),
-			price: integer('price').notNull(),
-			stock: integer('stock').notNull(),
-		});
-
-		const user = await db
-			.insert(users)
-			.values({ id1: 1, balance: 100 })
-			.returning()
-			.then((rows) => rows[0]!);
-		const product = await db
-			.insert(products)
-			.values({ id1: 1, price: 10, stock: 10 })
-			.returning()
-			.then((rows) => rows[0]!);
-
-		await db.transaction(async (tx) => {
-			await tx
-				.update(users)
-				.set({ balance: user.balance - product.price })
-				.where(eq(users.id1, user.id1));
-			await tx
-				.update(products)
-				.set({ stock: product.stock - 1 })
-				.where(eq(products.id1, product.id1));
-		});
-
-		const result = await db.select().from(users);
-
-		expect(result).toEqual([{ id1: 1, balance: 90 }]);
-	});
-
-	test('transaction rollback', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_transactions_rollback', {
-			id1: integer('id1').notNull(),
-			balance: integer('balance').notNull(),
-		});
-
-		await expect(
-			(async () => {
-				await db.transaction(async (tx) => {
-					await tx.insert(users).values({ id1: 1, balance: 100 });
-					tx.rollback();
-				});
-			})(),
-		).rejects.toThrowError(Error);
-
-		const result = await db.select().from(users);
-
-		expect(result).toEqual([]);
-	});
-
-	test('join subquery with join', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const internalStaff = gelTable('internal_staff', {
-			userId: integer('userId').notNull(),
-		});
-
-		const customUser = gelTable('custom_user', {
-			id1: integer('id1').notNull(),
-		});
-
-		const ticket = gelTable('ticket', {
-			staffId: integer('staffId').notNull(),
-		});
-
-		await db.insert(internalStaff).values({ userId: 1 });
-		await db.insert(customUser).values({ id1: 1 });
-		await db.insert(ticket).values({ staffId: 1 });
-
-		const subq = db.select().from(internalStaff).leftJoin(customUser, eq(internalStaff.userId, customUser.id1)).as(
-			'internal_staff',
-		);
-
-		const mainQuery = await db.select().from(ticket).leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-		expect(mainQuery).toEqual([
-			{
-				ticket: { staffId: 1 },
-				internal_staff: {
-					internal_staff: { userId: 1 },
-					custom_user: { id1: 1 },
-				},
-			},
-		]);
-	});
-
-	test('table selection with single table', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_with_cities', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-			cityId: integer('cityId').notNull(),
-		});
-
-		await db.insert(users).values({ id1: 1, name: 'John', cityId: 1 });
-
-		const result = await db.select({ users }).from(users);
-
-		expect(result).toEqual([{ users: { id1: 1, name: 'John', cityId: 1 } }]);
-	});
-
-	test('set null to json field', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const result = await db.insert(usersTable).values({ id1: 1, name: 'Alex', json: null }).returning();
-
-		expect(result.map((it) => ({ ...it, verified: undefined, createdAt: undefined }))).toEqual([
-			{
-				id1: 1,
-				name: 'Alex',
-				json: null,
-				verified: undefined,
-				createdAt: undefined,
-			},
-		]);
-	});
-
-	test('insert undefined', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_with_undefined', {
-			id1: integer('id1').notNull(),
-			name: text('name'),
-		});
-
-		await expect(
-			(async () => {
-				await db.insert(users).values({ id1: 1, name: undefined });
-			})(),
-		).resolves.not.toThrowError();
-	});
-
-	test('update undefined', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users', {
-			id1: integer('id1').notNull(),
-			name: text('name'),
-		});
-
-		await expect(
-			(async () => {
-				await db.update(users).set({ name: undefined });
-			})(),
-		).rejects.toThrowError();
-		await expect(
-			(async () => {
-				db.update(users).set({ name: undefined });
-			})(),
-		).rejects.toThrowError();
-	});
-
-	test('array operators', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const posts = gelTable('posts', {
-			id1: integer('id1').notNull(),
-			tags: text('tags').array(),
-		});
-
-		await db.insert(posts).values([
-			{
-				id1: 1,
-				tags: ['ORM'],
-			},
-			{
-				id1: 2,
-				tags: ['Typescript'],
-			},
-			{
-				id1: 3,
-				tags: ['Typescript', 'ORM'],
-			},
-			{ id1: 4, tags: ['Typescript', 'Frontend', 'React'] },
-			{
-				id1: 5,
-				tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
-			},
-			{
-				id1: 6,
-				tags: ['Java', 'Spring', 'OOP'],
-			},
-		]);
-
-		const contains = await db
-			.select({ id1: posts.id1 })
-			.from(posts)
-			.where(arrayContains(posts.tags, ['Typescript', 'ORM']));
-		const contained = await db
-			.select({ id1: posts.id1 })
-			.from(posts)
-			.where(arrayContained(posts.tags, ['Typescript', 'ORM']));
-		const overlaps = await db
-			.select({ id1: posts.id1 })
-			.from(posts)
-			.where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']));
-		const withSubQuery = await db
-			.select({ id1: posts.id1 })
-			.from(posts)
-			.where(arrayContains(posts.tags, db.select({ tags: posts.tags }).from(posts).where(eq(posts.id1, 1))));
-
-		expect(contains).toEqual([{ id1: 3 }, { id1: 5 }]);
-		expect(contained).toEqual([{ id1: 1 }, { id1: 2 }, { id1: 3 }]);
-		expect(overlaps).toEqual([{ id1: 1 }, { id1: 2 }, { id1: 3 }, { id1: 4 }, { id1: 5 }]);
-		expect(withSubQuery).toEqual([{ id1: 1 }, { id1: 3 }, { id1: 5 }]);
-	});
-
-	test('set operations (union) from query builder with subquery', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const sq = db
-			.select({ id: users2Table.id1, name: users2Table.name })
-			.from(users2Table).as('sq');
-
-		const result = await db
-			.select({ id: cities2Table.id1, name: citiesTable.name })
-			.from(cities2Table).union(
-				db.select().from(sq),
-			).orderBy(asc(sql`name`)).limit(2).offset(1);
-
-		expect(result).toHaveLength(2);
-
-		expect(result).toEqual([
-			{ id: 3, name: 'Jack' },
-			{ id: 2, name: 'Jane' },
-		]);
-
-		await expect((async () => {
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name, name2: users2Table.name })
-				.from(cities2Table).union(
-					// @ts-expect-error
-					db
-						.select({ id: users2Table.id1, name: users2Table.name })
-						.from(users2Table),
-				).orderBy(asc(sql`name`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (union) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await union(
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).where(eq(citiesTable.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		).orderBy(asc(sql`name`)).limit(1).offset(1);
-
-		expect(result).toHaveLength(1);
-
-		expect(result).toEqual([
-			{ id: 1, name: 'New York' },
-		]);
-
-		await expect((async () => {
-			union(
-				db
-					.select({ name: citiesTable.name, id: cities2Table.id1 })
-					.from(cities2Table).where(eq(citiesTable.id1, 1)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			).orderBy(asc(sql`name`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (union all) from query builder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await db
-			.select({ id1: cities2Table.id1, name: citiesTable.name })
-			.from(cities2Table).limit(2).unionAll(
-				db
-					.select({ id1: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).limit(2),
-			).orderBy(asc(sql`id1`));
-
-		expect(result).toHaveLength(4);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'New York' },
-			{ id1: 1, name: 'New York' },
-			{ id1: 2, name: 'London' },
-			{ id1: 2, name: 'London' },
-		]);
-
-		await expect((async () => {
-			db
-				.select({ id1: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).limit(2).unionAll(
-					db
-						.select({ name: citiesTable.name, id1: cities2Table.id1 })
-						.from(cities2Table).limit(2),
-				).orderBy(asc(sql`id1`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (union all) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await unionAll(
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).where(eq(citiesTable.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		);
-
-		expect(result).toHaveLength(3);
-
-		expect(result).toEqual([
-			{ id: 1, name: 'New York' },
-			{ id: 1, name: 'John' },
-			{ id: 1, name: 'John' },
-		]);
-
-		await expect((async () => {
-			unionAll(
-				db
-					.select({ id: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id1, 1)),
-				db
-					.select({ name: users2Table.name, id: users2Table.id1 })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			);
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (intersect) from query builder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await db
-			.select({ id: cities2Table.id1, name: citiesTable.name })
-			.from(cities2Table).intersect(
-				db
-					.select({ id: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).where(gt(citiesTable.id1, 1)),
-			).orderBy(asc(sql`name`));
-
-		expect(result).toHaveLength(2);
-
-		expect(result).toEqual([
-			{ id: 2, name: 'London' },
-			{ id: 3, name: 'Tampa' },
-		]);
-
-		await expect((async () => {
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).intersect(
-					// @ts-expect-error
-					db
-						.select({ id: cities2Table.id1, name: citiesTable.name, id2: cities2Table.id1 })
-						.from(cities2Table).where(gt(citiesTable.id1, 1)),
-				).orderBy(asc(sql`name`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (intersect) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await intersect(
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).where(eq(citiesTable.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		);
-
-		expect(result).toHaveLength(0);
-
-		expect(result).toEqual([]);
-
-		await expect((async () => {
-			intersect(
-				db
-					.select({ id: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id1, 1)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				db
-					.select({ name: users2Table.name, id: users2Table.id1 })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			);
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (intersect all) from query builder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await db
-			.select({ id1: cities2Table.id1, name: citiesTable.name })
-			.from(cities2Table).limit(2).intersectAll(
-				db
-					.select({ id1: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).limit(2),
-			).orderBy(asc(sql`id1`));
-
-		expect(result).toHaveLength(2);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'New York' },
-			{ id1: 2, name: 'London' },
-		]);
-
-		await expect((async () => {
-			db
-				.select({ id: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).limit(2).intersectAll(
-					db
-						.select({ name: users2Table.name, id: users2Table.id1 })
-						.from(cities2Table).limit(2),
-				).orderBy(asc(sql`id`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (intersect all) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await intersectAll(
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			db
-				.select({ id: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		);
-
-		expect(result).toHaveLength(1);
-
-		expect(result).toEqual([
-			{ id: 1, name: 'John' },
-		]);
-
-		await expect((async () => {
-			intersectAll(
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				db
-					.select({ name: users2Table.name, id: users2Table.id1 })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			);
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (except) from query builder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await db
-			.select()
-			.from(cities2Table).except(
-				db
-					.select()
-					.from(cities2Table).where(gt(citiesTable.id1, 1)),
-			);
-
-		expect(result).toHaveLength(1);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'New York' },
-		]);
-
-		await expect((async () => {
-			db
-				.select()
-				.from(cities2Table).except(
-					db
-						.select({ name: users2Table.name, id1: users2Table.id1 })
-						.from(cities2Table).where(gt(citiesTable.id1, 1)),
-				);
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (except) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await except(
-			db
-				.select({ id1: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table),
-			db
-				.select({ id1: cities2Table.id1, name: citiesTable.name })
-				.from(cities2Table).where(eq(citiesTable.id1, 1)),
-			db
-				.select({ id1: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		).orderBy(asc(sql`id1`));
-
-		expect(result).toHaveLength(2);
-
-		expect(result).toEqual([
-			{ id1: 2, name: 'London' },
-			{ id1: 3, name: 'Tampa' },
-		]);
-
-		await expect((async () => {
-			except(
-				db
-					.select({ id1: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table),
-				db
-					.select({ name: users2Table.name, id1: users2Table.id1 })
-					.from(cities2Table).where(eq(citiesTable.id1, 1)),
-				db
-					.select({ id1: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			).orderBy(asc(sql`id1`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (except all) from query builder', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await db
-			.select()
-			.from(cities2Table).exceptAll(
-				db
-					.select({ id1: cities2Table.id1, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id1, 1)),
-			).orderBy(asc(sql`id1`));
-
-		expect(result).toHaveLength(2);
-
-		expect(result).toEqual([
-			{ id1: 2, name: 'London' },
-			{ id1: 3, name: 'Tampa' },
-		]);
-
-		await expect((async () => {
-			db
-				.select({ name: cities2Table.name, id1: cities2Table.id1 })
-				.from(cities2Table).exceptAll(
-					db
-						.select({ id1: cities2Table.id1, name: citiesTable.name })
-						.from(cities2Table).where(eq(citiesTable.id1, 1)),
-				).orderBy(asc(sql`id1`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (except all) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await exceptAll(
-			db
-				.select({ id1: users2Table.id1, name: users2Table.name })
-				.from(users2Table),
-			db
-				.select({ id1: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(gt(users2Table.id1, 7)),
-			db
-				.select({ id1: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-		).orderBy(asc(sql`id1`)).limit(5).offset(2);
-
-		expect(result).toHaveLength(4);
-
-		expect(result).toEqual([
-			{ id1: 4, name: 'Peter' },
-			{ id1: 5, name: 'Ben' },
-			{ id1: 6, name: 'Jill' },
-			{ id1: 7, name: 'Mary' },
-		]);
-
-		await expect((async () => {
-			exceptAll(
-				db
-					.select({ name: users2Table.name, id: users2Table.id1 })
-					.from(users2Table),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(gt(users2Table.id1, 7)),
-				db
-					.select({ id: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-			).orderBy(asc(sql`id`));
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (mixed) from query builder with subquery', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-		const sq = db
-			.select()
-			.from(cities2Table).where(gt(citiesTable.id1, 1)).as('sq');
-
-		const result = await db
-			.select()
-			.from(cities2Table).except(
-				({ unionAll }) =>
-					unionAll(
-						db.select().from(sq),
-						db.select().from(cities2Table).where(eq(citiesTable.id1, 2)),
-					),
-			);
-
-		expect(result).toHaveLength(1);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'New York' },
-		]);
-
-		await expect((async () => {
-			db
-				.select()
-				.from(cities2Table).except(
-					({ unionAll }) =>
-						unionAll(
-							db
-								.select({ name: cities2Table.name, id1: cities2Table.id1 })
-								.from(cities2Table).where(gt(citiesTable.id1, 1)),
-							db.select().from(cities2Table).where(eq(citiesTable.id1, 2)),
-						),
-				);
-		})()).rejects.toThrowError();
-	});
-
-	test('set operations (mixed all) as function', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await setupSetOperationTest(db);
-
-		const result = await union(
-			db
-				.select({ id1: users2Table.id1, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id1, 1)),
-			except(
-				db
-					.select({ id1: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(gte(users2Table.id1, 5)),
-				db
-					.select({ id1: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 7)),
-			),
-			db
-				.select().from(cities2Table).where(gt(citiesTable.id1, 1)),
-		).orderBy(asc(sql`id1`));
-
-		expect(result).toHaveLength(6);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'London' },
-			{ id1: 3, name: 'Tampa' },
-			{ id1: 5, name: 'Ben' },
-			{ id1: 6, name: 'Jill' },
-			{ id1: 8, name: 'Sally' },
-		]);
-
-		await expect((async () => {
-			union(
-				db
-					.select({ id1: users2Table.id1, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id1, 1)),
-				except(
-					db
-						.select({ id1: users2Table.id1, name: users2Table.name })
-						.from(users2Table).where(gte(users2Table.id1, 5)),
-					db
-						.select({ name: users2Table.name, id1: users2Table.id1 })
-						.from(users2Table).where(eq(users2Table.id1, 7)),
-				),
-				db
-					.select().from(cities2Table).where(gt(citiesTable.id1, 1)),
-			).orderBy(asc(sql`id`));
-		})()).rejects.toThrowError();
-	});
-	test('aggregate function: count', async (ctx) => {
-		const { db } = ctx.gel;
-		const table = aggregateTable;
-		await setupAggregateFunctionsTest(db);
-
-		const result1 = await db.select({ value: count() }).from(table);
-		const result2 = await db.select({ value: count(table.a) }).from(table);
-		const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
-
-		expect(result1[0]?.value).toBe(7);
-		expect(result2[0]?.value).toBe(5);
-		expect(result3[0]?.value).toBe(6);
-	});
-
-	test('aggregate function: avg', async (ctx) => {
-		const { db } = ctx.gel;
-		const table = aggregateTable;
-		await setupAggregateFunctionsTest(db);
-
-		const result1 = await db.select({ value: avg(table.b) }).from(table);
-		const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
-		const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
-
-		expect(result1[0]?.value).toBe('33.3333333333333333');
-		expect(result2[0]?.value).toBeNull();
-		expect(result3[0]?.value).toBe('42.5000000000000000');
-	});
-
-	test('aggregate function: sum', async (ctx) => {
-		const { db } = ctx.gel;
-		const table = aggregateTable;
-		await setupAggregateFunctionsTest(db);
-
-		const result1 = await db.select({ value: sum(table.b) }).from(table);
-		const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
-		const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
-
-		expect(result1[0]?.value).toBe('200');
-		expect(result2[0]?.value).toBeNull();
-		expect(result3[0]?.value).toBe('170');
-	});
-
-	test('aggregate function: max', async (ctx) => {
-		const { db } = ctx.gel;
-		const table = aggregateTable;
-		await setupAggregateFunctionsTest(db);
-
-		const result1 = await db.select({ value: max(table.b) }).from(table);
-		const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
-
-		expect(result1[0]?.value).toBe(90);
-		expect(result2[0]?.value).toBeNull();
-	});
-
-	test('aggregate function: min', async (ctx) => {
-		const { db } = ctx.gel;
-		const table = aggregateTable;
-		await setupAggregateFunctionsTest(db);
-
-		const result1 = await db.select({ value: min(table.b) }).from(table);
-		const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
-
-		expect(result1[0]?.value).toBe(10);
-		expect(result2[0]?.value).toBeNull();
-	});
-
-	test('array mapping and parsing', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const arrays = gelTable('arrays_tests', {
-			id1: integer('id1').notNull(),
-			tags: text('tags').array(),
-			numbers: integer('numbers').notNull().array(),
-		});
-
-		await db.insert(arrays).values({
-			id1: 1,
-			tags: ['', 'b', 'c'],
-			numbers: [1, 2, 3],
-		});
-
-		const result = await db.select().from(arrays);
-
-		expect(result).toEqual([
-			{
-				id1: 1,
-				tags: ['', 'b', 'c'],
-				numbers: [1, 2, 3],
-			},
-		]);
-	});
-
-	test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersOnUpdate).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jack',
-			},
-			{ id1: 4, name: 'Jill' },
-		]);
-
-		// const { updatedAt, ..._ } = getTableColumns(usersOnUpdate);
-
-		// const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id1));
-
-		const response = await db.select(getTableColumns(usersOnUpdate)).from(usersOnUpdate).orderBy(
-			asc(usersOnUpdate.id1),
-		);
-
-		expect(response.map((it) => ({ ...it, updatedAt: undefined }))).toEqual([
-			{ name: 'John', id1: 1, updateCounter: 1, alwaysNull: null, updatedAt: undefined },
-			{ name: 'Jane', id1: 2, updateCounter: 1, alwaysNull: null, updatedAt: undefined },
-			{ name: 'Jack', id1: 3, updateCounter: 1, alwaysNull: null, updatedAt: undefined },
-			{ name: 'Jill', id1: 4, updateCounter: 1, alwaysNull: null, updatedAt: undefined },
-		]);
-
-		// const msDelay = 250;
-
-		// for (const eachUser of justDates) {
-		// 	expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-		// }
-	});
-
-	test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersOnUpdate).values([
-			{ id1: 1, name: 'John', alwaysNull: 'this will be null after updating' },
-			{ id1: 2, name: 'Jane' },
-			{ id1: 3, name: 'Jack' },
-			{ id1: 4, name: 'Jill' },
-		]);
-
-		const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-		await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id1));
-
-		await db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id1, 1));
-		await db.update(usersOnUpdate).set({ updateCounter: null }).where(eq(usersOnUpdate.id1, 2));
-
-		// const justDates = await db.select({ updatedAt: usersOnUpdate.updatedAt }).from(usersOnUpdate).orderBy(
-		// 	asc(usersOnUpdate.id1),
-		// );
-
-		const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(
-			asc(usersOnUpdate.id1),
-		);
-
-		expect(response).toEqual([
-			{ name: 'Angel', id1: 1, updateCounter: 2, alwaysNull: null },
-			{ name: 'Jane', id1: 2, updateCounter: null, alwaysNull: null },
-			{ name: 'Jack', id1: 3, updateCounter: 1, alwaysNull: null },
-			{ name: 'Jill', id1: 4, updateCounter: 1, alwaysNull: null },
-		]);
-		// const msDelay = 500;
-
-		// for (const eachUser of justDates) {
-		// 	expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-		// }
-	});
-
-	test('test if method with sql operators', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = gelTable('users_with_age', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-			age: integer('age').notNull(),
-			city: text('city').notNull(),
-		});
-
-		await db.insert(users).values([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition1 = true;
-
-		const [result1] = await db.select().from(users).where(eq(users.id1, 1).if(condition1));
-
-		expect({ ...result1, id: undefined }).toEqual({
-			id1: 1,
-			name: 'John',
-			age: 20,
-			city: 'New York',
-		});
-
-		const condition2 = 1;
-
-		const [result2] = await db
-			.select()
-			.from(users)
-			.where(sql`${users.id1} = 1`.if(condition2));
-
-		expect({ ...result2, id: undefined }).toEqual({ id1: 1, name: 'John', age: 20, city: 'New York' });
-
-		const condition3 = 'non-empty string';
-
-		const result3 = await db
-			.select()
-			.from(users)
-			.where(or(eq(users.id1, 1).if(condition3), eq(users.id1, 2).if(condition3)));
-
-		expect(result3.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{
-				id1: 2,
-				name: 'Alice',
-				age: 21,
-				city: 'New York',
-			},
-		]);
-
-		const condtition4 = false;
-
-		const result4 = await db.select().from(users).where(eq(users.id1, 1).if(condtition4));
-
-		expect(result4.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition5 = undefined;
-
-		const result5 = await db
-			.select()
-			.from(users)
-			.where(sql`${users.id1} = 1`.if(condition5));
-
-		expect(result5.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition6 = null;
-
-		const result6 = await db
-			.select()
-			.from(users)
-			.where(or(eq(users.id1, 1).if(condition6), eq(users.id1, 2).if(condition6)));
-
-		expect(result6.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition7 = {
-			term1: 0,
-			term2: 1,
-		};
-
-		const result7 = await db
-			.select()
-			.from(users)
-			.where(and(gt(users.age, 20).if(condition7.term1), eq(users.city, 'New York').if(condition7.term2)));
-
-		expect(result7.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-		]);
-
-		const condition8 = {
-			term1: '',
-			term2: 'non-empty string',
-		};
-
-		const result8 = await db
-			.select()
-			.from(users)
-			.where(or(lt(users.age, 21).if(condition8.term1), eq(users.city, 'London').if(condition8.term2)));
-
-		expect(result8.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition9 = {
-			term1: 1,
-			term2: true,
-		};
-
-		const result9 = await db
-			.select()
-			.from(users)
-			.where(
-				and(
-					inArray(users.city, ['New York', 'London']).if(condition9.term1),
-					ilike(users.name, 'a%').if(condition9.term2),
-				),
-			);
-
-		expect(result9.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{
-				id1: 2,
-				name: 'Alice',
-				age: 21,
-				city: 'New York',
-			},
-		]);
-
-		const condition10 = {
-			term1: 4,
-			term2: 19,
-		};
-
-		const result10 = await db
-			.select()
-			.from(users)
-			.where(
-				and(
-					sql`length(${users.name}) <= ${condition10.term1}`.if(condition10.term1),
-					gt(users.age, condition10.term2).if(condition10.term2 > 20),
-				),
-			);
-
-		expect(result10.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition11 = true;
-
-		const result11 = await db
-			.select()
-			.from(users)
-			.where(or(eq(users.city, 'New York'), gte(users.age, 22))!.if(condition11));
-
-		expect(result11.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition12 = false;
-
-		const result12 = await db
-			.select()
-			.from(users)
-			.where(and(eq(users.city, 'London'), gte(users.age, 23))!.if(condition12));
-
-		expect(result12.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition13 = true;
-
-		const result13 = await db
-			.select()
-			.from(users)
-			.where(sql`(city = 'New York' or age >= 22)`.if(condition13));
-
-		expect(result13.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-
-		const condition14 = false;
-
-		const result14 = await db
-			.select()
-			.from(users)
-			.where(sql`(city = 'London' and age >= 23)`.if(condition14));
-
-		expect(result14.map((it) => ({ ...it, id: undefined }))).toEqual([
-			{ id1: 1, name: 'John', age: 20, city: 'New York' },
-			{ id1: 2, name: 'Alice', age: 21, city: 'New York' },
-			{ id1: 3, name: 'Nick', age: 22, city: 'London' },
-			{ id1: 4, name: 'Lina', age: 23, city: 'London' },
-		]);
-	});
-
-	// MySchema tests
-	test('mySchema :: select all fields', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const now = Date.now();
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const result = await db.select().from(usersMySchemaTable);
-
-		expect(result[0]!.createdAt).toBeInstanceOf(Date);
-		expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(500);
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				verified: false,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('mySchema :: select sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.select({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			})
-			.from(usersMySchemaTable);
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('mySchema :: select typed sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.select({
-				name: sql<string>`upper(${usersMySchemaTable.name})`,
-			})
-			.from(usersMySchemaTable);
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('mySchema :: select distinct', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'John' },
-			{ id1: 1, name: 'Jane' },
-		]);
-		const users1 = await db.selectDistinct().from(usersMySchemaTable).orderBy(
-			usersMySchemaTable.id1,
-			usersMySchemaTable.name,
-		);
-		const users2 = await db.selectDistinctOn([usersMySchemaTable.id1]).from(usersMySchemaTable).orderBy(
-			usersMySchemaTable.id1,
-		);
-		const users3 = await db.selectDistinctOn([usersMySchemaTable.name], { name: usersMySchemaTable.name }).from(
-			usersMySchemaTable,
-		).orderBy(usersMySchemaTable.name);
-
-		expect(users1.map((it) => ({ ...it, id: undefined, createdAt: undefined }))).toEqual([
-			{ id1: 1, name: 'Jane', id: undefined, verified: false, json: null, createdAt: undefined },
-			{ id1: 1, name: 'John', id: undefined, verified: false, json: null, createdAt: undefined },
-			{ id1: 2, name: 'John', id: undefined, verified: false, json: null, createdAt: undefined },
-		]);
-
-		expect(users2).toHaveLength(2);
-		expect(users2[0]?.id1).toBe(1);
-		expect(users2[1]?.id1).toBe(2);
-
-		expect(users3).toHaveLength(2);
-		expect(users3[0]?.name).toBe('Jane');
-		expect(users3[1]?.name).toBe('John');
-	});
-
-	test('mySchema :: insert returning sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users = await db
-			.insert(usersMySchemaTable)
-			.values({ id1: 1, name: 'John' })
-			.returning({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			});
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('mySchema :: delete returning sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const users = await db
-			.delete(usersMySchemaTable)
-			.where(eq(usersMySchemaTable.name, 'John'))
-			.returning({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			});
-
-		expect(users).toEqual([{ name: 'JOHN' }]);
-	});
-
-	test('mySchema :: update with returning partial', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const users = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(
-			eq(usersMySchemaTable.name, 'John'),
-		)
-			.returning({
-				id1: usersMySchemaTable.id1,
-				name: usersMySchemaTable.name,
-			});
-
-		expect(users).toEqual([{ id1: 1, name: 'Jane' }]);
-	});
-
-	test('mySchema :: delete with returning all fields', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const now = Date.now();
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John')).returning();
-
-		expect(users[0]!.createdAt).toBeInstanceOf(Date);
-		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(500);
-		expect(users).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				verified: false,
-				json: null,
-				createdAt: users[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('mySchema :: insert + select', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const result = await db.select().from(usersMySchemaTable);
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				verified: false,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-
-		await db.insert(usersMySchemaTable).values({ id1: 2, name: 'Jane' });
-		const result2 = await db.select().from(usersMySchemaTable);
-		expect(result2).toEqual([
-			{ id1: 1, name: 'John', verified: false, json: null, createdAt: result2[0]!.createdAt },
-			{ id1: 2, name: 'Jane', verified: false, json: null, createdAt: result2[1]!.createdAt },
-		]);
-	});
-
-	test('mySchema :: insert with overridden default values', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John', verified: true });
-		const result = await db.select().from(usersMySchemaTable);
-
-		expect(result).toEqual([
-			{
-				id1: 1,
-				name: 'John',
-				verified: true,
-				json: null,
-				createdAt: result[0]!.createdAt,
-			},
-		]);
-	});
-
-	test('mySchema :: insert many', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values([
-			{ id1: 1, name: 'John' },
-			{
-				id1: 2,
-				name: 'Bruce',
-				json: ['foo', 'bar'],
-			},
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-			{ id1: 4, name: 'Austin', verified: true },
-		]);
-		const result = await db
-			.select({
-				id1: usersMySchemaTable.id1,
-				name: usersMySchemaTable.name,
-				json: usersMySchemaTable.json,
-				verified: usersMySchemaTable.verified,
-			})
-			.from(usersMySchemaTable);
-
-		expect(result).toEqual([
-			{ id1: 1, name: 'John', json: null, verified: false },
-			{ id1: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
-			{ id1: 3, name: 'Jane', json: null, verified: false },
-			{ id1: 4, name: 'Austin', json: null, verified: true },
-		]);
-	});
-
-	test('mySchema :: select with group by as field', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable).groupBy(
-			usersMySchemaTable.name,
-		);
-
-		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-	});
-
-	test('mySchema :: select with group by as column + sql', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values([
-			{ id1: 1, name: 'John' },
-			{ id1: 2, name: 'Jane' },
-			{
-				id1: 3,
-				name: 'Jane',
-			},
-		]);
-
-		const result = await db
-			.select({ name: usersMySchemaTable.name })
-			.from(usersMySchemaTable)
-			.groupBy(usersMySchemaTable.id1, sql`${usersMySchemaTable.name}`);
-
-		expect(result.sort((a, b) => a.name.localeCompare(b.name))).toEqual([
-			{ name: 'Jane' },
-			{ name: 'Jane' },
-			{
-				name: 'John',
-			},
-		]);
-	});
-
-	test('mySchema :: build query', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db.select({ id1: usersMySchemaTable.id1, name: usersMySchemaTable.name }).from(usersMySchemaTable)
-			.groupBy(usersMySchemaTable.id1, usersMySchemaTable.name).toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'select "mySchema"."users"."id1", "mySchema"."users"."name" from "mySchema"."users" group by "mySchema"."users"."id1", "mySchema"."users"."name"',
-			params: [],
-		});
-	});
-
-	test('mySchema :: partial join with alias', async (ctx) => {
-		const { db } = ctx.gel;
-		const customerAlias = alias(usersMySchemaTable, 'customer');
-
-		await db.insert(usersMySchemaTable).values([
-			{ id1: 10, name: 'Ivan' },
-			{ id1: 11, name: 'Hans' },
-		]);
-		const result = await db
-			.select({
-				user: {
-					id1: usersMySchemaTable.id1,
-					name: usersMySchemaTable.name,
-				},
-				customer: {
-					id1: customerAlias.id1,
-					name: customerAlias.name,
-				},
-			})
-			.from(usersMySchemaTable)
-			.leftJoin(customerAlias, eq(customerAlias.id1, 11))
-			.where(eq(usersMySchemaTable.id1, 10));
-
-		expect(result).toEqual([
-			{
-				user: { id1: 10, name: 'Ivan' },
-				customer: { id1: 11, name: 'Hans' },
-			},
-		]);
-	});
-
-	test('mySchema :: insert with spaces', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: sql`'Jo   h     n'` });
-		const result = await db.select({ id1: usersMySchemaTable.id1, name: usersMySchemaTable.name }).from(
-			usersMySchemaTable,
-		);
-
-		expect(result).toEqual([{ id1: 1, name: 'Jo   h     n' }]);
-	});
-
-	test('mySchema :: prepared statement with placeholder in .limit', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 1, name: 'John' });
-		const stmt = db
-			.select({
-				id1: usersMySchemaTable.id1,
-				name: usersMySchemaTable.name,
-			})
-			.from(usersMySchemaTable)
-			.where(eq(usersMySchemaTable.id1, sql.placeholder('id1')))
-			.limit(sql.placeholder('limit'))
-			.prepare('mySchema_stmt_limit');
-
-		const result = await stmt.execute({ id1: 1, limit: 1 });
-
-		expect(result.map((it) => ({ ...it, id: undefined }))).toEqual([{ id1: 1, name: 'John' }]);
-		expect(result).toHaveLength(1);
-	});
-
-	// TODO on conflict does not supported in gel
-	test.todo('mySchema :: build query insert with onConflict do update / multiple columns', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersMySchemaTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoUpdate({ target: [usersMySchemaTable.id1, usersMySchemaTable.name], set: { name: 'John1' } })
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "mySchema"."users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, $3, default) on conflict ("id1","name") do update set "name" = $4',
-			params: [1, 'John', ['foo', 'bar'], 'John1'],
-		});
-	});
-
-	// TODO on conflict not supported in gel
-	test.todo('mySchema :: build query insert with onConflict do nothing + target', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const query = db
-			.insert(usersMySchemaTable)
-			.values({ id1: 1, name: 'John', json: ['foo', 'bar'] })
-			// .onConflictDoNothing({ target: usersMySchemaTable.id1 })
-			.toSQL();
-
-		expect(query).toEqual({
-			sql:
-				'insert into "mySchema"."users" ("id1", "name", "verified", "json", "created_at") values ($1, $2, default, $3, default) on conflict ("id1") do nothing',
-			params: [1, 'John', ['foo', 'bar']],
-		});
-	});
-
-	test('mySchema :: select from tables with same name from different schema using alias', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersMySchemaTable).values({ id1: 10, name: 'Ivan' });
-		await db.insert(usersTable).values({ id1: 11, name: 'Hans' });
-
-		const customerAlias = alias(usersTable, 'customer');
-
-		const result = await db.select().from(usersMySchemaTable).leftJoin(customerAlias, eq(customerAlias.id1, 11))
-			.where(eq(customerAlias.id1, 11));
-
-		expect(result).toEqual([
-			{
-				users: {
-					id1: 10,
-					name: 'Ivan',
-					verified: false,
-					json: null,
-					createdAt: result[0]!.users.createdAt,
-				},
-				customer: {
-					id1: 11,
-					name: 'Hans',
-					verified: false,
-					json: null,
-					createdAt: result[0]!.customer!.createdAt,
-				},
-			},
-		]);
-	});
-
-	test('limit 0', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-		const users = await db.select().from(usersTable).limit(0);
-
-		expect(users).toEqual([]);
-	});
-
-	test('limit -1', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(usersTable).values({ id1: 2, name: 'John' });
-		const users = await db.select().from(usersTable).limit(-1);
-
-		expect(users.length).toBeGreaterThan(0);
-	});
-
-	test('Object keys as column names', async (ctx) => {
-		const { db } = ctx.gel;
-
-		// Tests the following:
-		// Column with required config
-		// Column with optional config without providing a value
-		// Column with optional config providing a value
-		// Column without config
-		const users = gelTable('users_with_names', {
-			id1: integer().notNull(),
-			firstName: text(),
-			lastName: text(),
-			admin: boolean(),
-		});
-
-		await db.insert(users).values([
-			{ id1: 1, firstName: 'John', lastName: 'Doe', admin: true },
-			{ id1: 2, firstName: 'Jane', lastName: 'Smith', admin: false },
-		]);
-		const result = await db.select({ id1: users.id1, firstName: users.firstName, lastName: users.lastName }).from(
-			users,
-		).where(eq(users.admin, true));
-
-		expect(result).toEqual([{ id1: 1, firstName: 'John', lastName: 'Doe' }]);
-	});
-
-	test('proper json handling', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const jsonTable = gelTable('json_table', {
-			json: json('json').$type<{ name: string; age: number }>(),
-		});
-
-		await db.insert(jsonTable).values({ json: { name: 'Tom', age: 75 } });
-
-		const result = await db.select().from(jsonTable);
-
-		const justNames = await db
-			.select({
-				name1: sql<string>`${jsonTable.json}->>'name'`.as('name1'),
-				name2: sql<string>`${jsonTable.json}->>'name'`.as('name2'),
-			})
-			.from(jsonTable);
-
-		expect(result).toStrictEqual([
-			{
-				json: { name: 'Tom', age: 75 },
-			},
-		]);
-
-		expect(justNames).toStrictEqual([
-			{
-				name1: 'Tom',
-				name2: 'Tom',
-			},
-		]);
-	});
-
-	test('set json fields with objects and retrieve with the ->> operator', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const obj = { string: 'test', number: 123 };
-		const { string: testString, number: testNumber } = obj;
-
-		await db.insert(jsonTestTable).values({
-			id1: 1,
-			json: obj,
-		});
-
-		const result = await db
-			.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->>'string'`,
-				jsonNumberField: sql<string>`${jsonTestTable.json}->>'number'`,
-			})
-			.from(jsonTestTable);
-
-		expect(result).toStrictEqual([
-			{
-				jsonStringField: testString,
-				jsonNumberField: String(testNumber),
-			},
-		]);
-	});
-
-	test('set json fields with objects and retrieve with the -> operator', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const obj = { string: 'test', number: 123 };
-		const { string: testString, number: testNumber } = obj;
-
-		await db.insert(jsonTestTable).values({ id1: 1, json: obj });
-
-		const result = await db
-			.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
-				jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
-			})
-			.from(jsonTestTable);
-
-		expect(result).toStrictEqual([
-			{
-				jsonStringField: testString,
-				jsonNumberField: testNumber,
-			},
-		]);
-	});
-
-	test('set json fields with strings and retrieve with the -> operator', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const obj = { string: 'test', number: 123 };
-		const { string: testString, number: testNumber } = obj;
-
-		await db.insert(jsonTestTable).values({
-			id1: 1,
-			json: sql`${obj}`,
-		});
-
-		const result = await db
-			.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
-				jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
-			})
-			.from(jsonTestTable);
-
-		expect(result).toStrictEqual([
-			{
-				jsonStringField: testString,
-				jsonNumberField: testNumber,
-			},
-		]);
-	});
-
-	test('cross join', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db
-			.insert(usersTable)
-			.values([
-				{ id1: 1, name: 'John' },
-				{ id1: 2, name: 'Jane' },
-			]);
-
-		await db
-			.insert(citiesTable)
-			.values([
-				{ id1: 1, name: 'Seattle' },
-				{ id1: 2, name: 'New York City' },
-			]);
-
-		const result = await db
-			.select({
-				user: usersTable.name,
-				city: citiesTable.name,
-			})
-			.from(usersTable)
-			.crossJoin(citiesTable)
-			.orderBy(usersTable.name, citiesTable.name);
-
-		expect(result).toStrictEqual([
-			{ city: 'New York City', user: 'Jane' },
-			{ city: 'Seattle', user: 'Jane' },
-			{ city: 'New York City', user: 'John' },
-			{ city: 'Seattle', user: 'John' },
-		]);
-	});
-
-	test('left join (lateral)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db
-			.insert(citiesTable)
-			.values([{ id1: 1, name: 'Paris' }, { id1: 2, name: 'London' }])
-			.returning({ id: citiesTable.id1 });
-
-		await db.insert(users2Table).values([{ id1: 1, name: 'John', cityId: 1 }, { id1: 2, name: 'Jane' }]);
-
-		const sq = db
-			.select({
-				userId: users2Table.id1,
-				userName: users2Table.name,
-				cityId: users2Table.cityId,
-			})
-			.from(users2Table)
-			.where(eq(users2Table.cityId, citiesTable.id1))
-			.as('sq');
-
-		const res = await db
-			.select({
-				cityId: citiesTable.id1,
-				cityName: citiesTable.name,
-				userId: sq.userId,
-				userName: sq.userName,
-			})
-			.from(citiesTable)
-			.leftJoinLateral(sq, sql`true`);
-
-		expect(res).toStrictEqual([
-			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-			{ cityId: 2, cityName: 'London', userId: null, userName: null },
-		]);
-	});
-
-	test('inner join (lateral)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db
-			.insert(citiesTable)
-			.values([{ id1: 1, name: 'Paris' }, { id1: 2, name: 'London' }])
-			.returning({ id: citiesTable.id1 });
-
-		await db.insert(users2Table).values([{ id1: 1, name: 'John', cityId: 1 }, { id1: 2, name: 'Jane' }]);
-
-		const sq = db
-			.select({
-				userId: users2Table.id1,
-				userName: users2Table.name,
-				cityId: users2Table.cityId,
-			})
-			.from(users2Table)
-			.where(eq(users2Table.cityId, citiesTable.id1))
-			.as('sq');
-
-		const res = await db
-			.select({
-				cityId: citiesTable.id1,
-				cityName: citiesTable.name,
-				userId: sq.userId,
-				userName: sq.userName,
-			})
-			.from(citiesTable)
-			.innerJoinLateral(sq, sql`true`);
-
-		expect(res).toStrictEqual([
-			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-		]);
-	});
-
-	test('cross join (lateral)', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db
-			.insert(citiesTable)
-			.values([{ id1: 1, name: 'Paris' }, { id1: 2, name: 'London' }, { id1: 3, name: 'Berlin' }]);
-
-		await db.insert(users2Table).values([{ id1: 1, name: 'John', cityId: 1 }, { id1: 2, name: 'Jane' }, {
-			id1: 3,
-			name: 'Patrick',
-			cityId: 2,
-		}]);
-
-		const sq = db
-			.select({
-				userId: users2Table.id1,
-				userName: users2Table.name,
-				cityId: users2Table.cityId,
-			})
-			.from(users2Table)
-			.where(not(like(citiesTable.name, 'L%')))
-			.as('sq');
-
-		const res = await db
-			.select({
-				cityId: citiesTable.id1,
-				cityName: citiesTable.name,
-				userId: sq.userId,
-				userName: sq.userName,
-			})
-			.from(citiesTable)
-			.crossJoinLateral(sq)
-			.orderBy(citiesTable.id1, sq.userId);
-
-		expect(res).toStrictEqual([
-			{
-				cityId: 1,
-				cityName: 'Paris',
-				userId: 1,
-				userName: 'John',
-			},
-			{
-				cityId: 1,
-				cityName: 'Paris',
-				userId: 2,
-				userName: 'Jane',
-			},
-			{
-				cityId: 1,
-				cityName: 'Paris',
-				userId: 3,
-				userName: 'Patrick',
-			},
-			{
-				cityId: 3,
-				cityName: 'Berlin',
-				userId: 1,
-				userName: 'John',
-			},
-			{
-				cityId: 3,
-				cityName: 'Berlin',
-				userId: 2,
-				userName: 'Jane',
-			},
-			{
-				cityId: 3,
-				cityName: 'Berlin',
-				userId: 3,
-				userName: 'Patrick',
-			},
-		]);
-	});
-
-	// TODO not supported yet
-	test.todo('update ... from', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(cities2Table).values([
-			{ id1: 1, name: 'New York City' },
-			{ id1: 2, name: 'Seattle' },
-		]);
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId: 1 },
-			{ id1: 2, name: 'Jane', cityId: 2 },
-		]);
-		const result = await db
-			.update(users2Table)
-			.set({
-				cityId: cities2Table.id1,
-			})
-			.from(cities2Table)
-			.where(and(eq(cities2Table.name, 'Seattle'), eq(users2Table.name, 'John')))
-			.returning();
-
-		expect(result).toStrictEqual([
-			{
-				id1: 1,
-				name: 'John',
-				cityId: 2,
-				cities: {
-					id1: 2,
-					name: 'Seattle',
-				},
-			},
-		]);
-	});
-
-	// TODO not supported yet
-	test.todo('update ... from with alias', async (ctx) => {
-		const { db } = ctx.gel;
-
-		await db.insert(cities2Table).values([
-			{ id1: 1, name: 'New York City' },
-			{ id1: 2, name: 'Seattle' },
-		]);
-		await db.insert(users2Table).values([
-			{ id1: 1, name: 'John', cityId: 1 },
-			{ id1: 2, name: 'Jane', cityId: 2 },
-		]);
-
-		const users = alias(users2Table, 'u');
-		const cities = alias(cities2Table, 'c');
-		const result = await db
-			.update(users)
-			.set({
-				cityId: cities.id1,
-			})
-			.from(cities)
-			.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
-			.returning();
-
-		expect(result).toStrictEqual([
-			{
-				id1: 1,
-				name: 'John',
-				cityId: 2,
-				c: {
-					id1: 2,
-					name: 'Seattle',
-				},
-			},
-		]);
-	});
-
-	// TODO not supported yet
-	// test.todo('update ... from with join', async (ctx) => {
-	// 	const { db } = ctx.gel;
-
-	// 	const states = gelTable('states', {
-	// 		id1: integer('id1').primaryKey(),
-	// 		name: text('name').notNull(),
-	// 	});
-	// 	const cities = gelTable('cities', {
-	// 		id1: integer('id1').primaryKey(),
-	// 		name: text('name').notNull(),
-	// 		stateId: integer('state_id').references(() => states.id1),
-	// 	});
-	// 	const users = gelTable('users', {
-	// 		id1: integer('id1').primaryKey(),
-	// 		name: text('name').notNull(),
-	// 		cityId: integer('city_id')
-	// 			.notNull()
-	// 			.references(() => cities.id1),
-	// 	});
-
-	// 	await db.execute(sql`drop table if exists "states" cascade`);
-	// 	await db.execute(sql`drop table if exists "cities" cascade`);
-	// 	await db.execute(sql`drop table if exists "users" cascade`);
-	// 	await db.execute(sql`
-	//             create table "states" (
-	//                 "id" serial primary key,
-	//                 "name" text not null
-	//             )
-	//         `);
-	// 	await db.execute(sql`
-	//             create table "cities" (
-	//                 "id" serial primary key,
-	//                 "name" text not null,
-	//                 "state_id" integer references "states"("id")
-	//             )
-	//         `);
-	// 	await db.execute(sql`
-	//             create table "users" (
-	//                 "id" serial primary key,
-	//                 "name" text not null,
-	//                 "city_id" integer not null references "cities"("id")
-	//             )
-	//         `);
-
-	// 	await db.insert(states).values([{ id1: 1, name: 'New York' }, { id1: 2, name: 'Washington' }]);
-	// 	await db.insert(cities).values([
-	// 		{ id1: 1, name: 'New York City', stateId: 1 },
-	// 		{ id1: 2, name: 'Seattle', stateId: 2 },
-	// 		{
-	// 			id1: 2,
-	// 			name: 'London',
-	// 		},
-	// 	]);
-	// 	await db.insert(users).values([
-	// 		{ id1: 1, name: 'John', cityId: 1 },
-	// 		{ id1: 2, name: 'Jane', cityId: 2 },
-	// 		{ id1: 3, name: 'Jack', cityId: 3 },
-	// 	]);
-
-	// 	const result1 = await db
-	// 		.update(users)
-	// 		.set({
-	// 			cityId: cities.id1,
-	// 		})
-	// 		.from(cities)
-	// 		.leftJoin(states, eq(cities.stateId, states.id1))
-	// 		.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
-	// 		.returning();
-	// 	const result2 = await db
-	// 		.update(users)
-	// 		.set({
-	// 			cityId: cities.id1,
-	// 		})
-	// 		.from(cities)
-	// 		.leftJoin(states, eq(cities.stateId, states.id1))
-	// 		.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
-	// 		.returning();
-
-	// 	expect(result1).toStrictEqual([
-	// 		{
-	// 			id: 1,
-	// 			name: 'John',
-	// 			cityId: 2,
-	// 			cities: {
-	// 				id: 2,
-	// 				name: 'Seattle',
-	// 				stateId: 2,
-	// 			},
-	// 			states: {
-	// 				id: 2,
-	// 				name: 'Washington',
-	// 			},
-	// 		},
-	// 	]);
-	// 	expect(result2).toStrictEqual([
-	// 		{
-	// 			id: 3,
-	// 			name: 'Jack',
-	// 			cityId: 3,
-	// 			cities: {
-	// 				id: 3,
-	// 				name: 'London',
-	// 				stateId: null,
-	// 			},
-	// 			states: null,
-	// 		},
-	// 	]);
-	// });
-
-	test('insert into ... select', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const notifications = gelTable('notifications', {
-			id1: integer('id1').notNull(),
-			sentAt: timestamp('sentAt').notNull().defaultNow(),
-			message: text('message').notNull(),
-		});
-		const users = gelTable('users_insert_select', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-		const userNotications = gelTable('user_notifications', {
-			userId: integer('userId').notNull(),
-			notificationId: integer('notificationId').notNull(),
-		});
-
-		const newNotification = await db
-			.insert(notifications)
-			.values({ id1: 1, message: 'You are one of the 3 lucky winners!' })
-			.returning({ id1: notifications.id1 })
-			.then((result) => result[0]);
-		await db.insert(users).values([
-			{ id1: 1, name: 'Alice' },
-			{ id1: 2, name: 'Bob' },
-			{ id1: 3, name: 'Charlie' },
-			{
-				id1: 4,
-				name: 'David',
-			},
-			{
-				id1: 5,
-				name: 'Eve',
-			},
-		]);
-
-		const sentNotifications = await db
-			.insert(userNotications)
-			.select(
-				db
-					.select({
-						userId: users.id1,
-						notificationId: sql`${newNotification!.id1}`.as('notification_id'),
-					})
-					.from(users)
-					.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
-					.orderBy(asc(users.id1)),
-			)
-			.returning();
-
-		expect(sentNotifications).toStrictEqual([
-			{ userId: 1, notificationId: newNotification!.id1 },
-			{ userId: 3, notificationId: newNotification!.id1 },
-			{ userId: 5, notificationId: newNotification!.id1 },
-		]);
-	});
-
-	test('insert into ... select with keys in different order', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const users1 = gelTable('users1', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-		const users2 = gelTable('users2', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		expect(() =>
-			db.insert(users1).select(
-				db
-					.select({
-						name: users2.name,
-						id1: users2.id1,
-					})
-					.from(users2),
-			)
-		).toThrowError();
-	});
-
-	test('policy', () => {
-		{
-			const policy = gelPolicy('test policy');
-
-			expect(is(policy, GelPolicy)).toBe(true);
-			expect(policy.name).toBe('test policy');
-		}
-
-		{
-			const policy = gelPolicy('test policy', {
-				as: 'permissive',
-				for: 'all',
-				to: 'public',
-				using: sql`1=1`,
-				withCheck: sql`1=1`,
-			});
-
-			expect(is(policy, GelPolicy)).toBe(true);
-			expect(policy.name).toBe('test policy');
-			expect(policy.as).toBe('permissive');
-			expect(policy.for).toBe('all');
-			expect(policy.to).toBe('public');
-			const dialect = new GelDialect();
-			expect(is(policy.using, SQL)).toBe(true);
-			expect(dialect.sqlToQuery(policy.using!).sql).toBe('1=1');
-			expect(is(policy.withCheck, SQL)).toBe(true);
-			expect(dialect.sqlToQuery(policy.withCheck!).sql).toBe('1=1');
-		}
-
-		{
-			const policy = gelPolicy('test policy', {
-				to: 'custom value',
-			});
-
-			expect(policy.to).toBe('custom value');
-		}
-
-		{
-			const p1 = gelPolicy('test policy');
-			const p2 = gelPolicy('test policy 2', {
-				as: 'permissive',
-				for: 'all',
-				to: 'public',
-				using: sql`1=1`,
-				withCheck: sql`1=1`,
-			});
-			const table = gelTable(
-				'table_with_policy',
-				{
-					id: integer('id').primaryKey(),
-					name: text('name').notNull(),
-				},
-				() => ({
-					p1,
-					p2,
-				}),
-			);
-			const config = getTableConfig(table);
-			expect(config.policies).toHaveLength(2);
-			expect(config.policies[0]).toBe(p1);
-			expect(config.policies[1]).toBe(p2);
-		}
-	});
-
-	test('Enable RLS function', () => {
-		const usersWithRLS = gelTable('users', {
-			id: integer(),
-		}).enableRLS();
-
-		const config1 = getTableConfig(usersWithRLS);
-
-		const usersNoRLS = gelTable('users', {
-			id: integer(),
-		});
-
-		const config2 = getTableConfig(usersNoRLS);
-
-		expect(config1.enableRLS).toBeTruthy();
-		expect(config2.enableRLS).toBeFalsy();
-	});
-
-	test('$count separate', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = await db.$count(countTestTable);
-
-		expect(count).toStrictEqual(4);
-	});
-
-	test('$count embedded', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = await db
-			.select({
-				count: db.$count(countTestTable),
-			})
-			.from(countTestTable);
-
-		expect(count).toStrictEqual([{ count: 4 }, { count: 4 }, { count: 4 }, { count: 4 }]);
-	});
-
-	test('$count separate reuse', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = db.$count(countTestTable);
-
-		const count1 = await count;
-
-		await db.insert(countTestTable).values({ id1: 5, name: 'fifth' });
-
-		const count2 = await count;
-
-		await db.insert(countTestTable).values({ id1: 6, name: 'sixth' });
-
-		const count3 = await count;
-
-		expect(count1).toStrictEqual(4);
-		expect(count2).toStrictEqual(5);
-		expect(count3).toStrictEqual(6);
-	});
-
-	test('$count embedded reuse', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = db
-			.select({
-				count: db.$count(countTestTable),
-			})
-			.from(countTestTable);
-
-		const count1 = await count;
-
-		await db.insert(countTestTable).values({ id1: 5, name: 'fifth' });
-
-		const count2 = await count;
-
-		await db.insert(countTestTable).values({ id1: 6, name: 'sixth' });
-
-		const count3 = await count;
-
-		expect(count1).toStrictEqual([{ count: 4 }, { count: 4 }, { count: 4 }, { count: 4 }]);
-		expect(count2).toStrictEqual([{ count: 5 }, { count: 5 }, { count: 5 }, { count: 5 }, { count: 5 }]);
-		expect(count3).toStrictEqual([
-			{ count: 6 },
-			{ count: 6 },
-			{ count: 6 },
-			{ count: 6 },
-			{ count: 6 },
-			{
-				count: 6,
-			},
-		]);
-	});
-
-	test('$count separate with filters', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = await db.$count(countTestTable, gt(countTestTable.id1, 1));
-
-		expect(count).toStrictEqual(3);
-	});
-
-	test('$count embedded with filters', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const countTestTable = gelTable('count_test', {
-			id1: integer('id1').notNull(),
-			name: text('name').notNull(),
-		});
-
-		await db.insert(countTestTable).values([
-			{ id1: 1, name: 'First' },
-			{ id1: 2, name: 'Second' },
-			{ id1: 3, name: 'Third' },
-			{ id1: 4, name: 'Fourth' },
-		]);
-
-		const count = await db
-			.select({
-				count: db.$count(countTestTable, gt(countTestTable.id1, 1)),
-			})
-			.from(countTestTable);
-
-		expect(count).toStrictEqual([{ count: 3 }, { count: 3 }, { count: 3 }, { count: 3 }]);
-	});
-
-	// TODO
-	test.todo('insert multiple rows into table with generated identity column', async (ctx) => {
-		const { db } = ctx.gel;
-
-		const identityColumnsTable = gelTable('identity_columns_table', {
-			id: integer('id').generatedAlwaysAsIdentity(),
-			id1: integer('id1').generatedByDefaultAsIdentity(),
-			name: text('name').notNull(),
-		});
-
-		// not passing identity columns
-		await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-		await db.execute(
-			sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-		);
-
-		let result = await db
-			.insert(identityColumnsTable)
-			.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Bob' }])
-			.returning();
-
-		expect(result).toEqual([
-			{ id: 1, id1: 1, name: 'John' },
-			{ id: 2, id1: 2, name: 'Jane' },
-			{ id: 3, id1: 3, name: 'Bob' },
-		]);
-
-		// passing generated by default as identity column
-		await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-		await db.execute(
-			sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-		);
-
-		result = await db
-			.insert(identityColumnsTable)
-			.values([
-				{ name: 'John', id1: 3 },
-				{ name: 'Jane', id1: 5 },
-				{ name: 'Bob', id1: 5 },
-			])
-			.returning();
-
-		expect(result).toEqual([
-			{ id: 1, id1: 3, name: 'John' },
-			{ id: 2, id1: 5, name: 'Jane' },
-			{ id: 3, id1: 5, name: 'Bob' },
-		]);
-
-		// passing all identity columns
-		await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-		await db.execute(
-			sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-		);
-
-		result = await db
-			.insert(identityColumnsTable)
-			.overridingSystemValue()
-			.values([
-				{ name: 'John', id: 2, id1: 3 },
-				{ name: 'Jane', id: 4, id1: 5 },
-				{ name: 'Bob', id: 4, id1: 5 },
-			])
-			.returning();
-
-		expect(result).toEqual([
-			{ id: 2, id1: 3, name: 'John' },
-			{ id: 4, id1: 5, name: 'Jane' },
-			{ id: 4, id1: 5, name: 'Bob' },
-		]);
-	});
-
-	test('insert via db.execute + select via db.execute', async (ctx) => {
-		const { db } = ctx.gel;
-		await db.execute(
-			sql`insert into ${usersTable} (${sql.identifier(usersTable.id1.name)},${
-				sql.identifier(usersTable.name.name)
-			}) values (1, ${'John'})`,
-		);
-
-		const result = await db.execute<{ id1: number; name: string }>(
-			sql`select id1, name from "users"`,
-		);
-		expect(result).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('insert via db.execute + returning', async (ctx) => {
-		const { db } = ctx.gel;
-		const inserted = await db.execute<{ id1: number; name: string }>(
-			sql`insert into ${usersTable} (${
-				sql.identifier(
-					usersTable.id1.name,
-				)
-			}, ${
-				sql.identifier(
-					usersTable.name.name,
-				)
-			}) values (1, ${'John'}) returning ${usersTable.id1}, ${usersTable.name}`,
-		);
-		expect(inserted).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('insert via db.execute w/ query builder', async (ctx) => {
-		const { db } = ctx.gel;
-		const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id1' | 'name'>>(
-			db
-				.insert(usersTable)
-				.values({ id1: 1, name: 'John' })
-				.returning({ id1: usersTable.id1, name: usersTable.name }),
-		);
-		expect(inserted).toEqual([{ id1: 1, name: 'John' }]);
-	});
-
-	test('test force invalidate', async (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		const spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
-		await db.$cache?.invalidate({ tables: 'users' });
-		expect(spyInvalidate).toHaveBeenCalledTimes(1);
-	});
-
-	test('default global config - no cache should be hit', async (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable);
-
-		expect(spyPut).toHaveBeenCalledTimes(0);
-		expect(spyGet).toHaveBeenCalledTimes(0);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-	});
-
-	test('default global config + enable cache on select: get, put', async (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache();
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-	});
-
-	test('default global config + enable cache on select + write: get, put, onMutate', async (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-		spyPut.mockClear();
-		spyGet.mockClear();
-		spyInvalidate.mockClear();
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		expect(spyPut).toHaveBeenCalledTimes(0);
-		expect(spyGet).toHaveBeenCalledTimes(0);
-		expect(spyInvalidate).toHaveBeenCalledTimes(1);
-	});
-
-	test('default global config + enable cache on select + disable invalidate: get, put', async (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		// invalidate force
-		await db.$cache?.invalidate({ tags: ['custom'] });
-	});
-
-	test('global: true + disable cache', async (ctx) => {
-		const { dbGlobalCached: db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache(false);
-
-		expect(spyPut).toHaveBeenCalledTimes(0);
-		expect(spyGet).toHaveBeenCalledTimes(0);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-	});
-
-	test('global: true - cache should be hit', async (ctx) => {
-		const { dbGlobalCached: db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable);
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-	});
-
-	test('global: true - cache: false on select - no cache hit', async (ctx) => {
-		const { dbGlobalCached: db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache(false);
-
-		expect(spyPut).toHaveBeenCalledTimes(0);
-		expect(spyGet).toHaveBeenCalledTimes(0);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-	});
-
-	test('global: true - disable invalidate - cache hit + no invalidate', async (ctx) => {
-		const { dbGlobalCached: db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache({ autoInvalidate: false });
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-		spyPut.mockClear();
-		spyGet.mockClear();
-		spyInvalidate.mockClear();
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		expect(spyPut).toHaveBeenCalledTimes(0);
-		expect(spyGet).toHaveBeenCalledTimes(0);
-		expect(spyInvalidate).toHaveBeenCalledTimes(1);
-	});
-
-	test('global: true - with custom tag', async (ctx) => {
-		const { dbGlobalCached: db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		const spyPut = vi.spyOn(db.$cache, 'put');
-		// @ts-expect-error
-		const spyGet = vi.spyOn(db.$cache, 'get');
-		// @ts-expect-error
-		const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-		await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
-
-		expect(spyPut).toHaveBeenCalledTimes(1);
-		expect(spyGet).toHaveBeenCalledTimes(1);
-		expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-		await db.insert(usersTable).values({ id1: 1, name: 'John' });
-
-		// invalidate force
-		await db.$cache?.invalidate({ tags: ['custom'] });
-	});
-
-	// check select used tables
-	test('check simple select used tables', (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
-		// @ts-expect-error
-		expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
-	});
-	// check select+join used tables
-	test('select+join', (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		// @ts-expect-error
-		expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
-			.toStrictEqual(['users', 'posts']);
-		expect(
-			// @ts-expect-error
-			db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
-		).toStrictEqual(['users', 'posts']);
-	});
-	// check select+2join used tables
-	test('select+2joins', (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		expect(
-			db.select().from(usersTable).leftJoin(
-				postsTable,
-				eq(usersTable.id1, postsTable.userId),
-			).leftJoin(
-				alias(postsTable, 'post2'),
-				eq(usersTable.id1, postsTable.userId),
-			)
-				// @ts-expect-error
-				.getUsedTables(),
-		)
-			.toStrictEqual(['users', 'posts']);
-		expect(
-			db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id1, postsTable.userId)).leftJoin(
-				alias(postsTable, 'post2'),
-				eq(usersTable.id1, postsTable.userId),
-				// @ts-expect-error
-			).getUsedTables(),
-		).toStrictEqual(['users', 'posts']);
-	});
-	// select subquery used tables
-	test('select+join', (ctx) => {
-		const { db } = ctx.cachedGel;
-
-		const sq = db.select().from(usersTable).where(eq(usersTable.id1, 42)).as('sq');
-
-		// @ts-expect-error
-		expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
-	});
-});
diff --git a/integration-tests/tests/imports/index.test.ts b/integration-tests/tests/imports/index.test.ts
index be1c2eebd7..f4c75d6938 100644
--- a/integration-tests/tests/imports/index.test.ts
+++ b/integration-tests/tests/imports/index.test.ts
@@ -2,72 +2,94 @@ import { afterAll, expect, it } from 'vitest';
 import 'zx/globals';
 import * as fs from 'fs';
 import path from 'path';
-
-$.verbose = false;
+$.verbose = true;
 
 const IMPORTS_FOLDER = 'tests/imports/files';
 
 const folderPath = '../drizzle-orm/dist/package.json';
 const pj = JSON.parse(fs.readFileSync(folderPath, 'utf8'));
 
-if (!fs.existsSync(IMPORTS_FOLDER)) {
-	fs.mkdirSync(IMPORTS_FOLDER);
-}
-
-it('dynamic imports check for CommonJS', async () => {
-	const promises: ProcessPromise[] = [];
-	for (const [i, key] of Object.keys(pj['exports']).entries()) {
-		const o1 = path.join('drizzle-orm', key);
-		if (
-			o1.startsWith('drizzle-orm/bun-sqlite') || o1.startsWith('drizzle-orm/pglite')
-			|| o1.startsWith('drizzle-orm/expo-sqlite') || o1.startsWith('drizzle-orm/libsql/wasm')
-			|| o1.startsWith('drizzle-orm/bun-sql')
-		) {
-			continue;
-		}
-		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'requ');
-		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'ire("' + o1 + '");\n', {});
+fs.mkdirSync(IMPORTS_FOLDER, { recursive: true });
 
-		// fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
-		// fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+afterAll(() => {
+	fs.rmSync(IMPORTS_FOLDER, { recursive: true });
+});
 
-		promises.push(
-			$`node ${IMPORTS_FOLDER}/imports_${i}.cjs`.nothrow(),
-			// $`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow(),
-		);
+function chunk<T>(arr: T[], size: number): T[][] {
+	const chunks: T[][] = [];
+	for (let i = 0; i < arr.length; i += size) {
+		chunks.push(arr.slice(i, i + size));
 	}
-	const results = await Promise.all(promises);
+	return chunks;
+}
 
-	for (const result of results) {
-		expect(result.exitCode, result.message).toBe(0);
+const promisesCJS: (() => ProcessPromise)[] = [];
+for (const [i, key] of Object.keys(pj['exports']).entries()) {
+	const o1 = path.join('drizzle-orm', key);
+	if (
+		o1.startsWith('drizzle-orm/bun-sqlite') || o1.startsWith('drizzle-orm/pglite')
+		|| o1.startsWith('drizzle-orm/expo-sqlite') || o1.startsWith('drizzle-orm/libsql/wasm')
+		|| o1.startsWith('drizzle-orm/bun-sql') || o1.startsWith('drizzle-orm/tursodatabase/wasm')
+		|| o1.startsWith('drizzle-orm/prisma') || o1.startsWith('drizzle-orm/node-sqlite')
+		|| o1.startsWith('drizzle-orm/effect-sqlite-bun')
+	) {
+		continue;
 	}
-});
+	fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'requ');
+	fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'ire("' + o1 + '");\n', {});
+
+	// fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
+	// fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+
+	promisesCJS.push(
+		() => $`node ${IMPORTS_FOLDER}/imports_${i}.cjs`.nothrow().timeout('5s', 'SIGTERM'),
+		// () => $`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow().timeout('5s', 'SIGTERM'),
+	);
+}
 
-it('dynamic imports check for ESM', async () => {
-	const promises: ProcessPromise[] = [];
-	for (const [i, key] of Object.keys(pj['exports']).entries()) {
-		const o1 = path.join('drizzle-orm', key);
-		if (
-			o1.startsWith('drizzle-orm/bun-sqlite') || o1.startsWith('drizzle-orm/expo-sqlite')
-			|| o1.startsWith('drizzle-orm/bun-sql')
-		) {
-			continue;
+const chunksCJS = chunk(promisesCJS, 10);
+
+for (const c of chunksCJS) {
+	it.concurrent('dynamic imports check for CommonJS chunk', async () => {
+		const results = await Promise.all(c.map((c) => c()));
+
+		for (const result of results) {
+			expect(result.exitCode, result.message).toBe(0);
 		}
-		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
-		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
-		promises.push(
-			$`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow(),
-			$`node --import import-in-the-middle/hook.mjs ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow(),
-		);
+	});
+}
+
+const promises: (() => ProcessPromise)[] = [];
+for (const [i, key] of Object.keys(pj['exports']).entries()) {
+	const o1 = path.join('drizzle-orm', key);
+	if (
+		o1.startsWith('drizzle-orm/bun-sqlite') || o1.startsWith('drizzle-orm/expo-sqlite')
+		|| o1.startsWith('drizzle-orm/bun-sql') || o1.startsWith('drizzle-orm/tursodatabase/wasm')
+		|| o1.startsWith('drizzle-orm/prisma') || o1.startsWith('drizzle-orm/node-sqlite')
+		|| o1.startsWith('drizzle-orm/effect-sqlite-bun')
+	) {
+		continue;
 	}
+	fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
+	fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+	promises.push(
+		() => $`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow().timeout('5s', 'SIGTERM'),
+		() =>
+			$`node --import import-in-the-middle/hook.mjs ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow().timeout(
+				'5s',
+				'SIGTERM',
+			),
+	);
+}
 
-	const results = await Promise.all(promises);
+const chunksESM = chunk(promises, 10);
 
-	for (const result of results) {
-		expect(result.exitCode, result.message).toBe(0);
-	}
-});
+for (const c of chunksESM) {
+	it('dynamic imports check for ESM chunk', async () => {
+		const results = await Promise.all(c.map((c) => c()));
 
-afterAll(() => {
-	fs.rmdirSync(IMPORTS_FOLDER, { recursive: true });
-});
+		for (const result of results) {
+			expect(result.exitCode, result.message).toBe(0);
+		}
+	});
+}
diff --git a/integration-tests/tests/mssql/instrumentation.ts b/integration-tests/tests/mssql/instrumentation.ts
new file mode 100644
index 0000000000..3a0001ab04
--- /dev/null
+++ b/integration-tests/tests/mssql/instrumentation.ts
@@ -0,0 +1,90 @@
+import { randomUUID } from 'crypto';
+import { defineRelations } from 'drizzle-orm';
+import type { NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import mssql from 'mssql';
+import { test as base } from 'vitest';
+import * as schema from './mssql.schema';
+
+export function parseMssqlUrl(urlString: string) {
+	const url = new URL(urlString);
+	return {
+		user: url.username,
+		password: url.password,
+		server: url.hostname,
+		port: Number.parseInt(url.port, 10),
+		database: url.pathname.replace(/^\//, ''),
+		options: {
+			encrypt: url.searchParams.get('encrypt') === 'true',
+			trustServerCertificate: url.searchParams.get('trustServerCertificate') === 'true',
+		},
+	};
+}
+
+export const createClient = async () => {
+	const url = process.env['MSSQL_CONNECTION_STRING'];
+	if (!url) {
+		throw new Error(
+			'MSSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mssql` and export the connection string (e.g. `mssql://SA:drizzle123PASSWORD!@127.0.0.1:1433?encrypt=true&trustServerCertificate=true`) before running tests.',
+		);
+	}
+	const close = () => Promise.resolve();
+	const params = parseMssqlUrl(url);
+
+	const url2 = `Server=localhost,${params.port};User Id=SA;Password=drizzle123PASSWORD!;TrustServerCertificate=True;`;
+
+	const client = await mssql.connect(params);
+	const id = `db${randomUUID().split('-')[0]}`;
+	await client.query('select 1');
+	await client.query(`create database ${id}`);
+	await client.query(`use ${id}`);
+	const db = drizzle({ client, schema, relations: defineRelations(schema) });
+	return { client, close, url, url2, db };
+};
+
+export const test = base.extend<
+	{
+		connection: { client: mssql.ConnectionPool; url: string; url2: string; db: NodeMsSqlDatabase<typeof schema> };
+		client: mssql.ConnectionPool;
+		url: string;
+		url2: string;
+		db: NodeMsSqlDatabase<typeof schema>;
+	}
+>({
+	connection: [
+		// oxlint-disable-next-line no-empty-pattern
+		async ({}, use) => {
+			const { client, close, url, url2, db } = await createClient();
+			try {
+				await use({ client, url, url2, db });
+			} finally {
+				await close();
+			}
+		},
+		{ scope: 'file' },
+	],
+	client: [
+		async ({ connection }, use) => {
+			await use(connection.client);
+		},
+		{ scope: 'file' },
+	],
+	url: [
+		async ({ connection }, use) => {
+			await use(connection.url);
+		},
+		{ scope: 'file' },
+	],
+	url2: [
+		async ({ connection }, use) => {
+			await use(connection.url2);
+		},
+		{ scope: 'file' },
+	],
+	db: [
+		async ({ connection }, use) => {
+			await use(connection.db);
+		},
+		{ scope: 'file' },
+	],
+});
diff --git a/integration-tests/tests/mssql/mssql.custom.test.ts b/integration-tests/tests/mssql/mssql.custom.test.ts
new file mode 100644
index 0000000000..56b8f80b11
--- /dev/null
+++ b/integration-tests/tests/mssql/mssql.custom.test.ts
@@ -0,0 +1,638 @@
+import 'dotenv/config';
+import { asc, DefaultLogger, eq, Name, sql } from 'drizzle-orm';
+import {
+	alias,
+	customType,
+	date,
+	datetime2,
+	int,
+	mssqlTable,
+	mssqlTableCreator,
+	time,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import type { NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';
+import { migrate } from 'drizzle-orm/node-mssql/migrator';
+import type { ConnectionPool } from 'mssql';
+import { v4 as uuid } from 'uuid';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { createClient } from './instrumentation';
+
+const ENABLE_LOGGING = false;
+
+let db: NodeMsSqlDatabase;
+let client: ConnectionPool;
+let close: () => Promise<void>;
+
+beforeAll(async () => {
+	const res = await createClient();
+	client = res.client;
+	close = res.close;
+	db = drizzle({ client, logger: ENABLE_LOGGING ? new DefaultLogger() : undefined });
+});
+
+afterAll(async () => {
+	await close?.();
+	await client?.close().catch(console.error);
+});
+
+const customText = customType<{ data: string }>({
+	dataType() {
+		return 'varchar(50)';
+	},
+});
+
+const customBoolean = customType<{ data: boolean }>({
+	dataType() {
+		return 'bit';
+	},
+	fromDriver(value) {
+		if (typeof value === 'boolean') {
+			return value;
+		}
+		return value === 1;
+	},
+});
+
+const customJson = <TData>(name: string) =>
+	customType<{ data: TData; driverData: string }>({
+		dataType() {
+			return 'nvarchar(50)';
+		},
+		toDriver(value: TData): string {
+			return JSON.stringify(value);
+		},
+		fromDriver(value: string): TData {
+			return JSON.parse(value);
+		},
+	})(name);
+
+const customTimestamp = customType<
+	{ data: Date; driverData: string; config: { fsp: number } }
+>({
+	dataType(config) {
+		const precision = config?.fsp === undefined ? '' : ` (${config.fsp})`;
+		return `datetime2${precision}`;
+	},
+	fromDriver(value: string): Date {
+		return new Date(value);
+	},
+});
+
+const customBinary = customType<{ data: Buffer; driverData: Buffer; config: { length: number } }>({
+	dataType(config) {
+		return config?.length === undefined
+			? `binary`
+			: `binary(${config.length})`;
+	},
+});
+
+const usersTable = mssqlTable('userstest', {
+	id: int('id').identity().primaryKey(),
+	name: customText('name').notNull(),
+	verified: customBoolean('verified').notNull().default(false),
+	jsonb: customJson<string[]>('jsonb'),
+	createdAt: customTimestamp('created_at', { fsp: 2 }).notNull().default(sql`CURRENT_TIMESTAMP`),
+});
+
+const datesTable = mssqlTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time', { precision: 1 }),
+	datetime: datetime2('datetime', { precision: 2 }),
+	datetimeAsString: datetime2('datetime_as_string', { precision: 2, mode: 'string' }),
+});
+
+export const testTable = mssqlTable('test_table', {
+	id: customBinary('id', { length: 32 }).primaryKey(),
+	rawId: varchar('raw_id', { length: 64 }),
+});
+
+const usersMigratorTable = mssqlTable('users12', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { length: 50 }).notNull(),
+	email: varchar('email', { length: 50 }).notNull(),
+});
+
+beforeEach(async () => {
+	await db.execute(sql`drop table if exists [userstest]`);
+	await db.execute(sql`drop table if exists [datestable]`);
+	await db.execute(sql`drop table if exists [test_table]`);
+	// await ctx.db.execute(sql`create schema public`);
+	await db.execute(
+		sql`
+			create table [userstest] (
+				[id] int identity primary key,
+				[name] varchar(50) not null,
+				[verified] bit not null default 0,
+				[jsonb] nvarchar(50),
+				[created_at] datetime2 not null default CURRENT_TIMESTAMP
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table [datestable] (
+				[date] date,
+				[date_as_string] date,
+				[time] time,
+				[datetime] datetime,
+				[datetime_as_string] datetime,
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table [test_table] (
+				[id] binary(32) primary key,
+				[raw_id] varchar(64)
+			)
+		`,
+	);
+});
+
+test('select all fields', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test('select sql', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select typed sql', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql<string>`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('insert returning sql', async () => {
+	const result = await db.insert(usersTable).values({ name: 'John' });
+
+	expect(result.rowsAffected[0]).toEqual(1);
+});
+
+test('delete returning sql', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update returning sql', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update with returning all fields', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toBe(1);
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+	expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+});
+
+test('update with returning partial', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	expect(updatedUsers.rowsAffected[0]).toEqual(1);
+
+	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+});
+
+test('delete with returning all fields', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('delete with returning partial', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	expect(result2).toEqual([
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test('json insert', async () => {
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+	}).from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test('insert with overridden default values', async () => {
+	await db.insert(usersTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test('insert many', async () => {
+	await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('insert many with returning', async () => {
+	const result = await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+
+	expect(result.rowsAffected[0]).toBe(4);
+});
+
+test('select with group by as field', async () => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.name);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('select with group by as sql', async () => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('select with group by as sql + column', async () => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by as column + sql', async () => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by complex query', async () => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.offset(0).fetch(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test('build query', async () => {
+	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `select [id], [name] from [userstest] group by [userstest].[id], [userstest].[name]`,
+		params: [],
+	});
+});
+
+test('insert sql', async () => {
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('partial join with alias', async () => {
+	const customerAlias = alias(usersTable, 'customer');
+
+	await db.insert(usersTable).values([{ name: 'Ivan' }, { name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersTable.id,
+				name: usersTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		}).from(usersTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 2))
+		.where(eq(usersTable.id, 1));
+
+	expect(result).toEqual([{
+		user: { id: 1, name: 'Ivan' },
+		customer: { id: 2, name: 'Hans' },
+	}]);
+});
+
+test('full join with alias', async () => {
+	const mysqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey(),
+		name: varchar('name', { length: 50 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int primary key, name varchar(50) not null)`);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select().from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([{
+		users: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('select from alias', async () => {
+	const mysqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTable('users', {
+		id: int('id').primaryKey(),
+		name: varchar('name', { length: 50 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int primary key, name varchar(50) not null)`);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	expect(result).toEqual([{
+		user: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('insert with spaces', async () => {
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test('prepared statement', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.prepare();
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('prepared statement reuse', async () => {
+	const stmt = db.insert(usersTable).values({
+		verified: true,
+		name: sql.placeholder('name'),
+	}).prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test('prepared statement with placeholder in .where', async () => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.where(eq(usersTable.id, sql.placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('migrator', async () => {
+	await db.execute(sql`drop table if exists cities_migration`);
+	await db.execute(sql`drop table if exists users_migration`);
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists [drizzle].[__drizzle_migrations]`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/mssql' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table cities_migration`);
+	await db.execute(sql`drop table users_migration`);
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table [drizzle].[__drizzle_migrations]`);
+});
+
+test('insert via db.execute + select via db.execute', async () => {
+	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
+	expect(result.recordset).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('insert via db.execute w/ query builder', async () => {
+	const inserted = await db.execute(
+		db.insert(usersTable).values({ name: 'John' }),
+	);
+	expect(inserted.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select all possible dates', async () => {
+	const date = new Date('2022-11-11');
+
+	await db.insert(datesTable).values({
+		date: date,
+		dateAsString: '2022-11-11',
+		time: new Date('1970-01-01T12:12:12.000Z'),
+		datetime: date,
+		datetimeAsString: '2022-11-11T12:12:12.000Z',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	expect(res[0]?.date).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	expect(res[0]?.datetime).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	expect(typeof res[0]?.dateAsString).toEqual('string');
+	expect(typeof res[0]?.datetimeAsString).toEqual('string');
+
+	expect(res).toEqual([{
+		date: new Date('2022-11-11'),
+		dateAsString: '2022-11-11',
+		time: new Date('1970-01-01T12:12:12.000Z'),
+		datetime: new Date('2022-11-11'),
+		datetimeAsString: '2022-11-11T12:12:12.000Z',
+	}]);
+});
+
+const tableWithEnums = mssqlTable('enums_test_case', {
+	id: int('id').primaryKey(),
+	enum1: varchar('enum1', { enum: ['a', 'b', 'c'], length: 50 }).notNull(),
+	enum2: varchar('enum2', { enum: ['a', 'b', 'c'], length: 50 }).default('a'),
+	enum3: varchar('enum3', { enum: ['a', 'b', 'c'], length: 50 }).notNull().default('b'),
+});
+
+test('Mssql enum test case #1', async () => {
+	await db.execute(sql`drop table if exists [enums_test_case]`);
+
+	await db.execute(sql`
+		create table [enums_test_case] (
+			[id] int primary key,
+			[enum1] varchar(50) not null,
+			[enum2] varchar(50) default 'a',
+			[enum3] varchar(50) not null default 'b'
+		)
+	`);
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	await db.execute(sql`drop table [enums_test_case]`);
+
+	expect(res).toEqual([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test('custom binary', async () => {
+	const id = uuid().replace(/-/g, '');
+	await db.insert(testTable).values({
+		id: Buffer.from(id),
+		rawId: id,
+	});
+
+	const res = await db.select().from(testTable);
+
+	expect(res).toEqual([{
+		id: Buffer.from(id),
+		rawId: id,
+	}]);
+});
diff --git a/integration-tests/tests/mssql/mssql.prefixed.test.ts b/integration-tests/tests/mssql/mssql.prefixed.test.ts
new file mode 100644
index 0000000000..a50ea03f2d
--- /dev/null
+++ b/integration-tests/tests/mssql/mssql.prefixed.test.ts
@@ -0,0 +1,1452 @@
+import 'dotenv/config';
+
+import { asc, eq, getTableName, gt, inArray, Name, sql, TransactionRollbackError } from 'drizzle-orm';
+import {
+	alias,
+	date,
+	datetime2,
+	getViewConfig,
+	int,
+	mssqlTable,
+	mssqlTable as mssqlTableRaw,
+	mssqlTableCreator,
+	mssqlView,
+	text,
+	time,
+	uniqueIndex,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { migrate } from 'drizzle-orm/node-mssql/migrator';
+import { expect } from 'vitest';
+import { type Equal, Expect } from '~/utils';
+import { test } from './instrumentation';
+import { citiesTable, users2Table, usersTable } from './schema';
+
+test.beforeEach(async ({ db }) => {
+	await db.execute(sql`drop table if exists ${usersTable}`);
+	await db.execute(sql`drop table if exists ${users2Table}`);
+	await db.execute(sql`drop table if exists ${citiesTable}`);
+
+	await db.execute(
+		sql`
+			create table ${usersTable} (
+				[id] int identity primary key,
+				[name] varchar(30) not null,
+				[verified] bit not null default 0,
+				[jsonb] text,
+				[created_at] datetime not null default current_timestamp
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table ${citiesTable} (
+				[id] int primary key,
+				[name] varchar(30) not null
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table ${users2Table} (
+				[id] int primary key,
+				[name] varchar(30) not null,
+				[city_id] int null foreign key references ${citiesTable}([id])
+			)
+		`,
+	);
+});
+
+test('select all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test('select sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select typed sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql<string>`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select distinct', async ({ db }) => {
+	const usersDistinctTable = mssqlTable('users_distinct', {
+		id: int('id').notNull(),
+		name: varchar('name', { length: 100 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+	await db.execute(sql`create table ${usersDistinctTable} (id int, name varchar(100))`);
+
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+		usersDistinctTable.id,
+		usersDistinctTable.name,
+	);
+
+	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+	expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+});
+
+test('insert returning sql', async ({ db }) => {
+	const result = await db.insert(usersTable).values({ name: 'John' });
+
+	expect(result.rowsAffected[0]).toEqual(1);
+});
+
+test('delete returning sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update returning sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update with returning all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toBe(1);
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+	expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+});
+
+test('update with returning partial', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	expect(updatedUsers.rowsAffected[0]).toEqual(1);
+
+	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+});
+
+test('delete with returning all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('delete with returning partial', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	expect(result2).toEqual([
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test('json insert', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+	}).from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test('insert with overridden default values', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test('insert many', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('insert many with returning', async ({ db }) => {
+	const result = await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+
+	expect(result.rowsAffected[0]).toBe(4);
+});
+
+test('select with group by as field', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.name);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('select with group by as sql', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('select with group by as sql + column', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by as column + sql', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test('select with group by complex query', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.offset(0).fetch(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test('build query', async ({ db }) => {
+	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `select [id], [name] from [${getTableName(usersTable)}] group by [${getTableName(usersTable)}].[id], [${
+			getTableName(usersTable)
+		}].[name]`,
+		params: [],
+	});
+});
+
+test('insert sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('partial join with alias', async ({ db }) => {
+	const customerAlias = alias(usersTable, 'customer');
+
+	await db.insert(usersTable).values([{ name: 'Ivan' }, { name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersTable.id,
+				name: usersTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		}).from(usersTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 2))
+		.where(eq(usersTable.id, 1));
+
+	expect(result).toEqual([{
+		user: { id: 1, name: 'Ivan' },
+		customer: { id: 2, name: 'Hans' },
+	}]);
+});
+
+test('full join with alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int primary key, name text not null)`);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select().from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([{
+		users: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('select from alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int primary key, name text not null)`);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	expect(result).toEqual([{
+		user: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('insert with spaces', async ({ db }) => {
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test('prepared statement', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.prepare();
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('prepared statement reuse', async ({ db }) => {
+	const stmt = db.insert(usersTable).values({
+		verified: true,
+		name: sql.placeholder('name'),
+	}).prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test('prepared statement with placeholder in .where', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.where(eq(usersTable.id, sql.placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('migrator', async ({ db }) => {
+	const usersMigratorTable = mssqlTableRaw('users12', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		email: text('email').notNull(),
+	}, (table) => [
+		uniqueIndex('').on(table.name),
+	]);
+
+	await db.execute(sql.raw(`drop table if exists cities_migration`));
+	await db.execute(sql.raw(`drop table if exists users_migration`));
+	await db.execute(sql.raw(`drop table if exists users12`));
+	await db.execute(sql.raw(`drop table if exists [drizzle].[__drizzle_migrations]`));
+
+	await migrate(db, { migrationsFolder: './drizzle2/mssql' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql.raw(`drop table cities_migration`));
+	await db.execute(sql.raw(`drop table users_migration`));
+	await db.execute(sql.raw(`drop table users12`));
+	await db.execute(sql.raw(`drop table [drizzle].[__drizzle_migrations]`));
+});
+
+test('insert via db.execute + select via db.execute', async ({ db }) => {
+	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
+	expect(result.recordset[0]).toEqual({ id: 1, name: 'John' });
+});
+
+test('insert via db.execute w/ query builder', async ({ db }) => {
+	const inserted = await db.execute(
+		db.insert(usersTable).values({ name: 'John' }),
+	);
+	expect(inserted.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select all possible dates', async ({ db }) => {
+	const datesTable = mssqlTable('datestable', {
+		date: date('date'),
+		dateAsString: date('date_as_string', { mode: 'string' }),
+		time: time('time', { precision: 1 }),
+		datetime: datetime2('datetime', { precision: 2 }),
+		datetimeAsString: datetime2('datetime_as_string', { precision: 2, mode: 'string' }),
+	});
+
+	await db.execute(sql`drop table if exists ${datesTable}`);
+	await db.execute(
+		sql`
+			create table ${datesTable} (
+				[date] date,
+				[date_as_string] date,
+				[time] time(1),
+				[datetime] datetime2(2),
+				[datetime_as_string] datetime2(2)
+			)
+		`,
+	);
+
+	const d = new Date('2022-11-11');
+
+	await db.insert(datesTable).values({
+		date: d,
+		dateAsString: '2022-11-11',
+		time: new Date('1970-01-01T12:12:12.000Z'),
+		datetime: d,
+		datetimeAsString: '2022-11-11T12:12:12.000Z',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	expect(res[0]?.date).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	expect(res[0]?.datetime).toBeInstanceOf(Date); // eslint-disable-line no-instanceof/no-instanceof
+	expect(typeof res[0]?.dateAsString).toEqual('string');
+	expect(typeof res[0]?.datetimeAsString).toEqual('string');
+
+	expect(res).toEqual([{
+		date: (new Date('2022-11-11')),
+		dateAsString: '2022-11-11',
+		time: new Date('1970-01-01T12:12:12.000Z'),
+		datetime: new Date('2022-11-11'),
+		datetimeAsString: '2022-11-11T12:12:12.000Z',
+	}]);
+
+	await db.execute(sql`drop table ${datesTable}`);
+});
+
+test('Mysql enum test case #1', async ({ db }) => {
+	const tableWithEnums = mssqlTable('enums_test_case', {
+		id: int('id').primaryKey(),
+		enum1: varchar('enum1', { enum: ['a', 'b', 'c'], length: 50 }).notNull(),
+		enum2: varchar('enum2', { enum: ['a', 'b', 'c'], length: 50 }).default('a'),
+		enum3: varchar('enum3', { enum: ['a', 'b', 'c'], length: 50 }).notNull().default('b'),
+	});
+
+	await db.execute(sql`drop table if exists ${tableWithEnums}`);
+
+	await db.execute(sql`
+		create table ${tableWithEnums} (
+			[id] int primary key,
+			[enum1] varchar(50) not null,
+			[enum2] varchar(50) default 'a',
+			[enum3] varchar(50) not null default 'b'
+		)
+	`);
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	await db.execute(sql`drop table ${tableWithEnums}`);
+
+	expect(res).toEqual([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test('left join (flat object fields)', async ({ db }) => {
+	await db.insert(citiesTable)
+		.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+	await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+	const res = await db.select({
+		userId: users2Table.id,
+		userName: users2Table.name,
+		cityId: citiesTable.id,
+		cityName: citiesTable.name,
+	}).from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+	]);
+});
+
+test('left join (grouped fields)', async ({ db }) => {
+	await db.insert(citiesTable)
+		.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+	await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+	const res = await db.select({
+		id: users2Table.id,
+		user: {
+			name: users2Table.name,
+			nameUpper: sql<string>`upper(${users2Table.name})`,
+		},
+		city: {
+			id: citiesTable.id,
+			name: citiesTable.name,
+			nameUpper: sql<string>`upper(${citiesTable.name})`,
+		},
+	}).from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{
+			id: 1,
+			user: { name: 'John', nameUpper: 'JOHN' },
+			city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+		},
+		{
+			id: 2,
+			user: { name: 'Jane', nameUpper: 'JANE' },
+			city: null,
+		},
+	]);
+});
+
+test('left join (all fields)', async ({ db }) => {
+	await db.insert(citiesTable)
+		.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+	await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+	const res = await db.select().from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{
+			users2: {
+				id: 1,
+				name: 'John',
+				cityId: 1,
+			},
+			cities: {
+				id: 1,
+				name: 'Paris',
+			},
+		},
+		{
+			users2: {
+				id: 2,
+				name: 'Jane',
+				cityId: null,
+			},
+			cities: null,
+		},
+	]);
+});
+
+test('join subquery', async ({ db }) => {
+	const coursesTable = mssqlTable('courses', {
+		id: int('id').identity().primaryKey(),
+		name: varchar('name', { length: 50 }).notNull(),
+		categoryId: int('category_id').references(() => courseCategoriesTable.id),
+	});
+
+	const courseCategoriesTable = mssqlTable('course_categories', {
+		id: int('id').identity().primaryKey(),
+		name: varchar('name', { length: 50 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${coursesTable}`);
+	await db.execute(sql`drop table if exists ${courseCategoriesTable}`);
+
+	await db.execute(
+		sql`
+			create table ${courseCategoriesTable} (
+				[id] int identity primary key,
+				[name] varchar(50) not null
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table ${coursesTable} (
+				[id] int identity primary key,
+				[name] varchar(50) not null,
+				[category_id] int references ${courseCategoriesTable}([id])
+			)
+		`,
+	);
+
+	await db.insert(courseCategoriesTable).values([
+		{ name: 'Category 1' },
+		{ name: 'Category 2' },
+		{ name: 'Category 3' },
+		{ name: 'Category 4' },
+	]);
+
+	await db.insert(coursesTable).values([
+		{ name: 'Development', categoryId: 2 },
+		{ name: 'IT & Software', categoryId: 3 },
+		{ name: 'Marketing', categoryId: 4 },
+		{ name: 'Design', categoryId: 1 },
+	]);
+
+	const sq2 = db
+		.select({
+			categoryId: courseCategoriesTable.id,
+			category: courseCategoriesTable.name,
+			total: sql<number>`count(${courseCategoriesTable.id})`.as('total'),
+		})
+		.from(courseCategoriesTable)
+		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+		.as('sq2');
+
+	const res = await db
+		.select({
+			courseName: coursesTable.name,
+			categoryId: sq2.categoryId,
+		})
+		.from(coursesTable)
+		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+		.orderBy(coursesTable.name);
+
+	await db.execute(sql`drop table ${coursesTable}`);
+	await db.execute(sql`drop table ${courseCategoriesTable}`);
+
+	expect(res).toEqual([
+		{ courseName: 'Design', categoryId: 1 },
+		{ courseName: 'Development', categoryId: 2 },
+		{ courseName: 'IT & Software', categoryId: 3 },
+		{ courseName: 'Marketing', categoryId: 4 },
+	]);
+});
+
+test('with ... select', async ({ db }) => {
+	const orders = mssqlTable('orders', {
+		id: int('id').identity().primaryKey(),
+		region: varchar('region', { length: 50 }).notNull(),
+		product: varchar('product', { length: 50 }).notNull(),
+		amount: int('amount').notNull(),
+		quantity: int('quantity').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${orders}`);
+	await db.execute(
+		sql`
+			create table ${orders} (
+				[id] int identity primary key,
+				[region] varchar(50) not null,
+				[product] varchar(50) not null,
+				[amount] int not null,
+				[quantity] int not null
+			)
+		`,
+	);
+
+	await db.insert(orders).values([
+		{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+		{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+	]);
+
+	const regionalSales = db
+		.$with('regional_sales')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region),
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as(
+			db
+				.select({
+					region: regionalSales.region,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				),
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`sum(${orders.quantity})`.as('product_units'),
+			productSales: sql<number>`sum(${orders.amount})`.as('product_sales'),
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+		.groupBy(orders.region, orders.product)
+		.orderBy(orders.region, orders.product);
+
+	await db.execute(sql`drop table ${orders}`);
+
+	expect(result).toEqual([
+		{
+			region: 'Europe',
+			product: 'A',
+			productUnits: 3,
+			productSales: 30,
+		},
+		{
+			region: 'Europe',
+			product: 'B',
+			productUnits: 5,
+			productSales: 50,
+		},
+		{
+			region: 'US',
+			product: 'A',
+			productUnits: 7,
+			productSales: 70,
+		},
+		{
+			region: 'US',
+			product: 'B',
+			productUnits: 9,
+			productSales: 90,
+		},
+	]);
+});
+
+test('select from subquery sql', async ({ db }) => {
+	await db.insert(users2Table).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+
+	const sq = db
+		.select({ name: sql<string>`concat(${users2Table.name}, ' modified')`.as('name') })
+		.from(users2Table)
+		.as('sq');
+
+	const res = await db.select({ name: sq.name }).from(sq);
+
+	expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test('select a field without joining its table', ({ db }) => {
+	expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+});
+
+test('select all fields from subquery without alias', ({ db }) => {
+	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+	expect(() => db.select().from(sq).prepare()).toThrowError();
+});
+
+test('select count()', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+	expect(res).toEqual([{ count: 2 }]);
+});
+
+test('having', async ({ db }) => {
+	await db.insert(citiesTable).values([{ id: 1, name: 'London' }, { id: 2, name: 'Paris' }, {
+		id: 3,
+		name: 'New York',
+	}]);
+
+	await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane', cityId: 1 }, {
+		id: 3,
+		name: 'Jack',
+		cityId: 2,
+	}]);
+
+	const result = await db
+		.select({
+			id: citiesTable.id,
+			name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+			usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+		})
+		.from(citiesTable)
+		.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+		.where(({ name }) => sql`len(${name}) >= 3`)
+		.groupBy(citiesTable.id, citiesTable.name)
+		.having(({ usersCount }) => sql`${usersCount} > 0`)
+		.orderBy(({ name }) => name);
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'LONDON',
+			usersCount: 2,
+		},
+		{
+			id: 2,
+			name: 'PARIS',
+			usersCount: 1,
+		},
+	]);
+});
+
+test('view', async ({ db }) => {
+	const newYorkers1 = mssqlView('new_yorkers')
+		.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+	const newYorkers2 = mssqlView('new_yorkers', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+	const newYorkers3 = mssqlView('new_yorkers', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).existing();
+
+	await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+	await db.insert(citiesTable).values([{ id: 1, name: 'New York' }, { id: 2, name: 'Paris' }]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+		expect(result).toEqual([
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test('select from raw sql', async ({ db }) => {
+	const result = await db.select({
+		id: sql<number>`id`,
+		name: sql<string>`name`,
+	}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+	Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test('select from raw sql with joins', async ({ db }) => {
+	const result = await db
+		.select({
+			id: sql<number>`users.id`,
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+	]);
+});
+
+test('join on aliased sql from select', async ({ db }) => {
+	const result = await db
+		.select({
+			userId: sql<number>`users.id`.as('userId'),
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityId: sql<number>`cities.id`.as('cityId'),
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test('join on aliased sql from with clause', async ({ db }) => {
+	const users = db.$with('users').as(
+		db.select({
+			id: sql<number>`id`.as('userId'),
+			name: sql<string>`name`.as('userName'),
+			city: sql<string>`city`.as('city'),
+		}).from(
+			sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+		),
+	);
+
+	const cities = db.$with('cities').as(
+		db.select({
+			id: sql<number>`id`.as('cityId'),
+			name: sql<string>`name`.as('cityName'),
+		}).from(
+			sql`(select 1 as id, 'Paris' as name) as cities`,
+		),
+	);
+
+	const result = await db
+		.with(users, cities)
+		.select({
+			userId: users.id,
+			name: users.name,
+			userCity: users.city,
+			cityId: cities.id,
+			cityName: cities.name,
+		})
+		.from(users)
+		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test('prefixed table', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `myprefix_${name}`);
+
+	const users = mssqlTable('test_prefixed_table_with_unique_name', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
+	);
+
+	await db.insert(users).values({ id: 1, name: 'John' });
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('orderBy with aliased column', ({ db }) => {
+	const query = db.select({
+		test: sql`something`.as('test'),
+	}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+	expect(query.sql).toEqual(`select something as [test] from [${getTableName(users2Table)}] order by [test]`);
+});
+
+test('transaction', async ({ db }) => {
+	const users = mssqlTable('users_transactions', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+	const products = mssqlTable('products_transactions', {
+		id: int('id').identity().primaryKey(),
+		price: int('price').notNull(),
+		stock: int('stock').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${products}`);
+
+	await db.execute(sql`create table ${users} (id int identity not null primary key, balance int not null)`);
+	await db.execute(
+		sql`create table ${products} (id int identity not null primary key, price int not null, stock int not null)`,
+	);
+
+	await db.insert(users).values({ balance: 100 });
+	const userId = (await db.select().from(users).then((rows) => rows[0]!))!.id;
+
+	const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
+
+	await db.insert(products).values({ price: 10, stock: 10 });
+	const productId = (await db.select().from(products).then((rows) => rows[0]!))!.id;
+	const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
+
+	await db.transaction(async (tx) => {
+		await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+		await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+	});
+
+	const result = await db.select().from(users);
+
+	await db.execute(sql`drop table ${users}`);
+	await db.execute(sql`drop table ${products}`);
+
+	expect(result).toEqual([{ id: 1, balance: 90 }]);
+});
+
+test('transaction rollback', async ({ db }) => {
+	const users = mssqlTable('users_transactions_rollback', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, balance int not null)`,
+	);
+
+	await expect((async () => {
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+			tx.rollback();
+		});
+	})()).rejects.toThrowError(TransactionRollbackError);
+
+	const result = await db.select().from(users);
+
+	await db.execute(sql`drop table ${users}`);
+
+	expect(result).toEqual([]);
+});
+
+test('nested transaction', async ({ db }) => {
+	const users = mssqlTable('users_nested_transactions', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, balance int not null)`,
+	);
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await tx.transaction(async (tx) => {
+			await tx.update(users).set({ balance: 200 });
+		});
+	});
+
+	const result = await db.select().from(users);
+
+	await db.execute(sql`drop table ${users}`);
+
+	expect(result).toEqual([{ id: 1, balance: 200 }]);
+});
+
+test('nested transaction rollback', async ({ db }) => {
+	const users = mssqlTable('users_nested_transactions_rollback', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, balance int not null)`,
+	);
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await expect((async () => {
+			await tx.transaction(async (tx) => {
+				await tx.update(users).set({ balance: 200 });
+				tx.rollback();
+			});
+		})()).rejects.toThrowError(TransactionRollbackError);
+	});
+
+	const result = await db.select().from(users);
+
+	await db.execute(sql`drop table ${users}`);
+
+	expect(result).toEqual([{ id: 1, balance: 100 }]);
+});
+
+test('join subquery with join', async ({ db }) => {
+	const internalStaff = mssqlTable('internal_staff', {
+		userId: int('user_id').notNull(),
+	});
+
+	const customUser = mssqlTable('custom_user', {
+		id: int('id').notNull(),
+	});
+
+	const ticket = mssqlTable('ticket', {
+		staffId: int('staff_id').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${internalStaff}`);
+	await db.execute(sql`drop table if exists ${customUser}`);
+	await db.execute(sql`drop table if exists ${ticket}`);
+
+	await db.execute(sql`create table ${internalStaff} (user_id integer not null)`);
+	await db.execute(sql`create table ${customUser} (id integer not null)`);
+	await db.execute(sql`create table ${ticket} (staff_id integer not null)`);
+
+	await db.insert(internalStaff).values({ userId: 1 });
+	await db.insert(customUser).values({ id: 1 });
+	await db.insert(ticket).values({ staffId: 1 });
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+		.as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	await db.execute(sql`drop table ${internalStaff}`);
+	await db.execute(sql`drop table ${customUser}`);
+	await db.execute(sql`drop table ${ticket}`);
+
+	expect(mainQuery).toEqual([{
+		ticket: { staffId: 1 },
+		internal_staff: {
+			internal_staff: { userId: 1 },
+			custom_user: { id: 1 },
+		},
+	}]);
+});
+
+test('subquery with view', async ({ db }) => {
+	const users = mssqlTable('users_subquery_view', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mssqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.$with('sq').as(db.select().from(newYorkers));
+	const result = await db.with(sq).select().from(sq);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 1 },
+	]);
+});
+
+test('join view as subquery', async ({ db }) => {
+	const users = mssqlTable('users_join_view', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mssqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+	const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+	expect(result).toEqual([
+		{
+			users_join_view: { id: 1, name: 'John', cityId: 1 },
+			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+		{
+			users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('select iterator', async ({ db }) => {
+	const users = mssqlTable('users_iterator', {
+		id: int('id').identity().primaryKey(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int identity not null primary key)`);
+
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+
+	const iter = db.select().from(users).iterator();
+	const result: typeof users.$inferSelect[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test('select iterator w/ prepared statement', async ({ db }) => {
+	const users = mssqlTable('users_iterator', {
+		id: int('id').identity().primaryKey(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id int identity not null primary key)`);
+
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+
+	const prepared = db.select().from(users).prepare();
+	const iter = prepared.iterator();
+	const result: typeof users.$inferSelect[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test('insert undefined', async ({ db }) => {
+	const users = mssqlTable('users', {
+		id: int('id').identity().primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text)`,
+	);
+
+	await expect((async () => {
+		await db.insert(users).values({ name: undefined });
+	})()).resolves.not.toThrowError();
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('update undefined', async ({ db }) => {
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int not null primary key, name text)`,
+	);
+
+	await expect((async () => {
+		await db.update(users).set({ name: undefined });
+	})()).rejects.toThrowError();
+
+	await expect((async () => {
+		await db.update(users).set({ id: 1, name: undefined });
+	})()).resolves.not.toThrowError();
+
+	await db.execute(sql`drop table ${users}`);
+});
diff --git a/integration-tests/tests/mssql/mssql.rels.test.ts b/integration-tests/tests/mssql/mssql.rels.test.ts
new file mode 100644
index 0000000000..78f584432e
--- /dev/null
+++ b/integration-tests/tests/mssql/mssql.rels.test.ts
@@ -0,0 +1,5965 @@
+import 'dotenv/config';
+import { desc, DrizzleError, eq, gt, gte, or, sql, TransactionRollbackError } from 'drizzle-orm';
+import { expect, expectTypeOf } from 'vitest';
+import { test } from './instrumentation';
+import * as schema from './mssql.schema';
+
+const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
+
+/*
+	Test cases:
+	- querying nested relation without PK with additional fields
+*/
+
+test.beforeEach(async ({ db }) => {
+	await db.execute(sql`drop table if exists [users_to_groups]`);
+	await db.execute(sql`drop table if exists [comment_likes]`);
+	await db.execute(sql`drop table if exists [comments]`);
+	await db.execute(sql`drop table if exists [posts]`);
+	await db.execute(sql`drop table if exists [groups]`);
+	await db.execute(sql`drop table if exists [users]`);
+
+	await db.execute(
+		sql`
+			CREATE TABLE [users] (
+				[id] int PRIMARY KEY NOT NULL,
+				[name] varchar(100) NOT NULL,
+				[verified] bit DEFAULT 0 NOT NULL,
+				[invited_by] int null foreign key REFERENCES [users]([id])
+			);
+		`,
+	);
+	await db.execute(
+		sql`
+			CREATE TABLE [groups] (
+				[id] int PRIMARY KEY NOT NULL,
+				[name] varchar(100) NOT NULL,
+				[description] varchar(100)
+			);
+		`,
+	);
+	await db.execute(
+		sql`
+			CREATE TABLE [users_to_groups] (
+				[id] int identity PRIMARY KEY NOT NULL,
+				[user_id] int foreign key REFERENCES [users]([id]),
+				[group_id] int foreign key REFERENCES [groups]([id])
+			);
+		`,
+	);
+	await db.execute(
+		sql`
+			CREATE TABLE [posts] (
+				[id] int identity PRIMARY KEY NOT NULL,
+				[content] varchar(100) NOT NULL,
+				[owner_id] int null foreign key REFERENCES [users]([id]),
+				[created_at] datetime DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await db.execute(
+		sql`
+			CREATE TABLE [comments] (
+				[id] int identity PRIMARY KEY NOT NULL,
+				[content] varchar(100) NOT NULL,
+				[creator] int null foreign key REFERENCES [users]([id]),
+				[post_id] int null foreign key REFERENCES [posts]([id]),
+				[created_at] datetime DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await db.execute(
+		sql`
+			CREATE TABLE [comment_likes] (
+				[id] int identity PRIMARY KEY NOT NULL,
+				[creator] int null foreign key REFERENCES [users]([id]),
+				[comment_id] int null foreign key REFERENCES [comments]([id]),
+				[created_at] datetime DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+});
+
+/*
+	[Find Many] One relation users+posts
+*/
+
+test('[Find Many] Get users with posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: (usersTable, { sql }) => ({
+			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
+			},
+		},
+		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		where: (({ id }, { eq }) => eq(id, 1)),
+		with: {
+			posts: {
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async ({ db }) => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx._query.usersTable.findMany({
+			where: (({ id }, { eq }) => eq(id, 1)),
+			with: {
+				posts: {
+					where: (({ id }, { eq }) => eq(id, 1)),
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async ({ db }) => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx._query.usersTable.findMany({
+			where: (({ id }, { eq }) => eq(id, 1)),
+			with: {
+				posts: {
+					where: (({ id }, { eq }) => eq(id, 1)),
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+// select only custom
+test('[Find Many] Get only custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test('[Find Many] Get only custom fields + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				limit: 1,
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				orderBy: [desc(postsTable.id)],
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+// select only custom find one
+test('[Find One] Get only custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+});
+
+test('[Find One] Get only custom fields + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				limit: 1,
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: gte(postsTable.id, 2),
+				orderBy: [desc(postsTable.id)],
+				extras: ({ content }) => ({
+					lowerName: sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: eq(usersTable.id, 1),
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+// columns {}
+test('[Find Many] Get select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(
+		async () =>
+			await db._query.usersTable.findMany({
+				columns: {},
+			}),
+	).rejects.toThrow(DrizzleError);
+});
+
+// columns {}
+test('[Find One] Get select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db._query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+// deep select {}
+test('[Find Many] Get deep select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db._query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+// deep select {}
+test('[Find One] Get deep select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db._query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+/*
+	Prepared statements for users+posts
+*/
+test('[Find Many] Get users with posts + prepared limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db._query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db._query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db._query.usersTable.findMany({
+		where: (({ id }, { eq }) => eq(id, sql.placeholder('id'))),
+		with: {
+			posts: {
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db._query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: (({ id }, { eq, or }) => or(eq(id, sql.placeholder('id')), eq(id, 3))),
+		with: {
+			posts: {
+				where: (({ id }, { eq }) => eq(id, sql.placeholder('pid'))),
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+/*
+	[Find One] One relation users+posts
+*/
+
+test('[Find One] Get users with posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async ({ db }) => {
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({ name }) => ({
+			lowerName: sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(false);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: (usersTable, { sql }) => ({
+			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
+			},
+		},
+		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		where: (({ id }, { eq }) => eq(id, 1)),
+		with: {
+			posts: {
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db._query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: (({ id }, { eq }) => eq(id, 1)),
+			},
+		},
+		where: (({ id }, { eq }) => eq(id, 1)),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+/*
+	One relation users+users. Self referencing
+*/
+
+test('Get user with invitee', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+/*
+	Two first-level relations users+users and users+posts
+*/
+
+test('Get user with invitee and posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		limit: 3,
+		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: (posts, { desc }) => [desc(posts.id)],
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
+		with: {
+			invitee: true,
+			posts: {
+				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		orderBy: [desc(usersTable.id)],
+		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
+		extras: {
+			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: eq(postsTable.ownerId, 3),
+				orderBy: [desc(postsTable.id)],
+				extras: {
+					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		orderBy: [desc(usersTable.id)],
+		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
+		extras: {
+			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: {
+					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				},
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: eq(postsTable.ownerId, 3),
+				orderBy: [desc(postsTable.id)],
+				extras: {
+					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+/*
+	One two-level relation users+posts+comments
+*/
+
+test('Get user with posts and posts with comments', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: false,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+// Get user with limit posts and limit comments
+
+// Get user with custom field + post + comment with custom field
+
+// Get user with limit + posts orderBy + comment orderBy
+
+// Get user with where + posts where + comment where
+
+// Get user with where + posts partial where + comment where
+
+// Get user with where + posts partial where + comment partial(false) where
+
+// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
+
+// Get user with where + posts partial where + comment where. Didn't select field from where in posts
+
+// Get user with where + posts partial where + comment where. Didn't select field from where for all
+
+// Get with limit+offset in each
+
+/*
+	One two-level + One first-level relation users+posts+comments and users+users
+*/
+
+/*
+	One three-level relation users+posts+comments+comment_owner
+*/
+
+test('Get user with posts and posts with comments and comments with owner', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				} | null;
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+/*
+	One three-level relation + 1 first-level relatioon
+	1. users+posts+comments+comment_owner
+	2. users+users
+*/
+
+/*
+	One four-level relation users+posts+comments+coment_likes
+*/
+
+/*
+	[Find Many] Many-to-many cases
+
+	Users+users_to_groups+groups
+*/
+
+test('[Find Many] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		limit: 1,
+		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.groupId, 1),
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		limit: 1,
+		where: gt(groupsTable.id, 1),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.userId, 2),
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.groupId, 2),
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		where: gt(groupsTable.id, 1),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.userId, 2),
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		with: {
+			usersToGroups: {
+				orderBy: [desc(usersToGroupsTable.groupId)],
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		orderBy: [desc(groupsTable.id)],
+		with: {
+			usersToGroups: {
+				orderBy: (utg, { desc }) => [desc(utg.userId)],
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: [desc(usersToGroupsTable.groupId)],
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+/*
+	[Find One] Many-to-many cases
+
+	Users+users_to_groups+groups
+*/
+
+test('[Find One] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.groupId, 1),
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findFirst({
+		where: gt(groupsTable.id, 1),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.userId, 2),
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.groupId, 2),
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findFirst({
+		where: gt(groupsTable.id, 1),
+		with: {
+			usersToGroups: {
+				where: eq(usersToGroupsTable.userId, 2),
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		with: {
+			usersToGroups: {
+				orderBy: [desc(usersToGroupsTable.groupId)],
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findFirst({
+		orderBy: [desc(groupsTable.id)],
+		with: {
+			usersToGroups: {
+				orderBy: (utg, { desc }) => [desc(utg.userId)],
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findFirst({
+		orderBy: (users, { desc }) => [desc(users.id)],
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: [desc(usersToGroupsTable.groupId)],
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		orderBy: [desc(groupsTable.id)],
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: (utg, { desc }) => [desc(utg.userId)],
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.usersTable.findMany({
+		extras: {
+			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		},
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: {
+							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db._query.groupsTable.findMany({
+		extras: (table, { sql }) => ({
+			lower: sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: (table, { sql }) => ({
+							lower: sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('.toSQL()', ({ db }) => {
+	const query = db._query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
+
+// + custom + where + orderby
+
+// + custom + where + orderby + limit
+
+// + partial
+
+// + partial(false)
+
+// + partial + orderBy + where (all not selected)
+
+/*
+	One four-level relation users+posts+comments+coment_likes
+	+ users+users_to_groups+groups
+*/
+
+/*
+	Really hard case
+	1. users+posts+comments+coment_likes
+	2. users+users_to_groups+groups
+	3. users+users
+*/
diff --git a/integration-tests/tests/mssql/mssql.schema.ts b/integration-tests/tests/mssql/mssql.schema.ts
new file mode 100644
index 0000000000..e1e7fa50d7
--- /dev/null
+++ b/integration-tests/tests/mssql/mssql.schema.ts
@@ -0,0 +1,103 @@
+import { type AnyMsSqlColumn, bit, datetime, int, mssqlTable, primaryKey, varchar } from 'drizzle-orm/mssql-core';
+
+import { sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
+
+export const usersTable = mssqlTable('users', {
+	id: int('id').primaryKey().notNull(),
+	name: varchar('name', { length: 100 }).notNull(),
+	verified: bit('verified').notNull().default(false),
+	invitedBy: int('invited_by').references((): AnyMsSqlColumn => usersTable.id),
+});
+export const usersConfig = relations(usersTable, ({ one, many }) => ({
+	invitee: one(usersTable, {
+		fields: [usersTable.invitedBy],
+		references: [usersTable.id],
+	}),
+	usersToGroups: many(usersToGroupsTable),
+	posts: many(postsTable),
+}));
+
+export const groupsTable = mssqlTable('groups', {
+	id: int('id').primaryKey().notNull(),
+	name: varchar('name', { length: 100 }).notNull(),
+	description: varchar('description', { length: 100 }),
+});
+export const groupsConfig = relations(groupsTable, ({ many }) => ({
+	usersToGroups: many(usersToGroupsTable),
+}));
+
+export const usersToGroupsTable = mssqlTable(
+	'users_to_groups',
+	{
+		id: int('id').primaryKey().identity().notNull(),
+		userId: int('user_id').notNull().references(() => usersTable.id),
+		groupId: int('group_id').notNull().references(() => groupsTable.id),
+	},
+	(t) => [
+		primaryKey({ name: 'pk_1', columns: [t.userId, t.groupId] }),
+	],
+);
+export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
+	group: one(groupsTable, {
+		fields: [usersToGroupsTable.groupId],
+		references: [groupsTable.id],
+	}),
+	user: one(usersTable, {
+		fields: [usersToGroupsTable.userId],
+		references: [usersTable.id],
+	}),
+}));
+
+export const postsTable = mssqlTable('posts', {
+	id: int('id').primaryKey().identity().notNull(),
+	content: varchar('content', { length: 100 }).notNull(),
+	ownerId: int('owner_id').references(() => usersTable.id),
+	createdAt: datetime('created_at')
+		.notNull().default(sql`current_timestamp`),
+});
+export const postsConfig = relations(postsTable, ({ one, many }) => ({
+	author: one(usersTable, {
+		fields: [postsTable.ownerId],
+		references: [usersTable.id],
+	}),
+	comments: many(commentsTable),
+}));
+
+export const commentsTable = mssqlTable('comments', {
+	id: int('id').primaryKey().identity().notNull(),
+	content: varchar('content', { length: 100 }).notNull(),
+	creator: int('creator').references(() => usersTable.id),
+	postId: int('post_id').references(() => postsTable.id),
+	createdAt: datetime('created_at')
+		.notNull().default(sql`current_timestamp`),
+});
+export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
+	post: one(postsTable, {
+		fields: [commentsTable.postId],
+		references: [postsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentsTable.creator],
+		references: [usersTable.id],
+	}),
+	likes: many(commentLikesTable),
+}));
+
+export const commentLikesTable = mssqlTable('comment_likes', {
+	id: int('id').primaryKey().identity().notNull(),
+	creator: int('creator').references(() => usersTable.id),
+	commentId: int('comment_id').references(() => commentsTable.id),
+	createdAt: datetime('created_at')
+		.notNull().default(sql`current_timestamp`),
+});
+export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
+	comment: one(commentsTable, {
+		fields: [commentLikesTable.commentId],
+		references: [commentsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentLikesTable.creator],
+		references: [usersTable.id],
+	}),
+}));
diff --git a/integration-tests/tests/mssql/mssql.test.ts b/integration-tests/tests/mssql/mssql.test.ts
new file mode 100644
index 0000000000..2e6e1f4190
--- /dev/null
+++ b/integration-tests/tests/mssql/mssql.test.ts
@@ -0,0 +1,5061 @@
+import {
+	and,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	desc,
+	DrizzleQueryError,
+	eq,
+	getColumns,
+	getTableColumns,
+	gt,
+	gte,
+	inArray,
+	isNull,
+	max,
+	min,
+	Name,
+	sql,
+	sum,
+	sumDistinct,
+	TransactionRollbackError,
+} from 'drizzle-orm';
+import {
+	alias,
+	bit,
+	date,
+	except,
+	foreignKey,
+	getTableConfig,
+	getViewConfig,
+	int,
+	intersect,
+	MsSqlDialect,
+	mssqlTable,
+	mssqlTableCreator,
+	mssqlView,
+	nvarchar,
+	primaryKey,
+	real,
+	text,
+	union,
+	unionAll,
+	unique,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+import { drizzle, type NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';
+import { migrate } from 'drizzle-orm/node-mssql/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { type Equal, Expect } from '~/utils';
+import { test } from './instrumentation';
+import {
+	aggregateTable,
+	allPossibleColumns,
+	citiesSchemaTable,
+	citiesTable,
+	courseCategoriesTable,
+	coursesTable,
+	datesTable,
+	departments,
+	employees,
+	mySchema,
+	nvarcharWithJsonTable,
+	orders,
+	tableWithEnums,
+	users2SchemaTable,
+	users2Table,
+	usersMigratorTable,
+	usersOnUpdate,
+	usersSchemaTable,
+	usersTable,
+} from './schema';
+
+// const ENABLE_LOGGING = true;
+
+test.beforeEach(async ({ client }) => {
+	await client.query(`drop table if exists [userstest]`);
+	await client.query(`drop table if exists [nvarchar_with_json]`);
+	await client.query(`drop table if exists [users2]`);
+	await client.query(`drop table if exists [cities]`);
+	await client.query(`drop table if exists [mySchema].[userstest]`);
+	await client.query(`drop table if exists [mySchema].[users2]`);
+	await client.query(`drop table if exists [mySchema].[cities]`);
+	await client.query(`drop schema if exists [mySchema]`);
+	await client.query(`create schema [mySchema]`);
+	await client.query(`drop table if exists [table_where_is_null];`);
+
+	await client.query(`
+		create table [userstest] (
+			[id] int identity primary key,
+			[name] varchar(30) not null,
+			[verified] bit not null default 0,
+			[jsonb] text,
+			[created_at] datetime not null default current_timestamp
+		)
+`);
+
+	await client.query(`
+		create table [nvarchar_with_json] (
+		[id] int identity primary key,
+		[json] nvarchar(max)
+		);`);
+
+	await client.query(`
+		create table [cities] (
+			[id] int primary key,
+			[name] varchar(30) not null
+		)`);
+
+	await client.query(`
+		create table [users2] (
+			[id] int primary key,
+			[name] varchar(30) not null,
+			[city_id] int null foreign key references [cities]([id])
+		)`);
+
+	await client.query(`
+		create table [mySchema].[userstest] (
+			[id] int identity primary key,
+			[name] varchar(100) not null,
+			[verified] bit not null default 0,
+			[jsonb] nvarchar(100),
+			[created_at] datetime2(2) not null default current_timestamp
+		)`);
+
+	await client.query(`
+		create table [mySchema].[cities] (
+			[id] int identity primary key,
+			[name] varchar(100) not null
+		)`);
+
+	await client.query(`
+		create table [mySchema].[users2] (
+			[id] int identity primary key,
+			[name] varchar(100) not null,
+			[city_id] int references [mySchema].[cities]([id])
+		)`);
+
+	await client.query(`
+		create table [table_where_is_null] (
+			[col1] bit,
+			[col2] varchar(6)
+		)`);
+});
+
+async function setupSetOperationTest(db: NodeMsSqlDatabase<any>) {
+	await db.execute(sql`drop table if exists [users2]`);
+	await db.execute(sql`drop table if exists [cities]`);
+	await db.execute(sql`
+		create table [cities] (
+			[id] int primary key,
+			[name] varchar(30) not null
+		)
+	`);
+
+	await db.execute(sql`
+		create table [users2] (
+			[id] int primary key,
+			[name] varchar(30) not null,
+			[city_id] int foreign key references [cities]([id])
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+}
+
+async function setupAggregateFunctionsTest(db: NodeMsSqlDatabase<any>) {
+	await db.execute(sql`drop table if exists [aggregate_table]`);
+	await db.execute(
+		sql`
+			create table [aggregate_table] (
+				[id] int identity primary key not null,
+				[name] varchar(30) not null,
+				[a] int,
+				[b] int,
+				[c] int,
+				[null_only] int
+			);
+		`,
+	);
+	await db.insert(aggregateTable).values([
+		{ name: 'value 1', a: 5, b: 10, c: 20 },
+		{ name: 'value 1', a: 5, b: 20, c: 30 },
+		{ name: 'value 2', a: 10, b: 50, c: 60 },
+		{ name: 'value 3', a: 20, b: 20, c: null },
+		{ name: 'value 4', a: null, b: 90, c: 120 },
+		{ name: 'value 5', a: 80, b: 10, c: null },
+		{ name: 'value 6', a: null, b: null, c: 150 },
+	]);
+}
+
+test('table config: columns', async () => {
+	const table = mssqlTable(
+		'cities',
+		{
+			id: int().primaryKey().identity(),
+			id1: int().primaryKey().identity({ increment: 2, seed: 3 }),
+		},
+		(t) => [
+			foreignKey({
+				foreignColumns: [t.id],
+				columns: [t.id],
+				name: 'custom_fk',
+			}),
+		],
+	);
+
+	const tableConfig = getTableConfig(table);
+
+	// @ts-ignore
+	// Drizzle ORM gives this value in runtime, but not in types.
+	// After sync with Andrew, we decided to fix this with Dan later
+	// That's due to architecture problems we have in columns and complex abstraction we should avoid
+	// for now we are sure this value is here
+	// If it's undefined - than users didn't provide any identity
+	// If it's an object with seed/increment and a) both are undefined - use default identity startegy
+	// b) some of them have values - use them
+	// Note: you can't have only one value. Either both are undefined or both are defined
+	// console.log(tableConfig.identity);
+
+	expect(tableConfig.foreignKeys).toHaveLength(1);
+	expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
+});
+
+test('table config: foreign keys name', async () => {
+	const table = mssqlTable(
+		'cities',
+		{
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		},
+		(t) => [
+			foreignKey({
+				foreignColumns: [t.id],
+				columns: [t.id],
+				name: 'custom_fk',
+			}),
+		],
+	);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.foreignKeys).toHaveLength(1);
+	expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
+});
+
+test('table config: primary keys name', async () => {
+	const table = mssqlTable(
+		'cities',
+		{
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		},
+		(t) => [primaryKey({ columns: [t.id, t.name] })],
+	);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.primaryKeys).toHaveLength(1);
+	expect(tableConfig.primaryKeys[0]!.getName()).toBe(undefined);
+});
+
+test('table configs: unique third param', async () => {
+	const cities1Table = mssqlTable(
+		'cities1',
+		{
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			state: text('state'),
+		},
+		(t) => [
+			unique().on(t.name, t.state),
+			unique('custom_name1').on(t.name, t.state),
+		],
+	);
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+	expect(tableConfig.uniqueConstraints[0]?.name).toBe(undefined);
+	expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual([
+		'name',
+		'state',
+	]);
+
+	expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
+	expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual([
+		'name',
+		'state',
+	]);
+});
+
+test('table configs: unique in column', async () => {
+	const cities1Table = mssqlTable('cities1', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull().unique('unique_name'),
+		state: text('state').unique('custom'),
+		field: text('field').unique('custom_field'),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+	expect(columnName?.uniqueName).toBe('unique_name');
+	expect(columnName?.isUnique).toBeTruthy();
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	expect(columnState?.uniqueName).toBe('custom');
+	expect(columnState?.isUnique).toBeTruthy();
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	expect(columnField?.uniqueName).toBe('custom_field');
+	expect(columnField?.isUnique).toBeTruthy();
+});
+
+test('select all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+});
+
+test('select sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.select({
+			name: sql`upper(${usersTable.name})`,
+		})
+		.from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select typed sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.select({
+			name: sql<string>`upper(${usersTable.name})`,
+		})
+		.from(usersTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('select distinct', async ({ db }) => {
+	const usersDistinctTable = mssqlTable('users_distinct', {
+		id: int('id').notNull(),
+		name: varchar('name', { length: 30 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+	await db.execute(
+		sql`create table ${usersDistinctTable} (id int, name varchar(30))`,
+	);
+
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const users = await db
+		.selectDistinct()
+		.from(usersDistinctTable)
+		.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+
+	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+	expect(users).toEqual([
+		{ id: 1, name: 'Jane' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+	]);
+});
+
+test('insert returning sql', async ({ db }) => {
+	const result = await db.insert(usersTable).values({ name: 'John' });
+
+	expect(result.rowsAffected[0]).toEqual(1);
+});
+
+test('delete returning sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update returning sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	expect(users.rowsAffected[0]).toBe(1);
+});
+
+test('update with returning all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toBe(1);
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Jane',
+			verified: false,
+			jsonb: null,
+			createdAt: users[0]!.createdAt,
+		},
+	]);
+});
+
+test('update with returning partial', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	const users = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.where(eq(usersTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toEqual(1);
+
+	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+});
+
+test('delete with returning all fields', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db
+		.delete(usersTable)
+		.where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('delete with returning partial', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db
+		.delete(usersTable)
+		.where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	expect(result2).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result2[0]!.createdAt,
+		},
+		{
+			id: 2,
+			name: 'Jane',
+			verified: false,
+			jsonb: null,
+			createdAt: result2[1]!.createdAt,
+		},
+	]);
+});
+
+test('json insert', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+		})
+		.from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test('insert with overridden default values', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: true,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+});
+
+test('insert many', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+			verified: usersTable.verified,
+		})
+		.from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('insert many with returning', async ({ db }) => {
+	const result = await db
+		.insert(usersTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+
+	expect(result.rowsAffected[0]).toBe(4);
+});
+
+test('select with group by as field', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.name)
+		.orderBy(usersTable.name);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('select with group by as sql', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(sql`${usersTable.name}`)
+		.orderBy(usersTable.name);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('$default function', async ({ db }) => {
+	await db.execute(sql`drop table if exists [orders]`);
+	await db.execute(
+		sql`
+			create table [orders] (
+				[id] int primary key,
+				[region] text not null,
+				[product] text not null,
+				[amount] int not null,
+				[quantity] int not null
+			)
+		`,
+	);
+
+	await db
+		.insert(orders)
+		.values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+	const selectedOrder = await db.select().from(orders);
+
+	expect(selectedOrder).toEqual([
+		{
+			id: 1,
+			amount: 1,
+			quantity: 1,
+			region: 'Ukraine',
+			product: 'random_string',
+		},
+	]);
+});
+
+test('$default with empty array', async ({ db }) => {
+	await db.execute(sql`drop table if exists [s_orders]`);
+	await db.execute(
+		sql`
+			create table [s_orders] (
+				[id] int identity primary key,
+				[region] text default ('Ukraine'),
+				[product] text not null
+			)
+		`,
+	);
+
+	const users = mssqlTable('s_orders', {
+		id: int('id').identity().primaryKey(),
+		region: text('region').default('Ukraine'),
+		product: text('product').$defaultFn(() => 'random_string'),
+	});
+
+	await db.insert(users).values({});
+	const selectedOrder = await db.select().from(users);
+
+	expect(selectedOrder).toEqual([
+		{
+			id: 1,
+			region: 'Ukraine',
+			product: 'random_string',
+		},
+	]);
+});
+
+test('select with group by as sql + column', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	expect(result).toEqual([
+		{ name: 'John' },
+		{ name: 'Jane' },
+		{ name: 'Jane' },
+	]);
+});
+
+test('select with group by as column + sql', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	expect(result).toEqual([
+		{ name: 'John' },
+		{ name: 'Jane' },
+		{ name: 'Jane' },
+	]);
+});
+
+test('select with group by complex query', async ({ db }) => {
+	await db
+		.insert(usersTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.offset(0)
+		.fetch(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test('build query', async ({ db }) => {
+	const query = db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `select [id], [name] from [userstest] group by [userstest].[id], [userstest].[name]`,
+		params: [],
+	});
+});
+
+test('Query check: Insert all defaults in 1 row', async ({ db }) => {
+	const users = mssqlTable('users', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	const query = db.insert(users).values({}).toSQL();
+
+	expect(query).toEqual({
+		sql: 'insert into [users] ([name], [state]) values (default, default)',
+		params: [],
+	});
+});
+
+test('Query check: Insert all defaults in multiple rows', async ({ db }) => {
+	const users = mssqlTable('users', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state').default('UA'),
+	});
+
+	const query = db.insert(users).values([{}, {}]).toSQL();
+
+	expect(query).toEqual({
+		sql: 'insert into [users] ([name], [state]) values (default, default), (default, default)',
+		params: [],
+	});
+});
+
+test('Insert all defaults in 1 row', async ({ db }) => {
+	const users = mssqlTable('empty_insert_single', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity primary key, name text default ('Dan'), state text)`,
+	);
+
+	await db.insert(users).values({});
+
+	const res = await db.select().from(users);
+
+	expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
+});
+
+test('Insert all defaults in multiple rows', async ({ db }) => {
+	const users = mssqlTable('empty_insert_multiple', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity primary key, name text default ('Dan'), state text)`,
+	);
+
+	await db.insert(users).values([{}, {}]);
+
+	const res = await db.select().from(users);
+
+	expect(res).toEqual([
+		{ id: 1, name: 'Dan', state: null },
+		{ id: 2, name: 'Dan', state: null },
+	]);
+});
+
+test('insert sql', async ({ db }) => {
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('partial join with alias', async ({ db }) => {
+	const users = mssqlTable('usersForTest', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int primary key, name text not null)`,
+	);
+
+	const customerAlias = alias(users, 'customer');
+
+	await db.insert(users).values([
+		{ id: 10, name: 'Ivan' },
+		{ id: 11, name: 'Hans' },
+	]);
+	const result = await db
+		.select({
+			user: {
+				id: users.id,
+				name: users.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		})
+		.from(users)
+		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([
+		{
+			user: { id: 10, name: 'Ivan' },
+			customer: { id: 11, name: 'Hans' },
+		},
+	]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('full join with alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int primary key, name text not null)`,
+	);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([
+		{ id: 10, name: 'Ivan' },
+		{ id: 11, name: 'Hans' },
+	]);
+	const result = await db
+		.select()
+		.from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([
+		{
+			users: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		},
+	]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('select from alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int primary key, name text not null)`,
+	);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([
+		{ id: 10, name: 'Ivan' },
+		{ id: 11, name: 'Hans' },
+	]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	expect(result).toEqual([
+		{
+			user: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		},
+	]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('insert with spaces', async ({ db }) => {
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable);
+
+	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test('prepared statement', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.orderBy()
+		.prepare();
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('prepared statement reuse', async ({ db }) => {
+	const stmt = db
+		.insert(usersTable)
+		.values({
+			verified: true,
+			name: sql.placeholder('name'),
+		})
+		.prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			verified: usersTable.verified,
+		})
+		.from(usersTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test('prepared statement with placeholder in .where', async ({ db }) => {
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.where(eq(usersTable.id, sql.placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('migrator', async ({ db }) => {
+	await db.execute(sql`drop table if exists cities_migration`);
+	await db.execute(sql`drop table if exists users_migration`);
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists [drizzle].[__drizzle_migrations]`);
+
+	await migrate(db, { migrationsFolder: './drizzle2/mssql' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table if exists cities_migration`);
+	await db.execute(sql`drop table if exists users_migration`);
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table [drizzle].[__drizzle_migrations]`);
+});
+
+test('migrator : --init', async ({ db }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(
+		sql`drop table if exists ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)};`,
+	);
+	await db.execute(
+		sql`drop schema if exists ${sql.identifier(migrationsSchema)};`,
+	);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('cities_migration')}`,
+	);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('users_migration')}`,
+	);
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/mssql',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db
+		.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`
+				.mapWith(Number)
+				.as('created_at'),
+		})
+		.from(
+			sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+		);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT 
+	CASE
+		WHEN EXISTS (
+			SELECT 1
+			FROM INFORMATION_SCHEMA.TABLES
+			WHERE TABLE_SCHEMA = ${getTableConfig(usersMigratorTable).schema ?? 'dbo'} AND TABLE_NAME = ${
+		getTableConfig(usersMigratorTable).name
+	}) 
+		THEN 1 
+		ELSE 0
+	END AS ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res.recordset[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(
+		sql`drop table if exists ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)};`,
+	);
+	await db.execute(
+		sql`drop schema if exists ${sql.identifier(migrationsSchema)};`,
+	);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('cities_migration')}`,
+	);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('users_migration')}`,
+	);
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/mssql-init',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db
+		.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`
+				.mapWith(Number)
+				.as('created_at'),
+		})
+		.from(
+			sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+		);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT 
+	CASE
+		WHEN EXISTS (
+			SELECT 1
+			FROM INFORMATION_SCHEMA.TABLES
+			WHERE TABLE_SCHEMA = ${getTableConfig(usersMigratorTable).schema ?? 'dbo'} AND TABLE_NAME = ${
+		getTableConfig(usersMigratorTable).name
+	}) 
+		THEN 1 
+		ELSE 0
+	END AS ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res.recordset[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(
+		sql`drop table if exists ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)};`,
+	);
+	await db.execute(
+		sql`drop schema if exists ${sql.identifier(migrationsSchema)};`,
+	);
+	await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('cities_migration')}`,
+	);
+	await db.execute(
+		sql`drop table if exists ${sql.identifier('users_migration')}`,
+	);
+
+	await migrate(db, {
+		migrationsFolder: './drizzle2/mssql-init',
+		migrationsSchema,
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db, {
+		migrationsFolder: './drizzle2/mssql',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db
+		.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`
+				.mapWith(Number)
+				.as('created_at'),
+		})
+		.from(
+			sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`,
+		);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT 
+	CASE
+		WHEN EXISTS (
+			SELECT 1
+			FROM INFORMATION_SCHEMA.TABLES
+			WHERE TABLE_SCHEMA = ${getTableConfig(usersMigratorTable).schema ?? 'dbo'} AND TABLE_NAME = ${
+		getTableConfig(usersMigratorTable).name
+	}) 
+		THEN 1 
+		ELSE 0
+	END AS ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(2);
+	expect(!!res.recordset[0]?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = mssqlTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = mssqlTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.execute(sql`drop schema if exists "drizzle";`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/mssql';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE [migration_users] (\n[id] INT PRIMARY KEY,\n[name] text NOT NULL,\n[email] text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE [migration_users] ADD [age] INT;`,
+	);
+
+	await migrate(db, { migrationsFolder: migrationDir });
+	await db.insert(users).values({ id: 1, name: 'John', email: '', age: 30 });
+	const res1 = await db.select().from(users);
+
+	// second migration was not applied yet
+	await expect(
+		db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 }),
+	).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE [migration_users2] (\n[id] INT PRIMARY KEY,\n[name] text NOT NULL,\n[email] text NOT NULL\n,[age] INT\n);`,
+	);
+	await migrate(db, { migrationsFolder: migrationDir });
+
+	await db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 });
+	const res2 = await db.select().from(users2);
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+test('insert via db.execute + select via db.execute', async ({ db }) => {
+	await db.execute(
+		sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`,
+	);
+
+	const result = await db.execute<{ id: number; name: string }>(
+		sql`select id, name from ${usersTable}`,
+	);
+	expect(result.recordset).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('insert via db.execute w/ query builder', async ({ db }) => {
+	const inserted = await db.execute(
+		db.insert(usersTable).values({ name: 'John' }),
+	);
+	expect(inserted.rowsAffected[0]).toBe(1);
+});
+
+test('insert + select all possible dates', async ({ db }) => {
+	await db.execute(sql`drop table if exists [datestable]`);
+	await db.execute(
+		sql`
+			create table [datestable] (
+				[date] date,
+				[date_as_string] date,
+				[time] time,
+				[time_as_string] time,
+				[datetime] datetime,
+				[datetime_as_string] datetime,
+			)
+		`,
+	);
+
+	const date = new Date('2022-11-11');
+
+	await db.insert(datesTable).values({
+		date: date,
+		dateAsString: '2022-11-11',
+		time: date,
+		timeAsString: '12:12:12',
+		datetime: date,
+		datetimeAsString: '2022-11-11 12:12:12',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	expect(res[0]?.date).toBeInstanceOf(Date);
+	expect(res[0]?.datetime).toBeInstanceOf(Date);
+	expect(typeof res[0]?.dateAsString).toBe('string');
+	expect(typeof res[0]?.datetimeAsString).toBe('string');
+
+	expect(res).toEqual([
+		{
+			date: new Date('2022-11-11'),
+			dateAsString: '2022-11-11',
+			time: new Date('1970-01-01T00:00:00Z'),
+			datetime: new Date('2022-11-11'),
+			datetimeAsString: '2022-11-11T12:12:12.000Z',
+			timeAsString: '12:12:12.000',
+		},
+	]);
+
+	await db.execute(sql`drop table if exists [datestable]`);
+});
+
+test('Mssql enum test case #1', async ({ db }) => {
+	await db.execute(sql`drop table if exists [enums_test_case]`);
+
+	await db.execute(sql`
+		create table [enums_test_case] (
+			[id] int primary key,
+			[enum1] text not null,
+			[enum2] text default 'a',
+			[enum3] text not null default 'b'
+		)
+	`);
+
+	const tableWithEnums = mssqlTable('enums_test_case', {
+		id: int('id').primaryKey(),
+		enum1: varchar('enum1', { enum: ['a', 'b', 'c'] }).notNull(),
+		enum2: varchar('enum2', { enum: ['a', 'b', 'c'] }).default('a'),
+		enum3: varchar('enum3', { enum: ['a', 'b', 'c'] })
+			.notNull()
+			.default('b'),
+	});
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	await db.execute(sql`drop table [enums_test_case]`);
+
+	expect(res).toEqual([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test('left join (flat object fields)', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'Paris' },
+		{ id: 2, name: 'London' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane' },
+	]);
+
+	const res = await db
+		.select({
+			userId: users2Table.id,
+			userName: users2Table.name,
+			cityId: citiesTable.id,
+			cityName: citiesTable.name,
+		})
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+	]);
+});
+
+test('left join (grouped fields)', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'Paris' },
+		{ id: 2, name: 'London' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane' },
+	]);
+
+	const res = await db
+		.select({
+			id: users2Table.id,
+			user: {
+				name: users2Table.name,
+				nameUpper: sql<string>`upper(${users2Table.name})`,
+			},
+			city: {
+				id: citiesTable.id,
+				name: citiesTable.name,
+				nameUpper: sql<string>`upper(${citiesTable.name})`,
+			},
+		})
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{
+			id: 1,
+			user: { name: 'John', nameUpper: 'JOHN' },
+			city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+		},
+		{
+			id: 2,
+			user: { name: 'Jane', nameUpper: 'JANE' },
+			city: null,
+		},
+	]);
+});
+
+test('left join (all fields)', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'Paris' },
+		{ id: 2, name: 'London' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane' },
+	]);
+
+	const res = await db
+		.select()
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	expect(res).toEqual([
+		{
+			users2: {
+				id: 1,
+				name: 'John',
+				cityId: 1,
+			},
+			cities: {
+				id: 1,
+				name: 'Paris',
+			},
+		},
+		{
+			users2: {
+				id: 2,
+				name: 'Jane',
+				cityId: null,
+			},
+			cities: null,
+		},
+	]);
+});
+
+test('join subquery', async ({ db }) => {
+	await db.execute(sql`drop table if exists [courses]`);
+	await db.execute(sql`drop table if exists [course_categories]`);
+
+	await db.execute(
+		sql`
+			create table [course_categories] (
+				[id] int identity primary key,
+				[name] varchar(50) not null
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table [courses] (
+				[id] int identity primary key,
+				[name] varchar(50) not null,
+				[category_id] int references [course_categories]([id])
+			)
+		`,
+	);
+
+	await db
+		.insert(courseCategoriesTable)
+		.values([
+			{ name: 'Category 1' },
+			{ name: 'Category 2' },
+			{ name: 'Category 3' },
+			{ name: 'Category 4' },
+		]);
+
+	await db.insert(coursesTable).values([
+		{ name: 'Development', categoryId: 2 },
+		{ name: 'IT & Software', categoryId: 3 },
+		{ name: 'Marketing', categoryId: 4 },
+		{ name: 'Design', categoryId: 1 },
+	]);
+
+	const sq2 = db
+		.select({
+			categoryId: courseCategoriesTable.id,
+			category: courseCategoriesTable.name,
+			total: sql<number>`count(${courseCategoriesTable.id})`.as('count'),
+		})
+		.from(courseCategoriesTable)
+		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+		.as('sq2');
+
+	const res = await db
+		.select({
+			courseName: coursesTable.name,
+			categoryId: sq2.categoryId,
+		})
+		.from(coursesTable)
+		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+		.orderBy(coursesTable.name);
+
+	expect(res).toEqual([
+		{ courseName: 'Design', categoryId: 1 },
+		{ courseName: 'Development', categoryId: 2 },
+		{ courseName: 'IT & Software', categoryId: 3 },
+		{ courseName: 'Marketing', categoryId: 4 },
+	]);
+
+	await db.execute(sql`drop table if exists [courses]`);
+	await db.execute(sql`drop table if exists [course_categories]`);
+});
+
+test('with ... select', async ({ db }) => {
+	await db.execute(sql`drop table if exists [orders]`);
+	await db.execute(
+		sql`
+			create table [orders] (
+				[id] int primary key,
+				[region] varchar(50) not null,
+				[product] varchar(50) not null,
+				[amount] int not null,
+				[quantity] int not null
+			)
+		`,
+	);
+
+	await db.insert(orders).values([
+		{ id: 1, region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+		{ id: 2, region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+		{ id: 3, region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+		{ id: 4, region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+		{ id: 5, region: 'US', product: 'A', amount: 30, quantity: 3 },
+		{ id: 6, region: 'US', product: 'A', amount: 40, quantity: 4 },
+		{ id: 7, region: 'US', product: 'B', amount: 40, quantity: 4 },
+		{ id: 8, region: 'US', product: 'B', amount: 50, quantity: 5 },
+	]);
+
+	const regionalSales = db.$with('regional_sales').as(
+		db
+			.select({
+				region: orders.region,
+				totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+			})
+			.from(orders)
+			.groupBy(orders.region),
+	);
+
+	const topRegions = db.$with('top_regions').as(
+		db
+			.select({
+				region: regionalSales.region,
+			})
+			.from(regionalSales)
+			.where(
+				gt(
+					regionalSales.totalSales,
+					db
+						.select({ sales: sql`sum(${regionalSales.totalSales})/10` })
+						.from(regionalSales),
+				),
+			),
+	);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`cast(sum(${orders.quantity}) as int)`,
+			productSales: sql<number>`cast(sum(${orders.amount}) as int)`,
+		})
+		.from(orders)
+		.where(
+			inArray(
+				orders.region,
+				db.select({ region: topRegions.region }).from(topRegions),
+			),
+		)
+		.groupBy(orders.region, orders.product)
+		.orderBy(orders.region, orders.product);
+
+	expect(result).toEqual([
+		{
+			region: 'Europe',
+			product: 'A',
+			productUnits: 3,
+			productSales: 30,
+		},
+		{
+			region: 'Europe',
+			product: 'B',
+			productUnits: 5,
+			productSales: 50,
+		},
+		{
+			region: 'US',
+			product: 'A',
+			productUnits: 7,
+			productSales: 70,
+		},
+		{
+			region: 'US',
+			product: 'B',
+			productUnits: 9,
+			productSales: 90,
+		},
+	]);
+});
+
+test('select from subquery sql', async ({ db }) => {
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'Jane' },
+	]);
+
+	const sq = db
+		.select({
+			name: sql<string>`concat(${users2Table.name}, ' modified')`.as('name'),
+		})
+		.from(users2Table)
+		.as('sq');
+
+	const res = await db.select({ name: sq.name }).from(sq);
+
+	expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test('select a field without joining its table', ({ db }) => {
+	expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+});
+
+test('select all fields from subquery without alias', ({ db }) => {
+	const sq = db
+		.$with('sq')
+		.as(
+			db
+				.select({ name: sql<string>`upper(${users2Table.name})` })
+				.from(users2Table),
+		);
+
+	expect(() => db.select().from(sq).prepare()).toThrowError();
+});
+
+test('sql.Aliased in cte', async ({ db }) => {
+	const users = mssqlTable('users_109_sqla', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`DROP TABLE IF EXISTS ${users}`);
+	await db.execute(sql`CREATE TABLE ${users} (
+		id INT PRIMARY KEY,
+		name TEXT NOT NULL
+	)`);
+	await db.insert(users).values([
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'Jane' },
+	]);
+
+	const sq1 = db.$with('sq1').as((qb) =>
+		qb
+			.select({
+				aliased: sql`count(*)`.mapWith(Number).as('alias'),
+			})
+			.from(users)
+	);
+	const sq2 = db.$with('sq2').as((qb) =>
+		qb
+			.select({
+				aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+			})
+			.from(users)
+	);
+
+	const result = await db
+		.with(sq1, sq2)
+		.select({
+			count: sq1.aliased,
+			sum: sq2.aliased,
+		})
+		.from(sq1)
+		.innerJoin(sq2, sql`1 = 1`);
+
+	expect(result).toEqual([{ count: 2, sum: 3 }]);
+
+	const result2 = await db
+		.with(sq1)
+		.select({
+			count: sq1.aliased,
+		})
+		.from(sq1)
+		.groupBy(sq1.aliased)
+		.orderBy(sq1.aliased);
+
+	expect(result2).toEqual([{ count: 2 }]);
+});
+
+test('select count()', async ({ db }) => {
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+	expect(res).toEqual([{ count: 2 }]);
+});
+
+test('having', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'London' },
+		{ id: 2, name: 'Paris' },
+		{
+			id: 3,
+			name: 'New York',
+		},
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 2 },
+	]);
+
+	const result = await db
+		.select({
+			id: citiesTable.id,
+			name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+			usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+		})
+		.from(citiesTable)
+		.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+		.where(({ name }) => sql`len(${name}) >= 3`)
+		.groupBy(citiesTable.id, citiesTable.name)
+		.having(({ usersCount }) => sql`${usersCount} > 0`)
+		.orderBy(({ name }) => name);
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'LONDON',
+			usersCount: 2,
+		},
+		{
+			id: 2,
+			name: 'PARIS',
+			usersCount: 1,
+		},
+	]);
+});
+
+test('view', async ({ db }) => {
+	const newYorkers1 = mssqlView('new_yorkers').as((qb) =>
+		qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+	);
+
+	const newYorkers2 = mssqlView('new_yorkers', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+	const newYorkers3 = mssqlView('new_yorkers', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).existing();
+
+	await db.execute(
+		sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'Paris' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db
+			.select({ name: newYorkers1.name })
+			.from(newYorkers1);
+		expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test('select from raw sql', async ({ db }) => {
+	const result = await db
+		.select({
+			id: sql<number>`id`,
+			name: sql<string>`name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name) as users`);
+
+	Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('select from raw sql with joins', async ({ db }) => {
+	const result = await db
+		.select({
+			id: sql<number>`users.id`,
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(
+			sql`(select 1 as id, 'Paris' as name) as cities`,
+			sql`cities.id = users.id`,
+		);
+
+	Expect<
+		Equal<
+			{ id: number; name: string; userCity: string; cityName: string }[],
+			typeof result
+		>
+	>;
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+	]);
+});
+
+test('join on aliased sql from select', async ({ db }) => {
+	const result = await db
+		.select({
+			userId: sql<number>`users.id`.as('userId'),
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityId: sql<number>`cities.id`.as('cityId'),
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<
+		Equal<
+			{
+				userId: number;
+				name: string;
+				userCity: string;
+				cityId: number;
+				cityName: string;
+			}[],
+			typeof result
+		>
+	>;
+
+	expect(result).toEqual([
+		{
+			userId: 1,
+			name: 'John',
+			userCity: 'New York',
+			cityId: 1,
+			cityName: 'Paris',
+		},
+	]);
+});
+
+test('join on aliased sql from with clause', async ({ db }) => {
+	const users = db.$with('users').as(
+		db
+			.select({
+				id: sql<number>`id`.as('userId'),
+				name: sql<string>`name`.as('userName'),
+				city: sql<string>`city`.as('city'),
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`),
+	);
+
+	const cities = db.$with('cities').as(
+		db
+			.select({
+				id: sql<number>`id`.as('cityId'),
+				name: sql<string>`name`.as('cityName'),
+			})
+			.from(sql`(select 1 as id, 'Paris' as name) as cities`),
+	);
+
+	const result = await db
+		.with(users, cities)
+		.select({
+			userId: users.id,
+			name: users.name,
+			userCity: users.city,
+			cityId: cities.id,
+			cityName: cities.name,
+		})
+		.from(users)
+		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<
+		Equal<
+			{
+				userId: number;
+				name: string;
+				userCity: string;
+				cityId: number;
+				cityName: string;
+			}[],
+			typeof result
+		>
+	>;
+
+	expect(result).toEqual([
+		{
+			userId: 1,
+			name: 'John',
+			userCity: 'New York',
+			cityId: 1,
+			cityName: 'Paris',
+		},
+	]);
+});
+
+test('prefixed table', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `myprefix_${name}`);
+
+	const users = mssqlTable('test_prefixed_table_with_unique_name', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
+	);
+
+	await db.insert(users).values({ id: 1, name: 'John' });
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('orderBy with aliased column', ({ db }) => {
+	const query = db
+		.select({
+			test: sql`something`.as('test'),
+		})
+		.from(users2Table)
+		.orderBy((fields) => fields.test)
+		.toSQL();
+
+	expect(query.sql).toEqual(
+		'select something as [test] from [users2] order by [test]',
+	);
+});
+
+test('timestamp timezone', async ({ db }) => {
+	const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+	await db.insert(usersTable).values({ name: 'With default times' });
+	await db.insert(usersTable).values({
+		name: 'Without default times',
+		createdAt: date,
+	});
+	const users = await db.select().from(usersTable);
+
+	// check that the timestamps are set correctly for default times
+	expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(
+		2000,
+	);
+
+	// check that the timestamps are set correctly for non default times
+	expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(
+		2000,
+	);
+});
+
+test('transaction', async ({ db }) => {
+	const users = mssqlTable('users_transactions', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+	const products = mssqlTable('products_transactions', {
+		id: int('id').identity().primaryKey(),
+		price: int('price').notNull(),
+		stock: int('stock').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${products}`);
+
+	await db.execute(
+		sql`create table users_transactions (id int identity not null primary key, balance int not null)`,
+	);
+	await db.execute(
+		sql`create table products_transactions (id int identity not null primary key, price int not null, stock int not null)`,
+	);
+
+	await db.insert(users).values({ balance: 100 });
+	const user = await db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.then((rows) => rows[0]!);
+	await db.insert(products).values({ price: 10, stock: 10 });
+	const product = await db
+		.select()
+		.from(products)
+		.where(eq(products.id, 1))
+		.then((rows) => rows[0]!);
+
+	await db.transaction(async (tx) => {
+		await tx
+			.update(users)
+			.set({ balance: user.balance - product.price })
+			.where(eq(users.id, user.id));
+		await tx
+			.update(products)
+			.set({ stock: product.stock - 1 })
+			.where(eq(products.id, product.id));
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 90 }]);
+
+	await db.execute(sql`drop table ${users}`);
+	await db.execute(sql`drop table ${products}`);
+});
+
+test('transaction - set isolation level', async ({ db }) => {
+	const users = mssqlTable('users_transactions', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+	const products = mssqlTable('products_transactions', {
+		id: int('id').identity().primaryKey(),
+		price: int('price').notNull(),
+		stock: int('stock').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${products}`);
+
+	await db.execute(
+		sql`create table users_transactions (id int identity not null primary key, balance int not null)`,
+	);
+	await db.execute(
+		sql`create table products_transactions (id int identity not null primary key, price int not null, stock int not null)`,
+	);
+
+	await db.insert(users).values({ balance: 100 });
+	const user = await db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.then((rows) => rows[0]!);
+	await db.insert(products).values({ price: 10, stock: 10 });
+	const product = await db
+		.select()
+		.from(products)
+		.where(eq(products.id, 1))
+		.then((rows) => rows[0]!);
+
+	await db.transaction(async (tx) => {
+		await tx
+			.update(users)
+			.set({ balance: user.balance - product.price })
+			.where(eq(users.id, user.id));
+		await tx
+			.update(products)
+			.set({ stock: product.stock - 1 })
+			.where(eq(products.id, product.id));
+	}, {
+		isolationLevel: 'read committed',
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 90 }]);
+
+	await db.execute(sql`drop table ${users}`);
+	await db.execute(sql`drop table ${products}`);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5328
+test('transaction #2', async ({ url2 }) => {
+	const db = drizzle(url2);
+	await db.transaction(async (tx) => {
+		await tx.execute('select 1;');
+	});
+});
+
+test('transaction rollback', async ({ db }) => {
+	const users = mssqlTable('users_transactions_rollback', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table users_transactions_rollback (id int identity not null primary key, balance int not null)`,
+	);
+
+	await expect(
+		(async () => {
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 });
+				tx.rollback();
+			});
+		})(),
+	).rejects.toThrowError(TransactionRollbackError);
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('nested transaction', async ({ db }) => {
+	const users = mssqlTable('users_nested_transactions', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table users_nested_transactions (id int identity not null primary key, balance int not null)`,
+	);
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await tx.transaction(async (tx) => {
+			await tx.update(users).set({ balance: 200 });
+		});
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 200 }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('nested transaction rollback', async ({ db }) => {
+	const users = mssqlTable('users_nested_transactions_rollback', {
+		id: int('id').identity().primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table users_nested_transactions_rollback (id int identity not null primary key, balance int not null)`,
+	);
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await expect(
+			(async () => {
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 });
+					tx.rollback();
+				});
+			})(),
+		).rejects.toThrowError(TransactionRollbackError);
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 100 }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('join subquery with join', async ({ db }) => {
+	const internalStaff = mssqlTable('internal_staff', {
+		userId: int('user_id').notNull(),
+	});
+
+	const customUser = mssqlTable('custom_user', {
+		id: int('id').notNull(),
+	});
+
+	const ticket = mssqlTable('ticket', {
+		staffId: int('staff_id').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${internalStaff}`);
+	await db.execute(sql`drop table if exists ${customUser}`);
+	await db.execute(sql`drop table if exists ${ticket}`);
+
+	await db.execute(sql`create table internal_staff (user_id integer not null)`);
+	await db.execute(sql`create table custom_user (id integer not null)`);
+	await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+	await db.insert(internalStaff).values({ userId: 1 });
+	await db.insert(customUser).values({ id: 1 });
+	await db.insert(ticket).values({ staffId: 1 });
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+		.as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	expect(mainQuery).toEqual([
+		{
+			ticket: { staffId: 1 },
+			internal_staff: {
+				internal_staff: { userId: 1 },
+				custom_user: { id: 1 },
+			},
+		},
+	]);
+
+	await db.execute(sql`drop table ${internalStaff}`);
+	await db.execute(sql`drop table ${customUser}`);
+	await db.execute(sql`drop table ${ticket}`);
+});
+
+test('subquery with view', async ({ db }) => {
+	const users = mssqlTable('users_subquery_view', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mssqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(
+		sql`create view ${newYorkers} as select * from ${users} where city_id = 1`,
+	);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.$with('sq').as(db.select().from(newYorkers));
+	const result = await db.with(sq).select().from(sq);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 1 },
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('join view as subquery', async ({ db }) => {
+	const users = mssqlTable('users_join_view', {
+		id: int('id').identity().primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mssqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(
+		sql`create view ${newYorkers} as select * from ${users} where city_id = 1`,
+	);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+	const result = await db
+		.select()
+		.from(users)
+		.leftJoin(sq, eq(users.id, sq.id));
+
+	expect(result).toEqual([
+		{
+			users_join_view: { id: 1, name: 'John', cityId: 1 },
+			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+		{
+			users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('select iterator', async ({ db }) => {
+	const users = mssqlTable('users_iterator', {
+		id: int('id').identity().primaryKey(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key)`,
+	);
+
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+
+	const iter = db.select().from(users).iterator();
+	const result: (typeof users.$inferSelect)[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test('select iterator w/ prepared statement', async ({ db }) => {
+	const users = mssqlTable('users_iterator', {
+		id: int('id').identity({ increment: 1, seed: 1 }).primaryKey(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key)`,
+	);
+
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+	await db.insert(users).values({});
+
+	const prepared = db.select().from(users).prepare();
+	const iter = prepared.iterator();
+	const result: (typeof users.$inferSelect)[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test('insert undefined', async ({ db }) => {
+	const users = mssqlTable('usersForTests', {
+		id: int('id').identity().primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int identity not null primary key, name text)`,
+	);
+
+	await expect(
+		(async () => {
+			await db.insert(users).values({ name: undefined });
+		})(),
+	).resolves.not.toThrowError();
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('update undefined', async ({ db }) => {
+	const users = mssqlTable('usersForTests', {
+		id: int('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id int not null primary key, name text)`,
+	);
+
+	await expect(
+		(async () => {
+			await db.update(users).set({ name: undefined });
+		})(),
+	).rejects.toThrowError();
+
+	await expect(
+		(async () => {
+			await db.update(users).set({ id: 1, name: undefined });
+		})(),
+	).resolves.not.toThrowError();
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('update with placeholder', async ({ db }) => {
+	const users = mssqlTable('userstest_update_p', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: bit('verified').notNull().default(false),
+	});
+
+	await db.execute(sql`drop table if exists ${users};`);
+	await db.execute(sql`create table ${users} (
+				[id] int primary key,
+				[name] text not null,
+				[verified] bit not null default 0
+			);`);
+
+	await db.insert(users).values([
+		{ id: 1, name: 'Barry', verified: false },
+		{ id: 2, name: 'Alan', verified: false },
+		{ id: 3, name: 'Carl', verified: false },
+	]);
+
+	await db
+		.update(users)
+		.set({ verified: sql.placeholder('verified') })
+		.execute({
+			verified: true,
+		});
+
+	const result = await db
+		.select({ name: users.name, verified: users.verified })
+		.from(users)
+		.orderBy(asc(users.id));
+	expect(result).toStrictEqual([
+		{ name: 'Barry', verified: true },
+		{ name: 'Alan', verified: true },
+		{ name: 'Carl', verified: true },
+	]);
+});
+
+// test('utc config for datetime', async ({ db }) => {
+//
+//
+// 	await db.execute(sql`drop table if exists [datestable]`);
+// 	await db.execute(
+// 		sql`
+// 			create table [datestable] (
+// 				[datetime_utc] datetime,
+// 				[datetime] datetime,
+// 				[datetime_as_string] datetime
+// 			)
+// 		`,
+// 	);
+// 	const datesTable = mssqlTable('datestable', {
+// 		datetimeUTC: datetime('datetime_utc', { mode: 'date' }),
+// 		datetime: datetime('datetime'),
+// 		datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+// 	});
+//
+// 	const dateObj = new Date('2022-11-11');
+// 	const dateUtc = new Date('2022-11-11T12:12:12.122Z');
+//
+// 	await db.insert(datesTable).values({
+// 		datetimeUTC: dateUtc,
+// 		datetime: dateObj,
+// 		datetimeAsString: '2022-11-11 12:12:12',
+// 	});
+//
+// 	const res = await db.select().from(datesTable);
+//
+// 	const rawSelect = await db.execute(sql`select [datetime_utc] from [datestable]`);
+// 	const selectedRow = rawSelect.recordset[0];
+//
+// 	expect(selectedRow.datetime_utc).toBe('2022-11-11 12:12:12.122');
+// 	expect(new Date(selectedRow.datetime_utc.replace(' ').toEqual('T') + 'Z'), dateUtc);
+//
+// 	t.assert(res[0]?.datetime instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+// 	t.assert(res[0]?.datetimeUTC instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+// 	t.assert(typeof res[0]?.datetimeAsString === 'string');
+//
+// 	expect(res).toEqual([{
+// 		datetimeUTC: dateUtc,
+// 		datetime: new Date('2022-11-11'),
+// 		datetimeAsString: '2022-11-11 12:12:12',
+// 	}]);
+//
+// 	await db.execute(sql`drop table if exists [datestable]`);
+// });
+
+test('set operations (union) from query builder with subquery', async ({ db }) => {
+	await setupSetOperationTest(db);
+	const sq = db
+		.select({ id: users2Table.id, name: users2Table.name })
+		.from(users2Table)
+		.as('sq');
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable)
+		.union(db.select().from(sq))
+		.orderBy(asc(citiesTable.name))
+		.offset(0)
+		.fetch(8);
+
+	expect(result).toHaveLength(8);
+
+	expect(result).toEqual([
+		{ id: 5, name: 'Ben' },
+		{ id: 3, name: 'Jack' },
+		{ id: 2, name: 'Jane' },
+		{ id: 6, name: 'Jill' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'London' },
+		{ id: 7, name: 'Mary' },
+		{ id: 1, name: 'New York' },
+	]);
+
+	// union should throw if selected fields are not in the same order
+	await expect(
+		(async () => {
+			db.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.union(
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table),
+				);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (union) as function', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await union(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable)
+			.where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+	).orderBy(sql`name`);
+
+	expect(result).toHaveLength(2);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'New York' },
+	]);
+
+	await expect(
+		(async () => {
+			union(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (union all) from query builder', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable)
+		.unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable),
+		)
+		.orderBy(asc(citiesTable.id))
+		.offset(1)
+		.fetch(5);
+
+	expect(result).toHaveLength(5);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await expect(
+		(async () => {
+			db.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.unionAll(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable),
+				)
+				.orderBy(asc(sql`id`));
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (union all) as function', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await unionAll(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable)
+			.where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+	)
+		.orderBy(citiesTable.id)
+		.offset(0)
+		.fetch(1);
+
+	expect(result).toHaveLength(1);
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+	await expect(
+		(async () => {
+			unionAll(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			)
+				.orderBy(citiesTable.id)
+				.offset(0)
+				.fetch(1);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (intersect) from query builder', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable)
+		.intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.where(gt(citiesTable.id, 1)),
+		);
+
+	expect(result).toHaveLength(2);
+
+	expect(result).toEqual([
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await expect(
+		(async () => {
+			db.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable)
+				.intersect(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable)
+						.where(gt(citiesTable.id, 1)),
+				);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (intersect) as function', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await intersect(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable)
+			.where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+	)
+		.orderBy(citiesTable.id)
+		.offset(0)
+		.fetch(1);
+
+	expect(result).toHaveLength(0);
+
+	expect(result).toEqual([]);
+
+	await expect(
+		(async () => {
+			intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			)
+				.orderBy(citiesTable.id)
+				.offset(0)
+				.fetch(1);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (except) from query builder', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await db
+		.select()
+		.from(citiesTable)
+		.except(db.select().from(citiesTable).where(gt(citiesTable.id, 1)));
+
+	expect(result).toHaveLength(1);
+
+	expect(result).toEqual([{ id: 1, name: 'New York' }]);
+});
+
+test('set operations (except) as function', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await except(
+		db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable),
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable)
+			.where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+	)
+		.orderBy(citiesTable.id)
+		.offset(0)
+		.fetch(3);
+
+	expect(result).toHaveLength(2);
+
+	expect(result).toEqual([
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await expect(
+		(async () => {
+			except(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable),
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			)
+				.orderBy(citiesTable.id)
+				.offset(0)
+				.fetch(3);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (mixed) from query builder', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const result = await db
+		.select()
+		.from(citiesTable)
+		.except(({ unionAll }) =>
+			unionAll(
+				db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+				db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+			)
+		);
+
+	expect(result).toHaveLength(1);
+
+	expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+	await expect(
+		(async () => {
+			db.select()
+				.from(citiesTable)
+				.except(({ unionAll }) =>
+					unionAll(
+						db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+						db
+							.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable)
+							.where(eq(citiesTable.id, 2)),
+					)
+				);
+		})(),
+	).rejects.toThrowError();
+});
+
+test('set operations (mixed all) as function with subquery', async ({ db }) => {
+	await setupSetOperationTest(db);
+
+	const sq = union(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table)
+			.where(eq(users2Table.id, 1)),
+		except(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table)
+				.where(gte(users2Table.id, 5)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table)
+				.where(eq(users2Table.id, 7)),
+		),
+		db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+	).as('sq');
+
+	const result = await db.select().from(sq).orderBy(sq.id).offset(1).fetch(4);
+
+	expect(result).toHaveLength(4);
+
+	expect(result).toEqual([
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+	]);
+
+	await expect(
+		(async () => {
+			union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				except(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(gte(users2Table.id, 5)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 7)),
+				),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(citiesTable)
+					.where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+		})(),
+	).rejects.toThrowError();
+});
+
+test('test $onUpdateFn and $onUpdate works as $default', async ({ db }) => {
+	await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+	await db.execute(
+		sql`
+			create table ${usersOnUpdate} (
+			id int identity not null primary key,
+			[name] text not null,
+			update_counter integer default 1 not null,
+			updated_at datetime,
+			always_null text
+			)
+		`,
+	);
+
+	await db
+		.insert(usersOnUpdate)
+		.values([
+			{ name: 'John' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+	const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+	const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+	const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+	expect(response).toEqual([
+		{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+		{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+		{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+		{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+	]);
+	const msDelay = 250;
+
+	for (const eachUser of justDates) {
+		expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+	}
+});
+
+test('test $onUpdateFn and $onUpdate works updating', async ({ db }) => {
+	await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+	await db.execute(
+		sql`
+			create table ${usersOnUpdate} (
+			id int identity not null primary key,
+			[name] text not null,
+			update_counter integer default 1 not null,
+			updated_at datetime,
+			always_null text
+			)
+		`,
+	);
+
+	await db
+		.insert(usersOnUpdate)
+		.values([
+			{ name: 'John', alwaysNull: 'this will will be null after updating' },
+			{ name: 'Jane' },
+			{ name: 'Jack' },
+			{ name: 'Jill' },
+		]);
+
+	const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+	const initial = await db.select({ updatedAt }).from(usersOnUpdate);
+
+	await db
+		.update(usersOnUpdate)
+		.set({ name: 'Angel' })
+		.where(eq(usersOnUpdate.id, 1));
+
+	const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+	const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+	expect(response).toEqual([
+		{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+		{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+		{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+		{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+	]);
+	const msDelay = 250;
+
+	expect(initial[0]?.updatedAt?.valueOf()).not.toEqual(
+		justDates[0]?.updatedAt?.valueOf(),
+	);
+
+	for (const eachUser of justDates) {
+		expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
+	}
+});
+
+test('aggregate function: count', async ({ db }) => {
+	const table = aggregateTable;
+	await setupAggregateFunctionsTest(db);
+
+	const result1 = await db.select({ value: count() }).from(table);
+	const result2 = await db.select({ value: count(table.a) }).from(table);
+	const result3 = await db
+		.select({ value: countDistinct(table.name) })
+		.from(table);
+
+	expect(result1[0]?.value).toEqual(7);
+	expect(result2[0]?.value).toEqual(5);
+	expect(result3[0]?.value).toEqual(6);
+});
+
+test('aggregate function: avg', async ({ db }) => {
+	const table = aggregateTable;
+	await setupAggregateFunctionsTest(db);
+
+	const result1 = await db.select({ value: avg(table.b) }).from(table);
+	const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
+	const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
+
+	expect(result1[0]?.value).toEqual('33');
+	expect(result2[0]?.value).toEqual(null);
+	expect(result3[0]?.value).toEqual('42');
+});
+
+test('aggregate function: sum', async ({ db }) => {
+	const table = aggregateTable;
+	await setupAggregateFunctionsTest(db);
+
+	const result1 = await db.select({ value: sum(table.b) }).from(table);
+	const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
+	const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
+
+	expect(result1[0]?.value).toEqual('200');
+	expect(result2[0]?.value).toEqual(null);
+	expect(result3[0]?.value).toEqual('170');
+});
+
+test('aggregate function: max', async ({ db }) => {
+	const table = aggregateTable;
+	await setupAggregateFunctionsTest(db);
+
+	const result1 = await db.select({ value: max(table.b) }).from(table);
+	const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
+
+	expect(result1[0]?.value).toEqual(90);
+	expect(result2[0]?.value).toEqual(null);
+});
+
+test('aggregate function: min', async ({ db }) => {
+	const table = aggregateTable;
+	await setupAggregateFunctionsTest(db);
+
+	const result1 = await db.select({ value: min(table.b) }).from(table);
+	const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
+
+	expect(result1[0]?.value).toEqual(10);
+	expect(result2[0]?.value).toEqual(null);
+});
+
+test('mySchema :: select all fields', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const result = await db.select().from(usersSchemaTable);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+});
+
+test('mySchema :: select sql', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const users = await db
+		.select({
+			name: sql`upper(${usersSchemaTable.name})`,
+		})
+		.from(usersSchemaTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('mySchema :: select typed sql', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const users = await db
+		.select({
+			name: sql<string>`upper(${usersSchemaTable.name})`,
+		})
+		.from(usersSchemaTable);
+
+	expect(users).toEqual([{ name: 'JOHN' }]);
+});
+
+test('mySchema :: select distinct', async ({ db }) => {
+	const usersDistinctTable = mssqlTable('users_distinct', {
+		id: int('id').notNull(),
+		name: varchar('name', { length: 30 }).notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+	await db.execute(
+		sql`create table ${usersDistinctTable} (id int, name varchar(30))`,
+	);
+
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const users = await db
+		.selectDistinct()
+		.from(usersDistinctTable)
+		.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+
+	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+	expect(users).toEqual([
+		{ id: 1, name: 'Jane' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+	]);
+});
+
+test('mySchema :: insert returning sql', async ({ db }) => {
+	const result = await db.insert(usersSchemaTable).values({ name: 'John' });
+
+	expect(result.rowsAffected[0]).toEqual(1);
+});
+
+test('mySchema :: delete returning sql', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const result = await db
+		.delete(usersSchemaTable)
+		.where(eq(usersTable.name, 'John'));
+
+	expect(result.rowsAffected[0]).toBe(1);
+});
+
+test('mySchema :: update returning sql', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const result = await db
+		.update(usersSchemaTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	expect(result.rowsAffected[0]).toBe(1);
+});
+
+test('mySchema :: update with returning all fields', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const updatedUsers = await db
+		.update(usersSchemaTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	const users = await db
+		.select()
+		.from(usersSchemaTable)
+		.where(eq(usersTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toBe(1);
+
+	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Jane',
+			verified: false,
+			jsonb: null,
+			createdAt: users[0]!.createdAt,
+		},
+	]);
+});
+
+test('mySchema :: update with returning partial', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const updatedUsers = await db
+		.update(usersSchemaTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'));
+
+	const users = await db
+		.select({ id: usersSchemaTable.id, name: usersTable.name })
+		.from(usersSchemaTable)
+		.where(eq(usersSchemaTable.id, 1));
+
+	expect(updatedUsers.rowsAffected[0]).toBe(1);
+
+	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+});
+
+test('mySchema :: delete with returning all fields', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const deletedUser = await db
+		.delete(usersSchemaTable)
+		.where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('mySchema :: delete with returning partial', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const deletedUser = await db
+		.delete(usersSchemaTable)
+		.where(eq(usersTable.name, 'John'));
+
+	expect(deletedUser.rowsAffected[0]).toBe(1);
+});
+
+test('mySchema :: insert + select', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const result = await db.select().from(usersSchemaTable);
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+
+	await db.insert(usersSchemaTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersSchemaTable);
+	expect(result2).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: false,
+			jsonb: null,
+			createdAt: result2[0]!.createdAt,
+		},
+		{
+			id: 2,
+			name: 'Jane',
+			verified: false,
+			jsonb: null,
+			createdAt: result2[1]!.createdAt,
+		},
+	]);
+});
+
+test('mySchema :: json insert', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db
+		.select({
+			id: usersSchemaTable.id,
+			name: usersSchemaTable.name,
+			jsonb: usersSchemaTable.jsonb,
+		})
+		.from(usersSchemaTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test('mySchema :: insert with overridden default values', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersSchemaTable);
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'John',
+			verified: true,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		},
+	]);
+});
+
+test('mySchema :: insert many', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+	const result = await db
+		.select({
+			id: usersSchemaTable.id,
+			name: usersSchemaTable.name,
+			jsonb: usersSchemaTable.jsonb,
+			verified: usersSchemaTable.verified,
+		})
+		.from(usersSchemaTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test('mySchema :: insert many with returning', async ({ db }) => {
+	const result = await db
+		.insert(usersSchemaTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+
+	expect(result.rowsAffected[0]).toBe(4);
+});
+
+test('mySchema :: select with group by as field', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(usersSchemaTable.name);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('mySchema :: select with group by as sql', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(sql`${usersSchemaTable.name}`);
+
+	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test('mySchema :: select with group by as sql + column', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(sql`${usersSchemaTable.name}`, usersSchemaTable.id);
+
+	expect(result).toEqual([
+		{ name: 'John' },
+		{ name: 'Jane' },
+		{ name: 'Jane' },
+	]);
+});
+
+test('mySchema :: select with group by as column + sql', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(usersSchemaTable.id, sql`${usersSchemaTable.name}`);
+
+	expect(result).toEqual([
+		{ name: 'John' },
+		{ name: 'Jane' },
+		{ name: 'Jane' },
+	]);
+});
+
+test('mySchema :: select with group by complex query', async ({ db }) => {
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(usersSchemaTable.id, sql`${usersSchemaTable.name}`)
+		.orderBy(asc(usersSchemaTable.name))
+		.offset(0)
+		.fetch(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test('mySchema :: build query', async ({ db }) => {
+	const query = db
+		.select({ id: usersSchemaTable.id, name: usersSchemaTable.name })
+		.from(usersSchemaTable)
+		.groupBy(usersSchemaTable.id, usersSchemaTable.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			`select [id], [name] from [mySchema].[userstest] group by [mySchema].[userstest].[id], [mySchema].[userstest].[name]`,
+		params: [],
+	});
+});
+
+test('mySchema :: insert sql', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: sql`${'John'}` });
+	const result = await db
+		.select({ id: usersSchemaTable.id, name: usersSchemaTable.name })
+		.from(usersSchemaTable);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('mySchema :: partial join with alias', async ({ db }) => {
+	const customerAlias = alias(usersSchemaTable, 'customer');
+
+	await db
+		.insert(usersSchemaTable)
+		.values([{ name: 'Ivan' }, { name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersSchemaTable.id,
+				name: usersSchemaTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		})
+		.from(usersSchemaTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 2))
+		.where(eq(usersSchemaTable.id, 1));
+
+	expect(result).toEqual([
+		{
+			user: { id: 1, name: 'Ivan' },
+			customer: { id: 2, name: 'Hans' },
+		},
+	]);
+});
+
+test('mySchema :: full join with alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int primary key, name text not null)`,
+	);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([
+		{ id: 10, name: 'Ivan' },
+		{ id: 11, name: 'Hans' },
+	]);
+	const result = await db
+		.select()
+		.from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([
+		{
+			users: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		},
+	]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('mySchema :: select from alias', async ({ db }) => {
+	const mssqlTable = mssqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mssqlTable('users', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(
+		sql`create table ${users} (id int primary key, name text not null)`,
+	);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([
+		{ id: 10, name: 'Ivan' },
+		{ id: 11, name: 'Hans' },
+	]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	expect(result).toEqual([
+		{
+			user: {
+				id: 10,
+				name: 'Ivan',
+			},
+			customer: {
+				id: 11,
+				name: 'Hans',
+			},
+		},
+	]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test('mySchema :: insert with spaces', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db
+		.select({ id: usersSchemaTable.id, name: usersSchemaTable.name })
+		.from(usersSchemaTable);
+
+	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test('mySchema :: prepared statement', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const statement = db
+		.select({
+			id: usersSchemaTable.id,
+			name: usersSchemaTable.name,
+		})
+		.from(usersSchemaTable)
+		.prepare();
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('mySchema :: prepared statement reuse', async ({ db }) => {
+	const stmt = db
+		.insert(usersSchemaTable)
+		.values({
+			verified: true,
+			name: sql.placeholder('name'),
+		})
+		.prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db
+		.select({
+			id: usersSchemaTable.id,
+			name: usersSchemaTable.name,
+			verified: usersSchemaTable.verified,
+		})
+		.from(usersSchemaTable);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test('mySchema :: prepared statement with placeholder in .where', async ({ db }) => {
+	await db.insert(usersSchemaTable).values({ name: 'John' });
+	const stmt = db
+		.select({
+			id: usersSchemaTable.id,
+			name: usersSchemaTable.name,
+		})
+		.from(usersSchemaTable)
+		.where(eq(usersSchemaTable.id, sql.placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('mySchema :: insert via db.execute + select via db.execute', async ({ db }) => {
+	await db.execute(
+		sql`insert into ${usersSchemaTable} (${new Name(usersTable.name.name)}) values (${'John'})`,
+	);
+
+	const result = await db.execute<{ id: number; name: string }>(
+		sql`select id, name from ${usersSchemaTable}`,
+	);
+	expect(result.recordset).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test('mySchema :: insert via db.execute w/ query builder', async ({ db }) => {
+	const inserted = await db.execute(
+		db.insert(usersSchemaTable).values({ name: 'John' }),
+	);
+	expect(inserted.rowsAffected[0]).toBe(1);
+});
+
+test('mySchema :: select from tables with same name from different schema using alias', async ({ db }) => {
+	await db.execute(sql`drop table if exists [userstest]`);
+	await db.execute(
+		sql`
+			create table [userstest] (
+				[id] int identity primary key,
+				[name] varchar(100) not null,
+				[verified] bit not null default 0,
+				[jsonb] nvarchar(100),
+				[created_at] datetime2(2) not null default current_timestamp
+			)
+		`,
+	);
+
+	await db.insert(usersSchemaTable).values({ name: 'Ivan' });
+	await db.insert(usersTable).values({ name: 'Hans' });
+
+	const customerAlias = alias(usersTable, 'customer');
+
+	const result = await db
+		.select()
+		.from(usersSchemaTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 1))
+		.where(eq(usersSchemaTable.id, 1));
+
+	expect(result).toEqual([
+		{
+			userstest: {
+				id: 1,
+				name: 'Ivan',
+				verified: false,
+				jsonb: null,
+				createdAt: result[0]?.userstest.createdAt,
+			},
+			customer: {
+				id: 1,
+				name: 'Hans',
+				verified: false,
+				jsonb: null,
+				createdAt: result[0]?.customer!.createdAt,
+			},
+		},
+	]);
+});
+
+test('mySchema :: Mssql enum test case #1', async ({ db }) => {
+	await db.execute(sql`
+		create table ${tableWithEnums} (
+			[id] int primary key,
+			[enum1] varchar not null,
+			[enum2] varchar default 'a',
+			[enum3] varchar not null default 'b'
+		)
+	`);
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	await db.execute(sql`drop table ${tableWithEnums}`);
+
+	expect(res).toEqual([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test('mySchema :: view', async ({ db }) => {
+	const newYorkers1 = mySchema
+		.view('new_yorkers')
+		.as((qb) => qb.select().from(users2SchemaTable).where(eq(users2Table.cityId, 1)));
+
+	const newYorkers2 = mySchema
+		.view('new_yorkers', {
+			id: int('id').identity().primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		})
+		.as(
+			sql`select * from ${users2SchemaTable} where ${eq(users2Table.cityId, 1)}`,
+		);
+
+	const newYorkers3 = mySchema
+		.view('new_yorkers', {
+			id: int('id').identity().primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		})
+		.existing();
+
+	await db.execute(
+		sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`,
+	);
+
+	await db
+		.insert(citiesSchemaTable)
+		.values([{ name: 'New York' }, { name: 'Paris' }]);
+
+	await db.insert(users2SchemaTable).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 1 },
+		{ name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db
+			.select({ name: newYorkers1.name })
+			.from(newYorkers1);
+		expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test('all possible columns', async ({ db }) => {
+	await db.execute(sql`DROP TABLE IF EXISTS [all_possible_columns]`);
+	// eslint-disable-next-line unicorn/template-indent
+	await db.execute(sql`
+				CREATE TABLE [all_possible_columns] (
+		bigintBigint bigint,
+		bigintString bigint,
+		bigintNumber bigint,
+		bigintBigintDefault bigint DEFAULT 123,
+		bigintStringDefault bigint DEFAULT 123,
+		bigintNumberDefault bigint DEFAULT 123,
+
+		binary binary,
+		binaryLength binary(1),
+		binaryDefault binary DEFAULT 0x01,
+
+		bit bit,
+		bitDefault bit DEFAULT 0,
+
+		char char,
+		charWithConfig char(3),
+		charDefault char DEFAULT '4',
+
+		date date,
+		dateModeDate date,
+		dateModeString date,
+		dateDefault date DEFAULT '2025-04-18T00:00:00.000Z',
+		dateModeStringDefault date DEFAULT '2025-04-18T00:00:00.000Z',
+
+		dateTime datetime,
+		dateTimeModeDate datetime,
+		dateTimeModeString datetime,
+		dateTimeDefault datetime DEFAULT '2025-04-18T00:00:00.000Z',
+		dateTimeModeStringDefault datetime DEFAULT '2025-04-18T00:00:00.000Z',
+
+		dateTime2 datetime2,
+		dateTime2ModeDate datetime2,
+		dateTime2ModeString datetime2,
+		dateTime2WithPrecision datetime2(5),
+		dateTime2Default datetime2 DEFAULT '2025-04-18T00:00:00.000Z',
+		dateTime2ModeStringDefault datetime2 DEFAULT '2025-04-18T00:00:00.000Z',
+		dateTime2ModeStringWithPrecisionDefault datetime2(1) DEFAULT '2025-04-18T00:00:00.000Z', 
+
+		datetimeOffset datetimeoffset,
+		datetimeOffsetModeDate datetimeoffset,
+		datetimeOffsetModeString datetimeoffset,
+		datetimeOffsetDefault datetimeoffset DEFAULT '2025-04-18 03:00:00.000+3:00',
+		datetimeOffsetModeStringDefault datetimeoffset DEFAULT '2025-04-18 03:00:00.000+3:00',
+		datetimeOffsetModeStringWithPrecisionDefault datetimeoffset DEFAULT '2025-04-18 03:00:00.000+3:00', 
+
+		decimal decimal,
+		decimalWithPrecision decimal(3),
+		decimalWithConfig decimal(10,8),
+		decimalDefaultString decimal DEFAULT 1.312,
+		decimalDefaultNumber decimal DEFAULT 1.312,
+
+		float float,
+		floatWithPrecision float(3),
+		floatDefault float DEFAULT 32.412,
+
+		int int,
+		intDefault int DEFAULT 43,
+		
+		numeric decimal,
+		numericWithPrecision numeric(3),
+		numericWithConfig numeric(10,8),
+		numericDefault numeric DEFAULT 1.312,
+		numericDefaultNumber numeric DEFAULT 1.312,
+
+		real real,
+		realDefault real DEFAULT 5231.4123,
+
+		text text,
+		textEnum text,
+		textDefault text DEFAULT 'hello, world',
+		nText ntext,
+		nTextEnum ntext,
+		nTextDefault ntext DEFAULT 'hello, world',
+
+		time time,
+		timeModeDate time,
+		timeModeString time,
+		timeWithPrecision time(3),
+		timeDefault time DEFAULT '2025-04-18T00:00:00.000Z',
+		timeModeDateDefault time DEFAULT '2025-04-18T00:00:00.000Z',
+		timeModeStringDefault time DEFAULT '00:00:00.000',
+
+		smallint smallint,
+		smallintDefault smallint DEFAULT 331,
+
+		tinyint tinyint,
+		tinyintDefault tinyint DEFAULT 23,
+
+		varbinary varbinary,
+		varbinaryWithLength varbinary(100),
+		varbinaryDefault varbinary DEFAULT 0x01,
+
+		varchar varchar,
+		varcharWithEnum varchar(3),
+		varcharWithLength varchar(3),
+		varcharDefault varchar,
+		varcharWithEnumDefault varchar DEFAULT '1',
+
+		nchar nchar,
+		ncharWithEnum nchar(12),
+		ncharLength nchar(231),
+		ncharDefault nchar DEFAULT 'h',
+
+		nvarchar nvarchar,
+		nvarcharWithEnum nvarchar(12),
+		nvarcharLength nvarchar(231),
+		nvarcharDefault nvarchar DEFAULT 'h',
+		nvarcharJson nvarchar(max)
+);`);
+
+	const currentDate = new Date('2025-04-18T00:00:00.000Z');
+	// insert
+	await db.insert(allPossibleColumns).values({
+		bigintBigint: BigInt(100),
+		bigintString: '100',
+		bigintNumber: 100,
+		bigintBigintDefault: undefined,
+		bigintStringDefault: undefined,
+		bigintNumberDefault: undefined,
+
+		binary: Buffer.from('1'),
+		binaryLength: Buffer.from([0x01]),
+		binaryDefault: undefined,
+
+		bit: true,
+		bitDefault: undefined,
+
+		char: 'a',
+		charWithConfig: '342',
+		charDefault: undefined,
+
+		date: currentDate,
+		dateModeDate: currentDate,
+		dateModeString: currentDate.toISOString(),
+		dateDefault: undefined,
+		dateModeStringDefault: undefined,
+		dateTime: currentDate,
+		dateTimeModeDate: currentDate,
+		dateTimeModeString: currentDate.toISOString(),
+		dateTimeDefault: undefined,
+		dateTimeModeStringDefault: undefined,
+		dateTime2: currentDate,
+		dateTime2ModeDate: currentDate,
+		dateTime2ModeString: currentDate.toISOString(),
+		dateTime2WithPrecision: currentDate,
+		dateTime2Default: undefined,
+		dateTime2ModeStringDefault: undefined,
+		dateTime2ModeStringWithPrecisionDefault: undefined,
+		datetimeOffset: currentDate,
+		datetimeOffsetModeDate: currentDate,
+		datetimeOffsetModeString: currentDate.toISOString(),
+		datetimeOffsetDefault: undefined,
+		datetimeOffsetModeStringDefault: undefined,
+		datetimeOffsetModeStringWithPrecisionDefault: undefined,
+
+		decimal: '1.33',
+		decimalWithPrecision: '4.11',
+		decimalWithConfig: '41.34234526',
+		decimalDefaultString: undefined,
+		decimalDefaultNumber: undefined,
+
+		float: 5234.132,
+		floatWithPrecision: 1.23,
+		floatDefault: undefined,
+
+		int: 140,
+		intDefault: undefined,
+
+		numeric: '33.2',
+		numericWithPrecision: '33.4',
+		numericWithConfig: '41.34512',
+		numericDefault: undefined,
+		numericDefaultNumber: undefined,
+
+		real: 421.4,
+		realDefault: undefined,
+
+		text: 'hello',
+		textEnum: 'this',
+		textDefault: undefined,
+		nText: 'hello',
+		nTextEnum: 'this',
+		nTextDefault: undefined,
+
+		time: currentDate,
+		timeModeDate: currentDate,
+		timeModeString: '00:00:00.000',
+		timeWithPrecision: currentDate,
+		timeDefault: undefined,
+		timeModeDateDefault: undefined,
+		timeModeStringDefault: undefined,
+
+		smallint: 1312,
+		smallintDefault: undefined,
+
+		tinyint: 31,
+		tinyintDefault: undefined,
+
+		varbinary: Buffer.from('1'),
+		varbinaryWithLength: Buffer.from([0x01]),
+		varbinaryDefault: undefined,
+
+		varchar: 'v',
+		varcharWithEnum: '123',
+		varcharWithLength: '301',
+		varcharDefault: undefined,
+		varcharWithEnumDefault: undefined,
+		nvarcharJson: { hello: 'world' },
+		nchar: 'n',
+		ncharWithEnum: 'hello, world',
+		ncharLength: 'some value',
+		ncharDefault: undefined,
+
+		nvarchar: 'n',
+		nvarcharWithEnum: 'hello, world',
+		nvarcharLength: 'some value',
+		nvarcharDefault: undefined,
+	});
+
+	const res = await db.select().from(allPossibleColumns);
+
+	expect(res.length).toBe(1);
+	expect(Buffer.isBuffer(res[0]?.binary)).toBe(true);
+	expect(Buffer.isBuffer(res[0]?.binaryLength)).toBe(true);
+	expect(Buffer.isBuffer(res[0]?.binaryDefault)).toBe(true);
+	expect(Buffer.isBuffer(res[0]?.varbinary)).toBe(true);
+	expect(Buffer.isBuffer(res[0]?.varbinaryWithLength)).toBe(true);
+	expect(Buffer.isBuffer(res[0]?.varbinaryDefault)).toBe(true);
+
+	expect(
+		res.map((it) => ({
+			...it,
+			binary: it.binary ? it.binary.toString() : null,
+			binaryLength: it.binaryLength ? it.binaryLength.toString('hex') : null,
+			binaryDefault: it.binaryDefault ? it.binaryDefault.toString('hex') : null,
+			varbinary: it.varbinary ? it.varbinary.toString() : null,
+			varbinaryDefault: it.varbinaryDefault
+				? it.varbinaryDefault.toString('hex')
+				: null,
+			varbinaryWithLength: it.varbinaryWithLength
+				? it.varbinaryWithLength.toString('hex')
+				: null,
+		})),
+	).toStrictEqual([
+		{
+			bigintBigint: 100n,
+			bigintString: '100',
+			bigintNumber: 100,
+			bigintBigintDefault: 123n,
+			bigintStringDefault: '123',
+			bigintNumberDefault: 123,
+
+			binary: '1',
+			binaryLength: '01',
+			binaryDefault: '01',
+
+			bit: true,
+			bitDefault: false,
+			char: 'a',
+			charWithConfig: '342',
+			charDefault: '4',
+			date: currentDate,
+			dateModeDate: currentDate,
+			dateModeString: `${currentDate.getFullYear()}-${
+				(
+					currentDate.getMonth() + 1
+				)
+					.toString()
+					.padStart(2, '0')
+			}-${currentDate.getDate()}`,
+			dateDefault: currentDate,
+			dateModeStringDefault: `${currentDate.getFullYear()}-${
+				(
+					currentDate.getMonth() + 1
+				)
+					.toString()
+					.padStart(2, '0')
+			}-${currentDate.getDate()}`,
+			dateTime: currentDate,
+			dateTimeModeDate: currentDate,
+			dateTimeModeString: currentDate.toISOString(),
+			dateTimeDefault: currentDate,
+			dateTimeModeStringDefault: currentDate.toISOString(),
+			dateTime2: currentDate,
+			dateTime2ModeDate: currentDate,
+			dateTime2ModeString: currentDate.toISOString(),
+			dateTime2WithPrecision: currentDate,
+			dateTime2Default: currentDate,
+			dateTime2ModeStringDefault: currentDate.toISOString(),
+			dateTime2ModeStringWithPrecisionDefault: currentDate.toISOString(),
+			datetimeOffset: currentDate,
+			datetimeOffsetModeDate: currentDate,
+			datetimeOffsetModeString: currentDate.toISOString(),
+			datetimeOffsetDefault: currentDate,
+			datetimeOffsetModeStringDefault: currentDate.toISOString(),
+			datetimeOffsetModeStringWithPrecisionDefault: currentDate.toISOString(),
+			decimal: '1',
+			decimalWithPrecision: '4',
+			decimalWithConfig: '41.34234526',
+			decimalDefaultNumber: 1,
+			decimalDefaultString: '1',
+			float: 5234.132,
+			floatWithPrecision: 1.2300000190734863,
+			floatDefault: 32.412,
+			int: 140,
+			intDefault: 43,
+			numeric: '33',
+			numericWithPrecision: '33',
+			numericWithConfig: '41.34512',
+			numericDefault: '1',
+			numericDefaultNumber: 1,
+			real: 421.4,
+			realDefault: 5231.412,
+			text: 'hello',
+			textEnum: 'this',
+			textDefault: 'hello, world',
+			nText: 'hello',
+			nTextEnum: 'this',
+			nTextDefault: 'hello, world',
+			time: new Date(`1970-01-01T00:00:00.000Z`), // mssql returns date, and sets only hours:mm:ss for 1970 year
+			timeModeDate: new Date(`1970-01-01T00:00:00.000Z`),
+			timeModeString: `00:00:00.000`,
+			timeWithPrecision: new Date(`1970-01-01T00:00:00.000Z`),
+			timeDefault: new Date(`1970-01-01T00:00:00.000Z`),
+			timeModeDateDefault: new Date(`1970-01-01T00:00:00.000Z`),
+			timeModeStringDefault: '00:00:00.000',
+			smallint: 1312,
+			smallintDefault: 331,
+			tinyint: 31,
+			tinyintDefault: 23,
+
+			varbinary: '1',
+			varbinaryWithLength: '01',
+			varbinaryDefault: '01',
+
+			varchar: 'v',
+			varcharWithEnum: '123',
+			varcharWithLength: '301',
+			varcharDefault: null,
+			varcharWithEnumDefault: '1',
+			nchar: 'n',
+			ncharWithEnum: 'hello, world',
+			ncharLength:
+				'some value                                                                                                                                                                                                                             ',
+			ncharDefault: 'h',
+			nvarchar: 'n',
+			nvarcharWithEnum: 'hello, world',
+			nvarcharLength: 'some value',
+			nvarcharDefault: 'h',
+			nvarcharJson: { hello: 'world' },
+		},
+	]);
+});
+
+test('inner join', async ({ db }) => {
+	await db.execute(sql`DROP TABLE IF EXISTS ${employees};`);
+	await db.execute(sql`DROP TABLE IF EXISTS ${departments};`);
+
+	await db.execute(sql`
+		CREATE TABLE employees (
+						employeeID INT PRIMARY KEY IDENTITY(1,1),
+						name NVARCHAR(100),
+						departmentID INT
+					);
+	`);
+	await db.execute(sql`
+						CREATE TABLE departments (
+		    departmentId INT PRIMARY KEY IDENTITY(1,1),
+		    departmentName NVARCHAR(100)
+		);
+	`);
+
+	await db.insert(departments).values({ departmentName: 'Drizzle1' });
+	await db.insert(departments).values({ departmentName: 'Drizzle2' });
+	await db.insert(departments).values({ departmentName: 'Drizzle3' });
+	await db.insert(departments).values({ departmentName: 'Drizzle4' });
+	await db.insert(employees).values({ departmentId: 1, name: 'Andrew1' });
+	await db.insert(employees).values({ departmentId: 2, name: 'Andrew2' });
+	await db.insert(employees).values({ departmentId: 5, name: 'Andrew3' });
+
+	const res = await db
+		.select({
+			employeeName: employees.name,
+			department: departments.departmentName,
+		})
+		.from(employees)
+		.innerJoin(
+			departments,
+			eq(departments.departmentId, employees.departmentId),
+		);
+
+	expect(res).toStrictEqual([
+		{ employeeName: 'Andrew1', department: 'Drizzle1' },
+		{
+			employeeName: 'Andrew2',
+			department: 'Drizzle2',
+		},
+	]);
+});
+
+test('right join', async ({ db }) => {
+	await db.execute(sql`DROP TABLE IF EXISTS ${employees};`);
+	await db.execute(sql`DROP TABLE IF EXISTS ${departments};`);
+
+	await db.execute(sql`
+		CREATE TABLE employees (
+						employeeID INT PRIMARY KEY IDENTITY(1,1),
+						name NVARCHAR(100),
+						departmentID INT
+					);
+	`);
+	await db.execute(sql`
+						CREATE TABLE departments (
+		    departmentId INT PRIMARY KEY IDENTITY(1,1),
+		    departmentName NVARCHAR(100)
+		);
+	`);
+
+	await db.insert(departments).values({ departmentName: 'Drizzle1' });
+	await db.insert(departments).values({ departmentName: 'Drizzle2' });
+	await db.insert(departments).values({ departmentName: 'Drizzle3' });
+	await db.insert(departments).values({ departmentName: 'Drizzle4' });
+	await db.insert(employees).values({ departmentId: 1, name: 'Andrew1' });
+	await db.insert(employees).values({ departmentId: 2, name: 'Andrew2' });
+	await db.insert(employees).values({ departmentId: 5, name: 'Andrew3' });
+
+	const res = await db
+		.select({
+			employeeName: employees.name,
+			department: departments.departmentName,
+		})
+		.from(employees)
+		.rightJoin(
+			departments,
+			eq(departments.departmentId, employees.departmentId),
+		);
+
+	expect(res).toStrictEqual([
+		{ employeeName: 'Andrew1', department: 'Drizzle1' },
+		{
+			employeeName: 'Andrew2',
+			department: 'Drizzle2',
+		},
+		{
+			employeeName: null,
+			department: 'Drizzle3',
+		},
+		{
+			employeeName: null,
+			department: 'Drizzle4',
+		},
+	]);
+});
+
+test('full join', async ({ db }) => {
+	await db.execute(sql`DROP TABLE IF EXISTS ${employees};`);
+	await db.execute(sql`DROP TABLE IF EXISTS ${departments};`);
+
+	await db.execute(sql`
+		CREATE TABLE employees (
+						employeeID INT PRIMARY KEY IDENTITY(1,1),
+						name NVARCHAR(100),
+						departmentID INT
+					);
+	`);
+	await db.execute(sql`
+						CREATE TABLE departments (
+		    departmentId INT PRIMARY KEY IDENTITY(1,1),
+		    departmentName NVARCHAR(100)
+		);
+	`);
+
+	await db.insert(departments).values({ departmentName: 'Drizzle1' });
+	await db.insert(departments).values({ departmentName: 'Drizzle2' });
+	await db.insert(departments).values({ departmentName: 'Drizzle3' });
+	await db.insert(departments).values({ departmentName: 'Drizzle4' });
+	await db.insert(employees).values({ departmentId: 1, name: 'Andrew1' });
+	await db.insert(employees).values({ departmentId: 2, name: 'Andrew2' });
+	await db.insert(employees).values({ departmentId: 5, name: 'Andrew3' });
+
+	const res = await db
+		.select({
+			employeeName: employees.name,
+			department: departments.departmentName,
+		})
+		.from(employees)
+		.fullJoin(
+			departments,
+			eq(departments.departmentId, employees.departmentId),
+		);
+
+	expect(res).toStrictEqual([
+		{ employeeName: 'Andrew1', department: 'Drizzle1' },
+		{ employeeName: 'Andrew2', department: 'Drizzle2' },
+		{ employeeName: 'Andrew3', department: null },
+		{ employeeName: null, department: 'Drizzle3' },
+		{ employeeName: null, department: 'Drizzle4' },
+	]);
+});
+
+test('select top', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db.select().top(4).from(citiesTable);
+
+	expect(query.toSQL()).toStrictEqual({
+		sql: `select top(@par0) [id], [name] from [cities]`,
+		params: [4],
+	});
+
+	const res = await query;
+
+	expect(res.length).toBe(4);
+	expect(res).toStrictEqual([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{ id: 3, name: 'city3' },
+		{ id: 4, name: 'city4' },
+	]);
+});
+
+test('select top prepared query', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db.select().top(sql.placeholder('top')).from(citiesTable);
+
+	const res = await query.execute({ top: 4 });
+
+	expect(res.length).toBe(4);
+	expect(res).toStrictEqual([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{ id: 3, name: 'city3' },
+		{ id: 4, name: 'city4' },
+	]);
+});
+
+test('select offset', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db
+		.select()
+		.from(citiesTable)
+		.orderBy(desc(citiesTable.id))
+		.offset(9);
+
+	expect(query.toSQL()).toStrictEqual({
+		sql: `select [id], [name] from [cities] order by [cities].[id] desc offset @par0 rows`,
+		params: [9],
+	});
+
+	const res = await query;
+
+	expect(res.length).toBe(1);
+	expect(res).toStrictEqual([{ id: 1, name: 'city1' }]);
+});
+
+test('select offset prepared query', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db
+		.select()
+		.from(citiesTable)
+		.orderBy(desc(citiesTable.id))
+		.offset(sql.placeholder('offset'));
+
+	const res = await query.execute({ offset: 9 });
+
+	expect(res.length).toBe(1);
+	expect(res).toStrictEqual([{ id: 1, name: 'city1' }]);
+});
+
+test('select offset and fetch', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db
+		.select()
+		.from(citiesTable)
+		.orderBy(desc(citiesTable.id))
+		.offset(5)
+		.fetch(2);
+
+	expect(query.toSQL()).toStrictEqual({
+		sql: `select [id], [name] from [cities] order by [cities].[id] desc offset @par0 rows fetch next @par1 rows only`,
+		params: [5, 2],
+	});
+
+	const res = await query;
+
+	expect(res.length).toBe(2);
+	expect(res).toStrictEqual([
+		{ id: 5, name: 'city5' },
+		{ id: 4, name: 'city4' },
+	]);
+});
+
+test('select offset and fetch prepared query', async ({ db }) => {
+	await db.insert(citiesTable).values({ id: 1, name: 'city1' });
+	await db.insert(citiesTable).values({ id: 2, name: 'city2' });
+	await db.insert(citiesTable).values({ id: 3, name: 'city3' });
+	await db.insert(citiesTable).values({ id: 4, name: 'city4' });
+	await db.insert(citiesTable).values({ id: 5, name: 'city5' });
+	await db.insert(citiesTable).values({ id: 6, name: 'city6' });
+	await db.insert(citiesTable).values({ id: 7, name: 'city7' });
+	await db.insert(citiesTable).values({ id: 8, name: 'city8' });
+	await db.insert(citiesTable).values({ id: 9, name: 'city9' });
+	await db.insert(citiesTable).values({ id: 10, name: 'city10' });
+
+	const query = db
+		.select()
+		.from(citiesTable)
+		.orderBy(desc(citiesTable.id))
+		.offset(sql.placeholder('offset'))
+		.fetch(sql.placeholder('fetch'));
+
+	const res = await query.execute({ offset: 5, fetch: 2 });
+
+	expect(res.length).toBe(2);
+	expect(res).toStrictEqual([
+		{ id: 5, name: 'city5' },
+		{ id: 4, name: 'city4' },
+	]);
+});
+
+test('insert with output', async ({ db }) => {
+	const fullOutput = await db
+		.insert(citiesTable)
+		.output()
+		.values({ id: 1, name: 'city1' });
+	const partialOutput = await db
+		.insert(citiesTable)
+		.output({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+			id: citiesTable.id,
+		})
+		.values({
+			id: 2,
+			name: 'city1',
+		});
+
+	expect(fullOutput).toStrictEqual([{ id: 1, name: 'city1' }]);
+
+	expect(partialOutput).toStrictEqual([{ id: 2, name: 'city1hey' }]);
+});
+
+test('delete with output', async ({ db }) => {
+	await db
+		.insert(citiesTable)
+		.output()
+		.values([
+			{ id: 1, name: 'city1' },
+			{ id: 2, name: 'city2' },
+			{
+				id: 3,
+				name: 'city3',
+			},
+		]);
+	const partialDeleteOutput = await db
+		.delete(citiesTable)
+		.output({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+			id: citiesTable.id,
+		})
+		.where(eq(citiesTable.id, 3));
+
+	expect(partialDeleteOutput).toStrictEqual([{ id: 3, name: 'city3hey' }]);
+
+	const fullDeleteOutput = await db.delete(citiesTable).output();
+
+	expect(fullDeleteOutput).toStrictEqual([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+	]);
+});
+
+test('update with output', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{
+			id: 3,
+			name: 'city3',
+		},
+	]);
+
+	const updateOutput = await db
+		.update(citiesTable)
+		.set({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+		})
+		.output()
+		.where(eq(citiesTable.id, 3));
+
+	expect(updateOutput).toStrictEqual([{ id: 3, name: 'city3hey' }]);
+});
+
+test('update with output inserted true', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{
+			id: 3,
+			name: 'city3',
+		},
+	]);
+
+	const updateOutput = await db
+		.update(citiesTable)
+		.set({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+		})
+		.output({ inserted: true })
+		.where(eq(citiesTable.id, 3));
+
+	expect(updateOutput).toStrictEqual([
+		{ inserted: { id: 3, name: 'city3hey' } },
+	]);
+});
+
+test('update with output deleted true', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{
+			id: 3,
+			name: 'city3',
+		},
+	]);
+
+	const updateOutput = await db
+		.update(citiesTable)
+		.set({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+		})
+		.output({ deleted: true })
+		.where(eq(citiesTable.id, 3));
+
+	expect(updateOutput).toStrictEqual([{ deleted: { id: 3, name: 'city3' } }]);
+});
+
+test('update with output with both true', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{
+			id: 3,
+			name: 'city3',
+		},
+	]);
+
+	const updateOutput = await db
+		.update(citiesTable)
+		.set({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+		})
+		.output({ deleted: true, inserted: true })
+		.where(eq(citiesTable.id, 3));
+
+	expect(updateOutput).toStrictEqual([
+		{
+			deleted: { id: 3, name: 'city3' },
+			inserted: { id: 3, name: 'city3hey' },
+		},
+	]);
+});
+
+test('update with output with partial select', async ({ db }) => {
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'city1' },
+		{ id: 2, name: 'city2' },
+		{
+			id: 3,
+			name: 'city3',
+		},
+	]);
+
+	const updateOutput = await db
+		.update(citiesTable)
+		.set({
+			name: sql<string>`${citiesTable.name} + 'hey'`,
+		})
+		.output({
+			deleted: { id: citiesTable.id },
+			inserted: { name: citiesTable.name },
+		})
+		.where(eq(citiesTable.id, 3));
+
+	expect(updateOutput).toStrictEqual([
+		{ deleted: { id: 3 }, inserted: { name: 'city3hey' } },
+	]);
+});
+
+test('nvarchar with json mode', async ({ db }) => {
+	await db.insert(nvarcharWithJsonTable).values([{ json: { hello: 'world' } }]);
+
+	const res = await db.select().from(nvarcharWithJsonTable);
+
+	expect(res).toStrictEqual([{ id: 1, json: { hello: 'world' } }]);
+});
+
+test('column.as', async ({ db }) => {
+	const users = mssqlTable('users_column_as', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').references(() => cities.id),
+	});
+
+	const cities = mssqlTable('cities_column_as', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const ucView = mssqlView('cities_users_column_as_view').as((qb) =>
+		qb
+			.select({
+				userId: users.id.as('user_id'),
+				cityId: cities.id.as('city_id'),
+				userName: users.name.as('user_name'),
+				cityName: cities.name.as('city_name'),
+			})
+			.from(users)
+			.leftJoin(cities, eq(cities.id, users.cityId))
+	);
+
+	await db.execute(sql`CREATE TABLE ${cities} (
+				[id] INT PRIMARY KEY,
+				[name] TEXT NOT NULL
+			);`);
+
+	await db.execute(sql`CREATE TABLE ${users} (
+				[id] INT PRIMARY KEY,
+				[name] TEXT NOT NULL,
+				[city_id] INT REFERENCES ${cities}([id]) 
+			);`);
+
+	await db.execute(
+		sql`CREATE VIEW ${ucView} AS SELECT ${users.id} as [user_id], ${cities.id} as [city_id], ${users.name} as [user_name], ${cities.name} as [city_name] FROM ${users} LEFT JOIN ${cities} ON ${
+			eq(
+				cities.id,
+				users.cityId,
+			)
+		};`,
+	);
+
+	const citiesInsRet = await db
+		.insert(cities)
+		.output({
+			cityId: cities.id.as('city_id'),
+			cityName: cities.name.as('city_name'),
+		})
+		.values([
+			{
+				id: 1,
+				name: 'Firstistan',
+			},
+			{
+				id: 2,
+				name: 'Secondaria',
+			},
+		]);
+
+	expect(citiesInsRet).toStrictEqual(
+		expect.arrayContaining([
+			{
+				cityId: 1,
+				cityName: 'Firstistan',
+			},
+			{
+				cityId: 2,
+				cityName: 'Secondaria',
+			},
+		]),
+	);
+
+	const usersInsRet = await db
+		.insert(users)
+		.output({
+			userId: users.id.as('user_id'),
+			userName: users.name.as('users_name'),
+			userCityId: users.cityId,
+		})
+		.values([
+			{ id: 1, name: 'First', cityId: 1 },
+			{
+				id: 2,
+				name: 'Second',
+				cityId: 2,
+			},
+			{
+				id: 3,
+				name: 'Third',
+			},
+		]);
+
+	expect(usersInsRet).toStrictEqual(
+		expect.arrayContaining([
+			{ userId: 1, userName: 'First', userCityId: 1 },
+			{
+				userId: 2,
+				userName: 'Second',
+				userCityId: 2,
+			},
+			{
+				userId: 3,
+				userName: 'Third',
+				userCityId: null,
+			},
+		]),
+	);
+
+	const joinSelectReturn = await db
+		.select({
+			userId: users.id.as('user_id'),
+			cityId: cities.id.as('city_id'),
+			userName: users.name.as('user_name'),
+			cityName: cities.name.as('city_name'),
+		})
+		.from(users)
+		.leftJoin(cities, eq(cities.id, users.cityId));
+
+	expect(joinSelectReturn).toStrictEqual(
+		expect.arrayContaining([
+			{
+				userId: 1,
+				userName: 'First',
+				cityId: 1,
+				cityName: 'Firstistan',
+			},
+			{
+				userId: 2,
+				userName: 'Second',
+				cityId: 2,
+				cityName: 'Secondaria',
+			},
+			{
+				userId: 3,
+				userName: 'Third',
+				cityId: null,
+				cityName: null,
+			},
+		]),
+	);
+
+	const viewSelectReturn = await db.select().from(ucView);
+
+	expect(viewSelectReturn).toStrictEqual(
+		expect.arrayContaining([
+			{
+				userId: 1,
+				userName: 'First',
+				cityId: 1,
+				cityName: 'Firstistan',
+			},
+			{
+				userId: 2,
+				userName: 'Second',
+				cityId: 2,
+				cityName: 'Secondaria',
+			},
+			{
+				userId: 3,
+				userName: 'Third',
+				cityId: null,
+				cityName: null,
+			},
+		]),
+	);
+
+	const viewJoinReturn = await db
+		.select({
+			userId: ucView.userId.as('user_id_ucv'),
+			cityId: cities.id.as('city_id'),
+			userName: ucView.userName.as('user_name_ucv'),
+			cityName: cities.name.as('city_name'),
+		})
+		.from(ucView)
+		.leftJoin(cities, eq(cities.id, ucView.cityId));
+
+	expect(viewJoinReturn).toStrictEqual(
+		expect.arrayContaining([
+			{
+				userId: 1,
+				userName: 'First',
+				cityId: 1,
+				cityName: 'Firstistan',
+			},
+			{
+				userId: 2,
+				userName: 'Second',
+				cityId: 2,
+				cityName: 'Secondaria',
+			},
+			{
+				userId: 3,
+				userName: 'Third',
+				cityId: null,
+				cityName: null,
+			},
+		]),
+	);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4878
+test('.where with isNull in it', async ({ db }) => {
+	const table = mssqlTable('table_where_is_null', {
+		col1: bit(),
+		col2: text(),
+	});
+
+	await db
+		.insert(table)
+		.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+	const query = db
+		.select()
+		.from(table)
+		.where(
+			eq(table.col1, sql`case when ${isNull(table.col2)} then 1 else 0 end;`),
+		);
+	expect(query.toSQL()).toStrictEqual({
+		sql:
+			'select [col1], [col2] from [table_where_is_null] where [table_where_is_null].[col1] = case when ([table_where_is_null].[col2] is null) then 1 else 0 end;',
+		params: [],
+	});
+	const res = await query;
+	expect(res).toStrictEqual([
+		{ col1: true, col2: null },
+		{ col1: false, col2: 'qwerty' },
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4875
+test('select aliased view', async ({ db }) => {
+	const productionJobTable = mssqlTable('production_job', {
+		id: text('id').primaryKey(),
+		name: text('name'),
+	});
+
+	const rfidTagTable = mssqlTable('rfid_tag', {
+		createdAt: date('created_at')
+			.notNull()
+			.default(sql`now()`),
+		epc: text('epc').notNull(),
+		locationId: text('location_id').notNull(),
+		id: text('id')
+			.notNull()
+			.unique()
+			.$default(() => 'abc'),
+	});
+
+	const productionJobWithLocationView = mssqlView(
+		'production_job_with_location',
+	).as((qb) => {
+		const productionColumns = getColumns(productionJobTable);
+		const sub = qb.selectDistinct().from(rfidTagTable).as('r');
+		return qb
+			.select({
+				...productionColumns,
+				locationId: sub.locationId,
+				tagId: sub.id.as('tag_id'),
+				tagCreatedAt: sub.createdAt.as('tag_created_at'),
+			})
+			.from(productionJobTable)
+			.leftJoin(
+				sub,
+				and(
+					eq(productionJobTable.id, sql`LTRIM(${sub.epc}, '0')`),
+					sql`${sub.epc} ~ '^0?[0-9]+'`,
+				),
+			);
+	});
+
+	const sub = alias(productionJobWithLocationView, 'p'); // if select from "productionJobWithLocationView" (not from alias), it works as expected
+
+	const query = db.select().from(sub);
+	expect(query.toSQL().sql).toStrictEqual(
+		(<{ dialect: MsSqlDialect }> (<any> db)).dialect.sqlToQuery(
+			sql`select ${sql.identifier('id')}, ${sql.identifier('name')}, ${sql.identifier('location_id')}, ${
+				sql.identifier(
+					'tag_id',
+				)
+			}, ${sql.identifier('tag_created_at')} from ${sql.identifier('production_job_with_location')} ${
+				sql.identifier(
+					'p',
+				)
+			}`,
+		).sql,
+	);
+});
+
+test('sql.identifier escape', async () => {
+	const dialect = new MsSqlDialect();
+	const userInput = 'id] ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+	const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+	const str = dialect.sqlToQuery(query);
+	expect(str.sql).toBe(
+		'SELECT * FROM [users] ORDER BY [id]] ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--] ASC',
+	);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4612
+test('select with inline params in sql', async ({ db }) => {
+	const users = mssqlTable('users_115', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const query = db.select({ sum: sql`sum(${3})`.inlineParams() }).from(users);
+
+	expect(query.toSQL()).toStrictEqual({
+		sql: 'select sum(3) from [users_115]',
+		params: [],
+	});
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5527
+test('issue 5527. real() returns unprecise float64 values', async ({ db }) => {
+	const users = mssqlTable('users_116', {
+		id: int('id').primaryKey(),
+		age: real('age').notNull(),
+	});
+
+	await db.execute(sql`CREATE TABLE [users_116] (
+		id int primary key,
+		age real not null	
+	);`);
+
+	await db.insert(users).values({ id: 1, age: 0.01 });
+	const [res] = await db.select().from(users);
+
+	expect(res).toStrictEqual({ id: 1, age: 0.01 });
+});
+
+test.skipIf(Date.now() < +new Date('2026-07-01'))('Query error wrapping', async ({ db }) => {
+	await expect(db.insert(users2Table).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]))
+		.rejects.toBeInstanceOf(DrizzleQueryError);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/5881
+test('insert into table with generated column', async ({ db }) => {
+	const docs = mssqlTable('docs', {
+		id: int().identity(),
+		value: nvarchar({ length: 'max' }).notNull(),
+		value_idx: nvarchar({ length: 450 }).generatedAlwaysAs(sql`(CONVERT([nvarchar](450),[value]))`),
+	});
+
+	await db.execute(sql`drop table if exists [docs]`);
+	await db.execute(sql`
+		create table [docs] (
+			[id] int identity,
+			[value] nvarchar(max) not null,
+			[value_idx] as (upper([value]))
+		);
+	`);
+
+	const query = db.insert(docs).values({ value: 'hello' });
+	expect(query.toSQL()).toStrictEqual({
+		params: [
+			'hello',
+		],
+		sql: 'insert into [docs] ([value]) values (@par0)',
+	});
+
+	await query;
+	const result = await db.select().from(docs);
+	expect(result).toEqual([{ id: 1, value: 'hello', value_idx: 'HELLO' }]);
+});
diff --git a/integration-tests/tests/mssql/replicas.test.ts b/integration-tests/tests/mssql/replicas.test.ts
new file mode 100644
index 0000000000..09e81c8800
--- /dev/null
+++ b/integration-tests/tests/mssql/replicas.test.ts
@@ -0,0 +1,827 @@
+import { sql } from 'drizzle-orm';
+import { bit, datetime2, int, mssqlTable, text, varchar, withReplicas } from 'drizzle-orm/mssql-core';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = mssqlTable('users', {
+	id: int('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: bit('verified').notNull().default(false),
+	jsonb: varchar('jsonb').$type<string[]>(),
+	createdAt: datetime2('created_at').notNull().defaultGetDate(),
+});
+
+const users = mssqlTable('users', {
+	id: int('id' as string).primaryKey(),
+});
+
+describe('[select] read replicas postgres', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query = db.$primary.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual('select [id] from [users]');
+
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(query1.toSQL().sql).toEqual('select count(*) as [count] from [users]');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select [id] from [users]');
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select [id] from [users]');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select [id] from [users]');
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select({ id: users.id }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select [id] from [users]');
+
+		const query2 = db.$primary.select().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select [id] from [users]');
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select [id] from [users]');
+
+		const query2 = db.select().from(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select [id] from [users]');
+	});
+});
+
+describe('[selectDistinct] read replicas postgres', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query = db.$primary.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query.toSQL().sql).toEqual('select distinct [id] from [users]');
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct [id] from [users]');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct [id] from [users]');
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct [id] from [users]');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select distinct [id] from [users]');
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct [id] from [users]');
+
+		const query2 = db.$primary.selectDistinct().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct [id] from [users]');
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct [id] from [users]');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select distinct [id] from [users]');
+	});
+});
+
+describe('[with] read replicas postgres', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+		const obj4 = {} as any;
+
+		db.$primary.with(obj1, obj2, obj3, obj4);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+
+		db.with(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		db.with(obj2, obj3);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
+	});
+});
+
+describe('[update] replicas postgres', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		const query1 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('update [users] set [id] = @par0');
+
+		const query2 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('update [users] set [id] = @par0');
+
+		const query3 = db.$primary.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query3.toSQL().sql).toEqual('update [users] set [id] = @par0');
+	});
+});
+
+describe('[delete] replicas postgres', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		const query1 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query1.toSQL().sql).toEqual('delete from [users]');
+
+		const query2 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+		expect(query2.toSQL().sql).toEqual('delete from [users]');
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas postgres', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		const query = db.insert(users).values({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query.toSQL().sql).toEqual('insert into [users] ([id]) values (@par0)');
+
+		db.insert(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas postgres', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		expect(db.execute(sql``)).rejects.toThrow();
+
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas postgres', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const txFn1 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn1)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
+
+		const txFn2 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn2)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findFirst] read replicas postgres', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findFirst');
+		const obj = {} as any;
+
+		db.$primary._query.usersTable.findFirst(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findFirst');
+		const par1 = {} as any;
+
+		db._query.usersTable.findFirst(par1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(par1);
+
+		const query = db._query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual(
+			'select top(@par0) [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findFirst');
+
+		db._query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db._query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findFirst');
+
+		db._query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary._query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findFirst');
+
+		db._query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db._query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas postgres', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findMany');
+		const obj = {} as any;
+
+		const query = db.$primary._query.usersTable.findMany(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+		expect(query.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db._query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		const query2 = db._query.usersTable.findMany(obj2);
+
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+		expect(spyRead2).toHaveBeenCalledWith(obj2);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db._query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+
+		const query2 = db._query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db._query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+
+		const query2 = db.$primary._query.usersTable.findMany(obj2);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle.mock({ schema: { usersTable } });
+		const read1 = drizzle.mock({ schema: { usersTable } });
+		const read2 = drizzle.mock({ schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['_query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['_query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['_query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db._query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+
+		const query2 = db._query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select [id], [name], [verified], [jsonb], [created_at] from [users] [usersTable]',
+		);
+	});
+});
diff --git a/integration-tests/tests/mssql/schema.ts b/integration-tests/tests/mssql/schema.ts
new file mode 100644
index 0000000000..b41a337395
--- /dev/null
+++ b/integration-tests/tests/mssql/schema.ts
@@ -0,0 +1,263 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	binary,
+	bit,
+	char,
+	date,
+	datetime,
+	datetime2,
+	datetimeoffset,
+	decimal,
+	float,
+	int,
+	mssqlSchema,
+	mssqlTable,
+	nchar,
+	ntext,
+	numeric,
+	nvarchar,
+	real,
+	smallint,
+	text,
+	time,
+	tinyint,
+	uniqueIndex,
+	varbinary,
+	varchar,
+} from 'drizzle-orm/mssql-core';
+
+export const usersTable = mssqlTable('userstest', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { mode: 'text' }).notNull(),
+	verified: bit('verified').notNull().default(false),
+	jsonb: nvarchar('jsonb', { length: 300, mode: 'json' }).$type<string[]>(),
+	createdAt: datetime('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
+});
+
+export const nvarcharWithJsonTable = mssqlTable('nvarchar_with_json', {
+	id: int('id').identity().primaryKey(),
+	json: nvarchar({ mode: 'json', length: 'max' }),
+});
+
+export const users2Table = mssqlTable('users2', {
+	id: int('id').primaryKey(),
+	name: varchar('name', { length: 30 }).notNull(),
+	cityId: int('city_id').default(sql`null`).references(() => citiesTable.id),
+});
+
+export const citiesTable = mssqlTable('cities', {
+	id: int().primaryKey(),
+	name: varchar({ length: 30 }).notNull(),
+});
+
+export const usersOnUpdate = mssqlTable('users_on_update', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+	updateCounter: int('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: datetime('updated_at', { mode: 'date' }).$onUpdate(() => new Date()),
+	// uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper([name])`),
+	alwaysNull: text('always_null').$type<string | null>().$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
+});
+
+export const datesTable = mssqlTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time', { precision: 1 }),
+	timeAsString: time('time_as_string', { mode: 'string', precision: 1 }),
+	datetime: datetime('datetime'),
+	datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+});
+
+export const coursesTable = mssqlTable('courses', {
+	id: int().identity().primaryKey(),
+	name: text().notNull(),
+	categoryId: int('category_id').references(() => courseCategoriesTable.id),
+});
+
+export const courseCategoriesTable = mssqlTable('course_categories', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+});
+
+export const orders = mssqlTable('orders', {
+	id: int('id').primaryKey(),
+	region: varchar('region', { length: 50 }).notNull(),
+	product: varchar('product', { length: 50 }).notNull().$default(() => 'random_string'),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+export const usersMigratorTable = mssqlTable('users12', {
+	id: int('id').identity().primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => [
+	uniqueIndex('').on(table.name),
+]);
+
+// To test aggregate functions
+export const aggregateTable = mssqlTable('aggregate_table', {
+	id: int('id').identity().notNull(),
+	name: varchar('name', { length: 30 }).notNull(),
+	a: int('a'),
+	b: int('b'),
+	c: int('c'),
+	nullOnly: int('null_only'),
+});
+
+export const mySchema = mssqlSchema('mySchema');
+
+export const usersSchemaTable = mySchema.table('userstest', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { length: 100 }).notNull(),
+	verified: bit('verified').notNull().default(false),
+	jsonb: nvarchar('jsonb', { mode: 'json', length: 100 }).$type<string[]>(),
+	createdAt: datetime2('created_at', { precision: 2 }).notNull().defaultGetDate(),
+});
+
+export const users2SchemaTable = mySchema.table('users2', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { length: 100 }).notNull(),
+	cityId: int('city_id').references(() => citiesTable.id),
+});
+
+export const citiesSchemaTable = mySchema.table('cities', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { length: 100 }).notNull(),
+});
+
+export const tableWithEnums = mySchema.table('enums_test_case', {
+	id: int('id').primaryKey(),
+	enum1: varchar('enum1', { enum: ['a', 'b', 'c'] }).notNull(),
+	enum2: varchar('enum2', { enum: ['a', 'b', 'c'] }).default('a'),
+	enum3: varchar('enum3', { enum: ['a', 'b', 'c'] }).notNull().default('b'),
+});
+
+export const employees = mssqlTable('employees', {
+	employeeId: int().identity({ increment: 1, seed: 1 }).primaryKey(),
+	name: nvarchar({ length: 100 }),
+	departmentId: int(),
+});
+
+export const departments = mssqlTable('departments', {
+	departmentId: int().primaryKey().identity({ increment: 1, seed: 1 }),
+	departmentName: nvarchar({ length: 100 }),
+});
+
+export const allPossibleColumns = mssqlTable('all_possible_columns', {
+	bigintBigint: bigint({ mode: 'bigint' }),
+	bigintString: bigint({ mode: 'string' }),
+	bigintNumber: bigint({ mode: 'number' }),
+	bigintBigintDefault: bigint({ mode: 'bigint' }).default(BigInt(123)),
+	bigintStringDefault: bigint({ mode: 'string' }).default('123'),
+	bigintNumberDefault: bigint({ mode: 'number' }).default(123),
+	binary: binary(),
+	binaryLength: binary({ length: 1 }),
+	binaryDefault: binary().default(Buffer.from([0x01])),
+
+	bit: bit(),
+	bitDefault: bit().default(false),
+
+	char: char(),
+	charWithConfig: char({ enum: ['123', '342'], length: 3 }),
+	charDefault: char().default('4'),
+
+	nchar: nchar(),
+	ncharWithEnum: nchar({ enum: ['hello, world'], length: 12 }),
+	ncharLength: nchar({ length: 231 }),
+	ncharDefault: nchar().default('h'),
+
+	date: date(),
+	dateModeDate: date({ mode: 'date' }),
+	dateModeString: date({ mode: 'string' }),
+	dateDefault: date().default(new Date('2025-04-17')),
+	dateModeStringDefault: date({ mode: 'string' }).default('2025-04-17'),
+
+	dateTime: datetime(),
+	dateTimeModeDate: datetime({ mode: 'date' }),
+	dateTimeModeString: datetime({ mode: 'string' }),
+	dateTimeDefault: datetime().default(new Date('2025-04-17 13:54:28.227')),
+	dateTimeModeStringDefault: datetime({ mode: 'string' }).default(new Date('2025-04-17 13:54:28.227').toISOString()),
+
+	dateTime2: datetime2(),
+	dateTime2ModeDate: datetime2({ mode: 'date' }),
+	dateTime2ModeString: datetime2({ mode: 'string' }),
+	dateTime2WithPrecision: datetime2({ precision: 5 }),
+	dateTime2Default: datetime2().default(new Date('2025-04-17 13:55:07.530')),
+	dateTime2ModeStringDefault: datetime2({ mode: 'string' }).default(
+		'2025-04-17 13:55:07.5300000',
+	),
+	dateTime2ModeStringWithPrecisionDefault: datetime2({ mode: 'string', precision: 1 }).default(
+		'2025-04-17 13:55:07.5300000',
+	),
+
+	datetimeOffset: datetimeoffset(),
+	datetimeOffsetModeDate: datetimeoffset({ mode: 'date' }),
+	datetimeOffsetModeString: datetimeoffset({ mode: 'string' }),
+	datetimeOffsetDefault: datetimeoffset().default(new Date('2025-04-18 11:47:41.000+3:00')),
+	datetimeOffsetModeStringDefault: datetimeoffset({ mode: 'string' }).default('2025-04-18 11:47:41.000+3:00'),
+	datetimeOffsetModeStringWithPrecisionDefault: datetimeoffset({ mode: 'string', precision: 1 }).default(
+		'2025-04-18 11:47:41.000+3:00',
+	),
+
+	decimal: decimal(),
+	decimalWithPrecision: decimal({ precision: 3 }),
+	decimalWithConfig: decimal({ precision: 10, scale: 8 }),
+	decimalDefaultString: decimal().default('1.312'),
+	decimalDefaultNumber: decimal({ mode: 'number' }).default(1.3),
+
+	float: float(),
+	floatWithPrecision: float({ precision: 3 }),
+	floatDefault: float().default(32.412),
+
+	int: int(),
+	intDefault: int().default(43),
+
+	numeric: numeric(),
+	numericWithPrecision: numeric({ precision: 3 }),
+	numericWithConfig: numeric({ precision: 10, scale: 8 }),
+	numericDefault: numeric().default('1.312'),
+	numericDefaultNumber: numeric({ mode: 'number' }).default(1.312),
+
+	real: real(),
+	realDefault: real().default(5231.4123),
+
+	text: text(),
+	textEnum: text({ enum: ['only', 'this', 'values'] }),
+	textDefault: text().default('hello, world'),
+
+	nText: ntext(),
+	nTextEnum: ntext({ enum: ['only', 'this', 'values'] }),
+	nTextDefault: ntext().default('hello, world'),
+
+	time: time(),
+	timeModeDate: time({ mode: 'date' }),
+	timeModeString: time({ mode: 'string' }),
+	timeWithPrecision: time({ precision: 3 }),
+	timeDefault: time().default(new Date('2025-10-10 14:17:56.470')),
+	timeModeDateDefault: time({ mode: 'date' }).default(new Date('2025-10-10 14:17:56.470')),
+	timeModeStringDefault: time({ mode: 'string' }).default('14:17:56.470'),
+
+	smallint: smallint(),
+	smallintDefault: smallint().default(331),
+
+	tinyint: tinyint(),
+	tinyintDefault: tinyint().default(23),
+
+	varbinary: varbinary(),
+	varbinaryWithLength: varbinary({ length: 100 }),
+	varbinaryDefault: varbinary().default(Buffer.from([0x01])),
+
+	varchar: varchar(),
+	varcharWithEnum: varchar({ enum: ['123', '312'], length: 3 }),
+	varcharWithLength: varchar({ length: 3 }),
+	varcharDefault: varchar().default('hello, world'),
+	varcharWithEnumDefault: varchar({ enum: ['1', '2'] }).default('1'),
+
+	nvarchar: nvarchar(),
+	nvarcharWithEnum: nvarchar({ enum: ['hello, world'], length: 12 }),
+	nvarcharLength: nvarchar({ length: 231 }),
+	nvarcharDefault: nvarchar().default('h'),
+	nvarcharJson: nvarchar({ mode: 'json', length: 'max' }),
+});
diff --git a/integration-tests/tests/mssql/schemaPrefixed.ts b/integration-tests/tests/mssql/schemaPrefixed.ts
new file mode 100644
index 0000000000..5b502e74e1
--- /dev/null
+++ b/integration-tests/tests/mssql/schemaPrefixed.ts
@@ -0,0 +1,24 @@
+import { sql } from 'drizzle-orm';
+import { bit, datetime, int, mssqlTableCreator, nvarchar, varchar } from 'drizzle-orm/mssql-core';
+
+const tablePrefix = 'drizzle_tests_';
+const mssqlTable = mssqlTableCreator((name) => `${tablePrefix}${name}`);
+
+export const usersTable = mssqlTable('userstest', {
+	id: int('id').identity().primaryKey(),
+	name: varchar('name', { length: 30 }).notNull(),
+	verified: bit('verified').notNull().default(false),
+	jsonb: nvarchar('jsonb', { length: 300, mode: 'json' }).$type<string[]>(),
+	createdAt: datetime('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
+});
+
+export const users2Table = mssqlTable('users2', {
+	id: int('id').primaryKey(),
+	name: varchar('name', { length: 30 }).notNull(),
+	cityId: int('city_id').default(sql`null`).references(() => citiesTable.id),
+});
+
+export const citiesTable = mssqlTable('cities', {
+	id: int('id').primaryKey(),
+	name: varchar('name', { length: 30 }).notNull(),
+});
diff --git a/integration-tests/tests/mysql/default/effect-mysql2.test.ts b/integration-tests/tests/mysql/default/effect-mysql2.test.ts
new file mode 100644
index 0000000000..763b72eff4
--- /dev/null
+++ b/integration-tests/tests/mysql/default/effect-mysql2.test.ts
@@ -0,0 +1,347 @@
+import { MysqlClient } from '@effect/sql-mysql2';
+import { expect } from '@effect/vitest';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as MySqlDrizzle from 'drizzle-orm/effect-mysql2';
+import { migrate } from 'drizzle-orm/effect-mysql2/migrator';
+import { getTableConfig, int, mysqlTable, text } from 'drizzle-orm/mysql-core';
+import { Redacted } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { DB, runCommonEffectMySqlTests } from '../effect-common';
+import relations from '../relations';
+import { usersMigratorTable } from '../schema2';
+
+if (!process.env['MYSQL_CONNECTION_STRING']) throw new Error('`MYSQL_CONNECTION_STRING` not set!');
+
+const MySqlClientLive = MysqlClient.layer({
+	url: Redacted.make(process.env['MYSQL_CONNECTION_STRING']!),
+});
+
+const dbEffect = MySqlDrizzle.make({ relations }).pipe(Effect.provide(MySqlDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const connectionStringFor = (database: string) => {
+	const url = new URL(process.env['MYSQL_CONNECTION_STRING']!);
+	url.pathname = `/${database}`;
+	return url.toString();
+};
+
+const onDatabase = <A, E, R>(
+	database: string,
+	use: (db: any) => Effect.Effect<A, E, R>,
+) =>
+	MySqlDrizzle.make({ relations }).pipe(
+		Effect.flatMap(use),
+		Effect.provide(MySqlDrizzle.DefaultServices),
+		Effect.provide(MysqlClient.layer({ url: Redacted.make(connectionStringFor(database)) })),
+	);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	MySqlDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(MySqlDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(MySqlClientLive, DBLive.pipe(Layer.provide(MySqlClientLive)));
+
+runCommonEffectMySqlTests({
+	testLayer: TestLive,
+	MySqlDrizzle: MySqlDrizzle,
+	createDB,
+	addTests: (it) => {
+		it.effect(
+			'migrator',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					yield* db.execute(sql`drop table if exists ${sql.identifier('__drizzle_migrations')}`);
+					yield* db.execute(sql`drop table if exists ${usersMigratorTable}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+					yield* migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+					yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+					const result = yield* db.select().from(usersMigratorTable);
+
+					expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				}),
+		);
+
+		it.effect(
+			'migrator : --init',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					const migrationsTable = 'drzl_init';
+
+					yield* db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+					yield* db.execute(sql`drop table if exists ${usersMigratorTable}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+					const migratorRes = yield* migrate(db, {
+						migrationsFolder: './drizzle2/mysql',
+						migrationsTable,
+						// @ts-ignore - internal param
+						init: true,
+					});
+
+					const meta = yield* db.select({
+						hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+						createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+					}).from(sql`${sql.identifier(migrationsTable)}`);
+
+					const res = yield* db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM INFORMATION_SCHEMA.TABLES
+						WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+						AND TABLE_SCHEMA = DATABASE()
+					) as ${sql.identifier('tableExists')};`);
+
+					expect(migratorRes).toStrictEqual(undefined);
+					expect(meta.length).toStrictEqual(1);
+					expect(!!res[0]?.tableExists).toStrictEqual(false);
+				}),
+		);
+
+		it.effect(
+			'migrator : --init - local migrations error',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					const migrationsTable = 'drzl_init';
+
+					yield* db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+					yield* db.execute(sql`drop table if exists ${usersMigratorTable}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+					const migratorRes = yield* Effect.flip(migrate(db, {
+						migrationsFolder: './drizzle2/mysql-init',
+
+						migrationsTable,
+						// @ts-ignore - internal param
+						init: true,
+					}));
+
+					const meta = yield* db.select({
+						hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+						createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+					}).from(sql`${sql.identifier(migrationsTable)}`);
+
+					const res = yield* db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM INFORMATION_SCHEMA.TABLES
+						WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+						AND TABLE_SCHEMA = DATABASE()
+					) as ${sql.identifier('tableExists')};`);
+
+					expect((migratorRes as Extract<typeof migratorRes, { exitCode: unknown }>).exitCode)
+						.toStrictEqual('localMigrations');
+					expect(meta.length).toStrictEqual(0);
+					expect(!!res[0]?.tableExists).toStrictEqual(false);
+				}),
+		);
+
+		it.effect(
+			'migrator : --init - db migrations error',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					const migrationsTable = 'drzl_init';
+
+					yield* db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+					yield* db.execute(sql`drop table if exists ${usersMigratorTable}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+					yield* db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+					yield* migrate(db, {
+						migrationsFolder: './drizzle2/mysql',
+						migrationsTable,
+					});
+
+					const migratorRes = yield* Effect.flip(migrate(db, {
+						migrationsFolder: './drizzle2/mysql-init',
+
+						migrationsTable,
+						// @ts-ignore - internal param
+						init: true,
+					}));
+
+					const meta = yield* db.select({
+						hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+						createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+					}).from(sql`${sql.identifier(migrationsTable)}`);
+
+					const res = yield* db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM INFORMATION_SCHEMA.TABLES
+						WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+						AND TABLE_SCHEMA = DATABASE()
+					) as ${sql.identifier('tableExists')};`);
+
+					expect((migratorRes as Extract<typeof migratorRes, { exitCode: unknown }>).exitCode)
+						.toStrictEqual('databaseMigrations');
+					expect(meta.length).toStrictEqual(1);
+					expect(!!res[0]?.tableExists).toStrictEqual(true);
+				}),
+		);
+
+		it.effect(
+			'migrator: local migration is unapplied. Migrations timestamp is less than last db migration',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					const users = mysqlTable('migration_users', {
+						id: int('id').primaryKey(),
+						name: text().notNull(),
+						email: text().notNull(),
+						age: int(),
+					});
+
+					const users2 = mysqlTable('migration_users2', {
+						id: int('id').primaryKey(),
+						name: text().notNull(),
+						email: text().notNull(),
+						age: int(),
+					});
+
+					yield* db.execute(sql`drop table if exists ${users}`);
+					yield* db.execute(sql`drop table if exists ${users2}`);
+
+					// create migration directory
+					const migrationDir = './migrations/mysql';
+					if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+					mkdirSync(migrationDir, { recursive: true });
+
+					// first branch
+					mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+					writeFileSync(
+						`${migrationDir}/20240101010101_initial/migration.sql`,
+						'CREATE TABLE `migration_users` (\n`id` INT PRIMARY KEY,\n`name` text NOT NULL,\n`email` text NOT NULL\n);',
+					);
+					mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+					writeFileSync(
+						`${migrationDir}/20240303030303_third/migration.sql`,
+						'ALTER TABLE `migration_users` ADD COLUMN `age` INT;',
+					);
+
+					yield* migrate(db, { migrationsFolder: migrationDir });
+					yield* db.insert(users).values({ id: 1, name: 'John', email: '', age: 30 });
+					const res1 = yield* db.select().from(users);
+
+					// second migration was not applied yet
+					yield* Effect.flip(db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 }));
+
+					// insert migration with earlier timestamp
+					mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+					writeFileSync(
+						`${migrationDir}/20240202020202_second/migration.sql`,
+						'CREATE TABLE `migration_users2` (\n`id` INT PRIMARY KEY,\n`name` text NOT NULL,\n`email` text NOT NULL\n,`age` INT\n);',
+					);
+					yield* migrate(db, { migrationsFolder: migrationDir });
+
+					yield* db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 });
+					const res2 = yield* db.select().from(users2);
+
+					const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+					expect(res1).toStrictEqual(expected);
+					expect(res2).toStrictEqual(expected);
+
+					rmSync(migrationDir, { recursive: true });
+				}),
+		);
+
+		it.effect(
+			'managing multiple databases #1',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					yield* db.execute('drop database if exists drizzle1;');
+					yield* db.execute('create database drizzle1;');
+					yield* db.execute('drop database if exists drizzle2;');
+					yield* db.execute('create database drizzle2;');
+
+					// drizzle1
+					const result1 = yield* onDatabase('drizzle1', (db1) =>
+						Effect.gen(function*() {
+							yield* migrate(db1, { migrationsFolder: './drizzle2/mysql' });
+							yield* db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+							return yield* db1.select().from(usersMigratorTable);
+						}));
+
+					// drizzle2
+					const result2 = yield* onDatabase('drizzle2', (db2) =>
+						Effect.gen(function*() {
+							yield* migrate(db2, { migrationsFolder: './drizzle2/mysql' });
+							yield* db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+							return yield* db2.select().from(usersMigratorTable);
+						}));
+
+					yield* db.execute('drop database if exists drizzle1;');
+					yield* db.execute('drop database if exists drizzle2;');
+
+					expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+					expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				}),
+		);
+
+		it.effect(
+			'managing multiple databases #2',
+			() =>
+				Effect.gen(function*() {
+					const db = yield* DB;
+					yield* db.execute('drop database if exists drizzle1;');
+					yield* db.execute('drop database if exists drizzle2;');
+					yield* db.execute('create database drizzle1;');
+					yield* db.execute('create database drizzle2;');
+
+					// drizzle1
+					const result1 = yield* onDatabase('drizzle1', (db1) =>
+						Effect.gen(function*() {
+							yield* migrate(db1, { migrationsFolder: './drizzle2/mysql' });
+							yield* db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+							return yield* db1.select().from(usersMigratorTable);
+						}));
+
+					// drizzle2
+					const result2 = yield* onDatabase('drizzle2', (db2) =>
+						Effect.gen(function*() {
+							yield* migrate(db2, { migrationsFolder: './drizzle2/mysql' });
+							yield* db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+							return yield* db2.select().from(usersMigratorTable);
+						}));
+
+					yield* db.execute('drop database drizzle1;');
+					yield* db.execute('drop database drizzle2;');
+
+					expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+					expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				}),
+		);
+	},
+});
diff --git a/integration-tests/tests/mysql/mysql-custom.test.ts b/integration-tests/tests/mysql/default/mysql-custom.test.ts
similarity index 80%
rename from integration-tests/tests/mysql/mysql-custom.test.ts
rename to integration-tests/tests/mysql/default/mysql-custom.test.ts
index 515de86f40..d6806ac60d 100644
--- a/integration-tests/tests/mysql/mysql-custom.test.ts
+++ b/integration-tests/tests/mysql/default/mysql-custom.test.ts
@@ -1,5 +1,3 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
 import { asc, eq, Name, sql } from 'drizzle-orm';
 import {
 	alias,
@@ -16,57 +14,11 @@ import {
 	varchar,
 	year,
 } from 'drizzle-orm/mysql-core';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
 import { migrate } from 'drizzle-orm/mysql2/migrator';
-import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { expect } from 'vitest';
 import { toLocalDate } from '~/utils';
-import { createDockerDB } from './mysql-common';
-
-const ENABLE_LOGGING = false;
-
-let db: MySql2Database;
-let client: mysql.Connection;
-let container: Docker.Container | undefined;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['MYSQL_CONNECTION_STRING']) {
-		connectionString = process.env['MYSQL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	client = await retry(async () => {
-		client = await mysql.createConnection(connectionString);
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end();
-	await container?.stop().catch(console.error);
-});
-
-beforeEach((ctx) => {
-	ctx.mysql = {
-		db,
-	};
-});
+import { mysqlTest as test } from '../instrumentation';
 
 const customSerial = customType<{ data: number; notNull: true; default: true }>({
 	dataType() {
@@ -159,7 +111,7 @@ const usersMigratorTable = mysqlTable('users12', {
 	email: text('email').notNull(),
 });
 
-beforeEach(async () => {
+test.beforeEach(async ({ db }) => {
 	await db.execute(sql`drop table if exists \`userstest\``);
 	await db.execute(sql`drop table if exists \`datestable\``);
 	await db.execute(sql`drop table if exists \`test_table\``);
@@ -200,9 +152,7 @@ beforeEach(async () => {
 	);
 });
 
-test('select all fields', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select all fields', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const result = await db.select().from(usersTable);
 
@@ -212,9 +162,7 @@ test('select all fields', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
 });
 
-test('select sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.select({
 		name: sql`upper(${usersTable.name})`,
@@ -223,9 +171,7 @@ test('select sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('select typed sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select typed sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.select({
 		name: sql<string>`upper(${usersTable.name})`,
@@ -234,35 +180,27 @@ test('select typed sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('insert returning sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert returning sql', async ({ db }) => {
 	const [result, _] = await db.insert(usersTable).values({ name: 'John' });
 
 	expect(result.insertId).toBe(1);
 });
 
-test('delete returning sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('delete returning sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
 
 	expect(users[0].affectedRows).toBe(1);
 });
 
-test('update returning sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('update returning sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
 
 	expect(users[0].changedRows).toBe(1);
 });
 
-test('update with returning all fields', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('update with returning all fields', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
 
@@ -276,9 +214,7 @@ test('update with returning all fields', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
 });
 
-test('update with returning partial', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('update with returning partial', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
 
@@ -291,27 +227,21 @@ test('update with returning partial', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
 });
 
-test('delete with returning all fields', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('delete with returning all fields', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
 
 	expect(deletedUser[0].affectedRows).toBe(1);
 });
 
-test('delete with returning partial', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('delete with returning partial', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
 
 	expect(deletedUser[0].affectedRows).toBe(1);
 });
 
-test('insert + select', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert + select', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const result = await db.select().from(usersTable);
 	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
@@ -324,9 +254,7 @@ test('insert + select', async (ctx) => {
 	]);
 });
 
-test('json insert', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('json insert', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
 	const result = await db.select({
 		id: usersTable.id,
@@ -337,18 +265,14 @@ test('json insert', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
 });
 
-test('insert with overridden default values', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert with overridden default values', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John', verified: true });
 	const result = await db.select().from(usersTable);
 
 	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
 });
 
-test('insert many', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert many', async ({ db }) => {
 	await db.insert(usersTable).values([
 		{ name: 'John' },
 		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
@@ -370,9 +294,7 @@ test('insert many', async (ctx) => {
 	]);
 });
 
-test('insert many with returning', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert many with returning', async ({ db }) => {
 	const result = await db.insert(usersTable).values([
 		{ name: 'John' },
 		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
@@ -383,9 +305,7 @@ test('insert many with returning', async (ctx) => {
 	expect(result[0].affectedRows).toBe(4);
 });
 
-test('select with group by as field', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select with group by as field', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -394,9 +314,7 @@ test('select with group by as field', async (ctx) => {
 	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
 });
 
-test('select with group by as sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select with group by as sql', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -405,9 +323,7 @@ test('select with group by as sql', async (ctx) => {
 	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
 });
 
-test('select with group by as sql + column', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select with group by as sql + column', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -416,9 +332,7 @@ test('select with group by as sql + column', async (ctx) => {
 	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 });
 
-test('select with group by as column + sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select with group by as column + sql', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -427,9 +341,7 @@ test('select with group by as column + sql', async (ctx) => {
 	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 });
 
-test('select with group by complex query', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select with group by complex query', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -440,9 +352,7 @@ test('select with group by complex query', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }]);
 });
 
-test('build query', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('build query', async ({ db }) => {
 	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
 		.groupBy(usersTable.id, usersTable.name)
 		.toSQL();
@@ -453,9 +363,7 @@ test('build query', async (ctx) => {
 	});
 });
 
-test('build query insert with onDuplicate', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('build query insert with onDuplicate', async ({ db }) => {
 	const query = db.insert(usersTable)
 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
 		.onDuplicateKeyUpdate({ set: { name: 'John1' } })
@@ -468,9 +376,7 @@ test('build query insert with onDuplicate', async (ctx) => {
 	});
 });
 
-test('insert with onDuplicate', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert with onDuplicate', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
@@ -485,9 +391,7 @@ test('insert with onDuplicate', async (ctx) => {
 	expect(res).toEqual([{ id: 1, name: 'John1' }]);
 });
 
-test('insert conflict', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert conflict', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
@@ -496,9 +400,7 @@ test('insert conflict', async (ctx) => {
 	})()).resolves.not.toThrowError();
 });
 
-test('insert conflict with ignore', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert conflict with ignore', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
@@ -513,16 +415,13 @@ test('insert conflict with ignore', async (ctx) => {
 	expect(res).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert sql', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: sql`${'John'}` });
 	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('partial join with alias', async (ctx) => {
-	const { db } = ctx.mysql;
+test('partial join with alias', async ({ db }) => {
 	const customerAlias = alias(usersTable, 'customer');
 
 	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
@@ -546,9 +445,7 @@ test('partial join with alias', async (ctx) => {
 	}]);
 });
 
-test('full join with alias', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('full join with alias', async ({ db }) => {
 	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
 
 	const users = mysqlTable('users', {
@@ -581,9 +478,7 @@ test('full join with alias', async (ctx) => {
 	await db.execute(sql`drop table ${users}`);
 });
 
-test('select from alias', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('select from alias', async ({ db }) => {
 	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
 
 	const users = mysqlTable('users', {
@@ -618,18 +513,14 @@ test('select from alias', async (ctx) => {
 	await db.execute(sql`drop table ${users}`);
 });
 
-test('insert with spaces', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert with spaces', async ({ db }) => {
 	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
 	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
 
 	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
 });
 
-test('prepared statement', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('prepared statement', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const statement = db.select({
 		id: usersTable.id,
@@ -641,9 +532,7 @@ test('prepared statement', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('prepared statement reuse', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('prepared statement reuse', async ({ db }) => {
 	const stmt = db.insert(usersTable).values({
 		verified: true,
 		name: sql.placeholder('name'),
@@ -673,9 +562,7 @@ test('prepared statement reuse', async (ctx) => {
 	]);
 });
 
-test('prepared statement with placeholder in .where', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('prepared statement with placeholder in .where', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const stmt = db.select({
 		id: usersTable.id,
@@ -688,9 +575,7 @@ test('prepared statement with placeholder in .where', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('migrator', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('migrator', async ({ db }) => {
 	await db.execute(sql`drop table if exists cities_migration`);
 	await db.execute(sql`drop table if exists users_migration`);
 	await db.execute(sql`drop table if exists users12`);
@@ -710,27 +595,21 @@ test('migrator', async (ctx) => {
 	await db.execute(sql`drop table __drizzle_migrations`);
 });
 
-test('insert via db.execute + select via db.execute', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert via db.execute + select via db.execute', async ({ db }) => {
 	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
 
 	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
 	expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert via db.execute w/ query builder', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert via db.execute w/ query builder', async ({ db }) => {
 	const inserted = await db.execute(
 		db.insert(usersTable).values({ name: 'John' }),
 	);
 	expect(inserted[0].affectedRows).toBe(1);
 });
 
-test('insert + select all possible dates', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('insert + select all possible dates', async ({ db }) => {
 	const date = new Date('2022-11-11');
 
 	await db.insert(datesTable).values({
@@ -766,9 +645,7 @@ const tableWithEnums = mysqlTable('enums_test_case', {
 	enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
 });
 
-test('Mysql enum test case #1', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('Mysql enum test case #1', async ({ db }) => {
 	await db.execute(sql`drop table if exists \`enums_test_case\``);
 
 	await db.execute(sql`
@@ -797,9 +674,7 @@ test('Mysql enum test case #1', async (ctx) => {
 	]);
 });
 
-test('custom binary', async (ctx) => {
-	const { db } = ctx.mysql;
-
+test('custom binary', async ({ db }) => {
 	const id = uuid().replace(/-/g, '');
 	await db.insert(testTable).values({
 		id,
diff --git a/integration-tests/tests/mysql/default/mysql-prefixed.test.ts b/integration-tests/tests/mysql/default/mysql-prefixed.test.ts
new file mode 100644
index 0000000000..5fb1080d9c
--- /dev/null
+++ b/integration-tests/tests/mysql/default/mysql-prefixed.test.ts
@@ -0,0 +1,1759 @@
+import type { Equal } from 'drizzle-orm';
+import { asc, eq, getTableName, gt, inArray, Name, sql, TransactionRollbackError } from 'drizzle-orm';
+import {
+	alias,
+	bigint,
+	boolean,
+	date,
+	datetime,
+	getViewConfig,
+	int,
+	json,
+	mysqlEnum,
+	mysqlTable as mysqlTableRaw,
+	mysqlTableCreator,
+	mysqlView,
+	serial,
+	text,
+	time,
+	timestamp,
+	uniqueIndex,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { migrate } from 'drizzle-orm/mysql2/migrator';
+import { expect } from 'vitest';
+import { Expect, toLocalDate } from '~/utils';
+import { mysqlTest as test } from '../instrumentation';
+
+const tablePrefix = 'drizzle_tests_';
+
+const mysqlTable = mysqlTableCreator((name) => `${tablePrefix}${name}`);
+
+test.concurrent('select all fields', async ({ db, push }) => {
+	const users = mysqlTable('users_1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.select().from(users);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.concurrent('select sql', async ({ db, push }) => {
+	const users = mysqlTable('users_sql', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.select({
+		name: sql`upper(${users.name})`,
+	}).from(users);
+
+	expect(result).toEqual([{ name: 'JOHN' }]);
+});
+
+test.concurrent('select typed sql', async ({ db, push }) => {
+	const users = mysqlTable('users_typed_sql', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.select({
+		name: sql<string>`upper(${users.name})`,
+	}).from(users);
+
+	expect(result).toEqual([{ name: 'JOHN' }]);
+});
+
+test.concurrent('select distinct', async ({ db, push }) => {
+	const usersDistinctTable = mysqlTable('users_distinct', {
+		id: int('id').notNull(),
+		name: text('name').notNull(),
+	});
+
+	await push({ usersDistinctTable });
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const result = await db.selectDistinct().from(usersDistinctTable).orderBy(
+		usersDistinctTable.id,
+		usersDistinctTable.name,
+	);
+
+	expect(result).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+});
+
+test.concurrent('insert returning sql', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_returning', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const [result, _] = await db.insert(users).values({ name: 'John' });
+
+	expect(result.insertId).toBe(1);
+});
+
+test.concurrent('delete returning sql', async ({ db, push }) => {
+	const users = mysqlTable('users_delete_returning', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.delete(users).where(eq(users.name, 'John'));
+
+	expect(result[0].affectedRows).toBe(1);
+});
+
+test.concurrent('update returning sql', async ({ db, push }) => {
+	const users = mysqlTable('users_update_returning', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.update(users).set({ name: 'Jane' }).where(eq(users.name, 'John'));
+
+	expect(result[0].changedRows).toBe(1);
+});
+
+test.concurrent('update with returning all fields', async ({ db, push }) => {
+	const users = mysqlTable('users_update_all_fields', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const updatedUsers = await db.update(users).set({ name: 'Jane' }).where(eq(users.name, 'John'));
+
+	const result = await db.select().from(users).where(eq(users.id, 1));
+
+	expect(updatedUsers[0].changedRows).toBe(1);
+
+	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	expect(result).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.concurrent('update with returning partial', async ({ db, push }) => {
+	const users = mysqlTable('users_update_partial', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const updatedUsers = await db.update(users).set({ name: 'Jane' }).where(eq(users.name, 'John'));
+
+	const result = await db.select({ id: users.id, name: users.name }).from(users).where(
+		eq(users.id, 1),
+	);
+
+	expect(updatedUsers[0].changedRows).toBe(1);
+
+	expect(result).toEqual([{ id: 1, name: 'Jane' }]);
+});
+
+test.concurrent('delete with returning all fields', async ({ db, push }) => {
+	const users = mysqlTable('users_delete_all_fields', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const deletedUser = await db.delete(users).where(eq(users.name, 'John'));
+
+	expect(deletedUser[0].affectedRows).toBe(1);
+});
+
+test.concurrent('delete with returning partial', async ({ db, push }) => {
+	const users = mysqlTable('users_delete_partial', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const deletedUser = await db.delete(users).where(eq(users.name, 'John'));
+
+	expect(deletedUser[0].affectedRows).toBe(1);
+});
+
+test.concurrent('insert + select', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_select_249', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const result = await db.select().from(users);
+	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+	await db.insert(users).values({ name: 'Jane' });
+	const result2 = await db.select().from(users);
+	expect(result2).toEqual([
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test.concurrent('json insert', async ({ db, push }) => {
+	const users = mysqlTable('users_json_insert_262', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db.select({
+		id: users.id,
+		name: users.name,
+		jsonb: users.jsonb,
+	}).from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test.concurrent('insert with overridden default values', async ({ db, push }) => {
+	const users = mysqlTable('users_override_defaults_273', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John', verified: true });
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.concurrent('insert many', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_many_307', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+	const result = await db.select({
+		id: users.id,
+		name: users.name,
+		jsonb: users.jsonb,
+		verified: users.verified,
+	}).from(users);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test.concurrent('insert many with returning', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_many_returning_329', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const result = await db.insert(users).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+
+	expect(result[0].affectedRows).toBe(4);
+});
+
+test.concurrent('select with group by as field', async ({ db, push }) => {
+	const users = mysqlTable('users_group_by_field_249', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: users.name }).from(users)
+		.groupBy(users.name);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test.concurrent('select with group by as sql', async ({ db, push }) => {
+	const users = mysqlTable('users_group_by_sql_250', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: users.name }).from(users)
+		.groupBy(sql`${users.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test.concurrent('select with group by as sql + column', async ({ db, push }) => {
+	const users = mysqlTable('users_group_by_sql_col_251', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: users.name }).from(users)
+		.groupBy(sql`${users.name}`, users.id);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test.concurrent('select with group by as column + sql', async ({ db, push }) => {
+	const users = mysqlTable('users_group_by_col_sql_252', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: users.name }).from(users)
+		.groupBy(users.id, sql`${users.name}`);
+
+	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test.concurrent('select with group by complex query', async ({ db, push }) => {
+	const users = mysqlTable('users_group_by_complex_253', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: users.name }).from(users)
+		.groupBy(users.id, sql`${users.name}`)
+		.orderBy(asc(users.name))
+		.limit(1);
+
+	expect(result).toEqual([{ name: 'Jane' }]);
+});
+
+test.concurrent('build query', async ({ db, push }) => {
+	const users = mysqlTable('users_build_query_254', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const query = db.select({ id: users.id, name: users.name }).from(users)
+		.groupBy(users.id, users.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `select \`id\`, \`name\` from \`${getTableName(users)}\` group by \`${getTableName(users)}\`.\`id\`, \`${
+			getTableName(users)
+		}\`.\`name\``,
+		params: [],
+	});
+});
+
+test.concurrent('build query insert with onDuplicate', async ({ db, push }) => {
+	const users = mysqlTable('users_on_duplicate_255', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const query = db.insert(users)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onDuplicateKeyUpdate({ set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `insert into \`${
+			getTableName(users)
+		}\` (\`id\`, \`name\`, \`verified\`, \`jsonb\`, \`created_at\`) values (default, ?, default, ?, default) on duplicate key update \`name\` = ?`,
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test.concurrent('insert with onDuplicate', async ({ db, push }) => {
+	const users = mysqlTable('users_on_duplicate_test_256', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users)
+		.values({ name: 'John' });
+
+	await db.insert(users)
+		.values({ id: 1, name: 'John' })
+		.onDuplicateKeyUpdate({ set: { name: 'John1' } });
+
+	const res = await db.select({ id: users.id, name: users.name }).from(users).where(
+		eq(users.id, 1),
+	);
+
+	expect(res).toEqual([{ id: 1, name: 'John1' }]);
+});
+
+test.concurrent('insert conflict', async ({ db, push }) => {
+	const users = mysqlTable('users_conflict_257', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users)
+		.values({ name: 'John' });
+
+	await expect((async () => {
+		db.insert(users).values({ id: 1, name: 'John1' });
+	})()).resolves.not.toThrowError();
+});
+
+test.concurrent('insert conflict with ignore', async ({ db, push }) => {
+	const users = mysqlTable('users_conflict_ignore_258', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users)
+		.values({ name: 'John' });
+
+	await db.insert(users)
+		.ignore()
+		.values({ id: 1, name: 'John1' });
+
+	const res = await db.select({ id: users.id, name: users.name }).from(users).where(
+		eq(users.id, 1),
+	);
+
+	expect(res).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('insert sql', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_sql_561', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: users.id, name: users.name }).from(users);
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('partial join with alias', async ({ db, push }) => {
+	const users = mysqlTable('users_partial_join_567', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const customerAlias = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: users.id,
+				name: users.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		}).from(users)
+		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([{
+		user: { id: 10, name: 'Ivan' },
+		customer: { id: 11, name: 'Hans' },
+	}]);
+});
+
+test.concurrent('full join with alias', async ({ db, push }) => {
+	const mysqlTableLocal = mysqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTableLocal('users_full_join_591', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users });
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select().from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	expect(result).toEqual([{
+		users_full_join_591: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+});
+
+test.concurrent('select from alias', async ({ db, push }) => {
+	const mysqlTableLocal = mysqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTableLocal('users_select_alias_638', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users });
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	expect(result).toEqual([{
+		user: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+});
+
+test.concurrent('insert with spaces', async ({ db, push }) => {
+	const users = mysqlTable('users_insert_spaces_669', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ id: users.id, name: users.name }).from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test.concurrent('prepared statement', async ({ db, push }) => {
+	const users = mysqlTable('users_prepared_676', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const statement = db.select({
+		id: users.id,
+		name: users.name,
+	}).from(users)
+		.prepare();
+	const result = await statement.execute();
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('prepared statement reuse', async ({ db, push }) => {
+	const users = mysqlTable('users_prepared_reuse_688', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const stmt = db.insert(users).values({
+		verified: true,
+		name: sql.placeholder('name'),
+	}).prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db.select({
+		id: users.id,
+		name: users.name,
+		verified: users.verified,
+	}).from(users);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test.concurrent('prepared statement with placeholder in .where', async ({ db, push }) => {
+	const users = mysqlTable('users_745', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ name: 'John' });
+	const stmt = db.select({
+		id: users.id,
+		name: users.name,
+	}).from(users)
+		.where(eq(users.id, sql.placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('migrator', async ({ db, push }) => {
+	const usersMigratorTable = mysqlTableRaw('users12_758', {
+		id: serial('id').primaryKey(),
+		name: varchar('name', { length: 100 }).notNull(),
+		email: text('email').notNull(),
+	}, (table) => [uniqueIndex('name_unique_idx').on(table.name).using('btree')]);
+
+	await push({ usersMigratorTable });
+	await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+});
+
+test.concurrent('insert via db.execute + select via db.execute', async ({ db, push }) => {
+	const users = mysqlTable('users_788', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.execute(sql`insert into ${users} (${new Name(users.name.name)}) values (${'John'})`);
+
+	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${users}`);
+	expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('insert via db.execute w/ query builder', async ({ db, push }) => {
+	const users = mysqlTable('users_795', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const inserted = await db.execute(
+		db.insert(users).values({ name: 'John' }),
+	);
+	expect(inserted[0].affectedRows).toBe(1);
+});
+
+test.concurrent('insert + select all possible dates', async ({ db, push }) => {
+	const datesTable = mysqlTable('datestable_802', {
+		date: date('date'),
+		dateAsString: date('date_as_string', { mode: 'string' }),
+		time: time('time', { fsp: 1 }),
+		datetime: datetime('datetime', { fsp: 2 }),
+		datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
+		year: year('year'),
+	});
+
+	await push({ datesTable });
+
+	const d = new Date('2022-11-11');
+
+	await db.insert(datesTable).values({
+		date: d,
+		dateAsString: '2022-11-11',
+		time: '12:12:12',
+		datetime: d,
+		year: 22,
+		datetimeAsString: '2022-11-11 12:12:12',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	expect(res[0]?.date).toBeInstanceOf(Date);
+	expect(res[0]?.datetime).toBeInstanceOf(Date);
+	expect(typeof res[0]?.dateAsString).toBe('string');
+	expect(typeof res[0]?.datetimeAsString).toBe('string');
+
+	expect(res).toEqual([{
+		date: toLocalDate(new Date('2022-11-11')),
+		dateAsString: '2022-11-11',
+		time: '12:12:12.0',
+		datetime: new Date('2022-11-11'),
+		year: 2022,
+		datetimeAsString: '2022-11-11 12:12:12.00',
+	}]);
+});
+
+test.concurrent('Mysql enum test case #1', async ({ db, push }) => {
+	const tableWithEnums = mysqlTable('enums_test_case_856', {
+		id: serial('id').primaryKey(),
+		enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
+		enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
+		enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
+	});
+
+	await push({ tableWithEnums });
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	expect(res).toEqual([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test.concurrent('left join (flat object fields)', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_892', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const cities = mysqlTable('cities_892', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users2, cities });
+	await db.insert(cities)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select({
+		userId: users2.id,
+		userName: users2.name,
+		cityId: cities.id,
+		cityName: cities.name,
+	}).from(users2)
+		.leftJoin(cities, eq(users2.cityId, cities.id));
+
+	expect(res).toEqual([
+		{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+	]);
+});
+
+test.concurrent('left join (grouped fields)', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_912', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const cities = mysqlTable('cities_912', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users2, cities });
+	await db.insert(cities)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select({
+		id: users2.id,
+		user: {
+			name: users2.name,
+			nameUpper: sql<string>`upper(${users2.name})`,
+		},
+		city: {
+			id: cities.id,
+			name: cities.name,
+			nameUpper: sql<string>`upper(${cities.name})`,
+		},
+	}).from(users2)
+		.leftJoin(cities, eq(users2.cityId, cities.id));
+
+	expect(res).toEqual([
+		{
+			id: 1,
+			user: { name: 'John', nameUpper: 'JOHN' },
+			city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+		},
+		{
+			id: 2,
+			user: { name: 'Jane', nameUpper: 'JANE' },
+			city: null,
+		},
+	]);
+});
+
+test.concurrent('left join (all fields)', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_946', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const cities = mysqlTable('cities_946', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users2, cities });
+	await db.insert(cities)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select().from(users2)
+		.leftJoin(cities, eq(users2.cityId, cities.id));
+
+	expect(res).toEqual([
+		{
+			users2_946: {
+				id: 1,
+				name: 'John',
+				cityId: 1,
+			},
+			cities_946: {
+				id: 1,
+				name: 'Paris',
+			},
+		},
+		{
+			users2_946: {
+				id: 2,
+				name: 'Jane',
+				cityId: null,
+			},
+			cities_946: null,
+		},
+	]);
+});
+
+test.concurrent('join subquery', async ({ db, push }) => {
+	const coursesTable = mysqlTable('courses_978', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		categoryId: bigint('category_id', { mode: 'number', unsigned: true }).references(() => courseCategoriesTable.id),
+	});
+
+	const courseCategoriesTable = mysqlTable('course_categories_978', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ coursesTable, courseCategoriesTable });
+
+	await db.insert(courseCategoriesTable).values([
+		{ name: 'Category 1' },
+		{ name: 'Category 2' },
+		{ name: 'Category 3' },
+		{ name: 'Category 4' },
+	]);
+
+	await db.insert(coursesTable).values([
+		{ name: 'Development', categoryId: 2 },
+		{ name: 'IT & Software', categoryId: 3 },
+		{ name: 'Marketing', categoryId: 4 },
+		{ name: 'Design', categoryId: 1 },
+	]);
+
+	const sq2 = db
+		.select({
+			categoryId: courseCategoriesTable.id,
+			category: courseCategoriesTable.name,
+			total: sql<number>`count(${courseCategoriesTable.id})`,
+		})
+		.from(courseCategoriesTable)
+		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+		.as('sq2');
+
+	const res = await db
+		.select({
+			courseName: coursesTable.name,
+			categoryId: sq2.categoryId,
+		})
+		.from(coursesTable)
+		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+		.orderBy(coursesTable.name);
+
+	expect(res).toEqual([
+		{ courseName: 'Design', categoryId: 1 },
+		{ courseName: 'Development', categoryId: 2 },
+		{ courseName: 'IT & Software', categoryId: 3 },
+		{ courseName: 'Marketing', categoryId: 4 },
+	]);
+});
+
+test.concurrent('with ... select', async ({ db, push }) => {
+	const orders = mysqlTable('orders_1056', {
+		id: serial('id').primaryKey(),
+		region: text('region').notNull(),
+		product: text('product').notNull(),
+		amount: int('amount').notNull(),
+		quantity: int('quantity').notNull(),
+	});
+
+	await push({ orders });
+
+	await db.insert(orders).values([
+		{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+		{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+	]);
+
+	const regionalSales = db
+		.$with('regional_sales')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region),
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as(
+			db
+				.select({
+					region: regionalSales.region,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				),
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+			productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+		.groupBy(orders.region, orders.product)
+		.orderBy(orders.region, orders.product);
+
+	expect(result).toEqual([
+		{
+			region: 'Europe',
+			product: 'A',
+			productUnits: 3,
+			productSales: 30,
+		},
+		{
+			region: 'Europe',
+			product: 'B',
+			productUnits: 5,
+			productSales: 50,
+		},
+		{
+			region: 'US',
+			product: 'A',
+			productUnits: 7,
+			productSales: 70,
+		},
+		{
+			region: 'US',
+			product: 'B',
+			productUnits: 9,
+			productSales: 90,
+		},
+	]);
+});
+
+test.concurrent('select from subquery sql', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_1160', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	await push({ users2 });
+	await db.insert(users2).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const sq = db
+		.select({ name: sql<string>`concat(${users2.name}, " modified")`.as('name') })
+		.from(users2)
+		.as('sq');
+
+	const res = await db.select({ name: sq.name }).from(sq);
+
+	expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test.concurrent('select a field without joining its table', ({ db }) => {
+	const users = mysqlTable('users_1173', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	const users2 = mysqlTable('users2_1173', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	expect(() => db.select({ name: users2.name }).from(users).prepare()).toThrowError();
+});
+
+test.concurrent('select all fields from subquery without alias', ({ db }) => {
+	const users2 = mysqlTable('users2_1177', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2.name})` }).from(users2));
+
+	expect(() => db.select().from(sq).prepare()).toThrowError();
+});
+
+test.concurrent('select count()', async ({ db, push }) => {
+	const users = mysqlTable('users_1183', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: sql`count(*)` }).from(users);
+
+	expect(res).toEqual([{ count: 2 }]);
+});
+
+test.concurrent('select for ...', ({ db }) => {
+	const users2 = mysqlTable('users2_1191', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	{
+		const query = db.select().from(users2).for('update').toSQL();
+		expect(query.sql).toMatch(/ for update$/);
+	}
+	{
+		const query = db.select().from(users2).for('share', { skipLocked: true }).toSQL();
+		expect(query.sql).toMatch(/ for share skip locked$/);
+	}
+	{
+		const query = db.select().from(users2).for('update', { noWait: true }).toSQL();
+		expect(query.sql).toMatch(/ for update nowait$/);
+	}
+});
+
+test.concurrent('having', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_1206', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const cities = mysqlTable('cities_1206', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users2, cities });
+	await db.insert(cities).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+	await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
+		name: 'Jack',
+		cityId: 2,
+	}]);
+
+	const result = await db
+		.select({
+			id: cities.id,
+			name: sql<string>`upper(${cities.name})`.as('upper_name'),
+			usersCount: sql<number>`count(${users2.id})`.as('users_count'),
+		})
+		.from(cities)
+		.leftJoin(users2, eq(users2.cityId, cities.id))
+		.where(({ name }) => sql`length(${name}) >= 3`)
+		.groupBy(cities.id)
+		.having(({ usersCount }) => sql`${usersCount} > 0`)
+		.orderBy(({ name }) => name);
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			name: 'LONDON',
+			usersCount: 2,
+		},
+		{
+			id: 2,
+			name: 'PARIS',
+			usersCount: 1,
+		},
+	]);
+});
+
+test.concurrent('view', async ({ db, push }) => {
+	const users2 = mysqlTable('users2_1241', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const cities = mysqlTable('cities_1241', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const newYorkers1 = mysqlView('new_yorkers_1241')
+		.as((qb) => qb.select().from(users2).where(eq(users2.cityId, 1)));
+
+	const newYorkers2 = mysqlView('new_yorkers_1241', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).as(sql`select * from ${users2} where ${eq(users2.cityId, 1)}`);
+
+	const newYorkers3 = mysqlView('new_yorkers_1241', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).existing();
+
+	await push({ users2, cities });
+	await db.execute(sql`create view new_yorkers_1241 as ${getViewConfig(newYorkers1).query}`);
+
+	await db.insert(cities).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+	await db.insert(users2).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 1 },
+		{ name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+		expect(result).toEqual([
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test.concurrent('select from raw sql', async ({ db }) => {
+	const result = await db.select({
+		id: sql<number>`id`,
+		name: sql<string>`name`,
+	}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+	Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.concurrent('select from raw sql with joins', async ({ db }) => {
+	const result = await db
+		.select({
+			id: sql<number>`users.id`,
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+	]);
+});
+
+test.concurrent('join on aliased sql from select', async ({ db }) => {
+	const result = await db
+		.select({
+			userId: sql<number>`users.id`.as('userId'),
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityId: sql<number>`cities.id`.as('cityId'),
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.concurrent('join on aliased sql from with clause', async ({ db }) => {
+	const users = db.$with('users').as(
+		db.select({
+			id: sql<number>`id`.as('userId'),
+			name: sql<string>`name`.as('userName'),
+			city: sql<string>`city`.as('city'),
+		}).from(
+			sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+		),
+	);
+
+	const cities = db.$with('cities').as(
+		db.select({
+			id: sql<number>`id`.as('cityId'),
+			name: sql<string>`name`.as('cityName'),
+		}).from(
+			sql`(select 1 as id, 'Paris' as name) as cities`,
+		),
+	);
+
+	const result = await db
+		.with(users, cities)
+		.select({
+			userId: users.id,
+			name: users.name,
+			userCity: users.city,
+			cityId: cities.id,
+			cityName: cities.name,
+		})
+		.from(users)
+		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	expect(result).toEqual([
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.concurrent('prefixed table', async ({ db, push }) => {
+	const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
+
+	const users = mysqlTable('test_prefixed_table_with_unique_name_1450', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await push({ users });
+	await db.insert(users).values({ id: 1, name: 'John' });
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, name: 'John' }]);
+});
+
+test.concurrent('orderBy with aliased column', ({ db }) => {
+	const users2 = mysqlTable('users2_1473', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id'),
+	});
+
+	const query = db.select({
+		test: sql`something`.as('test'),
+	}).from(users2).orderBy((fields) => fields.test).toSQL();
+
+	expect(query.sql).toBe(`select something as \`test\` from \`${getTableName(users2)}\` order by \`test\``);
+});
+
+test.concurrent('timestamp timezone', async ({ db, push }) => {
+	const users = mysqlTable('users_1481', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	await push({ users });
+	const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+	await db.insert(users).values({ name: 'With default times' });
+	await db.insert(users).values({
+		name: 'Without default times',
+		createdAt: date,
+	});
+	const usersResult = await db.select().from(users);
+
+	// check that the timestamps are set correctly for default times
+	expect(Math.abs(usersResult[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
+
+	// check that the timestamps are set correctly for non default times
+	expect(Math.abs(usersResult[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
+});
+
+test('transaction', async ({ db, push }) => {
+	const users = mysqlTable('users_transactions_1498', {
+		id: serial('id').primaryKey(),
+		balance: int('balance').notNull(),
+	});
+	const products = mysqlTable('products_transactions_1498', {
+		id: serial('id').primaryKey(),
+		price: int('price').notNull(),
+		stock: int('stock').notNull(),
+	});
+
+	await push({ users, products });
+
+	const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
+	const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
+	const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
+	const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
+
+	await db.transaction(async (tx) => {
+		await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+		await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 90 }]);
+});
+
+test.concurrent('transaction rollback', async ({ db, push }) => {
+	const users = mysqlTable('users_transactions_rollback_1535', {
+		id: serial('id').primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await push({ users });
+
+	await expect((async () => {
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+			tx.rollback();
+		});
+	})()).rejects.toThrowError(TransactionRollbackError);
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([]);
+});
+
+test('nested transaction', async ({ db, push }) => {
+	const users = mysqlTable('users_nested_transactions_1561', {
+		id: serial('id').primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await push({ users });
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await tx.transaction(async (tx) => {
+			await tx.update(users).set({ balance: 200 });
+		});
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 200 }]);
+});
+
+test('nested transaction rollback', async ({ db, push }) => {
+	const users = mysqlTable('users_nested_transactions_rollback_1588', {
+		id: serial('id').primaryKey(),
+		balance: int('balance').notNull(),
+	});
+
+	await push({ users });
+
+	await db.transaction(async (tx) => {
+		await tx.insert(users).values({ balance: 100 });
+
+		await expect((async () => {
+			await tx.transaction(async (tx) => {
+				await tx.update(users).set({ balance: 200 });
+				tx.rollback();
+			});
+		})()).rejects.toThrowError(TransactionRollbackError);
+	});
+
+	const result = await db.select().from(users);
+
+	expect(result).toEqual([{ id: 1, balance: 100 }]);
+});
+
+test.concurrent('join subquery with join', async ({ db, push }) => {
+	const internalStaff = mysqlTable('internal_staff_1618', {
+		userId: int('user_id').notNull(),
+	});
+
+	const customUser = mysqlTable('custom_user_1618', {
+		id: int('id').notNull(),
+	});
+
+	const ticket = mysqlTable('ticket_1618', {
+		staffId: int('staff_id').notNull(),
+	});
+
+	await push({ internalStaff, customUser, ticket });
+
+	await db.insert(internalStaff).values({ userId: 1 });
+	await db.insert(customUser).values({ id: 1 });
+	await db.insert(ticket).values({ staffId: 1 });
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+		.as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff_1618.userId, ticket.staffId));
+
+	expect(mainQuery).toEqual([{
+		ticket_1618: { staffId: 1 },
+		internal_staff: {
+			internal_staff_1618: { userId: 1 },
+			custom_user_1618: { id: 1 },
+		},
+	}]);
+});
+
+test.concurrent('subquery with view', async ({ db, push }) => {
+	const users = mysqlTable('users_subquery_view_1667', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mysqlView('new_yorkers_1667').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await push({ users });
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.$with('sq').as(db.select().from(newYorkers));
+	const result = await db.with(sq).select().from(sq);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+
+	expect(result).toEqual([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 1 },
+	]);
+});
+
+test.concurrent('join view as subquery', async ({ db, push }) => {
+	const users = mysqlTable('users_join_view_1703', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mysqlView('new_yorkers_1703').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await push({ users });
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+	const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+	expect(result).toEqual([
+		{
+			users_join_view_1703: { id: 1, name: 'John', cityId: 1 },
+			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+		},
+		{
+			users_join_view_1703: { id: 2, name: 'Jane', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+		{
+			users_join_view_1703: { id: 3, name: 'Jack', cityId: 1 },
+			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+		},
+		{
+			users_join_view_1703: { id: 4, name: 'Jill', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+});
+
+test.concurrent('select iterator', async ({ db, push }) => {
+	const users = mysqlTable('users_iterator_1754', {
+		id: serial('id').primaryKey(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{}, {}, {}]);
+
+	const iter = db.select().from(users).iterator();
+
+	const result: typeof users.$inferSelect[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test.concurrent('select iterator w/ prepared statement', async ({ db, push }) => {
+	const users = mysqlTable('users_iterator_1775', {
+		id: serial('id').primaryKey(),
+	});
+
+	await push({ users });
+	await db.insert(users).values([{}, {}, {}]);
+
+	const prepared = db.select().from(users).prepare();
+	const iter = prepared.iterator();
+	const result: typeof users.$inferSelect[] = [];
+
+	for await (const row of iter) {
+		result.push(row);
+	}
+
+	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+});
+
+test.concurrent('insert undefined', async ({ db, push }) => {
+	const users = mysqlTable('users_1796', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await push({ users });
+
+	await expect((async () => {
+		await db.insert(users).values({ name: undefined });
+	})()).resolves.not.toThrowError();
+});
+
+test.concurrent('update undefined', async ({ db, push }) => {
+	const users = mysqlTable('users_1815', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await push({ users });
+
+	await expect((async () => {
+		await db.update(users).set({ name: undefined });
+	})()).rejects.toThrowError();
+
+	await expect((async () => {
+		await db.update(users).set({ id: 1, name: undefined });
+	})()).resolves.not.toThrowError();
+});
diff --git a/integration-tests/tests/mysql/default/mysql-proxy.test.ts b/integration-tests/tests/mysql/default/mysql-proxy.test.ts
new file mode 100644
index 0000000000..8eb729e59e
--- /dev/null
+++ b/integration-tests/tests/mysql/default/mysql-proxy.test.ts
@@ -0,0 +1,280 @@
+import { sql } from 'drizzle-orm';
+import { getTableConfig } from 'drizzle-orm/mysql-core';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+import { createConnection } from 'mysql2/promise';
+import { describe, expect } from 'vitest';
+import { proxyTest } from '../instrumentation';
+import { proxyTest as test } from '../instrumentation';
+import { tests } from '../mysql-common';
+import { usersMigratorTable } from '../schema2';
+
+const omit = new Set([
+	'nested transaction rollback',
+	'nested transaction',
+	'transaction rollback',
+	'transaction',
+	'transaction with options (set isolationLevel)',
+	'RQB v2 transaction find first - no rows',
+	'RQB v2 transaction find first - multiple rows',
+	'RQB v2 transaction find first - with relation',
+	'RQB v2 transaction find first - placeholders',
+	'RQB v2 transaction find many - no rows',
+	'RQB v2 transaction find many - multiple rows',
+	'RQB v2 transaction find many - with relation',
+	'RQB v2 transaction find many - placeholders',
+]);
+
+tests(proxyTest, omit);
+
+describe('migrator', () => {
+	test('migrator', async ({ db, simulator }) => {
+		await db.execute(sql`drop table if exists ${sql.identifier('__drizzle_migrations')}`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('migrator : --init', async ({ db, simulator }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db, simulator }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db, simulator }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('managing multiple databases #1', async ({ db, simulator }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		await db.execute(`use drizzle1`);
+		await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		await db.execute(`use drizzle2`);
+		await migrate(db, async (queries) => {
+			try {
+				await simulator.migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		// drizzle2
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db.select().from(usersMigratorTable);
+
+		// drizzle1
+		await db.execute(`use drizzle1`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db.select().from(usersMigratorTable);
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('managing multiple databases #2', async ({ db, createDB, createSimulator }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		const migrationsTable = 'drzl_init';
+
+		const client1 = await createConnection({ uri: process.env['MYSQL_CONNECTION_STRING'], database: 'drizzle1' });
+		const client2 = await createConnection({ uri: process.env['MYSQL_CONNECTION_STRING'], database: 'drizzle2' });
+
+		const db1 = createDB({ proxyClient: client1 });
+		const db2 = createDB({ proxyClient: client2 });
+
+		await migrate(db1, async (queries) => {
+			try {
+				await createSimulator(client1).migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		await migrate(db2, async (queries) => {
+			try {
+				await createSimulator(client2).migrations(queries);
+			} catch (e) {
+				console.error(e);
+				throw new Error('Proxy server cannot run migrations');
+			}
+		}, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		// drizzle1
+		await db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db1.select().from(usersMigratorTable);
+
+		// drizzle2
+		await db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db2.select().from(usersMigratorTable);
+
+		await db.execute('drop database drizzle1;');
+		await db.execute('drop database drizzle2;');
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+});
diff --git a/integration-tests/tests/mysql/default/mysql.test.ts b/integration-tests/tests/mysql/default/mysql.test.ts
new file mode 100644
index 0000000000..c5d4366286
--- /dev/null
+++ b/integration-tests/tests/mysql/default/mysql.test.ts
@@ -0,0 +1,250 @@
+import { sql } from 'drizzle-orm';
+import { getTableConfig, int, mysqlTable, text } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { migrate } from 'drizzle-orm/mysql2/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { createConnection } from 'mysql2/promise';
+import { describe, expect } from 'vitest';
+import { mysqlTest as test } from '../instrumentation';
+import { tests } from '../mysql-common';
+import { runTests } from '../mysql-common-cache';
+import { usersMigratorTable } from '../schema2';
+
+runTests('mysql', test);
+tests(test);
+
+describe('migrator', () => {
+	test('migrator', async ({ db }) => {
+		await db.execute(sql`drop table if exists ${sql.identifier('__drizzle_migrations')}`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('migrator : --init', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+                SELECT 1
+                FROM INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+            ) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+                SELECT 1
+                FROM INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+            ) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+                SELECT 1
+                FROM INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+				AND TABLE_SCHEMA = DATABASE()
+            ) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res[0]?.[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+		const users = mysqlTable('migration_users', {
+			id: int('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: int(),
+		});
+
+		const users2 = mysqlTable('migration_users2', {
+			id: int('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: int(),
+		});
+
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/mysql';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			'CREATE TABLE `migration_users` (\n`id` INT PRIMARY KEY,\n`name` text NOT NULL,\n`email` text NOT NULL\n);',
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			'ALTER TABLE `migration_users` ADD COLUMN `age` INT;',
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		await db.insert(users).values({ id: 1, name: 'John', email: '', age: 30 });
+		const res1 = await db.select().from(users);
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			'CREATE TABLE `migration_users2` (\n`id` INT PRIMARY KEY,\n`name` text NOT NULL,\n`email` text NOT NULL\n,`age` INT\n);',
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		await db.insert(users2).values({ id: 1, name: 'John', email: '', age: 30 });
+		const res2 = await db.select().from(users2);
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
+
+	test('managing multiple databases #1', async ({ db }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		await db.execute(`use drizzle1`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.execute(`use drizzle2`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle2
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db.select().from(usersMigratorTable);
+
+		// drizzle1
+		await db.execute(`use drizzle1`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db.select().from(usersMigratorTable);
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('managing multiple databases #2', async ({ db }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle1;');
+		await db.execute('create database drizzle2;');
+
+		const client1 = await createConnection({ uri: process.env['MYSQL_CONNECTION_STRING'], database: 'drizzle1' });
+		const client2 = await createConnection({ uri: process.env['MYSQL_CONNECTION_STRING'], database: 'drizzle2' });
+
+		const db1 = drizzle({ client: client1 });
+		const db2 = drizzle({ client: client2 });
+
+		await migrate(db1, { migrationsFolder: './drizzle2/mysql' });
+
+		await migrate(db2, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle1
+		await db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db1.select().from(usersMigratorTable);
+
+		// drizzle2
+		await db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db2.select().from(usersMigratorTable);
+
+		await db.execute('drop database drizzle1;');
+		await db.execute('drop database drizzle2;');
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+});
diff --git a/integration-tests/tests/mysql/default/schema.test.ts b/integration-tests/tests/mysql/default/schema.test.ts
new file mode 100644
index 0000000000..92066d55f6
--- /dev/null
+++ b/integration-tests/tests/mysql/default/schema.test.ts
@@ -0,0 +1,263 @@
+import { sql } from 'drizzle-orm';
+import { jsonb } from 'drizzle-orm/cockroach-core';
+import {
+	bigint,
+	boolean,
+	foreignKey,
+	getTableConfig,
+	index,
+	int,
+	json,
+	mediumint,
+	MySqlDialect,
+	mysqlTable,
+	mysqlTableCreator,
+	primaryKey,
+	serial,
+	smallint,
+	text,
+	timestamp,
+	tinyint,
+	unique,
+} from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { expect, test } from 'vitest';
+
+const db = drizzle.mock();
+
+test('table config: unsigned ints', async () => {
+	const unsignedInts = mysqlTable('cities1', {
+		bigint: bigint({ mode: 'number', unsigned: true }),
+		int: int({ unsigned: true }),
+		smallint: smallint({ unsigned: true }),
+		mediumint: mediumint({ unsigned: true }),
+		tinyint: tinyint({ unsigned: true }),
+	});
+
+	const tableConfig = getTableConfig(unsignedInts);
+
+	const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+	const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+	const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+	const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+	const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+	expect(bigintColumn.getSQLType()).toBe('bigint unsigned');
+	expect(intColumn.getSQLType()).toBe('int unsigned');
+	expect(smallintColumn.getSQLType()).toBe('smallint unsigned');
+	expect(mediumintColumn.getSQLType()).toBe('mediumint unsigned');
+	expect(tinyintColumn.getSQLType()).toBe('tinyint unsigned');
+});
+
+test('table config: signed ints', async () => {
+	const unsignedInts = mysqlTable('cities1', {
+		bigint: bigint('bigint', { mode: 'number' }),
+		int: int('int'),
+		smallint: smallint('smallint'),
+		mediumint: mediumint('mediumint'),
+		tinyint: tinyint('tinyint'),
+	});
+
+	const tableConfig = getTableConfig(unsignedInts);
+
+	const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+	const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+	const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+	const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+	const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+	expect(bigintColumn.getSQLType()).toBe('bigint');
+	expect(intColumn.getSQLType()).toBe('int');
+	expect(smallintColumn.getSQLType()).toBe('smallint');
+	expect(mediumintColumn.getSQLType()).toBe('mediumint');
+	expect(tinyintColumn.getSQLType()).toBe('tinyint');
+});
+
+test('table config: foreign keys name', async () => {
+	const table = mysqlTable('cities', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		state: text(),
+	}, (t) => [foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' })]);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.foreignKeys).toHaveLength(1);
+	expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
+});
+
+test('table config: primary keys name', async () => {
+	const table = mysqlTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => [primaryKey({ columns: [t.id, t.name] })]);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.primaryKeys).toHaveLength(1);
+});
+
+test('table configs: unique third param', async () => {
+	const cities1Table = mysqlTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => [unique('custom_name').on(t.name, t.state), unique('custom_name1').on(t.name, t.state)]);
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+	expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
+	expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+
+	expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
+	expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+});
+
+test('table configs: unique in column', async () => {
+	const cities1Table = mysqlTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull().unique(),
+		state: text('state').unique('custom'),
+		field: text('field').unique('custom_field'),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+	expect(columnName?.uniqueName).toBe(undefined);
+	expect(columnName?.isUnique).toBeTruthy();
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	expect(columnState?.uniqueName).toBe('custom');
+	expect(columnState?.isUnique).toBeTruthy();
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	expect(columnField?.uniqueName).toBe('custom_field');
+	expect(columnField?.isUnique).toBeTruthy();
+});
+
+test('prefixed', () => {
+	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const dialect = new MySqlDialect();
+	// await db.execute(`);
+	expect(dialect.sqlToQuery(sql`drop table if exists ${users}`)).toStrictEqual({
+		sql: 'drop table if exists `prefixed_users`',
+		params: [],
+	});
+
+	expect(dialect.sqlToQuery(sql`create table ${users} (id serial primary key, name text not null)`)).toStrictEqual({
+		sql: 'create table `prefixed_users` (id serial primary key, name text not null)',
+		params: [],
+	});
+});
+
+test.concurrent('define constraints as array', async () => {
+	const table = mysqlTable('name', {
+		id: int(),
+	}, (t) => [
+		index('name').on(t.id),
+		primaryKey({ columns: [t.id] }),
+	]);
+
+	const { indexes, primaryKeys } = getTableConfig(table);
+
+	expect(indexes.length).toBe(1);
+	expect(primaryKeys.length).toBe(1);
+});
+
+test('define constraints as array inside third param', async () => {
+	const table = mysqlTable('name', {
+		id: int(),
+	}, (t) => [
+		[index('name').on(t.id), primaryKey({ columns: [t.id] })],
+	]);
+
+	const { indexes, primaryKeys } = getTableConfig(table);
+
+	expect(indexes.length).toBe(1);
+	expect(primaryKeys.length).toBe(1);
+});
+
+test.concurrent('build query', async () => {
+	const table = mysqlTable('table', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+
+	const query = db.select({ id: table.id, name: table.name }).from(table)
+		.groupBy(table.id, table.name)
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: `select \`id\`, \`name\` from \`table\` group by \`table\`.\`id\`, \`table\`.\`name\``,
+		params: [],
+	});
+});
+
+test.concurrent('Query check: Insert all defaults in 1 row', async () => {
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	const query = db
+		.insert(users)
+		.values({})
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
+		params: [],
+	});
+});
+
+test.concurrent('Query check: Insert all defaults in multiple rows', async () => {
+	const users = mysqlTable('table', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state').default('UA'),
+	});
+
+	const query = db
+		.insert(users)
+		.values([{}, {}])
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: 'insert into `table` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
+		params: [],
+	});
+});
+
+test.concurrent('build query insert with onDuplicate', async () => {
+	const users = mysqlTable('users', {
+		id: serial().primaryKey(),
+		name: text().default('Dan'),
+		verified: boolean().default(false),
+		jsonb: jsonb(),
+	});
+
+	const query = db.insert(users)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onDuplicateKeyUpdate({ set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into `users` (`id`, `name`, `verified`, `jsonb`) values (default, ?, default, ?) on duplicate key update `name` = ?',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
diff --git a/integration-tests/tests/mysql/effect-common.ts b/integration-tests/tests/mysql/effect-common.ts
new file mode 100644
index 0000000000..4d7d273c9c
--- /dev/null
+++ b/integration-tests/tests/mysql/effect-common.ts
@@ -0,0 +1,5934 @@
+import { assert, expect, expectTypeOf, it, Vitest } from '@effect/vitest';
+import {
+	asc,
+	eq,
+	getColumns,
+	getTableColumns,
+	gt,
+	gte,
+	inArray,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	sql,
+} from 'drizzle-orm';
+import { EffectCache, type EffectCacheShape } from 'drizzle-orm/cache/core/cache-effect';
+import { EffectLogger, type EffectLoggerShape, QueryEffectHKTBase } from 'drizzle-orm/effect-core';
+import {
+	alias,
+	bigint,
+	binary,
+	blob,
+	boolean,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	except,
+	float,
+	getViewConfig,
+	int,
+	json,
+	longblob,
+	mediumblob,
+	mediumint,
+	MySqlDialect,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyblob,
+	tinyint,
+	union,
+	unionAll,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+import type { MySqlEffectDatabase } from 'drizzle-orm/mysql-core/effect/db';
+import { MySqlEffectSession } from 'drizzle-orm/mysql-core/effect/session';
+import {
+	EmptyRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+} from 'drizzle-orm/relations';
+import { ConfigError } from 'effect/Config';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Ref from 'effect/Ref';
+import * as Result from 'effect/Result';
+import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlError } from 'effect/unstable/sql/SqlError';
+import relations from './relations';
+import { rqbPost, rqbUser } from './schema';
+import { allTypesCodecsTable } from './schema2';
+import { normalizeDataWithDbCodecs } from './utils';
+
+export class DB extends Context.Service<DB, MySqlEffectDatabase<any, any, typeof relations>>()('CommonEffectMySqlDB') {}
+
+let _diff!: (_: {}, schema: Record<string, unknown>, renames: []) => Promise<{ sqlStatements: string[] }>;
+const getDiff = async () => {
+	return _diff ??= (await import('../../../drizzle-kit/tests/mysql/mocks' as string)).diff;
+};
+
+export const push = (db: MySqlEffectDatabase<any, any, any>, schema: Record<string, any>) =>
+	Effect.gen(function*() {
+		const diff = yield* Effect.promise(() => getDiff());
+
+		const { sqlStatements: deleteStatements } = yield* Effect.promise(() => diff(schema, {}, []));
+		const { sqlStatements: createStatements } = yield* Effect.promise(() => diff({}, schema, []));
+
+		yield* db.execute('SET FOREIGN_KEY_CHECKS = 0;');
+
+		for (const s of deleteStatements) {
+			if (s.startsWith('DROP')) {
+				const exists = s.replace('`', 'IF EXISTS `');
+
+				yield* db.execute(exists.includes('CASCADE') ? exists : exists.replace(';', ' CASCADE;'));
+			}
+		}
+		for (const s of createStatements) {
+			yield* db.execute(s);
+		}
+
+		yield* db.execute('SET FOREIGN_KEY_CHECKS = 1;');
+	});
+
+export interface RunCommonEffectMySqlTestsOptions {
+	testLayer: Layer.Layer<DB | SqlClient, SqlError | ConfigError, never>;
+	MySqlDrizzle: {
+		make: (config?: any) => Effect.Effect<MySqlEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		makeWithDefaults: (
+			config?: any,
+		) => Effect.Effect<MySqlEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		DefaultServices: Layer.Layer<any, never, any>;
+	};
+	createDB: <
+		TSchema extends Record<string, any>,
+		TConfig extends RelationsBuilderConfig<TTables>,
+		TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+	>(
+		schema: TSchema,
+		relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+		useJitMappers?: boolean,
+	) => Effect.Effect<
+		MySqlEffectDatabase<QueryEffectHKTBase, any, ExtractTablesWithRelations<TConfig, TTables>>,
+		never,
+		any
+	>;
+	skipTests?: string[];
+	addTests?: (it: Vitest.MethodsNonLive<DB | SqlClient>) => void;
+}
+
+export const runCommonEffectMySqlTests = (opts: RunCommonEffectMySqlTestsOptions): void => {
+	const { testLayer, MySqlDrizzle, createDB, addTests, skipTests = [] } = opts;
+
+	it.layer(testLayer)('common', (it) => {
+		it.beforeEach(({ task, skip }) => {
+			if (skipTests.includes(task.name)) skip();
+		});
+
+		it.effect('execute', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const res = yield* db.execute<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual([{ '1': 1 }]);
+			}));
+
+		it.effect('all types', () =>
+			Effect.gen(function*() {
+				const en = mysqlEnum('en_48', ['enVal1', 'enVal2']);
+				const allTypesTable = mysqlTable('all_types_48', {
+					serial: serial('serial'),
+					bigint53: bigint('bigint53', {
+						mode: 'number',
+					}),
+					bigint64: bigint('bigint64', {
+						mode: 'bigint',
+					}),
+					bigintString: bigint('bigint_string', {
+						mode: 'string',
+					}),
+					binary: binary('binary'),
+					boolean: boolean('boolean'),
+					char: char('char'),
+					date: date('date', {
+						mode: 'date',
+					}),
+					dateStr: date('date_str', {
+						mode: 'string',
+					}),
+					datetime: datetime('datetime', {
+						mode: 'date',
+					}),
+					datetimeStr: datetime('datetime_str', {
+						mode: 'string',
+					}),
+					decimal: decimal('decimal'),
+					decimalNum: decimal('decimal_num', {
+						precision: 30,
+						mode: 'number',
+					}),
+					decimalBig: decimal('decimal_big', {
+						precision: 30,
+						mode: 'bigint',
+					}),
+					double: double('double'),
+					float: float('float'),
+					int: int('int'),
+					json: json('json'),
+					medInt: mediumint('med_int'),
+					smallInt: smallint('small_int'),
+					real: real('real'),
+					text: text('text'),
+					time: time('time'),
+					timestamp: timestamp('timestamp', {
+						mode: 'date',
+					}),
+					timestampStr: timestamp('timestamp_str', {
+						mode: 'string',
+					}),
+					tinyInt: tinyint('tiny_int'),
+					varbin: varbinary('varbin', {
+						length: 16,
+					}),
+					varchar: varchar('varchar', {
+						length: 255,
+					}),
+					year: year('year'),
+					enum: mysqlEnum('enum', ['enV1', 'enV2']),
+					blob: blob('blob'),
+					tinyblob: tinyblob('tinyblob'),
+					mediumblob: mediumblob('mediumblob'),
+					longblob: longblob('longblob'),
+					stringblob: blob('stringblob', { mode: 'string' }),
+					stringtinyblob: tinyblob('stringtinyblob', { mode: 'string' }),
+					stringmediumblob: mediumblob('stringmediumblob', { mode: 'string' }),
+					stringlongblob: longblob('stringlongblob', { mode: 'string' }),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { en, allTypesTable });
+
+				yield* db.insert(allTypesTable).values({
+					serial: 1,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bigintString: '5044565289845416380',
+					binary: '1',
+					boolean: true,
+					char: 'c',
+					date: new Date('2025-03-12T00:00:00.000Z'),
+					dateStr: new Date('2025-03-12T00:00:00.000Z').toISOString().slice(0, 19).replace('T', ' '),
+					datetime: new Date('2025-03-12T00:00:00.000Z'),
+					datetimeStr: new Date('2025-03-12T00:00:00.000Z').toISOString().slice(0, 19).replace('T', ' '),
+					decimal: '47521',
+					decimalNum: 9007199254740991,
+					decimalBig: 5044565289845416380n,
+					double: 15.35325689124218,
+					enum: 'enV1',
+					float: 1.048596,
+					real: 1.048596,
+					text: 'C4-',
+					int: 621,
+					json: {
+						str: 'strval',
+						arr: ['str', 10],
+					},
+					medInt: 560,
+					smallInt: 14,
+					time: '04:13:22',
+					timestamp: new Date('2025-03-12T00:00:00.000Z'),
+					timestampStr: new Date('2025-03-12T00:00:00.000Z').toISOString().slice(0, 19).replace('T', ' '),
+					tinyInt: 7,
+					varbin: '1010110101001101',
+					varchar: 'VCHAR',
+					year: 2025,
+					blob: Buffer.from('string'),
+					longblob: Buffer.from('string'),
+					mediumblob: Buffer.from('string'),
+					tinyblob: Buffer.from('string'),
+					stringblob: 'string',
+					stringlongblob: 'string',
+					stringmediumblob: 'string',
+					stringtinyblob: 'string',
+				});
+
+				const rawRes = yield* db.select().from(allTypesTable);
+
+				type ExpectedType = {
+					serial: number;
+					bigint53: number | null;
+					bigint64: bigint | null;
+					bigintString: string | null;
+					binary: string | null;
+					boolean: boolean | null;
+					char: string | null;
+					date: Date | null;
+					dateStr: string | null;
+					datetime: Date | null;
+					datetimeStr: string | null;
+					decimal: string | null;
+					decimalNum: number | null;
+					decimalBig: bigint | null;
+					double: number | null;
+					float: number | null;
+					int: number | null;
+					json: unknown;
+					medInt: number | null;
+					smallInt: number | null;
+					real: number | null;
+					text: string | null;
+					time: string | null;
+					timestamp: Date | null;
+					timestampStr: string | null;
+					tinyInt: number | null;
+					varbin: string | null;
+					varchar: string | null;
+					year: number | null;
+					enum: 'enV1' | 'enV2' | null;
+					blob: Buffer | null;
+					tinyblob: Buffer | null;
+					mediumblob: Buffer | null;
+					longblob: Buffer | null;
+					stringblob: string | null;
+					stringtinyblob: string | null;
+					stringmediumblob: string | null;
+					stringlongblob: string | null;
+				}[];
+
+				const expectedRes: ExpectedType = [
+					{
+						serial: 1,
+						bigint53: 9007199254740991,
+						bigint64: 5044565289845416380n,
+						bigintString: '5044565289845416380',
+						binary: '1',
+						boolean: true,
+						char: 'c',
+						date: new Date('2025-03-12T00:00:00.000Z'),
+						dateStr: '2025-03-12',
+						datetime: new Date('2025-03-12T00:00:00.000Z'),
+						datetimeStr: '2025-03-12 00:00:00',
+						decimal: '47521',
+						decimalNum: 9007199254740991,
+						decimalBig: 5044565289845416380n,
+						double: 15.35325689124218,
+						float: 1.048596,
+						int: 621,
+						json: { arr: ['str', 10], str: 'strval' },
+						medInt: 560,
+						smallInt: 14,
+						real: 1.048596,
+						text: 'C4-',
+						time: '04:13:22',
+						timestamp: new Date('2025-03-12T00:00:00.000Z'),
+						timestampStr: '2025-03-12 00:00:00',
+						tinyInt: 7,
+						varbin: '1010110101001101',
+						varchar: 'VCHAR',
+						year: 2025,
+						enum: 'enV1',
+						blob: Buffer.from('string'),
+						longblob: Buffer.from('string'),
+						mediumblob: Buffer.from('string'),
+						tinyblob: Buffer.from('string'),
+						stringblob: 'string',
+						stringlongblob: 'string',
+						stringmediumblob: 'string',
+						stringtinyblob: 'string',
+					},
+				];
+
+				expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+				expect(rawRes).toStrictEqual(expectedRes);
+			}));
+
+		it.effect('all types ~codecs~', () =>
+			Effect.gen(function*() {
+				const db = yield* createDB({ allTypesTable: allTypesCodecsTable }, (r) => ({
+					allTypesTable: {
+						self: r.many.allTypesTable({
+							from: r.allTypesTable.serial,
+							to: r.allTypesTable.serial,
+						}),
+					},
+				}));
+				yield* push(db, { allTypesCodecsTable });
+
+				type ExpectedType = {
+					serial: number;
+					bigint53: number;
+					bigint64: bigint;
+					bigintstr: string;
+					binary: string;
+					boolean: boolean;
+					char: string;
+					date: Date;
+					datestr: string;
+					datetime: Date;
+					datetimestr: string;
+					decimal: string;
+					decimalnum: number;
+					decimalbig: bigint;
+					double: number;
+					float: number;
+					int: number;
+					json1: unknown;
+					json2: unknown;
+					json3: unknown;
+					json4: unknown;
+					medint: number;
+					smallint: number;
+					real: number;
+					text: string;
+					tinytext: string;
+					mediumtext: string;
+					longtext: string;
+					time: string;
+					timestamp: Date;
+					timestampstr: string;
+					tinyint: number;
+					varbin: string;
+					varchar: string;
+					year: number;
+					enum: 'enV1' | 'enV2';
+					blob: Buffer;
+					tinyblob: Buffer;
+					mediumblob: Buffer;
+					longblob: Buffer;
+					stringblob: string;
+					stringtinyblob: string;
+					stringmediumblob: string;
+					stringlongblob: string;
+				};
+
+				const testData: ExpectedType = {
+					serial: 1,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bigintstr: '5044565289845416380',
+					binary: '1',
+					boolean: true,
+					char: 'c',
+					date: new Date('2025-03-12'),
+					datestr: '2025-03-12',
+					datetime: new Date(1741743161623),
+					datetimestr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+					decimal: '47521',
+					decimalnum: 9007199254740991,
+					decimalbig: 5044565289845416380n,
+					double: 15.35325689124218,
+					enum: 'enV1',
+					float: 1.048596,
+					real: 1.048596,
+					text: 'C4-',
+					tinytext: 'tiny text',
+					mediumtext: 'medium text',
+					longtext: 'long text',
+					int: 621,
+					json1: { str: 'strval', arr: ['str', 10] },
+					json2: [{ key: 'value', num: 7 }, 'v', '11', 5],
+					json3: 5,
+					json4: '5',
+					medint: 560,
+					smallint: 14,
+					time: '04:13:22',
+					timestamp: new Date(1741743161623),
+					timestampstr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+					tinyint: 7,
+					varbin: '1010110101001101',
+					varchar: 'VCHAR',
+					year: 2025,
+					blob: Buffer.from('string'),
+					longblob: Buffer.from('string'),
+					mediumblob: Buffer.from('string'),
+					tinyblob: Buffer.from('string'),
+					stringblob: 'string',
+					stringlongblob: 'string',
+					stringmediumblob: 'string',
+					stringtinyblob: 'string',
+				};
+
+				yield* db.insert(allTypesCodecsTable).values(testData);
+
+				const session = (<any> db).session as MySqlEffectSession;
+
+				const queryRaw = yield* session.objects<ExpectedType>(
+					db.select(
+						Object.fromEntries(
+							Object.entries(getTableColumns(allTypesCodecsTable)).map(([k, v]) => [k, v.as(v.name)]),
+						),
+					).from(allTypesCodecsTable).getSQL(),
+				);
+				const queryRes = normalizeDataWithDbCodecs({
+					db,
+					columns: getColumns(allTypesCodecsTable),
+					data: queryRaw,
+					mode: 'query',
+				})[0];
+
+				const relationRaw = yield* session.objects<ExpectedType & { self: ExpectedType[] }>(
+					db.query.allTypesTable.findFirst({
+						with: {
+							self: true,
+						},
+					}).getSQL(),
+				);
+				const { self: relationSelf, ...rootRaw } = relationRaw[0]!;
+				const relationRes = normalizeDataWithDbCodecs({
+					db,
+					columns: getColumns(allTypesCodecsTable),
+					data: relationSelf,
+					mode: 'json',
+				})[0]!;
+				const rootRes = normalizeDataWithDbCodecs({
+					db,
+					columns: getColumns(allTypesCodecsTable),
+					data: [rootRaw],
+					mode: 'query',
+				})[0]!;
+
+				expect(queryRes).toStrictEqual(testData);
+				expect(relationRes).toStrictEqual(testData);
+				expect(rootRes).toStrictEqual(testData);
+
+				// ---- numbers ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+							'serial ∪ bigint53': allTypesCodecsTable.serial.as('serial ∪ bigint53'),
+							'serial ∪ decimalnum': allTypesCodecsTable.serial.as('serial ∪ decimalnum'),
+							'serial ∪ double': allTypesCodecsTable.serial.as('serial ∪ double'),
+							'serial ∪ float': allTypesCodecsTable.serial.as('serial ∪ float'),
+							'serial ∪ int': allTypesCodecsTable.serial.as('serial ∪ int'),
+							'serial ∪ medint': allTypesCodecsTable.serial.as('serial ∪ medint'),
+							'serial ∪ smallint': allTypesCodecsTable.serial.as('serial ∪ smallint'),
+							'serial ∪ real': allTypesCodecsTable.serial.as('serial ∪ real'),
+							'serial ∪ tinyint': allTypesCodecsTable.serial.as('serial ∪ tinyint'),
+							'serial ∪ year': allTypesCodecsTable.serial.as('serial ∪ year'),
+							'bigint53 ∪ serial': allTypesCodecsTable.bigint53.as('bigint53 ∪ serial'),
+							'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+							'bigint53 ∪ decimalnum': allTypesCodecsTable.bigint53.as('bigint53 ∪ decimalnum'),
+							'bigint53 ∪ double': allTypesCodecsTable.bigint53.as('bigint53 ∪ double'),
+							'bigint53 ∪ float': allTypesCodecsTable.bigint53.as('bigint53 ∪ float'),
+							'bigint53 ∪ int': allTypesCodecsTable.bigint53.as('bigint53 ∪ int'),
+							'bigint53 ∪ medint': allTypesCodecsTable.bigint53.as('bigint53 ∪ medint'),
+							'bigint53 ∪ smallint': allTypesCodecsTable.bigint53.as('bigint53 ∪ smallint'),
+							'bigint53 ∪ real': allTypesCodecsTable.bigint53.as('bigint53 ∪ real'),
+							'bigint53 ∪ tinyint': allTypesCodecsTable.bigint53.as('bigint53 ∪ tinyint'),
+							'bigint53 ∪ year': allTypesCodecsTable.bigint53.as('bigint53 ∪ year'),
+							'decimalnum ∪ serial': allTypesCodecsTable.decimalnum.as('decimalnum ∪ serial'),
+							'decimalnum ∪ bigint53': allTypesCodecsTable.decimalnum.as('decimalnum ∪ bigint53'),
+							'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+							'decimalnum ∪ double': allTypesCodecsTable.decimalnum.as('decimalnum ∪ double'),
+							'decimalnum ∪ float': allTypesCodecsTable.decimalnum.as('decimalnum ∪ float'),
+							'decimalnum ∪ int': allTypesCodecsTable.decimalnum.as('decimalnum ∪ int'),
+							'decimalnum ∪ medint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ medint'),
+							'decimalnum ∪ smallint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ smallint'),
+							'decimalnum ∪ real': allTypesCodecsTable.decimalnum.as('decimalnum ∪ real'),
+							'decimalnum ∪ tinyint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ tinyint'),
+							'decimalnum ∪ year': allTypesCodecsTable.decimalnum.as('decimalnum ∪ year'),
+							'double ∪ serial': allTypesCodecsTable.double.as('double ∪ serial'),
+							'double ∪ bigint53': allTypesCodecsTable.double.as('double ∪ bigint53'),
+							'double ∪ decimalnum': allTypesCodecsTable.double.as('double ∪ decimalnum'),
+							'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+							'double ∪ float': allTypesCodecsTable.double.as('double ∪ float'),
+							'double ∪ int': allTypesCodecsTable.double.as('double ∪ int'),
+							'double ∪ medint': allTypesCodecsTable.double.as('double ∪ medint'),
+							'double ∪ smallint': allTypesCodecsTable.double.as('double ∪ smallint'),
+							'double ∪ real': allTypesCodecsTable.double.as('double ∪ real'),
+							'double ∪ tinyint': allTypesCodecsTable.double.as('double ∪ tinyint'),
+							'double ∪ year': allTypesCodecsTable.double.as('double ∪ year'),
+							'float ∪ serial': allTypesCodecsTable.float.as('float ∪ serial'),
+							'float ∪ bigint53': allTypesCodecsTable.float.as('float ∪ bigint53'),
+							'float ∪ decimalnum': allTypesCodecsTable.float.as('float ∪ decimalnum'),
+							'float ∪ double': allTypesCodecsTable.float.as('float ∪ double'),
+							'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+							'float ∪ int': allTypesCodecsTable.float.as('float ∪ int'),
+							'float ∪ medint': allTypesCodecsTable.float.as('float ∪ medint'),
+							'float ∪ smallint': allTypesCodecsTable.float.as('float ∪ smallint'),
+							'float ∪ real': allTypesCodecsTable.float.as('float ∪ real'),
+							'float ∪ tinyint': allTypesCodecsTable.float.as('float ∪ tinyint'),
+							'float ∪ year': allTypesCodecsTable.float.as('float ∪ year'),
+							'int ∪ serial': allTypesCodecsTable.int.as('int ∪ serial'),
+							'int ∪ bigint53': allTypesCodecsTable.int.as('int ∪ bigint53'),
+							'int ∪ decimalnum': allTypesCodecsTable.int.as('int ∪ decimalnum'),
+							'int ∪ double': allTypesCodecsTable.int.as('int ∪ double'),
+							'int ∪ float': allTypesCodecsTable.int.as('int ∪ float'),
+							'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+							'int ∪ medint': allTypesCodecsTable.int.as('int ∪ medint'),
+							'int ∪ smallint': allTypesCodecsTable.int.as('int ∪ smallint'),
+							'int ∪ real': allTypesCodecsTable.int.as('int ∪ real'),
+							'int ∪ tinyint': allTypesCodecsTable.int.as('int ∪ tinyint'),
+							'int ∪ year': allTypesCodecsTable.int.as('int ∪ year'),
+							'medint ∪ serial': allTypesCodecsTable.medint.as('medint ∪ serial'),
+							'medint ∪ bigint53': allTypesCodecsTable.medint.as('medint ∪ bigint53'),
+							'medint ∪ decimalnum': allTypesCodecsTable.medint.as('medint ∪ decimalnum'),
+							'medint ∪ double': allTypesCodecsTable.medint.as('medint ∪ double'),
+							'medint ∪ float': allTypesCodecsTable.medint.as('medint ∪ float'),
+							'medint ∪ int': allTypesCodecsTable.medint.as('medint ∪ int'),
+							'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+							'medint ∪ smallint': allTypesCodecsTable.medint.as('medint ∪ smallint'),
+							'medint ∪ real': allTypesCodecsTable.medint.as('medint ∪ real'),
+							'medint ∪ tinyint': allTypesCodecsTable.medint.as('medint ∪ tinyint'),
+							'medint ∪ year': allTypesCodecsTable.medint.as('medint ∪ year'),
+							'smallint ∪ serial': allTypesCodecsTable.smallint.as('smallint ∪ serial'),
+							'smallint ∪ bigint53': allTypesCodecsTable.smallint.as('smallint ∪ bigint53'),
+							'smallint ∪ decimalnum': allTypesCodecsTable.smallint.as('smallint ∪ decimalnum'),
+							'smallint ∪ double': allTypesCodecsTable.smallint.as('smallint ∪ double'),
+							'smallint ∪ float': allTypesCodecsTable.smallint.as('smallint ∪ float'),
+							'smallint ∪ int': allTypesCodecsTable.smallint.as('smallint ∪ int'),
+							'smallint ∪ medint': allTypesCodecsTable.smallint.as('smallint ∪ medint'),
+							'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+							'smallint ∪ real': allTypesCodecsTable.smallint.as('smallint ∪ real'),
+							'smallint ∪ tinyint': allTypesCodecsTable.smallint.as('smallint ∪ tinyint'),
+							'smallint ∪ year': allTypesCodecsTable.smallint.as('smallint ∪ year'),
+							'real ∪ serial': allTypesCodecsTable.real.as('real ∪ serial'),
+							'real ∪ bigint53': allTypesCodecsTable.real.as('real ∪ bigint53'),
+							'real ∪ decimalnum': allTypesCodecsTable.real.as('real ∪ decimalnum'),
+							'real ∪ double': allTypesCodecsTable.real.as('real ∪ double'),
+							'real ∪ float': allTypesCodecsTable.real.as('real ∪ float'),
+							'real ∪ int': allTypesCodecsTable.real.as('real ∪ int'),
+							'real ∪ medint': allTypesCodecsTable.real.as('real ∪ medint'),
+							'real ∪ smallint': allTypesCodecsTable.real.as('real ∪ smallint'),
+							'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+							'real ∪ tinyint': allTypesCodecsTable.real.as('real ∪ tinyint'),
+							'real ∪ year': allTypesCodecsTable.real.as('real ∪ year'),
+							'tinyint ∪ serial': allTypesCodecsTable.tinyint.as('tinyint ∪ serial'),
+							'tinyint ∪ bigint53': allTypesCodecsTable.tinyint.as('tinyint ∪ bigint53'),
+							'tinyint ∪ decimalnum': allTypesCodecsTable.tinyint.as('tinyint ∪ decimalnum'),
+							'tinyint ∪ double': allTypesCodecsTable.tinyint.as('tinyint ∪ double'),
+							'tinyint ∪ float': allTypesCodecsTable.tinyint.as('tinyint ∪ float'),
+							'tinyint ∪ int': allTypesCodecsTable.tinyint.as('tinyint ∪ int'),
+							'tinyint ∪ medint': allTypesCodecsTable.tinyint.as('tinyint ∪ medint'),
+							'tinyint ∪ smallint': allTypesCodecsTable.tinyint.as('tinyint ∪ smallint'),
+							'tinyint ∪ real': allTypesCodecsTable.tinyint.as('tinyint ∪ real'),
+							'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+							'tinyint ∪ year': allTypesCodecsTable.tinyint.as('tinyint ∪ year'),
+							'year ∪ serial': allTypesCodecsTable.year.as('year ∪ serial'),
+							'year ∪ bigint53': allTypesCodecsTable.year.as('year ∪ bigint53'),
+							'year ∪ decimalnum': allTypesCodecsTable.year.as('year ∪ decimalnum'),
+							'year ∪ double': allTypesCodecsTable.year.as('year ∪ double'),
+							'year ∪ float': allTypesCodecsTable.year.as('year ∪ float'),
+							'year ∪ int': allTypesCodecsTable.year.as('year ∪ int'),
+							'year ∪ medint': allTypesCodecsTable.year.as('year ∪ medint'),
+							'year ∪ smallint': allTypesCodecsTable.year.as('year ∪ smallint'),
+							'year ∪ real': allTypesCodecsTable.year.as('year ∪ real'),
+							'year ∪ tinyint': allTypesCodecsTable.year.as('year ∪ tinyint'),
+							'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+							'serial ∪ bigint53': allTypesCodecsTable.bigint53.as('serial ∪ bigint53'),
+							'serial ∪ decimalnum': allTypesCodecsTable.decimalnum.as('serial ∪ decimalnum'),
+							'serial ∪ double': allTypesCodecsTable.double.as('serial ∪ double'),
+							'serial ∪ float': allTypesCodecsTable.float.as('serial ∪ float'),
+							'serial ∪ int': allTypesCodecsTable.int.as('serial ∪ int'),
+							'serial ∪ medint': allTypesCodecsTable.medint.as('serial ∪ medint'),
+							'serial ∪ smallint': allTypesCodecsTable.smallint.as('serial ∪ smallint'),
+							'serial ∪ real': allTypesCodecsTable.real.as('serial ∪ real'),
+							'serial ∪ tinyint': allTypesCodecsTable.tinyint.as('serial ∪ tinyint'),
+							'serial ∪ year': allTypesCodecsTable.year.as('serial ∪ year'),
+							'bigint53 ∪ serial': allTypesCodecsTable.serial.as('bigint53 ∪ serial'),
+							'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+							'bigint53 ∪ decimalnum': allTypesCodecsTable.decimalnum.as('bigint53 ∪ decimalnum'),
+							'bigint53 ∪ double': allTypesCodecsTable.double.as('bigint53 ∪ double'),
+							'bigint53 ∪ float': allTypesCodecsTable.float.as('bigint53 ∪ float'),
+							'bigint53 ∪ int': allTypesCodecsTable.int.as('bigint53 ∪ int'),
+							'bigint53 ∪ medint': allTypesCodecsTable.medint.as('bigint53 ∪ medint'),
+							'bigint53 ∪ smallint': allTypesCodecsTable.smallint.as('bigint53 ∪ smallint'),
+							'bigint53 ∪ real': allTypesCodecsTable.real.as('bigint53 ∪ real'),
+							'bigint53 ∪ tinyint': allTypesCodecsTable.tinyint.as('bigint53 ∪ tinyint'),
+							'bigint53 ∪ year': allTypesCodecsTable.year.as('bigint53 ∪ year'),
+							'decimalnum ∪ serial': allTypesCodecsTable.serial.as('decimalnum ∪ serial'),
+							'decimalnum ∪ bigint53': allTypesCodecsTable.bigint53.as('decimalnum ∪ bigint53'),
+							'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+							'decimalnum ∪ double': allTypesCodecsTable.double.as('decimalnum ∪ double'),
+							'decimalnum ∪ float': allTypesCodecsTable.float.as('decimalnum ∪ float'),
+							'decimalnum ∪ int': allTypesCodecsTable.int.as('decimalnum ∪ int'),
+							'decimalnum ∪ medint': allTypesCodecsTable.medint.as('decimalnum ∪ medint'),
+							'decimalnum ∪ smallint': allTypesCodecsTable.smallint.as('decimalnum ∪ smallint'),
+							'decimalnum ∪ real': allTypesCodecsTable.real.as('decimalnum ∪ real'),
+							'decimalnum ∪ tinyint': allTypesCodecsTable.tinyint.as('decimalnum ∪ tinyint'),
+							'decimalnum ∪ year': allTypesCodecsTable.year.as('decimalnum ∪ year'),
+							'double ∪ serial': allTypesCodecsTable.serial.as('double ∪ serial'),
+							'double ∪ bigint53': allTypesCodecsTable.bigint53.as('double ∪ bigint53'),
+							'double ∪ decimalnum': allTypesCodecsTable.decimalnum.as('double ∪ decimalnum'),
+							'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+							'double ∪ float': allTypesCodecsTable.float.as('double ∪ float'),
+							'double ∪ int': allTypesCodecsTable.int.as('double ∪ int'),
+							'double ∪ medint': allTypesCodecsTable.medint.as('double ∪ medint'),
+							'double ∪ smallint': allTypesCodecsTable.smallint.as('double ∪ smallint'),
+							'double ∪ real': allTypesCodecsTable.real.as('double ∪ real'),
+							'double ∪ tinyint': allTypesCodecsTable.tinyint.as('double ∪ tinyint'),
+							'double ∪ year': allTypesCodecsTable.year.as('double ∪ year'),
+							'float ∪ serial': allTypesCodecsTable.serial.as('float ∪ serial'),
+							'float ∪ bigint53': allTypesCodecsTable.bigint53.as('float ∪ bigint53'),
+							'float ∪ decimalnum': allTypesCodecsTable.decimalnum.as('float ∪ decimalnum'),
+							'float ∪ double': allTypesCodecsTable.double.as('float ∪ double'),
+							'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+							'float ∪ int': allTypesCodecsTable.int.as('float ∪ int'),
+							'float ∪ medint': allTypesCodecsTable.medint.as('float ∪ medint'),
+							'float ∪ smallint': allTypesCodecsTable.smallint.as('float ∪ smallint'),
+							'float ∪ real': allTypesCodecsTable.real.as('float ∪ real'),
+							'float ∪ tinyint': allTypesCodecsTable.tinyint.as('float ∪ tinyint'),
+							'float ∪ year': allTypesCodecsTable.year.as('float ∪ year'),
+							'int ∪ serial': allTypesCodecsTable.serial.as('int ∪ serial'),
+							'int ∪ bigint53': allTypesCodecsTable.bigint53.as('int ∪ bigint53'),
+							'int ∪ decimalnum': allTypesCodecsTable.decimalnum.as('int ∪ decimalnum'),
+							'int ∪ double': allTypesCodecsTable.double.as('int ∪ double'),
+							'int ∪ float': allTypesCodecsTable.float.as('int ∪ float'),
+							'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+							'int ∪ medint': allTypesCodecsTable.medint.as('int ∪ medint'),
+							'int ∪ smallint': allTypesCodecsTable.smallint.as('int ∪ smallint'),
+							'int ∪ real': allTypesCodecsTable.real.as('int ∪ real'),
+							'int ∪ tinyint': allTypesCodecsTable.tinyint.as('int ∪ tinyint'),
+							'int ∪ year': allTypesCodecsTable.year.as('int ∪ year'),
+							'medint ∪ serial': allTypesCodecsTable.serial.as('medint ∪ serial'),
+							'medint ∪ bigint53': allTypesCodecsTable.bigint53.as('medint ∪ bigint53'),
+							'medint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('medint ∪ decimalnum'),
+							'medint ∪ double': allTypesCodecsTable.double.as('medint ∪ double'),
+							'medint ∪ float': allTypesCodecsTable.float.as('medint ∪ float'),
+							'medint ∪ int': allTypesCodecsTable.int.as('medint ∪ int'),
+							'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+							'medint ∪ smallint': allTypesCodecsTable.smallint.as('medint ∪ smallint'),
+							'medint ∪ real': allTypesCodecsTable.real.as('medint ∪ real'),
+							'medint ∪ tinyint': allTypesCodecsTable.tinyint.as('medint ∪ tinyint'),
+							'medint ∪ year': allTypesCodecsTable.year.as('medint ∪ year'),
+							'smallint ∪ serial': allTypesCodecsTable.serial.as('smallint ∪ serial'),
+							'smallint ∪ bigint53': allTypesCodecsTable.bigint53.as('smallint ∪ bigint53'),
+							'smallint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('smallint ∪ decimalnum'),
+							'smallint ∪ double': allTypesCodecsTable.double.as('smallint ∪ double'),
+							'smallint ∪ float': allTypesCodecsTable.float.as('smallint ∪ float'),
+							'smallint ∪ int': allTypesCodecsTable.int.as('smallint ∪ int'),
+							'smallint ∪ medint': allTypesCodecsTable.medint.as('smallint ∪ medint'),
+							'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+							'smallint ∪ real': allTypesCodecsTable.real.as('smallint ∪ real'),
+							'smallint ∪ tinyint': allTypesCodecsTable.tinyint.as('smallint ∪ tinyint'),
+							'smallint ∪ year': allTypesCodecsTable.year.as('smallint ∪ year'),
+							'real ∪ serial': allTypesCodecsTable.serial.as('real ∪ serial'),
+							'real ∪ bigint53': allTypesCodecsTable.bigint53.as('real ∪ bigint53'),
+							'real ∪ decimalnum': allTypesCodecsTable.decimalnum.as('real ∪ decimalnum'),
+							'real ∪ double': allTypesCodecsTable.double.as('real ∪ double'),
+							'real ∪ float': allTypesCodecsTable.float.as('real ∪ float'),
+							'real ∪ int': allTypesCodecsTable.int.as('real ∪ int'),
+							'real ∪ medint': allTypesCodecsTable.medint.as('real ∪ medint'),
+							'real ∪ smallint': allTypesCodecsTable.smallint.as('real ∪ smallint'),
+							'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+							'real ∪ tinyint': allTypesCodecsTable.tinyint.as('real ∪ tinyint'),
+							'real ∪ year': allTypesCodecsTable.year.as('real ∪ year'),
+							'tinyint ∪ serial': allTypesCodecsTable.serial.as('tinyint ∪ serial'),
+							'tinyint ∪ bigint53': allTypesCodecsTable.bigint53.as('tinyint ∪ bigint53'),
+							'tinyint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('tinyint ∪ decimalnum'),
+							'tinyint ∪ double': allTypesCodecsTable.double.as('tinyint ∪ double'),
+							'tinyint ∪ float': allTypesCodecsTable.float.as('tinyint ∪ float'),
+							'tinyint ∪ int': allTypesCodecsTable.int.as('tinyint ∪ int'),
+							'tinyint ∪ medint': allTypesCodecsTable.medint.as('tinyint ∪ medint'),
+							'tinyint ∪ smallint': allTypesCodecsTable.smallint.as('tinyint ∪ smallint'),
+							'tinyint ∪ real': allTypesCodecsTable.real.as('tinyint ∪ real'),
+							'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+							'tinyint ∪ year': allTypesCodecsTable.year.as('tinyint ∪ year'),
+							'year ∪ serial': allTypesCodecsTable.serial.as('year ∪ serial'),
+							'year ∪ bigint53': allTypesCodecsTable.bigint53.as('year ∪ bigint53'),
+							'year ∪ decimalnum': allTypesCodecsTable.decimalnum.as('year ∪ decimalnum'),
+							'year ∪ double': allTypesCodecsTable.double.as('year ∪ double'),
+							'year ∪ float': allTypesCodecsTable.float.as('year ∪ float'),
+							'year ∪ int': allTypesCodecsTable.int.as('year ∪ int'),
+							'year ∪ medint': allTypesCodecsTable.medint.as('year ∪ medint'),
+							'year ∪ smallint': allTypesCodecsTable.smallint.as('year ∪ smallint'),
+							'year ∪ real': allTypesCodecsTable.real.as('year ∪ real'),
+							'year ∪ tinyint': allTypesCodecsTable.tinyint.as('year ∪ tinyint'),
+							'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'serial ∪ serial': 1,
+						'serial ∪ bigint53': 1,
+						'serial ∪ decimalnum': 1,
+						'serial ∪ double': 1,
+						'serial ∪ float': 1,
+						'serial ∪ int': 1,
+						'serial ∪ medint': 1,
+						'serial ∪ smallint': 1,
+						'serial ∪ real': 1,
+						'serial ∪ tinyint': 1,
+						'serial ∪ year': 1,
+						'bigint53 ∪ serial': 9007199254740991,
+						'bigint53 ∪ bigint53': 9007199254740991,
+						'bigint53 ∪ decimalnum': 9007199254740991,
+						'bigint53 ∪ double': 9007199254740991,
+						'bigint53 ∪ float': 9007199254740991,
+						'bigint53 ∪ int': 9007199254740991,
+						'bigint53 ∪ medint': 9007199254740991,
+						'bigint53 ∪ smallint': 9007199254740991,
+						'bigint53 ∪ real': 9007199254740991,
+						'bigint53 ∪ tinyint': 9007199254740991,
+						'bigint53 ∪ year': 9007199254740991,
+						'decimalnum ∪ serial': 9007199254740991,
+						'decimalnum ∪ bigint53': 9007199254740991,
+						'decimalnum ∪ decimalnum': 9007199254740991,
+						'decimalnum ∪ double': 9007199254740991,
+						'decimalnum ∪ float': 9007199254740991,
+						'decimalnum ∪ int': 9007199254740991,
+						'decimalnum ∪ medint': 9007199254740991,
+						'decimalnum ∪ smallint': 9007199254740991,
+						'decimalnum ∪ real': 9007199254740991,
+						'decimalnum ∪ tinyint': 9007199254740991,
+						'decimalnum ∪ year': 9007199254740991,
+						'double ∪ serial': 15.35325689124218,
+						'double ∪ bigint53': 15.35325689124218,
+						'double ∪ decimalnum': 15.35325689124218,
+						'double ∪ double': 15.35325689124218,
+						'double ∪ float': 15.35325689124218,
+						'double ∪ int': 15.35325689124218,
+						'double ∪ medint': 15.35325689124218,
+						'double ∪ smallint': 15.35325689124218,
+						'double ∪ real': 15.35325689124218,
+						'double ∪ tinyint': 15.35325689124218,
+						'double ∪ year': 15.35325689124218,
+						'float ∪ serial': 1.048596,
+						'float ∪ bigint53': 1.048596,
+						'float ∪ decimalnum': 1.0485960245132446,
+						'float ∪ double': 1.0485960245132446,
+						'float ∪ float': 1.048596,
+						'float ∪ int': 1.0485960245132446,
+						'float ∪ medint': 1.048596,
+						'float ∪ smallint': 1.048596,
+						'float ∪ real': 1.0485960245132446,
+						'float ∪ tinyint': 1.048596,
+						'float ∪ year': 1.048596,
+						'int ∪ serial': 621,
+						'int ∪ bigint53': 621,
+						'int ∪ decimalnum': 621,
+						'int ∪ double': 621,
+						'int ∪ float': 621,
+						'int ∪ int': 621,
+						'int ∪ medint': 621,
+						'int ∪ smallint': 621,
+						'int ∪ real': 621,
+						'int ∪ tinyint': 621,
+						'int ∪ year': 621,
+						'medint ∪ serial': 560,
+						'medint ∪ bigint53': 560,
+						'medint ∪ decimalnum': 560,
+						'medint ∪ double': 560,
+						'medint ∪ float': 560,
+						'medint ∪ int': 560,
+						'medint ∪ medint': 560,
+						'medint ∪ smallint': 560,
+						'medint ∪ real': 560,
+						'medint ∪ tinyint': 560,
+						'medint ∪ year': 560,
+						'smallint ∪ serial': 14,
+						'smallint ∪ bigint53': 14,
+						'smallint ∪ decimalnum': 14,
+						'smallint ∪ double': 14,
+						'smallint ∪ float': 14,
+						'smallint ∪ int': 14,
+						'smallint ∪ medint': 14,
+						'smallint ∪ smallint': 14,
+						'smallint ∪ real': 14,
+						'smallint ∪ tinyint': 14,
+						'smallint ∪ year': 14,
+						'real ∪ serial': 1.048596,
+						'real ∪ bigint53': 1.048596,
+						'real ∪ decimalnum': 1.048596,
+						'real ∪ double': 1.048596,
+						'real ∪ float': 1.048596,
+						'real ∪ int': 1.048596,
+						'real ∪ medint': 1.048596,
+						'real ∪ smallint': 1.048596,
+						'real ∪ real': 1.048596,
+						'real ∪ tinyint': 1.048596,
+						'real ∪ year': 1.048596,
+						'tinyint ∪ serial': 7,
+						'tinyint ∪ bigint53': 7,
+						'tinyint ∪ decimalnum': 7,
+						'tinyint ∪ double': 7,
+						'tinyint ∪ float': 7,
+						'tinyint ∪ int': 7,
+						'tinyint ∪ medint': 7,
+						'tinyint ∪ smallint': 7,
+						'tinyint ∪ real': 7,
+						'tinyint ∪ tinyint': 7,
+						'tinyint ∪ year': 7,
+						'year ∪ serial': 2025,
+						'year ∪ bigint53': 2025,
+						'year ∪ decimalnum': 2025,
+						'year ∪ double': 2025,
+						'year ∪ float': 2025,
+						'year ∪ int': 2025,
+						'year ∪ medint': 2025,
+						'year ∪ smallint': 2025,
+						'year ∪ real': 2025,
+						'year ∪ tinyint': 127,
+						'year ∪ year': 2025,
+					},
+					{
+						'serial ∪ serial': 1,
+						'serial ∪ bigint53': 9007199254740991,
+						'serial ∪ decimalnum': 9007199254740991,
+						'serial ∪ double': 15.35325689124218,
+						'serial ∪ float': 1.0485960245132446,
+						'serial ∪ int': 621,
+						'serial ∪ medint': 560,
+						'serial ∪ smallint': 14,
+						'serial ∪ real': 1.048596,
+						'serial ∪ tinyint': 7,
+						'serial ∪ year': 2025,
+						'bigint53 ∪ serial': 1,
+						'bigint53 ∪ bigint53': 9007199254740991,
+						'bigint53 ∪ decimalnum': 9007199254740991,
+						'bigint53 ∪ double': 15.35325689124218,
+						'bigint53 ∪ float': 1.0485960245132446,
+						'bigint53 ∪ int': 621,
+						'bigint53 ∪ medint': 560,
+						'bigint53 ∪ smallint': 14,
+						'bigint53 ∪ real': 1.048596,
+						'bigint53 ∪ tinyint': 7,
+						'bigint53 ∪ year': 2025,
+						'decimalnum ∪ serial': 1,
+						'decimalnum ∪ bigint53': 9007199254740991,
+						'decimalnum ∪ decimalnum': 9007199254740991,
+						'decimalnum ∪ double': 15.35325689124218,
+						'decimalnum ∪ float': 1.0485960245132446,
+						'decimalnum ∪ int': 621,
+						'decimalnum ∪ medint': 560,
+						'decimalnum ∪ smallint': 14,
+						'decimalnum ∪ real': 1.048596,
+						'decimalnum ∪ tinyint': 7,
+						'decimalnum ∪ year': 2025,
+						'double ∪ serial': 1,
+						'double ∪ bigint53': 9007199254740991,
+						'double ∪ decimalnum': 9007199254740991,
+						'double ∪ double': 15.35325689124218,
+						'double ∪ float': 1.0485960245132446,
+						'double ∪ int': 621,
+						'double ∪ medint': 560,
+						'double ∪ smallint': 14,
+						'double ∪ real': 1.048596,
+						'double ∪ tinyint': 7,
+						'double ∪ year': 2025,
+						'float ∪ serial': 1,
+						'float ∪ bigint53': 9007199000000000,
+						'float ∪ decimalnum': 9007199254740991,
+						'float ∪ double': 15.35325689124218,
+						'float ∪ float': 1.048596,
+						'float ∪ int': 621,
+						'float ∪ medint': 560,
+						'float ∪ smallint': 14,
+						'float ∪ real': 1.048596,
+						'float ∪ tinyint': 7,
+						'float ∪ year': 2025,
+						'int ∪ serial': 1,
+						'int ∪ bigint53': 9007199254740991,
+						'int ∪ decimalnum': 9007199254740991,
+						'int ∪ double': 15.35325689124218,
+						'int ∪ float': 1.0485960245132446,
+						'int ∪ int': 621,
+						'int ∪ medint': 560,
+						'int ∪ smallint': 14,
+						'int ∪ real': 1.048596,
+						'int ∪ tinyint': 7,
+						'int ∪ year': 2025,
+						'medint ∪ serial': 1,
+						'medint ∪ bigint53': 9007199254740991,
+						'medint ∪ decimalnum': 9007199254740991,
+						'medint ∪ double': 15.35325689124218,
+						'medint ∪ float': 1.048596,
+						'medint ∪ int': 621,
+						'medint ∪ medint': 560,
+						'medint ∪ smallint': 14,
+						'medint ∪ real': 1.048596,
+						'medint ∪ tinyint': 7,
+						'medint ∪ year': 2025,
+						'smallint ∪ serial': 1,
+						'smallint ∪ bigint53': 9007199254740991,
+						'smallint ∪ decimalnum': 9007199254740991,
+						'smallint ∪ double': 15.35325689124218,
+						'smallint ∪ float': 1.048596,
+						'smallint ∪ int': 621,
+						'smallint ∪ medint': 560,
+						'smallint ∪ smallint': 14,
+						'smallint ∪ real': 1.048596,
+						'smallint ∪ tinyint': 7,
+						'smallint ∪ year': 2025,
+						'real ∪ serial': 1,
+						'real ∪ bigint53': 9007199254740991,
+						'real ∪ decimalnum': 9007199254740991,
+						'real ∪ double': 15.35325689124218,
+						'real ∪ float': 1.0485960245132446,
+						'real ∪ int': 621,
+						'real ∪ medint': 560,
+						'real ∪ smallint': 14,
+						'real ∪ real': 1.048596,
+						'real ∪ tinyint': 7,
+						'real ∪ year': 2025,
+						'tinyint ∪ serial': 1,
+						'tinyint ∪ bigint53': 9007199254740991,
+						'tinyint ∪ decimalnum': 9007199254740991,
+						'tinyint ∪ double': 15.35325689124218,
+						'tinyint ∪ float': 1.048596,
+						'tinyint ∪ int': 621,
+						'tinyint ∪ medint': 560,
+						'tinyint ∪ smallint': 14,
+						'tinyint ∪ real': 1.048596,
+						'tinyint ∪ tinyint': 7,
+						'tinyint ∪ year': 127,
+						'year ∪ serial': 1,
+						'year ∪ bigint53': 9007199254740991,
+						'year ∪ decimalnum': 9007199254740991,
+						'year ∪ double': 15.35325689124218,
+						'year ∪ float': 1.048596,
+						'year ∪ int': 621,
+						'year ∪ medint': 560,
+						'year ∪ smallint': 14,
+						'year ∪ real': 1.048596,
+						'year ∪ tinyint': 7,
+						'year ∪ year': 2025,
+					},
+				]));
+
+				// ---- strings ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+							'bigintstr ∪ char': allTypesCodecsTable.bigintstr.as('bigintstr ∪ char'),
+							'bigintstr ∪ decimal': allTypesCodecsTable.bigintstr.as('bigintstr ∪ decimal'),
+							'bigintstr ∪ text': allTypesCodecsTable.bigintstr.as('bigintstr ∪ text'),
+							'bigintstr ∪ tinytext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ tinytext'),
+							'bigintstr ∪ mediumtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ mediumtext'),
+							'bigintstr ∪ longtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ longtext'),
+							'bigintstr ∪ varchar': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varchar'),
+							'bigintstr ∪ varbin': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varbin'),
+							'bigintstr ∪ stringblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringblob'),
+							'bigintstr ∪ stringtinyblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringtinyblob'),
+							'bigintstr ∪ stringmediumblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringmediumblob'),
+							'bigintstr ∪ stringlongblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringlongblob'),
+							'bigintstr ∪ datestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datestr'),
+							'bigintstr ∪ datetimestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datetimestr'),
+							'bigintstr ∪ timestampstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ timestampstr'),
+							'bigintstr ∪ time': allTypesCodecsTable.bigintstr.as('bigintstr ∪ time'),
+							'char ∪ bigintstr': allTypesCodecsTable.char.as('char ∪ bigintstr'),
+							'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+							'char ∪ decimal': allTypesCodecsTable.char.as('char ∪ decimal'),
+							'char ∪ text': allTypesCodecsTable.char.as('char ∪ text'),
+							'char ∪ tinytext': allTypesCodecsTable.char.as('char ∪ tinytext'),
+							'char ∪ mediumtext': allTypesCodecsTable.char.as('char ∪ mediumtext'),
+							'char ∪ longtext': allTypesCodecsTable.char.as('char ∪ longtext'),
+							'char ∪ varchar': allTypesCodecsTable.char.as('char ∪ varchar'),
+							'char ∪ varbin': allTypesCodecsTable.char.as('char ∪ varbin'),
+							'char ∪ stringblob': allTypesCodecsTable.char.as('char ∪ stringblob'),
+							'char ∪ stringtinyblob': allTypesCodecsTable.char.as('char ∪ stringtinyblob'),
+							'char ∪ stringmediumblob': allTypesCodecsTable.char.as('char ∪ stringmediumblob'),
+							'char ∪ stringlongblob': allTypesCodecsTable.char.as('char ∪ stringlongblob'),
+							'char ∪ datestr': allTypesCodecsTable.char.as('char ∪ datestr'),
+							'char ∪ datetimestr': allTypesCodecsTable.char.as('char ∪ datetimestr'),
+							'char ∪ timestampstr': allTypesCodecsTable.char.as('char ∪ timestampstr'),
+							'char ∪ time': allTypesCodecsTable.char.as('char ∪ time'),
+							'decimal ∪ bigintstr': allTypesCodecsTable.decimal.as('decimal ∪ bigintstr'),
+							'decimal ∪ char': allTypesCodecsTable.decimal.as('decimal ∪ char'),
+							'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+							'decimal ∪ text': allTypesCodecsTable.decimal.as('decimal ∪ text'),
+							'decimal ∪ tinytext': allTypesCodecsTable.decimal.as('decimal ∪ tinytext'),
+							'decimal ∪ mediumtext': allTypesCodecsTable.decimal.as('decimal ∪ mediumtext'),
+							'decimal ∪ longtext': allTypesCodecsTable.decimal.as('decimal ∪ longtext'),
+							'decimal ∪ varchar': allTypesCodecsTable.decimal.as('decimal ∪ varchar'),
+							'decimal ∪ varbin': allTypesCodecsTable.decimal.as('decimal ∪ varbin'),
+							'decimal ∪ stringblob': allTypesCodecsTable.decimal.as('decimal ∪ stringblob'),
+							'decimal ∪ stringtinyblob': allTypesCodecsTable.decimal.as('decimal ∪ stringtinyblob'),
+							'decimal ∪ stringmediumblob': allTypesCodecsTable.decimal.as('decimal ∪ stringmediumblob'),
+							'decimal ∪ stringlongblob': allTypesCodecsTable.decimal.as('decimal ∪ stringlongblob'),
+							'decimal ∪ datestr': allTypesCodecsTable.decimal.as('decimal ∪ datestr'),
+							'decimal ∪ datetimestr': allTypesCodecsTable.decimal.as('decimal ∪ datetimestr'),
+							'decimal ∪ timestampstr': allTypesCodecsTable.decimal.as('decimal ∪ timestampstr'),
+							'decimal ∪ time': allTypesCodecsTable.decimal.as('decimal ∪ time'),
+							'text ∪ bigintstr': allTypesCodecsTable.text.as('text ∪ bigintstr'),
+							'text ∪ char': allTypesCodecsTable.text.as('text ∪ char'),
+							'text ∪ decimal': allTypesCodecsTable.text.as('text ∪ decimal'),
+							'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+							'text ∪ tinytext': allTypesCodecsTable.text.as('text ∪ tinytext'),
+							'text ∪ mediumtext': allTypesCodecsTable.text.as('text ∪ mediumtext'),
+							'text ∪ longtext': allTypesCodecsTable.text.as('text ∪ longtext'),
+							'text ∪ varchar': allTypesCodecsTable.text.as('text ∪ varchar'),
+							'text ∪ varbin': allTypesCodecsTable.text.as('text ∪ varbin'),
+							'text ∪ stringblob': allTypesCodecsTable.text.as('text ∪ stringblob'),
+							'text ∪ stringtinyblob': allTypesCodecsTable.text.as('text ∪ stringtinyblob'),
+							'text ∪ stringmediumblob': allTypesCodecsTable.text.as('text ∪ stringmediumblob'),
+							'text ∪ stringlongblob': allTypesCodecsTable.text.as('text ∪ stringlongblob'),
+							'text ∪ datestr': allTypesCodecsTable.text.as('text ∪ datestr'),
+							'text ∪ datetimestr': allTypesCodecsTable.text.as('text ∪ datetimestr'),
+							'text ∪ timestampstr': allTypesCodecsTable.text.as('text ∪ timestampstr'),
+							'text ∪ time': allTypesCodecsTable.text.as('text ∪ time'),
+							'tinytext ∪ bigintstr': allTypesCodecsTable.tinytext.as('tinytext ∪ bigintstr'),
+							'tinytext ∪ char': allTypesCodecsTable.tinytext.as('tinytext ∪ char'),
+							'tinytext ∪ decimal': allTypesCodecsTable.tinytext.as('tinytext ∪ decimal'),
+							'tinytext ∪ text': allTypesCodecsTable.tinytext.as('tinytext ∪ text'),
+							'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+							'tinytext ∪ mediumtext': allTypesCodecsTable.tinytext.as('tinytext ∪ mediumtext'),
+							'tinytext ∪ longtext': allTypesCodecsTable.tinytext.as('tinytext ∪ longtext'),
+							'tinytext ∪ varchar': allTypesCodecsTable.tinytext.as('tinytext ∪ varchar'),
+							'tinytext ∪ varbin': allTypesCodecsTable.tinytext.as('tinytext ∪ varbin'),
+							'tinytext ∪ stringblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringblob'),
+							'tinytext ∪ stringtinyblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringtinyblob'),
+							'tinytext ∪ stringmediumblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringmediumblob'),
+							'tinytext ∪ stringlongblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringlongblob'),
+							'tinytext ∪ datestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datestr'),
+							'tinytext ∪ datetimestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datetimestr'),
+							'tinytext ∪ timestampstr': allTypesCodecsTable.tinytext.as('tinytext ∪ timestampstr'),
+							'tinytext ∪ time': allTypesCodecsTable.tinytext.as('tinytext ∪ time'),
+							'mediumtext ∪ bigintstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ bigintstr'),
+							'mediumtext ∪ char': allTypesCodecsTable.mediumtext.as('mediumtext ∪ char'),
+							'mediumtext ∪ decimal': allTypesCodecsTable.mediumtext.as('mediumtext ∪ decimal'),
+							'mediumtext ∪ text': allTypesCodecsTable.mediumtext.as('mediumtext ∪ text'),
+							'mediumtext ∪ tinytext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ tinytext'),
+							'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+							'mediumtext ∪ longtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ longtext'),
+							'mediumtext ∪ varchar': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varchar'),
+							'mediumtext ∪ varbin': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varbin'),
+							'mediumtext ∪ stringblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringblob'),
+							'mediumtext ∪ stringtinyblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringtinyblob'),
+							'mediumtext ∪ stringmediumblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringmediumblob'),
+							'mediumtext ∪ stringlongblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringlongblob'),
+							'mediumtext ∪ datestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datestr'),
+							'mediumtext ∪ datetimestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datetimestr'),
+							'mediumtext ∪ timestampstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ timestampstr'),
+							'mediumtext ∪ time': allTypesCodecsTable.mediumtext.as('mediumtext ∪ time'),
+							'longtext ∪ bigintstr': allTypesCodecsTable.longtext.as('longtext ∪ bigintstr'),
+							'longtext ∪ char': allTypesCodecsTable.longtext.as('longtext ∪ char'),
+							'longtext ∪ decimal': allTypesCodecsTable.longtext.as('longtext ∪ decimal'),
+							'longtext ∪ text': allTypesCodecsTable.longtext.as('longtext ∪ text'),
+							'longtext ∪ tinytext': allTypesCodecsTable.longtext.as('longtext ∪ tinytext'),
+							'longtext ∪ mediumtext': allTypesCodecsTable.longtext.as('longtext ∪ mediumtext'),
+							'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+							'longtext ∪ varchar': allTypesCodecsTable.longtext.as('longtext ∪ varchar'),
+							'longtext ∪ varbin': allTypesCodecsTable.longtext.as('longtext ∪ varbin'),
+							'longtext ∪ stringblob': allTypesCodecsTable.longtext.as('longtext ∪ stringblob'),
+							'longtext ∪ stringtinyblob': allTypesCodecsTable.longtext.as('longtext ∪ stringtinyblob'),
+							'longtext ∪ stringmediumblob': allTypesCodecsTable.longtext.as('longtext ∪ stringmediumblob'),
+							'longtext ∪ stringlongblob': allTypesCodecsTable.longtext.as('longtext ∪ stringlongblob'),
+							'longtext ∪ datestr': allTypesCodecsTable.longtext.as('longtext ∪ datestr'),
+							'longtext ∪ datetimestr': allTypesCodecsTable.longtext.as('longtext ∪ datetimestr'),
+							'longtext ∪ timestampstr': allTypesCodecsTable.longtext.as('longtext ∪ timestampstr'),
+							'longtext ∪ time': allTypesCodecsTable.longtext.as('longtext ∪ time'),
+							'varchar ∪ bigintstr': allTypesCodecsTable.varchar.as('varchar ∪ bigintstr'),
+							'varchar ∪ char': allTypesCodecsTable.varchar.as('varchar ∪ char'),
+							'varchar ∪ decimal': allTypesCodecsTable.varchar.as('varchar ∪ decimal'),
+							'varchar ∪ text': allTypesCodecsTable.varchar.as('varchar ∪ text'),
+							'varchar ∪ tinytext': allTypesCodecsTable.varchar.as('varchar ∪ tinytext'),
+							'varchar ∪ mediumtext': allTypesCodecsTable.varchar.as('varchar ∪ mediumtext'),
+							'varchar ∪ longtext': allTypesCodecsTable.varchar.as('varchar ∪ longtext'),
+							'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+							'varchar ∪ varbin': allTypesCodecsTable.varchar.as('varchar ∪ varbin'),
+							'varchar ∪ stringblob': allTypesCodecsTable.varchar.as('varchar ∪ stringblob'),
+							'varchar ∪ stringtinyblob': allTypesCodecsTable.varchar.as('varchar ∪ stringtinyblob'),
+							'varchar ∪ stringmediumblob': allTypesCodecsTable.varchar.as('varchar ∪ stringmediumblob'),
+							'varchar ∪ stringlongblob': allTypesCodecsTable.varchar.as('varchar ∪ stringlongblob'),
+							'varchar ∪ datestr': allTypesCodecsTable.varchar.as('varchar ∪ datestr'),
+							'varchar ∪ datetimestr': allTypesCodecsTable.varchar.as('varchar ∪ datetimestr'),
+							'varchar ∪ timestampstr': allTypesCodecsTable.varchar.as('varchar ∪ timestampstr'),
+							'varchar ∪ time': allTypesCodecsTable.varchar.as('varchar ∪ time'),
+							'varbin ∪ bigintstr': allTypesCodecsTable.varbin.as('varbin ∪ bigintstr'),
+							'varbin ∪ char': allTypesCodecsTable.varbin.as('varbin ∪ char'),
+							'varbin ∪ decimal': allTypesCodecsTable.varbin.as('varbin ∪ decimal'),
+							'varbin ∪ text': allTypesCodecsTable.varbin.as('varbin ∪ text'),
+							'varbin ∪ tinytext': allTypesCodecsTable.varbin.as('varbin ∪ tinytext'),
+							'varbin ∪ mediumtext': allTypesCodecsTable.varbin.as('varbin ∪ mediumtext'),
+							'varbin ∪ longtext': allTypesCodecsTable.varbin.as('varbin ∪ longtext'),
+							'varbin ∪ varchar': allTypesCodecsTable.varbin.as('varbin ∪ varchar'),
+							'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+							'varbin ∪ stringblob': allTypesCodecsTable.varbin.as('varbin ∪ stringblob'),
+							'varbin ∪ stringtinyblob': allTypesCodecsTable.varbin.as('varbin ∪ stringtinyblob'),
+							'varbin ∪ stringmediumblob': allTypesCodecsTable.varbin.as('varbin ∪ stringmediumblob'),
+							'varbin ∪ stringlongblob': allTypesCodecsTable.varbin.as('varbin ∪ stringlongblob'),
+							'varbin ∪ datestr': allTypesCodecsTable.varbin.as('varbin ∪ datestr'),
+							'varbin ∪ datetimestr': allTypesCodecsTable.varbin.as('varbin ∪ datetimestr'),
+							'varbin ∪ timestampstr': allTypesCodecsTable.varbin.as('varbin ∪ timestampstr'),
+							'varbin ∪ time': allTypesCodecsTable.varbin.as('varbin ∪ time'),
+							'stringblob ∪ bigintstr': allTypesCodecsTable.stringblob.as('stringblob ∪ bigintstr'),
+							'stringblob ∪ char': allTypesCodecsTable.stringblob.as('stringblob ∪ char'),
+							'stringblob ∪ decimal': allTypesCodecsTable.stringblob.as('stringblob ∪ decimal'),
+							'stringblob ∪ text': allTypesCodecsTable.stringblob.as('stringblob ∪ text'),
+							'stringblob ∪ tinytext': allTypesCodecsTable.stringblob.as('stringblob ∪ tinytext'),
+							'stringblob ∪ mediumtext': allTypesCodecsTable.stringblob.as('stringblob ∪ mediumtext'),
+							'stringblob ∪ longtext': allTypesCodecsTable.stringblob.as('stringblob ∪ longtext'),
+							'stringblob ∪ varchar': allTypesCodecsTable.stringblob.as('stringblob ∪ varchar'),
+							'stringblob ∪ varbin': allTypesCodecsTable.stringblob.as('stringblob ∪ varbin'),
+							'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+							'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringtinyblob'),
+							'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringmediumblob'),
+							'stringblob ∪ stringlongblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringlongblob'),
+							'stringblob ∪ datestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datestr'),
+							'stringblob ∪ datetimestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datetimestr'),
+							'stringblob ∪ timestampstr': allTypesCodecsTable.stringblob.as('stringblob ∪ timestampstr'),
+							'stringblob ∪ time': allTypesCodecsTable.stringblob.as('stringblob ∪ time'),
+							'stringtinyblob ∪ bigintstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ bigintstr'),
+							'stringtinyblob ∪ char': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ char'),
+							'stringtinyblob ∪ decimal': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ decimal'),
+							'stringtinyblob ∪ text': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ text'),
+							'stringtinyblob ∪ tinytext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ tinytext'),
+							'stringtinyblob ∪ mediumtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ mediumtext'),
+							'stringtinyblob ∪ longtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ longtext'),
+							'stringtinyblob ∪ varchar': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varchar'),
+							'stringtinyblob ∪ varbin': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varbin'),
+							'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringblob'),
+							'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringtinyblob ∪ stringtinyblob',
+							),
+							'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringtinyblob ∪ stringmediumblob',
+							),
+							'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringtinyblob ∪ stringlongblob',
+							),
+							'stringtinyblob ∪ datestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datestr'),
+							'stringtinyblob ∪ datetimestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datetimestr'),
+							'stringtinyblob ∪ timestampstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ timestampstr'),
+							'stringtinyblob ∪ time': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ time'),
+							'stringmediumblob ∪ bigintstr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ bigintstr'),
+							'stringmediumblob ∪ char': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ char'),
+							'stringmediumblob ∪ decimal': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ decimal'),
+							'stringmediumblob ∪ text': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ text'),
+							'stringmediumblob ∪ tinytext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ tinytext'),
+							'stringmediumblob ∪ mediumtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ mediumtext'),
+							'stringmediumblob ∪ longtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ longtext'),
+							'stringmediumblob ∪ varchar': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varchar'),
+							'stringmediumblob ∪ varbin': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varbin'),
+							'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ stringblob'),
+							'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ stringtinyblob',
+							),
+							'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ stringmediumblob',
+							),
+							'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ stringlongblob',
+							),
+							'stringmediumblob ∪ datestr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ datestr'),
+							'stringmediumblob ∪ datetimestr': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ datetimestr',
+							),
+							'stringmediumblob ∪ timestampstr': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ timestampstr',
+							),
+							'stringmediumblob ∪ time': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ time'),
+							'stringlongblob ∪ bigintstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ bigintstr'),
+							'stringlongblob ∪ char': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ char'),
+							'stringlongblob ∪ decimal': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ decimal'),
+							'stringlongblob ∪ text': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ text'),
+							'stringlongblob ∪ tinytext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ tinytext'),
+							'stringlongblob ∪ mediumtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ mediumtext'),
+							'stringlongblob ∪ longtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ longtext'),
+							'stringlongblob ∪ varchar': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varchar'),
+							'stringlongblob ∪ varbin': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varbin'),
+							'stringlongblob ∪ stringblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringblob'),
+							'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringlongblob.as(
+								'stringlongblob ∪ stringtinyblob',
+							),
+							'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringlongblob.as(
+								'stringlongblob ∪ stringmediumblob',
+							),
+							'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as(
+								'stringlongblob ∪ stringlongblob',
+							),
+							'stringlongblob ∪ datestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datestr'),
+							'stringlongblob ∪ datetimestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datetimestr'),
+							'stringlongblob ∪ timestampstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ timestampstr'),
+							'stringlongblob ∪ time': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ time'),
+							'datestr ∪ bigintstr': allTypesCodecsTable.datestr.as('datestr ∪ bigintstr'),
+							'datestr ∪ char': allTypesCodecsTable.datestr.as('datestr ∪ char'),
+							'datestr ∪ decimal': allTypesCodecsTable.datestr.as('datestr ∪ decimal'),
+							'datestr ∪ text': allTypesCodecsTable.datestr.as('datestr ∪ text'),
+							'datestr ∪ tinytext': allTypesCodecsTable.datestr.as('datestr ∪ tinytext'),
+							'datestr ∪ mediumtext': allTypesCodecsTable.datestr.as('datestr ∪ mediumtext'),
+							'datestr ∪ longtext': allTypesCodecsTable.datestr.as('datestr ∪ longtext'),
+							'datestr ∪ varchar': allTypesCodecsTable.datestr.as('datestr ∪ varchar'),
+							'datestr ∪ varbin': allTypesCodecsTable.datestr.as('datestr ∪ varbin'),
+							'datestr ∪ stringblob': allTypesCodecsTable.datestr.as('datestr ∪ stringblob'),
+							'datestr ∪ stringtinyblob': allTypesCodecsTable.datestr.as('datestr ∪ stringtinyblob'),
+							'datestr ∪ stringmediumblob': allTypesCodecsTable.datestr.as('datestr ∪ stringmediumblob'),
+							'datestr ∪ stringlongblob': allTypesCodecsTable.datestr.as('datestr ∪ stringlongblob'),
+							'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+							'datestr ∪ datetimestr': allTypesCodecsTable.datestr.as('datestr ∪ datetimestr'),
+							'datestr ∪ timestampstr': allTypesCodecsTable.datestr.as('datestr ∪ timestampstr'),
+							'datetimestr ∪ bigintstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ bigintstr'),
+							'datetimestr ∪ char': allTypesCodecsTable.datetimestr.as('datetimestr ∪ char'),
+							'datetimestr ∪ decimal': allTypesCodecsTable.datetimestr.as('datetimestr ∪ decimal'),
+							'datetimestr ∪ text': allTypesCodecsTable.datetimestr.as('datetimestr ∪ text'),
+							'datetimestr ∪ tinytext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ tinytext'),
+							'datetimestr ∪ mediumtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ mediumtext'),
+							'datetimestr ∪ longtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ longtext'),
+							'datetimestr ∪ varchar': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varchar'),
+							'datetimestr ∪ varbin': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varbin'),
+							'datetimestr ∪ stringblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringblob'),
+							'datetimestr ∪ stringtinyblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringtinyblob'),
+							'datetimestr ∪ stringmediumblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringmediumblob'),
+							'datetimestr ∪ stringlongblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringlongblob'),
+							'datetimestr ∪ datestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datestr'),
+							'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+							'datetimestr ∪ timestampstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ timestampstr'),
+							'timestampstr ∪ bigintstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ bigintstr'),
+							'timestampstr ∪ char': allTypesCodecsTable.timestampstr.as('timestampstr ∪ char'),
+							'timestampstr ∪ decimal': allTypesCodecsTable.timestampstr.as('timestampstr ∪ decimal'),
+							'timestampstr ∪ text': allTypesCodecsTable.timestampstr.as('timestampstr ∪ text'),
+							'timestampstr ∪ tinytext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ tinytext'),
+							'timestampstr ∪ mediumtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ mediumtext'),
+							'timestampstr ∪ longtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ longtext'),
+							'timestampstr ∪ varchar': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varchar'),
+							'timestampstr ∪ varbin': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varbin'),
+							'timestampstr ∪ stringblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringblob'),
+							'timestampstr ∪ stringtinyblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringtinyblob'),
+							'timestampstr ∪ stringmediumblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringmediumblob'),
+							'timestampstr ∪ stringlongblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringlongblob'),
+							'timestampstr ∪ datestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datestr'),
+							'timestampstr ∪ datetimestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datetimestr'),
+							'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+							'time ∪ bigintstr': allTypesCodecsTable.time.as('time ∪ bigintstr'),
+							'time ∪ char': allTypesCodecsTable.time.as('time ∪ char'),
+							'time ∪ decimal': allTypesCodecsTable.time.as('time ∪ decimal'),
+							'time ∪ text': allTypesCodecsTable.time.as('time ∪ text'),
+							'time ∪ tinytext': allTypesCodecsTable.time.as('time ∪ tinytext'),
+							'time ∪ mediumtext': allTypesCodecsTable.time.as('time ∪ mediumtext'),
+							'time ∪ longtext': allTypesCodecsTable.time.as('time ∪ longtext'),
+							'time ∪ varchar': allTypesCodecsTable.time.as('time ∪ varchar'),
+							'time ∪ varbin': allTypesCodecsTable.time.as('time ∪ varbin'),
+							'time ∪ stringblob': allTypesCodecsTable.time.as('time ∪ stringblob'),
+							'time ∪ stringtinyblob': allTypesCodecsTable.time.as('time ∪ stringtinyblob'),
+							'time ∪ stringmediumblob': allTypesCodecsTable.time.as('time ∪ stringmediumblob'),
+							'time ∪ stringlongblob': allTypesCodecsTable.time.as('time ∪ stringlongblob'),
+							'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+							'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+							'bigintstr ∪ char': allTypesCodecsTable.char.as('bigintstr ∪ char'),
+							'bigintstr ∪ decimal': allTypesCodecsTable.decimal.as('bigintstr ∪ decimal'),
+							'bigintstr ∪ text': allTypesCodecsTable.text.as('bigintstr ∪ text'),
+							'bigintstr ∪ tinytext': allTypesCodecsTable.tinytext.as('bigintstr ∪ tinytext'),
+							'bigintstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('bigintstr ∪ mediumtext'),
+							'bigintstr ∪ longtext': allTypesCodecsTable.longtext.as('bigintstr ∪ longtext'),
+							'bigintstr ∪ varchar': allTypesCodecsTable.varchar.as('bigintstr ∪ varchar'),
+							'bigintstr ∪ varbin': allTypesCodecsTable.varbin.as('bigintstr ∪ varbin'),
+							'bigintstr ∪ stringblob': allTypesCodecsTable.stringblob.as('bigintstr ∪ stringblob'),
+							'bigintstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('bigintstr ∪ stringtinyblob'),
+							'bigintstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('bigintstr ∪ stringmediumblob'),
+							'bigintstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('bigintstr ∪ stringlongblob'),
+							'bigintstr ∪ datestr': allTypesCodecsTable.datestr.as('bigintstr ∪ datestr'),
+							'bigintstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('bigintstr ∪ datetimestr'),
+							'bigintstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('bigintstr ∪ timestampstr'),
+							'bigintstr ∪ time': allTypesCodecsTable.time.as('bigintstr ∪ time'),
+							'char ∪ bigintstr': allTypesCodecsTable.bigintstr.as('char ∪ bigintstr'),
+							'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+							'char ∪ decimal': allTypesCodecsTable.decimal.as('char ∪ decimal'),
+							'char ∪ text': allTypesCodecsTable.text.as('char ∪ text'),
+							'char ∪ tinytext': allTypesCodecsTable.tinytext.as('char ∪ tinytext'),
+							'char ∪ mediumtext': allTypesCodecsTable.mediumtext.as('char ∪ mediumtext'),
+							'char ∪ longtext': allTypesCodecsTable.longtext.as('char ∪ longtext'),
+							'char ∪ varchar': allTypesCodecsTable.varchar.as('char ∪ varchar'),
+							'char ∪ varbin': allTypesCodecsTable.varbin.as('char ∪ varbin'),
+							'char ∪ stringblob': allTypesCodecsTable.stringblob.as('char ∪ stringblob'),
+							'char ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('char ∪ stringtinyblob'),
+							'char ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('char ∪ stringmediumblob'),
+							'char ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('char ∪ stringlongblob'),
+							'char ∪ datestr': allTypesCodecsTable.datestr.as('char ∪ datestr'),
+							'char ∪ datetimestr': allTypesCodecsTable.datetimestr.as('char ∪ datetimestr'),
+							'char ∪ timestampstr': allTypesCodecsTable.timestampstr.as('char ∪ timestampstr'),
+							'char ∪ time': allTypesCodecsTable.time.as('char ∪ time'),
+							'decimal ∪ bigintstr': allTypesCodecsTable.bigintstr.as('decimal ∪ bigintstr'),
+							'decimal ∪ char': allTypesCodecsTable.char.as('decimal ∪ char'),
+							'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+							'decimal ∪ text': allTypesCodecsTable.text.as('decimal ∪ text'),
+							'decimal ∪ tinytext': allTypesCodecsTable.tinytext.as('decimal ∪ tinytext'),
+							'decimal ∪ mediumtext': allTypesCodecsTable.mediumtext.as('decimal ∪ mediumtext'),
+							'decimal ∪ longtext': allTypesCodecsTable.longtext.as('decimal ∪ longtext'),
+							'decimal ∪ varchar': allTypesCodecsTable.varchar.as('decimal ∪ varchar'),
+							'decimal ∪ varbin': allTypesCodecsTable.varbin.as('decimal ∪ varbin'),
+							'decimal ∪ stringblob': allTypesCodecsTable.stringblob.as('decimal ∪ stringblob'),
+							'decimal ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('decimal ∪ stringtinyblob'),
+							'decimal ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('decimal ∪ stringmediumblob'),
+							'decimal ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('decimal ∪ stringlongblob'),
+							'decimal ∪ datestr': allTypesCodecsTable.datestr.as('decimal ∪ datestr'),
+							'decimal ∪ datetimestr': allTypesCodecsTable.datetimestr.as('decimal ∪ datetimestr'),
+							'decimal ∪ timestampstr': allTypesCodecsTable.timestampstr.as('decimal ∪ timestampstr'),
+							'decimal ∪ time': allTypesCodecsTable.time.as('decimal ∪ time'),
+							'text ∪ bigintstr': allTypesCodecsTable.bigintstr.as('text ∪ bigintstr'),
+							'text ∪ char': allTypesCodecsTable.char.as('text ∪ char'),
+							'text ∪ decimal': allTypesCodecsTable.decimal.as('text ∪ decimal'),
+							'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+							'text ∪ tinytext': allTypesCodecsTable.tinytext.as('text ∪ tinytext'),
+							'text ∪ mediumtext': allTypesCodecsTable.mediumtext.as('text ∪ mediumtext'),
+							'text ∪ longtext': allTypesCodecsTable.longtext.as('text ∪ longtext'),
+							'text ∪ varchar': allTypesCodecsTable.varchar.as('text ∪ varchar'),
+							'text ∪ varbin': allTypesCodecsTable.varbin.as('text ∪ varbin'),
+							'text ∪ stringblob': allTypesCodecsTable.stringblob.as('text ∪ stringblob'),
+							'text ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('text ∪ stringtinyblob'),
+							'text ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('text ∪ stringmediumblob'),
+							'text ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('text ∪ stringlongblob'),
+							'text ∪ datestr': allTypesCodecsTable.datestr.as('text ∪ datestr'),
+							'text ∪ datetimestr': allTypesCodecsTable.datetimestr.as('text ∪ datetimestr'),
+							'text ∪ timestampstr': allTypesCodecsTable.timestampstr.as('text ∪ timestampstr'),
+							'text ∪ time': allTypesCodecsTable.time.as('text ∪ time'),
+							'tinytext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('tinytext ∪ bigintstr'),
+							'tinytext ∪ char': allTypesCodecsTable.char.as('tinytext ∪ char'),
+							'tinytext ∪ decimal': allTypesCodecsTable.decimal.as('tinytext ∪ decimal'),
+							'tinytext ∪ text': allTypesCodecsTable.text.as('tinytext ∪ text'),
+							'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+							'tinytext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('tinytext ∪ mediumtext'),
+							'tinytext ∪ longtext': allTypesCodecsTable.longtext.as('tinytext ∪ longtext'),
+							'tinytext ∪ varchar': allTypesCodecsTable.varchar.as('tinytext ∪ varchar'),
+							'tinytext ∪ varbin': allTypesCodecsTable.varbin.as('tinytext ∪ varbin'),
+							'tinytext ∪ stringblob': allTypesCodecsTable.stringblob.as('tinytext ∪ stringblob'),
+							'tinytext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('tinytext ∪ stringtinyblob'),
+							'tinytext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('tinytext ∪ stringmediumblob'),
+							'tinytext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('tinytext ∪ stringlongblob'),
+							'tinytext ∪ datestr': allTypesCodecsTable.datestr.as('tinytext ∪ datestr'),
+							'tinytext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('tinytext ∪ datetimestr'),
+							'tinytext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('tinytext ∪ timestampstr'),
+							'tinytext ∪ time': allTypesCodecsTable.time.as('tinytext ∪ time'),
+							'mediumtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('mediumtext ∪ bigintstr'),
+							'mediumtext ∪ char': allTypesCodecsTable.char.as('mediumtext ∪ char'),
+							'mediumtext ∪ decimal': allTypesCodecsTable.decimal.as('mediumtext ∪ decimal'),
+							'mediumtext ∪ text': allTypesCodecsTable.text.as('mediumtext ∪ text'),
+							'mediumtext ∪ tinytext': allTypesCodecsTable.tinytext.as('mediumtext ∪ tinytext'),
+							'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+							'mediumtext ∪ longtext': allTypesCodecsTable.longtext.as('mediumtext ∪ longtext'),
+							'mediumtext ∪ varchar': allTypesCodecsTable.varchar.as('mediumtext ∪ varchar'),
+							'mediumtext ∪ varbin': allTypesCodecsTable.varbin.as('mediumtext ∪ varbin'),
+							'mediumtext ∪ stringblob': allTypesCodecsTable.stringblob.as('mediumtext ∪ stringblob'),
+							'mediumtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('mediumtext ∪ stringtinyblob'),
+							'mediumtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('mediumtext ∪ stringmediumblob'),
+							'mediumtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('mediumtext ∪ stringlongblob'),
+							'mediumtext ∪ datestr': allTypesCodecsTable.datestr.as('mediumtext ∪ datestr'),
+							'mediumtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('mediumtext ∪ datetimestr'),
+							'mediumtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('mediumtext ∪ timestampstr'),
+							'mediumtext ∪ time': allTypesCodecsTable.time.as('mediumtext ∪ time'),
+							'longtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('longtext ∪ bigintstr'),
+							'longtext ∪ char': allTypesCodecsTable.char.as('longtext ∪ char'),
+							'longtext ∪ decimal': allTypesCodecsTable.decimal.as('longtext ∪ decimal'),
+							'longtext ∪ text': allTypesCodecsTable.text.as('longtext ∪ text'),
+							'longtext ∪ tinytext': allTypesCodecsTable.tinytext.as('longtext ∪ tinytext'),
+							'longtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('longtext ∪ mediumtext'),
+							'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+							'longtext ∪ varchar': allTypesCodecsTable.varchar.as('longtext ∪ varchar'),
+							'longtext ∪ varbin': allTypesCodecsTable.varbin.as('longtext ∪ varbin'),
+							'longtext ∪ stringblob': allTypesCodecsTable.stringblob.as('longtext ∪ stringblob'),
+							'longtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('longtext ∪ stringtinyblob'),
+							'longtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('longtext ∪ stringmediumblob'),
+							'longtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('longtext ∪ stringlongblob'),
+							'longtext ∪ datestr': allTypesCodecsTable.datestr.as('longtext ∪ datestr'),
+							'longtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('longtext ∪ datetimestr'),
+							'longtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('longtext ∪ timestampstr'),
+							'longtext ∪ time': allTypesCodecsTable.time.as('longtext ∪ time'),
+							'varchar ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varchar ∪ bigintstr'),
+							'varchar ∪ char': allTypesCodecsTable.char.as('varchar ∪ char'),
+							'varchar ∪ decimal': allTypesCodecsTable.decimal.as('varchar ∪ decimal'),
+							'varchar ∪ text': allTypesCodecsTable.text.as('varchar ∪ text'),
+							'varchar ∪ tinytext': allTypesCodecsTable.tinytext.as('varchar ∪ tinytext'),
+							'varchar ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varchar ∪ mediumtext'),
+							'varchar ∪ longtext': allTypesCodecsTable.longtext.as('varchar ∪ longtext'),
+							'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+							'varchar ∪ varbin': allTypesCodecsTable.varbin.as('varchar ∪ varbin'),
+							'varchar ∪ stringblob': allTypesCodecsTable.stringblob.as('varchar ∪ stringblob'),
+							'varchar ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varchar ∪ stringtinyblob'),
+							'varchar ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varchar ∪ stringmediumblob'),
+							'varchar ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varchar ∪ stringlongblob'),
+							'varchar ∪ datestr': allTypesCodecsTable.datestr.as('varchar ∪ datestr'),
+							'varchar ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varchar ∪ datetimestr'),
+							'varchar ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varchar ∪ timestampstr'),
+							'varchar ∪ time': allTypesCodecsTable.time.as('varchar ∪ time'),
+							'varbin ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varbin ∪ bigintstr'),
+							'varbin ∪ char': allTypesCodecsTable.char.as('varbin ∪ char'),
+							'varbin ∪ decimal': allTypesCodecsTable.decimal.as('varbin ∪ decimal'),
+							'varbin ∪ text': allTypesCodecsTable.text.as('varbin ∪ text'),
+							'varbin ∪ tinytext': allTypesCodecsTable.tinytext.as('varbin ∪ tinytext'),
+							'varbin ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varbin ∪ mediumtext'),
+							'varbin ∪ longtext': allTypesCodecsTable.longtext.as('varbin ∪ longtext'),
+							'varbin ∪ varchar': allTypesCodecsTable.varchar.as('varbin ∪ varchar'),
+							'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+							'varbin ∪ stringblob': allTypesCodecsTable.stringblob.as('varbin ∪ stringblob'),
+							'varbin ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varbin ∪ stringtinyblob'),
+							'varbin ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varbin ∪ stringmediumblob'),
+							'varbin ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varbin ∪ stringlongblob'),
+							'varbin ∪ datestr': allTypesCodecsTable.datestr.as('varbin ∪ datestr'),
+							'varbin ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varbin ∪ datetimestr'),
+							'varbin ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varbin ∪ timestampstr'),
+							'varbin ∪ time': allTypesCodecsTable.time.as('varbin ∪ time'),
+							'stringblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringblob ∪ bigintstr'),
+							'stringblob ∪ char': allTypesCodecsTable.char.as('stringblob ∪ char'),
+							'stringblob ∪ decimal': allTypesCodecsTable.decimal.as('stringblob ∪ decimal'),
+							'stringblob ∪ text': allTypesCodecsTable.text.as('stringblob ∪ text'),
+							'stringblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringblob ∪ tinytext'),
+							'stringblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringblob ∪ mediumtext'),
+							'stringblob ∪ longtext': allTypesCodecsTable.longtext.as('stringblob ∪ longtext'),
+							'stringblob ∪ varchar': allTypesCodecsTable.varchar.as('stringblob ∪ varchar'),
+							'stringblob ∪ varbin': allTypesCodecsTable.varbin.as('stringblob ∪ varbin'),
+							'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+							'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringblob ∪ stringtinyblob'),
+							'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('stringblob ∪ stringmediumblob'),
+							'stringblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringblob ∪ stringlongblob'),
+							'stringblob ∪ datestr': allTypesCodecsTable.datestr.as('stringblob ∪ datestr'),
+							'stringblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringblob ∪ datetimestr'),
+							'stringblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringblob ∪ timestampstr'),
+							'stringblob ∪ time': allTypesCodecsTable.time.as('stringblob ∪ time'),
+							'stringtinyblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringtinyblob ∪ bigintstr'),
+							'stringtinyblob ∪ char': allTypesCodecsTable.char.as('stringtinyblob ∪ char'),
+							'stringtinyblob ∪ decimal': allTypesCodecsTable.decimal.as('stringtinyblob ∪ decimal'),
+							'stringtinyblob ∪ text': allTypesCodecsTable.text.as('stringtinyblob ∪ text'),
+							'stringtinyblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringtinyblob ∪ tinytext'),
+							'stringtinyblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringtinyblob ∪ mediumtext'),
+							'stringtinyblob ∪ longtext': allTypesCodecsTable.longtext.as('stringtinyblob ∪ longtext'),
+							'stringtinyblob ∪ varchar': allTypesCodecsTable.varchar.as('stringtinyblob ∪ varchar'),
+							'stringtinyblob ∪ varbin': allTypesCodecsTable.varbin.as('stringtinyblob ∪ varbin'),
+							'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringtinyblob ∪ stringblob'),
+							'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringtinyblob ∪ stringtinyblob',
+							),
+							'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringtinyblob ∪ stringmediumblob',
+							),
+							'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as(
+								'stringtinyblob ∪ stringlongblob',
+							),
+							'stringtinyblob ∪ datestr': allTypesCodecsTable.datestr.as('stringtinyblob ∪ datestr'),
+							'stringtinyblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringtinyblob ∪ datetimestr'),
+							'stringtinyblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringtinyblob ∪ timestampstr'),
+							'stringtinyblob ∪ time': allTypesCodecsTable.time.as('stringtinyblob ∪ time'),
+							'stringmediumblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringmediumblob ∪ bigintstr'),
+							'stringmediumblob ∪ char': allTypesCodecsTable.char.as('stringmediumblob ∪ char'),
+							'stringmediumblob ∪ decimal': allTypesCodecsTable.decimal.as('stringmediumblob ∪ decimal'),
+							'stringmediumblob ∪ text': allTypesCodecsTable.text.as('stringmediumblob ∪ text'),
+							'stringmediumblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringmediumblob ∪ tinytext'),
+							'stringmediumblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringmediumblob ∪ mediumtext'),
+							'stringmediumblob ∪ longtext': allTypesCodecsTable.longtext.as('stringmediumblob ∪ longtext'),
+							'stringmediumblob ∪ varchar': allTypesCodecsTable.varchar.as('stringmediumblob ∪ varchar'),
+							'stringmediumblob ∪ varbin': allTypesCodecsTable.varbin.as('stringmediumblob ∪ varbin'),
+							'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringmediumblob ∪ stringblob'),
+							'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringmediumblob ∪ stringtinyblob',
+							),
+							'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringmediumblob ∪ stringmediumblob',
+							),
+							'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as(
+								'stringmediumblob ∪ stringlongblob',
+							),
+							'stringmediumblob ∪ datestr': allTypesCodecsTable.datestr.as('stringmediumblob ∪ datestr'),
+							'stringmediumblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringmediumblob ∪ datetimestr'),
+							'stringmediumblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringmediumblob ∪ timestampstr'),
+							'stringmediumblob ∪ time': allTypesCodecsTable.time.as('stringmediumblob ∪ time'),
+							'stringlongblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringlongblob ∪ bigintstr'),
+							'stringlongblob ∪ char': allTypesCodecsTable.char.as('stringlongblob ∪ char'),
+							'stringlongblob ∪ decimal': allTypesCodecsTable.decimal.as('stringlongblob ∪ decimal'),
+							'stringlongblob ∪ text': allTypesCodecsTable.text.as('stringlongblob ∪ text'),
+							'stringlongblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringlongblob ∪ tinytext'),
+							'stringlongblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringlongblob ∪ mediumtext'),
+							'stringlongblob ∪ longtext': allTypesCodecsTable.longtext.as('stringlongblob ∪ longtext'),
+							'stringlongblob ∪ varchar': allTypesCodecsTable.varchar.as('stringlongblob ∪ varchar'),
+							'stringlongblob ∪ varbin': allTypesCodecsTable.varbin.as('stringlongblob ∪ varbin'),
+							'stringlongblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringlongblob ∪ stringblob'),
+							'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as(
+								'stringlongblob ∪ stringtinyblob',
+							),
+							'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'stringlongblob ∪ stringmediumblob',
+							),
+							'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as(
+								'stringlongblob ∪ stringlongblob',
+							),
+							'stringlongblob ∪ datestr': allTypesCodecsTable.datestr.as('stringlongblob ∪ datestr'),
+							'stringlongblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringlongblob ∪ datetimestr'),
+							'stringlongblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringlongblob ∪ timestampstr'),
+							'stringlongblob ∪ time': allTypesCodecsTable.time.as('stringlongblob ∪ time'),
+							'datestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datestr ∪ bigintstr'),
+							'datestr ∪ char': allTypesCodecsTable.char.as('datestr ∪ char'),
+							'datestr ∪ decimal': allTypesCodecsTable.decimal.as('datestr ∪ decimal'),
+							'datestr ∪ text': allTypesCodecsTable.text.as('datestr ∪ text'),
+							'datestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datestr ∪ tinytext'),
+							'datestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datestr ∪ mediumtext'),
+							'datestr ∪ longtext': allTypesCodecsTable.longtext.as('datestr ∪ longtext'),
+							'datestr ∪ varchar': allTypesCodecsTable.varchar.as('datestr ∪ varchar'),
+							'datestr ∪ varbin': allTypesCodecsTable.varbin.as('datestr ∪ varbin'),
+							'datestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datestr ∪ stringblob'),
+							'datestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datestr ∪ stringtinyblob'),
+							'datestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('datestr ∪ stringmediumblob'),
+							'datestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datestr ∪ stringlongblob'),
+							'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+							'datestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datestr ∪ datetimestr'),
+							'datestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datestr ∪ timestampstr'),
+							'datetimestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datetimestr ∪ bigintstr'),
+							'datetimestr ∪ char': allTypesCodecsTable.char.as('datetimestr ∪ char'),
+							'datetimestr ∪ decimal': allTypesCodecsTable.decimal.as('datetimestr ∪ decimal'),
+							'datetimestr ∪ text': allTypesCodecsTable.text.as('datetimestr ∪ text'),
+							'datetimestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datetimestr ∪ tinytext'),
+							'datetimestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datetimestr ∪ mediumtext'),
+							'datetimestr ∪ longtext': allTypesCodecsTable.longtext.as('datetimestr ∪ longtext'),
+							'datetimestr ∪ varchar': allTypesCodecsTable.varchar.as('datetimestr ∪ varchar'),
+							'datetimestr ∪ varbin': allTypesCodecsTable.varbin.as('datetimestr ∪ varbin'),
+							'datetimestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datetimestr ∪ stringblob'),
+							'datetimestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datetimestr ∪ stringtinyblob'),
+							'datetimestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'datetimestr ∪ stringmediumblob',
+							),
+							'datetimestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datetimestr ∪ stringlongblob'),
+							'datetimestr ∪ datestr': allTypesCodecsTable.datestr.as('datetimestr ∪ datestr'),
+							'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+							'datetimestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datetimestr ∪ timestampstr'),
+							'timestampstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('timestampstr ∪ bigintstr'),
+							'timestampstr ∪ char': allTypesCodecsTable.char.as('timestampstr ∪ char'),
+							'timestampstr ∪ decimal': allTypesCodecsTable.decimal.as('timestampstr ∪ decimal'),
+							'timestampstr ∪ text': allTypesCodecsTable.text.as('timestampstr ∪ text'),
+							'timestampstr ∪ tinytext': allTypesCodecsTable.tinytext.as('timestampstr ∪ tinytext'),
+							'timestampstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('timestampstr ∪ mediumtext'),
+							'timestampstr ∪ longtext': allTypesCodecsTable.longtext.as('timestampstr ∪ longtext'),
+							'timestampstr ∪ varchar': allTypesCodecsTable.varchar.as('timestampstr ∪ varchar'),
+							'timestampstr ∪ varbin': allTypesCodecsTable.varbin.as('timestampstr ∪ varbin'),
+							'timestampstr ∪ stringblob': allTypesCodecsTable.stringblob.as('timestampstr ∪ stringblob'),
+							'timestampstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('timestampstr ∪ stringtinyblob'),
+							'timestampstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+								'timestampstr ∪ stringmediumblob',
+							),
+							'timestampstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('timestampstr ∪ stringlongblob'),
+							'timestampstr ∪ datestr': allTypesCodecsTable.datestr.as('timestampstr ∪ datestr'),
+							'timestampstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('timestampstr ∪ datetimestr'),
+							'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+							'time ∪ bigintstr': allTypesCodecsTable.bigintstr.as('time ∪ bigintstr'),
+							'time ∪ char': allTypesCodecsTable.char.as('time ∪ char'),
+							'time ∪ decimal': allTypesCodecsTable.decimal.as('time ∪ decimal'),
+							'time ∪ text': allTypesCodecsTable.text.as('time ∪ text'),
+							'time ∪ tinytext': allTypesCodecsTable.tinytext.as('time ∪ tinytext'),
+							'time ∪ mediumtext': allTypesCodecsTable.mediumtext.as('time ∪ mediumtext'),
+							'time ∪ longtext': allTypesCodecsTable.longtext.as('time ∪ longtext'),
+							'time ∪ varchar': allTypesCodecsTable.varchar.as('time ∪ varchar'),
+							'time ∪ varbin': allTypesCodecsTable.varbin.as('time ∪ varbin'),
+							'time ∪ stringblob': allTypesCodecsTable.stringblob.as('time ∪ stringblob'),
+							'time ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('time ∪ stringtinyblob'),
+							'time ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('time ∪ stringmediumblob'),
+							'time ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('time ∪ stringlongblob'),
+							'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+							'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'bigintstr ∪ bigintstr': '5044565289845416380',
+						'bigintstr ∪ char': '5044565289845416380',
+						'bigintstr ∪ decimal': '5044565289845416380',
+						'bigintstr ∪ text': '5044565289845416380',
+						'bigintstr ∪ tinytext': '5044565289845416380',
+						'bigintstr ∪ mediumtext': '5044565289845416380',
+						'bigintstr ∪ longtext': '5044565289845416380',
+						'bigintstr ∪ varchar': '5044565289845416380',
+						'bigintstr ∪ varbin': '5044565289845416380',
+						'bigintstr ∪ stringblob': '5044565289845416380',
+						'bigintstr ∪ stringtinyblob': '5044565289845416380',
+						'bigintstr ∪ stringmediumblob': '5044565289845416380',
+						'bigintstr ∪ stringlongblob': '5044565289845416380',
+						'bigintstr ∪ datestr': '5044565289845416380',
+						'bigintstr ∪ datetimestr': '5044565289845416380',
+						'bigintstr ∪ timestampstr': '5044565289845416380',
+						'bigintstr ∪ time': '5044565289845416380',
+						'char ∪ bigintstr': 'c',
+						'char ∪ char': 'c',
+						'char ∪ decimal': 'c',
+						'char ∪ text': 'c',
+						'char ∪ tinytext': 'c',
+						'char ∪ mediumtext': 'c',
+						'char ∪ longtext': 'c',
+						'char ∪ varchar': 'c',
+						'char ∪ varbin': 'c',
+						'char ∪ stringblob': 'c',
+						'char ∪ stringtinyblob': 'c',
+						'char ∪ stringmediumblob': 'c',
+						'char ∪ stringlongblob': 'c',
+						'char ∪ datestr': 'c',
+						'char ∪ datetimestr': 'c',
+						'char ∪ timestampstr': 'c',
+						'char ∪ time': 'c',
+						'decimal ∪ bigintstr': '47521',
+						'decimal ∪ char': '47521',
+						'decimal ∪ decimal': '47521',
+						'decimal ∪ text': '47521',
+						'decimal ∪ tinytext': '47521',
+						'decimal ∪ mediumtext': '47521',
+						'decimal ∪ longtext': '47521',
+						'decimal ∪ varchar': '47521',
+						'decimal ∪ varbin': '47521',
+						'decimal ∪ stringblob': '47521',
+						'decimal ∪ stringtinyblob': '47521',
+						'decimal ∪ stringmediumblob': '47521',
+						'decimal ∪ stringlongblob': '47521',
+						'decimal ∪ datestr': '47521',
+						'decimal ∪ datetimestr': '47521',
+						'decimal ∪ timestampstr': '47521',
+						'decimal ∪ time': '47521',
+						'text ∪ bigintstr': 'C4-',
+						'text ∪ char': 'C4-',
+						'text ∪ decimal': 'C4-',
+						'text ∪ text': 'C4-',
+						'text ∪ tinytext': 'C4-',
+						'text ∪ mediumtext': 'C4-',
+						'text ∪ longtext': 'C4-',
+						'text ∪ varchar': 'C4-',
+						'text ∪ varbin': 'C4-',
+						'text ∪ stringblob': 'C4-',
+						'text ∪ stringtinyblob': 'C4-',
+						'text ∪ stringmediumblob': 'C4-',
+						'text ∪ stringlongblob': 'C4-',
+						'text ∪ datestr': 'C4-',
+						'text ∪ datetimestr': 'C4-',
+						'text ∪ timestampstr': 'C4-',
+						'text ∪ time': 'C4-',
+						'tinytext ∪ bigintstr': 'tiny text',
+						'tinytext ∪ char': 'tiny text',
+						'tinytext ∪ decimal': 'tiny text',
+						'tinytext ∪ text': 'tiny text',
+						'tinytext ∪ tinytext': 'tiny text',
+						'tinytext ∪ mediumtext': 'tiny text',
+						'tinytext ∪ longtext': 'tiny text',
+						'tinytext ∪ varchar': 'tiny text',
+						'tinytext ∪ varbin': 'tiny text',
+						'tinytext ∪ stringblob': 'tiny text',
+						'tinytext ∪ stringtinyblob': 'tiny text',
+						'tinytext ∪ stringmediumblob': 'tiny text',
+						'tinytext ∪ stringlongblob': 'tiny text',
+						'tinytext ∪ datestr': 'tiny text',
+						'tinytext ∪ datetimestr': 'tiny text',
+						'tinytext ∪ timestampstr': 'tiny text',
+						'tinytext ∪ time': 'tiny text',
+						'mediumtext ∪ bigintstr': 'medium text',
+						'mediumtext ∪ char': 'medium text',
+						'mediumtext ∪ decimal': 'medium text',
+						'mediumtext ∪ text': 'medium text',
+						'mediumtext ∪ tinytext': 'medium text',
+						'mediumtext ∪ mediumtext': 'medium text',
+						'mediumtext ∪ longtext': 'medium text',
+						'mediumtext ∪ varchar': 'medium text',
+						'mediumtext ∪ varbin': 'medium text',
+						'mediumtext ∪ stringblob': 'medium text',
+						'mediumtext ∪ stringtinyblob': 'medium text',
+						'mediumtext ∪ stringmediumblob': 'medium text',
+						'mediumtext ∪ stringlongblob': 'medium text',
+						'mediumtext ∪ datestr': 'medium text',
+						'mediumtext ∪ datetimestr': 'medium text',
+						'mediumtext ∪ timestampstr': 'medium text',
+						'mediumtext ∪ time': 'medium text',
+						'longtext ∪ bigintstr': 'long text',
+						'longtext ∪ char': 'long text',
+						'longtext ∪ decimal': 'long text',
+						'longtext ∪ text': 'long text',
+						'longtext ∪ tinytext': 'long text',
+						'longtext ∪ mediumtext': 'long text',
+						'longtext ∪ longtext': 'long text',
+						'longtext ∪ varchar': 'long text',
+						'longtext ∪ varbin': 'long text',
+						'longtext ∪ stringblob': 'long text',
+						'longtext ∪ stringtinyblob': 'long text',
+						'longtext ∪ stringmediumblob': 'long text',
+						'longtext ∪ stringlongblob': 'long text',
+						'longtext ∪ datestr': 'long text',
+						'longtext ∪ datetimestr': 'long text',
+						'longtext ∪ timestampstr': 'long text',
+						'longtext ∪ time': 'long text',
+						'varchar ∪ bigintstr': 'VCHAR',
+						'varchar ∪ char': 'VCHAR',
+						'varchar ∪ decimal': 'VCHAR',
+						'varchar ∪ text': 'VCHAR',
+						'varchar ∪ tinytext': 'VCHAR',
+						'varchar ∪ mediumtext': 'VCHAR',
+						'varchar ∪ longtext': 'VCHAR',
+						'varchar ∪ varchar': 'VCHAR',
+						'varchar ∪ varbin': 'VCHAR',
+						'varchar ∪ stringblob': 'VCHAR',
+						'varchar ∪ stringtinyblob': 'VCHAR',
+						'varchar ∪ stringmediumblob': 'VCHAR',
+						'varchar ∪ stringlongblob': 'VCHAR',
+						'varchar ∪ datestr': 'VCHAR',
+						'varchar ∪ datetimestr': 'VCHAR',
+						'varchar ∪ timestampstr': 'VCHAR',
+						'varchar ∪ time': 'VCHAR',
+						'varbin ∪ bigintstr': '1010110101001101',
+						'varbin ∪ char': '1010110101001101',
+						'varbin ∪ decimal': '1010110101001101',
+						'varbin ∪ text': '1010110101001101',
+						'varbin ∪ tinytext': '1010110101001101',
+						'varbin ∪ mediumtext': '1010110101001101',
+						'varbin ∪ longtext': '1010110101001101',
+						'varbin ∪ varchar': '1010110101001101',
+						'varbin ∪ varbin': '1010110101001101',
+						'varbin ∪ stringblob': '1010110101001101',
+						'varbin ∪ stringtinyblob': '1010110101001101',
+						'varbin ∪ stringmediumblob': '1010110101001101',
+						'varbin ∪ stringlongblob': '1010110101001101',
+						'varbin ∪ datestr': '1010110101001101',
+						'varbin ∪ datetimestr': '1010110101001101',
+						'varbin ∪ timestampstr': '1010110101001101',
+						'varbin ∪ time': '1010110101001101',
+						'stringblob ∪ bigintstr': 'string',
+						'stringblob ∪ char': 'string',
+						'stringblob ∪ decimal': 'string',
+						'stringblob ∪ text': 'string',
+						'stringblob ∪ tinytext': 'string',
+						'stringblob ∪ mediumtext': 'string',
+						'stringblob ∪ longtext': 'string',
+						'stringblob ∪ varchar': 'string',
+						'stringblob ∪ varbin': 'string',
+						'stringblob ∪ stringblob': 'string',
+						'stringblob ∪ stringtinyblob': 'string',
+						'stringblob ∪ stringmediumblob': 'string',
+						'stringblob ∪ stringlongblob': 'string',
+						'stringblob ∪ datestr': 'string',
+						'stringblob ∪ datetimestr': 'string',
+						'stringblob ∪ timestampstr': 'string',
+						'stringblob ∪ time': 'string',
+						'stringtinyblob ∪ bigintstr': 'string',
+						'stringtinyblob ∪ char': 'string',
+						'stringtinyblob ∪ decimal': 'string',
+						'stringtinyblob ∪ text': 'string',
+						'stringtinyblob ∪ tinytext': 'string',
+						'stringtinyblob ∪ mediumtext': 'string',
+						'stringtinyblob ∪ longtext': 'string',
+						'stringtinyblob ∪ varchar': 'string',
+						'stringtinyblob ∪ varbin': 'string',
+						'stringtinyblob ∪ stringblob': 'string',
+						'stringtinyblob ∪ stringtinyblob': 'string',
+						'stringtinyblob ∪ stringmediumblob': 'string',
+						'stringtinyblob ∪ stringlongblob': 'string',
+						'stringtinyblob ∪ datestr': 'string',
+						'stringtinyblob ∪ datetimestr': 'string',
+						'stringtinyblob ∪ timestampstr': 'string',
+						'stringtinyblob ∪ time': 'string',
+						'stringmediumblob ∪ bigintstr': 'string',
+						'stringmediumblob ∪ char': 'string',
+						'stringmediumblob ∪ decimal': 'string',
+						'stringmediumblob ∪ text': 'string',
+						'stringmediumblob ∪ tinytext': 'string',
+						'stringmediumblob ∪ mediumtext': 'string',
+						'stringmediumblob ∪ longtext': 'string',
+						'stringmediumblob ∪ varchar': 'string',
+						'stringmediumblob ∪ varbin': 'string',
+						'stringmediumblob ∪ stringblob': 'string',
+						'stringmediumblob ∪ stringtinyblob': 'string',
+						'stringmediumblob ∪ stringmediumblob': 'string',
+						'stringmediumblob ∪ stringlongblob': 'string',
+						'stringmediumblob ∪ datestr': 'string',
+						'stringmediumblob ∪ datetimestr': 'string',
+						'stringmediumblob ∪ timestampstr': 'string',
+						'stringmediumblob ∪ time': 'string',
+						'stringlongblob ∪ bigintstr': 'string',
+						'stringlongblob ∪ char': 'string',
+						'stringlongblob ∪ decimal': 'string',
+						'stringlongblob ∪ text': 'string',
+						'stringlongblob ∪ tinytext': 'string',
+						'stringlongblob ∪ mediumtext': 'string',
+						'stringlongblob ∪ longtext': 'string',
+						'stringlongblob ∪ varchar': 'string',
+						'stringlongblob ∪ varbin': 'string',
+						'stringlongblob ∪ stringblob': 'string',
+						'stringlongblob ∪ stringtinyblob': 'string',
+						'stringlongblob ∪ stringmediumblob': 'string',
+						'stringlongblob ∪ stringlongblob': 'string',
+						'stringlongblob ∪ datestr': 'string',
+						'stringlongblob ∪ datetimestr': 'string',
+						'stringlongblob ∪ timestampstr': 'string',
+						'stringlongblob ∪ time': 'string',
+						'datestr ∪ bigintstr': '2025-03-12',
+						'datestr ∪ char': '2025-03-12',
+						'datestr ∪ decimal': '2025-03-12',
+						'datestr ∪ text': '2025-03-12',
+						'datestr ∪ tinytext': '2025-03-12',
+						'datestr ∪ mediumtext': '2025-03-12',
+						'datestr ∪ longtext': '2025-03-12',
+						'datestr ∪ varchar': '2025-03-12',
+						'datestr ∪ varbin': '2025-03-12',
+						'datestr ∪ stringblob': '2025-03-12',
+						'datestr ∪ stringtinyblob': '2025-03-12',
+						'datestr ∪ stringmediumblob': '2025-03-12',
+						'datestr ∪ stringlongblob': '2025-03-12',
+						'datestr ∪ datestr': '2025-03-12',
+						'datestr ∪ datetimestr': '2025-03-12 00:00:00.000',
+						'datestr ∪ timestampstr': '2025-03-12 00:00:00.000',
+						'datetimestr ∪ bigintstr': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ char': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ decimal': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ text': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ tinytext': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ mediumtext': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ longtext': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ varchar': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ varbin': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ stringblob': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ datestr': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ bigintstr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ char': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ decimal': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ text': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ tinytext': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ mediumtext': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ longtext': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ varchar': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ varbin': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ stringblob': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ datestr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'time ∪ bigintstr': '04:13:22',
+						'time ∪ char': '04:13:22',
+						'time ∪ decimal': '04:13:22',
+						'time ∪ text': '04:13:22',
+						'time ∪ tinytext': '04:13:22',
+						'time ∪ mediumtext': '04:13:22',
+						'time ∪ longtext': '04:13:22',
+						'time ∪ varchar': '04:13:22',
+						'time ∪ varbin': '04:13:22',
+						'time ∪ stringblob': '04:13:22',
+						'time ∪ stringtinyblob': '04:13:22',
+						'time ∪ stringmediumblob': '04:13:22',
+						'time ∪ stringlongblob': '04:13:22',
+						'time ∪ time': '04:13:22',
+						'binary ∪ binary': '1',
+					},
+					{
+						'bigintstr ∪ bigintstr': '5044565289845416380',
+						'bigintstr ∪ char': 'c',
+						'bigintstr ∪ decimal': '47521',
+						'bigintstr ∪ text': 'C4-',
+						'bigintstr ∪ tinytext': 'tiny text',
+						'bigintstr ∪ mediumtext': 'medium text',
+						'bigintstr ∪ longtext': 'long text',
+						'bigintstr ∪ varchar': 'VCHAR',
+						'bigintstr ∪ varbin': '1010110101001101',
+						'bigintstr ∪ stringblob': 'string',
+						'bigintstr ∪ stringtinyblob': 'string',
+						'bigintstr ∪ stringmediumblob': 'string',
+						'bigintstr ∪ stringlongblob': 'string',
+						'bigintstr ∪ datestr': '2025-03-12',
+						'bigintstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'bigintstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'bigintstr ∪ time': '04:13:22',
+						'char ∪ bigintstr': '5044565289845416380',
+						'char ∪ char': 'c',
+						'char ∪ decimal': '47521',
+						'char ∪ text': 'C4-',
+						'char ∪ tinytext': 'tiny text',
+						'char ∪ mediumtext': 'medium text',
+						'char ∪ longtext': 'long text',
+						'char ∪ varchar': 'VCHAR',
+						'char ∪ varbin': '1010110101001101',
+						'char ∪ stringblob': 'string',
+						'char ∪ stringtinyblob': 'string',
+						'char ∪ stringmediumblob': 'string',
+						'char ∪ stringlongblob': 'string',
+						'char ∪ datestr': '2025-03-12',
+						'char ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'char ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'char ∪ time': '04:13:22',
+						'decimal ∪ bigintstr': '5044565289845416380',
+						'decimal ∪ char': 'c',
+						'decimal ∪ decimal': '47521',
+						'decimal ∪ text': 'C4-',
+						'decimal ∪ tinytext': 'tiny text',
+						'decimal ∪ mediumtext': 'medium text',
+						'decimal ∪ longtext': 'long text',
+						'decimal ∪ varchar': 'VCHAR',
+						'decimal ∪ varbin': '1010110101001101',
+						'decimal ∪ stringblob': 'string',
+						'decimal ∪ stringtinyblob': 'string',
+						'decimal ∪ stringmediumblob': 'string',
+						'decimal ∪ stringlongblob': 'string',
+						'decimal ∪ datestr': '2025-03-12',
+						'decimal ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'decimal ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'decimal ∪ time': '04:13:22',
+						'text ∪ bigintstr': '5044565289845416380',
+						'text ∪ char': 'c',
+						'text ∪ decimal': '47521',
+						'text ∪ text': 'C4-',
+						'text ∪ tinytext': 'tiny text',
+						'text ∪ mediumtext': 'medium text',
+						'text ∪ longtext': 'long text',
+						'text ∪ varchar': 'VCHAR',
+						'text ∪ varbin': '1010110101001101',
+						'text ∪ stringblob': 'string',
+						'text ∪ stringtinyblob': 'string',
+						'text ∪ stringmediumblob': 'string',
+						'text ∪ stringlongblob': 'string',
+						'text ∪ datestr': '2025-03-12',
+						'text ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'text ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'text ∪ time': '04:13:22',
+						'tinytext ∪ bigintstr': '5044565289845416380',
+						'tinytext ∪ char': 'c',
+						'tinytext ∪ decimal': '47521',
+						'tinytext ∪ text': 'C4-',
+						'tinytext ∪ tinytext': 'tiny text',
+						'tinytext ∪ mediumtext': 'medium text',
+						'tinytext ∪ longtext': 'long text',
+						'tinytext ∪ varchar': 'VCHAR',
+						'tinytext ∪ varbin': '1010110101001101',
+						'tinytext ∪ stringblob': 'string',
+						'tinytext ∪ stringtinyblob': 'string',
+						'tinytext ∪ stringmediumblob': 'string',
+						'tinytext ∪ stringlongblob': 'string',
+						'tinytext ∪ datestr': '2025-03-12',
+						'tinytext ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'tinytext ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'tinytext ∪ time': '04:13:22',
+						'mediumtext ∪ bigintstr': '5044565289845416380',
+						'mediumtext ∪ char': 'c',
+						'mediumtext ∪ decimal': '47521',
+						'mediumtext ∪ text': 'C4-',
+						'mediumtext ∪ tinytext': 'tiny text',
+						'mediumtext ∪ mediumtext': 'medium text',
+						'mediumtext ∪ longtext': 'long text',
+						'mediumtext ∪ varchar': 'VCHAR',
+						'mediumtext ∪ varbin': '1010110101001101',
+						'mediumtext ∪ stringblob': 'string',
+						'mediumtext ∪ stringtinyblob': 'string',
+						'mediumtext ∪ stringmediumblob': 'string',
+						'mediumtext ∪ stringlongblob': 'string',
+						'mediumtext ∪ datestr': '2025-03-12',
+						'mediumtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'mediumtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'mediumtext ∪ time': '04:13:22',
+						'longtext ∪ bigintstr': '5044565289845416380',
+						'longtext ∪ char': 'c',
+						'longtext ∪ decimal': '47521',
+						'longtext ∪ text': 'C4-',
+						'longtext ∪ tinytext': 'tiny text',
+						'longtext ∪ mediumtext': 'medium text',
+						'longtext ∪ longtext': 'long text',
+						'longtext ∪ varchar': 'VCHAR',
+						'longtext ∪ varbin': '1010110101001101',
+						'longtext ∪ stringblob': 'string',
+						'longtext ∪ stringtinyblob': 'string',
+						'longtext ∪ stringmediumblob': 'string',
+						'longtext ∪ stringlongblob': 'string',
+						'longtext ∪ datestr': '2025-03-12',
+						'longtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'longtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'longtext ∪ time': '04:13:22',
+						'varchar ∪ bigintstr': '5044565289845416380',
+						'varchar ∪ char': 'c',
+						'varchar ∪ decimal': '47521',
+						'varchar ∪ text': 'C4-',
+						'varchar ∪ tinytext': 'tiny text',
+						'varchar ∪ mediumtext': 'medium text',
+						'varchar ∪ longtext': 'long text',
+						'varchar ∪ varchar': 'VCHAR',
+						'varchar ∪ varbin': '1010110101001101',
+						'varchar ∪ stringblob': 'string',
+						'varchar ∪ stringtinyblob': 'string',
+						'varchar ∪ stringmediumblob': 'string',
+						'varchar ∪ stringlongblob': 'string',
+						'varchar ∪ datestr': '2025-03-12',
+						'varchar ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'varchar ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'varchar ∪ time': '04:13:22',
+						'varbin ∪ bigintstr': '5044565289845416380',
+						'varbin ∪ char': 'c',
+						'varbin ∪ decimal': '47521',
+						'varbin ∪ text': 'C4-',
+						'varbin ∪ tinytext': 'tiny text',
+						'varbin ∪ mediumtext': 'medium text',
+						'varbin ∪ longtext': 'long text',
+						'varbin ∪ varchar': 'VCHAR',
+						'varbin ∪ varbin': '1010110101001101',
+						'varbin ∪ stringblob': 'string',
+						'varbin ∪ stringtinyblob': 'string',
+						'varbin ∪ stringmediumblob': 'string',
+						'varbin ∪ stringlongblob': 'string',
+						'varbin ∪ datestr': '2025-03-12',
+						'varbin ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'varbin ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'varbin ∪ time': '04:13:22',
+						'stringblob ∪ bigintstr': '5044565289845416380',
+						'stringblob ∪ char': 'c',
+						'stringblob ∪ decimal': '47521',
+						'stringblob ∪ text': 'C4-',
+						'stringblob ∪ tinytext': 'tiny text',
+						'stringblob ∪ mediumtext': 'medium text',
+						'stringblob ∪ longtext': 'long text',
+						'stringblob ∪ varchar': 'VCHAR',
+						'stringblob ∪ varbin': '1010110101001101',
+						'stringblob ∪ stringblob': 'string',
+						'stringblob ∪ stringtinyblob': 'string',
+						'stringblob ∪ stringmediumblob': 'string',
+						'stringblob ∪ stringlongblob': 'string',
+						'stringblob ∪ datestr': '2025-03-12',
+						'stringblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'stringblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'stringblob ∪ time': '04:13:22',
+						'stringtinyblob ∪ bigintstr': '5044565289845416380',
+						'stringtinyblob ∪ char': 'c',
+						'stringtinyblob ∪ decimal': '47521',
+						'stringtinyblob ∪ text': 'C4-',
+						'stringtinyblob ∪ tinytext': 'tiny text',
+						'stringtinyblob ∪ mediumtext': 'medium text',
+						'stringtinyblob ∪ longtext': 'long text',
+						'stringtinyblob ∪ varchar': 'VCHAR',
+						'stringtinyblob ∪ varbin': '1010110101001101',
+						'stringtinyblob ∪ stringblob': 'string',
+						'stringtinyblob ∪ stringtinyblob': 'string',
+						'stringtinyblob ∪ stringmediumblob': 'string',
+						'stringtinyblob ∪ stringlongblob': 'string',
+						'stringtinyblob ∪ datestr': '2025-03-12',
+						'stringtinyblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'stringtinyblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'stringtinyblob ∪ time': '04:13:22',
+						'stringmediumblob ∪ bigintstr': '5044565289845416380',
+						'stringmediumblob ∪ char': 'c',
+						'stringmediumblob ∪ decimal': '47521',
+						'stringmediumblob ∪ text': 'C4-',
+						'stringmediumblob ∪ tinytext': 'tiny text',
+						'stringmediumblob ∪ mediumtext': 'medium text',
+						'stringmediumblob ∪ longtext': 'long text',
+						'stringmediumblob ∪ varchar': 'VCHAR',
+						'stringmediumblob ∪ varbin': '1010110101001101',
+						'stringmediumblob ∪ stringblob': 'string',
+						'stringmediumblob ∪ stringtinyblob': 'string',
+						'stringmediumblob ∪ stringmediumblob': 'string',
+						'stringmediumblob ∪ stringlongblob': 'string',
+						'stringmediumblob ∪ datestr': '2025-03-12',
+						'stringmediumblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'stringmediumblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'stringmediumblob ∪ time': '04:13:22',
+						'stringlongblob ∪ bigintstr': '5044565289845416380',
+						'stringlongblob ∪ char': 'c',
+						'stringlongblob ∪ decimal': '47521',
+						'stringlongblob ∪ text': 'C4-',
+						'stringlongblob ∪ tinytext': 'tiny text',
+						'stringlongblob ∪ mediumtext': 'medium text',
+						'stringlongblob ∪ longtext': 'long text',
+						'stringlongblob ∪ varchar': 'VCHAR',
+						'stringlongblob ∪ varbin': '1010110101001101',
+						'stringlongblob ∪ stringblob': 'string',
+						'stringlongblob ∪ stringtinyblob': 'string',
+						'stringlongblob ∪ stringmediumblob': 'string',
+						'stringlongblob ∪ stringlongblob': 'string',
+						'stringlongblob ∪ datestr': '2025-03-12',
+						'stringlongblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'stringlongblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'stringlongblob ∪ time': '04:13:22',
+						'datestr ∪ bigintstr': '5044565289845416380',
+						'datestr ∪ char': 'c',
+						'datestr ∪ decimal': '47521',
+						'datestr ∪ text': 'C4-',
+						'datestr ∪ tinytext': 'tiny text',
+						'datestr ∪ mediumtext': 'medium text',
+						'datestr ∪ longtext': 'long text',
+						'datestr ∪ varchar': 'VCHAR',
+						'datestr ∪ varbin': '1010110101001101',
+						'datestr ∪ stringblob': 'string',
+						'datestr ∪ stringtinyblob': 'string',
+						'datestr ∪ stringmediumblob': 'string',
+						'datestr ∪ stringlongblob': 'string',
+						'datestr ∪ datestr': '2025-03-12',
+						'datestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'datestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ bigintstr': '5044565289845416380',
+						'datetimestr ∪ char': 'c',
+						'datetimestr ∪ decimal': '47521',
+						'datetimestr ∪ text': 'C4-',
+						'datetimestr ∪ tinytext': 'tiny text',
+						'datetimestr ∪ mediumtext': 'medium text',
+						'datetimestr ∪ longtext': 'long text',
+						'datetimestr ∪ varchar': 'VCHAR',
+						'datetimestr ∪ varbin': '1010110101001101',
+						'datetimestr ∪ stringblob': 'string',
+						'datetimestr ∪ stringtinyblob': 'string',
+						'datetimestr ∪ stringmediumblob': 'string',
+						'datetimestr ∪ stringlongblob': 'string',
+						'datetimestr ∪ datestr': '2025-03-12 00:00:00.000',
+						'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ bigintstr': '5044565289845416380',
+						'timestampstr ∪ char': 'c',
+						'timestampstr ∪ decimal': '47521',
+						'timestampstr ∪ text': 'C4-',
+						'timestampstr ∪ tinytext': 'tiny text',
+						'timestampstr ∪ mediumtext': 'medium text',
+						'timestampstr ∪ longtext': 'long text',
+						'timestampstr ∪ varchar': 'VCHAR',
+						'timestampstr ∪ varbin': '1010110101001101',
+						'timestampstr ∪ stringblob': 'string',
+						'timestampstr ∪ stringtinyblob': 'string',
+						'timestampstr ∪ stringmediumblob': 'string',
+						'timestampstr ∪ stringlongblob': 'string',
+						'timestampstr ∪ datestr': '2025-03-12 00:00:00.000',
+						'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+						'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+						'time ∪ bigintstr': '5044565289845416380',
+						'time ∪ char': 'c',
+						'time ∪ decimal': '47521',
+						'time ∪ text': 'C4-',
+						'time ∪ tinytext': 'tiny text',
+						'time ∪ mediumtext': 'medium text',
+						'time ∪ longtext': 'long text',
+						'time ∪ varchar': 'VCHAR',
+						'time ∪ varbin': '1010110101001101',
+						'time ∪ stringblob': 'string',
+						'time ∪ stringtinyblob': 'string',
+						'time ∪ stringmediumblob': 'string',
+						'time ∪ stringlongblob': 'string',
+						'time ∪ time': '04:13:22',
+						'binary ∪ binary': '1',
+					},
+				]));
+
+				// ---- bigint ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+							'bigint64 ∪ decimalbig': allTypesCodecsTable.bigint64.as('bigint64 ∪ decimalbig'),
+							'decimalbig ∪ bigint64': allTypesCodecsTable.decimalbig.as('decimalbig ∪ bigint64'),
+							'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+							'bigint64 ∪ decimalbig': allTypesCodecsTable.decimalbig.as('bigint64 ∪ decimalbig'),
+							'decimalbig ∪ bigint64': allTypesCodecsTable.bigint64.as('decimalbig ∪ bigint64'),
+							'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'bigint64 ∪ bigint64': 5044565289845416380n,
+						'bigint64 ∪ decimalbig': 5044565289845416380n,
+						'decimalbig ∪ bigint64': 5044565289845416380n,
+						'decimalbig ∪ decimalbig': 5044565289845416380n,
+					},
+					{
+						'bigint64 ∪ bigint64': 5044565289845416380n,
+						'bigint64 ∪ decimalbig': 5044565289845416380n,
+						'decimalbig ∪ bigint64': 5044565289845416380n,
+						'decimalbig ∪ decimalbig': 5044565289845416380n,
+					},
+				]));
+
+				// ---- boolean ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'boolean ∪ boolean': true,
+					},
+					{
+						'boolean ∪ boolean': true,
+					},
+				]));
+
+				// ---- date ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+							'date ∪ datetime': allTypesCodecsTable.date.as('date ∪ datetime'),
+							'date ∪ timestamp': allTypesCodecsTable.date.as('date ∪ timestamp'),
+							'datetime ∪ date': allTypesCodecsTable.datetime.as('datetime ∪ date'),
+							'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+							'datetime ∪ timestamp': allTypesCodecsTable.datetime.as('datetime ∪ timestamp'),
+							'timestamp ∪ date': allTypesCodecsTable.timestamp.as('timestamp ∪ date'),
+							'timestamp ∪ datetime': allTypesCodecsTable.timestamp.as('timestamp ∪ datetime'),
+							'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+							'date ∪ datetime': allTypesCodecsTable.datetime.as('date ∪ datetime'),
+							'date ∪ timestamp': allTypesCodecsTable.timestamp.as('date ∪ timestamp'),
+							'datetime ∪ date': allTypesCodecsTable.date.as('datetime ∪ date'),
+							'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+							'datetime ∪ timestamp': allTypesCodecsTable.timestamp.as('datetime ∪ timestamp'),
+							'timestamp ∪ date': allTypesCodecsTable.date.as('timestamp ∪ date'),
+							'timestamp ∪ datetime': allTypesCodecsTable.datetime.as('timestamp ∪ datetime'),
+							'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'date ∪ date': new Date('2025-03-12'),
+						'date ∪ datetime': new Date('2025-03-12'),
+						'date ∪ timestamp': new Date('2025-03-12'),
+						'datetime ∪ date': new Date(1741743161623),
+						'datetime ∪ datetime': new Date(1741743161623),
+						'datetime ∪ timestamp': new Date(1741743161623),
+						'timestamp ∪ date': new Date(1741743161623),
+						'timestamp ∪ datetime': new Date(1741743161623),
+						'timestamp ∪ timestamp': new Date(1741743161623),
+					},
+					{
+						'date ∪ date': new Date('2025-03-12'),
+						'date ∪ datetime': new Date(1741743161623),
+						'date ∪ timestamp': new Date(1741743161623),
+						'datetime ∪ date': new Date('2025-03-12'),
+						'datetime ∪ datetime': new Date(1741743161623),
+						'datetime ∪ timestamp': new Date(1741743161623),
+						'timestamp ∪ date': new Date('2025-03-12'),
+						'timestamp ∪ datetime': new Date(1741743161623),
+						'timestamp ∪ timestamp': new Date(1741743161623),
+					},
+				]));
+
+				// ---- buffer ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+							'blob ∪ tinyblob': allTypesCodecsTable.blob.as('blob ∪ tinyblob'),
+							'blob ∪ mediumblob': allTypesCodecsTable.blob.as('blob ∪ mediumblob'),
+							'blob ∪ longblob': allTypesCodecsTable.blob.as('blob ∪ longblob'),
+							'tinyblob ∪ blob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ blob'),
+							'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+							'tinyblob ∪ mediumblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ mediumblob'),
+							'tinyblob ∪ longblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ longblob'),
+							'mediumblob ∪ blob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ blob'),
+							'mediumblob ∪ tinyblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ tinyblob'),
+							'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+							'mediumblob ∪ longblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ longblob'),
+							'longblob ∪ blob': allTypesCodecsTable.longblob.as('longblob ∪ blob'),
+							'longblob ∪ tinyblob': allTypesCodecsTable.longblob.as('longblob ∪ tinyblob'),
+							'longblob ∪ mediumblob': allTypesCodecsTable.longblob.as('longblob ∪ mediumblob'),
+							'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+							'blob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('blob ∪ tinyblob'),
+							'blob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('blob ∪ mediumblob'),
+							'blob ∪ longblob': allTypesCodecsTable.longblob.as('blob ∪ longblob'),
+							'tinyblob ∪ blob': allTypesCodecsTable.blob.as('tinyblob ∪ blob'),
+							'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+							'tinyblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('tinyblob ∪ mediumblob'),
+							'tinyblob ∪ longblob': allTypesCodecsTable.longblob.as('tinyblob ∪ longblob'),
+							'mediumblob ∪ blob': allTypesCodecsTable.blob.as('mediumblob ∪ blob'),
+							'mediumblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('mediumblob ∪ tinyblob'),
+							'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+							'mediumblob ∪ longblob': allTypesCodecsTable.longblob.as('mediumblob ∪ longblob'),
+							'longblob ∪ blob': allTypesCodecsTable.blob.as('longblob ∪ blob'),
+							'longblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('longblob ∪ tinyblob'),
+							'longblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('longblob ∪ mediumblob'),
+							'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'blob ∪ blob': Buffer.from('string'),
+						'blob ∪ tinyblob': Buffer.from('string'),
+						'blob ∪ mediumblob': Buffer.from('string'),
+						'blob ∪ longblob': Buffer.from('string'),
+						'tinyblob ∪ blob': Buffer.from('string'),
+						'tinyblob ∪ tinyblob': Buffer.from('string'),
+						'tinyblob ∪ mediumblob': Buffer.from('string'),
+						'tinyblob ∪ longblob': Buffer.from('string'),
+						'mediumblob ∪ blob': Buffer.from('string'),
+						'mediumblob ∪ tinyblob': Buffer.from('string'),
+						'mediumblob ∪ mediumblob': Buffer.from('string'),
+						'mediumblob ∪ longblob': Buffer.from('string'),
+						'longblob ∪ blob': Buffer.from('string'),
+						'longblob ∪ tinyblob': Buffer.from('string'),
+						'longblob ∪ mediumblob': Buffer.from('string'),
+						'longblob ∪ longblob': Buffer.from('string'),
+					},
+					{
+						'blob ∪ blob': Buffer.from('string'),
+						'blob ∪ tinyblob': Buffer.from('string'),
+						'blob ∪ mediumblob': Buffer.from('string'),
+						'blob ∪ longblob': Buffer.from('string'),
+						'tinyblob ∪ blob': Buffer.from('string'),
+						'tinyblob ∪ tinyblob': Buffer.from('string'),
+						'tinyblob ∪ mediumblob': Buffer.from('string'),
+						'tinyblob ∪ longblob': Buffer.from('string'),
+						'mediumblob ∪ blob': Buffer.from('string'),
+						'mediumblob ∪ tinyblob': Buffer.from('string'),
+						'mediumblob ∪ mediumblob': Buffer.from('string'),
+						'mediumblob ∪ longblob': Buffer.from('string'),
+						'longblob ∪ blob': Buffer.from('string'),
+						'longblob ∪ tinyblob': Buffer.from('string'),
+						'longblob ∪ mediumblob': Buffer.from('string'),
+						'longblob ∪ longblob': Buffer.from('string'),
+					},
+				]));
+
+				// ---- enum ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'enum ∪ enum': 'enV1',
+					},
+					{
+						'enum ∪ enum': 'enV1',
+					},
+				]));
+
+				// ---- json ----
+				expect(
+					yield* unionAll(
+						db.select({
+							'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+							'json1 ∪ json2': allTypesCodecsTable.json1.as('json1 ∪ json2'),
+							'json1 ∪ json3': allTypesCodecsTable.json1.as('json1 ∪ json3'),
+							'json1 ∪ json4': allTypesCodecsTable.json1.as('json1 ∪ json4'),
+							'json2 ∪ json1': allTypesCodecsTable.json2.as('json2 ∪ json1'),
+							'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+							'json2 ∪ json3': allTypesCodecsTable.json2.as('json2 ∪ json3'),
+							'json2 ∪ json4': allTypesCodecsTable.json2.as('json2 ∪ json4'),
+							'json3 ∪ json1': allTypesCodecsTable.json3.as('json3 ∪ json1'),
+							'json3 ∪ json2': allTypesCodecsTable.json3.as('json3 ∪ json2'),
+							'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+							'json3 ∪ json4': allTypesCodecsTable.json3.as('json3 ∪ json4'),
+							'json4 ∪ json1': allTypesCodecsTable.json4.as('json4 ∪ json1'),
+							'json4 ∪ json2': allTypesCodecsTable.json4.as('json4 ∪ json2'),
+							'json4 ∪ json3': allTypesCodecsTable.json4.as('json4 ∪ json3'),
+							'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+						}).from(allTypesCodecsTable),
+						db.select({
+							'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+							'json1 ∪ json2': allTypesCodecsTable.json2.as('json1 ∪ json2'),
+							'json1 ∪ json3': allTypesCodecsTable.json3.as('json1 ∪ json3'),
+							'json1 ∪ json4': allTypesCodecsTable.json4.as('json1 ∪ json4'),
+							'json2 ∪ json1': allTypesCodecsTable.json1.as('json2 ∪ json1'),
+							'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+							'json2 ∪ json3': allTypesCodecsTable.json3.as('json2 ∪ json3'),
+							'json2 ∪ json4': allTypesCodecsTable.json4.as('json2 ∪ json4'),
+							'json3 ∪ json1': allTypesCodecsTable.json1.as('json3 ∪ json1'),
+							'json3 ∪ json2': allTypesCodecsTable.json2.as('json3 ∪ json2'),
+							'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+							'json3 ∪ json4': allTypesCodecsTable.json4.as('json3 ∪ json4'),
+							'json4 ∪ json1': allTypesCodecsTable.json1.as('json4 ∪ json1'),
+							'json4 ∪ json2': allTypesCodecsTable.json2.as('json4 ∪ json2'),
+							'json4 ∪ json3': allTypesCodecsTable.json3.as('json4 ∪ json3'),
+							'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+						}).from(allTypesCodecsTable),
+					),
+				).toEqual(expect.arrayContaining([
+					{
+						'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+						'json1 ∪ json2': { str: 'strval', arr: ['str', 10] },
+						'json1 ∪ json3': { str: 'strval', arr: ['str', 10] },
+						'json1 ∪ json4': { str: 'strval', arr: ['str', 10] },
+						'json2 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json2 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json2 ∪ json4': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json3 ∪ json1': 5,
+						'json3 ∪ json2': 5,
+						'json3 ∪ json3': 5,
+						'json3 ∪ json4': 5,
+						'json4 ∪ json1': '5',
+						'json4 ∪ json2': '5',
+						'json4 ∪ json3': '5',
+						'json4 ∪ json4': '5',
+					},
+					{
+						'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+						'json1 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json1 ∪ json3': 5,
+						'json1 ∪ json4': '5',
+						'json2 ∪ json1': { str: 'strval', arr: ['str', 10] },
+						'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json2 ∪ json3': 5,
+						'json2 ∪ json4': '5',
+						'json3 ∪ json1': { str: 'strval', arr: ['str', 10] },
+						'json3 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json3 ∪ json3': 5,
+						'json3 ∪ json4': '5',
+						'json4 ∪ json1': { str: 'strval', arr: ['str', 10] },
+						'json4 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+						'json4 ∪ json3': 5,
+						'json4 ∪ json4': '5',
+					},
+				]));
+			}));
+
+		it.effect('RQB v2 simple find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 simple find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 simple find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbPost.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst();
+
+						expect(result).toStrictEqual(undefined);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 transaction find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							with: {
+								posts: {
+									orderBy: {
+										id: 'asc',
+									},
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 1,
+							createdAt: date,
+							name: 'First',
+							posts: [{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+							}, {
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+							}],
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findFirst({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany();
+
+						expect(result).toStrictEqual([]);
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 transaction find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}, {
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbPost.findMany({
+							with: {
+								author: true,
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}, {
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findMany({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}]);
+
+						return result;
+					})
+				);
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = mysqlTable('users_transactions', {
+					id: serial('id').primaryKey(),
+					balance: int('balance').notNull(),
+				});
+				const products = mysqlTable('products_transactions', {
+					id: serial('id').primaryKey(),
+					price: int('price').notNull(),
+					stock: int('stock').notNull(),
+				});
+
+				yield* push(db, { users, products });
+
+				const [userId] = yield* db.insert(users).values({ balance: 100 }).$returningId();
+				const [productId] = yield* db.insert(products).values({ price: 10, stock: 10 }).$returningId();
+
+				const [user] = yield* db.select().from(users).where(eq(users.id, userId!.id));
+				const [product] = yield* db.select().from(products).where(eq(products.id, productId!.id));
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.update(users).set({ balance: user!.balance - product!.price }).where(eq(users.id, user!.id));
+						yield* tx.update(products).set({ stock: product!.stock - 1 }).where(eq(products.id, product!.id));
+
+						// Regardless if `db` or `tx` is used, every query within the transaction effect is completed in transaction
+						const nonTxRes = yield* db.select().from(users);
+						expect(nonTxRes).toStrictEqual([{ id: 1, balance: 90 }]);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 90 }]);
+			}));
+
+		it.effect('transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = mysqlTable('users_transactions_rollback', {
+					id: serial('id').primaryKey(),
+					balance: int('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				const res = yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+						yield* tx.rollback();
+					})
+				).pipe(Effect.result);
+
+				assert(Result.isFailure(res));
+				assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([]);
+			}));
+
+		it.effect('nested transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = mysqlTable('users_nested_transactions', {
+					id: serial('id').primaryKey(),
+					balance: int('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+							})
+						);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 200 }]);
+			}));
+
+		it.effect('nested transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = mysqlTable('users_nested_transactions_rollback', {
+					id: serial('id').primaryKey(),
+					balance: int('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						const res = yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+								yield* tx.rollback();
+							})
+						).pipe(Effect.result);
+
+						assert(Result.isFailure(res));
+						assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 100 }]);
+			}));
+
+		it.effect('mySchema :: view', () =>
+			Effect.gen(function*() {
+				const mySchema = mysqlSchema(`my_schema_custom`);
+
+				const users = mySchema.table('users_100', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int('city_id').notNull(),
+				});
+
+				const cities = mySchema.table('cities_100', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				// Kit's push doesn't support schemas, create manually
+				yield* db.execute('drop schema if exists `my_schema_custom`;');
+				yield* db.execute('create schema `my_schema_custom`;');
+				yield* db.execute(
+					'create table `my_schema_custom`.`users_100` (`id` serial AUTO_INCREMENT PRIMARY KEY NOT NULL, `name` text NOT NULL, `city_id` int NOT NULL);',
+				);
+				yield* db.execute(
+					'create table `my_schema_custom`.`cities_100` (`id` serial AUTO_INCREMENT PRIMARY KEY NOT NULL, `name` text NOT NULL);',
+				);
+
+				const newYorkers1 = mySchema.view('new_yorkers')
+					.as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+				const newYorkers2 = mySchema.view('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int('city_id').notNull(),
+				}).as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+
+				const newYorkers3 = mySchema.view('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int('city_id').notNull(),
+				}).existing();
+
+				yield* db.execute(
+					sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`,
+				);
+
+				yield* db.insert(cities).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+				yield* db.insert(users).values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				]);
+
+				{
+					const result = yield* db.select().from(newYorkers1);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select().from(newYorkers2);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select().from(newYorkers3);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select({ name: newYorkers1.name }).from(newYorkers1);
+					expect(result).toEqual([
+						{ name: 'John' },
+						{ name: 'Jane' },
+					]);
+				}
+			}));
+
+		it.effect('insert into ... select', () =>
+			Effect.gen(function*() {
+				const notifications = mysqlTable('notifications_31', {
+					id: int('id').primaryKey().autoincrement(),
+					sentAt: timestamp('sent_at').notNull().defaultNow(),
+					message: text('message').notNull(),
+				});
+				const users = mysqlTable('users_31', {
+					id: int('id').primaryKey().autoincrement(),
+					name: text('name').notNull(),
+				});
+				const userNotications = mysqlTable('user_notifications_31', {
+					userId: int('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: int('notification_id').notNull().references(() => notifications.id, {
+						onDelete: 'cascade',
+					}),
+				}, (t) => [primaryKey({ columns: [t.userId, t.notificationId] })]);
+
+				const db = yield* DB;
+
+				yield* push(db, { notifications, users, userNotications });
+
+				yield* db
+					.insert(notifications)
+					.values({ message: 'You are one of the 3 lucky winners!' });
+				const newNotification = (yield* db
+					.select({ id: notifications.id })
+					.from(notifications))[0]!;
+
+				yield* db.insert(users).values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+				yield* db
+					.insert(userNotications)
+					.select(
+						db
+							.select({
+								userId: users.id,
+								notificationId: sql`(${newNotification!.id})`.as('notification_id'),
+							})
+							.from(users)
+							.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+							.orderBy(asc(users.id)),
+					);
+				const sentNotifications = yield* db.select().from(userNotications);
+
+				expect(sentNotifications).toStrictEqual([
+					{ userId: 1, notificationId: newNotification!.id },
+					{ userId: 3, notificationId: newNotification!.id },
+					{ userId: 5, notificationId: newNotification!.id },
+				]);
+			}));
+
+		it.effect('$count separate', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_33', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable);
+
+				expect(count).toStrictEqual(4);
+			}));
+
+		it.effect('$count embedded', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_34', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+			}));
+
+		it.effect('$count separate reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_35', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.$count(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual(4);
+				expect(count2).toStrictEqual(5);
+				expect(count3).toStrictEqual(6);
+			}));
+
+		it.effect('$count embedded reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_36', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+				expect(count2).toStrictEqual([
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+				]);
+				expect(count3).toStrictEqual([
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+				]);
+			}));
+
+		it.effect('$count separate with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_37', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable, gt(countTestTable.id, 1));
+				expect(count).toStrictEqual(3);
+			}));
+
+		it.effect('$count embedded with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = mysqlTable('count_test_38', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+				]);
+			}));
+
+		it.effect('select distinct', () =>
+			Effect.gen(function*() {
+				const usersDistinctTable = mysqlTable('users_distinct_101', {
+					id: int('id').notNull(),
+					name: text('name').notNull(),
+					age: int('age').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersDistinctTable });
+
+				yield* db.insert(usersDistinctTable).values([
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+				]);
+				const users1 = yield* db.selectDistinct().from(usersDistinctTable).orderBy(
+					usersDistinctTable.id,
+					usersDistinctTable.name,
+				);
+
+				expect(users1).toEqual([
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+				]);
+			}));
+
+		it.effect('update with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_9', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: json('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at').notNull().defaultNow(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'));
+				const usersResult = yield* db.select().from(users);
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(1000);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('update with returning partial', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_10', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'));
+				const usersResult = yield* db.select({
+					id: users.id,
+					name: users.name,
+				}).from(users);
+
+				expect(usersResult).toEqual([{ id: 1, name: 'Jane' }]);
+			}));
+
+		it.effect('delete with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_11', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: json('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at').notNull().defaultNow(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.select().from(users);
+				yield* db.delete(users).where(eq(users.name, 'John'));
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(1000);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+
+				const afterDelete = yield* db.select().from(users);
+				expect(afterDelete).toEqual([]);
+			}));
+
+		it.effect('delete with returning partial', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_12', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.select({
+					id: users.id,
+					name: users.name,
+				}).from(users);
+				yield* db.delete(users).where(eq(users.name, 'John'));
+
+				expect(usersResult).toEqual([{ id: 1, name: 'John' }]);
+
+				const afterDelete = yield* db.select().from(users);
+				expect(afterDelete).toEqual([]);
+			}));
+
+		it.effect('insert many', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_19', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: json('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning partial', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_20', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: json('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_20', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: json('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement reuse', () =>
+			Effect.gen(function*() {
+				const usersTable = mysqlTable('users_35', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						verified: true,
+						name: sql.placeholder('name'),
+					})
+					.prepare();
+
+				for (let i = 0; i < 10; i++) {
+					yield* stmt.execute({ name: `John ${i}` });
+				}
+
+				const result = yield* db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+						verified: usersTable.verified,
+					})
+					.from(usersTable);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John 0', verified: true },
+					{ id: 2, name: 'John 1', verified: true },
+					{ id: 3, name: 'John 2', verified: true },
+					{ id: 4, name: 'John 3', verified: true },
+					{ id: 5, name: 'John 4', verified: true },
+					{ id: 6, name: 'John 5', verified: true },
+					{ id: 7, name: 'John 6', verified: true },
+					{ id: 8, name: 'John 7', verified: true },
+					{ id: 9, name: 'John 8', verified: true },
+					{ id: 10, name: 'John 9', verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement with placeholder in .where', () =>
+			Effect.gen(function*() {
+				const usersTable = mysqlTable('users_36', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.prepare();
+				const result = yield* stmt.execute({ id: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('prepared statement with placeholder in .limit', () =>
+			Effect.gen(function*() {
+				const usersTable = mysqlTable('users_37', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ id: 1, limit: '1' });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('prepared statement with placeholder in .offset', () =>
+			Effect.gen(function*() {
+				const usersTable = mysqlTable('users_38', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.offset(sql.placeholder('offset'))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ offset: '1', limit: '1' });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			}));
+
+		it.effect('prepared statement built using $dynamic', () =>
+			Effect.gen(function*() {
+				const usersTable = mysqlTable('users_39', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				function withLimitOffset(qb: any) {
+					return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+				}
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.$dynamic();
+				withLimitOffset(stmt).prepare();
+
+				const result = yield* stmt.execute({ limit: '1', offset: '1' });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('with ... select', () =>
+			Effect.gen(function*() {
+				const orders = mysqlTable('orders_55', {
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: int('amount').notNull(),
+					quantity: int('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const regionalSales = db
+					.$with('regional_sales')
+					.as(
+						db
+							.select({
+								region: orders.region,
+								totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+							})
+							.from(orders)
+							.groupBy(orders.region),
+					);
+
+				const topRegions = db
+					.$with('top_regions')
+					.as(
+						db
+							.select({
+								region: regionalSales.region,
+							})
+							.from(regionalSales)
+							.where(
+								gt(
+									regionalSales.totalSales,
+									db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+								),
+							),
+					);
+
+				const result1 = yield* db
+					.with(regionalSales, topRegions)
+					.select({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+						productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result2 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+						productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result3 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+						productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region)
+					.orderBy(orders.region);
+
+				expect(result1).toEqual([
+					{
+						region: 'Europe',
+						product: 'A',
+						productUnits: 3,
+						productSales: 30,
+					},
+					{
+						region: 'Europe',
+						product: 'B',
+						productUnits: 5,
+						productSales: 50,
+					},
+					{
+						region: 'US',
+						product: 'A',
+						productUnits: 7,
+						productSales: 70,
+					},
+					{
+						region: 'US',
+						product: 'B',
+						productUnits: 9,
+						productSales: 90,
+					},
+				]);
+				expect(result2).toEqual(result1);
+				expect(result3).toEqual([
+					{
+						region: 'Europe',
+						productUnits: 8,
+						productSales: 80,
+					},
+					{
+						region: 'US',
+						productUnits: 16,
+						productSales: 160,
+					},
+				]);
+			}));
+
+		it.effect('with ... update', () =>
+			Effect.gen(function*() {
+				const products = mysqlTable('products_56', {
+					id: serial('id').primaryKey(),
+					price: decimal('price', {
+						precision: 15,
+						scale: 2,
+					}).notNull(),
+					cheap: boolean('cheap').notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { products });
+
+				yield* db.insert(products).values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
+
+				const averagePrice = db
+					.$with('average_price')
+					.as(
+						db
+							.select({
+								value: sql`avg(${products.price})`.as('value'),
+							})
+							.from(products),
+					);
+
+				yield* db
+					.with(averagePrice)
+					.update(products)
+					.set({
+						cheap: true,
+					})
+					.where(lt(products.price, sql`(select * from ${averagePrice})`));
+
+				const result = yield* db
+					.select({
+						id: products.id,
+					})
+					.from(products)
+					.where(eq(products.cheap, true));
+
+				expect(result).toEqual([
+					{ id: 1 },
+					{ id: 4 },
+					{ id: 5 },
+				]);
+			}));
+
+		it.effect('with ... delete', () =>
+			Effect.gen(function*() {
+				const orders = mysqlTable('orders_58', {
+					id: serial('id').primaryKey(),
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: int('amount').notNull(),
+					quantity: int('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const averageAmount = db
+					.$with('average_amount')
+					.as(
+						db
+							.select({
+								value: sql`avg(${orders.amount})`.as('value'),
+							})
+							.from(orders),
+					);
+
+				yield* db
+					.with(averageAmount)
+					.delete(orders)
+					.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
+
+				const result = yield* db
+					.select({
+						id: orders.id,
+					})
+					.from(orders);
+
+				expect(result).toEqual([
+					{ id: 1 },
+					{ id: 2 },
+					{ id: 3 },
+					{ id: 4 },
+					{ id: 5 },
+				]);
+			}));
+
+		it.effect('partial join with alias', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('users_29', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customerAlias = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user: {
+							id: users.id,
+							name: users.name,
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			}));
+
+		it.effect('full join with alias', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('prefixed_users_30', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(users)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([{
+					prefixed_users_30: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('select from alias', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('prefixed_users_31', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const user = alias(users, 'user');
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(user)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(user.id, 10));
+
+				expect(result).toEqual([{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('set operations (mixed) from query builder with subquery', () =>
+			Effect.gen(function*() {
+				const cities2Table = mysqlTable('cities_1', {
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = mysqlTable('users2_1', {
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const sq = db
+					.select()
+					.from(cities2Table).where(gt(cities2Table.id, 1)).as('sq');
+
+				const result = yield* db
+					.select()
+					.from(cities2Table).except(
+						({ unionAll }) =>
+							unionAll(
+								db.select().from(sq),
+								db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+							),
+					);
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* db
+						.select()
+						.from(cities2Table).except(
+							({ unionAll }) =>
+								unionAll(
+									db
+										.select({ name: cities2Table.name, id: cities2Table.id })
+										.from(cities2Table).where(gt(cities2Table.id, 1)),
+									db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+								),
+						);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('set operations (mixed all) as function', () =>
+			Effect.gen(function*() {
+				const cities2Table = mysqlTable('cities_2', {
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = mysqlTable('users2_2', {
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: int('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const result = yield* union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 7)),
+					),
+					db
+						.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+				).orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(6);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+					{ id: 8, name: 'Sally' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table).where(gte(users2Table.id, 5)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table).where(eq(users2Table.id, 7)),
+						),
+						db
+							.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+					);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('custom EffectLogger override - user provided logger takes precedence over default', () =>
+			Effect.gen(function*() {
+				const loggedQueries: Array<{ query: string; params: unknown[] }> = [];
+
+				const customLogger: EffectLoggerShape = {
+					logQuery: (query: string, params: unknown[]) =>
+						Effect.sync(() => {
+							loggedQueries.push({ query, params });
+						}),
+				};
+				const customLoggerLayer = Layer.succeed(EffectLogger, customLogger);
+
+				const db = yield* MySqlDrizzle.make({ relations }).pipe(
+					Effect.provide(customLoggerLayer),
+					Effect.provide(MySqlDrizzle.DefaultServices),
+				);
+
+				const users = mysqlTable('users_custom_logger', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users);
+
+				expect(loggedQueries.length).toBeGreaterThanOrEqual(2);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('insert'))).toBe(true);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('select'))).toBe(true);
+			}));
+
+		it.effect('custom EffectCache override - user provided cache takes precedence over default', () =>
+			Effect.gen(function*() {
+				const cacheOperations = yield* Ref.make<Array<{ op: 'get' | 'put' | 'mutate'; key?: string }>>([]);
+
+				const customCacheService: EffectCacheShape = {
+					strategy: () => 'all' as const,
+					get: (key: string, _tables: string[], _isTag: boolean, _isAutoInvalidate?: boolean) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'get' as const, key }]);
+							// oxlint-disable-next-line no-useless-undefined
+							return undefined;
+						}),
+					put: (key: string, _response: any, _tables: string[], _isTag: boolean, _config?: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'put' as const, key }]);
+						}),
+					onMutate: (_params: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'mutate' as const }]);
+						}),
+				};
+				const customCacheLayer = Layer.succeed(EffectCache, customCacheService);
+
+				const db = yield* MySqlDrizzle.make({ relations }).pipe(
+					Effect.provide(customCacheLayer),
+					Effect.provide(MySqlDrizzle.DefaultServices),
+				);
+
+				const users = mysqlTable('users_custom_cache', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users).$withCache();
+
+				const ops = yield* Ref.get(cacheOperations);
+				expect(ops.some((o) => o.op === 'mutate')).toBe(true);
+				expect(ops.some((o) => o.op === 'get')).toBe(true);
+			}));
+
+		it.effect('makeWithDefaults - convenience function that includes DefaultServices', () =>
+			Effect.gen(function*() {
+				const db = yield* MySqlDrizzle.makeWithDefaults({ relations });
+
+				const users = mysqlTable('users_make_with_defaults', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'Alice' });
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, name: 'Alice' }]);
+			}));
+
+		it.effect('Mappers: correct mappers enabled', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const jitDb = yield* createDB({}, () => ({}), true);
+
+				const dialect: MySqlDialect = (<any> db).dialect;
+				const jitDialect: MySqlDialect = (<any> jitDb).dialect;
+
+				expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+				expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+			}));
+
+		const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+		it.effect('Mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_1', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_2', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_3', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Mappers: insert $returningId + select', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_4', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+				const selected = yield* db.select().from(users);
+
+				yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2));
+
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+			}));
+
+		it.effect('Mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_5', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = mysqlTable('mappers_posts_1', (t) => ({
+					id: t.int('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users, posts });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('mappers_users_6', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = mysqlTable('mappers_posts_2', (t) => ({
+					id: t.int('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					false,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_1', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Jit mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_2', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Jit mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_3', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Jit mappers: insert $returningId + select', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_4', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const insertedIds = yield* db.insert(users).values([{
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+				const selected = yield* db.select().from(users);
+
+				yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2));
+
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+			}));
+
+		it.effect('Jit mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_5', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = mysqlTable('jit_mappers_posts_1', (t) => ({
+					id: t.int('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users, posts });
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = mysqlTable('jit_mappers_users_6', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = mysqlTable('jit_mappers_posts_2', (t) => ({
+					id: t.int('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					true,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				const insertedIds = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).$returningId();
+
+				expect(insertedIds).toStrictEqual([]);
+
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		addTests?.(it);
+	});
+};
+
+export * as relations from './relations';
+export { rqbPost, rqbUser } from './schema';
diff --git a/integration-tests/tests/mysql/instrumentation.ts b/integration-tests/tests/mysql/instrumentation.ts
new file mode 100644
index 0000000000..64079093e3
--- /dev/null
+++ b/integration-tests/tests/mysql/instrumentation.ts
@@ -0,0 +1,505 @@
+import { Client } from '@planetscale/database';
+import { connect, type Connection } from '@tidbcloud/serverless';
+import {
+	AnyRelationsBuilderConfig,
+	defineRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	getTableName,
+	is,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Table,
+} from 'drizzle-orm';
+import type { MutationOption } from 'drizzle-orm/cache/core';
+import { Cache } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import type { MySqlAsyncDatabase, MySqlSchema, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
+import { drizzle as proxyDrizzle, RemoteCallback } from 'drizzle-orm/mysql-proxy';
+import type { AnyMySql2Connection } from 'drizzle-orm/mysql2';
+import { drizzle as mysql2Drizzle } from 'drizzle-orm/mysql2';
+import { mysql2Codecs } from 'drizzle-orm/mysql2/codecs';
+import { drizzle as psDrizzle } from 'drizzle-orm/planetscale-serverless';
+import { drizzle as drizzleTidb } from 'drizzle-orm/tidb-serverless';
+import { type FunctionsVersioning, type InferCallbackType, seed } from 'drizzle-seed';
+import Keyv from 'keyv';
+import { createConnection } from 'mysql2/promise';
+import type * as mysql from 'mysql2/promise';
+import type { Mock } from 'vitest';
+import { test as base, vi } from 'vitest';
+import { relations } from './schema';
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private readonly strat: 'explicit' | 'all', private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy(): 'explicit' | 'all' {
+		return this.strat;
+	}
+
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+class ServerSimulator {
+	constructor(private db: mysql.Connection) {}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+					sql,
+					values: params,
+					rowsAsArray: true,
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
+				});
+
+				return { data: result[0] as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+					sql,
+					values: params,
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
+				});
+
+				return { data: result as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('START TRANSACTION');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch (e) {
+			await this.db.query('ROLLBACK');
+			throw e;
+		}
+
+		return {};
+	}
+}
+
+export type MysqlSchema = Record<
+	string,
+	MySqlTable<any> | MySqlSchema | MySqlView
+>;
+
+export type RefineCallbackT<Schema extends MysqlSchema> = (
+	funcs: FunctionsVersioning,
+) => InferCallbackType<MySqlAsyncDatabase<any, any>, Schema>;
+
+const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+	vendor: string,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/mysql/mocks' as string);
+
+	const res = await diff({}, schema, []);
+	for (const s of res.sqlStatements) {
+		const patched = vendor === 'tidb' ? s.replace('(now())', '(now(2))') : s;
+		await query(patched, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+const _seed = async <Schema extends MysqlSchema>(
+	db: MySqlAsyncDatabase<any, any>,
+	schema: Schema,
+	refineCallback?: RefineCallbackT<Schema>,
+) => {
+	return refineCallback === undefined ? seed(db, schema) : seed(db, schema).refine(refineCallback);
+};
+
+const createProxyHandler = (client: mysql.Connection) => {
+	const serverSimulator = new ServerSimulator(client);
+	const proxyHandler: RemoteCallback = async (sql: string, params: any[], method: any) => {
+		try {
+			const response = await serverSimulator.query(sql, params, method);
+			if (response.error !== undefined) {
+				throw response.error;
+			}
+			return {
+				rows: response.data,
+				...(Array.isArray(response.data[0])
+					? {}
+					: { insertId: response.data.lastInsertRowId, affectedRows: response.data.affectedRows }),
+			};
+		} catch (e: any) {
+			console.error('Error from mysql proxy server:', e.message);
+			throw e;
+		}
+	};
+	return proxyHandler;
+};
+const prepareTest = (vendor: 'mysql' | 'planetscale' | 'tidb' | 'mysql-proxy') => {
+	return base.extend<
+		{
+			client: {
+				client: AnyMySql2Connection | Client | Connection;
+				query: (sql: string, params: any[]) => Promise<any[]>;
+				batch: (statements: string[]) => Promise<void>;
+			};
+			// proxyHandler: (sql: string, params: any[], method: any) => Promise<{
+			// 	rows: any;
+			// }>;
+			db: MySqlAsyncDatabase<any, typeof relations>;
+			createDB: {
+				<S extends MysqlSchema, TConfig extends AnyRelationsBuilderConfig>(config: {
+					schema?: S;
+					cb?: (helpers: RelationsBuilder<ExtractTablesFromSchema<S>>) => TConfig;
+					proxyClient?: mysql.Connection;
+					jit?: boolean;
+				}): MySqlAsyncDatabase<any, ExtractTablesWithRelations<TConfig, ExtractTablesFromSchema<S>>>;
+			};
+			push: (schema: any) => Promise<void>;
+			seed: <Schema extends MysqlSchema>(
+				schema: Schema,
+				refineCallback?: (funcs: FunctionsVersioning) => InferCallbackType<MySqlAsyncDatabase<any, any>, Schema>,
+			) => Promise<void>;
+			drizzle: {
+				withCacheAll: {
+					db: MySqlAsyncDatabase<any, any>;
+					put: Mock<any>;
+					get: Mock<any>;
+					onMutate: Mock<any>;
+					invalidate: Mock<any>;
+				};
+				withCacheExplicit: {
+					db: MySqlAsyncDatabase<any, any>;
+					put: Mock<any>;
+					get: Mock<any>;
+					onMutate: Mock<any>;
+					invalidate: Mock<any>;
+				};
+			};
+		}
+	>({
+		client: [
+			// oxlint-disable-next-line
+			async ({}, use) => {
+				if (vendor === 'mysql' || vendor === 'mysql-proxy') {
+					const envurl = process.env['MYSQL_CONNECTION_STRING'];
+					if (!envurl) throw new Error('No mysql url provided');
+					const client = await createConnection({
+						uri: envurl,
+						supportBigNumbers: true,
+						multipleStatements: true,
+					});
+					await client.connect();
+					await client.query('drop database if exists drizzle; create database drizzle; use drizzle;');
+
+					const query = async (sql: string, params: any[] = []) => {
+						const res = await client.query(sql, params);
+						return res[0] as any[];
+					};
+					const batch = async (statements: string[]) => {
+						return client.query(statements.map((x) => x.endsWith(';') ? x : `${x};`).join('\n')).then(() => '' as any);
+					};
+
+					await use({ client, query, batch });
+					await client.end();
+					client.destroy();
+					return;
+				}
+
+				if (vendor === 'planetscale') {
+					const envurl = process.env['PLANETSCALE_CONNECTION_STRING'];
+					if (!envurl) throw new Error('No mysql url provided');
+					const client = new Client({ url: envurl });
+
+					const query = async (sql: string, params: any[] = []) => {
+						return client.execute(sql, params).then((x) => x.rows);
+					};
+
+					const batch = async (statements: string[]) => {
+						const queries = statements.map((x) => {
+							return client.execute(x);
+						});
+						return Promise.all(queries).then(() => '' as any);
+					};
+
+					const tables =
+						(await query('SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE();')).map(
+							(x) => x['TABLE_NAME'],
+						);
+					const views =
+						(await query('SELECT table_name FROM information_schema.views WHERE table_schema = DATABASE();')).map((x) =>
+							x['TABLE_NAME']
+						);
+
+					const dropViews = views.length === 0
+						? 'select 1;'
+						: `DROP VIEW IF EXISTS ${views.map((x) => `\`${x}\``).join(',')};`;
+					const dropTables = tables.length === 0
+						? 'select 1;'
+						: `DROP TABLE IF EXISTS ${tables.map((x) => `\`${x}\``).join(',')};`;
+					await query(dropViews);
+					await query('SET FOREIGN_KEY_CHECKS = 0;');
+					await query(dropTables);
+					await query('SET FOREIGN_KEY_CHECKS = 1;');
+
+					await use({ client, query, batch });
+					return;
+				}
+
+				if (vendor === 'tidb') {
+					const connectionString = process.env['TIDB_CONNECTION_STRING'];
+					if (!connectionString) {
+						throw new Error('TIDB_CONNECTION_STRING is not set');
+					}
+
+					const tmpClient = connect({ url: connectionString });
+					await tmpClient.execute('drop database if exists ci;');
+					await tmpClient.execute('create database ci;');
+					await tmpClient.execute('use ci;');
+
+					const client = connect({ url: connectionString, database: 'ci' });
+
+					const query = async (sql: string, params: any[] = []) => {
+						return client.execute(sql, params) as Promise<any[]>;
+					};
+
+					const batch = async (statements: string[]) => {
+						const queries = statements.map((x) => {
+							return client.execute(x);
+						});
+						return Promise.all(queries).then(() => '' as any);
+					};
+					await use({ client, query, batch });
+					return;
+				}
+
+				throw new Error('error');
+			},
+			{ scope: 'worker' },
+		],
+		db: [
+			async ({ client }, use) => {
+				const db = vendor === 'mysql'
+					? mysql2Drizzle({ client: client.client as AnyMySql2Connection, relations })
+					: vendor === 'tidb'
+					? drizzleTidb({ client: client.client as Connection, relations })
+					: vendor === 'planetscale'
+					? psDrizzle({ client: client.client as Client, relations })
+					: proxyDrizzle(createProxyHandler(client.client as mysql.Connection), {
+						relations,
+						codecs: mysql2Codecs,
+					});
+
+				await use(db as any);
+			},
+			{ scope: 'worker' },
+		],
+		createDB: [
+			async ({ client }, use) => {
+				const createDB = <S extends MysqlSchema>(config: {
+					schema?: S;
+					cb?: (
+						helpers: RelationsBuilder<ExtractTablesFromSchema<S>>,
+					) => RelationsBuilderConfig<ExtractTablesFromSchema<S>>;
+					proxyClient?: mysql.Connection;
+					jit?: boolean;
+				}) => {
+					const { schema, cb, proxyClient, jit } = config;
+					const relations = schema ? cb ? defineRelations(schema, cb) : defineRelations(schema) : undefined;
+
+					if (vendor === 'mysql') {
+						return mysql2Drizzle({ client: client.client as any, relations, jit });
+					}
+					if (vendor === 'tidb') return drizzleTidb({ client: client.client as any, relations, jit });
+					if (vendor === 'planetscale') return psDrizzle({ client: client.client as any, relations, jit });
+					if (vendor === 'mysql-proxy') {
+						return proxyDrizzle(createProxyHandler(proxyClient ?? client.client as any), {
+							relations,
+							codecs: mysql2Codecs,
+							jit,
+						}) as any;
+					}
+					throw new Error();
+				};
+
+				await use(createDB);
+			},
+			{ scope: 'worker' },
+		],
+		push: [
+			async ({ client }, use) => {
+				const { query } = client;
+				const push = (
+					schema: any,
+				) => _push(query, schema, vendor);
+
+				await use(push);
+			},
+			{ scope: 'worker' },
+		],
+		seed: [
+			async ({ db }, use) => {
+				const seed = (
+					schema: any,
+					refineCallback?: (funcs: FunctionsVersioning) => InferCallbackType<MySqlAsyncDatabase<any, any>, any>,
+				) => _seed(db, schema, refineCallback);
+
+				await use(seed);
+			},
+			{ scope: 'worker' },
+		],
+		drizzle: [
+			async ({ client }, use) => {
+				const explicitCache = new TestCache('explicit');
+				const allCache = new TestCache('all');
+				const proxyHandler = createProxyHandler(client.client as mysql.Connection);
+
+				const withCacheExplicit = vendor === 'mysql'
+					? mysql2Drizzle({ client: client.client as any, cache: explicitCache })
+					: vendor === 'tidb'
+					? drizzleTidb({ client: client.client as Connection, relations, cache: explicitCache })
+					: vendor === 'planetscale'
+					? psDrizzle({ client: client.client as any, cache: explicitCache })
+					: proxyDrizzle(proxyHandler, { cache: explicitCache, codecs: mysql2Codecs });
+				const withCacheAll = vendor === 'mysql'
+					? mysql2Drizzle({ client: client.client as any, cache: allCache })
+					: vendor === 'tidb'
+					? drizzleTidb({ client: client.client as Connection, relations, cache: allCache })
+					: vendor === 'planetscale'
+					? psDrizzle({ client: client.client as any, cache: allCache })
+					: proxyDrizzle(proxyHandler, { cache: allCache, codecs: mysql2Codecs });
+
+				const drz = {
+					withCacheAll: {
+						db: withCacheAll,
+						put: vi.spyOn(allCache, 'put'),
+						get: vi.spyOn(allCache, 'get'),
+						onMutate: vi.spyOn(allCache, 'onMutate'),
+						invalidate: vi.spyOn(withCacheAll.$cache, 'invalidate'),
+					},
+					withCacheExplicit: {
+						db: withCacheExplicit,
+						put: vi.spyOn(explicitCache, 'put'),
+						get: vi.spyOn(explicitCache, 'get'),
+						onMutate: vi.spyOn(explicitCache, 'onMutate'),
+						invalidate: vi.spyOn(withCacheExplicit.$cache, 'invalidate'),
+					},
+				};
+
+				await use(drz as any);
+
+				await withCacheAll.$cache.invalidate({});
+				await withCacheExplicit.$cache.invalidate({});
+				drz.withCacheAll.get.mockClear();
+				drz.withCacheAll.put.mockClear();
+				drz.withCacheAll.onMutate.mockClear();
+				drz.withCacheAll.invalidate.mockClear();
+				drz.withCacheExplicit.get.mockClear();
+				drz.withCacheExplicit.put.mockClear();
+				drz.withCacheExplicit.onMutate.mockClear();
+				drz.withCacheExplicit.invalidate.mockClear();
+			},
+			{ scope: 'test' },
+		],
+	});
+};
+
+export const mysqlTest = prepareTest('mysql');
+export const planetscaleTest = prepareTest('planetscale');
+export const tidbTest = prepareTest('tidb');
+export const proxyTest = prepareTest('mysql-proxy').extend<
+	{ simulator: ServerSimulator; createSimulator: (proxyClient?: mysql.Connection) => ServerSimulator }
+>({
+	simulator: [
+		async ({ client: { client } }, use) => {
+			const simulator = new ServerSimulator(client as mysql.Connection);
+			await use(simulator);
+		},
+		{ scope: 'test' },
+	],
+	createSimulator: [
+		async ({ client: { client } }, use) => {
+			const createSimulator = (proxyClient?: mysql.Connection) => {
+				const simulator = new ServerSimulator(proxyClient ?? client as mysql.Connection);
+				return simulator;
+			};
+
+			await use(createSimulator);
+		},
+		{ scope: 'test' },
+	],
+});
+export type Test = ReturnType<typeof prepareTest>;
diff --git a/integration-tests/tests/mysql/mysql-common-1.ts b/integration-tests/tests/mysql/mysql-common-1.ts
new file mode 100644
index 0000000000..85188aa436
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-1.ts
@@ -0,0 +1,459 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { and, asc, eq, exists, inArray, notInArray, sql } from 'drizzle-orm';
+import {
+	alias,
+	boolean,
+	date,
+	datetime,
+	int,
+	json,
+	mysqlEnum,
+	mysqlTable,
+	serial,
+	text,
+	time,
+	timestamp,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { expect } from 'vitest';
+import { toLocalDate } from '~/utils';
+import type { Test } from './instrumentation';
+import { createUserTable } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test.concurrent('select all fields', async ({ db, push, seed }) => {
+		const users = createUserTable('users_1');
+
+		await push({ users });
+		await db.insert(users).values({ id: 1, name: 'Agripina', createdAt: new Date() });
+
+		const result = await db.select().from(users);
+
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		// not timezone based timestamp, thats why it should not work here
+		// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+		expect(result).toStrictEqual([{
+			id: 1,
+			name: 'Agripina',
+			verified: false,
+			jsonb: null,
+			createdAt: result[0]!.createdAt,
+		}]);
+	});
+
+	test.concurrent('select sql', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_2', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: json('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { mode: 'date', fsp: 2 }).notNull().defaultNow(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 1 } }));
+
+		const result = await db.select({
+			name: sql`upper(${users.name})`,
+		}).from(users);
+
+		expect(result).toStrictEqual([{ name: 'AGRIPINA' }]);
+	});
+
+	test.concurrent('select typed sql', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_3', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: json('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { mode: 'date', fsp: 2 }).notNull().defaultNow(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 1 } }));
+
+		const result = await db.select({
+			name: sql<string>`upper(${users.name})`,
+		}).from(users);
+
+		expect(result).toEqual([{ name: 'AGRIPINA' }]);
+	});
+
+	test.concurrent('select with empty array in inArray', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_4', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: json('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { mode: 'date', fsp: 2 }).notNull().defaultNow(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const result = await db
+			.select({
+				name: sql`upper(${users.name})`,
+			})
+			.from(users)
+			.where(inArray(users.id, []));
+
+		expect(result).toEqual([]);
+	});
+
+	test.concurrent('select with empty array in notInArray', async ({ db, push, seed }) => {
+		const users = createUserTable('users_5');
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const result = await db
+			.select({
+				name: sql`upper(${users.name})`,
+			})
+			.from(users)
+			.where(notInArray(users.id, []));
+
+		expect(result).toEqual([{ name: 'AGRIPINA' }, { name: 'CANDY' }, { name: 'ILSE' }]);
+	});
+
+	test.concurrent('select distinct', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_6', {
+			id: int('id').notNull(),
+			name: text('name').notNull(),
+		});
+		await push({ users });
+		await seed(
+			{ users },
+			(funcs: any) => ({
+				users: { count: 3, columns: { id: funcs.valuesFromArray({ values: [1, 1, 2], isUnique: true }) } },
+			}),
+		);
+
+		const result = await db.selectDistinct().from(users).orderBy(
+			users.id,
+			users.name,
+		);
+		expect(result).toEqual([{ id: 1, name: 'Candy' }, { id: 1, name: 'Ilse' }, { id: 2, name: 'Agripina' }]);
+	});
+
+	test.concurrent('select with group by as field', async ({ db, push, seed }) => {
+		const users = createUserTable('users_7');
+		await push({ users });
+		await seed({ users }, (funcs: any) => ({
+			users: {
+				count: 3,
+				columns: { name: funcs.valuesFromArray({ values: ['John', 'John', 'Jane'], isUnique: true }) },
+			},
+		}));
+
+		const result = await db.select({ name: users.name }).from(users)
+			.groupBy(users.name).orderBy(users.name);
+
+		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+	});
+
+	test.concurrent('select with exists', async ({ db, push, seed }) => {
+		const users = createUserTable('users_8');
+		const user = alias(users, 'user');
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const result = await db.select({ name: users.name }).from(users).where(
+			exists(
+				db.select({ one: sql`1` }).from(user).where(and(eq(users.name, 'Candy'), eq(user.id, users.id))),
+			),
+		);
+
+		expect(result).toEqual([{ name: 'Candy' }]);
+	});
+
+	test.concurrent('select with group by as sql', async ({ db, push, seed }) => {
+		const users = createUserTable('users_9');
+		await push({ users });
+		await seed({ users }, (funcs: any) => ({
+			users: {
+				columns: { name: funcs.valuesFromArray({ values: ['John', 'John', 'Jane'] }) },
+			},
+		}));
+
+		const result = await db.select({ name: users.name }).from(users)
+			.groupBy(sql`${users.name}`);
+
+		expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+	});
+
+	test.concurrent('select with group by as sql + column', async ({ db, push, seed }) => {
+		const users = createUserTable('users_10');
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const result = await db.select({ name: users.name }).from(users)
+			.groupBy(sql`${users.name}`, users.id);
+
+		expect(result).toEqual([{ name: 'Agripina' }, { name: 'Candy' }, { name: 'Ilse' }]);
+	});
+
+	test.concurrent('select with group by as column + sql', async ({ db, push, seed }) => {
+		const users = createUserTable('users_11');
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const result = await db.select({ name: users.name }).from(users)
+			.groupBy(users.id, sql`${users.name}`);
+
+		expect(result).toEqual([{ name: 'Agripina' }, { name: 'Candy' }, { name: 'Ilse' }]);
+	});
+
+	test.concurrent('select with group by complex query', async ({ db, push, seed }) => {
+		const users = createUserTable('users_12');
+		await push({ users });
+		await seed({ users }, (funcs: any) => ({
+			users: {
+				count: 3,
+				columns: { name: funcs.valuesFromArray({ values: ['John', 'Jane', 'Jane'], isUnique: true }) },
+			},
+		}));
+
+		const result = await db.select({ name: users.name }).from(users)
+			.groupBy(users.id, sql`${users.name}`)
+			.orderBy(asc(users.name))
+			.limit(1);
+
+		expect(result).toEqual([{ name: 'Jane' }]);
+	});
+
+	test.concurrent('partial join with alias', async ({ db, push, seed }) => {
+		const users = createUserTable('users_13');
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 2 } }));
+
+		const customerAlias = alias(users, 'customer');
+		const result = await db
+			.select({
+				user: {
+					id: users.id,
+					name: users.name,
+				},
+				customer: {
+					id: customerAlias.id,
+					name: customerAlias.name,
+				},
+			}).from(users)
+			.leftJoin(customerAlias, eq(customerAlias.id, 2))
+			.where(eq(users.id, 1));
+
+		expect(result).toEqual([{
+			user: { id: 1, name: 'Agripina' },
+			customer: { id: 2, name: 'Candy' },
+		}]);
+	});
+
+	test.concurrent('prepared statement', async ({ db, push, seed }) => {
+		const users = createUserTable('users_14');
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 1 } }));
+
+		const statement = db.select({
+			id: users.id,
+			name: users.name,
+		}).from(users)
+			.prepare();
+		const result = await statement.execute();
+
+		expect(result).toEqual([{ id: 1, name: 'Agripina' }]);
+	});
+
+	test.concurrent('prepared statement with placeholder in .where', async ({ db, push, seed }) => {
+		const users = createUserTable('users_15');
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 1 } }));
+
+		const stmt = db.select({
+			id: users.id,
+			name: users.name,
+		}).from(users)
+			.where(eq(users.id, sql.placeholder('id')))
+			.prepare();
+		const result = await stmt.execute({ id: 1 });
+
+		expect(result).toEqual([{ id: 1, name: 'Agripina' }]);
+	});
+
+	test.concurrent('prepared statement with placeholder in .limit', async ({ db, push, seed }) => {
+		const users = createUserTable('users_16');
+
+		await push({ users });
+		await seed({ users }, (funcs: any) => ({ users: { count: 1 } }));
+
+		const stmt = db
+			.select({
+				id: users.id,
+				name: users.name,
+			})
+			.from(users)
+			.where(eq(users.id, sql.placeholder('id')))
+			.limit(sql.placeholder('limit'))
+			.prepare();
+
+		const result = await stmt.execute({ id: 1, limit: 1 });
+
+		expect(result).toEqual([{ id: 1, name: 'Agripina' }]);
+		expect(result).toHaveLength(1);
+	});
+
+	test.concurrent('prepared statement with placeholder in .offset', async ({ db, push, seed }) => {
+		const users = createUserTable('users_17');
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 3 } }));
+
+		const stmt = db
+			.select({
+				id: users.id,
+				name: users.name,
+			})
+			.from(users)
+			.limit(sql.placeholder('limit'))
+			.offset(sql.placeholder('offset'))
+			.prepare();
+
+		const result = await stmt.execute({ limit: 1, offset: 1 });
+
+		expect(result).toEqual([{ id: 2, name: 'Candy' }]);
+	});
+
+	test.concurrent('prepared statement built using $dynamic', async ({ db, push, seed }) => {
+		const users = createUserTable('users_18');
+
+		await push({ users });
+		await seed({ users }, (funcs: any) => ({ users: { count: 3 } }));
+
+		function withLimitOffset(qb: any) {
+			return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+		}
+
+		const stmt = db
+			.select({
+				id: users.id,
+				name: users.name,
+			})
+			.from(users)
+			.$dynamic();
+		withLimitOffset(stmt).prepare('stmt_limit');
+
+		const result = await stmt.execute({ limit: 1, offset: 1 });
+
+		expect(result).toEqual([{ id: 2, name: 'Candy' }]);
+	});
+
+	test.concurrent('insert + select all possible dates', async ({ db, push }) => {
+		const datesTable = mysqlTable('datestable_1', {
+			date: date('date'),
+			dateAsString: date('date_as_string', { mode: 'string' }),
+			time: time('time', { fsp: 1 }),
+			datetime: datetime('datetime', { fsp: 2 }),
+			datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
+			timestamp: timestamp('timestamp', { fsp: 3 }),
+			timestampAsString: timestamp('timestamp_as_string', { fsp: 3, mode: 'string' }),
+			year: year('year'),
+		});
+
+		await push({ datesTable });
+
+		const testDate = new Date('2022-11-11');
+		const testDateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
+
+		await db.insert(datesTable).values({
+			date: testDate,
+			dateAsString: '2022-11-11',
+			time: '12:12:12',
+			datetime: testDate,
+			year: 22,
+			datetimeAsString: '2022-11-11 12:12:12',
+			timestamp: testDateWithMilliseconds,
+			timestampAsString: '2022-11-11 12:12:12.123',
+		});
+
+		const res = await db.select().from(datesTable);
+
+		expect(res[0]?.date).toBeInstanceOf(Date);
+		expect(res[0]?.datetime).toBeInstanceOf(Date);
+		expect(typeof res[0]?.dateAsString).toBe('string');
+		expect(typeof res[0]?.datetimeAsString).toBe('string');
+
+		expect(res).toEqual([{
+			date: toLocalDate(new Date('2022-11-11')),
+			dateAsString: '2022-11-11',
+			time: '12:12:12.0',
+			datetime: new Date('2022-11-11'),
+			year: 2022,
+			datetimeAsString: '2022-11-11 12:12:12.00',
+			timestamp: new Date('2022-11-11 12:12:12.123'),
+			timestampAsString: '2022-11-11 12:12:12.123',
+		}]);
+	});
+
+	test.concurrent('Mysql enum as ts enum', async ({ db, push }) => {
+		enum Test {
+			a = 'a',
+			b = 'b',
+			c = 'c',
+		}
+
+		const tableWithTsEnums = mysqlTable('enums_test_case_1', {
+			id: serial('id').primaryKey(),
+			enum1: mysqlEnum('enum1', Test).notNull(),
+			enum2: mysqlEnum('enum2', Test).default(Test.a),
+			enum3: mysqlEnum('enum3', Test).notNull().default(Test.b),
+		});
+
+		await push({ tableWithTsEnums });
+
+		await db.insert(tableWithTsEnums).values([
+			{ id: 1, enum1: Test.a, enum2: Test.b, enum3: Test.c },
+			{ id: 2, enum1: Test.a, enum3: Test.c },
+			{ id: 3, enum1: Test.a },
+		]);
+
+		const res = await db.select().from(tableWithTsEnums);
+
+		expect(res).toEqual([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+		]);
+	});
+
+	test.concurrent('Mysql enum test case #1', async ({ db, push }) => {
+		const tableWithEnums = mysqlTable('enums_test_case_2', {
+			id: serial('id').primaryKey(),
+			enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
+			enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
+			enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
+		});
+
+		await push({ tableWithEnums });
+
+		await db.insert(tableWithEnums).values([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a' },
+		]);
+
+		const res = await db.select().from(tableWithEnums);
+
+		expect(res).toEqual([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+		]);
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-2.ts b/integration-tests/tests/mysql/mysql-common-2.ts
new file mode 100644
index 0000000000..ca25f66a5a
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-2.ts
@@ -0,0 +1,689 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { eq, gt, inArray, lt, sql } from 'drizzle-orm';
+import {
+	boolean,
+	decimal,
+	getViewConfig,
+	int,
+	mysqlTable,
+	mysqlTableCreator,
+	mysqlView,
+	serial,
+	text,
+} from 'drizzle-orm/mysql-core';
+import { expect } from 'vitest';
+import { Expect } from '~/utils';
+import type { Equal } from '~/utils';
+import type { Test } from './instrumentation';
+import { createOrdersTable } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test.concurrent('left join (flat object fields)', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_19', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id'),
+		});
+		const cities = mysqlTable('cities_19', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users, cities });
+		await seed(
+			{ users, cities },
+			(funcs) => ({
+				users: { count: 2, columns: { cityId: funcs.valuesFromArray({ values: [1, null as any] }) } },
+				cities: { count: 1 },
+			}),
+		);
+
+		const res = await db.select({
+			userId: users.id,
+			userName: users.name,
+			cityId: cities.id,
+			cityName: cities.name,
+		}).from(users)
+			.leftJoin(cities, eq(users.cityId, cities.id));
+
+		expect(res).toEqual([
+			{ userId: 1, userName: 'Agripina', cityId: 1, cityName: 'Lakeitha' },
+			{ userId: 2, userName: 'Candy', cityId: null, cityName: null },
+		]);
+	});
+
+	test.concurrent('left join (grouped fields)', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_24', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id'),
+		});
+		const cities = mysqlTable('cities_4', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users, cities });
+		await seed(
+			{ users, cities },
+			(funcs) => ({
+				users: { count: 2, columns: { cityId: funcs.valuesFromArray({ values: [1, null as any] }) } },
+				cities: { count: 1 },
+			}),
+		);
+
+		const res = await db.select({
+			id: users.id,
+			user: {
+				name: users.name,
+				nameUpper: sql<string>`upper(${users.name})`,
+			},
+			city: {
+				id: cities.id,
+				name: cities.name,
+				nameUpper: sql<string>`upper(${cities.name})`,
+			},
+		}).from(users)
+			.leftJoin(cities, eq(users.cityId, cities.id));
+
+		expect(res).toEqual([
+			{
+				id: 1,
+				user: { name: 'Agripina', nameUpper: 'AGRIPINA' },
+				city: { id: 1, name: 'Lakeitha', nameUpper: 'LAKEITHA' },
+			},
+			{
+				id: 2,
+				user: { name: 'Candy', nameUpper: 'CANDY' },
+				city: null,
+			},
+		]);
+	});
+
+	test.concurrent('left join (all fields)', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_25', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id'),
+		});
+		const cities = mysqlTable('cities_25', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users, cities });
+		await seed(
+			{ users, cities },
+			(funcs) => ({
+				users: { count: 2, columns: { cityId: funcs.valuesFromArray({ values: [1, null as any] }) } },
+				cities: { count: 1 },
+			}),
+		);
+
+		const res = await db.select().from(users)
+			.leftJoin(cities, eq(users.cityId, cities.id));
+
+		expect(res).toEqual([
+			{
+				users_25: {
+					id: 1,
+					name: 'Agripina',
+					cityId: 1,
+				},
+				cities_25: {
+					id: 1,
+					name: 'Lakeitha',
+				},
+			},
+			{
+				users_25: {
+					id: 2,
+					name: 'Candy',
+					cityId: null,
+				},
+				cities_25: null,
+			},
+		]);
+	});
+
+	test.concurrent('join subquery', async ({ db, push }) => {
+		const courseCategories = mysqlTable('course_categories_1', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+		const courses = mysqlTable('courses_1', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			categoryId: int('category_id'),
+		});
+
+		await push({ courseCategories, courses });
+
+		await db.insert(courseCategories).values([
+			{ name: 'Category 1' },
+			{ name: 'Category 2' },
+			{ name: 'Category 3' },
+			{ name: 'Category 4' },
+		]);
+
+		await db.insert(courses).values([
+			{ name: 'Development', categoryId: 2 },
+			{ name: 'IT & Software', categoryId: 3 },
+			{ name: 'Marketing', categoryId: 4 },
+			{ name: 'Design', categoryId: 1 },
+		]);
+
+		const sq2 = db
+			.select({
+				categoryId: courseCategories.id,
+				category: courseCategories.name,
+				total: sql<number>`count(${courseCategories.id})`,
+			})
+			.from(courseCategories)
+			.groupBy(courseCategories.id, courseCategories.name)
+			.as('sq2');
+
+		const res = await db
+			.select({
+				courseName: courses.name,
+				categoryId: sq2.categoryId,
+			})
+			.from(courses)
+			.leftJoin(sq2, eq(courses.categoryId, sq2.categoryId))
+			.orderBy(courses.name);
+
+		expect(res).toEqual([
+			{ courseName: 'Design', categoryId: 1 },
+			{ courseName: 'Development', categoryId: 2 },
+			{ courseName: 'IT & Software', categoryId: 3 },
+			{ courseName: 'Marketing', categoryId: 4 },
+		]);
+	});
+
+	test.concurrent('with ... select', async ({ db, push }) => {
+		const orders = createOrdersTable('orders_1');
+
+		await push({ orders });
+
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]);
+
+		const regionalSales = db
+			.$with('regional_sales')
+			.as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+		const topRegions = db
+			.$with('top_regions')
+			.as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+						),
+					),
+			);
+
+		const result = await db
+			.with(regionalSales, topRegions)
+			.select({
+				region: orders.region,
+				product: orders.product,
+				productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+				productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+			})
+			.from(orders)
+			.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+			.groupBy(orders.region, orders.product)
+			.orderBy(orders.region, orders.product);
+
+		expect(result).toEqual([
+			{
+				region: 'Europe',
+				product: 'A',
+				productUnits: 3,
+				productSales: 30,
+			},
+			{
+				region: 'Europe',
+				product: 'B',
+				productUnits: 5,
+				productSales: 50,
+			},
+			{
+				region: 'US',
+				product: 'A',
+				productUnits: 7,
+				productSales: 70,
+			},
+			{
+				region: 'US',
+				product: 'B',
+				productUnits: 9,
+				productSales: 90,
+			},
+		]);
+	});
+
+	test.concurrent('with ... update', async ({ db, push }) => {
+		const products = mysqlTable('products', {
+			id: serial('id').primaryKey(),
+			price: decimal('price', {
+				precision: 15,
+				scale: 2,
+			}).notNull(),
+			cheap: boolean('cheap').notNull().default(false),
+		});
+
+		await push({ products });
+
+		await db.insert(products).values([
+			{ price: '10.99' },
+			{ price: '25.85' },
+			{ price: '32.99' },
+			{ price: '2.50' },
+			{ price: '4.59' },
+		]);
+
+		const averagePrice = db
+			.$with('average_price')
+			.as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+		await db
+			.with(averagePrice)
+			.update(products)
+			.set({
+				cheap: true,
+			})
+			.where(lt(products.price, sql`(select * from ${averagePrice})`));
+
+		const result = await db
+			.select({
+				id: products.id,
+			})
+			.from(products)
+			.where(eq(products.cheap, true));
+
+		expect(result).toEqual([
+			{ id: 1 },
+			{ id: 4 },
+			{ id: 5 },
+		]);
+	});
+
+	test.concurrent('with ... delete', async ({ db, push }) => {
+		const orders = createOrdersTable('orders_2');
+
+		await push({ orders });
+
+		await db.insert(orders).values([
+			{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+			{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+			{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+			{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+			{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+		]);
+
+		const averageAmount = db
+			.$with('average_amount')
+			.as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+		await db
+			.with(averageAmount)
+			.delete(orders)
+			.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
+
+		const result = await db
+			.select({
+				id: orders.id,
+			})
+			.from(orders);
+
+		expect(result).toEqual([
+			{ id: 1 },
+			{ id: 2 },
+			{ id: 3 },
+			{ id: 4 },
+			{ id: 5 },
+		]);
+	});
+
+	test.concurrent('select from subquery sql', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_30', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 2 } }));
+
+		const sq = db
+			.select({ name: sql<string>`concat(${users.name}, " modified")`.as('name') })
+			.from(users)
+			.as('sq');
+
+		const res = await db.select({ name: sq.name }).from(sq);
+
+		expect(res).toEqual([{ name: 'Agripina modified' }, { name: 'Candy modified' }]);
+	});
+
+	test.concurrent('select a field without joining its table', ({ db, push }) => {
+		const users1 = mysqlTable('users_31', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+		const users2 = mysqlTable('users_32', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		push({ users1, users2 });
+
+		expect(() => db.select({ name: users2.name }).from(users1).prepare()).toThrowError();
+	});
+
+	test.concurrent('select all fields from subquery without alias', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_33', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 2 } }));
+
+		const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users.name})` }).from(users));
+
+		expect(() => db.select().from(sq).prepare()).toThrowError();
+	});
+
+	test.concurrent('select count()', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_34', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+		await seed({ users }, () => ({ users: { count: 2 } }));
+
+		const res = await db.select({ count: sql`count(*)` }).from(users);
+
+		expect(res).toEqual([{ count: 2 }]);
+	});
+
+	test.concurrent('select for ...', ({ db, push }) => {
+		const users = mysqlTable('users_35', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		push({ users });
+
+		{
+			const query = db.select().from(users).for('update').toSQL();
+			expect(query.sql).toMatch(/ for update$/);
+		}
+		{
+			const query = db.select().from(users).for('share', { skipLocked: true }).toSQL();
+			expect(query.sql).toMatch(/ for share skip locked$/);
+		}
+		{
+			const query = db.select().from(users).for('update', { noWait: true }).toSQL();
+			expect(query.sql).toMatch(/ for update nowait$/);
+		}
+	});
+
+	test.concurrent('having', async ({ db, push, seed }) => {
+		const cities = mysqlTable('cities_37', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+		const users = mysqlTable('users_37', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id'),
+		});
+
+		await push({ cities, users });
+		await seed({ cities, users }, (funcs: any) => ({
+			cities: { count: 3 },
+			users: { count: 3, columns: { cityId: funcs.valuesFromArray({ values: [1, 1, 2] }) } },
+		}));
+
+		const result = await db
+			.select({
+				id: cities.id,
+				name: sql<string>`upper(${cities.name})`.as('upper_name'),
+				usersCount: sql<number>`count(${users.id})`.as('users_count'),
+			})
+			.from(cities)
+			.leftJoin(users, eq(users.cityId, cities.id))
+			.where(({ name }) => sql`length(${name}) >= 3`)
+			.groupBy(cities.id)
+			.having(({ usersCount }) => sql`${usersCount} > 0`)
+			.orderBy(({ name }) => name);
+
+		expect(result).toEqual([
+			{
+				id: 2,
+				name: 'HOVANES',
+				usersCount: 1,
+			},
+			{
+				id: 1,
+				name: 'LAKEITHA',
+				usersCount: 2,
+			},
+		]);
+	});
+
+	test.concurrent('view', async ({ db, push, seed }) => {
+		const users = mysqlTable('users_39', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		});
+
+		const newYorkers1 = mysqlView('new_yorkers_1')
+			.as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		const newYorkers2 = mysqlView('new_yorkers_2', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+
+		const newYorkers3 = mysqlView('new_yorkers_3', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		}).existing();
+
+		await push({ users, newYorkers1, newYorkers2, newYorkers3 });
+		await db.execute(sql`create view new_yorkers_3 as ${getViewConfig(newYorkers1).query}`);
+		await seed({ users }, (funcs: any) => ({
+			users: { count: 3, columns: { cityId: funcs.valuesFromArray({ values: [1, 1, 2] }) } },
+		}));
+
+		{
+			const result = await db.select().from(newYorkers1);
+			expect(result).toEqual([
+				{ id: 2, name: 'Candy', cityId: 1 },
+				{ id: 3, name: 'Ilse', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers2);
+			expect(result).toEqual([
+				{ id: 2, name: 'Candy', cityId: 1 },
+				{ id: 3, name: 'Ilse', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select().from(newYorkers3);
+			expect(result).toEqual([
+				{ id: 2, name: 'Candy', cityId: 1 },
+				{ id: 3, name: 'Ilse', cityId: 1 },
+			]);
+		}
+
+		{
+			const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+			expect(result).toEqual([
+				{ name: 'Candy' },
+				{ name: 'Ilse' },
+			]);
+		}
+	});
+
+	test.concurrent('select from raw sql', async ({ db }) => {
+		const result = await db.select({
+			id: sql<number>`id`,
+			name: sql<string>`name`,
+		}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+		Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+		expect(result).toEqual([
+			{ id: 1, name: 'John' },
+		]);
+	});
+
+	test.concurrent('select from raw sql with joins', async ({ db }) => {
+		const result = await db
+			.select({
+				id: sql<number>`users.id`,
+				name: sql<string>`users.name`,
+				userCity: sql<string>`users.city`,
+				cityName: sql<string>`cities.name`,
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+		Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+		expect(result).toEqual([
+			{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+		]);
+	});
+
+	test.concurrent('join on aliased sql from select', async ({ db }) => {
+		const result = await db
+			.select({
+				userId: sql<number>`users.id`.as('userId'),
+				name: sql<string>`users.name`,
+				userCity: sql<string>`users.city`,
+				cityId: sql<number>`cities.id`.as('cityId'),
+				cityName: sql<string>`cities.name`,
+			})
+			.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+			.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test.concurrent('join on aliased sql from with clause', async ({ db }) => {
+		const users = db.$with('users').as(
+			db.select({
+				id: sql<number>`id`.as('userId'),
+				name: sql<string>`name`.as('userName'),
+				city: sql<string>`city`.as('city'),
+			}).from(
+				sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+			),
+		);
+
+		const cities = db.$with('cities').as(
+			db.select({
+				id: sql<number>`id`.as('cityId'),
+				name: sql<string>`name`.as('cityName'),
+			}).from(
+				sql`(select 1 as id, 'Paris' as name) as cities`,
+			),
+		);
+
+		const result = await db
+			.with(users, cities)
+			.select({
+				userId: users.id,
+				name: users.name,
+				userCity: users.city,
+				cityId: cities.id,
+				cityName: cities.name,
+			})
+			.from(users)
+			.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+		Expect<
+			Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+		>;
+
+		expect(result).toEqual([
+			{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+		]);
+	});
+
+	test.concurrent('prefixed table', async ({ db, push }) => {
+		const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
+
+		const users = mysqlTable('test_prefixed_table_with_unique_name', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values({ id: 1, name: 'John' });
+
+		const result = await db.select().from(users);
+
+		expect(result).toEqual([{ id: 1, name: 'John' }]);
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-3.ts b/integration-tests/tests/mysql/mysql-common-3.ts
new file mode 100644
index 0000000000..9bfacefe30
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-3.ts
@@ -0,0 +1,606 @@
+import 'dotenv/config';
+import { asc, eq, gt, sql, TransactionRollbackError } from 'drizzle-orm';
+import { datetime, int, mysqlTable, mysqlView, serial, text, union, unionAll } from 'drizzle-orm/mysql-core';
+import { expect } from 'vitest';
+
+import type { Test } from './instrumentation';
+import { createCitiesTable, createUsers2Table, createUserTable } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test.concurrent('orderBy with aliased column', ({ db }) => {
+		const users2 = createUserTable('users2_41');
+		const query = db.select({
+			test: sql`something`.as('test'),
+		}).from(users2).orderBy((fields) => fields.test).toSQL();
+
+		expect(query.sql).toBe('select something as `test` from `users2_41` order by `test`');
+	});
+
+	test.concurrent('timestamp timezone', async ({ db, push }) => {
+		const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+		const users = createUserTable('users_48');
+		await push({ users });
+		await db.insert(users).values({ name: 'With default times' });
+		await db.insert(users).values({
+			name: 'Without default times',
+			createdAt: date,
+		});
+		const result = await db.select().from(users);
+
+		// check that the timestamps are set correctly for default times
+		expect(Math.abs(result[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
+
+		// check that the timestamps are set correctly for non default times
+		expect(Math.abs(result[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
+	});
+
+	test('transaction', async ({ db, push }) => {
+		const users = mysqlTable('users_transactions_48', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+		const products = mysqlTable('products_transactions_48', {
+			id: serial('id').primaryKey(),
+			price: int('price').notNull(),
+			stock: int('stock').notNull(),
+		});
+
+		await push({ users, products });
+
+		const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
+		const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
+		const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
+		const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
+
+		await db.transaction(async (tx) => {
+			await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+			await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toEqual([{ id: 1, balance: 90 }]);
+	});
+
+	test('transaction with options (set isolationLevel)', async ({ db, push }) => {
+		const users = mysqlTable('users_transactions_49', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+		const products = mysqlTable('products_transactions_49', {
+			id: serial('id').primaryKey(),
+			price: int('price').notNull(),
+			stock: int('stock').notNull(),
+		});
+
+		await push({ users, products });
+
+		const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
+		const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
+		const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
+		const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
+
+		await db.transaction(async (tx) => {
+			await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+			await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+		}, { isolationLevel: 'serializable' });
+
+		const result = await db.select().from(users);
+		expect(result).toEqual([{ id: 1, balance: 90 }]);
+	});
+
+	test('transaction rollback', async ({ db, push }) => {
+		const users = mysqlTable('users_transactions_rollback_50', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await push({ users });
+
+		await expect((async () => {
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 });
+				tx.rollback();
+			});
+		})()).rejects.toThrowError(TransactionRollbackError);
+
+		const result = await db.select().from(users);
+
+		expect(result).toEqual([]);
+	});
+
+	test('nested transaction', async ({ db, push }) => {
+		const users = mysqlTable('users_nested_transactions_51', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await push({ users });
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+
+			await tx.transaction(async (tx) => {
+				await tx.update(users).set({ balance: 200 });
+			});
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toEqual([{ id: 1, balance: 200 }]);
+	});
+
+	test('nested transaction rollback', async ({ db, push }) => {
+		const users = mysqlTable('users_52', {
+			id: serial('id').primaryKey(),
+			balance: int('balance').notNull(),
+		});
+
+		await push({ users });
+
+		await db.transaction(async (tx) => {
+			await tx.insert(users).values({ balance: 100 });
+
+			await expect((async () => {
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 });
+					tx.rollback();
+				});
+			})()).rejects.toThrowError(TransactionRollbackError);
+		});
+
+		const result = await db.select().from(users);
+
+		expect(result).toEqual([{ id: 1, balance: 100 }]);
+	});
+
+	test.concurrent('join subquery with join', async ({ db, push }) => {
+		const internalStaff = mysqlTable('users_53_internal_staff', {
+			userId: int('user_id').notNull(),
+		});
+
+		const customUser = mysqlTable('users_53_custom_user', {
+			id: int('id').notNull(),
+		});
+
+		const ticket = mysqlTable('users_53_ticket', {
+			staffId: int('staff_id').notNull(),
+		});
+
+		await push({ internalStaff, customUser, ticket });
+
+		await db.insert(internalStaff).values({ userId: 1 });
+		await db.insert(customUser).values({ id: 1 });
+		await db.insert(ticket).values({ staffId: 1 });
+
+		const subq = db
+			.select()
+			.from(internalStaff)
+			.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+			.as('internal_staff');
+
+		const mainQuery = await db
+			.select()
+			.from(ticket)
+			.leftJoin(subq, eq(subq.users_53_internal_staff.userId, ticket.staffId));
+
+		expect(mainQuery).toEqual([{
+			users_53_ticket: { staffId: 1 },
+			internal_staff: {
+				users_53_internal_staff: { userId: 1 },
+				users_53_custom_user: { id: 1 },
+			},
+		}]);
+	});
+
+	test.concurrent('subquery with view', async ({ db, push }) => {
+		const users = mysqlTable('users_54', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		});
+
+		const newYorkers = mysqlView('users_54_new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		await push({ users, newYorkers });
+
+		await db.insert(users).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 1 },
+			{ name: 'Jill', cityId: 2 },
+		]);
+
+		const sq = db.$with('sq').as(db.select().from(newYorkers));
+		const result = await db.with(sq).select().from(sq);
+
+		expect(result).toEqual([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 3, name: 'Jack', cityId: 1 },
+		]);
+	});
+
+	test.concurrent('join view as subquery', async ({ db, push }) => {
+		const users = mysqlTable('users_join_view', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').notNull(),
+		});
+
+		const newYorkers = mysqlView('users_55_new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+		await push({ users, newYorkers });
+
+		await db.insert(users).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 1 },
+			{ name: 'Jill', cityId: 2 },
+		]);
+
+		const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+		const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+		expect(result).toEqual([
+			{
+				users_join_view: { id: 1, name: 'John', cityId: 1 },
+				new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+			{
+				users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+				new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+			},
+			{
+				users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+				new_yorkers_sq: null,
+			},
+		]);
+	});
+
+	test.concurrent('select iterator', async ({ db, push }) => {
+		const users = mysqlTable('users_iterator_1', {
+			id: serial('id').primaryKey(),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values([{}, {}, {}]);
+
+		const iter = db.select().from(users).iterator();
+
+		const result: typeof users.$inferSelect[] = [];
+
+		for await (const row of iter) {
+			result.push(row);
+		}
+
+		expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+	});
+
+	test.concurrent('select iterator w/ prepared statement', async ({ db, push }) => {
+		const users = mysqlTable('users_iterator_2', {
+			id: serial('id').primaryKey(),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values([{}, {}, {}]);
+
+		const prepared = db.select().from(users).prepare();
+		const iter = prepared.iterator();
+		const result: typeof users.$inferSelect[] = [];
+
+		for await (const row of iter) {
+			result.push(row);
+		}
+
+		expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+	});
+
+	test.concurrent('insert undefined', async ({ db, push }) => {
+		const users = mysqlTable('users_58', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await push({ users });
+
+		await expect((async () => {
+			await db.insert(users).values({ name: undefined });
+		})()).resolves.not.toThrowError();
+	});
+
+	test.concurrent('update undefined', async ({ db, push }) => {
+		const users = mysqlTable('users_59', {
+			id: serial('id').primaryKey(),
+			name: text('name'),
+		});
+
+		await push({ users });
+
+		await expect((async () => {
+			await db.update(users).set({ name: undefined });
+		})()).rejects.toThrowError();
+
+		await expect((async () => {
+			await db.update(users).set({ id: 1, name: undefined });
+		})()).resolves.not.toThrowError();
+	});
+
+	test.concurrent('utc config for datetime', async ({ db, push, client }) => {
+		const query = client.query;
+		const datesTable = mysqlTable('datestable_2', {
+			datetimeUTC: datetime('datetime_utc', { fsp: 3, mode: 'date' }),
+			datetime: datetime('datetime', { fsp: 3 }),
+			datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+		});
+
+		await push({ datesTable });
+
+		await query(`SET time_zone = '+00:00'`, []);
+
+		const dateObj = new Date('2022-11-11');
+		const dateUtc = new Date('2022-11-11T12:12:12.122Z');
+
+		await db.insert(datesTable).values({
+			datetimeUTC: dateUtc,
+			datetime: dateObj,
+			datetimeAsString: '2022-11-11 12:12:12',
+		});
+
+		const res = await db.select().from(datesTable);
+
+		expect(res[0]?.datetime).toBeInstanceOf(Date);
+		expect(res[0]?.datetimeUTC).toBeInstanceOf(Date);
+		expect(typeof res[0]?.datetimeAsString).toBe('string');
+
+		expect(res).toEqual([{
+			datetimeUTC: dateUtc,
+			datetime: new Date('2022-11-11'),
+			datetimeAsString: '2022-11-11 12:12:12',
+		}]);
+	});
+
+	test('set operations (union) from query builder with subquery', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_38');
+		const users2 = createUsers2Table('users2_38', cities);
+		await push({ cities, users2 });
+
+		await db.insert(cities).values([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await db.insert(users2).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+
+		const sq = db
+			.select({ id: users2.id, name: users2.name })
+			.from(users2).as('sq');
+
+		const result = await db
+			.select({ id: cities.id, name: cities.name })
+			.from(cities).union(
+				db.select().from(sq),
+			).limit(8);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+		]);
+
+		// union should throw if selected fields are not in the same order
+		await expect((async () => {
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).union(
+					db
+						.select({ name: users2.name, id: users2.id })
+						.from(users2),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union) as function', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_39');
+		const users2 = createUsers2Table('users2_39', cities);
+		await push({ cities, users2 });
+
+		await db.insert(cities).values([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await db.insert(users2).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+
+		const result = await union(
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).where(eq(cities.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		);
+
+		expect(result).toHaveLength(2);
+
+		expect(result).toEqual([
+			{ id: 1, name: 'Paris' },
+			{ id: 1, name: 'John' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(eq(cities.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+				db
+					.select({ name: users2.name, id: users2.id })
+					.from(users2).where(eq(users2.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test('set operations (union all) from query builder', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_40');
+		await push({ cities });
+
+		await db.insert(cities).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		const result = await db
+			.select({ id: cities.id, name: cities.name })
+			.from(cities).limit(2).unionAll(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).limit(2),
+			).orderBy(asc(sql`id`)).limit(3);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).limit(2).unionAll(
+					db
+						.select({ name: cities.name, id: cities.id })
+						.from(cities).limit(2),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (union all) as function', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_41');
+		const users2 = createUsers2Table('users2_41', cities);
+		await push({ cities, users2 });
+
+		await db.insert(cities).values([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await db.insert(users2).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+
+		const result = await unionAll(
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).where(eq(cities.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		).limit(1);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'Paris' },
+		]);
+
+		await expect((async () => {
+			unionAll(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(eq(cities.id, 1)),
+				db
+					.select({ name: users2.name, id: users2.id })
+					.from(users2).where(eq(users2.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+			).limit(1);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (intersect) from query builder', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_42');
+		await push({ cities });
+
+		await db.insert(cities).values([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		const result = await db
+			.select({ id: cities.id, name: cities.name })
+			.from(cities).intersect(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(gt(cities.id, 1)),
+			);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ name: cities.name, id: cities.id })
+				.from(cities).intersect(
+					db
+						.select({ id: cities.id, name: cities.name })
+						.from(cities).where(gt(cities.id, 1)),
+				);
+		})()).rejects.toThrowError();
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-4.ts b/integration-tests/tests/mysql/mysql-common-4.ts
new file mode 100644
index 0000000000..8c9f6faaca
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-4.ts
@@ -0,0 +1,488 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { asc, avg, avgDistinct, count, countDistinct, eq, gt, gte, max, min, sql, sum, sumDistinct } from 'drizzle-orm';
+import { except, exceptAll, intersect, intersectAll, union } from 'drizzle-orm/mysql-core';
+import { expect } from 'vitest';
+
+import type { Test } from './instrumentation';
+import { createAggregateTable, createCitiesTable, createUsers2Table } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test.concurrent('set operations (intersect) as function', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_43');
+		const users2 = createUsers2Table('users2_43', cities);
+		await push({ cities, users2 });
+
+		const result = await intersect(
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).where(eq(cities.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		).limit(1);
+
+		expect(result).toStrictEqual([]);
+
+		await expect((async () => {
+			intersect(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(eq(cities.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+				db
+					.select({ name: users2.name, id: users2.id })
+					.from(users2).where(eq(users2.id, 1)),
+			).limit(1);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (intersect all) from query builder', async ({ db, push, seed }) => {
+		const cities = createCitiesTable('cities_44');
+		await push({ cities });
+
+		await seed(
+			{ cities },
+			(funcs) => ({ cities: { count: 3, columns: { name: funcs.city() } } }),
+		);
+
+		const result = await db
+			.select({ id: cities.id, name: cities.name })
+			.from(cities).limit(2).intersectAll(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).limit(2),
+			).orderBy(asc(sql`id`));
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'Hoogvliet' },
+			{ id: 2, name: 'South Milwaukee' },
+		]);
+
+		await expect((async () => {
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).limit(2).intersectAll(
+					db
+						.select({ name: cities.name, id: cities.id })
+						.from(cities).limit(2),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (intersect all) as function', async ({ db, push, seed }) => {
+		const cities = createCitiesTable('cities_45');
+		const users2 = createUsers2Table('users2_45', cities);
+		await push({ cities, users2 });
+
+		await seed(
+			{ cities, users2 },
+			(funcs) => ({
+				cities: { count: 3, columns: { name: funcs.city() } },
+				users2: { count: 8 },
+			}),
+		);
+
+		const result = await intersectAll(
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'Melina' },
+		]);
+
+		await expect((async () => {
+			intersectAll(
+				db
+					.select({ name: users2.name, id: users2.id })
+					.from(users2).where(eq(users2.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (except) from query builder', async ({ db, push, seed }) => {
+		const cities = createCitiesTable('cities_46');
+		await push({ cities });
+
+		await seed(
+			{ cities },
+			(funcs) => ({ cities: { count: 3, columns: { name: funcs.city() } } }),
+		);
+
+		const result = await db
+			.select()
+			.from(cities).except(
+				db
+					.select()
+					.from(cities).where(gt(cities.id, 1)),
+			);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'Hoogvliet' },
+		]);
+	});
+
+	test.concurrent('set operations (except) as function', async ({ db, push, seed }) => {
+		const cities = createCitiesTable('cities_47');
+		const users2 = createUsers2Table('users2_47', cities);
+		await push({ cities, users2 });
+
+		await seed(
+			{ cities, users2 },
+			(funcs) => ({
+				cities: { count: 3, columns: { name: funcs.city() } },
+				users2: { count: 8 },
+			}),
+		);
+
+		const result = await except(
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities),
+			db
+				.select({ id: cities.id, name: cities.name })
+				.from(cities).where(eq(cities.id, 1)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		).limit(3);
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'South Milwaukee' },
+			{ id: 3, name: 'Bou Hadjar' },
+		]);
+
+		await expect((async () => {
+			except(
+				db
+					.select({ name: cities.name, id: cities.id })
+					.from(cities),
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(eq(cities.id, 1)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+			).limit(3);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (except all) from query builder', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_50');
+		await push({ cities });
+		await db.insert(cities).values([
+			{ id: 1, name: 'Paris' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		const result = await db
+			.select()
+			.from(cities).exceptAll(
+				db
+					.select({ id: cities.id, name: cities.name })
+					.from(cities).where(eq(cities.id, 1)),
+			).orderBy(asc(sql`id`));
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(cities).exceptAll(
+					db
+						.select({ name: cities.name, id: cities.id })
+						.from(cities).where(eq(cities.id, 1)),
+				).orderBy(asc(sql`id`));
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (except all) as function', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_51');
+		const users2 = createUsers2Table('users2_51', cities);
+		await push({ cities, users2 });
+		await db.insert(users2).values([
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+			{ id: 6, name: 'Jill' },
+			{ id: 7, name: 'Mary' },
+		]);
+
+		const result = await exceptAll(
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(gt(users2.id, 7)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+		).limit(6).orderBy(asc(sql.identifier('id')));
+
+		expect(result).toStrictEqual([
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+			{ id: 6, name: 'Jill' },
+			{ id: 7, name: 'Mary' },
+		]);
+
+		await expect((async () => {
+			exceptAll(
+				db
+					.select({ name: users2.name, id: users2.id })
+					.from(users2),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(gt(users2.id, 7)),
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+			).limit(6);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (mixed) from query builder', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_52');
+		await push({ cities });
+		await db.insert(cities).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		const result = await db
+			.select()
+			.from(cities).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select()
+							.from(cities).where(gt(cities.id, 1)),
+						db.select().from(cities).where(eq(cities.id, 2)),
+					).orderBy(asc(cities.id)).limit(1).offset(1),
+			);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'New York' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			db
+				.select()
+				.from(cities).except(
+					({ unionAll }) =>
+						unionAll(
+							db
+								.select({ name: cities.name, id: cities.id })
+								.from(cities).where(gt(cities.id, 1)),
+							db.select().from(cities).where(eq(cities.id, 2)),
+						),
+				);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('set operations (mixed all) as function with subquery', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_48');
+		const users2 = createUsers2Table('users2_48', cities);
+		await push({ cities, users2 });
+		await db.insert(cities).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+		await db.insert(users2).values([
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+			{ id: 3, name: 'Jack' },
+			{ id: 4, name: 'Peter' },
+			{ id: 5, name: 'Ben' },
+			{ id: 6, name: 'Jill' },
+			{ id: 7, name: 'Mary' },
+		]);
+
+		const sq = except(
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(gte(users2.id, 5)),
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 7)),
+		).orderBy(asc(sql.identifier('id'))).as('sq');
+
+		const result = await union(
+			db
+				.select({ id: users2.id, name: users2.name })
+				.from(users2).where(eq(users2.id, 1)),
+			db.select().from(sq).limit(1),
+			db
+				.select().from(cities).where(gt(cities.id, 1)),
+		);
+
+		expect(result).toHaveLength(4);
+
+		expect(result).toEqual([
+			{ id: 1, name: 'John' },
+			{ id: 5, name: 'Ben' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		await expect((async () => {
+			union(
+				db
+					.select({ id: users2.id, name: users2.name })
+					.from(users2).where(eq(users2.id, 1)),
+				except(
+					db
+						.select({ id: users2.id, name: users2.name })
+						.from(users2).where(gte(users2.id, 5)),
+					db
+						.select({ name: users2.name, id: users2.id })
+						.from(users2).where(eq(users2.id, 7)),
+				).limit(1),
+				db
+					.select().from(cities).where(gt(cities.id, 1)),
+			);
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent('aggregate function: count', async ({ db, push }) => {
+		const aggregateTable = createAggregateTable('aggregate_table_1');
+
+		await push({ aggregateTable });
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+
+		const result1 = await db.select({ value: count() }).from(aggregateTable);
+		const result2 = await db.select({ value: count(aggregateTable.a) }).from(aggregateTable);
+		const result3 = await db.select({ value: countDistinct(aggregateTable.name) }).from(aggregateTable);
+
+		expect(result1[0]?.value).toBe(7);
+		expect(result2[0]?.value).toBe(5);
+		expect(result3[0]?.value).toBe(6);
+	});
+
+	test.concurrent('aggregate function: avg', async ({ db, push }) => {
+		const aggregateTable = createAggregateTable('aggregate_table_2');
+
+		await push({ aggregateTable });
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+		const result1 = await db.select({ value: avg(aggregateTable.b) }).from(aggregateTable);
+		const result2 = await db.select({ value: avg(aggregateTable.nullOnly) }).from(aggregateTable);
+		const result3 = await db.select({ value: avgDistinct(aggregateTable.b) }).from(aggregateTable);
+
+		expect(result1[0]?.value).toBe('33.3333');
+		expect(result2[0]?.value).toBe(null);
+		expect(result3[0]?.value).toBe('42.5000');
+	});
+
+	test.concurrent('aggregate function: sum', async ({ db, push }) => {
+		const table = createAggregateTable('aggregate_table_3');
+		await push({ table });
+		await db.insert(table).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+
+		const result1 = await db.select({ value: sum(table.b) }).from(table);
+		const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
+		const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
+
+		expect(result1[0]?.value).toBe('200');
+		expect(result2[0]?.value).toBe(null);
+		expect(result3[0]?.value).toBe('170');
+	});
+
+	test.concurrent('aggregate function: max', async ({ db, push }) => {
+		const aggregateTable = createAggregateTable('aggregate_table_4');
+		await push({ table: aggregateTable });
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+
+		const result1 = await db.select({ value: max(aggregateTable.b) }).from(aggregateTable);
+		const result2 = await db.select({ value: max(aggregateTable.nullOnly) }).from(aggregateTable);
+
+		expect(result1[0]?.value).toBe(90);
+		expect(result2[0]?.value).toBe(null);
+	});
+
+	test.concurrent('aggregate function: min', async ({ db, push }) => {
+		const aggregateTable = createAggregateTable('aggregate_table_5');
+		await push({ table: aggregateTable });
+		await db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+
+		const result1 = await db.select({ value: min(aggregateTable.b) }).from(aggregateTable);
+		const result2 = await db.select({ value: min(aggregateTable.nullOnly) }).from(aggregateTable);
+
+		expect(result1[0]?.value).toBe(10);
+		expect(result2[0]?.value).toBe(null);
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-5.ts b/integration-tests/tests/mysql/mysql-common-5.ts
new file mode 100644
index 0000000000..63fff3a105
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-5.ts
@@ -0,0 +1,370 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { eq, sql } from 'drizzle-orm';
+import { alias, getViewConfig, int, mysqlTable, serial, text } from 'drizzle-orm/mysql-core';
+import { describe, expect } from 'vitest';
+import type { Test } from './instrumentation';
+import { citiesMySchemaTable, mySchema, users2MySchemaTable, usersMySchemaTable } from './schema2';
+
+async function setupReturningFunctionsTest(batch: (s: string[]) => Promise<void>) {
+	await batch([`drop table if exists \`users_default_fn\``]);
+	await batch([`create table \`users_default_fn\` (
+					\`id\` varchar(256) primary key,
+					\`name\` text not null
+				);`]);
+}
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	describe('mySchema_tests', () => {
+		test.beforeEach(async ({ task, skip, db }) => {
+			if (exclude.has(task.name) || (task.suite?.name && exclude.has(task.suite.name))) skip();
+			await db.execute(sql`drop schema if exists \`mySchema\``);
+			await db.execute(sql`create schema if not exists \`mySchema\``);
+
+			await db.execute(
+				sql`
+						create table \`mySchema\`.\`userstest\` (
+							\`id\` serial primary key,
+							\`name\` text not null,
+							\`verified\` boolean not null default false,
+							\`jsonb\` json,
+							\`created_at\` timestamp not null default now()
+						)
+					`,
+			);
+
+			await db.execute(
+				sql`
+						create table \`mySchema\`.\`cities\` (
+							\`id\` serial primary key,
+							\`name\` text not null
+						)
+					`,
+			);
+
+			await db.execute(
+				sql`
+						create table \`mySchema\`.\`users2\` (
+							\`id\` serial primary key,
+							\`name\` text not null,
+							\`city_id\` int references \`mySchema\`.\`cities\`(\`id\`)
+						)
+					`,
+			);
+		});
+		// mySchema tests
+		test('mySchema :: select all fields', async ({ db, push }) => {
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			// not timezone based timestamp, thats why it should not work here
+			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+		});
+
+		test('mySchema :: select sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db.select({
+				name: sql`upper(${usersMySchemaTable.name})`,
+			}).from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: select typed sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db.select({
+				name: sql<string>`upper(${usersMySchemaTable.name})`,
+			}).from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test('mySchema :: select distinct', async ({ db }) => {
+			const usersDistinctTable = mysqlTable('users_distinct', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+				{ id: 1, name: 'Jane' },
+			]);
+			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+				usersDistinctTable.id,
+				usersDistinctTable.name,
+			);
+
+			await db.execute(sql`drop table ${usersDistinctTable}`);
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+		});
+
+		test('mySchema :: insert returning sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			const [result, _] = await db.insert(usersMySchemaTable).values({ name: 'John' });
+
+			expect(result.insertId).toBe(1);
+		});
+
+		test('mySchema :: delete returning sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
+
+			expect(users[0].affectedRows).toBe(1);
+		});
+
+		test('mySchema :: update with returning partial', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const updatedUsers = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(
+				eq(usersMySchemaTable.name, 'John'),
+			);
+
+			const users = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
+				usersMySchemaTable,
+			)
+				.where(
+					eq(usersMySchemaTable.id, 1),
+				);
+
+			expect(updatedUsers[0].changedRows).toBe(1);
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+		});
+
+		test('mySchema :: delete with returning all fields', async ({ db }) => {
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const deletedUser = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
+
+			expect(deletedUser[0].affectedRows).toBe(1);
+		});
+
+		test('mySchema :: insert + select', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+			await db.insert(usersMySchemaTable).values({ name: 'Jane' });
+			const result2 = await db.select().from(usersMySchemaTable);
+			expect(result2).toEqual([
+				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+			]);
+		});
+
+		test('mySchema :: insert with overridden default values', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John', verified: true });
+			const result = await db.select().from(usersMySchemaTable);
+
+			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+		});
+
+		test('mySchema :: insert many', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values([
+				{ name: 'John' },
+				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ name: 'Jane' },
+				{ name: 'Austin', verified: true },
+			]);
+			const result = await db.select({
+				id: usersMySchemaTable.id,
+				name: usersMySchemaTable.name,
+				jsonb: usersMySchemaTable.jsonb,
+				verified: usersMySchemaTable.verified,
+			}).from(usersMySchemaTable);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test('mySchema :: select with group by as field', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.name);
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test('mySchema :: select with group by as column + sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`);
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		});
+
+		test('mySchema :: build query', async ({ db }) => {
+			const query = db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					`select \`id\`, \`name\` from \`mySchema\`.\`userstest\` group by \`mySchema\`.\`userstest\`.\`id\`, \`mySchema\`.\`userstest\`.\`name\``,
+				params: [],
+			});
+		});
+
+		test('mySchema :: insert with spaces', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: sql`'Jo   h     n'` });
+			const result = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
+				usersMySchemaTable,
+			);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test('mySchema :: prepared statement with placeholder in .where', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const stmt = db.select({
+				id: usersMySchemaTable.id,
+				name: usersMySchemaTable.name,
+			}).from(usersMySchemaTable)
+				.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
+				.prepare();
+			const result = await stmt.execute({ id: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test('mySchema :: select from tables with same name from different schema using alias', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.execute(sql`drop table if exists \`userstest\``);
+			await db.execute(
+				sql`
+					create table \`userstest\` (
+						\`id\` serial primary key,
+						\`name\` text not null,
+						\`verified\` boolean not null default false,
+						\`jsonb\` json,
+						\`created_at\` timestamp not null default now()
+					)
+				`,
+			);
+
+			await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
+			await db.insert(usersMySchemaTable).values({ id: 11, name: 'Hans' });
+
+			const customerAlias = alias(usersMySchemaTable, 'customer');
+
+			const result = await db
+				.select().from(usersMySchemaTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(usersMySchemaTable.id, 10));
+
+			expect(result).toEqual([{
+				userstest: {
+					id: 10,
+					name: 'Ivan',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.userstest.createdAt,
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.customer!.createdAt,
+				},
+			}]);
+		});
+
+		test('mySchema :: view', async ({ db }) => {
+			const newYorkers1 = mySchema.view('new_yorkers')
+				.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
+
+			const newYorkers2 = mySchema.view('new_yorkers', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int('city_id').notNull(),
+			}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
+
+			const newYorkers3 = mySchema.view('new_yorkers', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int('city_id').notNull(),
+			}).existing();
+
+			await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
+
+			await db.insert(citiesMySchemaTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users2MySchemaTable).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+				expect(result).toEqual([
+					{ name: 'John' },
+					{ name: 'Jane' },
+				]);
+			}
+
+			await db.execute(sql`drop view ${newYorkers1}`);
+		});
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-6.ts b/integration-tests/tests/mysql/mysql-common-6.ts
new file mode 100644
index 0000000000..d9ecdf323a
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-6.ts
@@ -0,0 +1,915 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { eq, gt, like, not, sql } from 'drizzle-orm';
+import { bigint, int, mysqlTable, primaryKey, serial, text, varchar } from 'drizzle-orm/mysql-core';
+import { expect, expectTypeOf } from 'vitest';
+import type { Test } from './instrumentation';
+import { rqbPost, rqbUser } from './schema';
+import { createCitiesTable, createCountTestTable, createUsers2Table, createUserTable } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	let firstTime = true;
+	let resolveValue: (val: any) => void;
+	const promise = new Promise((resolve) => {
+		resolveValue = resolve;
+	});
+	test.beforeEach(async ({ task, skip, client, db }) => {
+		if (firstTime) {
+			firstTime = false;
+
+			await client.batch([
+				`CREATE TABLE \`user_rqb_test\` (
+		        	\`id\` SERIAL PRIMARY KEY,
+		        	\`name\` TEXT NOT NULL,
+		        	\`created_at\` TIMESTAMP NOT NULL
+		     	);`,
+				`CREATE TABLE \`post_rqb_test\` ( 
+		        	\`id\` SERIAL PRIMARY KEY,
+		        	\`user_id\` BIGINT(20) UNSIGNED NOT NULL,
+		        	\`content\` TEXT,
+		        	\`created_at\` TIMESTAMP NOT NULL
+				);`,
+				`CREATE TABLE \`empty\` (\`id\` int);`,
+			]);
+
+			const date = new Date(120000);
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			resolveValue('');
+		}
+
+		await promise;
+		if (exclude.has(task.name)) skip();
+	});
+
+	// .sequential is needed for beforeEach to be executed before all tests
+	test.concurrent('insert $returningId: serial as id', async ({ db, push }) => {
+		const users = createUserTable('users_60');
+		await push({ users });
+		const result = await db.insert(users).values({ name: 'John' }).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }]);
+	});
+
+	test.concurrent('insert $returningId: serial as id, not first column', async ({ db, push }) => {
+		const usersTableDefNotFirstColumn = mysqlTable('users2_52', {
+			name: text('name').notNull(),
+			id: serial('id').primaryKey(),
+		});
+
+		await push({ usersTableDefNotFirstColumn });
+
+		const result = await db.insert(usersTableDefNotFirstColumn).values({ name: 'John' }).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }]);
+	});
+
+	test.concurrent('insert $returningId: serial as id, batch insert', async ({ db, push }) => {
+		const users = createUserTable('users_61');
+		await push({ users });
+
+		const result = await db.insert(users).values([{ name: 'John' }, { name: 'John1' }]).$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			id: number;
+		}[]>();
+
+		expect(result).toStrictEqual([{ id: 1 }, { id: 2 }]);
+	});
+
+	test.concurrent('insert $returningId: $default as primary key', async ({ db, push }) => {
+		const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
+		let iterator = 0;
+
+		const usersTableDefFn = mysqlTable('users_default_fn_1', {
+			customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
+				const value = uniqueKeys[iterator]!;
+				iterator++;
+				return value;
+			}),
+			name: text('name').notNull(),
+		});
+
+		await push({ usersTableDefFn });
+
+		const result = await db.insert(usersTableDefFn).values([{ name: 'John' }, { name: 'John1' }])
+			//    ^?
+			.$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			customId: string;
+		}[]>();
+
+		expect(result).toStrictEqual([{ customId: 'ao865jf3mcmkfkk8o5ri495z' }, {
+			customId: 'dyqs529eom0iczo2efxzbcut',
+		}]);
+	});
+
+	test.concurrent('insert $returningId: $default as primary key with value', async ({ db, push }) => {
+		const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
+		let iterator = 0;
+
+		const usersTableDefFn = mysqlTable('users_default_fn_2', {
+			customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
+				const value = uniqueKeys[iterator]!;
+				iterator++;
+				return value;
+			}),
+			name: text('name').notNull(),
+		});
+
+		await push({ usersTableDefFn });
+
+		const result = await db.insert(usersTableDefFn).values([{ name: 'John', customId: 'test' }, { name: 'John1' }])
+			//    ^?
+			.$returningId();
+
+		expectTypeOf(result).toEqualTypeOf<{
+			customId: string;
+		}[]>();
+
+		expect(result).toStrictEqual([{ customId: 'test' }, { customId: 'ao865jf3mcmkfkk8o5ri495z' }]);
+	});
+
+	test.concurrent('$count separate', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_1');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable);
+
+		expect(count).toStrictEqual(4);
+	});
+
+	test.concurrent('$count embedded', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_2');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		expect(count).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+	});
+
+	test.concurrent('$count separate reuse', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_3');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.$count(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		expect(count1).toStrictEqual(4);
+		expect(count2).toStrictEqual(5);
+		expect(count3).toStrictEqual(6);
+	});
+
+	test.concurrent('$count embedded reuse', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_4');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = db.select({
+			count: db.$count(countTestTable),
+		}).from(countTestTable);
+
+		const count1 = await count;
+
+		await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+		const count2 = await count;
+
+		await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+		const count3 = await count;
+
+		expect(count1).toStrictEqual([
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+			{ count: 4 },
+		]);
+		expect(count2).toStrictEqual([
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+			{ count: 5 },
+		]);
+		expect(count3).toStrictEqual([
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+			{ count: 6 },
+		]);
+	});
+
+	test.concurrent('$count separate with filters', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_5');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
+
+		expect(count).toStrictEqual(3);
+	});
+
+	test.concurrent('$count embedded with filters', async ({ db, push }) => {
+		const countTestTable = createCountTestTable('count_test_6');
+
+		await push({ countTestTable });
+
+		await db.insert(countTestTable).values([
+			{ id: 1, name: 'First' },
+			{ id: 2, name: 'Second' },
+			{ id: 3, name: 'Third' },
+			{ id: 4, name: 'Fourth' },
+		]);
+
+		const count = await db.select({
+			count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+		}).from(countTestTable);
+
+		expect(count).toStrictEqual([
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+			{ count: 3 },
+		]);
+	});
+
+	test.concurrent('limit 0', async ({ db, push }) => {
+		const users = createUserTable('users_62');
+		await push({ users });
+		await db.insert(users).values({ name: 'John' });
+
+		const result = await db
+			.select()
+			.from(users)
+			.limit(0);
+
+		expect(result).toEqual([]);
+	});
+
+	test.concurrent('limit -1', async ({ db, push }) => {
+		const users = createUserTable('users_631');
+		await push({ users });
+		await db.insert(users).values({ name: 'John' });
+
+		const result = await db
+			.select()
+			.from(users)
+			.limit(-1);
+
+		expect(result.length).toBeGreaterThan(0);
+	});
+
+	test.concurrent('cross join', async ({ db, push, seed }) => {
+		const users = createUserTable('users_63');
+		const cities = createCitiesTable('cities_63');
+
+		await push({ users, cities });
+		await seed({ users, cities }, (funcs) => ({
+			users: { count: 2, columns: { name: funcs.firstName() } },
+			cities: { count: 2, columns: { name: funcs.city() } },
+		}));
+
+		const result = await db
+			.select({
+				user: users.name,
+				city: cities.name,
+			})
+			.from(users)
+			.crossJoin(cities)
+			.orderBy(users.name, cities.name);
+
+		expect(result).toStrictEqual([
+			{ city: 'Hoogvliet', user: 'Agripina' },
+			{ city: 'South Milwaukee', user: 'Agripina' },
+			{ city: 'Hoogvliet', user: 'Candy' },
+			{ city: 'South Milwaukee', user: 'Candy' },
+		]);
+	});
+
+	test.concurrent('left join (lateral)', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_64');
+		const users2 = createUsers2Table('users2_64', cities);
+
+		await push({ cities, users2 });
+
+		await db
+			.insert(cities)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+		await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const sq = db
+			.select({
+				userId: users2.id,
+				userName: users2.name,
+				cityId: users2.cityId,
+			})
+			.from(users2)
+			.where(eq(users2.cityId, cities.id))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: cities.id,
+				cityName: cities.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(cities)
+			.leftJoinLateral(sq, sql`true`);
+
+		expect(res).toStrictEqual([
+			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+			{ cityId: 2, cityName: 'London', userId: null, userName: null },
+		]);
+	});
+
+	test.concurrent('inner join (lateral)', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_65');
+		const users2 = createUsers2Table('users2_65', cities);
+
+		await push({ cities, users2 });
+
+		await db.insert(cities).values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+		await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+		const sq = db
+			.select({
+				userId: users2.id,
+				userName: users2.name,
+				cityId: users2.cityId,
+			})
+			.from(users2)
+			.where(eq(users2.cityId, cities.id))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: cities.id,
+				cityName: cities.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(cities)
+			.innerJoinLateral(sq, sql`true`);
+
+		expect(res).toStrictEqual([
+			{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+		]);
+	});
+
+	test.concurrent('cross join (lateral)', async ({ db, push }) => {
+		const cities = createCitiesTable('cities_66');
+		const users2 = createUsers2Table('users2_66', cities);
+
+		await push({ cities, users2 });
+
+		await db
+			.insert(cities)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }, { id: 3, name: 'Berlin' }]);
+
+		await db.insert(users2).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }, {
+			name: 'Patrick',
+			cityId: 2,
+		}]);
+
+		const sq = db
+			.select({
+				userId: users2.id,
+				userName: users2.name,
+				cityId: users2.cityId,
+			})
+			.from(users2)
+			.where(not(like(cities.name, 'L%')))
+			.as('sq');
+
+		const res = await db
+			.select({
+				cityId: cities.id,
+				cityName: cities.name,
+				userId: sq.userId,
+				userName: sq.userName,
+			})
+			.from(cities)
+			.crossJoinLateral(sq)
+			.orderBy(cities.id, sq.userId);
+
+		expect(res).toStrictEqual([
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 1,
+				userName: 'John',
+			},
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 2,
+				userName: 'Jane',
+			},
+			{
+				cityId: 1,
+				cityName: 'Paris',
+				userId: 3,
+				userName: 'Patrick',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 1,
+				userName: 'John',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 2,
+				userName: 'Jane',
+			},
+			{
+				cityId: 3,
+				cityName: 'Berlin',
+				userId: 3,
+				userName: 'Patrick',
+			},
+		]);
+	});
+
+	test.concurrent('RQB v2 simple find first - no rows', async ({ db }) => {
+		const result = await db.query.empty.findFirst();
+		expect(result).toStrictEqual(undefined);
+	});
+
+	test.concurrent('RQB v2 simple find first - multiple rows', async ({ db }) => {
+		const result = await db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: new Date(120000),
+			name: 'Second',
+		});
+	});
+
+	test.concurrent('RQB v2 simple find first - with relation', async ({ db }) => {
+		const result = await db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual({
+			id: 1,
+			createdAt: new Date(120000),
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: new Date(120000),
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: new Date(120000),
+				content: 'Has message this time',
+			}],
+		});
+	});
+
+	test('RQB v2 simple find first - placeholders', async ({ db }) => {
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual({
+			id: 2,
+			createdAt: new Date(120000),
+			name: 'Second',
+		});
+	});
+
+	test('RQB v2 simple find many - no rows', async ({ db }) => {
+		const result = await db.query.empty.findMany();
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test('RQB v2 simple find many - multiple rows', async ({ db }) => {
+		const result = await db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: new Date(120000),
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: new Date(120000),
+			name: 'First',
+		}]);
+	});
+
+	test('RQB v2 simple find many - with relation', async ({ db }) => {
+		const result = await db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 1,
+			userId: 1,
+			createdAt: new Date(120000),
+			content: null,
+			author: {
+				id: 1,
+				createdAt: new Date(120000),
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: new Date(120000),
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: new Date(120000),
+				name: 'First',
+			},
+		}]);
+	});
+
+	test('RQB v2 simple find many - placeholders', async ({ db }) => {
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).toStrictEqual([{
+			id: 2,
+			createdAt: new Date(120000),
+			name: 'Second',
+		}]);
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4891
+	test('RQB v2 find many - bigint precision loss', async ({ createDB, push }) => {
+		const products = mysqlTable(
+			'products_1',
+			{
+				id: bigint({ mode: 'bigint', unsigned: true }).notNull(),
+			},
+			(table) => [primaryKey({ columns: [table.id] })],
+		);
+
+		const prices = mysqlTable(
+			'prices_1',
+			{
+				id: bigint({ mode: 'bigint', unsigned: true }).notNull(),
+				productId: bigint('product_id', { mode: 'bigint', unsigned: true })
+					.notNull()
+					.references(() => products.id, { onDelete: 'cascade' }),
+			},
+			(table) => [primaryKey({ columns: [table.id] })],
+		);
+
+		const schema = { products, prices };
+		await push(schema);
+
+		const db = createDB({
+			schema,
+			cb: (r) => ({
+				// prices: {
+				// 	product: r.one.products({
+				// 		from: r.prices.productId,
+				// 		to: r.products.id,
+				// 	}),
+				// },
+				products: {
+					price: r.many.prices({
+						from: r.products.id,
+						to: r.prices.productId,
+					}),
+				},
+			}),
+		});
+
+		await db.insert(products).values({ id: 219701375175495680n });
+		await db.insert(prices).values({ id: 219701380107997184n, productId: 219701375175495680n });
+
+		const result = await db.query.products.findMany({
+			columns: {
+				id: true,
+			},
+			with: {
+				price: {
+					columns: {
+						id: true,
+					},
+				},
+			},
+		});
+
+		expect(result).toStrictEqual([{
+			id: 219701375175495680n,
+			price: [
+				{
+					id: 219701380107997184n,
+				},
+			],
+		}]);
+	});
+
+	test('RQB v2 transaction find first - no rows', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.empty.findFirst();
+
+			expect(result).toStrictEqual(undefined);
+		});
+	});
+
+	test('RQB v2 transaction find first - multiple rows', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: new Date(120000),
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - with relation', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: new Date(120000),
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: new Date(120000),
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: new Date(120000),
+					content: 'Has message this time',
+				}],
+			});
+		});
+	});
+
+	test('RQB v2 transaction find first - placeholders', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: new Date(120000),
+				name: 'Second',
+			});
+		});
+	});
+
+	test('RQB v2 transaction find many - no rows', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.empty.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+	});
+
+	test('RQB v2 transaction find many - multiple rows', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: new Date(120000),
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: new Date(120000),
+				name: 'First',
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - with relation', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const result = await db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: new Date(120000),
+				content: null,
+				author: {
+					id: 1,
+					createdAt: new Date(120000),
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: new Date(120000),
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: new Date(120000),
+					name: 'First',
+				},
+			}]);
+		});
+	});
+
+	test('RQB v2 transaction find many - placeholders', async ({ db }) => {
+		await db.transaction(async (db) => {
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: new Date(120000),
+				name: 'Second',
+			}]);
+		});
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-7.ts b/integration-tests/tests/mysql/mysql-common-7.ts
new file mode 100644
index 0000000000..686bb5d69e
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-7.ts
@@ -0,0 +1,1025 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { and, asc, count, eq, inArray, sql } from 'drizzle-orm';
+import {
+	bigint,
+	getTableConfig,
+	index,
+	int,
+	mysqlTable,
+	mysqlView,
+	primaryKey,
+	serial,
+	text,
+	timestamp,
+	varchar,
+} from 'drizzle-orm/mysql-core';
+import { expect, expectTypeOf } from 'vitest';
+import type { Test } from './instrumentation';
+import { allTypesTable, createCitiesTable, createUsers2Table } from './schema2';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test('select from a many subquery', async ({ db, push }) => {
+		const citiesTable = createCitiesTable('cities_many_subquery');
+		const users2Table = createUsers2Table('users_2_many_subquery', citiesTable);
+
+		await push({ citiesTable, users2Table });
+
+		await db.insert(citiesTable)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+		await db.insert(users2Table).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 2 },
+		]);
+
+		const res = await db.select({
+			population: db.select({ count: count().as('count') }).from(users2Table).where(
+				eq(users2Table.cityId, citiesTable.id),
+			).as(
+				'population',
+			),
+			name: citiesTable.name,
+		}).from(citiesTable);
+
+		expectTypeOf(res).toEqualTypeOf<
+			{
+				population: number;
+				name: string;
+			}[]
+		>();
+
+		expect(res).toStrictEqual([{
+			population: 1,
+			name: 'Paris',
+		}, {
+			population: 2,
+			name: 'London',
+		}]);
+	});
+
+	test('select from a one subquery', async ({ db, push }) => {
+		const citiesTable = createCitiesTable('cities_one_subquery');
+		const users2Table = createUsers2Table('users_2_one_subquery', citiesTable);
+
+		await push({ citiesTable, users2Table });
+
+		await db.insert(citiesTable)
+			.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+		await db.insert(users2Table).values([
+			{ name: 'John', cityId: 1 },
+			{ name: 'Jane', cityId: 2 },
+			{ name: 'Jack', cityId: 2 },
+		]);
+
+		const res = await db.select({
+			cityName: db.select({ name: citiesTable.name }).from(citiesTable).where(eq(users2Table.cityId, citiesTable.id))
+				.as(
+					'cityName',
+				),
+			name: users2Table.name,
+		}).from(users2Table);
+
+		expectTypeOf(res).toEqualTypeOf<
+			{
+				cityName: string;
+				name: string;
+			}[]
+		>();
+
+		expect(res).toStrictEqual([{
+			cityName: 'Paris',
+			name: 'John',
+		}, {
+			cityName: 'London',
+			name: 'Jane',
+		}, {
+			cityName: 'London',
+			name: 'Jack',
+		}]);
+	});
+
+	test('test $onUpdateFn and $onUpdate works with sql value', async ({ db, push }) => {
+		const users = mysqlTable('users_on_update', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			updatedAt: timestamp('updated_at', {
+				fsp: 6,
+			})
+				.notNull()
+				.$onUpdate(() => sql`current_timestamp`),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values({
+			name: 'John',
+		});
+		const insertResp = await db.select({ updatedAt: users.updatedAt }).from(users);
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+
+		const now = Date.now();
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+		await db.update(users).set({
+			name: 'John',
+		});
+		const updateResp = await db.select({ updatedAt: users.updatedAt }).from(users);
+
+		expect(insertResp[0]?.updatedAt.getTime() ?? 0).lessThan(now);
+		expect(updateResp[0]?.updatedAt.getTime() ?? 0).greaterThan(now);
+	});
+
+	test.concurrent('all types', async ({ db, push }) => {
+		await push({ allTypesTable });
+
+		await db.insert(allTypesTable).values({
+			serial: 1,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			datetime: new Date('2025-03-12T01:32:42.000Z'),
+			datetimeStr: '2025-03-12 01:32:41',
+			decimal: '47521',
+			decimalNum: 9007199254740991,
+			decimalBig: 5044565289845416380n,
+			double: 15.35325689124218,
+			enum: 'enV1',
+			float: 1.048596,
+			real: 1.048596,
+			text: 'C4-',
+			int: 621,
+			json: {
+				str: 'strval',
+				arr: ['str', 10],
+			},
+			medInt: 560,
+			smallInt: 14,
+			time: '04:13:22',
+			timestamp: new Date('2025-03-12T01:32:42.000Z'),
+			timestampStr: '2025-03-12 01:32:41',
+			tinyInt: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+			blob: Buffer.from('string'),
+			longblob: Buffer.from('string'),
+			mediumblob: Buffer.from('string'),
+			tinyblob: Buffer.from('string'),
+			stringblob: 'string',
+			stringlongblob: 'string',
+			stringmediumblob: 'string',
+			stringtinyblob: 'string',
+		});
+
+		const rawRes = await db.select().from(allTypesTable);
+
+		type ExpectedType = {
+			serial: number;
+			bigint53: number | null;
+			bigint64: bigint | null;
+			bigintString: string | null;
+			binary: string | null;
+			boolean: boolean | null;
+			char: string | null;
+			date: Date | null;
+			dateStr: string | null;
+			datetime: Date | null;
+			datetimeStr: string | null;
+			decimal: string | null;
+			decimalNum: number | null;
+			decimalBig: bigint | null;
+			double: number | null;
+			float: number | null;
+			int: number | null;
+			json: unknown;
+			medInt: number | null;
+			smallInt: number | null;
+			real: number | null;
+			text: string | null;
+			time: string | null;
+			timestamp: Date | null;
+			timestampStr: string | null;
+			tinyInt: number | null;
+			varbin: string | null;
+			varchar: string | null;
+			year: number | null;
+			enum: 'enV1' | 'enV2' | null;
+			blob: Buffer | null;
+			tinyblob: Buffer | null;
+			mediumblob: Buffer | null;
+			longblob: Buffer | null;
+			stringblob: string | null;
+			stringtinyblob: string | null;
+			stringmediumblob: string | null;
+			stringlongblob: string | null;
+		}[];
+
+		const expectedRes: ExpectedType = [
+			{
+				serial: 1,
+				bigint53: 9007199254740991,
+				bigint64: 5044565289845416380n,
+				bigintString: '5044565289845416380',
+				binary: '1',
+				boolean: true,
+				char: 'c',
+				date: new Date('2025-03-12T00:00:00.000Z'),
+				dateStr: '2025-03-12',
+				datetime: new Date('2025-03-12T01:32:42.000Z'),
+				datetimeStr: '2025-03-12 01:32:41',
+				decimal: '47521',
+				decimalNum: 9007199254740991,
+				decimalBig: 5044565289845416380n,
+				double: 15.35325689124218,
+				float: 1.048596,
+				int: 621,
+				json: { arr: ['str', 10], str: 'strval' },
+				medInt: 560,
+				smallInt: 14,
+				real: 1.048596,
+				text: 'C4-',
+				time: '04:13:22',
+				timestamp: new Date('2025-03-12T01:32:42.000Z'),
+				timestampStr: '2025-03-12 01:32:41',
+				tinyInt: 7,
+				varbin: '1010110101001101',
+				varchar: 'VCHAR',
+				year: 2025,
+				enum: 'enV1',
+				blob: Buffer.from('string'),
+				longblob: Buffer.from('string'),
+				mediumblob: Buffer.from('string'),
+				tinyblob: Buffer.from('string'),
+				stringblob: 'string',
+				stringlongblob: 'string',
+				stringmediumblob: 'string',
+				stringtinyblob: 'string',
+			},
+		];
+
+		expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+		expect(rawRes).toStrictEqual(expectedRes);
+	});
+
+	test.concurrent('insert into ... select', async ({ db, push }) => {
+		const notifications = mysqlTable('notifications', {
+			id: int('id').primaryKey().autoincrement(),
+			sentAt: timestamp('sent_at').notNull().defaultNow(),
+			message: text('message').notNull(),
+		});
+		const users = mysqlTable('users_64', {
+			id: int('id').primaryKey().autoincrement(),
+			name: text('name').notNull(),
+		});
+		const userNotications = mysqlTable('user_notifications', {
+			userId: int('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+			notificationId: int('notification_id').notNull().references(() => notifications.id, { onDelete: 'cascade' }),
+		}, (t) => [primaryKey({ columns: [t.userId, t.notificationId] })]);
+
+		await push({ notifications, users, userNotications });
+
+		await db
+			.insert(notifications)
+			.values({ message: 'You are one of the 3 lucky winners!' });
+		const newNotification = await db
+			.select({ id: notifications.id })
+			.from(notifications)
+			.then((result) => result[0]);
+
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		await db
+			.insert(userNotications)
+			.select(
+				db
+					.select({
+						userId: users.id,
+						notificationId: sql`(${newNotification!.id})`.as('notification_id'),
+					})
+					.from(users)
+					.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+					.orderBy(asc(users.id)),
+			);
+		const sentNotifications = await db.select().from(userNotications);
+
+		expect(sentNotifications).toStrictEqual([
+			{ userId: 1, notificationId: newNotification!.id },
+			{ userId: 3, notificationId: newNotification!.id },
+			{ userId: 5, notificationId: newNotification!.id },
+		]);
+	});
+
+	test.concurrent('insert into ... select with keys in different order', async ({ db, push }) => {
+		const users1 = mysqlTable('users_65', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+		const users2 = mysqlTable('users_66', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users1, users2 });
+
+		await db.insert(users2).values({ id: 1, name: 'First' });
+		await db.insert(users1).select(
+			db
+				.select({
+					name: users2.name,
+					id: users2.id,
+				})
+				.from(users2),
+		);
+		const res = await db.select().from(users1);
+
+		expect(res).toStrictEqual([{
+			id: 1,
+			name: 'First',
+		}]);
+	});
+
+	test.concurrent('insert into ... select with generated column', async ({ db, push }) => {
+		const users1 = mysqlTable('users1_iswgc', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+		const users2 = mysqlTable('users2_iswgc', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users1, users2 });
+
+		await db.insert(users1).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+		]);
+
+		await db.insert(users2).select(db.select({ name: users1.name }).from(users1));
+		const result1 = await db.select().from(users2);
+
+		expect(result1).toStrictEqual([
+			{ id: 1, name: 'Alice' },
+			{ id: 2, name: 'Bob' },
+			{ id: 3, name: 'Charlie' },
+		]);
+
+		// @ts-expect-error
+		expect(() => db.insert(users2).select(db.select({ name: users1.name, unknown: users1.id }).from(users1)))
+			.toThrowError();
+	});
+
+	test.concurrent('MySqlTable :: select with `use index` hint', async ({ db, push }) => {
+		const users = mysqlTable('users_67', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		}, () => [usersTableNameIndex]);
+		const usersTableNameIndex = index('users_name_index_67').on(users.name);
+
+		await push({ users });
+
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		const result = await db.select()
+			.from(users, {
+				useIndex: [usersTableNameIndex],
+			})
+			.where(eq(users.name, 'David'));
+
+		expect(result).toHaveLength(1);
+		expect(result).toEqual([{ id: 4, name: 'David' }]);
+	});
+
+	test.concurrent('MySqlTable :: select with `use index` hint on 1 index', async ({ db, push }) => {
+		const users = mysqlTable('users_68', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		}, () => [usersTableNameIndex]);
+		const usersTableNameIndex = index('users_name_index_68').on(users.name);
+
+		await push({ users });
+
+		const query = db.select()
+			.from(users, {
+				useIndex: usersTableNameIndex,
+			})
+			.where(eq(users.name, 'David'))
+			.toSQL();
+
+		expect(query.sql).to.include('USE INDEX (`users_name_index_68`)');
+	});
+
+	test.concurrent('MySqlTable :: select with `use index` hint on multiple indexes', async ({ db, push }) => {
+		const users = mysqlTable('users_69', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+			age: int('age').notNull(),
+		}, () => [usersTableNameIndex, usersTableAgeIndex]);
+		const usersTableNameIndex = index('users_name_index_69').on(users.name);
+		const usersTableAgeIndex = index('users_age_index_69').on(users.age);
+
+		await push({ users });
+
+		const query = db.select()
+			.from(users, {
+				useIndex: [usersTableNameIndex, usersTableAgeIndex],
+			})
+			.where(eq(users.name, 'David'))
+			.toSQL();
+
+		expect(query.sql).to.include('USE INDEX (`users_name_index_69`, `users_age_index_69`)');
+	});
+
+	test.concurrent('MySqlTable :: select with `use index` hint on not existed index', async ({ db, push }) => {
+		const users = mysqlTable('users_70', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		}, () => [usersTableNameIndex]);
+		const usersTableNameIndex = index('users_name_index_70').on(users.name);
+
+		await push({ users });
+
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		await expect((async () => {
+			return await db.select()
+				.from(users, {
+					useIndex: ['some_other_index'],
+				})
+				.where(eq(users.name, 'David'));
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent(
+		'MySqlTable :: select with `use index` + `force index` incompatible hints',
+		async ({ db, push }) => {
+			const users = mysqlTable('users_71', {
+				id: serial('id').primaryKey(),
+				name: varchar('name', { length: 100 }).notNull(),
+				age: int('age').notNull(),
+			}, () => [usersTableNameIndex, usersTableAgeIndex]);
+			const usersTableNameIndex = index('users_name_index_71').on(users.name);
+			const usersTableAgeIndex = index('users_age_index_71').on(users.age);
+
+			await push({ users });
+
+			await db.insert(users).values([
+				{ name: 'Alice', age: 18 },
+				{ name: 'Bob', age: 19 },
+				{ name: 'Charlie', age: 20 },
+				{ name: 'David', age: 21 },
+				{ name: 'Eve', age: 22 },
+			]);
+
+			await expect((async () => {
+				return await db.select()
+					.from(users, {
+						useIndex: [usersTableNameIndex],
+						forceIndex: [usersTableAgeIndex],
+					})
+					.where(eq(users.name, 'David'));
+			})()).rejects.toThrowError();
+		},
+	);
+
+	test.concurrent('MySqlTable :: select with join `use index` hint', async ({ db, push }) => {
+		const users = mysqlTable('users_72', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_72', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_72').on(posts.userId);
+
+		await push({ users, posts });
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		await db.insert(posts).values([
+			{ text: 'Alice post', userId: 1 },
+			{ text: 'Bob post', userId: 2 },
+			{ text: 'Charlie post', userId: 3 },
+			{ text: 'David post', userId: 4 },
+			{ text: 'Eve post', userId: 5 },
+		]);
+
+		const result = await db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.leftJoin(posts, eq(users.id, posts.userId), {
+				useIndex: [postsTableUserIdIndex],
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			));
+
+		expect(result).toHaveLength(1);
+		expect(result).toEqual([{ userId: 4, name: 'David', postId: 4, text: 'David post' }]);
+	});
+
+	test.concurrent('MySqlTable :: select with join `use index` hint on 1 index', async ({ db, push }) => {
+		const users = mysqlTable('users_73', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_73', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_73').on(posts.userId);
+
+		await push({ users, posts });
+
+		const query = db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.leftJoin(posts, eq(users.id, posts.userId), {
+				useIndex: postsTableUserIdIndex,
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			)).toSQL();
+
+		expect(query.sql).to.include('USE INDEX (`posts_user_id_index_73`)');
+	});
+
+	test.concurrent('MySqlTable :: select with cross join `use index` hint', async ({ db, push }) => {
+		const users = mysqlTable('users_74', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_74', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_74').on(posts.userId);
+
+		await push({ users, posts });
+
+		await db.insert(users).values([
+			{ id: 1, name: 'Alice' },
+			{ id: 2, name: 'Bob' },
+		]);
+
+		await db.insert(posts).values([
+			{ id: 1, text: 'Alice post', userId: 1 },
+			{ id: 2, text: 'Bob post', userId: 2 },
+		]);
+
+		const result = await db.select()
+			.from(users)
+			.crossJoin(posts, {
+				useIndex: [postsTableUserIdIndex],
+			})
+			.orderBy(users.id, posts.id);
+
+		expect(result).toStrictEqual([{
+			users_74: { id: 1, name: 'Alice' },
+			posts_74: { id: 1, text: 'Alice post', userId: 1 },
+		}, {
+			users_74: { id: 1, name: 'Alice' },
+			posts_74: { id: 2, text: 'Bob post', userId: 2 },
+		}, {
+			users_74: { id: 2, name: 'Bob' },
+			posts_74: { id: 1, text: 'Alice post', userId: 1 },
+		}, {
+			users_74: { id: 2, name: 'Bob' },
+			posts_74: { id: 2, text: 'Bob post', userId: 2 },
+		}]);
+	});
+
+	test.concurrent('MySqlTable :: select with cross join `use index` hint on 1 index', async ({ db, push }) => {
+		const users = mysqlTable('users_75', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_75', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_75').on(posts.userId);
+
+		await push({ users, posts });
+
+		const query = db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.crossJoin(posts, {
+				useIndex: postsTableUserIdIndex,
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			)).toSQL();
+
+		expect(query.sql).to.include('USE INDEX (`posts_user_id_index_75`)');
+	});
+
+	test.concurrent('MySqlTable :: select with join `use index` hint on multiple indexes', async ({ db, push }) => {
+		const users = mysqlTable('users_76', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_76', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex, postsTableTextIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_76').on(posts.userId);
+		const postsTableTextIndex = index('posts_text_index_76').on(posts.text);
+
+		await push({ users, posts });
+
+		const query = db.select({
+			userId: users.id,
+			name: users.name,
+			postId: posts.id,
+			text: posts.text,
+		})
+			.from(users)
+			.leftJoin(posts, eq(users.id, posts.userId), {
+				useIndex: [postsTableUserIdIndex, postsTableTextIndex],
+			})
+			.where(and(
+				eq(users.name, 'David'),
+				eq(posts.text, 'David post'),
+			)).toSQL();
+
+		expect(query.sql).to.include('USE INDEX (`posts_user_id_index_76`, `posts_text_index_76`)');
+	});
+
+	test.concurrent('MySqlTable :: select with join `use index` hint on not existed index', async ({ db, push }) => {
+		const users = mysqlTable('users_77', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_77', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_77').on(posts.userId);
+
+		await push({ users, posts });
+
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		await db.insert(posts).values([
+			{ text: 'Alice post', userId: 1 },
+			{ text: 'Bob post', userId: 2 },
+			{ text: 'Charlie post', userId: 3 },
+			{ text: 'David post', userId: 4 },
+			{ text: 'Eve post', userId: 5 },
+		]);
+
+		await expect((async () => {
+			return await db.select({
+				userId: users.id,
+				name: users.name,
+				postId: posts.id,
+				text: posts.text,
+			})
+				.from(users)
+				.leftJoin(posts, eq(users.id, posts.userId), {
+					useIndex: ['some_other_index'],
+				})
+				.where(and(
+					eq(users.name, 'David'),
+					eq(posts.text, 'David post'),
+				));
+		})()).rejects.toThrowError();
+	});
+
+	test.concurrent(
+		'MySqlTable :: select with join `use index` + `force index` incompatible hints',
+		async ({ db, push }) => {
+			const users = mysqlTable('users_78', {
+				id: serial('id').primaryKey(),
+				name: varchar('name', { length: 100 }).notNull(),
+			});
+
+			const posts = mysqlTable('posts_78', {
+				id: serial('id').primaryKey(),
+				text: varchar('text', { length: 100 }).notNull(),
+				userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, {
+					onDelete: 'cascade',
+				})
+					.notNull(),
+			}, () => [postsTableUserIdIndex, postsTableTextIndex]);
+			const postsTableUserIdIndex = index('posts_user_id_index_78').on(posts.userId);
+			const postsTableTextIndex = index('posts_text_index_78').on(posts.text);
+
+			await push({ users, posts });
+
+			await db.insert(users).values([
+				{ name: 'Alice' },
+				{ name: 'Bob' },
+				{ name: 'Charlie' },
+				{ name: 'David' },
+				{ name: 'Eve' },
+			]);
+
+			await db.insert(posts).values([
+				{ text: 'Alice post', userId: 1 },
+				{ text: 'Bob post', userId: 2 },
+				{ text: 'Charlie post', userId: 3 },
+				{ text: 'David post', userId: 4 },
+				{ text: 'Eve post', userId: 5 },
+			]);
+
+			await expect((async () => {
+				return await db.select({
+					userId: users.id,
+					name: users.name,
+					postId: posts.id,
+					text: posts.text,
+				})
+					.from(users)
+					.leftJoin(posts, eq(users.id, posts.userId), {
+						useIndex: [postsTableUserIdIndex],
+						forceIndex: [postsTableTextIndex],
+					})
+					.where(and(
+						eq(users.name, 'David'),
+						eq(posts.text, 'David post'),
+					));
+			})()).rejects.toThrowError();
+		},
+	);
+
+	test.concurrent('MySqlTable :: select with Subquery join `use index`', async ({ db, push }) => {
+		const users = mysqlTable('users_79', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_79', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_79').on(posts.userId);
+
+		await push({ users, posts });
+
+		await db.insert(users).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+			{ name: 'David' },
+			{ name: 'Eve' },
+		]);
+
+		await db.insert(posts).values([
+			{ text: 'Alice post', userId: 1 },
+			{ text: 'Bob post', userId: 2 },
+			{ text: 'Charlie post', userId: 3 },
+			{ text: 'David post', userId: 4 },
+			{ text: 'Eve post', userId: 5 },
+		]);
+
+		const sq = db.select().from(posts, { useIndex: [postsTableUserIdIndex] }).where(eq(posts.userId, 1)).as('sq');
+
+		const result = await db.select({
+			userId: users.id,
+			name: users.name,
+			postId: sq.id,
+			text: sq.text,
+		})
+			.from(users)
+			.leftJoin(sq, eq(users.id, sq.userId))
+			.where(eq(users.name, 'Alice'));
+
+		expect(result).toHaveLength(1);
+		expect(result).toEqual([{ userId: 1, name: 'Alice', postId: 1, text: 'Alice post' }]);
+	});
+
+	test.concurrent('MySqlTable :: select with Subquery join with `use index` in join', async ({ db, push }) => {
+		const users = mysqlTable('users_80', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		});
+
+		const posts = mysqlTable('posts_80', {
+			id: serial('id').primaryKey(),
+			text: varchar('text', { length: 100 }).notNull(),
+			userId: bigint('user_id', { mode: 'number', unsigned: true }).references(() => users.id, { onDelete: 'cascade' })
+				.notNull(),
+		}, () => [postsTableUserIdIndex]);
+		const postsTableUserIdIndex = index('posts_user_id_index_80').on(posts.userId);
+
+		await push({ users, posts });
+
+		const sq = db.select().from(posts).where(eq(posts.userId, 1)).as('sq');
+
+		const query = db.select({
+			userId: users.id,
+			name: users.name,
+			postId: sq.id,
+			text: sq.text,
+		})
+			.from(users)
+			// @ts-expect-error
+			.leftJoin(sq, eq(users.id, sq.userId, { useIndex: [postsTableUserIdIndex] }))
+			.where(eq(users.name, 'Alice'))
+			.toSQL();
+
+		expect(query.sql).not.include('USE INDEX');
+	});
+
+	test.concurrent('View :: select with `use index` hint', async ({ db, push }) => {
+		const users = mysqlTable('users_81', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		}, () => [usersTableNameIndex]);
+
+		const usersTableNameIndex = index('users_name_index_81').on(users.name);
+
+		const usersView = mysqlView('users_view_81').as((qb) => qb.select().from(users));
+
+		await push({ users, usersView });
+
+		// @ts-expect-error
+		const query = db.select().from(usersView, {
+			useIndex: [usersTableNameIndex],
+		}).toSQL();
+
+		expect(query.sql).not.include('USE INDEX');
+	});
+
+	test.concurrent('Subquery :: select with `use index` hint', async ({ db, push }) => {
+		const users = mysqlTable('users_82', {
+			id: serial('id').primaryKey(),
+			name: varchar('name', { length: 100 }).notNull(),
+		}, () => [usersTableNameIndex]);
+		const usersTableNameIndex = index('users_name_index_82').on(users.name);
+
+		await push({ users });
+
+		const sq = db.select().from(users).as('sq');
+
+		// @ts-expect-error
+		const query = db.select().from(sq, {
+			useIndex: [usersTableNameIndex],
+		}).toSQL();
+
+		expect(query.sql).not.include('USE INDEX');
+	});
+
+	test.concurrent('sql operator as cte', async ({ db, push }) => {
+		const users = mysqlTable('users_83', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+		await db.insert(users).values([
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+
+		const sq1 = db.$with('sq', {
+			userId: users.id,
+			data: {
+				name: users.name,
+			},
+		}).as(sql`select * from ${users} where ${users.name} = 'John'`);
+		const result1 = await db.with(sq1).select().from(sq1);
+
+		const sq2 = db.$with('sq', {
+			userId: users.id,
+			data: {
+				name: users.name,
+			},
+		}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+		const result2 = await db.with(sq2).select().from(sq1);
+
+		expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
+		expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+	});
+
+	test.concurrent('sql.Aliased in cte', async ({ db, push }) => {
+		const users = mysqlTable('users_109_sqla', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+		await db.insert(users).values([
+			{ id: 1, name: 'John' },
+			{ id: 2, name: 'Jane' },
+		]);
+
+		const sq1 = db.$with('sq1').as((qb) =>
+			qb.select({
+				aliased: sql`count(*)`.mapWith(Number).as('alias'),
+			}).from(users)
+		);
+		const sq2 = db.$with('sq2').as((qb) =>
+			qb.select({
+				aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+			}).from(users)
+		);
+
+		const result = await db.with(sq1, sq2).select({
+			count: sq1.aliased,
+			sum: sq2.aliased,
+		}).from(sq1).crossJoin(sq2);
+
+		expect(result).toEqual([{ count: 2, sum: 3 }]);
+
+		const result2 = await db.with(sq1).select({
+			count: sq1.aliased,
+		}).from(sq1).groupBy(sq1.aliased).orderBy(sq1.aliased);
+
+		expect(result2).toEqual([{ count: 2 }]);
+	});
+
+	test.concurrent('contraint names config', async ({ db, push }) => {
+		const users = mysqlTable('users_84', {
+			id: int('id').unique(),
+			id1: int('id1').unique('custom_name'),
+		});
+
+		await push({ users });
+
+		const tableConf = getTableConfig(users);
+
+		expect(tableConf.columns.find((it) => it.name === 'id')!.uniqueName).toBe(undefined);
+		expect(tableConf.columns.find((it) => it.name === 'id1')!.uniqueName).toBe('custom_name');
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-8.ts b/integration-tests/tests/mysql/mysql-common-8.ts
new file mode 100644
index 0000000000..7914a5ed50
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql-common-8.ts
@@ -0,0 +1,5271 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import {
+	and,
+	asc,
+	DrizzleQueryError,
+	eq,
+	getColumns,
+	getTableColumns,
+	gt,
+	inArray,
+	is,
+	isNull,
+	make$ReturningResponseMapper,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	max,
+	Name,
+	sql,
+} from 'drizzle-orm';
+import {
+	alias,
+	bigint,
+	boolean,
+	customType,
+	datetime,
+	index,
+	int,
+	MySqlAsyncSession,
+	MySqlDialect,
+	mysqlEnum,
+	mysqlTable,
+	mysqlTableCreator,
+	mysqlView,
+	serial,
+	text,
+	timestamp,
+	unionAll,
+	unique,
+	varchar,
+} from 'drizzle-orm/mysql-core';
+import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
+import { TiDBServerlessDatabase } from 'drizzle-orm/tidb-serverless';
+import { expect } from 'vitest';
+import { expectTypeOf } from 'vitest';
+import type { Test } from './instrumentation';
+import { allTypesCodecsTable, createUsersOnUpdateTable, createUserTable, usersMigratorTable } from './schema2';
+import { normalizeDataWithDbCodecs } from './utils';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	test.concurrent(
+		'insert+update+delete returning sql',
+		async ({ db, push }) => {
+			const users = createUserTable('users_85');
+			await push({ users });
+
+			const res0 = await db.insert(users).values({ name: 'John' });
+			const res1 = await db
+				.update(users)
+				.set({ name: 'Jane' })
+				.where(eq(users.name, 'John'));
+			const res2 = await db.delete(users).where(eq(users.name, 'Jane'));
+
+			const insertId = res0.insertId ? Number(res0.insertId) : res0[0].insertId;
+			const changedRows = res1.rowsAffected ?? res1[0].changedRows;
+			const affectedRows = res2.rowsAffected ?? res2[0].affectedRows;
+
+			expect(insertId).toBe(1);
+			expect(changedRows).toBe(1);
+			expect(affectedRows).toBe(1);
+		},
+	);
+
+	test.concurrent(
+		'update with returning all fields + partial',
+		async ({ db, push }) => {
+			const users = createUserTable('users_86');
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const updatedUsers = await db
+				.update(users)
+				.set({ name: 'Jane' })
+				.where(eq(users.name, 'John'));
+
+			const result = await db.select().from(users).where(eq(users.id, 1));
+
+			const countRows = updatedUsers[0]?.changedRows ?? updatedUsers.rowsAffected;
+			expect(countRows).toBe(1);
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			// not timezone based timestamp, thats why it should not work here
+			// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		},
+	);
+
+	test.concurrent('update with returning partial', async ({ db, push }) => {
+		const users = createUserTable('users_87');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+		const updatedUsers = await db
+			.update(users)
+			.set({ name: 'Jane' })
+			.where(eq(users.name, 'John'));
+
+		const result = await db
+			.select({ id: users.id, name: users.name })
+			.from(users)
+			.where(eq(users.id, 1));
+
+		expect(updatedUsers[0].changedRows).toBe(1);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'Jane' }]);
+	});
+
+	test.concurrent('delete with returning all fields', async ({ db, push }) => {
+		const users = createUserTable('users_88');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+		const deletedUser = await db.delete(users).where(eq(users.name, 'John'));
+
+		expect(deletedUser[0].affectedRows).toBe(1);
+	});
+
+	test.concurrent('delete with returning partial', async ({ db, push }) => {
+		const users = createUserTable('users_89');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+		const deletedUser = await db.delete(users).where(eq(users.name, 'John'));
+
+		expect(deletedUser[0].affectedRows).toBe(1);
+	});
+
+	test.concurrent('insert + select', async ({ db, push }) => {
+		const users = createUserTable('users_90');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+		const result = await db.select().from(users);
+		expect(result).toStrictEqual([
+			{
+				id: 1,
+				name: 'John',
+				verified: false,
+				jsonb: null,
+				createdAt: result[0]!.createdAt,
+			},
+		]);
+
+		await db.insert(users).values({ name: 'Jane' });
+		const result2 = await db.select().from(users);
+		expect(result2).toStrictEqual([
+			{
+				id: 1,
+				name: 'John',
+				verified: false,
+				jsonb: null,
+				createdAt: result2[0]!.createdAt,
+			},
+			{
+				id: 2,
+				name: 'Jane',
+				verified: false,
+				jsonb: null,
+				createdAt: result2[1]!.createdAt,
+			},
+		]);
+	});
+
+	test.concurrent('json insert', async ({ db, push }) => {
+		const users = createUserTable('users_91');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John', jsonb: ['foo', 'bar'] });
+		const result = await db
+			.select({
+				id: users.id,
+				name: users.name,
+				jsonb: users.jsonb,
+			})
+			.from(users);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', jsonb: ['foo', 'bar'] },
+		]);
+	});
+
+	test.concurrent(
+		'insert with overridden default values',
+		async ({ db, push }) => {
+			const users = createUserTable('users_92');
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John', verified: true });
+			const result = await db.select().from(users);
+
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: true,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		},
+	);
+
+	test.concurrent('insert many', async ({ db, push }) => {
+		const users = createUserTable('users_93');
+		await push({ users });
+
+		await db
+			.insert(users)
+			.values([
+				{ name: 'John' },
+				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ name: 'Jane' },
+				{ name: 'Austin', verified: true },
+			]);
+		const result = await db
+			.select({
+				id: users.id,
+				name: users.name,
+				jsonb: users.jsonb,
+				verified: users.verified,
+			})
+			.from(users);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John', jsonb: null, verified: false },
+			{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+			{ id: 3, name: 'Jane', jsonb: null, verified: false },
+			{ id: 4, name: 'Austin', jsonb: null, verified: true },
+		]);
+	});
+
+	test.concurrent('insert many with returning', async ({ db, push }) => {
+		const users = createUserTable('users_94');
+		await push({ users });
+
+		const result = await db
+			.insert(users)
+			.values([
+				{ name: 'John' },
+				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ name: 'Jane' },
+				{ name: 'Austin', verified: true },
+			]);
+
+		expect(result[0].affectedRows).toBe(4);
+	});
+	test.concurrent('$default function', async ({ db, push }) => {
+		const orders = mysqlTable('orders', {
+			id: serial('id').primaryKey(),
+			region: text('region').notNull(),
+			product: text('product')
+				.notNull()
+				.$default(() => 'random_string'),
+			amount: int('amount').notNull(),
+			quantity: int('quantity').notNull(),
+		});
+		await push({ orders });
+
+		await db
+			.insert(orders)
+			.values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+		const selectedOrder = await db.select().from(orders);
+
+		expect(selectedOrder).toStrictEqual([
+			{
+				id: 1,
+				amount: 1,
+				quantity: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			},
+		]);
+	});
+
+	test.concurrent('$default with empty array', async ({ db, push }) => {
+		const sOrders = mysqlTable('s_orders', {
+			id: serial('id').primaryKey(),
+			region: text('region').default('Ukraine'),
+			product: text('product').$defaultFn(() => 'random_string'),
+		});
+		await push({ sOrders });
+
+		await db.insert(sOrders).values({});
+		const selectedOrder = await db.select().from(sOrders);
+
+		expect(selectedOrder).toStrictEqual([
+			{
+				id: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			},
+		]);
+	});
+
+	// here
+
+	test.concurrent('Insert all defaults in 1 row', async ({ db, push }) => {
+		const users = mysqlTable('empty_insert_single_97', {
+			id: serial('id').primaryKey(),
+			name: text('name').default('Dan'),
+			state: text('state'),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values({});
+
+		const res = await db.select().from(users);
+
+		expect(res).toStrictEqual([{ id: 1, name: 'Dan', state: null }]);
+	});
+
+	test.concurrent(
+		'Insert all defaults in multiple rows',
+		async ({ db, push }) => {
+			const users = mysqlTable('empty_insert_multiple_97', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{}, {}]);
+
+			const res = await db.select().from(users);
+
+			expect(res).toStrictEqual([
+				{ id: 1, name: 'Dan', state: null },
+				{ id: 2, name: 'Dan', state: null },
+			]);
+		},
+	);
+
+	test.concurrent('insert with onDuplicate', async ({ db, push }) => {
+		const users = createUserTable('users_98');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+
+		await db
+			.insert(users)
+			.values({ id: 1, name: 'John' })
+			.onDuplicateKeyUpdate({ set: { name: 'John1' } });
+
+		const res = await db
+			.select({ id: users.id, name: users.name })
+			.from(users)
+			.where(eq(users.id, 1));
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John1' }]);
+	});
+
+	test.concurrent(
+		'insert with onDuplicate placeholder',
+		async ({ db, push }) => {
+			const users = createUserTable('users_98_p');
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+
+			await db
+				.insert(users)
+				.values({ id: 1, name: 'John' })
+				.onDuplicateKeyUpdate({ set: { name: sql.placeholder('name') } })
+				.execute({ name: 'John1' });
+
+			const res = await db
+				.select({ id: users.id, name: users.name })
+				.from(users)
+				.where(eq(users.id, 1));
+
+			expect(res).toStrictEqual([{ id: 1, name: 'John1' }]);
+		},
+	);
+
+	test.concurrent('insert conflict', async ({ db, push }) => {
+		const users = createUserTable('users_99');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+
+		await expect(
+			(async () => {
+				await db.insert(users).values({ id: 1, name: 'John1' });
+			})(),
+		).rejects.toThrowError();
+	});
+
+	test.concurrent('insert conflict with ignore', async ({ db, push }) => {
+		const users = createUserTable('users_100');
+		await push({ users });
+
+		await db.insert(users).values({ name: 'John' });
+
+		await db.insert(users).ignore().values({ id: 1, name: 'John1' });
+
+		const res = await db
+			.select({ id: users.id, name: users.name })
+			.from(users)
+			.where(eq(users.id, 1));
+
+		expect(res).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test.concurrent('insert sql', async ({ db, push }) => {
+		const users = createUserTable('users_101');
+		await push({ users });
+
+		await db.insert(users).values({ name: sql`${'John'}` });
+		const result = await db
+			.select({ id: users.id, name: users.name })
+			.from(users);
+		expect(result).toStrictEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test.concurrent('full join with alias', async ({ db, push }) => {
+		const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+		const users = mysqlTable('users_102', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([
+			{ id: 10, name: 'Ivan' },
+			{ id: 11, name: 'Hans' },
+		]);
+		const result = await db
+			.select()
+			.from(users)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(users.id, 10));
+
+		expect(result).toStrictEqual([
+			{
+				users_102: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			},
+		]);
+	});
+
+	test.concurrent('select from alias', async ({ db, push }) => {
+		const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+		const users = mysqlTable('users_103', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		await push({ users });
+
+		const user = alias(users, 'user');
+		const customers = alias(users, 'customer');
+
+		await db.insert(users).values([
+			{ id: 10, name: 'Ivan' },
+			{ id: 11, name: 'Hans' },
+		]);
+		const result = await db
+			.select()
+			.from(user)
+			.leftJoin(customers, eq(customers.id, 11))
+			.where(eq(user.id, 10));
+
+		expect(result).toStrictEqual([
+			{
+				user: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			},
+		]);
+	});
+
+	test.concurrent('insert with spaces', async ({ db, push }) => {
+		const users = createUserTable('users_104');
+		await push({ users });
+
+		await db.insert(users).values({ name: sql`'Jo   h     n'` });
+		const result = await db
+			.select({ id: users.id, name: users.name })
+			.from(users);
+
+		expect(result).toStrictEqual([{ id: 1, name: 'Jo   h     n' }]);
+	});
+
+	test.concurrent(
+		'insert: placeholders on columns with encoder',
+		async ({ db, push }) => {
+			const users = createUserTable('users_105');
+			await push({ users });
+
+			const date = new Date('2024-08-07T15:30:00Z');
+
+			const statement = db
+				.insert(users)
+				.values({
+					name: 'John',
+					createdAt: sql.placeholder('createdAt'),
+				})
+				.prepare();
+
+			await statement.execute({ createdAt: date });
+
+			const result = await db
+				.select({
+					id: users.id,
+					createdAt: users.createdAt,
+				})
+				.from(users);
+
+			expect(result).toStrictEqual([{ id: 1, createdAt: date }]);
+		},
+	);
+
+	test.concurrent('prepared statement reuse', async ({ db, push }) => {
+		const users = createUserTable('users_106');
+		await push({ users });
+
+		const stmt = db
+			.insert(users)
+			.values({
+				verified: true,
+				name: sql.placeholder('name'),
+			})
+			.prepare();
+
+		for (let i = 0; i < 10; i++) {
+			await stmt.execute({ name: `John ${i}` });
+		}
+
+		const result = await db
+			.select({
+				id: users.id,
+				name: users.name,
+				verified: users.verified,
+			})
+			.from(users);
+
+		expect(result).toStrictEqual([
+			{ id: 1, name: 'John 0', verified: true },
+			{ id: 2, name: 'John 1', verified: true },
+			{ id: 3, name: 'John 2', verified: true },
+			{ id: 4, name: 'John 3', verified: true },
+			{ id: 5, name: 'John 4', verified: true },
+			{ id: 6, name: 'John 5', verified: true },
+			{ id: 7, name: 'John 6', verified: true },
+			{ id: 8, name: 'John 7', verified: true },
+			{ id: 9, name: 'John 8', verified: true },
+			{ id: 10, name: 'John 9', verified: true },
+		]);
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/1415
+	test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+		'prepared statement sql.placeholder in .inArray',
+		async ({ db, push }) => {
+			const users = createUserTable('users_116');
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'John1' }]);
+			// TODO: it seems to me that prepared shouldn't be of type any
+			const prepared = db.select({ name: users.name }).from(users).where(
+				inArray(users.name, sql.placeholder('names')),
+			).prepare();
+
+			const result = await prepared.execute({ names: ['John', 'John1'] });
+			expect(result).toStrictEqual([{ name: 'John' }, { name: 'John1' }]);
+		},
+	);
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/1415
+	test
+		.skipIf(Date.now() < +new Date('2026-07-01'))
+		.concurrent(
+			'prepared statement sql.placeholder in .inArray #2',
+			async ({ db, push, seed }) => {
+				const users = createUserTable('users_116_2');
+				await push({ users });
+
+				await db.insert(users).values([{ name: 'John' }, { name: 'John1' }]);
+				// TODO: it seems to me that prepared shouldn't be of type any
+				const prepared = db
+					.select({ name: users.name })
+					.from(users)
+					.where(inArray(users.name, sql.placeholder('names')))
+					.prepare();
+
+				const result = await prepared.execute({ names: ['John', 'John1'] });
+				expect(result).toStrictEqual([{ name: 'John' }, { name: 'John1' }]);
+			},
+		);
+
+	test.concurrent(
+		'insert via db.execute + select via db.execute',
+		async ({ db, push }) => {
+			const users = createUserTable('users_108');
+			await push({ users });
+
+			await db.execute(
+				sql`insert into ${users} (${new Name(users.name.name)}) values (${'John'})`,
+			);
+
+			const result = await db.execute<{ id: number; name: string }>(
+				sql`select id, name from ${users}`,
+			);
+			expect(result[0]).toStrictEqual([{ id: 1, name: 'John' }]);
+		},
+	);
+
+	test.concurrent(
+		'insert via db.execute w/ query builder',
+		async ({ db, push }) => {
+			const users = createUserTable('users_109');
+			await push({ users });
+
+			const inserted = await db.execute(
+				db.insert(users).values({ name: 'John' }),
+			);
+			expect(inserted[0].affectedRows).toBe(1);
+		},
+	);
+
+	test.concurrent('Mysql enum as ts enum', async ({ db, push }) => {
+		enum Test {
+			a = 'a',
+			b = 'b',
+			c = 'c',
+		}
+
+		const tableWithTsEnums = mysqlTable('enums_test_case_109', {
+			id: serial('id').primaryKey(),
+			enum1: mysqlEnum('enum1', Test).notNull(),
+			enum2: mysqlEnum('enum2', Test).default(Test.a),
+			enum3: mysqlEnum('enum3', Test).notNull().default(Test.b),
+		});
+
+		await push({ tableWithTsEnums });
+
+		await db.insert(tableWithTsEnums).values([
+			{ id: 1, enum1: Test.a, enum2: Test.b, enum3: Test.c },
+			{ id: 2, enum1: Test.a, enum3: Test.c },
+			{ id: 3, enum1: Test.a },
+		]);
+
+		const res = await db.select().from(tableWithTsEnums);
+
+		expect(res).toStrictEqual([
+			{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+			{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+			{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+		]);
+	});
+	test.concurrent(
+		'test $onUpdateFn and $onUpdate works as $default',
+		async ({ db, push }) => {
+			const usersOnUpdate = createUsersOnUpdateTable('users_on_update_1');
+			await push({ usersOnUpdate });
+
+			await db
+				.insert(usersOnUpdate)
+				.values([
+					{ name: 'John' },
+					{ name: 'Jane' },
+					{ name: 'Jack' },
+					{ name: 'Jill' },
+				]);
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+			const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+			const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+			expect(response).toStrictEqual([
+				{
+					name: 'John',
+					id: 1,
+					updateCounter: 1,
+					uppercaseName: 'JOHN',
+					alwaysNull: null,
+				},
+				{
+					name: 'Jane',
+					id: 2,
+					updateCounter: 1,
+					uppercaseName: 'JANE',
+					alwaysNull: null,
+				},
+				{
+					name: 'Jack',
+					id: 3,
+					updateCounter: 1,
+					uppercaseName: 'JACK',
+					alwaysNull: null,
+				},
+				{
+					name: 'Jill',
+					id: 4,
+					updateCounter: 1,
+					uppercaseName: 'JILL',
+					alwaysNull: null,
+				},
+			]);
+			const msDelay = 750;
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+					Date.now() - msDelay,
+				);
+			}
+		},
+	);
+
+	test.concurrent(
+		'test $onUpdateFn and $onUpdate works updating',
+		async ({ db, push }) => {
+			const usersOnUpdate = createUsersOnUpdateTable('users_on_update_2');
+			await push({ usersOnUpdate });
+
+			await db
+				.insert(usersOnUpdate)
+				.values([
+					{ name: 'John', alwaysNull: 'this will will be null after updating' },
+					{ name: 'Jane' },
+					{ name: 'Jack' },
+					{ name: 'Jill' },
+				]);
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+			const initial = await db.select({ updatedAt }).from(usersOnUpdate);
+
+			await db
+				.update(usersOnUpdate)
+				.set({ name: 'Angel', uppercaseName: null })
+				.where(eq(usersOnUpdate.id, 1));
+
+			const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+			const response = await db.select({ ...rest }).from(usersOnUpdate);
+
+			expect(response).toStrictEqual([
+				{
+					name: 'Angel',
+					id: 1,
+					updateCounter: 2,
+					uppercaseName: null,
+					alwaysNull: null,
+				},
+				{
+					name: 'Jane',
+					id: 2,
+					updateCounter: 1,
+					uppercaseName: 'JANE',
+					alwaysNull: null,
+				},
+				{
+					name: 'Jack',
+					id: 3,
+					updateCounter: 1,
+					uppercaseName: 'JACK',
+					alwaysNull: null,
+				},
+				{
+					name: 'Jill',
+					id: 4,
+					updateCounter: 1,
+					uppercaseName: 'JILL',
+					alwaysNull: null,
+				},
+			]);
+			const msDelay = 750;
+
+			expect(initial[0]?.updatedAt?.valueOf()).not.toBe(
+				justDates[0]?.updatedAt?.valueOf(),
+			);
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+					Date.now() - msDelay,
+				);
+			}
+		},
+	);
+
+	test.concurrent('Object keys as column names', async ({ db, push }) => {
+		// Tests the following:
+		// Column with required config
+		// Column with optional config without providing a value
+		// Column with optional config providing a value
+		// Column without config
+		const users = mysqlTable('users_114', {
+			id: bigint({ mode: 'number' }).autoincrement().primaryKey(),
+			createdAt: timestamp(),
+			updatedAt: timestamp({ fsp: 3 }),
+			admin: boolean(),
+		});
+
+		await push({ users });
+
+		await db.insert(users).values([
+			{
+				createdAt: sql`now() - interval 30 day`,
+				updatedAt: sql`now() - interval 1 day`,
+				admin: true,
+			},
+			{
+				createdAt: sql`now() - interval 1 day`,
+				updatedAt: sql`now() - interval 30 day`,
+				admin: true,
+			},
+			{
+				createdAt: sql`now() - interval 1 day`,
+				updatedAt: sql`now() - interval 1 day`,
+				admin: false,
+			},
+		]);
+		const result = await db
+			.select({ id: users.id, admin: users.admin })
+			.from(users)
+			.where(
+				and(
+					gt(users.createdAt, sql`now() - interval 7 day`),
+					gt(users.updatedAt, sql`now() - interval 7 day`),
+				),
+			);
+
+		expect(result).toStrictEqual([{ id: 3, admin: false }]);
+	});
+
+	test.concurrent('update with limit and order by', async ({ db, push }) => {
+		const users = createUserTable('users_112');
+		await push({ users });
+
+		await db.insert(users).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db
+			.update(users)
+			.set({ verified: true })
+			.limit(2)
+			.orderBy(asc(users.name));
+
+		const result = await db
+			.select({ name: users.name, verified: users.verified })
+			.from(users)
+			.orderBy(asc(users.name));
+		expect(result).toStrictEqual([
+			{ name: 'Alan', verified: true },
+			{ name: 'Barry', verified: true },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test.concurrent('update with placeholder', async ({ db, push }) => {
+		const users = createUserTable('users_112_p');
+		await push({ users });
+
+		await db.insert(users).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db
+			.update(users)
+			.set({ verified: sql.placeholder('verified') })
+			.execute({
+				verified: true,
+			});
+
+		const result = await db
+			.select({ name: users.name, verified: users.verified })
+			.from(users)
+			.orderBy(asc(users.name));
+		expect(result).toStrictEqual([
+			{ name: 'Alan', verified: true },
+			{ name: 'Barry', verified: true },
+			{ name: 'Carl', verified: true },
+		]);
+	});
+
+	test.concurrent('delete with limit and order by', async ({ db, push }) => {
+		const users = createUserTable('users_113');
+		await push({ users });
+
+		await db.insert(users).values([
+			{ name: 'Barry', verified: false },
+			{ name: 'Alan', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+
+		await db
+			.delete(users)
+			.where(eq(users.verified, false))
+			.limit(1)
+			.orderBy(asc(users.name));
+
+		const result = await db
+			.select({ name: users.name, verified: users.verified })
+			.from(users)
+			.orderBy(asc(users.name));
+		expect(result).toStrictEqual([
+			{ name: 'Barry', verified: false },
+			{ name: 'Carl', verified: false },
+		]);
+	});
+
+	test.concurrent('column.as', async ({ db, push }) => {
+		const users = mysqlTable('users_column_as', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+			cityId: int('city_id').references(() => cities.id),
+		});
+
+		const cities = mysqlTable('cities_column_as', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		const ucView = mysqlView('cities_users_column_as_view').as((qb) =>
+			qb
+				.select({
+					userId: users.id.as('user_id'),
+					cityId: cities.id.as('city_id'),
+					userName: users.name.as('user_name'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(users)
+				.leftJoin(cities, eq(cities.id, users.cityId))
+		);
+
+		await push({ users, cities, ucView });
+
+		try {
+			await db.insert(cities).values([
+				{
+					id: 1,
+					name: 'Firstistan',
+				},
+				{
+					id: 2,
+					name: 'Secondaria',
+				},
+			]);
+
+			await db.insert(users).values([
+				{ id: 1, name: 'First', cityId: 1 },
+				{
+					id: 2,
+					name: 'Second',
+					cityId: 2,
+				},
+				{
+					id: 3,
+					name: 'Third',
+				},
+			]);
+
+			const joinSelectReturn = await db
+				.select({
+					userId: users.id.as('user_id'),
+					cityId: cities.id.as('city_id'),
+					userName: users.name.as('user_name'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(users)
+				.leftJoin(cities, eq(cities.id, users.cityId));
+
+			expect(joinSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewSelectReturn = await db.select().from(ucView);
+
+			expect(viewSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewJoinReturn = await db
+				.select({
+					userId: ucView.userId.as('user_id_ucv'),
+					cityId: cities.id.as('city_id'),
+					userName: ucView.userName.as('user_name_ucv'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(ucView)
+				.leftJoin(cities, eq(cities.id, ucView.cityId));
+
+			expect(viewJoinReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+		} finally {
+			await db.execute(sql`DROP TABLE ${users}`).catch(() => null);
+			await db.execute(sql`DROP TABLE ${cities}`).catch(() => null);
+			await db.execute(sql`DROP VIEW ${ucView}`).catch(() => null);
+		}
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4878
+	test.concurrent('.where with isNull in it', async ({ db, push }) => {
+		const table = mysqlTable('table_where_is_null', {
+			col1: boolean(),
+			col2: text(),
+		});
+
+		await push({ table });
+		await db
+			.insert(table)
+			.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+		const query = db
+			.select()
+			.from(table)
+			.where(eq(table.col1, isNull(table.col2)));
+		expect(query.toSQL()).toStrictEqual({
+			sql:
+				'select `col1`, `col2` from `table_where_is_null` where `table_where_is_null`.`col1` = (`table_where_is_null`.`col2` is null)',
+			params: [],
+		});
+		const res = await query;
+		expect(res).toStrictEqual([
+			{ col1: true, col2: null },
+			{ col1: false, col2: 'qwerty' },
+		]);
+	});
+
+	test.concurrent('select + extra index params', async ({ db, push }) => {
+		const users = mysqlTable(
+			'index_test',
+			{
+				id: int('id').primaryKey(),
+				name: varchar('name', { length: 15 }).notNull(),
+				age: int('age').notNull(),
+				time: int('time').notNull(),
+			},
+			() => [idx, idx2, unq],
+		);
+		const idx = index('name_index').on(users.name);
+		const idx2 = index('age_index2').on(users.age);
+		const unq = unique('time_unq').on(users.time);
+
+		expect(
+			db
+				.select()
+				.from(users, { useIndex: [idx] })
+				.toSQL().sql,
+		).toBe(
+			'select `id`, `name`, `age`, `time` from `index_test` USE INDEX (`name_index`)',
+		);
+		expect(
+			db
+				.select()
+				.from(users, { forceIndex: [idx] })
+				.toSQL().sql,
+		).toBe(
+			'select `id`, `name`, `age`, `time` from `index_test` FORCE INDEX (`name_index`)',
+		);
+		expect(
+			db
+				.select()
+				.from(users, { ignoreIndex: [idx] })
+				.toSQL().sql,
+		).toBe(
+			'select `id`, `name`, `age`, `time` from `index_test` IGNORE INDEX (`name_index`)',
+		);
+		expect(
+			db
+				.select()
+				.from(users, { ignoreIndex: [unq] })
+				.toSQL().sql,
+		).toBe(
+			'select `id`, `name`, `age`, `time` from `index_test` IGNORE INDEX (`time_unq`)',
+		);
+
+		await push({ users });
+
+		try {
+			await db.insert(users).values([
+				{ id: 1, name: 'hello1', age: 1, time: 1 },
+				{
+					id: 2,
+					name: 'hello2',
+					age: 2,
+					time: 2,
+				},
+			]);
+
+			const res1 = await db.select().from(users, { forceIndex: idx });
+			const res2 = await db.select().from(users, { ignoreIndex: idx });
+			const res3 = await db.select().from(users, { useIndex: idx });
+			const res4 = await db
+				.select()
+				.from(users, { forceIndex: idx, ignoreIndex: idx2 });
+			const res5 = await db
+				.select()
+				.from(users, { useIndex: unq, ignoreIndex: unq });
+
+			const result = [
+				{
+					age: 1,
+					id: 1,
+					name: 'hello1',
+					time: 1,
+				},
+				{
+					age: 2,
+					id: 2,
+					name: 'hello2',
+					time: 2,
+				},
+			];
+			expect(res1).toStrictEqual(result);
+			expect(res2).toStrictEqual(result);
+			expect(res3).toStrictEqual(result);
+			expect(res4).toStrictEqual(result);
+			expect(res5).toStrictEqual(result);
+		} finally {
+			await db.execute(sql`DROP TABLE ${users}`).catch(() => null);
+		}
+	});
+
+	test.concurrent('placeholder + sql dates', async ({ db, push }) => {
+		const dateTable = mysqlTable('dates_placeholder_test', (t) => ({
+			id: t.int('id').primaryKey().notNull(),
+			date: t.datetime('date', { mode: 'date' }).notNull(),
+			dateStr: t.datetime('date_str', { mode: 'string' }).notNull(),
+			timestamp: t.timestamp('timestamp', { mode: 'date' }).notNull(),
+			timestampStr: t.timestamp('timestamp_str', { mode: 'string' }).notNull(),
+		}));
+
+		await db.execute(sql`DROP TABLE IF EXISTS ${dateTable};`);
+		await push({ dateTable });
+
+		const date = new Date('2025-12-10T01:01:01.000Z');
+		const timestamp = new Date('2025-12-10T01:01:01.000Z');
+		const dateStr = date.toISOString().slice(0, -5).replace('T', ' ');
+		const timestampStr = timestamp.toISOString().slice(0, -5).replace('T', ' ');
+
+		await db
+			.insert(dateTable)
+			.values([
+				{
+					id: 1,
+					date: date,
+					dateStr: dateStr,
+					timestamp: timestamp,
+					timestampStr: timestampStr,
+				},
+				{
+					id: 2,
+					date: sql.placeholder('dateAsDate'),
+					dateStr: sql.placeholder('dateStrAsDate'),
+					timestamp: sql.placeholder('timestampAsDate'),
+					timestampStr: sql.placeholder('timestampStrAsDate'),
+				},
+				{
+					id: 3,
+					date: sql.placeholder('dateAsString'),
+					dateStr: sql.placeholder('dateStrAsString'),
+					timestamp: sql.placeholder('timestampAsString'),
+					timestampStr: sql.placeholder('timestampStrAsString'),
+				},
+				{
+					id: 4,
+					date: sql`${dateStr}`,
+					dateStr: sql`${dateStr}`,
+					timestamp: sql`${timestampStr}`,
+					timestampStr: sql`${timestampStr}`,
+				},
+			])
+			.execute({
+				dateAsDate: date,
+				dateAsString: dateStr,
+				dateStrAsDate: date,
+				dateStrAsString: dateStr,
+				timestampAsDate: timestamp,
+				timestampAsString: timestampStr,
+				timestampStrAsDate: timestamp,
+				timestampStrAsString: timestampStr,
+			});
+
+		const initial = await db.select().from(dateTable).orderBy(dateTable.id);
+
+		await db.update(dateTable).set({
+			date: sql`${dateStr}`,
+			dateStr: sql`${dateStr}`,
+			timestamp: sql`${timestampStr}`,
+			timestampStr: sql`${timestampStr}`,
+		});
+
+		const updated = await db.select().from(dateTable).orderBy(dateTable.id);
+
+		expect(initial).toStrictEqual([
+			{
+				id: 1,
+				date,
+				dateStr,
+				timestamp,
+				timestampStr,
+			},
+			{
+				id: 2,
+				date,
+				dateStr,
+				timestamp,
+				timestampStr,
+			},
+			{
+				id: 3,
+				date,
+				dateStr,
+				timestamp,
+				timestampStr,
+			},
+			{
+				id: 4,
+				date,
+				dateStr,
+				timestamp,
+				timestampStr,
+			},
+		]);
+
+		expect(updated).toStrictEqual(initial);
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4875
+	test.concurrent('select aliased view', async ({ db }) => {
+		const productionJobTable = mysqlTable('production_job', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+		});
+
+		const rfidTagTable = mysqlTable('rfid_tag', {
+			createdAt: timestamp('created_at')
+				.notNull()
+				.default(sql`now()`),
+			epc: text('epc').notNull(),
+			locationId: text('location_id').notNull(),
+			id: text('id')
+				.notNull()
+				.unique()
+				.$default(() => 'abc'),
+		});
+
+		const productionJobWithLocationView = mysqlView(
+			'production_job_with_location',
+		).as((qb) => {
+			const productionColumns = getColumns(productionJobTable);
+			const sub = qb.selectDistinct().from(rfidTagTable).as('r');
+			return qb
+				.select({
+					...productionColumns,
+					locationId: sub.locationId,
+					tagId: sub.id.as('tag_id'),
+					tagCreatedAt: sub.createdAt.as('tag_created_at'),
+				})
+				.from(productionJobTable)
+				.leftJoin(
+					sub,
+					and(
+						eq(productionJobTable.id, sql`LTRIM(${sub.epc}, '0')`),
+						sql`${sub.epc} ~ '^0?[0-9]+'`,
+					),
+				);
+		});
+
+		const sub = alias(productionJobWithLocationView, 'p'); // if select from "productionJobWithLocationView" (not from alias), it works as expected
+
+		const query = db.select().from(sub);
+		expect(query.toSQL().sql).toStrictEqual(
+			(<{ dialect: MySqlDialect }> (<any> db)).dialect.sqlToQuery(
+				sql`select ${sql.identifier('id')}, ${sql.identifier('name')}, ${sql.identifier('location_id')}, ${
+					sql.identifier(
+						'tag_id',
+					)
+				}, ${sql.identifier('tag_created_at')} from ${sql.identifier('production_job_with_location')} ${
+					sql.identifier(
+						'p',
+					)
+				}`,
+			).sql,
+		);
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4612
+	test.concurrent('select with inline params in sql', async ({ db }) => {
+		const users = mysqlTable('users_115', {
+			id: int('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		const query = db.select({ sum: sql`sum(${3})`.inlineParams() }).from(users);
+
+		expect(query.toSQL()).toStrictEqual({
+			sql: 'select sum(3) from `users_115`',
+			params: [],
+		});
+	});
+
+	test.concurrent('sql.identifier escape', async () => {
+		const dialect = new MySqlDialect();
+		const userInput = 'id` ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+		const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+		const str = dialect.sqlToQuery(query);
+		expect(str.sql).toBe(
+			'SELECT * FROM `users` ORDER BY `id`` ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--` ASC',
+		);
+	});
+
+	test.concurrent('Query error wrapping', async ({ push, db }) => {
+		const table = mysqlTable('users_error_wrap', (t) => ({
+			id: t.int().primaryKey(),
+			name: t.text().notNull(),
+		}));
+
+		await push({ table });
+		await expect(db.insert(table).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]))
+			.rejects.toBeInstanceOf(DrizzleQueryError);
+	});
+
+	test.concurrent('comments', async ({ createDB, push }) => {
+		const ctbl = mysqlTable('comments_test', (t) => ({
+			id: t.int('id').primaryKey(),
+			name: t.text('name').notNull(),
+		}));
+
+		await push({ ctbl });
+		const db = createDB({ schema: { ctbl } });
+
+		const insertQ = db
+			.insert(ctbl)
+			.values([
+				{
+					id: 1,
+					name: 'First',
+				},
+				{
+					id: 2,
+					name: 'Second',
+				},
+			])
+			.comment({ insert: '*/ comment /*', '/* n': 1 });
+
+		expect(insertQ.toSQL().sql).toStrictEqual(
+			`insert into \`comments_test\` (\`id\`, \`name\`) values (?, ?), (?, ?) /*%2F*%20n='1',insert='*%2F%20comment%20%2F*'*/`,
+		);
+
+		const deleteQ = db
+			.delete(ctbl)
+			.where(eq(ctbl.id, 2))
+			.comment({ "del ' ete": '*/ comment /*' });
+		expect(deleteQ.toSQL().sql).toStrictEqual(
+			`delete from \`comments_test\` where \`comments_test\`.\`id\` = ? /*del%20\\'%20ete='*%2F%20comment%20%2F*'*/`,
+		);
+
+		const updateQ = db
+			.update(ctbl)
+			.set({ name: 'Updated' })
+			.where(eq(ctbl.id, 1))
+			.comment({
+				update: 'here /**',
+			});
+		expect(updateQ.toSQL().sql).toStrictEqual(
+			`update \`comments_test\` set \`name\` = ? where \`comments_test\`.\`id\` = ? /*update='here%20%2F**'*/`,
+		);
+
+		const selectQ = db
+			.select()
+			.from(ctbl)
+			.comment({ select: 'co\'m"m`/* ent*/ "' });
+		expect(selectQ.toSQL().sql).toStrictEqual(
+			`select \`id\`, \`name\` from \`comments_test\` /*select='co\\'m%22m%60%2F*%20ent*%2F%20%22'*/`,
+		);
+
+		const rqbQ = db.query.ctbl.findFirst({
+			columns: {
+				id: true,
+			},
+			comment: {
+				fieldOne: '_valueOne',
+				_fieldTwo: 'value two',
+			},
+		});
+		expect(rqbQ.toSQL().sql).toStrictEqual(
+			`select \`d0\`.\`id\` as \`id\` from \`comments_test\` as \`d0\` limit ? /*_fieldTwo='value%20two',fieldOne='_valueOne'*/`,
+		);
+
+		const selectQPrepared = db
+			.select()
+			.from(ctbl)
+			.comment({
+				select: `com'ment`,
+			})
+			.prepare();
+		expect(
+			typeof (<any> selectQPrepared).query?.sql === 'string'
+				? (<any> selectQPrepared).query.sql
+				: (<any> selectQPrepared).queryString,
+		)
+			.toStrictEqual(
+				`select \`id\`, \`name\` from \`comments_test\` /*select='com\\'ment'*/`,
+			);
+
+		await insertQ;
+		await updateQ;
+		await deleteQ;
+
+		const [res1, res2, res3] = [
+			await selectQ,
+			await rqbQ,
+			await selectQPrepared.execute(),
+		];
+
+		expectTypeOf(res2).toEqualTypeOf<
+			| {
+				id: number;
+			}
+			| undefined
+		>();
+		expect(res1).toStrictEqual([{ id: 1, name: 'Updated' }]);
+		expect(res2).toStrictEqual({ id: 1 });
+		expect(res3).toStrictEqual([{ id: 1, name: 'Updated' }]);
+	});
+
+	test.concurrent('all types ~codecs~', async ({ createDB, push }) => {
+		const db = createDB({
+			schema: { allTypesTable: allTypesCodecsTable },
+			cb: (r) => ({
+				allTypesTable: {
+					self: r.many.allTypesTable({
+						from: r.allTypesTable.serial,
+						to: r.allTypesTable.serial,
+					}),
+				},
+			}),
+		});
+		await push({ allTypesCodecsTable });
+		type ExpectedType = {
+			serial: number;
+			bigint53: number;
+			bigint64: bigint;
+			bigintstr: string;
+			binary: string;
+			boolean: boolean;
+			char: string;
+			date: Date;
+			datestr: string;
+			datetime: Date;
+			datetimestr: string;
+			decimal: string;
+			decimalnum: number;
+			decimalbig: bigint;
+			double: number;
+			float: number;
+			int: number;
+			json1: unknown;
+			json2: unknown;
+			json3: unknown;
+			json4: unknown;
+			medint: number;
+			smallint: number;
+			real: number;
+			text: string;
+			tinytext: string;
+			mediumtext: string;
+			longtext: string;
+			time: string;
+			timestamp: Date;
+			timestampstr: string;
+			tinyint: number;
+			varbin: string;
+			varchar: string;
+			year: number;
+			enum: 'enV1' | 'enV2';
+			blob: Buffer;
+			tinyblob: Buffer;
+			mediumblob: Buffer;
+			longblob: Buffer;
+			stringblob: string;
+			stringtinyblob: string;
+			stringmediumblob: string;
+			stringlongblob: string;
+		};
+
+		const testData: ExpectedType = {
+			serial: 1,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintstr: '5044565289845416380',
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date('2025-03-12'),
+			datestr: '2025-03-12',
+			datetime: new Date(1741743161623),
+			datetimestr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+			decimal: '47521',
+			decimalnum: 9007199254740991,
+			decimalbig: 5044565289845416380n,
+			double: 15.35325689124218,
+			enum: 'enV1',
+			float: 1.048596,
+			real: 1.048596,
+			text: 'C4-',
+			tinytext: 'tiny text',
+			mediumtext: 'medium text',
+			longtext: 'long text',
+			int: 621,
+			json1: { str: 'strval', arr: ['str', 10] },
+			json2: [{ key: 'value', num: 7 }, 'v', '11', 5],
+			json3: 5,
+			json4: '5',
+			medint: 560,
+			smallint: 14,
+			time: '04:13:22',
+			timestamp: new Date(1741743161623),
+			timestampstr: new Date(1741743161623).toISOString().slice(0, 23).replace('T', ' '),
+			tinyint: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+			blob: Buffer.from('string'),
+			longblob: Buffer.from('string'),
+			mediumblob: Buffer.from('string'),
+			tinyblob: Buffer.from('string'),
+			stringblob: 'string',
+			stringlongblob: 'string',
+			stringmediumblob: 'string',
+			stringtinyblob: 'string',
+		};
+
+		await db.insert(allTypesCodecsTable).values(testData);
+
+		const session = (<any> db).session as MySqlAsyncSession;
+
+		const queryRes = await session.objects<ExpectedType>(
+			db.select(
+				Object.fromEntries(Object.entries(getTableColumns(allTypesCodecsTable)).map(([k, v]) => [k, v.as(v.name)])),
+			).from(allTypesCodecsTable).getSQL(),
+		).then((e) =>
+			normalizeDataWithDbCodecs({
+				db,
+				columns: getColumns(allTypesCodecsTable),
+				data: e,
+				mode: 'query',
+			})[0]
+		);
+
+		expect(queryRes).toStrictEqual(testData);
+
+		const isTidb = is(db, TiDBServerlessDatabase);
+		// TiDB and PlanetScale (serverless HTTP drivers) widen `<col> ∪ varbinary` to a binary
+		// type, returning the bit-string of the raw bytes; mysql2 keeps the text value. (Float
+		// precision and `year ∪ tinyint` narrowing, by contrast, match mysql2 on PlanetScale.)
+		const binWidens = isTidb || is(db, PlanetScaleDatabase);
+
+		// ---- numbers ----
+		expect(
+			await unionAll(
+				db.select({
+					'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+					'serial ∪ bigint53': allTypesCodecsTable.serial.as('serial ∪ bigint53'),
+					'serial ∪ decimalnum': allTypesCodecsTable.serial.as('serial ∪ decimalnum'),
+					'serial ∪ double': allTypesCodecsTable.serial.as('serial ∪ double'),
+					'serial ∪ float': allTypesCodecsTable.serial.as('serial ∪ float'),
+					'serial ∪ int': allTypesCodecsTable.serial.as('serial ∪ int'),
+					'serial ∪ medint': allTypesCodecsTable.serial.as('serial ∪ medint'),
+					'serial ∪ smallint': allTypesCodecsTable.serial.as('serial ∪ smallint'),
+					'serial ∪ real': allTypesCodecsTable.serial.as('serial ∪ real'),
+					'serial ∪ tinyint': allTypesCodecsTable.serial.as('serial ∪ tinyint'),
+					'serial ∪ year': allTypesCodecsTable.serial.as('serial ∪ year'),
+					'bigint53 ∪ serial': allTypesCodecsTable.bigint53.as('bigint53 ∪ serial'),
+					'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+					'bigint53 ∪ decimalnum': allTypesCodecsTable.bigint53.as('bigint53 ∪ decimalnum'),
+					'bigint53 ∪ double': allTypesCodecsTable.bigint53.as('bigint53 ∪ double'),
+					'bigint53 ∪ float': allTypesCodecsTable.bigint53.as('bigint53 ∪ float'),
+					'bigint53 ∪ int': allTypesCodecsTable.bigint53.as('bigint53 ∪ int'),
+					'bigint53 ∪ medint': allTypesCodecsTable.bigint53.as('bigint53 ∪ medint'),
+					'bigint53 ∪ smallint': allTypesCodecsTable.bigint53.as('bigint53 ∪ smallint'),
+					'bigint53 ∪ real': allTypesCodecsTable.bigint53.as('bigint53 ∪ real'),
+					'bigint53 ∪ tinyint': allTypesCodecsTable.bigint53.as('bigint53 ∪ tinyint'),
+					'bigint53 ∪ year': allTypesCodecsTable.bigint53.as('bigint53 ∪ year'),
+					'decimalnum ∪ serial': allTypesCodecsTable.decimalnum.as('decimalnum ∪ serial'),
+					'decimalnum ∪ bigint53': allTypesCodecsTable.decimalnum.as('decimalnum ∪ bigint53'),
+					'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+					'decimalnum ∪ double': allTypesCodecsTable.decimalnum.as('decimalnum ∪ double'),
+					'decimalnum ∪ float': allTypesCodecsTable.decimalnum.as('decimalnum ∪ float'),
+					'decimalnum ∪ int': allTypesCodecsTable.decimalnum.as('decimalnum ∪ int'),
+					'decimalnum ∪ medint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ medint'),
+					'decimalnum ∪ smallint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ smallint'),
+					'decimalnum ∪ real': allTypesCodecsTable.decimalnum.as('decimalnum ∪ real'),
+					'decimalnum ∪ tinyint': allTypesCodecsTable.decimalnum.as('decimalnum ∪ tinyint'),
+					'decimalnum ∪ year': allTypesCodecsTable.decimalnum.as('decimalnum ∪ year'),
+					'double ∪ serial': allTypesCodecsTable.double.as('double ∪ serial'),
+					'double ∪ bigint53': allTypesCodecsTable.double.as('double ∪ bigint53'),
+					'double ∪ decimalnum': allTypesCodecsTable.double.as('double ∪ decimalnum'),
+					'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+					'double ∪ float': allTypesCodecsTable.double.as('double ∪ float'),
+					'double ∪ int': allTypesCodecsTable.double.as('double ∪ int'),
+					'double ∪ medint': allTypesCodecsTable.double.as('double ∪ medint'),
+					'double ∪ smallint': allTypesCodecsTable.double.as('double ∪ smallint'),
+					'double ∪ real': allTypesCodecsTable.double.as('double ∪ real'),
+					'double ∪ tinyint': allTypesCodecsTable.double.as('double ∪ tinyint'),
+					'double ∪ year': allTypesCodecsTable.double.as('double ∪ year'),
+					'float ∪ serial': allTypesCodecsTable.float.as('float ∪ serial'),
+					'float ∪ bigint53': allTypesCodecsTable.float.as('float ∪ bigint53'),
+					'float ∪ decimalnum': allTypesCodecsTable.float.as('float ∪ decimalnum'),
+					'float ∪ double': allTypesCodecsTable.float.as('float ∪ double'),
+					'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+					'float ∪ int': allTypesCodecsTable.float.as('float ∪ int'),
+					'float ∪ medint': allTypesCodecsTable.float.as('float ∪ medint'),
+					'float ∪ smallint': allTypesCodecsTable.float.as('float ∪ smallint'),
+					'float ∪ real': allTypesCodecsTable.float.as('float ∪ real'),
+					'float ∪ tinyint': allTypesCodecsTable.float.as('float ∪ tinyint'),
+					'float ∪ year': allTypesCodecsTable.float.as('float ∪ year'),
+					'int ∪ serial': allTypesCodecsTable.int.as('int ∪ serial'),
+					'int ∪ bigint53': allTypesCodecsTable.int.as('int ∪ bigint53'),
+					'int ∪ decimalnum': allTypesCodecsTable.int.as('int ∪ decimalnum'),
+					'int ∪ double': allTypesCodecsTable.int.as('int ∪ double'),
+					'int ∪ float': allTypesCodecsTable.int.as('int ∪ float'),
+					'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+					'int ∪ medint': allTypesCodecsTable.int.as('int ∪ medint'),
+					'int ∪ smallint': allTypesCodecsTable.int.as('int ∪ smallint'),
+					'int ∪ real': allTypesCodecsTable.int.as('int ∪ real'),
+					'int ∪ tinyint': allTypesCodecsTable.int.as('int ∪ tinyint'),
+					'int ∪ year': allTypesCodecsTable.int.as('int ∪ year'),
+					'medint ∪ serial': allTypesCodecsTable.medint.as('medint ∪ serial'),
+					'medint ∪ bigint53': allTypesCodecsTable.medint.as('medint ∪ bigint53'),
+					'medint ∪ decimalnum': allTypesCodecsTable.medint.as('medint ∪ decimalnum'),
+					'medint ∪ double': allTypesCodecsTable.medint.as('medint ∪ double'),
+					'medint ∪ float': allTypesCodecsTable.medint.as('medint ∪ float'),
+					'medint ∪ int': allTypesCodecsTable.medint.as('medint ∪ int'),
+					'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+					'medint ∪ smallint': allTypesCodecsTable.medint.as('medint ∪ smallint'),
+					'medint ∪ real': allTypesCodecsTable.medint.as('medint ∪ real'),
+					'medint ∪ tinyint': allTypesCodecsTable.medint.as('medint ∪ tinyint'),
+					'medint ∪ year': allTypesCodecsTable.medint.as('medint ∪ year'),
+					'smallint ∪ serial': allTypesCodecsTable.smallint.as('smallint ∪ serial'),
+					'smallint ∪ bigint53': allTypesCodecsTable.smallint.as('smallint ∪ bigint53'),
+					'smallint ∪ decimalnum': allTypesCodecsTable.smallint.as('smallint ∪ decimalnum'),
+					'smallint ∪ double': allTypesCodecsTable.smallint.as('smallint ∪ double'),
+					'smallint ∪ float': allTypesCodecsTable.smallint.as('smallint ∪ float'),
+					'smallint ∪ int': allTypesCodecsTable.smallint.as('smallint ∪ int'),
+					'smallint ∪ medint': allTypesCodecsTable.smallint.as('smallint ∪ medint'),
+					'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+					'smallint ∪ real': allTypesCodecsTable.smallint.as('smallint ∪ real'),
+					'smallint ∪ tinyint': allTypesCodecsTable.smallint.as('smallint ∪ tinyint'),
+					'smallint ∪ year': allTypesCodecsTable.smallint.as('smallint ∪ year'),
+					'real ∪ serial': allTypesCodecsTable.real.as('real ∪ serial'),
+					'real ∪ bigint53': allTypesCodecsTable.real.as('real ∪ bigint53'),
+					'real ∪ decimalnum': allTypesCodecsTable.real.as('real ∪ decimalnum'),
+					'real ∪ double': allTypesCodecsTable.real.as('real ∪ double'),
+					'real ∪ float': allTypesCodecsTable.real.as('real ∪ float'),
+					'real ∪ int': allTypesCodecsTable.real.as('real ∪ int'),
+					'real ∪ medint': allTypesCodecsTable.real.as('real ∪ medint'),
+					'real ∪ smallint': allTypesCodecsTable.real.as('real ∪ smallint'),
+					'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+					'real ∪ tinyint': allTypesCodecsTable.real.as('real ∪ tinyint'),
+					'real ∪ year': allTypesCodecsTable.real.as('real ∪ year'),
+					'tinyint ∪ serial': allTypesCodecsTable.tinyint.as('tinyint ∪ serial'),
+					'tinyint ∪ bigint53': allTypesCodecsTable.tinyint.as('tinyint ∪ bigint53'),
+					'tinyint ∪ decimalnum': allTypesCodecsTable.tinyint.as('tinyint ∪ decimalnum'),
+					'tinyint ∪ double': allTypesCodecsTable.tinyint.as('tinyint ∪ double'),
+					'tinyint ∪ float': allTypesCodecsTable.tinyint.as('tinyint ∪ float'),
+					'tinyint ∪ int': allTypesCodecsTable.tinyint.as('tinyint ∪ int'),
+					'tinyint ∪ medint': allTypesCodecsTable.tinyint.as('tinyint ∪ medint'),
+					'tinyint ∪ smallint': allTypesCodecsTable.tinyint.as('tinyint ∪ smallint'),
+					'tinyint ∪ real': allTypesCodecsTable.tinyint.as('tinyint ∪ real'),
+					'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+					'tinyint ∪ year': allTypesCodecsTable.tinyint.as('tinyint ∪ year'),
+					'year ∪ serial': allTypesCodecsTable.year.as('year ∪ serial'),
+					'year ∪ bigint53': allTypesCodecsTable.year.as('year ∪ bigint53'),
+					'year ∪ decimalnum': allTypesCodecsTable.year.as('year ∪ decimalnum'),
+					'year ∪ double': allTypesCodecsTable.year.as('year ∪ double'),
+					'year ∪ float': allTypesCodecsTable.year.as('year ∪ float'),
+					'year ∪ int': allTypesCodecsTable.year.as('year ∪ int'),
+					'year ∪ medint': allTypesCodecsTable.year.as('year ∪ medint'),
+					'year ∪ smallint': allTypesCodecsTable.year.as('year ∪ smallint'),
+					'year ∪ real': allTypesCodecsTable.year.as('year ∪ real'),
+					'year ∪ tinyint': allTypesCodecsTable.year.as('year ∪ tinyint'),
+					'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'serial ∪ serial': allTypesCodecsTable.serial.as('serial ∪ serial'),
+					'serial ∪ bigint53': allTypesCodecsTable.bigint53.as('serial ∪ bigint53'),
+					'serial ∪ decimalnum': allTypesCodecsTable.decimalnum.as('serial ∪ decimalnum'),
+					'serial ∪ double': allTypesCodecsTable.double.as('serial ∪ double'),
+					'serial ∪ float': allTypesCodecsTable.float.as('serial ∪ float'),
+					'serial ∪ int': allTypesCodecsTable.int.as('serial ∪ int'),
+					'serial ∪ medint': allTypesCodecsTable.medint.as('serial ∪ medint'),
+					'serial ∪ smallint': allTypesCodecsTable.smallint.as('serial ∪ smallint'),
+					'serial ∪ real': allTypesCodecsTable.real.as('serial ∪ real'),
+					'serial ∪ tinyint': allTypesCodecsTable.tinyint.as('serial ∪ tinyint'),
+					'serial ∪ year': allTypesCodecsTable.year.as('serial ∪ year'),
+					'bigint53 ∪ serial': allTypesCodecsTable.serial.as('bigint53 ∪ serial'),
+					'bigint53 ∪ bigint53': allTypesCodecsTable.bigint53.as('bigint53 ∪ bigint53'),
+					'bigint53 ∪ decimalnum': allTypesCodecsTable.decimalnum.as('bigint53 ∪ decimalnum'),
+					'bigint53 ∪ double': allTypesCodecsTable.double.as('bigint53 ∪ double'),
+					'bigint53 ∪ float': allTypesCodecsTable.float.as('bigint53 ∪ float'),
+					'bigint53 ∪ int': allTypesCodecsTable.int.as('bigint53 ∪ int'),
+					'bigint53 ∪ medint': allTypesCodecsTable.medint.as('bigint53 ∪ medint'),
+					'bigint53 ∪ smallint': allTypesCodecsTable.smallint.as('bigint53 ∪ smallint'),
+					'bigint53 ∪ real': allTypesCodecsTable.real.as('bigint53 ∪ real'),
+					'bigint53 ∪ tinyint': allTypesCodecsTable.tinyint.as('bigint53 ∪ tinyint'),
+					'bigint53 ∪ year': allTypesCodecsTable.year.as('bigint53 ∪ year'),
+					'decimalnum ∪ serial': allTypesCodecsTable.serial.as('decimalnum ∪ serial'),
+					'decimalnum ∪ bigint53': allTypesCodecsTable.bigint53.as('decimalnum ∪ bigint53'),
+					'decimalnum ∪ decimalnum': allTypesCodecsTable.decimalnum.as('decimalnum ∪ decimalnum'),
+					'decimalnum ∪ double': allTypesCodecsTable.double.as('decimalnum ∪ double'),
+					'decimalnum ∪ float': allTypesCodecsTable.float.as('decimalnum ∪ float'),
+					'decimalnum ∪ int': allTypesCodecsTable.int.as('decimalnum ∪ int'),
+					'decimalnum ∪ medint': allTypesCodecsTable.medint.as('decimalnum ∪ medint'),
+					'decimalnum ∪ smallint': allTypesCodecsTable.smallint.as('decimalnum ∪ smallint'),
+					'decimalnum ∪ real': allTypesCodecsTable.real.as('decimalnum ∪ real'),
+					'decimalnum ∪ tinyint': allTypesCodecsTable.tinyint.as('decimalnum ∪ tinyint'),
+					'decimalnum ∪ year': allTypesCodecsTable.year.as('decimalnum ∪ year'),
+					'double ∪ serial': allTypesCodecsTable.serial.as('double ∪ serial'),
+					'double ∪ bigint53': allTypesCodecsTable.bigint53.as('double ∪ bigint53'),
+					'double ∪ decimalnum': allTypesCodecsTable.decimalnum.as('double ∪ decimalnum'),
+					'double ∪ double': allTypesCodecsTable.double.as('double ∪ double'),
+					'double ∪ float': allTypesCodecsTable.float.as('double ∪ float'),
+					'double ∪ int': allTypesCodecsTable.int.as('double ∪ int'),
+					'double ∪ medint': allTypesCodecsTable.medint.as('double ∪ medint'),
+					'double ∪ smallint': allTypesCodecsTable.smallint.as('double ∪ smallint'),
+					'double ∪ real': allTypesCodecsTable.real.as('double ∪ real'),
+					'double ∪ tinyint': allTypesCodecsTable.tinyint.as('double ∪ tinyint'),
+					'double ∪ year': allTypesCodecsTable.year.as('double ∪ year'),
+					'float ∪ serial': allTypesCodecsTable.serial.as('float ∪ serial'),
+					'float ∪ bigint53': allTypesCodecsTable.bigint53.as('float ∪ bigint53'),
+					'float ∪ decimalnum': allTypesCodecsTable.decimalnum.as('float ∪ decimalnum'),
+					'float ∪ double': allTypesCodecsTable.double.as('float ∪ double'),
+					'float ∪ float': allTypesCodecsTable.float.as('float ∪ float'),
+					'float ∪ int': allTypesCodecsTable.int.as('float ∪ int'),
+					'float ∪ medint': allTypesCodecsTable.medint.as('float ∪ medint'),
+					'float ∪ smallint': allTypesCodecsTable.smallint.as('float ∪ smallint'),
+					'float ∪ real': allTypesCodecsTable.real.as('float ∪ real'),
+					'float ∪ tinyint': allTypesCodecsTable.tinyint.as('float ∪ tinyint'),
+					'float ∪ year': allTypesCodecsTable.year.as('float ∪ year'),
+					'int ∪ serial': allTypesCodecsTable.serial.as('int ∪ serial'),
+					'int ∪ bigint53': allTypesCodecsTable.bigint53.as('int ∪ bigint53'),
+					'int ∪ decimalnum': allTypesCodecsTable.decimalnum.as('int ∪ decimalnum'),
+					'int ∪ double': allTypesCodecsTable.double.as('int ∪ double'),
+					'int ∪ float': allTypesCodecsTable.float.as('int ∪ float'),
+					'int ∪ int': allTypesCodecsTable.int.as('int ∪ int'),
+					'int ∪ medint': allTypesCodecsTable.medint.as('int ∪ medint'),
+					'int ∪ smallint': allTypesCodecsTable.smallint.as('int ∪ smallint'),
+					'int ∪ real': allTypesCodecsTable.real.as('int ∪ real'),
+					'int ∪ tinyint': allTypesCodecsTable.tinyint.as('int ∪ tinyint'),
+					'int ∪ year': allTypesCodecsTable.year.as('int ∪ year'),
+					'medint ∪ serial': allTypesCodecsTable.serial.as('medint ∪ serial'),
+					'medint ∪ bigint53': allTypesCodecsTable.bigint53.as('medint ∪ bigint53'),
+					'medint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('medint ∪ decimalnum'),
+					'medint ∪ double': allTypesCodecsTable.double.as('medint ∪ double'),
+					'medint ∪ float': allTypesCodecsTable.float.as('medint ∪ float'),
+					'medint ∪ int': allTypesCodecsTable.int.as('medint ∪ int'),
+					'medint ∪ medint': allTypesCodecsTable.medint.as('medint ∪ medint'),
+					'medint ∪ smallint': allTypesCodecsTable.smallint.as('medint ∪ smallint'),
+					'medint ∪ real': allTypesCodecsTable.real.as('medint ∪ real'),
+					'medint ∪ tinyint': allTypesCodecsTable.tinyint.as('medint ∪ tinyint'),
+					'medint ∪ year': allTypesCodecsTable.year.as('medint ∪ year'),
+					'smallint ∪ serial': allTypesCodecsTable.serial.as('smallint ∪ serial'),
+					'smallint ∪ bigint53': allTypesCodecsTable.bigint53.as('smallint ∪ bigint53'),
+					'smallint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('smallint ∪ decimalnum'),
+					'smallint ∪ double': allTypesCodecsTable.double.as('smallint ∪ double'),
+					'smallint ∪ float': allTypesCodecsTable.float.as('smallint ∪ float'),
+					'smallint ∪ int': allTypesCodecsTable.int.as('smallint ∪ int'),
+					'smallint ∪ medint': allTypesCodecsTable.medint.as('smallint ∪ medint'),
+					'smallint ∪ smallint': allTypesCodecsTable.smallint.as('smallint ∪ smallint'),
+					'smallint ∪ real': allTypesCodecsTable.real.as('smallint ∪ real'),
+					'smallint ∪ tinyint': allTypesCodecsTable.tinyint.as('smallint ∪ tinyint'),
+					'smallint ∪ year': allTypesCodecsTable.year.as('smallint ∪ year'),
+					'real ∪ serial': allTypesCodecsTable.serial.as('real ∪ serial'),
+					'real ∪ bigint53': allTypesCodecsTable.bigint53.as('real ∪ bigint53'),
+					'real ∪ decimalnum': allTypesCodecsTable.decimalnum.as('real ∪ decimalnum'),
+					'real ∪ double': allTypesCodecsTable.double.as('real ∪ double'),
+					'real ∪ float': allTypesCodecsTable.float.as('real ∪ float'),
+					'real ∪ int': allTypesCodecsTable.int.as('real ∪ int'),
+					'real ∪ medint': allTypesCodecsTable.medint.as('real ∪ medint'),
+					'real ∪ smallint': allTypesCodecsTable.smallint.as('real ∪ smallint'),
+					'real ∪ real': allTypesCodecsTable.real.as('real ∪ real'),
+					'real ∪ tinyint': allTypesCodecsTable.tinyint.as('real ∪ tinyint'),
+					'real ∪ year': allTypesCodecsTable.year.as('real ∪ year'),
+					'tinyint ∪ serial': allTypesCodecsTable.serial.as('tinyint ∪ serial'),
+					'tinyint ∪ bigint53': allTypesCodecsTable.bigint53.as('tinyint ∪ bigint53'),
+					'tinyint ∪ decimalnum': allTypesCodecsTable.decimalnum.as('tinyint ∪ decimalnum'),
+					'tinyint ∪ double': allTypesCodecsTable.double.as('tinyint ∪ double'),
+					'tinyint ∪ float': allTypesCodecsTable.float.as('tinyint ∪ float'),
+					'tinyint ∪ int': allTypesCodecsTable.int.as('tinyint ∪ int'),
+					'tinyint ∪ medint': allTypesCodecsTable.medint.as('tinyint ∪ medint'),
+					'tinyint ∪ smallint': allTypesCodecsTable.smallint.as('tinyint ∪ smallint'),
+					'tinyint ∪ real': allTypesCodecsTable.real.as('tinyint ∪ real'),
+					'tinyint ∪ tinyint': allTypesCodecsTable.tinyint.as('tinyint ∪ tinyint'),
+					'tinyint ∪ year': allTypesCodecsTable.year.as('tinyint ∪ year'),
+					'year ∪ serial': allTypesCodecsTable.serial.as('year ∪ serial'),
+					'year ∪ bigint53': allTypesCodecsTable.bigint53.as('year ∪ bigint53'),
+					'year ∪ decimalnum': allTypesCodecsTable.decimalnum.as('year ∪ decimalnum'),
+					'year ∪ double': allTypesCodecsTable.double.as('year ∪ double'),
+					'year ∪ float': allTypesCodecsTable.float.as('year ∪ float'),
+					'year ∪ int': allTypesCodecsTable.int.as('year ∪ int'),
+					'year ∪ medint': allTypesCodecsTable.medint.as('year ∪ medint'),
+					'year ∪ smallint': allTypesCodecsTable.smallint.as('year ∪ smallint'),
+					'year ∪ real': allTypesCodecsTable.real.as('year ∪ real'),
+					'year ∪ tinyint': allTypesCodecsTable.tinyint.as('year ∪ tinyint'),
+					'year ∪ year': allTypesCodecsTable.year.as('year ∪ year'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'serial ∪ serial': 1,
+				'serial ∪ bigint53': 1,
+				'serial ∪ decimalnum': 1,
+				'serial ∪ double': 1,
+				'serial ∪ float': 1,
+				'serial ∪ int': 1,
+				'serial ∪ medint': 1,
+				'serial ∪ smallint': 1,
+				'serial ∪ real': 1,
+				'serial ∪ tinyint': 1,
+				'serial ∪ year': 1,
+				'bigint53 ∪ serial': 9007199254740991,
+				'bigint53 ∪ bigint53': 9007199254740991,
+				'bigint53 ∪ decimalnum': 9007199254740991,
+				'bigint53 ∪ double': 9007199254740991,
+				'bigint53 ∪ float': 9007199254740991,
+				'bigint53 ∪ int': 9007199254740991,
+				'bigint53 ∪ medint': 9007199254740991,
+				'bigint53 ∪ smallint': 9007199254740991,
+				'bigint53 ∪ real': 9007199254740991,
+				'bigint53 ∪ tinyint': 9007199254740991,
+				'bigint53 ∪ year': 9007199254740991,
+				'decimalnum ∪ serial': 9007199254740991,
+				'decimalnum ∪ bigint53': 9007199254740991,
+				'decimalnum ∪ decimalnum': 9007199254740991,
+				'decimalnum ∪ double': 9007199254740991,
+				'decimalnum ∪ float': 9007199254740991,
+				'decimalnum ∪ int': 9007199254740991,
+				'decimalnum ∪ medint': 9007199254740991,
+				'decimalnum ∪ smallint': 9007199254740991,
+				'decimalnum ∪ real': 9007199254740991,
+				'decimalnum ∪ tinyint': 9007199254740991,
+				'decimalnum ∪ year': 9007199254740991,
+				'double ∪ serial': 15.35325689124218,
+				'double ∪ bigint53': 15.35325689124218,
+				'double ∪ decimalnum': 15.35325689124218,
+				'double ∪ double': 15.35325689124218,
+				'double ∪ float': 15.35325689124218,
+				'double ∪ int': 15.35325689124218,
+				'double ∪ medint': 15.35325689124218,
+				'double ∪ smallint': 15.35325689124218,
+				'double ∪ real': 15.35325689124218,
+				'double ∪ tinyint': 15.35325689124218,
+				'double ∪ year': 15.35325689124218,
+				'float ∪ serial': 1.048596,
+				'float ∪ bigint53': 1.048596,
+				'float ∪ decimalnum': 1.0485960245132446,
+				'float ∪ double': 1.0485960245132446,
+				'float ∪ float': 1.048596,
+				'float ∪ int': 1.0485960245132446,
+				'float ∪ medint': 1.048596,
+				'float ∪ smallint': 1.048596,
+				'float ∪ real': 1.0485960245132446,
+				'float ∪ tinyint': 1.048596,
+				'float ∪ year': 1.048596,
+				'int ∪ serial': 621,
+				'int ∪ bigint53': 621,
+				'int ∪ decimalnum': 621,
+				'int ∪ double': 621,
+				'int ∪ float': 621,
+				'int ∪ int': 621,
+				'int ∪ medint': 621,
+				'int ∪ smallint': 621,
+				'int ∪ real': 621,
+				'int ∪ tinyint': 621,
+				'int ∪ year': 621,
+				'medint ∪ serial': 560,
+				'medint ∪ bigint53': 560,
+				'medint ∪ decimalnum': 560,
+				'medint ∪ double': 560,
+				'medint ∪ float': 560,
+				'medint ∪ int': 560,
+				'medint ∪ medint': 560,
+				'medint ∪ smallint': 560,
+				'medint ∪ real': 560,
+				'medint ∪ tinyint': 560,
+				'medint ∪ year': 560,
+				'smallint ∪ serial': 14,
+				'smallint ∪ bigint53': 14,
+				'smallint ∪ decimalnum': 14,
+				'smallint ∪ double': 14,
+				'smallint ∪ float': 14,
+				'smallint ∪ int': 14,
+				'smallint ∪ medint': 14,
+				'smallint ∪ smallint': 14,
+				'smallint ∪ real': 14,
+				'smallint ∪ tinyint': 14,
+				'smallint ∪ year': 14,
+				'real ∪ serial': 1.048596,
+				'real ∪ bigint53': 1.048596,
+				'real ∪ decimalnum': 1.048596,
+				'real ∪ double': 1.048596,
+				'real ∪ float': 1.048596,
+				'real ∪ int': 1.048596,
+				'real ∪ medint': 1.048596,
+				'real ∪ smallint': 1.048596,
+				'real ∪ real': 1.048596,
+				'real ∪ tinyint': 1.048596,
+				'real ∪ year': 1.048596,
+				'tinyint ∪ serial': 7,
+				'tinyint ∪ bigint53': 7,
+				'tinyint ∪ decimalnum': 7,
+				'tinyint ∪ double': 7,
+				'tinyint ∪ float': 7,
+				'tinyint ∪ int': 7,
+				'tinyint ∪ medint': 7,
+				'tinyint ∪ smallint': 7,
+				'tinyint ∪ real': 7,
+				'tinyint ∪ tinyint': 7,
+				'tinyint ∪ year': 7,
+				'year ∪ serial': 2025,
+				'year ∪ bigint53': 2025,
+				'year ∪ decimalnum': 2025,
+				'year ∪ double': 2025,
+				'year ∪ float': 2025,
+				'year ∪ int': 2025,
+				'year ∪ medint': 2025,
+				'year ∪ smallint': 2025,
+				'year ∪ real': 2025,
+				'year ∪ tinyint': isTidb ? 2025 : 127,
+				'year ∪ year': 2025,
+			},
+			{
+				'serial ∪ serial': 1,
+				'serial ∪ bigint53': 9007199254740991,
+				'serial ∪ decimalnum': 9007199254740991,
+				'serial ∪ double': 15.35325689124218,
+				'serial ∪ float': 1.0485960245132446,
+				'serial ∪ int': 621,
+				'serial ∪ medint': 560,
+				'serial ∪ smallint': 14,
+				'serial ∪ real': 1.048596,
+				'serial ∪ tinyint': 7,
+				'serial ∪ year': 2025,
+				'bigint53 ∪ serial': 1,
+				'bigint53 ∪ bigint53': 9007199254740991,
+				'bigint53 ∪ decimalnum': 9007199254740991,
+				'bigint53 ∪ double': 15.35325689124218,
+				'bigint53 ∪ float': 1.0485960245132446,
+				'bigint53 ∪ int': 621,
+				'bigint53 ∪ medint': 560,
+				'bigint53 ∪ smallint': 14,
+				'bigint53 ∪ real': 1.048596,
+				'bigint53 ∪ tinyint': 7,
+				'bigint53 ∪ year': 2025,
+				'decimalnum ∪ serial': 1,
+				'decimalnum ∪ bigint53': 9007199254740991,
+				'decimalnum ∪ decimalnum': 9007199254740991,
+				'decimalnum ∪ double': 15.35325689124218,
+				'decimalnum ∪ float': 1.0485960245132446,
+				'decimalnum ∪ int': 621,
+				'decimalnum ∪ medint': 560,
+				'decimalnum ∪ smallint': 14,
+				'decimalnum ∪ real': 1.048596,
+				'decimalnum ∪ tinyint': 7,
+				'decimalnum ∪ year': 2025,
+				'double ∪ serial': 1,
+				'double ∪ bigint53': 9007199254740991,
+				'double ∪ decimalnum': 9007199254740991,
+				'double ∪ double': 15.35325689124218,
+				'double ∪ float': 1.0485960245132446,
+				'double ∪ int': 621,
+				'double ∪ medint': 560,
+				'double ∪ smallint': 14,
+				'double ∪ real': 1.048596,
+				'double ∪ tinyint': 7,
+				'double ∪ year': 2025,
+				'float ∪ serial': 1,
+				'float ∪ bigint53': isTidb ? 9007200000000000 : 9007199000000000,
+				'float ∪ decimalnum': 9007199254740991,
+				'float ∪ double': 15.35325689124218,
+				'float ∪ float': 1.048596,
+				'float ∪ int': 621,
+				'float ∪ medint': 560,
+				'float ∪ smallint': 14,
+				'float ∪ real': 1.048596,
+				'float ∪ tinyint': 7,
+				'float ∪ year': 2025,
+				'int ∪ serial': 1,
+				'int ∪ bigint53': 9007199254740991,
+				'int ∪ decimalnum': 9007199254740991,
+				'int ∪ double': 15.35325689124218,
+				'int ∪ float': 1.0485960245132446,
+				'int ∪ int': 621,
+				'int ∪ medint': 560,
+				'int ∪ smallint': 14,
+				'int ∪ real': 1.048596,
+				'int ∪ tinyint': 7,
+				'int ∪ year': 2025,
+				'medint ∪ serial': 1,
+				'medint ∪ bigint53': 9007199254740991,
+				'medint ∪ decimalnum': 9007199254740991,
+				'medint ∪ double': 15.35325689124218,
+				'medint ∪ float': 1.048596,
+				'medint ∪ int': 621,
+				'medint ∪ medint': 560,
+				'medint ∪ smallint': 14,
+				'medint ∪ real': 1.048596,
+				'medint ∪ tinyint': 7,
+				'medint ∪ year': 2025,
+				'smallint ∪ serial': 1,
+				'smallint ∪ bigint53': 9007199254740991,
+				'smallint ∪ decimalnum': 9007199254740991,
+				'smallint ∪ double': 15.35325689124218,
+				'smallint ∪ float': 1.048596,
+				'smallint ∪ int': 621,
+				'smallint ∪ medint': 560,
+				'smallint ∪ smallint': 14,
+				'smallint ∪ real': 1.048596,
+				'smallint ∪ tinyint': 7,
+				'smallint ∪ year': 2025,
+				'real ∪ serial': 1,
+				'real ∪ bigint53': 9007199254740991,
+				'real ∪ decimalnum': 9007199254740991,
+				'real ∪ double': 15.35325689124218,
+				'real ∪ float': 1.0485960245132446,
+				'real ∪ int': 621,
+				'real ∪ medint': 560,
+				'real ∪ smallint': 14,
+				'real ∪ real': 1.048596,
+				'real ∪ tinyint': 7,
+				'real ∪ year': 2025,
+				'tinyint ∪ serial': 1,
+				'tinyint ∪ bigint53': 9007199254740991,
+				'tinyint ∪ decimalnum': 9007199254740991,
+				'tinyint ∪ double': 15.35325689124218,
+				'tinyint ∪ float': 1.048596,
+				'tinyint ∪ int': 621,
+				'tinyint ∪ medint': 560,
+				'tinyint ∪ smallint': 14,
+				'tinyint ∪ real': 1.048596,
+				'tinyint ∪ tinyint': 7,
+				'tinyint ∪ year': isTidb ? 2025 : 127,
+				'year ∪ serial': 1,
+				'year ∪ bigint53': 9007199254740991,
+				'year ∪ decimalnum': 9007199254740991,
+				'year ∪ double': 15.35325689124218,
+				'year ∪ float': 1.048596,
+				'year ∪ int': 621,
+				'year ∪ medint': 560,
+				'year ∪ smallint': 14,
+				'year ∪ real': 1.048596,
+				'year ∪ tinyint': 7,
+				'year ∪ year': 2025,
+			},
+		]));
+
+		// ---- strings ----
+		expect(
+			await unionAll(
+				db.select({
+					'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+					'bigintstr ∪ char': allTypesCodecsTable.bigintstr.as('bigintstr ∪ char'),
+					'bigintstr ∪ decimal': allTypesCodecsTable.bigintstr.as('bigintstr ∪ decimal'),
+					'bigintstr ∪ text': allTypesCodecsTable.bigintstr.as('bigintstr ∪ text'),
+					'bigintstr ∪ tinytext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ tinytext'),
+					'bigintstr ∪ mediumtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ mediumtext'),
+					'bigintstr ∪ longtext': allTypesCodecsTable.bigintstr.as('bigintstr ∪ longtext'),
+					'bigintstr ∪ varchar': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varchar'),
+					'bigintstr ∪ varbin': allTypesCodecsTable.bigintstr.as('bigintstr ∪ varbin'),
+					'bigintstr ∪ stringblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringblob'),
+					'bigintstr ∪ stringtinyblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringtinyblob'),
+					'bigintstr ∪ stringmediumblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringmediumblob'),
+					'bigintstr ∪ stringlongblob': allTypesCodecsTable.bigintstr.as('bigintstr ∪ stringlongblob'),
+					'bigintstr ∪ datestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datestr'),
+					'bigintstr ∪ datetimestr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ datetimestr'),
+					'bigintstr ∪ timestampstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ timestampstr'),
+					'bigintstr ∪ time': allTypesCodecsTable.bigintstr.as('bigintstr ∪ time'),
+					'char ∪ bigintstr': allTypesCodecsTable.char.as('char ∪ bigintstr'),
+					'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+					'char ∪ decimal': allTypesCodecsTable.char.as('char ∪ decimal'),
+					'char ∪ text': allTypesCodecsTable.char.as('char ∪ text'),
+					'char ∪ tinytext': allTypesCodecsTable.char.as('char ∪ tinytext'),
+					'char ∪ mediumtext': allTypesCodecsTable.char.as('char ∪ mediumtext'),
+					'char ∪ longtext': allTypesCodecsTable.char.as('char ∪ longtext'),
+					'char ∪ varchar': allTypesCodecsTable.char.as('char ∪ varchar'),
+					'char ∪ varbin': allTypesCodecsTable.char.as('char ∪ varbin'),
+					'char ∪ stringblob': allTypesCodecsTable.char.as('char ∪ stringblob'),
+					'char ∪ stringtinyblob': allTypesCodecsTable.char.as('char ∪ stringtinyblob'),
+					'char ∪ stringmediumblob': allTypesCodecsTable.char.as('char ∪ stringmediumblob'),
+					'char ∪ stringlongblob': allTypesCodecsTable.char.as('char ∪ stringlongblob'),
+					'char ∪ datestr': allTypesCodecsTable.char.as('char ∪ datestr'),
+					'char ∪ datetimestr': allTypesCodecsTable.char.as('char ∪ datetimestr'),
+					'char ∪ timestampstr': allTypesCodecsTable.char.as('char ∪ timestampstr'),
+					'char ∪ time': allTypesCodecsTable.char.as('char ∪ time'),
+					'decimal ∪ bigintstr': allTypesCodecsTable.decimal.as('decimal ∪ bigintstr'),
+					'decimal ∪ char': allTypesCodecsTable.decimal.as('decimal ∪ char'),
+					'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+					'decimal ∪ text': allTypesCodecsTable.decimal.as('decimal ∪ text'),
+					'decimal ∪ tinytext': allTypesCodecsTable.decimal.as('decimal ∪ tinytext'),
+					'decimal ∪ mediumtext': allTypesCodecsTable.decimal.as('decimal ∪ mediumtext'),
+					'decimal ∪ longtext': allTypesCodecsTable.decimal.as('decimal ∪ longtext'),
+					'decimal ∪ varchar': allTypesCodecsTable.decimal.as('decimal ∪ varchar'),
+					'decimal ∪ varbin': allTypesCodecsTable.decimal.as('decimal ∪ varbin'),
+					'decimal ∪ stringblob': allTypesCodecsTable.decimal.as('decimal ∪ stringblob'),
+					'decimal ∪ stringtinyblob': allTypesCodecsTable.decimal.as('decimal ∪ stringtinyblob'),
+					'decimal ∪ stringmediumblob': allTypesCodecsTable.decimal.as('decimal ∪ stringmediumblob'),
+					'decimal ∪ stringlongblob': allTypesCodecsTable.decimal.as('decimal ∪ stringlongblob'),
+					'decimal ∪ datestr': allTypesCodecsTable.decimal.as('decimal ∪ datestr'),
+					'decimal ∪ datetimestr': allTypesCodecsTable.decimal.as('decimal ∪ datetimestr'),
+					'decimal ∪ timestampstr': allTypesCodecsTable.decimal.as('decimal ∪ timestampstr'),
+					'decimal ∪ time': allTypesCodecsTable.decimal.as('decimal ∪ time'),
+					'text ∪ bigintstr': allTypesCodecsTable.text.as('text ∪ bigintstr'),
+					'text ∪ char': allTypesCodecsTable.text.as('text ∪ char'),
+					'text ∪ decimal': allTypesCodecsTable.text.as('text ∪ decimal'),
+					'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+					'text ∪ tinytext': allTypesCodecsTable.text.as('text ∪ tinytext'),
+					'text ∪ mediumtext': allTypesCodecsTable.text.as('text ∪ mediumtext'),
+					'text ∪ longtext': allTypesCodecsTable.text.as('text ∪ longtext'),
+					'text ∪ varchar': allTypesCodecsTable.text.as('text ∪ varchar'),
+					'text ∪ varbin': allTypesCodecsTable.text.as('text ∪ varbin'),
+					'text ∪ stringblob': allTypesCodecsTable.text.as('text ∪ stringblob'),
+					'text ∪ stringtinyblob': allTypesCodecsTable.text.as('text ∪ stringtinyblob'),
+					'text ∪ stringmediumblob': allTypesCodecsTable.text.as('text ∪ stringmediumblob'),
+					'text ∪ stringlongblob': allTypesCodecsTable.text.as('text ∪ stringlongblob'),
+					'text ∪ datestr': allTypesCodecsTable.text.as('text ∪ datestr'),
+					'text ∪ datetimestr': allTypesCodecsTable.text.as('text ∪ datetimestr'),
+					'text ∪ timestampstr': allTypesCodecsTable.text.as('text ∪ timestampstr'),
+					'text ∪ time': allTypesCodecsTable.text.as('text ∪ time'),
+					'tinytext ∪ bigintstr': allTypesCodecsTable.tinytext.as('tinytext ∪ bigintstr'),
+					'tinytext ∪ char': allTypesCodecsTable.tinytext.as('tinytext ∪ char'),
+					'tinytext ∪ decimal': allTypesCodecsTable.tinytext.as('tinytext ∪ decimal'),
+					'tinytext ∪ text': allTypesCodecsTable.tinytext.as('tinytext ∪ text'),
+					'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+					'tinytext ∪ mediumtext': allTypesCodecsTable.tinytext.as('tinytext ∪ mediumtext'),
+					'tinytext ∪ longtext': allTypesCodecsTable.tinytext.as('tinytext ∪ longtext'),
+					'tinytext ∪ varchar': allTypesCodecsTable.tinytext.as('tinytext ∪ varchar'),
+					'tinytext ∪ varbin': allTypesCodecsTable.tinytext.as('tinytext ∪ varbin'),
+					'tinytext ∪ stringblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringblob'),
+					'tinytext ∪ stringtinyblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringtinyblob'),
+					'tinytext ∪ stringmediumblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringmediumblob'),
+					'tinytext ∪ stringlongblob': allTypesCodecsTable.tinytext.as('tinytext ∪ stringlongblob'),
+					'tinytext ∪ datestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datestr'),
+					'tinytext ∪ datetimestr': allTypesCodecsTable.tinytext.as('tinytext ∪ datetimestr'),
+					'tinytext ∪ timestampstr': allTypesCodecsTable.tinytext.as('tinytext ∪ timestampstr'),
+					'tinytext ∪ time': allTypesCodecsTable.tinytext.as('tinytext ∪ time'),
+					'mediumtext ∪ bigintstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ bigintstr'),
+					'mediumtext ∪ char': allTypesCodecsTable.mediumtext.as('mediumtext ∪ char'),
+					'mediumtext ∪ decimal': allTypesCodecsTable.mediumtext.as('mediumtext ∪ decimal'),
+					'mediumtext ∪ text': allTypesCodecsTable.mediumtext.as('mediumtext ∪ text'),
+					'mediumtext ∪ tinytext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ tinytext'),
+					'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+					'mediumtext ∪ longtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ longtext'),
+					'mediumtext ∪ varchar': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varchar'),
+					'mediumtext ∪ varbin': allTypesCodecsTable.mediumtext.as('mediumtext ∪ varbin'),
+					'mediumtext ∪ stringblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringblob'),
+					'mediumtext ∪ stringtinyblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringtinyblob'),
+					'mediumtext ∪ stringmediumblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringmediumblob'),
+					'mediumtext ∪ stringlongblob': allTypesCodecsTable.mediumtext.as('mediumtext ∪ stringlongblob'),
+					'mediumtext ∪ datestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datestr'),
+					'mediumtext ∪ datetimestr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ datetimestr'),
+					'mediumtext ∪ timestampstr': allTypesCodecsTable.mediumtext.as('mediumtext ∪ timestampstr'),
+					'mediumtext ∪ time': allTypesCodecsTable.mediumtext.as('mediumtext ∪ time'),
+					'longtext ∪ bigintstr': allTypesCodecsTable.longtext.as('longtext ∪ bigintstr'),
+					'longtext ∪ char': allTypesCodecsTable.longtext.as('longtext ∪ char'),
+					'longtext ∪ decimal': allTypesCodecsTable.longtext.as('longtext ∪ decimal'),
+					'longtext ∪ text': allTypesCodecsTable.longtext.as('longtext ∪ text'),
+					'longtext ∪ tinytext': allTypesCodecsTable.longtext.as('longtext ∪ tinytext'),
+					'longtext ∪ mediumtext': allTypesCodecsTable.longtext.as('longtext ∪ mediumtext'),
+					'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+					'longtext ∪ varchar': allTypesCodecsTable.longtext.as('longtext ∪ varchar'),
+					'longtext ∪ varbin': allTypesCodecsTable.longtext.as('longtext ∪ varbin'),
+					'longtext ∪ stringblob': allTypesCodecsTable.longtext.as('longtext ∪ stringblob'),
+					'longtext ∪ stringtinyblob': allTypesCodecsTable.longtext.as('longtext ∪ stringtinyblob'),
+					'longtext ∪ stringmediumblob': allTypesCodecsTable.longtext.as('longtext ∪ stringmediumblob'),
+					'longtext ∪ stringlongblob': allTypesCodecsTable.longtext.as('longtext ∪ stringlongblob'),
+					'longtext ∪ datestr': allTypesCodecsTable.longtext.as('longtext ∪ datestr'),
+					'longtext ∪ datetimestr': allTypesCodecsTable.longtext.as('longtext ∪ datetimestr'),
+					'longtext ∪ timestampstr': allTypesCodecsTable.longtext.as('longtext ∪ timestampstr'),
+					'longtext ∪ time': allTypesCodecsTable.longtext.as('longtext ∪ time'),
+					'varchar ∪ bigintstr': allTypesCodecsTable.varchar.as('varchar ∪ bigintstr'),
+					'varchar ∪ char': allTypesCodecsTable.varchar.as('varchar ∪ char'),
+					'varchar ∪ decimal': allTypesCodecsTable.varchar.as('varchar ∪ decimal'),
+					'varchar ∪ text': allTypesCodecsTable.varchar.as('varchar ∪ text'),
+					'varchar ∪ tinytext': allTypesCodecsTable.varchar.as('varchar ∪ tinytext'),
+					'varchar ∪ mediumtext': allTypesCodecsTable.varchar.as('varchar ∪ mediumtext'),
+					'varchar ∪ longtext': allTypesCodecsTable.varchar.as('varchar ∪ longtext'),
+					'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+					'varchar ∪ varbin': allTypesCodecsTable.varchar.as('varchar ∪ varbin'),
+					'varchar ∪ stringblob': allTypesCodecsTable.varchar.as('varchar ∪ stringblob'),
+					'varchar ∪ stringtinyblob': allTypesCodecsTable.varchar.as('varchar ∪ stringtinyblob'),
+					'varchar ∪ stringmediumblob': allTypesCodecsTable.varchar.as('varchar ∪ stringmediumblob'),
+					'varchar ∪ stringlongblob': allTypesCodecsTable.varchar.as('varchar ∪ stringlongblob'),
+					'varchar ∪ datestr': allTypesCodecsTable.varchar.as('varchar ∪ datestr'),
+					'varchar ∪ datetimestr': allTypesCodecsTable.varchar.as('varchar ∪ datetimestr'),
+					'varchar ∪ timestampstr': allTypesCodecsTable.varchar.as('varchar ∪ timestampstr'),
+					'varchar ∪ time': allTypesCodecsTable.varchar.as('varchar ∪ time'),
+					'varbin ∪ bigintstr': allTypesCodecsTable.varbin.as('varbin ∪ bigintstr'),
+					'varbin ∪ char': allTypesCodecsTable.varbin.as('varbin ∪ char'),
+					'varbin ∪ decimal': allTypesCodecsTable.varbin.as('varbin ∪ decimal'),
+					'varbin ∪ text': allTypesCodecsTable.varbin.as('varbin ∪ text'),
+					'varbin ∪ tinytext': allTypesCodecsTable.varbin.as('varbin ∪ tinytext'),
+					'varbin ∪ mediumtext': allTypesCodecsTable.varbin.as('varbin ∪ mediumtext'),
+					'varbin ∪ longtext': allTypesCodecsTable.varbin.as('varbin ∪ longtext'),
+					'varbin ∪ varchar': allTypesCodecsTable.varbin.as('varbin ∪ varchar'),
+					'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+					'varbin ∪ stringblob': allTypesCodecsTable.varbin.as('varbin ∪ stringblob'),
+					'varbin ∪ stringtinyblob': allTypesCodecsTable.varbin.as('varbin ∪ stringtinyblob'),
+					'varbin ∪ stringmediumblob': allTypesCodecsTable.varbin.as('varbin ∪ stringmediumblob'),
+					'varbin ∪ stringlongblob': allTypesCodecsTable.varbin.as('varbin ∪ stringlongblob'),
+					'varbin ∪ datestr': allTypesCodecsTable.varbin.as('varbin ∪ datestr'),
+					'varbin ∪ datetimestr': allTypesCodecsTable.varbin.as('varbin ∪ datetimestr'),
+					'varbin ∪ timestampstr': allTypesCodecsTable.varbin.as('varbin ∪ timestampstr'),
+					'varbin ∪ time': allTypesCodecsTable.varbin.as('varbin ∪ time'),
+					'stringblob ∪ bigintstr': allTypesCodecsTable.stringblob.as('stringblob ∪ bigintstr'),
+					'stringblob ∪ char': allTypesCodecsTable.stringblob.as('stringblob ∪ char'),
+					'stringblob ∪ decimal': allTypesCodecsTable.stringblob.as('stringblob ∪ decimal'),
+					'stringblob ∪ text': allTypesCodecsTable.stringblob.as('stringblob ∪ text'),
+					'stringblob ∪ tinytext': allTypesCodecsTable.stringblob.as('stringblob ∪ tinytext'),
+					'stringblob ∪ mediumtext': allTypesCodecsTable.stringblob.as('stringblob ∪ mediumtext'),
+					'stringblob ∪ longtext': allTypesCodecsTable.stringblob.as('stringblob ∪ longtext'),
+					'stringblob ∪ varchar': allTypesCodecsTable.stringblob.as('stringblob ∪ varchar'),
+					'stringblob ∪ varbin': allTypesCodecsTable.stringblob.as('stringblob ∪ varbin'),
+					'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+					'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringtinyblob'),
+					'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringmediumblob'),
+					'stringblob ∪ stringlongblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringlongblob'),
+					'stringblob ∪ datestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datestr'),
+					'stringblob ∪ datetimestr': allTypesCodecsTable.stringblob.as('stringblob ∪ datetimestr'),
+					'stringblob ∪ timestampstr': allTypesCodecsTable.stringblob.as('stringblob ∪ timestampstr'),
+					'stringblob ∪ time': allTypesCodecsTable.stringblob.as('stringblob ∪ time'),
+					'stringtinyblob ∪ bigintstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ bigintstr'),
+					'stringtinyblob ∪ char': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ char'),
+					'stringtinyblob ∪ decimal': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ decimal'),
+					'stringtinyblob ∪ text': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ text'),
+					'stringtinyblob ∪ tinytext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ tinytext'),
+					'stringtinyblob ∪ mediumtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ mediumtext'),
+					'stringtinyblob ∪ longtext': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ longtext'),
+					'stringtinyblob ∪ varchar': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varchar'),
+					'stringtinyblob ∪ varbin': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ varbin'),
+					'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringblob'),
+					'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringtinyblob'),
+					'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringtinyblob.as(
+						'stringtinyblob ∪ stringmediumblob',
+					),
+					'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringlongblob'),
+					'stringtinyblob ∪ datestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datestr'),
+					'stringtinyblob ∪ datetimestr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ datetimestr'),
+					'stringtinyblob ∪ timestampstr': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ timestampstr'),
+					'stringtinyblob ∪ time': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ time'),
+					'stringmediumblob ∪ bigintstr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ bigintstr'),
+					'stringmediumblob ∪ char': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ char'),
+					'stringmediumblob ∪ decimal': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ decimal'),
+					'stringmediumblob ∪ text': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ text'),
+					'stringmediumblob ∪ tinytext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ tinytext'),
+					'stringmediumblob ∪ mediumtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ mediumtext'),
+					'stringmediumblob ∪ longtext': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ longtext'),
+					'stringmediumblob ∪ varchar': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varchar'),
+					'stringmediumblob ∪ varbin': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ varbin'),
+					'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ stringblob'),
+					'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringmediumblob ∪ stringtinyblob',
+					),
+					'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringmediumblob ∪ stringmediumblob',
+					),
+					'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringmediumblob ∪ stringlongblob',
+					),
+					'stringmediumblob ∪ datestr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ datestr'),
+					'stringmediumblob ∪ datetimestr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ datetimestr'),
+					'stringmediumblob ∪ timestampstr': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ timestampstr'),
+					'stringmediumblob ∪ time': allTypesCodecsTable.stringmediumblob.as('stringmediumblob ∪ time'),
+					'stringlongblob ∪ bigintstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ bigintstr'),
+					'stringlongblob ∪ char': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ char'),
+					'stringlongblob ∪ decimal': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ decimal'),
+					'stringlongblob ∪ text': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ text'),
+					'stringlongblob ∪ tinytext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ tinytext'),
+					'stringlongblob ∪ mediumtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ mediumtext'),
+					'stringlongblob ∪ longtext': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ longtext'),
+					'stringlongblob ∪ varchar': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varchar'),
+					'stringlongblob ∪ varbin': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ varbin'),
+					'stringlongblob ∪ stringblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringblob'),
+					'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringtinyblob'),
+					'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringlongblob.as(
+						'stringlongblob ∪ stringmediumblob',
+					),
+					'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringlongblob'),
+					'stringlongblob ∪ datestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datestr'),
+					'stringlongblob ∪ datetimestr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ datetimestr'),
+					'stringlongblob ∪ timestampstr': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ timestampstr'),
+					'stringlongblob ∪ time': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ time'),
+					'datestr ∪ bigintstr': allTypesCodecsTable.datestr.as('datestr ∪ bigintstr'),
+					'datestr ∪ char': allTypesCodecsTable.datestr.as('datestr ∪ char'),
+					'datestr ∪ decimal': allTypesCodecsTable.datestr.as('datestr ∪ decimal'),
+					'datestr ∪ text': allTypesCodecsTable.datestr.as('datestr ∪ text'),
+					'datestr ∪ tinytext': allTypesCodecsTable.datestr.as('datestr ∪ tinytext'),
+					'datestr ∪ mediumtext': allTypesCodecsTable.datestr.as('datestr ∪ mediumtext'),
+					'datestr ∪ longtext': allTypesCodecsTable.datestr.as('datestr ∪ longtext'),
+					'datestr ∪ varchar': allTypesCodecsTable.datestr.as('datestr ∪ varchar'),
+					'datestr ∪ varbin': allTypesCodecsTable.datestr.as('datestr ∪ varbin'),
+					'datestr ∪ stringblob': allTypesCodecsTable.datestr.as('datestr ∪ stringblob'),
+					'datestr ∪ stringtinyblob': allTypesCodecsTable.datestr.as('datestr ∪ stringtinyblob'),
+					'datestr ∪ stringmediumblob': allTypesCodecsTable.datestr.as('datestr ∪ stringmediumblob'),
+					'datestr ∪ stringlongblob': allTypesCodecsTable.datestr.as('datestr ∪ stringlongblob'),
+					'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+					'datestr ∪ datetimestr': allTypesCodecsTable.datestr.as('datestr ∪ datetimestr'),
+					'datestr ∪ timestampstr': allTypesCodecsTable.datestr.as('datestr ∪ timestampstr'),
+					'datetimestr ∪ bigintstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ bigintstr'),
+					'datetimestr ∪ char': allTypesCodecsTable.datetimestr.as('datetimestr ∪ char'),
+					'datetimestr ∪ decimal': allTypesCodecsTable.datetimestr.as('datetimestr ∪ decimal'),
+					'datetimestr ∪ text': allTypesCodecsTable.datetimestr.as('datetimestr ∪ text'),
+					'datetimestr ∪ tinytext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ tinytext'),
+					'datetimestr ∪ mediumtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ mediumtext'),
+					'datetimestr ∪ longtext': allTypesCodecsTable.datetimestr.as('datetimestr ∪ longtext'),
+					'datetimestr ∪ varchar': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varchar'),
+					'datetimestr ∪ varbin': allTypesCodecsTable.datetimestr.as('datetimestr ∪ varbin'),
+					'datetimestr ∪ stringblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringblob'),
+					'datetimestr ∪ stringtinyblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringtinyblob'),
+					'datetimestr ∪ stringmediumblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringmediumblob'),
+					'datetimestr ∪ stringlongblob': allTypesCodecsTable.datetimestr.as('datetimestr ∪ stringlongblob'),
+					'datetimestr ∪ datestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datestr'),
+					'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+					'datetimestr ∪ timestampstr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ timestampstr'),
+					'timestampstr ∪ bigintstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ bigintstr'),
+					'timestampstr ∪ char': allTypesCodecsTable.timestampstr.as('timestampstr ∪ char'),
+					'timestampstr ∪ decimal': allTypesCodecsTable.timestampstr.as('timestampstr ∪ decimal'),
+					'timestampstr ∪ text': allTypesCodecsTable.timestampstr.as('timestampstr ∪ text'),
+					'timestampstr ∪ tinytext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ tinytext'),
+					'timestampstr ∪ mediumtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ mediumtext'),
+					'timestampstr ∪ longtext': allTypesCodecsTable.timestampstr.as('timestampstr ∪ longtext'),
+					'timestampstr ∪ varchar': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varchar'),
+					'timestampstr ∪ varbin': allTypesCodecsTable.timestampstr.as('timestampstr ∪ varbin'),
+					'timestampstr ∪ stringblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringblob'),
+					'timestampstr ∪ stringtinyblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringtinyblob'),
+					'timestampstr ∪ stringmediumblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringmediumblob'),
+					'timestampstr ∪ stringlongblob': allTypesCodecsTable.timestampstr.as('timestampstr ∪ stringlongblob'),
+					'timestampstr ∪ datestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datestr'),
+					'timestampstr ∪ datetimestr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ datetimestr'),
+					'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+					'time ∪ bigintstr': allTypesCodecsTable.time.as('time ∪ bigintstr'),
+					'time ∪ char': allTypesCodecsTable.time.as('time ∪ char'),
+					'time ∪ decimal': allTypesCodecsTable.time.as('time ∪ decimal'),
+					'time ∪ text': allTypesCodecsTable.time.as('time ∪ text'),
+					'time ∪ tinytext': allTypesCodecsTable.time.as('time ∪ tinytext'),
+					'time ∪ mediumtext': allTypesCodecsTable.time.as('time ∪ mediumtext'),
+					'time ∪ longtext': allTypesCodecsTable.time.as('time ∪ longtext'),
+					'time ∪ varchar': allTypesCodecsTable.time.as('time ∪ varchar'),
+					'time ∪ varbin': allTypesCodecsTable.time.as('time ∪ varbin'),
+					'time ∪ stringblob': allTypesCodecsTable.time.as('time ∪ stringblob'),
+					'time ∪ stringtinyblob': allTypesCodecsTable.time.as('time ∪ stringtinyblob'),
+					'time ∪ stringmediumblob': allTypesCodecsTable.time.as('time ∪ stringmediumblob'),
+					'time ∪ stringlongblob': allTypesCodecsTable.time.as('time ∪ stringlongblob'),
+					'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+					'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'bigintstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('bigintstr ∪ bigintstr'),
+					'bigintstr ∪ char': allTypesCodecsTable.char.as('bigintstr ∪ char'),
+					'bigintstr ∪ decimal': allTypesCodecsTable.decimal.as('bigintstr ∪ decimal'),
+					'bigintstr ∪ text': allTypesCodecsTable.text.as('bigintstr ∪ text'),
+					'bigintstr ∪ tinytext': allTypesCodecsTable.tinytext.as('bigintstr ∪ tinytext'),
+					'bigintstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('bigintstr ∪ mediumtext'),
+					'bigintstr ∪ longtext': allTypesCodecsTable.longtext.as('bigintstr ∪ longtext'),
+					'bigintstr ∪ varchar': allTypesCodecsTable.varchar.as('bigintstr ∪ varchar'),
+					'bigintstr ∪ varbin': allTypesCodecsTable.varbin.as('bigintstr ∪ varbin'),
+					'bigintstr ∪ stringblob': allTypesCodecsTable.stringblob.as('bigintstr ∪ stringblob'),
+					'bigintstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('bigintstr ∪ stringtinyblob'),
+					'bigintstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('bigintstr ∪ stringmediumblob'),
+					'bigintstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('bigintstr ∪ stringlongblob'),
+					'bigintstr ∪ datestr': allTypesCodecsTable.datestr.as('bigintstr ∪ datestr'),
+					'bigintstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('bigintstr ∪ datetimestr'),
+					'bigintstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('bigintstr ∪ timestampstr'),
+					'bigintstr ∪ time': allTypesCodecsTable.time.as('bigintstr ∪ time'),
+					'char ∪ bigintstr': allTypesCodecsTable.bigintstr.as('char ∪ bigintstr'),
+					'char ∪ char': allTypesCodecsTable.char.as('char ∪ char'),
+					'char ∪ decimal': allTypesCodecsTable.decimal.as('char ∪ decimal'),
+					'char ∪ text': allTypesCodecsTable.text.as('char ∪ text'),
+					'char ∪ tinytext': allTypesCodecsTable.tinytext.as('char ∪ tinytext'),
+					'char ∪ mediumtext': allTypesCodecsTable.mediumtext.as('char ∪ mediumtext'),
+					'char ∪ longtext': allTypesCodecsTable.longtext.as('char ∪ longtext'),
+					'char ∪ varchar': allTypesCodecsTable.varchar.as('char ∪ varchar'),
+					'char ∪ varbin': allTypesCodecsTable.varbin.as('char ∪ varbin'),
+					'char ∪ stringblob': allTypesCodecsTable.stringblob.as('char ∪ stringblob'),
+					'char ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('char ∪ stringtinyblob'),
+					'char ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('char ∪ stringmediumblob'),
+					'char ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('char ∪ stringlongblob'),
+					'char ∪ datestr': allTypesCodecsTable.datestr.as('char ∪ datestr'),
+					'char ∪ datetimestr': allTypesCodecsTable.datetimestr.as('char ∪ datetimestr'),
+					'char ∪ timestampstr': allTypesCodecsTable.timestampstr.as('char ∪ timestampstr'),
+					'char ∪ time': allTypesCodecsTable.time.as('char ∪ time'),
+					'decimal ∪ bigintstr': allTypesCodecsTable.bigintstr.as('decimal ∪ bigintstr'),
+					'decimal ∪ char': allTypesCodecsTable.char.as('decimal ∪ char'),
+					'decimal ∪ decimal': allTypesCodecsTable.decimal.as('decimal ∪ decimal'),
+					'decimal ∪ text': allTypesCodecsTable.text.as('decimal ∪ text'),
+					'decimal ∪ tinytext': allTypesCodecsTable.tinytext.as('decimal ∪ tinytext'),
+					'decimal ∪ mediumtext': allTypesCodecsTable.mediumtext.as('decimal ∪ mediumtext'),
+					'decimal ∪ longtext': allTypesCodecsTable.longtext.as('decimal ∪ longtext'),
+					'decimal ∪ varchar': allTypesCodecsTable.varchar.as('decimal ∪ varchar'),
+					'decimal ∪ varbin': allTypesCodecsTable.varbin.as('decimal ∪ varbin'),
+					'decimal ∪ stringblob': allTypesCodecsTable.stringblob.as('decimal ∪ stringblob'),
+					'decimal ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('decimal ∪ stringtinyblob'),
+					'decimal ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('decimal ∪ stringmediumblob'),
+					'decimal ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('decimal ∪ stringlongblob'),
+					'decimal ∪ datestr': allTypesCodecsTable.datestr.as('decimal ∪ datestr'),
+					'decimal ∪ datetimestr': allTypesCodecsTable.datetimestr.as('decimal ∪ datetimestr'),
+					'decimal ∪ timestampstr': allTypesCodecsTable.timestampstr.as('decimal ∪ timestampstr'),
+					'decimal ∪ time': allTypesCodecsTable.time.as('decimal ∪ time'),
+					'text ∪ bigintstr': allTypesCodecsTable.bigintstr.as('text ∪ bigintstr'),
+					'text ∪ char': allTypesCodecsTable.char.as('text ∪ char'),
+					'text ∪ decimal': allTypesCodecsTable.decimal.as('text ∪ decimal'),
+					'text ∪ text': allTypesCodecsTable.text.as('text ∪ text'),
+					'text ∪ tinytext': allTypesCodecsTable.tinytext.as('text ∪ tinytext'),
+					'text ∪ mediumtext': allTypesCodecsTable.mediumtext.as('text ∪ mediumtext'),
+					'text ∪ longtext': allTypesCodecsTable.longtext.as('text ∪ longtext'),
+					'text ∪ varchar': allTypesCodecsTable.varchar.as('text ∪ varchar'),
+					'text ∪ varbin': allTypesCodecsTable.varbin.as('text ∪ varbin'),
+					'text ∪ stringblob': allTypesCodecsTable.stringblob.as('text ∪ stringblob'),
+					'text ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('text ∪ stringtinyblob'),
+					'text ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('text ∪ stringmediumblob'),
+					'text ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('text ∪ stringlongblob'),
+					'text ∪ datestr': allTypesCodecsTable.datestr.as('text ∪ datestr'),
+					'text ∪ datetimestr': allTypesCodecsTable.datetimestr.as('text ∪ datetimestr'),
+					'text ∪ timestampstr': allTypesCodecsTable.timestampstr.as('text ∪ timestampstr'),
+					'text ∪ time': allTypesCodecsTable.time.as('text ∪ time'),
+					'tinytext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('tinytext ∪ bigintstr'),
+					'tinytext ∪ char': allTypesCodecsTable.char.as('tinytext ∪ char'),
+					'tinytext ∪ decimal': allTypesCodecsTable.decimal.as('tinytext ∪ decimal'),
+					'tinytext ∪ text': allTypesCodecsTable.text.as('tinytext ∪ text'),
+					'tinytext ∪ tinytext': allTypesCodecsTable.tinytext.as('tinytext ∪ tinytext'),
+					'tinytext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('tinytext ∪ mediumtext'),
+					'tinytext ∪ longtext': allTypesCodecsTable.longtext.as('tinytext ∪ longtext'),
+					'tinytext ∪ varchar': allTypesCodecsTable.varchar.as('tinytext ∪ varchar'),
+					'tinytext ∪ varbin': allTypesCodecsTable.varbin.as('tinytext ∪ varbin'),
+					'tinytext ∪ stringblob': allTypesCodecsTable.stringblob.as('tinytext ∪ stringblob'),
+					'tinytext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('tinytext ∪ stringtinyblob'),
+					'tinytext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('tinytext ∪ stringmediumblob'),
+					'tinytext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('tinytext ∪ stringlongblob'),
+					'tinytext ∪ datestr': allTypesCodecsTable.datestr.as('tinytext ∪ datestr'),
+					'tinytext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('tinytext ∪ datetimestr'),
+					'tinytext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('tinytext ∪ timestampstr'),
+					'tinytext ∪ time': allTypesCodecsTable.time.as('tinytext ∪ time'),
+					'mediumtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('mediumtext ∪ bigintstr'),
+					'mediumtext ∪ char': allTypesCodecsTable.char.as('mediumtext ∪ char'),
+					'mediumtext ∪ decimal': allTypesCodecsTable.decimal.as('mediumtext ∪ decimal'),
+					'mediumtext ∪ text': allTypesCodecsTable.text.as('mediumtext ∪ text'),
+					'mediumtext ∪ tinytext': allTypesCodecsTable.tinytext.as('mediumtext ∪ tinytext'),
+					'mediumtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('mediumtext ∪ mediumtext'),
+					'mediumtext ∪ longtext': allTypesCodecsTable.longtext.as('mediumtext ∪ longtext'),
+					'mediumtext ∪ varchar': allTypesCodecsTable.varchar.as('mediumtext ∪ varchar'),
+					'mediumtext ∪ varbin': allTypesCodecsTable.varbin.as('mediumtext ∪ varbin'),
+					'mediumtext ∪ stringblob': allTypesCodecsTable.stringblob.as('mediumtext ∪ stringblob'),
+					'mediumtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('mediumtext ∪ stringtinyblob'),
+					'mediumtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('mediumtext ∪ stringmediumblob'),
+					'mediumtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('mediumtext ∪ stringlongblob'),
+					'mediumtext ∪ datestr': allTypesCodecsTable.datestr.as('mediumtext ∪ datestr'),
+					'mediumtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('mediumtext ∪ datetimestr'),
+					'mediumtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('mediumtext ∪ timestampstr'),
+					'mediumtext ∪ time': allTypesCodecsTable.time.as('mediumtext ∪ time'),
+					'longtext ∪ bigintstr': allTypesCodecsTable.bigintstr.as('longtext ∪ bigintstr'),
+					'longtext ∪ char': allTypesCodecsTable.char.as('longtext ∪ char'),
+					'longtext ∪ decimal': allTypesCodecsTable.decimal.as('longtext ∪ decimal'),
+					'longtext ∪ text': allTypesCodecsTable.text.as('longtext ∪ text'),
+					'longtext ∪ tinytext': allTypesCodecsTable.tinytext.as('longtext ∪ tinytext'),
+					'longtext ∪ mediumtext': allTypesCodecsTable.mediumtext.as('longtext ∪ mediumtext'),
+					'longtext ∪ longtext': allTypesCodecsTable.longtext.as('longtext ∪ longtext'),
+					'longtext ∪ varchar': allTypesCodecsTable.varchar.as('longtext ∪ varchar'),
+					'longtext ∪ varbin': allTypesCodecsTable.varbin.as('longtext ∪ varbin'),
+					'longtext ∪ stringblob': allTypesCodecsTable.stringblob.as('longtext ∪ stringblob'),
+					'longtext ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('longtext ∪ stringtinyblob'),
+					'longtext ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('longtext ∪ stringmediumblob'),
+					'longtext ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('longtext ∪ stringlongblob'),
+					'longtext ∪ datestr': allTypesCodecsTable.datestr.as('longtext ∪ datestr'),
+					'longtext ∪ datetimestr': allTypesCodecsTable.datetimestr.as('longtext ∪ datetimestr'),
+					'longtext ∪ timestampstr': allTypesCodecsTable.timestampstr.as('longtext ∪ timestampstr'),
+					'longtext ∪ time': allTypesCodecsTable.time.as('longtext ∪ time'),
+					'varchar ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varchar ∪ bigintstr'),
+					'varchar ∪ char': allTypesCodecsTable.char.as('varchar ∪ char'),
+					'varchar ∪ decimal': allTypesCodecsTable.decimal.as('varchar ∪ decimal'),
+					'varchar ∪ text': allTypesCodecsTable.text.as('varchar ∪ text'),
+					'varchar ∪ tinytext': allTypesCodecsTable.tinytext.as('varchar ∪ tinytext'),
+					'varchar ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varchar ∪ mediumtext'),
+					'varchar ∪ longtext': allTypesCodecsTable.longtext.as('varchar ∪ longtext'),
+					'varchar ∪ varchar': allTypesCodecsTable.varchar.as('varchar ∪ varchar'),
+					'varchar ∪ varbin': allTypesCodecsTable.varbin.as('varchar ∪ varbin'),
+					'varchar ∪ stringblob': allTypesCodecsTable.stringblob.as('varchar ∪ stringblob'),
+					'varchar ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varchar ∪ stringtinyblob'),
+					'varchar ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varchar ∪ stringmediumblob'),
+					'varchar ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varchar ∪ stringlongblob'),
+					'varchar ∪ datestr': allTypesCodecsTable.datestr.as('varchar ∪ datestr'),
+					'varchar ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varchar ∪ datetimestr'),
+					'varchar ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varchar ∪ timestampstr'),
+					'varchar ∪ time': allTypesCodecsTable.time.as('varchar ∪ time'),
+					'varbin ∪ bigintstr': allTypesCodecsTable.bigintstr.as('varbin ∪ bigintstr'),
+					'varbin ∪ char': allTypesCodecsTable.char.as('varbin ∪ char'),
+					'varbin ∪ decimal': allTypesCodecsTable.decimal.as('varbin ∪ decimal'),
+					'varbin ∪ text': allTypesCodecsTable.text.as('varbin ∪ text'),
+					'varbin ∪ tinytext': allTypesCodecsTable.tinytext.as('varbin ∪ tinytext'),
+					'varbin ∪ mediumtext': allTypesCodecsTable.mediumtext.as('varbin ∪ mediumtext'),
+					'varbin ∪ longtext': allTypesCodecsTable.longtext.as('varbin ∪ longtext'),
+					'varbin ∪ varchar': allTypesCodecsTable.varchar.as('varbin ∪ varchar'),
+					'varbin ∪ varbin': allTypesCodecsTable.varbin.as('varbin ∪ varbin'),
+					'varbin ∪ stringblob': allTypesCodecsTable.stringblob.as('varbin ∪ stringblob'),
+					'varbin ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('varbin ∪ stringtinyblob'),
+					'varbin ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('varbin ∪ stringmediumblob'),
+					'varbin ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('varbin ∪ stringlongblob'),
+					'varbin ∪ datestr': allTypesCodecsTable.datestr.as('varbin ∪ datestr'),
+					'varbin ∪ datetimestr': allTypesCodecsTable.datetimestr.as('varbin ∪ datetimestr'),
+					'varbin ∪ timestampstr': allTypesCodecsTable.timestampstr.as('varbin ∪ timestampstr'),
+					'varbin ∪ time': allTypesCodecsTable.time.as('varbin ∪ time'),
+					'stringblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringblob ∪ bigintstr'),
+					'stringblob ∪ char': allTypesCodecsTable.char.as('stringblob ∪ char'),
+					'stringblob ∪ decimal': allTypesCodecsTable.decimal.as('stringblob ∪ decimal'),
+					'stringblob ∪ text': allTypesCodecsTable.text.as('stringblob ∪ text'),
+					'stringblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringblob ∪ tinytext'),
+					'stringblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringblob ∪ mediumtext'),
+					'stringblob ∪ longtext': allTypesCodecsTable.longtext.as('stringblob ∪ longtext'),
+					'stringblob ∪ varchar': allTypesCodecsTable.varchar.as('stringblob ∪ varchar'),
+					'stringblob ∪ varbin': allTypesCodecsTable.varbin.as('stringblob ∪ varbin'),
+					'stringblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringblob ∪ stringblob'),
+					'stringblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringblob ∪ stringtinyblob'),
+					'stringblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('stringblob ∪ stringmediumblob'),
+					'stringblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringblob ∪ stringlongblob'),
+					'stringblob ∪ datestr': allTypesCodecsTable.datestr.as('stringblob ∪ datestr'),
+					'stringblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringblob ∪ datetimestr'),
+					'stringblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringblob ∪ timestampstr'),
+					'stringblob ∪ time': allTypesCodecsTable.time.as('stringblob ∪ time'),
+					'stringtinyblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringtinyblob ∪ bigintstr'),
+					'stringtinyblob ∪ char': allTypesCodecsTable.char.as('stringtinyblob ∪ char'),
+					'stringtinyblob ∪ decimal': allTypesCodecsTable.decimal.as('stringtinyblob ∪ decimal'),
+					'stringtinyblob ∪ text': allTypesCodecsTable.text.as('stringtinyblob ∪ text'),
+					'stringtinyblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringtinyblob ∪ tinytext'),
+					'stringtinyblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringtinyblob ∪ mediumtext'),
+					'stringtinyblob ∪ longtext': allTypesCodecsTable.longtext.as('stringtinyblob ∪ longtext'),
+					'stringtinyblob ∪ varchar': allTypesCodecsTable.varchar.as('stringtinyblob ∪ varchar'),
+					'stringtinyblob ∪ varbin': allTypesCodecsTable.varbin.as('stringtinyblob ∪ varbin'),
+					'stringtinyblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringtinyblob ∪ stringblob'),
+					'stringtinyblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringtinyblob ∪ stringtinyblob'),
+					'stringtinyblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringtinyblob ∪ stringmediumblob',
+					),
+					'stringtinyblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringtinyblob ∪ stringlongblob'),
+					'stringtinyblob ∪ datestr': allTypesCodecsTable.datestr.as('stringtinyblob ∪ datestr'),
+					'stringtinyblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringtinyblob ∪ datetimestr'),
+					'stringtinyblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringtinyblob ∪ timestampstr'),
+					'stringtinyblob ∪ time': allTypesCodecsTable.time.as('stringtinyblob ∪ time'),
+					'stringmediumblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringmediumblob ∪ bigintstr'),
+					'stringmediumblob ∪ char': allTypesCodecsTable.char.as('stringmediumblob ∪ char'),
+					'stringmediumblob ∪ decimal': allTypesCodecsTable.decimal.as('stringmediumblob ∪ decimal'),
+					'stringmediumblob ∪ text': allTypesCodecsTable.text.as('stringmediumblob ∪ text'),
+					'stringmediumblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringmediumblob ∪ tinytext'),
+					'stringmediumblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringmediumblob ∪ mediumtext'),
+					'stringmediumblob ∪ longtext': allTypesCodecsTable.longtext.as('stringmediumblob ∪ longtext'),
+					'stringmediumblob ∪ varchar': allTypesCodecsTable.varchar.as('stringmediumblob ∪ varchar'),
+					'stringmediumblob ∪ varbin': allTypesCodecsTable.varbin.as('stringmediumblob ∪ varbin'),
+					'stringmediumblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringmediumblob ∪ stringblob'),
+					'stringmediumblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as(
+						'stringmediumblob ∪ stringtinyblob',
+					),
+					'stringmediumblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringmediumblob ∪ stringmediumblob',
+					),
+					'stringmediumblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as(
+						'stringmediumblob ∪ stringlongblob',
+					),
+					'stringmediumblob ∪ datestr': allTypesCodecsTable.datestr.as('stringmediumblob ∪ datestr'),
+					'stringmediumblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringmediumblob ∪ datetimestr'),
+					'stringmediumblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringmediumblob ∪ timestampstr'),
+					'stringmediumblob ∪ time': allTypesCodecsTable.time.as('stringmediumblob ∪ time'),
+					'stringlongblob ∪ bigintstr': allTypesCodecsTable.bigintstr.as('stringlongblob ∪ bigintstr'),
+					'stringlongblob ∪ char': allTypesCodecsTable.char.as('stringlongblob ∪ char'),
+					'stringlongblob ∪ decimal': allTypesCodecsTable.decimal.as('stringlongblob ∪ decimal'),
+					'stringlongblob ∪ text': allTypesCodecsTable.text.as('stringlongblob ∪ text'),
+					'stringlongblob ∪ tinytext': allTypesCodecsTable.tinytext.as('stringlongblob ∪ tinytext'),
+					'stringlongblob ∪ mediumtext': allTypesCodecsTable.mediumtext.as('stringlongblob ∪ mediumtext'),
+					'stringlongblob ∪ longtext': allTypesCodecsTable.longtext.as('stringlongblob ∪ longtext'),
+					'stringlongblob ∪ varchar': allTypesCodecsTable.varchar.as('stringlongblob ∪ varchar'),
+					'stringlongblob ∪ varbin': allTypesCodecsTable.varbin.as('stringlongblob ∪ varbin'),
+					'stringlongblob ∪ stringblob': allTypesCodecsTable.stringblob.as('stringlongblob ∪ stringblob'),
+					'stringlongblob ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('stringlongblob ∪ stringtinyblob'),
+					'stringlongblob ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as(
+						'stringlongblob ∪ stringmediumblob',
+					),
+					'stringlongblob ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('stringlongblob ∪ stringlongblob'),
+					'stringlongblob ∪ datestr': allTypesCodecsTable.datestr.as('stringlongblob ∪ datestr'),
+					'stringlongblob ∪ datetimestr': allTypesCodecsTable.datetimestr.as('stringlongblob ∪ datetimestr'),
+					'stringlongblob ∪ timestampstr': allTypesCodecsTable.timestampstr.as('stringlongblob ∪ timestampstr'),
+					'stringlongblob ∪ time': allTypesCodecsTable.time.as('stringlongblob ∪ time'),
+					'datestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datestr ∪ bigintstr'),
+					'datestr ∪ char': allTypesCodecsTable.char.as('datestr ∪ char'),
+					'datestr ∪ decimal': allTypesCodecsTable.decimal.as('datestr ∪ decimal'),
+					'datestr ∪ text': allTypesCodecsTable.text.as('datestr ∪ text'),
+					'datestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datestr ∪ tinytext'),
+					'datestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datestr ∪ mediumtext'),
+					'datestr ∪ longtext': allTypesCodecsTable.longtext.as('datestr ∪ longtext'),
+					'datestr ∪ varchar': allTypesCodecsTable.varchar.as('datestr ∪ varchar'),
+					'datestr ∪ varbin': allTypesCodecsTable.varbin.as('datestr ∪ varbin'),
+					'datestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datestr ∪ stringblob'),
+					'datestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datestr ∪ stringtinyblob'),
+					'datestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('datestr ∪ stringmediumblob'),
+					'datestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datestr ∪ stringlongblob'),
+					'datestr ∪ datestr': allTypesCodecsTable.datestr.as('datestr ∪ datestr'),
+					'datestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datestr ∪ datetimestr'),
+					'datestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datestr ∪ timestampstr'),
+					'datetimestr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('datetimestr ∪ bigintstr'),
+					'datetimestr ∪ char': allTypesCodecsTable.char.as('datetimestr ∪ char'),
+					'datetimestr ∪ decimal': allTypesCodecsTable.decimal.as('datetimestr ∪ decimal'),
+					'datetimestr ∪ text': allTypesCodecsTable.text.as('datetimestr ∪ text'),
+					'datetimestr ∪ tinytext': allTypesCodecsTable.tinytext.as('datetimestr ∪ tinytext'),
+					'datetimestr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('datetimestr ∪ mediumtext'),
+					'datetimestr ∪ longtext': allTypesCodecsTable.longtext.as('datetimestr ∪ longtext'),
+					'datetimestr ∪ varchar': allTypesCodecsTable.varchar.as('datetimestr ∪ varchar'),
+					'datetimestr ∪ varbin': allTypesCodecsTable.varbin.as('datetimestr ∪ varbin'),
+					'datetimestr ∪ stringblob': allTypesCodecsTable.stringblob.as('datetimestr ∪ stringblob'),
+					'datetimestr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('datetimestr ∪ stringtinyblob'),
+					'datetimestr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('datetimestr ∪ stringmediumblob'),
+					'datetimestr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('datetimestr ∪ stringlongblob'),
+					'datetimestr ∪ datestr': allTypesCodecsTable.datestr.as('datetimestr ∪ datestr'),
+					'datetimestr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('datetimestr ∪ datetimestr'),
+					'datetimestr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('datetimestr ∪ timestampstr'),
+					'timestampstr ∪ bigintstr': allTypesCodecsTable.bigintstr.as('timestampstr ∪ bigintstr'),
+					'timestampstr ∪ char': allTypesCodecsTable.char.as('timestampstr ∪ char'),
+					'timestampstr ∪ decimal': allTypesCodecsTable.decimal.as('timestampstr ∪ decimal'),
+					'timestampstr ∪ text': allTypesCodecsTable.text.as('timestampstr ∪ text'),
+					'timestampstr ∪ tinytext': allTypesCodecsTable.tinytext.as('timestampstr ∪ tinytext'),
+					'timestampstr ∪ mediumtext': allTypesCodecsTable.mediumtext.as('timestampstr ∪ mediumtext'),
+					'timestampstr ∪ longtext': allTypesCodecsTable.longtext.as('timestampstr ∪ longtext'),
+					'timestampstr ∪ varchar': allTypesCodecsTable.varchar.as('timestampstr ∪ varchar'),
+					'timestampstr ∪ varbin': allTypesCodecsTable.varbin.as('timestampstr ∪ varbin'),
+					'timestampstr ∪ stringblob': allTypesCodecsTable.stringblob.as('timestampstr ∪ stringblob'),
+					'timestampstr ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('timestampstr ∪ stringtinyblob'),
+					'timestampstr ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('timestampstr ∪ stringmediumblob'),
+					'timestampstr ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('timestampstr ∪ stringlongblob'),
+					'timestampstr ∪ datestr': allTypesCodecsTable.datestr.as('timestampstr ∪ datestr'),
+					'timestampstr ∪ datetimestr': allTypesCodecsTable.datetimestr.as('timestampstr ∪ datetimestr'),
+					'timestampstr ∪ timestampstr': allTypesCodecsTable.timestampstr.as('timestampstr ∪ timestampstr'),
+					'time ∪ bigintstr': allTypesCodecsTable.bigintstr.as('time ∪ bigintstr'),
+					'time ∪ char': allTypesCodecsTable.char.as('time ∪ char'),
+					'time ∪ decimal': allTypesCodecsTable.decimal.as('time ∪ decimal'),
+					'time ∪ text': allTypesCodecsTable.text.as('time ∪ text'),
+					'time ∪ tinytext': allTypesCodecsTable.tinytext.as('time ∪ tinytext'),
+					'time ∪ mediumtext': allTypesCodecsTable.mediumtext.as('time ∪ mediumtext'),
+					'time ∪ longtext': allTypesCodecsTable.longtext.as('time ∪ longtext'),
+					'time ∪ varchar': allTypesCodecsTable.varchar.as('time ∪ varchar'),
+					'time ∪ varbin': allTypesCodecsTable.varbin.as('time ∪ varbin'),
+					'time ∪ stringblob': allTypesCodecsTable.stringblob.as('time ∪ stringblob'),
+					'time ∪ stringtinyblob': allTypesCodecsTable.stringtinyblob.as('time ∪ stringtinyblob'),
+					'time ∪ stringmediumblob': allTypesCodecsTable.stringmediumblob.as('time ∪ stringmediumblob'),
+					'time ∪ stringlongblob': allTypesCodecsTable.stringlongblob.as('time ∪ stringlongblob'),
+					'time ∪ time': allTypesCodecsTable.time.as('time ∪ time'),
+					'binary ∪ binary': allTypesCodecsTable.binary.as('binary ∪ binary'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'bigintstr ∪ bigintstr': '5044565289845416380',
+				'bigintstr ∪ char': '5044565289845416380',
+				'bigintstr ∪ decimal': '5044565289845416380',
+				'bigintstr ∪ text': '5044565289845416380',
+				'bigintstr ∪ tinytext': '5044565289845416380',
+				'bigintstr ∪ mediumtext': '5044565289845416380',
+				'bigintstr ∪ longtext': '5044565289845416380',
+				'bigintstr ∪ varchar': '5044565289845416380',
+				'bigintstr ∪ varbin': binWidens ? '0000000000000010000' : '5044565289845416380',
+				'bigintstr ∪ stringblob': '5044565289845416380',
+				'bigintstr ∪ stringtinyblob': '5044565289845416380',
+				'bigintstr ∪ stringmediumblob': '5044565289845416380',
+				'bigintstr ∪ stringlongblob': '5044565289845416380',
+				'bigintstr ∪ datestr': '5044565289845416380',
+				'bigintstr ∪ datetimestr': '5044565289845416380',
+				'bigintstr ∪ timestampstr': '5044565289845416380',
+				'bigintstr ∪ time': '5044565289845416380',
+				'char ∪ bigintstr': 'c',
+				'char ∪ char': 'c',
+				'char ∪ decimal': 'c',
+				'char ∪ text': 'c',
+				'char ∪ tinytext': 'c',
+				'char ∪ mediumtext': 'c',
+				'char ∪ longtext': 'c',
+				'char ∪ varchar': 'c',
+				'char ∪ varbin': binWidens ? '0' : 'c',
+				'char ∪ stringblob': 'c',
+				'char ∪ stringtinyblob': 'c',
+				'char ∪ stringmediumblob': 'c',
+				'char ∪ stringlongblob': 'c',
+				'char ∪ datestr': 'c',
+				'char ∪ datetimestr': 'c',
+				'char ∪ timestampstr': 'c',
+				'char ∪ time': 'c',
+				'decimal ∪ bigintstr': '47521',
+				'decimal ∪ char': '47521',
+				'decimal ∪ decimal': '47521',
+				'decimal ∪ text': '47521',
+				'decimal ∪ tinytext': '47521',
+				'decimal ∪ mediumtext': '47521',
+				'decimal ∪ longtext': '47521',
+				'decimal ∪ varchar': '47521',
+				'decimal ∪ varbin': binWidens ? '00001' : '47521',
+				'decimal ∪ stringblob': '47521',
+				'decimal ∪ stringtinyblob': '47521',
+				'decimal ∪ stringmediumblob': '47521',
+				'decimal ∪ stringlongblob': '47521',
+				'decimal ∪ datestr': '47521',
+				'decimal ∪ datetimestr': '47521',
+				'decimal ∪ timestampstr': '47521',
+				'decimal ∪ time': '47521',
+				'text ∪ bigintstr': 'C4-',
+				'text ∪ char': 'C4-',
+				'text ∪ decimal': 'C4-',
+				'text ∪ text': 'C4-',
+				'text ∪ tinytext': 'C4-',
+				'text ∪ mediumtext': 'C4-',
+				'text ∪ longtext': 'C4-',
+				'text ∪ varchar': 'C4-',
+				'text ∪ varbin': 'C4-',
+				'text ∪ stringblob': 'C4-',
+				'text ∪ stringtinyblob': 'C4-',
+				'text ∪ stringmediumblob': 'C4-',
+				'text ∪ stringlongblob': 'C4-',
+				'text ∪ datestr': 'C4-',
+				'text ∪ datetimestr': 'C4-',
+				'text ∪ timestampstr': 'C4-',
+				'text ∪ time': 'C4-',
+				'tinytext ∪ bigintstr': 'tiny text',
+				'tinytext ∪ char': 'tiny text',
+				'tinytext ∪ decimal': 'tiny text',
+				'tinytext ∪ text': 'tiny text',
+				'tinytext ∪ tinytext': 'tiny text',
+				'tinytext ∪ mediumtext': 'tiny text',
+				'tinytext ∪ longtext': 'tiny text',
+				'tinytext ∪ varchar': 'tiny text',
+				'tinytext ∪ varbin': 'tiny text',
+				'tinytext ∪ stringblob': 'tiny text',
+				'tinytext ∪ stringtinyblob': 'tiny text',
+				'tinytext ∪ stringmediumblob': 'tiny text',
+				'tinytext ∪ stringlongblob': 'tiny text',
+				'tinytext ∪ datestr': 'tiny text',
+				'tinytext ∪ datetimestr': 'tiny text',
+				'tinytext ∪ timestampstr': 'tiny text',
+				'tinytext ∪ time': 'tiny text',
+				'mediumtext ∪ bigintstr': 'medium text',
+				'mediumtext ∪ char': 'medium text',
+				'mediumtext ∪ decimal': 'medium text',
+				'mediumtext ∪ text': 'medium text',
+				'mediumtext ∪ tinytext': 'medium text',
+				'mediumtext ∪ mediumtext': 'medium text',
+				'mediumtext ∪ longtext': 'medium text',
+				'mediumtext ∪ varchar': 'medium text',
+				'mediumtext ∪ varbin': 'medium text',
+				'mediumtext ∪ stringblob': 'medium text',
+				'mediumtext ∪ stringtinyblob': 'medium text',
+				'mediumtext ∪ stringmediumblob': 'medium text',
+				'mediumtext ∪ stringlongblob': 'medium text',
+				'mediumtext ∪ datestr': 'medium text',
+				'mediumtext ∪ datetimestr': 'medium text',
+				'mediumtext ∪ timestampstr': 'medium text',
+				'mediumtext ∪ time': 'medium text',
+				'longtext ∪ bigintstr': 'long text',
+				'longtext ∪ char': 'long text',
+				'longtext ∪ decimal': 'long text',
+				'longtext ∪ text': 'long text',
+				'longtext ∪ tinytext': 'long text',
+				'longtext ∪ mediumtext': 'long text',
+				'longtext ∪ longtext': 'long text',
+				'longtext ∪ varchar': 'long text',
+				'longtext ∪ varbin': 'long text',
+				'longtext ∪ stringblob': 'long text',
+				'longtext ∪ stringtinyblob': 'long text',
+				'longtext ∪ stringmediumblob': 'long text',
+				'longtext ∪ stringlongblob': 'long text',
+				'longtext ∪ datestr': 'long text',
+				'longtext ∪ datetimestr': 'long text',
+				'longtext ∪ timestampstr': 'long text',
+				'longtext ∪ time': 'long text',
+				'varchar ∪ bigintstr': 'VCHAR',
+				'varchar ∪ char': 'VCHAR',
+				'varchar ∪ decimal': 'VCHAR',
+				'varchar ∪ text': 'VCHAR',
+				'varchar ∪ tinytext': 'VCHAR',
+				'varchar ∪ mediumtext': 'VCHAR',
+				'varchar ∪ longtext': 'VCHAR',
+				'varchar ∪ varchar': 'VCHAR',
+				'varchar ∪ varbin': binWidens ? '00000' : 'VCHAR',
+				'varchar ∪ stringblob': 'VCHAR',
+				'varchar ∪ stringtinyblob': 'VCHAR',
+				'varchar ∪ stringmediumblob': 'VCHAR',
+				'varchar ∪ stringlongblob': 'VCHAR',
+				'varchar ∪ datestr': 'VCHAR',
+				'varchar ∪ datetimestr': 'VCHAR',
+				'varchar ∪ timestampstr': 'VCHAR',
+				'varchar ∪ time': 'VCHAR',
+				'varbin ∪ bigintstr': '1010110101001101',
+				'varbin ∪ char': '1010110101001101',
+				'varbin ∪ decimal': '1010110101001101',
+				'varbin ∪ text': '1010110101001101',
+				'varbin ∪ tinytext': '1010110101001101',
+				'varbin ∪ mediumtext': '1010110101001101',
+				'varbin ∪ longtext': '1010110101001101',
+				'varbin ∪ varchar': '1010110101001101',
+				'varbin ∪ varbin': '1010110101001101',
+				'varbin ∪ stringblob': '1010110101001101',
+				'varbin ∪ stringtinyblob': '1010110101001101',
+				'varbin ∪ stringmediumblob': '1010110101001101',
+				'varbin ∪ stringlongblob': '1010110101001101',
+				'varbin ∪ datestr': '1010110101001101',
+				'varbin ∪ datetimestr': '1010110101001101',
+				'varbin ∪ timestampstr': '1010110101001101',
+				'varbin ∪ time': '1010110101001101',
+				'stringblob ∪ bigintstr': 'string',
+				'stringblob ∪ char': 'string',
+				'stringblob ∪ decimal': 'string',
+				'stringblob ∪ text': 'string',
+				'stringblob ∪ tinytext': 'string',
+				'stringblob ∪ mediumtext': 'string',
+				'stringblob ∪ longtext': 'string',
+				'stringblob ∪ varchar': 'string',
+				'stringblob ∪ varbin': 'string',
+				'stringblob ∪ stringblob': 'string',
+				'stringblob ∪ stringtinyblob': 'string',
+				'stringblob ∪ stringmediumblob': 'string',
+				'stringblob ∪ stringlongblob': 'string',
+				'stringblob ∪ datestr': 'string',
+				'stringblob ∪ datetimestr': 'string',
+				'stringblob ∪ timestampstr': 'string',
+				'stringblob ∪ time': 'string',
+				'stringtinyblob ∪ bigintstr': 'string',
+				'stringtinyblob ∪ char': 'string',
+				'stringtinyblob ∪ decimal': 'string',
+				'stringtinyblob ∪ text': 'string',
+				'stringtinyblob ∪ tinytext': 'string',
+				'stringtinyblob ∪ mediumtext': 'string',
+				'stringtinyblob ∪ longtext': 'string',
+				'stringtinyblob ∪ varchar': 'string',
+				'stringtinyblob ∪ varbin': 'string',
+				'stringtinyblob ∪ stringblob': 'string',
+				'stringtinyblob ∪ stringtinyblob': 'string',
+				'stringtinyblob ∪ stringmediumblob': 'string',
+				'stringtinyblob ∪ stringlongblob': 'string',
+				'stringtinyblob ∪ datestr': 'string',
+				'stringtinyblob ∪ datetimestr': 'string',
+				'stringtinyblob ∪ timestampstr': 'string',
+				'stringtinyblob ∪ time': 'string',
+				'stringmediumblob ∪ bigintstr': 'string',
+				'stringmediumblob ∪ char': 'string',
+				'stringmediumblob ∪ decimal': 'string',
+				'stringmediumblob ∪ text': 'string',
+				'stringmediumblob ∪ tinytext': 'string',
+				'stringmediumblob ∪ mediumtext': 'string',
+				'stringmediumblob ∪ longtext': 'string',
+				'stringmediumblob ∪ varchar': 'string',
+				'stringmediumblob ∪ varbin': 'string',
+				'stringmediumblob ∪ stringblob': 'string',
+				'stringmediumblob ∪ stringtinyblob': 'string',
+				'stringmediumblob ∪ stringmediumblob': 'string',
+				'stringmediumblob ∪ stringlongblob': 'string',
+				'stringmediumblob ∪ datestr': 'string',
+				'stringmediumblob ∪ datetimestr': 'string',
+				'stringmediumblob ∪ timestampstr': 'string',
+				'stringmediumblob ∪ time': 'string',
+				'stringlongblob ∪ bigintstr': 'string',
+				'stringlongblob ∪ char': 'string',
+				'stringlongblob ∪ decimal': 'string',
+				'stringlongblob ∪ text': 'string',
+				'stringlongblob ∪ tinytext': 'string',
+				'stringlongblob ∪ mediumtext': 'string',
+				'stringlongblob ∪ longtext': 'string',
+				'stringlongblob ∪ varchar': 'string',
+				'stringlongblob ∪ varbin': 'string',
+				'stringlongblob ∪ stringblob': 'string',
+				'stringlongblob ∪ stringtinyblob': 'string',
+				'stringlongblob ∪ stringmediumblob': 'string',
+				'stringlongblob ∪ stringlongblob': 'string',
+				'stringlongblob ∪ datestr': 'string',
+				'stringlongblob ∪ datetimestr': 'string',
+				'stringlongblob ∪ timestampstr': 'string',
+				'stringlongblob ∪ time': 'string',
+				'datestr ∪ bigintstr': '2025-03-12',
+				'datestr ∪ char': '2025-03-12',
+				'datestr ∪ decimal': '2025-03-12',
+				'datestr ∪ text': '2025-03-12',
+				'datestr ∪ tinytext': '2025-03-12',
+				'datestr ∪ mediumtext': '2025-03-12',
+				'datestr ∪ longtext': '2025-03-12',
+				'datestr ∪ varchar': '2025-03-12',
+				'datestr ∪ varbin': binWidens ? '0000000010' : '2025-03-12',
+				'datestr ∪ stringblob': '2025-03-12',
+				'datestr ∪ stringtinyblob': '2025-03-12',
+				'datestr ∪ stringmediumblob': '2025-03-12',
+				'datestr ∪ stringlongblob': '2025-03-12',
+				'datestr ∪ datestr': '2025-03-12',
+				'datestr ∪ datetimestr': '2025-03-12 00:00:00.000',
+				'datestr ∪ timestampstr': '2025-03-12 00:00:00.000',
+				'datetimestr ∪ bigintstr': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ char': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ decimal': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ text': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ tinytext': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ mediumtext': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ longtext': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ varchar': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ varbin': binWidens ? '00000000100010000010000' : '2025-03-12 01:32:41.623',
+				'datetimestr ∪ stringblob': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ datestr': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ bigintstr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ char': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ decimal': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ text': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ tinytext': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ mediumtext': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ longtext': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ varchar': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ varbin': binWidens ? '00000000100010000010000' : '2025-03-12 01:32:41.623',
+				'timestampstr ∪ stringblob': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ stringtinyblob': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ stringmediumblob': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ stringlongblob': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ datestr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'time ∪ bigintstr': '04:13:22',
+				'time ∪ char': '04:13:22',
+				'time ∪ decimal': '04:13:22',
+				'time ∪ text': '04:13:22',
+				'time ∪ tinytext': '04:13:22',
+				'time ∪ mediumtext': '04:13:22',
+				'time ∪ longtext': '04:13:22',
+				'time ∪ varchar': '04:13:22',
+				'time ∪ varbin': binWidens ? '00010000' : '04:13:22',
+				'time ∪ stringblob': '04:13:22',
+				'time ∪ stringtinyblob': '04:13:22',
+				'time ∪ stringmediumblob': '04:13:22',
+				'time ∪ stringlongblob': '04:13:22',
+				'time ∪ time': '04:13:22',
+				'binary ∪ binary': '1',
+			},
+			{
+				'bigintstr ∪ bigintstr': '5044565289845416380',
+				'bigintstr ∪ char': 'c',
+				'bigintstr ∪ decimal': '47521',
+				'bigintstr ∪ text': 'C4-',
+				'bigintstr ∪ tinytext': 'tiny text',
+				'bigintstr ∪ mediumtext': 'medium text',
+				'bigintstr ∪ longtext': 'long text',
+				'bigintstr ∪ varchar': 'VCHAR',
+				'bigintstr ∪ varbin': '1010110101001101',
+				'bigintstr ∪ stringblob': 'string',
+				'bigintstr ∪ stringtinyblob': 'string',
+				'bigintstr ∪ stringmediumblob': 'string',
+				'bigintstr ∪ stringlongblob': 'string',
+				'bigintstr ∪ datestr': '2025-03-12',
+				'bigintstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'bigintstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'bigintstr ∪ time': '04:13:22',
+				'char ∪ bigintstr': '5044565289845416380',
+				'char ∪ char': 'c',
+				'char ∪ decimal': '47521',
+				'char ∪ text': 'C4-',
+				'char ∪ tinytext': 'tiny text',
+				'char ∪ mediumtext': 'medium text',
+				'char ∪ longtext': 'long text',
+				'char ∪ varchar': 'VCHAR',
+				'char ∪ varbin': '1010110101001101',
+				'char ∪ stringblob': 'string',
+				'char ∪ stringtinyblob': 'string',
+				'char ∪ stringmediumblob': 'string',
+				'char ∪ stringlongblob': 'string',
+				'char ∪ datestr': '2025-03-12',
+				'char ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'char ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'char ∪ time': '04:13:22',
+				'decimal ∪ bigintstr': '5044565289845416380',
+				'decimal ∪ char': 'c',
+				'decimal ∪ decimal': '47521',
+				'decimal ∪ text': 'C4-',
+				'decimal ∪ tinytext': 'tiny text',
+				'decimal ∪ mediumtext': 'medium text',
+				'decimal ∪ longtext': 'long text',
+				'decimal ∪ varchar': 'VCHAR',
+				'decimal ∪ varbin': '1010110101001101',
+				'decimal ∪ stringblob': 'string',
+				'decimal ∪ stringtinyblob': 'string',
+				'decimal ∪ stringmediumblob': 'string',
+				'decimal ∪ stringlongblob': 'string',
+				'decimal ∪ datestr': '2025-03-12',
+				'decimal ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'decimal ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'decimal ∪ time': '04:13:22',
+				'text ∪ bigintstr': '5044565289845416380',
+				'text ∪ char': 'c',
+				'text ∪ decimal': '47521',
+				'text ∪ text': 'C4-',
+				'text ∪ tinytext': 'tiny text',
+				'text ∪ mediumtext': 'medium text',
+				'text ∪ longtext': 'long text',
+				'text ∪ varchar': 'VCHAR',
+				'text ∪ varbin': '1010110101001101',
+				'text ∪ stringblob': 'string',
+				'text ∪ stringtinyblob': 'string',
+				'text ∪ stringmediumblob': 'string',
+				'text ∪ stringlongblob': 'string',
+				'text ∪ datestr': '2025-03-12',
+				'text ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'text ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'text ∪ time': '04:13:22',
+				'tinytext ∪ bigintstr': '5044565289845416380',
+				'tinytext ∪ char': 'c',
+				'tinytext ∪ decimal': '47521',
+				'tinytext ∪ text': 'C4-',
+				'tinytext ∪ tinytext': 'tiny text',
+				'tinytext ∪ mediumtext': 'medium text',
+				'tinytext ∪ longtext': 'long text',
+				'tinytext ∪ varchar': 'VCHAR',
+				'tinytext ∪ varbin': '1010110101001101',
+				'tinytext ∪ stringblob': 'string',
+				'tinytext ∪ stringtinyblob': 'string',
+				'tinytext ∪ stringmediumblob': 'string',
+				'tinytext ∪ stringlongblob': 'string',
+				'tinytext ∪ datestr': '2025-03-12',
+				'tinytext ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'tinytext ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'tinytext ∪ time': '04:13:22',
+				'mediumtext ∪ bigintstr': '5044565289845416380',
+				'mediumtext ∪ char': 'c',
+				'mediumtext ∪ decimal': '47521',
+				'mediumtext ∪ text': 'C4-',
+				'mediumtext ∪ tinytext': 'tiny text',
+				'mediumtext ∪ mediumtext': 'medium text',
+				'mediumtext ∪ longtext': 'long text',
+				'mediumtext ∪ varchar': 'VCHAR',
+				'mediumtext ∪ varbin': '1010110101001101',
+				'mediumtext ∪ stringblob': 'string',
+				'mediumtext ∪ stringtinyblob': 'string',
+				'mediumtext ∪ stringmediumblob': 'string',
+				'mediumtext ∪ stringlongblob': 'string',
+				'mediumtext ∪ datestr': '2025-03-12',
+				'mediumtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'mediumtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'mediumtext ∪ time': '04:13:22',
+				'longtext ∪ bigintstr': '5044565289845416380',
+				'longtext ∪ char': 'c',
+				'longtext ∪ decimal': '47521',
+				'longtext ∪ text': 'C4-',
+				'longtext ∪ tinytext': 'tiny text',
+				'longtext ∪ mediumtext': 'medium text',
+				'longtext ∪ longtext': 'long text',
+				'longtext ∪ varchar': 'VCHAR',
+				'longtext ∪ varbin': '1010110101001101',
+				'longtext ∪ stringblob': 'string',
+				'longtext ∪ stringtinyblob': 'string',
+				'longtext ∪ stringmediumblob': 'string',
+				'longtext ∪ stringlongblob': 'string',
+				'longtext ∪ datestr': '2025-03-12',
+				'longtext ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'longtext ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'longtext ∪ time': '04:13:22',
+				'varchar ∪ bigintstr': '5044565289845416380',
+				'varchar ∪ char': 'c',
+				'varchar ∪ decimal': '47521',
+				'varchar ∪ text': 'C4-',
+				'varchar ∪ tinytext': 'tiny text',
+				'varchar ∪ mediumtext': 'medium text',
+				'varchar ∪ longtext': 'long text',
+				'varchar ∪ varchar': 'VCHAR',
+				'varchar ∪ varbin': '1010110101001101',
+				'varchar ∪ stringblob': 'string',
+				'varchar ∪ stringtinyblob': 'string',
+				'varchar ∪ stringmediumblob': 'string',
+				'varchar ∪ stringlongblob': 'string',
+				'varchar ∪ datestr': '2025-03-12',
+				'varchar ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'varchar ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'varchar ∪ time': '04:13:22',
+				'varbin ∪ bigintstr': binWidens ? '0000000000000010000' : '5044565289845416380',
+				'varbin ∪ char': binWidens ? '0' : 'c',
+				'varbin ∪ decimal': binWidens ? '00001' : '47521',
+				'varbin ∪ text': 'C4-',
+				'varbin ∪ tinytext': 'tiny text',
+				'varbin ∪ mediumtext': 'medium text',
+				'varbin ∪ longtext': 'long text',
+				'varbin ∪ varchar': binWidens ? '00000' : 'VCHAR',
+				'varbin ∪ varbin': '1010110101001101',
+				'varbin ∪ stringblob': 'string',
+				'varbin ∪ stringtinyblob': 'string',
+				'varbin ∪ stringmediumblob': 'string',
+				'varbin ∪ stringlongblob': 'string',
+				'varbin ∪ datestr': binWidens ? '0000000010' : '2025-03-12',
+				'varbin ∪ datetimestr': binWidens ? '00000000100010000010000' : '2025-03-12 01:32:41.623',
+				'varbin ∪ timestampstr': binWidens ? '00000000100010000010000' : '2025-03-12 01:32:41.623',
+				'varbin ∪ time': binWidens ? '00010000' : '04:13:22',
+				'stringblob ∪ bigintstr': '5044565289845416380',
+				'stringblob ∪ char': 'c',
+				'stringblob ∪ decimal': '47521',
+				'stringblob ∪ text': 'C4-',
+				'stringblob ∪ tinytext': 'tiny text',
+				'stringblob ∪ mediumtext': 'medium text',
+				'stringblob ∪ longtext': 'long text',
+				'stringblob ∪ varchar': 'VCHAR',
+				'stringblob ∪ varbin': '1010110101001101',
+				'stringblob ∪ stringblob': 'string',
+				'stringblob ∪ stringtinyblob': 'string',
+				'stringblob ∪ stringmediumblob': 'string',
+				'stringblob ∪ stringlongblob': 'string',
+				'stringblob ∪ datestr': '2025-03-12',
+				'stringblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'stringblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'stringblob ∪ time': '04:13:22',
+				'stringtinyblob ∪ bigintstr': '5044565289845416380',
+				'stringtinyblob ∪ char': 'c',
+				'stringtinyblob ∪ decimal': '47521',
+				'stringtinyblob ∪ text': 'C4-',
+				'stringtinyblob ∪ tinytext': 'tiny text',
+				'stringtinyblob ∪ mediumtext': 'medium text',
+				'stringtinyblob ∪ longtext': 'long text',
+				'stringtinyblob ∪ varchar': 'VCHAR',
+				'stringtinyblob ∪ varbin': '1010110101001101',
+				'stringtinyblob ∪ stringblob': 'string',
+				'stringtinyblob ∪ stringtinyblob': 'string',
+				'stringtinyblob ∪ stringmediumblob': 'string',
+				'stringtinyblob ∪ stringlongblob': 'string',
+				'stringtinyblob ∪ datestr': '2025-03-12',
+				'stringtinyblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'stringtinyblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'stringtinyblob ∪ time': '04:13:22',
+				'stringmediumblob ∪ bigintstr': '5044565289845416380',
+				'stringmediumblob ∪ char': 'c',
+				'stringmediumblob ∪ decimal': '47521',
+				'stringmediumblob ∪ text': 'C4-',
+				'stringmediumblob ∪ tinytext': 'tiny text',
+				'stringmediumblob ∪ mediumtext': 'medium text',
+				'stringmediumblob ∪ longtext': 'long text',
+				'stringmediumblob ∪ varchar': 'VCHAR',
+				'stringmediumblob ∪ varbin': '1010110101001101',
+				'stringmediumblob ∪ stringblob': 'string',
+				'stringmediumblob ∪ stringtinyblob': 'string',
+				'stringmediumblob ∪ stringmediumblob': 'string',
+				'stringmediumblob ∪ stringlongblob': 'string',
+				'stringmediumblob ∪ datestr': '2025-03-12',
+				'stringmediumblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'stringmediumblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'stringmediumblob ∪ time': '04:13:22',
+				'stringlongblob ∪ bigintstr': '5044565289845416380',
+				'stringlongblob ∪ char': 'c',
+				'stringlongblob ∪ decimal': '47521',
+				'stringlongblob ∪ text': 'C4-',
+				'stringlongblob ∪ tinytext': 'tiny text',
+				'stringlongblob ∪ mediumtext': 'medium text',
+				'stringlongblob ∪ longtext': 'long text',
+				'stringlongblob ∪ varchar': 'VCHAR',
+				'stringlongblob ∪ varbin': '1010110101001101',
+				'stringlongblob ∪ stringblob': 'string',
+				'stringlongblob ∪ stringtinyblob': 'string',
+				'stringlongblob ∪ stringmediumblob': 'string',
+				'stringlongblob ∪ stringlongblob': 'string',
+				'stringlongblob ∪ datestr': '2025-03-12',
+				'stringlongblob ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'stringlongblob ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'stringlongblob ∪ time': '04:13:22',
+				'datestr ∪ bigintstr': '5044565289845416380',
+				'datestr ∪ char': 'c',
+				'datestr ∪ decimal': '47521',
+				'datestr ∪ text': 'C4-',
+				'datestr ∪ tinytext': 'tiny text',
+				'datestr ∪ mediumtext': 'medium text',
+				'datestr ∪ longtext': 'long text',
+				'datestr ∪ varchar': 'VCHAR',
+				'datestr ∪ varbin': '1010110101001101',
+				'datestr ∪ stringblob': 'string',
+				'datestr ∪ stringtinyblob': 'string',
+				'datestr ∪ stringmediumblob': 'string',
+				'datestr ∪ stringlongblob': 'string',
+				'datestr ∪ datestr': '2025-03-12',
+				'datestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'datestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ bigintstr': '5044565289845416380',
+				'datetimestr ∪ char': 'c',
+				'datetimestr ∪ decimal': '47521',
+				'datetimestr ∪ text': 'C4-',
+				'datetimestr ∪ tinytext': 'tiny text',
+				'datetimestr ∪ mediumtext': 'medium text',
+				'datetimestr ∪ longtext': 'long text',
+				'datetimestr ∪ varchar': 'VCHAR',
+				'datetimestr ∪ varbin': '1010110101001101',
+				'datetimestr ∪ stringblob': 'string',
+				'datetimestr ∪ stringtinyblob': 'string',
+				'datetimestr ∪ stringmediumblob': 'string',
+				'datetimestr ∪ stringlongblob': 'string',
+				'datetimestr ∪ datestr': '2025-03-12 00:00:00.000',
+				'datetimestr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'datetimestr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ bigintstr': '5044565289845416380',
+				'timestampstr ∪ char': 'c',
+				'timestampstr ∪ decimal': '47521',
+				'timestampstr ∪ text': 'C4-',
+				'timestampstr ∪ tinytext': 'tiny text',
+				'timestampstr ∪ mediumtext': 'medium text',
+				'timestampstr ∪ longtext': 'long text',
+				'timestampstr ∪ varchar': 'VCHAR',
+				'timestampstr ∪ varbin': '1010110101001101',
+				'timestampstr ∪ stringblob': 'string',
+				'timestampstr ∪ stringtinyblob': 'string',
+				'timestampstr ∪ stringmediumblob': 'string',
+				'timestampstr ∪ stringlongblob': 'string',
+				'timestampstr ∪ datestr': '2025-03-12 00:00:00.000',
+				'timestampstr ∪ datetimestr': '2025-03-12 01:32:41.623',
+				'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+				'time ∪ bigintstr': '5044565289845416380',
+				'time ∪ char': 'c',
+				'time ∪ decimal': '47521',
+				'time ∪ text': 'C4-',
+				'time ∪ tinytext': 'tiny text',
+				'time ∪ mediumtext': 'medium text',
+				'time ∪ longtext': 'long text',
+				'time ∪ varchar': 'VCHAR',
+				'time ∪ varbin': '1010110101001101',
+				'time ∪ stringblob': 'string',
+				'time ∪ stringtinyblob': 'string',
+				'time ∪ stringmediumblob': 'string',
+				'time ∪ stringlongblob': 'string',
+				'time ∪ time': '04:13:22',
+				'binary ∪ binary': '1',
+			},
+		]));
+
+		// ---- bigint ----
+		expect(
+			await unionAll(
+				db.select({
+					'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+					'bigint64 ∪ decimalbig': allTypesCodecsTable.bigint64.as('bigint64 ∪ decimalbig'),
+					'decimalbig ∪ bigint64': allTypesCodecsTable.decimalbig.as('decimalbig ∪ bigint64'),
+					'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'bigint64 ∪ bigint64': allTypesCodecsTable.bigint64.as('bigint64 ∪ bigint64'),
+					'bigint64 ∪ decimalbig': allTypesCodecsTable.decimalbig.as('bigint64 ∪ decimalbig'),
+					'decimalbig ∪ bigint64': allTypesCodecsTable.bigint64.as('decimalbig ∪ bigint64'),
+					'decimalbig ∪ decimalbig': allTypesCodecsTable.decimalbig.as('decimalbig ∪ decimalbig'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'bigint64 ∪ bigint64': 5044565289845416380n,
+				'bigint64 ∪ decimalbig': 5044565289845416380n,
+				'decimalbig ∪ bigint64': 5044565289845416380n,
+				'decimalbig ∪ decimalbig': 5044565289845416380n,
+			},
+			{
+				'bigint64 ∪ bigint64': 5044565289845416380n,
+				'bigint64 ∪ decimalbig': 5044565289845416380n,
+				'decimalbig ∪ bigint64': 5044565289845416380n,
+				'decimalbig ∪ decimalbig': 5044565289845416380n,
+			},
+		]));
+
+		// ---- boolean ----
+		expect(
+			await unionAll(
+				db.select({
+					'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'boolean ∪ boolean': allTypesCodecsTable.boolean.as('boolean ∪ boolean'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'boolean ∪ boolean': true,
+			},
+			{
+				'boolean ∪ boolean': true,
+			},
+		]));
+
+		// ---- date ----
+		expect(
+			await unionAll(
+				db.select({
+					'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+					'date ∪ datetime': allTypesCodecsTable.date.as('date ∪ datetime'),
+					'date ∪ timestamp': allTypesCodecsTable.date.as('date ∪ timestamp'),
+					'datetime ∪ date': allTypesCodecsTable.datetime.as('datetime ∪ date'),
+					'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+					'datetime ∪ timestamp': allTypesCodecsTable.datetime.as('datetime ∪ timestamp'),
+					'timestamp ∪ date': allTypesCodecsTable.timestamp.as('timestamp ∪ date'),
+					'timestamp ∪ datetime': allTypesCodecsTable.timestamp.as('timestamp ∪ datetime'),
+					'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'date ∪ date': allTypesCodecsTable.date.as('date ∪ date'),
+					'date ∪ datetime': allTypesCodecsTable.datetime.as('date ∪ datetime'),
+					'date ∪ timestamp': allTypesCodecsTable.timestamp.as('date ∪ timestamp'),
+					'datetime ∪ date': allTypesCodecsTable.date.as('datetime ∪ date'),
+					'datetime ∪ datetime': allTypesCodecsTable.datetime.as('datetime ∪ datetime'),
+					'datetime ∪ timestamp': allTypesCodecsTable.timestamp.as('datetime ∪ timestamp'),
+					'timestamp ∪ date': allTypesCodecsTable.date.as('timestamp ∪ date'),
+					'timestamp ∪ datetime': allTypesCodecsTable.datetime.as('timestamp ∪ datetime'),
+					'timestamp ∪ timestamp': allTypesCodecsTable.timestamp.as('timestamp ∪ timestamp'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'date ∪ date': new Date('2025-03-12'),
+				'date ∪ datetime': new Date('2025-03-12'),
+				'date ∪ timestamp': new Date('2025-03-12'),
+				'datetime ∪ date': new Date(1741743161623),
+				'datetime ∪ datetime': new Date(1741743161623),
+				'datetime ∪ timestamp': new Date(1741743161623),
+				'timestamp ∪ date': new Date(1741743161623),
+				'timestamp ∪ datetime': new Date(1741743161623),
+				'timestamp ∪ timestamp': new Date(1741743161623),
+			},
+			{
+				'date ∪ date': new Date('2025-03-12'),
+				'date ∪ datetime': new Date(1741743161623),
+				'date ∪ timestamp': new Date(1741743161623),
+				'datetime ∪ date': new Date('2025-03-12'),
+				'datetime ∪ datetime': new Date(1741743161623),
+				'datetime ∪ timestamp': new Date(1741743161623),
+				'timestamp ∪ date': new Date('2025-03-12'),
+				'timestamp ∪ datetime': new Date(1741743161623),
+				'timestamp ∪ timestamp': new Date(1741743161623),
+			},
+		]));
+
+		// ---- buffer ----
+		expect(
+			await unionAll(
+				db.select({
+					'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+					'blob ∪ tinyblob': allTypesCodecsTable.blob.as('blob ∪ tinyblob'),
+					'blob ∪ mediumblob': allTypesCodecsTable.blob.as('blob ∪ mediumblob'),
+					'blob ∪ longblob': allTypesCodecsTable.blob.as('blob ∪ longblob'),
+					'tinyblob ∪ blob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ blob'),
+					'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+					'tinyblob ∪ mediumblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ mediumblob'),
+					'tinyblob ∪ longblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ longblob'),
+					'mediumblob ∪ blob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ blob'),
+					'mediumblob ∪ tinyblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ tinyblob'),
+					'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+					'mediumblob ∪ longblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ longblob'),
+					'longblob ∪ blob': allTypesCodecsTable.longblob.as('longblob ∪ blob'),
+					'longblob ∪ tinyblob': allTypesCodecsTable.longblob.as('longblob ∪ tinyblob'),
+					'longblob ∪ mediumblob': allTypesCodecsTable.longblob.as('longblob ∪ mediumblob'),
+					'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'blob ∪ blob': allTypesCodecsTable.blob.as('blob ∪ blob'),
+					'blob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('blob ∪ tinyblob'),
+					'blob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('blob ∪ mediumblob'),
+					'blob ∪ longblob': allTypesCodecsTable.longblob.as('blob ∪ longblob'),
+					'tinyblob ∪ blob': allTypesCodecsTable.blob.as('tinyblob ∪ blob'),
+					'tinyblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('tinyblob ∪ tinyblob'),
+					'tinyblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('tinyblob ∪ mediumblob'),
+					'tinyblob ∪ longblob': allTypesCodecsTable.longblob.as('tinyblob ∪ longblob'),
+					'mediumblob ∪ blob': allTypesCodecsTable.blob.as('mediumblob ∪ blob'),
+					'mediumblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('mediumblob ∪ tinyblob'),
+					'mediumblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('mediumblob ∪ mediumblob'),
+					'mediumblob ∪ longblob': allTypesCodecsTable.longblob.as('mediumblob ∪ longblob'),
+					'longblob ∪ blob': allTypesCodecsTable.blob.as('longblob ∪ blob'),
+					'longblob ∪ tinyblob': allTypesCodecsTable.tinyblob.as('longblob ∪ tinyblob'),
+					'longblob ∪ mediumblob': allTypesCodecsTable.mediumblob.as('longblob ∪ mediumblob'),
+					'longblob ∪ longblob': allTypesCodecsTable.longblob.as('longblob ∪ longblob'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'blob ∪ blob': Buffer.from('string'),
+				'blob ∪ tinyblob': Buffer.from('string'),
+				'blob ∪ mediumblob': Buffer.from('string'),
+				'blob ∪ longblob': Buffer.from('string'),
+				'tinyblob ∪ blob': Buffer.from('string'),
+				'tinyblob ∪ tinyblob': Buffer.from('string'),
+				'tinyblob ∪ mediumblob': Buffer.from('string'),
+				'tinyblob ∪ longblob': Buffer.from('string'),
+				'mediumblob ∪ blob': Buffer.from('string'),
+				'mediumblob ∪ tinyblob': Buffer.from('string'),
+				'mediumblob ∪ mediumblob': Buffer.from('string'),
+				'mediumblob ∪ longblob': Buffer.from('string'),
+				'longblob ∪ blob': Buffer.from('string'),
+				'longblob ∪ tinyblob': Buffer.from('string'),
+				'longblob ∪ mediumblob': Buffer.from('string'),
+				'longblob ∪ longblob': Buffer.from('string'),
+			},
+			{
+				'blob ∪ blob': Buffer.from('string'),
+				'blob ∪ tinyblob': Buffer.from('string'),
+				'blob ∪ mediumblob': Buffer.from('string'),
+				'blob ∪ longblob': Buffer.from('string'),
+				'tinyblob ∪ blob': Buffer.from('string'),
+				'tinyblob ∪ tinyblob': Buffer.from('string'),
+				'tinyblob ∪ mediumblob': Buffer.from('string'),
+				'tinyblob ∪ longblob': Buffer.from('string'),
+				'mediumblob ∪ blob': Buffer.from('string'),
+				'mediumblob ∪ tinyblob': Buffer.from('string'),
+				'mediumblob ∪ mediumblob': Buffer.from('string'),
+				'mediumblob ∪ longblob': Buffer.from('string'),
+				'longblob ∪ blob': Buffer.from('string'),
+				'longblob ∪ tinyblob': Buffer.from('string'),
+				'longblob ∪ mediumblob': Buffer.from('string'),
+				'longblob ∪ longblob': Buffer.from('string'),
+			},
+		]));
+
+		// ---- enum ----
+		expect(
+			await unionAll(
+				db.select({
+					'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'enum ∪ enum': allTypesCodecsTable.enum.as('enum ∪ enum'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'enum ∪ enum': 'enV1',
+			},
+			{
+				'enum ∪ enum': 'enV1',
+			},
+		]));
+
+		// ---- json ----
+		expect(
+			await unionAll(
+				db.select({
+					'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+					'json1 ∪ json2': allTypesCodecsTable.json1.as('json1 ∪ json2'),
+					'json1 ∪ json3': allTypesCodecsTable.json1.as('json1 ∪ json3'),
+					'json1 ∪ json4': allTypesCodecsTable.json1.as('json1 ∪ json4'),
+					'json2 ∪ json1': allTypesCodecsTable.json2.as('json2 ∪ json1'),
+					'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+					'json2 ∪ json3': allTypesCodecsTable.json2.as('json2 ∪ json3'),
+					'json2 ∪ json4': allTypesCodecsTable.json2.as('json2 ∪ json4'),
+					'json3 ∪ json1': allTypesCodecsTable.json3.as('json3 ∪ json1'),
+					'json3 ∪ json2': allTypesCodecsTable.json3.as('json3 ∪ json2'),
+					'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+					'json3 ∪ json4': allTypesCodecsTable.json3.as('json3 ∪ json4'),
+					'json4 ∪ json1': allTypesCodecsTable.json4.as('json4 ∪ json1'),
+					'json4 ∪ json2': allTypesCodecsTable.json4.as('json4 ∪ json2'),
+					'json4 ∪ json3': allTypesCodecsTable.json4.as('json4 ∪ json3'),
+					'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+				}).from(allTypesCodecsTable),
+				db.select({
+					'json1 ∪ json1': allTypesCodecsTable.json1.as('json1 ∪ json1'),
+					'json1 ∪ json2': allTypesCodecsTable.json2.as('json1 ∪ json2'),
+					'json1 ∪ json3': allTypesCodecsTable.json3.as('json1 ∪ json3'),
+					'json1 ∪ json4': allTypesCodecsTable.json4.as('json1 ∪ json4'),
+					'json2 ∪ json1': allTypesCodecsTable.json1.as('json2 ∪ json1'),
+					'json2 ∪ json2': allTypesCodecsTable.json2.as('json2 ∪ json2'),
+					'json2 ∪ json3': allTypesCodecsTable.json3.as('json2 ∪ json3'),
+					'json2 ∪ json4': allTypesCodecsTable.json4.as('json2 ∪ json4'),
+					'json3 ∪ json1': allTypesCodecsTable.json1.as('json3 ∪ json1'),
+					'json3 ∪ json2': allTypesCodecsTable.json2.as('json3 ∪ json2'),
+					'json3 ∪ json3': allTypesCodecsTable.json3.as('json3 ∪ json3'),
+					'json3 ∪ json4': allTypesCodecsTable.json4.as('json3 ∪ json4'),
+					'json4 ∪ json1': allTypesCodecsTable.json1.as('json4 ∪ json1'),
+					'json4 ∪ json2': allTypesCodecsTable.json2.as('json4 ∪ json2'),
+					'json4 ∪ json3': allTypesCodecsTable.json3.as('json4 ∪ json3'),
+					'json4 ∪ json4': allTypesCodecsTable.json4.as('json4 ∪ json4'),
+				}).from(allTypesCodecsTable),
+			),
+		).toEqual(expect.arrayContaining([
+			{
+				'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+				'json1 ∪ json2': { str: 'strval', arr: ['str', 10] },
+				'json1 ∪ json3': { str: 'strval', arr: ['str', 10] },
+				'json1 ∪ json4': { str: 'strval', arr: ['str', 10] },
+				'json2 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json2 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json2 ∪ json4': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json3 ∪ json1': 5,
+				'json3 ∪ json2': 5,
+				'json3 ∪ json3': 5,
+				'json3 ∪ json4': 5,
+				'json4 ∪ json1': '5',
+				'json4 ∪ json2': '5',
+				'json4 ∪ json3': '5',
+				'json4 ∪ json4': '5',
+			},
+			{
+				'json1 ∪ json1': { str: 'strval', arr: ['str', 10] },
+				'json1 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json1 ∪ json3': 5,
+				'json1 ∪ json4': '5',
+				'json2 ∪ json1': { str: 'strval', arr: ['str', 10] },
+				'json2 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json2 ∪ json3': 5,
+				'json2 ∪ json4': '5',
+				'json3 ∪ json1': { str: 'strval', arr: ['str', 10] },
+				'json3 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json3 ∪ json3': 5,
+				'json3 ∪ json4': '5',
+				'json4 ∪ json1': { str: 'strval', arr: ['str', 10] },
+				'json4 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+				'json4 ∪ json3': 5,
+				'json4 ∪ json4': '5',
+			},
+		]));
+
+		// TiDB's engine does not support `LATERAL` derived tables, which the RQB relation query
+		// (`with: { self }`) relies on — skip the relation-based assertions there.
+		const relationSQL = db.query.allTypesTable.findFirst({
+			with: {
+				self: true,
+			},
+		}).getSQL();
+		if (!is(db, TiDBServerlessDatabase)) {
+			const { relationRes, rootRes } = await session.objects(relationSQL).then((e) => {
+				const [{ self: relationRaw, ...rootRaw }] = e as [Record<string, any>];
+
+				return {
+					relationRes: normalizeDataWithDbCodecs({
+						db,
+						columns: getColumns(allTypesCodecsTable),
+						data: relationRaw,
+						mode: 'json',
+					})[0]!,
+					rootRes: normalizeDataWithDbCodecs({
+						db,
+						columns: getColumns(allTypesCodecsTable),
+						data: [rootRaw],
+						mode: 'query',
+					})[0]!,
+				};
+			});
+
+			expect(relationRes).toStrictEqual(testData);
+			expect(rootRes).toStrictEqual(testData);
+		}
+	});
+
+	test.concurrent('Column as decoder applies codecs', async ({ createDB, push }) => {
+		let customCast = false;
+		let customMap = false;
+
+		const codecBypass = customType<{
+			data: Date;
+			driverData: string;
+			jsonData: string;
+		}>({
+			codec: 'timestamp',
+			dataType: () => 'timestamp(3)',
+			forJsonSelect: (identifier, sql) => {
+				customCast = true;
+				return sql`cast(${identifier} as char)`;
+			},
+			fromJson: (v) => {
+				customMap = true;
+				return new Date(v + '+0000');
+			},
+			toDriver: (v) => v.toISOString().replace('T', ' ').replace('Z', ''),
+		});
+
+		const users = mysqlTable('users_823', (t) => ({
+			id: t.int().primaryKey(),
+			name: t.text().notNull(),
+			createdAt: t.timestamp('created_at', { fsp: 3 }).notNull(),
+			createdAtStr: t.timestamp('created_at_str', { fsp: 3, mode: 'string' }).notNull(),
+			cus: codecBypass('custom').notNull(),
+		}));
+
+		const usersView = mysqlView('users_823_v').as((qb) =>
+			qb.select({
+				...getColumns(users),
+				max: max(users.createdAt).as('max'),
+				maxStr: max(users.createdAtStr).as('max_str'),
+				sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+			}).from(users).groupBy(users.id)
+		);
+
+		await push({ users, usersView });
+
+		const db = createDB({
+			schema: { users, usersView },
+			cb: (r) => ({
+				users: {
+					self: r.one.users({
+						from: r.users.id,
+						to: r.users.id,
+					}),
+				},
+				usersView: {
+					self: r.one.usersView({
+						from: r.usersView.id,
+						to: r.usersView.id,
+					}),
+				},
+			}),
+		});
+
+		const exDateStr = '1970-01-16 16:45:46.351';
+		const exDate = new Date(exDateStr);
+
+		await db.insert(users).values({
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			cus: exDate,
+		});
+
+		const res = await db.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id);
+
+		const viewRes = await db.select().from(usersView);
+
+		const nested = await db.query.users.findFirst({
+			with: {
+				self: {
+					extras: {
+						max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+						maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					},
+				},
+			},
+			extras: {
+				max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+				maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+			},
+		});
+
+		const viewNested = await db.query.usersView.findFirst({
+			columns: {
+				sq: false, // TODO: re-enable when supported in RQBv2
+			},
+			with: {
+				self: {
+					columns: {
+						sq: false, // TODO: re-enable when supported in RQBv2
+					},
+				},
+			},
+		});
+
+		expect(res).toStrictEqual([
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				sq: exDate,
+				cus: exDate,
+			},
+		]);
+		expect(viewRes).toStrictEqual([
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				sq: exDate,
+				cus: exDate,
+			},
+		]);
+
+		expect(customCast).toBeTruthy();
+		expect(customMap).toBeTruthy();
+
+		expect(nested).toStrictEqual(
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+				self: {
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					max: exDate,
+					maxStr: exDateStr,
+					cus: exDate,
+				},
+			},
+		);
+		expect(viewNested).toStrictEqual(
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+				self: {
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					max: exDate,
+					maxStr: exDateStr,
+					cus: exDate,
+				},
+			},
+		);
+	});
+
+	test.concurrent('Column as decoder applies codecs - Jit mappers', async ({ createDB, push }) => {
+		let customCast = false;
+		let customMap = false;
+
+		const codecBypass = customType<{
+			data: Date;
+			driverData: string;
+			jsonData: string;
+		}>({
+			codec: 'timestamp',
+			dataType: () => 'timestamp(3)',
+			forJsonSelect: (identifier, sql) => {
+				customCast = true;
+				return sql`cast(${identifier} as char)`;
+			},
+			fromJson: (v) => {
+				customMap = true;
+				return new Date(v + '+0000');
+			},
+			toDriver: (v) => v.toISOString().replace('T', ' ').replace('Z', ''),
+		});
+
+		const users = mysqlTable('users_823_jit', (t) => ({
+			id: t.int().primaryKey(),
+			name: t.text().notNull(),
+			createdAt: t.timestamp('created_at', { fsp: 3 }).notNull(),
+			createdAtStr: t.timestamp('created_at_str', { fsp: 3, mode: 'string' }).notNull(),
+			cus: codecBypass('custom').notNull(),
+		}));
+
+		const usersView = mysqlView('users_823_v_jit').as((qb) =>
+			qb.select({
+				...getColumns(users),
+				max: max(users.createdAt).as('max'),
+				maxStr: max(users.createdAtStr).as('max_str'),
+				sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+			}).from(users).groupBy(users.id)
+		);
+
+		await push({ users, usersView });
+
+		const db = createDB({
+			schema: { users, usersView },
+			cb: (r) => ({
+				users: {
+					self: r.one.users({
+						from: r.users.id,
+						to: r.users.id,
+					}),
+				},
+				usersView: {
+					self: r.one.usersView({
+						from: r.usersView.id,
+						to: r.usersView.id,
+					}),
+				},
+			}),
+		});
+
+		const exDateStr = '1970-01-16 16:45:46.351';
+		const exDate = new Date(exDateStr);
+
+		await db.insert(users).values({
+			id: 1,
+			name: 'First',
+			createdAt: exDate,
+			createdAtStr: exDateStr,
+			cus: exDate,
+		});
+
+		const res = await db.select({
+			...getColumns(users),
+			max: max(users.createdAt).as('max'),
+			maxStr: max(users.createdAtStr).as('max_str'),
+			sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+		}).from(users).groupBy(users.id);
+
+		const viewRes = await db.select().from(usersView);
+
+		const nested = await db.query.users.findFirst({
+			with: {
+				self: {
+					extras: {
+						max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+						maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					},
+				},
+			},
+			extras: {
+				max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+				maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+			},
+		});
+
+		const viewNested = await db.query.usersView.findFirst({
+			columns: {
+				sq: false, // TODO: re-enable when supported in RQBv2
+			},
+			with: {
+				self: {
+					columns: {
+						sq: false, // TODO: re-enable when supported in RQBv2
+					},
+				},
+			},
+		});
+
+		expect(res).toStrictEqual([
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				sq: exDate,
+				cus: exDate,
+			},
+		]);
+		expect(viewRes).toStrictEqual([
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				sq: exDate,
+				cus: exDate,
+			},
+		]);
+
+		expect(customCast).toBeTruthy();
+		expect(customMap).toBeTruthy();
+
+		expect(nested).toStrictEqual(
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+				self: {
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					max: exDate,
+					maxStr: exDateStr,
+					cus: exDate,
+				},
+			},
+		);
+		expect(viewNested).toStrictEqual(
+			{
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				max: exDate,
+				maxStr: exDateStr,
+				cus: exDate,
+				self: {
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					max: exDate,
+					maxStr: exDateStr,
+					cus: exDate,
+				},
+			},
+		);
+	});
+
+	test.concurrent('Mappers: correct mappers enabled', async ({ db, createDB }) => {
+		const jitDb = createDB({ jit: true });
+
+		const dialect: MySqlDialect = (<any> db).dialect;
+		const jitDialect: MySqlDialect = (<any> jitDb).dialect;
+
+		expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+		expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+		expect(dialect.mapperGenerators.$returning === make$ReturningResponseMapper).toStrictEqual(true);
+		expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+		expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+		// TODO: replace after making jit version
+		expect(jitDialect.mapperGenerators.$returning === make$ReturningResponseMapper).toStrictEqual(true);
+	});
+
+	const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+	test.concurrent('Mappers: simple select - no rows', async ({ db, push }) => {
+		const users = mysqlTable('mappers_users_1', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		await push({ users });
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test.concurrent('Mappers: select - nothing to decode - text', async ({ db, push }) => {
+		const users = mysqlTable('mappers_users_2', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		const selected = await db.select({ name: users.name }).from(users);
+
+		expect(selected).toStrictEqual([{ name: 'First' }]);
+	});
+
+	test.concurrent('Mappers: select - nothing to decode - null', async ({ db, push }) => {
+		const users = mysqlTable('mappers_users_3', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+		expect(selected).toStrictEqual([{ isBanned: null }]);
+	});
+
+	test.concurrent('Mappers: insert $returningId + select', async ({ db, push }) => {
+		const users = mysqlTable('mappers_users_4', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+		const selected = await db.select().from(users);
+
+		await db.update(users).set({
+			isBanned: false,
+		}).where(eq(users.id, 2));
+
+		expect(selected).toStrictEqual([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+			isBanned: null,
+		}]);
+	});
+
+	test.concurrent('Mappers: select complex selections', async ({ db, push }) => {
+		const users = mysqlTable('mappers_users_5', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const posts = mysqlTable('mappers_posts_1', (t) => ({
+			id: t.int('id').primaryKey(),
+			authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		await push({ users, posts });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected3 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected4 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+
+		expect(selected1).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			},
+			post: null,
+		}, {
+			user: {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: null,
+		}]);
+		expect(selected2).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}]);
+		expect(selected3).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: true,
+				name: 'Second',
+				postId: null,
+				userId: 2,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'Third',
+				postId: null,
+				userId: 3,
+			},
+		]);
+		expect(selected4).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+		]);
+	});
+
+	test.concurrent('Mappers: relational', async ({ createDB, push }) => {
+		const users = mysqlTable('mappers_users_6', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const posts = mysqlTable('mappers_posts_2', (t) => ({
+			id: t.int('id').primaryKey(),
+			authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB({
+			schema: { users, posts },
+			cb: (r) => ({
+				users: {
+					post: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+					posts: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+				},
+				posts: {
+					author: r.one.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+					authors: r.many.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+				},
+			}),
+			jit: false,
+		});
+		await push({ users, posts });
+
+		const empty1 = await db.query.users.findFirst();
+		const empty2 = await db.query.users.findMany();
+
+		expect(empty1).toStrictEqual(undefined);
+		expect(empty2).toStrictEqual([]);
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const simple1 = await db.query.users.findFirst();
+		const simple2 = await db.query.users.findMany();
+
+		expect(simple1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+		);
+		expect(simple2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+			},
+		]);
+
+		const extra1 = await db.query.users.findFirst({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const extra2 = await db.query.users.findMany({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(extra1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(extra2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+
+		const nested1 = await db.query.users.findFirst({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const nested2 = await db.query.users.findMany({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(nested1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(nested2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+	});
+
+	test.concurrent('Jit mappers: simple select - no rows', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_1', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const db = createDB({ jit: true });
+		await push({ users });
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test.concurrent('Jit mappers: select - nothing to decode - text', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_2', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const db = createDB({ jit: true });
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		const selected = await db.select({ name: users.name }).from(users);
+
+		expect(selected).toStrictEqual([{ name: 'First' }]);
+	});
+
+	test.concurrent('Jit mappers: select - nothing to decode - null', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_3', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const db = createDB({ jit: true });
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+		expect(selected).toStrictEqual([{ isBanned: null }]);
+	});
+
+	test.concurrent('Jit mappers: insert $returningId + select', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_4', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).autoincrement().primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const db = createDB({ jit: true });
+		await push({ users });
+
+		const insertedIds = await db.insert(users).values([{
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+		const selected = await db.select().from(users);
+
+		await db.update(users).set({
+			isBanned: false,
+		}).where(eq(users.id, 2));
+
+		expect(selected).toStrictEqual([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+			isBanned: null,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+			isBanned: null,
+		}]);
+	});
+
+	test.concurrent('Jit mappers: select complex selections', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_5', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const posts = mysqlTable('jit_mappers_posts_1', (t) => ({
+			id: t.int('id').primaryKey(),
+			authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB({ jit: true });
+		await push({ users, posts });
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected3 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+		const selected4 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		);
+
+		expect(selected1).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			},
+			post: null,
+		}, {
+			user: {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: null,
+		}]);
+		expect(selected2).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}]);
+		expect(selected3).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: true,
+				name: 'Second',
+				postId: null,
+				userId: 2,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'Third',
+				postId: null,
+				userId: 3,
+			},
+		]);
+		expect(selected4).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+		]);
+	});
+
+	test.concurrent('Jit mappers: relational', async ({ createDB, push }) => {
+		const users = mysqlTable('jit_mappers_users_6', (t) => ({
+			id: t.bigint('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.timestamp('created_at', { mode: 'date' }).notNull(),
+			isBanned: t.boolean('is_banned'),
+		}));
+
+		const posts = mysqlTable('jit_mappers_posts_2', (t) => ({
+			id: t.int('id').primaryKey(),
+			authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB({
+			schema: { users, posts },
+			cb: (r) => ({
+				users: {
+					post: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+					posts: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+				},
+				posts: {
+					author: r.one.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+					authors: r.many.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+				},
+			}),
+			jit: true,
+		});
+		await push({ users, posts });
+
+		const empty1 = await db.query.users.findFirst();
+		const empty2 = await db.query.users.findMany();
+
+		expect(empty1).toStrictEqual(undefined);
+		expect(empty2).toStrictEqual([]);
+
+		const insertedIds = await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).$returningId();
+
+		expect(insertedIds).toStrictEqual([]);
+
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const simple1 = await db.query.users.findFirst();
+		const simple2 = await db.query.users.findMany();
+
+		expect(simple1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+		);
+		expect(simple2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+			},
+		]);
+
+		const extra1 = await db.query.users.findFirst({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const extra2 = await db.query.users.findMany({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(extra1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(extra2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+
+		const nested1 = await db.query.users.findFirst({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const nested2 = await db.query.users.findMany({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(nested1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(nested2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+	});
+}
diff --git a/integration-tests/tests/mysql/mysql-common-cache.ts b/integration-tests/tests/mysql/mysql-common-cache.ts
index 9a7a2f1d7c..333244aa2f 100644
--- a/integration-tests/tests/mysql/mysql-common-cache.ts
+++ b/integration-tests/tests/mysql/mysql-common-cache.ts
@@ -1,90 +1,9 @@
-import { eq, getTableName, is, sql, Table } from 'drizzle-orm';
-import type { MutationOption } from 'drizzle-orm/cache/core';
-import { Cache } from 'drizzle-orm/cache/core';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import type { MySqlDatabase } from 'drizzle-orm/mysql-core';
+import { eq, sql } from 'drizzle-orm';
 import { alias, boolean, int, json, mysqlTable, serial, text, timestamp } from 'drizzle-orm/mysql-core';
-import Keyv from 'keyv';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestGlobalCache extends Cache {
-	private globalTtl: number = 1000;
-	private usedTablesPerKey: Record<string, string[]> = {};
-
-	constructor(private kv: Keyv = new Keyv()) {
-		super();
-	}
-
-	override strategy(): 'explicit' | 'all' {
-		return 'all';
-	}
-	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
-		const res = await this.kv.get(key) ?? undefined;
-		return res;
-	}
-	override async put(
-		key: string,
-		response: any,
-		tables: string[],
-		isTag: boolean,
-		config?: CacheConfig,
-	): Promise<void> {
-		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
-		for (const table of tables) {
-			const keys = this.usedTablesPerKey[table];
-			if (keys === undefined) {
-				this.usedTablesPerKey[table] = [key];
-			} else {
-				keys.push(key);
-			}
-		}
-	}
-	override async onMutate(params: MutationOption): Promise<void> {
-		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
-		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
-
-		const keysToDelete = new Set<string>();
-
-		for (const table of tablesArray) {
-			const tableName = is(table, Table) ? getTableName(table) : table as string;
-			const keys = this.usedTablesPerKey[tableName] ?? [];
-			for (const key of keys) keysToDelete.add(key);
-		}
-
-		if (keysToDelete.size > 0 || tagsArray.length > 0) {
-			for (const tag of tagsArray) {
-				await this.kv.delete(tag);
-			}
-
-			for (const key of keysToDelete) {
-				await this.kv.delete(key);
-				for (const table of tablesArray) {
-					const tableName = is(table, Table) ? getTableName(table) : table as string;
-					this.usedTablesPerKey[tableName] = [];
-				}
-			}
-		}
-	}
-}
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestCache extends TestGlobalCache {
-	override strategy(): 'explicit' | 'all' {
-		return 'explicit';
-	}
-}
+import { describe, expect } from 'vitest';
+import type { Test } from './instrumentation';
 
-declare module 'vitest' {
-	interface TestContext {
-		cachedMySQL: {
-			db: MySqlDatabase<any, any>;
-			dbGlobalCached: MySqlDatabase<any, any>;
-		};
-	}
-}
-
-const usersTable = mysqlTable('users', {
+const usersTable = mysqlTable('users_for_cache', {
 	id: serial('id').primaryKey(),
 	name: text('name').notNull(),
 	verified: boolean('verified').notNull().default(false),
@@ -92,258 +11,189 @@ const usersTable = mysqlTable('users', {
 	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
 });
 
-const postsTable = mysqlTable('posts', {
+const postsTable = mysqlTable('posts_for_cache', {
 	id: serial().primaryKey(),
 	description: text().notNull(),
 	userId: int('city_id').references(() => usersTable.id),
 });
 
-export function tests() {
-	describe('common_cache', () => {
-		beforeEach(async (ctx) => {
-			const { db, dbGlobalCached } = ctx.cachedMySQL;
-			await db.execute(sql`drop table if exists users`);
-			await db.execute(sql`drop table if exists posts`);
-			await db.$cache?.invalidate({ tables: 'users' });
-			await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
-			// public users
-			await db.execute(
-				sql`
-					create table users (
+export function runTests(vendor: 'mysql' | 'planetscale', test: Test) {
+	describe('cache:', () => {
+		test.beforeEach(async ({ client }) => {
+			await client.batch([
+				`drop table if exists users_for_cache, posts_for_cache`,
+			]);
+			await client.batch([
+				`create table users_for_cache (
 						id serial primary key,
 						name text not null,
 						verified boolean not null default false,
 						jsonb json,
 						created_at timestamp not null default now()
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table posts (
+					)`,
+				`create table posts_for_cache (
 						id serial primary key,
 						description text not null,
 						user_id int
-					)
-				`,
-			);
+					)`,
+			]);
 		});
 
-		test('test force invalidate', async (ctx) => {
-			const { db } = ctx.cachedMySQL;
+		test('test force invalidate', async ({ drizzle }) => {
+			const { db, invalidate } = drizzle.withCacheExplicit;
 
-			const spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
-			await db.$cache?.invalidate({ tables: 'users' });
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+			await db.$cache?.invalidate({ tables: 'users_for_cache' });
+			expect(invalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('default global config - no cache should be hit', async (ctx) => {
-			const { db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('default global config - no cache should be hit', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheExplicit;
 
 			await db.select().from(usersTable);
 
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(0);
+			expect(get).toHaveBeenCalledTimes(0);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('default global config + enable cache on select: get, put', async (ctx) => {
-			const { db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('default global config + enable cache on select: get, put', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheExplicit;
 
 			await db.select().from(usersTable).$withCache();
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('default global config + enable cache on select + write: get, put, onMutate', async (ctx) => {
-			const { db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('default global config + enable cache on select + write: get, put, onMutate', async ({ drizzle }) => {
+			const { db, put, get, onMutate: invalidate } = drizzle.withCacheExplicit;
 
 			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
+			put.mockClear();
+			get.mockClear();
+			invalidate.mockClear();
 
 			await db.insert(usersTable).values({ name: 'John' });
 
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+			expect(put).toHaveBeenCalledTimes(0);
+			expect(get).toHaveBeenCalledTimes(0);
+			expect(invalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('default global config + enable cache on select + disable invalidate: get, put', async (ctx) => {
-			const { db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('default global config + enable cache on select + disable invalidate: get, put', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheExplicit;
 
 			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 
 			await db.insert(usersTable).values({ name: 'John' });
 
 			// invalidate force
 			await db.$cache?.invalidate({ tags: ['custom'] });
+			// TODO: check?
 		});
 
-		test('global: true + disable cache', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('global: true + disable cache', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheAll;
 
 			await db.select().from(usersTable).$withCache(false);
 
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(0);
+			expect(get).toHaveBeenCalledTimes(0);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - cache should be hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('global: true - cache should be hit', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheAll;
 
 			await db.select().from(usersTable);
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - cache: false on select - no cache hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('global: true - cache: false on select - no cache hit', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheAll;
 
 			await db.select().from(usersTable).$withCache(false);
 
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(0);
+			expect(get).toHaveBeenCalledTimes(0);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - disable invalidate - cache hit + no invalidate', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('global: true - disable invalidate - cache hit + no invalidate', async ({ drizzle }) => {
+			const { db, put, get, onMutate: invalidate } = drizzle.withCacheAll;
 
 			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
+			put.mockClear();
+			get.mockClear();
+			invalidate.mockClear();
 
 			await db.insert(usersTable).values({ name: 'John' });
 
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+			expect(put).toHaveBeenCalledTimes(0);
+			expect(get).toHaveBeenCalledTimes(0);
+			expect(invalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('global: true - with custom tag', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedMySQL;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+		test('global: true - with custom tag', async ({ drizzle }) => {
+			const { db, put, get, invalidate } = drizzle.withCacheAll;
 
 			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
 
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+			expect(put).toHaveBeenCalledTimes(1);
+			expect(get).toHaveBeenCalledTimes(1);
+			expect(invalidate).toHaveBeenCalledTimes(0);
 
 			await db.insert(usersTable).values({ name: 'John' });
 
 			// invalidate force
 			await db.$cache?.invalidate({ tags: ['custom'] });
+			// TODO: check?
 		});
 
 		// check select used tables
-		test('check simple select used tables', (ctx) => {
-			const { db } = ctx.cachedMySQL;
+		test('check simple select used tables', ({ drizzle }) => {
+			const { db } = drizzle.withCacheExplicit;
 
 			// @ts-expect-error
-			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
+			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users_for_cache']);
 			// @ts-expect-error
-			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
+			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users_for_cache']);
 		});
+
 		// check select+join used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedMySQL;
+		test('select+join', ({ drizzle }) => {
+			const { db } = drizzle.withCacheExplicit;
 
 			// @ts-expect-error
 			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
-				.toStrictEqual(['users', 'posts']);
+				.toStrictEqual(['users_for_cache', 'posts_for_cache']);
 			expect(
 				// @ts-expect-error
 				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
+			).toStrictEqual(['users_for_cache', 'posts_for_cache']);
 		});
+
 		// check select+2join used tables
-		test('select+2joins', (ctx) => {
-			const { db } = ctx.cachedMySQL;
+		test('select+2joins', ({ drizzle }) => {
+			const { db } = drizzle.withCacheExplicit;
 
 			expect(
 				db.select().from(usersTable).leftJoin(
@@ -356,24 +206,24 @@ export function tests() {
 					// @ts-expect-error
 					.getUsedTables(),
 			)
-				.toStrictEqual(['users', 'posts']);
+				.toStrictEqual(['users_for_cache', 'posts_for_cache']);
 			expect(
 				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).leftJoin(
 					alias(postsTable, 'post2'),
 					eq(usersTable.id, postsTable.userId),
 					// @ts-expect-error
 				).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
+			).toStrictEqual(['users_for_cache', 'posts_for_cache']);
 		});
 		// select subquery used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedMySQL;
+		test('select+join', ({ drizzle }) => {
+			const { db } = drizzle.withCacheExplicit;
 
 			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
 			db.select().from(sq);
 
 			// @ts-expect-error
-			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
+			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users_for_cache']);
 		});
 	});
 }
diff --git a/integration-tests/tests/mysql/mysql-common.ts b/integration-tests/tests/mysql/mysql-common.ts
index 9df31a2d57..6cfe099da8 100644
--- a/integration-tests/tests/mysql/mysql-common.ts
+++ b/integration-tests/tests/mysql/mysql-common.ts
@@ -1,5363 +1,27 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import 'dotenv/config';
-import Docker from 'dockerode';
-import {
-	and,
-	asc,
-	avg,
-	avgDistinct,
-	count,
-	countDistinct,
-	eq,
-	exists,
-	getTableColumns,
-	gt,
-	gte,
-	inArray,
-	like,
-	lt,
-	max,
-	min,
-	Name,
-	not,
-	notInArray,
-	sql,
-	sum,
-	sumDistinct,
-	TransactionRollbackError,
-} from 'drizzle-orm';
-import type { MySqlDatabase } from 'drizzle-orm/mysql-core';
-import {
-	alias,
-	bigint,
-	binary,
-	boolean,
-	char,
-	date,
-	datetime,
-	decimal,
-	double,
-	except,
-	exceptAll,
-	float,
-	foreignKey,
-	getTableConfig,
-	getViewConfig,
-	index,
-	int,
-	intersect,
-	intersectAll,
-	json,
-	mediumint,
-	mysqlEnum,
-	mysqlSchema,
-	mysqlTable,
-	mysqlTableCreator,
-	mysqlView,
-	primaryKey,
-	real,
-	serial,
-	smallint,
-	text,
-	time,
-	timestamp,
-	tinyint,
-	union,
-	unionAll,
-	unique,
-	uniqueIndex,
-	uniqueKeyName,
-	varbinary,
-	varchar,
-	year,
-} from 'drizzle-orm/mysql-core';
-import type { MySqlRemoteDatabase } from 'drizzle-orm/mysql-proxy';
-import { migrate } from 'drizzle-orm/mysql2/migrator';
-import getPort from 'get-port';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
-import { Expect, toLocalDate } from '~/utils.ts';
-import type { Equal } from '~/utils.ts';
 
-type TestMySQLDB = MySqlDatabase<any, any>;
-
-declare module 'vitest' {
-	interface TestContext {
-		mysql: {
-			db: TestMySQLDB;
-		};
-		mysqlProxy: {
-			db: MySqlRemoteDatabase;
-		};
-	}
-}
-
-const ENABLE_LOGGING = false;
-
-const allTypesTable = mysqlTable('all_types', {
-	serial: serial('serial'),
-	bigint53: bigint('bigint53', {
-		mode: 'number',
-	}),
-	bigint64: bigint('bigint64', {
-		mode: 'bigint',
-	}),
-	binary: binary('binary'),
-	boolean: boolean('boolean'),
-	char: char('char'),
-	date: date('date', {
-		mode: 'date',
-	}),
-	dateStr: date('date_str', {
-		mode: 'string',
-	}),
-	datetime: datetime('datetime', {
-		mode: 'date',
-	}),
-	datetimeStr: datetime('datetime_str', {
-		mode: 'string',
-	}),
-	decimal: decimal('decimal'),
-	decimalNum: decimal('decimal_num', {
-		scale: 30,
-		mode: 'number',
-	}),
-	decimalBig: decimal('decimal_big', {
-		scale: 30,
-		mode: 'bigint',
-	}),
-	double: double('double'),
-	float: float('float'),
-	int: int('int'),
-	json: json('json'),
-	medInt: mediumint('med_int'),
-	smallInt: smallint('small_int'),
-	real: real('real'),
-	text: text('text'),
-	time: time('time'),
-	timestamp: timestamp('timestamp', {
-		mode: 'date',
-	}),
-	timestampStr: timestamp('timestamp_str', {
-		mode: 'string',
-	}),
-	tinyInt: tinyint('tiny_int'),
-	varbin: varbinary('varbin', {
-		length: 16,
-	}),
-	varchar: varchar('varchar', {
-		length: 255,
-	}),
-	year: year('year'),
-	enum: mysqlEnum('enum', ['enV1', 'enV2']),
-});
-
-const usersTable = mysqlTable('userstest', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
-});
-
-const users2Table = mysqlTable('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id').references(() => citiesTable.id),
-});
-
-const citiesTable = mysqlTable('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const usersOnUpdate = mysqlTable('users_on_update', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	updateCounter: int('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
-	updatedAt: datetime('updated_at', { mode: 'date', fsp: 3 }).$onUpdate(() => new Date()),
-	uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper(name)`),
-	alwaysNull: text('always_null').$type<string | null>().$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
-});
-
-const datesTable = mysqlTable('datestable', {
-	date: date('date'),
-	dateAsString: date('date_as_string', { mode: 'string' }),
-	time: time('time', { fsp: 1 }),
-	datetime: datetime('datetime', { fsp: 2 }),
-	datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
-	timestamp: timestamp('timestamp', { fsp: 3 }),
-	timestampAsString: timestamp('timestamp_as_string', { fsp: 3, mode: 'string' }),
-	year: year('year'),
-});
-
-const coursesTable = mysqlTable('courses', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	categoryId: int('category_id').references(() => courseCategoriesTable.id),
-});
-
-const courseCategoriesTable = mysqlTable('course_categories', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const orders = mysqlTable('orders', {
-	id: serial('id').primaryKey(),
-	region: text('region').notNull(),
-	product: text('product').notNull().$default(() => 'random_string'),
-	amount: int('amount').notNull(),
-	quantity: int('quantity').notNull(),
-});
-
-const usersMigratorTable = mysqlTable('users12', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-}, (table) => {
-	return {
-		name: uniqueIndex('').on(table.name).using('btree'),
-	};
-});
-
-// To test aggregate functions
-const aggregateTable = mysqlTable('aggregate_table', {
-	id: serial('id').notNull(),
-	name: text('name').notNull(),
-	a: int('a'),
-	b: int('b'),
-	c: int('c'),
-	nullOnly: int('null_only'),
-});
-
-// To test another schema and multischema
-const mySchema = mysqlSchema(`mySchema`);
-
-const usersMySchemaTable = mySchema.table('userstest', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
-});
-
-const users2MySchemaTable = mySchema.table('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id').references(() => citiesTable.id),
-});
-
-const citiesMySchemaTable = mySchema.table('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-let mysqlContainer: Docker.Container;
-export async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-	return { connectionString: `mysql://root:mysql@127.0.0.1:${port}/drizzle`, container: mysqlContainer };
-}
-
-afterAll(async () => {
-	await mysqlContainer?.stop().catch(console.error);
-});
-
-export function tests(driver?: string) {
-	describe('common', () => {
-		// afterAll(async () => {
-		// 	await mysqlContainer?.stop().catch(console.error);
-		// });
-
-		beforeEach(async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`drop table if exists userstest`);
-			await db.execute(sql`drop table if exists users2`);
-			await db.execute(sql`drop table if exists cities`);
-			await db.execute(sql`drop table if exists \`all_types\``);
-
-			if (driver !== 'planetscale') {
-				await db.execute(sql`drop schema if exists \`mySchema\``);
-				await db.execute(sql`create schema if not exists \`mySchema\``);
-			}
-
-			await db.execute(
-				sql`
-					create table userstest (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb json,
-						created_at timestamp not null default now()
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table users2 (
-						id serial primary key,
-						name text not null,
-						city_id int references cities(id)
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table cities (
-						id serial primary key,
-						name text not null
-					)
-				`,
-			);
-
-			if (driver !== 'planetscale') {
-				// mySchema
-				await db.execute(
-					sql`
-						create table \`mySchema\`.\`userstest\` (
-							\`id\` serial primary key,
-							\`name\` text not null,
-							\`verified\` boolean not null default false,
-							\`jsonb\` json,
-							\`created_at\` timestamp not null default now()
-						)
-					`,
-				);
-
-				await db.execute(
-					sql`
-						create table \`mySchema\`.\`cities\` (
-							\`id\` serial primary key,
-							\`name\` text not null
-						)
-					`,
-				);
-
-				await db.execute(
-					sql`
-						create table \`mySchema\`.\`users2\` (
-							\`id\` serial primary key,
-							\`name\` text not null,
-							\`city_id\` int references \`mySchema\`.\`cities\`(\`id\`)
-						)
-					`,
-				);
-			}
-		});
-
-		async function setupReturningFunctionsTest(db: MySqlDatabase<any, any>) {
-			await db.execute(sql`drop table if exists \`users_default_fn\``);
-			await db.execute(
-				sql`
-					create table \`users_default_fn\` (
-						\`id\` varchar(256) primary key,
-						\`name\` text not null
-					);
-				`,
-			);
-		}
-
-		async function setupSetOperationTest(db: TestMySQLDB) {
-			await db.execute(sql`drop table if exists \`users2\``);
-			await db.execute(sql`drop table if exists \`cities\``);
-			await db.execute(
-				sql`
-					create table \`users2\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`city_id\` int references \`cities\`(\`id\`)
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`cities\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null
-					)
-				`,
-			);
-
-			await db.insert(citiesTable).values([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await db.insert(users2Table).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 2 },
-				{ id: 3, name: 'Jack', cityId: 3 },
-				{ id: 4, name: 'Peter', cityId: 3 },
-				{ id: 5, name: 'Ben', cityId: 2 },
-				{ id: 6, name: 'Jill', cityId: 1 },
-				{ id: 7, name: 'Mary', cityId: 2 },
-				{ id: 8, name: 'Sally', cityId: 1 },
-			]);
-		}
-
-		async function setupAggregateFunctionsTest(db: TestMySQLDB) {
-			await db.execute(sql`drop table if exists \`aggregate_table\``);
-			await db.execute(
-				sql`
-					create table \`aggregate_table\` (
-					    \`id\` integer primary key auto_increment not null,
-					    \`name\` text not null,
-					    \`a\` integer,
-					    \`b\` integer,
-					    \`c\` integer,
-					    \`null_only\` integer
-					);
-				`,
-			);
-			await db.insert(aggregateTable).values([
-				{ name: 'value 1', a: 5, b: 10, c: 20 },
-				{ name: 'value 1', a: 5, b: 20, c: 30 },
-				{ name: 'value 2', a: 10, b: 50, c: 60 },
-				{ name: 'value 3', a: 20, b: 20, c: null },
-				{ name: 'value 4', a: null, b: 90, c: 120 },
-				{ name: 'value 5', a: 80, b: 10, c: null },
-				{ name: 'value 6', a: null, b: null, c: 150 },
-			]);
-		}
-
-		test('table config: unsigned ints', async () => {
-			const unsignedInts = mysqlTable('cities1', {
-				bigint: bigint('bigint', { mode: 'number', unsigned: true }),
-				int: int('int', { unsigned: true }),
-				smallint: smallint('smallint', { unsigned: true }),
-				mediumint: mediumint('mediumint', { unsigned: true }),
-				tinyint: tinyint('tinyint', { unsigned: true }),
-			});
-
-			const tableConfig = getTableConfig(unsignedInts);
-
-			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
-			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
-			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
-			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
-			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
-
-			expect(bigintColumn.getSQLType()).toBe('bigint unsigned');
-			expect(intColumn.getSQLType()).toBe('int unsigned');
-			expect(smallintColumn.getSQLType()).toBe('smallint unsigned');
-			expect(mediumintColumn.getSQLType()).toBe('mediumint unsigned');
-			expect(tinyintColumn.getSQLType()).toBe('tinyint unsigned');
-		});
-
-		test('table config: signed ints', async () => {
-			const unsignedInts = mysqlTable('cities1', {
-				bigint: bigint('bigint', { mode: 'number' }),
-				int: int('int'),
-				smallint: smallint('smallint'),
-				mediumint: mediumint('mediumint'),
-				tinyint: tinyint('tinyint'),
-			});
-
-			const tableConfig = getTableConfig(unsignedInts);
-
-			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
-			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
-			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
-			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
-			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
-
-			expect(bigintColumn.getSQLType()).toBe('bigint');
-			expect(intColumn.getSQLType()).toBe('int');
-			expect(smallintColumn.getSQLType()).toBe('smallint');
-			expect(mediumintColumn.getSQLType()).toBe('mediumint');
-			expect(tinyintColumn.getSQLType()).toBe('tinyint');
-		});
-
-		test('table config: foreign keys name', async () => {
-			const table = mysqlTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
-			}));
-
-			const tableConfig = getTableConfig(table);
-
-			expect(tableConfig.foreignKeys).toHaveLength(1);
-			expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
-		});
-
-		test('table config: primary keys name', async () => {
-			const table = mysqlTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-			}));
-
-			const tableConfig = getTableConfig(table);
-
-			expect(tableConfig.primaryKeys).toHaveLength(1);
-			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
-		});
-
-		test('table configs: unique third param', async () => {
-			const cities1Table = mysqlTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: unique('custom_name').on(t.name, t.state),
-				f1: unique('custom_name1').on(t.name, t.state),
-			}));
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			expect(tableConfig.uniqueConstraints).toHaveLength(2);
-
-			expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
-			expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-
-			expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
-			expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-		});
-
-		test('table configs: unique in column', async () => {
-			const cities1Table = mysqlTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull().unique(),
-				state: text('state').unique('custom'),
-				field: text('field').unique('custom_field'),
-			});
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			const columnName = tableConfig.columns.find((it) => it.name === 'name');
-			expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
-			expect(columnName?.isUnique).toBeTruthy();
-
-			const columnState = tableConfig.columns.find((it) => it.name === 'state');
-			expect(columnState?.uniqueName).toBe('custom');
-			expect(columnState?.isUnique).toBeTruthy();
-
-			const columnField = tableConfig.columns.find((it) => it.name === 'field');
-			expect(columnField?.uniqueName).toBe('custom_field');
-			expect(columnField?.isUnique).toBeTruthy();
-		});
-
-		test('select all fields', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const result = await db.select().from(usersTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('select sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql`upper(${usersTable.name})`,
-			}).from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select typed sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql<string>`upper(${usersTable.name})`,
-			}).from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select with empty array in inArray', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(inArray(usersTable.id, []));
-
-			expect(result).toEqual([]);
-		});
-
-		test('select with empty array in notInArray', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(notInArray(usersTable.id, []));
-
-			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
-		});
-
-		test('select distinct', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const usersDistinctTable = mysqlTable('users_distinct', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]);
-			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-		});
-
-		test('insert returning sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const [result, _] = await db.insert(usersTable).values({ name: 'John' });
-
-			expect(result.insertId).toBe(1);
-		});
-
-		test('delete returning sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(users[0].affectedRows).toBe(1);
-		});
-
-		test('update returning sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			expect(users[0].changedRows).toBe(1);
-		});
-
-		test('update with returning all fields', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
-			expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
-		});
-
-		test('update with returning partial', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('delete with returning all fields', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('delete with returning partial', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('insert + select', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const result = await db.select().from(usersTable);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-			await db.insert(usersTable).values({ name: 'Jane' });
-			const result2 = await db.select().from(usersTable);
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('json insert', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				jsonb: usersTable.jsonb,
-			}).from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
-		});
-
-		test('insert with overridden default values', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John', verified: true });
-			const result = await db.select().from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('insert many', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]);
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				jsonb: usersTable.jsonb,
-				verified: usersTable.verified,
-			}).from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('insert many with returning', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]);
-
-			expect(result[0].affectedRows).toBe(4);
-		});
-
-		test('select with group by as field', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.name);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('select with exists', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const user = alias(usersTable, 'user');
-			const result = await db.select({ name: usersTable.name }).from(usersTable).where(
-				exists(
-					db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
-				),
-			);
-
-			expect(result).toEqual([{ name: 'John' }]);
-		});
-
-		test('select with group by as sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(sql`${usersTable.name}`);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('$default function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
-			const selectedOrder = await db.select().from(orders);
-
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-		});
-
-		test('$default with empty array', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`s_orders\``);
-			await db.execute(
-				sql`
-					create table \`s_orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text default ('Ukraine'),
-					    \`product\` text not null
-					)
-				`,
-			);
-
-			const users = mysqlTable('s_orders', {
-				id: serial('id').primaryKey(),
-				region: text('region').default('Ukraine'),
-				product: text('product').$defaultFn(() => 'random_string'),
-			});
-
-			await db.insert(users).values({});
-			const selectedOrder = await db.select().from(users);
-
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-		});
-
-		test('select with group by as sql + column', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(sql`${usersTable.name}`, usersTable.id);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('select with group by complex query', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`)
-				.orderBy(asc(usersTable.name))
-				.limit(1);
-
-			expect(result).toEqual([{ name: 'Jane' }]);
-		});
-
-		test('build query', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, usersTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: `select \`id\`, \`name\` from \`userstest\` group by \`userstest\`.\`id\`, \`userstest\`.\`name\``,
-				params: [],
-			});
-		});
-
-		test('Query check: Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			const query = db
-				.insert(users)
-				.values({})
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Query check: Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state').default('UA'),
-			});
-
-			const query = db
-				.insert(users)
-				.values([{}, {}])
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into `users` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('empty_insert_single', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
-			);
-
-			await db.insert(users).values({});
-
-			const res = await db.select().from(users);
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
-		});
-
-		test('Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('empty_insert_multiple', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
-			);
-
-			await db.insert(users).values([{}, {}]);
-
-			const res = await db.select().from(users);
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
-		});
-
-		test('build query insert with onDuplicate', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const query = db.insert(usersTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onDuplicateKeyUpdate({ set: { name: 'John1' } })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
-				params: ['John', '["foo","bar"]', 'John1'],
-			});
-		});
-
-		test('insert with onDuplicate', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable)
-				.values({ name: 'John' });
-
-			await db.insert(usersTable)
-				.values({ id: 1, name: 'John' })
-				.onDuplicateKeyUpdate({ set: { name: 'John1' } });
-
-			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(res).toEqual([{ id: 1, name: 'John1' }]);
-		});
-
-		test('insert conflict', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable)
-				.values({ name: 'John' });
-
-			await expect((async () => {
-				db.insert(usersTable).values({ id: 1, name: 'John1' });
-			})()).resolves.not.toThrowError();
-		});
-
-		test('insert conflict with ignore', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable)
-				.values({ name: 'John' });
-
-			await db.insert(usersTable)
-				.ignore()
-				.values({ id: 1, name: 'John1' });
-
-			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: sql`${'John'}` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('partial join with alias', async (ctx) => {
-			const { db } = ctx.mysql;
-			const customerAlias = alias(usersTable, 'customer');
-
-			await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select({
-					user: {
-						id: usersTable.id,
-						name: usersTable.name,
-					},
-					customer: {
-						id: customerAlias.id,
-						name: customerAlias.name,
-					},
-				}).from(usersTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersTable.id, 10));
-
-			expect(result).toEqual([{
-				user: { id: 10, name: 'Ivan' },
-				customer: { id: 11, name: 'Hans' },
-			}]);
-		});
-
-		test('full join with alias', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select().from(users)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(users.id, 10));
-
-			expect(result).toEqual([{
-				users: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('select from alias', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const user = alias(users, 'user');
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select()
-				.from(user)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(user.id, 10));
-
-			expect(result).toEqual([{
-				user: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('insert with spaces', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('prepared statement', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const statement = db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable)
-				.prepare();
-			const result = await statement.execute();
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert: placeholders on columns with encoder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const date = new Date('2024-08-07T15:30:00Z');
-
-			const statement = db.insert(usersTable).values({
-				name: 'John',
-				createdAt: sql.placeholder('createdAt'),
-			}).prepare();
-
-			await statement.execute({ createdAt: date });
-
-			const result = await db
-				.select({
-					id: usersTable.id,
-					createdAt: usersTable.createdAt,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, createdAt: date },
-			]);
-		});
-
-		test('prepared statement reuse', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const stmt = db.insert(usersTable).values({
-				verified: true,
-				name: sql.placeholder('name'),
-			}).prepare();
-
-			for (let i = 0; i < 10; i++) {
-				await stmt.execute({ name: `John ${i}` });
-			}
-
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				verified: usersTable.verified,
-			}).from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John 0', verified: true },
-				{ id: 2, name: 'John 1', verified: true },
-				{ id: 3, name: 'John 2', verified: true },
-				{ id: 4, name: 'John 3', verified: true },
-				{ id: 5, name: 'John 4', verified: true },
-				{ id: 6, name: 'John 5', verified: true },
-				{ id: 7, name: 'John 6', verified: true },
-				{ id: 8, name: 'John 7', verified: true },
-				{ id: 9, name: 'John 8', verified: true },
-				{ id: 10, name: 'John 9', verified: true },
-			]);
-		});
-
-		test('prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const stmt = db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.prepare();
-			const result = await stmt.execute({ id: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('prepared statement with placeholder in .limit', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.limit(sql.placeholder('limit'))
-				.prepare();
-
-			const result = await stmt.execute({ id: 1, limit: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-			expect(result).toHaveLength(1);
-		});
-
-		test('prepared statement with placeholder in .offset', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.limit(sql.placeholder('limit'))
-				.offset(sql.placeholder('offset'))
-				.prepare();
-
-			const result = await stmt.execute({ limit: 1, offset: 1 });
-
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-		});
-
-		test('prepared statement built using $dynamic', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			function withLimitOffset(qb: any) {
-				return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
-			}
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.$dynamic();
-			withLimitOffset(stmt).prepare('stmt_limit');
-
-			const result = await stmt.execute({ limit: 1, offset: 1 });
-
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-			expect(result).toHaveLength(1);
-		});
-
-		test('migrator', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists cities_migration`);
-			await db.execute(sql`drop table if exists users_migration`);
-			await db.execute(sql`drop table if exists users12`);
-			await db.execute(sql`drop table if exists __drizzle_migrations`);
-
-			await migrate(db, { migrationsFolder: './drizzle2/mysql' });
-
-			await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-
-			const result = await db.select().from(usersMigratorTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-			await db.execute(sql`drop table cities_migration`);
-			await db.execute(sql`drop table users_migration`);
-			await db.execute(sql`drop table users12`);
-			await db.execute(sql`drop table __drizzle_migrations`);
-		});
-
-		test('insert via db.execute + select via db.execute', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
-
-			const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
-			expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert via db.execute w/ query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const inserted = await db.execute(
-				db.insert(usersTable).values({ name: 'John' }),
-			);
-			expect(inserted[0].affectedRows).toBe(1);
-		});
-
-		test('insert + select all possible dates', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-			await db.execute(
-				sql`
-					create table \`datestable\` (
-					    \`date\` date,
-					    \`date_as_string\` date,
-					    \`time\` time,
-					    \`datetime\` datetime,
-					    \`datetime_as_string\` datetime,
-					    \`timestamp\` timestamp(3),
-					    \`timestamp_as_string\` timestamp(3),
-					    \`year\` year
-					)
-				`,
-			);
-
-			const date = new Date('2022-11-11');
-			const dateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
-
-			await db.insert(datesTable).values({
-				date: date,
-				dateAsString: '2022-11-11',
-				time: '12:12:12',
-				datetime: date,
-				year: 22,
-				datetimeAsString: '2022-11-11 12:12:12',
-				timestamp: dateWithMilliseconds,
-				timestampAsString: '2022-11-11 12:12:12.123',
-			});
-
-			const res = await db.select().from(datesTable);
-
-			expect(res[0]?.date).toBeInstanceOf(Date);
-			expect(res[0]?.datetime).toBeInstanceOf(Date);
-			expect(typeof res[0]?.dateAsString).toBe('string');
-			expect(typeof res[0]?.datetimeAsString).toBe('string');
-
-			expect(res).toEqual([{
-				date: toLocalDate(new Date('2022-11-11')),
-				dateAsString: '2022-11-11',
-				time: '12:12:12',
-				datetime: new Date('2022-11-11'),
-				year: 2022,
-				datetimeAsString: '2022-11-11 12:12:12',
-				timestamp: new Date('2022-11-11 12:12:12.123'),
-				timestampAsString: '2022-11-11 12:12:12.123',
-			}]);
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-		});
-
-		const tableWithEnums = mysqlTable('enums_test_case', {
-			id: serial('id').primaryKey(),
-			enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
-			enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
-			enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
-		});
-
-		test('Mysql enum as ts enum', async (ctx) => {
-			enum Test {
-				a = 'a',
-				b = 'b',
-				c = 'c',
-			}
-
-			const tableWithTsEnums = mysqlTable('enums_test_case', {
-				id: serial('id').primaryKey(),
-				enum1: mysqlEnum('enum1', Test).notNull(),
-				enum2: mysqlEnum('enum2', Test).default(Test.a),
-				enum3: mysqlEnum('enum3', Test).notNull().default(Test.b),
-			});
-
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`enums_test_case\``);
-
-			await db.execute(sql`
-				create table \`enums_test_case\` (
-				    \`id\` serial primary key,
-				    \`enum1\` ENUM('a', 'b', 'c') not null,
-				    \`enum2\` ENUM('a', 'b', 'c') default 'a',
-				    \`enum3\` ENUM('a', 'b', 'c') not null default 'b'
-				)
-			`);
-
-			await db.insert(tableWithTsEnums).values([
-				{ id: 1, enum1: Test.a, enum2: Test.b, enum3: Test.c },
-				{ id: 2, enum1: Test.a, enum3: Test.c },
-				{ id: 3, enum1: Test.a },
-			]);
-
-			const res = await db.select().from(tableWithTsEnums);
-
-			await db.execute(sql`drop table \`enums_test_case\``);
-
-			expect(res).toEqual([
-				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-				{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
-				{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
-			]);
-		});
-
-		test('Mysql enum test case #1', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`enums_test_case\``);
-
-			await db.execute(sql`
-				create table \`enums_test_case\` (
-				    \`id\` serial primary key,
-				    \`enum1\` ENUM('a', 'b', 'c') not null,
-				    \`enum2\` ENUM('a', 'b', 'c') default 'a',
-				    \`enum3\` ENUM('a', 'b', 'c') not null default 'b'
-				)
-			`);
-
-			await db.insert(tableWithEnums).values([
-				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-				{ id: 2, enum1: 'a', enum3: 'c' },
-				{ id: 3, enum1: 'a' },
-			]);
-
-			const res = await db.select().from(tableWithEnums);
-
-			await db.execute(sql`drop table \`enums_test_case\``);
-
-			expect(res).toEqual([
-				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-				{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
-				{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
-			]);
-		});
-
-		test('left join (flat object fields)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const res = await db.select({
-				userId: users2Table.id,
-				userName: users2Table.name,
-				cityId: citiesTable.id,
-				cityName: citiesTable.name,
-			}).from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
-				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
-			]);
-		});
-
-		test('left join (grouped fields)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const res = await db.select({
-				id: users2Table.id,
-				user: {
-					name: users2Table.name,
-					nameUpper: sql<string>`upper(${users2Table.name})`,
-				},
-				city: {
-					id: citiesTable.id,
-					name: citiesTable.name,
-					nameUpper: sql<string>`upper(${citiesTable.name})`,
-				},
-			}).from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{
-					id: 1,
-					user: { name: 'John', nameUpper: 'JOHN' },
-					city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
-				},
-				{
-					id: 2,
-					user: { name: 'Jane', nameUpper: 'JANE' },
-					city: null,
-				},
-			]);
-		});
-
-		test('left join (all fields)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const res = await db.select().from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{
-					users2: {
-						id: 1,
-						name: 'John',
-						cityId: 1,
-					},
-					cities: {
-						id: 1,
-						name: 'Paris',
-					},
-				},
-				{
-					users2: {
-						id: 2,
-						name: 'Jane',
-						cityId: null,
-					},
-					cities: null,
-				},
-			]);
-		});
-
-		test('join subquery', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`courses\``);
-			await db.execute(sql`drop table if exists \`course_categories\``);
-
-			await db.execute(
-				sql`
-					create table \`course_categories\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`courses\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`category_id\` int references \`course_categories\`(\`id\`)
-					)
-				`,
-			);
-
-			await db.insert(courseCategoriesTable).values([
-				{ name: 'Category 1' },
-				{ name: 'Category 2' },
-				{ name: 'Category 3' },
-				{ name: 'Category 4' },
-			]);
-
-			await db.insert(coursesTable).values([
-				{ name: 'Development', categoryId: 2 },
-				{ name: 'IT & Software', categoryId: 3 },
-				{ name: 'Marketing', categoryId: 4 },
-				{ name: 'Design', categoryId: 1 },
-			]);
-
-			const sq2 = db
-				.select({
-					categoryId: courseCategoriesTable.id,
-					category: courseCategoriesTable.name,
-					total: sql<number>`count(${courseCategoriesTable.id})`,
-				})
-				.from(courseCategoriesTable)
-				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
-				.as('sq2');
-
-			const res = await db
-				.select({
-					courseName: coursesTable.name,
-					categoryId: sq2.categoryId,
-				})
-				.from(coursesTable)
-				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
-				.orderBy(coursesTable.name);
-
-			expect(res).toEqual([
-				{ courseName: 'Design', categoryId: 1 },
-				{ courseName: 'Development', categoryId: 2 },
-				{ courseName: 'IT & Software', categoryId: 3 },
-				{ courseName: 'Marketing', categoryId: 4 },
-			]);
-
-			await db.execute(sql`drop table if exists \`courses\``);
-			await db.execute(sql`drop table if exists \`course_categories\``);
-		});
-
-		test('with ... select', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const regionalSales = db
-				.$with('regional_sales')
-				.as(
-					db
-						.select({
-							region: orders.region,
-							totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-						})
-						.from(orders)
-						.groupBy(orders.region),
-				);
-
-			const topRegions = db
-				.$with('top_regions')
-				.as(
-					db
-						.select({
-							region: regionalSales.region,
-						})
-						.from(regionalSales)
-						.where(
-							gt(
-								regionalSales.totalSales,
-								db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-							),
-						),
-				);
-
-			const result = await db
-				.with(regionalSales, topRegions)
-				.select({
-					region: orders.region,
-					product: orders.product,
-					productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
-					productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
-				})
-				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-				.groupBy(orders.region, orders.product)
-				.orderBy(orders.region, orders.product);
-
-			expect(result).toEqual([
-				{
-					region: 'Europe',
-					product: 'A',
-					productUnits: 3,
-					productSales: 30,
-				},
-				{
-					region: 'Europe',
-					product: 'B',
-					productUnits: 5,
-					productSales: 50,
-				},
-				{
-					region: 'US',
-					product: 'A',
-					productUnits: 7,
-					productSales: 70,
-				},
-				{
-					region: 'US',
-					product: 'B',
-					productUnits: 9,
-					productSales: 90,
-				},
-			]);
-		});
-
-		test('with ... update', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const products = mysqlTable('products', {
-				id: serial('id').primaryKey(),
-				price: decimal('price', {
-					precision: 15,
-					scale: 2,
-				}).notNull(),
-				cheap: boolean('cheap').notNull().default(false),
-			});
-
-			await db.execute(sql`drop table if exists ${products}`);
-			await db.execute(sql`
-				create table ${products} (
-				    id serial primary key,
-				    price decimal(15, 2) not null,
-				    cheap boolean not null default false
-				)
-			`);
-
-			await db.insert(products).values([
-				{ price: '10.99' },
-				{ price: '25.85' },
-				{ price: '32.99' },
-				{ price: '2.50' },
-				{ price: '4.59' },
-			]);
-
-			const averagePrice = db
-				.$with('average_price')
-				.as(
-					db
-						.select({
-							value: sql`avg(${products.price})`.as('value'),
-						})
-						.from(products),
-				);
-
-			await db
-				.with(averagePrice)
-				.update(products)
-				.set({
-					cheap: true,
-				})
-				.where(lt(products.price, sql`(select * from ${averagePrice})`));
-
-			const result = await db
-				.select({
-					id: products.id,
-				})
-				.from(products)
-				.where(eq(products.cheap, true));
-
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
-		});
-
-		test('with ... delete', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const averageAmount = db
-				.$with('average_amount')
-				.as(
-					db
-						.select({
-							value: sql`avg(${orders.amount})`.as('value'),
-						})
-						.from(orders),
-				);
-
-			await db
-				.with(averageAmount)
-				.delete(orders)
-				.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
-
-			const result = await db
-				.select({
-					id: orders.id,
-				})
-				.from(orders);
-
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 2 },
-				{ id: 3 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
-		});
-
-		test('select from subquery sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({ name: sql<string>`concat(${users2Table.name}, " modified")`.as('name') })
-				.from(users2Table)
-				.as('sq');
-
-			const res = await db.select({ name: sq.name }).from(sq);
-
-			expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
-		});
-
-		test('select a field without joining its table', (ctx) => {
-			const { db } = ctx.mysql;
-
-			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
-		});
-
-		test('select all fields from subquery without alias', (ctx) => {
-			const { db } = ctx.mysql;
-
-			const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
-
-			expect(() => db.select().from(sq).prepare()).toThrowError();
-		});
-
-		test('select count()', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const res = await db.select({ count: sql`count(*)` }).from(usersTable);
-
-			expect(res).toEqual([{ count: 2 }]);
-		});
-
-		test('select for ...', (ctx) => {
-			const { db } = ctx.mysql;
-
-			{
-				const query = db.select().from(users2Table).for('update').toSQL();
-				expect(query.sql).toMatch(/ for update$/);
-			}
-			{
-				const query = db.select().from(users2Table).for('share', { skipLocked: true }).toSQL();
-				expect(query.sql).toMatch(/ for share skip locked$/);
-			}
-			{
-				const query = db.select().from(users2Table).for('update', { noWait: true }).toSQL();
-				expect(query.sql).toMatch(/ for update nowait$/);
-			}
-		});
-
-		test('having', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
-				name: 'Jack',
-				cityId: 2,
-			}]);
-
-			const result = await db
-				.select({
-					id: citiesTable.id,
-					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
-					usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
-				})
-				.from(citiesTable)
-				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
-				.where(({ name }) => sql`length(${name}) >= 3`)
-				.groupBy(citiesTable.id)
-				.having(({ usersCount }) => sql`${usersCount} > 0`)
-				.orderBy(({ name }) => name);
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					name: 'LONDON',
-					usersCount: 2,
-				},
-				{
-					id: 2,
-					name: 'PARIS',
-					usersCount: 1,
-				},
-			]);
-		});
-
-		test('view', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const newYorkers1 = mysqlView('new_yorkers')
-				.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
-
-			const newYorkers2 = mysqlView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
-
-			const newYorkers3 = mysqlView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		});
-
-		test('select from raw sql', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db.select({
-				id: sql<number>`id`,
-				name: sql<string>`name`,
-			}).from(sql`(select 1 as id, 'John' as name) as users`);
-
-			Expect<Equal<{ id: number; name: string }[], typeof result>>;
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
-		});
-
-		test('select from raw sql with joins', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db
-				.select({
-					id: sql<number>`users.id`,
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
-
-			Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from select', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db
-				.select({
-					userId: sql<number>`users.id`.as('userId'),
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityId: sql<number>`cities.id`.as('cityId'),
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from with clause', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = db.$with('users').as(
-				db.select({
-					id: sql<number>`id`.as('userId'),
-					name: sql<string>`name`.as('userName'),
-					city: sql<string>`city`.as('city'),
-				}).from(
-					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
-				),
-			);
-
-			const cities = db.$with('cities').as(
-				db.select({
-					id: sql<number>`id`.as('cityId'),
-					name: sql<string>`name`.as('cityName'),
-				}).from(
-					sql`(select 1 as id, 'Paris' as name) as cities`,
-				),
-			);
-
-			const result = await db
-				.with(users, cities)
-				.select({
-					userId: users.id,
-					name: users.name,
-					userCity: users.city,
-					cityId: cities.id,
-					cityName: cities.name,
-				})
-				.from(users)
-				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('prefixed table', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
-
-			const users = mysqlTable('test_prefixed_table_with_unique_name', {
-				id: int('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
-			);
-
-			await db.insert(users).values({ id: 1, name: 'John' });
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('orderBy with aliased column', (ctx) => {
-			const { db } = ctx.mysql;
-
-			const query = db.select({
-				test: sql`something`.as('test'),
-			}).from(users2Table).orderBy((fields) => fields.test).toSQL();
-
-			expect(query.sql).toBe('select something as `test` from `users2` order by `test`');
-		});
-
-		test('timestamp timezone', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
-
-			await db.insert(usersTable).values({ name: 'With default times' });
-			await db.insert(usersTable).values({
-				name: 'Without default times',
-				createdAt: date,
-			});
-			const users = await db.select().from(usersTable);
-
-			// check that the timestamps are set correctly for default times
-			expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
-
-			// check that the timestamps are set correctly for non default times
-			expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
-		});
-
-		test('transaction', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_transactions', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-			const products = mysqlTable('products_transactions', {
-				id: serial('id').primaryKey(),
-				price: int('price').notNull(),
-				stock: int('stock').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop table if exists ${products}`);
-
-			await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
-			await db.execute(
-				sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
-			);
-
-			const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
-			const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
-			const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
-			const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
-
-			await db.transaction(async (tx) => {
-				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
-				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 90 }]);
-
-			await db.execute(sql`drop table ${users}`);
-			await db.execute(sql`drop table ${products}`);
-		});
-
-		test('transaction with options (set isolationLevel)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_transactions', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-			const products = mysqlTable('products_transactions', {
-				id: serial('id').primaryKey(),
-				price: int('price').notNull(),
-				stock: int('stock').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop table if exists ${products}`);
-
-			await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
-			await db.execute(
-				sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
-			);
-
-			const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
-			const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
-			const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
-			const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
-
-			await db.transaction(async (tx) => {
-				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
-				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
-			}, { isolationLevel: 'serializable' });
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 90 }]);
-
-			await db.execute(sql`drop table ${users}`);
-			await db.execute(sql`drop table ${products}`);
-		});
-
-		test('transaction rollback', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_transactions_rollback', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_transactions_rollback (id serial not null primary key, balance int not null)`,
-			);
-
-			await expect((async () => {
-				await db.transaction(async (tx) => {
-					await tx.insert(users).values({ balance: 100 });
-					tx.rollback();
-				});
-			})()).rejects.toThrowError(TransactionRollbackError);
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('nested transaction', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_nested_transactions', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_nested_transactions (id serial not null primary key, balance int not null)`,
-			);
-
-			await db.transaction(async (tx) => {
-				await tx.insert(users).values({ balance: 100 });
-
-				await tx.transaction(async (tx) => {
-					await tx.update(users).set({ balance: 200 });
-				});
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 200 }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('nested transaction rollback', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_nested_transactions_rollback', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_nested_transactions_rollback (id serial not null primary key, balance int not null)`,
-			);
-
-			await db.transaction(async (tx) => {
-				await tx.insert(users).values({ balance: 100 });
-
-				await expect((async () => {
-					await tx.transaction(async (tx) => {
-						await tx.update(users).set({ balance: 200 });
-						tx.rollback();
-					});
-				})()).rejects.toThrowError(TransactionRollbackError);
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 100 }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('join subquery with join', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const internalStaff = mysqlTable('internal_staff', {
-				userId: int('user_id').notNull(),
-			});
-
-			const customUser = mysqlTable('custom_user', {
-				id: int('id').notNull(),
-			});
-
-			const ticket = mysqlTable('ticket', {
-				staffId: int('staff_id').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${internalStaff}`);
-			await db.execute(sql`drop table if exists ${customUser}`);
-			await db.execute(sql`drop table if exists ${ticket}`);
-
-			await db.execute(sql`create table internal_staff (user_id integer not null)`);
-			await db.execute(sql`create table custom_user (id integer not null)`);
-			await db.execute(sql`create table ticket (staff_id integer not null)`);
-
-			await db.insert(internalStaff).values({ userId: 1 });
-			await db.insert(customUser).values({ id: 1 });
-			await db.insert(ticket).values({ staffId: 1 });
-
-			const subq = db
-				.select()
-				.from(internalStaff)
-				.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
-				.as('internal_staff');
-
-			const mainQuery = await db
-				.select()
-				.from(ticket)
-				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-			expect(mainQuery).toEqual([{
-				ticket: { staffId: 1 },
-				internal_staff: {
-					internal_staff: { userId: 1 },
-					custom_user: { id: 1 },
-				},
-			}]);
-
-			await db.execute(sql`drop table ${internalStaff}`);
-			await db.execute(sql`drop table ${customUser}`);
-			await db.execute(sql`drop table ${ticket}`);
-		});
-
-		test('subquery with view', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_subquery_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			});
-
-			const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 1 },
-				{ name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.$with('sq').as(db.select().from(newYorkers));
-			const result = await db.with(sq).select().from(sq);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 3, name: 'Jack', cityId: 1 },
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('join view as subquery', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_join_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			});
-
-			const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 1 },
-				{ name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
-
-			const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
-
-			expect(result).toEqual([
-				{
-					users_join_view: { id: 1, name: 'John', cityId: 1 },
-					new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 2, name: 'Jane', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-				{
-					users_join_view: { id: 3, name: 'Jack', cityId: 1 },
-					new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 4, name: 'Jill', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('select iterator', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_iterator', {
-				id: serial('id').primaryKey(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-			await db.insert(users).values([{}, {}, {}]);
-
-			const iter = db.select().from(users).iterator();
-
-			const result: typeof users.$inferSelect[] = [];
-
-			for await (const row of iter) {
-				result.push(row);
-			}
-
-			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		});
-
-		test('select iterator w/ prepared statement', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users_iterator', {
-				id: serial('id').primaryKey(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-			await db.insert(users).values([{}, {}, {}]);
-
-			const prepared = db.select().from(users).prepare();
-			const iter = prepared.iterator();
-			const result: typeof users.$inferSelect[] = [];
-
-			for await (const row of iter) {
-				result.push(row);
-			}
-
-			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		});
-
-		test('insert undefined', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.insert(users).values({ name: undefined });
-			})()).resolves.not.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('update undefined', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const users = mysqlTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.update(users).set({ name: undefined });
-			})()).rejects.toThrowError();
-
-			await expect((async () => {
-				await db.update(users).set({ id: 1, name: undefined });
-			})()).resolves.not.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('utc config for datetime', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-			await db.execute(
-				sql`
-					create table \`datestable\` (
-					    \`datetime_utc\` datetime(3),
-					    \`datetime\` datetime(3),
-					    \`datetime_as_string\` datetime
-					)
-				`,
-			);
-			const datesTable = mysqlTable('datestable', {
-				datetimeUTC: datetime('datetime_utc', { fsp: 3, mode: 'date' }),
-				datetime: datetime('datetime', { fsp: 3 }),
-				datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
-			});
-
-			const dateObj = new Date('2022-11-11');
-			const dateUtc = new Date('2022-11-11T12:12:12.122Z');
-
-			await db.insert(datesTable).values({
-				datetimeUTC: dateUtc,
-				datetime: dateObj,
-				datetimeAsString: '2022-11-11 12:12:12',
-			});
-
-			const res = await db.select().from(datesTable);
-
-			const [rawSelect] = await db.execute(sql`select \`datetime_utc\` from \`datestable\``);
-			const selectedRow = (rawSelect as unknown as [{ datetime_utc: string }])[0];
-
-			expect(selectedRow.datetime_utc).toBe('2022-11-11 12:12:12.122');
-			expect(new Date(selectedRow.datetime_utc.replace(' ', 'T') + 'Z')).toEqual(dateUtc);
-
-			expect(res[0]?.datetime).toBeInstanceOf(Date);
-			expect(res[0]?.datetimeUTC).toBeInstanceOf(Date);
-			expect(typeof res[0]?.datetimeAsString).toBe('string');
-
-			expect(res).toEqual([{
-				datetimeUTC: dateUtc,
-				datetime: new Date('2022-11-11'),
-				datetimeAsString: '2022-11-11 12:12:12',
-			}]);
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-		});
-
-		test('set operations (union) from query builder with subquery', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-			const sq = db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table).as('sq');
-
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).union(
-					db.select().from(sq),
-				).limit(8);
-
-			expect(result).toHaveLength(8);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Jane' },
-				{ id: 3, name: 'Jack' },
-				{ id: 4, name: 'Peter' },
-				{ id: 5, name: 'Ben' },
-			]);
-
-			// union should throw if selected fields are not in the same order
-			await expect((async () => {
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).union(
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(users2Table),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await union(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'John' },
-			]);
-
-			await expect((async () => {
-				union(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).limit(2).unionAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).limit(2),
-				).orderBy(asc(sql`id`)).limit(3);
-
-			expect(result).toHaveLength(3);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).limit(2).unionAll(
-						db
-							.select({ name: citiesTable.name, id: citiesTable.id })
-							.from(citiesTable).limit(2),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await unionAll(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).limit(1);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				unionAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(1);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).intersect(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ name: citiesTable.name, id: citiesTable.id })
-					.from(citiesTable).intersect(
-						db
-							.select({ id: citiesTable.id, name: citiesTable.name })
-							.from(citiesTable).where(gt(citiesTable.id, 1)),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await intersect(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).limit(1);
-
-			expect(result).toHaveLength(0);
-
-			expect(result).toEqual([]);
-
-			await expect((async () => {
-				intersect(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(1);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect all) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).limit(2).intersectAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).limit(2),
-				).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).limit(2).intersectAll(
-						db
-							.select({ name: citiesTable.name, id: citiesTable.id })
-							.from(citiesTable).limit(2),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect all) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await intersectAll(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
-
-			await expect((async () => {
-				intersectAll(
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).except(
-					db
-						.select()
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-		});
-
-		test('set operations (except) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await except(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable),
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).limit(3);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				except(
-					db
-						.select({ name: citiesTable.name, id: citiesTable.id })
-						.from(citiesTable),
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(3);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except all) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).exceptAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-				).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select()
-					.from(citiesTable).exceptAll(
-						db
-							.select({ name: citiesTable.name, id: citiesTable.id })
-							.from(citiesTable).where(eq(citiesTable.id, 1)),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except all) as function', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await exceptAll(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(gt(users2Table.id, 7)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).limit(6).orderBy(asc(sql.identifier('id')));
-
-			expect(result).toHaveLength(6);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'Jane' },
-				{ id: 3, name: 'Jack' },
-				{ id: 4, name: 'Peter' },
-				{ id: 5, name: 'Ben' },
-				{ id: 6, name: 'Jill' },
-				{ id: 7, name: 'Mary' },
-			]);
-
-			await expect((async () => {
-				exceptAll(
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(gt(users2Table.id, 7)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(6);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (mixed) from query builder', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).except(
-					({ unionAll }) =>
-						unionAll(
-							db
-								.select()
-								.from(citiesTable).where(gt(citiesTable.id, 1)),
-							db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-						).orderBy(asc(citiesTable.id)).limit(1).offset(1),
-				);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select()
-					.from(citiesTable).except(
-						({ unionAll }) =>
-							unionAll(
-								db
-									.select({ name: citiesTable.name, id: citiesTable.id })
-									.from(citiesTable).where(gt(citiesTable.id, 1)),
-								db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-							),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (mixed all) as function with subquery', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await setupSetOperationTest(db);
-
-			const sq = except(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(gte(users2Table.id, 5)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 7)),
-			).orderBy(asc(sql.identifier('id'))).as('sq');
-
-			const result = await union(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db.select().from(sq).limit(1),
-				db
-					.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-			);
-
-			expect(result).toHaveLength(4);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-				{ id: 5, name: 'Ben' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				union(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					except(
-						db
-							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table).where(gte(users2Table.id, 5)),
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(users2Table).where(eq(users2Table.id, 7)),
-					).limit(1),
-					db
-						.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('aggregate function: count', async (ctx) => {
-			const { db } = ctx.mysql;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: count() }).from(table);
-			const result2 = await db.select({ value: count(table.a) }).from(table);
-			const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
-
-			expect(result1[0]?.value).toBe(7);
-			expect(result2[0]?.value).toBe(5);
-			expect(result3[0]?.value).toBe(6);
-		});
-
-		test('aggregate function: avg', async (ctx) => {
-			const { db } = ctx.mysql;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: avg(table.b) }).from(table);
-			const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('33.3333');
-			expect(result2[0]?.value).toBe(null);
-			expect(result3[0]?.value).toBe('42.5000');
-		});
-
-		test('aggregate function: sum', async (ctx) => {
-			const { db } = ctx.mysql;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: sum(table.b) }).from(table);
-			const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('200');
-			expect(result2[0]?.value).toBe(null);
-			expect(result3[0]?.value).toBe('170');
-		});
-
-		test('aggregate function: max', async (ctx) => {
-			const { db } = ctx.mysql;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: max(table.b) }).from(table);
-			const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(90);
-			expect(result2[0]?.value).toBe(null);
-		});
-
-		test('aggregate function: min', async (ctx) => {
-			const { db } = ctx.mysql;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: min(table.b) }).from(table);
-			const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(10);
-			expect(result2[0]?.value).toBe(null);
-		});
-
-		test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial not null primary key,
-					name text not null,
-					update_counter integer default 1 not null,
-					updated_at datetime(3),
-					uppercase_name text,
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate);
-
-			expect(response).toEqual([
-				{ name: 'John', id: 1, updateCounter: 1, uppercaseName: 'JOHN', alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: 1, uppercaseName: 'JANE', alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, uppercaseName: 'JACK', alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, uppercaseName: 'JILL', alwaysNull: null },
-			]);
-			const msDelay = 750;
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial not null primary key,
-					name text not null,
-					update_counter integer default 1 not null,
-					updated_at datetime(3),
-					uppercase_name text,
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John', alwaysNull: 'this will will be null after updating' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-			const initial = await db.select({ updatedAt }).from(usersOnUpdate);
-
-			await db.update(usersOnUpdate).set({ name: 'Angel', uppercaseName: null }).where(eq(usersOnUpdate.id, 1));
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate);
-
-			expect(response).toEqual([
-				{ name: 'Angel', id: 1, updateCounter: 2, uppercaseName: null, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: 1, uppercaseName: 'JANE', alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, uppercaseName: 'JACK', alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, uppercaseName: 'JILL', alwaysNull: null },
-			]);
-			const msDelay = 750;
-
-			expect(initial[0]?.updatedAt?.valueOf()).not.toBe(justDates[0]?.updatedAt?.valueOf());
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		// mySchema tests
-		test('mySchema :: select all fields', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: select sql', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select typed sql', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql<string>`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select distinct', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const usersDistinctTable = mysqlTable('users_distinct', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]);
-			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-		});
-
-		test('mySchema :: insert returning sql', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			const [result, _] = await db.insert(usersMySchemaTable).values({ name: 'John' });
-
-			expect(result.insertId).toBe(1);
-		});
-
-		test('mySchema :: delete returning sql', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
-
-			expect(users[0].affectedRows).toBe(1);
-		});
-
-		test('mySchema :: update with returning partial', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const updatedUsers = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(
-				eq(usersMySchemaTable.name, 'John'),
-			);
-
-			const users = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
-				usersMySchemaTable,
-			)
-				.where(
-					eq(usersMySchemaTable.id, 1),
-				);
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('mySchema :: delete with returning all fields', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('mySchema :: insert + select', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-			await db.insert(usersMySchemaTable).values({ name: 'Jane' });
-			const result2 = await db.select().from(usersMySchemaTable);
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('mySchema :: insert with overridden default values', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John', verified: true });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: insert many', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]);
-			const result = await db.select({
-				id: usersMySchemaTable.id,
-				name: usersMySchemaTable.name,
-				jsonb: usersMySchemaTable.jsonb,
-				verified: usersMySchemaTable.verified,
-			}).from(usersMySchemaTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('mySchema :: select with group by as field', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.name);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('mySchema :: select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`);
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('mySchema :: build query', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const query = db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					`select \`id\`, \`name\` from \`mySchema\`.\`userstest\` group by \`mySchema\`.\`userstest\`.\`id\`, \`mySchema\`.\`userstest\`.\`name\``,
-				params: [],
-			});
-		});
-
-		test('mySchema :: insert with spaces', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
-				usersMySchemaTable,
-			);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('mySchema :: prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const stmt = db.select({
-				id: usersMySchemaTable.id,
-				name: usersMySchemaTable.name,
-			}).from(usersMySchemaTable)
-				.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
-				.prepare();
-			const result = await stmt.execute({ id: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('mySchema :: select from tables with same name from different schema using alias', async (ctx) => {
-			const { db } = ctx.mysql;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.execute(sql`drop table if exists \`userstest\``);
-			await db.execute(
-				sql`
-					create table \`userstest\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`verified\` boolean not null default false,
-					    \`jsonb\` json,
-					    \`created_at\` timestamp not null default now()
-					)
-				`,
-			);
-
-			await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
-			await db.insert(usersTable).values({ id: 11, name: 'Hans' });
-
-			const customerAlias = alias(usersTable, 'customer');
-
-			const result = await db
-				.select().from(usersMySchemaTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersMySchemaTable.id, 10));
-
-			expect(result).toEqual([{
-				userstest: {
-					id: 10,
-					name: 'Ivan',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.userstest.createdAt,
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.customer!.createdAt,
-				},
-			}]);
-		});
-
-		test('insert $returningId: serial as id', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db.insert(usersTable).values({ name: 'John' }).$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				id: number;
-			}[]>();
-
-			expect(result).toStrictEqual([{ id: 1 }]);
-		});
-
-		test('insert $returningId: serial as id, not first column', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const usersTableDefNotFirstColumn = mysqlTable('users2', {
-				name: text('name').notNull(),
-				id: serial('id').primaryKey(),
-			});
-
-			const result = await db.insert(usersTableDefNotFirstColumn).values({ name: 'John' }).$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				id: number;
-			}[]>();
-
-			expect(result).toStrictEqual([{ id: 1 }]);
-		});
-
-		test('insert $returningId: serial as id, batch insert', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const result = await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				id: number;
-			}[]>();
-
-			expect(result).toStrictEqual([{ id: 1 }, { id: 2 }]);
-		});
-
-		test('insert $returningId: $default as primary key', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
-			let iterator = 0;
-
-			const usersTableDefFn = mysqlTable('users_default_fn', {
-				customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
-					const value = uniqueKeys[iterator]!;
-					iterator++;
-					return value;
-				}),
-				name: text('name').notNull(),
-			});
-
-			await setupReturningFunctionsTest(db);
-
-			const result = await db.insert(usersTableDefFn).values([{ name: 'John' }, { name: 'John1' }])
-				//    ^?
-				.$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				customId: string;
-			}[]>();
-
-			expect(result).toStrictEqual([{ customId: 'ao865jf3mcmkfkk8o5ri495z' }, {
-				customId: 'dyqs529eom0iczo2efxzbcut',
-			}]);
-		});
-
-		test('insert $returningId: $default as primary key with value', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
-			let iterator = 0;
-
-			const usersTableDefFn = mysqlTable('users_default_fn', {
-				customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
-					const value = uniqueKeys[iterator]!;
-					iterator++;
-					return value;
-				}),
-				name: text('name').notNull(),
-			});
-
-			await setupReturningFunctionsTest(db);
-
-			const result = await db.insert(usersTableDefFn).values([{ name: 'John', customId: 'test' }, { name: 'John1' }])
-				//    ^?
-				.$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				customId: string;
-			}[]>();
-
-			expect(result).toStrictEqual([{ customId: 'test' }, { customId: 'ao865jf3mcmkfkk8o5ri495z' }]);
-		});
-
-		test('mySchema :: view', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const newYorkers1 = mySchema.view('new_yorkers')
-				.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
-
-			const newYorkers2 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
-
-			const newYorkers3 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesMySchemaTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2MySchemaTable).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		});
-
-		test('$count separate', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.$count(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual(4);
-		});
-
-		test('$count embedded', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual([
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-			]);
-		});
-
-		test('$count separate reuse', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = db.$count(countTestTable);
-
-			const count1 = await count;
-
-			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
-
-			const count2 = await count;
-
-			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
-
-			const count3 = await count;
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count1).toStrictEqual(4);
-			expect(count2).toStrictEqual(5);
-			expect(count3).toStrictEqual(6);
-		});
-
-		test('$count embedded reuse', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
-
-			const count1 = await count;
-
-			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
-
-			const count2 = await count;
-
-			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
-
-			const count3 = await count;
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count1).toStrictEqual([
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-			]);
-			expect(count2).toStrictEqual([
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-			]);
-			expect(count3).toStrictEqual([
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-			]);
-		});
-
-		test('$count separate with filters', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual(3);
-		});
-
-		test('$count embedded with filters', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const countTestTable = mysqlTable('count_test', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.select({
-				count: db.$count(countTestTable, gt(countTestTable.id, 1)),
-			}).from(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual([
-				{ count: 3 },
-				{ count: 3 },
-				{ count: 3 },
-				{ count: 3 },
-			]);
-		});
-
-		test('limit 0', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(0);
-
-			expect(users).toEqual([]);
-		});
-
-		test('limit -1', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(-1);
-
-			expect(users.length).toBeGreaterThan(0);
-		});
-
-		test('define constraints as array', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const table = mysqlTable('name', {
-				id: int(),
-			}, (t) => [
-				index('name').on(t.id),
-				primaryKey({ columns: [t.id], name: 'custom' }),
-			]);
-
-			const { indexes, primaryKeys } = getTableConfig(table);
-
-			expect(indexes.length).toBe(1);
-			expect(primaryKeys.length).toBe(1);
-		});
-
-		test('define constraints as array inside third param', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			const table = mysqlTable('name', {
-				id: int(),
-			}, (t) => [
-				[index('name').on(t.id), primaryKey({ columns: [t.id], name: 'custom' })],
-			]);
-
-			const { indexes, primaryKeys } = getTableConfig(table);
-
-			expect(indexes.length).toBe(1);
-			expect(primaryKeys.length).toBe(1);
-		});
-
-		test('update with limit and order by', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([
-				{ name: 'Barry', verified: false },
-				{ name: 'Alan', verified: false },
-				{ name: 'Carl', verified: false },
-			]);
-
-			await db.update(usersTable).set({ verified: true }).limit(2).orderBy(asc(usersTable.name));
-
-			const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
-				asc(usersTable.name),
-			);
-			expect(result).toStrictEqual([
-				{ name: 'Alan', verified: true },
-				{ name: 'Barry', verified: true },
-				{ name: 'Carl', verified: false },
-			]);
-		});
-
-		test('delete with limit and order by', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.insert(usersTable).values([
-				{ name: 'Barry', verified: false },
-				{ name: 'Alan', verified: false },
-				{ name: 'Carl', verified: false },
-			]);
-
-			await db.delete(usersTable).where(eq(usersTable.verified, false)).limit(1).orderBy(asc(usersTable.name));
-
-			const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
-				asc(usersTable.name),
-			);
-			expect(result).toStrictEqual([
-				{ name: 'Barry', verified: false },
-				{ name: 'Carl', verified: false },
-			]);
-		});
-
-		test('Object keys as column names', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			// Tests the following:
-			// Column with required config
-			// Column with optional config without providing a value
-			// Column with optional config providing a value
-			// Column without config
-			const users = mysqlTable('users', {
-				id: bigint({ mode: 'number' }).autoincrement().primaryKey(),
-				createdAt: timestamp(),
-				updatedAt: timestamp({ fsp: 3 }),
-				admin: boolean(),
-			});
-
-			await db.execute(sql`drop table if exists users`);
-			await db.execute(
-				sql`
-					create table users (
-						\`id\` bigint auto_increment primary key,
-						\`createdAt\` timestamp,
-						\`updatedAt\` timestamp(3),
-						\`admin\` boolean
-					)
-				`,
-			);
-
-			await db.insert(users).values([
-				{ createdAt: sql`now() - interval 30 day`, updatedAt: sql`now() - interval 1 day`, admin: true },
-				{ createdAt: sql`now() - interval 1 day`, updatedAt: sql`now() - interval 30 day`, admin: true },
-				{ createdAt: sql`now() - interval 1 day`, updatedAt: sql`now() - interval 1 day`, admin: false },
-			]);
-			const result = await db
-				.select({ id: users.id, admin: users.admin })
-				.from(users)
-				.where(
-					and(
-						gt(users.createdAt, sql`now() - interval 7 day`),
-						gt(users.updatedAt, sql`now() - interval 7 day`),
-					),
-				);
-
-			expect(result).toEqual([
-				{ id: 3, admin: false },
-			]);
-
-			await db.execute(sql`drop table users`);
-		});
-
-		test('cross join', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-
-			await db
-				.insert(citiesTable)
-				.values([
-					{ name: 'Seattle' },
-					{ name: 'New York City' },
-				]);
-
-			const result = await db
-				.select({
-					user: usersTable.name,
-					city: citiesTable.name,
-				})
-				.from(usersTable)
-				.crossJoin(citiesTable)
-				.orderBy(usersTable.name, citiesTable.name);
-
-			expect(result).toStrictEqual([
-				{ city: 'New York City', user: 'Jane' },
-				{ city: 'Seattle', user: 'Jane' },
-				{ city: 'New York City', user: 'John' },
-				{ city: 'Seattle', user: 'John' },
-			]);
-		});
-
-		test('left join (lateral)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.leftJoinLateral(sq, sql`true`);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-				{ cityId: 2, cityName: 'London', userId: null, userName: null },
-			]);
-		});
-
-		test('inner join (lateral)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.innerJoinLateral(sq, sql`true`);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-			]);
-		});
-
-		test('cross join (lateral)', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }, { id: 3, name: 'Berlin' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }, {
-				name: 'Patrick',
-				cityId: 2,
-			}]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(not(like(citiesTable.name, 'L%')))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.crossJoinLateral(sq)
-				.orderBy(citiesTable.id, sq.userId);
-
-			expect(res).toStrictEqual([
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 1,
-					userName: 'John',
-				},
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 2,
-					userName: 'Jane',
-				},
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 3,
-					userName: 'Patrick',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 1,
-					userName: 'John',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 2,
-					userName: 'Jane',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 3,
-					userName: 'Patrick',
-				},
-			]);
-		});
-
-		test('all types', async (ctx) => {
-			const { db } = ctx.mysql;
-
-			await db.execute(sql`
-				CREATE TABLE \`all_types\` (
-						\`serial\` serial AUTO_INCREMENT,
-						\`bigint53\` bigint,
-						\`bigint64\` bigint,
-						\`binary\` binary,
-						\`boolean\` boolean,
-						\`char\` char,
-						\`date\` date,
-						\`date_str\` date,
-						\`datetime\` datetime,
-						\`datetime_str\` datetime,
-						\`decimal\` decimal,
-						\`decimal_num\` decimal(30),
-						\`decimal_big\` decimal(30),
-						\`double\` double,
-						\`float\` float,
-						\`int\` int,
-						\`json\` json,
-						\`med_int\` mediumint,
-						\`small_int\` smallint,
-						\`real\` real,
-						\`text\` text,
-						\`time\` time,
-						\`timestamp\` timestamp,
-						\`timestamp_str\` timestamp,
-						\`tiny_int\` tinyint,
-						\`varbin\` varbinary(16),
-						\`varchar\` varchar(255),
-						\`year\` year,
-						\`enum\` enum('enV1','enV2')
-					);
-			`);
-
-			await db.insert(allTypesTable).values({
-				serial: 1,
-				bigint53: 9007199254740991,
-				bigint64: 5044565289845416380n,
-				binary: '1',
-				boolean: true,
-				char: 'c',
-				date: new Date(1741743161623),
-				dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				datetime: new Date(1741743161623),
-				datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				decimal: '47521',
-				decimalNum: 9007199254740991,
-				decimalBig: 5044565289845416380n,
-				double: 15.35325689124218,
-				enum: 'enV1',
-				float: 1.048596,
-				real: 1.048596,
-				text: 'C4-',
-				int: 621,
-				json: {
-					str: 'strval',
-					arr: ['str', 10],
-				},
-				medInt: 560,
-				smallInt: 14,
-				time: '04:13:22',
-				timestamp: new Date(1741743161623),
-				timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				tinyInt: 7,
-				varbin: '1010110101001101',
-				varchar: 'VCHAR',
-				year: 2025,
-			});
-
-			const rawRes = await db.select().from(allTypesTable);
-
-			type ExpectedType = {
-				serial: number;
-				bigint53: number | null;
-				bigint64: bigint | null;
-				binary: string | null;
-				boolean: boolean | null;
-				char: string | null;
-				date: Date | null;
-				dateStr: string | null;
-				datetime: Date | null;
-				datetimeStr: string | null;
-				decimal: string | null;
-				decimalNum: number | null;
-				decimalBig: bigint | null;
-				double: number | null;
-				float: number | null;
-				int: number | null;
-				json: unknown;
-				medInt: number | null;
-				smallInt: number | null;
-				real: number | null;
-				text: string | null;
-				time: string | null;
-				timestamp: Date | null;
-				timestampStr: string | null;
-				tinyInt: number | null;
-				varbin: string | null;
-				varchar: string | null;
-				year: number | null;
-				enum: 'enV1' | 'enV2' | null;
-			}[];
-
-			const expectedRes: ExpectedType = [
-				{
-					serial: 1,
-					bigint53: 9007199254740991,
-					bigint64: 5044565289845416380n,
-					binary: '1',
-					boolean: true,
-					char: 'c',
-					date: new Date('2025-03-12T00:00:00.000Z'),
-					dateStr: '2025-03-12',
-					datetime: new Date('2025-03-12T01:32:42.000Z'),
-					datetimeStr: '2025-03-12 01:32:41',
-					decimal: '47521',
-					decimalNum: 9007199254740991,
-					decimalBig: 5044565289845416380n,
-					double: 15.35325689124218,
-					float: 1.0486,
-					int: 621,
-					json: { arr: ['str', 10], str: 'strval' },
-					medInt: 560,
-					smallInt: 14,
-					real: 1.048596,
-					text: 'C4-',
-					time: '04:13:22',
-					timestamp: new Date('2025-03-12T01:32:42.000Z'),
-					timestampStr: '2025-03-12 01:32:41',
-					tinyInt: 7,
-					varbin: '1010110101001101',
-					varchar: 'VCHAR',
-					year: 2025,
-					enum: 'enV1',
-				},
-			];
-
-			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
-			expect(rawRes).toStrictEqual(expectedRes);
-		});
-	});
-
-	test('insert into ... select', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const notifications = mysqlTable('notifications', {
-			id: serial('id').primaryKey(),
-			sentAt: timestamp('sent_at').notNull().defaultNow(),
-			message: text('message').notNull(),
-		});
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		});
-		const userNotications = mysqlTable('user_notifications', {
-			userId: int('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
-			notificationId: int('notification_id').notNull().references(() => notifications.id, { onDelete: 'cascade' }),
-		}, (t) => ({
-			pk: primaryKey({ columns: [t.userId, t.notificationId] }),
-		}));
-
-		await db.execute(sql`drop table if exists ${notifications}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`drop table if exists ${userNotications}`);
-		await db.execute(sql`
-			create table ${notifications} (
-				\`id\` serial primary key,
-				\`sent_at\` timestamp not null default now(),
-				\`message\` text not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${userNotications} (
-				\`user_id\` int references users(id) on delete cascade,
-				\`notification_id\` int references notifications(id) on delete cascade,
-				primary key (user_id, notification_id)
-			)
-		`);
-
-		await db
-			.insert(notifications)
-			.values({ message: 'You are one of the 3 lucky winners!' });
-		const newNotification = await db
-			.select({ id: notifications.id })
-			.from(notifications)
-			.then((result) => result[0]);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await db
-			.insert(userNotications)
-			.select(
-				db
-					.select({
-						userId: users.id,
-						notificationId: sql`(${newNotification!.id})`.as('notification_id'),
-					})
-					.from(users)
-					.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
-					.orderBy(asc(users.id)),
-			);
-		const sentNotifications = await db.select().from(userNotications);
-
-		expect(sentNotifications).toStrictEqual([
-			{ userId: 1, notificationId: newNotification!.id },
-			{ userId: 3, notificationId: newNotification!.id },
-			{ userId: 5, notificationId: newNotification!.id },
-		]);
-	});
-
-	test('insert into ... select with keys in different order', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users1 = mysqlTable('users1', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		});
-		const users2 = mysqlTable('users2', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		});
-
-		await db.execute(sql`drop table if exists ${users1}`);
-		await db.execute(sql`drop table if exists ${users2}`);
-		await db.execute(sql`
-			create table ${users1} (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${users2} (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`);
-
-		expect(
-			() =>
-				db
-					.insert(users1)
-					.select(
-						db
-							.select({
-								name: users2.name,
-								id: users2.id,
-							})
-							.from(users2),
-					),
-		).toThrowError();
-	});
-
-	test('MySqlTable :: select with `use index` hint', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		}, () => [usersTableNameIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		const result = await db.select()
-			.from(users, {
-				useIndex: [usersTableNameIndex],
-			})
-			.where(eq(users.name, 'David'));
-
-		expect(result).toHaveLength(1);
-		expect(result).toEqual([{ id: 4, name: 'David' }]);
-	});
-
-	test('MySqlTable :: select with `use index` hint on 1 index', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		}, () => [usersTableNameIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-
-		const query = db.select()
-			.from(users, {
-				useIndex: usersTableNameIndex,
-			})
-			.where(eq(users.name, 'David'))
-			.toSQL();
-
-		expect(query.sql).to.include('USE INDEX (users_name_index)');
-	});
-
-	test('MySqlTable :: select with `use index` hint on multiple indexes', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-			age: int('age').notNull(),
-		}, () => [usersTableNameIndex, usersTableAgeIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-		const usersTableAgeIndex = index('users_age_index').on(users.age);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null,
-				\`age\` int not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-		await db.execute(sql`create index users_age_index ON users(age)`);
-
-		const query = db.select()
-			.from(users, {
-				useIndex: [usersTableNameIndex, usersTableAgeIndex],
-			})
-			.where(eq(users.name, 'David'))
-			.toSQL();
-
-		expect(query.sql).to.include('USE INDEX (users_name_index, users_age_index)');
-	});
-
-	test('MySqlTable :: select with `use index` hint on not existed index', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		}, () => [usersTableNameIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await expect((async () => {
-			return await db.select()
-				.from(users, {
-					useIndex: ['some_other_index'],
-				})
-				.where(eq(users.name, 'David'));
-		})()).rejects.toThrowError();
-	});
-
-	test('MySqlTable :: select with `use index` + `force index` incompatible hints', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-			age: int('age').notNull(),
-		}, () => [usersTableNameIndex, usersTableAgeIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-		const usersTableAgeIndex = index('users_age_index').on(users.age);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null,
-				\`age\` int not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-		await db.execute(sql`create index users_age_index ON users(age)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice', age: 18 },
-			{ name: 'Bob', age: 19 },
-			{ name: 'Charlie', age: 20 },
-			{ name: 'David', age: 21 },
-			{ name: 'Eve', age: 22 },
-		]);
-
-		await expect((async () => {
-			return await db.select()
-				.from(users, {
-					useIndex: [usersTableNameIndex],
-					forceIndex: [usersTableAgeIndex],
-				})
-				.where(eq(users.name, 'David'));
-		})()).rejects.toThrowError();
-	});
-
-	test('MySqlTable :: select with join `use index` hint', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await db.insert(posts).values([
-			{ text: 'Alice post', userId: 1 },
-			{ text: 'Bob post', userId: 2 },
-			{ text: 'Charlie post', userId: 3 },
-			{ text: 'David post', userId: 4 },
-			{ text: 'Eve post', userId: 5 },
-		]);
-
-		const result = await db.select({
-			userId: users.id,
-			name: users.name,
-			postId: posts.id,
-			text: posts.text,
-		})
-			.from(users)
-			.leftJoin(posts, eq(users.id, posts.userId), {
-				useIndex: [postsTableUserIdIndex],
-			})
-			.where(and(
-				eq(users.name, 'David'),
-				eq(posts.text, 'David post'),
-			));
-
-		expect(result).toHaveLength(1);
-		expect(result).toEqual([{ userId: 4, name: 'David', postId: 4, text: 'David post' }]);
-	});
-
-	test('MySqlTable :: select with join `use index` hint on 1 index', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		const query = db.select({
-			userId: users.id,
-			name: users.name,
-			postId: posts.id,
-			text: posts.text,
-		})
-			.from(users)
-			.leftJoin(posts, eq(users.id, posts.userId), {
-				useIndex: postsTableUserIdIndex,
-			})
-			.where(and(
-				eq(users.name, 'David'),
-				eq(posts.text, 'David post'),
-			)).toSQL();
-
-		expect(query.sql).to.include('USE INDEX (posts_user_id_index)');
-	});
-
-	test('MySqlTable :: select with cross join `use index` hint', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		await db.insert(users).values([
-			{ id: 1, name: 'Alice' },
-			{ id: 2, name: 'Bob' },
-		]);
-
-		await db.insert(posts).values([
-			{ id: 1, text: 'Alice post', userId: 1 },
-			{ id: 2, text: 'Bob post', userId: 2 },
-		]);
-
-		const result = await db.select()
-			.from(users)
-			.crossJoin(posts, {
-				useIndex: [postsTableUserIdIndex],
-			})
-			.orderBy(users.id, posts.id);
-
-		expect(result).toStrictEqual([{
-			users: { id: 1, name: 'Alice' },
-			posts: { id: 1, text: 'Alice post', userId: 1 },
-		}, {
-			users: { id: 1, name: 'Alice' },
-			posts: { id: 2, text: 'Bob post', userId: 2 },
-		}, {
-			users: { id: 2, name: 'Bob' },
-			posts: { id: 1, text: 'Alice post', userId: 1 },
-		}, {
-			users: { id: 2, name: 'Bob' },
-			posts: { id: 2, text: 'Bob post', userId: 2 },
-		}]);
-	});
-
-	test('MySqlTable :: select with cross join `use index` hint on 1 index', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		const query = db.select({
-			userId: users.id,
-			name: users.name,
-			postId: posts.id,
-			text: posts.text,
-		})
-			.from(users)
-			.crossJoin(posts, {
-				useIndex: postsTableUserIdIndex,
-			})
-			.where(and(
-				eq(users.name, 'David'),
-				eq(posts.text, 'David post'),
-			)).toSQL();
-
-		expect(query.sql).to.include('USE INDEX (posts_user_id_index)');
-	});
-
-	test('MySqlTable :: select with join `use index` hint on multiple indexes', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex, postsTableTextIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-		const postsTableTextIndex = index('posts_text_index').on(posts.text);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-		await db.execute(sql`create index posts_text_index ON posts(text)`);
-
-		const query = db.select({
-			userId: users.id,
-			name: users.name,
-			postId: posts.id,
-			text: posts.text,
-		})
-			.from(users)
-			.leftJoin(posts, eq(users.id, posts.userId), {
-				useIndex: [postsTableUserIdIndex, postsTableTextIndex],
-			})
-			.where(and(
-				eq(users.name, 'David'),
-				eq(posts.text, 'David post'),
-			)).toSQL();
-
-		expect(query.sql).to.include('USE INDEX (posts_user_id_index, posts_text_index)');
-	});
-
-	test('MySqlTable :: select with join `use index` hint on not existed index', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await db.insert(posts).values([
-			{ text: 'Alice post', userId: 1 },
-			{ text: 'Bob post', userId: 2 },
-			{ text: 'Charlie post', userId: 3 },
-			{ text: 'David post', userId: 4 },
-			{ text: 'Eve post', userId: 5 },
-		]);
-
-		await expect((async () => {
-			return await db.select({
-				userId: users.id,
-				name: users.name,
-				postId: posts.id,
-				text: posts.text,
-			})
-				.from(users)
-				.leftJoin(posts, eq(users.id, posts.userId), {
-					useIndex: ['some_other_index'],
-				})
-				.where(and(
-					eq(users.name, 'David'),
-					eq(posts.text, 'David post'),
-				));
-		})()).rejects.toThrowError();
-	});
-
-	test('MySqlTable :: select with join `use index` + `force index` incompatible hints', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex, postsTableTextIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-		const postsTableTextIndex = index('posts_text_index').on(posts.text);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-		await db.execute(sql`create index posts_text_index ON posts(text)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await db.insert(posts).values([
-			{ text: 'Alice post', userId: 1 },
-			{ text: 'Bob post', userId: 2 },
-			{ text: 'Charlie post', userId: 3 },
-			{ text: 'David post', userId: 4 },
-			{ text: 'Eve post', userId: 5 },
-		]);
-
-		await expect((async () => {
-			return await db.select({
-				userId: users.id,
-				name: users.name,
-				postId: posts.id,
-				text: posts.text,
-			})
-				.from(users)
-				.leftJoin(posts, eq(users.id, posts.userId), {
-					useIndex: [postsTableUserIdIndex],
-					forceIndex: [postsTableTextIndex],
-				})
-				.where(and(
-					eq(users.name, 'David'),
-					eq(posts.text, 'David post'),
-				));
-		})()).rejects.toThrowError();
-	});
-
-	test('MySqlTable :: select with Subquery join `use index`', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
-
-		await db.insert(posts).values([
-			{ text: 'Alice post', userId: 1 },
-			{ text: 'Bob post', userId: 2 },
-			{ text: 'Charlie post', userId: 3 },
-			{ text: 'David post', userId: 4 },
-			{ text: 'Eve post', userId: 5 },
-		]);
-
-		const sq = db.select().from(posts, { useIndex: [postsTableUserIdIndex] }).where(eq(posts.userId, 1)).as('sq');
-
-		const result = await db.select({
-			userId: users.id,
-			name: users.name,
-			postId: sq.id,
-			text: sq.text,
-		})
-			.from(users)
-			.leftJoin(sq, eq(users.id, sq.userId))
-			.where(eq(users.name, 'Alice'));
-
-		expect(result).toHaveLength(1);
-		expect(result).toEqual([{ userId: 1, name: 'Alice', postId: 1, text: 'Alice post' }]);
-	});
-
-	test('MySqlTable :: select with Subquery join with `use index` in join', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		});
-
-		const posts = mysqlTable('posts', {
-			id: serial('id').primaryKey(),
-			text: varchar('text', { length: 100 }).notNull(),
-			userId: int('user_id').references(() => users.id, { onDelete: 'cascade' }).notNull(),
-		}, () => [postsTableUserIdIndex]);
-		const postsTableUserIdIndex = index('posts_user_id_index').on(posts.userId);
-
-		await db.execute(sql`drop table if exists ${posts}`);
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`
-			create table ${posts} (
-				\`id\` serial primary key,
-				\`text\` varchar(100) not null,
-				\`user_id\` int not null references users(id) on delete cascade
-			)
-		`);
-		await db.execute(sql`create index posts_user_id_index ON posts(user_id)`);
-
-		const sq = db.select().from(posts).where(eq(posts.userId, 1)).as('sq');
-
-		const query = db.select({
-			userId: users.id,
-			name: users.name,
-			postId: sq.id,
-			text: sq.text,
-		})
-			.from(users)
-			// @ts-expect-error
-			.leftJoin(sq, eq(users.id, sq.userId, { useIndex: [postsTableUserIdIndex] }))
-			.where(eq(users.name, 'Alice'))
-			.toSQL();
-
-		expect(query.sql).not.include('USE INDEX');
-	});
-
-	test('View :: select with `use index` hint', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		}, () => [usersTableNameIndex]);
-
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-
-		const usersView = mysqlView('users_view').as((qb) => qb.select().from(users));
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-		await db.execute(sql`create view ${usersView} as select * from ${users}`);
-
-		// @ts-expect-error
-		const query = db.select().from(usersView, {
-			useIndex: [usersTableNameIndex],
-		}).toSQL();
-
-		expect(query.sql).not.include('USE INDEX');
-
-		await db.execute(sql`drop view ${usersView}`);
-	});
-
-	test('Subquery :: select with `use index` hint', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: varchar('name', { length: 100 }).notNull(),
-		}, () => [usersTableNameIndex]);
-		const usersTableNameIndex = index('users_name_index').on(users.name);
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`
-			create table ${users} (
-				\`id\` serial primary key,
-				\`name\` varchar(100) not null
-			)
-		`);
-		await db.execute(sql`create index users_name_index ON users(name)`);
-
-		const sq = db.select().from(users).as('sq');
-
-		// @ts-expect-error
-		const query = db.select().from(sq, {
-			useIndex: [usersTableNameIndex],
-		}).toSQL();
-
-		expect(query.sql).not.include('USE INDEX');
-	});
-
-	test('sql operator as cte', async (ctx) => {
-		const { db } = ctx.mysql;
-
-		const users = mysqlTable('users', {
-			id: serial('id').primaryKey(),
-			name: text('name').notNull(),
-		});
-
-		await db.execute(sql`drop table if exists ${users}`);
-		await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
-		await db.insert(users).values([
-			{ name: 'John' },
-			{ name: 'Jane' },
-		]);
-
-		const sq1 = db.$with('sq', {
-			userId: users.id,
-			data: {
-				name: users.name,
-			},
-		}).as(sql`select * from ${users} where ${users.name} = 'John'`);
-		const result1 = await db.with(sq1).select().from(sq1);
-
-		const sq2 = db.$with('sq', {
-			userId: users.id,
-			data: {
-				name: users.name,
-			},
-		}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
-		const result2 = await db.with(sq2).select().from(sq1);
-
-		expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
-		expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
-	});
+import type { Test } from './instrumentation';
+import { tests as tests1 } from './mysql-common-1';
+import { tests as tests2 } from './mysql-common-2';
+import { tests as tests3 } from './mysql-common-3';
+import { tests as tests4 } from './mysql-common-4';
+import { tests as tests5 } from './mysql-common-5';
+import { tests as tests6 } from './mysql-common-6';
+import { tests as tests7 } from './mysql-common-7';
+import { tests as tests8 } from './mysql-common-8';
+
+export function tests(test: Test, exclude: Set<string> = new Set<string>([])) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.has(task.name)) skip();
+	});
+
+	tests1(test, exclude);
+	tests2(test, exclude);
+	tests3(test, exclude);
+	tests4(test, exclude);
+	tests5(test, exclude);
+	tests6(test, exclude);
+	tests7(test, exclude);
+	tests8(test, exclude);
 }
diff --git a/integration-tests/tests/mysql/mysql-planetscale.test.ts b/integration-tests/tests/mysql/mysql-planetscale.test.ts
deleted file mode 100644
index fc97ea254a..0000000000
--- a/integration-tests/tests/mysql/mysql-planetscale.test.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { Client } from '@planetscale/database';
-import type { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
-import { drizzle } from 'drizzle-orm/planetscale-serverless';
-import { beforeAll, beforeEach } from 'vitest';
-import { skipTests } from '~/common';
-import { tests } from './mysql-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './mysql-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: PlanetScaleDatabase;
-let dbGlobalCached: PlanetScaleDatabase;
-let cachedDb: PlanetScaleDatabase;
-
-beforeAll(async () => {
-	const client = new Client({ url: process.env['PLANETSCALE_CONNECTION_STRING']! });
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-beforeEach((ctx) => {
-	ctx.mysql = {
-		db,
-	};
-	ctx.cachedMySQL = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-skipTests([
-	'mySchema :: view',
-	'mySchema :: select from tables with same name from different schema using alias',
-	'mySchema :: prepared statement with placeholder in .where',
-	'mySchema :: insert with spaces',
-	'mySchema :: select with group by as column + sql',
-	'mySchema :: select with group by as field',
-	'mySchema :: insert many',
-	'mySchema :: insert with overridden default values',
-	'mySchema :: insert + select',
-	'mySchema :: delete with returning all fields',
-	'mySchema :: update with returning partial',
-	'mySchema :: delete returning sql',
-	'mySchema :: insert returning sql',
-	'mySchema :: select typed sql',
-	'mySchema :: select sql',
-	'mySchema :: select all fields',
-	'test $onUpdateFn and $onUpdate works updating',
-	'test $onUpdateFn and $onUpdate works as $default',
-	'set operations (mixed all) as function with subquery',
-	'set operations (mixed) from query builder',
-	'set operations (except all) as function',
-	'set operations (except all) from query builder',
-	'set operations (except) as function',
-	'set operations (except) from query builder',
-	'set operations (intersect all) as function',
-	'set operations (intersect all) from query builder',
-	'set operations (intersect) as function',
-	'set operations (intersect) from query builder',
-	'select iterator w/ prepared statement',
-	'select iterator',
-	'subquery with view',
-	'join on aliased sql from with clause',
-	'with ... delete',
-	'with ... update',
-	'with ... select',
-
-	// to redefine in this file
-	'utc config for datetime',
-	'transaction',
-	'transaction with options (set isolationLevel)',
-	'having',
-	'select count()',
-	'insert via db.execute w/ query builder',
-	'insert via db.execute + select via db.execute',
-	'insert many with returning',
-	'delete with returning partial',
-	'delete with returning all fields',
-	'update with returning partial',
-	'update with returning all fields',
-	'update returning sql',
-	'delete returning sql',
-	'insert returning sql',
-]);
-
-tests('planetscale');
-cacheTests();
diff --git a/integration-tests/tests/mysql/mysql-prefixed.test.ts b/integration-tests/tests/mysql/mysql-prefixed.test.ts
deleted file mode 100644
index ac2c6755b6..0000000000
--- a/integration-tests/tests/mysql/mysql-prefixed.test.ts
+++ /dev/null
@@ -1,1598 +0,0 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
-import type { Equal } from 'drizzle-orm';
-import { asc, eq, getTableName, gt, inArray, Name, sql, TransactionRollbackError } from 'drizzle-orm';
-import {
-	alias,
-	boolean,
-	date,
-	datetime,
-	getViewConfig,
-	int,
-	json,
-	mysqlEnum,
-	mysqlTable as mysqlTableRaw,
-	mysqlTableCreator,
-	mysqlView,
-	serial,
-	text,
-	time,
-	timestamp,
-	uniqueIndex,
-	year,
-} from 'drizzle-orm/mysql-core';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
-import { migrate } from 'drizzle-orm/mysql2/migrator';
-import * as mysql from 'mysql2/promise';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { Expect, toLocalDate } from '~/utils';
-import { createDockerDB } from './mysql-common';
-
-const ENABLE_LOGGING = false;
-
-let db: MySql2Database;
-let client: mysql.Connection;
-let container: Docker.Container | undefined;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['MYSQL_CONNECTION_STRING']) {
-		connectionString = process.env['MYSQL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	client = await retry(async () => {
-		client = await mysql.createConnection(connectionString);
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end();
-	await container?.stop().catch(console.error);
-});
-
-const tablePrefix = 'drizzle_tests_';
-
-const mysqlTable = mysqlTableCreator((name) => `${tablePrefix}${name}`);
-const usersTable = mysqlTable('userstest', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
-});
-
-const users2Table = mysqlTable('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id').references(() => citiesTable.id),
-});
-
-const citiesTable = mysqlTable('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-beforeEach(async () => {
-	await db.execute(sql`drop table if exists ${usersTable}`);
-	await db.execute(sql`drop table if exists ${users2Table}`);
-	await db.execute(sql`drop table if exists ${citiesTable}`);
-
-	await db.execute(
-		sql`
-			create table ${usersTable} (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`verified\` boolean not null default false,
-				\`jsonb\` json,
-				\`created_at\` timestamp not null default now()
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table ${users2Table} (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references ${citiesTable}(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table ${citiesTable} (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-});
-
-test('select all fields', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const result = await db.select().from(usersTable);
-
-	expect(result[0]!.createdAt).toBeInstanceOf(Date);
-	// not timezone based timestamp, thats why it should not work here
-	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
-	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-});
-
-test('select sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db.select({
-		name: sql`upper(${usersTable.name})`,
-	}).from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('select typed sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db.select({
-		name: sql<string>`upper(${usersTable.name})`,
-	}).from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('select distinct', async () => {
-	const usersDistinctTable = mysqlTable('users_distinct', {
-		id: int('id').notNull(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-	await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
-
-	await db.insert(usersDistinctTable).values([
-		{ id: 1, name: 'John' },
-		{ id: 1, name: 'John' },
-		{ id: 2, name: 'John' },
-		{ id: 1, name: 'Jane' },
-	]);
-	const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-		usersDistinctTable.id,
-		usersDistinctTable.name,
-	);
-
-	await db.execute(sql`drop table ${usersDistinctTable}`);
-
-	expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-});
-
-test('insert returning sql', async () => {
-	const [result, _] = await db.insert(usersTable).values({ name: 'John' });
-
-	expect(result.insertId).toBe(1);
-});
-
-test('delete returning sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-	expect(users[0].affectedRows).toBe(1);
-});
-
-test('update returning sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-	expect(users[0].changedRows).toBe(1);
-});
-
-test('update with returning all fields', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-	const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
-
-	expect(updatedUsers[0].changedRows).toBe(1);
-
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	// not timezone based timestamp, thats why it should not work here
-	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
-	expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
-});
-
-test('update with returning partial', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-	const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-		eq(usersTable.id, 1),
-	);
-
-	expect(updatedUsers[0].changedRows).toBe(1);
-
-	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-});
-
-test('delete with returning all fields', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-	expect(deletedUser[0].affectedRows).toBe(1);
-});
-
-test('delete with returning partial', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-	expect(deletedUser[0].affectedRows).toBe(1);
-});
-
-test('insert + select', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const result = await db.select().from(usersTable);
-	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-	await db.insert(usersTable).values({ name: 'Jane' });
-	const result2 = await db.select().from(usersTable);
-	expect(result2).toEqual([
-		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-	]);
-});
-
-test('json insert', async () => {
-	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
-	const result = await db.select({
-		id: usersTable.id,
-		name: usersTable.name,
-		jsonb: usersTable.jsonb,
-	}).from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
-});
-
-test('insert with overridden default values', async () => {
-	await db.insert(usersTable).values({ name: 'John', verified: true });
-	const result = await db.select().from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-});
-
-test('insert many', async () => {
-	await db.insert(usersTable).values([
-		{ name: 'John' },
-		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-		{ name: 'Jane' },
-		{ name: 'Austin', verified: true },
-	]);
-	const result = await db.select({
-		id: usersTable.id,
-		name: usersTable.name,
-		jsonb: usersTable.jsonb,
-		verified: usersTable.verified,
-	}).from(usersTable);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', jsonb: null, verified: false },
-		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-		{ id: 3, name: 'Jane', jsonb: null, verified: false },
-		{ id: 4, name: 'Austin', jsonb: null, verified: true },
-	]);
-});
-
-test('insert many with returning', async () => {
-	const result = await db.insert(usersTable).values([
-		{ name: 'John' },
-		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-		{ name: 'Jane' },
-		{ name: 'Austin', verified: true },
-	]);
-
-	expect(result[0].affectedRows).toBe(4);
-});
-
-test('select with group by as field', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.name);
-
-	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-});
-
-test('select with group by as sql', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(sql`${usersTable.name}`);
-
-	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-});
-
-test('select with group by as sql + column', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(sql`${usersTable.name}`, usersTable.id);
-
-	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-});
-
-test('select with group by as column + sql', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id, sql`${usersTable.name}`);
-
-	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-});
-
-test('select with group by complex query', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db.select({ name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id, sql`${usersTable.name}`)
-		.orderBy(asc(usersTable.name))
-		.limit(1);
-
-	expect(result).toEqual([{ name: 'Jane' }]);
-});
-
-test('build query', async () => {
-	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
-		.groupBy(usersTable.id, usersTable.name)
-		.toSQL();
-
-	expect(query).toEqual({
-		sql: `select \`id\`, \`name\` from \`${getTableName(usersTable)}\` group by \`${
-			getTableName(usersTable)
-		}\`.\`id\`, \`${getTableName(usersTable)}\`.\`name\``,
-		params: [],
-	});
-});
-
-test('build query insert with onDuplicate', async () => {
-	const query = db.insert(usersTable)
-		.values({ name: 'John', jsonb: ['foo', 'bar'] })
-		.onDuplicateKeyUpdate({ set: { name: 'John1' } })
-		.toSQL();
-
-	expect(query).toEqual({
-		sql: `insert into \`${
-			getTableName(usersTable)
-		}\` (\`id\`, \`name\`, \`verified\`, \`jsonb\`, \`created_at\`) values (default, ?, default, ?, default) on duplicate key update \`name\` = ?`,
-		params: ['John', '["foo","bar"]', 'John1'],
-	});
-});
-
-test('insert with onDuplicate', async () => {
-	await db.insert(usersTable)
-		.values({ name: 'John' });
-
-	await db.insert(usersTable)
-		.values({ id: 1, name: 'John' })
-		.onDuplicateKeyUpdate({ set: { name: 'John1' } });
-
-	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-		eq(usersTable.id, 1),
-	);
-
-	expect(res).toEqual([{ id: 1, name: 'John1' }]);
-});
-
-test('insert conflict', async () => {
-	await db.insert(usersTable)
-		.values({ name: 'John' });
-
-	await expect((async () => {
-		db.insert(usersTable).values({ id: 1, name: 'John1' });
-	})()).resolves.not.toThrowError();
-});
-
-test('insert conflict with ignore', async () => {
-	await db.insert(usersTable)
-		.values({ name: 'John' });
-
-	await db.insert(usersTable)
-		.ignore()
-		.values({ id: 1, name: 'John1' });
-
-	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-		eq(usersTable.id, 1),
-	);
-
-	expect(res).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert sql', async () => {
-	await db.insert(usersTable).values({ name: sql`${'John'}` });
-	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('partial join with alias', async () => {
-	const customerAlias = alias(usersTable, 'customer');
-
-	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-	const result = await db
-		.select({
-			user: {
-				id: usersTable.id,
-				name: usersTable.name,
-			},
-			customer: {
-				id: customerAlias.id,
-				name: customerAlias.name,
-			},
-		}).from(usersTable)
-		.leftJoin(customerAlias, eq(customerAlias.id, 11))
-		.where(eq(usersTable.id, 10));
-
-	expect(result).toEqual([{
-		user: { id: 10, name: 'Ivan' },
-		customer: { id: 11, name: 'Hans' },
-	}]);
-});
-
-test('full join with alias', async () => {
-	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
-
-	const users = mysqlTable('users', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-	const customers = alias(users, 'customer');
-
-	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-	const result = await db
-		.select().from(users)
-		.leftJoin(customers, eq(customers.id, 11))
-		.where(eq(users.id, 10));
-
-	expect(result).toEqual([{
-		users: {
-			id: 10,
-			name: 'Ivan',
-		},
-		customer: {
-			id: 11,
-			name: 'Hans',
-		},
-	}]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('select from alias', async () => {
-	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
-
-	const users = mysqlTable('users', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-	const user = alias(users, 'user');
-	const customers = alias(users, 'customer');
-
-	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-	const result = await db
-		.select()
-		.from(user)
-		.leftJoin(customers, eq(customers.id, 11))
-		.where(eq(user.id, 10));
-
-	expect(result).toEqual([{
-		user: {
-			id: 10,
-			name: 'Ivan',
-		},
-		customer: {
-			id: 11,
-			name: 'Hans',
-		},
-	}]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('insert with spaces', async () => {
-	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
-	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-});
-
-test('prepared statement', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const statement = db.select({
-		id: usersTable.id,
-		name: usersTable.name,
-	}).from(usersTable)
-		.prepare();
-	const result = await statement.execute();
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('prepared statement reuse', async () => {
-	const stmt = db.insert(usersTable).values({
-		verified: true,
-		name: sql.placeholder('name'),
-	}).prepare();
-
-	for (let i = 0; i < 10; i++) {
-		await stmt.execute({ name: `John ${i}` });
-	}
-
-	const result = await db.select({
-		id: usersTable.id,
-		name: usersTable.name,
-		verified: usersTable.verified,
-	}).from(usersTable);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John 0', verified: true },
-		{ id: 2, name: 'John 1', verified: true },
-		{ id: 3, name: 'John 2', verified: true },
-		{ id: 4, name: 'John 3', verified: true },
-		{ id: 5, name: 'John 4', verified: true },
-		{ id: 6, name: 'John 5', verified: true },
-		{ id: 7, name: 'John 6', verified: true },
-		{ id: 8, name: 'John 7', verified: true },
-		{ id: 9, name: 'John 8', verified: true },
-		{ id: 10, name: 'John 9', verified: true },
-	]);
-});
-
-test('prepared statement with placeholder in .where', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const stmt = db.select({
-		id: usersTable.id,
-		name: usersTable.name,
-	}).from(usersTable)
-		.where(eq(usersTable.id, sql.placeholder('id')))
-		.prepare();
-	const result = await stmt.execute({ id: 1 });
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('migrator', async () => {
-	const usersMigratorTable = mysqlTableRaw('users12', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		email: text('email').notNull(),
-	}, (table) => {
-		return {
-			name: uniqueIndex('').on(table.name).using('btree'),
-		};
-	});
-
-	await db.execute(sql.raw(`drop table if exists cities_migration`));
-	await db.execute(sql.raw(`drop table if exists users_migration`));
-	await db.execute(sql.raw(`drop table if exists users12`));
-	await db.execute(sql.raw(`drop table if exists __drizzle_migrations`));
-
-	await migrate(db, { migrationsFolder: './drizzle2/mysql' });
-
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-
-	const result = await db.select().from(usersMigratorTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql.raw(`drop table cities_migration`));
-	await db.execute(sql.raw(`drop table users_migration`));
-	await db.execute(sql.raw(`drop table users12`));
-	await db.execute(sql.raw(`drop table __drizzle_migrations`));
-});
-
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
-
-	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
-	expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute(
-		db.insert(usersTable).values({ name: 'John' }),
-	);
-	expect(inserted[0].affectedRows).toBe(1);
-});
-
-test('insert + select all possible dates', async () => {
-	const datesTable = mysqlTable('datestable', {
-		date: date('date'),
-		dateAsString: date('date_as_string', { mode: 'string' }),
-		time: time('time', { fsp: 1 }),
-		datetime: datetime('datetime', { fsp: 2 }),
-		datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
-		year: year('year'),
-	});
-
-	await db.execute(sql`drop table if exists ${datesTable}`);
-	await db.execute(
-		sql`
-			create table ${datesTable} (
-				\`date\` date,
-				\`date_as_string\` date,
-				\`time\` time,
-				\`datetime\` datetime,
-				\`datetime_as_string\` datetime,
-				\`year\` year
-			)
-		`,
-	);
-
-	const d = new Date('2022-11-11');
-
-	await db.insert(datesTable).values({
-		date: d,
-		dateAsString: '2022-11-11',
-		time: '12:12:12',
-		datetime: d,
-		year: 22,
-		datetimeAsString: '2022-11-11 12:12:12',
-	});
-
-	const res = await db.select().from(datesTable);
-
-	expect(res[0]?.date).toBeInstanceOf(Date);
-	expect(res[0]?.datetime).toBeInstanceOf(Date);
-	expect(typeof res[0]?.dateAsString).toBe('string');
-	expect(typeof res[0]?.datetimeAsString).toBe('string');
-
-	expect(res).toEqual([{
-		date: toLocalDate(new Date('2022-11-11')),
-		dateAsString: '2022-11-11',
-		time: '12:12:12',
-		datetime: new Date('2022-11-11'),
-		year: 2022,
-		datetimeAsString: '2022-11-11 12:12:12',
-	}]);
-
-	await db.execute(sql`drop table ${datesTable}`);
-});
-
-test('Mysql enum test case #1', async () => {
-	const tableWithEnums = mysqlTable('enums_test_case', {
-		id: serial('id').primaryKey(),
-		enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
-		enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
-		enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
-	});
-
-	await db.execute(sql`drop table if exists ${tableWithEnums}`);
-
-	await db.execute(sql`
-		create table ${tableWithEnums} (
-			\`id\` serial primary key,
-			\`enum1\` ENUM('a', 'b', 'c') not null,
-			\`enum2\` ENUM('a', 'b', 'c') default 'a',
-			\`enum3\` ENUM('a', 'b', 'c') not null default 'b'
-		)
-	`);
-
-	await db.insert(tableWithEnums).values([
-		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-		{ id: 2, enum1: 'a', enum3: 'c' },
-		{ id: 3, enum1: 'a' },
-	]);
-
-	const res = await db.select().from(tableWithEnums);
-
-	await db.execute(sql`drop table ${tableWithEnums}`);
-
-	expect(res).toEqual([
-		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
-		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
-	]);
-});
-
-test('left join (flat object fields)', async () => {
-	await db.insert(citiesTable)
-		.values([{ name: 'Paris' }, { name: 'London' }]);
-
-	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-	const res = await db.select({
-		userId: users2Table.id,
-		userName: users2Table.name,
-		cityId: citiesTable.id,
-		cityName: citiesTable.name,
-	}).from(users2Table)
-		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-	expect(res).toEqual([
-		{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
-		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
-	]);
-});
-
-test('left join (grouped fields)', async () => {
-	await db.insert(citiesTable)
-		.values([{ name: 'Paris' }, { name: 'London' }]);
-
-	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-	const res = await db.select({
-		id: users2Table.id,
-		user: {
-			name: users2Table.name,
-			nameUpper: sql<string>`upper(${users2Table.name})`,
-		},
-		city: {
-			id: citiesTable.id,
-			name: citiesTable.name,
-			nameUpper: sql<string>`upper(${citiesTable.name})`,
-		},
-	}).from(users2Table)
-		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-	expect(res).toEqual([
-		{
-			id: 1,
-			user: { name: 'John', nameUpper: 'JOHN' },
-			city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
-		},
-		{
-			id: 2,
-			user: { name: 'Jane', nameUpper: 'JANE' },
-			city: null,
-		},
-	]);
-});
-
-test('left join (all fields)', async () => {
-	await db.insert(citiesTable)
-		.values([{ name: 'Paris' }, { name: 'London' }]);
-
-	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-	const res = await db.select().from(users2Table)
-		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-	expect(res).toEqual([
-		{
-			users2: {
-				id: 1,
-				name: 'John',
-				cityId: 1,
-			},
-			cities: {
-				id: 1,
-				name: 'Paris',
-			},
-		},
-		{
-			users2: {
-				id: 2,
-				name: 'Jane',
-				cityId: null,
-			},
-			cities: null,
-		},
-	]);
-});
-
-test('join subquery', async () => {
-	const coursesTable = mysqlTable('courses', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		categoryId: int('category_id').references(() => courseCategoriesTable.id),
-	});
-
-	const courseCategoriesTable = mysqlTable('course_categories', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${coursesTable}`);
-	await db.execute(sql`drop table if exists ${courseCategoriesTable}`);
-
-	await db.execute(
-		sql`
-			create table ${courseCategoriesTable} (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table ${coursesTable} (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`category_id\` int references ${courseCategoriesTable}(\`id\`)
-			)
-		`,
-	);
-
-	await db.insert(courseCategoriesTable).values([
-		{ name: 'Category 1' },
-		{ name: 'Category 2' },
-		{ name: 'Category 3' },
-		{ name: 'Category 4' },
-	]);
-
-	await db.insert(coursesTable).values([
-		{ name: 'Development', categoryId: 2 },
-		{ name: 'IT & Software', categoryId: 3 },
-		{ name: 'Marketing', categoryId: 4 },
-		{ name: 'Design', categoryId: 1 },
-	]);
-
-	const sq2 = db
-		.select({
-			categoryId: courseCategoriesTable.id,
-			category: courseCategoriesTable.name,
-			total: sql<number>`count(${courseCategoriesTable.id})`,
-		})
-		.from(courseCategoriesTable)
-		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
-		.as('sq2');
-
-	const res = await db
-		.select({
-			courseName: coursesTable.name,
-			categoryId: sq2.categoryId,
-		})
-		.from(coursesTable)
-		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
-		.orderBy(coursesTable.name);
-
-	await db.execute(sql`drop table ${coursesTable}`);
-	await db.execute(sql`drop table ${courseCategoriesTable}`);
-
-	expect(res).toEqual([
-		{ courseName: 'Design', categoryId: 1 },
-		{ courseName: 'Development', categoryId: 2 },
-		{ courseName: 'IT & Software', categoryId: 3 },
-		{ courseName: 'Marketing', categoryId: 4 },
-	]);
-});
-
-test('with ... select', async () => {
-	const orders = mysqlTable('orders', {
-		id: serial('id').primaryKey(),
-		region: text('region').notNull(),
-		product: text('product').notNull(),
-		amount: int('amount').notNull(),
-		quantity: int('quantity').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${orders}`);
-	await db.execute(
-		sql`
-			create table ${orders} (
-				\`id\` serial primary key,
-				\`region\` text not null,
-				\`product\` text not null,
-				\`amount\` int not null,
-				\`quantity\` int not null
-			)
-		`,
-	);
-
-	await db.insert(orders).values([
-		{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-		{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-		{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-		{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-		{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-		{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-		{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-		{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-	]);
-
-	const regionalSales = db
-		.$with('regional_sales')
-		.as(
-			db
-				.select({
-					region: orders.region,
-					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-				})
-				.from(orders)
-				.groupBy(orders.region),
-		);
-
-	const topRegions = db
-		.$with('top_regions')
-		.as(
-			db
-				.select({
-					region: regionalSales.region,
-				})
-				.from(regionalSales)
-				.where(
-					gt(
-						regionalSales.totalSales,
-						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-					),
-				),
-		);
-
-	const result = await db
-		.with(regionalSales, topRegions)
-		.select({
-			region: orders.region,
-			product: orders.product,
-			productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
-			productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
-		})
-		.from(orders)
-		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-		.groupBy(orders.region, orders.product)
-		.orderBy(orders.region, orders.product);
-
-	await db.execute(sql`drop table ${orders}`);
-
-	expect(result).toEqual([
-		{
-			region: 'Europe',
-			product: 'A',
-			productUnits: 3,
-			productSales: 30,
-		},
-		{
-			region: 'Europe',
-			product: 'B',
-			productUnits: 5,
-			productSales: 50,
-		},
-		{
-			region: 'US',
-			product: 'A',
-			productUnits: 7,
-			productSales: 70,
-		},
-		{
-			region: 'US',
-			product: 'B',
-			productUnits: 9,
-			productSales: 90,
-		},
-	]);
-});
-
-test('select from subquery sql', async () => {
-	await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
-
-	const sq = db
-		.select({ name: sql<string>`concat(${users2Table.name}, " modified")`.as('name') })
-		.from(users2Table)
-		.as('sq');
-
-	const res = await db.select({ name: sq.name }).from(sq);
-
-	expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
-});
-
-test('select a field without joining its table', () => {
-	expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
-});
-
-test('select all fields from subquery without alias', () => {
-	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
-
-	expect(() => db.select().from(sq).prepare()).toThrowError();
-});
-
-test('select count()', async () => {
-	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
-
-	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
-
-	expect(res).toEqual([{ count: 2 }]);
-});
-
-test('select for ...', () => {
-	{
-		const query = db.select().from(users2Table).for('update').toSQL();
-		expect(query.sql).toMatch(/ for update$/);
-	}
-	{
-		const query = db.select().from(users2Table).for('share', { skipLocked: true }).toSQL();
-		expect(query.sql).toMatch(/ for share skip locked$/);
-	}
-	{
-		const query = db.select().from(users2Table).for('update', { noWait: true }).toSQL();
-		expect(query.sql).toMatch(/ for update nowait$/);
-	}
-});
-
-test('having', async () => {
-	await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
-
-	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
-		name: 'Jack',
-		cityId: 2,
-	}]);
-
-	const result = await db
-		.select({
-			id: citiesTable.id,
-			name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
-			usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
-		})
-		.from(citiesTable)
-		.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
-		.where(({ name }) => sql`length(${name}) >= 3`)
-		.groupBy(citiesTable.id)
-		.having(({ usersCount }) => sql`${usersCount} > 0`)
-		.orderBy(({ name }) => name);
-
-	expect(result).toEqual([
-		{
-			id: 1,
-			name: 'LONDON',
-			usersCount: 2,
-		},
-		{
-			id: 2,
-			name: 'PARIS',
-			usersCount: 1,
-		},
-	]);
-});
-
-test('view', async () => {
-	const newYorkers1 = mysqlView('new_yorkers')
-		.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
-
-	const newYorkers2 = mysqlView('new_yorkers', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		cityId: int('city_id').notNull(),
-	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
-
-	const newYorkers3 = mysqlView('new_yorkers', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		cityId: int('city_id').notNull(),
-	}).existing();
-
-	await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
-
-	await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-	await db.insert(users2Table).values([
-		{ name: 'John', cityId: 1 },
-		{ name: 'Jane', cityId: 1 },
-		{ name: 'Jack', cityId: 2 },
-	]);
-
-	{
-		const result = await db.select().from(newYorkers1);
-		expect(result).toEqual([
-			{ id: 1, name: 'John', cityId: 1 },
-			{ id: 2, name: 'Jane', cityId: 1 },
-		]);
-	}
-
-	{
-		const result = await db.select().from(newYorkers2);
-		expect(result).toEqual([
-			{ id: 1, name: 'John', cityId: 1 },
-			{ id: 2, name: 'Jane', cityId: 1 },
-		]);
-	}
-
-	{
-		const result = await db.select().from(newYorkers3);
-		expect(result).toEqual([
-			{ id: 1, name: 'John', cityId: 1 },
-			{ id: 2, name: 'Jane', cityId: 1 },
-		]);
-	}
-
-	{
-		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-		expect(result).toEqual([
-			{ name: 'John' },
-			{ name: 'Jane' },
-		]);
-	}
-
-	await db.execute(sql`drop view ${newYorkers1}`);
-});
-
-test('select from raw sql', async () => {
-	const result = await db.select({
-		id: sql<number>`id`,
-		name: sql<string>`name`,
-	}).from(sql`(select 1 as id, 'John' as name) as users`);
-
-	Expect<Equal<{ id: number; name: string }[], typeof result>>;
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John' },
-	]);
-});
-
-test('select from raw sql with joins', async () => {
-	const result = await db
-		.select({
-			id: sql<number>`users.id`,
-			name: sql<string>`users.name`,
-			userCity: sql<string>`users.city`,
-			cityName: sql<string>`cities.name`,
-		})
-		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
-
-	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
-	]);
-});
-
-test('join on aliased sql from select', async () => {
-	const result = await db
-		.select({
-			userId: sql<number>`users.id`.as('userId'),
-			name: sql<string>`users.name`,
-			userCity: sql<string>`users.city`,
-			cityId: sql<number>`cities.id`.as('cityId'),
-			cityName: sql<string>`cities.name`,
-		})
-		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
-
-	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
-
-	expect(result).toEqual([
-		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-	]);
-});
-
-test('join on aliased sql from with clause', async () => {
-	const users = db.$with('users').as(
-		db.select({
-			id: sql<number>`id`.as('userId'),
-			name: sql<string>`name`.as('userName'),
-			city: sql<string>`city`.as('city'),
-		}).from(
-			sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
-		),
-	);
-
-	const cities = db.$with('cities').as(
-		db.select({
-			id: sql<number>`id`.as('cityId'),
-			name: sql<string>`name`.as('cityName'),
-		}).from(
-			sql`(select 1 as id, 'Paris' as name) as cities`,
-		),
-	);
-
-	const result = await db
-		.with(users, cities)
-		.select({
-			userId: users.id,
-			name: users.name,
-			userCity: users.city,
-			cityId: cities.id,
-			cityName: cities.name,
-		})
-		.from(users)
-		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
-
-	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
-
-	expect(result).toEqual([
-		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-	]);
-});
-
-test('prefixed table', async () => {
-	const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
-
-	const users = mysqlTable('test_prefixed_table_with_unique_name', {
-		id: int('id').primaryKey(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
-	);
-
-	await db.insert(users).values({ id: 1, name: 'John' });
-
-	const result = await db.select().from(users);
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('orderBy with aliased column', () => {
-	const query = db.select({
-		test: sql`something`.as('test'),
-	}).from(users2Table).orderBy((fields) => fields.test).toSQL();
-
-	expect(query.sql).toBe(`select something as \`test\` from \`${getTableName(users2Table)}\` order by \`test\``);
-});
-
-test('timestamp timezone', async () => {
-	const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
-
-	await db.insert(usersTable).values({ name: 'With default times' });
-	await db.insert(usersTable).values({
-		name: 'Without default times',
-		createdAt: date,
-	});
-	const users = await db.select().from(usersTable);
-
-	// check that the timestamps are set correctly for default times
-	expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
-
-	// check that the timestamps are set correctly for non default times
-	expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
-});
-
-test('transaction', async () => {
-	const users = mysqlTable('users_transactions', {
-		id: serial('id').primaryKey(),
-		balance: int('balance').notNull(),
-	});
-	const products = mysqlTable('products_transactions', {
-		id: serial('id').primaryKey(),
-		price: int('price').notNull(),
-		stock: int('stock').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`drop table if exists ${products}`);
-
-	await db.execute(sql`create table ${users} (id serial not null primary key, balance int not null)`);
-	await db.execute(
-		sql`create table ${products} (id serial not null primary key, price int not null, stock int not null)`,
-	);
-
-	const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
-	const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
-	const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
-	const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
-
-	await db.transaction(async (tx) => {
-		await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
-		await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
-	});
-
-	const result = await db.select().from(users);
-
-	await db.execute(sql`drop table ${users}`);
-	await db.execute(sql`drop table ${products}`);
-
-	expect(result).toEqual([{ id: 1, balance: 90 }]);
-});
-
-test('transaction rollback', async () => {
-	const users = mysqlTable('users_transactions_rollback', {
-		id: serial('id').primaryKey(),
-		balance: int('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, balance int not null)`,
-	);
-
-	await expect((async () => {
-		await db.transaction(async (tx) => {
-			await tx.insert(users).values({ balance: 100 });
-			tx.rollback();
-		});
-	})()).rejects.toThrowError(TransactionRollbackError);
-
-	const result = await db.select().from(users);
-
-	await db.execute(sql`drop table ${users}`);
-
-	expect(result).toEqual([]);
-});
-
-test('nested transaction', async () => {
-	const users = mysqlTable('users_nested_transactions', {
-		id: serial('id').primaryKey(),
-		balance: int('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, balance int not null)`,
-	);
-
-	await db.transaction(async (tx) => {
-		await tx.insert(users).values({ balance: 100 });
-
-		await tx.transaction(async (tx) => {
-			await tx.update(users).set({ balance: 200 });
-		});
-	});
-
-	const result = await db.select().from(users);
-
-	await db.execute(sql`drop table ${users}`);
-
-	expect(result).toEqual([{ id: 1, balance: 200 }]);
-});
-
-test('nested transaction rollback', async () => {
-	const users = mysqlTable('users_nested_transactions_rollback', {
-		id: serial('id').primaryKey(),
-		balance: int('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, balance int not null)`,
-	);
-
-	await db.transaction(async (tx) => {
-		await tx.insert(users).values({ balance: 100 });
-
-		await expect((async () => {
-			await tx.transaction(async (tx) => {
-				await tx.update(users).set({ balance: 200 });
-				tx.rollback();
-			});
-		})()).rejects.toThrowError(TransactionRollbackError);
-	});
-
-	const result = await db.select().from(users);
-
-	await db.execute(sql`drop table ${users}`);
-
-	expect(result).toEqual([{ id: 1, balance: 100 }]);
-});
-
-test('join subquery with join', async () => {
-	const internalStaff = mysqlTable('internal_staff', {
-		userId: int('user_id').notNull(),
-	});
-
-	const customUser = mysqlTable('custom_user', {
-		id: int('id').notNull(),
-	});
-
-	const ticket = mysqlTable('ticket', {
-		staffId: int('staff_id').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${internalStaff}`);
-	await db.execute(sql`drop table if exists ${customUser}`);
-	await db.execute(sql`drop table if exists ${ticket}`);
-
-	await db.execute(sql`create table ${internalStaff} (user_id integer not null)`);
-	await db.execute(sql`create table ${customUser} (id integer not null)`);
-	await db.execute(sql`create table ${ticket} (staff_id integer not null)`);
-
-	await db.insert(internalStaff).values({ userId: 1 });
-	await db.insert(customUser).values({ id: 1 });
-	await db.insert(ticket).values({ staffId: 1 });
-
-	const subq = db
-		.select()
-		.from(internalStaff)
-		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
-		.as('internal_staff');
-
-	const mainQuery = await db
-		.select()
-		.from(ticket)
-		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-	await db.execute(sql`drop table ${internalStaff}`);
-	await db.execute(sql`drop table ${customUser}`);
-	await db.execute(sql`drop table ${ticket}`);
-
-	expect(mainQuery).toEqual([{
-		ticket: { staffId: 1 },
-		internal_staff: {
-			internal_staff: { userId: 1 },
-			custom_user: { id: 1 },
-		},
-	}]);
-});
-
-test('subquery with view', async () => {
-	const users = mysqlTable('users_subquery_view', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		cityId: int('city_id').notNull(),
-	});
-
-	const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`drop view if exists ${newYorkers}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-	);
-	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-	await db.insert(users).values([
-		{ name: 'John', cityId: 1 },
-		{ name: 'Jane', cityId: 2 },
-		{ name: 'Jack', cityId: 1 },
-		{ name: 'Jill', cityId: 2 },
-	]);
-
-	const sq = db.$with('sq').as(db.select().from(newYorkers));
-	const result = await db.with(sq).select().from(sq);
-
-	await db.execute(sql`drop view ${newYorkers}`);
-	await db.execute(sql`drop table ${users}`);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 3, name: 'Jack', cityId: 1 },
-	]);
-});
-
-test('join view as subquery', async () => {
-	const users = mysqlTable('users_join_view', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-		cityId: int('city_id').notNull(),
-	});
-
-	const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`drop view if exists ${newYorkers}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-	);
-	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-	await db.insert(users).values([
-		{ name: 'John', cityId: 1 },
-		{ name: 'Jane', cityId: 2 },
-		{ name: 'Jack', cityId: 1 },
-		{ name: 'Jill', cityId: 2 },
-	]);
-
-	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
-
-	const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
-
-	expect(result).toEqual([
-		{
-			users_join_view: { id: 1, name: 'John', cityId: 1 },
-			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
-		},
-		{
-			users_join_view: { id: 2, name: 'Jane', cityId: 2 },
-			new_yorkers_sq: null,
-		},
-		{
-			users_join_view: { id: 3, name: 'Jack', cityId: 1 },
-			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
-		},
-		{
-			users_join_view: { id: 4, name: 'Jill', cityId: 2 },
-			new_yorkers_sq: null,
-		},
-	]);
-
-	await db.execute(sql`drop view ${newYorkers}`);
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('select iterator', async () => {
-	const users = mysqlTable('users_iterator', {
-		id: serial('id').primaryKey(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-	await db.insert(users).values([{}, {}, {}]);
-
-	const iter = db.select().from(users).iterator();
-
-	const result: typeof users.$inferSelect[] = [];
-
-	for await (const row of iter) {
-		result.push(row);
-	}
-
-	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-});
-
-test('select iterator w/ prepared statement', async () => {
-	const users = mysqlTable('users_iterator', {
-		id: serial('id').primaryKey(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-	await db.insert(users).values([{}, {}, {}]);
-
-	const prepared = db.select().from(users).prepare();
-	const iter = prepared.iterator();
-	const result: typeof users.$inferSelect[] = [];
-
-	for await (const row of iter) {
-		result.push(row);
-	}
-
-	expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-});
-
-test('insert undefined', async () => {
-	const users = mysqlTable('users', {
-		id: serial('id').primaryKey(),
-		name: text('name'),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, name text)`,
-	);
-
-	await expect((async () => {
-		await db.insert(users).values({ name: undefined });
-	})()).resolves.not.toThrowError();
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('update undefined', async () => {
-	const users = mysqlTable('users', {
-		id: serial('id').primaryKey(),
-		name: text('name'),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table ${users} (id serial not null primary key, name text)`,
-	);
-
-	await expect((async () => {
-		await db.update(users).set({ name: undefined });
-	})()).rejects.toThrowError();
-
-	await expect((async () => {
-		await db.update(users).set({ id: 1, name: undefined });
-	})()).resolves.not.toThrowError();
-
-	await db.execute(sql`drop table ${users}`);
-});
diff --git a/integration-tests/tests/mysql/mysql-proxy.test.ts b/integration-tests/tests/mysql/mysql-proxy.test.ts
deleted file mode 100644
index d5755cb80c..0000000000
--- a/integration-tests/tests/mysql/mysql-proxy.test.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import retry from 'async-retry';
-import type { MySqlRemoteDatabase } from 'drizzle-orm/mysql-proxy';
-import { drizzle as proxyDrizzle } from 'drizzle-orm/mysql-proxy';
-import * as mysql from 'mysql2/promise';
-import { afterAll, beforeAll, beforeEach } from 'vitest';
-import { skipTests } from '~/common';
-import { createDockerDB, tests } from './mysql-common';
-
-const ENABLE_LOGGING = false;
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-class ServerSimulator {
-	constructor(private db: mysql.Connection) {}
-
-	async query(sql: string, params: any[], method: 'all' | 'execute') {
-		if (method === 'all') {
-			try {
-				const result = await this.db.query({
-					sql,
-					values: params,
-					rowsAsArray: true,
-					typeCast: function(field: any, next: any) {
-						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-							return field.string();
-						}
-						return next();
-					},
-				});
-
-				return { data: result[0] as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else if (method === 'execute') {
-			try {
-				const result = await this.db.query({
-					sql,
-					values: params,
-					typeCast: function(field: any, next: any) {
-						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-							return field.string();
-						}
-						return next();
-					},
-				});
-
-				return { data: result as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else {
-			return { error: 'Unknown method value' };
-		}
-	}
-
-	async migrations(queries: string[]) {
-		await this.db.query('START TRANSACTION');
-		try {
-			for (const query of queries) {
-				await this.db.query(query);
-			}
-			await this.db.query('COMMIT');
-		} catch (e) {
-			await this.db.query('ROLLBACK');
-			throw e;
-		}
-
-		return {};
-	}
-}
-
-let db: MySqlRemoteDatabase;
-let client: mysql.Connection;
-let serverSimulator: ServerSimulator;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['MYSQL_CONNECTION_STRING']) {
-		connectionString = process.env['MYSQL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = await mysql.createConnection({
-			uri: connectionString,
-			supportBigNumbers: true,
-		});
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	serverSimulator = new ServerSimulator(client);
-	db = proxyDrizzle(async (sql, params, method) => {
-		try {
-			const response = await serverSimulator.query(sql, params, method);
-
-			if (response.error !== undefined) {
-				throw response.error;
-			}
-
-			return { rows: response.data };
-		} catch (e: any) {
-			console.error('Error from mysql proxy server:', e.message);
-			throw e;
-		}
-	}, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.mysql = {
-		db,
-	};
-});
-
-skipTests([
-	'select iterator w/ prepared statement',
-	'select iterator',
-	'nested transaction rollback',
-	'nested transaction',
-	'transaction rollback',
-	'transaction',
-	'transaction with options (set isolationLevel)',
-	'migrator',
-]);
-
-tests();
diff --git a/integration-tests/tests/mysql-returning.test.ts b/integration-tests/tests/mysql/mysql-returning.test.ts
similarity index 80%
rename from integration-tests/tests/mysql-returning.test.ts
rename to integration-tests/tests/mysql/mysql-returning.test.ts
index 557d8a756b..f0720c43a7 100644
--- a/integration-tests/tests/mysql-returning.test.ts
+++ b/integration-tests/tests/mysql/mysql-returning.test.ts
@@ -2,14 +2,11 @@ import 'dotenv/config';
 
 import type { TestFn } from 'ava';
 import anyTest from 'ava';
-import Docker from 'dockerode';
 import { DefaultLogger, sql } from 'drizzle-orm';
 import { boolean, json, mysqlTable, serial, text, timestamp, varchar } from 'drizzle-orm/mysql-core';
 import type { MySql2Database } from 'drizzle-orm/mysql2';
 import { drizzle } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
 
 const ENABLE_LOGGING = false;
 
@@ -22,44 +19,20 @@ const usersTable = mysqlTable('userstest', {
 });
 
 interface Context {
-	docker: Docker;
-	mysqlContainer: Docker.Container;
 	db: MySql2Database;
 	client: mysql.Connection;
 }
 
 const test = anyTest as TestFn<Context>;
 
-async function createDockerDB(ctx: Context): Promise<string> {
-	const docker = (ctx.docker = new Docker());
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	ctx.mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await ctx.mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
 test.before(async (t) => {
 	const ctx = t.context;
-	const connectionString = process.env['MYSQL_CONNECTION_STRING'] ?? await createDockerDB(ctx);
+	const connectionString = process.env['MYSQL_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mysql` and export the connection string before running tests.',
+		);
+	}
 
 	const sleep = 1000;
 	let timeLeft = 20000;
@@ -80,16 +53,14 @@ test.before(async (t) => {
 	if (!connected) {
 		console.error('Cannot connect to MySQL');
 		await ctx.client?.end().catch(console.error);
-		await ctx.mysqlContainer?.stop().catch(console.error);
 		throw lastError;
 	}
-	ctx.db = drizzle(ctx.client, { logger: ENABLE_LOGGING ? new DefaultLogger() : undefined });
+	ctx.db = drizzle({ client: ctx.client, logger: ENABLE_LOGGING ? new DefaultLogger() : undefined });
 });
 
 test.after.always(async (t) => {
 	const ctx = t.context;
 	await ctx.client?.end().catch(console.error);
-	await ctx.mysqlContainer?.stop().catch(console.error);
 });
 
 test.beforeEach(async (t) => {
diff --git a/integration-tests/tests/mysql/mysql.planetscale.test.ts b/integration-tests/tests/mysql/mysql.planetscale.test.ts
new file mode 100644
index 0000000000..e613586fb2
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql.planetscale.test.ts
@@ -0,0 +1,10290 @@
+import 'dotenv/config';
+
+import { Client } from '@planetscale/database';
+import { DrizzleError, sql, TransactionRollbackError } from 'drizzle-orm';
+import { alias } from 'drizzle-orm/mysql-core';
+import { drizzle, type PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
+import { beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './mysql.relations';
+import {
+	allTypesTable,
+	commentsTable,
+	customTypesTable,
+	groupsTable,
+	postsTable,
+	usersTable,
+	usersToGroupsTable,
+} from './mysql.schema';
+
+const ENABLE_LOGGING = false;
+
+let db: PlanetScaleDatabase<typeof relations>;
+
+beforeAll(async () => {
+	db = drizzle(
+		{
+			client: new Client({
+				url: process.env['PLANETSCALE_CONNECTION_STRING']!,
+			}),
+			relations,
+			logger: ENABLE_LOGGING,
+		},
+	);
+
+	await Promise.all([
+		db.execute(sql`drop table if exists \`users\``),
+		db.execute(sql`drop table if exists \`groups\``),
+		db.execute(sql`drop table if exists \`users_to_groups\``),
+		db.execute(sql`drop table if exists \`posts\``),
+		db.execute(sql`drop table if exists \`comments\``),
+		db.execute(sql`drop table if exists \`comment_likes\``),
+		db.execute(sql`drop table if exists \`all_types\``),
+		db.execute(sql`drop table if exists \`custom_types\``),
+	]);
+	await Promise.all([
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`users\` (
+					  \`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					  \`name\` text NOT NULL,
+					  \`verified\` boolean DEFAULT false NOT NULL,
+					  \`invited_by\` bigint
+				);
+			`,
+		),
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`groups\` (
+					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					\`name\` text NOT NULL,
+					\`description\` text
+				);
+			`,
+		),
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`users_to_groups\` (
+					\`id\` serial PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					\`user_id\` bigint,
+					\`group_id\` bigint
+				);
+			`,
+		),
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`posts\` (
+					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					\`content\` text NOT NULL,
+					\`owner_id\` bigint,
+					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+				);
+			`,
+		),
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`comments\` (
+					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					\`content\` text NOT NULL,
+					\`creator\` bigint,
+					\`post_id\` bigint,
+					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+				);
+			`,
+		),
+		db.execute(
+			sql`
+				CREATE TABLE IF NOT EXISTS \`comment_likes\` (
+					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
+					\`creator\` bigint,
+					\`comment_id\` bigint,
+					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+				);
+			`,
+		),
+	]);
+});
+
+beforeEach(async () => {
+	await Promise.all([
+		db.delete(usersTable),
+		db.delete(postsTable),
+		db.delete(commentsTable),
+		db.delete(groupsTable),
+		db.delete(usersToGroupsTable),
+		db.execute(sql`delete from \`comment_likes\``),
+	]);
+	await Promise.all([
+		db.execute(sql`ALTER TABLE \`users\` AUTO_INCREMENT = 1`),
+		db.execute(sql`ALTER TABLE \`groups\` AUTO_INCREMENT = 1`),
+		db.execute(sql`ALTER TABLE \`users_to_groups\` AUTO_INCREMENT = 1`),
+		db.execute(sql`ALTER TABLE \`posts\` AUTO_INCREMENT = 1`),
+		db.execute(sql`ALTER TABLE \`comments\` AUTO_INCREMENT = 1`),
+		db.execute(sql`ALTER TABLE \`comment_likes\` AUTO_INCREMENT = 1`),
+	]);
+});
+
+test('[Find Many] Get users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [
+			{
+				id: 3,
+				ownerId: 1,
+				content: '3',
+				createdAt: usersWithPosts[2]?.posts[2]?.createdAt,
+			},
+			{
+				id: 2,
+				ownerId: 1,
+				content: '2',
+				createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+			},
+			{
+				id: 1,
+				ownerId: 1,
+				content: '1',
+				createdAt: usersWithPosts[2]?.posts[0]?.createdAt,
+			},
+		],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 1, content: 'Post1.2' },
+		{ id: 3, ownerId: 1, content: 'Post1.3' },
+		{ id: 4, ownerId: 2, content: 'Post2' },
+		{ id: 5, ownerId: 2, content: 'Post2.1' },
+		{ id: 6, ownerId: 3, content: 'Post3' },
+		{ id: 7, ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test('[Find Many] Get only custom fields + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+});
+
+test('[Find One] Get only custom fields + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get deep select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts + prepared limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [
+					{
+						eq: sql.placeholder('id'),
+					},
+					3,
+				],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async () => {
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(false);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: { OR: [3, 4] },
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: { OR: [3, 4] },
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: false,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+test('Get user with posts and posts with comments and comments with owner', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: (table, { exists, eq }) =>
+				exists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(sql`1`, table.id))),
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(1);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: (groupsTable) => sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Force optional on where on non-optional relation query', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users + filter users by posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter posts by author', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}],
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 1,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 3,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('alltypes', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`all_types\` (
+				\`serial\` serial AUTO_INCREMENT,
+				\`blob\` blob,
+				\`blob_str\` blob,
+				\`bigint53\` bigint,
+				\`bigint64\` bigint,
+				\`bigint_string\` bigint,
+				\`binary\` binary,
+				\`boolean\` boolean,
+				\`char\` char,
+				\`date\` date,
+				\`date_str\` date,
+				\`datetime\` datetime,
+				\`datetime_str\` datetime,
+				\`decimal\` decimal,
+				\`decimal_num\` decimal(30),
+				\`decimal_big\` decimal(30),
+				\`double\` double,
+				\`float\` float,
+				\`int\` int,
+				\`json\` json,
+				\`med_int\` mediumint,
+				\`small_int\` smallint,
+				\`real\` real,
+				\`text\` text,
+				\`time\` time,
+				\`timestamp\` timestamp,
+				\`timestamp_str\` timestamp,
+				\`tiny_int\` tinyint,
+				\`varbin\` varbinary(16),
+				\`varchar\` varchar(255),
+				\`year\` year,
+				\`enum\` enum('enV1','enV2')
+			);
+	`);
+
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		blob: Buffer.from('BYTES'),
+		blobStr: 'BYTES',
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintString: '5044565289845416380',
+		binary: '1',
+		boolean: true,
+		char: 'c',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		datetime: new Date(1741743161623),
+		datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		decimal: '47521',
+		decimalNum: 9007199254740991,
+		decimalBig: 5044565289845416380n,
+		double: 15.35325689124218,
+		enum: 'enV1',
+		float: 1.048596,
+		real: 1.048596,
+		text: 'C4-',
+		int: 621,
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		medInt: 560,
+		smallInt: 14,
+		time: '04:13:22',
+		timestamp: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		tinyInt: 7,
+		varbin: '1010110101001101',
+		varchar: 'VCHAR',
+		year: 2025,
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			serial: 1,
+			blob: Buffer.from('BYTES'),
+			blobStr: 'BYTES',
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			datetime: new Date('2025-03-12T01:32:42.000Z'),
+			datetimeStr: '2025-03-12 01:32:41',
+			decimal: '47521',
+			decimalNum: 9007199254740991,
+			decimalBig: 5044565289845416380n,
+			double: 15.35325689124218,
+			float: 1.0486,
+			int: 621,
+			json: { arr: ['str', 10], str: 'strval' },
+			medInt: 560,
+			smallInt: 14,
+			real: 1.048596,
+			text: 'C4-',
+			time: '04:13:22',
+			timestamp: new Date('2025-03-12T01:32:42.000Z'),
+			timestampStr: '2025-03-12 01:32:41',
+			tinyInt: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+			enum: 'enV1',
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`custom_types\` (
+			\`id\` int,
+			\`big\` bigint,
+			\`bytes\` blob,
+			\`time\` timestamp,
+			\`int\` int
+		);
+	`);
+
+	await db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bytes: Buffer.from('BYTES'),
+		time: new Date(1741743161000),
+		int: 250,
+	});
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number | null;
+		big: bigint | null;
+		bytes: Buffer | null;
+		time: Date | null;
+		int: number | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bytes: Buffer.from('BYTES'),
+			time: new Date(1741743161000),
+			int: 250,
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/mysql/mysql.relations.ts b/integration-tests/tests/mysql/mysql.relations.ts
new file mode 100644
index 0000000000..ef8c9fb86e
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql.relations.ts
@@ -0,0 +1,212 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './mysql.schema';
+
+export default defineRelations(schema, (r) => ({
+	usersView: {
+		posts: r.many.postsTable(),
+		groups: r.many.groupsTable(),
+	},
+	schemaUsersView: {
+		posts: r.many.schemaPosts(),
+		groups: r.many.schemaGroups(),
+	},
+	usersTable: {
+		alltypes: r.many.allTypesTable({
+			from: r.usersTable.id,
+			to: r.allTypesTable.serial,
+		}),
+		invitee: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+		}),
+		inviteeRequired: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		usersToGroups: r.many.usersToGroupsTable(),
+		posts: r.many.postsTable(),
+		postsFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				ownerId: 2,
+			},
+			alias: 'author-filtered',
+		}),
+		postsAltFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				content: {
+					like: '%.1',
+				},
+			},
+			alias: 'author-alt-filtered',
+		}),
+		group: r.one.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+		}),
+		groups: r.many.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			alias: 'users-groups-direct',
+		}),
+		groupsFiltered: r.many.groupsTable({
+			alias: 'users-groups-direct-filtered',
+		}),
+	},
+	groupsTable: {
+		usersToGroups: r.many.usersToGroupsTable(),
+		user: r.one.usersTable(),
+		users: r.many.usersTable({
+			alias: 'users-groups-direct',
+		}),
+		usersFiltered: r.many.usersTable({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+			alias: 'users-groups-direct-filtered',
+		}),
+		usersView: r.many.usersView({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersView.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	usersToGroupsTable: {
+		group: r.one.groupsTable({
+			from: r.usersToGroupsTable.groupId,
+			to: r.groupsTable.id,
+			optional: false,
+		}),
+		user: r.one.usersTable({
+			from: r.usersToGroupsTable.userId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	postsTable: {
+		author: r.one.usersTable({
+			from: r.postsTable.ownerId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		viewAuthor: r.one.usersView({
+			from: r.postsTable.ownerId,
+			to: r.usersView.id,
+			optional: false,
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+		authorFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-filtered',
+		}),
+		authorAltFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-alt-filtered',
+		}),
+		comments: r.many.commentsTable(),
+	},
+	commentsTable: {
+		post: r.one.postsTable({
+			from: r.commentsTable.postId,
+			to: r.postsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentsTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		likes: r.many.commentLikesTable(),
+	},
+	commentLikesTable: {
+		comment: r.one.commentsTable({
+			from: r.commentLikesTable.commentId,
+			to: r.commentsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentLikesTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	schemaUsers: {
+		posts: r.many.schemaPosts({
+			from: r.schemaUsers.id,
+			to: r.schemaPosts.ownerId,
+			where: {
+				content: {
+					like: 'M%',
+				},
+			},
+		}),
+		groups: r.many.schemaGroups({
+			from: r.schemaUsers.id.through(r.schemaUsersToGroups.userId),
+			to: r.schemaGroups.id.through(r.schemaUsersToGroups.groupId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+		}),
+	},
+	schemaPosts: {
+		author: r.one.schemaUsers(),
+		viewAuthor: r.one.schemaUsersView({
+			from: r.schemaPosts.ownerId,
+			to: r.schemaUsersView.id,
+			optional: false,
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	schemaGroups: {
+		users: r.many.schemaUsers(),
+		usersView: r.many.schemaUsersView({
+			from: r.schemaGroups.id.through(r.schemaUsersToGroups.groupId),
+			to: r.schemaUsersView.id.through(r.schemaUsersToGroups.userId),
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	students: {
+		courseOfferings: r.many.courseOfferings({
+			from: r.students.studentId.through(r.studentGrades.studentId),
+			to: [
+				r.courseOfferings.courseId.through(r.studentGrades.courseId),
+				r.courseOfferings.semester.through(r.studentGrades.semester),
+			],
+		}),
+	},
+	courseOfferings: {
+		students: r.many.students(),
+	},
+	customTypesTable: {
+		self: r.many.customTypesTable({
+			from: r.customTypesTable.id,
+			to: r.customTypesTable.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/mysql/mysql.schema.ts b/integration-tests/tests/mysql/mysql.schema.ts
new file mode 100644
index 0000000000..d965f62442
--- /dev/null
+++ b/integration-tests/tests/mysql/mysql.schema.ts
@@ -0,0 +1,329 @@
+import {
+	alias,
+	type AnyMySqlColumn,
+	bigint,
+	binary,
+	blob,
+	boolean,
+	char,
+	customType,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	int,
+	json,
+	mediumint,
+	mysqlEnum,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+
+import { eq, getTableColumns, ne, sql } from 'drizzle-orm';
+
+export const usersTable = snakeCase.table('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	verified: boolean().notNull().default(false),
+	invitedBy: bigint({ mode: 'number' }).references(
+		(): AnyMySqlColumn => usersTable.id,
+	),
+});
+
+const schemaV1 = snakeCase.schema('schemaV1');
+
+export const usersV1 = schemaV1.table('usersV1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: bigint('invited_by', { mode: 'number' }),
+});
+
+export const usersTableV1 = schemaV1.table('users_table_V1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: bigint('invited_by', { mode: 'number' }),
+});
+
+export const groupsTable = snakeCase.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+
+export const usersToGroupsTable = snakeCase.table(
+	'users_to_groups',
+	{
+		id: serial().primaryKey(),
+		userId: bigint({ mode: 'number' }).notNull().references(
+			() => usersTable.id,
+		),
+		groupId: bigint({ mode: 'number' }).notNull().references(
+			() => groupsTable.id,
+		),
+	},
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
+);
+
+export const postsTable = snakeCase.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: bigint({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+
+export const usersView = snakeCase.view('rqb_users_view').as((qb) =>
+	qb.select({
+		...getTableColumns(usersTable),
+		postContent: postsTable.content,
+		createdAt: postsTable.createdAt,
+		counter: sql<string | number>`(select count(*) from ${usersTable} as ${alias(usersTable, 'count_source')} where ${
+			ne(usersTable.id, 2)
+		})`
+			.mapWith((data) => {
+				return data === '0' || data === 0 ? null : Number(data);
+			}).as('count'),
+	})
+		.from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.ownerId))
+);
+
+export const commentsTable = snakeCase.table('comments', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	creator: bigint({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	postId: bigint({ mode: 'number' }).references(() => postsTable.id),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+
+export const commentLikesTable = snakeCase.table('comment_likes', {
+	id: serial().primaryKey(),
+	creator: bigint({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	commentId: bigint({ mode: 'number' }).references(
+		() => commentsTable.id,
+	),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+
+export const rqbSchema = snakeCase.schema('rqb_test_schema');
+
+export const schemaUsers = rqbSchema.table('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	verified: boolean().notNull().default(false),
+	invitedBy: bigint({ mode: 'number' }).references(
+		(): AnyMySqlColumn => schemaUsers.id,
+	),
+});
+
+export const schemaPosts = rqbSchema.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: bigint({ mode: 'number' }).references(
+		() => schemaUsers.id,
+	),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+
+export const schemaGroups = rqbSchema.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+
+export const schemaUsersToGroups = rqbSchema.table(
+	'users_to_groups',
+	{
+		id: serial().primaryKey(),
+		userId: bigint({ mode: 'number' }).notNull().references(
+			() => schemaUsers.id,
+		),
+		groupId: bigint({ mode: 'number' }).notNull().references(
+			() => schemaGroups.id,
+		),
+	},
+	(t) => ({
+		pk: primaryKey(t.userId, t.groupId),
+	}),
+);
+
+export const schemaUsersView = rqbSchema.view('users_sch_view').as((qb) =>
+	qb.select({
+		...getTableColumns(schemaUsers),
+		postContent: schemaPosts.content,
+		createdAt: schemaPosts.createdAt,
+		counter: sql<string | number>`(select count(*) from ${schemaUsers} as ${alias(schemaUsers, 'count_source')} where ${
+			ne(schemaUsers.id, 2)
+		})`
+			.mapWith((data) => {
+				return data === '0' || data === 0 ? null : Number(data);
+			}).as('count'),
+	})
+		.from(schemaUsers).leftJoin(schemaPosts, eq(schemaUsers.id, schemaPosts.ownerId))
+);
+
+export const allTypesTable = snakeCase.table('all_types', {
+	serial: serial(),
+	blob: blob({
+		mode: 'buffer',
+	}),
+	blobStr: blob({
+		mode: 'string',
+	}),
+	bigint53: bigint({
+		mode: 'number',
+	}),
+	bigint64: bigint({
+		mode: 'bigint',
+	}),
+	bigintString: bigint({
+		mode: 'string',
+	}),
+	binary: binary(),
+	boolean: boolean(),
+	char: char(),
+	date: date({
+		mode: 'date',
+	}),
+	dateStr: date({
+		mode: 'string',
+	}),
+	datetime: datetime({
+		mode: 'date',
+	}),
+	datetimeStr: datetime({
+		mode: 'string',
+	}),
+	decimal: decimal(),
+	decimalNum: decimal({
+		scale: 30,
+		mode: 'number',
+	}),
+	decimalBig: decimal({
+		scale: 30,
+		mode: 'bigint',
+	}),
+	double: double(),
+	float: float(),
+	int: int(),
+	json: json(),
+	medInt: mediumint(),
+	smallInt: smallint(),
+	real: real(),
+	text: text(),
+	time: time(),
+	timestamp: timestamp({
+		mode: 'date',
+	}),
+	timestampStr: timestamp({
+		mode: 'string',
+	}),
+	tinyInt: tinyint(),
+	varbin: varbinary({
+		length: 16,
+	}),
+	varchar: varchar({
+		length: 255,
+	}),
+	year: year(),
+	enum: mysqlEnum(['enV1', 'enV2']),
+});
+
+export const students = snakeCase.table('students', {
+	studentId: serial('student_id').primaryKey().notNull(),
+	name: text().notNull(),
+});
+
+export const courseOfferings = snakeCase.table('course_offerings', {
+	courseId: int('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+});
+
+export const studentGrades = snakeCase.table('student_grades', {
+	studentId: int('student_id').notNull(),
+	courseId: int('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+	grade: char({ length: 2 }),
+});
+
+const customBigInt = customType<{
+	data: bigint;
+	driverData: bigint;
+	driverOutput: string;
+	jsonData: string;
+}>({
+	dataType: () => 'bigint',
+	fromDriver: BigInt,
+});
+
+const customBytes = customType<{
+	data: Buffer;
+	driverData: Buffer;
+	driverOutput: Buffer | Uint8Array;
+	jsonData: string;
+}>({
+	dataType: () => 'blob',
+	fromDriver: (value) => {
+		return Buffer.isBuffer(value) ? value : Buffer.from(value);
+	},
+	fromJson: (value) => {
+		return Buffer.from(value, 'hex');
+	},
+	forJsonSelect: (identifier, sql) => {
+		return sql`hex(${identifier})`;
+	},
+});
+
+const customTimestamp = customType<{
+	data: Date;
+	driverData: string;
+	jsonData: string;
+}>({
+	dataType: () => 'timestamp',
+	fromDriver: (value: string) => {
+		return new Date(value + '+0000');
+	},
+	toDriver: (value: Date) => {
+		return value.toISOString().slice(0, 19).replace('T', ' ');
+	},
+});
+
+const customInt = customType<{
+	data: number;
+	driverData: number;
+}>({
+	dataType: () => 'int',
+});
+
+export const customTypesTable = snakeCase.table('custom_types', {
+	id: int('id'),
+	big: customBigInt(),
+	bytes: customBytes(),
+	time: customTimestamp(),
+	int: customInt(),
+});
diff --git a/integration-tests/tests/mysql/mysql.test.ts b/integration-tests/tests/mysql/mysql.test.ts
index 6641e2d14f..57d7850674 100644
--- a/integration-tests/tests/mysql/mysql.test.ts
+++ b/integration-tests/tests/mysql/mysql.test.ts
@@ -1,61 +1,12972 @@
-import retry from 'async-retry';
-import type { MySql2Database } from 'drizzle-orm/mysql2';
-import { drizzle } from 'drizzle-orm/mysql2';
+import 'dotenv/config';
+import { defineRelations, DrizzleError, eq, sql, TransactionRollbackError } from 'drizzle-orm';
+import { alias, int, mysqlTable, snakeCase, time } from 'drizzle-orm/mysql-core';
+import { drizzle, type MySql2Database } from 'drizzle-orm/mysql2';
 import * as mysql from 'mysql2/promise';
-import { afterAll, beforeAll, beforeEach } from 'vitest';
-import { createDockerDB, tests } from './mysql-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './mysql-common-cache';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './mysql.relations';
+import {
+	allTypesTable,
+	commentsTable,
+	courseOfferings,
+	customTypesTable,
+	groupsTable,
+	postsTable,
+	schemaGroups,
+	schemaPosts,
+	schemaUsers,
+	schemaUsersToGroups,
+	studentGrades,
+	students,
+	usersTable,
+	usersToGroupsTable,
+} from './mysql.schema';
 
 const ENABLE_LOGGING = false;
 
-let db: MySql2Database;
-let dbGlobalCached: MySql2Database;
-let cachedDb: MySql2Database;
+declare module 'vitest' {
+	export interface TestContext {
+		mysqlDbV2: MySql2Database<typeof relations>;
+		mysqlClient: mysql.Connection;
+	}
+}
+
+let db: MySql2Database<typeof relations>;
 let client: mysql.Connection;
 
 beforeAll(async () => {
-	let connectionString;
-	if (process.env['MYSQL_CONNECTION_STRING']) {
-		connectionString = process.env['MYSQL_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = await mysql.createConnection({
-			uri: connectionString!,
-			supportBigNumbers: true,
+	const connectionString = process.env['MYSQL_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mysql` and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 1000;
+	let timeLeft = 30000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			client = await mysql.createConnection({ uri: connectionString, supportBigNumbers: true, bigNumberStrings: true });
+			await client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to MySQL');
+		await client?.end().catch(console.error);
+		throw lastError;
+	}
+	db = drizzle({ client, relations, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
+beforeEach(async (ctx) => {
+	ctx.mysqlDbV2 = db;
+	ctx.mysqlClient = client;
+
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`users\``);
+	await ctx.mysqlDbV2.execute(sql`drop view if exists \`rqb_users_view\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`users\``);
+	await ctx.mysqlDbV2.execute(sql`drop view if exists \`rqb_test_schema\`.\`users_sch_view\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`groups\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`groups\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`users_to_groups\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`users_to_groups\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`posts\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`posts\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`comments\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`comment_likes\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`all_types\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`custom_types\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`course_offerings\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`student_grades\``);
+	await ctx.mysqlDbV2.execute(sql`drop table if exists \`students\``);
+
+	await ctx.mysqlDbV2.execute(sql`create schema if not exists \`rqb_test_schema\``);
+
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`users\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL,
+				\`verified\` boolean DEFAULT false NOT NULL,
+				\`invited_by\` bigint REFERENCES \`users\`(\`id\`)
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`users\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL,
+				\`verified\` boolean DEFAULT false NOT NULL,
+				\`invited_by\` bigint REFERENCES \`rqb_test_schema\`.\`users\`(\`id\`)
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`groups\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL,
+				\`description\` text
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`groups\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL,
+				\`description\` text
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`users_to_groups\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`user_id\` bigint REFERENCES \`users\`(\`id\`),
+				\`group_id\` bigint REFERENCES \`groups\`(\`id\`)
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`users_to_groups\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`user_id\` bigint REFERENCES \`rqb_test_schema\`.\`users\`(\`id\`),
+				\`group_id\` bigint REFERENCES \`rqb_test_schema\`.\`groups\`(\`id\`)
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`posts\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`content\` text NOT NULL,
+				\`owner_id\` bigint REFERENCES \`users\`(\`id\`),
+				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`posts\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`content\` text NOT NULL,
+				\`owner_id\` bigint REFERENCES \`rqb_test_schema\`.\`users\`(\`id\`),
+				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE ALGORITHM = undefined
+			SQL SECURITY definer
+			VIEW \`rqb_test_schema\`.\`users_sch_view\` AS (select \`rqb_test_schema\`.\`users\`.\`id\`, \`rqb_test_schema\`.\`users\`.\`name\`, \`rqb_test_schema\`.\`users\`.\`verified\`, \`rqb_test_schema\`.\`users\`.\`invited_by\`, \`rqb_test_schema\`.\`posts\`.\`content\`, \`rqb_test_schema\`.\`posts\`.\`created_at\`, (select count(*) from \`rqb_test_schema\`.\`users\` as \`count_source\` where \`rqb_test_schema\`.\`users\`.\`id\` <> 2) as \`count\` from \`rqb_test_schema\`.\`users\` left join \`rqb_test_schema\`.\`posts\` on \`rqb_test_schema\`.\`users\`.\`id\` = \`rqb_test_schema\`.\`posts\`.\`owner_id\`);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE ALGORITHM = undefined
+			SQL SECURITY definer
+			VIEW \`rqb_users_view\` AS (select \`users\`.\`id\`, \`users\`.\`name\`, \`users\`.\`verified\`, \`users\`.\`invited_by\`, \`posts\`.\`content\`, \`posts\`.\`created_at\`, (select count(*) from \`users\` as \`count_source\` where \`users\`.\`id\` <> 2) as \`count\` from \`users\` left join \`posts\` on \`users\`.\`id\` = \`posts\`.\`owner_id\`);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`comments\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`content\` text NOT NULL,
+				\`creator\` bigint REFERENCES \`users\`(\`id\`),
+				\`post_id\` bigint REFERENCES \`posts\`(\`id\`),
+				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`comment_likes\` (
+				\`id\` serial PRIMARY KEY NOT NULL,
+				\`creator\` bigint REFERENCES \`users\`(\`id\`),
+				\`comment_id\` bigint REFERENCES \`comments\`(\`id\`),
+				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`course_offerings\` (
+				\`course_id\` integer NOT NULL,
+				\`semester\` varchar(10) NOT NULL,
+				CONSTRAINT \`course_offerings_pkey\` PRIMARY KEY(\`course_id\`,\`semester\`)
+			)	
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`student_grades\` (
+				\`student_id\` integer NOT NULL,
+				\`course_id\` integer NOT NULL,
+				\`semester\` varchar(10) NOT NULL,
+				\`grade\` char(2),
+				CONSTRAINT \`student_grades_pkey\` PRIMARY KEY(\`student_id\`,\`course_id\`,\`semester\`)
+			);
+		`,
+	);
+	await ctx.mysqlDbV2.execute(
+		sql`
+			CREATE TABLE \`students\` (
+				\`student_id\` serial PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL
+			);
+		`,
+	);
+});
+
+test('[Find Many] Get users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts and users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
 		});
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 1, content: 'Post1.2' },
+		{ id: 3, ownerId: 1, content: 'Post1.3' },
+		{ id: 4, ownerId: 2, content: 'Post2' },
+		{ id: 5, ownerId: 2, content: 'Post2.1' },
+		{ id: 6, ownerId: 3, content: 'Post3' },
+		{ id: 7, ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test('[Find Many] Get only custom fields + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
 		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
 	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
 });
 
-afterAll(async () => {
-	await client?.end();
+test('[Find Many] Get only custom fields + where + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
 });
 
-beforeEach((ctx) => {
-	ctx.mysql = {
-		db,
-	};
-	ctx.cachedMySQL = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
+test('[Find One] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
 });
 
-cacheTests();
-tests();
+test('[Find One] Get only custom fields + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(
+		async () =>
+			await db.query.usersTable.findMany({
+				columns: {},
+			}),
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+test('[Find One] Get deep select {}', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts + prepared limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [
+					{
+						eq: sql.placeholder('id'),
+					},
+					3,
+				],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(false);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: false,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+test('Get user with posts and posts with comments and comments with owner', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: ({ id }, { exists, eq }) =>
+				exists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(sql`1`, id))),
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(1);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: (groupsTable) => sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Force optional on where on non-optional relation query', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many .through] Get users with groups', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + orderBy', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users + orderBy + limit', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + custom', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get custom schema users with filtered posts + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsers.findMany({
+		with: {
+			posts: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%2.%',
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				gte: 2,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [
+			{ ownerId: 2, content: 'Message2.1' },
+			{ ownerId: 2, content: 'Message2.2' },
+			{ ownerId: 2, content: 'Message2.3' },
+		],
+	}]);
+});
+
+test('[Find Many] Get custom schema posts with filtered authors + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const posts = await db.query.schemaPosts.findMany({
+		columns: {
+			content: true,
+		},
+		with: {
+			author: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		content: string;
+		author: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	expect(posts).toStrictEqual([
+		{ content: 'Post3.3', author: null },
+		{ content: 'Post2.3', author: null },
+		{ content: 'Post1.3', author: null },
+		{ content: 'Post3.2', author: null },
+		{ content: 'Post2.2', author: null },
+		{ content: 'Post1.2', author: null },
+		{ content: 'Post3.1', author: null },
+		{ content: 'Post2.1', author: null },
+		{ content: 'Post1.1', author: null },
+		{ content: 'Message3.3', author: null },
+		{ content: 'Message2.3', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.3', author: null },
+		{ content: 'Message3.2', author: null },
+		{ content: 'Message2.2', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.2', author: null },
+		{ content: 'Message3.1', author: null },
+		{ content: 'Message2.1', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.1', author: null },
+	]);
+});
+
+test('[Find Many .through] Get custom schema users with filtered groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsers.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get custom schema groups with filtered users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			users: {
+				where: { id: { lt: 3 } },
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by SQL.Aliased field', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by joined field', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get posts with view users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter by joined column with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notLike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get posts with view users + filter by SQL.Aliased with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get view users with filtered groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered view users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts + filter by SQL.Aliased field', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts + filter by joined field', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema posts with view users with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users + filter with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users + filter by joined column with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notLike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get schema posts with view users + filter by SQL.Aliased with posts', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(50000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get schema view users with filtered groups + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get schema groups with filtered view users + where', async (t) => {
+	const { mysqlDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('[Find Many] Get users + filter users by posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter posts by author', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}],
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async (ctx) => {
+	const { mysqlDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 1,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 3,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.students.findMany({
+		with: {
+			courseOfferings: {
+				orderBy: {
+					courseId: 'asc',
+					semester: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			studentId: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		studentId: number;
+		name: string;
+		courseOfferings: {
+			courseId: number;
+			semester: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			name: 'First',
+			studentId: 1,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+				{
+					courseId: 2,
+					semester: 's2',
+				},
+			],
+		},
+		{
+			name: 'Second',
+			studentId: 2,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+			],
+		},
+		{
+			name: 'Third',
+			studentId: 3,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's2',
+				},
+				{
+					courseId: 2,
+					semester: 's3',
+				},
+				{
+					courseId: 4,
+					semester: 's4',
+				},
+			],
+		},
+		{
+			name: 'Fourth',
+			studentId: 4,
+			courseOfferings: [
+				{
+					courseId: 3,
+					semester: 's1',
+				},
+				{
+					courseId: 4,
+					semester: 's3',
+				},
+			],
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count - reverse', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.courseOfferings.findMany({
+		with: {
+			students: {
+				orderBy: {
+					studentId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			courseId: 'asc',
+			semester: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		courseId: number;
+		semester: string;
+		students: {
+			studentId: number;
+			name: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			courseId: 1,
+			semester: 's1',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+				{
+					name: 'Second',
+					studentId: 2,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's2',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's2',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's3',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's1',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 3,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's3',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 4,
+			semester: 's4',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+	]);
+});
+
+// https://github.com/drizzle-team/drizzle-orm/issues/4539
+test('[Find many] time column parsing', async () => {
+	const studios = snakeCase.table('studios', {
+		id: int().primaryKey(),
+		openTime: time(),
+	});
+
+	const notices = snakeCase.table('notices', {
+		studioId: int().references(() => studios.id),
+	});
+	const relations = defineRelations({ studios, notices }, (r) => ({
+		studio: {
+			notices: r.many.notices({
+				from: r.studios.id,
+				to: r.notices.studioId,
+			}),
+		},
+		notices: {
+			studio: r.one.studios({
+				from: r.notices.studioId,
+				to: r.studios.id,
+			}),
+		},
+	}));
+	const db = drizzle({ client, relations });
+	await db.execute(sql`DROP TABLE IF EXISTS \`notices\`;`);
+	await db.execute(sql`DROP TABLE IF EXISTS \`studios\`;`);
+	await db.execute(sql`
+	CREATE TABLE \`notices\` (
+        \`studio_id\` int
+		);
+	`);
+	await db.execute(sql`
+	CREATE TABLE \`studios\` (
+        \`id\` int PRIMARY KEY,
+        \`open_time\` time
+		);
+	`);
+	await db.execute(
+		sql`ALTER TABLE \`notices\` ADD CONSTRAINT \`notices_studios_id_studio_id_fkey\` FOREIGN KEY (\`studio_id\`) REFERENCES \`studios\`(\`id\`);`,
+	);
+
+	await db.insert(studios).values({ id: 1, openTime: '18:48:26' });
+	await db.insert(notices).values({ studioId: 1 });
+
+	const result1 = await db.query.notices.findMany({
+		with: {
+			studio: true,
+		},
+	});
+	expect(result1[0]?.studio?.openTime).toEqual('18:48:26');
+
+	const result2 = await db
+		.select()
+		.from(notices)
+		.leftJoin(studios, eq(notices.studioId, studios.id));
+	expect(result2[0]?.studios?.openTime).toEqual('18:48:26');
+});
+
+test('alltypes', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`all_types\` (
+				\`serial\` serial AUTO_INCREMENT,
+				\`blob\` blob,
+				\`blob_str\` blob,
+				\`bigint53\` bigint,
+				\`bigint64\` bigint,
+				\`bigint_string\` bigint,
+				\`binary\` binary,
+				\`boolean\` boolean,
+				\`char\` char,
+				\`date\` date,
+				\`date_str\` date,
+				\`datetime\` datetime,
+				\`datetime_str\` datetime,
+				\`decimal\` decimal,
+				\`decimal_num\` decimal(30),
+				\`decimal_big\` decimal(30),
+				\`double\` double,
+				\`float\` float,
+				\`int\` int,
+				\`json\` json,
+				\`med_int\` mediumint,
+				\`small_int\` smallint,
+				\`real\` real,
+				\`text\` text,
+				\`time\` time,
+				\`timestamp\` timestamp,
+				\`timestamp_str\` timestamp,
+				\`tiny_int\` tinyint,
+				\`varbin\` varbinary(16),
+				\`varchar\` varchar(255),
+				\`year\` year,
+				\`enum\` enum('enV1','enV2')
+			);
+	`);
+
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		blob: Buffer.from('BYTES'),
+		blobStr: 'BYTES',
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintString: '5044565289845416380',
+		binary: '1',
+		boolean: true,
+		char: 'c',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		datetime: new Date(1741743161623),
+		datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		decimal: '47521',
+		decimalNum: 9007199254740991,
+		decimalBig: 5044565289845416380n,
+		double: 15.35325689124218,
+		enum: 'enV1',
+		float: 1.048596,
+		real: 1.048596,
+		text: 'C4-',
+		int: 621,
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		medInt: 560,
+		smallInt: 14,
+		time: '04:13:22',
+		timestamp: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		tinyInt: 7,
+		varbin: '1010110101001101',
+		varchar: 'VCHAR',
+		year: 2025,
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			serial: 1,
+			blob: Buffer.from('BYTES'),
+			blobStr: 'BYTES',
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			datetime: new Date('2025-03-12T01:32:42.000Z'),
+			datetimeStr: '2025-03-12 01:32:41',
+			decimal: '47521',
+			decimalNum: 9007199254740991,
+			decimalBig: 5044565289845416380n,
+			double: 15.35325689124218,
+			float: 1.0486,
+			int: 621,
+			json: { arr: ['str', 10], str: 'strval' },
+			medInt: 560,
+			smallInt: 14,
+			real: 1.048596,
+			text: 'C4-',
+			time: '04:13:22',
+			timestamp: new Date('2025-03-12T01:32:42.000Z'),
+			timestampStr: '2025-03-12 01:32:41',
+			tinyInt: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+			enum: 'enV1',
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`custom_types\` (
+			\`id\` int,
+			\`big\` bigint,
+			\`bytes\` blob,
+			\`time\` timestamp,
+			\`int\` int
+		);
+	`);
+
+	await db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bytes: Buffer.from('BYTES'),
+		time: new Date(1741743161000),
+		int: 250,
+	});
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number | null;
+		big: bigint | null;
+		bytes: Buffer | null;
+		time: Date | null;
+		int: number | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bytes: Buffer.from('BYTES'),
+			time: new Date(1741743161000),
+			int: 250,
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/mysql/planetscale.test.ts b/integration-tests/tests/mysql/planetscale.test.ts
new file mode 100644
index 0000000000..fb1ec4f203
--- /dev/null
+++ b/integration-tests/tests/mysql/planetscale.test.ts
@@ -0,0 +1,239 @@
+import { Client } from '@planetscale/database';
+import { sql } from 'drizzle-orm';
+import { getTableConfig } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/planetscale-serverless';
+import { migrate } from 'drizzle-orm/planetscale-serverless/migrator';
+import { describe, expect } from 'vitest';
+import { planetscaleTest as test } from './instrumentation';
+import { tests } from './mysql-common';
+import { runTests as cacheTests } from './mysql-common-cache';
+import { usersMigratorTable } from './schema2';
+
+const omit = new Set([
+	'mySchema :: view',
+	'mySchema :: select from tables with same name from different schema using alias',
+	'mySchema :: prepared statement with placeholder in .where',
+	'mySchema :: insert with spaces',
+	'mySchema :: select with group by as column + sql',
+	'mySchema :: select with group by as field',
+	'mySchema :: insert many',
+	'mySchema :: insert with overridden default values',
+	'mySchema :: insert + select',
+	'mySchema :: delete with returning all fields',
+	'mySchema :: update with returning partial',
+	'mySchema :: delete returning sql',
+	'mySchema :: insert returning sql',
+	'mySchema :: select typed sql',
+	'mySchema :: select sql',
+	'mySchema :: select all fields',
+	'mySchema :: select distinct',
+	'mySchema :: build query',
+	'test $onUpdateFn and $onUpdate works updating',
+	'test $onUpdateFn and $onUpdate works as $default',
+	'set operations (mixed all) as function with subquery',
+	'set operations (mixed) from query builder',
+	'set operations (except all) as function',
+	'set operations (except all) from query builder',
+	'set operations (except) as function',
+	'set operations (except) from query builder',
+	'set operations (intersect all) as function',
+	'set operations (intersect all) from query builder',
+	'set operations (intersect) as function',
+	'set operations (intersect) from query builder',
+	'select iterator w/ prepared statement',
+	'select iterator',
+	'subquery with view',
+	'join on aliased sql from with clause',
+	'with ... delete',
+	'with ... update',
+	'with ... select',
+
+	// to redefine in this file
+	'utc config for datetime',
+	'transaction',
+	'transaction with options (set isolationLevel)',
+	'having',
+	'select count()',
+	'insert via db.execute w/ query builder',
+	'insert via db.execute + select via db.execute',
+	'insert many with returning',
+	'delete with returning partial',
+	'delete with returning all fields',
+	'update with returning partial',
+	'update with returning all fields',
+	'update returning sql',
+	'delete returning sql',
+	'insert returning sql',
+]);
+
+tests(test, omit);
+cacheTests('planetscale', test);
+
+describe('migrator', () => {
+	test('migrator', async ({ db }) => {
+		await db.execute(sql`drop table if exists ${sql.identifier('__drizzle_migrations')}`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('migrator : --init', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: 'string' }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(!!(Number(res.rows[0]?.tableExists ?? 0))).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: 'string' }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(!!(Number(res.rows[0]?.tableExists ?? 0))).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: 'string' }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(!!(Number(res.rows[0]?.tableExists ?? 0))).toStrictEqual(true);
+	});
+
+	// databases should manually be created in PlanetScale dashboard
+	test.skip('managing multiple databases #1', async ({ db }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		await db.execute(`use drizzle1`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.execute(`use drizzle2`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle2
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db.select().from(usersMigratorTable);
+
+		// drizzle1
+		await db.execute(`use drizzle1`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db.select().from(usersMigratorTable);
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+	test.skip('managing multiple databases #2', async () => {
+		const client1 = new Client({ url: process.env['PLANETSCALE_CONNECTION_STRING'] });
+		await client1.execute('drop database if exists drizzle1;');
+		await client1.execute('create database drizzle1;');
+		await client1.execute('use drizzle1;');
+
+		const client2 = new Client({ url: process.env['PLANETSCALE_CONNECTION_STRING'] });
+		await client2.execute('drop database if exists drizzle2;');
+		await client2.execute('create database drizzle2;');
+		await client2.execute('use drizzle2;');
+
+		const db1 = drizzle({ client: client1 });
+		const db2 = drizzle({ client: client2 });
+
+		await migrate(db1, { migrationsFolder: './drizzle2/mysql' });
+		await migrate(db2, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle1
+		await db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db1.select().from(usersMigratorTable);
+
+		// drizzle2
+		await db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db2.select().from(usersMigratorTable);
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+});
diff --git a/integration-tests/tests/mysql/ps.ts b/integration-tests/tests/mysql/ps.ts
new file mode 100644
index 0000000000..105a5924f6
--- /dev/null
+++ b/integration-tests/tests/mysql/ps.ts
@@ -0,0 +1,104 @@
+import { setTimeout as delay } from 'node:timers/promises';
+
+const PS_API = 'https://api.planetscale.com/v1';
+const ORG = 'drizzle-team';
+const DB = 'pathtrami';
+const TOKEN = process.env['PS_TOKEN']!; // service token or OAuth bearer
+
+console.log(TOKEN);
+
+type BranchOpts = {
+	name?: string;
+	parentBranch?: string; // usually "main"
+	region?: string; // optional; defaults to DB's default region
+	// For Data Branching® (clone schema+data) use one of:
+	backupId?: string; // create from a specific backup
+	restorePoint?: string; // RFC3339 timestamp
+};
+
+async function ps<T = any>(path: string, init?: RequestInit): Promise<T> {
+	const res = await fetch(`${PS_API}${path}`, {
+		...init,
+		headers: {
+			Authorization: TOKEN,
+			'Content-Type': 'application/json',
+			...init?.headers,
+		},
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`[${res.status}] ${res.statusText} — ${body}`);
+	}
+	return res.json() as Promise<T>;
+}
+
+export async function createBranch(opts: BranchOpts = {}) {
+	const name = opts.name ?? `test_${Date.now().toString(36)}`;
+	const result = await ps(
+		`/organizations/${ORG}/databases/${DB}/branches`,
+		{
+			method: 'POST',
+			body: JSON.stringify({
+				name,
+				parent_branch: opts.parentBranch ?? 'main',
+				region: opts.region,
+				backup_id: opts.backupId,
+				restore_point: opts.restorePoint,
+			}),
+		},
+	);
+
+	console.time();
+	for (let i = 0; i < 60; i++) {
+		const b = await ps<{ state: string }>(
+			`/organizations/${ORG}/databases/${DB}/branches/${name}`,
+		);
+		if (b.state?.toLowerCase() === 'ready') break;
+		await delay(1000); // ~1–7s total typical
+	}
+	console.timeEnd();
+
+	return result;
+}
+
+export async function createEphemeralPassword(branch: string, ttlSeconds = 3600) {
+	// role: "writer" for tests that need DDL/DML; "reader" routes to replicas
+	const p = await ps<{
+		username: string;
+		plaintext: string;
+		access_host_url: string;
+	}>(
+		`/organizations/${ORG}/databases/${DB}/branches/${branch}/passwords`,
+		{
+			method: 'POST',
+			body: JSON.stringify({
+				name: `pw_${branch}`,
+				role: 'writer',
+				ttl: ttlSeconds, // auto-expires to reduce cleanup needs
+				replica: false,
+			}),
+		},
+	);
+
+	// Build a standard MySQL connection URL
+	const url = `mysql://${encodeURIComponent(p.username)}:${
+		encodeURIComponent(
+			p.plaintext,
+		)
+	}@${p.access_host_url}/?ssl={"rejectUnauthorized":true}`;
+	return { ...p, url };
+}
+
+export async function deleteBranch(branch: string) {
+	await ps(
+		`/organizations/${ORG}/databases/${DB}/branches/${branch}`,
+		{ method: 'DELETE' },
+	);
+}
+
+export async function listBranches() {
+	await ps(
+		`/organizations/${ORG}/databases/${DB}/branches/`,
+		{ method: 'GET' },
+	);
+}
diff --git a/integration-tests/tests/mysql/relations.ts b/integration-tests/tests/mysql/relations.ts
new file mode 100644
index 0000000000..1e7748c064
--- /dev/null
+++ b/integration-tests/tests/mysql/relations.ts
@@ -0,0 +1,14 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './schema';
+
+export default defineRelations(schema, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/mysql/replicas.test.ts b/integration-tests/tests/mysql/replicas.test.ts
new file mode 100644
index 0000000000..0c6b6581a0
--- /dev/null
+++ b/integration-tests/tests/mysql/replicas.test.ts
@@ -0,0 +1,933 @@
+import { defineRelations, sql } from 'drizzle-orm';
+import { boolean, mysqlTable, serial, text, withReplicas } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = mysqlTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+});
+
+const users = mysqlTable('users', {
+	id: serial('id' as string).primaryKey(),
+});
+
+describe('[select] read replicas mysql', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query = db.$primary.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual('select `id` from `users`');
+
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(query1.toSQL().sql).toEqual('select count(*) as `count` from `users` limit ?');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select({ id: users.id }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.$primary.select().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.select().from(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+});
+
+describe('[selectDistinct] read replicas mysql', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query = db.$primary.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.$primary.selectDistinct().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+});
+
+describe('[with] read replicas mysql', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+		const obj4 = {} as any;
+
+		db.$primary.with(obj1, obj2, obj3, obj4);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+
+		db.with(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		db.with(obj2, obj3);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
+	});
+});
+
+describe('[update] replicas mysql', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		const query1 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('update `users` set `id` = ?');
+
+		const query2 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('update `users` set `id` = ?');
+
+		const query3 = db.$primary.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query3.toSQL().sql).toEqual('update `users` set `id` = ?');
+	});
+});
+
+describe('[delete] replicas mysql', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		const query1 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query1.toSQL().sql).toEqual('delete from `users`');
+
+		const query2 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+		expect(query2.toSQL().sql).toEqual('delete from `users`');
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas mysql', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		const query = db.insert(users).values({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query.toSQL().sql).toEqual('insert into `users` (`id`) values (?)');
+
+		db.insert(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas mysql', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		expect(db.execute(sql``)).rejects.toThrow();
+
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas mysql', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const txFn1 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn1)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
+
+		const txFn2 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn2)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findFirst] read replicas mysql', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const obj = {} as any;
+
+		db.$primary.query.usersTable.findFirst(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const par1 = {} as any;
+
+		db.query.usersTable.findFirst(par1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(par1);
+
+		const query = db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0` limit ?',
+		);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas mysql', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj = {} as any;
+
+		const query = db.$primary.query.usersTable.findMany(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+		expect(query.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+		expect(spyRead2).toHaveBeenCalledWith(obj2);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.$primary.query.usersTable.findMany(obj2);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+});
+
+describe('[$count] read replicas postgres', () => {
+	it('primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$primary.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$count(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$count(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica $count + primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.$count(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$count(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/tests/mysql/schema.ts b/integration-tests/tests/mysql/schema.ts
new file mode 100644
index 0000000000..f1b744ba01
--- /dev/null
+++ b/integration-tests/tests/mysql/schema.ts
@@ -0,0 +1,35 @@
+import { defineRelations } from 'drizzle-orm';
+import { bigint, int, mysqlTable, serial, text, timestamp } from 'drizzle-orm/mysql-core';
+
+export const rqbUser = mysqlTable('user_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
+
+export const rqbPost = mysqlTable('post_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	userId: bigint('user_id', {
+		mode: 'number',
+	}).notNull(),
+	content: text(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
+
+export const empty = mysqlTable('empty', { id: int() });
+
+export const relations = defineRelations({ rqbUser, rqbPost, empty }, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/mysql/schema2.ts b/integration-tests/tests/mysql/schema2.ts
new file mode 100644
index 0000000000..beb14289bb
--- /dev/null
+++ b/integration-tests/tests/mysql/schema2.ts
@@ -0,0 +1,303 @@
+import { sql } from 'drizzle-orm';
+import {
+	bigint,
+	binary,
+	blob,
+	boolean,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	int,
+	json,
+	longblob,
+	longtext,
+	mediumblob,
+	mediumint,
+	mediumtext,
+	type MySqlColumn,
+	mysqlEnum,
+	mysqlSchema,
+	mysqlTable,
+	type MySqlTableWithColumns,
+	real,
+	serial,
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyblob,
+	tinyint,
+	tinytext,
+	uniqueIndex,
+	varbinary,
+	varchar,
+	year,
+} from 'drizzle-orm/mysql-core';
+
+export const allTypesTable = mysqlTable('all_types', {
+	serial: serial('serial'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	bigintString: bigint('bigint_string', {
+		mode: 'string',
+	}),
+	binary: binary('binary'),
+	boolean: boolean('boolean'),
+	char: char('char'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	datetime: datetime('datetime', {
+		mode: 'date',
+	}),
+	datetimeStr: datetime('datetime_str', {
+		mode: 'string',
+	}),
+	decimal: decimal('decimal'),
+	decimalNum: decimal('decimal_num', {
+		precision: 30,
+		mode: 'number',
+	}),
+	decimalBig: decimal('decimal_big', {
+		precision: 30,
+		mode: 'bigint',
+	}),
+	double: double('double'),
+	float: float('float'),
+	int: int('int'),
+	json: json('json'),
+	medInt: mediumint('med_int'),
+	smallInt: smallint('small_int'),
+	real: real('real'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	tinyInt: tinyint('tiny_int'),
+	varbin: varbinary('varbin', {
+		length: 16,
+	}),
+	varchar: varchar('varchar', {
+		length: 255,
+	}),
+	year: year('year'),
+	enum: mysqlEnum('enum', ['enV1', 'enV2']),
+	blob: blob('blob'),
+	tinyblob: tinyblob('tinyblob'),
+	mediumblob: mediumblob('mediumblob'),
+	longblob: longblob('longblob'),
+	stringblob: blob('stringblob', { mode: 'string' }),
+	stringtinyblob: tinyblob('stringtinyblob', { mode: 'string' }),
+	stringmediumblob: mediumblob('stringmediumblob', { mode: 'string' }),
+	stringlongblob: longblob('stringlongblob', { mode: 'string' }),
+});
+
+export const allTypesCodecsTable = mysqlTable('all_types_codecs', {
+	serial: serial('serial'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}).notNull(),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}).notNull(),
+	bigintstr: bigint('bigintstr', {
+		mode: 'string',
+	}).notNull(),
+	binary: binary('binary').notNull(),
+	boolean: boolean('boolean').notNull(),
+	char: char('char').notNull(),
+	date: date('date', {
+		mode: 'date',
+	}).notNull(),
+	datestr: date('datestr', {
+		mode: 'string',
+	}).notNull(),
+	datetime: datetime('datetime', {
+		mode: 'date',
+		fsp: 3,
+	}).notNull(),
+	datetimestr: datetime('datetimestr', {
+		mode: 'string',
+		fsp: 3,
+	}).notNull(),
+	decimal: decimal('decimal').notNull(),
+	decimalnum: decimal('decimalnum', {
+		precision: 30,
+		mode: 'number',
+	}).notNull(),
+	decimalbig: decimal('decimalbig', {
+		precision: 30,
+		mode: 'bigint',
+	}).notNull(),
+	double: double('double').notNull(),
+	float: float('float').notNull(),
+	int: int('int').notNull(),
+	json1: json('json1').notNull(),
+	json2: json('json2').notNull(),
+	json3: json('json3').notNull(),
+	json4: json('json4').notNull(),
+	medint: mediumint('medint').notNull(),
+	smallint: smallint('smallint').notNull(),
+	real: real('real').notNull(),
+	text: text('text').notNull(),
+	tinytext: tinytext('tinytext').notNull(),
+	mediumtext: mediumtext('mediumtext').notNull(),
+	longtext: longtext('longtext').notNull(),
+	time: time('time').notNull(),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+		fsp: 3,
+	}).notNull(),
+	timestampstr: timestamp('timestampstr', {
+		mode: 'string',
+		fsp: 3,
+	}).notNull(),
+	tinyint: tinyint('tinyint').notNull(),
+	varbin: varbinary('varbin', {
+		length: 16,
+	}).notNull(),
+	varchar: varchar('varchar', {
+		length: 255,
+	}).notNull(),
+	year: year('year').notNull(),
+	enum: mysqlEnum('enum', ['enV1', 'enV2']).notNull(),
+	blob: blob('blob').notNull(),
+	tinyblob: tinyblob('tinyblob').notNull(),
+	mediumblob: mediumblob('mediumblob').notNull(),
+	longblob: longblob('longblob').notNull(),
+	stringblob: blob('stringblob', { mode: 'string' }).notNull(),
+	stringtinyblob: tinyblob('stringtinyblob', { mode: 'string' }).notNull(),
+	stringmediumblob: mediumblob('stringmediumblob', { mode: 'string' }).notNull(),
+	stringlongblob: longblob('stringlongblob', { mode: 'string' }).notNull(),
+});
+
+export const createUserTable = (name: string) => {
+	return mysqlTable(name, {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: json('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+	});
+};
+
+export const createCitiesTable = (name: string) =>
+	mysqlTable(name, {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+export const createUsers2Table = (
+	name: string,
+	citiesTable: MySqlTableWithColumns<{
+		name: string;
+		schema: undefined;
+		dialect: 'mysql';
+		columns: { id: MySqlColumn<any> };
+	}>,
+) =>
+	mysqlTable(name, {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').references(() => citiesTable.id),
+	});
+
+export const createUsersOnUpdateTable = (name: string) =>
+	mysqlTable(name, {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		updateCounter: int('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+		updatedAt: datetime('updated_at', { mode: 'date', fsp: 3 }).$onUpdate(() => new Date()),
+		uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper(name)`),
+		alwaysNull: text('always_null').$type<string | null>().$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
+	});
+
+export const createCountTestTable = (name: string) =>
+	mysqlTable(name, {
+		id: int('id').notNull(),
+		name: text('name').notNull(),
+	});
+
+export const datesTable = mysqlTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time', { fsp: 1 }),
+	datetime: datetime('datetime', { fsp: 2 }),
+	datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
+	timestamp: timestamp('timestamp', { fsp: 3 }),
+	timestampAsString: timestamp('timestamp_as_string', { fsp: 3, mode: 'string' }),
+	year: year('year'),
+});
+
+export const coursesTable = mysqlTable('courses', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: int('category_id').references(() => courseCategoriesTable.id),
+});
+
+export const courseCategoriesTable = mysqlTable('course_categories', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+export const createOrdersTable = (name: string) =>
+	mysqlTable(name, {
+		id: serial('id').primaryKey(),
+		region: text('region').notNull(),
+		product: text('product').notNull().$default(() => 'random_string'),
+		amount: int('amount').notNull(),
+		quantity: int('quantity').notNull(),
+	});
+
+export const usersMigratorTable = mysqlTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => [uniqueIndex('').on(table.name).using('btree')]);
+
+// To test aggregate functions
+export const createAggregateTable = (name: string) =>
+	mysqlTable(name, {
+		id: serial('id').notNull(),
+		name: text('name').notNull(),
+		a: int('a'),
+		b: int('b'),
+		c: int('c'),
+		nullOnly: int('null_only'),
+	});
+
+// To test another schema and multischema
+export const mySchema = mysqlSchema(`mySchema`);
+
+export const usersMySchemaTable = mySchema.table('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+});
+
+export const users2MySchemaTable = mySchema.table('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id').references(() => citiesMySchemaTable.id),
+});
+
+export const citiesMySchemaTable = mySchema.table('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
diff --git a/integration-tests/tests/mysql/tidb-serverless.test.ts b/integration-tests/tests/mysql/tidb-serverless.test.ts
index 9121c31de4..7e84042e99 100644
--- a/integration-tests/tests/mysql/tidb-serverless.test.ts
+++ b/integration-tests/tests/mysql/tidb-serverless.test.ts
@@ -1,41 +1,21 @@
-import 'dotenv/config';
-
 import { connect } from '@tidbcloud/serverless';
-import type { TiDBServerlessDatabase } from 'drizzle-orm/tidb-serverless';
+import { sql } from 'drizzle-orm';
+import { getTableConfig } from 'drizzle-orm/mysql-core';
 import { drizzle } from 'drizzle-orm/tidb-serverless';
-import { beforeAll, beforeEach } from 'vitest';
-import { skipTests } from '~/common.ts';
-import { tests } from './mysql-common.ts';
-
-const ENABLE_LOGGING = false;
-
-let db: TiDBServerlessDatabase;
-
-beforeAll(async () => {
-	const connectionString = process.env['TIDB_CONNECTION_STRING'];
-	if (!connectionString) {
-		throw new Error('TIDB_CONNECTION_STRING is not set');
-	}
+import { migrate } from 'drizzle-orm/tidb-serverless/migrator';
+import { describe, expect } from 'vitest';
+import { tidbTest as test } from './instrumentation';
+import { tests } from './mysql-common';
+import { runTests as cacheTests } from './mysql-common-cache';
+import { usersMigratorTable } from './schema2';
 
-	const client = connect({ url: connectionString });
-	db = drizzle(client!, { logger: ENABLE_LOGGING });
-});
-
-beforeEach((ctx) => {
-	ctx.mysql = {
-		db,
-	};
-});
-
-skipTests([
+const skip = new Set([
 	'mySchema :: select with group by as field',
 	'mySchema :: delete with returning all fields',
 	'mySchema :: update with returning partial',
 	'mySchema :: delete returning sql',
 	'mySchema :: insert returning sql',
 	'test $onUpdateFn and $onUpdate works updating',
-	'set operations (mixed all) as function with subquery',
-	'set operations (union) from query builder with subquery',
 	'join on aliased sql from with clause',
 	'join on aliased sql from select',
 	'select from raw sql with joins',
@@ -55,22 +35,214 @@ skipTests([
 	'update returning sql',
 	'delete returning sql',
 	'insert returning sql',
+	'test $onUpdateFn and $onUpdate works as $default',
+	'MySqlTable :: select with join `use index` + `force index` incompatible hints',
+	'MySqlTable :: select with `use index` + `force index` incompatible hints',
 
 	// not supported
+	'set operations (mixed all) as function with subquery',
+	'set operations (union) from query builder with subquery',
 	'set operations (except all) as function',
 	'set operations (except all) from query builder',
 	'set operations (intersect all) as function',
 	'set operations (intersect all) from query builder',
 	'set operations (union all) as function',
+	'set operations (union) as function',
 	'tc config for datetime',
-	'select iterator w/ prepared statement',
-	'select iterator',
 	'transaction',
 	'transaction with options (set isolationLevel)',
 	'Insert all defaults in multiple rows',
 	'Insert all defaults in 1 row',
 	'$default with empty array',
 	'utc config for datetime',
+	'insert into ... select',
+	'RQB v2 transaction find many - with relation',
+	'RQB v2 transaction find first - with relation',
+	'RQB v2 simple find many - with relation',
+	'RQB v2 simple find first - with relation',
+	'cross join (lateral)',
+	'inner join (lateral)',
+	'left join (lateral)',
+	'update with returning all fields + partial',
+	'insert+update+delete returning sql',
+	'RQB v2 find many - bigint precision loss',
+	'select from a one subquery',
+	'all types',
+	'Column as decoder applies codecs',
+	'Column as decoder applies codecs - Jit mappers',
+	'Mappers: relational',
+	'Jit mappers: relational',
 ]);
 
-tests();
+tests(test, skip);
+cacheTests('mysql', test);
+
+describe('migrator', () => {
+	test('migrator', async ({ db }) => {
+		await db.execute(sql`drop table if exists ${sql.identifier('__drizzle_migrations')}`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('migrator : --init', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(!!res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop table if exists ${sql.identifier(migrationsTable)} cascade;`);
+		await db.execute(sql`drop table if exists ${usersMigratorTable}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('cities_migration')}`);
+		await db.execute(sql`drop table if exists ${sql.identifier('users_migration')}`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/mysql',
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/mysql-init',
+			migrationsTable,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean | number }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM INFORMATION_SCHEMA.TABLES
+				WHERE TABLE_NAME = ${getTableConfig(usersMigratorTable).name}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(!!res.rows[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('managing multiple databases #1', async ({ db }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('create database drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle2;');
+
+		await db.execute(`use drizzle1`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		await db.execute(`use drizzle2`);
+		await migrate(db, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle2
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db.select().from(usersMigratorTable);
+
+		// drizzle1
+		await db.execute(`use drizzle1`);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db.select().from(usersMigratorTable);
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+
+	test('managing multiple databases #2', async ({ db }) => {
+		await db.execute('drop database if exists drizzle1;');
+		await db.execute('drop database if exists drizzle2;');
+		await db.execute('create database drizzle1;');
+		await db.execute('create database drizzle2;');
+
+		const client1 = connect({ url: process.env['TIDB_CONNECTION_STRING'], database: 'drizzle1' });
+		const client2 = connect({ url: process.env['TIDB_CONNECTION_STRING'], database: 'drizzle2' });
+
+		const db1 = drizzle({ client: client1 });
+		const db2 = drizzle({ client: client2 });
+
+		await migrate(db1, { migrationsFolder: './drizzle2/mysql' });
+		await migrate(db2, { migrationsFolder: './drizzle2/mysql' });
+
+		// drizzle1
+		await db1.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result1 = await db1.select().from(usersMigratorTable);
+
+		// drizzle2
+		await db2.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result2 = await db2.select().from(usersMigratorTable);
+
+		await db.execute('drop database drizzle1;');
+		await db.execute('drop database drizzle2;');
+
+		expect(result1).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	});
+});
diff --git a/integration-tests/tests/mysql/utils.ts b/integration-tests/tests/mysql/utils.ts
new file mode 100644
index 0000000000..264ec18163
--- /dev/null
+++ b/integration-tests/tests/mysql/utils.ts
@@ -0,0 +1,37 @@
+import { Column } from 'drizzle-orm';
+import { CodecsCollection } from 'drizzle-orm/codecs';
+import { MySqlAsyncDatabase, MySqlDialect } from 'drizzle-orm/mysql-core';
+import { MySqlEffectDatabase } from 'drizzle-orm/mysql-core/effect/db';
+
+export function normalizeDataWithDbCodecs(
+	cfg: {
+		db: MySqlAsyncDatabase<any, any> | MySqlEffectDatabase<any, any, any>;
+		data: Record<string, unknown>[] | string;
+		columns: Record<string, Column>;
+		mode: 'json' | 'query';
+	},
+) {
+	const { db, data: rawData, columns, mode } = cfg;
+	const dialect = (<any> db).dialect as MySqlDialect;
+	const codecs = (<any> dialect).codecs as CodecsCollection;
+	const data = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
+
+	const dbNamedColumns = Object.values(columns).map((c) => {
+		return [c.name, c];
+	}) as [string, Column][];
+
+	const res: Record<string, any>[] = [];
+	for (const item of data) {
+		const current: Record<string, any> = {};
+
+		for (const [k, v] of dbNamedColumns) {
+			current[k] = item[k] === null
+				? item[k]
+				: codecs.apply(v, mode === 'query' ? 'normalize' : 'normalizeInJson', item[k]!);
+		}
+
+		res.push(current);
+	}
+
+	return res;
+}
diff --git a/integration-tests/tests/pg/awsdatapi.test.ts b/integration-tests/tests/pg/awsdatapi.test.ts
index 3bb884c0c3..2813963ded 100644
--- a/integration-tests/tests/pg/awsdatapi.test.ts
+++ b/integration-tests/tests/pg/awsdatapi.test.ts
@@ -1,1619 +1,2592 @@
-import 'dotenv/config';
-
-import { RDSDataClient } from '@aws-sdk/client-rds-data';
-import * as dotenv from 'dotenv';
-import { asc, eq, inArray, notInArray, relations, sql, TransactionRollbackError } from 'drizzle-orm';
-import type { AwsDataApiPgDatabase } from 'drizzle-orm/aws-data-api/pg';
-import { drizzle } from 'drizzle-orm/aws-data-api/pg';
-import { migrate } from 'drizzle-orm/aws-data-api/pg/migrator';
-import {
-	alias,
-	boolean,
-	date,
-	integer,
-	jsonb,
-	pgTable,
-	pgTableCreator,
-	serial,
-	text,
-	time,
-	timestamp,
-	uuid,
-} from 'drizzle-orm/pg-core';
-import { Resource } from 'sst';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-
-import type { Equal } from '../utils.ts';
-import { Expect, randomString } from '../utils.ts';
-
-dotenv.config();
-
-const ENABLE_LOGGING = false;
-
-const usersTable = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: jsonb('jsonb').$type<string[]>(),
-	bestTexts: text('best_texts')
-		.array()
-		.default(sql`'{}'`)
-		.notNull(),
-	createdAt: timestamp('created_at', { withTimezone: true })
-		.notNull()
-		.defaultNow(),
-});
-
-const usersMigratorTable = pgTable('users12', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-});
-
-const todo = pgTable('todo', {
-	id: uuid('id').primaryKey(),
-	title: text('title').notNull(),
-	description: text('description'),
-});
-
-const todoRelations = relations(todo, (ctx) => ({
-	user: ctx.many(todoUser),
-}));
-
-const user = pgTable('user', {
-	id: uuid('id').primaryKey(),
-	email: text('email').notNull(),
-});
-
-const userRelations = relations(user, (ctx) => ({
-	todos: ctx.many(todoUser),
-}));
-
-const todoUser = pgTable('todo_user', {
-	todoId: uuid('todo_id').references(() => todo.id),
-	userId: uuid('user_id').references(() => user.id),
-});
-
-const todoToGroupRelations = relations(todoUser, (ctx) => ({
-	todo: ctx.one(todo, {
-		fields: [todoUser.todoId],
-		references: [todo.id],
-	}),
-	user: ctx.one(user, {
-		fields: [todoUser.userId],
-		references: [user.id],
-	}),
-}));
-
-const schema = {
-	todo,
-	todoRelations,
-	user,
-	userRelations,
-	todoUser,
-	todoToGroupRelations,
-};
-
-let db: AwsDataApiPgDatabase<typeof schema>;
-
-beforeAll(async () => {
-	const rdsClient = new RDSDataClient();
-
-	db = drizzle(rdsClient, {
-		// @ts-ignore
-		database: Resource.Postgres.database,
-		// @ts-ignore
-		secretArn: Resource.Postgres.secretArn,
-		// @ts-ignore
-		resourceArn: Resource.Postgres.clusterArn,
-		logger: ENABLE_LOGGING,
-		schema,
-	});
-});
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				best_texts text[] not null default '{}',
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table todo (
-				id uuid primary key,
-				title text not null,
-				description text
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table "user" (
-				id uuid primary key,
-				email text not null
-			)
-
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table todo_user (
-				todo_id uuid references todo(id),
-				user_id uuid references "user"(id)
-			)
-		`,
-	);
-});
-
-test('select all fields', async () => {
-	const insertResult = await db.insert(usersTable).values({ name: 'John' });
-
-	expect(insertResult.numberOfRecordsUpdated).toBe(1);
-
-	const result = await db.select().from(usersTable);
-
-	expect(result[0]!.createdAt).toBeInstanceOf(Date);
-	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 100);
-	expect(result).toEqual([
-		{
-			bestTexts: [],
-			id: 1,
-			name: 'John',
-			verified: false,
-			jsonb: null,
-			createdAt: result[0]!.createdAt,
-		},
-	]);
-});
-
-test('select sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.select({
-			name: sql`upper(${usersTable.name})`,
-		})
-		.from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('select with empty array in inArray', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-	const users = await db
-		.select({
-			name: sql`upper(${usersTable.name})`,
-		})
-		.from(usersTable)
-		.where(inArray(usersTable.id, []));
-
-	expect(users).toEqual([]);
-});
-
-test('select with empty array in notInArray', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-	const result = await db
-		.select({
-			name: sql`upper(${usersTable.name})`,
-		})
-		.from(usersTable)
-		.where(notInArray(usersTable.id, []));
-
-	expect(result).toEqual([
-		{ name: 'JOHN' },
-		{ name: 'JANE' },
-		{ name: 'JANE' },
-	]);
-});
-
-test('select typed sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.select({
-			name: sql<string>`upper(${usersTable.name})`,
-		})
-		.from(usersTable);
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('select distinct', async () => {
-	const usersDistinctTable = pgTable('users_distinct', {
-		id: integer('id').notNull(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-	await db.execute(
-		sql`create table ${usersDistinctTable} (id integer, name text)`,
-	);
-
-	await db.insert(usersDistinctTable).values([
-		{ id: 1, name: 'John' },
-		{ id: 1, name: 'John' },
-		{ id: 2, name: 'John' },
-		{ id: 1, name: 'Jane' },
-	]);
-	const users1 = await db
-		.selectDistinct()
-		.from(usersDistinctTable)
-		.orderBy(usersDistinctTable.id, usersDistinctTable.name);
-	const users2 = await db
-		.selectDistinctOn([usersDistinctTable.id])
-		.from(usersDistinctTable)
-		.orderBy(usersDistinctTable.id);
-	const users3 = await db
-		.selectDistinctOn([usersDistinctTable.name], {
-			name: usersDistinctTable.name,
-		})
-		.from(usersDistinctTable)
-		.orderBy(usersDistinctTable.name);
-
-	await db.execute(sql`drop table ${usersDistinctTable}`);
-
-	expect(users1).toEqual([
-		{ id: 1, name: 'Jane' },
-		{ id: 1, name: 'John' },
-		{ id: 2, name: 'John' },
-	]);
-
-	expect(users2.length).toEqual(2);
-	expect(users2[0]?.id).toEqual(1);
-	expect(users2[1]?.id).toEqual(2);
-
-	expect(users3.length).toEqual(2);
-	expect(users3[0]?.name).toEqual('Jane');
-	expect(users3[1]?.name).toEqual('John');
-});
-
-test('insert returning sql', async () => {
-	const users = await db
-		.insert(usersTable)
-		.values({ name: 'John' })
-		.returning({
-			name: sql`upper(${usersTable.name})`,
-		});
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('delete returning sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.delete(usersTable)
-		.where(eq(usersTable.name, 'John'))
-		.returning({
-			name: sql`upper(${usersTable.name})`,
-		});
-
-	expect(users).toEqual([{ name: 'JOHN' }]);
-});
-
-test('update returning sql', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.update(usersTable)
-		.set({ name: 'Jane' })
-		.where(eq(usersTable.name, 'John'))
-		.returning({
-			name: sql`upper(${usersTable.name})`,
-		});
-
-	expect(users).toEqual([{ name: 'JANE' }]);
-});
-
-test('update with returning all fields', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.update(usersTable)
-		.set({ name: 'Jane' })
-		.where(eq(usersTable.name, 'John'))
-		.returning();
-
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
-	expect(users).toEqual([
-		{
-			id: 1,
-			bestTexts: [],
-			name: 'Jane',
-			verified: false,
-			jsonb: null,
-			createdAt: users[0]!.createdAt,
-		},
-	]);
-});
-
-test('update with returning partial', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.update(usersTable)
-		.set({ name: 'Jane' })
-		.where(eq(usersTable.name, 'John'))
-		.returning({
-			id: usersTable.id,
-			name: usersTable.name,
-		});
-
-	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-});
-
-test('delete with returning all fields', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.delete(usersTable)
-		.where(eq(usersTable.name, 'John'))
-		.returning();
-
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
-	expect(users).toEqual([
-		{
-			bestTexts: [],
-			id: 1,
-			name: 'John',
-			verified: false,
-			jsonb: null,
-			createdAt: users[0]!.createdAt,
-		},
-	]);
-});
-
-test('delete with returning partial', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.delete(usersTable)
-		.where(eq(usersTable.name, 'John'))
-		.returning({
-			id: usersTable.id,
-			name: usersTable.name,
-		});
-
-	expect(users).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert + select', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const result = await db.select().from(usersTable);
-	expect(result).toEqual([
-		{
-			bestTexts: [],
-			id: 1,
-			name: 'John',
-			verified: false,
-			jsonb: null,
-			createdAt: result[0]!.createdAt,
-		},
-	]);
-
-	await db.insert(usersTable).values({ name: 'Jane' });
-	const result2 = await db.select().from(usersTable);
-	expect(result2).toEqual([
-		{
-			bestTexts: [],
-			id: 1,
-			name: 'John',
-			verified: false,
-			jsonb: null,
-			createdAt: result2[0]!.createdAt,
-		},
-		{
-			bestTexts: [],
-			id: 2,
-			name: 'Jane',
-			verified: false,
-			jsonb: null,
-			createdAt: result2[1]!.createdAt,
-		},
-	]);
-});
-
-test('json insert', async () => {
-	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
-	const result = await db
-		.select({
-			id: usersTable.id,
-			name: usersTable.name,
-			jsonb: usersTable.jsonb,
-		})
-		.from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
-});
-
-test('insert with overridden default values', async () => {
-	await db.insert(usersTable).values({ name: 'John', verified: true });
-	const result = await db.select().from(usersTable);
-
-	expect(result).toEqual([
-		{
-			bestTexts: [],
-			id: 1,
-			name: 'John',
-			verified: true,
-			jsonb: null,
-			createdAt: result[0]!.createdAt,
-		},
-	]);
-});
-
-test('insert many', async () => {
-	await db
-		.insert(usersTable)
-		.values([
-			{ name: 'John' },
-			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-			{ name: 'Jane' },
-			{ name: 'Austin', verified: true },
-		]);
-	const result = await db
-		.select({
-			id: usersTable.id,
-			name: usersTable.name,
-			jsonb: usersTable.jsonb,
-			verified: usersTable.verified,
-		})
-		.from(usersTable);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', jsonb: null, verified: false },
-		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-		{ id: 3, name: 'Jane', jsonb: null, verified: false },
-		{ id: 4, name: 'Austin', jsonb: null, verified: true },
-	]);
-});
-
-test('insert many with returning', async () => {
-	const result = await db
-		.insert(usersTable)
-		.values([
-			{ name: 'John' },
-			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-			{ name: 'Jane' },
-			{ name: 'Austin', verified: true },
-		])
-		.returning({
-			id: usersTable.id,
-			name: usersTable.name,
-			jsonb: usersTable.jsonb,
-			verified: usersTable.verified,
-		});
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John', jsonb: null, verified: false },
-		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-		{ id: 3, name: 'Jane', jsonb: null, verified: false },
-		{ id: 4, name: 'Austin', jsonb: null, verified: true },
-	]);
-});
-
-test('select with group by as field', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db
-		.select({ name: usersTable.name })
-		.from(usersTable)
-		.groupBy(usersTable.name);
-
-	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-});
-
-test('select with group by as sql', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db
-		.select({ name: usersTable.name })
-		.from(usersTable)
-		.groupBy(sql`${usersTable.name}`);
-
-	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-});
-
-test('select with group by as sql + column', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db
-		.select({ name: usersTable.name })
-		.from(usersTable)
-		.groupBy(sql`${usersTable.name}`, usersTable.id);
-
-	expect(result).toEqual([
-		{ name: 'Jane' },
-		{ name: 'Jane' },
-		{ name: 'John' },
-	]);
-});
-
-test('select with group by as column + sql', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db
-		.select({ name: usersTable.name })
-		.from(usersTable)
-		.groupBy(usersTable.id, sql`${usersTable.name}`);
-
-	expect(result).toEqual([
-		{ name: 'Jane' },
-		{ name: 'Jane' },
-		{ name: 'John' },
-	]);
-});
-
-test('select with group by complex query', async () => {
-	await db
-		.insert(usersTable)
-		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-	const result = await db
-		.select({ name: usersTable.name })
-		.from(usersTable)
-		.groupBy(usersTable.id, sql`${usersTable.name}`)
-		.orderBy(asc(usersTable.name))
-		.limit(1);
-
-	expect(result).toEqual([{ name: 'Jane' }]);
-});
-
-test('build query', async () => {
-	const query = db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable)
-		.groupBy(usersTable.id, usersTable.name)
-		.toSQL();
-
-	expect(query).toEqual({
-		sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
-		params: [],
-		// typings: []
-	});
-});
-
-test('insert sql', async () => {
-	await db.insert(usersTable).values({ name: sql`${'John'}` });
-	const result = await db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable);
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('partial join with alias', async () => {
-	const customerAlias = alias(usersTable, 'customer');
-
-	await db.insert(usersTable).values([
-		{ id: 10, name: 'Ivan' },
-		{ id: 11, name: 'Hans' },
-	]);
-	const result = await db
-		.select({
-			user: {
-				id: usersTable.id,
-				name: usersTable.name,
-			},
-			customer: {
-				id: customerAlias.id,
-				name: customerAlias.name,
-			},
-		})
-		.from(usersTable)
-		.leftJoin(customerAlias, eq(customerAlias.id, 11))
-		.where(eq(usersTable.id, 10));
-
-	expect(result).toEqual([
-		{
-			user: { id: 10, name: 'Ivan' },
-			customer: { id: 11, name: 'Hans' },
-		},
-	]);
-});
-
-test('full join with alias', async () => {
-	const customerAlias = alias(usersTable, 'customer');
-
-	await db.insert(usersTable).values([
-		{ id: 10, name: 'Ivan' },
-		{ id: 11, name: 'Hans' },
-	]);
-
-	const result = await db
-		.select()
-		.from(usersTable)
-		.leftJoin(customerAlias, eq(customerAlias.id, 11))
-		.where(eq(usersTable.id, 10));
-
-	expect(result).toEqual([
-		{
-			users: {
-				id: 10,
-				bestTexts: [],
-				name: 'Ivan',
-				verified: false,
-				jsonb: null,
-				createdAt: result[0]!.users.createdAt,
-			},
-			customer: {
-				bestTexts: [],
-				id: 11,
-				name: 'Hans',
-				verified: false,
-				jsonb: null,
-				createdAt: result[0]!.customer!.createdAt,
-			},
-		},
-	]);
-});
-
-test('select from alias', async () => {
-	const pgTable = pgTableCreator((name) => `prefixed_${name}`);
-
-	const users = pgTable('users', {
-		id: serial('id').primaryKey(),
-		name: text('name').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(
-		sql`create table ${users} (id serial primary key, name text not null)`,
-	);
-
-	const user = alias(users, 'user');
-	const customers = alias(users, 'customer');
-
-	await db.insert(users).values([
-		{ id: 10, name: 'Ivan' },
-		{ id: 11, name: 'Hans' },
-	]);
-	const result = await db
-		.select()
-		.from(user)
-		.leftJoin(customers, eq(customers.id, 11))
-		.where(eq(user.id, 10));
-
-	expect(result).toEqual([
-		{
-			user: {
-				id: 10,
-				name: 'Ivan',
-			},
-			customer: {
-				id: 11,
-				name: 'Hans',
-			},
-		},
-	]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('insert with spaces', async () => {
-	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
-	const result = await db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable);
-
-	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-});
-
-test('prepared statement', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const statement = db
-		.select({
-			id: usersTable.id,
-			name: usersTable.name,
-		})
-		.from(usersTable)
-		.prepare('statement1');
-	const result = await statement.execute();
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('prepared statement reuse', async () => {
-	const stmt = db
-		.insert(usersTable)
-		.values({
-			verified: true,
-			name: sql.placeholder('name'),
-		})
-		.prepare('stmt2');
-
-	for (let i = 0; i < 10; i++) {
-		await stmt.execute({ name: `John ${i}` });
-	}
-
-	const result = await db
-		.select({
-			id: usersTable.id,
-			name: usersTable.name,
-			verified: usersTable.verified,
-		})
-		.from(usersTable);
-
-	expect(result).toEqual([
-		{ id: 1, name: 'John 0', verified: true },
-		{ id: 2, name: 'John 1', verified: true },
-		{ id: 3, name: 'John 2', verified: true },
-		{ id: 4, name: 'John 3', verified: true },
-		{ id: 5, name: 'John 4', verified: true },
-		{ id: 6, name: 'John 5', verified: true },
-		{ id: 7, name: 'John 6', verified: true },
-		{ id: 8, name: 'John 7', verified: true },
-		{ id: 9, name: 'John 8', verified: true },
-		{ id: 10, name: 'John 9', verified: true },
-	]);
-});
-
-test('prepared statement with placeholder in .where', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-	const stmt = db
-		.select({
-			id: usersTable.id,
-			name: usersTable.name,
-		})
-		.from(usersTable)
-		.where(eq(usersTable.id, sql.placeholder('id')))
-		.prepare('stmt3');
-	const result = await stmt.execute({ id: 1 });
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
-
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-
-	const result = await db.select().from(usersMigratorTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
-
-test('migrator : migrate with custom schema', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsSchema: 'custom_migrations',
-	});
-
-	// test if the custom migrations table was created
-	const { rows } = await db.execute(
-		sql`select * from custom_migrations."__drizzle_migrations";`,
-	);
-	expect(rows).toBeTruthy();
-	expect(rows!.length).toBeGreaterThan(0);
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(
-		sql`drop table custom_migrations."__drizzle_migrations"`,
-	);
-});
-
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-	});
-
-	// test if the custom migrations table was created
-	const { rows } = await db.execute(
-		sql`select * from "drizzle".${sql.identifier(customTable)};`,
-	);
-	expect(rows).toBeTruthy();
-	expect(rows!.length).toBeGreaterThan(0);
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
-
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: 'custom_migrations',
-	});
-
-	// test if the custom migrations table was created
-	const { rows } = await db.execute(
-		sql`select * from custom_migrations.${
-			sql.identifier(
-				customTable,
-			)
-		};`,
-	);
-	expect(rows).toBeTruthy();
-	expect(rows!.length).toBeGreaterThan(0);
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(
-		sql`drop table custom_migrations.${
-			sql.identifier(
-				customTable,
-			)
-		}`,
-	);
-});
-
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'})`,
-	);
-
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expectTypeOf(result.rows).toEqualTypeOf<{ id: number; name: string }[]>();
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('build query insert with onConflict do update', async () => {
-	const query = db
-		.insert(usersTable)
-		.values({ name: 'John', jsonb: ['foo', 'bar'] })
-		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
-		.toSQL();
-
-	expect(query).toEqual({
-		sql:
-			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1, default, :2, default, default) on conflict ("id") do update set "name" = :3',
-		params: ['John', '["foo","bar"]', 'John1'],
-		// typings: ['none', 'json', 'none']
-	});
-});
-
-test('build query insert with onConflict do update / multiple columns', async () => {
-	const query = db
-		.insert(usersTable)
-		.values({ name: 'John', jsonb: ['foo', 'bar'] })
-		.onConflictDoUpdate({
-			target: [usersTable.id, usersTable.name],
-			set: { name: 'John1' },
-		})
-		.toSQL();
-
-	expect(query).toEqual({
-		sql:
-			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1, default, :2, default, default) on conflict ("id","name") do update set "name" = :3',
-		params: ['John', '["foo","bar"]', 'John1'],
-		// typings: ['none', 'json', 'none']
-	});
-});
-
-test('build query insert with onConflict do nothing', async () => {
-	const query = db
-		.insert(usersTable)
-		.values({ name: 'John', jsonb: ['foo', 'bar'] })
-		.onConflictDoNothing()
-		.toSQL();
-
-	expect(query).toEqual({
-		sql:
-			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1, default, :2, default, default) on conflict do nothing',
-		params: ['John', '["foo","bar"]'],
-		// typings: ['none', 'json']
-	});
-});
-
-test('build query insert with onConflict do nothing + target', async () => {
-	const query = db
-		.insert(usersTable)
-		.values({ name: 'John', jsonb: ['foo', 'bar'] })
-		.onConflictDoNothing({ target: usersTable.id })
-		.toSQL();
-
-	expect(query).toEqual({
-		sql:
-			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1, default, :2, default, default) on conflict ("id") do nothing',
-		params: ['John', '["foo","bar"]'],
-		// typings: ['none', 'json']
-	});
-});
-
-test('insert with onConflict do update', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-
-	await db
-		.insert(usersTable)
-		.values({ id: 1, name: 'John' })
-		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
-
-	const res = await db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable)
-		.where(eq(usersTable.id, 1));
-
-	expect(res).toEqual([{ id: 1, name: 'John1' }]);
-});
-
-test('insert with onConflict do nothing', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-
-	await db
-		.insert(usersTable)
-		.values({ id: 1, name: 'John' })
-		.onConflictDoNothing();
-
-	const res = await db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable)
-		.where(eq(usersTable.id, 1));
-
-	expect(res).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert with onConflict do nothing + target', async () => {
-	await db.insert(usersTable).values({ name: 'John' });
-
-	await db
-		.insert(usersTable)
-		.values({ id: 1, name: 'John' })
-		.onConflictDoNothing({ target: usersTable.id });
-
-	const res = await db
-		.select({ id: usersTable.id, name: usersTable.name })
-		.from(usersTable)
-		.where(eq(usersTable.id, 1));
-
-	expect(res).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('transaction', async () => {
-	const users = pgTable('users_transactions', {
-		id: serial('id').primaryKey(),
-		balance: integer('balance').notNull(),
-	});
-	const products = pgTable('products_transactions', {
-		id: serial('id').primaryKey(),
-		price: integer('price').notNull(),
-		stock: integer('stock').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-	await db.execute(sql`drop table if exists ${products}`);
-
-	await db.execute(
-		sql`create table users_transactions (id serial not null primary key, balance integer not null)`,
-	);
-	await db.execute(
-		sql`create table products_transactions (id serial not null primary key, price integer not null, stock integer not null)`,
-	);
-
-	const user = await db
-		.insert(users)
-		.values({ balance: 100 })
-		.returning()
-		.then((rows) => rows[0]!);
-	const product = await db
-		.insert(products)
-		.values({ price: 10, stock: 10 })
-		.returning()
-		.then((rows) => rows[0]!);
-
-	await db.transaction(async (tx) => {
-		await tx
-			.update(users)
-			.set({ balance: user.balance - product.price })
-			.where(eq(users.id, user.id));
-		await tx
-			.update(products)
-			.set({ stock: product.stock - 1 })
-			.where(eq(products.id, product.id));
-	});
-
-	const result = await db.select().from(users);
-
-	expect(result).toEqual([{ id: 1, balance: 90 }]);
-
-	await db.execute(sql`drop table ${users}`);
-	await db.execute(sql`drop table ${products}`);
-});
-
-test('transaction rollback', async () => {
-	const users = pgTable('users_transactions_rollback', {
-		id: serial('id').primaryKey(),
-		balance: integer('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table users_transactions_rollback (id serial not null primary key, balance integer not null)`,
-	);
-
-	await expect(
-		db.transaction(async (tx) => {
-			await tx.insert(users).values({ balance: 100 });
-			tx.rollback();
-		}),
-	).rejects.toThrowError(TransactionRollbackError);
-
-	const result = await db.select().from(users);
-
-	expect(result).toEqual([]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('nested transaction', async () => {
-	const users = pgTable('users_nested_transactions', {
-		id: serial('id').primaryKey(),
-		balance: integer('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table users_nested_transactions (id serial not null primary key, balance integer not null)`,
-	);
-
-	await db.transaction(async (tx) => {
-		await tx.insert(users).values({ balance: 100 });
-
-		await tx.transaction(async (tx) => {
-			await tx.update(users).set({ balance: 200 });
-		});
-	});
-
-	const result = await db.select().from(users);
-
-	expect(result).toEqual([{ id: 1, balance: 200 }]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('nested transaction rollback', async () => {
-	const users = pgTable('users_nested_transactions_rollback', {
-		id: serial('id').primaryKey(),
-		balance: integer('balance').notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${users}`);
-
-	await db.execute(
-		sql`create table users_nested_transactions_rollback (id serial not null primary key, balance integer not null)`,
-	);
-
-	await db.transaction(async (tx) => {
-		await tx.insert(users).values({ balance: 100 });
-
-		await expect(
-			tx.transaction(async (tx2) => {
-				await tx2.update(users).set({ balance: 200 });
-				tx2.rollback();
-			}),
-		).rejects.toThrowError(TransactionRollbackError);
-	});
-
-	const result = await db.select().from(users);
-
-	expect(result).toEqual([{ id: 1, balance: 100 }]);
-
-	await db.execute(sql`drop table ${users}`);
-});
-
-test('select from raw sql', async () => {
-	const result = await db.execute(sql`select 1 as id, 'John' as name`);
-
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('select from raw sql with mapped values', async () => {
-	const result = await db
-		.select({
-			id: sql<number>`id`,
-			name: sql<string>`name`,
-		})
-		.from(sql`(select 1 as id, 'John' as name) as users`);
-
-	expect(result).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert with array values works', async () => {
-	const bestTexts = ['text1', 'text2', 'text3'];
-	const [insertResult] = await db
-		.insert(usersTable)
-		.values({
-			name: 'John',
-			bestTexts,
-		})
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('update with array values works', async () => {
-	const [newUser] = await db
-		.insert(usersTable)
-		.values({ name: 'John' })
-		.returning();
-
-	const bestTexts = ['text4', 'text5', 'text6'];
-	const [insertResult] = await db
-		.update(usersTable)
-		.set({
-			bestTexts,
-		})
-		.where(eq(usersTable.id, newUser!.id))
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('insert with array values works', async () => {
-	const bestTexts = ['text1', 'text2', 'text3'];
-	const [insertResult] = await db
-		.insert(usersTable)
-		.values({
-			name: 'John',
-			bestTexts,
-		})
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('update with array values works', async () => {
-	const [newUser] = await db
-		.insert(usersTable)
-		.values({ name: 'John' })
-		.returning();
-
-	const bestTexts = ['text4', 'text5', 'text6'];
-	const [insertResult] = await db
-		.update(usersTable)
-		.set({
-			bestTexts,
-		})
-		.where(eq(usersTable.id, newUser!.id))
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('insert with array values works', async () => {
-	const bestTexts = ['text1', 'text2', 'text3'];
-	const [insertResult] = await db
-		.insert(usersTable)
-		.values({
-			name: 'John',
-			bestTexts,
-		})
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('update with array values works', async () => {
-	const [newUser] = await db
-		.insert(usersTable)
-		.values({ name: 'John' })
-		.returning();
-
-	const bestTexts = ['text4', 'text5', 'text6'];
-	const [insertResult] = await db
-		.update(usersTable)
-		.set({
-			bestTexts,
-		})
-		.where(eq(usersTable.id, newUser!.id))
-		.returning();
-
-	expect(insertResult?.bestTexts).toEqual(bestTexts);
-});
-
-test('all date and time columns', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		dateString: date('date_string', { mode: 'string' }).notNull(),
-		time: time('time', { precision: 3 }).notNull(),
-		datetime: timestamp('datetime').notNull(),
-		// datetimeWTZ: timestamp('datetime_wtz', { withTimezone: true }).notNull(),
-		datetimeString: timestamp('datetime_string', { mode: 'string' }).notNull(),
-		datetimeFullPrecision: timestamp('datetime_full_precision', {
-			precision: 6,
-			mode: 'string',
-		}).notNull(),
-		// datetimeWTZString: timestamp('datetime_wtz_string', { withTimezone: true, mode: 'string' }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					date_string date not null,
-					time time(3) not null,
-					datetime timestamp not null,
-					-- datetime_wtz timestamp with time zone not null,
-					datetime_string timestamp not null,
-					datetime_full_precision timestamp(6) not null
-					-- datetime_wtz_string timestamp with time zone not null
-			)
-	`);
-
-	const someDatetime = new Date('2022-01-01T00:00:00.123Z');
-	const fullPrecision = '2022-01-01T00:00:00.123456';
-	const someTime = '23:23:12.432';
-
-	await db.insert(table).values({
-		dateString: '2022-01-01',
-		time: someTime,
-		datetime: someDatetime,
-		// datetimeWTZ: someDatetime,
-		datetimeString: '2022-01-01T00:00:00.123Z',
-		datetimeFullPrecision: fullPrecision,
-		// datetimeWTZString: '2022-01-01T00:00:00.123Z',
-	});
-
-	const result = await db.select().from(table);
-
-	Expect<
-		Equal<
-			{
-				id: number;
-				dateString: string;
-				time: string;
-				datetime: Date;
-				// datetimeWTZ: Date;
-				datetimeString: string;
-				datetimeFullPrecision: string;
-				// datetimeWTZString: string;
-			}[],
-			typeof result
-		>
-	>;
-
-	Expect<
-		Equal<
-			{
-				dateString: string;
-				time: string;
-				datetime: Date;
-				// datetimeWTZ: Date;
-				datetimeString: string;
-				datetimeFullPrecision: string;
-				// datetimeWTZString: string;
-				id?: number | undefined;
-			},
-			typeof table.$inferInsert
-		>
-	>;
-
-	expect(result).toEqual([
-		{
-			id: 1,
-			dateString: '2022-01-01',
-			time: someTime,
-			datetime: someDatetime,
-			// datetimeWTZ: someDatetime,
-			datetimeString: '2022-01-01 00:00:00.123',
-			datetimeFullPrecision: fullPrecision.replace('T', ' ').replace('Z', ''),
-			// datetimeWTZString: '2022-01-01 00:00:00.123+00',
-		},
-	]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test.skip('all date and time columns with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', {
-			mode: 'string',
-			withTimezone: true,
-			precision: 6,
-		}).notNull(),
-		timestampAsDate: timestamp('timestamp_date', {
-			withTimezone: true,
-			precision: 3,
-		}).notNull(),
-		timestampTimeZones: timestamp('timestamp_date_2', {
-			withTimezone: true,
-			precision: 3,
-		}).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null,
-					timestamp_date timestamp(3) with time zone not null,
-					timestamp_date_2 timestamp(3) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
-	const timestampDate = new Date();
-	const timestampDateWTZ = new Date('2022-01-01 00:00:00.123 +0500');
-
-	const timestampString2 = '2022-01-01 00:00:00.123456-0400';
-	const timestampDate2 = new Date();
-	const timestampDateWTZ2 = new Date('2022-01-01 00:00:00.123 +0200');
-
-	await db.insert(table).values([
-		{
-			timestamp: timestampString,
-			timestampAsDate: timestampDate,
-			timestampTimeZones: timestampDateWTZ,
-		},
-		{
-			timestamp: timestampString2,
-			timestampAsDate: timestampDate2,
-			timestampTimeZones: timestampDateWTZ2,
-		},
-	]);
-
-	const result = await db.select().from(table);
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-		timestamp_date: string;
-		timestamp_date_2: string;
-	}>(sql`select * from ${table}`);
-
-	// Whatever you put in, you get back when you're using the date mode
-	// But when using the string mode, postgres returns a string transformed into UTC
-	expect(result).toEqual([
-		{
-			id: 1,
-			timestamp: '2022-01-01 02:00:00.123456+00',
-			timestampAsDate: timestampDate,
-			timestampTimeZones: timestampDateWTZ,
-		},
-		{
-			id: 2,
-			timestamp: '2022-01-01 04:00:00.123456+00',
-			timestampAsDate: timestampDate2,
-			timestampTimeZones: timestampDateWTZ2,
-		},
-	]);
-
-	expect(result2.rows).toEqual([
-		{
-			id: 1,
-			timestamp_string: '2022-01-01 02:00:00.123456+00',
-			timestamp_date: timestampDate.toISOString().replace('T', ' ').replace('Z', '') + '+00',
-			timestamp_date_2: timestampDateWTZ.toISOString().replace('T', ' ').replace('Z', '')
-				+ '+00',
-		},
-		{
-			id: 2,
-			timestamp_string: '2022-01-01 04:00:00.123456+00',
-			timestamp_date: timestampDate2.toISOString().replace('T', ' ').replace('Z', '') + '+00',
-			timestamp_date_2: timestampDateWTZ2.toISOString().replace('T', ' ').replace('Z', '')
-				+ '+00',
-		},
-	]);
-
-	expect(result[0]?.timestampTimeZones.getTime()).toEqual(
-		new Date((result2.rows?.[0] as any).timestamp_date_2 as any).getTime(),
-	);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestampString: timestamp('timestamp_string', {
-			mode: 'string',
-			precision: 6,
-		}).notNull(),
-		timestampString2: timestamp('timestamp_string2', {
-			precision: 3,
-			mode: 'string',
-		}).notNull(),
-		timestampDate: timestamp('timestamp_date', { precision: 3 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null,
-					timestamp_string2 timestamp(3) not null,
-					timestamp_date timestamp(3) not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456';
-	// const timestampString2 = '2022-01-02 00:00:00.123 -0300';
-	const timestampString2 = '2022-01-02 00:00:00.123';
-	const timestampDate = new Date('2022-01-01 00:00:00.123Z');
-
-	const timestampString_2 = '2022-01-01 00:00:00.123456';
-	// const timestampString2_2 = '2022-01-01 00:00:00.123 -0300';
-	const timestampString2_2 = '2022-01-01 00:00:00.123';
-	// const timestampDate2 = new Date('2022-01-01 00:00:00.123 +0200');
-	const timestampDate2 = new Date('2022-01-01 00:00:00.123');
-
-	await db.insert(table).values([
-		{ timestampString, timestampString2, timestampDate },
-		{
-			timestampString: timestampString_2,
-			timestampString2: timestampString2_2,
-			timestampDate: timestampDate2,
-		},
-	]);
-
-	const result = await db.select().from(table);
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-		timestamp_string2: string;
-		timestamp_date: string;
-	}>(sql`select * from ${table}`);
-
-	// Whatever you put in, you get back when you're using the date mode
-	// But when using the string mode, postgres returns a string transformed into UTC
-	expect(result).toEqual([
-		{
-			id: 1,
-			timestampString: timestampString,
-			timestampString2: '2022-01-02 00:00:00.123',
-			timestampDate: timestampDate,
-		},
-		{
-			id: 2,
-			timestampString: timestampString_2,
-			timestampString2: '2022-01-01 00:00:00.123',
-			timestampDate: timestampDate2,
-		},
-	]);
-
-	expect(result2.rows).toEqual([
-		{
-			id: 1,
-			timestamp_string: timestampString,
-			timestamp_string2: '2022-01-02 00:00:00.123',
-			timestamp_date: timestampDate
-				.toISOString()
-				.replace('T', ' ')
-				.replace('Z', ''),
-		},
-		{
-			id: 2,
-			timestamp_string: timestampString_2,
-			timestamp_string2: '2022-01-01 00:00:00.123',
-			timestamp_date: timestampDate2
-				.toISOString()
-				.replace('T', ' ')
-				.replace('Z', ''),
-		},
-	]);
-
-	expect((result2.rows?.[0] as any).timestamp_string).toEqual(
-		'2022-01-01 00:00:00.123456',
-	);
-	// need to add the 'Z', otherwise javascript assumes it's in local time
-	expect(
-		new Date(((result2.rows?.[0] as any).timestamp_date + 'Z') as any).getTime(),
-	).toEqual(timestampDate.getTime());
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('Typehints mix for RQB', async () => {
-	const uuid = 'd997d46d-5769-4c78-9a35-93acadbe6076';
-
-	const res = await db.query.user.findMany({
-		where: eq(user.id, uuid),
-		with: {
-			todos: {
-				with: {
-					todo: true,
-				},
-			},
-		},
-	});
-
-	expect(res).toStrictEqual([]);
-});
-
-test('Typehints mix for findFirst', async () => {
-	const uuid = 'd997d46d-5769-4c78-9a35-93acadbe6076';
-
-	await db.insert(user).values({ id: uuid, email: 'd' });
-
-	const res = await db.query.user.findFirst({
-		where: eq(user.id, uuid),
-	});
-
-	expect(res).toStrictEqual({ id: 'd997d46d-5769-4c78-9a35-93acadbe6076', email: 'd' });
-});
-
-afterAll(async () => {
-	await db.execute(sql`drop table if exists "users"`);
-	await db.execute(sql`drop table if exists "todo_user"`);
-	await db.execute(sql`drop table if exists "user"`);
-	await db.execute(sql`drop table if exists "todo"`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-});
+// import 'dotenv/config';
+// import { RDSDataClient } from '@aws-sdk/client-rds-data';
+// import * as dotenv from 'dotenv';
+// import { asc, defineRelations, eq, getColumns, inArray, notInArray, sql, TransactionRollbackError } from 'drizzle-orm';
+// import type { AwsDataApiPgDatabase } from 'drizzle-orm/aws-data-api/pg';
+// import { drizzle } from 'drizzle-orm/aws-data-api/pg';
+// import { migrate } from 'drizzle-orm/aws-data-api/pg/migrator';
+// import {
+// 	alias,
+// 	bigint,
+// 	bigserial,
+// 	bit,
+// 	boolean,
+// 	bytea,
+// 	char,
+// 	cidr,
+// 	date,
+// 	doublePrecision,
+// 	inet,
+// 	integer,
+// 	interval,
+// 	json,
+// 	jsonb,
+// 	line,
+// 	macaddr,
+// 	macaddr8,
+// 	numeric,
+// 	pgEnum,
+// 	pgTable,
+// 	pgTableCreator,
+// 	point,
+// 	real,
+// 	serial,
+// 	smallint,
+// 	smallserial,
+// 	text,
+// 	time,
+// 	timestamp,
+// 	uuid,
+// 	varchar,
+// } from 'drizzle-orm/pg-core';
+// import { Resource } from 'sst';
+// import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+// import type { Equal } from '../utils';
+// import { Expect, randomString } from '../utils';
+// import { relations as relationsV2 } from './relations';
+// import { clear, init, rqbPost, rqbUser } from './schema';
+// import { normalizeDataWithDbCodecs } from './utils';
+
+// dotenv.config();
+
+// const ENABLE_LOGGING = false;
+
+// test('mock', () => {});
+
+// const usersTable = pgTable('users', {
+// 	id: serial('id').primaryKey(),
+// 	name: text('name').notNull(),
+// 	verified: boolean('verified').notNull().default(false),
+// 	jsonb: jsonb('jsonb').$type<string[]>(),
+// 	bestTexts: text('best_texts')
+// 		.array()
+// 		.default(sql`'{}'`)
+// 		.notNull(),
+// 	createdAt: timestamp('created_at', { withTimezone: true })
+// 		.notNull()
+// 		.defaultNow(),
+// });
+
+// const usersMigratorTable = pgTable('users12', {
+// 	id: serial('id').primaryKey(),
+// 	name: text('name').notNull(),
+// 	email: text('email').notNull(),
+// });
+
+// let db: AwsDataApiPgDatabase<typeof relationsV2>;
+// let rdsClient: RDSDataClient;
+// const credentials = {
+// 	// @ts-ignore
+// 	database: Resource.Postgres.database as string,
+// 	// @ts-ignore
+// 	secretArn: Resource.Postgres.secretArn as string,
+// 	// @ts-ignore
+// 	resourceArn: Resource.Postgres.clusterArn as string,
+// };
+
+// beforeAll(async () => {
+// 	rdsClient = new RDSDataClient();
+
+// 	db = drizzle({
+// 		client: rdsClient,
+// 		...credentials,
+// 		logger: ENABLE_LOGGING,
+// 		relations: relationsV2,
+// 	});
+// });
+
+// beforeEach(async () => {
+// 	await db.execute(sql`drop schema public cascade`);
+// 	await db.execute(sql`create schema public`);
+// 	await db.execute(
+// 		sql`
+// 			create table users (
+// 				id serial primary key,
+// 				name text not null,
+// 				verified boolean not null default false,
+// 				jsonb jsonb,
+// 				best_texts text[] not null default '{}',
+// 				created_at timestamptz not null default now()
+// 			)
+// 		`,
+// 	);
+
+// 	await db.execute(
+// 		sql`
+// 			create table todo (
+// 				id uuid primary key,
+// 				title text not null,
+// 				description text
+// 			)
+// 		`,
+// 	);
+
+// 	await db.execute(
+// 		sql`
+// 			create table "user" (
+// 				id uuid primary key,
+// 				email text not null
+// 			)
+
+// 		`,
+// 	);
+
+// 	await db.execute(
+// 		sql`
+// 			create table todo_user (
+// 				todo_id uuid references todo(id),
+// 				user_id uuid references "user"(id)
+// 			)
+// 		`,
+// 	);
+// });
+
+// test('select all fields', async () => {
+// 	const insertResult = await db.insert(usersTable).values({ name: 'John' });
+
+// 	expect(insertResult.numberOfRecordsUpdated).toBe(1);
+
+// 	const result = await db.select().from(usersTable);
+
+// 	expect(result[0]!.createdAt).toBeInstanceOf(Date);
+// 	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 100);
+// 	expect(result).toEqual([
+// 		{
+// 			bestTexts: [],
+// 			id: 1,
+// 			name: 'John',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: result[0]!.createdAt,
+// 		},
+// 	]);
+// });
+
+// test('select sql', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.select({
+// 			name: sql`upper(${usersTable.name})`,
+// 		})
+// 		.from(usersTable);
+
+// 	expect(users).toEqual([{ name: 'JOHN' }]);
+// });
+
+// test('select with empty array in inArray', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+// 	const users = await db
+// 		.select({
+// 			name: sql`upper(${usersTable.name})`,
+// 		})
+// 		.from(usersTable)
+// 		.where(inArray(usersTable.id, []));
+
+// 	expect(users).toEqual([]);
+// });
+
+// test('select with empty array in notInArray', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+// 	const result = await db
+// 		.select({
+// 			name: sql`upper(${usersTable.name})`,
+// 		})
+// 		.from(usersTable)
+// 		.where(notInArray(usersTable.id, []));
+
+// 	expect(result).toEqual([
+// 		{ name: 'JOHN' },
+// 		{ name: 'JANE' },
+// 		{ name: 'JANE' },
+// 	]);
+// });
+
+// test('select typed sql', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.select({
+// 			name: sql<string>`upper(${usersTable.name})`,
+// 		})
+// 		.from(usersTable);
+
+// 	expect(users).toEqual([{ name: 'JOHN' }]);
+// });
+
+// test('select distinct', async () => {
+// 	const usersDistinctTable = pgTable('users_distinct', {
+// 		id: integer('id').notNull(),
+// 		name: text('name').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+// 	await db.execute(
+// 		sql`create table ${usersDistinctTable} (id integer, name text)`,
+// 	);
+
+// 	await db.insert(usersDistinctTable).values([
+// 		{ id: 1, name: 'John' },
+// 		{ id: 1, name: 'John' },
+// 		{ id: 2, name: 'John' },
+// 		{ id: 1, name: 'Jane' },
+// 	]);
+// 	const users1 = await db
+// 		.selectDistinct()
+// 		.from(usersDistinctTable)
+// 		.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+// 	const users2 = await db
+// 		.selectDistinctOn([usersDistinctTable.id])
+// 		.from(usersDistinctTable)
+// 		.orderBy(usersDistinctTable.id);
+// 	const users3 = await db
+// 		.selectDistinctOn([usersDistinctTable.name], {
+// 			name: usersDistinctTable.name,
+// 		})
+// 		.from(usersDistinctTable)
+// 		.orderBy(usersDistinctTable.name);
+
+// 	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+// 	expect(users1).toEqual([
+// 		{ id: 1, name: 'Jane' },
+// 		{ id: 1, name: 'John' },
+// 		{ id: 2, name: 'John' },
+// 	]);
+
+// 	expect(users2.length).toEqual(2);
+// 	expect(users2[0]?.id).toEqual(1);
+// 	expect(users2[1]?.id).toEqual(2);
+
+// 	expect(users3.length).toEqual(2);
+// 	expect(users3[0]?.name).toEqual('Jane');
+// 	expect(users3[1]?.name).toEqual('John');
+// });
+
+// test('insert returning sql', async () => {
+// 	const users = await db
+// 		.insert(usersTable)
+// 		.values({ name: 'John' })
+// 		.returning({
+// 			name: sql`upper(${usersTable.name})`,
+// 		});
+
+// 	expect(users).toEqual([{ name: 'JOHN' }]);
+// });
+
+// test('delete returning sql', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.delete(usersTable)
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning({
+// 			name: sql`upper(${usersTable.name})`,
+// 		});
+
+// 	expect(users).toEqual([{ name: 'JOHN' }]);
+// });
+
+// test('update returning sql', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.update(usersTable)
+// 		.set({ name: 'Jane' })
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning({
+// 			name: sql`upper(${usersTable.name})`,
+// 		});
+
+// 	expect(users).toEqual([{ name: 'JANE' }]);
+// });
+
+// test('update with returning all fields', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.update(usersTable)
+// 		.set({ name: 'Jane' })
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning();
+
+// 	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+// 	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+// 	expect(users).toEqual([
+// 		{
+// 			id: 1,
+// 			bestTexts: [],
+// 			name: 'Jane',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: users[0]!.createdAt,
+// 		},
+// 	]);
+// });
+
+// test('update with returning partial', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.update(usersTable)
+// 		.set({ name: 'Jane' })
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 		});
+
+// 	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+// });
+
+// test('delete with returning all fields', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.delete(usersTable)
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning();
+
+// 	expect(users[0]!.createdAt).toBeInstanceOf(Date);
+// 	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+// 	expect(users).toEqual([
+// 		{
+// 			bestTexts: [],
+// 			id: 1,
+// 			name: 'John',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: users[0]!.createdAt,
+// 		},
+// 	]);
+// });
+
+// test('delete with returning partial', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const users = await db
+// 		.delete(usersTable)
+// 		.where(eq(usersTable.name, 'John'))
+// 		.returning({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 		});
+
+// 	expect(users).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert + select', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const result = await db.select().from(usersTable);
+// 	expect(result).toEqual([
+// 		{
+// 			bestTexts: [],
+// 			id: 1,
+// 			name: 'John',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: result[0]!.createdAt,
+// 		},
+// 	]);
+
+// 	await db.insert(usersTable).values({ name: 'Jane' });
+// 	const result2 = await db.select().from(usersTable);
+// 	expect(result2).toEqual([
+// 		{
+// 			bestTexts: [],
+// 			id: 1,
+// 			name: 'John',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: result2[0]!.createdAt,
+// 		},
+// 		{
+// 			bestTexts: [],
+// 			id: 2,
+// 			name: 'Jane',
+// 			verified: false,
+// 			jsonb: null,
+// 			createdAt: result2[1]!.createdAt,
+// 		},
+// 	]);
+// });
+
+// test('json insert', async () => {
+// 	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+// 	const result = await db
+// 		.select({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 			jsonb: usersTable.jsonb,
+// 		})
+// 		.from(usersTable);
+
+// 	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+// });
+
+// test('insert with overridden default values', async () => {
+// 	await db.insert(usersTable).values({ name: 'John', verified: true });
+// 	const result = await db.select().from(usersTable);
+
+// 	expect(result).toEqual([
+// 		{
+// 			bestTexts: [],
+// 			id: 1,
+// 			name: 'John',
+// 			verified: true,
+// 			jsonb: null,
+// 			createdAt: result[0]!.createdAt,
+// 		},
+// 	]);
+// });
+
+// test('insert many', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([
+// 			{ name: 'John' },
+// 			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+// 			{ name: 'Jane' },
+// 			{ name: 'Austin', verified: true },
+// 		]);
+// 	const result = await db
+// 		.select({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 			jsonb: usersTable.jsonb,
+// 			verified: usersTable.verified,
+// 		})
+// 		.from(usersTable);
+
+// 	expect(result).toEqual([
+// 		{ id: 1, name: 'John', jsonb: null, verified: false },
+// 		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+// 		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+// 		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+// 	]);
+// });
+
+// test('insert many with returning', async () => {
+// 	const result = await db
+// 		.insert(usersTable)
+// 		.values([
+// 			{ name: 'John' },
+// 			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+// 			{ name: 'Jane' },
+// 			{ name: 'Austin', verified: true },
+// 		])
+// 		.returning({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 			jsonb: usersTable.jsonb,
+// 			verified: usersTable.verified,
+// 		});
+
+// 	expect(result).toEqual([
+// 		{ id: 1, name: 'John', jsonb: null, verified: false },
+// 		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+// 		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+// 		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+// 	]);
+// });
+
+// test('select with group by as field', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+// 	const result = await db
+// 		.select({ name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(usersTable.name);
+
+// 	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+// });
+
+// test('select with group by as sql', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+// 	const result = await db
+// 		.select({ name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(sql`${usersTable.name}`);
+
+// 	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+// });
+
+// test('select with group by as sql + column', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+// 	const result = await db
+// 		.select({ name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+// 	expect(result).toEqual([
+// 		{ name: 'Jane' },
+// 		{ name: 'Jane' },
+// 		{ name: 'John' },
+// 	]);
+// });
+
+// test('select with group by as column + sql', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+// 	const result = await db
+// 		.select({ name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+// 	expect(result).toEqual([
+// 		{ name: 'Jane' },
+// 		{ name: 'Jane' },
+// 		{ name: 'John' },
+// 	]);
+// });
+
+// test('select with group by complex query', async () => {
+// 	await db
+// 		.insert(usersTable)
+// 		.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+// 	const result = await db
+// 		.select({ name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(usersTable.id, sql`${usersTable.name}`)
+// 		.orderBy(asc(usersTable.name))
+// 		.limit(1);
+
+// 	expect(result).toEqual([{ name: 'Jane' }]);
+// });
+
+// test('build query', async () => {
+// 	const query = db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable)
+// 		.groupBy(usersTable.id, usersTable.name)
+// 		.toSQL();
+
+// 	expect(query).toEqual({
+// 		sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+// 		params: [],
+// 	});
+// });
+
+// test('insert sql', async () => {
+// 	await db.insert(usersTable).values({ name: sql`${'John'}` });
+// 	const result = await db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable);
+// 	expect(result).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('partial join with alias', async () => {
+// 	const customerAlias = alias(usersTable, 'customer');
+
+// 	await db.insert(usersTable).values([
+// 		{ id: 10, name: 'Ivan' },
+// 		{ id: 11, name: 'Hans' },
+// 	]);
+// 	const result = await db
+// 		.select({
+// 			user: {
+// 				id: usersTable.id,
+// 				name: usersTable.name,
+// 			},
+// 			customer: {
+// 				id: customerAlias.id,
+// 				name: customerAlias.name,
+// 			},
+// 		})
+// 		.from(usersTable)
+// 		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+// 		.where(eq(usersTable.id, 10));
+
+// 	expect(result).toEqual([
+// 		{
+// 			user: { id: 10, name: 'Ivan' },
+// 			customer: { id: 11, name: 'Hans' },
+// 		},
+// 	]);
+// });
+
+// test('full join with alias', async () => {
+// 	const customerAlias = alias(usersTable, 'customer');
+
+// 	await db.insert(usersTable).values([
+// 		{ id: 10, name: 'Ivan' },
+// 		{ id: 11, name: 'Hans' },
+// 	]);
+
+// 	const result = await db
+// 		.select()
+// 		.from(usersTable)
+// 		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+// 		.where(eq(usersTable.id, 10));
+
+// 	expect(result).toEqual([
+// 		{
+// 			users: {
+// 				id: 10,
+// 				bestTexts: [],
+// 				name: 'Ivan',
+// 				verified: false,
+// 				jsonb: null,
+// 				createdAt: result[0]!.users.createdAt,
+// 			},
+// 			customer: {
+// 				bestTexts: [],
+// 				id: 11,
+// 				name: 'Hans',
+// 				verified: false,
+// 				jsonb: null,
+// 				createdAt: result[0]!.customer!.createdAt,
+// 			},
+// 		},
+// 	]);
+// });
+
+// test('select from alias', async () => {
+// 	const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+// 	const users = pgTable('users', {
+// 		id: serial('id').primaryKey(),
+// 		name: text('name').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(
+// 		sql`create table ${users} (id serial primary key, name text not null)`,
+// 	);
+
+// 	const user = alias(users, 'user');
+// 	const customers = alias(users, 'customer');
+
+// 	await db.insert(users).values([
+// 		{ id: 10, name: 'Ivan' },
+// 		{ id: 11, name: 'Hans' },
+// 	]);
+// 	const result = await db
+// 		.select()
+// 		.from(user)
+// 		.leftJoin(customers, eq(customers.id, 11))
+// 		.where(eq(user.id, 10));
+
+// 	expect(result).toEqual([
+// 		{
+// 			user: {
+// 				id: 10,
+// 				name: 'Ivan',
+// 			},
+// 			customer: {
+// 				id: 11,
+// 				name: 'Hans',
+// 			},
+// 		},
+// 	]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// test('insert with spaces', async () => {
+// 	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+// 	const result = await db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable);
+
+// 	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+// });
+
+// test('prepared statement', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const statement = db
+// 		.select({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 		})
+// 		.from(usersTable)
+// 		.prepare('statement1');
+// 	const result = await statement.execute();
+
+// 	expect(result).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('prepared statement reuse', async () => {
+// 	const stmt = db
+// 		.insert(usersTable)
+// 		.values({
+// 			verified: true,
+// 			name: sql.placeholder('name'),
+// 		})
+// 		.prepare('stmt2');
+
+// 	for (let i = 0; i < 10; i++) {
+// 		await stmt.execute({ name: `John ${i}` });
+// 	}
+
+// 	const result = await db
+// 		.select({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 			verified: usersTable.verified,
+// 		})
+// 		.from(usersTable);
+
+// 	expect(result).toEqual([
+// 		{ id: 1, name: 'John 0', verified: true },
+// 		{ id: 2, name: 'John 1', verified: true },
+// 		{ id: 3, name: 'John 2', verified: true },
+// 		{ id: 4, name: 'John 3', verified: true },
+// 		{ id: 5, name: 'John 4', verified: true },
+// 		{ id: 6, name: 'John 5', verified: true },
+// 		{ id: 7, name: 'John 6', verified: true },
+// 		{ id: 8, name: 'John 7', verified: true },
+// 		{ id: 9, name: 'John 8', verified: true },
+// 		{ id: 10, name: 'John 9', verified: true },
+// 	]);
+// });
+
+// test('prepared statement with placeholder in .where', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+// 	const stmt = db
+// 		.select({
+// 			id: usersTable.id,
+// 			name: usersTable.name,
+// 		})
+// 		.from(usersTable)
+// 		.where(eq(usersTable.id, sql.placeholder('id')))
+// 		.prepare('stmt3');
+// 	const result = await stmt.execute({ id: 1 });
+
+// 	expect(result).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('migrator : default migration strategy', async () => {
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+// 	const result = await db.select().from(usersMigratorTable);
+
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+// });
+
+// test('migrator : migrate with custom schema', async () => {
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, {
+// 		migrationsFolder: './drizzle2/pg',
+// 		migrationsSchema: 'custom_migrations',
+// 	});
+
+// 	// test if the custom migrations table was created
+// 	const { rows } = await db.execute(
+// 		sql`select * from custom_migrations."__drizzle_migrations";`,
+// 	);
+// 	expect(rows).toBeTruthy();
+// 	expect(rows!.length).toBeGreaterThan(0);
+
+// 	// test if the migrated table are working as expected
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+// 	const result = await db.select().from(usersMigratorTable);
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(
+// 		sql`drop table custom_migrations."__drizzle_migrations"`,
+// 	);
+// });
+
+// test('migrator : migrate with custom table', async () => {
+// 	const customTable = randomString();
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, {
+// 		migrationsFolder: './drizzle2/pg',
+// 		migrationsTable: customTable,
+// 	});
+
+// 	// test if the custom migrations table was created
+// 	const { rows } = await db.execute(
+// 		sql`select * from "drizzle".${sql.identifier(customTable)};`,
+// 	);
+// 	expect(rows).toBeTruthy();
+// 	expect(rows!.length).toBeGreaterThan(0);
+
+// 	// test if the migrated table are working as expected
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+// 	const result = await db.select().from(usersMigratorTable);
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
+// });
+
+// test('migrator : migrate with custom table and custom schema', async () => {
+// 	const customTable = randomString();
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, {
+// 		migrationsFolder: './drizzle2/pg',
+// 		migrationsTable: customTable,
+// 		migrationsSchema: 'custom_migrations',
+// 	});
+
+// 	// test if the custom migrations table was created
+// 	const { rows } = await db.execute(
+// 		sql`select * from custom_migrations.${
+// 			sql.identifier(
+// 				customTable,
+// 			)
+// 		};`,
+// 	);
+// 	expect(rows).toBeTruthy();
+// 	expect(rows!.length).toBeGreaterThan(0);
+
+// 	// test if the migrated table are working as expected
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+// 	const result = await db.select().from(usersMigratorTable);
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(
+// 		sql`drop table custom_migrations.${
+// 			sql.identifier(
+// 				customTable,
+// 			)
+// 		}`,
+// 	);
+// });
+
+// test('insert via db.execute + select via db.execute', async () => {
+// 	await db.execute(
+// 		sql`insert into ${usersTable} (${
+// 			sql.identifier(
+// 				usersTable.name.name,
+// 			)
+// 		}) values (${'John'})`,
+// 	);
+
+// 	const result = await db.execute<{ id: number; name: string }>(
+// 		sql`select id, name from "users"`,
+// 	);
+// 	expectTypeOf(result.rows).toEqualTypeOf<{ id: number; name: string }[]>();
+// 	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert via db.execute + returning', async () => {
+// 	const inserted = await db.execute(
+// 		sql`insert into ${usersTable} (${
+// 			sql.identifier(
+// 				usersTable.name.name,
+// 			)
+// 		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+// 	);
+// 	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert via db.execute w/ query builder', async () => {
+// 	const inserted = await db.execute(
+// 		db
+// 			.insert(usersTable)
+// 			.values({ name: 'John' })
+// 			.returning({ id: usersTable.id, name: usersTable.name }),
+// 	);
+// 	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('build query insert with onConflict do update', async () => {
+// 	const query = db
+// 		.insert(usersTable)
+// 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+// 		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+// 		.toSQL();
+
+// 	expect(query).toEqual({
+// 		sql:
+// 			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1::text, default, :2::jsonb, default, default) on conflict ("id") do update set "name" = :3::text',
+// 		params: ['John', '["foo","bar"]', 'John1'],
+// 	});
+// });
+
+// test('build query insert with onConflict do update / multiple columns', async () => {
+// 	const query = db
+// 		.insert(usersTable)
+// 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+// 		.onConflictDoUpdate({
+// 			target: [usersTable.id, usersTable.name],
+// 			set: { name: 'John1' },
+// 		})
+// 		.toSQL();
+
+// 	expect(query).toEqual({
+// 		sql:
+// 			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1::text, default, :2::jsonb, default, default) on conflict ("id","name") do update set "name" = :3::text',
+// 		params: ['John', '["foo","bar"]', 'John1'],
+// 	});
+// });
+
+// test('build query insert with onConflict do nothing', async () => {
+// 	const query = db
+// 		.insert(usersTable)
+// 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+// 		.onConflictDoNothing()
+// 		.toSQL();
+
+// 	expect(query).toEqual({
+// 		sql:
+// 			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1::text, default, :2::jsonb, default, default) on conflict do nothing',
+// 		params: ['John', '["foo","bar"]'],
+// 	});
+// });
+
+// test('build query insert with onConflict do nothing + target', async () => {
+// 	const query = db
+// 		.insert(usersTable)
+// 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+// 		.onConflictDoNothing({ target: usersTable.id })
+// 		.toSQL();
+
+// 	expect(query).toEqual({
+// 		sql:
+// 			'insert into "users" ("id", "name", "verified", "jsonb", "best_texts", "created_at") values (default, :1::text, default, :2::jsonb, default, default) on conflict ("id") do nothing',
+// 		params: ['John', '["foo","bar"]'],
+// 	});
+// });
+
+// test('insert with onConflict do update', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+
+// 	await db
+// 		.insert(usersTable)
+// 		.values({ id: 1, name: 'John' })
+// 		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+// 	const res = await db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable)
+// 		.where(eq(usersTable.id, 1));
+
+// 	expect(res).toEqual([{ id: 1, name: 'John1' }]);
+// });
+
+// test('insert with onConflict do nothing', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+
+// 	await db
+// 		.insert(usersTable)
+// 		.values({ id: 1, name: 'John' })
+// 		.onConflictDoNothing();
+
+// 	const res = await db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable)
+// 		.where(eq(usersTable.id, 1));
+
+// 	expect(res).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert with onConflict do nothing + target', async () => {
+// 	await db.insert(usersTable).values({ name: 'John' });
+
+// 	await db
+// 		.insert(usersTable)
+// 		.values({ id: 1, name: 'John' })
+// 		.onConflictDoNothing({ target: usersTable.id });
+
+// 	const res = await db
+// 		.select({ id: usersTable.id, name: usersTable.name })
+// 		.from(usersTable)
+// 		.where(eq(usersTable.id, 1));
+
+// 	expect(res).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('transaction', async () => {
+// 	const users = pgTable('users_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+// 	const products = pgTable('products_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		price: integer('price').notNull(),
+// 		stock: integer('stock').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(sql`drop table if exists ${products}`);
+
+// 	await db.execute(
+// 		sql`create table users_transactions (id serial not null primary key, balance integer not null)`,
+// 	);
+// 	await db.execute(
+// 		sql`create table products_transactions (id serial not null primary key, price integer not null, stock integer not null)`,
+// 	);
+
+// 	const user = await db
+// 		.insert(users)
+// 		.values({ balance: 100 })
+// 		.returning()
+// 		.then((rows) => rows[0]!);
+// 	const product = await db
+// 		.insert(products)
+// 		.values({ price: 10, stock: 10 })
+// 		.returning()
+// 		.then((rows) => rows[0]!);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx
+// 			.update(users)
+// 			.set({ balance: user.balance - product.price })
+// 			.where(eq(users.id, user.id));
+// 		await tx
+// 			.update(products)
+// 			.set({ stock: product.stock - 1 })
+// 			.where(eq(products.id, product.id));
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	expect(result).toEqual([{ id: 1, balance: 90 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// 	await db.execute(sql`drop table ${products}`);
+// });
+
+// test('transaction rollback', async () => {
+// 	const users = pgTable('users_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_transactions_rollback (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await expect(
+// 		db.transaction(async (tx) => {
+// 			await tx.insert(users).values({ balance: 100 });
+// 			tx.rollback();
+// 		}),
+// 	).rejects.toThrowError(TransactionRollbackError);
+
+// 	const result = await db.select().from(users);
+
+// 	expect(result).toEqual([]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// test('nested transaction', async () => {
+// 	const users = pgTable('users_nested_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await tx.transaction(async (tx) => {
+// 			await tx.update(users).set({ balance: 200 });
+// 		});
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	expect(result).toEqual([{ id: 1, balance: 200 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// test('nested transaction rollback', async () => {
+// 	const users = pgTable('users_nested_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions_rollback (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await expect(
+// 			tx.transaction(async (tx2) => {
+// 				await tx2.update(users).set({ balance: 200 });
+// 				tx2.rollback();
+// 			}),
+// 		).rejects.toThrowError(TransactionRollbackError);
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	expect(result).toEqual([{ id: 1, balance: 100 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// test('select from raw sql', async () => {
+// 	const result = await db.execute(sql`select 1 as id, 'John' as name`);
+
+// 	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('select from raw sql with mapped values', async () => {
+// 	const result = await db
+// 		.select({
+// 			id: sql<number>`id`,
+// 			name: sql<string>`name`,
+// 		})
+// 		.from(sql`(select 1 as id, 'John' as name) as users`);
+
+// 	expect(result).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert with array values works', async () => {
+// 	const bestTexts = ['text1', 'text2', 'text3'];
+// 	const [insertResult] = await db
+// 		.insert(usersTable)
+// 		.values({
+// 			name: 'John',
+// 			bestTexts,
+// 		})
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('update with array values works', async () => {
+// 	const [newUser] = await db
+// 		.insert(usersTable)
+// 		.values({ name: 'John' })
+// 		.returning();
+
+// 	const bestTexts = ['text4', 'text5', 'text6'];
+// 	const [insertResult] = await db
+// 		.update(usersTable)
+// 		.set({
+// 			bestTexts,
+// 		})
+// 		.where(eq(usersTable.id, newUser!.id))
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('insert with array values works', async () => {
+// 	const bestTexts = ['text1', 'text2', 'text3'];
+// 	const [insertResult] = await db
+// 		.insert(usersTable)
+// 		.values({
+// 			name: 'John',
+// 			bestTexts,
+// 		})
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('update with array values works', async () => {
+// 	const [newUser] = await db
+// 		.insert(usersTable)
+// 		.values({ name: 'John' })
+// 		.returning();
+
+// 	const bestTexts = ['text4', 'text5', 'text6'];
+// 	const [insertResult] = await db
+// 		.update(usersTable)
+// 		.set({
+// 			bestTexts,
+// 		})
+// 		.where(eq(usersTable.id, newUser!.id))
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('insert with array values works', async () => {
+// 	const bestTexts = ['text1', 'text2', 'text3'];
+// 	const [insertResult] = await db
+// 		.insert(usersTable)
+// 		.values({
+// 			name: 'John',
+// 			bestTexts,
+// 		})
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('update with array values works', async () => {
+// 	const [newUser] = await db
+// 		.insert(usersTable)
+// 		.values({ name: 'John' })
+// 		.returning();
+
+// 	const bestTexts = ['text4', 'text5', 'text6'];
+// 	const [insertResult] = await db
+// 		.update(usersTable)
+// 		.set({
+// 			bestTexts,
+// 		})
+// 		.where(eq(usersTable.id, newUser!.id))
+// 		.returning();
+
+// 	expect(insertResult?.bestTexts).toEqual(bestTexts);
+// });
+
+// test('all date and time columns', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		dateString: date('date_string', { mode: 'string' }).notNull(),
+// 		time: time('time', { precision: 3 }).notNull(),
+// 		datetime: timestamp('datetime').notNull(),
+// 		// datetimeWTZ: timestamp('datetime_wtz', { withTimezone: true }).notNull(),
+// 		datetimeString: timestamp('datetime_string', { mode: 'string' }).notNull(),
+// 		datetimeFullPrecision: timestamp('datetime_full_precision', {
+// 			precision: 6,
+// 			mode: 'string',
+// 		}).notNull(),
+// 		// datetimeWTZString: timestamp('datetime_wtz_string', { withTimezone: true, mode: 'string' }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					date_string date not null,
+// 					time time(3) not null,
+// 					datetime timestamp not null,
+// 					-- datetime_wtz timestamp with time zone not null,
+// 					datetime_string timestamp not null,
+// 					datetime_full_precision timestamp(6) not null
+// 					-- datetime_wtz_string timestamp with time zone not null
+// 			)
+// 	`);
+
+// 	const someDatetime = new Date('2022-01-01T00:00:00.123Z');
+// 	const fullPrecision = '2022-01-01T00:00:00.123456';
+// 	const someTime = '23:23:12.432';
+
+// 	await db.insert(table).values({
+// 		dateString: '2022-01-01',
+// 		time: someTime,
+// 		datetime: someDatetime,
+// 		// datetimeWTZ: someDatetime,
+// 		datetimeString: '2022-01-01T00:00:00.123Z',
+// 		datetimeFullPrecision: fullPrecision,
+// 		// datetimeWTZString: '2022-01-01T00:00:00.123Z',
+// 	});
+
+// 	const result = await db.select().from(table);
+
+// 	Expect<
+// 		Equal<
+// 			{
+// 				id: number;
+// 				dateString: string;
+// 				time: string;
+// 				datetime: Date;
+// 				// datetimeWTZ: Date;
+// 				datetimeString: string;
+// 				datetimeFullPrecision: string;
+// 				// datetimeWTZString: string;
+// 			}[],
+// 			typeof result
+// 		>
+// 	>;
+
+// 	Expect<
+// 		Equal<
+// 			{
+// 				dateString: string;
+// 				time: string;
+// 				datetime: Date;
+// 				// datetimeWTZ: Date;
+// 				datetimeString: string;
+// 				datetimeFullPrecision: string;
+// 				// datetimeWTZString: string;
+// 				id?: number | undefined;
+// 			},
+// 			typeof table.$inferInsert
+// 		>
+// 	>;
+
+// 	expect(result).toEqual([
+// 		{
+// 			id: 1,
+// 			dateString: '2022-01-01',
+// 			time: someTime,
+// 			datetime: someDatetime,
+// 			// datetimeWTZ: someDatetime,
+// 			datetimeString: '2022-01-01 00:00:00.123',
+// 			datetimeFullPrecision: fullPrecision.replace('T', ' ').replace('Z', ''),
+// 			// datetimeWTZString: '2022-01-01 00:00:00.123+00',
+// 		},
+// 	]);
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('all date and time columns with timezone', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', {
+// 			mode: 'string',
+// 			withTimezone: true,
+// 			precision: 6,
+// 		}).notNull(),
+// 		timestampAsDate: timestamp('timestamp_date', {
+// 			mode: 'date',
+// 			withTimezone: true,
+// 			precision: 3,
+// 		}).notNull(),
+// 		timestampTimeZones: timestamp('timestamp_date_2', {
+// 			mode: 'date',
+// 			withTimezone: true,
+// 			precision: 3,
+// 		}).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) with time zone not null,
+// 					timestamp_date timestamp(3) with time zone not null,
+// 					timestamp_date_2 timestamp(3) with time zone not null
+// 			)
+// 	`);
+
+// 	const timestampString = '2022-01-01 00:00:00.123456-0200';
+// 	const timestampDate = new Date();
+// 	const timestampDateWTZ = new Date('2022-01-01 00:00:00.123 +0500');
+
+// 	const timestampString2 = '2022-01-01 00:00:00.123456-0400';
+// 	const timestampDate2 = new Date();
+// 	const timestampDateWTZ2 = new Date('2022-01-01 00:00:00.123 +0200');
+
+// 	await db.insert(table).values([
+// 		{
+// 			timestamp: timestampString,
+// 			timestampAsDate: timestampDate,
+// 			timestampTimeZones: timestampDateWTZ,
+// 		},
+// 		{
+// 			timestamp: timestampString2,
+// 			timestampAsDate: timestampDate2,
+// 			timestampTimeZones: timestampDateWTZ2,
+// 		},
+// 	]);
+
+// 	const result = await db.select().from(table);
+// 	// Requires in-query casts performad by codecs to preserve all required data
+// 	// const result2 = await db.execute<{
+// 	// 	id: number;
+// 	// 	timestamp_string: string;
+// 	// 	timestamp_date: string;
+// 	// 	timestamp_date_2: string;
+// 	// }>(sql`select * from ${table}`);
+
+// 	// Whatever you put in, you get back when you're using the date mode
+// 	// But when using the string mode, postgres returns a string transformed into UTC
+// 	expect(result).toEqual([
+// 		{
+// 			id: 1,
+// 			timestamp: '2022-01-01 02:00:00.123456+00',
+// 			timestampAsDate: timestampDate,
+// 			timestampTimeZones: timestampDateWTZ,
+// 		},
+// 		{
+// 			id: 2,
+// 			timestamp: '2022-01-01 04:00:00.123456+00',
+// 			timestampAsDate: timestampDate2,
+// 			timestampTimeZones: timestampDateWTZ2,
+// 		},
+// 	]);
+
+// 	// expect(result2.rows).toEqual([
+// 	// 	{
+// 	// 		id: 1,
+// 	// 		timestamp_string: '2022-01-01 02:00:00.123456+00',
+// 	// 		timestamp_date: timestampDate.toISOString().replace('T', ' ').replace('Z', '') + '+00',
+// 	// 		timestamp_date_2: timestampDateWTZ.toISOString().replace('T', ' ').replace('Z', '')
+// 	// 			+ '+00',
+// 	// 	},
+// 	// 	{
+// 	// 		id: 2,
+// 	// 		timestamp_string: '2022-01-01 04:00:00.123456+00',
+// 	// 		timestamp_date: timestampDate2.toISOString().replace('T', ' ').replace('Z', '') + '+00',
+// 	// 		timestamp_date_2: timestampDateWTZ2.toISOString().replace('T', ' ').replace('Z', '')
+// 	// 			+ '+00',
+// 	// 	},
+// 	// ]);
+
+// 	// expect(result[0]?.timestampTimeZones.getTime()).toEqual(
+// 	// 	new Date((result2.rows?.[0]?.timestamp_date_2) as any).getTime(),
+// 	// );
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('all date and time columns without timezone', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestampString: timestamp('timestamp_string', {
+// 			mode: 'string',
+// 			precision: 6,
+// 		}).notNull(),
+// 		timestampString2: timestamp('timestamp_string2', {
+// 			precision: 3,
+// 			mode: 'string',
+// 		}).notNull(),
+// 		timestampDate: timestamp('timestamp_date', { precision: 3 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) not null,
+// 					timestamp_string2 timestamp(3) not null,
+// 					timestamp_date timestamp(3) not null
+// 			)
+// 	`);
+
+// 	const timestampString = '2022-01-01 00:00:00.123456';
+// 	// const timestampString2 = '2022-01-02 00:00:00.123 -0300';
+// 	const timestampString2 = '2022-01-02 00:00:00.123';
+// 	const timestampDate = new Date('2022-01-01 00:00:00.123Z');
+
+// 	const timestampString_2 = '2022-01-01 00:00:00.123456';
+// 	// const timestampString2_2 = '2022-01-01 00:00:00.123 -0300';
+// 	const timestampString2_2 = '2022-01-01 00:00:00.123';
+// 	// const timestampDate2 = new Date('2022-01-01 00:00:00.123 +0200');
+// 	const timestampDate2 = new Date('2022-01-01 00:00:00.123');
+
+// 	await db.insert(table).values([
+// 		{ timestampString, timestampString2, timestampDate },
+// 		{
+// 			timestampString: timestampString_2,
+// 			timestampString2: timestampString2_2,
+// 			timestampDate: timestampDate2,
+// 		},
+// 	]);
+
+// 	const result = await db.select().from(table);
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 		timestamp_string2: string;
+// 		timestamp_date: string;
+// 	}>(sql`select * from ${table}`);
+
+// 	// Whatever you put in, you get back when you're using the date mode
+// 	// But when using the string mode, postgres returns a string transformed into UTC
+// 	expect(result).toEqual([
+// 		{
+// 			id: 1,
+// 			timestampString: timestampString,
+// 			timestampString2: '2022-01-02 00:00:00.123',
+// 			timestampDate: timestampDate,
+// 		},
+// 		{
+// 			id: 2,
+// 			timestampString: timestampString_2,
+// 			timestampString2: '2022-01-01 00:00:00.123',
+// 			timestampDate: timestampDate2,
+// 		},
+// 	]);
+
+// 	expect(result2.rows).toEqual([
+// 		{
+// 			id: 1,
+// 			timestamp_string: timestampString,
+// 			timestamp_string2: '2022-01-02 00:00:00.123',
+// 			timestamp_date: timestampDate
+// 				.toISOString()
+// 				.replace('T', ' ')
+// 				.replace('Z', ''),
+// 		},
+// 		{
+// 			id: 2,
+// 			timestamp_string: timestampString_2,
+// 			timestamp_string2: '2022-01-01 00:00:00.123',
+// 			timestamp_date: timestampDate2
+// 				.toISOString()
+// 				.replace('T', ' ')
+// 				.replace('Z', ''),
+// 		},
+// 	]);
+
+// 	expect(result2.rows?.[0]?.timestamp_string).toEqual(
+// 		'2022-01-01 00:00:00.123456',
+// 	);
+// 	// need to add the 'Z', otherwise javascript assumes it's in local time
+// 	expect(
+// 		new Date((result2.rows?.[0]?.timestamp_date + 'Z') as any).getTime(),
+// 	).toEqual(timestampDate.getTime());
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('RQB v2 simple find first - no rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const result = await db.query.rqbUser.findFirst();
+
+// 		expect(result).toStrictEqual(undefined);
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find first - multiple rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		const result = await db.query.rqbUser.findFirst({
+// 			orderBy: {
+// 				id: 'desc',
+// 			},
+// 		});
+
+// 		expect(result).toStrictEqual({
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find first - with relation', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.insert(rqbPost).values([{
+// 			id: 1,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: null,
+// 		}, {
+// 			id: 2,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: 'Has message this time',
+// 		}]);
+
+// 		const result = await db.query.rqbUser.findFirst({
+// 			with: {
+// 				posts: {
+// 					orderBy: {
+// 						id: 'asc',
+// 					},
+// 				},
+// 			},
+// 			orderBy: {
+// 				id: 'asc',
+// 			},
+// 		});
+
+// 		expect(result).toStrictEqual({
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 			posts: [{
+// 				id: 1,
+// 				userId: 1,
+// 				createdAt: date,
+// 				content: null,
+// 			}, {
+// 				id: 2,
+// 				userId: 1,
+// 				createdAt: date,
+// 				content: 'Has message this time',
+// 			}],
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find first - placeholders', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		const query = db.query.rqbUser.findFirst({
+// 			where: {
+// 				id: {
+// 					eq: sql.placeholder('filter'),
+// 				},
+// 			},
+// 			orderBy: {
+// 				id: 'asc',
+// 			},
+// 		}).prepare('rqb_v2_find_first_placeholders');
+
+// 		const result = await query.execute({
+// 			filter: 2,
+// 		});
+
+// 		expect(result).toStrictEqual({
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find many - no rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const result = await db.query.rqbUser.findMany();
+
+// 		expect(result).toStrictEqual([]);
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find many - multiple rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		const result = await db.query.rqbUser.findMany({
+// 			orderBy: {
+// 				id: 'desc',
+// 			},
+// 		});
+
+// 		expect(result).toStrictEqual([{
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}, {
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}]);
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find many - with relation', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.insert(rqbPost).values([{
+// 			id: 1,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: null,
+// 		}, {
+// 			id: 2,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: 'Has message this time',
+// 		}]);
+
+// 		const result = await db.query.rqbPost.findMany({
+// 			with: {
+// 				author: true,
+// 			},
+// 			orderBy: {
+// 				id: 'asc',
+// 			},
+// 		});
+
+// 		expect(result).toStrictEqual([{
+// 			id: 1,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: null,
+// 			author: {
+// 				id: 1,
+// 				createdAt: date,
+// 				name: 'First',
+// 			},
+// 		}, {
+// 			id: 2,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: 'Has message this time',
+// 			author: {
+// 				id: 1,
+// 				createdAt: date,
+// 				name: 'First',
+// 			},
+// 		}]);
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 simple find many - placeholders', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		const query = db.query.rqbUser.findMany({
+// 			where: {
+// 				id: {
+// 					eq: sql.placeholder('filter'),
+// 				},
+// 			},
+// 			orderBy: {
+// 				id: 'asc',
+// 			},
+// 		}).prepare('rqb_v2_find_many_placeholders');
+
+// 		const result = await query.execute({
+// 			filter: 2,
+// 		});
+
+// 		expect(result).toStrictEqual([{
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find first - no rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbUser.findFirst();
+
+// 			expect(result).toStrictEqual(undefined);
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find first - multiple rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbUser.findFirst({
+// 				orderBy: {
+// 					id: 'desc',
+// 				},
+// 			});
+
+// 			expect(result).toStrictEqual({
+// 				id: 2,
+// 				createdAt: date,
+// 				name: 'Second',
+// 			});
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find first - with relation', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.insert(rqbPost).values([{
+// 			id: 1,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: null,
+// 		}, {
+// 			id: 2,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: 'Has message this time',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbUser.findFirst({
+// 				with: {
+// 					posts: {
+// 						orderBy: {
+// 							id: 'asc',
+// 						},
+// 					},
+// 				},
+// 				orderBy: {
+// 					id: 'asc',
+// 				},
+// 			});
+
+// 			expect(result).toStrictEqual({
+// 				id: 1,
+// 				createdAt: date,
+// 				name: 'First',
+// 				posts: [{
+// 					id: 1,
+// 					userId: 1,
+// 					createdAt: date,
+// 					content: null,
+// 				}, {
+// 					id: 2,
+// 					userId: 1,
+// 					createdAt: date,
+// 					content: 'Has message this time',
+// 				}],
+// 			});
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find first - placeholders', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const query = db.query.rqbUser.findFirst({
+// 				where: {
+// 					id: {
+// 						eq: sql.placeholder('filter'),
+// 					},
+// 				},
+// 				orderBy: {
+// 					id: 'asc',
+// 				},
+// 			}).prepare('rqb_v2_find_first_tx_placeholders');
+
+// 			const result = await query.execute({
+// 				filter: 2,
+// 			});
+
+// 			expect(result).toStrictEqual({
+// 				id: 2,
+// 				createdAt: date,
+// 				name: 'Second',
+// 			});
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find many - no rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbUser.findMany();
+
+// 			expect(result).toStrictEqual([]);
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find many - multiple rows', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbUser.findMany({
+// 				orderBy: {
+// 					id: 'desc',
+// 				},
+// 			});
+
+// 			expect(result).toStrictEqual([{
+// 				id: 2,
+// 				createdAt: date,
+// 				name: 'Second',
+// 			}, {
+// 				id: 1,
+// 				createdAt: date,
+// 				name: 'First',
+// 			}]);
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find many - with relation', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.insert(rqbPost).values([{
+// 			id: 1,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: null,
+// 		}, {
+// 			id: 2,
+// 			userId: 1,
+// 			createdAt: date,
+// 			content: 'Has message this time',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const result = await db.query.rqbPost.findMany({
+// 				with: {
+// 					author: true,
+// 				},
+// 				orderBy: {
+// 					id: 'asc',
+// 				},
+// 			});
+
+// 			expect(result).toStrictEqual([{
+// 				id: 1,
+// 				userId: 1,
+// 				createdAt: date,
+// 				content: null,
+// 				author: {
+// 					id: 1,
+// 					createdAt: date,
+// 					name: 'First',
+// 				},
+// 			}, {
+// 				id: 2,
+// 				userId: 1,
+// 				createdAt: date,
+// 				content: 'Has message this time',
+// 				author: {
+// 					id: 1,
+// 					createdAt: date,
+// 					name: 'First',
+// 				},
+// 			}]);
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('RQB v2 transaction find many - placeholders', async () => {
+// 	try {
+// 		await init(db);
+
+// 		const date = new Date(120000);
+
+// 		await db.insert(rqbUser).values([{
+// 			id: 1,
+// 			createdAt: date,
+// 			name: 'First',
+// 		}, {
+// 			id: 2,
+// 			createdAt: date,
+// 			name: 'Second',
+// 		}]);
+
+// 		await db.transaction(async (db) => {
+// 			const query = db.query.rqbUser.findMany({
+// 				where: {
+// 					id: {
+// 						eq: sql.placeholder('filter'),
+// 					},
+// 				},
+// 				orderBy: {
+// 					id: 'asc',
+// 				},
+// 			}).prepare('rqb_v2_find_many_placeholders');
+
+// 			const result = await query.execute({
+// 				filter: 2,
+// 			});
+
+// 			expect(result).toStrictEqual([{
+// 				id: 2,
+// 				createdAt: date,
+// 				name: 'Second',
+// 			}]);
+// 		});
+// 	} finally {
+// 		await clear(db);
+// 	}
+// });
+
+// test('all types ~codecs~', async () => {
+// 	const en = pgEnum('en_49', ['enVal1', 'enVal2']);
+// 	const allTypesTable = pgTable('all_types_48_cdcs', {
+// 		serial: serial('serial'),
+// 		bigserial: bigserial('bigserial', {
+// 			mode: 'bigint',
+// 		}),
+// 		bigserialnum: bigserial('bigserialnum', {
+// 			mode: 'number',
+// 		}),
+// 		int: integer('int'),
+// 		bigint: bigint('bigint', {
+// 			mode: 'bigint',
+// 		}),
+// 		bigintnum: bigint('bigintnum', {
+// 			mode: 'number',
+// 		}),
+// 		bigintstr: bigint('bigintstr', {
+// 			mode: 'string',
+// 		}),
+// 		bit: bit('bit', { dimensions: 3 }),
+// 		bool: boolean('bool'),
+// 		bytea: bytea('bytea'),
+// 		char: char('char'),
+// 		cidr: cidr('cidr'),
+// 		date: date('date', {
+// 			mode: 'date',
+// 		}),
+// 		datestr: date('datestr', {
+// 			mode: 'string',
+// 		}),
+// 		double: doublePrecision('double'),
+// 		enum: en('enum'),
+// 		inet: inet('inet'),
+// 		interval: interval('interval'),
+// 		json: json('json'),
+// 		jsonb: jsonb('jsonb'),
+// 		json1: json('json1'),
+// 		jsonb1: jsonb('jsonb1'),
+// 		json2: json('json2'),
+// 		jsonb2: jsonb('jsonb2'),
+// 		json3: json('json3'),
+// 		jsonb3: jsonb('jsonb3'),
+// 		line: line('line', {
+// 			mode: 'abc',
+// 		}),
+// 		linetuple: line('linetuple', {
+// 			mode: 'tuple',
+// 		}),
+// 		macaddr: macaddr('macaddr'),
+// 		macaddr8: macaddr8('macaddr8'),
+// 		numeric: numeric('numeric'),
+// 		numericnum: numeric('numericnum', {
+// 			mode: 'number',
+// 		}),
+// 		numericbig: numeric('numericbig', {
+// 			mode: 'bigint',
+// 		}),
+// 		point: point('point', {
+// 			mode: 'xy',
+// 		}),
+// 		pointtuple: point('pointtuple', {
+// 			mode: 'tuple',
+// 		}),
+// 		real: real('real'),
+// 		smallint: smallint('smallint'),
+// 		smallserial: smallserial('smallserial'),
+// 		text: text('text'),
+// 		time: time('time'),
+// 		timestamp: timestamp('timestamp', {
+// 			mode: 'date',
+// 		}),
+// 		timestampTz: timestamp('timestampTz', {
+// 			mode: 'date',
+// 			withTimezone: true,
+// 		}),
+// 		timestampstr: timestamp('timestampstr', {
+// 			mode: 'string',
+// 		}),
+// 		timestampTzstr: timestamp('timestampTzstr', {
+// 			mode: 'string',
+// 			withTimezone: true,
+// 		}),
+// 		uuid: uuid('uuid'),
+// 		varchar: varchar('varchar'),
+// 		arrint: integer('arrint').array(),
+// 		arrbigint: bigint('arrbigint', {
+// 			mode: 'bigint',
+// 		}).array(),
+// 		arrbigintnum: bigint('arrbigintnum', {
+// 			mode: 'number',
+// 		}).array(),
+// 		arrbigintstr: bigint('arrbigintstr', {
+// 			mode: 'string',
+// 		}).array(),
+// 		arrbit: bit('arrbit', { dimensions: 3 }).array(),
+// 		arrbool: boolean('arrbool').array(),
+// 		arrbytea: bytea('arrbytea').array(),
+// 		// mtxbytea: bytea('mtxbytea').array('[][]'), // AWS Data API does not support multidimensional arrays in results
+// 		arrchar: char('arrchar').array(),
+// 		arrcidr: cidr('arrcidr').array(),
+// 		arrdate: date('arrdate', {
+// 			mode: 'date',
+// 		}).array(),
+// 		arrdatestr: date('arrdatestr', {
+// 			mode: 'string',
+// 		}).array(),
+// 		arrdouble: doublePrecision('arrdouble').array(),
+// 		arrenum: en('arrenum').array(),
+// 		arrinet: inet('arrinet').array(),
+// 		arrinterval: interval('arrinterval').array(),
+// 		arrjson: json('arrjson').array(),
+// 		arrjsonb: jsonb('arrjsonb').array(),
+// 		arrjson1: json('arrjson1').array(),
+// 		arrjsonb1: jsonb('arrjsonb1').array(),
+// 		arrjson2: json('arrjson2').array(),
+// 		arrjsonb2: jsonb('arrjsonb2').array(),
+// 		arrjson3: json('arrjson3').array(),
+// 		arrjsonb3: jsonb('arrjsonb3').array(),
+// 		arrline: line('arrline', {
+// 			mode: 'abc',
+// 		}).array(),
+// 		arrlinetuple: line('arrlinetuple', {
+// 			mode: 'tuple',
+// 		}).array(),
+// 		arrmacaddr: macaddr('arrmacaddr').array(),
+// 		arrmacaddr8: macaddr8('arrmacaddr8').array(),
+// 		arrnumeric: numeric('arrnumeric').array(),
+// 		arrnumericnum: numeric('arrnumericnum', { mode: 'number' }).array(),
+// 		arrnumericbig: numeric('arrnumericbig', { mode: 'bigint' }).array(),
+// 		arrpoint: point('arrpoint', {
+// 			mode: 'xy',
+// 		}).array(),
+// 		arrpointtuple: point('arrpointtuple', {
+// 			mode: 'tuple',
+// 		}).array(),
+// 		arrreal: real('arrreal').array(),
+// 		arrsmallint: smallint('arrsmallint').array(),
+// 		arrtext: text('arrtext').array(),
+// 		arrtime: time('arrtime').array(),
+// 		arrtimestamp: timestamp('arrtimestamp', {
+// 			mode: 'date',
+// 		}).array(),
+// 		arrtimestampTz: timestamp('arrtimestampTz', {
+// 			mode: 'date',
+// 			withTimezone: true,
+// 		}).array(),
+// 		arrtimestampstr: timestamp('arrtimestampstr', {
+// 			mode: 'string',
+// 		}).array(),
+// 		arrtimestampTzstr: timestamp('arrtimestampTzstr', {
+// 			mode: 'string',
+// 			withTimezone: true,
+// 		}).array(),
+// 		arruuid: uuid('arruuid').array(),
+// 		arrvarchar: varchar('arrvarchar').array(),
+// 	});
+
+// 	const relations = defineRelations({ allTypesTable }, (r) => ({
+// 		allTypesTable: {
+// 			self: r.many.allTypesTable({
+// 				from: r.allTypesTable.serial,
+// 				to: r.allTypesTable.serial,
+// 			}),
+// 		},
+// 	}));
+// 	const db = drizzle({
+// 		...credentials,
+// 		client: rdsClient,
+// 		logger: ENABLE_LOGGING,
+// 		relations,
+// 	});
+
+// 	const { diff } = await import('../../../drizzle-kit/tests/postgres/mocks' as string);
+// 	const res = await diff({}, { en, allTypesTable }, []);
+// 	for (const s of res.sqlStatements) {
+// 		await db.execute(s);
+// 	}
+
+// 	type ExpectedType = {
+// 		serial: number;
+// 		bigserial: bigint;
+// 		bigserialnum: number;
+// 		int: number | null;
+// 		bigint: bigint | null;
+// 		bigintnum: number | null;
+// 		bigintstr: string | null;
+// 		bit: string | null;
+// 		bool: boolean | null;
+// 		bytea: Buffer | null;
+// 		char: string | null;
+// 		cidr: string | null;
+// 		date: Date | null;
+// 		datestr: string | null;
+// 		double: number | null;
+// 		enum: 'enVal1' | 'enVal2' | null;
+// 		inet: string | null;
+// 		interval: string | null;
+// 		json: unknown;
+// 		jsonb: unknown;
+// 		json1: unknown;
+// 		jsonb1: unknown;
+// 		json2: unknown;
+// 		jsonb2: unknown;
+// 		json3: unknown;
+// 		jsonb3: unknown;
+// 		line: { a: number; b: number; c: number } | null;
+// 		linetuple: [number, number, number] | null;
+// 		macaddr: string | null;
+// 		macaddr8: string | null;
+// 		numeric: string | null;
+// 		numericnum: number | null;
+// 		numericbig: bigint | null;
+// 		point: { x: number; y: number } | null;
+// 		pointtuple: [number, number] | null;
+// 		real: number | null;
+// 		smallint: number | null;
+// 		smallserial: number;
+// 		text: string | null;
+// 		time: string | null;
+// 		timestamp: Date | null;
+// 		timestampTz: Date | null;
+// 		timestampstr: string | null;
+// 		timestampTzstr: string | null;
+// 		uuid: string | null;
+// 		varchar: string | null;
+// 		arrint: number[] | null;
+// 		arrbigint: bigint[] | null;
+// 		arrbigintnum: number[] | null;
+// 		arrbigintstr: string[] | null;
+// 		arrbit: string[] | null;
+// 		arrbool: boolean[] | null;
+// 		arrbytea: (Buffer)[] | null;
+// 		// mtxbytea: (Buffer)[][] | null;
+// 		arrchar: string[] | null;
+// 		arrcidr: string[] | null;
+// 		arrdate: Date[] | null;
+// 		arrdatestr: string[] | null;
+// 		arrdouble: number[] | null;
+// 		arrenum: ('enVal1' | 'enVal2')[] | null;
+// 		arrinet: string[] | null;
+// 		arrinterval: string[] | null;
+// 		arrjson: unknown[] | null;
+// 		arrjsonb: unknown[] | null;
+// 		arrjson1: unknown[] | null;
+// 		arrjsonb1: unknown[] | null;
+// 		arrjson2: unknown[] | null;
+// 		arrjsonb2: unknown[] | null;
+// 		arrjson3: unknown[] | null;
+// 		arrjsonb3: unknown[] | null;
+// 		arrline: { a: number; b: number; c: number }[] | null;
+// 		arrlinetuple: [number, number, number][] | null;
+// 		arrmacaddr: string[] | null;
+// 		arrmacaddr8: string[] | null;
+// 		arrnumeric: string[] | null;
+// 		arrnumericnum: number[] | null;
+// 		arrnumericbig: bigint[] | null;
+// 		arrpoint: { x: number; y: number }[] | null;
+// 		arrpointtuple: [number, number][] | null;
+// 		arrreal: number[] | null;
+// 		arrsmallint: number[] | null;
+// 		arrtext: string[] | null;
+// 		arrtime: string[] | null;
+// 		arrtimestamp: Date[] | null;
+// 		arrtimestampTz: Date[] | null;
+// 		arrtimestampstr: string[] | null;
+// 		arrtimestampTzstr: string[] | null;
+// 		arruuid: string[] | null;
+// 		arrvarchar: string[] | null;
+// 	};
+
+// 	const testData: ExpectedType = {
+// 		serial: 1,
+// 		bigserial: 5044565289845416380n,
+// 		bigserialnum: 9007199254740991,
+// 		int: 621,
+// 		bigint: 5044565289845416380n,
+// 		bigintnum: 9007199254740991,
+// 		bigintstr: '5044565289845416380',
+// 		bit: '101',
+// 		bool: true,
+// 		bytea: Buffer.from('BYTES'),
+// 		char: 'c',
+// 		cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+// 		date: new Date('2025-03-12'),
+// 		datestr: '2025-03-12',
+// 		double: 15.35325689124218,
+// 		enum: 'enVal1',
+// 		inet: '192.168.0.1/24',
+// 		interval: '-2 mons',
+// 		json: { str: 'strval', arr: ['str', 10] },
+// 		jsonb: { arr: ['strb', 11], str: 'strvalb' },
+// 		json1: [{ key: 'value', num: 7 }, 'v', '11', 5],
+// 		jsonb1: [{ key: 'value', num: 8 }, 'x', '10', 3],
+// 		json2: 5,
+// 		jsonb2: 7,
+// 		json3: '5',
+// 		jsonb3: '7',
+// 		line: { a: 1, b: 2, c: 3 },
+// 		linetuple: [1, 2, 3],
+// 		macaddr: '08:00:2b:01:02:03',
+// 		macaddr8: '08:00:2b:01:02:03:04:05',
+// 		numeric: '5044565289845416380',
+// 		numericnum: 9007199254740991,
+// 		numericbig: 5044565289845416380n,
+// 		point: { x: 24.5, y: 49.6 },
+// 		pointtuple: [24.5, 49.6],
+// 		real: 1.048596,
+// 		smallint: 10,
+// 		smallserial: 15,
+// 		text: 'TEXT STRING',
+// 		time: '13:59:28',
+// 		timestamp: new Date('2025-03-12 01:32:41.623'),
+// 		timestampTz: new Date('2025-03-12 01:32:41.623+00'),
+// 		timestampstr: '2025-03-12 01:32:41.623',
+// 		timestampTzstr: '2025-03-12 01:32:41.623+00',
+// 		uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+// 		varchar: 'C4-',
+// 		arrint: [621],
+// 		arrbigint: [5044565289845416380n],
+// 		arrbigintnum: [9007199254740991],
+// 		arrbigintstr: ['5044565289845416380'],
+// 		arrbit: ['101'],
+// 		arrbool: [true],
+// 		arrbytea: [Buffer.from('BYTES')],
+// 		// mtxbytea: [[Buffer.from('BYTES'), Buffer.from('BYTES2')], [
+// 		// 	Buffer.from('OTHERBYTES'),
+// 		// 	Buffer.from('OTHERBYTES2'),
+// 		// ]],
+// 		arrchar: ['c'],
+// 		arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+// 		arrdate: [new Date('2025-03-12')],
+// 		arrdatestr: ['2025-03-12'],
+// 		arrdouble: [15.35325689124218],
+// 		arrenum: ['enVal1'],
+// 		arrinet: ['192.168.0.1/24'],
+// 		arrinterval: ['-2 mons'],
+// 		arrjson: [{ str: 'strval', arr: ['str', 10] }],
+// 		arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+// 		arrjson1: [[{ key: 'value', num: 7 }, 'v', '11', 5]],
+// 		arrjsonb1: [[{ key: 'value', num: 8 }, 'x', '10', 3]],
+// 		arrjson2: [5],
+// 		arrjsonb2: [7],
+// 		arrjson3: ['5'],
+// 		arrjsonb3: ['7'],
+// 		arrline: [{ a: 1, b: 2, c: 3 }],
+// 		arrlinetuple: [[1, 2, 3]],
+// 		arrmacaddr: ['08:00:2b:01:02:03'],
+// 		arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+// 		arrnumeric: ['5044565289845416380'],
+// 		arrnumericnum: [9007199254740991],
+// 		arrnumericbig: [5044565289845416380n],
+// 		arrpoint: [{ x: 24.5, y: 49.6 }],
+// 		arrpointtuple: [[24.5, 49.6]],
+// 		arrreal: [1.048596],
+// 		arrsmallint: [10],
+// 		arrtext: ['TEXT STRING'],
+// 		arrtime: ['13:59:28'],
+// 		arrtimestamp: [new Date('2025-03-12 01:32:41.623')],
+// 		arrtimestampTz: [new Date('2025-03-12 01:32:41.623+00')],
+// 		arrtimestampstr: ['2025-03-12 01:32:41.623'],
+// 		arrtimestampTzstr: ['2025-03-12 01:32:41.623+00'],
+// 		arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+// 		arrvarchar: ['C4-'],
+// 	};
+// 	await db.insert(allTypesTable).values(testData);
+
+// 	const queryRes = await db.execute<ExpectedType>(db.select().from(allTypesTable)).then((e) =>
+// 		normalizeDataWithDbCodecs({
+// 			db,
+// 			columns: getColumns(allTypesTable),
+// 			data: e.rows ?? e,
+// 			mode: 'query',
+// 		})[0]
+// 	);
+
+// 	const { relationRes, rootRes } = await db.execute(db.query.allTypesTable.findFirst({
+// 		with: {
+// 			self: true,
+// 		},
+// 	})).then((e: any) => {
+// 		const [{ self: relationRaw, ...rootRaw }] = e.rows ?? e;
+
+// 		return {
+// 			relationRes: normalizeDataWithDbCodecs({
+// 				db,
+// 				columns: getColumns(allTypesTable),
+// 				data: relationRaw,
+// 				mode: 'json',
+// 			})[0]!,
+// 			rootRes: normalizeDataWithDbCodecs({
+// 				db,
+// 				columns: getColumns(allTypesTable),
+// 				data: [rootRaw],
+// 				mode: 'query',
+// 			})[0]!,
+// 		};
+// 	});
+
+// 	expect(queryRes).toStrictEqual(testData);
+// 	expect(relationRes).toStrictEqual(testData);
+// 	expect(rootRes).toStrictEqual(testData);
+// });
+
+// afterAll(async () => {
+// 	await db.execute(sql`drop table if exists "users"`);
+// 	await db.execute(sql`drop table if exists "todo_user"`);
+// 	await db.execute(sql`drop table if exists "user"`);
+// 	await db.execute(sql`drop table if exists "todo"`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+// 	await db.execute(sql`drop table if exists all_types_48_cdcs`);
+// 	await db.execute(sql`drop type if exists en_49`);
+// });
diff --git a/integration-tests/tests/pg/common-cache.ts b/integration-tests/tests/pg/common-cache.ts
new file mode 100644
index 0000000000..f2961a4448
--- /dev/null
+++ b/integration-tests/tests/pg/common-cache.ts
@@ -0,0 +1,345 @@
+import { DrizzleQueryError, eq, sql } from 'drizzle-orm';
+import { alias, integer, pgTable } from 'drizzle-orm/pg-core';
+import { describe, expect, vi } from 'vitest';
+import type { Test } from './instrumentation';
+import { postsTable, usersTable } from './schema';
+
+export function tests(test: Test) {
+	describe('caches', () => {
+		test.beforeEach(async ({ caches }) => {
+			const { all, explicit } = caches;
+
+			await explicit.execute(sql`drop schema if exists public cascade`);
+			await explicit.$cache?.invalidate({ tables: 'users' });
+			await all.$cache?.invalidate({ tables: 'users' });
+			await explicit.execute(sql`create schema public`);
+			// public users
+			await explicit.execute(
+				sql`
+					create table users (
+						id serial primary key,
+						name text not null,
+						verified boolean not null default false,
+						jsonb jsonb,
+						created_at timestamptz not null default now()
+					)
+				`,
+			);
+		});
+
+		test('test force invalidate', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			using spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
+			await db.$cache?.invalidate({ tables: 'users' });
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test('default global config - no cache should be hit', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test('default global config + enable cache on select: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache();
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test('default global config + enable cache on select + write: get, put, onMutate', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			spyPut.mockClear();
+			spyGet.mockClear();
+			spyInvalidate.mockClear();
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test('default global config + enable cache on select + disable invalidate: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			// invalidate force
+			await db.$cache?.invalidate({ tags: ['custom'] });
+		});
+
+		test('global: true + disable cache', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache(false);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test('global: true - cache should be hit', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable);
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test('global: true - cache: false on select - no cache hit', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache(false);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test('global: true - disable invalidate - cache hit + no invalidate', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			spyPut.mockClear();
+			spyGet.mockClear();
+			spyInvalidate.mockClear();
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test('global: true - with custom tag', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			// invalidate force
+			await db.$cache?.invalidate({ tags: ['custom'] });
+		});
+
+		test('global: true - with custom tag + with autoinvalidate', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ tag: 'custom' });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+
+			// invalidate force
+			await db.$cache?.invalidate({ tags: ['custom'] });
+		});
+
+		// check select used tables
+		test('check simple select used tables', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
+			// @ts-expect-error
+			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
+		});
+		// check select+join used tables
+		test('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
+				.toStrictEqual(['users', 'posts']);
+			expect(
+				// @ts-expect-error
+				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
+			).toStrictEqual(['users', 'posts']);
+		});
+		// check select+2join used tables
+		test('select+2joins', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			expect(
+				db.select().from(usersTable).leftJoin(
+					postsTable,
+					eq(usersTable.id, postsTable.userId),
+				).leftJoin(
+					alias(postsTable, 'post2'),
+					eq(usersTable.id, postsTable.userId),
+				)
+					// @ts-expect-error
+					.getUsedTables(),
+			)
+				.toStrictEqual(['users', 'posts']);
+			expect(
+				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).leftJoin(
+					alias(postsTable, 'post2'),
+					eq(usersTable.id, postsTable.userId),
+					// @ts-expect-error
+				).getUsedTables(),
+			).toStrictEqual(['users', 'posts']);
+		});
+		// select subquery used tables
+		test('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
+			db.select().from(sq);
+
+			// @ts-expect-error
+			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4677
+		test('select+join+with', async ({ caches, push }) => {
+			const { all: db } = caches;
+
+			const shortLink = pgTable('short-link', {
+				id: integer().primaryKey(),
+				createdBy: integer().references(() => usersTable.id),
+			});
+
+			await push({ shortLink });
+
+			// using spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			const shortLinkClickCount = db.$with('shortLinkClickCount').as(db.select().from(shortLink));
+
+			const query = db.with(shortLinkClickCount).select().from(shortLinkClickCount).leftJoin(
+				usersTable,
+				eq(usersTable.id, shortLinkClickCount.createdBy),
+			);
+			// @ts-expect-error
+			const usedTables = query.getUsedTables();
+			expect(usedTables).toStrictEqual(['short-link', 'users']);
+
+			await query;
+			await db.insert(usersTable).values({ id: 1, name: 'Alex' });
+			await db.insert(shortLink).values({ id: 1, createdBy: 1 });
+
+			expect(spyInvalidate).toHaveBeenCalledTimes(2);
+		});
+
+		// Test itself passes, but breaks 'insert via db.execute w/ query builder' tests later on
+		// need to revisit test cleanup
+		test.skipIf(Date.now() < +new Date('2026-07-01'))('Query error wrapping', async ({ db, push }) => {
+			const table = pgTable('somethingelse_error_wrap_slowpath', (t) => ({
+				id: t.integer().primaryKey(),
+				name: t.text().notNull(),
+			}));
+
+			await push({ table });
+			await expect(db.insert(table).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]))
+				.rejects.toBeInstanceOf(DrizzleQueryError);
+		});
+	});
+}
diff --git a/integration-tests/tests/pg/common-pt1.ts b/integration-tests/tests/pg/common-pt1.ts
new file mode 100644
index 0000000000..4245852736
--- /dev/null
+++ b/integration-tests/tests/pg/common-pt1.ts
@@ -0,0 +1,1860 @@
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import { and, asc, eq, exists, gt, inArray, lt, notInArray, sql } from 'drizzle-orm';
+import {
+	alias,
+	boolean,
+	char,
+	cidr,
+	inet,
+	integer,
+	jsonb,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgTable,
+	pgTableCreator,
+	serial,
+	text,
+	timestamp,
+	uuid,
+} from 'drizzle-orm/pg-core';
+import { describe, expect } from 'vitest';
+import type { Test } from './instrumentation';
+
+export function tests(test: Test) {
+	describe('common', () => {
+		test.concurrent('select all fields', async ({ db, push }) => {
+			const users = pgTable('users_1', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			const now = Date.now();
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
+			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+		});
+
+		test.concurrent('select sql', async ({ db, push }) => {
+			const users = pgTable('users_2', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const res = await db.select({ name: sql`upper(${users.name})` }).from(users);
+
+			expect(res).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('select typed sql', async ({ db, push }) => {
+			const users = pgTable('users_3', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+
+			const usersResult = await db.select({
+				name: sql<string>`upper(${users.name})`,
+			}).from(users);
+
+			expect(usersResult).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('select with empty array in inArray', async ({ db, push }) => {
+			const users = pgTable('users_4', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${users.name})`,
+				})
+				.from(users)
+				.where(inArray(users.id, []));
+
+			expect(result).toEqual([]);
+		});
+
+		test.concurrent('select with empty array in notInArray', async ({ db, push }) => {
+			const users = pgTable('users_5', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${users.name})`,
+				})
+				.from(users)
+				.where(notInArray(users.id, []));
+
+			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+		});
+
+		test.concurrent('$default function', async ({ db, push }) => {
+			const orders = pgTable('orders_1', {
+				id: serial('id').primaryKey(),
+				region: text('region').notNull(),
+				product: text('product').notNull().$default(() => 'random_string'),
+				amount: integer('amount').notNull(),
+				quantity: integer('quantity').notNull(),
+			});
+
+			await push({ orders });
+
+			const insertedOrder = await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 })
+				.returning();
+			const selectedOrder = await db.select().from(orders);
+
+			expect(insertedOrder).toEqual([{
+				id: 1,
+				amount: 1,
+				quantity: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			}]);
+
+			expect(selectedOrder).toEqual([{
+				id: 1,
+				amount: 1,
+				quantity: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			}]);
+		});
+
+		test.concurrent('select distinct', async ({ db, push }) => {
+			const usersDistinctTable = pgTable('users_distinct_101', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+				age: integer('age').notNull(),
+			});
+
+			await push({ usersDistinctTable });
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 2, name: 'John', age: 25 },
+				{ id: 1, name: 'Jane', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+			]);
+			const users1 = await db.selectDistinct().from(usersDistinctTable).orderBy(
+				usersDistinctTable.id,
+				usersDistinctTable.name,
+			);
+			const users2 = await db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
+				usersDistinctTable.id,
+			);
+			const users3 = await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
+				usersDistinctTable,
+			).orderBy(usersDistinctTable.name);
+			const users4 = await db.selectDistinctOn([usersDistinctTable.id, usersDistinctTable.age]).from(
+				usersDistinctTable,
+			).orderBy(usersDistinctTable.id, usersDistinctTable.age);
+
+			expect(users1).toEqual([
+				{ id: 1, name: 'Jane', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 2, name: 'John', age: 25 },
+			]);
+
+			expect(users2).toHaveLength(2);
+			expect(users2[0]?.id).toBe(1);
+			expect(users2[1]?.id).toBe(2);
+
+			expect(users3).toHaveLength(2);
+			expect(users3[0]?.name).toBe('Jane');
+			expect(users3[1]?.name).toBe('John');
+
+			expect(users4).toEqual([
+				{ id: 1, name: 'John', age: 24 },
+				{ id: 1, name: 'Jane', age: 26 },
+				{ id: 2, name: 'John', age: 25 },
+			]);
+		});
+
+		test.concurrent('insert returning sql', async ({ db, push }) => {
+			const users = pgTable('users_6', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const usersResult = await db
+				.insert(users)
+				.values({ name: 'John' })
+				.returning({
+					name: sql`upper(${users.name})`,
+				});
+
+			expect(usersResult).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('delete returning sql', async ({ db, push }) => {
+			const users = pgTable('users_7', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.delete(users)
+				.where(eq(users.name, 'John'))
+				.returning({
+					name: sql`upper(${users.name})`,
+				});
+
+			expect(usersResult).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('update returning sql', async ({ db, push }) => {
+			const users = pgTable('users_8', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.update(users)
+				.set({ name: 'Jane' })
+				.where(eq(users.name, 'John'))
+				.returning({
+					name: sql`upper(${users.name})`,
+				});
+
+			expect(usersResult).toEqual([{ name: 'JANE' }]);
+		});
+
+		test.concurrent('update with returning all fields', async ({ db, push }) => {
+			const users = pgTable('users_9', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			const now = Date.now();
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.update(users)
+				.set({ name: 'Jane' })
+				.where(eq(users.name, 'John'))
+				.returning();
+
+			expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(usersResult).toEqual([
+				{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+			]);
+		});
+
+		test.concurrent('update with placeholder returning all fields', async ({ db, push }) => {
+			const users = pgTable('users_9_p', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			const now = Date.now();
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.update(users)
+				.set({ name: sql.placeholder('name') })
+				.where(eq(users.name, 'John'))
+				.returning().execute({ name: 'Jane' });
+
+			expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(usersResult).toEqual([
+				{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+			]);
+		});
+
+		test.concurrent('update with returning partial', async ({ db, push }) => {
+			const users = pgTable('users_10', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.update(users)
+				.set({ name: 'Jane' })
+				.where(eq(users.name, 'John'))
+				.returning({
+					id: users.id,
+					name: users.name,
+				});
+
+			expect(usersResult).toEqual([{ id: 1, name: 'Jane' }]);
+		});
+
+		test.concurrent('delete with returning all fields', async ({ db, push }) => {
+			const users = pgTable('users_11', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			const now = Date.now();
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db.delete(users).where(eq(users.name, 'John')).returning();
+
+			expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(usersResult).toEqual([
+				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+			]);
+		});
+
+		test.concurrent('delete with returning partial', async ({ db, push }) => {
+			const users = pgTable('users_12', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db.delete(users).where(eq(users.name, 'John')).returning({
+				id: users.id,
+				name: users.name,
+			});
+
+			expect(usersResult).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert + select', async ({ db, push }) => {
+			const users = pgTable('users_13', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users);
+			expect(result).toEqual([
+				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt },
+			]);
+
+			await db.insert(users).values({ name: 'Jane' });
+			const result2 = await db.select().from(users);
+			expect(result2).toEqual([
+				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+			]);
+		});
+
+		test.concurrent('json insert', async ({ db, push }) => {
+			const users = pgTable('users_14', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John', jsonb: ['foo', 'bar'] });
+			const result = await db
+				.select({
+					id: users.id,
+					name: users.name,
+					jsonb: users.jsonb,
+				})
+				.from(users);
+
+			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+		});
+
+		test.concurrent('char insert', async ({ db, push }) => {
+			const cities = pgTable('cities_15', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: char('state', { length: 2 }),
+			});
+
+			await push({ cities });
+
+			await db.insert(cities).values({ name: 'Austin', state: 'TX' });
+			const result = await db
+				.select({ id: cities.id, name: cities.name, state: cities.state })
+				.from(cities);
+
+			expect(result).toEqual([{ id: 1, name: 'Austin', state: 'TX' }]);
+		});
+
+		test.concurrent('char update', async ({ db, push }) => {
+			const cities = pgTable('cities_16', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: char('state', { length: 2 }),
+			});
+
+			await push({ cities });
+
+			await db.insert(cities).values({ name: 'Austin', state: 'TX' });
+			await db.update(cities).set({ name: 'Atlanta', state: 'GA' }).where(eq(cities.id, 1));
+			const result = await db
+				.select({ id: cities.id, name: cities.name, state: cities.state })
+				.from(cities);
+
+			expect(result).toEqual([{ id: 1, name: 'Atlanta', state: 'GA' }]);
+		});
+
+		test.concurrent('char delete', async ({ db, push }) => {
+			const cities = pgTable('cities_17', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: char('state', { length: 2 }),
+			});
+
+			await push({ cities });
+
+			await db.insert(cities).values({ name: 'Austin', state: 'TX' });
+			await db.delete(cities).where(eq(cities.state, 'TX'));
+			const result = await db
+				.select({ id: cities.id, name: cities.name, state: cities.state })
+				.from(cities);
+
+			expect(result).toEqual([]);
+		});
+
+		test.concurrent('insert with overridden default values', async ({ db, push }) => {
+			const users = pgTable('users_18', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John', verified: true });
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt },
+			]);
+		});
+
+		test.concurrent('insert many', async ({ db, push }) => {
+			const users = pgTable('users_19', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+			});
+
+			await push({ users });
+
+			await db
+				.insert(users)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				]);
+			const result = await db
+				.select({
+					id: users.id,
+					name: users.name,
+					jsonb: users.jsonb,
+					verified: users.verified,
+				})
+				.from(users);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test.concurrent('insert many with returning', async ({ db, push }) => {
+			const users = pgTable('users_20', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+			});
+
+			await push({ users });
+
+			const result = await db
+				.insert(users)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				])
+				.returning({
+					id: users.id,
+					name: users.name,
+					jsonb: users.jsonb,
+					verified: users.verified,
+				});
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test.concurrent('select with group by as field', async ({ db, push }) => {
+			const users = pgTable('users_121', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: users.name })
+				.from(users)
+				.groupBy(users.name);
+
+			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+		});
+
+		test.concurrent('select with exists', async ({ db, push }) => {
+			const users = pgTable('users_122', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const user = alias(users, 'user');
+			const result = await db.select({ name: users.name }).from(users).where(
+				exists(
+					db.select({ one: sql`1` }).from(user).where(and(eq(users.name, 'John'), eq(user.id, users.id))),
+				),
+			);
+
+			expect(result).toEqual([{ name: 'John' }]);
+		});
+
+		test.concurrent('select with group by as sql', async ({ db, push }) => {
+			const users = pgTable('users_23', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: users.name })
+				.from(users)
+				.groupBy(sql`${users.name}`);
+
+			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+		});
+
+		test.concurrent('select with group by as sql + column', async ({ db, push }) => {
+			const users = pgTable('users_24', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: users.name })
+				.from(users)
+				.groupBy(sql`${users.name}`, users.id)
+				.orderBy(users.name);
+
+			expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+		});
+
+		test.concurrent('select with group by as column + sql', async ({ db, push }) => {
+			const users = pgTable('users_25', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: users.name })
+				.from(users)
+				.groupBy(users.id, sql`${users.name}`)
+				.orderBy(users.name);
+
+			expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+		});
+
+		test.concurrent('select with group by complex query', async ({ db, push }) => {
+			const users = pgTable('users_26', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+			const result = await db
+				.select({ name: users.name })
+				.from(users)
+				.groupBy(users.id, sql`${users.name}`)
+				.orderBy(asc(users.name))
+				.limit(1);
+
+			expect(result).toEqual([{ name: 'Jane' }]);
+		});
+
+		test.concurrent('build query', async ({ db, push }) => {
+			const users = pgTable('users_27', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const query = db
+				.select({ id: users.id, name: users.name })
+				.from(users)
+				.groupBy(users.id, users.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql: 'select "id", "name" from "users_27" group by "users_27"."id", "users_27"."name"',
+				params: [],
+			});
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4209
+		test.concurrent('2 consecutive use of .toSQL', async ({ db }) => {
+			const t1 = pgTable('table', (t) => ({
+				id: t.text().primaryKey(),
+			}));
+			const query1 = db.insert(t1).values({ id: '1' }).toSQL();
+			expect(query1).toStrictEqual({ sql: 'insert into "table" ("id") values ($1)', params: ['1'] });
+
+			const t2 = pgTable('table', (t) => ({
+				id: t.text().primaryKey(),
+				name: t.text(),
+			}));
+			const query2 = db.insert(t2).values({ id: '1', name: 'test' }).toSQL();
+			expect(query2).toStrictEqual({
+				sql: 'insert into "table" ("id", "name") values ($1, $2)',
+				params: ['1', 'test'],
+			});
+		});
+
+		test.concurrent('insert sql', async ({ db, push }) => {
+			const users = pgTable('users_128', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: sql`${'John'}` });
+			const result = await db.select({ id: users.id, name: users.name }).from(users);
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('partial join with alias', async ({ db, push }) => {
+			const users = pgTable('users_29', {
+				id: serial('id' as string).primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const customerAlias = alias(users, 'customer');
+
+			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select({
+					user: {
+						id: users.id,
+						name: users.name,
+					},
+					customer: {
+						id: customerAlias.id,
+						name: customerAlias.name,
+					},
+				})
+				.from(users)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(users.id, 10));
+
+			expect(result).toEqual([
+				{
+					user: { id: 10, name: 'Ivan' },
+					customer: { id: 11, name: 'Hans' },
+				},
+			]);
+		});
+
+		test.concurrent('full join with alias', async ({ db, push }) => {
+			const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+			const users = pgTable('users_30', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select()
+				.from(users)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(users.id, 10));
+
+			expect(result).toEqual([{
+				users_30: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			}]);
+		});
+
+		test.concurrent('select from alias', async ({ db, push }) => {
+			const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+			const users = pgTable('users_31', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const user = alias(users, 'user');
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select()
+				.from(user)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(user.id, 10));
+
+			expect(result).toEqual([{
+				user: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			}]);
+		});
+
+		test.concurrent('insert with spaces', async ({ db, push }) => {
+			const usersTable = pgTable('users_32', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test.concurrent('prepared statement', async ({ db, push }) => {
+			const usersTable = pgTable('users_33', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const statement = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.prepare('statement1');
+			const result = await statement.execute();
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('nameless prepared statement', async ({ db, push }) => {
+			const usersTable = pgTable('users_33_nmls', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const statement = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.prepare('get-users');
+			const result1 = await statement.execute();
+			const result2 = await statement.execute();
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert: placeholders on columns with encoder', async ({ db, push }) => {
+			const usersTable = pgTable('users_34', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+			});
+
+			await push({ usersTable });
+
+			const statement = db.insert(usersTable).values({
+				name: 'John',
+				jsonb: sql.placeholder('jsonb'),
+			}).prepare('encoder_statement');
+
+			await statement.execute({ jsonb: ['foo', 'bar'] });
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+					jsonb: usersTable.jsonb,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([
+				{ id: 1, jsonb: ['foo', 'bar'] },
+			]);
+		});
+
+		test.concurrent('prepared statement reuse', async ({ db, push }) => {
+			const usersTable = pgTable('users_35', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+			});
+
+			await push({ usersTable });
+
+			const stmt = db
+				.insert(usersTable)
+				.values({
+					verified: true,
+					name: sql.placeholder('name'),
+				})
+				.prepare('stmt2');
+
+			for (let i = 0; i < 10; i++) {
+				await stmt.execute({ name: `John ${i}` });
+			}
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					verified: usersTable.verified,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John 0', verified: true },
+				{ id: 2, name: 'John 1', verified: true },
+				{ id: 3, name: 'John 2', verified: true },
+				{ id: 4, name: 'John 3', verified: true },
+				{ id: 5, name: 'John 4', verified: true },
+				{ id: 6, name: 'John 5', verified: true },
+				{ id: 7, name: 'John 6', verified: true },
+				{ id: 8, name: 'John 7', verified: true },
+				{ id: 9, name: 'John 8', verified: true },
+				{ id: 10, name: 'John 9', verified: true },
+			]);
+		});
+
+		test.concurrent('prepared statement with placeholder in .where', async ({ db, push }) => {
+			const usersTable = pgTable('users_36', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.prepare('stmt3');
+			const result = await stmt.execute({ id: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('prepared statement with placeholder in .limit', async ({ db, push }) => {
+			const usersTable = pgTable('users_37', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.limit(sql.placeholder('limit'))
+				.prepare('stmt_limit');
+
+			const result = await stmt.execute({ id: 1, limit: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+			expect(result).toHaveLength(1);
+		});
+
+		test.concurrent('prepared statement with placeholder in .offset', async ({ db, push }) => {
+			const usersTable = pgTable('users_38', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.offset(sql.placeholder('offset'))
+				.prepare('stmt_offset');
+
+			const result = await stmt.execute({ offset: 1 });
+
+			expect(result).toEqual([{ id: 2, name: 'John1' }]);
+		});
+
+		test.concurrent('prepared statement built using $dynamic', async ({ db, push }) => {
+			const usersTable = pgTable('users_39', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			function withLimitOffset(qb: any) {
+				return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+			}
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.$dynamic();
+			withLimitOffset(stmt).prepare('stmt_limit');
+
+			const result = await stmt.execute({ limit: 1, offset: 1 });
+
+			expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			expect(result).toHaveLength(1);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4468
+		test.concurrent('prepared statement with placeholder in .where', async ({ db, push }) => {
+			const usersTable = pgTable('users_391', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				createdAt: timestamp('created_at', { withTimezone: true }).notNull().default(sql`now()`),
+			});
+
+			await push({ usersTable });
+			await db.insert(usersTable).values({ name: 'John' });
+			const stmt = db
+				.select()
+				.from(usersTable)
+				.where(lt(usersTable.createdAt, sql`now() - ${sql.placeholder('timeWindow')}::interval`))
+				.prepare('get_old_users');
+
+			const result = await stmt.execute({ timeWindow: '40 days' });
+
+			expect(result).toEqual([]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/2872
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'prepared statement with placeholder in .inArray',
+			async ({ db, push }) => {
+				const usersTable = pgTable('users_392', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ usersTable });
+				await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({ name: usersTable.name })
+					.from(usersTable)
+					.where(inArray(usersTable.name, sql.placeholder('names')))
+					.prepare('get_users');
+
+				const result = await stmt.execute({ names: ['John', 'John1'] });
+
+				expect(result).toStrictEqual([{ name: 'John' }, { name: 'John1' }]);
+			},
+		);
+
+		test.concurrent('Insert all defaults in 1 row', async ({ db, push }) => {
+			const users = pgTable('users_42', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({});
+
+			const res = await db.select().from(users);
+
+			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
+		});
+
+		test.concurrent('Insert all defaults in multiple rows', async ({ db, push }) => {
+			const users = pgTable('users_43', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{}, {}]);
+
+			const res = await db.select().from(users);
+
+			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+		});
+
+		test.concurrent('insert with onConflict do update', async ({ db, push }) => {
+			const usersTable = pgTable('users_48', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John1' }]);
+		});
+
+		test.concurrent('insert with onConflict do update placeholder', async ({ db, push }) => {
+			const usersTable = pgTable('users_48_p', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoUpdate({ target: usersTable.id, set: { name: sql.placeholder('name') } })
+				.execute({ name: 'John1' });
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John1' }]);
+		});
+
+		test.concurrent('insert with onConflict do nothing', async ({ db, push }) => {
+			const usersTable = pgTable('users_49', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing();
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert with onConflict do nothing + target', async ({ db, push }) => {
+			const usersTable = pgTable('users_50', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoNothing({ target: usersTable.id });
+
+			const res = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1));
+
+			expect(res).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('left join (flat object fields)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_51', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const users2Table = pgTable('users2_51', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+				})
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{ userId: 1, userName: 'John', cityId, cityName: 'Paris' },
+				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+			]);
+		});
+
+		test.concurrent('left join (grouped fields)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_52', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const users2Table = pgTable('users2_52', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select({
+					id: users2Table.id,
+					user: {
+						name: users2Table.name,
+						nameUpper: sql<string>`upper(${users2Table.name})`,
+					},
+					city: {
+						id: citiesTable.id,
+						name: citiesTable.name,
+						nameUpper: sql<string>`upper(${citiesTable.name})`,
+					},
+				})
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{
+					id: 1,
+					user: { name: 'John', nameUpper: 'JOHN' },
+					city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
+				},
+				{
+					id: 2,
+					user: { name: 'Jane', nameUpper: 'JANE' },
+					city: null,
+				},
+			]);
+		});
+
+		test.concurrent('left join (all fields)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_53', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: text('state'),
+			});
+
+			const users2Table = pgTable('users2_53', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			const { id: cityId } = await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }])
+				.returning({ id: citiesTable.id })
+				.then((rows) => rows[0]!);
+
+			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+			const res = await db
+				.select()
+				.from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+			expect(res).toEqual([
+				{
+					users2_53: {
+						id: 1,
+						name: 'John',
+						cityId,
+					},
+					cities_53: {
+						id: cityId,
+						name: 'Paris',
+						state: null,
+					},
+				},
+				{
+					users2_53: {
+						id: 2,
+						name: 'Jane',
+						cityId: null,
+					},
+					cities_53: null,
+				},
+			]);
+		});
+
+		test.concurrent('join subquery', async ({ db, push }) => {
+			const courseCategoriesTable = pgTable('course_categories_54', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const coursesTable = pgTable('courses_54', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				categoryId: integer('category_id').references(() => courseCategoriesTable.id),
+			});
+
+			await push({ courseCategoriesTable, coursesTable });
+
+			await db
+				.insert(courseCategoriesTable)
+				.values([
+					{ name: 'Category 1' },
+					{ name: 'Category 2' },
+					{ name: 'Category 3' },
+					{ name: 'Category 4' },
+				]);
+
+			await db
+				.insert(coursesTable)
+				.values([
+					{ name: 'Development', categoryId: 2 },
+					{ name: 'IT & Software', categoryId: 3 },
+					{ name: 'Marketing', categoryId: 4 },
+					{ name: 'Design', categoryId: 1 },
+				]);
+
+			const sq2 = db
+				.select({
+					categoryId: courseCategoriesTable.id,
+					category: courseCategoriesTable.name,
+					total: sql<number>`count(${courseCategoriesTable.id})`,
+				})
+				.from(courseCategoriesTable)
+				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+				.as('sq2');
+
+			const res = await db
+				.select({
+					courseName: coursesTable.name,
+					categoryId: sq2.categoryId,
+				})
+				.from(coursesTable)
+				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+				.orderBy(coursesTable.name);
+
+			expect(res).toEqual([
+				{ courseName: 'Design', categoryId: 1 },
+				{ courseName: 'Development', categoryId: 2 },
+				{ courseName: 'IT & Software', categoryId: 3 },
+				{ courseName: 'Marketing', categoryId: 4 },
+			]);
+		});
+
+		test.concurrent('with ... select', async ({ db, push }) => {
+			const orders = pgTable('orders_55', {
+				region: text('region').notNull(),
+				product: text('product').notNull(),
+				amount: integer('amount').notNull(),
+				quantity: integer('quantity').notNull(),
+			});
+
+			await push({ orders });
+
+			await db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const regionalSales = db
+				.$with('regional_sales')
+				.as(
+					db
+						.select({
+							region: orders.region,
+							totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+						})
+						.from(orders)
+						.groupBy(orders.region),
+				);
+
+			const topRegions = db
+				.$with('top_regions')
+				.as(
+					db
+						.select({
+							region: regionalSales.region,
+						})
+						.from(regionalSales)
+						.where(
+							gt(
+								regionalSales.totalSales,
+								db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+							),
+						),
+				);
+
+			const result1 = await db
+				.with(regionalSales, topRegions)
+				.select({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`sum(${orders.quantity})::int`,
+					productSales: sql<number>`sum(${orders.amount})::int`,
+				})
+				.from(orders)
+				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product);
+			const result2 = await db
+				.with(regionalSales, topRegions)
+				.selectDistinct({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`sum(${orders.quantity})::int`,
+					productSales: sql<number>`sum(${orders.amount})::int`,
+				})
+				.from(orders)
+				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product);
+			const result3 = await db
+				.with(regionalSales, topRegions)
+				.selectDistinctOn([orders.region], {
+					region: orders.region,
+					productUnits: sql<number>`sum(${orders.quantity})::int`,
+					productSales: sql<number>`sum(${orders.amount})::int`,
+				})
+				.from(orders)
+				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+				.groupBy(orders.region)
+				.orderBy(orders.region);
+
+			expect(result1).toEqual([
+				{
+					region: 'Europe',
+					product: 'A',
+					productUnits: 3,
+					productSales: 30,
+				},
+				{
+					region: 'Europe',
+					product: 'B',
+					productUnits: 5,
+					productSales: 50,
+				},
+				{
+					region: 'US',
+					product: 'A',
+					productUnits: 7,
+					productSales: 70,
+				},
+				{
+					region: 'US',
+					product: 'B',
+					productUnits: 9,
+					productSales: 90,
+				},
+			]);
+			expect(result2).toEqual(result1);
+			expect(result3).toEqual([
+				{
+					region: 'Europe',
+					productUnits: 8,
+					productSales: 80,
+				},
+				{
+					region: 'US',
+					productUnits: 16,
+					productSales: 160,
+				},
+			]);
+		});
+
+		test.concurrent('with ... update', async ({ db, push }) => {
+			const products = pgTable('products_56', {
+				id: serial('id').primaryKey(),
+				price: numeric('price').notNull(),
+				cheap: boolean('cheap').notNull().default(false),
+			});
+
+			await push({ products });
+
+			await db.insert(products).values([
+				{ price: '10.99' },
+				{ price: '25.85' },
+				{ price: '32.99' },
+				{ price: '2.50' },
+				{ price: '4.59' },
+			]);
+
+			const averagePrice = db
+				.$with('average_price')
+				.as(
+					db
+						.select({
+							value: sql`avg(${products.price})`.as('value'),
+						})
+						.from(products),
+				);
+
+			const result = await db
+				.with(averagePrice)
+				.update(products)
+				.set({
+					cheap: true,
+				})
+				.where(lt(products.price, sql`(select * from ${averagePrice})`))
+				.returning({
+					id: products.id,
+				});
+
+			expect(result).toEqual([
+				{ id: 1 },
+				{ id: 4 },
+				{ id: 5 },
+			]);
+		});
+
+		test.concurrent('with ... insert', async ({ db, push }) => {
+			const users = pgTable('users_57', {
+				username: text('username').notNull(),
+				admin: boolean('admin').notNull().default(false),
+			});
+
+			await push({ users });
+
+			const userCount = db
+				.$with('user_count')
+				.as(
+					db
+						.select({
+							value: sql`count(*)`.as('value'),
+						})
+						.from(users),
+				);
+
+			const result = await db
+				.with(userCount)
+				.insert(users)
+				.values([
+					{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+				])
+				.returning({
+					admin: users.admin,
+				});
+
+			expect(result).toEqual([{ admin: true }]);
+		});
+
+		test.concurrent('with ... delete', async ({ db, push }) => {
+			const orders = pgTable('orders_58', {
+				id: serial('id').primaryKey(),
+				region: text('region').notNull(),
+				product: text('product').notNull(),
+				amount: integer('amount').notNull(),
+				quantity: integer('quantity').notNull(),
+			});
+
+			await push({ orders });
+
+			await db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const averageAmount = db
+				.$with('average_amount')
+				.as(
+					db
+						.select({
+							value: sql`avg(${orders.amount})`.as('value'),
+						})
+						.from(orders),
+				);
+
+			const result = await db
+				.with(averageAmount)
+				.delete(orders)
+				.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+				.returning({
+					id: orders.id,
+				});
+
+			expect(result).toEqual([
+				{ id: 6 },
+				{ id: 7 },
+				{ id: 8 },
+			]);
+		});
+
+		test.concurrent('select from subquery sql', async ({ db, push }) => {
+			const users2Table = pgTable('users2_59', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users2Table });
+
+			await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+				.from(users2Table)
+				.as('sq');
+
+			const res = await db.select({ name: sq.name }).from(sq);
+
+			expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+		});
+
+		test.concurrent('select count()', async ({ db, push }) => {
+			const usersTable = pgTable('users_62', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const res = await db.select({ count: sql`count(*)::int` }).from(usersTable);
+
+			expect(res).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('select count w/ custom mapper', async ({ db, push }) => {
+			const usersTable = pgTable('users_63', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable });
+
+			function count(value: any): any;
+			function count(value: any, alias: string): any;
+			function count(value: any, alias?: string): any {
+				const result = sql`count(${value})`.mapWith(Number);
+				if (!alias) {
+					return result;
+				}
+				return result.as(alias);
+			}
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const res = await db.select({ count: count(sql`*`) }).from(usersTable);
+
+			expect(res).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('network types', async ({ db, push }) => {
+			const network = pgTable('network_64', {
+				inet: inet('inet').notNull(),
+				cidr: cidr('cidr').notNull(),
+				macaddr: macaddr('macaddr').notNull(),
+				macaddr8: macaddr8('macaddr8').notNull(),
+			});
+
+			await push({ network });
+
+			const value = {
+				inet: '127.0.0.1',
+				cidr: '192.168.100.128/25',
+				macaddr: '08:00:2b:01:02:03',
+				macaddr8: '08:00:2b:01:02:03:04:05',
+			};
+
+			await db.insert(network).values(value);
+
+			const res = await db.select().from(network);
+
+			expect(res).toEqual([value]);
+		});
+
+		test.concurrent('array types', async ({ db, push }) => {
+			const salEmp = pgTable('sal_emp_65', {
+				name: text('name').notNull(),
+				payByQuarter: integer('pay_by_quarter').array().notNull(),
+				schedule: text('schedule').array('[][]').notNull(),
+			});
+
+			await push({ salEmp });
+
+			const values = [
+				{
+					name: 'John',
+					payByQuarter: [10000, 10000, 10000, 10000],
+					schedule: [['meeting', 'lunch'], ['training', 'presentation']],
+				},
+				{
+					name: 'Carol',
+					payByQuarter: [20000, 25000, 25000, 25000],
+					schedule: [['breakfast', 'consulting'], ['meeting', 'lunch']],
+				},
+			];
+
+			await db.insert(salEmp).values(values);
+
+			const res = await db.select().from(salEmp);
+
+			expect(res).toEqual(values);
+		});
+
+		test.concurrent('having', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_85', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const users2Table = pgTable('users2_85', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
+				name: 'Jack',
+				cityId: 2,
+			}]);
+
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+					usersCount: sql<number>`count(${users2Table.id})::int`.as('users_count'),
+				})
+				.from(citiesTable)
+				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+				.where(({ name }) => sql`length(${name}) >= 3`)
+				.groupBy(citiesTable.id)
+				.having(({ usersCount }) => sql`${usersCount} > 0`)
+				.orderBy(({ name }) => name);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'LONDON',
+					usersCount: 2,
+				},
+				{
+					id: 2,
+					name: 'PARIS',
+					usersCount: 1,
+				},
+			]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5780
+		test.concurrent('issue #5780. .onUpdateFn()', async ({ db, push }) => {
+			const table = pgTable('example', {
+				id: uuid('id').primaryKey().defaultRandom(),
+				name: text('name').notNull(),
+				updatedById: text('updated_by_id')
+					.$onUpdate(() => sql`1`)
+					.notNull(),
+			});
+
+			await push({ table });
+
+			await db.insert(table).values({ name: 'foo', updatedById: 'some-uuid' });
+
+			// This should NOT invoke the $onUpdate callback — updatedById is explicitly provided.
+			// ----
+			await db.update(table).set({ name: 'foo', updatedById: 'new-some-uuid-new' }).where(
+				eq(table.updatedById, 'some-uuid'),
+			);
+			const result = (await db.select({ updatedById: table.updatedById }).from(table))[0];
+
+			expect(result).toStrictEqual({
+				updatedById: 'new-some-uuid-new',
+			});
+
+			// ----
+			await db.update(table).set({ name: 'foo' }).where(
+				eq(table.updatedById, 'new-some-uuid-new'),
+			);
+
+			const result2 = (await db.select({ updatedById: table.updatedById }).from(table))[0];
+			expect(result2).toStrictEqual({
+				updatedById: '1',
+			});
+		});
+	});
+}
diff --git a/integration-tests/tests/pg/common-pt2.ts b/integration-tests/tests/pg/common-pt2.ts
new file mode 100644
index 0000000000..3832259b7c
--- /dev/null
+++ b/integration-tests/tests/pg/common-pt2.ts
@@ -0,0 +1,7987 @@
+import {
+	aliasedTable,
+	and,
+	arrayContains,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	desc,
+	DrizzleQueryError,
+	eq,
+	getColumns,
+	getTableColumns,
+	gt,
+	gte,
+	ilike,
+	inArray,
+	is,
+	isNull,
+	like,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	max,
+	min,
+	not,
+	or,
+	SQL,
+	sql,
+	sum,
+	sumDistinct,
+} from 'drizzle-orm';
+import {
+	alias,
+	AnyPgColumn,
+	bigint,
+	bigserial,
+	boolean,
+	bytea,
+	char,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	except,
+	getMaterializedViewConfig,
+	getViewConfig,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	PgAsyncSession,
+	PgDialect,
+	pgEnum,
+	pgSchema,
+	pgTable,
+	pgView,
+	point,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	union,
+	unionAll,
+	uniqueIndex,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { PgliteDatabase } from 'drizzle-orm/pglite';
+import { describe, expect, expectTypeOf } from 'vitest';
+import type { Test } from './instrumentation';
+import { normalizeDataWithDbCodecs } from './utils';
+
+const msDelay = 15000;
+
+export function tests(test: Test) {
+	describe('common', () => {
+		test.concurrent(
+			'set operations (mixed) from query builder with subquery',
+			async ({ db, push }) => {
+				const cities2Table = pgTable('cities_1', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = pgTable('users2_1', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				await push({ cities2Table, users2Table });
+
+				await db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				await db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const sq = db
+					.select()
+					.from(cities2Table)
+					.where(gt(cities2Table.id, 1))
+					.as('sq');
+
+				const result = await db
+					.select()
+					.from(cities2Table)
+					.except(({ unionAll }) =>
+						unionAll(
+							db.select().from(sq),
+							db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+						)
+					);
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+				await expect(
+					(async () => {
+						db.select()
+							.from(cities2Table)
+							.except(({ unionAll }) =>
+								unionAll(
+									db
+										.select({ name: cities2Table.name, id: cities2Table.id })
+										.from(cities2Table)
+										.where(gt(cities2Table.id, 1)),
+									db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+								)
+							);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (mixed all) as function',
+			async ({ db, push }) => {
+				const cities2Table = pgTable('cities_2', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = pgTable('users2_2', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				await push({ cities2Table, users2Table });
+
+				await db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				await db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const result = await union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 7)),
+					),
+					db.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+				).orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(6);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+					{ id: 8, name: 'Sally' },
+				]);
+
+				await expect(
+					(async () => {
+						union(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+							except(
+								db
+									.select({ id: users2Table.id, name: users2Table.name })
+									.from(users2Table)
+									.where(gte(users2Table.id, 5)),
+								db
+									.select({ name: users2Table.name, id: users2Table.id })
+									.from(users2Table)
+									.where(eq(users2Table.id, 7)),
+							),
+							db.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+						).orderBy(asc(sql`id`));
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4189
+		test.concurrent(
+			'set operations; union; date mode',
+			async ({ db, push }) => {
+				const recipes = pgTable('recipes', {
+					id: serial().primaryKey(),
+					publishedAt: timestamp({ mode: 'date' }).defaultNow(),
+				});
+
+				const recipesQuery = db
+					.select({
+						id: recipes.id,
+						publishedAt: recipes.publishedAt,
+					})
+					.from(recipes);
+
+				const creators = pgTable('creators', {
+					id: serial().primaryKey(),
+					publishedAt: timestamp({ mode: 'date' }).defaultNow(),
+				});
+
+				const creatorsQuery = db
+					.select({
+						id: creators.id,
+						publishedAt: creators.publishedAt,
+					})
+					.from(creators);
+
+				await push({ recipes, creators });
+				await db.insert(recipes).values({});
+				await db.insert(creators).values({});
+
+				const unionQuery = union(creatorsQuery, recipesQuery);
+				const result = await unionQuery;
+
+				for (const val of result) {
+					expect(val.publishedAt).toBeInstanceOf(Date);
+				}
+			},
+		);
+
+		test.concurrent('aggregate function: count', async ({ db, push }) => {
+			const aggregateTable = pgTable('aggregate_table_3', {
+				id: serial('id').notNull(),
+				name: text('name').notNull(),
+				value: integer('value'),
+				nullOnly: integer('null_only'),
+			});
+
+			await push({ aggregateTable });
+
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', value: 10 },
+				{ name: 'value 1', value: 20 },
+				{ name: 'value 2', value: 50 },
+				{ name: 'value 3', value: 20 },
+				{ name: 'value 4', value: 90 },
+				{ name: 'value 5', value: 10 },
+				{ name: 'value 6', nullOnly: null },
+			]);
+
+			const result1 = await db.select({ value: count() }).from(aggregateTable);
+			const result2 = await db
+				.select({ value: count(aggregateTable.value) })
+				.from(aggregateTable);
+			const result3 = await db
+				.select({ value: countDistinct(aggregateTable.name) })
+				.from(aggregateTable);
+
+			expect(result1[0]?.value).toBe(7);
+			expect(result2[0]?.value).toBe(6);
+			expect(result3[0]?.value).toBe(6);
+		});
+
+		test.concurrent('aggregate function: avg', async ({ db, push }) => {
+			const aggregateTable = pgTable('aggregate_table_4', {
+				id: serial('id').notNull(),
+				name: text('name').notNull(),
+				value: integer('value'),
+				nullOnly: integer('null_only'),
+			});
+
+			await push({ aggregateTable });
+
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', value: 10 },
+				{ name: 'value 1', value: 20 },
+				{ name: 'value 2', value: 50 },
+				{ name: 'value 3', value: 20 },
+				{ name: 'value 4', value: 90 },
+				{ name: 'value 5', value: 10 },
+				{ name: 'value 6', nullOnly: null },
+			]);
+
+			const result1 = await db
+				.select({ value: avg(aggregateTable.value) })
+				.from(aggregateTable);
+			const result2 = await db
+				.select({ value: avg(aggregateTable.nullOnly) })
+				.from(aggregateTable);
+			const result3 = await db
+				.select({ value: avgDistinct(aggregateTable.value) })
+				.from(aggregateTable);
+
+			expect(result1[0]?.value).toBe('33.3333333333333333');
+			expect(result2[0]?.value).toBeNull();
+			expect(result3[0]?.value).toBe('42.5000000000000000');
+		});
+
+		test.concurrent('aggregate function: sum', async ({ db, push }) => {
+			const aggregateTable = pgTable('aggregate_table_5', {
+				id: serial('id').notNull(),
+				name: text('name').notNull(),
+				value: integer('value'),
+				nullOnly: integer('null_only'),
+			});
+
+			await push({ aggregateTable });
+
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', value: 10 },
+				{ name: 'value 1', value: 20 },
+				{ name: 'value 2', value: 50 },
+				{ name: 'value 3', value: 20 },
+				{ name: 'value 4', value: 90 },
+				{ name: 'value 5', value: 10 },
+				{ name: 'value 6', nullOnly: null },
+			]);
+
+			const result1 = await db
+				.select({ value: sum(aggregateTable.value) })
+				.from(aggregateTable);
+			const result2 = await db
+				.select({ value: sum(aggregateTable.nullOnly) })
+				.from(aggregateTable);
+			const result3 = await db
+				.select({ value: sumDistinct(aggregateTable.value) })
+				.from(aggregateTable);
+
+			expect(result1[0]?.value).toBe('200');
+			expect(result2[0]?.value).toBeNull();
+			expect(result3[0]?.value).toBe('170');
+		});
+
+		test.concurrent('aggregate function: max', async ({ db, push }) => {
+			const aggregateTable = pgTable('aggregate_table_6', {
+				id: serial('id').notNull(),
+				name: text('name').notNull(),
+				value: integer('value'),
+				nullOnly: integer('null_only'),
+			});
+
+			await push({ aggregateTable });
+
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', value: 10 },
+				{ name: 'value 1', value: 20 },
+				{ name: 'value 2', value: 50 },
+				{ name: 'value 3', value: 20 },
+				{ name: 'value 4', value: 90 },
+				{ name: 'value 5', value: 10 },
+				{ name: 'value 6', nullOnly: null },
+			]);
+
+			const result1 = await db
+				.select({ value: max(aggregateTable.value) })
+				.from(aggregateTable);
+			const result2 = await db
+				.select({ value: max(aggregateTable.nullOnly) })
+				.from(aggregateTable);
+
+			expect(result1[0]?.value).toBe(90);
+			expect(result2[0]?.value).toBeNull();
+		});
+
+		test.concurrent('aggregate function: min', async ({ db, push }) => {
+			const aggregateTable = pgTable('aggregate_table_7', {
+				id: serial('id').notNull(),
+				name: text('name').notNull(),
+				value: integer('value'),
+				nullOnly: integer('null_only'),
+			});
+
+			await push({ aggregateTable });
+
+			await db.insert(aggregateTable).values([
+				{ name: 'value 1', value: 10 },
+				{ name: 'value 1', value: 20 },
+				{ name: 'value 2', value: 50 },
+				{ name: 'value 3', value: 20 },
+				{ name: 'value 4', value: 90 },
+				{ name: 'value 5', value: 10 },
+				{ name: 'value 6', nullOnly: null },
+			]);
+
+			const result1 = await db
+				.select({ value: min(aggregateTable.value) })
+				.from(aggregateTable);
+			const result2 = await db
+				.select({ value: min(aggregateTable.nullOnly) })
+				.from(aggregateTable);
+
+			expect(result1[0]?.value).toBe(10);
+			expect(result2[0]?.value).toBeNull();
+		});
+
+		test.concurrent('array mapping and parsing', async ({ db, push }) => {
+			const arrays = pgTable('arrays_tests_7', {
+				id: serial('id').primaryKey(),
+				tags: text('tags').array(),
+				nested: text('nested').array('[][]'),
+				numbers: integer('numbers').notNull().array(),
+			});
+
+			await push({ arrays });
+
+			await db.insert(arrays).values({
+				tags: ['', 'b', 'c'],
+				nested: [
+					['1', ''],
+					['3', '\\a'],
+				],
+				numbers: [1, 2, 3],
+			});
+
+			const result = await db.select().from(arrays);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					tags: ['', 'b', 'c'],
+					nested: [
+						['1', ''],
+						['3', '\\a'],
+					],
+					numbers: [1, 2, 3],
+				},
+			]);
+		});
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works as $default',
+			async ({ db, push }) => {
+				const usersOnUpdate = pgTable('users_on_update_8', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					updateCounter: integer('update_counter')
+						.default(sql`1`)
+						.$onUpdateFn(() => sql`update_counter + 1`),
+					updatedAt: timestamp('updated_at', {
+						mode: 'date',
+						precision: 3,
+					}).$onUpdate(() => new Date()),
+					alwaysNull: text('always_null')
+						.$type<string | null>()
+						.$onUpdate(() => null),
+				});
+
+				await push({ usersOnUpdate });
+
+				await db
+					.insert(usersOnUpdate)
+					.values([
+						{ name: 'John' },
+						{ name: 'Jane' },
+						{ name: 'Jack' },
+						{ name: 'Jill' },
+					]);
+
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+				const justDates = await db
+					.select({ updatedAt })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				const response = await db
+					.select({ ...rest })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+				]);
+
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works updating',
+			async ({ db, push }) => {
+				const usersOnUpdate = pgTable('users_on_update_9', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					updateCounter: integer('update_counter')
+						.default(sql`1`)
+						.$onUpdateFn(() => sql`update_counter + 1`),
+					updatedAt: timestamp('updated_at', {
+						mode: 'date',
+						precision: 3,
+					}).$onUpdate(() => new Date()),
+					alwaysNull: text('always_null')
+						.$type<string | null>()
+						.$onUpdate(() => null),
+				});
+
+				await push({ usersOnUpdate });
+
+				await db
+					.insert(usersOnUpdate)
+					.values([
+						{ name: 'John', alwaysNull: 'this will be null after updating' },
+						{ name: 'Jane' },
+						{ name: 'Jack' },
+						{ name: 'Jill' },
+					]);
+
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+				await db
+					.select({ updatedAt })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				await db
+					.update(usersOnUpdate)
+					.set({ name: 'Angel' })
+					.where(eq(usersOnUpdate.id, 1));
+				await db
+					.update(usersOnUpdate)
+					.set({ updateCounter: null })
+					.where(eq(usersOnUpdate.id, 2));
+
+				const justDates = await db
+					.select({ updatedAt })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				const response = await db
+					.select({ ...rest })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+					{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
+					{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+				]);
+
+				// expect(initial[0]?.updatedAt?.valueOf()).not.toBe(justDates[0]?.updatedAt?.valueOf());
+
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
+
+		test.concurrent(
+			'test if method with sql operators',
+			async ({ db, push }) => {
+				const users = pgTable('users_106', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					age: integer('age').notNull(),
+					city: text('city').notNull(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition1 = true;
+
+				const [result1] = await db
+					.select()
+					.from(users)
+					.where(eq(users.id, 1).if(condition1));
+
+				expect(result1).toEqual({
+					id: 1,
+					name: 'John',
+					age: 20,
+					city: 'New York',
+				});
+
+				const condition2 = 1;
+
+				const [result2] = await db
+					.select()
+					.from(users)
+					.where(sql`${users.id} = 1`.if(condition2));
+
+				expect(result2).toEqual({
+					id: 1,
+					name: 'John',
+					age: 20,
+					city: 'New York',
+				});
+
+				const condition3 = 'non-empty string';
+
+				const result3 = await db
+					.select()
+					.from(users)
+					.where(
+						or(eq(users.id, 1).if(condition3), eq(users.id, 2).if(condition3)),
+					);
+
+				expect(result3).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{
+						id: 2,
+						name: 'Alice',
+						age: 21,
+						city: 'New York',
+					},
+				]);
+
+				const condtition4 = false;
+
+				const result4 = await db
+					.select()
+					.from(users)
+					.where(eq(users.id, 1).if(condtition4));
+
+				expect(result4).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition5 = undefined;
+
+				const result5 = await db
+					.select()
+					.from(users)
+					.where(sql`${users.id} = 1`.if(condition5));
+
+				expect(result5).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition6 = null;
+
+				const result6 = await db
+					.select()
+					.from(users)
+					.where(
+						or(eq(users.id, 1).if(condition6), eq(users.id, 2).if(condition6)),
+					);
+
+				expect(result6).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition7 = {
+					term1: 0,
+					term2: 1,
+				};
+
+				const result7 = await db
+					.select()
+					.from(users)
+					.where(
+						and(
+							gt(users.age, 20).if(condition7.term1),
+							eq(users.city, 'New York').if(condition7.term2),
+						),
+					);
+
+				expect(result7).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				]);
+
+				const condition8 = {
+					term1: '',
+					term2: 'non-empty string',
+				};
+
+				const result8 = await db
+					.select()
+					.from(users)
+					.where(
+						or(
+							lt(users.age, 21).if(condition8.term1),
+							eq(users.city, 'London').if(condition8.term2),
+						),
+					);
+
+				expect(result8).toEqual([
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition9 = {
+					term1: 1,
+					term2: true,
+				};
+
+				const result9 = await db
+					.select()
+					.from(users)
+					.where(
+						and(
+							inArray(users.city, ['New York', 'London']).if(condition9.term1),
+							ilike(users.name, 'a%').if(condition9.term2),
+						),
+					);
+
+				expect(result9).toEqual([
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+				]);
+
+				const condition10 = {
+					term1: 4,
+					term2: 19,
+				};
+
+				const result10 = await db
+					.select()
+					.from(users)
+					.where(
+						and(
+							sql`length(${users.name}) <= ${condition10.term1}`.if(
+								condition10.term1,
+							),
+							gt(users.age, condition10.term2).if(condition10.term2 > 20),
+						),
+					);
+
+				expect(result10).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition11 = true;
+
+				const result11 = await db
+					.select()
+					.from(users)
+					.where(
+						or(eq(users.city, 'New York'), gte(users.age, 22))!.if(condition11),
+					);
+
+				expect(result11).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition12 = false;
+
+				const result12 = await db
+					.select()
+					.from(users)
+					.where(
+						and(eq(users.city, 'London'), gte(users.age, 23))!.if(condition12),
+					);
+
+				expect(result12).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition13 = true;
+
+				const result13 = await db
+					.select()
+					.from(users)
+					.where(sql`(city = 'New York' or age >= 22)`.if(condition13));
+
+				expect(result13).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+
+				const condition14 = false;
+
+				const result14 = await db
+					.select()
+					.from(users)
+					.where(sql`(city = 'London' and age >= 23)`.if(condition14));
+
+				expect(result14).toEqual([
+					{ id: 1, name: 'John', age: 20, city: 'New York' },
+					{ id: 2, name: 'Alice', age: 21, city: 'New York' },
+					{ id: 3, name: 'Nick', age: 22, city: 'London' },
+					{ id: 4, name: 'Lina', age: 23, city: 'London' },
+				]);
+			},
+		);
+
+		// MySchema tests
+		test.concurrent('mySchema :: select all fields', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true })
+					.notNull()
+					.defaultNow(),
+			});
+
+			await push({ users });
+
+			const now = Date.now();
+
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test.concurrent('mySchema :: select sql', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_10', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.select({
+					name: sql`upper(${users.name})`,
+				})
+				.from(users);
+
+			expect(usersResult).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('mySchema :: select typed sql', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_111', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const usersResult = await db
+				.select({
+					name: sql<string>`upper(${users.name})`,
+				})
+				.from(users);
+
+			expect(usersResult).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('mySchema :: select distinct', async ({ db, push }) => {
+			const usersDistinctTable = pgTable('users_distinct_1', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersDistinctTable });
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+				{ id: 1, name: 'Jane' },
+			]);
+			const users1 = await db
+				.selectDistinct()
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+			const users2 = await db
+				.selectDistinctOn([usersDistinctTable.id])
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id);
+			const users3 = await db
+				.selectDistinctOn([usersDistinctTable.name], {
+					name: usersDistinctTable.name,
+				})
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.name);
+
+			expect(users1).toEqual([
+				{ id: 1, name: 'Jane' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+			]);
+
+			expect(users2).toHaveLength(2);
+			expect(users2[0]?.id).toBe(1);
+			expect(users2[1]?.id).toBe(2);
+
+			expect(users3).toHaveLength(2);
+			expect(users3[0]?.name).toBe('Jane');
+			expect(users3[1]?.name).toBe('John');
+		});
+
+		test.concurrent(
+			'mySchema :: insert returning sql',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_2', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				const result = await db
+					.insert(users)
+					.values({ name: 'John' })
+					.returning({
+						name: sql`upper(${users.name})`,
+					});
+
+				expect(result).toEqual([{ name: 'JOHN' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: delete returning sql',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_3', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values({ name: 'John' });
+				const result = await db
+					.delete(users)
+					.where(eq(users.name, 'John'))
+					.returning({
+						name: sql`upper(${users.name})`,
+					});
+
+				expect(result).toEqual([{ name: 'JOHN' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: update with returning partial',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_4', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values({ name: 'John' });
+				const result = await db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning({
+						id: users.id,
+						name: users.name,
+					});
+
+				expect(result).toEqual([{ id: 1, name: 'Jane' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: delete with returning all fields',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_5', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				await push({ users });
+
+				const now = Date.now();
+
+				await db.insert(users).values({ name: 'John' });
+				const result = await db
+					.delete(users)
+					.where(eq(users.name, 'John'))
+					.returning();
+
+				expect(result[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(
+					300,
+				);
+				expect(result).toEqual([
+					{
+						id: 1,
+						name: 'John',
+						verified: false,
+						jsonb: null,
+						createdAt: result[0]!.createdAt,
+					},
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: insert + select', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_6', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true })
+					.notNull()
+					.defaultNow(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+
+			await db.insert(users).values({ name: 'Jane' });
+			const result2 = await db.select().from(users);
+			expect(result2).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[0]!.createdAt,
+				},
+				{
+					id: 2,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[1]!.createdAt,
+				},
+			]);
+		});
+
+		test.concurrent(
+			'mySchema :: insert with overridden default values',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_7', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values({ name: 'John', verified: true });
+				const result = await db.select().from(users);
+
+				expect(result).toEqual([
+					{
+						id: 1,
+						name: 'John',
+						verified: true,
+						jsonb: null,
+						createdAt: result[0]!.createdAt,
+					},
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: insert many', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_8', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+				jsonb: jsonb('jsonb').$type<string[]>(),
+				createdAt: timestamp('created_at', { withTimezone: true })
+					.notNull()
+					.defaultNow(),
+			});
+
+			await push({ users });
+
+			await db
+				.insert(users)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				]);
+			const result = await db
+				.select({
+					id: users.id,
+					name: users.name,
+					jsonb: users.jsonb,
+					verified: users.verified,
+				})
+				.from(users);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test.concurrent(
+			'mySchema :: select with group by as field',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_9', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db
+					.insert(users)
+					.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+				const result = await db
+					.select({ name: users.name })
+					.from(users)
+					.groupBy(users.name);
+
+				expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: select with group by as column + sql',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_101', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db
+					.insert(users)
+					.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+				const result = await db
+					.select({ name: users.name })
+					.from(users)
+					.groupBy(users.id, sql`${users.name}`)
+					.orderBy(users.name);
+
+				expect(result).toEqual([
+					{ name: 'Jane' },
+					{ name: 'Jane' },
+					{ name: 'John' },
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: build query', async ({ db }) => {
+			const mySchema = pgSchema('mySchema_11');
+			const users = mySchema.table('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const query = db
+				.select({ id: users.id, name: users.name })
+				.from(users)
+				.groupBy(users.id, users.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'select "id", "name" from "mySchema_11"."users" group by "mySchema_11"."users"."id", "mySchema_11"."users"."name"',
+				params: [],
+			});
+		});
+
+		test.concurrent(
+			'mySchema :: partial join with alias',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_105', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				const customerAlias = alias(users, 'customer');
+
+				await db.insert(users).values([
+					{ id: 10, name: 'Ivan' },
+					{ id: 11, name: 'Hans' },
+				]);
+				const result = await db
+					.select({
+						user: {
+							id: users.id,
+							name: users.name,
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: insert with spaces', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_104', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: sql`'Jo   h     n'` });
+			const result = await db
+				.select({ id: users.id, name: users.name })
+				.from(users);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test.concurrent(
+			'mySchema :: prepared statement with placeholder in .limit',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_103', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: users.id,
+						name: users.name,
+					})
+					.from(users)
+					.where(eq(users.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare('mySchema_stmt_limit');
+
+				const result = await stmt.execute({ id: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: build query insert with onConflict do update / multiple columns',
+			async ({ db }) => {
+				const mySchema = pgSchema('mySchema_15');
+				const users = mySchema.table('users', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				const query = db
+					.insert(users)
+					.values({ name: 'John', jsonb: ['foo', 'bar'] })
+					.onConflictDoUpdate({
+						target: [users.id, users.name],
+						set: { name: 'John1' },
+					})
+					.toSQL();
+
+				expect(query).toEqual({
+					sql:
+						'insert into "mySchema_15"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+					params: [
+						'John',
+						is(db, PgliteDatabase) ? ['foo', 'bar'] : JSON.stringify(['foo', 'bar']),
+						'John1',
+					],
+				});
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: build query insert with onConflict do nothing + target',
+			async ({ db }) => {
+				const mySchema = pgSchema('mySchema_16');
+				const users = mySchema.table('users', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				const query = db
+					.insert(users)
+					.values({ name: 'John', jsonb: ['foo', 'bar'] })
+					.onConflictDoNothing({ target: users.id })
+					.toSQL();
+
+				expect(query).toEqual({
+					sql:
+						'insert into "mySchema_16"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+					params: [
+						'John',
+						is(db, PgliteDatabase) ? ['foo', 'bar'] : JSON.stringify(['foo', 'bar']),
+					],
+				});
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: select from tables with same name from different schema using alias',
+			async ({ db, push }) => {
+				const mySchema = pgSchema('mySchema');
+				const users = mySchema.table('users_99', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				const usersDefault = pgTable('users_17', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true })
+						.notNull()
+						.defaultNow(),
+				});
+
+				await push({ users, usersDefault });
+
+				await db.insert(users).values({ id: 10, name: 'Ivan' });
+				await db.insert(usersDefault).values({ id: 11, name: 'Hans' });
+
+				const customerAlias = alias(usersDefault, 'customer');
+
+				const result = await db
+					.select()
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(customerAlias.id, 11));
+
+				expect(result).toEqual([
+					{
+						users_99: {
+							id: 10,
+							name: 'Ivan',
+							verified: false,
+							jsonb: null,
+							createdAt: result[0]!.users_99.createdAt,
+						},
+						customer: {
+							id: 11,
+							name: 'Hans',
+							verified: false,
+							jsonb: null,
+							createdAt: result[0]!.customer!.createdAt,
+						},
+					},
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: view', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+
+			const users = mySchema.table('users_102', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			const cities = mySchema.table('cities_101', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users, cities });
+
+			const newYorkers1 = mySchema
+				.view('new_yorkers')
+				.as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+			const newYorkers2 = mySchema
+				.view('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				})
+				.as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+
+			const newYorkers3 = mySchema
+				.view('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				})
+				.existing();
+
+			await db.execute(
+				sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`,
+			);
+
+			await db.insert(cities).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop view ${newYorkers1}`);
+		});
+
+		test.concurrent('mySchema :: materialized view', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+
+			const users = mySchema.table('users_100', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			const cities = mySchema.table('cities_100', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users, cities });
+
+			const newYorkers1 = mySchema
+				.materializedView('new_yorkers')
+				.as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+			const newYorkers2 = mySchema
+				.materializedView('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				})
+				.as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+
+			const newYorkers3 = mySchema
+				.materializedView('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				})
+				.existing();
+
+			await db.execute(
+				sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`,
+			);
+
+			await db.insert(cities).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 1 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([]);
+			}
+
+			await db.refreshMaterializedView(newYorkers1);
+
+			{
+				const result = await db.select().from(newYorkers1);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers2);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db.select().from(newYorkers3);
+				expect(result).toEqual([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1);
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			await db.execute(sql`drop materialized view ${newYorkers1}`);
+		});
+
+		test.concurrent('limit 0', async ({ db, push }) => {
+			const users = pgTable('users_120', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users).limit(0);
+
+			expect(result).toEqual([]);
+		});
+
+		test.concurrent('limit -1', async ({ db, push }) => {
+			const users = pgTable('users_21', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values({ name: 'John' });
+			const result = await db.select().from(users).limit(-1);
+
+			expect(result.length).toBeGreaterThan(0);
+		});
+
+		test.concurrent('Object keys as column names', async ({ db, push }) => {
+			// Tests the following:
+			// Column with required config
+			// Column with optional config without providing a value
+			// Column with optional config providing a value
+			// Column without config
+			const users = pgTable('users_22', {
+				id: bigserial({ mode: 'number' }).primaryKey(),
+				firstName: varchar(),
+				lastName: varchar({ length: 50 }),
+				admin: boolean(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([
+				{ firstName: 'John', lastName: 'Doe', admin: true },
+				{ firstName: 'Jane', lastName: 'Smith', admin: false },
+			]);
+			const result = await db
+				.select({
+					id: users.id,
+					firstName: users.firstName,
+					lastName: users.lastName,
+				})
+				.from(users)
+				.where(eq(users.admin, true));
+
+			expect(result).toEqual([{ id: 1, firstName: 'John', lastName: 'Doe' }]);
+		});
+
+		test.concurrent('proper json and jsonb handling', async ({ db, push }) => {
+			const jsonTable = pgTable('json_table_23', {
+				json: json('json').$type<{ name: string; age: number }>(),
+				jsonb: jsonb('jsonb').$type<{ name: string; age: number }>(),
+			});
+
+			await push({ jsonTable });
+
+			await db.insert(jsonTable).values({
+				json: { name: 'Tom', age: 75 },
+				jsonb: { name: 'Pete', age: 23 },
+			});
+
+			const result = await db.select().from(jsonTable);
+
+			const justNames = await db
+				.select({
+					name1: sql<string>`${jsonTable.json}->>'name'`.as('name1'),
+					name2: sql<string>`${jsonTable.jsonb}->>'name'`.as('name2'),
+				})
+				.from(jsonTable);
+
+			expect(result).toStrictEqual([
+				{
+					json: { name: 'Tom', age: 75 },
+					jsonb: { name: 'Pete', age: 23 },
+				},
+			]);
+
+			expect(justNames).toStrictEqual([
+				{
+					name1: 'Tom',
+					name2: 'Pete',
+				},
+			]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/3171
+		// TODO: review case
+		// Fails in `postgres-js` if not inlined - driver expects stringified jsons
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'proper json and jsonb handling - sql operator',
+			async ({ db, push }) => {
+				const jsonTable = pgTable('json_table_sql_3', {
+					json: json('json').$type<{ name: string; age: number }>(),
+					jsonb: jsonb('jsonb').$type<{ name: string; age: number }>(),
+				});
+
+				await push({ jsonTable });
+
+				await db.execute(
+					sql`insert into ${jsonTable} ("json", "jsonb") values (${{ name: 'Tom', age: 75 }}, ${{
+						name: 'Pete',
+						age: 23,
+					}})`,
+				);
+
+				const result = await db.select().from(jsonTable);
+
+				const justNames = await db.select({
+					name1: sql<string>`${jsonTable.json}->>'name'`.as('name1'),
+					name2: sql<string>`${jsonTable.jsonb}->>'name'`.as('name2'),
+				}).from(jsonTable);
+
+				expect(result).toStrictEqual([
+					{
+						json: { name: 'Tom', age: 75 },
+						jsonb: { name: 'Pete', age: 23 },
+					},
+				]);
+
+				expect(justNames).toStrictEqual([
+					{
+						name1: 'Tom',
+						name2: 'Pete',
+					},
+				]);
+			},
+		);
+
+		test.concurrent(
+			'set json/jsonb fields with objects and retrieve with the ->> operator',
+			async ({ db, push }) => {
+				const jsonTestTable_13 = pgTable('json_test_24', {
+					id: serial('id').primaryKey(),
+					json: json('json').notNull(),
+					jsonb: jsonb('jsonb').notNull(),
+				});
+
+				await push({ jsonTestTable_13 });
+
+				const obj = { string: 'test', number: 123 };
+				const { string: testString, number: testNumber } = obj;
+
+				await db.insert(jsonTestTable_13).values({
+					json: obj,
+					jsonb: obj,
+				});
+
+				const result = await db
+					.select({
+						jsonStringField: sql<string>`${jsonTestTable_13.json}->>'string'`,
+						jsonNumberField: sql<string>`${jsonTestTable_13.json}->>'number'`,
+						jsonbStringField: sql<string>`${jsonTestTable_13.jsonb}->>'string'`,
+						jsonbNumberField: sql<string>`${jsonTestTable_13.jsonb}->>'number'`,
+					})
+					.from(jsonTestTable_13);
+
+				expect(result).toStrictEqual([
+					{
+						jsonStringField: testString,
+						jsonNumberField: String(testNumber),
+						jsonbStringField: testString,
+						jsonbNumberField: String(testNumber),
+					},
+				]);
+			},
+		);
+
+		test.concurrent(
+			'set json/jsonb fields with strings and retrieve with the ->> operator',
+			async ({ db, push }) => {
+				const jsonTestTable = pgTable('json_test_25', {
+					id: serial('id').primaryKey(),
+					json: json('json').notNull(),
+					jsonb: jsonb('jsonb').notNull(),
+				});
+
+				await push({ jsonTestTable });
+
+				const obj = { string: 'test', number: 123 };
+				const { string: testString, number: testNumber } = obj;
+
+				await db.insert(jsonTestTable).values({
+					json: sql`${JSON.stringify(obj)}`,
+					jsonb: sql`${JSON.stringify(obj)}`,
+				});
+
+				const result = await db
+					.select({
+						jsonStringField: sql<string>`${jsonTestTable.json}->>'string'`,
+						jsonNumberField: sql<string>`${jsonTestTable.json}->>'number'`,
+						jsonbStringField: sql<string>`${jsonTestTable.jsonb}->>'string'`,
+						jsonbNumberField: sql<string>`${jsonTestTable.jsonb}->>'number'`,
+					})
+					.from(jsonTestTable);
+
+				expect(result).toStrictEqual([
+					{
+						jsonStringField: testString,
+						jsonNumberField: String(testNumber),
+						jsonbStringField: testString,
+						jsonbNumberField: String(testNumber),
+					},
+				]);
+			},
+		);
+
+		test.concurrent(
+			'set json/jsonb fields with objects and retrieve with the -> operator',
+			async ({ db, push }) => {
+				const jsonTestTable = pgTable('json_test_26', {
+					id: serial('id').primaryKey(),
+					json: json('json').notNull(),
+					jsonb: jsonb('jsonb').notNull(),
+				});
+
+				await push({ jsonTestTable });
+
+				const obj = { string: 'test', number: 123 };
+				const { string: testString, number: testNumber } = obj;
+
+				await db.insert(jsonTestTable).values({
+					json: obj,
+					jsonb: obj,
+				});
+
+				const result = await db
+					.select({
+						jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
+						jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
+						jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
+						jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
+					})
+					.from(jsonTestTable);
+
+				expect(result).toStrictEqual([
+					{
+						jsonStringField: testString,
+						jsonNumberField: testNumber,
+						jsonbStringField: testString,
+						jsonbNumberField: testNumber,
+					},
+				]);
+			},
+		);
+
+		test.concurrent(
+			'set json/jsonb fields with strings and retrieve with the -> operator',
+			async ({ db, push }) => {
+				const jsonTestTable = pgTable('json_test_27', {
+					id: serial('id').primaryKey(),
+					json: json('json').notNull(),
+					jsonb: jsonb('jsonb').notNull(),
+				});
+
+				await push({ jsonTestTable });
+
+				const obj = { string: 'test', number: 123 };
+				const { string: testString, number: testNumber } = obj;
+
+				await db.insert(jsonTestTable).values({
+					json: sql`${JSON.stringify(obj)}`,
+					jsonb: sql`${JSON.stringify(obj)}`,
+				});
+
+				const result = await db
+					.select({
+						jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
+						jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
+						jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
+						jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
+					})
+					.from(jsonTestTable);
+
+				expect(result).toStrictEqual([
+					{
+						jsonStringField: testString,
+						jsonNumberField: testNumber,
+						jsonbStringField: testString,
+						jsonbNumberField: testNumber,
+					},
+				]);
+			},
+		);
+
+		test.concurrent('update ... from', async ({ db, push }) => {
+			const cities2Table = pgTable('cities_28', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2Table = pgTable('users_28', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			await push({ cities2Table, users2Table });
+
+			await db
+				.insert(cities2Table)
+				.values([{ name: 'New York City' }, { name: 'Seattle' }]);
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+			]);
+
+			const result = await db
+				.update(users2Table)
+				.set({
+					cityId: cities2Table.id,
+				})
+				.from(cities2Table)
+				.where(
+					and(eq(cities2Table.name, 'Seattle'), eq(users2Table.name, 'John')),
+				)
+				.returning();
+
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					cities_28: {
+						id: 2,
+						name: 'Seattle',
+					},
+				},
+			]);
+		});
+
+		test.concurrent('update ... from with alias', async ({ db, push }) => {
+			const cities2Table = pgTable('cities_29', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2Table = pgTable('users_108', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			await push({ cities2Table, users2Table });
+
+			await db
+				.insert(cities2Table)
+				.values([{ name: 'New York City' }, { name: 'Seattle' }]);
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+			]);
+
+			const users = alias(users2Table, 'u');
+			const cities = alias(cities2Table, 'c');
+			const result = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+				.returning();
+
+			expect(result).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					c: {
+						id: 2,
+						name: 'Seattle',
+					},
+				},
+			]);
+		});
+
+		test.concurrent('update ... from with join', async ({ db, push }) => {
+			const states = pgTable('states_30', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const cities = pgTable('cities_30', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				stateId: integer('state_id').references(() => states.id),
+			});
+			const users = pgTable('users_30', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id')
+					.notNull()
+					.references(() => cities.id),
+			});
+
+			await push({ states, cities, users });
+
+			await db
+				.insert(states)
+				.values([{ name: 'New York' }, { name: 'Washington' }]);
+			await db
+				.insert(cities)
+				.values([
+					{ name: 'New York City', stateId: 1 },
+					{ name: 'Seattle', stateId: 2 },
+					{ name: 'London' },
+				]);
+			await db.insert(users).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 3 },
+			]);
+
+			const result1 = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.leftJoin(states, eq(cities.stateId, states.id))
+				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+				.returning();
+			const result2 = await db
+				.update(users)
+				.set({
+					cityId: cities.id,
+				})
+				.from(cities)
+				.leftJoin(states, eq(cities.stateId, states.id))
+				.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+				.returning();
+
+			expect(result1).toStrictEqual([
+				{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					cities_30: {
+						id: 2,
+						name: 'Seattle',
+						stateId: 2,
+					},
+					states_30: {
+						id: 2,
+						name: 'Washington',
+					},
+				},
+			]);
+			expect(result2).toStrictEqual([
+				{
+					id: 3,
+					name: 'Jack',
+					cityId: 3,
+					cities_30: {
+						id: 3,
+						name: 'London',
+						stateId: null,
+					},
+					states_30: null,
+				},
+			]);
+		});
+
+		test.concurrent('insert into ... select', async ({ db, push }) => {
+			const notifications = pgTable('notifications_31', {
+				id: serial('id').primaryKey(),
+				sentAt: timestamp('sent_at').notNull().defaultNow(),
+				message: text('message').notNull(),
+			});
+			const users = pgTable('users_31', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const userNotications = pgTable(
+				'user_notifications_31',
+				{
+					userId: integer('user_id')
+						.notNull()
+						.references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: integer('notification_id')
+						.notNull()
+						.references(() => notifications.id, {
+							onDelete: 'cascade',
+						}),
+				},
+				(t) => [primaryKey({ columns: [t.userId, t.notificationId] })],
+			);
+
+			await push({ notifications, users, userNotications });
+
+			const newNotification = await db
+				.insert(notifications)
+				.values({ message: 'You are one of the 3 lucky winners!' })
+				.returning({ id: notifications.id })
+				.then((result) => result[0]);
+			await db
+				.insert(users)
+				.values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+			const sentNotifications = await db
+				.insert(userNotications)
+				.select(
+					db
+						.select({
+							userId: users.id,
+							notificationId: sql`${newNotification!.id}`.as('notification_id'),
+						})
+						.from(users)
+						.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+						.orderBy(asc(users.id)),
+				)
+				.returning();
+
+			expect(sentNotifications).toStrictEqual([
+				{ userId: 1, notificationId: newNotification!.id },
+				{ userId: 3, notificationId: newNotification!.id },
+				{ userId: 5, notificationId: newNotification!.id },
+			]);
+		});
+
+		test.concurrent(
+			'insert into ... select with keys in different order',
+			async ({ db, push }) => {
+				const users1 = pgTable('users1_32', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const users2 = pgTable('users2_32', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users1, users2 });
+
+				await db.insert(users2).values({ id: 1, name: 'First' });
+				const res = await db.insert(users1).select(
+					db
+						.select({
+							name: users2.name,
+							id: users2.id,
+						})
+						.from(users2),
+				).returning();
+
+				expect(res).toStrictEqual([{
+					id: 1,
+					name: 'First',
+				}]);
+			},
+		);
+
+		test.concurrent('insert into ... select with generated column', async ({ db, push }) => {
+			const users1 = pgTable('users1_iswgc', {
+				id: integer().generatedAlwaysAsIdentity().primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2 = pgTable('users2_iswgc', {
+				id: integer().generatedAlwaysAsIdentity().primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users1, users2 });
+
+			await db.insert(users1).values([
+				{ name: 'Alice' },
+				{ name: 'Bob' },
+				{ name: 'Charlie' },
+			]);
+
+			const result1 = await db.insert(users2).select(db.select({ name: users1.name }).from(users1))
+				.returning();
+			const result2 = await db.insert(users2).overridingSystemValue().select((db) =>
+				db.select({ id: sql`${users1.id} + 3`.as('id'), name: users1.name }).from(users1)
+			).returning();
+
+			expect(result1).toStrictEqual([
+				{ id: 1, name: 'Alice' },
+				{ id: 2, name: 'Bob' },
+				{ id: 3, name: 'Charlie' },
+			]);
+			expect(result2).toStrictEqual([
+				{ id: 4, name: 'Alice' },
+				{ id: 5, name: 'Bob' },
+				{ id: 6, name: 'Charlie' },
+			]);
+
+			// @ts-expect-error
+			db.insert(users2).select(db.select({ name: users1.name, id: users1.id }).from(users1));
+			// @ts-expect-error
+			expect(() => db.insert(users2).select(db.select({ name: users1.name, unknown: users1.id }).from(users1)))
+				.toThrowError();
+		});
+
+		test.concurrent('ignore generated columns in insert', async ({ db, push }) => {
+			const users = pgTable('users_ignore_generated_columns_in_insert', {
+				id: integer().generatedAlwaysAsIdentity(),
+				otherId: integer('other_id').generatedByDefaultAsIdentity(),
+				firstName: text('first_name').notNull(),
+				lastName: text('last_name').notNull(),
+				name: text().generatedAlwaysAs((): any => sql`${users.firstName} || ' ' || ${users.lastName}`),
+			});
+
+			await push({ users });
+
+			const values = {
+				id: 5,
+				otherId: 10,
+				firstName: 'John',
+				lastName: 'Doe',
+				name: 'N/A',
+			};
+			const result = await db.insert(users).values(values).returning();
+
+			expect(result).toEqual([
+				{ id: 1, otherId: 10, firstName: 'John', lastName: 'Doe', name: 'John Doe' },
+			]);
+		});
+
+		test.concurrent('$count separate', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_33', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db.$count(countTestTable);
+
+			expect(count).toStrictEqual(4);
+		});
+
+		test.concurrent('$count embedded', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_34', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			expect(count).toStrictEqual([
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+			]);
+		});
+
+		test.concurrent('$count separate reuse', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_35', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db.$count(countTestTable);
+
+			const count1 = await count;
+
+			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = await count;
+
+			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = await count;
+
+			expect(count1).toStrictEqual(4);
+			expect(count2).toStrictEqual(5);
+			expect(count3).toStrictEqual(6);
+		});
+
+		test.concurrent('$count embedded reuse', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_36', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			const count1 = await count;
+
+			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = await count;
+
+			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = await count;
+
+			expect(count1).toStrictEqual([
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+				{ count: 4 },
+			]);
+			expect(count2).toStrictEqual([
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+				{ count: 5 },
+			]);
+			expect(count3).toStrictEqual([
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+				{ count: 6 },
+			]);
+		});
+
+		test.concurrent('$count separate with filters', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_37', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
+			expect(count).toStrictEqual(3);
+		});
+
+		test.concurrent('$count embedded with filters', async ({ db, push }) => {
+			const countTestTable = pgTable('count_test_38', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await push({ countTestTable });
+
+			await db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = await db
+				.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				})
+				.from(countTestTable);
+
+			expect(count).toStrictEqual([
+				{ count: 3 },
+				{ count: 3 },
+				{ count: 3 },
+				{ count: 3 },
+			]);
+		});
+
+		test.concurrent(
+			'insert multiple rows into table with generated identity column',
+			async ({ db, push }) => {
+				const identityColumnsTable = pgTable('identity_columns_table_39', {
+					id: integer('id').generatedAlwaysAsIdentity(),
+					id1: integer('id1').generatedByDefaultAsIdentity(),
+					name: text('name').notNull(),
+				});
+
+				// not passing identity columns
+				await db.execute(sql`drop table if exists ${identityColumnsTable}`);
+				await push({ identityColumnsTable });
+
+				let result = await db
+					.insert(identityColumnsTable)
+					.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Bob' }])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 1, id1: 1, name: 'John' },
+					{ id: 2, id1: 2, name: 'Jane' },
+					{ id: 3, id1: 3, name: 'Bob' },
+				]);
+
+				// passing generated by default as identity column
+				await db.execute(sql`drop table if exists ${identityColumnsTable}`);
+				await push({ identityColumnsTable });
+
+				result = await db
+					.insert(identityColumnsTable)
+					.values([
+						{ name: 'John', id1: 3 },
+						{ name: 'Jane', id1: 5 },
+						{ name: 'Bob', id1: 5 },
+					])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 1, id1: 3, name: 'John' },
+					{ id: 2, id1: 5, name: 'Jane' },
+					{ id: 3, id1: 5, name: 'Bob' },
+				]);
+
+				// passing all identity columns
+				await db.execute(sql`drop table if exists ${identityColumnsTable}`);
+				await push({ identityColumnsTable });
+
+				result = await db
+					.insert(identityColumnsTable)
+					.overridingSystemValue()
+					.values([
+						{ name: 'John', id: 2, id1: 3 },
+						{ name: 'Jane', id: 4, id1: 5 },
+						{ name: 'Bob', id: 4, id1: 5 },
+					])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 2, id1: 3, name: 'John' },
+					{ id: 4, id1: 5, name: 'Jane' },
+					{ id: 4, id1: 5, name: 'Bob' },
+				]);
+			},
+		);
+
+		test.concurrent('insert as cte', async ({ db, push }) => {
+			const users = pgTable('users_40', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			const sq1 = db
+				.$with('sq')
+				.as(db.insert(users).values({ name: 'John' }).returning());
+			const result1 = await db.with(sq1).select().from(sq1);
+			const result2 = await db.with(sq1).select({ id: sq1.id }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.insert(users)
+						.values({ name: 'Jane' })
+						.returning({ id: users.id, name: users.name }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ id: 2 }]);
+			expect(result3).toEqual([{ id: 3, name: 'Jane' }]);
+			expect(result4).toEqual([{ name: 'Jane' }]);
+		});
+
+		test.concurrent('update as cte', async ({ db, push }) => {
+			const users = pgTable('users_41', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				age: integer('age').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([
+				{ name: 'John', age: 30 },
+				{ name: 'Jane', age: 30 },
+			]);
+
+			const sq1 = db
+				.$with('sq')
+				.as(
+					db
+						.update(users)
+						.set({ age: 25 })
+						.where(eq(users.name, 'John'))
+						.returning(),
+				);
+			const result1 = await db.with(sq1).select().from(sq1);
+			await db.update(users).set({ age: 30 });
+			const result2 = await db.with(sq1).select({ age: sq1.age }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.update(users)
+						.set({ age: 20 })
+						.where(eq(users.name, 'Jane'))
+						.returning({ name: users.name, age: users.age }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			await db.update(users).set({ age: 30 });
+			const result4 = await db.with(sq2).select({ age: sq2.age }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John', age: 25 }]);
+			expect(result2).toEqual([{ age: 25 }]);
+			expect(result3).toEqual([{ name: 'Jane', age: 20 }]);
+			expect(result4).toEqual([{ age: 20 }]);
+		});
+
+		test.concurrent('delete as cte', async ({ db, push }) => {
+			const users = pgTable('users_107', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq1 = db
+				.$with('sq')
+				.as(db.delete(users).where(eq(users.name, 'John')).returning());
+			const result1 = await db.with(sq1).select().from(sq1);
+			await db.insert(users).values({ name: 'John' });
+			const result2 = await db.with(sq1).select({ name: sq1.name }).from(sq1);
+
+			const sq2 = db
+				.$with('sq')
+				.as(
+					db
+						.delete(users)
+						.where(eq(users.name, 'Jane'))
+						.returning({ id: users.id, name: users.name }),
+				);
+			const result3 = await db.with(sq2).select().from(sq2);
+			await db.insert(users).values({ name: 'Jane' });
+			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
+
+			expect(result1).toEqual([{ id: 1, name: 'John' }]);
+			expect(result2).toEqual([{ name: 'John' }]);
+			expect(result3).toEqual([{ id: 2, name: 'Jane' }]);
+			expect(result4).toEqual([{ name: 'Jane' }]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4160
+		test.concurrent(
+			'delete; composition of `not` and `or`/`and`',
+			async ({ db, push }) => {
+				const users = pgTable('users_1070', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const sessions = pgTable('sessions_0', {
+					id: serial('id').primaryKey(),
+					userId: integer('userId')
+						.references(() => users.id, { onDelete: 'cascade' })
+						.notNull(),
+					name: text('name').notNull().default(''),
+				});
+
+				await push({ users, sessions });
+
+				const DEFAULT_SESSION_NAME = 'Default Session';
+				const BASE_SESSION_NAME = 'Base Scramble';
+				const sessionId = 1;
+				const userId = 1;
+
+				await db.insert(users).values([{ id: userId, name: 'John' }]);
+
+				await db
+					.insert(sessions)
+					.values([{ id: sessionId, userId: 1, name: 'some session' }]);
+
+				const query = db.delete(sessions).where(
+					and(
+						eq(sessions.id, sessionId),
+						eq(sessions.userId, userId),
+						not(
+							// @ts-expect-error
+							// TODO @skylotus
+							or(
+								eq(sessions.name, DEFAULT_SESSION_NAME),
+								eq(sessions.name, BASE_SESSION_NAME),
+							),
+						),
+					),
+				);
+
+				await query;
+				const result = await db.select().from(sessions);
+				expect(result).toStrictEqual([]);
+			},
+		);
+
+		test.concurrent('sql operator as cte', async ({ db, push }) => {
+			const users = pgTable('users_109', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq1 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(sql`select * from ${users} where ${users.name} = 'John'`);
+			const result1 = await db.with(sq1).select().from(sq1);
+
+			const sq2 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+			const result2 = await db.with(sq2).select().from(sq1);
+
+			expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
+			expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+		});
+
+		test.concurrent('sql.Aliased in cte', async ({ db, push }) => {
+			const users = pgTable('users_109_sqla', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+			await db.insert(users).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			const sq1 = db.$with('sq1').as((qb) =>
+				qb
+					.select({
+						aliased: sql`count(*)`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+			const sq2 = db.$with('sq2').as((qb) =>
+				qb
+					.select({
+						aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+
+			const result = await db
+				.with(sq1, sq2)
+				.select({
+					count: sq1.aliased,
+					sum: sq2.aliased,
+				})
+				.from(sq1)
+				.crossJoin(sq2);
+
+			expect(result).toEqual([{ count: 2, sum: 3 }]);
+
+			const result2 = await db
+				.with(sq1)
+				.select({
+					count: sq1.aliased,
+				})
+				.from(sq1)
+				.groupBy(sq1.aliased)
+				.orderBy(sq1.aliased);
+
+			expect(result2).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('cross join', async ({ db, push }) => {
+			const usersTable = pgTable('users_44', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const citiesTable = pgTable('cities_44', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ usersTable, citiesTable });
+
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Seattle' }, { name: 'New York City' }]);
+
+			const result = await db
+				.select({
+					user: usersTable.name,
+					city: citiesTable.name,
+				})
+				.from(usersTable)
+				.crossJoin(citiesTable)
+				.orderBy(usersTable.name, citiesTable.name);
+
+			expect(result).toStrictEqual([
+				{ city: 'New York City', user: 'Jane' },
+				{ city: 'Seattle', user: 'Jane' },
+				{ city: 'New York City', user: 'John' },
+				{ city: 'Seattle', user: 'John' },
+			]);
+		});
+
+		test.concurrent('left join (lateral)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_45', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2Table = pgTable('users2_45', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id'),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.leftJoinLateral(sq, sql`true`);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+				{ cityId: 2, cityName: 'London', userId: null, userName: null },
+			]);
+		});
+
+		test.concurrent('inner join (lateral)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_46', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2Table = pgTable('users2_46', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.innerJoinLateral(sq, sql`true`);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+			]);
+		});
+
+		test.concurrent('cross join (lateral)', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_47', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+			const users2Table = pgTable('users2_47', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Berlin' },
+			]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane' },
+				{
+					name: 'Patrick',
+					cityId: 2,
+				},
+			]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(not(like(citiesTable.name, 'L%')))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.crossJoinLateral(sq)
+				.orderBy(citiesTable.id, sq.userId);
+
+			expect(res).toStrictEqual([
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 1,
+					userName: 'John',
+				},
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 2,
+					userName: 'Jane',
+				},
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 3,
+					userName: 'Patrick',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 1,
+					userName: 'John',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 2,
+					userName: 'Jane',
+				},
+				{
+					cityId: 3,
+					cityName: 'Berlin',
+					userId: 3,
+					userName: 'Patrick',
+				},
+			]);
+		});
+
+		test.concurrent('column.as', async ({ db, push }) => {
+			const users = pgTable('users_column_as', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => cities.id),
+			});
+
+			const cities = pgTable('cities_column_as', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const ucView = pgView('cities_users_column_as_view').as((qb) =>
+				qb
+					.select({
+						userId: users.id.as('user_id'),
+						cityId: cities.id.as('city_id'),
+						userName: users.name.as('user_name'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.cityId))
+			);
+
+			await push({ users, cities, ucView });
+
+			const citiesInsRet = await db
+				.insert(cities)
+				.values([
+					{
+						id: 1,
+						name: 'Firstistan',
+					},
+					{
+						id: 2,
+						name: 'Secondaria',
+					},
+				])
+				.returning({
+					cityId: cities.id.as('city_id'),
+					cityName: cities.name.as('city_name'),
+				});
+
+			expect(citiesInsRet).toStrictEqual(
+				expect.arrayContaining([
+					{
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+				]),
+			);
+
+			const usersInsRet = await db
+				.insert(users)
+				.values([
+					{ id: 1, name: 'First', cityId: 1 },
+					{
+						id: 2,
+						name: 'Second',
+						cityId: 2,
+					},
+					{
+						id: 3,
+						name: 'Third',
+					},
+				])
+				.returning({
+					userId: users.id.as('user_id'),
+					userName: users.name.as('users_name'),
+					userCityId: users.cityId,
+				});
+
+			expect(usersInsRet).toStrictEqual(
+				expect.arrayContaining([
+					{ userId: 1, userName: 'First', userCityId: 1 },
+					{
+						userId: 2,
+						userName: 'Second',
+						userCityId: 2,
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						userCityId: null,
+					},
+				]),
+			);
+
+			const joinSelectReturn = await db
+				.select({
+					userId: users.id.as('user_id'),
+					cityId: cities.id.as('city_id'),
+					userName: users.name.as('user_name'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(users)
+				.leftJoin(cities, eq(cities.id, users.cityId));
+
+			expect(joinSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewSelectReturn = await db.select().from(ucView);
+
+			expect(viewSelectReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+
+			const viewJoinReturn = await db
+				.select({
+					userId: ucView.userId.as('user_id_ucv'),
+					cityId: cities.id.as('city_id'),
+					userName: ucView.userName.as('user_name_ucv'),
+					cityName: cities.name.as('city_name'),
+				})
+				.from(ucView)
+				.leftJoin(cities, eq(cities.id, ucView.cityId));
+
+			expect(viewJoinReturn).toStrictEqual(
+				expect.arrayContaining([
+					{
+						userId: 1,
+						userName: 'First',
+						cityId: 1,
+						cityName: 'Firstistan',
+					},
+					{
+						userId: 2,
+						userName: 'Second',
+						cityId: 2,
+						cityName: 'Secondaria',
+					},
+					{
+						userId: 3,
+						userName: 'Third',
+						cityId: null,
+						cityName: null,
+					},
+				]),
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5112
+		// looks like casing issue
+		// ^ and so it was
+		test.concurrent('view #1', async ({ push, createDB }) => {
+			const animal = pgTable('animal', (t) => ({
+				id: t.text().primaryKey(),
+				name: t.text().notNull(),
+				caretakerId: t.text().notNull(),
+			}));
+			const caretaker = pgTable('caretaker', (t) => ({
+				id: t.text().primaryKey(),
+				caretakerName: t.text().notNull(),
+			}));
+			const animalWithCaretakerView = pgView('animal_with_caretaker_view').as(
+				(qb) =>
+					qb
+						.select({
+							id: animal.id,
+							animalName: animal.name,
+							caretakerName: caretaker.caretakerName,
+						})
+						.from(animal)
+						.innerJoin(caretaker, eq(animal.caretakerId, caretaker.id)),
+			);
+
+			const schema = { animal, caretaker, animalWithCaretakerView };
+			const db = createDB(schema);
+
+			const sql = db.select().from(animalWithCaretakerView).toSQL().sql;
+			expect(sql).toEqual(
+				'select "id", "name", "caretakerName" from "animal_with_caretaker_view"',
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4875
+		test.concurrent('select aliased view', async ({ db }) => {
+			const productionJobTable = pgTable('production_job', {
+				id: text('id').primaryKey(),
+				name: text('name'),
+			});
+
+			const rfidTagTable = pgTable('rfid_tag', {
+				createdAt: timestamp('created_at')
+					.notNull()
+					.default(sql`now()`),
+				epc: text('epc').notNull(),
+				locationId: text('location_id').notNull(),
+				id: text('id')
+					.notNull()
+					.unique()
+					.$default(() => 'abc'),
+			});
+
+			const productionJobWithLocationView = pgView(
+				'production_job_with_location',
+			).as((qb) => {
+				const productionColumns = getColumns(productionJobTable);
+				const sub = qb
+					.selectDistinctOn([rfidTagTable.epc])
+					.from(rfidTagTable)
+					.as('r');
+				return qb
+					.select({
+						...productionColumns,
+						locationId: sub.locationId,
+						tagId: sub.id.as('tag_id'),
+						tagCreatedAt: sub.createdAt.as('tag_created_at'),
+					})
+					.from(productionJobTable)
+					.leftJoin(
+						sub,
+						and(
+							eq(productionJobTable.id, sql`LTRIM(${sub.epc}, '0')`),
+							sql`${sub.epc} ~ '^0?[0-9]+'`,
+						),
+					);
+			});
+
+			const sub = alias(productionJobWithLocationView, 'p'); // if select from "productionJobWithLocationView" (not from alias), it works as expected
+
+			const query = db.select().from(sub);
+			expect(query.toSQL().sql).toStrictEqual(
+				(<{ dialect: PgDialect }> (<any> db)).dialect.sqlToQuery(
+					sql`select ${sql.identifier('id')}, ${sql.identifier('name')}, ${sql.identifier('location_id')}, ${
+						sql.identifier(
+							'tag_id',
+						)
+					}, ${sql.identifier('tag_created_at')} from ${sql.identifier('production_job_with_location')} ${
+						sql.identifier(
+							'p',
+						)
+					}`,
+				).sql,
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4326
+		test.concurrent('mutation of getColumns(table)', async ({ db, push }) => {
+			const cities2Table = pgTable('cities_48', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const users2Table = pgTable('users2_48', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => cities2Table.id),
+			});
+
+			await push({ cities2Table, users2Table });
+
+			await db.insert(cities2Table).values([
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db.insert(users2Table).values([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 2 },
+			]);
+
+			const joinSelection = Object.assign(
+				{ ...getColumns(users2Table) },
+				{ cityName: cities2Table.name },
+			);
+			const result = await db
+				.select({ ...joinSelection })
+				.from(users2Table)
+				.innerJoin(cities2Table, eq(users2Table.cityId, cities2Table.id))
+				.where(eq(users2Table.id, 1));
+			expect(result).toStrictEqual([
+				{ cityId: 1, cityName: 'New York', id: 1, name: 'John' },
+			]);
+
+			const userSelection = getColumns(users2Table);
+			expect(Object.keys(userSelection)).toStrictEqual([
+				'id',
+				'name',
+				'cityId',
+			]);
+			const result1 = await db
+				.select({ ...userSelection })
+				.from(users2Table)
+				.where(eq(users2Table.id, 2));
+			expect(result1).toStrictEqual([{ id: 2, name: 'Jane', cityId: 2 }]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5049
+		test('view #3', async ({ db }) => {
+			const table1 = pgTable('table1', {
+				id: integer(),
+				name: text(),
+			});
+
+			const view1 = pgView('view1').as((qb) => qb.select().from(table1));
+
+			const query = db
+				.select({
+					id: view1.id,
+					name: view1.name,
+				})
+				.from(view1)
+				.innerJoin(table1, eq(view1.id, table1.id));
+			expect(query.toSQL().sql).toEqual(
+				'select "view1"."id", "view1"."name" from "view1" inner join "table1" on "view1"."id" = "table1"."id"',
+			);
+		});
+
+		test.concurrent('select from a many subquery', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_many_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: char('state', { length: 2 }),
+			});
+
+			const users2Table = pgTable('users2_many_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					population: db
+						.select({ count: count().as('count') })
+						.from(users2Table)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('population'),
+					name: citiesTable.name,
+				})
+				.from(citiesTable);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					population: number;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					population: 1,
+					name: 'Paris',
+				},
+				{
+					population: 2,
+					name: 'London',
+				},
+			]);
+		});
+
+		test.concurrent('select from a one subquery', async ({ db, push }) => {
+			const citiesTable = pgTable('cities_one_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: char('state', { length: 2 }),
+			});
+
+			const users2Table = pgTable('users2_one_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => citiesTable.id),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					cityName: db
+						.select({ name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('cityName'),
+					name: users2Table.name,
+				})
+				.from(users2Table);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					cityName: string;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					cityName: 'Paris',
+					name: 'John',
+				},
+				{
+					cityName: 'London',
+					name: 'Jane',
+				},
+				{
+					cityName: 'London',
+					name: 'Jack',
+				},
+			]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4878
+		test.concurrent('.where with isNull in it', async ({ db, push }) => {
+			const table = pgTable('table_where_is_null', {
+				col1: boolean(),
+				col2: text(),
+			});
+
+			await push({ table });
+			await db
+				.insert(table)
+				.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+			const query = db
+				.select()
+				.from(table)
+				.where(eq(table.col1, isNull(table.col2)));
+			expect(query.toSQL()).toStrictEqual({
+				sql:
+					'select "col1", "col2" from "table_where_is_null" where "table_where_is_null"."col1" = ("table_where_is_null"."col2" is null)',
+				params: [],
+			});
+			const res = await query;
+			expect(res).toStrictEqual([
+				{ col1: true, col2: null },
+				{ col1: false, col2: 'qwerty' },
+			]);
+		});
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works with sql value',
+			async ({ db, push }) => {
+				const users = pgTable('users_on_update', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					updatedAt: timestamp('updated_at', { mode: 'date' })
+						.notNull()
+						.$onUpdate(() => sql`now()`),
+				});
+
+				await push({ users });
+
+				const insertResp = await db
+					.insert(users)
+					.values({
+						name: 'John',
+					})
+					.returning({
+						updatedAt: users.updatedAt,
+					});
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+
+				const now = Date.now();
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+				const updateResp = await db
+					.update(users)
+					.set({
+						name: 'John',
+					})
+					.returning({
+						updatedAt: users.updatedAt,
+					});
+
+				expect(insertResp[0]?.updatedAt.getTime() ?? 0).lessThan(now);
+				expect(updateResp[0]?.updatedAt.getTime() ?? 0).greaterThan(now);
+			},
+		);
+
+		test.concurrent('placeholder + sql dates', async ({ db }) => {
+			const dateTable = pgTable('dates_placeholder_test', (t) => ({
+				id: t.integer('id').primaryKey().notNull(),
+				date: t.date('date', { mode: 'date' }).notNull(),
+				dateStr: t.date('date_str', { mode: 'string' }).notNull(),
+				timestamp: t.timestamp('timestamp', { mode: 'date' }).notNull(),
+				timestampStr: t
+					.timestamp('timestamp_str', { mode: 'string' })
+					.notNull(),
+			}));
+
+			await db.execute(sql`DROP TABLE IF EXISTS ${dateTable};`);
+			await db.execute(sql`CREATE TABLE ${dateTable} (
+			${sql.identifier('id')} INTEGER PRIMARY KEY NOT NULL,
+			${sql.identifier('date')} DATE NOT NULL,
+			${sql.identifier('date_str')} DATE NOT NULL,
+			${sql.identifier('timestamp')} TIMESTAMP NOT NULL,
+			${sql.identifier('timestamp_str')} TIMESTAMP NOT NULL
+		);`);
+
+			const date = new Date('2025-12-10T00:00:00.000Z');
+			const timestamp = new Date('2025-12-10T01:01:01.111Z');
+			const dateStr = date.toISOString().slice(0, -14);
+			const timestampStr = timestamp
+				.toISOString()
+				.slice(0, -1)
+				.replace('T', ' ');
+
+			const initial = await db
+				.insert(dateTable)
+				.values([
+					{
+						id: 1,
+						date: date,
+						dateStr: dateStr,
+						timestamp: timestamp,
+						timestampStr: timestampStr,
+					},
+					{
+						id: 2,
+						date: sql.placeholder('dateAsDate'),
+						dateStr: sql.placeholder('dateStrAsDate'),
+						timestamp: sql.placeholder('timestampAsDate'),
+						timestampStr: sql.placeholder('timestampStrAsDate'),
+					},
+					{
+						id: 3,
+						date: sql.placeholder('dateAsString'),
+						dateStr: sql.placeholder('dateStrAsString'),
+						timestamp: sql.placeholder('timestampAsString'),
+						timestampStr: sql.placeholder('timestampStrAsString'),
+					},
+					{
+						id: 4,
+						date: sql`${dateStr}`,
+						dateStr: sql`${dateStr}`,
+						timestamp: sql`${timestampStr}`,
+						timestampStr: sql`${timestampStr}`,
+					},
+				])
+				.returning()
+				.execute({
+					dateAsDate: date,
+					dateAsString: dateStr,
+					dateStrAsDate: date,
+					dateStrAsString: dateStr,
+					timestampAsDate: timestamp,
+					timestampAsString: timestampStr,
+					timestampStrAsDate: timestamp,
+					timestampStrAsString: timestampStr,
+				});
+
+			const updated = await db
+				.update(dateTable)
+				.set({
+					date: sql`${dateStr}`,
+					dateStr: sql`${dateStr}`,
+					timestamp: sql`${timestampStr}`,
+					timestampStr: sql`${timestampStr}`,
+				})
+				.returning();
+
+			expect(initial).toStrictEqual([
+				{
+					id: 1,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 2,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 3,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 4,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+			]);
+
+			expect(updated).toStrictEqual(initial);
+		});
+
+		test.concurrent('all types', async ({ db, push }) => {
+			const en = pgEnum('en_48', ['enVal1', 'enVal2']);
+			const allTypesTable = pgTable('all_types_48', {
+				serial: serial('serial'),
+				bigserial53: bigserial('bigserial53', {
+					mode: 'number',
+				}),
+				bigserial64: bigserial('bigserial64', {
+					mode: 'bigint',
+				}),
+				int: integer('int'),
+				bigint53: bigint('bigint53', {
+					mode: 'number',
+				}),
+				bigint64: bigint('bigint64', {
+					mode: 'bigint',
+				}),
+				bigintString: bigint('bigint_string', {
+					mode: 'string',
+				}),
+				bool: boolean('bool'),
+				bytea: bytea('bytea'),
+				char: char('char'),
+				cidr: cidr('cidr'),
+				date: date('date', {
+					mode: 'date',
+				}),
+				dateStr: date('date_str', {
+					mode: 'string',
+				}),
+				double: doublePrecision('double'),
+				enum: en('enum'),
+				inet: inet('inet'),
+				interval: interval('interval'),
+				json: json('json'),
+				jsonb: jsonb('jsonb'),
+				line: line('line', {
+					mode: 'abc',
+				}),
+				lineTuple: line('line_tuple', {
+					mode: 'tuple',
+				}),
+				macaddr: macaddr('macaddr'),
+				macaddr8: macaddr8('macaddr8'),
+				numeric: numeric('numeric'),
+				numericNum: numeric('numeric_num', {
+					mode: 'number',
+				}),
+				numericBig: numeric('numeric_big', {
+					mode: 'bigint',
+				}),
+				point: point('point', {
+					mode: 'xy',
+				}),
+				pointTuple: point('point_tuple', {
+					mode: 'tuple',
+				}),
+				real: real('real'),
+				smallint: smallint('smallint'),
+				smallserial: smallserial('smallserial'),
+				text: text('text'),
+				time: time('time'),
+				timestamp: timestamp('timestamp', {
+					mode: 'date',
+				}),
+				timestampTz: timestamp('timestamp_tz', {
+					mode: 'date',
+					withTimezone: true,
+				}),
+				timestampStr: timestamp('timestamp_str', {
+					mode: 'string',
+				}),
+				timestampTzStr: timestamp('timestamp_tz_str', {
+					mode: 'string',
+					withTimezone: true,
+				}),
+				uuid: uuid('uuid'),
+				varchar: varchar('varchar'),
+				arrint: integer('arrint').array(),
+				arrbigint53: bigint('arrbigint53', {
+					mode: 'number',
+				}).array(),
+				arrbigint64: bigint('arrbigint64', {
+					mode: 'bigint',
+				}).array(),
+				arrbigintString: bigint('arrbigint_string', {
+					mode: 'string',
+				}).array(),
+				arrbool: boolean('arrbool').array(),
+				arrbytea: bytea('arrbytea').array(),
+				arrchar: char('arrchar').array(),
+				arrcidr: cidr('arrcidr').array(),
+				arrdate: date('arrdate', {
+					mode: 'date',
+				}).array(),
+				arrdateStr: date('arrdate_str', {
+					mode: 'string',
+				}).array(),
+				arrdouble: doublePrecision('arrdouble').array(),
+				arrenum: en('arrenum').array(),
+				arrinet: inet('arrinet').array(),
+				arrinterval: interval('arrinterval').array(),
+				arrjson: json('arrjson').array(),
+				arrjsonb: jsonb('arrjsonb').array(),
+				arrline: line('arrline', {
+					mode: 'abc',
+				}).array(),
+				arrlineTuple: line('arrline_tuple', {
+					mode: 'tuple',
+				}).array(),
+				arrmacaddr: macaddr('arrmacaddr').array(),
+				arrmacaddr8: macaddr8('arrmacaddr8').array(),
+				arrnumeric: numeric('arrnumeric').array(),
+				arrnumericNum: numeric('arrnumeric_num', {
+					mode: 'number',
+				}).array(),
+				arrnumericBig: numeric('arrnumeric_big', {
+					mode: 'bigint',
+				}).array(),
+				arrpoint: point('arrpoint', {
+					mode: 'xy',
+				}).array(),
+				arrpointTuple: point('arrpoint_tuple', {
+					mode: 'tuple',
+				}).array(),
+				arrreal: real('arrreal').array(),
+				arrsmallint: smallint('arrsmallint').array(),
+				arrtext: text('arrtext').array(),
+				arrtime: time('arrtime').array(),
+				arrtimestamp: timestamp('arrtimestamp', {
+					mode: 'date',
+				}).array(),
+				arrtimestampTz: timestamp('arrtimestamp_tz', {
+					mode: 'date',
+					withTimezone: true,
+				}).array(),
+				arrtimestampStr: timestamp('arrtimestamp_str', {
+					mode: 'string',
+				}).array(),
+				arrtimestampTzStr: timestamp('arrtimestamp_tz_str', {
+					mode: 'string',
+					withTimezone: true,
+				}).array(),
+				arruuid: uuid('arruuid').array(),
+				arrvarchar: varchar('arrvarchar').array(),
+			});
+
+			await push({ en, allTypesTable });
+
+			await db.insert(allTypesTable).values({
+				serial: 1,
+				smallserial: 15,
+				bigint53: 9007199254740991,
+				bigint64: 5044565289845416380n,
+				bigintString: '5044565289845416380',
+				bigserial53: 9007199254740991,
+				bigserial64: 5044565289845416380n,
+				bool: true,
+				bytea: Buffer.from('BYTES'),
+				char: 'c',
+				cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+				inet: '192.168.0.1/24',
+				macaddr: '08:00:2b:01:02:03',
+				macaddr8: '08:00:2b:01:02:03:04:05',
+				date: new Date(1741743161623),
+				dateStr: new Date(1741743161623).toISOString(),
+				double: 15.35325689124218,
+				enum: 'enVal1',
+				int: 621,
+				interval: '2 months ago',
+				json: {
+					str: 'strval',
+					arr: ['str', 10],
+				},
+				jsonb: {
+					str: 'strvalb',
+					arr: ['strb', 11],
+				},
+				line: {
+					a: 1,
+					b: 2,
+					c: 3,
+				},
+				lineTuple: [1, 2, 3],
+				numeric: '475452353476',
+				numericNum: 9007199254740991,
+				numericBig: 5044565289845416380n,
+				point: {
+					x: 24.5,
+					y: 49.6,
+				},
+				pointTuple: [57.2, 94.3],
+				real: 1.048596,
+				smallint: 10,
+				text: 'TEXT STRING',
+				time: '13:59:28',
+				timestamp: new Date(1741743161623),
+				timestampTz: new Date(1741743161623),
+				timestampStr: new Date(1741743161623).toISOString(),
+				timestampTzStr: new Date(1741743161623).toISOString(),
+				uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+				varchar: 'C4-',
+				arrbigint53: [9007199254740991],
+				arrbigint64: [5044565289845416380n],
+				arrbigintString: ['5044565289845416380'],
+				arrbool: [true],
+				arrbytea: [Buffer.from('BYTES')],
+				arrchar: ['c'],
+				arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+				arrinet: ['192.168.0.1/24'],
+				arrmacaddr: ['08:00:2b:01:02:03'],
+				arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+				arrdate: [new Date(1741743161623)],
+				arrdateStr: [new Date(1741743161623).toISOString()],
+				arrdouble: [15.35325689124218],
+				arrenum: ['enVal1'],
+				arrint: [621],
+				arrinterval: ['2 months ago'],
+				arrjson: [
+					{
+						str: 'strval',
+						arr: ['str', 10],
+					},
+				],
+				arrjsonb: [
+					{
+						str: 'strvalb',
+						arr: ['strb', 11],
+					},
+				],
+				arrline: [
+					{
+						a: 1,
+						b: 2,
+						c: 3,
+					},
+				],
+				arrlineTuple: [[1, 2, 3]],
+				arrnumeric: ['475452353476'],
+				arrnumericNum: [9007199254740991],
+				arrnumericBig: [5044565289845416380n],
+				arrpoint: [
+					{
+						x: 24.5,
+						y: 49.6,
+					},
+				],
+				arrpointTuple: [[57.2, 94.3]],
+				arrreal: [1.048596],
+				arrsmallint: [10],
+				arrtext: ['TEXT STRING'],
+				arrtime: ['13:59:28'],
+				arrtimestamp: [new Date(1741743161623)],
+				arrtimestampTz: [new Date(1741743161623)],
+				arrtimestampStr: [new Date(1741743161623).toISOString()],
+				arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+				arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+				arrvarchar: ['C4-'],
+			});
+
+			const rawRes = await db.select().from(allTypesTable);
+
+			type ExpectedType = {
+				serial: number;
+				bigserial53: number;
+				bigserial64: bigint;
+				int: number | null;
+				bigint53: number | null;
+				bigint64: bigint | null;
+				bigintString: string | null;
+				bool: boolean | null;
+				bytea: Buffer | null;
+				char: string | null;
+				cidr: string | null;
+				date: Date | null;
+				dateStr: string | null;
+				double: number | null;
+				enum: 'enVal1' | 'enVal2' | null;
+				inet: string | null;
+				interval: string | null;
+				json: unknown;
+				jsonb: unknown;
+				line: {
+					a: number;
+					b: number;
+					c: number;
+				} | null;
+				lineTuple: [number, number, number] | null;
+				macaddr: string | null;
+				macaddr8: string | null;
+				numeric: string | null;
+				numericNum: number | null;
+				numericBig: bigint | null;
+				point: {
+					x: number;
+					y: number;
+				} | null;
+				pointTuple: [number, number] | null;
+				real: number | null;
+				smallint: number | null;
+				smallserial: number;
+				text: string | null;
+				time: string | null;
+				timestamp: Date | null;
+				timestampTz: Date | null;
+				timestampStr: string | null;
+				timestampTzStr: string | null;
+				uuid: string | null;
+				varchar: string | null;
+				arrint: number[] | null;
+				arrbigint53: number[] | null;
+				arrbigint64: bigint[] | null;
+				arrbigintString: string[] | null;
+				arrbool: boolean[] | null;
+				arrbytea: Buffer[] | null;
+				arrchar: string[] | null;
+				arrcidr: string[] | null;
+				arrdate: Date[] | null;
+				arrdateStr: string[] | null;
+				arrdouble: number[] | null;
+				arrenum: ('enVal1' | 'enVal2')[] | null;
+				arrinet: string[] | null;
+				arrinterval: string[] | null;
+				arrjson: unknown[] | null;
+				arrjsonb: unknown[] | null;
+				arrline:
+					| {
+						a: number;
+						b: number;
+						c: number;
+					}[]
+					| null;
+				arrlineTuple: [number, number, number][] | null;
+				arrmacaddr: string[] | null;
+				arrmacaddr8: string[] | null;
+				arrnumeric: string[] | null;
+				arrnumericNum: number[] | null;
+				arrnumericBig: bigint[] | null;
+				arrpoint: { x: number; y: number }[] | null;
+				arrpointTuple: [number, number][] | null;
+				arrreal: number[] | null;
+				arrsmallint: number[] | null;
+				arrtext: string[] | null;
+				arrtime: string[] | null;
+				arrtimestamp: Date[] | null;
+				arrtimestampTz: Date[] | null;
+				arrtimestampStr: string[] | null;
+				arrtimestampTzStr: string[] | null;
+				arruuid: string[] | null;
+				arrvarchar: string[] | null;
+			}[];
+
+			const expectedRes: ExpectedType = [
+				{
+					serial: 1,
+					bigserial53: 9007199254740991,
+					bigserial64: 5044565289845416380n,
+					int: 621,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bigintString: '5044565289845416380',
+					bool: true,
+					bytea: Buffer.from('BYTES'),
+					char: 'c',
+					cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+					date: new Date('2025-03-12T00:00:00.000Z'),
+					dateStr: '2025-03-12',
+					double: 15.35325689124218,
+					enum: 'enVal1',
+					inet: '192.168.0.1/24',
+					interval: '-2 mons',
+					json: { str: 'strval', arr: ['str', 10] },
+					jsonb: { arr: ['strb', 11], str: 'strvalb' },
+					line: { a: 1, b: 2, c: 3 },
+					lineTuple: [1, 2, 3],
+					macaddr: '08:00:2b:01:02:03',
+					macaddr8: '08:00:2b:01:02:03:04:05',
+					numeric: '475452353476',
+					numericNum: 9007199254740991,
+					numericBig: 5044565289845416380n,
+					point: { x: 24.5, y: 49.6 },
+					pointTuple: [57.2, 94.3],
+					real: 1.048596,
+					smallint: 10,
+					smallserial: 15,
+					text: 'TEXT STRING',
+					time: '13:59:28',
+					timestamp: new Date('2025-03-12T01:32:41.623Z'),
+					timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+					timestampStr: '2025-03-12 01:32:41.623',
+					timestampTzStr: '2025-03-12 01:32:41.623+00',
+					uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+					varchar: 'C4-',
+					arrint: [621],
+					arrbigint53: [9007199254740991],
+					arrbigint64: [5044565289845416380n],
+					arrbigintString: ['5044565289845416380'],
+					arrbool: [true],
+					arrbytea: [Buffer.from('BYTES')],
+					arrchar: ['c'],
+					arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+					arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+					arrdateStr: ['2025-03-12'],
+					arrdouble: [15.35325689124218],
+					arrenum: ['enVal1'],
+					arrinet: ['192.168.0.1/24'],
+					arrinterval: ['-2 mons'],
+					arrjson: [{ str: 'strval', arr: ['str', 10] }],
+					arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+					arrline: [{ a: 1, b: 2, c: 3 }],
+					arrlineTuple: [[1, 2, 3]],
+					arrmacaddr: ['08:00:2b:01:02:03'],
+					arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+					arrnumeric: ['475452353476'],
+					arrnumericNum: [9007199254740991],
+					arrnumericBig: [5044565289845416380n],
+					arrpoint: [{ x: 24.5, y: 49.6 }],
+					arrpointTuple: [[57.2, 94.3]],
+					arrreal: [1.048596],
+					arrsmallint: [10],
+					arrtext: ['TEXT STRING'],
+					arrtime: ['13:59:28'],
+					arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+					arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+					arrtimestampStr: ['2025-03-12 01:32:41.623'],
+					arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+					arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+					arrvarchar: ['C4-'],
+				},
+			];
+
+			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+			expect(rawRes).toStrictEqual(expectedRes);
+		});
+
+		test('raw jsons', async ({ db, push }) => {
+			const allTypesTable = pgTable('all_types_raw_jsons', {
+				json: json('json'),
+				jsonb: jsonb('jsonb'),
+				arrjson: json('arrjson').array(),
+				arrjsonb: jsonb('arrjsonb').array(),
+			});
+
+			await push({ allTypesTable });
+
+			await db.insert(allTypesTable).values({
+				json: {
+					str: 'strval',
+					arr: ['str', 10],
+				},
+				jsonb: {
+					str: 'strvalb',
+					arr: ['strb', 11],
+				},
+				arrjson: [{
+					str: 'strval',
+					arr: ['str', 10],
+				}],
+				arrjsonb: [{
+					str: 'strvalb',
+					arr: ['strb', 11],
+				}],
+			});
+
+			const queryRes1 = await db.execute(sql`select * from ${allTypesTable};`);
+			const rawData1 = [(queryRes1.rows ?? queryRes1)[0]];
+
+			const expectedRes1 = [
+				{
+					json: { str: 'strval', arr: ['str', 10] },
+					jsonb: { arr: ['strb', 11], str: 'strvalb' },
+
+					arrjson: [{ str: 'strval', arr: ['str', 10] }],
+					arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+				},
+			];
+
+			expect(rawData1).toStrictEqual(expectedRes1);
+
+			await db.update(allTypesTable).set({
+				json: {
+					str: 'strval',
+					arr: ['str', 100],
+				},
+				jsonb: {
+					str: 'strvalb',
+					arr: ['strb', 110],
+				},
+				arrjson: [{
+					str: 'strval',
+					arr: ['str', 100],
+				}],
+				arrjsonb: [{
+					str: 'strvalb',
+					arr: ['strb', 110],
+				}],
+			});
+
+			const queryRes2 = await db.execute(sql`select * from ${allTypesTable};`);
+			const rawData2 = [(queryRes2.rows ?? queryRes2)[0]];
+
+			const expectedRes2 = [
+				{
+					json: { str: 'strval', arr: ['str', 100] },
+					jsonb: { arr: ['strb', 110], str: 'strvalb' },
+
+					arrjson: [{ str: 'strval', arr: ['str', 100] }],
+					arrjsonb: [{ arr: ['strb', 110], str: 'strvalb' }],
+				},
+			];
+
+			expect(rawData2).toStrictEqual(expectedRes2);
+		});
+
+		test.concurrent('all types ~codecs~', async ({ createDB, push }) => {
+			const en = pgEnum('en_49', ['enVal1', 'enVal2']);
+			const allTypesTable = pgTable('all_types_48_cdcs', {
+				serial: serial('serial').notNull(),
+				bigserial: bigserial('bigserial', {
+					mode: 'bigint',
+				}).notNull(),
+				bigserialnum: bigserial('bigserialnum', {
+					mode: 'number',
+				}).notNull(),
+				int: integer('int').notNull(),
+				bigint: bigint('bigint', {
+					mode: 'bigint',
+				}).notNull(),
+				bigintnum: bigint('bigintnum', {
+					mode: 'number',
+				}).notNull(),
+				bigintstr: bigint('bigintstr', {
+					mode: 'string',
+				}).notNull(),
+				bool: boolean('bool').notNull(),
+				bytea: bytea('bytea').notNull(),
+				char: char('char').notNull(),
+				cidr: cidr('cidr').notNull(),
+				date: date('date', {
+					mode: 'date',
+				}).notNull(),
+				datestr: date('datestr', {
+					mode: 'string',
+				}).notNull(),
+				double: doublePrecision('double').notNull(),
+				enum: en('enum').notNull(),
+				inet: inet('inet').notNull(),
+				interval: interval('interval').notNull(),
+				json: json('json').notNull(),
+				jsonb: jsonb('jsonb').notNull(),
+				json1: json('json1').notNull(),
+				jsonb1: jsonb('jsonb1').notNull(),
+				json2: json('json2').notNull(),
+				jsonb2: jsonb('jsonb2').notNull(),
+				json3: json('json3').notNull(),
+				jsonb3: jsonb('jsonb3').notNull(),
+				line: line('line', {
+					mode: 'abc',
+				}).notNull(),
+				linetuple: line('linetuple', {
+					mode: 'tuple',
+				}).notNull(),
+				macaddr: macaddr('macaddr').notNull(),
+				macaddr8: macaddr8('macaddr8').notNull(),
+				numeric: numeric('numeric').notNull(),
+				numericnum: numeric('numericnum', {
+					mode: 'number',
+				}).notNull(),
+				numericbig: numeric('numericbig', {
+					mode: 'bigint',
+				}).notNull(),
+				point: point('point', {
+					mode: 'xy',
+				}).notNull(),
+				pointtuple: point('pointtuple', {
+					mode: 'tuple',
+				}).notNull(),
+				real: real('real').notNull(),
+				smallint: smallint('smallint').notNull(),
+				smallserial: smallserial('smallserial').notNull(),
+				text: text('text').notNull(),
+				time: time('time').notNull(),
+				timestamp: timestamp('timestamp', {
+					mode: 'date',
+				}).notNull(),
+				timestampTz: timestamp('timestampTz', {
+					mode: 'date',
+					withTimezone: true,
+				}).notNull(),
+				timestampstr: timestamp('timestampstr', {
+					mode: 'string',
+				}).notNull(),
+				timestampTzstr: timestamp('timestampTzstr', {
+					mode: 'string',
+					withTimezone: true,
+				}).notNull(),
+				uuid: uuid('uuid').notNull(),
+				varchar: varchar('varchar').notNull(),
+				arrint: integer('arrint').array().notNull(),
+				arrbigint: bigint('arrbigint', {
+					mode: 'bigint',
+				}).array().notNull(),
+				arrbigintnum: bigint('arrbigintnum', {
+					mode: 'number',
+				}).array().notNull(),
+				arrbigintstr: bigint('arrbigintstr', {
+					mode: 'string',
+				}).array().notNull(),
+				arrbool: boolean('arrbool').array().notNull(),
+				arrbytea: bytea('arrbytea').array().notNull(),
+				mtxbytea: bytea('mtxbytea').array('[][]').notNull(),
+				arrchar: char('arrchar').array().notNull(),
+				arrcidr: cidr('arrcidr').array().notNull(),
+				arrdate: date('arrdate', {
+					mode: 'date',
+				}).array().notNull(),
+				arrdatestr: date('arrdatestr', {
+					mode: 'string',
+				}).array().notNull(),
+				arrdouble: doublePrecision('arrdouble').array().notNull(),
+				arrenum: en('arrenum').array().notNull(),
+				arrinet: inet('arrinet').array().notNull(),
+				arrinterval: interval('arrinterval').array().notNull(),
+				arrjson: json('arrjson').array().notNull(),
+				arrjsonb: jsonb('arrjsonb').array().notNull(),
+				arrjson1: json('arrjson1').array().notNull(),
+				arrjsonb1: jsonb('arrjsonb1').array().notNull(),
+				arrjson2: json('arrjson2').array().notNull(),
+				arrjsonb2: jsonb('arrjsonb2').array().notNull(),
+				arrjson3: json('arrjson3').array().notNull(),
+				arrjsonb3: jsonb('arrjsonb3').array().notNull(),
+				arrline: line('arrline', {
+					mode: 'abc',
+				}).array().notNull(),
+				arrlinetuple: line('arrlinetuple', {
+					mode: 'tuple',
+				}).array().notNull(),
+				arrmacaddr: macaddr('arrmacaddr').array().notNull(),
+				arrmacaddr8: macaddr8('arrmacaddr8').array().notNull(),
+				arrnumeric: numeric('arrnumeric').array().notNull(),
+				arrnumericnum: numeric('arrnumericnum', { mode: 'number' }).array().notNull(),
+				arrnumericbig: numeric('arrnumericbig', { mode: 'bigint' }).array().notNull(),
+				arrpoint: point('arrpoint', {
+					mode: 'xy',
+				}).array().notNull(),
+				arrpointtuple: point('arrpointtuple', {
+					mode: 'tuple',
+				}).array().notNull(),
+				arrreal: real('arrreal').array().notNull(),
+				arrsmallint: smallint('arrsmallint').array().notNull(),
+				arrtext: text('arrtext').array().notNull(),
+				arrtime: time('arrtime').array().notNull(),
+				arrtimestamp: timestamp('arrtimestamp', {
+					mode: 'date',
+				}).array().notNull(),
+				arrtimestampTz: timestamp('arrtimestampTz', {
+					mode: 'date',
+					withTimezone: true,
+				}).array().notNull(),
+				arrtimestampstr: timestamp('arrtimestampstr', {
+					mode: 'string',
+				}).array().notNull(),
+				arrtimestampTzstr: timestamp('arrtimestampTzstr', {
+					mode: 'string',
+					withTimezone: true,
+				}).array().notNull(),
+				arruuid: uuid('arruuid').array().notNull(),
+				arrvarchar: varchar('arrvarchar').array().notNull(),
+			});
+
+			const db = createDB({ allTypesTable }, (r) => ({
+				allTypesTable: {
+					self: r.many.allTypesTable({
+						from: r.allTypesTable.serial,
+						to: r.allTypesTable.serial,
+					}),
+				},
+			}));
+			await push({ en, allTypesTable });
+			type ExpectedType = {
+				serial: number;
+				bigserial: bigint;
+				bigserialnum: number;
+				int: number;
+				bigint: bigint;
+				bigintnum: number;
+				bigintstr: string;
+				bool: boolean;
+				bytea: Buffer;
+				char: string;
+				cidr: string;
+				date: Date;
+				datestr: string;
+				double: number;
+				enum: 'enVal1' | 'enVal2';
+				inet: string;
+				interval: string;
+				json: unknown;
+				jsonb: unknown;
+				json1: unknown;
+				jsonb1: unknown;
+				json2: unknown;
+				jsonb2: unknown;
+				json3: unknown;
+				jsonb3: unknown;
+				line: { a: number; b: number; c: number };
+				linetuple: [number, number, number];
+				macaddr: string;
+				macaddr8: string;
+				numeric: string;
+				numericnum: number;
+				numericbig: bigint;
+				point: { x: number; y: number };
+				pointtuple: [number, number];
+				real: number;
+				smallint: number;
+				smallserial: number;
+				text: string;
+				time: string;
+				timestamp: Date;
+				timestampTz: Date;
+				timestampstr: string;
+				timestampTzstr: string;
+				uuid: string;
+				varchar: string;
+				arrint: number[];
+				arrbigint: bigint[];
+				arrbigintnum: number[];
+				arrbigintstr: string[];
+				arrbool: boolean[];
+				arrbytea: (Buffer)[];
+				mtxbytea: (Buffer)[][];
+				arrchar: string[];
+				arrcidr: string[];
+				arrdate: Date[];
+				arrdatestr: string[];
+				arrdouble: number[];
+				arrenum: ('enVal1' | 'enVal2')[];
+				arrinet: string[];
+				arrinterval: string[];
+				arrjson: unknown[];
+				arrjsonb: unknown[];
+				arrjson1: unknown[];
+				arrjsonb1: unknown[];
+				arrjson2: unknown[];
+				arrjsonb2: unknown[];
+				arrjson3: unknown[];
+				arrjsonb3: unknown[];
+				arrline: { a: number; b: number; c: number }[];
+				arrlinetuple: [number, number, number][];
+				arrmacaddr: string[];
+				arrmacaddr8: string[];
+				arrnumeric: string[];
+				arrnumericnum: number[];
+				arrnumericbig: bigint[];
+				arrpoint: { x: number; y: number }[];
+				arrpointtuple: [number, number][];
+				arrreal: number[];
+				arrsmallint: number[];
+				arrtext: string[];
+				arrtime: string[];
+				arrtimestamp: Date[];
+				arrtimestampTz: Date[];
+				arrtimestampstr: string[];
+				arrtimestampTzstr: string[];
+				arruuid: string[];
+				arrvarchar: string[];
+			};
+
+			const testData: ExpectedType = {
+				serial: 1,
+				bigserial: 5044565289845416380n,
+				bigserialnum: 9007199254740991,
+				int: 621,
+				bigint: 5044565289845416380n,
+				bigintnum: 9007199254740991,
+				bigintstr: '5044565289845416380',
+				bool: true,
+				bytea: Buffer.from('BYTES'),
+				char: 'c',
+				cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+				date: new Date('2025-03-12'),
+				datestr: '2025-03-12',
+				double: 15.35325689124218,
+				enum: 'enVal1',
+				inet: '192.168.0.1/24',
+				interval: '-2 mons',
+				json: { str: 'strval', arr: ['str', 10] },
+				jsonb: { arr: ['strb', 11], str: 'strvalb' },
+				json1: [{ key: 'value', num: 7 }, 'v', '11', 5],
+				jsonb1: [{ key: 'value', num: 8 }, 'x', '10', 3],
+				json2: 5,
+				jsonb2: 7,
+				json3: '5',
+				jsonb3: '7',
+				line: { a: 1, b: 2, c: 3 },
+				linetuple: [1, 2, 3],
+				macaddr: '08:00:2b:01:02:03',
+				macaddr8: '08:00:2b:01:02:03:04:05',
+				numeric: '5044565289845416380',
+				numericnum: 9007199254740991,
+				numericbig: 5044565289845416380n,
+				point: { x: 24.5, y: 49.6 },
+				pointtuple: [24.5, 49.6],
+				real: 1.048596,
+				smallint: 10,
+				smallserial: 15,
+				text: 'TEXT STRING',
+				time: '13:59:28',
+				timestamp: new Date('2025-03-12 01:32:41.623'),
+				timestampTz: new Date('2025-03-12 01:32:41.623+00'),
+				timestampstr: '2025-03-12 01:32:41.623',
+				timestampTzstr: '2025-03-12 01:32:41.623+00',
+				uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+				varchar: 'C4-',
+				arrint: [621],
+				arrbigint: [5044565289845416380n],
+				arrbigintnum: [9007199254740991],
+				arrbigintstr: ['5044565289845416380'],
+				arrbool: [true],
+				arrbytea: [Buffer.from('BYTES')],
+				mtxbytea: [[Buffer.from('BYTES'), Buffer.from('BYTES2')], [
+					Buffer.from('OTHERBYTES'),
+					Buffer.from('OTHERBYTES2'),
+				]],
+				arrchar: ['c'],
+				arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+				arrdate: [new Date('2025-03-12')],
+				arrdatestr: ['2025-03-12'],
+				arrdouble: [15.35325689124218],
+				arrenum: ['enVal1'],
+				arrinet: ['192.168.0.1/24'],
+				arrinterval: ['-2 mons'],
+				arrjson: [{ str: 'strval', arr: ['str', 10] }],
+				arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+				arrjson1: [[{ key: 'value', num: 7 }, 'v', '11', 5]],
+				arrjsonb1: [[{ key: 'value', num: 8 }, 'x', '10', 3]],
+				arrjson2: [5],
+				arrjsonb2: [7],
+				arrjson3: ['5'],
+				arrjsonb3: ['7'],
+				arrline: [{ a: 1, b: 2, c: 3 }],
+				arrlinetuple: [[1, 2, 3]],
+				arrmacaddr: ['08:00:2b:01:02:03'],
+				arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+				arrnumeric: ['5044565289845416380'],
+				arrnumericnum: [9007199254740991],
+				arrnumericbig: [5044565289845416380n],
+				arrpoint: [{ x: 24.5, y: 49.6 }],
+				arrpointtuple: [[24.5, 49.6]],
+				arrreal: [1.048596],
+				arrsmallint: [10],
+				arrtext: ['TEXT STRING'],
+				arrtime: ['13:59:28'],
+				arrtimestamp: [new Date('2025-03-12 01:32:41.623')],
+				arrtimestampTz: [new Date('2025-03-12 01:32:41.623+00')],
+				arrtimestampstr: ['2025-03-12 01:32:41.623'],
+				arrtimestampTzstr: ['2025-03-12 01:32:41.623+00'],
+				arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+				arrvarchar: ['C4-'],
+			};
+
+			await db.insert(allTypesTable).values(testData);
+			const session = (<any> db).session as PgAsyncSession;
+
+			const queryRes = await session.objects<ExpectedType>(db.select().from(allTypesTable).getSQL()).then((e) =>
+				normalizeDataWithDbCodecs({
+					db,
+					columns: getColumns(allTypesTable),
+					data: e,
+					mode: 'query',
+				})[0]
+			);
+
+			const { relationRes, rootRes } = await session.objects<ExpectedType & { self: ExpectedType[] }>(
+				db.query.allTypesTable.findFirst({
+					with: {
+						self: true,
+					},
+				}).getSQL(),
+			).then((e) => {
+				const { self: relationRaw, ...rootRaw } = e[0]!;
+
+				return {
+					relationRes: normalizeDataWithDbCodecs({
+						db,
+						columns: getColumns(allTypesTable),
+						data: relationRaw,
+						mode: 'json',
+					})[0]!,
+					rootRes: normalizeDataWithDbCodecs({
+						db,
+						columns: getColumns(allTypesTable),
+						data: [rootRaw],
+						mode: 'query',
+					})[0]!,
+				};
+			});
+
+			expect(queryRes).toStrictEqual(testData);
+			expect(relationRes).toStrictEqual(testData);
+			expect(rootRes).toStrictEqual(testData);
+
+			// ---- numbers ----
+			expect(
+				await unionAll(
+					db.select({
+						'int ∪ int': allTypesTable.int.as('int ∪ int'),
+						'int ∪ smallint': allTypesTable.int.as('int ∪ smallint'),
+						'int ∪ double': allTypesTable.int.as('int ∪ double'),
+						'int ∪ real': allTypesTable.int.as('int ∪ real'),
+						'int ∪ smallserial': allTypesTable.int.as('int ∪ smallserial'),
+						'int ∪ serial': allTypesTable.int.as('int ∪ serial'),
+						'int ∪ bigserialnum': allTypesTable.int.as('int ∪ bigserialnum'),
+						'int ∪ bigintnum': allTypesTable.int.as('int ∪ bigintnum'),
+						'int ∪ numericnum': allTypesTable.int.as('int ∪ numericnum'),
+						'smallint ∪ int': allTypesTable.smallint.as('smallint ∪ int'),
+						'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+						'smallint ∪ double': allTypesTable.smallint.as('smallint ∪ double'),
+						'smallint ∪ real': allTypesTable.smallint.as('smallint ∪ real'),
+						'smallint ∪ smallserial': allTypesTable.smallint.as('smallint ∪ smallserial'),
+						'smallint ∪ serial': allTypesTable.smallint.as('smallint ∪ serial'),
+						'smallint ∪ bigserialnum': allTypesTable.smallint.as('smallint ∪ bigserialnum'),
+						'smallint ∪ bigintnum': allTypesTable.smallint.as('smallint ∪ bigintnum'),
+						'smallint ∪ numericnum': allTypesTable.smallint.as('smallint ∪ numericnum'),
+						'double ∪ int': allTypesTable.double.as('double ∪ int'),
+						'double ∪ smallint': allTypesTable.double.as('double ∪ smallint'),
+						'double ∪ double': allTypesTable.double.as('double ∪ double'),
+						'double ∪ real': allTypesTable.double.as('double ∪ real'),
+						'double ∪ smallserial': allTypesTable.double.as('double ∪ smallserial'),
+						'double ∪ serial': allTypesTable.double.as('double ∪ serial'),
+						'double ∪ bigserialnum': allTypesTable.double.as('double ∪ bigserialnum'),
+						'double ∪ bigintnum': allTypesTable.double.as('double ∪ bigintnum'),
+						'double ∪ numericnum': allTypesTable.double.as('double ∪ numericnum'),
+						'real ∪ int': allTypesTable.real.as('real ∪ int'),
+						'real ∪ smallint': allTypesTable.real.as('real ∪ smallint'),
+						'real ∪ double': allTypesTable.real.as('real ∪ double'),
+						'real ∪ real': allTypesTable.real.as('real ∪ real'),
+						'real ∪ smallserial': allTypesTable.real.as('real ∪ smallserial'),
+						'real ∪ serial': allTypesTable.real.as('real ∪ serial'),
+						'smallserial ∪ int': allTypesTable.smallserial.as('smallserial ∪ int'),
+						'smallserial ∪ smallint': allTypesTable.smallserial.as('smallserial ∪ smallint'),
+						'smallserial ∪ double': allTypesTable.smallserial.as('smallserial ∪ double'),
+						'smallserial ∪ real': allTypesTable.smallserial.as('smallserial ∪ real'),
+						'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+						'smallserial ∪ serial': allTypesTable.smallserial.as('smallserial ∪ serial'),
+						'smallserial ∪ bigserialnum': allTypesTable.smallserial.as('smallserial ∪ bigserialnum'),
+						'smallserial ∪ bigintnum': allTypesTable.smallserial.as('smallserial ∪ bigintnum'),
+						'smallserial ∪ numericnum': allTypesTable.smallserial.as('smallserial ∪ numericnum'),
+						'serial ∪ int': allTypesTable.serial.as('serial ∪ int'),
+						'serial ∪ smallint': allTypesTable.serial.as('serial ∪ smallint'),
+						'serial ∪ double': allTypesTable.serial.as('serial ∪ double'),
+						'serial ∪ real': allTypesTable.serial.as('serial ∪ real'),
+						'serial ∪ smallserial': allTypesTable.serial.as('serial ∪ smallserial'),
+						'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+						'serial ∪ bigserialnum': allTypesTable.serial.as('serial ∪ bigserialnum'),
+						'serial ∪ bigintnum': allTypesTable.serial.as('serial ∪ bigintnum'),
+						'serial ∪ numericnum': allTypesTable.serial.as('serial ∪ numericnum'),
+						'bigserialnum ∪ int': allTypesTable.bigserialnum.as('bigserialnum ∪ int'),
+						'bigserialnum ∪ smallint': allTypesTable.bigserialnum.as('bigserialnum ∪ smallint'),
+						'bigserialnum ∪ double': allTypesTable.bigserialnum.as('bigserialnum ∪ double'),
+						'bigserialnum ∪ smallserial': allTypesTable.bigserialnum.as('bigserialnum ∪ smallserial'),
+						'bigserialnum ∪ serial': allTypesTable.bigserialnum.as('bigserialnum ∪ serial'),
+						'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+						'bigserialnum ∪ bigintnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigintnum'),
+						'bigserialnum ∪ numericnum': allTypesTable.bigserialnum.as('bigserialnum ∪ numericnum'),
+						'bigintnum ∪ int': allTypesTable.bigintnum.as('bigintnum ∪ int'),
+						'bigintnum ∪ smallint': allTypesTable.bigintnum.as('bigintnum ∪ smallint'),
+						'bigintnum ∪ double': allTypesTable.bigintnum.as('bigintnum ∪ double'),
+						'bigintnum ∪ smallserial': allTypesTable.bigintnum.as('bigintnum ∪ smallserial'),
+						'bigintnum ∪ serial': allTypesTable.bigintnum.as('bigintnum ∪ serial'),
+						'bigintnum ∪ bigserialnum': allTypesTable.bigintnum.as('bigintnum ∪ bigserialnum'),
+						'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+						'bigintnum ∪ numericnum': allTypesTable.bigintnum.as('bigintnum ∪ numericnum'),
+						'numericnum ∪ int': allTypesTable.numericnum.as('numericnum ∪ int'),
+						'numericnum ∪ smallint': allTypesTable.numericnum.as('numericnum ∪ smallint'),
+						'numericnum ∪ double': allTypesTable.numericnum.as('numericnum ∪ double'),
+						'numericnum ∪ smallserial': allTypesTable.numericnum.as('numericnum ∪ smallserial'),
+						'numericnum ∪ serial': allTypesTable.numericnum.as('numericnum ∪ serial'),
+						'numericnum ∪ bigserialnum': allTypesTable.numericnum.as('numericnum ∪ bigserialnum'),
+						'numericnum ∪ bigintnum': allTypesTable.numericnum.as('numericnum ∪ bigintnum'),
+						'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+					}).from(allTypesTable),
+					db.select({
+						'int ∪ int': allTypesTable.int.as('int ∪ int'),
+						'int ∪ smallint': allTypesTable.smallint.as('int ∪ smallint'),
+						'int ∪ double': allTypesTable.double.as('int ∪ double'),
+						'int ∪ real': allTypesTable.real.as('int ∪ real'),
+						'int ∪ smallserial': allTypesTable.smallserial.as('int ∪ smallserial'),
+						'int ∪ serial': allTypesTable.serial.as('int ∪ serial'),
+						'int ∪ bigserialnum': allTypesTable.bigserialnum.as('int ∪ bigserialnum'),
+						'int ∪ bigintnum': allTypesTable.bigintnum.as('int ∪ bigintnum'),
+						'int ∪ numericnum': allTypesTable.numericnum.as('int ∪ numericnum'),
+						'smallint ∪ int': allTypesTable.int.as('smallint ∪ int'),
+						'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+						'smallint ∪ double': allTypesTable.double.as('smallint ∪ double'),
+						'smallint ∪ real': allTypesTable.real.as('smallint ∪ real'),
+						'smallint ∪ smallserial': allTypesTable.smallserial.as('smallint ∪ smallserial'),
+						'smallint ∪ serial': allTypesTable.serial.as('smallint ∪ serial'),
+						'smallint ∪ bigserialnum': allTypesTable.bigserialnum.as('smallint ∪ bigserialnum'),
+						'smallint ∪ bigintnum': allTypesTable.bigintnum.as('smallint ∪ bigintnum'),
+						'smallint ∪ numericnum': allTypesTable.numericnum.as('smallint ∪ numericnum'),
+						'double ∪ int': allTypesTable.int.as('double ∪ int'),
+						'double ∪ smallint': allTypesTable.smallint.as('double ∪ smallint'),
+						'double ∪ double': allTypesTable.double.as('double ∪ double'),
+						'double ∪ real': allTypesTable.real.as('double ∪ real'),
+						'double ∪ smallserial': allTypesTable.smallserial.as('double ∪ smallserial'),
+						'double ∪ serial': allTypesTable.serial.as('double ∪ serial'),
+						'double ∪ bigserialnum': allTypesTable.bigserialnum.as('double ∪ bigserialnum'),
+						'double ∪ bigintnum': allTypesTable.bigintnum.as('double ∪ bigintnum'),
+						'double ∪ numericnum': allTypesTable.numericnum.as('double ∪ numericnum'),
+						'real ∪ int': allTypesTable.int.as('real ∪ int'),
+						'real ∪ smallint': allTypesTable.smallint.as('real ∪ smallint'),
+						'real ∪ double': allTypesTable.double.as('real ∪ double'),
+						'real ∪ real': allTypesTable.real.as('real ∪ real'),
+						'real ∪ smallserial': allTypesTable.smallserial.as('real ∪ smallserial'),
+						'real ∪ serial': allTypesTable.serial.as('real ∪ serial'),
+						'smallserial ∪ int': allTypesTable.int.as('smallserial ∪ int'),
+						'smallserial ∪ smallint': allTypesTable.smallint.as('smallserial ∪ smallint'),
+						'smallserial ∪ double': allTypesTable.double.as('smallserial ∪ double'),
+						'smallserial ∪ real': allTypesTable.real.as('smallserial ∪ real'),
+						'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+						'smallserial ∪ serial': allTypesTable.serial.as('smallserial ∪ serial'),
+						'smallserial ∪ bigserialnum': allTypesTable.bigserialnum.as('smallserial ∪ bigserialnum'),
+						'smallserial ∪ bigintnum': allTypesTable.bigintnum.as('smallserial ∪ bigintnum'),
+						'smallserial ∪ numericnum': allTypesTable.numericnum.as('smallserial ∪ numericnum'),
+						'serial ∪ int': allTypesTable.int.as('serial ∪ int'),
+						'serial ∪ smallint': allTypesTable.smallint.as('serial ∪ smallint'),
+						'serial ∪ double': allTypesTable.double.as('serial ∪ double'),
+						'serial ∪ real': allTypesTable.real.as('serial ∪ real'),
+						'serial ∪ smallserial': allTypesTable.smallserial.as('serial ∪ smallserial'),
+						'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+						'serial ∪ bigserialnum': allTypesTable.bigserialnum.as('serial ∪ bigserialnum'),
+						'serial ∪ bigintnum': allTypesTable.bigintnum.as('serial ∪ bigintnum'),
+						'serial ∪ numericnum': allTypesTable.numericnum.as('serial ∪ numericnum'),
+						'bigserialnum ∪ int': allTypesTable.int.as('bigserialnum ∪ int'),
+						'bigserialnum ∪ smallint': allTypesTable.smallint.as('bigserialnum ∪ smallint'),
+						'bigserialnum ∪ double': allTypesTable.double.as('bigserialnum ∪ double'),
+						'bigserialnum ∪ smallserial': allTypesTable.smallserial.as('bigserialnum ∪ smallserial'),
+						'bigserialnum ∪ serial': allTypesTable.serial.as('bigserialnum ∪ serial'),
+						'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+						'bigserialnum ∪ bigintnum': allTypesTable.bigintnum.as('bigserialnum ∪ bigintnum'),
+						'bigserialnum ∪ numericnum': allTypesTable.numericnum.as('bigserialnum ∪ numericnum'),
+						'bigintnum ∪ int': allTypesTable.int.as('bigintnum ∪ int'),
+						'bigintnum ∪ smallint': allTypesTable.smallint.as('bigintnum ∪ smallint'),
+						'bigintnum ∪ double': allTypesTable.double.as('bigintnum ∪ double'),
+						'bigintnum ∪ smallserial': allTypesTable.smallserial.as('bigintnum ∪ smallserial'),
+						'bigintnum ∪ serial': allTypesTable.serial.as('bigintnum ∪ serial'),
+						'bigintnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigintnum ∪ bigserialnum'),
+						'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+						'bigintnum ∪ numericnum': allTypesTable.numericnum.as('bigintnum ∪ numericnum'),
+						'numericnum ∪ int': allTypesTable.int.as('numericnum ∪ int'),
+						'numericnum ∪ smallint': allTypesTable.smallint.as('numericnum ∪ smallint'),
+						'numericnum ∪ double': allTypesTable.double.as('numericnum ∪ double'),
+						'numericnum ∪ smallserial': allTypesTable.smallserial.as('numericnum ∪ smallserial'),
+						'numericnum ∪ serial': allTypesTable.serial.as('numericnum ∪ serial'),
+						'numericnum ∪ bigserialnum': allTypesTable.bigserialnum.as('numericnum ∪ bigserialnum'),
+						'numericnum ∪ bigintnum': allTypesTable.bigintnum.as('numericnum ∪ bigintnum'),
+						'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'int ∪ int': 621,
+					'int ∪ smallint': 621,
+					'int ∪ double': 621,
+					'int ∪ real': 621,
+					'int ∪ smallserial': 621,
+					'int ∪ serial': 621,
+					'int ∪ bigserialnum': 621,
+					'int ∪ bigintnum': 621,
+					'int ∪ numericnum': 621,
+					'smallint ∪ int': 10,
+					'smallint ∪ smallint': 10,
+					'smallint ∪ double': 10,
+					'smallint ∪ real': 10,
+					'smallint ∪ smallserial': 10,
+					'smallint ∪ serial': 10,
+					'smallint ∪ bigserialnum': 10,
+					'smallint ∪ bigintnum': 10,
+					'smallint ∪ numericnum': 10,
+					'double ∪ int': 15.35325689124218,
+					'double ∪ smallint': 15.35325689124218,
+					'double ∪ double': 15.35325689124218,
+					'double ∪ real': 15.35325689124218,
+					'double ∪ smallserial': 15.35325689124218,
+					'double ∪ serial': 15.35325689124218,
+					'double ∪ bigserialnum': 15.35325689124218,
+					'double ∪ bigintnum': 15.35325689124218,
+					'double ∪ numericnum': 15.35325689124218,
+					'real ∪ int': 1.048596,
+					'real ∪ smallint': 1.048596,
+					'real ∪ double': 1.0485960245132446,
+					'real ∪ real': 1.048596,
+					'real ∪ smallserial': 1.048596,
+					'real ∪ serial': 1.048596,
+					'smallserial ∪ int': 15,
+					'smallserial ∪ smallint': 15,
+					'smallserial ∪ double': 15,
+					'smallserial ∪ real': 15,
+					'smallserial ∪ smallserial': 15,
+					'smallserial ∪ serial': 15,
+					'smallserial ∪ bigserialnum': 15,
+					'smallserial ∪ bigintnum': 15,
+					'smallserial ∪ numericnum': 15,
+					'serial ∪ int': 1,
+					'serial ∪ smallint': 1,
+					'serial ∪ double': 1,
+					'serial ∪ real': 1,
+					'serial ∪ smallserial': 1,
+					'serial ∪ serial': 1,
+					'serial ∪ bigserialnum': 1,
+					'serial ∪ bigintnum': 1,
+					'serial ∪ numericnum': 1,
+					'bigserialnum ∪ int': 9007199254740991,
+					'bigserialnum ∪ smallint': 9007199254740991,
+					'bigserialnum ∪ double': 9007199254740991,
+					'bigserialnum ∪ smallserial': 9007199254740991,
+					'bigserialnum ∪ serial': 9007199254740991,
+					'bigserialnum ∪ bigserialnum': 9007199254740991,
+					'bigserialnum ∪ bigintnum': 9007199254740991,
+					'bigserialnum ∪ numericnum': 9007199254740991,
+					'bigintnum ∪ int': 9007199254740991,
+					'bigintnum ∪ smallint': 9007199254740991,
+					'bigintnum ∪ double': 9007199254740991,
+					'bigintnum ∪ smallserial': 9007199254740991,
+					'bigintnum ∪ serial': 9007199254740991,
+					'bigintnum ∪ bigserialnum': 9007199254740991,
+					'bigintnum ∪ bigintnum': 9007199254740991,
+					'bigintnum ∪ numericnum': 9007199254740991,
+					'numericnum ∪ int': 9007199254740991,
+					'numericnum ∪ smallint': 9007199254740991,
+					'numericnum ∪ double': 9007199254740991,
+					'numericnum ∪ smallserial': 9007199254740991,
+					'numericnum ∪ serial': 9007199254740991,
+					'numericnum ∪ bigserialnum': 9007199254740991,
+					'numericnum ∪ bigintnum': 9007199254740991,
+					'numericnum ∪ numericnum': 9007199254740991,
+				},
+				{
+					'int ∪ int': 621,
+					'int ∪ smallint': 10,
+					'int ∪ double': 15.35325689124218,
+					'int ∪ real': 1.048596,
+					'int ∪ smallserial': 15,
+					'int ∪ serial': 1,
+					'int ∪ bigserialnum': 9007199254740991,
+					'int ∪ bigintnum': 9007199254740991,
+					'int ∪ numericnum': 9007199254740991,
+					'smallint ∪ int': 621,
+					'smallint ∪ smallint': 10,
+					'smallint ∪ double': 15.35325689124218,
+					'smallint ∪ real': 1.048596,
+					'smallint ∪ smallserial': 15,
+					'smallint ∪ serial': 1,
+					'smallint ∪ bigserialnum': 9007199254740991,
+					'smallint ∪ bigintnum': 9007199254740991,
+					'smallint ∪ numericnum': 9007199254740991,
+					'double ∪ int': 621,
+					'double ∪ smallint': 10,
+					'double ∪ double': 15.35325689124218,
+					'double ∪ real': 1.0485960245132446,
+					'double ∪ smallserial': 15,
+					'double ∪ serial': 1,
+					'double ∪ bigserialnum': 9007199254740991,
+					'double ∪ bigintnum': 9007199254740991,
+					'double ∪ numericnum': 9007199254740991,
+					'real ∪ int': 621,
+					'real ∪ smallint': 10,
+					'real ∪ double': 15.35325689124218,
+					'real ∪ real': 1.048596,
+					'real ∪ smallserial': 15,
+					'real ∪ serial': 1,
+					'smallserial ∪ int': 621,
+					'smallserial ∪ smallint': 10,
+					'smallserial ∪ double': 15.35325689124218,
+					'smallserial ∪ real': 1.048596,
+					'smallserial ∪ smallserial': 15,
+					'smallserial ∪ serial': 1,
+					'smallserial ∪ bigserialnum': 9007199254740991,
+					'smallserial ∪ bigintnum': 9007199254740991,
+					'smallserial ∪ numericnum': 9007199254740991,
+					'serial ∪ int': 621,
+					'serial ∪ smallint': 10,
+					'serial ∪ double': 15.35325689124218,
+					'serial ∪ real': 1.048596,
+					'serial ∪ smallserial': 15,
+					'serial ∪ serial': 1,
+					'serial ∪ bigserialnum': 9007199254740991,
+					'serial ∪ bigintnum': 9007199254740991,
+					'serial ∪ numericnum': 9007199254740991,
+					'bigserialnum ∪ int': 621,
+					'bigserialnum ∪ smallint': 10,
+					'bigserialnum ∪ double': 15.35325689124218,
+					'bigserialnum ∪ smallserial': 15,
+					'bigserialnum ∪ serial': 1,
+					'bigserialnum ∪ bigserialnum': 9007199254740991,
+					'bigserialnum ∪ bigintnum': 9007199254740991,
+					'bigserialnum ∪ numericnum': 9007199254740991,
+					'bigintnum ∪ int': 621,
+					'bigintnum ∪ smallint': 10,
+					'bigintnum ∪ double': 15.35325689124218,
+					'bigintnum ∪ smallserial': 15,
+					'bigintnum ∪ serial': 1,
+					'bigintnum ∪ bigserialnum': 9007199254740991,
+					'bigintnum ∪ bigintnum': 9007199254740991,
+					'bigintnum ∪ numericnum': 9007199254740991,
+					'numericnum ∪ int': 621,
+					'numericnum ∪ smallint': 10,
+					'numericnum ∪ double': 15.35325689124218,
+					'numericnum ∪ smallserial': 15,
+					'numericnum ∪ serial': 1,
+					'numericnum ∪ bigserialnum': 9007199254740991,
+					'numericnum ∪ bigintnum': 9007199254740991,
+					'numericnum ∪ numericnum': 9007199254740991,
+				},
+			]));
+
+			// ---- bigint ----
+			expect(
+				await unionAll(
+					db.select({
+						'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+						'bigint ∪ bigserial': allTypesTable.bigint.as('bigint ∪ bigserial'),
+						'bigint ∪ numericbig': allTypesTable.bigint.as('bigint ∪ numericbig'),
+						'bigserial ∪ bigint': allTypesTable.bigserial.as('bigserial ∪ bigint'),
+						'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+						'bigserial ∪ numericbig': allTypesTable.bigserial.as('bigserial ∪ numericbig'),
+						'numericbig ∪ bigint': allTypesTable.numericbig.as('numericbig ∪ bigint'),
+						'numericbig ∪ bigserial': allTypesTable.numericbig.as('numericbig ∪ bigserial'),
+						'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+					}).from(allTypesTable),
+					db.select({
+						'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+						'bigint ∪ bigserial': allTypesTable.bigserial.as('bigint ∪ bigserial'),
+						'bigint ∪ numericbig': allTypesTable.numericbig.as('bigint ∪ numericbig'),
+						'bigserial ∪ bigint': allTypesTable.bigint.as('bigserial ∪ bigint'),
+						'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+						'bigserial ∪ numericbig': allTypesTable.numericbig.as('bigserial ∪ numericbig'),
+						'numericbig ∪ bigint': allTypesTable.bigint.as('numericbig ∪ bigint'),
+						'numericbig ∪ bigserial': allTypesTable.bigserial.as('numericbig ∪ bigserial'),
+						'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'bigint ∪ bigint': 5044565289845416380n,
+					'bigint ∪ bigserial': 5044565289845416380n,
+					'bigint ∪ numericbig': 5044565289845416380n,
+					'bigserial ∪ bigint': 5044565289845416380n,
+					'bigserial ∪ bigserial': 5044565289845416380n,
+					'bigserial ∪ numericbig': 5044565289845416380n,
+					'numericbig ∪ bigint': 5044565289845416380n,
+					'numericbig ∪ bigserial': 5044565289845416380n,
+					'numericbig ∪ numericbig': 5044565289845416380n,
+				},
+				{
+					'bigint ∪ bigint': 5044565289845416380n,
+					'bigint ∪ bigserial': 5044565289845416380n,
+					'bigint ∪ numericbig': 5044565289845416380n,
+					'bigserial ∪ bigint': 5044565289845416380n,
+					'bigserial ∪ bigserial': 5044565289845416380n,
+					'bigserial ∪ numericbig': 5044565289845416380n,
+					'numericbig ∪ bigint': 5044565289845416380n,
+					'numericbig ∪ bigserial': 5044565289845416380n,
+					'numericbig ∪ numericbig': 5044565289845416380n,
+				},
+			]));
+
+			// ---- text ----
+			expect(
+				await unionAll(
+					db.select({
+						'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+						'varchar ∪ text': allTypesTable.varchar.as('varchar ∪ text'),
+						'text ∪ varchar': allTypesTable.text.as('text ∪ varchar'),
+						'text ∪ text': allTypesTable.text.as('text ∪ text'),
+					}).from(allTypesTable),
+					db.select({
+						'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+						'varchar ∪ text': allTypesTable.text.as('varchar ∪ text'),
+						'text ∪ varchar': allTypesTable.varchar.as('text ∪ varchar'),
+						'text ∪ text': allTypesTable.text.as('text ∪ text'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'varchar ∪ varchar': 'C4-',
+					'varchar ∪ text': 'C4-',
+					'text ∪ varchar': 'TEXT STRING',
+					'text ∪ text': 'TEXT STRING',
+				},
+				{
+					'varchar ∪ varchar': 'C4-',
+					'varchar ∪ text': 'TEXT STRING',
+					'text ∪ varchar': 'C4-',
+					'text ∪ text': 'TEXT STRING',
+				},
+			]));
+
+			// ---- numstr ----
+			expect(
+				await unionAll(
+					db.select({
+						'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+						'bigintstr ∪ numeric': allTypesTable.bigintstr.as('bigintstr ∪ numeric'),
+						'numeric ∪ bigintstr': allTypesTable.numeric.as('numeric ∪ bigintstr'),
+						'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+					}).from(allTypesTable),
+					db.select({
+						'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+						'bigintstr ∪ numeric': allTypesTable.numeric.as('bigintstr ∪ numeric'),
+						'numeric ∪ bigintstr': allTypesTable.bigintstr.as('numeric ∪ bigintstr'),
+						'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'bigintstr ∪ bigintstr': '5044565289845416380',
+					'bigintstr ∪ numeric': '5044565289845416380',
+					'numeric ∪ bigintstr': '5044565289845416380',
+					'numeric ∪ numeric': '5044565289845416380',
+				},
+				{
+					'bigintstr ∪ bigintstr': '5044565289845416380',
+					'bigintstr ∪ numeric': '5044565289845416380',
+					'numeric ∪ bigintstr': '5044565289845416380',
+					'numeric ∪ numeric': '5044565289845416380',
+				},
+			]));
+
+			// ---- date ----
+			expect(
+				await unionAll(
+					db.select({
+						'date ∪ date': allTypesTable.date.as('date ∪ date'),
+						'date ∪ timestamp': allTypesTable.date.as('date ∪ timestamp'),
+						'date ∪ timestampTz': allTypesTable.date.as('date ∪ timestampTz'),
+						'timestamp ∪ date': allTypesTable.timestamp.as('timestamp ∪ date'),
+						'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+						'timestamp ∪ timestampTz': allTypesTable.timestamp.as('timestamp ∪ timestampTz'),
+						'timestampTz ∪ date': allTypesTable.timestampTz.as('timestampTz ∪ date'),
+						'timestampTz ∪ timestamp': allTypesTable.timestampTz.as('timestampTz ∪ timestamp'),
+						'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+					}).from(allTypesTable),
+					db.select({
+						'date ∪ date': allTypesTable.date.as('date ∪ date'),
+						'date ∪ timestamp': allTypesTable.timestamp.as('date ∪ timestamp'),
+						'date ∪ timestampTz': allTypesTable.timestampTz.as('date ∪ timestampTz'),
+						'timestamp ∪ date': allTypesTable.date.as('timestamp ∪ date'),
+						'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+						'timestamp ∪ timestampTz': allTypesTable.timestampTz.as('timestamp ∪ timestampTz'),
+						'timestampTz ∪ date': allTypesTable.date.as('timestampTz ∪ date'),
+						'timestampTz ∪ timestamp': allTypesTable.timestamp.as('timestampTz ∪ timestamp'),
+						'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'date ∪ date': new Date('2025-03-12'),
+					'date ∪ timestamp': new Date('2025-03-12'),
+					'date ∪ timestampTz': new Date('2025-03-12'),
+					'timestamp ∪ date': new Date('2025-03-12 01:32:41.623'),
+					'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+					'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623'),
+					'timestampTz ∪ date': new Date('2025-03-12 01:32:41.623+00'),
+					'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623+00'),
+					'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+				},
+				{
+					'date ∪ date': new Date('2025-03-12'),
+					'date ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+					'date ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+					'timestamp ∪ date': new Date('2025-03-12'),
+					'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+					'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+					'timestampTz ∪ date': new Date('2025-03-12'),
+					'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+					'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+				},
+			]));
+
+			// ---- json ----
+			expect(
+				await unionAll(
+					db.select({
+						'json ∪ json': allTypesTable.json.as('json ∪ json'),
+						'json ∪ json1': allTypesTable.json.as('json ∪ json1'),
+						'json ∪ json2': allTypesTable.json.as('json ∪ json2'),
+						'json ∪ json3': allTypesTable.json.as('json ∪ json3'),
+						'json1 ∪ json': allTypesTable.json1.as('json1 ∪ json'),
+						'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+						'json1 ∪ json2': allTypesTable.json1.as('json1 ∪ json2'),
+						'json1 ∪ json3': allTypesTable.json1.as('json1 ∪ json3'),
+						'json2 ∪ json': allTypesTable.json2.as('json2 ∪ json'),
+						'json2 ∪ json1': allTypesTable.json2.as('json2 ∪ json1'),
+						'json2 ∪ json2': allTypesTable.json2.as('json2 ∪ json2'),
+						'json2 ∪ json3': allTypesTable.json2.as('json2 ∪ json3'),
+						'json3 ∪ json': allTypesTable.json3.as('json3 ∪ json'),
+						'json3 ∪ json1': allTypesTable.json3.as('json3 ∪ json1'),
+						'json3 ∪ json2': allTypesTable.json3.as('json3 ∪ json2'),
+						'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+					}).from(allTypesTable),
+					db.select({
+						'json ∪ json': allTypesTable.json.as('json ∪ json'),
+						'json ∪ json1': allTypesTable.json1.as('json ∪ json1'),
+						'json ∪ json2': allTypesTable.json2.as('json ∪ json2'),
+						'json ∪ json3': allTypesTable.json3.as('json ∪ json3'),
+						'json1 ∪ json': allTypesTable.json.as('json1 ∪ json'),
+						'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+						'json1 ∪ json2': allTypesTable.json2.as('json1 ∪ json2'),
+						'json1 ∪ json3': allTypesTable.json3.as('json1 ∪ json3'),
+						'json2 ∪ json': allTypesTable.json.as('json2 ∪ json'),
+						'json2 ∪ json1': allTypesTable.json1.as('json2 ∪ json1'),
+						'json2 ∪ json2': allTypesTable.json2.as('json2 ∪ json2'),
+						'json2 ∪ json3': allTypesTable.json3.as('json2 ∪ json3'),
+						'json3 ∪ json': allTypesTable.json.as('json3 ∪ json'),
+						'json3 ∪ json1': allTypesTable.json1.as('json3 ∪ json1'),
+						'json3 ∪ json2': allTypesTable.json2.as('json3 ∪ json2'),
+						'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'json ∪ json': { str: 'strval', arr: ['str', 10] },
+					'json ∪ json1': { str: 'strval', arr: ['str', 10] },
+					'json ∪ json2': { str: 'strval', arr: ['str', 10] },
+					'json ∪ json3': { str: 'strval', arr: ['str', 10] },
+					'json1 ∪ json': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json1 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json1 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json2 ∪ json': 5,
+					'json2 ∪ json1': 5,
+					'json2 ∪ json2': 5,
+					'json2 ∪ json3': 5,
+					'json3 ∪ json': '5',
+					'json3 ∪ json1': '5',
+					'json3 ∪ json2': '5',
+					'json3 ∪ json3': '5',
+				},
+				{
+					'json ∪ json': { str: 'strval', arr: ['str', 10] },
+					'json ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json ∪ json2': 5,
+					'json ∪ json3': '5',
+					'json1 ∪ json': { str: 'strval', arr: ['str', 10] },
+					'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json1 ∪ json2': 5,
+					'json1 ∪ json3': '5',
+					'json2 ∪ json': { str: 'strval', arr: ['str', 10] },
+					'json2 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json2 ∪ json2': 5,
+					'json2 ∪ json3': '5',
+					'json3 ∪ json': { str: 'strval', arr: ['str', 10] },
+					'json3 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+					'json3 ∪ json2': 5,
+					'json3 ∪ json3': '5',
+				},
+			]));
+
+			// ---- jsonb ----
+			expect(
+				await unionAll(
+					db.select({
+						'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+						'jsonb ∪ jsonb1': allTypesTable.jsonb.as('jsonb ∪ jsonb1'),
+						'jsonb ∪ jsonb2': allTypesTable.jsonb.as('jsonb ∪ jsonb2'),
+						'jsonb ∪ jsonb3': allTypesTable.jsonb.as('jsonb ∪ jsonb3'),
+						'jsonb1 ∪ jsonb': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb'),
+						'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+						'jsonb1 ∪ jsonb2': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb2'),
+						'jsonb1 ∪ jsonb3': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb3'),
+						'jsonb2 ∪ jsonb': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb'),
+						'jsonb2 ∪ jsonb1': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb1'),
+						'jsonb2 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb2'),
+						'jsonb2 ∪ jsonb3': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb3'),
+						'jsonb3 ∪ jsonb': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb'),
+						'jsonb3 ∪ jsonb1': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb1'),
+						'jsonb3 ∪ jsonb2': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb2'),
+						'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+					}).from(allTypesTable),
+					db.select({
+						'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+						'jsonb ∪ jsonb1': allTypesTable.jsonb1.as('jsonb ∪ jsonb1'),
+						'jsonb ∪ jsonb2': allTypesTable.jsonb2.as('jsonb ∪ jsonb2'),
+						'jsonb ∪ jsonb3': allTypesTable.jsonb3.as('jsonb ∪ jsonb3'),
+						'jsonb1 ∪ jsonb': allTypesTable.jsonb.as('jsonb1 ∪ jsonb'),
+						'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+						'jsonb1 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb1 ∪ jsonb2'),
+						'jsonb1 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb1 ∪ jsonb3'),
+						'jsonb2 ∪ jsonb': allTypesTable.jsonb.as('jsonb2 ∪ jsonb'),
+						'jsonb2 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb2 ∪ jsonb1'),
+						'jsonb2 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb2'),
+						'jsonb2 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb2 ∪ jsonb3'),
+						'jsonb3 ∪ jsonb': allTypesTable.jsonb.as('jsonb3 ∪ jsonb'),
+						'jsonb3 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb3 ∪ jsonb1'),
+						'jsonb3 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb3 ∪ jsonb2'),
+						'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb ∪ jsonb1': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb ∪ jsonb2': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb ∪ jsonb3': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb1 ∪ jsonb': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb1 ∪ jsonb2': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb1 ∪ jsonb3': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb2 ∪ jsonb': 7,
+					'jsonb2 ∪ jsonb1': 7,
+					'jsonb2 ∪ jsonb2': 7,
+					'jsonb2 ∪ jsonb3': 7,
+					'jsonb3 ∪ jsonb': '7',
+					'jsonb3 ∪ jsonb1': '7',
+					'jsonb3 ∪ jsonb2': '7',
+					'jsonb3 ∪ jsonb3': '7',
+				},
+				{
+					'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb ∪ jsonb2': 7,
+					'jsonb ∪ jsonb3': '7',
+					'jsonb1 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb1 ∪ jsonb2': 7,
+					'jsonb1 ∪ jsonb3': '7',
+					'jsonb2 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb2 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb2 ∪ jsonb2': 7,
+					'jsonb2 ∪ jsonb3': '7',
+					'jsonb3 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+					'jsonb3 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+					'jsonb3 ∪ jsonb2': 7,
+					'jsonb3 ∪ jsonb3': '7',
+				},
+			]));
+
+			// ---- self-only ----
+			expect(
+				await unionAll(
+					db.select({
+						'char ∪ char': allTypesTable.char.as('char ∪ char'),
+						'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+						'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+						'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+						'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+						'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+						'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+						'time ∪ time': allTypesTable.time.as('time ∪ time'),
+						'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+						'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+						'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+						'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+						'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+						'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+						'line ∪ line': allTypesTable.line.as('line ∪ line'),
+						'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+						'point ∪ point': allTypesTable.point.as('point ∪ point'),
+						'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+					}).from(allTypesTable),
+					db.select({
+						'char ∪ char': allTypesTable.char.as('char ∪ char'),
+						'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+						'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+						'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+						'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+						'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+						'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+						'time ∪ time': allTypesTable.time.as('time ∪ time'),
+						'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+						'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+						'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+						'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+						'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+						'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+						'line ∪ line': allTypesTable.line.as('line ∪ line'),
+						'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+						'point ∪ point': allTypesTable.point.as('point ∪ point'),
+						'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+					}).from(allTypesTable),
+				),
+			).toEqual(expect.arrayContaining([
+				{
+					'char ∪ char': 'c',
+					'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+					'inet ∪ inet': '192.168.0.1/24',
+					'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+					'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+					'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+					'interval ∪ interval': '-2 mons',
+					'time ∪ time': '13:59:28',
+					'datestr ∪ datestr': '2025-03-12',
+					'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+					'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+					'bool ∪ bool': true,
+					'bytea ∪ bytea': Buffer.from('BYTES'),
+					'enum ∪ enum': 'enVal1',
+					'line ∪ line': { a: 1, b: 2, c: 3 },
+					'linetuple ∪ linetuple': [1, 2, 3],
+					'point ∪ point': { x: 24.5, y: 49.6 },
+					'pointtuple ∪ pointtuple': [24.5, 49.6],
+				},
+				{
+					'char ∪ char': 'c',
+					'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+					'inet ∪ inet': '192.168.0.1/24',
+					'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+					'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+					'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+					'interval ∪ interval': '-2 mons',
+					'time ∪ time': '13:59:28',
+					'datestr ∪ datestr': '2025-03-12',
+					'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+					'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+					'bool ∪ bool': true,
+					'bytea ∪ bytea': Buffer.from('BYTES'),
+					'enum ∪ enum': 'enVal1',
+					'line ∪ line': { a: 1, b: 2, c: 3 },
+					'linetuple ∪ linetuple': [1, 2, 3],
+					'point ∪ point': { x: 24.5, y: 49.6 },
+					'pointtuple ∪ pointtuple': [24.5, 49.6],
+				},
+			]));
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/3018
+		test.concurrent(
+			'select string from jsonb/json column',
+			async ({ db, push }) => {
+				const table = pgTable('table_jsonb', { col1: jsonb(), col2: json() });
+				await push({ table });
+
+				await db.insert(table).values({ col1: '10.5', col2: '10.6' });
+				const res = await db.select().from(table);
+				expect(res).toStrictEqual([{ col1: '10.5', col2: '10.6' }]);
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5227
+		test.concurrent(
+			'select with bigint array in inArray',
+			async ({ db, push }) => {
+				const users = pgTable('users_112', {
+					id: bigint('id', { mode: 'bigint' }).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values([
+					{ id: 1n, name: 'John' },
+					{ id: 2n, name: 'Jane' },
+					{
+						id: 9223372036854775807n,
+						name: 'Jane',
+					},
+				]);
+				const result = await db
+					.select({ name: users.name })
+					.from(users)
+					.where(inArray(users.id, [9223372036854775807n, 2n]));
+				expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }]);
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4950
+		test.concurrent('mySchema :: select with for', async ({ db, push }) => {
+			const mySchema = pgSchema('mySchema');
+			const users = mySchema.table('users_113', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+
+			await db.insert(users).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+			const query = db
+				.select({ name: users.name })
+				.from(users)
+				.for('update', { of: users });
+
+			expect(query.toSQL().sql).toEqual(
+				'select "name" from "mySchema"."users_113" for update of "users_113"',
+			);
+			const result = await query;
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		// test.concurrent('mySchema :: select with for #2', async ({ db, push }) => {
+		// 	const schemaA = pgSchema('schema_a');
+		// 	const schemaB = pgSchema('schema_b');
+		// 	const usersA = schemaA.table('users', {
+		// 		id: integer('id').primaryKey(),
+		// 		name: text('name').notNull(),
+		// 	});
+		// 	const usersB = schemaB.table('users', {
+		// 		id: integer('id').primaryKey(),
+		// 		name: text('name').notNull(),
+		// 	});
+
+		// 	await push({ usersA, usersB, schemaA, schemaB });
+
+		// 	await db.insert(usersA).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+		// 	await db.insert(usersB).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+
+		// 	const query = db
+		// 		.select({ nameA: usersA.name, nameB: usersB.name })
+		// 		.from(usersA)
+		// 		.leftJoin(usersB, eq(usersA.id, usersB.id))
+		// 		.for('update', { of: usersA });
+
+		// 	expect(query.toSQL().sql).toEqual(
+		// 		'select "schema_a"."users"."name", "schema_b"."users"."name" from "schema_a"."users" left join "schema_b"."users" on "schema_a"."users"."id" = "schema_b"."users"."id" for update of "users"',
+		// 	);
+		// 	const result = await query;
+		// 	expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		// });
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5253
+		// enhancement
+		// allow select which columns to insert in insert...select
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent('insert into ... select #2', async ({ db, push }) => {
+			const users = pgTable('users_114', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+				role: text().notNull(),
+			});
+			const employees = pgTable('employees_114', {
+				id: integer('id').primaryKey().generatedByDefaultAsIdentity(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users, employees });
+
+			await db.insert(users).values([
+				{ id: 1, name: 'John', role: 'employee' },
+				{
+					id: 2,
+					name: 'Jane',
+					role: 'admin',
+				},
+			]);
+
+			await db
+				.insert(employees)
+				.select(
+					db
+						.select({ name: users.name })
+						.from(users)
+						.where(eq(users.role, 'employee')),
+				)
+				.returning({
+					id: employees.id,
+					name: employees.name,
+				});
+
+			const employeesList = await db.select().from(employees);
+			expect(employeesList).toStrictEqual([{ id: 1, name: 'John' }]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4612
+		test('select with inline params in sql', async ({ db }) => {
+			const users = pgTable('users_115', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const query = db
+				.select({ sum: sql`sum(${3})`.inlineParams() })
+				.from(users);
+
+			expect(query.toSQL()).toStrictEqual({
+				sql: 'select sum(3) from "users_115"',
+				params: [],
+			});
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4578
+		test('arrayContains', async ({ db, push }) => {
+			const myTable = pgTable('my_table', {
+				id: integer().primaryKey(),
+				movieId: integer(),
+				tag: text(),
+			});
+
+			await push({ myTable });
+			await db.insert(myTable).values([
+				{ id: 1, movieId: 1, tag: 'abc' },
+				{ id: 2, movieId: 1, tag: 'def' },
+			]);
+
+			const subquery = db
+				.select({
+					tags_array: sql<string[] | null>`array_agg(${myTable.tag})`.as(
+						'selectedIds',
+					),
+				})
+				.from(myTable)
+				.groupBy(myTable.movieId)
+				.as('subquery');
+
+			const result = await db
+				.select()
+				.from(subquery)
+				.where(arrayContains(subquery.tags_array, ['abc', 'def']));
+
+			expect(result).toStrictEqual([{ tags_array: ['abc', 'def'] }]);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4596
+		test.skipIf(Date.now() < +new Date('2026-07-01'))(
+			'functional index; onConflict do update',
+			async ({ db, push }) => {
+				throw new Error('SKIP. commented below because of type error');
+				// const lower = (email: AnyPgColumn): SQL => {
+				// 	return sql`lower(${email})`;
+				// };
+				// const users = pgTable('users_116', {
+				// 	id: integer().primaryKey(),
+				// 	name: varchar(),
+				// 	email: text().notNull(),
+				// 	deletedAt: timestamp(),
+				// }, (table) => [
+				// 	uniqueIndex('email_idx').on(lower(table.email)).where(isNull(table.deletedAt)),
+				// ]);
+
+				// await push({ users });
+
+				// await db.insert(users).values([{ id: 1, email: 'a', name: 'aName' }])
+				// 	.onConflictDoUpdate({
+				// 		target: lower(users.email),
+				// 		targetWhere: isNull(users.deletedAt),
+				// 		set: { name: sql`excluded.name` },
+				// 	});
+
+				// await db.insert(users).values([{ id: 2, email: 'A', name: 'bName' }])
+				// 	.onConflictDoUpdate({
+				// 		target: lower(users.email),
+				// 		targetWhere: isNull(users.deletedAt),
+				// 		set: { name: sql`excluded.name` },
+				// 	});
+
+				// const result = await db.select({ name: users.name }).from(users);
+				// expect(result).toStrictEqual([{ name: 'bName' }]);
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5282
+		test('casing in sql``', async ({ db, push }) => {
+			const payments = snakeCase.table('payments', {
+				id: integer().primaryKey(),
+				amount: numeric(),
+				completedAt: timestamp(),
+			});
+			const schema = { payments };
+			await push(schema);
+			db.insert(payments).values({
+				id: 1,
+				amount: '10.12',
+				completedAt: new Date(),
+			});
+
+			const query = db
+				.insert(payments)
+				.values({ id: 1, amount: '12.14', completedAt: new Date() })
+				.onConflictDoUpdate({
+					target: [payments.id],
+					set: {
+						completedAt: sql`excluded.${sql.identifier(payments.completedAt.name)}`,
+						amount: sql`excluded.${sql.identifier(payments.amount.name)}`,
+					},
+				});
+
+			expect(query.toSQL().sql).toEqual(
+				'insert into "payments" ("id", "amount", "completed_at") values ($1, $2, $3) on conflict ("id") do update set "amount" = excluded."amount", "completed_at" = excluded."completed_at"',
+			);
+			await query;
+
+			const result = await db
+				.select({ amount: payments.amount })
+				.from(payments)
+				.where(eq(payments.id, 1));
+
+			expect(result).toStrictEqual([{ amount: '12.14' }]);
+		});
+
+		test.concurrent('sql.identifier escape', async () => {
+			const dialect = new PgDialect();
+			const userInput = 'id" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+			const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+			const str = dialect.sqlToQuery(query);
+			expect(str.sql).toBe(
+				'SELECT * FROM "users" ORDER BY "id"" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--" ASC',
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4419
+		test.skipIf(Date.now() < +new Date('2026-07-01'))('db/js timestamp comparison', async ({ db, push }) => {
+			const table1 = pgTable('table1', {
+				id: integer(),
+				// default config equal to: { mode: 'date' }
+				// config to make it work: { mode: 'date', precision: 3 }
+				rowCreatedAt: timestamp('row_created_at').notNull().defaultNow(),
+			});
+
+			await push({ table1 });
+
+			await db.insert(table1).values({ id: 1 });
+			const result1 = await db.select().from(table1);
+			const rowCreatedAt = result1[0]!.rowCreatedAt;
+
+			const result2 = await db
+				.select({ id: table1.id })
+				.from(table1)
+				.where(eq(table1.rowCreatedAt, rowCreatedAt));
+			expect(result2).toStrictEqual([{ id: 1 }]);
+		});
+
+		test.concurrent('comments', async ({ createDB, push }) => {
+			const ctbl = pgTable('comments_test', (t) => ({
+				id: t.integer('id').primaryKey(),
+				name: t.text('name').notNull(),
+			}));
+
+			await push({ ctbl });
+			const db = createDB({ ctbl });
+
+			const insertQ = db
+				.insert(ctbl)
+				.values([
+					{
+						id: 1,
+						name: 'First',
+					},
+					{
+						id: 2,
+						name: 'Second',
+					},
+				])
+				.comment({ insert: '*/ comment /*', '/* n': 1 });
+
+			expect(insertQ.toSQL().sql).toStrictEqual(
+				`insert into "comments_test" ("id", "name") values ($1, $2), ($3, $4) /*%2F*%20n='1',insert='*%2F%20comment%20%2F*'*/`,
+			);
+
+			const deleteQ = db
+				.delete(ctbl)
+				.where(eq(ctbl.id, 2))
+				.comment({ "del ' ete": '*/ comment /*' });
+			expect(deleteQ.toSQL().sql).toStrictEqual(
+				`delete from "comments_test" where "comments_test"."id" = $1 /*del%20\\'%20ete='*%2F%20comment%20%2F*'*/`,
+			);
+
+			const updateQ = db
+				.update(ctbl)
+				.set({ name: 'Updated' })
+				.where(eq(ctbl.id, 1))
+				.comment({
+					update: 'here /**',
+				});
+			expect(updateQ.toSQL().sql).toStrictEqual(
+				`update "comments_test" set "name" = $1 where "comments_test"."id" = $2 /*update='here%20%2F**'*/`,
+			);
+
+			const selectQ = db
+				.select()
+				.from(ctbl)
+				.comment({ select: 'co\'m"m`/* ent*/ "' });
+			expect(selectQ.toSQL().sql).toStrictEqual(
+				`select "id", "name" from "comments_test" /*select='co\\'m%22m%60%2F*%20ent*%2F%20%22'*/`,
+			);
+
+			const rqbQ = db.query.ctbl.findFirst({
+				columns: {
+					id: true,
+				},
+				comment: {
+					fieldOne: '_valueOne',
+					_fieldTwo: 'value two',
+				},
+			});
+			expect(rqbQ.toSQL().sql).toStrictEqual(
+				`select "d0"."id" as "id" from "comments_test" as "d0" limit $1 /*_fieldTwo='value%20two',fieldOne='_valueOne'*/`,
+			);
+
+			const selectQPrepared = db
+				.select()
+				.from(ctbl)
+				.comment({
+					select: `com'ment`,
+				})
+				.prepare();
+			expect(selectQPrepared.getQuery().sql).toStrictEqual(
+				`select "id", "name" from "comments_test" /*select='com\\'ment'*/`,
+			);
+
+			await insertQ;
+			await updateQ;
+			await deleteQ;
+
+			const [res1, res2, res3] = [
+				await selectQ,
+				await rqbQ,
+				await selectQPrepared.execute(),
+			];
+
+			expectTypeOf(res2).toEqualTypeOf<
+				| {
+					id: number;
+				}
+				| undefined
+			>();
+
+			expect(res1).toStrictEqual([{ id: 1, name: 'Updated' }]);
+			expect(res2).toStrictEqual({ id: 1 });
+			expect(res3).toStrictEqual([{ id: 1, name: 'Updated' }]);
+		});
+
+		test.concurrent('Mappers: correct mappers enabled', async ({ createDB, db }) => {
+			const dialect: PgDialect = (<any> db).dialect;
+			const jitDialect: PgDialect = (<any> createDB({}, () => ({}), true)).dialect;
+
+			expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+			expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+			expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+			expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+		});
+
+		const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+		test.concurrent('Mappers: simple select - no rows', async ({ db, push }) => {
+			const users = pgTable('mappers_users_1', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+
+			const result = await db.select().from(users);
+
+			expect(result).toStrictEqual([]);
+		});
+
+		test.concurrent('Mappers: select - nothing to decode - text', async ({ db, push }) => {
+			const users = pgTable('mappers_users_2', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select({ name: users.name }).from(users);
+
+			expect(selected).toStrictEqual([{ name: 'First' }]);
+		});
+
+		test.concurrent('Mappers: select - nothing to decode - null', async ({ db, push }) => {
+			const users = pgTable('mappers_users_3', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+			expect(selected).toStrictEqual([{ isBanned: null }]);
+		});
+
+		test.concurrent('Mappers: insert returning all + select + update returning + delete returning', async ({ db, push }) => {
+			const users = pgTable('mappers_users_4', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+
+			const inserted = await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select().from(users);
+
+			const updated = await db.update(users).set({
+				isBanned: false,
+			}).where(eq(users.id, 2)).returning();
+
+			const deleted = await db.delete(users).returning();
+
+			expect(inserted).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(selected).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(updated).toStrictEqual([{
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}]);
+			expect(deleted).toStrictEqual(expect.arrayContaining([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]));
+		});
+
+		test.concurrent('Mappers: select complex selections', async ({ db, push }) => {
+			const users = pgTable('mappers_users_5', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			const posts = pgTable('mappers_posts_1', (t) => ({
+				id: t.integer('id').primaryKey(),
+				authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+				content: t.text('content'),
+			}));
+
+			const internalStaff = pgTable('internal_staff_qm1', {
+				userId: integer('user_id').notNull().primaryKey(),
+			});
+
+			const ticket = pgTable('ticket_qm1', {
+				staffId: integer('staff_id').notNull(),
+			});
+
+			await push({ users, posts, internalStaff, ticket });
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+			await db.insert(posts).values({
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			});
+			await db.insert(internalStaff).values([{
+				userId: 1,
+			}, {
+				userId: 2,
+			}]);
+			await db.insert(ticket).values([{ staffId: 1 }, { staffId: 2 }]);
+
+			const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected3 = await db.select({
+				userId: users.id,
+				postId: posts.id,
+				name: users.name,
+				isBanned: users.isBanned,
+				content: posts.content,
+				createdAt: users.createdAt,
+			}).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected4 = await db.select({
+				userId: users.id,
+				postId: posts.id,
+				name: users.name,
+				isBanned: users.isBanned,
+				content: posts.content,
+				createdAt: users.createdAt,
+			}).from(users).innerJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected5 = await db.select({
+				user: {
+					...getTableColumns(users),
+					extra: sql`1`.mapWith(Number).as('extra_1'),
+				},
+				post: {
+					...getTableColumns(posts),
+					extra: sql`1`.mapWith(Number).as('extra_1'),
+				},
+			}).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const subq = db
+				.select()
+				.from(internalStaff)
+				.leftJoin(users, eq(internalStaff.userId, users.id))
+				.as('internal_staff');
+			const selected6 = await db
+				.select()
+				.from(ticket)
+				.leftJoin(subq, eq(subq.internal_staff_qm1.userId, ticket.staffId));
+
+			expect(selected1).toStrictEqual([{
+				user: {
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: {
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				},
+			}, {
+				user: {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				},
+				post: null,
+			}, {
+				user: {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: null,
+			}]);
+			expect(selected2).toStrictEqual([{
+				user: {
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: {
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				},
+			}]);
+			expect(selected3).toStrictEqual([
+				{
+					content: 'p1',
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'First',
+					postId: 1,
+					userId: 1,
+				},
+				{
+					content: null,
+					createdAt: mappersDate,
+					isBanned: true,
+					name: 'Second',
+					postId: null,
+					userId: 2,
+				},
+				{
+					content: null,
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'Third',
+					postId: null,
+					userId: 3,
+				},
+			]);
+			expect(selected4).toStrictEqual([
+				{
+					content: 'p1',
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'First',
+					postId: 1,
+					userId: 1,
+				},
+			]);
+			expect(selected5).toStrictEqual([
+				{
+					post: {
+						authorId: 1,
+						content: 'p1',
+						extra: 1,
+						id: 1,
+					},
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				},
+				{
+					post: null,
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+				},
+				{
+					post: null,
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				},
+			]);
+			expect(selected6).toStrictEqual(
+				[
+					{
+						internal_staff: {
+							internal_staff_qm1: {
+								userId: 1,
+							},
+							mappers_users_5: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+							},
+						},
+						ticket_qm1: {
+							staffId: 1,
+						},
+					},
+					{
+						internal_staff: {
+							internal_staff_qm1: {
+								userId: 2,
+							},
+							mappers_users_5: {
+								createdAt: mappersDate,
+								id: 2,
+								isBanned: true,
+								name: 'Second',
+							},
+						},
+						ticket_qm1: {
+							staffId: 2,
+						},
+					},
+				],
+			);
+		});
+
+		test.concurrent('Mappers: relational', async ({ createDB, push }) => {
+			const users = pgTable('mappers_users_6', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			const posts = pgTable('mappers_posts_2', (t) => ({
+				id: t.integer('id').primaryKey(),
+				authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+				content: t.text('content'),
+			}));
+
+			await push({ users, posts });
+			const db = createDB(
+				{ users, posts },
+				(r) => ({
+					users: {
+						post: r.one.posts({
+							from: r.users.id,
+							to: r.posts.authorId,
+						}),
+						posts: r.one.posts({
+							from: r.users.id,
+							to: r.posts.authorId,
+						}),
+					},
+					posts: {
+						author: r.one.users({
+							from: r.posts.authorId,
+							to: r.users.id,
+						}),
+						authors: r.many.users({
+							from: r.posts.authorId,
+							to: r.users.id,
+						}),
+					},
+				}),
+				false,
+			);
+
+			const empty1 = await db.query.users.findFirst();
+			const empty2 = await db.query.users.findMany();
+
+			expect(empty1).toStrictEqual(undefined);
+			expect(empty2).toStrictEqual([]);
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+			await db.insert(posts).values({
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			});
+
+			const simple1 = await db.query.users.findFirst();
+			const simple2 = await db.query.users.findMany();
+
+			expect(simple1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+				},
+			);
+			expect(simple2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+				},
+			]);
+
+			const extra1 = await db.query.users.findFirst({
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+			const extra2 = await db.query.users.findMany({
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+
+			expect(extra1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			);
+			expect(extra2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			]);
+
+			const nested1 = await db.query.users.findFirst({
+				with: {
+					post: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					posts: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+			const nested2 = await db.query.users.findMany({
+				with: {
+					post: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					posts: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+
+			expect(nested1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					post: {
+						author: null,
+						authorId: 1,
+						authors: [],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					posts: {
+						author: {
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						authorId: 1,
+						authors: [
+							{
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+						],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			);
+			expect(nested2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					post: {
+						author: null,
+						authorId: 1,
+						authors: [],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					posts: {
+						author: {
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						authorId: 1,
+						authors: [
+							{
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+						],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+					post: null,
+					posts: null,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+					post: null,
+					posts: null,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			]);
+		});
+
+		test.concurrent('Jit mappers: simple select - no rows', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_1', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+			const db = createDB({}, () => ({}), true);
+
+			const result = await db.select().from(users);
+
+			expect(result).toStrictEqual([]);
+		});
+
+		test.concurrent('Jit mappers: select - nothing to decode - text', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_2', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+			const db = createDB({}, () => ({}), true);
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select({ name: users.name }).from(users);
+
+			expect(selected).toStrictEqual([{ name: 'First' }]);
+		});
+
+		test.concurrent('Jit mappers: select - nothing to decode - null', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_3', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+			const db = createDB({}, () => ({}), true);
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+			expect(selected).toStrictEqual([{ isBanned: null }]);
+		});
+
+		test.concurrent('Jit mappers: insert returning all + select + update returning + delete returning', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_4', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			await push({ users });
+			const db = createDB({}, () => ({}), true);
+
+			const inserted = await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select().from(users);
+
+			const updated = await db.update(users).set({
+				isBanned: false,
+			}).where(eq(users.id, 2)).returning();
+
+			const deleted = await db.delete(users).returning();
+
+			expect(inserted).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(selected).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(updated).toStrictEqual([{
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}]);
+			expect(deleted).toStrictEqual(expect.arrayContaining([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]));
+		});
+
+		test.concurrent('Jit mappers: select complex selections', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_5', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			const posts = pgTable('jit_mappers_posts_1', (t) => ({
+				id: t.integer('id').primaryKey(),
+				authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+				content: t.text('content'),
+			}));
+
+			const internalStaff = pgTable('internal_staff_jqm1', {
+				userId: integer('user_id').notNull().primaryKey(),
+			});
+
+			const ticket = pgTable('ticket_jqm1', {
+				staffId: integer('staff_id').notNull(),
+			});
+
+			await push({ users, posts, internalStaff, ticket });
+			const db = createDB({}, () => ({}), true);
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+			await db.insert(posts).values({
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			});
+			await db.insert(internalStaff).values([{
+				userId: 1,
+			}, {
+				userId: 2,
+			}]);
+			await db.insert(ticket).values([{ staffId: 1 }, { staffId: 2 }]);
+
+			const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected3 = await db.select({
+				userId: users.id,
+				postId: posts.id,
+				name: users.name,
+				isBanned: users.isBanned,
+				content: posts.content,
+				createdAt: users.createdAt,
+			}).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected4 = await db.select({
+				userId: users.id,
+				postId: posts.id,
+				name: users.name,
+				isBanned: users.isBanned,
+				content: posts.content,
+				createdAt: users.createdAt,
+			}).from(users).innerJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const selected5 = await db.select({
+				user: {
+					...getTableColumns(users),
+					extra: sql`1`.mapWith(Number).as('extra_1'),
+				},
+				post: {
+					...getTableColumns(posts),
+					extra: sql`1`.mapWith(Number).as('extra_1'),
+				},
+			}).from(users).leftJoin(
+				posts,
+				eq(users.id, posts.authorId),
+			);
+			const subq = db
+				.select()
+				.from(internalStaff)
+				.leftJoin(users, eq(internalStaff.userId, users.id))
+				.as('internal_staff');
+			const selected6 = await db
+				.select()
+				.from(ticket)
+				.leftJoin(subq, eq(subq.internal_staff_jqm1.userId, ticket.staffId));
+
+			expect(selected1).toStrictEqual([{
+				user: {
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: {
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				},
+			}, {
+				user: {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				},
+				post: null,
+			}, {
+				user: {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: null,
+			}]);
+			expect(selected2).toStrictEqual([{
+				user: {
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				},
+				post: {
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				},
+			}]);
+			expect(selected3).toStrictEqual([
+				{
+					content: 'p1',
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'First',
+					postId: 1,
+					userId: 1,
+				},
+				{
+					content: null,
+					createdAt: mappersDate,
+					isBanned: true,
+					name: 'Second',
+					postId: null,
+					userId: 2,
+				},
+				{
+					content: null,
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'Third',
+					postId: null,
+					userId: 3,
+				},
+			]);
+			expect(selected4).toStrictEqual([
+				{
+					content: 'p1',
+					createdAt: mappersDate,
+					isBanned: null,
+					name: 'First',
+					postId: 1,
+					userId: 1,
+				},
+			]);
+			expect(selected5).toStrictEqual([
+				{
+					post: {
+						authorId: 1,
+						content: 'p1',
+						extra: 1,
+						id: 1,
+					},
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				},
+				{
+					post: null,
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+				},
+				{
+					post: null,
+					user: {
+						createdAt: mappersDate,
+						extra: 1,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				},
+			]);
+			expect(selected6).toStrictEqual(
+				[
+					{
+						internal_staff: {
+							internal_staff_jqm1: {
+								userId: 1,
+							},
+							jit_mappers_users_5: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+							},
+						},
+						ticket_jqm1: {
+							staffId: 1,
+						},
+					},
+					{
+						internal_staff: {
+							internal_staff_jqm1: {
+								userId: 2,
+							},
+							jit_mappers_users_5: {
+								createdAt: mappersDate,
+								id: 2,
+								isBanned: true,
+								name: 'Second',
+							},
+						},
+						ticket_jqm1: {
+							staffId: 2,
+						},
+					},
+				],
+			);
+		});
+
+		test.concurrent('Jit mappers: relational', async ({ createDB, push }) => {
+			const users = pgTable('jit_mappers_users_6', (t) => ({
+				id: t.bigint('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.timestamp('created_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+				isBanned: t.boolean('is_banned'),
+			}));
+
+			const posts = pgTable('jit_mappers_posts_2', (t) => ({
+				id: t.integer('id').primaryKey(),
+				authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+				content: t.text('content'),
+			}));
+
+			await push({ users, posts });
+			const db = createDB(
+				{ users, posts },
+				(r) => ({
+					users: {
+						post: r.one.posts({
+							from: r.users.id,
+							to: r.posts.authorId,
+						}),
+						posts: r.one.posts({
+							from: r.users.id,
+							to: r.posts.authorId,
+						}),
+					},
+					posts: {
+						author: r.one.users({
+							from: r.posts.authorId,
+							to: r.users.id,
+						}),
+						authors: r.many.users({
+							from: r.posts.authorId,
+							to: r.users.id,
+						}),
+					},
+				}),
+				true,
+			);
+
+			const empty1 = await db.query.users.findFirst();
+			const empty2 = await db.query.users.findMany();
+
+			expect(empty1).toStrictEqual(undefined);
+			expect(empty2).toStrictEqual([]);
+
+			await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+			await db.insert(posts).values({
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			});
+
+			const simple1 = await db.query.users.findFirst();
+			const simple2 = await db.query.users.findMany();
+
+			expect(simple1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+				},
+			);
+			expect(simple2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+				},
+			]);
+
+			const extra1 = await db.query.users.findFirst({
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+			const extra2 = await db.query.users.findMany({
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+
+			expect(extra1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			);
+			expect(extra2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			]);
+
+			const nested1 = await db.query.users.findFirst({
+				with: {
+					post: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					posts: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+			const nested2 = await db.query.users.findMany({
+				with: {
+					post: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+								where: {
+									RAW: sql`false`,
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+					posts: {
+						with: {
+							author: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+							authors: {
+								extras: {
+									sql: sql`SELECT 1`.mapWith(Number),
+									sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+								},
+							},
+						},
+						extras: {
+							sql: sql`SELECT 1`.mapWith(Number),
+							sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+						},
+					},
+				},
+				extras: {
+					sql: sql`SELECT 1`.mapWith(Number),
+					sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+				},
+			});
+
+			expect(nested1).toStrictEqual(
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					post: {
+						author: null,
+						authorId: 1,
+						authors: [],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					posts: {
+						author: {
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						authorId: 1,
+						authors: [
+							{
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+						],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			);
+			expect(nested2).toStrictEqual([
+				{
+					createdAt: mappersDate,
+					id: 1,
+					isBanned: null,
+					name: 'First',
+					post: {
+						author: null,
+						authorId: 1,
+						authors: [],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					posts: {
+						author: {
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						authorId: 1,
+						authors: [
+							{
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+						],
+						content: 'p1',
+						id: 1,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 2,
+					isBanned: true,
+					name: 'Second',
+					post: null,
+					posts: null,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				{
+					createdAt: mappersDate,
+					id: 3,
+					isBanned: null,
+					name: 'Third',
+					post: null,
+					posts: null,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+			]);
+		});
+
+		test.concurrent('Query error wrapping', async ({ db, push }) => {
+			const table = pgTable('users_error_wrap', (t) => ({
+				id: t.integer().primaryKey(),
+				name: t.text().notNull(),
+			}));
+
+			await push({ table });
+			await expect(db.insert(table).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]))
+				.rejects.toBeInstanceOf(DrizzleQueryError);
+		});
+
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'Mappers: deep nullification',
+			async ({ db, push }) => {
+				const users = pgTable('mappers_users_dn', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const internalStaff = pgTable('internal_staff_qm_dn', {
+					userId: integer('user_id').notNull().primaryKey(),
+				});
+
+				const ticket = pgTable('ticket_qm_dn', {
+					staffId: integer('staff_id').notNull(),
+				});
+
+				await push({ users, internalStaff, ticket });
+
+				await db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				await db.insert(internalStaff).values([{
+					userId: 1,
+				}, {
+					userId: 2,
+				}]);
+				await db.insert(ticket).values([{ staffId: 1 }, { staffId: 2 }, { staffId: 3 }]);
+
+				const subq = db
+					.select()
+					.from(internalStaff)
+					.leftJoin(users, eq(internalStaff.userId, users.id))
+					.as('internal_staff');
+				const selected = await db
+					.select()
+					.from(ticket)
+					.leftJoin(subq, eq(subq.internal_staff_qm_dn.userId, ticket.staffId));
+
+				expect(selected).toStrictEqual(
+					[
+						{
+							internal_staff: {
+								internal_staff_qm_dn: {
+									userId: 1,
+								},
+								mappers_users_dn: {
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+								},
+							},
+							ticket_qm_dn: {
+								staffId: 1,
+							},
+						},
+						{
+							internal_staff: {
+								internal_staff_qm_dn: {
+									userId: 2,
+								},
+								mappers_users_dn: {
+									createdAt: mappersDate,
+									id: 2,
+									isBanned: true,
+									name: 'Second',
+								},
+							},
+							ticket_qm_dn: {
+								staffId: 2,
+							},
+						},
+						{
+							internal_staff: null,
+							ticket_qm_dn: {
+								staffid: 3,
+							},
+						},
+					],
+				);
+			},
+		);
+
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'Jit mappers: deep nullification',
+			async ({ createDB, push }) => {
+				const users = pgTable('mappers_users_jdn', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const internalStaff = pgTable('internal_staff_qm_jdn', {
+					userId: integer('user_id').notNull().primaryKey(),
+				});
+
+				const ticket = pgTable('ticket_qm_jdn', {
+					staffId: integer('staff_id').notNull(),
+				});
+
+				await push({ users, internalStaff, ticket });
+				const db = createDB({}, () => ({}), true);
+
+				await db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				await db.insert(internalStaff).values([{
+					userId: 1,
+				}, {
+					userId: 2,
+				}]);
+				await db.insert(ticket).values([{ staffId: 1 }, { staffId: 2 }, { staffId: 3 }]);
+
+				const subq = db
+					.select()
+					.from(internalStaff)
+					.leftJoin(users, eq(internalStaff.userId, users.id))
+					.as('internal_staff');
+				const selected = await db
+					.select()
+					.from(ticket)
+					.leftJoin(subq, eq(subq.internal_staff_qm_jdn.userId, ticket.staffId));
+
+				expect(selected).toStrictEqual(
+					[
+						{
+							internal_staff: {
+								internal_staff_qm_jdn: {
+									userId: 1,
+								},
+								mappers_users_jdn: {
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+								},
+							},
+							ticket_qm_jdn: {
+								staffId: 1,
+							},
+						},
+						{
+							internal_staff: {
+								internal_staff_qm_jdn: {
+									userId: 2,
+								},
+								mappers_users_jdn: {
+									createdAt: mappersDate,
+									id: 2,
+									isBanned: true,
+									name: 'Second',
+								},
+							},
+							ticket_qm_jdn: {
+								staffId: 2,
+							},
+						},
+						{
+							internal_staff: null,
+							ticket_qm_jdn: {
+								staffid: 3,
+							},
+						},
+					],
+				);
+			},
+		);
+
+		test.concurrent('Column as decoder applies codecs', async ({ createDB, push }) => {
+			let customCast = false;
+			let customMap = false;
+
+			const codecBypass = customType<{
+				data: Date;
+				driverData: string;
+				jsonData: string;
+			}>({
+				codec: 'timestamptz',
+				dataType: () => 'timestamptz(3)',
+				forJsonSelect: (identifier, sql, arrayDimensions) => {
+					customCast = true;
+					return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+				},
+				fromJson: (v) => {
+					customMap = true;
+					return new Date(v);
+				},
+				toDriver: (v) => v.toISOString(),
+			});
+
+			const users = pgTable('users_823', (t) => ({
+				id: t.integer().primaryKey(),
+				name: t.text().notNull(),
+				createdAt: t.timestamp('created_at').notNull(),
+				createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+				arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+				arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+				cus: codecBypass('custom').notNull(),
+				arrCus: codecBypass('arr_custom').notNull().array(),
+			}));
+
+			const usersView = pgView('users_823_v').as((qb) =>
+				qb.select({
+					...getColumns(users),
+					max: max(users.createdAt).as('max'),
+					maxStr: max(users.createdAtStr).as('max_str'),
+					arrMax: max(users.arrCreatedAt).as('arr_max'),
+					arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+					sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+				}).from(users).groupBy(users.id)
+			);
+
+			await push({ users, usersView });
+
+			const db = createDB({ users, usersView }, (r) => ({
+				users: {
+					self: r.one.users({
+						from: r.users.id,
+						to: r.users.id,
+					}),
+				},
+				usersView: {
+					self: r.one.usersView({
+						from: r.usersView.id,
+						to: r.usersView.id,
+					}),
+				},
+			}));
+
+			const exDateStr = '1970-01-16 16:45:46.351';
+			const exDate = new Date(exDateStr);
+
+			await db.insert(users).values({
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			});
+
+			const res = await db.select({
+				...getColumns(users),
+				max: max(users.createdAt).as('max'),
+				maxStr: max(users.createdAtStr).as('max_str'),
+				arrMax: max(users.arrCreatedAt).as('arr_max'),
+				arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+				sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+			}).from(users).groupBy(users.id);
+
+			const viewRes = await db.select().from(usersView);
+
+			const nested = await db.query.users.findFirst({
+				with: {
+					self: {
+						extras: {
+							max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+							maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+							arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+							arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+						},
+					},
+				},
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+					arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+				},
+			});
+
+			const viewNested = await db.query.usersView.findFirst({
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+				with: {
+					self: {
+						columns: {
+							sq: false, // TODO: re-enable when supported in RQBv2
+						},
+					},
+				},
+			});
+
+			expect(res).toStrictEqual([
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					sq: exDate,
+					cus: exDate,
+					arrCus: [exDate],
+				},
+			]);
+			expect(viewRes).toStrictEqual([
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					sq: exDate,
+					cus: exDate,
+					arrCus: [exDate],
+				},
+			]);
+
+			expect(customCast).toBeTruthy();
+			expect(customMap).toBeTruthy();
+
+			expect(nested).toStrictEqual(
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+					self: {
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				},
+			);
+			expect(viewNested).toStrictEqual(
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+					self: {
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				},
+			);
+		});
+
+		test.concurrent('Column as decoder applies codecs - Jit mappers', async ({ createDB, push }) => {
+			let customCast = false;
+			let customMap = false;
+
+			const codecBypass = customType<{
+				data: Date;
+				driverData: string;
+				jsonData: string;
+			}>({
+				codec: 'timestamptz',
+				dataType: () => 'timestamptz(3)',
+				forJsonSelect: (identifier, sql, arrayDimensions) => {
+					customCast = true;
+					return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+				},
+				fromJson: (v) => {
+					customMap = true;
+					return new Date(v);
+				},
+				toDriver: (v) => v.toISOString(),
+			});
+
+			const users = pgTable('users_823_jit', (t) => ({
+				id: t.integer().primaryKey(),
+				name: t.text().notNull(),
+				createdAt: t.timestamp('created_at').notNull(),
+				createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+				arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+				arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+				cus: codecBypass('custom').notNull(),
+				arrCus: codecBypass('arr_custom').notNull().array(),
+			}));
+
+			const usersView = pgView('users_823_v_jit').as((qb) =>
+				qb.select({
+					...getColumns(users),
+					max: max(users.createdAt).as('max'),
+					maxStr: max(users.createdAtStr).as('max_str'),
+					arrMax: max(users.arrCreatedAt).as('arr_max'),
+					arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+					sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+				}).from(users).groupBy(users.id)
+			);
+
+			await push({ users, usersView });
+
+			const db = createDB({ users, usersView }, (r) => ({
+				users: {
+					self: r.one.users({
+						from: r.users.id,
+						to: r.users.id,
+					}),
+				},
+				usersView: {
+					self: r.one.usersView({
+						from: r.usersView.id,
+						to: r.usersView.id,
+					}),
+				},
+			}), true);
+
+			const exDateStr = '1970-01-16 16:45:46.351';
+			const exDate = new Date(exDateStr);
+
+			await db.insert(users).values({
+				id: 1,
+				name: 'First',
+				createdAt: exDate,
+				createdAtStr: exDateStr,
+				arrCreatedAt: [exDate],
+				arrCreatedAtStr: [exDateStr],
+				cus: exDate,
+				arrCus: [exDate],
+			});
+
+			const res = await db.select({
+				...getColumns(users),
+				max: max(users.createdAt).as('max'),
+				maxStr: max(users.createdAtStr).as('max_str'),
+				arrMax: max(users.arrCreatedAt).as('arr_max'),
+				arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+				sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+			}).from(users).groupBy(users.id);
+
+			const viewRes = await db.select().from(usersView);
+
+			const nested = await db.query.users.findFirst({
+				with: {
+					self: {
+						extras: {
+							max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+							maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+							arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+							arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+						},
+					},
+				},
+				extras: {
+					max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+					maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+					arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+					arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+				},
+			});
+
+			const viewNested = await db.query.usersView.findFirst({
+				columns: {
+					sq: false, // TODO: re-enable when supported in RQBv2
+				},
+				with: {
+					self: {
+						columns: {
+							sq: false, // TODO: re-enable when supported in RQBv2
+						},
+					},
+				},
+			});
+
+			expect(res).toStrictEqual([
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					sq: exDate,
+					cus: exDate,
+					arrCus: [exDate],
+				},
+			]);
+			expect(viewRes).toStrictEqual([
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					sq: exDate,
+					cus: exDate,
+					arrCus: [exDate],
+				},
+			]);
+
+			expect(customCast).toBeTruthy();
+			expect(customMap).toBeTruthy();
+
+			expect(nested).toStrictEqual(
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+					self: {
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				},
+			);
+			expect(viewNested).toStrictEqual(
+				{
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					max: exDate,
+					maxStr: exDateStr,
+					arrMax: [exDate],
+					arrMaxStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+					self: {
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				},
+			);
+		});
+
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'Same table name joined between schemas',
+			async ({ db }) => {
+				const users1 = pgTable('users_cs_join_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					name: t.text('name').notNull(),
+				}));
+				const schema = pgSchema('cs_join_1');
+				const users2 = schema.table('users_cs_join_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					name: t.text('name').notNull(),
+				}));
+
+				await db.insert(users1).values([{
+					id: 1,
+					name: 'First',
+				}, {
+					id: 2,
+					name: 'Second',
+				}]);
+				await db.insert(users2).values([{
+					id: 1,
+					name: 'First',
+				}]);
+
+				const res = await db.select({
+					u1: users1,
+					u2: users2,
+				}).from(users1).leftJoin(users2, eq(users1.id, users2.id));
+
+				// @ts-ignore skipIf(Date.now() < +new Date('2026-07-01')) - just to make it searchable
+				expectTypeOf(res).toEqualTypeOf<{
+					u1: {
+						id: number;
+						name: string;
+					};
+					u2: {
+						id: number;
+						name: string;
+					} | null;
+				}[]>();
+				expect(res).toStrictEqual([
+					{
+						u1: {
+							id: 1,
+							name: 'First',
+						},
+						u2: {
+							id: 1,
+							name: 'First',
+						},
+					},
+					{
+						u1: {
+							id: 2,
+							name: 'Second',
+						},
+						u2: null,
+					},
+				]);
+			},
+		);
+	});
+}
diff --git a/integration-tests/tests/pg/common-rqb.ts b/integration-tests/tests/pg/common-rqb.ts
new file mode 100644
index 0000000000..7f5c75840d
--- /dev/null
+++ b/integration-tests/tests/pg/common-rqb.ts
@@ -0,0 +1,1200 @@
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import { and, defineRelations, eq, inArray, isNotNull, not, or, sql } from 'drizzle-orm';
+import type { AnyPgColumn, PgColumnBuilder } from 'drizzle-orm/pg-core';
+import { bigint, integer, numeric, pgEnum, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { describe, expect, expectTypeOf } from 'vitest';
+import type { Test } from './instrumentation';
+
+export function tests(test: Test) {
+	describe('common', () => {
+		test.concurrent('RQB v2 simple find first - no rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_1', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const result = await db.query.users.findFirst();
+
+			expect(result).toStrictEqual(undefined);
+		});
+
+		test.concurrent('RQB v2 simple find first - multiple rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_2', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = await db.query.users.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+
+		test.concurrent('RQB v2 simple find first - with relation', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_3', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			const posts = pgTable('rqb_posts_3', {
+				id: serial().primaryKey().notNull(),
+				userId: integer('user_id').notNull(),
+				content: text(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users, posts });
+			const db = createDB({ users, posts }, (r) => ({
+				users: {
+					posts: r.many.posts({
+						from: r.users.id,
+						to: r.posts.userId,
+					}),
+				},
+				posts: {
+					author: r.one.users({
+						from: r.posts.userId,
+						to: r.users.id,
+					}),
+				},
+			}));
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(posts).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = await db.query.users.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+
+		test.concurrent('RQB v2 simple find first - placeholders', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_4', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.users.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare('rqb_v2_find_first_placeholders');
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5172
+		test.concurrent('RQB v2 simple find first - result type', async ({ push, createDB }) => {
+			const user = pgTable('users', {
+				id: text('id').primaryKey(),
+				email: text('email').notNull().unique(),
+				password: text('password').notNull(),
+			});
+
+			const userSession = pgTable('user_sessions', {
+				id: text('id').primaryKey(),
+				userId: text('user_id')
+					.notNull()
+					.references(() => user.id),
+				expiresAt: timestamp('expires_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+			});
+
+			const schema = { user, userSession };
+			const db = createDB(schema, (r) => ({
+				user: {
+					sessions: r.many.userSession(),
+				},
+				userSession: {
+					user: r.one.user({
+						from: r.userSession.userId,
+						to: r.user.id,
+						optional: false,
+					}),
+				},
+			}));
+
+			const query = db.query.userSession.findFirst({
+				where: { id: '' },
+				with: { user: true },
+			});
+
+			expectTypeOf(query).resolves.toEqualTypeOf<
+				{
+					id: string;
+					userId: string;
+					expiresAt: Date;
+					user: {
+						id: string;
+						email: string;
+						password: string;
+					};
+				} | undefined
+			>();
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5172
+		test.concurrent('RQB v2 simple find first - result type', async ({ push, createDB }) => {
+			const user = pgTable('users', {
+				id: text('id').primaryKey(),
+				email: text('email').notNull().unique(),
+				password: text('password').notNull(),
+			});
+
+			const userSession = pgTable('user_sessions', {
+				id: text('id').primaryKey(),
+				userId: text('user_id')
+					.notNull()
+					.references(() => user.id),
+				expiresAt: timestamp('expires_at', {
+					withTimezone: true,
+					mode: 'date',
+				}).notNull(),
+			});
+
+			const schema = { user, userSession };
+			const db = createDB(schema, (r) => ({
+				user: {
+					sessions: r.many.userSession(),
+				},
+				userSession: {
+					user: r.one.user({
+						from: r.userSession.userId,
+						to: r.user.id,
+						optional: false,
+					}),
+				},
+			}));
+
+			const query = db.query.userSession.findFirst({
+				where: { id: '' },
+				with: { user: true },
+			});
+
+			expectTypeOf(query).resolves.toEqualTypeOf<
+				{
+					id: string;
+					userId: string;
+					expiresAt: Date;
+					user: {
+						id: string;
+						email: string;
+						password: string;
+					};
+				} | undefined
+			>();
+		});
+
+		test.concurrent('RQB v2 simple find many - no rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_5', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const result = await db.query.users.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+
+		test.concurrent('RQB v2 simple find many - multiple rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_6', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = await db.query.users.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+
+		test.concurrent('RQB v2 simple find many - with relation', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_7', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			const posts = pgTable('rqb_posts_7', {
+				id: serial().primaryKey().notNull(),
+				userId: integer('user_id').notNull(),
+				content: text(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users, posts });
+			const db = createDB({ users, posts }, (r) => ({
+				posts: {
+					author: r.one.users({
+						from: r.posts.userId,
+						to: r.users.id,
+					}),
+				},
+			}));
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(posts).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = await db.query.posts.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+
+		test.concurrent('RQB v2 simple find many - placeholders', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_8', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.users.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare('rqb_v2_find_many_placeholders');
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+
+		test.concurrent('RQB v2 transaction find first - no rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_9', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			await db.transaction(async (db) => {
+				const result = await db.query.users.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - multiple rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_10', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.users.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - with relation', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_11', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			const posts = pgTable('rqb_posts_11', {
+				id: serial().primaryKey().notNull(),
+				userId: integer('user_id').notNull(),
+				content: text(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users, posts });
+			const db = createDB({ users, posts }, (r) => ({
+				users: {
+					posts: r.many.posts({
+						from: r.users.id,
+						to: r.posts.userId,
+					}),
+				},
+			}));
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(posts).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.users.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - placeholders', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_12', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const query = db.query.users.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare('rqb_v2_find_first_tx_placeholders');
+
+				const result = await query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - no rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_13', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			await db.transaction(async (db) => {
+				const result = await db.query.users.findMany();
+
+				expect(result).toStrictEqual([]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - multiple rows', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_14', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.users.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - with relation', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_15', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			const posts = pgTable('rqb_posts_15', {
+				id: serial().primaryKey().notNull(),
+				userId: integer('user_id').notNull(),
+				content: text(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users, posts });
+			const db = createDB({ users, posts }, (r) => ({
+				posts: {
+					author: r.one.users({
+						from: r.posts.userId,
+						to: r.users.id,
+					}),
+				},
+			}));
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(posts).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.posts.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - placeholders', async ({ push, createDB }) => {
+			const users = pgTable('rqb_users_16', {
+				id: serial().primaryKey().notNull(),
+				name: text().notNull(),
+				createdAt: timestamp('created_at', {
+					mode: 'date',
+					precision: 3,
+				}).notNull(),
+			});
+
+			await push({ users });
+			const db = createDB({ users });
+
+			const date = new Date(120000);
+
+			await db.insert(users).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const query = db.query.users.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare('rqb_v2_find_many_placeholders_10');
+
+				const result = await query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			});
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4358
+		test.concurrent('RQB v2 find many - table creation func', async ({ push, createDB }) => {
+			const createUserTable = <T extends Record<string, PgColumnBuilder<any>>>(
+				{ customColumns, tableName }: { customColumns: T; tableName: string },
+			) =>
+				pgTable(tableName, {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					email: text('email').notNull().unique(),
+					createdAt: timestamp('created_at').defaultNow().notNull(),
+					...customColumns,
+				});
+			const users = createUserTable(
+				{
+					tableName: 'rqb_users_17',
+					customColumns: {
+						test: text('test').notNull(),
+					},
+				},
+			);
+
+			const orders = pgTable('rqb_orders_17', {
+				id: serial('id').primaryKey(),
+				userId: integer('user_id').references(() => users.id).notNull(),
+				amount: integer('amount').notNull(),
+				status: text('status').notNull(),
+				createdAt: timestamp('created_at').defaultNow().notNull(),
+			});
+
+			await push({ users, orders });
+			const db = createDB({ users, orders }, (r) => ({
+				orders: {
+					user: r.one.users({
+						from: [r.orders.userId],
+						to: [r.users.id],
+					}),
+				},
+			}));
+
+			await db.insert(users).values([{ id: 1, email: 'a', name: 'b', test: 'c' }, {
+				id: 2,
+				email: 'aa',
+				name: 'bb',
+				test: 'cc',
+			}]);
+			await db.insert(orders).values([{ userId: 1, amount: 11, status: 'delivered' }, {
+				userId: 2,
+				amount: 22,
+				status: 'delivered',
+			}]);
+
+			const ordersWithUser = await db.query.orders.findMany({
+				with: {
+					user: {
+						columns: {
+							id: true,
+							// This fails type checking. `id` column works, but not `test`
+							test: true,
+						},
+					},
+				},
+			});
+
+			for (const order of ordersWithUser) {
+				expect(order.user!.id).toBeDefined();
+				expect(order.user!.test).toBeDefined();
+			}
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4169
+		test.concurrent(
+			'RQB v2 find many - $count',
+			async ({ push, createDB }) => {
+				const users = pgTable('rqb_users_18', {
+					id: serial('id').primaryKey(),
+				});
+
+				const statusEnum = pgEnum('status', [
+					'IN_PROGRESS',
+					'CANCELED',
+					'CLOSED',
+				]);
+
+				const orders = pgTable('rqb_orders_18', {
+					id: serial('id').primaryKey(),
+					userId: integer('user_id').references(() => users.id).notNull(),
+					status: statusEnum('status'),
+				});
+
+				await push({ users, orders, statusEnum });
+				const db = createDB({ users, orders }, (r) => ({
+					orders: {
+						user: r.one.users({
+							from: [r.orders.userId],
+							to: [r.users.id],
+						}),
+					},
+				}));
+
+				await db.insert(users).values([{ id: 1 }, { id: 2 }]);
+				await db.insert(orders).values([{ userId: 1, status: 'CANCELED' }, { userId: 2, status: 'IN_PROGRESS' }]);
+
+				const recordsQuery = db.query.users.findMany({
+					extras: {
+						activeOrders: (users) =>
+							db
+								.$count(
+									orders,
+									and(
+										eq(orders.userId, users.id),
+										not(
+											inArray(orders.status, ['CANCELED', 'CLOSED']),
+										),
+									),
+								)
+								.as('activeOrders'),
+						allOrders: db.$count(orders),
+					},
+				});
+
+				const expectedResult = [{ id: 1, activeOrders: 0, allOrders: 2 }, { id: 2, activeOrders: 1, allOrders: 2 }];
+				const result = await recordsQuery;
+				expect(result).toStrictEqual(expectedResult);
+				expect(recordsQuery.toSQL()).toStrictEqual({
+					sql:
+						'select "d0"."id" as "id", ((select count(*) from "rqb_orders_18" where (("rqb_orders_18"."user_id" = "d0"."id") and (not ("rqb_orders_18"."status" in ($1, $2)))))) as "activeOrders", ((select count(*) from "rqb_orders_18")) as "allOrders" from "rqb_users_18" as "d0"',
+					params: ['CANCELED', 'CLOSED'],
+				});
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4696
+		// postgresjs returns strings for itemCount but other drivers return numbers
+		test.skipIf(Date.now() < +new Date('2026-07-01')).concurrent(
+			'RQB v2 find many - extras',
+			async ({ push, createDB }) => {
+				const orderItemTable = pgTable('rqb_order_item_19', {
+					id: integer('id').primaryKey(),
+					orderId: integer().references(() => orderTable.id),
+				});
+
+				const orderTable = pgTable('rqb_order_19', {
+					id: integer('id').primaryKey(),
+				});
+
+				await push({ orderItemTable, orderTable });
+				const db = createDB({ orderItemTable, orderTable });
+
+				await db.insert(orderTable).values([{ id: 1 }, { id: 2 }]);
+				await db.insert(orderItemTable).values([{ id: 1, orderId: 1 }, { id: 2, orderId: 1 }]);
+
+				const query = db.query.orderTable.findMany({
+					extras: {
+						itemCount: (t) =>
+							sql`(select count(*) from ${orderItemTable} where ${orderItemTable.orderId} = ${t.id})`.as('itemCount'),
+					},
+				});
+
+				expect(query.toSQL()).toStrictEqual({
+					sql:
+						`select "d0"."id" as "id", ((select count(*) from "rqb_order_item_19" where "rqb_order_item_19"."orderId" = "d0"."id")) as "itemCount" from "rqb_order_19" as "d0"`,
+					params: [],
+				});
+
+				const expectedResult = [{ id: 1, itemCount: 2 }, { id: 2, itemCount: 0 }];
+				const result = await query;
+				expect(result).toStrictEqual(expectedResult);
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4494
+		test.concurrent('RQB v2 find first 100 columns in table', async ({ push, createDB }) => {
+			const columns: Record<string, PgColumnBuilder<any>> = {};
+			const columnCount = 101;
+			for (let i = 0; i < columnCount; i++) {
+				columns[`col${i}`] = numeric({ precision: 20, scale: 2 });
+			}
+
+			const prices = pgTable('prices', {
+				id: integer().primaryKey(),
+				...columns,
+			});
+
+			const entity = pgTable('entity', {
+				id: serial('id').primaryKey(),
+				priceId: integer('price_id').references(() => prices.id),
+			});
+
+			await push({ prices, entity });
+			const db = createDB({ prices, entity }, (r) => ({
+				entity: {
+					price: r.one.prices({
+						from: [r.entity.priceId],
+						to: [r.prices.id],
+					}),
+				},
+			}));
+
+			await db.execute('insert into prices(id, col0, col1, col2) values (1, 23,24,25);');
+			await db.insert(entity).values([{ id: 1, priceId: 1 }]);
+			const query = db.query.entity.findFirst({
+				with: {
+					price: {},
+				},
+			});
+			await query;
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5350
+		test.concurrent('RQB v2 defineRelations error', () => {
+			const users = pgTable('users', { id: integer().primaryKey() });
+			const posts = pgTable('posts', { id: integer().primaryKey(), userId: integer() });
+			const blogs = pgTable('blogs', { id: integer().primaryKey() });
+
+			const throwFunc1 = () => {
+				defineRelations({ users, posts, blogs }, (r) => ({
+					users: {
+						posts: r.many.posts({
+							from: r.users.id,
+							to: r.blogs.id,
+						}),
+					},
+				}));
+			};
+			expect(throwFunc1).toThrowError(
+				/.+all "to" columns must belong to table "posts", found column of table "blogs"$/,
+			);
+
+			const throwFunc2 = () => {
+				defineRelations({ users, posts, blogs }, (r) => ({
+					users: {
+						posts: r.many.posts({
+							from: r.blogs.id,
+							to: r.posts.userId,
+						}),
+					},
+				}));
+			};
+			expect(throwFunc2).toThrowError(
+				/.+all "from" columns must belong to table "users", found column of table "blogs"$/,
+			);
+		});
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/5760
+	test.concurrent('issue 5760. bigint precision', async ({ createDB, push }) => {
+		const users = pgTable('users', {
+			id: bigint({ mode: 'bigint' }).primaryKey(),
+		});
+
+		const posts = pgTable('posts', {
+			id: bigint({ mode: 'bigint' }).primaryKey(),
+			title: text().notNull(),
+			author: bigint({ mode: 'bigint' })
+				.notNull()
+				.references(() => users.id, { onDelete: 'cascade' }),
+		});
+
+		const schema = { users, posts };
+		const db = createDB(schema, (r) => ({
+			users: {
+				posts: r.many.posts(),
+			},
+			posts: {
+				authorRel: r.one.users({
+					from: r.posts.author,
+					to: r.users.id,
+				}),
+			},
+		}));
+
+		await db.execute(sql`DROP TABLE IF EXISTS ${posts};`);
+		await db.execute(sql`DROP TABLE IF EXISTS ${users};`);
+
+		await push(schema);
+
+		await db.insert(users).values({ id: 1000000000000000001n });
+		await db.insert(posts).values([{ id: 1000000000000000002n, title: 'foo', author: 1000000000000000001n }, {
+			id: 1000000000000000003n,
+			title: 'bar',
+			author: 1000000000000000001n,
+		}]);
+
+		const res = await db.query.users.findMany({ with: { posts: true } });
+		expect(res).toStrictEqual([
+			{
+				id: 1000000000000000001n,
+				posts: [
+					{
+						author: 1000000000000000001n,
+						id: 1000000000000000002n,
+						title: 'foo',
+					},
+					{
+						author: 1000000000000000001n,
+						id: 1000000000000000003n,
+						title: 'bar',
+					},
+				],
+			},
+		]);
+	});
+}
diff --git a/integration-tests/tests/pg/common.ts b/integration-tests/tests/pg/common.ts
new file mode 100644
index 0000000000..8862374346
--- /dev/null
+++ b/integration-tests/tests/pg/common.ts
@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+
+import { tests as testCommonCache } from './common-cache';
+import { tests as tests1 } from './common-pt1';
+import { tests as tests2 } from './common-pt2';
+import { tests as testCommonRQB } from './common-rqb';
+import type { Test } from './instrumentation';
+
+export function tests(test: Test, exclude: string[]) {
+	test.beforeEach(async ({ task, skip }) => {
+		if (exclude.includes(task.name)) skip();
+	});
+
+	tests1(test);
+	tests2(test);
+	testCommonRQB(test);
+	testCommonCache(test);
+}
diff --git a/integration-tests/tests/pg/effect-common.ts b/integration-tests/tests/pg/effect-common.ts
new file mode 100644
index 0000000000..160f96c8f9
--- /dev/null
+++ b/integration-tests/tests/pg/effect-common.ts
@@ -0,0 +1,5776 @@
+import { assert, expect, expectTypeOf, it, Vitest } from '@effect/vitest';
+import {
+	and,
+	asc,
+	eq,
+	getColumns,
+	gt,
+	gte,
+	inArray,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	max,
+	sql,
+} from 'drizzle-orm';
+import { EffectCache, type EffectCacheShape } from 'drizzle-orm/cache/core/cache-effect';
+import { EffectLogger, type EffectLoggerShape, QueryEffectHKTBase } from 'drizzle-orm/effect-core';
+import {
+	alias,
+	bigint,
+	bigserial,
+	boolean,
+	bytea,
+	char,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	except,
+	getMaterializedViewConfig,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	PgDialect,
+	pgEnum,
+	pgSchema,
+	pgTable,
+	pgView,
+	point,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	text,
+	time,
+	timestamp,
+	union,
+	unionAll,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import type { PgEffectDatabase } from 'drizzle-orm/pg-core/effect/db';
+import { PgEffectSession } from 'drizzle-orm/pg-core/effect/session';
+import {
+	EmptyRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+} from 'drizzle-orm/relations';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Ref from 'effect/Ref';
+import * as Result from 'effect/Result';
+import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlError } from 'effect/unstable/sql/SqlError';
+import { relations } from './relations';
+import { rqbPost, rqbUser } from './schema';
+import { normalizeDataWithDbCodecs } from './utils';
+
+export class DB extends Context.Service<DB, PgEffectDatabase<any, any, typeof relations>>()('CommonEffectPgDB') {}
+
+let _diff!: (_: {}, schema: Record<string, unknown>, renames: []) => Promise<{ sqlStatements: string[] }>;
+const getDiff = async () => {
+	return _diff ??= (await import('../../../drizzle-kit/tests/postgres/mocks' as string)).diff;
+};
+
+export const push = (db: PgEffectDatabase<any, any, any>, schema: Record<string, any>) =>
+	Effect.gen(function*() {
+		const diff = yield* Effect.promise(() => getDiff());
+
+		const { sqlStatements } = yield* Effect.promise(() => diff({}, schema, []));
+
+		yield* db.transaction((tx) =>
+			Effect.gen(function*() {
+				for (const s of sqlStatements) {
+					yield* tx.execute(s);
+				}
+			})
+		);
+	});
+
+export interface RunCommonEffectPgTestsOptions {
+	testLayer: Layer.Layer<DB | SqlClient, SqlError, never>;
+	PgDrizzle: {
+		make: (config?: any) => Effect.Effect<PgEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		makeWithDefaults: (
+			config?: any,
+		) => Effect.Effect<PgEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		DefaultServices: Layer.Layer<any, never, any>;
+	};
+	createDB: <
+		TSchema extends Record<string, any>,
+		TConfig extends RelationsBuilderConfig<TTables>,
+		TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+	>(
+		schema: TSchema,
+		relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+		useJitMappers?: boolean,
+	) => Effect.Effect<
+		PgEffectDatabase<QueryEffectHKTBase, any, ExtractTablesWithRelations<TConfig, TTables>>,
+		never,
+		any
+	>;
+	usedSchema: string;
+	skipTests?: string[];
+	addTests?: (it: Vitest.MethodsNonLive<DB | SqlClient>) => void;
+}
+
+export const runCommonEffectPgTests = (opts: RunCommonEffectPgTestsOptions): void => {
+	const { testLayer, usedSchema, PgDrizzle, createDB, addTests, skipTests = [] } = opts;
+
+	it.layer(testLayer)('common', (it) => {
+		// Run setup before each test.
+		const _effect = it.effect;
+		const effect: typeof it.effect = Object.assign(
+			(testName: string, fn: () => Effect.Effect<any, any, any>, timeout?: number) =>
+				_effect(testName, () =>
+					Effect.andThen(
+						Effect.gen(function*() {
+							const db = yield* DB;
+
+							yield* db.execute(sql`DROP SCHEMA IF EXISTS ${sql.identifier(usedSchema)} CASCADE`);
+							yield* db.execute(sql`DROP SCHEMA IF EXISTS ${sql.identifier(`${usedSchema}_custom`)} CASCADE`);
+							yield* db.execute(sql`DROP SCHEMA IF EXISTS ${sql.identifier('drizzle')} CASCADE`);
+							yield* db.execute(sql`DROP SCHEMA IF EXISTS ${sql.identifier('drzl_migrations_init')} CASCADE`);
+							yield* db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(usedSchema)};`);
+							yield* db.execute(sql`SET search_path TO ${sql.identifier(usedSchema)};`);
+							yield* db.execute(sql`SET TIME ZONE 'UTC';`);
+						}),
+						fn(),
+					), timeout),
+			it.effect,
+		);
+		Object.assign(it, { effect });
+
+		it.beforeEach(({ task, skip }) => {
+			if (skipTests.includes(task.name)) skip();
+		});
+
+		it.effect('all types', () =>
+			Effect.gen(function*() {
+				const en = pgEnum('en_48', ['enVal1', 'enVal2']);
+				const allTypesTable = pgTable('all_types_48', {
+					serial: serial('serial'),
+					bigserial53: bigserial('bigserial53', {
+						mode: 'number',
+					}),
+					bigserial64: bigserial('bigserial64', {
+						mode: 'bigint',
+					}),
+					int: integer('int'),
+					bigint53: bigint('bigint53', {
+						mode: 'number',
+					}),
+					bigint64: bigint('bigint64', {
+						mode: 'bigint',
+					}),
+					bigintString: bigint('bigint_string', {
+						mode: 'string',
+					}),
+					bool: boolean('bool'),
+					bytea: bytea('bytea'),
+					char: char('char'),
+					cidr: cidr('cidr'),
+					date: date('date', {
+						mode: 'date',
+					}),
+					dateStr: date('date_str', {
+						mode: 'string',
+					}),
+					double: doublePrecision('double'),
+					enum: en('enum'),
+					inet: inet('inet'),
+					interval: interval('interval'),
+					json: json('json'),
+					jsonb: jsonb('jsonb'),
+					line: line('line', {
+						mode: 'abc',
+					}),
+					lineTuple: line('line_tuple', {
+						mode: 'tuple',
+					}),
+					macaddr: macaddr('macaddr'),
+					macaddr8: macaddr8('macaddr8'),
+					numeric: numeric('numeric'),
+					numericNum: numeric('numeric_num', {
+						mode: 'number',
+					}),
+					numericBig: numeric('numeric_big', {
+						mode: 'bigint',
+					}),
+					point: point('point', {
+						mode: 'xy',
+					}),
+					pointTuple: point('point_tuple', {
+						mode: 'tuple',
+					}),
+					real: real('real'),
+					smallint: smallint('smallint'),
+					smallserial: smallserial('smallserial'),
+					text: text('text'),
+					time: time('time'),
+					timestamp: timestamp('timestamp', {
+						mode: 'date',
+					}),
+					timestampTz: timestamp('timestamp_tz', {
+						mode: 'date',
+						withTimezone: true,
+					}),
+					timestampStr: timestamp('timestamp_str', {
+						mode: 'string',
+					}),
+					timestampTzStr: timestamp('timestamp_tz_str', {
+						mode: 'string',
+						withTimezone: true,
+					}),
+					uuid: uuid('uuid'),
+					varchar: varchar('varchar'),
+					arrint: integer('arrint').array(),
+					arrbigint53: bigint('arrbigint53', {
+						mode: 'number',
+					}).array(),
+					arrbigint64: bigint('arrbigint64', {
+						mode: 'bigint',
+					}).array(),
+					arrbigintString: bigint('arrbigint_string', {
+						mode: 'string',
+					}).array(),
+					arrbool: boolean('arrbool').array(),
+					arrbytea: bytea('arrbytea').array(),
+					arrchar: char('arrchar').array(),
+					arrcidr: cidr('arrcidr').array(),
+					arrdate: date('arrdate', {
+						mode: 'date',
+					}).array(),
+					arrdateStr: date('arrdate_str', {
+						mode: 'string',
+					}).array(),
+					arrdouble: doublePrecision('arrdouble').array(),
+					arrenum: en('arrenum').array(),
+					arrinet: inet('arrinet').array(),
+					arrinterval: interval('arrinterval').array(),
+					arrjson: json('arrjson').array(),
+					arrjsonb: jsonb('arrjsonb').array(),
+					arrline: line('arrline', {
+						mode: 'abc',
+					}).array(),
+					arrlineTuple: line('arrline_tuple', {
+						mode: 'tuple',
+					}).array(),
+					arrmacaddr: macaddr('arrmacaddr').array(),
+					arrmacaddr8: macaddr8('arrmacaddr8').array(),
+					arrnumeric: numeric('arrnumeric').array(),
+					arrnumericNum: numeric('arrnumeric_num', {
+						mode: 'number',
+					}).array(),
+					arrnumericBig: numeric('arrnumeric_big', {
+						mode: 'bigint',
+					}).array(),
+					arrpoint: point('arrpoint', {
+						mode: 'xy',
+					}).array(),
+					arrpointTuple: point('arrpoint_tuple', {
+						mode: 'tuple',
+					}).array(),
+					arrreal: real('arrreal').array(),
+					arrsmallint: smallint('arrsmallint').array(),
+					arrtext: text('arrtext').array(),
+					arrtime: time('arrtime').array(),
+					arrtimestamp: timestamp('arrtimestamp', {
+						mode: 'date',
+					}).array(),
+					arrtimestampTz: timestamp('arrtimestamp_tz', {
+						mode: 'date',
+						withTimezone: true,
+					}).array(),
+					arrtimestampStr: timestamp('arrtimestamp_str', {
+						mode: 'string',
+					}).array(),
+					arrtimestampTzStr: timestamp('arrtimestamp_tz_str', {
+						mode: 'string',
+						withTimezone: true,
+					}).array(),
+					arruuid: uuid('arruuid').array(),
+					arrvarchar: varchar('arrvarchar').array(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { en, allTypesTable });
+
+				yield* db.insert(allTypesTable).values({
+					serial: 1,
+					smallserial: 15,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bigintString: '5044565289845416380',
+					bigserial53: 9007199254740991,
+					bigserial64: 5044565289845416380n,
+					bool: true,
+					bytea: Buffer.from('BYTES'),
+					char: 'c',
+					cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+					inet: '192.168.0.1/24',
+					macaddr: '08:00:2b:01:02:03',
+					macaddr8: '08:00:2b:01:02:03:04:05',
+					date: new Date(1741743161623),
+					dateStr: new Date(1741743161623).toISOString(),
+					double: 15.35325689124218,
+					enum: 'enVal1',
+					int: 621,
+					interval: '2 months ago',
+					json: {
+						str: 'strval',
+						arr: ['str', 10],
+					},
+					jsonb: {
+						str: 'strvalb',
+						arr: ['strb', 11],
+					},
+					line: {
+						a: 1,
+						b: 2,
+						c: 3,
+					},
+					lineTuple: [1, 2, 3],
+					numeric: '475452353476',
+					numericNum: 9007199254740991,
+					numericBig: 5044565289845416380n,
+					point: {
+						x: 24.5,
+						y: 49.6,
+					},
+					pointTuple: [57.2, 94.3],
+					real: 1.048596,
+					smallint: 10,
+					text: 'TEXT STRING',
+					time: '13:59:28',
+					timestamp: new Date(1741743161623),
+					timestampTz: new Date(1741743161623),
+					timestampStr: new Date(1741743161623).toISOString(),
+					timestampTzStr: new Date(1741743161623).toISOString(),
+					uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+					varchar: 'C4-',
+					arrbigint53: [9007199254740991],
+					arrbigint64: [5044565289845416380n],
+					arrbigintString: ['5044565289845416380'],
+					arrbool: [true],
+					arrbytea: [Buffer.from('BYTES')],
+					arrchar: ['c'],
+					arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+					arrinet: ['192.168.0.1/24'],
+					arrmacaddr: ['08:00:2b:01:02:03'],
+					arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+					arrdate: [new Date(1741743161623)],
+					arrdateStr: [new Date(1741743161623).toISOString()],
+					arrdouble: [15.35325689124218],
+					arrenum: ['enVal1'],
+					arrint: [621],
+					arrinterval: ['2 months ago'],
+					arrjson: [{
+						str: 'strval',
+						arr: ['str', 10],
+					}],
+					arrjsonb: [{
+						str: 'strvalb',
+						arr: ['strb', 11],
+					}],
+					arrline: [{
+						a: 1,
+						b: 2,
+						c: 3,
+					}],
+					arrlineTuple: [[1, 2, 3]],
+					arrnumeric: ['475452353476'],
+					arrnumericNum: [9007199254740991],
+					arrnumericBig: [5044565289845416380n],
+					arrpoint: [{
+						x: 24.5,
+						y: 49.6,
+					}],
+					arrpointTuple: [[57.2, 94.3]],
+					arrreal: [1.048596],
+					arrsmallint: [10],
+					arrtext: ['TEXT STRING'],
+					arrtime: ['13:59:28'],
+					arrtimestamp: [new Date(1741743161623)],
+					arrtimestampTz: [new Date(1741743161623)],
+					arrtimestampStr: [new Date(1741743161623).toISOString()],
+					arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+					arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+					arrvarchar: ['C4-'],
+				});
+
+				const rawRes = yield* db.select().from(allTypesTable);
+
+				type ExpectedType = {
+					serial: number;
+					bigserial53: number;
+					bigserial64: bigint;
+					int: number | null;
+					bigint53: number | null;
+					bigint64: bigint | null;
+					bigintString: string | null;
+					bool: boolean | null;
+					bytea: Buffer | null;
+					char: string | null;
+					cidr: string | null;
+					date: Date | null;
+					dateStr: string | null;
+					double: number | null;
+					enum: 'enVal1' | 'enVal2' | null;
+					inet: string | null;
+					interval: string | null;
+					json: unknown;
+					jsonb: unknown;
+					line: {
+						a: number;
+						b: number;
+						c: number;
+					} | null;
+					lineTuple: [number, number, number] | null;
+					macaddr: string | null;
+					macaddr8: string | null;
+					numeric: string | null;
+					numericNum: number | null;
+					numericBig: bigint | null;
+					point: {
+						x: number;
+						y: number;
+					} | null;
+					pointTuple: [number, number] | null;
+					real: number | null;
+					smallint: number | null;
+					smallserial: number;
+					text: string | null;
+					time: string | null;
+					timestamp: Date | null;
+					timestampTz: Date | null;
+					timestampStr: string | null;
+					timestampTzStr: string | null;
+					uuid: string | null;
+					varchar: string | null;
+					arrint: number[] | null;
+					arrbigint53: number[] | null;
+					arrbigint64: bigint[] | null;
+					arrbigintString: string[] | null;
+					arrbool: boolean[] | null;
+					arrbytea: Buffer[] | null;
+					arrchar: string[] | null;
+					arrcidr: string[] | null;
+					arrdate: Date[] | null;
+					arrdateStr: string[] | null;
+					arrdouble: number[] | null;
+					arrenum: ('enVal1' | 'enVal2')[] | null;
+					arrinet: string[] | null;
+					arrinterval: string[] | null;
+					arrjson: unknown[] | null;
+					arrjsonb: unknown[] | null;
+					arrline: {
+						a: number;
+						b: number;
+						c: number;
+					}[] | null;
+					arrlineTuple: [number, number, number][] | null;
+					arrmacaddr: string[] | null;
+					arrmacaddr8: string[] | null;
+					arrnumeric: string[] | null;
+					arrnumericNum: number[] | null;
+					arrnumericBig: bigint[] | null;
+					arrpoint: { x: number; y: number }[] | null;
+					arrpointTuple: [number, number][] | null;
+					arrreal: number[] | null;
+					arrsmallint: number[] | null;
+					arrtext: string[] | null;
+					arrtime: string[] | null;
+					arrtimestamp: Date[] | null;
+					arrtimestampTz: Date[] | null;
+					arrtimestampStr: string[] | null;
+					arrtimestampTzStr: string[] | null;
+					arruuid: string[] | null;
+					arrvarchar: string[] | null;
+				}[];
+
+				const expectedRes: ExpectedType = [
+					{
+						serial: 1,
+						bigserial53: 9007199254740991,
+						bigserial64: 5044565289845416380n,
+						int: 621,
+						bigint53: 9007199254740991,
+						bigint64: 5044565289845416380n,
+						bigintString: '5044565289845416380',
+						bool: true,
+						bytea: Buffer.from('BYTES'),
+						char: 'c',
+						cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+						date: new Date('2025-03-12T00:00:00.000Z'),
+						dateStr: '2025-03-12',
+						double: 15.35325689124218,
+						enum: 'enVal1',
+						inet: '192.168.0.1/24',
+						interval: '-2 mons',
+						json: { str: 'strval', arr: ['str', 10] },
+						jsonb: { arr: ['strb', 11], str: 'strvalb' },
+						line: { a: 1, b: 2, c: 3 },
+						lineTuple: [1, 2, 3],
+						macaddr: '08:00:2b:01:02:03',
+						macaddr8: '08:00:2b:01:02:03:04:05',
+						numeric: '475452353476',
+						numericNum: 9007199254740991,
+						numericBig: 5044565289845416380n,
+						point: { x: 24.5, y: 49.6 },
+						pointTuple: [57.2, 94.3],
+						real: 1.048596,
+						smallint: 10,
+						smallserial: 15,
+						text: 'TEXT STRING',
+						time: '13:59:28',
+						timestamp: new Date('2025-03-12T01:32:41.623Z'),
+						timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+						timestampStr: '2025-03-12 01:32:41.623',
+						timestampTzStr: '2025-03-12 01:32:41.623+00',
+						uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+						varchar: 'C4-',
+						arrint: [621],
+						arrbigint53: [9007199254740991],
+						arrbigint64: [5044565289845416380n],
+						arrbigintString: ['5044565289845416380'],
+						arrbool: [true],
+						arrbytea: [Buffer.from('BYTES')],
+						arrchar: ['c'],
+						arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+						arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+						arrdateStr: ['2025-03-12'],
+						arrdouble: [15.35325689124218],
+						arrenum: ['enVal1'],
+						arrinet: ['192.168.0.1/24'],
+						arrinterval: ['-2 mons'],
+						arrjson: [{ str: 'strval', arr: ['str', 10] }],
+						arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+						arrline: [{ a: 1, b: 2, c: 3 }],
+						arrlineTuple: [[1, 2, 3]],
+						arrmacaddr: ['08:00:2b:01:02:03'],
+						arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+						arrnumeric: ['475452353476'],
+						arrnumericNum: [9007199254740991],
+						arrnumericBig: [5044565289845416380n],
+						arrpoint: [{ x: 24.5, y: 49.6 }],
+						arrpointTuple: [[57.2, 94.3]],
+						arrreal: [1.048596],
+						arrsmallint: [10],
+						arrtext: ['TEXT STRING'],
+						arrtime: ['13:59:28'],
+						arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+						arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+						arrtimestampStr: ['2025-03-12 01:32:41.623'],
+						arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+						arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+						arrvarchar: ['C4-'],
+					},
+				];
+
+				expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+				expect(rawRes).toStrictEqual(expectedRes);
+			}));
+
+		it.effect('RQB v2 simple find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 simple find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare('rqb_v2_find_first_placeholders');
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 simple find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbPost.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare('rqb_v2_find_many_placeholders');
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst();
+
+						expect(result).toStrictEqual(undefined);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 transaction find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							with: {
+								posts: {
+									orderBy: {
+										id: 'asc',
+									},
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 1,
+							createdAt: date,
+							name: 'First',
+							posts: [{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+							}, {
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+							}],
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findFirst({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare('rqb_v2_find_first_tx_placeholders');
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany();
+
+						expect(result).toStrictEqual([]);
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 transaction find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}, {
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbPost.findMany({
+							with: {
+								author: true,
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}, {
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findMany({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare('rqb_v2_find_many_placeholders_10');
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}]);
+
+						return result;
+					})
+				);
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('users_transactions', {
+					id: serial('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+				const products = pgTable('products_transactions', {
+					id: serial('id').primaryKey(),
+					price: integer('price').notNull(),
+					stock: integer('stock').notNull(),
+				});
+
+				yield* push(db, { users, products });
+
+				const [user] = yield* db.insert(users).values({ balance: 100 }).returning();
+				const [product] = yield* db.insert(products).values({ price: 10, stock: 10 }).returning();
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.update(users).set({ balance: user!.balance - product!.price }).where(eq(users.id, user!.id));
+						yield* tx.update(products).set({ stock: product!.stock - 1 }).where(eq(products.id, product!.id));
+
+						// Regardless if `db` or `tx` is used, every query within the transaction effect is completed in transaction
+						const nonTxRes = yield* db.select().from(users);
+						expect(nonTxRes).toStrictEqual([{ id: 1, balance: 90 }]);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 90 }]);
+			}));
+
+		it.effect('transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('users_transactions_rollback', {
+					id: serial('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				const res = yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+						yield* tx.rollback();
+					})
+				).pipe(Effect.result);
+
+				assert(Result.isFailure(res));
+				assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([]);
+			}));
+
+		it.effect('nested transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('users_nested_transactions', {
+					id: serial('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+							})
+						);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 200 }]);
+			}));
+
+		it.effect('nested transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('users_nested_transactions_rollback', {
+					id: serial('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						const res = yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+								yield* tx.rollback();
+							})
+						).pipe(Effect.result);
+
+						assert(Result.isFailure(res));
+						assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 100 }]);
+			}));
+
+		it.effect('mySchema :: materialized view', () =>
+			Effect.gen(function*() {
+				const mySchema = pgSchema(`${usedSchema}_custom`);
+
+				const users = mySchema.table('users_100', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				});
+
+				const cities = mySchema.table('cities_100', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { mySchema, users, cities });
+
+				const newYorkers1 = mySchema.materializedView('new_yorkers')
+					.as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+				const newYorkers2 = mySchema.materializedView('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				}).as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+
+				const newYorkers3 = mySchema.materializedView('new_yorkers', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull(),
+				}).existing();
+
+				yield* db.execute(
+					sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`,
+				);
+
+				yield* db.insert(cities).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+				yield* db.insert(users).values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				]);
+
+				{
+					const result = yield* db.select().from(newYorkers1);
+					expect(result).toEqual([]);
+				}
+
+				yield* db.refreshMaterializedView(newYorkers1);
+
+				{
+					const result = yield* db.select().from(newYorkers1);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select().from(newYorkers2);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select().from(newYorkers3);
+					expect(result).toEqual([
+						{ id: 1, name: 'John', cityId: 1 },
+						{ id: 2, name: 'Jane', cityId: 1 },
+					]);
+				}
+
+				{
+					const result = yield* db.select({ name: newYorkers1.name }).from(newYorkers1);
+					expect(result).toEqual([
+						{ name: 'John' },
+						{ name: 'Jane' },
+					]);
+				}
+			}));
+
+		it.effect('update ... from with join', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const states = pgTable('states_30', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const cities = pgTable('cities_30', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					stateId: integer('state_id').references(() => states.id),
+				});
+				const users = pgTable('users_30', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull().references(() => cities.id),
+				});
+
+				yield* push(db, { states, cities, users });
+
+				yield* db.insert(states).values([
+					{ name: 'New York' },
+					{ name: 'Washington' },
+				]);
+				yield* db.insert(cities).values([
+					{ name: 'New York City', stateId: 1 },
+					{ name: 'Seattle', stateId: 2 },
+					{ name: 'London' },
+				]);
+				yield* db.insert(users).values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 2 },
+					{ name: 'Jack', cityId: 3 },
+				]);
+
+				const result1 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+					.returning();
+				const result2 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+					.returning();
+
+				expect(result1).toStrictEqual([{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+					cities_30: {
+						id: 2,
+						name: 'Seattle',
+						stateId: 2,
+					},
+					states_30: {
+						id: 2,
+						name: 'Washington',
+					},
+				}]);
+				expect(result2).toStrictEqual([{
+					id: 3,
+					name: 'Jack',
+					cityId: 3,
+					cities_30: {
+						id: 3,
+						name: 'London',
+						stateId: null,
+					},
+					states_30: null,
+				}]);
+			}));
+
+		it.effect('insert into ... select', () =>
+			Effect.gen(function*() {
+				const notifications = pgTable('notifications_31', {
+					id: serial('id').primaryKey(),
+					sentAt: timestamp('sent_at').notNull().defaultNow(),
+					message: text('message').notNull(),
+				});
+				const users = pgTable('users_31', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const userNotications = pgTable('user_notifications_31', {
+					userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: integer('notification_id').notNull().references(() => notifications.id, {
+						onDelete: 'cascade',
+					}),
+				}, (t) => [primaryKey({ columns: [t.userId, t.notificationId] })]);
+
+				const db = yield* DB;
+
+				yield* push(db, { notifications, users, userNotications });
+
+				const newNotification = (yield* db
+					.insert(notifications)
+					.values({ message: 'You are one of the 3 lucky winners!' })
+					.returning({ id: notifications.id }))[0]!;
+
+				yield* db.insert(users).values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+				const sentNotifications = yield* db
+					.insert(userNotications)
+					.select(
+						db
+							.select({
+								userId: users.id,
+								notificationId: sql`${newNotification!.id}`.as('notification_id'),
+							})
+							.from(users)
+							.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+							.orderBy(asc(users.id)),
+					)
+					.returning();
+
+				expect(sentNotifications).toStrictEqual([
+					{ userId: 1, notificationId: newNotification!.id },
+					{ userId: 3, notificationId: newNotification!.id },
+					{ userId: 5, notificationId: newNotification!.id },
+				]);
+			}));
+
+		it.effect('$count separate', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_33', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable);
+
+				expect(count).toStrictEqual(4);
+			}));
+
+		it.effect('$count embedded', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_34', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+			}));
+
+		it.effect('$count separate reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_35', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.$count(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual(4);
+				expect(count2).toStrictEqual(5);
+				expect(count3).toStrictEqual(6);
+			}));
+
+		it.effect('$count embedded reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_36', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+				expect(count2).toStrictEqual([
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+				]);
+				expect(count3).toStrictEqual([
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+				]);
+			}));
+
+		it.effect('$count separate with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_37', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable, gt(countTestTable.id, 1));
+				expect(count).toStrictEqual(3);
+			}));
+
+		it.effect('$count embedded with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = pgTable('count_test_38', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+				]);
+			}));
+
+		it.effect('select distinct', () =>
+			Effect.gen(function*() {
+				const usersDistinctTable = pgTable('users_distinct_101', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+					age: integer('age').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersDistinctTable });
+
+				yield* db.insert(usersDistinctTable).values([
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+				]);
+				const users1 = yield* db.selectDistinct().from(usersDistinctTable).orderBy(
+					usersDistinctTable.id,
+					usersDistinctTable.name,
+				);
+				const users2 = yield* db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
+					usersDistinctTable.id,
+				);
+				const users3 = yield* db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
+					usersDistinctTable,
+				).orderBy(usersDistinctTable.name);
+				const users4 = yield* db.selectDistinctOn([usersDistinctTable.id, usersDistinctTable.age]).from(
+					usersDistinctTable,
+				).orderBy(usersDistinctTable.id, usersDistinctTable.age);
+
+				expect(users1).toEqual([
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+				]);
+
+				expect(users2).toHaveLength(2);
+				expect(users2[0]?.id).toBe(1);
+				expect(users2[1]?.id).toBe(2);
+
+				expect(users3).toHaveLength(2);
+				expect(users3[0]?.name).toBe('Jane');
+				expect(users3[1]?.name).toBe('John');
+
+				expect(users4).toEqual([
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+					{ id: 2, name: 'John', age: 25 },
+				]);
+			}));
+
+		it.effect('update with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_9', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('update with returning partial', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_10', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning({
+						id: users.id,
+						name: users.name,
+					});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'Jane' }]);
+			}));
+
+		it.effect('delete with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_11', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+					createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('delete with returning partial', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_12', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning({
+					id: users.id,
+					name: users.name,
+				});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('insert many', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_19', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning partial', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_20', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					});
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_20', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+					jsonb: jsonb('jsonb').$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement reuse', () =>
+			Effect.gen(function*() {
+				const usersTable = pgTable('users_35', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: boolean('verified').notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						verified: true,
+						name: sql.placeholder('name'),
+					})
+					.prepare('stmt2');
+
+				for (let i = 0; i < 10; i++) {
+					yield* stmt.execute({ name: `John ${i}` });
+				}
+
+				const result = yield* db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+						verified: usersTable.verified,
+					})
+					.from(usersTable);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John 0', verified: true },
+					{ id: 2, name: 'John 1', verified: true },
+					{ id: 3, name: 'John 2', verified: true },
+					{ id: 4, name: 'John 3', verified: true },
+					{ id: 5, name: 'John 4', verified: true },
+					{ id: 6, name: 'John 5', verified: true },
+					{ id: 7, name: 'John 6', verified: true },
+					{ id: 8, name: 'John 7', verified: true },
+					{ id: 9, name: 'John 8', verified: true },
+					{ id: 10, name: 'John 9', verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement with placeholder in .where', () =>
+			Effect.gen(function*() {
+				const usersTable = pgTable('users_36', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.prepare('stmt3');
+				const result = yield* stmt.execute({ id: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('prepared statement with placeholder in .limit', () =>
+			Effect.gen(function*() {
+				const usersTable = pgTable('users_37', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare('stmt_limit');
+
+				const result = yield* stmt.execute({ id: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('prepared statement with placeholder in .offset', () =>
+			Effect.gen(function*() {
+				const usersTable = pgTable('users_38', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.offset(sql.placeholder('offset'))
+					.prepare('stmt_offset');
+
+				const result = yield* stmt.execute({ offset: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			}));
+
+		it.effect('prepared statement built using $dynamic', () =>
+			Effect.gen(function*() {
+				const usersTable = pgTable('users_39', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				function withLimitOffset(qb: any) {
+					return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+				}
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.$dynamic();
+				withLimitOffset(stmt).prepare('stmt_limit');
+
+				const result = yield* stmt.execute({ limit: 1, offset: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('with ... select', () =>
+			Effect.gen(function*() {
+				const orders = pgTable('orders_55', {
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const regionalSales = db
+					.$with('regional_sales')
+					.as(
+						db
+							.select({
+								region: orders.region,
+								totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+							})
+							.from(orders)
+							.groupBy(orders.region),
+					);
+
+				const topRegions = db
+					.$with('top_regions')
+					.as(
+						db
+							.select({
+								region: regionalSales.region,
+							})
+							.from(regionalSales)
+							.where(
+								gt(
+									regionalSales.totalSales,
+									db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+								),
+							),
+					);
+
+				const result1 = yield* db
+					.with(regionalSales, topRegions)
+					.select({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})::int`,
+						productSales: sql<number>`sum(${orders.amount})::int`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result2 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})::int`,
+						productSales: sql<number>`sum(${orders.amount})::int`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result3 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinctOn([orders.region], {
+						region: orders.region,
+						productUnits: sql<number>`sum(${orders.quantity})::int`,
+						productSales: sql<number>`sum(${orders.amount})::int`,
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region)
+					.orderBy(orders.region);
+
+				expect(result1).toEqual([
+					{
+						region: 'Europe',
+						product: 'A',
+						productUnits: 3,
+						productSales: 30,
+					},
+					{
+						region: 'Europe',
+						product: 'B',
+						productUnits: 5,
+						productSales: 50,
+					},
+					{
+						region: 'US',
+						product: 'A',
+						productUnits: 7,
+						productSales: 70,
+					},
+					{
+						region: 'US',
+						product: 'B',
+						productUnits: 9,
+						productSales: 90,
+					},
+				]);
+				expect(result2).toEqual(result1);
+				expect(result3).toEqual([
+					{
+						region: 'Europe',
+						productUnits: 8,
+						productSales: 80,
+					},
+					{
+						region: 'US',
+						productUnits: 16,
+						productSales: 160,
+					},
+				]);
+			}));
+
+		it.effect('with ... update', () =>
+			Effect.gen(function*() {
+				const products = pgTable('products_56', {
+					id: serial('id').primaryKey(),
+					price: numeric('price').notNull(),
+					cheap: boolean('cheap').notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { products });
+
+				yield* db.insert(products).values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
+
+				const averagePrice = db
+					.$with('average_price')
+					.as(
+						db
+							.select({
+								value: sql`avg(${products.price})`.as('value'),
+							})
+							.from(products),
+					);
+
+				const result = yield* db
+					.with(averagePrice)
+					.update(products)
+					.set({
+						cheap: true,
+					})
+					.where(lt(products.price, sql`(select * from ${averagePrice})`))
+					.returning({
+						id: products.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 1 },
+					{ id: 4 },
+					{ id: 5 },
+				]);
+			}));
+
+		it.effect('with ... insert', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_57', {
+					username: text('username').notNull(),
+					admin: boolean('admin').notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const userCount = db
+					.$with('user_count')
+					.as(
+						db
+							.select({
+								value: sql`count(*)`.as('value'),
+							})
+							.from(users),
+					);
+
+				const result = yield* db
+					.with(userCount)
+					.insert(users)
+					.values([
+						{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+					])
+					.returning({
+						admin: users.admin,
+					});
+
+				expect(result).toEqual([{ admin: true }]);
+			}));
+
+		it.effect('with ... delete', () =>
+			Effect.gen(function*() {
+				const orders = pgTable('orders_58', {
+					id: serial('id').primaryKey(),
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const averageAmount = db
+					.$with('average_amount')
+					.as(
+						db
+							.select({
+								value: sql`avg(${orders.amount})`.as('value'),
+							})
+							.from(orders),
+					);
+
+				const result = yield* db
+					.with(averageAmount)
+					.delete(orders)
+					.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+					.returning({
+						id: orders.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 6 },
+					{ id: 7 },
+					{ id: 8 },
+				]);
+			}));
+
+		it.effect('partial join with alias', () =>
+			Effect.gen(function*() {
+				const users = pgTable('users_29', {
+					id: serial('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customerAlias = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user: {
+							id: users.id,
+							name: users.name,
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			}));
+
+		it.effect('full join with alias', () =>
+			Effect.gen(function*() {
+				const users = pgTable('prefixed_users_30', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(users)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([{
+					prefixed_users_30: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('select from alias', () =>
+			Effect.gen(function*() {
+				const users = pgTable('prefixed_users_31', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const user = alias(users, 'user');
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(user)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(user.id, 10));
+
+				expect(result).toEqual([{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('set operations (mixed) from query builder with subquery', () =>
+			Effect.gen(function*() {
+				const cities2Table = pgTable('cities_1', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = pgTable('users2_1', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const sq = db
+					.select()
+					.from(cities2Table).where(gt(cities2Table.id, 1)).as('sq');
+
+				const result = yield* db
+					.select()
+					.from(cities2Table).except(
+						({ unionAll }) =>
+							unionAll(
+								db.select().from(sq),
+								db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+							),
+					);
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* db
+						.select()
+						.from(cities2Table).except(
+							({ unionAll }) =>
+								unionAll(
+									db
+										.select({ name: cities2Table.name, id: cities2Table.id })
+										.from(cities2Table).where(gt(cities2Table.id, 1)),
+									db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+								),
+						);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('set operations (mixed all) as function', () =>
+			Effect.gen(function*() {
+				const cities2Table = pgTable('cities_2', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = pgTable('users2_2', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const result = yield* union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 7)),
+					),
+					db
+						.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+				).orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(6);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+					{ id: 8, name: 'Sally' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table).where(gte(users2Table.id, 5)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table).where(eq(users2Table.id, 7)),
+						),
+						db
+							.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+					);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('custom EffectLogger override - user provided logger takes precedence over default', () =>
+			Effect.gen(function*() {
+				const loggedQueries: Array<{ query: string; params: unknown[] }> = [];
+
+				const customLogger: EffectLoggerShape = {
+					logQuery: (query: string, params: unknown[]) =>
+						Effect.sync(() => {
+							loggedQueries.push({ query, params });
+						}),
+				};
+				const customLoggerLayer = Layer.succeed(EffectLogger, customLogger);
+
+				const db = yield* PgDrizzle.make({ relations }).pipe(
+					Effect.provide(customLoggerLayer),
+					Effect.provide(PgDrizzle.DefaultServices),
+				);
+
+				const users = pgTable('users_custom_logger', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users);
+
+				expect(loggedQueries.length).toBeGreaterThanOrEqual(2);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('insert'))).toBe(true);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('select'))).toBe(true);
+			}));
+
+		it.effect('custom EffectCache override - user provided cache takes precedence over default', () =>
+			Effect.gen(function*() {
+				const cacheOperations = yield* Ref.make<Array<{ op: 'get' | 'put' | 'mutate'; key?: string }>>([]);
+
+				const customCacheService: EffectCacheShape = {
+					strategy: () => 'all' as const,
+					get: (key: string, _tables: string[], _isTag: boolean, _isAutoInvalidate?: boolean) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'get' as const, key }]);
+							// oxlint-disable-next-line no-useless-undefined
+							return undefined;
+						}),
+					put: (key: string, _response: any, _tables: string[], _isTag: boolean, _config?: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'put' as const, key }]);
+						}),
+					onMutate: (_params: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'mutate' as const }]);
+						}),
+				};
+				const customCacheLayer = Layer.succeed(EffectCache, customCacheService);
+
+				const db = yield* PgDrizzle.make({ relations }).pipe(
+					Effect.provide(customCacheLayer),
+					Effect.provide(PgDrizzle.DefaultServices),
+				);
+
+				const users = pgTable('users_custom_cache', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users).$withCache();
+
+				const ops = yield* Ref.get(cacheOperations);
+				expect(ops.some((o) => o.op === 'mutate')).toBe(true);
+				expect(ops.some((o) => o.op === 'get')).toBe(true);
+			}));
+
+		it.effect('makeWithDefaults - convenience function that includes DefaultServices', () =>
+			Effect.gen(function*() {
+				const db = yield* PgDrizzle.makeWithDefaults({ relations });
+
+				const users = pgTable('users_make_with_defaults', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'Alice' });
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, name: 'Alice' }]);
+			}));
+
+		it.effect(
+			'all types ~codecs~',
+			() =>
+				Effect.gen(function*() {
+					const en = pgEnum('en_48', ['enVal1', 'enVal2']);
+					const allTypesTable = pgTable('all_types_cdc_ef', {
+						serial: serial('serial'),
+						bigserial: bigserial('bigserial', {
+							mode: 'bigint',
+						}).notNull(),
+						bigserialnum: bigserial('bigserialnum', {
+							mode: 'number',
+						}).notNull(),
+						int: integer('int').notNull(),
+						bigint: bigint('bigint', {
+							mode: 'bigint',
+						}).notNull(),
+						bigintnum: bigint('bigintnum', {
+							mode: 'number',
+						}).notNull(),
+						bigintstr: bigint('bigintstr', {
+							mode: 'string',
+						}).notNull(),
+						bool: boolean('bool').notNull(),
+						bytea: bytea('bytea').notNull(),
+						char: char('char').notNull(),
+						cidr: cidr('cidr').notNull(),
+						date: date('date', {
+							mode: 'date',
+						}).notNull(),
+						datestr: date('datestr', {
+							mode: 'string',
+						}).notNull(),
+						double: doublePrecision('double').notNull(),
+						enum: en('enum').notNull(),
+						inet: inet('inet').notNull(),
+						interval: interval('interval').notNull(),
+						json: json('json').notNull(),
+						jsonb: jsonb('jsonb').notNull(),
+						json1: json('json1').notNull(),
+						jsonb1: jsonb('jsonb1').notNull(),
+						json2: json('json2').notNull(),
+						jsonb2: jsonb('jsonb2').notNull(),
+						json3: json('json3').notNull(),
+						jsonb3: jsonb('jsonb3').notNull(),
+						line: line('line', {
+							mode: 'abc',
+						}).notNull(),
+						linetuple: line('linetuple', {
+							mode: 'tuple',
+						}).notNull(),
+						macaddr: macaddr('macaddr').notNull(),
+						macaddr8: macaddr8('macaddr8').notNull(),
+						numeric: numeric('numeric').notNull(),
+						numericnum: numeric('numericnum', {
+							mode: 'number',
+						}).notNull(),
+						numericbig: numeric('numericbig', {
+							mode: 'bigint',
+						}).notNull(),
+						point: point('point', {
+							mode: 'xy',
+						}).notNull(),
+						pointtuple: point('pointtuple', {
+							mode: 'tuple',
+						}).notNull(),
+						real: real('real').notNull(),
+						smallint: smallint('smallint').notNull(),
+						smallserial: smallserial('smallserial').notNull(),
+						text: text('text').notNull(),
+						time: time('time').notNull(),
+						timestamp: timestamp('timestamp', {
+							mode: 'date',
+						}).notNull(),
+						timestampTz: timestamp('timestampTz', {
+							mode: 'date',
+							withTimezone: true,
+						}).notNull(),
+						timestampstr: timestamp('timestampstr', {
+							mode: 'string',
+						}).notNull(),
+						timestampTzstr: timestamp('timestampTzstr', {
+							mode: 'string',
+							withTimezone: true,
+						}).notNull(),
+						uuid: uuid('uuid').notNull(),
+						varchar: varchar('varchar').notNull(),
+						arrint: integer('arrint').array().notNull(),
+						arrbigint: bigint('arrbigint', {
+							mode: 'bigint',
+						}).array().notNull(),
+						arrbigintnum: bigint('arrbigintnum', {
+							mode: 'number',
+						}).array().notNull(),
+						arrbigintstr: bigint('arrbigintstr', {
+							mode: 'string',
+						}).array().notNull(),
+						arrbool: boolean('arrbool').array().notNull(),
+						arrbytea: bytea('arrbytea').array().notNull(),
+						mtxbytea: bytea('mtxbytea').array('[][]').notNull(),
+						arrchar: char('arrchar').array().notNull(),
+						arrcidr: cidr('arrcidr').array().notNull(),
+						arrdate: date('arrdate', {
+							mode: 'date',
+						}).array().notNull(),
+						arrdatestr: date('arrdatestr', {
+							mode: 'string',
+						}).array().notNull(),
+						arrdouble: doublePrecision('arrdouble').array().notNull(),
+						arrenum: en('arrenum').array().notNull(),
+						arrinet: inet('arrinet').array().notNull(),
+						arrinterval: interval('arrinterval').array().notNull(),
+						arrjson: json('arrjson').array().notNull(),
+						arrjsonb: jsonb('arrjsonb').array().notNull(),
+						arrjson1: json('arrjson1').array().notNull(),
+						arrjsonb1: jsonb('arrjsonb1').array().notNull(),
+						arrjson2: json('arrjson2').array().notNull(),
+						arrjsonb2: jsonb('arrjsonb2').array().notNull(),
+						arrjson3: json('arrjson3').array().notNull(),
+						arrjsonb3: jsonb('arrjsonb3').array().notNull(),
+						arrline: line('arrline', {
+							mode: 'abc',
+						}).array().notNull(),
+						arrlinetuple: line('arrlinetuple', {
+							mode: 'tuple',
+						}).array().notNull(),
+						arrmacaddr: macaddr('arrmacaddr').array().notNull(),
+						arrmacaddr8: macaddr8('arrmacaddr8').array().notNull(),
+						arrnumeric: numeric('arrnumeric').array().notNull(),
+						arrnumericnum: numeric('arrnumericnum', { mode: 'number' }).array().notNull(),
+						arrnumericbig: numeric('arrnumericbig', { mode: 'bigint' }).array().notNull(),
+						arrpoint: point('arrpoint', {
+							mode: 'xy',
+						}).array().notNull(),
+						arrpointtuple: point('arrpointtuple', {
+							mode: 'tuple',
+						}).array().notNull(),
+						arrreal: real('arrreal').array().notNull(),
+						arrsmallint: smallint('arrsmallint').array().notNull(),
+						arrtext: text('arrtext').array().notNull(),
+						arrtime: time('arrtime').array().notNull(),
+						arrtimestamp: timestamp('arrtimestamp', {
+							mode: 'date',
+						}).array().notNull(),
+						arrtimestampTz: timestamp('arrtimestampTz', {
+							mode: 'date',
+							withTimezone: true,
+						}).array().notNull(),
+						arrtimestampstr: timestamp('arrtimestampstr', {
+							mode: 'string',
+						}).array().notNull(),
+						arrtimestampTzstr: timestamp('arrtimestampTzstr', {
+							mode: 'string',
+							withTimezone: true,
+						}).array().notNull(),
+						arruuid: uuid('arruuid').array().notNull(),
+						arrvarchar: varchar('arrvarchar').array().notNull(),
+					});
+
+					const db = yield* DB;
+					yield* push(db, {
+						en,
+						allTypesTable,
+					});
+
+					type ExpectedType = {
+						serial: number;
+						bigserial: bigint;
+						bigserialnum: number;
+						int: number;
+						bigint: bigint;
+						bigintnum: number;
+						bigintstr: string;
+						bool: boolean;
+						bytea: Buffer;
+						char: string;
+						cidr: string;
+						date: Date;
+						datestr: string;
+						double: number;
+						enum: 'enVal1' | 'enVal2';
+						inet: string;
+						interval: string;
+						json: unknown;
+						jsonb: unknown;
+						json1: unknown;
+						jsonb1: unknown;
+						json2: unknown;
+						jsonb2: unknown;
+						json3: unknown;
+						jsonb3: unknown;
+						line: { a: number; b: number; c: number };
+						linetuple: [number, number, number];
+						macaddr: string;
+						macaddr8: string;
+						numeric: string;
+						numericnum: number;
+						numericbig: bigint;
+						point: { x: number; y: number };
+						pointtuple: [number, number];
+						real: number;
+						smallint: number;
+						smallserial: number;
+						text: string;
+						time: string;
+						timestamp: Date;
+						timestampTz: Date;
+						timestampstr: string;
+						timestampTzstr: string;
+						uuid: string;
+						varchar: string;
+						arrint: number[];
+						arrbigint: bigint[];
+						arrbigintnum: number[];
+						arrbigintstr: string[];
+						arrbool: boolean[];
+						arrbytea: (Buffer)[];
+						mtxbytea: (Buffer)[][];
+						arrchar: string[];
+						arrcidr: string[];
+						arrdate: Date[];
+						arrdatestr: string[];
+						arrdouble: number[];
+						arrenum: ('enVal1' | 'enVal2')[];
+						arrinet: string[];
+						arrinterval: string[];
+						arrjson: unknown[];
+						arrjsonb: unknown[];
+						arrjson1: unknown[];
+						arrjsonb1: unknown[];
+						arrjson2: unknown[];
+						arrjsonb2: unknown[];
+						arrjson3: unknown[];
+						arrjsonb3: unknown[];
+						arrline: { a: number; b: number; c: number }[];
+						arrlinetuple: [number, number, number][];
+						arrmacaddr: string[];
+						arrmacaddr8: string[];
+						arrnumeric: string[];
+						arrnumericnum: number[];
+						arrnumericbig: bigint[];
+						arrpoint: { x: number; y: number }[];
+						arrpointtuple: [number, number][];
+						arrreal: number[];
+						arrsmallint: number[];
+						arrtext: string[];
+						arrtime: string[];
+						arrtimestamp: Date[];
+						arrtimestampTz: Date[];
+						arrtimestampstr: string[];
+						arrtimestampTzstr: string[];
+						arruuid: string[];
+						arrvarchar: string[];
+					};
+
+					const testData: ExpectedType = {
+						serial: 1,
+						bigserial: 5044565289845416380n,
+						bigserialnum: 9007199254740991,
+						int: 621,
+						bigint: 5044565289845416380n,
+						bigintnum: 9007199254740991,
+						bigintstr: '5044565289845416380',
+						bool: true,
+						bytea: Buffer.from('BYTES'),
+						char: 'c',
+						cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+						date: new Date('2025-03-12'),
+						datestr: '2025-03-12',
+						double: 15.35325689124218,
+						enum: 'enVal1',
+						inet: '192.168.0.1/24',
+						interval: '-2 mons',
+						json: { str: 'strval', arr: ['str', 10] },
+						jsonb: { arr: ['strb', 11], str: 'strvalb' },
+						json1: [{ key: 'value', num: 7 }, 'v', '11', 5],
+						jsonb1: [{ key: 'value', num: 8 }, 'x', '10', 3],
+						json2: 5,
+						jsonb2: 7,
+						json3: '5',
+						jsonb3: '7',
+						line: { a: 1, b: 2, c: 3 },
+						linetuple: [1, 2, 3],
+						macaddr: '08:00:2b:01:02:03',
+						macaddr8: '08:00:2b:01:02:03:04:05',
+						numeric: '5044565289845416380',
+						numericnum: 9007199254740991,
+						numericbig: 5044565289845416380n,
+						point: { x: 24.5, y: 49.6 },
+						pointtuple: [24.5, 49.6],
+						real: 1.048596,
+						smallint: 10,
+						smallserial: 15,
+						text: 'TEXT STRING',
+						time: '13:59:28',
+						timestamp: new Date('2025-03-12 01:32:41.623'),
+						timestampTz: new Date('2025-03-12 01:32:41.623+00'),
+						timestampstr: '2025-03-12 01:32:41.623',
+						timestampTzstr: '2025-03-12 01:32:41.623+00',
+						uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+						varchar: 'C4-',
+						arrint: [621],
+						arrbigint: [5044565289845416380n],
+						arrbigintnum: [9007199254740991],
+						arrbigintstr: ['5044565289845416380'],
+						arrbool: [true],
+						arrbytea: [Buffer.from('BYTES')],
+						mtxbytea: [[Buffer.from('BYTES'), Buffer.from('BYTES2')], [
+							Buffer.from('OTHERBYTES'),
+							Buffer.from('OTHERBYTES2'),
+						]],
+						arrchar: ['c'],
+						arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+						arrdate: [new Date('2025-03-12')],
+						arrdatestr: ['2025-03-12'],
+						arrdouble: [15.35325689124218],
+						arrenum: ['enVal1'],
+						arrinet: ['192.168.0.1/24'],
+						arrinterval: ['-2 mons'],
+						arrjson: [{ str: 'strval', arr: ['str', 10] }],
+						arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+						arrjson1: [[{ key: 'value', num: 7 }, 'v', '11', 5]],
+						arrjsonb1: [[{ key: 'value', num: 8 }, 'x', '10', 3]],
+						arrjson2: [5],
+						arrjsonb2: [7],
+						arrjson3: ['5'],
+						arrjsonb3: ['7'],
+						arrline: [{ a: 1, b: 2, c: 3 }],
+						arrlinetuple: [[1, 2, 3]],
+						arrmacaddr: ['08:00:2b:01:02:03'],
+						arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+						arrnumeric: ['5044565289845416380'],
+						arrnumericnum: [9007199254740991],
+						arrnumericbig: [5044565289845416380n],
+						arrpoint: [{ x: 24.5, y: 49.6 }],
+						arrpointtuple: [[24.5, 49.6]],
+						arrreal: [1.048596],
+						arrsmallint: [10],
+						arrtext: ['TEXT STRING'],
+						arrtime: ['13:59:28'],
+						arrtimestamp: [new Date('2025-03-12 01:32:41.623')],
+						arrtimestampTz: [new Date('2025-03-12 01:32:41.623+00')],
+						arrtimestampstr: ['2025-03-12 01:32:41.623'],
+						arrtimestampTzstr: ['2025-03-12 01:32:41.623+00'],
+						arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+						arrvarchar: ['C4-'],
+					};
+
+					yield* db.insert(allTypesTable).values(testData);
+					const session = (<any> db).session as PgEffectSession;
+
+					const queryRes = yield* session.objects<ExpectedType>(db.select().from(allTypesTable).getSQL()).pipe(
+						Effect.map((e) =>
+							normalizeDataWithDbCodecs({
+								db,
+								columns: getColumns(allTypesTable),
+								data: e as ExpectedType[],
+								mode: 'query',
+							})[0]
+						),
+					);
+
+					const relDb = yield* createDB({ allTypesTable }, (r) => ({
+						allTypesTable: {
+							self: r.many.allTypesTable({
+								from: r.allTypesTable.serial,
+								to: r.allTypesTable.serial,
+							}),
+						},
+					}));
+
+					const { relationRes, rootRes } = yield* session.objects<ExpectedType & { self: ExpectedType[] }>(
+						relDb.query.allTypesTable.findFirst({
+							with: {
+								self: true,
+							},
+						}).getSQL(),
+					).pipe(Effect.map((e) => {
+						const { self: relationRaw, ...rootRaw } = e[0]!;
+
+						return {
+							relationRes: normalizeDataWithDbCodecs({
+								db,
+								columns: getColumns(allTypesTable),
+								data: relationRaw as ExpectedType[],
+								mode: 'json',
+							})[0]!,
+							rootRes: normalizeDataWithDbCodecs({
+								db,
+								columns: getColumns(allTypesTable),
+								data: [rootRaw],
+								mode: 'query',
+							})[0]!,
+						};
+					}));
+
+					expect(queryRes).toStrictEqual(testData);
+					expect(relationRes).toStrictEqual(testData);
+					expect(rootRes).toStrictEqual(testData);
+
+					// ---- numbers ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'int ∪ int': allTypesTable.int.as('int ∪ int'),
+								'int ∪ smallint': allTypesTable.int.as('int ∪ smallint'),
+								'int ∪ double': allTypesTable.int.as('int ∪ double'),
+								'int ∪ real': allTypesTable.int.as('int ∪ real'),
+								'int ∪ smallserial': allTypesTable.int.as('int ∪ smallserial'),
+								'int ∪ serial': allTypesTable.int.as('int ∪ serial'),
+								'int ∪ bigserialnum': allTypesTable.int.as('int ∪ bigserialnum'),
+								'int ∪ bigintnum': allTypesTable.int.as('int ∪ bigintnum'),
+								'int ∪ numericnum': allTypesTable.int.as('int ∪ numericnum'),
+								'smallint ∪ int': allTypesTable.smallint.as('smallint ∪ int'),
+								'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+								'smallint ∪ double': allTypesTable.smallint.as('smallint ∪ double'),
+								'smallint ∪ real': allTypesTable.smallint.as('smallint ∪ real'),
+								'smallint ∪ smallserial': allTypesTable.smallint.as('smallint ∪ smallserial'),
+								'smallint ∪ serial': allTypesTable.smallint.as('smallint ∪ serial'),
+								'smallint ∪ bigserialnum': allTypesTable.smallint.as('smallint ∪ bigserialnum'),
+								'smallint ∪ bigintnum': allTypesTable.smallint.as('smallint ∪ bigintnum'),
+								'smallint ∪ numericnum': allTypesTable.smallint.as('smallint ∪ numericnum'),
+								'double ∪ int': allTypesTable.double.as('double ∪ int'),
+								'double ∪ smallint': allTypesTable.double.as('double ∪ smallint'),
+								'double ∪ double': allTypesTable.double.as('double ∪ double'),
+								'double ∪ real': allTypesTable.double.as('double ∪ real'),
+								'double ∪ smallserial': allTypesTable.double.as('double ∪ smallserial'),
+								'double ∪ serial': allTypesTable.double.as('double ∪ serial'),
+								'double ∪ bigserialnum': allTypesTable.double.as('double ∪ bigserialnum'),
+								'double ∪ bigintnum': allTypesTable.double.as('double ∪ bigintnum'),
+								'double ∪ numericnum': allTypesTable.double.as('double ∪ numericnum'),
+								'real ∪ int': allTypesTable.real.as('real ∪ int'),
+								'real ∪ smallint': allTypesTable.real.as('real ∪ smallint'),
+								'real ∪ double': allTypesTable.real.as('real ∪ double'),
+								'real ∪ real': allTypesTable.real.as('real ∪ real'),
+								'real ∪ smallserial': allTypesTable.real.as('real ∪ smallserial'),
+								'real ∪ serial': allTypesTable.real.as('real ∪ serial'),
+								'smallserial ∪ int': allTypesTable.smallserial.as('smallserial ∪ int'),
+								'smallserial ∪ smallint': allTypesTable.smallserial.as('smallserial ∪ smallint'),
+								'smallserial ∪ double': allTypesTable.smallserial.as('smallserial ∪ double'),
+								'smallserial ∪ real': allTypesTable.smallserial.as('smallserial ∪ real'),
+								'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+								'smallserial ∪ serial': allTypesTable.smallserial.as('smallserial ∪ serial'),
+								'smallserial ∪ bigserialnum': allTypesTable.smallserial.as('smallserial ∪ bigserialnum'),
+								'smallserial ∪ bigintnum': allTypesTable.smallserial.as('smallserial ∪ bigintnum'),
+								'smallserial ∪ numericnum': allTypesTable.smallserial.as('smallserial ∪ numericnum'),
+								'serial ∪ int': allTypesTable.serial.as('serial ∪ int'),
+								'serial ∪ smallint': allTypesTable.serial.as('serial ∪ smallint'),
+								'serial ∪ double': allTypesTable.serial.as('serial ∪ double'),
+								'serial ∪ real': allTypesTable.serial.as('serial ∪ real'),
+								'serial ∪ smallserial': allTypesTable.serial.as('serial ∪ smallserial'),
+								'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+								'serial ∪ bigserialnum': allTypesTable.serial.as('serial ∪ bigserialnum'),
+								'serial ∪ bigintnum': allTypesTable.serial.as('serial ∪ bigintnum'),
+								'serial ∪ numericnum': allTypesTable.serial.as('serial ∪ numericnum'),
+								'bigserialnum ∪ int': allTypesTable.bigserialnum.as('bigserialnum ∪ int'),
+								'bigserialnum ∪ smallint': allTypesTable.bigserialnum.as('bigserialnum ∪ smallint'),
+								'bigserialnum ∪ double': allTypesTable.bigserialnum.as('bigserialnum ∪ double'),
+								'bigserialnum ∪ smallserial': allTypesTable.bigserialnum.as('bigserialnum ∪ smallserial'),
+								'bigserialnum ∪ serial': allTypesTable.bigserialnum.as('bigserialnum ∪ serial'),
+								'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+								'bigserialnum ∪ bigintnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigintnum'),
+								'bigserialnum ∪ numericnum': allTypesTable.bigserialnum.as('bigserialnum ∪ numericnum'),
+								'bigintnum ∪ int': allTypesTable.bigintnum.as('bigintnum ∪ int'),
+								'bigintnum ∪ smallint': allTypesTable.bigintnum.as('bigintnum ∪ smallint'),
+								'bigintnum ∪ double': allTypesTable.bigintnum.as('bigintnum ∪ double'),
+								'bigintnum ∪ smallserial': allTypesTable.bigintnum.as('bigintnum ∪ smallserial'),
+								'bigintnum ∪ serial': allTypesTable.bigintnum.as('bigintnum ∪ serial'),
+								'bigintnum ∪ bigserialnum': allTypesTable.bigintnum.as('bigintnum ∪ bigserialnum'),
+								'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+								'bigintnum ∪ numericnum': allTypesTable.bigintnum.as('bigintnum ∪ numericnum'),
+								'numericnum ∪ int': allTypesTable.numericnum.as('numericnum ∪ int'),
+								'numericnum ∪ smallint': allTypesTable.numericnum.as('numericnum ∪ smallint'),
+								'numericnum ∪ double': allTypesTable.numericnum.as('numericnum ∪ double'),
+								'numericnum ∪ smallserial': allTypesTable.numericnum.as('numericnum ∪ smallserial'),
+								'numericnum ∪ serial': allTypesTable.numericnum.as('numericnum ∪ serial'),
+								'numericnum ∪ bigserialnum': allTypesTable.numericnum.as('numericnum ∪ bigserialnum'),
+								'numericnum ∪ bigintnum': allTypesTable.numericnum.as('numericnum ∪ bigintnum'),
+								'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+							}).from(allTypesTable),
+							db.select({
+								'int ∪ int': allTypesTable.int.as('int ∪ int'),
+								'int ∪ smallint': allTypesTable.smallint.as('int ∪ smallint'),
+								'int ∪ double': allTypesTable.double.as('int ∪ double'),
+								'int ∪ real': allTypesTable.real.as('int ∪ real'),
+								'int ∪ smallserial': allTypesTable.smallserial.as('int ∪ smallserial'),
+								'int ∪ serial': allTypesTable.serial.as('int ∪ serial'),
+								'int ∪ bigserialnum': allTypesTable.bigserialnum.as('int ∪ bigserialnum'),
+								'int ∪ bigintnum': allTypesTable.bigintnum.as('int ∪ bigintnum'),
+								'int ∪ numericnum': allTypesTable.numericnum.as('int ∪ numericnum'),
+								'smallint ∪ int': allTypesTable.int.as('smallint ∪ int'),
+								'smallint ∪ smallint': allTypesTable.smallint.as('smallint ∪ smallint'),
+								'smallint ∪ double': allTypesTable.double.as('smallint ∪ double'),
+								'smallint ∪ real': allTypesTable.real.as('smallint ∪ real'),
+								'smallint ∪ smallserial': allTypesTable.smallserial.as('smallint ∪ smallserial'),
+								'smallint ∪ serial': allTypesTable.serial.as('smallint ∪ serial'),
+								'smallint ∪ bigserialnum': allTypesTable.bigserialnum.as('smallint ∪ bigserialnum'),
+								'smallint ∪ bigintnum': allTypesTable.bigintnum.as('smallint ∪ bigintnum'),
+								'smallint ∪ numericnum': allTypesTable.numericnum.as('smallint ∪ numericnum'),
+								'double ∪ int': allTypesTable.int.as('double ∪ int'),
+								'double ∪ smallint': allTypesTable.smallint.as('double ∪ smallint'),
+								'double ∪ double': allTypesTable.double.as('double ∪ double'),
+								'double ∪ real': allTypesTable.real.as('double ∪ real'),
+								'double ∪ smallserial': allTypesTable.smallserial.as('double ∪ smallserial'),
+								'double ∪ serial': allTypesTable.serial.as('double ∪ serial'),
+								'double ∪ bigserialnum': allTypesTable.bigserialnum.as('double ∪ bigserialnum'),
+								'double ∪ bigintnum': allTypesTable.bigintnum.as('double ∪ bigintnum'),
+								'double ∪ numericnum': allTypesTable.numericnum.as('double ∪ numericnum'),
+								'real ∪ int': allTypesTable.int.as('real ∪ int'),
+								'real ∪ smallint': allTypesTable.smallint.as('real ∪ smallint'),
+								'real ∪ double': allTypesTable.double.as('real ∪ double'),
+								'real ∪ real': allTypesTable.real.as('real ∪ real'),
+								'real ∪ smallserial': allTypesTable.smallserial.as('real ∪ smallserial'),
+								'real ∪ serial': allTypesTable.serial.as('real ∪ serial'),
+								'smallserial ∪ int': allTypesTable.int.as('smallserial ∪ int'),
+								'smallserial ∪ smallint': allTypesTable.smallint.as('smallserial ∪ smallint'),
+								'smallserial ∪ double': allTypesTable.double.as('smallserial ∪ double'),
+								'smallserial ∪ real': allTypesTable.real.as('smallserial ∪ real'),
+								'smallserial ∪ smallserial': allTypesTable.smallserial.as('smallserial ∪ smallserial'),
+								'smallserial ∪ serial': allTypesTable.serial.as('smallserial ∪ serial'),
+								'smallserial ∪ bigserialnum': allTypesTable.bigserialnum.as('smallserial ∪ bigserialnum'),
+								'smallserial ∪ bigintnum': allTypesTable.bigintnum.as('smallserial ∪ bigintnum'),
+								'smallserial ∪ numericnum': allTypesTable.numericnum.as('smallserial ∪ numericnum'),
+								'serial ∪ int': allTypesTable.int.as('serial ∪ int'),
+								'serial ∪ smallint': allTypesTable.smallint.as('serial ∪ smallint'),
+								'serial ∪ double': allTypesTable.double.as('serial ∪ double'),
+								'serial ∪ real': allTypesTable.real.as('serial ∪ real'),
+								'serial ∪ smallserial': allTypesTable.smallserial.as('serial ∪ smallserial'),
+								'serial ∪ serial': allTypesTable.serial.as('serial ∪ serial'),
+								'serial ∪ bigserialnum': allTypesTable.bigserialnum.as('serial ∪ bigserialnum'),
+								'serial ∪ bigintnum': allTypesTable.bigintnum.as('serial ∪ bigintnum'),
+								'serial ∪ numericnum': allTypesTable.numericnum.as('serial ∪ numericnum'),
+								'bigserialnum ∪ int': allTypesTable.int.as('bigserialnum ∪ int'),
+								'bigserialnum ∪ smallint': allTypesTable.smallint.as('bigserialnum ∪ smallint'),
+								'bigserialnum ∪ double': allTypesTable.double.as('bigserialnum ∪ double'),
+								'bigserialnum ∪ smallserial': allTypesTable.smallserial.as('bigserialnum ∪ smallserial'),
+								'bigserialnum ∪ serial': allTypesTable.serial.as('bigserialnum ∪ serial'),
+								'bigserialnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigserialnum ∪ bigserialnum'),
+								'bigserialnum ∪ bigintnum': allTypesTable.bigintnum.as('bigserialnum ∪ bigintnum'),
+								'bigserialnum ∪ numericnum': allTypesTable.numericnum.as('bigserialnum ∪ numericnum'),
+								'bigintnum ∪ int': allTypesTable.int.as('bigintnum ∪ int'),
+								'bigintnum ∪ smallint': allTypesTable.smallint.as('bigintnum ∪ smallint'),
+								'bigintnum ∪ double': allTypesTable.double.as('bigintnum ∪ double'),
+								'bigintnum ∪ smallserial': allTypesTable.smallserial.as('bigintnum ∪ smallserial'),
+								'bigintnum ∪ serial': allTypesTable.serial.as('bigintnum ∪ serial'),
+								'bigintnum ∪ bigserialnum': allTypesTable.bigserialnum.as('bigintnum ∪ bigserialnum'),
+								'bigintnum ∪ bigintnum': allTypesTable.bigintnum.as('bigintnum ∪ bigintnum'),
+								'bigintnum ∪ numericnum': allTypesTable.numericnum.as('bigintnum ∪ numericnum'),
+								'numericnum ∪ int': allTypesTable.int.as('numericnum ∪ int'),
+								'numericnum ∪ smallint': allTypesTable.smallint.as('numericnum ∪ smallint'),
+								'numericnum ∪ double': allTypesTable.double.as('numericnum ∪ double'),
+								'numericnum ∪ smallserial': allTypesTable.smallserial.as('numericnum ∪ smallserial'),
+								'numericnum ∪ serial': allTypesTable.serial.as('numericnum ∪ serial'),
+								'numericnum ∪ bigserialnum': allTypesTable.bigserialnum.as('numericnum ∪ bigserialnum'),
+								'numericnum ∪ bigintnum': allTypesTable.bigintnum.as('numericnum ∪ bigintnum'),
+								'numericnum ∪ numericnum': allTypesTable.numericnum.as('numericnum ∪ numericnum'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'int ∪ int': 621,
+							'int ∪ smallint': 621,
+							'int ∪ double': 621,
+							'int ∪ real': 621,
+							'int ∪ smallserial': 621,
+							'int ∪ serial': 621,
+							'int ∪ bigserialnum': 621,
+							'int ∪ bigintnum': 621,
+							'int ∪ numericnum': 621,
+							'smallint ∪ int': 10,
+							'smallint ∪ smallint': 10,
+							'smallint ∪ double': 10,
+							'smallint ∪ real': 10,
+							'smallint ∪ smallserial': 10,
+							'smallint ∪ serial': 10,
+							'smallint ∪ bigserialnum': 10,
+							'smallint ∪ bigintnum': 10,
+							'smallint ∪ numericnum': 10,
+							'double ∪ int': 15.35325689124218,
+							'double ∪ smallint': 15.35325689124218,
+							'double ∪ double': 15.35325689124218,
+							'double ∪ real': 15.35325689124218,
+							'double ∪ smallserial': 15.35325689124218,
+							'double ∪ serial': 15.35325689124218,
+							'double ∪ bigserialnum': 15.35325689124218,
+							'double ∪ bigintnum': 15.35325689124218,
+							'double ∪ numericnum': 15.35325689124218,
+							'real ∪ int': 1.048596,
+							'real ∪ smallint': 1.048596,
+							'real ∪ double': 1.0485960245132446,
+							'real ∪ real': 1.048596,
+							'real ∪ smallserial': 1.048596,
+							'real ∪ serial': 1.048596,
+							'smallserial ∪ int': 15,
+							'smallserial ∪ smallint': 15,
+							'smallserial ∪ double': 15,
+							'smallserial ∪ real': 15,
+							'smallserial ∪ smallserial': 15,
+							'smallserial ∪ serial': 15,
+							'smallserial ∪ bigserialnum': 15,
+							'smallserial ∪ bigintnum': 15,
+							'smallserial ∪ numericnum': 15,
+							'serial ∪ int': 1,
+							'serial ∪ smallint': 1,
+							'serial ∪ double': 1,
+							'serial ∪ real': 1,
+							'serial ∪ smallserial': 1,
+							'serial ∪ serial': 1,
+							'serial ∪ bigserialnum': 1,
+							'serial ∪ bigintnum': 1,
+							'serial ∪ numericnum': 1,
+							'bigserialnum ∪ int': 9007199254740991,
+							'bigserialnum ∪ smallint': 9007199254740991,
+							'bigserialnum ∪ double': 9007199254740991,
+							'bigserialnum ∪ smallserial': 9007199254740991,
+							'bigserialnum ∪ serial': 9007199254740991,
+							'bigserialnum ∪ bigserialnum': 9007199254740991,
+							'bigserialnum ∪ bigintnum': 9007199254740991,
+							'bigserialnum ∪ numericnum': 9007199254740991,
+							'bigintnum ∪ int': 9007199254740991,
+							'bigintnum ∪ smallint': 9007199254740991,
+							'bigintnum ∪ double': 9007199254740991,
+							'bigintnum ∪ smallserial': 9007199254740991,
+							'bigintnum ∪ serial': 9007199254740991,
+							'bigintnum ∪ bigserialnum': 9007199254740991,
+							'bigintnum ∪ bigintnum': 9007199254740991,
+							'bigintnum ∪ numericnum': 9007199254740991,
+							'numericnum ∪ int': 9007199254740991,
+							'numericnum ∪ smallint': 9007199254740991,
+							'numericnum ∪ double': 9007199254740991,
+							'numericnum ∪ smallserial': 9007199254740991,
+							'numericnum ∪ serial': 9007199254740991,
+							'numericnum ∪ bigserialnum': 9007199254740991,
+							'numericnum ∪ bigintnum': 9007199254740991,
+							'numericnum ∪ numericnum': 9007199254740991,
+						},
+						{
+							'int ∪ int': 621,
+							'int ∪ smallint': 10,
+							'int ∪ double': 15.35325689124218,
+							'int ∪ real': 1.048596,
+							'int ∪ smallserial': 15,
+							'int ∪ serial': 1,
+							'int ∪ bigserialnum': 9007199254740991,
+							'int ∪ bigintnum': 9007199254740991,
+							'int ∪ numericnum': 9007199254740991,
+							'smallint ∪ int': 621,
+							'smallint ∪ smallint': 10,
+							'smallint ∪ double': 15.35325689124218,
+							'smallint ∪ real': 1.048596,
+							'smallint ∪ smallserial': 15,
+							'smallint ∪ serial': 1,
+							'smallint ∪ bigserialnum': 9007199254740991,
+							'smallint ∪ bigintnum': 9007199254740991,
+							'smallint ∪ numericnum': 9007199254740991,
+							'double ∪ int': 621,
+							'double ∪ smallint': 10,
+							'double ∪ double': 15.35325689124218,
+							'double ∪ real': 1.0485960245132446,
+							'double ∪ smallserial': 15,
+							'double ∪ serial': 1,
+							'double ∪ bigserialnum': 9007199254740991,
+							'double ∪ bigintnum': 9007199254740991,
+							'double ∪ numericnum': 9007199254740991,
+							'real ∪ int': 621,
+							'real ∪ smallint': 10,
+							'real ∪ double': 15.35325689124218,
+							'real ∪ real': 1.048596,
+							'real ∪ smallserial': 15,
+							'real ∪ serial': 1,
+							'smallserial ∪ int': 621,
+							'smallserial ∪ smallint': 10,
+							'smallserial ∪ double': 15.35325689124218,
+							'smallserial ∪ real': 1.048596,
+							'smallserial ∪ smallserial': 15,
+							'smallserial ∪ serial': 1,
+							'smallserial ∪ bigserialnum': 9007199254740991,
+							'smallserial ∪ bigintnum': 9007199254740991,
+							'smallserial ∪ numericnum': 9007199254740991,
+							'serial ∪ int': 621,
+							'serial ∪ smallint': 10,
+							'serial ∪ double': 15.35325689124218,
+							'serial ∪ real': 1.048596,
+							'serial ∪ smallserial': 15,
+							'serial ∪ serial': 1,
+							'serial ∪ bigserialnum': 9007199254740991,
+							'serial ∪ bigintnum': 9007199254740991,
+							'serial ∪ numericnum': 9007199254740991,
+							'bigserialnum ∪ int': 621,
+							'bigserialnum ∪ smallint': 10,
+							'bigserialnum ∪ double': 15.35325689124218,
+							'bigserialnum ∪ smallserial': 15,
+							'bigserialnum ∪ serial': 1,
+							'bigserialnum ∪ bigserialnum': 9007199254740991,
+							'bigserialnum ∪ bigintnum': 9007199254740991,
+							'bigserialnum ∪ numericnum': 9007199254740991,
+							'bigintnum ∪ int': 621,
+							'bigintnum ∪ smallint': 10,
+							'bigintnum ∪ double': 15.35325689124218,
+							'bigintnum ∪ smallserial': 15,
+							'bigintnum ∪ serial': 1,
+							'bigintnum ∪ bigserialnum': 9007199254740991,
+							'bigintnum ∪ bigintnum': 9007199254740991,
+							'bigintnum ∪ numericnum': 9007199254740991,
+							'numericnum ∪ int': 621,
+							'numericnum ∪ smallint': 10,
+							'numericnum ∪ double': 15.35325689124218,
+							'numericnum ∪ smallserial': 15,
+							'numericnum ∪ serial': 1,
+							'numericnum ∪ bigserialnum': 9007199254740991,
+							'numericnum ∪ bigintnum': 9007199254740991,
+							'numericnum ∪ numericnum': 9007199254740991,
+						},
+					]));
+
+					// ---- bigint ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+								'bigint ∪ bigserial': allTypesTable.bigint.as('bigint ∪ bigserial'),
+								'bigint ∪ numericbig': allTypesTable.bigint.as('bigint ∪ numericbig'),
+								'bigserial ∪ bigint': allTypesTable.bigserial.as('bigserial ∪ bigint'),
+								'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+								'bigserial ∪ numericbig': allTypesTable.bigserial.as('bigserial ∪ numericbig'),
+								'numericbig ∪ bigint': allTypesTable.numericbig.as('numericbig ∪ bigint'),
+								'numericbig ∪ bigserial': allTypesTable.numericbig.as('numericbig ∪ bigserial'),
+								'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+							}).from(allTypesTable),
+							db.select({
+								'bigint ∪ bigint': allTypesTable.bigint.as('bigint ∪ bigint'),
+								'bigint ∪ bigserial': allTypesTable.bigserial.as('bigint ∪ bigserial'),
+								'bigint ∪ numericbig': allTypesTable.numericbig.as('bigint ∪ numericbig'),
+								'bigserial ∪ bigint': allTypesTable.bigint.as('bigserial ∪ bigint'),
+								'bigserial ∪ bigserial': allTypesTable.bigserial.as('bigserial ∪ bigserial'),
+								'bigserial ∪ numericbig': allTypesTable.numericbig.as('bigserial ∪ numericbig'),
+								'numericbig ∪ bigint': allTypesTable.bigint.as('numericbig ∪ bigint'),
+								'numericbig ∪ bigserial': allTypesTable.bigserial.as('numericbig ∪ bigserial'),
+								'numericbig ∪ numericbig': allTypesTable.numericbig.as('numericbig ∪ numericbig'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'bigint ∪ bigint': 5044565289845416380n,
+							'bigint ∪ bigserial': 5044565289845416380n,
+							'bigint ∪ numericbig': 5044565289845416380n,
+							'bigserial ∪ bigint': 5044565289845416380n,
+							'bigserial ∪ bigserial': 5044565289845416380n,
+							'bigserial ∪ numericbig': 5044565289845416380n,
+							'numericbig ∪ bigint': 5044565289845416380n,
+							'numericbig ∪ bigserial': 5044565289845416380n,
+							'numericbig ∪ numericbig': 5044565289845416380n,
+						},
+						{
+							'bigint ∪ bigint': 5044565289845416380n,
+							'bigint ∪ bigserial': 5044565289845416380n,
+							'bigint ∪ numericbig': 5044565289845416380n,
+							'bigserial ∪ bigint': 5044565289845416380n,
+							'bigserial ∪ bigserial': 5044565289845416380n,
+							'bigserial ∪ numericbig': 5044565289845416380n,
+							'numericbig ∪ bigint': 5044565289845416380n,
+							'numericbig ∪ bigserial': 5044565289845416380n,
+							'numericbig ∪ numericbig': 5044565289845416380n,
+						},
+					]));
+
+					// ---- text ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+								'varchar ∪ text': allTypesTable.varchar.as('varchar ∪ text'),
+								'text ∪ varchar': allTypesTable.text.as('text ∪ varchar'),
+								'text ∪ text': allTypesTable.text.as('text ∪ text'),
+							}).from(allTypesTable),
+							db.select({
+								'varchar ∪ varchar': allTypesTable.varchar.as('varchar ∪ varchar'),
+								'varchar ∪ text': allTypesTable.text.as('varchar ∪ text'),
+								'text ∪ varchar': allTypesTable.varchar.as('text ∪ varchar'),
+								'text ∪ text': allTypesTable.text.as('text ∪ text'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'varchar ∪ varchar': 'C4-',
+							'varchar ∪ text': 'C4-',
+							'text ∪ varchar': 'TEXT STRING',
+							'text ∪ text': 'TEXT STRING',
+						},
+						{
+							'varchar ∪ varchar': 'C4-',
+							'varchar ∪ text': 'TEXT STRING',
+							'text ∪ varchar': 'C4-',
+							'text ∪ text': 'TEXT STRING',
+						},
+					]));
+
+					// ---- numstr ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+								'bigintstr ∪ numeric': allTypesTable.bigintstr.as('bigintstr ∪ numeric'),
+								'numeric ∪ bigintstr': allTypesTable.numeric.as('numeric ∪ bigintstr'),
+								'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+							}).from(allTypesTable),
+							db.select({
+								'bigintstr ∪ bigintstr': allTypesTable.bigintstr.as('bigintstr ∪ bigintstr'),
+								'bigintstr ∪ numeric': allTypesTable.numeric.as('bigintstr ∪ numeric'),
+								'numeric ∪ bigintstr': allTypesTable.bigintstr.as('numeric ∪ bigintstr'),
+								'numeric ∪ numeric': allTypesTable.numeric.as('numeric ∪ numeric'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'bigintstr ∪ bigintstr': '5044565289845416380',
+							'bigintstr ∪ numeric': '5044565289845416380',
+							'numeric ∪ bigintstr': '5044565289845416380',
+							'numeric ∪ numeric': '5044565289845416380',
+						},
+						{
+							'bigintstr ∪ bigintstr': '5044565289845416380',
+							'bigintstr ∪ numeric': '5044565289845416380',
+							'numeric ∪ bigintstr': '5044565289845416380',
+							'numeric ∪ numeric': '5044565289845416380',
+						},
+					]));
+
+					// ---- date ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'date ∪ date': allTypesTable.date.as('date ∪ date'),
+								'date ∪ timestamp': allTypesTable.date.as('date ∪ timestamp'),
+								'date ∪ timestampTz': allTypesTable.date.as('date ∪ timestampTz'),
+								'timestamp ∪ date': allTypesTable.timestamp.as('timestamp ∪ date'),
+								'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+								'timestamp ∪ timestampTz': allTypesTable.timestamp.as('timestamp ∪ timestampTz'),
+								'timestampTz ∪ date': allTypesTable.timestampTz.as('timestampTz ∪ date'),
+								'timestampTz ∪ timestamp': allTypesTable.timestampTz.as('timestampTz ∪ timestamp'),
+								'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+							}).from(allTypesTable),
+							db.select({
+								'date ∪ date': allTypesTable.date.as('date ∪ date'),
+								'date ∪ timestamp': allTypesTable.timestamp.as('date ∪ timestamp'),
+								'date ∪ timestampTz': allTypesTable.timestampTz.as('date ∪ timestampTz'),
+								'timestamp ∪ date': allTypesTable.date.as('timestamp ∪ date'),
+								'timestamp ∪ timestamp': allTypesTable.timestamp.as('timestamp ∪ timestamp'),
+								'timestamp ∪ timestampTz': allTypesTable.timestampTz.as('timestamp ∪ timestampTz'),
+								'timestampTz ∪ date': allTypesTable.date.as('timestampTz ∪ date'),
+								'timestampTz ∪ timestamp': allTypesTable.timestamp.as('timestampTz ∪ timestamp'),
+								'timestampTz ∪ timestampTz': allTypesTable.timestampTz.as('timestampTz ∪ timestampTz'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'date ∪ date': new Date('2025-03-12'),
+							'date ∪ timestamp': new Date('2025-03-12'),
+							'date ∪ timestampTz': new Date('2025-03-12'),
+							'timestamp ∪ date': new Date('2025-03-12 01:32:41.623'),
+							'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+							'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623'),
+							'timestampTz ∪ date': new Date('2025-03-12 01:32:41.623+00'),
+							'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623+00'),
+							'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+						},
+						{
+							'date ∪ date': new Date('2025-03-12'),
+							'date ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+							'date ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+							'timestamp ∪ date': new Date('2025-03-12'),
+							'timestamp ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+							'timestamp ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+							'timestampTz ∪ date': new Date('2025-03-12'),
+							'timestampTz ∪ timestamp': new Date('2025-03-12 01:32:41.623'),
+							'timestampTz ∪ timestampTz': new Date('2025-03-12 01:32:41.623+00'),
+						},
+					]));
+
+					// ---- json ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'json ∪ json': allTypesTable.json.as('json ∪ json'),
+								'json ∪ json1': allTypesTable.json.as('json ∪ json1'),
+								'json ∪ json2': allTypesTable.json.as('json ∪ json2'),
+								'json ∪ json3': allTypesTable.json.as('json ∪ json3'),
+								'json1 ∪ json': allTypesTable.json1.as('json1 ∪ json'),
+								'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+								'json1 ∪ json2': allTypesTable.json1.as('json1 ∪ json2'),
+								'json1 ∪ json3': allTypesTable.json1.as('json1 ∪ json3'),
+								'json2 ∪ json': allTypesTable.json2.as('json2 ∪ json'),
+								'json2 ∪ json1': allTypesTable.json2.as('json2 ∪ json1'),
+								'json2 ∪ json2': allTypesTable.json2.as('json2 ∪ json2'),
+								'json2 ∪ json3': allTypesTable.json2.as('json2 ∪ json3'),
+								'json3 ∪ json': allTypesTable.json3.as('json3 ∪ json'),
+								'json3 ∪ json1': allTypesTable.json3.as('json3 ∪ json1'),
+								'json3 ∪ json2': allTypesTable.json3.as('json3 ∪ json2'),
+								'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+							}).from(allTypesTable),
+							db.select({
+								'json ∪ json': allTypesTable.json.as('json ∪ json'),
+								'json ∪ json1': allTypesTable.json1.as('json ∪ json1'),
+								'json ∪ json2': allTypesTable.json2.as('json ∪ json2'),
+								'json ∪ json3': allTypesTable.json3.as('json ∪ json3'),
+								'json1 ∪ json': allTypesTable.json.as('json1 ∪ json'),
+								'json1 ∪ json1': allTypesTable.json1.as('json1 ∪ json1'),
+								'json1 ∪ json2': allTypesTable.json2.as('json1 ∪ json2'),
+								'json1 ∪ json3': allTypesTable.json3.as('json1 ∪ json3'),
+								'json2 ∪ json': allTypesTable.json.as('json2 ∪ json'),
+								'json2 ∪ json1': allTypesTable.json1.as('json2 ∪ json1'),
+								'json2 ∪ json2': allTypesTable.json2.as('json2 ∪ json2'),
+								'json2 ∪ json3': allTypesTable.json3.as('json2 ∪ json3'),
+								'json3 ∪ json': allTypesTable.json.as('json3 ∪ json'),
+								'json3 ∪ json1': allTypesTable.json1.as('json3 ∪ json1'),
+								'json3 ∪ json2': allTypesTable.json2.as('json3 ∪ json2'),
+								'json3 ∪ json3': allTypesTable.json3.as('json3 ∪ json3'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'json ∪ json': { str: 'strval', arr: ['str', 10] },
+							'json ∪ json1': { str: 'strval', arr: ['str', 10] },
+							'json ∪ json2': { str: 'strval', arr: ['str', 10] },
+							'json ∪ json3': { str: 'strval', arr: ['str', 10] },
+							'json1 ∪ json': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json1 ∪ json2': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json1 ∪ json3': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json2 ∪ json': 5,
+							'json2 ∪ json1': 5,
+							'json2 ∪ json2': 5,
+							'json2 ∪ json3': 5,
+							'json3 ∪ json': '5',
+							'json3 ∪ json1': '5',
+							'json3 ∪ json2': '5',
+							'json3 ∪ json3': '5',
+						},
+						{
+							'json ∪ json': { str: 'strval', arr: ['str', 10] },
+							'json ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json ∪ json2': 5,
+							'json ∪ json3': '5',
+							'json1 ∪ json': { str: 'strval', arr: ['str', 10] },
+							'json1 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json1 ∪ json2': 5,
+							'json1 ∪ json3': '5',
+							'json2 ∪ json': { str: 'strval', arr: ['str', 10] },
+							'json2 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json2 ∪ json2': 5,
+							'json2 ∪ json3': '5',
+							'json3 ∪ json': { str: 'strval', arr: ['str', 10] },
+							'json3 ∪ json1': [{ key: 'value', num: 7 }, 'v', '11', 5],
+							'json3 ∪ json2': 5,
+							'json3 ∪ json3': '5',
+						},
+					]));
+
+					// ---- jsonb ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+								'jsonb ∪ jsonb1': allTypesTable.jsonb.as('jsonb ∪ jsonb1'),
+								'jsonb ∪ jsonb2': allTypesTable.jsonb.as('jsonb ∪ jsonb2'),
+								'jsonb ∪ jsonb3': allTypesTable.jsonb.as('jsonb ∪ jsonb3'),
+								'jsonb1 ∪ jsonb': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb'),
+								'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+								'jsonb1 ∪ jsonb2': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb2'),
+								'jsonb1 ∪ jsonb3': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb3'),
+								'jsonb2 ∪ jsonb': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb'),
+								'jsonb2 ∪ jsonb1': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb1'),
+								'jsonb2 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb2'),
+								'jsonb2 ∪ jsonb3': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb3'),
+								'jsonb3 ∪ jsonb': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb'),
+								'jsonb3 ∪ jsonb1': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb1'),
+								'jsonb3 ∪ jsonb2': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb2'),
+								'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+							}).from(allTypesTable),
+							db.select({
+								'jsonb ∪ jsonb': allTypesTable.jsonb.as('jsonb ∪ jsonb'),
+								'jsonb ∪ jsonb1': allTypesTable.jsonb1.as('jsonb ∪ jsonb1'),
+								'jsonb ∪ jsonb2': allTypesTable.jsonb2.as('jsonb ∪ jsonb2'),
+								'jsonb ∪ jsonb3': allTypesTable.jsonb3.as('jsonb ∪ jsonb3'),
+								'jsonb1 ∪ jsonb': allTypesTable.jsonb.as('jsonb1 ∪ jsonb'),
+								'jsonb1 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb1 ∪ jsonb1'),
+								'jsonb1 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb1 ∪ jsonb2'),
+								'jsonb1 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb1 ∪ jsonb3'),
+								'jsonb2 ∪ jsonb': allTypesTable.jsonb.as('jsonb2 ∪ jsonb'),
+								'jsonb2 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb2 ∪ jsonb1'),
+								'jsonb2 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb2 ∪ jsonb2'),
+								'jsonb2 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb2 ∪ jsonb3'),
+								'jsonb3 ∪ jsonb': allTypesTable.jsonb.as('jsonb3 ∪ jsonb'),
+								'jsonb3 ∪ jsonb1': allTypesTable.jsonb1.as('jsonb3 ∪ jsonb1'),
+								'jsonb3 ∪ jsonb2': allTypesTable.jsonb2.as('jsonb3 ∪ jsonb2'),
+								'jsonb3 ∪ jsonb3': allTypesTable.jsonb3.as('jsonb3 ∪ jsonb3'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb ∪ jsonb1': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb ∪ jsonb2': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb ∪ jsonb3': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb1 ∪ jsonb': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb1 ∪ jsonb2': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb1 ∪ jsonb3': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb2 ∪ jsonb': 7,
+							'jsonb2 ∪ jsonb1': 7,
+							'jsonb2 ∪ jsonb2': 7,
+							'jsonb2 ∪ jsonb3': 7,
+							'jsonb3 ∪ jsonb': '7',
+							'jsonb3 ∪ jsonb1': '7',
+							'jsonb3 ∪ jsonb2': '7',
+							'jsonb3 ∪ jsonb3': '7',
+						},
+						{
+							'jsonb ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb ∪ jsonb2': 7,
+							'jsonb ∪ jsonb3': '7',
+							'jsonb1 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb1 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb1 ∪ jsonb2': 7,
+							'jsonb1 ∪ jsonb3': '7',
+							'jsonb2 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb2 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb2 ∪ jsonb2': 7,
+							'jsonb2 ∪ jsonb3': '7',
+							'jsonb3 ∪ jsonb': { arr: ['strb', 11], str: 'strvalb' },
+							'jsonb3 ∪ jsonb1': [{ key: 'value', num: 8 }, 'x', '10', 3],
+							'jsonb3 ∪ jsonb2': 7,
+							'jsonb3 ∪ jsonb3': '7',
+						},
+					]));
+
+					// ---- self-only ----
+					expect(
+						yield* unionAll(
+							db.select({
+								'char ∪ char': allTypesTable.char.as('char ∪ char'),
+								'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+								'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+								'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+								'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+								'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+								'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+								'time ∪ time': allTypesTable.time.as('time ∪ time'),
+								'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+								'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+								'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+								'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+								'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+								'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+								'line ∪ line': allTypesTable.line.as('line ∪ line'),
+								'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+								'point ∪ point': allTypesTable.point.as('point ∪ point'),
+								'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+							}).from(allTypesTable),
+							db.select({
+								'char ∪ char': allTypesTable.char.as('char ∪ char'),
+								'cidr ∪ cidr': allTypesTable.cidr.as('cidr ∪ cidr'),
+								'inet ∪ inet': allTypesTable.inet.as('inet ∪ inet'),
+								'macaddr ∪ macaddr': allTypesTable.macaddr.as('macaddr ∪ macaddr'),
+								'macaddr8 ∪ macaddr8': allTypesTable.macaddr8.as('macaddr8 ∪ macaddr8'),
+								'uuid ∪ uuid': allTypesTable.uuid.as('uuid ∪ uuid'),
+								'interval ∪ interval': allTypesTable.interval.as('interval ∪ interval'),
+								'time ∪ time': allTypesTable.time.as('time ∪ time'),
+								'datestr ∪ datestr': allTypesTable.datestr.as('datestr ∪ datestr'),
+								'timestampstr ∪ timestampstr': allTypesTable.timestampstr.as('timestampstr ∪ timestampstr'),
+								'timestampTzstr ∪ timestampTzstr': allTypesTable.timestampTzstr.as('timestampTzstr ∪ timestampTzstr'),
+								'bool ∪ bool': allTypesTable.bool.as('bool ∪ bool'),
+								'bytea ∪ bytea': allTypesTable.bytea.as('bytea ∪ bytea'),
+								'enum ∪ enum': allTypesTable.enum.as('enum ∪ enum'),
+								'line ∪ line': allTypesTable.line.as('line ∪ line'),
+								'linetuple ∪ linetuple': allTypesTable.linetuple.as('linetuple ∪ linetuple'),
+								'point ∪ point': allTypesTable.point.as('point ∪ point'),
+								'pointtuple ∪ pointtuple': allTypesTable.pointtuple.as('pointtuple ∪ pointtuple'),
+							}).from(allTypesTable),
+						),
+					).toEqual(expect.arrayContaining([
+						{
+							'char ∪ char': 'c',
+							'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+							'inet ∪ inet': '192.168.0.1/24',
+							'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+							'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+							'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+							'interval ∪ interval': '-2 mons',
+							'time ∪ time': '13:59:28',
+							'datestr ∪ datestr': '2025-03-12',
+							'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+							'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+							'bool ∪ bool': true,
+							'bytea ∪ bytea': Buffer.from('BYTES'),
+							'enum ∪ enum': 'enVal1',
+							'line ∪ line': { a: 1, b: 2, c: 3 },
+							'linetuple ∪ linetuple': [1, 2, 3],
+							'point ∪ point': { x: 24.5, y: 49.6 },
+							'pointtuple ∪ pointtuple': [24.5, 49.6],
+						},
+						{
+							'char ∪ char': 'c',
+							'cidr ∪ cidr': '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+							'inet ∪ inet': '192.168.0.1/24',
+							'macaddr ∪ macaddr': '08:00:2b:01:02:03',
+							'macaddr8 ∪ macaddr8': '08:00:2b:01:02:03:04:05',
+							'uuid ∪ uuid': 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+							'interval ∪ interval': '-2 mons',
+							'time ∪ time': '13:59:28',
+							'datestr ∪ datestr': '2025-03-12',
+							'timestampstr ∪ timestampstr': '2025-03-12 01:32:41.623',
+							'timestampTzstr ∪ timestampTzstr': '2025-03-12 01:32:41.623+00',
+							'bool ∪ bool': true,
+							'bytea ∪ bytea': Buffer.from('BYTES'),
+							'enum ∪ enum': 'enVal1',
+							'line ∪ line': { a: 1, b: 2, c: 3 },
+							'linetuple ∪ linetuple': [1, 2, 3],
+							'point ∪ point': { x: 24.5, y: 49.6 },
+							'pointtuple ∪ pointtuple': [24.5, 49.6],
+						},
+					]));
+				}),
+		);
+
+		it.effect('Mappers: - correct mappers enabled', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const jitDb = yield* createDB({}, () => ({}), true);
+
+				const dialect: PgDialect = (<any> db).dialect;
+				const jitDialect: PgDialect = (<any> jitDb).dialect;
+
+				expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+				expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+			}));
+
+		const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+		it.effect('Mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_1', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_2', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_3', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Mappers: insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_4', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_5', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = pgTable('mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = pgTable('mappers_users_6', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = pgTable('mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					false,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: - simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_1', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Jit mappers: - select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_2', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Jit mappers: - select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_3', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Jit mappers: - insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_4', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Jit mappers: - select complex selections', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_5', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = pgTable('jit_mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: - relational', () =>
+			Effect.gen(function*() {
+				const users = pgTable('jit_mappers_users_6', (t) => ({
+					id: t.bigint('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.timestamp('created_at', {
+						withTimezone: true,
+						mode: 'date',
+					}).notNull(),
+					isBanned: t.boolean('is_banned'),
+				}));
+
+				const posts = pgTable('jit_mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.bigint('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					true,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		it.effect('Column as decoder applies codecs', () =>
+			Effect.gen(function*() {
+				let customCast = false;
+				let customMap = false;
+
+				const codecBypass = customType<{
+					data: Date;
+					driverData: string;
+					jsonData: string;
+				}>({
+					codec: 'timestamptz',
+					dataType: () => 'timestamptz(3)',
+					forJsonSelect: (identifier, sql, arrayDimensions) => {
+						customCast = true;
+						return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+					},
+					fromJson: (v) => {
+						customMap = true;
+						return new Date(v);
+					},
+					toDriver: (v) => v.toISOString(),
+				});
+
+				const users = pgTable('users_823', (t) => ({
+					id: t.integer().primaryKey(),
+					name: t.text().notNull(),
+					createdAt: t.timestamp('created_at').notNull(),
+					createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+					arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+					arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+					cus: codecBypass('custom').notNull(),
+					arrCus: codecBypass('arr_custom').notNull().array(),
+				}));
+
+				const usersView = pgView('users_823_v').as((qb) =>
+					qb.select({
+						...getColumns(users),
+						max: max(users.createdAt).as('max'),
+						maxStr: max(users.createdAtStr).as('max_str'),
+						arrMax: max(users.arrCreatedAt).as('arr_max'),
+						arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+						sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+					}).from(users).groupBy(users.id)
+				);
+
+				const db = yield* createDB({ users, usersView }, (r) => ({
+					users: {
+						self: r.one.users({
+							from: r.users.id,
+							to: r.users.id,
+						}),
+					},
+					usersView: {
+						self: r.one.usersView({
+							from: r.usersView.id,
+							to: r.usersView.id,
+						}),
+					},
+				}));
+				yield* push(db, { users, usersView });
+
+				const exDateStr = '1970-01-16 16:45:46.351';
+				const exDate = new Date(exDateStr);
+
+				yield* db.insert(users).values({
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+				});
+
+				const res = yield* db.select({
+					...getColumns(users),
+					max: max(users.createdAt).as('max'),
+					maxStr: max(users.createdAtStr).as('max_str'),
+					arrMax: max(users.arrCreatedAt).as('arr_max'),
+					arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+					sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+				}).from(users).groupBy(users.id);
+
+				const viewRes = yield* db.select().from(usersView);
+
+				const nested = yield* db.query.users.findFirst({
+					with: {
+						self: {
+							extras: {
+								max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+								maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+								arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+								arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+							},
+						},
+					},
+					extras: {
+						max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+						maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+						arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+						arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+					},
+				});
+
+				const viewNested = yield* db.query.usersView.findFirst({
+					columns: {
+						sq: false, // TODO: re-enable when supported in RQBv2
+					},
+					with: {
+						self: {
+							columns: {
+								sq: false, // TODO: re-enable when supported in RQBv2
+							},
+						},
+					},
+				});
+
+				expect(res).toStrictEqual([
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						sq: exDate,
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				]);
+				expect(viewRes).toStrictEqual([
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						sq: exDate,
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				]);
+
+				expect(customCast).toBeTruthy();
+				expect(customMap).toBeTruthy();
+
+				expect(nested).toStrictEqual(
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+						self: {
+							id: 1,
+							name: 'First',
+							createdAt: exDate,
+							createdAtStr: exDateStr,
+							arrCreatedAt: [exDate],
+							arrCreatedAtStr: [exDateStr],
+							max: exDate,
+							maxStr: exDateStr,
+							arrMax: [exDate],
+							arrMaxStr: [exDateStr],
+							cus: exDate,
+							arrCus: [exDate],
+						},
+					},
+				);
+				expect(viewNested).toStrictEqual(
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+						self: {
+							id: 1,
+							name: 'First',
+							createdAt: exDate,
+							createdAtStr: exDateStr,
+							arrCreatedAt: [exDate],
+							arrCreatedAtStr: [exDateStr],
+							max: exDate,
+							maxStr: exDateStr,
+							arrMax: [exDate],
+							arrMaxStr: [exDateStr],
+							cus: exDate,
+							arrCus: [exDate],
+						},
+					},
+				);
+			}));
+
+		it.effect('Column as decoder applies codecs - Jit mappers', () =>
+			Effect.gen(function*() {
+				let customCast = false;
+				let customMap = false;
+
+				const codecBypass = customType<{
+					data: Date;
+					driverData: string;
+					jsonData: string;
+				}>({
+					codec: 'timestamptz',
+					dataType: () => 'timestamptz(3)',
+					forJsonSelect: (identifier, sql, arrayDimensions) => {
+						customCast = true;
+						return sql`${identifier}::text${arrayDimensions ? sql.raw('[]'.repeat(arrayDimensions)) : undefined}`;
+					},
+					fromJson: (v) => {
+						customMap = true;
+						return new Date(v);
+					},
+					toDriver: (v) => v.toISOString(),
+				});
+
+				const users = pgTable('users_823_jit', (t) => ({
+					id: t.integer().primaryKey(),
+					name: t.text().notNull(),
+					createdAt: t.timestamp('created_at').notNull(),
+					createdAtStr: t.timestamp('created_at_str', { mode: 'string' }).notNull(),
+					arrCreatedAt: t.timestamp('arr_created_at').notNull().array(),
+					arrCreatedAtStr: t.timestamp('arr_created_at_str', { mode: 'string' }).notNull().array(),
+					cus: codecBypass('custom').notNull(),
+					arrCus: codecBypass('arr_custom').notNull().array(),
+				}));
+
+				const usersView = pgView('users_823_v_jit').as((qb) =>
+					qb.select({
+						...getColumns(users),
+						max: max(users.createdAt).as('max'),
+						maxStr: max(users.createdAtStr).as('max_str'),
+						arrMax: max(users.arrCreatedAt).as('arr_max'),
+						arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+						sq: qb.select({ createdAt: users.createdAt }).from(users).as('sq'),
+					}).from(users).groupBy(users.id)
+				);
+
+				const db = yield* createDB({ users, usersView }, (r) => ({
+					users: {
+						self: r.one.users({
+							from: r.users.id,
+							to: r.users.id,
+						}),
+					},
+					usersView: {
+						self: r.one.usersView({
+							from: r.usersView.id,
+							to: r.usersView.id,
+						}),
+					},
+				}), true);
+				yield* push(db, { users, usersView });
+
+				const exDateStr = '1970-01-16 16:45:46.351';
+				const exDate = new Date(exDateStr);
+
+				yield* db.insert(users).values({
+					id: 1,
+					name: 'First',
+					createdAt: exDate,
+					createdAtStr: exDateStr,
+					arrCreatedAt: [exDate],
+					arrCreatedAtStr: [exDateStr],
+					cus: exDate,
+					arrCus: [exDate],
+				});
+
+				const res = yield* db.select({
+					...getColumns(users),
+					max: max(users.createdAt).as('max'),
+					maxStr: max(users.createdAtStr).as('max_str'),
+					arrMax: max(users.arrCreatedAt).as('arr_max'),
+					arrMaxStr: max(users.arrCreatedAtStr).as('arr_max_str'),
+					sq: db.select({ createdAt: users.createdAt }).from(users).as('sq'),
+				}).from(users).groupBy(users.id);
+
+				const viewRes = yield* db.select().from(usersView);
+
+				const nested = yield* db.query.users.findFirst({
+					with: {
+						self: {
+							extras: {
+								max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+								maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+								arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+								arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+							},
+						},
+					},
+					extras: {
+						max: () => sql`select max(${users.createdAt}) from ${users}`.mapWith(users.createdAt),
+						maxStr: () => sql`select max(${users.createdAtStr}) from ${users}`.mapWith(users.createdAtStr),
+						arrMax: () => sql`select max(${users.arrCreatedAt}) from ${users}`.mapWith(users.arrCreatedAt),
+						arrMaxStr: () => sql`select max(${users.arrCreatedAtStr}) from ${users}`.mapWith(users.arrCreatedAtStr),
+					},
+				});
+
+				const viewNested = yield* db.query.usersView.findFirst({
+					columns: {
+						sq: false, // TODO: re-enable when supported in RQBv2
+					},
+					with: {
+						self: {
+							columns: {
+								sq: false, // TODO: re-enable when supported in RQBv2
+							},
+						},
+					},
+				});
+
+				expect(res).toStrictEqual([
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						sq: exDate,
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				]);
+				expect(viewRes).toStrictEqual([
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						sq: exDate,
+						cus: exDate,
+						arrCus: [exDate],
+					},
+				]);
+
+				expect(customCast).toBeTruthy();
+				expect(customMap).toBeTruthy();
+
+				expect(nested).toStrictEqual(
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+						self: {
+							id: 1,
+							name: 'First',
+							createdAt: exDate,
+							createdAtStr: exDateStr,
+							arrCreatedAt: [exDate],
+							arrCreatedAtStr: [exDateStr],
+							max: exDate,
+							maxStr: exDateStr,
+							arrMax: [exDate],
+							arrMaxStr: [exDateStr],
+							cus: exDate,
+							arrCus: [exDate],
+						},
+					},
+				);
+				expect(viewNested).toStrictEqual(
+					{
+						id: 1,
+						name: 'First',
+						createdAt: exDate,
+						createdAtStr: exDateStr,
+						arrCreatedAt: [exDate],
+						arrCreatedAtStr: [exDateStr],
+						max: exDate,
+						maxStr: exDateStr,
+						arrMax: [exDate],
+						arrMaxStr: [exDateStr],
+						cus: exDate,
+						arrCus: [exDate],
+						self: {
+							id: 1,
+							name: 'First',
+							createdAt: exDate,
+							createdAtStr: exDateStr,
+							arrCreatedAt: [exDate],
+							arrCreatedAtStr: [exDateStr],
+							max: exDate,
+							maxStr: exDateStr,
+							arrMax: [exDate],
+							arrMaxStr: [exDateStr],
+							cus: exDate,
+							arrCus: [exDate],
+						},
+					},
+				);
+			}));
+
+		addTests?.(it);
+	});
+};
+
+export { relations } from './relations';
+export { rqbPost, rqbUser } from './schema';
diff --git a/integration-tests/tests/pg/effect-pg.test.ts b/integration-tests/tests/pg/effect-pg.test.ts
new file mode 100644
index 0000000000..3e6f172288
--- /dev/null
+++ b/integration-tests/tests/pg/effect-pg.test.ts
@@ -0,0 +1,326 @@
+import { PgClient } from '@effect/sql-pg';
+import { assert, expect, it } from '@effect/vitest';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as PgDrizzle from 'drizzle-orm/effect-postgres';
+import { migrate } from 'drizzle-orm/effect-postgres/migrator';
+import { getTableConfig, integer, pgTable, serial, text } from 'drizzle-orm/pg-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Redacted from 'effect/Redacted';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { randomString } from '~/utils';
+import { DB, runCommonEffectPgTests } from './effect-common';
+import { relations } from './relations';
+import { usersMigratorTable } from './schema';
+
+const connectionStr = Redacted.make(
+	process.env['PG_CONNECTION_STRING'] ?? 'postgres://postgres:postgres@localhost:55433/drizzle',
+);
+const PgClientLive = PgClient.layer({
+	url: connectionStr,
+});
+
+const dbEffect = PgDrizzle.make({ relations }).pipe(Effect.provide(PgDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	PgDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(PgDrizzle.DefaultServices),
+	);
+const TestLive = Layer.merge(PgClientLive, DBLive.pipe(Layer.provide(PgClientLive)));
+const usedSchema = 'effect_pg_test';
+
+runCommonEffectPgTests({
+	testLayer: TestLive,
+	PgDrizzle: PgDrizzle,
+	createDB: createDB as any,
+	usedSchema,
+	addTests: (it) => {
+		it.effect('execute', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.execute<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res.rows).toStrictEqual([{ '1': 1 }]);
+			}));
+
+		it.effect('migrator : default migration strategy', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+				const result = yield* db.select().from(usersMigratorTable);
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+			}));
+
+		it.effect('migrator : migrate with custom schema', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customSchema = randomString();
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier(customSchema)}.${
+						sql.identifier('__drizzle_migrations')
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.execute(sql`DROP SCHEMA ${sql.identifier(customSchema)} CASCADE;`);
+			}));
+
+		it.effect('migrator : migrate with custom table', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customTable = randomString();
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier('drizzle')}.${
+						sql.identifier(customTable)
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+			}));
+
+		it.effect('migrator : migrate with custom table and custom schema', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customTable = randomString();
+				const customSchema = randomString();
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable: customTable,
+					migrationsSchema: customSchema,
+				});
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier(customSchema)}.${
+						sql.identifier(customTable)
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.execute(sql`DROP SCHEMA ${sql.identifier(customSchema)} CASCADE;`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg-init',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+				expect(meta.length).toStrictEqual(0);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg-init',
+					migrationsSchema,
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+				expect(meta.length).toStrictEqual(1);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(true);
+			}));
+
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('migration_users', {
+					id: serial('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: integer(),
+				});
+
+				const users2 = pgTable('migration_users2', {
+					id: serial('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: integer(),
+				});
+
+				yield* db.execute(sql`drop schema if exists "drizzle" cascade;`);
+				yield* db.execute(sql`drop table if exists ${users}`);
+				yield* db.execute(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/effect-sql';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrationsFolder: migrationDir });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrationsFolder: migrationDir });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+	},
+});
diff --git a/integration-tests/tests/pg/effect-pglite.test.ts b/integration-tests/tests/pg/effect-pglite.test.ts
new file mode 100644
index 0000000000..d9224d38c0
--- /dev/null
+++ b/integration-tests/tests/pg/effect-pglite.test.ts
@@ -0,0 +1,449 @@
+import { PgliteClient } from '@effect/sql-pglite';
+import { assert, expect } from '@effect/vitest';
+import { postgis } from '@electric-sql/pglite-postgis';
+import { vector } from '@electric-sql/pglite/vector';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	getColumns,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as PgDrizzle from 'drizzle-orm/effect-pglite';
+import { migrate } from 'drizzle-orm/effect-pglite/migrator';
+import { getTableConfig, integer, pgTable, serial, text } from 'drizzle-orm/pg-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { randomString } from '~/utils';
+import { push } from './effect-common';
+import { DB, runCommonEffectPgTests } from './effect-common';
+import { relations } from './relations';
+import { usersMigratorTable } from './schema';
+import { normalizeDataWithDbCodecs } from './utils';
+
+const PgClientLive = PgliteClient.layer({
+	dataDir: 'memory://',
+	extensions: {
+		postgis,
+		vector: vector as any, // works and should work without `as any`
+	},
+});
+
+const dbEffect = PgDrizzle.make({ relations }).pipe(Effect.provide(PgDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	PgDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(PgDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(PgClientLive, DBLive.pipe(Layer.provide(PgClientLive)));
+const usedSchema = 'effect_pg_test';
+
+runCommonEffectPgTests({
+	testLayer: TestLive,
+	PgDrizzle: PgDrizzle,
+	createDB,
+	usedSchema,
+	addTests: (it) => {
+		it.effect('execute', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.execute<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res.rows).toStrictEqual([{ '1': 1 }]);
+			}));
+
+		it.effect('migrator : default migration strategy', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+				const result = yield* db.select().from(usersMigratorTable);
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+			}));
+
+		it.effect('migrator : migrate with custom schema', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customSchema = randomString();
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier(customSchema)}.${
+						sql.identifier('__drizzle_migrations')
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.execute(sql`DROP SCHEMA ${sql.identifier(customSchema)} CASCADE;`);
+			}));
+
+		it.effect('migrator : migrate with custom table', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customTable = randomString();
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier('drizzle')}.${
+						sql.identifier(customTable)
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+			}));
+
+		it.effect('migrator : migrate with custom table and custom schema', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const customTable = randomString();
+				const customSchema = randomString();
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable: customTable,
+					migrationsSchema: customSchema,
+				});
+
+				// test if the custom migrations table was created
+				const res = yield* db.execute<{ count: number }>(
+					sql`select count(*) as ${sql.identifier('count')} from ${sql.identifier(customSchema)}.${
+						sql.identifier(customTable)
+					} limit 1;`,
+				);
+				expect((res.rows[0]?.count ?? 0) > 0).toBeTruthy();
+
+				// test if the migrated table are working as expected
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+				const result = yield* db.select().from(usersMigratorTable);
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.execute(sql`DROP SCHEMA ${sql.identifier(customSchema)} CASCADE;`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg-init',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+				expect(meta.length).toStrictEqual(0);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsSchema = 'drzl_migrations_init';
+				const migrationsTable = 'drzl_init';
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg-init',
+					migrationsSchema,
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/pg',
+					migrationsTable,
+					migrationsSchema,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? usedSchema} AND tablename = ${
+					getTableConfig(usersMigratorTable).name
+				}
+					) as ${sql.identifier('tableExists')};`);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+				expect(meta.length).toStrictEqual(1);
+				expect(res.rows[0]?.['tableExists']).toStrictEqual(true);
+			}));
+
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = pgTable('migration_users', {
+					id: serial('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: integer(),
+				});
+
+				const users2 = pgTable('migration_users2', {
+					id: serial('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: integer(),
+				});
+
+				yield* db.execute(sql`drop schema if exists "drizzle" cascade;`);
+				yield* db.execute(sql`drop table if exists ${users}`);
+				yield* db.execute(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/effect-sql';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrationsFolder: migrationDir });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrationsFolder: migrationDir });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+
+		it.effect('extension types ~codecs~', () =>
+			Effect.gen(function*() {
+				const allTypesTable = pgTable('extension_types', (t) => ({
+					id: t.integer('id').primaryKey(),
+					geo: t.geometry('geo'),
+					arrgeo: t.geometry('arrgeo').array(),
+					geoxy: t.geometry('geoxy', { mode: 'xy' }),
+					arrgeoxy: t.geometry('arrgeoxy', { mode: 'xy' }).array(),
+					bit: t.bit('bit', {
+						dimensions: 3,
+					}),
+					arrbit: t.bit('arrbit', {
+						dimensions: 3,
+					}).array(),
+					halfvec: t.halfvec('halfvec', {
+						dimensions: 3,
+					}),
+					arrhalfvec: t.halfvec('arrhalfvec', {
+						dimensions: 3,
+					}).array(),
+					vector: t.vector('vector', {
+						dimensions: 3,
+					}),
+					arrvector: t.vector('arrvector', {
+						dimensions: 3,
+					}).array(),
+					sparsevec: t.sparsevec('sparsevec', {
+						dimensions: 5,
+					}),
+					arrsparsevec: t.sparsevec('arrsparsevec', {
+						dimensions: 5,
+					}).array(),
+				}));
+
+				const db = yield* createDB({ allTypesTable }, (r) => ({
+					allTypesTable: {
+						self: r.many.allTypesTable({
+							from: r.allTypesTable.id,
+							to: r.allTypesTable.id,
+						}),
+					},
+				}));
+
+				yield* db.execute(sql`CREATE EXTENSION IF NOT EXISTS postgis;`);
+				yield* db.execute(sql`CREATE EXTENSION IF NOT EXISTS vector;`);
+				yield* db.execute(sql`DROP TABLE IF EXISTS ${allTypesTable} CASCADE;`);
+				yield* push(db, { allTypesTable });
+
+				yield* db.insert(allTypesTable).values({
+					id: 1,
+					geo: [15.23, 51.13],
+					arrgeo: [[15.23, 51.13]],
+					geoxy: { x: 15.23, y: 51.13 },
+					arrgeoxy: [{ x: 15.23, y: 51.13 }],
+					bit: '101',
+					arrbit: ['101'],
+					halfvec: [0.2, 3.5, 8.4],
+					arrhalfvec: [[0.2, 3.5, 8.4]],
+					vector: [1.9345, 2.8238, 12.3465],
+					arrvector: [[1.9345, 2.8238, 12.3465]],
+					sparsevec: '{1:1,3:2,5:3}/5',
+					arrsparsevec: ['{1:1,3:2,5:3}/5'],
+				});
+
+				const queryRes = yield* db.execute<Record<string, any>>(db.select().from(allTypesTable)).pipe(Effect.map((e) =>
+					normalizeDataWithDbCodecs({
+						db,
+						columns: getColumns(allTypesTable),
+						data: (e as any).rows as Record<string, unknown>[],
+						mode: 'query',
+					})[0]
+				));
+
+				const { relationRes, rootRes } = yield* db.execute<Record<string, any>>(db.query.allTypesTable.findFirst({
+					with: {
+						self: true,
+					},
+				})).pipe(Effect.map((e) => {
+					const [{ self: relationRaw, ...rootRaw }] = (e as any).rows;
+
+					return {
+						relationRes: normalizeDataWithDbCodecs({
+							db,
+							columns: getColumns(allTypesTable),
+							data: relationRaw,
+							mode: 'json',
+						})[0]!,
+						rootRes: normalizeDataWithDbCodecs({
+							db,
+							columns: getColumns(allTypesTable),
+							data: [rootRaw],
+							mode: 'query',
+						})[0]!,
+					};
+				}));
+
+				const expectedRes = {
+					id: 1,
+					geo: [15.23, 51.13],
+					arrgeo: [[15.23, 51.13]],
+					geoxy: { x: 15.23, y: 51.13 },
+					arrgeoxy: [{ x: 15.23, y: 51.13 }],
+					bit: '101',
+					arrbit: ['101'],
+					halfvec: [0.19995117, 3.5, 8.3984375],
+					arrhalfvec: [[0.19995117, 3.5, 8.3984375]],
+					vector: [1.9345, 2.8238, 12.3465],
+					arrvector: [[1.9345, 2.8238, 12.3465]],
+					sparsevec: '{1:1,3:2,5:3}/5',
+					arrsparsevec: ['{1:1,3:2,5:3}/5'],
+				};
+
+				expect(queryRes).toStrictEqual(expectedRes);
+				expect(relationRes).toStrictEqual(expectedRes);
+				expect(rootRes).toStrictEqual(expectedRes);
+			}));
+	},
+});
diff --git a/integration-tests/tests/pg/instrumentation.ts b/integration-tests/tests/pg/instrumentation.ts
new file mode 100644
index 0000000000..c6c3e3db71
--- /dev/null
+++ b/integration-tests/tests/pg/instrumentation.ts
@@ -0,0 +1,784 @@
+import { neon, neonConfig, type NeonQueryFunction, Pool as NeonPool } from '@neondatabase/serverless';
+
+import { PGlite } from '@electric-sql/pglite';
+import {
+	type AnyRelationsBuilderConfig,
+	defineRelations,
+	DrizzleConfig,
+	type ExtractTablesFromSchema,
+	type ExtractTablesWithRelations,
+	getTableName,
+	is,
+	type RelationsBuilder,
+	type RelationsBuilderConfig,
+	Table,
+} from 'drizzle-orm';
+import { Cache, type MutationOption } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { drizzle as drizzleNeonHttp, type NeonHttpDatabase } from 'drizzle-orm/neon-http';
+import { drizzle as drizzleNeonWs } from 'drizzle-orm/neon-serverless';
+import { drizzle as drizzleNetlify, type ServerlessDrizzleClient } from 'drizzle-orm/netlify-db';
+import { drizzle as drizzleNodePostgres, nodePgCodecs } from 'drizzle-orm/node-postgres';
+import type {
+	PgEnum,
+	PgEnumObject,
+	PgMaterializedView,
+	PgPolicy,
+	PgRole,
+	PgSchema,
+	PgSequence,
+	PgTable,
+	PgView,
+} from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async/db';
+import { drizzle as drizzleProxy } from 'drizzle-orm/pg-proxy';
+import { drizzle as drizzlePglite } from 'drizzle-orm/pglite';
+import { drizzle as drizzlePostgresjs } from 'drizzle-orm/postgres-js';
+import Keyv from 'keyv';
+import { Client as ClientNodePostgres, types as typesNodePostgres } from 'pg';
+import postgres from 'postgres';
+import { test as base } from 'vitest';
+import ws from 'ws';
+import { relations } from './relations';
+
+export type PostgresSchema = Record<
+	string,
+	| PgTable<any>
+	| PgEnum<any>
+	| PgEnumObject<any>
+	| PgSchema
+	| PgSequence
+	| PgView
+	| PgMaterializedView
+	| PgRole
+	| PgPolicy
+	| unknown
+>;
+
+neonConfig.webSocketConstructor = ws;
+
+// TODO: @L-Mario564 we need this rule only for drizzle-orm package
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private readonly strat: 'explicit' | 'all', private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy() {
+		return this.strat;
+	}
+
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+class ServerSimulator {
+	constructor(private db: ClientNodePostgres) {
+		const types = typesNodePostgres;
+
+		types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
+		types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
+		types.setTypeParser(types.builtins.DATE, (val) => val);
+		types.setTypeParser(types.builtins.INTERVAL, (val) => val);
+		types.setTypeParser(1231 as (typeof types.builtins)[keyof typeof types.builtins], (val) => val);
+		types.setTypeParser(1115 as (typeof types.builtins)[keyof typeof types.builtins], (val) => val);
+		types.setTypeParser(1185 as (typeof types.builtins)[keyof typeof types.builtins], (val) => val);
+		types.setTypeParser(1187 as (typeof types.builtins)[keyof typeof types.builtins], (val) => val);
+		types.setTypeParser(1182 as (typeof types.builtins)[keyof typeof types.builtins], (val) => val);
+	}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+					text: sql,
+					values: params,
+					rowMode: 'array',
+				});
+
+				return { data: result.rows as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+					text: sql,
+					values: params,
+				});
+
+				return { data: result.rows as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('BEGIN');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch (e) {
+			await this.db.query('ROLLBACK');
+			throw e;
+		}
+
+		return {};
+	}
+}
+
+export const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+	log?: 'statements',
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/postgres/mocks' as string);
+
+	const res = await diff({}, schema, []);
+
+	for (const s of res.sqlStatements) {
+		if (log === 'statements') console.log(s);
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+export const prepareNeonHttpClient = async (db: string) => {
+	const url = new URL(process.env['NEON_CONNECTION_STRING']!);
+	url.pathname = `/${db}`;
+	const client = neon(url.toString());
+
+	await client('drop schema if exists public, "mySchema" cascade;');
+	await client('create schema public');
+	await client('create schema "mySchema";');
+	await client(`SET TIME ZONE 'UTC';`);
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client(sql, params);
+		return res as any[];
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareNeonWsClient = async (db: string) => {
+	const url = new URL(process.env['NEON_CONNECTION_STRING']!);
+	url.pathname = `/${db}`;
+	const client = new NeonPool({ connectionString: url.toString(), max: 1 });
+
+	await client.query('drop schema if exists public, "mySchema" cascade;');
+	await client.query('create schema public');
+	await client.query('create schema "mySchema";');
+	await client.query(`SET TIME ZONE 'UTC';`);
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const preparePglite = async () => {
+	const client = new PGlite();
+	await client.query('create schema "mySchema";');
+	await client.query("SET TIME ZONE 'UTC';");
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareNodePostgres = async (db: string) => {
+	const url = new URL(process.env['PG_CONNECTION_STRING']!);
+	url.pathname = `/${db}`;
+	if (!url) throw new Error();
+
+	const client = new ClientNodePostgres(url.toString());
+	client.connect();
+
+	await client.query('drop schema if exists public, "mySchema" cascade;');
+	await client.query('create schema public');
+	await client.query('create schema "mySchema";');
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const preparePostgresjs = async (db: string) => {
+	const url = new URL(process.env['PG_CONNECTION_STRING']!);
+	url.pathname = `/${db}`;
+	if (!url) throw new Error();
+
+	const client = postgres(url.toString(), { max: 1, onnotice: () => {} });
+	await client`drop schema if exists public, "mySchema" cascade;`;
+	await client`create schema public`;
+	await client`create schema "mySchema";`;
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.unsafe(sql, params);
+		return res;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.unsafe(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareProxy = async (db: string) => {
+	const url = new URL(process.env['PG_CONNECTION_STRING']!);
+	url.pathname = `/${db}`;
+	if (!url) throw new Error();
+
+	const client = new ClientNodePostgres(url.toString());
+	client.connect();
+
+	await client.query('drop schema if exists public, "mySchema" cascade;');
+	await client.query('create schema public');
+	await client.query('create schema "mySchema";');
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareNetlifyDb = async (db: string) => {
+	const url = new URL(process.env['NETLIFY_DB_URL']!);
+	url.pathname = `/${db}`;
+	const conStr = url.toString();
+	const client: ServerlessDrizzleClient = {
+		driver: 'serverless',
+		connectionString: conStr,
+		httpClient: neon(conStr),
+		pool: new NeonPool({
+			connectionString: conStr,
+			max: 1,
+		}),
+	};
+
+	await client.pool.query('drop schema if exists public, "mySchema" cascade;');
+	await client.pool.query('create schema public');
+	await client.pool.query('create schema "mySchema";');
+	await client.pool.query(`SET TIME ZONE 'UTC';`);
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.pool.query(sql, params);
+		return res.rows as any[];
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(statements.map((x) => client.pool.query(x))).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+const providerClosure = async <T>(items: T[]) => {
+	return async () => {
+		while (true) {
+			const c = items.shift();
+			if (!c) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				continue;
+			}
+			return {
+				...c,
+				release: () => {
+					items.push(c);
+				},
+			};
+		}
+	};
+};
+
+export const providerForNeonHttp = async () => {
+	const clients = [
+		await prepareNeonHttpClient('db0'),
+		await prepareNeonHttpClient('db1'),
+		await prepareNeonHttpClient('db2'),
+		await prepareNeonHttpClient('db3'),
+		await prepareNeonHttpClient('db4'),
+	];
+
+	return providerClosure(clients);
+};
+
+export const providerForNeonWs = async () => {
+	const clients = [
+		await prepareNeonWsClient('db5'),
+		await prepareNeonWsClient('db6'),
+		await prepareNeonWsClient('db7'),
+		await prepareNeonWsClient('db8'),
+		await prepareNeonWsClient('db9'),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForPglite = async () => {
+	const clients = [
+		await preparePglite(),
+		await preparePglite(),
+		await preparePglite(),
+		await preparePglite(),
+		await preparePglite(),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForNodePostgres = async () => {
+	const url = process.env['PG_CONNECTION_STRING'];
+	if (!url) throw new Error();
+	const client = new ClientNodePostgres({ connectionString: url });
+	client.connect();
+
+	await client.query(`drop database if exists db0`);
+	await client.query(`drop database if exists db1`);
+	await client.query(`drop database if exists db2`);
+	await client.query(`drop database if exists db3`);
+	await client.query(`drop database if exists db4`);
+	await client.query('create database db0;');
+	await client.query('create database db1;');
+	await client.query('create database db2;');
+	await client.query('create database db3;');
+	await client.query('create database db4;');
+
+	const clients = [
+		await prepareNodePostgres('db0'),
+		await prepareNodePostgres('db1'),
+		await prepareNodePostgres('db2'),
+		await prepareNodePostgres('db3'),
+		await prepareNodePostgres('db4'),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForPostgresjs = async () => {
+	const url = process.env['PG_CONNECTION_STRING'];
+	if (!url) throw new Error();
+	const client = postgres(url, { max: 1, onnotice: () => {} });
+
+	await client`drop database if exists db0`;
+	await client`drop database if exists db1`;
+	await client`drop database if exists db2`;
+	await client`drop database if exists db3`;
+	await client`drop database if exists db4`;
+	await client`create database db0;`;
+	await client`create database db1;`;
+	await client`create database db2;`;
+	await client`create database db3;`;
+	await client`create database db4;`;
+
+	const clients = [
+		await preparePostgresjs('db0'),
+		await preparePostgresjs('db1'),
+		await preparePostgresjs('db2'),
+		await preparePostgresjs('db3'),
+		await preparePostgresjs('db4'),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForProxy = async () => {
+	const url = process.env['PG_CONNECTION_STRING'];
+	if (!url) throw new Error();
+	const client = new ClientNodePostgres({ connectionString: url });
+	client.connect();
+
+	await client.query(`drop database if exists db0`);
+	await client.query('create database db0;');
+
+	const clients = [
+		await prepareProxy('db0'),
+	];
+
+	return providerClosure(clients);
+};
+
+export const provideForNetlifyDb = async () => {
+	const url = process.env['NETLIFY_DB_URL']!;
+	if (!url) {
+		throw new Error('NETLIFY_DB_URL is not defined');
+	}
+
+	// WebSocket constructor for Node.js < 22
+	if (!neonConfig.webSocketConstructor && typeof WebSocket === 'undefined') {
+		neonConfig.webSocketConstructor = ws;
+	}
+
+	const clients = [
+		await prepareNetlifyDb('db10'),
+		await prepareNetlifyDb('db11'),
+		await prepareNetlifyDb('db12'),
+		await prepareNetlifyDb('db13'),
+		await prepareNetlifyDb('db14'),
+	];
+
+	return providerClosure(clients);
+};
+
+type ProviderNeonHttp = Awaited<ReturnType<typeof providerForNeonHttp>>;
+type ProviderNeonWs = Awaited<ReturnType<typeof providerForNeonWs>>;
+type ProvideForPglite = Awaited<ReturnType<typeof provideForPglite>>;
+type ProvideForNodePostgres = Awaited<ReturnType<typeof provideForNodePostgres>>;
+type ProvideForPostgresjs = Awaited<ReturnType<typeof provideForPostgresjs>>;
+type ProvideForProxy = Awaited<ReturnType<typeof provideForProxy>>;
+type ProvideForNetlifyDb = Awaited<ReturnType<typeof provideForNetlifyDb>>;
+
+type Provider =
+	| ProviderNeonHttp
+	| ProviderNeonWs
+	| ProvideForPglite
+	| ProvideForNodePostgres
+	| ProvideForPostgresjs
+	| ProvideForProxy
+	| ProvideForNetlifyDb;
+
+const testFor = (
+	vendor: 'neon-http' | 'neon-serverless' | 'pglite' | 'node-postgres' | 'postgresjs' | 'proxy' | 'netlify-db',
+) => {
+	return base.extend<{
+		provider: Provider;
+		kit: {
+			client: any;
+			query: (sql: string, params?: any[]) => Promise<any[]>;
+			batch: (statements: string[]) => Promise<any>;
+		};
+		client: any;
+		db: PgAsyncDatabase<any, typeof relations>;
+		push: (schema: any, params?: { log: 'statements' }) => Promise<void>;
+		createDB: {
+			<S extends PostgresSchema>(schema: S): PgAsyncDatabase<any, ReturnType<typeof defineRelations<S>>>;
+			<S extends PostgresSchema, TConfig extends AnyRelationsBuilderConfig>(
+				schema: S,
+				cb: (helpers: RelationsBuilder<ExtractTablesFromSchema<S>>) => TConfig,
+				useJitMappers?: boolean,
+			): PgAsyncDatabase<any, ExtractTablesWithRelations<TConfig, ExtractTablesFromSchema<S>>>;
+		};
+		caches: { all: PgAsyncDatabase<any, typeof relations>; explicit: PgAsyncDatabase<any, typeof relations> };
+	}>({
+		provider: [
+			// oxlint-disable-next-line no-empty-pattern
+			async ({}, use) => {
+				const provider = vendor === 'neon-http'
+					? await providerForNeonHttp()
+					: vendor === 'neon-serverless'
+					? await providerForNeonWs()
+					: vendor === 'pglite'
+					? await provideForPglite()
+					: vendor === 'node-postgres'
+					? await provideForNodePostgres()
+					: vendor === 'postgresjs'
+					? await provideForPostgresjs()
+					: vendor === 'proxy'
+					? await provideForProxy()
+					: vendor === 'netlify-db'
+					? await provideForNetlifyDb()
+					: '' as never;
+
+				await use(provider);
+			},
+			{ scope: 'file' },
+		],
+		kit: [
+			async ({ provider }, use) => {
+				const { client, batch, query, release } = await provider();
+				await use({ client: client as any, query, batch });
+				release();
+			},
+			{ scope: 'test' },
+		],
+		client: [
+			async ({ kit }, use) => {
+				await use(kit.client);
+			},
+			{ scope: 'test' },
+		],
+		db: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw response.error;
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from pg proxy server:', e.message);
+							throw e;
+						}
+					};
+					await use(drizzleProxy(proxyHandler, { relations, codecs: nodePgCodecs }));
+					return;
+				}
+
+				const db = vendor === 'neon-http'
+					? drizzleNeonHttp({ client: kit.client as any, relations })
+					: vendor === 'neon-serverless'
+					? drizzleNeonWs({ client: kit.client as any, relations })
+					: vendor === 'pglite'
+					? drizzlePglite({ client: kit.client as any, relations })
+					: vendor === 'node-postgres'
+					? drizzleNodePostgres({ client: kit.client as any, relations })
+					: vendor === 'postgresjs'
+					? drizzlePostgresjs({ client: kit.client as any, relations })
+					: vendor === 'netlify-db'
+					? drizzleNetlify({ client: kit.client as any, relations })
+					: '' as never;
+
+				await use(db);
+			},
+			{ scope: 'test' },
+		],
+		push: [
+			async ({ kit }, use) => {
+				const push = (
+					schema: any,
+					params?: { log: 'statements' },
+				) => _push(kit.query, schema, params?.log);
+
+				await use(push);
+			},
+			{ scope: 'test' },
+		],
+		createDB: [
+			async ({ kit }, use) => {
+				const createDB = <S extends PostgresSchema>(
+					schema: S,
+					cb?: (
+						helpers: RelationsBuilder<ExtractTablesFromSchema<S>>,
+					) => RelationsBuilderConfig<ExtractTablesFromSchema<S>>,
+					useJitMappers?: boolean,
+				) => {
+					const relations = cb ? defineRelations(schema, cb) : defineRelations(schema);
+
+					if (vendor === 'neon-http') {
+						return drizzleNeonHttp({ client: kit.client, relations, jit: useJitMappers });
+					}
+					if (vendor === 'neon-serverless') {
+						return drizzleNeonWs({ client: kit.client as any, relations, jit: useJitMappers });
+					}
+					if (vendor === 'pglite') {
+						return drizzlePglite({ client: kit.client as any, relations, jit: useJitMappers });
+					}
+					if (vendor === 'node-postgres') {
+						return drizzleNodePostgres({ client: kit.client as any, relations, jit: useJitMappers });
+					}
+					if (vendor === 'postgresjs') {
+						return drizzlePostgresjs({ client: kit.client as any, relations, jit: useJitMappers });
+					}
+					if (vendor === 'netlify-db') {
+						return drizzleNetlify({ client: kit.client as any, relations, jit: useJitMappers });
+					}
+
+					if (vendor === 'proxy') {
+						const serverSimulator = new ServerSimulator(kit.client);
+						const proxyHandler = async (sql: string, params: any[], method: any) => {
+							try {
+								const response = await serverSimulator.query(sql, params, method);
+
+								if (response.error !== undefined) {
+									throw response.error;
+								}
+
+								return { rows: response.data };
+							} catch (e: any) {
+								console.error('Error from pg proxy server:', e.message);
+								throw e;
+							}
+						};
+						return drizzleProxy(proxyHandler, { relations, codecs: nodePgCodecs, jit: useJitMappers });
+					}
+					throw new Error();
+				};
+
+				await use(createDB);
+			},
+			{ scope: 'test' },
+		],
+		caches: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw response.error;
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from pg proxy server:', e.message);
+							throw e;
+						}
+					};
+					const db1 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('all'), codecs: nodePgCodecs });
+					const db2 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('explicit'), codecs: nodePgCodecs });
+					await use({ all: db1, explicit: db2 });
+					return;
+				}
+
+				const config1 = { client: kit.client as any, relations, cache: new TestCache('all') };
+				const config2 = { client: kit.client as any, relations, cache: new TestCache('explicit') };
+
+				const db1 = vendor === 'neon-http'
+					? drizzleNeonHttp(config1)
+					: vendor === 'neon-serverless'
+					? drizzleNeonWs(config1)
+					: vendor === 'pglite'
+					? drizzlePglite(config1)
+					: vendor === 'node-postgres'
+					? drizzleNodePostgres(config1)
+					: vendor === 'postgresjs'
+					? drizzlePostgresjs(config1)
+					: vendor === 'netlify-db'
+					? drizzleNetlify(config1)
+					: '' as never;
+
+				const db2 = vendor === 'neon-http'
+					? drizzleNeonHttp(config2)
+					: vendor === 'neon-serverless'
+					? drizzleNeonWs(config2)
+					: vendor === 'pglite'
+					? drizzlePglite(config2)
+					: vendor === 'node-postgres'
+					? drizzleNodePostgres(config2)
+					: vendor === 'postgresjs'
+					? drizzlePostgresjs(config2)
+					: vendor === 'netlify-db'
+					? drizzleNetlify(config2)
+					: '' as never;
+
+				await use({ all: db1, explicit: db2 });
+			},
+			{ scope: 'test' },
+		],
+	});
+};
+
+export const neonHttpTest = testFor('neon-http').extend<{ neonhttp: NeonHttpDatabase }>({
+	neonhttp: [
+		async ({ kit }, use) => {
+			const db = drizzleNeonHttp({ client: kit.client as NeonQueryFunction<false, false>, relations });
+			await use(db);
+		},
+		{ scope: 'test' },
+	],
+});
+
+export const neonWsTest = testFor('neon-serverless');
+export const pgliteTest = testFor('pglite');
+export const nodePostgresTest = testFor('node-postgres');
+export const postgresjsTest = testFor('postgresjs');
+export const netlifyDbTest = testFor('netlify-db');
+export const proxyTest = testFor('proxy').extend<{ simulator: ServerSimulator }>({
+	simulator: [
+		async ({ client }, use) => {
+			const simulator = new ServerSimulator(client);
+			await use(simulator);
+		},
+		{ scope: 'test' },
+	],
+});
+
+export type Test = ReturnType<typeof testFor>;
diff --git a/integration-tests/tests/pg/neon-http-batch.test.ts b/integration-tests/tests/pg/neon-http-batch.test.ts
index 2c5a71bf6c..d400af923c 100644
--- a/integration-tests/tests/pg/neon-http-batch.test.ts
+++ b/integration-tests/tests/pg/neon-http-batch.test.ts
@@ -1,27 +1,109 @@
-import { neon, type NeonQueryFunction } from '@neondatabase/serverless';
-import { drizzle, type NeonHttpDatabase } from 'drizzle-orm/neon-http';
-import { beforeAll, beforeEach, expect, test } from 'vitest';
-import {
-	commentLikesConfig,
-	commentsConfig,
-	commentsTable,
-	groupsConfig,
-	groupsTable,
-	postsConfig,
-	postsTable,
-	usersConfig,
-	usersTable,
-	usersToGroupsConfig,
-	usersToGroupsTable,
-} from './neon-http-batch';
-import { TestCache, TestGlobalCache } from './pg-common-cache';
+import { defineRelations, eq, sql } from 'drizzle-orm';
+import { relations as oldRels } from 'drizzle-orm/_relations';
+import { drizzle, type NeonHttpDatabase, type NeonHttpQueryResult } from 'drizzle-orm/neon-http';
+import { type AnyPgColumn, integer, pgTable, primaryKey, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { describe, expect, expectTypeOf, test as base } from 'vitest';
+import { _push, prepareNeonHttpClient } from './instrumentation';
 
-const ENABLE_LOGGING = false;
+export const usersTable = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: integer('verified').notNull().default(0),
+	invitedBy: integer('invited_by').references((): AnyPgColumn => usersTable.id),
+});
+export const usersConfig = oldRels(usersTable, ({ one, many }) => ({
+	invitee: one(usersTable, {
+		fields: [usersTable.invitedBy],
+		references: [usersTable.id],
+	}),
+	usersToGroups: many(usersToGroupsTable),
+	posts: many(postsTable),
+}));
+
+export const groupsTable = pgTable('groups', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	description: text('description'),
+});
+export const groupsConfig = oldRels(groupsTable, ({ many }) => ({
+	usersToGroups: many(usersToGroupsTable),
+}));
+
+export const usersToGroupsTable = pgTable(
+	'users_to_groups',
+	{
+		id: serial('id'),
+		userId: integer('user_id').notNull().references(() => usersTable.id),
+		groupId: integer('group_id').notNull().references(() => groupsTable.id),
+	},
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
+);
+export const usersToGroupsConfig = oldRels(usersToGroupsTable, ({ one }) => ({
+	group: one(groupsTable, {
+		fields: [usersToGroupsTable.groupId],
+		references: [groupsTable.id],
+	}),
+	user: one(usersTable, {
+		fields: [usersToGroupsTable.userId],
+		references: [usersTable.id],
+	}),
+}));
+
+export const postsTable = pgTable('posts', {
+	id: serial('id').primaryKey(),
+	content: text('content').notNull(),
+	ownerId: integer('owner_id').references(() => usersTable.id),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+export const postsConfig = oldRels(postsTable, ({ one, many }) => ({
+	author: one(usersTable, {
+		fields: [postsTable.ownerId],
+		references: [usersTable.id],
+	}),
+	comments: many(commentsTable),
+}));
+
+export const commentsTable = pgTable('comments', {
+	id: serial('id').primaryKey(),
+	content: text('content').notNull(),
+	creator: integer('creator').references(() => usersTable.id),
+	postId: integer('post_id').references(() => postsTable.id),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+export const commentsConfig = oldRels(commentsTable, ({ one, many }) => ({
+	post: one(postsTable, {
+		fields: [commentsTable.postId],
+		references: [postsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentsTable.creator],
+		references: [usersTable.id],
+	}),
+	likes: many(commentLikesTable),
+}));
+
+export const commentLikesTable = pgTable('comment_likes', {
+	id: serial('id').primaryKey(),
+	creator: integer('creator').references(() => usersTable.id),
+	commentId: integer('comment_id').references(() => commentsTable.id),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+export const commentLikesConfig = oldRels(commentLikesTable, ({ one }) => ({
+	comment: one(commentsTable, {
+		fields: [commentLikesTable.commentId],
+		references: [commentsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentLikesTable.creator],
+		references: [usersTable.id],
+	}),
+}));
 
 export const schema = {
 	usersTable,
 	postsTable,
 	commentsTable,
+	commentLikesTable,
 	usersToGroupsTable,
 	groupsTable,
 	commentLikesConfig,
@@ -32,38 +114,368 @@ export const schema = {
 	usersConfig,
 };
 
-let db: NeonHttpDatabase<typeof schema>;
-let client: NeonQueryFunction<false, true>;
-let dbGlobalCached: NeonHttpDatabase;
-let cachedDb: NeonHttpDatabase;
-
-beforeAll(async () => {
-	const connectionString = process.env['NEON_HTTP_CONNECTION_STRING'];
-	if (!connectionString) {
-		throw new Error('NEON_HTTP_CONNECTION_STRING is not defined');
-	}
-	client = neon(connectionString);
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestCache(),
+export const relations = defineRelations(schema);
+
+const test = base.extend<{ db: NeonHttpDatabase<typeof relations> }>({
+	db: [
+		// oxlint-disable-next-line no-empty-pattern
+		async ({}, use) => {
+			const { client, query } = await prepareNeonHttpClient('db6');
+			await _push(query, schema);
+
+			const db = drizzle({ client, relations });
+			await use(db);
+		},
+		{ scope: 'file' },
+	],
+});
+
+describe('batch', () => {
+	test.beforeEach(async ({ db }) => {
+		await db.execute(
+			`truncate table users, groups, users_to_groups, posts, comments, comment_likes RESTART IDENTITY CASCADE;`,
+		);
 	});
-	dbGlobalCached = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestGlobalCache(),
+
+	test('batch api example', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
+				id: usersTable.id,
+				invitedBy: usersTable.invitedBy,
+			}),
+			db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+			db.select().from(usersTable),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+				invitedBy: number | null;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+		]>();
+
+		expect(batchResponse.length).eq(3);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+			invitedBy: null,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, name: 'John', verified: 0, invitedBy: null },
+			{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+		]);
 	});
-});
 
-beforeEach((ctx) => {
-	ctx.neonPg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
+	// batch api only relational many
+	test('insert + findMany', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+			db.query.usersTable.findMany({}),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+		]>();
+
+		expect(batchResponse.length).eq(3);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, name: 'John', verified: 0, invitedBy: null },
+			{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+		]);
+	});
+
+	// batch api relational many + one
+	test('insert + findMany + findFirst', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+			db.query.usersTable.findMany({}),
+			db.query.usersTable.findFirst({}),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | undefined,
+		]>();
+
+		expect(batchResponse.length).eq(4);
 
-test('skip', async () => {
-	expect(1).toBe(1);
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, name: 'John', verified: 0, invitedBy: null },
+			{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+		]);
+
+		expect(batchResponse[3]).toEqual(
+			{ id: 1, name: 'John', verified: 0, invitedBy: null },
+		);
+	});
+
+	test('insert + db.execute', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.execute(sql`insert into users (id, name) values (2, 'Dan')`),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<Record<string, unknown>>,
+		]>();
+
+		expect(batchResponse.length).eq(2);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rowAsArray: false, rows: [], rowCount: 1 });
+	});
+
+	// batch api combined rqb + raw call
+	test('insert + findManyWith + db.all', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+			db.query.usersTable.findMany({}),
+			db.execute<typeof usersTable.$inferSelect>(sql`select * from users`),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+			NeonHttpQueryResult<{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}>,
+		]>();
+
+		expect(batchResponse.length).eq(4);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rowAsArray: false, rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, name: 'John', verified: 0, invitedBy: null },
+			{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+		]);
+
+		expect(batchResponse[3]).toMatchObject({
+			rows: [
+				{ id: 1, name: 'John', verified: 0, invited_by: null },
+				{ id: 2, name: 'Dan', verified: 0, invited_by: null },
+			],
+		});
+	});
+
+	// batch api for insert + update + select
+	test('insert + update + select + select partial', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+			db.query.usersTable.findMany({}),
+			db.select().from(usersTable).where(eq(usersTable.id, 1)),
+			db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(usersTable),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+			{
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[],
+			{
+				id: number;
+				invitedBy: number | null;
+			}[],
+		]>();
+
+		expect(batchResponse.length).eq(5);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		]);
+
+		expect(batchResponse[3]).toEqual([
+			{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		]);
+
+		expect(batchResponse[4]).toEqual([
+			{ id: 1, invitedBy: null },
+		]);
+	});
+
+	// batch api for insert + delete + select
+	test('insert + delete + select + select partial', async ({ db }) => {
+		const batchResponse = await db.batch([
+			db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+			db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+			db.delete(usersTable).where(eq(usersTable.id, 1)).returning({
+				id: usersTable.id,
+				invitedBy: usersTable.invitedBy,
+			}),
+			db.query.usersTable.findFirst({
+				columns: {
+					id: true,
+					invitedBy: true,
+				},
+			}),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			{
+				id: number;
+			}[],
+			NeonHttpQueryResult<never>,
+			{
+				id: number;
+				invitedBy: number | null;
+			}[],
+			{
+				id: number;
+				invitedBy: number | null;
+			} | undefined,
+		]>();
+
+		expect(batchResponse.length).eq(4);
+
+		expect(batchResponse[0]).toEqual([{
+			id: 1,
+		}]);
+
+		expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
+
+		expect(batchResponse[2]).toEqual([
+			{ id: 1, invitedBy: null },
+		]);
+
+		expect(batchResponse[3]).toEqual(
+			{ id: 2, invitedBy: null },
+		);
+	});
+
+	test('select raw', async ({ db }) => {
+		await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Dan' }]);
+		const batchResponse = await db.batch([
+			db.execute<{
+				id: number;
+				name: string;
+				verified: number;
+				invited_by: number | null;
+			}>(sql`select * from users`),
+			db.execute<{
+				id: number;
+				name: string;
+				verified: number;
+				invited_by: number | null;
+			}>(sql`select * from users where id = 1`),
+		]);
+
+		expectTypeOf(batchResponse).toEqualTypeOf<[
+			NeonHttpQueryResult<{
+				id: number;
+				name: string;
+				verified: number;
+				invited_by: number | null;
+			}>,
+			NeonHttpQueryResult<{
+				id: number;
+				name: string;
+				verified: number;
+				invited_by: number | null;
+			}>,
+		]>();
+
+		expect(batchResponse.length).eq(2);
+
+		expect(batchResponse[0]).toMatchObject({
+			rows: [
+				{ id: 1, name: 'John', verified: 0, invited_by: null },
+				{ id: 2, name: 'Dan', verified: 0, invited_by: null },
+			],
+		});
+
+		expect(batchResponse[1]).toMatchObject({
+			rows: [
+				{ id: 1, name: 'John', verified: 0, invited_by: null },
+			],
+		});
+	});
 });
diff --git a/integration-tests/tests/pg/neon-http-batch.ts b/integration-tests/tests/pg/neon-http-batch.ts
deleted file mode 100644
index e2cc57ae2a..0000000000
--- a/integration-tests/tests/pg/neon-http-batch.ts
+++ /dev/null
@@ -1,556 +0,0 @@
-import Docker from 'dockerode';
-import type { InferSelectModel } from 'drizzle-orm';
-import { eq, relations, sql } from 'drizzle-orm';
-import type { NeonHttpQueryResult } from 'drizzle-orm/neon-http';
-import { integer, pgTable, primaryKey, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import type { AnyPgColumn } from 'drizzle-orm/pg-core';
-import getPort from 'get-port';
-import { v4 as uuidV4 } from 'uuid';
-import { afterAll, beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
-
-export const usersTable = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: integer('verified').notNull().default(0),
-	invitedBy: integer('invited_by').references((): AnyPgColumn => usersTable.id),
-});
-export const usersConfig = relations(usersTable, ({ one, many }) => ({
-	invitee: one(usersTable, {
-		fields: [usersTable.invitedBy],
-		references: [usersTable.id],
-	}),
-	usersToGroups: many(usersToGroupsTable),
-	posts: many(postsTable),
-}));
-
-export const groupsTable = pgTable('groups', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	description: text('description'),
-});
-export const groupsConfig = relations(groupsTable, ({ many }) => ({
-	usersToGroups: many(usersToGroupsTable),
-}));
-
-export const usersToGroupsTable = pgTable(
-	'users_to_groups',
-	{
-		id: serial('id'),
-		userId: integer('user_id').notNull().references(() => usersTable.id),
-		groupId: integer('group_id').notNull().references(() => groupsTable.id),
-	},
-	(t) => ({
-		pk: primaryKey({ columns: [t.userId, t.groupId] }),
-	}),
-);
-export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
-	group: one(groupsTable, {
-		fields: [usersToGroupsTable.groupId],
-		references: [groupsTable.id],
-	}),
-	user: one(usersTable, {
-		fields: [usersToGroupsTable.userId],
-		references: [usersTable.id],
-	}),
-}));
-
-export const postsTable = pgTable('posts', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	ownerId: integer('owner_id').references(() => usersTable.id),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-export const postsConfig = relations(postsTable, ({ one, many }) => ({
-	author: one(usersTable, {
-		fields: [postsTable.ownerId],
-		references: [usersTable.id],
-	}),
-	comments: many(commentsTable),
-}));
-
-export const commentsTable = pgTable('comments', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	creator: integer('creator').references(() => usersTable.id),
-	postId: integer('post_id').references(() => postsTable.id),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
-	post: one(postsTable, {
-		fields: [commentsTable.postId],
-		references: [postsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentsTable.creator],
-		references: [usersTable.id],
-	}),
-	likes: many(commentLikesTable),
-}));
-
-export const commentLikesTable = pgTable('comment_likes', {
-	id: serial('id').primaryKey(),
-	creator: integer('creator').references(() => usersTable.id),
-	commentId: integer('comment_id').references(() => commentsTable.id),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
-	comment: one(commentsTable, {
-		fields: [commentLikesTable.commentId],
-		references: [commentsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentLikesTable.creator],
-		references: [usersTable.id],
-	}),
-}));
-
-let pgContainer: Docker.Container;
-export async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuidV4()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-afterAll(async () => {
-	await pgContainer?.stop().catch(console.error);
-});
-
-export function tests() {
-	describe('common', () => {
-		beforeEach(async (ctx) => {
-			const { db } = ctx.pg;
-			await db.execute(sql`drop schema if exists public cascade`);
-			await db.execute(sql`drop schema if exists mySchema cascade`);
-
-			await db.execute(
-				sql`
-					create table users (
-					    id serial primary key,
-					    name text not null,
-					    verified int not null default 0,
-					    invited_by int references users(id)
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table groups (
-					    id serial primary key,
-					    name text not null,
-					    description text
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table users_to_groups (
-					    id serial,
-					    user_id int not null references users(id),
-					    group_id int not null references groups(id),
-					    primary key (user_id, group_id)
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table posts (
-					    id serial primary key,
-					    content text not null,
-					    owner_id int references users(id),
-					    created_at timestamp not null default now()
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table comments (
-					    id serial primary key,
-					    content text not null,
-					    creator int references users(id),
-					    post_id int references posts(id),
-					    created_at timestamp not null default now()
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table comment_likes (
-					    id serial primary key,
-					    creator int references users(id),
-					    comment_id int references comments(id),
-					    created_at timestamp not null default now()
-					)
-				`,
-			);
-		});
-
-		test('batch api example', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
-					id: usersTable.id,
-					invitedBy: usersTable.invitedBy,
-				}),
-				db.insert(usersTable).values({ id: 2, name: 'Dan' }),
-				db.select().from(usersTable),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-					invitedBy: number | null;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-			]>();
-
-			expect(batchResponse.length).eq(3);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-				invitedBy: null,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, name: 'John', verified: 0, invitedBy: null },
-				{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-		});
-
-		// batch api only relational many
-		test('insert + findMany', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.insert(usersTable).values({ id: 2, name: 'Dan' }),
-				db.query.usersTable.findMany({}),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-			]>();
-
-			expect(batchResponse.length).eq(3);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, name: 'John', verified: 0, invitedBy: null },
-				{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-		});
-
-		// batch api relational many + one
-		test('insert + findMany + findFirst', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.insert(usersTable).values({ id: 2, name: 'Dan' }),
-				db.query.usersTable.findMany({}),
-				db.query.usersTable.findFirst({}),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				} | undefined,
-			]>();
-
-			expect(batchResponse.length).eq(4);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, name: 'John', verified: 0, invitedBy: null },
-				{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-
-			expect(batchResponse[3]).toEqual(
-				{ id: 1, name: 'John', verified: 0, invitedBy: null },
-			);
-		});
-
-		test('insert + db.execute', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.execute(sql`insert into users (id, name) values (2, 'Dan')`),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<Record<string, unknown>>,
-			]>();
-
-			expect(batchResponse.length).eq(2);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rowAsArray: false, rows: [], rowCount: 1 });
-		});
-
-		// batch api combined rqb + raw call
-		test('insert + findManyWith + db.all', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.insert(usersTable).values({ id: 2, name: 'Dan' }),
-				db.query.usersTable.findMany({}),
-				db.execute<typeof usersTable.$inferSelect>(sql`select * from users`),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-				NeonHttpQueryResult<{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}>,
-			]>();
-
-			expect(batchResponse.length).eq(4);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rowAsArray: true, rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, name: 'John', verified: 0, invitedBy: null },
-				{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-
-			expect(batchResponse[3]).toMatchObject({
-				rows: [
-					{ id: 1, name: 'John', verified: 0, invited_by: null },
-					{ id: 2, name: 'Dan', verified: 0, invited_by: null },
-				],
-			});
-		});
-
-		// batch api for insert + update + select
-		test('insert + update + select + select partial', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
-				db.query.usersTable.findMany({}),
-				db.select().from(usersTable).where(eq(usersTable.id, 1)),
-				db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(usersTable),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-				{
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				}[],
-				{
-					id: number;
-					invitedBy: number | null;
-				}[],
-			]>();
-
-			expect(batchResponse.length).eq(5);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-
-			expect(batchResponse[3]).toEqual([
-				{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
-			]);
-
-			expect(batchResponse[4]).toEqual([
-				{ id: 1, invitedBy: null },
-			]);
-		});
-
-		// batch api for insert + delete + select
-		test('insert + delete + select + select partial', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			const batchResponse = await db.batch([
-				db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
-				db.insert(usersTable).values({ id: 2, name: 'Dan' }),
-				db.delete(usersTable).where(eq(usersTable.id, 1)).returning({
-					id: usersTable.id,
-					invitedBy: usersTable.invitedBy,
-				}),
-				db.query.usersTable.findFirst({
-					columns: {
-						id: true,
-						invitedBy: true,
-					},
-				}),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				{
-					id: number;
-				}[],
-				NeonHttpQueryResult<never>,
-				{
-					id: number;
-					invitedBy: number | null;
-				}[],
-				{
-					id: number;
-					invitedBy: number | null;
-				} | undefined,
-			]>();
-
-			expect(batchResponse.length).eq(4);
-
-			expect(batchResponse[0]).toEqual([{
-				id: 1,
-			}]);
-
-			expect(batchResponse[1]).toMatchObject({ rows: [], rowCount: 1 });
-
-			expect(batchResponse[2]).toEqual([
-				{ id: 1, invitedBy: null },
-			]);
-
-			expect(batchResponse[3]).toEqual(
-				{ id: 2, invitedBy: null },
-			);
-		});
-
-		test('select raw', async (ctx) => {
-			const { db } = ctx.neonPg;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Dan' }]);
-			const batchResponse = await db.batch([
-				db.execute<InferSelectModel<typeof usersTable, { dbColumnNames: true }>>(sql`select * from users`),
-				db.execute<InferSelectModel<typeof usersTable, { dbColumnNames: true }>>(sql`select * from users where id = 1`),
-			]);
-
-			expectTypeOf(batchResponse).toEqualTypeOf<[
-				NeonHttpQueryResult<{
-					id: number;
-					name: string;
-					verified: number;
-					invited_by: number | null;
-				}>,
-				NeonHttpQueryResult<{
-					id: number;
-					name: string;
-					verified: number;
-					invited_by: number | null;
-				}>,
-			]>();
-
-			expect(batchResponse.length).eq(2);
-
-			expect(batchResponse[0]).toMatchObject({
-				rows: [
-					{ id: 1, name: 'John', verified: 0, invited_by: null },
-					{ id: 2, name: 'Dan', verified: 0, invited_by: null },
-				],
-			});
-
-			expect(batchResponse[1]).toMatchObject({
-				rows: [
-					{ id: 1, name: 'John', verified: 0, invited_by: null },
-				],
-			});
-		});
-	});
-}
diff --git a/integration-tests/tests/pg/neon-http.test.ts b/integration-tests/tests/pg/neon-http.test.ts
index 863680316e..7aa5f59a48 100644
--- a/integration-tests/tests/pg/neon-http.test.ts
+++ b/integration-tests/tests/pg/neon-http.test.ts
@@ -1,500 +1,573 @@
-import { neon, neonConfig, type NeonQueryFunction } from '@neondatabase/serverless';
-import { eq, sql } from 'drizzle-orm';
-import { drizzle, type NeonHttpDatabase } from 'drizzle-orm/neon-http';
+import type { NeonQueryFunction } from '@neondatabase/serverless';
+import { defineRelations, eq, getColumns, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/neon-http';
 import { migrate } from 'drizzle-orm/neon-http/migrator';
-import { pgMaterializedView, pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { skipTests } from '~/common';
+import {
+	bigint,
+	bigserial,
+	boolean,
+	bytea,
+	char,
+	cidr,
+	date,
+	doublePrecision,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgMaterializedView,
+	pgTable,
+	point,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { getTableConfig } from 'drizzle-orm/pg-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe, expect, expectTypeOf, vi } from 'vitest';
 import { randomString } from '~/utils';
-import { tests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: NeonHttpDatabase;
-let dbGlobalCached: NeonHttpDatabase;
-let cachedDb: NeonHttpDatabase;
-
-beforeAll(async () => {
-	const connectionString = process.env['NEON_HTTP_CONNECTION_STRING'];
-	if (!connectionString) {
-		throw new Error('NEON_CONNECTION_STRING is not defined');
-	}
-
-	neonConfig.fetchEndpoint = (host) => {
-		const [protocol, port] = host === 'db.localtest.me' ? ['http', 4444] : ['https', 443];
-		return `${protocol}://${host}:${port}/sql`;
-	};
-	const client = neon(connectionString);
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestCache(),
-	});
-	dbGlobalCached = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestGlobalCache(),
+import { tests } from './common';
+import { neonHttpTest as test } from './instrumentation';
+import { usersMigratorTable, usersTable } from './schema';
+
+const skips = [
+	'RQB v2 transaction find first - no rows',
+	'RQB v2 transaction find first - multiple rows',
+	'RQB v2 transaction find first - with relation',
+	'RQB v2 transaction find first - placeholders',
+	'RQB v2 transaction find many - no rows',
+	'RQB v2 transaction find many - multiple rows',
+	'RQB v2 transaction find many - with relation',
+	'RQB v2 transaction find many - placeholders',
+];
+
+// COMMON
+tests(test, skips);
+
+describe('migrator', () => {
+	test.beforeEach(async ({ db }) => {
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+		await db.execute(
+			sql`
+			create table users (
+				id serial primary key,
+				name text not null,
+				verified boolean not null default false,
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+		);
 	});
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	test('migrator : default migration strategy', async ({ neonhttp: db }) => {
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	const result = await db.select().from(usersMigratorTable);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
 
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		const result = await db.select().from(usersMigratorTable);
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-test('migrator : migrate with custom schema', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await db.execute(sql`drop table all_columns, users12, "drizzle"."__drizzle_migrations"`);
+	});
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
+	test('migrator : migrate with custom schema', async ({ neonhttp: db }) => {
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, custom_migrations."__drizzle_migrations"`);
+	});
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	test('migrator : migrate with custom table', async ({ neonhttp: db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations."__drizzle_migrations"`);
-});
-
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, "drizzle".${sql.identifier(customTable)}`);
+	});
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+	test('migrator : migrate with custom table and custom schema', async ({ neonhttp: db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable: customTable,
+			migrationsSchema: 'custom_migrations',
+		});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(
+			sql`select * from custom_migrations.${sql.identifier(customTable)};`,
+		);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, custom_migrations.${sql.identifier(customTable)}`);
+	});
+
+	test('migrator : --init', async ({ neonhttp: db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ neonhttp: db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
 
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
 
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: 'custom_migrations',
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
 	});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(
-		sql`select * from custom_migrations.${sql.identifier(customTable)};`,
-	);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+	test('migrator : --init - db migrations error', async ({ neonhttp: db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations.${sql.identifier(customTable)}`);
-});
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
 
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
-	});
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ neonhttp: db }) => {
+		const users = pgTable('migrations_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
 
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
+		const users2 = pgTable('migrations_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
 
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
+		await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/postgres-neon-http';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migrations_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migrations_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migrations_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
+
+	test('all date and time columns without timezone first case mode string', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
 
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
+		await push({ table });
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+		// 1. Insert date in string format without timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01 02:00:00.123456' },
+		]);
 
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select in string format and check that values are the same
+		const result = await db.select().from(table);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3. Select as raw query and check that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
+	test('all date and time columns without timezone second case mode string', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
 
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		await push({ table });
 
-	expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01T02:00:00.123456-02' },
+		]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 2, Select as raw query and check that values are the same
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) not null
-			)
-	`);
-
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+	test('all date and time columns without timezone third case mode date', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		});
 
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
+		await push({ table });
 
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		const insertedDate = new Date('2022-01-01 20:00:00.123+04');
 
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+		// 1. Insert date as new date
+		await db.insert(table).values([
+			{ timestamp: insertedDate },
+		]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 2, Select as raw query as string
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+		expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+	test('test mode string for timestamp with timezone', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		await push({ table });
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) with time zone not null
-			)
-	`);
-
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+	test('test mode date for timestamp with timezone', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		});
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+		await push({ table });
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		const timestampString = new Date('2022-01-01 00:00:00.456-0200');
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
 
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode string for timestamp with timezone in UTC timezone', async ({ db, push }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
+		// set timezone to UTC
+		await db.execute(sql`set time zone 'UTC'`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const table = pgTable('all_columns_6', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		await push({ table });
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-test.skip('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+	});
 
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
+	test.skip('test mode string for timestamp with timezone in different timezone', async ({ db }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		// set timezone to HST (UTC - 10)
+		await db.execute(sql`set time zone 'HST'`);
+
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
+		const timestampString = '2022-01-01 00:00:00.123456-1000';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456+00' }]);
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456+00' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'nested transaction rollback',
-	'transaction rollback',
-	'nested transaction',
-	'transaction',
-	'timestamp timezone',
-	'test $onUpdateFn and $onUpdate works as $default',
-]);
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false,
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
-	);
+	test('insert via db.execute + select via db.execute', async ({ db }) => {
+		await db.execute(
+			sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+		);
 
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from "users"`,
+		);
+		expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('insert via db.execute + returning', async ({ db }) => {
+		const inserted = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${
+				sql.identifier(
+					usersTable.name.name,
+				)
+			}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	test('insert via db.execute w/ query builder', async ({ db }) => {
+		const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 });
 
 describe('$withAuth tests', (it) => {
 	const client = vi.fn();
 	const db = drizzle({
 		client: client as any as NeonQueryFunction<any, any>,
-		schema: {
-			usersTable,
-		},
+		relations: defineRelations({ usersTable }),
 	});
 
 	it('$count', async () => {
 		await db.$withAuth('$count').$count(usersTable).catch(() => null);
 
-		expect(client.mock.lastCall?.[2]).toStrictEqual({ arrayMode: false, fullResults: true, authToken: '$count' });
+		expect(client.mock.lastCall?.[2]).toStrictEqual({ arrayMode: true, fullResults: true, authToken: '$count' });
 	});
 
 	it('delete', async () => {
@@ -552,10 +625,10 @@ describe('$withAuth tests', (it) => {
 		expect(client.mock.lastCall?.[2]).toStrictEqual({ arrayMode: true, fullResults: true, authToken: 'with' });
 	});
 
-	it('rqb', async () => {
-		await db.$withAuth('rqb').query.usersTable.findFirst().catch(() => null);
+	it('rqbV2', async () => {
+		await db.$withAuth('rqbV2').query.usersTable.findFirst().catch(() => null);
 
-		expect(client.mock.lastCall?.[2]).toStrictEqual({ arrayMode: true, fullResults: true, authToken: 'rqb' });
+		expect(client.mock.lastCall?.[2]).toStrictEqual({ arrayMode: true, fullResults: true, authToken: 'rqbV2' });
 	});
 
 	it('exec', async () => {
@@ -590,9 +663,7 @@ describe('$withAuth callback tests', (it) => {
 	const client = vi.fn();
 	const db = drizzle({
 		client: client as any as NeonQueryFunction<any, any>,
-		schema: {
-			usersTable,
-		},
+		relations: defineRelations({ usersTable }),
 	});
 	const auth = (token: string) => () => token;
 
@@ -651,10 +722,10 @@ describe('$withAuth callback tests', (it) => {
 		expect(client.mock.lastCall?.[2]['authToken']()).toStrictEqual('with');
 	});
 
-	it('rqb', async () => {
-		await db.$withAuth(auth('rqb')).query.usersTable.findFirst().catch(() => null);
+	it('rqbV2', async () => {
+		await db.$withAuth(auth('rqbV2')).query.usersTable.findFirst().catch(() => null);
 
-		expect(client.mock.lastCall?.[2]['authToken']()).toStrictEqual('rqb');
+		expect(client.mock.lastCall?.[2]['authToken']()).toStrictEqual('rqbV2');
 	});
 
 	it('exec', async () => {
@@ -685,9 +756,7 @@ describe('$withAuth async callback tests', (it) => {
 	const client = vi.fn();
 	const db = drizzle({
 		client: client as any as NeonQueryFunction<any, any>,
-		schema: {
-			usersTable,
-		},
+		relations: defineRelations({ usersTable }),
 	});
 	const auth = (token: string) => async () => token;
 
@@ -754,11 +823,11 @@ describe('$withAuth async callback tests', (it) => {
 		expect(await client.mock.lastCall?.[2]['authToken']()).toStrictEqual('with');
 	});
 
-	it('rqb', async () => {
-		await db.$withAuth(auth('rqb')).query.usersTable.findFirst().catch(() => null);
+	it('rqbV2', async () => {
+		await db.$withAuth(auth('rqbV2')).query.usersTable.findFirst().catch(() => null);
 
 		expect(client.mock.lastCall?.[2]['authToken']()).toBeInstanceOf(Promise);
-		expect(await client.mock.lastCall?.[2]['authToken']()).toStrictEqual('rqb');
+		expect(await client.mock.lastCall?.[2]['authToken']()).toStrictEqual('rqbV2');
 	});
 
 	it('exec', async () => {
diff --git a/integration-tests/tests/pg/neon-serverless.test.ts b/integration-tests/tests/pg/neon-serverless.test.ts
index 703f59696a..a515d5fbb2 100644
--- a/integration-tests/tests/pg/neon-serverless.test.ts
+++ b/integration-tests/tests/pg/neon-serverless.test.ts
@@ -1,585 +1,648 @@
-import { neonConfig, Pool } from '@neondatabase/serverless';
 import { eq, sql } from 'drizzle-orm';
-import { drizzle, type NeonDatabase } from 'drizzle-orm/neon-serverless';
 import { migrate } from 'drizzle-orm/neon-serverless/migrator';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import ws from 'ws';
-import { skipTests } from '~/common';
+import { getTableConfig, integer, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async/db';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe } from 'node:test';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
-import { mySchema, tests, usersMigratorTable, usersMySchemaTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: NeonDatabase;
-let dbGlobalCached: NeonDatabase;
-let cachedDb: NeonDatabase;
-let client: Pool;
-
-neonConfig.wsProxy = (host) => `${host}:5446/v1`;
-neonConfig.useSecureWebSocket = false;
-neonConfig.pipelineTLS = false;
-neonConfig.pipelineConnect = false;
-neonConfig.webSocketConstructor = ws;
-
-beforeAll(async () => {
-	const connectionString = process.env['NEON_SERVERLESS_CONNECTION_STRING'];
-	if (!connectionString) {
-		throw new Error('NEON_SERVERLESS_CONNECTION_STRING is not defined');
-	}
-
-	client = new Pool({ connectionString });
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestCache(),
+import { tests } from './common';
+import { neonWsTest as test } from './instrumentation';
+import { usersMigratorTable, usersMySchemaTable, usersTable } from './schema';
+
+/*
+	it doesn't work as expected, scope: "file" treats all these tests as 1 file
+	thus extra execute statements below
+ */
+tests(test, []);
+
+describe('neon-serverless', () => {
+	let db: PgAsyncDatabase<any, any>;
+	test.sequential('_', async ({ db: _db, push }) => {
+		db = _db;
+
+		await db.execute('drop schema if exists public, "mySchema" cascade;');
+		await db.execute('create schema public');
+		await db.execute('create schema "mySchema";');
+
+		await push({ usersTable, usersMySchemaTable });
 	});
-	dbGlobalCached = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestGlobalCache(),
-	});
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	test('migrator : default migration strategy', async () => {
+		await db.execute(sql`drop table if exists all_columns,users12,"drizzle"."__drizzle_migrations"`);
 
-	const result = await db.select().from(usersMigratorTable);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
+		const result = await db.select().from(usersMigratorTable);
 
-test('migrator : migrate with custom schema', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
+		await db.execute(sql`drop table all_columns,users12,"drizzle"."__drizzle_migrations"`);
+	});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+	test('migrator : migrate with custom schema', async () => {
+		await db.execute(sql`drop table if exists all_columns,users12,"drizzle"."__drizzle_migrations"`);
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations."__drizzle_migrations"`);
-});
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
 
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+		await db.execute(sql`drop table all_columns,users12,custom_migrations."__drizzle_migrations"`);
+	});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+	test('migrator : migrate with custom table', async () => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns,users12,"drizzle"."__drizzle_migrations"`);
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
 
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: 'custom_migrations',
+		await db.execute(sql`drop table all_columns,users12,"drizzle".${sql.identifier(customTable)}`);
 	});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(
-		sql`select * from custom_migrations.${sql.identifier(customTable)};`,
-	);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+	test('migrator : migrate with custom table and custom schema', async () => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns,users12,"drizzle"."__drizzle_migrations"`);
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable: customTable,
+			migrationsSchema: 'custom_migrations',
+		});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations.${sql.identifier(customTable)}`);
-});
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(
+			sql`select * from custom_migrations.${sql.identifier(customTable)};`,
+		);
+		expect(rowCount && rowCount > 0).toBeTruthy();
 
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+		await db.execute(sql`drop table all_columns,users12,custom_migrations.${sql.identifier(customTable)}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone first case mode string', async () => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
+		// 1. Insert date in string format without timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01 02:00:00.123456' },
+		]);
 
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
+		// 2, Select in string format and check that values are the same
+		const result = await db.select().from(table);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
 
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and check that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone second case mode string', async () => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`
+		await db.execute(sql`drop table if exists ${table}`);
+
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
-
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01T02:00:00.123456-02' },
+		]);
 
-	expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		// 2, Select as raw query and check that values are the same
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone third case mode date', async () => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) not null
 			)
 	`);
 
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+		const insertedDate = new Date('2022-01-01 20:00:00.123+04');
 
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
+		// 1. Insert date as new date
+		await db.insert(table).values([
+			{ timestamp: insertedDate },
+		]);
 
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select as raw query as string
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+		expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
 
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode string for timestamp with timezone', async () => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`
+		await db.execute(sql`drop table if exists ${table}`);
+
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode date for timestamp with timezone', async () => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) with time zone not null
 			)
 	`);
 
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+		const timestampString = new Date('2022-01-01 00:00:00.456-0200');
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test('test mode string for timestamp with timezone in UTC timezone', async () => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
+		// set timezone to UTC
+		await db.execute(sql`set time zone 'UTC'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test.skip('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test.skip('test mode string for timestamp with timezone in different timezone', async () => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
+		// set timezone to HST (UTC - 10)
+		await db.execute(sql`set time zone 'HST'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		const timestampString = '2022-01-01 00:00:00.123456-1000';
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456+00' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('select all fields', async (ctx) => {
-	const { db } = ctx.pg;
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456+00' }]);
 
-	const now = Date.now();
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
 
-	await db.insert(usersTable).values({ name: 'John' });
-	const result = await db.select().from(usersTable);
-
-	expect(result[0]!.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
-	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('update with returning all fields', async (ctx) => {
-	const { db } = ctx.pg;
+	test('select all fields', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const now = Date.now();
 
-	const now = Date.now();
+		await db.insert(usersTable).values({ name: 'John' });
+		const result = await db.select().from(usersTable);
 
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db
-		.update(usersTable)
-		.set({ name: 'Jane' })
-		.where(eq(usersTable.name, 'John'))
-		.returning();
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
+		expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+	});
 
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
-	expect(users).toEqual([
-		{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
-	]);
-});
+	test('update with returning all fields', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const now = Date.now();
+
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db
+			.update(usersTable)
+			.set({ name: 'Jane' })
+			.where(eq(usersTable.name, 'John'))
+			.returning();
+
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
+		expect(users).toEqual([
+			{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
+		]);
+	});
 
-test('delete with returning all fields', async (ctx) => {
-	const { db } = ctx.pg;
+	test('delete with returning all fields', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const now = Date.now();
 
-	const now = Date.now();
+		await db.insert(usersTable).values({ name: 'John' });
+		const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
 
-	await db.insert(usersTable).values({ name: 'John' });
-	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
+		expect(users).toEqual([
+			{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
+		]);
+	});
 
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
-	expect(users).toEqual([
-		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
-	]);
-});
+	test('mySchema :: select all fields', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const now = Date.now();
 
-test('mySchema :: select all fields', async (ctx) => {
-	const { db } = ctx.pg;
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const result = await db.select().from(usersMySchemaTable);
 
-	const now = Date.now();
+		expect(result[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
+		expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+	});
 
-	await db.insert(usersMySchemaTable).values({ name: 'John' });
-	const result = await db.select().from(usersMySchemaTable);
+	test('mySchema :: delete with returning all fields', async () => {
+		await db.execute(`truncate table "mySchema"."users" restart identity;`);
+		const now = Date.now();
 
-	expect(result[0]!.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
-	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-});
+		await db.insert(usersMySchemaTable).values({ name: 'John' });
+		const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John')).returning();
 
-test('mySchema :: delete with returning all fields', async (ctx) => {
-	const { db } = ctx.pg;
+		expect(users[0]!.createdAt).toBeInstanceOf(Date);
+		expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
+		expect(users).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+	});
 
-	const now = Date.now();
+	test('insert via db.execute + select via db.execute', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		await db.execute(
+			sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+		);
 
-	await db.insert(usersMySchemaTable).values({ name: 'John' });
-	const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John')).returning();
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from "users"`,
+		);
+		expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-	expect(users[0]!.createdAt).toBeInstanceOf(Date);
-	expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(3000);
-	expect(users).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
-});
+	test('insert via db.execute + returning', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const inserted = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${
+				sql.identifier(
+					usersTable.name.name,
+				)
+			}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'nested transaction rollback',
-	'transaction rollback',
-	'nested transaction',
-	'transaction',
-	'timestamp timezone',
-	'test $onUpdateFn and $onUpdate works as $default',
-	'select all fields',
-	'update with returning all fields',
-	'delete with returning all fields',
-	'mySchema :: select all fields',
-	'mySchema :: delete with returning all fields',
-]);
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`drop schema if exists ${mySchema} cascade`);
-
-	await db.execute(sql`create schema public`);
-	await db.execute(sql`create schema ${mySchema}`);
-
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table ${usersMySchemaTable} (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false,
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
+	test('insert via db.execute w/ query builder', async () => {
+		await db.execute(`truncate table users restart identity;`);
+		const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
-	);
+	test('migrator : --init', async () => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
 
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('migrator : --init - local migrations error', async () => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
 
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('migrator : --init - db migrations error', async () => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(true);
+	});
 
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db: database }) => {
+		const users = pgTable('migration_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		const users2 = pgTable('migration_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		await database.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await database.execute(sql`drop table if exists ${users}`);
+		await database.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/postgres-neon-serverless';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(database, { migrationsFolder: migrationDir });
+		const res1 = await database.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(database.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(database, { migrationsFolder: migrationDir });
+
+		const res2 = await database.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
 });
diff --git a/integration-tests/tests/pg/netlify-db.test.ts b/integration-tests/tests/pg/netlify-db.test.ts
new file mode 100644
index 0000000000..0378d98f09
--- /dev/null
+++ b/integration-tests/tests/pg/netlify-db.test.ts
@@ -0,0 +1,774 @@
+import { neon, Pool as NeonPool } from '@neondatabase/serverless';
+import { eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/netlify-db';
+import { migrate } from 'drizzle-orm/netlify-db/migrator';
+import {
+	bigint,
+	bigserial,
+	boolean,
+	bytea,
+	char,
+	cidr,
+	date,
+	doublePrecision,
+	getTableConfig,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	pgEnum,
+	pgMaterializedView,
+	pgTable,
+	point,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import pg from 'pg';
+import { describe, expect, expectTypeOf } from 'vitest';
+import { randomString } from '~/utils';
+import { tests } from './common';
+import { netlifyDbTest as test } from './instrumentation';
+import { usersMigratorTable, usersTable } from './schema';
+
+const skips = [] as string[];
+
+const connectionString = process.env['NETLIFY_DB_URL']!;
+
+// COMMON
+tests(test, skips);
+
+const testItems = pgTable('netlify_db_test_items', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	value: integer('value').default(0),
+});
+
+async function setupTestTable(database: { execute: (query: any) => Promise<any> }) {
+	await database.execute(sql`drop table if exists netlify_db_test_items`);
+	await database.execute(sql`
+		create table netlify_db_test_items (
+			id serial primary key,
+			name text not null,
+			value integer default 0
+		)
+	`);
+}
+
+async function teardownTestTable(database: { execute: (query: any) => Promise<any> }) {
+	await database.execute(sql`drop table if exists netlify_db_test_items`);
+}
+
+describe('migrator', () => {
+	test.beforeEach(async ({ db }) => {
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+		await db.execute(
+			sql`
+			create table users (
+				id serial primary key,
+				name text not null,
+				verified boolean not null default false,
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+		);
+	});
+
+	test('migrator : default migration strategy', async ({ db }) => {
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+		const result = await db.select().from(usersMigratorTable);
+
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+		await db.execute(sql`drop table all_columns, users12, "drizzle"."__drizzle_migrations"`);
+	});
+
+	test('migrator : migrate with custom schema', async ({ db }) => {
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
+
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, custom_migrations."__drizzle_migrations"`);
+	});
+
+	test('migrator : migrate with custom table', async ({ db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, "drizzle".${sql.identifier(customTable)}`);
+	});
+
+	test('migrator : migrate with custom table and custom schema', async ({ db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns, users12, "drizzle"."__drizzle_migrations"`);
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable: customTable,
+			migrationsSchema: 'custom_migrations',
+		});
+
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(
+			sql`select * from custom_migrations.${sql.identifier(customTable)};`,
+		);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns, users12, custom_migrations.${sql.identifier(customTable)}`);
+	});
+
+	test('migrator : --init', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+			SELECT 1
+			FROM pg_tables
+			WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+		) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+		const users = pgTable('migrations_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		const users2 = pgTable('migrations_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/postgres-neon-http';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migrations_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migrations_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migrations_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
+
+	test('all date and time columns without timezone first case mode string', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await push({ table });
+
+		// 1. Insert date in string format without timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01 02:00:00.123456' },
+		]);
+
+		// 2, Select in string format and check that values are the same
+		const result = await db.select().from(table);
+
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+
+		// 3. Select as raw query and check that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+	});
+
+	test('all date and time columns without timezone second case mode string', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await push({ table });
+
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01T02:00:00.123456-02' },
+		]);
+
+		// 2, Select as raw query and check that values are the same
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+	});
+
+	test('all date and time columns without timezone third case mode date', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		});
+
+		await push({ table });
+
+		const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+
+		// 1. Insert date as new date
+		await db.insert(table).values([
+			{ timestamp: insertedDate },
+		]);
+
+		// 2, Select as raw query as string
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+		expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+	});
+
+	test('test mode string for timestamp with timezone', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
+
+		await push({ table });
+
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
+
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
+
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
+
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+	});
+
+	test('test mode date for timestamp with timezone', async ({ db, push }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		});
+
+		await push({ table });
+
+		const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
+
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
+
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+	});
+
+	test('test mode string for timestamp with timezone in UTC timezone', async ({ db, push }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+
+		// set timezone to UTC
+		await db.execute(sql`set time zone 'UTC'`);
+
+		const table = pgTable('all_columns_6', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
+
+		await push({ table });
+
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
+
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
+
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
+
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+	});
+
+	test.skip('test mode string for timestamp with timezone in different timezone', async ({ db }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+
+		// set timezone to HST (UTC - 10)
+		await db.execute(sql`set time zone 'HST'`);
+
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
+
+		await db.execute(sql`
+		create table ${table} (
+					id serial primary key,
+					timestamp_string timestamp(6) with time zone not null
+			)
+	`);
+
+		const timestampString = '2022-01-01 00:00:00.123456-1000';
+
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
+
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
+
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
+
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456+00' }]);
+
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+
+		await db.execute(sql`drop table if exists ${table}`);
+	});
+
+	test('insert via db.execute + select via db.execute', async ({ db }) => {
+		await db.execute(
+			sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+		);
+
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from "users"`,
+		);
+		expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert via db.execute + returning', async ({ db }) => {
+		const inserted = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${
+				sql.identifier(
+					usersTable.name.name,
+				)
+			}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
+
+	test('insert via db.execute w/ query builder', async ({ db }) => {
+		const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
+});
+
+describe('instantiation paths', () => {
+	test('connection string', async () => {
+		const testDb = drizzle(connectionString);
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Alice' });
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toEqual([{ id: 1, name: 'Alice', value: 0 }]);
+
+		await teardownTestTable(testDb);
+	});
+
+	test('config with connection string', async () => {
+		const testDb = drizzle({ connection: connectionString });
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Bob' });
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toEqual([{ id: 1, name: 'Bob', value: 0 }]);
+
+		await teardownTestTable(testDb);
+	});
+
+	test('config with connection object', async () => {
+		const testDb = drizzle({ connection: { connectionString } });
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Charlie' });
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toEqual([{ id: 1, name: 'Charlie', value: 0 }]);
+
+		await teardownTestTable(testDb);
+	});
+
+	test('zero-config via NETLIFY_DB_URL env var', async () => {
+		const savedUrl = process.env['NETLIFY_DB_URL'];
+		const savedDriver = process.env['NETLIFY_DB_DRIVER'];
+
+		try {
+			process.env['NETLIFY_DB_URL'] = connectionString;
+			delete process.env['NETLIFY_DB_DRIVER'];
+
+			const testDb = drizzle();
+			await setupTestTable(testDb);
+
+			await testDb.insert(testItems).values({ name: 'ZeroConfig' });
+			const rows = await testDb.select().from(testItems);
+			expect(rows).toEqual([{ id: 1, name: 'ZeroConfig', value: 0 }]);
+
+			await teardownTestTable(testDb);
+		} finally {
+			process.env['NETLIFY_DB_URL'] = savedUrl;
+			process.env['NETLIFY_DB_DRIVER'] = savedDriver;
+		}
+	});
+
+	test('zero-config with NETLIFY_DB_DRIVER=server uses node-postgres', async () => {
+		const savedUrl = process.env['NETLIFY_DB_URL'];
+		const savedDriver = process.env['NETLIFY_DB_DRIVER'];
+
+		try {
+			process.env['NETLIFY_DB_URL'] = connectionString;
+			process.env['NETLIFY_DB_DRIVER'] = 'server';
+
+			const testDb = drizzle();
+			await setupTestTable(testDb);
+
+			await testDb.insert(testItems).values({ name: 'ServerMode' });
+			const rows = await testDb.select().from(testItems);
+			expect(rows).toEqual([{ id: 1, name: 'ServerMode', value: 0 }]);
+
+			await teardownTestTable(testDb);
+		} finally {
+			process.env['NETLIFY_DB_URL'] = savedUrl;
+			process.env['NETLIFY_DB_DRIVER'] = savedDriver;
+		}
+	});
+
+	test('explicit serverless client', async () => {
+		const httpClient = neon(connectionString);
+		const pool = new NeonPool({ connectionString });
+
+		const testDb = drizzle({
+			client: {
+				driver: 'serverless' as const,
+				httpClient,
+				pool,
+				connectionString,
+			},
+		});
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Serverless' });
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toEqual([{ id: 1, name: 'Serverless', value: 0 }]);
+
+		await teardownTestTable(testDb);
+		await pool.end();
+	});
+
+	test('explicit server client', async () => {
+		const pool = new pg.Pool({ connectionString });
+
+		const testDb = drizzle({
+			client: {
+				driver: 'server' as const,
+				pool,
+				connectionString,
+			},
+		});
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Server' });
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toEqual([{ id: 1, name: 'Server', value: 0 }]);
+
+		await teardownTestTable(testDb);
+		await pool.end();
+	});
+});
+
+describe('serverless transport selection', () => {
+	test('regular queries and transactions both work in the same session', async () => {
+		const testDb = drizzle(connectionString);
+		await setupTestTable(testDb);
+
+		// Regular query — goes over HTTP
+		await testDb.insert(testItems).values([
+			{ name: 'Alice', value: 10 },
+			{ name: 'Bob', value: 20 },
+		]);
+
+		const beforeTx = await testDb.select().from(testItems).orderBy(testItems.id);
+		expect(beforeTx).toHaveLength(2);
+
+		// Transaction — switches to WebSocket
+		await testDb.transaction(async (tx) => {
+			await tx.update(testItems).set({ value: 100 }).where(eq(testItems.name, 'Alice'));
+			await tx.insert(testItems).values({ name: 'Charlie', value: 30 });
+		});
+
+		const afterTx = await testDb.select().from(testItems).orderBy(testItems.id);
+		expect(afterTx).toHaveLength(3);
+		expect(afterTx[0]).toEqual({ id: 1, name: 'Alice', value: 100 });
+		expect(afterTx[2]).toEqual({ id: 3, name: 'Charlie', value: 30 });
+
+		await teardownTestTable(testDb);
+	});
+
+	test('transaction rollback works', async () => {
+		const testDb = drizzle(connectionString);
+		await setupTestTable(testDb);
+
+		await testDb.insert(testItems).values({ name: 'Alice', value: 10 });
+
+		try {
+			await testDb.transaction(async (tx) => {
+				await tx.insert(testItems).values({ name: 'Ghost' });
+				throw new Error('intentional rollback');
+			});
+		} catch (e: any) {
+			expect(e.message).toBe('intentional rollback');
+		}
+
+		// The rolled-back row should not exist
+		const rows = await testDb.select().from(testItems);
+		expect(rows).toHaveLength(1);
+		expect(rows[0]!.name).toBe('Alice');
+
+		await teardownTestTable(testDb);
+	});
+
+	test('nested transactions use savepoints', async () => {
+		const testDb = drizzle(connectionString);
+		await setupTestTable(testDb);
+
+		await testDb.transaction(async (tx) => {
+			await tx.insert(testItems).values({ name: 'Outer' });
+
+			try {
+				await tx.transaction(async (tx2) => {
+					await tx2.insert(testItems).values({ name: 'Inner - rolled back' });
+					throw new Error('inner rollback');
+				});
+			} catch {
+				// inner savepoint rolled back
+			}
+
+			await tx.insert(testItems).values({ name: 'After inner rollback' });
+		});
+
+		const rows = await testDb.select().from(testItems).orderBy(testItems.id);
+		const names = rows.map((r) => r.name);
+		expect(names).toContain('Outer');
+		expect(names).toContain('After inner rollback');
+		expect(names).not.toContain('Inner - rolled back');
+
+		await teardownTestTable(testDb);
+	});
+});
diff --git a/integration-tests/tests/pg/node-postgres.test.ts b/integration-tests/tests/pg/node-postgres.test.ts
index a7921ad189..2b9f1a6020 100644
--- a/integration-tests/tests/pg/node-postgres.test.ts
+++ b/integration-tests/tests/pg/node-postgres.test.ts
@@ -1,492 +1,574 @@
-import retry from 'async-retry';
 import { sql } from 'drizzle-orm';
-import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { drizzle } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import { Client } from 'pg';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, integer, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe, expect } from 'vitest';
 import { randomString } from '~/utils';
-import { createDockerDB, tests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: NodePgDatabase;
-let client: Client;
-let dbGlobalCached: NodePgDatabase;
-let cachedDb: NodePgDatabase;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['PG_CONNECTION_STRING']) {
-		connectionString = process.env['PG_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = new Client(connectionString);
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
+import { tests } from './common';
+import { nodePostgresTest as test } from './instrumentation';
+import { usersMigratorTable, usersTable } from './schema';
 
-afterAll(async () => {
-	await client?.end();
-});
+tests(test, []);
 
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
+describe('migrator', () => {
+	test('migrator : default migration strategy', async ({ db }) => {
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
 
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
 
-	const result = await db.select().from(usersMigratorTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-test('migrator : migrate with custom schema', async () => {
-	const customSchema = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+	});
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
+	test('migrator : migrate with custom schema', async ({ db }) => {
+		const customSchema = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
-});
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
+	});
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+	test('migrator : migrate with custom table', async ({ db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+		expect(rowCount && rowCount > 0).toBeTruthy();
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	const customSchema = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: customSchema,
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
 	});
 
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(
-		sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
-	);
-	expect(rowCount && rowCount > 0).toBeTruthy();
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
-});
-
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+	test('migrator : migrate with custom table and custom schema', async ({ db }) => {
+		const customTable = randomString();
+		const customSchema = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable: customTable,
+			migrationsSchema: customSchema,
+		});
+
+		// test if the custom migrations table was created
+		const { rowCount } = await db.execute(
+			sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
+		);
+		expect(rowCount && rowCount > 0).toBeTruthy();
+
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone first case mode string', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
+		// 1. Insert date in string format without timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01 02:00:00.123456' },
+		]);
 
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
+		// 2, Select in string format and check that values are the same
+		const result = await db.select().from(table);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
 
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and check that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone second case mode string', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01T02:00:00.123456-02' },
+		]);
 
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select as raw query and check that values are the same
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone third case mode date', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) not null
 			)
 	`);
 
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+		const insertedDate = new Date('2022-01-01 20:00:00.123+04');
 
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
+		// 1. Insert date as new date
+		await db.insert(table).values([
+			{ timestamp: insertedDate },
+		]);
 
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select as raw query as string
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+		// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+		expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode string for timestamp with timezone', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode date for timestamp with timezone', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) with time zone not null
 			)
 	`);
 
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+		const timestampString = new Date('2022-01-01 00:00:00.456-0200');
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test('test mode string for timestamp with timezone in UTC timezone', async ({ db }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
+		// set timezone to UTC
+		await db.execute(sql`set time zone 'UTC'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test('test mode string for timestamp with timezone in different timezone', async ({ db }) => {
+		// get current timezone from db
+		const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
+		// set timezone to HST (UTC - 10)
+		await db.execute(sql`set time zone '-10'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
+		const timestampString = '2022-01-01 00:00:00.123456-1000';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
+		expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
+	test('insert via db.execute + select via db.execute', async ({ db }) => {
+		await db.execute(
+			sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+		);
+
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from "users"`,
+		);
+		expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-]);
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
+	test('insert via db.execute + returning', async ({ db }) => {
+		const inserted = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${
+				sql.identifier(
+					usersTable.name.name,
+				)
+			}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
-	);
+	test('insert via db.execute w/ query builder', async ({ db }) => {
+		const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('migrator : --init', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+						SELECT 1
+						FROM pg_tables
+						WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
 
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
 
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+		const users = pgTable('migration_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		const users2 = pgTable('migration_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/postgres';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
 });
diff --git a/integration-tests/tests/pg/pg-common-cache.ts b/integration-tests/tests/pg/pg-common-cache.ts
deleted file mode 100644
index 3d34e43d91..0000000000
--- a/integration-tests/tests/pg/pg-common-cache.ts
+++ /dev/null
@@ -1,400 +0,0 @@
-import type Docker from 'dockerode';
-import { eq, getTableName, is, sql, Table } from 'drizzle-orm';
-import type { MutationOption } from 'drizzle-orm/cache/core';
-import { Cache } from 'drizzle-orm/cache/core';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import type { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
-import { alias, boolean, integer, jsonb, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
-import Keyv from 'keyv';
-import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestGlobalCache extends Cache {
-	private globalTtl: number = 1000;
-	private usedTablesPerKey: Record<string, string[]> = {};
-
-	constructor(private kv: Keyv = new Keyv()) {
-		super();
-	}
-
-	override strategy(): 'explicit' | 'all' {
-		return 'all';
-	}
-	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
-		const res = await this.kv.get(key) ?? undefined;
-		return res;
-	}
-	override async put(
-		key: string,
-		response: any,
-		tables: string[],
-		isTag: boolean,
-		config?: CacheConfig,
-	): Promise<void> {
-		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
-		for (const table of tables) {
-			const keys = this.usedTablesPerKey[table];
-			if (keys === undefined) {
-				this.usedTablesPerKey[table] = [key];
-			} else {
-				keys.push(key);
-			}
-		}
-	}
-	override async onMutate(params: MutationOption): Promise<void> {
-		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
-		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
-
-		const keysToDelete = new Set<string>();
-
-		for (const table of tablesArray) {
-			const tableName = is(table, Table) ? getTableName(table) : table as string;
-			const keys = this.usedTablesPerKey[tableName] ?? [];
-			for (const key of keys) keysToDelete.add(key);
-		}
-
-		if (keysToDelete.size > 0 || tagsArray.length > 0) {
-			for (const tag of tagsArray) {
-				await this.kv.delete(tag);
-			}
-
-			for (const key of keysToDelete) {
-				await this.kv.delete(key);
-				for (const table of tablesArray) {
-					const tableName = is(table, Table) ? getTableName(table) : table as string;
-					this.usedTablesPerKey[tableName] = [];
-				}
-			}
-		}
-	}
-}
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestCache extends TestGlobalCache {
-	override strategy(): 'explicit' | 'all' {
-		return 'explicit';
-	}
-}
-
-declare module 'vitest' {
-	interface TestContext {
-		cachedPg: {
-			db: PgDatabase<PgQueryResultHKT>;
-			dbGlobalCached: PgDatabase<PgQueryResultHKT>;
-		};
-	}
-}
-
-const usersTable = pgTable('users', {
-	id: serial().primaryKey(),
-	name: text().notNull(),
-	verified: boolean().notNull().default(false),
-	jsonb: jsonb().$type<string[]>(),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-const postsTable = pgTable('posts', {
-	id: serial().primaryKey(),
-	description: text().notNull(),
-	userId: integer('city_id').references(() => usersTable.id),
-});
-
-let pgContainer: Docker.Container;
-
-afterAll(async () => {
-	await pgContainer?.stop().catch(console.error);
-});
-
-export function tests() {
-	describe('common', () => {
-		beforeEach(async (ctx) => {
-			const { db, dbGlobalCached } = ctx.cachedPg;
-			await db.execute(sql`drop schema if exists public cascade`);
-			await db.$cache?.invalidate({ tables: 'users' });
-			await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
-			await db.execute(sql`create schema public`);
-			// public users
-			await db.execute(
-				sql`
-					create table users (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb jsonb,
-						created_at timestamptz not null default now()
-					)
-				`,
-			);
-		});
-
-		test('test force invalidate', async (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			const spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
-			await db.$cache?.invalidate({ tables: 'users' });
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('default global config - no cache should be hit', async (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('default global config + enable cache on select: get, put', async (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache();
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('default global config + enable cache on select + write: get, put, onMutate', async (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('default global config + enable cache on select + disable invalidate: get, put', async (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			// invalidate force
-			await db.$cache?.invalidate({ tags: ['custom'] });
-		});
-
-		test('global: true + disable cache', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache(false);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - cache should be hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable);
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - cache: false on select - no cache hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache(false);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - disable invalidate - cache hit + no invalidate', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('global: true - with custom tag', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			// invalidate force
-			await db.$cache?.invalidate({ tags: ['custom'] });
-		});
-
-		test('global: true - with custom tag + with autoinvalidate', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ tag: 'custom' });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-
-			// invalidate force
-			await db.$cache?.invalidate({ tags: ['custom'] });
-		});
-
-		// check select used tables
-		test('check simple select used tables', (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
-			// @ts-expect-error
-			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
-		});
-		// check select+join used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			// @ts-expect-error
-			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
-				.toStrictEqual(['users', 'posts']);
-			expect(
-				// @ts-expect-error
-				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
-		});
-		// check select+2join used tables
-		test('select+2joins', (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			expect(
-				db.select().from(usersTable).leftJoin(
-					postsTable,
-					eq(usersTable.id, postsTable.userId),
-				).leftJoin(
-					alias(postsTable, 'post2'),
-					eq(usersTable.id, postsTable.userId),
-				)
-					// @ts-expect-error
-					.getUsedTables(),
-			)
-				.toStrictEqual(['users', 'posts']);
-			expect(
-				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).leftJoin(
-					alias(postsTable, 'post2'),
-					eq(usersTable.id, postsTable.userId),
-					// @ts-expect-error
-				).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
-		});
-		// select subquery used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedPg;
-
-			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
-			db.select().from(sq);
-
-			// @ts-expect-error
-			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
-		});
-	});
-}
diff --git a/integration-tests/tests/pg/pg-common.ts b/integration-tests/tests/pg/pg-common.ts
deleted file mode 100644
index 2946674182..0000000000
--- a/integration-tests/tests/pg/pg-common.ts
+++ /dev/null
@@ -1,6408 +0,0 @@
-import Docker from 'dockerode';
-// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-import {
-	and,
-	arrayContained,
-	arrayContains,
-	arrayOverlaps,
-	asc,
-	avg,
-	avgDistinct,
-	count,
-	countDistinct,
-	eq,
-	Equal,
-	exists,
-	getTableColumns,
-	gt,
-	gte,
-	ilike,
-	inArray,
-	is,
-	like,
-	lt,
-	max,
-	min,
-	not,
-	notInArray,
-	or,
-	SQL,
-	sql,
-	SQLWrapper,
-	sum,
-	sumDistinct,
-	TransactionRollbackError,
-} from 'drizzle-orm';
-import { authenticatedRole, crudPolicy, usersSync } from 'drizzle-orm/neon';
-import type { NeonHttpDatabase } from 'drizzle-orm/neon-http';
-import type { PgColumn, PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
-import {
-	alias,
-	bigint,
-	bigserial,
-	boolean,
-	char,
-	cidr,
-	date,
-	doublePrecision,
-	except,
-	exceptAll,
-	foreignKey,
-	getMaterializedViewConfig,
-	getTableConfig,
-	getViewConfig,
-	index,
-	inet,
-	integer,
-	intersect,
-	intersectAll,
-	interval,
-	json,
-	jsonb,
-	line,
-	macaddr,
-	macaddr8,
-	numeric,
-	PgDialect,
-	pgEnum,
-	pgMaterializedView,
-	PgPolicy,
-	pgPolicy,
-	pgSchema,
-	pgTable,
-	pgTableCreator,
-	pgView,
-	point,
-	primaryKey,
-	real,
-	serial,
-	smallint,
-	smallserial,
-	text,
-	time,
-	timestamp,
-	union,
-	unionAll,
-	unique,
-	uniqueKeyName,
-	uuid,
-	uuid as pgUuid,
-	varchar,
-} from 'drizzle-orm/pg-core';
-import getPort from 'get-port';
-import { v4 as uuidV4 } from 'uuid';
-import { afterAll, afterEach, beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
-import { Expect } from '~/utils';
-import type { schema } from './neon-http-batch.test';
-// eslint-disable-next-line @typescript-eslint/no-import-type-side-effects
-// import { type NodePgDatabase } from 'drizzle-orm/node-postgres';
-
-declare module 'vitest' {
-	interface TestContext {
-		pg: {
-			db: PgDatabase<PgQueryResultHKT>;
-		};
-		neonPg: {
-			db: NeonHttpDatabase<typeof schema>;
-		};
-	}
-}
-
-const en = pgEnum('en', ['enVal1', 'enVal2']);
-
-const allTypesTable = pgTable('all_types', {
-	serial: serial('serial'),
-	bigserial53: bigserial('bigserial53', {
-		mode: 'number',
-	}),
-	bigserial64: bigserial('bigserial64', {
-		mode: 'bigint',
-	}),
-	int: integer('int'),
-	bigint53: bigint('bigint53', {
-		mode: 'number',
-	}),
-	bigint64: bigint('bigint64', {
-		mode: 'bigint',
-	}),
-	bool: boolean('bool'),
-	char: char('char'),
-	cidr: cidr('cidr'),
-	date: date('date', {
-		mode: 'date',
-	}),
-	dateStr: date('date_str', {
-		mode: 'string',
-	}),
-	double: doublePrecision('double'),
-	enum: en('enum'),
-	inet: inet('inet'),
-	interval: interval('interval'),
-	json: json('json'),
-	jsonb: jsonb('jsonb'),
-	line: line('line', {
-		mode: 'abc',
-	}),
-	lineTuple: line('line_tuple', {
-		mode: 'tuple',
-	}),
-	macaddr: macaddr('macaddr'),
-	macaddr8: macaddr8('macaddr8'),
-	numeric: numeric('numeric'),
-	numericNum: numeric('numeric_num', {
-		mode: 'number',
-	}),
-	numericBig: numeric('numeric_big', {
-		mode: 'bigint',
-	}),
-	point: point('point', {
-		mode: 'xy',
-	}),
-	pointTuple: point('point_tuple', {
-		mode: 'tuple',
-	}),
-	real: real('real'),
-	smallint: smallint('smallint'),
-	smallserial: smallserial('smallserial'),
-	text: text('text'),
-	time: time('time'),
-	timestamp: timestamp('timestamp', {
-		mode: 'date',
-	}),
-	timestampTz: timestamp('timestamp_tz', {
-		mode: 'date',
-		withTimezone: true,
-	}),
-	timestampStr: timestamp('timestamp_str', {
-		mode: 'string',
-	}),
-	timestampTzStr: timestamp('timestamp_tz_str', {
-		mode: 'string',
-		withTimezone: true,
-	}),
-	uuid: uuid('uuid'),
-	varchar: varchar('varchar'),
-	arrint: integer('arrint').array(),
-	arrbigint53: bigint('arrbigint53', {
-		mode: 'number',
-	}).array(),
-	arrbigint64: bigint('arrbigint64', {
-		mode: 'bigint',
-	}).array(),
-	arrbool: boolean('arrbool').array(),
-	arrchar: char('arrchar').array(),
-	arrcidr: cidr('arrcidr').array(),
-	arrdate: date('arrdate', {
-		mode: 'date',
-	}).array(),
-	arrdateStr: date('arrdate_str', {
-		mode: 'string',
-	}).array(),
-	arrdouble: doublePrecision('arrdouble').array(),
-	arrenum: en('arrenum').array(),
-	arrinet: inet('arrinet').array(),
-	arrinterval: interval('arrinterval').array(),
-	arrjson: json('arrjson').array(),
-	arrjsonb: jsonb('arrjsonb').array(),
-	arrline: line('arrline', {
-		mode: 'abc',
-	}).array(),
-	arrlineTuple: line('arrline_tuple', {
-		mode: 'tuple',
-	}).array(),
-	arrmacaddr: macaddr('arrmacaddr').array(),
-	arrmacaddr8: macaddr8('arrmacaddr8').array(),
-	arrnumeric: numeric('arrnumeric').array(),
-	arrnumericNum: numeric('arrnumeric_num', {
-		mode: 'number',
-	}).array(),
-	arrnumericBig: numeric('arrnumeric_big', {
-		mode: 'bigint',
-	}).array(),
-	arrpoint: point('arrpoint', {
-		mode: 'xy',
-	}).array(),
-	arrpointTuple: point('arrpoint_tuple', {
-		mode: 'tuple',
-	}).array(),
-	arrreal: real('arrreal').array(),
-	arrsmallint: smallint('arrsmallint').array(),
-	arrtext: text('arrtext').array(),
-	arrtime: time('arrtime').array(),
-	arrtimestamp: timestamp('arrtimestamp', {
-		mode: 'date',
-	}).array(),
-	arrtimestampTz: timestamp('arrtimestamp_tz', {
-		mode: 'date',
-		withTimezone: true,
-	}).array(),
-	arrtimestampStr: timestamp('arrtimestamp_str', {
-		mode: 'string',
-	}).array(),
-	arrtimestampTzStr: timestamp('arrtimestamp_tz_str', {
-		mode: 'string',
-		withTimezone: true,
-	}).array(),
-	arruuid: uuid('arruuid').array(),
-	arrvarchar: varchar('arrvarchar').array(),
-});
-
-export const usersTable = pgTable('users', {
-	id: serial('id' as string).primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: jsonb('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-const usersOnUpdate = pgTable('users_on_update', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	updateCounter: integer('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
-	updatedAt: timestamp('updated_at', { mode: 'date', precision: 3 }).$onUpdate(() => new Date()),
-	alwaysNull: text('always_null').$type<string | null>().$onUpdate(() => null),
-	// uppercaseName: text('uppercase_name').$onUpdateFn(() => sql`upper(name)`), looks like this is not supported in pg
-});
-
-const citiesTable = pgTable('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	state: char('state', { length: 2 }),
-});
-
-const cities2Table = pgTable('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const users2Table = pgTable('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: integer('city_id').references(() => citiesTable.id),
-});
-
-const coursesTable = pgTable('courses', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	categoryId: integer('category_id').references(() => courseCategoriesTable.id),
-});
-
-const courseCategoriesTable = pgTable('course_categories', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const orders = pgTable('orders', {
-	id: serial('id').primaryKey(),
-	region: text('region').notNull(),
-	product: text('product').notNull().$default(() => 'random_string'),
-	amount: integer('amount').notNull(),
-	quantity: integer('quantity').notNull(),
-});
-
-const network = pgTable('network_table', {
-	inet: inet('inet').notNull(),
-	cidr: cidr('cidr').notNull(),
-	macaddr: macaddr('macaddr').notNull(),
-	macaddr8: macaddr8('macaddr8').notNull(),
-});
-
-const salEmp = pgTable('sal_emp', {
-	name: text('name'),
-	payByQuarter: integer('pay_by_quarter').array(),
-	schedule: text('schedule').array().array(),
-});
-
-const _tictactoe = pgTable('tictactoe', {
-	squares: integer('squares').array(3).array(3),
-});
-
-export const usersMigratorTable = pgTable('users12', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-});
-
-// To test aggregate functions
-const aggregateTable = pgTable('aggregate_table', {
-	id: serial('id').notNull(),
-	name: text('name').notNull(),
-	a: integer('a'),
-	b: integer('b'),
-	c: integer('c'),
-	nullOnly: integer('null_only'),
-});
-
-// To test another schema and multischema
-export const mySchema = pgSchema('mySchema');
-
-export const usersMySchemaTable = mySchema.table('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: jsonb('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-const citiesMySchemaTable = mySchema.table('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	state: char('state', { length: 2 }),
-});
-
-const users2MySchemaTable = mySchema.table('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: integer('city_id').references(() => citiesTable.id),
-});
-
-const jsonTestTable = pgTable('jsontest', {
-	id: serial('id').primaryKey(),
-	json: json('json').$type<{ string: string; number: number }>(),
-	jsonb: jsonb('jsonb').$type<{ string: string; number: number }>(),
-});
-
-let pgContainer: Docker.Container;
-
-export async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
-		name: `drizzle-integration-tests-${uuidV4()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return { connectionString: `postgres://postgres:postgres@localhost:${port}/postgres`, container: pgContainer };
-}
-
-afterAll(async () => {
-	await pgContainer?.stop().catch(console.error);
-});
-
-export function tests() {
-	describe('common', () => {
-		beforeEach(async (ctx) => {
-			const { db } = ctx.pg;
-			await db.execute(sql`drop schema if exists public cascade`);
-			await db.execute(sql`drop schema if exists ${mySchema} cascade`);
-			await db.execute(sql`create schema public`);
-			await db.execute(sql`create schema if not exists custom_migrations`);
-			await db.execute(sql`create schema ${mySchema}`);
-			// public users
-			await db.execute(
-				sql`
-					create table users (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb jsonb,
-						created_at timestamptz not null default now()
-					)
-				`,
-			);
-			// public cities
-			await db.execute(
-				sql`
-					create table cities (
-						id serial primary key,
-						name text not null,
-						state char(2)
-					)
-				`,
-			);
-			// public users2
-			await db.execute(
-				sql`
-					create table users2 (
-						id serial primary key,
-						name text not null,
-						city_id integer references cities(id)
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table course_categories (
-						id serial primary key,
-						name text not null
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table courses (
-						id serial primary key,
-						name text not null,
-						category_id integer references course_categories(id)
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table orders (
-						id serial primary key,
-						region text not null,
-						product text not null,
-						amount integer not null,
-						quantity integer not null
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table network_table (
-						inet inet not null,
-						cidr cidr not null,
-						macaddr macaddr not null,
-						macaddr8 macaddr8 not null
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table sal_emp (
-						name text not null,
-						pay_by_quarter integer[] not null,
-						schedule text[][] not null
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table tictactoe (
-						squares integer[3][3] not null
-					)
-				`,
-			);
-			// // mySchema users
-			await db.execute(
-				sql`
-					create table ${usersMySchemaTable} (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb jsonb,
-						created_at timestamptz not null default now()
-					)
-				`,
-			);
-			// mySchema cities
-			await db.execute(
-				sql`
-					create table ${citiesMySchemaTable} (
-						id serial primary key,
-						name text not null,
-						state char(2)
-					)
-				`,
-			);
-			// mySchema users2
-			await db.execute(
-				sql`
-					create table ${users2MySchemaTable} (
-						id serial primary key,
-						name text not null,
-						city_id integer references "mySchema".cities(id)
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table jsontest (
-						id serial primary key,
-						json json,
-						jsonb jsonb
-					)
-				`,
-			);
-		});
-
-		afterEach(async (ctx) => {
-			const { db } = ctx.pg;
-			await db.execute(sql`drop schema if exists custom_migrations cascade`);
-		});
-
-		async function setupSetOperationTest(db: PgDatabase<PgQueryResultHKT>) {
-			await db.execute(sql`drop table if exists users2`);
-			await db.execute(sql`drop table if exists cities`);
-			await db.execute(
-				sql`
-					create table cities (
-						id serial primary key,
-						name text not null
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table users2 (
-						id serial primary key,
-						name text not null,
-						city_id integer references cities(id)
-					)
-				`,
-			);
-
-			await db.insert(cities2Table).values([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await db.insert(users2Table).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 2 },
-				{ id: 3, name: 'Jack', cityId: 3 },
-				{ id: 4, name: 'Peter', cityId: 3 },
-				{ id: 5, name: 'Ben', cityId: 2 },
-				{ id: 6, name: 'Jill', cityId: 1 },
-				{ id: 7, name: 'Mary', cityId: 2 },
-				{ id: 8, name: 'Sally', cityId: 1 },
-			]);
-		}
-
-		async function setupAggregateFunctionsTest(db: PgDatabase<PgQueryResultHKT>) {
-			await db.execute(sql`drop table if exists "aggregate_table"`);
-			await db.execute(
-				sql`
-					create table "aggregate_table" (
-						"id" serial not null,
-						"name" text not null,
-						"a" integer,
-						"b" integer,
-						"c" integer,
-						"null_only" integer
-					);
-				`,
-			);
-			await db.insert(aggregateTable).values([
-				{ name: 'value 1', a: 5, b: 10, c: 20 },
-				{ name: 'value 1', a: 5, b: 20, c: 30 },
-				{ name: 'value 2', a: 10, b: 50, c: 60 },
-				{ name: 'value 3', a: 20, b: 20, c: null },
-				{ name: 'value 4', a: null, b: 90, c: 120 },
-				{ name: 'value 5', a: 80, b: 10, c: null },
-				{ name: 'value 6', a: null, b: null, c: 150 },
-			]);
-		}
-
-		test('table configs: unique third param', async () => {
-			const cities1Table = pgTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: char('state', { length: 2 }),
-			}, (t) => ({
-				f: unique('custom_name').on(t.name, t.state).nullsNotDistinct(),
-				f1: unique('custom_name1').on(t.name, t.state),
-			}));
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			expect(tableConfig.uniqueConstraints).toHaveLength(2);
-
-			expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
-			expect(tableConfig.uniqueConstraints[0]?.nullsNotDistinct).toBe(true);
-			expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-
-			expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
-			expect(tableConfig.uniqueConstraints[1]?.nullsNotDistinct).toBe(false);
-			expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-		});
-
-		test('table configs: unique in column', async () => {
-			const cities1Table = pgTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull().unique(),
-				state: char('state', { length: 2 }).unique('custom'),
-				field: char('field', { length: 2 }).unique('custom_field', { nulls: 'not distinct' }),
-			});
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			const columnName = tableConfig.columns.find((it) => it.name === 'name');
-
-			expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
-			expect(columnName?.isUnique).toBe(true);
-
-			const columnState = tableConfig.columns.find((it) => it.name === 'state');
-			expect(columnState?.uniqueName).toBe('custom');
-			expect(columnState?.isUnique).toBe(true);
-
-			const columnField = tableConfig.columns.find((it) => it.name === 'field');
-			expect(columnField?.uniqueName).toBe('custom_field');
-			expect(columnField?.isUnique).toBe(true);
-			expect(columnField?.uniqueType).toBe('not distinct');
-		});
-
-		test('table config: foreign keys name', async () => {
-			const table = pgTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
-			}));
-
-			const tableConfig = getTableConfig(table);
-
-			expect(tableConfig.foreignKeys).toHaveLength(1);
-			expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
-		});
-
-		test('table config: primary keys name', async () => {
-			const table = pgTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-			}));
-
-			const tableConfig = getTableConfig(table);
-
-			expect(tableConfig.primaryKeys).toHaveLength(1);
-			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
-		});
-
-		test('select all fields', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const now = Date.now();
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const result = await db.select().from(usersTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(300);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('select sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select typed sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			const users = await db.select({
-				name: sql<string>`upper(${usersTable.name})`,
-			}).from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select with empty array in inArray', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(inArray(usersTable.id, []));
-
-			expect(result).toEqual([]);
-		});
-
-		test('select with empty array in notInArray', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(notInArray(usersTable.id, []));
-
-			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
-		});
-
-		test('$default function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const insertedOrder = await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 })
-				.returning();
-			const selectedOrder = await db.select().from(orders);
-
-			expect(insertedOrder).toEqual([{
-				id: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-		});
-
-		test('select distinct', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const usersDistinctTable = pgTable('users_distinct', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-				age: integer('age').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id integer, name text, age integer)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John', age: 24 },
-				{ id: 1, name: 'John', age: 24 },
-				{ id: 2, name: 'John', age: 25 },
-				{ id: 1, name: 'Jane', age: 24 },
-				{ id: 1, name: 'Jane', age: 26 },
-			]);
-			const users1 = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-			const users2 = await db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-			);
-			const users3 = await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
-				usersDistinctTable,
-			).orderBy(usersDistinctTable.name);
-			const users4 = await db.selectDistinctOn([usersDistinctTable.id, usersDistinctTable.age]).from(
-				usersDistinctTable,
-			).orderBy(usersDistinctTable.id, usersDistinctTable.age);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users1).toEqual([
-				{ id: 1, name: 'Jane', age: 24 },
-				{ id: 1, name: 'Jane', age: 26 },
-				{ id: 1, name: 'John', age: 24 },
-				{ id: 2, name: 'John', age: 25 },
-			]);
-
-			expect(users2).toHaveLength(2);
-			expect(users2[0]?.id).toBe(1);
-			expect(users2[1]?.id).toBe(2);
-
-			expect(users3).toHaveLength(2);
-			expect(users3[0]?.name).toBe('Jane');
-			expect(users3[1]?.name).toBe('John');
-
-			expect(users4).toEqual([
-				{ id: 1, name: 'John', age: 24 },
-				{ id: 1, name: 'Jane', age: 26 },
-				{ id: 2, name: 'John', age: 25 },
-			]);
-		});
-
-		test('insert returning sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = await db
-				.insert(usersTable)
-				.values({ name: 'John' })
-				.returning({
-					name: sql`upper(${usersTable.name})`,
-				});
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('delete returning sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.delete(usersTable)
-				.where(eq(usersTable.name, 'John'))
-				.returning({
-					name: sql`upper(${usersTable.name})`,
-				});
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('update returning sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.update(usersTable)
-				.set({ name: 'Jane' })
-				.where(eq(usersTable.name, 'John'))
-				.returning({
-					name: sql`upper(${usersTable.name})`,
-				});
-
-			expect(users).toEqual([{ name: 'JANE' }]);
-		});
-
-		test('update with returning all fields', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const now = Date.now();
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.update(usersTable)
-				.set({ name: 'Jane' })
-				.where(eq(usersTable.name, 'John'))
-				.returning();
-
-			expect(users[0]!.createdAt).toBeInstanceOf(Date);
-			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
-			expect(users).toEqual([
-				{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
-			]);
-		});
-
-		test('update with returning partial', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.update(usersTable)
-				.set({ name: 'Jane' })
-				.where(eq(usersTable.name, 'John'))
-				.returning({
-					id: usersTable.id,
-					name: usersTable.name,
-				});
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('delete with returning all fields', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const now = Date.now();
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
-
-			expect(users[0]!.createdAt).toBeInstanceOf(Date);
-			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
-			expect(users).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
-			]);
-		});
-
-		test('delete with returning partial', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-				id: usersTable.id,
-				name: usersTable.name,
-			});
-
-			expect(users).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert + select', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const result = await db.select().from(usersTable);
-			expect(result).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt },
-			]);
-
-			await db.insert(usersTable).values({ name: 'Jane' });
-			const result2 = await db.select().from(usersTable);
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('json insert', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
-			const result = await db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-					jsonb: usersTable.jsonb,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
-		});
-
-		test('char insert', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
-				.from(citiesTable);
-
-			expect(result).toEqual([{ id: 1, name: 'Austin', state: 'TX' }]);
-		});
-
-		test('char update', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
-			await db.update(citiesTable).set({ name: 'Atlanta', state: 'GA' }).where(eq(citiesTable.id, 1));
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
-				.from(citiesTable);
-
-			expect(result).toEqual([{ id: 1, name: 'Atlanta', state: 'GA' }]);
-		});
-
-		test('char delete', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
-			await db.delete(citiesTable).where(eq(citiesTable.state, 'TX'));
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
-				.from(citiesTable);
-
-			expect(result).toEqual([]);
-		});
-
-		test('insert with overridden default values', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John', verified: true });
-			const result = await db.select().from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt },
-			]);
-		});
-
-		test('insert many', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-					{ name: 'Jane' },
-					{ name: 'Austin', verified: true },
-				]);
-			const result = await db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-					jsonb: usersTable.jsonb,
-					verified: usersTable.verified,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('insert many with returning', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const result = await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-					{ name: 'Jane' },
-					{ name: 'Austin', verified: true },
-				])
-				.returning({
-					id: usersTable.id,
-					name: usersTable.name,
-					jsonb: usersTable.jsonb,
-					verified: usersTable.verified,
-				});
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('select with group by as field', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db
-				.select({ name: usersTable.name })
-				.from(usersTable)
-				.groupBy(usersTable.name);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('select with exists', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const user = alias(usersTable, 'user');
-			const result = await db.select({ name: usersTable.name }).from(usersTable).where(
-				exists(
-					db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
-				),
-			);
-
-			expect(result).toEqual([{ name: 'John' }]);
-		});
-
-		test('select with group by as sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db
-				.select({ name: usersTable.name })
-				.from(usersTable)
-				.groupBy(sql`${usersTable.name}`);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('select with group by as sql + column', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db
-				.select({ name: usersTable.name })
-				.from(usersTable)
-				.groupBy(sql`${usersTable.name}`, usersTable.id);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db
-				.select({ name: usersTable.name })
-				.from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('select with group by complex query', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db
-				.select({ name: usersTable.name })
-				.from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`)
-				.orderBy(asc(usersTable.name))
-				.limit(1);
-
-			expect(result).toEqual([{ name: 'Jane' }]);
-		});
-
-		test('build query', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db
-				.select({ id: usersTable.id, name: usersTable.name })
-				.from(usersTable)
-				.groupBy(usersTable.id, usersTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
-				params: [],
-			});
-		});
-
-		test('insert sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: sql`${'John'}` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('partial join with alias', async (ctx) => {
-			const { db } = ctx.pg;
-			const customerAlias = alias(usersTable, 'customer');
-
-			await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select({
-					user: {
-						id: usersTable.id,
-						name: usersTable.name,
-					},
-					customer: {
-						id: customerAlias.id,
-						name: customerAlias.name,
-					},
-				})
-				.from(usersTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersTable.id, 10));
-
-			expect(result).toEqual([
-				{
-					user: { id: 10, name: 'Ivan' },
-					customer: { id: 11, name: 'Hans' },
-				},
-			]);
-		});
-
-		test('full join with alias', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const pgTable = pgTableCreator((name) => `prefixed_${name}`);
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select()
-				.from(users)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(users.id, 10));
-
-			expect(result).toEqual([{
-				users: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('select from alias', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const pgTable = pgTableCreator((name) => `prefixed_${name}`);
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const user = alias(users, 'user');
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select()
-				.from(user)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(user.id, 10));
-
-			expect(result).toEqual([{
-				user: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('insert with spaces', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('prepared statement', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const statement = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.prepare('statement1');
-			const result = await statement.execute();
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert: placeholders on columns with encoder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const statement = db.insert(usersTable).values({
-				name: 'John',
-				jsonb: sql.placeholder('jsonb'),
-			}).prepare('encoder_statement');
-
-			await statement.execute({ jsonb: ['foo', 'bar'] });
-
-			const result = await db
-				.select({
-					id: usersTable.id,
-					jsonb: usersTable.jsonb,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, jsonb: ['foo', 'bar'] },
-			]);
-		});
-
-		test('prepared statement reuse', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const stmt = db
-				.insert(usersTable)
-				.values({
-					verified: true,
-					name: sql.placeholder('name'),
-				})
-				.prepare('stmt2');
-
-			for (let i = 0; i < 10; i++) {
-				await stmt.execute({ name: `John ${i}` });
-			}
-
-			const result = await db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-					verified: usersTable.verified,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John 0', verified: true },
-				{ id: 2, name: 'John 1', verified: true },
-				{ id: 3, name: 'John 2', verified: true },
-				{ id: 4, name: 'John 3', verified: true },
-				{ id: 5, name: 'John 4', verified: true },
-				{ id: 6, name: 'John 5', verified: true },
-				{ id: 7, name: 'John 6', verified: true },
-				{ id: 8, name: 'John 7', verified: true },
-				{ id: 9, name: 'John 8', verified: true },
-				{ id: 10, name: 'John 9', verified: true },
-			]);
-		});
-
-		test('prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.prepare('stmt3');
-			const result = await stmt.execute({ id: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('prepared statement with placeholder in .limit', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.limit(sql.placeholder('limit'))
-				.prepare('stmt_limit');
-
-			const result = await stmt.execute({ id: 1, limit: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-			expect(result).toHaveLength(1);
-		});
-
-		test('prepared statement with placeholder in .offset', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.offset(sql.placeholder('offset'))
-				.prepare('stmt_offset');
-
-			const result = await stmt.execute({ offset: 1 });
-
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-		});
-
-		test('prepared statement built using $dynamic', async (ctx) => {
-			const { db } = ctx.pg;
-
-			function withLimitOffset(qb: any) {
-				return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
-			}
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.$dynamic();
-			withLimitOffset(stmt).prepare('stmt_limit');
-
-			const result = await stmt.execute({ limit: 1, offset: 1 });
-
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-			expect(result).toHaveLength(1);
-		});
-
-		// TODO change tests to new structure
-		test('Query check: Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			const query = db
-				.insert(users)
-				.values({})
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: 'insert into "users" ("id", "name", "state") values (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Query check: Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state').default('UA'),
-			});
-
-			const query = db
-				.insert(users)
-				.values([{}, {}])
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "users" ("id", "name", "state") values (default, default, default), (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('empty_insert_single', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
-			);
-
-			await db.insert(users).values({});
-
-			const res = await db.select().from(users);
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
-		});
-
-		test('Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('empty_insert_multiple', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
-			);
-
-			await db.insert(users).values([{}, {}]);
-
-			const res = await db.select().from(users);
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
-		});
-
-		test('build query insert with onConflict do update', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db
-				.insert(usersTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
-				params: ['John', '["foo","bar"]', 'John1'],
-			});
-		});
-
-		test('build query insert with onConflict do update / multiple columns', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db
-				.insert(usersTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
-				params: ['John', '["foo","bar"]', 'John1'],
-			});
-		});
-
-		test('build query insert with onConflict do nothing', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db
-				.insert(usersTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoNothing()
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
-				params: ['John', '["foo","bar"]'],
-			});
-		});
-
-		test('build query insert with onConflict do nothing + target', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db
-				.insert(usersTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoNothing({ target: usersTable.id })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
-				params: ['John', '["foo","bar"]'],
-			});
-		});
-
-		test('insert with onConflict do update', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			await db
-				.insert(usersTable)
-				.values({ id: 1, name: 'John' })
-				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
-
-			const res = await db
-				.select({ id: usersTable.id, name: usersTable.name })
-				.from(usersTable)
-				.where(eq(usersTable.id, 1));
-
-			expect(res).toEqual([{ id: 1, name: 'John1' }]);
-		});
-
-		test('insert with onConflict do nothing', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing();
-
-			const res = await db
-				.select({ id: usersTable.id, name: usersTable.name })
-				.from(usersTable)
-				.where(eq(usersTable.id, 1));
-
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert with onConflict do nothing + target', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			await db
-				.insert(usersTable)
-				.values({ id: 1, name: 'John' })
-				.onConflictDoNothing({ target: usersTable.id });
-
-			const res = await db
-				.select({ id: usersTable.id, name: usersTable.name })
-				.from(usersTable)
-				.where(eq(usersTable.id, 1));
-
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('left join (flat object fields)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const { id: cityId } = await db
-				.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }])
-				.returning({ id: citiesTable.id })
-				.then((rows) => rows[0]!);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
-
-			const res = await db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-				})
-				.from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{ userId: 1, userName: 'John', cityId, cityName: 'Paris' },
-				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
-			]);
-		});
-
-		test('left join (grouped fields)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const { id: cityId } = await db
-				.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }])
-				.returning({ id: citiesTable.id })
-				.then((rows) => rows[0]!);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
-
-			const res = await db
-				.select({
-					id: users2Table.id,
-					user: {
-						name: users2Table.name,
-						nameUpper: sql<string>`upper(${users2Table.name})`,
-					},
-					city: {
-						id: citiesTable.id,
-						name: citiesTable.name,
-						nameUpper: sql<string>`upper(${citiesTable.name})`,
-					},
-				})
-				.from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{
-					id: 1,
-					user: { name: 'John', nameUpper: 'JOHN' },
-					city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
-				},
-				{
-					id: 2,
-					user: { name: 'Jane', nameUpper: 'JANE' },
-					city: null,
-				},
-			]);
-		});
-
-		test('left join (all fields)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const { id: cityId } = await db
-				.insert(citiesTable)
-				.values([{ name: 'Paris' }, { name: 'London' }])
-				.returning({ id: citiesTable.id })
-				.then((rows) => rows[0]!);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
-
-			const res = await db
-				.select()
-				.from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
-
-			expect(res).toEqual([
-				{
-					users2: {
-						id: 1,
-						name: 'John',
-						cityId,
-					},
-					cities: {
-						id: cityId,
-						name: 'Paris',
-						state: null,
-					},
-				},
-				{
-					users2: {
-						id: 2,
-						name: 'Jane',
-						cityId: null,
-					},
-					cities: null,
-				},
-			]);
-		});
-
-		test('join subquery', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(courseCategoriesTable)
-				.values([
-					{ name: 'Category 1' },
-					{ name: 'Category 2' },
-					{ name: 'Category 3' },
-					{ name: 'Category 4' },
-				]);
-
-			await db
-				.insert(coursesTable)
-				.values([
-					{ name: 'Development', categoryId: 2 },
-					{ name: 'IT & Software', categoryId: 3 },
-					{ name: 'Marketing', categoryId: 4 },
-					{ name: 'Design', categoryId: 1 },
-				]);
-
-			const sq2 = db
-				.select({
-					categoryId: courseCategoriesTable.id,
-					category: courseCategoriesTable.name,
-					total: sql<number>`count(${courseCategoriesTable.id})`,
-				})
-				.from(courseCategoriesTable)
-				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
-				.as('sq2');
-
-			const res = await db
-				.select({
-					courseName: coursesTable.name,
-					categoryId: sq2.categoryId,
-				})
-				.from(coursesTable)
-				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
-				.orderBy(coursesTable.name);
-
-			expect(res).toEqual([
-				{ courseName: 'Design', categoryId: 1 },
-				{ courseName: 'Development', categoryId: 2 },
-				{ courseName: 'IT & Software', categoryId: 3 },
-				{ courseName: 'Marketing', categoryId: 4 },
-			]);
-		});
-
-		test('with ... select', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const regionalSales = db
-				.$with('regional_sales')
-				.as(
-					db
-						.select({
-							region: orders.region,
-							totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-						})
-						.from(orders)
-						.groupBy(orders.region),
-				);
-
-			const topRegions = db
-				.$with('top_regions')
-				.as(
-					db
-						.select({
-							region: regionalSales.region,
-						})
-						.from(regionalSales)
-						.where(
-							gt(
-								regionalSales.totalSales,
-								db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-							),
-						),
-				);
-
-			const result1 = await db
-				.with(regionalSales, topRegions)
-				.select({
-					region: orders.region,
-					product: orders.product,
-					productUnits: sql<number>`sum(${orders.quantity})::int`,
-					productSales: sql<number>`sum(${orders.amount})::int`,
-				})
-				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-				.groupBy(orders.region, orders.product)
-				.orderBy(orders.region, orders.product);
-			const result2 = await db
-				.with(regionalSales, topRegions)
-				.selectDistinct({
-					region: orders.region,
-					product: orders.product,
-					productUnits: sql<number>`sum(${orders.quantity})::int`,
-					productSales: sql<number>`sum(${orders.amount})::int`,
-				})
-				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-				.groupBy(orders.region, orders.product)
-				.orderBy(orders.region, orders.product);
-			const result3 = await db
-				.with(regionalSales, topRegions)
-				.selectDistinctOn([orders.region], {
-					region: orders.region,
-					productUnits: sql<number>`sum(${orders.quantity})::int`,
-					productSales: sql<number>`sum(${orders.amount})::int`,
-				})
-				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-				.groupBy(orders.region)
-				.orderBy(orders.region);
-
-			expect(result1).toEqual([
-				{
-					region: 'Europe',
-					product: 'A',
-					productUnits: 3,
-					productSales: 30,
-				},
-				{
-					region: 'Europe',
-					product: 'B',
-					productUnits: 5,
-					productSales: 50,
-				},
-				{
-					region: 'US',
-					product: 'A',
-					productUnits: 7,
-					productSales: 70,
-				},
-				{
-					region: 'US',
-					product: 'B',
-					productUnits: 9,
-					productSales: 90,
-				},
-			]);
-			expect(result2).toEqual(result1);
-			expect(result3).toEqual([
-				{
-					region: 'Europe',
-					productUnits: 8,
-					productSales: 80,
-				},
-				{
-					region: 'US',
-					productUnits: 16,
-					productSales: 160,
-				},
-			]);
-		});
-
-		test('with ... update', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const products = pgTable('products', {
-				id: serial('id').primaryKey(),
-				price: numeric('price').notNull(),
-				cheap: boolean('cheap').notNull().default(false),
-			});
-
-			await db.execute(sql`drop table if exists ${products}`);
-			await db.execute(sql`
-				create table ${products} (
-					id serial primary key,
-					price numeric not null,
-					cheap boolean not null default false
-				)
-			`);
-
-			await db.insert(products).values([
-				{ price: '10.99' },
-				{ price: '25.85' },
-				{ price: '32.99' },
-				{ price: '2.50' },
-				{ price: '4.59' },
-			]);
-
-			const averagePrice = db
-				.$with('average_price')
-				.as(
-					db
-						.select({
-							value: sql`avg(${products.price})`.as('value'),
-						})
-						.from(products),
-				);
-
-			const result = await db
-				.with(averagePrice)
-				.update(products)
-				.set({
-					cheap: true,
-				})
-				.where(lt(products.price, sql`(select * from ${averagePrice})`))
-				.returning({
-					id: products.id,
-				});
-
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
-		});
-
-		test('with ... insert', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				username: text('username').notNull(),
-				admin: boolean('admin').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (username text not null, admin boolean not null default false)`);
-
-			const userCount = db
-				.$with('user_count')
-				.as(
-					db
-						.select({
-							value: sql`count(*)`.as('value'),
-						})
-						.from(users),
-				);
-
-			const result = await db
-				.with(userCount)
-				.insert(users)
-				.values([
-					{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
-				])
-				.returning({
-					admin: users.admin,
-				});
-
-			expect(result).toEqual([{ admin: true }]);
-		});
-
-		test('with ... delete', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const averageAmount = db
-				.$with('average_amount')
-				.as(
-					db
-						.select({
-							value: sql`avg(${orders.amount})`.as('value'),
-						})
-						.from(orders),
-				);
-
-			const result = await db
-				.with(averageAmount)
-				.delete(orders)
-				.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
-				.returning({
-					id: orders.id,
-				});
-
-			expect(result).toEqual([
-				{ id: 6 },
-				{ id: 7 },
-				{ id: 8 },
-			]);
-		});
-
-		test('select from subquery sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
-				.from(users2Table)
-				.as('sq');
-
-			const res = await db.select({ name: sq.name }).from(sq);
-
-			expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
-		});
-
-		test('select a field without joining its table', (ctx) => {
-			const { db } = ctx.pg;
-
-			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare('query')).toThrowError();
-		});
-
-		test('select all fields from subquery without alias', (ctx) => {
-			const { db } = ctx.pg;
-
-			const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
-
-			expect(() => db.select().from(sq).prepare('query')).toThrowError();
-		});
-
-		test('select count()', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const res = await db.select({ count: sql`count(*)` }).from(usersTable);
-
-			expect(res).toEqual([{ count: '2' }]);
-		});
-
-		test('select count w/ custom mapper', async (ctx) => {
-			const { db } = ctx.pg;
-
-			function count(value: PgColumn | SQLWrapper): SQL<number>;
-			function count(value: PgColumn | SQLWrapper, alias: string): SQL.Aliased<number>;
-			function count(value: PgColumn | SQLWrapper, alias?: string): SQL<number> | SQL.Aliased<number> {
-				const result = sql`count(${value})`.mapWith(Number);
-				if (!alias) {
-					return result;
-				}
-				return result.as(alias);
-			}
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const res = await db.select({ count: count(sql`*`) }).from(usersTable);
-
-			expect(res).toEqual([{ count: 2 }]);
-		});
-
-		test('network types', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const value: typeof network.$inferSelect = {
-				inet: '127.0.0.1',
-				cidr: '192.168.100.128/25',
-				macaddr: '08:00:2b:01:02:03',
-				macaddr8: '08:00:2b:01:02:03:04:05',
-			};
-
-			await db.insert(network).values(value);
-
-			const res = await db.select().from(network);
-
-			expect(res).toEqual([value]);
-		});
-
-		test('array types', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const values: typeof salEmp.$inferSelect[] = [
-				{
-					name: 'John',
-					payByQuarter: [10000, 10000, 10000, 10000],
-					schedule: [['meeting', 'lunch'], ['training', 'presentation']],
-				},
-				{
-					name: 'Carol',
-					payByQuarter: [20000, 25000, 25000, 25000],
-					schedule: [['breakfast', 'consulting'], ['meeting', 'lunch']],
-				},
-			];
-
-			await db.insert(salEmp).values(values);
-
-			const res = await db.select().from(salEmp);
-
-			expect(res).toEqual(values);
-		});
-
-		test('select for ...', (ctx) => {
-			const { db } = ctx.pg;
-
-			{
-				const query = db
-					.select()
-					.from(users2Table)
-					.for('update')
-					.toSQL();
-
-				expect(query.sql).toMatch(/ for update$/);
-			}
-
-			{
-				const query = db
-					.select()
-					.from(users2Table)
-					.for('update', { of: [users2Table, coursesTable] })
-					.toSQL();
-
-				expect(query.sql).toMatch(/ for update of "users2", "courses"$/);
-			}
-
-			{
-				const query = db
-					.select()
-					.from(users2Table)
-					.for('no key update', { of: users2Table })
-					.toSQL();
-
-				expect(query.sql).toMatch(/for no key update of "users2"$/);
-			}
-
-			{
-				const query = db
-					.select()
-					.from(users2Table)
-					.for('no key update', { of: users2Table, skipLocked: true })
-					.toSQL();
-
-				expect(query.sql).toMatch(/ for no key update of "users2" skip locked$/);
-			}
-
-			{
-				const query = db
-					.select()
-					.from(users2Table)
-					.for('share', { of: users2Table, noWait: true })
-					.toSQL();
-
-				expect(query.sql).toMatch(/for share of "users2" nowait$/);
-			}
-		});
-
-		test('having', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
-				name: 'Jack',
-				cityId: 2,
-			}]);
-
-			const result = await db
-				.select({
-					id: citiesTable.id,
-					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
-					usersCount: sql<number>`count(${users2Table.id})::int`.as('users_count'),
-				})
-				.from(citiesTable)
-				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
-				.where(({ name }) => sql`length(${name}) >= 3`)
-				.groupBy(citiesTable.id)
-				.having(({ usersCount }) => sql`${usersCount} > 0`)
-				.orderBy(({ name }) => name);
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					name: 'LONDON',
-					usersCount: 2,
-				},
-				{
-					id: 2,
-					name: 'PARIS',
-					usersCount: 1,
-				},
-			]);
-		});
-
-		test('view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const newYorkers1 = pgView('new_yorkers')
-				.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
-
-			const newYorkers2 = pgView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
-
-			const newYorkers3 = pgView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		});
-
-		// NEXT
-		test('materialized view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const newYorkers1 = pgMaterializedView('new_yorkers')
-				.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
-
-			const newYorkers2 = pgMaterializedView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
-
-			const newYorkers3 = pgMaterializedView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([]);
-			}
-
-			await db.refreshMaterializedView(newYorkers1);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop materialized view ${newYorkers1}`);
-		});
-
-		test('select from existing view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const schema = pgSchema('test_schema');
-
-			const newYorkers = schema.view('new_yorkers', {
-				id: integer('id').notNull(),
-			}).existing();
-
-			await db.execute(sql`drop schema if exists ${schema} cascade`);
-			await db.execute(sql`create schema ${schema}`);
-			await db.execute(sql`create view ${newYorkers} as select id from ${usersTable}`);
-
-			await db.insert(usersTable).values({ id: 100, name: 'John' });
-
-			const result = await db.select({
-				id: usersTable.id,
-			}).from(usersTable).innerJoin(newYorkers, eq(newYorkers.id, usersTable.id));
-
-			expect(result).toEqual([{ id: 100 }]);
-		});
-
-		// TODO: copy to SQLite and MySQL, add to docs
-		test('select from raw sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const result = await db.select({
-				id: sql<number>`id`,
-				name: sql<string>`name`,
-			}).from(sql`(select 1 as id, 'John' as name) as users`);
-
-			Expect<Equal<{ id: number; name: string }[], typeof result>>;
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
-		});
-
-		test('select from raw sql with joins', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const result = await db
-				.select({
-					id: sql<number>`users.id`,
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
-
-			Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from select', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const result = await db
-				.select({
-					userId: sql<number>`users.id`.as('userId'),
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityId: sql<number>`cities.id`.as('cityId'),
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from with clause', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = db.$with('users').as(
-				db.select({
-					id: sql<number>`id`.as('userId'),
-					name: sql<string>`name`.as('userName'),
-					city: sql<string>`city`.as('city'),
-				}).from(
-					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
-				),
-			);
-
-			const cities = db.$with('cities').as(
-				db.select({
-					id: sql<number>`id`.as('cityId'),
-					name: sql<string>`name`.as('cityName'),
-				}).from(
-					sql`(select 1 as id, 'Paris' as name) as cities`,
-				),
-			);
-
-			const result = await db
-				.with(users, cities)
-				.select({
-					userId: users.id,
-					name: users.name,
-					userCity: users.city,
-					cityId: cities.id,
-					cityName: cities.name,
-				})
-				.from(users)
-				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('prefixed table', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const pgTable = pgTableCreator((name) => `myprefix_${name}`);
-
-			const users = pgTable('test_prefixed_table_with_unique_name', {
-				id: integer('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table myprefix_test_prefixed_table_with_unique_name (id integer not null primary key, name text not null)`,
-			);
-
-			await db.insert(users).values({ id: 1, name: 'John' });
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('select from enum as ts enum', async (ctx) => {
-			const { db } = ctx.pg;
-
-			enum Muscle {
-				abdominals = 'abdominals',
-				hamstrings = 'hamstrings',
-				adductors = 'adductors',
-				quadriceps = 'quadriceps',
-				biceps = 'biceps',
-				shoulders = 'shoulders',
-				chest = 'chest',
-				middle_back = 'middle_back',
-				calves = 'calves',
-				glutes = 'glutes',
-				lower_back = 'lower_back',
-				lats = 'lats',
-				triceps = 'triceps',
-				traps = 'traps',
-				forearms = 'forearms',
-				neck = 'neck',
-				abductors = 'abductors',
-			}
-
-			enum Force {
-				isometric = 'isometric',
-				isotonic = 'isotonic',
-				isokinetic = 'isokinetic',
-			}
-
-			enum Level {
-				beginner = 'beginner',
-				intermediate = 'intermediate',
-				advanced = 'advanced',
-			}
-
-			enum Mechanic {
-				compound = 'compound',
-				isolation = 'isolation',
-			}
-
-			enum Equipment {
-				barbell = 'barbell',
-				dumbbell = 'dumbbell',
-				bodyweight = 'bodyweight',
-				machine = 'machine',
-				cable = 'cable',
-				kettlebell = 'kettlebell',
-			}
-
-			enum Category {
-				upper_body = 'upper_body',
-				lower_body = 'lower_body',
-				full_body = 'full_body',
-			}
-
-			const muscleEnum = pgEnum('muscle', Muscle);
-
-			const forceEnum = pgEnum('force', Force);
-
-			const levelEnum = pgEnum('level', Level);
-
-			const mechanicEnum = pgEnum('mechanic', Mechanic);
-
-			const equipmentEnum = pgEnum('equipment', Equipment);
-
-			const categoryEnum = pgEnum('category', Category);
-
-			const exercises = pgTable('exercises', {
-				id: serial('id').primaryKey(),
-				name: varchar('name').notNull(),
-				force: forceEnum('force'),
-				level: levelEnum('level'),
-				mechanic: mechanicEnum('mechanic'),
-				equipment: equipmentEnum('equipment'),
-				instructions: text('instructions'),
-				category: categoryEnum('category'),
-				primaryMuscles: muscleEnum('primary_muscles').array(),
-				secondaryMuscles: muscleEnum('secondary_muscles').array(),
-				createdAt: timestamp('created_at').notNull().default(sql`now()`),
-				updatedAt: timestamp('updated_at').notNull().default(sql`now()`),
-			});
-
-			await db.execute(sql`drop table if exists ${exercises}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(muscleEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(forceEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(levelEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(mechanicEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(equipmentEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(categoryEnum.enumName)}`);
-
-			await db.execute(
-				sql`create type ${
-					sql.identifier(muscleEnum.enumName)
-				} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`,
-			);
-			await db.execute(sql`create type ${sql.identifier(mechanicEnum.enumName)} as enum ('compound', 'isolation')`);
-			await db.execute(
-				sql`create type ${
-					sql.identifier(equipmentEnum.enumName)
-				} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`,
-			);
-			await db.execute(sql`
-				create table ${exercises} (
-					id serial primary key,
-					name varchar not null,
-					force force,
-					level level,
-					mechanic mechanic,
-					equipment equipment,
-					instructions text,
-					category category,
-					primary_muscles muscle[],
-					secondary_muscles muscle[],
-					created_at timestamp not null default now(),
-					updated_at timestamp not null default now()
-				)
-			`);
-
-			await db.insert(exercises).values({
-				name: 'Bench Press',
-				force: Force.isotonic,
-				level: Level.beginner,
-				mechanic: Mechanic.compound,
-				equipment: Equipment.barbell,
-				instructions:
-					'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
-				category: Category.upper_body,
-				primaryMuscles: [Muscle.chest, Muscle.triceps],
-				secondaryMuscles: [Muscle.shoulders, Muscle.traps],
-			});
-
-			const result = await db.select().from(exercises);
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					name: 'Bench Press',
-					force: 'isotonic',
-					level: 'beginner',
-					mechanic: 'compound',
-					equipment: 'barbell',
-					instructions:
-						'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
-					category: 'upper_body',
-					primaryMuscles: ['chest', 'triceps'],
-					secondaryMuscles: ['shoulders', 'traps'],
-					createdAt: result[0]!.createdAt,
-					updatedAt: result[0]!.updatedAt,
-				},
-			]);
-
-			await db.execute(sql`drop table ${exercises}`);
-			await db.execute(sql`drop type ${sql.identifier(muscleEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(forceEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(levelEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(mechanicEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(equipmentEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(categoryEnum.enumName)}`);
-		});
-
-		test('select from enum', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const muscleEnum = pgEnum('muscle', [
-				'abdominals',
-				'hamstrings',
-				'adductors',
-				'quadriceps',
-				'biceps',
-				'shoulders',
-				'chest',
-				'middle_back',
-				'calves',
-				'glutes',
-				'lower_back',
-				'lats',
-				'triceps',
-				'traps',
-				'forearms',
-				'neck',
-				'abductors',
-			]);
-
-			const forceEnum = pgEnum('force', ['isometric', 'isotonic', 'isokinetic']);
-
-			const levelEnum = pgEnum('level', ['beginner', 'intermediate', 'advanced']);
-
-			const mechanicEnum = pgEnum('mechanic', ['compound', 'isolation']);
-
-			const equipmentEnum = pgEnum('equipment', [
-				'barbell',
-				'dumbbell',
-				'bodyweight',
-				'machine',
-				'cable',
-				'kettlebell',
-			]);
-
-			const categoryEnum = pgEnum('category', ['upper_body', 'lower_body', 'full_body']);
-
-			const exercises = pgTable('exercises', {
-				id: serial('id').primaryKey(),
-				name: varchar('name').notNull(),
-				force: forceEnum('force'),
-				level: levelEnum('level'),
-				mechanic: mechanicEnum('mechanic'),
-				equipment: equipmentEnum('equipment'),
-				instructions: text('instructions'),
-				category: categoryEnum('category'),
-				primaryMuscles: muscleEnum('primary_muscles').array(),
-				secondaryMuscles: muscleEnum('secondary_muscles').array(),
-				createdAt: timestamp('created_at').notNull().default(sql`now()`),
-				updatedAt: timestamp('updated_at').notNull().default(sql`now()`),
-			});
-
-			await db.execute(sql`drop table if exists ${exercises}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(muscleEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(forceEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(levelEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(mechanicEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(equipmentEnum.enumName)}`);
-			await db.execute(sql`drop type if exists ${sql.identifier(categoryEnum.enumName)}`);
-
-			await db.execute(
-				sql`create type ${
-					sql.identifier(muscleEnum.enumName)
-				} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`,
-			);
-			await db.execute(sql`create type ${sql.identifier(mechanicEnum.enumName)} as enum ('compound', 'isolation')`);
-			await db.execute(
-				sql`create type ${
-					sql.identifier(equipmentEnum.enumName)
-				} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`,
-			);
-			await db.execute(
-				sql`create type ${sql.identifier(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`,
-			);
-			await db.execute(sql`
-				create table ${exercises} (
-					id serial primary key,
-					name varchar not null,
-					force force,
-					level level,
-					mechanic mechanic,
-					equipment equipment,
-					instructions text,
-					category category,
-					primary_muscles muscle[],
-					secondary_muscles muscle[],
-					created_at timestamp not null default now(),
-					updated_at timestamp not null default now()
-				)
-			`);
-
-			await db.insert(exercises).values({
-				name: 'Bench Press',
-				force: 'isotonic',
-				level: 'beginner',
-				mechanic: 'compound',
-				equipment: 'barbell',
-				instructions:
-					'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
-				category: 'upper_body',
-				primaryMuscles: ['chest', 'triceps'],
-				secondaryMuscles: ['shoulders', 'traps'],
-			});
-
-			const result = await db.select().from(exercises);
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					name: 'Bench Press',
-					force: 'isotonic',
-					level: 'beginner',
-					mechanic: 'compound',
-					equipment: 'barbell',
-					instructions:
-						'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
-					category: 'upper_body',
-					primaryMuscles: ['chest', 'triceps'],
-					secondaryMuscles: ['shoulders', 'traps'],
-					createdAt: result[0]!.createdAt,
-					updatedAt: result[0]!.updatedAt,
-				},
-			]);
-
-			await db.execute(sql`drop table ${exercises}`);
-			await db.execute(sql`drop type ${sql.identifier(muscleEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(forceEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(levelEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(mechanicEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(equipmentEnum.enumName)}`);
-			await db.execute(sql`drop type ${sql.identifier(categoryEnum.enumName)}`);
-		});
-
-		test('all date and time columns', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const table = pgTable('all_columns', {
-				id: serial('id').primaryKey(),
-				dateString: date('date_string', { mode: 'string' }).notNull(),
-				time: time('time', { precision: 3 }).notNull(),
-				datetime: timestamp('datetime').notNull(),
-				datetimeWTZ: timestamp('datetime_wtz', { withTimezone: true }).notNull(),
-				datetimeString: timestamp('datetime_string', { mode: 'string' }).notNull(),
-				datetimeFullPrecision: timestamp('datetime_full_precision', { precision: 6, mode: 'string' }).notNull(),
-				datetimeWTZString: timestamp('datetime_wtz_string', { withTimezone: true, mode: 'string' }).notNull(),
-				interval: interval('interval').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${table}`);
-
-			await db.execute(sql`
-				create table ${table} (
-							id serial primary key,
-							date_string date not null,
-							time time(3) not null,
-							datetime timestamp not null,
-							datetime_wtz timestamp with time zone not null,
-							datetime_string timestamp not null,
-							datetime_full_precision timestamp(6) not null,
-							datetime_wtz_string timestamp with time zone not null,
-							interval interval not null
-					)
-			`);
-
-			const someDatetime = new Date('2022-01-01T00:00:00.123Z');
-			const fullPrecision = '2022-01-01T00:00:00.123456Z';
-			const someTime = '23:23:12.432';
-
-			await db.insert(table).values({
-				dateString: '2022-01-01',
-				time: someTime,
-				datetime: someDatetime,
-				datetimeWTZ: someDatetime,
-				datetimeString: '2022-01-01T00:00:00.123Z',
-				datetimeFullPrecision: fullPrecision,
-				datetimeWTZString: '2022-01-01T00:00:00.123Z',
-				interval: '1 day',
-			});
-
-			const result = await db.select().from(table);
-
-			Expect<
-				Equal<{
-					id: number;
-					dateString: string;
-					time: string;
-					datetime: Date;
-					datetimeWTZ: Date;
-					datetimeString: string;
-					datetimeFullPrecision: string;
-					datetimeWTZString: string;
-					interval: string;
-				}[], typeof result>
-			>;
-
-			Expect<
-				Equal<{
-					dateString: string;
-					time: string;
-					datetime: Date;
-					datetimeWTZ: Date;
-					datetimeString: string;
-					datetimeFullPrecision: string;
-					datetimeWTZString: string;
-					interval: string;
-					id?: number | undefined;
-				}, typeof table.$inferInsert>
-			>;
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					dateString: '2022-01-01',
-					time: someTime,
-					datetime: someDatetime,
-					datetimeWTZ: someDatetime,
-					datetimeString: '2022-01-01 00:00:00.123',
-					datetimeFullPrecision: fullPrecision.replace('T', ' ').replace('Z', ''),
-					datetimeWTZString: '2022-01-01 00:00:00.123+00',
-					interval: '1 day',
-				},
-			]);
-
-			await db.execute(sql`drop table if exists ${table}`);
-		});
-
-		test('all date and time columns with timezone second case mode date', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const table = pgTable('all_columns', {
-				id: serial('id').primaryKey(),
-				timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${table}`);
-
-			await db.execute(sql`
-				create table ${table} (
-							id serial primary key,
-							timestamp_string timestamp(3) with time zone not null
-					)
-			`);
-
-			const insertedDate = new Date();
-
-			// 1. Insert date as new date
-			await db.insert(table).values([
-				{ timestamp: insertedDate },
-			]);
-
-			// 2, Select as date and check that timezones are the same
-			// There is no way to check timezone in Date object, as it is always represented internally in UTC
-			const result = await db.select().from(table);
-
-			expect(result).toEqual([{ id: 1, timestamp: insertedDate }]);
-
-			// 3. Compare both dates
-			expect(insertedDate.getTime()).toBe(result[0]?.timestamp.getTime());
-
-			await db.execute(sql`drop table if exists ${table}`);
-		});
-
-		test('all date and time columns with timezone third case mode date', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const table = pgTable('all_columns', {
-				id: serial('id').primaryKey(),
-				timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${table}`);
-
-			await db.execute(sql`
-				create table ${table} (
-							id serial primary key,
-							timestamp_string timestamp(3) with time zone not null
-					)
-			`);
-
-			const insertedDate = new Date('2022-01-01 20:00:00.123-04'); // used different time zones, internally is still UTC
-			const insertedDate2 = new Date('2022-01-02 04:00:00.123+04'); // They are both the same date in different time zones
-
-			// 1. Insert date as new dates with different time zones
-			await db.insert(table).values([
-				{ timestamp: insertedDate },
-				{ timestamp: insertedDate2 },
-			]);
-
-			// 2, Select and compare both dates
-			const result = await db.select().from(table);
-
-			expect(result[0]?.timestamp.getTime()).toBe(result[1]?.timestamp.getTime());
-
-			await db.execute(sql`drop table if exists ${table}`);
-		});
-
-		test('orderBy with aliased column', (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db.select({
-				test: sql`something`.as('test'),
-			}).from(users2Table).orderBy((fields) => fields.test).toSQL();
-
-			expect(query.sql).toBe('select something as "test" from "users2" order by "test"');
-		});
-
-		test('select from sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const metricEntry = pgTable('metric_entry', {
-				id: pgUuid('id').notNull(),
-				createdAt: timestamp('created_at').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${metricEntry}`);
-			await db.execute(sql`create table ${metricEntry} (id uuid not null, created_at timestamp not null)`);
-
-			const metricId = uuidV4();
-
-			const intervals = db.$with('intervals').as(
-				db
-					.select({
-						startTime: sql<string>`(date'2023-03-01'+ x * '1 day'::interval)`.as('start_time'),
-						endTime: sql<string>`(date'2023-03-01'+ (x+1) *'1 day'::interval)`.as('end_time'),
-					})
-					.from(sql`generate_series(0, 29, 1) as t(x)`),
-			);
-
-			const func = () =>
-				db
-					.with(intervals)
-					.select({
-						startTime: intervals.startTime,
-						endTime: intervals.endTime,
-						count: sql<number>`count(${metricEntry})`,
-					})
-					.from(metricEntry)
-					.rightJoin(
-						intervals,
-						and(
-							eq(metricEntry.id, metricId),
-							gte(metricEntry.createdAt, intervals.startTime),
-							lt(metricEntry.createdAt, intervals.endTime),
-						),
-					)
-					.groupBy(intervals.startTime, intervals.endTime)
-					.orderBy(asc(intervals.startTime));
-
-			await expect((async () => {
-				func();
-			})()).resolves.not.toThrowError();
-		});
-
-		test('timestamp timezone', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const usersTableWithAndWithoutTimezone = pgTable('users_test_with_and_without_timezone', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-				updatedAt: timestamp('updated_at', { withTimezone: false }).notNull().defaultNow(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersTableWithAndWithoutTimezone}`);
-
-			await db.execute(
-				sql`
-					create table users_test_with_and_without_timezone (
-						id serial not null primary key,
-						name text not null,
-						created_at timestamptz not null default now(),
-						updated_at timestamp not null default now()
-					)
-				`,
-			);
-
-			const date = new Date(Date.parse('2020-01-01T00:00:00+04:00'));
-
-			await db.insert(usersTableWithAndWithoutTimezone).values({ name: 'With default times' });
-			await db.insert(usersTableWithAndWithoutTimezone).values({
-				name: 'Without default times',
-				createdAt: date,
-				updatedAt: date,
-			});
-			const users = await db.select().from(usersTableWithAndWithoutTimezone);
-
-			// check that the timestamps are set correctly for default times
-			expect(Math.abs(users[0]!.updatedAt.getTime() - Date.now())).toBeLessThan(2000);
-			expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
-
-			// check that the timestamps are set correctly for non default times
-			expect(Math.abs(users[1]!.updatedAt.getTime() - date.getTime())).toBeLessThan(2000);
-			expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
-		});
-
-		test('transaction', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_transactions', {
-				id: serial('id').primaryKey(),
-				balance: integer('balance').notNull(),
-			});
-			const products = pgTable('products_transactions', {
-				id: serial('id').primaryKey(),
-				price: integer('price').notNull(),
-				stock: integer('stock').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop table if exists ${products}`);
-
-			await db.execute(sql`create table users_transactions (id serial not null primary key, balance integer not null)`);
-			await db.execute(
-				sql`create table products_transactions (id serial not null primary key, price integer not null, stock integer not null)`,
-			);
-
-			const user = await db.insert(users).values({ balance: 100 }).returning().then((rows) => rows[0]!);
-			const product = await db.insert(products).values({ price: 10, stock: 10 }).returning().then((rows) => rows[0]!);
-
-			await db.transaction(async (tx) => {
-				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
-				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 90 }]);
-
-			await db.execute(sql`drop table ${users}`);
-			await db.execute(sql`drop table ${products}`);
-		});
-
-		test('transaction rollback', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_transactions_rollback', {
-				id: serial('id').primaryKey(),
-				balance: integer('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_transactions_rollback (id serial not null primary key, balance integer not null)`,
-			);
-
-			await expect((async () => {
-				await db.transaction(async (tx) => {
-					await tx.insert(users).values({ balance: 100 });
-					tx.rollback();
-				});
-			})()).rejects.toThrowError(TransactionRollbackError);
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('nested transaction', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_nested_transactions', {
-				id: serial('id').primaryKey(),
-				balance: integer('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_nested_transactions (id serial not null primary key, balance integer not null)`,
-			);
-
-			await db.transaction(async (tx) => {
-				await tx.insert(users).values({ balance: 100 });
-
-				await tx.transaction(async (tx) => {
-					await tx.update(users).set({ balance: 200 });
-				});
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 200 }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('nested transaction rollback', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_nested_transactions_rollback', {
-				id: serial('id').primaryKey(),
-				balance: integer('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_nested_transactions_rollback (id serial not null primary key, balance integer not null)`,
-			);
-
-			await db.transaction(async (tx) => {
-				await tx.insert(users).values({ balance: 100 });
-
-				await expect((async () => {
-					await tx.transaction(async (tx) => {
-						await tx.update(users).set({ balance: 200 });
-						tx.rollback();
-					});
-				})()).rejects.toThrowError(TransactionRollbackError);
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 100 }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('join subquery with join', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const internalStaff = pgTable('internal_staff', {
-				userId: integer('user_id').notNull(),
-			});
-
-			const customUser = pgTable('custom_user', {
-				id: integer('id').notNull(),
-			});
-
-			const ticket = pgTable('ticket', {
-				staffId: integer('staff_id').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${internalStaff}`);
-			await db.execute(sql`drop table if exists ${customUser}`);
-			await db.execute(sql`drop table if exists ${ticket}`);
-
-			await db.execute(sql`create table internal_staff (user_id integer not null)`);
-			await db.execute(sql`create table custom_user (id integer not null)`);
-			await db.execute(sql`create table ticket (staff_id integer not null)`);
-
-			await db.insert(internalStaff).values({ userId: 1 });
-			await db.insert(customUser).values({ id: 1 });
-			await db.insert(ticket).values({ staffId: 1 });
-
-			const subq = db
-				.select()
-				.from(internalStaff)
-				.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
-				.as('internal_staff');
-
-			const mainQuery = await db
-				.select()
-				.from(ticket)
-				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-			expect(mainQuery).toEqual([{
-				ticket: { staffId: 1 },
-				internal_staff: {
-					internal_staff: { userId: 1 },
-					custom_user: { id: 1 },
-				},
-			}]);
-
-			await db.execute(sql`drop table ${internalStaff}`);
-			await db.execute(sql`drop table ${customUser}`);
-			await db.execute(sql`drop table ${ticket}`);
-		});
-
-		test('subquery with view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_subquery_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			});
-
-			const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 1 },
-				{ name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.$with('sq').as(db.select().from(newYorkers));
-			const result = await db.with(sq).select().from(sq);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 3, name: 'Jack', cityId: 1 },
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('join view as subquery', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users_join_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			});
-
-			const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 1 },
-				{ name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
-
-			const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
-
-			expect(result).toEqual([
-				{
-					users_join_view: { id: 1, name: 'John', cityId: 1 },
-					new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 2, name: 'Jane', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-				{
-					users_join_view: { id: 3, name: 'Jack', cityId: 1 },
-					new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 4, name: 'Jill', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('table selection with single table', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-
-			await db.insert(users).values({ name: 'John', cityId: 1 });
-
-			const result = await db.select({ users }).from(users);
-
-			expect(result).toEqual([{ users: { id: 1, name: 'John', cityId: 1 } }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('set null to jsonb field', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				jsonb: jsonb('jsonb'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, jsonb jsonb)`,
-			);
-
-			const result = await db.insert(users).values({ jsonb: null }).returning();
-
-			expect(result).toEqual([{ id: 1, jsonb: null }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('insert undefined', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.insert(users).values({ name: undefined });
-			})()).resolves.not.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('update undefined', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.update(users).set({ name: undefined });
-			})()).rejects.toThrowError();
-			await expect((async () => {
-				db.update(users).set({ name: undefined });
-			})()).rejects.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('array operators', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const posts = pgTable('posts', {
-				id: serial('id').primaryKey(),
-				tags: text('tags').array(),
-			});
-
-			await db.execute(sql`drop table if exists ${posts}`);
-
-			await db.execute(
-				sql`create table ${posts} (id serial primary key, tags text[])`,
-			);
-
-			await db.insert(posts).values([{
-				tags: ['ORM'],
-			}, {
-				tags: ['Typescript'],
-			}, {
-				tags: ['Typescript', 'ORM'],
-			}, {
-				tags: ['Typescript', 'Frontend', 'React'],
-			}, {
-				tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
-			}, {
-				tags: ['Java', 'Spring', 'OOP'],
-			}]);
-
-			const contains = await db.select({ id: posts.id }).from(posts)
-				.where(arrayContains(posts.tags, ['Typescript', 'ORM']));
-			const contained = await db.select({ id: posts.id }).from(posts)
-				.where(arrayContained(posts.tags, ['Typescript', 'ORM']));
-			const overlaps = await db.select({ id: posts.id }).from(posts)
-				.where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']));
-			const withSubQuery = await db.select({ id: posts.id }).from(posts)
-				.where(arrayContains(
-					posts.tags,
-					db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
-				));
-
-			expect(contains).toEqual([{ id: 3 }, { id: 5 }]);
-			expect(contained).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-			expect(overlaps).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-			expect(withSubQuery).toEqual([{ id: 1 }, { id: 3 }, { id: 5 }]);
-		});
-
-		test('set operations (union) from query builder with subquery', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const sq = db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table).as('sq');
-
-			const result = await db
-				.select({ id: cities2Table.id, name: citiesTable.name })
-				.from(cities2Table).union(
-					db.select().from(sq),
-				).orderBy(asc(sql`name`)).limit(2).offset(1);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 3, name: 'Jack' },
-				{ id: 2, name: 'Jane' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name, name2: users2Table.name })
-					.from(cities2Table).union(
-						// @ts-expect-error
-						db
-							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table),
-					).orderBy(asc(sql`name`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await union(
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).orderBy(asc(sql`name`)).limit(1).offset(1);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				union(
-					db
-						.select({ name: citiesTable.name, id: cities2Table.id })
-						.from(cities2Table).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).orderBy(asc(sql`name`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) from query builder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: cities2Table.id, name: citiesTable.name })
-				.from(cities2Table).limit(2).unionAll(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).limit(2),
-				).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(4);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 2, name: 'London' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).limit(2).unionAll(
-						db
-							.select({ name: citiesTable.name, id: cities2Table.id })
-							.from(cities2Table).limit(2),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await unionAll(
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(3);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-			]);
-
-			await expect((async () => {
-				unionAll(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).where(eq(citiesTable.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) from query builder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: cities2Table.id, name: citiesTable.name })
-				.from(cities2Table).intersect(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).where(gt(citiesTable.id, 1)),
-				).orderBy(asc(sql`name`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).intersect(
-						// @ts-expect-error
-						db
-							.select({ id: cities2Table.id, name: citiesTable.name, id2: cities2Table.id })
-							.from(cities2Table).where(gt(citiesTable.id, 1)),
-					).orderBy(asc(sql`name`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await intersect(
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(0);
-
-			expect(result).toEqual([]);
-
-			await expect((async () => {
-				intersect(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect all) from query builder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: cities2Table.id, name: citiesTable.name })
-				.from(cities2Table).limit(2).intersectAll(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).limit(2),
-				).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).limit(2).intersectAll(
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(cities2Table).limit(2),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect all) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await intersectAll(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
-
-			await expect((async () => {
-				intersectAll(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except) from query builder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(cities2Table).except(
-					db
-						.select()
-						.from(cities2Table).where(gt(citiesTable.id, 1)),
-				);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				db
-					.select()
-					.from(cities2Table).except(
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(cities2Table).where(gt(citiesTable.id, 1)),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await except(
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table),
-				db
-					.select({ id: cities2Table.id, name: citiesTable.name })
-					.from(cities2Table).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				except(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(cities2Table).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except all) from query builder', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(cities2Table).exceptAll(
-					db
-						.select({ id: cities2Table.id, name: citiesTable.name })
-						.from(cities2Table).where(eq(citiesTable.id, 1)),
-				).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ name: cities2Table.name, id: cities2Table.id })
-					.from(cities2Table).exceptAll(
-						db
-							.select({ id: cities2Table.id, name: citiesTable.name })
-							.from(cities2Table).where(eq(citiesTable.id, 1)),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except all) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await exceptAll(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(gt(users2Table.id, 7)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).orderBy(asc(sql`id`)).limit(5).offset(2);
-
-			expect(result).toHaveLength(4);
-
-			expect(result).toEqual([
-				{ id: 4, name: 'Peter' },
-				{ id: 5, name: 'Ben' },
-				{ id: 6, name: 'Jill' },
-				{ id: 7, name: 'Mary' },
-			]);
-
-			await expect((async () => {
-				exceptAll(
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(gt(users2Table.id, 7)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (mixed) from query builder with subquery', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-			const sq = db
-				.select()
-				.from(cities2Table).where(gt(citiesTable.id, 1)).as('sq');
-
-			const result = await db
-				.select()
-				.from(cities2Table).except(
-					({ unionAll }) =>
-						unionAll(
-							db.select().from(sq),
-							db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
-						),
-				);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				db
-					.select()
-					.from(cities2Table).except(
-						({ unionAll }) =>
-							unionAll(
-								db
-									.select({ name: cities2Table.name, id: cities2Table.id })
-									.from(cities2Table).where(gt(citiesTable.id, 1)),
-								db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
-							),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (mixed all) as function', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await setupSetOperationTest(db);
-
-			const result = await union(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				except(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(gte(users2Table.id, 5)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 7)),
-				),
-				db
-					.select().from(cities2Table).where(gt(citiesTable.id, 1)),
-			).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(6);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-				{ id: 5, name: 'Ben' },
-				{ id: 6, name: 'Jill' },
-				{ id: 8, name: 'Sally' },
-			]);
-
-			await expect((async () => {
-				union(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					except(
-						db
-							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table).where(gte(users2Table.id, 5)),
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(users2Table).where(eq(users2Table.id, 7)),
-					),
-					db
-						.select().from(cities2Table).where(gt(citiesTable.id, 1)),
-				).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('aggregate function: count', async (ctx) => {
-			const { db } = ctx.pg;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: count() }).from(table);
-			const result2 = await db.select({ value: count(table.a) }).from(table);
-			const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
-
-			expect(result1[0]?.value).toBe(7);
-			expect(result2[0]?.value).toBe(5);
-			expect(result3[0]?.value).toBe(6);
-		});
-
-		test('aggregate function: avg', async (ctx) => {
-			const { db } = ctx.pg;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: avg(table.b) }).from(table);
-			const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('33.3333333333333333');
-			expect(result2[0]?.value).toBeNull();
-			expect(result3[0]?.value).toBe('42.5000000000000000');
-		});
-
-		test('aggregate function: sum', async (ctx) => {
-			const { db } = ctx.pg;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: sum(table.b) }).from(table);
-			const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('200');
-			expect(result2[0]?.value).toBeNull();
-			expect(result3[0]?.value).toBe('170');
-		});
-
-		test('aggregate function: max', async (ctx) => {
-			const { db } = ctx.pg;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: max(table.b) }).from(table);
-			const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(90);
-			expect(result2[0]?.value).toBeNull();
-		});
-
-		test('aggregate function: min', async (ctx) => {
-			const { db } = ctx.pg;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: min(table.b) }).from(table);
-			const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(10);
-			expect(result2[0]?.value).toBeNull();
-		});
-
-		test('array mapping and parsing', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const arrays = pgTable('arrays_tests', {
-				id: serial('id').primaryKey(),
-				tags: text('tags').array(),
-				nested: text('nested').array().array(),
-				numbers: integer('numbers').notNull().array(),
-			});
-
-			await db.execute(sql`drop table if exists ${arrays}`);
-			await db.execute(sql`
-				 create table ${arrays} (
-				 id serial primary key,
-				 tags text[],
-				 nested text[][],
-				 numbers integer[]
-				)
-			`);
-
-			await db.insert(arrays).values({
-				tags: ['', 'b', 'c'],
-				nested: [['1', ''], ['3', '\\a']],
-				numbers: [1, 2, 3],
-			});
-
-			const result = await db.select().from(arrays);
-
-			expect(result).toEqual([{
-				id: 1,
-				tags: ['', 'b', 'c'],
-				nested: [['1', ''], ['3', '\\a']],
-				numbers: [1, 2, 3],
-			}]);
-
-			await db.execute(sql`drop table ${arrays}`);
-		});
-
-		test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial primary key,
-					name text not null,
-					update_counter integer default 1 not null,
-					updated_at timestamp(3),
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			expect(response).toEqual([
-				{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
-			]);
-			const msDelay = 250;
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial primary key,
-					name text not null,
-					update_counter integer default 1,
-					updated_at timestamp(3),
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John', alwaysNull: 'this will be null after updating' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-			await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			await db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id, 1));
-			await db.update(usersOnUpdate).set({ updateCounter: null }).where(eq(usersOnUpdate.id, 2));
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			expect(response).toEqual([
-				{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
-			]);
-			const msDelay = 15000;
-
-			// expect(initial[0]?.updatedAt?.valueOf()).not.toBe(justDates[0]?.updatedAt?.valueOf());
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		test('test if method with sql operators', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				age: integer('age').notNull(),
-				city: text('city').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(sql`
-				create table ${users} (
-				id serial primary key,
-				name text not null,
-				age integer not null,
-				city text not null
-				)
-			`);
-
-			await db.insert(users).values([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition1 = true;
-
-			const [result1] = await db.select().from(users).where(eq(users.id, 1).if(condition1));
-
-			expect(result1).toEqual({ id: 1, name: 'John', age: 20, city: 'New York' });
-
-			const condition2 = 1;
-
-			const [result2] = await db.select().from(users).where(sql`${users.id} = 1`.if(condition2));
-
-			expect(result2).toEqual({ id: 1, name: 'John', age: 20, city: 'New York' });
-
-			const condition3 = 'non-empty string';
-
-			const result3 = await db.select().from(users).where(
-				or(eq(users.id, 1).if(condition3), eq(users.id, 2).if(condition3)),
-			);
-
-			expect(result3).toEqual([{ id: 1, name: 'John', age: 20, city: 'New York' }, {
-				id: 2,
-				name: 'Alice',
-				age: 21,
-				city: 'New York',
-			}]);
-
-			const condtition4 = false;
-
-			const result4 = await db.select().from(users).where(eq(users.id, 1).if(condtition4));
-
-			expect(result4).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition5 = undefined;
-
-			const result5 = await db.select().from(users).where(sql`${users.id} = 1`.if(condition5));
-
-			expect(result5).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition6 = null;
-
-			const result6 = await db.select().from(users).where(
-				or(eq(users.id, 1).if(condition6), eq(users.id, 2).if(condition6)),
-			);
-
-			expect(result6).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition7 = {
-				term1: 0,
-				term2: 1,
-			};
-
-			const result7 = await db.select().from(users).where(
-				and(gt(users.age, 20).if(condition7.term1), eq(users.city, 'New York').if(condition7.term2)),
-			);
-
-			expect(result7).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-			]);
-
-			const condition8 = {
-				term1: '',
-				term2: 'non-empty string',
-			};
-
-			const result8 = await db.select().from(users).where(
-				or(lt(users.age, 21).if(condition8.term1), eq(users.city, 'London').if(condition8.term2)),
-			);
-
-			expect(result8).toEqual([
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition9 = {
-				term1: 1,
-				term2: true,
-			};
-
-			const result9 = await db.select().from(users).where(
-				and(
-					inArray(users.city, ['New York', 'London']).if(condition9.term1),
-					ilike(users.name, 'a%').if(condition9.term2),
-				),
-			);
-
-			expect(result9).toEqual([
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-			]);
-
-			const condition10 = {
-				term1: 4,
-				term2: 19,
-			};
-
-			const result10 = await db.select().from(users).where(
-				and(
-					sql`length(${users.name}) <= ${condition10.term1}`.if(condition10.term1),
-					gt(users.age, condition10.term2).if(condition10.term2 > 20),
-				),
-			);
-
-			expect(result10).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition11 = true;
-
-			const result11 = await db.select().from(users).where(
-				or(eq(users.city, 'New York'), gte(users.age, 22))!.if(condition11),
-			);
-
-			expect(result11).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition12 = false;
-
-			const result12 = await db.select().from(users).where(
-				and(eq(users.city, 'London'), gte(users.age, 23))!.if(condition12),
-			);
-
-			expect(result12).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition13 = true;
-
-			const result13 = await db.select().from(users).where(sql`(city = 'New York' or age >= 22)`.if(condition13));
-
-			expect(result13).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			const condition14 = false;
-
-			const result14 = await db.select().from(users).where(sql`(city = 'London' and age >= 23)`.if(condition14));
-
-			expect(result14).toEqual([
-				{ id: 1, name: 'John', age: 20, city: 'New York' },
-				{ id: 2, name: 'Alice', age: 21, city: 'New York' },
-				{ id: 3, name: 'Nick', age: 22, city: 'London' },
-				{ id: 4, name: 'Lina', age: 23, city: 'London' },
-			]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		// MySchema tests
-		test('mySchema :: select all fields', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const now = Date.now();
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(300);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: select sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select typed sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql<string>`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select distinct', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const usersDistinctTable = pgTable('users_distinct', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id integer, name text)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]);
-			const users1 = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-			const users2 = await db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-			);
-			const users3 = await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
-				usersDistinctTable,
-			).orderBy(usersDistinctTable.name);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users1).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-
-			expect(users2).toHaveLength(2);
-			expect(users2[0]?.id).toBe(1);
-			expect(users2[1]?.id).toBe(2);
-
-			expect(users3).toHaveLength(2);
-			expect(users3[0]?.name).toBe('Jane');
-			expect(users3[1]?.name).toBe('John');
-		});
-
-		test('mySchema :: insert returning sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = await db.insert(usersMySchemaTable).values({ name: 'John' }).returning({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			});
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: delete returning sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John')).returning({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			});
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: update with returning partial', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(eq(usersMySchemaTable.name, 'John'))
-				.returning({
-					id: usersMySchemaTable.id,
-					name: usersMySchemaTable.name,
-				});
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('mySchema :: delete with returning all fields', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const now = Date.now();
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John')).returning();
-
-			expect(users[0]!.createdAt).toBeInstanceOf(Date);
-			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(300);
-			expect(users).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
-		});
-
-		test('mySchema :: insert + select', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-			await db.insert(usersMySchemaTable).values({ name: 'Jane' });
-			const result2 = await db.select().from(usersMySchemaTable);
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('mySchema :: insert with overridden default values', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John', verified: true });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: insert many', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]);
-			const result = await db.select({
-				id: usersMySchemaTable.id,
-				name: usersMySchemaTable.name,
-				jsonb: usersMySchemaTable.jsonb,
-				verified: usersMySchemaTable.verified,
-			}).from(usersMySchemaTable);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('mySchema :: select with group by as field', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.name);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('mySchema :: select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`);
-
-			expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
-		});
-
-		test('mySchema :: build query', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: 'select "id", "name" from "mySchema"."users" group by "mySchema"."users"."id", "mySchema"."users"."name"',
-				params: [],
-			});
-		});
-
-		test('mySchema :: partial join with alias', async (ctx) => {
-			const { db } = ctx.pg;
-			const customerAlias = alias(usersMySchemaTable, 'customer');
-
-			await db.insert(usersMySchemaTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select({
-					user: {
-						id: usersMySchemaTable.id,
-						name: usersMySchemaTable.name,
-					},
-					customer: {
-						id: customerAlias.id,
-						name: customerAlias.name,
-					},
-				}).from(usersMySchemaTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersMySchemaTable.id, 10));
-
-			expect(result).toEqual([{
-				user: { id: 10, name: 'Ivan' },
-				customer: { id: 11, name: 'Hans' },
-			}]);
-		});
-
-		test('mySchema :: insert with spaces', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
-				usersMySchemaTable,
-			);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('mySchema :: prepared statement with placeholder in .limit', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const stmt = db
-				.select({
-					id: usersMySchemaTable.id,
-					name: usersMySchemaTable.name,
-				})
-				.from(usersMySchemaTable)
-				.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
-				.limit(sql.placeholder('limit'))
-				.prepare('mySchema_stmt_limit');
-
-			const result = await stmt.execute({ id: 1, limit: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-			expect(result).toHaveLength(1);
-		});
-
-		test('mySchema :: build query insert with onConflict do update / multiple columns', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db.insert(usersMySchemaTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoUpdate({ target: [usersMySchemaTable.id, usersMySchemaTable.name], set: { name: 'John1' } })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
-				params: ['John', '["foo","bar"]', 'John1'],
-			});
-		});
-
-		test('mySchema :: build query insert with onConflict do nothing + target', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const query = db.insert(usersMySchemaTable)
-				.values({ name: 'John', jsonb: ['foo', 'bar'] })
-				.onConflictDoNothing({ target: usersMySchemaTable.id })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into "mySchema"."users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
-				params: ['John', '["foo","bar"]'],
-			});
-		});
-
-		test('mySchema :: select from tables with same name from different schema using alias', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
-			await db.insert(usersTable).values({ id: 11, name: 'Hans' });
-
-			const customerAlias = alias(usersTable, 'customer');
-
-			const result = await db
-				.select().from(usersMySchemaTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(customerAlias.id, 11));
-
-			expect(result).toEqual([{
-				users: {
-					id: 10,
-					name: 'Ivan',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.users.createdAt,
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.customer!.createdAt,
-				},
-			}]);
-		});
-
-		test('mySchema :: view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const newYorkers1 = mySchema.view('new_yorkers')
-				.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
-
-			const newYorkers2 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
-
-			const newYorkers3 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesMySchemaTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2MySchemaTable).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		});
-
-		test('mySchema :: materialized view', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const newYorkers1 = mySchema.materializedView('new_yorkers')
-				.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
-
-			const newYorkers2 = mySchema.materializedView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
-
-			const newYorkers3 = mySchema.materializedView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesMySchemaTable).values([{ name: 'New York' }, { name: 'Paris' }]);
-
-			await db.insert(users2MySchemaTable).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([]);
-			}
-
-			await db.refreshMaterializedView(newYorkers1);
-
-			{
-				const result = await db.select().from(newYorkers1);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3);
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop materialized view ${newYorkers1}`);
-		});
-
-		test('limit 0', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(0);
-
-			expect(users).toEqual([]);
-		});
-
-		test('limit -1', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(-1);
-
-			expect(users.length).toBeGreaterThan(0);
-		});
-
-		test('Object keys as column names', async (ctx) => {
-			const { db } = ctx.pg;
-
-			// Tests the following:
-			// Column with required config
-			// Column with optional config without providing a value
-			// Column with optional config providing a value
-			// Column without config
-			const users = pgTable('users', {
-				id: bigserial({ mode: 'number' }).primaryKey(),
-				firstName: varchar(),
-				lastName: varchar({ length: 50 }),
-				admin: boolean(),
-			});
-
-			await db.execute(sql`drop table if exists users`);
-			await db.execute(
-				sql`
-					create table users (
-						"id" bigserial primary key,
-						"firstName" varchar,
-						"lastName" varchar(50),
-						"admin" boolean
-					)
-				`,
-			);
-
-			await db.insert(users).values([
-				{ firstName: 'John', lastName: 'Doe', admin: true },
-				{ firstName: 'Jane', lastName: 'Smith', admin: false },
-			]);
-			const result = await db
-				.select({ id: users.id, firstName: users.firstName, lastName: users.lastName })
-				.from(users)
-				.where(eq(users.admin, true));
-
-			expect(result).toEqual([
-				{ id: 1, firstName: 'John', lastName: 'Doe' },
-			]);
-
-			await db.execute(sql`drop table users`);
-		});
-
-		test('proper json and jsonb handling', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const jsonTable = pgTable('json_table', {
-				json: json('json').$type<{ name: string; age: number }>(),
-				jsonb: jsonb('jsonb').$type<{ name: string; age: number }>(),
-			});
-
-			await db.execute(sql`drop table if exists ${jsonTable}`);
-
-			await db.execute(sql`create table ${jsonTable} (json json, jsonb jsonb)`);
-
-			await db.insert(jsonTable).values({ json: { name: 'Tom', age: 75 }, jsonb: { name: 'Pete', age: 23 } });
-
-			const result = await db.select().from(jsonTable);
-
-			const justNames = await db.select({
-				name1: sql<string>`${jsonTable.json}->>'name'`.as('name1'),
-				name2: sql<string>`${jsonTable.jsonb}->>'name'`.as('name2'),
-			}).from(jsonTable);
-
-			expect(result).toStrictEqual([
-				{
-					json: { name: 'Tom', age: 75 },
-					jsonb: { name: 'Pete', age: 23 },
-				},
-			]);
-
-			expect(justNames).toStrictEqual([
-				{
-					name1: 'Tom',
-					name2: 'Pete',
-				},
-			]);
-		});
-
-		test('set json/jsonb fields with objects and retrieve with the ->> operator', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const obj = { string: 'test', number: 123 };
-			const { string: testString, number: testNumber } = obj;
-
-			await db.insert(jsonTestTable).values({
-				json: obj,
-				jsonb: obj,
-			});
-
-			const result = await db.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->>'string'`,
-				jsonNumberField: sql<string>`${jsonTestTable.json}->>'number'`,
-				jsonbStringField: sql<string>`${jsonTestTable.jsonb}->>'string'`,
-				jsonbNumberField: sql<string>`${jsonTestTable.jsonb}->>'number'`,
-			}).from(jsonTestTable);
-
-			expect(result).toStrictEqual([{
-				jsonStringField: testString,
-				jsonNumberField: String(testNumber),
-				jsonbStringField: testString,
-				jsonbNumberField: String(testNumber),
-			}]);
-		});
-
-		test('set json/jsonb fields with strings and retrieve with the ->> operator', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const obj = { string: 'test', number: 123 };
-			const { string: testString, number: testNumber } = obj;
-
-			await db.insert(jsonTestTable).values({
-				json: sql`${JSON.stringify(obj)}`,
-				jsonb: sql`${JSON.stringify(obj)}`,
-			});
-
-			const result = await db.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->>'string'`,
-				jsonNumberField: sql<string>`${jsonTestTable.json}->>'number'`,
-				jsonbStringField: sql<string>`${jsonTestTable.jsonb}->>'string'`,
-				jsonbNumberField: sql<string>`${jsonTestTable.jsonb}->>'number'`,
-			}).from(jsonTestTable);
-
-			expect(result).toStrictEqual([{
-				jsonStringField: testString,
-				jsonNumberField: String(testNumber),
-				jsonbStringField: testString,
-				jsonbNumberField: String(testNumber),
-			}]);
-		});
-
-		test('set json/jsonb fields with objects and retrieve with the -> operator', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const obj = { string: 'test', number: 123 };
-			const { string: testString, number: testNumber } = obj;
-
-			await db.insert(jsonTestTable).values({
-				json: obj,
-				jsonb: obj,
-			});
-
-			const result = await db.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
-				jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
-				jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
-				jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
-			}).from(jsonTestTable);
-
-			expect(result).toStrictEqual([{
-				jsonStringField: testString,
-				jsonNumberField: testNumber,
-				jsonbStringField: testString,
-				jsonbNumberField: testNumber,
-			}]);
-		});
-
-		test('set json/jsonb fields with strings and retrieve with the -> operator', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const obj = { string: 'test', number: 123 };
-			const { string: testString, number: testNumber } = obj;
-
-			await db.insert(jsonTestTable).values({
-				json: sql`${JSON.stringify(obj)}`,
-				jsonb: sql`${JSON.stringify(obj)}`,
-			});
-
-			const result = await db.select({
-				jsonStringField: sql<string>`${jsonTestTable.json}->'string'`,
-				jsonNumberField: sql<number>`${jsonTestTable.json}->'number'`,
-				jsonbStringField: sql<string>`${jsonTestTable.jsonb}->'string'`,
-				jsonbNumberField: sql<number>`${jsonTestTable.jsonb}->'number'`,
-			}).from(jsonTestTable);
-
-			expect(result).toStrictEqual([{
-				jsonStringField: testString,
-				jsonNumberField: testNumber,
-				jsonbStringField: testString,
-				jsonbNumberField: testNumber,
-			}]);
-		});
-
-		test('update ... from', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(cities2Table).values([
-				{ name: 'New York City' },
-				{ name: 'Seattle' },
-			]);
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-			]);
-
-			const result = await db
-				.update(users2Table)
-				.set({
-					cityId: cities2Table.id,
-				})
-				.from(cities2Table)
-				.where(and(eq(cities2Table.name, 'Seattle'), eq(users2Table.name, 'John')))
-				.returning();
-
-			expect(result).toStrictEqual([{
-				id: 1,
-				name: 'John',
-				cityId: 2,
-				cities: {
-					id: 2,
-					name: 'Seattle',
-				},
-			}]);
-		});
-
-		test('update ... from with alias', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.insert(cities2Table).values([
-				{ name: 'New York City' },
-				{ name: 'Seattle' },
-			]);
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-			]);
-
-			const users = alias(users2Table, 'u');
-			const cities = alias(cities2Table, 'c');
-			const result = await db
-				.update(users)
-				.set({
-					cityId: cities.id,
-				})
-				.from(cities)
-				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
-				.returning();
-
-			expect(result).toStrictEqual([{
-				id: 1,
-				name: 'John',
-				cityId: 2,
-				c: {
-					id: 2,
-					name: 'Seattle',
-				},
-			}]);
-		});
-
-		test('update ... from with join', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const states = pgTable('states', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-			const cities = pgTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				stateId: integer('state_id').references(() => states.id),
-			});
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: integer('city_id').notNull().references(() => cities.id),
-			});
-
-			await db.execute(sql`drop table if exists "states" cascade`);
-			await db.execute(sql`drop table if exists "cities" cascade`);
-			await db.execute(sql`drop table if exists "users" cascade`);
-			await db.execute(sql`
-				create table "states" (
-					"id" serial primary key,
-					"name" text not null
-				)
-			`);
-			await db.execute(sql`
-				create table "cities" (
-					"id" serial primary key,
-					"name" text not null,
-					"state_id" integer references "states"("id")
-				)
-			`);
-			await db.execute(sql`
-				create table "users" (
-					"id" serial primary key,
-					"name" text not null,
-					"city_id" integer not null references "cities"("id")
-				)
-			`);
-
-			await db.insert(states).values([
-				{ name: 'New York' },
-				{ name: 'Washington' },
-			]);
-			await db.insert(cities).values([
-				{ name: 'New York City', stateId: 1 },
-				{ name: 'Seattle', stateId: 2 },
-				{ name: 'London' },
-			]);
-			await db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 3 },
-			]);
-
-			const result1 = await db
-				.update(users)
-				.set({
-					cityId: cities.id,
-				})
-				.from(cities)
-				.leftJoin(states, eq(cities.stateId, states.id))
-				.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
-				.returning();
-			const result2 = await db
-				.update(users)
-				.set({
-					cityId: cities.id,
-				})
-				.from(cities)
-				.leftJoin(states, eq(cities.stateId, states.id))
-				.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
-				.returning();
-
-			expect(result1).toStrictEqual([{
-				id: 1,
-				name: 'John',
-				cityId: 2,
-				cities: {
-					id: 2,
-					name: 'Seattle',
-					stateId: 2,
-				},
-				states: {
-					id: 2,
-					name: 'Washington',
-				},
-			}]);
-			expect(result2).toStrictEqual([{
-				id: 3,
-				name: 'Jack',
-				cityId: 3,
-				cities: {
-					id: 3,
-					name: 'London',
-					stateId: null,
-				},
-				states: null,
-			}]);
-		});
-
-		test('insert into ... select', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const notifications = pgTable('notifications', {
-				id: serial('id').primaryKey(),
-				sentAt: timestamp('sent_at').notNull().defaultNow(),
-				message: text('message').notNull(),
-			});
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-			const userNotications = pgTable('user_notifications', {
-				userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
-				notificationId: integer('notification_id').notNull().references(() => notifications.id, {
-					onDelete: 'cascade',
-				}),
-			}, (t) => ({
-				pk: primaryKey({ columns: [t.userId, t.notificationId] }),
-			}));
-
-			await db.execute(sql`drop table if exists notifications`);
-			await db.execute(sql`drop table if exists users`);
-			await db.execute(sql`drop table if exists user_notifications`);
-			await db.execute(sql`
-				create table notifications (
-					id serial primary key,
-					sent_at timestamp not null default now(),
-					message text not null
-				)
-			`);
-			await db.execute(sql`
-				create table users (
-					id serial primary key,
-					name text not null
-				)
-			`);
-			await db.execute(sql`
-				create table user_notifications (
-					user_id int references users(id) on delete cascade,
-					notification_id int references notifications(id) on delete cascade,
-					primary key (user_id, notification_id)
-				)
-			`);
-
-			const newNotification = await db
-				.insert(notifications)
-				.values({ message: 'You are one of the 3 lucky winners!' })
-				.returning({ id: notifications.id })
-				.then((result) => result[0]);
-			await db.insert(users).values([
-				{ name: 'Alice' },
-				{ name: 'Bob' },
-				{ name: 'Charlie' },
-				{ name: 'David' },
-				{ name: 'Eve' },
-			]);
-
-			const sentNotifications = await db
-				.insert(userNotications)
-				.select(
-					db
-						.select({
-							userId: users.id,
-							notificationId: sql`${newNotification!.id}`.as('notification_id'),
-						})
-						.from(users)
-						.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
-						.orderBy(asc(users.id)),
-				)
-				.returning();
-
-			expect(sentNotifications).toStrictEqual([
-				{ userId: 1, notificationId: newNotification!.id },
-				{ userId: 3, notificationId: newNotification!.id },
-				{ userId: 5, notificationId: newNotification!.id },
-			]);
-		});
-
-		test('insert into ... select with keys in different order', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users1 = pgTable('users1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-			const users2 = pgTable('users2', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists users1`);
-			await db.execute(sql`drop table if exists users2`);
-			await db.execute(sql`
-				create table users1 (
-					id serial primary key,
-					name text not null
-				)
-			`);
-			await db.execute(sql`
-				create table users2 (
-					id serial primary key,
-					name text not null
-				)
-			`);
-
-			expect(
-				() =>
-					db
-						.insert(users1)
-						.select(
-							db
-								.select({
-									name: users2.name,
-									id: users2.id,
-								})
-								.from(users2),
-						),
-			).toThrowError();
-		});
-
-		test('policy', () => {
-			{
-				const policy = pgPolicy('test policy');
-
-				expect(is(policy, PgPolicy)).toBe(true);
-				expect(policy.name).toBe('test policy');
-			}
-
-			{
-				const policy = pgPolicy('test policy', {
-					as: 'permissive',
-					for: 'all',
-					to: 'public',
-					using: sql`1=1`,
-					withCheck: sql`1=1`,
-				});
-
-				expect(is(policy, PgPolicy)).toBe(true);
-				expect(policy.name).toBe('test policy');
-				expect(policy.as).toBe('permissive');
-				expect(policy.for).toBe('all');
-				expect(policy.to).toBe('public');
-				const dialect = new PgDialect();
-				expect(is(policy.using, SQL)).toBe(true);
-				expect(dialect.sqlToQuery(policy.using!).sql).toBe('1=1');
-				expect(is(policy.withCheck, SQL)).toBe(true);
-				expect(dialect.sqlToQuery(policy.withCheck!).sql).toBe('1=1');
-			}
-
-			{
-				const policy = pgPolicy('test policy', {
-					to: 'custom value',
-				});
-
-				expect(policy.to).toBe('custom value');
-			}
-
-			{
-				const p1 = pgPolicy('test policy');
-				const p2 = pgPolicy('test policy 2', {
-					as: 'permissive',
-					for: 'all',
-					to: 'public',
-					using: sql`1=1`,
-					withCheck: sql`1=1`,
-				});
-				const table = pgTable('table_with_policy', {
-					id: serial('id').primaryKey(),
-					name: text('name').notNull(),
-				}, () => ({
-					p1,
-					p2,
-				}));
-				const config = getTableConfig(table);
-				expect(config.policies).toHaveLength(2);
-				expect(config.policies[0]).toBe(p1);
-				expect(config.policies[1]).toBe(p2);
-			}
-		});
-
-		test('neon: policy', () => {
-			{
-				const policy = crudPolicy({
-					read: true,
-					modify: true,
-					role: authenticatedRole,
-				});
-
-				for (const it of Object.values(policy)) {
-					expect(is(it, PgPolicy)).toBe(true);
-					expect(it?.to).toStrictEqual(authenticatedRole);
-					it?.using ? expect(it.using).toStrictEqual(sql`true`) : '';
-					it?.withCheck ? expect(it.withCheck).toStrictEqual(sql`true`) : '';
-				}
-			}
-
-			{
-				const table = pgTable('name', {
-					id: integer('id'),
-				}, (t) => [
-					index('name').on(t.id),
-					crudPolicy({
-						read: true,
-						modify: true,
-						role: authenticatedRole,
-					}),
-					primaryKey({ columns: [t.id], name: 'custom' }),
-				]);
-
-				const { policies, indexes, primaryKeys } = getTableConfig(table);
-
-				expect(policies.length).toBe(4);
-				expect(indexes.length).toBe(1);
-				expect(primaryKeys.length).toBe(1);
-
-				expect(policies[0]?.name === 'crud-custom-policy-modify');
-				expect(policies[1]?.name === 'crud-custom-policy-read');
-			}
-		});
-
-		test('neon: neon_auth', () => {
-			const usersSyncTable = usersSync;
-
-			const { columns, schema, name } = getTableConfig(usersSyncTable);
-
-			expect(name).toBe('users_sync');
-			expect(schema).toBe('neon_auth');
-			expect(columns).toHaveLength(6);
-		});
-
-		test('Enable RLS function', () => {
-			const usersWithRLS = pgTable('users', {
-				id: integer(),
-			}).enableRLS();
-
-			const config1 = getTableConfig(usersWithRLS);
-
-			const usersNoRLS = pgTable('users', {
-				id: integer(),
-			});
-
-			const config2 = getTableConfig(usersNoRLS);
-
-			expect(config1.enableRLS).toBeTruthy();
-			expect(config2.enableRLS).toBeFalsy();
-		});
-
-		test('$count separate', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.$count(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual(4);
-		});
-
-		test('$count embedded', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual([
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-			]);
-		});
-
-		test('$count separate reuse', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = db.$count(countTestTable);
-
-			const count1 = await count;
-
-			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
-
-			const count2 = await count;
-
-			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
-
-			const count3 = await count;
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count1).toStrictEqual(4);
-			expect(count2).toStrictEqual(5);
-			expect(count3).toStrictEqual(6);
-		});
-
-		test('$count embedded reuse', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
-
-			const count1 = await count;
-
-			await db.insert(countTestTable).values({ id: 5, name: 'fifth' });
-
-			const count2 = await count;
-
-			await db.insert(countTestTable).values({ id: 6, name: 'sixth' });
-
-			const count3 = await count;
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count1).toStrictEqual([
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-				{ count: 4 },
-			]);
-			expect(count2).toStrictEqual([
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-				{ count: 5 },
-			]);
-			expect(count3).toStrictEqual([
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-				{ count: 6 },
-			]);
-		});
-
-		test('$count separate with filters', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.$count(countTestTable, gt(countTestTable.id, 1));
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual(3);
-		});
-
-		test('$count embedded with filters', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const countTestTable = pgTable('count_test', {
-				id: integer('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${countTestTable}`);
-			await db.execute(sql`create table ${countTestTable} (id int, name text)`);
-
-			await db.insert(countTestTable).values([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-				{ id: 3, name: 'Third' },
-				{ id: 4, name: 'Fourth' },
-			]);
-
-			const count = await db.select({
-				count: db.$count(countTestTable, gt(countTestTable.id, 1)),
-			}).from(countTestTable);
-
-			await db.execute(sql`drop table ${countTestTable}`);
-
-			expect(count).toStrictEqual([
-				{ count: 3 },
-				{ count: 3 },
-				{ count: 3 },
-				{ count: 3 },
-			]);
-		});
-
-		test('insert multiple rows into table with generated identity column', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const identityColumnsTable = pgTable('identity_columns_table', {
-				id: integer('id').generatedAlwaysAsIdentity(),
-				id1: integer('id1').generatedByDefaultAsIdentity(),
-				name: text('name').notNull(),
-			});
-
-			// not passing identity columns
-			await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-			await db.execute(
-				sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-			);
-
-			let result = await db.insert(identityColumnsTable).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-				{ name: 'Bob' },
-			]).returning();
-
-			expect(result).toEqual([
-				{ id: 1, id1: 1, name: 'John' },
-				{ id: 2, id1: 2, name: 'Jane' },
-				{ id: 3, id1: 3, name: 'Bob' },
-			]);
-
-			// passing generated by default as identity column
-			await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-			await db.execute(
-				sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-			);
-
-			result = await db.insert(identityColumnsTable).values([
-				{ name: 'John', id1: 3 },
-				{ name: 'Jane', id1: 5 },
-				{ name: 'Bob', id1: 5 },
-			]).returning();
-
-			expect(result).toEqual([
-				{ id: 1, id1: 3, name: 'John' },
-				{ id: 2, id1: 5, name: 'Jane' },
-				{ id: 3, id1: 5, name: 'Bob' },
-			]);
-
-			// passing all identity columns
-			await db.execute(sql`drop table if exists ${identityColumnsTable}`);
-			await db.execute(
-				sql`create table ${identityColumnsTable} ("id" integer generated always as identity, "id1" integer generated by default as identity, "name" text)`,
-			);
-
-			result = await db.insert(identityColumnsTable).overridingSystemValue().values([
-				{ name: 'John', id: 2, id1: 3 },
-				{ name: 'Jane', id: 4, id1: 5 },
-				{ name: 'Bob', id: 4, id1: 5 },
-			]).returning();
-
-			expect(result).toEqual([
-				{ id: 2, id1: 3, name: 'John' },
-				{ id: 4, id1: 5, name: 'Jane' },
-				{ id: 4, id1: 5, name: 'Bob' },
-			]);
-		});
-
-		test('insert as cte', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
-
-			const sq1 = db.$with('sq').as(
-				db.insert(users).values({ name: 'John' }).returning(),
-			);
-			const result1 = await db.with(sq1).select().from(sq1);
-			const result2 = await db.with(sq1).select({ id: sq1.id }).from(sq1);
-
-			const sq2 = db.$with('sq').as(
-				db.insert(users).values({ name: 'Jane' }).returning({ id: users.id, name: users.name }),
-			);
-			const result3 = await db.with(sq2).select().from(sq2);
-			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
-
-			expect(result1).toEqual([{ id: 1, name: 'John' }]);
-			expect(result2).toEqual([{ id: 2 }]);
-			expect(result3).toEqual([{ id: 3, name: 'Jane' }]);
-			expect(result4).toEqual([{ name: 'Jane' }]);
-		});
-
-		test('update as cte', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				age: integer('age').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, age integer not null)`,
-			);
-
-			await db.insert(users).values([
-				{ name: 'John', age: 30 },
-				{ name: 'Jane', age: 30 },
-			]);
-
-			const sq1 = db.$with('sq').as(
-				db.update(users).set({ age: 25 }).where(eq(users.name, 'John')).returning(),
-			);
-			const result1 = await db.with(sq1).select().from(sq1);
-			await db.update(users).set({ age: 30 });
-			const result2 = await db.with(sq1).select({ age: sq1.age }).from(sq1);
-
-			const sq2 = db.$with('sq').as(
-				db.update(users).set({ age: 20 }).where(eq(users.name, 'Jane')).returning({ name: users.name, age: users.age }),
-			);
-			const result3 = await db.with(sq2).select().from(sq2);
-			await db.update(users).set({ age: 30 });
-			const result4 = await db.with(sq2).select({ age: sq2.age }).from(sq2);
-
-			expect(result1).toEqual([{ id: 1, name: 'John', age: 25 }]);
-			expect(result2).toEqual([{ age: 25 }]);
-			expect(result3).toEqual([{ name: 'Jane', age: 20 }]);
-			expect(result4).toEqual([{ age: 20 }]);
-		});
-
-		test('delete as cte', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
-
-			await db.insert(users).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-			]);
-
-			const sq1 = db.$with('sq').as(
-				db.delete(users).where(eq(users.name, 'John')).returning(),
-			);
-			const result1 = await db.with(sq1).select().from(sq1);
-			await db.insert(users).values({ name: 'John' });
-			const result2 = await db.with(sq1).select({ name: sq1.name }).from(sq1);
-
-			const sq2 = db.$with('sq').as(
-				db.delete(users).where(eq(users.name, 'Jane')).returning({ id: users.id, name: users.name }),
-			);
-			const result3 = await db.with(sq2).select().from(sq2);
-			await db.insert(users).values({ name: 'Jane' });
-			const result4 = await db.with(sq2).select({ name: sq2.name }).from(sq2);
-
-			expect(result1).toEqual([{ id: 1, name: 'John' }]);
-			expect(result2).toEqual([{ name: 'John' }]);
-			expect(result3).toEqual([{ id: 2, name: 'Jane' }]);
-			expect(result4).toEqual([{ name: 'Jane' }]);
-		});
-
-		test('sql operator as cte', async (ctx) => {
-			const { db } = ctx.pg;
-
-			const users = pgTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
-			await db.insert(users).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-			]);
-
-			const sq1 = db.$with('sq', {
-				userId: users.id,
-				data: {
-					name: users.name,
-				},
-			}).as(sql`select * from ${users} where ${users.name} = 'John'`);
-			const result1 = await db.with(sq1).select().from(sq1);
-
-			const sq2 = db.$with('sq', {
-				userId: users.id,
-				data: {
-					name: users.name,
-				},
-			}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
-			const result2 = await db.with(sq2).select().from(sq1);
-
-			expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
-			expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
-		});
-
-		test('cross join', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-
-			await db
-				.insert(citiesTable)
-				.values([
-					{ name: 'Seattle' },
-					{ name: 'New York City' },
-				]);
-
-			const result = await db
-				.select({
-					user: usersTable.name,
-					city: citiesTable.name,
-				})
-				.from(usersTable)
-				.crossJoin(citiesTable)
-				.orderBy(usersTable.name, citiesTable.name);
-
-			expect(result).toStrictEqual([
-				{ city: 'New York City', user: 'Jane' },
-				{ city: 'Seattle', user: 'Jane' },
-				{ city: 'New York City', user: 'John' },
-				{ city: 'Seattle', user: 'John' },
-			]);
-		});
-
-		test('left join (lateral)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.leftJoinLateral(sq, sql`true`);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-				{ cityId: 2, cityName: 'London', userId: null, userName: null },
-			]);
-		});
-
-		test('inner join (lateral)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.innerJoinLateral(sq, sql`true`);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-			]);
-		});
-
-		test('cross join (lateral)', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }, { id: 3, name: 'Berlin' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }, {
-				name: 'Patrick',
-				cityId: 2,
-			}]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(not(like(citiesTable.name, 'L%')))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.crossJoinLateral(sq)
-				.orderBy(citiesTable.id, sq.userId);
-
-			expect(res).toStrictEqual([
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 1,
-					userName: 'John',
-				},
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 2,
-					userName: 'Jane',
-				},
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 3,
-					userName: 'Patrick',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 1,
-					userName: 'John',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 2,
-					userName: 'Jane',
-				},
-				{
-					cityId: 3,
-					cityName: 'Berlin',
-					userId: 3,
-					userName: 'Patrick',
-				},
-			]);
-		});
-
-		test('all types', async (ctx) => {
-			const { db } = ctx.pg;
-
-			await db.execute(sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`);
-			await db.execute(sql`
-				CREATE TABLE "all_types" (
-					"serial" serial NOT NULL,
-					"bigserial53" bigserial NOT NULL,
-					"bigserial64" bigserial,
-					"int" integer,
-					"bigint53" bigint,
-					"bigint64" bigint,
-					"bool" boolean,
-					"char" char,
-					"cidr" "cidr",
-					"date" date,
-					"date_str" date,
-					"double" double precision,
-					"enum" "en",
-					"inet" "inet",
-					"interval" interval,
-					"json" json,
-					"jsonb" jsonb,
-					"line" "line",
-					"line_tuple" "line",
-					"macaddr" "macaddr",
-					"macaddr8" "macaddr8",
-					"numeric" numeric,
-					"numeric_num" numeric,
-					"numeric_big" numeric,
-					"point" "point",
-					"point_tuple" "point",
-					"real" real,
-					"smallint" smallint,
-					"smallserial" "smallserial" NOT NULL,
-					"text" text,
-					"time" time,
-					"timestamp" timestamp,
-					"timestamp_tz" timestamp with time zone,
-					"timestamp_str" timestamp,
-					"timestamp_tz_str" timestamp with time zone,
-					"uuid" uuid,
-					"varchar" varchar,
-					"arrint" integer[],
-					"arrbigint53" bigint[],
-					"arrbigint64" bigint[],
-					"arrbool" boolean[],
-					"arrchar" char[],
-					"arrcidr" "cidr"[],
-					"arrdate" date[],
-					"arrdate_str" date[],
-					"arrdouble" double precision[],
-					"arrenum" "en"[],
-					"arrinet" "inet"[],
-					"arrinterval" interval[],
-					"arrjson" json[],
-					"arrjsonb" jsonb[],
-					"arrline" "line"[],
-					"arrline_tuple" "line"[],
-					"arrmacaddr" "macaddr"[],
-					"arrmacaddr8" "macaddr8"[],
-					"arrnumeric" numeric[],
-					"arrnumeric_num" numeric[],
-					"arrnumeric_big" numeric[],
-					"arrpoint" "point"[],
-					"arrpoint_tuple" "point"[],
-					"arrreal" real[],
-					"arrsmallint" smallint[],
-					"arrtext" text[],
-					"arrtime" time[],
-					"arrtimestamp" timestamp[],
-					"arrtimestamp_tz" timestamp with time zone[],
-					"arrtimestamp_str" timestamp[],
-					"arrtimestamp_tz_str" timestamp with time zone[],
-					"arruuid" uuid[],
-					"arrvarchar" varchar[]
-				);
-			`);
-
-			await db.insert(allTypesTable).values({
-				serial: 1,
-				smallserial: 15,
-				bigint53: 9007199254740991,
-				bigint64: 5044565289845416380n,
-				bigserial53: 9007199254740991,
-				bigserial64: 5044565289845416380n,
-				bool: true,
-				char: 'c',
-				cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
-				inet: '192.168.0.1/24',
-				macaddr: '08:00:2b:01:02:03',
-				macaddr8: '08:00:2b:01:02:03:04:05',
-				date: new Date(1741743161623),
-				dateStr: new Date(1741743161623).toISOString(),
-				double: 15.35325689124218,
-				enum: 'enVal1',
-				int: 621,
-				interval: '2 months ago',
-				json: {
-					str: 'strval',
-					arr: ['str', 10],
-				},
-				jsonb: {
-					str: 'strvalb',
-					arr: ['strb', 11],
-				},
-				line: {
-					a: 1,
-					b: 2,
-					c: 3,
-				},
-				lineTuple: [1, 2, 3],
-				numeric: '475452353476',
-				numericNum: 9007199254740991,
-				numericBig: 5044565289845416380n,
-				point: {
-					x: 24.5,
-					y: 49.6,
-				},
-				pointTuple: [57.2, 94.3],
-				real: 1.048596,
-				smallint: 10,
-				text: 'TEXT STRING',
-				time: '13:59:28',
-				timestamp: new Date(1741743161623),
-				timestampTz: new Date(1741743161623),
-				timestampStr: new Date(1741743161623).toISOString(),
-				timestampTzStr: new Date(1741743161623).toISOString(),
-				uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
-				varchar: 'C4-',
-				arrbigint53: [9007199254740991],
-				arrbigint64: [5044565289845416380n],
-				arrbool: [true],
-				arrchar: ['c'],
-				arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
-				arrinet: ['192.168.0.1/24'],
-				arrmacaddr: ['08:00:2b:01:02:03'],
-				arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
-				arrdate: [new Date(1741743161623)],
-				arrdateStr: [new Date(1741743161623).toISOString()],
-				arrdouble: [15.35325689124218],
-				arrenum: ['enVal1'],
-				arrint: [621],
-				arrinterval: ['2 months ago'],
-				arrjson: [{
-					str: 'strval',
-					arr: ['str', 10],
-				}],
-				arrjsonb: [{
-					str: 'strvalb',
-					arr: ['strb', 11],
-				}],
-				arrline: [{
-					a: 1,
-					b: 2,
-					c: 3,
-				}],
-				arrlineTuple: [[1, 2, 3]],
-				arrnumeric: ['475452353476'],
-				arrnumericNum: [9007199254740991],
-				arrnumericBig: [5044565289845416380n],
-				arrpoint: [{
-					x: 24.5,
-					y: 49.6,
-				}],
-				arrpointTuple: [[57.2, 94.3]],
-				arrreal: [1.048596],
-				arrsmallint: [10],
-				arrtext: ['TEXT STRING'],
-				arrtime: ['13:59:28'],
-				arrtimestamp: [new Date(1741743161623)],
-				arrtimestampTz: [new Date(1741743161623)],
-				arrtimestampStr: [new Date(1741743161623).toISOString()],
-				arrtimestampTzStr: [new Date(1741743161623).toISOString()],
-				arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
-				arrvarchar: ['C4-'],
-			});
-
-			const rawRes = await db.select().from(allTypesTable);
-
-			type ExpectedType = {
-				serial: number;
-				bigserial53: number;
-				bigserial64: bigint;
-				int: number | null;
-				bigint53: number | null;
-				bigint64: bigint | null;
-				bool: boolean | null;
-				char: string | null;
-				cidr: string | null;
-				date: Date | null;
-				dateStr: string | null;
-				double: number | null;
-				enum: 'enVal1' | 'enVal2' | null;
-				inet: string | null;
-				interval: string | null;
-				json: unknown;
-				jsonb: unknown;
-				line: {
-					a: number;
-					b: number;
-					c: number;
-				} | null;
-				lineTuple: [number, number, number] | null;
-				macaddr: string | null;
-				macaddr8: string | null;
-				numeric: string | null;
-				numericNum: number | null;
-				numericBig: bigint | null;
-				point: {
-					x: number;
-					y: number;
-				} | null;
-				pointTuple: [number, number] | null;
-				real: number | null;
-				smallint: number | null;
-				smallserial: number;
-				text: string | null;
-				time: string | null;
-				timestamp: Date | null;
-				timestampTz: Date | null;
-				timestampStr: string | null;
-				timestampTzStr: string | null;
-				uuid: string | null;
-				varchar: string | null;
-				arrint: number[] | null;
-				arrbigint53: number[] | null;
-				arrbigint64: bigint[] | null;
-				arrbool: boolean[] | null;
-				arrchar: string[] | null;
-				arrcidr: string[] | null;
-				arrdate: Date[] | null;
-				arrdateStr: string[] | null;
-				arrdouble: number[] | null;
-				arrenum: ('enVal1' | 'enVal2')[] | null;
-				arrinet: string[] | null;
-				arrinterval: string[] | null;
-				arrjson: unknown[] | null;
-				arrjsonb: unknown[] | null;
-				arrline: {
-					a: number;
-					b: number;
-					c: number;
-				}[] | null;
-				arrlineTuple: [number, number, number][] | null;
-				arrmacaddr: string[] | null;
-				arrmacaddr8: string[] | null;
-				arrnumeric: string[] | null;
-				arrnumericNum: number[] | null;
-				arrnumericBig: bigint[] | null;
-				arrpoint: { x: number; y: number }[] | null;
-				arrpointTuple: [number, number][] | null;
-				arrreal: number[] | null;
-				arrsmallint: number[] | null;
-				arrtext: string[] | null;
-				arrtime: string[] | null;
-				arrtimestamp: Date[] | null;
-				arrtimestampTz: Date[] | null;
-				arrtimestampStr: string[] | null;
-				arrtimestampTzStr: string[] | null;
-				arruuid: string[] | null;
-				arrvarchar: string[] | null;
-			}[];
-
-			const expectedRes: ExpectedType = [
-				{
-					serial: 1,
-					bigserial53: 9007199254740991,
-					bigserial64: 5044565289845416380n,
-					int: 621,
-					bigint53: 9007199254740991,
-					bigint64: 5044565289845416380n,
-					bool: true,
-					char: 'c',
-					cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
-					date: new Date('2025-03-12T00:00:00.000Z'),
-					dateStr: '2025-03-12',
-					double: 15.35325689124218,
-					enum: 'enVal1',
-					inet: '192.168.0.1/24',
-					interval: '-2 mons',
-					json: { str: 'strval', arr: ['str', 10] },
-					jsonb: { arr: ['strb', 11], str: 'strvalb' },
-					line: { a: 1, b: 2, c: 3 },
-					lineTuple: [1, 2, 3],
-					macaddr: '08:00:2b:01:02:03',
-					macaddr8: '08:00:2b:01:02:03:04:05',
-					numeric: '475452353476',
-					numericNum: 9007199254740991,
-					numericBig: 5044565289845416380n,
-					point: { x: 24.5, y: 49.6 },
-					pointTuple: [57.2, 94.3],
-					real: 1.048596,
-					smallint: 10,
-					smallserial: 15,
-					text: 'TEXT STRING',
-					time: '13:59:28',
-					timestamp: new Date('2025-03-12T01:32:41.623Z'),
-					timestampTz: new Date('2025-03-12T01:32:41.623Z'),
-					timestampStr: '2025-03-12 01:32:41.623',
-					timestampTzStr: '2025-03-12 01:32:41.623+00',
-					uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
-					varchar: 'C4-',
-					arrint: [621],
-					arrbigint53: [9007199254740991],
-					arrbigint64: [5044565289845416380n],
-					arrbool: [true],
-					arrchar: ['c'],
-					arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
-					arrdate: [new Date('2025-03-12T00:00:00.000Z')],
-					arrdateStr: ['2025-03-12'],
-					arrdouble: [15.35325689124218],
-					arrenum: ['enVal1'],
-					arrinet: ['192.168.0.1/24'],
-					arrinterval: ['-2 mons'],
-					arrjson: [{ str: 'strval', arr: ['str', 10] }],
-					arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
-					arrline: [{ a: 1, b: 2, c: 3 }],
-					arrlineTuple: [[1, 2, 3]],
-					arrmacaddr: ['08:00:2b:01:02:03'],
-					arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
-					arrnumeric: ['475452353476'],
-					arrnumericNum: [9007199254740991],
-					arrnumericBig: [5044565289845416380n],
-					arrpoint: [{ x: 24.5, y: 49.6 }],
-					arrpointTuple: [[57.2, 94.3]],
-					arrreal: [1.048596],
-					arrsmallint: [10],
-					arrtext: ['TEXT STRING'],
-					arrtime: ['13:59:28'],
-					arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
-					arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
-					arrtimestampStr: ['2025-03-12 01:32:41.623'],
-					arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
-					arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
-					arrvarchar: ['C4-'],
-				},
-			];
-
-			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
-			expect(rawRes).toStrictEqual(expectedRes);
-		});
-	});
-}
diff --git a/integration-tests/tests/pg/pg-custom.test.ts b/integration-tests/tests/pg/pg-custom.test.ts
index 9ba4fe0cc0..8de9e98e39 100644
--- a/integration-tests/tests/pg/pg-custom.test.ts
+++ b/integration-tests/tests/pg/pg-custom.test.ts
@@ -1,71 +1,26 @@
-import retry from 'async-retry';
-import type Docker from 'dockerode';
 import { asc, eq, sql } from 'drizzle-orm';
-import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { drizzle } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
 import { alias, customType, pgTable, pgTableCreator, serial, text } from 'drizzle-orm/pg-core';
-import { Client } from 'pg';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
-import { createDockerDB } from './pg-common';
-
-const ENABLE_LOGGING = false;
-
-let db: NodePgDatabase;
-let client: Client;
-let container: Docker.Container | undefined;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['PG_CONNECTION_STRING']) {
-		connectionString = process.env['PG_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
-	client = await retry(async () => {
-		client = new Client(connectionString);
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end();
-	await container?.stop().catch(console.error);
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-});
+import { nodePostgresTest as test } from './instrumentation';
 
 const customSerial = customType<{ data: number; notNull: true; default: true }>({
+	codec: 'serial',
 	dataType() {
 		return 'serial';
 	},
 });
 
 const customText = customType<{ data: string }>({
+	codec: 'text',
 	dataType() {
 		return 'text';
 	},
 });
 
 const customBoolean = customType<{ data: boolean }>({
+	codec: 'boolean',
 	dataType() {
 		return 'boolean';
 	},
@@ -73,17 +28,16 @@ const customBoolean = customType<{ data: boolean }>({
 
 const customJsonb = <TData>(name: string) =>
 	customType<{ data: TData; driverData: string }>({
+		codec: 'jsonb',
 		dataType() {
 			return 'jsonb';
 		},
-		toDriver(value: TData): string {
-			return JSON.stringify(value);
-		},
 	})(name);
 
 const customTimestamp = customType<
 	{ data: Date; driverData: string; config: { withTimezone: boolean; precision?: number } }
 >({
+	codec: (config) => `timestamp${config?.withTimezone ? 'tz' : ''}`,
 	dataType(config) {
 		const precision = config?.precision === undefined ? '' : ` (${config.precision})`;
 		return `timestamp${precision}${config?.withTimezone ? ' with time zone' : ''}`;
@@ -107,8 +61,7 @@ const usersMigratorTable = pgTable('users12', {
 	email: text('email').notNull(),
 });
 
-beforeEach(async (ctx) => {
-	const { db } = ctx.pg;
+test.beforeEach(async ({ db }) => {
 	await db.execute(sql`drop schema if exists public cascade`);
 	await db.execute(sql`create schema public`);
 	await db.execute(
@@ -124,9 +77,7 @@ beforeEach(async (ctx) => {
 	);
 });
 
-test('select all fields', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select all fields', async ({ db }) => {
 	const now = Date.now();
 
 	await db.insert(usersTable).values({ name: 'John' });
@@ -137,9 +88,7 @@ test('select all fields', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
 });
 
-test('select sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.select({
 		name: sql`upper(${usersTable.name})`,
@@ -148,9 +97,7 @@ test('select sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('select typed sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select typed sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.select({
 		name: sql<string>`upper(${usersTable.name})`,
@@ -159,9 +106,7 @@ test('select typed sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('insert returning sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert returning sql', async ({ db }) => {
 	const users = await db.insert(usersTable).values({ name: 'John' }).returning({
 		name: sql`upper(${usersTable.name})`,
 	});
@@ -169,9 +114,7 @@ test('insert returning sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('delete returning sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('delete returning sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
 		name: sql`upper(${usersTable.name})`,
@@ -180,9 +123,7 @@ test('delete returning sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JOHN' }]);
 });
 
-test('update returning sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('update returning sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
 		name: sql`upper(${usersTable.name})`,
@@ -191,9 +132,7 @@ test('update returning sql', async (ctx) => {
 	expect(users).toEqual([{ name: 'JANE' }]);
 });
 
-test('update with returning all fields', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('update with returning all fields', async ({ db }) => {
 	const now = Date.now();
 
 	await db.insert(usersTable).values({ name: 'John' });
@@ -204,9 +143,7 @@ test('update with returning all fields', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
 });
 
-test('update with returning partial', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('update with returning partial', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
 		id: usersTable.id,
@@ -216,9 +153,7 @@ test('update with returning partial', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'Jane' }]);
 });
 
-test('delete with returning all fields', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('delete with returning all fields', async ({ db }) => {
 	const now = Date.now();
 
 	await db.insert(usersTable).values({ name: 'John' });
@@ -229,9 +164,7 @@ test('delete with returning all fields', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
 });
 
-test('delete with returning partial', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('delete with returning partial', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
 		id: usersTable.id,
@@ -241,9 +174,7 @@ test('delete with returning partial', async (ctx) => {
 	expect(users).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert + select', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert + select', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const result = await db.select().from(usersTable);
 	expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
@@ -256,9 +187,7 @@ test('insert + select', async (ctx) => {
 	]);
 });
 
-test('json insert', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('json insert', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
 	const result = await db.select({
 		id: usersTable.id,
@@ -269,18 +198,14 @@ test('json insert', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
 });
 
-test('insert with overridden default values', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert with overridden default values', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John', verified: true });
 	const result = await db.select().from(usersTable);
 
 	expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
 });
 
-test('insert many', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert many', async ({ db }) => {
 	await db.insert(usersTable).values([
 		{ name: 'John' },
 		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
@@ -302,9 +227,7 @@ test('insert many', async (ctx) => {
 	]);
 });
 
-test('insert many with returning', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert many with returning', async ({ db }) => {
 	const result = await db.insert(usersTable).values([
 		{ name: 'John' },
 		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
@@ -326,9 +249,7 @@ test('insert many with returning', async (ctx) => {
 	]);
 });
 
-test('select with group by as field', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select with group by as field', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -337,9 +258,7 @@ test('select with group by as field', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
 });
 
-test('select with group by as sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select with group by as sql', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -348,9 +267,7 @@ test('select with group by as sql', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
 });
 
-test('select with group by as sql + column', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select with group by as sql + column', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -359,9 +276,7 @@ test('select with group by as sql + column', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
 });
 
-test('select with group by as column + sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select with group by as column + sql', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -370,9 +285,7 @@ test('select with group by as column + sql', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
 });
 
-test('select with group by complex query', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('select with group by complex query', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 
 	const result = await db.select({ name: usersTable.name }).from(usersTable)
@@ -383,9 +296,7 @@ test('select with group by complex query', async (ctx) => {
 	expect(result).toEqual([{ name: 'Jane' }]);
 });
 
-test('build query', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('build query', async ({ db }) => {
 	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
 		.groupBy(usersTable.id, usersTable.name)
 		.toSQL();
@@ -396,16 +307,13 @@ test('build query', async (ctx) => {
 	});
 });
 
-test('insert sql', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert sql', async ({ db }) => {
 	await db.insert(usersTable).values({ name: sql`${'John'}` });
 	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('partial join with alias', async (ctx) => {
-	const { db } = ctx.pg;
+test('partial join with alias', async ({ db }) => {
 	const customerAlias = alias(usersTable, 'customer');
 
 	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
@@ -429,9 +337,7 @@ test('partial join with alias', async (ctx) => {
 	}]);
 });
 
-test('full join with alias', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('full join with alias', async ({ db }) => {
 	const pgTable = pgTableCreator((name) => `prefixed_${name}`);
 
 	const users = pgTable('users', {
@@ -464,18 +370,14 @@ test('full join with alias', async (ctx) => {
 	await db.execute(sql`drop table ${users}`);
 });
 
-test('insert with spaces', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert with spaces', async ({ db }) => {
 	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
 	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
 
 	expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
 });
 
-test('prepared statement', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('prepared statement', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const statement = db.select({
 		id: usersTable.id,
@@ -487,9 +389,7 @@ test('prepared statement', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('prepared statement reuse', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('prepared statement reuse', async ({ db }) => {
 	const stmt = db.insert(usersTable).values({
 		verified: true,
 		name: sql.placeholder('name'),
@@ -519,9 +419,7 @@ test('prepared statement reuse', async (ctx) => {
 	]);
 });
 
-test('prepared statement with placeholder in .where', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('prepared statement with placeholder in .where', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const stmt = db.select({
 		id: usersTable.id,
@@ -534,9 +432,7 @@ test('prepared statement with placeholder in .where', async (ctx) => {
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('prepared statement with placeholder in .limit', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('prepared statement with placeholder in .limit', async ({ db }) => {
 	await db.insert(usersTable).values({ name: 'John' });
 	const stmt = db
 		.select({
@@ -554,9 +450,7 @@ test('prepared statement with placeholder in .limit', async (ctx) => {
 	expect(result).toHaveLength(1);
 });
 
-test('prepared statement with placeholder in .offset', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('prepared statement with placeholder in .offset', async ({ db }) => {
 	await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
 	const stmt = db
 		.select({
@@ -572,7 +466,7 @@ test('prepared statement with placeholder in .offset', async (ctx) => {
 	expect(result).toEqual([{ id: 2, name: 'John1' }]);
 });
 
-test('migrator : default migration strategy', async () => {
+test('migrator : default migration strategy', async ({ db }) => {
 	await db.execute(sql`drop table if exists all_columns`);
 	await db.execute(sql`drop table if exists users12`);
 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
@@ -590,7 +484,7 @@ test('migrator : default migration strategy', async () => {
 	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
 });
 
-test('migrator : migrate with custom schema', async () => {
+test('migrator : migrate with custom schema', async ({ db }) => {
 	const customSchema = randomString();
 	await db.execute(sql`drop table if exists all_columns`);
 	await db.execute(sql`drop table if exists users12`);
@@ -612,7 +506,7 @@ test('migrator : migrate with custom schema', async () => {
 	await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.execute(sql`drop table if exists all_columns`);
 	await db.execute(sql`drop table if exists users12`);
@@ -634,7 +528,7 @@ test('migrator : migrate with custom table', async () => {
 	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
 });
 
-test('migrator : migrate with custom table and custom schema', async () => {
+test('migrator : migrate with custom table and custom schema', async ({ db }) => {
 	const customTable = randomString();
 	const customSchema = randomString();
 	await db.execute(sql`drop table if exists all_columns`);
@@ -663,14 +557,14 @@ test('migrator : migrate with custom table and custom schema', async () => {
 	await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
 });
 
-test('insert via db.execute + select via db.execute', async () => {
+test('insert via db.execute + select via db.execute', async ({ db }) => {
 	await db.execute(sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`);
 
 	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
 	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert via db.execute + returning', async () => {
+test('insert via db.execute + returning', async ({ db }) => {
 	const inserted = await db.execute<{ id: number; name: string }>(
 		sql`insert into ${usersTable} (${
 			sql.identifier(usersTable.name.name)
@@ -679,16 +573,14 @@ test('insert via db.execute + returning', async () => {
 	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert via db.execute w/ query builder', async () => {
+test('insert via db.execute w/ query builder', async ({ db }) => {
 	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
 		db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
 	);
 	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('build query insert with onConflict do update', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('build query insert with onConflict do update', async ({ db }) => {
 	const query = db.insert(usersTable)
 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
 		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
@@ -701,9 +593,7 @@ test('build query insert with onConflict do update', async (ctx) => {
 	});
 });
 
-test('build query insert with onConflict do update / multiple columns', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('build query insert with onConflict do update / multiple columns', async ({ db }) => {
 	const query = db.insert(usersTable)
 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
 		.onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
@@ -716,9 +606,7 @@ test('build query insert with onConflict do update / multiple columns', async (c
 	});
 });
 
-test('build query insert with onConflict do nothing', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('build query insert with onConflict do nothing', async ({ db }) => {
 	const query = db.insert(usersTable)
 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
 		.onConflictDoNothing()
@@ -731,9 +619,7 @@ test('build query insert with onConflict do nothing', async (ctx) => {
 	});
 });
 
-test('build query insert with onConflict do nothing + target', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('build query insert with onConflict do nothing + target', async ({ db }) => {
 	const query = db.insert(usersTable)
 		.values({ name: 'John', jsonb: ['foo', 'bar'] })
 		.onConflictDoNothing({ target: usersTable.id })
@@ -746,9 +632,7 @@ test('build query insert with onConflict do nothing + target', async (ctx) => {
 	});
 });
 
-test('insert with onConflict do update', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert with onConflict do update', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
@@ -763,9 +647,7 @@ test('insert with onConflict do update', async (ctx) => {
 	expect(res).toEqual([{ id: 1, name: 'John1' }]);
 });
 
-test('insert with onConflict do nothing', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert with onConflict do nothing', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
@@ -780,9 +662,7 @@ test('insert with onConflict do nothing', async (ctx) => {
 	expect(res).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert with onConflict do nothing + target', async (ctx) => {
-	const { db } = ctx.pg;
-
+test('insert with onConflict do nothing + target', async ({ db }) => {
 	await db.insert(usersTable)
 		.values({ name: 'John' });
 
diff --git a/integration-tests/tests/pg/pg-proxy.test.ts b/integration-tests/tests/pg/pg-proxy.test.ts
index 19aa41cb75..5edfa4dabd 100644
--- a/integration-tests/tests/pg/pg-proxy.test.ts
+++ b/integration-tests/tests/pg/pg-proxy.test.ts
@@ -1,144 +1,41 @@
-import retry from 'async-retry';
 import { sql } from 'drizzle-orm';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import type { PgRemoteDatabase } from 'drizzle-orm/pg-proxy';
-import { drizzle as proxyDrizzle } from 'drizzle-orm/pg-proxy';
+import { getTableConfig, integer, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
 import { migrate } from 'drizzle-orm/pg-proxy/migrator';
-import * as pg from 'pg';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
-import { createDockerDB, tests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-class ServerSimulator {
-	constructor(private db: pg.Client) {
-		const { types } = pg;
-
-		types.setTypeParser(types.builtins.TIMESTAMPTZ, (val) => val);
-		types.setTypeParser(types.builtins.TIMESTAMP, (val) => val);
-		types.setTypeParser(types.builtins.DATE, (val) => val);
-		types.setTypeParser(types.builtins.INTERVAL, (val) => val);
-		types.setTypeParser(1231, (val) => val);
-		types.setTypeParser(1115, (val) => val);
-		types.setTypeParser(1185, (val) => val);
-		types.setTypeParser(1187, (val) => val);
-		types.setTypeParser(1182, (val) => val);
-	}
-
-	async query(sql: string, params: any[], method: 'all' | 'execute') {
-		if (method === 'all') {
-			try {
-				const result = await this.db.query({
-					text: sql,
-					values: params,
-					rowMode: 'array',
-				});
-
-				return { data: result.rows as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else if (method === 'execute') {
-			try {
-				const result = await this.db.query({
-					text: sql,
-					values: params,
-				});
-
-				return { data: result.rows as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else {
-			return { error: 'Unknown method value' };
-		}
-	}
-
-	async migrations(queries: string[]) {
-		await this.db.query('BEGIN');
-		try {
-			for (const query of queries) {
-				await this.db.query(query);
-			}
-			await this.db.query('COMMIT');
-		} catch (e) {
-			await this.db.query('ROLLBACK');
-			throw e;
-		}
-
-		return {};
-	}
-}
-
-const ENABLE_LOGGING = false;
-
-let db: PgRemoteDatabase;
-let dbGlobalCached: PgRemoteDatabase;
-let cachedDb: PgRemoteDatabase;
-let client: pg.Client;
-let serverSimulator: ServerSimulator;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['PG_CONNECTION_STRING']) {
-		connectionString = process.env['PG_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = new pg.Client(connectionString);
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	serverSimulator = new ServerSimulator(client);
-	const proxyHandler = async (sql: string, params: any[], method: any) => {
-		try {
-			const response = await serverSimulator.query(sql, params, method);
-
-			if (response.error !== undefined) {
-				throw response.error;
-			}
-
-			return { rows: response.data };
-		} catch (e: any) {
-			console.error('Error from pg proxy server:', e.message);
-			throw e;
-		}
-	};
-	db = proxyDrizzle(proxyHandler, {
-		logger: ENABLE_LOGGING,
-	});
-
-	cachedDb = proxyDrizzle(proxyHandler, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = proxyDrizzle(proxyHandler, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { tests } from './common';
+import { proxyTest as test } from './instrumentation';
+import { usersMigratorTable, usersTable } from './schema';
+
+const skips = [
+	'RQB v2 transaction find first - no rows',
+	'RQB v2 transaction find first - multiple rows',
+	'RQB v2 transaction find first - with relation',
+	'RQB v2 transaction find first - placeholders',
+	'RQB v2 transaction find many - no rows',
+	'RQB v2 transaction find many - multiple rows',
+	'RQB v2 transaction find many - with relation',
+	'RQB v2 transaction find many - placeholders',
+];
+tests(test, skips);
+
+test.beforeEach(async ({ db }) => {
+	await db.execute(sql`drop schema if exists public cascade`);
+	await db.execute(sql`create schema public`);
+	await db.execute(
+		sql`
+			create table users (
+				id serial primary key,
+				name text not null,
+				verified boolean not null default false, 
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+	);
 });
 
-test('migrator : default migration strategy', async () => {
+test('migrator : default migration strategy', async ({ db, simulator }) => {
 	await db.execute(sql`drop table if exists all_columns`);
 	await db.execute(sql`drop table if exists users12`);
 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
@@ -146,7 +43,7 @@ test('migrator : default migration strategy', async () => {
 	// './drizzle2/pg-proxy/first' ??
 	await migrate(db, async (queries) => {
 		try {
-			await serverSimulator.migrations(queries);
+			await simulator.migrations(queries);
 		} catch (e) {
 			console.error(e);
 			throw new Error('Proxy server cannot run migrations');
@@ -164,7 +61,7 @@ test('migrator : default migration strategy', async () => {
 	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
 });
 
-test('all date and time columns without timezone first case mode string', async () => {
+test('all date and time columns without timezone first case mode string', async ({ db }) => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
 		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
@@ -200,7 +97,7 @@ test('all date and time columns without timezone first case mode string', async
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('all date and time columns without timezone second case mode string', async () => {
+test('all date and time columns without timezone second case mode string', async ({ db }) => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
 		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
@@ -231,7 +128,7 @@ test('all date and time columns without timezone second case mode string', async
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('all date and time columns without timezone third case mode date', async () => {
+test('all date and time columns without timezone third case mode date', async ({ db }) => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
 		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
@@ -265,7 +162,7 @@ test('all date and time columns without timezone third case mode date', async ()
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('test mode string for timestamp with timezone', async () => {
+test('test mode string for timestamp with timezone', async ({ db }) => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
 		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
@@ -305,7 +202,7 @@ test('test mode string for timestamp with timezone', async () => {
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('test mode date for timestamp with timezone', async () => {
+test('test mode date for timestamp with timezone', async ({ db }) => {
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
 		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
@@ -345,7 +242,7 @@ test('test mode date for timestamp with timezone', async () => {
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
+test('test mode string for timestamp with timezone in UTC timezone', async ({ db }) => {
 	// get current timezone from db
 	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
@@ -393,12 +290,12 @@ test('test mode string for timestamp with timezone in UTC timezone', async () =>
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-test('test mode string for timestamp with timezone in different timezone', async () => {
+test('test mode string for timestamp with timezone in different timezone', async ({ db }) => {
 	// get current timezone from db
 	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
 	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
+	await db.execute(sql`set time zone '-10'`);
 
 	const table = pgTable('all_columns', {
 		id: serial('id').primaryKey(),
@@ -439,44 +336,7 @@ test('test mode string for timestamp with timezone in different timezone', async
 	await db.execute(sql`drop table if exists ${table}`);
 });
 
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-	'transaction',
-	'transaction rollback',
-	'nested transaction',
-	'nested transaction rollback',
-	'test $onUpdateFn and $onUpdate works updating',
-]);
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
-
-test('insert via db.execute + select via db.execute', async () => {
+test('insert via db.execute + select via db.execute', async ({ db }) => {
 	await db.execute(
 		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
 	);
@@ -487,7 +347,7 @@ test('insert via db.execute + select via db.execute', async () => {
 	expect(result).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert via db.execute + returning', async () => {
+test('insert via db.execute + returning', async ({ db }) => {
 	const inserted = await db.execute<{ id: number; name: string }>(
 		sql`insert into ${usersTable} (${
 			sql.identifier(
@@ -498,7 +358,7 @@ test('insert via db.execute + returning', async () => {
 	expect(inserted).toEqual([{ id: 1, name: 'John' }]);
 });
 
-test('insert via db.execute w/ query builder', async () => {
+test('insert via db.execute w/ query builder', async ({ db }) => {
 	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
 		db
 			.insert(usersTable)
@@ -508,5 +368,211 @@ test('insert via db.execute w/ query builder', async () => {
 	expect(inserted).toEqual([{ id: 1, name: 'John' }]);
 });
 
-tests();
-cacheTests();
+test('migrator : --init', async ({ db, simulator }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop schema if exists public cascade`);
+	await db.execute(sql`create schema public`);
+
+	const migratorRes = await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/pg-init',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(res[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db, simulator }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop schema if exists public cascade`);
+	await db.execute(sql`create schema public`);
+
+	const migratorRes = await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/pg',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(res[0]?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db, simulator }) => {
+	const migrationsSchema = 'drzl_migrations_init';
+	const migrationsTable = 'drzl_init';
+
+	await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+	await db.execute(sql`drop schema if exists public cascade`);
+	await db.execute(sql`create schema public`);
+
+	await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/pg-init',
+		migrationsSchema,
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/pg',
+		migrationsTable,
+		migrationsSchema,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+	const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+		getTableConfig(usersMigratorTable).name
+	}
+			) as ${sql.identifier('tableExists')};`);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(res[0]?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db, simulator }) => {
+	const users = pgTable('migration_users', {
+		id: serial('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: integer(),
+	});
+
+	const users2 = pgTable('migration_users2', {
+		id: serial('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: integer(),
+	});
+
+	await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/pg-proxy';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db, async (queries) => {
+		try {
+			await simulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
diff --git a/integration-tests/tests/pg/pg.postgresjs.test.ts b/integration-tests/tests/pg/pg.postgresjs.test.ts
new file mode 100644
index 0000000000..d0ac30cccf
--- /dev/null
+++ b/integration-tests/tests/pg/pg.postgresjs.test.ts
@@ -0,0 +1,13062 @@
+import 'dotenv/config';
+import { DrizzleError, sql, TransactionRollbackError } from 'drizzle-orm';
+import { alias } from 'drizzle-orm/pg-core';
+import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './pg.relations';
+import * as schema from './pg.schema';
+
+const ENABLE_LOGGING = false;
+
+const {
+	usersTable,
+	postsTable,
+	commentsTable,
+	usersToGroupsTable,
+	groupsTable,
+	schemaGroups,
+	schemaPosts,
+	schemaUsers,
+	schemaUsersToGroups,
+	allTypesTable,
+	studentGrades,
+	students,
+	courseOfferings,
+	customTypesTable,
+} = schema;
+
+declare module 'vitest' {
+	export interface TestContext {
+		pgjsDbV2: PostgresJsDatabase<typeof relations>;
+		pgjsClient: postgres.Sql<{}>;
+	}
+}
+
+let db: PostgresJsDatabase<typeof relations>;
+let client: postgres.Sql<{}>;
+
+beforeAll(async () => {
+	const connectionString = process.env['PG_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'PG_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up postgres` and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 250;
+	let timeLeft = 5000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			client = postgres(connectionString, {
+				max: 1,
+				onnotice: () => {
+					// disable notices
+				},
+			});
+			await client`select 1`;
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to Postgres');
+		await client?.end().catch(console.error);
+		throw lastError;
+	}
+	db = drizzle({ client, relations, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
+beforeEach(async (ctx) => {
+	ctx.pgjsDbV2 = db;
+	ctx.pgjsClient = client;
+
+	await ctx.pgjsDbV2.execute(sql`drop schema public cascade`);
+	await ctx.pgjsDbV2.execute(sql`drop schema if exists rqb_test_schema cascade`);
+	await ctx.pgjsDbV2.execute(sql`create schema public`);
+	await ctx.pgjsDbV2.execute(sql`create schema rqb_test_schema`);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE "users" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"verified" boolean DEFAULT false NOT NULL,
+				"invited_by" int REFERENCES "users"("id")
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE "rqb_test_schema"."users" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"verified" boolean DEFAULT false NOT NULL,
+				"invited_by" int REFERENCES "rqb_test_schema"."users"("id")
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"description" text
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"description" text
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "users_to_groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"user_id" int REFERENCES "users"("id"),
+				"group_id" int REFERENCES "groups"("id")
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."users_to_groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"user_id" int REFERENCES "rqb_test_schema"."users"("id"),
+				"group_id" int REFERENCES "rqb_test_schema"."groups"("id")
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "posts" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"owner_id" int REFERENCES "users"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."posts" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"owner_id" int REFERENCES "rqb_test_schema"."users"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE VIEW "users_view" AS (SELECT "users".*, "posts"."content", "posts"."created_at", (SELECT COUNT(*) FROM "users" as "count_source" WHERE "users"."id" <> 2) AS "count" FROM "users" LEFT JOIN "posts" ON "users"."id" = "posts"."owner_id");
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE VIEW "rqb_test_schema"."users_sch_view" AS (SELECT "rqb_test_schema"."users".*, "rqb_test_schema"."posts"."content", "rqb_test_schema"."posts"."created_at", (SELECT COUNT(*) FROM "rqb_test_schema"."users" as "count_source" WHERE "rqb_test_schema"."users"."id" <> 2) AS "count" FROM "rqb_test_schema"."users" LEFT JOIN "rqb_test_schema"."posts" ON "rqb_test_schema"."users"."id" = "rqb_test_schema"."posts"."owner_id");
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "comments" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"creator" int REFERENCES "users"("id"),
+				"post_id" int REFERENCES "posts"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "comment_likes" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"creator" int REFERENCES "users"("id"),
+				"comment_id" int REFERENCES "comments"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE "course_offerings" (
+				"course_id" integer NOT NULL,
+				"semester" varchar(10) NOT NULL,
+				CONSTRAINT "course_offerings_pkey" PRIMARY KEY("course_id","semester")
+			)	
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE "student_grades" (
+				"student_id" integer NOT NULL,
+				"course_id" integer NOT NULL,
+				"semester" varchar(10) NOT NULL,
+				"grade" char(2),
+				CONSTRAINT "student_grades_pkey" PRIMARY KEY("student_id","course_id","semester")
+			);
+		`,
+	);
+	await ctx.pgjsDbV2.execute(
+		sql`
+			CREATE TABLE "students" (
+				"student_id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL
+			);
+		`,
+	);
+});
+
+test('[Find Many] Get users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts and users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1' }, {
+			lowerName: 'post1.2',
+		}, { lowerName: 'post1.3' }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'andrew',
+		posts: [{ lowerName: 'post2' }, {
+			lowerName: 'post2.1',
+		}],
+	});
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'alex',
+		posts: [{ lowerName: 'post3' }, {
+			lowerName: 'post3.1',
+		}],
+	});
+});
+
+test('[Find Many] Get only custom fields + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1' }, {
+			lowerName: 'post1.2',
+		}, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get deep select {}', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts + prepared limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare('query1');
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare('query2');
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare('query3');
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [{ eq: sql.placeholder('id') }, 3],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare('query4');
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts?.posts[2]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: ({ content }) => sql<string>`lower(${content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: ({ content }) => sql<string>`lower(${content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: false,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+test('Get user with posts and posts with comments and comments with owner', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: ({ id }, { notExists, eq }) =>
+				notExists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(sql`1`, id))),
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(2);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+				orderBy: {
+					groupId: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: expect.arrayContaining([
+			{
+				group: {
+					id: 2,
+					name: 'Group2',
+					description: null,
+				},
+			},
+			{
+				group: {
+					id: 3,
+					name: 'Group3',
+					description: null,
+				},
+			},
+		]),
+	});
+});
+
+test('[Find Many] Get groups with users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+						}),
+					},
+				},
+				orderBy: {
+					groupId: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [
+			{
+				group: {
+					id: 2,
+					name: 'Group2',
+					lower: 'group2',
+					description: null,
+				},
+			},
+			{
+				group: {
+					id: 3,
+					name: 'Group3',
+					lower: 'group3',
+					description: null,
+				},
+			},
+		],
+	});
+});
+
+test('Get groups with users + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many .through] Get users with groups', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + orderBy', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users + orderBy + limit', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + custom', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get custom schema users with filtered posts + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsers.findMany({
+		with: {
+			posts: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%2.%',
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				gte: 2,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [
+			{ ownerId: 2, content: 'Message2.1' },
+			{ ownerId: 2, content: 'Message2.2' },
+			{ ownerId: 2, content: 'Message2.3' },
+		],
+	}]);
+});
+
+test('[Find Many] Get custom schema posts with filtered authors + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const posts = await db.query.schemaPosts.findMany({
+		columns: {
+			content: true,
+		},
+		with: {
+			author: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		content: string;
+		author: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	expect(posts).toStrictEqual([
+		{ content: 'Post3.3', author: null },
+		{ content: 'Post2.3', author: null },
+		{ content: 'Post1.3', author: null },
+		{ content: 'Post3.2', author: null },
+		{ content: 'Post2.2', author: null },
+		{ content: 'Post1.2', author: null },
+		{ content: 'Post3.1', author: null },
+		{ content: 'Post2.1', author: null },
+		{ content: 'Post1.1', author: null },
+		{ content: 'Message3.3', author: null },
+		{ content: 'Message2.3', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.3', author: null },
+		{ content: 'Message3.2', author: null },
+		{ content: 'Message2.2', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.2', author: null },
+		{ content: 'Message3.1', author: null },
+		{ content: 'Message2.1', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.1', author: null },
+	]);
+});
+
+test('[Find Many .through] Get custom schema users with filtered groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsers.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get custom schema groups with filtered users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			users: {
+				where: { id: { lt: 3 } },
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by SQL.Aliased field', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by joined field', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get posts with view users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter by joined column with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notIlike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get posts with view users + filter by SQL.Aliased with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get view users with filtered groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered view users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts + filter by SQL.Aliased field', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts + filter by joined field', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema posts with view users with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users + filter with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users + filter by joined column with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notIlike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get schema posts with view users + filter by SQL.Aliased with posts', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get schema view users with filtered groups + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get schema groups with filtered view users + where', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('Force optional on where on non-optional relation query', async (t) => {
+	const { pgjsDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many] Get users + filter users by posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter posts by author', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}],
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async (ctx) => {
+	const { pgjsDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_1');
+
+	const posts = await query.execute({
+		id: 1,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_2');
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_3');
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_4');
+
+	const posts = await query.execute({
+		id: 3,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.students.findMany({
+		with: {
+			courseOfferings: {
+				orderBy: {
+					courseId: 'asc',
+					semester: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			studentId: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		studentId: number;
+		name: string;
+		courseOfferings: {
+			courseId: number;
+			semester: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			name: 'First',
+			studentId: 1,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+				{
+					courseId: 2,
+					semester: 's2',
+				},
+			],
+		},
+		{
+			name: 'Second',
+			studentId: 2,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+			],
+		},
+		{
+			name: 'Third',
+			studentId: 3,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's2',
+				},
+				{
+					courseId: 2,
+					semester: 's3',
+				},
+				{
+					courseId: 4,
+					semester: 's4',
+				},
+			],
+		},
+		{
+			name: 'Fourth',
+			studentId: 4,
+			courseOfferings: [
+				{
+					courseId: 3,
+					semester: 's1',
+				},
+				{
+					courseId: 4,
+					semester: 's3',
+				},
+			],
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count - reverse', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.courseOfferings.findMany({
+		with: {
+			students: {
+				orderBy: {
+					studentId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			courseId: 'asc',
+			semester: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		courseId: number;
+		semester: string;
+		students: {
+			studentId: number;
+			name: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			courseId: 1,
+			semester: 's1',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+				{
+					name: 'Second',
+					studentId: 2,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's2',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's2',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's3',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's1',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 3,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's3',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 4,
+			semester: 's4',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+	]);
+});
+
+test('alltypes', async () => {
+	await db.execute(sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`);
+	await db.execute(sql`
+		CREATE TABLE "all_types" (
+			"serial" serial NOT NULL,
+			"bigserial53" bigserial NOT NULL,
+			"bigserial64" bigserial,
+			"int" integer,
+			"bigint53" bigint,
+			"bigint64" bigint,
+			"bigint_string" bigint,
+			"bool" boolean,
+			"bytea" bytea,
+			"char" char,
+			"cidr" "cidr",
+			"date" date,
+			"date_str" date,
+			"double" double precision,
+			"enum" "en",
+			"inet" "inet",
+			"interval" interval,
+			"json" json,
+			"jsonb" jsonb,
+			"line" "line",
+			"line_tuple" "line",
+			"macaddr" "macaddr",
+			"macaddr8" "macaddr8",
+			"numeric" numeric,
+			"numeric_num" numeric,
+			"numeric_big" numeric,
+			"point" "point",
+			"point_tuple" "point",
+			"real" real,
+			"smallint" smallint,
+			"smallserial" "smallserial" NOT NULL,
+			"text" text,
+			"time" time,
+			"timestamp" timestamp,
+			"timestamp_tz" timestamp with time zone,
+			"timestamp_str" timestamp,
+			"timestamp_tz_str" timestamp with time zone,
+			"uuid" uuid,
+			"varchar" varchar,
+			"arrint" integer[],
+			"arrbigint53" bigint[],
+			"arrbigint64" bigint[],
+			"arrbigint_string" bigint[],
+			"arrbool" boolean[],
+			"arrbytea" bytea[],
+			"arrchar" char[],
+			"arrcidr" "cidr"[],
+			"arrdate" date[],
+			"arrdate_str" date[],
+			"arrdouble" double precision[],
+			"arrenum" "en"[],
+			"arrinet" "inet"[],
+			"arrinterval" interval[],
+			"arrjson" json[],
+			"arrjsonb" jsonb[],
+			"arrline" "line"[],
+			"arrline_tuple" "line"[],
+			"arrmacaddr" "macaddr"[],
+			"arrmacaddr8" "macaddr8"[],
+			"arrnumeric" numeric[],
+			"arrnumeric_num" numeric[],
+			"arrnumeric_big" numeric[],
+			"arrpoint" "point"[],
+			"arrpoint_tuple" "point"[],
+			"arrreal" real[],
+			"arrsmallint" smallint[],
+			"arrtext" text[],
+			"arrtime" time[],
+			"arrtimestamp" timestamp[],
+			"arrtimestamp_tz" timestamp with time zone[],
+			"arrtimestamp_str" timestamp[],
+			"arrtimestamp_tz_str" timestamp with time zone[],
+			"arruuid" uuid[],
+			"arrvarchar" varchar[]
+		);
+	`);
+
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		smallserial: 15,
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintString: '5044565289845416380',
+		bigserial53: 9007199254740991,
+		bigserial64: 5044565289845416380n,
+		bool: true,
+		bytea: Buffer.from('BYTES'),
+		char: 'c',
+		cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+		inet: '192.168.0.1/24',
+		macaddr: '08:00:2b:01:02:03',
+		macaddr8: '08:00:2b:01:02:03:04:05',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString(),
+		double: 15.35325689124218,
+		enum: 'enVal1',
+		int: 621,
+		interval: '2 months ago',
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		jsonb: {
+			str: 'strvalb',
+			arr: ['strb', 11],
+		},
+		line: {
+			a: 1,
+			b: 2,
+			c: 3,
+		},
+		lineTuple: [1, 2, 3],
+		numeric: '475452353476',
+		numericNum: 9007199254740991,
+		numericBig: 5044565289845416380n,
+		point: {
+			x: 24.5,
+			y: 49.6,
+		},
+		pointTuple: [57.2, 94.3],
+		real: 1.048596,
+		smallint: 10,
+		text: 'TEXT STRING',
+		time: '13:59:28',
+		timestamp: new Date(1741743161623),
+		timestampTz: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString(),
+		timestampTzStr: new Date(1741743161623).toISOString(),
+		uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+		varchar: 'C4-',
+		arrbigint53: [9007199254740991],
+		arrbigint64: [5044565289845416380n],
+		arrbigintString: ['5044565289845416380'],
+		arrbool: [true],
+		arrbytea: [Buffer.from('BYTES')],
+		arrchar: ['c'],
+		arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+		arrinet: ['192.168.0.1/24'],
+		arrmacaddr: ['08:00:2b:01:02:03'],
+		arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+		arrdate: [new Date(1741743161623)],
+		arrdateStr: [new Date(1741743161623).toISOString()],
+		arrdouble: [15.35325689124218],
+		arrenum: ['enVal1'],
+		arrint: [621],
+		arrinterval: ['2 months ago'],
+		arrjson: [{
+			str: 'strval',
+			arr: ['str', 10],
+		}],
+		arrjsonb: [{
+			str: 'strvalb',
+			arr: ['strb', 11],
+		}],
+		arrline: [{
+			a: 1,
+			b: 2,
+			c: 3,
+		}],
+		arrlineTuple: [[1, 2, 3]],
+		arrnumeric: ['475452353476'],
+		arrnumericNum: [9007199254740991],
+		arrnumericBig: [5044565289845416380n],
+		arrpoint: [{
+			x: 24.5,
+			y: 49.6,
+		}],
+		arrpointTuple: [[57.2, 94.3]],
+		arrreal: [1.048596],
+		arrsmallint: [10],
+		arrtext: ['TEXT STRING'],
+		arrtime: ['13:59:28'],
+		arrtimestamp: [new Date(1741743161623)],
+		arrtimestampTz: [new Date(1741743161623)],
+		arrtimestampStr: [new Date(1741743161623).toISOString()],
+		arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+		arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+		arrvarchar: ['C4-'],
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			serial: 1,
+			bigserial53: 9007199254740991,
+			bigserial64: 5044565289845416380n,
+			int: 621,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			bool: true,
+			bytea: Buffer.from('BYTES'),
+			char: 'c',
+			cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			double: 15.35325689124218,
+			enum: 'enVal1',
+			inet: '192.168.0.1/24',
+			interval: '-2 mons',
+			json: { str: 'strval', arr: ['str', 10] },
+			jsonb: { arr: ['strb', 11], str: 'strvalb' },
+			line: { a: 1, b: 2, c: 3 },
+			lineTuple: [1, 2, 3],
+			macaddr: '08:00:2b:01:02:03',
+			macaddr8: '08:00:2b:01:02:03:04:05',
+			numeric: '475452353476',
+			numericNum: 9007199254740991,
+			numericBig: 5044565289845416380n,
+			point: { x: 24.5, y: 49.6 },
+			pointTuple: [57.2, 94.3],
+			real: 1.048596,
+			smallint: 10,
+			smallserial: 15,
+			text: 'TEXT STRING',
+			time: '13:59:28',
+			timestamp: new Date('2025-03-12T01:32:41.623Z'),
+			timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+			timestampStr: '2025-03-12 01:32:41.623',
+			timestampTzStr: '2025-03-12 01:32:41.623+00',
+			uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+			varchar: 'C4-',
+			arrint: [621],
+			arrbigint53: [9007199254740991],
+			arrbigint64: [5044565289845416380n],
+			arrbigintString: ['5044565289845416380'],
+			arrbool: [true],
+			arrbytea: [Buffer.from('BYTES')],
+			arrchar: ['c'],
+			arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+			arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+			arrdateStr: ['2025-03-12'],
+			arrdouble: [15.35325689124218],
+			arrenum: ['enVal1'],
+			arrinet: ['192.168.0.1/24'],
+			arrinterval: ['-2 mons'],
+			arrjson: [{ str: 'strval', arr: ['str', 10] }],
+			arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+			arrline: [{ a: 1, b: 2, c: 3 }],
+			arrlineTuple: [[1, 2, 3]],
+			arrmacaddr: ['08:00:2b:01:02:03'],
+			arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+			arrnumeric: ['475452353476'],
+			arrnumericNum: [9007199254740991],
+			arrnumericBig: [5044565289845416380n],
+			arrpoint: [{ x: 24.5, y: 49.6 }],
+			arrpointTuple: [[57.2, 94.3]],
+			arrreal: [1.048596],
+			arrsmallint: [10],
+			arrtext: ['TEXT STRING'],
+			arrtime: ['13:59:28'],
+			arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampStr: ['2025-03-12 01:32:41.623'],
+			arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+			arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+			arrvarchar: ['C4-'],
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	await db.execute(sql`
+		CREATE TABLE "custom_types" (
+			"id" serial,
+			"big" bigint,
+			"big_arr" bigint[],
+			"big_mtx" bigint[][],
+			"bytes" bytea,
+			"bytes_arr" bytea[],
+			"bytes_mtx" bytea[][],
+			"time" timestamp(3),
+			"time_arr" timestamp(3)[],
+			"time_mtx" timestamp(3)[][],
+			"int" integer,
+			"int_arr" integer[],
+			"int_mtx" integer[][]
+		);
+	`);
+
+	await db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bigArr: [5044565289845416380n],
+		bigMtx: [[5044565289845416380n]],
+		bytes: Buffer.from('BYTES'),
+		bytesArr: [Buffer.from('BYTES')],
+		bytesMtx: [[Buffer.from('BYTES')]],
+		time: new Date(1741743161623),
+		timeArr: [new Date(1741743161623)],
+		timeMtx: [[new Date(1741743161623)]],
+		int: 250,
+		intArr: [250],
+		intMtx: [[250]],
+	});
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number;
+		big: bigint | null;
+		bigArr: bigint[] | null;
+		bigMtx: bigint[][] | null;
+		bytes: Buffer | null;
+		bytesArr: Buffer[] | null;
+		bytesMtx: Buffer[][] | null;
+		time: Date | null;
+		timeArr: Date[] | null;
+		timeMtx: Date[][] | null;
+		int: number | null;
+		intArr: number[] | null;
+		intMtx: number[][] | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bigArr: [5044565289845416380n],
+			bigMtx: [[5044565289845416380n]],
+			bytes: Buffer.from('BYTES'),
+			bytesArr: [Buffer.from('BYTES')],
+			bytesMtx: [[Buffer.from('BYTES')]],
+			time: new Date(1741743161623),
+			timeArr: [new Date(1741743161623)],
+			timeMtx: [[new Date(1741743161623)]],
+			int: 250,
+			intArr: [250],
+			intMtx: [[250]],
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/pg/pg.relations.ts b/integration-tests/tests/pg/pg.relations.ts
new file mode 100644
index 0000000000..5478a72f27
--- /dev/null
+++ b/integration-tests/tests/pg/pg.relations.ts
@@ -0,0 +1,212 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './pg.schema';
+
+export default defineRelations(schema, (r) => ({
+	usersView: {
+		posts: r.many.postsTable(),
+		groups: r.many.groupsTable(),
+	},
+	schemaUsersView: {
+		posts: r.many.schemaPosts(),
+		groups: r.many.schemaGroups(),
+	},
+	usersTable: {
+		alltypes: r.many.allTypesTable({
+			from: r.usersTable.id,
+			to: r.allTypesTable.serial,
+		}),
+		invitee: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+		}),
+		inviteeRequired: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		usersToGroups: r.many.usersToGroupsTable(),
+		posts: r.many.postsTable(),
+		postsFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				ownerId: 2,
+			},
+			alias: 'author-filtered',
+		}),
+		postsAltFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				content: {
+					like: '%.1',
+				},
+			},
+			alias: 'author-alt-filtered',
+		}),
+		group: r.one.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+		}),
+		groups: r.many.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			alias: 'users-groups-direct',
+		}),
+		groupsFiltered: r.many.groupsTable({
+			alias: 'users-groups-direct-filtered',
+		}),
+	},
+	groupsTable: {
+		usersToGroups: r.many.usersToGroupsTable(),
+		user: r.one.usersTable(),
+		users: r.many.usersTable({
+			alias: 'users-groups-direct',
+		}),
+		usersFiltered: r.many.usersTable({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+			alias: 'users-groups-direct-filtered',
+		}),
+		usersView: r.many.usersView({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersView.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	usersToGroupsTable: {
+		group: r.one.groupsTable({
+			from: r.usersToGroupsTable.groupId,
+			to: r.groupsTable.id,
+			optional: false,
+		}),
+		user: r.one.usersTable({
+			from: r.usersToGroupsTable.userId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	postsTable: {
+		author: r.one.usersTable({
+			from: r.postsTable.ownerId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		viewAuthor: r.one.usersView({
+			from: r.postsTable.ownerId,
+			to: r.usersView.id,
+			optional: false,
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+		authorFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-filtered',
+		}),
+		authorAltFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-alt-filtered',
+		}),
+		comments: r.many.commentsTable(),
+	},
+	commentsTable: {
+		post: r.one.postsTable({
+			from: r.commentsTable.postId,
+			to: r.postsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentsTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		likes: r.many.commentLikesTable(),
+	},
+	commentLikesTable: {
+		comment: r.one.commentsTable({
+			from: r.commentLikesTable.commentId,
+			to: r.commentsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentLikesTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	schemaUsers: {
+		posts: r.many.schemaPosts({
+			from: r.schemaUsers.id,
+			to: r.schemaPosts.ownerId,
+			where: {
+				content: {
+					like: 'M%',
+				},
+			},
+		}),
+		groups: r.many.schemaGroups({
+			from: r.schemaUsers.id.through(r.schemaUsersToGroups.userId),
+			to: r.schemaGroups.id.through(r.schemaUsersToGroups.groupId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+		}),
+	},
+	schemaPosts: {
+		author: r.one.schemaUsers(),
+		viewAuthor: r.one.schemaUsersView({
+			from: r.schemaPosts.ownerId,
+			to: r.schemaUsersView.id,
+			optional: false,
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	schemaGroups: {
+		users: r.many.schemaUsers(),
+		usersView: r.many.schemaUsersView({
+			from: r.schemaGroups.id.through(r.schemaUsersToGroups.groupId),
+			to: r.schemaUsersView.id.through(r.schemaUsersToGroups.userId),
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	students: {
+		courseOfferings: r.many.courseOfferings({
+			from: r.students.studentId.through(r.studentGrades.studentId),
+			to: [
+				r.courseOfferings.courseId.through(r.studentGrades.courseId),
+				r.courseOfferings.semester.through(r.studentGrades.semester),
+			],
+		}),
+	},
+	courseOfferings: {
+		students: r.many.students(),
+	},
+	customTypesTable: {
+		self: r.many.customTypesTable({
+			from: r.customTypesTable.id,
+			to: r.customTypesTable.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/pg/pg.schema.ts b/integration-tests/tests/pg/pg.schema.ts
new file mode 100644
index 0000000000..eeab32be15
--- /dev/null
+++ b/integration-tests/tests/pg/pg.schema.ts
@@ -0,0 +1,381 @@
+import { eq, getTableColumns, ne, sql } from 'drizzle-orm';
+import {
+	alias,
+	bigint,
+	bigserial,
+	boolean,
+	bytea,
+	char,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	line,
+	macaddr,
+	macaddr8,
+	numeric,
+	type PgColumn,
+	pgEnum,
+	point,
+	primaryKey,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+
+export const usersTable = snakeCase.table('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: integer('invited_by').references((): PgColumn => usersTable.id),
+});
+
+export const schemaV1 = snakeCase.schema('schemaV1');
+
+export const usersV1 = schemaV1.table('usersV1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: integer('invited_by'),
+});
+
+export const usersTableV1 = schemaV1.table('users_table_V1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: integer('invited_by'),
+});
+
+export const groupsTable = snakeCase.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+
+export const usersToGroupsTable = snakeCase.table('users_to_groups', {
+	id: serial().primaryKey(),
+	userId: integer().notNull().references(() => usersTable.id),
+	groupId: integer().notNull().references(() => groupsTable.id),
+}, (t) => ({
+	pk: primaryKey(t.groupId, t.userId),
+}));
+
+export const postsTable = snakeCase.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: integer().references(() => usersTable.id),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+});
+
+export const usersView = snakeCase.view('users_view').as((qb) =>
+	qb.select({
+		...getTableColumns(usersTable),
+		postContent: postsTable.content,
+		createdAt: postsTable.createdAt,
+		counter: sql<string | number>`(select count(*) from ${usersTable} as ${alias(usersTable, 'count_source')} where ${
+			ne(usersTable.id, 2)
+		})`
+			.mapWith((data) => {
+				return data === '0' || data === 0 ? null : Number(data);
+			}).as('count'),
+	})
+		.from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.ownerId))
+);
+
+export const commentsTable = snakeCase.table('comments', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	creator: integer().references(() => usersTable.id),
+	postId: integer().references(() => postsTable.id),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+});
+
+export const commentLikesTable = snakeCase.table('comment_likes', {
+	id: serial().primaryKey(),
+	creator: integer().references(() => usersTable.id),
+	commentId: integer().references(() => commentsTable.id),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+});
+
+export const rqbSchema = snakeCase.schema('rqb_test_schema');
+
+export const schemaUsers = rqbSchema.table('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	verified: boolean().notNull().default(false),
+	invitedBy: integer().references((): PgColumn => schemaUsers.id),
+});
+
+export const schemaPosts = rqbSchema.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: integer().references(() => schemaUsers.id),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+});
+
+export const schemaGroups = rqbSchema.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+
+export const schemaUsersToGroups = rqbSchema.table('users_to_groups', {
+	id: serial().primaryKey(),
+	userId: integer().notNull().references(() => schemaUsers.id),
+	groupId: integer().notNull().references(() => schemaGroups.id),
+}, (t) => ({
+	pk: primaryKey(t.groupId, t.userId),
+}));
+
+export const schemaUsersView = rqbSchema.view('users_sch_view').as((qb) =>
+	qb.select({
+		...getTableColumns(schemaUsers),
+		postContent: schemaPosts.content,
+		createdAt: schemaPosts.createdAt,
+		counter: sql<string | number>`(select count(*) from ${schemaUsers} as ${alias(schemaUsers, 'count_source')} where ${
+			ne(schemaUsers.id, 2)
+		})`
+			.mapWith((data) => {
+				return data === '0' || data === 0 ? null : Number(data);
+			}).as('count'),
+	})
+		.from(schemaUsers).leftJoin(schemaPosts, eq(schemaUsers.id, schemaPosts.ownerId))
+);
+
+export const en = pgEnum('en', ['enVal1', 'enVal2']);
+
+export const allTypesTable = snakeCase.table('all_types', {
+	serial: serial(),
+	bigserial53: bigserial({
+		mode: 'number',
+	}),
+	bigserial64: bigserial({
+		mode: 'bigint',
+	}),
+	int: integer(),
+	bigint53: bigint({
+		mode: 'number',
+	}),
+	bigint64: bigint({
+		mode: 'bigint',
+	}),
+	bigintString: bigint({
+		mode: 'string',
+	}),
+	bool: boolean(),
+	bytea: bytea(),
+	char: char(),
+	cidr: cidr(),
+	date: date({
+		mode: 'date',
+	}),
+	dateStr: date({
+		mode: 'string',
+	}),
+	double: doublePrecision(),
+	enum: en(),
+	inet: inet(),
+	interval: interval(),
+	json: json(),
+	jsonb: jsonb(),
+	line: line({
+		mode: 'abc',
+	}),
+	lineTuple: line({
+		mode: 'tuple',
+	}),
+	macaddr: macaddr(),
+	macaddr8: macaddr8(),
+	numeric: numeric(),
+	numericNum: numeric({
+		mode: 'number',
+	}),
+	numericBig: numeric({
+		mode: 'bigint',
+	}),
+	point: point({
+		mode: 'xy',
+	}),
+	pointTuple: point({
+		mode: 'tuple',
+	}),
+	real: real(),
+	smallint: smallint(),
+	smallserial: smallserial(),
+	text: text(),
+	time: time(),
+	timestamp: timestamp({
+		mode: 'date',
+	}),
+	timestampTz: timestamp({
+		mode: 'date',
+		withTimezone: true,
+	}),
+	timestampStr: timestamp({
+		mode: 'string',
+	}),
+	timestampTzStr: timestamp({
+		mode: 'string',
+		withTimezone: true,
+	}),
+	uuid: uuid(),
+	varchar: varchar(),
+	arrint: integer().array(),
+	arrbigint53: bigint({
+		mode: 'number',
+	}).array(),
+	arrbigint64: bigint({
+		mode: 'bigint',
+	}).array(),
+	arrbigintString: bigint({
+		mode: 'string',
+	}).array(),
+	arrbool: boolean().array(),
+	arrbytea: bytea().array(),
+	arrchar: char().array(),
+	arrcidr: cidr().array(),
+	arrdate: date({
+		mode: 'date',
+	}).array(),
+	arrdateStr: date({
+		mode: 'string',
+	}).array(),
+	arrdouble: doublePrecision().array(),
+	arrenum: en().array(),
+	arrinet: inet().array(),
+	arrinterval: interval().array(),
+	arrjson: json().array(),
+	arrjsonb: jsonb().array(),
+	arrline: line({
+		mode: 'abc',
+	}).array(),
+	arrlineTuple: line({
+		mode: 'tuple',
+	}).array(),
+	arrmacaddr: macaddr().array(),
+	arrmacaddr8: macaddr8().array(),
+	arrnumeric: numeric().array(),
+	arrnumericNum: numeric({
+		mode: 'number',
+	}).array(),
+	arrnumericBig: numeric({
+		mode: 'bigint',
+	}).array(),
+	arrpoint: point({
+		mode: 'xy',
+	}).array(),
+	arrpointTuple: point({
+		mode: 'tuple',
+	}).array(),
+	arrreal: real().array(),
+	arrsmallint: smallint().array(),
+	arrtext: text().array(),
+	arrtime: time().array(),
+	arrtimestamp: timestamp({
+		mode: 'date',
+	}).array(),
+	arrtimestampTz: timestamp({
+		mode: 'date',
+		withTimezone: true,
+	}).array(),
+	arrtimestampStr: timestamp({
+		mode: 'string',
+	}).array(),
+	arrtimestampTzStr: timestamp({
+		mode: 'string',
+		withTimezone: true,
+	}).array(),
+	arruuid: uuid().array(),
+	arrvarchar: varchar().array(),
+});
+
+export const students = snakeCase.table('students', {
+	studentId: serial('student_id').primaryKey().notNull(),
+	name: text().notNull(),
+});
+
+export const courseOfferings = snakeCase.table('course_offerings', {
+	courseId: integer('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+});
+
+export const studentGrades = snakeCase.table('student_grades', {
+	studentId: integer('student_id').notNull(),
+	courseId: integer('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+	grade: char({ length: 2 }),
+});
+
+const customBigInt = customType<{
+	data: bigint;
+	driverData: bigint;
+	driverOutput: string;
+	jsonData: string;
+}>({
+	codec: 'bigint',
+	dataType: () => 'bigint',
+	fromDriver: BigInt,
+	fromJson: BigInt,
+});
+
+const customBytes = customType<{
+	data: Buffer;
+	driverData: Buffer;
+	jsonData: string;
+}>({
+	codec: 'bytea',
+	dataType: () => 'bytea',
+	fromJson: (value) => {
+		return Buffer.from(value.slice(2, value.length), 'hex');
+	},
+	forJsonSelect: (identifier, sql, arrayDimensions) =>
+		sql`${identifier}::text${sql.raw('[]'.repeat(arrayDimensions ?? 0))}`,
+});
+
+const customTimestamp = customType<{
+	data: Date;
+	driverData: string;
+	jsonData: string;
+}>({
+	codec: 'timestamp',
+	dataType: () => 'timestamp(3)',
+	toDriver: (value: Date) => {
+		return value.toISOString();
+	},
+});
+
+const customInt = customType<{
+	data: number;
+	driverData: number;
+}>({
+	codec: 'integer',
+	dataType: () => 'integer',
+});
+
+export const customTypesTable = snakeCase.table('custom_types', {
+	id: serial('id'),
+	big: customBigInt(),
+	bigArr: customBigInt().array(),
+	bigMtx: customBigInt().array('[][]'),
+	bytes: customBytes(),
+	bytesArr: customBytes().array(),
+	bytesMtx: customBytes().array('[][]'),
+	time: customTimestamp(),
+	timeArr: customTimestamp().array(),
+	timeMtx: customTimestamp().array('[][]'),
+	int: customInt(),
+	intArr: customInt().array(),
+	intMtx: customInt().array('[][]'),
+});
diff --git a/integration-tests/tests/pg/pg.test.ts b/integration-tests/tests/pg/pg.test.ts
new file mode 100644
index 0000000000..50dcefe546
--- /dev/null
+++ b/integration-tests/tests/pg/pg.test.ts
@@ -0,0 +1,13245 @@
+import 'dotenv/config';
+import { DrizzleError, eq, sql, TransactionRollbackError } from 'drizzle-orm';
+import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { alias } from 'drizzle-orm/pg-core';
+import pg from 'pg';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './pg.relations';
+import {
+	allTypesTable,
+	commentsTable,
+	courseOfferings,
+	customTypesTable,
+	groupsTable,
+	postsTable,
+	schemaGroups,
+	schemaPosts,
+	schemaUsers,
+	schemaUsersToGroups,
+	studentGrades,
+	students,
+	usersTable,
+	usersToGroupsTable,
+} from './pg.schema';
+
+const { Client } = pg;
+
+const ENABLE_LOGGING = false;
+
+declare module 'vitest' {
+	export interface TestContext {
+		pgDbV2: NodePgDatabase<typeof relations>;
+		pgClient: pg.Client;
+	}
+}
+
+let db: NodePgDatabase<typeof relations>;
+let client: pg.Client;
+
+beforeAll(async () => {
+	const connectionString = process.env['PG_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'PG_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up postgres` and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 250;
+	let timeLeft = 5000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			client = new Client(connectionString);
+			await client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to Postgres');
+		await client?.end().catch(console.error);
+		throw lastError;
+	}
+	db = drizzle({ client, relations, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
+beforeEach(async (ctx) => {
+	ctx.pgDbV2 = db;
+	ctx.pgClient = client;
+
+	await ctx.pgDbV2.execute(sql`drop schema public cascade`);
+	await ctx.pgDbV2.execute(sql`drop schema if exists rqb_test_schema cascade`);
+	await ctx.pgDbV2.execute(sql`create schema public`);
+	await ctx.pgDbV2.execute(sql`create schema rqb_test_schema`);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE "users" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"verified" boolean DEFAULT false NOT NULL,
+				"invited_by" int REFERENCES "users"("id")
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE "rqb_test_schema"."users" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"verified" boolean DEFAULT false NOT NULL,
+				"invited_by" int REFERENCES "rqb_test_schema"."users"("id")
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"description" text
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL,
+				"description" text
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "users_to_groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"user_id" int REFERENCES "users"("id"),
+				"group_id" int REFERENCES "groups"("id")
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."users_to_groups" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"user_id" int REFERENCES "rqb_test_schema"."users"("id"),
+				"group_id" int REFERENCES "rqb_test_schema"."groups"("id")
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "posts" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"owner_id" int REFERENCES "users"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "rqb_test_schema"."posts" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"owner_id" int REFERENCES "rqb_test_schema"."users"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE VIEW "users_view" AS (SELECT "users".*, "posts"."content", "posts"."created_at", (SELECT COUNT(*) FROM "users" AS "count_source" WHERE "users"."id" <> 2) AS "count" FROM "users" LEFT JOIN "posts" ON "users"."id" = "posts"."owner_id");
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE VIEW "rqb_test_schema"."users_sch_view" AS (SELECT "rqb_test_schema"."users".*, "rqb_test_schema"."posts"."content", "rqb_test_schema"."posts"."created_at", (SELECT COUNT(*) FROM "rqb_test_schema"."users" AS "count_source" WHERE "rqb_test_schema"."users"."id" <> 2) AS "count" FROM "rqb_test_schema"."users" LEFT JOIN "rqb_test_schema"."posts" ON "rqb_test_schema"."users"."id" = "rqb_test_schema"."posts"."owner_id");
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "comments" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"content" text NOT NULL,
+				"creator" int REFERENCES "users"("id"),
+				"post_id" int REFERENCES "posts"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE IF NOT EXISTS "comment_likes" (
+				"id" serial PRIMARY KEY NOT NULL,
+				"creator" int REFERENCES "users"("id"),
+				"comment_id" int REFERENCES "comments"("id"),
+				"created_at" timestamp with time zone DEFAULT now() NOT NULL
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE "course_offerings" (
+				"course_id" integer NOT NULL,
+				"semester" varchar(10) NOT NULL,
+				CONSTRAINT "course_offerings_pkey" PRIMARY KEY("course_id","semester")
+			)	
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE "student_grades" (
+				"student_id" integer NOT NULL,
+				"course_id" integer NOT NULL,
+				"semester" varchar(10) NOT NULL,
+				"grade" char(2),
+				CONSTRAINT "student_grades_pkey" PRIMARY KEY("student_id","course_id","semester")
+			);
+		`,
+	);
+	await ctx.pgDbV2.execute(
+		sql`
+			CREATE TABLE "students" (
+				"student_id" serial PRIMARY KEY NOT NULL,
+				"name" text NOT NULL
+			);
+		`,
+	);
+});
+
+test('[Find Many] Get users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts limit posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts limit posts and users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts custom fields', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts custom fields limits', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts where partial', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts where partial. Did not select posts id, but used it in where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts where partial(true false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts where partial(false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async (t) => {
+	const { pgDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
+	const { pgDbV2: db } = t;
+
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1' }, {
+			lowerName: 'post1.2',
+		}, { lowerName: 'post1.3' }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'andrew',
+		posts: [{ lowerName: 'post2' }, {
+			lowerName: 'post2.1',
+		}],
+	});
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'alex',
+		posts: [{ lowerName: 'post3' }, {
+			lowerName: 'post3.1',
+		}],
+	});
+});
+
+test('[Find Many] Get only custom fields where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find Many] Get only custom fields where limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields where orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1' }, {
+			lowerName: 'post1.2',
+		}, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				extras: ({
+					contentLower: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				contentLower: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ contentLower: 'post1.2' }, { contentLower: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields where limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields where orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: { gte: 2 },
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get deep select {}', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts prepared limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare('query1');
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts prepared limit offset', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare('query2');
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts prepared where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare('query3');
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts prepared limit offset where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [{ eq: sql.placeholder('id') }, 3],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare('query4');
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts limit posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async (t) => {
+	const { pgDbV2: db } = t;
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts limit posts and users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts custom fields', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts?.posts[2]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts custom fields limits', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts where partial', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts where partial. Did not select posts id, but used it in where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts where partial(true false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts where partial(false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user limit with invitee', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields limits', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee order by', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee where partial', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee where partial.  Did not select users id, but used it in where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee where partial(true+false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee where partial(false)', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts limit posts and users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts limits custom fields in each', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts custom fields in each', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts limit posts and users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts orderBy where custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: ({ content }) => sql<string>`lower(${content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts orderBy where partial custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: ({ content }) => sql<string>`lower(${content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: false,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+test('Get user with posts and posts with comments and comments with owner', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: ({ id }, { exists }) => exists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(id, 1))),
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(1);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+				orderBy: {
+					userId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: expect.arrayContaining([
+			{
+				group: {
+					id: 2,
+					name: 'Group2',
+					description: null,
+				},
+			},
+			{
+				group: {
+					id: 3,
+					name: 'Group3',
+					description: null,
+				},
+			},
+		]),
+	});
+});
+
+test('[Find Many] Get groups with users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+						}),
+					},
+				},
+				orderBy: {
+					groupId: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [
+			{
+				group: {
+					id: 2,
+					name: 'Group2',
+					lower: 'group2',
+					description: null,
+				},
+			},
+			{
+				group: {
+					id: 3,
+					name: 'Group3',
+					lower: 'group3',
+					description: null,
+				},
+			},
+		],
+	});
+});
+
+test('Get groups with users custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many .through] Get users with groups', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users limit where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users orderBy', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users orderBy limit', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users custom', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups with usersToGroups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+				with: {
+					usersToGroups: {
+						where: {
+							userId: 2,
+						},
+						columns: {
+							userId: true,
+							groupId: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				userId: number;
+				groupId: number;
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+			usersToGroups: [{
+				groupId: 2,
+				userId: 2,
+			}],
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users with posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post2' },
+		{ ownerId: 1, content: 'Post3' },
+		{ ownerId: 2, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post1' },
+		{ ownerId: 3, content: 'Post2' },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				with: {
+					posts: {
+						where: {
+							content: 'Post1',
+						},
+						columns: {
+							ownerId: true,
+							content: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				content: string;
+				ownerId: number | null;
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [
+				{
+					ownerId: 2,
+					content: 'Post1',
+				},
+			],
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get custom schema users with filtered posts where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsers.findMany({
+		with: {
+			posts: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%2.%',
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				gte: 2,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [
+			{ ownerId: 2, content: 'Message2.1' },
+			{ ownerId: 2, content: 'Message2.2' },
+			{ ownerId: 2, content: 'Message2.3' },
+		],
+	}]);
+});
+
+test('[Find Many] Get custom schema posts with filtered authors where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const posts = await db.query.schemaPosts.findMany({
+		columns: {
+			content: true,
+		},
+		with: {
+			author: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		content: string;
+		author: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	expect(posts).toStrictEqual([
+		{ content: 'Post3.3', author: null },
+		{ content: 'Post2.3', author: null },
+		{ content: 'Post1.3', author: null },
+		{ content: 'Post3.2', author: null },
+		{ content: 'Post2.2', author: null },
+		{ content: 'Post1.2', author: null },
+		{ content: 'Post3.1', author: null },
+		{ content: 'Post2.1', author: null },
+		{ content: 'Post1.1', author: null },
+		{ content: 'Message3.3', author: null },
+		{ content: 'Message2.3', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.3', author: null },
+		{ content: 'Message3.2', author: null },
+		{ content: 'Message2.2', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.2', author: null },
+		{ content: 'Message3.1', author: null },
+		{ content: 'Message2.1', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.1', author: null },
+	]);
+});
+
+test('[Find Many .through] Get custom schema users with filtered groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsers.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get custom schema groups with filtered users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			users: {
+				where: { id: { lt: 3 } },
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get view users with posts filter by SQL.Aliased field', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts filter by joined field', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get posts with view users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users filter with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users filter by joined column with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notIlike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get posts with view users filter by SQL.Aliased with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get view users with filtered groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered view users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts filter by SQL.Aliased field', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: '0',
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get schema view users with posts filter by joined field', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get schema posts with view users with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users filter with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get schema posts with view users filter by joined column with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notIlike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get schema posts with view users filter by SQL.Aliased with posts', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(schemaPosts).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.schemaPosts.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: '0',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get schema view users with filtered groups where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get schema groups with filtered view users where', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('Filter by columns not present in select', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+		},
+		where: {
+			name: 'Dan',
+		},
+	});
+
+	expect(response).toEqual({ id: 1 });
+});
+
+test('Force optional on where on non-optional relation query', async (t) => {
+	const { pgDbV2: db } = t;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many] Get users filter users by posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts filter users by posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts filter users by existing posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts filter users by existing posts', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts filter posts by author', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: [{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}],
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async (ctx) => {
+	const { pgDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_1');
+
+	const posts = await query.execute({
+		id: 1,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_2');
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_3');
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare('w_sf_phd_4');
+
+	const posts = await query.execute({
+		id: 3,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.students.findMany({
+		with: {
+			courseOfferings: {
+				orderBy: {
+					courseId: 'asc',
+					semester: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			studentId: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		studentId: number;
+		name: string;
+		courseOfferings: {
+			courseId: number;
+			semester: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			name: 'First',
+			studentId: 1,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+				{
+					courseId: 2,
+					semester: 's2',
+				},
+			],
+		},
+		{
+			name: 'Second',
+			studentId: 2,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+			],
+		},
+		{
+			name: 'Third',
+			studentId: 3,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's2',
+				},
+				{
+					courseId: 2,
+					semester: 's3',
+				},
+				{
+					courseId: 4,
+					semester: 's4',
+				},
+			],
+		},
+		{
+			name: 'Fourth',
+			studentId: 4,
+			courseOfferings: [
+				{
+					courseId: 3,
+					semester: 's1',
+				},
+				{
+					courseId: 4,
+					semester: 's3',
+				},
+			],
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count - reverse', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.courseOfferings.findMany({
+		with: {
+			students: {
+				orderBy: {
+					studentId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			courseId: 'asc',
+			semester: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		courseId: number;
+		semester: string;
+		students: {
+			studentId: number;
+			name: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			courseId: 1,
+			semester: 's1',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+				{
+					name: 'Second',
+					studentId: 2,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's2',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's2',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's3',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's1',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 3,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's3',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 4,
+			semester: 's4',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+	]);
+});
+
+test('alltypes', async () => {
+	await db.execute(sql`CREATE TYPE "public"."en" AS ENUM('enVal1', 'enVal2');`);
+	await db.execute(sql`
+		CREATE TABLE "all_types" (
+			"serial" serial NOT NULL,
+			"bigserial53" bigserial NOT NULL,
+			"bigserial64" bigserial,
+			"int" integer,
+			"bigint53" bigint,
+			"bigint64" bigint,
+			"bigint_string" bigint,
+			"bool" boolean,
+			"bytea" bytea,
+			"char" char,
+			"cidr" "cidr",
+			"date" date,
+			"date_str" date,
+			"double" double precision,
+			"enum" "en",
+			"inet" "inet",
+			"interval" interval,
+			"json" json,
+			"jsonb" jsonb,
+			"line" "line",
+			"line_tuple" "line",
+			"macaddr" "macaddr",
+			"macaddr8" "macaddr8",
+			"numeric" numeric,
+			"numeric_num" numeric,
+			"numeric_big" numeric,
+			"point" "point",
+			"point_tuple" "point",
+			"real" real,
+			"smallint" smallint,
+			"smallserial" "smallserial" NOT NULL,
+			"text" text,
+			"time" time,
+			"timestamp" timestamp,
+			"timestamp_tz" timestamp with time zone,
+			"timestamp_str" timestamp,
+			"timestamp_tz_str" timestamp with time zone,
+			"uuid" uuid,
+			"varchar" varchar,
+			"arrint" integer[],
+			"arrbigint53" bigint[],
+			"arrbigint64" bigint[],
+			"arrbigint_string" bigint[],
+			"arrbool" boolean[],
+			"arrbytea" bytea[],
+			"arrchar" char[],
+			"arrcidr" "cidr"[],
+			"arrdate" date[],
+			"arrdate_str" date[],
+			"arrdouble" double precision[],
+			"arrenum" "en"[],
+			"arrinet" "inet"[],
+			"arrinterval" interval[],
+			"arrjson" json[],
+			"arrjsonb" jsonb[],
+			"arrline" "line"[],
+			"arrline_tuple" "line"[],
+			"arrmacaddr" "macaddr"[],
+			"arrmacaddr8" "macaddr8"[],
+			"arrnumeric" numeric[],
+			"arrnumeric_num" numeric[],
+			"arrnumeric_big" numeric[],
+			"arrpoint" "point"[],
+			"arrpoint_tuple" "point"[],
+			"arrreal" real[],
+			"arrsmallint" smallint[],
+			"arrtext" text[],
+			"arrtime" time[],
+			"arrtimestamp" timestamp[],
+			"arrtimestamp_tz" timestamp with time zone[],
+			"arrtimestamp_str" timestamp[],
+			"arrtimestamp_tz_str" timestamp with time zone[],
+			"arruuid" uuid[],
+			"arrvarchar" varchar[]
+		);
+	`);
+
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		smallserial: 15,
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintString: '5044565289845416380',
+		bigserial53: 9007199254740991,
+		bigserial64: 5044565289845416380n,
+		bool: true,
+		bytea: Buffer.from('BYTES'),
+		char: 'c',
+		cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+		inet: '192.168.0.1/24',
+		macaddr: '08:00:2b:01:02:03',
+		macaddr8: '08:00:2b:01:02:03:04:05',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString(),
+		double: 15.35325689124218,
+		enum: 'enVal1',
+		int: 621,
+		interval: '2 months ago',
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		jsonb: {
+			str: 'strvalb',
+			arr: ['strb', 11],
+		},
+		line: {
+			a: 1,
+			b: 2,
+			c: 3,
+		},
+		lineTuple: [1, 2, 3],
+		numeric: '475452353476',
+		numericNum: 9007199254740991,
+		numericBig: 5044565289845416380n,
+		point: {
+			x: 24.5,
+			y: 49.6,
+		},
+		pointTuple: [57.2, 94.3],
+		real: 1.048596,
+		smallint: 10,
+		text: 'TEXT STRING',
+		time: '13:59:28',
+		timestamp: new Date(1741743161623),
+		timestampTz: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString(),
+		timestampTzStr: new Date(1741743161623).toISOString(),
+		uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+		varchar: 'C4-',
+		arrbigint53: [9007199254740991],
+		arrbigint64: [5044565289845416380n],
+		arrbigintString: ['5044565289845416380'],
+		arrbool: [true],
+		arrbytea: [Buffer.from('BYTES')],
+		arrchar: ['c'],
+		arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+		arrinet: ['192.168.0.1/24'],
+		arrmacaddr: ['08:00:2b:01:02:03'],
+		arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+		arrdate: [new Date(1741743161623)],
+		arrdateStr: [new Date(1741743161623).toISOString()],
+		arrdouble: [15.35325689124218],
+		arrenum: ['enVal1'],
+		arrint: [621],
+		arrinterval: ['2 months ago'],
+		arrjson: [{
+			str: 'strval',
+			arr: ['str', 10],
+		}],
+		arrjsonb: [{
+			str: 'strvalb',
+			arr: ['strb', 11],
+		}],
+		arrline: [{
+			a: 1,
+			b: 2,
+			c: 3,
+		}],
+		arrlineTuple: [[1, 2, 3]],
+		arrnumeric: ['475452353476'],
+		arrnumericNum: [9007199254740991],
+		arrnumericBig: [5044565289845416380n],
+		arrpoint: [{
+			x: 24.5,
+			y: 49.6,
+		}],
+		arrpointTuple: [[57.2, 94.3]],
+		arrreal: [1.048596],
+		arrsmallint: [10],
+		arrtext: ['TEXT STRING'],
+		arrtime: ['13:59:28'],
+		arrtimestamp: [new Date(1741743161623)],
+		arrtimestampTz: [new Date(1741743161623)],
+		arrtimestampStr: [new Date(1741743161623).toISOString()],
+		arrtimestampTzStr: [new Date(1741743161623).toISOString()],
+		arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+		arrvarchar: ['C4-'],
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			serial: 1,
+			bigserial53: 9007199254740991,
+			bigserial64: 5044565289845416380n,
+			int: 621,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			bool: true,
+			bytea: Buffer.from('BYTES'),
+			char: 'c',
+			cidr: '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			double: 15.35325689124218,
+			enum: 'enVal1',
+			inet: '192.168.0.1/24',
+			interval: '-2 mons',
+			json: { str: 'strval', arr: ['str', 10] },
+			jsonb: { arr: ['strb', 11], str: 'strvalb' },
+			line: { a: 1, b: 2, c: 3 },
+			lineTuple: [1, 2, 3],
+			macaddr: '08:00:2b:01:02:03',
+			macaddr8: '08:00:2b:01:02:03:04:05',
+			numeric: '475452353476',
+			numericNum: 9007199254740991,
+			numericBig: 5044565289845416380n,
+			point: { x: 24.5, y: 49.6 },
+			pointTuple: [57.2, 94.3],
+			real: 1.048596,
+			smallint: 10,
+			smallserial: 15,
+			text: 'TEXT STRING',
+			time: '13:59:28',
+			timestamp: new Date('2025-03-12T01:32:41.623Z'),
+			timestampTz: new Date('2025-03-12T01:32:41.623Z'),
+			timestampStr: '2025-03-12 01:32:41.623',
+			timestampTzStr: '2025-03-12 01:32:41.623+00',
+			uuid: 'b77c9eef-8e28-4654-88a1-7221b46d2a1c',
+			varchar: 'C4-',
+			arrint: [621],
+			arrbigint53: [9007199254740991],
+			arrbigint64: [5044565289845416380n],
+			arrbigintString: ['5044565289845416380'],
+			arrbool: [true],
+			arrbytea: [Buffer.from('BYTES')],
+			arrchar: ['c'],
+			arrcidr: ['2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'],
+			arrdate: [new Date('2025-03-12T00:00:00.000Z')],
+			arrdateStr: ['2025-03-12'],
+			arrdouble: [15.35325689124218],
+			arrenum: ['enVal1'],
+			arrinet: ['192.168.0.1/24'],
+			arrinterval: ['-2 mons'],
+			arrjson: [{ str: 'strval', arr: ['str', 10] }],
+			arrjsonb: [{ arr: ['strb', 11], str: 'strvalb' }],
+			arrline: [{ a: 1, b: 2, c: 3 }],
+			arrlineTuple: [[1, 2, 3]],
+			arrmacaddr: ['08:00:2b:01:02:03'],
+			arrmacaddr8: ['08:00:2b:01:02:03:04:05'],
+			arrnumeric: ['475452353476'],
+			arrnumericNum: [9007199254740991],
+			arrnumericBig: [5044565289845416380n],
+			arrpoint: [{ x: 24.5, y: 49.6 }],
+			arrpointTuple: [[57.2, 94.3]],
+			arrreal: [1.048596],
+			arrsmallint: [10],
+			arrtext: ['TEXT STRING'],
+			arrtime: ['13:59:28'],
+			arrtimestamp: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampTz: [new Date('2025-03-12T01:32:41.623Z')],
+			arrtimestampStr: ['2025-03-12 01:32:41.623'],
+			arrtimestampTzStr: ['2025-03-12 01:32:41.623+00'],
+			arruuid: ['b77c9eef-8e28-4654-88a1-7221b46d2a1c'],
+			arrvarchar: ['C4-'],
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	await db.execute(sql`
+		CREATE TABLE "custom_types" (
+			"id" serial,
+			"big" bigint,
+			"big_arr" bigint[],
+			"big_mtx" bigint[][],
+			"bytes" bytea,
+			"bytes_arr" bytea[],
+			"bytes_mtx" bytea[][],
+			"time" timestamp(3),
+			"time_arr" timestamp(3)[],
+			"time_mtx" timestamp(3)[][],
+			"int" integer,
+			"int_arr" integer[],
+			"int_mtx" integer[][]
+		);
+	`);
+
+	await db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bigArr: [5044565289845416380n],
+		bigMtx: [[5044565289845416380n]],
+		bytes: Buffer.from('BYTES'),
+		bytesArr: [Buffer.from('BYTES')],
+		bytesMtx: [[Buffer.from('BYTES')]],
+		time: new Date(1741743161623),
+		timeArr: [new Date(1741743161623)],
+		timeMtx: [[new Date(1741743161623)]],
+		int: 250,
+		intArr: [250],
+		intMtx: [[250]],
+	});
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number;
+		big: bigint | null;
+		bigArr: bigint[] | null;
+		bigMtx: bigint[][] | null;
+		bytes: Buffer | null;
+		bytesArr: Buffer[] | null;
+		bytesMtx: Buffer[][] | null;
+		time: Date | null;
+		timeArr: Date[] | null;
+		timeMtx: Date[][] | null;
+		int: number | null;
+		intArr: number[] | null;
+		intMtx: number[][] | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bigArr: [5044565289845416380n],
+			bigMtx: [[5044565289845416380n]],
+			bytes: Buffer.from('BYTES'),
+			bytesArr: [Buffer.from('BYTES')],
+			bytesMtx: [[Buffer.from('BYTES')]],
+			time: new Date(1741743161623),
+			timeArr: [new Date(1741743161623)],
+			timeMtx: [[new Date(1741743161623)]],
+			int: 250,
+			intArr: [250],
+			intMtx: [[250]],
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/pg/pglite.test.ts b/integration-tests/tests/pg/pglite.test.ts
index 560b24490b..848afd89e7 100644
--- a/integration-tests/tests/pg/pglite.test.ts
+++ b/integration-tests/tests/pg/pglite.test.ts
@@ -1,129 +1,222 @@
-import { PGlite } from '@electric-sql/pglite';
 import { Name, sql } from 'drizzle-orm';
-import { drizzle, type PgliteDatabase } from 'drizzle-orm/pglite';
+import { getTableConfig, integer, pgTable, serial, text } from 'drizzle-orm/pg-core';
 import { migrate } from 'drizzle-orm/pglite/migrator';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
-import { tests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: PgliteDatabase;
-let dbGlobalCached: PgliteDatabase;
-let cachedDb: PgliteDatabase;
-let client: PGlite;
-
-beforeAll(async () => {
-	client = new PGlite();
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestCache(),
-	});
-	dbGlobalCached = drizzle(client, {
-		logger: ENABLE_LOGGING,
-		cache: new TestGlobalCache(),
-	});
-});
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe, expect } from 'vitest';
+import { tests } from './common';
+import { pgliteTest as test } from './instrumentation';
+import { usersMigratorTable, usersTable } from './schema';
 
-afterAll(async () => {
-	await client?.close();
-});
+tests(test, []);
 
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
+describe('pglite', () => {
+	test('migrator : default migration strategy', async ({ db }) => {
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(
+			sql`drop table if exists users12`,
+		);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(
-		sql`drop table if exists users12`,
-	);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
 
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
 
-	const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+	});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
+	test('insert via db.execute + select via db.execute', async ({ db }) => {
+		await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
 
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+		const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
+		expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
-	expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('insert via db.execute + returning', async ({ db }) => {
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${new Name(
+				usersTable.name.name,
+			)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute + returning', async () => {
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${new Name(
-			usersTable.name.name,
-		)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('insert via db.execute w/ query builder', async ({ db }) => {
+		const result = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
+	});
 
-test('insert via db.execute w/ query builder', async () => {
-	const result = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(Array.prototype.slice.call(result.rows)).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('migrator : --init', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+					SELECT 1
+					FROM pg_tables
+					WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+				) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
 
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-	'view',
-	'materialized view',
-	'subquery with view',
-	'mySchema :: materialized view',
-	'select count()',
-	// not working in 0.2.12
-	'select with group by as sql + column',
-	'select with group by as column + sql',
-	'mySchema :: select with group by as column + sql',
-]);
-
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false,
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+					SELECT 1
+					FROM pg_tables
+					WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+				) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res.rows[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+					SELECT 1
+					FROM pg_tables
+					WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+				) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res.rows[0]?.tableExists).toStrictEqual(true);
+	});
+
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+		const users = pgTable('migration_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		const users2 = pgTable('migration_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
+
+		await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/pglite';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
+	});
 });
diff --git a/integration-tests/tests/pg/postgres-js.test.ts b/integration-tests/tests/pg/postgres-js.test.ts
index ee48d3eb42..9d10802775 100644
--- a/integration-tests/tests/pg/postgres-js.test.ts
+++ b/integration-tests/tests/pg/postgres-js.test.ts
@@ -1,490 +1,601 @@
-import retry from 'async-retry';
-import type { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import { drizzle } from 'drizzle-orm/postgres-js';
-import postgres, { type Sql } from 'postgres';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-
 import { Name, sql } from 'drizzle-orm';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
+import { boolean, getTableConfig, integer, jsonb, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
 import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import { skipTests } from '~/common';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe } from 'node:test';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
-import { createDockerDB, tests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: PostgresJsDatabase;
-let dbGlobalCached: PostgresJsDatabase;
-let cachedDb: PostgresJsDatabase;
-let client: Sql;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['PG_CONNECTION_STRING']) {
-		connectionString = process.env['PG_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = postgres(connectionString, {
-			max: 1,
-			onnotice: () => {
-				// disable notices
-			},
-		});
-		await client`select 1`;
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
+import { tests } from './common';
+import { postgresjsTest as test } from './instrumentation';
+import { usersMigratorTable } from './schema';
 
-afterAll(async () => {
-	await client?.end();
-});
+tests(test, []);
 
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
+describe('postgresjs', () => {
+	test('migrator : default migration strategy', async ({ db }) => {
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg' });
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
 
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
 
-	const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+	});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
+	test('migrator : migrate with custom schema', async ({ db }) => {
+		const customSchema = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-test('migrator : migrate with custom schema', async () => {
-	const customSchema = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: customSchema });
+		// test if the custom migrations table was created
+		const { count } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
+		expect(count > 0).toBeTruthy();
 
-	// test if the custom migrations table was created
-	const { count } = await db.execute(sql`select * from ${sql.identifier(customSchema)}."__drizzle_migrations";`);
-	expect(count > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
+	});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table ${sql.identifier(customSchema)}."__drizzle_migrations"`);
-});
+	test('migrator : migrate with custom table', async ({ db }) => {
+		const customTable = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
 
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+		await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
 
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+		// test if the custom migrations table was created
+		const { count } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+		expect(count > 0).toBeTruthy();
 
-	// test if the custom migrations table was created
-	const { count } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(count > 0).toBeTruthy();
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
+	});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
+	test('migrator : migrate with custom table and custom schema', async ({ db }) => {
+		const customTable = randomString();
+		const customSchema = randomString();
+		await db.execute(sql`drop table if exists all_columns`);
+		await db.execute(sql`drop table if exists users12`);
+		await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable: customTable,
+			migrationsSchema: customSchema,
+		});
 
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	const customSchema = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: customSchema,
-	});
+		// test if the custom migrations table was created
+		const { count } = await db.execute(
+			sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
+		);
+		expect(count > 0).toBeTruthy();
+
+		// test if the migrated table are working as expected
+		await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+		const result = await db.select().from(usersMigratorTable);
+		expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-	// test if the custom migrations table was created
-	const { count } = await db.execute(
-		sql`select * from ${sql.identifier(customSchema)}.${sql.identifier(customTable)};`,
-	);
-	expect(count > 0).toBeTruthy();
+		await db.execute(sql`drop table all_columns`);
+		await db.execute(sql`drop table users12`);
+		await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
+	});
 
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+		const users = pgTable('migration_users', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
 
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table ${sql.identifier(customSchema)}.${sql.identifier(customTable)}`);
-});
+		const users2 = pgTable('migration_users2', {
+			id: serial('id').primaryKey(),
+			name: text().notNull(),
+			email: text().notNull(),
+			age: integer(),
+		});
 
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		await db.execute(sql`drop schema if exists "drizzle" cascade;`);
+		await db.execute(sql`drop table if exists ${users}`);
+		await db.execute(sql`drop table if exists ${users2}`);
+
+		// create migration directory
+		const migrationDir = './migrations/postgres-js';
+		if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+		mkdirSync(migrationDir, { recursive: true });
+
+		// first branch
+		mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240101010101_initial/migration.sql`,
+			`CREATE TABLE "migration_users" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+		);
+		mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240303030303_third/migration.sql`,
+			`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+		);
+
+		await migrate(db, { migrationsFolder: migrationDir });
+		const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+		// second migration was not applied yet
+		await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+		// insert migration with earlier timestamp
+		mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+		writeFileSync(
+			`${migrationDir}/20240202020202_second/migration.sql`,
+			`CREATE TABLE "migration_users2" (\n"id" serial PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+		);
+		await migrate(db, { migrationsFolder: migrationDir });
+
+		const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+		const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+		expect(res1).toStrictEqual(expected);
+		expect(res2).toStrictEqual(expected);
+
+		rmSync(migrationDir, { recursive: true });
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone first case mode string', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`
+		await db.execute(sql`drop table if exists ${table}`);
+
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
-
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
+		// 1. Insert date in string format without timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01 02:00:00.123456' },
+		]);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+		// 2, Select in string format and check that values are the same
+		const result = await db.select().from(table);
 
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
 
-	expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		// 3. Select as raw query and check that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone second case mode string', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) not null
 			)
 	`);
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: '2022-01-01T02:00:00.123456-02' },
+		]);
 
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select as raw query and check that values are the same
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect([...result]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+		expect([...result]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('all date and time columns without timezone third case mode date', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+		});
 
-	await db.execute(sql`
+		await db.execute(sql`drop table if exists ${table}`);
+
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) not null
 			)
 	`);
 
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+		const insertedDate = new Date('2022-01-01 20:00:00.123+04');
 
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
+		// 1. Insert date as new date
+		await db.insert(table).values([
+			{ timestamp: insertedDate },
+		]);
 
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 2, Select as raw query as string
+		const result = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+		// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+		expect(new Date(result[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode string for timestamp with timezone', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		await db.execute(sql`drop table if exists ${table}`);
 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+	test('test mode date for timestamp with timezone', async ({ db }) => {
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+		});
+
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(3) with time zone not null
 			)
 	`);
 
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+		const timestampString = new Date('2022-01-01 00:00:00.456-0200');
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const [timezone] = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test('test mode string for timestamp with timezone in UTC timezone', async ({ db }) => {
+		// get current timezone from db
+		const [timezone] = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
+		// set timezone to UTC
+		await db.execute(sql`set time zone 'UTC'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+		const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+		// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+		// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+		expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-test('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const [timezone] = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+	test('test mode string for timestamp with timezone in different timezone', async ({ db }) => {
+		// get current timezone from db
+		const [timezone] = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
+		// set timezone to HST (UTC - 10)
+		await db.execute(sql`set time zone '-10'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
+		const table = pgTable('all_columns', {
+			id: serial('id').primaryKey(),
+			timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+		});
 
-	await db.execute(sql`drop table if exists ${table}`);
+		await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
+		await db.execute(sql`
 		create table ${table} (
 					id serial primary key,
 					timestamp_string timestamp(6) with time zone not null
 			)
 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
+		const timestampString = '2022-01-01 00:00:00.123456-1000';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+		// 1. Insert date in string format with timezone in it
+		await db.insert(table).values([
+			{ timestamp: timestampString },
+		]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+		// 2. Select date in string format and check that the values are the same
+		const result = await db.select().from(table);
 
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+		expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+		// 3. Select as raw query and checke that values are the same
+		const result2 = await db.execute<{
+			id: number;
+			timestamp_string: string;
+		}>(sql`select * from ${table}`);
 
-	expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
+		expect([...result2]).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
 
-	await db.execute(sql`set time zone '${sql.raw(timezone!.TimeZone)}'`);
+		await db.execute(sql`set time zone '${sql.raw(timezone!.TimeZone)}'`);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+		await db.execute(sql`drop table if exists ${table}`);
+	});
 
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-]);
-
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
+	test('insert via db.execute + select via db.execute', async ({ db, push }) => {
+		const usersTable = pgTable('users2', {
+			id: serial('id' as string).primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: jsonb('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+		});
+		await push({ usersTable });
 
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+		await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
 
-	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from "users"`);
-	expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
-});
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`select id, name from "users2";`,
+		);
+		expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
+		await db.execute(sql`drop table ${usersTable};`);
+	});
 
-test('insert via db.execute + returning', async () => {
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${new Name(
-			usersTable.name.name,
-		)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
-});
+	test('insert via db.execute + returning', async ({ db, push }) => {
+		const usersTable = pgTable('users3', {
+			id: serial('id' as string).primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: jsonb('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+		});
+		await push({ usersTable });
+
+		const result = await db.execute<{ id: number; name: string }>(
+			sql`insert into ${usersTable} (${new Name(
+				usersTable.name.name,
+			)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+		);
+		expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
+		await db.execute(sql`drop table ${usersTable};`);
+	});
+
+	test('insert via db.execute w/ query builder', async ({ db, push }) => {
+		const usersTable = pgTable('users4', {
+			id: serial('id' as string).primaryKey(),
+			name: text('name').notNull(),
+			verified: boolean('verified').notNull().default(false),
+			jsonb: jsonb('jsonb').$type<string[]>(),
+			createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+		});
+		await push({ usersTable });
+		const result = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+			db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+		);
+		expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
+		await db.execute(sql`drop table ${usersTable};`);
+	});
 
-test('insert via db.execute w/ query builder', async () => {
-	const result = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(Array.prototype.slice.call(result)).toEqual([{ id: 1, name: 'John' }]);
+	test('migrator : --init', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual(undefined);
+		expect(meta.length).toStrictEqual(1);
+		expect(res[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - local migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+		expect(meta.length).toStrictEqual(0);
+		expect(res[0]?.tableExists).toStrictEqual(false);
+	});
+
+	test('migrator : --init - db migrations error', async ({ db }) => {
+		const migrationsSchema = 'drzl_migrations_init';
+		const migrationsTable = 'drzl_init';
+
+		await db.execute(sql`drop schema if exists ${sql.identifier(migrationsSchema)} cascade;`);
+		await db.execute(sql`drop schema if exists public cascade`);
+		await db.execute(sql`create schema public`);
+
+		await migrate(db, {
+			migrationsFolder: './drizzle2/pg-init',
+			migrationsSchema,
+			migrationsTable,
+		});
+
+		const migratorRes = await migrate(db, {
+			migrationsFolder: './drizzle2/pg',
+			migrationsTable,
+			migrationsSchema,
+			// @ts-ignore - internal param
+			init: true,
+		});
+
+		const meta = await db.select({
+			hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+			createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+		}).from(sql`${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)}`);
+
+		const res = await db.execute<{ tableExists: boolean }>(sql`SELECT EXISTS (
+				SELECT 1
+				FROM pg_tables
+				WHERE schemaname = ${getTableConfig(usersMigratorTable).schema ?? 'public'} AND tablename = ${
+			getTableConfig(usersMigratorTable).name
+		}
+			) as ${sql.identifier('tableExists')};`);
+
+		expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+		expect(meta.length).toStrictEqual(1);
+		expect(res[0]?.tableExists).toStrictEqual(true);
+	});
 });
diff --git a/integration-tests/tests/pg/relations.ts b/integration-tests/tests/pg/relations.ts
new file mode 100644
index 0000000000..7457696318
--- /dev/null
+++ b/integration-tests/tests/pg/relations.ts
@@ -0,0 +1,14 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './schema';
+
+export const relations = defineRelations(schema, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/pg/replicas.test.ts b/integration-tests/tests/pg/replicas.test.ts
new file mode 100644
index 0000000000..3bb1b7ad8e
--- /dev/null
+++ b/integration-tests/tests/pg/replicas.test.ts
@@ -0,0 +1,936 @@
+import { defineRelations, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean, jsonb, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { withReplicas } from 'drizzle-orm/pg-core';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = pgTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+const users = pgTable('users', {
+	id: serial('id' as string).primaryKey(),
+});
+
+describe('[select] read replicas postgres', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query = db.$primary.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual('select "id" from "users"');
+
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(query1.toSQL().sql).toEqual('select count(*) as "count" from "users" limit $1');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select({ id: users.id }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.$primary.select().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.select().from(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+});
+
+describe('[selectDistinct] read replicas postgres', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query = db.$primary.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.$primary.selectDistinct().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+});
+
+describe('[with] read replicas postgres', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+		const obj4 = {} as any;
+
+		db.$primary.with(obj1, obj2, obj3, obj4);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+
+		db.with(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		db.with(obj2, obj3);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
+	});
+});
+
+describe('[update] replicas postgres', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		const query1 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('update "users" set "id" = $1');
+
+		const query2 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('update "users" set "id" = $1');
+
+		const query3 = db.$primary.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query3.toSQL().sql).toEqual('update "users" set "id" = $1');
+	});
+});
+
+describe('[delete] replicas postgres', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		const query1 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query1.toSQL().sql).toEqual('delete from "users"');
+
+		const query2 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+		expect(query2.toSQL().sql).toEqual('delete from "users"');
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas postgres', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		const query = db.insert(users).values({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query.toSQL().sql).toEqual('insert into "users" ("id") values ($1)');
+
+		db.insert(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas postgres', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		expect(db.execute(sql``)).rejects.toThrow();
+
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas postgres', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const txFn1 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn1)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
+
+		const txFn2 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn2)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findFirst] read replicas postgres', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const obj = {} as any;
+
+		db.$primary.query.usersTable.findFirst(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const par1 = {} as any;
+
+		db.query.usersTable.findFirst(par1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(par1);
+
+		const query = db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0" limit $1',
+		);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas postgres', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj = {} as any;
+
+		const query = db.$primary.query.usersTable.findMany(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+		expect(query.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+		expect(spyRead2).toHaveBeenCalledWith(obj2);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+
+		const query2 = db.$primary.query.usersTable.findMany(obj2);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified", "d0"."jsonb" as "jsonb", "d0"."created_at" as "createdAt" from "users" as "d0"',
+		);
+	});
+});
+
+describe('[$count] read replicas postgres', () => {
+	it('primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$primary.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('single read replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$count(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica $count + primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.$count(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$count(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/tests/pg/schema.ts b/integration-tests/tests/pg/schema.ts
new file mode 100644
index 0000000000..b9dfefe43c
--- /dev/null
+++ b/integration-tests/tests/pg/schema.ts
@@ -0,0 +1,75 @@
+import { sql } from 'drizzle-orm';
+import { boolean, integer, jsonb, pgSchema, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { PgAsyncDatabase } from 'drizzle-orm/pg-core/async/db';
+
+export const rqbUser = pgTable('user_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+		precision: 3,
+	}).notNull(),
+});
+
+export const rqbPost = pgTable('post_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+		precision: 3,
+	}).notNull(),
+});
+
+export const postsTable = pgTable('posts', {
+	id: serial().primaryKey(),
+	description: text().notNull(),
+	userId: integer('city_id').references(() => usersTable.id),
+});
+
+export const usersMigratorTable = pgTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const usersTable = pgTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const mySchema = pgSchema('mySchema');
+
+export const usersMySchemaTable = mySchema.table('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const init = async (db: PgAsyncDatabase<any, any>) => {
+	await db.execute(sql`
+		CREATE TABLE ${rqbUser} (
+		        "id" SERIAL PRIMARY KEY NOT NULL,
+		        "name" TEXT NOT NULL,
+		        "created_at" TIMESTAMP(3) NOT NULL
+		     )
+	`);
+	await db.execute(sql`
+		CREATE TABLE ${rqbPost} ( 
+		        "id" SERIAL PRIMARY KEY NOT NULL,
+		        "user_id" INT NOT NULL,
+		        "content" TEXT,
+		        "created_at" TIMESTAMP(3) NOT NULL
+		)
+	`);
+};
+
+export const clear = async (db: PgAsyncDatabase<any, any>) => {
+	await db.execute(sql`DROP TABLE IF EXISTS ${rqbUser} CASCADE;`).catch(() => null);
+	await db.execute(sql`DROP TABLE IF EXISTS ${rqbPost} CASCADE;`).catch(() => null);
+};
diff --git a/integration-tests/tests/pg/utils.test.ts b/integration-tests/tests/pg/utils.test.ts
new file mode 100644
index 0000000000..fb0591fea1
--- /dev/null
+++ b/integration-tests/tests/pg/utils.test.ts
@@ -0,0 +1,454 @@
+import { is, SQL, sql } from 'drizzle-orm';
+import { usersSync } from 'drizzle-orm/neon';
+import { authenticatedRole, crudPolicy } from 'drizzle-orm/neon/rls';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import {
+	boolean,
+	char,
+	foreignKey,
+	getTableConfig,
+	index,
+	integer,
+	jsonb,
+	PgDialect,
+	PgPolicy,
+	pgPolicy,
+	pgTable,
+	primaryKey,
+	serial,
+	text,
+	timestamp,
+	unique,
+} from 'drizzle-orm/pg-core';
+import { expect, test } from 'vitest';
+
+const db = drizzle.mock();
+
+test('table configs: unique third param', async () => {
+	const cities1Table = pgTable(
+		'cities1',
+		{
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+			state: char('state', { length: 2 }),
+		},
+		(
+			t,
+		) => [unique('custom_name').on(t.name, t.state).nullsNotDistinct(), unique('custom_name1').on(t.name, t.state)],
+	);
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+	expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
+	expect(tableConfig.uniqueConstraints[0]?.nullsNotDistinct).toBe(true);
+	expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+
+	expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
+	expect(tableConfig.uniqueConstraints[1]?.nullsNotDistinct).toBe(false);
+	expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+});
+
+test('table configs: unique in column', async () => {
+	const cities1Table = pgTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull().unique(),
+		state: char('state', { length: 2 }).unique('custom'),
+		field: char('field', { length: 2 }).unique('custom_field', { nulls: 'not distinct' }),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+
+	expect(columnName?.uniqueName).toBe(undefined);
+	expect(columnName?.isUnique).toBe(true);
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	expect(columnState?.uniqueName).toBe('custom');
+	expect(columnState?.isUnique).toBe(true);
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	expect(columnField?.uniqueName).toBe('custom_field');
+	expect(columnField?.isUnique).toBe(true);
+	expect(columnField?.uniqueType).toBe('not distinct');
+});
+
+test('table config: foreign keys name', async () => {
+	const table = pgTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => [foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' })]);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.foreignKeys).toHaveLength(1);
+	expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
+});
+
+test('table config: primary keys name', async () => {
+	const table = pgTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => [primaryKey({ columns: [t.id, t.name], name: 'custom_pk' })]);
+
+	const tableConfig = getTableConfig(table);
+
+	expect(tableConfig.primaryKeys).toHaveLength(1);
+	expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
+});
+
+test('Query check: Insert all defaults in 1 row', async () => {
+	const users = pgTable('users_40', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	const query = db
+		.insert(users)
+		.values({})
+		.toSQL();
+
+	expect(query).toEqual({
+		sql: 'insert into "users_40" ("id", "name", "state") values (default, default, default)',
+		params: [],
+	});
+});
+
+test('Query check: Insert all defaults in multiple rows', async () => {
+	const users = pgTable('users_41', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state').default('UA'),
+	});
+
+	const query = db
+		.insert(users)
+		.values([{}, {}])
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users_41" ("id", "name", "state") values (default, default, default), (default, default, default)',
+		params: [],
+	});
+});
+
+test.concurrent('build query insert with onConflict do update', async () => {
+	const usersTable = pgTable('users_44', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: jsonb('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+	});
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users_44" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test('build query insert with onConflict do update / multiple columns', async () => {
+	const usersTable = pgTable('users_45', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: jsonb('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+	});
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users_45" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test.concurrent('build query insert with onConflict do nothing', async () => {
+	const usersTable = pgTable('users_46', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: jsonb('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+	});
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing()
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users_46" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test.concurrent('build query insert with onConflict do nothing + target', async () => {
+	const usersTable = pgTable('users_47', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		verified: boolean('verified').notNull().default(false),
+		jsonb: jsonb('jsonb').$type<string[]>(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+	});
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing({ target: usersTable.id })
+		.toSQL();
+
+	expect(query).toEqual({
+		sql:
+			'insert into "users_47" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test('select a field without joining its table', () => {
+	const usersTable = pgTable('users_60', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const users2Table = pgTable('users2_60', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare('query')).toThrowError();
+});
+
+test('select all fields from subquery without alias', () => {
+	const users2Table = pgTable('users2_61', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+	expect(() => db.select().from(sq).prepare('query')).toThrowError();
+});
+
+test('select for ...', () => {
+	const users2Table = pgTable('users2_66', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const coursesTable = pgTable('courses_66', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		expect(query.sql).toMatch(/ for update$/);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		expect(query.sql).toMatch(/ for update of "users2_66", "courses_66"$/);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		expect(query.sql).toMatch(/for no key update of "users2_66"$/);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		expect(query.sql).toMatch(/ for no key update of "users2_66" skip locked$/);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		expect(query.sql).toMatch(/for share of "users2_66" nowait$/);
+	}
+});
+
+test('orderBy with aliased column', () => {
+	const users2Table = pgTable('users2_70', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	const query = db.select({
+		test: sql`something`.as('test'),
+	}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+	expect(query.sql).toBe('select something as "test" from "users2_70" order by "test"');
+});
+
+test('policy', () => {
+	{
+		const policy = pgPolicy('test policy');
+
+		expect(is(policy, PgPolicy)).toBe(true);
+		expect(policy.name).toBe('test policy');
+	}
+
+	{
+		const policy = pgPolicy('test policy', {
+			as: 'permissive',
+			for: 'all',
+			to: 'public',
+			using: sql`1=1`,
+			withCheck: sql`1=1`,
+		});
+
+		expect(is(policy, PgPolicy)).toBe(true);
+		expect(policy.name).toBe('test policy');
+		expect(policy.as).toBe('permissive');
+		expect(policy.for).toBe('all');
+		expect(policy.to).toBe('public');
+		const dialect = new PgDialect();
+		expect(is(policy.using, SQL)).toBe(true);
+		expect(dialect.sqlToQuery(policy.using!).sql).toBe('1=1');
+		expect(is(policy.withCheck, SQL)).toBe(true);
+		expect(dialect.sqlToQuery(policy.withCheck!).sql).toBe('1=1');
+	}
+
+	{
+		const policy = pgPolicy('test policy', {
+			to: 'custom value',
+		});
+
+		expect(policy.to).toBe('custom value');
+	}
+
+	{
+		const p1 = pgPolicy('test policy');
+		const p2 = pgPolicy('test policy 2', {
+			as: 'permissive',
+			for: 'all',
+			to: 'public',
+			using: sql`1=1`,
+			withCheck: sql`1=1`,
+		});
+		const table = pgTable('table_with_policy', {
+			id: serial('id').primaryKey(),
+			name: text('name').notNull(),
+		}, () => [
+			p1,
+			p2,
+		]);
+		const config = getTableConfig(table);
+		expect(config.policies).toHaveLength(2);
+		expect(config.policies[0]).toBe(p1);
+		expect(config.policies[1]).toBe(p2);
+	}
+});
+
+test('neon: policy', () => {
+	{
+		const policy = crudPolicy({
+			read: true,
+			modify: true,
+			role: authenticatedRole,
+		});
+
+		for (const it of Object.values(policy)) {
+			expect(is(it, PgPolicy)).toBe(true);
+			expect(it?.to).toStrictEqual(authenticatedRole);
+			it?.using ? expect(it.using).toStrictEqual(sql`true`) : '';
+			it?.withCheck ? expect(it.withCheck).toStrictEqual(sql`true`) : '';
+		}
+	}
+
+	{
+		const table = pgTable('name', {
+			id: integer('id'),
+		}, (t) => [
+			index('name').on(t.id),
+			crudPolicy({
+				read: true,
+				modify: true,
+				role: authenticatedRole,
+			}),
+			primaryKey({ columns: [t.id], name: 'custom' }),
+		]);
+
+		const { policies, indexes, primaryKeys } = getTableConfig(table);
+
+		expect(policies.length).toBe(4);
+		expect(indexes.length).toBe(1);
+		expect(primaryKeys.length).toBe(1);
+
+		expect(policies[0]?.name === 'crud-custom-policy-modify');
+		expect(policies[1]?.name === 'crud-custom-policy-read');
+	}
+});
+
+test('neon: neon_auth', () => {
+	const usersSyncTable = usersSync;
+
+	const { columns, schema, name } = getTableConfig(usersSyncTable);
+
+	expect(name).toBe('users_sync');
+	expect(schema).toBe('neon_auth');
+	expect(columns).toHaveLength(7);
+});
+
+test('Enable RLS function', () => {
+	const usersWithRLS = pgTable.withRLS('users', {
+		id: integer(),
+	});
+
+	const config1 = getTableConfig(usersWithRLS);
+
+	const usersNoRLS = pgTable('users', {
+		id: integer(),
+	});
+
+	const config2 = getTableConfig(usersNoRLS);
+
+	expect(config1.enableRLS).toBeTruthy();
+	expect(config2.enableRLS).toBeFalsy();
+});
diff --git a/integration-tests/tests/pg/utils.ts b/integration-tests/tests/pg/utils.ts
new file mode 100644
index 0000000000..06e9a3c4f6
--- /dev/null
+++ b/integration-tests/tests/pg/utils.ts
@@ -0,0 +1,37 @@
+import { Column } from 'drizzle-orm';
+import { CodecsCollection } from 'drizzle-orm/codecs';
+import { PgAsyncDatabase, PgDialect } from 'drizzle-orm/pg-core';
+import { PgEffectDatabase } from 'drizzle-orm/pg-core/effect/db';
+
+export function normalizeDataWithDbCodecs(
+	cfg: {
+		db: PgAsyncDatabase<any, any> | PgEffectDatabase<any, any, any>;
+		data: Record<string, unknown>[] | string;
+		columns: Record<string, Column>;
+		mode: 'json' | 'query';
+	},
+) {
+	const { db, data: rawData, columns, mode } = cfg;
+	const dialect = (<any> db).dialect as PgDialect;
+	const codecs = (<any> dialect).codecs as CodecsCollection;
+	const data = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
+
+	const dbNamedColumns = Object.values(columns).map((c) => {
+		return [c.name, c];
+	}) as [string, Column][];
+
+	const res: Record<string, any>[] = [];
+	for (const item of data) {
+		const current: Record<string, any> = {};
+
+		for (const [k, v] of dbNamedColumns) {
+			current[k] = item[k] === null
+				? item[k]
+				: codecs.apply(v, mode === 'query' ? 'normalize' : 'normalizeInJson', item[k]!);
+		}
+
+		res.push(current);
+	}
+
+	return res;
+}
diff --git a/integration-tests/tests/pg/vercel-pg.test.ts b/integration-tests/tests/pg/vercel-pg.test.ts
deleted file mode 100644
index 3499b0eed8..0000000000
--- a/integration-tests/tests/pg/vercel-pg.test.ts
+++ /dev/null
@@ -1,500 +0,0 @@
-import { createClient, type VercelClient } from '@vercel/postgres';
-import { sql } from 'drizzle-orm';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import { drizzle, type VercelPgDatabase } from 'drizzle-orm/vercel-postgres';
-import { migrate } from 'drizzle-orm/vercel-postgres/migrator';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
-import { randomString } from '~/utils';
-import { createDockerDB, tests, tests as cacheTests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache } from './pg-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: VercelPgDatabase;
-let dbGlobalCached: VercelPgDatabase;
-let cachedDb: VercelPgDatabase;
-let client: VercelClient;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['PG_CONNECTION_STRING']) {
-		connectionString = process.env['PG_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = createClient({ connectionString });
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.log(connectionString);
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		// await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
-
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-
-	const result = await db.select().from(usersMigratorTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
-
-test('migrator : migrate with custom schema', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsSchema: 'custom_migrations' });
-
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from custom_migrations."__drizzle_migrations";`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations."__drizzle_migrations"`);
-});
-
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
-
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(rowCount && rowCount > 0).toBeTruthy();
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
-
-test('migrator : migrate with custom table and custom schema', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, {
-		migrationsFolder: './drizzle2/pg',
-		migrationsTable: customTable,
-		migrationsSchema: 'custom_migrations',
-	});
-
-	// test if the custom migrations table was created
-	const { rowCount } = await db.execute(
-		sql`select * from custom_migrations.${sql.identifier(customTable)};`,
-	);
-	expect(rowCount && rowCount > 0).toBeTruthy();
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table custom_migrations.${sql.identifier(customTable)}`);
-});
-
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
-
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
-
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
-
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
-
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
-
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) not null
-			)
-	`);
-
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
-
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
-
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result.rows[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) with time zone not null
-			)
-	`);
-
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
-
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
-
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
-
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
-
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
-
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result2.rows).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
-
-	await db.execute(sql`set time zone '${sql.raw(timezone.rows[0]!.TimeZone)}'`);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-	'build query insert with onConflict do nothing + target', //
-	'select from tables with same name from different schema using alias', //
-]);
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
-
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
-	);
-
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expect(result.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.rows).toEqual([{ id: 1, name: 'John' }]);
-});
diff --git a/integration-tests/tests/pg/xata-http.test.ts b/integration-tests/tests/pg/xata-http.test.ts
index 2fd35072d9..8f89d715ce 100644
--- a/integration-tests/tests/pg/xata-http.test.ts
+++ b/integration-tests/tests/pg/xata-http.test.ts
@@ -1,435 +1,436 @@
-import retry from 'async-retry';
-import { sql } from 'drizzle-orm';
-import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-import { drizzle } from 'drizzle-orm/xata-http';
-import type { XataHttpClient, XataHttpDatabase } from 'drizzle-orm/xata-http';
-import { migrate } from 'drizzle-orm/xata-http/migrator';
-import { beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
-import { randomString } from '~/utils';
-import { getXataClient } from '../xata/xata.ts';
-import { tests, tests as cacheTests, usersMigratorTable, usersTable } from './pg-common';
-import { TestCache, TestGlobalCache } from './pg-common-cache.ts';
-
-const ENABLE_LOGGING = false;
-
-let db: XataHttpDatabase;
-let dbGlobalCached: XataHttpDatabase;
-let cachedDb: XataHttpDatabase;
-let client: XataHttpClient;
-
-beforeAll(async () => {
-	const apiKey = process.env['XATA_API_KEY'];
-	if (!apiKey) {
-		throw new Error('XATA_API_KEY is not defined');
-	}
-
-	client = await retry(async () => {
-		client = getXataClient();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-beforeEach((ctx) => {
-	ctx.pg = {
-		db,
-	};
-	ctx.cachedPg = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-test('migrator : default migration strategy', async () => {
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg' });
-
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-
-	const result = await db.select().from(usersMigratorTable);
-
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
-});
-
-test('migrator : migrate with custom table', async () => {
-	const customTable = randomString();
-	await db.execute(sql`drop table if exists all_columns`);
-	await db.execute(sql`drop table if exists users12`);
-	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-
-	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
-
-	// test if the custom migrations table was created
-	const { records } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
-	expect(records && records.length > 0).toBeTruthy();
-
-	// test if the migrated table are working as expected
-	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
-	const result = await db.select().from(usersMigratorTable);
-	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-	await db.execute(sql`drop table all_columns`);
-	await db.execute(sql`drop table users12`);
-	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
-});
-
-test('all date and time columns without timezone first case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
-
-	// 1. Insert date in string format without timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01 02:00:00.123456' },
-	]);
-
-	// 2, Select in string format and check that values are the same
-	const result = await db.select().from(table);
-
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
-
-	// 3. Select as raw query and check that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('all date and time columns without timezone second case mode string', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) not null
-			)
-	`);
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: '2022-01-01T02:00:00.123456-02' },
-	]);
-
-	// 2, Select as raw query and check that values are the same
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+// import retry from 'async-retry';
+// import { sql } from 'drizzle-orm';
+// import { pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
+// import { drizzle } from 'drizzle-orm/xata-http';
+// import type { XataHttpClient, XataHttpDatabase } from 'drizzle-orm/xata-http';
+// import { migrate } from 'drizzle-orm/xata-http/migrator';
+// import { beforeAll, beforeEach, expect, test } from 'vitest';
+// import { skipTests } from '~/common';
+// import { randomString } from '~/utils';
+// import { getXataClient } from '../xata/xata';
+// import { tests, tests as cacheTests, usersMigratorTable, usersTable } from './common-pt1';
+// import { TestCache, TestGlobalCache } from './common-cache';
+// import relations from './relations';
+
+// const ENABLE_LOGGING = false;
+
+// let db: XataHttpDatabase<never, typeof relations>;
+// let dbGlobalCached: XataHttpDatabase;
+// let cachedDb: XataHttpDatabase;
+// let client: XataHttpClient;
+
+// beforeAll(async () => {
+// 	const apiKey = process.env['XATA_API_KEY'];
+// 	if (!apiKey) {
+// 		throw new Error('XATA_API_KEY is not defined');
+// 	}
+
+// 	client = await retry(async () => {
+// 		client = getXataClient();
+// 		return client;
+// 	}, {
+// 		retries: 20,
+// 		factor: 1,
+// 		minTimeout: 250,
+// 		maxTimeout: 250,
+// 		randomize: false,
+// 	});
+// 	db = drizzle(client, { logger: ENABLE_LOGGING, relations });
+// 	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
+// 	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
+// });
+
+// beforeEach((ctx) => {
+// 	ctx.pg = {
+// 		db,
+// 	};
+// 	ctx.cachedPg = {
+// 		db: cachedDb,
+// 		dbGlobalCached,
+// 	};
+// });
+
+// test('migrator : default migration strategy', async () => {
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, { migrationsFolder: './drizzle2/pg' });
+
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+// 	const result = await db.select().from(usersMigratorTable);
+
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+// });
+
+// test('migrator : migrate with custom table', async () => {
+// 	const customTable = randomString();
+// 	await db.execute(sql`drop table if exists all_columns`);
+// 	await db.execute(sql`drop table if exists users12`);
+// 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+
+// 	await migrate(db, { migrationsFolder: './drizzle2/pg', migrationsTable: customTable });
+
+// 	// test if the custom migrations table was created
+// 	const { records } = await db.execute(sql`select * from "drizzle".${sql.identifier(customTable)};`);
+// 	expect(records && records.length > 0).toBeTruthy();
+
+// 	// test if the migrated table are working as expected
+// 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+// 	const result = await db.select().from(usersMigratorTable);
+// 	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+// 	await db.execute(sql`drop table all_columns`);
+// 	await db.execute(sql`drop table users12`);
+// 	await db.execute(sql`drop table "drizzle".${sql.identifier(customTable)}`);
+// });
+
+// test('all date and time columns without timezone first case mode string', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) not null
+// 			)
+// 	`);
+
+// 	// 1. Insert date in string format without timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: '2022-01-01 02:00:00.123456' },
+// 	]);
+
+// 	// 2, Select in string format and check that values are the same
+// 	const result = await db.select().from(table);
+
+// 	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456' }]);
+
+// 	// 3. Select as raw query and check that values are the same
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
+
+// 	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('all date and time columns without timezone second case mode string', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'string', precision: 6 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) not null
+// 			)
+// 	`);
+
+// 	// 1. Insert date in string format with timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: '2022-01-01T02:00:00.123456-02' },
+// 	]);
+
+// 	// 2, Select as raw query and check that values are the same
+// 	const result = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
+
+// 	expect(result.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
 
-test('all date and time columns without timezone third case mode date', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) not null
-			)
-	`);
-
-	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
-
-	// 1. Insert date as new date
-	await db.insert(table).values([
-		{ timestamp: insertedDate },
-	]);
-
-	// 2, Select as raw query as string
-	const result = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+// test('all date and time columns without timezone third case mode date', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'date', precision: 3 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(3) not null
+// 			)
+// 	`);
+
+// 	const insertedDate = new Date('2022-01-01 20:00:00.123+04');
+
+// 	// 1. Insert date as new date
+// 	await db.insert(table).values([
+// 		{ timestamp: insertedDate },
+// 	]);
+
+// 	// 2, Select as raw query as string
+// 	const result = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
 
-	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
-	expect(new Date(result.records[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
+// 	// 3. Compare both dates using orm mapping - Need to add 'Z' to tell JS that it is UTC
+// 	expect(new Date(result.records[0]!.timestamp_string + 'Z').getTime()).toBe(insertedDate.getTime());
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('test mode string for timestamp with timezone', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) with time zone not null
+// 			)
+// 	`);
 
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
+// 	const timestampString = '2022-01-01 00:00:00.123456-0200';
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+// 	// 1. Insert date in string format with timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: timestampString },
+// 	]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+// 	// 2. Select date in string format and check that the values are the same
+// 	const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+// 	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+// 	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+// 	// 3. Select as raw query and checke that values are the same
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+// 	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+// 	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
 
-test('test mode date for timestamp with timezone', async () => {
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
-	});
+// test('test mode date for timestamp with timezone', async () => {
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'date', withTimezone: true, precision: 3 }).notNull(),
+// 	});
 
-	await db.execute(sql`drop table if exists ${table}`);
+// 	await db.execute(sql`drop table if exists ${table}`);
 
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(3) with time zone not null
-			)
-	`);
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(3) with time zone not null
+// 			)
+// 	`);
 
-	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
+// 	const timestampString = new Date('2022-01-01 00:00:00.456-0200');
 
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
+// 	// 1. Insert date in string format with timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: timestampString },
+// 	]);
 
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
+// 	// 2. Select date in string format and check that the values are the same
+// 	const result = await db.select().from(table);
 
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
+// 	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+// 	expect(result).toEqual([{ id: 1, timestamp: timestampString }]);
 
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
+// 	// 3. Select as raw query and checke that values are the same
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
 
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
+// 	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+// 	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.456+00' }]);
 
-	await db.execute(sql`drop table if exists ${table}`);
-});
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
 
-test('test mode string for timestamp with timezone in UTC timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+// test('test mode string for timestamp with timezone in UTC timezone', async () => {
+// 	// get current timezone from db
+// 	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
 
-	// set timezone to UTC
-	await db.execute(sql`set time zone 'UTC'`);
+// 	// set timezone to UTC
+// 	await db.execute(sql`set time zone 'UTC'`);
 
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-0200';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
-	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
-
-	await db.execute(sql`set time zone '${sql.raw(timezone.records[0]!.TimeZone)}'`);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-test('test mode string for timestamp with timezone in different timezone', async () => {
-	// get current timezone from db
-	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
-
-	// set timezone to HST (UTC - 10)
-	await db.execute(sql`set time zone 'HST'`);
-
-	const table = pgTable('all_columns', {
-		id: serial('id').primaryKey(),
-		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
-	});
-
-	await db.execute(sql`drop table if exists ${table}`);
-
-	await db.execute(sql`
-		create table ${table} (
-					id serial primary key,
-					timestamp_string timestamp(6) with time zone not null
-			)
-	`);
-
-	const timestampString = '2022-01-01 00:00:00.123456-1000';
-
-	// 1. Insert date in string format with timezone in it
-	await db.insert(table).values([
-		{ timestamp: timestampString },
-	]);
-
-	// 2. Select date in string format and check that the values are the same
-	const result = await db.select().from(table);
-
-	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
-
-	// 3. Select as raw query and checke that values are the same
-	const result2 = await db.execute<{
-		id: number;
-		timestamp_string: string;
-	}>(sql`select * from ${table}`);
-
-	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
-
-	await db.execute(sql`set time zone '${sql.raw(timezone.records[0]!.TimeZone)}'`);
-
-	await db.execute(sql`drop table if exists ${table}`);
-});
-
-skipTests([
-	'migrator : default migration strategy',
-	'migrator : migrate with custom schema',
-	'migrator : migrate with custom table',
-	'migrator : migrate with custom table and custom schema',
-	'insert via db.execute + select via db.execute',
-	'insert via db.execute + returning',
-	'insert via db.execute w/ query builder',
-	'all date and time columns without timezone first case mode string',
-	'all date and time columns without timezone third case mode date',
-	'test mode string for timestamp with timezone',
-	'test mode date for timestamp with timezone',
-	'test mode string for timestamp with timezone in UTC timezone',
-	'test mode string for timestamp with timezone in different timezone',
-	'view',
-	'materialized view',
-	'select from enum',
-	'subquery with view',
-]);
-tests();
-cacheTests();
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema if exists public cascade`);
-	await db.execute(sql`create schema public`);
-	await db.execute(
-		sql`
-			create table users (
-				id serial primary key,
-				name text not null,
-				verified boolean not null default false, 
-				jsonb jsonb,
-				created_at timestamptz not null default now()
-			)
-		`,
-	);
-});
-
-test('insert via db.execute + select via db.execute', async () => {
-	await db.execute(
-		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
-	);
-
-	const result = await db.execute<{ id: number; name: string }>(
-		sql`select id, name from "users"`,
-	);
-	expect(result.records).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute + returning', async () => {
-	const inserted = await db.execute<{ id: number; name: string }>(
-		sql`insert into ${usersTable} (${
-			sql.identifier(
-				usersTable.name.name,
-			)
-		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
-	);
-	expect(inserted.records).toEqual([{ id: 1, name: 'John' }]);
-});
-
-test('insert via db.execute w/ query builder', async () => {
-	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-		db
-			.insert(usersTable)
-			.values({ name: 'John' })
-			.returning({ id: usersTable.id, name: usersTable.name }),
-	);
-	expect(inserted.records).toEqual([{ id: 1, name: 'John' }]);
-});
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) with time zone not null
+// 			)
+// 	`);
+
+// 	const timestampString = '2022-01-01 00:00:00.123456-0200';
+
+// 	// 1. Insert date in string format with timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: timestampString },
+// 	]);
+
+// 	// 2. Select date in string format and check that the values are the same
+// 	const result = await db.select().from(table);
+
+// 	// 2.1 Notice that postgres will return the date in UTC, but it is exactly the same
+// 	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 02:00:00.123456+00' }]);
+
+// 	// 3. Select as raw query and checke that values are the same
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
+
+// 	// 3.1 Notice that postgres will return the date in UTC, but it is exactlt the same
+// 	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 02:00:00.123456+00' }]);
+
+// 	await db.execute(sql`set time zone '${sql.raw(timezone.records[0]!.TimeZone)}'`);
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// test('test mode string for timestamp with timezone in different timezone', async () => {
+// 	// get current timezone from db
+// 	const timezone = await db.execute<{ TimeZone: string }>(sql`show timezone`);
+
+// 	// set timezone to HST (UTC - 10)
+// 	await db.execute(sql`set time zone 'HST'`);
+
+// 	const table = pgTable('all_columns', {
+// 		id: serial('id').primaryKey(),
+// 		timestamp: timestamp('timestamp_string', { mode: 'string', withTimezone: true, precision: 6 }).notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+
+// 	await db.execute(sql`
+// 		create table ${table} (
+// 					id serial primary key,
+// 					timestamp_string timestamp(6) with time zone not null
+// 			)
+// 	`);
+
+// 	const timestampString = '2022-01-01 00:00:00.123456-1000';
+
+// 	// 1. Insert date in string format with timezone in it
+// 	await db.insert(table).values([
+// 		{ timestamp: timestampString },
+// 	]);
+
+// 	// 2. Select date in string format and check that the values are the same
+// 	const result = await db.select().from(table);
+
+// 	expect(result).toEqual([{ id: 1, timestamp: '2022-01-01 00:00:00.123456-10' }]);
+
+// 	// 3. Select as raw query and checke that values are the same
+// 	const result2 = await db.execute<{
+// 		id: number;
+// 		timestamp_string: string;
+// 	}>(sql`select * from ${table}`);
+
+// 	expect(result2.records).toEqual([{ id: 1, timestamp_string: '2022-01-01 00:00:00.123456-10' }]);
+
+// 	await db.execute(sql`set time zone '${sql.raw(timezone.records[0]!.TimeZone)}'`);
+
+// 	await db.execute(sql`drop table if exists ${table}`);
+// });
+
+// skipTests([
+// 	'migrator : default migration strategy',
+// 	'migrator : migrate with custom schema',
+// 	'migrator : migrate with custom table',
+// 	'migrator : migrate with custom table and custom schema',
+// 	'insert via db.execute + select via db.execute',
+// 	'insert via db.execute + returning',
+// 	'insert via db.execute w/ query builder',
+// 	'all date and time columns without timezone first case mode string',
+// 	'all date and time columns without timezone third case mode date',
+// 	'test mode string for timestamp with timezone',
+// 	'test mode date for timestamp with timezone',
+// 	'test mode string for timestamp with timezone in UTC timezone',
+// 	'test mode string for timestamp with timezone in different timezone',
+// 	'view',
+// 	'materialized view',
+// 	'select from enum',
+// 	'subquery with view',
+// ]);
+// tests();
+// cacheTests();
+
+// beforeEach(async () => {
+// 	await db.execute(sql`drop schema if exists public cascade`);
+// 	await db.execute(sql`create schema public`);
+// 	await db.execute(
+// 		sql`
+// 			create table users (
+// 				id serial primary key,
+// 				name text not null,
+// 				verified boolean not null default false,
+// 				jsonb jsonb,
+// 				created_at timestamptz not null default now()
+// 			)
+// 		`,
+// 	);
+// });
+
+// test('insert via db.execute + select via db.execute', async () => {
+// 	await db.execute(
+// 		sql`insert into ${usersTable} (${sql.identifier(usersTable.name.name)}) values (${'John'})`,
+// 	);
+
+// 	const result = await db.execute<{ id: number; name: string }>(
+// 		sql`select id, name from "users"`,
+// 	);
+// 	expect(result.records).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert via db.execute + returning', async () => {
+// 	const inserted = await db.execute<{ id: number; name: string }>(
+// 		sql`insert into ${usersTable} (${
+// 			sql.identifier(
+// 				usersTable.name.name,
+// 			)
+// 		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+// 	);
+// 	expect(inserted.records).toEqual([{ id: 1, name: 'John' }]);
+// });
+
+// test('insert via db.execute w/ query builder', async () => {
+// 	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+// 		db
+// 			.insert(usersTable)
+// 			.values({ name: 'John' })
+// 			.returning({ id: usersTable.id, name: usersTable.name }),
+// 	);
+// 	expect(inserted.records).toEqual([{ id: 1, name: 'John' }]);
+// });
diff --git a/integration-tests/tests/xata/xata.ts b/integration-tests/tests/pg/xata.ts
similarity index 100%
rename from integration-tests/tests/xata/xata.ts
rename to integration-tests/tests/pg/xata.ts
diff --git a/integration-tests/tests/relational/bettersqlite.test.ts b/integration-tests/tests/relational/bettersqlite.test.ts
deleted file mode 100644
index 20b4f9923f..0000000000
--- a/integration-tests/tests/relational/bettersqlite.test.ts
+++ /dev/null
@@ -1,6102 +0,0 @@
-import 'dotenv/config';
-import Database from 'better-sqlite3';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { type BetterSQLite3Database, drizzle } from 'drizzle-orm/better-sqlite3';
-import { beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './sqlite.schema.ts';
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let db: BetterSQLite3Database<typeof schema>;
-
-beforeAll(() => {
-	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
-
-	db = drizzle(new Database(dbPath), { schema, logger: ENABLE_LOGGING });
-});
-
-beforeEach(() => {
-	db.run(sql`drop table if exists \`groups\``);
-	db.run(sql`drop table if exists \`users\``);
-	db.run(sql`drop table if exists \`users_to_groups\``);
-	db.run(sql`drop table if exists \`posts\``);
-	db.run(sql`drop table if exists \`comments\``);
-	db.run(sql`drop table if exists \`comment_likes\``);
-
-	db.run(
-		sql`
-			CREATE TABLE \`users\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`name\` text NOT NULL,
-			    \`verified\` integer DEFAULT 0 NOT NULL,
-			    \`invited_by\` integer
-			);
-		`,
-	);
-	db.run(
-		sql`
-			CREATE TABLE \`groups\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`name\` text NOT NULL,
-			    \`description\` text
-			);
-		`,
-	);
-	db.run(
-		sql`
-			CREATE TABLE \`users_to_groups\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`user_id\` integer NOT NULL,
-			    \`group_id\` integer NOT NULL
-			);
-		`,
-	);
-	db.run(
-		sql`
-			CREATE TABLE \`posts\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`content\` text NOT NULL,
-			    \`owner_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-	db.run(
-		sql`
-			CREATE TABLE \`comments\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`content\` text NOT NULL,
-			    \`creator\` integer,
-			    \`post_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-	db.run(
-		sql`
-			CREATE TABLE \`comment_likes\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`creator\` integer,
-			    \`comment_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: expect.anything(),
-	});
-
-	expect(usersWithPosts[0]!.posts).toEqual([
-		{ id: 7, ownerId: 3, content: '7', createdAt: expect.any(Date) },
-		{ id: 6, ownerId: 3, content: '6', createdAt: expect.any(Date) },
-	]);
-
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: expect.anything(),
-	});
-
-	expect(usersWithPosts[1]!.posts).toEqual([
-		{ id: 5, ownerId: 2, content: '5', createdAt: expect.any(Date) },
-		{ id: 4, ownerId: 2, content: '4', createdAt: expect.any(Date) },
-	]);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: expect.anything(),
-	});
-
-	expect(usersWithPosts[2]!.posts).toEqual([
-		{ id: 3, ownerId: 1, content: '3', createdAt: expect.any(Date) },
-		{ id: 2, ownerId: 1, content: '2', createdAt: expect.any(Date) },
-		{ id: 1, ownerId: 1, content: '1', createdAt: expect.any(Date) },
-	]);
-});
-
-test('[Find Many] Get users with posts + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	db.transaction((tx) => {
-		tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]).run();
-
-		tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]).run();
-
-		usersWithPosts = tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		}).sync();
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	expect(() =>
-		db.transaction((tx) => {
-			tx.insert(usersTable).values([
-				{ id: 1, name: 'Dan' },
-				{ id: 2, name: 'Andrew' },
-				{ id: 3, name: 'Alex' },
-			]).run();
-
-			tx.insert(postsTable).values([
-				{ ownerId: 1, content: 'Post1' },
-				{ ownerId: 1, content: 'Post1.1' },
-				{ ownerId: 2, content: 'Post2' },
-				{ ownerId: 3, content: 'Post3' },
-			]).run();
-
-			tx.rollback();
-
-			usersWithPosts = tx.query.usersTable.findMany({
-				where: (({ id }, { eq }) => eq(id, 1)),
-				with: {
-					posts: {
-						where: (({ id }, { eq }) => eq(id, 1)),
-					},
-				},
-			}).sync();
-		})
-	).toThrow(TransactionRollbackError);
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 1, content: 'Post1.2' },
-		{ id: 3, ownerId: 1, content: 'Post1.3' },
-		{ id: 4, ownerId: 2, content: 'Post2' },
-		{ id: 5, ownerId: 2, content: 'Post2.1' },
-		{ id: 6, ownerId: 3, content: 'Post3' },
-		{ id: 7, ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
-	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
-	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2.1',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3.1',
-	});
-});
-
-test('[Find Many] Get only custom fields + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-});
-
-test('[Find One] Get only custom fields + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	expect(() =>
-		db.query.usersTable.findMany({
-			columns: {},
-		}).sync()
-	).toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	expect(() =>
-		db.query.usersTable.findFirst({
-			columns: {},
-		}).sync()
-	).toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	expect(() =>
-		db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		}).sync()
-	).toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	expect(() =>
-		db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		}).sync()
-	).toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = prepared.execute({ limit: 1 }).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 }).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = prepared.execute({ id: 1 }).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 }).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', () => {
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-	expect(usersWithPosts?.id).toEqual(1);
-	expect(usersWithPosts?.verified).toEqual(0);
-	expect(usersWithPosts?.invitedBy).toEqual(null);
-	expect(usersWithPosts?.name).toEqual('Dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 1,
-		ownerId: 1,
-		content: 'Post1',
-		createdAt: usersWithPosts?.posts[0]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 2,
-		ownerId: 1,
-		content: 'Post1.2',
-		createdAt: usersWithPosts?.posts[1]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 3,
-		ownerId: 1,
-		content: 'Post1.3',
-		createdAt: usersWithPosts?.posts[2]?.createdAt,
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test.skip('[Find One] Get users with posts + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.id)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	}).sync();
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: 0, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-// TODO Check order
-test.skip('Get user with invitee and posts + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]).run();
-
-	db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: 0,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]).run();
-
-	db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: 0,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: 0,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-test('Get user with posts and posts with comments and comments with owner where exists', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]).run();
-
-	db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-		where: (table, { exists, eq }) => exists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	expect(response.length).eq(1);
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: 0,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: expect.arrayContaining([{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}]),
-	});
-});
-
-test('[Find Many] Get groups with users', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-	response[1]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-	response[2]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 3,
-				name: 'Group3',
-				lower: 'group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + custom', () => {
-	db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	}).sync();
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('async api', async () => {
-	await db.insert(usersTable).values([{ id: 1, name: 'Dan' }]);
-	const users = await db.query.usersTable.findMany();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('async api - sync()', () => {
-	db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).run();
-	const users = db.query.usersTable.findMany().sync();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('async api - prepare', async () => {
-	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
-	await insertStmt.execute();
-	const queryStmt = db.query.usersTable.findMany().prepare();
-	const users = await queryStmt.execute();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('async api - sync() + prepare', () => {
-	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
-	insertStmt.execute().sync();
-	const queryStmt = db.query.usersTable.findMany().prepare();
-	const users = queryStmt.execute().sync();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/db.ts b/integration-tests/tests/relational/db.ts
deleted file mode 100644
index 6cf7db9e08..0000000000
--- a/integration-tests/tests/relational/db.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import 'dotenv/config';
-import Database from 'better-sqlite3';
-import { sql } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/better-sqlite3';
-import util from 'node:util';
-import * as schema from './tables.ts';
-
-async function main() {
-	const bdb = new Database(process.env['SQLITE_DB_PATH']!);
-	const db = drizzle(bdb, { schema, logger: true });
-
-	const result = db.query.users.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					authorId: true,
-				},
-				with: {
-					comments: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${schema.posts.title})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	console.log(util.inspect(result, false, null, true));
-	bdb.close();
-}
-
-main();
diff --git a/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.test.ts b/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.test.ts
deleted file mode 100644
index 60b178a06b..0000000000
--- a/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.test.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { sql } from 'drizzle-orm';
-import { drizzle, type MySql2Database } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import * as mysql from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './mysql.duplicates.ts';
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let mysqlContainer: Docker.Container;
-let db: MySql2Database<typeof schema>;
-let client: mysql.Connection;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['MYSQL_CONNECTION_STRING'] ?? await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 30000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await mysql.createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING, mode: 'default' });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
-});
-
-beforeEach(async () => {
-	await db.execute(sql`drop table if exists \`members\``);
-	await db.execute(sql`drop table if exists \`artist_to_member\``);
-	await db.execute(sql`drop table if exists \`artists\``);
-	await db.execute(sql`drop table if exists \`albums\``);
-
-	await db.execute(
-		sql`
-			CREATE TABLE \`members\` (
-			    \`id\` serial AUTO_INCREMENT PRIMARY KEY NOT NULL,
-			    \`created_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`updated_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`name_en\` varchar(50) NOT NULL,
-			    \`name_kr\` varchar(50) NOT NULL,
-			    \`stage_name_en\` varchar(50) NOT NULL,
-			    \`stage_name_kr\` varchar(50) NOT NULL,
-			    \`image\` varchar(255) NOT NULL,
-			    \`instagram\` varchar(255) NOT NULL);
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE \`artist_to_member\` (
-			    \`id\` serial AUTO_INCREMENT PRIMARY KEY NOT NULL,
-			    \`member_id\` int NOT NULL,
-			    \`artist_id\` int NOT NULL);
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE \`artists\` (
-			    \`id\` serial AUTO_INCREMENT PRIMARY KEY NOT NULL,
-			    \`created_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`updated_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`name_en\` varchar(50) NOT NULL,
-			    \`name_kr\` varchar(50) NOT NULL,
-			    \`debut\` date NOT NULL,
-			    \`company_id\` int NOT NULL,
-			    \`is_group\` boolean NOT NULL DEFAULT true,
-			    \`image\` varchar(255) NOT NULL,
-			    \`twitter\` varchar(255) NOT NULL,
-			    \`instagram\` varchar(255) NOT NULL,
-			    \`youtube\` varchar(255) NOT NULL,
-			    \`website\` varchar(255) NOT NULL,
-			    \`spotify_id\` varchar(32));
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE \`albums\` (
-			    \`id\` serial AUTO_INCREMENT PRIMARY KEY NOT NULL,
-			    \`created_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`updated_at\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    \`artist_id\` int NOT NULL,
-			    \`name\` varchar(50) NOT NULL,
-			    \`region\` enum('en','kr','jp','other') NOT NULL,
-			    \`release_date\` date NOT NULL,
-			    \`image\` varchar(255) NOT NULL,
-			    \`spotify_id\` varchar(32));
-		`,
-	);
-});
-
-test('Simple case from GH', async () => {
-	await db.insert(schema.artists).values([
-		{
-			id: 1,
-			nameEn: 'Dan',
-			nameKr: '',
-			debut: new Date(),
-			companyId: 1,
-			image: '',
-			twitter: '',
-			instagram: '',
-			youtube: '',
-			website: '',
-		},
-		{
-			id: 2,
-			nameEn: 'Andrew',
-			nameKr: '',
-			debut: new Date(),
-			companyId: 1,
-			image: '',
-			twitter: '',
-			instagram: '',
-			youtube: '',
-			website: '',
-		},
-		{
-			id: 3,
-			nameEn: 'Alex',
-			nameKr: '',
-			debut: new Date(),
-			companyId: 1,
-			image: '',
-			twitter: '',
-			instagram: '',
-			youtube: '',
-			website: '',
-		},
-	]);
-
-	await db.insert(schema.albums).values([
-		{ id: 1, artistId: 1, name: 'Album1', region: 'en', releaseDate: new Date(), image: '' },
-		{ id: 2, artistId: 2, name: 'Album2', region: 'en', releaseDate: new Date(), image: '' },
-		{ id: 3, artistId: 3, name: 'Album3', region: 'en', releaseDate: new Date(), image: '' },
-	]);
-
-	await db.insert(schema.members).values([
-		{ id: 1, nameEn: 'MemberA', nameKr: '', stageNameEn: '', stageNameKr: '', image: '', instagram: '' },
-		{ id: 2, nameEn: 'MemberB', nameKr: '', stageNameEn: '', stageNameKr: '', image: '', instagram: '' },
-		{ id: 3, nameEn: 'MemberC', nameKr: '', stageNameEn: '', stageNameKr: '', image: '', instagram: '' },
-	]);
-
-	await db.insert(schema.artistsToMembers).values([
-		{ memberId: 1, artistId: 1 },
-		{ memberId: 2, artistId: 1 },
-		{ memberId: 2, artistId: 2 },
-		{ memberId: 3, artistId: 3 },
-	]);
-
-	const response = await db.query.artists.findFirst({
-		where: (artists, { eq }) => eq(artists.id, 1),
-		with: {
-			albums: true,
-			members: {
-				columns: {},
-				with: {
-					member: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			createdAt: Date;
-			updatedAt: Date;
-			nameEn: string;
-			nameKr: string;
-			debut: Date;
-			companyId: number;
-			isGroup: boolean;
-			image: string;
-			twitter: string;
-			instagram: string;
-			youtube: string;
-			website: string;
-			spotifyId: string | null;
-			members: {
-				member: {
-					id: number;
-					createdAt: Date;
-					updatedAt: Date;
-					nameEn: string;
-					nameKr: string;
-					image: string;
-					instagram: string;
-					stageNameEn: string;
-					stageNameKr: string;
-				};
-			}[];
-			albums: {
-				id: number;
-				name: string;
-				createdAt: Date;
-				updatedAt: Date;
-				image: string;
-				spotifyId: string | null;
-				artistId: number;
-				region: 'en' | 'kr' | 'jp' | 'other';
-				releaseDate: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.members.length).eq(2);
-	expect(response?.albums.length).eq(1);
-
-	expect(response?.albums[0]).toEqual({
-		id: 1,
-		createdAt: response?.albums[0]?.createdAt,
-		updatedAt: response?.albums[0]?.updatedAt,
-		artistId: 1,
-		name: 'Album1',
-		region: 'en',
-		releaseDate: response?.albums[0]?.releaseDate,
-		image: '',
-		spotifyId: null,
-	});
-});
diff --git a/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.ts b/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.ts
deleted file mode 100644
index 9bda974811..0000000000
--- a/integration-tests/tests/relational/issues-schemas/duplicates/mysql/mysql.duplicates.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import { relations, sql } from 'drizzle-orm';
-import { boolean, date, index, int, mysqlEnum, mysqlTable, serial, timestamp, varchar } from 'drizzle-orm/mysql-core';
-
-export const artists = mysqlTable(
-	'artists',
-	{
-		id: serial('id').primaryKey(),
-		createdAt: timestamp('created_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		updatedAt: timestamp('updated_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		nameEn: varchar('name_en', { length: 50 }).notNull(),
-		nameKr: varchar('name_kr', { length: 50 }).notNull(),
-		debut: date('debut').notNull(),
-		companyId: int('company_id').notNull(),
-		isGroup: boolean('is_group').notNull().default(true),
-		image: varchar('image', { length: 255 }).notNull(),
-		twitter: varchar('twitter', { length: 255 }).notNull(),
-		instagram: varchar('instagram', { length: 255 }).notNull(),
-		youtube: varchar('youtube', { length: 255 }).notNull(),
-		website: varchar('website', { length: 255 }).notNull(),
-		spotifyId: varchar('spotify_id', { length: 32 }),
-	},
-	(table) => ({
-		nameEnIndex: index('artists__name_en__idx').on(table.nameEn),
-	}),
-);
-
-export const members = mysqlTable('members', {
-	id: serial('id').primaryKey(),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.default(sql`CURRENT_TIMESTAMP`),
-	updatedAt: timestamp('updated_at')
-		.notNull()
-		.default(sql`CURRENT_TIMESTAMP`),
-	nameEn: varchar('name_en', { length: 50 }).notNull(),
-	nameKr: varchar('name_kr', { length: 50 }).notNull(),
-	stageNameEn: varchar('stage_name_en', { length: 50 }).notNull(),
-	stageNameKr: varchar('stage_name_kr', { length: 50 }).notNull(),
-	image: varchar('image', { length: 255 }).notNull(),
-	instagram: varchar('instagram', { length: 255 }).notNull(),
-});
-
-export const artistsToMembers = mysqlTable(
-	'artist_to_member',
-	{
-		id: serial('id').primaryKey(),
-		memberId: int('member_id').notNull(),
-		artistId: int('artist_id').notNull(),
-	},
-	(table) => ({
-		memberArtistIndex: index('artist_to_member__artist_id__member_id__idx').on(
-			table.memberId,
-			table.artistId,
-		),
-	}),
-);
-
-export const albums = mysqlTable(
-	'albums',
-	{
-		id: serial('id').primaryKey(),
-		createdAt: timestamp('created_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		updatedAt: timestamp('updated_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		artistId: int('artist_id').notNull(),
-		name: varchar('name', { length: 50 }).notNull(),
-		region: mysqlEnum('region', ['en', 'kr', 'jp', 'other']).notNull(),
-		releaseDate: date('release_date').notNull(),
-		image: varchar('image', { length: 255 }).notNull(),
-		spotifyId: varchar('spotify_id', { length: 32 }),
-	},
-	(table) => ({
-		artistIndex: index('albums__artist_id__idx').on(table.artistId),
-		nameIndex: index('albums__name__idx').on(table.name),
-	}),
-);
-
-// relations
-export const artistRelations = relations(artists, ({ many }) => ({
-	albums: many(albums),
-	members: many(artistsToMembers),
-}));
-
-export const albumRelations = relations(albums, ({ one }) => ({
-	artist: one(artists, {
-		fields: [albums.artistId],
-		references: [artists.id],
-	}),
-}));
-
-export const memberRelations = relations(members, ({ many }) => ({
-	artists: many(artistsToMembers),
-}));
-
-export const artistsToMembersRelations = relations(artistsToMembers, ({ one }) => ({
-	artist: one(artists, {
-		fields: [artistsToMembers.artistId],
-		references: [artists.id],
-	}),
-	member: one(members, {
-		fields: [artistsToMembers.memberId],
-		references: [members.id],
-	}),
-}));
diff --git a/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.test.ts b/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.test.ts
deleted file mode 100644
index 17a057de7c..0000000000
--- a/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.test.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { sql } from 'drizzle-orm';
-import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
-import getPort from 'get-port';
-import pg from 'pg';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './pg.duplicates.ts';
-
-const { Client } = pg;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let pgContainer: Docker.Container;
-let db: NodePgDatabase<typeof schema>;
-let client: pg.Client;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'POSTGRES_PASSWORD=postgres',
-			'POSTGRES_USER=postgres',
-			'POSTGRES_DB=postgres',
-		],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = new Client(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-beforeEach(async () => {
-	await db.execute(sql`drop table if exists "members"`);
-	await db.execute(sql`drop table if exists "artist_to_member"`);
-	await db.execute(sql`drop table if exists "artists"`);
-	await db.execute(sql`drop table if exists "albums"`);
-
-	await db.execute(
-		sql`
-			CREATE TABLE "members" (
-			    "id" serial PRIMARY KEY NOT NULL,
-			    "created_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    "updated_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
-				);
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE "artist_to_member" (
-			    "id" serial PRIMARY KEY NOT NULL,
-			    "member_id" int NOT NULL,
-			    "artist_id" int NOT NULL);
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE "artists" (
-			    "id" serial PRIMARY KEY NOT NULL,
-			    "created_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    "updated_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    "company_id" int NOT NULL);
-		`,
-	);
-	await db.execute(
-		sql`
-			CREATE TABLE "albums" (
-			    "id" serial PRIMARY KEY NOT NULL,
-			    "created_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    "updated_at" timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-			    "artist_id" int NOT NULL);
-		`,
-	);
-});
-
-test('Simple case from GH', async () => {
-	await db.insert(schema.artists).values([
-		{
-			id: 1,
-			companyId: 1,
-		},
-		{
-			id: 2,
-			companyId: 1,
-		},
-		{
-			id: 3,
-			companyId: 1,
-		},
-	]);
-
-	await db.insert(schema.albums).values([
-		{ id: 1, artistId: 1 },
-		{ id: 2, artistId: 2 },
-		{ id: 3, artistId: 3 },
-	]);
-
-	await db.insert(schema.members).values([
-		{ id: 1 },
-		{ id: 2 },
-		{ id: 3 },
-	]);
-
-	await db.insert(schema.artistsToMembers).values([
-		{ memberId: 1, artistId: 1 },
-		{ memberId: 2, artistId: 1 },
-		{ memberId: 2, artistId: 2 },
-		{ memberId: 3, artistId: 3 },
-	]);
-
-	const response = await db.query.artists.findFirst({
-		where: (artists, { eq }) => eq(artists.id, 1),
-		with: {
-			albums: true,
-			members: {
-				columns: {},
-				with: {
-					member: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			createdAt: Date;
-			updatedAt: Date;
-			companyId: number;
-			albums: {
-				id: number;
-				createdAt: Date;
-				updatedAt: Date;
-				artistId: number;
-			}[];
-			members: {
-				member: {
-					id: number;
-					createdAt: Date;
-					updatedAt: Date;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.members.length).eq(2);
-	expect(response?.albums.length).eq(1);
-
-	expect(response?.albums[0]).toEqual({
-		id: 1,
-		createdAt: response?.albums[0]?.createdAt,
-		updatedAt: response?.albums[0]?.updatedAt,
-		artistId: 1,
-	});
-});
diff --git a/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.ts b/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.ts
deleted file mode 100644
index 5535b0bf81..0000000000
--- a/integration-tests/tests/relational/issues-schemas/duplicates/pg/pg.duplicates.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { relations, sql } from 'drizzle-orm';
-import { index, integer, pgTable, serial, timestamp } from 'drizzle-orm/pg-core';
-
-export const artists = pgTable(
-	'artists',
-	{
-		id: serial('id').primaryKey(),
-		createdAt: timestamp('created_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		updatedAt: timestamp('updated_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		companyId: integer('company_id').notNull(),
-	},
-);
-
-export const members = pgTable('members', {
-	id: serial('id').primaryKey(),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.default(sql`CURRENT_TIMESTAMP`),
-	updatedAt: timestamp('updated_at')
-		.notNull()
-		.default(sql`CURRENT_TIMESTAMP`),
-});
-
-export const artistsToMembers = pgTable(
-	'artist_to_member',
-	{
-		id: serial('id').primaryKey(),
-		memberId: integer('member_id').notNull(),
-		artistId: integer('artist_id').notNull(),
-	},
-	(table) => ({
-		memberArtistIndex: index('artist_to_member__artist_id__member_id__idx').on(
-			table.memberId,
-			table.artistId,
-		),
-	}),
-);
-
-export const albums = pgTable(
-	'albums',
-	{
-		id: serial('id').primaryKey(),
-		createdAt: timestamp('created_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		updatedAt: timestamp('updated_at')
-			.notNull()
-			.default(sql`CURRENT_TIMESTAMP`),
-		artistId: integer('artist_id').notNull(),
-	},
-	(table) => ({
-		artistIndex: index('albums__artist_id__idx').on(table.artistId),
-	}),
-);
-
-// relations
-export const artistRelations = relations(artists, ({ many }) => ({
-	albums: many(albums),
-	members: many(artistsToMembers),
-}));
-
-export const albumRelations = relations(albums, ({ one }) => ({
-	artist: one(artists, {
-		fields: [albums.artistId],
-		references: [artists.id],
-	}),
-}));
-
-export const memberRelations = relations(members, ({ many }) => ({
-	artists: many(artistsToMembers),
-}));
-
-export const artistsToMembersRelations = relations(artistsToMembers, ({ one }) => ({
-	artist: one(artists, {
-		fields: [artistsToMembers.artistId],
-		references: [artists.id],
-	}),
-	member: one(members, {
-		fields: [artistsToMembers.memberId],
-		references: [members.id],
-	}),
-}));
diff --git a/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.schema.ts b/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.schema.ts
deleted file mode 100644
index 7f4a60ac9a..0000000000
--- a/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.schema.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-import { relations } from 'drizzle-orm';
-import { boolean, integer, pgTable, primaryKey, text, uuid } from 'drizzle-orm/pg-core';
-
-export const menuItems = pgTable('menu_items', {
-	id: uuid('id').defaultRandom().primaryKey(),
-});
-
-export const modifierGroups = pgTable('modifier_groups', {
-	id: uuid('id').defaultRandom().primaryKey(),
-});
-
-export const menuItemModifierGroups = pgTable(
-	'menu_item_modifier_groups',
-	{
-		menuItemId: uuid('menu_item_id')
-			.notNull()
-			.references(() => menuItems.id),
-		modifierGroupId: uuid('modifier_group_id')
-			.notNull()
-			.references(() => modifierGroups.id),
-		order: integer('order').default(0),
-	},
-	(table) => ({
-		menuItemIdModifierGroupIdOrderPk: primaryKey(
-			table.menuItemId,
-			table.modifierGroupId,
-			table.order,
-		),
-	}),
-);
-
-export const ingredients = pgTable('ingredients', {
-	id: uuid('id').defaultRandom().primaryKey(),
-	name: text('name').notNull(),
-	description: text('description'),
-	imageUrl: text('image_url'),
-	inStock: boolean('in_stock').default(true),
-});
-
-export const modifiers = pgTable('modifiers', {
-	id: uuid('id').defaultRandom().primaryKey(),
-	ingredientId: uuid('ingredient_id').references(() => ingredients.id),
-	itemId: uuid('item_id').references(() => menuItems.id),
-});
-
-export const menuItemIngredients = pgTable(
-	'menu_item_ingredients',
-	{
-		menuItemId: uuid('menu_item_id')
-			.notNull()
-			.references(() => menuItems.id),
-		ingredientId: uuid('ingredient_id')
-			.notNull()
-			.references(() => ingredients.id),
-		order: integer('order').default(0),
-	},
-	(table) => ({
-		menuItemIdIngredientIdOrderPk: primaryKey(
-			table.menuItemId,
-			table.ingredientId,
-			table.order,
-		),
-	}),
-);
-
-export const modifierGroupModifiers = pgTable(
-	'modifier_group_modifiers',
-	{
-		modifierGroupId: uuid('modifier_group_id')
-			.notNull()
-			.references(() => modifierGroups.id),
-		modifierId: uuid('modifier_id')
-			.notNull()
-			.references(() => modifiers.id),
-		order: integer('order').default(0),
-	},
-	(table) => ({
-		modifierGroupIdModifierIdOrderPk: primaryKey(
-			table.modifierGroupId,
-			table.modifierId,
-			table.order,
-		),
-	}),
-);
-
-export const menuItemRelations = relations(menuItems, ({ many }) => ({
-	ingredients: many(menuItemIngredients),
-	modifierGroups: many(menuItemModifierGroups),
-	// category: one(menuCategories, {
-	// 	fields: [menuItems.categoryId],
-	// 	references: [menuCategories.id],
-	// }),
-}));
-
-export const menuItemIngredientRelations = relations(
-	menuItemIngredients,
-	({ one }) => ({
-		menuItem: one(menuItems, {
-			fields: [menuItemIngredients.menuItemId],
-			references: [menuItems.id],
-		}),
-		ingredient: one(ingredients, {
-			fields: [menuItemIngredients.ingredientId],
-			references: [ingredients.id],
-		}),
-	}),
-);
-
-export const ingredientRelations = relations(ingredients, ({ many }) => ({
-	menuItems: many(menuItemIngredients),
-}));
-
-export const modifierGroupRelations = relations(modifierGroups, ({ many }) => ({
-	menuItems: many(menuItemModifierGroups),
-	modifiers: many(modifierGroupModifiers),
-}));
-
-export const modifierRelations = relations(modifiers, ({ one, many }) => ({
-	modifierGroups: many(modifierGroupModifiers),
-	ingredient: one(ingredients, {
-		fields: [modifiers.ingredientId],
-		references: [ingredients.id],
-	}),
-	item: one(menuItems, {
-		fields: [modifiers.itemId],
-		references: [menuItems.id],
-	}),
-}));
-
-export const menuItemModifierGroupRelations = relations(
-	menuItemModifierGroups,
-	({ one }) => ({
-		menuItem: one(menuItems, {
-			fields: [menuItemModifierGroups.menuItemId],
-			references: [menuItems.id],
-		}),
-		modifierGroup: one(modifierGroups, {
-			fields: [menuItemModifierGroups.modifierGroupId],
-			references: [modifierGroups.id],
-		}),
-	}),
-);
-
-export const modifierGroupModifierRelations = relations(
-	modifierGroupModifiers,
-	({ one }) => ({
-		modifierGroup: one(modifierGroups, {
-			fields: [modifierGroupModifiers.modifierGroupId],
-			references: [modifierGroups.id],
-		}),
-		modifier: one(modifiers, {
-			fields: [modifierGroupModifiers.modifierId],
-			references: [modifiers.id],
-		}),
-	}),
-);
diff --git a/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.test.ts b/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.test.ts
deleted file mode 100644
index ea81c82fb6..0000000000
--- a/integration-tests/tests/relational/issues-schemas/wrong-mapping/pg.test.ts
+++ /dev/null
@@ -1,318 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { desc, sql } from 'drizzle-orm';
-import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
-import getPort from 'get-port';
-import pg from 'pg';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expectTypeOf, test } from 'vitest';
-import * as schema from './pg.schema.ts';
-
-const { Client } = pg;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let pgContainer: Docker.Container;
-let db: NodePgDatabase<typeof schema>;
-let client: pg.Client;
-
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'POSTGRES_PASSWORD=postgres',
-			'POSTGRES_USER=postgres',
-			'POSTGRES_DB=postgres',
-		],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = new Client(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-beforeEach(async () => {
-	await db.execute(sql`drop schema public cascade`);
-	await db.execute(sql`create schema public`);
-
-	await db.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "ingredients" (
-			    "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-			    "name" text NOT NULL,
-			    "description" text,
-			    "image_url" text,
-			    "in_stock" boolean DEFAULT true
-			);
-
-			CREATE TABLE IF NOT EXISTS "menu_item_ingredients" (
-			    "menu_item_id" uuid NOT NULL,
-			    "ingredient_id" uuid NOT NULL,
-			    "order" integer DEFAULT 0
-			);
-
-			ALTER TABLE "menu_item_ingredients" ADD CONSTRAINT "menu_item_ingredients_menu_item_id_ingredient_id_order" PRIMARY KEY("menu_item_id","ingredient_id","order");
-
-			CREATE TABLE IF NOT EXISTS "menu_item_modifier_groups" (
-			    "menu_item_id" uuid NOT NULL,
-			    "modifier_group_id" uuid NOT NULL,
-			    "order" integer DEFAULT 0
-			);
-
-			ALTER TABLE "menu_item_modifier_groups" ADD CONSTRAINT "menu_item_modifier_groups_menu_item_id_modifier_group_id_order" PRIMARY KEY("menu_item_id","modifier_group_id","order");
-
-			CREATE TABLE IF NOT EXISTS "menu_items" (
-			    "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL
-			);
-
-			CREATE TABLE IF NOT EXISTS "modifier_group_modifiers" (
-			    "modifier_group_id" uuid NOT NULL,
-			    "modifier_id" uuid NOT NULL,
-			    "order" integer DEFAULT 0
-			);
-
-			ALTER TABLE "modifier_group_modifiers" ADD CONSTRAINT "modifier_group_modifiers_modifier_group_id_modifier_id_order" PRIMARY KEY("modifier_group_id","modifier_id","order");
-
-			CREATE TABLE IF NOT EXISTS "modifier_groups" (
-			    "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL
-			);
-
-			CREATE TABLE IF NOT EXISTS "modifiers" (
-			    "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-			    "ingredient_id" uuid,
-			    "item_id" uuid
-			);
-
-			DO $$ BEGIN
-			 ALTER TABLE "menu_item_ingredients" ADD CONSTRAINT "menu_item_ingredients_menu_item_id_menu_items_id_fk" FOREIGN KEY ("menu_item_id") REFERENCES "menu_items"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "menu_item_ingredients" ADD CONSTRAINT "menu_item_ingredients_ingredient_id_ingredients_id_fk" FOREIGN KEY ("ingredient_id") REFERENCES "ingredients"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "menu_item_modifier_groups" ADD CONSTRAINT "menu_item_modifier_groups_menu_item_id_menu_items_id_fk" FOREIGN KEY ("menu_item_id") REFERENCES "menu_items"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "menu_item_modifier_groups" ADD CONSTRAINT "menu_item_modifier_groups_modifier_group_id_modifier_groups_id_fk" FOREIGN KEY ("modifier_group_id") REFERENCES "modifier_groups"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "modifier_group_modifiers" ADD CONSTRAINT "modifier_group_modifiers_modifier_group_id_modifier_groups_id_fk" FOREIGN KEY ("modifier_group_id") REFERENCES "modifier_groups"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "modifier_group_modifiers" ADD CONSTRAINT "modifier_group_modifiers_modifier_id_modifiers_id_fk" FOREIGN KEY ("modifier_id") REFERENCES "modifiers"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "modifiers" ADD CONSTRAINT "modifiers_ingredient_id_ingredients_id_fk" FOREIGN KEY ("ingredient_id") REFERENCES "ingredients"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-
-			DO $$ BEGIN
-			 ALTER TABLE "modifiers" ADD CONSTRAINT "modifiers_item_id_menu_items_id_fk" FOREIGN KEY ("item_id") REFERENCES "menu_items"("id") ON DELETE no action ON UPDATE no action;
-			EXCEPTION
-			 WHEN duplicate_object THEN null;
-			END $$;
-		`,
-	);
-});
-
-test('Simple case from GH', async () => {
-	const firstMenuItemId = uuid();
-	const secondMenuItemId = uuid();
-
-	const firstModGroupsId = uuid();
-	const secondModGroupsId = uuid();
-
-	await db.insert(schema.menuItems).values([{ id: firstMenuItemId }, { id: secondMenuItemId }]);
-	await db.insert(schema.modifierGroups).values([{ id: firstModGroupsId }, { id: secondModGroupsId }]);
-	await db.insert(schema.menuItemModifierGroups).values([{
-		modifierGroupId: firstModGroupsId,
-		menuItemId: firstMenuItemId,
-	}, {
-		modifierGroupId: firstModGroupsId,
-		menuItemId: secondMenuItemId,
-	}, {
-		modifierGroupId: secondModGroupsId,
-		menuItemId: firstMenuItemId,
-	}]);
-
-	const firstIngredientId = uuid();
-	const secondIngredientId = uuid();
-
-	await db.insert(schema.ingredients).values([{
-		id: firstIngredientId,
-		name: 'first',
-	}, {
-		id: secondIngredientId,
-		name: 'second',
-	}]);
-
-	const firstModifierId = uuid();
-	const secondModifierId = uuid();
-
-	await db.insert(schema.modifiers).values([{
-		id: firstModifierId,
-		ingredientId: firstIngredientId,
-		itemId: firstMenuItemId,
-	}, {
-		id: secondModifierId,
-		ingredientId: secondIngredientId,
-		itemId: secondMenuItemId,
-	}]);
-
-	await db.insert(schema.modifierGroupModifiers).values([
-		{
-			modifierGroupId: firstModGroupsId,
-			modifierId: firstModifierId,
-		},
-		{
-			modifierGroupId: secondModGroupsId,
-			modifierId: secondModifierId,
-		},
-	]);
-
-	const response = await db.query.menuItems
-		.findMany({
-			with: {
-				modifierGroups: {
-					with: {
-						modifierGroup: {
-							with: {
-								modifiers: {
-									with: {
-										modifier: {
-											with: {
-												ingredient: true,
-												item: true,
-											},
-										},
-									},
-									orderBy: desc(schema.modifierGroupModifiers.order),
-								},
-							},
-						},
-					},
-					orderBy: schema.menuItemModifierGroups.order,
-				},
-			},
-		});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: string;
-			modifierGroups: {
-				menuItemId: string;
-				modifierGroupId: string;
-				order: number | null;
-				modifierGroup: {
-					id: string;
-					modifiers: {
-						modifierGroupId: string;
-						order: number | null;
-						modifierId: string;
-						modifier: {
-							id: string;
-							ingredientId: string | null;
-							itemId: string | null;
-							ingredient: {
-								id: string;
-								name: string;
-								description: string | null;
-								imageUrl: string | null;
-								inStock: boolean | null;
-							} | null;
-							item: {
-								id: string;
-							} | null;
-						};
-					}[];
-				};
-			}[];
-		}[]
-	>();
-
-	// TODO: don't rely on items order
-	// expect(response.length).eq(2);
-	// expect(response[0]?.modifierGroups.length).eq(1);
-	// expect(response[0]?.modifierGroups[0]?.modifierGroup.modifiers.length).eq(1);
-
-	// TODO: add correct IDs
-	// expect(response[0]?.modifierGroups[0]?.modifierGroup.modifiers[0]?.modifier.ingredient?.id).eq(
-	// 	'0b2b9abc-5975-4a1d-ba3d-6fc3b3149902',
-	// );
-	// expect(response[0]?.modifierGroups[0]?.modifierGroup.modifiers[0]?.modifier.item?.id).eq(
-	// 	'a867133e-60b7-4003-aaa0-deeefad7e518',
-	// );
-});
diff --git a/integration-tests/tests/relational/mysql.planetscale.test.ts b/integration-tests/tests/relational/mysql.planetscale.test.ts
deleted file mode 100644
index a67e51ee4e..0000000000
--- a/integration-tests/tests/relational/mysql.planetscale.test.ts
+++ /dev/null
@@ -1,6110 +0,0 @@
-import 'dotenv/config';
-
-import { Client } from '@planetscale/database';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
-import { beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './mysql.schema.ts';
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let db: PlanetScaleDatabase<typeof schema>;
-
-beforeAll(async () => {
-	db = drizzle(
-		new Client({
-			url: process.env['PLANETSCALE_CONNECTION_STRING']!,
-			// host: process.env['DATABASE_HOST']!,
-			// username: process.env['DATABASE_USERNAME']!,
-			// password: process.env['DATABASE_PASSWORD']!,
-		}),
-		{ schema, logger: ENABLE_LOGGING },
-	);
-
-	await Promise.all([
-		db.execute(sql`drop table if exists \`users\``),
-		db.execute(sql`drop table if exists \`groups\``),
-		db.execute(sql`drop table if exists \`users_to_groups\``),
-		db.execute(sql`drop table if exists \`posts\``),
-		db.execute(sql`drop table if exists \`comments\``),
-		db.execute(sql`drop table if exists \`comment_likes\``),
-	]);
-	await Promise.all([
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`users\` (
-					  \`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					  \`name\` text NOT NULL,
-					  \`verified\` boolean DEFAULT false NOT NULL,
-					  \`invited_by\` bigint
-				);
-			`,
-		),
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`groups\` (
-					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					\`name\` text NOT NULL,
-					\`description\` text
-				);
-			`,
-		),
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`users_to_groups\` (
-					\`id\` serial PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					\`user_id\` bigint,
-					\`group_id\` bigint
-				);
-			`,
-		),
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`posts\` (
-					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					\`content\` text NOT NULL,
-					\`owner_id\` bigint,
-					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-				);
-			`,
-		),
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`comments\` (
-					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					\`content\` text NOT NULL,
-					\`creator\` bigint,
-					\`post_id\` bigint,
-					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-				);
-			`,
-		),
-		db.execute(
-			sql`
-				CREATE TABLE IF NOT EXISTS \`comment_likes\` (
-					\`id\` bigint PRIMARY KEY AUTO_INCREMENT NOT NULL,
-					\`creator\` bigint,
-					\`comment_id\` bigint,
-					\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-				);
-			`,
-		),
-	]);
-});
-
-beforeEach(async () => {
-	await Promise.all([
-		db.delete(usersTable),
-		db.delete(postsTable),
-		db.delete(commentsTable),
-		db.delete(groupsTable),
-		db.delete(usersToGroupsTable),
-		db.execute(sql`delete from \`comment_likes\``),
-	]);
-	await Promise.all([
-		db.execute(sql`ALTER TABLE \`users\` AUTO_INCREMENT = 1`),
-		db.execute(sql`ALTER TABLE \`groups\` AUTO_INCREMENT = 1`),
-		db.execute(sql`ALTER TABLE \`users_to_groups\` AUTO_INCREMENT = 1`),
-		db.execute(sql`ALTER TABLE \`posts\` AUTO_INCREMENT = 1`),
-		db.execute(sql`ALTER TABLE \`comments\` AUTO_INCREMENT = 1`),
-		db.execute(sql`ALTER TABLE \`comment_likes\` AUTO_INCREMENT = 1`),
-	]);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [
-			{
-				id: 3,
-				ownerId: 1,
-				content: '3',
-				createdAt: usersWithPosts[2]?.posts[2]?.createdAt,
-			},
-			{
-				id: 2,
-				ownerId: 1,
-				content: '2',
-				createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-			},
-			{
-				id: 1,
-				ownerId: 1,
-				content: '1',
-				createdAt: usersWithPosts[2]?.posts[0]?.createdAt,
-			},
-		],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 1, content: 'Post1.2' },
-		{ id: 3, ownerId: 1, content: 'Post1.3' },
-		{ id: 4, ownerId: 2, content: 'Post2' },
-		{ id: 5, ownerId: 2, content: 'Post2.1' },
-		{ id: 6, ownerId: 3, content: 'Post3' },
-		{ id: 7, ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
-	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
-	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2.1',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3.1',
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-});
-
-test('[Find One] Get only custom fields + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async () => {
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-	expect(usersWithPosts?.id).toEqual(1);
-	expect(usersWithPosts?.verified).toEqual(false);
-	expect(usersWithPosts?.invitedBy).toEqual(null);
-	expect(usersWithPosts?.name).toEqual('Dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 1,
-		ownerId: 1,
-		content: 'Post1',
-		createdAt: usersWithPosts?.posts[0]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 2,
-		ownerId: 1,
-		content: 'Post1.2',
-		createdAt: usersWithPosts?.posts[1]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 3,
-		ownerId: 1,
-		content: 'Post1.3',
-		createdAt: usersWithPosts?.posts[2]?.createdAt,
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: false, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: false,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-test('Get user with posts and posts with comments and comments with owner where exists', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-		where: (table, { exists, eq }) => exists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	expect(response.length).eq(1);
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				lower: 'group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/mysql.schema.ts b/integration-tests/tests/relational/mysql.schema.ts
deleted file mode 100644
index 385b200fe0..0000000000
--- a/integration-tests/tests/relational/mysql.schema.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import {
-	type AnyMySqlColumn,
-	bigint,
-	boolean,
-	mysqlSchema,
-	mysqlTable,
-	primaryKey,
-	serial,
-	text,
-	timestamp,
-} from 'drizzle-orm/mysql-core';
-
-import { relations } from 'drizzle-orm';
-
-export const usersTable = mysqlTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: bigint('invited_by', { mode: 'number' }).references(
-		(): AnyMySqlColumn => usersTable.id,
-	),
-});
-
-const schemaV1 = mysqlSchema('schemaV1');
-
-export const usersV1 = schemaV1.table('usersV1', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: bigint('invited_by', { mode: 'number' }),
-});
-
-export const usersTableV1 = schemaV1.table('users_table_V1', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: bigint('invited_by', { mode: 'number' }),
-});
-
-export const usersConfig = relations(usersTable, ({ one, many }) => ({
-	invitee: one(usersTable, {
-		fields: [usersTable.invitedBy],
-		references: [usersTable.id],
-	}),
-	usersToGroups: many(usersToGroupsTable),
-	posts: many(postsTable),
-	comments: many(commentsTable),
-}));
-
-export const groupsTable = mysqlTable('groups', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	description: text('description'),
-});
-export const groupsConfig = relations(groupsTable, ({ many }) => ({
-	usersToGroups: many(usersToGroupsTable),
-}));
-
-export const usersToGroupsTable = mysqlTable(
-	'users_to_groups',
-	{
-		id: serial('id').primaryKey(),
-		userId: bigint('user_id', { mode: 'number' }).notNull().references(
-			() => usersTable.id,
-		),
-		groupId: bigint('group_id', { mode: 'number' }).notNull().references(
-			() => groupsTable.id,
-		),
-	},
-	(t) => ({
-		pk: primaryKey(t.userId, t.groupId),
-	}),
-);
-export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
-	group: one(groupsTable, {
-		fields: [usersToGroupsTable.groupId],
-		references: [groupsTable.id],
-	}),
-	user: one(usersTable, {
-		fields: [usersToGroupsTable.userId],
-		references: [usersTable.id],
-	}),
-}));
-
-export const postsTable = mysqlTable('posts', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	ownerId: bigint('owner_id', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const postsConfig = relations(postsTable, ({ one, many }) => ({
-	author: one(usersTable, {
-		fields: [postsTable.ownerId],
-		references: [usersTable.id],
-	}),
-	comments: many(commentsTable),
-}));
-
-export const commentsTable = mysqlTable('comments', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	creator: bigint('creator', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	postId: bigint('post_id', { mode: 'number' }).references(() => postsTable.id),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
-	post: one(postsTable, {
-		fields: [commentsTable.postId],
-		references: [postsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentsTable.creator],
-		references: [usersTable.id],
-	}),
-	likes: many(commentLikesTable),
-}));
-
-export const commentLikesTable = mysqlTable('comment_likes', {
-	id: serial('id').primaryKey(),
-	creator: bigint('creator', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	commentId: bigint('comment_id', { mode: 'number' }).references(
-		() => commentsTable.id,
-	),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
-	comment: one(commentsTable, {
-		fields: [commentLikesTable.commentId],
-		references: [commentsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentLikesTable.creator],
-		references: [usersTable.id],
-	}),
-}));
diff --git a/integration-tests/tests/relational/mysql.test.ts b/integration-tests/tests/relational/mysql.test.ts
deleted file mode 100644
index c80bc9cb7c..0000000000
--- a/integration-tests/tests/relational/mysql.test.ts
+++ /dev/null
@@ -1,6416 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type MySql2Database } from 'drizzle-orm/mysql2';
-import getPort from 'get-port';
-import * as mysql from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './mysql.schema.ts';
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable, usersV1, usersTableV1 } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-declare module 'vitest' {
-	export interface TestContext {
-		docker: Docker;
-		mysqlContainer: Docker.Container;
-		mysqlDb: MySql2Database<typeof schema>;
-		mysqlClient: mysql.Connection;
-	}
-}
-
-let globalDocker: Docker;
-let mysqlContainer: Docker.Container;
-let db: MySql2Database<typeof schema>;
-let client: mysql.Connection;
-
-async function createDockerDB(): Promise<string> {
-	const docker = (globalDocker = new Docker());
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['MYSQL_CONNECTION_STRING'] ?? await createDockerDB();
-
-	const sleep = 1000;
-	let timeLeft = 30000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = await mysql.createConnection(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to MySQL');
-		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING, mode: 'default' });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
-});
-
-beforeEach(async (ctx) => {
-	ctx.mysqlDb = db;
-	ctx.mysqlClient = client;
-	ctx.docker = globalDocker;
-	ctx.mysqlContainer = mysqlContainer;
-
-	await ctx.mysqlDb.execute(sql`drop table if exists \`users\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`schemaV1\`.\`usersV1\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`schemaV1\`.\`users_table_V1\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`groups\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`users_to_groups\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`posts\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`comments\``);
-	await ctx.mysqlDb.execute(sql`drop table if exists \`comment_likes\``);
-
-	await ctx.mysqlDb.execute(sql`create schema if not exists \`schemaV1\``);
-
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`users\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`name\` text NOT NULL,
-				\`verified\` boolean DEFAULT false NOT NULL,
-				\`invited_by\` bigint REFERENCES \`users\`(\`id\`)
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`schemaV1\`.\`usersV1\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`name\` text NOT NULL,
-				\`verified\` boolean DEFAULT false NOT NULL,
-				\`invited_by\` bigint REFERENCES \`users\`(\`id\`)
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`schemaV1\`.\`users_table_V1\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`name\` text NOT NULL,
-				\`verified\` boolean DEFAULT false NOT NULL,
-				\`invited_by\` bigint REFERENCES \`users\`(\`id\`)
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`groups\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`name\` text NOT NULL,
-				\`description\` text
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`users_to_groups\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`user_id\` bigint REFERENCES \`users\`(\`id\`),
-				\`group_id\` bigint REFERENCES \`groups\`(\`id\`)
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`posts\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`content\` text NOT NULL,
-				\`owner_id\` bigint REFERENCES \`users\`(\`id\`),
-				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`comments\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`content\` text NOT NULL,
-				\`creator\` bigint REFERENCES \`users\`(\`id\`),
-				\`post_id\` bigint REFERENCES \`posts\`(\`id\`),
-				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-			);
-		`,
-	);
-	await ctx.mysqlDb.execute(
-		sql`
-			CREATE TABLE \`comment_likes\` (
-				\`id\` serial PRIMARY KEY NOT NULL,
-				\`creator\` bigint REFERENCES \`users\`(\`id\`),
-				\`comment_id\` bigint REFERENCES \`comments\`(\`id\`),
-				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: '2',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async (t) => {
-	const { mysqlDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
-	const { mysqlDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 1, content: 'Post1.2' },
-		{ id: 3, ownerId: 1, content: 'Post1.3' },
-		{ id: 4, ownerId: 2, content: 'Post2' },
-		{ id: 5, ownerId: 2, content: 'Post2.1' },
-		{ id: 6, ownerId: 3, content: 'Post3' },
-		{ id: 7, ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
-	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
-	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2.1',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3.1',
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-});
-
-test('[Find One] Get only custom fields + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(
-		async () =>
-			await db.query.usersTable.findMany({
-				columns: {},
-			}),
-	).rejects.toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async (t) => {
-	const { mysqlDb: db } = t;
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-	expect(usersWithPosts?.id).toEqual(1);
-	expect(usersWithPosts?.verified).toEqual(false);
-	expect(usersWithPosts?.invitedBy).toEqual(null);
-	expect(usersWithPosts?.name).toEqual('Dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 1,
-		ownerId: 1,
-		content: 'Post1',
-		createdAt: usersWithPosts?.posts[0]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 2,
-		ownerId: 1,
-		content: 'Post1.2',
-		createdAt: usersWithPosts?.posts[1]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 3,
-		ownerId: 1,
-		content: 'Post1.3',
-		createdAt: usersWithPosts?.posts[2]?.createdAt,
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: false, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: false,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-test('Get user with posts and posts with comments and comments with owner where exists', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-		where: (table, { exists, eq }) => exists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	expect(response.length).eq(1);
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				lower: 'group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + custom', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get schema users - dbName & tsName match', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('[Find Many] Get schema users - dbName & tsName mismatch', async (t) => {
-	const { mysqlDb: db } = t;
-
-	await db.insert(usersTableV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersTableV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/pg.postgresjs.test.ts b/integration-tests/tests/relational/pg.postgresjs.test.ts
deleted file mode 100644
index f88fb471da..0000000000
--- a/integration-tests/tests/relational/pg.postgresjs.test.ts
+++ /dev/null
@@ -1,6397 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import getPort from 'get-port';
-import postgres from 'postgres';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './pg.schema.ts';
-
-const ENABLE_LOGGING = false;
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable, usersV1, usersTableV1 } = schema;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-declare module 'vitest' {
-	export interface TestContext {
-		docker: Docker;
-		pgContainer: Docker.Container;
-		pgjsDb: PostgresJsDatabase<typeof schema>;
-		pgjsClient: postgres.Sql<{}>;
-	}
-}
-
-let globalDocker: Docker;
-let pgContainer: Docker.Container;
-let db: PostgresJsDatabase<typeof schema>;
-let client: postgres.Sql<{}>;
-
-async function createDockerDB(): Promise<string> {
-	const docker = (globalDocker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'POSTGRES_PASSWORD=postgres',
-			'POSTGRES_USER=postgres',
-			'POSTGRES_DB=postgres',
-		],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = postgres(connectionString, {
-				max: 1,
-				onnotice: () => {
-					// disable notices
-				},
-			});
-			await client`select 1`;
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-beforeEach(async (ctx) => {
-	ctx.pgjsDb = db;
-	ctx.pgjsClient = client;
-	ctx.docker = globalDocker;
-	ctx.pgContainer = pgContainer;
-
-	await ctx.pgjsDb.execute(sql`drop schema public cascade`);
-	await ctx.pgjsDb.execute(sql`drop schema if exists "schemaV1" cascade`);
-	await ctx.pgjsDb.execute(sql`create schema public`);
-	await ctx.pgjsDb.execute(sql`create schema "schemaV1"`);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE "users" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int REFERENCES "users"("id")
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE "schemaV1"."usersV1" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE "schemaV1"."users_table_V1" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"description" text
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "users_to_groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"user_id" int REFERENCES "users"("id"),
-				"group_id" int REFERENCES "groups"("id")
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "posts" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"owner_id" int REFERENCES "users"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comments" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"post_id" int REFERENCES "posts"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.pgjsDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comment_likes" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"comment_id" int REFERENCES "comments"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: '2',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async (t) => {
-	const { pgjsDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
-	const { pgjsDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'andrew',
-		posts: [{ lowerName: 'post2' }, {
-			lowerName: 'post2.1',
-		}],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'alex',
-		posts: [{ lowerName: 'post3' }, {
-			lowerName: 'post3.1',
-		}],
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare('query1');
-
-	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query2');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare('query3');
-
-	const usersWithPosts = await prepared.execute({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query4');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async (t) => {
-	const { pgjsDb: db } = t;
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts?.posts[2]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: false, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: false,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-test('Get user with posts and posts with comments and comments with owner where exists', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-		where: (table, { notExists, eq }) =>
-			notExists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	expect(response.length).eq(2);
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-				orderBy: usersToGroupsTable.groupId,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: expect.arrayContaining([
-			{
-				group: {
-					id: 2,
-					name: 'Group2',
-					description: null,
-				},
-			},
-			{
-				group: {
-					id: 3,
-					name: 'Group3',
-					description: null,
-				},
-			},
-		]),
-	});
-});
-
-test('[Find Many] Get groups with users', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-				orderBy: usersToGroupsTable.groupId,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [
-			{
-				group: {
-					id: 2,
-					name: 'Group2',
-					lower: 'group2',
-					description: null,
-				},
-			},
-			{
-				group: {
-					id: 3,
-					name: 'Group3',
-					lower: 'group3',
-					description: null,
-				},
-			},
-		],
-	});
-});
-
-test('Get groups with users + custom', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get schema users - dbName & tsName match', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('[Find Many] Get schema users - dbName & tsName mismatch', async (t) => {
-	const { pgjsDb: db } = t;
-
-	await db.insert(usersTableV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersTableV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/pg.schema.ts b/integration-tests/tests/relational/pg.schema.ts
deleted file mode 100644
index 8838d91f88..0000000000
--- a/integration-tests/tests/relational/pg.schema.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import {
-	boolean,
-	integer,
-	type PgColumn,
-	pgSchema,
-	pgTable,
-	primaryKey,
-	serial,
-	text,
-	timestamp,
-} from 'drizzle-orm/pg-core';
-
-import { relations } from 'drizzle-orm';
-
-export const usersTable = pgTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: integer('invited_by').references((): PgColumn => usersTable.id),
-});
-
-export const schemaV1 = pgSchema('schemaV1');
-
-export const usersV1 = schemaV1.table('usersV1', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: integer('invited_by'),
-});
-
-export const usersTableV1 = schemaV1.table('users_table_V1', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: integer('invited_by'),
-});
-
-export const usersConfig = relations(usersTable, ({ one, many }) => ({
-	invitee: one(usersTable, { fields: [usersTable.invitedBy], references: [usersTable.id] }),
-	usersToGroups: many(usersToGroupsTable),
-	posts: many(postsTable),
-}));
-
-export const groupsTable = pgTable('groups', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	description: text('description'),
-});
-
-export const groupsConfig = relations(groupsTable, ({ many }) => ({
-	usersToGroups: many(usersToGroupsTable),
-}));
-
-export const usersToGroupsTable = pgTable('users_to_groups', {
-	id: serial('id').primaryKey(),
-	userId: integer('user_id').notNull().references(() => usersTable.id),
-	groupId: integer('group_id').notNull().references(() => groupsTable.id),
-}, (t) => ({
-	pk: primaryKey(t.groupId, t.userId),
-}));
-
-export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
-	group: one(groupsTable, { fields: [usersToGroupsTable.groupId], references: [groupsTable.id] }),
-	user: one(usersTable, { fields: [usersToGroupsTable.userId], references: [usersTable.id] }),
-}));
-
-export const postsTable = pgTable('posts', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	ownerId: integer('owner_id').references(() => usersTable.id),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-export const postsConfig = relations(postsTable, ({ one, many }) => ({
-	author: one(usersTable, { fields: [postsTable.ownerId], references: [usersTable.id] }),
-	comments: many(commentsTable),
-}));
-
-export const commentsTable = pgTable('comments', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	creator: integer('creator').references(() => usersTable.id),
-	postId: integer('post_id').references(() => postsTable.id),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
-	post: one(postsTable, { fields: [commentsTable.postId], references: [postsTable.id] }),
-	author: one(usersTable, { fields: [commentsTable.creator], references: [usersTable.id] }),
-	likes: many(commentLikesTable),
-}));
-
-export const commentLikesTable = pgTable('comment_likes', {
-	id: serial('id').primaryKey(),
-	creator: integer('creator').references(() => usersTable.id),
-	commentId: integer('comment_id').references(() => commentsTable.id),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
-	comment: one(commentsTable, { fields: [commentLikesTable.commentId], references: [commentsTable.id] }),
-	author: one(usersTable, { fields: [commentLikesTable.creator], references: [usersTable.id] }),
-}));
diff --git a/integration-tests/tests/relational/pg.test.ts b/integration-tests/tests/relational/pg.test.ts
deleted file mode 100644
index 603353aa10..0000000000
--- a/integration-tests/tests/relational/pg.test.ts
+++ /dev/null
@@ -1,6477 +0,0 @@
-import 'dotenv/config';
-import Docker from 'dockerode';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
-import getPort from 'get-port';
-import pg from 'pg';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './pg.schema.ts';
-
-const { Client } = pg;
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable, usersV1, usersTableV1 } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-declare module 'vitest' {
-	export interface TestContext {
-		docker: Docker;
-		pgContainer: Docker.Container;
-		pgDb: NodePgDatabase<typeof schema>;
-		pgClient: pg.Client;
-	}
-}
-
-let globalDocker: Docker;
-let pgContainer: Docker.Container;
-let db: NodePgDatabase<typeof schema>;
-let client: pg.Client;
-
-async function createDockerDB(): Promise<string> {
-	const docker = (globalDocker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'POSTGRES_PASSWORD=postgres',
-			'POSTGRES_USER=postgres',
-			'POSTGRES_DB=postgres',
-		],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = new Client(connectionString);
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-beforeEach(async (ctx) => {
-	ctx.pgDb = db;
-	ctx.pgClient = client;
-	ctx.docker = globalDocker;
-	ctx.pgContainer = pgContainer;
-
-	await ctx.pgDb.execute(sql`drop schema public cascade`);
-	await ctx.pgDb.execute(sql`drop schema if exists "schemaV1" cascade`);
-	await ctx.pgDb.execute(sql`create schema public`);
-	await ctx.pgDb.execute(sql`create schema "schemaV1"`);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE "users" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int REFERENCES "users"("id")
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE "schemaV1"."usersV1" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE "schemaV1"."users_table_V1" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"description" text
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "users_to_groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"user_id" int REFERENCES "users"("id"),
-				"group_id" int REFERENCES "groups"("id")
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "posts" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"owner_id" int REFERENCES "users"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comments" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"post_id" int REFERENCES "posts"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.pgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comment_likes" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"comment_id" int REFERENCES "comments"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: '2',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async (t) => {
-	const { pgDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
-	const { pgDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'andrew',
-		posts: [{ lowerName: 'post2' }, {
-			lowerName: 'post2.1',
-		}],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'alex',
-		posts: [{ lowerName: 'post3' }, {
-			lowerName: 'post3.1',
-		}],
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					contentLower: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				contentLower: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ contentLower: 'post1.2' }, { contentLower: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare('query1');
-
-	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query2');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare('query3');
-
-	const usersWithPosts = await prepared.execute({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query4');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async (t) => {
-	const { pgDb: db } = t;
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts?.posts[2]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: false, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: false,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-test('Get user with posts and posts with comments and comments with owner where exists', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-		where: (table, { exists, eq }) => exists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	expect(response.length).eq(1);
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relation
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+comment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-				orderBy: usersToGroupsTable.userId,
-			},
-		},
-		orderBy: usersTable.id,
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: expect.arrayContaining([
-			{
-				group: {
-					id: 2,
-					name: 'Group2',
-					description: null,
-				},
-			},
-			{
-				group: {
-					id: 3,
-					name: 'Group3',
-					description: null,
-				},
-			},
-		]),
-	});
-});
-
-test('[Find Many] Get groups with users', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-				orderBy: usersToGroupsTable.groupId,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [
-			{
-				group: {
-					id: 2,
-					name: 'Group2',
-					lower: 'group2',
-					description: null,
-				},
-			},
-			{
-				group: {
-					id: 3,
-					name: 'Group3',
-					lower: 'group3',
-					description: null,
-				},
-			},
-		],
-	});
-});
-
-test('Get groups with users + custom', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Filter by columns not present in select', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-		},
-		where: eq(usersTable.name, 'Dan'),
-	});
-
-	expect(response).toEqual({ id: 1 });
-});
-
-test('[Find Many] Get schema users - dbName & tsName match', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('[Find Many] Get schema users - dbName & tsName mismatch', async (t) => {
-	const { pgDb: db } = t;
-
-	await db.insert(usersTableV1).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const schemaUsers = await db.query.usersTableV1.findMany();
-
-	expectTypeOf(schemaUsers).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-	}[]>();
-
-	schemaUsers.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(schemaUsers.length).eq(3);
-	expect(schemaUsers[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-	});
-	expect(schemaUsers[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-	});
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// test('Filter by relational column', async (t) => {
-// 	const { pgDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ id: 1, ownerId: 1, content: 'Content1' },
-// 		{ id: 2, ownerId: 2, content: 'Post2' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: true,
-// 		},
-// 		where: (users) => sql`json_array_length(${users.posts}) > 0`,
-// 		orderBy: usersTable.id,
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 1,
-// 			content: 'Content1',
-// 			ownerId: 1,
-// 			createdAt: expect.any(Date),
-// 		}],
-// 	});
-
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 2,
-// 			content: 'Post2',
-// 			ownerId: 2,
-// 			createdAt: expect.any(Date),
-// 		}],
-// 	});
-// });
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/singlestore.schema.ts b/integration-tests/tests/relational/singlestore.schema.ts
deleted file mode 100644
index ca3386ba02..0000000000
--- a/integration-tests/tests/relational/singlestore.schema.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { bigint, boolean, primaryKey, serial, singlestoreTable, text, timestamp } from 'drizzle-orm/singlestore-core';
-
-import { relations } from 'drizzle-orm';
-
-export const usersTable = singlestoreTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	invitedBy: bigint('invited_by', { mode: 'number' }),
-});
-export const usersConfig = relations(usersTable, ({ one, many }) => ({
-	invitee: one(usersTable, {
-		fields: [usersTable.invitedBy],
-		references: [usersTable.id],
-	}),
-	usersToGroups: many(usersToGroupsTable),
-	posts: many(postsTable),
-	comments: many(commentsTable),
-}));
-
-export const groupsTable = singlestoreTable('groups', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	description: text('description'),
-});
-export const groupsConfig = relations(groupsTable, ({ many }) => ({
-	usersToGroups: many(usersToGroupsTable),
-}));
-
-export const usersToGroupsTable = singlestoreTable(
-	'users_to_groups',
-	{
-		id: serial('id').primaryKey(),
-		userId: bigint('user_id', { mode: 'number' }).notNull(),
-		groupId: bigint('group_id', { mode: 'number' }).notNull(),
-	},
-	(t) => ({
-		pk: primaryKey(t.userId, t.groupId),
-	}),
-);
-export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
-	group: one(groupsTable, {
-		fields: [usersToGroupsTable.groupId],
-		references: [groupsTable.id],
-	}),
-	user: one(usersTable, {
-		fields: [usersToGroupsTable.userId],
-		references: [usersTable.id],
-	}),
-}));
-
-export const postsTable = singlestoreTable('posts', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	ownerId: bigint('owner_id', { mode: 'number' }),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const postsConfig = relations(postsTable, ({ one, many }) => ({
-	author: one(usersTable, {
-		fields: [postsTable.ownerId],
-		references: [usersTable.id],
-	}),
-	comments: many(commentsTable),
-}));
-
-export const commentsTable = singlestoreTable('comments', {
-	id: serial('id').primaryKey(),
-	content: text('content').notNull(),
-	creator: bigint('creator', { mode: 'number' }),
-	postId: bigint('post_id', { mode: 'number' }),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
-	post: one(postsTable, {
-		fields: [commentsTable.postId],
-		references: [postsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentsTable.creator],
-		references: [usersTable.id],
-	}),
-	likes: many(commentLikesTable),
-}));
-
-export const commentLikesTable = singlestoreTable('comment_likes', {
-	id: serial('id').primaryKey(),
-	creator: bigint('creator', { mode: 'number' }),
-	commentId: bigint('comment_id', { mode: 'number' }),
-	createdAt: timestamp('created_at')
-		.notNull()
-		.defaultNow(),
-});
-export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
-	comment: one(commentsTable, {
-		fields: [commentLikesTable.commentId],
-		references: [commentsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentLikesTable.creator],
-		references: [usersTable.id],
-	}),
-}));
diff --git a/integration-tests/tests/relational/singlestore.test.ts b/integration-tests/tests/relational/singlestore.test.ts
deleted file mode 100644
index 0e20a7046f..0000000000
--- a/integration-tests/tests/relational/singlestore.test.ts
+++ /dev/null
@@ -1,6403 +0,0 @@
-// import retry from 'async-retry';
-// import Docker from 'dockerode';
-// import 'dotenv/config';
-// import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-// import { drizzle, type SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
-// import getPort from 'get-port';
-// import * as mysql from 'mysql2/promise';
-// import { v4 as uuid } from 'uuid';
-// import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-// import * as schema from './singlestore.schema.ts';
-
-// const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
-
-// const ENABLE_LOGGING = false;
-
-// /*
-// 	Test cases:
-// 	- querying nested relation without PK with additional fields
-// */
-
-// declare module 'vitest' {
-// 	export interface TestContext {
-// 		docker: Docker;
-// 		singlestoreContainer: Docker.Container;
-// 		singlestoreDb: SingleStoreDriverDatabase<typeof schema>;
-// 		singlestoreClient: mysql.Connection;
-// 	}
-// }
-
-// let globalDocker: Docker;
-// let singlestoreContainer: Docker.Container;
-// let db: SingleStoreDriverDatabase<typeof schema>;
-// let client: mysql.Connection;
-
-// async function createDockerDB(): Promise<string> {
-// 	const docker = new Docker();
-// 	const port = await getPort({ port: 3306 });
-// 	const image = 'ghcr.io/singlestore-labs/singlestoredb-dev:latest';
-
-// 	const pullStream = await docker.pull(image);
-// 	await new Promise((resolve, reject) =>
-// 		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-// 	);
-
-// 	singlestoreContainer = await docker.createContainer({
-// 		Image: image,
-// 		Env: ['ROOT_PASSWORD=singlestore'],
-// 		name: `drizzle-integration-tests-${uuid()}`,
-// 		HostConfig: {
-// 			AutoRemove: true,
-// 			PortBindings: {
-// 				'3306/tcp': [{ HostPort: `${port}` }],
-// 			},
-// 		},
-// 	});
-
-// 	await singlestoreContainer.start();
-// 	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-// 	return `singlestore://root:singlestore@localhost:${port}/`;
-// }
-
-// beforeAll(async () => {
-// 	const connectionString = process.env['SINGLESTORE_CONNECTION_STRING'] ?? (await createDockerDB());
-// 	client = await retry(async () => {
-// 		client = await mysql.createConnection(connectionString);
-// 		await client.connect();
-// 		return client;
-// 	}, {
-// 		retries: 20,
-// 		factor: 1,
-// 		minTimeout: 250,
-// 		maxTimeout: 250,
-// 		randomize: false,
-// 		onRetry() {
-// 			client?.end();
-// 		},
-// 	});
-
-// 	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle;`);
-// 	await client.changeUser({ database: 'drizzle' });
-// 	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-// });
-
-// afterAll(async () => {
-// 	await client?.end().catch(console.error);
-// 	await singlestoreContainer?.stop().catch(console.error);
-// });
-
-// beforeEach(async (ctx) => {
-// 	ctx.singlestoreDb = db;
-// 	ctx.singlestoreClient = client;
-// 	ctx.docker = globalDocker;
-// 	ctx.singlestoreContainer = singlestoreContainer;
-
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`users\``);
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`groups\``);
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`users_to_groups\``);
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`posts\``);
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`comments\``);
-// 	await ctx.singlestoreDb.execute(sql`drop table if exists \`comment_likes\``);
-
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`users\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`name\` text NOT NULL,
-// 				\`verified\` boolean DEFAULT false NOT NULL,
-// 				\`invited_by\` bigint
-// 			);
-// 		`,
-// 	);
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`groups\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`name\` text NOT NULL,
-// 				\`description\` text
-// 			);
-// 		`,
-// 	);
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`users_to_groups\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`user_id\` bigint,
-// 				\`group_id\` bigint
-// 			);
-// 		`,
-// 	);
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`posts\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`content\` text NOT NULL,
-// 				\`owner_id\` bigint,
-// 				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-// 			);
-// 		`,
-// 	);
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`comments\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`content\` text NOT NULL,
-// 				\`creator\` bigint,
-// 				\`post_id\` bigint,
-// 				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-// 			);
-// 		`,
-// 	);
-// 	await ctx.singlestoreDb.execute(
-// 		sql`
-// 			CREATE TABLE \`comment_likes\` (
-// 				\`id\` serial PRIMARY KEY NOT NULL,
-// 				\`creator\` bigint,
-// 				\`comment_id\` bigint,
-// 				\`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
-// 			);
-// 		`,
-// 	);
-// });
-
-// /*
-// 	[Find Many] One relation users+posts
-// */
-
-// test('[Find Many] Get users with posts', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: true,
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithPosts.length).eq(3);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-// 	expect(usersWithPosts[1]?.posts.length).eq(1);
-// 	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + limit posts', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithPosts.length).eq(3);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-// 	expect(usersWithPosts[1]?.posts.length).eq(1);
-// 	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + limit posts and users', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		limit: 2,
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithPosts.length).eq(2);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-// 	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + custom fields', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: true,
-// 		},
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		lowerName: string;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithPosts.length).toEqual(3);
-// 	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-// 	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-// 	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		lowerName: 'dan',
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-// 			id: 2,
-// 			ownerId: 1,
-// 			content: 'Post1.2',
-// 			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-// 		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lowerName: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-// 			id: 5,
-// 			ownerId: 2,
-// 			content: 'Post2.1',
-// 			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(usersWithPosts[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lowerName: 'alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-// 			id: 7,
-// 			ownerId: 3,
-// 			content: 'Post3.1',
-// 			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + custom fields + limits', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		limit: 1,
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 		extras: (usersTable, { sql }) => ({
-// 			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		lowerName: string;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).toEqual(1);
-// 	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lowerName: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: '1' },
-// 		{ ownerId: 1, content: '2' },
-// 		{ ownerId: 1, content: '3' },
-// 		{ ownerId: 2, content: '4' },
-// 		{ ownerId: 2, content: '5' },
-// 		{ ownerId: 3, content: '6' },
-// 		{ ownerId: 3, content: '7' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-// 			},
-// 		},
-// 		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(3);
-// 	expect(usersWithPosts[0]?.posts.length).eq(2);
-// 	expect(usersWithPosts[1]?.posts.length).eq(2);
-// 	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-// 	expect(usersWithPosts[2]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-// 			id: 2,
-// 			ownerId: 1,
-// 			content: '2',
-// 			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-// 		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 5,
-// 			ownerId: 2,
-// 			content: '5',
-// 			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-// 		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 7,
-// 			ownerId: 3,
-// 			content: '7',
-// 			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-// 		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 		with: {
-// 			posts: {
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + where + partial', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: true,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		posts: [{ id: 1, content: 'Post1' }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: true,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		posts: [{ id: 1, content: 'Post1' }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {
-// 			id: true,
-// 			name: false,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: false,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		posts: {
-// 			id: number;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		posts: [{ id: 1 }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {
-// 			name: false,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					content: false,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts in transaction', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	let usersWithPosts: {
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[] = [];
-
-// 	await db.transaction(async (tx) => {
-// 		await tx.insert(usersTable).values([
-// 			{ id: 1, name: 'Dan' },
-// 			{ id: 2, name: 'Andrew' },
-// 			{ id: 3, name: 'Alex' },
-// 		]);
-
-// 		await tx.insert(postsTable).values([
-// 			{ ownerId: 1, content: 'Post1' },
-// 			{ ownerId: 1, content: 'Post1.1' },
-// 			{ ownerId: 2, content: 'Post2' },
-// 			{ ownerId: 3, content: 'Post3' },
-// 		]);
-
-// 		usersWithPosts = await tx.query.usersTable.findMany({
-// 			where: (({ id }, { eq }) => eq(id, 1)),
-// 			with: {
-// 				posts: {
-// 					where: (({ id }, { eq }) => eq(id, 1)),
-// 				},
-// 			},
-// 		});
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	let usersWithPosts: {
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[] = [];
-
-// 	await expect(db.transaction(async (tx) => {
-// 		await tx.insert(usersTable).values([
-// 			{ id: 1, name: 'Dan' },
-// 			{ id: 2, name: 'Andrew' },
-// 			{ id: 3, name: 'Alex' },
-// 		]);
-
-// 		await tx.insert(postsTable).values([
-// 			{ ownerId: 1, content: 'Post1' },
-// 			{ ownerId: 1, content: 'Post1.1' },
-// 			{ ownerId: 2, content: 'Post2' },
-// 			{ ownerId: 3, content: 'Post3' },
-// 		]);
-
-// 		tx.rollback();
-
-// 		usersWithPosts = await tx.query.usersTable.findMany({
-// 			where: (({ id }, { eq }) => eq(id, 1)),
-// 			with: {
-// 				posts: {
-// 					where: (({ id }, { eq }) => eq(id, 1)),
-// 				},
-// 			},
-// 		});
-// 	})).rejects.toThrowError(new TransactionRollbackError());
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(0);
-// });
-
-// // select only custom
-// test('[Find Many] Get only custom fields', async () => {
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ id: 1, ownerId: 1, content: 'Post1' },
-// 		{ id: 2, ownerId: 1, content: 'Post1.2' },
-// 		{ id: 3, ownerId: 1, content: 'Post1.3' },
-// 		{ id: 4, ownerId: 2, content: 'Post2' },
-// 		{ id: 5, ownerId: 2, content: 'Post2.1' },
-// 		{ id: 6, ownerId: 3, content: 'Post3' },
-// 		{ id: 7, ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		lowerName: string;
-// 		posts: {
-// 			lowerName: string;
-// 		}[];
-// 	}[]>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toHaveLength(3);
-
-// 	// Helper function to find user by lowerName
-// 	const findUser = (lowerName: string) => usersWithPosts.find((user) => user.lowerName === lowerName);
-
-// 	// Assertions for each user
-// 	const dan = findUser('dan');
-// 	const andrew = findUser('andrew');
-// 	const alex = findUser('alex');
-
-// 	expect(dan).toBeDefined();
-// 	expect(andrew).toBeDefined();
-// 	expect(alex).toBeDefined();
-
-// 	// Verify the number of posts for each user
-// 	expect(dan?.posts).toHaveLength(3);
-// 	expect(andrew?.posts).toHaveLength(2);
-// 	expect(alex?.posts).toHaveLength(2);
-
-// 	// Define expected posts for each user
-// 	const expectedDanPosts = ['post1', 'post1.2', 'post1.3'];
-// 	const expectedAndrewPosts = ['post2', 'post2.1'];
-// 	const expectedAlexPosts = ['post3', 'post3.1'];
-
-// 	// Helper function to extract lowerNames from posts
-// 	const getPostLowerNames = (posts: { lowerName: string }[]) => posts.map((post) => post.lowerName);
-
-// 	// Assertions for Dan's posts
-// 	expect(getPostLowerNames(dan!.posts)).toEqual(expect.arrayContaining(expectedDanPosts));
-// 	expect(getPostLowerNames(dan!.posts)).toHaveLength(expectedDanPosts.length);
-
-// 	// Assertions for Andrew's posts
-// 	expect(getPostLowerNames(andrew!.posts)).toEqual(expect.arrayContaining(expectedAndrewPosts));
-// 	expect(getPostLowerNames(andrew!.posts)).toHaveLength(expectedAndrewPosts.length);
-
-// 	// Assertions for Alex's posts
-// 	expect(getPostLowerNames(alex!.posts)).toEqual(expect.arrayContaining(expectedAlexPosts));
-// 	expect(getPostLowerNames(alex!.posts)).toHaveLength(expectedAlexPosts.length);
-// });
-
-// // select only custom with where clause (Order Agnostic)
-// test('[Find Many] Get only custom fields + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	// Insert Users
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	// Insert Posts
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	// Query Users with Posts where users.id = 1 and posts.id >= 2
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		lowerName: string;
-// 		posts: {
-// 			lowerName: string;
-// 		}[];
-// 	}[]>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toHaveLength(1);
-
-// 	// Since we expect only one user, we can extract it directly
-// 	const danWithPosts = usersWithPosts[0];
-
-// 	// Assert that the user exists and has the correct lowerName
-// 	expect(danWithPosts).toBeDefined();
-// 	expect(danWithPosts?.lowerName).toBe('dan');
-
-// 	// Assert that the user has the expected number of posts
-// 	expect(danWithPosts?.posts).toHaveLength(2);
-
-// 	// Define the expected posts
-// 	const expectedPosts = ['post1.2', 'post1.3'];
-
-// 	// Extract the lowerName of each post
-// 	const actualPostLowerNames = danWithPosts?.posts.map((post) => post.lowerName);
-
-// 	// Assert that all expected posts are present, regardless of order
-// 	for (const expectedPost of expectedPosts) {
-// 		expect(actualPostLowerNames).toContain(expectedPost);
-// 	}
-
-// 	// Additionally, ensure no unexpected posts are present
-// 	expect(actualPostLowerNames).toHaveLength(expectedPosts.length);
-// });
-
-// test.skip('[Find Many] Get only custom fields + where + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				limit: 1,
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		lowerName: string;
-// 		posts: {
-// 			lowerName: string;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).toEqual(1);
-// 	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-// 	expect(usersWithPosts).toContainEqual({
-// 		lowerName: 'dan',
-// 		posts: [{ lowerName: 'post1.2' }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get only custom fields + where + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findMany({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				orderBy: [desc(postsTable.id)],
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		lowerName: string;
-// 		posts: {
-// 			lowerName: string;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).toEqual(1);
-// 	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-// 	expect(usersWithPosts).toContainEqual({
-// 		lowerName: 'dan',
-// 		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-// 	});
-// });
-
-// // select only custom find one (Order Agnostic)
-// test('[Find One] Get only custom fields (Order Agnostic)', async () => {
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	// Query to find the first user without any specific order
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			lowerName: string;
-// 			posts: {
-// 				lowerName: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toBeDefined();
-
-// 	// Since findFirst without orderBy can return any user, we'll verify the returned user and their posts
-// 	if (usersWithPosts) {
-// 		// Define expected users and their corresponding posts
-// 		const expectedUsers: { [key: string]: string[] } = {
-// 			dan: ['post1', 'post1.2', 'post1.3'],
-// 			andrew: ['post2', 'post2.1'],
-// 			alex: ['post3', 'post3.1'],
-// 		};
-
-// 		// Verify that the returned user is one of the expected users
-// 		expect(Object.keys(expectedUsers)).toContain(usersWithPosts.lowerName);
-
-// 		// Get the expected posts for the returned user
-// 		const expectedPosts = expectedUsers[usersWithPosts.lowerName] as string[];
-
-// 		// Verify the number of posts
-// 		expect(usersWithPosts.posts).toHaveLength(expectedPosts.length);
-
-// 		// Extract the lowerName of each post
-// 		const actualPostLowerNames = usersWithPosts.posts.map((post) => post.lowerName);
-
-// 		// Assert that all expected posts are present, regardless of order
-// 		for (const expectedPost of expectedPosts) {
-// 			expect(actualPostLowerNames).toContain(expectedPost.toLowerCase());
-// 		}
-// 	}
-// });
-
-// // select only custom find one with where clause (Order Agnostic)
-// test('[Find One] Get only custom fields + where (Order Agnostic)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	// Query to find the first user with id = 1 and posts with id >= 2
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			lowerName: string;
-// 			posts: {
-// 				lowerName: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toBeDefined();
-
-// 	if (usersWithPosts) {
-// 		// Assert that the returned user has the expected lowerName
-// 		expect(usersWithPosts.lowerName).toBe('dan');
-
-// 		// Assert that the user has exactly two posts
-// 		expect(usersWithPosts.posts).toHaveLength(2);
-
-// 		// Define the expected posts
-// 		const expectedPosts = ['post1.2', 'post1.3'];
-
-// 		// Extract the lowerName of each post
-// 		const actualPostLowerNames = usersWithPosts.posts.map((post) => post.lowerName);
-
-// 		// Assert that all expected posts are present, regardless of order
-// 		for (const expectedPost of expectedPosts) {
-// 			expect(actualPostLowerNames).toContain(expectedPost.toLowerCase());
-// 		}
-
-// 		// Additionally, ensure no unexpected posts are present
-// 		expect(actualPostLowerNames).toHaveLength(expectedPosts.length);
-// 	}
-// });
-
-// test.skip('[Find One] Get only custom fields + where + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				limit: 1,
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			lowerName: string;
-// 			posts: {
-// 				lowerName: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts?.posts.length).toEqual(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		lowerName: 'dan',
-// 		posts: [{ lowerName: 'post1.2' }],
-// 	});
-// });
-
-// test.skip('[Find One] Get only custom fields + where + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {},
-// 		with: {
-// 			posts: {
-// 				columns: {},
-// 				where: gte(postsTable.id, 2),
-// 				orderBy: [desc(postsTable.id)],
-// 				extras: ({ content }) => ({
-// 					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-// 				}),
-// 			},
-// 		},
-// 		where: eq(usersTable.id, 1),
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			lowerName: string;
-// 			posts: {
-// 				lowerName: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts?.posts.length).toEqual(2);
-
-// 	expect(usersWithPosts).toEqual({
-// 		lowerName: 'dan',
-// 		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-// 	});
-// });
-
-// // columns {}
-// test('[Find Many] Get select {}', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await expect(
-// 		async () =>
-// 			await db.query.usersTable.findMany({
-// 				columns: {},
-// 			}),
-// 	).rejects.toThrow(DrizzleError);
-// });
-
-// // columns {}
-// test('[Find One] Get select {}', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await expect(async () =>
-// 		await db.query.usersTable.findFirst({
-// 			columns: {},
-// 		})
-// 	).rejects.toThrow(DrizzleError);
-// });
-
-// // deep select {}
-// test('[Find Many] Get deep select {}', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	await expect(async () =>
-// 		await db.query.usersTable.findMany({
-// 			columns: {},
-// 			with: {
-// 				posts: {
-// 					columns: {},
-// 				},
-// 			},
-// 		})
-// 	).rejects.toThrow(DrizzleError);
-// });
-
-// // deep select {}
-// test('[Find One] Get deep select {}', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	await expect(async () =>
-// 		await db.query.usersTable.findFirst({
-// 			columns: {},
-// 			with: {
-// 				posts: {
-// 					columns: {},
-// 				},
-// 			},
-// 		})
-// 	).rejects.toThrow(DrizzleError);
-// });
-
-// /*
-// 	Prepared statements for users+posts
-// */
-// test.skip('[Find Many] Get users with posts + prepared limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const prepared = db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				limit: placeholder('limit'),
-// 			},
-// 		},
-// 	}).prepare();
-
-// 	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(3);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-// 	expect(usersWithPosts[1]?.posts.length).eq(1);
-// 	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const prepared = db.query.usersTable.findMany({
-// 		limit: placeholder('uLimit'),
-// 		offset: placeholder('uOffset'),
-// 		with: {
-// 			posts: {
-// 				limit: placeholder('pLimit'),
-// 			},
-// 		},
-// 	}).prepare();
-
-// 	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(2);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-// 	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find Many] Get users with posts + prepared where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const prepared = db.query.usersTable.findMany({
-// 		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-// 		with: {
-// 			posts: {
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 	}).prepare();
-
-// 	const usersWithPosts = await prepared.execute({ id: 1 });
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const prepared = db.query.usersTable.findMany({
-// 		limit: placeholder('uLimit'),
-// 		offset: placeholder('uOffset'),
-// 		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-// 		with: {
-// 			posts: {
-// 				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-// 				limit: placeholder('pLimit'),
-// 			},
-// 		},
-// 	}).prepare();
-
-// 	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 		}[];
-// 	}[]>();
-
-// 	expect(usersWithPosts.length).eq(1);
-// 	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// /*
-// 	[Find One] One relation users+posts
-// */
-
-// test.only('[Find One] Get users with posts', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: true,
-// 		},
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toBeDefined();
-
-// 	if (usersWithPosts) {
-// 		const { id, name, posts } = usersWithPosts;
-
-// 		// Verify that the user is one of the inserted users
-// 		const validUsers: { [key: number]: string } = {
-// 			1: 'dan',
-// 			2: 'andrew',
-// 			3: 'alex',
-// 		};
-// 		expect(validUsers[id]).toBe(name.toLowerCase());
-
-// 		// Assert that the user has exactly one post
-// 		expect(posts).toHaveLength(1);
-
-// 		const post = posts[0];
-
-// 		// Verify that the post belongs to the user
-// 		expect(post?.ownerId).toBe(id);
-
-// 		// Verify that the post content matches the user
-// 		const expectedPostContent = `Post${id}`;
-// 		expect(post?.content.toLowerCase()).toBe(expectedPostContent.toLowerCase());
-
-// 		// Optionally, verify the presence of `createdAt`
-// 		expect(post?.createdAt).toBeInstanceOf(Date);
-// 	}
-// });
-
-// test.skip('[Find One] Get users with posts + limit posts', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with posts no results found', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts).toBeUndefined();
-// });
-
-// test.skip('[Find One] Get users with posts + limit posts and users', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find One] Get users with posts + custom fields', async () => {
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: true,
-// 		},
-// 		extras: ({ name }) => ({
-// 			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	// Type Assertion
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			lowerName: string;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	// General Assertions
-// 	expect(usersWithPosts).toBeDefined();
-
-// 	if (usersWithPosts) {
-// 		const { id, lowerName, posts } = usersWithPosts;
-
-// 		// Define valid users and their expected lower names
-// 		const validUsers: { [key: number]: string } = {
-// 			1: 'dan',
-// 			2: 'andrew',
-// 			3: 'alex',
-// 		};
-
-// 		// Verify that the returned user's lowerName matches the expected value
-// 		expect(validUsers[id]).toBe(lowerName);
-
-// 		// Define the expected posts based on the user ID
-// 		const expectedPostsByUser: Record<number, string[]> = {
-// 			1: ['post1', 'post1.2', 'post1.3'],
-// 			2: ['post2', 'post2.1'],
-// 			3: ['post3', 'post3.1'],
-// 		};
-
-// 		// Get the expected posts for the returned user
-// 		const expectedPosts = expectedPostsByUser[id] || [];
-
-// 		// Extract the lowerName of each post
-// 		const actualPostContents = posts.map((post) => post.content.toLowerCase());
-
-// 		// Assert that all expected posts are present, regardless of order
-// 		for (const expectedPost of expectedPosts) {
-// 			expect(actualPostContents).toContain(expectedPost.toLowerCase());
-// 		}
-
-// 		// Optionally, ensure that no unexpected posts are present
-// 		expect(actualPostContents).toHaveLength(expectedPosts.length);
-// 	}
-// });
-
-// test.skip('[Find One] Get users with posts + custom fields + limits', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.2' },
-// 		{ ownerId: 1, content: 'Post1.3' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 		extras: (usersTable, { sql }) => ({
-// 			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-// 		}),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			lowerName: string;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).toEqual(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lowerName: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with posts + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: '1' },
-// 		{ ownerId: 1, content: '2' },
-// 		{ ownerId: 1, content: '3' },
-// 		{ ownerId: 2, content: '4' },
-// 		{ ownerId: 2, content: '5' },
-// 		{ ownerId: 3, content: '6' },
-// 		{ ownerId: 3, content: '7' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		with: {
-// 			posts: {
-// 				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-// 			},
-// 		},
-// 		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(2);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 7,
-// 			ownerId: 3,
-// 			content: '7',
-// 			createdAt: usersWithPosts?.posts[1]?.createdAt,
-// 		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find One] Get users with posts + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 		with: {
-// 			posts: {
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test('[Find One] Get users with posts + where + partial', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: true,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		posts: [{ id: 1, content: 'Post1' }],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: true,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		posts: [{ id: 1, content: 'Post1' }],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {
-// 			id: true,
-// 			name: false,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: false,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			posts: {
-// 				id: number;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		posts: [{ id: 1 }],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with posts + where + partial(false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const usersWithPosts = await db.query.usersTable.findFirst({
-// 		columns: {
-// 			name: false,
-// 		},
-// 		with: {
-// 			posts: {
-// 				columns: {
-// 					content: false,
-// 				},
-// 				where: (({ id }, { eq }) => eq(id, 1)),
-// 			},
-// 		},
-// 		where: (({ id }, { eq }) => eq(id, 1)),
-// 	});
-
-// 	expectTypeOf(usersWithPosts).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(usersWithPosts!.posts.length).eq(1);
-
-// 	expect(usersWithPosts).toEqual({
-// 		id: 1,
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// /*
-// 	One relation users+users. Self referencing
-// */
-
-// test.skip('Get user with invitee', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		with: {
-// 			invitee: true,
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithInvitee.length).eq(4);
-// 	expect(usersWithInvitee[0]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 	});
-// 	expect(usersWithInvitee[3]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user + limit with invitee', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew', invitedBy: 1 },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		with: {
-// 			invitee: true,
-// 		},
-// 		limit: 2,
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user with invitee and custom fields', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-// 		with: {
-// 			invitee: {
-// 				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			lower: string;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				lower: string;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithInvitee.length).eq(4);
-// 	expect(usersWithInvitee[0]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lower: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lower: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-// 	});
-// 	expect(usersWithInvitee[3]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		lower: 'john',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user with invitee and custom fields + limits', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-// 		limit: 3,
-// 		with: {
-// 			invitee: {
-// 				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			lower: string;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				lower: string;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(usersWithInvitee.length).eq(3);
-// 	expect(usersWithInvitee[0]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lower: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lower: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[2]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user with invitee + order by', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		with: {
-// 			invitee: true,
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(4);
-// 	expect(usersWithInvitee[3]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[2]?.invitee).toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee[3]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[2]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 	});
-// 	expect(usersWithInvitee[1]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 	});
-// 	expect(usersWithInvitee[0]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user with invitee + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		with: {
-// 			invitee: true,
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 	});
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 	});
-// });
-
-// test.skip('Get user with invitee + where + partial', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			invitee: {
-// 				columns: {
-// 					id: true,
-// 					name: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		invitee: { id: 1, name: 'Dan' },
-// 	});
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		invitee: { id: 2, name: 'Andrew' },
-// 	});
-// });
-
-// test.skip('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		columns: {
-// 			name: true,
-// 		},
-// 		with: {
-// 			invitee: {
-// 				columns: {
-// 					id: true,
-// 					name: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			name: string;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee).toContainEqual({
-// 		name: 'Alex',
-// 		invitee: { id: 1, name: 'Dan' },
-// 	});
-// 	expect(usersWithInvitee).toContainEqual({
-// 		name: 'John',
-// 		invitee: { id: 2, name: 'Andrew' },
-// 	});
-// });
-
-// test.skip('Get user with invitee + where + partial(true+false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 			verified: false,
-// 		},
-// 		with: {
-// 			invitee: {
-// 				columns: {
-// 					id: true,
-// 					name: true,
-// 					verified: false,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		invitee: { id: 1, name: 'Dan' },
-// 	});
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		invitee: { id: 2, name: 'Andrew' },
-// 	});
-// });
-
-// test.skip('Get user with invitee + where + partial(false)', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	const usersWithInvitee = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		columns: {
-// 			verified: false,
-// 		},
-// 		with: {
-// 			invitee: {
-// 				columns: {
-// 					name: false,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			invitedBy: number | null;
-// 			invitee: {
-// 				id: number;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(usersWithInvitee.length).eq(2);
-// 	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-// 	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		invitedBy: 1,
-// 		invitee: { id: 1, verified: false, invitedBy: null },
-// 	});
-// 	expect(usersWithInvitee).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		invitedBy: 2,
-// 		invitee: { id: 2, verified: false, invitedBy: null },
-// 	});
-// });
-
-// /*
-// 	Two first-level relations users+users and users+posts
-// */
-
-// test.skip('Get user with invitee and posts', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			invitee: true,
-// 			posts: true,
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(4);
-
-// 	expect(response[0]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).toBeNull();
-// 	expect(response[2]?.invitee).not.toBeNull();
-// 	expect(response[3]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 		posts: [],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + limit posts and users', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		limit: 3,
-// 		with: {
-// 			invitee: true,
-// 			posts: {
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(3);
-
-// 	expect(response[0]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).toBeNull();
-// 	expect(response[2]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + limits + custom fields in each', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		limit: 3,
-// 		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-// 		with: {
-// 			invitee: {
-// 				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-// 			},
-// 			posts: {
-// 				limit: 1,
-// 				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			lower: string;
-// 			invitedBy: number | null;
-// 			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				lower: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(3);
-
-// 	expect(response[0]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).toBeNull();
-// 	expect(response[2]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lower: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lower: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-// 		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + custom fields in each', async () => {
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-// 		with: {
-// 			invitee: {
-// 				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-// 			},
-// 			posts: {
-// 				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			lower: string;
-// 			invitedBy: number | null;
-// 			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				lower: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-// 	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(4);
-
-// 	expect(response[0]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).toBeNull();
-// 	expect(response[2]?.invitee).not.toBeNull();
-// 	expect(response[3]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(2);
-// 	expect(response[1]?.posts.length).eq(2);
-// 	expect(response[2]?.posts.length).eq(2);
-// 	expect(response[3]?.posts.length).eq(0);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lower: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-// 			id: 2,
-// 			ownerId: 1,
-// 			content: 'Post1.1',
-// 			lower: 'post1.1',
-// 			createdAt: response[0]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lower: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-// 			id: 4,
-// 			ownerId: 2,
-// 			content: 'Post2.1',
-// 			lower: 'post2.1',
-// 			createdAt: response[1]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-// 		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-// 			id: 6,
-// 			ownerId: 3,
-// 			content: 'Post3.1',
-// 			lower: 'post3.1',
-// 			createdAt: response[2]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		lower: 'john',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-// 		posts: [],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		with: {
-// 			invitee: true,
-// 			posts: {
-// 				orderBy: (posts, { desc }) => [desc(posts.id)],
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(response.length).eq(4);
-
-// 	expect(response[3]?.invitee).toBeNull();
-// 	expect(response[2]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).not.toBeNull();
-// 	expect(response[0]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(0);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(2);
-// 	expect(response[3]?.posts.length).eq(2);
-
-// 	expect(response[3]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-// 			id: 1,
-// 			ownerId: 1,
-// 			content: 'Post1',
-// 			createdAt: response[3]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response[2]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-// 			id: 3,
-// 			ownerId: 2,
-// 			content: 'Post2',
-// 			createdAt: response[2]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response[1]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [{
-// 			id: 5,
-// 			ownerId: 3,
-// 			content: 'Post3',
-// 			createdAt: response[3]?.posts[1]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response[0]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 		posts: [],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-// 		with: {
-// 			invitee: true,
-// 			posts: {
-// 				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(2);
-
-// 	expect(response[0]?.invitee).toBeNull();
-// 	expect(response[1]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(0);
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		invitee: null,
-// 		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-// 	});
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + limit posts and users + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 		{ ownerId: 3, content: 'Post3.1' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-// 		limit: 1,
-// 		with: {
-// 			invitee: true,
-// 			posts: {
-// 				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-// 				limit: 1,
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(response.length).eq(1);
-
-// 	expect(response[0]?.invitee).not.toBeNull();
-// 	expect(response[0]?.posts.length).eq(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + orderBy + where + custom', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		orderBy: [desc(usersTable.id)],
-// 		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-// 		extras: {
-// 			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-// 		},
-// 		with: {
-// 			invitee: true,
-// 			posts: {
-// 				where: eq(postsTable.ownerId, 3),
-// 				orderBy: [desc(postsTable.id)],
-// 				extras: {
-// 					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			lower: string;
-// 			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(response.length).eq(2);
-
-// 	expect(response[1]?.invitee).not.toBeNull();
-// 	expect(response[0]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(0);
-// 	expect(response[1]?.posts.length).eq(1);
-
-// 	expect(response[1]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: 1,
-// 		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-// 		posts: [{
-// 			id: 5,
-// 			ownerId: 3,
-// 			content: 'Post3',
-// 			lower: 'post3',
-// 			createdAt: response[1]?.posts[0]?.createdAt,
-// 		}],
-// 	});
-// 	expect(response[0]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		lower: 'john',
-// 		verified: false,
-// 		invitedBy: 2,
-// 		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-// 		posts: [],
-// 	});
-// });
-
-// test.skip('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex', invitedBy: 1 },
-// 		{ id: 4, name: 'John', invitedBy: 2 },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ ownerId: 1, content: 'Post1' },
-// 		{ ownerId: 1, content: 'Post1.1' },
-// 		{ ownerId: 2, content: 'Post2' },
-// 		{ ownerId: 2, content: 'Post2.1' },
-// 		{ ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		orderBy: [desc(usersTable.id)],
-// 		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-// 		extras: {
-// 			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-// 		},
-// 		columns: {
-// 			id: true,
-// 			name: true,
-// 		},
-// 		with: {
-// 			invitee: {
-// 				columns: {
-// 					id: true,
-// 					name: true,
-// 				},
-// 				extras: {
-// 					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-// 				},
-// 			},
-// 			posts: {
-// 				columns: {
-// 					id: true,
-// 					content: true,
-// 				},
-// 				where: eq(postsTable.ownerId, 3),
-// 				orderBy: [desc(postsTable.id)],
-// 				extras: {
-// 					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			lower: string;
-// 			posts: { id: number; lower: string; content: string }[];
-// 			invitee: {
-// 				id: number;
-// 				name: string;
-// 				lower: string;
-// 			} | null;
-// 		}[]
-// 	>();
-
-// 	expect(response.length).eq(2);
-
-// 	expect(response[1]?.invitee).not.toBeNull();
-// 	expect(response[0]?.invitee).not.toBeNull();
-
-// 	expect(response[0]?.posts.length).eq(0);
-// 	expect(response[1]?.posts.length).eq(1);
-
-// 	expect(response[1]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-// 		posts: [{
-// 			id: 5,
-// 			content: 'Post3',
-// 			lower: 'post3',
-// 		}],
-// 	});
-// 	expect(response[0]).toEqual({
-// 		id: 4,
-// 		name: 'John',
-// 		lower: 'john',
-// 		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-// 		posts: [],
-// 	});
-// });
-
-// /*
-// 	One two-level relation users+posts+comments
-// */
-
-// test.skip('Get user with posts and posts with comments', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ id: 1, ownerId: 1, content: 'Post1' },
-// 		{ id: 2, ownerId: 2, content: 'Post2' },
-// 		{ id: 3, ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	await db.insert(commentsTable).values([
-// 		{ postId: 1, content: 'Comment1', creator: 2 },
-// 		{ postId: 2, content: 'Comment2', creator: 2 },
-// 		{ postId: 3, content: 'Comment3', creator: 3 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				with: {
-// 					comments: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			posts: {
-// 				id: number;
-// 				content: string;
-// 				ownerId: number | null;
-// 				createdAt: Date;
-// 				comments: {
-// 					id: number;
-// 					content: string;
-// 					createdAt: Date;
-// 					creator: number | null;
-// 					postId: number | null;
-// 				}[];
-// 			}[];
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(3);
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(1);
-
-// 	expect(response[0]?.posts[0]?.comments.length).eq(1);
-// 	expect(response[1]?.posts[0]?.comments.length).eq(1);
-// 	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-// 	expect(response[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 1,
-// 			ownerId: 1,
-// 			content: 'Post1',
-// 			createdAt: response[0]?.posts[0]?.createdAt,
-// 			comments: [
-// 				{
-// 					id: 1,
-// 					content: 'Comment1',
-// 					creator: 2,
-// 					postId: 1,
-// 					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-// 				},
-// 			],
-// 		}],
-// 	});
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 2,
-// 			ownerId: 2,
-// 			content: 'Post2',
-// 			createdAt: response[1]?.posts[0]?.createdAt,
-// 			comments: [
-// 				{
-// 					id: 2,
-// 					content: 'Comment2',
-// 					creator: 2,
-// 					postId: 2,
-// 					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-// 				},
-// 			],
-// 		}],
-// 	});
-// 	// expect(response[2]).toEqual({
-// 	// 	id: 3,
-// 	// 	name: 'Alex',
-// 	// 	verified: false,
-// 	// 	invitedBy: null,
-// 	// 	posts: [{
-// 	// 		id: 3,
-// 	// 		ownerId: 3,
-// 	// 		content: 'Post3',
-// 	// 		createdAt: response[2]?.posts[0]?.createdAt,
-// 	// 		comments: [
-// 	// 			{
-// 	// 				id: ,
-// 	// 				content: 'Comment3',
-// 	// 				creator: 3,
-// 	// 				postId: 3,
-// 	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-// 	// 			},
-// 	// 		],
-// 	// 	}],
-// 	// });
-// });
-
-// // Get user with limit posts and limit comments
-
-// // Get user with custom field + post + comment with custom field
-
-// // Get user with limit + posts orderBy + comment orderBy
-
-// // Get user with where + posts where + comment where
-
-// // Get user with where + posts partial where + comment where
-
-// // Get user with where + posts partial where + comment partial(false) where
-
-// // Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// // Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// // Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// // Get with limit+offset in each
-
-// /*
-// 	One two-level + One first-level relation users+posts+comments and users+users
-// */
-
-// /*
-// 	One three-level relation users+posts+comments+comment_owner
-// */
-
-// test.skip('Get user with posts and posts with comments and comments with owner', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ id: 1, ownerId: 1, content: 'Post1' },
-// 		{ id: 2, ownerId: 2, content: 'Post2' },
-// 		{ id: 3, ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	await db.insert(commentsTable).values([
-// 		{ postId: 1, content: 'Comment1', creator: 2 },
-// 		{ postId: 2, content: 'Comment2', creator: 2 },
-// 		{ postId: 3, content: 'Comment3', creator: 3 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				with: {
-// 					comments: {
-// 						with: {
-// 							author: true,
-// 						},
-// 					},
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 			comments: {
-// 				id: number;
-// 				content: string;
-// 				createdAt: Date;
-// 				creator: number | null;
-// 				postId: number | null;
-// 				author: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				} | null;
-// 			}[];
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).eq(3);
-// 	expect(response[0]?.posts.length).eq(1);
-// 	expect(response[1]?.posts.length).eq(1);
-// 	expect(response[2]?.posts.length).eq(1);
-
-// 	expect(response[0]?.posts[0]?.comments.length).eq(1);
-// 	expect(response[1]?.posts[0]?.comments.length).eq(1);
-// 	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-// 	expect(response[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 1,
-// 			ownerId: 1,
-// 			content: 'Post1',
-// 			createdAt: response[0]?.posts[0]?.createdAt,
-// 			comments: [
-// 				{
-// 					id: 1,
-// 					content: 'Comment1',
-// 					creator: 2,
-// 					author: {
-// 						id: 2,
-// 						name: 'Andrew',
-// 						verified: false,
-// 						invitedBy: null,
-// 					},
-// 					postId: 1,
-// 					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-// 				},
-// 			],
-// 		}],
-// 	});
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 2,
-// 			ownerId: 2,
-// 			content: 'Post2',
-// 			createdAt: response[1]?.posts[0]?.createdAt,
-// 			comments: [
-// 				{
-// 					id: 2,
-// 					content: 'Comment2',
-// 					creator: 2,
-// 					author: {
-// 						id: 2,
-// 						name: 'Andrew',
-// 						verified: false,
-// 						invitedBy: null,
-// 					},
-// 					postId: 2,
-// 					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-// 				},
-// 			],
-// 		}],
-// 	});
-// });
-
-// test.skip('Get user with posts and posts with comments and comments with owner where exists', async () => {
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(postsTable).values([
-// 		{ id: 1, ownerId: 1, content: 'Post1' },
-// 		{ id: 2, ownerId: 2, content: 'Post2' },
-// 		{ id: 3, ownerId: 3, content: 'Post3' },
-// 	]);
-
-// 	await db.insert(commentsTable).values([
-// 		{ postId: 1, content: 'Comment1', creator: 2 },
-// 		{ postId: 2, content: 'Comment2', creator: 2 },
-// 		{ postId: 3, content: 'Comment3', creator: 3 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			posts: {
-// 				with: {
-// 					comments: {
-// 						with: {
-// 							author: true,
-// 						},
-// 					},
-// 				},
-// 			},
-// 		},
-// 		where: (table, { exists, eq }) => exists(db.select({ one: sql`1` }).from(usersTable).where(eq(sql`1`, table.id))),
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		posts: {
-// 			id: number;
-// 			content: string;
-// 			ownerId: number | null;
-// 			createdAt: Date;
-// 			comments: {
-// 				id: number;
-// 				content: string;
-// 				createdAt: Date;
-// 				creator: number | null;
-// 				postId: number | null;
-// 				author: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				} | null;
-// 			}[];
-// 		}[];
-// 	}[]>();
-
-// 	expect(response.length).eq(1);
-// 	expect(response[0]?.posts.length).eq(1);
-
-// 	expect(response[0]?.posts[0]?.comments.length).eq(1);
-
-// 	expect(response[0]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		posts: [{
-// 			id: 1,
-// 			ownerId: 1,
-// 			content: 'Post1',
-// 			createdAt: response[0]?.posts[0]?.createdAt,
-// 			comments: [
-// 				{
-// 					id: 1,
-// 					content: 'Comment1',
-// 					creator: 2,
-// 					author: {
-// 						id: 2,
-// 						name: 'Andrew',
-// 						verified: false,
-// 						invitedBy: null,
-// 					},
-// 					postId: 1,
-// 					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-// 				},
-// 			],
-// 		}],
-// 	});
-// });
-
-// /*
-// 	One three-level relation + 1 first-level relatioon
-// 	1. users+posts+comments+comment_owner
-// 	2. users+users
-// */
-
-// /*
-// 	One four-level relation users+posts+comments+coment_likes
-// */
-
-// /*
-// 	[Find Many] Many-to-many cases
-
-// 	Users+users_to_groups+groups
-// */
-
-// test.skip('[Find Many] Get users with groups', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-// 	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				description: null,
-// 			},
-// 		}, {
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get groups with users', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		description: string | null;
-// 		usersToGroups: {
-// 			user: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(2);
-// 	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}, {
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with groups + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		limit: 2,
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get groups with users + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		limit: 2,
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		description: string | null;
-// 		usersToGroups: {
-// 			user: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with groups + limit + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		limit: 1,
-// 		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.groupId, 1),
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(1);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get groups with users + limit + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		limit: 1,
-// 		where: gt(groupsTable.id, 1),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.userId, 2),
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		description: string | null;
-// 		usersToGroups: {
-// 			user: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(1);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with groups + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.groupId, 2),
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(0);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get groups with users + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		where: gt(groupsTable.id, 1),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.userId, 2),
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		description: string | null;
-// 		usersToGroups: {
-// 			user: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		description: null,
-// 		usersToGroups: [],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with groups + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		with: {
-// 			usersToGroups: {
-// 				orderBy: [desc(usersToGroupsTable.groupId)],
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(2);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-// 	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response[2]).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[0]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				description: null,
-// 			},
-// 		}, {
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get groups with users + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		orderBy: [desc(groupsTable.id)],
-// 		with: {
-// 			usersToGroups: {
-// 				orderBy: (utg, { desc }) => [desc(utg.userId)],
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		description: string | null;
-// 		usersToGroups: {
-// 			user: {
-// 				id: number;
-// 				name: string;
-// 				verified: boolean;
-// 				invitedBy: number | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(2);
-// 	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response[2]).toEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}, {
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[0]).toEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find Many] Get users with groups + orderBy + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		limit: 2,
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				orderBy: [desc(usersToGroupsTable.groupId)],
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<{
-// 		id: number;
-// 		name: string;
-// 		verified: boolean;
-// 		invitedBy: number | null;
-// 		usersToGroups: {
-// 			group: {
-// 				id: number;
-// 				name: string;
-// 				description: string | null;
-// 			};
-// 		}[];
-// 	}[]>();
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[0]).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// /*
-// 	[Find One] Many-to-many cases
-
-// 	Users+users_to_groups+groups
-// */
-
-// test.skip('[Find One] Get users with groups', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get groups with users', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findFirst({
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with groups + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get groups with users + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findFirst({
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with groups + limit + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.groupId, 1),
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get groups with users + limit + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findFirst({
-// 		where: gt(groupsTable.id, 1),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.userId, 2),
-// 				limit: 1,
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with groups + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 2, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.groupId, 2),
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(0);
-
-// 	expect(response).toEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [],
-// 	});
-// });
-
-// test.skip('[Find One] Get groups with users + where', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findFirst({
-// 		where: gt(groupsTable.id, 1),
-// 		with: {
-// 			usersToGroups: {
-// 				where: eq(usersToGroupsTable.userId, 2),
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with groups + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		with: {
-// 			usersToGroups: {
-// 				orderBy: [desc(usersToGroupsTable.groupId)],
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(2);
-
-// 	expect(response).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				description: null,
-// 			},
-// 		}, {
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get groups with users + orderBy', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findFirst({
-// 		orderBy: [desc(groupsTable.id)],
-// 		with: {
-// 			usersToGroups: {
-// 				orderBy: (utg, { desc }) => [desc(utg.userId)],
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('[Find One] Get users with groups + orderBy + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findFirst({
-// 		orderBy: (users, { desc }) => [desc(users.id)],
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				orderBy: [desc(usersToGroupsTable.groupId)],
-// 				columns: {},
-// 				with: {
-// 					group: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 				};
-// 			}[];
-// 		} | undefined
-// 	>();
-
-// 	expect(response?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('Get groups with users + orderBy + limit', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		orderBy: [desc(groupsTable.id)],
-// 		limit: 2,
-// 		with: {
-// 			usersToGroups: {
-// 				limit: 1,
-// 				orderBy: (utg, { desc }) => [desc(utg.userId)],
-// 				columns: {},
-// 				with: {
-// 					user: true,
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 				};
-// 			}[];
-// 		}[]
-// 	>();
-
-// 	expect(response.length).toEqual(2);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response[1]).toEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response[0]).toEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('Get users with groups + custom', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.usersTable.findMany({
-// 		extras: {
-// 			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-// 		},
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					group: {
-// 						extras: {
-// 							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-// 						},
-// 					},
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			verified: boolean;
-// 			invitedBy: number | null;
-// 			lower: string;
-// 			usersToGroups: {
-// 				group: {
-// 					id: number;
-// 					name: string;
-// 					description: string | null;
-// 					lower: string;
-// 				};
-// 			}[];
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(1);
-// 	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Dan',
-// 		lower: 'dan',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 1,
-// 				name: 'Group1',
-// 				lower: 'group1',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Andrew',
-// 		lower: 'andrew',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				lower: 'group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Alex',
-// 		lower: 'alex',
-// 		verified: false,
-// 		invitedBy: null,
-// 		usersToGroups: [{
-// 			group: {
-// 				id: 3,
-// 				name: 'Group3',
-// 				lower: 'group3',
-// 				description: null,
-// 			},
-// 		}, {
-// 			group: {
-// 				id: 2,
-// 				name: 'Group2',
-// 				lower: 'group2',
-// 				description: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test.skip('Get groups with users + custom', async (t) => {
-// 	const { singlestoreDb: db } = t;
-
-// 	await db.insert(usersTable).values([
-// 		{ id: 1, name: 'Dan' },
-// 		{ id: 2, name: 'Andrew' },
-// 		{ id: 3, name: 'Alex' },
-// 	]);
-
-// 	await db.insert(groupsTable).values([
-// 		{ id: 1, name: 'Group1' },
-// 		{ id: 2, name: 'Group2' },
-// 		{ id: 3, name: 'Group3' },
-// 	]);
-
-// 	await db.insert(usersToGroupsTable).values([
-// 		{ userId: 1, groupId: 1 },
-// 		{ userId: 2, groupId: 2 },
-// 		{ userId: 3, groupId: 3 },
-// 		{ userId: 3, groupId: 2 },
-// 	]);
-
-// 	const response = await db.query.groupsTable.findMany({
-// 		extras: (table, { sql }) => ({
-// 			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-// 		}),
-// 		with: {
-// 			usersToGroups: {
-// 				columns: {},
-// 				with: {
-// 					user: {
-// 						extras: (table, { sql }) => ({
-// 							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-// 						}),
-// 					},
-// 				},
-// 			},
-// 		},
-// 	});
-
-// 	expectTypeOf(response).toEqualTypeOf<
-// 		{
-// 			id: number;
-// 			name: string;
-// 			description: string | null;
-// 			lower: string;
-// 			usersToGroups: {
-// 				user: {
-// 					id: number;
-// 					name: string;
-// 					verified: boolean;
-// 					invitedBy: number | null;
-// 					lower: string;
-// 				};
-// 			}[];
-// 		}[]
-// 	>();
-
-// 	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-// 	expect(response.length).toEqual(3);
-
-// 	expect(response[0]?.usersToGroups.length).toEqual(1);
-// 	expect(response[1]?.usersToGroups.length).toEqual(2);
-// 	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-// 	expect(response).toContainEqual({
-// 		id: 1,
-// 		name: 'Group1',
-// 		lower: 'group1',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 1,
-// 				name: 'Dan',
-// 				lower: 'dan',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 2,
-// 		name: 'Group2',
-// 		lower: 'group2',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 2,
-// 				name: 'Andrew',
-// 				lower: 'andrew',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}, {
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				lower: 'alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-
-// 	expect(response).toContainEqual({
-// 		id: 3,
-// 		name: 'Group3',
-// 		lower: 'group3',
-// 		description: null,
-// 		usersToGroups: [{
-// 			user: {
-// 				id: 3,
-// 				name: 'Alex',
-// 				lower: 'alex',
-// 				verified: false,
-// 				invitedBy: null,
-// 			},
-// 		}],
-// 	});
-// });
-
-// test('.toSQL()', () => {
-// 	const query = db.query.usersTable.findFirst().toSQL();
-
-// 	expect(query).toHaveProperty('sql', expect.any(String));
-// 	expect(query).toHaveProperty('params', expect.any(Array));
-// });
-
-// // + custom + where + orderby
-
-// // + custom + where + orderby + limit
-
-// // + partial
-
-// // + partial(false)
-
-// // + partial + orderBy + where (all not selected)
-
-// /*
-// 	One four-level relation users+posts+comments+coment_likes
-// 	+ users+users_to_groups+groups
-// */
-
-// /*
-// 	Really hard case
-// 	1. users+posts+comments+coment_likes
-// 	2. users+users_to_groups+groups
-// 	3. users+users
-// */
-// eslint-disable-next-line unicorn/no-empty-file
diff --git a/integration-tests/tests/relational/sqlite.schema.ts b/integration-tests/tests/relational/sqlite.schema.ts
deleted file mode 100644
index d39f823281..0000000000
--- a/integration-tests/tests/relational/sqlite.schema.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import { type AnySQLiteColumn, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-import { relations, sql } from 'drizzle-orm';
-
-export const usersTable = sqliteTable('users', {
-	id: integer('id').primaryKey({ autoIncrement: true }),
-	name: text('name').notNull(),
-	verified: integer('verified').notNull().default(0),
-	invitedBy: integer('invited_by').references((): AnySQLiteColumn => usersTable.id),
-});
-export const usersConfig = relations(usersTable, ({ one, many }) => ({
-	invitee: one(usersTable, {
-		fields: [usersTable.invitedBy],
-		references: [usersTable.id],
-	}),
-	usersToGroups: many(usersToGroupsTable),
-	posts: many(postsTable),
-}));
-
-export const groupsTable = sqliteTable('groups', {
-	id: integer('id').primaryKey({ autoIncrement: true }),
-	name: text('name').notNull(),
-	description: text('description'),
-});
-export const groupsConfig = relations(groupsTable, ({ many }) => ({
-	usersToGroups: many(usersToGroupsTable),
-}));
-
-export const usersToGroupsTable = sqliteTable(
-	'users_to_groups',
-	{
-		id: integer('id').primaryKey({ autoIncrement: true }),
-		userId: integer('user_id', { mode: 'number' }).notNull().references(
-			() => usersTable.id,
-		),
-		groupId: integer('group_id', { mode: 'number' }).notNull().references(
-			() => groupsTable.id,
-		),
-	},
-	(t) => ({
-		pk: primaryKey(t.userId, t.groupId),
-	}),
-);
-export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
-	group: one(groupsTable, {
-		fields: [usersToGroupsTable.groupId],
-		references: [groupsTable.id],
-	}),
-	user: one(usersTable, {
-		fields: [usersToGroupsTable.userId],
-		references: [usersTable.id],
-	}),
-}));
-
-export const postsTable = sqliteTable('posts', {
-	id: integer('id').primaryKey({ autoIncrement: true }),
-	content: text('content').notNull(),
-	ownerId: integer('owner_id', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' })
-		.notNull().default(sql`current_timestamp`),
-});
-export const postsConfig = relations(postsTable, ({ one, many }) => ({
-	author: one(usersTable, {
-		fields: [postsTable.ownerId],
-		references: [usersTable.id],
-	}),
-	comments: many(commentsTable),
-}));
-
-export const commentsTable = sqliteTable('comments', {
-	id: integer('id').primaryKey({ autoIncrement: true }),
-	content: text('content').notNull(),
-	creator: integer('creator', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	postId: integer('post_id', { mode: 'number' }).references(() => postsTable.id),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' })
-		.notNull().default(sql`current_timestamp`),
-});
-export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
-	post: one(postsTable, {
-		fields: [commentsTable.postId],
-		references: [postsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentsTable.creator],
-		references: [usersTable.id],
-	}),
-	likes: many(commentLikesTable),
-}));
-
-export const commentLikesTable = sqliteTable('comment_likes', {
-	id: integer('id').primaryKey({ autoIncrement: true }),
-	creator: integer('creator', { mode: 'number' }).references(
-		() => usersTable.id,
-	),
-	commentId: integer('comment_id', { mode: 'number' }).references(
-		() => commentsTable.id,
-	),
-	createdAt: integer('created_at', { mode: 'timestamp_ms' })
-		.notNull().default(sql`current_timestamp`),
-});
-export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
-	comment: one(commentsTable, {
-		fields: [commentLikesTable.commentId],
-		references: [commentsTable.id],
-	}),
-	author: one(usersTable, {
-		fields: [commentLikesTable.creator],
-		references: [usersTable.id],
-	}),
-}));
diff --git a/integration-tests/tests/relational/tables.ts b/integration-tests/tests/relational/tables.ts
deleted file mode 100644
index eba34e7aa4..0000000000
--- a/integration-tests/tests/relational/tables.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { relations } from 'drizzle-orm';
-import { foreignKey, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-export const users = sqliteTable('users', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id').references(() => cities.id).notNull(),
-	homeCityId: int('home_city_id').references(() => cities.id),
-	createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
-});
-export const usersConfig = relations(users, ({ one, many }) => ({
-	city: one(cities, { relationName: 'UsersInCity', fields: [users.cityId], references: [cities.id] }),
-	homeCity: one(cities, { fields: [users.homeCityId], references: [cities.id] }),
-	posts: many(posts),
-	comments: many(comments),
-}));
-
-export const cities = sqliteTable('cities', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-});
-export const citiesConfig = relations(cities, ({ many }) => ({
-	users: many(users, { relationName: 'UsersInCity' }),
-}));
-
-export const posts = sqliteTable('posts', {
-	id: integer('id').primaryKey(),
-	title: text('title').notNull(),
-	authorId: int('author_id').references(() => users.id),
-});
-export const postsConfig = relations(posts, ({ one, many }) => ({
-	author: one(users, { fields: [posts.authorId], references: [users.id] }),
-	comments: many(comments),
-}));
-
-export const comments = sqliteTable('comments', {
-	id: integer('id').primaryKey(),
-	postId: int('post_id').references(() => posts.id).notNull(),
-	authorId: int('author_id').references(() => users.id),
-	text: text('text').notNull(),
-});
-export const commentsConfig = relations(comments, ({ one }) => ({
-	post: one(posts, { fields: [comments.postId], references: [posts.id] }),
-	author: one(users, { fields: [comments.authorId], references: [users.id] }),
-}));
-
-export const books = sqliteTable('books', {
-	id: integer('id').primaryKey(),
-	name: text('name').notNull(),
-});
-export const booksConfig = relations(books, ({ many }) => ({
-	authors: many(bookAuthors),
-}));
-
-export const bookAuthors = sqliteTable('book_authors', {
-	bookId: int('book_id').references(() => books.id).notNull(),
-	authorId: int('author_id').references(() => users.id).notNull(),
-	role: text('role').notNull(),
-});
-export const bookAuthorsConfig = relations(bookAuthors, ({ one }) => ({
-	book: one(books, { fields: [bookAuthors.bookId], references: [books.id] }),
-	author: one(users, { fields: [bookAuthors.authorId], references: [users.id] }),
-}));
-
-export const node = sqliteTable('node', {
-	id: integer('id').primaryKey(),
-	parentId: int('parent_id'),
-	leftId: int('left_id'),
-	rightId: int('right_id'),
-}, (node) => ({
-	fk1: foreignKey(() => ({ columns: [node.parentId], foreignColumns: [node.id] })),
-	fk2: foreignKey(() => ({ columns: [node.leftId], foreignColumns: [node.id] })),
-	fk3: foreignKey(() => ({ columns: [node.rightId], foreignColumns: [node.id] })),
-}));
-export const nodeRelations = relations(node, ({ one }) => ({
-	parent: one(node, { fields: [node.parentId], references: [node.id] }),
-	left: one(node, { fields: [node.leftId], references: [node.id] }),
-	right: one(node, { fields: [node.rightId], references: [node.id] }),
-}));
diff --git a/integration-tests/tests/relational/turso.test.ts b/integration-tests/tests/relational/turso.test.ts
deleted file mode 100644
index ab37569fb0..0000000000
--- a/integration-tests/tests/relational/turso.test.ts
+++ /dev/null
@@ -1,6020 +0,0 @@
-import 'dotenv/config';
-import { type Client, createClient } from '@libsql/client';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type LibSQLDatabase } from 'drizzle-orm/libsql';
-import { beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './sqlite.schema.ts';
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-let db: LibSQLDatabase<typeof schema>;
-
-beforeAll(async () => {
-	const url = process.env['LIBSQL_URL'];
-	const authToken = process.env['LIBSQL_AUTH_TOKEN'];
-	if (!url) {
-		throw new Error('LIBSQL_URL is not set');
-	}
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	let client: Client;
-	do {
-		try {
-			client = createClient({ url, authToken });
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to libsql');
-		throw lastError;
-	}
-	db = drizzle(client!, { logger: ENABLE_LOGGING, schema });
-});
-
-beforeEach(async () => {
-	await db.run(sql`drop table if exists \`groups\``);
-	await db.run(sql`drop table if exists \`users\``);
-	await db.run(sql`drop table if exists \`users_to_groups\``);
-	await db.run(sql`drop table if exists \`posts\``);
-	await db.run(sql`drop table if exists \`comments\``);
-	await db.run(sql`drop table if exists \`comment_likes\``);
-
-	await db.run(
-		sql`
-			CREATE TABLE \`users\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`name\` text NOT NULL,
-			    \`verified\` integer DEFAULT 0 NOT NULL,
-			    \`invited_by\` integer
-			);
-		`,
-	);
-	await db.run(
-		sql`
-			CREATE TABLE \`groups\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`name\` text NOT NULL,
-			    \`description\` text
-			);
-		`,
-	);
-	await db.run(
-		sql`
-			CREATE TABLE \`users_to_groups\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`user_id\` integer NOT NULL,
-			    \`group_id\` integer NOT NULL
-			);
-		`,
-	);
-	await db.run(
-		sql`
-			CREATE TABLE \`posts\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`content\` text NOT NULL,
-			    \`owner_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-	await db.run(
-		sql`
-			CREATE TABLE \`comments\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`content\` text NOT NULL,
-			    \`creator\` integer,
-			    \`post_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-	await db.run(
-		sql`
-			CREATE TABLE \`comment_likes\` (
-			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
-			    \`creator\` integer,
-			    \`comment_id\` integer,
-			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-// TODO check order
-test.skip('[Find Many] Get users with posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: '2',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]).run();
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]).run();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async () => {
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]).run();
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]).run();
-
-		await tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 1, content: 'Post1.2' },
-		{ id: 3, ownerId: 1, content: 'Post1.3' },
-		{ id: 4, ownerId: 2, content: 'Post2' },
-		{ id: 5, ownerId: 2, content: 'Post2.1' },
-		{ id: 6, ownerId: 3, content: 'Post3' },
-		{ id: 7, ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
-	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
-	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts[0]?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2',
-	});
-
-	expect(usersWithPosts[1]?.posts).toContainEqual({
-		lowerName: 'post2.1',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3',
-	});
-
-	expect(usersWithPosts[2]?.posts).toContainEqual({
-		lowerName: 'post3.1',
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.2',
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		lowerName: 'post1.3',
-	});
-});
-
-test('[Find One] Get only custom fields + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// columns {}
-test('[Find One] Get select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	await expect(async () =>
-		await db.query.usersTable.findMany({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	await expect(async () =>
-		await db.query.usersTable.findFirst({
-			columns: {},
-			with: {
-				posts: {
-					columns: {},
-				},
-			},
-		})
-	).rejects.toThrow(DrizzleError);
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.all({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.all({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.all({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare();
-
-	const usersWithPosts = await prepared.all({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async () => {
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts?.lowerName).toEqual('dan');
-	expect(usersWithPosts?.id).toEqual(1);
-	expect(usersWithPosts?.verified).toEqual(0);
-	expect(usersWithPosts?.invitedBy).toEqual(null);
-	expect(usersWithPosts?.name).toEqual('Dan');
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 1,
-		ownerId: 1,
-		content: 'Post1',
-		createdAt: usersWithPosts?.posts[0]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 2,
-		ownerId: 1,
-		content: 'Post1.2',
-		createdAt: usersWithPosts?.posts[1]?.createdAt,
-	});
-
-	expect(usersWithPosts?.posts).toContainEqual({
-		id: 3,
-		ownerId: 1,
-		content: 'Post1.3',
-		createdAt: usersWithPosts?.posts[2]?.createdAt,
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-// TODO. Check order
-test.skip('[Find One] Get users with posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.id)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: 0,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: 0, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: 0, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-// TODO Check order
-test.skip('Get user with invitee and posts + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: 0,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]).run();
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: 0,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]).run();
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: 0,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: 0,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				orderBy: usersToGroupsTable.groupId,
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: number;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	response[0]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-	response[1]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-	response[2]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: 0,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 3,
-				name: 'Group3',
-				lower: 'group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + custom', async () => {
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]).run();
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]).run();
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]).run();
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: number;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: 0,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: 0,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('async api', async () => {
-	await db.insert(usersTable).values([{ id: 1, name: 'Dan' }]);
-	const users = await db.query.usersTable.findMany();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('async api - prepare', async () => {
-	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
-	await insertStmt.execute();
-	const queryStmt = db.query.usersTable.findMany().prepare();
-	const users = await queryStmt.execute();
-	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/relational/vercel.test.ts b/integration-tests/tests/relational/vercel.test.ts
deleted file mode 100644
index 424f25c99b..0000000000
--- a/integration-tests/tests/relational/vercel.test.ts
+++ /dev/null
@@ -1,6201 +0,0 @@
-import 'dotenv/config';
-import { createClient, type VercelClient } from '@vercel/postgres';
-import Docker from 'dockerode';
-import { desc, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
-import { drizzle, type VercelPgDatabase } from 'drizzle-orm/vercel-postgres';
-import getPort from 'get-port';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
-import * as schema from './pg.schema.ts';
-
-const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
-
-const ENABLE_LOGGING = false;
-
-/*
-	Test cases:
-	- querying nested relation without PK with additional fields
-*/
-
-declare module 'vitest' {
-	export interface TestContext {
-		docker: Docker;
-		vpgContainer: Docker.Container;
-		vpgDb: VercelPgDatabase<typeof schema>;
-		vpgClient: VercelClient;
-	}
-}
-
-let globalDocker: Docker;
-let pgContainer: Docker.Container;
-let db: VercelPgDatabase<typeof schema>;
-let client: VercelClient;
-
-async function createDockerDB(): Promise<string> {
-	const docker = (globalDocker = new Docker());
-	const port = await getPort({ port: 5432 });
-	const image = 'postgres:14';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	pgContainer = await docker.createContainer({
-		Image: image,
-		Env: [
-			'POSTGRES_PASSWORD=postgres',
-			'POSTGRES_USER=postgres',
-			'POSTGRES_DB=postgres',
-		],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'5432/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await pgContainer.start();
-
-	return `postgres://postgres:postgres@localhost:${port}/postgres`;
-}
-
-beforeAll(async () => {
-	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB());
-
-	const sleep = 250;
-	let timeLeft = 5000;
-	let connected = false;
-	let lastError: unknown | undefined;
-	do {
-		try {
-			client = createClient({ connectionString });
-			await client.connect();
-			connected = true;
-			break;
-		} catch (e) {
-			lastError = e;
-			await new Promise((resolve) => setTimeout(resolve, sleep));
-			timeLeft -= sleep;
-		}
-	} while (timeLeft > 0);
-	if (!connected) {
-		console.error('Cannot connect to Postgres');
-		await client?.end().catch(console.error);
-		await pgContainer?.stop().catch(console.error);
-		throw lastError;
-	}
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end().catch(console.error);
-	await pgContainer?.stop().catch(console.error);
-});
-
-beforeEach(async (ctx) => {
-	ctx.vpgDb = db;
-	ctx.vpgClient = client;
-	ctx.docker = globalDocker;
-	ctx.vpgContainer = pgContainer;
-
-	await ctx.vpgDb.execute(sql`drop schema public cascade`);
-	await ctx.vpgDb.execute(sql`create schema public`);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE "users" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"verified" boolean DEFAULT false NOT NULL,
-				"invited_by" int REFERENCES "users"("id")
-			);
-		`,
-	);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"name" text NOT NULL,
-				"description" text
-			);
-		`,
-	);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "users_to_groups" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"user_id" int REFERENCES "users"("id"),
-				"group_id" int REFERENCES "groups"("id")
-			);
-		`,
-	);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "posts" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"owner_id" int REFERENCES "users"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comments" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"content" text NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"post_id" int REFERENCES "posts"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-	await ctx.vpgDb.execute(
-		sql`
-			CREATE TABLE IF NOT EXISTS "comment_likes" (
-				"id" serial PRIMARY KEY NOT NULL,
-				"creator" int REFERENCES "users"("id"),
-				"comment_id" int REFERENCES "comments"("id"),
-				"created_at" timestamp with time zone DEFAULT now() NOT NULL
-			);
-		`,
-	);
-});
-
-/*
-	[Find Many] One relation users+posts
-*/
-
-test('[Find Many] Get users with posts', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + limit posts and users', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lowerName: 'andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
-			id: 5,
-			ownerId: 2,
-			content: 'Post2.1',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(usersWithPosts[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lowerName: 'alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
-			id: 7,
-			ownerId: 3,
-			content: 'Post3.1',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}],
-	});
-});
-
-test('[Find Many] Get users with posts + custom fields + limits', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		limit: 1,
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		lowerName: string;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(2);
-	expect(usersWithPosts[1]?.posts.length).eq(2);
-	expect(usersWithPosts[2]?.posts.length).eq(3);
-
-	expect(usersWithPosts[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: '2',
-			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
-		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 5,
-			ownerId: 2,
-			content: '5',
-			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
-		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		posts: {
-			id: number;
-			content: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(true + false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		posts: {
-			id: number;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find Many] Get users with posts + where + partial(false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in transaction', async (t) => {
-	const { vpgDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts in rollbacked transaction', async (t) => {
-	const { vpgDb: db } = t;
-
-	let usersWithPosts: {
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[] = [];
-
-	await expect(db.transaction(async (tx) => {
-		await tx.insert(usersTable).values([
-			{ id: 1, name: 'Dan' },
-			{ id: 2, name: 'Andrew' },
-			{ id: 3, name: 'Alex' },
-		]);
-
-		await tx.insert(postsTable).values([
-			{ ownerId: 1, content: 'Post1' },
-			{ ownerId: 1, content: 'Post1.1' },
-			{ ownerId: 2, content: 'Post2' },
-			{ ownerId: 3, content: 'Post3' },
-		]);
-
-		tx.rollback();
-
-		usersWithPosts = await tx.query.usersTable.findMany({
-			where: (({ id }, { eq }) => eq(id, 1)),
-			with: {
-				posts: {
-					where: (({ id }, { eq }) => eq(id, 1)),
-				},
-			},
-		});
-	})).rejects.toThrowError(new TransactionRollbackError());
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(0);
-});
-
-// select only custom
-test('[Find Many] Get only custom fields', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(3);
-	expect(usersWithPosts[0]?.posts.length).toEqual(3);
-	expect(usersWithPosts[1]?.posts.length).toEqual(2);
-	expect(usersWithPosts[2]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'andrew',
-		posts: [{ lowerName: 'post2' }, {
-			lowerName: 'post2.1',
-		}],
-	});
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'alex',
-		posts: [{ lowerName: 'post3' }, {
-			lowerName: 'post3.1',
-		}],
-	});
-});
-
-test('[Find Many] Get only custom fields + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find Many] Get only custom fields + where + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		lowerName: string;
-		posts: {
-			lowerName: string;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).toEqual(1);
-	expect(usersWithPosts[0]?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toContainEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// select only custom find one
-test('[Find One] Get only custom fields', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1' }, {
-			lowerName: 'post1.2',
-		}, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				limit: 1,
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.2' }],
-	});
-});
-
-test('[Find One] Get only custom fields + where + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-				where: gte(postsTable.id, 2),
-				orderBy: [desc(postsTable.id)],
-				extras: ({ content }) => ({
-					lowerName: sql<string>`lower(${content})`.as('content_lower'),
-				}),
-			},
-		},
-		where: eq(usersTable.id, 1),
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			lowerName: string;
-			posts: {
-				lowerName: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts?.posts.length).toEqual(2);
-
-	expect(usersWithPosts).toEqual({
-		lowerName: 'dan',
-		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
-	});
-});
-
-// columns {}
-test('[Find Many] Get select {}', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const users = await db.query.usersTable.findMany({
-		columns: {},
-	});
-
-	expectTypeOf(users).toEqualTypeOf<{}[]>();
-
-	expect(users.length).toBe(3);
-
-	expect(users[0]).toEqual({});
-	expect(users[1]).toEqual({});
-	expect(users[2]).toEqual({});
-});
-
-// columns {}
-test('[Find One] Get select {}', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	const users = await db.query.usersTable.findFirst({
-		columns: {},
-	});
-
-	expectTypeOf(users).toEqualTypeOf<{} | undefined>();
-
-	expect(users).toEqual({});
-});
-
-// deep select {}
-test('[Find Many] Get deep select {}', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const users = await db.query.usersTable.findMany({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-			},
-		},
-	});
-
-	expectTypeOf(users).toEqualTypeOf<{ posts: {}[] }[]>();
-
-	expect(users.length).toBe(3);
-
-	expect(users[0]).toEqual({ posts: [{}] });
-	expect(users[1]).toEqual({ posts: [{}] });
-	expect(users[2]).toEqual({ posts: [{}] });
-});
-
-// deep select {}
-test('[Find One] Get deep select {}', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const users = await db.query.usersTable.findFirst({
-		columns: {},
-		with: {
-			posts: {
-				columns: {},
-			},
-		},
-	});
-
-	expectTypeOf(users).toEqualTypeOf<{ posts: {}[] } | undefined>();
-
-	expect(users).toEqual({ posts: [{}] });
-});
-
-/*
-	Prepared statements for users+posts
-*/
-test('[Find Many] Get users with posts + prepared limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		with: {
-			posts: {
-				limit: placeholder('limit'),
-			},
-		},
-	}).prepare('query1');
-
-	const usersWithPosts = await prepared.execute({ limit: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(3);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-	expect(usersWithPosts[2]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared limit + offset', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		with: {
-			posts: {
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query2');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(2);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-	expect(usersWithPosts[1]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		where: (({ id }, { eq }) => eq(id, placeholder('id'))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	}).prepare('query3');
-
-	const usersWithPosts = await prepared.execute({ id: 1 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find Many] Get users with posts + prepared + limit + offset + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const prepared = db.query.usersTable.findMany({
-		limit: placeholder('uLimit'),
-		offset: placeholder('uOffset'),
-		where: (({ id }, { eq, or }) => or(eq(id, placeholder('id')), eq(id, 3))),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, placeholder('pid'))),
-				limit: placeholder('pLimit'),
-			},
-		},
-	}).prepare('query4');
-
-	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-		}[];
-	}[]>();
-
-	expect(usersWithPosts.length).eq(1);
-	expect(usersWithPosts[0]?.posts.length).eq(1);
-
-	expect(usersWithPosts).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	[Find One] One relation users+posts
-*/
-
-test('[Find One] Get users with posts', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + limit posts', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts no results found', async (t) => {
-	const { vpgDb: db } = t;
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts).toBeUndefined();
-});
-
-test('[Find One] Get users with posts + limit posts and users', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: true,
-		},
-		extras: ({ name }) => ({
-			lowerName: sql<string>`lower(${name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(3);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		lowerName: 'dan',
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.2',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts?.posts[2]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + custom fields + limits', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.2' },
-		{ ownerId: 1, content: 'Post1.3' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				limit: 1,
-			},
-		},
-		extras: (usersTable, { sql }) => ({
-			lowerName: sql<string>`lower(${usersTable.name})`.as('name_lower'),
-		}),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lowerName: string;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).toEqual(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		lowerName: 'dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: '1' },
-		{ ownerId: 1, content: '2' },
-		{ ownerId: 1, content: '3' },
-		{ ownerId: 2, content: '4' },
-		{ ownerId: 2, content: '5' },
-		{ ownerId: 3, content: '6' },
-		{ ownerId: 3, content: '7' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		with: {
-			posts: {
-				orderBy: (postsTable, { desc }) => [desc(postsTable.content)],
-			},
-		},
-		orderBy: (usersTable, { desc }) => [desc(usersTable.id)],
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(2);
-
-	expect(usersWithPosts).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 7,
-			ownerId: 3,
-			content: '7',
-			createdAt: usersWithPosts?.posts[1]?.createdAt,
-		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		where: (({ id }, { eq }) => eq(id, 1)),
-		with: {
-			posts: {
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			posts: {
-				id: number;
-				content: string;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		name: 'Dan',
-		posts: [{ id: 1, content: 'Post1' }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(true + false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			id: true,
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					id: true,
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			posts: {
-				id: number;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		posts: [{ id: 1 }],
-	});
-});
-
-test('[Find One] Get users with posts + where + partial(false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const usersWithPosts = await db.query.usersTable.findFirst({
-		columns: {
-			name: false,
-		},
-		with: {
-			posts: {
-				columns: {
-					content: false,
-				},
-				where: (({ id }, { eq }) => eq(id, 1)),
-			},
-		},
-		where: (({ id }, { eq }) => eq(id, 1)),
-	});
-
-	expectTypeOf(usersWithPosts).toEqualTypeOf<
-		{
-			id: number;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				ownerId: number | null;
-				createdAt: Date;
-			}[];
-		} | undefined
-	>();
-
-	expect(usersWithPosts!.posts.length).eq(1);
-
-	expect(usersWithPosts).toEqual({
-		id: 1,
-		verified: false,
-		invitedBy: null,
-		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
-	});
-});
-
-/*
-	One relation users+users. Self referencing
-*/
-
-test('Get user with invitee', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user + limit with invitee', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew', invitedBy: 1 },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-		},
-		limit: 2,
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[3]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee and custom fields + limits', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		limit: 3,
-		with: {
-			invitee: {
-				extras: (invitee, { sql }) => ({ lower: sql<string>`lower(${invitee.name})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				lower: string;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(usersWithInvitee.length).eq(3);
-	expect(usersWithInvitee[0]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + order by', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(4);
-	expect(usersWithInvitee[3]?.invitee).toBeNull();
-	expect(usersWithInvitee[2]?.invitee).toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-	});
-	expect(usersWithInvitee[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		with: {
-			invitee: true,
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-	});
-});
-
-test('Get user with invitee + where + partial', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(true+false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			id: true,
-			name: true,
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-					verified: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitee: {
-				id: number;
-				name: string;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitee: { id: 1, name: 'Dan' },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitee: { id: 2, name: 'Andrew' },
-	});
-});
-
-test('Get user with invitee + where + partial(false)', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	const usersWithInvitee = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		columns: {
-			verified: false,
-		},
-		with: {
-			invitee: {
-				columns: {
-					name: false,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(usersWithInvitee).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			invitedBy: number | null;
-			invitee: {
-				id: number;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(usersWithInvitee.length).eq(2);
-	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
-	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
-
-	expect(usersWithInvitee).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		invitedBy: 1,
-		invitee: { id: 1, verified: false, invitedBy: null },
-	});
-	expect(usersWithInvitee).toContainEqual({
-		id: 4,
-		name: 'John',
-		invitedBy: 2,
-		invitee: { id: 2, verified: false, invitedBy: null },
-	});
-});
-
-/*
-	Two first-level relations users+users and users+posts
-*/
-
-test('Get user with invitee and posts', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			invitee: true,
-			posts: true,
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		with: {
-			invitee: true,
-			posts: {
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + limits + custom fields in each', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 3,
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
-			},
-			posts: {
-				limit: 1,
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_content') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + custom fields in each', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-		with: {
-			invitee: {
-				extras: (users, { sql }) => ({ lower: sql<string>`lower(${users.name})`.as('lower_name') }),
-			},
-			posts: {
-				extras: (posts, { sql }) => ({ lower: sql<string>`lower(${posts.content})`.as('lower_name') }),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			lower: string;
-			invitedBy: number | null;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(4);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).toBeNull();
-	expect(response[2]?.invitee).not.toBeNull();
-	expect(response[3]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(2);
-	expect(response[1]?.posts.length).eq(2);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
-			id: 2,
-			ownerId: 1,
-			content: 'Post1.1',
-			lower: 'post1.1',
-			createdAt: response[0]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
-			id: 4,
-			ownerId: 2,
-			content: 'Post2.1',
-			lower: 'post2.1',
-			createdAt: response[1]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 6,
-			ownerId: 3,
-			content: 'Post3.1',
-			lower: 'post3.1',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response).toContainEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			invitee: true,
-			posts: {
-				orderBy: (posts, { desc }) => [desc(posts.id)],
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(4);
-
-	expect(response[3]?.invitee).toBeNull();
-	expect(response[2]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(2);
-	expect(response[3]?.posts.length).eq(2);
-
-	expect(response[3]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[2]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
-			id: 3,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[2]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			createdAt: response[3]?.posts[1]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 2), eq(users.id, 3))),
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 2)),
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(2);
-
-	expect(response[0]?.invitee).toBeNull();
-	expect(response[1]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		invitee: null,
-		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + limit posts and users + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-		{ ownerId: 3, content: 'Post3.1' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (users, { eq, or }) => (or(eq(users.id, 3), eq(users.id, 4))),
-		limit: 1,
-		with: {
-			invitee: true,
-			posts: {
-				where: (posts, { eq }) => (eq(posts.ownerId, 3)),
-				limit: 1,
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(1);
-
-	expect(response[0]?.invitee).not.toBeNull();
-	expect(response[0]?.posts.length).eq(1);
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + custom', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			invitee: true,
-			posts: {
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
-			invitee: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: 1,
-		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
-		posts: [{
-			id: 5,
-			ownerId: 3,
-			content: 'Post3',
-			lower: 'post3',
-			createdAt: response[1]?.posts[0]?.createdAt,
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		verified: false,
-		invitedBy: 2,
-		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
-		posts: [],
-	});
-});
-
-test('Get user with invitee and posts + orderBy + where + partial + custom', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex', invitedBy: 1 },
-		{ id: 4, name: 'John', invitedBy: 2 },
-	]);
-
-	await db.insert(postsTable).values([
-		{ ownerId: 1, content: 'Post1' },
-		{ ownerId: 1, content: 'Post1.1' },
-		{ ownerId: 2, content: 'Post2' },
-		{ ownerId: 2, content: 'Post2.1' },
-		{ ownerId: 3, content: 'Post3' },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: [desc(usersTable.id)],
-		where: or(eq(usersTable.id, 3), eq(usersTable.id, 4)),
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		columns: {
-			id: true,
-			name: true,
-		},
-		with: {
-			invitee: {
-				columns: {
-					id: true,
-					name: true,
-				},
-				extras: {
-					lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-				},
-			},
-			posts: {
-				columns: {
-					id: true,
-					content: true,
-				},
-				where: eq(postsTable.ownerId, 3),
-				orderBy: [desc(postsTable.id)],
-				extras: {
-					lower: sql<string>`lower(${postsTable.content})`.as('lower_name'),
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			lower: string;
-			posts: { id: number; lower: string; content: string }[];
-			invitee: {
-				id: number;
-				name: string;
-				lower: string;
-			} | null;
-		}[]
-	>();
-
-	expect(response.length).eq(2);
-
-	expect(response[1]?.invitee).not.toBeNull();
-	expect(response[0]?.invitee).not.toBeNull();
-
-	expect(response[0]?.posts.length).eq(0);
-	expect(response[1]?.posts.length).eq(1);
-
-	expect(response[1]).toEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		invitee: { id: 1, name: 'Dan', lower: 'dan' },
-		posts: [{
-			id: 5,
-			content: 'Post3',
-			lower: 'post3',
-		}],
-	});
-	expect(response[0]).toEqual({
-		id: 4,
-		name: 'John',
-		lower: 'john',
-		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
-		posts: [],
-	});
-});
-
-/*
-	One two-level relation users+posts+comments
-*/
-
-test('Get user with posts and posts with comments', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			posts: {
-				id: number;
-				content: string;
-				ownerId: number | null;
-				createdAt: Date;
-				comments: {
-					id: number;
-					content: string;
-					createdAt: Date;
-					creator: number | null;
-					postId: number | null;
-				}[];
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	// expect(response[2]).toEqual({
-	// 	id: 3,
-	// 	name: 'Alex',
-	// 	verified: false,
-	// 	invitedBy: null,
-	// 	posts: [{
-	// 		id: 3,
-	// 		ownerId: 3,
-	// 		content: 'Post3',
-	// 		createdAt: response[2]?.posts[0]?.createdAt,
-	// 		comments: [
-	// 			{
-	// 				id: ,
-	// 				content: 'Comment3',
-	// 				creator: 3,
-	// 				postId: 3,
-	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
-	// 			},
-	// 		],
-	// 	}],
-	// });
-});
-
-// Get user with limit posts and limit comments
-
-// Get user with custom field + post + comment with custom field
-
-// Get user with limit + posts orderBy + comment orderBy
-
-// Get user with where + posts where + comment where
-
-// Get user with where + posts partial where + comment where
-
-// Get user with where + posts partial where + comment partial(false) where
-
-// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
-
-// Get user with where + posts partial where + comment where. Didn't select field from where in posts
-
-// Get user with where + posts partial where + comment where. Didn't select field from where for all
-
-// Get with limit+offset in each
-
-/*
-	One two-level + One first-level relation users+posts+comments and users+users
-*/
-
-/*
-	One three-level relation users+posts+comments+comment_owner
-*/
-
-test('Get user with posts and posts with comments and comments with owner', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(postsTable).values([
-		{ id: 1, ownerId: 1, content: 'Post1' },
-		{ id: 2, ownerId: 2, content: 'Post2' },
-		{ id: 3, ownerId: 3, content: 'Post3' },
-	]);
-
-	await db.insert(commentsTable).values([
-		{ postId: 1, content: 'Comment1', creator: 2 },
-		{ postId: 2, content: 'Comment2', creator: 2 },
-		{ postId: 3, content: 'Comment3', creator: 3 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			posts: {
-				with: {
-					comments: {
-						with: {
-							author: true,
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		posts: {
-			id: number;
-			content: string;
-			ownerId: number | null;
-			createdAt: Date;
-			comments: {
-				id: number;
-				content: string;
-				createdAt: Date;
-				creator: number | null;
-				postId: number | null;
-				author: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				} | null;
-			}[];
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).eq(3);
-	expect(response[0]?.posts.length).eq(1);
-	expect(response[1]?.posts.length).eq(1);
-	expect(response[2]?.posts.length).eq(1);
-
-	expect(response[0]?.posts[0]?.comments.length).eq(1);
-	expect(response[1]?.posts[0]?.comments.length).eq(1);
-	expect(response[2]?.posts[0]?.comments.length).eq(1);
-
-	expect(response[0]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 1,
-			ownerId: 1,
-			content: 'Post1',
-			createdAt: response[0]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 1,
-					content: 'Comment1',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 1,
-					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		posts: [{
-			id: 2,
-			ownerId: 2,
-			content: 'Post2',
-			createdAt: response[1]?.posts[0]?.createdAt,
-			comments: [
-				{
-					id: 2,
-					content: 'Comment2',
-					creator: 2,
-					author: {
-						id: 2,
-						name: 'Andrew',
-						verified: false,
-						invitedBy: null,
-					},
-					postId: 2,
-					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
-				},
-			],
-		}],
-	});
-});
-
-/*
-	One three-level relation + 1 first-level relatioon
-	1. users+posts+comments+comment_owner
-	2. users+users
-*/
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-*/
-
-/*
-	[Find Many] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find Many] Get users with groups', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + limit + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		limit: 1,
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + limit + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		limit: 1,
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(1);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(0);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(0);
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(2);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get groups with users + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		description: string | null;
-		usersToGroups: {
-			user: {
-				id: number;
-				name: string;
-				verified: boolean;
-				invitedBy: number | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response[2]).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find Many] Get users with groups + orderBy + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<{
-		id: number;
-		name: string;
-		verified: boolean;
-		invitedBy: number | null;
-		usersToGroups: {
-			group: {
-				id: number;
-				name: string;
-				description: string | null;
-			};
-		}[];
-	}[]>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-/*
-	[Find One] Many-to-many cases
-
-	Users+users_to_groups+groups
-*/
-
-test('[Find One] Get users with groups', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		with: {
-			usersToGroups: {
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + limit + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 1),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + limit + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				limit: 1,
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 2, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		where: (_, { eq, or }) => or(eq(usersTable.id, 1), eq(usersTable.id, 2)),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.groupId, 2),
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(0);
-
-	expect(response).toEqual({
-		id: 1,
-		name: 'Dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [],
-	});
-});
-
-test('[Find One] Get groups with users + where', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		where: gt(groupsTable.id, 1),
-		with: {
-			usersToGroups: {
-				where: eq(usersToGroupsTable.userId, 2),
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(2);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get groups with users + orderBy', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findFirst({
-		orderBy: [desc(groupsTable.id)],
-		with: {
-			usersToGroups: {
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('[Find One] Get users with groups + orderBy + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findFirst({
-		orderBy: (users, { desc }) => [desc(users.id)],
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: [desc(usersToGroupsTable.groupId)],
-				columns: {},
-				with: {
-					group: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-				};
-			}[];
-		} | undefined
-	>();
-
-	expect(response?.usersToGroups.length).toEqual(1);
-
-	expect(response).toEqual({
-		id: 3,
-		name: 'Alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + orderBy + limit', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		orderBy: [desc(groupsTable.id)],
-		limit: 2,
-		with: {
-			usersToGroups: {
-				limit: 1,
-				orderBy: (utg, { desc }) => [desc(utg.userId)],
-				columns: {},
-				with: {
-					user: true,
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-				};
-			}[];
-		}[]
-	>();
-
-	expect(response.length).toEqual(2);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-
-	expect(response[1]).toEqual({
-		id: 2,
-		name: 'Group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response[0]).toEqual({
-		id: 3,
-		name: 'Group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('Get users with groups + custom', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.usersTable.findMany({
-		extras: {
-			lower: sql<string>`lower(${usersTable.name})`.as('lower_name'),
-		},
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					group: {
-						extras: {
-							lower: sql<string>`lower(${groupsTable.name})`.as('lower_name'),
-						},
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			verified: boolean;
-			invitedBy: number | null;
-			lower: string;
-			usersToGroups: {
-				group: {
-					id: number;
-					name: string;
-					description: string | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(1);
-	expect(response[2]?.usersToGroups.length).toEqual(2);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Dan',
-		lower: 'dan',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 1,
-				name: 'Group1',
-				lower: 'group1',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Andrew',
-		lower: 'andrew',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Alex',
-		lower: 'alex',
-		verified: false,
-		invitedBy: null,
-		usersToGroups: [{
-			group: {
-				id: 3,
-				name: 'Group3',
-				lower: 'group3',
-				description: null,
-			},
-		}, {
-			group: {
-				id: 2,
-				name: 'Group2',
-				lower: 'group2',
-				description: null,
-			},
-		}],
-	});
-});
-
-test('Get groups with users + custom', async (t) => {
-	const { vpgDb: db } = t;
-
-	await db.insert(usersTable).values([
-		{ id: 1, name: 'Dan' },
-		{ id: 2, name: 'Andrew' },
-		{ id: 3, name: 'Alex' },
-	]);
-
-	await db.insert(groupsTable).values([
-		{ id: 1, name: 'Group1' },
-		{ id: 2, name: 'Group2' },
-		{ id: 3, name: 'Group3' },
-	]);
-
-	await db.insert(usersToGroupsTable).values([
-		{ userId: 1, groupId: 1 },
-		{ userId: 2, groupId: 2 },
-		{ userId: 3, groupId: 3 },
-		{ userId: 3, groupId: 2 },
-	]);
-
-	const response = await db.query.groupsTable.findMany({
-		extras: (table, { sql }) => ({
-			lower: sql<string>`lower(${table.name})`.as('lower_name'),
-		}),
-		with: {
-			usersToGroups: {
-				columns: {},
-				with: {
-					user: {
-						extras: (table, { sql }) => ({
-							lower: sql<string>`lower(${table.name})`.as('lower_name'),
-						}),
-					},
-				},
-			},
-		},
-	});
-
-	expectTypeOf(response).toEqualTypeOf<
-		{
-			id: number;
-			name: string;
-			description: string | null;
-			lower: string;
-			usersToGroups: {
-				user: {
-					id: number;
-					name: string;
-					verified: boolean;
-					invitedBy: number | null;
-					lower: string;
-				};
-			}[];
-		}[]
-	>();
-
-	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
-
-	expect(response.length).toEqual(3);
-
-	expect(response[0]?.usersToGroups.length).toEqual(1);
-	expect(response[1]?.usersToGroups.length).toEqual(2);
-	expect(response[2]?.usersToGroups.length).toEqual(1);
-
-	expect(response).toContainEqual({
-		id: 1,
-		name: 'Group1',
-		lower: 'group1',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 1,
-				name: 'Dan',
-				lower: 'dan',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 2,
-		name: 'Group2',
-		lower: 'group2',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 2,
-				name: 'Andrew',
-				lower: 'andrew',
-				verified: false,
-				invitedBy: null,
-			},
-		}, {
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-
-	expect(response).toContainEqual({
-		id: 3,
-		name: 'Group3',
-		lower: 'group3',
-		description: null,
-		usersToGroups: [{
-			user: {
-				id: 3,
-				name: 'Alex',
-				lower: 'alex',
-				verified: false,
-				invitedBy: null,
-			},
-		}],
-	});
-});
-
-test('.toSQL()', () => {
-	const query = db.query.usersTable.findFirst().toSQL();
-
-	expect(query).toHaveProperty('sql', expect.any(String));
-	expect(query).toHaveProperty('params', expect.any(Array));
-});
-
-// + custom + where + orderby
-
-// + custom + where + orderby + limit
-
-// + partial
-
-// + partial(false)
-
-// + partial + orderBy + where (all not selected)
-
-/*
-	One four-level relation users+posts+comments+coment_likes
-	+ users+users_to_groups+groups
-*/
-
-/*
-	Really hard case
-	1. users+posts+comments+coment_likes
-	2. users+users_to_groups+groups
-	3. users+users
-*/
diff --git a/integration-tests/tests/replicas/mysql.test.ts b/integration-tests/tests/replicas/mysql.test.ts
deleted file mode 100644
index f0202a781c..0000000000
--- a/integration-tests/tests/replicas/mysql.test.ts
+++ /dev/null
@@ -1,913 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { boolean, mysqlTable, serial, text, withReplicas } from 'drizzle-orm/mysql-core';
-import { drizzle } from 'drizzle-orm/mysql2';
-import { describe, expect, it, vi } from 'vitest';
-
-const usersTable = mysqlTable('users', {
-	id: serial('id' as string).primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-});
-
-const users = mysqlTable('users', {
-	id: serial('id' as string).primaryKey(),
-});
-
-describe('[select] read replicas mysql', () => {
-	it('primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query = db.$primary.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select `id` from `users`');
-
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(query1.toSQL().sql).toEqual('select count(*) as `count` from `users` limit ?');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('single read replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('single read replica select + primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select({ id: users.id }).from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.$primary.select().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('always first read select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.select().from(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-});
-
-describe('[selectDistinct] read replicas mysql', () => {
-	it('primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query = db.$primary.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('random replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('single read replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('single read replica selectDistinct + primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.$primary.selectDistinct().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('always first read selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-});
-
-describe('[with] read replicas mysql', () => {
-	it('primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-		const obj4 = {} as any;
-
-		db.$primary.with(obj1, obj2, obj3, obj4);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
-	});
-
-	it('random replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-	});
-
-	it('single read replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica with + primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.with();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-
-		db.with(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		db.with(obj2, obj3);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
-	});
-});
-
-describe('[update] replicas mysql', () => {
-	it('primary update', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'update');
-		const spyRead1 = vi.spyOn(read1, 'update');
-		const spyRead2 = vi.spyOn(read2, 'update');
-
-		const query1 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('update `users` set `id` = ?');
-
-		const query2 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('update `users` set `id` = ?');
-
-		const query3 = db.$primary.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query3.toSQL().sql).toEqual('update `users` set `id` = ?');
-	});
-});
-
-describe('[delete] replicas mysql', () => {
-	it('primary delete', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'delete');
-		const spyRead1 = vi.spyOn(read1, 'delete');
-		const spyRead2 = vi.spyOn(read2, 'delete');
-
-		const query1 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query1.toSQL().sql).toEqual('delete from `users`');
-
-		const query2 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-		expect(query2.toSQL().sql).toEqual('delete from `users`');
-
-		db.$primary.delete({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[insert] replicas mysql', () => {
-	it('primary insert', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'insert');
-		const spyRead1 = vi.spyOn(read1, 'insert');
-		const spyRead2 = vi.spyOn(read2, 'insert');
-
-		const query = db.insert(users).values({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query.toSQL().sql).toEqual('insert into `users` (`id`) values (?)');
-
-		db.insert(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-
-		db.$primary.insert({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[execute] replicas mysql', () => {
-	it('primary execute', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'execute');
-		const spyRead1 = vi.spyOn(read1, 'execute');
-		const spyRead2 = vi.spyOn(read2, 'execute');
-
-		expect(db.execute(sql``)).rejects.toThrow();
-
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[transaction] replicas mysql', () => {
-	it('primary transaction', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
-		const spyRead1 = vi.spyOn(read1, 'transaction');
-		const spyRead2 = vi.spyOn(read2, 'transaction');
-		const txFn1 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn1)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
-
-		const txFn2 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn2)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
-
-		expect(db.transaction(async (tx) => {
-			tx.select().from({} as any);
-		})).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findFirst] read replicas mysql', () => {
-	it('primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const obj = {} as any;
-
-		db.$primary.query.usersTable.findFirst(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-	});
-
-	it('random replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const par1 = {} as any;
-
-		db.query.usersTable.findFirst(par1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(par1);
-
-		const query = db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable` limit ?');
-	});
-
-	it('single read replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica findFirst + primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.query.usersTable.findFirst();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findMany] read replicas mysql', () => {
-	it('primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj = {} as any;
-
-		const query = db.$primary.query.usersTable.findMany(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-		expect(query.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-	});
-
-	it('random replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		const query2 = db.query.usersTable.findMany(obj2);
-
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-		expect(spyRead2).toHaveBeenCalledWith(obj2);
-	});
-
-	it('single read replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-	});
-
-	it('single read replica findMany + primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-		const query2 = db.$primary.query.usersTable.findMany(obj2);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
-		expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-	});
-
-	it('always first read findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read1 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-		const read2 = drizzle.mock({ schema: { usersTable }, mode: 'default' });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-	});
-});
-
-describe('[$count] read replicas postgres', () => {
-	it('primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$primary.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.$count(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-	});
-
-	it('single read replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$count(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica $count + primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.$count(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.$count(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
diff --git a/integration-tests/tests/replicas/postgres.test.ts b/integration-tests/tests/replicas/postgres.test.ts
deleted file mode 100644
index ab8dda4f56..0000000000
--- a/integration-tests/tests/replicas/postgres.test.ts
+++ /dev/null
@@ -1,935 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { boolean, jsonb, pgTable, serial, text, timestamp, withReplicas } from 'drizzle-orm/pg-core';
-import { describe, expect, it, vi } from 'vitest';
-
-const usersTable = pgTable('users', {
-	id: serial('id' as string).primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: jsonb('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
-});
-
-const users = pgTable('users', {
-	id: serial('id' as string).primaryKey(),
-});
-
-describe('[select] read replicas postgres', () => {
-	it('primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query = db.$primary.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select "id" from "users"');
-
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(query1.toSQL().sql).toEqual('select count(*) as "count" from "users" limit $1');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('single read replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('single read replica select + primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select({ id: users.id }).from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.$primary.select().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('always first read select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.select().from(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-});
-
-describe('[selectDistinct] read replicas postgres', () => {
-	it('primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query = db.$primary.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('random replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('single read replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('single read replica selectDistinct + primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.$primary.selectDistinct().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('always first read selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-});
-
-describe('[with] read replicas postgres', () => {
-	it('primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-		const obj4 = {} as any;
-
-		db.$primary.with(obj1, obj2, obj3, obj4);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
-	});
-
-	it('random replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-	});
-
-	it('single read replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica with + primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.with();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-
-		db.with(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		db.with(obj2, obj3);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
-	});
-});
-
-describe('[update] replicas postgres', () => {
-	it('primary update', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'update');
-		const spyRead1 = vi.spyOn(read1, 'update');
-		const spyRead2 = vi.spyOn(read2, 'update');
-
-		const query1 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('update "users" set "id" = $1');
-
-		const query2 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('update "users" set "id" = $1');
-
-		const query3 = db.$primary.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query3.toSQL().sql).toEqual('update "users" set "id" = $1');
-	});
-});
-
-describe('[delete] replicas postgres', () => {
-	it('primary delete', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'delete');
-		const spyRead1 = vi.spyOn(read1, 'delete');
-		const spyRead2 = vi.spyOn(read2, 'delete');
-
-		const query1 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query1.toSQL().sql).toEqual('delete from "users"');
-
-		const query2 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-		expect(query2.toSQL().sql).toEqual('delete from "users"');
-
-		db.$primary.delete({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[insert] replicas postgres', () => {
-	it('primary insert', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'insert');
-		const spyRead1 = vi.spyOn(read1, 'insert');
-		const spyRead2 = vi.spyOn(read2, 'insert');
-
-		const query = db.insert(users).values({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query.toSQL().sql).toEqual('insert into "users" ("id") values ($1)');
-
-		db.insert(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-
-		db.$primary.insert({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[execute] replicas postgres', () => {
-	it('primary execute', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'execute');
-		const spyRead1 = vi.spyOn(read1, 'execute');
-		const spyRead2 = vi.spyOn(read2, 'execute');
-
-		expect(db.execute(sql``)).rejects.toThrow();
-
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[transaction] replicas postgres', () => {
-	it('primary transaction', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
-		const spyRead1 = vi.spyOn(read1, 'transaction');
-		const spyRead2 = vi.spyOn(read2, 'transaction');
-		const txFn1 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn1)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
-
-		const txFn2 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn2)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
-
-		expect(db.transaction(async (tx) => {
-			tx.select().from({} as any);
-		})).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findFirst] read replicas postgres', () => {
-	it('primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const obj = {} as any;
-
-		db.$primary.query.usersTable.findFirst(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-	});
-
-	it('random replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const par1 = {} as any;
-
-		db.query.usersTable.findFirst(par1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(par1);
-
-		const query = db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable" limit $1',
-		);
-	});
-
-	it('single read replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica findFirst + primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.query.usersTable.findFirst();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findMany] read replicas postgres', () => {
-	it('primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj = {} as any;
-
-		const query = db.$primary.query.usersTable.findMany(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-		expect(query.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-	});
-
-	it('random replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		const query2 = db.query.usersTable.findMany(obj2);
-
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-		expect(spyRead2).toHaveBeenCalledWith(obj2);
-	});
-
-	it('single read replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-	});
-
-	it('single read replica findMany + primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-
-		const query2 = db.$primary.query.usersTable.findMany(obj2);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
-		expect(query2.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-	});
-
-	it('always first read findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual(
-			'select "id", "name", "verified", "jsonb", "created_at" from "users" "usersTable"',
-		);
-	});
-});
-
-describe('[$count] read replicas postgres', () => {
-	it('primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$primary.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('single read replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$count(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica $count + primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.$count(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.$count(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
diff --git a/integration-tests/tests/replicas/singlestore.test.ts b/integration-tests/tests/replicas/singlestore.test.ts
deleted file mode 100644
index f0f0ed14f8..0000000000
--- a/integration-tests/tests/replicas/singlestore.test.ts
+++ /dev/null
@@ -1,922 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/singlestore';
-import { serial, singlestoreTable, withReplicas } from 'drizzle-orm/singlestore-core';
-import { describe, expect, it, vi } from 'vitest';
-
-// const usersTable = singlestoreTable('users', {
-// 	id: serial('id' as string).primaryKey(),
-// 	name: text('name').notNull(),
-// 	verified: boolean('verified').notNull().default(false),
-// });
-
-const users = singlestoreTable('users', {
-	id: serial('id' as string).primaryKey(),
-});
-
-describe('[select] read replicas singlestore', () => {
-	it('primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query = db.$primary.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select `id` from `users`');
-
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(query1.toSQL().sql).toEqual('select count(*) as `count` from `users` limit ?');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('single read replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('single read replica select + primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select({ id: users.id }).from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.$primary.select().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-
-	it('always first read select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
-
-		const query2 = db.select().from(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
-	});
-});
-
-describe('[selectDistinct] read replicas singlestore', () => {
-	it('primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query = db.$primary.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('random replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('single read replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('single read replica selectDistinct + primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.$primary.selectDistinct().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-
-	it('always first read selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
-	});
-});
-
-describe('[with] read replicas singlestore', () => {
-	it('primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-		const obj4 = {} as any;
-
-		db.$primary.with(obj1, obj2, obj3, obj4);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
-	});
-
-	it('random replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-	});
-
-	it('single read replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica with + primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.with();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-
-		db.with(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		db.with(obj2, obj3);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
-	});
-});
-
-describe('[update] replicas singlestore', () => {
-	it('primary update', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'update');
-		const spyRead1 = vi.spyOn(read1, 'update');
-		const spyRead2 = vi.spyOn(read2, 'update');
-
-		const query1 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('update `users` set `id` = ?');
-
-		const query2 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('update `users` set `id` = ?');
-
-		const query3 = db.$primary.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query3.toSQL().sql).toEqual('update `users` set `id` = ?');
-	});
-});
-
-describe('[delete] replicas singlestore', () => {
-	it('primary delete', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'delete');
-		const spyRead1 = vi.spyOn(read1, 'delete');
-		const spyRead2 = vi.spyOn(read2, 'delete');
-
-		const query1 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query1.toSQL().sql).toEqual('delete from `users`');
-
-		const query2 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-		expect(query2.toSQL().sql).toEqual('delete from `users`');
-
-		db.$primary.delete({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[insert] replicas singlestore', () => {
-	it('primary insert', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'insert');
-		const spyRead1 = vi.spyOn(read1, 'insert');
-		const spyRead2 = vi.spyOn(read2, 'insert');
-
-		const query = db.insert(users).values({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query.toSQL().sql).toEqual('insert into `users` (`id`) values (?)');
-
-		db.insert(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-
-		db.$primary.insert({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[execute] replicas singlestore', () => {
-	it('primary execute', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'execute');
-		const spyRead1 = vi.spyOn(read1, 'execute');
-		const spyRead2 = vi.spyOn(read2, 'execute');
-
-		expect(db.execute(sql``)).rejects.toThrow();
-
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.execute(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[transaction] replicas singlestore', () => {
-	it('primary transaction', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
-		const spyRead1 = vi.spyOn(read1, 'transaction');
-		const spyRead2 = vi.spyOn(read2, 'transaction');
-		const txFn1 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn1)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
-
-		const txFn2 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn2)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
-
-		expect(db.transaction(async (tx) => {
-			tx.select().from({} as any);
-		})).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-// We are waiting for SingleStore support for `json_array` function
-// describe('[findFirst] read replicas singlestore', () => {
-// 	// it('primary findFirst', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-// 	// 	const obj = {} as any;
-
-// 	// 	db.$primary.query.usersTable.findFirst(obj);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyPrimary).toHaveBeenCalledWith(obj);
-// 	// });
-
-// 	// it('random replica findFirst', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2], () => {
-// 	// 		return randomMockReplica();
-// 	// 	});
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-// 	// 	const par1 = {} as any;
-
-// 	// 	db.query.usersTable.findFirst(par1);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledWith(par1);
-
-// 	// 	const query = db.query.usersTable.findFirst();
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	// 	expect(query.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable` limit ?');
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('single read replica findFirst', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-// 	// 	db.query.usersTable.findFirst();
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-
-// 	// 	db.query.usersTable.findFirst();
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('single read replica findFirst + primary findFirst', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-// 	// 	db.query.usersTable.findFirst();
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-
-// 	// 	db.$primary.query.usersTable.findFirst();
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('always first read findFirst', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 	// 		return replicas[0]!;
-// 	// 	});
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-
-// 	// 	db.query.usersTable.findFirst();
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-
-// 	// 	db.query.usersTable.findFirst();
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// });
-// });
-
-// describe('[findMany] read replicas singlestore', () => {
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('primary findMany', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-// 	// 	const obj = {} as any;
-
-// 	// 	const query = db.$primary.query.usersTable.findMany(obj);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyPrimary).toHaveBeenCalledWith(obj);
-// 	// 	expect(query.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('random replica findMany', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2], () => {
-// 	// 		return randomMockReplica();
-// 	// 	});
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-// 	// 	const obj1 = {} as any;
-// 	// 	const obj2 = {} as any;
-
-// 	// 	const query1 = db.query.usersTable.findMany(obj1);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// 	expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-// 	// 	const query2 = db.query.usersTable.findMany(obj2);
-
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	// 	expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// 	expect(spyRead2).toHaveBeenCalledWith(obj2);
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('single read replica findMany', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 	// 	const obj1 = {} as any;
-// 	// 	const obj2 = {} as any;
-
-// 	// 	const query1 = db.query.usersTable.findMany(obj1);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledWith(obj1);
-// 	// 	expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-// 	// 	const query2 = db.query.usersTable.findMany(obj2);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	// 	expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-// 	// 	expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('single read replica findMany + primary findMany', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1]);
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 	// 	const obj1 = {} as any;
-// 	// 	const obj2 = {} as any;
-
-// 	// 	const query1 = db.query.usersTable.findMany(obj1);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledWith(obj1);
-// 	// 	expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-// 	// 	const query2 = db.$primary.query.usersTable.findMany(obj2);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
-// 	// 	expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// });
-
-// 	// We are waiting for SingleStore support for `json_array` function
-// 	// it('always first read findMany', () => {
-// 	// 	const primaryDb = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read1 = drizzle.mock({ schema: { usersTable } });
-// 	// 	const read2 = drizzle.mock({ schema: { usersTable } });
-
-// 	// 	const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 	// 		return replicas[0]!;
-// 	// 	});
-
-// 	// 	const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 	// 	const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 	// 	const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-// 	// 	const obj1 = {} as any;
-// 	// 	const obj2 = {} as any;
-
-// 	// 	const query1 = db.query.usersTable.findMany(obj1);
-
-// 	// 	expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenCalledWith(obj1);
-// 	// 	expect(query1.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-
-// 	// 	const query2 = db.query.usersTable.findMany(obj2);
-// 	// 	expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	// 	expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	// 	expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-// 	// 	expect(query2.toSQL().sql).toEqual('select `id`, `name`, `verified` from `users` `usersTable`');
-// 	// });
-// });
-
-describe('[$count] read replicas postgres', () => {
-	it('primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$primary.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('single read replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$count(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica $count + primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.$count(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.$count(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
diff --git a/integration-tests/tests/replicas/sqlite.test.ts b/integration-tests/tests/replicas/sqlite.test.ts
deleted file mode 100644
index af7ef951cb..0000000000
--- a/integration-tests/tests/replicas/sqlite.test.ts
+++ /dev/null
@@ -1,909 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/libsql';
-import { int, sqliteTable, text, withReplicas } from 'drizzle-orm/sqlite-core';
-import { describe, expect, it, vi } from 'vitest';
-
-const usersTable = sqliteTable('users', {
-	id: int('id' as string).primaryKey(),
-	name: text('name').notNull(),
-	verified: text('verified').notNull().default('true'),
-});
-
-const users = sqliteTable('users', {
-	id: int('id' as string).primaryKey(),
-});
-
-describe('[select] read replicas sqlite', () => {
-	it('primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query = db.$primary.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select "id" from "users"');
-
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(query1.toSQL().sql).toEqual('select count(*) as "count" from "users" limit ?');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('single read replica select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('single read replica select + primary select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-
-		const query1 = db.select({ id: users.id }).from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.$primary.select().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-
-	it('always first read select', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'select');
-		const spyRead1 = vi.spyOn(read1, 'select');
-		const spyRead2 = vi.spyOn(read2, 'select');
-
-		const query1 = db.select().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
-
-		const query2 = db.select().from(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
-	});
-});
-
-describe('[selectDistinct] read replicas sqlite', () => {
-	it('primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query = db.$primary.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('random replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('single read replica selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('single read replica selectDistinct + primary selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.$primary.selectDistinct().from(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-
-	it('always first read selectDistinct', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
-
-		const query1 = db.selectDistinct().from(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
-
-		const query2 = db.selectDistinct().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
-	});
-});
-
-describe('[with] read replicas sqlite', () => {
-	it('primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-		const obj4 = {} as any;
-
-		db.$primary.with(obj1, obj2, obj3, obj4);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
-	});
-
-	it('random replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-	});
-
-	it('single read replica with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.with();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica with + primary with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-
-		db.with();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.with();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read with', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, 'with');
-		const spyRead1 = vi.spyOn(read1, 'with');
-		const spyRead2 = vi.spyOn(read2, 'with');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-		const obj3 = {} as any;
-
-		db.with(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		db.with(obj2, obj3);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
-	});
-});
-
-describe('[update] replicas sqlite', () => {
-	it('primary update', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'update');
-		const spyRead1 = vi.spyOn(read1, 'update');
-		const spyRead2 = vi.spyOn(read2, 'update');
-
-		const query1 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('update "users" set "id" = ?');
-
-		const query2 = db.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query2.toSQL().sql).toEqual('update "users" set "id" = ?');
-
-		const query3 = db.$primary.update(users).set({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query3.toSQL().sql).toEqual('update "users" set "id" = ?');
-	});
-});
-
-describe('[delete] replicas sqlite', () => {
-	it('primary delete', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'delete');
-		const spyRead1 = vi.spyOn(read1, 'delete');
-		const spyRead2 = vi.spyOn(read2, 'delete');
-
-		const query1 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query1.toSQL().sql).toEqual('delete from "users"');
-
-		const query2 = db.delete(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-		expect(query2.toSQL().sql).toEqual('delete from "users"');
-
-		db.$primary.delete({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[insert] replicas sqlite', () => {
-	it('primary insert', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'insert');
-		const spyRead1 = vi.spyOn(read1, 'insert');
-		const spyRead2 = vi.spyOn(read2, 'insert');
-
-		const query = db.insert(users).values({ id: 1 });
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(users);
-		expect(query.toSQL().sql).toEqual('insert into "users" ("id") values (?)');
-
-		db.insert(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
-
-		db.$primary.insert({} as any);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[execute] replicas sqlite', () => {
-	it('primary execute', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'all');
-		const spyRead1 = vi.spyOn(read1, 'all');
-		const spyRead2 = vi.spyOn(read2, 'all');
-
-		expect(db.all(sql``)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.all(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		expect(db.all(sql``)).rejects.toThrow();
-		// try {
-		// 	db.execute(sql``);
-		// } catch { /* empty */ }
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[transaction] replicas sqlite', () => {
-	it('primary transaction', async () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
-		const spyRead1 = vi.spyOn(read1, 'transaction');
-		const spyRead2 = vi.spyOn(read2, 'transaction');
-		const txFn1 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn1)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
-
-		const txFn2 = async (tx: any) => {
-			tx.select().from({} as any);
-		};
-
-		expect(db.transaction(txFn2)).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
-
-		expect(db.transaction(async (tx) => {
-			tx.select().from({} as any);
-		})).rejects.toThrow();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(3);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findFirst] read replicas sqlite', () => {
-	it('primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const obj = {} as any;
-
-		db.$primary.query.usersTable.findFirst(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-	});
-
-	it('random replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-		const par1 = {} as any;
-
-		db.query.usersTable.findFirst(par1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(par1);
-
-		const query = db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable" limit ?');
-	});
-
-	it('single read replica findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica findFirst + primary findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.query.usersTable.findFirst();
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read findFirst', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-
-		db.query.usersTable.findFirst();
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.query.usersTable.findFirst();
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
-
-describe('[findMany] read replicas sqlite', () => {
-	it('primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj = {} as any;
-
-		const query = db.$primary.query.usersTable.findMany(obj);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyPrimary).toHaveBeenCalledWith(obj);
-		expect(query.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-	});
-
-	it('random replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(query1.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-
-		const query2 = db.query.usersTable.findMany(obj2);
-
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(1);
-		expect(query2.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-		expect(spyRead2).toHaveBeenCalledWith(obj2);
-	});
-
-	it('single read replica findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-	});
-
-	it('single read replica findMany + primary findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-
-		const query2 = db.$primary.query.usersTable.findMany(obj2);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
-		expect(query2.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-	});
-
-	it('always first read findMany', () => {
-		const primaryDb = drizzle.mock({ schema: { usersTable } });
-		const read1 = drizzle.mock({ schema: { usersTable } });
-		const read2 = drizzle.mock({ schema: { usersTable } });
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
-		const obj1 = {} as any;
-		const obj2 = {} as any;
-
-		const query1 = db.query.usersTable.findMany(obj1);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledWith(obj1);
-		expect(query1.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-
-		const query2 = db.query.usersTable.findMany(obj2);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
-		expect(query2.toSQL().sql).toEqual('select "id", "name", "verified" from "users" "usersTable"');
-	});
-});
-
-describe('[$count] read replicas postgres', () => {
-	it('primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$primary.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(0);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('random replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
-
-		const db = withReplicas(primaryDb, [read1, read2], () => {
-			return randomMockReplica();
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.select().from(users);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-
-	it('single read replica $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$count(users);
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-	});
-
-	it('single read replica $count + primary $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1]);
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-
-		db.$primary.$count(users);
-		expect(spyPrimary).toHaveBeenCalledTimes(1);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-	});
-
-	it('always first read $count', () => {
-		const primaryDb = drizzle.mock();
-		const read1 = drizzle.mock();
-		const read2 = drizzle.mock();
-
-		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-			return replicas[0]!;
-		});
-
-		const spyPrimary = vi.spyOn(primaryDb, '$count');
-		const spyRead1 = vi.spyOn(read1, '$count');
-		const spyRead2 = vi.spyOn(read2, '$count');
-
-		db.$count(users);
-
-		expect(spyPrimary).toHaveBeenCalledTimes(0);
-		expect(spyRead1).toHaveBeenCalledTimes(1);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-
-		db.$count(users);
-
-		expect(spyRead1).toHaveBeenCalledTimes(2);
-		expect(spyRead2).toHaveBeenCalledTimes(0);
-	});
-});
diff --git a/integration-tests/tests/seeder/mysql.test.ts b/integration-tests/tests/seeder/mysql.test.ts
index 22530a2aa3..bd766339a2 100644
--- a/integration-tests/tests/seeder/mysql.test.ts
+++ b/integration-tests/tests/seeder/mysql.test.ts
@@ -1,47 +1,15 @@
-import Docker from 'dockerode';
 import { sql } from 'drizzle-orm';
 import type { MySql2Database } from 'drizzle-orm/mysql2';
 import { drizzle } from 'drizzle-orm/mysql2';
 import { reset, seed } from 'drizzle-seed';
-import getPort from 'get-port';
 import type { Connection } from 'mysql2/promise';
 import { createConnection } from 'mysql2/promise';
-import { v4 as uuid } from 'uuid';
 import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
-import * as schema from './mysqlSchema.ts';
+import * as schema from './mysqlSchema';
 
-let mysqlContainer: Docker.Container;
 let client: Connection;
 let db: MySql2Database;
 
-async function createDockerDB(): Promise<string> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'mysql:8';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		docker.modem.followProgress(pullStream, (err) => err ? reject(err) : resolve(err))
-	);
-
-	mysqlContainer = await docker.createContainer({
-		Image: image,
-		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await mysqlContainer.start();
-
-	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
-}
-
 const createNorthwindTables = async () => {
 	await db.execute(
 		sql`
@@ -246,7 +214,12 @@ const createAllGeneratorsTables = async () => {
 };
 
 beforeAll(async () => {
-	const connectionString = await createDockerDB();
+	const connectionString = process.env['MYSQL_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'MYSQL_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up mysql` and export the connection string before running tests.',
+		);
+	}
 
 	const sleep = 1000;
 	let timeLeft = 40000;
@@ -256,7 +229,7 @@ beforeAll(async () => {
 		try {
 			client = await createConnection(connectionString);
 			await client.connect();
-			db = drizzle(client);
+			db = drizzle({ client });
 			connected = true;
 			break;
 		} catch (e) {
@@ -268,7 +241,6 @@ beforeAll(async () => {
 	if (!connected) {
 		console.error('Cannot connect to MySQL');
 		await client?.end().catch(console.error);
-		await mysqlContainer?.stop().catch(console.error);
 		throw lastError;
 	}
 
@@ -279,7 +251,6 @@ beforeAll(async () => {
 
 afterAll(async () => {
 	await client?.end().catch(console.error);
-	await mysqlContainer?.stop().catch(console.error);
 });
 
 afterEach(async () => {
diff --git a/integration-tests/tests/seeder/pg.test.ts b/integration-tests/tests/seeder/pg.test.ts
index 48109f9fa0..05416f3b09 100644
--- a/integration-tests/tests/seeder/pg.test.ts
+++ b/integration-tests/tests/seeder/pg.test.ts
@@ -4,7 +4,7 @@ import type { PgliteDatabase } from 'drizzle-orm/pglite';
 import { drizzle } from 'drizzle-orm/pglite';
 import { cities, countries, firstNames, lastNames, reset, seed } from 'drizzle-seed';
 import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
-import * as schema from './pgSchema.ts';
+import * as schema from './pgSchema';
 
 let client: PGlite;
 let db: PgliteDatabase;
@@ -79,7 +79,7 @@ const createNorthwindTables = async () => {
 				"ship_country" text NOT NULL,
 				"customer_id" text NOT NULL,
 				"employee_id" integer NOT NULL
-			);    
+			);
 		`,
 	);
 
@@ -95,7 +95,7 @@ const createNorthwindTables = async () => {
 				"reorder_level" integer NOT NULL,
 				"discontinued" integer NOT NULL,
 				"supplier_id" integer NOT NULL
-			);    
+			);
 		`,
 	);
 
@@ -112,7 +112,7 @@ const createNorthwindTables = async () => {
 				"postal_code" text NOT NULL,
 				"country" text NOT NULL,
 				"phone" text NOT NULL
-			);    
+			);
 		`,
 	);
 
@@ -132,7 +132,7 @@ const createNorthwindTables = async () => {
 			 ALTER TABLE "seeder_lib_pg"."order_detail" ADD CONSTRAINT "order_detail_product_id_product_id_fk" FOREIGN KEY ("product_id") REFERENCES "seeder_lib_pg"."product"("id") ON DELETE cascade ON UPDATE no action;
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;    
+			END $$;
 		`,
 	);
 
@@ -142,7 +142,7 @@ const createNorthwindTables = async () => {
 			 ALTER TABLE "seeder_lib_pg"."employee" ADD CONSTRAINT "employee_reports_to_employee_id_fk" FOREIGN KEY ("reports_to") REFERENCES "seeder_lib_pg"."employee"("id") ON DELETE no action ON UPDATE no action;
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;    
+			END $$;
 		`,
 	);
 
@@ -152,7 +152,7 @@ const createNorthwindTables = async () => {
 			 ALTER TABLE "seeder_lib_pg"."order" ADD CONSTRAINT "order_customer_id_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "seeder_lib_pg"."customer"("id") ON DELETE cascade ON UPDATE no action;
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;    
+			END $$;
 		`,
 	);
 
@@ -162,7 +162,7 @@ const createNorthwindTables = async () => {
 			 ALTER TABLE "seeder_lib_pg"."order" ADD CONSTRAINT "order_employee_id_employee_id_fk" FOREIGN KEY ("employee_id") REFERENCES "seeder_lib_pg"."employee"("id") ON DELETE cascade ON UPDATE no action;
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;    
+			END $$;
 		`,
 	);
 
@@ -172,7 +172,7 @@ const createNorthwindTables = async () => {
 			 ALTER TABLE "seeder_lib_pg"."product" ADD CONSTRAINT "product_supplier_id_supplier_id_fk" FOREIGN KEY ("supplier_id") REFERENCES "seeder_lib_pg"."supplier"("id") ON DELETE cascade ON UPDATE no action;
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;    
+			END $$;
 		`,
 	);
 };
@@ -276,14 +276,14 @@ const createAllGeneratorsTables = async () => {
 			 CREATE TYPE "seeder_lib_pg"."enum" AS ENUM('sad', 'ok', 'happy');
 			EXCEPTION
 			 WHEN duplicate_object THEN null;
-			END $$;  
+			END $$;
 		`,
 	);
 	await db.execute(
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_table" (
 				"default_string" text
-			);    
+			);
 		`,
 	);
 
@@ -291,7 +291,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_array_table" (
 				"default_string" text[]
-			);    
+			);
 		`,
 	);
 
@@ -299,7 +299,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_table" (
 				"boolean" boolean
-			);    
+			);
 		`,
 	);
 
@@ -307,7 +307,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_array_table" (
 				"boolean" boolean[]
-			);    
+			);
 		`,
 	);
 
@@ -315,7 +315,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_table" (
 				"city" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -324,7 +324,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_unique_table" (
 				"city_unique" varchar(256),
 				CONSTRAINT "city_unique_table_city_unique_unique" UNIQUE("city_unique")
-			);    
+			);
 		`,
 	);
 
@@ -332,7 +332,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_array_table" (
 				"city" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -340,7 +340,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_table" (
 				"company_name" text
-			);    
+			);
 		`,
 	);
 
@@ -349,7 +349,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_unique_table" (
 				"company_name_unique" varchar(256),
 				CONSTRAINT "company_name_unique_table_company_name_unique_unique" UNIQUE("company_name_unique")
-			);    
+			);
 		`,
 	);
 
@@ -357,7 +357,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_array_table" (
 				"company_name" text[]
-			);    
+			);
 		`,
 	);
 
@@ -365,7 +365,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_table" (
 				"country" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -374,7 +374,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_unique_table" (
 				"country_unique" varchar(256),
 				CONSTRAINT "country_unique_table_country_unique_unique" UNIQUE("country_unique")
-			);    
+			);
 		`,
 	);
 
@@ -382,7 +382,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_array_table" (
 				"country" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -390,7 +390,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_table" (
 				"date" date
-			);    
+			);
 		`,
 	);
 
@@ -399,7 +399,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_array_table" (
 				"date" date[],
 				"date_string" date[]
-			);    
+			);
 		`,
 	);
 
@@ -408,7 +408,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_table" (
 				"email" varchar(256),
 				CONSTRAINT "email_table_email_unique" UNIQUE("email")
-			);    
+			);
 		`,
 	);
 
@@ -416,7 +416,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_array_table" (
 				"email" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -424,7 +424,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."enum_table" (
 				"mood_enum" "seeder_lib_pg"."enum"
-			);  
+			);
 		`,
 	);
 
@@ -432,7 +432,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_table" (
 				"first_name" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -441,7 +441,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_unique_table" (
 				"first_name_unique" varchar(256),
 				CONSTRAINT "first_name_unique_table_first_name_unique_unique" UNIQUE("first_name_unique")
-			);    
+			);
 		`,
 	);
 
@@ -449,7 +449,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_array_table" (
 				"first_name" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -457,7 +457,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name__table" (
 				"full_name_" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -466,7 +466,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_unique_table" (
 				"full_name_unique" varchar(256),
 				CONSTRAINT "full_name_unique_table_full_name_unique_unique" UNIQUE("full_name_unique")
-			);    
+			);
 		`,
 	);
 
@@ -474,7 +474,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_array_table" (
 				"full_name" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -483,7 +483,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_primary_key_table" (
 				"int_primary_key" integer,
 				CONSTRAINT "int_primary_key_table_int_primary_key_unique" UNIQUE("int_primary_key")
-			);    
+			);
 		`,
 	);
 
@@ -491,7 +491,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_table" (
 				"int" integer
-			);    
+			);
 		`,
 	);
 
@@ -500,7 +500,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_unique_table" (
 				"int_unique" integer,
 				CONSTRAINT "int_unique_table_int_unique_unique" UNIQUE("int_unique")
-			);    
+			);
 		`,
 	);
 
@@ -508,7 +508,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_array_table" (
 				"int" integer[]
-			);    
+			);
 		`,
 	);
 
@@ -516,7 +516,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_table" (
 				"interval" interval
-			);    
+			);
 		`,
 	);
 
@@ -525,7 +525,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_unique_table" (
 				"interval_unique" interval,
 				CONSTRAINT "interval_unique_table_interval_unique_unique" UNIQUE("interval_unique")
-			);    
+			);
 		`,
 	);
 
@@ -533,7 +533,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_array_table" (
 				"interval" interval[]
-			);    
+			);
 		`,
 	);
 
@@ -541,7 +541,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_title_table" (
 				"job_title" text
-			);    
+			);
 		`,
 	);
 
@@ -549,7 +549,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_title_array_table" (
 				"job_title" text[]
-			);    
+			);
 		`,
 	);
 
@@ -557,7 +557,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_table" (
 				"json" json
-			);    
+			);
 		`,
 	);
 
@@ -565,7 +565,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_array_table" (
 				"json" json[]
-			);    
+			);
 		`,
 	);
 
@@ -573,7 +573,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_table" (
 				"last_name" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -582,7 +582,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_unique_table" (
 				"last_name_unique" varchar(256),
 				CONSTRAINT "last_name_unique_table_last_name_unique_unique" UNIQUE("last_name_unique")
-			);    
+			);
 		`,
 	);
 
@@ -590,7 +590,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_array_table" (
 				"last_name" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -598,7 +598,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_table" (
 				"line" "line"
-			);    
+			);
 		`,
 	);
 
@@ -606,7 +606,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_array_table" (
 				"line" "line"[]
-			);    
+			);
 		`,
 	);
 
@@ -614,7 +614,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_table" (
 				"lorem_ipsum" text
-			);    
+			);
 		`,
 	);
 
@@ -622,7 +622,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_array_table" (
 				"lorem_ipsum" text[]
-			);    
+			);
 		`,
 	);
 
@@ -630,7 +630,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_table" (
 				"number" real
-			);    
+			);
 		`,
 	);
 
@@ -639,7 +639,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_unique_table" (
 				"number_unique" real,
 				CONSTRAINT "number_unique_table_number_unique_unique" UNIQUE("number_unique")
-			);    
+			);
 		`,
 	);
 
@@ -647,7 +647,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_array_table" (
 				"number" real[]
-			);    
+			);
 		`,
 	);
 
@@ -660,7 +660,7 @@ const createAllGeneratorsTables = async () => {
 				CONSTRAINT "phone_number_table_phoneNumber_unique" UNIQUE("phoneNumber"),
 				CONSTRAINT "phone_number_table_phone_number_template_unique" UNIQUE("phone_number_template"),
 				CONSTRAINT "phone_number_table_phone_number_prefixes_unique" UNIQUE("phone_number_prefixes")
-			);    
+			);
 		`,
 	);
 
@@ -670,7 +670,7 @@ const createAllGeneratorsTables = async () => {
 				"phoneNumber" varchar(256)[],
 				"phone_number_template" varchar(256)[],
 				"phone_number_prefixes" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -678,7 +678,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_table" (
 				"point" "point"
-			);    
+			);
 		`,
 	);
 
@@ -686,7 +686,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_array_table" (
 				"point" "point"[]
-			);    
+			);
 		`,
 	);
 
@@ -694,7 +694,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_table" (
 				"postcode" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -703,7 +703,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_unique_table" (
 				"postcode_unique" varchar(256),
 				CONSTRAINT "postcode_unique_table_postcode_unique_unique" UNIQUE("postcode_unique")
-			);    
+			);
 		`,
 	);
 
@@ -711,7 +711,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_array_table" (
 				"postcode" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -719,7 +719,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_table" (
 				"state" text
-			);   
+			);
 		`,
 	);
 
@@ -727,7 +727,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_array_table" (
 				"state" text[]
-			);   
+			);
 		`,
 	);
 
@@ -735,7 +735,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_table" (
 				"street_address" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -744,7 +744,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_unique_table" (
 				"street_address_unique" varchar(256),
 				CONSTRAINT "street_address_unique_table_street_address_unique_unique" UNIQUE("street_address_unique")
-			);    
+			);
 		`,
 	);
 
@@ -752,7 +752,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_array_table" (
 				"street_address" varchar(256)[]
-			);    
+			);
 		`,
 	);
 
@@ -760,7 +760,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_table" (
 				"string" text
-			);    
+			);
 		`,
 	);
 
@@ -769,7 +769,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_unique_table" (
 				"string_unique" varchar(256),
 				CONSTRAINT "string_unique_table_string_unique_unique" UNIQUE("string_unique")
-			);    
+			);
 		`,
 	);
 
@@ -777,7 +777,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_array_table" (
 				"string" text[]
-			);    
+			);
 		`,
 	);
 
@@ -785,7 +785,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_table" (
 				"time" time
-			);    
+			);
 		`,
 	);
 
@@ -793,7 +793,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_array_table" (
 				"time" time[]
-			);    
+			);
 		`,
 	);
 
@@ -801,7 +801,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_table" (
 				"timestamp" timestamp
-			);    
+			);
 		`,
 	);
 
@@ -809,7 +809,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_array_table" (
 				"timestamp" timestamp[]
-			);    
+			);
 		`,
 	);
 
@@ -818,7 +818,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_table" (
 				"values_from_array_not_null" varchar(256) NOT NULL,
 				"values_from_array_weighted_not_null" varchar(256) NOT NULL
-			);    
+			);
 		`,
 	);
 
@@ -833,15 +833,15 @@ const createAllGeneratorsTables = async () => {
 				CONSTRAINT "values_from_array_unique_table_values_from_array_not_null_unique" UNIQUE("values_from_array_not_null"),
 				CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_unique" UNIQUE("values_from_array_weighted"),
 				CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_not_null_unique" UNIQUE("values_from_array_weighted_not_null")
-			);    
+			);
 		`,
 	);
 
 	await db.execute(
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_array_table" (
-				"values_from_array" varchar(256)
-			);    
+				"values_from_array" varchar(256)[]
+			);
 		`,
 	);
 
@@ -849,7 +849,7 @@ const createAllGeneratorsTables = async () => {
 		sql`
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_table" (
 				"weighted_random" varchar(256)
-			);    
+			);
 		`,
 	);
 
@@ -858,7 +858,7 @@ const createAllGeneratorsTables = async () => {
 			    CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_with_unique_gens_table" (
 				"weighted_random_with_unique_gens" varchar(256),
 				CONSTRAINT "weighted_random_with_unique_gens_table_weighted_random_with_unique_gens_unique" UNIQUE("weighted_random_with_unique_gens")
-			);    
+			);
 		`,
 	);
 
@@ -868,7 +868,7 @@ const createAllGeneratorsTables = async () => {
 							"id" integer GENERATED ALWAYS AS IDENTITY,
 							"id1" integer,
 							"name" text
-						); 
+						);
 		`,
 	);
 };
@@ -876,7 +876,7 @@ const createAllGeneratorsTables = async () => {
 beforeAll(async () => {
 	client = new PGlite();
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	await db.execute(sql`CREATE SCHEMA IF NOT EXISTS "seeder_lib_pg";`);
 
@@ -1127,28 +1127,15 @@ test('all array data types test', async () => {
 });
 
 test('nd arrays', async () => {
-	await seed(db, { ndArrays: schema.ndArrays }, { count: 1000 });
+	await seed(db, { ndArrays: schema.ndArrays }, { count: 500 });
 
 	const ndArrays = await db.select().from(schema.ndArrays);
 	// every value in each rows does not equal undefined.
 	const predicate0 = ndArrays.every((row) =>
 		Object.values(row).every((val) => val !== undefined && val !== null && val.length !== 0)
 	);
-	let predicate1 = true, predicate2 = true, predicate3 = true, predicate4 = true;
-
-	for (const row of ndArrays) {
-		predicate1 = predicate1 && (row.integer1DArray?.length === 3);
-
-		predicate2 = predicate2 && (row.integer2DArray?.length === 4) && (row.integer2DArray[0]?.length === 3);
-
-		predicate3 = predicate3 && (row.integer3DArray?.length === 5) && (row.integer3DArray[0]?.length === 4)
-			&& (row.integer3DArray[0][0]?.length === 3);
-
-		predicate4 = predicate4 && (row.integer4DArray?.length === 6) && (row.integer4DArray[0]?.length === 5)
-			&& (row.integer4DArray[0][0]?.length === 4) && (row.integer4DArray[0][0][0]?.length === 3);
-	}
 
-	expect(predicate0 && predicate1 && predicate2 && predicate3 && predicate4).toBe(true);
+	expect(predicate0).toBe(true);
 });
 
 // All generators test-------------------------------
@@ -1242,8 +1229,8 @@ test('valuesFromArray unique generator test', async () => {
 				}),
 				valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
 					values: [
-						{ values: lastNames.slice(0, 14920), weight: 0.3 },
-						{ values: lastNames.slice(14920), weight: 0.7 },
+						{ values: lastNames.slice(0, 14894), weight: 0.3 },
+						{ values: lastNames.slice(14894), weight: 0.7 },
 					],
 					isUnique: true,
 				}),
diff --git a/integration-tests/tests/seeder/pgSchema.ts b/integration-tests/tests/seeder/pgSchema.ts
index ee0fceff56..707afefddf 100644
--- a/integration-tests/tests/seeder/pgSchema.ts
+++ b/integration-tests/tests/seeder/pgSchema.ts
@@ -194,10 +194,10 @@ export const allArrayDataTypes = schema.table('all_array_data_types', {
 });
 
 export const ndArrays = schema.table('nd_arrays', {
-	integer1DArray: integer('integer_1d_array').array(3),
-	integer2DArray: integer('integer_2d_array').array(3).array(4),
-	integer3DArray: integer('integer_3d_array').array(3).array(4).array(5),
-	integer4DArray: integer('integer_4d_array').array(3).array(4).array(5).array(6),
+	integer1DArray: integer('integer_1d_array').array(),
+	integer2DArray: integer('integer_2d_array').array('[][]'),
+	integer3DArray: integer('integer_3d_array').array('[][][]'),
+	integer4DArray: integer('integer_4d_array').array('[][][][]'),
 });
 
 // All generators tables -------------------------------
diff --git a/integration-tests/tests/seeder/sqlite.test.ts b/integration-tests/tests/seeder/sqlite.test.ts
index f9d124401b..3c731bf7f8 100644
--- a/integration-tests/tests/seeder/sqlite.test.ts
+++ b/integration-tests/tests/seeder/sqlite.test.ts
@@ -4,7 +4,7 @@ import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { drizzle } from 'drizzle-orm/better-sqlite3';
 import { reset, seed } from 'drizzle-seed';
 import { afterAll, afterEach, beforeAll, expect, test } from 'vitest';
-import * as schema from './sqliteSchema.ts';
+import * as schema from './sqliteSchema';
 
 let client: BetterSqlite3.Database;
 let db: BetterSQLite3Database;
@@ -12,7 +12,7 @@ let db: BetterSQLite3Database;
 beforeAll(async () => {
 	client = new BetterSqlite3(':memory:');
 
-	db = drizzle(client);
+	db = drizzle({ client });
 
 	db.run(
 		sql.raw(`
@@ -66,7 +66,7 @@ beforeAll(async () => {
 	\`reports_to\` integer,
 	\`photo_path\` text,
 	FOREIGN KEY (\`reports_to\`) REFERENCES \`employee\`(\`id\`) ON UPDATE no action ON DELETE no action
-);        
+);
     `),
 	);
 
@@ -88,7 +88,7 @@ beforeAll(async () => {
 	\`employee_id\` integer NOT NULL,
 	FOREIGN KEY (\`customer_id\`) REFERENCES \`customer\`(\`id\`) ON UPDATE no action ON DELETE cascade,
 	FOREIGN KEY (\`employee_id\`) REFERENCES \`employee\`(\`id\`) ON UPDATE no action ON DELETE cascade
-);        
+);
     `),
 	);
 
@@ -105,7 +105,7 @@ beforeAll(async () => {
 	\`discontinued\` integer NOT NULL,
 	\`supplier_id\` integer NOT NULL,
 	FOREIGN KEY (\`supplier_id\`) REFERENCES \`supplier\`(\`id\`) ON UPDATE no action ON DELETE cascade
-);        
+);
     `),
 	);
 
@@ -122,7 +122,7 @@ beforeAll(async () => {
 	\`postal_code\` text NOT NULL,
 	\`country\` text NOT NULL,
 	\`phone\` text NOT NULL
-);        
+);
     `),
 	);
 
diff --git a/integration-tests/tests/seeder/sqliteSchema.ts b/integration-tests/tests/seeder/sqliteSchema.ts
index 3388336593..126c35b992 100644
--- a/integration-tests/tests/seeder/sqliteSchema.ts
+++ b/integration-tests/tests/seeder/sqliteSchema.ts
@@ -34,12 +34,10 @@ export const employees = sqliteTable(
 		reportsTo: integer('reports_to'),
 		photoPath: text('photo_path'),
 	},
-	(table) => ({
-		reportsToFk: foreignKey(() => ({
-			columns: [table.reportsTo],
-			foreignColumns: [table.id],
-		})),
-	}),
+	(table) => [foreignKey({
+		columns: [table.reportsTo],
+		foreignColumns: [table.id],
+	})],
 );
 
 export const orders = sqliteTable('order', {
diff --git a/integration-tests/tests/singlestore/common-1.ts b/integration-tests/tests/singlestore/common-1.ts
new file mode 100644
index 0000000000..5d6e7d0322
--- /dev/null
+++ b/integration-tests/tests/singlestore/common-1.ts
@@ -0,0 +1,1261 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { and, asc, eq, exists, inArray, Name, notInArray, placeholder, sql } from 'drizzle-orm';
+import type { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
+import {
+	alias,
+	bigint,
+	boolean,
+	date,
+	datetime,
+	getTableConfig,
+	int,
+	json,
+	mediumint,
+	primaryKey,
+	serial,
+	singlestoreEnum,
+	singlestoreTable,
+	singlestoreTableCreator,
+	/* singlestoreView, */
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	unique,
+	uniqueIndex,
+	vector,
+	year,
+} from 'drizzle-orm/singlestore-core';
+import { migrate } from 'drizzle-orm/singlestore/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { describe, expect } from 'vitest';
+import { toLocalDate } from '../utils';
+import type { Test } from './instrumentation';
+
+const usersTable = singlestoreTable('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+const users2Table = singlestoreTable('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id'),
+});
+
+const citiesTable = singlestoreTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const datesTable = singlestoreTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time'),
+	datetime: datetime('datetime'),
+	datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+	timestamp: timestamp('timestamp'),
+	timestampAsString: timestamp('timestamp_as_string', { mode: 'string' }),
+	year: year('year'),
+});
+
+const coursesTable = singlestoreTable('courses', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: int('category_id'),
+});
+
+const courseCategoriesTable = singlestoreTable('course_categories', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const orders = singlestoreTable('orders', {
+	id: serial('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+const usersMigratorTable = singlestoreTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => [
+	uniqueIndex('').on(table.name).using('btree'),
+]);
+
+export function tests(test: Test) {
+	const connDict: Record<string, any> = {};
+
+	describe('common', () => {
+		test.beforeEach(async ({ db, client }) => {
+			const connKey = `${client.config.user}:${client.config.password}@${client.config.host}:${client.config.port}`;
+			if (connDict[connKey] === undefined) {
+				connDict[connKey] = false;
+
+				await Promise.all([
+					db.execute(sql`drop table if exists userstest;`),
+					db.execute(sql`drop table if exists users2;`),
+					db.execute(sql`drop table if exists cities;`),
+				]);
+				await Promise.all([
+					db.execute(sql`create table userstest (
+                        id serial primary key,
+                        name text not null,
+                        verified boolean not null default false,
+                        jsonb json,
+                        created_at timestamp not null default now()
+                    );`),
+					db.execute(sql`create table users2 (
+                        id serial primary key,
+                        name text not null,
+                        city_id int
+                	);`),
+					db.execute(sql`create table cities (
+                	    id serial primary key,
+                	    name text not null
+                	);`),
+				]);
+			}
+
+			await Promise.all([
+				db.execute(sql`truncate table userstest;`),
+				db.execute(sql`truncate table users2;`),
+				db.execute(sql`truncate table cities;`),
+			]);
+		});
+
+		test.concurrent('table config: unsigned ints', async () => {
+			const unsignedInts = singlestoreTable('cities1', {
+				bigint: bigint('bigint', { mode: 'number', unsigned: true }),
+				int: int('int', { unsigned: true }),
+				smallint: smallint('smallint', { unsigned: true }),
+				mediumint: mediumint('mediumint', { unsigned: true }),
+				tinyint: tinyint('tinyint', { unsigned: true }),
+			});
+
+			const tableConfig = getTableConfig(unsignedInts);
+
+			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+			expect(bigintColumn.getSQLType()).toBe('bigint unsigned');
+			expect(intColumn.getSQLType()).toBe('int unsigned');
+			expect(smallintColumn.getSQLType()).toBe('smallint unsigned');
+			expect(mediumintColumn.getSQLType()).toBe('mediumint unsigned');
+			expect(tinyintColumn.getSQLType()).toBe('tinyint unsigned');
+		});
+
+		test.concurrent('table config: signed ints', async () => {
+			const unsignedInts = singlestoreTable('cities1', {
+				bigint: bigint('bigint', { mode: 'number' }),
+				int: int('int'),
+				smallint: smallint('smallint'),
+				mediumint: mediumint('mediumint'),
+				tinyint: tinyint('tinyint'),
+			});
+
+			const tableConfig = getTableConfig(unsignedInts);
+
+			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+			expect(bigintColumn.getSQLType()).toBe('bigint');
+			expect(intColumn.getSQLType()).toBe('int');
+			expect(smallintColumn.getSQLType()).toBe('smallint');
+			expect(mediumintColumn.getSQLType()).toBe('mediumint');
+			expect(tinyintColumn.getSQLType()).toBe('tinyint');
+		});
+
+		test.concurrent('table config: primary keys name', async () => {
+			const table = singlestoreTable('cities', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: text('state'),
+			}, (t) => [primaryKey({ columns: [t.id, t.name], name: 'custom_pk' })]);
+
+			const tableConfig = getTableConfig(table);
+
+			expect(tableConfig.primaryKeys).toHaveLength(1);
+			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
+		});
+
+		test.concurrent('table configs: unique third param', async () => {
+			const cities1Table = singlestoreTable('cities1', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				state: text('state'),
+			}, (t) => [unique('custom_name').on(t.name, t.state), unique('custom_name1').on(t.name, t.state)]);
+
+			const tableConfig = getTableConfig(cities1Table);
+
+			expect(tableConfig.uniqueConstraints).toHaveLength(2);
+
+			expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
+			expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+
+			expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
+			expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+		});
+
+		test.concurrent('table configs: unique in column', async () => {
+			const cities1Table = singlestoreTable('cities1', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull().unique(),
+				state: text('state').unique('custom'),
+				field: text('field').unique('custom_field'),
+			});
+
+			const tableConfig = getTableConfig(cities1Table);
+
+			const columnName = tableConfig.columns.find((it) => it.name === 'name');
+			expect(columnName?.uniqueName).toBe(undefined);
+			expect(columnName?.isUnique).toBeTruthy();
+
+			const columnState = tableConfig.columns.find((it) => it.name === 'state');
+			expect(columnState?.uniqueName).toBe('custom');
+			expect(columnState?.isUnique).toBeTruthy();
+
+			const columnField = tableConfig.columns.find((it) => it.name === 'field');
+			expect(columnField?.uniqueName).toBe('custom_field');
+			expect(columnField?.isUnique).toBeTruthy();
+		});
+
+		test.concurrent('select all fields', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const result = await db.select().from(usersTable);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			// not timezone based timestamp, thats why it should not work here
+			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+		});
+
+		test.concurrent('select sql', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select({
+				name: sql`upper(${usersTable.name})`,
+			}).from(usersTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('select typed sql', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select({
+				name: sql<string>`upper(${usersTable.name})`,
+			}).from(usersTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('select with empty array in inArray', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(inArray(usersTable.id, []))
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([]);
+		});
+
+		test.concurrent('select with empty array in notInArray', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+			const result = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(notInArray(usersTable.id, []))
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+		});
+
+		test.concurrent('select distinct', async ({ db }) => {
+			const usersDistinctTable = singlestoreTable('users_distinct', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+				{ id: 1, name: 'Jane' },
+			]);
+			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+				usersDistinctTable.id,
+				usersDistinctTable.name,
+			);
+
+			await db.execute(sql`drop table ${usersDistinctTable}`);
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+		});
+
+		test.concurrent('insert returning sql', async ({ db }) => {
+			const [result, _] = await db.insert(usersTable).values({ id: 1, name: 'John' });
+
+			expect(result.insertId).toBe(1);
+		});
+
+		test.concurrent('delete returning sql', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+			expect(users[0].affectedRows).toBe(1);
+		});
+
+		test.concurrent('update returning sql', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+			expect(users[0].changedRows).toBe(1);
+		});
+
+		test.concurrent('update with returning all fields', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+			const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+			expect(updatedUsers[0].changedRows).toBe(1);
+
+			expect(users[0]!.createdAt).toBeInstanceOf(Date);
+			// not timezone based timestamp, thats why it should not work here
+			// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+			expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+		});
+
+		test.concurrent('update with returning partial', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+			const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			);
+
+			expect(updatedUsers[0].changedRows).toBe(1);
+
+			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+		});
+
+		test.concurrent('delete with returning all fields', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+			expect(deletedUser[0].affectedRows).toBe(1);
+		});
+
+		test.concurrent('delete with returning partial', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+			expect(deletedUser[0].affectedRows).toBe(1);
+		});
+
+		test.concurrent('insert + select', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const result = await db.select().from(usersTable);
+			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+			await db.insert(usersTable).values({ id: 2, name: 'Jane' });
+			const result2 = await db.select().from(usersTable).orderBy(asc(usersTable.id));
+			expect(result2).toEqual([
+				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+			]);
+		});
+
+		test.concurrent('json insert', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John', jsonb: ['foo', 'bar'] });
+			const result = await db.select({
+				id: usersTable.id,
+				name: usersTable.name,
+				jsonb: usersTable.jsonb,
+			}).from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+		});
+
+		test.concurrent('insert with overridden default values', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John', verified: true });
+			const result = await db.select().from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+		});
+
+		test.concurrent('insert many', async ({ db }) => {
+			await db.insert(usersTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ id: 3, name: 'Jane' },
+				{ id: 4, name: 'Austin', verified: true },
+			]);
+			const result = await db.select({
+				id: usersTable.id,
+				name: usersTable.name,
+				jsonb: usersTable.jsonb,
+				verified: usersTable.verified,
+			}).from(usersTable)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test.concurrent('insert many with returning', async ({ db }) => {
+			const result = await db.insert(usersTable).values([
+				{ name: 'John' },
+				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ name: 'Jane' },
+				{ name: 'Austin', verified: true },
+			]);
+
+			expect(result[0].affectedRows).toBe(4);
+		});
+
+		test.concurrent('select with group by as field', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const result = await db.select({ name: usersTable.name }).from(usersTable)
+				.groupBy(usersTable.name)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test.concurrent('select with exists', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const user = alias(usersTable, 'user');
+			const result = await db.select({ name: usersTable.name }).from(usersTable).where(
+				exists(
+					db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
+				),
+			)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'John' }]);
+		});
+
+		test.concurrent('select with group by as sql', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const result = await db.select({ name: usersTable.name }).from(usersTable)
+				.groupBy(sql`${usersTable.name}`)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+		});
+
+		test.concurrent('$default function', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`orders\``);
+			await db.execute(
+				sql`
+                    create table \`orders\` (
+                        \`id\` serial primary key,
+                        \`region\` text not null,
+                        \`product\` text not null,
+                        \`amount\` int not null,
+                        \`quantity\` int not null
+                    )
+                `,
+			);
+
+			await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+			const selectedOrder = await db.select().from(orders);
+
+			expect(selectedOrder).toEqual([{
+				id: 1,
+				amount: 1,
+				quantity: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			}]);
+		});
+
+		test.concurrent('$default with empty array', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`s_orders\``);
+			await db.execute(
+				sql`
+                    create table \`s_orders\` (
+                        \`id\` serial primary key,
+                        \`region\` text default 'Ukraine',
+                        \`product\` text not null
+                    )
+                `,
+			);
+
+			const users = singlestoreTable('s_orders', {
+				id: serial('id').primaryKey(),
+				region: text('region').default('Ukraine'),
+				product: text('product').$defaultFn(() => 'random_string'),
+			});
+
+			await db.insert(users).values({ id: 1 });
+			const selectedOrder = await db.select().from(users);
+
+			expect(selectedOrder).toEqual([{
+				id: 1,
+				region: 'Ukraine',
+				product: 'random_string',
+			}]);
+		});
+
+		test.concurrent('select with group by as sql + column', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const result = await db.select({ name: usersTable.name }).from(usersTable)
+				.groupBy(sql`${usersTable.name}`, usersTable.id)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		});
+
+		test.concurrent('select with group by as column + sql', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const result = await db.select({ name: usersTable.name }).from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		});
+
+		test.concurrent('select with group by complex query', async ({ db }) => {
+			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
+
+			const result = await db.select({ name: usersTable.name }).from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`)
+				.orderBy(asc(usersTable.name))
+				.limit(1);
+
+			expect(result).toEqual([{ name: 'Jane' }]);
+		});
+
+		test.concurrent('build query', async ({ db }) => {
+			const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+				.groupBy(usersTable.id, usersTable.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql: `select \`id\`, \`name\` from \`userstest\` group by \`userstest\`.\`id\`, \`userstest\`.\`name\``,
+				params: [],
+			});
+		});
+
+		test.concurrent('Query check: Insert all defaults in 1 row', async ({ db }) => {
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			const query = db
+				.insert(users)
+				.values({})
+				.toSQL();
+
+			expect(query).toEqual({
+				sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
+				params: [],
+			});
+		});
+
+		test.concurrent('Query check: Insert all defaults in multiple rows', async ({ db }) => {
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state').default('UA'),
+			});
+
+			const query = db
+				.insert(users)
+				.values([{}, {}])
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into `users` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
+				params: [],
+			});
+		});
+
+		test.concurrent('Insert all defaults in 1 row', async ({ db }) => {
+			const users = singlestoreTable('empty_insert_single', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
+			);
+
+			await db.insert(users).values({ id: 1 });
+
+			const res = await db.select().from(users);
+
+			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
+		});
+
+		test.concurrent('Insert all defaults in multiple rows', async ({ db }) => {
+			const users = singlestoreTable('empty_insert_multiple', {
+				id: serial('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
+			);
+
+			await db.insert(users).values([{ id: 1 }, { id: 2 }]);
+
+			const res = await db.select().from(users).orderBy(asc(users.id));
+
+			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+		});
+
+		test.concurrent('build query insert with onDuplicate', async ({ db }) => {
+			const query = db.insert(usersTable)
+				.values({ id: 1, name: 'John', jsonb: ['foo', 'bar'] })
+				.onDuplicateKeyUpdate({ set: { id: 1, name: 'John1' } })
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (?, ?, default, ?, default) on duplicate key update `id` = ?, `name` = ?',
+				params: [1, 'John', '["foo","bar"]', 1, 'John1'],
+			});
+		});
+
+		test.concurrent('insert with onDuplicate', async ({ db }) => {
+			const users = singlestoreTable('userstest_update_p', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+			});
+
+			await db.execute(sql`drop table if exists ${users};`);
+			await db.execute(sql`create table ${users} (
+						\`id\` serial primary key,
+						\`name\` text not null,
+						\`verified\` boolean not null default false
+					);`);
+
+			await db.insert(users)
+				.values({ id: 1, name: 'John' });
+
+			await db.insert(users)
+				.values({ id: 1, name: 'John' })
+				.onDuplicateKeyUpdate({ set: { name: 'John1' } });
+
+			const res = await db.select({ id: users.id, name: users.name }).from(users).where(
+				eq(users.id, 1),
+			);
+
+			expect(res).toEqual([{ id: 1, name: 'John1' }]);
+		});
+
+		test.concurrent('insert with onDuplicate placeholder', async ({ db }) => {
+			await db.insert(usersTable)
+				.values({ id: 1, name: 'John' });
+
+			await db.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onDuplicateKeyUpdate({ set: { name: sql.placeholder('name') } })
+				.execute({ name: 'John1' });
+
+			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			);
+
+			expect(res).toEqual([{ id: 1, name: 'John1' }]);
+		});
+
+		test.concurrent('insert conflict', async ({ db }) => {
+			await db.insert(usersTable)
+				.values({ id: 1, name: 'John' });
+
+			await expect((async () => {
+				db.insert(usersTable).values({ id: 1, name: 'John1' });
+			})()).resolves.not.toThrowError();
+		});
+
+		test.concurrent('insert conflict with ignore', async ({ db }) => {
+			await db.insert(usersTable)
+				.values({ id: 1, name: 'John' });
+
+			await db.insert(usersTable)
+				.ignore()
+				.values({ id: 1, name: 'John1' });
+
+			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			);
+
+			expect(res).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert sql', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: sql`${'John'}` });
+			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('partial join with alias', async ({ db }) => {
+			const customerAlias = alias(usersTable, 'customer');
+
+			await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select({
+					user: {
+						id: usersTable.id,
+						name: usersTable.name,
+					},
+					customer: {
+						id: customerAlias.id,
+						name: customerAlias.name,
+					},
+				}).from(usersTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(usersTable.id, 10))
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([{
+				user: { id: 10, name: 'Ivan' },
+				customer: { id: 11, name: 'Hans' },
+			}]);
+		});
+
+		test.concurrent('full join with alias', async ({ db }) => {
+			const singlestoreTable = singlestoreTableCreator((name) => `prefixed_${name}`);
+
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select().from(users)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(users.id, 10))
+				.orderBy(asc(users.id));
+
+			expect(result).toEqual([{
+				users: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			}]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('select from alias', async ({ db }) => {
+			const singlestoreTable = singlestoreTableCreator((name) => `prefixed_${name}`);
+
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+			const user = alias(users, 'user');
+			const customers = alias(users, 'customer');
+
+			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			const result = await db
+				.select()
+				.from(user)
+				.leftJoin(customers, eq(customers.id, 11))
+				.where(eq(user.id, 10))
+				.orderBy(asc(user.id));
+
+			expect(result).toEqual([{
+				user: {
+					id: 10,
+					name: 'Ivan',
+				},
+				customer: {
+					id: 11,
+					name: 'Hans',
+				},
+			}]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('insert with spaces', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: sql`'Jo   h     n'` });
+			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test.concurrent('prepared statement', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const statement = db.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			}).from(usersTable)
+				.prepare();
+			const result = await statement.execute();
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert: placeholders on columns with encoder', async ({ db }) => {
+			const date = new Date('2024-08-07T15:30:00Z');
+
+			const statement = db.insert(usersTable).values({
+				id: 1,
+				name: 'John',
+				createdAt: sql.placeholder('createdAt'),
+			}).prepare();
+
+			await statement.execute({ createdAt: date });
+
+			const result = await db
+				.select({
+					id: usersTable.id,
+					createdAt: usersTable.createdAt,
+				})
+				.from(usersTable);
+
+			expect(result).toEqual([
+				{ id: 1, createdAt: date },
+			]);
+		});
+
+		test.concurrent('prepared statement reuse', async ({ db }) => {
+			const stmt = db.insert(usersTable).values({
+				verified: true,
+				id: placeholder('id'),
+				name: placeholder('name'),
+			}).prepare();
+
+			for (let i = 0; i < 10; i++) {
+				await stmt.execute({ id: i + 1, name: `John ${i}` });
+			}
+
+			const result = await db.select({
+				id: usersTable.id,
+				name: usersTable.name,
+				verified: usersTable.verified,
+			}).from(usersTable)
+				.orderBy(asc(usersTable.id));
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John 0', verified: true },
+				{ id: 2, name: 'John 1', verified: true },
+				{ id: 3, name: 'John 2', verified: true },
+				{ id: 4, name: 'John 3', verified: true },
+				{ id: 5, name: 'John 4', verified: true },
+				{ id: 6, name: 'John 5', verified: true },
+				{ id: 7, name: 'John 6', verified: true },
+				{ id: 8, name: 'John 7', verified: true },
+				{ id: 9, name: 'John 8', verified: true },
+				{ id: 10, name: 'John 9', verified: true },
+			]);
+		});
+
+		test.concurrent('prepared statement with placeholder in .where', async ({ db }) => {
+			await db.insert(usersTable).values({ id: 1, name: 'John' });
+			const stmt = db.select({
+				id: usersTable.id,
+				name: usersTable.name,
+			}).from(usersTable)
+				.where(eq(usersTable.id, placeholder('id')))
+				.prepare();
+			const result = await stmt.execute({ id: 1 });
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('migrator', async ({ db }) => {
+			await db.execute(sql`drop table if exists cities_migration`);
+			await db.execute(sql`drop table if exists users_migration`);
+			await db.execute(sql`drop table if exists users12`);
+			await db.execute(sql`drop table if exists __drizzle_migrations`);
+
+			await migrate(db, { migrationsFolder: './drizzle2/singlestore' });
+
+			await db.insert(usersMigratorTable).values({ id: 1, name: 'John', email: 'email' });
+
+			const result = await db.select().from(usersMigratorTable);
+
+			expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+			await db.execute(sql`drop table cities_migration`);
+			await db.execute(sql`drop table users_migration`);
+			await db.execute(sql`drop table users12`);
+			await db.execute(sql`drop table __drizzle_migrations`);
+		});
+
+		test.concurrent('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+			const users = singlestoreTable('migration_users', {
+				id: serial('id').primaryKey(),
+				name: text().notNull(),
+				email: text().notNull(),
+				age: int(),
+			});
+
+			const users2 = singlestoreTable('migration_users2', {
+				id: serial('id').primaryKey(),
+				name: text().notNull(),
+				email: text().notNull(),
+				age: int(),
+			});
+
+			await db.execute(sql`drop table if exists \`__drizzle_migrations\`;`);
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop table if exists ${users2}`);
+
+			// create migration directory
+			const migrationDir = './migrations/singlestore';
+			if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+			mkdirSync(migrationDir, { recursive: true });
+
+			// first branch
+			mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+			writeFileSync(
+				`${migrationDir}/20240101010101_initial/migration.sql`,
+				'CREATE TABLE `migration_users` (\n`id` serial PRIMARY KEY NOT NULL,\n`name` text NOT NULL,\n`email` text NOT NULL\n);',
+			);
+			mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+			writeFileSync(
+				`${migrationDir}/20240303030303_third/migration.sql`,
+				'ALTER TABLE `migration_users` ADD `age` int;',
+			);
+
+			await migrate(db, { migrationsFolder: migrationDir });
+			await db.insert(users).values({ name: 'John', email: '', age: 30 });
+			const res1 = await db.select().from(users);
+
+			// second migration was not applied yet
+			await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+			// insert migration with earlier timestamp
+			mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+			writeFileSync(
+				`${migrationDir}/20240202020202_second/migration.sql`,
+				'CREATE TABLE `migration_users2` (\n`id` serial PRIMARY KEY NOT NULL,\n`name` text NOT NULL,\n`email` text NOT NULL,\n`age` int\n);',
+			);
+			await migrate(db, { migrationsFolder: migrationDir });
+
+			await db.insert(users2).values({ name: 'John', email: '', age: 30 });
+			const res2 = await db.select().from(users2);
+
+			const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+			expect(res1).toStrictEqual(expected);
+			expect(res2).toStrictEqual(expected);
+
+			rmSync(migrationDir, { recursive: true });
+		});
+
+		test.concurrent('insert via db.execute + select via db.execute', async ({ db }) => {
+			await db.execute(
+				sql`insert into ${usersTable} (${new Name(usersTable.id.name)},${new Name(
+					usersTable.name.name,
+				)}) values (1,${'John'})`,
+			);
+
+			const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
+			expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('insert via db.execute w/ query builder', async ({ db }) => {
+			const inserted = await db.execute(
+				db.insert(usersTable).values({ id: 1, name: 'John' }),
+			);
+			expect(inserted[0].affectedRows).toBe(1);
+		});
+
+		test.concurrent('insert + select all possible dates', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`datestable\``);
+			await db.execute(
+				sql`
+                    create table \`datestable\` (
+                        \`date\` date,
+                        \`date_as_string\` date,
+                        \`time\` time,
+                        \`datetime\` datetime,
+                        \`datetime_as_string\` datetime,
+                        \`timestamp\` timestamp(6),
+                        \`timestamp_as_string\` timestamp(6),
+                        \`year\` year
+                    )
+                `,
+			);
+
+			const date = new Date('2022-11-11');
+			const dateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
+
+			await db.insert(datesTable).values({
+				date: date,
+				dateAsString: '2022-11-11',
+				time: '12:12:12',
+				datetime: date,
+				year: 22,
+				datetimeAsString: '2022-11-11 12:12:12',
+				timestamp: dateWithMilliseconds,
+				timestampAsString: '2022-11-11 12:12:12.123',
+			});
+
+			const res = await db.select().from(datesTable);
+
+			expect(res[0]?.date).toBeInstanceOf(Date);
+			expect(res[0]?.datetime).toBeInstanceOf(Date);
+			expect(typeof res[0]?.dateAsString).toBe('string');
+			expect(typeof res[0]?.datetimeAsString).toBe('string');
+
+			expect(res).toEqual([{
+				date: toLocalDate(new Date('2022-11-11')),
+				dateAsString: '2022-11-11',
+				time: '12:12:12',
+				datetime: new Date('2022-11-11'),
+				year: 2022,
+				datetimeAsString: '2022-11-11 12:12:12',
+				timestamp: new Date('2022-11-11 12:12:12.123'),
+				timestampAsString: '2022-11-11 12:12:12.123000',
+			}]);
+
+			await db.execute(sql`drop table if exists \`datestable\``);
+		});
+
+		const tableWithEnums = singlestoreTable('enums_test_case', {
+			id: serial('id').primaryKey(),
+			enum1: singlestoreEnum('enum1', ['a', 'b', 'c']).notNull(),
+			enum2: singlestoreEnum('enum2', ['a', 'b', 'c']).default('a'),
+			enum3: singlestoreEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
+		});
+
+		test.concurrent('SingleStore enum test case #1', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`enums_test_case\``);
+
+			await db.execute(sql`
+                create table \`enums_test_case\` (
+                    \`id\` serial primary key,
+                    \`enum1\` ENUM('a', 'b', 'c') not null,
+                    \`enum2\` ENUM('a', 'b', 'c') default 'a',
+                    \`enum3\` ENUM('a', 'b', 'c') not null default 'b'
+                )
+            `);
+
+			await db.insert(tableWithEnums).values([
+				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+				{ id: 2, enum1: 'a', enum3: 'c' },
+				{ id: 3, enum1: 'a' },
+			]);
+
+			const res = await db.select().from(tableWithEnums).orderBy(asc(tableWithEnums.id));
+
+			await db.execute(sql`drop table \`enums_test_case\``);
+
+			expect(res).toEqual([
+				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+				{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+				{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+			]);
+		});
+
+		test.concurrent('left join (flat object fields)', async ({ db }) => {
+			await db.insert(citiesTable)
+				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+			const res = await db.select({
+				userId: users2Table.id,
+				userName: users2Table.name,
+				cityId: citiesTable.id,
+				cityName: citiesTable.name,
+			}).from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
+				.orderBy(users2Table.id);
+
+			expect(res).toEqual([
+				{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+			]);
+		});
+
+		test.concurrent('left join (grouped fields)', async ({ db }) => {
+			await db.insert(citiesTable)
+				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+			const res = await db.select({
+				id: users2Table.id,
+				user: {
+					name: users2Table.name,
+					nameUpper: sql<string>`upper(${users2Table.name})`,
+				},
+				city: {
+					id: citiesTable.id,
+					name: citiesTable.name,
+					nameUpper: sql<string>`upper(${citiesTable.name})`,
+				},
+			}).from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
+				.orderBy(asc(users2Table.id));
+
+			expect(res).toEqual([
+				{
+					id: 1,
+					user: { name: 'John', nameUpper: 'JOHN' },
+					city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+				},
+				{
+					id: 2,
+					user: { name: 'Jane', nameUpper: 'JANE' },
+					city: null,
+				},
+			]);
+		});
+
+		test.concurrent('left join (all fields)', async ({ db }) => {
+			await db.insert(citiesTable)
+				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
+
+			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
+
+			const res = await db.select().from(users2Table)
+				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
+				.orderBy(asc(users2Table.id));
+
+			expect(res).toEqual([
+				{
+					users2: {
+						id: 1,
+						name: 'John',
+						cityId: 1,
+					},
+					cities: {
+						id: 1,
+						name: 'Paris',
+					},
+				},
+				{
+					users2: {
+						id: 2,
+						name: 'Jane',
+						cityId: null,
+					},
+					cities: null,
+				},
+			]);
+		});
+
+		test.concurrent('join subquery', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`courses\``);
+			await db.execute(sql`drop table if exists \`course_categories\``);
+
+			await db.execute(
+				sql`
+                    create table \`course_categories\` (
+                        \`id\` serial primary key,
+                        \`name\` text not null
+                    )
+                `,
+			);
+
+			await db.execute(
+				sql`
+                    create table \`courses\` (
+                        \`id\` serial primary key,
+                        \`name\` text not null,
+                        \`category_id\` int
+                    )
+                `,
+			);
+
+			await db.insert(courseCategoriesTable).values([
+				{ id: 1, name: 'Category 1' },
+				{ id: 2, name: 'Category 2' },
+				{ id: 3, name: 'Category 3' },
+				{ id: 4, name: 'Category 4' },
+			]);
+
+			await db.insert(coursesTable).values([
+				{ id: 1, name: 'Development', categoryId: 2 },
+				{ id: 2, name: 'IT & Software', categoryId: 3 },
+				{ id: 3, name: 'Marketing', categoryId: 4 },
+				{ id: 4, name: 'Design', categoryId: 1 },
+			]);
+
+			const sq2 = db
+				.select({
+					categoryId: courseCategoriesTable.id,
+					category: courseCategoriesTable.name,
+					total: sql<number>`count(${courseCategoriesTable.id})`,
+				})
+				.from(courseCategoriesTable)
+				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+				.as('sq2');
+
+			const res = await db
+				.select({
+					courseName: coursesTable.name,
+					categoryId: sq2.categoryId,
+				})
+				.from(coursesTable)
+				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+				.orderBy(coursesTable.name);
+
+			expect(res).toEqual([
+				{ courseName: 'Design', categoryId: 1 },
+				{ courseName: 'Development', categoryId: 2 },
+				{ courseName: 'IT & Software', categoryId: 3 },
+				{ courseName: 'Marketing', categoryId: 4 },
+			]);
+
+			await db.execute(sql`drop table if exists \`courses\``);
+			await db.execute(sql`drop table if exists \`course_categories\``);
+		});
+	});
+}
diff --git a/integration-tests/tests/singlestore/common-2.ts b/integration-tests/tests/singlestore/common-2.ts
new file mode 100644
index 0000000000..eafbc7b974
--- /dev/null
+++ b/integration-tests/tests/singlestore/common-2.ts
@@ -0,0 +1,3598 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import {
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	eq,
+	getTableColumns,
+	gt,
+	gte,
+	inArray,
+	isNull,
+	lt,
+	max,
+	min,
+	sql,
+	sum,
+	sumDistinct,
+	TransactionRollbackError,
+} from 'drizzle-orm';
+import type { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
+import {
+	alias,
+	bigint,
+	binary,
+	boolean,
+	char,
+	date,
+	datetime,
+	decimal,
+	double,
+	except,
+	float,
+	getTableConfig,
+	index,
+	int,
+	intersect,
+	json,
+	mediumint,
+	primaryKey,
+	real,
+	serial,
+	SingleStoreDialect,
+	singlestoreEnum,
+	singlestoreSchema,
+	singlestoreTable,
+	singlestoreTableCreator,
+	/* singlestoreView, */
+	smallint,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	union,
+	unionAll,
+	varbinary,
+	varchar,
+	vector,
+	year,
+} from 'drizzle-orm/singlestore-core';
+import { dotProduct, euclideanDistance } from 'drizzle-orm/singlestore-core/expressions';
+import { describe, expect, expectTypeOf } from 'vitest';
+import { Expect } from '../utils';
+import type { Equal } from '../utils';
+import type { Test } from './instrumentation';
+import type relations from './relations';
+
+type TestSingleStoreDB = SingleStoreDatabase<any, any, any, typeof relations>;
+
+const allTypesTable = singlestoreTable('all_types', {
+	serial: serial('scol'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	bigintString: bigint('bigint_string', {
+		mode: 'string',
+	}),
+	binary: binary('binary'),
+	boolean: boolean('boolean'),
+	char: char('char'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	datetime: datetime('datetime', {
+		mode: 'date',
+	}),
+	datetimeStr: datetime('datetime_str', {
+		mode: 'string',
+	}),
+	decimal: decimal('decimal'),
+	decimalNum: decimal('decimal_num', {
+		scale: 30,
+		mode: 'number',
+	}),
+	decimalBig: decimal('decimal_big', {
+		scale: 30,
+		mode: 'bigint',
+	}),
+	double: double('double'),
+	float: float('float'),
+	int: int('int'),
+	json: json('json'),
+	medInt: mediumint('med_int'),
+	smallInt: smallint('small_int'),
+	real: real('real'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	tinyInt: tinyint('tiny_int'),
+	varbin: varbinary('varbin', {
+		length: 16,
+	}),
+	varchar: varchar('varchar', {
+		length: 255,
+	}),
+	year: year('year'),
+	enum: singlestoreEnum('enum', ['enV1', 'enV2']),
+	vectorI8: vector('vec_i8', {
+		dimensions: 5,
+		elementType: 'I8',
+	}),
+	vectorI16: vector('vec_i16', {
+		dimensions: 5,
+		elementType: 'I16',
+	}),
+	vectorI32: vector('vec_i32', {
+		dimensions: 5,
+		elementType: 'I32',
+	}),
+	vectorI64: vector('vec_i64', {
+		dimensions: 5,
+		elementType: 'I64',
+	}),
+	vectorF32: vector('vec_f32', {
+		dimensions: 5,
+		elementType: 'F32',
+	}),
+	vectorF64: vector('vec_f64', {
+		dimensions: 5,
+		elementType: 'F64',
+	}),
+});
+
+const usersTable = singlestoreTable('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+const users2Table = singlestoreTable('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id'),
+});
+
+const citiesTable = singlestoreTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const usersOnUpdate = singlestoreTable('users_on_update', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	updateCounter: int('update_counter')
+		.default(sql`1`)
+		.$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: datetime('updated_at', { mode: 'date' }).$onUpdateFn(
+		() => new Date(),
+	),
+	alwaysNull: text('always_null')
+		.$type<string | null>()
+		.$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
+});
+
+const orders = singlestoreTable('orders', {
+	id: serial('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product')
+		.notNull()
+		.$default(() => 'random_string'),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+// To test aggregate functions
+const aggregateTable = singlestoreTable('aggregate_table', {
+	id: serial('id').notNull(),
+	name: text('name').notNull(),
+	a: int('a'),
+	b: int('b'),
+	c: int('c'),
+	nullOnly: int('null_only'),
+});
+
+const vectorSearchTable = singlestoreTable('vector_search', {
+	id: serial('id').notNull(),
+	text: text('text').notNull(),
+	embedding: vector('embedding', { dimensions: 10 }),
+});
+
+// To test another schema and multischema
+const mySchema = singlestoreSchema(`mySchema`);
+
+const usersMySchemaTable = mySchema.table('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+export function tests(test: Test) {
+	const connDict: Record<string, any> = {};
+
+	describe('common', () => {
+		test.beforeEach(async ({ db, client }) => {
+			const connKey = `${client.config.user}:${client.config.password}@${client.config.host}:${client.config.port}`;
+
+			if (connDict[connKey] === undefined) {
+				connDict[connKey] = false;
+
+				await Promise.all([
+					db.execute(sql`drop schema if exists \`mySchema\`;`),
+					db.execute(sql`drop table if exists userstest;`),
+					db.execute(sql`drop table if exists users2;`),
+					db.execute(sql`drop table if exists cities;`),
+					db.execute(sql`drop table if exists aggregate_table;`),
+					db.execute(sql`drop table if exists vector_search;`),
+					db.execute(sql`drop table if exists users_default_fn;`),
+				]);
+				await db.execute(sql`create schema \`mySchema\`;`);
+				await Promise.all([
+					db.execute(sql`create table userstest (
+                        id serial primary key,
+                        name text not null,
+                        verified boolean not null default false,
+                        jsonb json,
+                        created_at timestamp not null default now()
+                    );`),
+					db.execute(sql`create table users2 (
+                        id serial primary key,
+                        name text not null,
+                        city_id int
+                	);`),
+					db.execute(sql`create table cities (
+                	    id serial primary key,
+                	    name text not null
+                	);`),
+					db.execute(sql`create table \`mySchema\`.\`userstest\` (
+                	    id serial primary key,
+                	    name text not null,
+                	    verified boolean not null default false,
+                	    jsonb json,
+                	    created_at timestamp not null default now()
+                	);`),
+					db.execute(sql`create table \`mySchema\`.\`cities\` (
+                	    \`id\` serial primary key,
+                	    \`name\` text not null
+                	);`),
+					db.execute(sql`create table \`mySchema\`.\`users2\` (
+                	    \`id\` serial primary key,
+                	    \`name\` text not null,
+                	    \`city_id\` int 
+                	);`),
+					db.execute(sql`create table aggregate_table (
+                	    id integer primary key auto_increment not null,
+                	    name text not null,
+                	    a integer,
+                	    b integer,
+                	    c integer,
+                	    null_only integer
+                	);`),
+					db.execute(sql`create table vector_search (
+                	    id integer primary key auto_increment not null,
+                	    text text not null,
+                	    embedding vector(10) not null
+                	);`),
+					db.execute(sql`create table users_default_fn (
+                	    id varchar(256) primary key,
+                	    name text not null
+                	);`),
+				]);
+			}
+
+			await Promise.all([
+				db.execute(sql`truncate table userstest;`),
+				db.execute(sql`truncate table users2;`),
+				db.execute(sql`truncate table cities;`),
+				db.execute(sql`truncate table aggregate_table;`),
+				db.execute(sql`truncate table vector_search;`),
+				db.execute(sql`truncate table users_default_fn;`),
+
+				db.execute(sql`truncate table \`mySchema\`.\`userstest\`;`),
+				db.execute(sql`truncate table \`mySchema\`.\`cities\`;`),
+				db.execute(sql`truncate table \`mySchema\`.\`users2\`;`),
+			]);
+		});
+
+		async function setupReturningFunctionsTest(
+			db: SingleStoreDatabase<any, any>,
+		) {
+			await db.execute(sql`truncate table users_default_fn`);
+		}
+
+		async function setupSetOperationTest(db: TestSingleStoreDB) {
+			await Promise.all([
+				db.execute(sql`truncate table \`users2\`;`),
+				db.execute(sql`truncate table \`cities\``),
+			]);
+			await Promise.all([
+				db.insert(citiesTable).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]),
+				db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]),
+			]);
+		}
+
+		async function setupAggregateFunctionsTest(db: TestSingleStoreDB) {
+			await db.execute(sql`truncate table aggregate_table`);
+			await db.insert(aggregateTable).values([
+				{ id: 1, name: 'value 1', a: 5, b: 10, c: 20 },
+				{ id: 2, name: 'value 1', a: 5, b: 20, c: 30 },
+				{ id: 3, name: 'value 2', a: 10, b: 50, c: 60 },
+				{ id: 4, name: 'value 3', a: 20, b: 20, c: null },
+				{ id: 5, name: 'value 4', a: null, b: 90, c: 120 },
+				{ id: 6, name: 'value 5', a: 80, b: 10, c: null },
+				{ id: 7, name: 'value 6', a: null, b: null, c: 150 },
+			]);
+		}
+
+		async function setupVectorSearchTest(db: TestSingleStoreDB) {
+			await db.execute(sql`truncate table vector_search`);
+			await db.insert(vectorSearchTable).values([
+				{
+					id: 1,
+					text: 'I like dogs',
+					embedding: [
+						0.6119,
+						0.1395,
+						0.2921,
+						0.3664,
+						0.4561,
+						0.7852,
+						0.1997,
+						0.5142,
+						0.5924,
+						0.0465,
+					],
+				},
+				{
+					id: 2,
+					text: 'I like cats',
+					embedding: [
+						0.6075,
+						0.1705,
+						0.0651,
+						0.9489,
+						0.9656,
+						0.8084,
+						0.3046,
+						0.0977,
+						0.6842,
+						0.4402,
+					],
+				},
+			]);
+		}
+
+		test.concurrent('with ... select', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`orders\``);
+			await db.execute(
+				sql`
+                    create table \`orders\` (
+                        \`id\` serial primary key,
+                        \`region\` text not null,
+                        \`product\` text not null,
+                        \`amount\` int not null,
+                        \`quantity\` int not null
+                    )
+                `,
+			);
+
+			await db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const regionalSales = db.$with('regional_sales').as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+			const topRegions = db.$with('top_regions').as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db
+								.select({ sales: sql`sum(${regionalSales.totalSales})/10` })
+								.from(regionalSales),
+						),
+					),
+			);
+
+			const result = await db
+				.with(regionalSales, topRegions)
+				.select({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+					productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+				})
+				.from(orders)
+				.where(
+					inArray(
+						orders.region,
+						db.select({ region: topRegions.region }).from(topRegions),
+					),
+				)
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product);
+
+			expect(result).toEqual([
+				{
+					region: 'Europe',
+					product: 'A',
+					productUnits: 3,
+					productSales: 30,
+				},
+				{
+					region: 'Europe',
+					product: 'B',
+					productUnits: 5,
+					productSales: 50,
+				},
+				{
+					region: 'US',
+					product: 'A',
+					productUnits: 7,
+					productSales: 70,
+				},
+				{
+					region: 'US',
+					product: 'B',
+					productUnits: 9,
+					productSales: 90,
+				},
+			]);
+		});
+
+		test.concurrent('with ... update', async ({ db }) => {
+			const products = singlestoreTable('products', {
+				id: serial('id').primaryKey(),
+				price: decimal('price', {
+					precision: 15,
+					scale: 2,
+				}).notNull(),
+				cheap: boolean('cheap').notNull().default(false),
+			});
+
+			await db.execute(sql`drop table if exists ${products}`);
+			await db.execute(sql`
+                create table ${products} (
+                    id serial primary key,
+                    price decimal(15, 2) not null,
+                    cheap boolean not null default false
+                )
+            `);
+
+			await db.insert(products).values([
+				{ id: 1, price: '10.99' },
+				{ id: 2, price: '25.85' },
+				{ id: 3, price: '32.99' },
+				{ id: 4, price: '2.50' },
+				{ id: 5, price: '4.59' },
+			]);
+
+			const averagePrice = db.$with('average_price').as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+			await db
+				.with(averagePrice)
+				.update(products)
+				.set({
+					cheap: true,
+				})
+				.where(lt(products.price, sql`(select * from ${averagePrice})`));
+
+			const result = await db
+				.select({
+					id: products.id,
+				})
+				.from(products)
+				.where(eq(products.cheap, true))
+				.orderBy(asc(products.id));
+
+			expect(result).toEqual([{ id: 1 }, { id: 4 }, { id: 5 }]);
+		});
+
+		test.concurrent('with ... delete', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`orders\``);
+			await db.execute(
+				sql`
+                    create table \`orders\` (
+                        \`id\` serial primary key,
+                        \`region\` text not null,
+                        \`product\` text not null,
+                        \`amount\` int not null,
+                        \`quantity\` int not null
+                    )
+                `,
+			);
+
+			await db.insert(orders).values([
+				{ id: 1, region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ id: 2, region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ id: 3, region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ id: 4, region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ id: 5, region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ id: 6, region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ id: 7, region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ id: 8, region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const averageAmount = db.$with('average_amount').as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+			await db
+				.with(averageAmount)
+				.delete(orders)
+				.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
+
+			const result = await db
+				.select({
+					id: orders.id,
+				})
+				.from(orders)
+				.orderBy(asc(orders.id));
+
+			expect(result).toEqual([
+				{ id: 1 },
+				{ id: 2 },
+				{ id: 3 },
+				{ id: 4 },
+				{ id: 5 },
+			]);
+		});
+
+		test.concurrent('select from subquery sql', async ({ db }) => {
+			await db.insert(users2Table).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			const sq = db
+				.select({
+					name: sql<string>`concat(${users2Table.name}, " modified")`.as(
+						'name',
+					),
+				})
+				.from(users2Table)
+				.orderBy(asc(users2Table.id))
+				.as('sq');
+
+			const res = await db.select({ name: sq.name }).from(sq);
+
+			expect(res).toEqual([
+				{ name: 'John modified' },
+				{ name: 'Jane modified' },
+			]);
+		});
+
+		test.concurrent('select a field without joining its table', ({ db }) => {
+			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+		});
+
+		test.concurrent(
+			'select all fields from subquery without alias',
+			({ db }) => {
+				const sq = db
+					.$with('sq')
+					.as(
+						db
+							.select({ name: sql<string>`upper(${users2Table.name})` })
+							.from(users2Table),
+					);
+
+				expect(() => db.select().from(sq).prepare()).toThrowError();
+			},
+		);
+
+		test.concurrent('select count()', async ({ db }) => {
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+			expect(res).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('select for ...', ({ db }) => {
+			{
+				const query = db.select().from(users2Table).for('update').toSQL();
+				expect(query.sql).toMatch(/ for update$/);
+			}
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('share', { skipLocked: true })
+					.toSQL();
+				expect(query.sql).toMatch(/ for share skip locked$/);
+			}
+			{
+				const query = db
+					.select()
+					.from(users2Table)
+					.for('update', { noWait: true })
+					.toSQL();
+				expect(query.sql).toMatch(/ for update nowait$/);
+			}
+		});
+
+		test.concurrent('having', async ({ db }) => {
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'London' },
+				{ id: 2, name: 'Paris' },
+				{
+					id: 3,
+					name: 'New York',
+				},
+			]);
+
+			await db.insert(users2Table).values([
+				{ id: 1, name: 'John', cityId: 1 },
+				{ id: 2, name: 'Jane', cityId: 1 },
+				{
+					id: 3,
+					name: 'Jack',
+					cityId: 2,
+				},
+			]);
+
+			const result = await db
+				.select({
+					id: citiesTable.id,
+					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+					usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+				})
+				.from(citiesTable)
+				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+				.where(({ name }) => sql`length(${name}) >= 3`)
+				.groupBy(citiesTable.id)
+				.having(({ usersCount }) => sql`${usersCount} > 0`)
+				.orderBy(({ name }) => name);
+
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'LONDON',
+					usersCount: 2,
+				},
+				{
+					id: 2,
+					name: 'PARIS',
+					usersCount: 1,
+				},
+			]);
+		});
+
+		// TODO: Unskip when views are supported
+		/* test.skip('view', async ({ db }) => {
+
+
+            const newYorkers1 = singlestoreView('new_yorkers')
+                .as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+            const newYorkers2 = singlestoreView('new_yorkers', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            }).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+            const newYorkers3 = singlestoreView('new_yorkers', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            }).existing();
+
+            await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+            await db.insert(citiesTable).values([{ id: 1, name: 'New York' }, { id: 2, name: 'Paris' }]);
+
+            await db.insert(users2Table).values([
+                { id: 1, name: 'John', cityId: 1 },
+                { id: 2, name: 'Jane', cityId: 1 },
+                { id: 3, name: 'Jack', cityId: 2 },
+            ]);
+
+            {
+                const result = await db.select().from(newYorkers1).orderBy(asc(newYorkers1.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select().from(newYorkers2).orderBy(asc(newYorkers2.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select().from(newYorkers3).orderBy(asc(newYorkers3.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).orderBy(asc(newYorkers1.id));
+                expect(result).toEqual([
+                    { name: 'John' },
+                    { name: 'Jane' },
+                ]);
+            }
+
+            await db.execute(sql`drop view ${newYorkers1}`);
+        }); */
+
+		test.concurrent('select from raw sql', async ({ db }) => {
+			const result = await db
+				.select({
+					id: sql<number>`id`,
+					name: sql<string>`name`,
+				})
+				.from(sql`(select 1 as id, 'John' as name) as users`);
+
+			Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+		});
+
+		test.concurrent('select from raw sql with joins', async ({ db }) => {
+			const result = await db
+				.select({
+					id: sql<number>`users.id`,
+					name: sql<string>`users.name`,
+					userCity: sql<string>`users.city`,
+					cityName: sql<string>`cities.name`,
+				})
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
+				.leftJoin(
+					sql`(select 1 as id, 'Paris' as name) as cities`,
+					sql`cities.id = users.id`,
+				);
+
+			Expect<
+				Equal<
+					{ id: number; name: string; userCity: string; cityName: string }[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+			]);
+		});
+
+		test.concurrent('join on aliased sql from select', async ({ db }) => {
+			const result = await db
+				.select({
+					userId: sql<number>`users.id`.as('userId'),
+					name: sql<string>`users.name`,
+					userCity: sql<string>`users.city`,
+					cityId: sql<number>`cities.id`.as('cityId'),
+					cityName: sql<string>`cities.name`,
+				})
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
+				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+			Expect<
+				Equal<
+					{
+						userId: number;
+						name: string;
+						userCity: string;
+						cityId: number;
+						cityName: string;
+					}[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{
+					userId: 1,
+					name: 'John',
+					userCity: 'New York',
+					cityId: 1,
+					cityName: 'Paris',
+				},
+			]);
+		});
+
+		test.concurrent('join on aliased sql from with clause', async ({ db }) => {
+			const users = db.$with('users').as(
+				db
+					.select({
+						id: sql<number>`id`.as('userId'),
+						name: sql<string>`name`.as('userName'),
+						city: sql<string>`city`.as('city'),
+					})
+					.from(
+						sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+					),
+			);
+
+			const cities = db.$with('cities').as(
+				db
+					.select({
+						id: sql<number>`id`.as('cityId'),
+						name: sql<string>`name`.as('cityName'),
+					})
+					.from(sql`(select 1 as id, 'Paris' as name) as cities`),
+			);
+
+			const result = await db
+				.with(users, cities)
+				.select({
+					userId: users.id,
+					name: users.name,
+					userCity: users.city,
+					cityId: cities.id,
+					cityName: cities.name,
+				})
+				.from(users)
+				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+			Expect<
+				Equal<
+					{
+						userId: number;
+						name: string;
+						userCity: string;
+						cityId: number;
+						cityName: string;
+					}[],
+					typeof result
+				>
+			>;
+
+			expect(result).toEqual([
+				{
+					userId: 1,
+					name: 'John',
+					userCity: 'New York',
+					cityId: 1,
+					cityName: 'Paris',
+				},
+			]);
+		});
+
+		test.concurrent('prefixed table', async ({ db }) => {
+			const singlestoreTable = singlestoreTableCreator(
+				(name) => `myprefix_${name}`,
+			);
+
+			const users = singlestoreTable('test_prefixed_table_with_unique_name', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
+			);
+
+			await db.insert(users).values({ id: 1, name: 'John' });
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('orderBy with aliased column', ({ db }) => {
+			const query = db
+				.select({
+					test: sql`something`.as('test'),
+				})
+				.from(users2Table)
+				.orderBy((fields) => fields.test)
+				.toSQL();
+
+			expect(query.sql).toBe(
+				'select something as `test` from `users2` order by `test`',
+			);
+		});
+
+		test.concurrent('timestamp timezone', async ({ db }) => {
+			const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+			await db.insert(usersTable).values({ id: 1, name: 'With default times' });
+			await db.insert(usersTable).values({
+				id: 2,
+				name: 'Without default times',
+				createdAt: date,
+			});
+			const users = await db
+				.select()
+				.from(usersTable)
+				.orderBy(asc(usersTable.id));
+
+			// check that the timestamps are set correctly for default times
+			expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(
+				5000,
+			);
+
+			// check that the timestamps are set correctly for non default times
+			expect(
+				Math.abs(users[1]!.createdAt.getTime() - date.getTime()),
+			).toBeLessThan(2000);
+		});
+
+		test.concurrent('transaction', async ({ db }) => {
+			const users = singlestoreTable('users_transactions', {
+				id: serial('id').primaryKey(),
+				balance: int('balance').notNull(),
+			});
+			const products = singlestoreTable('products_transactions', {
+				id: serial('id').primaryKey(),
+				price: int('price').notNull(),
+				stock: int('stock').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(sql`drop table if exists ${products}`);
+
+			await db.execute(
+				sql`create table users_transactions (id serial not null primary key, balance int not null)`,
+			);
+			await db.execute(
+				sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
+			);
+
+			const [{ insertId: userId }] = await db
+				.insert(users)
+				.values({ id: 1, balance: 100 });
+			const user = await db
+				.select()
+				.from(users)
+				.where(eq(users.id, userId))
+				.then((rows) => rows[0]!);
+			const [{ insertId: productId }] = await db
+				.insert(products)
+				.values({ id: 1, price: 10, stock: 10 });
+			const product = await db
+				.select()
+				.from(products)
+				.where(eq(products.id, productId))
+				.then((rows) => rows[0]!);
+
+			await db.transaction(async (tx) => {
+				await tx
+					.update(users)
+					.set({ balance: user.balance - product.price })
+					.where(eq(users.id, user.id));
+				await tx
+					.update(products)
+					.set({ stock: product.stock - 1 })
+					.where(eq(products.id, product.id));
+			});
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([{ id: 1, balance: 90 }]);
+
+			await db.execute(sql`drop table ${users}`);
+			await db.execute(sql`drop table ${products}`);
+		});
+
+		test.concurrent('transaction rollback', async ({ db }) => {
+			const users = singlestoreTable('users_transactions_rollback', {
+				id: serial('id').primaryKey(),
+				balance: int('balance').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table users_transactions_rollback (id serial not null primary key, balance int not null)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.transaction(async (tx) => {
+						await tx.insert(users).values({ balance: 100 });
+						tx.rollback();
+					});
+				})(),
+			).rejects.toThrowError(TransactionRollbackError);
+
+			const result = await db.select().from(users);
+
+			expect(result).toEqual([]);
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('join subquery with join', async ({ db }) => {
+			const internalStaff = singlestoreTable('internal_staff', {
+				userId: int('user_id').notNull(),
+			});
+
+			const customUser = singlestoreTable('custom_user', {
+				id: int('id').notNull(),
+			});
+
+			const ticket = singlestoreTable('ticket', {
+				staffId: int('staff_id').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${internalStaff}`);
+			await db.execute(sql`drop table if exists ${customUser}`);
+			await db.execute(sql`drop table if exists ${ticket}`);
+
+			await db.execute(
+				sql`create table internal_staff (user_id integer not null)`,
+			);
+			await db.execute(sql`create table custom_user (id integer not null)`);
+			await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+			await db.insert(internalStaff).values({ userId: 1 });
+			await db.insert(customUser).values({ id: 1 });
+			await db.insert(ticket).values({ staffId: 1 });
+
+			const subq = db
+				.select()
+				.from(internalStaff)
+				.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+				.as('internal_staff');
+
+			const mainQuery = await db
+				.select()
+				.from(ticket)
+				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+			expect(mainQuery).toEqual([
+				{
+					ticket: { staffId: 1 },
+					internal_staff: {
+						internal_staff: { userId: 1 },
+						custom_user: { id: 1 },
+					},
+				},
+			]);
+
+			await db.execute(sql`drop table ${internalStaff}`);
+			await db.execute(sql`drop table ${customUser}`);
+			await db.execute(sql`drop table ${ticket}`);
+		});
+
+		// TODO: Unskip when views are supported
+		/* test.skip('subquery with view', async ({ db }) => {
+
+
+            const users = singlestoreTable('users_subquery_view', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            });
+
+            const newYorkers = singlestoreView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+            await db.execute(sql`drop table if exists ${users}`);
+            await db.execute(sql`drop view if exists ${newYorkers}`);
+
+            await db.execute(
+                sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+            );
+            await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+            await db.insert(users).values([
+                { id: 1, name: 'John', cityId: 1 },
+                { id: 2, name: 'Jane', cityId: 2 },
+                { id: 3, name: 'Jack', cityId: 1 },
+                { id: 4, name: 'Jill', cityId: 2 },
+            ]);
+
+            const sq = db.$with('sq').as(db.select().from(newYorkers));
+            const result = await db.with(sq).select().from(sq).orderBy(asc(sq.id));
+
+            expect(result).toEqual([
+                { id: 1, name: 'John', cityId: 1 },
+                { id: 3, name: 'Jack', cityId: 1 },
+            ]);
+
+            await db.execute(sql`drop view ${newYorkers}`);
+            await db.execute(sql`drop table ${users}`);
+        }); */
+
+		// TODO: Unskip when views are supported
+		/* test.skip('join view as subquery', async ({ db }) => {
+
+
+            const users = singlestoreTable('users_join_view', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            });
+
+            const newYorkers = singlestoreView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+            await db.execute(sql`drop table if exists ${users}`);
+            await db.execute(sql`drop view if exists ${newYorkers}`);
+
+            await db.execute(
+                sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+            );
+            await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+            await db.insert(users).values([
+                { id: 1, name: 'John', cityId: 1 },
+                { id: 2, name: 'Jane', cityId: 2 },
+                { id: 3, name: 'Jack', cityId: 1 },
+                { id: 4, name: 'Jill', cityId: 2 },
+            ]);
+
+            const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+            const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id)).orderBy(asc(users.id));
+
+            expect(result).toEqual([
+                {
+                    users_join_view: { id: 1, name: 'John', cityId: 1 },
+                    new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+                },
+                {
+                    users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+                    new_yorkers_sq: null,
+                },
+                {
+                    users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+                    new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+                },
+                {
+                    users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+                    new_yorkers_sq: null,
+                },
+            ]);
+
+            await db.execute(sql`drop view ${newYorkers}`);
+            await db.execute(sql`drop table ${users}`);
+        }); */
+
+		test.concurrent('select iterator', async ({ db }) => {
+			const users = singlestoreTable('users_iterator', {
+				id: serial('id').primaryKey(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id serial not null primary key)`,
+			);
+
+			await db.insert(users).values([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+			const iter = db.select().from(users).orderBy(asc(users.id)).iterator();
+
+			const result: (typeof users.$inferSelect)[] = [];
+
+			for await (const row of iter) {
+				result.push(row);
+			}
+
+			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+		});
+
+		test.concurrent('select iterator w/ prepared statement', async ({ db }) => {
+			const users = singlestoreTable('users_iterator', {
+				id: serial('id').primaryKey(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id serial not null primary key)`,
+			);
+
+			await db.insert(users).values([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+			const prepared = db.select().from(users).orderBy(asc(users.id)).prepare();
+			const iter = prepared.iterator();
+			const result: (typeof users.$inferSelect)[] = [];
+
+			for await (const row of iter) {
+				result.push(row);
+			}
+
+			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
+		});
+
+		test.concurrent('insert undefined', async ({ db }) => {
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id serial not null primary key, name text)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.insert(users).values({ name: undefined });
+				})(),
+			).resolves.not.toThrowError();
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('update undefined', async ({ db }) => {
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name'),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+
+			await db.execute(
+				sql`create table ${users} (id serial not null primary key, name text)`,
+			);
+
+			await expect(
+				(async () => {
+					await db.update(users).set({ name: undefined });
+				})(),
+			).rejects.toThrowError();
+
+			await expect(
+				(async () => {
+					await db.update(users).set({ id: 1, name: undefined });
+				})(),
+			).resolves.not.toThrowError();
+
+			await db.execute(sql`drop table ${users}`);
+		});
+
+		test.concurrent('update with placeholder', async ({ db }) => {
+			const users = singlestoreTable('userstest_update_p', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				verified: boolean('verified').notNull().default(false),
+			});
+
+			await db.execute(sql`drop table if exists ${users};`);
+			await db.execute(sql`create table ${users} (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`verified\` boolean not null default false
+			);`);
+
+			await db.insert(users).values([
+				{ name: 'Barry', verified: false },
+				{ name: 'Alan', verified: false },
+				{ name: 'Carl', verified: false },
+			]);
+
+			await db
+				.update(users)
+				.set({ verified: sql.placeholder('verified') })
+				.execute({
+					verified: true,
+				});
+
+			const result = await db
+				.select({ name: users.name, verified: users.verified })
+				.from(users)
+				.orderBy(asc(users.name));
+			expect(result).toStrictEqual([
+				{ name: 'Alan', verified: true },
+				{ name: 'Barry', verified: true },
+				{ name: 'Carl', verified: true },
+			]);
+		});
+
+		test.concurrent('utc config for datetime', async ({ db }) => {
+			await db.execute(sql`drop table if exists \`datestable\``);
+			await db.execute(
+				sql`
+                    create table \`datestable\` (
+                        \`datetime_utc\` datetime(6),
+                        \`datetime\` datetime(6)
+                    )
+                `,
+			);
+			const datesTable = singlestoreTable('datestable', {
+				datetimeUTC: datetime('datetime_utc', { mode: 'date' }),
+				datetime: datetime('datetime'),
+			});
+
+			const dateObj = new Date('2022-11-11');
+			const dateUtc = new Date('2022-11-11T12:12:12.122Z');
+
+			await db.insert(datesTable).values({
+				datetimeUTC: dateUtc,
+				datetime: dateObj,
+			});
+
+			const res = await db.select().from(datesTable);
+
+			const [rawSelect] = await db.execute(
+				sql`select \`datetime_utc\` from \`datestable\``,
+			);
+			const selectedRow = (
+				rawSelect as unknown as [{ datetime_utc: string }]
+			)[0];
+
+			expect(selectedRow.datetime_utc).toBe('2022-11-11 12:12:12.122000');
+			expect(
+				new Date(selectedRow.datetime_utc.replace(' ', 'T') + 'Z'),
+			).toEqual(dateUtc);
+
+			expect(res[0]?.datetime).toBeInstanceOf(Date);
+			expect(res[0]?.datetimeUTC).toBeInstanceOf(Date);
+
+			expect(res).toEqual([
+				{
+					datetimeUTC: dateUtc,
+					datetime: new Date('2022-11-11'),
+				},
+			]);
+
+			await db.execute(sql`drop table if exists \`datestable\``);
+		});
+
+		// TODO (https://memsql.atlassian.net/browse/MCDB-63261) allow chaining limit and orderby in subquery
+		test.concurrent(
+			'set operations (union) from query builder with subquery',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+				const citiesQuery = db
+					.select({
+						id: citiesTable.id,
+						name: citiesTable.name,
+						orderCol: sql`0`.as('orderCol'),
+					})
+					.from(citiesTable);
+
+				const usersQuery = db
+					.select({
+						id: users2Table.id,
+						name: users2Table.name,
+						orderCol: sql`1`.as('orderCol'),
+					})
+					.from(users2Table);
+
+				const unionQuery = db
+					.select({
+						id: sql`id`,
+						name: sql`name`,
+					})
+					.from(citiesQuery.union(usersQuery).as('combined'))
+					.orderBy(sql`orderCol`, sql`id`)
+					.limit(8);
+
+				const result = await unionQuery;
+
+				expect(result).toHaveLength(8);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'Jane' },
+					{ id: 3, name: 'Jack' },
+					{ id: 4, name: 'Peter' },
+					{ id: 5, name: 'Ben' },
+				]);
+
+				// union should throw if selected fields are not in the same order
+				await expect(
+					(async () => {
+						db.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.union(
+								db
+									.select({ name: users2Table.name, id: users2Table.id })
+									.from(users2Table),
+							);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent('set operations (union) as function', async ({ db }) => {
+			await setupSetOperationTest(db);
+
+			const result = await union(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			);
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 1, name: 'New York' },
+				{ id: 1, name: 'John' },
+			]);
+
+			await expect(
+				(async () => {
+					union(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test.concurrent(
+			'set operations (union all) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const sq = db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.orderBy(asc(sql`id`))
+					.limit(2)
+					.unionAll(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.orderBy(asc(sql`id`))
+							.limit(2),
+					)
+					.as('sq');
+
+				const result = await db
+					.select()
+					.from(sq)
+					.orderBy(asc(sql`id`))
+					.limit(3);
+
+				expect(result).toHaveLength(3);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+				]);
+
+				await expect(
+					(async () => {
+						db.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.limit(2)
+							.unionAll(
+								db
+									.select({ name: citiesTable.name, id: citiesTable.id })
+									.from(citiesTable)
+									.limit(2),
+							)
+							.orderBy(asc(sql`id`));
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (union all) as function',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const sq = unionAll(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+				).as('sq');
+
+				const result = await db.select().from(sq).limit(1);
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+				await expect(
+					(async () => {
+						unionAll(
+							db
+								.select({ id: citiesTable.id, name: citiesTable.name })
+								.from(citiesTable)
+								.where(eq(citiesTable.id, 1)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+						).limit(1);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (intersect) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const sq = db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.intersect(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.where(gt(citiesTable.id, 1)),
+					)
+					.as('sq');
+
+				const result = await db
+					.select()
+					.from(sq)
+					.orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(2);
+
+				expect(result).toEqual([
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				await expect(
+					(async () => {
+						db.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable)
+							.intersect(
+								db
+									.select({ id: citiesTable.id, name: citiesTable.name })
+									.from(citiesTable)
+									.where(gt(citiesTable.id, 1)),
+							);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (intersect) as function',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const sq = await intersect(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+				).as('sq');
+
+				const result = await db.select().from(sq).limit(1);
+
+				expect(result).toHaveLength(0);
+
+				expect(result).toEqual([]);
+
+				await expect(
+					(async () => {
+						intersect(
+							db
+								.select({ id: citiesTable.id, name: citiesTable.name })
+								.from(citiesTable)
+								.where(eq(citiesTable.id, 1)),
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+						).limit(1);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (except) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const result = await db
+					.select()
+					.from(citiesTable)
+					.except(db.select().from(citiesTable).where(gt(citiesTable.id, 1)));
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([{ id: 1, name: 'New York' }]);
+			},
+		);
+
+		test.concurrent('set operations (except) as function', async ({ db }) => {
+			await setupSetOperationTest(db);
+
+			const sq = except(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable),
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
+			).as('sq');
+
+			const result = await db.select().from(sq).limit(3);
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toContainEqual({ id: 2, name: 'London' });
+			expect(result).toContainEqual({ id: 3, name: 'Tampa' });
+
+			await expect(
+				(async () => {
+					except(
+						db
+							.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable),
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					).limit(3);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test.concurrent('define constraints as array', async ({ db }) => {
+			const table = singlestoreTable(
+				'name',
+				{
+					id: int(),
+				},
+				(t) => [
+					index('name').on(t.id),
+					primaryKey({ columns: [t.id], name: 'custom' }),
+				],
+			);
+
+			const { indexes, primaryKeys } = getTableConfig(table);
+
+			expect(indexes.length).toBe(1);
+			expect(primaryKeys.length).toBe(1);
+		});
+
+		test.concurrent(
+			'define constraints as array inside third param',
+			async ({ db }) => {
+				const table = singlestoreTable(
+					'name',
+					{
+						id: int(),
+					},
+					(t) => [
+						[
+							index('name').on(t.id),
+							primaryKey({ columns: [t.id], name: 'custom' }),
+						],
+					],
+				);
+
+				const { indexes, primaryKeys } = getTableConfig(table);
+
+				expect(indexes.length).toBe(1);
+				expect(primaryKeys.length).toBe(1);
+			},
+		);
+
+		test.skip('set operations (mixed) from query builder', async ({ db }) => {
+			await setupSetOperationTest(db);
+
+			const sq1 = unionAll(
+				db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+				db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+			).as('sq1');
+
+			const sq2 = await db
+				.select()
+				.from(sq1)
+				.orderBy(asc(sql`id`))
+				.as('sq2');
+
+			const sq3 = await db.select().from(sq2).limit(1).offset(1).as('sq3');
+
+			const result = await db
+				.select()
+				.from(citiesTable)
+				.except(db.select().from(sq3));
+
+			expect(result).toHaveLength(2);
+
+			expect(result).toEqual([
+				{ id: 3, name: 'Tampa' },
+				{ id: 1, name: 'New York' },
+			]);
+
+			await expect(
+				(async () => {
+					db.select()
+						.from(citiesTable)
+						.except(({ unionAll }) =>
+							unionAll(
+								db
+									.select({ name: citiesTable.name, id: citiesTable.id })
+									.from(citiesTable)
+									.where(gt(citiesTable.id, 1)),
+								db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+							)
+						);
+				})(),
+			).rejects.toThrowError();
+		});
+
+		test.concurrent(
+			'set operations (mixed all) as function with subquery',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
+
+				const sq1 = except(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(gte(users2Table.id, 5)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 7)),
+				).as('sq1');
+
+				const sq2 = await db
+					.select()
+					.from(sq1)
+					.orderBy(asc(sql`id`))
+					.as('sq2');
+
+				const sq3 = await db.select().from(sq2).limit(1).as('sq3');
+
+				const result = await union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+					db.select().from(sq3),
+					db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+				);
+
+				expect(result).toHaveLength(4);
+
+				// multiple results possible as a result of the filters >= 5 and ==7 because singlestore doesn't guarantee order
+				// dynamically validate results
+				const hasValidEntry = (entry: { id: number; name: string }) => {
+					if (entry.id === 1) return entry.name === 'John';
+					if (entry.id > 1 && entry.id < 5) {
+						return entry.name === 'Tampa' || entry.name === 'London';
+					}
+					if (entry.id >= 5 && entry.id !== 7) return true; // Accept any entry with id >= 5 and not 7
+					return false;
+				};
+
+				for (const entry of result) {
+					expect(hasValidEntry(entry)).toBe(true);
+				}
+
+				await expect(
+					(async () => {
+						union(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(eq(users2Table.id, 1)),
+							except(
+								db
+									.select({ id: users2Table.id, name: users2Table.name })
+									.from(users2Table)
+									.where(gte(users2Table.id, 5)),
+								db
+									.select({ name: users2Table.name, id: users2Table.id })
+									.from(users2Table)
+									.where(eq(users2Table.id, 7)),
+							).limit(1),
+							db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+						);
+					})(),
+				).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent('aggregate function: count', async ({ db }) => {
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: count() }).from(table);
+			const result2 = await db.select({ value: count(table.a) }).from(table);
+			const result3 = await db
+				.select({ value: countDistinct(table.name) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(7);
+			expect(result2[0]?.value).toBe(5);
+			expect(result3[0]?.value).toBe(6);
+		});
+
+		test.concurrent('aggregate function: avg', async ({ db }) => {
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: avg(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: avg(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: avgDistinct(table.b) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe('33.3333');
+			expect(result2[0]?.value).toBe(null);
+			expect(result3[0]?.value).toBe('42.5000');
+		});
+
+		test.concurrent('aggregate function: sum', async ({ db }) => {
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: sum(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: sum(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: sumDistinct(table.b) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe('200');
+			expect(result2[0]?.value).toBe(null);
+			expect(result3[0]?.value).toBe('170');
+		});
+
+		test.concurrent('aggregate function: max', async ({ db }) => {
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: max(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: max(table.nullOnly) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(90);
+			expect(result2[0]?.value).toBe(null);
+		});
+
+		test.concurrent('aggregate function: min', async ({ db }) => {
+			const table = aggregateTable;
+			await setupAggregateFunctionsTest(db);
+
+			const result1 = await db.select({ value: min(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: min(table.nullOnly) })
+				.from(table);
+
+			expect(result1[0]?.value).toBe(10);
+			expect(result2[0]?.value).toBe(null);
+		});
+
+		test.concurrent('simple vector search', async ({ db }) => {
+			const table = vectorSearchTable;
+			const embedding = [
+				0.42,
+				0.93,
+				0.88,
+				0.57,
+				0.32,
+				0.64,
+				0.76,
+				0.52,
+				0.19,
+				0.81,
+			]; // ChatGPT's 10 dimension embedding for "dogs are cool" not sure how accurate but it works
+			await setupVectorSearchTest(db);
+
+			const withRankEuclidean = db
+				.select({
+					id: table.id,
+					text: table.text,
+					rank: sql`row_number() over (order by ${euclideanDistance(table.embedding, embedding)})`.as(
+						'rank',
+					),
+				})
+				.from(table)
+				.as('with_rank');
+			const withRankDotProduct = db
+				.select({
+					id: table.id,
+					text: table.text,
+					rank: sql`row_number() over (order by ${dotProduct(table.embedding, embedding)})`.as(
+						'rank',
+					),
+				})
+				.from(table)
+				.as('with_rank');
+			const result1 = await db
+				.select({ id: withRankEuclidean.id, text: withRankEuclidean.text })
+				.from(withRankEuclidean)
+				.where(eq(withRankEuclidean.rank, 1));
+			const result2 = await db
+				.select({ id: withRankDotProduct.id, text: withRankDotProduct.text })
+				.from(withRankDotProduct)
+				.where(eq(withRankDotProduct.rank, 1));
+
+			expect(result1.length).toEqual(1);
+			expect(result1[0]).toEqual({ id: 1, text: 'I like dogs' });
+
+			expect(result2.length).toEqual(1);
+			expect(result2[0]).toEqual({ id: 1, text: 'I like dogs' });
+		});
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works as $default',
+			async ({ db }) => {
+				await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+				await db.execute(
+					sql`
+                    create table ${usersOnUpdate} (
+                    id serial not null primary key,
+                    name text not null,
+                    update_counter integer default 1 not null,
+                    updated_at datetime(6),
+                    always_null text
+                    )
+                `,
+				);
+
+				await db.insert(usersOnUpdate).values([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'Jane' },
+					{ id: 3, name: 'Jack' },
+					{ id: 4, name: 'Jill' },
+				]);
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+				const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
+
+				const response = await db
+					.select({ ...rest })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+				]);
+				const msDelay = 5000;
+
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works updating',
+			async ({ db }) => {
+				await db.execute(sql`drop table if exists ${usersOnUpdate}`);
+
+				await db.execute(
+					sql`
+                    create table ${usersOnUpdate} (
+                    id serial not null primary key,
+                    name text not null,
+                    update_counter integer default 1 not null,
+                    updated_at datetime(6),
+                    always_null text
+                    )
+                `,
+				);
+
+				await db.insert(usersOnUpdate).values([
+					{
+						id: 1,
+						name: 'John',
+						alwaysNull: 'this will will be null after updating',
+					},
+					{ id: 2, name: 'Jane' },
+					{ id: 3, name: 'Jack' },
+					{ id: 4, name: 'Jill' },
+				]);
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+				const initial = await db
+					.select({ id: usersOnUpdate.id, updatedAt: usersOnUpdate.updatedAt })
+					.from(usersOnUpdate);
+
+				await db
+					.update(usersOnUpdate)
+					.set({ name: 'Angel' })
+					.where(eq(usersOnUpdate.id, 1));
+
+				const justDates = await db
+					.select({ id: usersOnUpdate.id, updatedAt: usersOnUpdate.updatedAt })
+					.from(usersOnUpdate);
+
+				const response = await db
+					.select()
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{
+						id: 1,
+						name: 'Angel',
+						updateCounter: 2,
+						updatedAt: expect.any(Date),
+						alwaysNull: null,
+					},
+					{
+						id: 2,
+						name: 'Jane',
+						updateCounter: 1,
+						updatedAt: expect.any(Date),
+						alwaysNull: null,
+					},
+					{
+						id: 3,
+						name: 'Jack',
+						updateCounter: 1,
+						updatedAt: expect.any(Date),
+						alwaysNull: null,
+					},
+					{
+						id: 4,
+						name: 'Jill',
+						updateCounter: 1,
+						updatedAt: expect.any(Date),
+						alwaysNull: null,
+					},
+				]);
+
+				const initialRecord = initial.find((record) => record.id === 1);
+				const updatedRecord = justDates.find((record) => record.id === 1);
+
+				expect(initialRecord?.updatedAt?.valueOf()).not.toBe(
+					updatedRecord?.updatedAt?.valueOf(),
+				);
+
+				const msDelay = 5000;
+
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
+
+		// mySchema tests
+		test.concurrent('mySchema :: select all fields', async ({ db }) => {
+			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+
+			expect(result[0]!.createdAt).toBeInstanceOf(Date);
+			// not timezone based timestamp, thats why it should not work here
+			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+		});
+
+		test.concurrent('mySchema :: select sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.select({
+					name: sql`upper(${usersMySchemaTable.name})`,
+				})
+				.from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('mySchema :: select typed sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.select({
+					name: sql<string>`upper(${usersMySchemaTable.name})`,
+				})
+				.from(usersMySchemaTable);
+
+			expect(users).toEqual([{ name: 'JOHN' }]);
+		});
+
+		test.concurrent('mySchema :: select distinct', async ({ db }) => {
+			const usersDistinctTable = singlestoreTable('users_distinct', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+			await db.execute(
+				sql`create table ${usersDistinctTable} (id int, name text)`,
+			);
+
+			await db.insert(usersDistinctTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+				{ id: 1, name: 'Jane' },
+			]);
+			const users = await db
+				.selectDistinct()
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.name);
+
+			await db.execute(sql`drop table ${usersDistinctTable}`);
+
+			expect(users).toEqual([
+				{ id: 1, name: 'Jane' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+			]);
+		});
+
+		test.concurrent('mySchema :: insert returning sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			const [result, _] = await db
+				.insert(usersMySchemaTable)
+				.values({ id: 1, name: 'John' });
+
+			expect(result.insertId).toBe(1);
+		});
+
+		test.concurrent('mySchema :: delete returning sql', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ name: 'John' });
+			const users = await db
+				.delete(usersMySchemaTable)
+				.where(eq(usersMySchemaTable.name, 'John'));
+
+			expect(users[0].affectedRows).toBe(1);
+		});
+
+		test.concurrent(
+			'mySchema :: update with returning partial',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
+				const updatedUsers = await db
+					.update(usersMySchemaTable)
+					.set({ name: 'Jane' })
+					.where(eq(usersMySchemaTable.name, 'John'));
+
+				const users = await db
+					.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name })
+					.from(usersMySchemaTable)
+					.where(eq(usersMySchemaTable.id, 1));
+
+				expect(updatedUsers[0].changedRows).toBe(1);
+
+				expect(users).toEqual([{ id: 1, name: 'Jane' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: delete with returning all fields',
+			async ({ db }) => {
+				await db.insert(usersMySchemaTable).values({ name: 'John' });
+				const deletedUser = await db
+					.delete(usersMySchemaTable)
+					.where(eq(usersMySchemaTable.name, 'John'));
+
+				expect(deletedUser[0].affectedRows).toBe(1);
+			},
+		);
+
+		test.concurrent('mySchema :: insert + select', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
+			const result = await db.select().from(usersMySchemaTable);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
+
+			await db.insert(usersMySchemaTable).values({ id: 2, name: 'Jane' });
+			const result2 = await db
+				.select()
+				.from(usersMySchemaTable)
+				.orderBy(asc(usersMySchemaTable.id));
+			expect(result2).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[0]!.createdAt,
+				},
+				{
+					id: 2,
+					name: 'Jane',
+					verified: false,
+					jsonb: null,
+					createdAt: result2[1]!.createdAt,
+				},
+			]);
+		});
+
+		test.concurrent(
+			'mySchema :: insert with overridden default values',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db
+					.insert(usersMySchemaTable)
+					.values({ id: 1, name: 'John', verified: true });
+				const result = await db.select().from(usersMySchemaTable);
+
+				expect(result).toEqual([
+					{
+						id: 1,
+						name: 'John',
+						verified: true,
+						jsonb: null,
+						createdAt: result[0]!.createdAt,
+					},
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: insert many', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db.insert(usersMySchemaTable).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'] },
+				{ id: 3, name: 'Jane' },
+				{ id: 4, name: 'Austin', verified: true },
+			]);
+			const result = await db
+				.select({
+					id: usersMySchemaTable.id,
+					name: usersMySchemaTable.name,
+					jsonb: usersMySchemaTable.jsonb,
+					verified: usersMySchemaTable.verified,
+				})
+				.from(usersMySchemaTable)
+				.orderBy(asc(usersMySchemaTable.id));
+
+			expect(result).toEqual([
+				{ id: 1, name: 'John', jsonb: null, verified: false },
+				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', jsonb: null, verified: false },
+				{ id: 4, name: 'Austin', jsonb: null, verified: true },
+			]);
+		});
+
+		test.concurrent(
+			'mySchema :: select with group by as field',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db.insert(usersMySchemaTable).values([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'Jane' },
+					{
+						id: 3,
+						name: 'Jane',
+					},
+				]);
+
+				const result = await db
+					.select({ name: usersMySchemaTable.name })
+					.from(usersMySchemaTable)
+					.groupBy(usersMySchemaTable.name)
+					.orderBy(asc(usersMySchemaTable.id));
+
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: select with group by as column + sql',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db.insert(usersMySchemaTable).values([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'Jane' },
+					{
+						id: 3,
+						name: 'Jane',
+					},
+				]);
+
+				const result = await db
+					.select({ name: usersMySchemaTable.name })
+					.from(usersMySchemaTable)
+					.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`)
+					.orderBy(asc(usersMySchemaTable.id));
+
+				expect(result).toEqual([
+					{ name: 'John' },
+					{ name: 'Jane' },
+					{ name: 'Jane' },
+				]);
+			},
+		);
+
+		test.concurrent('mySchema :: build query', async ({ db }) => {
+			const query = db
+				.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name })
+				.from(usersMySchemaTable)
+				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
+				.toSQL();
+
+			expect(query).toEqual({
+				sql:
+					`select \`id\`, \`name\` from \`mySchema\`.\`userstest\` group by \`mySchema\`.\`userstest\`.\`id\`, \`mySchema\`.\`userstest\`.\`name\``,
+				params: [],
+			});
+		});
+
+		test.concurrent('mySchema :: insert with spaces', async ({ db }) => {
+			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+			await db
+				.insert(usersMySchemaTable)
+				.values({ id: 1, name: sql`'Jo   h     n'` });
+			const result = await db
+				.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name })
+				.from(usersMySchemaTable);
+
+			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
+		});
+
+		test.concurrent(
+			'mySchema :: prepared statement with placeholder in .where',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
+				const stmt = db
+					.select({
+						id: usersMySchemaTable.id,
+						name: usersMySchemaTable.name,
+					})
+					.from(usersMySchemaTable)
+					.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
+					.prepare();
+				const result = await stmt.execute({ id: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			},
+		);
+
+		test.concurrent(
+			'mySchema :: select from tables with same name from different schema using alias',
+			async ({ db }) => {
+				await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
+
+				await db.execute(sql`drop table if exists \`userstest\``);
+				await db.execute(
+					sql`
+                    create table \`userstest\` (
+                        \`id\` serial primary key,
+                        \`name\` text not null,
+                        \`verified\` boolean not null default false,
+                        \`jsonb\` json,
+                        \`created_at\` timestamp not null default now()
+                    )
+                `,
+				);
+
+				await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
+				await db.insert(usersTable).values({ id: 11, name: 'Hans' });
+
+				const customerAlias = alias(usersTable, 'customer');
+
+				const result = await db
+					.select()
+					.from(usersMySchemaTable)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(usersMySchemaTable.id, 10));
+
+				expect(result).toEqual([
+					{
+						userstest: {
+							id: 10,
+							name: 'Ivan',
+							verified: false,
+							jsonb: null,
+							createdAt: result[0]!.userstest.createdAt,
+						},
+						customer: {
+							id: 11,
+							name: 'Hans',
+							verified: false,
+							jsonb: null,
+							createdAt: result[0]!.customer!.createdAt,
+						},
+					},
+				]);
+			},
+		);
+
+		test.concurrent('insert $returningId: serial as id', async ({ db }) => {
+			const result = await db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.$returningId();
+
+			expectTypeOf(result).toEqualTypeOf<
+				{
+					id: number;
+				}[]
+			>();
+
+			expect(result).toStrictEqual([{ id: 1 }]);
+		});
+
+		test.concurrent(
+			'insert $returningId: serial as id, batch insert',
+			async ({ db }) => {
+				const result = await db
+					.insert(usersTable)
+					.values([
+						{ id: 1, name: 'John' },
+						{ id: 2, name: 'John1' },
+					])
+					.$returningId();
+
+				expectTypeOf(result).toEqualTypeOf<
+					{
+						id: number;
+					}[]
+				>();
+
+				// singlestore auto increments when batch inserting, so the ids increment by one
+				expect(result).toStrictEqual([{ id: 2 }, { id: 3 }]);
+			},
+		);
+
+		test.concurrent(
+			'insert $returningId: $default as primary key',
+			async ({ db }) => {
+				const uniqueKeys = [
+					'ao865jf3mcmkfkk8o5ri495z',
+					'dyqs529eom0iczo2efxzbcut',
+				];
+				let iterator = 0;
+
+				const usersTableDefFn = singlestoreTable('users_default_fn', {
+					customId: varchar('id', { length: 256 })
+						.primaryKey()
+						.$defaultFn(() => {
+							const value = uniqueKeys[iterator]!;
+							iterator++;
+							return value;
+						}),
+					name: text('name').notNull(),
+				});
+
+				await setupReturningFunctionsTest(db);
+
+				const result = await db
+					.insert(usersTableDefFn)
+					.values([{ name: 'John' }, { name: 'John1' }])
+					//    ^?
+					.$returningId();
+
+				expectTypeOf(result).toEqualTypeOf<
+					{
+						customId: string;
+					}[]
+				>();
+
+				expect(result).toStrictEqual([
+					{ customId: 'ao865jf3mcmkfkk8o5ri495z' },
+					{
+						customId: 'dyqs529eom0iczo2efxzbcut',
+					},
+				]);
+			},
+		);
+
+		test.concurrent(
+			'insert $returningId: $default as primary key with value',
+			async ({ db }) => {
+				const uniqueKeys = [
+					'ao865jf3mcmkfkk8o5ri495z',
+					'dyqs529eom0iczo2efxzbcut',
+				];
+				let iterator = 0;
+
+				const usersTableDefFn = singlestoreTable('users_default_fn', {
+					customId: varchar('id', { length: 256 })
+						.primaryKey()
+						.$defaultFn(() => {
+							const value = uniqueKeys[iterator]!;
+							iterator++;
+							return value;
+						}),
+					name: text('name').notNull(),
+				});
+
+				await setupReturningFunctionsTest(db);
+
+				const result = await db
+					.insert(usersTableDefFn)
+					.values([{ name: 'John', customId: 'test' }, { name: 'John1' }])
+					//    ^?
+					.$returningId();
+
+				expectTypeOf(result).toEqualTypeOf<
+					{
+						customId: string;
+					}[]
+				>();
+
+				expect(result).toStrictEqual([
+					{ customId: 'test' },
+					{ customId: 'ao865jf3mcmkfkk8o5ri495z' },
+				]);
+			},
+		);
+
+		// TODO: Unkip this test when views are supported
+		/* test.skip('mySchema :: view', async ({ db }) => {
+
+
+            const newYorkers1 = mySchema.view('new_yorkers')
+                .as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
+
+            const newYorkers2 = mySchema.view('new_yorkers', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            }).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
+
+            const newYorkers3 = mySchema.view('new_yorkers', {
+                id: serial('id').primaryKey(),
+                name: text('name').notNull(),
+                cityId: int('city_id').notNull(),
+            }).existing();
+
+            await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
+
+            await db.insert(citiesMySchemaTable).values([{ id: 1, name: 'New York' }, { id: 2, name: 'Paris' }]);
+
+            await db.insert(users2MySchemaTable).values([
+                { id: 1, name: 'John', cityId: 1 },
+                { id: 2, name: 'Jane', cityId: 1 },
+                { id: 3, name: 'Jack', cityId: 2 },
+            ]);
+
+            {
+                const result = await db.select().from(newYorkers1).orderBy(asc(newYorkers1.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select().from(newYorkers2).orderBy(asc(newYorkers2.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select().from(newYorkers3).orderBy(asc(newYorkers3.id));
+                expect(result).toEqual([
+                    { id: 1, name: 'John', cityId: 1 },
+                    { id: 2, name: 'Jane', cityId: 1 },
+                ]);
+            }
+
+            {
+                const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).orderBy(asc(newYorkers1.id));
+                expect(result).toEqual([
+                    { name: 'John' },
+                    { name: 'Jane' },
+                ]);
+            }
+
+            await db.execute(sql`drop view ${newYorkers1}`);
+        }); */
+
+		test.concurrent('limit 0', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(0);
+
+			expect(users).toEqual([]);
+		});
+
+		test.concurrent('limit -1', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(-1);
+
+			expect(users.length).toBeGreaterThan(0);
+		});
+
+		test.concurrent('sql operator as cte', async ({ db }) => {
+			const users = singlestoreTable('users', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await db.execute(sql`drop table if exists ${users}`);
+			await db.execute(
+				sql`create table ${users} (id serial not null primary key, name text not null)`,
+			);
+			await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			const sq1 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(sql`select * from ${users} where ${users.name} = 'John'`);
+			const result1 = await db.with(sq1).select().from(sq1);
+
+			const sq2 = db
+				.$with('sq', {
+					userId: users.id,
+					data: {
+						name: users.name,
+					},
+				})
+				.as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+			const result2 = await db.with(sq2).select().from(sq1);
+
+			expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
+			expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+		});
+
+		test.concurrent('sql.Aliased in cte', async ({ db, push }) => {
+			const users = singlestoreTable('users_109_sqla', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users });
+			await db.insert(users).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			const sq1 = db.$with('sq1').as((qb) =>
+				qb
+					.select({
+						aliased: sql`count(*)`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+			const sq2 = db.$with('sq2').as((qb) =>
+				qb
+					.select({
+						aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+
+			const result = await db
+				.with(sq1, sq2)
+				.select({
+					count: sq1.aliased,
+					sum: sq2.aliased,
+				})
+				.from(sq1)
+				.crossJoin(sq2);
+
+			expect(result).toEqual([{ count: 2, sum: 3 }]);
+
+			const result2 = await db
+				.with(sq1)
+				.select({
+					count: sq1.aliased,
+				})
+				.from(sq1)
+				.groupBy(sq1.aliased)
+				.orderBy(sq1.aliased);
+
+			expect(result2).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('cross join', async ({ db }) => {
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Seattle' }, { name: 'New York City' }]);
+
+			const result = await db
+				.select({
+					user: usersTable.name,
+					city: citiesTable.name,
+				})
+				.from(usersTable)
+				.crossJoin(citiesTable)
+				.orderBy(usersTable.name, citiesTable.name);
+
+			expect(result).toStrictEqual([
+				{ city: 'New York City', user: 'Jane' },
+				{ city: 'Seattle', user: 'Jane' },
+				{ city: 'New York City', user: 'John' },
+				{ city: 'Seattle', user: 'John' },
+			]);
+		});
+
+		test.concurrent('left join (lateral)', async ({ db }) => {
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.leftJoinLateral(sq, sql`true`)
+				.orderBy(citiesTable.id);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+				{ cityId: 2, cityName: 'London', userId: null, userName: null },
+			]);
+		});
+
+		test.concurrent('inner join (lateral)', async ({ db }) => {
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.innerJoinLateral(sq, sql`true`);
+
+			expect(res).toStrictEqual([
+				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
+			]);
+		});
+
+		test.concurrent('cross join (lateral)', async ({ db }) => {
+			await db.insert(citiesTable).values([
+				{ id: 1, name: 'Paris' },
+				{ id: 2, name: 'London' },
+			]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{
+					name: 'Patrick',
+					cityId: 2,
+				},
+			]);
+
+			const sq = db
+				.select({
+					userId: users2Table.id,
+					userName: users2Table.name,
+					cityId: users2Table.cityId,
+				})
+				.from(users2Table)
+				.where(eq(users2Table.cityId, citiesTable.id))
+				.as('sq');
+
+			const res = await db
+				.select({
+					cityId: citiesTable.id,
+					cityName: citiesTable.name,
+					userId: sq.userId,
+					userName: sq.userName,
+				})
+				.from(citiesTable)
+				.crossJoinLateral(sq)
+				.orderBy(sq.userId, citiesTable.id);
+
+			expect(res).toStrictEqual([
+				{
+					cityId: 1,
+					cityName: 'Paris',
+					userId: 1,
+					userName: 'John',
+				},
+				{
+					cityId: 2,
+					cityName: 'London',
+					userId: 2,
+					userName: 'Jane',
+				},
+				{
+					cityId: 2,
+					cityName: 'London',
+					userId: 3,
+					userName: 'Patrick',
+				},
+			]);
+		});
+
+		test.concurrent('column.as', async ({ db, push }) => {
+			const users = singlestoreTable('users_column_as', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int('city_id'),
+			});
+
+			const cities = singlestoreTable('cities_column_as', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ users, cities });
+
+			try {
+				await db.insert(cities).values([
+					{
+						id: 1,
+						name: 'Firstistan',
+					},
+					{
+						id: 2,
+						name: 'Secondaria',
+					},
+				]);
+
+				await db.insert(users).values([
+					{ id: 1, name: 'First', cityId: 1 },
+					{
+						id: 2,
+						name: 'Second',
+						cityId: 2,
+					},
+					{
+						id: 3,
+						name: 'Third',
+					},
+				]);
+
+				const joinSelectReturn = await db
+					.select({
+						userId: users.id.as('user_id'),
+						cityId: cities.id.as('city_id'),
+						userName: users.name.as('user_name'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.cityId));
+
+				expect(joinSelectReturn).toStrictEqual(
+					expect.arrayContaining([
+						{
+							userId: 1,
+							userName: 'First',
+							cityId: 1,
+							cityName: 'Firstistan',
+						},
+						{
+							userId: 2,
+							userName: 'Second',
+							cityId: 2,
+							cityName: 'Secondaria',
+						},
+						{
+							userId: 3,
+							userName: 'Third',
+							cityId: null,
+							cityName: null,
+						},
+					]),
+				);
+			} finally {
+				await db.execute(sql`DROP TABLE ${users}`).catch(() => null);
+				await db.execute(sql`DROP TABLE ${cities}`).catch(() => null);
+			}
+		});
+
+		test.concurrent('select from a many subquery', async ({ db, push }) => {
+			const users2Table = singlestoreTable('users_many_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int('city_id'),
+			});
+
+			const citiesTable = singlestoreTable('cities_many_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					population: db
+						.select({ count: count().as('count') })
+						.from(users2Table)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('population'),
+					name: citiesTable.name,
+				})
+				.from(citiesTable);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					population: number;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual(
+				expect.arrayContaining([
+					{
+						population: 1,
+						name: 'Paris',
+					},
+					{
+						population: 2,
+						name: 'London',
+					},
+				]),
+			);
+		});
+
+		test.concurrent('select from a one subquery', async ({ db, push }) => {
+			const users2Table = singlestoreTable('users_one_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: int('city_id'),
+			});
+
+			const citiesTable = singlestoreTable('cities_one_subquery', {
+				id: serial('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			await push({ citiesTable, users2Table });
+
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					cityName: db
+						.select({ name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('cityName'),
+					name: users2Table.name,
+				})
+				.from(users2Table);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					cityName: string;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual(
+				expect.arrayContaining([
+					{
+						cityName: 'Paris',
+						name: 'John',
+					},
+					{
+						cityName: 'London',
+						name: 'Jane',
+					},
+					{
+						cityName: 'London',
+						name: 'Jack',
+					},
+				]),
+			);
+		});
+
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works with sql value',
+			async ({ db, push }) => {
+				const users = singlestoreTable('users_on_update_sql', {
+					id: serial('id').primaryKey(),
+					name: text('name').notNull(),
+					updatedAt: timestamp('updated_at')
+						.notNull()
+						.$onUpdate(() => sql`current_timestamp`),
+				});
+
+				await push({ users });
+
+				await db.insert(users).values({
+					name: 'John',
+				});
+				const insertResp = await db
+					.select({ updatedAt: users.updatedAt })
+					.from(users);
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+
+				const now = Date.now();
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+				await db.update(users).set({
+					name: 'John',
+				});
+				const updateResp = await db
+					.select({ updatedAt: users.updatedAt })
+					.from(users);
+
+				expect(insertResp[0]?.updatedAt.getTime() ?? 0).lessThan(now);
+				expect(updateResp[0]?.updatedAt.getTime() ?? 0).greaterThan(now);
+			},
+		);
+
+		test.concurrent('placeholder + sql dates', async ({ db, push }) => {
+			const dateTable = singlestoreTable('dates_placeholder_test', (t) => ({
+				id: t.int('id').primaryKey().notNull(),
+				date: t.datetime('date', { mode: 'date' }).notNull(),
+				dateStr: t.datetime('date_str', { mode: 'string' }).notNull(),
+				timestamp: t.timestamp('timestamp', { mode: 'date' }).notNull(),
+				timestampStr: t
+					.timestamp('timestamp_str', { mode: 'string' })
+					.notNull(),
+			}));
+
+			await db.execute(sql`DROP TABLE IF EXISTS ${dateTable};`);
+			await push({ dateTable });
+
+			const date = new Date('2025-12-10T01:01:01.000Z');
+			const timestamp = new Date('2025-12-10T01:01:01.000Z');
+			const dateStr = date.toISOString().slice(0, -5).replace('T', ' ');
+			const timestampStr = timestamp
+				.toISOString()
+				.slice(0, -5)
+				.replace('T', ' ');
+
+			await db
+				.insert(dateTable)
+				.values([
+					{
+						id: 1,
+						date: date,
+						dateStr: dateStr,
+						timestamp: timestamp,
+						timestampStr: timestampStr,
+					},
+					{
+						id: 2,
+						date: sql.placeholder('dateAsDate'),
+						dateStr: sql.placeholder('dateStrAsDate'),
+						timestamp: sql.placeholder('timestampAsDate'),
+						timestampStr: sql.placeholder('timestampStrAsDate'),
+					},
+					{
+						id: 3,
+						date: sql.placeholder('dateAsString'),
+						dateStr: sql.placeholder('dateStrAsString'),
+						timestamp: sql.placeholder('timestampAsString'),
+						timestampStr: sql.placeholder('timestampStrAsString'),
+					},
+					{
+						id: 4,
+						date: sql`${dateStr}`,
+						dateStr: sql`${dateStr}`,
+						timestamp: sql`${timestampStr}`,
+						timestampStr: sql`${timestampStr}`,
+					},
+				])
+				.execute({
+					dateAsDate: date,
+					dateAsString: dateStr,
+					dateStrAsDate: date,
+					dateStrAsString: dateStr,
+					timestampAsDate: timestamp,
+					timestampAsString: timestampStr,
+					timestampStrAsDate: timestamp,
+					timestampStrAsString: timestampStr,
+				});
+
+			const initial = await db.select().from(dateTable).orderBy(dateTable.id);
+
+			await db.update(dateTable).set({
+				date: sql`${dateStr}`,
+				dateStr: sql`${dateStr}`,
+				timestamp: sql`${timestampStr}`,
+				timestampStr: sql`${timestampStr}`,
+			});
+
+			const updated = await db.select().from(dateTable).orderBy(dateTable.id);
+
+			expect(initial).toStrictEqual([
+				{
+					id: 1,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 2,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 3,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+				{
+					id: 4,
+					date,
+					dateStr,
+					timestamp,
+					timestampStr,
+				},
+			]);
+
+			expect(updated).toStrictEqual(initial);
+		});
+
+		test.concurrent('all types', async ({ db }) => {
+			await db.execute(sql`drop table if exists ${allTypesTable};`);
+			await db.execute(sql`
+                CREATE TABLE \`all_types\` (
+                        \`scol\` serial,
+                        \`bigint53\` bigint,
+                        \`bigint64\` bigint,
+                        \`bigint_string\` bigint,
+                        \`binary\` binary,
+                        \`boolean\` boolean,
+                        \`char\` char,
+                        \`date\` date,
+                        \`date_str\` date,
+                        \`datetime\` datetime,
+                        \`datetime_str\` datetime,
+                        \`decimal\` decimal,
+                        \`decimal_num\` decimal(30),
+                        \`decimal_big\` decimal(30),
+                        \`double\` double,
+                        \`float\` float,
+                        \`int\` int,
+                        \`json\` json,
+                        \`med_int\` mediumint,
+                        \`small_int\` smallint,
+                        \`real\` real,
+                        \`text\` text,
+                        \`time\` time,
+                        \`timestamp\` timestamp,
+                        \`timestamp_str\` timestamp,
+                        \`tiny_int\` tinyint,
+                        \`varbin\` varbinary(16),
+                        \`varchar\` varchar(255),
+                        \`year\` year,
+                        \`enum\` enum('enV1','enV2'),
+                        \`vec_i8\` vector(5, I8),
+                        \`vec_i16\` vector(5, I16),
+                        \`vec_i32\` vector(5, I32),
+                        \`vec_i64\` vector(5, I64),
+                        \`vec_f32\` vector(5, F32),
+                        \`vec_f64\` vector(5, F64),
+                        shard key(\`scol\`)
+                    );
+            `);
+
+			await db.insert(allTypesTable).values({
+				serial: 1,
+				bigint53: 9007199254740991,
+				bigint64: 5044565289845416380n,
+				bigintString: '5044565289845416380',
+				binary: '1',
+				boolean: true,
+				char: 'c',
+				date: new Date(1741743161623),
+				dateStr: new Date(1741743161623)
+					.toISOString()
+					.slice(0, 19)
+					.replace('T', ' '),
+				datetime: new Date(1741743161623),
+				datetimeStr: new Date(1741743161623)
+					.toISOString()
+					.slice(0, 19)
+					.replace('T', ' '),
+				decimal: '47521',
+				decimalNum: 9007199254740991,
+				decimalBig: 5044565289845416380n,
+				double: 15.35325689124218,
+				enum: 'enV1',
+				float: 1.048596,
+				real: 1.048596,
+				text: 'C4-',
+				int: 621,
+				json: {
+					str: 'strval',
+					arr: ['str', 10],
+				},
+				medInt: 560,
+				smallInt: 14,
+				time: '04:13:22',
+				timestamp: new Date(1741743161623),
+				timestampStr: new Date(1741743161623)
+					.toISOString()
+					.slice(0, 19)
+					.replace('T', ' '),
+				tinyInt: 7,
+				varbin: '1010110101001101',
+				varchar: 'VCHAR',
+				year: 2025,
+				vectorF32: [0.735482, -0.291647, 1.183529, -2.406378, 0.014263],
+				vectorF64: [
+					0.3918573842719283,
+					-1.682530118745203,
+					2.014963587205109,
+					-0.005832741903218165,
+					0.7841029456712038,
+				],
+				vectorI8: [-2, 8, 127, 85, -128],
+				vectorI16: [-2, 8, 127, 85, -128],
+				vectorI32: [15342, -27894, 6271, -10385, 31056],
+				vectorI64: [
+					4829301283746501823n,
+					-7203847501293847201n,
+					1623847561928374650n,
+					-5938475628374651983n,
+					803745610293847561n,
+				],
+			});
+
+			const rawRes = await db.select().from(allTypesTable);
+
+			type ExpectedType = {
+				serial: number;
+				bigint53: number | null;
+				bigint64: bigint | null;
+				bigintString: string | null;
+				binary: string | null;
+				boolean: boolean | null;
+				char: string | null;
+				date: Date | null;
+				dateStr: string | null;
+				datetime: Date | null;
+				datetimeStr: string | null;
+				decimal: string | null;
+				decimalNum: number | null;
+				decimalBig: bigint | null;
+				double: number | null;
+				float: number | null;
+				int: number | null;
+				json: unknown;
+				medInt: number | null;
+				smallInt: number | null;
+				real: number | null;
+				text: string | null;
+				time: string | null;
+				timestamp: Date | null;
+				timestampStr: string | null;
+				tinyInt: number | null;
+				varbin: string | null;
+				varchar: string | null;
+				year: number | null;
+				enum: 'enV1' | 'enV2' | null;
+				vectorI8: number[] | null;
+				vectorI16: number[] | null;
+				vectorI32: number[] | null;
+				vectorI64: bigint[] | null;
+				vectorF32: number[] | null;
+				vectorF64: number[] | null;
+			}[];
+
+			const expectedRes: ExpectedType = [
+				{
+					serial: 1,
+					bigint53: 9007199254740991,
+					bigint64: 5044565289845416380n,
+					bigintString: '5044565289845416380',
+					binary: '1',
+					boolean: true,
+					char: 'c',
+					date: new Date('2025-03-12T00:00:00.000Z'),
+					dateStr: '2025-03-12',
+					datetime: new Date('2025-03-12T01:32:41.000Z'),
+					datetimeStr: '2025-03-12 01:32:41',
+					decimal: '47521',
+					decimalNum: 9007199254740991,
+					decimalBig: 5044565289845416380n,
+					double: 15.35325689124218,
+					float: 1.0486,
+					int: 621,
+					json: { arr: ['str', 10], str: 'strval' },
+					medInt: 560,
+					smallInt: 14,
+					real: 1.048596,
+					text: 'C4-',
+					time: '04:13:22',
+					timestamp: new Date('2025-03-12T01:32:41.000Z'),
+					timestampStr: '2025-03-12 01:32:41',
+					tinyInt: 7,
+					varbin: '1010110101001101',
+					varchar: 'VCHAR',
+					year: 2025,
+					enum: 'enV1',
+					vectorF32: [
+						...new Float32Array([
+							0.735482,
+							-0.291647,
+							1.183529,
+							-2.406378,
+							0.014263,
+						]),
+					],
+					vectorF64: [
+						0.3918573842719283,
+						-1.682530118745203,
+						2.014963587205109,
+						-0.005832741903218165,
+						0.7841029456712038,
+					],
+					vectorI8: [-2, 8, 127, 85, -128],
+					vectorI16: [-2, 8, 127, 85, -128],
+					vectorI32: [15342, -27894, 6271, -10385, 31056],
+					vectorI64: [
+						4829301283746501823n,
+						-7203847501293847201n,
+						1623847561928374650n,
+						-5938475628374651983n,
+						803745610293847561n,
+					],
+				},
+			];
+
+			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+			expect(rawRes).toStrictEqual(expectedRes);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4878
+		test.concurrent('.where with isNull in it', async ({ db, push }) => {
+			const table = singlestoreTable('table_where_is_null', {
+				col1: boolean(),
+				col2: text(),
+			});
+
+			await push({ table });
+			await db
+				.insert(table)
+				.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+			const query = db
+				.select()
+				.from(table)
+				.where(eq(table.col1, isNull(table.col2)));
+			expect(query.toSQL()).toStrictEqual({
+				sql:
+					'select `col1`, `col2` from `table_where_is_null` where `table_where_is_null`.`col1` = (`table_where_is_null`.`col2` is null)',
+				params: [],
+			});
+			const res = await query;
+
+			expect(res.length).toBe(2);
+			expect(
+				res.find((it) => it.col1 === true && it.col2 === null),
+			).toStrictEqual({ col1: true, col2: null });
+			expect(
+				res.find((it) => it.col1 === false && it.col2 === 'qwerty'),
+			).toStrictEqual({
+				col1: false,
+				col2: 'qwerty',
+			});
+		});
+
+		test.concurrent('sql.identifier escape', async () => {
+			const dialect = new SingleStoreDialect();
+			const userInput = 'id` ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+			const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+			const str = dialect.sqlToQuery(query);
+			expect(str.sql).toBe(
+				'SELECT * FROM `users` ORDER BY `id`` ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--` ASC',
+			);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4612
+		test.concurrent('select with inline params in sql', async ({ db }) => {
+			const users = singlestoreTable('users_115', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const query = db
+				.select({ sum: sql`sum(${3})`.inlineParams() })
+				.from(users);
+
+			expect(query.toSQL()).toStrictEqual({
+				sql: 'select sum(3) from `users_115`',
+				params: [],
+			});
+		});
+	});
+}
diff --git a/integration-tests/tests/singlestore/common-cache.ts b/integration-tests/tests/singlestore/common-cache.ts
new file mode 100644
index 0000000000..7f69407ce5
--- /dev/null
+++ b/integration-tests/tests/singlestore/common-cache.ts
@@ -0,0 +1,284 @@
+import { eq, sql } from 'drizzle-orm';
+import { alias, boolean, int, json, serial, singlestoreTable, text, timestamp } from 'drizzle-orm/singlestore-core';
+import { describe, expect, vi } from 'vitest';
+import type { Test } from './instrumentation';
+
+const usersTable = singlestoreTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+const postsTable = singlestoreTable('posts', {
+	id: serial().primaryKey(),
+	description: text().notNull(),
+	userId: int('city_id'),
+});
+
+export function tests(test: Test) {
+	describe('common_cache', () => {
+		test.beforeEach(async ({ caches, push }) => {
+			const { explicit, all } = caches;
+			await Promise.all([
+				explicit.execute(sql`drop table if exists users`),
+				explicit.execute(sql`drop table if exists posts`),
+			]);
+			await explicit.$cache?.invalidate({ tables: 'users' });
+			await all.$cache?.invalidate({ tables: 'users' });
+			// public users
+			await Promise.all([
+				push({ usersTable }),
+				push({ postsTable }),
+			]);
+		});
+
+		test.concurrent('test force invalidate', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			using spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
+			await db.$cache?.invalidate({ tables: 'users' });
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test.concurrent('default global config - no cache should be hit', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test.concurrent('default global config + enable cache on select: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache();
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test.concurrent('default global config + enable cache on select + write: get, put, onMutate', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			spyPut.mockClear();
+			spyGet.mockClear();
+			spyInvalidate.mockClear();
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test.concurrent('default global config + enable cache on select + disable invalidate: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			// invalidate force
+			await db.$cache?.invalidate({ tags: ['custom'] });
+		});
+
+		test.concurrent('global: true + disable cache', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache(false);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test.concurrent('global: true - cache should be hit', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable);
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test.concurrent('global: true - cache: false on select - no cache hit', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache(false);
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+		});
+
+		test.concurrent('global: true - disable invalidate - cache hit + no invalidate', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			spyPut.mockClear();
+			spyGet.mockClear();
+			spyInvalidate.mockClear();
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+		});
+
+		test.concurrent('global: true - with custom tag', async ({ caches }) => {
+			const { all: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
+
+			expect(spyPut).toHaveBeenCalledTimes(1);
+			expect(spyGet).toHaveBeenCalledTimes(1);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			// invalidate force
+			await db.$cache?.invalidate({ tags: ['custom'] });
+		});
+
+		// check select used tables
+		test.concurrent('check simple select used tables', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
+			// @ts-expect-error
+			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
+		});
+		// check select+join used tables
+		test.concurrent('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
+				.toStrictEqual(['users', 'posts']);
+			expect(
+				// @ts-expect-error
+				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
+			).toStrictEqual(['users', 'posts']);
+		});
+		// check select+2join used tables
+		test.concurrent('select+2joins', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			expect(
+				db.select().from(usersTable).leftJoin(
+					postsTable,
+					eq(usersTable.id, postsTable.userId),
+				).leftJoin(
+					alias(postsTable, 'post2'),
+					eq(usersTable.id, postsTable.userId),
+				)
+					// @ts-expect-error
+					.getUsedTables(),
+			)
+				.toStrictEqual(['users', 'posts']);
+			expect(
+				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).leftJoin(
+					alias(postsTable, 'post2'),
+					eq(usersTable.id, postsTable.userId),
+					// @ts-expect-error
+				).getUsedTables(),
+			).toStrictEqual(['users', 'posts']);
+		});
+		// select subquery used tables
+		test.concurrent('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
+
+			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
+			db.select().from(sq);
+
+			// @ts-expect-error
+			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
+		});
+	});
+}
diff --git a/integration-tests/tests/singlestore/common-rqb.ts b/integration-tests/tests/singlestore/common-rqb.ts
new file mode 100644
index 0000000000..06d4f98c3c
--- /dev/null
+++ b/integration-tests/tests/singlestore/common-rqb.ts
@@ -0,0 +1,552 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import 'dotenv/config';
+import { sql } from 'drizzle-orm';
+import { describe, expect } from 'vitest';
+import type { Test } from './instrumentation';
+import { rqbPost, rqbUser } from './schema';
+
+export function tests(test: Test) {
+	const connDict: Record<string, any> = {};
+
+	describe('common', () => {
+		test.beforeEach(async ({ db, client, push }) => {
+			const connKey = `${client.config.user}:${client.config.password}@${client.config.host}:${client.config.port}`;
+			if (connDict[connKey] === undefined) {
+				connDict[connKey] = false;
+
+				await Promise.all([
+					db.execute(sql`drop table if exists ${rqbUser};`),
+					db.execute(sql`drop table if exists ${rqbPost};`),
+				]);
+
+				await Promise.all([
+					push({ rqbUser }),
+					push({ rqbPost }),
+				]);
+			}
+
+			await Promise.all([
+				db.execute(sql`truncate table ${rqbUser};`),
+				db.execute(sql`truncate table ${rqbPost};`),
+			]);
+		});
+
+		test.concurrent('RQB v2 simple find first - no rows', async ({ db }) => {
+			const result = await db.query.rqbUser.findFirst();
+
+			expect(result).toStrictEqual(undefined);
+		});
+
+		test.concurrent('RQB v2 simple find first - multiple rows', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = await db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+
+		test.concurrent('RQB v2 simple find first - with relation', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = await db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+
+		test.concurrent('RQB v2 simple find first - placeholders', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+
+		test.concurrent('RQB v2 simple find many - no rows', async ({ db }) => {
+			const result = await db.query.rqbUser.findMany();
+
+			expect(result).toStrictEqual([]);
+		});
+
+		test.concurrent('RQB v2 simple find many - multiple rows', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = await db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+
+		test.concurrent('RQB v2 simple find many - with relation', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = await db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).toStrictEqual([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+
+		test.concurrent('RQB v2 simple find many - placeholders', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = await query.execute({
+				filter: 2,
+			});
+
+			expect(result).toStrictEqual([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+
+		test.concurrent('RQB v2 transaction find first - no rows', async ({ db }) => {
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - multiple rows', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbUser.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - with relation', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbUser.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find first - placeholders', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const query = db.query.rqbUser.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = await query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - no rows', async ({ db }) => {
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - multiple rows', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbUser.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - with relation', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			await db.transaction(async (db) => {
+				const result = await db.query.rqbPost.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			});
+		});
+
+		test.concurrent('RQB v2 transaction find many - placeholders', async ({ db }) => {
+			const date = new Date(120000);
+
+			await db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			await db.transaction(async (db) => {
+				const query = db.query.rqbUser.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = await query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			});
+		});
+	});
+}
diff --git a/integration-tests/tests/singlestore/common.ts b/integration-tests/tests/singlestore/common.ts
new file mode 100644
index 0000000000..b0a2ca713f
--- /dev/null
+++ b/integration-tests/tests/singlestore/common.ts
@@ -0,0 +1,14 @@
+import { tests as tests1 } from './common-1';
+import { tests as tests2 } from './common-2';
+import { tests as tests3 } from './common-rqb';
+import type { Test } from './instrumentation';
+
+export const tests = (test: Test, exclude: string[] = []) => {
+	test.beforeEach(({ task, skip }) => {
+		if (exclude.includes(task.name)) skip();
+	});
+
+	tests1(test);
+	tests2(test);
+	tests3(test);
+};
diff --git a/integration-tests/tests/singlestore/instrumentation.ts b/integration-tests/tests/singlestore/instrumentation.ts
new file mode 100644
index 0000000000..313f93eadd
--- /dev/null
+++ b/integration-tests/tests/singlestore/instrumentation.ts
@@ -0,0 +1,467 @@
+import {
+	type AnyRelationsBuilderConfig,
+	defineRelations,
+	type ExtractTablesFromSchema,
+	type ExtractTablesWithRelations,
+	getTableName,
+	is,
+	type RelationsBuilder,
+	type RelationsBuilderConfig,
+	Table,
+} from 'drizzle-orm';
+import { Cache, type MutationOption } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { drizzle as drizzleSingleStore, type SingleStoreDatabase } from 'drizzle-orm/singlestore';
+import type { SingleStoreEnumColumn, SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import type { SingleStoreView } from 'drizzle-orm/singlestore-core/view';
+import { drizzle as drizzleProxy } from 'drizzle-orm/singlestore-proxy';
+import Keyv from 'keyv';
+import { type Connection, createConnection } from 'mysql2/promise';
+import { test as base } from 'vitest';
+import relations from './relations';
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private readonly strat: 'explicit' | 'all', private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy() {
+		return this.strat;
+	}
+
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+class ServerSimulator {
+	constructor(private db: Connection) {}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+					sql,
+					values: params,
+					rowsAsArray: true,
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
+				});
+
+				return { data: result[0] as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+					sql,
+					values: params,
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
+				});
+
+				return { data: result as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('START TRANSACTION');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch (e) {
+			await this.db.query('ROLLBACK');
+			throw e;
+		}
+
+		return {};
+	}
+}
+
+export const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/singlestore/mocks' as string);
+
+	const res = await diff({}, schema, []);
+
+	for (const s of res.sqlStatements) {
+		await query(s, []).catch((e) => {
+			console.error(s);
+			console.error(e);
+			throw e;
+		});
+	}
+};
+
+export const prepareSingleStoreClient = async (uri: string) => {
+	const client = await createConnection({
+		uri,
+		supportBigNumbers: true,
+		multipleStatements: true,
+	});
+	await client.connect();
+
+	await Promise.all([
+		client.query('drop database if exists "mySchema";'),
+		client.query('drop database if exists drizzle;'),
+	]);
+
+	await Promise.all([
+		client.query('create database "mySchema";'),
+		client.query('create database drizzle'),
+	]);
+
+	await client.changeUser({ database: 'drizzle' });
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res[0] as any[];
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => client.query(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+export const prepareProxy = async (uri: string) => {
+	const client = await createConnection({
+		uri,
+		supportBigNumbers: true,
+		multipleStatements: true,
+	});
+	await client.connect();
+
+	await Promise.all([
+		client.query('drop database if exists "mySchema";'),
+		client.query('drop database if exists drizzle;'),
+	]);
+
+	await Promise.all([
+		client.query('create database "mySchema";'),
+		client.query('create database drizzle'),
+	]);
+
+	await client.changeUser({ database: 'drizzle' });
+
+	const query = async (sql: string, params: any[] = []) => {
+		const res = await client.query(sql, params);
+		return res[0] as any[];
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => client.query(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, query, batch };
+};
+
+const providerClosure = async <T>(items: T[]) => {
+	return async () => {
+		while (true) {
+			const c = items.shift();
+			if (!c) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				continue;
+			}
+			return {
+				...c,
+				release: () => {
+					items.push(c);
+				},
+			};
+		}
+	};
+};
+
+export const providerForSingleStore = async () => {
+	const url = process.env['SINGLESTORE_MANY_CONNECTION_STRING'];
+	if (url === undefined) throw new Error('SINGLESTORE_MANY_CONNECTION_STRING is not set.');
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareSingleStoreClient(urlI)));
+
+	return providerClosure(clients);
+};
+
+export const provideForProxy = async () => {
+	const url = process.env['SINGLESTORE_MANY_CONNECTION_STRING'];
+	if (url === undefined) throw new Error('SINGLESTORE_MANY_CONNECTION_STRING is not set.');
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareSingleStoreClient(urlI)));
+
+	return providerClosure(clients);
+};
+
+type ProviderSingleStore = Awaited<ReturnType<typeof providerForSingleStore>>;
+type ProvideForProxy = Awaited<ReturnType<typeof provideForProxy>>;
+
+type Provider =
+	| ProviderSingleStore
+	| ProvideForProxy;
+
+export type SingleStoreSchema_ = Record<
+	string,
+	| SingleStoreTable<any>
+	| SingleStoreEnumColumn<any>
+	| SingleStoreSchema
+	| SingleStoreView
+	| unknown
+>;
+
+const testFor = (vendor: 'singlestore' | 'proxy') => {
+	return base.extend<{
+		provider: Provider;
+		kit: {
+			client: any;
+			query: (sql: string, params?: any[]) => Promise<any[]>;
+			batch: (statements: string[]) => Promise<any>;
+		};
+		client: Connection;
+		db: SingleStoreDatabase<any, any, any, typeof relations>;
+		push: (schema: any) => Promise<void>;
+		createDB: {
+			<S extends SingleStoreSchema_>(
+				schema: S,
+			): SingleStoreDatabase<any, any, any, ReturnType<typeof defineRelations<S>>>;
+			<S extends SingleStoreSchema_, TConfig extends AnyRelationsBuilderConfig>(
+				schema: S,
+				cb: (helpers: RelationsBuilder<ExtractTablesFromSchema<S>>) => TConfig,
+			): SingleStoreDatabase<any, any, any, ExtractTablesWithRelations<TConfig, ExtractTablesFromSchema<S>>>;
+		};
+		caches: {
+			all: SingleStoreDatabase<any, any, any, typeof relations>;
+			explicit: SingleStoreDatabase<any, any, any, typeof relations>;
+		};
+	}>({
+		provider: [
+			// oxlint-disable-next-line no-empty-pattern
+			async ({}, use) => {
+				const provider = vendor === 'singlestore'
+					? await providerForSingleStore()
+					: vendor === 'proxy'
+					? await provideForProxy()
+					: '' as never;
+
+				await use(provider);
+			},
+			{ scope: 'file' },
+		],
+		kit: [
+			async ({ provider }, use) => {
+				const { client, batch, query, release } = await provider();
+				await use({ client: client, query, batch });
+				release();
+			},
+			{ scope: 'test' },
+		],
+		client: [
+			async ({ kit }, use) => {
+				await use(kit.client);
+			},
+			{ scope: 'test' },
+		],
+		db: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw response.error;
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from singlestore proxy server:', e.message);
+							throw e;
+						}
+					};
+					await use(drizzleProxy(proxyHandler, { relations }));
+					return;
+				}
+
+				const db = vendor === 'singlestore'
+					? drizzleSingleStore({ client: kit.client as any, relations })
+					: '' as never;
+
+				await use(db);
+			},
+			{ scope: 'test' },
+		],
+		push: [
+			async ({ kit }, use) => {
+				const push = (
+					schema: any,
+				) => _push(kit.query, schema);
+
+				await use(push);
+			},
+			{ scope: 'test' },
+		],
+		createDB: [
+			async ({ kit }, use) => {
+				const createDB = <S extends SingleStoreSchema_>(
+					schema: S,
+					cb?: (
+						helpers: RelationsBuilder<ExtractTablesFromSchema<S>>,
+					) => RelationsBuilderConfig<ExtractTablesFromSchema<S>>,
+				) => {
+					const relations = cb ? defineRelations(schema, cb) : defineRelations(schema);
+
+					if (vendor === 'singlestore') return drizzleSingleStore({ client: kit.client, relations });
+
+					if (vendor === 'proxy') {
+						const serverSimulator = new ServerSimulator(kit.client);
+						const proxyHandler = async (sql: string, params: any[], method: any) => {
+							try {
+								const response = await serverSimulator.query(sql, params, method);
+
+								if (response.error !== undefined) {
+									throw response.error;
+								}
+
+								return { rows: response.data };
+							} catch (e: any) {
+								console.error('Error from singlestore proxy server:', e.message);
+								throw e;
+							}
+						};
+						return drizzleProxy(proxyHandler, { relations });
+					}
+					throw new Error();
+				};
+
+				await use(createDB);
+			},
+			{ scope: 'test' },
+		],
+		caches: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw response.error;
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from singlestore proxy server:', e.message);
+							throw e;
+						}
+					};
+					const db1 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('all') });
+					const db2 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('explicit') });
+					await use({ all: db1, explicit: db2 });
+					return;
+				}
+
+				const config1 = { client: kit.client as any, relations, cache: new TestCache('all') };
+				const config2 = { client: kit.client as any, relations, cache: new TestCache('explicit') };
+
+				const db1 = vendor === 'singlestore'
+					? drizzleSingleStore(config1)
+					: '' as never;
+
+				const db2 = vendor === 'singlestore'
+					? drizzleSingleStore(config2)
+					: '' as never;
+
+				await use({ all: db1, explicit: db2 });
+			},
+			{ scope: 'test' },
+		],
+	});
+};
+
+export const singleStoreTest = testFor('singlestore');
+export const proxyTest = testFor('proxy').extend<{ simulator: ServerSimulator }>({
+	simulator: [
+		async ({ client }, use) => {
+			const simulator = new ServerSimulator(client);
+			await use(simulator);
+		},
+		{ scope: 'test' },
+	],
+});
+
+export type Test = ReturnType<typeof testFor>;
diff --git a/integration-tests/tests/singlestore/relations.ts b/integration-tests/tests/singlestore/relations.ts
new file mode 100644
index 0000000000..1e7748c064
--- /dev/null
+++ b/integration-tests/tests/singlestore/relations.ts
@@ -0,0 +1,14 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './schema';
+
+export default defineRelations(schema, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/singlestore/replicas.test.ts b/integration-tests/tests/singlestore/replicas.test.ts
new file mode 100644
index 0000000000..5f05281cad
--- /dev/null
+++ b/integration-tests/tests/singlestore/replicas.test.ts
@@ -0,0 +1,933 @@
+import { defineRelations, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/singlestore';
+import { boolean, serial, singlestoreTable, text, withReplicas } from 'drizzle-orm/singlestore-core';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = singlestoreTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+});
+
+const users = singlestoreTable('users', {
+	id: serial('id' as string).primaryKey(),
+});
+
+describe('[select] read replicas singlestore', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query = db.$primary.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual('select `id` from `users`');
+
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(query1.toSQL().sql).toEqual('select count(*) as `count` from `users` limit ?');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select({ id: users.id }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.$primary.select().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select `id` from `users`');
+
+		const query2 = db.select().from(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select `id` from `users`');
+	});
+});
+
+describe('[selectDistinct] read replicas singlestore', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query = db.$primary.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.$primary.selectDistinct().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct `id` from `users`');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select distinct `id` from `users`');
+	});
+});
+
+describe('[with] read replicas singlestore', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+		const obj4 = {} as any;
+
+		db.$primary.with(obj1, obj2, obj3, obj4);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+
+		db.with(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		db.with(obj2, obj3);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
+	});
+});
+
+describe('[update] replicas singlestore', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		const query1 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('update `users` set `id` = ?');
+
+		const query2 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('update `users` set `id` = ?');
+
+		const query3 = db.$primary.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query3.toSQL().sql).toEqual('update `users` set `id` = ?');
+	});
+});
+
+describe('[delete] replicas singlestore', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		const query1 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query1.toSQL().sql).toEqual('delete from `users`');
+
+		const query2 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+		expect(query2.toSQL().sql).toEqual('delete from `users`');
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas singlestore', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		const query = db.insert(users).values({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query.toSQL().sql).toEqual('insert into `users` (`id`) values (?)');
+
+		db.insert(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas singlestore', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		expect(db.execute(sql``)).rejects.toThrow();
+
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.execute(sql``)).rejects.toThrow();
+		// try {
+		// 	db.execute(sql``);
+		// } catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas singlestore', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const txFn1 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn1)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
+
+		const txFn2 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn2)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[v2 findFirst] read replicas mysql', () => {
+	it('primary v2 findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const obj = {} as any;
+
+		db.$primary.query.usersTable.findFirst(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+	});
+
+	it('random replica v2 findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const par1 = {} as any;
+
+		db.query.usersTable.findFirst(par1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(par1);
+
+		const query = db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0` limit ?',
+		);
+	});
+
+	it('single read replica v2 findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica v2 findFirst + primary v2 findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read v2 findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[v2 findMany] read replicas mysql', () => {
+	it('primary v2 findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj = {} as any;
+
+		const query = db.$primary.query.usersTable.findMany(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+		expect(query.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('random replica v2 findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+		expect(spyRead2).toHaveBeenCalledWith(obj2);
+	});
+
+	it('single read replica v2 findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('single read replica v2 findMany + primary v2 findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.$primary.query.usersTable.findMany(obj2);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+
+	it('always first read v2 v2 findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select `d0`.`id` as `id`, `d0`.`name` as `name`, `d0`.`verified` as `verified` from `users` as `d0`',
+		);
+	});
+});
+
+describe('[$count] read replicas postgres', () => {
+	it('primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$primary.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('single read replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$count(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica $count + primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.$count(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$count(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/tests/singlestore/schema.ts b/integration-tests/tests/singlestore/schema.ts
new file mode 100644
index 0000000000..fb475c0761
--- /dev/null
+++ b/integration-tests/tests/singlestore/schema.ts
@@ -0,0 +1,21 @@
+import { bigint, serial, singlestoreTable, text, timestamp } from 'drizzle-orm/singlestore-core';
+
+export const rqbUser = singlestoreTable('user_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
+
+export const rqbPost = singlestoreTable('post_rqb_test', {
+	id: serial().primaryKey().notNull(),
+	userId: bigint('user_id', {
+		mode: 'number',
+		unsigned: true,
+	}).notNull(),
+	content: text(),
+	createdAt: timestamp('created_at', {
+		mode: 'date',
+	}).notNull(),
+});
diff --git a/integration-tests/tests/singlestore/singlestore-cache.ts b/integration-tests/tests/singlestore/singlestore-cache.ts
deleted file mode 100644
index 992849aa8a..0000000000
--- a/integration-tests/tests/singlestore/singlestore-cache.ts
+++ /dev/null
@@ -1,390 +0,0 @@
-import { eq, getTableName, is, sql, Table } from 'drizzle-orm';
-import type { MutationOption } from 'drizzle-orm/cache/core';
-import { Cache } from 'drizzle-orm/cache/core';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import {
-	alias,
-	boolean,
-	int,
-	json,
-	serial,
-	type SingleStoreDatabase,
-	singlestoreTable,
-	text,
-	timestamp,
-} from 'drizzle-orm/singlestore-core';
-import Keyv from 'keyv';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestGlobalCache extends Cache {
-	private globalTtl: number = 1000;
-	private usedTablesPerKey: Record<string, string[]> = {};
-
-	constructor(private kv: Keyv = new Keyv()) {
-		super();
-	}
-
-	override strategy(): 'explicit' | 'all' {
-		return 'all';
-	}
-	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
-		const res = await this.kv.get(key) ?? undefined;
-		return res;
-	}
-	override async put(
-		key: string,
-		response: any,
-		tables: string[],
-		isTag: boolean,
-		config?: CacheConfig,
-	): Promise<void> {
-		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
-		for (const table of tables) {
-			const keys = this.usedTablesPerKey[table];
-			if (keys === undefined) {
-				this.usedTablesPerKey[table] = [key];
-			} else {
-				keys.push(key);
-			}
-		}
-	}
-	override async onMutate(params: MutationOption): Promise<void> {
-		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
-		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
-
-		const keysToDelete = new Set<string>();
-
-		for (const table of tablesArray) {
-			const tableName = is(table, Table) ? getTableName(table) : table as string;
-			const keys = this.usedTablesPerKey[tableName] ?? [];
-			for (const key of keys) keysToDelete.add(key);
-		}
-
-		if (keysToDelete.size > 0 || tagsArray.length > 0) {
-			for (const tag of tagsArray) {
-				await this.kv.delete(tag);
-			}
-
-			for (const key of keysToDelete) {
-				await this.kv.delete(key);
-				for (const table of tablesArray) {
-					const tableName = is(table, Table) ? getTableName(table) : table as string;
-					this.usedTablesPerKey[tableName] = [];
-				}
-			}
-		}
-	}
-}
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestCache extends TestGlobalCache {
-	override strategy(): 'explicit' | 'all' {
-		return 'explicit';
-	}
-}
-
-type TestSingleStoreDB = SingleStoreDatabase<any, any>;
-
-declare module 'vitest' {
-	interface TestContext {
-		cachedSingleStore: {
-			db: TestSingleStoreDB;
-			dbGlobalCached: TestSingleStoreDB;
-		};
-	}
-}
-
-const usersTable = singlestoreTable('users', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-const postsTable = singlestoreTable('posts', {
-	id: serial().primaryKey(),
-	description: text().notNull(),
-	userId: int('city_id'),
-});
-
-export function tests() {
-	describe('common_cache', () => {
-		beforeEach(async (ctx) => {
-			const { db, dbGlobalCached } = ctx.cachedSingleStore;
-			await db.execute(sql`drop table if exists users`);
-			await db.execute(sql`drop table if exists posts`);
-			await db.$cache?.invalidate({ tables: 'users' });
-			await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
-			// public users
-			await db.execute(
-				sql`
-					create table users (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb json,
-						created_at timestamp not null default now()
-					)
-				`,
-			);
-			await db.execute(
-				sql`
-					create table posts (
-						id serial primary key,
-						description text not null,
-						user_id int
-					)
-				`,
-			);
-		});
-
-		test('test force invalidate', async (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			const spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
-			await db.$cache?.invalidate({ tables: 'users' });
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('default global config - no cache should be hit', async (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('default global config + enable cache on select: get, put', async (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache();
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('default global config + enable cache on select + write: get, put, onMutate', async (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('default global config + enable cache on select + disable invalidate: get, put', async (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			// invalidate force
-			await db.$cache?.invalidate({ tags: ['custom'] });
-		});
-
-		test('global: true + disable cache', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache(false);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - cache should be hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable);
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - cache: false on select - no cache hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache(false);
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-		});
-
-		test('global: true - disable invalidate - cache hit + no invalidate', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			spyPut.mockClear();
-			spyGet.mockClear();
-			spyInvalidate.mockClear();
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			expect(spyPut).toHaveBeenCalledTimes(0);
-			expect(spyGet).toHaveBeenCalledTimes(0);
-			expect(spyInvalidate).toHaveBeenCalledTimes(1);
-		});
-
-		test('global: true - with custom tag', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
-			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
-			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
-
-			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
-
-			expect(spyPut).toHaveBeenCalledTimes(1);
-			expect(spyGet).toHaveBeenCalledTimes(1);
-			expect(spyInvalidate).toHaveBeenCalledTimes(0);
-
-			await db.insert(usersTable).values({ name: 'John' });
-
-			// invalidate force
-			await db.$cache?.invalidate({ tags: ['custom'] });
-		});
-
-		// check select used tables
-		test('check simple select used tables', (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
-			// @ts-expect-error
-			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
-		});
-		// check select+join used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			// @ts-expect-error
-			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
-				.toStrictEqual(['users', 'posts']);
-			expect(
-				// @ts-expect-error
-				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
-		});
-		// check select+2join used tables
-		test('select+2joins', (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			expect(
-				db.select().from(usersTable).leftJoin(
-					postsTable,
-					eq(usersTable.id, postsTable.userId),
-				).leftJoin(
-					alias(postsTable, 'post2'),
-					eq(usersTable.id, postsTable.userId),
-				)
-					// @ts-expect-error
-					.getUsedTables(),
-			)
-				.toStrictEqual(['users', 'posts']);
-			expect(
-				db.select().from(sql`${usersTable}`).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).leftJoin(
-					alias(postsTable, 'post2'),
-					eq(usersTable.id, postsTable.userId),
-					// @ts-expect-error
-				).getUsedTables(),
-			).toStrictEqual(['users', 'posts']);
-		});
-		// select subquery used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedSingleStore;
-
-			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
-			db.select().from(sq);
-
-			// @ts-expect-error
-			expect(db.select().from(sq).getUsedTables()).toStrictEqual(['users']);
-		});
-	});
-}
diff --git a/integration-tests/tests/singlestore/singlestore-common.ts b/integration-tests/tests/singlestore/singlestore-common.ts
deleted file mode 100644
index 896981619f..0000000000
--- a/integration-tests/tests/singlestore/singlestore-common.ts
+++ /dev/null
@@ -1,3926 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import 'dotenv/config';
-import Docker from 'dockerode';
-import {
-	and,
-	asc,
-	avg,
-	avgDistinct,
-	count,
-	countDistinct,
-	eq,
-	exists,
-	getTableColumns,
-	gt,
-	gte,
-	inArray,
-	lt,
-	max,
-	min,
-	Name,
-	notInArray,
-	placeholder,
-	sql,
-	sum,
-	sumDistinct,
-	TransactionRollbackError,
-} from 'drizzle-orm';
-import type { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
-import {
-	alias,
-	bigint,
-	binary,
-	boolean,
-	char,
-	date,
-	datetime,
-	decimal,
-	double,
-	except,
-	float,
-	getTableConfig,
-	index,
-	int,
-	intersect,
-	json,
-	mediumint,
-	primaryKey,
-	real,
-	serial,
-	singlestoreEnum,
-	singlestoreSchema,
-	singlestoreTable,
-	singlestoreTableCreator,
-	/* singlestoreView, */
-	smallint,
-	text,
-	time,
-	timestamp,
-	tinyint,
-	union,
-	unionAll,
-	unique,
-	uniqueIndex,
-	uniqueKeyName,
-	varbinary,
-	varchar,
-	vector,
-	year,
-} from 'drizzle-orm/singlestore-core';
-import { dotProduct, euclideanDistance } from 'drizzle-orm/singlestore-core/expressions';
-import { migrate } from 'drizzle-orm/singlestore/migrator';
-import getPort from 'get-port';
-import { v4 as uuid } from 'uuid';
-import { afterAll, beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
-import { Expect, toLocalDate } from '~/utils.ts';
-import type { Equal } from '~/utils.ts';
-
-type TestSingleStoreDB = SingleStoreDatabase<any, any>;
-
-declare module 'vitest' {
-	interface TestContext {
-		singlestore: {
-			db: TestSingleStoreDB;
-		};
-	}
-}
-
-const ENABLE_LOGGING = false;
-
-const allTypesTable = singlestoreTable('all_types', {
-	serial: serial('scol'),
-	bigint53: bigint('bigint53', {
-		mode: 'number',
-	}),
-	bigint64: bigint('bigint64', {
-		mode: 'bigint',
-	}),
-	binary: binary('binary'),
-	boolean: boolean('boolean'),
-	char: char('char'),
-	date: date('date', {
-		mode: 'date',
-	}),
-	dateStr: date('date_str', {
-		mode: 'string',
-	}),
-	datetime: datetime('datetime', {
-		mode: 'date',
-	}),
-	datetimeStr: datetime('datetime_str', {
-		mode: 'string',
-	}),
-	decimal: decimal('decimal'),
-	decimalNum: decimal('decimal_num', {
-		scale: 30,
-		mode: 'number',
-	}),
-	decimalBig: decimal('decimal_big', {
-		scale: 30,
-		mode: 'bigint',
-	}),
-	double: double('double'),
-	float: float('float'),
-	int: int('int'),
-	json: json('json'),
-	medInt: mediumint('med_int'),
-	smallInt: smallint('small_int'),
-	real: real('real'),
-	text: text('text'),
-	time: time('time'),
-	timestamp: timestamp('timestamp', {
-		mode: 'date',
-	}),
-	timestampStr: timestamp('timestamp_str', {
-		mode: 'string',
-	}),
-	tinyInt: tinyint('tiny_int'),
-	varbin: varbinary('varbin', {
-		length: 16,
-	}),
-	varchar: varchar('varchar', {
-		length: 255,
-	}),
-	year: year('year'),
-	enum: singlestoreEnum('enum', ['enV1', 'enV2']),
-});
-
-const usersTable = singlestoreTable('userstest', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-const users2Table = singlestoreTable('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id'),
-});
-
-const citiesTable = singlestoreTable('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const usersOnUpdate = singlestoreTable('users_on_update', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	updateCounter: int('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
-	updatedAt: datetime('updated_at', { mode: 'date' }).$onUpdateFn(() => new Date()),
-	alwaysNull: text('always_null').$type<string | null>().$onUpdateFn(() => null), // need to add $type because $onUpdate add a default value
-});
-
-const datesTable = singlestoreTable('datestable', {
-	date: date('date'),
-	dateAsString: date('date_as_string', { mode: 'string' }),
-	time: time('time'),
-	datetime: datetime('datetime'),
-	datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
-	timestamp: timestamp('timestamp'),
-	timestampAsString: timestamp('timestamp_as_string', { mode: 'string' }),
-	year: year('year'),
-});
-
-const coursesTable = singlestoreTable('courses', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	categoryId: int('category_id'),
-});
-
-const courseCategoriesTable = singlestoreTable('course_categories', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-const orders = singlestoreTable('orders', {
-	id: serial('id').primaryKey(),
-	region: text('region').notNull(),
-	product: text('product').notNull().$default(() => 'random_string'),
-	amount: int('amount').notNull(),
-	quantity: int('quantity').notNull(),
-});
-
-const usersMigratorTable = singlestoreTable('users12', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-}, (table) => {
-	return {
-		name: uniqueIndex('').on(table.name).using('btree'),
-	};
-});
-
-// To test aggregate functions
-const aggregateTable = singlestoreTable('aggregate_table', {
-	id: serial('id').notNull(),
-	name: text('name').notNull(),
-	a: int('a'),
-	b: int('b'),
-	c: int('c'),
-	nullOnly: int('null_only'),
-});
-
-const vectorSearchTable = singlestoreTable('vector_search', {
-	id: serial('id').notNull(),
-	text: text('text').notNull(),
-	embedding: vector('embedding', { dimensions: 10 }),
-});
-
-// To test another schema and multischema
-const mySchema = singlestoreSchema(`mySchema`);
-
-const usersMySchemaTable = mySchema.table('userstest', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	verified: boolean('verified').notNull().default(false),
-	jsonb: json('jsonb').$type<string[]>(),
-	createdAt: timestamp('created_at').notNull().defaultNow(),
-});
-
-const users2MySchemaTable = mySchema.table('users2', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-	cityId: int('city_id'),
-});
-
-const citiesMySchemaTable = mySchema.table('cities', {
-	id: serial('id').primaryKey(),
-	name: text('name').notNull(),
-});
-
-let singlestoreContainer: Docker.Container;
-export async function createDockerDB(): Promise<{ connectionString: string; container: Docker.Container }> {
-	const docker = new Docker();
-	const port = await getPort({ port: 3306 });
-	const image = 'ghcr.io/singlestore-labs/singlestoredb-dev:latest';
-
-	const pullStream = await docker.pull(image);
-	await new Promise((resolve, reject) =>
-		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	);
-
-	singlestoreContainer = await docker.createContainer({
-		Image: image,
-		Env: ['ROOT_PASSWORD=singlestore'],
-		name: `drizzle-integration-tests-${uuid()}`,
-		HostConfig: {
-			AutoRemove: true,
-			PortBindings: {
-				'3306/tcp': [{ HostPort: `${port}` }],
-			},
-		},
-	});
-
-	await singlestoreContainer.start();
-	await new Promise((resolve) => setTimeout(resolve, 4000));
-
-	return {
-		connectionString: `singlestore://root:singlestore@localhost:${port}/`,
-		container: singlestoreContainer,
-	};
-}
-
-export function tests(driver?: string) {
-	describe('common', () => {
-		afterAll(async () => {
-			await singlestoreContainer?.stop().catch(console.error);
-		});
-
-		beforeEach(async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`drop table if exists userstest`);
-			await db.execute(sql`drop table if exists users2`);
-			await db.execute(sql`drop table if exists cities`);
-			await db.execute(sql`drop table if exists ${allTypesTable}`);
-
-			await db.execute(sql`drop schema if exists \`mySchema\``);
-			await db.execute(sql`create schema if not exists \`mySchema\``);
-
-			await db.execute(
-				sql`
-					create table userstest (
-						id serial primary key,
-						name text not null,
-						verified boolean not null default false,
-						jsonb json,
-						created_at timestamp not null default now()
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table users2 (
-						id serial primary key,
-						name text not null,
-						city_id int
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table cities (
-						id serial primary key,
-						name text not null
-					)
-				`,
-			);
-
-			// mySchema
-			await db.execute(
-				sql`
-					create table \`mySchema\`.\`userstest\` (
-						\`id\` serial primary key,
-						\`name\` text not null,
-						\`verified\` boolean not null default false,
-						\`jsonb\` json,
-						\`created_at\` timestamp not null default now()
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`mySchema\`.\`cities\` (
-						\`id\` serial primary key,
-						\`name\` text not null
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`mySchema\`.\`users2\` (
-						\`id\` serial primary key,
-						\`name\` text not null,
-						\`city_id\` int 
-					)
-				`,
-			);
-		});
-
-		async function setupReturningFunctionsTest(db: SingleStoreDatabase<any, any>) {
-			await db.execute(sql`drop table if exists \`users_default_fn\``);
-			await db.execute(
-				sql`
-					create table \`users_default_fn\` (
-						\`id\` varchar(256) primary key,
-						\`name\` text not null
-					);
-				`,
-			);
-		}
-
-		async function setupSetOperationTest(db: TestSingleStoreDB) {
-			await db.execute(sql`drop table if exists \`users2\``);
-			await db.execute(sql`drop table if exists \`cities\``);
-			await db.execute(
-				sql`
-					create table \`users2\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`city_id\` int
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`cities\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null
-					)
-				`,
-			);
-
-			await db.insert(citiesTable).values([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await db.insert(users2Table).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 2 },
-				{ id: 3, name: 'Jack', cityId: 3 },
-				{ id: 4, name: 'Peter', cityId: 3 },
-				{ id: 5, name: 'Ben', cityId: 2 },
-				{ id: 6, name: 'Jill', cityId: 1 },
-				{ id: 7, name: 'Mary', cityId: 2 },
-				{ id: 8, name: 'Sally', cityId: 1 },
-			]);
-		}
-
-		async function setupAggregateFunctionsTest(db: TestSingleStoreDB) {
-			await db.execute(sql`drop table if exists \`aggregate_table\``);
-			await db.execute(
-				sql`
-					create table \`aggregate_table\` (
-					    \`id\` integer primary key auto_increment not null,
-					    \`name\` text not null,
-					    \`a\` integer,
-					    \`b\` integer,
-					    \`c\` integer,
-					    \`null_only\` integer
-					);
-				`,
-			);
-			await db.insert(aggregateTable).values([
-				{ id: 1, name: 'value 1', a: 5, b: 10, c: 20 },
-				{ id: 2, name: 'value 1', a: 5, b: 20, c: 30 },
-				{ id: 3, name: 'value 2', a: 10, b: 50, c: 60 },
-				{ id: 4, name: 'value 3', a: 20, b: 20, c: null },
-				{ id: 5, name: 'value 4', a: null, b: 90, c: 120 },
-				{ id: 6, name: 'value 5', a: 80, b: 10, c: null },
-				{ id: 7, name: 'value 6', a: null, b: null, c: 150 },
-			]);
-		}
-
-		async function setupVectorSearchTest(db: TestSingleStoreDB) {
-			await db.execute(sql`drop table if exists \`vector_search\``);
-			await db.execute(
-				sql`
-					create table \`vector_search\` (
-						\`id\` integer primary key auto_increment not null,
-						\`text\` text not null,
-						\`embedding\` vector(10) not null
-					)
-				`,
-			);
-			await db.insert(vectorSearchTable).values([
-				{
-					id: 1,
-					text: 'I like dogs',
-					embedding: [0.6119, 0.1395, 0.2921, 0.3664, 0.4561, 0.7852, 0.1997, 0.5142, 0.5924, 0.0465],
-				},
-				{
-					id: 2,
-					text: 'I like cats',
-					embedding: [0.6075, 0.1705, 0.0651, 0.9489, 0.9656, 0.8084, 0.3046, 0.0977, 0.6842, 0.4402],
-				},
-			]);
-		}
-
-		test('table config: unsigned ints', async () => {
-			const unsignedInts = singlestoreTable('cities1', {
-				bigint: bigint('bigint', { mode: 'number', unsigned: true }),
-				int: int('int', { unsigned: true }),
-				smallint: smallint('smallint', { unsigned: true }),
-				mediumint: mediumint('mediumint', { unsigned: true }),
-				tinyint: tinyint('tinyint', { unsigned: true }),
-			});
-
-			const tableConfig = getTableConfig(unsignedInts);
-
-			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
-			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
-			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
-			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
-			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
-
-			expect(bigintColumn.getSQLType()).toBe('bigint unsigned');
-			expect(intColumn.getSQLType()).toBe('int unsigned');
-			expect(smallintColumn.getSQLType()).toBe('smallint unsigned');
-			expect(mediumintColumn.getSQLType()).toBe('mediumint unsigned');
-			expect(tinyintColumn.getSQLType()).toBe('tinyint unsigned');
-		});
-
-		test('table config: signed ints', async () => {
-			const unsignedInts = singlestoreTable('cities1', {
-				bigint: bigint('bigint', { mode: 'number' }),
-				int: int('int'),
-				smallint: smallint('smallint'),
-				mediumint: mediumint('mediumint'),
-				tinyint: tinyint('tinyint'),
-			});
-
-			const tableConfig = getTableConfig(unsignedInts);
-
-			const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
-			const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
-			const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
-			const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
-			const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
-
-			expect(bigintColumn.getSQLType()).toBe('bigint');
-			expect(intColumn.getSQLType()).toBe('int');
-			expect(smallintColumn.getSQLType()).toBe('smallint');
-			expect(mediumintColumn.getSQLType()).toBe('mediumint');
-			expect(tinyintColumn.getSQLType()).toBe('tinyint');
-		});
-
-		test('table config: primary keys name', async () => {
-			const table = singlestoreTable('cities', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-			}));
-
-			const tableConfig = getTableConfig(table);
-
-			expect(tableConfig.primaryKeys).toHaveLength(1);
-			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
-		});
-
-		test('table configs: unique third param', async () => {
-			const cities1Table = singlestoreTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: unique('custom_name').on(t.name, t.state),
-				f1: unique('custom_name1').on(t.name, t.state),
-			}));
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			expect(tableConfig.uniqueConstraints).toHaveLength(2);
-
-			expect(tableConfig.uniqueConstraints[0]?.name).toBe('custom_name');
-			expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-
-			expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom_name1');
-			expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
-		});
-
-		test('table configs: unique in column', async () => {
-			const cities1Table = singlestoreTable('cities1', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull().unique(),
-				state: text('state').unique('custom'),
-				field: text('field').unique('custom_field'),
-			});
-
-			const tableConfig = getTableConfig(cities1Table);
-
-			const columnName = tableConfig.columns.find((it) => it.name === 'name');
-			expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
-			expect(columnName?.isUnique).toBeTruthy();
-
-			const columnState = tableConfig.columns.find((it) => it.name === 'state');
-			expect(columnState?.uniqueName).toBe('custom');
-			expect(columnState?.isUnique).toBeTruthy();
-
-			const columnField = tableConfig.columns.find((it) => it.name === 'field');
-			expect(columnField?.uniqueName).toBe('custom_field');
-			expect(columnField?.isUnique).toBeTruthy();
-		});
-
-		test('select all fields', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const result = await db.select().from(usersTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('select sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql`upper(${usersTable.name})`,
-			}).from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select typed sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql<string>`upper(${usersTable.name})`,
-			}).from(usersTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('select with empty array in inArray', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(inArray(usersTable.id, []))
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([]);
-		});
-
-		test('select with empty array in notInArray', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-			const result = await db
-				.select({
-					name: sql`upper(${usersTable.name})`,
-				})
-				.from(usersTable)
-				.where(notInArray(usersTable.id, []))
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
-		});
-
-		test('select distinct', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const usersDistinctTable = singlestoreTable('users_distinct', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]);
-			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-		});
-
-		test('insert returning sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const [result, _] = await db.insert(usersTable).values({ id: 1, name: 'John' });
-
-			expect(result.insertId).toBe(1);
-		});
-
-		test('delete returning sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(users[0].affectedRows).toBe(1);
-		});
-
-		test('update returning sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			expect(users[0].changedRows).toBe(1);
-		});
-
-		test('update with returning all fields', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
-			expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
-		});
-
-		test('update with returning partial', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
-
-			const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('delete with returning all fields', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('delete with returning partial', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('insert + select', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const result = await db.select().from(usersTable);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-			await db.insert(usersTable).values({ id: 2, name: 'Jane' });
-			const result2 = await db.select().from(usersTable).orderBy(asc(usersTable.id));
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('json insert', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John', jsonb: ['foo', 'bar'] });
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				jsonb: usersTable.jsonb,
-			}).from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
-		});
-
-		test('insert with overridden default values', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John', verified: true });
-			const result = await db.select().from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('insert many', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ id: 3, name: 'Jane' },
-				{ id: 4, name: 'Austin', verified: true },
-			]);
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				jsonb: usersTable.jsonb,
-				verified: usersTable.verified,
-			}).from(usersTable)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('insert many with returning', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]);
-
-			expect(result[0].affectedRows).toBe(4);
-		});
-
-		test('select with group by as field', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.name)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('select with exists', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const user = alias(usersTable, 'user');
-			const result = await db.select({ name: usersTable.name }).from(usersTable).where(
-				exists(
-					db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
-				),
-			)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'John' }]);
-		});
-
-		test('select with group by as sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(sql`${usersTable.name}`)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('$default function', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
-			const selectedOrder = await db.select().from(orders);
-
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-		});
-
-		test('$default with empty array', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`s_orders\``);
-			await db.execute(
-				sql`
-					create table \`s_orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text default 'Ukraine',
-					    \`product\` text not null
-					)
-				`,
-			);
-
-			const users = singlestoreTable('s_orders', {
-				id: serial('id').primaryKey(),
-				region: text('region').default('Ukraine'),
-				product: text('product').$defaultFn(() => 'random_string'),
-			});
-
-			await db.insert(users).values({ id: 1 });
-			const selectedOrder = await db.select().from(users);
-
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
-		});
-
-		test('select with group by as sql + column', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(sql`${usersTable.name}`, usersTable.id)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('select with group by complex query', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Jane' }]);
-
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, sql`${usersTable.name}`)
-				.orderBy(asc(usersTable.name))
-				.limit(1);
-
-			expect(result).toEqual([{ name: 'Jane' }]);
-		});
-
-		test('build query', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
-				.groupBy(usersTable.id, usersTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: `select \`id\`, \`name\` from \`userstest\` group by \`userstest\`.\`id\`, \`userstest\`.\`name\``,
-				params: [],
-			});
-		});
-
-		test('Query check: Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			const query = db
-				.insert(users)
-				.values({})
-				.toSQL();
-
-			expect(query).toEqual({
-				sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Query check: Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state').default('UA'),
-			});
-
-			const query = db
-				.insert(users)
-				.values([{}, {}])
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into `users` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
-				params: [],
-			});
-		});
-
-		test('Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('empty_insert_single', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
-			);
-
-			await db.insert(users).values({ id: 1 });
-
-			const res = await db.select().from(users);
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
-		});
-
-		test('Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('empty_insert_multiple', {
-				id: serial('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
-			);
-
-			await db.insert(users).values([{ id: 1 }, { id: 2 }]);
-
-			const res = await db.select().from(users).orderBy(asc(users.id));
-
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
-		});
-
-		test('build query insert with onDuplicate', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const query = db.insert(usersTable)
-				.values({ id: 1, name: 'John', jsonb: ['foo', 'bar'] })
-				.onDuplicateKeyUpdate({ set: { id: 1, name: 'John1' } })
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (?, ?, default, ?, default) on duplicate key update `id` = ?, `name` = ?',
-				params: [1, 'John', '["foo","bar"]', 1, 'John1'],
-			});
-		});
-
-		test('insert with onDuplicate', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable)
-				.values({ id: 1, name: 'John' });
-
-			await db.insert(usersTable)
-				.values({ id: 1, name: 'John' })
-				.onDuplicateKeyUpdate({ set: { name: 'John1' } });
-
-			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(res).toEqual([{ id: 1, name: 'John1' }]);
-		});
-
-		test('insert conflict', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable)
-				.values({ id: 1, name: 'John' });
-
-			await expect((async () => {
-				db.insert(usersTable).values({ id: 1, name: 'John1' });
-			})()).resolves.not.toThrowError();
-		});
-
-		test('insert conflict with ignore', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable)
-				.values({ id: 1, name: 'John' });
-
-			await db.insert(usersTable)
-				.ignore()
-				.values({ id: 1, name: 'John1' });
-
-			const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
-				eq(usersTable.id, 1),
-			);
-
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: sql`${'John'}` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('partial join with alias', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const customerAlias = alias(usersTable, 'customer');
-
-			await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select({
-					user: {
-						id: usersTable.id,
-						name: usersTable.name,
-					},
-					customer: {
-						id: customerAlias.id,
-						name: customerAlias.name,
-					},
-				}).from(usersTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersTable.id, 10))
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([{
-				user: { id: 10, name: 'Ivan' },
-				customer: { id: 11, name: 'Hans' },
-			}]);
-		});
-
-		test('full join with alias', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const singlestoreTable = singlestoreTableCreator((name) => `prefixed_${name}`);
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select().from(users)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(users.id, 10))
-				.orderBy(asc(users.id));
-
-			expect(result).toEqual([{
-				users: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('select from alias', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const singlestoreTable = singlestoreTableCreator((name) => `prefixed_${name}`);
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
-
-			const user = alias(users, 'user');
-			const customers = alias(users, 'customer');
-
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
-			const result = await db
-				.select()
-				.from(user)
-				.leftJoin(customers, eq(customers.id, 11))
-				.where(eq(user.id, 10))
-				.orderBy(asc(user.id));
-
-			expect(result).toEqual([{
-				user: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-				},
-			}]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('insert with spaces', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('prepared statement', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const statement = db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable)
-				.prepare();
-			const result = await statement.execute();
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert: placeholders on columns with encoder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const date = new Date('2024-08-07T15:30:00Z');
-
-			const statement = db.insert(usersTable).values({
-				id: 1,
-				name: 'John',
-				createdAt: sql.placeholder('createdAt'),
-			}).prepare();
-
-			await statement.execute({ createdAt: date });
-
-			const result = await db
-				.select({
-					id: usersTable.id,
-					createdAt: usersTable.createdAt,
-				})
-				.from(usersTable);
-
-			expect(result).toEqual([
-				{ id: 1, createdAt: date },
-			]);
-		});
-
-		test('prepared statement reuse', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const stmt = db.insert(usersTable).values({
-				verified: true,
-				id: placeholder('id'),
-				name: placeholder('name'),
-			}).prepare();
-
-			for (let i = 0; i < 10; i++) {
-				await stmt.execute({ id: i + 1, name: `John ${i}` });
-			}
-
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				verified: usersTable.verified,
-			}).from(usersTable)
-				.orderBy(asc(usersTable.id));
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John 0', verified: true },
-				{ id: 2, name: 'John 1', verified: true },
-				{ id: 3, name: 'John 2', verified: true },
-				{ id: 4, name: 'John 3', verified: true },
-				{ id: 5, name: 'John 4', verified: true },
-				{ id: 6, name: 'John 5', verified: true },
-				{ id: 7, name: 'John 6', verified: true },
-				{ id: 8, name: 'John 7', verified: true },
-				{ id: 9, name: 'John 8', verified: true },
-				{ id: 10, name: 'John 9', verified: true },
-			]);
-		});
-
-		test('prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ id: 1, name: 'John' });
-			const stmt = db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable)
-				.where(eq(usersTable.id, placeholder('id')))
-				.prepare();
-			const result = await stmt.execute({ id: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('migrator', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists cities_migration`);
-			await db.execute(sql`drop table if exists users_migration`);
-			await db.execute(sql`drop table if exists users12`);
-			await db.execute(sql`drop table if exists __drizzle_migrations`);
-
-			await migrate(db, { migrationsFolder: './drizzle2/singlestore' });
-
-			await db.insert(usersMigratorTable).values({ id: 1, name: 'John', email: 'email' });
-
-			const result = await db.select().from(usersMigratorTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
-
-			await db.execute(sql`drop table cities_migration`);
-			await db.execute(sql`drop table users_migration`);
-			await db.execute(sql`drop table users12`);
-			await db.execute(sql`drop table __drizzle_migrations`);
-		});
-
-		test('insert via db.execute + select via db.execute', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(
-				sql`insert into ${usersTable} (${new Name(usersTable.id.name)},${new Name(
-					usersTable.name.name,
-				)}) values (1,${'John'})`,
-			);
-
-			const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
-			expect(result[0]).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('insert via db.execute w/ query builder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const inserted = await db.execute(
-				db.insert(usersTable).values({ id: 1, name: 'John' }),
-			);
-			expect(inserted[0].affectedRows).toBe(1);
-		});
-
-		test('insert + select all possible dates', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-			await db.execute(
-				sql`
-					create table \`datestable\` (
-					    \`date\` date,
-					    \`date_as_string\` date,
-					    \`time\` time,
-					    \`datetime\` datetime,
-					    \`datetime_as_string\` datetime,
-					    \`timestamp\` timestamp(6),
-					    \`timestamp_as_string\` timestamp(6),
-					    \`year\` year
-					)
-				`,
-			);
-
-			const date = new Date('2022-11-11');
-			const dateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
-
-			await db.insert(datesTable).values({
-				date: date,
-				dateAsString: '2022-11-11',
-				time: '12:12:12',
-				datetime: date,
-				year: 22,
-				datetimeAsString: '2022-11-11 12:12:12',
-				timestamp: dateWithMilliseconds,
-				timestampAsString: '2022-11-11 12:12:12.123',
-			});
-
-			const res = await db.select().from(datesTable);
-
-			expect(res[0]?.date).toBeInstanceOf(Date);
-			expect(res[0]?.datetime).toBeInstanceOf(Date);
-			expect(typeof res[0]?.dateAsString).toBe('string');
-			expect(typeof res[0]?.datetimeAsString).toBe('string');
-
-			expect(res).toEqual([{
-				date: toLocalDate(new Date('2022-11-11')),
-				dateAsString: '2022-11-11',
-				time: '12:12:12',
-				datetime: new Date('2022-11-11'),
-				year: 2022,
-				datetimeAsString: '2022-11-11 12:12:12',
-				timestamp: new Date('2022-11-11 12:12:12.123'),
-				timestampAsString: '2022-11-11 12:12:12.123000',
-			}]);
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-		});
-
-		const tableWithEnums = singlestoreTable('enums_test_case', {
-			id: serial('id').primaryKey(),
-			enum1: singlestoreEnum('enum1', ['a', 'b', 'c']).notNull(),
-			enum2: singlestoreEnum('enum2', ['a', 'b', 'c']).default('a'),
-			enum3: singlestoreEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
-		});
-
-		test('SingleStore enum test case #1', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`enums_test_case\``);
-
-			await db.execute(sql`
-				create table \`enums_test_case\` (
-				    \`id\` serial primary key,
-				    \`enum1\` ENUM('a', 'b', 'c') not null,
-				    \`enum2\` ENUM('a', 'b', 'c') default 'a',
-				    \`enum3\` ENUM('a', 'b', 'c') not null default 'b'
-				)
-			`);
-
-			await db.insert(tableWithEnums).values([
-				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-				{ id: 2, enum1: 'a', enum3: 'c' },
-				{ id: 3, enum1: 'a' },
-			]);
-
-			const res = await db.select().from(tableWithEnums).orderBy(asc(tableWithEnums.id));
-
-			await db.execute(sql`drop table \`enums_test_case\``);
-
-			expect(res).toEqual([
-				{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
-				{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
-				{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
-			]);
-		});
-
-		test('left join (flat object fields)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
-
-			const res = await db.select({
-				userId: users2Table.id,
-				userName: users2Table.name,
-				cityId: citiesTable.id,
-				cityName: citiesTable.name,
-			}).from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
-				.orderBy(users2Table.id);
-
-			expect(res).toEqual([
-				{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
-				{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
-			]);
-		});
-
-		test('left join (grouped fields)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
-
-			const res = await db.select({
-				id: users2Table.id,
-				user: {
-					name: users2Table.name,
-					nameUpper: sql<string>`upper(${users2Table.name})`,
-				},
-				city: {
-					id: citiesTable.id,
-					name: citiesTable.name,
-					nameUpper: sql<string>`upper(${citiesTable.name})`,
-				},
-			}).from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
-				.orderBy(asc(users2Table.id));
-
-			expect(res).toEqual([
-				{
-					id: 1,
-					user: { name: 'John', nameUpper: 'JOHN' },
-					city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
-				},
-				{
-					id: 2,
-					user: { name: 'Jane', nameUpper: 'JANE' },
-					city: null,
-				},
-			]);
-		});
-
-		test('left join (all fields)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane' }]);
-
-			const res = await db.select().from(users2Table)
-				.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id))
-				.orderBy(asc(users2Table.id));
-
-			expect(res).toEqual([
-				{
-					users2: {
-						id: 1,
-						name: 'John',
-						cityId: 1,
-					},
-					cities: {
-						id: 1,
-						name: 'Paris',
-					},
-				},
-				{
-					users2: {
-						id: 2,
-						name: 'Jane',
-						cityId: null,
-					},
-					cities: null,
-				},
-			]);
-		});
-
-		test('join subquery', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`courses\``);
-			await db.execute(sql`drop table if exists \`course_categories\``);
-
-			await db.execute(
-				sql`
-					create table \`course_categories\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null
-					)
-				`,
-			);
-
-			await db.execute(
-				sql`
-					create table \`courses\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`category_id\` int
-					)
-				`,
-			);
-
-			await db.insert(courseCategoriesTable).values([
-				{ id: 1, name: 'Category 1' },
-				{ id: 2, name: 'Category 2' },
-				{ id: 3, name: 'Category 3' },
-				{ id: 4, name: 'Category 4' },
-			]);
-
-			await db.insert(coursesTable).values([
-				{ id: 1, name: 'Development', categoryId: 2 },
-				{ id: 2, name: 'IT & Software', categoryId: 3 },
-				{ id: 3, name: 'Marketing', categoryId: 4 },
-				{ id: 4, name: 'Design', categoryId: 1 },
-			]);
-
-			const sq2 = db
-				.select({
-					categoryId: courseCategoriesTable.id,
-					category: courseCategoriesTable.name,
-					total: sql<number>`count(${courseCategoriesTable.id})`,
-				})
-				.from(courseCategoriesTable)
-				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
-				.as('sq2');
-
-			const res = await db
-				.select({
-					courseName: coursesTable.name,
-					categoryId: sq2.categoryId,
-				})
-				.from(coursesTable)
-				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
-				.orderBy(coursesTable.name);
-
-			expect(res).toEqual([
-				{ courseName: 'Design', categoryId: 1 },
-				{ courseName: 'Development', categoryId: 2 },
-				{ courseName: 'IT & Software', categoryId: 3 },
-				{ courseName: 'Marketing', categoryId: 4 },
-			]);
-
-			await db.execute(sql`drop table if exists \`courses\``);
-			await db.execute(sql`drop table if exists \`course_categories\``);
-		});
-
-		test('with ... select', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const regionalSales = db
-				.$with('regional_sales')
-				.as(
-					db
-						.select({
-							region: orders.region,
-							totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-						})
-						.from(orders)
-						.groupBy(orders.region),
-				);
-
-			const topRegions = db
-				.$with('top_regions')
-				.as(
-					db
-						.select({
-							region: regionalSales.region,
-						})
-						.from(regionalSales)
-						.where(
-							gt(
-								regionalSales.totalSales,
-								db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-							),
-						),
-				);
-
-			const result = await db
-				.with(regionalSales, topRegions)
-				.select({
-					region: orders.region,
-					product: orders.product,
-					productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
-					productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
-				})
-				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
-				.groupBy(orders.region, orders.product)
-				.orderBy(orders.region, orders.product);
-
-			expect(result).toEqual([
-				{
-					region: 'Europe',
-					product: 'A',
-					productUnits: 3,
-					productSales: 30,
-				},
-				{
-					region: 'Europe',
-					product: 'B',
-					productUnits: 5,
-					productSales: 50,
-				},
-				{
-					region: 'US',
-					product: 'A',
-					productUnits: 7,
-					productSales: 70,
-				},
-				{
-					region: 'US',
-					product: 'B',
-					productUnits: 9,
-					productSales: 90,
-				},
-			]);
-		});
-
-		test('with ... update', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const products = singlestoreTable('products', {
-				id: serial('id').primaryKey(),
-				price: decimal('price', {
-					precision: 15,
-					scale: 2,
-				}).notNull(),
-				cheap: boolean('cheap').notNull().default(false),
-			});
-
-			await db.execute(sql`drop table if exists ${products}`);
-			await db.execute(sql`
-				create table ${products} (
-				    id serial primary key,
-				    price decimal(15, 2) not null,
-				    cheap boolean not null default false
-				)
-			`);
-
-			await db.insert(products).values([
-				{ id: 1, price: '10.99' },
-				{ id: 2, price: '25.85' },
-				{ id: 3, price: '32.99' },
-				{ id: 4, price: '2.50' },
-				{ id: 5, price: '4.59' },
-			]);
-
-			const averagePrice = db
-				.$with('average_price')
-				.as(
-					db
-						.select({
-							value: sql`avg(${products.price})`.as('value'),
-						})
-						.from(products),
-				);
-
-			await db
-				.with(averagePrice)
-				.update(products)
-				.set({
-					cheap: true,
-				})
-				.where(lt(products.price, sql`(select * from ${averagePrice})`));
-
-			const result = await db
-				.select({
-					id: products.id,
-				})
-				.from(products)
-				.where(eq(products.cheap, true))
-				.orderBy(asc(products.id));
-
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
-		});
-
-		test('with ... delete', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`orders\``);
-			await db.execute(
-				sql`
-					create table \`orders\` (
-					    \`id\` serial primary key,
-					    \`region\` text not null,
-					    \`product\` text not null,
-					    \`amount\` int not null,
-					    \`quantity\` int not null
-					)
-				`,
-			);
-
-			await db.insert(orders).values([
-				{ id: 1, region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ id: 2, region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ id: 3, region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ id: 4, region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ id: 5, region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ id: 6, region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ id: 7, region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ id: 8, region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]);
-
-			const averageAmount = db
-				.$with('average_amount')
-				.as(
-					db
-						.select({
-							value: sql`avg(${orders.amount})`.as('value'),
-						})
-						.from(orders),
-				);
-
-			await db
-				.with(averageAmount)
-				.delete(orders)
-				.where(gt(orders.amount, sql`(select * from ${averageAmount})`));
-
-			const result = await db
-				.select({
-					id: orders.id,
-				})
-				.from(orders)
-				.orderBy(asc(orders.id));
-
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 2 },
-				{ id: 3 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
-		});
-
-		test('select from subquery sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(users2Table).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
-
-			const sq = db
-				.select({ name: sql<string>`concat(${users2Table.name}, " modified")`.as('name') })
-				.from(users2Table)
-				.orderBy(asc(users2Table.id))
-				.as('sq');
-
-			const res = await db.select({ name: sq.name }).from(sq);
-
-			expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
-		});
-
-		test('select a field without joining its table', (ctx) => {
-			const { db } = ctx.singlestore;
-
-			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
-		});
-
-		test('select all fields from subquery without alias', (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
-
-			expect(() => db.select().from(sq).prepare()).toThrowError();
-		});
-
-		test('select count()', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
-
-			const res = await db.select({ count: sql`count(*)` }).from(usersTable);
-
-			expect(res).toEqual([{ count: 2 }]);
-		});
-
-		test('select for ...', (ctx) => {
-			const { db } = ctx.singlestore;
-
-			{
-				const query = db.select().from(users2Table).for('update').toSQL();
-				expect(query.sql).toMatch(/ for update$/);
-			}
-			{
-				const query = db.select().from(users2Table).for('share', { skipLocked: true }).toSQL();
-				expect(query.sql).toMatch(/ for share skip locked$/);
-			}
-			{
-				const query = db.select().from(users2Table).for('update', { noWait: true }).toSQL();
-				expect(query.sql).toMatch(/ for update nowait$/);
-			}
-		});
-
-		test('having', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(citiesTable).values([{ id: 1, name: 'London' }, { id: 2, name: 'Paris' }, {
-				id: 3,
-				name: 'New York',
-			}]);
-
-			await db.insert(users2Table).values([{ id: 1, name: 'John', cityId: 1 }, { id: 2, name: 'Jane', cityId: 1 }, {
-				id: 3,
-				name: 'Jack',
-				cityId: 2,
-			}]);
-
-			const result = await db
-				.select({
-					id: citiesTable.id,
-					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
-					usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
-				})
-				.from(citiesTable)
-				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
-				.where(({ name }) => sql`length(${name}) >= 3`)
-				.groupBy(citiesTable.id)
-				.having(({ usersCount }) => sql`${usersCount} > 0`)
-				.orderBy(({ name }) => name);
-
-			expect(result).toEqual([
-				{
-					id: 1,
-					name: 'LONDON',
-					usersCount: 2,
-				},
-				{
-					id: 2,
-					name: 'PARIS',
-					usersCount: 1,
-				},
-			]);
-		});
-
-		// TODO: Unskip when views are supported
-		/* test.skip('view', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const newYorkers1 = singlestoreView('new_yorkers')
-				.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
-
-			const newYorkers2 = singlestoreView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
-
-			const newYorkers3 = singlestoreView('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesTable).values([{ id: 1, name: 'New York' }, { id: 2, name: 'Paris' }]);
-
-			await db.insert(users2Table).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 1 },
-				{ id: 3, name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1).orderBy(asc(newYorkers1.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2).orderBy(asc(newYorkers2.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3).orderBy(asc(newYorkers3.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).orderBy(asc(newYorkers1.id));
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		}); */
-
-		test('select from raw sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db.select({
-				id: sql<number>`id`,
-				name: sql<string>`name`,
-			}).from(sql`(select 1 as id, 'John' as name) as users`);
-
-			Expect<Equal<{ id: number; name: string }[], typeof result>>;
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
-		});
-
-		test('select from raw sql with joins', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db
-				.select({
-					id: sql<number>`users.id`,
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
-
-			Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from select', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db
-				.select({
-					userId: sql<number>`users.id`.as('userId'),
-					name: sql<string>`users.name`,
-					userCity: sql<string>`users.city`,
-					cityId: sql<number>`cities.id`.as('cityId'),
-					cityName: sql<string>`cities.name`,
-				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('join on aliased sql from with clause', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = db.$with('users').as(
-				db.select({
-					id: sql<number>`id`.as('userId'),
-					name: sql<string>`name`.as('userName'),
-					city: sql<string>`city`.as('city'),
-				}).from(
-					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
-				),
-			);
-
-			const cities = db.$with('cities').as(
-				db.select({
-					id: sql<number>`id`.as('cityId'),
-					name: sql<string>`name`.as('cityName'),
-				}).from(
-					sql`(select 1 as id, 'Paris' as name) as cities`,
-				),
-			);
-
-			const result = await db
-				.with(users, cities)
-				.select({
-					userId: users.id,
-					name: users.name,
-					userCity: users.city,
-					cityId: cities.id,
-					cityName: cities.name,
-				})
-				.from(users)
-				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
-
-			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
-			>;
-
-			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
-			]);
-		});
-
-		test('prefixed table', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const singlestoreTable = singlestoreTableCreator((name) => `myprefix_${name}`);
-
-			const users = singlestoreTable('test_prefixed_table_with_unique_name', {
-				id: int('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
-			);
-
-			await db.insert(users).values({ id: 1, name: 'John' });
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('orderBy with aliased column', (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const query = db.select({
-				test: sql`something`.as('test'),
-			}).from(users2Table).orderBy((fields) => fields.test).toSQL();
-
-			expect(query.sql).toBe('select something as `test` from `users2` order by `test`');
-		});
-
-		test('timestamp timezone', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
-
-			await db.insert(usersTable).values({ id: 1, name: 'With default times' });
-			await db.insert(usersTable).values({
-				id: 2,
-				name: 'Without default times',
-				createdAt: date,
-			});
-			const users = await db.select().from(usersTable).orderBy(asc(usersTable.id));
-
-			// check that the timestamps are set correctly for default times
-			expect(Math.abs(users[0]!.createdAt.getTime() - Date.now())).toBeLessThan(2000);
-
-			// check that the timestamps are set correctly for non default times
-			expect(Math.abs(users[1]!.createdAt.getTime() - date.getTime())).toBeLessThan(2000);
-		});
-
-		test('transaction', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_transactions', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-			const products = singlestoreTable('products_transactions', {
-				id: serial('id').primaryKey(),
-				price: int('price').notNull(),
-				stock: int('stock').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop table if exists ${products}`);
-
-			await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
-			await db.execute(
-				sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
-			);
-
-			const [{ insertId: userId }] = await db.insert(users).values({ id: 1, balance: 100 });
-			const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
-			const [{ insertId: productId }] = await db.insert(products).values({ id: 1, price: 10, stock: 10 });
-			const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
-
-			await db.transaction(async (tx) => {
-				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
-				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
-			});
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([{ id: 1, balance: 90 }]);
-
-			await db.execute(sql`drop table ${users}`);
-			await db.execute(sql`drop table ${products}`);
-		});
-
-		test('transaction rollback', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_transactions_rollback', {
-				id: serial('id').primaryKey(),
-				balance: int('balance').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table users_transactions_rollback (id serial not null primary key, balance int not null)`,
-			);
-
-			await expect((async () => {
-				await db.transaction(async (tx) => {
-					await tx.insert(users).values({ balance: 100 });
-					tx.rollback();
-				});
-			})()).rejects.toThrowError(TransactionRollbackError);
-
-			const result = await db.select().from(users);
-
-			expect(result).toEqual([]);
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('join subquery with join', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const internalStaff = singlestoreTable('internal_staff', {
-				userId: int('user_id').notNull(),
-			});
-
-			const customUser = singlestoreTable('custom_user', {
-				id: int('id').notNull(),
-			});
-
-			const ticket = singlestoreTable('ticket', {
-				staffId: int('staff_id').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${internalStaff}`);
-			await db.execute(sql`drop table if exists ${customUser}`);
-			await db.execute(sql`drop table if exists ${ticket}`);
-
-			await db.execute(sql`create table internal_staff (user_id integer not null)`);
-			await db.execute(sql`create table custom_user (id integer not null)`);
-			await db.execute(sql`create table ticket (staff_id integer not null)`);
-
-			await db.insert(internalStaff).values({ userId: 1 });
-			await db.insert(customUser).values({ id: 1 });
-			await db.insert(ticket).values({ staffId: 1 });
-
-			const subq = db
-				.select()
-				.from(internalStaff)
-				.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
-				.as('internal_staff');
-
-			const mainQuery = await db
-				.select()
-				.from(ticket)
-				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
-
-			expect(mainQuery).toEqual([{
-				ticket: { staffId: 1 },
-				internal_staff: {
-					internal_staff: { userId: 1 },
-					custom_user: { id: 1 },
-				},
-			}]);
-
-			await db.execute(sql`drop table ${internalStaff}`);
-			await db.execute(sql`drop table ${customUser}`);
-			await db.execute(sql`drop table ${ticket}`);
-		});
-
-		// TODO: Unskip when views are supported
-		/* test.skip('subquery with view', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_subquery_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			});
-
-			const newYorkers = singlestoreView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 2 },
-				{ id: 3, name: 'Jack', cityId: 1 },
-				{ id: 4, name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.$with('sq').as(db.select().from(newYorkers));
-			const result = await db.with(sq).select().from(sq).orderBy(asc(sq.id));
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 3, name: 'Jack', cityId: 1 },
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		}); */
-
-		// TODO: Unskip when views are supported
-		/* test.skip('join view as subquery', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_join_view', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			});
-
-			const newYorkers = singlestoreView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`drop view if exists ${newYorkers}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
-			);
-			await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
-
-			await db.insert(users).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 2 },
-				{ id: 3, name: 'Jack', cityId: 1 },
-				{ id: 4, name: 'Jill', cityId: 2 },
-			]);
-
-			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
-
-			const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id)).orderBy(asc(users.id));
-
-			expect(result).toEqual([
-				{
-					users_join_view: { id: 1, name: 'John', cityId: 1 },
-					new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 2, name: 'Jane', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-				{
-					users_join_view: { id: 3, name: 'Jack', cityId: 1 },
-					new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
-				},
-				{
-					users_join_view: { id: 4, name: 'Jill', cityId: 2 },
-					new_yorkers_sq: null,
-				},
-			]);
-
-			await db.execute(sql`drop view ${newYorkers}`);
-			await db.execute(sql`drop table ${users}`);
-		}); */
-
-		test('select iterator', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_iterator', {
-				id: serial('id').primaryKey(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-			await db.insert(users).values([{ id: 1 }, { id: 2 }, { id: 3 }]);
-
-			const iter = db.select().from(users)
-				.orderBy(asc(users.id))
-				.iterator();
-
-			const result: typeof users.$inferSelect[] = [];
-
-			for await (const row of iter) {
-				result.push(row);
-			}
-
-			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		});
-
-		test('select iterator w/ prepared statement', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users_iterator', {
-				id: serial('id').primaryKey(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key)`);
-
-			await db.insert(users).values([{ id: 1 }, { id: 2 }, { id: 3 }]);
-
-			const prepared = db.select().from(users)
-				.orderBy(asc(users.id))
-				.prepare();
-			const iter = prepared.iterator();
-			const result: typeof users.$inferSelect[] = [];
-
-			for await (const row of iter) {
-				result.push(row);
-			}
-
-			expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }]);
-		});
-
-		test('insert undefined', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.insert(users).values({ name: undefined });
-			})()).resolves.not.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('update undefined', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name'),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-
-			await db.execute(
-				sql`create table ${users} (id serial not null primary key, name text)`,
-			);
-
-			await expect((async () => {
-				await db.update(users).set({ name: undefined });
-			})()).rejects.toThrowError();
-
-			await expect((async () => {
-				await db.update(users).set({ id: 1, name: undefined });
-			})()).resolves.not.toThrowError();
-
-			await db.execute(sql`drop table ${users}`);
-		});
-
-		test('utc config for datetime', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-			await db.execute(
-				sql`
-					create table \`datestable\` (
-					    \`datetime_utc\` datetime(6),
-					    \`datetime\` datetime(6)
-					)
-				`,
-			);
-			const datesTable = singlestoreTable('datestable', {
-				datetimeUTC: datetime('datetime_utc', { mode: 'date' }),
-				datetime: datetime('datetime'),
-			});
-
-			const dateObj = new Date('2022-11-11');
-			const dateUtc = new Date('2022-11-11T12:12:12.122Z');
-
-			await db.insert(datesTable).values({
-				datetimeUTC: dateUtc,
-				datetime: dateObj,
-			});
-
-			const res = await db.select().from(datesTable);
-
-			const [rawSelect] = await db.execute(sql`select \`datetime_utc\` from \`datestable\``);
-			const selectedRow = (rawSelect as unknown as [{ datetime_utc: string }])[0];
-
-			expect(selectedRow.datetime_utc).toBe('2022-11-11 12:12:12.122000');
-			expect(new Date(selectedRow.datetime_utc.replace(' ', 'T') + 'Z')).toEqual(dateUtc);
-
-			expect(res[0]?.datetime).toBeInstanceOf(Date);
-			expect(res[0]?.datetimeUTC).toBeInstanceOf(Date);
-
-			expect(res).toEqual([{
-				datetimeUTC: dateUtc,
-				datetime: new Date('2022-11-11'),
-			}]);
-
-			await db.execute(sql`drop table if exists \`datestable\``);
-		});
-
-		// TODO (https://memsql.atlassian.net/browse/MCDB-63261) allow chaining limit and orderby in subquery
-		test('set operations (union) from query builder with subquery', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-			const citiesQuery = db
-				.select({
-					id: citiesTable.id,
-					name: citiesTable.name,
-					orderCol: sql`0`.as('orderCol'),
-				})
-				.from(citiesTable);
-
-			const usersQuery = db
-				.select({
-					id: users2Table.id,
-					name: users2Table.name,
-					orderCol: sql`1`.as('orderCol'),
-				})
-				.from(users2Table);
-
-			const unionQuery = db
-				.select({
-					id: sql`id`,
-					name: sql`name`,
-				})
-				.from(
-					citiesQuery.union(usersQuery).as('combined'),
-				)
-				.orderBy(sql`orderCol`, sql`id`)
-				.limit(8);
-
-			const result = await unionQuery;
-
-			expect(result).toHaveLength(8);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Jane' },
-				{ id: 3, name: 'Jack' },
-				{ id: 4, name: 'Peter' },
-				{ id: 5, name: 'Ben' },
-			]);
-
-			// union should throw if selected fields are not in the same order
-			await expect((async () => {
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).union(
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(users2Table),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union) as function', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const result = await union(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'John' },
-			]);
-
-			await expect((async () => {
-				union(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) from query builder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq = db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).orderBy(asc(sql`id`)).limit(2).unionAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).orderBy(asc(sql`id`)).limit(2),
-				).as('sq');
-
-			const result = await db.select().from(sq).orderBy(asc(sql`id`)).limit(3);
-
-			expect(result).toHaveLength(3);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).limit(2).unionAll(
-						db
-							.select({ name: citiesTable.name, id: citiesTable.id })
-							.from(citiesTable).limit(2),
-					).orderBy(asc(sql`id`));
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (union all) as function', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq = unionAll(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).as('sq');
-
-			const result = await db.select().from(sq).limit(1);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				unionAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(1);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) from query builder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq = db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).intersect(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				)
-				.as('sq');
-
-			const result = await db.select().from(sq).orderBy(asc(sql`id`));
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
-
-			await expect((async () => {
-				db
-					.select({ name: citiesTable.name, id: citiesTable.id })
-					.from(citiesTable).intersect(
-						db
-							.select({ id: citiesTable.id, name: citiesTable.name })
-							.from(citiesTable).where(gt(citiesTable.id, 1)),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) as function', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq = await intersect(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).as('sq');
-
-			const result = await db.select().from(sq).limit(1);
-
-			expect(result).toHaveLength(0);
-
-			expect(result).toEqual([]);
-
-			await expect((async () => {
-				intersect(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(1);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (except) from query builder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).except(
-					db
-						.select()
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				);
-
-			expect(result).toHaveLength(1);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
-		});
-
-		test('set operations (except) as function', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq = except(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable),
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			).as('sq');
-
-			const result = await db.select().from(sq).limit(3);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toContainEqual({ id: 2, name: 'London' });
-			expect(result).toContainEqual({ id: 3, name: 'Tampa' });
-
-			await expect((async () => {
-				except(
-					db
-						.select({ name: citiesTable.name, id: citiesTable.id })
-						.from(citiesTable),
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				).limit(3);
-			})()).rejects.toThrowError();
-		});
-
-		test('define constraints as array', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const table = singlestoreTable('name', {
-				id: int(),
-			}, (t) => [
-				index('name').on(t.id),
-				primaryKey({ columns: [t.id], name: 'custom' }),
-			]);
-
-			const { indexes, primaryKeys } = getTableConfig(table);
-
-			expect(indexes.length).toBe(1);
-			expect(primaryKeys.length).toBe(1);
-		});
-
-		test('define constraints as array inside third param', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const table = singlestoreTable('name', {
-				id: int(),
-			}, (t) => [
-				[index('name').on(t.id), primaryKey({ columns: [t.id], name: 'custom' })],
-			]);
-
-			const { indexes, primaryKeys } = getTableConfig(table);
-
-			expect(indexes.length).toBe(1);
-			expect(primaryKeys.length).toBe(1);
-		});
-
-		test.skip('set operations (mixed) from query builder', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq1 = unionAll(
-				db
-					.select()
-					.from(citiesTable).where(gt(citiesTable.id, 1)),
-				db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-			).as('sq1');
-
-			const sq2 = await db.select().from(sq1).orderBy(asc(sql`id`)).as('sq2');
-
-			const sq3 = await db.select().from(sq2).limit(1).offset(1).as('sq3');
-
-			const result = await db
-				.select()
-				.from(citiesTable)
-				.except(
-					db
-						.select()
-						.from(sq3),
-				);
-
-			expect(result).toHaveLength(2);
-
-			expect(result).toEqual([
-				{ id: 3, name: 'Tampa' },
-				{ id: 1, name: 'New York' },
-			]);
-
-			await expect((async () => {
-				db
-					.select()
-					.from(citiesTable).except(
-						({ unionAll }) =>
-							unionAll(
-								db
-									.select({ name: citiesTable.name, id: citiesTable.id })
-									.from(citiesTable).where(gt(citiesTable.id, 1)),
-								db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-							),
-					);
-			})()).rejects.toThrowError();
-		});
-
-		test('set operations (mixed all) as function with subquery', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await setupSetOperationTest(db);
-
-			const sq1 = except(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(gte(users2Table.id, 5)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 7)),
-			).as('sq1');
-
-			const sq2 = await db.select().from(sq1).orderBy(asc(sql`id`)).as('sq2');
-
-			const sq3 = await db.select().from(sq2).limit(1).as('sq3');
-
-			const result = await union(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db.select().from(sq3),
-				db
-					.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-			);
-
-			expect(result).toHaveLength(4);
-
-			// multiple results possible as a result of the filters >= 5 and ==7 because singlestore doesn't guarantee order
-			// dynamically validate results
-			const hasValidEntry = (entry: { id: number; name: string }) => {
-				if (entry.id === 1) return entry.name === 'John';
-				if (entry.id > 1 && entry.id < 5) return entry.name === 'Tampa' || entry.name === 'London';
-				if (entry.id >= 5 && entry.id !== 7) return true; // Accept any entry with id >= 5 and not 7
-				return false;
-			};
-
-			for (const entry of result) {
-				expect(hasValidEntry(entry)).toBe(true);
-			}
-
-			await expect((async () => {
-				union(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					except(
-						db
-							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table).where(gte(users2Table.id, 5)),
-						db
-							.select({ name: users2Table.name, id: users2Table.id })
-							.from(users2Table).where(eq(users2Table.id, 7)),
-					).limit(1),
-					db
-						.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-				);
-			})()).rejects.toThrowError();
-		});
-
-		test('aggregate function: count', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: count() }).from(table);
-			const result2 = await db.select({ value: count(table.a) }).from(table);
-			const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
-
-			expect(result1[0]?.value).toBe(7);
-			expect(result2[0]?.value).toBe(5);
-			expect(result3[0]?.value).toBe(6);
-		});
-
-		test('aggregate function: avg', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: avg(table.b) }).from(table);
-			const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('33.3333');
-			expect(result2[0]?.value).toBe(null);
-			expect(result3[0]?.value).toBe('42.5000');
-		});
-
-		test('aggregate function: sum', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: sum(table.b) }).from(table);
-			const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
-
-			expect(result1[0]?.value).toBe('200');
-			expect(result2[0]?.value).toBe(null);
-			expect(result3[0]?.value).toBe('170');
-		});
-
-		test('aggregate function: max', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: max(table.b) }).from(table);
-			const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(90);
-			expect(result2[0]?.value).toBe(null);
-		});
-
-		test('aggregate function: min', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = aggregateTable;
-			await setupAggregateFunctionsTest(db);
-
-			const result1 = await db.select({ value: min(table.b) }).from(table);
-			const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
-
-			expect(result1[0]?.value).toBe(10);
-			expect(result2[0]?.value).toBe(null);
-		});
-
-		test('simple vector search', async (ctx) => {
-			const { db } = ctx.singlestore;
-			const table = vectorSearchTable;
-			const embedding = [0.42, 0.93, 0.88, 0.57, 0.32, 0.64, 0.76, 0.52, 0.19, 0.81]; // ChatGPT's 10 dimension embedding for "dogs are cool" not sure how accurate but it works
-			await setupVectorSearchTest(db);
-
-			const withRankEuclidean = db.select({
-				id: table.id,
-				text: table.text,
-				rank: sql`row_number() over (order by ${euclideanDistance(table.embedding, embedding)})`.as('rank'),
-			}).from(table).as('with_rank');
-			const withRankDotProduct = db.select({
-				id: table.id,
-				text: table.text,
-				rank: sql`row_number() over (order by ${dotProduct(table.embedding, embedding)})`.as('rank'),
-			}).from(table).as('with_rank');
-			const result1 = await db.select({ id: withRankEuclidean.id, text: withRankEuclidean.text }).from(
-				withRankEuclidean,
-			).where(eq(withRankEuclidean.rank, 1));
-			const result2 = await db.select({ id: withRankDotProduct.id, text: withRankDotProduct.text }).from(
-				withRankDotProduct,
-			).where(eq(withRankDotProduct.rank, 1));
-
-			expect(result1.length).toEqual(1);
-			expect(result1[0]).toEqual({ id: 1, text: 'I like dogs' });
-
-			expect(result2.length).toEqual(1);
-			expect(result2[0]).toEqual({ id: 1, text: 'I like dogs' });
-		});
-
-		test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial not null primary key,
-					name text not null,
-					update_counter integer default 1 not null,
-					updated_at datetime(6),
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Jane' },
-				{ id: 3, name: 'Jack' },
-				{ id: 4, name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate);
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			expect(response).toEqual([
-				{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
-			]);
-			const msDelay = 750;
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.execute(
-				sql`
-					create table ${usersOnUpdate} (
-					id serial not null primary key,
-					name text not null,
-					update_counter integer default 1 not null,
-					updated_at datetime(6),
-					always_null text
-					)
-				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ id: 1, name: 'John', alwaysNull: 'this will will be null after updating' },
-				{ id: 2, name: 'Jane' },
-				{ id: 3, name: 'Jack' },
-				{ id: 4, name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-			const initial = await db.select({ id: usersOnUpdate.id, updatedAt: usersOnUpdate.updatedAt }).from(usersOnUpdate);
-
-			await db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id, 1));
-
-			const justDates = await db.select({ id: usersOnUpdate.id, updatedAt: usersOnUpdate.updatedAt }).from(
-				usersOnUpdate,
-			);
-
-			const response = await db.select().from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			expect(response).toEqual([
-				{ id: 1, name: 'Angel', updateCounter: 2, updatedAt: expect.any(Date), alwaysNull: null },
-				{ id: 2, name: 'Jane', updateCounter: 1, updatedAt: expect.any(Date), alwaysNull: null },
-				{ id: 3, name: 'Jack', updateCounter: 1, updatedAt: expect.any(Date), alwaysNull: null },
-				{ id: 4, name: 'Jill', updateCounter: 1, updatedAt: expect.any(Date), alwaysNull: null },
-			]);
-
-			const initialRecord = initial.find((record) => record.id === 1);
-			const updatedRecord = justDates.find((record) => record.id === 1);
-
-			expect(initialRecord?.updatedAt?.valueOf()).not.toBe(updatedRecord?.updatedAt?.valueOf());
-
-			const msDelay = 2000;
-
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
-
-		// mySchema tests
-		test('mySchema :: select all fields', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result[0]!.createdAt).toBeInstanceOf(Date);
-			// not timezone based timestamp, thats why it should not work here
-			// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: select sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select typed sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.select({
-				name: sql<string>`upper(${usersMySchemaTable.name})`,
-			}).from(usersMySchemaTable);
-
-			expect(users).toEqual([{ name: 'JOHN' }]);
-		});
-
-		test('mySchema :: select distinct', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const usersDistinctTable = singlestoreTable('users_distinct', {
-				id: int('id').notNull(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${usersDistinctTable}`);
-			await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
-
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]);
-			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			);
-
-			await db.execute(sql`drop table ${usersDistinctTable}`);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
-		});
-
-		test('mySchema :: insert returning sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			const [result, _] = await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
-
-			expect(result.insertId).toBe(1);
-		});
-
-		test('mySchema :: delete returning sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const users = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
-
-			expect(users[0].affectedRows).toBe(1);
-		});
-
-		test('mySchema :: update with returning partial', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
-			const updatedUsers = await db.update(usersMySchemaTable).set({ name: 'Jane' }).where(
-				eq(usersMySchemaTable.name, 'John'),
-			);
-
-			const users = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
-				usersMySchemaTable,
-			)
-				.where(
-					eq(usersMySchemaTable.id, 1),
-				);
-
-			expect(updatedUsers[0].changedRows).toBe(1);
-
-			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
-		});
-
-		test('mySchema :: delete with returning all fields', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersMySchemaTable).values({ name: 'John' });
-			const deletedUser = await db.delete(usersMySchemaTable).where(eq(usersMySchemaTable.name, 'John'));
-
-			expect(deletedUser[0].affectedRows).toBe(1);
-		});
-
-		test('mySchema :: insert + select', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
-			const result = await db.select().from(usersMySchemaTable);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
-
-			await db.insert(usersMySchemaTable).values({ id: 2, name: 'Jane' });
-			const result2 = await db.select().from(usersMySchemaTable).orderBy(asc(usersMySchemaTable.id));
-			expect(result2).toEqual([
-				{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
-				{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
-			]);
-		});
-
-		test('mySchema :: insert with overridden default values', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John', verified: true });
-			const result = await db.select().from(usersMySchemaTable);
-
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
-		});
-
-		test('mySchema :: insert many', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'] },
-				{ id: 3, name: 'Jane' },
-				{ id: 4, name: 'Austin', verified: true },
-			]);
-			const result = await db.select({
-				id: usersMySchemaTable.id,
-				name: usersMySchemaTable.name,
-				jsonb: usersMySchemaTable.jsonb,
-				verified: usersMySchemaTable.verified,
-			}).from(usersMySchemaTable)
-				.orderBy(asc(usersMySchemaTable.id));
-
-			expect(result).toEqual([
-				{ id: 1, name: 'John', jsonb: null, verified: false },
-				{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
-				{ id: 3, name: 'Jane', jsonb: null, verified: false },
-				{ id: 4, name: 'Austin', jsonb: null, verified: true },
-			]);
-		});
-
-		test('mySchema :: select with group by as field', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, {
-				id: 3,
-				name: 'Jane',
-			}]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.name)
-				.orderBy(asc(usersMySchemaTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
-		});
-
-		test('mySchema :: select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, {
-				id: 3,
-				name: 'Jane',
-			}]);
-
-			const result = await db.select({ name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, sql`${usersMySchemaTable.name}`)
-				.orderBy(asc(usersMySchemaTable.id));
-
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
-		});
-
-		test('mySchema :: build query', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const query = db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(usersMySchemaTable)
-				.groupBy(usersMySchemaTable.id, usersMySchemaTable.name)
-				.toSQL();
-
-			expect(query).toEqual({
-				sql:
-					`select \`id\`, \`name\` from \`mySchema\`.\`userstest\` group by \`mySchema\`.\`userstest\`.\`id\`, \`mySchema\`.\`userstest\`.\`name\``,
-				params: [],
-			});
-		});
-
-		test('mySchema :: insert with spaces', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: sql`'Jo   h     n'` });
-			const result = await db.select({ id: usersMySchemaTable.id, name: usersMySchemaTable.name }).from(
-				usersMySchemaTable,
-			);
-
-			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
-		});
-
-		test('mySchema :: prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.insert(usersMySchemaTable).values({ id: 1, name: 'John' });
-			const stmt = db.select({
-				id: usersMySchemaTable.id,
-				name: usersMySchemaTable.name,
-			}).from(usersMySchemaTable)
-				.where(eq(usersMySchemaTable.id, sql.placeholder('id')))
-				.prepare();
-			const result = await stmt.execute({ id: 1 });
-
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
-
-		test('mySchema :: select from tables with same name from different schema using alias', async (ctx) => {
-			const { db } = ctx.singlestore;
-			await db.execute(sql`truncate table \`mySchema\`.\`userstest\``);
-
-			await db.execute(sql`drop table if exists \`userstest\``);
-			await db.execute(
-				sql`
-					create table \`userstest\` (
-					    \`id\` serial primary key,
-					    \`name\` text not null,
-					    \`verified\` boolean not null default false,
-					    \`jsonb\` json,
-					    \`created_at\` timestamp not null default now()
-					)
-				`,
-			);
-
-			await db.insert(usersMySchemaTable).values({ id: 10, name: 'Ivan' });
-			await db.insert(usersTable).values({ id: 11, name: 'Hans' });
-
-			const customerAlias = alias(usersTable, 'customer');
-
-			const result = await db
-				.select().from(usersMySchemaTable)
-				.leftJoin(customerAlias, eq(customerAlias.id, 11))
-				.where(eq(usersMySchemaTable.id, 10));
-
-			expect(result).toEqual([{
-				userstest: {
-					id: 10,
-					name: 'Ivan',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.userstest.createdAt,
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
-					verified: false,
-					jsonb: null,
-					createdAt: result[0]!.customer!.createdAt,
-				},
-			}]);
-		});
-
-		test('insert $returningId: serial as id', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db.insert(usersTable).values({ id: 1, name: 'John' }).$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				id: number;
-			}[]>();
-
-			expect(result).toStrictEqual([{ id: 1 }]);
-		});
-
-		test('insert $returningId: serial as id, batch insert', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const result = await db.insert(usersTable).values([{ id: 1, name: 'John' }, { id: 2, name: 'John1' }])
-				.$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				id: number;
-			}[]>();
-
-			// singlestore auto increments when batch inserting, so the ids increment by one
-			expect(result).toStrictEqual([{ id: 2 }, { id: 3 }]);
-		});
-
-		test('insert $returningId: $default as primary key', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
-			let iterator = 0;
-
-			const usersTableDefFn = singlestoreTable('users_default_fn', {
-				customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
-					const value = uniqueKeys[iterator]!;
-					iterator++;
-					return value;
-				}),
-				name: text('name').notNull(),
-			});
-
-			await setupReturningFunctionsTest(db);
-
-			const result = await db.insert(usersTableDefFn).values([{ name: 'John' }, { name: 'John1' }])
-				//    ^?
-				.$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				customId: string;
-			}[]>();
-
-			expect(result).toStrictEqual([{ customId: 'ao865jf3mcmkfkk8o5ri495z' }, {
-				customId: 'dyqs529eom0iczo2efxzbcut',
-			}]);
-		});
-
-		test('insert $returningId: $default as primary key with value', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const uniqueKeys = ['ao865jf3mcmkfkk8o5ri495z', 'dyqs529eom0iczo2efxzbcut'];
-			let iterator = 0;
-
-			const usersTableDefFn = singlestoreTable('users_default_fn', {
-				customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => {
-					const value = uniqueKeys[iterator]!;
-					iterator++;
-					return value;
-				}),
-				name: text('name').notNull(),
-			});
-
-			await setupReturningFunctionsTest(db);
-
-			const result = await db.insert(usersTableDefFn).values([{ name: 'John', customId: 'test' }, { name: 'John1' }])
-				//    ^?
-				.$returningId();
-
-			expectTypeOf(result).toEqualTypeOf<{
-				customId: string;
-			}[]>();
-
-			expect(result).toStrictEqual([{ customId: 'test' }, { customId: 'ao865jf3mcmkfkk8o5ri495z' }]);
-		});
-
-		// TODO: Unkip this test when views are supported
-		/* test.skip('mySchema :: view', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const newYorkers1 = mySchema.view('new_yorkers')
-				.as((qb) => qb.select().from(users2MySchemaTable).where(eq(users2MySchemaTable.cityId, 1)));
-
-			const newYorkers2 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).as(sql`select * from ${users2MySchemaTable} where ${eq(users2MySchemaTable.cityId, 1)}`);
-
-			const newYorkers3 = mySchema.view('new_yorkers', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-				cityId: int('city_id').notNull(),
-			}).existing();
-
-			await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
-
-			await db.insert(citiesMySchemaTable).values([{ id: 1, name: 'New York' }, { id: 2, name: 'Paris' }]);
-
-			await db.insert(users2MySchemaTable).values([
-				{ id: 1, name: 'John', cityId: 1 },
-				{ id: 2, name: 'Jane', cityId: 1 },
-				{ id: 3, name: 'Jack', cityId: 2 },
-			]);
-
-			{
-				const result = await db.select().from(newYorkers1).orderBy(asc(newYorkers1.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers2).orderBy(asc(newYorkers2.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select().from(newYorkers3).orderBy(asc(newYorkers3.id));
-				expect(result).toEqual([
-					{ id: 1, name: 'John', cityId: 1 },
-					{ id: 2, name: 'Jane', cityId: 1 },
-				]);
-			}
-
-			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).orderBy(asc(newYorkers1.id));
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-			}
-
-			await db.execute(sql`drop view ${newYorkers1}`);
-		}); */
-
-		test('limit 0', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(0);
-
-			expect(users).toEqual([]);
-		});
-
-		test('limit -1', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.insert(usersTable).values({ name: 'John' });
-			const users = await db
-				.select()
-				.from(usersTable)
-				.limit(-1);
-
-			expect(users.length).toBeGreaterThan(0);
-		});
-
-		test('sql operator as cte', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			const users = singlestoreTable('users', {
-				id: serial('id').primaryKey(),
-				name: text('name').notNull(),
-			});
-
-			await db.execute(sql`drop table if exists ${users}`);
-			await db.execute(sql`create table ${users} (id serial not null primary key, name text not null)`);
-			await db.insert(users).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-			]);
-
-			const sq1 = db.$with('sq', {
-				userId: users.id,
-				data: {
-					name: users.name,
-				},
-			}).as(sql`select * from ${users} where ${users.name} = 'John'`);
-			const result1 = await db.with(sq1).select().from(sq1);
-
-			const sq2 = db.$with('sq', {
-				userId: users.id,
-				data: {
-					name: users.name,
-				},
-			}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
-			const result2 = await db.with(sq2).select().from(sq1);
-
-			expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
-			expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
-		});
-
-		test('cross join', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
-
-			await db
-				.insert(citiesTable)
-				.values([
-					{ name: 'Seattle' },
-					{ name: 'New York City' },
-				]);
-
-			const result = await db
-				.select({
-					user: usersTable.name,
-					city: citiesTable.name,
-				})
-				.from(usersTable)
-				.crossJoin(citiesTable)
-				.orderBy(usersTable.name, citiesTable.name);
-
-			expect(result).toStrictEqual([
-				{ city: 'New York City', user: 'Jane' },
-				{ city: 'Seattle', user: 'Jane' },
-				{ city: 'New York City', user: 'John' },
-				{ city: 'Seattle', user: 'John' },
-			]);
-		});
-
-		test('left join (lateral)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.leftJoinLateral(sq, sql`true`)
-				.orderBy(citiesTable.id);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-				{ cityId: 2, cityName: 'London', userId: null, userName: null },
-			]);
-		});
-
-		test('inner join (lateral)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.innerJoinLateral(sq, sql`true`);
-
-			expect(res).toStrictEqual([
-				{ cityId: 1, cityName: 'Paris', userId: 1, userName: 'John' },
-			]);
-		});
-
-		test('cross join (lateral)', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db
-				.insert(citiesTable)
-				.values([{ id: 1, name: 'Paris' }, { id: 2, name: 'London' }]);
-
-			await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 2 }, {
-				name: 'Patrick',
-				cityId: 2,
-			}]);
-
-			const sq = db
-				.select({
-					userId: users2Table.id,
-					userName: users2Table.name,
-					cityId: users2Table.cityId,
-				})
-				.from(users2Table)
-				.where(eq(users2Table.cityId, citiesTable.id))
-				.as('sq');
-
-			const res = await db
-				.select({
-					cityId: citiesTable.id,
-					cityName: citiesTable.name,
-					userId: sq.userId,
-					userName: sq.userName,
-				})
-				.from(citiesTable)
-				.crossJoinLateral(sq)
-				.orderBy(sq.userId, citiesTable.id);
-
-			expect(res).toStrictEqual([
-				{
-					cityId: 1,
-					cityName: 'Paris',
-					userId: 1,
-					userName: 'John',
-				},
-				{
-					cityId: 2,
-					cityName: 'London',
-					userId: 2,
-					userName: 'Jane',
-				},
-				{
-					cityId: 2,
-					cityName: 'London',
-					userId: 3,
-					userName: 'Patrick',
-				},
-			]);
-		});
-
-		test('all types', async (ctx) => {
-			const { db } = ctx.singlestore;
-
-			await db.execute(sql`
-				CREATE TABLE \`all_types\` (
-						\`scol\` serial,
-						\`bigint53\` bigint,
-						\`bigint64\` bigint,
-						\`binary\` binary,
-						\`boolean\` boolean,
-						\`char\` char,
-						\`date\` date,
-						\`date_str\` date,
-						\`datetime\` datetime,
-						\`datetime_str\` datetime,
-						\`decimal\` decimal,
-						\`decimal_num\` decimal(30),
-						\`decimal_big\` decimal(30),
-						\`double\` double,
-						\`float\` float,
-						\`int\` int,
-						\`json\` json,
-						\`med_int\` mediumint,
-						\`small_int\` smallint,
-						\`real\` real,
-						\`text\` text,
-						\`time\` time,
-						\`timestamp\` timestamp,
-						\`timestamp_str\` timestamp,
-						\`tiny_int\` tinyint,
-						\`varbin\` varbinary(16),
-						\`varchar\` varchar(255),
-						\`year\` year,
-						\`enum\` enum('enV1','enV2'),
-						shard key(\`scol\`)
-					);
-			`);
-
-			await db.insert(allTypesTable).values({
-				serial: 1,
-				bigint53: 9007199254740991,
-				bigint64: 5044565289845416380n,
-				binary: '1',
-				boolean: true,
-				char: 'c',
-				date: new Date(1741743161623),
-				dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				datetime: new Date(1741743161623),
-				datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				decimal: '47521',
-				decimalNum: 9007199254740991,
-				decimalBig: 5044565289845416380n,
-				double: 15.35325689124218,
-				enum: 'enV1',
-				float: 1.048596,
-				real: 1.048596,
-				text: 'C4-',
-				int: 621,
-				json: {
-					str: 'strval',
-					arr: ['str', 10],
-				},
-				medInt: 560,
-				smallInt: 14,
-				time: '04:13:22',
-				timestamp: new Date(1741743161623),
-				timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
-				tinyInt: 7,
-				varbin: '1010110101001101',
-				varchar: 'VCHAR',
-				year: 2025,
-			});
-
-			const rawRes = await db.select().from(allTypesTable);
-
-			type ExpectedType = {
-				serial: number;
-				bigint53: number | null;
-				bigint64: bigint | null;
-				binary: string | null;
-				boolean: boolean | null;
-				char: string | null;
-				date: Date | null;
-				dateStr: string | null;
-				datetime: Date | null;
-				datetimeStr: string | null;
-				decimal: string | null;
-				decimalNum: number | null;
-				decimalBig: bigint | null;
-				double: number | null;
-				float: number | null;
-				int: number | null;
-				json: unknown;
-				medInt: number | null;
-				smallInt: number | null;
-				real: number | null;
-				text: string | null;
-				time: string | null;
-				timestamp: Date | null;
-				timestampStr: string | null;
-				tinyInt: number | null;
-				varbin: string | null;
-				varchar: string | null;
-				year: number | null;
-				enum: 'enV1' | 'enV2' | null;
-			}[];
-
-			const expectedRes: ExpectedType = [
-				{
-					serial: 1,
-					bigint53: 9007199254740991,
-					bigint64: 5044565289845416380n,
-					binary: '1',
-					boolean: true,
-					char: 'c',
-					date: new Date('2025-03-12T00:00:00.000Z'),
-					dateStr: '2025-03-12',
-					datetime: new Date('2025-03-12T01:32:41.000Z'),
-					datetimeStr: '2025-03-12 01:32:41',
-					decimal: '47521',
-					decimalNum: 9007199254740991,
-					decimalBig: 5044565289845416380n,
-					double: 15.35325689124218,
-					float: 1.0486,
-					int: 621,
-					json: { arr: ['str', 10], str: 'strval' },
-					medInt: 560,
-					smallInt: 14,
-					real: 1.048596,
-					text: 'C4-',
-					time: '04:13:22',
-					timestamp: new Date('2025-03-12T01:32:41.000Z'),
-					timestampStr: '2025-03-12 01:32:41',
-					tinyInt: 7,
-					varbin: '1010110101001101',
-					varchar: 'VCHAR',
-					year: 2025,
-					enum: 'enV1',
-				},
-			];
-
-			expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
-			expect(rawRes).toStrictEqual(expectedRes);
-		});
-	});
-}
diff --git a/integration-tests/tests/singlestore/singlestore-custom.test.ts b/integration-tests/tests/singlestore/singlestore-custom.test.ts
index ac0558c0fa..4bc3648290 100644
--- a/integration-tests/tests/singlestore/singlestore-custom.test.ts
+++ b/integration-tests/tests/singlestore/singlestore-custom.test.ts
@@ -1,5 +1,4 @@
 import retry from 'async-retry';
-import type Docker from 'dockerode';
 import { asc, eq, Name, placeholder, sql } from 'drizzle-orm';
 import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
 import { drizzle } from 'drizzle-orm/singlestore';
@@ -23,23 +22,22 @@ import * as mysql2 from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
 import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
 import { toLocalDate } from '~/utils';
-import { createDockerDB } from './singlestore-common';
-
-const ENABLE_LOGGING = false;
+import relations from './relations';
+
+type TestSingleStoreDB = SingleStoreDriverDatabase<any, typeof relations>;
+declare module 'vitest' {
+	interface TestContext {
+		singlestore: {
+			db: TestSingleStoreDB;
+		};
+	}
+}
 
-let db: SingleStoreDriverDatabase;
+let db: SingleStoreDriverDatabase<never, typeof relations>;
 let client: mysql2.Connection;
-let container: Docker.Container | undefined;
 
 beforeAll(async () => {
-	let connectionString;
-	if (process.env['SINGLESTORE_CONNECTION_STRING']) {
-		connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
+	const connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
 	client = await retry(async () => {
 		client = await mysql2.createConnection({ uri: connectionString, supportBigNumbers: true });
 		await client.connect();
@@ -56,12 +54,11 @@ beforeAll(async () => {
 	});
 	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle;`);
 	await client.changeUser({ database: 'drizzle' });
-	db = drizzle(client, { logger: ENABLE_LOGGING });
+	db = drizzle({ client, relations });
 });
 
 afterAll(async () => {
 	await client?.end();
-	await container?.stop().catch(console.error);
 });
 
 beforeEach((ctx) => {
diff --git a/integration-tests/tests/singlestore/singlestore-prefixed.test.ts b/integration-tests/tests/singlestore/singlestore-prefixed.test.ts
index 7c5d63322c..5822c4b0e4 100644
--- a/integration-tests/tests/singlestore/singlestore-prefixed.test.ts
+++ b/integration-tests/tests/singlestore/singlestore-prefixed.test.ts
@@ -1,7 +1,6 @@
 import retry from 'async-retry';
-import type Docker from 'dockerode';
-import type { Equal } from 'drizzle-orm';
 import { asc, eq, getTableName, gt, inArray, Name, sql, TransactionRollbackError } from 'drizzle-orm';
+import type { Equal } from 'drizzle-orm';
 import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
 import { drizzle } from 'drizzle-orm/singlestore';
 import {
@@ -26,23 +25,16 @@ import { migrate } from 'drizzle-orm/singlestore/migrator';
 import * as mysql2 from 'mysql2/promise';
 import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
 import { Expect, toLocalDate } from '~/utils';
-import { createDockerDB } from './singlestore-common';
 
 const ENABLE_LOGGING = false;
 
 let db: SingleStoreDriverDatabase;
 let client: mysql2.Connection;
-let container: Docker.Container | undefined;
 
 beforeAll(async () => {
-	let connectionString;
-	if (process.env['SINGLESTORE_CONNECTION_STRING']) {
-		connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr, container: contrainerObj } = await createDockerDB();
-		connectionString = conStr;
-		container = contrainerObj;
-	}
+	const connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
+	if (!connectionString) throw new Error();
+
 	client = await retry(async () => {
 		client = await mysql2.createConnection({ uri: connectionString, supportBigNumbers: true });
 		await client.connect();
@@ -60,12 +52,11 @@ beforeAll(async () => {
 
 	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle;`);
 	await client.changeUser({ database: 'drizzle' });
-	db = drizzle(client, { logger: ENABLE_LOGGING });
+	db = drizzle({ client, logger: ENABLE_LOGGING });
 });
 
 afterAll(async () => {
 	await client?.end();
-	await container?.stop().catch(console.error);
 });
 
 const tablePrefix = 'drizzle_tests_';
diff --git a/integration-tests/tests/singlestore/singlestore-proxy.test.ts b/integration-tests/tests/singlestore/singlestore-proxy.test.ts
index 9fce172e05..be23f8c3c3 100644
--- a/integration-tests/tests/singlestore/singlestore-proxy.test.ts
+++ b/integration-tests/tests/singlestore/singlestore-proxy.test.ts
@@ -1,132 +1,7 @@
-import retry from 'async-retry';
-import type { SingleStoreRemoteDatabase } from 'drizzle-orm/singlestore-proxy';
-import { drizzle as proxyDrizzle } from 'drizzle-orm/singlestore-proxy';
-import * as mysql2 from 'mysql2/promise';
-import { afterAll, beforeAll, beforeEach } from 'vitest';
-import { skipTests } from '~/common';
-import { createDockerDB, tests } from './singlestore-common';
+import { tests } from './common';
+import { proxyTest } from './instrumentation';
 
-const ENABLE_LOGGING = false;
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-class ServerSimulator {
-	constructor(private db: mysql2.Connection) {}
-
-	async query(sql: string, params: any[], method: 'all' | 'execute') {
-		if (method === 'all') {
-			try {
-				const result = await this.db.query({
-					sql,
-					values: params,
-					rowsAsArray: true,
-					typeCast: function(field: any, next: any) {
-						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-							return field.string();
-						}
-						return next();
-					},
-				});
-
-				return { data: result[0] as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else if (method === 'execute') {
-			try {
-				const result = await this.db.query({
-					sql,
-					values: params,
-					typeCast: function(field: any, next: any) {
-						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-							return field.string();
-						}
-						return next();
-					},
-				});
-
-				return { data: result as any };
-			} catch (e: any) {
-				return { error: e };
-			}
-		} else {
-			return { error: 'Unknown method value' };
-		}
-	}
-
-	async migrations(queries: string[]) {
-		await this.db.query('START TRANSACTION');
-		try {
-			for (const query of queries) {
-				await this.db.query(query);
-			}
-			await this.db.query('COMMIT');
-		} catch (e) {
-			await this.db.query('ROLLBACK');
-			throw e;
-		}
-
-		return {};
-	}
-}
-
-let db: SingleStoreRemoteDatabase;
-let client: mysql2.Connection;
-let serverSimulator: ServerSimulator;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['SINGLESTORE_CONNECTION_STRING']) {
-		connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = await mysql2.createConnection({ uri: connectionString, supportBigNumbers: true });
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-
-	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle;`);
-	await client.changeUser({ database: 'drizzle' });
-
-	serverSimulator = new ServerSimulator(client);
-	db = proxyDrizzle(async (sql, params, method) => {
-		try {
-			const response = await serverSimulator.query(sql, params, method);
-
-			if (response.error !== undefined) {
-				throw response.error;
-			}
-
-			return { rows: response.data };
-		} catch (e: any) {
-			console.error('Error from singlestore proxy server:', e.message);
-			throw e;
-		}
-	}, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.singlestore = {
-		db,
-	};
-});
-
-skipTests([
+const exclude = [
 	'select iterator w/ prepared statement',
 	'select iterator',
 	'nested transaction rollback',
@@ -135,6 +10,14 @@ skipTests([
 	'transaction',
 	'transaction with options (set isolationLevel)',
 	'migrator',
-]);
-
-tests();
+	'RQB v2 transaction find first - no rows',
+	'RQB v2 transaction find first - multiple rows',
+	'RQB v2 transaction find first - with relation',
+	'RQB v2 transaction find first - placeholders',
+	'RQB v2 transaction find many - no rows',
+	'RQB v2 transaction find many - multiple rows',
+	'RQB v2 transaction find many - with relation',
+	'RQB v2 transaction find many - placeholders',
+];
+
+tests(proxyTest, exclude);
diff --git a/integration-tests/tests/singlestore/singlestore.relations.ts b/integration-tests/tests/singlestore/singlestore.relations.ts
new file mode 100644
index 0000000000..de78deffe9
--- /dev/null
+++ b/integration-tests/tests/singlestore/singlestore.relations.ts
@@ -0,0 +1,174 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './singlestore.schema';
+
+export default defineRelations(schema, (r) => ({
+	usersView: {
+		posts: r.many.postsTable(),
+		groups: r.many.groupsTable(),
+	},
+	schemaUsersView: {
+		posts: r.many.schemaPosts(),
+		groups: r.many.schemaGroups(),
+	},
+	usersTable: {
+		alltypes: r.many.allTypesTable({
+			from: r.usersTable.id,
+			to: r.allTypesTable.serial,
+		}),
+		invitee: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+		}),
+		inviteeRequired: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		usersToGroups: r.many.usersToGroupsTable(),
+		posts: r.many.postsTable(),
+		postsFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				ownerId: 2,
+			},
+			alias: 'author-filtered',
+		}),
+		postsAltFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				content: {
+					like: '%.1',
+				},
+			},
+			alias: 'author-alt-filtered',
+		}),
+		group: r.one.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+		}),
+		groups: r.many.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			alias: 'users-groups-direct',
+		}),
+		groupsFiltered: r.many.groupsTable({
+			alias: 'users-groups-direct-filtered',
+		}),
+	},
+	groupsTable: {
+		usersToGroups: r.many.usersToGroupsTable(),
+		user: r.one.usersTable(),
+		users: r.many.usersTable({
+			alias: 'users-groups-direct',
+		}),
+		usersFiltered: r.many.usersTable({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+			alias: 'users-groups-direct-filtered',
+		}),
+	},
+	usersToGroupsTable: {
+		group: r.one.groupsTable({
+			from: r.usersToGroupsTable.groupId,
+			to: r.groupsTable.id,
+			optional: false,
+		}),
+		user: r.one.usersTable({
+			from: r.usersToGroupsTable.userId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	postsTable: {
+		author: r.one.usersTable({
+			from: r.postsTable.ownerId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		authorFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-filtered',
+		}),
+		authorAltFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-alt-filtered',
+		}),
+		comments: r.many.commentsTable(),
+	},
+	commentsTable: {
+		post: r.one.postsTable({
+			from: r.commentsTable.postId,
+			to: r.postsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentsTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		likes: r.many.commentLikesTable(),
+	},
+	commentLikesTable: {
+		comment: r.one.commentsTable({
+			from: r.commentLikesTable.commentId,
+			to: r.commentsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentLikesTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	schemaUsers: {
+		posts: r.many.schemaPosts({
+			from: r.schemaUsers.id,
+			to: r.schemaPosts.ownerId,
+			where: {
+				content: {
+					like: 'M%',
+				},
+			},
+		}),
+		groups: r.many.schemaGroups({
+			from: r.schemaUsers.id.through(r.schemaUsersToGroups.userId),
+			to: r.schemaGroups.id.through(r.schemaUsersToGroups.groupId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+		}),
+	},
+	schemaPosts: {
+		author: r.one.schemaUsers(),
+	},
+	schemaGroups: {
+		users: r.many.schemaUsers(),
+	},
+	students: {
+		courseOfferings: r.many.courseOfferings({
+			from: r.students.studentId.through(r.studentGrades.studentId),
+			to: [
+				r.courseOfferings.courseId.through(r.studentGrades.courseId),
+				r.courseOfferings.semester.through(r.studentGrades.semester),
+			],
+		}),
+	},
+	courseOfferings: {
+		students: r.many.students(),
+	},
+	customTypesTable: {
+		self: r.many.customTypesTable({
+			from: r.customTypesTable.id,
+			to: r.customTypesTable.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/singlestore/singlestore.rels.test.ts b/integration-tests/tests/singlestore/singlestore.rels.test.ts
new file mode 100644
index 0000000000..95e2a8a31a
--- /dev/null
+++ b/integration-tests/tests/singlestore/singlestore.rels.test.ts
@@ -0,0 +1,11326 @@
+import 'dotenv/config';
+import { DrizzleError, sql, TransactionRollbackError } from 'drizzle-orm';
+import { drizzle, type SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
+import { alias } from 'drizzle-orm/singlestore-core';
+import * as mysql from 'mysql2/promise';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './singlestore.relations';
+import {
+	allTypesTable,
+	commentsTable,
+	courseOfferings,
+	customTypesTable,
+	groupsTable,
+	postsTable,
+	schemaGroups,
+	schemaPosts,
+	schemaUsers,
+	schemaUsersToGroups,
+	studentGrades,
+	students,
+	usersTable,
+	usersToGroupsTable,
+} from './singlestore.schema';
+
+const ENABLE_LOGGING = false;
+
+declare module 'vitest' {
+	export interface TestContext {
+		singlestoreDbV2: SingleStoreDriverDatabase<never, typeof relations>;
+		singlestoreClient: mysql.Connection;
+	}
+}
+
+let db: SingleStoreDriverDatabase<never, typeof relations>;
+let client: mysql.Connection;
+
+beforeAll(async () => {
+	const connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
+	if (!connectionString) {
+		throw new Error(
+			'SINGLESTORE_CONNECTION_STRING is not set. Bring DBs up with `bash compose/dockers.sh up singlestore` and export the connection string before running tests.',
+		);
+	}
+
+	const sleep = 1000;
+	let timeLeft = 30000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			client = await mysql.createConnection({
+				uri: connectionString,
+				supportBigNumbers: true,
+				bigNumberStrings: true,
+			});
+			await client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to MySQL');
+		await client?.end().catch(console.error);
+		throw lastError;
+	}
+	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle_rqb;`);
+	await client.changeUser({ database: 'drizzle_rqb' });
+	db = drizzle({ client, relations, logger: ENABLE_LOGGING });
+});
+
+afterAll(async () => {
+	await client?.end().catch(console.error);
+});
+
+beforeEach(async (ctx) => {
+	ctx.singlestoreDbV2 = db;
+	ctx.singlestoreClient = client;
+
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`users\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`users\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`groups\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`groups\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`users_to_groups\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`users_to_groups\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`posts\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`rqb_test_schema\`.\`posts\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`comments\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`comment_likes\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`all_types\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`custom_types\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`course_offerings\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`student_grades\``);
+	await ctx.singlestoreDbV2.execute(sql`drop table if exists \`students\``);
+
+	await ctx.singlestoreDbV2.execute(sql`create schema if not exists \`rqb_test_schema\``);
+
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` boolean DEFAULT false NOT NULL,
+			    \`invited_by\` bigint
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`users\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` boolean DEFAULT false NOT NULL,
+			    \`invited_by\` bigint
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`groups\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`description\` text
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`groups\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`description\` text
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`users_to_groups\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`user_id\` bigint,
+			    \`group_id\` bigint
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`users_to_groups\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`user_id\` bigint,
+			    \`group_id\` bigint
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`posts\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`owner_id\` bigint,
+			    \`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`rqb_test_schema\`.\`posts\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`owner_id\` bigint,
+			    \`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`comments\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`creator\` bigint,
+			    \`post_id\` bigint,
+			    \`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`comment_likes\` (
+			    \`id\` serial PRIMARY KEY NOT NULL,
+			    \`creator\` bigint,
+			    \`comment_id\` bigint,
+			    \`created_at\` timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`course_offerings\` (
+			    \`course_id\` integer NOT NULL,
+			    \`semester\` varchar(10) NOT NULL,
+			    CONSTRAINT \`course_offerings_pkey\` PRIMARY KEY(\`course_id\`,\`semester\`)
+			)
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`student_grades\` (
+			    \`student_id\` integer NOT NULL,
+			    \`course_id\` integer NOT NULL,
+			    \`semester\` varchar(10) NOT NULL,
+			    \`grade\` char(2),
+			    CONSTRAINT \`student_grades_pkey\` PRIMARY KEY(\`student_id\`,\`course_id\`,\`semester\`)
+			);
+		`,
+	);
+	await ctx.singlestoreDbV2.execute(
+		sql`
+			CREATE TABLE \`students\` (
+			    \`student_id\` serial PRIMARY KEY NOT NULL,
+			    \`name\` text NOT NULL
+			);
+		`,
+	);
+});
+
+test('[Find Many] Get users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toStrictEqual(expect.arrayContaining([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	}]));
+});
+
+test('[Find Many] Get users with posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', async () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', async () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]);
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]);
+
+		tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 1, content: 'Post1.2' },
+		{ id: 3, ownerId: 1, content: 'Post1.3' },
+		{ id: 4, ownerId: 2, content: 'Post2' },
+		{ id: 5, ownerId: 2, content: 'Post2.1' },
+		{ id: 6, ownerId: 3, content: 'Post3' },
+		{ id: 7, ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test('[Find Many] Get only custom fields + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: expect.arrayContaining([{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }]),
+	});
+});
+
+test('[Find Many] Get only custom fields + where + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+});
+
+test('[Find One] Get only custom fields + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: expect.arrayContaining([{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }]),
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(
+		async () =>
+			await db.query.usersTable.findMany({
+				columns: {},
+			}),
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+test('[Find One] Get deep select {}', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts + prepared limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [
+					{
+						eq: sql.placeholder('id'),
+					},
+					3,
+				],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', async () => {
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(false);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: false, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	}]);
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: false,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: false, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[2]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 3,
+					content: 'Comment3',
+					creator: 3,
+					postId: 3,
+					createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]);
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: ({ id }, { exists, eq }) =>
+				exists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(sql`1`, id))),
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(1);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: expect.arrayContaining([{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}]),
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual(
+		expect.arrayContaining(
+			[{
+				id: 1,
+				name: 'Group1',
+				description: null,
+				usersToGroups: [{
+					user: {
+						id: 1,
+						name: 'Dan',
+						verified: false,
+						invitedBy: null,
+					},
+				}],
+			}, {
+				id: 2,
+				name: 'Group2',
+				description: null,
+				usersToGroups: [{
+					user: {
+						id: 2,
+						name: 'Andrew',
+						verified: false,
+						invitedBy: null,
+					},
+				}],
+			}],
+		),
+	);
+});
+
+test('[Find Many] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	}]);
+});
+
+test('[Find Many] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	}]);
+});
+
+test('[Find Many] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: (groupsTable) => sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: boolean;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: expect.arrayContaining([{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: false,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}]),
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: false,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Force optional on where on non-optional relation query', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: false, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: false,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: boolean;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: expect.arrayContaining([
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		]),
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get custom schema users with filtered posts + where', async () => {
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.schemaUsers.findMany({
+		with: {
+			posts: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%2.%',
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				gte: 2,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [
+			{ ownerId: 2, content: 'Message2.1' },
+			{ ownerId: 2, content: 'Message2.2' },
+			{ ownerId: 2, content: 'Message2.3' },
+		],
+	}]);
+});
+
+test('[Find Many] Get custom schema posts with filtered authors + where', async () => {
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaPosts).values([
+		{ id: 1, ownerId: 1, content: 'Message1.1' },
+		{ id: 2, ownerId: 2, content: 'Message2.1' },
+		{ id: 3, ownerId: 3, content: 'Message3.1' },
+		{ id: 4, ownerId: 1, content: 'Message1.2' },
+		{ id: 5, ownerId: 2, content: 'Message2.2' },
+		{ id: 6, ownerId: 3, content: 'Message3.2' },
+		{ id: 7, ownerId: 1, content: 'Message1.3' },
+		{ id: 8, ownerId: 2, content: 'Message2.3' },
+		{ id: 9, ownerId: 3, content: 'Message3.3' },
+		{ id: 10, ownerId: 1, content: 'Post1.1' },
+		{ id: 11, ownerId: 2, content: 'Post2.1' },
+		{ id: 12, ownerId: 3, content: 'Post3.1' },
+		{ id: 13, ownerId: 1, content: 'Post1.2' },
+		{ id: 14, ownerId: 2, content: 'Post2.2' },
+		{ id: 15, ownerId: 3, content: 'Post3.2' },
+		{ id: 16, ownerId: 1, content: 'Post1.3' },
+		{ id: 17, ownerId: 2, content: 'Post2.3' },
+		{ id: 18, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const posts = await db.query.schemaPosts.findMany({
+		columns: {
+			content: true,
+		},
+		with: {
+			author: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		content: string;
+		author: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	expect(posts).toStrictEqual([
+		{ content: 'Post3.3', author: null },
+		{ content: 'Post2.3', author: null },
+		{ content: 'Post1.3', author: null },
+		{ content: 'Post3.2', author: null },
+		{ content: 'Post2.2', author: null },
+		{ content: 'Post1.2', author: null },
+		{ content: 'Post3.1', author: null },
+		{ content: 'Post2.1', author: null },
+		{ content: 'Post1.1', author: null },
+		{ content: 'Message3.3', author: null },
+		{ content: 'Message2.3', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.3', author: null },
+		{ content: 'Message3.2', author: null },
+		{ content: 'Message2.2', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.2', author: null },
+		{ content: 'Message3.1', author: null },
+		{ content: 'Message2.1', author: { id: 2, name: 'Andrew' } },
+		{ content: 'Message1.1', author: null },
+	]);
+});
+
+test('[Find Many .through] Get custom schema users with filtered groups + where', async () => {
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaUsers.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get custom schema groups with filtered users + where', async () => {
+	await db.insert(schemaUsers).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(schemaGroups).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(schemaUsersToGroups).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.schemaGroups.findMany({
+		with: {
+			users: {
+				where: { id: { lt: 3 } },
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: boolean;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many] Get users + filter users by posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter posts by author', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: expect.arrayContaining([{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}]),
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(5000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+			posts: expect.arrayContaining([{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}]),
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: false,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: false,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async (ctx) => {
+	const { singlestoreDbV2: db } = ctx;
+
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 1,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id1: 1,
+		id2: 2,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = await query.execute({
+		id: 3,
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: false,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(45000);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: boolean;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: false,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.students.findMany({
+		with: {
+			courseOfferings: {
+				orderBy: {
+					courseId: 'asc',
+					semester: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			studentId: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		studentId: number;
+		name: string;
+		courseOfferings: {
+			courseId: number;
+			semester: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			name: 'First',
+			studentId: 1,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+				{
+					courseId: 2,
+					semester: 's2',
+				},
+			],
+		},
+		{
+			name: 'Second',
+			studentId: 2,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+			],
+		},
+		{
+			name: 'Third',
+			studentId: 3,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's2',
+				},
+				{
+					courseId: 2,
+					semester: 's3',
+				},
+				{
+					courseId: 4,
+					semester: 's4',
+				},
+			],
+		},
+		{
+			name: 'Fourth',
+			studentId: 4,
+			courseOfferings: expect.arrayContaining([
+				{
+					courseId: 3,
+					semester: 's1',
+				},
+				{
+					courseId: 4,
+					semester: 's3',
+				},
+			]),
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count - reverse', async () => {
+	await db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]);
+
+	await db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]);
+
+	await db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]);
+
+	const res = await db.query.courseOfferings.findMany({
+		with: {
+			students: {
+				orderBy: {
+					studentId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			courseId: 'asc',
+			semester: 'asc',
+		},
+	});
+
+	expectTypeOf(res).toEqualTypeOf<{
+		courseId: number;
+		semester: string;
+		students: {
+			studentId: number;
+			name: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			courseId: 1,
+			semester: 's1',
+			students: expect.arrayContaining([
+				{
+					name: 'First',
+					studentId: 1,
+				},
+				{
+					name: 'Second',
+					studentId: 2,
+				},
+			]),
+		},
+		{
+			courseId: 1,
+			semester: 's2',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's2',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's3',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's1',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 3,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's3',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 4,
+			semester: 's4',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+	]);
+});
+
+test('alltypes', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`all_types\` (
+			\`scol\` serial,
+			\`bigint53\` bigint,
+			\`bigint64\` bigint,
+			\`bigint_string\` bigint,
+			\`binary\` binary,
+			\`boolean\` boolean,
+			\`char\` char,
+			\`date\` date,
+			\`date_str\` date,
+			\`datetime\` datetime,
+			\`datetime_str\` datetime,
+			\`decimal\` decimal,
+			\`decimal_num\` decimal(30),
+			\`decimal_big\` decimal(30),
+			\`double\` double,
+			\`float\` float,
+			\`int\` int,
+			\`json\` json,
+			\`med_int\` mediumint,
+			\`small_int\` smallint,
+			\`real\` real,
+			\`text\` text,
+			\`time\` time,
+			\`timestamp\` timestamp,
+			\`timestamp_str\` timestamp,
+			\`tiny_int\` tinyint,
+			\`varbin\` varbinary(16),
+			\`varchar\` varchar(255),
+			\`year\` year,
+			\`enum\` enum('enV1','enV2'),
+		  	\`vec_i8\` vector(5, I8),
+		  	\`vec_i16\` vector(5, I16),
+		  	\`vec_i32\` vector(5, I32),
+		  	\`vec_i64\` vector(5, I64),
+		  	\`vec_f32\` vector(5, F32),
+		  	\`vec_f64\` vector(5, F64),
+			shard key(\`scol\`)
+		);
+	`);
+
+	await db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	});
+
+	await db.insert(allTypesTable).values({
+		serial: 1,
+		bigint53: 9007199254740991,
+		bigint64: 5044565289845416380n,
+		bigintString: '5044565289845416380',
+		binary: '1',
+		boolean: true,
+		char: 'c',
+		date: new Date(1741743161623),
+		dateStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		datetime: new Date(1741743161623),
+		datetimeStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		decimal: '47521',
+		decimalNum: 9007199254740991,
+		decimalBig: 5044565289845416380n,
+		double: 15.35325689124218,
+		enum: 'enV1',
+		float: 1.048596,
+		real: 1.048596,
+		text: 'C4-',
+		int: 621,
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		medInt: 560,
+		smallInt: 14,
+		time: '04:13:22',
+		timestamp: new Date(1741743161623),
+		timestampStr: new Date(1741743161623).toISOString().slice(0, 19).replace('T', ' '),
+		tinyInt: 7,
+		varbin: '1010110101001101',
+		varchar: 'VCHAR',
+		year: 2025,
+		vectorF32: [0.735482, -0.291647, 1.183529, -2.406378, 0.014263],
+		vectorF64: [
+			0.3918573842719283,
+			-1.682530118745203,
+			2.014963587205109,
+			-0.005832741903218165,
+			0.7841029456712038,
+		],
+		vectorI8: [-2, 8, 127, 85, -128],
+		vectorI16: [-2, 8, 127, 85, -128],
+		vectorI32: [15342, -27894, 6271, -10385, 31056],
+		vectorI64: [
+			4829301283746501823n,
+			-7203847501293847201n,
+			1623847561928374650n,
+			-5938475628374651983n,
+			803745610293847561n,
+		],
+	});
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			serial: 1,
+			bigint53: 9007199254740991,
+			bigint64: 5044565289845416380n,
+			bigintString: '5044565289845416380',
+			binary: '1',
+			boolean: true,
+			char: 'c',
+			date: new Date('2025-03-12T00:00:00.000Z'),
+			dateStr: '2025-03-12',
+			datetime: new Date('2025-03-12T01:32:41.000Z'),
+			datetimeStr: '2025-03-12 01:32:41',
+			decimal: '47521',
+			decimalNum: 9007199254740991,
+			decimalBig: 5044565289845416380n,
+			double: 15.35325689124218,
+			float: 1.0486,
+			int: 621,
+			json: { arr: ['str', 10], str: 'strval' },
+			medInt: 560,
+			smallInt: 14,
+			real: 1.048596,
+			text: 'C4-',
+			time: '04:13:22',
+			timestamp: new Date('2025-03-12T01:32:41.000Z'),
+			timestampStr: '2025-03-12 01:32:41',
+			tinyInt: 7,
+			varbin: '1010110101001101',
+			varchar: 'VCHAR',
+			year: 2025,
+			enum: 'enV1',
+			vectorF32: [...new Float32Array([0.735482, -0.291647, 1.183529, -2.406378, 0.014263])],
+			vectorF64: [
+				0.3918573842719283,
+				-1.682530118745203,
+				2.014963587205109,
+				-0.005832741903218165,
+				0.7841029456712038,
+			],
+			vectorI8: [-2, 8, 127, 85, -128],
+			vectorI16: [-2, 8, 127, 85, -128],
+			vectorI32: [15342, -27894, 6271, -10385, 31056],
+			vectorI64: [
+				4829301283746501823n,
+				-7203847501293847201n,
+				1623847561928374650n,
+				-5938475628374651983n,
+				803745610293847561n,
+			],
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	await db.execute(sql`
+		CREATE TABLE \`custom_types\` (
+		    \`id\` int,
+		    \`big\` bigint,
+		    \`bytes\` blob,
+		    \`time\` timestamp,
+		    \`int\` int
+		);
+	`);
+
+	await db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bytes: Buffer.from('BYTES'),
+		time: new Date(1741743161000),
+		int: 250,
+	});
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number | null;
+		big: bigint | null;
+		bytes: Buffer | null;
+		time: Date | null;
+		int: number | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bytes: Buffer.from('BYTES'),
+			time: new Date(1741743161000),
+			int: 250,
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/singlestore/singlestore.schema.ts b/integration-tests/tests/singlestore/singlestore.schema.ts
new file mode 100644
index 0000000000..dbe62f7e58
--- /dev/null
+++ b/integration-tests/tests/singlestore/singlestore.schema.ts
@@ -0,0 +1,343 @@
+import { relations } from 'drizzle-orm/_relations';
+import {
+	bigint,
+	binary,
+	boolean,
+	char,
+	customType,
+	date,
+	datetime,
+	decimal,
+	double,
+	float,
+	int,
+	json,
+	mediumint,
+	primaryKey,
+	real,
+	serial,
+	singlestoreEnum,
+	smallint,
+	snakeCase,
+	text,
+	time,
+	timestamp,
+	tinyint,
+	varbinary,
+	varchar,
+	vector,
+	year,
+} from 'drizzle-orm/singlestore-core';
+
+export const usersTable = snakeCase.table('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	verified: boolean().notNull().default(false),
+	invitedBy: bigint({ mode: 'number' }),
+});
+
+const schemaV1 = snakeCase.schema('schemaV1');
+
+export const usersV1 = schemaV1.table('usersV1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: bigint('invited_by', { mode: 'number' }),
+});
+
+export const usersTableV1 = schemaV1.table('users_table_V1', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	invitedBy: bigint('invited_by', { mode: 'number' }),
+});
+
+export const usersConfig = relations(usersTable, ({ one, many }) => ({
+	invitee: one(usersTable, {
+		fields: [usersTable.invitedBy],
+		references: [usersTable.id],
+	}),
+	usersToGroups: many(usersToGroupsTable),
+	posts: many(postsTable),
+	comments: many(commentsTable),
+}));
+
+export const groupsTable = snakeCase.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+export const groupsConfig = relations(groupsTable, ({ many }) => ({
+	usersToGroups: many(usersToGroupsTable),
+}));
+
+export const usersToGroupsTable = snakeCase.table(
+	'users_to_groups',
+	{
+		id: serial().primaryKey(),
+		userId: bigint({ mode: 'number' }).notNull(),
+		groupId: bigint({ mode: 'number' }).notNull(),
+	},
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
+);
+export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
+	group: one(groupsTable, {
+		fields: [usersToGroupsTable.groupId],
+		references: [groupsTable.id],
+	}),
+	user: one(usersTable, {
+		fields: [usersToGroupsTable.userId],
+		references: [usersTable.id],
+	}),
+}));
+
+export const postsTable = snakeCase.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: bigint({ mode: 'number' }),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+export const postsConfig = relations(postsTable, ({ one, many }) => ({
+	author: one(usersTable, {
+		fields: [postsTable.ownerId],
+		references: [usersTable.id],
+	}),
+	comments: many(commentsTable),
+}));
+
+export const commentsTable = snakeCase.table('comments', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	creator: bigint({ mode: 'number' }),
+	postId: bigint({ mode: 'number' }),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
+	post: one(postsTable, {
+		fields: [commentsTable.postId],
+		references: [postsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentsTable.creator],
+		references: [usersTable.id],
+	}),
+	likes: many(commentLikesTable),
+}));
+
+export const commentLikesTable = snakeCase.table('comment_likes', {
+	id: serial().primaryKey(),
+	creator: bigint({ mode: 'number' }),
+	commentId: bigint({ mode: 'number' }),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
+	comment: one(commentsTable, {
+		fields: [commentLikesTable.commentId],
+		references: [commentsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentLikesTable.creator],
+		references: [usersTable.id],
+	}),
+}));
+
+export const rqbSchema = snakeCase.schema('rqb_test_schema');
+
+export const schemaUsers = rqbSchema.table('users', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	verified: boolean().notNull().default(false),
+	invitedBy: bigint({ mode: 'number' }),
+});
+
+export const schemaPosts = rqbSchema.table('posts', {
+	id: serial().primaryKey(),
+	content: text().notNull(),
+	ownerId: bigint({ mode: 'number' }),
+	createdAt: timestamp()
+		.notNull()
+		.defaultNow(),
+});
+
+export const schemaGroups = rqbSchema.table('groups', {
+	id: serial().primaryKey(),
+	name: text().notNull(),
+	description: text(),
+});
+
+export const schemaUsersToGroups = rqbSchema.table(
+	'users_to_groups',
+	{
+		id: serial().primaryKey(),
+		userId: bigint({ mode: 'number' }).notNull(),
+		groupId: bigint({ mode: 'number' }).notNull(),
+	},
+	(t) => ({
+		pk: primaryKey(t.userId, t.groupId),
+	}),
+);
+
+export const allTypesTable = snakeCase.table('all_types', {
+	serial: serial('scol'),
+	bigint53: bigint('bigint53', {
+		mode: 'number',
+	}),
+	bigint64: bigint('bigint64', {
+		mode: 'bigint',
+	}),
+	bigintString: bigint('bigint_string', {
+		mode: 'string',
+	}),
+	binary: binary('binary'),
+	boolean: boolean('boolean'),
+	char: char('char'),
+	date: date('date', {
+		mode: 'date',
+	}),
+	dateStr: date('date_str', {
+		mode: 'string',
+	}),
+	datetime: datetime('datetime', {
+		mode: 'date',
+	}),
+	datetimeStr: datetime('datetime_str', {
+		mode: 'string',
+	}),
+	decimal: decimal('decimal'),
+	decimalNum: decimal('decimal_num', {
+		scale: 30,
+		mode: 'number',
+	}),
+	decimalBig: decimal('decimal_big', {
+		scale: 30,
+		mode: 'bigint',
+	}),
+	double: double('double'),
+	float: float('float'),
+	int: int('int'),
+	json: json('json'),
+	medInt: mediumint('med_int'),
+	smallInt: smallint('small_int'),
+	real: real('real'),
+	text: text('text'),
+	time: time('time'),
+	timestamp: timestamp('timestamp', {
+		mode: 'date',
+	}),
+	timestampStr: timestamp('timestamp_str', {
+		mode: 'string',
+	}),
+	tinyInt: tinyint('tiny_int'),
+	varbin: varbinary('varbin', {
+		length: 16,
+	}),
+	varchar: varchar('varchar', {
+		length: 255,
+	}),
+	year: year('year'),
+	enum: singlestoreEnum('enum', ['enV1', 'enV2']),
+	vectorI8: vector('vec_i8', {
+		dimensions: 5,
+		elementType: 'I8',
+	}),
+	vectorI16: vector('vec_i16', {
+		dimensions: 5,
+		elementType: 'I16',
+	}),
+	vectorI32: vector('vec_i32', {
+		dimensions: 5,
+		elementType: 'I32',
+	}),
+	vectorI64: vector('vec_i64', {
+		dimensions: 5,
+		elementType: 'I64',
+	}),
+	vectorF32: vector('vec_f32', {
+		dimensions: 5,
+		elementType: 'F32',
+	}),
+	vectorF64: vector('vec_f64', {
+		dimensions: 5,
+		elementType: 'F64',
+	}),
+});
+
+export const students = snakeCase.table('students', {
+	studentId: serial('student_id').primaryKey().notNull(),
+	name: text().notNull(),
+});
+
+export const courseOfferings = snakeCase.table('course_offerings', {
+	courseId: int('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+});
+
+export const studentGrades = snakeCase.table('student_grades', {
+	studentId: int('student_id').notNull(),
+	courseId: int('course_id').notNull(),
+	semester: varchar({ length: 10 }).notNull(),
+	grade: char({ length: 2 }),
+});
+
+const customBigInt = customType<{
+	data: bigint;
+	driverData: bigint;
+	driverOutput: string;
+	jsonData: string;
+}>({
+	dataType: () => 'bigint',
+	fromDriver: BigInt,
+});
+
+const customBytes = customType<{
+	data: Buffer;
+	driverData: Buffer;
+	driverOutput: Buffer | Uint8Array;
+	jsonData: string;
+}>({
+	dataType: () => 'blob',
+	fromDriver: (value) => {
+		return Buffer.isBuffer(value) ? value : Buffer.from(value);
+	},
+	fromJson: (value) => {
+		return Buffer.from(value, 'hex');
+	},
+	forJsonSelect: (identifier, sql) => {
+		return sql`hex(${identifier})`;
+	},
+});
+
+const customTimestamp = customType<{
+	data: Date;
+	driverData: string;
+	jsonData: string;
+}>({
+	dataType: () => 'timestamp',
+	fromDriver: (value: string) => {
+		return new Date(value + '+0000');
+	},
+	toDriver: (value: Date) => {
+		return value.toISOString().slice(0, 19).replace('T', ' ');
+	},
+});
+
+const customInt = customType<{
+	data: number;
+	driverData: number;
+}>({
+	dataType: () => 'int',
+});
+
+export const customTypesTable = snakeCase.table('custom_types', {
+	id: int('id'),
+	big: customBigInt(),
+	bytes: customBytes(),
+	time: customTimestamp(),
+	int: customInt(),
+});
diff --git a/integration-tests/tests/singlestore/singlestore.test.ts b/integration-tests/tests/singlestore/singlestore.test.ts
index 8a14bb17c5..441b357d06 100644
--- a/integration-tests/tests/singlestore/singlestore.test.ts
+++ b/integration-tests/tests/singlestore/singlestore.test.ts
@@ -1,61 +1,6 @@
-import retry from 'async-retry';
-import { drizzle } from 'drizzle-orm/singlestore';
-import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
-import * as mysql2 from 'mysql2/promise';
-import { afterAll, beforeAll, beforeEach } from 'vitest';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './singlestore-cache';
-import { createDockerDB, tests } from './singlestore-common';
+import { tests } from './common';
+import { tests as cacheTests } from './common-cache';
+import { singleStoreTest } from './instrumentation';
 
-const ENABLE_LOGGING = false;
-
-let db: SingleStoreDriverDatabase;
-let dbGlobalCached: SingleStoreDriverDatabase;
-let cachedDb: SingleStoreDriverDatabase;
-let client: mysql2.Connection;
-
-beforeAll(async () => {
-	let connectionString;
-	if (process.env['SINGLESTORE_CONNECTION_STRING']) {
-		connectionString = process.env['SINGLESTORE_CONNECTION_STRING'];
-	} else {
-		const { connectionString: conStr } = await createDockerDB();
-		connectionString = conStr;
-	}
-	client = await retry(async () => {
-		client = await mysql2.createConnection({ uri: connectionString, supportBigNumbers: true });
-		await client.connect();
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.end();
-		},
-	});
-
-	await client.query(`CREATE DATABASE IF NOT EXISTS drizzle;`);
-	await client.changeUser({ database: 'drizzle' });
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-afterAll(async () => {
-	await client?.end();
-});
-
-beforeEach((ctx) => {
-	ctx.singlestore = {
-		db,
-	};
-	ctx.cachedSingleStore = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-cacheTests();
-tests();
+cacheTests(singleStoreTest);
+tests(singleStoreTest);
diff --git a/integration-tests/tests/sqlite/better-sqlite.test.ts b/integration-tests/tests/sqlite/better-sqlite.test.ts
index 53feee15f2..fdba344795 100644
--- a/integration-tests/tests/sqlite/better-sqlite.test.ts
+++ b/integration-tests/tests/sqlite/better-sqlite.test.ts
@@ -1,38 +1,19 @@
-import Database from 'better-sqlite3';
 import { sql } from 'drizzle-orm';
-import { type BetterSQLite3Database, drizzle } from 'drizzle-orm/better-sqlite3';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { betterSqlite3Test as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: BetterSQLite3Database;
-let client: Database.Database;
-
-beforeAll(async () => {
-	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
-	client = new Database(dbPath);
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	db.run(sql`drop table if exists another_users`);
 	db.run(sql`drop table if exists users12`);
 	db.run(sql`drop table if exists __drizzle_migrations`);
 
-	migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	migrate(db as BetterSQLite3Database<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = db.select().from(usersMigratorTable).all();
@@ -48,13 +29,166 @@ test('migrator', async () => {
 	db.run(sql`drop table __drizzle_migrations`);
 });
 
-skipTests([
-	/**
-	 * doesn't work properly:
-	 * 	Expect: should rollback transaction and don't insert/ update data
-	 * 	Received: data inserted/ updated
-	 */
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as BetterSQLite3Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as BetterSQLite3Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	migrate(db as BetterSQLite3Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = migrate(db as BetterSQLite3Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/bettersqlite3';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	migrate(db as BetterSQLite3Database, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	migrate(db as BetterSQLite3Database, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses sync versions
 	'transaction rollback',
 	'nested transaction rollback',
-]);
-tests();
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/bettersqlite.test.ts b/integration-tests/tests/sqlite/bettersqlite.test.ts
new file mode 100644
index 0000000000..3270f99af9
--- /dev/null
+++ b/integration-tests/tests/sqlite/bettersqlite.test.ts
@@ -0,0 +1,11588 @@
+import 'dotenv/config';
+import Database from 'better-sqlite3';
+import { defineRelations, DrizzleError, eq, sql, TransactionRollbackError } from 'drizzle-orm';
+import { type BetterSQLite3Database, drizzle } from 'drizzle-orm/better-sqlite3';
+import { alias } from 'drizzle-orm/sqlite-core';
+import { beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+import relations from './sqlite.relations';
+import {
+	allTypesTable,
+	commentsTable,
+	courseOfferings,
+	customTypesTable,
+	groupsTable,
+	postsTable,
+	studentGrades,
+	students,
+	usersTable,
+	usersToGroupsTable,
+} from './sqlite.schema';
+
+const ENABLE_LOGGING = false;
+
+let db: BetterSQLite3Database<typeof relations>;
+
+beforeAll(() => {
+	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
+
+	db = drizzle({ client: new Database(dbPath), relations, logger: ENABLE_LOGGING });
+});
+
+beforeEach(() => {
+	db.run(sql`drop table if exists \`groups\``);
+	db.run(sql`drop table if exists \`users\``);
+	db.run(sql`drop view if exists \`users_view\``);
+	db.run(sql`drop table if exists \`users_to_groups\``);
+	db.run(sql`drop table if exists \`posts\``);
+	db.run(sql`drop table if exists \`comments\``);
+	db.run(sql`drop table if exists \`comment_likes\``);
+	db.run(sql`drop table if exists \`all_types\``);
+	db.run(sql`drop table if exists \`custom_types\``);
+	db.run(sql`drop table if exists \`course_offerings\``);
+	db.run(sql`drop table if exists \`student_grades\``);
+	db.run(sql`drop table if exists \`students\``);
+
+	db.run(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` integer DEFAULT 0 NOT NULL,
+			    \`invited_by\` integer
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`description\` text
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`users_to_groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`user_id\` integer NOT NULL,
+			    \`group_id\` integer NOT NULL
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`posts\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`owner_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE VIEW \`users_view\` AS select \`users\`.\`id\`, \`users\`.\`name\`, \`users\`.\`verified\`, \`users\`.\`invited_by\`, \`posts\`.\`content\`, \`posts\`.\`created_at\`, (select count(*) from \`users\` as \`count_source\` where \`users\`.\`id\` <> 2) as \`count\` from \`users\` left join \`posts\` on \`users\`.\`id\` = \`posts\`.\`owner_id\`;
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`comments\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`creator\` integer,
+			    \`post_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`comment_likes\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`creator\` integer,
+			    \`comment_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`course_offerings\` (
+				\`course_id\` integer NOT NULL,
+				\`semester\` text NOT NULL,
+				CONSTRAINT \`course_offerings_pkey\` PRIMARY KEY(\`course_id\`,\`semester\`)
+			)	
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`student_grades\` (
+				\`student_id\` integer NOT NULL,
+				\`course_id\` integer NOT NULL,
+				\`semester\` text NOT NULL,
+				\`grade\` text,
+				CONSTRAINT \`student_grades_pkey\` PRIMARY KEY(\`student_id\`,\`course_id\`,\`semester\`)
+			);
+		`,
+	);
+	db.run(
+		sql`
+			CREATE TABLE \`students\` (
+				\`student_id\` integer PRIMARY KEY NOT NULL,
+				\`name\` text NOT NULL
+			);
+		`,
+	);
+});
+
+test('[Find Many] Get users with posts', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + limit posts and users', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test('[Find Many] Get users with posts + custom fields + limits', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: expect.anything(),
+	});
+
+	expect(usersWithPosts[0]!.posts).toEqual([
+		{ id: 7, ownerId: 3, content: '7', createdAt: expect.any(Date) },
+		{ id: 6, ownerId: 3, content: '6', createdAt: expect.any(Date) },
+	]);
+
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: expect.anything(),
+	});
+
+	expect(usersWithPosts[1]!.posts).toEqual([
+		{ id: 5, ownerId: 2, content: '5', createdAt: expect.any(Date) },
+		{ id: 4, ownerId: 2, content: '4', createdAt: expect.any(Date) },
+	]);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: expect.anything(),
+	});
+
+	expect(usersWithPosts[2]!.posts).toEqual([
+		{ id: 3, ownerId: 1, content: '3', createdAt: expect.any(Date) },
+		{ id: 2, ownerId: 1, content: '2', createdAt: expect.any(Date) },
+		{ id: 1, ownerId: 1, content: '1', createdAt: expect.any(Date) },
+	]);
+});
+
+test('[Find Many] Get users with posts + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(true + false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find Many] Get users with posts + where + partial(false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in transaction', () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	db.transaction((tx) => {
+		tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]).run();
+
+		tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]).run();
+
+		usersWithPosts = tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		}).sync();
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts in rollbacked transaction', () => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	expect(() =>
+		db.transaction((tx) => {
+			tx.insert(usersTable).values([
+				{ id: 1, name: 'Dan' },
+				{ id: 2, name: 'Andrew' },
+				{ id: 3, name: 'Alex' },
+			]).run();
+
+			tx.insert(postsTable).values([
+				{ ownerId: 1, content: 'Post1' },
+				{ ownerId: 1, content: 'Post1.1' },
+				{ ownerId: 2, content: 'Post2' },
+				{ ownerId: 3, content: 'Post3' },
+			]).run();
+
+			tx.rollback();
+
+			usersWithPosts = tx.query.usersTable.findMany({
+				where: {
+					id: 1,
+				},
+				with: {
+					posts: {
+						where: {
+							id: 1,
+						},
+					},
+				},
+			}).sync();
+		})
+	).toThrow(TransactionRollbackError);
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+test('[Find Many] Get only custom fields', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 1, content: 'Post1.2' },
+		{ id: 3, ownerId: 1, content: 'Post1.3' },
+		{ id: 4, ownerId: 2, content: 'Post2' },
+		{ id: 5, ownerId: 2, content: 'Post2.1' },
+		{ id: 6, ownerId: 3, content: 'Post3' },
+		{ id: 7, ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test('[Find Many] Get only custom fields + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get only custom fields + where + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+});
+
+test('[Find One] Get only custom fields + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find One] Get only custom fields + where + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }, { sql }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+test('[Find Many] Get select {}', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	expect(() =>
+		db.query.usersTable.findMany({
+			columns: {},
+		}).sync()
+	).toThrow(DrizzleError);
+});
+
+test('[Find One] Get select {}', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	expect(() =>
+		db.query.usersTable.findFirst({
+			columns: {},
+		}).sync()
+	).toThrow(DrizzleError);
+});
+
+test('[Find Many] Get deep select {}', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	expect(() =>
+		db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		}).sync()
+	).toThrow(DrizzleError);
+});
+
+test('[Find One] Get deep select {}', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	expect(() =>
+		db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		}).sync()
+	).toThrow(DrizzleError);
+});
+
+test('[Find Many] Get users with posts + prepared limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = prepared.execute({ limit: 1 }).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared limit + offset', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1 }).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = prepared.execute({ id: 1 }).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find Many] Get users with posts + prepared + limit + offset + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [
+					{ eq: sql.placeholder('id') },
+					3,
+				],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = prepared.execute({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 }).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + limit posts', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts no results found', () => {
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test('[Find One] Get users with posts + limit posts and users', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + custom fields', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }, { sql }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(0);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test('[Find One] Get users with posts + custom fields + limits', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.skip('[Find One] Get users with posts + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(true + false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test('[Find One] Get users with posts + where + partial(false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user + limit with invitee', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and custom fields + limits', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + order by', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee + where + partial', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial.  Did not select users id, but used it in where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(true+false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test('Get user with invitee + where + partial(false)', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: 0, invitedBy: null },
+	});
+});
+
+test('Get user with invitee and posts', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + limits + custom fields in each', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + custom fields in each', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test.skip('Get user with invitee and posts + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + limit posts and users + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + custom', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test('Get user with invitee and posts + orderBy + where + partial + custom', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+test('Get user with posts and posts with comments', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]).run();
+
+	db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: 0,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+test('Get user with posts and posts with comments and comments with owner', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]).run();
+
+	db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: 0,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: 0,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('Get user with posts and posts with comments and comments with owner where exists', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]).run();
+
+	db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+		where: {
+			RAW: ({ id }, { exists }) => exists(db.select({ one: sql`1` }).from(alias(usersTable, 'alias')).where(eq(id, 1))),
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	expect(response.length).eq(1);
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: 0,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: expect.arrayContaining([{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}]),
+	});
+});
+
+test('[Find Many] Get groups with users', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + limit + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + limit + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get groups with users + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find Many] Get users with groups + orderBy + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + limit + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + limit + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test('[Find One] Get groups with users + where', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get groups with users + orderBy', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('[Find One] Get users with groups + orderBy + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + orderBy + limit', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('Get users with groups + custom', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.usersTable.findMany({
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: (groupsTable, { sql }) => sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+	response[1]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+	response[2]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test('Get groups with users + custom', () => {
+	db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	}).sync();
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test('async api', async () => {
+	await db.insert(usersTable).values([{ id: 1, name: 'Dan' }]);
+	const users = await db.query.usersTable.findMany();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test('async api - sync()', () => {
+	db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).run();
+	const users = db.query.usersTable.findMany().sync();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test('async api - prepare', async () => {
+	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
+	await insertStmt.execute();
+	const queryStmt = db.query.usersTable.findMany().prepare();
+	const users = await queryStmt.execute();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test('async api - sync() + prepare', () => {
+	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
+	insertStmt.execute().sync();
+	const queryStmt = db.query.usersTable.findMany().prepare();
+	const users = queryStmt.execute().sync();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test('Force optional on where on non-optional relation query', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test('[Find Many .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find One .through] Get users with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + limit + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test('[Find One .through] Get groups with users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get groups with users + orderBy', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test('[Find One .through] Get users with groups + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test('[Find Many .through] Get groups with users + orderBy + limit', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with groups + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with users + custom', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with first group', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get groups with first user', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users with filtered groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get users with filtered posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test('[Find Many] Get users with filtered posts + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test('[Find Many] Get posts with filtered authors + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test('[Find Many] Get view users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			id: {
+				lt: 3,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		counter: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		counter: 3,
+		postContent: 'Post1',
+		createdAt: date1,
+		posts: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by SQL.Aliased field', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		columns: {
+			id: true,
+			name: true,
+			verified: true,
+			invitedBy: true,
+			counter: true,
+		},
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			counter: {
+				ne: 0,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		counter: 3,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		counter: 3,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get view users with posts + filter by joined field', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersView.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			postContent: 'Post2',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		counter: null,
+		postContent: 'Post2',
+		createdAt: date2,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get posts with view users with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		};
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+				counter: null,
+				postContent: 'Post2',
+				createdAt: date2,
+				posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+			},
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					id: {
+						ne: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many] Get posts with view users + filter by joined column with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					postContent: {
+						notLike: '%2',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+test('[Find Many] Get posts with view users + filter by SQL.Aliased with posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const result = await db.query.postsTable.findMany({
+		with: {
+			viewAuthor: {
+				with: {
+					posts: true,
+				},
+				where: {
+					counter: {
+						ne: 0,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(result).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+		viewAuthor: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			createdAt: Date | null;
+			postContent: string | null;
+			counter: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | null;
+	}[]>();
+
+	expect(result).toEqual([
+		{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: date1,
+			viewAuthor: null,
+		},
+		{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: date2,
+			viewAuthor: null,
+		},
+		{
+			id: 3,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: date3,
+			viewAuthor: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+				counter: 3,
+				postContent: 'Post3',
+				createdAt: date3,
+				posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: date3 }],
+			},
+		},
+	]);
+});
+
+test('[Find Many .through] Get view users with filtered groups + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersView.findMany({
+		with: {
+			groups: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		createdAt: Date | null;
+		postContent: string | null;
+		counter: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		createdAt: null,
+		postContent: null,
+		counter: 3,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test('[Find Many .through] Get groups with filtered view users + where', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersView: {
+				columns: {
+					createdAt: false,
+					postContent: false,
+				},
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersView: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			counter: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersView.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersView: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersView: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+			counter: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersView: [],
+	}]);
+});
+
+test('[Find Many] Get users + filter users by posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: {
+				content: {
+					like: '%2',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 2, content: 'Post2', createdAt: date2 }],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 3, content: 'Post3', createdAt: date3 }],
+	}]);
+});
+
+test('[Find Many] Get users filtered by nonexisting posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter users by existing posts', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 2, content: 'Post2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		orderBy: {
+			id: 'asc',
+		},
+		where: {
+			posts: false,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [],
+	}]);
+});
+
+test('[Find Many] Get users with posts + filter posts by author', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+			posts: [],
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+			posts: [{
+				id: 3,
+				ownerId: 2,
+				content: 'Post2U.1',
+				createdAt: date2,
+			}, {
+				id: 4,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+			posts: [],
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by own columns and posts with filtered posts by own columns and author', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				where: {
+					content: {
+						like: '%2',
+					},
+					author: {
+						id: 2,
+					},
+				},
+			},
+		},
+		where: {
+			id: {
+				gt: 1,
+			},
+			posts: {
+				content: {
+					like: 'M%',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts).toEqual([
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+			posts: [{
+				id: 6,
+				ownerId: 2,
+				content: 'Post2U.2',
+				createdAt: date2,
+			}, {
+				id: 8,
+				ownerId: 2,
+				content: 'MessageU.2',
+				createdAt: date2,
+			}],
+		},
+	]);
+});
+
+test('[Find Many .through] Get users filtered by groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by existing groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with existing groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}, {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by nonexisting groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+	}]);
+});
+
+test('[Find Many .through] Get users with nonexisting groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+		where: {
+			groups: false,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group2',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by groups with groups filtered by users', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				where: {
+					users: {
+						id: 1,
+					},
+				},
+			},
+		},
+		where: {
+			groups: {
+				name: 'Group3',
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test('[Find Many .through] Get users filtered by users of groups with groups', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 1 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		where: {
+			groups: {
+				users: {
+					id: 3,
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}],
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+			groups: [{
+				id: 1,
+				name: 'Group1',
+				description: null,
+			}, {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			}],
+		},
+	]);
+});
+
+test('[Find First] Relationless querying', async () => {
+	const rels = defineRelations({
+		usersTable,
+	});
+
+	const d1 = drizzle(':memory:', {
+		relations: rels,
+	});
+
+	d1.run(sql`DROP TABLE IF EXISTS \`users\``);
+	d1.run(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` integer DEFAULT 0 NOT NULL,
+			    \`invited_by\` integer
+			);
+		`,
+	);
+
+	d1.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	const res = d1.query.usersTable.findFirst({
+		where: {
+			id: 2,
+		},
+	}).sync();
+
+	expectTypeOf(res).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		} | undefined
+	>();
+
+	expect(res).toStrictEqual(
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		},
+	);
+});
+
+test('[Find Many] Relationless querying', async () => {
+	const rels = defineRelations({
+		usersTable,
+	});
+
+	const d1 = drizzle(':memory:', {
+		relations: rels,
+	});
+
+	d1.run(sql`DROP TABLE IF EXISTS \`users\``);
+	d1.run(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` integer DEFAULT 0 NOT NULL,
+			    \`invited_by\` integer
+			);
+		`,
+	);
+
+	d1.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	const res = d1.query.usersTable.findMany({
+		where: {
+			id: {
+				lte: 2,
+			},
+		},
+	}).sync();
+
+	expectTypeOf(res).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[]
+	>();
+
+	expect(res).toStrictEqual(
+		[{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - eq', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: sql.placeholder('id'),
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = query.execute({
+		id: 1,
+	}).sync();
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			OR: [{
+				ownerId: sql.placeholder('id1'),
+			}, {
+				ownerId: sql.placeholder('id2'),
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = query.execute({
+		id1: 1,
+		id2: 2,
+	}).sync();
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column or', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				OR: [sql.placeholder('id1'), sql.placeholder('id2')],
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = query.execute({
+		id1: 1,
+		id2: 2,
+	}).sync();
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Shortcut form placeholders in filters - column not', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ id: 9, ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ id: 10, ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const query = await db.query.postsTable.findMany({
+		where: {
+			ownerId: {
+				NOT: sql.placeholder('id'),
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	}).prepare();
+
+	const posts = query.execute({
+		id: 3,
+	}).sync();
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		ownerId: number | null;
+		createdAt: Date;
+	}[]>();
+
+	expect(posts).toEqual([
+		{ id: 1, ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ id: 2, ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ id: 3, ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ id: 4, ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ id: 5, ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ id: 6, ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ id: 7, ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ id: 8, ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with AND', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			AND: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						ne: 2,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with OR', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			OR: [{
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			}, {
+				posts: {
+					ownerId: {
+						eq: 3,
+					},
+				},
+			}],
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		},
+		{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		},
+		{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many] Get users filtered by posts with NOT', async () => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	const date1 = new Date(0);
+	const date2 = new Date(1000);
+	const date3 = new Date(10000);
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Post1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.1', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.2', createdAt: date1 },
+		{ ownerId: 1, content: 'Message1U.3', createdAt: date1 },
+		{ ownerId: 2, content: 'Post2U.1', createdAt: date2 },
+		{ ownerId: 2, content: 'Post2U.2', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.1', createdAt: date2 },
+		{ ownerId: 2, content: 'MessageU.2', createdAt: date2 },
+		{ ownerId: 3, content: 'Post3U.1', createdAt: date3 },
+		{ ownerId: 3, content: 'Post3U.2', createdAt: date3 },
+	]);
+
+	const users = await db.query.usersTable.findMany({
+		where: {
+			NOT: {
+				posts: {
+					content: {
+						like: 'M%',
+					},
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(users).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[]>();
+
+	expect(users).toEqual([
+		{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count', async () => {
+	db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]).run();
+
+	db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]).run();
+
+	db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]).run();
+
+	const res = db.query.students.findMany({
+		with: {
+			courseOfferings: {
+				orderBy: {
+					courseId: 'asc',
+					semester: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			studentId: 'asc',
+		},
+	}).sync();
+
+	expectTypeOf(res).toEqualTypeOf<{
+		studentId: number;
+		name: string;
+		courseOfferings: {
+			courseId: number;
+			semester: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			name: 'First',
+			studentId: 1,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+				{
+					courseId: 2,
+					semester: 's2',
+				},
+			],
+		},
+		{
+			name: 'Second',
+			studentId: 2,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's1',
+				},
+			],
+		},
+		{
+			name: 'Third',
+			studentId: 3,
+			courseOfferings: [
+				{
+					courseId: 1,
+					semester: 's2',
+				},
+				{
+					courseId: 2,
+					semester: 's3',
+				},
+				{
+					courseId: 4,
+					semester: 's4',
+				},
+			],
+		},
+		{
+			name: 'Fourth',
+			studentId: 4,
+			courseOfferings: [
+				{
+					courseId: 3,
+					semester: 's1',
+				},
+				{
+					courseId: 4,
+					semester: 's3',
+				},
+			],
+		},
+	]);
+});
+
+test('[Find Many .through] Through with uneven relation column count - reverse', async () => {
+	db.insert(students).values([{
+		studentId: 1,
+		name: 'First',
+	}, {
+		studentId: 2,
+		name: 'Second',
+	}, {
+		studentId: 3,
+		name: 'Third',
+	}, {
+		studentId: 4,
+		name: 'Fourth',
+	}]).run();
+
+	db.insert(studentGrades).values([
+		{
+			studentId: 1,
+			courseId: 1,
+			semester: 's1',
+			grade: '44',
+		},
+		{
+			studentId: 1,
+			courseId: 2,
+			semester: 's2',
+			grade: '35',
+		},
+		{
+			studentId: 2,
+			courseId: 1,
+			semester: 's1',
+			grade: '58',
+		},
+		{
+			studentId: 2,
+			courseId: 3,
+			semester: 's2',
+			grade: '72',
+		},
+		{
+			studentId: 3,
+			courseId: 4,
+			semester: 's4',
+			grade: '99',
+		},
+		{
+			studentId: 3,
+			courseId: 2,
+			semester: 's3',
+			grade: '85',
+		},
+		{
+			studentId: 3,
+			courseId: 1,
+			semester: 's2',
+			grade: '48',
+		},
+		{
+			studentId: 4,
+			courseId: 3,
+			semester: 's1',
+			grade: '63',
+		},
+		{
+			studentId: 4,
+			courseId: 4,
+			semester: 's3',
+			grade: '51',
+		},
+	]).run();
+
+	db.insert(courseOfferings).values([{
+		courseId: 1,
+		semester: 's3',
+	}, {
+		courseId: 2,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's1',
+	}, {
+		courseId: 4,
+		semester: 's3',
+	}, {
+		courseId: 1,
+		semester: 's1',
+	}, {
+		courseId: 1,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's1',
+	}, {
+		courseId: 2,
+		semester: 's2',
+	}, {
+		courseId: 2,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's3',
+	}, {
+		courseId: 3,
+		semester: 's4',
+	}, {
+		courseId: 4,
+		semester: 's4',
+	}, {
+		courseId: 3,
+		semester: 's1',
+	}]).run();
+
+	const res = db.query.courseOfferings.findMany({
+		with: {
+			students: {
+				orderBy: {
+					studentId: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			courseId: 'asc',
+			semester: 'asc',
+		},
+	}).sync();
+
+	expectTypeOf(res).toEqualTypeOf<{
+		courseId: number;
+		semester: string;
+		students: {
+			studentId: number;
+			name: string;
+		}[];
+	}[]>();
+
+	expect(res).toStrictEqual([
+		{
+			courseId: 1,
+			semester: 's1',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+				{
+					name: 'Second',
+					studentId: 2,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's2',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 1,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 2,
+			semester: 's2',
+			students: [
+				{
+					name: 'First',
+					studentId: 1,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's3',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+		{
+			courseId: 2,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's1',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 3,
+			semester: 's3',
+			students: [],
+		},
+		{
+			courseId: 3,
+			semester: 's4',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's1',
+			students: [],
+		},
+		{
+			courseId: 4,
+			semester: 's3',
+			students: [
+				{
+					name: 'Fourth',
+					studentId: 4,
+				},
+			],
+		},
+		{
+			courseId: 4,
+			semester: 's4',
+			students: [
+				{
+					name: 'Third',
+					studentId: 3,
+				},
+			],
+		},
+	]);
+});
+
+test('alltypes', async () => {
+	db.run(sql`
+		CREATE TABLE \`all_types\`(
+			\`int\` integer,
+			\`bool\` integer,
+			\`time\` integer,
+			\`time_ms\` integer,
+			\`bigint\` blob,
+			\`buffer\` blob,
+			\`json\` blob,
+			\`numeric\` numeric,
+			\`numeric_num\` numeric,
+			\`numeric_big\` numeric,
+			\`real\` real,
+			\`text\` text,
+			\`json_text\` text
+			);
+	`);
+
+	db.insert(usersTable).values({
+		id: 1,
+		name: 'First',
+	}).run();
+
+	db.insert(allTypesTable).values({
+		int: 1,
+		bool: true,
+		bigint: 5044565289845416380n,
+		buffer: Buffer.from([
+			0x44,
+			0x65,
+			0x73,
+			0x70,
+			0x61,
+			0x69,
+			0x72,
+			0x20,
+			0x6F,
+			0x20,
+			0x64,
+			0x65,
+			0x73,
+			0x70,
+			0x61,
+			0x69,
+			0x72,
+			0x2E,
+			0x2E,
+			0x2E,
+		]),
+		json: {
+			str: 'strval',
+			arr: ['str', 10],
+		},
+		jsonText: {
+			str: 'strvalb',
+			arr: ['strb', 11],
+		},
+		numeric: '475452353476',
+		numericNum: 9007199254740991,
+		numericBig: 5044565289845416380n,
+		real: 1.048596,
+		text: 'TEXT STRING',
+		time: new Date(1741743161623),
+		timeMs: new Date(1741743161623),
+	}).run();
+
+	const rawRes = await db.select().from(allTypesTable);
+	const relationRootRes = await db.query.allTypesTable.findMany();
+	const { alltypes: nestedRelationRes } = (await db.query.usersTable.findFirst({
+		with: {
+			alltypes: true,
+		},
+	}))!;
+
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes = [
+		{
+			int: 1,
+			bool: true,
+			time: new Date('2025-03-12T01:32:41.000Z'),
+			timeMs: new Date('2025-03-12T01:32:41.623Z'),
+			bigint: 5044565289845416380n,
+			buffer: Buffer.from([
+				0x44,
+				0x65,
+				0x73,
+				0x70,
+				0x61,
+				0x69,
+				0x72,
+				0x20,
+				0x6F,
+				0x20,
+				0x64,
+				0x65,
+				0x73,
+				0x70,
+				0x61,
+				0x69,
+				0x72,
+				0x2E,
+				0x2E,
+				0x2E,
+			]),
+			json: { str: 'strval', arr: ['str', 10] },
+			numeric: '475452353476',
+			numericNum: 9007199254740991,
+			numericBig: 5044565289845416380n,
+			real: 1.048596,
+			text: 'TEXT STRING',
+			jsonText: { str: 'strvalb', arr: ['strb', 11] },
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('custom types', async () => {
+	db.run(sql`
+		CREATE TABLE \`custom_types\` (
+			\`id\` integer,
+			\`big\` blob,
+			\`bytes\` blob,
+			\`time\` integer,
+			\`int\` integer
+		);
+	`);
+
+	db.insert(customTypesTable).values({
+		id: 1,
+		big: 5044565289845416380n,
+		bytes: Buffer.from('BYTES'),
+		time: new Date(1741743161623),
+		int: 250,
+	}).run();
+
+	const rawRes = await db.select().from(customTypesTable);
+	const relationRootRes = await db.query.customTypesTable.findMany();
+	const { self: nestedRelationRes } = (await db.query.customTypesTable.findFirst({
+		with: {
+			self: true,
+		},
+	}))!;
+
+	type ExpectedType = {
+		id: number | null;
+		big: bigint | null;
+		bytes: Buffer | null;
+		time: Date | null;
+		int: number | null;
+	}[];
+
+	expectTypeOf<ExpectedType>().toEqualTypeOf(rawRes);
+	expectTypeOf(relationRootRes).toEqualTypeOf(rawRes);
+	expectTypeOf(nestedRelationRes).toEqualTypeOf(rawRes);
+
+	expect(nestedRelationRes).toStrictEqual(rawRes);
+	expect(relationRootRes).toStrictEqual(rawRes);
+
+	const expectedRes: ExpectedType = [
+		{
+			id: 1,
+			big: 5044565289845416380n,
+			bytes: Buffer.from('BYTES'),
+			time: new Date(1741743161623),
+			int: 250,
+		},
+	];
+
+	expect(rawRes).toStrictEqual(expectedRes);
+});
+
+test('.toSQL()', () => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/sqlite/d1-batch.test.ts b/integration-tests/tests/sqlite/d1-batch.test.ts
index dba22cd4d9..3eabe9d4c4 100644
--- a/integration-tests/tests/sqlite/d1-batch.test.ts
+++ b/integration-tests/tests/sqlite/d1-batch.test.ts
@@ -2,7 +2,8 @@
 import 'dotenv/config';
 import { D1Database, D1DatabaseAPI } from '@miniflare/d1';
 import { createSQLiteDB } from '@miniflare/shared';
-import { eq, relations, sql } from 'drizzle-orm';
+import { defineRelations, eq, sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { DrizzleD1Database } from 'drizzle-orm/d1';
 import { drizzle } from 'drizzle-orm/d1';
 import { type AnySQLiteColumn, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
@@ -45,9 +46,7 @@ export const usersToGroupsTable = sqliteTable(
 			() => groupsTable.id,
 		),
 	},
-	(t) => ({
-		pk: primaryKey({ columns: [t.userId, t.groupId] }),
-	}),
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
 );
 export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
 	group: one(groupsTable, {
@@ -135,12 +134,14 @@ const schema = {
 	usersConfig,
 };
 
-let db: DrizzleD1Database<typeof schema>;
+const relationsV2 = defineRelations(schema);
+
+let db: DrizzleD1Database<typeof relationsV2>;
 
 beforeAll(async () => {
 	const sqliteDb = await createSQLiteDB(':memory:');
 	const d1db = new D1Database(new D1DatabaseAPI(sqliteDb));
-	db = drizzle(d1db, { logger: ENABLE_LOGGING, schema });
+	db = drizzle(d1db, { logger: ENABLE_LOGGING, relations: relationsV2 });
 });
 
 beforeEach(async () => {
@@ -252,17 +253,17 @@ test('batch api example', async () => {
 		invitedBy: null,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({
-	// 	results: [],
-	// 	success: true,
-	// 	meta: {
-	// 		duration: 0.027083873748779297,
-	// 		last_row_id: 2,
-	// 		changes: 1,
-	// 		served_by: 'miniflare.db',
-	// 		internal_stats: null,
-	// 	},
-	// });
+	expect(batchResponse[1]).toEqual({
+		results: [],
+		success: true,
+		meta: {
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			last_row_id: 2,
+			changes: 1,
+			served_by: 'miniflare.db',
+			internal_stats: null,
+		},
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
@@ -297,7 +298,17 @@ test('insert + findMany', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 2,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
@@ -339,7 +350,17 @@ test('insert + findMany + findFirst', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 2,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
@@ -386,7 +407,17 @@ test('insert + db.all + db.get + db.values + db.run', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 2,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2], 'all').toEqual([
 		{ id: 1, name: 'John', verified: 0, invited_by: null },
@@ -434,7 +465,17 @@ test('insert + findManyWith + db.all', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 2,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
@@ -486,7 +527,17 @@ test('insert + update + select + select partial', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 1n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 1,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
@@ -536,7 +587,17 @@ test('insert + delete + select + select partial', async () => {
 		id: 1,
 	}]);
 
-	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+	expect(batchResponse[1]).toEqual({
+		meta: {
+			changes: 1,
+			duration: expect.toSatisfy((v) => typeof v === 'number', 'expected number'),
+			internal_stats: null,
+			last_row_id: 2,
+			served_by: 'miniflare.db',
+		},
+		results: [],
+		success: true,
+	});
 
 	expect(batchResponse[2]).toEqual([
 		{ id: 1, invitedBy: null },
diff --git a/integration-tests/tests/sqlite/d1.test.ts b/integration-tests/tests/sqlite/d1.test.ts
index 6878b127f6..1b68ff48ab 100644
--- a/integration-tests/tests/sqlite/d1.test.ts
+++ b/integration-tests/tests/sqlite/d1.test.ts
@@ -1,45 +1,21 @@
-import { D1Database, D1DatabaseAPI } from '@miniflare/d1';
-import { createSQLiteDB } from '@miniflare/shared';
 import { sql } from 'drizzle-orm';
 import type { DrizzleD1Database } from 'drizzle-orm/d1';
-import { drizzle } from 'drizzle-orm/d1';
 import { migrate } from 'drizzle-orm/d1/migrator';
-import { beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
+import { d1Test as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './sqlite-common-cache';
+import { tests as cacheTests } from './sqlite-common-cache';
 
-const ENABLE_LOGGING = false;
-
-let db: DrizzleD1Database;
-let dbGlobalCached: DrizzleD1Database;
-let cachedDb: DrizzleD1Database;
-
-beforeAll(async () => {
-	const sqliteDb = await createSQLiteDB(':memory:');
-	const d1db = new D1Database(new D1DatabaseAPI(sqliteDb));
-	db = drizzle(d1db, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(d1db, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(d1db, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-	ctx.cachedSqlite = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as DrizzleD1Database<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -55,13 +31,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as DrizzleD1Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -77,7 +56,167 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-skipTests([
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as DrizzleD1Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as DrizzleD1Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as DrizzleD1Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as DrizzleD1Database<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/d1';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as DrizzleD1Database<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as DrizzleD1Database<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
 	// Cannot convert 49,50,55 to a BigInt
 	'insert bigint values',
 	// SyntaxError: Unexpected token , in JSON at position 2
@@ -90,11 +229,24 @@ skipTests([
 	 * See #528 for more details.
 	 * Tldr the D1 driver does not execute joins successfully
 	 */
+	'inner join',
 	'partial join with alias',
 	'full join with alias',
 	'select from alias',
 	'join view as subquery',
 	'cross join',
-]);
-cacheTests();
-tests();
+	'sql.Aliased in cte',
+	'Mappers: select complex selections',
+	// No jit mappers in workers
+	'Mappers: - correct mappers enabled',
+	'Jit mappers: - simple select - no rows',
+	'Jit mappers: - select - nothing to decode - text',
+	'Jit mappers: - select - nothing to decode - null',
+	'Jit mappers: - insert returning all + select + update returning + delete returning',
+	'Jit mappers: - select complex selections',
+
+	// .run() includes time data, strict comparison fails, otherwise functional
+	'write + query all methods & verify data intergrity',
+];
+cacheTests(test, skip);
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/drizzle/0000_cuddly_black_bolt.sql b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/0000_cuddly_black_bolt.sql
new file mode 100644
index 0000000000..deff0ea9ab
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/0000_cuddly_black_bolt.sql
@@ -0,0 +1,11 @@
+CREATE TABLE `another_users` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `users12` (
+	`id` integer PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`email` text NOT NULL
+);
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/0000_snapshot.json b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/0000_snapshot.json
new file mode 100644
index 0000000000..9c151ecc95
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/0000_snapshot.json
@@ -0,0 +1,80 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "66be869a-d55d-4790-a382-de654dff1506",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "another_users": {
+      "name": "another_users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users12": {
+      "name": "users12",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/_journal.json b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/_journal.json
new file mode 100644
index 0000000000..ab94199ee9
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/meta/_journal.json
@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1732696446109,
+      "tag": "0000_cuddly_black_bolt",
+      "breakpoints": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/drizzle/migrations.js b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/migrations.js
new file mode 100644
index 0000000000..c6f2a6ada1
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/drizzle/migrations.js
@@ -0,0 +1,9 @@
+import m0000 from './0000_cuddly_black_bolt.sql';
+import journal from './meta/_journal.json';
+
+export default {
+	journal,
+	migrations: {
+		m0000,
+	},
+};
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/index.ts b/integration-tests/tests/sqlite/durable-objects-effect/index.ts
new file mode 100644
index 0000000000..9d7f448429
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/index.ts
@@ -0,0 +1,3863 @@
+/// <reference types="@cloudflare/workers-types" />
+
+// Can't use 'vitest' due to it having setTimeout in code, thus breaking workers
+import { SqliteClient } from '@effect/sql-sqlite-do';
+import { expect } from 'chai';
+import { DurableObject } from 'cloudflare:workers';
+import {
+	and,
+	asc,
+	avg,
+	avgDistinct,
+	count,
+	countDistinct,
+	defineRelations,
+	eq,
+	exists,
+	getTableColumns,
+	gt,
+	gte,
+	inArray,
+	lt,
+	max,
+	min,
+	Name,
+	notInArray,
+	sql,
+	sum,
+	sumDistinct,
+} from 'drizzle-orm';
+import { EffectCache } from 'drizzle-orm/cache/core/cache-effect';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite-do';
+import { migrate } from 'drizzle-orm/effect-sqlite-do/migrator';
+import {
+	alias,
+	blob,
+	except,
+	getViewConfig,
+	int,
+	integer,
+	intersect,
+	numeric,
+	primaryKey,
+	sqliteTable,
+	sqliteTableCreator,
+	sqliteView,
+	text,
+	union,
+	unionAll,
+} from 'drizzle-orm/sqlite-core';
+import { Layer } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import migrations from './drizzle/migrations';
+
+export const usersTable = sqliteTable('users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+	json: blob('json', { mode: 'json' }).$type<string[]>(),
+	createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`strftime('%s', 'now')`),
+});
+
+export const usersOnUpdate = sqliteTable('users_on_update', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	name: text('name').notNull(),
+	updateCounter: integer('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).$onUpdate(() => new Date()),
+	alwaysNull: text('always_null').$type<string | null>().$onUpdate(() => null),
+});
+
+export const users2Table = sqliteTable('users2', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: integer('city_id').references(() => citiesTable.id),
+});
+
+export const citiesTable = sqliteTable('cities', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+export const coursesTable = sqliteTable('courses', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: integer('category_id').references(() => courseCategoriesTable.id),
+});
+
+export const courseCategoriesTable = sqliteTable('course_categories', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+export const orders = sqliteTable('orders', {
+	id: integer('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: integer('amount').notNull(),
+	quantity: integer('quantity').notNull(),
+});
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const pkExampleTable = sqliteTable('pk_example', {
+	id: integer('id').notNull(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => [primaryKey({ columns: [table.id, table.name] })]);
+
+export const bigIntExample = sqliteTable('big_int_example', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	bigInt: blob('big_int', { mode: 'bigint' }).notNull(),
+});
+
+// To test aggregate functions
+export const aggregateTable = sqliteTable('aggregate_table', {
+	id: integer('id').primaryKey({ autoIncrement: true }).notNull(),
+	name: text('name').notNull(),
+	a: integer('a'),
+	b: integer('b'),
+	c: integer('c'),
+	nullOnly: integer('null_only'),
+});
+
+export const rqbUser = sqliteTable('user_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const rqbPost = sqliteTable('post_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const relations = defineRelations({ rqbUser, rqbPost }, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
+
+type Db = SQLiteDrizzle.EffectSQLiteDoDatabase<typeof relations>;
+
+const beforeEach = (db: Db) =>
+	Effect.gen(function*() {
+		yield* db.run(sql`drop table if exists ${usersTable}`);
+		yield* db.run(sql`drop table if exists ${users2Table}`);
+		yield* db.run(sql`drop table if exists ${citiesTable}`);
+		yield* db.run(sql`drop table if exists ${coursesTable}`);
+		yield* db.run(sql`drop table if exists ${courseCategoriesTable}`);
+		yield* db.run(sql`drop table if exists ${orders}`);
+		yield* db.run(sql`drop table if exists ${bigIntExample}`);
+		yield* db.run(sql`drop table if exists ${pkExampleTable}`);
+		yield* db.run(sql`drop table if exists ${rqbUser}`);
+		yield* db.run(sql`drop table if exists ${rqbPost}`);
+		yield* db.run(sql`drop table if exists user_notifications_insert_into`);
+		yield* db.run(sql`drop table if exists users_insert_into`);
+		yield* db.run(sql`drop table if exists notifications_insert_into`);
+
+		yield* db.run(sql`
+			create table ${usersTable} (
+				id integer primary key,
+				name text not null,
+				verified integer not null default 0,
+				json blob,
+				created_at integer not null default (strftime('%s', 'now'))
+			)
+		`);
+
+		yield* db.run(sql`
+			create table ${citiesTable} (
+				id integer primary key,
+				name text not null
+			)
+		`);
+		yield* db.run(sql`
+			create table ${courseCategoriesTable} (
+				id integer primary key,
+				name text not null
+			)
+		`);
+
+		yield* db.run(sql`
+			create table ${users2Table} (
+				id integer primary key,
+				name text not null,
+				city_id integer references ${citiesTable}(${sql.identifier(citiesTable.id.name)})
+			)
+		`);
+		yield* db.run(sql`
+			create table ${coursesTable} (
+				id integer primary key,
+				name text not null,
+				category_id integer references ${courseCategoriesTable}(${sql.identifier(courseCategoriesTable.id.name)})
+			)
+		`);
+		yield* db.run(sql`
+			create table ${orders} (
+				id integer primary key,
+				region text not null,
+				product text not null,
+				amount integer not null,
+				quantity integer not null
+			)
+		`);
+		yield* db.run(sql`
+			create table ${pkExampleTable} (
+				id integer not null,
+				name text not null,
+				email text not null,
+				primary key (id, name)
+			)
+		`);
+		yield* db.run(sql`
+			create table ${bigIntExample} (
+			  id integer primary key,
+			  name text not null,
+			  big_int blob not null
+			)
+		`);
+		yield* db.run(sql`
+			CREATE TABLE ${rqbUser} (
+			  id INT PRIMARY KEY NOT NULL,
+			  name TEXT NOT NULL,
+			  created_at INT NOT NULL
+			)
+		`);
+		yield* db.run(sql`
+			CREATE TABLE ${rqbPost} ( 
+			  id INT PRIMARY KEY NOT NULL,
+			  user_id INT NOT NULL,
+			  content TEXT,
+			  created_at INT NOT NULL
+			)
+		`);
+	});
+
+const setupSetOperationTest = (db: Db) =>
+	Effect.gen(function*() {
+		yield* db.run(sql`drop table if exists users2`);
+		yield* db.run(sql`drop table if exists cities`);
+		yield* db.run(sql`
+		create table \`cities\` (
+			id integer primary key,
+			name text not null
+		)
+	`);
+
+		yield* db.run(sql`
+		create table \`users2\` (
+			id integer primary key,
+			name text not null,
+			city_id integer references ${citiesTable}(${sql.identifier(citiesTable.id.name)})
+		)
+	`);
+
+		yield* db.insert(citiesTable).values([
+			{ id: 1, name: 'New York' },
+			{ id: 2, name: 'London' },
+			{ id: 3, name: 'Tampa' },
+		]);
+
+		yield* db.insert(users2Table).values([
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 2 },
+			{ id: 3, name: 'Jack', cityId: 3 },
+			{ id: 4, name: 'Peter', cityId: 3 },
+			{ id: 5, name: 'Ben', cityId: 2 },
+			{ id: 6, name: 'Jill', cityId: 1 },
+			{ id: 7, name: 'Mary', cityId: 2 },
+			{ id: 8, name: 'Sally', cityId: 1 },
+		]);
+	});
+
+const setupAggregateFunctionsTest = (db: Db) =>
+	Effect.gen(function*() {
+		yield* db.run(sql`drop table if exists "aggregate_table"`);
+		yield* db.run(
+			sql`
+			create table "aggregate_table" (
+				"id" integer primary key autoincrement not null,
+				"name" text not null,
+				"a" integer,
+				"b" integer,
+				"c" integer,
+				"null_only" integer
+			);
+		`,
+		);
+		yield* db.insert(aggregateTable).values([
+			{ name: 'value 1', a: 5, b: 10, c: 20 },
+			{ name: 'value 1', a: 5, b: 20, c: 30 },
+			{ name: 'value 2', a: 10, b: 50, c: 60 },
+			{ name: 'value 3', a: 20, b: 20, c: null },
+			{ name: 'value 4', a: null, b: 90, c: 120 },
+			{ name: 'value 5', a: 80, b: 10, c: null },
+			{ name: 'value 6', a: null, b: null, c: 150 },
+		]);
+	});
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+export class MyDurableObject extends DurableObject {
+	private db!: Db;
+	private runtime!: ManagedRuntime.ManagedRuntime<
+		EffectCache | SQLiteDrizzle.EffectLogger | SqliteClient.SqliteClient | SqlClient,
+		never
+	>;
+
+	constructor(ctx: DurableObjectState, env: Env) {
+		super(ctx, env);
+		this.runtime = ManagedRuntime.make(
+			Layer.merge(SQLiteDrizzle.DefaultServices, SqliteClient.layer({ db: ctx.storage.sql })),
+		);
+		ctx.blockConcurrencyWhile(async () => {
+			this.db = await this.runtime.runPromise(SQLiteDrizzle.make({ relations, storage: ctx.storage }));
+		});
+	}
+
+	private exec<A>(effect: Effect.Effect<A, unknown, any>): Promise<A> {
+		return (this.runtime.runPromise as (e: any) => Promise<A>)(
+			effect.pipe(Effect.catchCause((cause) => Effect.die(Cause.pretty(cause)))),
+		);
+	}
+
+	migrate1(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* db.run(sql`drop table if exists another_users`);
+			yield* db.run(sql`drop table if exists users12`);
+			yield* db.run(sql`drop table if exists __drizzle_migrations`);
+
+			yield* migrate(db, migrations);
+
+			yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+			const result = yield* db.select().from(usersMigratorTable);
+
+			yield* db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' });
+			const result2 = yield* db.select().from(anotherUsersMigratorTable);
+
+			expect(result).deep.equal([{ id: 1, name: 'John', email: 'email' }]);
+			expect(result2).deep.equal([{ id: 1, name: 'John', email: 'email' }]);
+
+			yield* db.run(sql`drop table another_users`);
+			yield* db.run(sql`drop table users12`);
+			yield* db.run(sql`drop table __drizzle_migrations`);
+		}));
+	}
+
+	insertBigIntValues(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db
+				.insert(bigIntExample)
+				.values({ name: 'one', bigInt: BigInt('0') })
+				.run();
+			yield* db
+				.insert(bigIntExample)
+				.values({ name: 'two', bigInt: BigInt('127') })
+				.run();
+			yield* db
+				.insert(bigIntExample)
+				.values({ name: 'three', bigInt: BigInt('32767') })
+				.run();
+			yield* db
+				.insert(bigIntExample)
+				.values({ name: 'four', bigInt: BigInt('1234567890') })
+				.run();
+			yield* db
+				.insert(bigIntExample)
+				.values({ name: 'five', bigInt: BigInt('12345678900987654321') })
+				.run();
+
+			const result = yield* db.select().from(bigIntExample).all();
+			expect(result).deep.equal([
+				{ id: 1, name: 'one', bigInt: BigInt('0') },
+				{ id: 2, name: 'two', bigInt: BigInt('127') },
+				{ id: 3, name: 'three', bigInt: BigInt('32767') },
+				{ id: 4, name: 'four', bigInt: BigInt('1234567890') },
+				{ id: 5, name: 'five', bigInt: BigInt('12345678900987654321') },
+			]);
+		}));
+	}
+
+	selectAllFields(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const now = Date.now();
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const result = yield* db.select().from(usersTable).all();
+			expect(result[0]!.createdAt).instanceOf(Date);
+			expect(Math.abs(result[0]!.createdAt.getTime() - now)).lessThan(5000);
+			expect(result).deep.equal([{
+				id: 1,
+				name: 'John',
+				verified: false,
+				json: null,
+				createdAt: result[0]!.createdAt,
+			}]);
+		}));
+	}
+
+	selectPartial(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const result = yield* db.select({ name: usersTable.name }).from(usersTable).all();
+
+			expect(result).deep.equal([{ name: 'John' }]);
+		}));
+	}
+
+	selectSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(users).deep.equal([{ name: 'JOHN' }]);
+		}));
+	}
+
+	selectTypedSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.select({
+					name: sql<string>`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(users).deep.equal([{ name: 'JOHN' }]);
+		}));
+	}
+
+	selectWithEmptyArrayInInArray(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = yield* db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(inArray(usersTable.id, []));
+
+			expect(result).deep.equal([]);
+		}));
+	}
+
+	selectWithEmptyArrayInNotInArray(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			const result = yield* db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.where(notInArray(usersTable.id, []));
+
+			expect(result).deep.equal([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+		}));
+	}
+
+	selectDistinct(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const usersDistinctTable = sqliteTable('users_distinct', {
+				id: integer('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${usersDistinctTable}`);
+			yield* db.run(sql`create table ${usersDistinctTable} (id integer, name text)`);
+
+			yield* db
+				.insert(usersDistinctTable)
+				.values([
+					{ id: 1, name: 'John' },
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'John' },
+					{ id: 1, name: 'Jane' },
+				])
+				.run();
+			const users = yield* db.selectDistinct().from(usersDistinctTable).orderBy(
+				usersDistinctTable.id,
+				usersDistinctTable.name,
+			).all();
+
+			yield* db.run(sql`drop table ${usersDistinctTable}`);
+
+			expect(users).deep.equal([
+				{ id: 1, name: 'Jane' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+			]);
+		}));
+	}
+
+	returingSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const users = yield* db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
+
+			expect(users).deep.equal([{ name: 'JOHN' }]);
+		}));
+	}
+
+	$defaultFunction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+			const selectedOrder = yield* db.select().from(orders);
+
+			expect(selectedOrder).deep.equal([
+				{
+					id: 1,
+					amount: 1,
+					quantity: 1,
+					region: 'Ukraine',
+					product: 'random_string',
+				},
+			]);
+		}));
+	}
+
+	deleteReturningSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
+
+			expect(users).deep.equal([{ name: 'JOHN' }]);
+		}));
+	}
+
+	queryCheckInsertSingleEmptyRow(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			const query = db.insert(users).values({}).toSQL();
+
+			expect(query).deep.equal({
+				sql: 'insert into "users" ("id", "name", "state") values (null, ?, null)',
+				params: ['Dan'],
+			});
+		}));
+	}
+
+	queryCheckInsertMultipleEmptyRow(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			const query = db.insert(users).values([{}, {}]).toSQL();
+
+			expect(query).deep.equal({
+				sql: 'insert into "users" ("id", "name", "state") values (null, ?, null), (null, ?, null)',
+				params: ['Dan', 'Dan'],
+			});
+		}));
+	}
+
+	insertAllDefaultsIn1Row(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const users = sqliteTable('empty_insert_single', {
+				id: integer('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text default 'Dan', state text)`);
+
+			yield* db.insert(users).values({}).run();
+
+			const res = yield* db.select().from(users).all();
+
+			expect(res).deep.equal([{ id: 1, name: 'Dan', state: null }]);
+		}));
+	}
+
+	insertAllDefaultsInMultipleRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const users = sqliteTable('empty_insert_multiple', {
+				id: integer('id').primaryKey(),
+				name: text('name').default('Dan'),
+				state: text('state'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text default 'Dan', state text)`);
+
+			yield* db.insert(users).values([{}, {}]).run();
+
+			const res = yield* db.select().from(users).all();
+
+			expect(res).deep.equal([
+				{ id: 1, name: 'Dan', state: null },
+				{ id: 2, name: 'Dan', state: null },
+			]);
+		}));
+	}
+
+	updateReturningSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
+
+			expect(users).deep.equal([{ name: 'JANE' }]);
+		}));
+	}
+
+	insertWithAutoIncrement(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'George' }, { name: 'Austin' }])
+				.run();
+			const result = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+				{ id: 3, name: 'George' },
+				{ id: 4, name: 'Austin' },
+			]);
+		}));
+	}
+
+	insertDataWithDefaultValues(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const result = yield* db.select().from(usersTable).all();
+
+			expect(result).deep.equal([{
+				id: 1,
+				name: 'John',
+				verified: false,
+				json: null,
+				createdAt: result[0]!.createdAt,
+			}]);
+		}));
+	}
+
+	insertDataWithOverridenDefaultValues(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John', verified: true }).run();
+			const result = yield* db.select().from(usersTable).all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John', verified: true, json: null, createdAt: result[0]!.createdAt }]);
+		}));
+	}
+
+	updateWithReturningFields(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const now = Date.now();
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning()
+				.all();
+
+			expect(users[0]!.createdAt).instanceOf(Date);
+			expect(Math.abs(users[0]!.createdAt.getTime() - now)).lessThan(5000);
+			expect(users).deep.equal([{ id: 1, name: 'Jane', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+		}));
+	}
+
+	updateWithReturningPartial(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.all();
+
+			expect(users).deep.equal([{ id: 1, name: 'Jane' }]);
+		}));
+	}
+
+	updateWithReturningAllFields(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const now = Date.now();
+
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db.delete(usersTable).where(eq(usersTable.name, 'John')).returning().all();
+
+			expect(users[0]!.createdAt).instanceOf(Date);
+			expect(Math.abs(users[0]!.createdAt.getTime() - now)).lessThan(5000);
+			expect(users).deep.equal([{ id: 1, name: 'John', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+		}));
+	}
+
+	deleteWithReturningPartial(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const users = yield* db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.all();
+
+			expect(users).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	insertAndSelect(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const result = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+
+			yield* db.insert(usersTable).values({ name: 'Jane' }).run();
+			const result2 = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+			expect(result2).deep.equal([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+		}));
+	}
+
+	jsonInsert(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values({ name: 'John', json: ['foo', 'bar'] })
+				.run();
+			const result = yield* db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					json: usersTable.json,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John', json: ['foo', 'bar'] }]);
+		}));
+	}
+
+	insertMany(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Bruce', json: ['foo', 'bar'] }, { name: 'Jane' }, {
+					name: 'Austin',
+					verified: true,
+				}])
+				.run();
+			const result = yield* db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					json: usersTable.json,
+					verified: usersTable.verified,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'John', json: null, verified: false },
+				{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', json: null, verified: false },
+				{ id: 4, name: 'Austin', json: null, verified: true },
+			]);
+		}));
+	}
+
+	insertManyWithReturning(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const result = yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Bruce', json: ['foo', 'bar'] }, { name: 'Jane' }, {
+					name: 'Austin',
+					verified: true,
+				}])
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+					json: usersTable.json,
+					verified: usersTable.verified,
+				})
+				.all();
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'John', json: null, verified: false },
+				{ id: 2, name: 'Bruce', json: ['foo', 'bar'], verified: false },
+				{ id: 3, name: 'Jane', json: null, verified: false },
+				{ id: 4, name: 'Austin', json: null, verified: true },
+			]);
+		}));
+	}
+
+	partialJoinWithAlias(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const customerAlias = alias(usersTable, 'customer');
+
+			yield* db.insert(usersTable).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
+
+			const result = yield* db
+				.select({
+					user: {
+						id: usersTable.id,
+						name: usersTable.name,
+					},
+					customer: {
+						id: customerAlias.id,
+						name: customerAlias.name,
+					},
+				})
+				.from(usersTable)
+				.leftJoin(customerAlias, eq(customerAlias.id, 11))
+				.where(eq(usersTable.id, 10));
+
+			expect(result).deep.equal([
+				{
+					user: { id: 10, name: 'Ivan' },
+					customer: { id: 11, name: 'Hans' },
+				},
+			]);
+		}));
+	}
+
+	fullJoinWithAlias(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
+
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+
+			const customers = alias(users, 'customer');
+
+			yield* db
+				.insert(users)
+				.values([
+					{ id: 10, name: 'Ivan' },
+					{ id: 11, name: 'Hans' },
+				])
+				.run();
+			const result = yield* db.select().from(users).leftJoin(customers, eq(customers.id, 11)).where(eq(users.id, 10))
+				.all();
+
+			expect(result).deep.equal([
+				{
+					users: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				},
+			]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	selectFromAlias(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
+
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+
+			const user = alias(users, 'user');
+			const customers = alias(users, 'customer');
+
+			yield* db
+				.insert(users)
+				.values([
+					{ id: 10, name: 'Ivan' },
+					{ id: 11, name: 'Hans' },
+				])
+				.run();
+			const result = yield* db.select().from(user).leftJoin(customers, eq(customers.id, 11)).where(eq(user.id, 10))
+				.all();
+
+			expect(result).deep.equal([
+				{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				},
+			]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	insertWithSpaces(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values({ name: sql`'Jo   h     n'` })
+				.run();
+			const result = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+
+			expect(result).deep.equal([{ id: 1, name: 'Jo   h     n' }]);
+		}));
+	}
+
+	preparedStatement(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const statement = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).prepare();
+			const result = yield* statement.all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	preparedStatementReuse(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const stmt = db
+				.insert(usersTable)
+				.values({ name: sql.placeholder('name') })
+				.prepare();
+
+			for (let i = 0; i < 10; i++) {
+				yield* stmt.run({ name: `John ${i}` });
+			}
+
+			const result = yield* db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'John 0' },
+				{ id: 2, name: 'John 1' },
+				{ id: 3, name: 'John 2' },
+				{ id: 4, name: 'John 3' },
+				{ id: 5, name: 'John 4' },
+				{ id: 6, name: 'John 5' },
+				{ id: 7, name: 'John 6' },
+				{ id: 8, name: 'John 7' },
+				{ id: 9, name: 'John 8' },
+				{ id: 10, name: 'John 9' },
+			]);
+		}));
+	}
+
+	insertPlaceholdersOnColumnsWithEncoder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const stmt = db
+				.insert(usersTable)
+				.values({
+					name: 'John',
+					verified: sql.placeholder('verified'),
+				})
+				.prepare();
+
+			yield* stmt.run({ verified: true });
+			yield* stmt.run({ verified: false });
+
+			const result = yield* db
+				.select({
+					id: usersTable.id,
+					verified: usersTable.verified,
+				})
+				.from(usersTable)
+				.all();
+
+			expect(result).deep.equal([
+				{ id: 1, verified: true },
+				{ id: 2, verified: false },
+			]);
+		}));
+	}
+
+	preparedStatementWithPlaceholderInWhere(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.prepare();
+			const result = yield* stmt.all({ id: 1 });
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	preparedStatementWithPlaceholderInLimit(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ name: 'John' }).run();
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.where(eq(usersTable.id, sql.placeholder('id')))
+				.limit(sql.placeholder('limit'))
+				.prepare();
+
+			const result = yield* stmt.all({ id: 1, limit: 1 });
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+			expect(result).length(1);
+		}));
+	}
+
+	preparedStatementWithPlaceholderInOffset(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'John1' }])
+				.run();
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.limit(sql.placeholder('limit'))
+				.offset(sql.placeholder('offset'))
+				.prepare();
+
+			const result = yield* stmt.all({ limit: 1, offset: 1 });
+
+			expect(result).deep.equal([{ id: 2, name: 'John1' }]);
+		}));
+	}
+
+	preparedStatementBuiltUsing$dynamic(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			function withLimitOffset(qb: any) {
+				return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+			}
+
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'John1' }])
+				.run();
+			const stmt = db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.$dynamic();
+			withLimitOffset(stmt).prepare('stmt_limit');
+
+			const result = yield* stmt.all({ limit: 1, offset: 1 });
+
+			expect(result).deep.equal([{ id: 2, name: 'John1' }]);
+			expect(result).length(1);
+		}));
+	}
+
+	selectWithGroupByAsField(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const result = yield* db.select({ name: usersTable.name }).from(usersTable).groupBy(usersTable.name).all();
+
+			expect(result).deep.equal([{ name: 'Jane' }, { name: 'John' }]);
+		}));
+	}
+
+	selectWithExists(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const user = alias(usersTable, 'user');
+			const result = yield* db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.where(
+					exists(
+						db
+							.select({ one: sql`1` })
+							.from(user)
+							.where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
+					),
+				)
+				.all();
+
+			expect(result).deep.equal([{ name: 'John' }]);
+		}));
+	}
+
+	selectWithGroupByAsSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const result = yield* db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(sql`${usersTable.name}`)
+				.all();
+
+			expect(result).deep.equal([{ name: 'Jane' }, { name: 'John' }]);
+		}));
+	}
+
+	selectWithGroupByAsSqlPlusColumn(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const result = yield* db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(sql`${usersTable.name}`, usersTable.id)
+				.all();
+
+			expect(result).deep.equal([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		}));
+	}
+
+	selectWithGroupByAsColumnPlusSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const result = yield* db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`)
+				.all();
+
+			expect(result).deep.equal([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		}));
+	}
+
+	selectWithGroupByComplexQuery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
+
+			const result = yield* db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, sql`${usersTable.name}`)
+				.orderBy(asc(usersTable.name))
+				.limit(1)
+				.all();
+
+			expect(result).deep.equal([{ name: 'Jane' }]);
+		}));
+	}
+
+	buildQuery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const query = db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.groupBy(usersTable.id, usersTable.name)
+				.toSQL();
+
+			expect(query).deep.equal({
+				sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+				params: [],
+			});
+		}));
+	}
+
+	insertViaDbRunPlusSelectViaDbAll(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+			const result = yield* db.all<{ id: number; name: string }>(sql`select id, name from "users"`);
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	insertViaDbGet(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const inserted = yield* db.get<{ id: number; name: string }>(
+				sql`insert into ${usersTable} (${new Name(
+					usersTable.name.name,
+				)}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+			);
+			expect(inserted).deep.equal({ id: 1, name: 'John' });
+		}));
+	}
+
+	insertViaDbRunPlusSelectViaDbGet(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+			const result = yield* db.get<{ id: number; name: string }>(
+				sql`select ${usersTable.id}, ${usersTable.name} from ${usersTable}`,
+			);
+			expect(result).deep.equal({ id: 1, name: 'John' });
+		}));
+	}
+
+	insertViaDbGetQueryBuilder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const inserted = yield* db.get<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+				db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+			);
+			expect(inserted).deep.equal({ id: 1, name: 'John' });
+		}));
+	}
+
+	joinSubquery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(courseCategoriesTable)
+				.values([{ name: 'Category 1' }, { name: 'Category 2' }, { name: 'Category 3' }, { name: 'Category 4' }])
+				.run();
+
+			yield* db
+				.insert(coursesTable)
+				.values([
+					{ name: 'Development', categoryId: 2 },
+					{ name: 'IT & Software', categoryId: 3 },
+					{ name: 'Marketing', categoryId: 4 },
+					{ name: 'Design', categoryId: 1 },
+				])
+				.run();
+
+			const sq2 = db
+				.select({
+					categoryId: courseCategoriesTable.id,
+					category: courseCategoriesTable.name,
+					total: sql<number>`count(${courseCategoriesTable.id})`,
+				})
+				.from(courseCategoriesTable)
+				.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+				.as('sq2');
+
+			const res = yield* db
+				.select({
+					courseName: coursesTable.name,
+					categoryId: sq2.categoryId,
+				})
+				.from(coursesTable)
+				.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+				.orderBy(coursesTable.name)
+				.all();
+
+			expect(res).deep.equal([
+				{ courseName: 'Design', categoryId: 1 },
+				{ courseName: 'Development', categoryId: 2 },
+				{ courseName: 'IT & Software', categoryId: 3 },
+				{ courseName: 'Marketing', categoryId: 4 },
+			]);
+		}));
+	}
+
+	withSelect(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(orders)
+				.values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				])
+				.run();
+
+			const regionalSales = db.$with('regional_sales').as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
+
+			const topRegions = db.$with('top_regions').as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+						),
+					),
+			);
+
+			const result = yield* db
+				.with(regionalSales, topRegions)
+				.select({
+					region: orders.region,
+					product: orders.product,
+					productUnits: sql<number>`cast(sum(${orders.quantity}) as int)`,
+					productSales: sql<number>`cast(sum(${orders.amount}) as int)`,
+				})
+				.from(orders)
+				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+				.groupBy(orders.region, orders.product)
+				.orderBy(orders.region, orders.product)
+				.all();
+
+			expect(result).deep.equal([
+				{
+					region: 'Europe',
+					product: 'A',
+					productUnits: 3,
+					productSales: 30,
+				},
+				{
+					region: 'Europe',
+					product: 'B',
+					productUnits: 5,
+					productSales: 50,
+				},
+				{
+					region: 'US',
+					product: 'A',
+					productUnits: 7,
+					productSales: 70,
+				},
+				{
+					region: 'US',
+					product: 'B',
+					productUnits: 9,
+					productSales: 90,
+				},
+			]);
+		}));
+	}
+
+	withUpdate(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const products = sqliteTable('products', {
+				id: integer('id').primaryKey(),
+				price: numeric('price').notNull(),
+				cheap: integer('cheap', { mode: 'boolean' }).notNull().default(false),
+			});
+
+			yield* db.run(sql`drop table if exists ${products}`);
+			yield* db.run(sql`
+				create table ${products} (
+					id integer primary key,
+					price numeric not null,
+					cheap integer not null default 0
+				)
+			`);
+
+			yield* db
+				.insert(products)
+				.values([{ price: '10.99' }, { price: '25.85' }, { price: '32.99' }, { price: '2.50' }, { price: '4.59' }]);
+
+			const averagePrice = db.$with('average_price').as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
+
+			const result = yield* db
+				.with(averagePrice)
+				.update(products)
+				.set({
+					cheap: true,
+				})
+				.where(lt(products.price, sql`(select * from ${averagePrice})`))
+				.returning({
+					id: products.id,
+				});
+
+			expect(result).deep.equal([{ id: 1 }, { id: 4 }, { id: 5 }]);
+		}));
+	}
+
+	withInsert(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users', {
+				username: text('username').notNull(),
+				admin: integer('admin', { mode: 'boolean' }).notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(sql`create table ${users} (username text not null, admin integer not null default 0)`);
+
+			const userCount = db.$with('user_count').as(
+				db
+					.select({
+						value: sql`count(*)`.as('value'),
+					})
+					.from(users),
+			);
+
+			const result = yield* db
+				.with(userCount)
+				.insert(users)
+				.values([{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` }])
+				.returning({
+					admin: users.admin,
+				});
+
+			expect(result).deep.equal([{ admin: true }]);
+		}));
+	}
+
+	withDelete(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(orders).values([
+				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+			]);
+
+			const averageAmount = db.$with('average_amount').as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
+
+			const result = yield* db
+				.with(averageAmount)
+				.delete(orders)
+				.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+				.returning({
+					id: orders.id,
+				})
+				.all();
+
+			expect(result).deep.equal([{ id: 6 }, { id: 7 }, { id: 8 }]);
+		}));
+	}
+
+	selectFromSubquerySql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(users2Table)
+				.values([{ name: 'John' }, { name: 'Jane' }])
+				.run();
+
+			const sq = db
+				.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+				.from(users2Table)
+				.as('sq');
+
+			const res = yield* db.select({ name: sq.name }).from(sq).all();
+
+			expect(res).deep.equal([{ name: 'John modified' }, { name: 'Jane modified' }]);
+		}));
+	}
+
+	selectAFieldWithoutJoiningItsTable(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).throw();
+		}));
+	}
+
+	selectAllFieldsFromSubqueryWithoutAlias(): Promise<void> {
+		const { db } = this;
+		// oxlint-disable-next-line require-yield
+		return this.exec(Effect.gen(function*() {
+			const sq = db.$with('sq').as(
+				db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table),
+			);
+
+			expect(() => db.select().from(sq).prepare()).throw();
+		}));
+	}
+
+	selectCount(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }])
+				.run();
+
+			const res = yield* db
+				.select({ count: sql`count(*)` })
+				.from(usersTable)
+				.all();
+
+			expect(res).deep.equal([{ count: 2 }]);
+		}));
+	}
+
+	having(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(citiesTable)
+				.values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }])
+				.run();
+
+			yield* db
+				.insert(users2Table)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				])
+				.run();
+
+			const result = yield* db
+				.select({
+					id: citiesTable.id,
+					name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+					usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+				})
+				.from(citiesTable)
+				.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+				.where(({ name }) => sql`length(${name}) >= 3`)
+				.groupBy(citiesTable.id)
+				.having(({ usersCount }) => sql`${usersCount} > 0`)
+				.orderBy(({ name }) => name)
+				.all();
+
+			expect(result).deep.equal([
+				{
+					id: 1,
+					name: 'LONDON',
+					usersCount: 2,
+				},
+				{
+					id: 2,
+					name: 'PARIS',
+					usersCount: 1,
+				},
+			]);
+		}));
+	}
+
+	view(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const newYorkers1 = sqliteView('new_yorkers').as((qb) =>
+				qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+			);
+
+			const newYorkers2 = sqliteView('new_yorkers', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+			const newYorkers3 = sqliteView('new_yorkers', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			}).existing();
+
+			yield* db.run(sql`create view if not exists new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+			yield* db
+				.insert(citiesTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }])
+				.run();
+
+			yield* db
+				.insert(users2Table)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				])
+				.run();
+
+			{
+				const result = yield* db.select().from(newYorkers1).all();
+				expect(result).deep.equal([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = yield* db.select().from(newYorkers2).all();
+				expect(result).deep.equal([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = yield* db.select().from(newYorkers3).all();
+				expect(result).deep.equal([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 1 },
+				]);
+			}
+
+			{
+				const result = yield* db.select({ name: newYorkers1.name }).from(newYorkers1).all();
+				expect(result).deep.equal([{ name: 'John' }, { name: 'Jane' }]);
+			}
+
+			yield* db.run(sql`drop view ${newYorkers1}`);
+		}));
+	}
+
+	insertNullTimestamp(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const test = sqliteTable('test', {
+				t: integer('t', { mode: 'timestamp' }),
+			});
+
+			yield* db.run(sql`create table ${test} (t timestamp)`);
+
+			yield* db.insert(test).values({ t: null }).run();
+			const res = yield* db.select().from(test).all();
+			expect(res).deep.equal([{ t: null }]);
+
+			yield* db.run(sql`drop table ${test}`);
+		}));
+	}
+
+	selectFromRawSql(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			const result = yield* db
+				.select({
+					id: sql<number>`id`,
+					name: sql<string>`name`,
+				})
+				.from(sql`(select 1 as id, 'John' as name) as users`)
+				.all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	selectFromRawSqlWithJoins(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const result = yield* db
+				.select({
+					id: sql<number>`users.id`,
+					name: sql<string>`users.name`.as('userName'),
+					userCity: sql<string>`users.city`,
+					cityName: sql<string>`cities.name`.as('cityName'),
+				})
+				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`)
+				.all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' }]);
+		}));
+	}
+
+	joinOnAliasedSqlFromSelect(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const result = yield* db
+				.select({
+					userId: sql<number>`users.id`.as('userId'),
+					name: sql<string>`users.name`.as('userName'),
+					userCity: sql<string>`users.city`,
+					cityId: sql<number>`cities.id`.as('cityId'),
+					cityName: sql<string>`cities.name`.as('cityName'),
+				})
+				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId))
+				.all();
+
+			expect(result).deep.equal([{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
+		}));
+	}
+
+	joinOnAliasedSqlFromWithClause(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = db.$with('users').as(
+				db
+					.select({
+						id: sql<number>`id`.as('userId'),
+						name: sql<string>`name`.as('userName'),
+						city: sql<string>`city`.as('city'),
+					})
+					.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`),
+			);
+
+			const cities = db.$with('cities').as(
+				db
+					.select({
+						id: sql<number>`id`.as('cityId'),
+						name: sql<string>`name`.as('cityName'),
+					})
+					.from(sql`(select 1 as id, 'Paris' as name) as cities`),
+			);
+
+			const result = yield* db
+				.with(users, cities)
+				.select({
+					userId: users.id,
+					name: users.name,
+					userCity: users.city,
+					cityId: cities.id,
+					cityName: cities.name,
+				})
+				.from(users)
+				.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId))
+				.all();
+
+			expect(result).deep.equal([{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' }]);
+		}));
+	}
+
+	prefixedTable(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const sqliteTable = sqliteTableCreator((name) => `myprefix_${name}`);
+
+			const users = sqliteTable('test_prefixed_table_with_unique_name', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(
+				sql`create table myprefix_test_prefixed_table_with_unique_name (id integer not null primary key, name text not null)`,
+			);
+
+			yield* db.insert(users).values({ id: 1, name: 'John' }).run();
+
+			const result = yield* db.select().from(users).all();
+
+			expect(result).deep.equal([{ id: 1, name: 'John' }]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	orderByWithAliasedColumn(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const query = db
+				.select({
+					test: sql`something`.as('test'),
+				})
+				.from(users2Table)
+				.orderBy((fields) => fields.test)
+				.toSQL();
+
+			expect(query.sql).equal('select something as "test" from "users2" order by "test"');
+		}));
+	}
+
+	joinSubqueryWithJoin(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const internalStaff = sqliteTable('internal_staff', {
+				userId: integer('user_id').notNull(),
+			});
+
+			const customUser = sqliteTable('custom_user', {
+				id: integer('id').notNull(),
+			});
+
+			const ticket = sqliteTable('ticket', {
+				staffId: integer('staff_id').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${internalStaff}`);
+			yield* db.run(sql`drop table if exists ${customUser}`);
+			yield* db.run(sql`drop table if exists ${ticket}`);
+
+			yield* db.run(sql`create table internal_staff (user_id integer not null)`);
+			yield* db.run(sql`create table custom_user (id integer not null)`);
+			yield* db.run(sql`create table ticket (staff_id integer not null)`);
+
+			yield* db.insert(internalStaff).values({ userId: 1 }).run();
+			yield* db.insert(customUser).values({ id: 1 }).run();
+			yield* db.insert(ticket).values({ staffId: 1 }).run();
+
+			const subq = db.select().from(internalStaff).leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+				.as('internal_staff');
+
+			const mainQuery = yield* db.select().from(ticket).leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId))
+				.all();
+
+			expect(mainQuery).deep.equal([
+				{
+					ticket: { staffId: 1 },
+					internal_staff: {
+						internal_staff: { userId: 1 },
+						custom_user: { id: 1 },
+					},
+				},
+			]);
+
+			yield* db.run(sql`drop table ${internalStaff}`);
+			yield* db.run(sql`drop table ${customUser}`);
+			yield* db.run(sql`drop table ${ticket}`);
+		}));
+	}
+
+	joinViewAsSubquery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users_join_view', {
+				id: integer('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').notNull(),
+			});
+
+			const newYorkers = sqliteView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(sql`drop view if exists ${newYorkers}`);
+
+			yield* db.run(
+				sql`create table ${users} (id integer not null primary key, name text not null, city_id integer not null)`,
+			);
+			yield* db.run(sql`create view if not exists ${newYorkers} as ${getViewConfig(newYorkers).query}`);
+
+			yield* db
+				.insert(users)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 2 },
+					{ name: 'Jack', cityId: 1 },
+					{ name: 'Jill', cityId: 2 },
+				])
+				.run();
+
+			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+			const result = yield* db.select().from(users).leftJoin(sq, eq(users.id, sq.id)).all();
+
+			expect(result).deep.equal([
+				{
+					users_join_view: { id: 1, name: 'John', cityId: 1 },
+					new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+				},
+				{
+					users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+					new_yorkers_sq: null,
+				},
+				{
+					users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+					new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+				},
+				{
+					users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+					new_yorkers_sq: null,
+				},
+			]);
+
+			yield* db.run(sql`drop view ${newYorkers}`);
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	insertWithOnConflictDoNothing(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+			yield* db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing().run();
+
+			const res = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			).all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	insertWithOnConflictDoNothinUsingCompositePk(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john@example.com' }).run();
+
+			yield* db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john1@example.com' }).onConflictDoNothing()
+				.run();
+
+			const res = yield* db
+				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+				.from(pkExampleTable)
+				.where(eq(pkExampleTable.id, 1))
+				.all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John', email: 'john@example.com' }]);
+		}));
+	}
+
+	insertWithOnConflictDoNothingUsingTarget(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+			yield* db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing({ target: usersTable.id }).run();
+
+			const res = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			).all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John' }]);
+		}));
+	}
+
+	insertWithOnConflictDoNothingUsingCompositePkAsTarget(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john@example.com' }).run();
+
+			yield* db
+				.insert(pkExampleTable)
+				.values({ id: 1, name: 'John', email: 'john1@example.com' })
+				.onConflictDoNothing({ target: [pkExampleTable.id, pkExampleTable.name] })
+				.run();
+
+			const res = yield* db
+				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+				.from(pkExampleTable)
+				.where(eq(pkExampleTable.id, 1))
+				.all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John', email: 'john@example.com' }]);
+		}));
+	}
+
+	insertWithOnConflictDoUpdate(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+
+			yield* db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John' })
+				.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+				.run();
+
+			const res = yield* db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+				eq(usersTable.id, 1),
+			).all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John1' }]);
+		}));
+	}
+
+	insertWithOnConflictDoUpdateWhere(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db
+				.insert(usersTable)
+				.values([{ id: 1, name: 'John', verified: false }])
+				.run();
+
+			yield* db
+				.insert(usersTable)
+				.values({ id: 1, name: 'John1', verified: true })
+				.onConflictDoUpdate({
+					target: usersTable.id,
+					set: { name: 'John1', verified: true },
+					where: eq(usersTable.verified, false),
+				})
+				.run();
+
+			const res = yield* db
+				.select({ id: usersTable.id, name: usersTable.name, verified: usersTable.verified })
+				.from(usersTable)
+				.where(eq(usersTable.id, 1))
+				.all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John1', verified: true }]);
+		}));
+	}
+
+	insertWithOnConflictDoUpdateUsingCompositePk(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john@example.com' }).run();
+
+			yield* db
+				.insert(pkExampleTable)
+				.values({ id: 1, name: 'John', email: 'john@example.com' })
+				.onConflictDoUpdate({ target: [pkExampleTable.id, pkExampleTable.name], set: { email: 'john1@example.com' } })
+				.run();
+
+			const res = yield* db
+				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
+				.from(pkExampleTable)
+				.where(eq(pkExampleTable.id, 1))
+				.all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John', email: 'john1@example.com' }]);
+		}));
+	}
+
+	apiCRUD(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text)`);
+
+			yield* db.insert(users).values({ id: 1, name: 'John' }).run();
+
+			const res = yield* db.select().from(users).all();
+
+			expect(res).deep.equal([{ id: 1, name: 'John' }]);
+
+			yield* db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).all();
+
+			const res1 = yield* db.select().from(users).all();
+
+			expect(res1).deep.equal([{ id: 1, name: 'John1' }]);
+
+			yield* db.delete(users).where(eq(users.id, 1)).run();
+
+			const res2 = yield* db.select().from(users).all();
+
+			expect(res2).deep.equal([]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	apiInsertPlusSelectPreparePlusAsyncExecute(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text)`);
+
+			const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
+			yield* insertStmt.execute();
+
+			const selectStmt = db.select().from(users).prepare();
+			const res = yield* selectStmt.execute();
+
+			expect(res).deep.equal([{ id: 1, name: 'John' }]);
+
+			const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
+			yield* updateStmt.execute();
+
+			const res1 = yield* selectStmt.execute();
+
+			expect(res1).deep.equal([{ id: 1, name: 'John1' }]);
+
+			const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+			yield* deleteStmt.execute();
+
+			const res2 = yield* selectStmt.execute();
+
+			expect(res2).deep.equal([]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	apiInsertSelectPreparePlusSyncExecute(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text)`);
+
+			const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
+			yield* insertStmt.execute();
+
+			const selectStmt = db.select().from(users).prepare();
+			const res = yield* selectStmt.execute();
+
+			expect(res).deep.equal([{ id: 1, name: 'John' }]);
+
+			const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
+			yield* updateStmt.execute();
+
+			const res1 = yield* selectStmt.execute();
+
+			expect(res1).deep.equal([{ id: 1, name: 'John1' }]);
+
+			const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+			yield* deleteStmt.execute();
+
+			const res2 = yield* selectStmt.execute();
+
+			expect(res2).deep.equal([]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	selectPlusGetForEmptyResult(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users', {
+				id: integer('id').primaryKey(),
+				name: text('name'),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+
+			yield* db.run(sql`create table ${users} (id integer primary key, name text)`);
+
+			const res = yield* db.select().from(users).where(eq(users.id, 1)).get();
+
+			expect(res).eq(undefined);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	setOperationsUnionFromQueryBuilderWithSubquery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const sq = db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.union(db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table))
+				.orderBy(asc(sql`name`))
+				.as('sq');
+
+			const result = yield* db.select().from(sq).limit(5).offset(5);
+
+			expect(result).length(5);
+
+			expect(result).deep.equal([
+				{ id: 2, name: 'London' },
+				{ id: 7, name: 'Mary' },
+				{ id: 1, name: 'New York' },
+				{ id: 4, name: 'Peter' },
+				{ id: 8, name: 'Sally' },
+			]);
+
+			expect(() => {
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable).union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table),
+					).orderBy(asc(sql`name`)).all();
+			}).throw();
+		}));
+	}
+
+	setOperationsUnionAsFunction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* union(
+				db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable).where(eq(citiesTable.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+			).orderBy(asc(sql`name`)).all();
+
+			expect(result).length(2);
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'New York' },
+			]);
+
+			expect(() => {
+				union(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(eq(citiesTable.id, 1)),
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+				).orderBy(asc(sql`name`)).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsUnionAllFromQueryBuilder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.unionAll(db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable))
+				.orderBy(asc(citiesTable.id))
+				.limit(5)
+				.offset(1).all();
+
+			expect(result).length(5);
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			expect(() => {
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).unionAll(
+						db
+							.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable),
+					).orderBy(asc(citiesTable.id)).limit(5).offset(1).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsUnionAllAsFunction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* unionAll(
+				db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable).where(eq(citiesTable.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+			).all();
+
+			expect(result).length(3);
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'New York' },
+				{ id: 1, name: 'John' },
+				{ id: 1, name: 'John' },
+			]);
+
+			expect(() => {
+				unionAll(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(eq(citiesTable.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+				).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsIntersectFromQueryBuilder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable)
+				.intersect(
+					db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable).where(gt(citiesTable.id, 1)),
+				)
+				.orderBy(asc(sql`name`)).all();
+
+			expect(result).length(2);
+
+			expect(result).deep.equal([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+
+			expect(() => {
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable).intersect(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+					).orderBy(asc(sql`name`)).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsIntersectAsFunction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* intersect(
+				db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable).where(eq(citiesTable.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+			).all();
+
+			expect(result).length(0);
+
+			expect(result).deep.equal([]);
+
+			expect(() => {
+				intersect(
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(eq(citiesTable.id, 1)),
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+				).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsExceptFromQueryBuilder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* db
+				.select()
+				.from(citiesTable)
+				.except(db.select().from(citiesTable).where(gt(citiesTable.id, 1))).all();
+
+			expect(result).length(1);
+
+			expect(result).deep.equal([{ id: 1, name: 'New York' }]);
+
+			expect(() => {
+				db
+					.select()
+					.from(citiesTable).except(
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+					);
+			}).throw();
+		}));
+	}
+
+	setOperationsExceptAsFunction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* except(
+				db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable),
+				db.select({ id: citiesTable.id, name: citiesTable.name }).from(citiesTable).where(eq(citiesTable.id, 1)),
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+			).orderBy(asc(sql`id`)).all();
+
+			expect(result).length(2);
+
+			expect(result).deep.equal([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+			]);
+			expect(() => {
+				except(
+					db
+						.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable),
+					db
+						.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable).where(eq(citiesTable.id, 1)),
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+				).orderBy(asc(sql`id`)).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsMixedFromQueryBuilder(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const result = yield* db
+				.select()
+				.from(citiesTable)
+				.except(({ unionAll }) =>
+					unionAll(
+						db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+						db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+					)
+				).all();
+
+			expect(result).length(2);
+
+			expect(result).deep.equal([
+				{ id: 1, name: 'New York' },
+				{ id: 2, name: 'London' },
+			]);
+
+			expect(() => {
+				db
+					.select()
+					.from(citiesTable).except(
+						({ unionAll }) =>
+							unionAll(
+								db
+									.select()
+									.from(citiesTable).where(gt(citiesTable.id, 1)),
+								db.select({ name: citiesTable.name, id: citiesTable.id })
+									.from(citiesTable).where(eq(citiesTable.id, 2)),
+							),
+					).run();
+			}).throw();
+		}));
+	}
+
+	setOperationsMixedAllAsFunctionWithSubquery(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* setupSetOperationTest(db);
+
+			const sq = union(
+				db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 1)),
+				except(
+					db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(
+						gte(users2Table.id, 5),
+					),
+					db.select({ id: users2Table.id, name: users2Table.name }).from(users2Table).where(eq(users2Table.id, 7)),
+				),
+				db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+			)
+				.orderBy(asc(sql`id`))
+				.as('sq');
+
+			const result = yield* db.select().from(sq).limit(4).offset(1);
+
+			expect(result).length(4);
+
+			expect(result).deep.equal([
+				{ id: 2, name: 'London' },
+				{ id: 3, name: 'Tampa' },
+				{ id: 5, name: 'Ben' },
+				{ id: 6, name: 'Jill' },
+			]);
+
+			expect(() => {
+				union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 7)),
+					),
+					db
+						.select({ name: users2Table.name, id: users2Table.id })
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+				).orderBy(asc(sql`id`)).run();
+			}).throw();
+		}));
+	}
+
+	aggregateFunctionCount(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const table = aggregateTable;
+			yield* setupAggregateFunctionsTest(db);
+
+			const result1 = yield* db.select({ value: count() }).from(table);
+			const result2 = yield* db.select({ value: count(table.a) }).from(table);
+			const result3 = yield* db.select({ value: countDistinct(table.name) }).from(table);
+
+			expect(result1[0]?.value).eq(7);
+			expect(result2[0]?.value).eq(5);
+			expect(result3[0]?.value).eq(6);
+		}));
+	}
+
+	aggregatFunctionAvg(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const table = aggregateTable;
+			yield* setupAggregateFunctionsTest(db);
+
+			const result1 = yield* db.select({ value: avg(table.a) }).from(table);
+			const result2 = yield* db.select({ value: avg(table.nullOnly) }).from(table);
+			const result3 = yield* db.select({ value: avgDistinct(table.b) }).from(table);
+
+			expect(result1[0]?.value).eq('24');
+			expect(result2[0]?.value).eq(null);
+			expect(result3[0]?.value).eq('42.5');
+		}));
+	}
+
+	aggregateFunctionSum(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const table = aggregateTable;
+			yield* setupAggregateFunctionsTest(db);
+
+			const result1 = yield* db.select({ value: sum(table.b) }).from(table);
+			const result2 = yield* db.select({ value: sum(table.nullOnly) }).from(table);
+			const result3 = yield* db.select({ value: sumDistinct(table.b) }).from(table);
+
+			expect(result1[0]?.value).eq('200');
+			expect(result2[0]?.value).eq(null);
+			expect(result3[0]?.value).eq('170');
+		}));
+	}
+
+	aggregateFunctionMax(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const table = aggregateTable;
+			yield* setupAggregateFunctionsTest(db);
+
+			const result1 = yield* db.select({ value: max(table.b) }).from(table);
+			const result2 = yield* db.select({ value: max(table.nullOnly) }).from(table);
+
+			expect(result1[0]?.value).eq(90);
+			expect(result2[0]?.value).eq(null);
+		}));
+	}
+
+	aggregateFunctionMin(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const table = aggregateTable;
+			yield* setupAggregateFunctionsTest(db);
+
+			const result1 = yield* db.select({ value: min(table.b) }).from(table);
+			const result2 = yield* db.select({ value: min(table.nullOnly) }).from(table);
+
+			expect(result1[0]?.value).eq(10);
+			expect(result2[0]?.value).eq(null);
+		}));
+	}
+
+	test$onUpdateFnAnd$onUpdateWorksAs$default(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.run(sql`drop table if exists ${usersOnUpdate}`);
+
+			yield* db.run(
+				sql`
+					create table ${usersOnUpdate} (
+					id integer primary key autoincrement,
+					name text not null,
+					update_counter integer default 1 not null,
+					updated_at integer,
+					always_null text
+					)
+				`,
+			);
+
+			yield* db
+				.insert(usersOnUpdate)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jack' }, { name: 'Jill' }])
+				.run();
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+			const justDates = yield* db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+			const response = yield* db
+				.select({ ...rest })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			expect(response).deep.equal([
+				{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+			]);
+			const msDelay = 250;
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).greaterThan(Date.now() - msDelay);
+			}
+		}));
+	}
+
+	test$onUpdateFnAnd$onUpdateWorksUpdating(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.run(sql`drop table if exists ${usersOnUpdate}`);
+
+			yield* db.run(
+				sql`
+					create table ${usersOnUpdate} (
+					id integer primary key autoincrement,
+					name text not null,
+					update_counter integer default 1,
+					updated_at integer,
+					always_null text
+					)
+				`,
+			);
+
+			yield* db
+				.insert(usersOnUpdate)
+				.values([{ name: 'John', alwaysNull: 'this will be null after updating' }, { name: 'Jane' }, { name: 'Jack' }, {
+					name: 'Jill',
+				}]);
+			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+			yield* db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id, 1));
+			yield* db.update(usersOnUpdate).set({ updateCounter: null }).where(eq(usersOnUpdate.id, 2));
+
+			const justDates = yield* db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+
+			const response = yield* db
+				.select({ ...rest })
+				.from(usersOnUpdate)
+				.orderBy(asc(usersOnUpdate.id));
+
+			expect(response).deep.equal([
+				{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+				{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
+				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+			]);
+			const msDelay = 250;
+
+			for (const eachUser of justDates) {
+				expect(eachUser.updatedAt!.valueOf()).greaterThan(Date.now() - msDelay);
+			}
+		}));
+	}
+
+	$countSeparate(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = yield* db.$count(countTestTable);
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count).eq(4);
+		}));
+	}
+
+	$countEmbedded(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = yield* db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count).deep.equal([{ count: 4 }, { count: 4 }, { count: 4 }, { count: 4 }]);
+		}));
+	}
+
+	$countSeparateReuse(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db.$count(countTestTable);
+
+			const count1 = yield* count;
+
+			yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = yield* count;
+
+			yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = yield* count;
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count1).eq(4);
+			expect(count2).eq(5);
+			expect(count3).eq(6);
+		}));
+	}
+
+	$countEmbeddedReuse(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
+
+			const count1 = yield* count;
+
+			yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+			const count2 = yield* count;
+
+			yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+			const count3 = yield* count;
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count1).deep.equal([{ count: 4 }, { count: 4 }, { count: 4 }, { count: 4 }]);
+			expect(count2).deep.equal([{ count: 5 }, { count: 5 }, { count: 5 }, { count: 5 }, { count: 5 }]);
+			expect(count3).deep.equal([{ count: 6 }, { count: 6 }, { count: 6 }, { count: 6 }, { count: 6 }, { count: 6 }]);
+		}));
+	}
+
+	$countSeparateWithFilters(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = yield* db.$count(countTestTable, gt(countTestTable.id, 1));
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count).deep.equal(3);
+		}));
+	}
+
+	$countEmbeddedWithFilters(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const countTestTable = sqliteTable('count_test', {
+				id: int('id').notNull(),
+				name: text('name').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${countTestTable}`);
+			yield* db.run(sql`create table ${countTestTable} (id int, name text)`);
+
+			yield* db.insert(countTestTable).values([
+				{ id: 1, name: 'First' },
+				{ id: 2, name: 'Second' },
+				{ id: 3, name: 'Third' },
+				{ id: 4, name: 'Fourth' },
+			]);
+
+			const count = yield* db
+				.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				})
+				.from(countTestTable);
+
+			yield* db.run(sql`drop table ${countTestTable}`);
+
+			expect(count).deep.equal([{ count: 3 }, { count: 3 }, { count: 3 }, { count: 3 }]);
+		}));
+	}
+
+	updateWithLimitAndOrderBy(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values([
+				{ name: 'Barry', verified: false },
+				{ name: 'Alan', verified: false },
+				{ name: 'Carl', verified: false },
+			]);
+
+			yield* db.update(usersTable).set({ verified: true }).limit(2).orderBy(asc(usersTable.name));
+
+			const result = yield* db
+				.select({ name: usersTable.name, verified: usersTable.verified })
+				.from(usersTable)
+				.orderBy(asc(usersTable.name));
+
+			expect(result).deep.equal([
+				{ name: 'Alan', verified: true },
+				{ name: 'Barry', verified: true },
+				{ name: 'Carl', verified: false },
+			]);
+		}));
+	}
+
+	deleteWithLimitAndOrderBy(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.insert(usersTable).values([
+				{ name: 'Barry', verified: false },
+				{ name: 'Alan', verified: false },
+				{ name: 'Carl', verified: false },
+			]);
+
+			yield* db.delete(usersTable).where(eq(usersTable.verified, false)).limit(1).orderBy(asc(usersTable.name));
+
+			const result = yield* db
+				.select({ name: usersTable.name, verified: usersTable.verified })
+				.from(usersTable)
+				.orderBy(asc(usersTable.name));
+			expect(result).deep.equal([
+				{ name: 'Barry', verified: false },
+				{ name: 'Carl', verified: false },
+			]);
+		}));
+	}
+
+	testRqbV2SimpleFindFirstNoRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const result = yield* db.query.rqbUser.findFirst();
+
+			expect(result).deep.equal(undefined);
+		}));
+	}
+
+	testRqbV2SimpleFindFirstMultipleRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = yield* db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).deep.equal({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		}));
+	}
+
+	testRqbV2SimpleFindFirstWithRelation(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			yield* db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = yield* db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).deep.equal({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		}));
+	}
+
+	testRqbV2SimpleFindFirstPlaceholders(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = yield* query.execute({
+				filter: 2,
+			});
+
+			expect(result).deep.equal({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		}));
+	}
+
+	testRqbV2SimpleFindManyNoRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const result = yield* db.query.rqbUser.findMany();
+
+			expect(result).deep.equal([]);
+		}));
+	}
+
+	testRqbV2SimpleFindManyMultipleRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const result = yield* db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			});
+
+			expect(result).deep.equal([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		}));
+	}
+
+	testRqbV2SimpleFindManyWithRelation(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			yield* db.insert(rqbPost).values([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+
+			const result = yield* db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			});
+
+			expect(result).deep.equal([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		}));
+	}
+
+	testRqbV2SimpleFindManyPlaceholders(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+
+			const date = new Date(120000);
+
+			yield* db.insert(rqbUser).values([{
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = yield* query.execute({
+				filter: 2,
+			});
+
+			expect(result).deep.equal([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		}));
+	}
+
+	transaction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users_transactions', {
+				id: integer('id').primaryKey(),
+				balance: integer('balance').notNull(),
+			});
+			const products = sqliteTable('products_transactions', {
+				id: integer('id').primaryKey(),
+				price: integer('price').notNull(),
+				stock: integer('stock').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(sql`drop table if exists ${products}`);
+
+			yield* db.run(sql`create table users_transactions (id integer not null primary key, balance integer not null)`);
+			yield* db.run(
+				sql`create table products_transactions (id integer not null primary key, price integer not null, stock integer not null)`,
+			);
+
+			const [user] = yield* db.insert(users).values({ balance: 100 }).returning();
+			const [product] = yield* db.insert(products).values({ price: 10, stock: 10 }).returning();
+
+			yield* db.transaction((tx) =>
+				Effect.gen(function*() {
+					yield* tx.update(users).set({ balance: user!.balance - product!.price }).where(eq(users.id, user!.id));
+					yield* tx.update(products).set({ stock: product!.stock - 1 }).where(eq(products.id, product!.id));
+				})
+			);
+
+			const result = yield* db.select().from(users);
+			expect(result).deep.equal([{ id: 1, balance: 90 }]);
+
+			yield* db.run(sql`drop table ${users}`);
+			yield* db.run(sql`drop table ${products}`);
+		}));
+	}
+
+	nestedTransaction(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const users = sqliteTable('users_nested_transactions', {
+				id: integer('id').primaryKey(),
+				balance: integer('balance').notNull(),
+			});
+
+			yield* db.run(sql`drop table if exists ${users}`);
+			yield* db.run(
+				sql`create table users_nested_transactions (id integer not null primary key, balance integer not null)`,
+			);
+
+			yield* db.transaction((tx) =>
+				Effect.gen(function*() {
+					yield* tx.insert(users).values({ balance: 100 });
+					yield* tx.transaction((tx2) =>
+						Effect.gen(function*() {
+							yield* tx2.update(users).set({ balance: 200 });
+						})
+					);
+				})
+			);
+
+			const result = yield* db.select().from(users);
+			expect(result).deep.equal([{ id: 1, balance: 200 }]);
+
+			yield* db.run(sql`drop table ${users}`);
+		}));
+	}
+
+	testRqbV2TransactionFindFirstNoRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbUser.findFirst();
+					expect(result).deep.equal(undefined);
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindFirstMultipleRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbUser.findFirst({ orderBy: { id: 'desc' } });
+					expect(result).deep.equal({ id: 2, createdAt: date, name: 'Second' });
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindFirstWithRelation(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.insert(rqbPost).values([{ id: 1, userId: 1, createdAt: date, content: null }, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbUser.findFirst({
+						with: { posts: { orderBy: { id: 'asc' } } },
+						orderBy: { id: 'asc' },
+					});
+					expect(result).deep.equal({
+						id: 1,
+						createdAt: date,
+						name: 'First',
+						posts: [{ id: 1, userId: 1, createdAt: date, content: null }, {
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+						}],
+					});
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindFirstPlaceholders(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const query = db.query.rqbUser.findFirst({
+						where: { id: { eq: sql.placeholder('filter') } },
+						orderBy: { id: 'asc' },
+					}).prepare();
+					const result = yield* query.execute({ filter: 2 });
+					expect(result).deep.equal({ id: 2, createdAt: date, name: 'Second' });
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindManyNoRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbUser.findMany();
+					expect(result).deep.equal([]);
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindManyMultipleRows(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbUser.findMany({ orderBy: { id: 'desc' } });
+					expect(result).deep.equal([{ id: 2, createdAt: date, name: 'Second' }, {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					}]);
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindManyWithRelation(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.insert(rqbPost).values([{ id: 1, userId: 1, createdAt: date, content: null }, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const result = yield* db.query.rqbPost.findMany({ with: { author: true }, orderBy: { id: 'asc' } });
+					expect(result).deep.equal([{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+						author: { id: 1, createdAt: date, name: 'First' },
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+						author: { id: 1, createdAt: date, name: 'First' },
+					}]);
+				})
+			);
+		}));
+	}
+
+	testRqbV2TransactionFindManyPlaceholders(): Promise<void> {
+		const { db } = this;
+		return this.exec(Effect.gen(function*() {
+			yield* beforeEach(db);
+			const date = new Date(120000);
+			yield* db.insert(rqbUser).values([{ id: 1, createdAt: date, name: 'First' }, {
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+			yield* db.transaction((db) =>
+				Effect.gen(function*() {
+					const query = db.query.rqbUser.findMany({
+						where: { id: { eq: sql.placeholder('filter') } },
+						orderBy: { id: 'asc' },
+					}).prepare();
+					const result = yield* query.execute({ filter: 2 });
+					expect(result).deep.equal([{ id: 2, createdAt: date, name: 'Second' }]);
+				})
+			);
+		}));
+	}
+}
+
+const TESTS = [
+	'migrate1',
+	'insertBigIntValues',
+	'selectAllFields',
+	'selectPartial',
+	'selectSql',
+	'selectTypedSql',
+	'selectWithEmptyArrayInInArray',
+	'selectWithEmptyArrayInNotInArray',
+	'selectDistinct',
+	'returingSql',
+	'$defaultFunction',
+	'deleteReturningSql',
+	'queryCheckInsertSingleEmptyRow',
+	'queryCheckInsertMultipleEmptyRow',
+	'insertAllDefaultsIn1Row',
+	'insertAllDefaultsInMultipleRows',
+	'updateReturningSql',
+	'insertWithAutoIncrement',
+	'insertDataWithDefaultValues',
+	'insertDataWithOverridenDefaultValues',
+	'updateWithReturningFields',
+	'updateWithReturningPartial',
+	'updateWithReturningAllFields',
+	'deleteWithReturningPartial',
+	'insertAndSelect',
+	'jsonInsert',
+	'insertMany',
+	'insertManyWithReturning',
+	'partialJoinWithAlias',
+	'fullJoinWithAlias',
+	'selectFromAlias',
+	'insertWithSpaces',
+	'preparedStatement',
+	'preparedStatementReuse',
+	'insertPlaceholdersOnColumnsWithEncoder',
+	'preparedStatementWithPlaceholderInWhere',
+	'preparedStatementWithPlaceholderInLimit',
+	'preparedStatementWithPlaceholderInOffset',
+	'preparedStatementBuiltUsing$dynamic',
+	'selectWithGroupByAsField',
+	'selectWithExists',
+	'selectWithGroupByAsSql',
+	'selectWithGroupByAsSqlPlusColumn',
+	'selectWithGroupByAsColumnPlusSql',
+	'selectWithGroupByComplexQuery',
+	'buildQuery',
+	'insertViaDbRunPlusSelectViaDbAll',
+	'insertViaDbGet',
+	'insertViaDbRunPlusSelectViaDbGet',
+	'insertViaDbGetQueryBuilder',
+	'joinSubquery',
+	'withSelect',
+	'withUpdate',
+	'withInsert',
+	'withDelete',
+	'selectFromSubquerySql',
+	'selectAFieldWithoutJoiningItsTable',
+	'selectAllFieldsFromSubqueryWithoutAlias',
+	'selectCount',
+	'having',
+	'view',
+	'insertNullTimestamp',
+	'selectFromRawSql',
+	'selectFromRawSqlWithJoins',
+	'joinOnAliasedSqlFromSelect',
+	'joinOnAliasedSqlFromWithClause',
+	'prefixedTable',
+	'orderByWithAliasedColumn',
+	'transaction',
+	'nestedTransaction',
+	'joinSubqueryWithJoin',
+	'joinViewAsSubquery',
+	'insertWithOnConflictDoNothing',
+	'insertWithOnConflictDoNothinUsingCompositePk',
+	'insertWithOnConflictDoNothingUsingTarget',
+	'insertWithOnConflictDoNothingUsingCompositePkAsTarget',
+	'insertWithOnConflictDoUpdate',
+	'insertWithOnConflictDoUpdateWhere',
+	'insertWithOnConflictDoUpdateUsingCompositePk',
+	'apiCRUD',
+	'apiInsertPlusSelectPreparePlusAsyncExecute',
+	'apiInsertSelectPreparePlusSyncExecute',
+	'selectPlusGetForEmptyResult',
+	'setOperationsUnionFromQueryBuilderWithSubquery',
+	'setOperationsUnionAsFunction',
+	'setOperationsUnionAllFromQueryBuilder',
+	'setOperationsUnionAllAsFunction',
+	'setOperationsIntersectFromQueryBuilder',
+	'setOperationsIntersectAsFunction',
+	'setOperationsExceptFromQueryBuilder',
+	'setOperationsExceptAsFunction',
+	'setOperationsMixedFromQueryBuilder',
+	'setOperationsMixedAllAsFunctionWithSubquery',
+	'aggregateFunctionCount',
+	'aggregatFunctionAvg',
+	'aggregateFunctionSum',
+	'aggregateFunctionMax',
+	'aggregateFunctionMin',
+	'test$onUpdateFnAnd$onUpdateWorksAs$default',
+	'test$onUpdateFnAnd$onUpdateWorksUpdating',
+	'$countSeparate',
+	'$countEmbedded',
+	'$countSeparateReuse',
+	'$countEmbeddedReuse',
+	'$countSeparateWithFilters',
+	'$countEmbeddedWithFilters',
+	'updateWithLimitAndOrderBy',
+	'deleteWithLimitAndOrderBy',
+	'testRqbV2SimpleFindFirstNoRows',
+	'testRqbV2SimpleFindFirstMultipleRows',
+	'testRqbV2SimpleFindFirstWithRelation',
+	'testRqbV2SimpleFindFirstPlaceholders',
+	'testRqbV2SimpleFindManyNoRows',
+	'testRqbV2SimpleFindManyMultipleRows',
+	'testRqbV2SimpleFindManyWithRelation',
+	'testRqbV2SimpleFindManyPlaceholders',
+	'testRqbV2TransactionFindFirstNoRows',
+	'testRqbV2TransactionFindFirstMultipleRows',
+	'testRqbV2TransactionFindFirstWithRelation',
+	'testRqbV2TransactionFindFirstPlaceholders',
+	'testRqbV2TransactionFindManyNoRows',
+	'testRqbV2TransactionFindManyMultipleRows',
+	'testRqbV2TransactionFindManyWithRelation',
+	'testRqbV2TransactionFindManyPlaceholders',
+] as const;
+
+export default {
+	async fetch(_request, env): Promise<Response> {
+		const id: DurableObjectId = env.MY_DURABLE_OBJECT.idFromName('durable-object');
+		const stub = env.MY_DURABLE_OBJECT.get(id);
+
+		const lines: string[] = [];
+		let failed = 0;
+		for (const name of TESTS) {
+			try {
+				await (stub as any)[name]();
+				lines.push(`✓ ${name}`);
+			} catch (error: any) {
+				failed++;
+				const msg = String(error?.message ?? error).split('\n')[0];
+				lines.push(`✗ ${name}: ${msg}`);
+			}
+		}
+
+		const body = `${failed === 0 ? 'OK' : `${failed}/${TESTS.length} FAILED`}\n\n${lines.join('\n')}`;
+		return new Response(body, { status: failed === 0 ? 200 : 500 });
+	},
+} satisfies ExportedHandler<Env>;
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/worker-configuration.d.ts b/integration-tests/tests/sqlite/durable-objects-effect/worker-configuration.d.ts
new file mode 100644
index 0000000000..cab87a7b0f
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/worker-configuration.d.ts
@@ -0,0 +1,5 @@
+// Generated by Wrangler by running `wrangler types`
+
+interface Env {
+	MY_DURABLE_OBJECT: DurableObjectNamespace<import('.').MyDurableObject>;
+}
diff --git a/integration-tests/tests/sqlite/durable-objects-effect/wrangler.toml b/integration-tests/tests/sqlite/durable-objects-effect/wrangler.toml
new file mode 100644
index 0000000000..90d29435f1
--- /dev/null
+++ b/integration-tests/tests/sqlite/durable-objects-effect/wrangler.toml
@@ -0,0 +1,23 @@
+#:schema node_modules/wrangler/config-schema.json
+name = "sqlite-durable-objects-effect"
+main = "index.ts"
+compatibility_date = "2024-11-12"
+compatibility_flags = [ "nodejs_compat" ]
+
+# Bind a Durable Object. Durable objects are a scale-to-zero compute primitive based on the actor model.
+# Durable Objects can live for as long as needed. Use these when you need a long-running "server", such as in realtime apps.
+# Docs: https://developers.cloudflare.com/workers/wrangler/configuration/#durable-objects
+[[durable_objects.bindings]]
+name = "MY_DURABLE_OBJECT"
+class_name = "MyDurableObject"
+
+# Durable Object migrations.
+# Docs: https://developers.cloudflare.com/workers/wrangler/configuration/#migrations
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["MyDurableObject"]
+
+[[rules]]
+type = "Text"
+globs = ["**/*.sql"]
+fallthrough = true
diff --git a/integration-tests/tests/sqlite/durable-objects/index.ts b/integration-tests/tests/sqlite/durable-objects/index.ts
index b67534d4ee..46c1ebb4be 100644
--- a/integration-tests/tests/sqlite/durable-objects/index.ts
+++ b/integration-tests/tests/sqlite/durable-objects/index.ts
@@ -1,6 +1,5 @@
 /// <reference types="@cloudflare/workers-types" />
 
-import { expect } from 'chai';
 import { DurableObject } from 'cloudflare:workers';
 import {
 	and,
@@ -9,6 +8,7 @@ import {
 	avgDistinct,
 	count,
 	countDistinct,
+	defineRelations,
 	eq,
 	exists,
 	getTableColumns,
@@ -28,7 +28,6 @@ import { drizzle, type DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlit
 import { migrate } from 'drizzle-orm/durable-sqlite/migrator';
 import {
 	alias,
-	type BaseSQLiteDatabase,
 	blob,
 	except,
 	getViewConfig,
@@ -37,6 +36,7 @@ import {
 	intersect,
 	numeric,
 	primaryKey,
+	type SQLiteAsyncDatabase,
 	sqliteTable,
 	sqliteTableCreator,
 	sqliteView,
@@ -44,6 +44,8 @@ import {
 	union,
 	unionAll,
 } from 'drizzle-orm/sqlite-core';
+// Can't use 'vitest' due to it having setTimeout in code, thus breaking workers
+import { expect } from 'chai';
 import { type Equal, Expect } from '~/utils';
 import migrations from './drizzle/migrations';
 
@@ -109,9 +111,7 @@ export const pkExampleTable = sqliteTable('pk_example', {
 	id: integer('id').notNull(),
 	name: text('name').notNull(),
 	email: text('email').notNull(),
-}, (table) => ({
-	compositePk: primaryKey({ columns: [table.id, table.name] }),
-}));
+}, (table) => [primaryKey({ columns: [table.id, table.name] })]);
 
 export const bigIntExample = sqliteTable('big_int_example', {
 	id: integer('id').primaryKey(),
@@ -129,7 +129,36 @@ export const aggregateTable = sqliteTable('aggregate_table', {
 	nullOnly: integer('null_only'),
 });
 
-async function setupSetOperationTest(db: BaseSQLiteDatabase<any, any>) {
+export const rqbUser = sqliteTable('user_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const rqbPost = sqliteTable('post_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const relations = defineRelations({ rqbUser, rqbPost }, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
+
+async function setupSetOperationTest(db: SQLiteAsyncDatabase<any, any, typeof relations>) {
 	await db.run(sql`drop table if exists users2`);
 	await db.run(sql`drop table if exists cities`);
 	await db.run(sql`
@@ -165,7 +194,7 @@ async function setupSetOperationTest(db: BaseSQLiteDatabase<any, any>) {
 	]);
 }
 
-async function setupAggregateFunctionsTest(db: BaseSQLiteDatabase<any, any>) {
+async function setupAggregateFunctionsTest(db: SQLiteAsyncDatabase<any, any, typeof relations>) {
 	await db.run(sql`drop table if exists "aggregate_table"`);
 	await db.run(
 		sql`
@@ -193,11 +222,11 @@ async function setupAggregateFunctionsTest(db: BaseSQLiteDatabase<any, any>) {
 // eslint-disable-next-line drizzle-internal/require-entity-kind
 export class MyDurableObject extends DurableObject {
 	storage: DurableObjectStorage;
-	db: DrizzleSqliteDODatabase;
+	db: DrizzleSqliteDODatabase<typeof relations>;
 	constructor(ctx: DurableObjectState, env: Env) {
 		super(ctx, env);
 		this.storage = ctx.storage;
-		this.db = drizzle(this.storage, { logger: false });
+		this.db = drizzle(this.storage, { logger: false, relations });
 	}
 
 	async migrate1(): Promise<void> {
@@ -234,6 +263,8 @@ export class MyDurableObject extends DurableObject {
 		this.db.run(sql`drop table if exists ${orders}`);
 		this.db.run(sql`drop table if exists ${bigIntExample}`);
 		this.db.run(sql`drop table if exists ${pkExampleTable}`);
+		this.db.run(sql`drop table if exists ${rqbUser}`);
+		this.db.run(sql`drop table if exists ${rqbPost}`);
 		this.db.run(sql`drop table if exists user_notifications_insert_into`);
 		this.db.run(sql`drop table if exists users_insert_into`);
 		this.db.run(sql`drop table if exists notifications_insert_into`);
@@ -299,6 +330,21 @@ export class MyDurableObject extends DurableObject {
 			  big_int blob not null
 			)
 		`);
+		this.db.run(sql`
+			CREATE TABLE ${rqbUser} (
+			  id INT PRIMARY KEY NOT NULL,
+			  name TEXT NOT NULL,
+			  created_at INT NOT NULL
+			)
+		`);
+		this.db.run(sql`
+			CREATE TABLE ${rqbPost} ( 
+			  id INT PRIMARY KEY NOT NULL,
+			  user_id INT NOT NULL,
+			  content TEXT,
+			  created_at INT NOT NULL
+			)
+		`);
 	}
 
 	async insertBigIntValues(): Promise<void> {
@@ -2087,7 +2133,7 @@ export class MyDurableObject extends DurableObject {
 			const user = this.db.insert(users).values({ balance: 100 }).returning().get();
 			const product = this.db.insert(products).values({ price: 10, stock: 10 }).returning().get();
 
-			this.db.transaction(async (tx) => {
+			this.db.transaction((tx) => {
 				tx.update(users)
 					.set({ balance: user.balance - product.price })
 					.where(eq(users.id, user.id))
@@ -2467,46 +2513,46 @@ export class MyDurableObject extends DurableObject {
 		}
 	}
 
-	async insertUndefined(): Promise<void> {
-		const users = sqliteTable('users', {
-			id: integer('id').primaryKey(),
-			name: text('name'),
-		});
+	// async insertUndefined(): Promise<void> {
+	// 	const users = sqliteTable('users', {
+	// 		id: integer('id').primaryKey(),
+	// 		name: text('name'),
+	// 	});
 
-		this.db.run(sql`drop table if exists ${users}`);
+	// 	this.db.run(sql`drop table if exists ${users}`);
 
-		this.db.run(
-			sql`create table ${users} (id integer primary key, name text)`,
-		);
+	// 	this.db.run(
+	// 		sql`create table ${users} (id integer primary key, name text)`,
+	// 	);
 
-		expect((() => {
-			this.db.insert(users).values({ name: undefined }).run();
-		})()).not.throw();
+	// 	expect((() => {
+	// 		this.db.insert(users).values({ name: undefined }).run();
+	// 	})()).not.throw();
 
-		this.db.run(sql`drop table ${users}`);
-	}
+	// 	this.db.run(sql`drop table ${users}`);
+	// }
 
-	async updateUndefined(): Promise<void> {
-		const users = sqliteTable('users', {
-			id: integer('id').primaryKey(),
-			name: text('name'),
-		});
+	// async updateUndefined(): Promise<void> {
+	// 	const users = sqliteTable('users', {
+	// 		id: integer('id').primaryKey(),
+	// 		name: text('name'),
+	// 	});
 
-		this.db.run(sql`drop table if exists ${users}`);
+	// 	this.db.run(sql`drop table if exists ${users}`);
 
-		this.db.run(
-			sql`create table ${users} (id integer primary key, name text)`,
-		);
+	// 	this.db.run(
+	// 		sql`create table ${users} (id integer primary key, name text)`,
+	// 	);
 
-		expect((() => {
-			this.db.update(users).set({ name: undefined }).run();
-		})()).throw();
-		expect((() => {
-			this.db.update(users).set({ id: 1, name: undefined }).run();
-		})()).not.throw();
+	// 	expect((() => {
+	// 		this.db.update(users).set({ name: undefined }).run();
+	// 	})()).throw();
+	// 	expect((() => {
+	// 		this.db.update(users).set({ id: 1, name: undefined }).run();
+	// 	})()).not.throw();
 
-		this.db.run(sql`drop table ${users}`);
-	}
+	// 	this.db.run(sql`drop table ${users}`);
+	// }
 
 	async apiCRUD(): Promise<void> {
 		try {
@@ -3481,6 +3527,572 @@ export class MyDurableObject extends DurableObject {
 			throw new Error(`deleteWithLimitAndOrderBy error`);
 		}
 	}
+
+	async testRqbV2SimpleFindFirstNoRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const result = await db.query.rqbUser.findFirst();
+
+		expect(result).deep.equal(undefined);
+	}
+
+	async testRqbV2SimpleFindFirstMultipleRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).deep.equal({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	}
+
+	async testRqbV2SimpleFindFirstWithRelation() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbUser.findFirst({
+			with: {
+				posts: {
+					orderBy: {
+						id: 'asc',
+					},
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).deep.equal({
+			id: 1,
+			createdAt: date,
+			name: 'First',
+			posts: [{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+			}],
+		});
+	}
+
+	async testRqbV2SimpleFindFirstPlaceholders() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findFirst({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).deep.equal({
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		});
+	}
+
+	async testRqbV2SimpleFindManyNoRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const result = await db.query.rqbUser.findMany();
+
+		expect(result).deep.equal([]);
+	}
+
+	async testRqbV2SimpleFindManyMultipleRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const result = await db.query.rqbUser.findMany({
+			orderBy: {
+				id: 'desc',
+			},
+		});
+
+		expect(result).deep.equal([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}, {
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}]);
+	}
+
+	async testRqbV2SimpleFindManyWithRelation() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		const result = await db.query.rqbPost.findMany({
+			with: {
+				author: true,
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		});
+
+		expect(result).deep.equal([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+			author: {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			},
+		}]);
+	}
+
+	async testRqbV2SimpleFindManyPlaceholders() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		const query = db.query.rqbUser.findMany({
+			where: {
+				id: {
+					eq: sql.placeholder('filter'),
+				},
+			},
+			orderBy: {
+				id: 'asc',
+			},
+		}).prepare();
+
+		const result = await query.execute({
+			filter: 2,
+		});
+
+		expect(result).deep.equal([{
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+	}
+
+	async testRqbV2TransactionFindFirstNoRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		await db.transaction((db) => {
+			const result = db.query.rqbUser.findFirst().sync();
+
+			expect(result).deep.equal(undefined);
+		});
+	}
+
+	async testRqbV2TransactionFindFirstMultipleRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction((db) => {
+			const result = db.query.rqbUser.findFirst({
+				orderBy: {
+					id: 'desc',
+				},
+			}).sync();
+
+			expect(result).deep.equal({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	}
+
+	async testRqbV2TransactionFindFirstWithRelation() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction((db) => {
+			const result = db.query.rqbUser.findFirst({
+				with: {
+					posts: {
+						orderBy: {
+							id: 'asc',
+						},
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).sync();
+
+			expect(result).deep.equal({
+				id: 1,
+				createdAt: date,
+				name: 'First',
+				posts: [{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}],
+			});
+		});
+	}
+
+	async testRqbV2TransactionFindFirstPlaceholders() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction((db) => {
+			const query = db.query.rqbUser.findFirst({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = query.execute({
+				filter: 2,
+			}).sync();
+
+			expect(result).deep.equal({
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			});
+		});
+	}
+
+	async testRqbV2TransactionFindManyNoRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		await db.transaction((db) => {
+			const result = db.query.rqbUser.findMany().sync();
+
+			expect(result).deep.equal([]);
+		});
+	}
+
+	async testRqbV2TransactionFindManyMultipleRows() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction((db) => {
+			const result = db.query.rqbUser.findMany({
+				orderBy: {
+					id: 'desc',
+				},
+			}).sync();
+
+			expect(result).deep.equal([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}, {
+				id: 1,
+				createdAt: date,
+				name: 'First',
+			}]);
+		});
+	}
+
+	async testRqbV2TransactionFindManyWithRelation() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.insert(rqbPost).values([{
+			id: 1,
+			userId: 1,
+			createdAt: date,
+			content: null,
+		}, {
+			id: 2,
+			userId: 1,
+			createdAt: date,
+			content: 'Has message this time',
+		}]);
+
+		await db.transaction((db) => {
+			const result = db.query.rqbPost.findMany({
+				with: {
+					author: true,
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).sync();
+
+			expect(result).deep.equal([{
+				id: 1,
+				userId: 1,
+				createdAt: date,
+				content: null,
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}, {
+				id: 2,
+				userId: 1,
+				createdAt: date,
+				content: 'Has message this time',
+				author: {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				},
+			}]);
+		});
+	}
+
+	async testRqbV2TransactionFindManyPlaceholders() {
+		const db = this.db;
+		await this.beforeEach();
+
+		const date = new Date(120000);
+
+		await db.insert(rqbUser).values([{
+			id: 1,
+			createdAt: date,
+			name: 'First',
+		}, {
+			id: 2,
+			createdAt: date,
+			name: 'Second',
+		}]);
+
+		await db.transaction((db) => {
+			const query = db.query.rqbUser.findMany({
+				where: {
+					id: {
+						eq: sql.placeholder('filter'),
+					},
+				},
+				orderBy: {
+					id: 'asc',
+				},
+			}).prepare();
+
+			const result = query.execute({
+				filter: 2,
+			}).sync();
+
+			expect(result).deep.equal([{
+				id: 2,
+				createdAt: date,
+				name: 'Second',
+			}]);
+		});
+	}
 }
 
 export default {
@@ -3608,12 +4220,35 @@ export default {
 			await stub.$countEmbeddedWithFilters();
 			await stub.updateWithLimitAndOrderBy();
 			await stub.deleteWithLimitAndOrderBy();
-			await stub.updateUndefined();
-			await stub.insertUndefined();
-
-			return new Response();
+			// await stub.updateUndefined().catch(() => {
+			// 	throw new Error('Update undefined error');
+			// });
+			// await stub.insertUndefined().catch(() => {
+			// 	throw new Error('Insert undefined error');
+			// });
+
+			await stub.testRqbV2SimpleFindFirstMultipleRows();
+			await stub.testRqbV2SimpleFindFirstNoRows();
+			await stub.testRqbV2SimpleFindFirstPlaceholders();
+			await stub.testRqbV2SimpleFindFirstWithRelation();
+			await stub.testRqbV2SimpleFindManyMultipleRows();
+			await stub.testRqbV2SimpleFindManyNoRows();
+			await stub.testRqbV2SimpleFindManyPlaceholders();
+			await stub.testRqbV2SimpleFindManyWithRelation();
+			await stub.testRqbV2TransactionFindFirstMultipleRows();
+			await stub.testRqbV2TransactionFindFirstNoRows();
+			await stub.testRqbV2TransactionFindFirstPlaceholders();
+			await stub.testRqbV2TransactionFindFirstWithRelation();
+			await stub.testRqbV2TransactionFindManyMultipleRows();
+			await stub.testRqbV2TransactionFindManyNoRows();
+			await stub.testRqbV2TransactionFindManyPlaceholders();
+			await stub.testRqbV2TransactionFindManyWithRelation();
+
+			return new Response('OK');
 		} catch (error: any) {
-			return new Response(error.message);
+			return new Response(`${error?.message ?? error}\n\n${error?.stack ?? ''}`, {
+				status: 500,
+			});
 		}
 	},
 } satisfies ExportedHandler<Env>;
diff --git a/integration-tests/tests/sqlite/effect-common.ts b/integration-tests/tests/sqlite/effect-common.ts
new file mode 100644
index 0000000000..2fb443d984
--- /dev/null
+++ b/integration-tests/tests/sqlite/effect-common.ts
@@ -0,0 +1,3838 @@
+import { assert, expect, expectTypeOf, it, vi, Vitest } from '@effect/vitest';
+import {
+	and,
+	asc,
+	eq,
+	gt,
+	gte,
+	inArray,
+	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
+	sql,
+} from 'drizzle-orm';
+import { EffectCache, type EffectCacheShape } from 'drizzle-orm/cache/core/cache-effect';
+import { EffectLogger, type EffectLoggerShape, QueryEffectHKTBase } from 'drizzle-orm/effect-core';
+import {
+	EmptyRelations,
+	ExtractTablesFromSchema,
+	ExtractTablesWithRelations,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+} from 'drizzle-orm/relations';
+import {
+	alias,
+	blob,
+	except,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	SQLiteDialect,
+	sqliteTable,
+	text,
+	union,
+} from 'drizzle-orm/sqlite-core';
+import type { SQLiteEffectDatabase } from 'drizzle-orm/sqlite-core/effect/db';
+import { ConfigError } from 'effect/Config';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Ref from 'effect/Ref';
+import * as Result from 'effect/Result';
+import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlError } from 'effect/unstable/sql/SqlError';
+import { TestCache } from './instrumentation';
+import relations from './relations';
+import { rqbPost, rqbUser } from './schema';
+
+export class DB
+	extends Context.Service<DB, SQLiteEffectDatabase<any, any, typeof relations>>()('CommonEffectSQLiteDB')
+{}
+
+let _diff!: (_: {}, schema: Record<string, unknown>, renames: []) => Promise<{ sqlStatements: string[] }>;
+const getDiff = async () => {
+	return _diff ??= (await import('../../../drizzle-kit/tests/sqlite/mocks' as string)).diff;
+};
+
+export const push = (db: SQLiteEffectDatabase<any, any, any>, schema: Record<string, any>) =>
+	Effect.gen(function*() {
+		const diff = yield* Effect.promise(() => getDiff());
+
+		const { sqlStatements: deleteStatements } = yield* Effect.promise(() => diff(schema, {}, []));
+		const { sqlStatements: createStatements } = yield* Effect.promise(() => diff({}, schema, []));
+
+		for (const s of deleteStatements) {
+			yield* db.run(s.replace('`', 'IF EXISTS `'));
+		}
+		for (const s of createStatements) {
+			yield* db.run(s);
+		}
+	});
+
+export interface RunCommonEffectSQLiteTestsOptions {
+	testLayer: Layer.Layer<DB | SqlClient, SqlError | ConfigError, never>;
+	SQLiteDrizzle: {
+		make: (config?: any) => Effect.Effect<SQLiteEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		makeWithDefaults: (
+			config?: any,
+		) => Effect.Effect<SQLiteEffectDatabase<QueryEffectHKTBase, any, EmptyRelations>, never, any>;
+		DefaultServices: Layer.Layer<any, never, any>;
+	};
+	createDB: <
+		TSchema extends Record<string, any>,
+		TConfig extends RelationsBuilderConfig<TTables>,
+		TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+	>(
+		schema: TSchema,
+		relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+		useJitMappers?: boolean,
+	) => Effect.Effect<
+		SQLiteEffectDatabase<QueryEffectHKTBase, any, ExtractTablesWithRelations<TConfig, TTables>>,
+		never,
+		any
+	>;
+	skipTests?: string[];
+	addTests?: (it: Vitest.MethodsNonLive<DB | SqlClient>) => void;
+}
+
+export const runCommonEffectSQLiteTests = (opts: RunCommonEffectSQLiteTestsOptions): void => {
+	const { testLayer, SQLiteDrizzle, createDB, addTests, skipTests = [] } = opts;
+
+	it.layer(testLayer)('common', (it) => {
+		it.beforeEach(({ task, skip }) => {
+			if (skipTests.includes(task.name)) skip();
+		});
+
+		it.effect('execute - all', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.all<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual([{ '1': 1 }]);
+			}));
+
+		it.effect('execute - get', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.get<{ '1': 1 }>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual({ '1': 1 });
+			}));
+
+		it.effect('execute - values', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const res = yield* db.values<[number]>(sql`SELECT 1 as "1"`);
+
+				expect(res).toStrictEqual([[1]]);
+			}));
+
+		it.effect('all types', () =>
+			Effect.gen(function*() {
+				const allTypesTable = sqliteTable('all_types', {
+					int: integer('int', {
+						mode: 'number',
+					}),
+					bool: integer('bool', {
+						mode: 'boolean',
+					}),
+					time: integer('time', {
+						mode: 'timestamp',
+					}),
+					timeMs: integer('time_ms', {
+						mode: 'timestamp_ms',
+					}),
+					bigint: blob('bigint', {
+						mode: 'bigint',
+					}),
+					buffer: blob('buffer', {
+						mode: 'buffer',
+					}),
+					json: blob('json', {
+						mode: 'json',
+					}),
+					numeric: numeric('numeric'),
+					numericNum: numeric('numeric_num', {
+						mode: 'number',
+					}),
+					numericBig: numeric('numeric_big', {
+						mode: 'bigint',
+					}),
+					real: real('real'),
+					text: text('text', {
+						mode: 'text',
+					}),
+					jsonText: text('json_text', {
+						mode: 'json',
+					}),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { allTypesTable });
+
+				yield* db.insert(allTypesTable).values({
+					int: 1,
+					bool: true,
+					bigint: 5044565289845416380n,
+					buffer: Buffer.from([
+						0x44,
+						0x65,
+						0x73,
+						0x70,
+						0x61,
+						0x69,
+						0x72,
+						0x20,
+						0x6f,
+						0x20,
+						0x64,
+						0x65,
+						0x73,
+						0x70,
+						0x61,
+						0x69,
+						0x72,
+						0x2e,
+						0x2e,
+						0x2e,
+					]),
+					json: {
+						str: 'strval',
+						arr: ['str', 10],
+					},
+					jsonText: {
+						str: 'strvalb',
+						arr: ['strb', 11],
+					},
+					numeric: '475452353476',
+					numericNum: 9007199254740991,
+					numericBig: 5044565289845416380n,
+					real: 1.048596,
+					text: 'TEXT STRING',
+					time: new Date(1741743161623),
+					timeMs: new Date(1741743161623),
+				});
+
+				const rawRes = yield* db.select().from(allTypesTable);
+
+				expect(typeof rawRes[0]?.numericBig).toStrictEqual('bigint');
+
+				type ExpectedType = {
+					int: number | null;
+					bool: boolean | null;
+					time: Date | null;
+					timeMs: Date | null;
+					bigint: bigint | null;
+					buffer: Buffer | null;
+					json: unknown;
+					numeric: string | null;
+					numericNum: number | null;
+					numericBig: bigint | null;
+					real: number | null;
+					text: string | null;
+					jsonText: unknown;
+				}[];
+
+				const expectedRes: ExpectedType = [
+					{
+						int: 1,
+						bool: true,
+						time: new Date('2025-03-12T01:32:41.000Z'),
+						timeMs: new Date('2025-03-12T01:32:41.623Z'),
+						bigint: 5044565289845416380n,
+						buffer: Buffer.from([
+							0x44,
+							0x65,
+							0x73,
+							0x70,
+							0x61,
+							0x69,
+							0x72,
+							0x20,
+							0x6f,
+							0x20,
+							0x64,
+							0x65,
+							0x73,
+							0x70,
+							0x61,
+							0x69,
+							0x72,
+							0x2e,
+							0x2e,
+							0x2e,
+						]),
+						json: { str: 'strval', arr: ['str', 10] },
+						numeric: '475452353476',
+						numericNum: 9007199254740991,
+						numericBig: 5044565289845416380n,
+						real: 1.048596,
+						text: 'TEXT STRING',
+						jsonText: { str: 'strvalb', arr: ['strb', 11] },
+					},
+				];
+
+				expectTypeOf(rawRes).toEqualTypeOf<ExpectedType>();
+				expect(rawRes).toStrictEqual(expectedRes);
+			}));
+
+		it.effect('RQB v2 simple find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 simple find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbUser.findFirst({
+					with: {
+						posts: {
+							orderBy: {
+								id: 'asc',
+							},
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 simple find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findFirst({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 simple find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 simple find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.query.rqbUser.findMany({
+					orderBy: {
+						id: 'desc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser, rqbPost });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.query.rqbPost.findMany({
+					with: {
+						author: true,
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				});
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 simple find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const query = db.query.rqbUser.findMany({
+					where: {
+						id: {
+							eq: sql.placeholder('filter'),
+						},
+					},
+					orderBy: {
+						id: 'asc',
+					},
+				}).prepare();
+
+				const result = yield* query.execute({
+					filter: 2,
+				});
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find first - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst();
+
+						expect(result).toStrictEqual(undefined);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual(undefined);
+			}));
+
+		it.effect('RQB v2 transaction find first - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findFirst({
+							with: {
+								posts: {
+									orderBy: {
+										id: 'asc',
+									},
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 1,
+							createdAt: date,
+							name: 'First',
+							posts: [{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+							}, {
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+							}],
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 1,
+					createdAt: date,
+					name: 'First',
+					posts: [{
+						id: 1,
+						userId: 1,
+						createdAt: date,
+						content: null,
+					}, {
+						id: 2,
+						userId: 1,
+						createdAt: date,
+						content: 'Has message this time',
+					}],
+				});
+			}));
+
+		it.effect('RQB v2 transaction find first - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findFirst({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual({
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				});
+			}));
+
+		it.effect('RQB v2 transaction find many - no rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany();
+
+						expect(result).toStrictEqual([]);
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('RQB v2 transaction find many - multiple rows', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbUser.findMany({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}, {
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}, {
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - with relation', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				yield* push(db, { rqbUser, rqbPost });
+				const date = new Date(120000);
+
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				yield* db.insert(rqbPost).values([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const result = yield* db.query.rqbPost.findMany({
+							with: {
+								author: true,
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual([{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}, {
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						}]);
+
+						return result;
+					})
+				);
+
+				expect(result).toStrictEqual([{
+					id: 1,
+					userId: 1,
+					createdAt: date,
+					content: null,
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}, {
+					id: 2,
+					userId: 1,
+					createdAt: date,
+					content: 'Has message this time',
+					author: {
+						id: 1,
+						createdAt: date,
+						name: 'First',
+					},
+				}]);
+			}));
+
+		it.effect('RQB v2 transaction find many - placeholders', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* push(db, { rqbUser });
+
+				const date = new Date(120000);
+				yield* db.insert(rqbUser).values([{
+					id: 1,
+					createdAt: date,
+					name: 'First',
+				}, {
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+
+				const result = yield* db.transaction((db) =>
+					Effect.gen(function*() {
+						const query = db.query.rqbUser.findMany({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						}).prepare();
+
+						const result = yield* query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual([{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						}]);
+
+						return result;
+					})
+				);
+				expect(result).toStrictEqual([{
+					id: 2,
+					createdAt: date,
+					name: 'Second',
+				}]);
+			}));
+
+		it.effect('transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_transactions', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+				const products = sqliteTable('products_transactions', {
+					id: integer('id').primaryKey(),
+					price: integer('price').notNull(),
+					stock: integer('stock').notNull(),
+				});
+
+				yield* push(db, { users, products });
+
+				const [user] = yield* db.insert(users).values({ balance: 100 }).returning();
+				const [product] = yield* db.insert(products).values({ price: 10, stock: 10 }).returning();
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.update(users).set({ balance: user!.balance - product!.price }).where(eq(users.id, user!.id));
+						yield* tx.update(products).set({ stock: product!.stock - 1 }).where(eq(products.id, product!.id));
+
+						// Regardless if `db` or `tx` is used, every query within the transaction effect is completed in transaction
+						const nonTxRes = yield* db.select().from(users);
+						expect(nonTxRes).toStrictEqual([{ id: 1, balance: 90 }]);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 90 }]);
+			}));
+
+		it.effect('transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_transactions_rollback', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				const res = yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+						yield* tx.rollback();
+					})
+				).pipe(Effect.result);
+
+				assert(Result.isFailure(res));
+				assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([]);
+			}));
+
+		it.effect('nested transaction', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_nested_transactions', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+							})
+						);
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 200 }]);
+			}));
+
+		it.effect('nested transaction rollback', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+
+				const users = sqliteTable('users_nested_transactions_rollback', {
+					id: integer('id').primaryKey(),
+					balance: integer('balance').notNull(),
+				});
+
+				yield* push(db, { users });
+
+				yield* db.transaction((tx) =>
+					Effect.gen(function*() {
+						yield* tx.insert(users).values({ balance: 100 });
+
+						const res = yield* tx.transaction((tx) =>
+							Effect.gen(function*() {
+								yield* tx.update(users).set({ balance: 200 });
+								yield* tx.rollback();
+							})
+						).pipe(Effect.result);
+
+						assert(Result.isFailure(res));
+						assert(Predicate.isTagged(res.failure, 'EffectTransactionRollbackError'));
+					})
+				);
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, balance: 100 }]);
+			}));
+
+		it.effect('update ... from with join', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const states = sqliteTable('states_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const cities = sqliteTable('cities_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					stateId: integer('state_id').references(() => states.id),
+				});
+				const users = sqliteTable('users_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').notNull().references(() => cities.id),
+				});
+
+				yield* push(db, { states, cities, users });
+
+				yield* db.insert(states).values([
+					{ name: 'New York' },
+					{ name: 'Washington' },
+				]);
+				yield* db.insert(cities).values([
+					{ name: 'New York City', stateId: 1 },
+					{ name: 'Seattle', stateId: 2 },
+					{ name: 'London' },
+				]);
+				yield* db.insert(users).values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 2 },
+					{ name: 'Jack', cityId: 3 },
+				]);
+
+				const result1 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+					.returning();
+				const result2 = yield* db
+					.update(users)
+					.set({
+						cityId: cities.id,
+					})
+					.from(cities)
+					.leftJoin(states, eq(cities.stateId, states.id))
+					.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
+					.returning();
+
+				expect(result1).toStrictEqual([{
+					id: 1,
+					name: 'John',
+					cityId: 2,
+				}]);
+				expect(result2).toStrictEqual([{
+					id: 3,
+					name: 'Jack',
+					cityId: 3,
+				}]);
+			}));
+
+		it.effect('insert into ... select', () =>
+			Effect.gen(function*() {
+				const notifications = sqliteTable('notifications_31', {
+					id: integer('id').primaryKey(),
+					sentAt: integer('sent_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+					message: text('message').notNull(),
+				});
+				const users = sqliteTable('users_31', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+				const userNotications = sqliteTable('user_notifications_31', {
+					userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+					notificationId: integer('notification_id').notNull().references(() => notifications.id, {
+						onDelete: 'cascade',
+					}),
+				}, (t) => [primaryKey({ columns: [t.userId, t.notificationId] })]);
+
+				const db = yield* DB;
+
+				yield* push(db, { notifications, users, userNotications });
+
+				const newNotification = (yield* db
+					.insert(notifications)
+					.values({ message: 'You are one of the 3 lucky winners!' })
+					.returning({ id: notifications.id }))[0]!;
+
+				yield* db.insert(users).values([
+					{ name: 'Alice' },
+					{ name: 'Bob' },
+					{ name: 'Charlie' },
+					{ name: 'David' },
+					{ name: 'Eve' },
+				]);
+
+				const sentNotifications = yield* db
+					.insert(userNotications)
+					.select(
+						db
+							.select({
+								userId: users.id,
+								notificationId: sql`${newNotification!.id}`.as('notification_id'),
+							})
+							.from(users)
+							.where(inArray(users.name, ['Alice', 'Charlie', 'Eve']))
+							.orderBy(asc(users.id)),
+					)
+					.returning();
+
+				expect(sentNotifications).toStrictEqual([
+					{ userId: 1, notificationId: newNotification!.id },
+					{ userId: 3, notificationId: newNotification!.id },
+					{ userId: 5, notificationId: newNotification!.id },
+				]);
+			}));
+
+		it.effect('$count separate', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_33', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable);
+
+				expect(count).toStrictEqual(4);
+			}));
+
+		it.effect('$count embedded', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_34', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+			}));
+
+		it.effect('$count separate reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_35', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.$count(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual(4);
+				expect(count2).toStrictEqual(5);
+				expect(count3).toStrictEqual(6);
+			}));
+
+		it.effect('$count embedded reuse', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_36', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = db.select({
+					count: db.$count(countTestTable),
+				}).from(countTestTable);
+
+				const count1 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 5, name: 'fifth' });
+
+				const count2 = yield* count;
+
+				yield* db.insert(countTestTable).values({ id: 6, name: 'sixth' });
+
+				const count3 = yield* count;
+
+				expect(count1).toStrictEqual([
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+					{ count: 4 },
+				]);
+				expect(count2).toStrictEqual([
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+					{ count: 5 },
+				]);
+				expect(count3).toStrictEqual([
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+					{ count: 6 },
+				]);
+			}));
+
+		it.effect('$count separate with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_37', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.$count(countTestTable, gt(countTestTable.id, 1));
+				expect(count).toStrictEqual(3);
+			}));
+
+		it.effect('$count embedded with filters', () =>
+			Effect.gen(function*() {
+				const countTestTable = sqliteTable('count_test_38', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { countTestTable });
+
+				yield* db.insert(countTestTable).values([
+					{ id: 1, name: 'First' },
+					{ id: 2, name: 'Second' },
+					{ id: 3, name: 'Third' },
+					{ id: 4, name: 'Fourth' },
+				]);
+
+				const count = yield* db.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				}).from(countTestTable);
+
+				expect(count).toStrictEqual([
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+					{ count: 3 },
+				]);
+			}));
+
+		it.effect('select distinct', () =>
+			Effect.gen(function*() {
+				const usersDistinctTable = sqliteTable('users_distinct_101', {
+					id: integer('id').notNull(),
+					name: text('name').notNull(),
+					age: integer('age').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersDistinctTable });
+
+				yield* db.insert(usersDistinctTable).values([
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+				]);
+				const users = yield* db.selectDistinct().from(usersDistinctTable).orderBy(
+					usersDistinctTable.id,
+					usersDistinctTable.name,
+				);
+
+				expect(users).toEqual([
+					{ id: 1, name: 'Jane', age: 24 },
+					{ id: 1, name: 'Jane', age: 26 },
+					{ id: 1, name: 'John', age: 24 },
+					{ id: 2, name: 'John', age: 25 },
+				]);
+			}));
+
+		it.effect('update with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_9', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+					createdAt: integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('update with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_10', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db
+					.update(users)
+					.set({ name: 'Jane' })
+					.where(eq(users.name, 'John'))
+					.returning({
+						id: users.id,
+						name: users.name,
+					});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'Jane' }]);
+			}));
+
+		it.effect('delete with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_11', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+					createdAt: integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull().default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const now = Date.now();
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning();
+
+				expect(usersResult[0]!.createdAt).toBeInstanceOf(Date);
+				expect(Math.abs(usersResult[0]!.createdAt.getTime() - now)).toBeLessThan(300);
+				expect(usersResult).toEqual([
+					{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: usersResult[0]!.createdAt },
+				]);
+			}));
+
+		it.effect('delete with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_12', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values({ name: 'John' });
+				const usersResult = yield* db.delete(users).where(eq(users.name, 'John')).returning({
+					id: users.id,
+					name: users.name,
+				});
+
+				expect(usersResult).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('insert many', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_19', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					]);
+				const result = yield* db
+					.select({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					})
+					.from(users);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning partial', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_20', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning({
+						id: users.id,
+						name: users.name,
+						jsonb: users.jsonb,
+						verified: users.verified,
+					});
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('insert with returning all fields', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_20', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+					jsonb: text('jsonb', { mode: 'json' }).$type<string[]>(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db
+					.insert(users)
+					.values([
+						{ name: 'John' },
+						{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+						{ name: 'Jane' },
+						{ name: 'Austin', verified: true },
+					])
+					.returning();
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John', jsonb: null, verified: false },
+					{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+					{ id: 3, name: 'Jane', jsonb: null, verified: false },
+					{ id: 4, name: 'Austin', jsonb: null, verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement reuse', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_35', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						verified: true,
+						name: sql.placeholder('name'),
+					})
+					.prepare();
+
+				for (let i = 0; i < 10; i++) {
+					yield* stmt.execute({ name: `John ${i}` });
+				}
+
+				const result = yield* db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+						verified: usersTable.verified,
+					})
+					.from(usersTable);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John 0', verified: true },
+					{ id: 2, name: 'John 1', verified: true },
+					{ id: 3, name: 'John 2', verified: true },
+					{ id: 4, name: 'John 3', verified: true },
+					{ id: 5, name: 'John 4', verified: true },
+					{ id: 6, name: 'John 5', verified: true },
+					{ id: 7, name: 'John 6', verified: true },
+					{ id: 8, name: 'John 7', verified: true },
+					{ id: 9, name: 'John 8', verified: true },
+					{ id: 10, name: 'John 9', verified: true },
+				]);
+			}));
+
+		it.effect('prepared statement with placeholder in .where', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_36', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.prepare();
+				const result = yield* stmt.execute({ id: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			}));
+
+		it.effect('prepared statement with placeholder in .limit', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_37', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values({ name: 'John' });
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ id: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('prepared statement with placeholder in .offset', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_38', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.offset(sql.placeholder('offset'))
+					.limit(sql.placeholder('limit'))
+					.prepare();
+
+				const result = yield* stmt.execute({ offset: 1, limit: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			}));
+
+		it.effect('prepared statement built using $dynamic', () =>
+			Effect.gen(function*() {
+				const usersTable = sqliteTable('users_39', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { usersTable });
+
+				function withLimitOffset(qb: any) {
+					return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
+				}
+
+				yield* db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.$dynamic();
+				withLimitOffset(stmt).prepare();
+
+				const result = yield* stmt.execute({ limit: 1, offset: 1 });
+
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+				expect(result).toHaveLength(1);
+			}));
+
+		it.effect('with ... select', () =>
+			Effect.gen(function*() {
+				const orders = sqliteTable('orders_55', {
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const regionalSales = db
+					.$with('regional_sales')
+					.as(
+						db
+							.select({
+								region: orders.region,
+								totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+							})
+							.from(orders)
+							.groupBy(orders.region),
+					);
+
+				const topRegions = db
+					.$with('top_regions')
+					.as(
+						db
+							.select({
+								region: regionalSales.region,
+							})
+							.from(regionalSales)
+							.where(
+								gt(
+									regionalSales.totalSales,
+									db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+								),
+							),
+					);
+
+				const result1 = yield* db
+					.with(regionalSales, topRegions)
+					.select({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result2 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						product: orders.product,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region, orders.product)
+					.orderBy(orders.region, orders.product);
+				const result3 = yield* db
+					.with(regionalSales, topRegions)
+					.selectDistinct({
+						region: orders.region,
+						productUnits: sql<number>`sum(${orders.quantity})`.mapWith(Number),
+						productSales: sql<number>`sum(${orders.amount})`.mapWith(Number),
+					})
+					.from(orders)
+					.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+					.groupBy(orders.region)
+					.orderBy(orders.region);
+
+				expect(result1).toEqual([
+					{
+						region: 'Europe',
+						product: 'A',
+						productUnits: 3,
+						productSales: 30,
+					},
+					{
+						region: 'Europe',
+						product: 'B',
+						productUnits: 5,
+						productSales: 50,
+					},
+					{
+						region: 'US',
+						product: 'A',
+						productUnits: 7,
+						productSales: 70,
+					},
+					{
+						region: 'US',
+						product: 'B',
+						productUnits: 9,
+						productSales: 90,
+					},
+				]);
+				expect(result2).toEqual(result1);
+				expect(result3).toEqual([
+					{
+						region: 'Europe',
+						productUnits: 8,
+						productSales: 80,
+					},
+					{
+						region: 'US',
+						productUnits: 16,
+						productSales: 160,
+					},
+				]);
+			}));
+
+		it.effect('with ... update', () =>
+			Effect.gen(function*() {
+				const products = sqliteTable('products_56', {
+					id: integer('id').primaryKey(),
+					price: numeric('price').notNull(),
+					cheap: integer('cheap', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { products });
+
+				yield* db.insert(products).values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
+
+				const averagePrice = db
+					.$with('average_price')
+					.as(
+						db
+							.select({
+								value: sql`avg(${products.price})`.as('value'),
+							})
+							.from(products),
+					);
+
+				const result = yield* db
+					.with(averagePrice)
+					.update(products)
+					.set({
+						cheap: true,
+					})
+					.where(lt(products.price, sql`(select * from ${averagePrice})`))
+					.returning({
+						id: products.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 1 },
+					{ id: 4 },
+					{ id: 5 },
+				]);
+			}));
+
+		it.effect('with ... insert', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_57', {
+					username: text('username').notNull(),
+					admin: integer('admin', { mode: 'boolean' }).notNull().default(false),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const userCount = db
+					.$with('user_count')
+					.as(
+						db
+							.select({
+								value: sql`count(*)`.as('value'),
+							})
+							.from(users),
+					);
+
+				const result = yield* db
+					.with(userCount)
+					.insert(users)
+					.values([
+						{ username: 'user1', admin: sql`((select * from ${userCount}) = 0)` },
+					])
+					.returning({
+						admin: users.admin,
+					});
+
+				expect(result).toEqual([{ admin: true }]);
+			}));
+
+		it.effect('with ... delete', () =>
+			Effect.gen(function*() {
+				const orders = sqliteTable('orders_58', {
+					id: integer('id').primaryKey(),
+					region: text('region').notNull(),
+					product: text('product').notNull(),
+					amount: integer('amount').notNull(),
+					quantity: integer('quantity').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { orders });
+
+				yield* db.insert(orders).values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				]);
+
+				const averageAmount = db
+					.$with('average_amount')
+					.as(
+						db
+							.select({
+								value: sql`avg(${orders.amount})`.as('value'),
+							})
+							.from(orders),
+					);
+
+				const result = yield* db
+					.with(averageAmount)
+					.delete(orders)
+					.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+					.returning({
+						id: orders.id,
+					});
+
+				expect(result).toEqual([
+					{ id: 6 },
+					{ id: 7 },
+					{ id: 8 },
+				]);
+			}));
+
+		it.effect('partial join with alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_29', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customerAlias = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user: {
+							id: users.id,
+							name: users.name,
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			}));
+
+		it.effect('full join with alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(users)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([{
+					prefixed_users_30: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('select from alias', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_31', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const user = alias(users, 'user');
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select()
+					.from(user)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(user.id, 10));
+
+				expect(result).toEqual([{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('set operations (mixed) from query builder with subquery', () =>
+			Effect.gen(function*() {
+				const cities2Table = sqliteTable('cities_1', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = sqliteTable('users2_1', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const sq = db
+					.select()
+					.from(cities2Table).where(gt(cities2Table.id, 1)).as('sq');
+
+				const result = yield* db
+					.select()
+					.from(cities2Table).except(
+						({ unionAll }) =>
+							unionAll(
+								db.select().from(sq),
+								db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+							),
+					);
+
+				expect(result).toHaveLength(2);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* db
+						.select()
+						.from(cities2Table).except(
+							({ unionAll }) =>
+								unionAll(
+									db
+										.select({ name: cities2Table.name, id: cities2Table.id })
+										.from(cities2Table).where(gt(cities2Table.id, 1)),
+									db.select().from(cities2Table).where(eq(cities2Table.id, 2)),
+								),
+						);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('set operations (mixed all) as function', () =>
+			Effect.gen(function*() {
+				const cities2Table = sqliteTable('cities_2', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const users2Table = sqliteTable('users2_2', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+					cityId: integer('city_id').references(() => cities2Table.id),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { cities2Table, users2Table });
+
+				yield* db.insert(cities2Table).values([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
+
+				yield* db.insert(users2Table).values([
+					{ id: 1, name: 'John', cityId: 1 },
+					{ id: 2, name: 'Jane', cityId: 2 },
+					{ id: 3, name: 'Jack', cityId: 3 },
+					{ id: 4, name: 'Peter', cityId: 3 },
+					{ id: 5, name: 'Ben', cityId: 2 },
+					{ id: 6, name: 'Jill', cityId: 1 },
+					{ id: 7, name: 'Mary', cityId: 2 },
+					{ id: 8, name: 'Sally', cityId: 1 },
+				]);
+
+				const result = yield* union(
+					db
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table).where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 7)),
+					),
+					db
+						.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+				).orderBy(asc(sql`id`));
+
+				expect(result).toHaveLength(6);
+
+				expect(result).toEqual([
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+					{ id: 8, name: 'Sally' },
+				]);
+
+				let err: unknown;
+				try {
+					yield* union(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table).where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table).where(gte(users2Table.id, 5)),
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(users2Table).where(eq(users2Table.id, 7)),
+						),
+						db
+							.select().from(cities2Table).where(gt(cities2Table.id, 1)),
+					);
+				} catch (error) {
+					err = error;
+				}
+
+				expect(err).toBeInstanceOf(Error);
+			}));
+
+		it.effect('custom EffectLogger override - user provided logger takes precedence over default', () =>
+			Effect.gen(function*() {
+				const loggedQueries: Array<{ query: string; params: unknown[] }> = [];
+
+				const customLogger: EffectLoggerShape = {
+					logQuery: (query: string, params: unknown[]) =>
+						Effect.sync(() => {
+							loggedQueries.push({ query, params });
+						}),
+				};
+				const customLoggerLayer = Layer.succeed(EffectLogger, customLogger);
+
+				const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+					Effect.provide(customLoggerLayer),
+					Effect.provide(SQLiteDrizzle.DefaultServices),
+				);
+
+				const users = sqliteTable('users_custom_logger', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users);
+
+				expect(loggedQueries.length).toBeGreaterThanOrEqual(2);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('insert'))).toBe(true);
+				expect(loggedQueries.some((q) => q.query.toLowerCase().includes('select'))).toBe(true);
+			}));
+
+		it.effect('custom EffectCache override - user provided cache takes precedence over default', () =>
+			Effect.gen(function*() {
+				const cacheOperations = yield* Ref.make<Array<{ op: 'get' | 'put' | 'mutate'; key?: string }>>([]);
+
+				const customCacheService: EffectCacheShape = {
+					strategy: () => 'all' as const,
+					get: (key: string, _tables: string[], _isTag: boolean, _isAutoInvalidate?: boolean) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'get' as const, key }]);
+							// oxlint-disable-next-line no-useless-undefined
+							return undefined;
+						}),
+					put: (key: string, _response: any, _tables: string[], _isTag: boolean, _config?: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'put' as const, key }]);
+						}),
+					onMutate: (_params: any) =>
+						Effect.gen(function*() {
+							yield* Ref.update(cacheOperations, (ops) => [...ops, { op: 'mutate' as const }]);
+						}),
+				};
+				const customCacheLayer = Layer.succeed(EffectCache, customCacheService);
+
+				const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+					Effect.provide(customCacheLayer),
+					Effect.provide(SQLiteDrizzle.DefaultServices),
+				);
+
+				const users = sqliteTable('users_custom_cache', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+				yield* db.select().from(users).$withCache();
+
+				const ops = yield* Ref.get(cacheOperations);
+				expect(ops.some((o) => o.op === 'mutate')).toBe(true);
+				expect(ops.some((o) => o.op === 'get')).toBe(true);
+			}));
+
+		it.effect('Cache: write + query all methods & verify data intergrity', () =>
+			Effect.gen(function*() {
+				const baseCache = new TestCache('explicit');
+
+				using spyPut = vi.spyOn(baseCache, 'put');
+				using spyGet = vi.spyOn(baseCache, 'get');
+				using spyInvalidate = vi.spyOn(baseCache, 'onMutate');
+
+				const customCacheLayer = EffectCache.layerFromDrizzle(baseCache);
+				const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+					Effect.provide(customCacheLayer),
+					Effect.provide(SQLiteDrizzle.DefaultServices),
+				);
+
+				const users = sqliteTable('users_custom_cache_2', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'John' });
+
+				expect(spyPut).toHaveBeenCalledTimes(0);
+				expect(spyGet).toHaveBeenCalledTimes(0);
+				expect(spyInvalidate).toHaveBeenCalledTimes(1);
+
+				spyPut.mockClear();
+				spyGet.mockClear();
+				spyInvalidate.mockClear();
+
+				const qRaw = db.select().from(users).prepare();
+				const qCache = db.select().from(users).$withCache({ config: { ex: 120 } }).prepare();
+
+				const [_all, _get, _run, _values] = [
+					yield* qRaw.all(),
+					yield* qRaw.get(),
+					yield* qRaw.run(),
+					yield* qRaw.values(),
+				];
+				const [all, get, run, values] = [
+					yield* qCache.all(),
+					yield* qCache.get(),
+					yield* qCache.run(),
+					yield* qCache.values(),
+				];
+
+				expect(all).toStrictEqual(_all);
+				expect(get).toStrictEqual(_get);
+				expect(run).toStrictEqual(_run);
+				expect(values).toStrictEqual(_values);
+
+				expect(spyPut).toHaveBeenCalledTimes(4);
+				expect(spyGet).toHaveBeenCalledTimes(4);
+				expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+				spyPut.mockClear();
+				spyGet.mockClear();
+				spyInvalidate.mockClear();
+			}));
+
+		it.effect('makeWithDefaults - convenience function that includes DefaultServices', () =>
+			Effect.gen(function*() {
+				const db = yield* SQLiteDrizzle.makeWithDefaults({ relations });
+
+				const users = sqliteTable('users_make_with_defaults', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				yield* push(db, { users });
+				yield* db.insert(users).values({ name: 'Alice' });
+				const result = yield* db.select().from(users);
+
+				expect(result).toEqual([{ id: 1, name: 'Alice' }]);
+			}));
+
+		it.effect('Mappers: correct mappers enabled', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const jitDb = yield* createDB({}, () => ({}), true);
+
+				const dialect: SQLiteDialect = (<any> db).dialect;
+				const jitDialect: SQLiteDialect = (<any> jitDb).dialect;
+
+				expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+				expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+				expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+			}));
+
+		const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+		it.effect('Mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_1', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_2', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_3', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Mappers: insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_4', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_5', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('mappers_users_6', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					false,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: simple select - no rows', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_1', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const result = yield* db.select().from(users);
+
+				expect(result).toStrictEqual([]);
+			}));
+
+		it.effect('Jit mappers: select - nothing to decode - text', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_2', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ name: users.name }).from(users);
+
+				expect(selected).toStrictEqual([{ name: 'First' }]);
+			}));
+
+		it.effect('Jit mappers: select - nothing to decode - null', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_3', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select({ isBanned: users.isBanned }).from(users);
+
+				expect(selected).toStrictEqual([{ isBanned: null }]);
+			}));
+
+		it.effect('Jit mappers: insert returning all + select + update returning + delete returning', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_4', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users });
+
+				const inserted = yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+
+				const selected = yield* db.select().from(users);
+
+				const updated = yield* db.update(users).set({
+					isBanned: false,
+				}).where(eq(users.id, 2)).returning();
+
+				const deleted = yield* db.delete(users).returning();
+
+				expect(inserted).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(selected).toStrictEqual([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]);
+				expect(updated).toStrictEqual([{
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}]);
+				expect(deleted).toStrictEqual(expect.arrayContaining([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+					isBanned: null,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: false,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+					isBanned: null,
+				}]));
+			}));
+
+		it.effect('Jit mappers: select complex selections', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_5', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('jit_mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB({}, () => ({}), true);
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({ user: users, post: posts }).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({ user: users, post: posts }).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id,
+					postId: posts.id,
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+
+		it.effect('Jit mappers: relational', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('jit_mappers_users_6', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('jit_mappers_posts_2', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* createDB(
+					{ users, posts },
+					(r) => ({
+						users: {
+							post: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+							posts: r.one.posts({
+								from: r.users.id,
+								to: r.posts.authorId,
+							}),
+						},
+						posts: {
+							author: r.one.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+							authors: r.many.users({
+								from: r.posts.authorId,
+								to: r.users.id,
+							}),
+						},
+					}),
+					true,
+				);
+				yield* push(db, { users, posts });
+
+				const empty1 = yield* db.query.users.findFirst();
+				const empty2 = yield* db.query.users.findMany();
+
+				expect(empty1).toStrictEqual(undefined);
+				expect(empty2).toStrictEqual([]);
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const simple1 = yield* db.query.users.findFirst();
+				const simple2 = yield* db.query.users.findMany();
+
+				expect(simple1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+				);
+				expect(simple2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+					},
+				]);
+
+				const extra1 = yield* db.query.users.findFirst({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const extra2 = yield* db.query.users.findMany({
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(extra1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(extra2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+
+				const nested1 = yield* db.query.users.findFirst({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+				const nested2 = yield* db.query.users.findMany({
+					with: {
+						post: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+									where: {
+										RAW: sql`false`,
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						posts: {
+							with: {
+								author: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+								authors: {
+									extras: {
+										sql: sql`SELECT 1`.mapWith(Number),
+										sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+									},
+								},
+							},
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				});
+
+				expect(nested1).toStrictEqual(
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				);
+				expect(nested2).toStrictEqual([
+					{
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						post: {
+							author: null,
+							authorId: 1,
+							authors: [],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						posts: {
+							author: {
+								createdAt: mappersDate,
+								id: 1,
+								isBanned: null,
+								name: 'First',
+								sql: 1,
+								sqlWrapper: 2,
+							},
+							authorId: 1,
+							authors: [
+								{
+									createdAt: mappersDate,
+									id: 1,
+									isBanned: null,
+									name: 'First',
+									sql: 1,
+									sqlWrapper: 2,
+								},
+							],
+							content: 'p1',
+							id: 1,
+							sql: 1,
+							sqlWrapper: 2,
+						},
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 2,
+						isBanned: true,
+						name: 'Second',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					{
+						createdAt: mappersDate,
+						id: 3,
+						isBanned: null,
+						name: 'Third',
+						post: null,
+						posts: null,
+						sql: 1,
+						sqlWrapper: 2,
+					},
+				]);
+			}));
+
+		addTests?.(it);
+	});
+};
diff --git a/integration-tests/tests/sqlite/effect-d1.test.ts b/integration-tests/tests/sqlite/effect-d1.test.ts
new file mode 100644
index 0000000000..db357f4e05
--- /dev/null
+++ b/integration-tests/tests/sqlite/effect-d1.test.ts
@@ -0,0 +1,369 @@
+import { D1Client } from '@effect/sql-d1';
+import { D1Database, D1DatabaseAPI } from '@miniflare/d1';
+import { createSQLiteDB } from '@miniflare/shared';
+import {
+	defineRelations,
+	eq,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+} from 'drizzle-orm';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-d1';
+import { alias, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { expect } from 'vitest';
+import { DB, push, runCommonEffectSQLiteTests } from './effect-common';
+import relations from './relations';
+
+const D1ClientLive = D1Client.layer({
+	db: new D1Database(new D1DatabaseAPI(await createSQLiteDB(':memory:'))) as any, // Old d1 version, has no `withSession`
+});
+
+const dbEffect = SQLiteDrizzle.make({ relations }).pipe(Effect.provide(SQLiteDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	// CF Workers don't support `new Function(...)`
+	_useJitMappers?: boolean,
+) =>
+	SQLiteDrizzle.make({ relations: defineRelations(schema, relations) }).pipe(
+		Effect.provide(SQLiteDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(D1ClientLive, DBLive.pipe(Layer.provide(D1ClientLive)));
+
+runCommonEffectSQLiteTests({
+	testLayer: TestLive,
+	SQLiteDrizzle: SQLiteDrizzle,
+	createDB,
+	skipTests: [
+		// Transactions are not supported in D1
+		'RQB v2 transaction find first - no rows',
+		'RQB v2 transaction find first - multiple rows',
+		'RQB v2 transaction find first - with relation',
+		'RQB v2 transaction find first - placeholders',
+		'RQB v2 transaction find many - no rows',
+		'RQB v2 transaction find many - multiple rows',
+		'RQB v2 transaction find many - with relation',
+		'RQB v2 transaction find many - placeholders',
+		'transaction',
+		'transaction rollback',
+		'nested transaction',
+		'nested transaction rollback',
+
+		// D1 returns broken results when joins have columns with same names even in array mode
+		// Altered tests with aliases are made in place of these
+		'partial join with alias',
+		'full join with alias',
+		'select from alias',
+		'Mappers: select complex selections',
+
+		// Cloudflare workers environment doesn't support 'new Function(...)'
+		'Mappers: correct mappers enabled',
+		'Jit mappers: simple select - no rows',
+		'Jit mappers: select - nothing to decode - text',
+		'Jit mappers: select - nothing to decode - null',
+		'Jit mappers: insert returning all + select + update returning + delete returning',
+		'Jit mappers: select complex selections',
+		'Jit mappers: relational',
+		// Driver has no migrator to test:
+		// transactions aren't supported by D1 and batch isn't exposed by Effect
+		// Recommended way to apply migrations is via `drizzle-kit generate` + `wrangler d1 migrations apply dbname`
+	],
+	addTests: (it) => {
+		// Bypass broken D1 joins by aliasing duplicate column names
+		it.effect('partial join with alias - D1 aliasing', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('users_29', {
+					id: integer('id' as string).primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customerAlias = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user: {
+							id: users.id.as('user_id'),
+							name: users.name.as('user_name'),
+						},
+						customer: {
+							id: customerAlias.id,
+							name: customerAlias.name,
+						},
+					})
+					.from(users)
+					.leftJoin(customerAlias, eq(customerAlias.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([
+					{
+						user: { id: 10, name: 'Ivan' },
+						customer: { id: 11, name: 'Hans' },
+					},
+				]);
+			}));
+
+		it.effect('full join with alias - D1 aliasing', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_30', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						prefixed_users_30: users,
+						customer: {
+							id: customers.id.as('customer_id'),
+							name: customers.name.as('customer_name'),
+						},
+					})
+					.from(users)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(users.id, 10));
+
+				expect(result).toEqual([{
+					prefixed_users_30: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('select from alias - D1 aliasing', () =>
+			Effect.gen(function*() {
+				const users = sqliteTable('prefixed_users_31', {
+					id: integer('id').primaryKey(),
+					name: text('name').notNull(),
+				});
+
+				const db = yield* DB;
+				yield* push(db, { users });
+
+				const user = alias(users, 'user');
+				const customers = alias(users, 'customer');
+
+				yield* db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+				const result = yield* db
+					.select({
+						user,
+						customer: {
+							id: customers.id.as('customer_id'),
+							name: customers.name.as('customer_name'),
+						},
+					})
+					.from(user)
+					.leftJoin(customers, eq(customers.id, 11))
+					.where(eq(user.id, 10));
+
+				expect(result).toEqual([{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				}]);
+			}));
+
+		it.effect('Mappers: select complex selections - D1 aliasing', () =>
+			Effect.gen(function*() {
+				const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+				const users = sqliteTable('mappers_users_5', (t) => ({
+					id: t.numeric('id', { mode: 'number' }).primaryKey(),
+					name: t.text('name').notNull(),
+					createdAt: t.integer('created_at', {
+						mode: 'timestamp_ms',
+					}).notNull(),
+					isBanned: t.integer('is_banned', { mode: 'boolean' }),
+				}));
+
+				const posts = sqliteTable('mappers_posts_1', (t) => ({
+					id: t.integer('id').primaryKey(),
+					authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+					content: t.text('content'),
+				}));
+
+				const db = yield* DB;
+				yield* push(db, { users, posts });
+
+				yield* db.insert(users).values([{
+					id: 1,
+					name: 'First',
+					createdAt: mappersDate,
+				}, {
+					id: 2,
+					name: 'Second',
+					createdAt: mappersDate,
+					isBanned: true,
+				}, {
+					id: 3,
+					name: 'Third',
+					createdAt: mappersDate,
+				}]).returning();
+				yield* db.insert(posts).values({
+					id: 1,
+					authorId: 1,
+					content: 'p1',
+				});
+
+				const selected1 = yield* db.select({
+					user: {
+						id: users.id.as('user_id'),
+						name: users.name,
+						createdAt: users.createdAt,
+						isBanned: users.isBanned,
+					},
+					post: posts,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected2 = yield* db.select({
+					user: users,
+					post: {
+						id: posts.id.as('post_id'),
+						authorId: posts.authorId,
+						content: posts.content,
+					},
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected3 = yield* db.select({
+					userId: users.id.as('user_id'),
+					postId: posts.id.as('post_id'),
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).leftJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+				const selected4 = yield* db.select({
+					userId: users.id.as('user_id'),
+					postId: posts.id.as('post_id'),
+					name: users.name,
+					isBanned: users.isBanned,
+					content: posts.content,
+					createdAt: users.createdAt,
+				}).from(users).innerJoin(
+					posts,
+					eq(users.id, posts.authorId),
+				);
+
+				expect(selected1).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}, {
+					user: {
+						id: 2,
+						name: 'Second',
+						createdAt: mappersDate,
+						isBanned: true,
+					},
+					post: null,
+				}, {
+					user: {
+						id: 3,
+						name: 'Third',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: null,
+				}]);
+				expect(selected2).toStrictEqual([{
+					user: {
+						id: 1,
+						name: 'First',
+						createdAt: mappersDate,
+						isBanned: null,
+					},
+					post: {
+						id: 1,
+						authorId: 1,
+						content: 'p1',
+					},
+				}]);
+				expect(selected3).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: true,
+						name: 'Second',
+						postId: null,
+						userId: 2,
+					},
+					{
+						content: null,
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'Third',
+						postId: null,
+						userId: 3,
+					},
+				]);
+				expect(selected4).toStrictEqual([
+					{
+						content: 'p1',
+						createdAt: mappersDate,
+						isBanned: null,
+						name: 'First',
+						postId: 1,
+						userId: 1,
+					},
+				]);
+			}));
+	},
+});
diff --git a/integration-tests/tests/sqlite/effect-libsql.test.ts b/integration-tests/tests/sqlite/effect-libsql.test.ts
new file mode 100644
index 0000000000..4485c1598f
--- /dev/null
+++ b/integration-tests/tests/sqlite/effect-libsql.test.ts
@@ -0,0 +1,257 @@
+import { LibsqlClient } from '@effect/sql-libsql';
+import { assert, expect } from '@effect/vitest';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-libsql';
+import { migrate } from 'drizzle-orm/effect-libsql/migrator';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { DB, runCommonEffectSQLiteTests } from './effect-common';
+import relations from './relations';
+import { anotherUsersMigratorTable, usersMigratorTable } from './sqlite-common';
+
+const SQLiteClientLive = LibsqlClient.layer({
+	// libsql's bare `:memory:` opens a fresh in-memory DB per connection, so a
+	// committed transaction (which acquires its own connection) is invisible to
+	// the base client afterwards. The shared cache makes all connections share
+	// one in-memory DB.
+	url: 'file::memory:?cache=shared',
+});
+
+const dbEffect = SQLiteDrizzle.make({ relations }).pipe(Effect.provide(SQLiteDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	SQLiteDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(SQLiteDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(SQLiteClientLive, DBLive.pipe(Layer.provide(SQLiteClientLive)));
+
+runCommonEffectSQLiteTests({
+	testLayer: TestLive,
+	SQLiteDrizzle: SQLiteDrizzle,
+	createDB,
+	addTests: (it) => {
+		it.effect('migrator', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* db.run(sql`drop table if exists another_users`);
+				yield* db.run(sql`drop table if exists users12`);
+				yield* db.run(sql`drop table if exists __drizzle_migrations`);
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result = yield* db.select().from(usersMigratorTable).all();
+
+				yield* db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result2 = yield* db.select().from(anotherUsersMigratorTable).all();
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.run(sql`drop table another_users`);
+				yield* db.run(sql`drop table users12`);
+				yield* db.run(sql`drop table __drizzle_migrations`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(0);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(true);
+			}));
+
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const users = sqliteTable('migration_users', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				const users2 = sqliteTable('migration_users2', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				yield* db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+				yield* db.run(sql`drop table if exists ${users}`);
+				yield* db.run(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/sql-js';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrationsFolder: migrationDir });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrationsFolder: migrationDir });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+	},
+});
diff --git a/integration-tests/tests/sqlite/effect-sqlite-node.test.ts b/integration-tests/tests/sqlite/effect-sqlite-node.test.ts
new file mode 100644
index 0000000000..f792909b16
--- /dev/null
+++ b/integration-tests/tests/sqlite/effect-sqlite-node.test.ts
@@ -0,0 +1,253 @@
+import { SqliteClient } from '@effect/sql-sqlite-node';
+import { assert, expect } from '@effect/vitest';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite-node';
+import { migrate } from 'drizzle-orm/effect-sqlite-node/migrator';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { DB, runCommonEffectSQLiteTests } from './effect-common';
+import relations from './relations';
+import { anotherUsersMigratorTable, usersMigratorTable } from './sqlite-common';
+
+const SQLiteClientLive = SqliteClient.layer({
+	filename: ':memory:',
+});
+
+const dbEffect = SQLiteDrizzle.make({ relations }).pipe(Effect.provide(SQLiteDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	SQLiteDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(SQLiteDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(SQLiteClientLive, DBLive.pipe(Layer.provide(SQLiteClientLive)));
+
+runCommonEffectSQLiteTests({
+	testLayer: TestLive,
+	SQLiteDrizzle: SQLiteDrizzle,
+	createDB,
+	addTests: (it) => {
+		it.effect('migrator', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* db.run(sql`drop table if exists another_users`);
+				yield* db.run(sql`drop table if exists users12`);
+				yield* db.run(sql`drop table if exists __drizzle_migrations`);
+
+				yield* migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result = yield* db.select().from(usersMigratorTable).all();
+
+				yield* db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result2 = yield* db.select().from(anotherUsersMigratorTable).all();
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.run(sql`drop table another_users`);
+				yield* db.run(sql`drop table users12`);
+				yield* db.run(sql`drop table __drizzle_migrations`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(0);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite',
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrationsFolder: './drizzle2/sqlite-init',
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(true);
+			}));
+
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const users = sqliteTable('migration_users', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				const users2 = sqliteTable('migration_users2', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				yield* db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+				yield* db.run(sql`drop table if exists ${users}`);
+				yield* db.run(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/sql-js';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrationsFolder: migrationDir });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrationsFolder: migrationDir });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+	},
+});
diff --git a/integration-tests/tests/sqlite/effect-sqlite-wasm.test.ts b/integration-tests/tests/sqlite/effect-sqlite-wasm.test.ts
new file mode 100644
index 0000000000..6c2f98df11
--- /dev/null
+++ b/integration-tests/tests/sqlite/effect-sqlite-wasm.test.ts
@@ -0,0 +1,261 @@
+import './wasm-fetch-patch';
+import { SqliteClient } from '@effect/sql-sqlite-wasm';
+import { assert, expect } from '@effect/vitest';
+import {
+	defineRelations,
+	ExtractTablesFromSchema,
+	RelationsBuilder,
+	RelationsBuilderConfig,
+	Schema,
+	sql,
+} from 'drizzle-orm';
+import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite-wasm';
+import { migrate } from 'drizzle-orm/effect-sqlite-wasm/migrator';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Predicate from 'effect/Predicate';
+import * as Result from 'effect/Result';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { DB, runCommonEffectSQLiteTests } from './effect-common';
+import relations from './relations';
+import { anotherUsersMigratorTable, usersMigratorTable } from './sqlite-common';
+
+const SQLiteClientLive = SqliteClient.layerMemory({});
+
+const dbEffect = SQLiteDrizzle.make({ relations }).pipe(Effect.provide(SQLiteDrizzle.DefaultServices));
+const DBLive = Layer.effect(
+	DB,
+	Effect.gen(function*() {
+		const db = yield* dbEffect;
+
+		return db;
+	}),
+);
+
+const bundleMigrations = (folder: string): Record<string, string> => {
+	const migrations: Record<string, string> = {};
+	for (const name of readdirSync(folder)) {
+		const file = `${folder}/${name}/migration.sql`;
+		if (existsSync(file)) migrations[name] = readFileSync(file, 'utf8');
+	}
+	return migrations;
+};
+
+const createDB = <
+	TSchema extends Record<string, any>,
+	TConfig extends RelationsBuilderConfig<TTables>,
+	TTables extends Schema = ExtractTablesFromSchema<TSchema>,
+>(
+	schema: TSchema,
+	relations: (helpers: RelationsBuilder<TTables>) => TConfig,
+	useJitMappers?: boolean,
+) =>
+	SQLiteDrizzle.make({ relations: defineRelations(schema, relations), jit: useJitMappers }).pipe(
+		Effect.provide(SQLiteDrizzle.DefaultServices),
+	);
+
+const TestLive = Layer.merge(SQLiteClientLive, DBLive.pipe(Layer.provide(SQLiteClientLive)));
+
+runCommonEffectSQLiteTests({
+	testLayer: TestLive,
+	SQLiteDrizzle: SQLiteDrizzle,
+	createDB,
+	addTests: (it) => {
+		it.effect('migrator', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				yield* db.run(sql`drop table if exists another_users`);
+				yield* db.run(sql`drop table if exists users12`);
+				yield* db.run(sql`drop table if exists __drizzle_migrations`);
+
+				yield* migrate(db, { migrations: bundleMigrations('./drizzle2/sqlite') });
+
+				yield* db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result = yield* db.select().from(usersMigratorTable).all();
+
+				yield* db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+				const result2 = yield* db.select().from(anotherUsersMigratorTable).all();
+
+				expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+				expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+				yield* db.run(sql`drop table another_users`);
+				yield* db.run(sql`drop table users12`);
+				yield* db.run(sql`drop table __drizzle_migrations`);
+			}));
+
+		it.effect('migrator : --init', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrations: bundleMigrations('./drizzle2/sqlite'),
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				});
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(migratorRes).toStrictEqual(undefined);
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - local migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				const migratorRes = yield* migrate(db, {
+					migrations: bundleMigrations('./drizzle2/sqlite-init'),
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('localMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(0);
+				expect(!!res?.tableExists).toStrictEqual(false);
+			}));
+
+		it.effect('migrator : --init - db migrations error', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const migrationsTable = 'drzl_init';
+
+				yield* db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+				yield* db.run(sql`drop table if exists ${usersMigratorTable}`);
+				yield* db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+				yield* migrate(db, {
+					migrations: bundleMigrations('./drizzle2/sqlite'),
+					migrationsTable,
+				});
+
+				const migratorRes = yield* migrate(db, {
+					migrations: bundleMigrations('./drizzle2/sqlite-init'),
+
+					migrationsTable,
+					// @ts-ignore - internal param
+					init: true,
+				}).pipe(Effect.result);
+
+				assert(Result.isFailure(migratorRes));
+				assert(Predicate.isTagged(migratorRes.failure, 'MigratorInitError'));
+				expect(migratorRes.failure.exitCode).toBe('databaseMigrations');
+
+				const meta = yield* db.select({
+					hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+					createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+				}).from(sql`${sql.identifier(migrationsTable)}`);
+
+				const res = yield* db.get<{ tableExists: boolean | number }>(
+					sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+						getTableConfig(usersMigratorTable).name
+					}) AS ${sql.identifier('tableExists')};`,
+				);
+
+				expect(meta.length).toStrictEqual(1);
+				expect(!!res?.tableExists).toStrictEqual(true);
+			}));
+
+		it.effect('migrator : local migration is unapplied. Migrations timestamp is less than last db migration', () =>
+			Effect.gen(function*() {
+				const db = yield* DB;
+				const users = sqliteTable('migration_users', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				const users2 = sqliteTable('migration_users2', {
+					id: int('id').primaryKey(),
+					name: text().notNull(),
+					email: text().notNull(),
+					age: int(),
+				});
+
+				yield* db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+				yield* db.run(sql`drop table if exists ${users}`);
+				yield* db.run(sql`drop table if exists ${users2}`);
+
+				// create migration directory
+				const migrationDir = './migrations/sql-js';
+				if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+				mkdirSync(migrationDir, { recursive: true });
+
+				// first branch
+				mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240101010101_initial/migration.sql`,
+					`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+				);
+				mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240303030303_third/migration.sql`,
+					`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+				);
+
+				yield* migrate(db, { migrations: bundleMigrations(migrationDir) });
+				const res1 = yield* db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+				// second migration was not applied yet
+				const insertResult = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).pipe(Effect.result);
+				assert(Result.isFailure(insertResult));
+				assert(Predicate.isTagged(insertResult.failure, 'EffectDrizzleQueryError'));
+
+				// insert migration with earlier timestamp
+				mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+				writeFileSync(
+					`${migrationDir}/20240202020202_second/migration.sql`,
+					`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+				);
+				yield* migrate(db, { migrations: bundleMigrations(migrationDir) });
+
+				const res2 = yield* db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+				const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+				expect(res1).toStrictEqual(expected);
+				expect(res2).toStrictEqual(expected);
+
+				rmSync(migrationDir, { recursive: true });
+			}));
+	},
+});
diff --git a/integration-tests/tests/sqlite/instrumentation.ts b/integration-tests/tests/sqlite/instrumentation.ts
new file mode 100644
index 0000000000..cda3149791
--- /dev/null
+++ b/integration-tests/tests/sqlite/instrumentation.ts
@@ -0,0 +1,1055 @@
+import { type Client as LibSQLClient, createClient, type InArgs, type InStatement } from '@libsql/client';
+import {
+	createClient as createHttpClient,
+	type InArgs as HttpInArgs,
+	type InStatement as HttpInStatement,
+} from '@libsql/client/http';
+import {
+	createClient as createNodeClient,
+	type InArgs as NodeInArgs,
+	type InStatement as NodeInStatement,
+} from '@libsql/client/node';
+import {
+	createClient as createSqlite3Client,
+	type InArgs as Sqlite3InArgs,
+	type InStatement as Sqlite3InStatement,
+} from '@libsql/client/sqlite3';
+import {
+	type Client as LibSQLWsClient,
+	createClient as createWsClient,
+	type InArgs as WsInArgs,
+	type InStatement as WsInStatement,
+} from '@libsql/client/ws';
+import { D1Database, D1DatabaseAPI } from '@miniflare/d1';
+import { createSQLiteDB } from '@miniflare/shared';
+import { Database as SqliteCloudDatabase, SQLiteCloudRowset } from '@sqlitecloud/drivers';
+import { Database as TursoDatabase } from '@tursodatabase/database';
+import { connect } from '@tursodatabase/serverless';
+import { Database as TursoDatabaseSync } from '@tursodatabase/sync';
+import type BetterSqlite3 from 'better-sqlite3';
+import Client from 'better-sqlite3';
+import {
+	type AnyRelationsBuilderConfig,
+	defineRelations,
+	type ExtractTablesFromSchema,
+	type ExtractTablesWithRelations,
+	getTableName,
+	is,
+	type RelationsBuilder,
+	type RelationsBuilderConfig,
+	Table,
+} from 'drizzle-orm';
+import { drizzle as drizzleBetterSqlite3 } from 'drizzle-orm/better-sqlite3';
+import { Cache, type MutationOption } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { drizzle as drizzleD1 } from 'drizzle-orm/d1';
+import { drizzle as drizzleLibSQL, type LibSQLDatabase } from 'drizzle-orm/libsql';
+import { drizzle as drizzleLibSQLHttp } from 'drizzle-orm/libsql/http';
+import { drizzle as drizzleLibSQLNode } from 'drizzle-orm/libsql/node';
+import { drizzle as drizzleLibSQLSqlite3 } from 'drizzle-orm/libsql/sqlite3';
+import { drizzle as drizzleLibSQLWs } from 'drizzle-orm/libsql/ws';
+import { drizzle as drizzleNodeSQLite, NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
+import { drizzle as drizzleSqlJs } from 'drizzle-orm/sql-js';
+import { drizzle as drizzleSqliteCloud } from 'drizzle-orm/sqlite-cloud';
+import { SQLiteAsyncDatabase, SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
+import { drizzle as drizzleProxy } from 'drizzle-orm/sqlite-proxy';
+import { drizzle as drizzleTursoDatabaseSls } from 'drizzle-orm/tursodatabase-serverless';
+import { drizzle as drizzleTursoDatabaseSync } from 'drizzle-orm/tursodatabase-sync';
+import { drizzle as drizzleTursoDatabase } from 'drizzle-orm/tursodatabase/database';
+import Keyv from 'keyv';
+import { DatabaseSync } from 'node:sqlite';
+import type { Database as SQLJsDatabase } from 'sql.js';
+import initSqlJs from 'sql.js';
+import { test as base } from 'vitest';
+import relations from './relations';
+import sqliteRelations from './sqlite.relations';
+
+// oxlint-disable-next-line drizzle-internal/require-entity-kind
+export class TestCache extends Cache {
+	private globalTtl: number = 1000;
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(private readonly strat: 'explicit' | 'all', private kv: Keyv = new Keyv()) {
+		super();
+	}
+
+	override strategy() {
+		return this.strat;
+	}
+
+	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
+		const res = await this.kv.get(key) ?? undefined;
+		return res;
+	}
+
+	override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig,
+	): Promise<void> {
+		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+
+	override async onMutate(params: MutationOption): Promise<void> {
+		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
+		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : table as string;
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			for (const tag of tagsArray) {
+				await this.kv.delete(tag);
+			}
+
+			for (const key of keysToDelete) {
+				await this.kv.delete(key);
+				for (const table of tablesArray) {
+					const tableName = is(table, Table) ? getTableName(table) : table as string;
+					this.usedTablesPerKey[tableName] = [];
+				}
+			}
+		}
+	}
+}
+
+// eslint-disable-next-line drizzle-internal/require-entity-kind
+class ServerSimulator {
+	constructor(private db: BetterSqlite3.Database) {}
+
+	async query(sql: string, params: any[], method: string) {
+		if (method === 'run') {
+			try {
+				const result = this.db.prepare(sql).run(params);
+				return { data: result as any };
+			} catch (e: any) {
+				return { error: e.message };
+			}
+		} else if (method === 'all' || method === 'values') {
+			try {
+				const rows = this.db.prepare(sql).raw().all(params);
+				return { data: rows };
+			} catch (e: any) {
+				return { error: e.message };
+			}
+		} else if (method === 'get') {
+			try {
+				const row = this.db.prepare(sql).raw().get(params);
+				return { data: row };
+			} catch (e: any) {
+				return { error: e.message };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	migrations(queries: string[]) {
+		this.db.exec('BEGIN');
+		try {
+			for (const query of queries) {
+				this.db.exec(query);
+			}
+			this.db.exec('COMMIT');
+		} catch {
+			this.db.exec('ROLLBACK');
+		}
+
+		return {};
+	}
+}
+
+export const _push = async (
+	query: (sql: string, params: any[]) => Promise<any[]>,
+	schema: any,
+) => {
+	const { diff } = await import('../../../drizzle-kit/tests/sqlite/mocks' as string);
+
+	const res = await diff({}, schema, []);
+
+	for (const s of res.sqlStatements) {
+		try {
+			await query(s, []);
+		} catch (e) {
+			console.error(s);
+			console.error(e);
+			throw e;
+		}
+	}
+};
+
+export const prepareSQLiteCloudClient = async (uri: string) => {
+	const client = new SqliteCloudDatabase(uri);
+
+	// TODO: revise: maybe I should create run and all funcs instead of query func
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return await new Promise<any>((resolve, reject) => {
+			(params.length ? stmt.bind(...params) : stmt).all((e: Error | null, d: SQLiteCloudRowset) => {
+				if (e) return reject(e);
+
+				return resolve(d.map((v) => Object.fromEntries(Object.entries(v))));
+			});
+		});
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return await new Promise<any>((resolve, reject) => {
+			(params.length ? stmt.bind(...params) : stmt).run((e: Error | null, d: SQLiteCloudRowset) => {
+				if (e) return reject(e);
+
+				return resolve(d);
+			});
+		});
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareBetterSqlite3Client = () => {
+	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
+	const client = new Client(dbPath);
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return stmt.all(...params);
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return stmt.run(...params) as any;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareTursoDatabaseClient = () => {
+	const client = new TursoDatabase(':memory:');
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.all(...params);
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.run(...params) as any;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareTursoDatabaseSyncClient = () => {
+	const client = new TursoDatabaseSync({
+		path: ':memory:',
+	});
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.all(...params);
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.run(...params) as any;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareTursoDatabaseServerlessClient = (url: string, authToken: string | undefined) => {
+	const client = connect({
+		url,
+		authToken,
+	});
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.all(params) as any;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = await client.prepare(sql);
+		return stmt.run(params) as any;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareLibSQLClient = async (url: string, authToken?: string) => {
+	const client = createClient({ url, authToken });
+	// TODO revise: should I add here do-while loop for client creation?
+
+	// client = await retry(async () => {
+	// 	client = createClient({ url, authToken, intMode: 'number' });
+	// 	return client;
+	// }, {
+	// 	retries: 20,
+	// 	factor: 1,
+	// 	minTimeout: 250,
+	// 	maxTimeout: 250,
+	// 	randomize: false,
+	// 	onRetry() {
+	// 		client?.close();
+	// 	},
+	// });
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt: InStatement = { sql, args: params as InArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt: InStatement = { sql, args: params as InArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareLibSQLWsClient = async (url: string, authToken?: string) => {
+	const client = createWsClient({ url, authToken });
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt: WsInStatement = { sql, args: params as WsInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt: WsInStatement = { sql, args: params as WsInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareLibSQLSqlite3Client = (url: string = ':memory:') => {
+	const client = createSqlite3Client({ url });
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt: Sqlite3InStatement = { sql, args: params as Sqlite3InArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt: Sqlite3InStatement = { sql, args: params as Sqlite3InArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareLibSQLNodeClient = async (url: string, authToken?: string) => {
+	const client = createNodeClient({ url, authToken });
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt: NodeInStatement = { sql, args: params as NodeInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt: NodeInStatement = { sql, args: params as NodeInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareLibSQLHttpClient = async (url: string, authToken?: string) => {
+	const client = createHttpClient({ url, authToken });
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt: HttpInStatement = { sql, args: params as HttpInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt: HttpInStatement = { sql, args: params as HttpInArgs };
+
+		const result = await client!.execute(stmt);
+		return result.rows;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareD1Client = async () => {
+	const sqliteDb = await createSQLiteDB(':memory:');
+	const client = new D1Database(new D1DatabaseAPI(sqliteDb));
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		const result = await stmt.bind(...params).all();
+		return result.results as any[];
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		const result = await stmt.bind(...params).run();
+		return result.results as any[];
+	};
+
+	const batch = async (statements: string[]) => {
+		return await client.batch(statements.map((x) => client.prepare(x)));
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareSqlJs = async () => {
+	const SQL = await initSqlJs();
+	const client = new SQL.Database();
+
+	const all = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		stmt.bind(params);
+		const rows: any[] = [];
+		while (stmt.step()) {
+			rows.push(stmt.getAsObject());
+		}
+		stmt.free();
+
+		return rows;
+	};
+
+	const run = async (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		const result = stmt.run(params);
+		stmt.free();
+		return result as any;
+	};
+
+	const batch = async (statements: string[]) => {
+		return Promise.all(
+			statements.map((x) => run(x)),
+		).then((results) => [results] as any);
+	};
+
+	return { client, all, run, batch };
+};
+
+export const prepareNodeSQLite = async () => {
+	const client = new DatabaseSync(':memory:');
+
+	const all = (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return stmt.all(...params) as any;
+	};
+
+	const run = (sql: string, params: any[] = []) => {
+		const stmt = client.prepare(sql);
+		return stmt.run(...params) as any;
+	};
+
+	const batch = (statements: string[]) => [statements.map((s) => run(s))] as any;
+
+	return { client, all, run, batch };
+};
+
+const providerClosure = async <T>(items: T[]) => {
+	return async () => {
+		while (true) {
+			const c = items.shift();
+			if (!c) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				continue;
+			}
+			return {
+				...c,
+				release: () => {
+					items.push(c);
+				},
+			};
+		}
+	};
+};
+
+export const providerForSQLiteCloud = async () => {
+	const url = process.env['SQLITE_MANY_CLOUD_CONNECTION_STRING'];
+	if (url === undefined) throw new Error('SQLITE_MANY_CLOUD_CONNECTION_STRING is not set.');
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareSQLiteCloudClient(urlI)));
+
+	return providerClosure(clients);
+};
+
+export const providerForTursoDatabase = async () => {
+	const clients = [prepareTursoDatabaseClient()];
+
+	return providerClosure(clients);
+};
+
+export const providerForTursoDatabaseSync = async () => {
+	const clients = [prepareTursoDatabaseSyncClient()];
+
+	return providerClosure(clients);
+};
+
+export const providerForTursoDatabaseServerless = async () => {
+	const url = process.env['TURSODATABASE_REMOTE_URL'];
+	const authToken = process.env['TURSODATABASE_REMOTE_TOKEN'];
+	if (!url) {
+		throw new Error('TURSODATABASE_REMOTE_URL is not set.');
+	}
+	if (!authToken) {
+		throw new Error('TURSODATABASE_REMOTE_TOKEN is not set.');
+	}
+	const uris = url.split(';').filter((val) => val !== '');
+	const tokens = authToken.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(
+		uris.map(async (urlI, i) => await prepareTursoDatabaseServerlessClient(urlI, tokens[i])),
+	);
+	return providerClosure(clients);
+};
+
+export const providerForLibSQL = async () => {
+	const url = process.env['LIBSQL_URL'];
+	const authToken = process.env['LIBSQL_AUTH_TOKEN'];
+	if (url === undefined) throw new Error('LIBSQL_URL is not set.');
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareLibSQLClient(urlI, authToken)));
+
+	return providerClosure(clients);
+};
+export const providerForLibSQLWs = async () => {
+	const url = process.env['LIBSQL_REMOTE_MANY_URL'];
+	const authToken = process.env['LIBSQL_REMOTE_TOKEN'];
+	if (url === undefined) {
+		throw new Error('LIBSQL_REMOTE_MANY_URL is not set.');
+	}
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareLibSQLWsClient(urlI, authToken)));
+
+	return providerClosure(clients);
+};
+export const providerForLibSQLSqlite3 = async () => {
+	const clients = [prepareLibSQLSqlite3Client()];
+
+	return providerClosure(clients);
+};
+
+export const providerForLibSQLNode = async () => {
+	const url = process.env['LIBSQL_URL'];
+	const authToken = process.env['LIBSQL_AUTH_TOKEN'];
+	if (url === undefined) {
+		throw new Error('LIBSQL_URL is not set.');
+	}
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareLibSQLNodeClient(urlI, authToken)));
+
+	return providerClosure(clients);
+};
+export const providerForLibSQLHttp = async () => {
+	const url = process.env['LIBSQL_REMOTE_MANY_URL'];
+	const authToken = process.env['LIBSQL_REMOTE_TOKEN'];
+	if (url === undefined) {
+		throw new Error('LIBSQL_REMOTE_MANY_URL is not set.');
+	}
+	const uris = url.split(';').filter((val) => val !== '');
+	const clients = await Promise.all(uris.map(async (urlI) => await prepareLibSQLHttpClient(urlI, authToken)));
+
+	return providerClosure(clients);
+};
+
+export const providerForBetterSqlite3 = async () => {
+	const clients = [prepareBetterSqlite3Client()];
+
+	return providerClosure(clients);
+};
+export const providerForD1 = async () => {
+	const clients = [await prepareD1Client()];
+
+	return providerClosure(clients);
+};
+export const providerForSqlJs = async () => {
+	const clients = [await prepareSqlJs()];
+
+	return providerClosure(clients);
+};
+export const providerForNodeSQLite = async () => {
+	const clients = [await prepareNodeSQLite()];
+
+	return providerClosure(clients);
+};
+
+type ProviderForSQLiteCloud = Awaited<ReturnType<typeof providerForSQLiteCloud>>;
+type ProviderForTursoDatabase = Awaited<ReturnType<typeof providerForTursoDatabase>>;
+type ProviderForTursoDatabaseSync = Awaited<ReturnType<typeof providerForTursoDatabaseSync>>;
+type ProviderForTursoDatabaseServerless = Awaited<ReturnType<typeof providerForTursoDatabaseServerless>>;
+type ProviderForLibSQL = Awaited<ReturnType<typeof providerForLibSQL>>;
+type ProviderForLibSQLWs = Awaited<ReturnType<typeof providerForLibSQLWs>>;
+type ProviderForLibSQLSqlite3 = Awaited<ReturnType<typeof providerForLibSQLSqlite3>>;
+type ProviderForLibSQLNode = Awaited<ReturnType<typeof providerForLibSQLNode>>;
+type ProviderForLibSQLHttp = Awaited<ReturnType<typeof providerForLibSQLHttp>>;
+type ProviderForBetterSqlite3 = Awaited<ReturnType<typeof providerForBetterSqlite3>>;
+type ProviderForD1 = Awaited<ReturnType<typeof providerForD1>>;
+type ProviderForSqlJs = Awaited<ReturnType<typeof providerForSqlJs>>;
+type ProviderForNodeSQLite = Awaited<ReturnType<typeof providerForNodeSQLite>>;
+
+type Provider =
+	| ProviderForSQLiteCloud
+	| ProviderForTursoDatabase
+	| ProviderForTursoDatabaseSync
+	| ProviderForTursoDatabaseServerless
+	| ProviderForLibSQL
+	| ProviderForLibSQLWs
+	| ProviderForLibSQLSqlite3
+	| ProviderForLibSQLNode
+	| ProviderForLibSQLHttp
+	| ProviderForBetterSqlite3
+	| ProviderForD1
+	| ProviderForSqlJs
+	| ProviderForNodeSQLite;
+
+export type SqliteSchema_ = Record<
+	string,
+	| SQLiteTable<any>
+	| SQLiteView
+	| unknown
+>;
+
+const testFor = (
+	vendor:
+		| 'sqlite-cloud'
+		| 'proxy'
+		| 'tursodatabase'
+		| 'tursodatabase-sync'
+		| 'tursodatabase-serverless'
+		| 'libsql'
+		| 'libsql-turso'
+		| 'libsql-turso-v1'
+		| 'libsql-ws'
+		| 'libsql-sqlite3'
+		| 'libsql-node'
+		| 'libsql-http'
+		| 'better-sqlite3'
+		| 'd1'
+		| 'sql-js'
+		| 'node-sqlite',
+) => {
+	return base.extend<{
+		provider: Provider;
+		kit: {
+			client: any;
+			all: (sql: string, params?: any[]) => Promise<any[]>;
+			run: (sql: string, params?: any[]) => Promise<any[]>;
+			batch: (statements: string[]) => Promise<any>;
+		};
+		client:
+			| BetterSqlite3.Database
+			| SqliteCloudDatabase
+			| TursoDatabase
+			| LibSQLClient
+			| LibSQLWsClient
+			| D1Database
+			| SQLJsDatabase
+			| NodeSQLiteDatabase;
+		db: SQLiteAsyncDatabase<'async' | 'sync', any, typeof relations>;
+		push: (schema: any) => Promise<void>;
+		createDB: {
+			<S extends SqliteSchema_>(
+				schema: S,
+			): SQLiteAsyncDatabase<'async' | 'sync', any, ReturnType<typeof defineRelations<S>>>;
+			<S extends SqliteSchema_, TConfig extends AnyRelationsBuilderConfig>(
+				schema: S,
+				cb: (helpers: RelationsBuilder<ExtractTablesFromSchema<S>>) => TConfig,
+				jit?: boolean,
+			): SQLiteAsyncDatabase<
+				'async' | 'sync',
+				any,
+				ExtractTablesWithRelations<TConfig, ExtractTablesFromSchema<S>>
+			>;
+		};
+		caches: {
+			all: SQLiteAsyncDatabase<'async' | 'sync', any, typeof relations>;
+			explicit: SQLiteAsyncDatabase<'async' | 'sync', any, typeof relations>;
+		};
+	}>({
+		provider: [
+			// oxlint-disable-next-line no-empty-pattern
+			async ({}, use) => {
+				const provider = vendor === 'sqlite-cloud'
+					? await providerForSQLiteCloud()
+					: vendor === 'tursodatabase'
+					? await providerForTursoDatabase()
+					: vendor === 'tursodatabase-sync'
+					? await providerForTursoDatabaseSync()
+					: vendor === 'tursodatabase-serverless'
+					? await providerForTursoDatabaseServerless()
+					: vendor === 'libsql' || vendor === 'libsql-turso' || vendor === 'libsql-turso-v1'
+					? await providerForLibSQL()
+					: vendor === 'libsql-ws'
+					? await providerForLibSQLWs()
+					: vendor === 'libsql-sqlite3'
+					? await providerForLibSQLSqlite3()
+					: vendor === 'libsql-node'
+					? await providerForLibSQLNode()
+					: vendor === 'libsql-http'
+					? await providerForLibSQLHttp()
+					: vendor === 'proxy' || vendor === 'better-sqlite3'
+					? await providerForBetterSqlite3()
+					: vendor === 'd1'
+					? await providerForD1()
+					: vendor === 'sql-js'
+					? await providerForSqlJs()
+					: vendor === 'node-sqlite'
+					? await providerForNodeSQLite()
+					: '' as never;
+
+				await use(provider);
+			},
+			{ scope: 'file' },
+		],
+		kit: [
+			async ({ provider }, use) => {
+				const { client, batch, all, run, release } = await provider();
+				await use({ client: client, all, run, batch });
+				release();
+			},
+			{ scope: 'test' },
+		],
+		client: [
+			async ({ kit }, use) => {
+				await use(kit.client);
+			},
+			{ scope: 'test' },
+		],
+		db: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw response.error;
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from sqlite proxy server:', e.message);
+							throw e;
+						}
+					};
+					await use(drizzleProxy(proxyHandler, { relations }));
+					return;
+				}
+
+				const db = vendor === 'sqlite-cloud'
+					? drizzleSqliteCloud({ client: kit.client as any, relations })
+					: vendor === 'tursodatabase'
+					? drizzleTursoDatabase({ client: kit.client, relations })
+					: vendor === 'tursodatabase-sync'
+					? drizzleTursoDatabaseSync({ client: kit.client, relations })
+					: vendor === 'tursodatabase-serverless'
+					? drizzleTursoDatabaseSls({ client: kit.client, relations })
+					: vendor === 'libsql'
+					? drizzleLibSQL({ client: kit.client, relations })
+					: vendor === 'libsql-ws'
+					? drizzleLibSQLWs({ client: kit.client, relations })
+					: vendor === 'libsql-sqlite3'
+					? drizzleLibSQLSqlite3({ client: kit.client, relations })
+					: vendor === 'libsql-node'
+					? drizzleLibSQLNode({ client: kit.client, relations })
+					: vendor === 'libsql-http'
+					? drizzleLibSQLHttp({ client: kit.client, relations })
+					: vendor === 'better-sqlite3'
+					? drizzleBetterSqlite3({ client: kit.client, relations })
+					: vendor === 'd1'
+					? drizzleD1(kit.client, { relations })
+					: vendor === 'sql-js'
+					? drizzleSqlJs(kit.client, { relations })
+					: vendor === 'node-sqlite'
+					? drizzleNodeSQLite({ client: kit.client, relations })
+					: '' as never;
+
+				await use(db);
+			},
+			{ scope: 'test' },
+		],
+		push: [
+			async ({ kit }, use) => {
+				const push = (
+					schema: any,
+				) => _push(kit.run, schema);
+
+				await use(push);
+			},
+			{ scope: 'test' },
+		],
+		createDB: [
+			async ({ kit }, use) => {
+				const createDB = <S extends SqliteSchema_>(
+					schema: S,
+					cb?: (
+						helpers: RelationsBuilder<ExtractTablesFromSchema<S>>,
+					) => RelationsBuilderConfig<ExtractTablesFromSchema<S>>,
+					jit?: boolean,
+				) => {
+					const relations = cb ? defineRelations(schema, cb) : defineRelations(schema);
+
+					if (vendor === 'sqlite-cloud') return drizzleSqliteCloud({ client: kit.client, relations, jit });
+					if (vendor === 'tursodatabase') return drizzleTursoDatabase({ client: kit.client, relations, jit });
+					if (vendor === 'tursodatabase-sync') return drizzleTursoDatabaseSync({ client: kit.client, relations, jit });
+					if (vendor === 'tursodatabase-serverless') {
+						return drizzleTursoDatabaseSls({ client: kit.client, relations, jit });
+					}
+					if (vendor === 'libsql' || vendor === 'libsql-turso' || vendor === 'libsql-turso-v1') {
+						return drizzleLibSQL({ client: kit.client, relations, jit });
+					}
+					if (vendor === 'libsql-ws') return drizzleLibSQLWs({ client: kit.client, relations, jit });
+					if (vendor === 'libsql-sqlite3') return drizzleLibSQLSqlite3({ client: kit.client, relations, jit });
+					if (vendor === 'libsql-node') return drizzleLibSQLNode({ client: kit.client, relations, jit });
+					if (vendor === 'libsql-http') return drizzleLibSQLHttp({ client: kit.client, relations, jit });
+					if (vendor === 'better-sqlite3') return drizzleBetterSqlite3({ client: kit.client, relations, jit });
+					if (vendor === 'd1') return drizzleD1(kit.client, { relations });
+					if (vendor === 'sql-js') return drizzleSqlJs(kit.client, { relations, jit });
+					if (vendor === 'node-sqlite') return drizzleNodeSQLite({ client: kit.client, relations, jit });
+
+					if (vendor === 'proxy') {
+						const serverSimulator = new ServerSimulator(kit.client);
+						const proxyHandler = async (sql: string, params: any[], method: any) => {
+							try {
+								const response = await serverSimulator.query(sql, params, method);
+
+								if (response.error !== undefined) {
+									throw response.error;
+								}
+
+								return { rows: response.data };
+							} catch (e: any) {
+								console.error('Error from sqlite proxy server:', e.message);
+								throw e;
+							}
+						};
+						return drizzleProxy(proxyHandler, { relations, jit });
+					}
+					throw new Error();
+				};
+
+				await use(createDB);
+			},
+			{ scope: 'test' },
+		],
+		caches: [
+			async ({ kit }, use) => {
+				if (vendor === 'proxy') {
+					const serverSimulator = new ServerSimulator(kit.client);
+					const proxyHandler = async (sql: string, params: any[], method: any) => {
+						try {
+							const response = await serverSimulator.query(sql, params, method);
+
+							if (response.error !== undefined) {
+								throw new Error(response.error);
+							}
+
+							return { rows: response.data };
+						} catch (e: any) {
+							console.error('Error from sqlite proxy server:', e.message);
+							throw e;
+						}
+					};
+					const db1 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('all') });
+					const db2 = drizzleProxy(proxyHandler, { relations, cache: new TestCache('explicit') });
+					await use({ all: db1, explicit: db2 });
+					return;
+				}
+
+				const config1 = { client: kit.client as any, relations, cache: new TestCache('all') };
+				const config2 = { client: kit.client as any, relations, cache: new TestCache('explicit') };
+
+				const db1 = vendor === 'sqlite-cloud'
+					? drizzleSqliteCloud(config1)
+					: vendor === 'tursodatabase'
+					? drizzleTursoDatabase(config1)
+					: vendor === 'tursodatabase-sync'
+					? drizzleTursoDatabaseSync(config1)
+					: vendor === 'tursodatabase-serverless'
+					? drizzleTursoDatabaseSls(config1)
+					: vendor === 'libsql' || vendor === 'libsql-turso' || vendor === 'libsql-turso-v1'
+					? drizzleLibSQL(config1)
+					: vendor === 'libsql-ws'
+					? drizzleLibSQLWs(config1)
+					: vendor === 'libsql-sqlite3'
+					? drizzleLibSQLSqlite3(config1)
+					: vendor === 'libsql-node'
+					? drizzleLibSQLNode(config1)
+					: vendor === 'libsql-http'
+					? drizzleLibSQLHttp(config1)
+					: vendor === 'better-sqlite3'
+					? drizzleBetterSqlite3(config1)
+					: vendor === 'd1'
+					? drizzleD1(config1.client, { cache: config1.cache, relations: config1.relations })
+					: vendor === 'sql-js'
+					? drizzleSqlJs(config1.client, { cache: config1.cache, relations: config1.relations })
+					: vendor === 'node-sqlite'
+					? drizzleNodeSQLite(config1)
+					: '' as never;
+
+				const db2 = vendor === 'sqlite-cloud'
+					? drizzleSqliteCloud(config2)
+					: vendor === 'tursodatabase'
+					? drizzleTursoDatabase(config2)
+					: vendor === 'tursodatabase-sync'
+					? drizzleTursoDatabaseSync(config2)
+					: vendor === 'tursodatabase-serverless'
+					? drizzleTursoDatabaseSls(config2)
+					: vendor === 'libsql' || vendor === 'libsql-turso' || vendor === 'libsql-turso-v1'
+					? drizzleLibSQL(config2)
+					: vendor === 'libsql-ws'
+					? drizzleLibSQLWs(config2)
+					: vendor === 'libsql-sqlite3'
+					? drizzleLibSQLSqlite3(config2)
+					: vendor === 'libsql-node'
+					? drizzleLibSQLNode(config2)
+					: vendor === 'libsql-http'
+					? drizzleLibSQLHttp(config2)
+					: vendor === 'better-sqlite3'
+					? drizzleBetterSqlite3(config2)
+					: vendor === 'd1'
+					? drizzleD1(config2.client, { cache: config2.cache, relations: config2.relations })
+					: vendor === 'sql-js'
+					? drizzleSqlJs(config2.client, { cache: config2.cache, relations: config2.relations })
+					: vendor === 'node-sqlite'
+					? drizzleNodeSQLite(config2)
+					: '' as never;
+
+				await use({ all: db1, explicit: db2 });
+			},
+			{ scope: 'test' },
+		],
+	});
+};
+
+export const sqliteCloudTest = testFor('sqlite-cloud');
+export const tursoDatabaseTest = testFor('tursodatabase');
+export const tursoDatabaseSyncTest = testFor('tursodatabase-sync');
+export const tursoDatabaseServerlessTest = testFor('tursodatabase-serverless');
+export const libSQLTest = testFor('libsql');
+export const libSQLWsTest = testFor('libsql-ws');
+export const libSQLSqlite3Test = testFor('libsql-sqlite3');
+export const libSQLNodeTest = testFor('libsql-node');
+export const libSQLHttpTest = testFor('libsql-http');
+export const betterSqlite3Test = testFor('better-sqlite3');
+export const d1Test = testFor('d1');
+export const sqlJsTest = testFor('sql-js');
+export const nodeSQLiteTest = testFor('node-sqlite');
+export const libSQLTursoTest = testFor('libsql-turso').extend<{ db: LibSQLDatabase<typeof sqliteRelations> }>({
+	db: [
+		async ({ kit }, use) => {
+			const db = drizzleLibSQL({
+				client: kit.client,
+				relations: sqliteRelations,
+			}) as LibSQLDatabase<typeof sqliteRelations>;
+
+			await use(db);
+		},
+		{ scope: 'test' },
+	],
+});
+export const proxyTest = testFor('proxy').extend<{ serverSimulator: ServerSimulator }>({
+	serverSimulator: [
+		async ({ client }, use) => {
+			const serverSimulator = new ServerSimulator(client as BetterSqlite3.Database);
+			await use(serverSimulator);
+		},
+		{ scope: 'test' },
+	],
+});
+
+export type Test = ReturnType<typeof testFor>;
diff --git a/integration-tests/tests/sqlite/libsql-batch.test.ts b/integration-tests/tests/sqlite/libsql-batch.test.ts
index 693845f308..de33a3b0ac 100644
--- a/integration-tests/tests/sqlite/libsql-batch.test.ts
+++ b/integration-tests/tests/sqlite/libsql-batch.test.ts
@@ -1,7 +1,8 @@
 import { createClient } from '@libsql/client';
 import type { Client, ResultSet } from '@libsql/client';
 import retry from 'async-retry';
-import { eq, relations, sql } from 'drizzle-orm';
+import { defineRelations, eq, sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import { drizzle, type LibSQLDatabase } from 'drizzle-orm/libsql';
 import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
 import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
@@ -44,9 +45,7 @@ export const usersToGroupsTable = sqliteTable(
 			() => groupsTable.id,
 		),
 	},
-	(t) => ({
-		pk: primaryKey({ columns: [t.userId, t.groupId] }),
-	}),
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
 );
 export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
 	group: one(groupsTable, {
@@ -134,7 +133,9 @@ const schema = {
 	usersConfig,
 };
 
-let db: LibSQLDatabase<typeof schema>;
+const relationsV2 = defineRelations(schema);
+
+let db: LibSQLDatabase<typeof relationsV2>;
 let client: Client;
 
 beforeAll(async () => {
@@ -156,7 +157,7 @@ beforeAll(async () => {
 			client?.close();
 		},
 	});
-	db = drizzle(client, { schema, logger: ENABLE_LOGGING });
+	db = drizzle({ client, logger: ENABLE_LOGGING, relations: relationsV2 });
 });
 
 afterAll(async () => {
@@ -462,6 +463,32 @@ test('insert + findManyWith + db.all', async () => {
 	]);
 });
 
+test('reproduce "insert + update + select + select partial" test bug', async () => {
+	await client.execute('drop table if exists "users";');
+	await client.execute(`
+			CREATE TABLE "users" (
+			    "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    "name" text NOT NULL,
+			    "verified" integer DEFAULT 0 NOT NULL,
+			    "invited_by" integer
+			);
+		`);
+
+	// const query1 = db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }).toSQL();
+	// console.log(query1);
+	const sql1 = 'insert into "users" ("id", "name", "verified", "invited_by") values (?, ?, ?, null) returning "id"';
+	const params1 = [1, 'John', 0];
+	const res1 = await client.execute({ sql: sql1 as string, args: params1 as any[] });
+	console.log(res1);
+
+	// const query2 = db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)).toSQL();
+	// console.log(query2);
+	const sql2 = 'update "users" set "name" = ? where "users"."id" = ?';
+	const params2 = ['Dan', 1];
+	const res2 = await client.execute({ sql: sql2 as string, args: params2 as any[] });
+	console.log(res2);
+});
+
 // batch api for insert + update + select
 test('insert + update + select + select partial', async () => {
 	const batchResponse = await db.batch([
diff --git a/integration-tests/tests/sqlite/libsql-http.test.ts b/integration-tests/tests/sqlite/libsql-http.test.ts
index 576d8d48a4..5ab3f8d973 100644
--- a/integration-tests/tests/sqlite/libsql-http.test.ts
+++ b/integration-tests/tests/sqlite/libsql-http.test.ts
@@ -1,57 +1,20 @@
-import { type Client, createClient } from '@libsql/client/http';
-import retry from 'async-retry';
 import { asc, eq, getTableColumns, sql } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import { drizzle } from 'drizzle-orm/libsql/http';
 import { migrate } from 'drizzle-orm/libsql/migrator';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
+import { libSQLHttpTest as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable, usersOnUpdate } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: LibSQLDatabase;
-let client: Client;
-
-beforeAll(async () => {
-	const url = process.env['LIBSQL_REMOTE_URL'];
-	const authToken = process.env['LIBSQL_REMOTE_TOKEN'];
-	if (!url) {
-		throw new Error('LIBSQL_REMOTE_URL is not set');
-	}
-	client = await retry(async () => {
-		client = createClient({ url, authToken });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -67,13 +30,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -89,9 +55,164 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-	const { db } = ctx.sqlite;
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/libsql-http';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
 
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+test('test $onUpdateFn and $onUpdate works as $default', async ({ db }) => {
 	await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
 	await db.run(
@@ -131,9 +252,7 @@ test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
 	}
 });
 
-test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-	const { db } = ctx.sqlite;
-
+test('test $onUpdateFn and $onUpdate works updating', async ({ db }) => {
 	await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
 	await db.run(
@@ -176,11 +295,15 @@ test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
 	}
 });
 
-skipTests([
-	'delete with limit and order by',
-	'update with limit and order by',
+const skip = [
 	'test $onUpdateFn and $onUpdate works as $default',
 	'test $onUpdateFn and $onUpdate works updating',
-]);
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+	// DB needs to be built in special way to support this
+	'delete with limit and order by',
+	'update with limit and order by',
+];
 
-tests();
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/libsql-node.test.ts b/integration-tests/tests/sqlite/libsql-node.test.ts
index bfe2c1574d..909e0b6fc9 100644
--- a/integration-tests/tests/sqlite/libsql-node.test.ts
+++ b/integration-tests/tests/sqlite/libsql-node.test.ts
@@ -1,57 +1,20 @@
-import { type Client, createClient } from '@libsql/client/node';
-import retry from 'async-retry';
 import { sql } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import { migrate } from 'drizzle-orm/libsql/migrator';
-import { drizzle } from 'drizzle-orm/libsql/node';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
+import { libSQLNodeTest as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: LibSQLDatabase;
-let client: Client;
-
-beforeAll(async () => {
-	const url = process.env['LIBSQL_URL'];
-	const authToken = process.env['LIBSQL_AUTH_TOKEN'];
-	if (!url) {
-		throw new Error('LIBSQL_URL is not set');
-	}
-	client = await retry(async () => {
-		client = createClient({ url, authToken });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -67,13 +30,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -89,9 +55,169 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-skipTests([
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/libsql-node';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
 	'delete with limit and order by',
 	'update with limit and order by',
-]);
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+];
 
-tests();
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/libsql-sqlite3.test.ts b/integration-tests/tests/sqlite/libsql-sqlite3.test.ts
index 8d8419f178..9a868c41dc 100644
--- a/integration-tests/tests/sqlite/libsql-sqlite3.test.ts
+++ b/integration-tests/tests/sqlite/libsql-sqlite3.test.ts
@@ -1,53 +1,22 @@
-import { type Client, createClient } from '@libsql/client/sqlite3';
-import retry from 'async-retry';
 import { sql } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import { migrate } from 'drizzle-orm/libsql/migrator';
 import { drizzle } from 'drizzle-orm/libsql/sqlite3';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { skipTests } from '~/common';
 import { randomString } from '~/utils';
+import { libSQLSqlite3Test as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: LibSQLDatabase;
-let client: Client;
-
-beforeAll(async () => {
-	const url = ':memory:';
-	client = await retry(async () => {
-		client = createClient({ url });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -63,13 +32,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -85,13 +57,172 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-skipTests([
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/libsql-sqlite3';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
 	'delete with limit and order by',
 	'update with limit and order by',
 	'transaction',
 	'transaction rollback',
+	'sync transaction rollback',
 	'nested transaction',
 	'nested transaction rollback',
-]);
+	'sync nested transaction rollback',
+];
 
-tests();
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/libsql-ws.test.ts b/integration-tests/tests/sqlite/libsql-ws.test.ts
index 86810a36f7..bcda06806c 100644
--- a/integration-tests/tests/sqlite/libsql-ws.test.ts
+++ b/integration-tests/tests/sqlite/libsql-ws.test.ts
@@ -1,57 +1,20 @@
-import { type Client, createClient } from '@libsql/client/ws';
-import retry from 'async-retry';
 import { asc, eq, getTableColumns, sql } from 'drizzle-orm';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import { migrate } from 'drizzle-orm/libsql/migrator';
-import { drizzle } from 'drizzle-orm/libsql/ws';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
+import { libSQLWsTest as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable, usersOnUpdate } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: LibSQLDatabase;
-let client: Client;
-
-beforeAll(async () => {
-	const url = process.env['LIBSQL_REMOTE_URL'];
-	const authToken = process.env['LIBSQL_REMOTE_TOKEN'];
-	if (!url) {
-		throw new Error('LIBSQL_REMOTE_URL is not set');
-	}
-	client = await retry(async () => {
-		client = createClient({ url, authToken });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -67,13 +30,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -89,9 +55,105 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-	const { db } = ctx.sqlite;
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
 
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('test $onUpdateFn and $onUpdate works as $default', async ({ db }) => {
 	await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
 	await db.run(
@@ -131,9 +193,7 @@ test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
 	}
 });
 
-test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-	const { db } = ctx.sqlite;
-
+test('test $onUpdateFn and $onUpdate works updating', async ({ db }) => {
 	await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
 	await db.run(
@@ -176,13 +236,77 @@ test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
 	}
 });
 
-skipTests([
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/libsql-ws';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+	// DB needs to be built in special way to support this
 	'delete with limit and order by',
 	'update with limit and order by',
+
 	'join view as subquery',
 	'test $onUpdateFn and $onUpdate works as $default',
 	'test $onUpdateFn and $onUpdate works updating',
 	'prepared statement reuse',
-]);
+];
 
-tests();
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/libsql.test.ts b/integration-tests/tests/sqlite/libsql.test.ts
index 8d68496584..06d98eac51 100644
--- a/integration-tests/tests/sqlite/libsql.test.ts
+++ b/integration-tests/tests/sqlite/libsql.test.ts
@@ -1,65 +1,21 @@
-import { type Client, createClient } from '@libsql/client';
-import retry from 'async-retry';
 import { sql } from 'drizzle-orm';
-import { drizzle, type LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 import { migrate } from 'drizzle-orm/libsql/migrator';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
 import { randomString } from '~/utils';
+import { libSQLTest as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './sqlite-common-cache';
-
-const ENABLE_LOGGING = false;
-
-let db: LibSQLDatabase;
-let dbGlobalCached: LibSQLDatabase;
-let cachedDb: LibSQLDatabase;
-let client: Client;
-
-beforeAll(async () => {
-	const url = process.env['LIBSQL_URL'];
-	const authToken = process.env['LIBSQL_AUTH_TOKEN'];
-	if (!url) {
-		throw new Error('LIBSQL_URL is not set');
-	}
-	client = await retry(async () => {
-		client = createClient({ url, authToken });
-		return client;
-	}, {
-		retries: 20,
-		factor: 1,
-		minTimeout: 250,
-		maxTimeout: 250,
-		randomize: false,
-		onRetry() {
-			client?.close();
-		},
-	});
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-	cachedDb = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestCache() });
-	dbGlobalCached = drizzle(client, { logger: ENABLE_LOGGING, cache: new TestGlobalCache() });
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-	ctx.cachedSqlite = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
-});
+import { tests as cacheTests } from './sqlite-common-cache';
 
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists __drizzle_migrations`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = await db.select().from(usersMigratorTable).all();
@@ -75,13 +31,16 @@ test('migrator', async () => {
 	await db.run(sql`drop table __drizzle_migrations`);
 });
 
-test('migrator : migrate with custom table', async () => {
+test('migrator : migrate with custom table', async ({ db }) => {
 	const customTable = randomString();
 	await db.run(sql`drop table if exists another_users`);
 	await db.run(sql`drop table if exists users12`);
 	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	await migrate(db, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable: customTable,
+	});
 
 	// test if the custom migrations table was created
 	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
@@ -97,10 +56,171 @@ test('migrator : migrate with custom table', async () => {
 	await db.run(sql`drop table ${sql.identifier(customTable)}`);
 });
 
-skipTests([
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as LibSQLDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/libsql';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as LibSQLDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+	// DB needs to be built in special way to support this
 	'delete with limit and order by',
 	'update with limit and order by',
-]);
+];
 
-cacheTests();
-tests();
+cacheTests(test, skip);
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/node-sqlite.test.ts b/integration-tests/tests/sqlite/node-sqlite.test.ts
new file mode 100644
index 0000000000..622f76064b
--- /dev/null
+++ b/integration-tests/tests/sqlite/node-sqlite.test.ts
@@ -0,0 +1,197 @@
+import { sql } from 'drizzle-orm';
+import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
+import { migrate } from 'drizzle-orm/node-sqlite/migrator';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { nodeSQLiteTest as test } from './instrumentation';
+import relations from './relations';
+import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
+
+test('migrator', async ({ db }) => {
+	db.run(sql`drop table if exists another_users`);
+	db.run(sql`drop table if exists users12`);
+	db.run(sql`drop table if exists __drizzle_migrations`);
+
+	migrate(db as NodeSQLiteDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
+
+	db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = db.select().from(usersMigratorTable).all();
+
+	db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	db.run(sql`drop table another_users`);
+	db.run(sql`drop table users12`);
+	db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as NodeSQLiteDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as NodeSQLiteDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	migrate(db as NodeSQLiteDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = migrate(db as NodeSQLiteDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sql-js';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as NodeSQLiteDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as NodeSQLiteDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses sync versions
+	'transaction rollback',
+	'nested transaction rollback',
+	// DB needs to be built in special way to support this
+	'delete with limit and order by',
+	'update with limit and order by',
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/relations.ts b/integration-tests/tests/sqlite/relations.ts
new file mode 100644
index 0000000000..1e7748c064
--- /dev/null
+++ b/integration-tests/tests/sqlite/relations.ts
@@ -0,0 +1,14 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './schema';
+
+export default defineRelations(schema, (r) => ({
+	rqbUser: {
+		posts: r.many.rqbPost(),
+	},
+	rqbPost: {
+		author: r.one.rqbUser({
+			from: r.rqbPost.userId,
+			to: r.rqbUser.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/sqlite/replicas.test.ts b/integration-tests/tests/sqlite/replicas.test.ts
new file mode 100644
index 0000000000..e798208737
--- /dev/null
+++ b/integration-tests/tests/sqlite/replicas.test.ts
@@ -0,0 +1,929 @@
+import { defineRelations, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/libsql';
+import { int, sqliteTable, text, withReplicas } from 'drizzle-orm/sqlite-core';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = sqliteTable('users', {
+	id: int('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: text('verified').notNull().default('true'),
+});
+
+const users = sqliteTable('users', {
+	id: int('id' as string).primaryKey(),
+});
+
+describe('[select] read replicas sqlite', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query = db.$primary.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual('select "id" from "users"');
+
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select({ count: sql`count(*)`.as('count') }).from(users).limit(1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(query1.toSQL().sql).toEqual('select count(*) as "count" from "users" limit ?');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		const query1 = db.select({ id: users.id }).from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.$primary.select().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		const query1 = db.select().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select "id" from "users"');
+
+		const query2 = db.select().from(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select "id" from "users"');
+	});
+});
+
+describe('[selectDistinct] read replicas sqlite', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query = db.$primary.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.$primary.selectDistinct().from(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		const query1 = db.selectDistinct().from(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('select distinct "id" from "users"');
+
+		const query2 = db.selectDistinct().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('select distinct "id" from "users"');
+	});
+});
+
+describe('[with] read replicas sqlite', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+		const obj4 = {} as any;
+
+		db.$primary.with(obj1, obj2, obj3, obj4);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj1, obj2, obj3, obj4);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+		const obj3 = {} as any;
+
+		db.with(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		db.with(obj2, obj3);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj2, obj3);
+	});
+});
+
+describe('[update] replicas sqlite', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		const query1 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual('update "users" set "id" = ?');
+
+		const query2 = db.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query2.toSQL().sql).toEqual('update "users" set "id" = ?');
+
+		const query3 = db.$primary.update(users).set({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query3.toSQL().sql).toEqual('update "users" set "id" = ?');
+	});
+});
+
+describe('[delete] replicas sqlite', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		const query1 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query1.toSQL().sql).toEqual('delete from "users"');
+
+		const query2 = db.delete(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+		expect(query2.toSQL().sql).toEqual('delete from "users"');
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas sqlite', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		const query = db.insert(users).values({ id: 1 });
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(users);
+		expect(query.toSQL().sql).toEqual('insert into "users" ("id") values (?)');
+
+		db.insert(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, users);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas sqlite', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'all');
+		const spyRead1 = vi.spyOn(read1, 'all');
+		const spyRead2 = vi.spyOn(read2, 'all');
+
+		try {
+			await db.all(sql``);
+		} catch {}
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			await db.all(sql``);
+		} catch {}
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			await db.all(sql``);
+		} catch {}
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas sqlite', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const txFn1 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn1)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(txFn1);
+
+		const txFn2 = async (tx: any) => {
+			tx.select().from({} as any);
+		};
+
+		expect(db.transaction(txFn2)).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenNthCalledWith(2, txFn2);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findFirst] read replicas sqlite', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const obj = {} as any;
+
+		db.$primary.query.usersTable.findFirst(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const par1 = {} as any;
+
+		db.query.usersTable.findFirst(par1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(par1);
+
+		const query = db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0" limit ?',
+		);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas sqlite', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj = {} as any;
+
+		const query = db.$primary.query.usersTable.findMany(obj);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledWith(obj);
+		expect(query.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+		expect(spyRead2).toHaveBeenCalledWith(obj2);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+
+		const query2 = db.$primary.query.usersTable.findMany(obj2);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenNthCalledWith(1, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read1 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+		const read2 = drizzle.mock({ relations: defineRelations({ usersTable }) });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const obj1 = {} as any;
+		const obj2 = {} as any;
+
+		const query1 = db.query.usersTable.findMany(obj1);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledWith(obj1);
+		expect(query1.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+
+		const query2 = db.query.usersTable.findMany(obj2);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenNthCalledWith(2, obj2);
+		expect(query2.toSQL().sql).toEqual(
+			'select "d0"."id" as "id", "d0"."name" as "name", "d0"."verified" as "verified" from "users" as "d0"',
+		);
+	});
+});
+
+describe('[$count] read replicas postgres', () => {
+	it('primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$primary.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from(users);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('single read replica $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$count(users);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica $count + primary $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.$count(users);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read $count', () => {
+		const primaryDb = drizzle.mock();
+		const read1 = drizzle.mock();
+		const read2 = drizzle.mock();
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, '$count');
+		const spyRead1 = vi.spyOn(read1, '$count');
+		const spyRead2 = vi.spyOn(read2, '$count');
+
+		db.$count(users);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$count(users);
+
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/tests/sqlite/schema.ts b/integration-tests/tests/sqlite/schema.ts
new file mode 100644
index 0000000000..b79fc80bc7
--- /dev/null
+++ b/integration-tests/tests/sqlite/schema.ts
@@ -0,0 +1,50 @@
+import { sql } from 'drizzle-orm';
+import { integer, type SQLiteAsyncDatabase, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const rqbUser = sqliteTable('user_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	name: text().notNull(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const rqbPost = sqliteTable('post_rqb_test', {
+	id: integer().primaryKey().notNull(),
+	userId: integer('user_id').notNull(),
+	content: text(),
+	createdAt: integer('created_at', {
+		mode: 'timestamp_ms',
+	}).notNull(),
+});
+
+export const init = async (db: SQLiteAsyncDatabase<any, any, any>) => {
+	await db.run(sql`
+		CREATE TABLE ${rqbUser} (
+		        "id" INT PRIMARY KEY NOT NULL,
+		        "name" TEXT NOT NULL,
+		        "created_at" INT NOT NULL
+		     )
+	`);
+	await db.run(sql`
+		CREATE TABLE ${rqbPost} ( 
+		        "id" INT PRIMARY KEY NOT NULL,
+		        "user_id" INT NOT NULL,
+		        "content" TEXT,
+		        "created_at" INT NOT NULL
+		)
+	`);
+};
+
+export const clear = async (db: SQLiteAsyncDatabase<any, any, any>) => {
+	try {
+		await db.run(sql`DROP TABLE IF EXISTS ${rqbUser};`);
+	} catch {
+		null;
+	}
+	try {
+		await db.run(sql`DROP TABLE IF EXISTS ${rqbPost};`);
+	} catch {
+		null;
+	}
+};
diff --git a/integration-tests/tests/sqlite/sql-js.test.ts b/integration-tests/tests/sqlite/sql-js.test.ts
index 4c733835fb..8864f182fb 100644
--- a/integration-tests/tests/sqlite/sql-js.test.ts
+++ b/integration-tests/tests/sqlite/sql-js.test.ts
@@ -1,40 +1,19 @@
 import { sql } from 'drizzle-orm';
 import type { SQLJsDatabase } from 'drizzle-orm/sql-js';
-import { drizzle } from 'drizzle-orm/sql-js';
 import { migrate } from 'drizzle-orm/sql-js/migrator';
-import type { Database } from 'sql.js';
-import initSqlJs from 'sql.js';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { sqlJsTest as test } from './instrumentation';
+import relations from './relations';
 import { anotherUsersMigratorTable, tests, usersMigratorTable } from './sqlite-common';
 
-const ENABLE_LOGGING = false;
-
-let db: SQLJsDatabase;
-let client: Database;
-
-beforeAll(async () => {
-	const SQL = await initSqlJs();
-	client = new SQL.Database();
-	db = drizzle(client, { logger: ENABLE_LOGGING });
-});
-
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-});
-
-afterAll(async () => {
-	client?.close();
-});
-
-test('migrator', async () => {
+test('migrator', async ({ db }) => {
 	db.run(sql`drop table if exists another_users`);
 	db.run(sql`drop table if exists users12`);
 	db.run(sql`drop table if exists __drizzle_migrations`);
 
-	migrate(db, { migrationsFolder: './drizzle2/sqlite' });
+	migrate(db as SQLJsDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
 
 	db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
 	const result = db.select().from(usersMigratorTable).all();
@@ -50,15 +29,169 @@ test('migrator', async () => {
 	db.run(sql`drop table __drizzle_migrations`);
 });
 
-skipTests([
-	/**
-	 * doesn't work properly:
-	 * 	Expect: should rollback transaction and don't insert/ update data
-	 * 	Received: data inserted/ updated
-	 */
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as SQLJsDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = migrate(db as SQLJsDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	migrate(db as SQLJsDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = migrate(db as SQLJsDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sql-js';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as SQLJsDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as SQLJsDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses sync versions
 	'transaction rollback',
 	'nested transaction rollback',
+	// DB needs to be built in special way to support this
 	'delete with limit and order by',
 	'update with limit and order by',
-]);
-tests();
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/sqlite-cloud.test.ts b/integration-tests/tests/sqlite/sqlite-cloud.test.ts
new file mode 100644
index 0000000000..1bdccd5f57
--- /dev/null
+++ b/integration-tests/tests/sqlite/sqlite-cloud.test.ts
@@ -0,0 +1,209 @@
+import { sql } from 'drizzle-orm';
+import type { SQLiteCloudDatabase } from 'drizzle-orm/sqlite-cloud';
+import { migrate } from 'drizzle-orm/sqlite-cloud/migrator';
+import { getTableConfig, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { sqliteCloudTest as test } from './instrumentation';
+import relations from './relations';
+import { tests } from './sqlite-common';
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+test.concurrent('migrator', async ({ db }) => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db as SQLiteCloudDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test.concurrent('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as SQLiteCloudDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test.concurrent('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as SQLiteCloudDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.tableExists).toStrictEqual(false);
+});
+
+test.concurrent('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as SQLiteCloudDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as SQLiteCloudDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ tableExists: boolean | number }>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.tableExists).toStrictEqual(true);
+});
+
+test.concurrent('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sqlite-cloud';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as SQLiteCloudDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as SQLiteCloudDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+	// Currently not supported by provider
+	'update with limit and order by',
+	'delete with limit and order by',
+];
+
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/sqlite-common-cache.ts b/integration-tests/tests/sqlite/sqlite-common-cache.ts
index 05582055f6..26273c61c8 100644
--- a/integration-tests/tests/sqlite/sqlite-common-cache.ts
+++ b/integration-tests/tests/sqlite/sqlite-common-cache.ts
@@ -1,90 +1,7 @@
-import { eq, getTableName, is, sql, Table } from 'drizzle-orm';
-import type { MutationOption } from 'drizzle-orm/cache/core';
-import { Cache } from 'drizzle-orm/cache/core';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
-import { alias, type BaseSQLiteDatabase, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import Keyv from 'keyv';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestGlobalCache extends Cache {
-	private globalTtl: number = 1000;
-	private usedTablesPerKey: Record<string, string[]> = {};
-
-	constructor(private kv: Keyv = new Keyv()) {
-		super();
-	}
-
-	override strategy(): 'explicit' | 'all' {
-		return 'all';
-	}
-	override async get(key: string, _tables: string[], _isTag: boolean): Promise<any[] | undefined> {
-		const res = await this.kv.get(key) ?? undefined;
-		return res;
-	}
-	override async put(
-		key: string,
-		response: any,
-		tables: string[],
-		isTag: boolean,
-		config?: CacheConfig,
-	): Promise<void> {
-		await this.kv.set(key, response, config ? config.ex : this.globalTtl);
-		for (const table of tables) {
-			const keys = this.usedTablesPerKey[table];
-			if (keys === undefined) {
-				this.usedTablesPerKey[table] = [key];
-			} else {
-				keys.push(key);
-			}
-		}
-	}
-	override async onMutate(params: MutationOption): Promise<void> {
-		const tagsArray = params.tags ? Array.isArray(params.tags) ? params.tags : [params.tags] : [];
-		const tablesArray = params.tables ? Array.isArray(params.tables) ? params.tables : [params.tables] : [];
-
-		const keysToDelete = new Set<string>();
-
-		for (const table of tablesArray) {
-			const tableName = is(table, Table) ? getTableName(table) : table as string;
-			const keys = this.usedTablesPerKey[tableName] ?? [];
-			for (const key of keys) keysToDelete.add(key);
-		}
-
-		if (keysToDelete.size > 0 || tagsArray.length > 0) {
-			for (const tag of tagsArray) {
-				await this.kv.delete(tag);
-			}
-
-			for (const key of keysToDelete) {
-				await this.kv.delete(key);
-				for (const table of tablesArray) {
-					const tableName = is(table, Table) ? getTableName(table) : table as string;
-					this.usedTablesPerKey[tableName] = [];
-				}
-			}
-		}
-	}
-}
-
-// eslint-disable-next-line drizzle-internal/require-entity-kind
-export class TestCache extends TestGlobalCache {
-	override strategy(): 'explicit' | 'all' {
-		return 'explicit';
-	}
-}
-
-declare module 'vitest' {
-	interface TestContext {
-		cachedSqlite: {
-			db: BaseSQLiteDatabase<any, any>;
-			dbGlobalCached: BaseSQLiteDatabase<any, any>;
-		};
-		sqlite: {
-			db: BaseSQLiteDatabase<'async' | 'sync', any, Record<string, never>>;
-		};
-	}
-}
+import { eq, sql } from 'drizzle-orm';
+import { alias, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { describe, expect, vi } from 'vitest';
+import { Test } from './instrumentation';
 
 const usersTable = sqliteTable('users', {
 	id: integer('id').primaryKey({ autoIncrement: true }),
@@ -100,16 +17,19 @@ const postsTable = sqliteTable('posts', {
 	userId: integer('user_id').references(() => usersTable.id),
 });
 
-export function tests() {
+export function tests(test: Test, exclude: string[] = []) {
+	test.beforeEach(({ task, skip }) => {
+		if (exclude.includes(task.name)) skip();
+	});
 	describe('common_cache', () => {
-		beforeEach(async (ctx) => {
-			const { db, dbGlobalCached } = ctx.cachedSqlite;
-			await db.run(sql`drop table if exists users`);
-			await db.run(sql`drop table if exists posts`);
-			await db.$cache?.invalidate({ tables: 'users' });
-			await dbGlobalCached.$cache?.invalidate({ tables: 'users' });
+		test.beforeEach(async ({ caches }) => {
+			const { explicit, all } = caches;
+			await explicit.run(sql`drop table if exists users`);
+			await explicit.run(sql`drop table if exists posts`);
+			await explicit.$cache?.invalidate({ tables: 'users' });
+			await all.$cache?.invalidate({ tables: 'users' });
 			// public users
-			await db.run(
+			await explicit.run(
 				sql`
 					create table users (
 						id integer primary key AUTOINCREMENT,
@@ -120,7 +40,7 @@ export function tests() {
 					)
 				`,
 			);
-			await db.run(
+			await explicit.run(
 				sql`
 					create table posts (
 						id integer primary key AUTOINCREMENT,
@@ -131,23 +51,23 @@ export function tests() {
 			);
 		});
 
-		test('test force invalidate', async (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('test force invalidate', async ({ caches }) => {
+			const { explicit: db } = caches;
 
-			const spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'invalidate');
 			await db.$cache?.invalidate({ tables: 'users' });
 			expect(spyInvalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('default global config - no cache should be hit', async (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('default global config - no cache should be hit', async ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable);
 
@@ -156,15 +76,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('default global config + enable cache on select: get, put', async (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('default global config + enable cache on select: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache();
 
@@ -173,15 +93,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('default global config + enable cache on select + write: get, put, onMutate', async (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('default global config + enable cache on select + write: get, put, onMutate', async ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache({ config: { ex: 1 } });
 
@@ -200,15 +120,61 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('default global config + enable cache on select + disable invalidate: get, put', async (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('write + query all methods & verify data intergrity', async ({ caches }) => {
+			const { explicit: db } = caches;
+
+			// @ts-expect-error
+			using spyPut = vi.spyOn(db.$cache, 'put');
+			// @ts-expect-error
+			using spyGet = vi.spyOn(db.$cache, 'get');
+			// @ts-expect-error
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+
+			await db.insert(usersTable).values({ name: 'John' });
+
+			expect(spyPut).toHaveBeenCalledTimes(0);
+			expect(spyGet).toHaveBeenCalledTimes(0);
+			expect(spyInvalidate).toHaveBeenCalledTimes(1);
+
+			spyPut.mockClear();
+			spyGet.mockClear();
+			spyInvalidate.mockClear();
+
+			const qRaw = db.select().from(usersTable).prepare();
+			const qCache = db.select().from(usersTable).$withCache({ config: { ex: 120 } }).prepare();
+
+			const [_all, _get, _run, _values] = [
+				await qRaw.all(),
+				await qRaw.get(),
+				await qRaw.run(),
+				await qRaw.values(),
+			];
+			const [all, get, run, values] = [
+				await qCache.all(),
+				await qCache.get(),
+				await qCache.run(),
+				await qCache.values(),
+			];
+
+			expect(spyPut).toHaveBeenCalledTimes(4);
+			expect(spyGet).toHaveBeenCalledTimes(4);
+			expect(spyInvalidate).toHaveBeenCalledTimes(0);
+
+			expect(all).toStrictEqual(_all);
+			expect(get).toStrictEqual(_get);
+			expect(run).toStrictEqual(_run);
+			expect(values).toStrictEqual(_values);
+		});
+
+		test('default global config + enable cache on select + disable invalidate: get, put', async ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false, config: { ex: 1 } });
 
@@ -222,15 +188,15 @@ export function tests() {
 			await db.$cache?.invalidate({ tags: ['custom'] });
 		});
 
-		test('global: true + disable cache', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSqlite;
+		test('global: true + disable cache', async ({ caches }) => {
+			const { all: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache(false);
 
@@ -239,15 +205,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - cache should be hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSqlite;
+		test('global: true - cache should be hit', async ({ caches }) => {
+			const { all: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable);
 
@@ -256,15 +222,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - cache: false on select - no cache hit', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSqlite;
+		test('global: true - cache: false on select - no cache hit', async ({ caches }) => {
+			const { all: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache(false);
 
@@ -273,15 +239,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(0);
 		});
 
-		test('global: true - disable invalidate - cache hit + no invalidate', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSqlite;
+		test('global: true - disable invalidate - cache hit + no invalidate', async ({ caches }) => {
+			const { all: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache({ autoInvalidate: false });
 
@@ -300,15 +266,15 @@ export function tests() {
 			expect(spyInvalidate).toHaveBeenCalledTimes(1);
 		});
 
-		test('global: true - with custom tag', async (ctx) => {
-			const { dbGlobalCached: db } = ctx.cachedSqlite;
+		test('global: true - with custom tag', async ({ caches }) => {
+			const { all: db } = caches;
 
 			// @ts-expect-error
-			const spyPut = vi.spyOn(db.$cache, 'put');
+			using spyPut = vi.spyOn(db.$cache, 'put');
 			// @ts-expect-error
-			const spyGet = vi.spyOn(db.$cache, 'get');
+			using spyGet = vi.spyOn(db.$cache, 'get');
 			// @ts-expect-error
-			const spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
+			using spyInvalidate = vi.spyOn(db.$cache, 'onMutate');
 
 			await db.select().from(usersTable).$withCache({ tag: 'custom', autoInvalidate: false });
 
@@ -323,8 +289,8 @@ export function tests() {
 		});
 
 		// check select used tables
-		test('check simple select used tables', (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('check simple select used tables', ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
 			expect(db.select().from(usersTable).getUsedTables()).toStrictEqual(['users']);
@@ -332,8 +298,8 @@ export function tests() {
 			expect(db.select().from(sql`${usersTable}`).getUsedTables()).toStrictEqual(['users']);
 		});
 		// check select+join used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
 
 			// @ts-expect-error
 			expect(db.select().from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.userId)).getUsedTables())
@@ -344,8 +310,8 @@ export function tests() {
 			).toStrictEqual(['users', 'posts']);
 		});
 		// check select+2join used tables
-		test('select+2joins', (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('select+2joins', ({ caches }) => {
+			const { explicit: db } = caches;
 
 			expect(
 				db.select().from(usersTable).leftJoin(
@@ -368,8 +334,8 @@ export function tests() {
 			).toStrictEqual(['users', 'posts']);
 		});
 		// select subquery used tables
-		test('select+join', (ctx) => {
-			const { db } = ctx.cachedSqlite;
+		test('select+join', ({ caches }) => {
+			const { explicit: db } = caches;
 
 			const sq = db.select().from(usersTable).where(eq(usersTable.id, 42)).as('sq');
 
diff --git a/integration-tests/tests/sqlite/sqlite-common.ts b/integration-tests/tests/sqlite/sqlite-common.ts
index 3af9c64b4d..fcd2efe224 100644
--- a/integration-tests/tests/sqlite/sqlite-common.ts
+++ b/integration-tests/tests/sqlite/sqlite-common.ts
@@ -5,13 +5,20 @@ import {
 	avgDistinct,
 	count,
 	countDistinct,
+	DrizzleQueryError,
 	eq,
 	exists,
+	getColumns,
 	getTableColumns,
 	gt,
 	gte,
 	inArray,
+	isNull,
 	lt,
+	makeDefaultQueryMapper,
+	makeDefaultRqbMapper,
+	makeJitQueryMapper,
+	makeJitRqbMapper,
 	max,
 	min,
 	Name,
@@ -23,8 +30,8 @@ import {
 } from 'drizzle-orm';
 import {
 	alias,
-	type BaseSQLiteDatabase,
 	blob,
+	customType,
 	except,
 	foreignKey,
 	getTableConfig,
@@ -36,6 +43,8 @@ import {
 	numeric,
 	primaryKey,
 	real,
+	type SQLiteAsyncDatabase,
+	SQLiteDialect,
 	sqliteTable,
 	sqliteTableCreator,
 	sqliteView,
@@ -45,17 +54,11 @@ import {
 	unique,
 	uniqueKeyName,
 } from 'drizzle-orm/sqlite-core';
-import { beforeEach, describe, expect, expectTypeOf, test } from 'vitest';
+import { describe, expect, expectTypeOf } from 'vitest';
 import type { Equal } from '~/utils';
 import { Expect } from '~/utils';
-
-declare module 'vitest' {
-	interface TestContext {
-		sqlite: {
-			db: BaseSQLiteDatabase<'async' | 'sync', any, Record<string, never>>;
-		};
-	}
-}
+import { Test } from './instrumentation';
+import { clear, init, rqbPost, rqbUser } from './schema';
 
 const allTypesTable = sqliteTable('all_types', {
 	int: integer('int', {
@@ -100,15 +103,23 @@ export const usersTable = sqliteTable('users', {
 	name: text('name').notNull(),
 	verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
 	json: blob('json', { mode: 'json' }).$type<string[]>(),
-	createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`strftime('%s', 'now')`),
+	createdAt: integer('created_at', { mode: 'timestamp' })
+		.notNull()
+		.default(sql`strftime('%s', 'now')`),
 });
 
 export const usersOnUpdate = sqliteTable('users_on_update', {
 	id: integer('id').primaryKey({ autoIncrement: true }),
 	name: text('name').notNull(),
-	updateCounter: integer('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
-	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).$onUpdate(() => new Date()),
-	alwaysNull: text('always_null').$type<string | null>().$onUpdate(() => null),
+	updateCounter: integer('update_counter')
+		.default(sql`1`)
+		.$onUpdateFn(() => sql`update_counter + 1`),
+	updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).$onUpdate(
+		() => new Date(),
+	),
+	alwaysNull: text('always_null')
+		.$type<string | null>()
+		.$onUpdate(() => null),
 	// uppercaseName: text('uppercase_name').$onUpdateFn(() =>
 	// 	sql`upper(s.name)`
 	// ),  This doesn't seem to be supported in sqlite
@@ -139,7 +150,9 @@ const courseCategoriesTable = sqliteTable('course_categories', {
 const orders = sqliteTable('orders', {
 	id: integer('id').primaryKey(),
 	region: text('region').notNull(),
-	product: text('product').notNull().$default(() => 'random_string'),
+	product: text('product')
+		.notNull()
+		.$default(() => 'random_string'),
 	amount: integer('amount').notNull(),
 	quantity: integer('quantity').notNull(),
 });
@@ -156,21 +169,25 @@ export const anotherUsersMigratorTable = sqliteTable('another_users', {
 	email: text('email').notNull(),
 });
 
-const pkExampleTable = sqliteTable('pk_example', {
-	id: integer('id').notNull(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-}, (table) => ({
-	compositePk: primaryKey({ columns: [table.id, table.name] }),
-}));
-
-const conflictChainExampleTable = sqliteTable('conflict_chain_example', {
-	id: integer('id').notNull().unique(),
-	name: text('name').notNull(),
-	email: text('email').notNull(),
-}, (table) => ({
-	compositePk: primaryKey({ columns: [table.id, table.name] }),
-}));
+const pkExampleTable = sqliteTable(
+	'pk_example',
+	{
+		id: integer('id').notNull(),
+		name: text('name').notNull(),
+		email: text('email').notNull(),
+	},
+	(table) => [primaryKey({ columns: [table.id, table.name] })],
+);
+
+const conflictChainExampleTable = sqliteTable(
+	'conflict_chain_example',
+	{
+		id: integer('id').notNull().unique(),
+		name: text('name').notNull(),
+		email: text('email').notNull(),
+	},
+	(table) => [primaryKey({ columns: [table.id, table.name] })],
+);
 
 const bigIntExample = sqliteTable('big_int_example', {
 	id: integer('id').primaryKey(),
@@ -188,11 +205,13 @@ const aggregateTable = sqliteTable('aggregate_table', {
 	nullOnly: integer('null_only'),
 });
 
-export function tests() {
-	describe('common', () => {
-		beforeEach(async (ctx) => {
-			const { db } = ctx.sqlite;
+export function tests(test: Test, exclude: string[] = []) {
+	test.beforeEach(({ task, skip }) => {
+		if (exclude.includes(task.name)) skip();
+	});
 
+	describe('common', () => {
+		test.beforeEach(async ({ db }) => {
 			await db.run(sql`drop table if exists ${usersTable}`);
 			await db.run(sql`drop table if exists ${users2Table}`);
 			await db.run(sql`drop table if exists ${citiesTable}`);
@@ -206,6 +225,7 @@ export function tests() {
 			await db.run(sql`drop table if exists user_notifications_insert_into`);
 			await db.run(sql`drop table if exists users_insert_into`);
 			await db.run(sql`drop table if exists notifications_insert_into`);
+			await db.run(sql`drop table if exists table1`);
 
 			await db.run(sql`
 				create table ${usersTable} (
@@ -278,7 +298,9 @@ export function tests() {
 			`);
 		});
 
-		async function setupSetOperationTest(db: BaseSQLiteDatabase<any, any>) {
+		async function setupSetOperationTest(
+			db: SQLiteAsyncDatabase<any, any, any>,
+		) {
 			await db.run(sql`drop table if exists users2`);
 			await db.run(sql`drop table if exists cities`);
 			await db.run(sql`
@@ -314,7 +336,9 @@ export function tests() {
 			]);
 		}
 
-		async function setupAggregateFunctionsTest(db: BaseSQLiteDatabase<any, any>) {
+		async function setupAggregateFunctionsTest(
+			db: SQLiteAsyncDatabase<any, any, any>,
+		) {
 			await db.run(sql`drop table if exists "aggregate_table"`);
 			await db.run(
 				sql`
@@ -339,31 +363,47 @@ export function tests() {
 			]);
 		}
 
-		test('table config: foreign keys name', async () => {
-			const table = sqliteTable('cities', {
-				id: int('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
-				f1: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk_deprecated' }),
-			}));
+		test.concurrent('table config: foreign keys name', async () => {
+			const table = sqliteTable(
+				'cities',
+				{
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+					state: text('state'),
+				},
+				(t) => [
+					foreignKey({
+						foreignColumns: [t.id],
+						columns: [t.id],
+						name: 'custom_fk',
+					}),
+					foreignKey({
+						foreignColumns: [t.id],
+						columns: [t.id],
+						name: 'custom_fk_deprecated',
+					}),
+				],
+			);
 
 			const tableConfig = getTableConfig(table);
 
 			expect(tableConfig.foreignKeys).toHaveLength(2);
 			expect(tableConfig.foreignKeys[0]!.getName()).toBe('custom_fk');
-			expect(tableConfig.foreignKeys[1]!.getName()).toBe('custom_fk_deprecated');
+			expect(tableConfig.foreignKeys[1]!.getName()).toBe(
+				'custom_fk_deprecated',
+			);
 		});
 
-		test('table config: primary keys name', async () => {
-			const table = sqliteTable('cities', {
-				id: int('id').primaryKey(),
-				name: text('name').notNull(),
-				state: text('state'),
-			}, (t) => ({
-				f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
-			}));
+		test.concurrent('table config: primary keys name', async () => {
+			const table = sqliteTable(
+				'cities',
+				{
+					id: int('id').primaryKey(),
+					name: text('name').notNull(),
+					state: text('state'),
+				},
+				(t) => [primaryKey({ columns: [t.id, t.name], name: 'custom_pk' })],
+			);
 
 			const tableConfig = getTableConfig(table);
 
@@ -371,14 +411,27 @@ export function tests() {
 			expect(tableConfig.primaryKeys[0]!.getName()).toBe('custom_pk');
 		});
 
-		test('insert bigint values', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(bigIntExample).values({ name: 'one', bigInt: BigInt('0') }).run();
-			await db.insert(bigIntExample).values({ name: 'two', bigInt: BigInt('127') }).run();
-			await db.insert(bigIntExample).values({ name: 'three', bigInt: BigInt('32767') }).run();
-			await db.insert(bigIntExample).values({ name: 'four', bigInt: BigInt('1234567890') }).run();
-			await db.insert(bigIntExample).values({ name: 'five', bigInt: BigInt('12345678900987654321') }).run();
+		test.concurrent('insert bigint values', async ({ db }) => {
+			await db
+				.insert(bigIntExample)
+				.values({ name: 'one', bigInt: BigInt('0') })
+				.run();
+			await db
+				.insert(bigIntExample)
+				.values({ name: 'two', bigInt: BigInt('127') })
+				.run();
+			await db
+				.insert(bigIntExample)
+				.values({ name: 'three', bigInt: BigInt('32767') })
+				.run();
+			await db
+				.insert(bigIntExample)
+				.values({ name: 'four', bigInt: BigInt('1234567890') })
+				.run();
+			await db
+				.insert(bigIntExample)
+				.values({ name: 'five', bigInt: BigInt('12345678900987654321') })
+				.run();
 
 			const result = await db.select().from(bigIntExample).all();
 			expect(result).toEqual([
@@ -390,53 +443,62 @@ export function tests() {
 			]);
 		});
 
-		test('select all fields', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select all fields', async ({ db }) => {
 			const now = Date.now();
 
 			await db.insert(usersTable).values({ name: 'John' }).run();
 			const result = await db.select().from(usersTable).all();
 			expect(result[0]!.createdAt).toBeInstanceOf(Date);
 			expect(Math.abs(result[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, json: null, createdAt: result[0]!.createdAt }]);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					json: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
 		});
 
-		test('select partial', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select partial', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const result = await db.select({ name: usersTable.name }).from(usersTable).all();
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([{ name: 'John' }]);
 		});
 
-		test('select sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select sql', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.select({
-				name: sql`upper(${usersTable.name})`,
-			}).from(usersTable).all();
+			const users = await db
+				.select({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.all();
 
 			expect(users).toEqual([{ name: 'JOHN' }]);
 		});
 
-		test('select typed sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select typed sql', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.select({
-				name: sql<string>`upper(${usersTable.name})`,
-			}).from(usersTable).all();
+			const users = await db
+				.select({
+					name: sql<string>`upper(${usersTable.name})`,
+				})
+				.from(usersTable)
+				.all();
 
 			expect(users).toEqual([{ name: 'JOHN' }]);
 		});
 
-		test('select with empty array in inArray', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		test.concurrent('select with empty array in inArray', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 			const result = await db
 				.select({
 					name: sql`upper(${usersTable.name})`,
@@ -447,10 +509,10 @@ export function tests() {
 			expect(result).toEqual([]);
 		});
 
-		test('select with empty array in notInArray', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+		test.concurrent('select with empty array in notInArray', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
 			const result = await db
 				.select({
 					name: sql`upper(${usersTable.name})`,
@@ -458,85 +520,130 @@ export function tests() {
 				.from(usersTable)
 				.where(notInArray(usersTable.id, []));
 
-			expect(result).toEqual([{ name: 'JOHN' }, { name: 'JANE' }, { name: 'JANE' }]);
+			expect(result).toEqual([
+				{ name: 'JOHN' },
+				{ name: 'JANE' },
+				{ name: 'JANE' },
+			]);
 		});
 
-		test('select distinct', async (ctx) => {
-			const { db } = ctx.sqlite;
+		// https://github.com/drizzle-team/drizzle-orm/issues/4878
+		test.concurrent('.where with isNull in it', async ({ db, push }) => {
+			const table = sqliteTable('table_where_is_null', {
+				col1: int({ mode: 'boolean' }),
+				col2: text(),
+			});
+
+			await db.run(sql`DROP TABLE IF EXISTS ${table}`);
+			await db.run(sql`CREATE TABLE ${table} (
+				col1 int,
+				col2 text
+			);`);
+			await db
+				.insert(table)
+				.values([{ col1: true }, { col1: false, col2: 'qwerty' }]);
+
+			const query = db
+				.select()
+				.from(table)
+				.where(eq(table.col1, isNull(table.col2)));
+			expect(query.toSQL()).toStrictEqual({
+				sql:
+					'select "col1", "col2" from "table_where_is_null" where "table_where_is_null"."col1" = ("table_where_is_null"."col2" is null)',
+				params: [],
+			});
+			const res = await query;
+			expect(res).toStrictEqual([
+				{ col1: true, col2: null },
+				{ col1: false, col2: 'qwerty' },
+			]);
+		});
 
+		test.concurrent('select distinct', async ({ db }) => {
 			const usersDistinctTable = sqliteTable('users_distinct', {
 				id: integer('id').notNull(),
 				name: text('name').notNull(),
 			});
 
 			await db.run(sql`drop table if exists ${usersDistinctTable}`);
-			await db.run(sql`create table ${usersDistinctTable} (id integer, name text)`);
+			await db.run(
+				sql`create table ${usersDistinctTable} (id integer, name text)`,
+			);
 
-			await db.insert(usersDistinctTable).values([
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'John' },
-				{ id: 1, name: 'Jane' },
-			]).run();
-			const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
-				usersDistinctTable.id,
-				usersDistinctTable.name,
-			).all();
+			await db
+				.insert(usersDistinctTable)
+				.values([
+					{ id: 1, name: 'John' },
+					{ id: 1, name: 'John' },
+					{ id: 2, name: 'John' },
+					{ id: 1, name: 'Jane' },
+				])
+				.run();
+			const users = await db
+				.selectDistinct()
+				.from(usersDistinctTable)
+				.orderBy(usersDistinctTable.id, usersDistinctTable.name)
+				.all();
 
 			await db.run(sql`drop table ${usersDistinctTable}`);
 
-			expect(users).toEqual([{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+			expect(users).toEqual([
+				{ id: 1, name: 'Jane' },
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'John' },
+			]);
 		});
 
-		test('insert returning sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const users = await db.insert(usersTable).values({ name: 'John' }).returning({
-				name: sql`upper(${usersTable.name})`,
-			}).all();
+		test.concurrent('insert returning sql', async ({ db }) => {
+			const users = await db
+				.insert(usersTable)
+				.values({ name: 'John' })
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
 
 			expect(users).toEqual([{ name: 'JOHN' }]);
 		});
 
-		test('$default function', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+		test.concurrent('$default function', async ({ db }) => {
+			await db
+				.insert(orders)
+				.values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
 			const selectedOrder = await db.select().from(orders);
 
-			expect(selectedOrder).toEqual([{
-				id: 1,
-				amount: 1,
-				quantity: 1,
-				region: 'Ukraine',
-				product: 'random_string',
-			}]);
+			expect(selectedOrder).toEqual([
+				{
+					id: 1,
+					amount: 1,
+					quantity: 1,
+					region: 'Ukraine',
+					product: 'random_string',
+				},
+			]);
 		});
 
-		test('delete returning sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('delete returning sql', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-				name: sql`upper(${usersTable.name})`,
-			}).all();
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
 
 			expect(users).toEqual([{ name: 'JOHN' }]);
 		});
 
-		test('query check: insert single empty row', (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('query check: insert single empty row', async ({ db }) => {
 			const users = sqliteTable('users', {
 				id: integer('id').primaryKey(),
 				name: text('name').default('Dan'),
 				state: text('state'),
 			});
 
-			const query = db
-				.insert(users)
-				.values({})
-				.toSQL();
+			const query = db.insert(users).values({}).toSQL();
 
 			expect(query).toEqual({
 				sql: 'insert into "users" ("id", "name", "state") values (null, ?, null)',
@@ -544,29 +651,25 @@ export function tests() {
 			});
 		});
 
-		test('query check: insert multiple empty rows', (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const users = sqliteTable('users', {
-				id: integer('id').primaryKey(),
-				name: text('name').default('Dan'),
-				state: text('state'),
-			});
-
-			const query = db
-				.insert(users)
-				.values([{}, {}])
-				.toSQL();
+		test.concurrent(
+			'query check: insert multiple empty rows',
+			async ({ db }) => {
+				const users = sqliteTable('users', {
+					id: integer('id').primaryKey(),
+					name: text('name').default('Dan'),
+					state: text('state'),
+				});
 
-			expect(query).toEqual({
-				sql: 'insert into "users" ("id", "name", "state") values (null, ?, null), (null, ?, null)',
-				params: ['Dan', 'Dan'],
-			});
-		});
+				const query = db.insert(users).values([{}, {}]).toSQL();
 
-		test('Insert all defaults in 1 row', async (ctx) => {
-			const { db } = ctx.sqlite;
+				expect(query).toEqual({
+					sql: 'insert into "users" ("id", "name", "state") values (null, ?, null), (null, ?, null)',
+					params: ['Dan', 'Dan'],
+				});
+			},
+		);
 
+		test.concurrent('Insert all defaults in 1 row', async ({ db }) => {
 			const users = sqliteTable('empty_insert_single', {
 				id: integer('id').primaryKey(),
 				name: text('name').default('Dan'),
@@ -586,9 +689,7 @@ export function tests() {
 			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }]);
 		});
 
-		test('Insert all defaults in multiple rows', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('Insert all defaults in multiple rows', async ({ db }) => {
 			const users = sqliteTable('empty_insert_multiple', {
 				id: integer('id').primaryKey(),
 				name: text('name').default('Dan'),
@@ -605,30 +706,56 @@ export function tests() {
 
 			const res = await db.select().from(users).all();
 
-			expect(res).toEqual([{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+			expect(res).toEqual([
+				{ id: 1, name: 'Dan', state: null },
+				{ id: 2, name: 'Dan', state: null },
+			]);
 		});
 
-		test('update returning sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('update returning sql', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
-				name: sql`upper(${usersTable.name})`,
-			}).all();
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all();
 
 			expect(users).toEqual([{ name: 'JANE' }]);
 		});
 
-		test('insert with auto increment', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('update placeholder', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' }).run();
+			const users = await db
+				.update(usersTable)
+				.set({ name: sql.placeholder('name') })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					name: sql`upper(${usersTable.name})`,
+				})
+				.all({
+					name: 'Jane',
+				});
 
-			await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-				{ name: 'George' },
-				{ name: 'Austin' },
-			]).run();
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+			expect(users).toEqual([{ name: 'JANE' }]);
+		});
+
+		test.concurrent('insert with auto increment', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Jane' },
+					{ name: 'George' },
+					{ name: 'Austin' },
+				])
+				.run();
+			const result = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([
 				{ id: 1, name: 'John' },
@@ -638,117 +765,172 @@ export function tests() {
 			]);
 		});
 
-		test('insert with default values', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('insert with default values', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
 			const result = await db.select().from(usersTable).all();
 
-			expect(result).toEqual([{ id: 1, name: 'John', verified: false, json: null, createdAt: result[0]!.createdAt }]);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					json: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
 		});
 
-		test('insert with overridden default values', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values({ name: 'John', verified: true }).run();
+		test.concurrent('insert with overridden default values', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values({ name: 'John', verified: true })
+				.run();
 			const result = await db.select().from(usersTable).all();
 
-			expect(result).toEqual([{ id: 1, name: 'John', verified: true, json: null, createdAt: result[0]!.createdAt }]);
+			expect(result).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: true,
+					json: null,
+					createdAt: result[0]!.createdAt,
+				},
+			]);
 		});
 
-		test('update with returning all fields', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('update with returning all fields', async ({ db }) => {
 			const now = Date.now();
 
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning()
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning()
 				.all();
 
 			expect(users[0]!.createdAt).toBeInstanceOf(Date);
 			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
-			expect(users).toEqual([{ id: 1, name: 'Jane', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+			expect(users).toEqual([
+				{
+					id: 1,
+					name: 'Jane',
+					verified: false,
+					json: null,
+					createdAt: users[0]!.createdAt,
+				},
+			]);
 		});
 
-		test('update with returning partial', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('update with returning partial', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John')).returning({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).all();
+			const users = await db
+				.update(usersTable)
+				.set({ name: 'Jane' })
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.all();
 
 			expect(users).toEqual([{ id: 1, name: 'Jane' }]);
 		});
 
-		test('delete with returning all fields', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('delete with returning all fields', async ({ db }) => {
 			const now = Date.now();
 
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning().all();
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning()
+				.all();
 
 			expect(users[0]!.createdAt).toBeInstanceOf(Date);
 			expect(Math.abs(users[0]!.createdAt.getTime() - now)).toBeLessThan(5000);
-			expect(users).toEqual([{ id: 1, name: 'John', verified: false, json: null, createdAt: users[0]!.createdAt }]);
+			expect(users).toEqual([
+				{
+					id: 1,
+					name: 'John',
+					verified: false,
+					json: null,
+					createdAt: users[0]!.createdAt,
+				},
+			]);
 		});
 
-		test('delete with returning partial', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('delete with returning partial', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).all();
+			const users = await db
+				.delete(usersTable)
+				.where(eq(usersTable.name, 'John'))
+				.returning({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.all();
 
 			expect(users).toEqual([{ id: 1, name: 'John' }]);
 		});
 
-		test('insert + select', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('insert + select', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+			const result = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([{ id: 1, name: 'John' }]);
 
 			await db.insert(usersTable).values({ name: 'Jane' }).run();
-			const result2 = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+			const result2 = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.all();
 
-			expect(result2).toEqual([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
+			expect(result2).toEqual([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
 		});
 
-		test('json insert', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values({ name: 'John', json: ['foo', 'bar'] }).run();
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				json: usersTable.json,
-			}).from(usersTable).all();
+		test.concurrent('json insert', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values({ name: 'John', json: ['foo', 'bar'] })
+				.run();
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					json: usersTable.json,
+				})
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([{ id: 1, name: 'John', json: ['foo', 'bar'] }]);
 		});
 
-		test('insert many', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', json: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			]).run();
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-				json: usersTable.json,
-				verified: usersTable.verified,
-			}).from(usersTable).all();
+		test.concurrent('insert many', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', json: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				])
+				.run();
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+					json: usersTable.json,
+					verified: usersTable.verified,
+				})
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([
 				{ id: 1, name: 'John', json: null, verified: false },
@@ -758,15 +940,15 @@ export function tests() {
 			]);
 		});
 
-		test('insert many with returning', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const result = await db.insert(usersTable).values([
-				{ name: 'John' },
-				{ name: 'Bruce', json: ['foo', 'bar'] },
-				{ name: 'Jane' },
-				{ name: 'Austin', verified: true },
-			])
+		test.concurrent('insert many with returning', async ({ db }) => {
+			const result = await db
+				.insert(usersTable)
+				.values([
+					{ name: 'John' },
+					{ name: 'Bruce', json: ['foo', 'bar'] },
+					{ name: 'Jane' },
+					{ name: 'Austin', verified: true },
+				])
 				.returning({
 					id: usersTable.id,
 					name: usersTable.name,
@@ -783,11 +965,13 @@ export function tests() {
 			]);
 		});
 
-		test('partial join with alias', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('partial join with alias', async ({ db }) => {
 			const customerAlias = alias(usersTable, 'customer');
 
-			await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+			await db.insert(usersTable).values([
+				{ id: 10, name: 'Ivan' },
+				{ id: 11, name: 'Hans' },
+			]);
 
 			const result = await db
 				.select({
@@ -799,19 +983,20 @@ export function tests() {
 						id: customerAlias.id,
 						name: customerAlias.name,
 					},
-				}).from(usersTable)
+				})
+				.from(usersTable)
 				.leftJoin(customerAlias, eq(customerAlias.id, 11))
 				.where(eq(usersTable.id, 10));
 
-			expect(result).toEqual([{
-				user: { id: 10, name: 'Ivan' },
-				customer: { id: 11, name: 'Hans' },
-			}]);
+			expect(result).toEqual([
+				{
+					user: { id: 10, name: 'Ivan' },
+					customer: { id: 11, name: 'Hans' },
+				},
+			]);
 		});
 
-		test('full join with alias', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('full join with alias', async ({ db }) => {
 			const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
 
 			const users = sqliteTable('users', {
@@ -820,34 +1005,97 @@ export function tests() {
 			});
 
 			await db.run(sql`drop table if exists ${users}`);
-			await db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+			await db.run(
+				sql`create table ${users} (id integer primary key, name text not null)`,
+			);
 
 			const customers = alias(users, 'customer');
 
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]).run();
+			await db
+				.insert(users)
+				.values([
+					{ id: 10, name: 'Ivan' },
+					{ id: 11, name: 'Hans' },
+				])
+				.run();
 			const result = await db
-				.select().from(users)
+				.select()
+				.from(users)
 				.leftJoin(customers, eq(customers.id, 11))
 				.where(eq(users.id, 10))
 				.all();
 
-			expect(result).toEqual([{
-				users: {
+			expect(result).toEqual([
+				{
+					users: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
+				},
+			]);
+
+			await db.run(sql`drop table ${users}`);
+		});
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/4389
+		test('inner join', async ({ db }) => {
+			const teams = sqliteTable('teams_1', {
+				id: integer().primaryKey(),
+			});
+			const users = sqliteTable('users_1', {
+				id: integer().primaryKey(),
+				name: text().notNull(),
+				teamId: integer('team_id').references(() => teams.id),
+			});
+
+			await db.run(sql`drop table if exists ${users}`);
+			await db.run(
+				sql`create table ${users} (id integer primary key, name text not null, team_id integer, FOREIGN KEY (team_id) REFERENCES ${teams}(id));`,
+			);
+
+			await db.run(sql`drop table if exists ${teams}`);
+			await db.run(sql`create table ${teams} (id integer primary key);`);
+
+			await db
+				.insert(teams)
+				.values([{ id: 1 }, { id: 2 }])
+				.run();
+			await db
+				.insert(users)
+				.values([
+					{ id: 10, name: 'Ivan', teamId: 1 },
+					{ id: 11, name: 'Hans', teamId: 2 },
+				])
+				.run();
+			const query = db
+				.select({ id: users.id, name: users.name, team_id: teams.id })
+				.from(users)
+				.innerJoin(teams, eq(teams.id, users.teamId));
+
+			const result = await query.all();
+
+			expect(result).toEqual([
+				{
 					id: 10,
 					name: 'Ivan',
+					team_id: 1,
 				},
-				customer: {
+				{
 					id: 11,
 					name: 'Hans',
+					team_id: 2,
 				},
-			}]);
+			]);
 
 			await db.run(sql`drop table ${users}`);
+			await db.run(sql`drop table ${teams}`);
 		});
 
-		test('select from alias', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select from alias', async ({ db }) => {
 			const sqliteTable = sqliteTableCreator((name) => `prefixed_${name}`);
 
 			const users = sqliteTable('users', {
@@ -856,12 +1104,20 @@ export function tests() {
 			});
 
 			await db.run(sql`drop table if exists ${users}`);
-			await db.run(sql`create table ${users} (id integer primary key, name text not null)`);
+			await db.run(
+				sql`create table ${users} (id integer primary key, name text not null)`,
+			);
 
 			const user = alias(users, 'user');
 			const customers = alias(users, 'customer');
 
-			await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]).run();
+			await db
+				.insert(users)
+				.values([
+					{ id: 10, name: 'Ivan' },
+					{ id: 11, name: 'Hans' },
+				])
+				.run();
 			const result = await db
 				.select()
 				.from(user)
@@ -869,52 +1125,63 @@ export function tests() {
 				.where(eq(user.id, 10))
 				.all();
 
-			expect(result).toEqual([{
-				user: {
-					id: 10,
-					name: 'Ivan',
-				},
-				customer: {
-					id: 11,
-					name: 'Hans',
+			expect(result).toEqual([
+				{
+					user: {
+						id: 10,
+						name: 'Ivan',
+					},
+					customer: {
+						id: 11,
+						name: 'Hans',
+					},
 				},
-			}]);
+			]);
 
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('insert with spaces', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values({ name: sql`'Jo   h     n'` }).run();
-			const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).all();
+		test.concurrent('insert with spaces', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values({ name: sql`'Jo   h     n'` })
+				.run();
+			const result = await db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([{ id: 1, name: 'Jo   h     n' }]);
 		});
 
-		test('prepared statement', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('prepared statement', async ({ db }) => {
 			await db.insert(usersTable).values({ name: 'John' }).run();
-			const statement = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).prepare();
+			const statement = db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
+				.prepare();
 			const result = await statement.all();
 
 			expect(result).toEqual([{ id: 1, name: 'John' }]);
 		});
 
-		test('prepared statement reuse', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const stmt = db.insert(usersTable).values({ name: sql.placeholder('name') }).prepare();
+		test.concurrent('prepared statement reuse', async ({ db }) => {
+			const stmt = db
+				.insert(usersTable)
+				.values({ name: sql.placeholder('name') })
+				.prepare();
 
 			for (let i = 0; i < 10; i++) {
 				await stmt.run({ name: `John ${i}` });
 			}
 
-			const result = await db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable).all();
+			const result = await db
+				.select({
+					id: usersTable.id,
+					name: usersTable.name,
+				})
+				.from(usersTable)
+				.all();
 
 			expect(result).toEqual([
 				{ id: 1, name: 'John 0' },
@@ -930,174 +1197,348 @@ export function tests() {
 			]);
 		});
 
-		test('insert: placeholders on columns with encoder', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'insert: placeholders on columns with encoder',
+			async ({ db }) => {
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						name: 'John',
+						verified: sql.placeholder('verified'),
+					})
+					.prepare();
 
-			const stmt = db.insert(usersTable).values({
-				name: 'John',
-				verified: sql.placeholder('verified'),
-			}).prepare();
+				await stmt.run({ verified: true });
+				await stmt.run({ verified: false });
 
-			await stmt.run({ verified: true });
-			await stmt.run({ verified: false });
+				const result = await db
+					.select({
+						id: usersTable.id,
+						verified: usersTable.verified,
+					})
+					.from(usersTable)
+					.all();
 
-			const result = await db.select({
-				id: usersTable.id,
-				verified: usersTable.verified,
-			}).from(usersTable).all();
+				expect(result).toEqual([
+					{ id: 1, verified: true },
+					{ id: 2, verified: false },
+				]);
+			},
+		);
 
-			expect(result).toEqual([
-				{ id: 1, verified: true },
-				{ id: 2, verified: false },
-			]);
-		});
+		// https://github.com/drizzle-team/drizzle-orm/issues/976
+		test.concurrent(
+			'insert; prepared statement with placeholder in .values',
+			async ({ db, push }) => {
+				const textArray = customType({
+					dataType() {
+						return 'text';
+					},
+					fromDriver(value) {
+						return JSON.parse(value as string);
+					},
+					toDriver(value) {
+						return JSON.stringify(value);
+					},
+				});
 
-		test('prepared statement with placeholder in .where', async (ctx) => {
-			const { db } = ctx.sqlite;
+				const schema = {
+					table1: sqliteTable('table1', {
+						list: textArray('list'),
+						col2: blob({ mode: 'json' }),
+						col3: blob({ mode: 'bigint' }),
+						col4: integer({ mode: 'timestamp' }),
+						col5: integer({ mode: 'timestamp_ms' }),
+					}),
+				};
+
+				await push(schema);
+
+				const stmt = db
+					.insert(schema.table1)
+					.values({
+						list: sql.placeholder('list'),
+						col2: sql.placeholder('col2'),
+						col3: sql.placeholder('col3'),
+						col4: sql.placeholder('col4'),
+						col5: sql.placeholder('col5'),
+					})
+					.prepare();
+
+				const date1 = new Date('2026-02-06T18:42:21');
+				const date2 = new Date('2026-02-06T18:42:21.123');
+				await stmt.run({
+					list: ['a', 'b'],
+					col2: { a: 1 },
+					col3: 123n,
+					col4: date1,
+					col5: date2,
+				});
+				const result = await db.select().from(schema.table1).get();
+				expect(result).toStrictEqual({
+					list: ['a', 'b'],
+					col2: { a: 1 },
+					col3: 123n,
+					col4: date1,
+					col5: date2,
+				});
+			},
+		);
 
-			await db.insert(usersTable).values({ name: 'John' }).run();
-			const stmt = db.select({
-				id: usersTable.id,
-				name: usersTable.name,
-			}).from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.prepare();
-			const result = await stmt.all({ id: 1 });
+		// https://github.com/drizzle-team/drizzle-orm/issues/2872
+		test
+			.skipIf(Date.now() < +new Date('2026-07-01'))
+			.concurrent(
+				'prepared statement with placeholder in .inArray',
+				async ({ db, push }) => {
+					const table1 = sqliteTable('table1', {
+						name: text(),
+					});
 
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-		});
+					await push({ table1 });
 
-		test('prepared statement with placeholder in .limit', async (ctx) => {
-			const { db } = ctx.sqlite;
+					await db.insert(table1).values([{ name: 'John' }, { name: 'John1' }]);
 
-			await db.insert(usersTable).values({ name: 'John' }).run();
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.where(eq(usersTable.id, sql.placeholder('id')))
-				.limit(sql.placeholder('limit'))
-				.prepare();
+					const prepared = db
+						.select()
+						.from(table1)
+						.where(inArray(table1.name, sql.placeholder('names')))
+						.prepare();
+					const result = await prepared.execute({ names: ['John', 'John1'] });
+					expect(result).toStrictEqual([{ name: 'John' }, { name: 'John1' }]);
+				},
+			);
 
-			const result = await stmt.all({ id: 1, limit: 1 });
+		test.concurrent(
+			'prepared statement with placeholder in .where',
+			async ({ db }) => {
+				await db.insert(usersTable).values({ name: 'John' }).run();
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.prepare();
+				const result = await stmt.all({ id: 1 });
 
-			expect(result).toEqual([{ id: 1, name: 'John' }]);
-			expect(result).toHaveLength(1);
-		});
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+			},
+		);
 
-		test('prepared statement with placeholder in .offset', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'prepared statement with placeholder in .limit',
+			async ({ db }) => {
+				await db.insert(usersTable).values({ name: 'John' }).run();
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, sql.placeholder('id')))
+					.limit(sql.placeholder('limit'))
+					.prepare();
 
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).run();
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.limit(sql.placeholder('limit'))
-				.offset(sql.placeholder('offset'))
-				.prepare();
+				const result = await stmt.all({ id: 1, limit: 1 });
 
-			const result = await stmt.all({ limit: 1, offset: 1 });
+				expect(result).toEqual([{ id: 1, name: 'John' }]);
+				expect(result).toHaveLength(1);
+			},
+		);
 
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-		});
+		test.concurrent(
+			'prepared statement with placeholder in .offset',
+			async ({ db }) => {
+				await db
+					.insert(usersTable)
+					.values([{ name: 'John' }, { name: 'John1' }])
+					.run();
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.limit(sql.placeholder('limit'))
+					.offset(sql.placeholder('offset'))
+					.prepare();
 
-		test('prepared statement built using $dynamic', async (ctx) => {
-			const { db } = ctx.sqlite;
+				const result = await stmt.all({ limit: 1, offset: 1 });
 
-			function withLimitOffset(qb: any) {
-				return qb.limit(sql.placeholder('limit')).offset(sql.placeholder('offset'));
-			}
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+			},
+		);
 
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).run();
-			const stmt = db
-				.select({
-					id: usersTable.id,
-					name: usersTable.name,
-				})
-				.from(usersTable)
-				.$dynamic();
-			withLimitOffset(stmt).prepare('stmt_limit');
+		// https://github.com/drizzle-team/drizzle-orm/issues/5084
+		// it's needed to fix the type error below.
+		test.concurrent(
+			'prepared statement with placeholder in .onConflictDoUpdate',
+			async ({ db }) => {
+				await db
+					.insert(usersTable)
+					.values([{ id: 1, name: 'John' }])
+					.run();
+				const stmt = db
+					.insert(usersTable)
+					.values({
+						id: sql.placeholder('id'),
+						name: sql.placeholder('name'),
+					})
+					.onConflictDoUpdate({
+						target: usersTable.id,
+						set: {
+							id: sql.placeholder('id'),
+							name: sql.placeholder('name'),
+						},
+					})
+					.prepare();
 
-			const result = await stmt.all({ limit: 1, offset: 1 });
+				await stmt.run({ id: 1, name: 'John1' });
 
-			expect(result).toEqual([{ id: 2, name: 'John1' }]);
-			expect(result).toHaveLength(1);
-		});
+				const result = await db
+					.select({ id: usersTable.id, name: usersTable.name })
+					.from(usersTable)
+					.all();
+				expect(result).toEqual([{ id: 1, name: 'John1' }]);
+			},
+		);
+
+		test.concurrent(
+			'prepared statement built using $dynamic',
+			async ({ db }) => {
+				function withLimitOffset(qb: any) {
+					return qb
+						.limit(sql.placeholder('limit'))
+						.offset(sql.placeholder('offset'));
+				}
+
+				await db
+					.insert(usersTable)
+					.values([{ name: 'John' }, { name: 'John1' }])
+					.run();
+				const stmt = db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+					})
+					.from(usersTable)
+					.$dynamic();
+				withLimitOffset(stmt).prepare('stmt_limit');
 
-		test('select with group by as field', async (ctx) => {
-			const { db } = ctx.sqlite;
+				const result = await stmt.all({ limit: 1, offset: 1 });
 
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+				expect(result).toEqual([{ id: 2, name: 'John1' }]);
+				expect(result).toHaveLength(1);
+			},
+		);
+
+		test.concurrent('select with group by as field', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
 				.groupBy(usersTable.name)
 				.all();
 
 			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
 		});
 
-		test('select with exists', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+		test.concurrent('select with exists', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
 			const user = alias(usersTable, 'user');
-			const result = await db.select({ name: usersTable.name }).from(usersTable).where(
-				exists(
-					db.select({ one: sql`1` }).from(user).where(and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id))),
-				),
-			).all();
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
+				.where(
+					exists(
+						db
+							.select({ one: sql`1` })
+							.from(user)
+							.where(
+								and(eq(usersTable.name, 'John'), eq(user.id, usersTable.id)),
+							),
+					),
+				)
+				.all();
 
 			expect(result).toEqual([{ name: 'John' }]);
 		});
 
-		test('select with group by as sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+		test.concurrent('select with group by as sql', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
 				.groupBy(sql`${usersTable.name}`)
 				.all();
 
 			expect(result).toEqual([{ name: 'Jane' }, { name: 'John' }]);
 		});
 
-		test('select with group by as sql + column', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+		test.concurrent('select with group by as sql + column', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
 				.groupBy(sql`${usersTable.name}`, usersTable.id)
 				.all();
 
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			expect(result.length).toStrictEqual(3);
+			expect(result).toStrictEqual(
+				expect.arrayContaining([
+					{ name: 'John' },
+					{ name: 'Jane' },
+					{ name: 'Jane' },
+				]),
+			);
 		});
 
-		test('select with group by as column + sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+		test.concurrent('select with group by as column + sql', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
 				.groupBy(usersTable.id, sql`${usersTable.name}`)
 				.all();
 
-			expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+			expect(result).toEqual([
+				{ name: 'John' },
+				{ name: 'Jane' },
+				{ name: 'Jane' },
+			]);
 		});
 
-		test('select with group by complex query', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]).run();
+		test.concurrent('select with group by complex query', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }])
+				.run();
 
-			const result = await db.select({ name: usersTable.name }).from(usersTable)
+			const result = await db
+				.select({ name: usersTable.name })
+				.from(usersTable)
 				.groupBy(usersTable.id, sql`${usersTable.name}`)
 				.orderBy(asc(usersTable.name))
 				.limit(1)
@@ -1106,10 +1547,10 @@ export function tests() {
 			expect(result).toEqual([{ name: 'Jane' }]);
 		});
 
-		test('build query', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+		test.concurrent('build query', async ({ db }) => {
+			const query = db
+				.select({ id: usersTable.id, name: usersTable.name })
+				.from(usersTable)
 				.groupBy(usersTable.id, usersTable.name)
 				.toSQL();
 
@@ -1119,18 +1560,18 @@ export function tests() {
 			});
 		});
 
-		test('insert via db.run + select via db.all', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+		test.concurrent('insert via db.run + select via db.all', async ({ db }) => {
+			await db.run(
+				sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`,
+			);
 
-			const result = await db.all<{ id: number; name: string }>(sql`select id, name from "users"`);
+			const result = await db.all<{ id: number; name: string }>(
+				sql`select id, name from "users"`,
+			);
 			expect(result).toEqual([{ id: 1, name: 'John' }]);
 		});
 
-		test('insert via db.get', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('insert via db.get', async ({ db }) => {
 			const inserted = await db.get<{ id: number; name: string }>(
 				sql`insert into ${usersTable} (${new Name(
 					usersTable.name.name,
@@ -1139,10 +1580,10 @@ export function tests() {
 			expect(inserted).toEqual({ id: 1, name: 'John' });
 		});
 
-		test('insert via db.run + select via db.get', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+		test.concurrent('insert via db.run + select via db.get', async ({ db }) => {
+			await db.run(
+				sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`,
+			);
 
 			const result = await db.get<{ id: number; name: string }>(
 				sql`select ${usersTable.id}, ${usersTable.name} from ${usersTable}`,
@@ -1150,36 +1591,129 @@ export function tests() {
 			expect(result).toEqual({ id: 1, name: 'John' });
 		});
 
-		test('insert via db.get w/ query builder', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const inserted = await db.get<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
-				db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
+		test.concurrent('insert via db.get w/ query builder', async ({ db }) => {
+			const inserted = await db.get<
+				Pick<typeof usersTable.$inferSelect, 'id' | 'name'>
+			>(
+				db
+					.insert(usersTable)
+					.values({ name: 'John' })
+					.returning({ id: usersTable.id, name: usersTable.name }),
 			);
 			expect(inserted).toEqual({ id: 1, name: 'John' });
 		});
 
-		test('join subquery', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(courseCategoriesTable).values([
-				{ name: 'Category 1' },
-				{ name: 'Category 2' },
-				{ name: 'Category 3' },
-				{ name: 'Category 4' },
-			]).run();
+		test.concurrent('select from a many subquery', async ({ db }) => {
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
 
-			await db.insert(coursesTable).values([
-				{ name: 'Development', categoryId: 2 },
-				{ name: 'IT & Software', categoryId: 3 },
-				{ name: 'Marketing', categoryId: 4 },
-				{ name: 'Design', categoryId: 1 },
-			]).run();
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
 
-			const sq2 = db
+			const res = await db
 				.select({
-					categoryId: courseCategoriesTable.id,
-					category: courseCategoriesTable.name,
+					population: db
+						.select({ count: count().as('count') })
+						.from(users2Table)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('population'),
+					name: citiesTable.name,
+				})
+				.from(citiesTable);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					population: number;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					population: 1,
+					name: 'Paris',
+				},
+				{
+					population: 2,
+					name: 'London',
+				},
+			]);
+		});
+
+		test.concurrent('select from a one subquery', async ({ db }) => {
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'Paris' }, { name: 'London' }]);
+
+			await db.insert(users2Table).values([
+				{ name: 'John', cityId: 1 },
+				{ name: 'Jane', cityId: 2 },
+				{ name: 'Jack', cityId: 2 },
+			]);
+
+			const res = await db
+				.select({
+					cityName: db
+						.select({ name: citiesTable.name })
+						.from(citiesTable)
+						.where(eq(users2Table.cityId, citiesTable.id))
+						.as('cityName'),
+					name: users2Table.name,
+				})
+				.from(users2Table);
+
+			expectTypeOf(res).toEqualTypeOf<
+				{
+					cityName: string;
+					name: string;
+				}[]
+			>();
+
+			expect(res).toStrictEqual([
+				{
+					cityName: 'Paris',
+					name: 'John',
+				},
+				{
+					cityName: 'London',
+					name: 'Jane',
+				},
+				{
+					cityName: 'London',
+					name: 'Jack',
+				},
+			]);
+		});
+
+		test.concurrent('join subquery', async ({ db }) => {
+			await db
+				.insert(courseCategoriesTable)
+				.values([
+					{ name: 'Category 1' },
+					{ name: 'Category 2' },
+					{ name: 'Category 3' },
+					{ name: 'Category 4' },
+				])
+				.run();
+
+			await db
+				.insert(coursesTable)
+				.values([
+					{ name: 'Development', categoryId: 2 },
+					{ name: 'IT & Software', categoryId: 3 },
+					{ name: 'Marketing', categoryId: 4 },
+					{ name: 'Design', categoryId: 1 },
+				])
+				.run();
+
+			const sq2 = db
+				.select({
+					categoryId: courseCategoriesTable.id,
+					category: courseCategoriesTable.name,
 					total: sql<number>`count(${courseCategoriesTable.id})`,
 				})
 				.from(courseCategoriesTable)
@@ -1204,47 +1738,46 @@ export function tests() {
 			]);
 		});
 
-		test('with ... select', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(orders).values([
-				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
-				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
-				{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 30, quantity: 3 },
-				{ region: 'US', product: 'A', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 40, quantity: 4 },
-				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
-			]).run();
+		test.concurrent('with ... select', async ({ db }) => {
+			await db
+				.insert(orders)
+				.values([
+					{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+					{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+					{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+					{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+					{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+				])
+				.run();
 
-			const regionalSales = await db
-				.$with('regional_sales')
-				.as(
-					db
-						.select({
-							region: orders.region,
-							totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
-						})
-						.from(orders)
-						.groupBy(orders.region),
-				);
+			const regionalSales = await db.$with('regional_sales').as(
+				db
+					.select({
+						region: orders.region,
+						totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+					})
+					.from(orders)
+					.groupBy(orders.region),
+			);
 
-			const topRegions = await db
-				.$with('top_regions')
-				.as(
-					db
-						.select({
-							region: regionalSales.region,
-						})
-						.from(regionalSales)
-						.where(
-							gt(
-								regionalSales.totalSales,
-								db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
-							),
+			const topRegions = await db.$with('top_regions').as(
+				db
+					.select({
+						region: regionalSales.region,
+					})
+					.from(regionalSales)
+					.where(
+						gt(
+							regionalSales.totalSales,
+							db
+								.select({ sales: sql`sum(${regionalSales.totalSales})/10` })
+								.from(regionalSales),
 						),
-				);
+					),
+			);
 
 			const result = await db
 				.with(regionalSales, topRegions)
@@ -1255,7 +1788,12 @@ export function tests() {
 					productSales: sql<number>`cast(sum(${orders.amount}) as int)`,
 				})
 				.from(orders)
-				.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+				.where(
+					inArray(
+						orders.region,
+						db.select({ region: topRegions.region }).from(topRegions),
+					),
+				)
 				.groupBy(orders.region, orders.product)
 				.orderBy(orders.region, orders.product)
 				.all();
@@ -1288,9 +1826,7 @@ export function tests() {
 			]);
 		});
 
-		test('with ... update', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('with ... update', async ({ db }) => {
 			const products = sqliteTable('products', {
 				id: integer('id').primaryKey(),
 				price: numeric('price').notNull(),
@@ -1306,23 +1842,23 @@ export function tests() {
 				)
 			`);
 
-			await db.insert(products).values([
-				{ price: '10.99' },
-				{ price: '25.85' },
-				{ price: '32.99' },
-				{ price: '2.50' },
-				{ price: '4.59' },
-			]);
+			await db
+				.insert(products)
+				.values([
+					{ price: '10.99' },
+					{ price: '25.85' },
+					{ price: '32.99' },
+					{ price: '2.50' },
+					{ price: '4.59' },
+				]);
 
-			const averagePrice = db
-				.$with('average_price')
-				.as(
-					db
-						.select({
-							value: sql`avg(${products.price})`.as('value'),
-						})
-						.from(products),
-				);
+			const averagePrice = db.$with('average_price').as(
+				db
+					.select({
+						value: sql`avg(${products.price})`.as('value'),
+					})
+					.from(products),
+			);
 
 			const result = await db
 				.with(averagePrice)
@@ -1335,33 +1871,27 @@ export function tests() {
 					id: products.id,
 				});
 
-			expect(result).toEqual([
-				{ id: 1 },
-				{ id: 4 },
-				{ id: 5 },
-			]);
+			expect(result).toEqual([{ id: 1 }, { id: 4 }, { id: 5 }]);
 		});
 
-		test('with ... insert', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('with ... insert', async ({ db }) => {
 			const users = sqliteTable('users', {
 				username: text('username').notNull(),
 				admin: integer('admin', { mode: 'boolean' }).notNull(),
 			});
 
 			await db.run(sql`drop table if exists ${users}`);
-			await db.run(sql`create table ${users} (username text not null, admin integer not null default 0)`);
+			await db.run(
+				sql`create table ${users} (username text not null, admin integer not null default 0)`,
+			);
 
-			const userCount = db
-				.$with('user_count')
-				.as(
-					db
-						.select({
-							value: sql`count(*)`.as('value'),
-						})
-						.from(users),
-				);
+			const userCount = db.$with('user_count').as(
+				db
+					.select({
+						value: sql`count(*)`.as('value'),
+					})
+					.from(users),
+			);
 
 			const result = await db
 				.with(userCount)
@@ -1376,9 +1906,7 @@ export function tests() {
 			expect(result).toEqual([{ admin: true }]);
 		});
 
-		test('with ... delete', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('with ... delete', async ({ db }) => {
 			await db.insert(orders).values([
 				{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
 				{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
@@ -1390,15 +1918,13 @@ export function tests() {
 				{ region: 'US', product: 'B', amount: 50, quantity: 5 },
 			]);
 
-			const averageAmount = db
-				.$with('average_amount')
-				.as(
-					db
-						.select({
-							value: sql`avg(${orders.amount})`.as('value'),
-						})
-						.from(orders),
-				);
+			const averageAmount = db.$with('average_amount').as(
+				db
+					.select({
+						value: sql`avg(${orders.amount})`.as('value'),
+					})
+					.from(orders),
+			);
 
 			const result = await db
 				.with(averageAmount)
@@ -1408,62 +1934,131 @@ export function tests() {
 					id: orders.id,
 				});
 
-			expect(result).toEqual([
-				{ id: 6 },
-				{ id: 7 },
-				{ id: 8 },
-			]);
+			expect(result).toEqual([{ id: 6 }, { id: 7 }, { id: 8 }]);
 		});
 
-		test('select from subquery sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]).run();
+		test.concurrent('select from subquery sql', async ({ db }) => {
+			await db
+				.insert(users2Table)
+				.values([{ name: 'John' }, { name: 'Jane' }])
+				.run();
 
 			const sq = db
-				.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+				.select({
+					name: sql<string>`${users2Table.name} || ' modified'`.as('name'),
+				})
 				.from(users2Table)
 				.as('sq');
 
 			const res = await db.select({ name: sq.name }).from(sq).all();
 
-			expect(res).toEqual([{ name: 'John modified' }, { name: 'Jane modified' }]);
+			expect(res).toEqual([
+				{ name: 'John modified' },
+				{ name: 'Jane modified' },
+			]);
 		});
 
-		test('select a field without joining its table', (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'select a field without joining its table',
+			async ({ db }) => {
+				expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
+			},
+		);
 
-			expect(() => db.select({ name: users2Table.name }).from(usersTable).prepare()).toThrowError();
-		});
+		test.concurrent(
+			'select all fields from subquery without alias',
+			async ({ db }) => {
+				const sq = db
+					.$with('sq')
+					.as(
+						db
+							.select({ name: sql<string>`upper(${users2Table.name})` })
+							.from(users2Table),
+					);
 
-		test('select all fields from subquery without alias', (ctx) => {
-			const { db } = ctx.sqlite;
+				expect(() => db.select().from(sq).prepare()).toThrowError();
+			},
+		);
 
-			const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+		test.concurrent('sql.Aliased in cte', async ({ db, push }) => {
+			const users = sqliteTable('users_109_sqla', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
 
-			expect(() => db.select().from(sq).prepare()).toThrowError();
-		});
+			await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+			await push({ users });
+			await db.insert(users).values([
+				{ id: 1, name: 'John' },
+				{ id: 2, name: 'Jane' },
+			]);
+
+			const sq1 = db.$with('sq1').as((qb) =>
+				qb
+					.select({
+						aliased: sql`count(*)`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
+			const sq2 = db.$with('sq2').as((qb) =>
+				qb
+					.select({
+						aliased: sql`sum(${users.id})`.mapWith(Number).as('alias'),
+					})
+					.from(users)
+			);
 
-		test('select count()', async (ctx) => {
-			const { db } = ctx.sqlite;
+			const result = await db
+				.with(sq1, sq2)
+				.select({
+					count: sq1.aliased,
+					sum: sq2.aliased,
+				})
+				.from(sq1)
+				.crossJoin(sq2);
 
-			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]).run();
+			expect(result).toEqual([{ count: 2, sum: 3 }]);
 
-			const res = await db.select({ count: sql`count(*)` }).from(usersTable).all();
+			const result2 = await db
+				.with(sq1)
+				.select({
+					count: sq1.aliased,
+				})
+				.from(sq1)
+				.groupBy(sq1.aliased)
+				.orderBy(sq1.aliased);
 
-			expect(res).toEqual([{ count: 2 }]);
+			expect(result2).toEqual([{ count: 2 }]);
 		});
 
-		test('having', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('select count()', async ({ db }) => {
+			await db
+				.insert(usersTable)
+				.values([{ name: 'John' }, { name: 'Jane' }])
+				.run();
 
-			await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]).run();
+			const res = await db
+				.select({ count: sql`count(*)` })
+				.from(usersTable)
+				.all();
 
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]).run();
+			expect(res).toEqual([{ count: 2 }]);
+		});
+
+		test.concurrent('having', async ({ db }) => {
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }])
+				.run();
+
+			await db
+				.insert(users2Table)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				])
+				.run();
 
 			const result = await db
 				.select({
@@ -1493,17 +2088,18 @@ export function tests() {
 			]);
 		});
 
-		test('view', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const newYorkers1 = sqliteView('new_yorkers')
-				.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+		test.concurrent('view', async ({ db }) => {
+			const newYorkers1 = sqliteView('new_yorkers').as((qb) =>
+				qb.select().from(users2Table).where(eq(users2Table.cityId, 1))
+			);
 
 			const newYorkers2 = sqliteView('new_yorkers', {
 				id: integer('id').primaryKey(),
 				name: text('name').notNull(),
 				cityId: integer('city_id').notNull(),
-			}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+			}).as(
+				sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`,
+			);
 
 			const newYorkers3 = sqliteView('new_yorkers', {
 				id: integer('id').primaryKey(),
@@ -1511,15 +2107,23 @@ export function tests() {
 				cityId: integer('city_id').notNull(),
 			}).existing();
 
-			await db.run(sql`create view if not exists new_yorkers as ${getViewConfig(newYorkers1).query}`);
+			await db.run(
+				sql`create view if not exists new_yorkers as ${getViewConfig(newYorkers1).query}`,
+			);
 
-			await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]).run();
+			await db
+				.insert(citiesTable)
+				.values([{ name: 'New York' }, { name: 'Paris' }])
+				.run();
 
-			await db.insert(users2Table).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 1 },
-				{ name: 'Jack', cityId: 2 },
-			]).run();
+			await db
+				.insert(users2Table)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 1 },
+					{ name: 'Jack', cityId: 2 },
+				])
+				.run();
 
 			{
 				const result = await db.select().from(newYorkers1).all();
@@ -1546,19 +2150,17 @@ export function tests() {
 			}
 
 			{
-				const result = await db.select({ name: newYorkers1.name }).from(newYorkers1).all();
-				expect(result).toEqual([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
+				const result = await db
+					.select({ name: newYorkers1.name })
+					.from(newYorkers1)
+					.all();
+				expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]);
 			}
 
 			await db.run(sql`drop view ${newYorkers1}`);
 		});
 
-		test('insert null timestamp', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('insert null timestamp', async ({ db }) => {
 			const test = sqliteTable('test', {
 				t: integer('t', { mode: 'timestamp' }),
 			});
@@ -1572,24 +2174,21 @@ export function tests() {
 			await db.run(sql`drop table ${test}`);
 		});
 
-		test('select from raw sql', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const result = await db.select({
-				id: sql<number>`id`,
-				name: sql<string>`name`,
-			}).from(sql`(select 1 as id, 'John' as name) as users`).all();
+		test.concurrent('select from raw sql', async ({ db }) => {
+			const result = await db
+				.select({
+					id: sql<number>`id`,
+					name: sql<string>`name`,
+				})
+				.from(sql`(select 1 as id, 'John' as name) as users`)
+				.all();
 
 			Expect<Equal<{ id: number; name: string }[], typeof result>>;
 
-			expect(result).toEqual([
-				{ id: 1, name: 'John' },
-			]);
+			expect(result).toEqual([{ id: 1, name: 'John' }]);
 		});
 
-		test('select from raw sql with joins', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('select from raw sql with joins', async ({ db }) => {
 			const result = await db
 				.select({
 					id: sql<number>`users.id`,
@@ -1597,20 +2196,28 @@ export function tests() {
 					userCity: sql<string>`users.city`,
 					cityName: sql<string>`cities.name`.as('cityName'),
 				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
-				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`)
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
+				.leftJoin(
+					sql`(select 1 as id, 'Paris' as name) as cities`,
+					sql`cities.id = users.id`,
+				)
 				.all();
 
-			Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+			Expect<
+				Equal<
+					{ id: number; name: string; userCity: string; cityName: string }[],
+					typeof result
+				>
+			>;
 
 			expect(result).toEqual([
 				{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
 			]);
 		});
 
-		test('join on aliased sql from select', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('join on aliased sql from select', async ({ db }) => {
 			const result = await db
 				.select({
 					userId: sql<number>`users.id`.as('userId'),
@@ -1619,39 +2226,56 @@ export function tests() {
 					cityId: sql<number>`cities.id`.as('cityId'),
 					cityName: sql<string>`cities.name`.as('cityName'),
 				})
-				.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+				.from(
+					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+				)
 				.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId))
 				.all();
 
 			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+				Equal<
+					{
+						userId: number;
+						name: string;
+						userCity: string;
+						cityId: number;
+						cityName: string;
+					}[],
+					typeof result
+				>
 			>;
 
 			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+				{
+					userId: 1,
+					name: 'John',
+					userCity: 'New York',
+					cityId: 1,
+					cityName: 'Paris',
+				},
 			]);
 		});
 
-		test('join on aliased sql from with clause', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('join on aliased sql from with clause', async ({ db }) => {
 			const users = db.$with('users').as(
-				db.select({
-					id: sql<number>`id`.as('userId'),
-					name: sql<string>`name`.as('userName'),
-					city: sql<string>`city`.as('city'),
-				}).from(
-					sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
-				),
+				db
+					.select({
+						id: sql<number>`id`.as('userId'),
+						name: sql<string>`name`.as('userName'),
+						city: sql<string>`city`.as('city'),
+					})
+					.from(
+						sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+					),
 			);
 
 			const cities = db.$with('cities').as(
-				db.select({
-					id: sql<number>`id`.as('cityId'),
-					name: sql<string>`name`.as('cityName'),
-				}).from(
-					sql`(select 1 as id, 'Paris' as name) as cities`,
-				),
+				db
+					.select({
+						id: sql<number>`id`.as('cityId'),
+						name: sql<string>`name`.as('cityName'),
+					})
+					.from(sql`(select 1 as id, 'Paris' as name) as cities`),
 			);
 
 			const result = await db
@@ -1668,17 +2292,30 @@ export function tests() {
 				.all();
 
 			Expect<
-				Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>
+				Equal<
+					{
+						userId: number;
+						name: string;
+						userCity: string;
+						cityId: number;
+						cityName: string;
+					}[],
+					typeof result
+				>
 			>;
 
 			expect(result).toEqual([
-				{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+				{
+					userId: 1,
+					name: 'John',
+					userCity: 'New York',
+					cityId: 1,
+					cityName: 'Paris',
+				},
 			]);
 		});
 
-		test('prefixed table', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('prefixed table', async ({ db }) => {
 			const sqliteTable = sqliteTableCreator((name) => `myprefix_${name}`);
 
 			const users = sqliteTable('test_prefixed_table_with_unique_name', {
@@ -1701,19 +2338,21 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('orderBy with aliased column', (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const query = db.select({
-				test: sql`something`.as('test'),
-			}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+		test.concurrent('orderBy with aliased column', async ({ db }) => {
+			const query = db
+				.select({
+					test: sql`something`.as('test'),
+				})
+				.from(users2Table)
+				.orderBy((fields) => fields.test)
+				.toSQL();
 
-			expect(query.sql).toBe('select something as "test" from "users2" order by "test"');
+			expect(query.sql).toBe(
+				'select something as "test" from "users2" order by "test"',
+			);
 		});
 
-		test('transaction', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('transaction', async ({ db }) => {
 			const users = sqliteTable('users_transactions', {
 				id: integer('id').primaryKey(),
 				balance: integer('balance').notNull(),
@@ -1727,17 +2366,35 @@ export function tests() {
 			await db.run(sql`drop table if exists ${users}`);
 			await db.run(sql`drop table if exists ${products}`);
 
-			await db.run(sql`create table users_transactions (id integer not null primary key, balance integer not null)`);
+			await db.run(
+				sql`create table users_transactions (id integer not null primary key, balance integer not null)`,
+			);
 			await db.run(
 				sql`create table products_transactions (id integer not null primary key, price integer not null, stock integer not null)`,
 			);
 
-			const user = await db.insert(users).values({ balance: 100 }).returning().get();
-			const product = await db.insert(products).values({ price: 10, stock: 10 }).returning().get();
+			const user = await db
+				.insert(users)
+				.values({ balance: 100 })
+				.returning()
+				.get();
+			const product = await db
+				.insert(products)
+				.values({ price: 10, stock: 10 })
+				.returning()
+				.get();
 
 			await db.transaction(async (tx) => {
-				await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id)).run();
-				await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id)).run();
+				await tx
+					.update(users)
+					.set({ balance: user.balance - product.price })
+					.where(eq(users.id, user.id))
+					.run();
+				await tx
+					.update(products)
+					.set({ stock: product.stock - 1 })
+					.where(eq(products.id, product.id))
+					.run();
 			});
 
 			const result = await db.select().from(users).all();
@@ -1748,9 +2405,7 @@ export function tests() {
 			await db.run(sql`drop table ${products}`);
 		});
 
-		test('transaction rollback', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('transaction rollback', async ({ db }) => {
 			const users = sqliteTable('users_transactions_rollback', {
 				id: integer('id').primaryKey(),
 				balance: integer('balance').notNull(),
@@ -1775,25 +2430,48 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('nested transaction', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			const users = sqliteTable('users_nested_transactions', {
+		test.concurrent('sync transaction rollback', ({ db }) => {
+			const users = sqliteTable('users_transactions_rollback', {
 				id: integer('id').primaryKey(),
 				balance: integer('balance').notNull(),
 			});
 
-			await db.run(sql`drop table if exists ${users}`);
+			db.run(sql`drop table if exists ${users}`);
 
-			await db.run(
-				sql`create table users_nested_transactions (id integer not null primary key, balance integer not null)`,
+			db.run(
+				sql`create table users_transactions_rollback (id integer not null primary key, balance integer not null)`,
 			);
+			expect(() => {
+				db.transaction((tx) => {
+					tx.insert(users).values({ balance: 100 }).run();
+					tx.rollback();
+				});
+			}).toThrowError(TransactionRollbackError);
 
-			await db.transaction(async (tx) => {
-				await tx.insert(users).values({ balance: 100 }).run();
+			const result = db.select().from(users).all();
 
-				await tx.transaction(async (tx) => {
-					await tx.update(users).set({ balance: 200 }).run();
+			expect(result).toEqual([]);
+
+			db.run(sql`drop table ${users}`);
+		});
+
+		test.concurrent('nested transaction', async ({ db }) => {
+			const users = sqliteTable('users_nested_transactions', {
+				id: integer('id').primaryKey(),
+				balance: integer('balance').notNull(),
+			});
+
+			await db.run(sql`drop table if exists ${users}`);
+
+			await db.run(
+				sql`create table users_nested_transactions (id integer not null primary key, balance integer not null)`,
+			);
+
+			await db.transaction(async (tx) => {
+				await tx.insert(users).values({ balance: 100 }).run();
+
+				await tx.transaction(async (tx) => {
+					await tx.update(users).set({ balance: 200 }).run();
 				});
 			});
 
@@ -1804,9 +2482,7 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('nested transaction rollback', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('nested transaction rollback', async ({ db }) => {
 			const users = sqliteTable('users_nested_transactions_rollback', {
 				id: integer('id').primaryKey(),
 				balance: integer('balance').notNull(),
@@ -1836,9 +2512,37 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('join subquery with join', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('sync nested transaction rollback', ({ db }) => {
+			const users = sqliteTable('users_nested_transactions_rollback', {
+				id: integer('id').primaryKey(),
+				balance: integer('balance').notNull(),
+			});
+
+			db.run(sql`drop table if exists ${users}`);
+
+			db.run(
+				sql`create table users_nested_transactions_rollback (id integer not null primary key, balance integer not null)`,
+			);
+
+			db.transaction((tx) => {
+				tx.insert(users).values({ balance: 100 }).run();
 
+				expect(() => {
+					tx.transaction((tx) => {
+						tx.update(users).set({ balance: 200 }).run();
+						tx.rollback();
+					});
+				}).toThrowError(TransactionRollbackError);
+			});
+
+			const result = db.select().from(users).all();
+
+			expect(result).toEqual([{ id: 1, balance: 100 }]);
+
+			db.run(sql`drop table ${users}`);
+		});
+
+		test.concurrent('join subquery with join', async ({ db }) => {
 			const internalStaff = sqliteTable('internal_staff', {
 				userId: integer('user_id').notNull(),
 			});
@@ -1875,22 +2579,22 @@ export function tests() {
 				.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId))
 				.all();
 
-			expect(mainQuery).toEqual([{
-				ticket: { staffId: 1 },
-				internal_staff: {
-					internal_staff: { userId: 1 },
-					custom_user: { id: 1 },
+			expect(mainQuery).toEqual([
+				{
+					ticket: { staffId: 1 },
+					internal_staff: {
+						internal_staff: { userId: 1 },
+						custom_user: { id: 1 },
+					},
 				},
-			}]);
+			]);
 
 			await db.run(sql`drop table ${internalStaff}`);
 			await db.run(sql`drop table ${customUser}`);
 			await db.run(sql`drop table ${ticket}`);
 		});
 
-		test('join view as subquery', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('join view as subquery', async ({ db }) => {
 			const users = sqliteTable('users_join_view', {
 				id: integer('id').primaryKey(),
 				name: text('name').notNull(),
@@ -1905,18 +2609,26 @@ export function tests() {
 			await db.run(
 				sql`create table ${users} (id integer not null primary key, name text not null, city_id integer not null)`,
 			);
-			await db.run(sql`create view if not exists ${newYorkers} as ${getViewConfig(newYorkers).query}`);
+			await db.run(
+				sql`create view if not exists ${newYorkers} as ${getViewConfig(newYorkers).query}`,
+			);
 
-			db.insert(users).values([
-				{ name: 'John', cityId: 1 },
-				{ name: 'Jane', cityId: 2 },
-				{ name: 'Jack', cityId: 1 },
-				{ name: 'Jill', cityId: 2 },
-			]).run();
+			await db.insert(users)
+				.values([
+					{ name: 'John', cityId: 1 },
+					{ name: 'Jane', cityId: 2 },
+					{ name: 'Jack', cityId: 1 },
+					{ name: 'Jill', cityId: 2 },
+				])
+				.run();
 
 			const sq = db.select().from(newYorkers).as('new_yorkers_sq');
 
-			const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id)).all();
+			const result = await db
+				.select()
+				.from(users)
+				.leftJoin(sq, eq(users.id, sq.id))
+				.all();
 
 			expect(result).toEqual([
 				{
@@ -1941,9 +2653,7 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('insert with onConflict do nothing', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('insert with onConflict do nothing', async ({ db }) => {
 			await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
 
 			await db
@@ -1961,75 +2671,90 @@ export function tests() {
 			expect(res).toEqual([{ id: 1, name: 'John' }]);
 		});
 
-		test('insert with onConflict do nothing using composite pk', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db
-				.insert(pkExampleTable)
-				.values({ id: 1, name: 'John', email: 'john@example.com' })
-				.run();
-
-			await db
-				.insert(pkExampleTable)
-				.values({ id: 1, name: 'John', email: 'john1@example.com' })
-				.onConflictDoNothing()
-				.run();
-
-			const res = await db
-				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
-				.from(pkExampleTable)
-				.where(eq(pkExampleTable.id, 1))
-				.all();
-
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john@example.com' }]);
-		});
-
-		test('insert with onConflict do nothing using target', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'insert with onConflict do nothing using composite pk',
+			async ({ db }) => {
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john@example.com' })
+					.run();
 
-			await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john1@example.com' })
+					.onConflictDoNothing()
+					.run();
 
-			await db
-				.insert(usersTable)
-				.values({ id: 1, name: 'John' })
-				.onConflictDoNothing({ target: usersTable.id })
-				.run();
+				const res = await db
+					.select({
+						id: pkExampleTable.id,
+						name: pkExampleTable.name,
+						email: pkExampleTable.email,
+					})
+					.from(pkExampleTable)
+					.where(eq(pkExampleTable.id, 1))
+					.all();
 
-			const res = await db
-				.select({ id: usersTable.id, name: usersTable.name })
-				.from(usersTable)
-				.where(eq(usersTable.id, 1))
-				.all();
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john@example.com' },
+				]);
+			},
+		);
 
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-		});
+		test.concurrent(
+			'insert with onConflict do nothing using target',
+			async ({ db }) => {
+				await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
 
-		test('insert with onConflict do nothing using composite pk as target', async (ctx) => {
-			const { db } = ctx.sqlite;
+				await db
+					.insert(usersTable)
+					.values({ id: 1, name: 'John' })
+					.onConflictDoNothing({ target: usersTable.id })
+					.run();
 
-			await db
-				.insert(pkExampleTable)
-				.values({ id: 1, name: 'John', email: 'john@example.com' })
-				.run();
+				const res = await db
+					.select({ id: usersTable.id, name: usersTable.name })
+					.from(usersTable)
+					.where(eq(usersTable.id, 1))
+					.all();
 
-			await db
-				.insert(pkExampleTable)
-				.values({ id: 1, name: 'John', email: 'john1@example.com' })
-				.onConflictDoNothing({ target: [pkExampleTable.id, pkExampleTable.name] })
-				.run();
+				expect(res).toEqual([{ id: 1, name: 'John' }]);
+			},
+		);
 
-			const res = await db
-				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
-				.from(pkExampleTable)
-				.where(eq(pkExampleTable.id, 1))
-				.all();
+		test.concurrent(
+			'insert with onConflict do nothing using composite pk as target',
+			async ({ db }) => {
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john@example.com' })
+					.run();
+
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john1@example.com' })
+					.onConflictDoNothing({
+						target: [pkExampleTable.id, pkExampleTable.name],
+					})
+					.run();
 
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john@example.com' }]);
-		});
+				const res = await db
+					.select({
+						id: pkExampleTable.id,
+						name: pkExampleTable.name,
+						email: pkExampleTable.email,
+					})
+					.from(pkExampleTable)
+					.where(eq(pkExampleTable.id, 1))
+					.all();
 
-		test('insert with onConflict do update', async (ctx) => {
-			const { db } = ctx.sqlite;
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john@example.com' },
+				]);
+			},
+		);
 
+		test.concurrent('insert with onConflict do update', async ({ db }) => {
 			await db.insert(usersTable).values({ id: 1, name: 'John' }).run();
 
 			await db
@@ -2047,215 +2772,298 @@ export function tests() {
 			expect(res).toEqual([{ id: 1, name: 'John1' }]);
 		});
 
-		test('insert with onConflict do update where', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db
-				.insert(usersTable)
-				.values([{ id: 1, name: 'John', verified: false }])
-				.run();
-
-			await db
-				.insert(usersTable)
-				.values({ id: 1, name: 'John1', verified: true })
-				.onConflictDoUpdate({
-					target: usersTable.id,
-					set: { name: 'John1', verified: true },
-					where: eq(usersTable.verified, false),
-				})
-				.run();
-
-			const res = await db
-				.select({ id: usersTable.id, name: usersTable.name, verified: usersTable.verified })
-				.from(usersTable)
-				.where(eq(usersTable.id, 1))
-				.all();
-
-			expect(res).toEqual([{ id: 1, name: 'John1', verified: true }]);
-		});
-
-		test('insert with onConflict do update using composite pk', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(pkExampleTable).values({ id: 1, name: 'John', email: 'john@example.com' }).run();
-
-			await db
-				.insert(pkExampleTable)
-				.values({ id: 1, name: 'John', email: 'john@example.com' })
-				.onConflictDoUpdate({ target: [pkExampleTable.id, pkExampleTable.name], set: { email: 'john1@example.com' } })
-				.run();
-
-			const res = await db
-				.select({ id: pkExampleTable.id, name: pkExampleTable.name, email: pkExampleTable.email })
-				.from(pkExampleTable)
-				.where(eq(pkExampleTable.id, 1))
-				.all();
-
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john1@example.com' }]);
-		});
-
-		test('insert with onConflict chained (.update -> .nothing)', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]).run();
-
-			await db
-				.insert(conflictChainExampleTable)
-				.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-					id: 2,
-					name: 'Anthony',
-					email: 'idthief@example.com',
-				}])
-				.onConflictDoUpdate({
-					target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
-					set: { email: 'john1@example.com' },
-				})
-				.onConflictDoNothing({ target: conflictChainExampleTable.id })
-				.run();
-
-			const res = await db
-				.select({
-					id: conflictChainExampleTable.id,
-					name: conflictChainExampleTable.name,
-					email: conflictChainExampleTable.email,
-				})
-				.from(conflictChainExampleTable)
-				.orderBy(conflictChainExampleTable.id)
-				.all();
-
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]);
-		});
-
-		test('insert with onConflict chained (.nothing -> .update)', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]).run();
-
-			await db
-				.insert(conflictChainExampleTable)
-				.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-					id: 2,
-					name: 'Anthony',
-					email: 'idthief@example.com',
-				}])
-				.onConflictDoUpdate({
-					target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
-					set: { email: 'john1@example.com' },
-				})
-				.onConflictDoNothing({ target: conflictChainExampleTable.id })
-				.run();
+		test.concurrent(
+			'insert with onConflict do update where',
+			async ({ db }) => {
+				await db
+					.insert(usersTable)
+					.values([{ id: 1, name: 'John', verified: false }])
+					.run();
+
+				await db
+					.insert(usersTable)
+					.values({ id: 1, name: 'John1', verified: true })
+					.onConflictDoUpdate({
+						target: usersTable.id,
+						set: { name: 'John1', verified: true },
+						where: eq(usersTable.verified, false),
+					})
+					.run();
 
-			const res = await db
-				.select({
-					id: conflictChainExampleTable.id,
-					name: conflictChainExampleTable.name,
-					email: conflictChainExampleTable.email,
-				})
-				.from(conflictChainExampleTable)
-				.orderBy(conflictChainExampleTable.id)
-				.all();
+				const res = await db
+					.select({
+						id: usersTable.id,
+						name: usersTable.name,
+						verified: usersTable.verified,
+					})
+					.from(usersTable)
+					.where(eq(usersTable.id, 1))
+					.all();
 
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]);
-		});
+				expect(res).toEqual([{ id: 1, name: 'John1', verified: true }]);
+			},
+		);
 
-		test('insert with onConflict chained (.update -> .update)', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'insert with onConflict do update using composite pk',
+			async ({ db }) => {
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john@example.com' })
+					.run();
+
+				await db
+					.insert(pkExampleTable)
+					.values({ id: 1, name: 'John', email: 'john@example.com' })
+					.onConflictDoUpdate({
+						target: [pkExampleTable.id, pkExampleTable.name],
+						set: { email: 'john1@example.com' },
+					})
+					.run();
 
-			await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]).run();
+				const res = await db
+					.select({
+						id: pkExampleTable.id,
+						name: pkExampleTable.name,
+						email: pkExampleTable.email,
+					})
+					.from(pkExampleTable)
+					.where(eq(pkExampleTable.id, 1))
+					.all();
 
-			await db
-				.insert(conflictChainExampleTable)
-				.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-					id: 2,
-					name: 'Anthony',
-					email: 'idthief@example.com',
-				}])
-				.onConflictDoUpdate({
-					target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
-					set: { email: 'john1@example.com' },
-				})
-				.onConflictDoUpdate({ target: conflictChainExampleTable.id, set: { email: 'john2@example.com' } })
-				.run();
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john1@example.com' },
+				]);
+			},
+		);
 
-			const res = await db
-				.select({
-					id: conflictChainExampleTable.id,
-					name: conflictChainExampleTable.name,
-					email: conflictChainExampleTable.email,
-				})
-				.from(conflictChainExampleTable)
-				.orderBy(conflictChainExampleTable.id)
-				.all();
+		test.concurrent(
+			'insert with onConflict chained (.update -> .nothing)',
+			async ({ db }) => {
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'John Second',
+							email: '2john@example.com',
+						},
+					])
+					.run();
+
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'Anthony',
+							email: 'idthief@example.com',
+						},
+					])
+					.onConflictDoUpdate({
+						target: [
+							conflictChainExampleTable.id,
+							conflictChainExampleTable.name,
+						],
+						set: { email: 'john1@example.com' },
+					})
+					.onConflictDoNothing({ target: conflictChainExampleTable.id })
+					.run();
 
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john1@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: 'john2@example.com',
-			}]);
-		});
+				const res = await db
+					.select({
+						id: conflictChainExampleTable.id,
+						name: conflictChainExampleTable.name,
+						email: conflictChainExampleTable.email,
+					})
+					.from(conflictChainExampleTable)
+					.orderBy(conflictChainExampleTable.id)
+					.all();
+
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john1@example.com' },
+					{
+						id: 2,
+						name: 'John Second',
+						email: '2john@example.com',
+					},
+				]);
+			},
+		);
 
-		test('insert with onConflict chained (.nothing -> .nothing)', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'insert with onConflict chained (.nothing -> .update)',
+			async ({ db }) => {
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'John Second',
+							email: '2john@example.com',
+						},
+					])
+					.run();
+
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'Anthony',
+							email: 'idthief@example.com',
+						},
+					])
+					.onConflictDoUpdate({
+						target: [
+							conflictChainExampleTable.id,
+							conflictChainExampleTable.name,
+						],
+						set: { email: 'john1@example.com' },
+					})
+					.onConflictDoNothing({ target: conflictChainExampleTable.id })
+					.run();
 
-			await db.insert(conflictChainExampleTable).values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]).run();
+				const res = await db
+					.select({
+						id: conflictChainExampleTable.id,
+						name: conflictChainExampleTable.name,
+						email: conflictChainExampleTable.email,
+					})
+					.from(conflictChainExampleTable)
+					.orderBy(conflictChainExampleTable.id)
+					.all();
+
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john1@example.com' },
+					{
+						id: 2,
+						name: 'John Second',
+						email: '2john@example.com',
+					},
+				]);
+			},
+		);
 
-			await db
-				.insert(conflictChainExampleTable)
-				.values([{ id: 1, name: 'John', email: 'john@example.com' }, {
-					id: 2,
-					name: 'Anthony',
-					email: 'idthief@example.com',
-				}])
-				.onConflictDoNothing({
-					target: [conflictChainExampleTable.id, conflictChainExampleTable.name],
-				})
-				.onConflictDoNothing({ target: conflictChainExampleTable.id })
-				.run();
+		test.concurrent(
+			'insert with onConflict chained (.update -> .update)',
+			async ({ db }) => {
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'John Second',
+							email: '2john@example.com',
+						},
+					])
+					.run();
+
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'Anthony',
+							email: 'idthief@example.com',
+						},
+					])
+					.onConflictDoUpdate({
+						target: [
+							conflictChainExampleTable.id,
+							conflictChainExampleTable.name,
+						],
+						set: { email: 'john1@example.com' },
+					})
+					.onConflictDoUpdate({
+						target: conflictChainExampleTable.id,
+						set: { email: 'john2@example.com' },
+					})
+					.run();
 
-			const res = await db
-				.select({
-					id: conflictChainExampleTable.id,
-					name: conflictChainExampleTable.name,
-					email: conflictChainExampleTable.email,
-				})
-				.from(conflictChainExampleTable)
-				.orderBy(conflictChainExampleTable.id)
-				.all();
+				const res = await db
+					.select({
+						id: conflictChainExampleTable.id,
+						name: conflictChainExampleTable.name,
+						email: conflictChainExampleTable.email,
+					})
+					.from(conflictChainExampleTable)
+					.orderBy(conflictChainExampleTable.id)
+					.all();
+
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john1@example.com' },
+					{
+						id: 2,
+						name: 'John Second',
+						email: 'john2@example.com',
+					},
+				]);
+			},
+		);
 
-			expect(res).toEqual([{ id: 1, name: 'John', email: 'john@example.com' }, {
-				id: 2,
-				name: 'John Second',
-				email: '2john@example.com',
-			}]);
-		});
+		test.concurrent(
+			'insert with onConflict chained (.nothing -> .nothing)',
+			async ({ db }) => {
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'John Second',
+							email: '2john@example.com',
+						},
+					])
+					.run();
+
+				await db
+					.insert(conflictChainExampleTable)
+					.values([
+						{ id: 1, name: 'John', email: 'john@example.com' },
+						{
+							id: 2,
+							name: 'Anthony',
+							email: 'idthief@example.com',
+						},
+					])
+					.onConflictDoNothing({
+						target: [
+							conflictChainExampleTable.id,
+							conflictChainExampleTable.name,
+						],
+					})
+					.onConflictDoNothing({ target: conflictChainExampleTable.id })
+					.run();
 
-		test('insert undefined', async (ctx) => {
-			const { db } = ctx.sqlite;
+				const res = await db
+					.select({
+						id: conflictChainExampleTable.id,
+						name: conflictChainExampleTable.name,
+						email: conflictChainExampleTable.email,
+					})
+					.from(conflictChainExampleTable)
+					.orderBy(conflictChainExampleTable.id)
+					.all();
+
+				expect(res).toEqual([
+					{ id: 1, name: 'John', email: 'john@example.com' },
+					{
+						id: 2,
+						name: 'John Second',
+						email: '2john@example.com',
+					},
+				]);
+			},
+		);
 
+		test.concurrent('insert undefined', async ({ db }) => {
 			const users = sqliteTable('users', {
 				id: integer('id').primaryKey(),
 				name: text('name'),
@@ -2267,16 +3075,16 @@ export function tests() {
 				sql`create table ${users} (id integer primary key, name text)`,
 			);
 
-			await expect((async () => {
-				await db.insert(users).values({ name: undefined }).run();
-			})()).resolves.not.toThrowError();
+			await expect(
+				(async () => {
+					await db.insert(users).values({ name: undefined }).run();
+				})(),
+			).resolves.not.toThrowError();
 
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('update undefined', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('update undefined', async ({ db }) => {
 			const users = sqliteTable('users', {
 				id: integer('id').primaryKey(),
 				name: text('name'),
@@ -2288,29 +3096,29 @@ export function tests() {
 				sql`create table ${users} (id integer primary key, name text)`,
 			);
 
-			await expect((async () => {
-				await db.update(users).set({ name: undefined }).run();
-			})()).rejects.toThrowError();
-			await expect((async () => {
-				await db.update(users).set({ id: 1, name: undefined }).run();
-			})()).resolves.not.toThrowError();
+			await expect(
+				(async () => {
+					await db.update(users).set({ name: undefined }).run();
+				})(),
+			).rejects.toThrowError();
+			await expect(
+				(async () => {
+					await db.update(users).set({ id: 1, name: undefined }).run();
+				})(),
+			).resolves.not.toThrowError();
 
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('async api - CRUD', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('async api - CRUD', async ({ db }) => {
 			const users = sqliteTable('users', {
 				id: integer('id').primaryKey(),
 				name: text('name'),
 			});
 
-			db.run(sql`drop table if exists ${users}`);
+			await db.run(sql`drop table if exists ${users}`);
 
-			db.run(
-				sql`create table ${users} (id integer primary key, name text)`,
-			);
+			await db.run(sql`create table ${users} (id integer primary key, name text)`);
 
 			await db.insert(users).values({ id: 1, name: 'John' });
 
@@ -2333,97 +3141,105 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('async api - insert + select w/ prepare + async execute', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'async api - insert + select w/ prepare + async execute',
+			async ({ db }) => {
+				const users = sqliteTable('users', {
+					id: integer('id').primaryKey(),
+					name: text('name'),
+				});
 
-			const users = sqliteTable('users', {
-				id: integer('id').primaryKey(),
-				name: text('name'),
-			});
+				await db.run(sql`drop table if exists ${users}`);
 
-			db.run(sql`drop table if exists ${users}`);
+				await db.run(sql`create table ${users} (id integer primary key, name text)`);
 
-			db.run(
-				sql`create table ${users} (id integer primary key, name text)`,
-			);
+				const insertStmt = db
+					.insert(users)
+					.values({ id: 1, name: 'John' })
+					.prepare();
+				await insertStmt.execute();
 
-			const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
-			await insertStmt.execute();
+				const selectStmt = db.select().from(users).prepare();
+				const res = await selectStmt.execute();
 
-			const selectStmt = db.select().from(users).prepare();
-			const res = await selectStmt.execute();
+				expect(res).toEqual([{ id: 1, name: 'John' }]);
 
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
+				const updateStmt = db
+					.update(users)
+					.set({ name: 'John1' })
+					.where(eq(users.id, 1))
+					.prepare();
+				await updateStmt.execute();
 
-			const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
-			await updateStmt.execute();
+				const res1 = await selectStmt.execute();
 
-			const res1 = await selectStmt.execute();
+				expect(res1).toEqual([{ id: 1, name: 'John1' }]);
 
-			expect(res1).toEqual([{ id: 1, name: 'John1' }]);
+				const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+				await deleteStmt.execute();
 
-			const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
-			await deleteStmt.execute();
+				const res2 = await selectStmt.execute();
 
-			const res2 = await selectStmt.execute();
+				expect(res2).toEqual([]);
 
-			expect(res2).toEqual([]);
+				await db.run(sql`drop table ${users}`);
+			},
+		);
 
-			await db.run(sql`drop table ${users}`);
-		});
+		test.concurrent(
+			'async api - insert + select w/ prepare + sync execute',
+			async ({ db }) => {
+				const users = sqliteTable('users', {
+					id: integer('id').primaryKey(),
+					name: text('name'),
+				});
 
-		test('async api - insert + select w/ prepare + sync execute', async (ctx) => {
-			const { db } = ctx.sqlite;
+				await db.run(sql`drop table if exists ${users}`);
 
-			const users = sqliteTable('users', {
-				id: integer('id').primaryKey(),
-				name: text('name'),
-			});
+				await db.run(sql`create table ${users} (id integer primary key, name text)`);
 
-			db.run(sql`drop table if exists ${users}`);
+				const insertStmt = db
+					.insert(users)
+					.values({ id: 1, name: 'John' })
+					.prepare();
+				await insertStmt.execute();
 
-			db.run(
-				sql`create table ${users} (id integer primary key, name text)`,
-			);
-
-			const insertStmt = db.insert(users).values({ id: 1, name: 'John' }).prepare();
-			await insertStmt.execute();
+				const selectStmt = db.select().from(users).prepare();
+				const res = await selectStmt.execute();
 
-			const selectStmt = db.select().from(users).prepare();
-			const res = await selectStmt.execute();
+				expect(res).toEqual([{ id: 1, name: 'John' }]);
 
-			expect(res).toEqual([{ id: 1, name: 'John' }]);
-
-			const updateStmt = db.update(users).set({ name: 'John1' }).where(eq(users.id, 1)).prepare();
-			await updateStmt.execute();
+				const updateStmt = db
+					.update(users)
+					.set({ name: 'John1' })
+					.where(eq(users.id, 1))
+					.prepare();
+				await updateStmt.execute();
 
-			const res1 = await selectStmt.execute();
-
-			expect(res1).toEqual([{ id: 1, name: 'John1' }]);
+				const res1 = await selectStmt.execute();
 
-			const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
-			await deleteStmt.execute();
+				expect(res1).toEqual([{ id: 1, name: 'John1' }]);
 
-			const res2 = await selectStmt.execute();
+				const deleteStmt = db.delete(users).where(eq(users.id, 1)).prepare();
+				await deleteStmt.execute();
 
-			expect(res2).toEqual([]);
+				const res2 = await selectStmt.execute();
 
-			await db.run(sql`drop table ${users}`);
-		});
+				expect(res2).toEqual([]);
 
-		test('select + .get() for empty result', async (ctx) => {
-			const { db } = ctx.sqlite;
+				await db.run(sql`drop table ${users}`);
+			},
+		);
 
+		test.concurrent('select + .get() for empty result', async ({ db }) => {
 			const users = sqliteTable('users', {
 				id: integer('id').primaryKey(),
 				name: text('name'),
 			});
 
-			db.run(sql`drop table if exists ${users}`);
+			await db.run(sql`drop table if exists ${users}`);
 
-			db.run(
-				sql`create table ${users} (id integer primary key, name text)`,
-			);
+			await db.run(sql`create table ${users} (id integer primary key, name text)`);
 
 			const res = await db.select().from(users).where(eq(users.id, 1)).get();
 
@@ -2432,57 +3248,63 @@ export function tests() {
 			await db.run(sql`drop table ${users}`);
 		});
 
-		test('set operations (union) from query builder with subquery', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await setupSetOperationTest(db);
-
-			const sq = db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).union(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table),
-				).orderBy(asc(sql`name`)).as('sq');
-
-			const result = await db.select().from(sq).limit(5).offset(5);
-
-			expect(result).toHaveLength(5);
-
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 7, name: 'Mary' },
-				{ id: 1, name: 'New York' },
-				{ id: 4, name: 'Peter' },
-				{ id: 8, name: 'Sally' },
-			]);
+		test.concurrent(
+			'set operations (union) from query builder with subquery',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await expect(async () => {
-				db
-					.select({ name: citiesTable.name, id: citiesTable.id })
-					.from(citiesTable).union(
+				const sq = db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.union(
 						db
 							.select({ id: users2Table.id, name: users2Table.name })
 							.from(users2Table),
-					).orderBy(asc(sql`name`));
-			}).rejects.toThrowError();
-		});
+					)
+					.orderBy(asc(sql`name`))
+					.as('sq');
+
+				const result = await db.select().from(sq).limit(5).offset(5);
+
+				expect(result).toHaveLength(5);
+
+				expect(result).toEqual([
+					{ id: 2, name: 'London' },
+					{ id: 7, name: 'Mary' },
+					{ id: 1, name: 'New York' },
+					{ id: 4, name: 'Peter' },
+					{ id: 8, name: 'Sally' },
+				]);
 
-		test('set operations (union) as function', async (ctx) => {
-			const { db } = ctx.sqlite;
+				await expect(async () => {
+					await db.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable)
+						.union(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table),
+						)
+						.orderBy(asc(sql`name`));
+				}).rejects.toThrowError();
+			},
+		);
 
+		test.concurrent('set operations (union) as function', async ({ db }) => {
 			await setupSetOperationTest(db);
 
 			const result = await union(
 				db
 					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
 				db
 					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
 				db
 					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
 			).orderBy(asc(sql`name`));
 
 			expect(result).toHaveLength(2);
@@ -2496,191 +3318,217 @@ export function tests() {
 				union(
 					db
 						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
 					db
 						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 					db
 						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 				).orderBy(asc(sql`name`));
 			}).rejects.toThrowError();
 		});
 
-		test('set operations (union all) from query builder', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).unionAll(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable),
-				).orderBy(asc(citiesTable.id)).limit(5).offset(1);
-
-			expect(result).toHaveLength(5);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-				{ id: 3, name: 'Tampa' },
-			]);
+		test.concurrent(
+			'set operations (union all) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await expect(async () => {
-				db
+				const result = await db
 					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).unionAll(
+					.from(citiesTable)
+					.unionAll(
 						db
-							.select({ name: citiesTable.name, id: citiesTable.id })
+							.select({ id: citiesTable.id, name: citiesTable.name })
 							.from(citiesTable),
-					).orderBy(asc(citiesTable.id)).limit(5).offset(1);
-			}).rejects.toThrowError();
-		});
-
-		test('set operations (union all) as function', async (ctx) => {
-			const { db } = ctx.sqlite;
+					)
+					.orderBy(asc(citiesTable.id))
+					.limit(5)
+					.offset(1);
 
-			await setupSetOperationTest(db);
+				expect(result).toHaveLength(5);
 
-			const result = await unionAll(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 3, name: 'Tampa' },
+				]);
 
-			expect(result).toHaveLength(3);
+				await expect(async () => {
+					await db.select({ id: citiesTable.id, name: citiesTable.name })
+						.from(citiesTable)
+						.unionAll(
+							db
+								.select({ name: citiesTable.name, id: citiesTable.id })
+								.from(citiesTable),
+						)
+						.orderBy(asc(citiesTable.id))
+						.limit(5)
+						.offset(1);
+				}).rejects.toThrowError();
+			},
+		);
 
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 1, name: 'John' },
-				{ id: 1, name: 'John' },
-			]);
+		test.concurrent(
+			'set operations (union all) as function',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await expect(async () => {
-				unionAll(
+				const result = await unionAll(
 					db
 						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
 					db
 						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 				);
-			}).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) from query builder', async (ctx) => {
-			const { db } = ctx.sqlite;
 
-			await setupSetOperationTest(db);
+				expect(result).toHaveLength(3);
 
-			const result = await db
-				.select({ id: citiesTable.id, name: citiesTable.name })
-				.from(citiesTable).intersect(
-					db
-						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				).orderBy(asc(sql`name`));
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 1, name: 'John' },
+					{ id: 1, name: 'John' },
+				]);
 
-			expect(result).toHaveLength(2);
+				await expect(async () => {
+					unionAll(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.where(eq(citiesTable.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+					);
+				}).rejects.toThrowError();
+			},
+		);
 
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-			]);
+		test.concurrent(
+			'set operations (intersect) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await expect(async () => {
-				db
-					.select({ name: citiesTable.name, id: citiesTable.id })
-					.from(citiesTable).intersect(
+				const result = await db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable)
+					.intersect(
 						db
 							.select({ id: citiesTable.id, name: citiesTable.name })
-							.from(citiesTable).where(gt(citiesTable.id, 1)),
-					).orderBy(asc(sql`name`));
-			}).rejects.toThrowError();
-		});
-
-		test('set operations (intersect) as function', async (ctx) => {
-			const { db } = ctx.sqlite;
+							.from(citiesTable)
+							.where(gt(citiesTable.id, 1)),
+					)
+					.orderBy(asc(sql`name`));
 
-			await setupSetOperationTest(db);
+				expect(result).toHaveLength(2);
 
-			const result = await intersect(
-				db
-					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-			);
+				expect(result).toEqual([
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+				]);
 
-			expect(result).toHaveLength(0);
+				await expect(async () => {
+					await db.select({ name: citiesTable.name, id: citiesTable.id })
+						.from(citiesTable)
+						.intersect(
+							db
+								.select({ id: citiesTable.id, name: citiesTable.name })
+								.from(citiesTable)
+								.where(gt(citiesTable.id, 1)),
+						)
+						.orderBy(asc(sql`name`));
+				}).rejects.toThrowError();
+			},
+		);
 
-			expect(result).toEqual([]);
+		test.concurrent(
+			'set operations (intersect) as function',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await expect(async () => {
-				intersect(
+				const result = await intersect(
 					db
 						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
 					db
 						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-				);
-			}).rejects.toThrowError();
-		});
-
-		test('set operations (except) from query builder', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).except(
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 					db
-						.select()
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
+						.select({ id: users2Table.id, name: users2Table.name })
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 				);
 
-			expect(result).toHaveLength(1);
+				expect(result).toHaveLength(0);
 
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-			]);
+				expect(result).toEqual([]);
 
-			await expect(async () => {
-				db
-					.select()
-					.from(citiesTable).except(
+				await expect(async () => {
+					intersect(
+						db
+							.select({ id: citiesTable.id, name: citiesTable.name })
+							.from(citiesTable)
+							.where(eq(citiesTable.id, 1)),
 						db
 							.select({ name: users2Table.name, id: users2Table.id })
-							.from(citiesTable).where(gt(citiesTable.id, 1)),
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
 					);
-			}).rejects.toThrowError();
-		});
+				}).rejects.toThrowError();
+			},
+		);
+
+		test.concurrent(
+			'set operations (except) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-		test('set operations (except) as function', async (ctx) => {
-			const { db } = ctx.sqlite;
+				const result = await db
+					.select()
+					.from(citiesTable)
+					.except(db.select().from(citiesTable).where(gt(citiesTable.id, 1)));
+
+				expect(result).toHaveLength(1);
+
+				expect(result).toEqual([{ id: 1, name: 'New York' }]);
+
+				await expect(async () => {
+					await db.select()
+						.from(citiesTable)
+						.except(
+							db
+								.select({ name: users2Table.name, id: users2Table.id })
+								.from(citiesTable)
+								.where(gt(citiesTable.id, 1)),
+						);
+				}).rejects.toThrowError();
+			},
+		);
 
+		test.concurrent('set operations (except) as function', async ({ db }) => {
 			await setupSetOperationTest(db);
 
 			const result = await except(
@@ -2689,10 +3537,12 @@ export function tests() {
 					.from(citiesTable),
 				db
 					.select({ id: citiesTable.id, name: citiesTable.name })
-					.from(citiesTable).where(eq(citiesTable.id, 1)),
+					.from(citiesTable)
+					.where(eq(citiesTable.id, 1)),
 				db
 					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
+					.from(users2Table)
+					.where(eq(users2Table.id, 1)),
 			).orderBy(asc(sql`id`));
 
 			expect(result).toHaveLength(2);
@@ -2709,113 +3559,126 @@ export function tests() {
 						.from(citiesTable),
 					db
 						.select({ id: citiesTable.id, name: citiesTable.name })
-						.from(citiesTable).where(eq(citiesTable.id, 1)),
+						.from(citiesTable)
+						.where(eq(citiesTable.id, 1)),
 					db
 						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
 				).orderBy(asc(sql`id`));
 			}).rejects.toThrowError();
 		});
 
-		test('set operations (mixed) from query builder', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'set operations (mixed) from query builder',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			await setupSetOperationTest(db);
-
-			const result = await db
-				.select()
-				.from(citiesTable).except(
-					({ unionAll }) =>
+				const result = await db
+					.select()
+					.from(citiesTable)
+					.except(({ unionAll }) =>
 						unionAll(
-							db
-								.select()
-								.from(citiesTable).where(gt(citiesTable.id, 1)),
+							db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
 							db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-						),
-				);
+						)
+					);
 
-			expect(result).toHaveLength(2);
+				expect(result).toHaveLength(2);
 
-			expect(result).toEqual([
-				{ id: 1, name: 'New York' },
-				{ id: 2, name: 'London' },
-			]);
+				expect(result).toEqual([
+					{ id: 1, name: 'New York' },
+					{ id: 2, name: 'London' },
+				]);
 
-			await expect(async () => {
-				db
-					.select()
-					.from(citiesTable).except(
-						({ unionAll }) =>
+				await expect(async () => {
+					await db.select()
+						.from(citiesTable)
+						.except(({ unionAll }) =>
 							unionAll(
+								db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
 								db
-									.select()
-									.from(citiesTable).where(gt(citiesTable.id, 1)),
-								db.select({ name: citiesTable.name, id: citiesTable.id })
-									.from(citiesTable).where(eq(citiesTable.id, 2)),
-							),
-					);
-			}).rejects.toThrowError();
-		});
-
-		test('set operations (mixed all) as function with subquery', async (ctx) => {
-			const { db } = ctx.sqlite;
+									.select({ name: citiesTable.name, id: citiesTable.id })
+									.from(citiesTable)
+									.where(eq(citiesTable.id, 2)),
+							)
+						);
+				}).rejects.toThrowError();
+			},
+		);
 
-			await setupSetOperationTest(db);
+		test.concurrent(
+			'set operations (mixed all) as function with subquery',
+			async ({ db }) => {
+				await setupSetOperationTest(db);
 
-			const sq = union(
-				db
-					.select({ id: users2Table.id, name: users2Table.name })
-					.from(users2Table).where(eq(users2Table.id, 1)),
-				except(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(gte(users2Table.id, 5)),
+				const sq = union(
 					db
 						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 7)),
-				),
-				db
-					.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-			).orderBy(asc(sql`id`)).as('sq');
+						.from(users2Table)
+						.where(eq(users2Table.id, 1)),
+					except(
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(gte(users2Table.id, 5)),
+						db
+							.select({ id: users2Table.id, name: users2Table.name })
+							.from(users2Table)
+							.where(eq(users2Table.id, 7)),
+					),
+					db.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+				)
+					.orderBy(asc(sql`id`))
+					.as('sq');
 
-			const result = await db.select().from(sq).limit(4).offset(1);
+				const result = await db.select().from(sq).limit(4).offset(1);
 
-			expect(result).toHaveLength(4);
+				expect(result).toHaveLength(4);
 
-			expect(result).toEqual([
-				{ id: 2, name: 'London' },
-				{ id: 3, name: 'Tampa' },
-				{ id: 5, name: 'Ben' },
-				{ id: 6, name: 'Jill' },
-			]);
+				expect(result).toEqual([
+					{ id: 2, name: 'London' },
+					{ id: 3, name: 'Tampa' },
+					{ id: 5, name: 'Ben' },
+					{ id: 6, name: 'Jill' },
+				]);
 
-			await expect(async () => {
-				union(
-					db
-						.select({ id: users2Table.id, name: users2Table.name })
-						.from(users2Table).where(eq(users2Table.id, 1)),
-					except(
+				await expect(async () => {
+					union(
 						db
 							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table).where(gte(users2Table.id, 5)),
+							.from(users2Table)
+							.where(eq(users2Table.id, 1)),
+						except(
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(gte(users2Table.id, 5)),
+							db
+								.select({ id: users2Table.id, name: users2Table.name })
+								.from(users2Table)
+								.where(eq(users2Table.id, 7)),
+						),
 						db
-							.select({ id: users2Table.id, name: users2Table.name })
-							.from(users2Table).where(eq(users2Table.id, 7)),
-					),
-					db
-						.select({ name: users2Table.name, id: users2Table.id })
-						.from(citiesTable).where(gt(citiesTable.id, 1)),
-				).orderBy(asc(sql`id`));
-			}).rejects.toThrowError();
-		});
+							.select({ name: users2Table.name, id: users2Table.id })
+							.from(citiesTable)
+							.where(gt(citiesTable.id, 1)),
+					).orderBy(asc(sql`id`));
+				}).rejects.toThrowError();
+			},
+		);
 
-		test('define constraints as array', async (_ctx) => {
-			const table = sqliteTable('name', {
-				id: int(),
-			}, (t) => [
-				index('name').on(t.id),
-				primaryKey({ columns: [t.id], name: 'custom' }),
-			]);
+		test.concurrent('define constraints as array', async () => {
+			const table = sqliteTable(
+				'name',
+				{
+					id: int(),
+				},
+				(t) => [
+					index('name').on(t.id),
+					primaryKey({ columns: [t.id], name: 'custom' }),
+				],
+			);
 
 			const { indexes, primaryKeys } = getTableConfig(table);
 
@@ -2823,93 +3686,109 @@ export function tests() {
 			expect(primaryKeys.length).toBe(1);
 		});
 
-		test('define constraints as array inside third param', async (_ctx) => {
-			const table = sqliteTable('name', {
-				id: int(),
-			}, (t) => [
-				index('name').on(t.id),
-				primaryKey({ columns: [t.id], name: 'custom' }),
-			]);
+		test.concurrent(
+			'define constraints as array inside third param',
+			async () => {
+				const table = sqliteTable(
+					'name',
+					{
+						id: int(),
+					},
+					(t) => [
+						index('name').on(t.id),
+						primaryKey({ columns: [t.id], name: 'custom' }),
+					],
+				);
 
-			const { indexes, primaryKeys } = getTableConfig(table);
+				const { indexes, primaryKeys } = getTableConfig(table);
 
-			expect(indexes.length).toBe(1);
-			expect(primaryKeys.length).toBe(1);
-		});
+				expect(indexes.length).toBe(1);
+				expect(primaryKeys.length).toBe(1);
+			},
+		);
 
-		test('aggregate function: count', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('aggregate function: count', async ({ db }) => {
 			const table = aggregateTable;
 			await setupAggregateFunctionsTest(db);
 
 			const result1 = await db.select({ value: count() }).from(table);
 			const result2 = await db.select({ value: count(table.a) }).from(table);
-			const result3 = await db.select({ value: countDistinct(table.name) }).from(table);
+			const result3 = await db
+				.select({ value: countDistinct(table.name) })
+				.from(table);
 
 			expect(result1[0]?.value).toBe(7);
 			expect(result2[0]?.value).toBe(5);
 			expect(result3[0]?.value).toBe(6);
 		});
 
-		test('aggregate function: avg', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('aggregate function: avg', async ({ db }) => {
 			const table = aggregateTable;
 			await setupAggregateFunctionsTest(db);
 
 			const result1 = await db.select({ value: avg(table.a) }).from(table);
-			const result2 = await db.select({ value: avg(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: avgDistinct(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: avg(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: avgDistinct(table.b) })
+				.from(table);
 
 			expect(result1[0]?.value).toBe('24');
 			expect(result2[0]?.value).toBeNull();
 			expect(result3[0]?.value).toBe('42.5');
 		});
 
-		test('aggregate function: sum', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('aggregate function: sum', async ({ db }) => {
 			const table = aggregateTable;
 			await setupAggregateFunctionsTest(db);
 
 			const result1 = await db.select({ value: sum(table.b) }).from(table);
-			const result2 = await db.select({ value: sum(table.nullOnly) }).from(table);
-			const result3 = await db.select({ value: sumDistinct(table.b) }).from(table);
+			const result2 = await db
+				.select({ value: sum(table.nullOnly) })
+				.from(table);
+			const result3 = await db
+				.select({ value: sumDistinct(table.b) })
+				.from(table);
 
 			expect(result1[0]?.value).toBe('200');
 			expect(result2[0]?.value).toBeNull();
 			expect(result3[0]?.value).toBe('170');
 		});
 
-		test('aggregate function: max', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('aggregate function: max', async ({ db }) => {
 			const table = aggregateTable;
 			await setupAggregateFunctionsTest(db);
 
 			const result1 = await db.select({ value: max(table.b) }).from(table);
-			const result2 = await db.select({ value: max(table.nullOnly) }).from(table);
+			const result2 = await db
+				.select({ value: max(table.nullOnly) })
+				.from(table);
 
 			expect(result1[0]?.value).toBe(90);
 			expect(result2[0]?.value).toBeNull();
 		});
 
-		test('aggregate function: min', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('aggregate function: min', async ({ db }) => {
 			const table = aggregateTable;
 			await setupAggregateFunctionsTest(db);
 
 			const result1 = await db.select({ value: min(table.b) }).from(table);
-			const result2 = await db.select({ value: min(table.nullOnly) }).from(table);
+			const result2 = await db
+				.select({ value: min(table.nullOnly) })
+				.from(table);
 
 			expect(result1[0]?.value).toBe(10);
 			expect(result2[0]?.value).toBeNull();
 		});
 
-		test('test $onUpdateFn and $onUpdate works as $default', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works as $default',
+			async ({ db }) => {
+				await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
-			await db.run(sql`drop table if exists ${usersOnUpdate}`);
-
-			await db.run(
-				sql`
+				await db.run(
+					sql`
 					create table ${usersOnUpdate} (
 					id integer primary key autoincrement,
 					name text not null,
@@ -2918,40 +3797,51 @@ export function tests() {
 					always_null text
 					)
 				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
-
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
-
-			expect(response).toEqual([
-				{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
-			]);
-			const msDelay = 250;
+				);
 
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
+				await db
+					.insert(usersOnUpdate)
+					.values([
+						{ name: 'John' },
+						{ name: 'Jane' },
+						{ name: 'Jack' },
+						{ name: 'Jill' },
+					]);
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+				const justDates = await db
+					.select({ updatedAt })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				const response = await db
+					.select({ ...rest })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{ name: 'John', id: 1, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jane', id: 2, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+				]);
+				const msDelay = 1000;
 
-		test('test $onUpdateFn and $onUpdate works updating', async (ctx) => {
-			const { db } = ctx.sqlite;
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
 
-			await db.run(sql`drop table if exists ${usersOnUpdate}`);
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works updating',
+			async ({ db }) => {
+				await db.run(sql`drop table if exists ${usersOnUpdate}`);
 
-			await db.run(
-				sql`
+				await db.run(
+					sql`
 					create table ${usersOnUpdate} (
 					id integer primary key autoincrement,
 					name text not null,
@@ -2960,39 +3850,104 @@ export function tests() {
 					always_null text
 					)
 				`,
-			);
-
-			await db.insert(usersOnUpdate).values([
-				{ name: 'John', alwaysNull: 'this will be null after updating' },
-				{ name: 'Jane' },
-				{ name: 'Jack' },
-				{ name: 'Jill' },
-			]);
-			const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+				);
 
-			await db.update(usersOnUpdate).set({ name: 'Angel' }).where(eq(usersOnUpdate.id, 1));
-			await db.update(usersOnUpdate).set({ updateCounter: null }).where(eq(usersOnUpdate.id, 2));
+				await db
+					.insert(usersOnUpdate)
+					.values([
+						{ name: 'John', alwaysNull: 'this will be null after updating' },
+						{ name: 'Jane' },
+						{ name: 'Jack' },
+						{ name: 'Jill' },
+					]);
+				const { updatedAt, ...rest } = getTableColumns(usersOnUpdate);
+
+				await db
+					.update(usersOnUpdate)
+					.set({ name: 'Angel' })
+					.where(eq(usersOnUpdate.id, 1));
+				await db
+					.update(usersOnUpdate)
+					.set({ updateCounter: null })
+					.where(eq(usersOnUpdate.id, 2));
+
+				const justDates = await db
+					.select({ updatedAt })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				const response = await db
+					.select({ ...rest })
+					.from(usersOnUpdate)
+					.orderBy(asc(usersOnUpdate.id));
+
+				expect(response).toEqual([
+					{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
+					{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
+					{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
+					{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
+				]);
+				const msDelay = 1000;
 
-			const justDates = await db.select({ updatedAt }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+				for (const eachUser of justDates) {
+					expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(
+						Date.now() - msDelay,
+					);
+				}
+			},
+		);
 
-			const response = await db.select({ ...rest }).from(usersOnUpdate).orderBy(asc(usersOnUpdate.id));
+		test.concurrent(
+			'test $onUpdateFn and $onUpdate works with sql value',
+			async ({ db }) => {
+				const users = sqliteTable('users_on_update', {
+					id: integer('id').primaryKey({ autoIncrement: true }),
+					name: text('name').notNull(),
+					updatedAt: integer('updated_at')
+						.notNull()
+						.$onUpdate(
+							() => sql`(strftime('%s', 'now') * 1000) + (strftime('%f', 'now') - strftime('%S', 'now')) * 1000`,
+						),
+				});
 
-			expect(response).toEqual([
-				{ name: 'Angel', id: 1, updateCounter: 2, alwaysNull: null },
-				{ name: 'Jane', id: 2, updateCounter: null, alwaysNull: null },
-				{ name: 'Jack', id: 3, updateCounter: 1, alwaysNull: null },
-				{ name: 'Jill', id: 4, updateCounter: 1, alwaysNull: null },
-			]);
-			const msDelay = 250;
+				await db.run(sql`drop table if exists ${users}`);
+				await db.run(
+					sql`
+					create table ${users} (
+						\`id\` integer primary key autoincrement,
+						\`name\` text not null,
+						\`updated_at\` integer not null
+					)
+				`,
+				);
 
-			for (const eachUser of justDates) {
-				expect(eachUser.updatedAt!.valueOf()).toBeGreaterThan(Date.now() - msDelay);
-			}
-		});
+				const insertResp = await db
+					.insert(users)
+					.values({
+						name: 'John',
+					})
+					.returning({
+						updatedAt: users.updatedAt,
+					});
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+
+				const now = Date.now();
+				await new Promise((resolve) => setTimeout(resolve, 1000));
+				const updateResp = await db
+					.update(users)
+					.set({
+						name: 'John',
+					})
+					.returning({
+						updatedAt: users.updatedAt,
+					});
 
-		test('$count separate', async (ctx) => {
-			const { db } = ctx.sqlite;
+				expect(insertResp[0]?.updatedAt ?? 0).lessThan(now);
+				expect(updateResp[0]?.updatedAt ?? 0).greaterThan(now);
+			},
+		);
 
+		test.concurrent('$count separate', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3015,9 +3970,7 @@ export function tests() {
 			expect(count).toStrictEqual(4);
 		});
 
-		test('$count embedded', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('$count embedded', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3033,9 +3986,11 @@ export function tests() {
 				{ id: 4, name: 'Fourth' },
 			]);
 
-			const count = await db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
+			const count = await db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
 
 			await db.run(sql`drop table ${countTestTable}`);
 
@@ -3047,9 +4002,7 @@ export function tests() {
 			]);
 		});
 
-		test('$count separate reuse', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('$count separate reuse', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3084,9 +4037,7 @@ export function tests() {
 			expect(count3).toStrictEqual(6);
 		});
 
-		test('$count embedded reuse', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('$count embedded reuse', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3102,9 +4053,11 @@ export function tests() {
 				{ id: 4, name: 'Fourth' },
 			]);
 
-			const count = db.select({
-				count: db.$count(countTestTable),
-			}).from(countTestTable);
+			const count = db
+				.select({
+					count: db.$count(countTestTable),
+				})
+				.from(countTestTable);
 
 			const count1 = await count;
 
@@ -3141,9 +4094,7 @@ export function tests() {
 			]);
 		});
 
-		test('$count separate with filters', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('$count separate with filters', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3166,9 +4117,7 @@ export function tests() {
 			expect(count).toStrictEqual(3);
 		});
 
-		test('$count embedded with filters', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('$count embedded with filters', async ({ db }) => {
 			const countTestTable = sqliteTable('count_test', {
 				id: int('id').notNull(),
 				name: text('name').notNull(),
@@ -3184,9 +4133,11 @@ export function tests() {
 				{ id: 4, name: 'Fourth' },
 			]);
 
-			const count = await db.select({
-				count: db.$count(countTestTable, gt(countTestTable.id, 1)),
-			}).from(countTestTable);
+			const count = await db
+				.select({
+					count: db.$count(countTestTable, gt(countTestTable.id, 1)),
+				})
+				.from(countTestTable);
 
 			await db.run(sql`drop table ${countTestTable}`);
 
@@ -3198,20 +4149,23 @@ export function tests() {
 			]);
 		});
 
-		test('update with limit and order by', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('update with limit and order by', async ({ db }) => {
 			await db.insert(usersTable).values([
 				{ name: 'Barry', verified: false },
 				{ name: 'Alan', verified: false },
 				{ name: 'Carl', verified: false },
 			]);
 
-			await db.update(usersTable).set({ verified: true }).limit(2).orderBy(asc(usersTable.name));
+			await db
+				.update(usersTable)
+				.set({ verified: true })
+				.limit(2)
+				.orderBy(asc(usersTable.name));
 
-			const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
-				asc(usersTable.name),
-			);
+			const result = await db
+				.select({ name: usersTable.name, verified: usersTable.verified })
+				.from(usersTable)
+				.orderBy(asc(usersTable.name));
 
 			expect(result).toStrictEqual([
 				{ name: 'Alan', verified: true },
@@ -3220,42 +4174,35 @@ export function tests() {
 			]);
 		});
 
-		test('delete with limit and order by', async (ctx) => {
-			const { db } = ctx.sqlite;
-
+		test.concurrent('delete with limit and order by', async ({ db }) => {
 			await db.insert(usersTable).values([
 				{ name: 'Barry', verified: false },
 				{ name: 'Alan', verified: false },
 				{ name: 'Carl', verified: false },
 			]);
 
-			await db.delete(usersTable).where(eq(usersTable.verified, false)).limit(1).orderBy(asc(usersTable.name));
+			await db
+				.delete(usersTable)
+				.where(eq(usersTable.verified, false))
+				.limit(1)
+				.orderBy(asc(usersTable.name));
 
-			const result = await db.select({ name: usersTable.name, verified: usersTable.verified }).from(usersTable).orderBy(
-				asc(usersTable.name),
-			);
+			const result = await db
+				.select({ name: usersTable.name, verified: usersTable.verified })
+				.from(usersTable)
+				.orderBy(asc(usersTable.name));
 			expect(result).toStrictEqual([
 				{ name: 'Barry', verified: false },
 				{ name: 'Carl', verified: false },
 			]);
 		});
 
-		test('cross join', async (ctx) => {
-			const { db } = ctx.sqlite;
-
-			await db
-				.insert(usersTable)
-				.values([
-					{ name: 'John' },
-					{ name: 'Jane' },
-				]);
+		test.concurrent('cross join', async ({ db }) => {
+			await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
 
 			await db
 				.insert(citiesTable)
-				.values([
-					{ name: 'Seattle' },
-					{ name: 'New York City' },
-				]);
+				.values([{ name: 'Seattle' }, { name: 'New York City' }]);
 
 			const result = await db
 				.select({
@@ -3274,9 +4221,1049 @@ export function tests() {
 			]);
 		});
 
-		test('all types', async (ctx) => {
-			const { db } = ctx.sqlite;
+		test.concurrent('RQB v2 simple find first - no rows', async ({ db }) => {
+			try {
+				await init(db);
+
+				const result = await db.query.rqbUser.findFirst();
+
+				expect(result).toStrictEqual(undefined);
+			} finally {
+				await clear(db);
+			}
+		});
+
+		test.concurrent(
+			'RQB v2 simple find first - multiple rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					const result = await db.query.rqbUser.findFirst({
+						orderBy: {
+							id: 'desc',
+						},
+					});
+
+					expect(result).toStrictEqual({
+						id: 2,
+						createdAt: date,
+						name: 'Second',
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 simple find first - with relation',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.insert(rqbPost).values([
+						{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+						},
+						{
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+						},
+					]);
+
+					const result = await db.query.rqbUser.findFirst({
+						with: {
+							posts: {
+								orderBy: {
+									id: 'asc',
+								},
+							},
+						},
+						orderBy: {
+							id: 'asc',
+						},
+					});
+
+					expect(result).toStrictEqual({
+						id: 1,
+						createdAt: date,
+						name: 'First',
+						posts: [
+							{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+							},
+							{
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+							},
+						],
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 simple find first - placeholders',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					const query = db.query.rqbUser
+						.findFirst({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						})
+						.prepare();
+
+					const result = await query.execute({
+						filter: 2,
+					});
+
+					expect(result).toStrictEqual({
+						id: 2,
+						createdAt: date,
+						name: 'Second',
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent('RQB v2 simple find many - no rows', async ({ db }) => {
+			try {
+				await init(db);
+
+				const result = await db.query.rqbUser.findMany();
+
+				expect(result).toStrictEqual([]);
+			} finally {
+				await clear(db);
+			}
+		});
+
+		test.concurrent(
+			'RQB v2 simple find many - multiple rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					const result = await db.query.rqbUser.findMany({
+						orderBy: {
+							id: 'desc',
+						},
+					});
+
+					expect(result).toStrictEqual([
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+					]);
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 simple find many - with relation',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.insert(rqbPost).values([
+						{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+						},
+						{
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+						},
+					]);
+
+					const result = await db.query.rqbPost.findMany({
+						with: {
+							author: true,
+						},
+						orderBy: {
+							id: 'asc',
+						},
+					});
+
+					expect(result).toStrictEqual([
+						{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						},
+						{
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+							author: {
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						},
+					]);
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		// https://github.com/drizzle-team/drizzle-orm/issues/5323
+		test.concurrent(
+			'RQB v2 simple find many - with text pks',
+			async ({ createDB, push }) => {
+				const dmsGroups = sqliteTable('dms_groups', {
+					id: text()
+						.primaryKey()
+						.$defaultFn(() => crypto.randomUUID()),
+					name: text().notNull(),
+					sort: int().notNull().default(99),
+				});
+
+				const dmsDocuments = sqliteTable('dms_documents', {
+					id: text()
+						.primaryKey()
+						.$defaultFn(() => crypto.randomUUID()),
+					name: text().notNull(),
+					groupId: text().references(() => dmsGroups.id, {
+						onDelete: 'set null',
+					}),
+				});
+
+				const schema = { dmsGroups, dmsDocuments };
+
+				const db = createDB(schema, (r) => ({
+					dmsGroups: {
+						documents: r.many.dmsDocuments(),
+					},
+					dmsDocuments: {
+						group: r.one.dmsGroups({
+							from: r.dmsDocuments.groupId,
+							to: r.dmsGroups.id,
+						}),
+					},
+				}));
+
+				try {
+					await push(schema);
+					const groupId = '230a2c2f-59b3-4b64-98f3-d521020bc99c';
+					await db.insert(dmsGroups).values({ id: groupId, name: 'group1' });
+
+					await db.insert(dmsDocuments).values({
+						id: '6fba1c11-3342-411f-a5ef-e6faf2aa95ec',
+						name: 'document1',
+						groupId,
+					});
+
+					const query = db.query.dmsGroups.findMany({
+						with: {
+							documents: true,
+						},
+						orderBy: (group) => [asc(group.sort)],
+					});
+
+					const groups = await query;
+
+					const expectedGroups = [
+						{
+							id: '230a2c2f-59b3-4b64-98f3-d521020bc99c',
+							name: 'group1',
+							sort: 99,
+							documents: [
+								{
+									id: '6fba1c11-3342-411f-a5ef-e6faf2aa95ec',
+									name: 'document1',
+									groupId: '230a2c2f-59b3-4b64-98f3-d521020bc99c',
+								},
+							],
+						},
+					];
+					expect(groups).toStrictEqual(expectedGroups);
+				} finally {
+					try {
+						await db.run(sql`DROP TABLE IF EXISTS ${dmsDocuments};`);
+					} catch {
+						null;
+					}
+					try {
+						await db.run(sql`DROP TABLE IF EXISTS ${dmsGroups};`);
+					} catch {
+						null;
+					}
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 simple find many - placeholders',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					const query = db.query.rqbUser
+						.findMany({
+							where: {
+								id: {
+									eq: sql.placeholder('filter'),
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						})
+						.prepare();
+
+					const result = await query.execute({
+						filter: 2,
+					});
+
+					expect(result).toStrictEqual([
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find first - no rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbUser.findFirst();
+
+						expect(result).toStrictEqual(undefined);
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find first - multiple rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbUser.findFirst({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find first - with relation',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.insert(rqbPost).values([
+						{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+						},
+						{
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbUser.findFirst({
+							with: {
+								posts: {
+									orderBy: {
+										id: 'asc',
+									},
+								},
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual({
+							id: 1,
+							createdAt: date,
+							name: 'First',
+							posts: [
+								{
+									id: 1,
+									userId: 1,
+									createdAt: date,
+									content: null,
+								},
+								{
+									id: 2,
+									userId: 1,
+									createdAt: date,
+									content: 'Has message this time',
+								},
+							],
+						});
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find first - placeholders',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const query = db.query.rqbUser
+							.findFirst({
+								where: {
+									id: {
+										eq: sql.placeholder('filter'),
+									},
+								},
+								orderBy: {
+									id: 'asc',
+								},
+							})
+							.prepare();
+
+						const result = await query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual({
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						});
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find many - no rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbUser.findMany();
+
+						expect(result).toStrictEqual([]);
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find many - multiple rows',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbUser.findMany({
+							orderBy: {
+								id: 'desc',
+							},
+						});
+
+						expect(result).toStrictEqual([
+							{
+								id: 2,
+								createdAt: date,
+								name: 'Second',
+							},
+							{
+								id: 1,
+								createdAt: date,
+								name: 'First',
+							},
+						]);
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find many - with relation',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.insert(rqbPost).values([
+						{
+							id: 1,
+							userId: 1,
+							createdAt: date,
+							content: null,
+						},
+						{
+							id: 2,
+							userId: 1,
+							createdAt: date,
+							content: 'Has message this time',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const result = await db.query.rqbPost.findMany({
+							with: {
+								author: true,
+							},
+							orderBy: {
+								id: 'asc',
+							},
+						});
+
+						expect(result).toStrictEqual([
+							{
+								id: 1,
+								userId: 1,
+								createdAt: date,
+								content: null,
+								author: {
+									id: 1,
+									createdAt: date,
+									name: 'First',
+								},
+							},
+							{
+								id: 2,
+								userId: 1,
+								createdAt: date,
+								content: 'Has message this time',
+								author: {
+									id: 1,
+									createdAt: date,
+									name: 'First',
+								},
+							},
+						]);
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent(
+			'RQB v2 transaction find many - placeholders',
+			async ({ db }) => {
+				try {
+					await init(db);
+
+					const date = new Date(120000);
+
+					await db.insert(rqbUser).values([
+						{
+							id: 1,
+							createdAt: date,
+							name: 'First',
+						},
+						{
+							id: 2,
+							createdAt: date,
+							name: 'Second',
+						},
+					]);
+
+					await db.transaction(async (db) => {
+						const query = db.query.rqbUser
+							.findMany({
+								where: {
+									id: {
+										eq: sql.placeholder('filter'),
+									},
+								},
+								orderBy: {
+									id: 'asc',
+								},
+							})
+							.prepare();
+
+						const result = await query.execute({
+							filter: 2,
+						});
+
+						expect(result).toStrictEqual([
+							{
+								id: 2,
+								createdAt: date,
+								name: 'Second',
+							},
+						]);
+					});
+				} finally {
+					await clear(db);
+				}
+			},
+		);
+
+		test.concurrent('limit 0', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(0);
+
+			expect(users).toEqual([]);
+		});
+
+		test.concurrent('limit -1', async ({ db }) => {
+			await db.insert(usersTable).values({ name: 'John' });
+			const users = await db.select().from(usersTable).limit(-1);
+
+			expect(users.length).toBeGreaterThan(0);
+		});
+
+		test.concurrent('column.as', async ({ db }) => {
+			const users = sqliteTable('users_column_as', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+				cityId: integer('city_id').references(() => cities.id),
+			});
+
+			const cities = sqliteTable('cities_column_as', {
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+			});
+
+			const ucView = sqliteView('cities_users_column_as_view').as((qb) =>
+				qb
+					.select({
+						userId: users.id.as('user_id'),
+						cityId: cities.id.as('city_id'),
+						userName: users.name.as('user_name'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.cityId))
+			);
+
+			try {
+				await db.run(sql`CREATE TABLE IF NOT EXISTS ${cities} (
+				\`id\` INTEGER PRIMARY KEY,
+				\`name\` TEXT NOT NULL
+			);`);
+
+				await db.run(sql`CREATE TABLE IF NOT EXISTS ${users} (
+				\`id\` INTEGER PRIMARY KEY,
+				\`name\` TEXT NOT NULL,
+				\`city_id\`  INTEGER REFERENCES ${cities}(\`id\`) 
+			);`);
+
+				await db.run(
+					sql`CREATE VIEW IF NOT EXISTS ${ucView} AS SELECT ${users.id} as \`user_id\`, ${cities.id} as \`city_id\`, ${users.name} as \`user_name\`, ${cities.name} as \`city_name\` FROM ${users} LEFT JOIN ${cities} ON ${
+						eq(
+							cities.id,
+							users.cityId,
+						)
+					};`,
+				);
+
+				const citiesInsRet = await db
+					.insert(cities)
+					.values([
+						{
+							id: 1,
+							name: 'Firstistan',
+						},
+						{
+							id: 2,
+							name: 'Secondaria',
+						},
+					])
+					.returning({
+						cityId: cities.id.as('city_id'),
+						cityName: cities.name.as('city_name'),
+					});
+
+				expect(citiesInsRet).toStrictEqual(
+					expect.arrayContaining([
+						{
+							cityId: 1,
+							cityName: 'Firstistan',
+						},
+						{
+							cityId: 2,
+							cityName: 'Secondaria',
+						},
+					]),
+				);
+
+				const usersInsRet = await db
+					.insert(users)
+					.values([
+						{ id: 1, name: 'First', cityId: 1 },
+						{
+							id: 2,
+							name: 'Second',
+							cityId: 2,
+						},
+						{
+							id: 3,
+							name: 'Third',
+						},
+					])
+					.returning({
+						userId: users.id.as('user_id'),
+						userName: users.name.as('users_name'),
+						userCityId: users.cityId,
+					});
+
+				expect(usersInsRet).toStrictEqual(
+					expect.arrayContaining([
+						{ userId: 1, userName: 'First', userCityId: 1 },
+						{
+							userId: 2,
+							userName: 'Second',
+							userCityId: 2,
+						},
+						{
+							userId: 3,
+							userName: 'Third',
+							userCityId: null,
+						},
+					]),
+				);
+
+				const joinSelectReturn = await db
+					.select({
+						userId: users.id.as('user_id'),
+						cityId: cities.id.as('city_id'),
+						userName: users.name.as('user_name'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(users)
+					.leftJoin(cities, eq(cities.id, users.cityId));
+
+				expect(joinSelectReturn).toStrictEqual(
+					expect.arrayContaining([
+						{
+							userId: 1,
+							userName: 'First',
+							cityId: 1,
+							cityName: 'Firstistan',
+						},
+						{
+							userId: 2,
+							userName: 'Second',
+							cityId: 2,
+							cityName: 'Secondaria',
+						},
+						{
+							userId: 3,
+							userName: 'Third',
+							cityId: null,
+							cityName: null,
+						},
+					]),
+				);
+
+				const viewSelectReturn = await db.select().from(ucView);
+
+				expect(viewSelectReturn).toStrictEqual(
+					expect.arrayContaining([
+						{
+							userId: 1,
+							userName: 'First',
+							cityId: 1,
+							cityName: 'Firstistan',
+						},
+						{
+							userId: 2,
+							userName: 'Second',
+							cityId: 2,
+							cityName: 'Secondaria',
+						},
+						{
+							userId: 3,
+							userName: 'Third',
+							cityId: null,
+							cityName: null,
+						},
+					]),
+				);
+
+				const viewJoinReturn = await db
+					.select({
+						userId: ucView.userId.as('user_id_ucv'),
+						cityId: cities.id.as('city_id'),
+						userName: ucView.userName.as('user_name_ucv'),
+						cityName: cities.name.as('city_name'),
+					})
+					.from(ucView)
+					.leftJoin(cities, eq(cities.id, ucView.cityId));
+
+				expect(viewJoinReturn).toStrictEqual(
+					expect.arrayContaining([
+						{
+							userId: 1,
+							userName: 'First',
+							cityId: 1,
+							cityName: 'Firstistan',
+						},
+						{
+							userId: 2,
+							userName: 'Second',
+							cityId: 2,
+							cityName: 'Secondaria',
+						},
+						{
+							userId: 3,
+							userName: 'Third',
+							cityId: null,
+							cityName: null,
+						},
+					]),
+				);
+			} finally {
+				await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+				await db.run(sql`DROP TABLE IF EXISTS ${cities};`);
+				await db.run(sql`DROP VIEW IF EXISTS ${ucView};`);
+			}
+		});
 
+		test.concurrent('all types', async ({ db }) => {
 			await db.run(sql`
 				CREATE TABLE \`all_types\`(
 					\`int\` integer,
@@ -3308,7 +5295,7 @@ export function tests() {
 					0x69,
 					0x72,
 					0x20,
-					0x6F,
+					0x6f,
 					0x20,
 					0x64,
 					0x65,
@@ -3317,9 +5304,9 @@ export function tests() {
 					0x61,
 					0x69,
 					0x72,
-					0x2E,
-					0x2E,
-					0x2E,
+					0x2e,
+					0x2e,
+					0x2e,
 				]),
 				json: {
 					str: 'strval',
@@ -3374,7 +5361,7 @@ export function tests() {
 						0x69,
 						0x72,
 						0x20,
-						0x6F,
+						0x6f,
 						0x20,
 						0x64,
 						0x65,
@@ -3383,9 +5370,9 @@ export function tests() {
 						0x61,
 						0x69,
 						0x72,
-						0x2E,
-						0x2E,
-						0x2E,
+						0x2e,
+						0x2e,
+						0x2e,
 					]),
 					json: { str: 'strval', arr: ['str', 10] },
 					numeric: '475452353476',
@@ -3402,32 +5389,53 @@ export function tests() {
 		});
 	});
 
-	test('table configs: unique third param', () => {
-		const cities1Table = sqliteTable('cities1', {
-			id: int('id').primaryKey(),
-			name: text('name').notNull(),
-			state: text('state'),
-		}, (t) => ({
-			f: unique().on(t.name, t.state),
-			f1: unique('custom').on(t.name, t.state),
-		}));
+	test.concurrent('sql.identifier escape', async () => {
+		const dialect = new SQLiteDialect();
+		const userInput = 'id" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--';
+		const query = sql`SELECT * FROM ${sql.identifier('users')} ORDER BY ${sql.identifier(userInput)} ASC`;
+		const str = dialect.sqlToQuery(query);
+		expect(str.sql).toBe(
+			'SELECT * FROM "users" ORDER BY "id"" ASC, CAST((SELECT password_hash FROM users LIMIT 1) AS int)--" ASC',
+		);
+	});
+
+	test.concurrent('table configs: unique third param', () => {
+		const cities1Table = sqliteTable(
+			'cities1',
+			{
+				id: int('id').primaryKey(),
+				name: text('name').notNull(),
+				state: text('state'),
+			},
+			(t) => [
+				unique().on(t.name, t.state),
+				unique('custom').on(t.name, t.state),
+			],
+		);
 
 		const tableConfig = getTableConfig(cities1Table);
 
 		expect(tableConfig.uniqueConstraints).toHaveLength(2);
 
-		expect(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
 		expect(
-			tableConfig.uniqueConstraints[0]?.name,
-		).toEqual(
-			uniqueKeyName(cities1Table, tableConfig.uniqueConstraints[0]?.columns?.map((column) => column.name) ?? []),
+			tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name),
+		).toEqual(['name', 'state']);
+		expect(tableConfig.uniqueConstraints[0]?.name).toEqual(
+			uniqueKeyName(
+				cities1Table,
+				tableConfig.uniqueConstraints[0]?.columns?.map(
+					(column) => column.name,
+				) ?? [],
+			),
 		);
 
-		expect(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name)).toEqual(['name', 'state']);
+		expect(
+			tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name),
+		).toEqual(['name', 'state']);
 		expect(tableConfig.uniqueConstraints[1]?.name).toBe('custom');
 	});
 
-	test('table configs: unique in column', () => {
+	test.concurrent('table configs: unique in column', () => {
 		const cities1Table = sqliteTable('cities1', {
 			id: int('id').primaryKey(),
 			name: text('name').notNull().unique(),
@@ -3439,7 +5447,7 @@ export function tests() {
 
 		const columnName = tableConfig.columns.find((it) => it.name === 'name');
 		expect(columnName?.isUnique).toBeTruthy();
-		expect(columnName?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnName!.name]));
+		expect(columnName?.uniqueName).toBe(undefined);
 
 		const columnState = tableConfig.columns.find((it) => it.name === 'state');
 		expect(columnState?.isUnique).toBeTruthy();
@@ -3447,36 +5455,10 @@ export function tests() {
 
 		const columnField = tableConfig.columns.find((it) => it.name === 'field');
 		expect(columnField?.isUnique).toBeTruthy();
-		expect(columnField?.uniqueName).toBe(uniqueKeyName(cities1Table, [columnField!.name]));
-	});
-
-	test('limit 0', async (ctx) => {
-		const { db } = ctx.sqlite;
-
-		await db.insert(usersTable).values({ name: 'John' });
-		const users = await db
-			.select()
-			.from(usersTable)
-			.limit(0);
-
-		expect(users).toEqual([]);
-	});
-
-	test('limit -1', async (ctx) => {
-		const { db } = ctx.sqlite;
-
-		await db.insert(usersTable).values({ name: 'John' });
-		const users = await db
-			.select()
-			.from(usersTable)
-			.limit(-1);
-
-		expect(users.length).toBeGreaterThan(0);
+		expect(columnField?.uniqueName).toBe(undefined);
 	});
 
-	test('update ... from', async (ctx) => {
-		const { db } = ctx.sqlite;
-
+	test.concurrent('update ... from', async ({ db }) => {
 		await db.run(sql`drop table if exists \`cities\``);
 		await db.run(sql`drop table if exists \`users2\``);
 		await db.run(sql`
@@ -3493,10 +5475,9 @@ export function tests() {
 			)
 		`);
 
-		await db.insert(citiesTable).values([
-			{ name: 'New York City' },
-			{ name: 'Seattle' },
-		]);
+		await db
+			.insert(citiesTable)
+			.values([{ name: 'New York City' }, { name: 'Seattle' }]);
 		await db.insert(users2Table).values([
 			{ name: 'John', cityId: 1 },
 			{ name: 'Jane', cityId: 2 },
@@ -3511,16 +5492,16 @@ export function tests() {
 			.where(and(eq(citiesTable.name, 'Seattle'), eq(users2Table.name, 'John')))
 			.returning();
 
-		expect(result).toStrictEqual([{
-			id: 1,
-			name: 'John',
-			cityId: 2,
-		}]);
+		expect(result).toStrictEqual([
+			{
+				id: 1,
+				name: 'John',
+				cityId: 2,
+			},
+		]);
 	});
 
-	test('update ... from with alias', async (ctx) => {
-		const { db } = ctx.sqlite;
-
+	test.concurrent('update ... from with alias', async ({ db }) => {
 		await db.run(sql`drop table if exists \`users2\``);
 		await db.run(sql`drop table if exists \`cities\``);
 		await db.run(sql`
@@ -3537,10 +5518,9 @@ export function tests() {
 			)
 		`);
 
-		await db.insert(citiesTable).values([
-			{ name: 'New York City' },
-			{ name: 'Seattle' },
-		]);
+		await db
+			.insert(citiesTable)
+			.values([{ name: 'New York City' }, { name: 'Seattle' }]);
 		await db.insert(users2Table).values([
 			{ name: 'John', cityId: 1 },
 			{ name: 'Jane', cityId: 2 },
@@ -3556,18 +5536,18 @@ export function tests() {
 			.where(and(eq(cities.name, 'Seattle'), eq(users2Table.name, 'John')))
 			.returning();
 
-		expect(result).toStrictEqual([{
-			id: 1,
-			name: 'John',
-			cityId: 2,
-		}]);
-
+		expect(result).toStrictEqual([
+			{
+				id: 1,
+				name: 'John',
+				cityId: 2,
+			},
+		]);
+
 		await db.run(sql`drop table if exists \`users2\``);
 	});
 
-	test('update ... from with join', async (ctx) => {
-		const { db } = ctx.sqlite;
-
+	test.concurrent('update ... from with join', async ({ db }) => {
 		const states = sqliteTable('states', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
@@ -3580,7 +5560,9 @@ export function tests() {
 		const users = sqliteTable('users', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
-			cityId: integer('city_id').notNull().references(() => cities.id),
+			cityId: integer('city_id')
+				.notNull()
+				.references(() => cities.id),
 		});
 
 		await db.run(sql`drop table if exists \`states\``);
@@ -3607,15 +5589,16 @@ export function tests() {
 			)
 		`);
 
-		await db.insert(states).values([
-			{ name: 'New York' },
-			{ name: 'Washington' },
-		]);
-		await db.insert(cities).values([
-			{ name: 'New York City', stateId: 1 },
-			{ name: 'Seattle', stateId: 2 },
-			{ name: 'London' },
-		]);
+		await db
+			.insert(states)
+			.values([{ name: 'New York' }, { name: 'Washington' }]);
+		await db
+			.insert(cities)
+			.values([
+				{ name: 'New York City', stateId: 1 },
+				{ name: 'Seattle', stateId: 2 },
+				{ name: 'London' },
+			]);
 		await db.insert(users).values([
 			{ name: 'John', cityId: 1 },
 			{ name: 'Jane', cityId: 2 },
@@ -3641,36 +5624,46 @@ export function tests() {
 			.where(and(eq(cities.name, 'London'), eq(users.name, 'Jack')))
 			.returning();
 
-		expect(result1).toStrictEqual([{
-			id: 1,
-			name: 'John',
-			cityId: 2,
-		}]);
-		expect(result2).toStrictEqual([{
-			id: 3,
-			name: 'Jack',
-			cityId: 3,
-		}]);
+		expect(result1).toStrictEqual([
+			{
+				id: 1,
+				name: 'John',
+				cityId: 2,
+			},
+		]);
+		expect(result2).toStrictEqual([
+			{
+				id: 3,
+				name: 'Jack',
+				cityId: 3,
+			},
+		]);
 	});
 
-	test('insert into ... select', async (ctx) => {
-		const { db } = ctx.sqlite;
-
+	test.concurrent('insert into ... select', async ({ db }) => {
 		const notifications = sqliteTable('notifications_insert_into', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
-			sentAt: integer('sent_at', { mode: 'timestamp' }).notNull().default(sql`current_timestamp`),
+			sentAt: integer('sent_at', { mode: 'timestamp' })
+				.notNull()
+				.default(sql`current_timestamp`),
 			message: text('message').notNull(),
 		});
 		const users = sqliteTable('users_insert_into', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
 		});
-		const userNotications = sqliteTable('user_notifications_insert_into', {
-			userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
-			notificationId: integer('notification_id').notNull().references(() => notifications.id, { onDelete: 'cascade' }),
-		}, (t) => ({
-			pk: primaryKey({ columns: [t.userId, t.notificationId] }),
-		}));
+		const userNotications = sqliteTable(
+			'user_notifications_insert_into',
+			{
+				userId: integer('user_id')
+					.notNull()
+					.references(() => users.id, { onDelete: 'cascade' }),
+				notificationId: integer('notification_id')
+					.notNull()
+					.references(() => notifications.id, { onDelete: 'cascade' }),
+			},
+			(t) => [primaryKey({ columns: [t.userId, t.notificationId] })],
+		);
 
 		await db.run(sql`drop table if exists notifications_insert_into`);
 		await db.run(sql`drop table if exists users_insert_into`);
@@ -3701,13 +5694,15 @@ export function tests() {
 			.values({ message: 'You are one of the 3 lucky winners!' })
 			.returning({ id: notifications.id })
 			.then((result) => result[0]);
-		await db.insert(users).values([
-			{ name: 'Alice' },
-			{ name: 'Bob' },
-			{ name: 'Charlie' },
-			{ name: 'David' },
-			{ name: 'Eve' },
-		]);
+		await db
+			.insert(users)
+			.values([
+				{ name: 'Alice' },
+				{ name: 'Bob' },
+				{ name: 'Charlie' },
+				{ name: 'David' },
+				{ name: 'Eve' },
+			]);
 
 		const sentNotifications = await db
 			.insert(userNotications)
@@ -3730,50 +5725,96 @@ export function tests() {
 		]);
 	});
 
-	test('insert into ... select with keys in different order', async (ctx) => {
-		const { db } = ctx.sqlite;
+	test.concurrent(
+		'insert into ... select with keys in different order',
+		async ({ db }) => {
+			const users1 = sqliteTable('users1', {
+				id: integer('id').primaryKey({ autoIncrement: true }),
+				name: text('name').notNull(),
+			});
+			const users2 = sqliteTable('users2', {
+				id: integer('id').primaryKey({ autoIncrement: true }),
+				name: text('name').notNull(),
+			});
+
+			await db.run(sql`drop table if exists users1`);
+			await db.run(sql`drop table if exists users2`);
+			await db.run(sql`
+			create table users1 (
+				id integer primary key autoincrement,
+				name text not null
+			)
+		`);
+			await db.run(sql`
+			create table users2 (
+				id integer primary key autoincrement,
+				name text not null
+			)
+		`);
+
+			await db.insert(users2).values({ id: 1, name: 'First' });
+			const res = await db.insert(users1).select(
+				db
+					.select({
+						name: users2.name,
+						id: users2.id,
+					})
+					.from(users2),
+			).returning();
+
+			expect(res).toStrictEqual([{
+				id: 1,
+				name: 'First',
+			}]);
+		},
+	);
 
-		const users1 = sqliteTable('users1', {
+	test.concurrent('insert into ... select with generated column', async ({ db }) => {
+		const users1 = sqliteTable('users1_iswgc', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
 		});
-		const users2 = sqliteTable('users2', {
+		const users2 = sqliteTable('users2_iswgc', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
 		});
 
-		await db.run(sql`drop table if exists users1`);
-		await db.run(sql`drop table if exists users2`);
+		await db.run(sql`drop table if exists users1_iswgc`);
+		await db.run(sql`drop table if exists users2_iswgc`);
 		await db.run(sql`
-			create table users1 (
+			create table users1_iswgc (
 				id integer primary key autoincrement,
 				name text not null
 			)
 		`);
 		await db.run(sql`
-			create table users2 (
+			create table users2_iswgc (
 				id integer primary key autoincrement,
 				name text not null
 			)
 		`);
 
-		await expect(async () => {
-			db
-				.insert(users1)
-				.select(
-					db
-						.select({
-							name: users2.name,
-							id: users2.id,
-						})
-						.from(users2),
-				);
-		}).rejects.toThrowError();
-	});
+		await db.insert(users1).values([
+			{ name: 'Alice' },
+			{ name: 'Bob' },
+			{ name: 'Charlie' },
+		]);
+
+		const result1 = await db.insert(users2).select(db.select({ name: users1.name }).from(users1))
+			.returning();
+
+		expect(result1).toStrictEqual([
+			{ id: 1, name: 'Alice' },
+			{ id: 2, name: 'Bob' },
+			{ id: 3, name: 'Charlie' },
+		]);
 
-	test('Object keys as column names', async (ctx) => {
-		const { db } = ctx.sqlite;
+		// @ts-expect-error
+		expect(() => db.insert(users2).select(db.select({ name: users1.name, unknown: users1.id }).from(users1)))
+			.toThrowError();
+	});
 
+	test.concurrent('Object keys as column names', async ({ db }) => {
 		// Tests the following:
 		// Column with optional config without providing a value
 		// Column with optional config providing a value
@@ -3804,45 +5845,1642 @@ export function tests() {
 			.from(users)
 			.where(gt(users.createdAt, new Date(Date.now() - 2592000000)));
 
-		expect(result).toEqual([
-			{ id: 2, name: 'Jane' },
-		]);
+		expect(result).toEqual([{ id: 2, name: 'Jane' }]);
 
 		await db.run(sql`drop table users`);
 	});
 
-	test('sql operator as cte', async (ctx) => {
-		const { db } = ctx.sqlite;
-
+	test.concurrent('sql operator as cte', async ({ db }) => {
 		const users = sqliteTable('users', {
 			id: integer('id').primaryKey({ autoIncrement: true }),
 			name: text('name').notNull(),
 		});
 
 		await db.run(sql`drop table if exists ${users}`);
-		await db.run(sql`create table ${users} (id integer not null primary key autoincrement, name text not null)`);
-		await db.insert(users).values([
-			{ name: 'John' },
-			{ name: 'Jane' },
+		await db.run(
+			sql`create table ${users} (id integer not null primary key autoincrement, name text not null)`,
+		);
+		await db.insert(users).values([{ name: 'John' }, { name: 'Jane' }]);
+
+		const sq1 = db
+			.$with('sq', {
+				userId: users.id,
+				data: {
+					name: users.name,
+				},
+			})
+			.as(sql`select * from ${users} where ${users.name} = 'John'`);
+		const result1 = await db.with(sq1).select().from(sq1);
+
+		const sq2 = db
+			.$with('sq', {
+				userId: users.id,
+				data: {
+					name: users.name,
+				},
+			})
+			.as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
+		const result2 = await db.with(sq2).select().from(sq1);
+
+		expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
+		expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+	});
+
+	test.concurrent('placeholder + sql dates', async ({ db }) => {
+		const dateTable = sqliteTable('dates_placeholder_test', (t) => ({
+			id: t.integer('id').primaryKey().notNull(),
+			unix: t
+				.integer('unix_date', {
+					mode: 'timestamp',
+				})
+				.notNull(),
+			ms: t
+				.integer('ms_date', {
+					mode: 'timestamp_ms',
+				})
+				.notNull(),
+		}));
+
+		await db.run(sql`DROP TABLE IF EXISTS ${dateTable};`);
+		await db.run(sql`CREATE TABLE ${dateTable} (
+			id INTEGER PRIMARY KEY NOT NULL,
+			unix_date INTEGER NOT NULL,
+			ms_date INTEGER NOT NULL
+		);`);
+
+		const msDate = new Date();
+		const unixDate = new Date(Math.floor(msDate.getTime() / 1000) * 1000);
+
+		const initial = await db
+			.insert(dateTable)
+			.values([
+				{
+					id: 1,
+					unix: unixDate,
+					ms: msDate,
+				},
+				{
+					id: 2,
+					unix: sql.placeholder('unixOne'),
+					ms: sql.placeholder('msOne'),
+				},
+				{
+					id: 3,
+					unix: sql.placeholder('unixTwo'),
+					ms: sql.placeholder('msTwo'),
+				},
+				{
+					id: 4,
+					unix: sql`${unixDate.getTime() / 1000}`,
+					ms: sql`${msDate.getTime()}`,
+				},
+			])
+			.returning()
+			.all({
+				unixOne: unixDate,
+				unixTwo: unixDate.getTime() / 1000,
+				msOne: msDate,
+				msTwo: msDate.getTime(),
+			});
+
+		const updated = await db
+			.update(dateTable)
+			.set({
+				unix: sql`${unixDate.getTime() / 1000}`,
+				ms: sql`${msDate.getTime()}`,
+			})
+			.returning();
+
+		expect(initial).toStrictEqual([
+			{
+				id: 1,
+				unix: unixDate,
+				ms: msDate,
+			},
+			{
+				id: 2,
+				unix: unixDate,
+				ms: msDate,
+			},
+			{
+				id: 3,
+				unix: unixDate,
+				ms: msDate,
+			},
+			{
+				id: 4,
+				unix: unixDate,
+				ms: msDate,
+			},
 		]);
 
-		const sq1 = db.$with('sq', {
+		expect(updated).toStrictEqual(initial);
+	});
+
+	test.concurrent(
+		'integer default as string for timestamps',
+		async ({ db }) => {
+			const integerDefAsString = sqliteTable('integer_def_as_string', {
+				id: integer('id').primaryKey({ autoIncrement: true }).notNull(),
+				timest: integer({ mode: 'timestamp' }).default(new Date('2023-12-12')),
+				timest_ms: integer({ mode: 'timestamp_ms' }).default(
+					new Date('2023-12-12'),
+				),
+			});
+
+			await db.run(sql`DROP TABLE IF EXISTS ${integerDefAsString};`);
+			await db.run(sql`CREATE TABLE ${integerDefAsString} (
+			timest integer DEFAULT '"2023-12-12T00:00:00.000Z"',
+			timest_ms integer DEFAULT '"2023-12-12T00:00:00.000Z"',
+			id integer PRIMARY KEY
+		);`);
+
+			await db.run(sql`INSERT INTO ${integerDefAsString} (\`id\`) VALUES (1);`);
+
+			const res = await db.select().from(integerDefAsString);
+
+			expect(res).toStrictEqual([
+				{
+					id: 1,
+					timest: new Date('2023-12-12T00:00:00.000Z'),
+					timest_ms: new Date('2023-12-12T00:00:00.000Z'),
+				},
+			]);
+		},
+	);
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4875
+	test.concurrent('select aliased view', async ({ db }) => {
+		const productionJobTable = sqliteTable('production_job', {
+			id: text('id').primaryKey(),
+			name: text('name'),
+		});
+
+		const rfidTagTable = sqliteTable('rfid_tag', {
+			createdAt: integer('created_at', {
+				mode: 'timestamp',
+			})
+				.notNull()
+				.default(sql`now()`),
+			epc: text('epc').notNull(),
+			locationId: text('location_id').notNull(),
+			id: text('id')
+				.notNull()
+				.unique()
+				.$default(() => 'abc'),
+		});
+
+		const productionJobWithLocationView = sqliteView(
+			'production_job_with_location',
+		).as((qb) => {
+			const productionColumns = getColumns(productionJobTable);
+			const sub = qb.selectDistinct().from(rfidTagTable).as('r');
+			return qb
+				.select({
+					...productionColumns,
+					locationId: sub.locationId,
+					tagId: sub.id.as('tag_id'),
+					tagCreatedAt: sub.createdAt.as('tag_created_at'),
+				})
+				.from(productionJobTable)
+				.leftJoin(
+					sub,
+					and(
+						eq(productionJobTable.id, sql`LTRIM(${sub.epc}, '0')`),
+						sql`${sub.epc} ~ '^0?[0-9]+'`,
+					),
+				);
+		});
+
+		const sub = alias(productionJobWithLocationView, 'p'); // if select from "productionJobWithLocationView" (not from alias), it works as expected
+
+		const query = db.select().from(sub);
+		expect(query.toSQL().sql).toStrictEqual(
+			(<{ dialect: SQLiteDialect }> (<any> db)).dialect.sqlToQuery(
+				sql`select ${sql.identifier('id')}, ${sql.identifier('name')}, ${sql.identifier('location_id')}, ${
+					sql.identifier(
+						'tag_id',
+					)
+				}, ${sql.identifier('tag_created_at')} from ${sql.identifier('production_job_with_location')} ${
+					sql.identifier(
+						'p',
+					)
+				}`,
+			).sql,
+		);
+	});
+
+	// https://github.com/drizzle-team/drizzle-orm/issues/4612
+	test.concurrent('select with inline params in sql', async ({ db }) => {
+		const users = sqliteTable('users_115', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		});
+
+		const query = db.select({ sum: sql`sum(${3})`.inlineParams() }).from(users);
+
+		expect(query.toSQL()).toStrictEqual({
+			sql: 'select sum(3) from "users_115"',
+			params: [],
+		});
+	});
+
+	test.concurrent('Mappers: - correct mappers enabled', async ({ db, push, createDB }) => {
+		const jitDb = createDB({}, () => ({}), true);
+
+		const dialect: SQLiteDialect = (<any> db).dialect;
+		const jitDialect: SQLiteDialect = (<any> jitDb).dialect;
+
+		expect(dialect.mapperGenerators.relationalRows === makeDefaultRqbMapper).toStrictEqual(true);
+		expect(dialect.mapperGenerators.rows === makeDefaultQueryMapper).toStrictEqual(true);
+		expect(jitDialect.mapperGenerators.relationalRows === makeJitRqbMapper).toStrictEqual(true);
+		expect(jitDialect.mapperGenerators.rows === makeJitQueryMapper).toStrictEqual(true);
+	});
+
+	const mappersDate = new Date('2026-04-02T00:00:00.000Z');
+
+	test.concurrent('Mappers: simple select - no rows', async ({ db, push, createDB }) => {
+		const users = sqliteTable('mappers_users_1', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test.concurrent('Mappers: select - nothing to decode - text', async ({ db, push, createDB }) => {
+		const users = sqliteTable('mappers_users_2', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).returning();
+
+		const selected = await db.select({ name: users.name }).from(users);
+
+		expect(selected).toStrictEqual([{ name: 'First' }]);
+	});
+
+	test.concurrent('Mappers: select - nothing to decode - null', async ({ db, push, createDB }) => {
+		const users = sqliteTable('mappers_users_3', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).returning();
+
+		const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+		expect(selected).toStrictEqual([{ isBanned: null }]);
+	});
+
+	test.concurrent(
+		'Mappers: insert returning all + select + update returning + delete returning',
+		async ({ db, push, createDB }) => {
+			const users = sqliteTable('mappers_users_4', (t) => ({
+				id: t.numeric('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.integer('created_at', {
+					mode: 'timestamp_ms',
+				}).notNull(),
+				isBanned: t.integer('is_banned', { mode: 'boolean' }),
+			}));
+
+			await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+			await push({ users });
+
+			const inserted = await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select().from(users);
+
+			const updated = await db.update(users).set({
+				isBanned: false,
+			}).where(eq(users.id, 2)).returning();
+
+			// Driver bug bypass for `sqlite-cloud` driver
+			const deleted = await db.delete(users).where(sql`true`).returning();
+
+			expect(inserted).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(selected).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(updated).toStrictEqual([{
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}]);
+			expect(deleted).toStrictEqual(expect.arrayContaining([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]));
+		},
+	);
+
+	test.concurrent('Mappers: select complex selections', async ({ db, push, createDB }) => {
+		const users = sqliteTable('mappers_users_5', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const posts = sqliteTable('mappers_posts_1', (t) => ({
+			id: t.integer('id').primaryKey(),
+			authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		await db.run(sql`DROP TABLE IF EXISTS ${posts};`);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users, posts });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).returning();
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected3 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected4 = await db.select({
 			userId: users.id,
-			data: {
-				name: users.name,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+
+		expect(selected1).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
 			},
-		}).as(sql`select * from ${users} where ${users.name} = 'John'`);
-		const result1 = await db.with(sq1).select().from(sq1);
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			},
+			post: null,
+		}, {
+			user: {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: null,
+		}]);
+		expect(selected2).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}]);
+		expect(selected3).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: true,
+				name: 'Second',
+				postId: null,
+				userId: 2,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'Third',
+				postId: null,
+				userId: 3,
+			},
+		]);
+		expect(selected4).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+		]);
+	});
+
+	test.concurrent('Mappers: relational', async ({ push, createDB }) => {
+		const users = sqliteTable('mappers_users_6', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
 
-		const sq2 = db.$with('sq', {
+		const posts = sqliteTable('mappers_posts_2', (t) => ({
+			id: t.integer('id').primaryKey(),
+			authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB(
+			{ users, posts },
+			(r) => ({
+				users: {
+					post: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+					posts: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+				},
+				posts: {
+					author: r.one.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+					authors: r.many.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+				},
+			}),
+			false,
+		);
+
+		await db.run(sql`DROP TABLE IF EXISTS ${posts};`);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users, posts });
+
+		const empty1 = await db.query.users.findFirst();
+		const empty2 = await db.query.users.findMany();
+
+		expect(empty1).toStrictEqual(undefined);
+		expect(empty2).toStrictEqual([]);
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).returning();
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const simple1 = await db.query.users.findFirst();
+		const simple2 = await db.query.users.findMany();
+
+		expect(simple1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+		);
+		expect(simple2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+			},
+		]);
+
+		const extra1 = await db.query.users.findFirst({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const extra2 = await db.query.users.findMany({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(extra1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(extra2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+
+		const nested1 = await db.query.users.findFirst({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const nested2 = await db.query.users.findMany({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(nested1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(nested2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+	});
+
+	test.concurrent('Jit mappers: - simple select - no rows', async ({ push, createDB }) => {
+		const users = sqliteTable('jit_mappers_users_1', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const db = createDB({}, () => ({}), true);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		const result = await db.select().from(users);
+
+		expect(result).toStrictEqual([]);
+	});
+
+	test.concurrent('Jit mappers: - select - nothing to decode - text', async ({ push, createDB }) => {
+		const users = sqliteTable('jit_mappers_users_2', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const db = createDB({}, () => ({}), true);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).returning();
+
+		const selected = await db.select({ name: users.name }).from(users);
+
+		expect(selected).toStrictEqual([{ name: 'First' }]);
+	});
+
+	test.concurrent('Jit mappers: - select - nothing to decode - null', async ({ push, createDB }) => {
+		const users = sqliteTable('jit_mappers_users_3', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const db = createDB({}, () => ({}), true);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}]).returning();
+
+		const selected = await db.select({ isBanned: users.isBanned }).from(users);
+
+		expect(selected).toStrictEqual([{ isBanned: null }]);
+	});
+
+	test.concurrent(
+		'Jit mappers: - insert returning all + select + update returning + delete returning',
+		async ({ push, createDB }) => {
+			const users = sqliteTable('jit_mappers_users_4', (t) => ({
+				id: t.numeric('id', { mode: 'number' }).primaryKey(),
+				name: t.text('name').notNull(),
+				createdAt: t.integer('created_at', {
+					mode: 'timestamp_ms',
+				}).notNull(),
+				isBanned: t.integer('is_banned', { mode: 'boolean' }),
+			}));
+
+			const db = createDB({}, () => ({}), true);
+			await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+			await push({ users });
+
+			const inserted = await db.insert(users).values([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+			}]).returning();
+
+			const selected = await db.select().from(users);
+
+			const updated = await db.update(users).set({
+				isBanned: false,
+			}).where(eq(users.id, 2)).returning();
+
+			// Driver bug bypass for `sqlite-cloud` driver
+			const deleted = await db.delete(users).where(sql`true`).returning();
+
+			expect(inserted).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(selected).toStrictEqual([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]);
+			expect(updated).toStrictEqual([{
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}]);
+			expect(deleted).toStrictEqual(expect.arrayContaining([{
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			}, {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: false,
+			}, {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			}]));
+		},
+	);
+
+	test.concurrent('Jit mappers: - select complex selections', async ({ push, createDB }) => {
+		const users = sqliteTable('jit_mappers_users_5', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const posts = sqliteTable('jit_mappers_posts_1', (t) => ({
+			id: t.integer('id').primaryKey(),
+			authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB({}, () => ({}), true);
+		await db.run(sql`DROP TABLE IF EXISTS ${posts};`);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users, posts });
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).returning();
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const selected1 = await db.select({ user: users, post: posts }).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected2 = await db.select({ user: users, post: posts }).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected3 = await db.select({
+			userId: users.id,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).leftJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+		const selected4 = await db.select({
 			userId: users.id,
-			data: {
-				name: users.name,
+			postId: posts.id,
+			name: users.name,
+			isBanned: users.isBanned,
+			content: posts.content,
+			createdAt: users.createdAt,
+		}).from(users).innerJoin(
+			posts,
+			eq(users.id, posts.authorId),
+		).orderBy(users.id);
+
+		expect(selected1).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
 			},
-		}).as(() => sql`select * from ${users} where ${users.name} = 'Jane'`);
-		const result2 = await db.with(sq2).select().from(sq1);
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Second',
+				createdAt: mappersDate,
+				isBanned: true,
+			},
+			post: null,
+		}, {
+			user: {
+				id: 3,
+				name: 'Third',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: null,
+		}]);
+		expect(selected2).toStrictEqual([{
+			user: {
+				id: 1,
+				name: 'First',
+				createdAt: mappersDate,
+				isBanned: null,
+			},
+			post: {
+				id: 1,
+				authorId: 1,
+				content: 'p1',
+			},
+		}]);
+		expect(selected3).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: true,
+				name: 'Second',
+				postId: null,
+				userId: 2,
+			},
+			{
+				content: null,
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'Third',
+				postId: null,
+				userId: 3,
+			},
+		]);
+		expect(selected4).toStrictEqual([
+			{
+				content: 'p1',
+				createdAt: mappersDate,
+				isBanned: null,
+				name: 'First',
+				postId: 1,
+				userId: 1,
+			},
+		]);
+	});
 
-		expect(result1).toEqual([{ userId: 1, data: { name: 'John' } }]);
-		expect(result2).toEqual([{ userId: 2, data: { name: 'Jane' } }]);
+	test.concurrent('Jit mappers: - relational', async ({ push, createDB }) => {
+		const users = sqliteTable('jit_mappers_users_6', (t) => ({
+			id: t.numeric('id', { mode: 'number' }).primaryKey(),
+			name: t.text('name').notNull(),
+			createdAt: t.integer('created_at', {
+				mode: 'timestamp_ms',
+			}).notNull(),
+			isBanned: t.integer('is_banned', { mode: 'boolean' }),
+		}));
+
+		const posts = sqliteTable('jit_mappers_posts_2', (t) => ({
+			id: t.integer('id').primaryKey(),
+			authorId: t.numeric('author_id', { mode: 'number' }).references(() => users.id),
+			content: t.text('content'),
+		}));
+
+		const db = createDB(
+			{ users, posts },
+			(r) => ({
+				users: {
+					post: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+					posts: r.one.posts({
+						from: r.users.id,
+						to: r.posts.authorId,
+					}),
+				},
+				posts: {
+					author: r.one.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+					authors: r.many.users({
+						from: r.posts.authorId,
+						to: r.users.id,
+					}),
+				},
+			}),
+			true,
+		);
+		await db.run(sql`DROP TABLE IF EXISTS ${posts};`);
+		await db.run(sql`DROP TABLE IF EXISTS ${users};`);
+		await push({ users, posts });
+
+		const empty1 = await db.query.users.findFirst();
+		const empty2 = await db.query.users.findMany();
+
+		expect(empty1).toStrictEqual(undefined);
+		expect(empty2).toStrictEqual([]);
+
+		await db.insert(users).values([{
+			id: 1,
+			name: 'First',
+			createdAt: mappersDate,
+		}, {
+			id: 2,
+			name: 'Second',
+			createdAt: mappersDate,
+			isBanned: true,
+		}, {
+			id: 3,
+			name: 'Third',
+			createdAt: mappersDate,
+		}]).returning();
+		await db.insert(posts).values({
+			id: 1,
+			authorId: 1,
+			content: 'p1',
+		});
+
+		const simple1 = await db.query.users.findFirst();
+		const simple2 = await db.query.users.findMany();
+
+		expect(simple1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+		);
+		expect(simple2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+			},
+		]);
+
+		const extra1 = await db.query.users.findFirst({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const extra2 = await db.query.users.findMany({
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(extra1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(extra2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+
+		const nested1 = await db.query.users.findFirst({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+		const nested2 = await db.query.users.findMany({
+			with: {
+				post: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+							where: {
+								RAW: sql`false`,
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+				posts: {
+					with: {
+						author: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+						authors: {
+							extras: {
+								sql: sql`SELECT 1`.mapWith(Number),
+								sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+							},
+						},
+					},
+					extras: {
+						sql: sql`SELECT 1`.mapWith(Number),
+						sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+					},
+				},
+			},
+			extras: {
+				sql: sql`SELECT 1`.mapWith(Number),
+				sqlWrapper: { getSQL: () => sql`SELECT 2`.mapWith(Number) },
+			},
+		});
+
+		expect(nested1).toStrictEqual(
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		);
+		expect(nested2).toStrictEqual([
+			{
+				createdAt: mappersDate,
+				id: 1,
+				isBanned: null,
+				name: 'First',
+				post: {
+					author: null,
+					authorId: 1,
+					authors: [],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				posts: {
+					author: {
+						createdAt: mappersDate,
+						id: 1,
+						isBanned: null,
+						name: 'First',
+						sql: 1,
+						sqlWrapper: 2,
+					},
+					authorId: 1,
+					authors: [
+						{
+							createdAt: mappersDate,
+							id: 1,
+							isBanned: null,
+							name: 'First',
+							sql: 1,
+							sqlWrapper: 2,
+						},
+					],
+					content: 'p1',
+					id: 1,
+					sql: 1,
+					sqlWrapper: 2,
+				},
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 2,
+				isBanned: true,
+				name: 'Second',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+			{
+				createdAt: mappersDate,
+				id: 3,
+				isBanned: null,
+				name: 'Third',
+				post: null,
+				posts: null,
+				sql: 1,
+				sqlWrapper: 2,
+			},
+		]);
+	});
+
+	test('Query error wrapping', async ({ db }) => {
+		await expect(async () =>
+			await db.insert(usersTable).values([{ id: 1, name: 'First' }, { id: 1, name: 'Second' }]).run()
+		)
+			.rejects.toBeInstanceOf(DrizzleQueryError);
 	});
 }
diff --git a/integration-tests/tests/sqlite/sqlite-proxy-batch.test.ts b/integration-tests/tests/sqlite/sqlite-proxy-batch.test.ts
index 1137faaf40..0116eaf5e7 100644
--- a/integration-tests/tests/sqlite/sqlite-proxy-batch.test.ts
+++ b/integration-tests/tests/sqlite/sqlite-proxy-batch.test.ts
@@ -1,7 +1,8 @@
 /* eslint-disable drizzle-internal/require-entity-kind */
 import type BetterSqlite3 from 'better-sqlite3';
 import Database from 'better-sqlite3';
-import { eq, relations, sql } from 'drizzle-orm';
+import { defineRelations, eq, sql } from 'drizzle-orm';
+import { relations } from 'drizzle-orm/_relations';
 import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
 import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import type { SqliteRemoteDatabase, SqliteRemoteResult } from 'drizzle-orm/sqlite-proxy';
@@ -133,6 +134,8 @@ const schema = {
 	usersConfig,
 };
 
+const relationsV2 = defineRelations(schema);
+
 class ServerSimulator {
 	constructor(private db: BetterSqlite3.Database) {}
 
@@ -211,7 +214,7 @@ class ServerSimulator {
 	}
 }
 
-let db: SqliteRemoteDatabase<typeof schema>;
+let db: SqliteRemoteDatabase<typeof relationsV2>;
 let client: Database.Database;
 let serverSimulator: ServerSimulator;
 
@@ -249,7 +252,7 @@ beforeAll(async () => {
 			console.error('Error from sqlite proxy server:', e);
 			throw e;
 		}
-	}, { schema });
+	}, { relations: relationsV2 });
 });
 
 beforeEach(async () => {
@@ -335,8 +338,8 @@ afterAll(async () => {
 test('findMany + findOne api example', async () => {
 	const user = await db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id });
 	const insertRes = await db.insert(usersTable).values({ id: 2, name: 'Dan' });
-	const manyUsers = await db.query.usersTable.findMany({});
-	const oneUser = await db.query.usersTable.findFirst({});
+	const manyUsersV2 = await db.query.usersTable.findMany({});
+	const oneUserV2 = await db.query.usersTable.findFirst({});
 
 	expectTypeOf(user).toEqualTypeOf<
 		{
@@ -346,14 +349,14 @@ test('findMany + findOne api example', async () => {
 
 	expectTypeOf(insertRes).toEqualTypeOf<SqliteRemoteResult>;
 
-	expectTypeOf(manyUsers).toEqualTypeOf<{
+	expectTypeOf(manyUsersV2).toEqualTypeOf<{
 		id: number;
 		name: string;
 		verified: number;
 		invitedBy: number | null;
 	}[]>;
 
-	expectTypeOf(oneUser).toEqualTypeOf<
+	expectTypeOf(oneUserV2).toEqualTypeOf<
 		{
 			id: number;
 			name: string;
@@ -368,12 +371,12 @@ test('findMany + findOne api example', async () => {
 
 	expect(insertRes).toEqual({ rows: { changes: 1, lastInsertRowid: 2 } });
 
-	expect(manyUsers).toEqual([
+	expect(manyUsersV2).toEqual([
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
 		{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
 	]);
 
-	expect(oneUser).toEqual(
+	expect(oneUserV2).toEqual(
 		{ id: 1, name: 'John', verified: 0, invitedBy: null },
 	);
 });
@@ -498,13 +501,14 @@ test('insert + findMany + findFirst', async () => {
 	);
 });
 
-test.skip('insert + db.all + db.get + db.values + db.run', async () => {
+// TODO: swap arrays for objects after adding object-mode querying support to proxy
+test('insert + db.all + db.get + db.values + db.run', async () => {
 	const batchResponse = await db.batch([
 		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
 		db.run(sql`insert into users (id, name) values (2, 'Dan')`),
-		db.all<typeof usersTable.$inferSelect>(sql`select * from users`),
+		db.all<[number, string, number, number | null]>(sql`select * from users`),
 		db.values(sql`select * from users`),
-		db.get<typeof usersTable.$inferSelect>(sql`select * from users`),
+		db.get<[number, string, number, number | null]>(sql`select * from users`),
 	]);
 
 	expectTypeOf(batchResponse).toEqualTypeOf<[
@@ -512,19 +516,9 @@ test.skip('insert + db.all + db.get + db.values + db.run', async () => {
 			id: number;
 		}[],
 		SqliteRemoteResult,
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-		}[],
+		[number, string, number, number | null][],
 		unknown[][],
-		{
-			id: number;
-			name: string;
-			verified: number;
-			invitedBy: number | null;
-		},
+		[number, string, number, number | null],
 	]>();
 
 	expect(batchResponse.length).eq(5);
@@ -536,17 +530,27 @@ test.skip('insert + db.all + db.get + db.values + db.run', async () => {
 	expect(batchResponse[1]).toEqual({ changes: 1, lastInsertRowid: 2 });
 
 	expect(batchResponse[2]).toEqual([
-		{ id: 1, name: 'John', verified: 0, invited_by: null },
-		{ id: 2, name: 'Dan', verified: 0, invited_by: null },
+		[
+			1,
+			'John',
+			0,
+			null,
+		],
+		[
+			2,
+			'Dan',
+			0,
+			null,
+		],
 	]);
 
-	expect(batchResponse[3].map((row) => Array.prototype.slice.call(row))).toEqual([
+	expect(batchResponse[3]).toEqual([
 		[1, 'John', 0, null],
 		[2, 'Dan', 0, null],
 	]);
 
 	expect(batchResponse[4]).toEqual(
-		{ id: 1, name: 'John', verified: 0, invited_by: null },
+		[1, 'John', 0, null],
 	);
 });
 
@@ -594,6 +598,7 @@ test('insert + findManyWith + db.all', async () => {
 	expect(batchResponse[3]).toEqual([
 		[1, 'John', 0, null],
 		[2, 'Dan', 0, null],
+		// TODO: replace after adding object-mode querying to proxy api
 		// { id: 1, name: 'John', verified: 0, invited_by: null },
 		// { id: 2, name: 'Dan', verified: 0, invited_by: null },
 	]);
diff --git a/integration-tests/tests/sqlite/sqlite-proxy.test.ts b/integration-tests/tests/sqlite/sqlite-proxy.test.ts
index 23024cf9af..bd0bcb8e16 100644
--- a/integration-tests/tests/sqlite/sqlite-proxy.test.ts
+++ b/integration-tests/tests/sqlite/sqlite-proxy.test.ts
@@ -1,135 +1,307 @@
-/* eslint-disable drizzle-internal/require-entity-kind */
-import type BetterSqlite3 from 'better-sqlite3';
-import Database from 'better-sqlite3';
 import { Name, sql } from 'drizzle-orm';
+import { SQLiteCloudDatabase } from 'drizzle-orm/sqlite-cloud';
+import { getTableConfig, int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-import { drizzle as proxyDrizzle } from 'drizzle-orm/sqlite-proxy';
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
-import { skipTests } from '~/common';
-import { tests, usersTable } from './sqlite-common';
-import { TestCache, TestGlobalCache, tests as cacheTests } from './sqlite-common-cache';
-
-class ServerSimulator {
-	constructor(private db: BetterSqlite3.Database) {}
-
-	async query(sql: string, params: any[], method: string) {
-		if (method === 'run') {
-			try {
-				const result = this.db.prepare(sql).run(params);
-				return { data: result as any };
-			} catch (e: any) {
-				return { error: e.message };
-			}
-		} else if (method === 'all' || method === 'values') {
-			try {
-				const rows = this.db.prepare(sql).raw().all(params);
-				return { data: rows };
-			} catch (e: any) {
-				return { error: e.message };
-			}
-		} else if (method === 'get') {
-			try {
-				const row = this.db.prepare(sql).raw().get(params);
-				return { data: row };
-			} catch (e: any) {
-				return { error: e.message };
-			}
-		} else {
-			return { error: 'Unknown method value' };
-		}
-	}
+import { migrate } from 'drizzle-orm/sqlite-proxy/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { randomString } from '~/utils';
+import { proxyTest as test } from './instrumentation';
+import relations from './relations';
+import { anotherUsersMigratorTable, tests, usersMigratorTable, usersTable } from './sqlite-common';
+import { tests as cacheTests } from './sqlite-common-cache';
+
+const skip = [
+	// Different driver respond
+	'insert via db.get w/ query builder',
+	'insert via db.run + select via db.get',
+	'insert via db.get',
+	'insert via db.run + select via db.all',
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+];
+cacheTests(test, skip);
+tests(test, skip);
+
+test.beforeEach(async ({ db }) => {
+	await db.run(sql`drop table if exists ${usersTable}`);
+
+	await db.run(sql`
+		create table ${usersTable} (
+		 id integer primary key,
+		 name text not null,
+		 verified integer not null default 0,
+		 json blob,
+		 created_at integer not null default (strftime('%s', 'now'))
+		)
+	`);
+});
 
-	migrations(queries: string[]) {
-		this.db.exec('BEGIN');
+test('migrator', async ({ db, serverSimulator }) => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
 		try {
-			for (const query of queries) {
-				this.db.exec(query);
-			}
-			this.db.exec('COMMIT');
-		} catch {
-			this.db.exec('ROLLBACK');
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
 		}
+	}, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
 
-		return {};
-	}
-}
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
 
-let db: SqliteRemoteDatabase;
-let dbGlobalCached: SqliteRemoteDatabase;
-let cachedDb: SqliteRemoteDatabase;
-let client: Database.Database;
-let serverSimulator: ServerSimulator;
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
 
-beforeAll(async () => {
-	const dbPath = process.env['SQLITE_DB_PATH'] ?? ':memory:';
-	client = new Database(dbPath);
-	serverSimulator = new ServerSimulator(client);
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator : migrate with custom table', async ({ db, serverSimulator }) => {
+	const customTable = randomString();
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists ${sql.identifier(customTable)}`);
 
-	const callback = async (sql: string, params: any[], method: string) => {
+	await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
 		try {
-			const rows = await serverSimulator.query(sql, params, method);
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: './drizzle2/sqlite', migrationsTable: customTable });
 
-			if (rows.error !== undefined) {
-				throw new Error(rows.error);
-			}
+	// test if the custom migrations table was created
+	const res = await db.all(sql`select * from ${sql.identifier(customTable)};`);
+	expect(res.length > 0).toBeTruthy();
+
+	// test if the migrated table are working as expected
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+	const result = await db.select().from(usersMigratorTable);
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table ${sql.identifier(customTable)}`);
+});
 
-			return { rows: rows.data };
-		} catch (e: any) {
-			console.error('Error from sqlite proxy server:', e.response?.data ?? e.message);
-			throw e;
+test('migrator : --init', async ({ db, serverSimulator }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
 		}
-	};
-	db = proxyDrizzle(callback);
-	cachedDb = proxyDrizzle(callback, { cache: new TestCache() });
-	dbGlobalCached = proxyDrizzle(callback, { cache: new TestGlobalCache() });
+	}, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<[number]>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.[0]).toStrictEqual(false);
 });
 
-beforeEach((ctx) => {
-	ctx.sqlite = {
-		db,
-	};
-	ctx.cachedSqlite = {
-		db: cachedDb,
-		dbGlobalCached,
-	};
+test('migrator : --init - local migrations error', async ({ db, serverSimulator }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<[number]>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res?.[0]).toStrictEqual(false);
 });
 
-afterAll(async () => {
-	client?.close();
+test('migrator : --init - db migrations error', async ({ db, serverSimulator }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<[number]>(
+		sql`SELECT EXISTS (SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${
+			getTableConfig(usersMigratorTable).name
+		}) AS ${sql.identifier('tableExists')};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res?.[0]).toStrictEqual(true);
 });
 
-skipTests([
-	// Different driver respond
-	'insert via db.get w/ query builder',
-	'insert via db.run + select via db.get',
-	'insert via db.get',
-	'insert via db.run + select via db.all',
-]);
-cacheTests();
-tests();
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db, serverSimulator }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
 
-beforeEach(async () => {
-	await db.run(sql`drop table if exists ${usersTable}`);
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
 
-	await db.run(sql`
-		create table ${usersTable} (
-		 id integer primary key,
-		 name text not null,
-		 verified integer not null default 0,
-		 json blob,
-		 created_at integer not null default (strftime('%s', 'now'))
-		)
-	`);
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sqlite-proxy';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as SqliteRemoteDatabase<typeof relations>, async (queries) => {
+		try {
+			serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
 });
 
-test('insert via db.get w/ query builder', async () => {
+test('insert via db.get w/ query builder', async ({ db }) => {
 	const inserted = await db.get<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
 		db.insert(usersTable).values({ name: 'John' }).returning({ id: usersTable.id, name: usersTable.name }),
 	);
 	expect(inserted).toEqual([1, 'John']);
 });
 
-test('insert via db.run + select via db.get', async () => {
+test('insert via db.run + select via db.get', async ({ db }) => {
 	await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
 
 	const result = await db.get<{ id: number; name: string }>(
@@ -138,7 +310,7 @@ test('insert via db.run + select via db.get', async () => {
 	expect(result).toEqual([1, 'John']);
 });
 
-test('insert via db.get', async () => {
+test('insert via db.get', async ({ db }) => {
 	const inserted = await db.get<{ id: number; name: string }>(
 		sql`insert into ${usersTable} (${new Name(
 			usersTable.name.name,
@@ -147,9 +319,7 @@ test('insert via db.get', async () => {
 	expect(inserted).toEqual([1, 'John']);
 });
 
-test('insert via db.run + select via db.all', async (ctx) => {
-	const { db } = ctx.sqlite;
-
+test('insert via db.run + select via db.all', async ({ db }) => {
 	await db.run(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
 
 	const result = await db.all<{ id: number; name: string }>(sql`select id, name from "users"`);
diff --git a/integration-tests/tests/sqlite/sqlite.relations.ts b/integration-tests/tests/sqlite/sqlite.relations.ts
new file mode 100644
index 0000000000..0c525b9109
--- /dev/null
+++ b/integration-tests/tests/sqlite/sqlite.relations.ts
@@ -0,0 +1,163 @@
+import { defineRelations } from 'drizzle-orm';
+import * as schema from './sqlite.schema';
+
+export default defineRelations(schema, (r) => ({
+	usersView: {
+		posts: r.many.postsTable(),
+		groups: r.many.groupsTable(),
+	},
+	usersTable: {
+		alltypes: r.many.allTypesTable({
+			from: r.usersTable.id,
+			to: r.allTypesTable.int,
+		}),
+		invitee: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+		}),
+		inviteeRequired: r.one.usersTable({
+			from: r.usersTable.invitedBy,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		usersToGroups: r.many.usersToGroupsTable(),
+		posts: r.many.postsTable(),
+		postsFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				ownerId: 2,
+			},
+			alias: 'author-filtered',
+		}),
+		postsAltFiltered: r.many.postsTable({
+			from: r.usersTable.id,
+			to: r.postsTable.ownerId,
+			where: {
+				content: {
+					like: '%.1',
+				},
+			},
+			alias: 'author-alt-filtered',
+		}),
+		group: r.one.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+		}),
+		groups: r.many.groupsTable({
+			from: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			to: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			alias: 'users-groups-direct',
+		}),
+		groupsFiltered: r.many.groupsTable({
+			alias: 'users-groups-direct-filtered',
+		}),
+	},
+	groupsTable: {
+		usersToGroups: r.many.usersToGroupsTable(),
+		user: r.one.usersTable(),
+		users: r.many.usersTable({
+			alias: 'users-groups-direct',
+		}),
+		usersFiltered: r.many.usersTable({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersTable.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gte: 2,
+				},
+			},
+			alias: 'users-groups-direct-filtered',
+		}),
+		usersView: r.many.usersView({
+			from: r.groupsTable.id.through(r.usersToGroupsTable.groupId),
+			to: r.usersView.id.through(r.usersToGroupsTable.userId),
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+	},
+	usersToGroupsTable: {
+		group: r.one.groupsTable({
+			from: r.usersToGroupsTable.groupId,
+			to: r.groupsTable.id,
+			optional: false,
+		}),
+		user: r.one.usersTable({
+			from: r.usersToGroupsTable.userId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	postsTable: {
+		author: r.one.usersTable({
+			from: r.postsTable.ownerId,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		viewAuthor: r.one.usersView({
+			from: r.postsTable.ownerId,
+			to: r.usersView.id,
+			optional: false,
+			where: {
+				id: {
+					gt: 1,
+				},
+			},
+		}),
+		authorFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-filtered',
+		}),
+		authorAltFiltered: r.one.usersTable({
+			optional: false,
+			alias: 'author-alt-filtered',
+		}),
+		comments: r.many.commentsTable(),
+	},
+	commentsTable: {
+		post: r.one.postsTable({
+			from: r.commentsTable.postId,
+			to: r.postsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentsTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+		likes: r.many.commentLikesTable(),
+	},
+	commentLikesTable: {
+		comment: r.one.commentsTable({
+			from: r.commentLikesTable.commentId,
+			to: r.commentsTable.id,
+			optional: false,
+		}),
+		author: r.one.usersTable({
+			from: r.commentLikesTable.creator,
+			to: r.usersTable.id,
+			optional: false,
+		}),
+	},
+	students: {
+		courseOfferings: r.many.courseOfferings({
+			from: r.students.studentId.through(r.studentGrades.studentId),
+			to: [
+				r.courseOfferings.courseId.through(r.studentGrades.courseId),
+				r.courseOfferings.semester.through(r.studentGrades.semester),
+			],
+		}),
+	},
+	courseOfferings: {
+		students: r.many.students(),
+	},
+	customTypesTable: {
+		self: r.many.customTypesTable({
+			from: r.customTypesTable.id,
+			to: r.customTypesTable.id,
+		}),
+	},
+}));
diff --git a/integration-tests/tests/sqlite/sqlite.schema.ts b/integration-tests/tests/sqlite/sqlite.schema.ts
new file mode 100644
index 0000000000..e88ac18203
--- /dev/null
+++ b/integration-tests/tests/sqlite/sqlite.schema.ts
@@ -0,0 +1,201 @@
+import {
+	alias,
+	type AnySQLiteColumn,
+	blob,
+	customType,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	snakeCase,
+	text,
+} from 'drizzle-orm/sqlite-core';
+
+import { eq, getTableColumns, ne, sql } from 'drizzle-orm';
+
+export const usersTable = snakeCase.table('users', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	name: text().notNull(),
+	verified: integer().notNull().default(0),
+	invitedBy: integer().references((): AnySQLiteColumn => usersTable.id),
+});
+
+export const groupsTable = snakeCase.table('groups', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	name: text().notNull(),
+	description: text(),
+});
+export const usersToGroupsTable = snakeCase.table(
+	'users_to_groups',
+	{
+		id: integer().primaryKey({ autoIncrement: true }),
+		userId: integer({ mode: 'number' }).notNull().references(
+			() => usersTable.id,
+		),
+		groupId: integer({ mode: 'number' }).notNull().references(
+			() => groupsTable.id,
+		),
+	},
+	(t) => [primaryKey({ columns: [t.userId, t.groupId] })],
+);
+
+export const postsTable = snakeCase.table('posts', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	content: text().notNull(),
+	ownerId: integer({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	createdAt: integer({ mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+
+export const usersView = snakeCase.view('users_view').as((qb) =>
+	qb.select({
+		...getTableColumns(usersTable),
+		postContent: postsTable.content,
+		createdAt: postsTable.createdAt,
+		counter: sql<string | number>`(select count(*) from ${usersTable} as ${alias(usersTable, 'count_source')} where ${
+			ne(usersTable.id, 2)
+		})`
+			.mapWith((data) => {
+				return data === '0' || data === 0 ? null : Number(data);
+			}).as('count'),
+	})
+		.from(usersTable).leftJoin(postsTable, eq(usersTable.id, postsTable.ownerId))
+);
+
+export const commentsTable = snakeCase.table('comments', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	content: text().notNull(),
+	creator: integer({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	postId: integer({ mode: 'number' }).references(() => postsTable.id),
+	createdAt: integer({ mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+
+export const commentLikesTable = snakeCase.table('comment_likes', {
+	id: integer().primaryKey({ autoIncrement: true }),
+	creator: integer({ mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	commentId: integer({ mode: 'number' }).references(
+		() => commentsTable.id,
+	),
+	createdAt: integer({ mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+
+export const allTypesTable = snakeCase.table('all_types', {
+	int: integer({
+		mode: 'number',
+	}),
+	bool: integer({
+		mode: 'boolean',
+	}),
+	time: integer({
+		mode: 'timestamp',
+	}),
+	timeMs: integer({
+		mode: 'timestamp_ms',
+	}),
+	bigint: blob({
+		mode: 'bigint',
+	}),
+	buffer: blob({
+		mode: 'buffer',
+	}),
+	json: blob({
+		mode: 'json',
+	}),
+	numeric: numeric(),
+	numericNum: numeric({
+		mode: 'number',
+	}),
+	numericBig: numeric({
+		mode: 'bigint',
+	}),
+	real: real(),
+	text: text({
+		mode: 'text',
+	}),
+	jsonText: text({
+		mode: 'json',
+	}),
+});
+
+export const students = snakeCase.table('students', {
+	studentId: integer('student_id').primaryKey().notNull(),
+	name: text().notNull(),
+});
+
+export const courseOfferings = snakeCase.table('course_offerings', {
+	courseId: integer('course_id').notNull(),
+	semester: text().notNull(),
+});
+
+export const studentGrades = snakeCase.table('student_grades', {
+	studentId: integer('student_id').notNull(),
+	courseId: integer('course_id').notNull(),
+	semester: text().notNull(),
+	grade: text(),
+});
+
+const customBigInt = customType<{
+	data: bigint;
+	driverData: Buffer;
+	jsonData: string;
+}>({
+	dataType: () => 'blob',
+	fromDriver: (value) => {
+		return BigInt(value.toString());
+	},
+	fromJson: (value) => {
+		return BigInt(Buffer.from(value, 'hex').toString());
+	},
+	toDriver: (value) => Buffer.from(value.toString()),
+});
+
+const customBytes = customType<{
+	data: Buffer;
+	driverData: Buffer;
+	jsonData: string;
+}>({
+	dataType: () => 'blob',
+	fromJson: (value) => {
+		return Buffer.from(value, 'hex');
+	},
+	forJsonSelect: (identifier, sql) => {
+		return sql`hex(${identifier})`;
+	},
+});
+
+const customTimestamp = customType<{
+	data: Date;
+	driverData: number;
+	jsonData: number;
+}>({
+	dataType: () => 'integer',
+	fromDriver: (value: number) => {
+		return new Date(value);
+	},
+	toDriver: (value: Date) => {
+		return value.getTime();
+	},
+});
+
+const customInt = customType<{
+	data: number;
+	driverData: number;
+}>({
+	dataType: () => 'integer',
+});
+
+export const customTypesTable = snakeCase.table('custom_types', {
+	id: integer('id'),
+	big: customBigInt(),
+	bytes: customBytes(),
+	time: customTimestamp(),
+	int: customInt(),
+});
diff --git a/integration-tests/tests/sqlite/tables.ts b/integration-tests/tests/sqlite/tables.ts
new file mode 100644
index 0000000000..2009956af2
--- /dev/null
+++ b/integration-tests/tests/sqlite/tables.ts
@@ -0,0 +1,79 @@
+import { relations } from 'drizzle-orm/_relations';
+import { foreignKey, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id').references(() => cities.id).notNull(),
+	homeCityId: int('home_city_id').references(() => cities.id),
+	createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+});
+export const usersConfig = relations(users, ({ one, many }) => ({
+	city: one(cities, { relationName: 'UsersInCity', fields: [users.cityId], references: [cities.id] }),
+	homeCity: one(cities, { fields: [users.homeCityId], references: [cities.id] }),
+	posts: many(posts),
+	comments: many(comments),
+}));
+
+export const cities = sqliteTable('cities', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+export const citiesConfig = relations(cities, ({ many }) => ({
+	users: many(users, { relationName: 'UsersInCity' }),
+}));
+
+export const posts = sqliteTable('posts', {
+	id: integer('id').primaryKey(),
+	title: text('title').notNull(),
+	authorId: int('author_id').references(() => users.id),
+});
+export const postsConfig = relations(posts, ({ one, many }) => ({
+	author: one(users, { fields: [posts.authorId], references: [users.id] }),
+	comments: many(comments),
+}));
+
+export const comments = sqliteTable('comments', {
+	id: integer('id').primaryKey(),
+	postId: int('post_id').references(() => posts.id).notNull(),
+	authorId: int('author_id').references(() => users.id),
+	text: text('text').notNull(),
+});
+export const commentsConfig = relations(comments, ({ one }) => ({
+	post: one(posts, { fields: [comments.postId], references: [posts.id] }),
+	author: one(users, { fields: [comments.authorId], references: [users.id] }),
+}));
+
+export const books = sqliteTable('books', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+});
+export const booksConfig = relations(books, ({ many }) => ({
+	authors: many(bookAuthors),
+}));
+
+export const bookAuthors = sqliteTable('book_authors', {
+	bookId: int('book_id').references(() => books.id).notNull(),
+	authorId: int('author_id').references(() => users.id).notNull(),
+	role: text('role').notNull(),
+});
+export const bookAuthorsConfig = relations(bookAuthors, ({ one }) => ({
+	book: one(books, { fields: [bookAuthors.bookId], references: [books.id] }),
+	author: one(users, { fields: [bookAuthors.authorId], references: [users.id] }),
+}));
+
+export const node = sqliteTable('node', {
+	id: integer('id').primaryKey(),
+	parentId: int('parent_id'),
+	leftId: int('left_id'),
+	rightId: int('right_id'),
+}, (node) => [
+	foreignKey({ columns: [node.parentId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.leftId], foreignColumns: [node.id] }),
+	foreignKey({ columns: [node.rightId], foreignColumns: [node.id] }),
+]);
+export const nodeRelations = relations(node, ({ one }) => ({
+	parent: one(node, { fields: [node.parentId], references: [node.id] }),
+	left: one(node, { fields: [node.leftId], references: [node.id] }),
+	right: one(node, { fields: [node.rightId], references: [node.id] }),
+}));
diff --git a/integration-tests/tests/sqlite/turso.test.ts b/integration-tests/tests/sqlite/turso.test.ts
new file mode 100644
index 0000000000..bdc5543dcd
--- /dev/null
+++ b/integration-tests/tests/sqlite/turso.test.ts
@@ -0,0 +1,8689 @@
+import 'dotenv/config';
+import { DrizzleError, sql, TransactionRollbackError } from 'drizzle-orm';
+import { expect, expectTypeOf } from 'vitest';
+import { libSQLTursoTest as test } from './instrumentation';
+import { commentsTable, groupsTable, postsTable, usersTable, usersToGroupsTable } from './sqlite.schema';
+
+test.beforeEach(async ({ db }) => {
+	await db.run(sql`drop table if exists \`groups\``);
+	await db.run(sql`drop table if exists \`users\``);
+	await db.run(sql`drop table if exists \`users_to_groups\``);
+	await db.run(sql`drop table if exists \`posts\``);
+	await db.run(sql`drop table if exists \`comments\``);
+	await db.run(sql`drop table if exists \`comment_likes\``);
+
+	await db.run(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` integer DEFAULT 0 NOT NULL,
+			    \`invited_by\` integer
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`description\` text
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`users_to_groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`user_id\` integer NOT NULL,
+			    \`group_id\` integer NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`posts\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`owner_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`comments\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`creator\` integer,
+			    \`post_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`comment_likes\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`creator\` integer,
+			    \`comment_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+});
+
+/*
+	[Find Many] One relation users+posts
+*/
+
+test.concurrent('[Find Many] Get users with posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + limit posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	usersWithPosts[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		lowerName: 'dan',
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.2',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: 'Post1.3', createdAt: usersWithPosts[0]?.posts[2]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lowerName: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }, {
+			id: 5,
+			ownerId: 2,
+			content: 'Post2.1',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(usersWithPosts[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lowerName: 'alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }, {
+			id: 7,
+			ownerId: 3,
+			content: 'Post3.1',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		limit: 1,
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		lowerName: string;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+// TODO check order
+test.skip('[Find Many] Get users with posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				orderBy: {
+					content: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(2);
+	expect(usersWithPosts[1]?.posts.length).eq(2);
+	expect(usersWithPosts[2]?.posts.length).eq(3);
+
+	expect(usersWithPosts[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: '1', createdAt: usersWithPosts[2]?.posts[2]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: '2',
+			createdAt: usersWithPosts[2]?.posts[1]?.createdAt,
+		}, { id: 3, ownerId: 1, content: '3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 5,
+			ownerId: 2,
+			content: '5',
+			createdAt: usersWithPosts[1]?.posts[1]?.createdAt,
+		}, { id: 4, ownerId: 2, content: '4', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts[0]?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + where + partial. Did not select posts id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		posts: {
+			id: number;
+			content: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + where + partial(true + false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		posts: {
+			id: number;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts in transaction', async ({ db }) => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	await db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]).run();
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]).run();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts in rollbacked transaction', async ({ db }) => {
+	let usersWithPosts: {
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[] = [];
+
+	expect(db.transaction(async (tx) => {
+		await tx.insert(usersTable).values([
+			{ id: 1, name: 'Dan' },
+			{ id: 2, name: 'Andrew' },
+			{ id: 3, name: 'Alex' },
+		]).run();
+
+		await tx.insert(postsTable).values([
+			{ ownerId: 1, content: 'Post1' },
+			{ ownerId: 1, content: 'Post1.1' },
+			{ ownerId: 2, content: 'Post2' },
+			{ ownerId: 3, content: 'Post3' },
+		]).run();
+
+		await tx.rollback();
+
+		usersWithPosts = await tx.query.usersTable.findMany({
+			where: {
+				id: 1,
+			},
+			with: {
+				posts: {
+					where: {
+						id: 1,
+					},
+				},
+			},
+		});
+	})).rejects.toThrowError(new TransactionRollbackError());
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(0);
+});
+
+// select only custom
+test.concurrent('[Find Many] Get only custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 1, content: 'Post1.2' },
+		{ id: 3, ownerId: 1, content: 'Post1.3' },
+		{ id: 4, ownerId: 2, content: 'Post2' },
+		{ id: 5, ownerId: 2, content: 'Post2.1' },
+		{ id: 6, ownerId: 3, content: 'Post3' },
+		{ id: 7, ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(3);
+	expect(usersWithPosts[0]?.posts.length).toEqual(3);
+	expect(usersWithPosts[1]?.posts.length).toEqual(2);
+	expect(usersWithPosts[2]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts[0]?.lowerName).toEqual('dan');
+	expect(usersWithPosts[1]?.lowerName).toEqual('andrew');
+	expect(usersWithPosts[2]?.lowerName).toEqual('alex');
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts[0]?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2',
+	});
+
+	expect(usersWithPosts[1]?.posts).toContainEqual({
+		lowerName: 'post2.1',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3',
+	});
+
+	expect(usersWithPosts[2]?.posts).toContainEqual({
+		lowerName: 'post3.1',
+	});
+});
+
+test.concurrent('[Find Many] Get only custom fields + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test.concurrent('[Find Many] Get only custom fields + where + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test.concurrent('[Find Many] Get only custom fields + where + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		lowerName: string;
+		posts: {
+			lowerName: string;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).toEqual(1);
+	expect(usersWithPosts[0]?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toContainEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+// select only custom find one
+test.concurrent('[Find One] Get only custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.2',
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		lowerName: 'post1.3',
+	});
+});
+
+test.concurrent('[Find One] Get only custom fields + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }, { lowerName: 'post1.3' }],
+	});
+});
+
+test.concurrent('[Find One] Get only custom fields + where + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				limit: 1,
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.2' }],
+	});
+});
+
+test.concurrent('[Find One] Get only custom fields + where + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {},
+		with: {
+			posts: {
+				columns: {},
+				where: {
+					id: {
+						gte: 2,
+					},
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lowerName: ({ content }) => sql<string>`lower(${content})`.as('content_lower'),
+				}),
+			},
+		},
+		where: {
+			id: 1,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			lowerName: string;
+			posts: {
+				lowerName: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts?.posts.length).toEqual(2);
+
+	expect(usersWithPosts).toEqual({
+		lowerName: 'dan',
+		posts: [{ lowerName: 'post1.3' }, { lowerName: 'post1.2' }],
+	});
+});
+
+// columns {}
+test.concurrent('[Find Many] Get select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+// columns {}
+test.concurrent('[Find One] Get select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+// deep select {}
+test.concurrent('[Find Many] Get deep select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	await expect(async () =>
+		await db.query.usersTable.findMany({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+// deep select {}
+test.concurrent('[Find One] Get deep select {}', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	await expect(async () =>
+		await db.query.usersTable.findFirst({
+			columns: {},
+			with: {
+				posts: {
+					columns: {},
+				},
+			},
+		})
+	).rejects.toThrow(DrizzleError);
+});
+
+/*
+	Prepared statements for users+posts
+*/
+test.concurrent('[Find Many] Get users with posts + prepared limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		with: {
+			posts: {
+				limit: sql.placeholder('limit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.all({ limit: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(3);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+	expect(usersWithPosts[2]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + prepared limit + offset', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		with: {
+			posts: {
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.all({ pLimit: 1, uLimit: 3, uOffset: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(2);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+	expect(usersWithPosts[1]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[1]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + prepared where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		where: {
+			id: {
+				eq: sql.placeholder('id'),
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.all({ id: 1 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find Many] Get users with posts + prepared + limit + offset + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const prepared = db.query.usersTable.findMany({
+		limit: sql.placeholder('uLimit'),
+		offset: sql.placeholder('uOffset'),
+		where: {
+			id: {
+				OR: [{
+					eq: sql.placeholder('id'),
+				}, 3],
+			},
+		},
+		with: {
+			posts: {
+				where: {
+					id: {
+						eq: sql.placeholder('pid'),
+					},
+				},
+				limit: sql.placeholder('pLimit'),
+			},
+		},
+	}).prepare();
+
+	const usersWithPosts = await prepared.all({ pLimit: 1, uLimit: 3, uOffset: 1, id: 2, pid: 6 });
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+		}[];
+	}[]>();
+
+	expect(usersWithPosts.length).eq(1);
+	expect(usersWithPosts[0]?.posts.length).eq(1);
+
+	expect(usersWithPosts).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 6, ownerId: 3, content: 'Post3', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }],
+	});
+});
+
+/*
+	[Find One] One relation users+posts
+*/
+
+test.concurrent('[Find One] Get users with posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + limit posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts no results found', async ({ db }) => {
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts).toBeUndefined();
+});
+
+test.concurrent('[Find One] Get users with posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: true,
+		},
+		extras: ({
+			lowerName: ({ name }) => sql<string>`lower(${name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(3);
+
+	expect(usersWithPosts?.lowerName).toEqual('dan');
+	expect(usersWithPosts?.id).toEqual(1);
+	expect(usersWithPosts?.verified).toEqual(0);
+	expect(usersWithPosts?.invitedBy).toEqual(null);
+	expect(usersWithPosts?.name).toEqual('Dan');
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 1,
+		ownerId: 1,
+		content: 'Post1',
+		createdAt: usersWithPosts?.posts[0]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 2,
+		ownerId: 1,
+		content: 'Post1.2',
+		createdAt: usersWithPosts?.posts[1]?.createdAt,
+	});
+
+	expect(usersWithPosts?.posts).toContainEqual({
+		id: 3,
+		ownerId: 1,
+		content: 'Post1.3',
+		createdAt: usersWithPosts?.posts[2]?.createdAt,
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.2' },
+		{ ownerId: 1, content: 'Post1.3' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				limit: 1,
+			},
+		},
+		extras: ({
+			lowerName: (usersTable, { sql }) => sql<string>`lower(${usersTable.name})`.as('name_lower'),
+		}),
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lowerName: string;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).toEqual(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		lowerName: 'dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+// TODO. Check order
+test.skip('[Find One] Get users with posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: '1' },
+		{ ownerId: 1, content: '2' },
+		{ ownerId: 1, content: '3' },
+		{ ownerId: 2, content: '4' },
+		{ ownerId: 2, content: '5' },
+		{ ownerId: 3, content: '6' },
+		{ ownerId: 3, content: '7' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		with: {
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'desc',
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(2);
+
+	expect(usersWithPosts).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 7,
+			ownerId: 3,
+			content: '7',
+			createdAt: usersWithPosts?.posts[1]?.createdAt,
+		}, { id: 6, ownerId: 3, content: '6', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + where + partial. Did not select posts id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			posts: {
+				id: number;
+				content: string;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		name: 'Dan',
+		posts: [{ id: 1, content: 'Post1' }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + where + partial(true + false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			id: true,
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					id: true,
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			posts: {
+				id: number;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		posts: [{ id: 1 }],
+	});
+});
+
+test.concurrent('[Find One] Get users with posts + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const usersWithPosts = await db.query.usersTable.findFirst({
+		columns: {
+			name: false,
+		},
+		with: {
+			posts: {
+				columns: {
+					content: false,
+				},
+				where: {
+					id: 1,
+				},
+			},
+		},
+		where: {
+			id: 1,
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<
+		{
+			id: number;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				ownerId: number | null;
+				createdAt: Date;
+			}[];
+		} | undefined
+	>();
+
+	expect(usersWithPosts!.posts.length).eq(1);
+
+	expect(usersWithPosts).toEqual({
+		id: 1,
+		verified: 0,
+		invitedBy: null,
+		posts: [{ id: 1, ownerId: 1, createdAt: usersWithPosts?.posts[0]?.createdAt }],
+	});
+});
+
+/*
+	One relation users+users. Self referencing
+*/
+
+test.concurrent('Get user with invitee', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user + limit with invitee', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew', invitedBy: 1 },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+		},
+		limit: 2,
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user with invitee and custom fields', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[3]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user with invitee and custom fields + limits', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		limit: 3,
+		with: {
+			invitee: {
+				extras: ({ lower: (invitee, { sql }) => sql<string>`lower(${invitee.name})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				lower: string;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(3);
+	expect(usersWithInvitee[0]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user with invitee + order by', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[3]?.invitee).toBeNull();
+	expect(usersWithInvitee[2]?.invitee).toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user with invitee + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		with: {
+			invitee: true,
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+	});
+});
+
+test.concurrent('Get user with invitee + where + partial', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test.concurrent('Get user with invitee + where + partial.  Did not select users id, but used it in where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test.concurrent('Get user with invitee + where + partial(true+false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			id: true,
+			name: true,
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+					verified: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitee: {
+				id: number;
+				name: string;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitee: { id: 1, name: 'Dan' },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitee: { id: 2, name: 'Andrew' },
+	});
+});
+
+test.concurrent('Get user with invitee + where + partial(false)', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		columns: {
+			verified: false,
+		},
+		with: {
+			invitee: {
+				columns: {
+					name: false,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			invitedBy: number | null;
+			invitee: {
+				id: number;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(usersWithInvitee.length).eq(2);
+	expect(usersWithInvitee[0]?.invitee).not.toBeNull();
+	expect(usersWithInvitee[1]?.invitee).not.toBeNull();
+
+	expect(usersWithInvitee).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		invitedBy: 1,
+		invitee: { id: 1, verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee).toContainEqual({
+		id: 4,
+		name: 'John',
+		invitedBy: 2,
+		invitee: { id: 2, verified: 0, invitedBy: null },
+	});
+});
+
+/*
+	Two first-level relations users+users and users+posts
+*/
+
+test.concurrent('Get user with invitee and posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			invitee: true,
+			posts: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 3, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + limit posts and users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		with: {
+			invitee: true,
+			posts: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + limits + custom fields in each', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		limit: 3,
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_invitee_name') }),
+			},
+			posts: {
+				limit: 1,
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_content') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + custom fields in each', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+		with: {
+			invitee: {
+				extras: ({ lower: (users, { sql }) => sql<string>`lower(${users.name})`.as('lower_name') }),
+			},
+			posts: {
+				extras: ({ lower: (posts, { sql }) => sql<string>`lower(${posts.content})`.as('lower_name') }),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			lower: string;
+			invitedBy: number | null;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[1]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	response[2]?.posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(4);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).toBeNull();
+	expect(response[2]?.invitee).not.toBeNull();
+	expect(response[3]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(2);
+	expect(response[1]?.posts.length).eq(2);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 1, ownerId: 1, content: 'Post1', lower: 'post1', createdAt: response[0]?.posts[0]?.createdAt }, {
+			id: 2,
+			ownerId: 1,
+			content: 'Post1.1',
+			lower: 'post1.1',
+			createdAt: response[0]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 3, ownerId: 2, content: 'Post2', lower: 'post2', createdAt: response[1]?.posts[0]?.createdAt }, {
+			id: 4,
+			ownerId: 2,
+			content: 'Post2.1',
+			lower: 'post2.1',
+			createdAt: response[1]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', lower: 'dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', lower: 'post3', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 6,
+			ownerId: 3,
+			content: 'Post3.1',
+			lower: 'post3.1',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response).toContainEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+// TODO Check order
+test.skip('Get user with invitee and posts + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			invitee: true,
+			posts: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(4);
+
+	expect(response[3]?.invitee).toBeNull();
+	expect(response[2]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(2);
+	expect(response[3]?.posts.length).eq(2);
+
+	expect(response[3]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 1, content: 'Post1.1', createdAt: response[3]?.posts[0]?.createdAt }, {
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[2]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 4, ownerId: 2, content: 'Post2.1', createdAt: response[2]?.posts[0]?.createdAt }, {
+			id: 3,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[2]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			createdAt: response[3]?.posts[1]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [2, 3],
+			},
+		},
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(2);
+
+	expect(response[0]?.invitee).toBeNull();
+	expect(response[1]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		invitee: null,
+		posts: [{ id: 2, ownerId: 2, content: 'Post2', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + limit posts and users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+		{ ownerId: 3, content: 'Post3.1' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		limit: 1,
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: { id: number; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(1);
+
+	expect(response[0]?.invitee).not.toBeNull();
+	expect(response[0]?.posts.length).eq(1);
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{ id: 5, ownerId: 3, content: 'Post3', createdAt: response[0]?.posts[0]?.createdAt }],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + orderBy + where + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			invitee: true,
+			posts: {
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			posts: { id: number; lower: string; ownerId: number | null; content: string; createdAt: Date }[];
+			invitee: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: 1,
+		invitee: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+		posts: [{
+			id: 5,
+			ownerId: 3,
+			content: 'Post3',
+			lower: 'post3',
+			createdAt: response[1]?.posts[0]?.createdAt,
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		verified: 0,
+		invitedBy: 2,
+		invitee: { id: 2, name: 'Andrew', verified: 0, invitedBy: null },
+		posts: [],
+	});
+});
+
+test.concurrent('Get user with invitee and posts + orderBy + where + partial + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ ownerId: 1, content: 'Post1' },
+		{ ownerId: 1, content: 'Post1.1' },
+		{ ownerId: 2, content: 'Post2' },
+		{ ownerId: 2, content: 'Post2.1' },
+		{ ownerId: 3, content: 'Post3' },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		where: {
+			id: {
+				OR: [3, 4],
+			},
+		},
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		columns: {
+			id: true,
+			name: true,
+		},
+		with: {
+			invitee: {
+				columns: {
+					id: true,
+					name: true,
+				},
+				extras: ({
+					lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+				}),
+			},
+			posts: {
+				columns: {
+					id: true,
+					content: true,
+				},
+				where: {
+					ownerId: 3,
+				},
+				orderBy: {
+					id: 'desc',
+				},
+				extras: ({
+					lower: (postsTable) => sql<string>`lower(${postsTable.content})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			lower: string;
+			posts: { id: number; lower: string; content: string }[];
+			invitee: {
+				id: number;
+				name: string;
+				lower: string;
+			} | null;
+		}[]
+	>();
+
+	expect(response.length).eq(2);
+
+	expect(response[1]?.invitee).not.toBeNull();
+	expect(response[0]?.invitee).not.toBeNull();
+
+	expect(response[0]?.posts.length).eq(0);
+	expect(response[1]?.posts.length).eq(1);
+
+	expect(response[1]).toEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		invitee: { id: 1, name: 'Dan', lower: 'dan' },
+		posts: [{
+			id: 5,
+			content: 'Post3',
+			lower: 'post3',
+		}],
+	});
+	expect(response[0]).toEqual({
+		id: 4,
+		name: 'John',
+		lower: 'john',
+		invitee: { id: 2, name: 'Andrew', lower: 'andrew' },
+		posts: [],
+	});
+});
+
+/*
+	One two-level relation users+posts+comments
+*/
+
+test.concurrent('Get user with posts and posts with comments', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]).run();
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			posts: {
+				id: number;
+				content: string;
+				ownerId: number | null;
+				createdAt: Date;
+				comments: {
+					id: number;
+					content: string;
+					createdAt: Date;
+					creator: number | null;
+					postId: number | null;
+				}[];
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	// expect(response[2]).toEqual({
+	// 	id: 3,
+	// 	name: 'Alex',
+	// 	verified: 0,
+	// 	invitedBy: null,
+	// 	posts: [{
+	// 		id: 3,
+	// 		ownerId: 3,
+	// 		content: 'Post3',
+	// 		createdAt: response[2]?.posts[0]?.createdAt,
+	// 		comments: [
+	// 			{
+	// 				id: ,
+	// 				content: 'Comment3',
+	// 				creator: 3,
+	// 				postId: 3,
+	// 				createdAt: response[2]?.posts[0]?.comments[0]?.createdAt,
+	// 			},
+	// 		],
+	// 	}],
+	// });
+});
+
+// Get user with limit posts and limit comments
+
+// Get user with custom field + post + comment with custom field
+
+// Get user with limit + posts orderBy + comment orderBy
+
+// Get user with where + posts where + comment where
+
+// Get user with where + posts partial where + comment where
+
+// Get user with where + posts partial where + comment partial(false) where
+
+// Get user with where partial(false) + posts partial where partial(false) + comment partial(false+true) where
+
+// Get user with where + posts partial where + comment where. Didn't select field from where in posts
+
+// Get user with where + posts partial where + comment where. Didn't select field from where for all
+
+// Get with limit+offset in each
+
+/*
+	One two-level + One first-level relation users+posts+comments and users+users
+*/
+
+/*
+	One three-level relation users+posts+comments+comment_owner
+*/
+
+test.concurrent('Get user with posts and posts with comments and comments with owner', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1' },
+		{ id: 2, ownerId: 2, content: 'Post2' },
+		{ id: 3, ownerId: 3, content: 'Post3' },
+	]).run();
+
+	await db.insert(commentsTable).values([
+		{ postId: 1, content: 'Comment1', creator: 2 },
+		{ postId: 2, content: 'Comment2', creator: 2 },
+		{ postId: 3, content: 'Comment3', creator: 3 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: {
+						with: {
+							author: true,
+						},
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		posts: {
+			id: number;
+			content: string;
+			ownerId: number | null;
+			createdAt: Date;
+			comments: {
+				id: number;
+				content: string;
+				createdAt: Date;
+				creator: number | null;
+				postId: number | null;
+				author: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).eq(3);
+	expect(response[0]?.posts.length).eq(1);
+	expect(response[1]?.posts.length).eq(1);
+	expect(response[2]?.posts.length).eq(1);
+
+	expect(response[0]?.posts[0]?.comments.length).eq(1);
+	expect(response[1]?.posts[0]?.comments.length).eq(1);
+	expect(response[2]?.posts[0]?.comments.length).eq(1);
+
+	expect(response[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 1,
+			ownerId: 1,
+			content: 'Post1',
+			createdAt: response[0]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 1,
+					content: 'Comment1',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: 0,
+						invitedBy: null,
+					},
+					postId: 1,
+					createdAt: response[0]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		posts: [{
+			id: 2,
+			ownerId: 2,
+			content: 'Post2',
+			createdAt: response[1]?.posts[0]?.createdAt,
+			comments: [
+				{
+					id: 2,
+					content: 'Comment2',
+					creator: 2,
+					author: {
+						id: 2,
+						name: 'Andrew',
+						verified: 0,
+						invitedBy: null,
+					},
+					postId: 2,
+					createdAt: response[1]?.posts[0]?.comments[0]?.createdAt,
+				},
+			],
+		}],
+	});
+});
+
+/*
+	One three-level relation + 1 first-level relatioon
+	1. users+posts+comments+comment_owner
+	2. users+users
+*/
+
+/*
+	One four-level relation users+posts+comments+coment_likes
+*/
+
+/*
+	[Find Many] Many-to-many cases
+
+	Users+users_to_groups+groups
+*/
+
+test.concurrent('[Find Many] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				orderBy: {
+					groupId: 'asc',
+				},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(1);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(0);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(0);
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [],
+	});
+});
+
+test.concurrent('[Find Many] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(2);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersToGroups: {
+			user: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response[2]).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find Many] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		usersToGroups: {
+			group: {
+				id: number;
+				name: string;
+				description: string | null;
+			};
+		}[];
+	}[]>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+/*
+	[Find One] Many-to-many cases
+
+	Users+users_to_groups+groups
+*/
+
+test.concurrent('[Find One] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			usersToGroups: {
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 1,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				limit: 1,
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					groupId: 2,
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(0);
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [],
+	});
+});
+
+test.concurrent('[Find One] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: {
+				gt: 1,
+			},
+		},
+		with: {
+			usersToGroups: {
+				where: {
+					userId: 2,
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(2);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('[Find One] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					groupId: 'desc',
+				},
+				columns: {},
+				with: {
+					group: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+				};
+			}[];
+		} | undefined
+	>();
+
+	expect(response?.usersToGroups.length).toEqual(1);
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('Get groups with users + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			usersToGroups: {
+				limit: 1,
+				orderBy: {
+					userId: 'desc',
+				},
+				columns: {},
+				with: {
+					user: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+				};
+			}[];
+		}[]
+	>();
+
+	expect(response.length).toEqual(2);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+
+	expect(response[1]).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response[0]).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('Get users with groups + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: (usersTable) => sql<string>`lower(${usersTable.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					group: {
+						extras: ({
+							lower: (groupsTable) => sql<string>`lower(${groupsTable.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			usersToGroups: {
+				group: {
+					id: number;
+					name: string;
+					description: string | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	response[0]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+	response[1]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+	response[2]?.usersToGroups.sort((a, b) => (a.group.id > b.group.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(1);
+	expect(response[2]?.usersToGroups.length).toEqual(2);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 1,
+				name: 'Group1',
+				lower: 'group1',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: null,
+		usersToGroups: [{
+			group: {
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+		}, {
+			group: {
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('Get groups with users + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]).run();
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]).run();
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]).run();
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			usersToGroups: {
+				columns: {},
+				with: {
+					user: {
+						extras: ({
+							lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+						}),
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			usersToGroups: {
+				user: {
+					id: number;
+					name: string;
+					verified: number;
+					invitedBy: number | null;
+					lower: string;
+				};
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response.length).toEqual(3);
+
+	expect(response[0]?.usersToGroups.length).toEqual(1);
+	expect(response[1]?.usersToGroups.length).toEqual(2);
+	expect(response[2]?.usersToGroups.length).toEqual(1);
+
+	expect(response).toContainEqual({
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 1,
+				name: 'Dan',
+				lower: 'dan',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 2,
+				name: 'Andrew',
+				lower: 'andrew',
+				verified: 0,
+				invitedBy: null,
+			},
+		}, {
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+
+	expect(response).toContainEqual({
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		usersToGroups: [{
+			user: {
+				id: 3,
+				name: 'Alex',
+				lower: 'alex',
+				verified: 0,
+				invitedBy: null,
+			},
+		}],
+	});
+});
+
+test.concurrent('async api', async ({ db }) => {
+	await db.insert(usersTable).values([{ id: 1, name: 'Dan' }]);
+	const users = await db.query.usersTable.findMany();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test.concurrent('async api - prepare', async ({ db }) => {
+	const insertStmt = db.insert(usersTable).values([{ id: 1, name: 'Dan' }]).prepare();
+	await insertStmt.execute();
+	const queryStmt = db.query.usersTable.findMany().prepare();
+	const users = await queryStmt.execute();
+	expect(users).toEqual([{ id: 1, name: 'Dan', verified: 0, invitedBy: null }]);
+});
+
+test.concurrent('Force optional on where on non-optional relation query', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex', invitedBy: 1 },
+		{ id: 4, name: 'John', invitedBy: 2 },
+	]);
+
+	const usersWithInvitee = await db.query.usersTable.findMany({
+		with: {
+			inviteeRequired: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithInvitee).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			inviteeRequired: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			} | null;
+		}[]
+	>();
+
+	usersWithInvitee.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithInvitee.length).eq(4);
+	expect(usersWithInvitee[0]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[1]?.inviteeRequired).toBeNull();
+	expect(usersWithInvitee[2]?.inviteeRequired).not.toBeNull();
+	expect(usersWithInvitee[3]?.inviteeRequired).toBeNull();
+
+	expect(usersWithInvitee[0]).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[1]).toEqual({
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		inviteeRequired: null,
+	});
+	expect(usersWithInvitee[2]).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: 1,
+		inviteeRequired: { id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	});
+	expect(usersWithInvitee[3]).toEqual({
+		id: 4,
+		name: 'John',
+		verified: 0,
+		invitedBy: 2,
+		inviteeRequired: null,
+	});
+});
+
+test.concurrent('[Find Many .through] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'asc',
+				},
+			},
+		},
+		orderBy: {
+			id: 'asc',
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		limit: 1,
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		limit: 1,
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		users: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groups: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find One .through] Get users with groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get groups with users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get users with groups + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		with: {
+			groups: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get groups with users + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		with: {
+			users: {
+				limit: 1,
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get users with groups + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 1,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			description: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get groups with users + limit + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get users with groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		where: {
+			id: {
+				OR: [1, 2],
+			},
+		},
+		with: {
+			groups: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [],
+	});
+});
+
+test.concurrent('[Find One .through] Get groups with users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		where: {
+			id: { gt: 1 },
+		},
+		with: {
+			users: {
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get users with groups + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toStrictEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}, {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get groups with users + orderBy', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			users: {
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	});
+});
+
+test.concurrent('[Find One .through] Get users with groups + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findFirst({
+		orderBy: {
+			id: 'desc',
+		},
+		with: {
+			groups: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+			}[];
+		} | undefined
+	>();
+
+	expect(response).toEqual({
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 3,
+			name: 'Group3',
+			description: null,
+		}],
+	});
+});
+
+test.concurrent('[Find Many .through] Get groups with users + orderBy + limit', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		orderBy: {
+			id: 'desc',
+		},
+		limit: 2,
+		with: {
+			users: {
+				limit: 1,
+				orderBy: {
+					id: 'desc',
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+			}[];
+		}[]
+	>();
+
+	expect(response).toStrictEqual([{
+		id: 3,
+		name: 'Group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with groups + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		extras: ({
+			lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+		}),
+		with: {
+			groups: {
+				orderBy: {
+					id: 'asc',
+				},
+				extras: ({
+					lower: ({ name }) => sql<string>`lower(${name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+			lower: string;
+			groups: {
+				id: number;
+				name: string;
+				description: string | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groups.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		lower: 'dan',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 1,
+			name: 'Group1',
+			lower: 'group1',
+			description: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		lower: 'andrew',
+		verified: 0,
+		invitedBy: null,
+		groups: [{
+			id: 2,
+			name: 'Group2',
+			lower: 'group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		lower: 'alex',
+		verified: 0,
+		invitedBy: null,
+		groups: [
+			{
+				id: 2,
+				name: 'Group2',
+				lower: 'group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				lower: 'group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with users + custom', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		extras: ({
+			lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+		}),
+		with: {
+			users: {
+				extras: ({
+					lower: (table, { sql }) => sql<string>`lower(${table.name})`.as('lower_name'),
+				}),
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<
+		{
+			id: number;
+			name: string;
+			description: string | null;
+			lower: string;
+			users: {
+				id: number;
+				name: string;
+				verified: number;
+				invitedBy: number | null;
+				lower: string;
+			}[];
+		}[]
+	>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.users.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		lower: 'group1',
+		description: null,
+		users: [{
+			id: 1,
+			name: 'Dan',
+			lower: 'dan',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 2,
+		name: 'Group2',
+		lower: 'group2',
+		description: null,
+		users: [{
+			id: 2,
+			name: 'Andrew',
+			lower: 'andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		lower: 'group3',
+		description: null,
+		users: [{
+			id: 3,
+			name: 'Alex',
+			lower: 'alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with first group', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 3, name: 'Group3' },
+		{ id: 2, name: 'Group2' },
+		{ id: 1, name: 'Group1' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 3, groupId: 2 },
+		{ userId: 2, groupId: 3 },
+		{ userId: 2, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			group: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		group: {
+			id: number;
+			name: string;
+			description: string | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		group: null,
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		group: {
+			id: 3,
+			name: 'Group3',
+			description: null,
+		},
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		group: {
+			id: 2,
+			name: 'Group2',
+			description: null,
+		},
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with first user', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			user: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		user: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		} | null;
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		user: null,
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		user: {
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		},
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		user: {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		},
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with filtered groups', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+			{
+				id: 3,
+				name: 'Group3',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with filtered users', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: true,
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}, {
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [{
+			id: 3,
+			name: 'Alex',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get users with filtered groups + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.usersTable.findMany({
+		with: {
+			groupsFiltered: {
+				where: {
+					id: {
+						lt: 3,
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		groupsFiltered: {
+			id: number;
+			name: string;
+			description: string | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.groupsFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [{
+			id: 2,
+			name: 'Group2',
+			description: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		groupsFiltered: [
+			{
+				id: 2,
+				name: 'Group2',
+				description: null,
+			},
+		],
+	}]);
+});
+
+test.concurrent('[Find Many .through] Get groups with filtered users + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(groupsTable).values([
+		{ id: 1, name: 'Group1' },
+		{ id: 2, name: 'Group2' },
+		{ id: 3, name: 'Group3' },
+	]);
+
+	await db.insert(usersToGroupsTable).values([
+		{ userId: 1, groupId: 1 },
+		{ userId: 2, groupId: 2 },
+		{ userId: 3, groupId: 3 },
+		{ userId: 3, groupId: 2 },
+	]);
+
+	const response = await db.query.groupsTable.findMany({
+		with: {
+			usersFiltered: {
+				where: { id: { lt: 3 } },
+			},
+		},
+	});
+
+	expectTypeOf(response).toEqualTypeOf<{
+		id: number;
+		name: string;
+		description: string | null;
+		usersFiltered: {
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[];
+	}[]>();
+
+	response.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	for (const e of response) {
+		e.usersFiltered.sort((a, b) => (a.id > b.id) ? 1 : -1);
+	}
+
+	expect(response).toStrictEqual([{
+		id: 1,
+		name: 'Group1',
+		description: null,
+		usersFiltered: [],
+	}, {
+		id: 2,
+		name: 'Group2',
+		description: null,
+		usersFiltered: [{
+			id: 2,
+			name: 'Andrew',
+			verified: 0,
+			invitedBy: null,
+		}],
+	}, {
+		id: 3,
+		name: 'Group3',
+		description: null,
+		usersFiltered: [],
+	}]);
+});
+
+test.concurrent('[Find Many] Get users with filtered posts', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.1' },
+			{ ownerId: 2, content: 'Post2.2' },
+			{ ownerId: 2, content: 'Post2.3' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test.concurrent('[Find Many] Get posts with filtered authors', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorFiltered: {
+			id: number;
+			name: string;
+		};
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorFiltered: null },
+		{ id: 4, content: 'Post1.2', authorFiltered: null },
+		{
+			id: 5,
+			content: 'Post2.2',
+			authorFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 6, content: 'Post3.2', authorFiltered: null },
+	]);
+});
+
+test.concurrent('[Find Many] Get users with filtered posts + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+		{ id: 7, ownerId: 1, content: 'Post1.3' },
+		{ id: 8, ownerId: 2, content: 'Post2.3' },
+		{ id: 9, ownerId: 3, content: 'Post3.3' },
+	]);
+
+	const usersWithPosts = await db.query.usersTable.findMany({
+		with: {
+			postsFiltered: {
+				columns: {
+					ownerId: true,
+					content: true,
+				},
+				where: {
+					content: {
+						like: '%.2',
+					},
+				},
+			},
+		},
+	});
+
+	expectTypeOf(usersWithPosts).toEqualTypeOf<{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+		postsFiltered: {
+			ownerId: number | null;
+			content: string;
+		}[];
+	}[]>();
+
+	usersWithPosts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(usersWithPosts).toStrictEqual([{
+		id: 1,
+		name: 'Dan',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}, {
+		id: 2,
+		name: 'Andrew',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [
+			{ ownerId: 2, content: 'Post2.2' },
+		],
+	}, {
+		id: 3,
+		name: 'Alex',
+		verified: 0,
+		invitedBy: null,
+		postsFiltered: [],
+	}]);
+});
+
+test.concurrent('[Find Many] Get posts with filtered authors + where', async ({ db }) => {
+	await db.insert(usersTable).values([
+		{ id: 1, name: 'Dan' },
+		{ id: 2, name: 'Andrew' },
+		{ id: 3, name: 'Alex' },
+	]);
+
+	await db.insert(postsTable).values([
+		{ id: 1, ownerId: 1, content: 'Post1.1' },
+		{ id: 2, ownerId: 2, content: 'Post2.1' },
+		{ id: 3, ownerId: 3, content: 'Post3.1' },
+		{ id: 4, ownerId: 1, content: 'Post1.2' },
+		{ id: 5, ownerId: 2, content: 'Post2.2' },
+		{ id: 6, ownerId: 3, content: 'Post3.2' },
+	]);
+
+	const posts = await db.query.postsTable.findMany({
+		columns: {
+			id: true,
+			content: true,
+		},
+		with: {
+			authorAltFiltered: {
+				columns: {
+					name: true,
+					id: true,
+				},
+				where: {
+					id: 2,
+				},
+			},
+		},
+	});
+
+	expectTypeOf(posts).toEqualTypeOf<{
+		id: number;
+		content: string;
+		authorAltFiltered: {
+			id: number;
+			name: string;
+		} | null;
+	}[]>();
+
+	posts.sort((a, b) => (a.id > b.id) ? 1 : -1);
+
+	expect(posts).toStrictEqual([
+		{ id: 1, content: 'Post1.1', authorAltFiltered: null },
+		{
+			id: 2,
+			content: 'Post2.1',
+			authorAltFiltered: {
+				id: 2,
+				name: 'Andrew',
+			},
+		},
+		{ id: 3, content: 'Post3.1', authorAltFiltered: null },
+		{ id: 4, content: 'Post1.2', authorAltFiltered: null },
+		{ id: 5, content: 'Post2.2', authorAltFiltered: null },
+		{ id: 6, content: 'Post3.2', authorAltFiltered: null },
+	]);
+});
+
+test.concurrent('.toSQL()', ({ db }) => {
+	const query = db.query.usersTable.findFirst().toSQL();
+
+	expect(query).toHaveProperty('sql', expect.any(String));
+	expect(query).toHaveProperty('params', expect.any(Array));
+});
diff --git a/integration-tests/tests/sqlite/tursodatabase-serverless.test.ts b/integration-tests/tests/sqlite/tursodatabase-serverless.test.ts
new file mode 100644
index 0000000000..8bbfc32cf1
--- /dev/null
+++ b/integration-tests/tests/sqlite/tursodatabase-serverless.test.ts
@@ -0,0 +1,204 @@
+import { sql } from 'drizzle-orm';
+import { getTableConfig, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { TursoDatabaseDatabase } from 'drizzle-orm/tursodatabase';
+import { migrate } from 'drizzle-orm/tursodatabase-serverless/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { tursoDatabaseServerlessTest as test } from './instrumentation';
+import relations from './relations';
+import { tests } from './sqlite-common';
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+test('migrator', async ({ db }) => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sqlite-cloud';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip: string[] = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+
+	// ORDER BY clause is not supported in DELETE
+	'delete with limit and order by',
+	// ORDER BY is not supported in UPDATE
+	'update with limit and order by',
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/tursodatabase-sync.test.ts b/integration-tests/tests/sqlite/tursodatabase-sync.test.ts
new file mode 100644
index 0000000000..86a0b521df
--- /dev/null
+++ b/integration-tests/tests/sqlite/tursodatabase-sync.test.ts
@@ -0,0 +1,208 @@
+import { sql } from 'drizzle-orm';
+import { getTableConfig, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { TursoDatabaseSyncDatabase } from 'drizzle-orm/tursodatabase-sync';
+import { migrate } from 'drizzle-orm/tursodatabase-sync/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { tursoDatabaseSyncTest as test } from './instrumentation';
+import relations from './relations';
+import { tests } from './sqlite-common';
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+test('migrator', async ({ db }) => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sqlite-cloud';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as TursoDatabaseSyncDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+
+	// ORDER BY clause is not supported in DELETE
+	'delete with limit and order by',
+	// ORDER BY is not supported in UPDATE
+	'update with limit and order by',
+
+	// Raw query field names differ
+	'insert via db.get',
+	'insert via db.get w/ query builder',
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/tursodatabase.test.ts b/integration-tests/tests/sqlite/tursodatabase.test.ts
new file mode 100644
index 0000000000..94db3f74dc
--- /dev/null
+++ b/integration-tests/tests/sqlite/tursodatabase.test.ts
@@ -0,0 +1,208 @@
+import { sql } from 'drizzle-orm';
+import { getTableConfig, int, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import type { TursoDatabaseDatabase } from 'drizzle-orm/tursodatabase';
+import { migrate } from 'drizzle-orm/tursodatabase/migrator';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { expect } from 'vitest';
+import { tursoDatabaseTest as test } from './instrumentation';
+import relations from './relations';
+import { tests } from './sqlite-common';
+
+export const usersMigratorTable = sqliteTable('users12', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+export const anotherUsersMigratorTable = sqliteTable('another_users', {
+	id: integer('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+test('migrator', async ({ db }) => {
+	await db.run(sql`drop table if exists another_users`);
+	await db.run(sql`drop table if exists users12`);
+	await db.run(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: './drizzle2/sqlite' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result = await db.select().from(usersMigratorTable).all();
+	await db.insert(anotherUsersMigratorTable).values({ name: 'John', email: 'email' }).run();
+	const result2 = await db.select().from(anotherUsersMigratorTable).all();
+
+	expect(result).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+	expect(result2).toEqual([{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.run(sql`drop table another_users`);
+	await db.run(sql`drop table users12`);
+	await db.run(sql`drop table __drizzle_migrations`);
+});
+
+test('migrator : --init', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual(undefined);
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - local migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'localMigrations' });
+	expect(meta.length).toStrictEqual(0);
+	expect(!!res).toStrictEqual(false);
+});
+
+test('migrator : --init - db migrations error', async ({ db }) => {
+	const migrationsTable = 'drzl_init';
+
+	await db.run(sql`drop table if exists ${sql.identifier(migrationsTable)};`);
+	await db.run(sql`drop table if exists ${usersMigratorTable}`);
+	await db.run(sql`drop table if exists ${sql.identifier('another_users')}`);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite',
+		migrationsTable,
+	});
+
+	const migratorRes = await migrate(db as TursoDatabaseDatabase<typeof relations>, {
+		migrationsFolder: './drizzle2/sqlite-init',
+
+		migrationsTable,
+		// @ts-ignore - internal param
+		init: true,
+	});
+
+	const meta = await db.select({
+		hash: sql<string>`${sql.identifier('hash')}`.as('hash'),
+		createdAt: sql<number>`${sql.identifier('created_at')}`.mapWith(Number).as('created_at'),
+	}).from(sql`${sql.identifier(migrationsTable)}`);
+
+	const res = await db.get<{ name: string }>(
+		sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${getTableConfig(usersMigratorTable).name};`,
+	);
+
+	expect(migratorRes).toStrictEqual({ exitCode: 'databaseMigrations' });
+	expect(meta.length).toStrictEqual(1);
+	expect(!!res).toStrictEqual(true);
+});
+
+test('migrator: local migration is unapplied. Migrations timestamp is less than last db migration', async ({ db }) => {
+	const users = sqliteTable('migration_users', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	const users2 = sqliteTable('migration_users2', {
+		id: int('id').primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		age: int(),
+	});
+
+	await db.run(sql`drop table if exists \`__drizzle_migrations\`;`);
+	await db.run(sql`drop table if exists ${users}`);
+	await db.run(sql`drop table if exists ${users2}`);
+
+	// create migration directory
+	const migrationDir = './migrations/sqlite-cloud';
+	if (existsSync(migrationDir)) rmSync(migrationDir, { recursive: true });
+	mkdirSync(migrationDir, { recursive: true });
+
+	// first branch
+	mkdirSync(`${migrationDir}/20240101010101_initial`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240101010101_initial/migration.sql`,
+		`CREATE TABLE "migration_users" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n);`,
+	);
+	mkdirSync(`${migrationDir}/20240303030303_third`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240303030303_third/migration.sql`,
+		`ALTER TABLE "migration_users" ADD COLUMN "age" integer;`,
+	);
+
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: migrationDir });
+	const res1 = await db.insert(users).values({ name: 'John', email: '', age: 30 }).returning();
+
+	// second migration was not applied yet
+	await expect(db.insert(users2).values({ name: 'John', email: '', age: 30 })).rejects.toThrowError();
+
+	// insert migration with earlier timestamp
+	mkdirSync(`${migrationDir}/20240202020202_second`, { recursive: true });
+	writeFileSync(
+		`${migrationDir}/20240202020202_second/migration.sql`,
+		`CREATE TABLE "migration_users2" (\n"id" integer PRIMARY KEY NOT NULL,\n"name" text NOT NULL,\n"email" text NOT NULL\n,"age" integer\n);`,
+	);
+	await migrate(db as TursoDatabaseDatabase<typeof relations>, { migrationsFolder: migrationDir });
+
+	const res2 = await db.insert(users2).values({ name: 'John', email: '', age: 30 }).returning();
+
+	const expected = [{ id: 1, name: 'John', email: '', age: 30 }];
+	expect(res1).toStrictEqual(expected);
+	expect(res2).toStrictEqual(expected);
+
+	rmSync(migrationDir, { recursive: true });
+});
+
+const skip = [
+	// Uses async versions
+	'sync transaction rollback',
+	'sync nested transaction rollback',
+
+	// ORDER BY clause is not supported in DELETE
+	'delete with limit and order by',
+	// ORDER BY is not supported in UPDATE
+	'update with limit and order by',
+
+	// Raw query field names differ
+	'insert via db.get',
+	'insert via db.get w/ query builder',
+];
+tests(test, skip);
diff --git a/integration-tests/tests/sqlite/wasm-fetch-patch.ts b/integration-tests/tests/sqlite/wasm-fetch-patch.ts
new file mode 100644
index 0000000000..12ff893620
--- /dev/null
+++ b/integration-tests/tests/sqlite/wasm-fetch-patch.ts
@@ -0,0 +1,23 @@
+// Patch Node's fetch to work with wasm drivers
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const originalFetch = globalThis.fetch;
+
+globalThis.fetch = (async (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+	const url = typeof input === 'string'
+		? input
+		: input instanceof URL
+		? input.href
+		: (input as Request).url;
+
+	if (typeof url === 'string' && url.startsWith('file://')) {
+		const path = fileURLToPath(url);
+		const data = await readFile(path);
+		const headers = new Headers();
+		if (path.endsWith('.wasm')) headers.set('content-type', 'application/wasm');
+		return new Response(data, { status: 200, headers });
+	}
+
+	return originalFetch(input, init);
+}) as typeof fetch;
diff --git a/integration-tests/tests/utils/is-config.test.ts b/integration-tests/tests/utils/is-config.test.ts
index a71a753c2f..36291ce4db 100644
--- a/integration-tests/tests/utils/is-config.test.ts
+++ b/integration-tests/tests/utils/is-config.test.ts
@@ -36,7 +36,7 @@ describe('Objects', (it) => {
 			isConfig({
 				casing: 'camelCase',
 			} as DrizzleConfig),
-		).toEqual(true);
+		).toEqual(false); // No more casings on DB
 
 		expect(
 			isConfig({
@@ -72,7 +72,7 @@ describe('Objects', (it) => {
 
 		expect(
 			isConfig({
-				casing: 'camelCase',
+				logger: true,
 				trash: true,
 			} as DrizzleConfig),
 		).toEqual(true);
@@ -180,7 +180,7 @@ describe('Rejects drivers', (it) => {
 
 	it('vercel:Client', async () => {
 		const cl = vcClient({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
+			connectionString: process.env['NEON_CONNECTION_STRING']?.replace('-pooler', ''),
 		});
 
 		const res = isConfig(cl);
@@ -374,7 +374,7 @@ describe('Accepts drivers in .client', (it) => {
 
 	it('vercel:Client', async () => {
 		const cl = vcClient({
-			connectionString: process.env['NEON_CONNECTION_STRING'],
+			connectionString: process.env['NEON_CONNECTION_STRING']?.replace('-pooler', ''),
 		});
 
 		const res = isConfig({ client: cl });
@@ -461,7 +461,7 @@ describe('Accepts drivers in .client', (it) => {
 	});
 
 	it('mysql2/promise:Pool', async () => {
-		const cl = await ms2pPool({
+		const cl = ms2pPool({
 			uri: process.env['MYSQL_CONNECTION_STRING'],
 		});
 
diff --git a/integration-tests/tests/version.test.ts b/integration-tests/tests/utils/version.test.ts
similarity index 100%
rename from integration-tests/tests/version.test.ts
rename to integration-tests/tests/utils/version.test.ts
diff --git a/integration-tests/tests/validators/arktype/cockroach.test.ts b/integration-tests/tests/validators/arktype/cockroach.test.ts
new file mode 100644
index 0000000000..6a469387a8
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/cockroach.test.ts
@@ -0,0 +1,563 @@
+import { type Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import { bigintNarrow, jsonSchema } from 'drizzle-orm/arktype/column';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	jsonb,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
+const int4NullableSchema = int4Schema.or(type.null);
+const int4OptionalSchema = int4Schema.optional();
+const int4NullableOptionalSchema = int4Schema.or(type.null).optional();
+
+const textSchema = type.string;
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = type('unknown.any');
+
+const extendedSchema = int4Schema.atMost(1000);
+const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: int4Schema, generated: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({
+		id: int4Schema,
+		nested: type({ name: textSchema, age: anySchema }),
+		table: type({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = type.enumerated('a', 'b', 'c');
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		nested: {
+			c5: (schema) => schema.atMost(1000),
+			c6: type.string.pipe(Number),
+		},
+		table: {
+			c2: (schema) => schema.atMost(1000),
+			c3: type.string.pipe(Number),
+		},
+	});
+	const expected = type({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: type({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: type({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		boolean: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigint2: type.bigint.narrow(bigintNarrow),
+		bit: type(/^[01]{5}$/).describe('a string containing ones or zeros while being 5 characters long'),
+		boolean: type.boolean,
+		char1: type.string.atMostLength(10),
+		char2: type.enumerated('a', 'b', 'c'),
+		date1: type.Date,
+		date2: type.string,
+		decimal1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		decimal2: type.bigint.narrow(bigintNarrow),
+		decimal3: type.string,
+		float: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		doublePrecision: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		geometry1: type([type.number, type.number]),
+		geometry2: type({ x: type.number, y: type.number }),
+		inet: type.string,
+		int2: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		int4: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		int8_1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		int8_2: type.bigint.narrow(bigintNarrow),
+		interval: type.string,
+		jsonb: jsonSchema,
+		numeric1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		numeric2: type.bigint.narrow(bigintNarrow),
+		numeric3: type.string,
+		real: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		smallint: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		string1: type.string,
+		string2: type.enumerated('a', 'b', 'c'),
+		text1: type.string,
+		text2: type.enumerated('a', 'b', 'c'),
+		time: type.string,
+		timestamp1: type.Date,
+		timestamp2: type.string,
+		uuid: type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID'),
+		varchar1: type.string.atMostLength(10),
+		varchar2: type.enumerated('a', 'b', 'c'),
+		vector: type.number.array().exactlyLength(3),
+		array: int4Schema.array(),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: type.string });
+}
diff --git a/integration-tests/tests/validators/arktype/mssql.test.ts b/integration-tests/tests/validators/arktype/mssql.test.ts
new file mode 100644
index 0000000000..b0a9d4ea85
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/mssql.test.ts
@@ -0,0 +1,503 @@
+import { Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import { bigintNarrow, bigintStringModeSchema, bufferSchema } from 'drizzle-orm/arktype/column';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const integerSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
+const integerNullableSchema = integerSchema.or(type.null);
+const integerOptionalSchema = integerSchema.optional();
+const integerNullableOptionalSchema = integerSchema.or(type.null).optional();
+
+const textSchema = type.string;
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = type('unknown.any');
+
+const extendedSchema = integerSchema.atMost(1000);
+const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({
+		id: integerSchema,
+		nested: type({ name: textSchema, age: anySchema }),
+		table: type({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		nested: {
+			c5: (schema) => schema.atMost(1000),
+			c6: type.string.pipe(Number),
+		},
+		table: {
+			c2: (schema) => schema.atMost(1000),
+			c3: type.string.pipe(Number),
+		},
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: type({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: type({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigint2: type.bigint.narrow(bigintNarrow),
+		bigint3: bigintStringModeSchema,
+		binary: bufferSchema,
+		bit: type.boolean,
+		char1: type.string.atMostLength(10),
+		char2: type.enumerated('a', 'b', 'c'),
+		date1: type.Date,
+		date2: type.string,
+		datetime1: type.Date,
+		datetime2: type.string,
+		datetime2_1: type.Date,
+		datetime2_2: type.string,
+		datetimeoffset1: type.Date,
+		datetimeoffset2: type.string,
+		decimal1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		decimal2: type.bigint.narrow(bigintNarrow),
+		decimal3: type.string,
+		float: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		int: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		numeric1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		numeric2: type.bigint.narrow(bigintNarrow),
+		numeric3: type.string,
+		real: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		smallint: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		text1: type.string,
+		text2: type.enumerated('a', 'b', 'c'),
+		time1: type.Date,
+		time2: type.string,
+		tinyint: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT8_UNSIGNED_MAX),
+		varbinary: bufferSchema,
+		varchar1: type.string.atMostLength(10),
+		varchar2: type.enumerated('a', 'b', 'c'),
+		ntext1: type.string,
+		ntext2: type.enumerated('a', 'b', 'c'),
+		nvarchar1: type.string.atMostLength(10),
+		nvarchar2: type.enumerated('a', 'b', 'c'),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: type.string });
+}
diff --git a/integration-tests/tests/validators/arktype/mysql.test.ts b/integration-tests/tests/validators/arktype/mysql.test.ts
new file mode 100644
index 0000000000..57c00fe00c
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/mysql.test.ts
@@ -0,0 +1,547 @@
+import { type Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import {
+	bigintNarrow,
+	bigintStringModeSchema,
+	jsonSchema,
+	unsignedBigintNarrow,
+	unsignedBigintStringModeSchema,
+} from 'drizzle-orm/arktype/column';
+import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
+const intNullableSchema = intSchema.or(type.null);
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intSchema.or(type.null).optional();
+
+const serialSchema = type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER);
+const serialOptionalSchema = serialSchema.optional();
+
+const textSchema = type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX);
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = type('unknown.any');
+
+const extendedSchema = intSchema.atMost(1000);
+const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: serialSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({
+		id: serialSchema,
+		nested: type({ name: textSchema, age: anySchema }),
+		table: type({ id: serialSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		nested: {
+			c5: (schema) => schema.atMost(1000),
+			c6: type.string.pipe(Number),
+		},
+		table: {
+			c2: (schema) => schema.atMost(1000),
+			c3: type.string.pipe(Number),
+		},
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: type({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: type({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigint2: type.bigint.narrow(bigintNarrow),
+		bigint3: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		bigint4: type.bigint.narrow(unsignedBigintNarrow),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: type(`/^[01]{0,10}$/`).describe(
+			`a string containing ones or zeros while being up to 10 characters long`,
+		) as Type<string>,
+		boolean: type.boolean,
+		char1: type.string.atMostLength(10),
+		char2: type.enumerated('a', 'b', 'c'),
+		date1: type.Date,
+		date2: type.string,
+		datetime1: type.Date,
+		datetime2: type.string,
+		decimal1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		decimal2: type.number.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		decimal3: type.bigint.narrow(bigintNarrow),
+		decimal4: type.bigint.narrow(unsignedBigintNarrow),
+		decimal5: type.string,
+		decimal6: type.string,
+		double1: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		double2: type.number.atLeast(0).atMost(CONSTANTS.INT48_UNSIGNED_MAX),
+		float1: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		float2: type.number.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
+		int1: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		int2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT32_UNSIGNED_MAX),
+		json: jsonSchema,
+		mediumint1: type.keywords.number.integer.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		mediumint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
+		enum: type.enumerated('a', 'b', 'c'),
+		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		serial: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		smallint1: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		smallint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT16_UNSIGNED_MAX),
+		text1: type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX),
+		text2: type.enumerated('a', 'b', 'c'),
+		time: type.string,
+		timestamp1: type.Date,
+		timestamp2: type.string,
+		tinyint1: type.keywords.number.integer.atLeast(CONSTANTS.INT8_MIN).atMost(CONSTANTS.INT8_MAX),
+		tinyint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT8_UNSIGNED_MAX),
+		varchar1: type.string.atMostLength(10),
+		varchar2: type.enumerated('a', 'b', 'c'),
+		varbinary: type(`/^[01]{0,10}$/`).describe(
+			`a string containing ones or zeros while being up to 10 characters long`,
+		) as Type<string>,
+		year: type.keywords.number.integer.atLeast(1901).atMost(2155),
+		longtext1: type.string.atMostLength(CONSTANTS.INT32_UNSIGNED_MAX),
+		longtext2: type.enumerated('a', 'b', 'c'),
+		mediumtext1: type.string.atMostLength(CONSTANTS.INT24_UNSIGNED_MAX),
+		mediumtext2: type.enumerated('a', 'b', 'c'),
+		tinytext1: type.string.atMostLength(CONSTANTS.INT8_UNSIGNED_MAX),
+		tinytext2: type.enumerated('a', 'b', 'c'),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+}
diff --git a/integration-tests/tests/validators/arktype/pg.test.ts b/integration-tests/tests/validators/arktype/pg.test.ts
new file mode 100644
index 0000000000..4629076f63
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/pg.test.ts
@@ -0,0 +1,585 @@
+import { type Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import { bigintNarrow, bigintStringModeSchema, jsonSchema } from 'drizzle-orm/arktype/column';
+import {
+	customType,
+	integer,
+	json,
+	jsonb,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
+const integerNullableSchema = integerSchema.or(type.null);
+const integerOptionalSchema = integerSchema.optional();
+const integerNullableOptionalSchema = integerSchema.or(type.null).optional();
+
+const textSchema = type.string;
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = type('unknown.any');
+
+const extendedSchema = integerSchema.atMost(1000);
+const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({
+		id: integerSchema,
+		nested: { name: textSchema, age: anySchema },
+		table: { id: integerSchema, name: textSchema },
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = type.enumerated('a', 'b', 'c');
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		nested: {
+			c5: (schema) => schema.atMost(1000),
+			c6: type.string.pipe(Number),
+		},
+		table: {
+			c2: (schema) => schema.atMost(1000),
+			c3: type.string.pipe(Number),
+		},
+	});
+	const expected = type({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: type({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: type({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigint2: type.bigint.narrow(bigintNarrow),
+		bigint3: bigintStringModeSchema,
+		bigserial1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigserial2: type.bigint.narrow(bigintNarrow),
+		bit: type(/^[01]{5}$/).describe('a string containing ones or zeros while being 5 characters long'),
+		boolean: type.boolean,
+		date1: type.Date,
+		date2: type.string,
+		char1: type.string.atMostLength(10),
+		char2: type.enumerated('a', 'b', 'c'),
+		cidr: type.string,
+		doublePrecision: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		geometry1: type([type.number, type.number]),
+		geometry2: type({ x: type.number, y: type.number }),
+		halfvec: type.number.array().exactlyLength(3),
+		inet: type.string,
+		integer: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		interval: type.string,
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: type({ a: type.number, b: type.number, c: type.number }),
+		line2: type([type.number, type.number, type.number]),
+		macaddr: type.string,
+		macaddr8: type.string,
+		numeric1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		numeric2: type.bigint.narrow(bigintNarrow),
+		numeric3: type.string,
+		point1: type({ x: type.number, y: type.number }),
+		point2: type([type.number, type.number]),
+		real: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		serial: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		smallint: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		smallserial: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		text1: type.string,
+		text2: type.enumerated('a', 'b', 'c'),
+		sparsevec: type.string,
+		time: type.string,
+		timestamp1: type.Date,
+		timestamp2: type.string,
+		uuid: type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu).describe('a RFC-4122-compliant UUID'),
+		varchar1: type.string.atMostLength(10),
+		varchar2: type.enumerated('a', 'b', 'c'),
+		vector: type.number.array().exactlyLength(3),
+		array1: integerSchema.array(),
+		array2: integerSchema.array().array(),
+		array3: type.string.atMostLength(10).array().array(),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: type.string });
+}
diff --git a/integration-tests/tests/validators/arktype/singlestore.test.ts b/integration-tests/tests/validators/arktype/singlestore.test.ts
new file mode 100644
index 0000000000..b2f65bbec3
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/singlestore.test.ts
@@ -0,0 +1,561 @@
+import { type Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import {
+	bigintNarrow,
+	bigintStringModeSchema,
+	jsonSchema,
+	unsignedBigintNarrow,
+	unsignedBigintStringModeSchema,
+} from 'drizzle-orm/arktype/column';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX);
+const intNullableSchema = intSchema.or(type.null);
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intSchema.or(type.null).optional();
+
+const serialSchema = type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER);
+const serialOptionalSchema = serialSchema.optional();
+
+const textSchema = type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX);
+const textOptionalSchema = textSchema.optional();
+
+// const anySchema = type('unknown.any');
+
+const extendedSchema = intSchema.atMost(1000);
+// const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (t) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({
+// 		id: serialSchema,
+// 		nested: v.object({ name: textSchema, age: anySchema }),
+// 		table: v.object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 		c3: v.pipe(type.string, v.transform(Number)),
+// 		nested: {
+// 			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 			c6: v.pipe(type.string, v.transform(Number)),
+// 		},
+// 		table: {
+// 			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 			c3: v.pipe(type.string, v.transform(Number)),
+// 		},
+// 	});
+// 	const expected = v.object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: v.object({
+// 			c4: intNullableSchema,,
+// 			c5: extendedNullableSchema,
+// 			c6: customSchema,
+// 		}),
+// 		table: v.object({
+// 			c1: v.nullable(intSchema),
+// 			c2: extendedNullableSchema,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,,
+// 			c5: intNullableSchema,,
+// 			c6: intNullableSchema,,
+// 		}),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (t) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		bigint1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		bigint2: type.bigint.narrow(bigintNarrow),
+		bigint3: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		bigint4: type.bigint.narrow(unsignedBigintNarrow),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: type(`/^[01]{0,10}$/`).describe(
+			`a string containing ones or zeros while being up to 10 characters long`,
+		) as Type<string>,
+		boolean: type.boolean,
+		char1: type.string.atMostLength(10),
+		char2: type.enumerated('a', 'b', 'c'),
+		date1: type.Date,
+		date2: type.string,
+		datetime1: type.Date,
+		datetime2: type.string,
+		decimal1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		decimal2: type.number.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		decimal3: type.bigint.narrow(bigintNarrow),
+		decimal4: type.bigint.narrow(unsignedBigintNarrow),
+		decimal5: type.string,
+		decimal6: type.string,
+		double1: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		double2: type.number.atLeast(0).atMost(CONSTANTS.INT48_UNSIGNED_MAX),
+		float1: type.number.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		float2: type.number.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
+		int1: type.keywords.number.integer.atLeast(CONSTANTS.INT32_MIN).atMost(CONSTANTS.INT32_MAX),
+		int2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT32_UNSIGNED_MAX),
+		json: jsonSchema,
+		mediumint1: type.keywords.number.integer.atLeast(CONSTANTS.INT24_MIN).atMost(CONSTANTS.INT24_MAX),
+		mediumint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT24_UNSIGNED_MAX),
+		enum: type.enumerated('a', 'b', 'c'),
+		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		serial: type.keywords.number.integer.atLeast(0).atMost(Number.MAX_SAFE_INTEGER),
+		smallint1: type.keywords.number.integer.atLeast(CONSTANTS.INT16_MIN).atMost(CONSTANTS.INT16_MAX),
+		smallint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT16_UNSIGNED_MAX),
+		text1: type.string.atMostLength(CONSTANTS.INT16_UNSIGNED_MAX),
+		text2: type.enumerated('a', 'b', 'c'),
+		time: type.string,
+		timestamp1: type.Date,
+		timestamp2: type.string,
+		tinyint1: type.keywords.number.integer.atLeast(CONSTANTS.INT8_MIN).atMost(CONSTANTS.INT8_MAX),
+		tinyint2: type.keywords.number.integer.atLeast(0).atMost(CONSTANTS.INT8_UNSIGNED_MAX),
+		varchar1: type.string.atMostLength(10),
+		varchar2: type.enumerated('a', 'b', 'c'),
+		varbinary: type(`/^[01]{0,10}$/`).describe(
+			`a string containing ones or zeros while being up to 10 characters long`,
+		) as Type<string>,
+		year: type.keywords.number.integer.atLeast(1901).atMost(2155),
+		longtext1: type.string.atMostLength(CONSTANTS.INT32_UNSIGNED_MAX),
+		longtext2: type.enumerated('a', 'b', 'c'),
+		mediumtext1: type.string.atMostLength(CONSTANTS.INT24_UNSIGNED_MAX),
+		mediumtext2: type.enumerated('a', 'b', 'c'),
+		tinytext1: type.string.atMostLength(CONSTANTS.INT8_UNSIGNED_MAX),
+		tinytext2: type.enumerated('a', 'b', 'c'),
+		vector: type.number.array().exactlyLength(3),
+		vector2: type.bigint.array().exactlyLength(2),
+	});
+	expectSchemaShape(t, expected).from(expected);
+	Expect<Equal<typeof result.infer, typeof expected.infer>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: type.string });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: type.string });
+// }
diff --git a/integration-tests/tests/validators/arktype/sqlite.test.ts b/integration-tests/tests/validators/arktype/sqlite.test.ts
new file mode 100644
index 0000000000..d8211e0b0d
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/sqlite.test.ts
@@ -0,0 +1,424 @@
+import { type Type, type } from 'arktype';
+import { type Equal, sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/arktype';
+import { bigintNarrow, bufferSchema, jsonSchema } from 'drizzle-orm/arktype/column';
+import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER);
+const intNullableSchema = intSchema.or(type.null);
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intSchema.or(type.null).optional();
+
+const textSchema = type.string;
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = type('unknown.any');
+
+const extendedSchema = intSchema.atMost(1000);
+const extendedNullableSchema = extendedSchema.or(type.null);
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = type.string.pipe(Number);
+
+test('table - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({ id: intSchema.optional(), name: textSchema, age: intNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: intSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = type({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = type({
+		id: intSchema,
+		nested: type({ name: textSchema, age: anySchema }),
+		table: type({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = type.string.atLeastLength(1).atMostLength(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		c4: customTextSchema,
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+	});
+	const expected = type({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.atMost(1000),
+		c3: type.string.pipe(Number),
+		nested: {
+			c5: (schema) => schema.atMost(1000),
+			c6: type.string.pipe(Number),
+		},
+		table: {
+			c2: (schema) => schema.atMost(1000),
+			c3: type.string.pipe(Number),
+		},
+	});
+	const expected = type({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: type({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: type({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = type({
+		blob1: bufferSchema,
+		blob2: type.bigint.narrow(bigintNarrow),
+		blob3: jsonSchema,
+		integer1: type.keywords.number.integer.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		integer2: type.boolean,
+		integer3: type.Date,
+		integer4: type.Date,
+		numeric1: type.number.atLeast(Number.MIN_SAFE_INTEGER).atMost(Number.MAX_SAFE_INTEGER),
+		numeric2: type.bigint.narrow(bigintNarrow),
+		numeric3: type.string,
+		real: type.number.atLeast(CONSTANTS.INT48_MIN).atMost(CONSTANTS.INT48_MAX),
+		text1: type.string,
+		text2: type.string.atMostLength(10),
+		text3: type.enumerated('a', 'b', 'c'),
+		text4: jsonSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: Type<TopLevelCondition> = type('unknown.any') as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = type({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<typeof result, typeof expected>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: type.string });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: type.string } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: type.string });
+}
diff --git a/integration-tests/tests/validators/arktype/utils.ts b/integration-tests/tests/validators/arktype/utils.ts
new file mode 100644
index 0000000000..e3e1366c17
--- /dev/null
+++ b/integration-tests/tests/validators/arktype/utils.ts
@@ -0,0 +1,15 @@
+import type { Type } from 'arktype';
+import { expect, type TestContext } from 'vitest';
+
+export function expectSchemaShape<T extends Type<any, any>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(actual.json).toStrictEqual(expected.json);
+			expect(actual.expression).toStrictEqual(expected.expression);
+		},
+	};
+}
+
+export const expectEnumValues = expectSchemaShape;
+
+export function Expect<_ extends true>() {}
diff --git a/integration-tests/tests/validators/effect-schema/cockroach.test.ts b/integration-tests/tests/validators/effect-schema/cockroach.test.ts
new file mode 100644
index 0000000000..b05ef24bd5
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/cockroach.test.ts
@@ -0,0 +1,636 @@
+import { sql } from 'drizzle-orm';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { jsonSchema } from 'drizzle-orm/effect-schema/column';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = s.Int.check(
+	s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+	s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+);
+const int4NullableSchema = s.NullOr(int4Schema);
+const int4OptionalSchema = s.optional(s.UndefinedOr(int4Schema));
+const int4NullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(int4Schema)));
+
+const textSchema = s.String;
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const anySchema = s.Any;
+
+const extendedSchema = int4Schema.check(s.isLessThanOrEqualTo(1000));
+const extendedNullableSchema = s.NullOr(extendedSchema);
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: int4Schema, generated: int4Schema, name: textSchema });
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({
+		id: int4Schema,
+		nested: s.Struct({ name: textSchema, age: anySchema }),
+		table: s.Struct({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = s.Literals(['a', 'b', 'c']);
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		nested: {
+			c5: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c6: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+		table: {
+			c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c3: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+	});
+	const expected = s.Struct({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: s.Struct({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: s.Struct({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		boolean: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		bigint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bit: s.String.check(s.isPattern(/^[01]*$/), s.isLengthBetween(5, 5)),
+		boolean: s.Boolean,
+		char1: s.String.check(s.isMaxLength(10)),
+		char2: s.Literals(['a', 'b', 'c']),
+		date1: s.Date,
+		date2: s.String,
+		decimal1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		decimal3: s.String,
+		float: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		doublePrecision: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		geometry1: s.Tuple([s.Number, s.Number]),
+		geometry2: s.Struct({ x: s.Number, y: s.Number }),
+		inet: s.String,
+		int2: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		int4: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		int8_1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		int8_2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		interval: s.String,
+		jsonb: jsonSchema,
+		numeric1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		numeric2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		numeric3: s.String,
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		smallint: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		string1: s.String,
+		string2: s.Literals(['a', 'b', 'c']),
+		text1: s.String,
+		text2: s.Literals(['a', 'b', 'c']),
+		time: s.String,
+		timestamp1: s.Date,
+		timestamp2: s.String,
+		uuid: s.String.check(s.isUUID()),
+		varchar1: s.String.check(s.isMaxLength(10)),
+		varchar2: s.Literals(['a', 'b', 'c']),
+		vector: s.Array(s.Number).check(s.isLengthBetween(3, 3)),
+		array: s.Array(int4Schema),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>;
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: s.String } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: s.String });
+}
diff --git a/integration-tests/tests/validators/effect-schema/mssql.test.ts b/integration-tests/tests/validators/effect-schema/mssql.test.ts
new file mode 100644
index 0000000000..3cce9fb395
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/mssql.test.ts
@@ -0,0 +1,566 @@
+import { sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { bigintStringModeSchema, bufferSchema } from 'drizzle-orm/effect-schema';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectSchemaShape } from './utils';
+
+const integerSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+	s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+);
+const integerNullableSchema = s.NullOr(integerSchema);
+const integerOptionalSchema = s.optional(s.UndefinedOr(integerSchema));
+const integerNullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(integerSchema)));
+
+const textSchema = s.String;
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const anySchema = s.Any;
+
+const extendedSchema = integerSchema.check(s.isLessThanOrEqualTo(1000));
+const extendedNullableSchema = s.NullOr(extendedSchema);
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({
+		id: integerSchema,
+		nested: s.Struct({ name: textSchema, age: anySchema }),
+		table: s.Struct({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		nested: {
+			c5: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c6: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+		table: {
+			c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c3: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: s.Struct({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: s.Struct({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		bigint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bigint3: bigintStringModeSchema,
+		binary: bufferSchema,
+		bit: s.Boolean,
+		char1: s.String.check(s.isMaxLength(10)),
+		char2: s.Literals(['a', 'b', 'c']),
+		date1: s.Date,
+		date2: s.String,
+		datetime1: s.Date,
+		datetime2: s.String,
+		datetime2_1: s.Date,
+		datetime2_2: s.String,
+		datetimeoffset1: s.Date,
+		datetimeoffset2: s.String,
+		decimal1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		decimal3: s.String,
+		float: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		int: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		numeric1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		numeric2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		numeric3: s.String,
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		smallint: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		text1: s.String,
+		text2: s.Literals(['a', 'b', 'c']),
+		time1: s.Date,
+		time2: s.String,
+		tinyint: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT8_UNSIGNED_MAX),
+		),
+		varbinary: bufferSchema,
+		varchar1: s.String.check(s.isMaxLength(10)),
+		varchar2: s.Literals(['a', 'b', 'c']),
+		ntext1: s.String,
+		ntext2: s.Literals(['a', 'b', 'c']),
+		nvarchar1: s.String.check(s.isMaxLength(10)),
+		nvarchar2: s.Literals(['a', 'b', 'c']),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: s.String } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: s.String });
+}
diff --git a/integration-tests/tests/validators/effect-schema/mysql.test.ts b/integration-tests/tests/validators/effect-schema/mysql.test.ts
new file mode 100644
index 0000000000..1acd531e85
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/mysql.test.ts
@@ -0,0 +1,637 @@
+import { sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/effect-schema';
+import { customType, int, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectSchemaShape } from './utils';
+
+const intSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+	s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+);
+const intNullableSchema = s.NullOr(intSchema);
+const intOptionalSchema = s.optional(s.UndefinedOr(intSchema));
+const intNullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(intSchema)));
+
+const serialSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(0),
+	s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+);
+
+const serialOptionalSchema = s.optional(s.UndefinedOr(serialSchema));
+
+const textSchema = s.String.check(s.isMaxLength(CONSTANTS.INT16_UNSIGNED_MAX));
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const anySchema = s.Any;
+
+const extendedSchema = intSchema.check(s.isLessThanOrEqualTo(1000));
+const extendedNullableSchema = s.NullOr(extendedSchema);
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: serialSchema, name: textSchema });
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: serialSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({
+		id: serialSchema,
+		nested: s.Struct({ name: textSchema, age: anySchema }),
+		table: s.Struct({ id: serialSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		nested: {
+			c5: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c6: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+		table: {
+			c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c3: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: s.Struct({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: s.Struct({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		bigint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bigint3: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint4: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(0n),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_UNSIGNED_MAX),
+		),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: s.String.check(s.isPattern(/^[01]*$/), s.isMaxLength(10)),
+		boolean: s.Boolean,
+		char1: s.String.check(s.isMaxLength(10)),
+		char2: s.Literals(['a', 'b', 'c']),
+		date1: s.Date,
+		date2: s.String,
+		datetime1: s.Date,
+		datetime2: s.String,
+		decimal1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal3: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		decimal4: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(0n),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_UNSIGNED_MAX),
+		),
+		decimal5: s.String,
+		decimal6: s.String,
+		double1: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		double2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_UNSIGNED_MAX),
+		),
+		float1: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		float2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_UNSIGNED_MAX),
+		),
+		int1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		int2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_UNSIGNED_MAX),
+		),
+		json: jsonSchema,
+		mediumint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		mediumint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_UNSIGNED_MAX),
+		),
+		enum: s.Literals(['a', 'b', 'c']),
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		serial: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		smallint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		smallint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_UNSIGNED_MAX),
+		),
+		text1: s.String.check(s.isMaxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
+		text2: s.Literals(['a', 'b', 'c']),
+		time: s.String,
+		timestamp1: s.Date,
+		timestamp2: s.String,
+		tinyint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT8_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT8_MAX),
+		),
+		tinyint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT8_UNSIGNED_MAX),
+		),
+		varchar1: s.String.check(s.isMaxLength(10)),
+		varchar2: s.Literals(['a', 'b', 'c']),
+		varbinary: s.String.check(s.isPattern(/^[01]*$/), s.isMaxLength(10)),
+		year: s.Int.check(s.isGreaterThanOrEqualTo(1901), s.isLessThanOrEqualTo(2155)),
+		longtext1: s.String.check(s.isMaxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
+		longtext2: s.Literals(['a', 'b', 'c']),
+		mediumtext1: s.String.check(s.isMaxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
+		mediumtext2: s.Literals(['a', 'b', 'c']),
+		tinytext1: s.String.check(s.isMaxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
+		tinytext2: s.Literals(['a', 'b', 'c']),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: s.String } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+}
diff --git a/integration-tests/tests/validators/effect-schema/pg.test.ts b/integration-tests/tests/validators/effect-schema/pg.test.ts
new file mode 100644
index 0000000000..e51e0a3e18
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/pg.test.ts
@@ -0,0 +1,651 @@
+import { sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { bigintStringModeSchema, jsonSchema } from 'drizzle-orm/effect-schema';
+import {
+	customType,
+	integer,
+	json,
+	jsonb,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+	s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+);
+const integerNullableSchema = s.NullOr(integerSchema);
+const integerOptionalSchema = s.optional(s.UndefinedOr(integerSchema));
+const integerNullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(integerSchema)));
+
+const textSchema = s.String;
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const anySchema = s.Any;
+
+const extendedSchema = integerSchema.check(s.isLessThanOrEqualTo(1000));
+const extendedNullableSchema = s.NullOr(extendedSchema);
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({
+		id: integerSchema,
+		nested: s.Struct({ name: textSchema, age: anySchema }),
+		table: s.Struct({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = s.Literals(['a', 'b', 'c']);
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		nested: {
+			c5: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c6: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+		table: {
+			c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c3: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+	});
+	const expected = s.Struct({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: s.Struct({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: s.Struct({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		bigint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bigint3: bigintStringModeSchema,
+		bigserial1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigserial2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bit: s.String.check(s.isPattern(/^[01]*$/), s.isLengthBetween(5, 5)),
+		boolean: s.Boolean,
+		date1: s.Date,
+		date2: s.String,
+		char1: s.String.check(s.isMaxLength(10)),
+		char2: s.Literals(['a', 'b', 'c']),
+		cidr: s.String,
+		doublePrecision: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		geometry1: s.Tuple([s.Number, s.Number]),
+		geometry2: s.Struct({ x: s.Number, y: s.Number }),
+		halfvec: s.Array(s.Number).check(s.isLengthBetween(3, 3)),
+		inet: s.String,
+		integer: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		interval: s.String,
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: s.Struct({ a: s.Number, b: s.Number, c: s.Number }),
+		line2: s.Tuple([s.Number, s.Number, s.Number]),
+		macaddr: s.String,
+		macaddr8: s.String,
+		numeric1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		numeric2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		numeric3: s.String,
+		point1: s.Struct({ x: s.Number, y: s.Number }),
+		point2: s.Tuple([s.Number, s.Number]),
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		serial: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		smallint: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		smallserial: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		text1: s.String,
+		text2: s.Literals(['a', 'b', 'c']),
+		sparsevec: s.String,
+		time: s.String,
+		timestamp1: s.Date,
+		timestamp2: s.String,
+		uuid: s.String.check(s.isUUID()),
+		varchar1: s.String.check(s.isMaxLength(10)),
+		varchar2: s.Literals(['a', 'b', 'c']),
+		vector: s.Array(s.Number).check(s.isLengthBetween(3, 3)),
+		array1: s.Array(integerSchema),
+		array2: s.Array(s.Array(integerSchema)),
+		array3: s.Array(s.Array(s.String.check(s.isMaxLength(10)))),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: s.String } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: s.String });
+}
diff --git a/integration-tests/tests/validators/effect-schema/singlestore.test.ts b/integration-tests/tests/validators/effect-schema/singlestore.test.ts
new file mode 100644
index 0000000000..588644c2a2
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/singlestore.test.ts
@@ -0,0 +1,642 @@
+import { sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/effect-schema';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectSchemaShape } from './utils';
+
+const intSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN as number),
+	s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX as number),
+);
+const intNullableSchema = s.NullOr(intSchema);
+const intOptionalSchema = s.optional(s.UndefinedOr(intSchema));
+const intNullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(intSchema)));
+
+const serialSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(0 as number),
+	s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER as number),
+);
+const serialOptionalSchema = s.optional(s.UndefinedOr(serialSchema));
+
+const textSchema = s.String.check(s.isMaxLength(CONSTANTS.INT16_UNSIGNED_MAX as number));
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const extendedSchema = intSchema.check(s.isLessThanOrEqualTo(1000));
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (t) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({
+// 		id: serialSchema,
+// 		nested: v.object({ name: textSchema, age: anySchema }),
+// 		table: v.object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => v.pipe(schema, v.lessThanOrEqualTo(1000)),
+// 		c3: v.pipe(v.string(), v.transform(Number)),
+// 		nested: {
+// 			c5: (schema) => v.pipe(schema, v.lessThanOrEqualTo(1000)),
+// 			c6: v.pipe(v.string(), v.transform(Number)),
+// 		},
+// 		table: {
+// 			c2: (schema) => v.pipe(schema, v.lessThanOrEqualTo(1000)),
+// 			c3: v.pipe(v.string(), v.transform(Number)),
+// 		},
+// 	});
+// 	const expected = v.object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: v.object({
+// 			c4: intNullableSchema,
+// 			c5: extendedNullableSchema,
+// 			c6: customSchema,
+// 		}),
+// 		table: v.object({
+// 			c1: intNullableSchema,
+// 			c2: extendedNullableSchema,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,
+// 			c5: intNullableSchema,
+// 			c6: intNullableSchema,
+// 		}),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (t) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		bigint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		bigint3: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		bigint4: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(0n),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_UNSIGNED_MAX),
+		),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: s.String.check(s.isPattern(/^[01]*$/), s.isMaxLength(10)),
+		boolean: s.Boolean,
+		char1: s.String.check(s.isMaxLength(10)),
+		char2: s.Literals(['a', 'b', 'c']),
+		date1: s.Date,
+		date2: s.String,
+		datetime1: s.Date,
+		datetime2: s.String,
+		decimal1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		decimal3: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		decimal4: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(0n),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_UNSIGNED_MAX),
+		),
+		decimal5: s.String,
+		decimal6: s.String,
+		double1: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		double2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_UNSIGNED_MAX),
+		),
+		float1: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		float2: s.Number.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_UNSIGNED_MAX),
+		),
+		int1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT32_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_MAX),
+		),
+		int2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT32_UNSIGNED_MAX),
+		),
+		json: jsonSchema,
+		mediumint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT24_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_MAX),
+		),
+		mediumint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT24_UNSIGNED_MAX),
+		),
+		enum: s.Literals(['a', 'b', 'c']),
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		serial: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		smallint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT16_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_MAX),
+		),
+		smallint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT16_UNSIGNED_MAX),
+		),
+		text1: s.String.check(s.isMaxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
+		text2: s.Literals(['a', 'b', 'c']),
+		time: s.String,
+		timestamp1: s.Date,
+		timestamp2: s.String,
+		tinyint1: s.Int.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT8_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT8_MAX),
+		),
+		tinyint2: s.Int.check(
+			s.isGreaterThanOrEqualTo(0),
+			s.isLessThanOrEqualTo(CONSTANTS.INT8_UNSIGNED_MAX),
+		),
+		varchar1: s.String.check(s.isMaxLength(10)),
+		varchar2: s.Literals(['a', 'b', 'c']),
+		varbinary: s.String.check(s.isPattern(/^[01]*$/), s.isMaxLength(10)),
+		year: s.Int.check(s.isGreaterThanOrEqualTo(1901), s.isLessThanOrEqualTo(2155)),
+		longtext1: s.String.check(s.isMaxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
+		longtext2: s.Literals(['a', 'b', 'c']),
+		mediumtext1: s.String.check(s.isMaxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
+		mediumtext2: s.Literals(['a', 'b', 'c']),
+		tinytext1: s.String.check(s.isMaxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
+		tinytext2: s.Literals(['a', 'b', 'c']),
+		vector: s.Array(s.Number).check(s.isLengthBetween(3, 3)),
+		vector2: s.Array(
+			s.BigInt.check(
+				s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+				s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+			),
+		).check(s.isLengthBetween(2, 2)),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: v.string() });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: v.string() });
+// }
diff --git a/integration-tests/tests/validators/effect-schema/sqlite.test.ts b/integration-tests/tests/validators/effect-schema/sqlite.test.ts
new file mode 100644
index 0000000000..1eddc9ade0
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/sqlite.test.ts
@@ -0,0 +1,469 @@
+import { sql } from 'drizzle-orm';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/effect-schema';
+import { bufferSchema, jsonSchema } from 'drizzle-orm/effect-schema';
+import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { Schema as s } from 'effect';
+import * as SchemaGetter from 'effect/SchemaGetter';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Equal, Expect } from '~/utils';
+import { expectEnumValues, expectSchemaShape } from './utils';
+
+const intSchema = s.Int.check(
+	s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+	s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+);
+const intNullableSchema = s.NullOr(intSchema);
+const intOptionalSchema = s.optional(s.UndefinedOr(intSchema));
+const intNullableOptionalSchema = s.optional(s.UndefinedOr(s.NullOr(intSchema)));
+
+const textSchema = s.String;
+const textOptionalSchema = s.optional(s.UndefinedOr(textSchema));
+
+const anySchema = s.Any;
+
+const extendedSchema = intSchema.check(s.isLessThanOrEqualTo(1000));
+const extendedNullableSchema = s.NullOr(extendedSchema);
+const extendedOptionalSchema = s.optional(s.UndefinedOr(extendedSchema));
+
+const customSchema = s.String.pipe(s.decodeTo(s.Number, {
+	decode: SchemaGetter.transform((v: string) => Number(v)),
+	encode: SchemaGetter.transform((v: number) => String(v)),
+}));
+
+test('table - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({ id: intOptionalSchema, name: textSchema, age: intNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: intSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = s.Struct({
+		id: intSchema,
+		nested: s.Struct({ name: textSchema, age: anySchema }),
+		table: s.Struct({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = s.String.check(s.isMinLength(1), s.isMaxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		c4: customTextSchema,
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+	});
+	const expected = s.Struct({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+		c3: s.String.pipe(s.decodeTo(s.Number, {
+			decode: SchemaGetter.transform((v: string) => Number(v)),
+			encode: SchemaGetter.transform((v: number) => String(v)),
+		})),
+		nested: {
+			c5: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c6: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+		table: {
+			c2: (schema) => schema.check(s.isLessThanOrEqualTo(1000)),
+			c3: s.String.pipe(s.decodeTo(s.Number, {
+				decode: SchemaGetter.transform((v: string) => Number(v)),
+				encode: SchemaGetter.transform((v: number) => String(v)),
+			})),
+		},
+	});
+	const expected = s.Struct({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: s.Struct({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: s.Struct({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = s.Struct({
+		blob1: bufferSchema,
+		blob2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		blob3: jsonSchema,
+		integer1: s.Int.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		integer2: s.Boolean,
+		integer3: s.Date,
+		integer4: s.Date,
+		numeric1: s.Number.check(
+			s.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER),
+			s.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER),
+		),
+		numeric2: s.BigInt.check(
+			s.isGreaterThanOrEqualToBigInt(CONSTANTS.INT64_MIN),
+			s.isLessThanOrEqualToBigInt(CONSTANTS.INT64_MAX),
+		),
+		numeric3: s.String,
+		real: s.Number.check(
+			s.isGreaterThanOrEqualTo(CONSTANTS.INT48_MIN),
+			s.isLessThanOrEqualTo(CONSTANTS.INT48_MAX),
+		),
+		text1: s.String,
+		text2: s.String.check(s.isMaxLength(10)),
+		text3: s.Literals(['a', 'b', 'c']),
+		text4: jsonSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* 'Infinitely recursive type'*/ {
+	const TopLevelCondition: s.Schema<TopLevelCondition> = s.Any.check(
+		s.makeFilter(() => undefined), // oxlint-disable-line no-useless-undefined
+	) as unknown as s.Schema<TopLevelCondition>;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = s.Struct({
+		tlc: TopLevelCondition,
+	});
+	Expect<Equal<typeof result, typeof expected>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: s.String });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: s.String } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: s.String });
+}
diff --git a/integration-tests/tests/validators/effect-schema/utils.ts b/integration-tests/tests/validators/effect-schema/utils.ts
new file mode 100644
index 0000000000..ed2696302c
--- /dev/null
+++ b/integration-tests/tests/validators/effect-schema/utils.ts
@@ -0,0 +1,22 @@
+import { Schema as s } from 'effect';
+import { expect, type TestContext } from 'vitest';
+
+const parseBigInt = (_: any, value: any) => (typeof value === 'bigint' ? `${value}n` : value);
+
+export const stringifySchema = (schema: s.Top): string => JSON.stringify(schema.ast, parseBigInt, 2);
+
+export function expectSchemaShape<T extends s.Top>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(stringifySchema(actual)).toStrictEqual(stringifySchema(expected));
+		},
+	};
+}
+
+export function expectEnumValues<T extends s.Top>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(stringifySchema(actual)).toStrictEqual(stringifySchema(expected));
+		},
+	};
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/cockroach.test.ts b/integration-tests/tests/validators/typebox-legacy/cockroach.test.ts
new file mode 100644
index 0000000000..eef2c9266f
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/cockroach.test.ts
@@ -0,0 +1,597 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+} from 'drizzle-orm/typebox-legacy';
+import { jsonSchema } from 'drizzle-orm/typebox-legacy/column';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const int4NullableSchema = t.Union([int4Schema, t.Null()]);
+const int4OptionalSchema = t.Optional(int4Schema);
+const int4NullableOptionalSchema = t.Optional(t.Union([int4Schema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: 1000,
+});
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: int4Schema, generated: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (tc) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: int4Schema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (tc) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = t.Enum({ a: 'a', b: 'b', c: 'c' });
+
+	expectEnumValues(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		boolean: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bit: t.RegExp(/^[01]*$/, { minLength: 5, maxLength: 5 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: t.Date(),
+		date2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal3: t.String(),
+		float: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		doublePrecision: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		geometry1: t.Tuple([t.Number(), t.Number()]),
+		geometry2: t.Object({ x: t.Number(), y: t.Number() }),
+		inet: t.String(),
+		int2: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		int4: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int8_1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		int8_2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		interval: t.String(),
+		jsonb: jsonSchema,
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		string1: t.String(),
+		string2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		text1: t.String(),
+		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		time: t.String(),
+		timestamp1: t.Date(),
+		timestamp2: t.String(),
+		uuid: t.String({ format: 'uuid' }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		array: t.Array(int4Schema),
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/mssql.test.ts b/integration-tests/tests/validators/typebox-legacy/mssql.test.ts
new file mode 100644
index 0000000000..acc51b7079
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/mssql.test.ts
@@ -0,0 +1,509 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/typebox-legacy';
+import { bigintStringModeSchema, bufferSchema } from 'drizzle-orm/typebox-legacy/column';
+import { GenericSchema } from 'drizzle-orm/typebox-legacy/column.types';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const integerSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const integerNullableSchema = t.Union([integerSchema, t.Null()]);
+const integerOptionalSchema = t.Optional(integerSchema);
+const integerNullableOptionalSchema = t.Optional(t.Union([integerSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: 1000,
+});
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: integerSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: bigintStringModeSchema,
+		binary: bufferSchema,
+		bit: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: t.Date(),
+		date2: t.String(),
+		datetime1: t.Date(),
+		datetime2: t.String(),
+		datetime2_1: t.Date(),
+		datetime2_2: t.String(),
+		datetimeoffset1: t.Date(),
+		datetimeoffset2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal3: t.String(),
+		float: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		int: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		text1: t.String(),
+		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		time1: t.Date(),
+		time2: t.String(),
+		tinyint: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varbinary: bufferSchema,
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		ntext1: t.String(),
+		ntext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		nvarchar1: t.String({ maxLength: 10 }),
+		nvarchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/mysql.test.ts b/integration-tests/tests/validators/typebox-legacy/mysql.test.ts
new file mode 100644
index 0000000000..55f2f24105
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/mysql.test.ts
@@ -0,0 +1,550 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+} from 'drizzle-orm/typebox-legacy';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/typebox-legacy/column';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const serialSchema = t.Integer({
+	minimum: 0,
+	maximum: Number.MAX_SAFE_INTEGER,
+});
+const serialOptionalSchema = t.Optional(serialSchema);
+
+const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: serialSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: serialSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: serialSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: t.RegExp(/^[01]*$/, { maxLength: 10 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: t.Date(),
+		date2: t.String(),
+		datetime1: t.Date(),
+		datetime2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.Number({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal3: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		decimal5: t.String(),
+		decimal6: t.String(),
+		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
+		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
+		json: jsonSchema,
+		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		enum: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		time: t.String(),
+		timestamp1: t.Date(),
+		timestamp2: t.String(),
+		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
+		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		varbinary: t.RegExp(/^[01]*$/, { maxLength: 10 }),
+		year: t.Integer({ minimum: 1901, maximum: 2155 }),
+		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
+		longtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
+		mediumtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
+		tinytext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/pg.test.ts b/integration-tests/tests/validators/typebox-legacy/pg.test.ts
new file mode 100644
index 0000000000..3b31fc6123
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/pg.test.ts
@@ -0,0 +1,590 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	customType,
+	integer,
+	json,
+	jsonb,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import { bigintStringModeSchema, jsonSchema } from 'drizzle-orm/typebox-legacy';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+} from 'drizzle-orm/typebox-legacy';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX });
+const integerNullableSchema = t.Union([integerSchema, t.Null()]);
+const integerOptionalSchema = t.Optional(integerSchema);
+const integerNullableOptionalSchema = t.Optional(t.Union([integerSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (tc) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: integerSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (tc) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = t.Enum({ a: 'a', b: 'b', c: 'c' });
+	expectEnumValues(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: bigintStringModeSchema,
+		bigserial1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigserial2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bit: t.RegExp(/^[01]*$/, { minLength: 5, maxLength: 5 }),
+		boolean: t.Boolean(),
+		date1: t.Date(),
+		date2: t.String(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		cidr: t.String(),
+		doublePrecision: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		geometry1: t.Tuple([t.Number(), t.Number()]),
+		geometry2: t.Object({ x: t.Number(), y: t.Number() }),
+		halfvec: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		inet: t.String(),
+		integer: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		interval: t.String(),
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: t.Object({ a: t.Number(), b: t.Number(), c: t.Number() }),
+		line2: t.Tuple([t.Number(), t.Number(), t.Number()]),
+		macaddr: t.String(),
+		macaddr8: t.String(),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		point1: t.Object({ x: t.Number(), y: t.Number() }),
+		point2: t.Tuple([t.Number(), t.Number()]),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		serial: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallserial: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		text1: t.String(),
+		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		sparsevec: t.String(),
+		time: t.String(),
+		timestamp1: t.Date(),
+		timestamp2: t.String(),
+		uuid: t.String({ format: 'uuid' }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		array1: t.Array(integerSchema),
+		array2: t.Array(t.Array(integerSchema)),
+		array3: t.Array(t.Array(t.String({ maxLength: 10 }))),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/singlestore.test.ts b/integration-tests/tests/validators/typebox-legacy/singlestore.test.ts
new file mode 100644
index 0000000000..b8614280bf
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/singlestore.test.ts
@@ -0,0 +1,565 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+} from 'drizzle-orm/typebox-legacy';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/typebox-legacy/column';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const serialSchema = t.Integer({
+	minimum: 0,
+	maximum: Number.MAX_SAFE_INTEGER,
+});
+const serialOptionalSchema = t.Optional(serialSchema);
+
+const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
+const textOptionalSchema = t.Optional(textSchema);
+
+// const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+// const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (tc) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({
+// 		id: serialNumberModeSchema,
+// 		nested: t.Object({ name: textSchema, age: anySchema }),
+// 		table: t.Object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+// 		c3: t.Integer({ minimum: 1, maximum: 10 }),
+// 		nested: {
+// 			c5: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+// 			c6: t.Integer({ minimum: 1, maximum: 10 }),
+// 		},
+// 		table: {
+// 			c2: (schema) => t.Integer({ minimum: schema.minimum, maximum: 1000 }),
+// 			c3: t.Integer({ minimum: 1, maximum: 10 }),
+// 		},
+// 	});
+// 	const expected = t.Object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: t.Object({
+// 			c4: intNullableSchema,
+// 			c5: extendedNullableSchema,
+// 			c6: customSchema,
+// 		}),
+// 		table: t.Object({
+// 			c1: intNullableSchema,
+// 			c2: extendedNullableSchema,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,
+// 			c5: intNullableSchema,
+// 			c6: intNullableSchema,
+// 		}),
+// 	});
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (tc) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: t.RegExp(/^[01]*$/, { maxLength: 10 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: t.Date(),
+		date2: t.String(),
+		datetime1: t.Date(),
+		datetime2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.Number({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal3: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		decimal5: t.String(),
+		decimal6: t.String(),
+		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
+		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
+		json: jsonSchema,
+		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		enum: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		time: t.String(),
+		timestamp1: t.Date(),
+		timestamp2: t.String(),
+		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
+		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		varbinary: t.RegExp(/^[01]*$/, { maxLength: 10 }),
+		year: t.Integer({ minimum: 1901, maximum: 2155 }),
+		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
+		longtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
+		mediumtext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
+		tinytext2: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		vector2: t.Array(t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }), {
+			minItems: 2,
+			maxItems: 2,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: t.String() });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: t.String() });
+// }
diff --git a/integration-tests/tests/validators/typebox-legacy/sqlite.test.ts b/integration-tests/tests/validators/typebox-legacy/sqlite.test.ts
new file mode 100644
index 0000000000..3c7430728a
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/sqlite.test.ts
@@ -0,0 +1,433 @@
+import { type Static, Type as t } from '@sinclair/typebox';
+import { type Equal, sql } from 'drizzle-orm';
+import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+} from 'drizzle-orm/typebox-legacy';
+import { bufferSchema, jsonSchema } from 'drizzle-orm/typebox-legacy/column';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: intSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: intOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: intSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: intSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: intSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		blob1: bufferSchema,
+		blob2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		blob3: jsonSchema,
+		integer1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		integer2: t.Boolean(),
+		integer3: t.Date(),
+		integer4: t.Date(),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		text1: t.String(),
+		text2: t.String({ maxLength: 10 }),
+		text3: t.Enum({ a: 'a', b: 'b', c: 'c' }),
+		text4: jsonSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox-legacy/utils.ts b/integration-tests/tests/validators/typebox-legacy/utils.ts
new file mode 100644
index 0000000000..71082869f6
--- /dev/null
+++ b/integration-tests/tests/validators/typebox-legacy/utils.ts
@@ -0,0 +1,34 @@
+import type * as t from '@sinclair/typebox';
+import { expect, type TestContext } from 'vitest';
+
+function removeKeysFromObject(obj: Record<string, any>, keys: string[]) {
+	for (const key of keys) {
+		delete obj[key];
+	}
+	return obj;
+}
+
+export function expectSchemaShape<T extends t.TObject>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(Object.keys(actual.properties)).toStrictEqual(Object.keys(expected.properties));
+			const keys = ['$id', '$schema', 'title', 'description', 'default', 'examples', 'readOnly', 'writeOnly'];
+
+			for (const key of Object.keys(actual.properties)) {
+				expect(removeKeysFromObject(actual.properties[key]!, keys)).toStrictEqual(
+					removeKeysFromObject(expected.properties[key]!, keys),
+				);
+			}
+		},
+	};
+}
+
+export function expectEnumValues<T extends t.TEnum<any>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(actual.anyOf).toStrictEqual(expected.anyOf);
+		},
+	};
+}
+
+export function Expect<_ extends true>() {}
diff --git a/integration-tests/tests/validators/typebox/cockroach.test.ts b/integration-tests/tests/validators/typebox/cockroach.test.ts
new file mode 100644
index 0000000000..8b0c652f88
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/cockroach.test.ts
@@ -0,0 +1,601 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+	jsonSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+} from 'drizzle-orm/typebox';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const int4NullableSchema = t.Union([int4Schema, t.Null()]);
+const int4OptionalSchema = t.Optional(int4Schema);
+const int4NullableOptionalSchema = t.Optional(t.Union([int4Schema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: 1000,
+});
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: int4Schema, generated: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (tc) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: int4Schema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (tc) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = t.Enum(['a', 'b', 'c']);
+
+	expectEnumValues(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		boolean: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bit: t.String({ pattern: /^[01]*$/, minLength: 5, maxLength: 5 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum(['a', 'b', 'c']),
+		date1: new TDate(),
+		date2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal3: t.String(),
+		float: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		doublePrecision: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		geometry1: t.Tuple([t.Number(), t.Number()]),
+		geometry2: t.Object({ x: t.Number(), y: t.Number() }),
+		inet: t.String(),
+		int2: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		int4: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int8_1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		int8_2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		interval: t.String(),
+		jsonb: jsonSchema,
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		string1: t.String(),
+		string2: t.Enum(['a', 'b', 'c']),
+		text1: t.String(),
+		text2: t.Enum(['a', 'b', 'c']),
+		time: t.String(),
+		timestamp1: new TDate(),
+		timestamp2: t.String(),
+		uuid: t.String({ format: 'uuid' }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum(['a', 'b', 'c']),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		array: t.Array(int4Schema),
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox/mssql.test.ts b/integration-tests/tests/validators/typebox/mssql.test.ts
new file mode 100644
index 0000000000..ebce6e4bc7
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/mssql.test.ts
@@ -0,0 +1,516 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+} from 'drizzle-orm/typebox';
+import { GenericSchema } from 'drizzle-orm/typebox/column.types';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const integerSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const integerNullableSchema = t.Union([integerSchema, t.Null()]);
+const integerOptionalSchema = t.Optional(integerSchema);
+const integerNullableOptionalSchema = t.Optional(t.Union([integerSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: 1000,
+});
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: integerSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: new TBigIntString(),
+		binary: new TBuffer(),
+		bit: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum(['a', 'b', 'c']),
+		date1: new TDate(),
+		date2: t.String(),
+		datetime1: new TDate(),
+		datetime2: t.String(),
+		datetime2_1: new TDate(),
+		datetime2_2: t.String(),
+		datetimeoffset1: new TDate(),
+		datetimeoffset2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal3: t.String(),
+		float: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		int: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		text1: t.String(),
+		text2: t.Enum(['a', 'b', 'c']),
+		time1: new TDate(),
+		time2: t.String(),
+		tinyint: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varbinary: new TBuffer(),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum(['a', 'b', 'c']),
+		ntext1: t.String(),
+		ntext2: t.Enum(['a', 'b', 'c']),
+		nvarchar1: t.String({ maxLength: 10 }),
+		nvarchar2: t.Enum(['a', 'b', 'c']),
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox/mysql.test.ts b/integration-tests/tests/validators/typebox/mysql.test.ts
new file mode 100644
index 0000000000..decf52836f
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/mysql.test.ts
@@ -0,0 +1,555 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+	jsonSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+	TUnsignedBigIntString,
+} from 'drizzle-orm/typebox';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const serialSchema = t.Integer({
+	minimum: 0,
+	maximum: Number.MAX_SAFE_INTEGER,
+});
+const serialOptionalSchema = t.Optional(serialSchema);
+
+const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: serialSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: serialSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: serialSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		bigint5: new TBigIntString(),
+		bigint6: new TUnsignedBigIntString(),
+		binary: t.String({ pattern: /^[01]*$/, maxLength: 10 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum(['a', 'b', 'c']),
+		date1: new TDate(),
+		date2: t.String(),
+		datetime1: new TDate(),
+		datetime2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.Number({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal3: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		decimal5: t.String(),
+		decimal6: t.String(),
+		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
+		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
+		json: jsonSchema,
+		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		enum: t.Enum(['a', 'b', 'c']),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text2: t.Enum(['a', 'b', 'c']),
+		time: t.String(),
+		timestamp1: new TDate(),
+		timestamp2: t.String(),
+		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
+		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum(['a', 'b', 'c']),
+		varbinary: t.String({ pattern: /^[01]*$/, maxLength: 10 }),
+		year: t.Integer({ minimum: 1901, maximum: 2155 }),
+		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
+		longtext2: t.Enum(['a', 'b', 'c']),
+		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
+		mediumtext2: t.Enum(['a', 'b', 'c']),
+		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
+		tinytext2: t.Enum(['a', 'b', 'c']),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox/pg.test.ts b/integration-tests/tests/validators/typebox/pg.test.ts
new file mode 100644
index 0000000000..b4ccd518e3
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/pg.test.ts
@@ -0,0 +1,594 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	customType,
+	integer,
+	json,
+	jsonb,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+	jsonSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+} from 'drizzle-orm/typebox';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX });
+const integerNullableSchema = t.Union([integerSchema, t.Null()]);
+const integerOptionalSchema = t.Optional(integerSchema);
+const integerNullableOptionalSchema = t.Optional(t.Union([integerSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (tc) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: integerSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (tc) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = t.Enum(['a', 'b', 'c']);
+	expectEnumValues(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+});
+
+test('nullability - update', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: new TBigIntString(),
+		bigserial1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigserial2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bit: t.String({ pattern: /^[01]*$/, minLength: 5, maxLength: 5 }),
+		boolean: t.Boolean(),
+		date1: new TDate(),
+		date2: t.String(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum(['a', 'b', 'c']),
+		cidr: t.String(),
+		doublePrecision: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		geometry1: t.Tuple([t.Number(), t.Number()]),
+		geometry2: t.Object({ x: t.Number(), y: t.Number() }),
+		halfvec: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		inet: t.String(),
+		integer: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		interval: t.String(),
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: t.Object({ a: t.Number(), b: t.Number(), c: t.Number() }),
+		line2: t.Tuple([t.Number(), t.Number(), t.Number()]),
+		macaddr: t.String(),
+		macaddr8: t.String(),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		point1: t.Object({ x: t.Number(), y: t.Number() }),
+		point2: t.Tuple([t.Number(), t.Number()]),
+		real: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		serial: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		smallint: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallserial: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		text1: t.String(),
+		text2: t.Enum(['a', 'b', 'c']),
+		sparsevec: t.String(),
+		time: t.String(),
+		timestamp1: new TDate(),
+		timestamp2: t.String(),
+		uuid: t.String({ format: 'uuid' }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum(['a', 'b', 'c']),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		array1: t.Array(integerSchema),
+		array2: t.Array(t.Array(integerSchema)),
+		array3: t.Array(t.Array(t.String({ maxLength: 10 }))),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox/singlestore.test.ts b/integration-tests/tests/validators/typebox/singlestore.test.ts
new file mode 100644
index 0000000000..322d9d9b10
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/singlestore.test.ts
@@ -0,0 +1,570 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+	jsonSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+	TUnsignedBigIntString,
+} from 'drizzle-orm/typebox';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({
+	minimum: CONSTANTS.INT32_MIN,
+	maximum: CONSTANTS.INT32_MAX,
+});
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const serialSchema = t.Integer({
+	minimum: 0,
+	maximum: Number.MAX_SAFE_INTEGER,
+});
+const serialOptionalSchema = t.Optional(serialSchema);
+
+const textSchema = t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX });
+const textOptionalSchema = t.Optional(textSchema);
+
+// const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+// const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (tc) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = t.Object({
+// 		id: serialNumberModeSchema,
+// 		nested: t.Object({ name: textSchema, age: anySchema }),
+// 		table: t.Object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => t.Integer({ minimum: (<any> schema).minimum, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (tc) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => t.Integer({ minimum: (<any>schema).minimum, maximum: 1000 }),
+// 		c3: t.Integer({ minimum: 1, maximum: 10 }),
+// 		nested: {
+// 			c5: (schema) => t.Integer({ minimum: (<any>schema).minimum, maximum: 1000 }),
+// 			c6: t.Integer({ minimum: 1, maximum: 10 }),
+// 		},
+// 		table: {
+// 			c2: (schema) => t.Integer({ minimum: (<any>schema).minimum, maximum: 1000 }),
+// 			c3: t.Integer({ minimum: 1, maximum: 10 }),
+// 		},
+// 	});
+// 	const expected = t.Object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: t.Object({
+// 			c4: intNullableSchema,
+// 			c5: extendedNullableSchema,
+// 			c6: customSchema,
+// 		}),
+// 		table: t.Object({
+// 			c1: intNullableSchema,
+// 			c2: extendedNullableSchema,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,
+// 			c5: intNullableSchema,
+// 			c6: intNullableSchema,
+// 		}),
+// 	});
+// 	expectSchemaShape(tc, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (tc) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		bigint1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		bigint3: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		bigint4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		bigint5: new TBigIntString(),
+		bigint6: new TUnsignedBigIntString(),
+		binary: t.String({ pattern: /^[01]*$/, maxLength: 10 }),
+		boolean: t.Boolean(),
+		char1: t.String({ maxLength: 10 }),
+		char2: t.Enum(['a', 'b', 'c']),
+		date1: new TDate(),
+		date2: t.String(),
+		datetime1: new TDate(),
+		datetime2: t.String(),
+		decimal1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal2: t.Number({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		decimal3: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		decimal4: t.BigInt({ minimum: 0n, maximum: CONSTANTS.INT64_UNSIGNED_MAX }),
+		decimal5: t.String(),
+		decimal6: t.String(),
+		double1: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		double2: t.Number({ minimum: 0, maximum: CONSTANTS.INT48_UNSIGNED_MAX }),
+		float1: t.Number({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		float2: t.Number({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		int1: t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: CONSTANTS.INT32_MAX }),
+		int2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT32_UNSIGNED_MAX }),
+		json: jsonSchema,
+		mediumint1: t.Integer({ minimum: CONSTANTS.INT24_MIN, maximum: CONSTANTS.INT24_MAX }),
+		mediumint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT24_UNSIGNED_MAX }),
+		enum: t.Enum(['a', 'b', 'c']),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		serial: t.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+		smallint1: t.Integer({ minimum: CONSTANTS.INT16_MIN, maximum: CONSTANTS.INT16_MAX }),
+		smallint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text1: t.String({ maxLength: CONSTANTS.INT16_UNSIGNED_MAX }),
+		text2: t.Enum(['a', 'b', 'c']),
+		time: t.String(),
+		timestamp1: new TDate(),
+		timestamp2: t.String(),
+		tinyint1: t.Integer({ minimum: CONSTANTS.INT8_MIN, maximum: CONSTANTS.INT8_MAX }),
+		tinyint2: t.Integer({ minimum: 0, maximum: CONSTANTS.INT8_UNSIGNED_MAX }),
+		varchar1: t.String({ maxLength: 10 }),
+		varchar2: t.Enum(['a', 'b', 'c']),
+		varbinary: t.String({ pattern: /^[01]*$/, maxLength: 10 }),
+		year: t.Integer({ minimum: 1901, maximum: 2155 }),
+		longtext1: t.String({ maxLength: CONSTANTS.INT32_UNSIGNED_MAX }),
+		longtext2: t.Enum(['a', 'b', 'c']),
+		mediumtext1: t.String({ maxLength: CONSTANTS.INT24_UNSIGNED_MAX }),
+		mediumtext2: t.Enum(['a', 'b', 'c']),
+		tinytext1: t.String({ maxLength: CONSTANTS.INT8_UNSIGNED_MAX }),
+		tinytext2: t.Enum(['a', 'b', 'c']),
+		vector: t.Array(t.Number(), { minItems: 3, maxItems: 3 }),
+		vector2: t.Array(t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }), {
+			minItems: 2,
+			maxItems: 2,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: t.String() });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: t.String() });
+// }
diff --git a/integration-tests/tests/validators/typebox/sqlite.test.ts b/integration-tests/tests/validators/typebox/sqlite.test.ts
new file mode 100644
index 0000000000..2a0e73e062
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/sqlite.test.ts
@@ -0,0 +1,437 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import {
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+	type GenericSchema,
+	jsonSchema,
+	TBigIntString,
+	TBuffer,
+	TDate,
+} from 'drizzle-orm/typebox';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import type { TopLevelCondition } from 'json-rules-engine';
+import t, { type Static } from 'typebox';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
+const intNullableSchema = t.Union([intSchema, t.Null()]);
+const intOptionalSchema = t.Optional(intSchema);
+const intNullableOptionalSchema = t.Optional(t.Union([intSchema, t.Null()]));
+
+const textSchema = t.String();
+const textOptionalSchema = t.Optional(textSchema);
+
+const anySchema = t.Any();
+
+const extendedSchema = t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 });
+const extendedNullableSchema = t.Union([extendedSchema, t.Null()]);
+const extendedOptionalSchema = t.Optional(extendedSchema);
+
+const customSchema = t.Integer({ minimum: 1, maximum: 10 });
+
+test('table - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({ id: intSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		id: intOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: intSchema, age: anySchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (tc) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({ id: intSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (tc) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = t.Object({
+		id: intSchema,
+		nested: t.Object({ name: textSchema, age: anySchema }),
+		table: t.Object({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (tc) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = t.String({ minLength: 1, maxLength: 100 });
+	const result = createSelectSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		c4: customTextSchema,
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+	});
+	const expected = t.Object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (tc) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+		c3: t.Integer({ minimum: 1, maximum: 10 }),
+		nested: {
+			c5: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+			c6: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+		table: {
+			c2: () => t.Integer({ minimum: CONSTANTS.INT32_MIN, maximum: 1000 }),
+			c3: t.Integer({ minimum: 1, maximum: 10 }),
+		},
+	});
+	const expected = t.Object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: t.Object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: t.Object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (tc) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = t.Object({
+		blob1: new TBuffer(),
+		blob2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		blob3: jsonSchema,
+		integer1: t.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		integer2: t.Boolean(),
+		integer3: new TDate(),
+		integer4: new TDate(),
+		numeric1: t.Number({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER }),
+		numeric2: t.BigInt({ minimum: CONSTANTS.INT64_MIN, maximum: CONSTANTS.INT64_MAX }),
+		numeric3: t.String(),
+		real: t.Number({ minimum: CONSTANTS.INT48_MIN, maximum: CONSTANTS.INT48_MAX }),
+		text1: t.String(),
+		text2: t.String({ maxLength: 10 }),
+		text3: t.Enum(['a', 'b', 'c']),
+		text4: jsonSchema,
+	});
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: GenericSchema<TopLevelCondition> = t.Any() as any;
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = t.Object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<Static<typeof result>, Static<typeof expected>>>();
+}
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: t.String() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: t.String() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: t.String() });
+}
diff --git a/integration-tests/tests/validators/typebox/utils.ts b/integration-tests/tests/validators/typebox/utils.ts
new file mode 100644
index 0000000000..d3740005fa
--- /dev/null
+++ b/integration-tests/tests/validators/typebox/utils.ts
@@ -0,0 +1,34 @@
+import type * as t from 'typebox';
+import { expect, type TestContext } from 'vitest';
+
+function removeKeysFromObject(obj: Record<string, any>, keys: string[]) {
+	for (const key of keys) {
+		delete obj[key];
+	}
+	return obj;
+}
+
+export function expectSchemaShape<T extends t.TObject>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(Object.keys(actual.properties)).toStrictEqual(Object.keys(expected.properties));
+			const keys = ['$id', '$schema', 'title', 'description', 'default', 'examples', 'readOnly', 'writeOnly'];
+
+			for (const key of Object.keys(actual.properties)) {
+				expect(removeKeysFromObject(actual.properties[key]!, keys)).toStrictEqual(
+					removeKeysFromObject(expected.properties[key]!, keys),
+				);
+			}
+		},
+	};
+}
+
+export function expectEnumValues<T extends t.TEnum<any>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(actual.enum).toStrictEqual(expected.enum);
+		},
+	};
+}
+
+export function Expect<_ extends true>() {}
diff --git a/integration-tests/tests/validators/valibot/cockroach.test.ts b/integration-tests/tests/validators/valibot/cockroach.test.ts
new file mode 100644
index 0000000000..21e23bf041
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/cockroach.test.ts
@@ -0,0 +1,565 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { jsonSchema } from 'drizzle-orm/valibot/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer());
+const int4NullableSchema = v.nullable(int4Schema);
+const int4OptionalSchema = v.optional(int4Schema);
+const int4NullableOptionalSchema = v.optional(v.nullable(int4Schema));
+
+const textSchema = v.string();
+const textOptionalSchema = v.optional(textSchema);
+
+const anySchema = v.any();
+
+const extendedSchema = v.pipe(int4Schema, v.maxValue(1000));
+const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: int4Schema, generated: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({
+		id: int4Schema,
+		nested: v.object({ name: textSchema, age: anySchema }),
+		table: v.object({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = v.enum({ a: 'a', b: 'b', c: 'c' });
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		nested: {
+			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c6: v.pipe(v.string(), v.transform(Number)),
+		},
+		table: {
+			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c3: v.pipe(v.string(), v.transform(Number)),
+		},
+	});
+	const expected = v.object({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: v.object({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: v.object({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		boolean: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bit: v.pipe(v.string(), v.regex(/^[01]*$/), v.length(5 as number)),
+		boolean: v.boolean(),
+		char1: v.pipe(v.string(), v.maxLength(10 as number)),
+		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: v.date(),
+		date2: v.string(),
+		decimal1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		decimal3: v.string(),
+		float: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		doublePrecision: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		geometry1: v.tuple([v.number(), v.number()]),
+		geometry2: v.object({ x: v.number(), y: v.number() }),
+		inet: v.string(),
+		int2: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		int4: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		int8_1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		int8_2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		interval: v.string(),
+		jsonb: jsonSchema,
+		numeric1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		numeric2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		numeric3: v.string(),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
+		smallint: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		string1: v.string(),
+		string2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		text1: v.string(),
+		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		time: v.string(),
+		timestamp1: v.date(),
+		timestamp2: v.string(),
+		uuid: v.pipe(v.string(), v.uuid()),
+		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: v.pipe(v.array(v.number()), v.length(3 as number)),
+		array: v.array(int4Schema),
+	});
+
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: v.string() });
+}
diff --git a/integration-tests/tests/validators/valibot/mssql.test.ts b/integration-tests/tests/validators/valibot/mssql.test.ts
new file mode 100644
index 0000000000..7484c63413
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/mssql.test.ts
@@ -0,0 +1,510 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import {
+	bigintStringModeSchema,
+	bufferSchema,
+	createInsertSchema,
+	createSelectSchema,
+	createUpdateSchema,
+} from 'drizzle-orm/valibot';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const integerSchema = v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer());
+const integerNullableSchema = v.nullable(integerSchema);
+const integerOptionalSchema = v.optional(integerSchema);
+const integerNullableOptionalSchema = v.optional(v.nullable(integerSchema));
+
+const textSchema = v.string();
+const textOptionalSchema = v.optional(textSchema);
+
+const anySchema = v.any();
+
+const extendedSchema = v.pipe(integerSchema, v.maxValue(1000));
+const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({
+		id: integerSchema,
+		nested: v.object({ name: textSchema, age: anySchema }),
+		table: v.object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		nested: {
+			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c6: v.pipe(v.string(), v.transform(Number)),
+		},
+		table: {
+			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c3: v.pipe(v.string(), v.transform(Number)),
+		},
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: v.object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: v.object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bigint3: bigintStringModeSchema,
+		binary: bufferSchema,
+		bit: v.boolean(),
+		char1: v.pipe(v.string(), v.maxLength(10 as number)),
+		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: v.date(),
+		date2: v.string(),
+		datetime1: v.date(),
+		datetime2: v.string(),
+		datetime2_1: v.date(),
+		datetime2_2: v.string(),
+		datetimeoffset1: v.date(),
+		datetimeoffset2: v.string(),
+		decimal1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		decimal3: v.string(),
+		float: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		int: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		numeric1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		numeric2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		numeric3: v.string(),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
+		smallint: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		text1: v.string(),
+		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		time1: v.date(),
+		time2: v.string(),
+		tinyint: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT8_UNSIGNED_MAX), v.integer()),
+		varbinary: bufferSchema,
+		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		ntext1: v.string(),
+		ntext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		nvarchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		nvarchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+	});
+
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: v.string() });
+}
diff --git a/integration-tests/tests/validators/valibot/mysql.test.ts b/integration-tests/tests/validators/valibot/mysql.test.ts
new file mode 100644
index 0000000000..8da8b5e8aa
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/mysql.test.ts
@@ -0,0 +1,563 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/valibot/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = v.pipe(
+	v.number(),
+	v.minValue(CONSTANTS.INT32_MIN as number),
+	v.maxValue(CONSTANTS.INT32_MAX as number),
+	v.integer(),
+);
+const intNullableSchema = v.nullable(intSchema);
+const intOptionalSchema = v.optional(intSchema);
+const intNullableOptionalSchema = v.optional(v.nullable(intSchema));
+
+const serialSchema = v.pipe(
+	v.number(),
+	v.minValue(0 as number),
+	v.maxValue(Number.MAX_SAFE_INTEGER as number),
+	v.integer(),
+);
+
+const serialOptionalSchema = v.optional(serialSchema);
+
+const textSchema = v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX as number));
+const textOptionalSchema = v.optional(textSchema);
+
+const anySchema = v.any();
+
+const extendedSchema = v.pipe(intSchema, v.maxValue(1000));
+const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: serialSchema, name: textSchema });
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: serialSchema, name: textSchema });
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(tc, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: serialSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: serialSchema, name: textSchema });
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({
+		id: serialSchema,
+		nested: v.object({ name: textSchema, age: anySchema }),
+		table: v.object({ id: serialSchema, name: textSchema }),
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		nested: {
+			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c6: v.pipe(v.string(), v.transform(Number)),
+		},
+		table: {
+			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c3: v.pipe(v.string(), v.transform(Number)),
+		},
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: v.object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: v.object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bigint3: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: v.pipe(v.string(), v.regex(/^[01]*$/), v.maxLength(10 as number)),
+		boolean: v.boolean(),
+		char1: v.pipe(v.string(), v.maxLength(10 as number)),
+		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: v.date(),
+		date2: v.string(),
+		datetime1: v.date(),
+		datetime2: v.string(),
+		decimal1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal3: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		decimal4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
+		decimal5: v.string(),
+		decimal6: v.string(),
+		double1: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		double2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT48_UNSIGNED_MAX)),
+		float1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
+		float2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX)),
+		int1: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		int2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT32_UNSIGNED_MAX), v.integer()),
+		json: jsonSchema,
+		mediumint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX), v.integer()),
+		mediumint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX), v.integer()),
+		enum: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		serial: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		smallint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		smallint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT16_UNSIGNED_MAX), v.integer()),
+		text1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
+		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		time: v.string(),
+		timestamp1: v.date(),
+		timestamp2: v.string(),
+		tinyint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT8_MIN), v.maxValue(CONSTANTS.INT8_MAX), v.integer()),
+		tinyint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT8_UNSIGNED_MAX), v.integer()),
+		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		varbinary: v.pipe(v.string(), v.regex(/^[01]*$/), v.maxLength(10 as number)),
+		year: v.pipe(v.number(), v.minValue(1901 as number), v.maxValue(2155 as number), v.integer()),
+		longtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
+		longtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		mediumtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
+		mediumtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		tinytext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
+		tinytext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+}
diff --git a/integration-tests/tests/validators/valibot/pg.test.ts b/integration-tests/tests/validators/valibot/pg.test.ts
new file mode 100644
index 0000000000..64a621465d
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/pg.test.ts
@@ -0,0 +1,591 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	customType,
+	integer,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { bigintStringModeSchema, jsonSchema } from 'drizzle-orm/valibot/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer());
+const integerNullableSchema = v.nullable(integerSchema);
+const integerOptionalSchema = v.optional(integerSchema);
+const integerNullableOptionalSchema = v.optional(v.nullable(integerSchema));
+
+const textSchema = v.string();
+const textOptionalSchema = v.optional(textSchema);
+
+const anySchema = v.any();
+
+const extendedSchema = v.pipe(integerSchema, v.maxValue(1000));
+const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({
+		id: integerSchema,
+		nested: v.object({ name: textSchema, age: anySchema }),
+		table: v.object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = v.enum({ a: 'a', b: 'b', c: 'c' });
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		nested: {
+			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c6: v.pipe(v.string(), v.transform(Number)),
+		},
+		table: {
+			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c3: v.pipe(v.string(), v.transform(Number)),
+		},
+	});
+	const expected = v.object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: v.object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: v.object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bigint3: bigintStringModeSchema,
+		bigserial1: v.pipe(
+			v.number(),
+			v.minValue(Number.MIN_SAFE_INTEGER),
+			v.maxValue(Number.MAX_SAFE_INTEGER),
+			v.integer(),
+		),
+		bigserial2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bit: v.pipe(v.string(), v.regex(/^[01]*$/), v.length(5 as number)),
+		boolean: v.boolean(),
+		date1: v.date(),
+		date2: v.string(),
+		char1: v.pipe(v.string(), v.maxLength(10 as number)),
+		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		cidr: v.string(),
+		doublePrecision: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		geometry1: v.tuple([v.number(), v.number()]),
+		geometry2: v.object({ x: v.number(), y: v.number() }),
+		halfvec: v.pipe(v.array(v.number()), v.length(3 as number)),
+		inet: v.string(),
+		integer: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		interval: v.string(),
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: v.object({ a: v.number(), b: v.number(), c: v.number() }),
+		line2: v.tuple([v.number(), v.number(), v.number()]),
+		macaddr: v.string(),
+		macaddr8: v.string(),
+		numeric1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		numeric2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		numeric3: v.string(),
+		point1: v.object({ x: v.number(), y: v.number() }),
+		point2: v.tuple([v.number(), v.number()]),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
+		serial: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		smallint: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		smallserial: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		text1: v.string(),
+		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		sparsevec: v.string(),
+		time: v.string(),
+		timestamp1: v.date(),
+		timestamp2: v.string(),
+		uuid: v.pipe(v.string(), v.uuid()),
+		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: v.pipe(v.array(v.number()), v.length(3 as number)),
+		array1: v.array(integerSchema),
+		array2: v.array(v.array(integerSchema)),
+		array3: v.array(v.array(v.pipe(v.string(), v.maxLength(10 as number)))),
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: v.string() });
+}
diff --git a/integration-tests/tests/validators/valibot/singlestore.test.ts b/integration-tests/tests/validators/valibot/singlestore.test.ts
new file mode 100644
index 0000000000..d8a544f3a3
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/singlestore.test.ts
@@ -0,0 +1,574 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/valibot/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = v.pipe(
+	v.number(),
+	v.minValue(CONSTANTS.INT32_MIN as number),
+	v.maxValue(CONSTANTS.INT32_MAX as number),
+	v.integer(),
+);
+const intNullableSchema = v.nullable(intSchema);
+const intOptionalSchema = v.optional(intSchema);
+const intNullableOptionalSchema = v.optional(v.nullable(intSchema));
+
+const serialSchema = v.pipe(
+	v.number(),
+	v.minValue(0 as number),
+	v.maxValue(Number.MAX_SAFE_INTEGER as number),
+	v.integer(),
+);
+const serialOptionalSchema = v.optional(serialSchema);
+
+const textSchema = v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX as number));
+const textOptionalSchema = v.optional(textSchema);
+
+// const anySchema = v.any();
+
+const extendedSchema = v.pipe(intSchema, v.maxValue(1000));
+// const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: serialSchema, name: textSchema });
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: serialSchema, name: textSchema });
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(tc, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (t) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = v.object({
+// 		id: serialSchema,
+// 		nested: v.object({ name: textSchema, age: anySchema }),
+// 		table: v.object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 		c3: v.pipe(v.string(), v.transform(Number)),
+// 		nested: {
+// 			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 			c6: v.pipe(v.string(), v.transform(Number)),
+// 		},
+// 		table: {
+// 			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+// 			c3: v.pipe(v.string(), v.transform(Number)),
+// 		},
+// 	});
+// 	const expected = v.object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: v.object({
+// 			c4: intNullableSchema,
+// 			c5: extendedNullableSchema,
+// 			c6: customSchema,
+// 		}),
+// 		table: v.object({
+// 			c1: intNullableSchema,
+// 			c2: extendedNullableSchema,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,
+// 			c5: intNullableSchema,
+// 			c6: intNullableSchema,
+// 		}),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (t) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		bigint1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		bigint3: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		bigint4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: v.pipe(v.string(), v.regex(/^[01]*$/), v.maxLength(10 as number)),
+		boolean: v.boolean(),
+		char1: v.pipe(v.string(), v.maxLength(10 as number)),
+		char2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		date1: v.date(),
+		date2: v.string(),
+		datetime1: v.date(),
+		datetime2: v.string(),
+		decimal1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		decimal3: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		decimal4: v.pipe(v.bigint(), v.minValue(0n as bigint), v.maxValue(CONSTANTS.INT64_UNSIGNED_MAX)),
+		decimal5: v.string(),
+		decimal6: v.string(),
+		double1: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		double2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT48_UNSIGNED_MAX)),
+		float1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX)),
+		float2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX)),
+		int1: v.pipe(v.number(), v.minValue(CONSTANTS.INT32_MIN), v.maxValue(CONSTANTS.INT32_MAX), v.integer()),
+		int2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT32_UNSIGNED_MAX), v.integer()),
+		json: jsonSchema,
+		mediumint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT24_MIN), v.maxValue(CONSTANTS.INT24_MAX), v.integer()),
+		mediumint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT24_UNSIGNED_MAX), v.integer()),
+		enum: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		serial: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		smallint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT16_MIN), v.maxValue(CONSTANTS.INT16_MAX), v.integer()),
+		smallint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT16_UNSIGNED_MAX), v.integer()),
+		text1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT16_UNSIGNED_MAX)),
+		text2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		time: v.string(),
+		timestamp1: v.date(),
+		timestamp2: v.string(),
+		tinyint1: v.pipe(v.number(), v.minValue(CONSTANTS.INT8_MIN), v.maxValue(CONSTANTS.INT8_MAX), v.integer()),
+		tinyint2: v.pipe(v.number(), v.minValue(0 as number), v.maxValue(CONSTANTS.INT8_UNSIGNED_MAX), v.integer()),
+		varchar1: v.pipe(v.string(), v.maxLength(10 as number)),
+		varchar2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		varbinary: v.pipe(v.string(), v.regex(/^[01]*$/), v.maxLength(10 as number)),
+		year: v.pipe(v.number(), v.minValue(1901 as number), v.maxValue(2155 as number), v.integer()),
+		longtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT32_UNSIGNED_MAX)),
+		longtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		mediumtext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT24_UNSIGNED_MAX)),
+		mediumtext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		tinytext1: v.pipe(v.string(), v.maxLength(CONSTANTS.INT8_UNSIGNED_MAX)),
+		tinytext2: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		vector: v.pipe(v.array(v.number()), v.length(3 as number)),
+		vector2: v.pipe(
+			v.array(v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX))),
+			v.length(2),
+		),
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: v.string() });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: v.string() });
+// }
diff --git a/integration-tests/tests/validators/valibot/sqlite.test.ts b/integration-tests/tests/validators/valibot/sqlite.test.ts
new file mode 100644
index 0000000000..f737a1ec91
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/sqlite.test.ts
@@ -0,0 +1,432 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { blob, customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from 'drizzle-orm/valibot';
+import { bufferSchema, jsonSchema } from 'drizzle-orm/valibot/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import * as v from 'valibot';
+import { test } from 'vitest';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = v.pipe(
+	v.number(),
+	v.minValue(Number.MIN_SAFE_INTEGER),
+	v.maxValue(Number.MAX_SAFE_INTEGER),
+	v.integer(),
+);
+const intNullableSchema = v.nullable(intSchema);
+const intOptionalSchema = v.optional(intSchema);
+const intNullableOptionalSchema = v.optional(v.nullable(intSchema));
+
+const textSchema = v.string();
+const textOptionalSchema = v.optional(textSchema);
+
+const anySchema = v.any();
+
+const extendedSchema = v.pipe(intSchema, v.maxValue(1000));
+const extendedNullableSchema = v.nullable(extendedSchema);
+const extendedOptionalSchema = v.optional(extendedSchema);
+
+const customSchema = v.pipe(v.string(), v.transform(Number));
+
+test('table - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({ id: intOptionalSchema, name: textSchema, age: intNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: intSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = v.object({
+		id: intSchema,
+		nested: v.object({ name: textSchema, age: anySchema }),
+		table: v.object({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(100));
+	const result = createSelectSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		c4: customTextSchema,
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+	});
+	const expected = v.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+		c3: v.pipe(v.string(), v.transform(Number)),
+		nested: {
+			c5: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c6: v.pipe(v.string(), v.transform(Number)),
+		},
+		table: {
+			c2: (schema) => v.pipe(schema, v.maxValue(1000)),
+			c3: v.pipe(v.string(), v.transform(Number)),
+		},
+	});
+	const expected = v.object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: v.object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: v.object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = v.object({
+		blob1: bufferSchema,
+		blob2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		blob3: jsonSchema,
+		integer1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER), v.integer()),
+		integer2: v.boolean(),
+		integer3: v.date(),
+		integer4: v.date(),
+		numeric1: v.pipe(v.number(), v.minValue(Number.MIN_SAFE_INTEGER), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		numeric2: v.pipe(v.bigint(), v.minValue(CONSTANTS.INT64_MIN), v.maxValue(CONSTANTS.INT64_MAX)),
+		numeric3: v.string(),
+		real: v.pipe(v.number(), v.minValue(CONSTANTS.INT48_MIN), v.maxValue(CONSTANTS.INT48_MAX)),
+		text1: v.string(),
+		text2: v.pipe(v.string(), v.maxLength(10 as number)),
+		text3: v.enum({ a: 'a', b: 'b', c: 'c' }),
+		text4: jsonSchema,
+	});
+	// @ts-ignore - TODO: Remake type checks for new columns
+	expectSchemaShape(t, expected).from(result);
+	// @ts-ignore - TODO: Remake type checks for new columns
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: v.GenericSchema<TopLevelCondition> = v.custom<TopLevelCondition>(() => true);
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = v.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<v.InferOutput<typeof result>, v.InferOutput<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: v.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: v.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: v.string() });
+}
diff --git a/integration-tests/tests/validators/valibot/utils.ts b/integration-tests/tests/validators/valibot/utils.ts
new file mode 100644
index 0000000000..c0793e3498
--- /dev/null
+++ b/integration-tests/tests/validators/valibot/utils.ts
@@ -0,0 +1,43 @@
+import type * as v from 'valibot';
+import { expect, type TestContext } from 'vitest';
+
+function onlySpecifiedKeys(obj: Record<string, any>, keys: string[]) {
+	return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
+}
+
+export function expectSchemaShape<T extends v.ObjectSchema<v.ObjectEntries, undefined>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(Object.keys(actual.entries)).toStrictEqual(Object.keys(expected.entries));
+
+			for (const key of Object.keys(actual.entries)) {
+				const actualEntry = actual.entries[key] as any;
+				const expectedEntry = expected.entries[key] as any;
+				const keys = ['kind', 'type', 'expects', 'async', 'message'];
+				actualEntry.pipe ??= [];
+				expectedEntry.pipe ??= [];
+
+				expect(onlySpecifiedKeys(actualEntry, keys)).toStrictEqual(onlySpecifiedKeys(expectedEntry, keys));
+				expect(actualEntry.pipe.length).toStrictEqual(expectedEntry.pipe.length);
+
+				for (let i = 0; i < actualEntry.pipe.length; i++) {
+					const actualPipeElement = actualEntry.pipe[i];
+					const expectedPipeElement = expectedEntry.pipe[i];
+					expect(onlySpecifiedKeys(actualPipeElement, keys)).toStrictEqual(
+						onlySpecifiedKeys(expectedPipeElement, keys),
+					);
+				}
+			}
+		},
+	};
+}
+
+export function expectEnumValues<T extends v.EnumSchema<any, undefined>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(actual.enum).toStrictEqual(expected.enum);
+		},
+	};
+}
+
+export function Expect<_ extends true>() {}
diff --git a/integration-tests/tests/validators/zod/cockroach.test.ts b/integration-tests/tests/validators/zod/cockroach.test.ts
new file mode 100644
index 0000000000..4ad6aee676
--- /dev/null
+++ b/integration-tests/tests/validators/zod/cockroach.test.ts
@@ -0,0 +1,616 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	cockroachEnum,
+	cockroachMaterializedView,
+	cockroachSchema,
+	cockroachTable,
+	cockroachView,
+	customType,
+	int4,
+	text,
+} from 'drizzle-orm/cockroach-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { jsonSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const int4Schema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
+const int4NullableSchema = int4Schema.nullable();
+const int4OptionalSchema = int4Schema.optional();
+const int4NullableOptionalSchema = int4Schema.nullable().optional();
+
+const textSchema = z.string();
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = z.any();
+
+const extendedSchema = int4Schema.lte(1000);
+const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		generated: int4().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: int4Schema, generated: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = cockroachSchema('test');
+	const table = schema.table('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({ name: textSchema, age: int4NullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: int4(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		name: textOptionalSchema,
+		age: int4NullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = cockroachView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachMaterializedView('test').as((qb) =>
+		qb.select({ id: table.id, age: sql``.as('age') }).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: int4Schema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = cockroachMaterializedView('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: int4Schema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = cockroachTable('test', {
+		id: int4().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({
+		id: int4Schema,
+		nested: z.object({ name: textSchema, age: anySchema }),
+		table: z.object({ id: int4Schema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = cockroachEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = z.enum(['a', 'b', 'c']);
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: int4NullableSchema,
+		c2: int4Schema,
+		c3: int4NullableSchema,
+		c4: int4Schema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: int4NullableOptionalSchema,
+		c2: int4Schema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().default(1),
+		c4: int4().notNull().default(1),
+		c5: int4().generatedAlwaysAs(sql`1`),
+		c6: int4().generatedAlwaysAsIdentity(),
+		c7: int4().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: int4NullableOptionalSchema,
+		c2: int4OptionalSchema,
+		c3: int4NullableOptionalSchema,
+		c4: int4OptionalSchema,
+		c7: int4OptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: int4NullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4().notNull(),
+		c3: int4().notNull(),
+		c4: int4().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: int4NullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = cockroachTable('test', {
+		c1: int4(),
+		c2: int4(),
+		c3: int4(),
+		c4: int4(),
+		c5: int4(),
+		c6: int4(),
+	});
+	const view = cockroachView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		nested: {
+			c5: (schema) => schema.lte(1000),
+			c6: z.string().transform(Number),
+		},
+		table: {
+			c2: (schema) => schema.lte(1000),
+			c3: z.string().transform(Number),
+		},
+	});
+	const expected = z.object({
+		c1: int4NullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: z.object({
+			c4: int4NullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: z.object({
+			c1: int4NullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: int4NullableSchema,
+			c5: int4NullableSchema,
+			c6: int4NullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bit,
+		bool,
+		char,
+		date,
+		decimal,
+		float,
+		doublePrecision,
+		geometry,
+		inet,
+		int2,
+		int4,
+		int8,
+		interval,
+		jsonb,
+		numeric,
+		real,
+		smallint,
+		string,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit({ length: 5 }).notNull(),
+		bool: bool().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		inet: inet().notNull(),
+		int2: int2().notNull(),
+		int4: int4().notNull(),
+		int8_1: int8({ mode: 'number' }).notNull(),
+		int8_2: int8({ mode: 'bigint' }).notNull(),
+		interval: interval().notNull(),
+		jsonb: jsonb().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		string1: string().notNull(),
+		string2: string({ enum: ['a', 'b', 'c'] }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array: int4().array().notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bit: z.string().regex(/^[01]*$/).length(5),
+		bool: z.boolean(),
+		char1: z.string().max(10),
+		char2: z.enum(['a', 'b', 'c']),
+		date1: z.date(),
+		date2: z.string(),
+		decimal1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		decimal2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		decimal3: z.string(),
+		float: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		doublePrecision: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		geometry1: z.tuple([z.number(), z.number()]),
+		geometry2: z.object({ x: z.number(), y: z.number() }),
+		inet: z.string(),
+		int2: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		int4: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		int8_1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		int8_2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		interval: z.string(),
+		jsonb: jsonSchema,
+		numeric1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		numeric2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		numeric3: z.string(),
+		real: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		smallint: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		string1: z.string(),
+		string2: z.enum(['a', 'b', 'c']),
+		text1: z.string(),
+		text2: z.enum(['a', 'b', 'c']),
+		time: z.string(),
+		timestamp1: z.date(),
+		timestamp2: z.string(),
+		uuid: z.uuid(),
+		varchar1: z.string().max(10),
+		varchar2: z.enum(['a', 'b', 'c']),
+		vector: z.array(z.number()).length(3),
+		array: z.array(int4Schema),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = cockroachTable('test', ({
+		bigint,
+		bool,
+		timestamp,
+		int4,
+		text,
+	}) => ({
+		bigint: bigint({ mode: 'bigint' }).notNull(),
+		bool: bool().notNull(),
+		timestamp: timestamp().notNull(),
+		int4: int4().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bool: z.coerce.boolean(),
+		timestamp: z.coerce.date(),
+		int4: z.coerce.number().int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		text: z.coerce.string(),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = cockroachTable('test', ({
+		timestamp,
+		int4,
+	}) => ({
+		timestamp: timestamp().notNull(),
+		int4: int4().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		timestamp: z.coerce.date(),
+		int4: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = cockroachTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = cockroachTable('test', { id: int4() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = cockroachTable('test', { id: int4() });
+	const view = cockroachView('test').as((qb) => qb.select().from(table));
+	const mView = cockroachMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = cockroachView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = cockroachView('test', { id: int4() }).as(sql``);
+	const mView = cockroachView('test', { id: int4() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: z.string() });
+}
diff --git a/integration-tests/tests/validators/zod/mssql.test.ts b/integration-tests/tests/validators/zod/mssql.test.ts
new file mode 100644
index 0000000000..c9f38ef0b1
--- /dev/null
+++ b/integration-tests/tests/validators/zod/mssql.test.ts
@@ -0,0 +1,556 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, mssqlSchema, mssqlTable, mssqlView, text } from 'drizzle-orm/mssql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { bigintStringModeSchema, bufferSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectSchemaShape } from './utils';
+
+const integerSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
+const integerNullableSchema = integerSchema.nullable();
+const integerOptionalSchema = integerSchema.optional();
+const integerNullableOptionalSchema = integerSchema.nullable().optional();
+
+const textSchema = z.string();
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = z.any();
+
+const extendedSchema = integerSchema.lte(1000);
+const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		generated: int().identity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mssqlSchema('test');
+	const table = schema.table('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mssqlTable('test', {
+		id: int().identity().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mssqlView('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mssqlTable('test', {
+		id: int().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({
+		id: integerSchema,
+		nested: z.object({ name: textSchema, age: anySchema }),
+		table: z.object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+		c6: int().identity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mssqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mssqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		nested: {
+			c5: (schema) => schema.lte(1000),
+			c6: z.string().transform(Number),
+		},
+		table: {
+			c2: (schema) => schema.lte(1000),
+			c3: z.string().transform(Number),
+		},
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: z.object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: z.object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		binary,
+		bit,
+		char,
+		date,
+		datetime,
+		datetime2,
+		datetimeoffset,
+		decimal,
+		float,
+		int,
+		numeric,
+		real,
+		smallint,
+		text,
+		time,
+		tinyint,
+		varbinary,
+		varchar,
+		ntext,
+		nvarchar,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		bit: bit().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		datetime2_1: datetime2({ mode: 'date' }).notNull(),
+		datetime2_2: datetime2({ mode: 'string' }).notNull(),
+		datetimeoffset1: datetimeoffset({ mode: 'date' }).notNull(),
+		datetimeoffset2: datetimeoffset({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'bigint' }).notNull(),
+		decimal3: decimal({ mode: 'string' }).notNull(),
+		float: float().notNull(),
+		int: int().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		smallint: smallint().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time1: time({ mode: 'date' }).notNull(),
+		time2: time({ mode: 'string' }).notNull(),
+		tinyint: tinyint().notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		ntext1: ntext().notNull(),
+		ntext2: ntext({ enum: ['a', 'b', 'c'] }).notNull(),
+		nvarchar1: nvarchar({ length: 10 }).notNull(),
+		nvarchar2: nvarchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bigint3: bigintStringModeSchema,
+		binary: bufferSchema,
+		bit: z.boolean(),
+		char1: z.string().max(10),
+		char2: z.enum(['a', 'b', 'c']),
+		date1: z.date(),
+		date2: z.string(),
+		datetime1: z.date(),
+		datetime2: z.string(),
+		datetime2_1: z.date(),
+		datetime2_2: z.string(),
+		datetimeoffset1: z.date(),
+		datetimeoffset2: z.string(),
+		decimal1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		decimal2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		decimal3: z.string(),
+		float: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		numeric1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		numeric2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		numeric3: z.string(),
+		real: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		smallint: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		text1: z.string(),
+		text2: z.enum(['a', 'b', 'c']),
+		time1: z.date(),
+		time2: z.string(),
+		tinyint: z.int().gte(0).lte(CONSTANTS.INT8_UNSIGNED_MAX),
+		varbinary: bufferSchema,
+		varchar1: z.string().max(10),
+		varchar2: z.enum(['a', 'b', 'c']),
+		ntext1: z.string(),
+		ntext2: z.enum(['a', 'b', 'c']),
+		nvarchar1: z.string().max(10),
+		nvarchar2: z.enum(['a', 'b', 'c']),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = mssqlTable('test', ({
+		bigint,
+		bit,
+		datetime,
+		int,
+		text,
+	}) => ({
+		bigint: bigint({ mode: 'bigint' }).notNull(),
+		bit: bit().notNull(),
+		datetime: datetime().notNull(),
+		int: int().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bit: z.coerce.boolean(),
+		datetime: z.coerce.date(),
+		int: z.coerce.number().int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		text: z.coerce.string(),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = mssqlTable('test', ({
+		datetime,
+		int,
+	}) => ({
+		datetime: datetime().notNull(),
+		int: int().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		datetime: z.coerce.date(),
+		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mssqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mssqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mssqlTable('test', { id: int() });
+	const view = mssqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mssqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mssqlView('test', { id: int() }).as(sql``);
+	const mView = mssqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: z.string() });
+}
diff --git a/integration-tests/tests/validators/zod/mysql.test.ts b/integration-tests/tests/validators/zod/mysql.test.ts
new file mode 100644
index 0000000000..ae55c2093b
--- /dev/null
+++ b/integration-tests/tests/validators/zod/mysql.test.ts
@@ -0,0 +1,593 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, json, mysqlSchema, mysqlTable, mysqlView, serial, text } from 'drizzle-orm/mysql-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
+const intNullableSchema = intSchema.nullable();
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intSchema.nullable().optional();
+
+const serialSchema = z.int().gte(0).lte(Number.MAX_SAFE_INTEGER);
+const serialOptionalSchema = serialSchema.optional();
+
+const textSchema = z.string().max(CONSTANTS.INT16_UNSIGNED_MAX);
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = z.any();
+
+const extendedSchema = intSchema.lte(1000);
+const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		generated: int().generatedAlwaysAs(sql`1`).notNull(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: serialSchema, generated: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = mysqlSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: serialSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = mysqlView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = mysqlTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({
+		id: serialSchema,
+		nested: z.object({ name: textSchema, age: anySchema }),
+		table: z.object({ id: serialSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: intSchema.nullable(),
+		c2: intSchema,
+		c3: intSchema.nullable(),
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = mysqlTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = mysqlView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		nested: {
+			c5: (schema) => schema.lte(1000),
+			c6: z.string().transform(Number),
+		},
+		table: {
+			c2: (schema) => schema.lte(1000),
+			c3: z.string().transform(Number),
+		},
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: z.object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: z.object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		mysqlEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: mysqlEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bigint3: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		bigint4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: z.string().regex(/^[01]*$/).max(10),
+		boolean: z.boolean(),
+		char1: z.string().max(10),
+		char2: z.enum(['a', 'b', 'c']),
+		date1: z.date(),
+		date2: z.string(),
+		datetime1: z.date(),
+		datetime2: z.string(),
+		decimal1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		decimal2: z.number().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		decimal3: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		decimal4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
+		decimal5: z.string(),
+		decimal6: z.string(),
+		double1: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		double2: z.number().gte(0).lte(CONSTANTS.INT48_UNSIGNED_MAX),
+		float1: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		float2: z.number().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
+		int1: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		int2: z.int().gte(0).lte(CONSTANTS.INT32_UNSIGNED_MAX),
+		json: jsonSchema,
+		mediumint1: z.int().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		mediumint2: z.int().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
+		enum: z.enum(['a', 'b', 'c']),
+		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		serial: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		smallint1: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		smallint2: z.int().gte(0).lte(CONSTANTS.INT16_UNSIGNED_MAX),
+		text1: z.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
+		text2: z.enum(['a', 'b', 'c']),
+		time: z.string(),
+		timestamp1: z.date(),
+		timestamp2: z.string(),
+		tinyint1: z.int().gte(CONSTANTS.INT8_MIN).lte(CONSTANTS.INT8_MAX),
+		tinyint2: z.int().gte(0).lte(CONSTANTS.INT8_UNSIGNED_MAX),
+		varchar1: z.string().max(10),
+		varchar2: z.enum(['a', 'b', 'c']),
+		varbinary: z.string().regex(/^[01]*$/).max(10),
+		year: z.int().gte(1901).lte(2155),
+		longtext1: z.string().max(CONSTANTS.INT32_UNSIGNED_MAX),
+		longtext2: z.enum(['a', 'b', 'c']),
+		mediumtext1: z.string().max(CONSTANTS.INT24_UNSIGNED_MAX),
+		mediumtext2: z.enum(['a', 'b', 'c']),
+		tinytext1: z.string().max(CONSTANTS.INT8_UNSIGNED_MAX),
+		tinytext2: z.enum(['a', 'b', 'c']),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = mysqlTable('test', ({
+		bigint,
+		boolean,
+		timestamp,
+		int,
+		text,
+	}) => ({
+		bigint: bigint({ mode: 'bigint' }).notNull(),
+		boolean: boolean().notNull(),
+		timestamp: timestamp().notNull(),
+		int: int().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		boolean: z.coerce.boolean(),
+		timestamp: z.coerce.date(),
+		int: z.coerce.number().int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		text: z.coerce.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = mysqlTable('test', ({
+		timestamp,
+		int,
+	}) => ({
+		timestamp: timestamp().notNull(),
+		int: int().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		timestamp: z.coerce.date(),
+		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = mysqlTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = mysqlTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = mysqlTable('test', { id: int() });
+	const view = mysqlView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = mysqlView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+}
diff --git a/integration-tests/tests/validators/zod/pg.test.ts b/integration-tests/tests/validators/zod/pg.test.ts
new file mode 100644
index 0000000000..9e914d74be
--- /dev/null
+++ b/integration-tests/tests/validators/zod/pg.test.ts
@@ -0,0 +1,640 @@
+import { type Equal, sql } from 'drizzle-orm';
+import {
+	customType,
+	integer,
+	json,
+	jsonb,
+	pgEnum,
+	pgMaterializedView,
+	pgSchema,
+	pgTable,
+	pgView,
+	serial,
+	text,
+} from 'drizzle-orm/pg-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { bigintStringModeSchema, jsonSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectEnumValues, expectSchemaShape } from './utils';
+
+const integerSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
+const integerNullableSchema = integerSchema.nullable();
+const integerOptionalSchema = integerSchema.optional();
+const integerNullableOptionalSchema = integerSchema.nullable().optional();
+
+const textSchema = z.string();
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = z.any();
+
+const extendedSchema = integerSchema.lte(1000);
+const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = pgTable('test', {
+		id: integer().primaryKey(),
+		generated: integer().generatedAlwaysAsIdentity(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: integerSchema, generated: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = pgSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({ name: textSchema, age: integerNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = pgTable('test', {
+		id: integer().generatedAlwaysAsIdentity().primaryKey(),
+		name: text().notNull(),
+		age: integer(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		name: textOptionalSchema,
+		age: integerNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = pgView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view qb - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgMaterializedView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('materialized view columns - select', (t) => {
+	const view = pgMaterializedView('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: integerSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = pgTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({
+		id: integerSchema,
+		nested: z.object({ name: textSchema, age: anySchema }),
+		table: z.object({ id: integerSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('enum - select', (t) => {
+	const enum_ = pgEnum('test', ['a', 'b', 'c']);
+
+	const result = createSelectSchema(enum_);
+	const expected = z.enum(['a', 'b', 'c']);
+	expectEnumValues(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: integerSchema,
+		c3: integerNullableSchema,
+		c4: integerSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+});
+
+test('nullability - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().default(1),
+		c4: integer().notNull().default(1),
+		c5: integer().generatedAlwaysAs(sql`1`),
+		c6: integer().generatedAlwaysAsIdentity(),
+		c7: integer().generatedByDefaultAsIdentity(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: integerOptionalSchema,
+		c3: integerNullableOptionalSchema,
+		c4: integerOptionalSchema,
+		c7: integerOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ codec: 'text', dataType: () => 'text' });
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer().notNull(),
+		c3: integer().notNull(),
+		c4: integer().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: integerNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = pgTable('test', {
+		c1: integer(),
+		c2: integer(),
+		c3: integer(),
+		c4: integer(),
+		c5: integer(),
+		c6: integer(),
+	});
+	const view = pgView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		nested: {
+			c5: (schema) => schema.lte(1000),
+			c6: z.string().transform(Number),
+		},
+		table: {
+			c2: (schema) => schema.lte(1000),
+			c3: z.string().transform(Number),
+		},
+	});
+	const expected = z.object({
+		c1: integerNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: z.object({
+			c4: integerNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: z.object({
+			c1: integerNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: integerNullableSchema,
+			c5: integerNullableSchema,
+			c6: integerNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = pgTable('test', ({
+		bigint,
+		bigserial,
+		bit,
+		boolean,
+		date,
+		char,
+		cidr,
+		doublePrecision,
+		geometry,
+		halfvec,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		sparsevec,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ mode: 'string' }).notNull(),
+		bigserial1: bigserial({ mode: 'number' }).notNull(),
+		bigserial2: bigserial({ mode: 'bigint' }).notNull(),
+		bit: bit({ dimensions: 5 }).notNull(),
+		boolean: boolean().notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		cidr: cidr().notNull(),
+		doublePrecision: doublePrecision().notNull(),
+		geometry1: geometry({ type: 'point', mode: 'tuple' }).notNull(),
+		geometry2: geometry({ type: 'point', mode: 'xy' }).notNull(),
+		halfvec: halfvec({ dimensions: 3 }).notNull(),
+		inet: inet().notNull(),
+		integer: integer().notNull(),
+		interval: interval().notNull(),
+		json: json().notNull(),
+		jsonb: jsonb().notNull(),
+		line1: line({ mode: 'abc' }).notNull(),
+		line2: line({ mode: 'tuple' }).notNull(),
+		macaddr: macaddr().notNull(),
+		macaddr8: macaddr8().notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		point1: point({ mode: 'xy' }).notNull(),
+		point2: point({ mode: 'tuple' }).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint: smallint().notNull(),
+		smallserial: smallserial().notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		sparsevec: sparsevec({ dimensions: 3 }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		uuid: uuid().notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({ dimensions: 3 }).notNull(),
+		array1: integer().array().notNull(),
+		array2: integer().array('[][]').notNull(),
+		array3: varchar({ length: 10 }).array('[][]').notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bigint3: bigintStringModeSchema,
+		bigserial1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigserial2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bit: z.string().regex(/^[01]*$/).length(5),
+		boolean: z.boolean(),
+		date1: z.date(),
+		date2: z.string(),
+		char1: z.string().max(10),
+		char2: z.enum(['a', 'b', 'c']),
+		cidr: z.string(),
+		doublePrecision: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		geometry1: z.tuple([z.number(), z.number()]),
+		geometry2: z.object({ x: z.number(), y: z.number() }),
+		halfvec: z.array(z.number()).length(3),
+		inet: z.string(),
+		integer: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		interval: z.string(),
+		json: jsonSchema,
+		jsonb: jsonSchema,
+		line1: z.object({ a: z.number(), b: z.number(), c: z.number() }),
+		line2: z.tuple([z.number(), z.number(), z.number()]),
+		macaddr: z.string(),
+		macaddr8: z.string(),
+		numeric1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		numeric2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		numeric3: z.string(),
+		point1: z.object({ x: z.number(), y: z.number() }),
+		point2: z.tuple([z.number(), z.number()]),
+		real: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		serial: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		smallint: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		smallserial: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		text1: z.string(),
+		text2: z.enum(['a', 'b', 'c']),
+		sparsevec: z.string(),
+		time: z.string(),
+		timestamp1: z.date(),
+		timestamp2: z.string(),
+		uuid: z.uuid(),
+		varchar1: z.string().max(10),
+		varchar2: z.enum(['a', 'b', 'c']),
+		vector: z.array(z.number()).length(3),
+		array1: z.array(integerSchema),
+		array2: z.array(z.array(integerSchema)),
+		array3: z.array(z.array(z.string().max(10))),
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = pgTable('test', ({
+		bigint,
+		boolean,
+		timestamp,
+		integer,
+		text,
+	}) => ({
+		bigint: bigint({ mode: 'bigint' }).notNull(),
+		boolean: boolean().notNull(),
+		timestamp: timestamp().notNull(),
+		integer: integer().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		boolean: z.coerce.boolean(),
+		timestamp: z.coerce.date(),
+		integer: z.coerce.number().int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		text: z.coerce.string(),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = pgTable('test', ({
+		timestamp,
+		integer,
+	}) => ({
+		timestamp: timestamp().notNull(),
+		integer: integer().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		timestamp: z.coerce.date(),
+		integer: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		codec: undefined,
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = pgTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = pgTable('test', { id: integer() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = pgTable('test', { id: integer() });
+	const view = pgView('test').as((qb) => qb.select().from(table));
+	const mView = pgMaterializedView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = pgView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = pgView('test', { id: integer() }).as(sql``);
+	const mView = pgView('test', { id: integer() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(mView, { unknown: z.string() });
+}
diff --git a/integration-tests/tests/validators/zod/singlestore.test.ts b/integration-tests/tests/validators/zod/singlestore.test.ts
new file mode 100644
index 0000000000..2d138aea33
--- /dev/null
+++ b/integration-tests/tests/validators/zod/singlestore.test.ts
@@ -0,0 +1,606 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, json, serial, singlestoreSchema, singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { bigintStringModeSchema, jsonSchema, unsignedBigintStringModeSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX);
+const intNullableSchema = intSchema.nullable();
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intNullableSchema.optional();
+
+const serialSchema = z.int().gte(0).lte(Number.MAX_SAFE_INTEGER);
+const serialOptionalSchema = serialSchema.optional();
+
+const textSchema = z.string().max(CONSTANTS.INT16_UNSIGNED_MAX);
+const textOptionalSchema = textSchema.optional();
+
+// const anySchema = z.any();
+
+const extendedSchema = intSchema.lte(1000);
+// const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		generated: int().generatedAlwaysAs(sql`1`).notNull(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: serialSchema, generated: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table in schema - select', (tc) => {
+	const schema = singlestoreSchema('test');
+	const table = schema.table('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: serialSchema, name: textSchema });
+	expectSchemaShape(tc, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		id: serialOptionalSchema,
+		name: textSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = singlestoreTable('test', {
+		id: serial().primaryKey(),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		id: serialOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// TODO: SingleStore doesn't support views yet. Add these tests when they're added
+
+// test('view qb - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+// 	const result = createSelectSchema(view);
+// 	const expected = z.object({ id: serialSchema, age: anySchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view columns - select', (t) => {
+// 	const view = mysqlView('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	}).as(sql``);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = z.object({ id: serialSchema, name: textSchema });
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+// test('view with nested fields - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		id: serial().primaryKey(),
+// 		name: text().notNull(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			id: table.id,
+// 			nested: {
+// 				name: table.name,
+// 				age: sql``.as('age'),
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view);
+// 	const expected = z.object({
+// 		id: serialNumberModeSchema,
+// 		nested: z.object({ name: textSchema, age: anySchema }),
+// 		table: z.object({ id: serialSchema, name: textSchema }),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('nullability - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: customSchema,
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = singlestoreTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+// test('refine view - select', (t) => {
+// 	const table = singlestoreTable('test', {
+// 		c1: int(),
+// 		c2: int(),
+// 		c3: int(),
+// 		c4: int(),
+// 		c5: int(),
+// 		c6: int(),
+// 	});
+// 	const view = mysqlView('test').as((qb) =>
+// 		qb.select({
+// 			c1: table.c1,
+// 			c2: table.c2,
+// 			c3: table.c3,
+// 			nested: {
+// 				c4: table.c4,
+// 				c5: table.c5,
+// 				c6: table.c6,
+// 			},
+// 			table,
+// 		}).from(table)
+// 	);
+
+// 	const result = createSelectSchema(view, {
+// 		c2: (schema) => schema.lte(1000),
+// 		c3: z.string().transform(Number),
+// 		nested: {
+// 			c5: (schema) => schema.lte(1000),
+// 			c6: z.string().transform(Number),
+// 		},
+// 		table: {
+// 			c2: (schema) => schema.lte(1000),
+// 			c3: z.string().transform(Number),
+// 		},
+// 	});
+// 	const expected = z.object({
+// 		c1: intNullableSchema,
+// 		c2: extendedNullableSchema,
+// 		c3: customSchema,
+// 		nested: z.object({
+// 			c4: intNullableSchema,
+// 			c5: extendedNullableSchema,,
+// 			c6: customSchema,
+// 		}),
+// 		table: z.object({
+// 			c1: intNullableSchema,
+// 			c2: extendedNullableSchema,,
+// 			c3: customSchema,
+// 			c4: intNullableSchema,
+// 			c5: intNullableSchema,
+// 			c6: intNullableSchema,
+// 		}),
+// 	});
+// 	expectSchemaShape(t, expected).from(result);
+// 	Expect<Equal<typeof result, typeof expected>>();
+// });
+
+test('all data types', (t) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		binary,
+		boolean,
+		char,
+		date,
+		datetime,
+		decimal,
+		double,
+		float,
+		int,
+		json,
+		mediumint,
+		singlestoreEnum,
+		real,
+		serial,
+		smallint,
+		text,
+		time,
+		timestamp,
+		tinyint,
+		varchar,
+		varbinary,
+		year,
+		longtext,
+		mediumtext,
+		tinytext,
+		vector,
+	}) => ({
+		bigint1: bigint({ mode: 'number' }).notNull(),
+		bigint2: bigint({ mode: 'bigint' }).notNull(),
+		bigint3: bigint({ unsigned: true, mode: 'number' }).notNull(),
+		bigint4: bigint({ unsigned: true, mode: 'bigint' }).notNull(),
+		bigint5: bigint({ mode: 'string' }).notNull(),
+		bigint6: bigint({ unsigned: true, mode: 'string' }).notNull(),
+		binary: binary({ length: 10 }).notNull(),
+		boolean: boolean().notNull(),
+		char1: char({ length: 10 }).notNull(),
+		char2: char({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		date1: date({ mode: 'date' }).notNull(),
+		date2: date({ mode: 'string' }).notNull(),
+		datetime1: datetime({ mode: 'date' }).notNull(),
+		datetime2: datetime({ mode: 'string' }).notNull(),
+		decimal1: decimal({ mode: 'number' }).notNull(),
+		decimal2: decimal({ mode: 'number', unsigned: true }).notNull(),
+		decimal3: decimal({ mode: 'bigint' }).notNull(),
+		decimal4: decimal({ mode: 'bigint', unsigned: true }).notNull(),
+		decimal5: decimal({ mode: 'string' }).notNull(),
+		decimal6: decimal({ mode: 'string', unsigned: true }).notNull(),
+		double1: double().notNull(),
+		double2: double({ unsigned: true }).notNull(),
+		float1: float().notNull(),
+		float2: float({ unsigned: true }).notNull(),
+		int1: int().notNull(),
+		int2: int({ unsigned: true }).notNull(),
+		json: json().notNull(),
+		mediumint1: mediumint().notNull(),
+		mediumint2: mediumint({ unsigned: true }).notNull(),
+		enum: singlestoreEnum('enum', ['a', 'b', 'c']).notNull(),
+		real: real().notNull(),
+		serial: serial().notNull(),
+		smallint1: smallint().notNull(),
+		smallint2: smallint({ unsigned: true }).notNull(),
+		text1: text().notNull(),
+		text2: text({ enum: ['a', 'b', 'c'] }).notNull(),
+		time: time().notNull(),
+		timestamp1: timestamp({ mode: 'date' }).notNull(),
+		timestamp2: timestamp({ mode: 'string' }).notNull(),
+		tinyint1: tinyint().notNull(),
+		tinyint2: tinyint({ unsigned: true }).notNull(),
+		varchar1: varchar({ length: 10 }).notNull(),
+		varchar2: varchar({ length: 1, enum: ['a', 'b', 'c'] }).notNull(),
+		varbinary: varbinary({ length: 10 }).notNull(),
+		year: year().notNull(),
+		longtext1: longtext().notNull(),
+		longtext2: longtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		mediumtext1: mediumtext().notNull(),
+		mediumtext2: mediumtext({ enum: ['a', 'b', 'c'] }).notNull(),
+		tinytext1: tinytext().notNull(),
+		tinytext2: tinytext({ enum: ['a', 'b', 'c'] }).notNull(),
+		vector: vector({
+			dimensions: 3,
+			elementType: 'F32',
+		}).notNull(),
+		vector2: vector({
+			dimensions: 2,
+			elementType: 'I64',
+		}).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		bigint2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		bigint3: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		bigint4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
+		bigint5: bigintStringModeSchema,
+		bigint6: unsignedBigintStringModeSchema,
+		binary: z.string().regex(/^[01]*$/).max(10),
+		boolean: z.boolean(),
+		char1: z.string().max(10),
+		char2: z.enum(['a', 'b', 'c']),
+		date1: z.date(),
+		date2: z.string(),
+		datetime1: z.date(),
+		datetime2: z.string(),
+		decimal1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		decimal2: z.number().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		decimal3: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		decimal4: z.bigint().gte(0n).lte(CONSTANTS.INT64_UNSIGNED_MAX),
+		decimal5: z.string(),
+		decimal6: z.string(),
+		double1: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		double2: z.number().gte(0).lte(CONSTANTS.INT48_UNSIGNED_MAX),
+		float1: z.number().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		float2: z.number().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
+		int1: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		int2: z.int().gte(0).lte(CONSTANTS.INT32_UNSIGNED_MAX),
+		json: jsonSchema,
+		mediumint1: z.int().gte(CONSTANTS.INT24_MIN).lte(CONSTANTS.INT24_MAX),
+		mediumint2: z.int().gte(0).lte(CONSTANTS.INT24_UNSIGNED_MAX),
+		enum: z.enum(['a', 'b', 'c']),
+		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		serial: z.int().gte(0).lte(Number.MAX_SAFE_INTEGER),
+		smallint1: z.int().gte(CONSTANTS.INT16_MIN).lte(CONSTANTS.INT16_MAX),
+		smallint2: z.int().gte(0).lte(CONSTANTS.INT16_UNSIGNED_MAX),
+		text1: z.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
+		text2: z.enum(['a', 'b', 'c']),
+		time: z.string(),
+		timestamp1: z.date(),
+		timestamp2: z.string(),
+		tinyint1: z.int().gte(CONSTANTS.INT8_MIN).lte(CONSTANTS.INT8_MAX),
+		tinyint2: z.int().gte(0).lte(CONSTANTS.INT8_UNSIGNED_MAX),
+		varchar1: z.string().max(10),
+		varchar2: z.enum(['a', 'b', 'c']),
+		varbinary: z.string().regex(/^[01]*$/).max(10),
+		year: z.int().gte(1901).lte(2155),
+		longtext1: z.string().max(CONSTANTS.INT32_UNSIGNED_MAX),
+		longtext2: z.enum(['a', 'b', 'c']),
+		mediumtext1: z.string().max(CONSTANTS.INT24_UNSIGNED_MAX),
+		mediumtext2: z.enum(['a', 'b', 'c']),
+		tinytext1: z.string().max(CONSTANTS.INT8_UNSIGNED_MAX),
+		tinytext2: z.enum(['a', 'b', 'c']),
+		vector: z.array(z.number()).length(3),
+		vector2: z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX)).length(2),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = singlestoreTable('test', ({
+		bigint,
+		boolean,
+		timestamp,
+		int,
+		text,
+	}) => ({
+		bigint: bigint({ mode: 'bigint' }).notNull(),
+		boolean: boolean().notNull(),
+		timestamp: timestamp().notNull(),
+		int: int().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		bigint: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		boolean: z.coerce.boolean(),
+		timestamp: z.coerce.date(),
+		int: z.coerce.number().int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+		text: z.coerce.string().max(CONSTANTS.INT16_UNSIGNED_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = singlestoreTable('test', ({
+		timestamp,
+		int,
+	}) => ({
+		timestamp: timestamp().notNull(),
+		int: int().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		timestamp: z.coerce.date(),
+		int: z.int().gte(CONSTANTS.INT32_MIN).lte(CONSTANTS.INT32_MAX),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = singlestoreTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = singlestoreTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+// /* Disallow unknown keys in view qb - select */ {
+// 	const table = singlestoreTable('test', { id: int() });
+// 	const view = mysqlView('test').as((qb) => qb.select().from(table));
+// 	const nestedSelect = mysqlView('test').as((qb) => qb.select({ table }).from(table));
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: z.string() });
+// 	// @ts-expect-error
+// 	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+// }
+
+// /* Disallow unknown keys in view columns - select */ {
+// 	const view = mysqlView('test', { id: int() }).as(sql``);
+// 	// @ts-expect-error
+// 	createSelectSchema(view, { unknown: z.string() });
+// }
diff --git a/integration-tests/tests/validators/zod/sqlite.test.ts b/integration-tests/tests/validators/zod/sqlite.test.ts
new file mode 100644
index 0000000000..8766a28250
--- /dev/null
+++ b/integration-tests/tests/validators/zod/sqlite.test.ts
@@ -0,0 +1,476 @@
+import { type Equal, sql } from 'drizzle-orm';
+import { customType, int, sqliteTable, sqliteView, text } from 'drizzle-orm/sqlite-core';
+import { CONSTANTS } from 'drizzle-orm/utils';
+import { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from 'drizzle-orm/zod';
+import { bufferSchema, jsonSchema } from 'drizzle-orm/zod/column';
+import type { TopLevelCondition } from 'json-rules-engine';
+import { test } from 'vitest';
+import { z } from 'zod/v4';
+import { Expect, expectSchemaShape } from './utils';
+
+const intSchema = z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER);
+const intNullableSchema = intSchema.nullable();
+const intOptionalSchema = intSchema.optional();
+const intNullableOptionalSchema = intSchema.nullable().optional();
+
+const textSchema = z.string();
+const textOptionalSchema = textSchema.optional();
+
+const anySchema = z.any();
+
+const extendedSchema = intSchema.lte(1000);
+const extendedNullableSchema = extendedSchema.nullable();
+const extendedOptionalSchema = extendedSchema.optional();
+
+const customSchema = z.string().transform(Number);
+
+test('table - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		generated: int().generatedAlwaysAs(sql`1`).notNull(),
+		name: text().notNull(),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({ id: intSchema, generated: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - insert', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({ id: intOptionalSchema, name: textSchema, age: intNullableOptionalSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('table - update', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+		age: int(),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		id: intOptionalSchema,
+		name: textOptionalSchema,
+		age: intNullableOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view qb - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) => qb.select({ id: table.id, age: sql``.as('age') }).from(table));
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: intSchema, age: anySchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view columns - select', (t) => {
+	const view = sqliteView('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	}).as(sql``);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({ id: intSchema, name: textSchema });
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('view with nested fields - select', (t) => {
+	const table = sqliteTable('test', {
+		id: int().primaryKey({ autoIncrement: true }),
+		name: text().notNull(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			id: table.id,
+			nested: {
+				name: table.name,
+				age: sql``.as('age'),
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view);
+	const expected = z.object({
+		id: intSchema,
+		nested: z.object({ name: textSchema, age: anySchema }),
+		table: z.object({ id: intSchema, name: textSchema }),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+	});
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: intSchema,
+		c3: intNullableSchema,
+		c4: intSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('nullability - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().default(1),
+		c4: int().notNull().default(1),
+		c5: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table);
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: intOptionalSchema,
+		c3: intNullableOptionalSchema,
+		c4: intOptionalSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+	});
+
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - select with custom data type', (t) => {
+	const customText = customType({ dataType: () => 'text' });
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: customText(),
+	});
+
+	const customTextSchema = z.string().min(1).max(100);
+	const result = createSelectSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		c4: customTextSchema,
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+		c4: customTextSchema,
+	});
+
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - insert', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createInsertSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine table - update', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int().notNull(),
+		c3: int().notNull(),
+		c4: int().generatedAlwaysAs(sql`1`),
+	});
+
+	const result = createUpdateSchema(table, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+	});
+	const expected = z.object({
+		c1: intNullableOptionalSchema,
+		c2: extendedOptionalSchema,
+		c3: customSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('refine view - select', (t) => {
+	const table = sqliteTable('test', {
+		c1: int(),
+		c2: int(),
+		c3: int(),
+		c4: int(),
+		c5: int(),
+		c6: int(),
+	});
+	const view = sqliteView('test').as((qb) =>
+		qb.select({
+			c1: table.c1,
+			c2: table.c2,
+			c3: table.c3,
+			nested: {
+				c4: table.c4,
+				c5: table.c5,
+				c6: table.c6,
+			},
+			table,
+		}).from(table)
+	);
+
+	const result = createSelectSchema(view, {
+		c2: (schema) => schema.lte(1000),
+		c3: z.string().transform(Number),
+		nested: {
+			c5: (schema) => schema.lte(1000),
+			c6: z.string().transform(Number),
+		},
+		table: {
+			c2: (schema) => schema.lte(1000),
+			c3: z.string().transform(Number),
+		},
+	});
+	const expected = z.object({
+		c1: intNullableSchema,
+		c2: extendedNullableSchema,
+		c3: customSchema,
+		nested: z.object({
+			c4: intNullableSchema,
+			c5: extendedNullableSchema,
+			c6: customSchema,
+		}),
+		table: z.object({
+			c1: intNullableSchema,
+			c2: extendedNullableSchema,
+			c3: customSchema,
+			c4: intNullableSchema,
+			c5: intNullableSchema,
+			c6: intNullableSchema,
+		}),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('all data types', (t) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		numeric,
+		real,
+		text,
+	}) => ({
+		blob1: blob({ mode: 'buffer' }).notNull(),
+		blob2: blob({ mode: 'bigint' }).notNull(),
+		blob3: blob({ mode: 'json' }).notNull(),
+		integer1: integer({ mode: 'number' }).notNull(),
+		integer2: integer({ mode: 'boolean' }).notNull(),
+		integer3: integer({ mode: 'timestamp' }).notNull(),
+		integer4: integer({ mode: 'timestamp_ms' }).notNull(),
+		numeric1: numeric({ mode: 'number' }).notNull(),
+		numeric2: numeric({ mode: 'bigint' }).notNull(),
+		numeric3: numeric({ mode: 'string' }).notNull(),
+		real: real().notNull(),
+		text1: text({ mode: 'text' }).notNull(),
+		text2: text({ mode: 'text', length: 10 }).notNull(),
+		text3: text({ mode: 'text', enum: ['a', 'b', 'c'] }).notNull(),
+		text4: text({ mode: 'json' }).notNull(),
+	}));
+
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		blob1: bufferSchema,
+		blob2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		blob3: jsonSchema,
+		integer1: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		integer2: z.boolean(),
+		integer3: z.date(),
+		integer4: z.date(),
+		numeric1: z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		numeric2: z.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		numeric3: z.string(),
+		real: z.number().gte(CONSTANTS.INT48_MIN).lte(CONSTANTS.INT48_MAX),
+		text1: z.string(),
+		text2: z.string().max(10),
+		text3: z.enum(['a', 'b', 'c']),
+		text4: jsonSchema,
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - all', (t) => {
+	const table = sqliteTable('test', ({
+		blob,
+		integer,
+		text,
+	}) => ({
+		blob: blob({ mode: 'bigint' }).notNull(),
+		integer1: integer({ mode: 'boolean' }).notNull(),
+		integer2: integer({ mode: 'timestamp' }).notNull(),
+		integer3: integer().notNull(),
+		text: text().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: true,
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		blob: z.coerce.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX),
+		integer1: z.coerce.boolean(),
+		integer2: z.coerce.date(),
+		integer3: z.coerce.number().int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+		text: z.coerce.string(),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+test('type coercion - mixed', (t) => {
+	const table = sqliteTable('test', ({
+		integer,
+	}) => ({
+		integer1: integer({ mode: 'timestamp' }).notNull(),
+		integer2: integer().notNull(),
+	}));
+
+	const { createSelectSchema } = createSchemaFactory({
+		coerce: {
+			date: true,
+		},
+	});
+	const result = createSelectSchema(table);
+	const expected = z.object({
+		integer1: z.coerce.date(),
+		integer2: z.int().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER),
+	});
+	expectSchemaShape(t, expected).from(result);
+	Expect<Equal<typeof result, typeof expected>>();
+});
+
+/* Infinitely recursive type */ {
+	const TopLevelCondition: z.ZodType<TopLevelCondition> = z.custom<TopLevelCondition>().superRefine(() => {});
+
+	const column = customType<{
+		data: TopLevelCondition;
+	}>({
+		dataType: () => 'object TopLevelCondition',
+	});
+	const table = sqliteTable('test', {
+		tlc: column('tlc'),
+	});
+
+	const result = createSelectSchema(table, {
+		tlc: TopLevelCondition,
+	});
+	const expected = z.object({
+		tlc: TopLevelCondition,
+	});
+
+	Expect<Equal<z.infer<typeof result>, z.infer<typeof expected>>>();
+}
+
+/* Disallow unknown keys in table refinement - select */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createSelectSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - insert */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createInsertSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in table refinement - update */ {
+	const table = sqliteTable('test', { id: int() });
+	// @ts-expect-error
+	createUpdateSchema(table, { unknown: z.string() });
+}
+
+/* Disallow unknown keys in view qb - select */ {
+	const table = sqliteTable('test', { id: int() });
+	const view = sqliteView('test').as((qb) => qb.select().from(table));
+	const nestedSelect = sqliteView('test').as((qb) => qb.select({ table }).from(table));
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+	// @ts-expect-error
+	createSelectSchema(nestedSelect, { table: { unknown: z.string() } });
+}
+
+/* Disallow unknown keys in view columns - select */ {
+	const view = sqliteView('test', { id: int() }).as(sql``);
+	// @ts-expect-error
+	createSelectSchema(view, { unknown: z.string() });
+}
diff --git a/integration-tests/tests/validators/zod/utils.ts b/integration-tests/tests/validators/zod/utils.ts
new file mode 100644
index 0000000000..ce3ab61830
--- /dev/null
+++ b/integration-tests/tests/validators/zod/utils.ts
@@ -0,0 +1,36 @@
+import { expect, type TestContext } from 'vitest';
+import type { z } from 'zod/v4';
+import type { $ZodEnumDef } from 'zod/v4/core';
+
+export function expectSchemaShape<T extends z.ZodObject<z.ZodRawShape>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(Object.keys(actual.shape)).toStrictEqual(Object.keys(expected.shape));
+
+			for (const key of Object.keys(actual.shape)) {
+				const actualDef = actual.shape[key]?._zod.def;
+				const expectedDef = expected.shape[key]?._zod.def;
+
+				expect({
+					key,
+					type: actualDef?.type,
+					checks: actualDef?.checks?.map((check) => check._zod.def),
+				}).toStrictEqual({
+					key,
+					type: expectedDef?.type,
+					checks: expectedDef?.checks?.map((check) => check._zod.def),
+				});
+			}
+		},
+	};
+}
+
+export function expectEnumValues<T extends z.ZodEnum<any>>(t: TestContext, expected: T) {
+	return {
+		from(actual: T) {
+			expect(actual.def).toStrictEqual(expected.def as $ZodEnumDef<any>);
+		},
+	};
+}
+
+export function Expect<_ extends true>() {}
diff --git a/integration-tests/tsconfig.json b/integration-tests/tsconfig.json
index 38541f8e26..a431e423f2 100644
--- a/integration-tests/tsconfig.json
+++ b/integration-tests/tsconfig.json
@@ -8,5 +8,5 @@
 		}
 	},
 	"include": ["tests", "type-tests"],
-	"exclude": ["**/playground", "**/.sst", "tests/prisma/*/client/**/*.js"]
+	"exclude": ["**/playground", "**/.sst", "tests/prisma/*/client/**/*.js", "tests/mysql/instrumentation.ts"]
 }
diff --git a/integration-tests/type-tests-no-strict-null-checks/cockroach.ts b/integration-tests/type-tests-no-strict-null-checks/cockroach.ts
new file mode 100644
index 0000000000..4f6b628fa2
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/cockroach.ts
@@ -0,0 +1,131 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/cockroach';
+import { cockroachTable, int4, text } from 'drizzle-orm/cockroach-core';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = cockroachTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		intId: int4('int_id')
+			.primaryKey()
+			.generatedAlwaysAsIdentity(),
+		int2Id: int4('int2_id').generatedByDefaultAsIdentity(),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+const db = drizzle.mock();
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		intId: number;
+		int2Id: number;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		int2Id?: number;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		id: '1',
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		intId: 1,
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		int2Id: 1,
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.insert(test).values({
+	// @ts-expect-error
+	id: '1',
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	// @ts-expect-error
+	intId: 1,
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	int2Id: 1,
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
diff --git a/integration-tests/type-tests-no-strict-null-checks/mssql.ts b/integration-tests/type-tests-no-strict-null-checks/mssql.ts
new file mode 100644
index 0000000000..ce3197e34f
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/mssql.ts
@@ -0,0 +1,88 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { mssqlTable, text } from 'drizzle-orm/mssql-core';
+import { drizzle } from 'drizzle-orm/node-mssql';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = mssqlTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+const db = drizzle.mock();
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		id: '1',
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.insert(test).values({
+	// @ts-expect-error
+	id: '1',
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
diff --git a/integration-tests/type-tests-no-strict-null-checks/mysql.ts b/integration-tests/type-tests-no-strict-null-checks/mysql.ts
new file mode 100644
index 0000000000..0bd2ba3d56
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/mysql.ts
@@ -0,0 +1,88 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { mysqlTable, text } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = mysqlTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+const db = drizzle.mock();
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		id: '1',
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.insert(test).values({
+	// @ts-expect-error
+	id: '1',
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
diff --git a/integration-tests/type-tests-no-strict-null-checks/pg.ts b/integration-tests/type-tests-no-strict-null-checks/pg.ts
new file mode 100644
index 0000000000..2fc1ddc472
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/pg.ts
@@ -0,0 +1,172 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { integer, pgTable, text } from 'drizzle-orm/pg-core';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = pgTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		intId: integer('int_id')
+			.primaryKey()
+			.generatedAlwaysAsIdentity(),
+		int2Id: integer('int2_id').generatedByDefaultAsIdentity(),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		intId: number;
+		int2Id: number;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		int2Id?: number;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+const db = drizzle.mock();
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		id: '1',
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		intId: 1,
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		int2Id: 1,
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.insert(test).values({
+	// @ts-expect-error
+	id: '1',
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	// @ts-expect-error
+	intId: 1,
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	int2Id: 1,
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
+
+// Dialect-agnostic test - do not duplicate
+{
+	const res = await db.select({
+		preNull: sql<number | null>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).as('sq1'),
+		postNull: sql<number>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).nullable().as('sq2'),
+		prePostNull: sql<number | null>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, number>>;
+			return String(v);
+		}).nullable().as('sq3'),
+		default: sql`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, unknown>>;
+			return String(v);
+		}).as('sq4'),
+		unknown: sql<unknown>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, unknown>>;
+			return String(v);
+		}).as('sq5'),
+		any: sql<any>`somequery`.mapWith((v) => {
+			Expect<Equal<typeof v, any>>;
+			return String(v);
+		}).as('sq6'),
+	}).from(test);
+
+	Expect<
+		Equal<typeof res, {
+			preNull: string | null;
+			postNull: string | null;
+			prePostNull: string | null;
+			default: string;
+			unknown: string;
+			any: string;
+		}[]>
+	>;
+}
diff --git a/integration-tests/type-tests-no-strict-null-checks/singlestore.ts b/integration-tests/type-tests-no-strict-null-checks/singlestore.ts
new file mode 100644
index 0000000000..acb1dd9932
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/singlestore.ts
@@ -0,0 +1,90 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/singlestore';
+import { singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = singlestoreTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+const db = drizzle.mock();
+
+// Enable after `.generatedAlwaysAs()` is implemented
+// db.update(test)
+// 	.set({
+// 		// @ts-expect-error
+// 		id: '1',
+// 		name: 'name',
+// 		title: 'title',
+// 		description: 'desc',
+// 		dbdef: 'upddef',
+// 	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+// Enable after `.generatedAlwaysAs()` is implemented
+// db.insert(test).values({
+// 	// @ts-expect-error
+// 	id: '1',
+// 	name: 'name',
+// 	title: 'title',
+// 	description: 'desc',
+// 	dbdef: 'upddef',
+// });
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
diff --git a/integration-tests/type-tests-no-strict-null-checks/sqlite.ts b/integration-tests/type-tests-no-strict-null-checks/sqlite.ts
new file mode 100644
index 0000000000..563823e12b
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/sqlite.ts
@@ -0,0 +1,88 @@
+// oxlint-disable no-unused-expressions
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { type Equal, Expect } from './utils.ts';
+
+export const test = sqliteTable(
+	'test',
+	{
+		id: text('id')
+			.primaryKey()
+			.generatedAlwaysAs(sql`'genstr'`),
+		name: text('name').$defaultFn(() => '' as string),
+		title: text('title').notNull(),
+		description: text('description'),
+		dbdef: text('dbdef').default('dbdefval'),
+	},
+);
+
+Expect<
+	Equal<typeof test['$inferSelect'], {
+		id: string;
+		name: string;
+		title: string;
+		description: string;
+		dbdef: string;
+	}>
+>;
+
+Expect<
+	Equal<typeof test['$inferInsert'], {
+		title: string;
+		name?: string;
+		description?: string;
+		dbdef?: string;
+	}>
+>;
+
+const db = drizzle.mock();
+
+db.update(test)
+	.set({
+		// @ts-expect-error
+		id: '1',
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.update(test)
+	.set({
+		name: 'name',
+		title: 'title',
+		description: 'desc',
+		dbdef: 'upddef',
+	});
+
+db.insert(test).values({
+	// @ts-expect-error
+	id: '1',
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	name: 'name',
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+	dbdef: 'upddef',
+});
+
+db.insert(test).values({
+	title: 'title',
+	description: 'desc',
+});
+
+db.insert(test).values({
+	title: 'title',
+});
diff --git a/integration-tests/type-tests-no-strict-null-checks/tsconfig.json b/integration-tests/type-tests-no-strict-null-checks/tsconfig.json
new file mode 100644
index 0000000000..6b472a2887
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/tsconfig.json
@@ -0,0 +1,20 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"strictNullChecks": false,
+		"strictPropertyInitialization": false,
+		"exactOptionalPropertyTypes": false,
+		"useDefineForClassFields": true,
+		"module": "nodenext",
+		"target": "es2022",
+		"moduleResolution": "node16",
+		"skipLibCheck": true,
+		"allowImportingTsExtensions": true,
+		"moduleDetection": "force",
+		"strict": false,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"include": ["./*.ts"]
+}
diff --git a/integration-tests/type-tests-no-strict-null-checks/utils.ts b/integration-tests/type-tests-no-strict-null-checks/utils.ts
new file mode 100644
index 0000000000..51b56d3816
--- /dev/null
+++ b/integration-tests/type-tests-no-strict-null-checks/utils.ts
@@ -0,0 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+export function Expect<T extends true>() {}
+
+export type Equal<X, Y extends X> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true
+	: false;
diff --git a/integration-tests/type-tests/join-nodenext/mysql.ts b/integration-tests/type-tests/join-nodenext/mysql.ts
new file mode 100644
index 0000000000..3224cd8306
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/mysql.ts
@@ -0,0 +1,39 @@
+import { eq } from 'drizzle-orm';
+import { mysqlTable, text } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { expectTypeOf } from 'vitest';
+
+const account = mysqlTable('accounts', {
+	id: text('id').primaryKey().notNull(),
+	userId: text('user_id')
+		.notNull()
+		.references(() => users.id),
+	meta: text().notNull(),
+});
+
+const users = mysqlTable('users', {
+	id: text('id').primaryKey(),
+	name: text('name').notNull(),
+	username: text('username').notNull().unique(),
+});
+
+const db = drizzle.mock();
+
+(async () => {
+	const res = await db.select()
+		.from(users)
+		.innerJoin(account, eq(users.id, account.id));
+
+	expectTypeOf(res).toEqualTypeOf<{
+		accounts: {
+			id: string;
+			userId: string;
+			meta: string;
+		};
+		users: {
+			id: string;
+			name: string;
+			username: string;
+		};
+	}[]>();
+});
diff --git a/integration-tests/type-tests/join-nodenext/package.json b/integration-tests/type-tests/join-nodenext/package.json
new file mode 100644
index 0000000000..a0df0c8677
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/package.json
@@ -0,0 +1,3 @@
+{
+	"type": "commonjs"
+}
diff --git a/integration-tests/type-tests/join-nodenext/pg.ts b/integration-tests/type-tests/join-nodenext/pg.ts
new file mode 100644
index 0000000000..e3209e2e5a
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/pg.ts
@@ -0,0 +1,39 @@
+import { eq } from 'drizzle-orm';
+import { pgTable, text, uuid } from 'drizzle-orm/pg-core';
+import { drizzle } from 'drizzle-orm/pglite';
+import { expectTypeOf } from 'vitest';
+
+const account = pgTable('accounts', {
+	id: uuid('id').primaryKey().notNull(),
+	userId: uuid('user_id')
+		.notNull()
+		.references(() => users.id),
+	meta: text().notNull(),
+});
+
+const users = pgTable('users', {
+	id: uuid('id').primaryKey(),
+	name: text('name').notNull(),
+	username: text('username').notNull().unique(),
+});
+
+const db = drizzle.mock();
+
+(async () => {
+	const res = await db.select()
+		.from(users)
+		.innerJoin(account, eq(users.id, account.id));
+
+	expectTypeOf(res).toEqualTypeOf<{
+		accounts: {
+			id: string;
+			userId: string;
+			meta: string;
+		};
+		users: {
+			id: string;
+			name: string;
+			username: string;
+		};
+	}[]>();
+});
diff --git a/integration-tests/type-tests/join-nodenext/singlestore.ts b/integration-tests/type-tests/join-nodenext/singlestore.ts
new file mode 100644
index 0000000000..8ac5449ec7
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/singlestore.ts
@@ -0,0 +1,38 @@
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/singlestore';
+import { singlestoreTable, text } from 'drizzle-orm/singlestore-core';
+import { expectTypeOf } from 'vitest';
+
+const account = singlestoreTable('accounts', {
+	id: text('id').primaryKey().notNull(),
+	userId: text('user_id')
+		.notNull(),
+	meta: text().notNull(),
+});
+
+const users = singlestoreTable('users', {
+	id: text('id').primaryKey(),
+	name: text('name').notNull(),
+	username: text('username').notNull().unique(),
+});
+
+const db = drizzle.mock();
+
+(async () => {
+	const res = await db.select()
+		.from(users)
+		.innerJoin(account, eq(users.id, account.id));
+
+	expectTypeOf(res).toEqualTypeOf<{
+		accounts: {
+			id: string;
+			userId: string;
+			meta: string;
+		};
+		users: {
+			id: string;
+			name: string;
+			username: string;
+		};
+	}[]>();
+});
diff --git a/integration-tests/type-tests/join-nodenext/sqlite.ts b/integration-tests/type-tests/join-nodenext/sqlite.ts
new file mode 100644
index 0000000000..265600aea6
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/sqlite.ts
@@ -0,0 +1,39 @@
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/libsql';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { expectTypeOf } from 'vitest';
+
+const account = sqliteTable('accounts', {
+	id: text('id').primaryKey().notNull(),
+	userId: text('user_id')
+		.notNull()
+		.references(() => users.id),
+	meta: text().notNull(),
+});
+
+const users = sqliteTable('users', {
+	id: text('id').primaryKey(),
+	name: text('name').notNull(),
+	username: text('username').notNull().unique(),
+});
+
+const db = drizzle.mock();
+
+(async () => {
+	const res = await db.select()
+		.from(users)
+		.innerJoin(account, eq(users.id, account.id));
+
+	expectTypeOf(res).toEqualTypeOf<{
+		accounts: {
+			id: string;
+			userId: string;
+			meta: string;
+		};
+		users: {
+			id: string;
+			name: string;
+			username: string;
+		};
+	}[]>();
+});
diff --git a/integration-tests/type-tests/join-nodenext/tsconfig.json b/integration-tests/type-tests/join-nodenext/tsconfig.json
new file mode 100644
index 0000000000..546c7c0d90
--- /dev/null
+++ b/integration-tests/type-tests/join-nodenext/tsconfig.json
@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"useDefineForClassFields": true,
+		"module": "nodenext",
+		"target": "es2022",
+		"moduleResolution": "node16",
+		"skipLibCheck": true,
+		"allowImportingTsExtensions": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"noEmit": true,
+	"include": ["./*.ts"]
+}
diff --git a/integration-tests/vitest-ci.config.ts b/integration-tests/vitest-ci.config.ts
index 8f6ecf4af3..5e2dfc8d84 100644
--- a/integration-tests/vitest-ci.config.ts
+++ b/integration-tests/vitest-ci.config.ts
@@ -1,5 +1,6 @@
-import 'dotenv/config';
+import 'dotenv/config.js';
 import tsconfigPaths from 'vite-tsconfig-paths';
+// oxlint-disable-next-line extensions
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index 3751e53e35..9f80dc8a2a 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -1,38 +1,35 @@
-import 'dotenv/config';
+import 'dotenv/config.js';
 import tsconfigPaths from 'vite-tsconfig-paths';
+// oxlint-disable-next-line extensions
 import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
 	test: {
 		include: [
-			'tests/seeder/**/*.test.ts',
-			'tests/extensions/postgis/**/*',
-			'tests/relational/**/*.test.ts',
-			'tests/pg/**/*.test.ts',
-			'tests/mysql/**/*.test.ts',
-			'tests/singlestore/**/*.test.ts',
-			'tests/sqlite/**/*.test.ts',
-			'tests/replicas/**/*',
-			'tests/imports/**/*',
-			'tests/extensions/vectors/**/*',
-			'tests/version.test.ts',
-			'tests/pg/node-postgres.test.ts',
-			'tests/utils/is-config.test.ts',
-			'js-tests/driver-init/commonjs/*.test.cjs',
-			'js-tests/driver-init/module/*.test.mjs',
-			'tests/gel/**/*.test.ts',
+			'tests/**/*.test.ts',
+			'js-tests',
 		],
 		exclude: [
-			...(process.env.SKIP_EXTERNAL_DB_TESTS
+			'tests/singlestore/**/*.test.ts',
+			...(process.env['SKIP_EXTERNAL_DB_TESTS']
 				? [
 					'tests/relational/mysql.planetscale.test.ts',
+					'tests/relational/mysql.planetscale-v1.test.ts',
 					'tests/pg/neon-serverless.test.ts',
+					'tests/pg/netlify-db.test.ts',
 					'tests/mysql/tidb-serverless.test.ts',
 					'tests/mysql/mysql-planetscale.test.ts',
 					'tests/sqlite/libsql.test.ts',
+					'tests/sqlite/libsql-http.test.ts',
+					'tests/sqlite/libsql-node.test.ts',
+					'tests/sqlite/libsql-sqlite3.test.ts',
+					'tests/sqlite/libsql-ws.test.ts',
 					'tests/sqlite/libsql-batch.test.ts',
+					'tests/sqlite/tursodatabase-serverless.test.ts',
 					'tests/pg/neon-http.test.ts',
 					'tests/pg/neon-http-batch.test.ts',
+					'tests/pg/netlify-db.test.ts',
+					'tests/sqlite/sqlite-cloud.test.ts',
 					'tests/utils/is-config.test.ts', // Uses external DBs in some cases
 					'js-tests/driver-init/commonjs/neon-http.test.cjs',
 					'js-tests/driver-init/commonjs/neon-ws.test.cjs',
@@ -48,20 +45,16 @@ export default defineConfig({
 				: []),
 			'tests/pg/awsdatapi.test.ts',
 			'tests/awsdatapi.alltypes.test.ts',
-			'tests/pg/vercel-pg.test.ts',
 			'tests/relational/vercel.test.ts',
+			'tests/relational/vercel-v1.test.ts',
 			// Have a strange "invalid SQL: ERROR: must be owner of schema public" error. Will need to check with xata team
 			'tests/pg/xata-http.test.ts',
-			'tests/pg/neon-http-batch.ts',
 			// todo: remove
 			'js-tests/driver-init/module/vercel.test.mjs',
 			'js-tests/driver-init/commonjs/vercel.test.cjs',
 			// move back after decide on speed
 			'tests/sqlite/libsql-ws.test.ts',
 			'tests/sqlite/libsql-http.test.ts',
-			'tests/mysql/tidb-serverless.test.ts',
-			// waiting for json_array from singlestore team
-			'tests/relational/singlestore.test.ts',
 			'js-tests/driver-init/module/planetscale.test.mjs',
 			'js-tests/driver-init/module/planetscale.test.cjs',
 			'js-tests/driver-init/commonjs/planetscale.test.cjs',
@@ -69,15 +62,8 @@ export default defineConfig({
 		typecheck: {
 			tsconfig: 'tsconfig.json',
 		},
-		testTimeout: 100000,
-		hookTimeout: 200000,
-		isolate: true,
-		poolOptions: {
-			threads: {
-				singleThread: true,
-			},
-		},
-		maxWorkers: 1,
+		testTimeout: 120000,
+		hookTimeout: 60000,
 		fileParallelism: false,
 	},
 	plugins: [tsconfigPaths()],
diff --git a/package.json b/package.json
index 613156573d..99e35e6cc8 100755
--- a/package.json
+++ b/package.json
@@ -1,43 +1,59 @@
 {
 	"name": "drizzle-root",
 	"private": true,
+	"type": "module",
 	"scripts": {
+		"postinstall": "pnpm husky",
 		"build:orm": "turbo run build --filter drizzle-orm --color",
 		"build": "turbo run build test:types //#lint --color",
+		"build:artifact": "turbo run build:artifact --color",
 		"b": "pnpm build",
 		"pack": "turbo run pack --color",
+		"pack:artifact": "turbo run pack:artifact --color",
 		"test": "turbo run test --color",
 		"t": "pnpm test",
 		"test:types": "turbo run test:types --color",
-		"lint": "dprint check --list-different",
-		"lint:fix": "dprint fmt"
+		"test:types-lint": "turbo run test:types //#lint --color",
+		"lint": "pnpm oxlint",
+		"lint:check": "pnpm oxlint --max-warnings=0",
+		"format": "dprint fmt",
+		"format:check": "dprint check --list-different",
+		"fmt": "pnpm format"
 	},
 	"devDependencies": {
-		"@arethetypeswrong/cli": "0.15.3",
-		"@trivago/prettier-plugin-sort-imports": "^5.2.2",
-		"@typescript-eslint/eslint-plugin": "^6.7.3",
-		"@typescript-eslint/experimental-utils": "^5.62.0",
-		"@typescript-eslint/parser": "^6.7.3",
 		"bun-types": "^1.2.0",
 		"concurrently": "^8.2.1",
-		"dprint": "^0.46.2",
-		"drizzle-kit": "^0.19.13",
+		"dprint": "^0.50.2",
+		"drizzle-kit": "workspace:./drizzle-kit/dist",
 		"drizzle-orm": "workspace:./drizzle-orm/dist",
 		"drizzle-orm-old": "npm:drizzle-orm@^0.27.2",
-		"eslint": "^8.50.0",
 		"eslint-plugin-drizzle-internal": "link:eslint/eslint-plugin-drizzle-internal",
-		"eslint-plugin-import": "^2.28.1",
-		"eslint-plugin-no-instanceof": "^1.0.1",
-		"eslint-plugin-unicorn": "^48.0.1",
-		"eslint-plugin-unused-imports": "^3.0.0",
 		"glob": "^10.3.10",
-		"prettier": "^3.0.3",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.2.4",
+		"oxlint": "^1.28.0",
 		"recast": "^0.23.9",
 		"resolve-tspaths": "^0.8.16",
+		"rolldown": "1.0.0-rc.9",
+		"tsdown": "^0.20.3",
 		"tsup": "^8.3.5",
 		"tsx": "^4.10.5",
 		"turbo": "^2.2.3",
-		"typescript": "5.6.3"
+		"typescript": "5.9.3",
+		"vite-tsconfig-paths": "^4.3.2",
+		"vitest": "4.0.13"
 	},
-	"packageManager": "pnpm@10.6.3"
+	"packageManager": "pnpm@10.15.0",
+	"engines": {
+		"node": ">=24"
+	},
+	"lint-staged": {
+		"*": [
+			"pnpm format:check --allow-no-files",
+			"pnpm lint:check"
+		]
+	},
+	"volta": {
+		"node": "24.10.0"
+	}
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 933d63fb75..c115729a8d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,178 +8,197 @@ importers:
 
   .:
     devDependencies:
-      '@arethetypeswrong/cli':
-        specifier: 0.15.3
-        version: 0.15.3
-      '@trivago/prettier-plugin-sort-imports':
-        specifier: ^5.2.2
-        version: 5.2.2(prettier@3.5.3)
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^6.7.3
-        version: 6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/experimental-utils':
-        specifier: ^5.62.0
-        version: 5.62.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/parser':
-        specifier: ^6.7.3
-        version: 6.21.0(eslint@8.57.1)(typescript@5.6.3)
       bun-types:
         specifier: ^1.2.0
-        version: 1.2.15
+        version: 1.3.3
       concurrently:
         specifier: ^8.2.1
         version: 8.2.2
       dprint:
-        specifier: ^0.46.2
-        version: 0.46.3
+        specifier: ^0.50.2
+        version: 0.50.2
       drizzle-kit:
-        specifier: ^0.19.13
-        version: 0.19.13
+        specifier: workspace:./drizzle-kit/dist
+        version: link:drizzle-kit/dist
       drizzle-orm:
         specifier: workspace:./drizzle-orm/dist
         version: link:drizzle-orm/dist
       drizzle-orm-old:
         specifier: npm:drizzle-orm@^0.27.2
-        version: drizzle-orm@0.27.2(@aws-sdk/client-rds-data@3.821.0)(@cloudflare/workers-types@4.20250603.0)(@libsql/client@0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3))(@neondatabase/serverless@0.10.0)(@opentelemetry/api@1.9.0)(@planetscale/database@1.19.0)(@types/better-sqlite3@7.6.13)(@types/pg@8.15.4)(@types/sql.js@1.4.9)(@vercel/postgres@0.8.0)(better-sqlite3@11.9.1)(bun-types@1.2.15)(knex@2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7))(kysely@0.25.0)(mysql2@3.14.1)(pg@8.16.0)(postgres@3.4.7)(sql.js@1.13.0)(sqlite3@5.1.7)
-      eslint:
-        specifier: ^8.50.0
-        version: 8.57.1
+        version: drizzle-orm@0.27.2(@aws-sdk/client-rds-data@3.940.0)(@cloudflare/workers-types@4.20260621.1)(@libsql/client@0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3))(@neondatabase/serverless@1.0.2)(@opentelemetry/api@1.9.0)(@planetscale/database@1.19.0)(@types/better-sqlite3@7.6.13)(@types/pg@8.15.6)(@types/sql.js@1.4.9)(@vercel/postgres@0.8.0)(better-sqlite3@12.10.0)(bun-types@1.3.3)(mysql2@3.22.3(@types/node@25.5.0))(pg@8.20.0)(postgres@3.4.7)(sql.js@1.13.0)(sqlite3@5.1.7)
       eslint-plugin-drizzle-internal:
         specifier: link:eslint/eslint-plugin-drizzle-internal
         version: link:eslint/eslint-plugin-drizzle-internal
-      eslint-plugin-import:
-        specifier: ^2.28.1
-        version: 2.31.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)
-      eslint-plugin-no-instanceof:
-        specifier: ^1.0.1
-        version: 1.0.1
-      eslint-plugin-unicorn:
-        specifier: ^48.0.1
-        version: 48.0.1(eslint@8.57.1)
-      eslint-plugin-unused-imports:
-        specifier: ^3.0.0
-        version: 3.2.0(@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)
       glob:
         specifier: ^10.3.10
-        version: 10.4.5
-      prettier:
-        specifier: ^3.0.3
-        version: 3.5.3
+        version: 10.5.0
+      husky:
+        specifier: ^9.1.7
+        version: 9.1.7
+      lint-staged:
+        specifier: ^16.2.4
+        version: 16.2.7
+      oxlint:
+        specifier: ^1.28.0
+        version: 1.30.0
       recast:
         specifier: ^0.23.9
         version: 0.23.11
       resolve-tspaths:
         specifier: ^0.8.16
-        version: 0.8.23(typescript@5.6.3)
+        version: 0.8.23(typescript@5.9.3)
+      rolldown:
+        specifier: 1.0.0-rc.9
+        version: 1.0.0-rc.9
+      tsdown:
+        specifier: ^0.20.3
+        version: 0.20.3(typescript@5.9.3)
       tsup:
         specifier: ^8.3.5
-        version: 8.5.0(postcss@8.5.4)(tsx@4.19.4)(typescript@5.6.3)(yaml@2.8.0)
+        version: 8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.9.0)
       tsx:
         specifier: ^4.10.5
-        version: 4.19.4
+        version: 4.20.6
       turbo:
         specifier: ^2.2.3
-        version: 2.5.4
+        version: 2.6.1
       typescript:
-        specifier: 5.6.3
-        version: 5.6.3
-
-  drizzle-arktype:
-    devDependencies:
-      '@ark/attest':
-        specifier: ^0.45.8
-        version: 0.45.11(typescript@5.6.3)
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.0
-        version: 11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)
-      '@types/node':
-        specifier: ^18.15.10
-        version: 18.19.110
-      arktype:
-        specifier: ^2.1.10
-        version: 2.1.20
-      cpy:
-        specifier: ^10.1.0
-        version: 10.1.0
-      drizzle-orm:
-        specifier: link:../drizzle-orm/dist
-        version: link:../drizzle-orm/dist
-      json-rules-engine:
-        specifier: 7.3.1
-        version: 7.3.1
-      rimraf:
-        specifier: ^5.0.0
-        version: 5.0.10
-      rollup:
-        specifier: ^3.29.5
-        version: 3.29.5
-      tsx:
-        specifier: ^4.19.3
-        version: 4.19.4
+        specifier: 5.9.3
+        version: 5.9.3
       vite-tsconfig-paths:
         specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
+        version: 4.3.2(typescript@5.9.3)(vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))
       vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      zx:
-        specifier: ^7.2.2
-        version: 7.2.3
+        specifier: 4.0.13
+        version: 4.0.13(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
+
+  attw-fork:
+    dependencies:
+      '@andrewbranch/untar.js':
+        specifier: ^1.0.3
+        version: 1.0.3
+      '@loaderkit/resolve':
+        specifier: ^1.0.2
+        version: 1.0.4
+      chalk:
+        specifier: ^4.1.2
+        version: 4.1.2
+      cjs-module-lexer:
+        specifier: ^1.2.3
+        version: 1.4.3
+      cli-table3:
+        specifier: ^0.6.3
+        version: 0.6.5
+      fflate:
+        specifier: ^0.8.2
+        version: 0.8.2
+      lru-cache:
+        specifier: ^11.0.1
+        version: 11.2.2
+      marked:
+        specifier: 9.1.2
+        version: 9.1.2
+      marked-terminal:
+        specifier: 7.1.0
+        version: 7.1.0(marked@9.1.2)
+      semver:
+        specifier: ^7.5.4
+        version: 7.7.3
+      typescript:
+        specifier: 5.9.3
+        version: 5.9.3
+      validate-npm-package-name:
+        specifier: ^5.0.0
+        version: 5.0.1
+    devDependencies:
+      '@types/marked-terminal':
+        specifier: 3.1.3
+        version: 3.1.3
+      '@types/node':
+        specifier: ^24.5.0
+        version: 24.10.1
+      '@types/semver':
+        specifier: ^7.5.0
+        version: 7.7.1
+      '@types/validate-npm-package-name':
+        specifier: ^4.0.0
+        version: 4.0.2
+      ts-expose-internals:
+        specifier: 5.6.3
+        version: 5.6.3
 
   drizzle-kit:
     dependencies:
       '@drizzle-team/brocli':
-        specifier: ^0.10.2
-        version: 0.10.2
-      '@esbuild-kit/esm-loader':
-        specifier: ^2.5.5
-        version: 2.6.5
+        specifier: ^0.12.0
+        version: 0.12.0
+      '@js-temporal/polyfill':
+        specifier: ^0.5.1
+        version: 0.5.1
       esbuild:
-        specifier: ^0.25.4
-        version: 0.25.5
-      esbuild-register:
-        specifier: ^3.5.0
-        version: 3.6.0(esbuild@0.25.5)
-      postgres-array:
-        specifier: ^3.0.4
-        version: 3.0.4
+        specifier: ^0.25.10
+        version: 0.25.12
+      get-tsconfig:
+        specifier: ^4.13.6
+        version: 4.13.6
+      jiti:
+        specifier: ^2.6.1
+        version: 2.6.1
     devDependencies:
-      '@arethetypeswrong/cli':
-        specifier: ^0.15.3
-        version: 0.15.3
       '@aws-sdk/client-rds-data':
         specifier: ^3.556.0
-        version: 3.821.0
+        version: 3.940.0
       '@cloudflare/workers-types':
         specifier: ^4.20230518.0
-        version: 4.20250603.0
+        version: 4.20251126.0
+      '@duckdb/node-api':
+        specifier: 1.5.0-r.1
+        version: 1.5.0-r.1
+      '@effect/sql':
+        specifier: ^0.48.5
+        version: 0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
       '@electric-sql/pglite':
-        specifier: ^0.2.12
-        version: 0.2.12
+        specifier: ^0.4.6
+        version: 0.4.6
       '@hono/node-server':
         specifier: ^1.9.0
-        version: 1.14.3(hono@4.7.11)
+        version: 1.19.6(hono@4.10.7)
       '@hono/zod-validator':
         specifier: ^0.2.1
-        version: 0.2.2(hono@4.7.11)(zod@3.25.1)
+        version: 0.2.2(hono@4.10.7)(zod@3.25.76)
       '@libsql/client':
         specifier: ^0.10.0
         version: 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@modelcontextprotocol/sdk':
+        specifier: ^1.29.0
+        version: 1.29.0(zod@3.25.76)
       '@neondatabase/serverless':
-        specifier: ^0.9.1
-        version: 0.9.5
+        specifier: ^1.0.2
+        version: 1.0.2
       '@originjs/vite-plugin-commonjs':
         specifier: ^1.0.3
         version: 1.0.3
       '@planetscale/database':
-        specifier: ^1.16.0
+        specifier: ^1.19.0
         version: 1.19.0
+      '@sqlitecloud/drivers':
+        specifier: ^1.0.653
+        version: 1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)
+      '@tursodatabase/database':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/serverless':
+        specifier: ^1.1.3
+        version: 1.1.3
       '@types/better-sqlite3':
         specifier: ^7.6.13
         version: 7.6.13
+      '@types/bun':
+        specifier: ^1.3.2
+        version: 1.3.3
       '@types/dockerode':
         specifier: ^3.3.28
-        version: 3.3.39
+        version: 3.3.47
       '@types/glob':
         specifier: ^8.1.0
         version: 8.1.0
@@ -188,34 +207,31 @@ importers:
         version: 1.0.3
       '@types/micromatch':
         specifier: ^4.0.9
-        version: 4.0.9
+        version: 4.0.10
       '@types/minimatch':
         specifier: ^5.1.2
         version: 5.1.2
+      '@types/mssql':
+        specifier: ^9.1.4
+        version: 9.1.8
       '@types/node':
-        specifier: ^18.11.15
-        version: 18.19.110
+        specifier: ^24.7.2
+        version: 24.10.1
       '@types/pg':
         specifier: ^8.10.7
-        version: 8.15.4
+        version: 8.15.6
       '@types/pluralize':
         specifier: ^0.0.33
         version: 0.0.33
       '@types/semver':
         specifier: ^7.5.5
-        version: 7.7.0
+        version: 7.7.1
       '@types/uuid':
         specifier: ^9.0.8
         version: 9.0.8
       '@types/ws':
         specifier: ^8.5.10
         version: 8.18.1
-      '@typescript-eslint/eslint-plugin':
-        specifier: ^7.2.0
-        version: 7.18.0(@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/parser':
-        specifier: ^7.2.0
-        version: 7.18.0(eslint@8.57.1)(typescript@5.6.3)
       '@vercel/postgres':
         specifier: ^0.8.0
         version: 0.8.0
@@ -226,47 +242,32 @@ importers:
         specifier: ^11.9.1
         version: 11.9.1
       bun-types:
-        specifier: ^0.6.6
-        version: 0.6.14
+        specifier: ^1.3.2
+        version: 1.3.3
       camelcase:
         specifier: ^7.0.1
         version: 7.0.1
       chalk:
         specifier: ^5.2.0
-        version: 5.4.1
+        version: 5.6.2
       commander:
         specifier: ^12.1.0
         version: 12.1.0
       dockerode:
         specifier: ^4.0.6
-        version: 4.0.6
+        version: 4.0.9
       dotenv:
         specifier: ^16.0.3
-        version: 16.5.0
+        version: 16.6.1
       drizzle-kit:
-        specifier: 0.25.0-b1faa33
-        version: 0.25.0-b1faa33
+        specifier: ^0.31.6
+        version: 0.31.7
       drizzle-orm:
-        specifier: 0.44.1
-        version: 0.44.1(202f5f917ad7b147b6fd5e02d382b3b3)
+        specifier: workspace:./drizzle-orm/dist
+        version: link:drizzle-orm/dist
       env-paths:
         specifier: ^3.0.0
         version: 3.0.0
-      esbuild-node-externals:
-        specifier: ^1.9.0
-        version: 1.18.0(esbuild@0.25.5)
-      eslint:
-        specifier: ^8.57.0
-        version: 8.57.1
-      eslint-config-prettier:
-        specifier: ^9.1.0
-        version: 9.1.0(eslint@8.57.1)
-      eslint-plugin-prettier:
-        specifier: ^5.1.3
-        version: 5.4.1(eslint-config-prettier@9.1.0(eslint@8.57.1))(eslint@8.57.1)(prettier@3.5.3)
-      gel:
-        specifier: ^2.0.0
-        version: 2.1.0
       get-port:
         specifier: ^6.1.2
         version: 6.1.2
@@ -274,11 +275,11 @@ importers:
         specifier: ^8.1.0
         version: 8.1.0
       hanji:
-        specifier: ^0.0.5
-        version: 0.0.5
+        specifier: ^0.0.8
+        version: 0.0.8
       hono:
         specifier: ^4.7.9
-        version: 4.7.11
+        version: 4.10.7
       json-diff:
         specifier: 1.0.6
         version: 1.0.6
@@ -288,6 +289,9 @@ importers:
       minimatch:
         specifier: ^7.4.3
         version: 7.4.6
+      mssql:
+        specifier: ^12.0.0
+        version: 12.1.1
       mysql2:
         specifier: 3.14.1
         version: 3.14.1
@@ -296,10 +300,13 @@ importers:
         version: 3.3.2
       ohm-js:
         specifier: ^17.1.0
-        version: 17.1.0
+        version: 17.2.1
+      orm044:
+        specifier: npm:drizzle-orm@0.44.1
+        version: drizzle-orm@0.44.1(79be78f2eb1aa75d0ee8731ec8070b23)
       pg:
         specifier: ^8.11.5
-        version: 8.16.0
+        version: 8.16.3
       pluralize:
         specifier: ^8.0.0
         version: 8.0.0
@@ -308,52 +315,77 @@ importers:
         version: 3.4.7
       prettier:
         specifier: ^3.5.3
-        version: 3.5.3
+        version: 3.6.2
       semver:
         specifier: ^7.7.2
-        version: 7.7.2
-      superjson:
-        specifier: ^2.2.1
-        version: 2.2.2
-      tsup:
-        specifier: ^8.3.5
-        version: 8.5.0(postcss@8.5.4)(tsx@3.14.0)(typescript@5.6.3)(yaml@2.8.0)
+        version: 7.7.3
       tsx:
-        specifier: ^3.12.1
-        version: 3.14.0
+        specifier: ^4.20.6
+        version: 4.20.6
       typescript:
-        specifier: ^5.6.3
-        version: 5.6.3
+        specifier: 5.9.3
+        version: 5.9.3
       uuid:
         specifier: ^9.0.1
         version: 9.0.1
-      vite-tsconfig-paths:
-        specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
       ws:
         specifier: ^8.18.2
-        version: 8.18.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+        version: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       zod:
-        specifier: ^3.20.2
-        version: 3.25.1
+        specifier: ^3.25
+        version: 3.25.76
       zx:
-        specifier: ^8.3.2
-        version: 8.5.4
+        specifier: ^8.8.5
+        version: 8.8.5
 
   drizzle-orm:
+    dependencies:
+      '@types/mssql':
+        specifier: ^9.1.4
+        version: 9.1.8
+      mssql:
+        specifier: ^11.0.1
+        version: 11.0.1
     devDependencies:
+      '@arktype/attest':
+        specifier: ^0.46.0
+        version: 0.46.0(typescript@5.9.3)
       '@aws-sdk/client-rds-data':
-        specifier: ^3.549.0
-        version: 3.821.0
+        specifier: ^3.914.0
+        version: 3.940.0
       '@cloudflare/workers-types':
-        specifier: ^4.20241112.0
-        version: 4.20250603.0
+        specifier: ^4.20251004.0
+        version: 4.20251126.0
+      '@effect/sql-d1':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-libsql':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(bufferutil@4.0.8)(effect@4.0.0-beta.83)(utf-8-validate@6.0.3)
+      '@effect/sql-mysql2':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(@types/node@25.5.0)(effect@4.0.0-beta.83)
+      '@effect/sql-pg':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-pglite':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-bun':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-do':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-node':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-wasm':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(@effect/wa-sqlite@0.1.2)(effect@4.0.0-beta.83)
       '@electric-sql/pglite':
-        specifier: ^0.2.12
-        version: 0.2.12
+        specifier: ^0.4.6
+        version: 0.4.6
       '@libsql/client':
         specifier: ^0.10.0
         version: 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
@@ -368,7 +400,7 @@ importers:
         version: 0.10.0
       '@op-engineering/op-sqlite':
         specifier: ^2.0.16
-        version: 2.0.22(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+        version: 2.0.22(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       '@opentelemetry/api':
         specifier: ^1.4.1
         version: 1.9.0
@@ -381,69 +413,84 @@ importers:
       '@prisma/client':
         specifier: 5.14.0
         version: 5.14.0(prisma@5.14.0)
+      '@sinclair/typebox':
+        specifier: ^0.34.48
+        version: 0.34.48
+      '@sqlitecloud/drivers':
+        specifier: ^1.0.653
+        version: 1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)
       '@tidbcloud/serverless':
         specifier: ^0.1.1
         version: 0.1.1
+      '@tursodatabase/database':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/database-common':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/database-wasm':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/serverless':
+        specifier: 1.1.3
+        version: 1.1.3
+      '@tursodatabase/sync':
+        specifier: 0.6.0
+        version: 0.6.0
       '@types/better-sqlite3':
         specifier: ^7.6.12
         version: 7.6.13
       '@types/node':
-        specifier: ^20.2.5
-        version: 20.17.57
+        specifier: ^25.4.0
+        version: 25.5.0
       '@types/pg':
         specifier: ^8.10.1
-        version: 8.15.4
+        version: 8.15.6
       '@types/react':
         specifier: ^18.2.45
-        version: 18.3.23
+        version: 18.3.27
       '@types/sql.js':
         specifier: ^1.4.4
         version: 1.4.9
       '@upstash/redis':
         specifier: ^1.34.3
-        version: 1.35.0
+        version: 1.35.7
       '@vercel/postgres':
         specifier: ^0.8.0
         version: 0.8.0
       '@xata.io/client':
         specifier: ^0.29.3
-        version: 0.29.5(typescript@5.6.3)
+        version: 0.29.5(typescript@5.9.3)
+      arktype:
+        specifier: ^2.1.10
+        version: 2.2.0
       better-sqlite3:
         specifier: ^11.9.1
         version: 11.9.1
       bun-types:
-        specifier: ^1.2.0
-        version: 1.2.15
+        specifier: ^1.2.23
+        version: 1.3.3
       cpy:
         specifier: ^10.1.0
         version: 10.1.0
+      effect:
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83
       expo-sqlite:
         specifier: ^14.0.0
-        version: 14.0.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
-      gel:
-        specifier: ^2.0.0
-        version: 2.1.0
+        version: 14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
       glob:
         specifier: ^11.0.1
-        version: 11.0.2
-      knex:
-        specifier: ^2.4.2
-        version: 2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7)
-      kysely:
-        specifier: ^0.25.0
-        version: 0.25.0
+        version: 11.1.0
       mysql2:
         specifier: ^3.14.1
         version: 3.14.1
       pg:
         specifier: ^8.11.0
-        version: 8.16.0
+        version: 8.16.3
       postgres:
         specifier: ^3.3.5
         version: 3.4.7
-      prisma:
-        specifier: 5.14.0
-        version: 5.14.0
       react:
         specifier: ^18.2.0
         version: 18.3.1
@@ -462,18 +509,15 @@ importers:
       tsx:
         specifier: ^3.12.7
         version: 3.14.0
-      vite-tsconfig-paths:
-        specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
+      typebox:
+        specifier: ^1.0.80
+        version: 1.1.6
+      valibot:
+        specifier: 1.0.0-beta.7
+        version: 1.0.0-beta.7(typescript@5.9.3)
       zod:
         specifier: ^3.20.2
         version: 3.25.1
-      zx:
-        specifier: ^7.2.2
-        version: 7.2.3
 
   drizzle-seed:
     dependencies:
@@ -485,29 +529,32 @@ importers:
         specifier: ^0.16.1
         version: 0.16.4
       '@electric-sql/pglite':
-        specifier: ^0.2.12
-        version: 0.2.12
-      '@rollup/plugin-terser':
-        specifier: ^0.4.4
-        version: 0.4.4(rollup@3.29.5)
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.6
-        version: 11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)
+        specifier: ^0.4.6
+        version: 0.4.6
+      '@types/async-retry':
+        specifier: ^1.4.8
+        version: 1.4.9
       '@types/better-sqlite3':
         specifier: ^7.6.11
         version: 7.6.13
       '@types/dockerode':
         specifier: ^3.3.31
-        version: 3.3.39
+        version: 3.3.47
+      '@types/mssql':
+        specifier: ^9.1.4
+        version: 9.1.8
       '@types/node':
         specifier: ^22.5.4
-        version: 22.15.29
+        version: 22.19.1
       '@types/pg':
         specifier: ^8.11.6
-        version: 8.15.4
+        version: 8.15.6
       '@types/uuid':
         specifier: ^10.0.0
         version: 10.0.0
+      async-retry:
+        specifier: ^1.3.3
+        version: 1.3.3
       better-sqlite3:
         specifier: ^11.1.2
         version: 11.9.1
@@ -516,169 +563,61 @@ importers:
         version: 11.1.0
       dockerode:
         specifier: ^4.0.6
-        version: 4.0.6
+        version: 4.0.9
       dotenv:
         specifier: ^16.4.5
-        version: 16.5.0
+        version: 16.6.1
       drizzle-kit:
-        specifier: workspace:./drizzle-kit/dist
-        version: link:drizzle-kit/dist
+        specifier: workspace:../drizzle-kit/dist
+        version: link:../drizzle-kit/dist
       drizzle-orm:
-        specifier: workspace:./drizzle-orm/dist
-        version: link:drizzle-orm/dist
+        specifier: workspace:../drizzle-orm/dist
+        version: link:../drizzle-orm/dist
       get-port:
         specifier: ^7.1.0
         version: 7.1.0
+      mssql:
+        specifier: ^11.0.1
+        version: 11.0.1
       mysql2:
         specifier: ^3.14.1
         version: 3.14.1
       pg:
         specifier: ^8.12.0
-        version: 8.16.0
-      resolve-tspaths:
-        specifier: ^0.8.19
-        version: 0.8.23(typescript@5.6.3)
-      rollup:
-        specifier: ^3.29.5
-        version: 3.29.5
+        version: 8.16.3
       tslib:
         specifier: ^2.7.0
         version: 2.8.1
       tsx:
         specifier: ^4.19.0
-        version: 4.19.4
+        version: 4.20.6
       uuid:
         specifier: ^10.0.0
         version: 10.0.0
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      zx:
-        specifier: ^8.1.5
-        version: 8.5.4
-
-  drizzle-typebox:
-    devDependencies:
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.0
-        version: 11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)
-      '@sinclair/typebox':
-        specifier: ^0.34.8
-        version: 0.34.33
-      '@types/node':
-        specifier: ^18.15.10
-        version: 18.19.110
-      cpy:
-        specifier: ^10.1.0
-        version: 10.1.0
-      drizzle-orm:
-        specifier: link:../drizzle-orm/dist
-        version: link:../drizzle-orm/dist
-      json-rules-engine:
-        specifier: ^7.3.1
-        version: 7.3.1
-      rimraf:
-        specifier: ^5.0.0
-        version: 5.0.10
-      rollup:
-        specifier: ^3.29.5
-        version: 3.29.5
-      vite-tsconfig-paths:
-        specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      zx:
-        specifier: ^7.2.2
-        version: 7.2.3
-
-  drizzle-valibot:
-    devDependencies:
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.0
-        version: 11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)
-      '@types/node':
-        specifier: ^18.15.10
-        version: 18.19.110
-      cpy:
-        specifier: ^10.1.0
-        version: 10.1.0
-      drizzle-orm:
-        specifier: link:../drizzle-orm/dist
-        version: link:../drizzle-orm/dist
-      json-rules-engine:
-        specifier: ^7.3.1
-        version: 7.3.1
-      rimraf:
-        specifier: ^5.0.0
-        version: 5.0.10
-      rollup:
-        specifier: ^3.29.5
-        version: 3.29.5
-      valibot:
-        specifier: 1.0.0-beta.7
-        version: 1.0.0-beta.7(typescript@5.6.3)
-      vite-tsconfig-paths:
-        specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      zx:
-        specifier: ^7.2.2
-        version: 7.2.3
-
-  drizzle-zod:
-    devDependencies:
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.0
-        version: 11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)
-      '@types/node':
-        specifier: ^18.15.10
-        version: 18.19.110
-      cpy:
-        specifier: ^10.1.0
-        version: 10.1.0
-      drizzle-orm:
-        specifier: link:../drizzle-orm/dist
-        version: link:../drizzle-orm/dist
-      json-rules-engine:
-        specifier: ^7.3.1
-        version: 7.3.1
-      rimraf:
-        specifier: ^5.0.0
-        version: 5.0.10
-      rollup:
-        specifier: ^3.29.5
-        version: 3.29.5
       vite-tsconfig-paths:
         specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+        version: 4.3.2(typescript@5.9.3)(vite@7.2.4(@types/node@22.19.1)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))
       zod:
-        specifier: 3.25.1
-        version: 3.25.1
+        specifier: ^4.0.0
+        version: 4.3.4
       zx:
-        specifier: ^7.2.2
-        version: 7.2.3
+        specifier: ^8.1.5
+        version: 8.8.5
 
   eslint-plugin-drizzle:
     devDependencies:
       '@types/node':
         specifier: ^20.10.1
-        version: 20.17.57
+        version: 20.19.25
       '@typescript-eslint/parser':
         specifier: ^6.10.0
-        version: 6.21.0(eslint@8.57.1)(typescript@5.6.3)
+        version: 6.21.0(eslint@8.57.1)(typescript@5.9.3)
       '@typescript-eslint/rule-tester':
         specifier: ^6.10.0
-        version: 6.21.0(@eslint/eslintrc@2.1.4)(eslint@8.57.1)(typescript@5.6.3)
+        version: 6.21.0(@eslint/eslintrc@2.1.4)(eslint@8.57.1)(typescript@5.9.3)
       '@typescript-eslint/utils':
         specifier: ^6.10.0
-        version: 6.21.0(eslint@8.57.1)(typescript@5.6.3)
+        version: 6.21.0(eslint@8.57.1)(typescript@5.9.3)
       cpy-cli:
         specifier: ^5.0.0
         version: 5.0.0
@@ -686,26 +625,53 @@ importers:
         specifier: ^8.53.0
         version: 8.57.1
       typescript:
-        specifier: ^5.2.2
-        version: 5.6.3
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@20.17.57)(@vitest/ui@1.6.1)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+        specifier: 5.9.3
+        version: 5.9.3
 
   integration-tests:
     dependencies:
       '@aws-sdk/client-rds-data':
         specifier: ^3.549.0
-        version: 3.821.0
+        version: 3.940.0
       '@aws-sdk/credential-providers':
         specifier: ^3.549.0
-        version: 3.821.0
+        version: 3.940.0
+      '@effect/sql-d1':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-libsql':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(bufferutil@4.0.8)(effect@4.0.0-beta.83)(utf-8-validate@6.0.3)
+      '@effect/sql-mysql2':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(@types/node@25.5.0)(effect@4.0.0-beta.83)
+      '@effect/sql-pg':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-pglite':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-bun':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-do':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-node':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(effect@4.0.0-beta.83)
+      '@effect/sql-sqlite-wasm':
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83(@effect/wa-sqlite@0.1.2)(effect@4.0.0-beta.83)
+      '@effect/vitest':
+        specifier: 4.0.0-beta.58
+        version: 4.0.0-beta.58(effect@4.0.0-beta.83)(vitest@4.0.13(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))
       '@electric-sql/pglite':
-        specifier: 0.2.12
-        version: 0.2.12
-      '@libsql/client':
-        specifier: ^0.10.0
-        version: 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+        specifier: 0.4.6
+        version: 0.4.6
+      '@electric-sql/pglite-postgis':
+        specifier: ^0.0.8
+        version: 0.0.8(@electric-sql/pglite@0.4.6)
       '@miniflare/d1':
         specifier: ^2.14.4
         version: 2.14.4
@@ -718,9 +684,30 @@ importers:
       '@prisma/client':
         specifier: 5.14.0
         version: 5.14.0(prisma@5.14.0)
+      '@sinclair/typebox':
+        specifier: ^0.34.48
+        version: 0.34.48
+      '@sqlitecloud/drivers':
+        specifier: ^1.0.653
+        version: 1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)
       '@tidbcloud/serverless':
         specifier: ^0.1.1
         version: 0.1.1
+      '@tursodatabase/database':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/database-wasm':
+        specifier: 0.6.0-pre.28
+        version: 0.6.0-pre.28
+      '@tursodatabase/serverless':
+        specifier: 1.2.0-pre.1
+        version: 1.2.0-pre.1
+      '@tursodatabase/sync':
+        specifier: 0.6.0
+        version: 0.6.0
+      '@types/chai':
+        specifier: ^5.2.2
+        version: 5.2.3
       '@typescript/analyze-trace':
         specifier: ^0.10.0
         version: 0.10.1
@@ -729,19 +716,28 @@ importers:
         version: 0.8.0
       '@xata.io/client':
         specifier: ^0.29.3
-        version: 0.29.5(typescript@5.6.3)
+        version: 0.29.5(typescript@5.9.3)
+      arktype:
+        specifier: ^2.1.10
+        version: 2.2.0
       async-retry:
         specifier: ^1.3.3
         version: 1.3.3
       better-sqlite3:
         specifier: 11.9.1
         version: 11.9.1
+      chai:
+        specifier: ^5.2.1
+        version: 5.3.3
       dockerode:
         specifier: ^4.0.6
-        version: 4.0.6
+        version: 4.0.9
       dotenv:
         specifier: ^16.1.4
-        version: 16.5.0
+        version: 16.6.1
+      drizzle-kit:
+        specifier: workspace:../drizzle-kit/dist
+        version: link:../drizzle-kit/dist
       drizzle-prisma-generator:
         specifier: ^0.1.2
         version: 0.1.7
@@ -757,18 +753,24 @@ importers:
       drizzle-zod:
         specifier: workspace:../drizzle-zod/dist
         version: link:../drizzle-zod/dist
-      gel:
-        specifier: ^2.0.0
-        version: 2.1.0
+      effect:
+        specifier: 4.0.0-beta.83
+        version: 4.0.0-beta.83
       get-port:
         specifier: ^7.0.0
         version: 7.1.0
+      json-rules-engine:
+        specifier: ^7.3.1
+        version: 7.3.1
+      mssql:
+        specifier: ^11.0.1
+        version: 11.0.1
       mysql2:
         specifier: ^3.14.1
         version: 3.14.1
       pg:
         specifier: ^8.11.0
-        version: 8.16.0
+        version: 8.16.3
       postgres:
         specifier: ^3.3.5
         version: 3.4.7
@@ -786,26 +788,32 @@ importers:
         version: 5.1.7
       sst:
         specifier: ^3.14.24
-        version: 3.17.0
+        version: 3.17.23
+      typebox:
+        specifier: ^1.0.80
+        version: 1.1.6
       uuid:
         specifier: ^9.0.0
         version: 9.0.1
       uvu:
         specifier: ^0.5.6
         version: 0.5.6
-      vitest:
-        specifier: ^3.1.3
-        version: 3.2.0(@types/node@20.17.57)(@vitest/ui@1.6.1)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      valibot:
+        specifier: 1.0.0-beta.7
+        version: 1.0.0-beta.7(typescript@5.9.3)
       ws:
         specifier: ^8.18.2
-        version: 8.18.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+        version: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       zod:
         specifier: ^3.20.2
         version: 3.25.1
     devDependencies:
       '@cloudflare/workers-types':
         specifier: ^4.20241004.0
-        version: 4.20250603.0
+        version: 4.20251126.0
+      '@libsql/client':
+        specifier: ^0.10.0
+        version: 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       '@neondatabase/serverless':
         specifier: 0.10.0
         version: 0.10.0
@@ -814,7 +822,7 @@ importers:
         version: 1.0.3
       '@paralleldrive/cuid2':
         specifier: ^2.2.2
-        version: 2.2.2
+        version: 2.3.1
       '@types/async-retry':
         specifier: ^1.4.8
         version: 1.4.9
@@ -823,13 +831,16 @@ importers:
         version: 7.6.13
       '@types/dockerode':
         specifier: ^3.3.18
-        version: 3.3.39
+        version: 3.3.47
+      '@types/mssql':
+        specifier: ^9.1.4
+        version: 9.1.8
       '@types/node':
-        specifier: ^20.2.5
-        version: 20.17.57
+        specifier: ^25.4.0
+        version: 25.5.0
       '@types/pg':
         specifier: ^8.10.1
-        version: 8.15.4
+        version: 8.15.6
       '@types/sql.js':
         specifier: ^1.4.4
         version: 1.4.9
@@ -841,94 +852,115 @@ importers:
         version: 8.18.1
       '@upstash/redis':
         specifier: ^1.34.3
-        version: 1.35.0
-      '@vitest/ui':
-        specifier: ^1.6.0
-        version: 1.6.1(vitest@3.2.0)
+        version: 1.35.7
       ava:
         specifier: ^5.3.0
         version: 5.3.1
+      bun-types:
+        specifier: ^1.2.23
+        version: 1.3.3
       cross-env:
         specifier: ^7.0.3
         version: 7.0.3
       import-in-the-middle:
         specifier: ^1.13.1
-        version: 1.14.0
+        version: 1.15.0
       keyv:
         specifier: ^5.2.3
-        version: 5.3.3
+        version: 5.5.4
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.17.57)(typescript@5.6.3)
+        version: 10.9.2(@types/node@25.5.0)(typescript@5.9.3)
       tsx:
         specifier: ^4.14.0
-        version: 4.19.4
+        version: 4.20.6
       vite-tsconfig-paths:
         specifier: ^4.3.2
-        version: 4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
+        version: 4.3.2(typescript@5.9.3)(vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))
       zx:
         specifier: ^8.3.2
-        version: 8.5.4
+        version: 8.8.5
+
+  typeperf-test:
+    dependencies:
+      drizzle-beta:
+        specifier: npm:drizzle-orm@1.0.0-beta.21
+        version: drizzle-orm@1.0.0-beta.21(9ac8cbab502f04e357d42ee4dc553962)
+      drizzle-seed:
+        specifier: workspace:../drizzle-seed/dist
+        version: link:../drizzle-seed/dist
+      drizzle-typebox:
+        specifier: workspace:../drizzle-typebox/dist
+        version: link:../drizzle-typebox/dist
+      drizzle-valibot:
+        specifier: workspace:../drizzle-valibot/dist
+        version: link:../drizzle-valibot/dist
+      drizzle-zod:
+        specifier: workspace:../drizzle-zod/dist
+        version: link:../drizzle-zod/dist
+    devDependencies:
+      '@ark/attest':
+        specifier: ^0.56.0
+        version: 0.56.0(typescript@5.9.3)
+      tsx:
+        specifier: ^4.19.0
+        version: 4.20.6
+      vitest:
+        specifier: ^2.1.8
+        version: 2.1.9(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1)
 
 packages:
 
-  '@0no-co/graphql.web@1.1.2':
-    resolution: {integrity: sha512-N2NGsU5FLBhT8NZ+3l2YrzZSHITjNXNuDhC4iDiikv0IujaJ0Xc6xIxQZ/Ek3Cb+rgPjnLHYyJm11tInuJn+cw==}
+  '@0no-co/graphql.web@1.2.0':
+    resolution: {integrity: sha512-/1iHy9TTr63gE1YcR5idjx8UREz1s0kFhydf3bBLCXyqjhkIc6igAzTOx3zPifCwFR87tsh/4Pa9cNts6d2otw==}
     peerDependencies:
       graphql: ^14.0.0 || ^15.0.0 || ^16.0.0
     peerDependenciesMeta:
       graphql:
         optional: true
 
-  '@ampproject/remapping@2.3.0':
-    resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==}
-    engines: {node: '>=6.0.0'}
-
   '@andrewbranch/untar.js@1.0.3':
     resolution: {integrity: sha512-Jh15/qVmrLGhkKJBdXlK1+9tY4lZruYjsgkDFj08ZmDiWVBLJcqkok7Z0/R0In+i1rScBpJlSvrTS2Lm41Pbnw==}
 
-  '@arethetypeswrong/cli@0.15.3':
-    resolution: {integrity: sha512-sIMA9ZJBWDEg1+xt5RkAEflZuf8+PO8SdKj17x6PtETuUho+qlZJg4DgmKc3q+QwQ9zOB5VLK6jVRbFdNLdUIA==}
-    engines: {node: '>=18'}
-    hasBin: true
-
   '@arethetypeswrong/cli@0.16.4':
     resolution: {integrity: sha512-qMmdVlJon5FtA+ahn0c1oAVNxiq4xW5lqFiTZ21XHIeVwAVIQ+uRz4UEivqRMsjVV1grzRgJSKqaOrq1MvlVyQ==}
     engines: {node: '>=18'}
     hasBin: true
 
-  '@arethetypeswrong/core@0.15.1':
-    resolution: {integrity: sha512-FYp6GBAgsNz81BkfItRz8RLZO03w5+BaeiPma1uCfmxTnxbtuMrI/dbzGiOk8VghO108uFI0oJo0OkewdSHw7g==}
-    engines: {node: '>=18'}
-
   '@arethetypeswrong/core@0.16.4':
     resolution: {integrity: sha512-RI3HXgSuKTfcBf1hSEg1P9/cOvmI0flsMm6/QL3L3wju4AlHDqd55JFPfXs4pzgEAgy5L9pul4/HPPz99x2GvA==}
     engines: {node: '>=18'}
 
-  '@ark/attest@0.45.11':
-    resolution: {integrity: sha512-1qGdE/ZlY8sf1IfQTSo8zlRi0sNH9mqqGsAYA4scKJugJ2JQ4Yl/B3bztnRW0Z6XdDrhCvPmtH4mcqVnnd84jQ==}
+  '@ark/attest@0.56.0':
+    resolution: {integrity: sha512-Pngs8f1UJiWbeO8LKVdyBL0K3rT/PDVACR7TPyCEULNcN8V1rVec6dKvUnQVpQSj60p4ejlK6dKs+fQoqdUMqA==}
     hasBin: true
     peerDependencies:
       typescript: '*'
 
-  '@ark/fs@0.45.10':
-    resolution: {integrity: sha512-xHHaLk77d3V7K1ZcJKgOJanmSfinezG/J8zVZ2/sx/mIOgjzMY3wPD6BQsQerlGtP4W34GrcCczhjfr8QfGyyg==}
+  '@ark/fs@0.46.0':
+    resolution: {integrity: sha512-lBW6Vv6dZ74Gcc+zvJP8gjZACMo5o6hEuOvAtX6EJ5xNYBmX7nrXQaDdRfQNGDzgaX5UHGqi/vxk5moK94K7Yw==}
 
-  '@ark/schema@0.45.9':
-    resolution: {integrity: sha512-rG0v/JI0sibn/0wERAHTYVLCtEqoMP2IIlxnb+S5DrEjCI5wpubbZSWMDW50tZ8tV6FANu6zzHDeeKbp6lsZdg==}
+  '@ark/fs@0.56.0':
+    resolution: {integrity: sha512-zY/wDDhcvmt6/upQwZM766PAnvIzdEMcgydUGd9pqY9FMGNo9I9uE4RYAfms9AeUUtbZJu2h2Ua0tvFsO5XF4Q==}
 
   '@ark/schema@0.46.0':
     resolution: {integrity: sha512-c2UQdKgP2eqqDArfBqQIJppxJHvNNXuQPeuSPlDML4rjw+f1cu0qAlzOG4b8ujgm9ctIDWwhpyw6gjG5ledIVQ==}
 
-  '@ark/util@0.45.10':
-    resolution: {integrity: sha512-O0tI/nCCOsTqnT0Vcunz97o66EROOXc0BOAVzBxurYkgU+Pp5I2nCaj0sRPQ1y9UCwaCwkW8qS7VTJYUTicGzg==}
-
-  '@ark/util@0.45.9':
-    resolution: {integrity: sha512-0WYNAb8aRGp7dNt6xIvIrRzL7V1XL3u3PK2vcklhtTrdaP235DjC9qJhzidrxtWr68mA5ySSjUrgrXk622bKkw==}
+  '@ark/schema@0.56.0':
+    resolution: {integrity: sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==}
 
   '@ark/util@0.46.0':
     resolution: {integrity: sha512-JPy/NGWn/lvf1WmGCPw2VGpBg5utZraE84I7wli18EDF3p3zc/e9WolT35tINeZO3l7C77SjqRJeAUoT0CvMRg==}
 
+  '@ark/util@0.56.0':
+    resolution: {integrity: sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==}
+
+  '@arktype/attest@0.46.0':
+    resolution: {integrity: sha512-qKuIXbbJ7rdS5wyYMsrGtcQpAyFizAwnB5o2eTAvrLxgDmg12rr+IJRCBPUCbv49yJ3H4l8woV+gYvjom6Wx6w==}
+    hasBin: true
+    peerDependencies:
+      typescript: '*'
+
   '@aws-crypto/sha256-browser@5.2.0':
     resolution: {integrity: sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==}
 
@@ -942,103 +974,107 @@ packages:
   '@aws-crypto/util@5.2.0':
     resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==}
 
-  '@aws-sdk/client-cognito-identity@3.821.0':
-    resolution: {integrity: sha512-c6TpvrRAb4hVcbGMCPjTWU2IRNBzfEz2qZ1v6DGViW0i8vN4+zXY/DcVOL2P3ZA9MDXjFRiiA8RdIy1/zsi3YQ==}
+  '@aws-sdk/client-cognito-identity@3.940.0':
+    resolution: {integrity: sha512-kFl2zLYQBLMplmYglbEe4qGuj1jlIuGuYUmtpH+XUMnbeqwU2KoDiLh+bn2u32KGrxNWHZQgraoqxMKN2q6Kcg==}
+    engines: {node: '>=18.0.0'}
+
+  '@aws-sdk/client-rds-data@3.940.0':
+    resolution: {integrity: sha512-68NH61MvS48CVPfzBNCPdCG4KnNjM+Uj/3DSw7rT9PJvdML9ARS4M2Uqco9POPw+Aj20KBumsEUd6FMVcYBXAA==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/client-rds-data@3.821.0':
-    resolution: {integrity: sha512-G/1kiTY7IzPwIl1S9c+jpl9qIyXBQnN2HRC62yMp61cOSnUqv+6opNlL2GoXduDb3m0trIM9MQl17lXfulklsA==}
+  '@aws-sdk/client-sso@3.940.0':
+    resolution: {integrity: sha512-SdqJGWVhmIURvCSgkDditHRO+ozubwZk9aCX9MK8qxyOndhobCndW1ozl3hX9psvMAo9Q4bppjuqy/GHWpjB+A==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/client-sso@3.821.0':
-    resolution: {integrity: sha512-aDEBZUKUd/+Tvudi0d9KQlqt2OW2P27LATZX0jkNC8yVk4145bAPS04EYoqdKLuyUn/U33DibEOgKUpxZB12jQ==}
+  '@aws-sdk/core@3.940.0':
+    resolution: {integrity: sha512-KsGD2FLaX5ngJao1mHxodIVU9VYd1E8810fcYiGwO1PFHDzf5BEkp6D9IdMeQwT8Q6JLYtiiT1Y/o3UCScnGoA==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/core@3.821.0':
-    resolution: {integrity: sha512-8eB3wKbmfciQFmxFq7hAjy7mXdUs7vBOR5SwT0ZtQBg0Txc18Lc9tMViqqdO6/KU7OukA6ib2IAVSjIJJEN7FQ==}
+  '@aws-sdk/credential-provider-cognito-identity@3.940.0':
+    resolution: {integrity: sha512-VZMijB+Dc2tISeumWw+Oxn0Oi9f4g4/xJu3kdFIjsac6GDdmBVuBbAG+bvPP73J1j1m1G1BwaYqEZvOlLwgjIA==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-cognito-identity@3.821.0':
-    resolution: {integrity: sha512-8ZdFwmSxvQv8QindA0DJ3YUT9FD8T9sA5hQWp3B9+Znkze29IiIadnsXY0Heo2/FOFygxh8jRXiCWEie7/YpzA==}
+  '@aws-sdk/credential-provider-env@3.940.0':
+    resolution: {integrity: sha512-/G3l5/wbZYP2XEQiOoIkRJmlv15f1P3MSd1a0gz27lHEMrOJOGq66rF1Ca4OJLzapWt3Fy9BPrZAepoAX11kMw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-env@3.821.0':
-    resolution: {integrity: sha512-C+s/A72pd7CXwEsJj9+Uq9T726iIfIF18hGRY8o82xcIEfOyakiPnlisku8zZOaAu+jm0CihbbYN4NyYNQ+HZQ==}
+  '@aws-sdk/credential-provider-http@3.940.0':
+    resolution: {integrity: sha512-dOrc03DHElNBD6N9Okt4U0zhrG4Wix5QUBSZPr5VN8SvmjD9dkrrxOkkJaMCl/bzrW7kbQEp7LuBdbxArMmOZQ==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-http@3.821.0':
-    resolution: {integrity: sha512-gIRzTLnAsRfRSNarCag7G7rhcHagz4x5nNTWRihQs5cwTOghEExDy7Tj5m4TEkv3dcTAsNn+l4tnR4nZXo6R+Q==}
+  '@aws-sdk/credential-provider-ini@3.940.0':
+    resolution: {integrity: sha512-gn7PJQEzb/cnInNFTOaDoCN/hOKqMejNmLof1W5VW95Qk0TPO52lH8R4RmJPnRrwFMswOWswTOpR1roKNLIrcw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-ini@3.821.0':
-    resolution: {integrity: sha512-VRTrmsca8kBHtY1tTek1ce+XkK/H0fzodBKcilM/qXjTyumMHPAzVAxKZfSvGC+28/pXyQzhOEyxZfw7giCiWA==}
+  '@aws-sdk/credential-provider-login@3.940.0':
+    resolution: {integrity: sha512-fOKC3VZkwa9T2l2VFKWRtfHQPQuISqqNl35ZhcXjWKVwRwl/o7THPMkqI4XwgT2noGa7LLYVbWMwnsgSsBqglg==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-node@3.821.0':
-    resolution: {integrity: sha512-oBgbcgOXWMgknAfhIdTeHSSVIv+k2LXN9oTbxu1r++o4WWBWrEQ8mHU0Zo9dfr7Uaoqi3pezYZznsBkXnMLEOg==}
+  '@aws-sdk/credential-provider-node@3.940.0':
+    resolution: {integrity: sha512-M8NFAvgvO6xZjiti5kztFiAYmSmSlG3eUfr4ZHSfXYZUA/KUdZU/D6xJyaLnU8cYRWBludb6K9XPKKVwKfqm4g==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-process@3.821.0':
-    resolution: {integrity: sha512-e18ucfqKB3ICNj5RP/FEdvUfhVK6E9MALOsl8pKP13mwegug46p/1BsZWACD5n+Zf9ViiiHxIO7td03zQixfwA==}
+  '@aws-sdk/credential-provider-process@3.940.0':
+    resolution: {integrity: sha512-pILBzt5/TYCqRsJb7vZlxmRIe0/T+FZPeml417EK75060ajDGnVJjHcuVdLVIeKoTKm9gmJc9l45gon6PbHyUQ==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-sso@3.821.0':
-    resolution: {integrity: sha512-Dt+pheBLom4O/egO4L75/72k9C1qtUOLl0F0h6lmqZe4Mvhz+wDtjoO/MdGC/P1q0kcIX/bBKr0NQ3cIvAH8pA==}
+  '@aws-sdk/credential-provider-sso@3.940.0':
+    resolution: {integrity: sha512-q6JMHIkBlDCOMnA3RAzf8cGfup+8ukhhb50fNpghMs1SNBGhanmaMbZSgLigBRsPQW7fOk2l8jnzdVLS+BB9Uw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-provider-web-identity@3.821.0':
-    resolution: {integrity: sha512-FF5wnRJkxSQaCVVvWNv53K1MhTMgH8d+O+MHTbkv51gVIgVATrtfFQMKBLcEAxzXrgAliIO3LiNv+1TqqBZ+BA==}
+  '@aws-sdk/credential-provider-web-identity@3.940.0':
+    resolution: {integrity: sha512-9QLTIkDJHHaYL0nyymO41H8g3ui1yz6Y3GmAN1gYQa6plXisuFBnGAbmKVj7zNvjWaOKdF0dV3dd3AFKEDoJ/w==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/credential-providers@3.821.0':
-    resolution: {integrity: sha512-ZkV7KlKD+rSW/AP5zjSgMi+0xJ5TL5J6XVaP3IG5qyqBYTREJ8DbB/9YVUpYt2qtzpWUh/K43nmDEyfLd2YJog==}
+  '@aws-sdk/credential-providers@3.940.0':
+    resolution: {integrity: sha512-1Thn8cboeJSZlsAwqFmwE6Z7i2/qDM9RiyusUp4M6YLSRumeCTsxR/BokxprOqWVH4ZMMB9cDjpewfkw7myUfQ==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/middleware-host-header@3.821.0':
-    resolution: {integrity: sha512-xSMR+sopSeWGx5/4pAGhhfMvGBHioVBbqGvDs6pG64xfNwM5vq5s5v6D04e2i+uSTj4qGa71dLUs5I0UzAK3sw==}
+  '@aws-sdk/middleware-host-header@3.936.0':
+    resolution: {integrity: sha512-tAaObaAnsP1XnLGndfkGWFuzrJYuk9W0b/nLvol66t8FZExIAf/WdkT2NNAWOYxljVs++oHnyHBCxIlaHrzSiw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/middleware-logger@3.821.0':
-    resolution: {integrity: sha512-0cvI0ipf2tGx7fXYEEN5fBeZDz2RnHyb9xftSgUsEq7NBxjV0yTZfLJw6Za5rjE6snC80dRN8+bTNR1tuG89zA==}
+  '@aws-sdk/middleware-logger@3.936.0':
+    resolution: {integrity: sha512-aPSJ12d3a3Ea5nyEnLbijCaaYJT2QjQ9iW+zGh5QcZYXmOGWbKVyPSxmVOboZQG+c1M8t6d2O7tqrwzIq8L8qw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/middleware-recursion-detection@3.821.0':
-    resolution: {integrity: sha512-efmaifbhBoqKG3bAoEfDdcM8hn1psF+4qa7ykWuYmfmah59JBeqHLfz5W9m9JoTwoKPkFcVLWZxnyZzAnVBOIg==}
+  '@aws-sdk/middleware-recursion-detection@3.936.0':
+    resolution: {integrity: sha512-l4aGbHpXM45YNgXggIux1HgsCVAvvBoqHPkqLnqMl9QVapfuSTjJHfDYDsx1Xxct6/m7qSMUzanBALhiaGO2fA==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/middleware-user-agent@3.821.0':
-    resolution: {integrity: sha512-rw8q3TxygMg3VrofN04QyWVCCyGwz3bVthYmBZZseENPWG3Krz1OCKcyqjkTcAxMQlEywOske+GIiOasGKnJ3w==}
+  '@aws-sdk/middleware-user-agent@3.940.0':
+    resolution: {integrity: sha512-nJbLrUj6fY+l2W2rIB9P4Qvpiy0tnTdg/dmixRxrU1z3e8wBdspJlyE+AZN4fuVbeL6rrRrO/zxQC1bB3cw5IA==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/nested-clients@3.821.0':
-    resolution: {integrity: sha512-2IuHcUsWw44ftSEDYU4dvktTEqgyDvkOcfpoGC/UmT4Qo6TVCP3U5tWEGpNK9nN+7nLvekruxxG/jaMt5/oWVw==}
+  '@aws-sdk/nested-clients@3.940.0':
+    resolution: {integrity: sha512-x0mdv6DkjXqXEcQj3URbCltEzW6hoy/1uIL+i8gExP6YKrnhiZ7SzuB4gPls2UOpK5UqLiqXjhRLfBb1C9i4Dw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/region-config-resolver@3.821.0':
-    resolution: {integrity: sha512-t8og+lRCIIy5nlId0bScNpCkif8sc0LhmtaKsbm0ZPm3sCa/WhCbSZibjbZ28FNjVCV+p0D9RYZx0VDDbtWyjw==}
+  '@aws-sdk/region-config-resolver@3.936.0':
+    resolution: {integrity: sha512-wOKhzzWsshXGduxO4pqSiNyL9oUtk4BEvjWm9aaq6Hmfdoydq6v6t0rAGHWPjFwy9z2haovGRi3C8IxdMB4muw==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/token-providers@3.821.0':
-    resolution: {integrity: sha512-qJ7wgKhdxGbPg718zWXbCYKDuSWZNU3TSw64hPRW6FtbZrIyZxObpiTKC6DKwfsVoZZhHEoP/imGykN1OdOTJA==}
+  '@aws-sdk/token-providers@3.940.0':
+    resolution: {integrity: sha512-k5qbRe/ZFjW9oWEdzLIa2twRVIEx7p/9rutofyrRysrtEnYh3HAWCngAnwbgKMoiwa806UzcTRx0TjyEpnKcCg==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/types@3.821.0':
-    resolution: {integrity: sha512-Znroqdai1a90TlxGaJ+FK1lwC0fHpo97Xjsp5UKGR5JODYm7f9+/fF17ebO1KdoBr/Rm0UIFiF5VmI8ts9F1eA==}
+  '@aws-sdk/types@3.936.0':
+    resolution: {integrity: sha512-uz0/VlMd2pP5MepdrHizd+T+OKfyK4r3OA9JI+L/lPKg0YFQosdJNCKisr6o70E3dh8iMpFYxF1UN/4uZsyARg==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/util-endpoints@3.821.0':
-    resolution: {integrity: sha512-Uknt/zUZnLE76zaAAPEayOeF5/4IZ2puTFXvcSCWHsi9m3tqbb9UozlnlVqvCZLCRWfQryZQoG2W4XSS3qgk5A==}
+  '@aws-sdk/util-endpoints@3.936.0':
+    resolution: {integrity: sha512-0Zx3Ntdpu+z9Wlm7JKUBOzS9EunwKAb4KdGUQQxDqh5Lc3ta5uBoub+FgmVuzwnmBu9U1Os8UuwVTH0Lgu+P5w==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/util-locate-window@3.804.0':
-    resolution: {integrity: sha512-zVoRfpmBVPodYlnMjgVjfGoEZagyRF5IPn3Uo6ZvOZp24chnW/FRstH7ESDHDDRga4z3V+ElUQHKpFDXWyBW5A==}
+  '@aws-sdk/util-locate-window@3.893.0':
+    resolution: {integrity: sha512-T89pFfgat6c8nMmpI8eKjBcDcgJq36+m9oiXbcUzeU55MP9ZuGgBomGjGnHaEyF36jenW9gmg3NfZDm0AO2XPg==}
     engines: {node: '>=18.0.0'}
 
-  '@aws-sdk/util-user-agent-browser@3.821.0':
-    resolution: {integrity: sha512-irWZHyM0Jr1xhC+38OuZ7JB6OXMLPZlj48thElpsO1ZSLRkLZx5+I7VV6k3sp2yZ7BYbKz/G2ojSv4wdm7XTLw==}
+  '@aws-sdk/util-user-agent-browser@3.936.0':
+    resolution: {integrity: sha512-eZ/XF6NxMtu+iCma58GRNRxSq4lHo6zHQLOZRIeL/ghqYJirqHdenMOwrzPettj60KWlv827RVebP9oNVrwZbw==}
 
-  '@aws-sdk/util-user-agent-node@3.821.0':
-    resolution: {integrity: sha512-YwMXc9EvuzJgnLBTyiQly2juPujXwDgcMHB0iSN92tHe7Dd1jJ1feBmTgdClaaqCeHFUaFpw+3JU/ZUJ6LjR+A==}
+  '@aws-sdk/util-user-agent-node@3.940.0':
+    resolution: {integrity: sha512-dlD/F+L/jN26I8Zg5x0oDGJiA+/WEQmnSE27fi5ydvYnpfQLwThtQo9SsNS47XSR/SOULaaoC9qx929rZuo74A==}
     engines: {node: '>=18.0.0'}
     peerDependencies:
       aws-crt: '>=1.0.0'
@@ -1046,6 +1082,82 @@ packages:
       aws-crt:
         optional: true
 
+  '@aws-sdk/xml-builder@3.930.0':
+    resolution: {integrity: sha512-YIfkD17GocxdmlUVc3ia52QhcWuRIUJonbF8A2CYfcWNV3HzvAqpcPeC0bYUhkK+8e8YO1ARnLKZQE0TlwzorA==}
+    engines: {node: '>=18.0.0'}
+
+  '@aws/lambda-invoke-store@0.2.1':
+    resolution: {integrity: sha512-sIyFcoPZkTtNu9xFeEoynMef3bPJIAbOfUh+ueYcfhVl6xm2VRtMcMclSxmZCMnHHd4hlYKJeq/aggmBEWynww==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure-rest/core-client@2.5.1':
+    resolution: {integrity: sha512-EHaOXW0RYDKS5CFffnixdyRPak5ytiCtU7uXDcP/uiY+A6jFRwNGzzJBiznkCzvi5EYpY+YWinieqHb0oY916A==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/abort-controller@2.1.2':
+    resolution: {integrity: sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure/core-auth@1.10.1':
+    resolution: {integrity: sha512-ykRMW8PjVAn+RS6ww5cmK9U2CyH9p4Q88YJwvUslfuMmN98w/2rdGRLPqJYObapBCdzBVeDgYWdJnFPFb7qzpg==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/core-client@1.10.1':
+    resolution: {integrity: sha512-Nh5PhEOeY6PrnxNPsEHRr9eimxLwgLlpmguQaHKBinFYA/RU9+kOYVOQqOrTsCL+KSxrLLl1gD8Dk5BFW/7l/w==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/core-http-compat@2.3.1':
+    resolution: {integrity: sha512-az9BkXND3/d5VgdRRQVkiJb2gOmDU8Qcq4GvjtBmDICNiQ9udFmDk4ZpSB5Qq1OmtDJGlQAfBaS4palFsazQ5g==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/core-lro@2.7.2':
+    resolution: {integrity: sha512-0YIpccoX8m/k00O7mDDMdJpbr6mf1yWo2dfmxt5A8XVZVVMz2SSKaEbMCeJRvgQ0IaSlqhjT47p4hVIRRy90xw==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure/core-paging@1.6.2':
+    resolution: {integrity: sha512-YKWi9YuCU04B55h25cnOYZHxXYtEvQEbKST5vqRga7hWY9ydd3FZHdeQF8pyh+acWZvppw13M/LMGx0LABUVMA==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure/core-rest-pipeline@1.22.2':
+    resolution: {integrity: sha512-MzHym+wOi8CLUlKCQu12de0nwcq9k9Kuv43j4Wa++CsCpJwps2eeBQwD2Bu8snkxTtDKDx4GwjuR9E8yC8LNrg==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/core-tracing@1.3.1':
+    resolution: {integrity: sha512-9MWKevR7Hz8kNzzPLfX4EAtGM2b8mr50HPDBvio96bURP/9C+HjdH3sBlLSNNrvRAr5/k/svoH457gB5IKpmwQ==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/core-util@1.13.1':
+    resolution: {integrity: sha512-XPArKLzsvl0Hf0CaGyKHUyVgF7oDnhKoP85Xv6M4StF/1AhfORhZudHtOyf2s+FcbuQ9dPRAjB8J2KvRRMUK2A==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/identity@4.13.0':
+    resolution: {integrity: sha512-uWC0fssc+hs1TGGVkkghiaFkkS7NkTxfnCH+Hdg+yTehTpMcehpok4PgUKKdyCH+9ldu6FhiHRv84Ntqj1vVcw==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/keyvault-common@2.0.0':
+    resolution: {integrity: sha512-wRLVaroQtOqfg60cxkzUkGKrKMsCP6uYXAOomOIysSMyt1/YM0eUn9LqieAWM8DLcU4+07Fio2YGpPeqUbpP9w==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure/keyvault-keys@4.10.0':
+    resolution: {integrity: sha512-eDT7iXoBTRZ2n3fLiftuGJFD+yjkiB1GNqzU2KbY1TLYeXeSPVTVgn2eJ5vmRTZ11978jy2Kg2wI7xa9Tyr8ag==}
+    engines: {node: '>=18.0.0'}
+
+  '@azure/logger@1.3.0':
+    resolution: {integrity: sha512-fCqPIfOcLE+CGqGPd66c8bZpwAji98tZ4JI9i/mlTNTlsIWslCfpg48s/ypyLxZTump5sypjrKn2/kY7q8oAbA==}
+    engines: {node: '>=20.0.0'}
+
+  '@azure/msal-browser@4.26.2':
+    resolution: {integrity: sha512-F2U1mEAFsYGC5xzo1KuWc/Sy3CRglU9Ql46cDUx8x/Y3KnAIr1QAq96cIKCk/ZfnVxlvprXWRjNKoEpgLJXLhg==}
+    engines: {node: '>=0.8.0'}
+
+  '@azure/msal-common@15.13.2':
+    resolution: {integrity: sha512-cNwUoCk3FF8VQ7Ln/MdcJVIv3sF73/OT86cRH81ECsydh7F4CNfIo2OAx6Cegtg8Yv75x4506wN4q+Emo6erOA==}
+    engines: {node: '>=0.8.0'}
+
+  '@azure/msal-node@3.8.3':
+    resolution: {integrity: sha512-Ul7A4gwmaHzYWj2Z5xBDly/W8JSC1vnKgJ898zPMZr0oSf1ah0tiL15sytjycU/PMhDZAlkWtEL1+MzNMU6uww==}
+    engines: {node: '>=16'}
+
   '@babel/code-frame@7.10.4':
     resolution: {integrity: sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==}
 
@@ -1053,18 +1165,22 @@ packages:
     resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/compat-data@7.27.3':
-    resolution: {integrity: sha512-V42wFfx1ymFte+ecf6iXghnnP8kWTO+ZLXIyZq+1LAXHHvTZdVxicn4yiVYdYMGaCO3tmqub11AorKkv+iodqw==}
+  '@babel/compat-data@7.28.5':
+    resolution: {integrity: sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/core@7.27.4':
-    resolution: {integrity: sha512-bXYxrXFubeYdvB0NhD/NBB3Qi6aZeV20GOWVI47t2dkecCEoneR4NPVcb7abpXDEvejgrUfFtG6vG/zxAKmg+g==}
+  '@babel/core@7.28.5':
+    resolution: {integrity: sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/generator@7.27.3':
-    resolution: {integrity: sha512-xnlJYj5zepml8NXtjkG0WquFUv8RskFqyFcVgTBp5k+NaA/8uw/K+OSVf8AMGw5e9HKP2ETd5xpK5MLZQD6b4Q==}
+  '@babel/generator@7.28.5':
+    resolution: {integrity: sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/generator@8.0.0-rc.2':
+    resolution: {integrity: sha512-oCQ1IKPwkzCeJzAPb7Fv8rQ9k5+1sG8mf2uoHiMInPYvkRfrDJxbTIbH51U+jstlkghus0vAi3EBvkfvEsYNLQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
   '@babel/helper-annotate-as-pure@7.27.3':
     resolution: {integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==}
     engines: {node: '>=6.9.0'}
@@ -1073,33 +1189,37 @@ packages:
     resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-create-class-features-plugin@7.27.1':
-    resolution: {integrity: sha512-QwGAmuvM17btKU5VqXfb+Giw4JcN0hjuufz3DYnpeVDvZLAObloM77bhMXiqry3Iio+Ai4phVRDwl6WU10+r5A==}
+  '@babel/helper-create-class-features-plugin@7.28.5':
+    resolution: {integrity: sha512-q3WC4JfdODypvxArsJQROfupPBq9+lMwjKq7C33GhbFYJsufD0yd/ziwD+hJucLeWsnFPWZjsU2DNFqBPE7jwQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
-  '@babel/helper-create-regexp-features-plugin@7.27.1':
-    resolution: {integrity: sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ==}
+  '@babel/helper-create-regexp-features-plugin@7.28.5':
+    resolution: {integrity: sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
-  '@babel/helper-define-polyfill-provider@0.6.4':
-    resolution: {integrity: sha512-jljfR1rGnXXNWnmQg2K3+bvhkxB51Rl32QRaOTuwwjviGrHzIbSc8+x9CpraDtbT7mfyjXObULP4w/adunNwAw==}
+  '@babel/helper-define-polyfill-provider@0.6.5':
+    resolution: {integrity: sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==}
     peerDependencies:
       '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
 
-  '@babel/helper-member-expression-to-functions@7.27.1':
-    resolution: {integrity: sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==}
+  '@babel/helper-globals@7.28.0':
+    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-member-expression-to-functions@7.28.5':
+    resolution: {integrity: sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==}
     engines: {node: '>=6.9.0'}
 
   '@babel/helper-module-imports@7.27.1':
     resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-module-transforms@7.27.3':
-    resolution: {integrity: sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg==}
+  '@babel/helper-module-transforms@7.28.3':
+    resolution: {integrity: sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
@@ -1132,33 +1252,46 @@ packages:
     resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.27.1':
-    resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==}
+  '@babel/helper-string-parser@8.0.0-rc.2':
+    resolution: {integrity: sha512-noLx87RwlBEMrTzncWd/FvTxoJ9+ycHNg0n8yyYydIoDsLZuxknKgWRJUqcrVkNrJ74uGyhWQzQaS3q8xfGAhQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
+  '@babel/helper-validator-identifier@7.28.5':
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/helper-validator-identifier@8.0.0-rc.2':
+    resolution: {integrity: sha512-xExUBkuXWJjVuIbO7z6q7/BA9bgfJDEhVL0ggrggLMbg0IzCUWGT1hZGE8qUH7Il7/RD/a6cZ3AAFrrlp1LF/A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
   '@babel/helper-validator-option@7.27.1':
     resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-wrap-function@7.27.1':
-    resolution: {integrity: sha512-NFJK2sHUvrjo8wAU/nQTWU890/zB2jj0qBcCbZbbf+005cAsv6tMjXz31fBign6M5ov1o0Bllu+9nbqkfsjjJQ==}
+  '@babel/helper-wrap-function@7.28.3':
+    resolution: {integrity: sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helpers@7.27.4':
-    resolution: {integrity: sha512-Y+bO6U+I7ZKaM5G5rDUZiYfUvQPUibYmAFe7EnKdnKBbVXDZxvp+MWOH5gYciY0EPk4EScsuFMQBbEfpdRKSCQ==}
+  '@babel/helpers@7.28.4':
+    resolution: {integrity: sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==}
     engines: {node: '>=6.9.0'}
 
   '@babel/highlight@7.25.9':
     resolution: {integrity: sha512-llL88JShoCsth8fF8R4SJnIn+WLvR6ccFxu1H3FlMhDontdcmZWf2HgIZ7AIqV3Xcck1idlohrN4EUBQz6klbw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.27.4':
-    resolution: {integrity: sha512-BRmLHGwpUqLFR2jzx9orBuX/ABDkj2jLKOXrHDTN2aOKL+jFDDKaRNo9nyYsIl9h/UE/7lMKdDjKQQyxKKDZ7g==}
+  '@babel/parser@7.28.5':
+    resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  '@babel/plugin-proposal-decorators@7.27.1':
-    resolution: {integrity: sha512-DTxe4LBPrtFdsWzgpmbBKevg3e9PBy+dXRt19kSbucbZvL2uqtdqwwpluL1jfxYE0wIDTFp1nTy/q6gNLsxXrg==}
+  '@babel/parser@8.0.0-rc.2':
+    resolution: {integrity: sha512-29AhEtcq4x8Dp3T72qvUMZHx0OMXCj4Jy/TEReQa+KWLln524Cj1fWb3QFi0l/xSpptQBR6y9RNEXuxpFvwiUQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+
+  '@babel/plugin-proposal-decorators@7.28.0':
+    resolution: {integrity: sha512-zOiZqvANjWDUaUS9xMxbMcK/Zccztbe/6ikvUXaG9nsPH3w6qh5UaPGAnirI/WhIbZ8m3OHU0ReyPrknG+ZKeg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1289,8 +1422,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-async-generator-functions@7.27.1':
-    resolution: {integrity: sha512-eST9RrwlpaoJBDHShc+DS2SG4ATTi2MYNb4OxYkf3n+7eb49LWpnS+HSpVfW4x927qQwgk8A2hGNVaajAEw0EA==}
+  '@babel/plugin-transform-async-generator-functions@7.28.0':
+    resolution: {integrity: sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1301,8 +1434,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-block-scoping@7.27.3':
-    resolution: {integrity: sha512-+F8CnfhuLhwUACIJMLWnjz6zvzYM2r0yeIHKlbgfw7ml8rOMJsXNXV/hyRcb3nb493gRs4WvYpQAndWj/qQmkQ==}
+  '@babel/plugin-transform-block-scoping@7.28.5':
+    resolution: {integrity: sha512-45DmULpySVvmq9Pj3X9B+62Xe+DJGov27QravQJU1LLcapR6/10i+gYVAucGGJpHBp5mYxIMK4nDAT/QDLr47g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1313,8 +1446,14 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-classes@7.27.1':
-    resolution: {integrity: sha512-7iLhfFAubmpeJe/Wo2TVuDrykh/zlWXLzPNdL0Jqn/Xu8R3QQ8h9ff8FQoISZOsw74/HFqFI7NX63HN7QFIHKA==}
+  '@babel/plugin-transform-class-static-block@7.28.3':
+    resolution: {integrity: sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.12.0
+
+  '@babel/plugin-transform-classes@7.28.4':
+    resolution: {integrity: sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1325,8 +1464,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-destructuring@7.27.3':
-    resolution: {integrity: sha512-s4Jrok82JpiaIprtY2nHsYmrThKvvwgHwjgd7UMiYhZaN0asdXNLr0y+NjTfkA7SyQE5i2Fb7eawUOZmLvyqOA==}
+  '@babel/plugin-transform-destructuring@7.28.5':
+    resolution: {integrity: sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1361,8 +1500,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-logical-assignment-operators@7.27.1':
-    resolution: {integrity: sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw==}
+  '@babel/plugin-transform-logical-assignment-operators@7.28.5':
+    resolution: {integrity: sha512-axUuqnUTBuXyHGcJEVVh9pORaN6wC5bYfE7FGzPiaWa3syib9m7g+/IT/4VgCOe2Upef43PHzeAvcrVek6QuuA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1391,8 +1530,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-object-rest-spread@7.27.3':
-    resolution: {integrity: sha512-7ZZtznF9g4l2JCImCo5LNKFHB5eXnN39lLtLY5Tg+VkR0jwOt7TBciMckuiQIOIW7L5tkQOCh3bVGYeXgMx52Q==}
+  '@babel/plugin-transform-object-rest-spread@7.28.4':
+    resolution: {integrity: sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1403,14 +1542,14 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-optional-chaining@7.27.1':
-    resolution: {integrity: sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg==}
+  '@babel/plugin-transform-optional-chaining@7.28.5':
+    resolution: {integrity: sha512-N6fut9IZlPnjPwgiQkXNhb+cT8wQKFlJNqcZkWlcTqkcqx6/kU4ynGmLFoa4LViBSirn05YAwk+sQBbPfxtYzQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-parameters@7.27.1':
-    resolution: {integrity: sha512-018KRk76HWKeZ5l4oTj2zPpSh+NbGdt0st5S6x0pga6HgrjBOJb24mMDHorFopOOd6YHkLgOZ+zaCjZGPO4aKg==}
+  '@babel/plugin-transform-parameters@7.27.7':
+    resolution: {integrity: sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1427,8 +1566,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-react-display-name@7.27.1':
-    resolution: {integrity: sha512-p9+Vl3yuHPmkirRrg021XiP+EETmPMQTLr6Ayjj85RLNEbb3Eya/4VI0vAdzQG9SEAl2Lnt7fy5lZyMzjYoZQQ==}
+  '@babel/plugin-transform-react-display-name@7.28.0':
+    resolution: {integrity: sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1463,14 +1602,14 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-regenerator@7.27.4':
-    resolution: {integrity: sha512-Glp/0n8xuj+E1588otw5rjJkTXfzW7FjH3IIUrfqiZOPQCd2vbg8e+DQE8jK9g4V5/zrxFW+D9WM9gboRPELpQ==}
+  '@babel/plugin-transform-regenerator@7.28.4':
+    resolution: {integrity: sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-runtime@7.27.4':
-    resolution: {integrity: sha512-D68nR5zxU64EUzV8i7T3R5XP0Xhrou/amNnddsRQssx6GrTLdZl1rLxyjtVZBd+v/NVX4AbTPOB5aU8thAZV1A==}
+  '@babel/plugin-transform-runtime@7.28.5':
+    resolution: {integrity: sha512-20NUVgOrinudkIBzQ2bNxP08YpKprUkRTiRSd2/Z5GOdPImJGkoN4Z7IQe1T5AdyKI1i5L6RBmluqdSzvaq9/w==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1493,8 +1632,8 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/plugin-transform-typescript@7.27.1':
-    resolution: {integrity: sha512-Q5sT5+O4QUebHdbwKedFBEwRLb02zJ7r4A5Gg2hUoLuU3FjdMcyqcywqUrLCaDsFCxzokf7u9kuy7qz51YUuAg==}
+  '@babel/plugin-transform-typescript@7.28.5':
+    resolution: {integrity: sha512-x2Qa+v/CuEoX7Dr31iAfr0IhInrVOWZU/2vJMJ00FOR/2nM0BcBEclpaf9sWCDc+v5e9dMrhSH8/atq/kX7+bA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -1505,91 +1644,258 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/preset-react@7.27.1':
-    resolution: {integrity: sha512-oJHWh2gLhU9dW9HHr42q0cI0/iHHXTLGe39qvpAZZzagHy0MzYLCnCVV0symeRvzmjHyVU7mw2K06E6u/JwbhA==}
+  '@babel/preset-react@7.28.5':
+    resolution: {integrity: sha512-Z3J8vhRq7CeLjdC58jLv4lnZ5RKFUJWqH5emvxmv9Hv3BD1T9R/Im713R4MTKwvFaV74ejZ3sM01LyEKk4ugNQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/preset-typescript@7.27.1':
-    resolution: {integrity: sha512-l7WfQfX0WK4M0v2RudjuQK4u99BS6yLHYEmdtVPP7lKV013zr9DygFuWNlnbvQ9LR+LS0Egz/XAvGx5U9MX0fQ==}
+  '@babel/preset-typescript@7.28.5':
+    resolution: {integrity: sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
-  '@babel/runtime@7.27.4':
-    resolution: {integrity: sha512-t3yaEOuGu9NlIZ+hIeGbBjFtZT7j2cb2tg0fuaJKeGotchRjjLfrBA9Kwf8quhpP1EUuxModQg04q/mBwyg8uA==}
+  '@babel/runtime@7.28.4':
+    resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==}
     engines: {node: '>=6.9.0'}
 
   '@babel/template@7.27.2':
     resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/traverse@7.27.4':
-    resolution: {integrity: sha512-oNcu2QbHqts9BtOWJosOVJapWjBDSxGCpFvikNR5TGDYDQf3JwpIoMzIKrvfoti93cLfPJEG4tH9SPVeyCGgdA==}
+  '@babel/traverse@7.28.5':
+    resolution: {integrity: sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.27.3':
-    resolution: {integrity: sha512-Y1GkI4ktrtvmawoSq+4FCVHNryea6uR+qUQy0AGxLSsjCX0nVmkYQMBLHDkXZuo5hGx7eYdnIaslsdBFm7zbUw==}
+  '@babel/types@7.28.5':
+    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
     engines: {node: '>=6.9.0'}
 
+  '@babel/types@8.0.0-rc.2':
+    resolution: {integrity: sha512-91gAaWRznDwSX4E2tZ1YjBuIfnQVOFDCQ2r0Toby0gu4XEbyF623kXLMA8d4ZbCu+fINcrudkmEcwSUHgDDkNw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
   '@balena/dockerignore@1.0.2':
     resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==}
 
-  '@cloudflare/workers-types@4.20250603.0':
-    resolution: {integrity: sha512-62g5wVdXiRRu9sfC9fmwgZfE9W0rWy2txlgRKn1Xx1NWHshSdh4RWMX6gO4EBKPqgwlHKaMuSPZ1qM0hHsq7bA==}
+  '@braidai/lang@1.1.2':
+    resolution: {integrity: sha512-qBcknbBufNHlui137Hft8xauQMTZDKdophmLFv05r2eNmdIv/MlPuP4TdUknHG68UdWLgVZwgxVe735HzJNIwA==}
+
+  '@cloudflare/workers-types@4.20251126.0':
+    resolution: {integrity: sha512-DSeI1Q7JYmh5/D/tw5eZCjrKY34v69rwj63hHt60nSQW5QLwWCbj/lLtNz9f2EPa+JCACwpLXHgCXfzJ29x66w==}
+
+  '@cloudflare/workers-types@4.20260621.1':
+    resolution: {integrity: sha512-c4xrf4shZdDOK1ihh1UKzlS/3MDYiGThT/Oqr4Y3qR9NLCSNzHB7rt+Vk/LOp0ZSNjA+7WNJEQsOhpiQtpT2GA==}
 
   '@colors/colors@1.5.0':
     resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
     engines: {node: '>=0.1.90'}
 
+  '@craftzdog/react-native-buffer@6.1.1':
+    resolution: {integrity: sha512-YXJ0Jr4V+Hk2CZXpQw0A0NJeuiW2Rv6rAAutJCZ2k/JG13vLsppUibkJ8exSMxODtH9yJUrLiR96rilG3pFZ4Q==}
+
   '@cspotcode/source-map-support@0.8.1':
     resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
 
-  '@dprint/darwin-arm64@0.46.3':
-    resolution: {integrity: sha512-1ycDpGvclGHF3UG5V6peymPDg6ouNTqM6BjhVELQ6zwr+X98AMhq/1slgO8hwHtPcaS5qhTAS+PkzOmBJRegow==}
+  '@dprint/darwin-arm64@0.50.2':
+    resolution: {integrity: sha512-4d08INZlTxbPW9LK9W8+93viN543/qA2Kxn4azVnPW/xCb2Im03UqJBz8mMm3nJZdtNnK3uTVG3ib1VW+XJisw==}
     cpu: [arm64]
     os: [darwin]
 
-  '@dprint/darwin-x64@0.46.3':
-    resolution: {integrity: sha512-v5IpLmrY836Q5hJAxZuX097ZNQvoZgO6JKO4bK4l6XDhhHAw2XTIUr41+FM5r36ENxyASMk0NpHjhcHtih3o0g==}
+  '@dprint/darwin-x64@0.50.2':
+    resolution: {integrity: sha512-ZXWPBwdLojhdBATq+bKwJvB7D8bIzrD6eR/Xuq9UYE7evQazUiR069d9NPF0iVuzTo6wNf9ub9SXI7qDl11EGA==}
     cpu: [x64]
     os: [darwin]
 
-  '@dprint/linux-arm64-glibc@0.46.3':
-    resolution: {integrity: sha512-9P13g1vgV8RfQH2qBGa8YAfaOeWA42RIhj7lmWRpkDFtwau96reMKwnBBn8bHUnc5e6bSsbPUOMb/X1KMUKz/g==}
+  '@dprint/linux-arm64-glibc@0.50.2':
+    resolution: {integrity: sha512-marxQzRw8atXAnaawwZHeeUaaAVewrGTlFKKcDASGyjPBhc23J5fHPUPremm8xCbgYZyTlokzrV8/1rDRWhJcw==}
     cpu: [arm64]
     os: [linux]
 
-  '@dprint/linux-arm64-musl@0.46.3':
-    resolution: {integrity: sha512-AAcdcMSZ6DEIoY9E0xQHjkZP+THP7EWsQge4TWzglSIjzn31YltglHAGYFcLB4CTJYpF0NsFDNFktzgkO+s0og==}
+  '@dprint/linux-arm64-musl@0.50.2':
+    resolution: {integrity: sha512-oGDq44ydzo0ZkJk6RHcUzUN5sOMT5HC6WA8kHXI6tkAsLUkaLO2DzZFfW4aAYZUn+hYNpQfQD8iGew0sjkyLyg==}
     cpu: [arm64]
     os: [linux]
 
-  '@dprint/linux-x64-glibc@0.46.3':
-    resolution: {integrity: sha512-c5cQ3G1rC64nBZ8Pd2LGWwzkEk4D7Ax9NrBbwYmNPvs6mFbGlJPC1+RD95x2WwIrIlMIciLG+Kxmt25PzBphmg==}
+  '@dprint/linux-riscv64-glibc@0.50.2':
+    resolution: {integrity: sha512-QMmZoZYWsXezDcC03fBOwPfxhTpPEyHqutcgJ0oauN9QcSXGji9NSZITMmtLz2Ki3T1MIvdaLd1goGzNSvNqTQ==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@dprint/linux-x64-glibc@0.50.2':
+    resolution: {integrity: sha512-KMeHEzb4teQJChTgq8HuQzc+reRNDnarOTGTQovAZ9WNjOtKLViftsKWW5HsnRHtP5nUIPE9rF1QLjJ/gUsqvw==}
     cpu: [x64]
     os: [linux]
 
-  '@dprint/linux-x64-musl@0.46.3':
-    resolution: {integrity: sha512-ONtk2QtLcV0TqWOCOqzUFQixgk3JC+vnJLB5L6tQwT7BX5LzeircfE/1f4dg459iqejNC9MBXZkHnXqabvWSow==}
+  '@dprint/linux-x64-musl@0.50.2':
+    resolution: {integrity: sha512-qM37T7H69g5coBTfE7SsA+KZZaRBky6gaUhPgAYxW+fOsoVtZSVkXtfTtQauHTpqqOEtbxfCtum70Hz1fr1teg==}
     cpu: [x64]
     os: [linux]
 
-  '@dprint/win32-x64@0.46.3':
-    resolution: {integrity: sha512-xvj4DSEilf0gGdT7CqnwNEgfWNuWqT6eIBxHDEUbmcn1vZ7IwirtqRq/nm3lmYtQaJ4EbtMQZvACHZwxC7G96w==}
+  '@dprint/win32-arm64@0.50.2':
+    resolution: {integrity: sha512-kuGVHGoxLwssVDsodefUIYQRoO2fQncurH/xKgXiZwMPOSzFcgUzYJQiyqmJEp+PENhO9VT1hXUHZtlyCAWBUQ==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@dprint/win32-x64@0.50.2':
+    resolution: {integrity: sha512-N3l9k31c3IMfVXqL0L6ygIhJFvCIrfQ+Z5Jph6RnCcBO6oDYWeYhAv/qBk1vLsF2y/e79TKsR1tvaEwnrQ03XA==}
     cpu: [x64]
     os: [win32]
 
   '@drizzle-team/brocli@0.10.2':
     resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==}
 
-  '@drizzle-team/studio@0.0.5':
-    resolution: {integrity: sha512-ps5qF0tMxWRVu+V5gvCRrQNqlY92aTnIKdq27gm9LZMSdaKYZt6AVvSK1dlUMzs6Rt0Jm80b+eWct6xShBKhIw==}
+  '@drizzle-team/brocli@0.12.0':
+    resolution: {integrity: sha512-mlUE+rZ8CatQekLhnaiN91Iemdd+e2gFKooGlnRB3oPTL3VghLfX24dx7HrzMNeC1JrIB/0kpsfyty3f5HNfxQ==}
+
+  '@duckdb/node-api@1.5.0-r.1':
+    resolution: {integrity: sha512-VjvjqlCyqUJ22bydG/+9Jj5l0CEvx9QUn1SATBkKFY0+x6n4uHzt0kp/FKwXK9LNduXX6KCKtdF+6v5BcHScfA==}
+
+  '@duckdb/node-bindings-darwin-arm64@1.5.0-r.1':
+    resolution: {integrity: sha512-s7CB9Y10f3dg2W4jdp6zipogxamq1pPQVt/r+YigZrHqk7HvytUeRH1VOI/3wuGTTlR8mAnIXj2MJIrmMujX4w==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@duckdb/node-bindings-darwin-x64@1.5.0-r.1':
+    resolution: {integrity: sha512-2KxnGvg9o/Y915hwr1Mpb6Cbfrvt/w+/Fv0RZ2VXeQuxqNCMOoJd/7yQ8ffWXJRuOFU/vRmsR88koIjW+yJibA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@duckdb/node-bindings-linux-arm64@1.5.0-r.1':
+    resolution: {integrity: sha512-FpmcfJqhKoInjEa1o5dsWPQAFWYgu1eZgJP94nz6d+cKfdXEZKT6vGIwokZRzDqKLG1ZAOBZO2IhxzmW8IbbfA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@duckdb/node-bindings-linux-x64@1.5.0-r.1':
+    resolution: {integrity: sha512-A4Zgsaq6szEKiMyF1eWkoaHw0OMA0a8Zl8Ev0GcZSRjI4iGHgBQ1f/Zi/w3QKyz7OtjIiZ+pQ1XYyG4QoF6OKA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@duckdb/node-bindings-win32-arm64@1.5.0-r.1':
+    resolution: {integrity: sha512-ctCJ2HWpyiN3FNiCQ40RWALZLwKtJ8Aq4Anen2ush1I0a2E52T//jitLzl7DcX0quzew5eci1MQ+H5T1nVhzFA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@duckdb/node-bindings-win32-x64@1.5.0-r.1':
+    resolution: {integrity: sha512-725LoefejBlyG/bUcMfqVJkZ8KnZRLa0xOkszw9Q+V5G26iagJY3dgtGJAvwTeVJvXigSEVc5yD9Cj6kWR67vA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@duckdb/node-bindings@1.5.0-r.1':
+    resolution: {integrity: sha512-ViyoHROp0HhQ0ATT8z6h7SV6vEOxNjN8mJcdkst+3rJIU3Rd/gKs8exJO23LxFsjBuAiDpndpEwFihTAdfwJZg==}
+
+  '@effect/experimental@0.57.8':
+    resolution: {integrity: sha512-3NYIH+ujSR+aBiQ5KqG8RviIdSWORjQUVQbLq8KSTT/DExRgsa8Sw+8IWiGeaaneVQd/PBpNnNqvncxhv+JGHw==}
+    peerDependencies:
+      '@effect/platform': ^0.93.5
+      effect: ^3.19.8
+      ioredis: ^5
+      lmdb: ^3
+    peerDependenciesMeta:
+      ioredis:
+        optional: true
+      lmdb:
+        optional: true
+
+  '@effect/platform@0.93.5':
+    resolution: {integrity: sha512-31ikgJRAG8py26SEIjyrgaPlEJ+JYqOsGP7g4WHFRIYxGFwFX/OrlBrW0+mRISCfeDR1BUztaFyIZyRPfBRvcw==}
+    peerDependencies:
+      effect: ^3.19.8
+
+  '@effect/sql-d1@4.0.0-beta.83':
+    resolution: {integrity: sha512-RqhwSJsL6UzaGo9rqKOK0259Lc+VZsew/S6g8o44pQ5LVPm5I75ejoaqsc2MQrHuMdd6rlWL6Kc/Ua1SaGIDxw==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-libsql@4.0.0-beta.83':
+    resolution: {integrity: sha512-rqKPHZ0Jqdho4Gdd0r9R7VgrJ7klDMsEeYLPrggU6UA7BT80oTXTmR0Rh0PPpi+LL3jwTtobHDqj3e6/fiiPMg==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-mysql2@4.0.0-beta.83':
+    resolution: {integrity: sha512-+8LYZDSDQcS4Vmy64GyldhsoyJeNjM0SNMMTV8pN7FYFwthRbEijFUNcUzUYz8TiDce2e62ma+KkPZf9jiyPsQ==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-pg@0.49.7':
+    resolution: {integrity: sha512-7yGHEcSTj3jo7EZxC4cEXUno+/pgbEjjY5WLrx0Nfta07Vu6CTplcSOQ5KA24HwkclBidNwfX7LWghc04kAgUQ==}
+    peerDependencies:
+      '@effect/experimental': ^0.57.5
+      '@effect/platform': ^0.93.4
+      '@effect/sql': ^0.48.1
+      effect: ^3.19.6
+
+  '@effect/sql-pg@4.0.0-beta.83':
+    resolution: {integrity: sha512-IfcShHsnYLVQpXv9k/TFBJIKTJU6aNv5NnHZsG3qs/D3M3oxc4ntLyPyKyY+45IQNS5lI5pB1qsEAXPi0CC6WQ==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-pglite@4.0.0-beta.83':
+    resolution: {integrity: sha512-fAO8nhQfTcwKZn9Y9t4Kdwi0cqd/uDRiutHcdmQkryDi94QFIZecoRWZmVpRVk97pul/VtbnjVj7gTTGf8iB9Q==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-sqlite-bun@4.0.0-beta.83':
+    resolution: {integrity: sha512-6OaxLsWffxkh9pXYUSyj/AxjVb9URY2rG9U6atjxClWy30Jx77R9Pm3Rrc7cQ63kQurePavEw1bQbzQ/SILiQQ==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-sqlite-do@4.0.0-beta.83':
+    resolution: {integrity: sha512-kRoJsQZ+veRUiMVlzqt8N4QQeZjXiBAJM6Jdb8Sd4l5cblIL93dUfy6aFqTE/zKTSvsVps8ghjr7+wYT/g5xag==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-sqlite-node@4.0.0-beta.83':
+    resolution: {integrity: sha512-7xkd2/0DjP/6Dp9QEhfduy1MHowu4DHhdznzXSik3Z18LcYkZ+LcNRzCfCrLufhy2pvXJEIDSsqIta9LFFP8Lg==}
+    peerDependencies:
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql-sqlite-wasm@4.0.0-beta.83':
+    resolution: {integrity: sha512-25JvSLg7PTkdT6Zpnl8UfciOCkO2iQy1A3fjrsAFYkmsCgFn+OjtyKGQW+xEMm5h6u/UZVyoon6l2U3P9+t7EA==}
+    peerDependencies:
+      '@effect/wa-sqlite': ^0.1.2
+      effect: ^4.0.0-beta.83
+
+  '@effect/sql@0.48.5':
+    resolution: {integrity: sha512-OhmqA4zaajZc5F4M30W/5UjnjnhW+Z3MIbdTn6KihYOywXG+uSD2RVDhW4HiMWlysD4jv2mapbYSzi+IowYqOg==}
+    peerDependencies:
+      '@effect/experimental': ^0.57.7
+      '@effect/platform': ^0.93.5
+      effect: ^3.19.8
+
+  '@effect/vitest@4.0.0-beta.58':
+    resolution: {integrity: sha512-smbZFxaznzlvbzsfq8r8lCZy6Ym3aAMv5LxmuZSm2DMcyL07jcg0qOrs7FCGvqneUvCEKkkZ8tkcEporBduH7A==}
+    peerDependencies:
+      effect: ^4.0.0-beta.58
+      vitest: ^3.0.0 || ^4.0.0
+
+  '@effect/wa-sqlite@0.1.2':
+    resolution: {integrity: sha512-2JvJ9BDkBOwfeY/gXsC0XwEKC0AwisP2W5ABJ6mx14QyXTK12MGDIybDlHieuZt1TEFSMiKfpg7yyqyRWRooJQ==}
+
+  '@electric-sql/pglite-postgis@0.0.8':
+    resolution: {integrity: sha512-ShtsBFpxb5JDTCbMSpEAcAHIwFmxrXsQi7fKVeLWd8e7seTlSeBcjt3itpFDFXCqhIcb5EKEfZCgVJH3d3E1Lg==}
+    peerDependencies:
+      '@electric-sql/pglite': 0.4.6
+
+  '@electric-sql/pglite@0.4.6':
+    resolution: {integrity: sha512-qmlmfN8UyKCee35qkV0r/MBp+Znl8FjBz7OpoglNvww3GJpw0/DLP0o1ZymvLNmcD5DTLOQdzKPtF8Hd3mdl1w==}
+
+  '@emnapi/core@1.7.1':
+    resolution: {integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==}
+
+  '@emnapi/core@1.8.1':
+    resolution: {integrity: sha512-AvT9QFpxK0Zd8J0jopedNm+w/2fIzvtPKPjqyw9jwvBaReTTqPBk9Hixaz7KbjimP+QNz605/XnjFcDAL2pqBg==}
+
+  '@emnapi/runtime@1.7.1':
+    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
+
+  '@emnapi/runtime@1.8.1':
+    resolution: {integrity: sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg==}
 
-  '@electric-sql/pglite@0.2.12':
-    resolution: {integrity: sha512-J/X42ujcoFEbOkgRyoNqZB5qcqrnJRWVlwpH3fKYoJkTz49N91uAK/rDSSG/85WRas9nC9mdV4FnMTxnQWE/rw==}
+  '@emnapi/wasi-threads@1.1.0':
+    resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
 
   '@esbuild-kit/core-utils@3.3.2':
     resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==}
@@ -1599,14 +1905,20 @@ packages:
     resolution: {integrity: sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==}
     deprecated: 'Merged into tsx: https://tsx.is'
 
-  '@esbuild/aix-ppc64@0.19.12':
-    resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==}
+  '@esbuild/aix-ppc64@0.21.5':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
     engines: {node: '>=12'}
     cpu: [ppc64]
     os: [aix]
 
-  '@esbuild/aix-ppc64@0.25.5':
-    resolution: {integrity: sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==}
+  '@esbuild/aix-ppc64@0.25.12':
+    resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/aix-ppc64@0.27.0':
+    resolution: {integrity: sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==}
     engines: {node: '>=18'}
     cpu: [ppc64]
     os: [aix]
@@ -1617,14 +1929,20 @@ packages:
     cpu: [arm64]
     os: [android]
 
-  '@esbuild/android-arm64@0.19.12':
-    resolution: {integrity: sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==}
+  '@esbuild/android-arm64@0.21.5':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [android]
 
-  '@esbuild/android-arm64@0.25.5':
-    resolution: {integrity: sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg==}
+  '@esbuild/android-arm64@0.25.12':
+    resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm64@0.27.0':
+    resolution: {integrity: sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [android]
@@ -1635,14 +1953,20 @@ packages:
     cpu: [arm]
     os: [android]
 
-  '@esbuild/android-arm@0.19.12':
-    resolution: {integrity: sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==}
+  '@esbuild/android-arm@0.21.5':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
     engines: {node: '>=12'}
     cpu: [arm]
     os: [android]
 
-  '@esbuild/android-arm@0.25.5':
-    resolution: {integrity: sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA==}
+  '@esbuild/android-arm@0.25.12':
+    resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.0':
+    resolution: {integrity: sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==}
     engines: {node: '>=18'}
     cpu: [arm]
     os: [android]
@@ -1653,14 +1977,20 @@ packages:
     cpu: [x64]
     os: [android]
 
-  '@esbuild/android-x64@0.19.12':
-    resolution: {integrity: sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==}
+  '@esbuild/android-x64@0.21.5':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [android]
 
-  '@esbuild/android-x64@0.25.5':
-    resolution: {integrity: sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw==}
+  '@esbuild/android-x64@0.25.12':
+    resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.0':
+    resolution: {integrity: sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [android]
@@ -1671,14 +2001,20 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
-  '@esbuild/darwin-arm64@0.19.12':
-    resolution: {integrity: sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==}
+  '@esbuild/darwin-arm64@0.21.5':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [darwin]
 
-  '@esbuild/darwin-arm64@0.25.5':
-    resolution: {integrity: sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ==}
+  '@esbuild/darwin-arm64@0.25.12':
+    resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-arm64@0.27.0':
+    resolution: {integrity: sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [darwin]
@@ -1689,14 +2025,20 @@ packages:
     cpu: [x64]
     os: [darwin]
 
-  '@esbuild/darwin-x64@0.19.12':
-    resolution: {integrity: sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==}
+  '@esbuild/darwin-x64@0.21.5':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [darwin]
 
-  '@esbuild/darwin-x64@0.25.5':
-    resolution: {integrity: sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ==}
+  '@esbuild/darwin-x64@0.25.12':
+    resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.0':
+    resolution: {integrity: sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [darwin]
@@ -1707,14 +2049,20 @@ packages:
     cpu: [arm64]
     os: [freebsd]
 
-  '@esbuild/freebsd-arm64@0.19.12':
-    resolution: {integrity: sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==}
+  '@esbuild/freebsd-arm64@0.21.5':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [freebsd]
 
-  '@esbuild/freebsd-arm64@0.25.5':
-    resolution: {integrity: sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw==}
+  '@esbuild/freebsd-arm64@0.25.12':
+    resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-arm64@0.27.0':
+    resolution: {integrity: sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [freebsd]
@@ -1725,14 +2073,20 @@ packages:
     cpu: [x64]
     os: [freebsd]
 
-  '@esbuild/freebsd-x64@0.19.12':
-    resolution: {integrity: sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==}
+  '@esbuild/freebsd-x64@0.21.5':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [freebsd]
 
-  '@esbuild/freebsd-x64@0.25.5':
-    resolution: {integrity: sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw==}
+  '@esbuild/freebsd-x64@0.25.12':
+    resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.0':
+    resolution: {integrity: sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [freebsd]
@@ -1743,14 +2097,20 @@ packages:
     cpu: [arm64]
     os: [linux]
 
-  '@esbuild/linux-arm64@0.19.12':
-    resolution: {integrity: sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==}
+  '@esbuild/linux-arm64@0.21.5':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [linux]
 
-  '@esbuild/linux-arm64@0.25.5':
-    resolution: {integrity: sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg==}
+  '@esbuild/linux-arm64@0.25.12':
+    resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm64@0.27.0':
+    resolution: {integrity: sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [linux]
@@ -1761,14 +2121,20 @@ packages:
     cpu: [arm]
     os: [linux]
 
-  '@esbuild/linux-arm@0.19.12':
-    resolution: {integrity: sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==}
+  '@esbuild/linux-arm@0.21.5':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
     engines: {node: '>=12'}
     cpu: [arm]
     os: [linux]
 
-  '@esbuild/linux-arm@0.25.5':
-    resolution: {integrity: sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw==}
+  '@esbuild/linux-arm@0.25.12':
+    resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.0':
+    resolution: {integrity: sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==}
     engines: {node: '>=18'}
     cpu: [arm]
     os: [linux]
@@ -1779,14 +2145,20 @@ packages:
     cpu: [ia32]
     os: [linux]
 
-  '@esbuild/linux-ia32@0.19.12':
-    resolution: {integrity: sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==}
+  '@esbuild/linux-ia32@0.21.5':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [linux]
 
-  '@esbuild/linux-ia32@0.25.5':
-    resolution: {integrity: sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA==}
+  '@esbuild/linux-ia32@0.25.12':
+    resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.0':
+    resolution: {integrity: sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==}
     engines: {node: '>=18'}
     cpu: [ia32]
     os: [linux]
@@ -1803,14 +2175,20 @@ packages:
     cpu: [loong64]
     os: [linux]
 
-  '@esbuild/linux-loong64@0.19.12':
-    resolution: {integrity: sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==}
+  '@esbuild/linux-loong64@0.21.5':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
     engines: {node: '>=12'}
     cpu: [loong64]
     os: [linux]
 
-  '@esbuild/linux-loong64@0.25.5':
-    resolution: {integrity: sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg==}
+  '@esbuild/linux-loong64@0.25.12':
+    resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.0':
+    resolution: {integrity: sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==}
     engines: {node: '>=18'}
     cpu: [loong64]
     os: [linux]
@@ -1821,14 +2199,20 @@ packages:
     cpu: [mips64el]
     os: [linux]
 
-  '@esbuild/linux-mips64el@0.19.12':
-    resolution: {integrity: sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==}
+  '@esbuild/linux-mips64el@0.21.5':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
     engines: {node: '>=12'}
     cpu: [mips64el]
     os: [linux]
 
-  '@esbuild/linux-mips64el@0.25.5':
-    resolution: {integrity: sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg==}
+  '@esbuild/linux-mips64el@0.25.12':
+    resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.0':
+    resolution: {integrity: sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==}
     engines: {node: '>=18'}
     cpu: [mips64el]
     os: [linux]
@@ -1839,14 +2223,20 @@ packages:
     cpu: [ppc64]
     os: [linux]
 
-  '@esbuild/linux-ppc64@0.19.12':
-    resolution: {integrity: sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==}
+  '@esbuild/linux-ppc64@0.21.5':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
     engines: {node: '>=12'}
     cpu: [ppc64]
     os: [linux]
 
-  '@esbuild/linux-ppc64@0.25.5':
-    resolution: {integrity: sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ==}
+  '@esbuild/linux-ppc64@0.25.12':
+    resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.0':
+    resolution: {integrity: sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==}
     engines: {node: '>=18'}
     cpu: [ppc64]
     os: [linux]
@@ -1857,14 +2247,20 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
-  '@esbuild/linux-riscv64@0.19.12':
-    resolution: {integrity: sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==}
+  '@esbuild/linux-riscv64@0.21.5':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
     engines: {node: '>=12'}
     cpu: [riscv64]
     os: [linux]
 
-  '@esbuild/linux-riscv64@0.25.5':
-    resolution: {integrity: sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA==}
+  '@esbuild/linux-riscv64@0.25.12':
+    resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.0':
+    resolution: {integrity: sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==}
     engines: {node: '>=18'}
     cpu: [riscv64]
     os: [linux]
@@ -1875,14 +2271,20 @@ packages:
     cpu: [s390x]
     os: [linux]
 
-  '@esbuild/linux-s390x@0.19.12':
-    resolution: {integrity: sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==}
+  '@esbuild/linux-s390x@0.21.5':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
     engines: {node: '>=12'}
     cpu: [s390x]
     os: [linux]
 
-  '@esbuild/linux-s390x@0.25.5':
-    resolution: {integrity: sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ==}
+  '@esbuild/linux-s390x@0.25.12':
+    resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.0':
+    resolution: {integrity: sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==}
     engines: {node: '>=18'}
     cpu: [s390x]
     os: [linux]
@@ -1893,20 +2295,32 @@ packages:
     cpu: [x64]
     os: [linux]
 
-  '@esbuild/linux-x64@0.19.12':
-    resolution: {integrity: sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==}
+  '@esbuild/linux-x64@0.21.5':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [linux]
 
-  '@esbuild/linux-x64@0.25.5':
-    resolution: {integrity: sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw==}
+  '@esbuild/linux-x64@0.25.12':
+    resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
-  '@esbuild/netbsd-arm64@0.25.5':
-    resolution: {integrity: sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw==}
+  '@esbuild/linux-x64@0.27.0':
+    resolution: {integrity: sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.25.12':
+    resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-arm64@0.27.0':
+    resolution: {integrity: sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [netbsd]
@@ -1917,20 +2331,32 @@ packages:
     cpu: [x64]
     os: [netbsd]
 
-  '@esbuild/netbsd-x64@0.19.12':
-    resolution: {integrity: sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==}
+  '@esbuild/netbsd-x64@0.21.5':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [netbsd]
 
-  '@esbuild/netbsd-x64@0.25.5':
-    resolution: {integrity: sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ==}
+  '@esbuild/netbsd-x64@0.25.12':
+    resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [netbsd]
 
-  '@esbuild/openbsd-arm64@0.25.5':
-    resolution: {integrity: sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw==}
+  '@esbuild/netbsd-x64@0.27.0':
+    resolution: {integrity: sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.25.12':
+    resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-arm64@0.27.0':
+    resolution: {integrity: sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [openbsd]
@@ -1941,32 +2367,56 @@ packages:
     cpu: [x64]
     os: [openbsd]
 
-  '@esbuild/openbsd-x64@0.19.12':
-    resolution: {integrity: sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==}
+  '@esbuild/openbsd-x64@0.21.5':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [openbsd]
 
-  '@esbuild/openbsd-x64@0.25.5':
-    resolution: {integrity: sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg==}
+  '@esbuild/openbsd-x64@0.25.12':
+    resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openbsd-x64@0.27.0':
+    resolution: {integrity: sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.25.12':
+    resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/openharmony-arm64@0.27.0':
+    resolution: {integrity: sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@esbuild/sunos-x64@0.18.20':
     resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [sunos]
 
-  '@esbuild/sunos-x64@0.19.12':
-    resolution: {integrity: sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==}
+  '@esbuild/sunos-x64@0.21.5':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [sunos]
 
-  '@esbuild/sunos-x64@0.25.5':
-    resolution: {integrity: sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA==}
+  '@esbuild/sunos-x64@0.25.12':
+    resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/sunos-x64@0.27.0':
+    resolution: {integrity: sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [sunos]
@@ -1977,14 +2427,20 @@ packages:
     cpu: [arm64]
     os: [win32]
 
-  '@esbuild/win32-arm64@0.19.12':
-    resolution: {integrity: sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==}
+  '@esbuild/win32-arm64@0.21.5':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [win32]
 
-  '@esbuild/win32-arm64@0.25.5':
-    resolution: {integrity: sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw==}
+  '@esbuild/win32-arm64@0.25.12':
+    resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-arm64@0.27.0':
+    resolution: {integrity: sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==}
     engines: {node: '>=18'}
     cpu: [arm64]
     os: [win32]
@@ -1995,14 +2451,20 @@ packages:
     cpu: [ia32]
     os: [win32]
 
-  '@esbuild/win32-ia32@0.19.12':
-    resolution: {integrity: sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==}
+  '@esbuild/win32-ia32@0.21.5':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [win32]
 
-  '@esbuild/win32-ia32@0.25.5':
-    resolution: {integrity: sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ==}
+  '@esbuild/win32-ia32@0.25.12':
+    resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.0':
+    resolution: {integrity: sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==}
     engines: {node: '>=18'}
     cpu: [ia32]
     os: [win32]
@@ -2013,26 +2475,32 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@esbuild/win32-x64@0.19.12':
-    resolution: {integrity: sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==}
+  '@esbuild/win32-x64@0.21.5':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [win32]
 
-  '@esbuild/win32-x64@0.25.5':
-    resolution: {integrity: sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g==}
+  '@esbuild/win32-x64@0.25.12':
+    resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.0':
+    resolution: {integrity: sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [win32]
 
-  '@eslint-community/eslint-utils@4.7.0':
-    resolution: {integrity: sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==}
+  '@eslint-community/eslint-utils@4.9.0':
+    resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
 
-  '@eslint-community/regexpp@4.12.1':
-    resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
+  '@eslint-community/regexpp@4.12.2':
+    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
   '@eslint/eslintrc@2.1.4':
@@ -2046,53 +2514,94 @@ packages:
   '@ewoudenberg/difflib@0.1.0':
     resolution: {integrity: sha512-OU5P5mJyD3OoWYMWY+yIgwvgNS9cFAU10f+DDuvtogcWQOoJIsQ4Hy2McSfUfhKjq8L0FuWVb4Rt7kgA+XK86A==}
 
-  '@expo/cli@0.24.13':
-    resolution: {integrity: sha512-2LSdbvYs+WmUljnplQXMCUyNzyX4H+F4l8uExfA1hud25Bl5kyaGrx1jjtgNxMTXmfmMjvgBdK798R50imEhkA==}
+  '@expo/cli@54.0.16':
+    resolution: {integrity: sha512-hY/OdRaJMs5WsVPuVSZ+RLH3VObJmL/pv5CGCHEZHN2PxZjSZSdctyKV8UcFBXTF0yIKNAJ9XLs1dlNYXHh4Cw==}
     hasBin: true
+    peerDependencies:
+      expo: '*'
+      expo-router: '*'
+      react-native: '*'
+    peerDependenciesMeta:
+      expo-router:
+        optional: true
+      react-native:
+        optional: true
 
   '@expo/code-signing-certificates@0.0.5':
     resolution: {integrity: sha512-BNhXkY1bblxKZpltzAx98G2Egj9g1Q+JRcvR7E99DOj862FTCX+ZPsAUtPTr7aHxwtrL7+fL3r0JSmM9kBm+Bw==}
 
-  '@expo/config-plugins@10.0.2':
-    resolution: {integrity: sha512-TzUn3pPdpwCS0yYaSlZOClgDmCX8N4I2lfgitX5oStqmvpPtB+vqtdyqsVM02fQ2tlJIAqwBW+NHaHqqy8Jv7g==}
+  '@expo/config-plugins@54.0.2':
+    resolution: {integrity: sha512-jD4qxFcURQUVsUFGMcbo63a/AnviK8WUGard+yrdQE3ZrB/aurn68SlApjirQQLEizhjI5Ar2ufqflOBlNpyPg==}
 
-  '@expo/config-types@53.0.4':
-    resolution: {integrity: sha512-0s+9vFx83WIToEr0Iwy4CcmiUXa5BgwBmEjylBB2eojX5XAMm9mJvw9KpjAb8m7zq2G0Q6bRbeufkzgbipuNQg==}
+  '@expo/config-types@54.0.8':
+    resolution: {integrity: sha512-lyIn/x/Yz0SgHL7IGWtgTLg6TJWC9vL7489++0hzCHZ4iGjVcfZmPTUfiragZ3HycFFj899qN0jlhl49IHa94A==}
 
-  '@expo/config@11.0.10':
-    resolution: {integrity: sha512-8S8Krr/c5lnl0eF03tA2UGY9rGBhZcbWKz2UWw5dpL/+zstwUmog8oyuuC8aRcn7GiTQLlbBkxcMeT8sOGlhbA==}
+  '@expo/config@12.0.10':
+    resolution: {integrity: sha512-lJMof5Nqakq1DxGYlghYB/ogSBjmv4Fxn1ovyDmcjlRsQdFCXgu06gEUogkhPtc9wBt9WlTTfqENln5HHyLW6w==}
 
   '@expo/devcert@1.2.0':
     resolution: {integrity: sha512-Uilcv3xGELD5t/b0eM4cxBFEKQRIivB3v7i+VhWLV/gL98aw810unLKKJbGAxAIhY6Ipyz8ChWibFsKFXYwstA==}
 
-  '@expo/env@1.0.5':
-    resolution: {integrity: sha512-dtEZ4CAMaVrFu2+tezhU3FoGWtbzQl50xV+rNJE5lYVRjUflWiZkVHlHkWUlPAwDPifLy4TuissVfScGGPWR5g==}
+  '@expo/devtools@0.1.7':
+    resolution: {integrity: sha512-dfIa9qMyXN+0RfU6SN4rKeXZyzKWsnz6xBSDccjL4IRiE+fQ0t84zg0yxgN4t/WK2JU5v6v4fby7W7Crv9gJvA==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+    peerDependenciesMeta:
+      react:
+        optional: true
+      react-native:
+        optional: true
+
+  '@expo/env@2.0.7':
+    resolution: {integrity: sha512-BNETbLEohk3HQ2LxwwezpG8pq+h7Fs7/vAMP3eAtFT1BCpprLYoBBFZH7gW4aqGfqOcVP4Lc91j014verrYNGg==}
 
-  '@expo/fingerprint@0.12.4':
-    resolution: {integrity: sha512-HOJVvjiQYVHIouCOfFf4JRrQvBDIV/12GVG2iwbw1iGwmpQVkPgEXa9lN0f2yuS4J3QXHs73wr9jvuCjMmJlfw==}
+  '@expo/fingerprint@0.15.3':
+    resolution: {integrity: sha512-8YPJpEYlmV171fi+t+cSLMX1nC5ngY9j2FiN70dHldLpd6Ct6ouGhk96svJ4BQZwsqwII2pokwzrDAwqo4Z0FQ==}
     hasBin: true
 
-  '@expo/image-utils@0.7.4':
-    resolution: {integrity: sha512-LcZ82EJy/t/a1avwIboeZbO6hlw8CvsIRh2k6SWPcAOvW0RqynyKFzUJsvnjWlhUzfBEn4oI7y/Pu5Xkw3KkkA==}
+  '@expo/image-utils@0.8.7':
+    resolution: {integrity: sha512-SXOww4Wq3RVXLyOaXiCCuQFguCDh8mmaHBv54h/R29wGl4jRY8GEyQEx8SypV/iHt1FbzsU/X3Qbcd9afm2W2w==}
 
-  '@expo/json-file@9.1.4':
-    resolution: {integrity: sha512-7Bv86X27fPERGhw8aJEZvRcH9sk+9BenDnEmrI3ZpywKodYSBgc8lX9Y32faNVQ/p0YbDK9zdJ0BfAKNAOyi0A==}
+  '@expo/json-file@10.0.7':
+    resolution: {integrity: sha512-z2OTC0XNO6riZu98EjdNHC05l51ySeTto6GP7oSQrCvQgG9ARBwD1YvMQaVZ9wU7p/4LzSf1O7tckL3B45fPpw==}
 
-  '@expo/metro-config@0.20.14':
-    resolution: {integrity: sha512-tYDDubuZycK+NX00XN7BMu73kBur/evOPcKfxc+UBeFfgN2EifOITtdwSUDdRsbtJ2OnXwMY1HfRUG3Lq3l4cw==}
+  '@expo/mcp-tunnel@0.1.0':
+    resolution: {integrity: sha512-rJ6hl0GnIZj9+ssaJvFsC7fwyrmndcGz+RGFzu+0gnlm78X01957yjtHgjcmnQAgL5hWEOR6pkT0ijY5nU5AWw==}
+    peerDependencies:
+      '@modelcontextprotocol/sdk': ^1.13.2
+    peerDependenciesMeta:
+      '@modelcontextprotocol/sdk':
+        optional: true
+
+  '@expo/metro-config@54.0.9':
+    resolution: {integrity: sha512-CRI4WgFXrQ2Owyr8q0liEBJveUIF9DcYAKadMRsJV7NxGNBdrIIKzKvqreDfsGiRqivbLsw6UoNb3UE7/SvPfg==}
+    peerDependencies:
+      expo: '*'
+    peerDependenciesMeta:
+      expo:
+        optional: true
 
-  '@expo/osascript@2.2.4':
-    resolution: {integrity: sha512-Q+Oyj+1pdRiHHpev9YjqfMZzByFH8UhKvSszxa0acTveijjDhQgWrq4e9T/cchBHi0GWZpGczWyiyJkk1wM1dg==}
+  '@expo/metro@54.1.0':
+    resolution: {integrity: sha512-MgdeRNT/LH0v1wcO0TZp9Qn8zEF0X2ACI0wliPtv5kXVbXWI+yK9GyrstwLAiTXlULKVIg3HVSCCvmLu0M3tnw==}
+
+  '@expo/osascript@2.3.7':
+    resolution: {integrity: sha512-IClSOXxR0YUFxIriUJVqyYki7lLMIHrrzOaP01yxAL1G8pj2DWV5eW1y5jSzIcIfSCNhtGsshGd1tU/AYup5iQ==}
     engines: {node: '>=12'}
 
-  '@expo/package-manager@1.8.4':
-    resolution: {integrity: sha512-8H8tLga/NS3iS7QaX/NneRPqbObnHvVCfMCo0ShudreOFmvmgqhYjRlkZTRstSyFqefai8ONaT4VmnLHneRYYg==}
+  '@expo/package-manager@1.9.8':
+    resolution: {integrity: sha512-4/I6OWquKXYnzo38pkISHCOCOXxfeEmu4uDoERq1Ei/9Ur/s9y3kLbAamEkitUkDC7gHk1INxRWEfFNzGbmOrA==}
+
+  '@expo/plist@0.4.7':
+    resolution: {integrity: sha512-dGxqHPvCZKeRKDU1sJZMmuyVtcASuSYh1LPFVaM1DuffqPL36n6FMEL0iUqq2Tx3xhWk8wCnWl34IKplUjJDdA==}
 
-  '@expo/plist@0.3.4':
-    resolution: {integrity: sha512-MhBLaUJNe9FQDDU2xhSNS4SAolr6K2wuyi4+A79vYuXLkAoICsbTwcGEQJN5jPY6D9izO/jsXh5k0h+mIWQMdw==}
+  '@expo/prebuild-config@54.0.6':
+    resolution: {integrity: sha512-xowuMmyPNy+WTNq+YX0m0EFO/Knc68swjThk4dKivgZa8zI1UjvFXOBIOp8RX4ljCXLzwxQJM5oBBTvyn+59ZA==}
+    peerDependencies:
+      expo: '*'
 
-  '@expo/prebuild-config@9.0.6':
-    resolution: {integrity: sha512-HDTdlMkTQZ95rd6EpvuLM+xkZV03yGLc38FqI37qKFLJtUN1WnYVaWsuXKoljd1OrVEVsHe6CfqKwaPZ52D56Q==}
+  '@expo/schema-utils@0.1.7':
+    resolution: {integrity: sha512-jWHoSuwRb5ZczjahrychMJ3GWZu54jK9ulNdh1d4OzAEq672K9E5yOlnlBsfIHWHGzUAT+0CL7Yt1INiXTz68g==}
 
   '@expo/sdk-runtime-versions@1.0.0':
     resolution: {integrity: sha512-Doz2bfiPndXYFPMRwPyGa1k5QaKDVpY806UJj570epIiMzWaYyCtobasyfC++qfIXVb5Ocy7r3tP9d62hAQ7IQ==}
@@ -2104,10 +2613,10 @@ packages:
   '@expo/sudo-prompt@9.3.2':
     resolution: {integrity: sha512-HHQigo3rQWKMDzYDLkubN5WQOYXJJE2eNqIQC2axC2iO3mHdwnIR7FgZVvHWtBwAdzBgAP0ECp8KqS8TiMKvgw==}
 
-  '@expo/vector-icons@14.1.0':
-    resolution: {integrity: sha512-7T09UE9h8QDTsUeMGymB4i+iqvtEeaO5VvUjryFB4tugDTG/bkzViWA74hm5pfjjDEhYMXWaX112mcvhccmIwQ==}
+  '@expo/vector-icons@15.0.3':
+    resolution: {integrity: sha512-SBUyYKphmlfUBqxSfDdJ3jAdEVSALS2VUPOUyqn48oZmb2TL/O7t7/PQm5v4NQujYEPLPMTLn9KVw6H7twwbTA==}
     peerDependencies:
-      expo-font: '*'
+      expo-font: '>=14.0.4'
       react: '*'
       react-native: '*'
 
@@ -2128,8 +2637,8 @@ packages:
   '@gar/promisify@1.1.3':
     resolution: {integrity: sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==}
 
-  '@grpc/grpc-js@1.13.4':
-    resolution: {integrity: sha512-GsFaMXCkMqkKIvwCQjCrwH+GHbPKBjhwo/8ZuUkWHqbI73Kky9I+pQltrlT0+MWpedCoosda53lgjYfyEPgxBg==}
+  '@grpc/grpc-js@1.14.1':
+    resolution: {integrity: sha512-sPxgEWtPUR3EnRJCEtbGZG2iX8LQDUls2wUS3o27jg07KqJFMq6YDeWvMo1wfpmy3rqRdS0rivpLwhqQtEyCuQ==}
     engines: {node: '>=12.10.0'}
 
   '@grpc/proto-loader@0.7.15':
@@ -2137,8 +2646,19 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
-  '@hono/node-server@1.14.3':
-    resolution: {integrity: sha512-KuDMwwghtFYSmIpr4WrKs1VpelTrptvJ+6x6mbUcZnFcc213cumTF5BdqfHyW93B19TNI4Vaev14vOI2a0Ie3w==}
+  '@grpc/proto-loader@0.8.0':
+    resolution: {integrity: sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  '@hono/node-server@1.19.14':
+    resolution: {integrity: sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==}
+    engines: {node: '>=18.14.1'}
+    peerDependencies:
+      hono: ^4
+
+  '@hono/node-server@1.19.6':
+    resolution: {integrity: sha512-Shz/KjlIeAhfiuE93NDKVdZ7HdBVLQAfdbaXEaoAVO3ic9ibRSLGIQGkcBbFyuLr+7/1D5ZCINM8B+6IvXeMtw==}
     engines: {node: '>=18.14.1'}
     peerDependencies:
       hono: ^4
@@ -2165,6 +2685,14 @@ packages:
   '@iarna/toml@2.2.5':
     resolution: {integrity: sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg==}
 
+  '@isaacs/balanced-match@4.0.1':
+    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/brace-expansion@5.0.0':
+    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
+    engines: {node: 20 || >=22}
+
   '@isaacs/cliui@8.0.2':
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
@@ -2209,33 +2737,38 @@ packages:
     resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
-  '@jridgewell/gen-mapping@0.3.8':
-    resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==}
-    engines: {node: '>=6.0.0'}
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
 
   '@jridgewell/resolve-uri@3.1.2':
     resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
     engines: {node: '>=6.0.0'}
 
-  '@jridgewell/set-array@1.2.1':
-    resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
-    engines: {node: '>=6.0.0'}
-
-  '@jridgewell/source-map@0.3.6':
-    resolution: {integrity: sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==}
+  '@jridgewell/source-map@0.3.11':
+    resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==}
 
-  '@jridgewell/sourcemap-codec@1.5.0':
-    resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==}
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
 
-  '@jridgewell/trace-mapping@0.3.25':
-    resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
   '@jridgewell/trace-mapping@0.3.9':
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
+  '@js-joda/core@5.6.5':
+    resolution: {integrity: sha512-3zwefSMwHpu8iVUW8YYz227sIv6UFqO31p1Bf1ZH/Vom7CmNyUsXjDBlnNzcuhmOL1XfxZ3nvND42kR23XlbcQ==}
+
   '@js-sdsl/ordered-map@4.4.2':
     resolution: {integrity: sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==}
 
+  '@js-temporal/polyfill@0.5.1':
+    resolution: {integrity: sha512-hloP58zRVCRSpgDxmqCWJNlizAlUgJFqG2ypq79DCvyv9tHjRYMDOcPFjzfl/A1/YxDvRCZz8wvZvmapQnKwFQ==}
+    engines: {node: '>=12'}
+
   '@jsep-plugin/assignment@1.3.0':
     resolution: {integrity: sha512-VVgV+CXrhbMI3aSusQyclHkenWSAm95WaiKrMxRFam3JSUiIaQjoMIw2sEs/OX4XifnqeQUN4DYbJjlA8EfktQ==}
     engines: {node: '>= 10.16.0'}
@@ -2248,8 +2781,8 @@ packages:
     peerDependencies:
       jsep: ^0.4.0||^1.0.0
 
-  '@keyv/serialize@1.0.3':
-    resolution: {integrity: sha512-qnEovoOp5Np2JDGonIDL6Ayihw0RhnRh6vxPuHo4RDn1UOzwEo4AeIfpL6UGIrsceWrCMiVPgwRjbHu4vYFc3g==}
+  '@keyv/serialize@1.1.1':
+    resolution: {integrity: sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==}
 
   '@libsql/client-wasm@0.10.0':
     resolution: {integrity: sha512-xSlpGdBGEr4mRtjCnDejTqtDpct2ng8cqHUQs+S4xG1yv0h+hLdzOtQJSY9JV9T/2MWWDfdCiEntPs2SdErSJA==}
@@ -2259,19 +2792,38 @@ packages:
   '@libsql/client@0.10.0':
     resolution: {integrity: sha512-2ERn08T4XOVx34yBtUPq0RDjAdd9TJ5qNH/izugr208ml2F94mk92qC64kXyDVQINodWJvp3kAdq6P4zTtCZ7g==}
 
+  '@libsql/client@0.17.3':
+    resolution: {integrity: sha512-HXk9wiAoJbKFbyBH4O+aEhN6ir5ERXuXvwE5OD2eR4/5RUa3Pw/8L9zrnVdU+iNJitRvisPWaIwmhkO3bH7giA==}
+
   '@libsql/core@0.10.0':
     resolution: {integrity: sha512-rqynAXGaiSpTsykOZdBtI1N4z4O+KZ6mt33K/aHeXAY0gSIfK/ctxuWa0Y1Bjo4FMz1idBTCXz4Ps5kITOvZZw==}
 
+  '@libsql/core@0.17.3':
+    resolution: {integrity: sha512-2UjK1i7JBkMduJo4WdvvBxMMvVJ31pArBZNONyz/GCJJAH+1UHat2X6vn10S/WpY5fKzIT98WqYFl2vzWRLOfg==}
+
   '@libsql/darwin-arm64@0.4.7':
     resolution: {integrity: sha512-yOL742IfWUlUevnI5PdnIT4fryY3LYTdLm56bnY0wXBw7dhFcnjuA7jrH3oSVz2mjZTHujxoITgAE7V6Z+eAbg==}
     cpu: [arm64]
     os: [darwin]
 
+  '@libsql/darwin-arm64@0.5.29':
+    resolution: {integrity: sha512-K+2RIB1OGFPYQbfay48GakLhqf3ArcbHqPFu7EZiaUcRgFcdw8RoltsMyvbj5ix2fY0HV3Q3Ioa/ByvQdaSM0A==}
+    cpu: [arm64]
+    os: [darwin]
+
   '@libsql/darwin-x64@0.4.7':
     resolution: {integrity: sha512-ezc7V75+eoyyH07BO9tIyJdqXXcRfZMbKcLCeF8+qWK5nP8wWuMcfOVywecsXGRbT99zc5eNra4NEx6z5PkSsA==}
     cpu: [x64]
     os: [darwin]
 
+  '@libsql/darwin-x64@0.5.29':
+    resolution: {integrity: sha512-OtT+KFHsKFy1R5FVadr8FJ2Bb1mghtXTyJkxv0trocq7NuHntSki1eUbxpO5ezJesDvBlqFjnWaYYY516QNLhQ==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@libsql/hrana-client@0.10.0':
+    resolution: {integrity: sha512-OoA4EMqRAC7kn7V2P6EQqRcpZf2W+AjsNIyCizBg339Tq/aMC7sRnzs3SklderhmQWAqEzvv8A2vhxVmWpkVvw==}
+
   '@libsql/hrana-client@0.6.2':
     resolution: {integrity: sha512-MWxgD7mXLNf9FXXiM0bc90wCjZSpErWKr5mGza7ERy2FJNNMXd7JIOv+DepBA1FQTIfI8TFO4/QDYgaQC0goNw==}
 
@@ -2282,31 +2834,69 @@ packages:
   '@libsql/isomorphic-ws@0.1.5':
     resolution: {integrity: sha512-DtLWIH29onUYR00i0GlQ3UdcTRC6EP4u9w/h9LxpUZJWRMARk6dQwZ6Jkd+QdwVpuAOrdxt18v0K2uIYR3fwFg==}
 
+  '@libsql/linux-arm-gnueabihf@0.5.29':
+    resolution: {integrity: sha512-CD4n4zj7SJTHso4nf5cuMoWoMSS7asn5hHygsDuhRl8jjjCTT3yE+xdUvI4J7zsyb53VO5ISh4cwwOtf6k2UhQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@libsql/linux-arm-musleabihf@0.5.29':
+    resolution: {integrity: sha512-2Z9qBVpEJV7OeflzIR3+l5yAd4uTOLxklScYTwpZnkm2vDSGlC1PRlueLaufc4EFITkLKXK2MWBpexuNJfMVcg==}
+    cpu: [arm]
+    os: [linux]
+
   '@libsql/linux-arm64-gnu@0.4.7':
     resolution: {integrity: sha512-WlX2VYB5diM4kFfNaYcyhw5y+UJAI3xcMkEUJZPtRDEIu85SsSFrQ+gvoKfcVh76B//ztSeEX2wl9yrjF7BBCA==}
     cpu: [arm64]
     os: [linux]
 
+  '@libsql/linux-arm64-gnu@0.5.29':
+    resolution: {integrity: sha512-gURBqaiXIGGwFNEaUj8Ldk7Hps4STtG+31aEidCk5evMMdtsdfL3HPCpvys+ZF/tkOs2MWlRWoSq7SOuCE9k3w==}
+    cpu: [arm64]
+    os: [linux]
+
   '@libsql/linux-arm64-musl@0.4.7':
     resolution: {integrity: sha512-6kK9xAArVRlTCpWeqnNMCoXW1pe7WITI378n4NpvU5EJ0Ok3aNTIC2nRPRjhro90QcnmLL1jPcrVwO4WD1U0xw==}
     cpu: [arm64]
     os: [linux]
 
+  '@libsql/linux-arm64-musl@0.5.29':
+    resolution: {integrity: sha512-fwgYZ0H8mUkyVqXZHF3mT/92iIh1N94Owi/f66cPVNsk9BdGKq5gVpoKO+7UxaNzuEH1roJp2QEwsCZMvBLpqg==}
+    cpu: [arm64]
+    os: [linux]
+
   '@libsql/linux-x64-gnu@0.4.7':
     resolution: {integrity: sha512-CMnNRCmlWQqqzlTw6NeaZXzLWI8bydaXDke63JTUCvu8R+fj/ENsLrVBtPDlxQ0wGsYdXGlrUCH8Qi9gJep0yQ==}
     cpu: [x64]
     os: [linux]
 
+  '@libsql/linux-x64-gnu@0.5.29':
+    resolution: {integrity: sha512-y14V0vY0nmMC6G0pHeJcEarcnGU2H6cm21ZceRkacWHvQAEhAG0latQkCtoS2njFOXiYIg+JYPfAoWKbi82rkg==}
+    cpu: [x64]
+    os: [linux]
+
   '@libsql/linux-x64-musl@0.4.7':
     resolution: {integrity: sha512-nI6tpS1t6WzGAt1Kx1n1HsvtBbZ+jHn0m7ogNNT6pQHZQj7AFFTIMeDQw/i/Nt5H38np1GVRNsFe99eSIMs9XA==}
     cpu: [x64]
     os: [linux]
 
+  '@libsql/linux-x64-musl@0.5.29':
+    resolution: {integrity: sha512-gquqwA/39tH4pFl+J9n3SOMSymjX+6kZ3kWgY3b94nXFTwac9bnFNMffIomgvlFaC4ArVqMnOZD3nuJ3H3VO1w==}
+    cpu: [x64]
+    os: [linux]
+
   '@libsql/win32-x64-msvc@0.4.7':
     resolution: {integrity: sha512-7pJzOWzPm6oJUxml+PCDRzYQ4A1hTMHAciTAHfFK4fkbDZX33nWPVG7Y3vqdKtslcwAzwmrNDc6sXy2nwWnbiw==}
     cpu: [x64]
     os: [win32]
 
+  '@libsql/win32-x64-msvc@0.5.29':
+    resolution: {integrity: sha512-4/0CvEdhi6+KjMxMaVbFM2n2Z44escBRoEYpR+gZg64DdetzGnYm8mcNLcoySaDJZNaBd6wz5DNdgRmcI4hXcg==}
+    cpu: [x64]
+    os: [win32]
+
+  '@loaderkit/resolve@1.0.4':
+    resolution: {integrity: sha512-rJzYKVcV4dxJv+vW6jlvagF8zvGxHJ2+HTr1e2qOejfmGhAApgJHl8Aog4mMszxceTRiKTTbnpgmTO1bEZHV/A==}
+
   '@miniflare/core@2.14.4':
     resolution: {integrity: sha512-FMmZcC1f54YpF4pDWPtdQPIO8NXfgUxCoR9uyrhxKJdZu7M6n8QKopPVNuaxR40jcsdxb7yKoQoFWnHfzJD9GQ==}
     engines: {node: '>=16.13'}
@@ -2332,10 +2922,56 @@ packages:
     engines: {node: '>=16.13'}
     deprecated: Miniflare v2 is no longer supported. Please upgrade to Miniflare v4
 
-  '@modelcontextprotocol/sdk@1.6.1':
-    resolution: {integrity: sha512-oxzMzYCkZHMntzuyerehK3fV6A2Kwh5BD6CGEJSVDU2QNEhfLOptf2X7esQgaHZXHZY0oHmMsOtIDLP71UJXgA==}
+  '@modelcontextprotocol/sdk@1.29.0':
+    resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==}
     engines: {node: '>=18'}
-
+    peerDependencies:
+      '@cfworker/json-schema': ^4.1.1
+      zod: ^3.25 || ^4.0
+    peerDependenciesMeta:
+      '@cfworker/json-schema':
+        optional: true
+
+  '@modelcontextprotocol/sdk@1.6.1':
+    resolution: {integrity: sha512-oxzMzYCkZHMntzuyerehK3fV6A2Kwh5BD6CGEJSVDU2QNEhfLOptf2X7esQgaHZXHZY0oHmMsOtIDLP71UJXgA==}
+    engines: {node: '>=18'}
+
+  '@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.4':
+    resolution: {integrity: sha512-LCkGo6JDfaBhgST7UpPWgNgLINpcpabaHfyz5OBx75nUYxBsaEPxjnyNjWpeb/xBup/682QnBfRBy2/LvPutZQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.4':
+    resolution: {integrity: sha512-zExlW9zUJKZH/tOtVMttwjKa4Xm/3KcNjnE3dPN92uCktwavMxpgCA3MoJK/DOnTWsQgo224OaST27/mPNAf+w==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.4':
+    resolution: {integrity: sha512-dgX0P/9wGPJeHFBG+ZmhgE6bmtMt7NP5CRBGyyktpopdk/mW4POnrpQsSLtKI1dwpc+pPLuXHDh6vvskyQE/sw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@msgpackr-extract/msgpackr-extract-linux-arm@3.0.4':
+    resolution: {integrity: sha512-Tg3yX65f5GbtXLkrYEHE5oibZG9epyYWas7FogTTEJeDEF9JlXJzKgXaNhT3UXlTOeA+AfZpYZYZ0uPj7Cfquw==}
+    cpu: [arm]
+    os: [linux]
+
+  '@msgpackr-extract/msgpackr-extract-linux-x64@3.0.4':
+    resolution: {integrity: sha512-8TNXMEjJc3QEy7R/x1INhgiU+XakDAFUzBhaz7+Rbrs8NH5UQeHQxxmzsSBJGyV6I1jW79undiQm8tOI+D+8FQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@msgpackr-extract/msgpackr-extract-win32-x64@3.0.4':
+    resolution: {integrity: sha512-CmCXPQrkbwExx3j946/PtHWHbYJiCRBRDl4BlkRQcJB/YOwQxJRTpoo7aTsortjgoJ1x7opzTSxn7C+ASSLVjQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@napi-rs/wasm-runtime@1.0.7':
+    resolution: {integrity: sha512-SeDnOO0Tk7Okiq6DbXmmBODgOAb9dp9gjlphokTUxmt8U3liIP1ZsozBahH69j/RJv+Rfs6IwUKHTgQYJ/HBAw==}
+
+  '@napi-rs/wasm-runtime@1.1.1':
+    resolution: {integrity: sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A==}
+
   '@neon-rs/load@0.0.4':
     resolution: {integrity: sha512-kTPhdZyTQxB+2wpiRcFWrDcejc4JI6tkPuS7UZCG4l6Zvc5kU/gGQ/ozvHTh1XR5tS+UlfAfGuPajjzQjCiHCw==}
 
@@ -2345,8 +2981,9 @@ packages:
   '@neondatabase/serverless@0.7.2':
     resolution: {integrity: sha512-wU3WA2uTyNO7wjPs3Mg0G01jztAxUxzd9/mskMmtPwPTjf7JKWi9AW5/puOGXLxmZ9PVgRFeBVRVYq5nBPhsCg==}
 
-  '@neondatabase/serverless@0.9.5':
-    resolution: {integrity: sha512-siFas6gItqv6wD/pZnvdu34wEqgG3nSE6zWZdq5j2DEsa+VvX8i/5HXJOo06qrw5axPXn+lGCxeR+NLaSPIXug==}
+  '@neondatabase/serverless@1.0.2':
+    resolution: {integrity: sha512-I5sbpSIAHiB+b6UttofhrN/UJXII+4tZPAq1qugzwCwLIL8EZLV7F/JyHUrEIiGgQpEXzpnjlJ+zwcEhheGvCw==}
+    engines: {node: '>=19.0.0'}
 
   '@noble/hashes@1.8.0':
     resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
@@ -2385,32 +3022,76 @@ packages:
   '@originjs/vite-plugin-commonjs@1.0.3':
     resolution: {integrity: sha512-KuEXeGPptM2lyxdIEJ4R11+5ztipHoE7hy8ClZt3PYaOVQ/pyngd2alaSrPnwyFeOW1UagRBaQ752aA1dTMdOQ==}
 
-  '@paralleldrive/cuid2@2.2.2':
-    resolution: {integrity: sha512-ZOBkgDwEdoYVlSeRbYYXs0S9MejQofiVYoTbKzy/6GQa39/q5tQU2IX46+shYnUkpEl3wc+J6wRlar7r2EK2xA==}
+  '@oxc-project/types@0.112.0':
+    resolution: {integrity: sha512-m6RebKHIRsax2iCwVpYW2ErQwa4ywHJrE4sCK3/8JK8ZZAWOKXaRJFl/uP51gaVyyXlaS4+chU1nSCdzYf6QqQ==}
+
+  '@oxc-project/types@0.115.0':
+    resolution: {integrity: sha512-4n91DKnebUS4yjUHl2g3/b2T+IUdCfmoZGhmwsovZCDaJSs+QkVAM+0AqqTxHSsHfeiMuueT75cZaZcT/m0pSw==}
+
+  '@oxlint/darwin-arm64@1.30.0':
+    resolution: {integrity: sha512-vIiTk1FBObXHvaG3WK/SpwCZP06fuHhSrn8mK2hEs2uSFWG63WgvLAHSGhI4U1X29JGf36zhfUzuKirDIVdKBQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxlint/darwin-x64@1.30.0':
+    resolution: {integrity: sha512-DP4ueul8Vza52gJX1/+jyXQjUsgjmPe4Pq5uYOVa8k2V8cKRb2JzBls+DugbeP7yzKNTmlSp3J2mUnHQXuntLA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxlint/linux-arm64-gnu@1.30.0':
+    resolution: {integrity: sha512-1e9NvTvjzG6t1tnUzNU9HZTVwNwhZw2BDQxwIsXV743g54BIkvyZNNXOEGic/Jw4IuIXHzpX3ztVWZaSzvDopg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxlint/linux-arm64-musl@1.30.0':
+    resolution: {integrity: sha512-szb5RB8Tbk756/z/GAdmUn+H1E2815BbcM7s6JZYQgyCJxR0RCL1yFXgKyz3BjIDqzR98Tw8H3g4TeJbN2etAg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxlint/linux-x64-gnu@1.30.0':
+    resolution: {integrity: sha512-yOWGu4a82yA8xLusaznW41IF5ZkvBNz/U++M2/tCYAQUoJKSfJuAS5AhApRMKZLKeX0Vmdagh0YwvC+e98QG0w==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxlint/linux-x64-musl@1.30.0':
+    resolution: {integrity: sha512-qL1902VF4EMTZTZdJEIzzUQ+UD0IbH+IW6dhYZXbP9nTXJnItW1fk4cyJq5zfUVu1IoVwKK2FP1jUMqEsBlWTw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxlint/win32-arm64@1.30.0':
+    resolution: {integrity: sha512-QK6C1djHKI7g1l5g6W9vkz9sd+sn1QJe6PbaV2sWFjVVoT0tO6LWygVWaci09ZHYVJ+lnCbbaFEgZ9jQhIs05A==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxlint/win32-x64@1.30.0':
+    resolution: {integrity: sha512-tbPnJIBUKke9KpceV+DpGyfN3LdhGaEPJHSuD4/mUEwP9Kk6IKSoDNih681RVGhgvaEZg3uHmQr6n9Uh0P3Yrg==}
+    cpu: [x64]
+    os: [win32]
+
+  '@paralleldrive/cuid2@2.3.1':
+    resolution: {integrity: sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==}
 
-  '@petamoriken/float16@3.9.2':
-    resolution: {integrity: sha512-VgffxawQde93xKxT3qap3OH+meZf7VaSB5Sqd4Rqc+FP5alWbpOyan/7tRbOAvynjpG3GpdtAuGU/NdhQpmrog==}
+  '@petamoriken/float16@3.9.3':
+    resolution: {integrity: sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g==}
 
   '@pkgjs/parseargs@0.11.0':
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
 
-  '@pkgr/core@0.2.7':
-    resolution: {integrity: sha512-YLT9Zo3oNPJoBjBc4q8G2mjU4tqIbf5CEOORbUUr48dCD9q3umJ3IPlVqOqDakPfd2HuwccBaqlGhN4Gmr5OWg==}
-    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
-
   '@planetscale/database@1.19.0':
     resolution: {integrity: sha512-Tv4jcFUFAFjOWrGSio49H6R2ijALv0ZzVBfJKIdm+kl9X046Fh4LLawrF9OMsglVbK6ukqMJsUCeucGAFTBcMA==}
     engines: {node: '>=16'}
 
-  '@polka/url@1.0.0-next.29':
-    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
-
   '@prettier/sync@0.5.5':
     resolution: {integrity: sha512-6BMtNr7aQhyNcGzmumkL0tgr1YQGfm9d7ZdmRpWqWuqpc9vZBind4xMe5NMiRECOhjuSiWHfBWLBnXkpeE90bw==}
     peerDependencies:
       prettier: '*'
 
+  '@prettier/sync@0.6.1':
+    resolution: {integrity: sha512-yF9G8vK/LYUTF3Cijd7VC9La3b20F20/J/fgoR4H0B8JGOWnZVZX6+I6+vODPosjmMcpdlUV+gUqJQZp3kLOcw==}
+    peerDependencies:
+      prettier: '*'
+
   '@prisma/client@5.14.0':
     resolution: {integrity: sha512-akMSuyvLKeoU4LeyBAUdThP/uhVP3GuLygFE3MlYzaCb3/J8SfsYBE5PkaFuLuVpLyA6sFoW+16z/aPhNAESqg==}
     engines: {node: '>=16.13'}
@@ -2471,204 +3152,379 @@ packages:
   '@protobufjs/utf8@1.1.0':
     resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
 
-  '@react-native/assets-registry@0.79.2':
-    resolution: {integrity: sha512-5h2Z7/+/HL/0h88s0JHOdRCW4CXMCJoROxqzHqxdrjGL6EBD1DdaB4ZqkCOEVSW4Vjhir5Qb97C8i/MPWEYPtg==}
-    engines: {node: '>=18'}
+  '@quansync/fs@1.0.0':
+    resolution: {integrity: sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==}
 
-  '@react-native/babel-plugin-codegen@0.79.2':
-    resolution: {integrity: sha512-d+NB7Uosn2ZWd4O4+7ZkB6q1a+0z2opD/4+Bzhk/Tv6fc5FrSftK2Noqxvo3/bhbdGFVPxf0yvLE8et4W17x/Q==}
-    engines: {node: '>=18'}
+  '@react-native/assets-registry@0.82.1':
+    resolution: {integrity: sha512-B1SRwpntaAcckiatxbjzylvNK562Ayza05gdJCjDQHTiDafa1OABmyB5LHt7qWDOpNkaluD+w11vHF7pBmTpzQ==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/babel-preset@0.79.2':
-    resolution: {integrity: sha512-/HNu869oUq4FUXizpiNWrIhucsYZqu0/0spudJEzk9SEKar0EjVDP7zkg/sKK+KccNypDQGW7nFXT8onzvQ3og==}
-    engines: {node: '>=18'}
+  '@react-native/babel-plugin-codegen@0.81.5':
+    resolution: {integrity: sha512-oF71cIH6je3fSLi6VPjjC3Sgyyn57JLHXs+mHWc9MoCiJJcM4nqsS5J38zv1XQ8d3zOW2JtHro+LF0tagj2bfQ==}
+    engines: {node: '>= 20.19.4'}
+
+  '@react-native/babel-preset@0.81.5':
+    resolution: {integrity: sha512-UoI/x/5tCmi+pZ3c1+Ypr1DaRMDLI3y+Q70pVLLVgrnC3DHsHRIbHcCHIeG/IJvoeFqFM2sTdhSOLJrf8lOPrA==}
+    engines: {node: '>= 20.19.4'}
     peerDependencies:
       '@babel/core': '*'
 
-  '@react-native/codegen@0.79.2':
-    resolution: {integrity: sha512-8JTlGLuLi1p8Jx2N/enwwEd7/2CfrqJpv90Cp77QLRX3VHF2hdyavRIxAmXMwN95k+Me7CUuPtqn2X3IBXOWYg==}
-    engines: {node: '>=18'}
+  '@react-native/codegen@0.81.5':
+    resolution: {integrity: sha512-a2TDA03Up8lpSa9sh5VRGCQDXgCTOyDOFH+aqyinxp1HChG8uk89/G+nkJ9FPd0rqgi25eCTR16TWdS3b+fA6g==}
+    engines: {node: '>= 20.19.4'}
     peerDependencies:
       '@babel/core': '*'
 
-  '@react-native/community-cli-plugin@0.79.2':
-    resolution: {integrity: sha512-E+YEY2dL+68HyR2iahsZdyBKBUi9QyPyaN9vsnda1jNgCjNpSPk2yAF5cXsho+zKK5ZQna3JSeE1Kbi2IfGJbw==}
-    engines: {node: '>=18'}
+  '@react-native/codegen@0.82.1':
+    resolution: {integrity: sha512-ezXTN70ygVm9l2m0i+pAlct0RntoV4afftWMGUIeAWLgaca9qItQ54uOt32I/9dBJvzBibT33luIR/pBG0dQvg==}
+    engines: {node: '>= 20.19.4'}
+    peerDependencies:
+      '@babel/core': '*'
+
+  '@react-native/community-cli-plugin@0.82.1':
+    resolution: {integrity: sha512-H/eMdtOy9nEeX7YVeEG1N2vyCoifw3dr9OV8++xfUElNYV7LtSmJ6AqxZUUfxGJRDFPQvaU/8enmJlM/l11VxQ==}
+    engines: {node: '>= 20.19.4'}
     peerDependencies:
       '@react-native-community/cli': '*'
+      '@react-native/metro-config': '*'
     peerDependenciesMeta:
       '@react-native-community/cli':
         optional: true
+      '@react-native/metro-config':
+        optional: true
 
-  '@react-native/debugger-frontend@0.79.2':
-    resolution: {integrity: sha512-cGmC7X6kju76DopSBNc+PRAEetbd7TWF9J9o84hOp/xL3ahxR2kuxJy0oJX8Eg8oehhGGEXTuMKHzNa3rDBeSg==}
-    engines: {node: '>=18'}
+  '@react-native/debugger-frontend@0.81.5':
+    resolution: {integrity: sha512-bnd9FSdWKx2ncklOetCgrlwqSGhMHP2zOxObJbOWXoj7GHEmih4MKarBo5/a8gX8EfA1EwRATdfNBQ81DY+h+w==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/dev-middleware@0.79.2':
-    resolution: {integrity: sha512-9q4CpkklsAs1L0Bw8XYCoqqyBSrfRALGEw4/r0EkR38Y/6fVfNfdsjSns0pTLO6h0VpxswK34L/hm4uK3MoLHw==}
-    engines: {node: '>=18'}
+  '@react-native/debugger-frontend@0.82.1':
+    resolution: {integrity: sha512-a2O6M7/OZ2V9rdavOHyCQ+10z54JX8+B+apYKCQ6a9zoEChGTxUMG2YzzJ8zZJVvYf1ByWSNxv9Se0dca1hO9A==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/gradle-plugin@0.79.2':
-    resolution: {integrity: sha512-6MJFemrwR0bOT0QM+2BxX9k3/pvZQNmJ3Js5pF/6owsA0cUDiCO57otiEU8Fz+UywWEzn1FoQfOfQ8vt2GYmoA==}
-    engines: {node: '>=18'}
+  '@react-native/debugger-shell@0.82.1':
+    resolution: {integrity: sha512-fdRHAeqqPT93bSrxfX+JHPpCXHApfDUdrXMXhoxlPgSzgXQXJDykIViKhtpu0M6slX6xU/+duq+AtP/qWJRpBw==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/js-polyfills@0.79.2':
-    resolution: {integrity: sha512-IaY87Ckd4GTPMkO1/Fe8fC1IgIx3vc3q9Tyt/6qS3Mtk9nC0x9q4kSR5t+HHq0/MuvGtu8HpdxXGy5wLaM+zUw==}
-    engines: {node: '>=18'}
+  '@react-native/dev-middleware@0.81.5':
+    resolution: {integrity: sha512-WfPfZzboYgo/TUtysuD5xyANzzfka8Ebni6RIb2wDxhb56ERi7qDrE4xGhtPsjCL4pQBXSVxyIlCy0d8I6EgGA==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/normalize-colors@0.79.2':
-    resolution: {integrity: sha512-+b+GNrupWrWw1okHnEENz63j7NSMqhKeFMOyzYLBwKcprG8fqJQhDIGXfizKdxeIa5NnGSAevKL1Ev1zJ56X8w==}
+  '@react-native/dev-middleware@0.82.1':
+    resolution: {integrity: sha512-wuOIzms/Qg5raBV6Ctf2LmgzEOCqdP3p1AYN4zdhMT110c39TVMbunpBaJxm0Kbt2HQ762MQViF9naxk7SBo4w==}
+    engines: {node: '>= 20.19.4'}
 
-  '@react-native/virtualized-lists@0.79.2':
-    resolution: {integrity: sha512-9G6ROJeP+rdw9Bvr5ruOlag11ET7j1z/En1riFFNo6W3xZvJY+alCuH1ttm12y9+zBm4n8jwCk4lGhjYaV4dKw==}
-    engines: {node: '>=18'}
+  '@react-native/gradle-plugin@0.82.1':
+    resolution: {integrity: sha512-KkF/2T1NSn6EJ5ALNT/gx0MHlrntFHv8YdooH9OOGl9HQn5NM0ZmQSr86o5utJsGc7ME3R6p3SaQuzlsFDrn8Q==}
+    engines: {node: '>= 20.19.4'}
+
+  '@react-native/js-polyfills@0.82.1':
+    resolution: {integrity: sha512-tf70X7pUodslOBdLN37J57JmDPB/yiZcNDzS2m+4bbQzo8fhx3eG9QEBv5n4fmzqfGAgSB4BWRHgDMXmmlDSVA==}
+    engines: {node: '>= 20.19.4'}
+
+  '@react-native/normalize-colors@0.81.5':
+    resolution: {integrity: sha512-0HuJ8YtqlTVRXGZuGeBejLE04wSQsibpTI+RGOyVqxZvgtlLLC/Ssw0UmbHhT4lYMp2fhdtvKZSs5emWB1zR/g==}
+
+  '@react-native/normalize-colors@0.82.1':
+    resolution: {integrity: sha512-CCfTR1uX+Z7zJTdt3DNX9LUXr2zWXsNOyLbwupW2wmRzrxlHRYfmLgTABzRL/cKhh0Ubuwn15o72MQChvCRaHw==}
+
+  '@react-native/virtualized-lists@0.82.1':
+    resolution: {integrity: sha512-f5zpJg9gzh7JtCbsIwV+4kP3eI0QBuA93JGmwFRd4onQ3DnCjV2J5pYqdWtM95sjSKK1dyik59Gj01lLeKqs1Q==}
+    engines: {node: '>= 20.19.4'}
     peerDependencies:
-      '@types/react': ^19.0.0
+      '@types/react': ^19.1.1
       react: '*'
       react-native: '*'
     peerDependenciesMeta:
       '@types/react':
         optional: true
 
-  '@rollup/plugin-terser@0.4.4':
-    resolution: {integrity: sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
+  '@rolldown/binding-android-arm64@1.0.0-rc.3':
+    resolution: {integrity: sha512-0T1k9FinuBZ/t7rZ8jN6OpUKPnUjNdYHoj/cESWrQ3ZraAJ4OMm6z7QjSfCxqj8mOp9kTKc1zHK3kGz5vMu+nQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@rolldown/binding-android-arm64@1.0.0-rc.9':
+    resolution: {integrity: sha512-lcJL0bN5hpgJfSIz/8PIf02irmyL43P+j1pTCfbD1DbLkmGRuFIA4DD3B3ZOvGqG0XiVvRznbKtN0COQVaKUTg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.3':
+    resolution: {integrity: sha512-JWWLzvcmc/3pe7qdJqPpuPk91SoE/N+f3PcWx/6ZwuyDVyungAEJPvKm/eEldiDdwTmaEzWfIR+HORxYWrCi1A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.9':
+    resolution: {integrity: sha512-J7Zk3kLYFsLtuH6U+F4pS2sYVzac0qkjcO5QxHS7OS7yZu2LRs+IXo+uvJ/mvpyUljDJ3LROZPoQfgBIpCMhdQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rolldown/binding-darwin-x64@1.0.0-rc.3':
+    resolution: {integrity: sha512-MTakBxfx3tde5WSmbHxuqlDsIW0EzQym+PJYGF4P6lG2NmKzi128OGynoFUqoD5ryCySEY85dug4v+LWGBElIw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rolldown/binding-darwin-x64@1.0.0-rc.9':
+    resolution: {integrity: sha512-iwtmmghy8nhfRGeNAIltcNXzD0QMNaaA5U/NyZc1Ia4bxrzFByNMDoppoC+hl7cDiUq5/1CnFthpT9n+UtfFyg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.3':
+    resolution: {integrity: sha512-jje3oopyOLs7IwfvXoS6Lxnmie5JJO7vW29fdGFu5YGY1EDbVDhD+P9vDihqS5X6fFiqL3ZQZCMBg6jyHkSVww==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.9':
+    resolution: {integrity: sha512-DLFYI78SCiZr5VvdEplsVC2Vx53lnA4/Ga5C65iyldMVaErr86aiqCoNBLl92PXPfDtUYjUh+xFFor40ueNs4Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.3':
+    resolution: {integrity: sha512-A0n8P3hdLAaqzSFrQoA42p23ZKBYQOw+8EH5r15Sa9X1kD9/JXe0YT2gph2QTWvdr0CVK2BOXiK6ENfy6DXOag==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.9':
+    resolution: {integrity: sha512-CsjTmTwd0Hri6iTw/DRMK7kOZ7FwAkrO4h8YWKoX/kcj833e4coqo2wzIFywtch/8Eb5enQ/lwLM7w6JX1W5RQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.3':
+    resolution: {integrity: sha512-kWXkoxxarYISBJ4bLNf5vFkEbb4JvccOwxWDxuK9yee8lg5XA7OpvlTptfRuwEvYcOZf+7VS69Uenpmpyo5Bjw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.9':
+    resolution: {integrity: sha512-2x9O2JbSPxpxMDhP9Z74mahAStibTlrBMW0520+epJH5sac7/LwZW5Bmg/E6CXuEF53JJFW509uP+lSedaUNxg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.3':
+    resolution: {integrity: sha512-Z03/wrqau9Bicfgb3Dbs6SYTHliELk2PM2LpG2nFd+cGupTMF5kanLEcj2vuuJLLhptNyS61rtk7SOZ+lPsTUA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.9':
+    resolution: {integrity: sha512-JA1QRW31ogheAIRhIg9tjMfsYbglXXYGNPLdPEYrwFxdbkQCAzvpSCSHCDWNl4hTtrol8WeboCSEpjdZK8qrCg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.9':
+    resolution: {integrity: sha512-aOKU9dJheda8Kj8Y3w9gnt9QFOO+qKPAl8SWd7JPHP+Cu0EuDAE5wokQubLzIDQWg2myXq2XhTpOVS07qqvT+w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.9':
+    resolution: {integrity: sha512-OalO94fqj7IWRn3VdXWty75jC5dk4C197AWEuMhIpvVv2lw9fiPhud0+bW2ctCxb3YoBZor71QHbY+9/WToadA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.3':
+    resolution: {integrity: sha512-iSXXZsQp08CSilff/DCTFZHSVEpEwdicV3W8idHyrByrcsRDVh9sGC3sev6d8BygSGj3vt8GvUKBPCoyMA4tgQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.9':
+    resolution: {integrity: sha512-cVEl1vZtBsBZna3YMjGXNvnYYrOJ7RzuWvZU0ffvJUexWkukMaDuGhUXn0rjnV0ptzGVkvc+vW9Yqy6h8YX4pg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.3':
+    resolution: {integrity: sha512-qaj+MFudtdCv9xZo9znFvkgoajLdc+vwf0Kz5N44g+LU5XMe+IsACgn3UG7uTRlCCvhMAGXm1XlpEA5bZBrOcw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.9':
+    resolution: {integrity: sha512-UzYnKCIIc4heAKgI4PZ3dfBGUZefGCJ1TPDuLHoCzgrMYPb5Rv6TLFuYtyM4rWyHM7hymNdsg5ik2C+UD9VDbA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.3':
+    resolution: {integrity: sha512-U662UnMETyjT65gFmG9ma+XziENrs7BBnENi/27swZPYagubfHRirXHG2oMl+pEax2WvO7Kb9gHZmMakpYqBHQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.9':
+    resolution: {integrity: sha512-+6zoiF+RRyf5cdlFQP7nm58mq7+/2PFaY2DNQeD4B87N36JzfF/l9mdBkkmTvSYcYPE8tMh/o3cRlsx1ldLfog==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
 
-  '@rollup/plugin-typescript@11.1.6':
-    resolution: {integrity: sha512-R92yOmIACgYdJ7dJ97p4K69I8gg6IEHt8M7dUBxN3W6nrO8uUxX5ixl0yU/N3aZTi8WhPuICvOHXQvF6FaykAA==}
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.3':
+    resolution: {integrity: sha512-gekrQ3Q2HiC1T5njGyuUJoGpK/l6B/TNXKed3fZXNf9YRTJn3L5MOZsFBn4bN2+UX+8+7hgdlTcEsexX988G4g==}
     engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^2.14.0||^3.0.0||^4.0.0
-      tslib: '*'
-      typescript: '>=3.7.0'
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-      tslib:
-        optional: true
+    cpu: [wasm32]
 
-  '@rollup/pluginutils@5.1.4':
-    resolution: {integrity: sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==}
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.9':
+    resolution: {integrity: sha512-rgFN6sA/dyebil3YTlL2evvi/M+ivhfnyxec7AccTpRPccno/rPoNlqybEZQBkcbZu8Hy+eqNJCqfBR8P7Pg8g==}
     engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
+    cpu: [wasm32]
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.3':
+    resolution: {integrity: sha512-85y5JifyMgs8m5K2XzR/VDsapKbiFiohl7s5lEj7nmNGO0pkTXE7q6TQScei96BNAsoK7JC3pA7ukA8WRHVJpg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.9':
+    resolution: {integrity: sha512-lHVNUG/8nlF1IQk1C0Ci574qKYyty2goMiPlRqkC5R+3LkXDkL5Dhx8ytbxq35m+pkHVIvIxviD+TWLdfeuadA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.3':
+    resolution: {integrity: sha512-a4VUQZH7LxGbUJ3qJ/TzQG8HxdHvf+jOnqf7B7oFx1TEBm+j2KNL2zr5SQ7wHkNAcaPevF6gf9tQnVBnC4mD+A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.9':
+    resolution: {integrity: sha512-G0oA4+w1iY5AGi5HcDTxWsoxF509hrFIPB2rduV5aDqS9FtDg1CAfa7V34qImbjfhIcA8C+RekocJZA96EarwQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@rolldown/pluginutils@1.0.0-rc.3':
+    resolution: {integrity: sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==}
 
-  '@rollup/rollup-android-arm-eabi@4.41.1':
-    resolution: {integrity: sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw==}
+  '@rolldown/pluginutils@1.0.0-rc.9':
+    resolution: {integrity: sha512-w6oiRWgEBl04QkFZgmW+jnU1EC9b57Oihi2ot3HNWIQRqgHp5PnYDia5iZ5FF7rpa4EQdiqMDXjlqKGXBhsoXw==}
+
+  '@rollup/rollup-android-arm-eabi@4.53.3':
+    resolution: {integrity: sha512-mRSi+4cBjrRLoaal2PnqH82Wqyb+d3HsPUN/W+WslCXsZsyHa9ZeQQX/pQsZaVIWDkPcpV6jJ+3KLbTbgnwv8w==}
     cpu: [arm]
     os: [android]
 
-  '@rollup/rollup-android-arm64@4.41.1':
-    resolution: {integrity: sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA==}
+  '@rollup/rollup-android-arm64@4.53.3':
+    resolution: {integrity: sha512-CbDGaMpdE9sh7sCmTrTUyllhrg65t6SwhjlMJsLr+J8YjFuPmCEjbBSx4Z/e4SmDyH3aB5hGaJUP2ltV/vcs4w==}
     cpu: [arm64]
     os: [android]
 
-  '@rollup/rollup-darwin-arm64@4.41.1':
-    resolution: {integrity: sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w==}
+  '@rollup/rollup-darwin-arm64@4.53.3':
+    resolution: {integrity: sha512-Nr7SlQeqIBpOV6BHHGZgYBuSdanCXuw09hon14MGOLGmXAFYjx1wNvquVPmpZnl0tLjg25dEdr4IQ6GgyToCUA==}
     cpu: [arm64]
     os: [darwin]
 
-  '@rollup/rollup-darwin-x64@4.41.1':
-    resolution: {integrity: sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg==}
+  '@rollup/rollup-darwin-x64@4.53.3':
+    resolution: {integrity: sha512-DZ8N4CSNfl965CmPktJ8oBnfYr3F8dTTNBQkRlffnUarJ2ohudQD17sZBa097J8xhQ26AwhHJ5mvUyQW8ddTsQ==}
     cpu: [x64]
     os: [darwin]
 
-  '@rollup/rollup-freebsd-arm64@4.41.1':
-    resolution: {integrity: sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg==}
+  '@rollup/rollup-freebsd-arm64@4.53.3':
+    resolution: {integrity: sha512-yMTrCrK92aGyi7GuDNtGn2sNW+Gdb4vErx4t3Gv/Tr+1zRb8ax4z8GWVRfr3Jw8zJWvpGHNpss3vVlbF58DZ4w==}
     cpu: [arm64]
     os: [freebsd]
 
-  '@rollup/rollup-freebsd-x64@4.41.1':
-    resolution: {integrity: sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA==}
+  '@rollup/rollup-freebsd-x64@4.53.3':
+    resolution: {integrity: sha512-lMfF8X7QhdQzseM6XaX0vbno2m3hlyZFhwcndRMw8fbAGUGL3WFMBdK0hbUBIUYcEcMhVLr1SIamDeuLBnXS+Q==}
     cpu: [x64]
     os: [freebsd]
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.41.1':
-    resolution: {integrity: sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg==}
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.3':
+    resolution: {integrity: sha512-k9oD15soC/Ln6d2Wv/JOFPzZXIAIFLp6B+i14KhxAfnq76ajt0EhYc5YPeX6W1xJkAdItcVT+JhKl1QZh44/qw==}
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm-musleabihf@4.41.1':
-    resolution: {integrity: sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA==}
+  '@rollup/rollup-linux-arm-musleabihf@4.53.3':
+    resolution: {integrity: sha512-vTNlKq+N6CK/8UktsrFuc+/7NlEYVxgaEgRXVUVK258Z5ymho29skzW1sutgYjqNnquGwVUObAaxae8rZ6YMhg==}
     cpu: [arm]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-gnu@4.41.1':
-    resolution: {integrity: sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA==}
+  '@rollup/rollup-linux-arm64-gnu@4.53.3':
+    resolution: {integrity: sha512-RGrFLWgMhSxRs/EWJMIFM1O5Mzuz3Xy3/mnxJp/5cVhZ2XoCAxJnmNsEyeMJtpK+wu0FJFWz+QF4mjCA7AUQ3w==}
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-arm64-musl@4.41.1':
-    resolution: {integrity: sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg==}
+  '@rollup/rollup-linux-arm64-musl@4.53.3':
+    resolution: {integrity: sha512-kASyvfBEWYPEwe0Qv4nfu6pNkITLTb32p4yTgzFCocHnJLAHs+9LjUu9ONIhvfT/5lv4YS5muBHyuV84epBo/A==}
     cpu: [arm64]
     os: [linux]
 
-  '@rollup/rollup-linux-loongarch64-gnu@4.41.1':
-    resolution: {integrity: sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw==}
+  '@rollup/rollup-linux-loong64-gnu@4.53.3':
+    resolution: {integrity: sha512-JiuKcp2teLJwQ7vkJ95EwESWkNRFJD7TQgYmCnrPtlu50b4XvT5MOmurWNrCj3IFdyjBQ5p9vnrX4JM6I8OE7g==}
     cpu: [loong64]
     os: [linux]
 
-  '@rollup/rollup-linux-powerpc64le-gnu@4.41.1':
-    resolution: {integrity: sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A==}
+  '@rollup/rollup-linux-ppc64-gnu@4.53.3':
+    resolution: {integrity: sha512-EoGSa8nd6d3T7zLuqdojxC20oBfNT8nexBbB/rkxgKj5T5vhpAQKKnD+h3UkoMuTyXkP5jTjK/ccNRmQrPNDuw==}
     cpu: [ppc64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-gnu@4.41.1':
-    resolution: {integrity: sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw==}
+  '@rollup/rollup-linux-riscv64-gnu@4.53.3':
+    resolution: {integrity: sha512-4s+Wped2IHXHPnAEbIB0YWBv7SDohqxobiiPA1FIWZpX+w9o2i4LezzH/NkFUl8LRci/8udci6cLq+jJQlh+0g==}
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-riscv64-musl@4.41.1':
-    resolution: {integrity: sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw==}
+  '@rollup/rollup-linux-riscv64-musl@4.53.3':
+    resolution: {integrity: sha512-68k2g7+0vs2u9CxDt5ktXTngsxOQkSEV/xBbwlqYcUrAVh6P9EgMZvFsnHy4SEiUl46Xf0IObWVbMvPrr2gw8A==}
     cpu: [riscv64]
     os: [linux]
 
-  '@rollup/rollup-linux-s390x-gnu@4.41.1':
-    resolution: {integrity: sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g==}
+  '@rollup/rollup-linux-s390x-gnu@4.53.3':
+    resolution: {integrity: sha512-VYsFMpULAz87ZW6BVYw3I6sWesGpsP9OPcyKe8ofdg9LHxSbRMd7zrVrr5xi/3kMZtpWL/wC+UIJWJYVX5uTKg==}
     cpu: [s390x]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-gnu@4.41.1':
-    resolution: {integrity: sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A==}
+  '@rollup/rollup-linux-x64-gnu@4.53.3':
+    resolution: {integrity: sha512-3EhFi1FU6YL8HTUJZ51imGJWEX//ajQPfqWLI3BQq4TlvHy4X0MOr5q3D2Zof/ka0d5FNdPwZXm3Yyib/UEd+w==}
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-linux-x64-musl@4.41.1':
-    resolution: {integrity: sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ==}
+  '@rollup/rollup-linux-x64-musl@4.53.3':
+    resolution: {integrity: sha512-eoROhjcc6HbZCJr+tvVT8X4fW3/5g/WkGvvmwz/88sDtSJzO7r/blvoBDgISDiCjDRZmHpwud7h+6Q9JxFwq1Q==}
     cpu: [x64]
     os: [linux]
 
-  '@rollup/rollup-win32-arm64-msvc@4.41.1':
-    resolution: {integrity: sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ==}
+  '@rollup/rollup-openharmony-arm64@4.53.3':
+    resolution: {integrity: sha512-OueLAWgrNSPGAdUdIjSWXw+u/02BRTcnfw9PN41D2vq/JSEPnJnVuBgw18VkN8wcd4fjUs+jFHVM4t9+kBSNLw==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.53.3':
+    resolution: {integrity: sha512-GOFuKpsxR/whszbF/bzydebLiXIHSgsEUp6M0JI8dWvi+fFa1TD6YQa4aSZHtpmh2/uAlj/Dy+nmby3TJ3pkTw==}
     cpu: [arm64]
     os: [win32]
 
-  '@rollup/rollup-win32-ia32-msvc@4.41.1':
-    resolution: {integrity: sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg==}
+  '@rollup/rollup-win32-ia32-msvc@4.53.3':
+    resolution: {integrity: sha512-iah+THLcBJdpfZ1TstDFbKNznlzoxa8fmnFYK4V67HvmuNYkVdAywJSoteUszvBQ9/HqN2+9AZghbajMsFT+oA==}
     cpu: [ia32]
     os: [win32]
 
-  '@rollup/rollup-win32-x64-msvc@4.41.1':
-    resolution: {integrity: sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw==}
+  '@rollup/rollup-win32-x64-gnu@4.53.3':
+    resolution: {integrity: sha512-J9QDiOIZlZLdcot5NXEepDkstocktoVjkaKUtqzgzpt2yWjGlbYiKyp05rWwk4nypbYUNoFAztEgixoLaSETkg==}
     cpu: [x64]
     os: [win32]
 
-  '@rtsao/scc@1.1.0':
-    resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==}
+  '@rollup/rollup-win32-x64-msvc@4.53.3':
+    resolution: {integrity: sha512-UhTd8u31dXadv0MopwGgNOBpUVROFKWVQgAg5N1ESyCz8AuBcMqm4AuTjrwgQKGDfoFuz02EuMRHQIw/frmYKQ==}
+    cpu: [x64]
+    os: [win32]
 
   '@sinclair/typebox@0.27.8':
     resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}
 
-  '@sinclair/typebox@0.34.33':
-    resolution: {integrity: sha512-5HAV9exOMcXRUxo+9iYB5n09XxzCXnfy4VTNW4xnDv+FgjzAGY989C28BIdljKqmF+ZltUwujE3aossvcVtq6g==}
+  '@sinclair/typebox@0.34.48':
+    resolution: {integrity: sha512-kKJTNuK3AQOrgjjotVxMrCn1sUJwM76wMszfq1kdU4uYVJjvEWuFQ6HgvLt4Xz3fSmZlTOxJ/Ie13KnIcWQXFA==}
 
   '@sindresorhus/is@4.6.0':
     resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==}
@@ -2684,174 +3540,199 @@ packages:
   '@sinonjs/fake-timers@10.3.0':
     resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==}
 
-  '@smithy/abort-controller@4.0.4':
-    resolution: {integrity: sha512-gJnEjZMvigPDQWHrW3oPrFhQtkrgqBkyjj3pCIdF3A5M6vsZODG93KNlfJprv6bp4245bdT32fsHK4kkH3KYDA==}
+  '@smithy/abort-controller@4.2.5':
+    resolution: {integrity: sha512-j7HwVkBw68YW8UmFRcjZOmssE77Rvk0GWAIN1oFBhsaovQmZWYCIcGa9/pwRB0ExI8Sk9MWNALTjftjHZea7VA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/config-resolver@4.1.4':
-    resolution: {integrity: sha512-prmU+rDddxHOH0oNcwemL+SwnzcG65sBF2yXRO7aeXIn/xTlq2pX7JLVbkBnVLowHLg4/OL4+jBmv9hVrVGS+w==}
+  '@smithy/config-resolver@4.4.3':
+    resolution: {integrity: sha512-ezHLe1tKLUxDJo2LHtDuEDyWXolw8WGOR92qb4bQdWq/zKenO5BvctZGrVJBK08zjezSk7bmbKFOXIVyChvDLw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/core@3.5.1':
-    resolution: {integrity: sha512-xSw7bZEFKwOKrm/iv8e2BLt2ur98YZdrRD6nII8ditQeUsY2Q1JmIQ0rpILOhaLKYxxG2ivnoOpokzr9qLyDWA==}
+  '@smithy/core@3.18.5':
+    resolution: {integrity: sha512-6gnIz3h+PEPQGDj8MnRSjDvKBah042jEoPgjFGJ4iJLBE78L4lY/n98x14XyPF4u3lN179Ub/ZKFY5za9GeLQw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/credential-provider-imds@4.0.6':
-    resolution: {integrity: sha512-hKMWcANhUiNbCJouYkZ9V3+/Qf9pteR1dnwgdyzR09R4ODEYx8BbUysHwRSyex4rZ9zapddZhLFTnT4ZijR4pw==}
+  '@smithy/credential-provider-imds@4.2.5':
+    resolution: {integrity: sha512-BZwotjoZWn9+36nimwm/OLIcVe+KYRwzMjfhd4QT7QxPm9WY0HiOV8t/Wlh+HVUif0SBVV7ksq8//hPaBC/okQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/fetch-http-handler@5.0.4':
-    resolution: {integrity: sha512-AMtBR5pHppYMVD7z7G+OlHHAcgAN7v0kVKEpHuTO4Gb199Gowh0taYi9oDStFeUhetkeP55JLSVlTW1n9rFtUw==}
+  '@smithy/fetch-http-handler@5.3.6':
+    resolution: {integrity: sha512-3+RG3EA6BBJ/ofZUeTFJA7mHfSYrZtQIrDP9dI8Lf7X6Jbos2jptuLrAAteDiFVrmbEmLSuRG/bUKzfAXk7dhg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/hash-node@4.0.4':
-    resolution: {integrity: sha512-qnbTPUhCVnCgBp4z4BUJUhOEkVwxiEi1cyFM+Zj6o+aY8OFGxUQleKWq8ltgp3dujuhXojIvJWdoqpm6dVO3lQ==}
+  '@smithy/hash-node@4.2.5':
+    resolution: {integrity: sha512-DpYX914YOfA3UDT9CN1BM787PcHfWRBB43fFGCYrZFUH0Jv+5t8yYl+Pd5PW4+QzoGEDvn5d5QIO4j2HyYZQSA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/invalid-dependency@4.0.4':
-    resolution: {integrity: sha512-bNYMi7WKTJHu0gn26wg8OscncTt1t2b8KcsZxvOv56XA6cyXtOAAAaNP7+m45xfppXfOatXF3Sb1MNsLUgVLTw==}
+  '@smithy/invalid-dependency@4.2.5':
+    resolution: {integrity: sha512-2L2erASEro1WC5nV+plwIMxrTXpvpfzl4e+Nre6vBVRR2HKeGGcvpJyyL3/PpiSg+cJG2KpTmZmq934Olb6e5A==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/is-array-buffer@2.2.0':
     resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/is-array-buffer@4.0.0':
-    resolution: {integrity: sha512-saYhF8ZZNoJDTvJBEWgeBccCg+yvp1CX+ed12yORU3NilJScfc6gfch2oVb4QgxZrGUx3/ZJlb+c/dJbyupxlw==}
+  '@smithy/is-array-buffer@4.2.0':
+    resolution: {integrity: sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-content-length@4.0.4':
-    resolution: {integrity: sha512-F7gDyfI2BB1Kc+4M6rpuOLne5LOcEknH1n6UQB69qv+HucXBR1rkzXBnQTB2q46sFy1PM/zuSJOB532yc8bg3w==}
+  '@smithy/middleware-content-length@4.2.5':
+    resolution: {integrity: sha512-Y/RabVa5vbl5FuHYV2vUCwvh/dqzrEY/K2yWPSqvhFUwIY0atLqO4TienjBXakoy4zrKAMCZwg+YEqmH7jaN7A==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-endpoint@4.1.9':
-    resolution: {integrity: sha512-AjDgX4UjORLltD/LZCBQTwjQqEfyrx/GeDTHcYLzIgf87pIT70tMWnN87NQpJru1K4ITirY2htSOxNECZJCBOg==}
+  '@smithy/middleware-endpoint@4.3.12':
+    resolution: {integrity: sha512-9pAX/H+VQPzNbouhDhkW723igBMLgrI8OtX+++M7iKJgg/zY/Ig3i1e6seCcx22FWhE6Q/S61BRdi2wXBORT+A==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-retry@4.1.10':
-    resolution: {integrity: sha512-RyhcA3sZIIvAo6r48b2Nx2qfg0OnyohlaV0fw415xrQyx5HQ2bvHl9vs/WBiDXIP49mCfws5wX4308c9Pi/isw==}
+  '@smithy/middleware-retry@4.4.12':
+    resolution: {integrity: sha512-S4kWNKFowYd0lID7/DBqWHOQxmxlsf0jBaos9chQZUWTVOjSW1Ogyh8/ib5tM+agFDJ/TCxuCTvrnlc+9cIBcQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-serde@4.0.8':
-    resolution: {integrity: sha512-iSSl7HJoJaGyMIoNn2B7czghOVwJ9nD7TMvLhMWeSB5vt0TnEYyRRqPJu/TqW76WScaNvYYB8nRoiBHR9S1Ddw==}
+  '@smithy/middleware-serde@4.2.6':
+    resolution: {integrity: sha512-VkLoE/z7e2g8pirwisLz8XJWedUSY8my/qrp81VmAdyrhi94T+riBfwP+AOEEFR9rFTSonC/5D2eWNmFabHyGQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-stack@4.0.4':
-    resolution: {integrity: sha512-kagK5ggDrBUCCzI93ft6DjteNSfY8Ulr83UtySog/h09lTIOAJ/xUSObutanlPT0nhoHAkpmW9V5K8oPyLh+QA==}
+  '@smithy/middleware-stack@4.2.5':
+    resolution: {integrity: sha512-bYrutc+neOyWxtZdbB2USbQttZN0mXaOyYLIsaTbJhFsfpXyGWUxJpEuO1rJ8IIJm2qH4+xJT0mxUSsEDTYwdQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/node-config-provider@4.1.3':
-    resolution: {integrity: sha512-HGHQr2s59qaU1lrVH6MbLlmOBxadtzTsoO4c+bF5asdgVik3I8o7JIOzoeqWc5MjVa+vD36/LWE0iXKpNqooRw==}
+  '@smithy/node-config-provider@4.3.5':
+    resolution: {integrity: sha512-UTurh1C4qkVCtqggI36DGbLB2Kv8UlcFdMXDcWMbqVY2uRg0XmT9Pb4Vj6oSQ34eizO1fvR0RnFV4Axw4IrrAg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/node-http-handler@4.0.6':
-    resolution: {integrity: sha512-NqbmSz7AW2rvw4kXhKGrYTiJVDHnMsFnX4i+/FzcZAfbOBauPYs2ekuECkSbtqaxETLLTu9Rl/ex6+I2BKErPA==}
+  '@smithy/node-http-handler@4.4.5':
+    resolution: {integrity: sha512-CMnzM9R2WqlqXQGtIlsHMEZfXKJVTIrqCNoSd/QpAyp+Dw0a1Vps13l6ma1fH8g7zSPNsA59B/kWgeylFuA/lw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/property-provider@4.0.4':
-    resolution: {integrity: sha512-qHJ2sSgu4FqF4U/5UUp4DhXNmdTrgmoAai6oQiM+c5RZ/sbDwJ12qxB1M6FnP+Tn/ggkPZf9ccn4jqKSINaquw==}
+  '@smithy/property-provider@4.2.5':
+    resolution: {integrity: sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/protocol-http@5.1.2':
-    resolution: {integrity: sha512-rOG5cNLBXovxIrICSBm95dLqzfvxjEmuZx4KK3hWwPFHGdW3lxY0fZNXfv2zebfRO7sJZ5pKJYHScsqopeIWtQ==}
+  '@smithy/protocol-http@5.3.5':
+    resolution: {integrity: sha512-RlaL+sA0LNMp03bf7XPbFmT5gN+w3besXSWMkA8rcmxLSVfiEXElQi4O2IWwPfxzcHkxqrwBFMbngB8yx/RvaQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/querystring-builder@4.0.4':
-    resolution: {integrity: sha512-SwREZcDnEYoh9tLNgMbpop+UTGq44Hl9tdj3rf+yeLcfH7+J8OXEBaMc2kDxtyRHu8BhSg9ADEx0gFHvpJgU8w==}
+  '@smithy/querystring-builder@4.2.5':
+    resolution: {integrity: sha512-y98otMI1saoajeik2kLfGyRp11e5U/iJYH/wLCh3aTV/XutbGT9nziKGkgCaMD1ghK7p6htHMm6b6scl9JRUWg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/querystring-parser@4.0.4':
-    resolution: {integrity: sha512-6yZf53i/qB8gRHH/l2ZwUG5xgkPgQF15/KxH0DdXMDHjesA9MeZje/853ifkSY0x4m5S+dfDZ+c4x439PF0M2w==}
+  '@smithy/querystring-parser@4.2.5':
+    resolution: {integrity: sha512-031WCTdPYgiQRYNPXznHXof2YM0GwL6SeaSyTH/P72M1Vz73TvCNH2Nq8Iu2IEPq9QP2yx0/nrw5YmSeAi/AjQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/service-error-classification@4.0.5':
-    resolution: {integrity: sha512-LvcfhrnCBvCmTee81pRlh1F39yTS/+kYleVeLCwNtkY8wtGg8V/ca9rbZZvYIl8OjlMtL6KIjaiL/lgVqHD2nA==}
+  '@smithy/service-error-classification@4.2.5':
+    resolution: {integrity: sha512-8fEvK+WPE3wUAcDvqDQG1Vk3ANLR8Px979te96m84CbKAjBVf25rPYSzb4xU4hlTyho7VhOGnh5i62D/JVF0JQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/shared-ini-file-loader@4.0.4':
-    resolution: {integrity: sha512-63X0260LoFBjrHifPDs+nM9tV0VMkOTl4JRMYNuKh/f5PauSjowTfvF3LogfkWdcPoxsA9UjqEOgjeYIbhb7Nw==}
+  '@smithy/shared-ini-file-loader@4.4.0':
+    resolution: {integrity: sha512-5WmZ5+kJgJDjwXXIzr1vDTG+RhF9wzSODQBfkrQ2VVkYALKGvZX1lgVSxEkgicSAFnFhPj5rudJV0zoinqS0bA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/signature-v4@5.1.2':
-    resolution: {integrity: sha512-d3+U/VpX7a60seHziWnVZOHuEgJlclufjkS6zhXvxcJgkJq4UWdH5eOBLzHRMx6gXjsdT9h6lfpmLzbrdupHgQ==}
+  '@smithy/signature-v4@5.3.5':
+    resolution: {integrity: sha512-xSUfMu1FT7ccfSXkoLl/QRQBi2rOvi3tiBZU2Tdy3I6cgvZ6SEi9QNey+lqps/sJRnogIS+lq+B1gxxbra2a/w==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/smithy-client@4.4.1':
-    resolution: {integrity: sha512-XPbcHRfd0iwx8dY5XCBCGyI7uweMW0oezYezxXcG8ANgvZ5YPuC6Ylh+n0bTHpdU3SCMZOnhzgVklYz+p3fIhw==}
+  '@smithy/smithy-client@4.9.8':
+    resolution: {integrity: sha512-8xgq3LgKDEFoIrLWBho/oYKyWByw9/corz7vuh1upv7ZBm0ZMjGYBhbn6v643WoIqA9UTcx5A5htEp/YatUwMA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/types@4.3.1':
-    resolution: {integrity: sha512-UqKOQBL2x6+HWl3P+3QqFD4ncKq0I8Nuz9QItGv5WuKuMHuuwlhvqcZCoXGfc+P1QmfJE7VieykoYYmrOoFJxA==}
+  '@smithy/types@4.9.0':
+    resolution: {integrity: sha512-MvUbdnXDTwykR8cB1WZvNNwqoWVaTRA0RLlLmf/cIFNMM2cKWz01X4Ly6SMC4Kks30r8tT3Cty0jmeWfiuyHTA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/url-parser@4.0.4':
-    resolution: {integrity: sha512-eMkc144MuN7B0TDA4U2fKs+BqczVbk3W+qIvcoCY6D1JY3hnAdCuhCZODC+GAeaxj0p6Jroz4+XMUn3PCxQQeQ==}
+  '@smithy/url-parser@4.2.5':
+    resolution: {integrity: sha512-VaxMGsilqFnK1CeBX+LXnSuaMx4sTL/6znSZh2829txWieazdVxr54HmiyTsIbpOTLcf5nYpq9lpzmwRdxj6rQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-base64@4.0.0':
-    resolution: {integrity: sha512-CvHfCmO2mchox9kjrtzoHkWHxjHZzaFojLc8quxXY7WAAMAg43nuxwv95tATVgQFNDwd4M9S1qFzj40Ul41Kmg==}
+  '@smithy/util-base64@4.3.0':
+    resolution: {integrity: sha512-GkXZ59JfyxsIwNTWFnjmFEI8kZpRNIBfxKjv09+nkAWPt/4aGaEWMM04m4sxgNVWkbt2MdSvE3KF/PfX4nFedQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-body-length-browser@4.0.0':
-    resolution: {integrity: sha512-sNi3DL0/k64/LO3A256M+m3CDdG6V7WKWHdAiBBMUN8S3hK3aMPhwnPik2A/a2ONN+9doY9UxaLfgqsIRg69QA==}
+  '@smithy/util-body-length-browser@4.2.0':
+    resolution: {integrity: sha512-Fkoh/I76szMKJnBXWPdFkQJl2r9SjPt3cMzLdOB6eJ4Pnpas8hVoWPYemX/peO0yrrvldgCUVJqOAjUrOLjbxg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-body-length-node@4.0.0':
-    resolution: {integrity: sha512-q0iDP3VsZzqJyje8xJWEJCNIu3lktUGVoSy1KB0UWym2CL1siV3artm+u1DFYTLejpsrdGyCSWBdGNjJzfDPjg==}
+  '@smithy/util-body-length-node@4.2.1':
+    resolution: {integrity: sha512-h53dz/pISVrVrfxV1iqXlx5pRg3V2YWFcSQyPyXZRrZoZj4R4DeWRDo1a7dd3CPTcFi3kE+98tuNyD2axyZReA==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/util-buffer-from@2.2.0':
     resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/util-buffer-from@4.0.0':
-    resolution: {integrity: sha512-9TOQ7781sZvddgO8nxueKi3+yGvkY35kotA0Y6BWRajAv8jjmigQ1sBwz0UX47pQMYXJPahSKEKYFgt+rXdcug==}
+  '@smithy/util-buffer-from@4.2.0':
+    resolution: {integrity: sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-config-provider@4.0.0':
-    resolution: {integrity: sha512-L1RBVzLyfE8OXH+1hsJ8p+acNUSirQnWQ6/EgpchV88G6zGBTDPdXiiExei6Z1wR2RxYvxY/XLw6AMNCCt8H3w==}
+  '@smithy/util-config-provider@4.2.0':
+    resolution: {integrity: sha512-YEjpl6XJ36FTKmD+kRJJWYvrHeUvm5ykaUS5xK+6oXffQPHeEM4/nXlZPe+Wu0lsgRUcNZiliYNh/y7q9c2y6Q==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-defaults-mode-browser@4.0.17':
-    resolution: {integrity: sha512-HXq5181qnXmIwB7VrwqwP8rsJybHMoYuJnNoXy4PROs2pfSI4sWDMASF2i+7Lo+u64Y6xowhegcdxczowgJtZg==}
+  '@smithy/util-defaults-mode-browser@4.3.11':
+    resolution: {integrity: sha512-yHv+r6wSQXEXTPVCIQTNmXVWs7ekBTpMVErjqZoWkYN75HIFN5y9+/+sYOejfAuvxWGvgzgxbTHa/oz61YTbKw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-defaults-mode-node@4.0.17':
-    resolution: {integrity: sha512-RfU2A5LjFhEHw4Nwl1GZNitK4AUWu5jGtigAUDoQtfDUvYHpQxcuLw2QGAdKDtKRflIiHSZ8wXBDR36H9R2Ang==}
+  '@smithy/util-defaults-mode-node@4.2.14':
+    resolution: {integrity: sha512-ljZN3iRvaJUgulfvobIuG97q1iUuCMrvXAlkZ4msY+ZuVHQHDIqn7FKZCEj+bx8omz6kF5yQXms/xhzjIO5XiA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-endpoints@3.0.6':
-    resolution: {integrity: sha512-YARl3tFL3WgPuLzljRUnrS2ngLiUtkwhQtj8PAL13XZSyUiNLQxwG3fBBq3QXFqGFUXepIN73pINp3y8c2nBmA==}
+  '@smithy/util-endpoints@3.2.5':
+    resolution: {integrity: sha512-3O63AAWu2cSNQZp+ayl9I3NapW1p1rR5mlVHcF6hAB1dPZUQFfRPYtplWX/3xrzWthPGj5FqB12taJJCfH6s8A==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-hex-encoding@4.0.0':
-    resolution: {integrity: sha512-Yk5mLhHtfIgW2W2WQZWSg5kuMZCVbvhFmC7rV4IO2QqnZdbEFPmQnCcGMAX2z/8Qj3B9hYYNjZOhWym+RwhePw==}
+  '@smithy/util-hex-encoding@4.2.0':
+    resolution: {integrity: sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-middleware@4.0.4':
-    resolution: {integrity: sha512-9MLKmkBmf4PRb0ONJikCbCwORACcil6gUWojwARCClT7RmLzF04hUR4WdRprIXal7XVyrddadYNfp2eF3nrvtQ==}
+  '@smithy/util-middleware@4.2.5':
+    resolution: {integrity: sha512-6Y3+rvBF7+PZOc40ybeZMcGln6xJGVeY60E7jy9Mv5iKpMJpHgRE6dKy9ScsVxvfAYuEX4Q9a65DQX90KaQ3bA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-retry@4.0.5':
-    resolution: {integrity: sha512-V7MSjVDTlEt/plmOFBn1762Dyu5uqMrV2Pl2X0dYk4XvWfdWJNe9Bs5Bzb56wkCuiWjSfClVMGcsuKrGj7S/yg==}
+  '@smithy/util-retry@4.2.5':
+    resolution: {integrity: sha512-GBj3+EZBbN4NAqJ/7pAhsXdfzdlznOh8PydUijy6FpNIMnHPSMO2/rP4HKu+UFeikJxShERk528oy7GT79YiJg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-stream@4.2.2':
-    resolution: {integrity: sha512-aI+GLi7MJoVxg24/3J1ipwLoYzgkB4kUfogZfnslcYlynj3xsQ0e7vk4TnTro9hhsS5PvX1mwmkRqqHQjwcU7w==}
+  '@smithy/util-stream@4.5.6':
+    resolution: {integrity: sha512-qWw/UM59TiaFrPevefOZ8CNBKbYEP6wBAIlLqxn3VAIo9rgnTNc4ASbVrqDmhuwI87usnjhdQrxodzAGFFzbRQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-uri-escape@4.0.0':
-    resolution: {integrity: sha512-77yfbCbQMtgtTylO9itEAdpPXSog3ZxMe09AEhm0dU0NLTalV70ghDZFR+Nfi1C60jnJoh/Re4090/DuZh2Omg==}
+  '@smithy/util-uri-escape@4.2.0':
+    resolution: {integrity: sha512-igZpCKV9+E/Mzrpq6YacdTQ0qTiLm85gD6N/IrmyDvQFA4UnU3d5g3m8tMT/6zG/vVkWSU+VxeUyGonL62DuxA==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/util-utf8@2.3.0':
     resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/util-utf8@4.0.0':
-    resolution: {integrity: sha512-b+zebfKCfRdgNJDknHCob3O7FpeYQN6ZG6YLExMcasDHsCXlsXCEuiPZeLnJLpwa5dvPetGlnGCiMHuLwGvFow==}
+  '@smithy/util-utf8@4.2.0':
+    resolution: {integrity: sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw==}
+    engines: {node: '>=18.0.0'}
+
+  '@smithy/uuid@1.1.0':
+    resolution: {integrity: sha512-4aUIteuyxtBUhVdiQqcDhKFitwfd9hqoSDYY2KRXiWtgoWJ9Bmise+KfEPDiVHWeJepvF8xJO9/9+WDIciMFFw==}
     engines: {node: '>=18.0.0'}
 
+  '@socket.io/component-emitter@3.1.2':
+    resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==}
+
+  '@sqlitecloud/drivers@1.0.653':
+    resolution: {integrity: sha512-dW5sQlLOgUD/e+clYcH07kFyoib4d6+9NMWjKj4sttanXYIfTg6GlTYF1ix0dZOoc+dIBybjE4jYv6jy9f+zsA==}
+    engines: {node: '>=18.0'}
+    peerDependencies:
+      '@craftzdog/react-native-buffer': '*'
+      react-native-quick-base64: '*'
+      react-native-tcp-socket: '*'
+      react-native-url-polyfill: '*'
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@tediousjs/connection-string@0.5.0':
+    resolution: {integrity: sha512-7qSgZbincDDDFyRweCIEvZULFAw5iz/DeunhvuxpL31nfntX3P4Yd4HkHBRg9H8CdqY1e5WFN1PZIz/REL9MVQ==}
+
+  '@tediousjs/connection-string@0.6.0':
+    resolution: {integrity: sha512-GxlsW354Vi6QqbUgdPyQVcQjI7cZBdGV5vOYVYuCVDTylx2wl3WHR2HlhcxxHTrMigbelpXsdcZso+66uxPfow==}
+
   '@tidbcloud/serverless@0.1.1':
     resolution: {integrity: sha512-km2P5Mgr9nqVah5p5aMYbO3dBqecSwZ0AU7+BhJH+03L2eJO6qCATcBR8UHPuVLhA7GCt3CambKvVYK79pVQ2g==}
     engines: {node: '>=16'}
@@ -2860,30 +3741,14 @@ packages:
     resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
     engines: {node: '>= 6'}
 
-  '@trivago/prettier-plugin-sort-imports@5.2.2':
-    resolution: {integrity: sha512-fYDQA9e6yTNmA13TLVSA+WMQRc5Bn/c0EUBditUHNfMMxN7M82c38b1kEggVE3pLpZ0FwkwJkUEKMiOi52JXFA==}
-    engines: {node: '>18.12'}
-    peerDependencies:
-      '@vue/compiler-sfc': 3.x
-      prettier: 2.x - 3.x
-      prettier-plugin-svelte: 3.x
-      svelte: 4.x || 5.x
-    peerDependenciesMeta:
-      '@vue/compiler-sfc':
-        optional: true
-      prettier-plugin-svelte:
-        optional: true
-      svelte:
-        optional: true
-
   '@ts-morph/common@0.26.1':
     resolution: {integrity: sha512-Sn28TGl/4cFpcM+jwsH1wLncYq3FtN/BIpem+HOygfBWPT5pAeS5dB4VFVzV8FbnOKHpDLZmvAl4AjPEev5idA==}
 
   '@tsconfig/bun@1.0.7':
     resolution: {integrity: sha512-udGrGJBNQdXGVulehc1aWT73wkR9wdaGBtB6yL70RJsqwW/yJhIg6ZbRlPOfIUiFNrnBuYLBi9CSmMKfDC7dvA==}
 
-  '@tsconfig/node10@1.0.11':
-    resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==}
+  '@tsconfig/node10@1.0.12':
+    resolution: {integrity: sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==}
 
   '@tsconfig/node12@1.0.11':
     resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
@@ -2894,6 +3759,111 @@ packages:
   '@tsconfig/node16@1.0.4':
     resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
 
+  '@tursodatabase/database-common@0.5.3':
+    resolution: {integrity: sha512-DqcHkvp17zGj2q+94ex+x9UR4iDcdv2mOgAsIJ8wcH23ehCu+UZ/848QUME0gO6pqstEhEX5xt3hCr+efVwOxQ==}
+
+  '@tursodatabase/database-common@0.6.0-pre.28':
+    resolution: {integrity: sha512-ZRhAb3S3N/Ecq6ZAkESsxbT31Rgqk+xb92Qk1/oVmFJcDuO8f1D/WUHZ2uIuylhXrPBvAok9LhW20hbT9X4GNA==}
+
+  '@tursodatabase/database-common@0.6.1':
+    resolution: {integrity: sha512-fkmkhgSUDg3MXkcziTG9Ime3AY5+YvvDN7VvUDEMNV7MP+XgwE/i5tU6eQP1EKa/zDkdSYPq8gPcmROmKmKL8Q==}
+
+  '@tursodatabase/database-darwin-arm64@0.5.3':
+    resolution: {integrity: sha512-qMrzByOBn0okPt/wlPAyp095aYf/2CiyZDjr5KvzZ5uFtCIMJGyC88Ay4zQyqzYSW0HFioW5UFSPorFLWMBfJA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tursodatabase/database-darwin-arm64@0.6.0-pre.28':
+    resolution: {integrity: sha512-UQ1Obj+BSZqE8zSfCvnNn3VLGu4ECGGIfkbF9v13+h/HeZr8JroTXdk0Y8WAGvb7m/hyvjEk+gU+1L0ydkKxWQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tursodatabase/database-linux-arm64-gnu@0.5.3':
+    resolution: {integrity: sha512-leZwGy4VDpr523ir7nyHCzFbUaLjVXTE/mcgqZ5ijofLQGyIJG1jae/adVMvzJgIU3OB+cVFKnsfLlEw2P7zeg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tursodatabase/database-linux-arm64-gnu@0.6.0-pre.28':
+    resolution: {integrity: sha512-a5OkedE0AissAbjocvDCsmcQc4gtnVWpwbcbeJ6EoC3oJApK4AzX6vzCl8W4oA7k4cn/V9U4L1QGjWZlLcjePg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tursodatabase/database-linux-x64-gnu@0.5.3':
+    resolution: {integrity: sha512-jWIXtUd2zZL2ahpeo7Mm/NU/y41wkfVrjDmkg6sZD1Dw8Wsul4SGUgouDH435Prwb1ntJAE3QkYd/+lIanVhbQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@tursodatabase/database-linux-x64-gnu@0.6.0-pre.28':
+    resolution: {integrity: sha512-raEgDNNUxZn2jKX0jV6XEozyWt+3wnazstPLx+YhCU3vSGEui4xnD/ehulCRPCKbybOAFLpmeLvkolc29KFLww==}
+    cpu: [x64]
+    os: [linux]
+
+  '@tursodatabase/database-wasm-common@0.5.3':
+    resolution: {integrity: sha512-MfUJGRKPx132JaYf/+xqQkMnOzmZMFIxxL+SjloD/PVWBzPq1BKXNmBpW6UL7J+CZVSo7sOICIawyJV8mBG0DQ==}
+
+  '@tursodatabase/database-wasm-common@0.6.0-pre.28':
+    resolution: {integrity: sha512-wfJ1VyOCptIU8buX4ircYgw8uYKEXKeblDs6kTudPo7kV22FILYh4M4cpjISAIo2i22+8PrOAxPV4wIlwLSOAA==}
+
+  '@tursodatabase/database-wasm@0.5.3':
+    resolution: {integrity: sha512-pdMuE4qJ0YYuHLFlw2qibdSM9DYuRI8SaLZR4VxGXkcp2eN+g7ic6AWxoM5kw6dWOZpUT23hFiCRtJIGc93ZDQ==}
+
+  '@tursodatabase/database-wasm@0.6.0-pre.28':
+    resolution: {integrity: sha512-2qZhabW+qxX32AW2+jDh5uDSjueco3KsASRC8kLjseG2l3j2KijuMCIn8nFnyHfWyPPCBvLsSKpKD7Mru4tD0g==}
+
+  '@tursodatabase/database-win32-x64-msvc@0.5.3':
+    resolution: {integrity: sha512-Blyt6fvmmbiPxO/HNRzmDjyvVqmBpD7hTjV77t+QNCMdI6aNqFN9x5MEjNMelxHon0RXXesXK92jMWJyTvqUPQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@tursodatabase/database-win32-x64-msvc@0.6.0-pre.28':
+    resolution: {integrity: sha512-BrGP+LtkvDR5hxb8a98ltQ9KZgLSn/njLEvDIL/D7OJY811EVcKVtw6dgVDXoQccv3w/NfEGP8MB4kHC4A3dIA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@tursodatabase/database@0.5.3':
+    resolution: {integrity: sha512-Dd9x+oKKkfNPDbBtoCO4QMzBwkNNpQET4wQPt72Yy4bZ1old2gUNjrUzEi17JSSAVpdtCbSaFmeKpsxb/Ie+fw==}
+
+  '@tursodatabase/database@0.6.0-pre.28':
+    resolution: {integrity: sha512-3uwqFwvEeUboSx7Q1/2ST2wGjXxhTmJh8K0jkCb2Amgvp9BJGTmqnLDWC1u3e6QOOHMijMQdetZRTLL+xf2+9Q==}
+
+  '@tursodatabase/serverless@0.2.4':
+    resolution: {integrity: sha512-kqf3FINvTGx8N1iH/4e1Dkbr/om5q9qitshzvljtQXwZFQIsVP/mDE76mGg9U2dg/ElOZKFKtT1VXDgd39Dr1w==}
+
+  '@tursodatabase/serverless@1.1.3':
+    resolution: {integrity: sha512-gy1BiH5uewAPthrEJJVGMig/U997SI843xQsa8jlbvbzE271VU/Ih5CrYXvmFjrugN1JofAlA0ahdH6oIvQVQw==}
+
+  '@tursodatabase/serverless@1.2.0-pre.1':
+    resolution: {integrity: sha512-InPOYP4uEECaBLG/7+XTxiUhpIW3IOaXQLkN5M+xghTcn8ANms/VZU5FTIVFhd+rrjrEp+Dr8oxBdP3nCRqg2A==}
+
+  '@tursodatabase/sync-common@0.6.1':
+    resolution: {integrity: sha512-QjImpfwGomXRPmr7+KQUxN1RHslOCY77ElHgmAdpDy0IAqp4WDO12waPpzV45hxoVb6tlmuArFEDdBGdiq9npQ==}
+
+  '@tursodatabase/sync-darwin-arm64@0.6.0':
+    resolution: {integrity: sha512-8RzoxroxG5UJaDX+xarCukwTyrw2AygMeEHSR+Xb0I2oKTHMACgnhvmokLGZUP3hOwygp0+QrShZx+qU7K8WBw==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tursodatabase/sync-linux-arm64-gnu@0.6.0':
+    resolution: {integrity: sha512-7dogVhpxI+KPj8mvxFbUqYuBaV+6emOSj3XIeKwAr+KdQF97li35Qpab6UqeJoS7aHNU64uoAEuK0GXy2i3Ykw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tursodatabase/sync-linux-x64-gnu@0.6.0':
+    resolution: {integrity: sha512-KxHRnE+5c1jmxaWRAMV9mA9Y5AYugvZ8bK91BNhmqvKah0lD6vSiQULWkA0gZx+vrGuj4nfYzwZpM4xUbId+xA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@tursodatabase/sync-win32-x64-msvc@0.6.0':
+    resolution: {integrity: sha512-c+LzrfAgycMA+lS2smGn+MGfz4+5Yu8BWTe+KMoZOzTvOGNZHd870h9bSU71y4hdN43BPal6fja5sdl95SdolA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@tursodatabase/sync@0.6.0':
+    resolution: {integrity: sha512-Oys6WOS7EgC0YgFW34SOlRvQlGuE5KhqxlY51HVqe/lxnA/EmVoe15mDOxCf4umuDArq9Js+432Ol2sgjh730A==}
+
+  '@tybys/wasm-util@0.10.1':
+    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+
   '@types/async-retry@1.4.9':
     resolution: {integrity: sha512-s1ciZQJzRh3708X/m3vPExr5KJlzlZJvXsKpbtE2luqNcbROr64qU+3KpJsYHqWMeaxI839OvXf9PrUSw1Xtyg==}
 
@@ -2906,8 +3876,8 @@ packages:
   '@types/babel__template@7.4.4':
     resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
 
-  '@types/babel__traverse@7.20.7':
-    resolution: {integrity: sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==}
+  '@types/babel__traverse@7.28.0':
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
 
   '@types/better-sqlite3@7.6.13':
     resolution: {integrity: sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==}
@@ -2915,8 +3885,11 @@ packages:
   '@types/braces@3.0.5':
     resolution: {integrity: sha512-SQFof9H+LXeWNz8wDe7oN5zu7ket0qwMu5vZubW4GCJ8Kkeh6nBWUz87+KTz/G3Kqsrp0j/W253XJb3KMEeg3w==}
 
-  '@types/chai@5.2.2':
-    resolution: {integrity: sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==}
+  '@types/bun@1.3.3':
+    resolution: {integrity: sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g==}
+
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
 
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
@@ -2924,17 +3897,14 @@ packages:
   '@types/docker-modem@3.0.6':
     resolution: {integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg==}
 
-  '@types/dockerode@3.3.39':
-    resolution: {integrity: sha512-uMPmxehH6ofeYjaslASPtjvyH8FRJdM9fZ+hjhGzL4Jq3bGjr9D7TKmp9soSwgFncNk0HOwmyBxjqOb3ikjjsA==}
-
-  '@types/emscripten@1.40.1':
-    resolution: {integrity: sha512-sr53lnYkQNhjHNN0oJDdUm5564biioI5DuOpycufDVK7D3y+GR3oUswe2rlwY1nPNyusHbrJ9WoTyIHl4/Bpwg==}
+  '@types/dockerode@3.3.47':
+    resolution: {integrity: sha512-ShM1mz7rCjdssXt7Xz0u1/R2BJC7piWa3SJpUBiVjCf2A3XNn4cP6pUVaD8bLanpPVVn4IKzJuw3dOvkJ8IbYw==}
 
-  '@types/estree@1.0.7':
-    resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
+  '@types/emscripten@1.41.5':
+    resolution: {integrity: sha512-cMQm7pxu6BxtHyqJ7mQZ2kXWV5SLmugybFdHCBbJ5eHzOo6VhBckEgAT3//rP5FwPHNPeEiq4SmQ5ucBwsOo4Q==}
 
-  '@types/fs-extra@11.0.4':
-    resolution: {integrity: sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==}
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
   '@types/glob@8.1.0':
     resolution: {integrity: sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w==}
@@ -2951,44 +3921,50 @@ packages:
   '@types/istanbul-reports@3.0.4':
     resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==}
 
+  '@types/jsesc@2.5.1':
+    resolution: {integrity: sha512-9VN+6yxLOPLOav+7PwjZbxiID2bVaeq0ED4qSQmdQTdjnXJSaCVKTR58t15oqH1H5t8Ng2ZX1SabJVoN9Q34bw==}
+
   '@types/json-diff@1.0.3':
     resolution: {integrity: sha512-Qvxm8fpRMv/1zZR3sQWImeRK2mBYJji20xF51Fq9Gt//Ed18u0x6/FNLogLS1xhfUWTEmDyqveJqn95ltB6Kvw==}
 
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
 
-  '@types/json5@0.0.29':
-    resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
+  '@types/marked-terminal@3.1.3':
+    resolution: {integrity: sha512-dKgOLKlI5zFb2jTbRcyQqbdrHxeU74DCOkVIZtsoB2sc1ctXZ1iB2uxG2jjAuzoLdvwHP065ijN6Q8HecWdWYg==}
 
-  '@types/jsonfile@6.1.4':
-    resolution: {integrity: sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ==}
+  '@types/marked@3.0.4':
+    resolution: {integrity: sha512-fzrd0O45A0hZl3+Fs3+BcuD3SF+kEkV0KHBXrSPi1B73PnDJI9wcUkpA8JoujFKqgyOijeKgIllFYsgJFhNB5g==}
 
-  '@types/micromatch@4.0.9':
-    resolution: {integrity: sha512-7V+8ncr22h4UoYRLnLXSpTxjQrNUXtWHGeMPRJt1nULXI57G9bIcpyrHlmrQ7QK24EyyuXvYcSSWAM8GA9nqCg==}
+  '@types/micromatch@4.0.10':
+    resolution: {integrity: sha512-5jOhFDElqr4DKTrTEbnW8DZ4Hz5LRUEmyrGpCMrD/NphYv3nUnaF08xmSLx1rGGnyEs/kFnhiw6dCgcDqMr5PQ==}
 
   '@types/minimatch@5.1.2':
     resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==}
 
-  '@types/minimist@1.2.5':
-    resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==}
+  '@types/mssql@9.1.8':
+    resolution: {integrity: sha512-mt9h5jWj+DYE5jxnKaWSV/GqDf9FV52XYVk6T3XZF69noEe+JJV6MKirii48l81+cjmAkSq+qeKX+k61fHkYrQ==}
+
+  '@types/node@18.19.130':
+    resolution: {integrity: sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==}
 
-  '@types/node@18.19.110':
-    resolution: {integrity: sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q==}
+  '@types/node@20.19.25':
+    resolution: {integrity: sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==}
 
-  '@types/node@20.17.57':
-    resolution: {integrity: sha512-f3T4y6VU4fVQDKVqJV4Uppy8c1p/sVvS3peyqxyWnzkqXFJLRU7Y1Bl7rMS1Qe9z0v4M6McY0Fp9yBsgHJUsWQ==}
+  '@types/node@22.19.1':
+    resolution: {integrity: sha512-LCCV0HdSZZZb34qifBsyWlUmok6W7ouER+oQIGBScS8EsZsQbrtFTUrDX4hOl+CS6p7cnNC4td+qrSVGSCTUfQ==}
 
-  '@types/node@22.15.29':
-    resolution: {integrity: sha512-LNdjOkUDlU1RZb8e1kOIUpN1qQUlzGkEtbVNo53vbrwDg5om6oduhm4SiUaPW5ASTXhAiP0jInWG8Qx9fVlOeQ==}
+  '@types/node@24.10.1':
+    resolution: {integrity: sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==}
 
-  '@types/normalize-package-data@2.4.4':
-    resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
+  '@types/node@25.5.0':
+    resolution: {integrity: sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw==}
 
   '@types/pg@8.11.6':
     resolution: {integrity: sha512-/2WmmBXHLsfRqzfHW7BNZ8SbYzE8OSk7i3WjFYvfgRHj7S1xj+16Je5fUKv3lVdVzk/zn9TXOqf+avFCFIE0yQ==}
 
-  '@types/pg@8.15.4':
-    resolution: {integrity: sha512-I6UNVBAoYbvuWkkU3oosC8yxqH21f4/Jc4DK71JLG3dT2mdlGe1z+ep/LQGXaKaOgcvUrsQoPRqfgtMcvZiJhg==}
+  '@types/pg@8.15.6':
+    resolution: {integrity: sha512-NoaMtzhxOrubeL/7UZuNTrejB4MPAJ0RpxZqXQf2qXuVlTPuG6Y8p4u9dKRaue4yjmC7ZhzVO2/Yyyn25znrPQ==}
 
   '@types/pg@8.6.6':
     resolution: {integrity: sha512-O2xNmXebtwVekJDD+02udOncjVcMZQuTEQEMpKJ0ZRf5E7/9JJX3izhKUcUifBkyKpljyUM6BTgy2trmviKlpw==}
@@ -2996,20 +3972,20 @@ packages:
   '@types/pluralize@0.0.33':
     resolution: {integrity: sha512-JOqsl+ZoCpP4e8TDke9W79FDcSgPAR0l6pixx2JHkhnRjvShyYiAYw2LVsnA7K08Y6DeOnaU6ujmENO4os/cYg==}
 
-  '@types/prop-types@15.7.14':
-    resolution: {integrity: sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==}
+  '@types/prop-types@15.7.15':
+    resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
 
-  '@types/ps-tree@1.1.6':
-    resolution: {integrity: sha512-PtrlVaOaI44/3pl3cvnlK+GxOM3re2526TJvPvh7W+keHIXdV4TE0ylpPBAcvFQCbGitaTXwL9u+RF7qtVeazQ==}
+  '@types/react@18.3.27':
+    resolution: {integrity: sha512-cisd7gxkzjBKU2GgdYrTdtQx1SORymWyaAFhaxQPK9bYO9ot3Y5OikQRvY0VYQtvwjeQnizCINJAenh/V7MK2w==}
 
-  '@types/react@18.3.23':
-    resolution: {integrity: sha512-/LDXMQh55EzZQ0uVAZmKKhfENivEvWz6E+EYzh+/MCjMhNsotd+ZHhBGIjFDTi6+fz0OhQQQLbTgdQIxxCsC0w==}
+  '@types/readable-stream@4.0.22':
+    resolution: {integrity: sha512-/FFhJpfCLAPwAcN3mFycNUa77ddnr8jTgF5VmSNetaemWB2cIlfCA9t0YTM3JAT0wOcv8D4tjPo7pkDhK3EJIg==}
 
   '@types/retry@0.12.5':
     resolution: {integrity: sha512-3xSjTp3v03X/lSQLkczaN9UIEwJMoMCA1+Nb5HfbJEQWogdeQIyVtTvxPXDQjZ5zws8rFQfVfRdz03ARihPJgw==}
 
-  '@types/semver@7.7.0':
-    resolution: {integrity: sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA==}
+  '@types/semver@7.7.1':
+    resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==}
 
   '@types/sql.js@1.4.9':
     resolution: {integrity: sha512-ep8b36RKHlgWPqjNG9ToUrPiwkhwh0AEzy883mO5Xnd+cL6VBH1EvSjBAAuxLUFF2Vn/moE3Me6v9E1Lo+48GQ==}
@@ -3026,8 +4002,8 @@ packages:
   '@types/uuid@9.0.8':
     resolution: {integrity: sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA==}
 
-  '@types/which@3.0.4':
-    resolution: {integrity: sha512-liyfuo/106JdlgSchJzXEQCVArk0CvevqPote8F8HgWgJ3dRCcTHgJIsLDuee0kxk/mhbInzIZk3QWSZJ8R+2w==}
+  '@types/validate-npm-package-name@4.0.2':
+    resolution: {integrity: sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw==}
 
   '@types/ws@8.18.1':
     resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
@@ -3035,117 +4011,34 @@ packages:
   '@types/yargs-parser@21.0.3':
     resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==}
 
-  '@types/yargs@17.0.33':
-    resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==}
+  '@types/yargs@17.0.35':
+    resolution: {integrity: sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==}
 
-  '@typescript-eslint/eslint-plugin@6.21.0':
-    resolution: {integrity: sha512-oy9+hTPCUFpngkEZUSzbf9MxI65wbKFoQYsgPdILTfbUldp5ovUuphZVe4i30emU9M/kP+T64Di0mxl7dSw3MA==}
+  '@typescript-eslint/parser@6.21.0':
+    resolution: {integrity: sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
       eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
 
-  '@typescript-eslint/eslint-plugin@7.18.0':
-    resolution: {integrity: sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
+  '@typescript-eslint/rule-tester@6.21.0':
+    resolution: {integrity: sha512-twxQo4He8+AQ/YG70Xt7Fl/ImBLpi7qElxHN6/aK+U4z97JsITCG7DdIIUw5M+qKtDMCYkZCEE2If8dnHI7jWA==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^7.0.0
-      eslint: ^8.56.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
+      '@eslint/eslintrc': '>=2'
+      eslint: '>=8'
 
-  '@typescript-eslint/experimental-utils@5.62.0':
-    resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-
-  '@typescript-eslint/parser@6.21.0':
-    resolution: {integrity: sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    peerDependencies:
-      eslint: ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  '@typescript-eslint/parser@7.18.0':
-    resolution: {integrity: sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    peerDependencies:
-      eslint: ^8.56.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  '@typescript-eslint/rule-tester@6.21.0':
-    resolution: {integrity: sha512-twxQo4He8+AQ/YG70Xt7Fl/ImBLpi7qElxHN6/aK+U4z97JsITCG7DdIIUw5M+qKtDMCYkZCEE2If8dnHI7jWA==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    peerDependencies:
-      '@eslint/eslintrc': '>=2'
-      eslint: '>=8'
-
-  '@typescript-eslint/scope-manager@5.62.0':
-    resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-
-  '@typescript-eslint/scope-manager@6.21.0':
-    resolution: {integrity: sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-
-  '@typescript-eslint/scope-manager@7.18.0':
-    resolution: {integrity: sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-
-  '@typescript-eslint/type-utils@6.21.0':
-    resolution: {integrity: sha512-rZQI7wHfao8qMX3Rd3xqeYSMCL3SoiSQLBATSiVKARdFGCYSRvmViieZjqc58jKgs8Y8i9YvVVhRbHSTA4VBag==}
-    engines: {node: ^16.0.0 || >=18.0.0}
-    peerDependencies:
-      eslint: ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  '@typescript-eslint/type-utils@7.18.0':
-    resolution: {integrity: sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    peerDependencies:
-      eslint: ^8.56.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  '@typescript-eslint/types@5.62.0':
-    resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  '@typescript-eslint/scope-manager@6.21.0':
+    resolution: {integrity: sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
 
   '@typescript-eslint/types@6.21.0':
     resolution: {integrity: sha512-1kFmZ1rOm5epu9NZEZm1kckCDGj5UJEf7P1kliH4LKu/RkwpsfqqGmY2OOcUs18lSlQBKLDYBOGxRVtrMN5lpg==}
     engines: {node: ^16.0.0 || >=18.0.0}
 
-  '@typescript-eslint/types@7.18.0':
-    resolution: {integrity: sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-
-  '@typescript-eslint/typescript-estree@5.62.0':
-    resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
   '@typescript-eslint/typescript-estree@6.21.0':
     resolution: {integrity: sha512-6npJTkZcO+y2/kr+z0hc4HwNfrrP4kNYh57ek7yCNlrBjWQ1Y0OS7jiZTkgumrvkX5HkEKXFZkkdFNkaW2wmUQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -3155,45 +4048,16 @@ packages:
       typescript:
         optional: true
 
-  '@typescript-eslint/typescript-estree@7.18.0':
-    resolution: {integrity: sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  '@typescript-eslint/utils@5.62.0':
-    resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-
   '@typescript-eslint/utils@6.21.0':
     resolution: {integrity: sha512-NfWVaC8HP9T8cbKQxHcsJBY5YE1O33+jpMwN45qzWWaPDZgLIbo12toGMWnmhvCpd3sIxkpDw3Wv1B3dYrbDQQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
 
-  '@typescript-eslint/utils@7.18.0':
-    resolution: {integrity: sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-    peerDependencies:
-      eslint: ^8.56.0
-
-  '@typescript-eslint/visitor-keys@5.62.0':
-    resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-
   '@typescript-eslint/visitor-keys@6.21.0':
     resolution: {integrity: sha512-JJtkDduxLi9bivAB+cYOVMtbkqdPOhZ+ZI5LC47MIRrDV4Yn2o+ZnW10Nkmr28xRpSpdJ6Sm42Hjf2+REYXm0A==}
     engines: {node: ^16.0.0 || >=18.0.0}
 
-  '@typescript-eslint/visitor-keys@7.18.0':
-    resolution: {integrity: sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==}
-    engines: {node: ^18.18.0 || >=20.0.0}
-
   '@typescript/analyze-trace@0.10.1':
     resolution: {integrity: sha512-RnlSOPh14QbopGCApgkSx5UBgGda5MX1cHqp2fsqfiDyCwGL/m1jaeB9fzu7didVS81LQqGZZuxFBcg8YU8EVw==}
     hasBin: true
@@ -3203,69 +4067,98 @@ packages:
     peerDependencies:
       typescript: '*'
 
+  '@typespec/ts-http-runtime@0.3.2':
+    resolution: {integrity: sha512-IlqQ/Gv22xUC1r/WQm4StLkYQmaaTsXAhUVsNE0+xiyf0yRFiH5++q78U3bw6bLKDCTmh0uqKB9eG9+Bt75Dkg==}
+    engines: {node: '>=20.0.0'}
+
   '@ungap/structured-clone@1.3.0':
     resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+    deprecated: Potential CWE-502 - Update to 1.3.1 or higher
 
-  '@upstash/redis@1.35.0':
-    resolution: {integrity: sha512-WUm0Jz1xN4DBDGeJIi2Y0kVsolWRB2tsVds4SExaiLg4wBdHFMB+8IfZtBWr+BP0FvhuBr5G1/VLrJ9xzIWHsg==}
+  '@upstash/redis@1.35.7':
+    resolution: {integrity: sha512-bdCdKhke+kYUjcLLuGWSeQw7OLuWIx3eyKksyToLBAlGIMX9qiII0ptp8E0y7VFE1yuBxBd/3kSzJ8774Q4g+A==}
 
-  '@urql/core@5.1.1':
-    resolution: {integrity: sha512-aGh024z5v2oINGD/In6rAtVKTm4VmQ2TxKQBAtk2ZSME5dunZFcjltw4p5ENQg+5CBhZ3FHMzl0Oa+rwqiWqlg==}
+  '@urql/core@5.2.0':
+    resolution: {integrity: sha512-/n0ieD0mvvDnVAXEQgX/7qJiVcvYvNkOHeBvkwtylfjydar123caCXcl58PXFY11oU1oquJocVXHxLAbtv4x1A==}
 
-  '@urql/exchange-retry@1.3.1':
-    resolution: {integrity: sha512-EEmtFu8JTuwsInqMakhLq+U3qN8ZMd5V3pX44q0EqD2imqTDsa8ikZqJ1schVrN8HljOdN+C08cwZ1/r5uIgLw==}
+  '@urql/exchange-retry@1.3.2':
+    resolution: {integrity: sha512-TQMCz2pFJMfpNxmSfX1VSfTjwUIFx/mL+p1bnfM1xjjdla7Z+KnGMW/EhFbpckp3LyWAH4PgOsMwOMnIN+MBFg==}
     peerDependencies:
       '@urql/core': ^5.0.0
 
   '@vercel/postgres@0.8.0':
     resolution: {integrity: sha512-/QUV9ExwaNdKooRjOQqvrKNVnRvsaXeukPNI5DB1ovUTesglfR/fparw7ngo1KUWWKIVpEj2TRrA+ObRHRdaLg==}
     engines: {node: '>=14.6'}
+    deprecated: '@vercel/postgres is deprecated. If you are setting up a new database, you can choose an alternate storage solution from the Vercel Marketplace. If you had an existing Vercel Postgres database, it should have been migrated to Neon as a native Vercel integration. You can find more details and the guide to migrate to Neon''s SDKs here: https://neon.com/docs/guides/vercel-postgres-transition-guide'
+
+  '@vitest/expect@2.1.9':
+    resolution: {integrity: sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==}
 
-  '@vitest/expect@3.2.0':
-    resolution: {integrity: sha512-0v4YVbhDKX3SKoy0PHWXpKhj44w+3zZkIoVES9Ex2pq+u6+Bijijbi2ua5kE+h3qT6LBWFTNZSCOEU37H8Y5sA==}
+  '@vitest/expect@4.0.13':
+    resolution: {integrity: sha512-zYtcnNIBm6yS7Gpr7nFTmq8ncowlMdOJkWLqYvhr/zweY6tFbDkDi8BPPOeHxEtK1rSI69H7Fd4+1sqvEGli6w==}
+
+  '@vitest/mocker@2.1.9':
+    resolution: {integrity: sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^5.0.0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
 
-  '@vitest/mocker@3.2.0':
-    resolution: {integrity: sha512-HFcW0lAMx3eN9vQqis63H0Pscv0QcVMo1Kv8BNysZbxcmHu3ZUYv59DS6BGYiGQ8F5lUkmsfMMlPm4DJFJdf/A==}
+  '@vitest/mocker@4.0.13':
+    resolution: {integrity: sha512-eNCwzrI5djoauklwP1fuslHBjrbR8rqIVbvNlAnkq1OTa6XT+lX68mrtPirNM9TnR69XUPt4puBCx2Wexseylg==}
     peerDependencies:
       msw: ^2.4.9
-      vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0
+      vite: ^6.0.0 || ^7.0.0-0
     peerDependenciesMeta:
       msw:
         optional: true
       vite:
         optional: true
 
-  '@vitest/pretty-format@3.2.0':
-    resolution: {integrity: sha512-gUUhaUmPBHFkrqnOokmfMGRBMHhgpICud9nrz/xpNV3/4OXCn35oG+Pl8rYYsKaTNd/FAIrqRHnwpDpmYxCYZw==}
+  '@vitest/pretty-format@2.1.9':
+    resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==}
 
-  '@vitest/runner@3.2.0':
-    resolution: {integrity: sha512-bXdmnHxuB7fXJdh+8vvnlwi/m1zvu+I06i1dICVcDQFhyV4iKw2RExC/acavtDn93m/dRuawUObKsrNE1gJacA==}
+  '@vitest/pretty-format@4.0.13':
+    resolution: {integrity: sha512-ooqfze8URWbI2ozOeLDMh8YZxWDpGXoeY3VOgcDnsUxN0jPyPWSUvjPQWqDGCBks+opWlN1E4oP1UYl3C/2EQA==}
 
-  '@vitest/snapshot@3.2.0':
-    resolution: {integrity: sha512-z7P/EneBRMe7hdvWhcHoXjhA6at0Q4ipcoZo6SqgxLyQQ8KSMMCmvw1cSt7FHib3ozt0wnRHc37ivuUMbxzG/A==}
+  '@vitest/runner@2.1.9':
+    resolution: {integrity: sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==}
 
-  '@vitest/spy@3.2.0':
-    resolution: {integrity: sha512-s3+TkCNUIEOX99S0JwNDfsHRaZDDZZR/n8F0mop0PmsEbQGKZikCGpTGZ6JRiHuONKew3Fb5//EPwCP+pUX9cw==}
+  '@vitest/runner@4.0.13':
+    resolution: {integrity: sha512-9IKlAru58wcVaWy7hz6qWPb2QzJTKt+IOVKjAx5vb5rzEFPTL6H4/R9BMvjZ2ppkxKgTrFONEJFtzvnyEpiT+A==}
 
-  '@vitest/ui@1.6.1':
-    resolution: {integrity: sha512-xa57bCPGuzEFqGjPs3vVLyqareG8DX0uMkr5U/v5vLv5/ZUrBrPL7gzxzTJedEyZxFMfsozwTIbbYfEQVo3kgg==}
-    peerDependencies:
-      vitest: 1.6.1
+  '@vitest/snapshot@2.1.9':
+    resolution: {integrity: sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==}
+
+  '@vitest/snapshot@4.0.13':
+    resolution: {integrity: sha512-hb7Usvyika1huG6G6l191qu1urNPsq1iFc2hmdzQY3F5/rTgqQnwwplyf8zoYHkpt7H6rw5UfIw6i/3qf9oSxQ==}
 
-  '@vitest/utils@1.6.1':
-    resolution: {integrity: sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==}
+  '@vitest/spy@2.1.9':
+    resolution: {integrity: sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==}
 
-  '@vitest/utils@3.2.0':
-    resolution: {integrity: sha512-gXXOe7Fj6toCsZKVQouTRLJftJwmvbhH5lKOBR6rlP950zUq9AitTUjnFoXS/CqjBC2aoejAztLPzzuva++XBw==}
+  '@vitest/spy@4.0.13':
+    resolution: {integrity: sha512-hSu+m4se0lDV5yVIcNWqjuncrmBgwaXa2utFLIrBkQCQkt+pSwyZTPFQAZiiF/63j8jYa8uAeUZ3RSfcdWaYWw==}
+
+  '@vitest/utils@2.1.9':
+    resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==}
+
+  '@vitest/utils@4.0.13':
+    resolution: {integrity: sha512-ydozWyQ4LZuu8rLp47xFUWis5VOKMdHjXCWhs1LuJsTNKww+pTHQNK4e0assIB9K80TxFyskENL6vCu3j34EYA==}
 
   '@xata.io/client@0.29.5':
     resolution: {integrity: sha512-b55dmPVNVFOE5nj2F2G6t9l/d5yYBhIu5X5w3rznhhsriGHkrzn93tqJexIZPS77E7f/yDXcFz06KbvR3bHK5w==}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       typescript: '>=4.5'
 
-  '@xmldom/xmldom@0.8.10':
-    resolution: {integrity: sha512-2WALfTl4xo2SkGCYRt6rDTFfk9R1czmBvUQy12gK2KuRKIpWEhcbbzy8EZXtz/jkRqHX8bFEc6FC1HjX4TUWYw==}
+  '@xmldom/xmldom@0.8.11':
+    resolution: {integrity: sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==}
     engines: {node: '>=10.0.0'}
+    deprecated: this version has critical issues, please update to the latest version
 
   abbrev@1.1.1:
     resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
@@ -3296,8 +4189,8 @@ packages:
     resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}
     engines: {node: '>=0.4.0'}
 
-  acorn@8.14.1:
-    resolution: {integrity: sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==}
+  acorn@8.15.0:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
     engines: {node: '>=0.4.0'}
     hasBin: true
 
@@ -3305,8 +4198,8 @@ packages:
     resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
     engines: {node: '>= 6.0.0'}
 
-  agent-base@7.1.3:
-    resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==}
+  agent-base@7.1.4:
+    resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
     engines: {node: '>= 14'}
 
   agentkeepalive@4.6.0:
@@ -3321,9 +4214,20 @@ packages:
     resolution: {integrity: sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==}
     engines: {node: '>=12'}
 
+  ajv-formats@3.0.1:
+    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
   ajv@6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
+  ajv@8.20.0:
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
+
   anser@1.4.10:
     resolution: {integrity: sha512-hCv9AqTQ8ycjpSd3upOJd7vFwW1JaoYQ7tpham03GJ1ca8/65rqn0RpaWpItOAd6ylW9wAw6luXYPJIyPFVOww==}
 
@@ -3335,12 +4239,8 @@ packages:
     resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
     engines: {node: '>=8'}
 
-  ansi-escapes@6.2.1:
-    resolution: {integrity: sha512-4nJ3yixlEthEJ9Rk4vPcdBRkZvQZlYyu8j4/Mqz5sgIkddmEnH2Yj2ZrnP9S3tQOvSNRUIgVNF/1yPpRAGNRig==}
-    engines: {node: '>=14.16'}
-
-  ansi-escapes@7.0.0:
-    resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==}
+  ansi-escapes@7.2.0:
+    resolution: {integrity: sha512-g6LhBsl+GBPRWGWsBtutpzBYuIIdBkLEvad5C/va/74Db018+5TZiyA26cZJAr3Rft5lprVqOIPxf5Vid6tqAw==}
     engines: {node: '>=18'}
 
   ansi-regex@4.1.1:
@@ -3351,8 +4251,8 @@ packages:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
 
-  ansi-regex@6.1.0:
-    resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==}
+  ansi-regex@6.2.2:
+    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
     engines: {node: '>=12'}
 
   ansi-styles@3.2.1:
@@ -3367,12 +4267,13 @@ packages:
     resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
     engines: {node: '>=10'}
 
-  ansi-styles@6.2.1:
-    resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
+  ansi-styles@6.2.3:
+    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
     engines: {node: '>=12'}
 
-  ansicolors@0.3.2:
-    resolution: {integrity: sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==}
+  ansis@4.2.0:
+    resolution: {integrity: sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==}
+    engines: {node: '>=14'}
 
   any-promise@1.3.0:
     resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
@@ -3381,8 +4282,8 @@ packages:
     resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
     engines: {node: '>= 8'}
 
-  aproba@2.0.0:
-    resolution: {integrity: sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==}
+  aproba@2.1.0:
+    resolution: {integrity: sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==}
 
   are-we-there-yet@3.0.1:
     resolution: {integrity: sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==}
@@ -3404,44 +4305,29 @@ packages:
   argsarray@0.0.1:
     resolution: {integrity: sha512-u96dg2GcAKtpTrBdDoFIM7PjcBA+6rSP0OR94MOReNRyUECL6MtQt5XXmRr4qrftYaef9+l5hcpO5te7sML1Cg==}
 
-  arktype@2.1.19:
-    resolution: {integrity: sha512-notORSuTSpfLV7rq0kYC4mTgIVlVR0xQuvtFxOaE9aKiXyON/kgoIBwZZcKeSSb4BebNcfJoGlxJicAUl/HMdw==}
+  arkregex@0.0.4:
+    resolution: {integrity: sha512-biS/FkvSwQq59TZ453piUp8bxMui11pgOMV9WHAnli1F8o0ayNCZzUwQadL/bGIUic5TkS/QlPcyMuI8ZIwedQ==}
+
+  arkregex@0.0.5:
+    resolution: {integrity: sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw==}
 
   arktype@2.1.20:
     resolution: {integrity: sha512-IZCEEXaJ8g+Ijd59WtSYwtjnqXiwM8sWQ5EjGamcto7+HVN9eK0C4p0zDlCuAwWhpqr6fIBkxPuYDl4/Mcj/+Q==}
 
-  array-buffer-byte-length@1.0.2:
-    resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
-    engines: {node: '>= 0.4'}
+  arktype@2.1.28:
+    resolution: {integrity: sha512-LVZqXl2zWRpNFnbITrtFmqeqNkPPo+KemuzbGSY6jvJwCb4v8NsDzrWOLHnQgWl26TkJeWWcUNUeBpq2Mst1/Q==}
+
+  arktype@2.2.0:
+    resolution: {integrity: sha512-t54MZ7ti5BhOEvzEkgKnWvqj+UbDfWig+DHr5I34xatymPusKLS0lQpNJd8M6DzmIto2QGszHfNKoFIT8tMCZQ==}
 
   array-find-index@1.0.2:
     resolution: {integrity: sha512-M1HQyIXcBGtVywBt8WVdim+lrNaK7VHp99Qt5pSNziXznKHViIBbXWtfRTpEFpF/c4FdfxNAsCCwPp5phBYJtw==}
     engines: {node: '>=0.10.0'}
 
-  array-includes@3.1.9:
-    resolution: {integrity: sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==}
-    engines: {node: '>= 0.4'}
-
   array-union@2.1.0:
     resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
     engines: {node: '>=8'}
 
-  array.prototype.findlastindex@1.2.6:
-    resolution: {integrity: sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==}
-    engines: {node: '>= 0.4'}
-
-  array.prototype.flat@1.3.3:
-    resolution: {integrity: sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==}
-    engines: {node: '>= 0.4'}
-
-  array.prototype.flatmap@1.3.3:
-    resolution: {integrity: sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==}
-    engines: {node: '>= 0.4'}
-
-  arraybuffer.prototype.slice@1.0.4:
-    resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==}
-    engines: {node: '>= 0.4'}
-
   arrgv@1.0.2:
     resolution: {integrity: sha512-a4eg4yhp7mmruZDQFqVMlxNRFGi/i1r87pt8SDHy0/I8PqSXoUTlWZRdAZo0VXgvEARcujbtTk8kiZRi1uDGRw==}
     engines: {node: '>=8.0.0'}
@@ -3460,14 +4346,14 @@ packages:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
 
+  ast-kit@3.0.0-beta.1:
+    resolution: {integrity: sha512-trmleAnZ2PxN/loHWVhhx1qeOHSRXq4TDsBBxq3GqeJitfk3+jTQ+v/C1km/KYq9M7wKqCewMh+/NAvVH7m+bw==}
+    engines: {node: '>=20.19.0'}
+
   ast-types@0.16.1:
     resolution: {integrity: sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==}
     engines: {node: '>=4'}
 
-  async-function@1.0.0:
-    resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
-    engines: {node: '>= 0.4'}
-
   async-limiter@1.0.1:
     resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==}
 
@@ -3491,6 +4377,7 @@ packages:
   aws-sdk@2.1692.0:
     resolution: {integrity: sha512-x511uiJ/57FIsbgUe5csJ13k3uzu25uWQE+XqfBis/sB0SFoiElJWXRkgEAUh0U6n40eT3ay5Ue4oPkRMu1LYw==}
     engines: {node: '>= 10.0.0'}
+    deprecated: The AWS SDK for JavaScript (v2) has reached end-of-support, and no longer receives updates. Please migrate your code to use AWS SDK for JavaScript (v3). More info https://a.co/cUPnyil
 
   aws-ssl-profiles@1.1.2:
     resolution: {integrity: sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==}
@@ -3513,41 +4400,51 @@ packages:
     resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
-  babel-plugin-polyfill-corejs2@0.4.13:
-    resolution: {integrity: sha512-3sX/eOms8kd3q2KZ6DAhKPc0dgm525Gqq5NtWKZ7QYYZEv57OQ54KtblzJzH1lQF/eQxO8KjWGIK9IPUJNus5g==}
+  babel-plugin-polyfill-corejs2@0.4.14:
+    resolution: {integrity: sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==}
     peerDependencies:
       '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
 
-  babel-plugin-polyfill-corejs3@0.11.1:
-    resolution: {integrity: sha512-yGCqvBT4rwMczo28xkH/noxJ6MZ4nJfkVYdoDaC/utLtWrXxv27HVrzAeSbqR8SxDsp46n0YF47EbHoixy6rXQ==}
+  babel-plugin-polyfill-corejs3@0.13.0:
+    resolution: {integrity: sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==}
     peerDependencies:
       '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
 
-  babel-plugin-polyfill-regenerator@0.6.4:
-    resolution: {integrity: sha512-7gD3pRadPrbjhjLyxebmx/WrFYcuSjZ0XbdUujQMZ/fcE9oeewk2U/7PCvez84UeuK3oSjmPZ0Ch0dlupQvGzw==}
+  babel-plugin-polyfill-regenerator@0.6.5:
+    resolution: {integrity: sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==}
     peerDependencies:
       '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
 
-  babel-plugin-react-native-web@0.19.13:
-    resolution: {integrity: sha512-4hHoto6xaN23LCyZgL9LJZc3olmAxd7b6jDzlZnKXAh4rRAbZRKNBJoOOdp46OBqgy+K0t0guTj5/mhA8inymQ==}
+  babel-plugin-react-compiler@1.0.0:
+    resolution: {integrity: sha512-Ixm8tFfoKKIPYdCCKYTsqv+Fd4IJ0DQqMyEimo+pxUOMUR9cVPlwTrFt9Avu+3cb6Zp3mAzl+t1MrG2fxxKsxw==}
+
+  babel-plugin-react-native-web@0.21.2:
+    resolution: {integrity: sha512-SPD0J6qjJn8231i0HZhlAGH6NORe+QvRSQM2mwQEzJ2Fb3E4ruWTiiicPlHjmeWShDXLcvoorOCXjeR7k/lyWA==}
+
+  babel-plugin-syntax-hermes-parser@0.29.1:
+    resolution: {integrity: sha512-2WFYnoWGdmih1I1J5eIqxATOeycOqRwYxAQBu3cUu/rhwInwHUg7k60AFNbuGjSDL8tje5GDrAnxzRLcu2pYcA==}
 
-  babel-plugin-syntax-hermes-parser@0.25.1:
-    resolution: {integrity: sha512-IVNpGzboFLfXZUAwkLFcI/bnqVbwky0jP3eBno4HKtqvQJAHBLdgxiG6lQ4to0+Q/YCN3PO0od5NZwIKyY4REQ==}
+  babel-plugin-syntax-hermes-parser@0.32.0:
+    resolution: {integrity: sha512-m5HthL++AbyeEA2FcdwOLfVFvWYECOBObLHNqdR8ceY4TsEdn4LdX2oTvbB2QJSSElE2AWA/b2MXZ/PF/CqLZg==}
 
   babel-plugin-transform-flow-enums@0.0.2:
     resolution: {integrity: sha512-g4aaCrDDOsWjbm0PUUeVnkcVd6AKJsVc/MbnPhEotEpkeJQP6b8nzewohQi7+QS8UyPehOhGWn0nOwjvWpmMvQ==}
 
-  babel-preset-current-node-syntax@1.1.0:
-    resolution: {integrity: sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==}
+  babel-preset-current-node-syntax@1.2.0:
+    resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==}
     peerDependencies:
-      '@babel/core': ^7.0.0
+      '@babel/core': ^7.0.0 || ^8.0.0-0
 
-  babel-preset-expo@13.1.11:
-    resolution: {integrity: sha512-jigWjvhRVdm9UTPJ1wjLYJ0OJvD5vLZ8YYkEknEl6+9S1JWORO/y3xtHr/hNj5n34nOilZqdXrmNFcqKc8YTsg==}
+  babel-preset-expo@54.0.7:
+    resolution: {integrity: sha512-JENWk0bvxW4I1ftveO8GRtX2t2TH6N4Z0TPvIHxroZ/4SswUfyNsUNbbP7Fm4erj3ar/JHGri5kTZ+s3xdjHZw==}
     peerDependencies:
-      babel-plugin-react-compiler: ^19.0.0-beta-e993439-20250405
+      '@babel/runtime': ^7.20.0
+      expo: '*'
+      react-refresh: '>=0.14.0 <1.0.0'
     peerDependenciesMeta:
-      babel-plugin-react-compiler:
+      '@babel/runtime':
+        optional: true
+      expo:
         optional: true
 
   babel-preset-jest@29.6.3:
@@ -3562,6 +4459,10 @@ packages:
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
+  baseline-browser-mapping@2.8.31:
+    resolution: {integrity: sha512-a28v2eWrrRWPpJSzxc+mKwm0ZtVx/G8SepdQZDArnXYU/XS+IF6mp8aB/4E+hH1tyGCoDo3KlUCdlSxGDsRkAw==}
+    hasBin: true
+
   bcrypt-pbkdf@1.0.2:
     resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==}
 
@@ -3572,6 +4473,10 @@ packages:
   better-sqlite3@11.9.1:
     resolution: {integrity: sha512-Ba0KR+Fzxh2jDRhdg6TSH0SJGzb8C0aBY4hR8w8madIdIzzC6Y1+kx5qR6eS1Z+Gy20h6ZU28aeyg0z1VIrShQ==}
 
+  better-sqlite3@12.10.0:
+    resolution: {integrity: sha512-CyzaZRQKyHkB2ZInfTTl2nvT33EbDpjkLEbE8/Zck3Ll6O0qqvuGdrJ45HgtH+HykRg88ITY3AdreBGN70aBSQ==}
+    engines: {node: 20.x || 22.x || 23.x || 24.x || 25.x || 26.x}
+
   big-integer@1.6.52:
     resolution: {integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==}
     engines: {node: '>=0.6'}
@@ -3583,18 +4488,24 @@ packages:
   bindings@1.5.0:
     resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
 
+  birpc@4.0.0:
+    resolution: {integrity: sha512-LShSxJP0KTmd101b6DRyGBj57LZxSDYWKitQNW/mi8GRMvZb078Uf9+pveax1DrVL89vm7mWe+TovdI/UDOuPw==}
+
   bl@4.1.0:
     resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
 
+  bl@6.1.5:
+    resolution: {integrity: sha512-XylDt2P3JBttAwLpORq/hOEX9eJzP0r6Voa46C/WVvad8D1J0jW5876txB8FnzKtbdnU6X4Y1vOEvC6PllJrDg==}
+
   blueimp-md5@2.19.0:
     resolution: {integrity: sha512-DRQrD6gJyy8FbiE4s+bDoXS9hiW3Vbx5uCdwvcCf3zLHL+Iv7LtGHLpr+GZV8rHG8tK766FGYBwRbu8pELTt+w==}
 
-  body-parser@2.2.0:
-    resolution: {integrity: sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==}
+  body-parser@2.2.1:
+    resolution: {integrity: sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==}
     engines: {node: '>=18'}
 
-  bowser@2.11.0:
-    resolution: {integrity: sha512-AlcaJBi/pqqJBIQ8U9Mcpc9i8Aqxn88Skv5d+xBX006BY5u8N3mGLHa5Lgppa7L/HfwgwLgZ6NYs+Ag6uUmJRA==}
+  bowser@2.13.0:
+    resolution: {integrity: sha512-yHAbSRuT6LTeKi6k2aS40csueHqgAsFEgmrOsfRyFpJnFv5O2hl9FYmWEUZ97gZ/dG17U4IQQcTx4YAFYPuWRQ==}
 
   bplist-creator@0.1.0:
     resolution: {integrity: sha512-sXaHZicyEEmY86WyueLTQesbeoH/mquvarJaQNbjuOQO+7gbFcDEWqKmcWA4cOTLzFlfgvkiVxolk1k5bBIpmg==}
@@ -3607,24 +4518,27 @@ packages:
     resolution: {integrity: sha512-apC2+fspHGI3mMKj+dGevkGo/tCqVB8jMb6i+OX+E29p0Iposz07fABkRIfVUPNd5A5VbuOz1bZbnmkKLYF+wQ==}
     engines: {node: '>= 5.10.0'}
 
-  brace-expansion@1.1.11:
-    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+  brace-expansion@1.1.12:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
 
-  brace-expansion@2.0.1:
-    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+  brace-expansion@2.0.2:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
 
   braces@3.0.3:
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
-  browserslist@4.25.0:
-    resolution: {integrity: sha512-PJ8gYKeS5e/whHBh8xrwYK+dAvEj7JXtz6uTucnMRB8OiGTsKccFekoRrjajPBHV8oOY+2tI4uxeceSimKwMFA==}
+  browserslist@4.28.0:
+    resolution: {integrity: sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
   bser@2.1.1:
     resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
 
+  buffer-equal-constant-time@1.0.1:
+    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
+
   buffer-from@1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
 
@@ -3641,22 +4555,19 @@ packages:
     resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==}
     engines: {node: '>=6.14.2'}
 
-  buildcheck@0.0.6:
-    resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==}
+  buildcheck@0.0.7:
+    resolution: {integrity: sha512-lHblz4ahamxpTmnsk+MNTRWsjYKv965MwOrSJyeD588rR3Jcu7swE+0wN5F+PbL5cjgu/9ObkhfzEPuofEMwLA==}
     engines: {node: '>=10.0.0'}
 
-  builtin-modules@3.3.0:
-    resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
-    engines: {node: '>=6'}
-
   builtins@5.1.0:
     resolution: {integrity: sha512-SW9lzGTLvWTP1AY8xeAMZimqDrIaSdLQUcVr9DMef51niJ022Ri87SwRRKYm4A6iHfkPaiVUu/Duw2Wc4J7kKg==}
 
-  bun-types@0.6.14:
-    resolution: {integrity: sha512-sRdvu+t59+H/TVOe7FSGFWYITbqkhiCx9NxVUHt2+JOXM9gUOe5uMPvVvcr/hGngnh+/yb5a7uPE4JaS6uxujg==}
+  bun-types@1.3.3:
+    resolution: {integrity: sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ==}
 
-  bun-types@1.2.15:
-    resolution: {integrity: sha512-NarRIaS+iOaQU1JPfyKhZm4AsUOrwUOqRNHY0XxI8GI8jYxiLXLcdjYMG9UKS+fwWasc1uw1htV9AX24dD+p4w==}
+  bundle-name@4.1.0:
+    resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==}
+    engines: {node: '>=18'}
 
   bundle-require@5.1.0:
     resolution: {integrity: sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==}
@@ -3692,18 +4603,6 @@ packages:
     resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
     engines: {node: '>= 0.4'}
 
-  caller-callsite@2.0.0:
-    resolution: {integrity: sha512-JuG3qI4QOftFsZyOn1qq87fq5grLIyk1JYd5lJmdA+fG7aQ9pA/i3JIJGcO3q0MrRcHlOt1U+ZeHW8Dq9axALQ==}
-    engines: {node: '>=4'}
-
-  caller-path@2.0.0:
-    resolution: {integrity: sha512-MCL3sf6nCSXOwCTzvPKhN18TU7AHTvdtam8DAogxcrJ8Rjfbbg7Lgng64H9Iy+vUV6VGFClN/TyxBkAebLRR4A==}
-    engines: {node: '>=4'}
-
-  callsites@2.0.0:
-    resolution: {integrity: sha512-ksWePWBloaWPxJYQ8TL0JHvtci6G5QTKwQ95RcWAa/lzoAKuAOflGdAK92hpHXjkwb8zLxoLNUoNYZgVsaJzvQ==}
-    engines: {node: '>=4'}
-
   callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -3724,20 +4623,20 @@ packages:
     resolution: {integrity: sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==}
     engines: {node: '>=14.16'}
 
-  caniuse-lite@1.0.30001720:
-    resolution: {integrity: sha512-Ec/2yV2nNPwb4DnTANEV99ZWwm3ZWfdlfkQbWSDDt+PsXEVYwlhPH8tdMaPunYTKKmz7AnHi2oNEi1GcmKCD8g==}
-
-  cardinal@2.1.1:
-    resolution: {integrity: sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==}
-    hasBin: true
+  caniuse-lite@1.0.30001757:
+    resolution: {integrity: sha512-r0nnL/I28Zi/yjk1el6ilj27tKcdjLsNqAOZr0yVjWPrSQyHgKI2INaEWw21bAQSv2LXRt1XuCS/GomNpWOxsQ==}
 
   cbor@8.1.0:
     resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==}
     engines: {node: '>=12.19'}
 
-  chai@5.2.0:
-    resolution: {integrity: sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==}
-    engines: {node: '>=12'}
+  chai@5.3.3:
+    resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
+    engines: {node: '>=18'}
+
+  chai@6.2.1:
+    resolution: {integrity: sha512-p4Z49OGG5W/WBCPSS/dH3jQ73kD6tiMmUM+bckNK6Jr5JHMG3k9bg/BvKR8lKmtVBKmOiuVaV2ws8s9oSbwysg==}
+    engines: {node: '>=18'}
 
   chalk@2.4.2:
     resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
@@ -3747,8 +4646,8 @@ packages:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
     engines: {node: '>=10'}
 
-  chalk@5.4.1:
-    resolution: {integrity: sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==}
+  chalk@5.6.2:
+    resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==}
     engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
 
   char-regex@1.0.2:
@@ -3802,10 +4701,6 @@ packages:
   cjs-module-lexer@1.4.3:
     resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==}
 
-  clean-regexp@1.0.0:
-    resolution: {integrity: sha512-GfisEZEJvzKrmGWkvfhgzcz/BllN1USeqD2V6tg14OAOgaCD2Z/PUEuxnAZ/nPvmaHRG7a8y77p1T/IRQ4D1Hw==}
-    engines: {node: '>=4'}
-
   clean-stack@2.2.0:
     resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
     engines: {node: '>=6'}
@@ -3818,14 +4713,14 @@ packages:
     resolution: {integrity: sha512-3yONmlN9CSAkzNwnRCiJQ7Q2xK5mWuEfL3PuTZcAUzhObbXsfsnMptJzXwz93nc5zn9V9TwCVMmV7w4xsm43dw==}
     engines: {node: '>=0.10.0'}
 
-  cli-color@2.0.4:
-    resolution: {integrity: sha512-zlnpg0jNcibNrO7GG9IeHH7maWFeCz+Ja1wx/7tZNU5ASSSSZ+/qZciM0/LHCYxSdqv5h2sdbQ/PXYdOuetXvA==}
-    engines: {node: '>=0.10'}
-
   cli-cursor@2.1.0:
     resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==}
     engines: {node: '>=4'}
 
+  cli-cursor@5.0.0:
+    resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==}
+    engines: {node: '>=18'}
+
   cli-highlight@2.1.11:
     resolution: {integrity: sha512-9KDcoEVwyUXrjcJNvHD0NFc/hiwe/WPVYIleQh2O1N2Zro5gWJZ/K+3DGn8w8P/F6FxOgzyC5bxDyHIgCSPhGg==}
     engines: {node: '>=8.0.0', npm: '>=5.0.0'}
@@ -3843,6 +4738,10 @@ packages:
     resolution: {integrity: sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  cli-truncate@5.1.1:
+    resolution: {integrity: sha512-SroPvNHxUnk+vIW/dOSfNqdy1sPEFkrTk6TUtqLCnBlo3N7TNYYkzzN7uSD6+jVjrdO4+p8nH7JzH6cIvUem6A==}
+    engines: {node: '>=20'}
+
   cliui@7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
 
@@ -3882,8 +4781,8 @@ packages:
     resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==}
     hasBin: true
 
-  colorette@2.0.19:
-    resolution: {integrity: sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==}
+  colorette@2.0.20:
+    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
 
   colors@1.4.0:
     resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==}
@@ -3893,10 +4792,18 @@ packages:
     resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
     engines: {node: '>=14'}
 
+  commander@11.1.0:
+    resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
+    engines: {node: '>=16'}
+
   commander@12.1.0:
     resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==}
     engines: {node: '>=18'}
 
+  commander@14.0.2:
+    resolution: {integrity: sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==}
+    engines: {node: '>=20'}
+
   commander@2.20.3:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
 
@@ -3908,10 +4815,6 @@ packages:
     resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
     engines: {node: '>= 10'}
 
-  commander@9.5.0:
-    resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
-    engines: {node: ^12.20.0 || >=14}
-
   common-path-prefix@3.0.0:
     resolution: {integrity: sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==}
 
@@ -3919,8 +4822,8 @@ packages:
     resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==}
     engines: {node: '>= 0.6'}
 
-  compression@1.8.0:
-    resolution: {integrity: sha512-k6WLKfunuqCYD3t6AsuPGvQWaKwuLLh2/xHNcX4qE+vIfDNXpSqnrhwA7O53R7WVQUnt8dVAIW+YHr7xTgOgGA==}
+  compression@1.8.1:
+    resolution: {integrity: sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==}
     engines: {node: '>= 0.8.0'}
 
   concat-map@0.0.1:
@@ -3949,9 +4852,9 @@ packages:
   console-control-strings@1.1.0:
     resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}
 
-  content-disposition@1.0.0:
-    resolution: {integrity: sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==}
-    engines: {node: '>= 0.6'}
+  content-disposition@1.0.1:
+    resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==}
+    engines: {node: '>=18'}
 
   content-type@1.0.5:
     resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
@@ -3972,25 +4875,17 @@ packages:
     resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
     engines: {node: '>= 0.6'}
 
-  copy-anything@3.0.5:
-    resolution: {integrity: sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==}
-    engines: {node: '>=12.13'}
-
-  copy-file@11.0.0:
-    resolution: {integrity: sha512-mFsNh/DIANLqFt5VHZoGirdg7bK5+oTWlhnGu6tgRhzBlnEKWaPX2xrFaLltii/6rmhqFMJqffUgknuRdpYlHw==}
+  copy-file@11.1.0:
+    resolution: {integrity: sha512-X8XDzyvYaA6msMyAM575CUoygY5b44QzLcGRKsK3MFmXcOvQa518dNPLsKYwkYsn72g3EiW+LE0ytd/FlqWmyw==}
     engines: {node: '>=18'}
 
-  core-js-compat@3.42.0:
-    resolution: {integrity: sha512-bQasjMfyDGyaeWKBIu33lHh9qlSR0MFE/Nmc6nMjf/iU9b3rSMdAYz1Baxrv4lPdGUsTqZudHA4jIGSJy0SWZQ==}
+  core-js-compat@3.47.0:
+    resolution: {integrity: sha512-IGfuznZ/n7Kp9+nypamBhvwdwLsW6KC8IOaURw2doAK5e98AG3acVLdh0woOnEqCfUtS+Vu882JE4k/DAm3ItQ==}
 
   cors@2.8.5:
     resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
     engines: {node: '>= 0.10'}
 
-  cosmiconfig@5.2.1:
-    resolution: {integrity: sha512-H65gsXo1SKjf8zmrJ67eJk8aIRKV5ff2D4uKZIBZShbhGSpEmsQOPW/SKMKYhSTrqR7ufy6RP69rPogdaPh/kA==}
-    engines: {node: '>=4'}
-
   cp-file@10.0.0:
     resolution: {integrity: sha512-vy2Vi1r2epK5WqxOLnskeKeZkdZvTKfFZQCplE3XWsP+SUJyd5XAUFC9lFgTjjXJF2GMne/UML14iEmkAaDfFg==}
     engines: {node: '>=14.16'}
@@ -4028,33 +4923,17 @@ packages:
     resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==}
     engines: {node: '>=8'}
 
-  csstype@3.1.3:
-    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
   currently-unhandled@0.4.1:
     resolution: {integrity: sha512-/fITjgjGU50vjQ4FH6eUoYu+iUoUKIXws2hL15JJpIR+BbTxaXQsMuuyjtNh2WqsSBS5nsaZHFsFecyw5CCAng==}
     engines: {node: '>=0.10.0'}
 
-  d@1.0.2:
-    resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==}
-    engines: {node: '>=0.12'}
-
   data-uri-to-buffer@4.0.1:
     resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
     engines: {node: '>= 12'}
 
-  data-view-buffer@1.0.2:
-    resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==}
-    engines: {node: '>= 0.4'}
-
-  data-view-byte-length@1.0.2:
-    resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==}
-    engines: {node: '>= 0.4'}
-
-  data-view-byte-offset@1.0.1:
-    resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
-    engines: {node: '>= 0.4'}
-
   date-fns@2.30.0:
     resolution: {integrity: sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==}
     engines: {node: '>=0.11'}
@@ -4079,8 +4958,8 @@ packages:
       supports-color:
         optional: true
 
-  debug@4.3.4:
-    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+  debug@4.3.7:
+    resolution: {integrity: sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==}
     engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
@@ -4088,8 +4967,8 @@ packages:
       supports-color:
         optional: true
 
-  debug@4.4.1:
-    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
     engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
@@ -4116,6 +4995,14 @@ packages:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
 
+  default-browser-id@5.0.1:
+    resolution: {integrity: sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==}
+    engines: {node: '>=18'}
+
+  default-browser@5.4.0:
+    resolution: {integrity: sha512-XDuvSq38Hr1MdN47EDvYtx3U0MTqpCEn+F6ft8z2vYDzMrvQhVp0ui9oQdqW3MvK3vqUETglt1tVGgjLuJ5izg==}
+    engines: {node: '>=18'}
+
   defaults@1.0.4:
     resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
 
@@ -4127,9 +5014,12 @@ packages:
     resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
     engines: {node: '>=8'}
 
-  define-properties@1.2.1:
-    resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
-    engines: {node: '>= 0.4'}
+  define-lazy-prop@3.0.0:
+    resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
+    engines: {node: '>=12'}
+
+  defu@6.1.4:
+    resolution: {integrity: sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==}
 
   delegates@1.0.0:
     resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==}
@@ -4150,23 +5040,14 @@ packages:
     resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
 
-  detect-libc@1.0.3:
-    resolution: {integrity: sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg==}
-    engines: {node: '>=0.10'}
-    hasBin: true
-
   detect-libc@2.0.2:
     resolution: {integrity: sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==}
     engines: {node: '>=8'}
 
-  detect-libc@2.0.4:
-    resolution: {integrity: sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==}
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
     engines: {node: '>=8'}
 
-  diff-sequences@29.6.3:
-    resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
-    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
-
   diff@4.0.2:
     resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
     engines: {node: '>=0.3.1'}
@@ -4175,9 +5056,6 @@ packages:
     resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==}
     engines: {node: '>=0.3.1'}
 
-  difflib@0.2.4:
-    resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==}
-
   dir-glob@3.0.1:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
@@ -4186,14 +5064,10 @@ packages:
     resolution: {integrity: sha512-ens7BiayssQz/uAxGzH8zGXCtiV24rRWXdjNha5V4zSOcxmAZsfGVm/PPFbwQdqEkDnhG+SyR9E3zSHUbOKXBQ==}
     engines: {node: '>= 8.0'}
 
-  dockerode@4.0.6:
-    resolution: {integrity: sha512-FbVf3Z8fY/kALB9s+P9epCpWhfi/r0N2DgYYcYpsAUlaTxPjdsitsFobnltb+lyCgAIvf9C+4PSWlTnHlJMf1w==}
+  dockerode@4.0.9:
+    resolution: {integrity: sha512-iND4mcOWhPaCNh54WmK/KoSb35AFqPAUWFMffTQcp52uQt36b5uNwEJTSXntJZBbeGad72Crbi/hvDIv6us/6Q==}
     engines: {node: '>= 8.0'}
 
-  doctrine@2.1.0:
-    resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==}
-    engines: {node: '>=0.10.0'}
-
   doctrine@3.0.0:
     resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==}
     engines: {node: '>=6.0.0'}
@@ -4210,24 +5084,20 @@ packages:
     resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==}
     engines: {node: '>=12'}
 
-  dotenv@16.5.0:
-    resolution: {integrity: sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==}
+  dotenv@16.6.1:
+    resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==}
     engines: {node: '>=12'}
 
-  dprint@0.46.3:
-    resolution: {integrity: sha512-ACEd7B7sO/uvPvV/nsHbtkIeMqeD2a8XGO1DokROtKDUmI5WbuflGZOwyjFCYwy4rkX6FXoYBzGdEQ6um7BjCA==}
+  dprint@0.50.2:
+    resolution: {integrity: sha512-+0Fzg+17jsMMUouK00/Fara5YtGOuE76EAJINHB8VpkXHd0n00rMXtw/03qorOgz23eo8Y0UpYvNZBJJo3aNtw==}
     hasBin: true
 
   dreamopt@0.8.0:
     resolution: {integrity: sha512-vyJTp8+mC+G+5dfgsY+r3ckxlz+QMX40VjPQsZc5gxVAxLmi64TBoVkP54A/pRAXMXsbu2GMMBrZPxNv23waMg==}
     engines: {node: '>=0.4.0'}
 
-  drizzle-kit@0.19.13:
-    resolution: {integrity: sha512-Rba5VW1O2JfJlwVBeZ8Zwt2E2us5oZ08PQBDiVSGlug53TOc8hzXjblZFuF+dnll9/RQEHrkzBmJFgqTvn5Rxg==}
-    hasBin: true
-
-  drizzle-kit@0.25.0-b1faa33:
-    resolution: {integrity: sha512-WMRuEgxt1oTc62EPVQhGD+pGs6LiqzT8UqxuI6mKfA5SCeCEIt87nFzzJ5WlwsqbuoSgXBXc5zhsHvqXRD03DA==}
+  drizzle-kit@0.31.7:
+    resolution: {integrity: sha512-hOzRGSdyKIU4FcTSFYGKdXEjFsncVwHZ43gY3WU5Bz9j5Iadp6Rh6hxLSQ1IWXpKLBKt/d5y1cpSPcV+FcoQ1A==}
     hasBin: true
 
   drizzle-orm@0.27.2:
@@ -4384,122 +5254,230 @@ packages:
       sqlite3:
         optional: true
 
-  drizzle-prisma-generator@0.1.7:
-    resolution: {integrity: sha512-KW+Z6W4hjvsiOCCPEmGyO+Oal7KPv2yQ3uZzHasaVIn+gUWGrkcy8BCDEp1h7uRBRSAd/l17EM4DfljhgYXxBw==}
-    hasBin: true
-
-  dunder-proto@1.0.1:
-    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
-    engines: {node: '>= 0.4'}
-
-  duplexer@0.1.2:
-    resolution: {integrity: sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==}
-
-  eastasianwidth@0.2.0:
-    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
-
-  ee-first@1.1.1:
-    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
-
-  electron-to-chromium@1.5.162:
-    resolution: {integrity: sha512-hQA+Zb5QQwoSaXJWEAGEw1zhk//O7qDzib05Z4qTqZfNju/FAkrm5ZInp0JbTp4Z18A6bilopdZWEYrFSsfllA==}
-
-  emittery@1.1.0:
-    resolution: {integrity: sha512-rsX7ktqARv/6UQDgMaLfIqUWAEzzbCQiVh7V9rhDXp6c37yoJcks12NVD+XPkgl4AEavmNhVfrhGoqYwIsMYYA==}
-    engines: {node: '>=14.16'}
-
-  emoji-regex@8.0.0:
-    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
-
-  emoji-regex@9.2.2:
-    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
-
-  emojilib@2.4.0:
-    resolution: {integrity: sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==}
-
-  encodeurl@1.0.2:
-    resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
-    engines: {node: '>= 0.8'}
-
-  encodeurl@2.0.0:
-    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
-    engines: {node: '>= 0.8'}
-
-  encoding@0.1.13:
-    resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
-
-  end-of-stream@1.4.4:
-    resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==}
-
-  env-editor@0.4.2:
-    resolution: {integrity: sha512-ObFo8v4rQJAE59M69QzwloxPZtd33TpYEIjtKD1rrFDcM1Gd7IkDxEBU+HriziN6HSHQnBJi8Dmy+JWkav5HKA==}
-    engines: {node: '>=8'}
-
-  env-paths@2.2.1:
-    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
-    engines: {node: '>=6'}
-
-  env-paths@3.0.0:
-    resolution: {integrity: sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-
-  environment@1.1.0:
-    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
-    engines: {node: '>=18'}
-
-  err-code@2.0.3:
-    resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==}
-
-  error-ex@1.3.2:
-    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
-
-  error-stack-parser@2.1.4:
-    resolution: {integrity: sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==}
-
-  es-abstract@1.24.0:
-    resolution: {integrity: sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==}
-    engines: {node: '>= 0.4'}
-
-  es-define-property@1.0.1:
-    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
-    engines: {node: '>= 0.4'}
-
-  es-errors@1.3.0:
-    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
-    engines: {node: '>= 0.4'}
-
-  es-module-lexer@1.7.0:
-    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
-
-  es-object-atoms@1.1.1:
-    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
-    engines: {node: '>= 0.4'}
-
-  es-set-tostringtag@2.1.0:
-    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
-    engines: {node: '>= 0.4'}
-
-  es-shim-unscopables@1.1.0:
-    resolution: {integrity: sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==}
-    engines: {node: '>= 0.4'}
-
-  es-to-primitive@1.3.0:
-    resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
-    engines: {node: '>= 0.4'}
+  drizzle-orm@1.0.0-beta.21:
+    resolution: {integrity: sha512-HZcIbVn5J9T/Z91Wj12Pn7Pi8/1aykS/GPJf2lXeZnEuPjxaBfQ+YAt0Sl+XI+9R/D1BpK+2fdIqbpuaTbcvqA==}
+    peerDependencies:
+      '@aws-sdk/client-rds-data': '>=3'
+      '@cloudflare/workers-types': '>=4'
+      '@effect/sql': ^0.48.5
+      '@effect/sql-pg': ^0.49.7
+      '@electric-sql/pglite': '>=0.2.0'
+      '@libsql/client': '>=0.10.0'
+      '@libsql/client-wasm': '>=0.10.0'
+      '@neondatabase/serverless': '>=0.10.0'
+      '@op-engineering/op-sqlite': '>=2'
+      '@opentelemetry/api': ^1.4.1
+      '@planetscale/database': '>=1.13'
+      '@sinclair/typebox': '>=0.34.8'
+      '@sqlitecloud/drivers': '>=1.0.653'
+      '@tidbcloud/serverless': '*'
+      '@tursodatabase/database': '>=0.2.1'
+      '@tursodatabase/database-common': '>=0.2.1'
+      '@tursodatabase/database-wasm': '>=0.2.1'
+      '@types/better-sqlite3': '*'
+      '@types/mssql': ^9.1.4
+      '@types/pg': '*'
+      '@types/sql.js': '*'
+      '@upstash/redis': '>=1.34.7'
+      '@vercel/postgres': '>=0.8.0'
+      '@xata.io/client': '*'
+      arktype: '>=2.0.0'
+      better-sqlite3: '>=9.3.0'
+      bun-types: '*'
+      expo-sqlite: '>=14.0.0'
+      gel: '>=2'
+      mssql: ^11.0.1
+      mysql2: '>=2'
+      pg: '>=8'
+      postgres: '>=3'
+      sql.js: '>=1'
+      sqlite3: '>=5'
+      typebox: '>=1.0.0'
+      valibot: '>=1.0.0-beta.7'
+      zod: ^3.25.0 || ^4.0.0
+    peerDependenciesMeta:
+      '@aws-sdk/client-rds-data':
+        optional: true
+      '@cloudflare/workers-types':
+        optional: true
+      '@effect/sql':
+        optional: true
+      '@effect/sql-pg':
+        optional: true
+      '@electric-sql/pglite':
+        optional: true
+      '@libsql/client':
+        optional: true
+      '@libsql/client-wasm':
+        optional: true
+      '@neondatabase/serverless':
+        optional: true
+      '@op-engineering/op-sqlite':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@planetscale/database':
+        optional: true
+      '@sinclair/typebox':
+        optional: true
+      '@sqlitecloud/drivers':
+        optional: true
+      '@tidbcloud/serverless':
+        optional: true
+      '@tursodatabase/database':
+        optional: true
+      '@tursodatabase/database-common':
+        optional: true
+      '@tursodatabase/database-wasm':
+        optional: true
+      '@types/better-sqlite3':
+        optional: true
+      '@types/pg':
+        optional: true
+      '@types/sql.js':
+        optional: true
+      '@upstash/redis':
+        optional: true
+      '@vercel/postgres':
+        optional: true
+      '@xata.io/client':
+        optional: true
+      arktype:
+        optional: true
+      better-sqlite3:
+        optional: true
+      bun-types:
+        optional: true
+      expo-sqlite:
+        optional: true
+      gel:
+        optional: true
+      mysql2:
+        optional: true
+      pg:
+        optional: true
+      postgres:
+        optional: true
+      sql.js:
+        optional: true
+      sqlite3:
+        optional: true
+      typebox:
+        optional: true
+      valibot:
+        optional: true
+      zod:
+        optional: true
 
-  es5-ext@0.10.64:
-    resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==}
-    engines: {node: '>=0.10'}
+  drizzle-prisma-generator@0.1.7:
+    resolution: {integrity: sha512-KW+Z6W4hjvsiOCCPEmGyO+Oal7KPv2yQ3uZzHasaVIn+gUWGrkcy8BCDEp1h7uRBRSAd/l17EM4DfljhgYXxBw==}
+    hasBin: true
+
+  dts-resolver@2.1.3:
+    resolution: {integrity: sha512-bihc7jPC90VrosXNzK0LTE2cuLP6jr0Ro8jk+kMugHReJVLIpHz/xadeq3MhuwyO4TD4OA3L1Q8pBBFRc08Tsw==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      oxc-resolver: '>=11.0.0'
+    peerDependenciesMeta:
+      oxc-resolver:
+        optional: true
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  eastasianwidth@0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+
+  ecdsa-sig-formatter@1.0.11:
+    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
+
+  ee-first@1.1.1:
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
+
+  effect@4.0.0-beta.83:
+    resolution: {integrity: sha512-0wsak8RtgGAr9UWSbVDgJHZcUqMSvicHcvaZv1MbMM7MCGgW4Rn/137J1MHQbwYPcwYGxT/IqehFd+UbYuj78w==}
+
+  electron-to-chromium@1.5.260:
+    resolution: {integrity: sha512-ov8rBoOBhVawpzdre+Cmz4FB+y66Eqrk6Gwqd8NGxuhv99GQ8XqMAr351KEkOt7gukXWDg6gJWEMKgL2RLMPtA==}
+
+  emittery@1.2.0:
+    resolution: {integrity: sha512-KxdRyyFcS85pH3dnU8Y5yFUm2YJdaHwcBZWrfG8o89ZY9a13/f9itbN+YG3ELbBo9Pg5zvIozstmuV8bX13q6g==}
+    engines: {node: '>=14.16'}
+
+  emoji-regex@10.6.0:
+    resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  emoji-regex@9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+
+  emojilib@2.4.0:
+    resolution: {integrity: sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw==}
+
+  empathic@2.0.0:
+    resolution: {integrity: sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==}
+    engines: {node: '>=14'}
+
+  encodeurl@1.0.2:
+    resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
+    engines: {node: '>= 0.8'}
+
+  encodeurl@2.0.0:
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
+
+  encoding@0.1.13:
+    resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
+
+  end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+
+  engine.io-client@6.6.3:
+    resolution: {integrity: sha512-T0iLjnyNWahNyv/lcjS2y4oE358tVS/SYQNxYXGAJ9/GLgH4VCvOQ/mhTjqU88mLZCQgiG8RIegFHYCdVC+j5w==}
+
+  engine.io-parser@5.2.3:
+    resolution: {integrity: sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==}
+    engines: {node: '>=10.0.0'}
+
+  env-editor@0.4.2:
+    resolution: {integrity: sha512-ObFo8v4rQJAE59M69QzwloxPZtd33TpYEIjtKD1rrFDcM1Gd7IkDxEBU+HriziN6HSHQnBJi8Dmy+JWkav5HKA==}
+    engines: {node: '>=8'}
+
+  env-paths@2.2.1:
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
+
+  env-paths@3.0.0:
+    resolution: {integrity: sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  environment@1.1.0:
+    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
+    engines: {node: '>=18'}
+
+  err-code@2.0.3:
+    resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==}
 
-  es6-iterator@2.0.3:
-    resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==}
+  error-stack-parser@2.1.4:
+    resolution: {integrity: sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
 
-  es6-symbol@3.1.4:
-    resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==}
-    engines: {node: '>=0.12'}
+  es-module-lexer@1.7.0:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
 
-  es6-weak-map@2.0.3:
-    resolution: {integrity: sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==}
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
 
   esbuild-android-64@0.14.54:
     resolution: {integrity: sha512-Tz2++Aqqz0rJ7kYBfz+iqyE3QMycD4vk7LBRyWaAVFgFtQ/O8EJOnVmTOiDWYZ/uYzB4kvP+bqejYdVKzE5lAQ==}
@@ -4591,12 +5569,6 @@ packages:
     cpu: [x64]
     os: [netbsd]
 
-  esbuild-node-externals@1.18.0:
-    resolution: {integrity: sha512-suFVX3SzZlXrGIS9Yqx+ZaHL4w1p0e/j7dQbOM9zk8SfFpnAGnDplHUKXIf9kcPEAfZRL66JuYeVSVlsSEQ5Eg==}
-    engines: {node: '>=12'}
-    peerDependencies:
-      esbuild: 0.12 - 0.25
-
   esbuild-openbsd-64@0.14.54:
     resolution: {integrity: sha512-Qyk7ikT2o7Wu76UsvvDS5q0amJvmRzDyVlL0qf5VLsLchjCa1+IAvd8kTBgUxD7VBUUVgItLkk609ZHUc1oCaw==}
     engines: {node: '>=12'}
@@ -4642,13 +5614,18 @@ packages:
     engines: {node: '>=12'}
     hasBin: true
 
-  esbuild@0.19.12:
-    resolution: {integrity: sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==}
+  esbuild@0.21.5:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
     engines: {node: '>=12'}
     hasBin: true
 
-  esbuild@0.25.5:
-    resolution: {integrity: sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ==}
+  esbuild@0.25.12:
+    resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  esbuild@0.27.0:
+    resolution: {integrity: sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==}
     engines: {node: '>=18'}
     hasBin: true
 
@@ -4675,87 +5652,6 @@ packages:
     resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
     engines: {node: '>=12'}
 
-  eslint-config-prettier@9.1.0:
-    resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==}
-    hasBin: true
-    peerDependencies:
-      eslint: '>=7.0.0'
-
-  eslint-import-resolver-node@0.3.9:
-    resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==}
-
-  eslint-module-utils@2.12.0:
-    resolution: {integrity: sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg==}
-    engines: {node: '>=4'}
-    peerDependencies:
-      '@typescript-eslint/parser': '*'
-      eslint: '*'
-      eslint-import-resolver-node: '*'
-      eslint-import-resolver-typescript: '*'
-      eslint-import-resolver-webpack: '*'
-    peerDependenciesMeta:
-      '@typescript-eslint/parser':
-        optional: true
-      eslint:
-        optional: true
-      eslint-import-resolver-node:
-        optional: true
-      eslint-import-resolver-typescript:
-        optional: true
-      eslint-import-resolver-webpack:
-        optional: true
-
-  eslint-plugin-import@2.31.0:
-    resolution: {integrity: sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==}
-    engines: {node: '>=4'}
-    peerDependencies:
-      '@typescript-eslint/parser': '*'
-      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9
-    peerDependenciesMeta:
-      '@typescript-eslint/parser':
-        optional: true
-
-  eslint-plugin-no-instanceof@1.0.1:
-    resolution: {integrity: sha512-zlqQ7EsfzbRO68uI+p8FIE7zYB4njs+nNbkNjSb5QmLi2et67zQLqSeaao5U9SpnlZTTJC87nS2oyHo2ACtajw==}
-
-  eslint-plugin-prettier@5.4.1:
-    resolution: {integrity: sha512-9dF+KuU/Ilkq27A8idRP7N2DH8iUR6qXcjF3FR2wETY21PZdBrIjwCau8oboyGj9b7etWmTGEeM8e7oOed6ZWg==}
-    engines: {node: ^14.18.0 || >=16.0.0}
-    peerDependencies:
-      '@types/eslint': '>=8.0.0'
-      eslint: '>=8.0.0'
-      eslint-config-prettier: '>= 7.0.0 <10.0.0 || >=10.1.0'
-      prettier: '>=3.0.0'
-    peerDependenciesMeta:
-      '@types/eslint':
-        optional: true
-      eslint-config-prettier:
-        optional: true
-
-  eslint-plugin-unicorn@48.0.1:
-    resolution: {integrity: sha512-FW+4r20myG/DqFcCSzoumaddKBicIPeFnTrifon2mWIzlfyvzwyqZjqVP7m4Cqr/ZYisS2aiLghkUWaPg6vtCw==}
-    engines: {node: '>=16'}
-    peerDependencies:
-      eslint: '>=8.44.0'
-
-  eslint-plugin-unused-imports@3.2.0:
-    resolution: {integrity: sha512-6uXyn6xdINEpxE1MtDjxQsyXB37lfyO2yKGVVgtD7WEWQGORSOZjgrD6hBhvGv4/SO+TOlS+UnC6JppRqbuwGQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      '@typescript-eslint/eslint-plugin': 6 - 7
-      eslint: '8'
-    peerDependenciesMeta:
-      '@typescript-eslint/eslint-plugin':
-        optional: true
-
-  eslint-rule-composer@0.3.0:
-    resolution: {integrity: sha512-bt+Sh8CtDmn2OajxvNO+BX7Wn4CIWMpTRm3MaiKPCQcnnlm0CS2mhui6QaoeQugs+3Kj2ESKEEGJUdVafwhiCg==}
-    engines: {node: '>=4.0.0'}
-
-  eslint-scope@5.1.1:
-    resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
-    engines: {node: '>=8.0.0'}
-
   eslint-scope@7.2.2:
     resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -4770,14 +5666,6 @@ packages:
     deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
 
-  esm@3.2.25:
-    resolution: {integrity: sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==}
-    engines: {node: '>=6'}
-
-  esniff@2.0.1:
-    resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==}
-    engines: {node: '>=0.10'}
-
   espree@9.6.1:
     resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -4795,17 +5683,10 @@ packages:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
     engines: {node: '>=4.0'}
 
-  estraverse@4.3.0:
-    resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==}
-    engines: {node: '>=4.0'}
-
   estraverse@5.3.0:
     resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
     engines: {node: '>=4.0'}
 
-  estree-walker@2.0.2:
-    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
-
   estree-walker@3.0.3:
     resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
 
@@ -4817,12 +5698,6 @@ packages:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
 
-  event-emitter@0.3.5:
-    resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==}
-
-  event-stream@3.3.4:
-    resolution: {integrity: sha512-QHpkERcGsR0T7Qm3HNJSyXKEEj8AHNxkY3PK8TS2KJvQ7NiSHe3DDpwVKKtoYprL/AreyzFBeIkBIWChAqn60g==}
-
   event-target-shim@5.0.1:
     resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
     engines: {node: '>=6'}
@@ -4830,12 +5705,22 @@ packages:
   eventemitter2@6.4.9:
     resolution: {integrity: sha512-JEPTiaOt9f04oa6NOkc4aH+nVp5I3wEjpHbIPqfgCdD5v5bUzy7xQqwcVO2aDQgOWhI28da57HksMrzK9HlRxg==}
 
+  eventemitter3@4.0.7:
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+
+  eventemitter3@5.0.1:
+    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
+
   events@1.1.1:
     resolution: {integrity: sha512-kEcvvCBByWXGnZy6JUlgAp2gBIUjfCAV6P6TgT1/aaQKcmuAEC4OZTV1I4EWQLz2gxZw76atuVyvHhTxvi0Flw==}
     engines: {node: '>=0.4.x'}
 
-  eventsource-parser@3.0.2:
-    resolution: {integrity: sha512-6RxOBZ/cYgd8usLwsEl+EC09Au/9BcmCKYF2/xbml6DNczf7nv0MQb+7BA2F+li6//I+28VNlQR37XfQtcAJuA==}
+  events@3.3.0:
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
+
+  eventsource-parser@3.0.6:
+    resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}
     engines: {node: '>=18.0.0'}
 
   eventsource@3.0.7:
@@ -4857,55 +5742,63 @@ packages:
     resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
     engines: {node: '>=6'}
 
-  expect-type@1.2.1:
-    resolution: {integrity: sha512-/kP8CAwxzLVEeFrMm4kMmy4CCDlpipyA7MYLVrdJIkV0fYF0UaigQHRsxHiuY/GEea+bh4KSv3TIlgr+2UL6bw==}
+  expect-type@1.2.2:
+    resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
     engines: {node: '>=12.0.0'}
 
-  expo-asset@11.1.5:
-    resolution: {integrity: sha512-GEQDCqC25uDBoXHEnXeBuwpeXvI+3fRGvtzwwt0ZKKzWaN+TgeF8H7c76p3Zi4DfBMFDcduM0CmOvJX+yCCLUQ==}
+  expo-asset@12.0.10:
+    resolution: {integrity: sha512-pZyeJkoDsALh4gpCQDzTA/UCLaPH/1rjQNGubmLn/uDM27S4iYJb/YWw4+CNZOtd5bCUOhDPg5DtGQnydNFSXg==}
     peerDependencies:
       expo: '*'
       react: '*'
       react-native: '*'
 
-  expo-constants@17.1.6:
-    resolution: {integrity: sha512-q5mLvJiLtPcaZ7t2diSOlQ2AyxIO8YMVEJsEfI/ExkGj15JrflNQ7CALEW6IF/uNae/76qI/XcjEuuAyjdaCNw==}
+  expo-constants@18.0.10:
+    resolution: {integrity: sha512-Rhtv+X974k0Cahmvx6p7ER5+pNhBC0XbP1lRviL2J1Xl4sT2FBaIuIxF/0I0CbhOsySf0ksqc5caFweAy9Ewiw==}
     peerDependencies:
       expo: '*'
       react-native: '*'
 
-  expo-file-system@18.1.10:
-    resolution: {integrity: sha512-SyaWg+HitScLuyEeSG9gMSDT0hIxbM9jiZjSBP9l9zMnwZjmQwsusE6+7qGiddxJzdOhTP4YGUfvEzeeS0YL3Q==}
+  expo-file-system@19.0.19:
+    resolution: {integrity: sha512-OrpOV4fEBFMFv+jy7PnENpPbsWoBmqWGidSwh1Ai52PLl6JIInYGfZTc6kqyPNGtFTwm7Y9mSWnE8g+dtLxu7g==}
     peerDependencies:
       expo: '*'
       react-native: '*'
 
-  expo-font@13.3.1:
-    resolution: {integrity: sha512-d+xrHYvSM9WB42wj8vP9OOFWyxed5R1evphfDb6zYBmC1dA9Hf89FpT7TNFtj2Bk3clTnpmVqQTCYbbA2P3CLg==}
+  expo-font@14.0.9:
+    resolution: {integrity: sha512-xCoQbR/36qqB6tew/LQ6GWICpaBmHLhg/Loix5Rku/0ZtNaXMJv08M9o1AcrdiGTn/Xf/BnLu6DgS45cWQEHZg==}
     peerDependencies:
       expo: '*'
       react: '*'
+      react-native: '*'
 
-  expo-keep-awake@14.1.4:
-    resolution: {integrity: sha512-wU9qOnosy4+U4z/o4h8W9PjPvcFMfZXrlUoKTMBW7F4pLqhkkP/5G4EviPZixv4XWFMjn1ExQ5rV6BX8GwJsWA==}
+  expo-keep-awake@15.0.7:
+    resolution: {integrity: sha512-CgBNcWVPnrIVII5G54QDqoE125l+zmqR4HR8q+MQaCfHet+dYpS5vX5zii/RMayzGN4jPgA4XYIQ28ePKFjHoA==}
     peerDependencies:
       expo: '*'
       react: '*'
 
-  expo-modules-autolinking@2.1.10:
-    resolution: {integrity: sha512-k93fzoszrYTKbZ51DSVnewYIGUV6Gi22Su8qySXPFJEfvtDs2NUUNRHBZNKgLHvwc6xPzVC5j7JYbrpXNuY44A==}
+  expo-modules-autolinking@3.0.22:
+    resolution: {integrity: sha512-Ej4SsZAnUUVFmbn6SoBso8K308mRKg8xgapdhP7v7IaSgfbexUoqxoiV31949HQQXuzmgvpkXCfp6Ex+mDW0EQ==}
     hasBin: true
 
-  expo-modules-core@2.3.13:
-    resolution: {integrity: sha512-vmKHv7tEo2wUQoYDV6grhsLsQfD3DUnew5Up3yNnOE1gHGQE+zhV1SBYqaPMPB12OvpyD1mlfzGhu6r9PODnng==}
+  expo-modules-core@3.0.26:
+    resolution: {integrity: sha512-WWjficXz32VmQ+xDoO+c0+jwDME0n/47wONrJkRvtm32H9W8n3MXkOMGemDl95HyPKYsaYKhjFGUOVOxIF3hcQ==}
+    peerDependencies:
+      react: '*'
+      react-native: '*'
+
+  expo-server@1.0.4:
+    resolution: {integrity: sha512-IN06r3oPxFh3plSXdvBL7dx0x6k+0/g0bgxJlNISs6qL5Z+gyPuWS750dpTzOeu37KyBG0RcyO9cXUKzjYgd4A==}
+    engines: {node: '>=20.16.0'}
 
   expo-sqlite@14.0.6:
     resolution: {integrity: sha512-T3YNx7LT7lM4UQRgi8ml+cj0Wf3Ep09+B4CVaWtUCjdyYJIZjsHDT65hypKG+r6btTLLEd11hjlrstNQhzt5gQ==}
     peerDependencies:
       expo: '*'
 
-  expo@53.0.9:
-    resolution: {integrity: sha512-UFG68aVOpccg3s++S3pbtI3YCQCnlu/TFvhnQ5vaD3vhOox1Uk/f2O2T95jmwA/EvKvetqGj34lys3DNXvPqgQ==}
+  expo@54.0.25:
+    resolution: {integrity: sha512-+iSeBJfHRHzNPnHMZceEXhSGw4t5bNqFyd/5xMUoGfM+39rO7F72wxiLRpBKj0M6+0GQtMaEs+eTbcCrO7XyJQ==}
     hasBin: true
     peerDependencies:
       '@expo/dom-webview': '*'
@@ -4921,21 +5814,32 @@ packages:
       react-native-webview:
         optional: true
 
-  exponential-backoff@3.1.2:
-    resolution: {integrity: sha512-8QxYTVXUkuy7fIIoitQkPwGonB8F3Zj8eEO8Sqg9Zv/bkI7RJAzowee4gr81Hak/dUTpA2Z7VfQgoijjPNlUZA==}
+  exponential-backoff@3.1.3:
+    resolution: {integrity: sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==}
+
+  express-rate-limit@7.5.1:
+    resolution: {integrity: sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      express: '>= 4.11'
 
-  express-rate-limit@7.5.0:
-    resolution: {integrity: sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==}
+  express-rate-limit@8.5.2:
+    resolution: {integrity: sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==}
     engines: {node: '>= 16'}
     peerDependencies:
-      express: ^4.11 || 5 || ^5.0.0-beta.1
+      express: '>= 4.11'
 
   express@5.1.0:
     resolution: {integrity: sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==}
     engines: {node: '>= 18'}
 
-  ext@1.7.0:
-    resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==}
+  express@5.2.1:
+    resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
+    engines: {node: '>= 18'}
+
+  fast-check@4.8.0:
+    resolution: {integrity: sha512-GOJ158CUMnN6cSahsv4+ExARvIDuzzinFjkp0E9WtiBa5zcVeLozVkWaE4IzFcc+Y48Wp1EDlUZsXRyAztQcSg==}
+    engines: {node: '>=12.17.0'}
 
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
@@ -4957,18 +5861,27 @@ packages:
   fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
-  fast-xml-parser@4.4.1:
-    resolution: {integrity: sha512-xkjOecfnKGkSsOwtZ5Pz7Us/T6mrbPQrq0nh+aCO5V9nk5NLWmasAHumTKjiPJPWANe+kAZ84Jc8ooJkzZ88Sw==}
+  fast-uri@3.1.2:
+    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
+
+  fast-xml-parser@5.2.5:
+    resolution: {integrity: sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ==}
     hasBin: true
 
   fastq@1.19.1:
     resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==}
 
+  fb-dotslash@0.5.8:
+    resolution: {integrity: sha512-XHYLKk9J4BupDxi9bSEhkfss0m+Vr9ChTrjhf9l2iw3jB5C7BnY4GVPoMcqbrTutsKJso6yj2nAB6BI/F2oZaA==}
+    engines: {node: '>=20'}
+    hasBin: true
+
   fb-watchman@2.0.2:
     resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==}
 
-  fdir@6.4.5:
-    resolution: {integrity: sha512-4BG7puHpVsIYxZUbiUE3RqGloLaSSwzYie5jvasC4LWuBWzZawynvYouhjbQKw2JuIGYdm0DzIxl8iVidKlUEw==}
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
     peerDependencies:
       picomatch: ^3 || ^4
     peerDependenciesMeta:
@@ -5005,6 +5918,9 @@ packages:
     resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==}
     engines: {node: '>= 0.8'}
 
+  find-my-way-ts@0.1.6:
+    resolution: {integrity: sha512-a85L9ZoXtNAey3Y6Z+eBWW658kO/MwR7zIafkIUPUMf3isZG0NCs2pjW2wtjxAKuJPxMAsHUIP4ZPGv0o5gyTA==}
+
   find-up@4.1.0:
     resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
     engines: {node: '>=8'}
@@ -5061,16 +5977,9 @@ packages:
     resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
     engines: {node: '>= 0.8'}
 
-  from@0.1.7:
-    resolution: {integrity: sha512-twe20eF1OxVxp/ML/kq2p1uc6KvFK/+vs8WjEbeKmV2He22MKm7YF2ANIt+EOqhJ5L3K/SuuPhk0hWQDjOM23g==}
-
   fs-constants@1.0.0:
     resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
 
-  fs-extra@11.3.0:
-    resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==}
-    engines: {node: '>=14.14'}
-
   fs-minipass@2.1.0:
     resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
     engines: {node: '>= 8'}
@@ -5086,30 +5995,23 @@ packages:
   function-bind@1.1.2:
     resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
-  function.prototype.name@1.1.8:
-    resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==}
-    engines: {node: '>= 0.4'}
-
-  functions-have-names@1.2.3:
-    resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
-
-  fx@36.0.3:
-    resolution: {integrity: sha512-E+flQ8IQpctke+/dfBdKg2h8UGZapVfadRU3LR4xC/BYvaJPoUlxfbrfWBLzdKYrqfWse5YxEpekRl853L/zrw==}
-    hasBin: true
-
   gauge@4.0.4:
     resolution: {integrity: sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
     deprecated: This package is no longer supported.
 
-  gel@2.1.0:
-    resolution: {integrity: sha512-HCeRqInCt6BjbMmeghJ6BKeYwOj7WJT5Db6IWWAA3IMUUa7or7zJfTUEkUWCxiOtoXnwnm96sFK9Fr47Yh2hOA==}
+  gel@2.2.0:
+    resolution: {integrity: sha512-q0ma7z2swmoamHQusey8ayo8+ilVdzDt4WTxSPzq/yRqvucWRfymRVMvNgmSC0XK7eNjjEZEcplxpgaNojKdmQ==}
     engines: {node: '>= 18.0.0'}
     hasBin: true
 
   generate-function@2.3.1:
     resolution: {integrity: sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==}
 
+  generator-function@2.0.1:
+    resolution: {integrity: sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==}
+    engines: {node: '>= 0.4'}
+
   gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
     engines: {node: '>=6.9.0'}
@@ -5118,8 +6020,9 @@ packages:
     resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
     engines: {node: 6.* || 8.* || >= 10.*}
 
-  get-func-name@2.0.2:
-    resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==}
+  get-east-asian-width@1.4.0:
+    resolution: {integrity: sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==}
+    engines: {node: '>=18'}
 
   get-intrinsic@1.3.0:
     resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
@@ -5145,20 +6048,16 @@ packages:
     resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
     engines: {node: '>=10'}
 
-  get-symbol-description@1.1.0:
-    resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
-    engines: {node: '>= 0.4'}
+  get-tsconfig@4.13.0:
+    resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==}
 
-  get-tsconfig@4.10.1:
-    resolution: {integrity: sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==}
+  get-tsconfig@4.13.6:
+    resolution: {integrity: sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==}
 
-  getenv@1.0.0:
-    resolution: {integrity: sha512-7yetJWqbS9sbn0vIfliPsFgoXMKn/YMF+Wuiog97x+urnSRRRZ7xB+uVkwGKzRgq9CDFfMQnE9ruL5DHv9c6Xg==}
+  getenv@2.0.0:
+    resolution: {integrity: sha512-VilgtJj/ALgGY77fiLam5iD336eSWi96Q15JSAG1zi8NRBysm3LXKdGnHb4m5cuyxvOLQQKWpBZAT6ni4FI2iQ==}
     engines: {node: '>=6'}
 
-  getopts@2.3.0:
-    resolution: {integrity: sha512-5eDf9fuSXwxBL6q5HX+dhDj+dslFGWzU5thZ9kNKUkcPtaPdatmUFKwHFrLb/uf/WpA4BHET+AX3Scl56cAjpA==}
-
   github-from-package@0.0.0:
     resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
 
@@ -5170,36 +6069,34 @@ packages:
     resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
     engines: {node: '>=10.13.0'}
 
-  glob@10.4.5:
-    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+  glob@10.5.0:
+    resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
-  glob@11.0.2:
-    resolution: {integrity: sha512-YT7U7Vye+t5fZ/QMkBFrTJ7ZQxInIUjwyAjVj84CYXqgBdv30MFUPGnBR6sQaVq6Is15wYJUsnzTuWaGRBhBAQ==}
+  glob@11.1.0:
+    resolution: {integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==}
     engines: {node: 20 || >=22}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   glob@8.1.0:
     resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
     engines: {node: '>=12'}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
-  globals@11.12.0:
-    resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
+  global-dirs@0.1.1:
+    resolution: {integrity: sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg==}
     engines: {node: '>=4'}
 
   globals@13.24.0:
     resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==}
     engines: {node: '>=8'}
 
-  globalthis@1.0.4:
-    resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==}
-    engines: {node: '>= 0.4'}
-
   globby@11.1.0:
     resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
     engines: {node: '>=10'}
@@ -5225,12 +6122,8 @@ packages:
   graphemer@1.4.0:
     resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
 
-  hanji@0.0.5:
-    resolution: {integrity: sha512-Abxw1Lq+TnYiL4BueXqMau222fPSPMFtya8HdpWsz/xVAhifXou71mPh/kY2+08RgFcVccjG3uZHs6K5HAe3zw==}
-
-  has-bigints@1.1.0:
-    resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
-    engines: {node: '>= 0.4'}
+  hanji@0.0.8:
+    resolution: {integrity: sha512-Z1n2OGhZGnNjrbI4FRSAla2wGcu+mafkTi0al0NSfsQN5ccka7n+rK/x2YISB4oYU8WGejjQWoyWyukRmbFVUA==}
 
   has-flag@3.0.0:
     resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
@@ -5243,10 +6136,6 @@ packages:
   has-property-descriptors@1.0.2:
     resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
 
-  has-proto@1.2.0:
-    resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==}
-    engines: {node: '>= 0.4'}
-
   has-symbols@1.1.0:
     resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
     engines: {node: '>= 0.4'}
@@ -5258,8 +6147,8 @@ packages:
   has-unicode@2.0.1:
     resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
 
-  hash-it@6.0.0:
-    resolution: {integrity: sha512-KHzmSFx1KwyMPw0kXeeUD752q/Kfbzhy6dAZrjXV9kAIXGqzGvv8vhkUqj+2MGZldTo0IBpw6v7iWE7uxsvH0w==}
+  hash-it@6.0.1:
+    resolution: {integrity: sha512-qhl8+l4Zwi1eLlL3lja5ywmDQnBzLEJxd0QJoAVIgZpgQbdtVZrN5ypB0y3VHwBlvAalpcbM2/A6x7oUks5zNg==}
 
   hasown@2.0.2:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
@@ -5268,31 +6157,38 @@ packages:
   heap@0.2.7:
     resolution: {integrity: sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==}
 
-  hermes-estree@0.25.1:
-    resolution: {integrity: sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==}
+  hermes-compiler@0.0.0:
+    resolution: {integrity: sha512-boVFutx6ME/Km2mB6vvsQcdnazEYYI/jV1pomx1wcFUG/EVqTkr5CU0CW9bKipOA/8Hyu3NYwW3THg2Q1kNCfA==}
+
+  hermes-estree@0.29.1:
+    resolution: {integrity: sha512-jl+x31n4/w+wEqm0I2r4CMimukLbLQEYpisys5oCre611CI5fc9TxhqkBBCJ1edDG4Kza0f7CgNz8xVMLZQOmQ==}
 
-  hermes-estree@0.28.1:
-    resolution: {integrity: sha512-w3nxl/RGM7LBae0v8LH2o36+8VqwOZGv9rX1wyoWT6YaKZLqpJZ0YQ5P0LVr3tuRpf7vCx0iIG4i/VmBJejxTQ==}
+  hermes-estree@0.32.0:
+    resolution: {integrity: sha512-KWn3BqnlDOl97Xe1Yviur6NbgIZ+IP+UVSpshlZWkq+EtoHg6/cwiDj/osP9PCEgFE15KBm1O55JRwbMEm5ejQ==}
 
-  hermes-parser@0.25.1:
-    resolution: {integrity: sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==}
+  hermes-parser@0.29.1:
+    resolution: {integrity: sha512-xBHWmUtRC5e/UL0tI7Ivt2riA/YBq9+SiYFU7C1oBa/j2jYGlIF9043oak1F47ihuDIxQ5nbsKueYJDRY02UgA==}
 
-  hermes-parser@0.28.1:
-    resolution: {integrity: sha512-nf8o+hE8g7UJWParnccljHumE9Vlq8F7MqIdeahl+4x0tvCUJYRrT0L7h0MMg/X9YJmkNwsfbaNNrzPtFXOscg==}
+  hermes-parser@0.32.0:
+    resolution: {integrity: sha512-g4nBOWFpuiTqjR3LZdRxKUkij9iyveWeuks7INEsMX741f3r9xxrOe8TeQfUxtda0eXmiIFiMQzoeSQEno33Hw==}
 
   highlight.js@10.7.3:
     resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==}
 
-  hono@4.7.11:
-    resolution: {integrity: sha512-rv0JMwC0KALbbmwJDEnxvQCeJh+xbS3KEWW5PC9cMJ08Ur9xgatI0HmtgYZfOdOSOeYsp5LO2cOhdI8cLEbDEQ==}
+  hono@4.10.7:
+    resolution: {integrity: sha512-icXIITfw/07Q88nLSkB9aiUrd8rYzSweK681Kjo/TSggaGbOX4RRyxxm71v+3PC8C/j+4rlxGeoTRxQDkaJkUw==}
+    engines: {node: '>=16.9.0'}
+
+  hono@4.12.27:
+    resolution: {integrity: sha512-1yrb/+w6HWQJrUCLkJ2IF5jNIPvvFkblV5RNOYl6bV+OA6p9GLcMpHFFGTosSvHvcAUibuUukRqhlYI4z32C7Q==}
     engines: {node: '>=16.9.0'}
 
   hono@4.7.4:
     resolution: {integrity: sha512-Pst8FuGqz3L7tFF+u9Pu70eI0xa5S3LPUmrNd5Jm8nTHze9FxLTK9Kaj5g/k4UcwuJSXTP65SyHOPLrffpcAJg==}
     engines: {node: '>=16.9.0'}
 
-  hosted-git-info@2.8.9:
-    resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
+  hookable@6.0.1:
+    resolution: {integrity: sha512-uKGyY8BuzN/a5gvzvA+3FVWo0+wUjgtfSdnmjtrOVwQCZPHpHDH2WRO3VZSOeluYrHoDCiXFffZXs8Dj1ULWtw==}
 
   hosted-git-info@7.0.2:
     resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==}
@@ -5305,10 +6201,18 @@ packages:
     resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
     engines: {node: '>= 0.8'}
 
+  http-errors@2.0.1:
+    resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+    engines: {node: '>= 0.8'}
+
   http-proxy-agent@4.0.1:
     resolution: {integrity: sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==}
     engines: {node: '>= 6'}
 
+  http-proxy-agent@7.0.2:
+    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
+    engines: {node: '>= 14'}
+
   https-proxy-agent@5.0.1:
     resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
     engines: {node: '>= 6'}
@@ -5324,10 +6228,23 @@ packages:
   humanize-ms@1.2.1:
     resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
 
+  husky@9.1.7:
+    resolution: {integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   iconv-lite@0.6.3:
     resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
     engines: {node: '>=0.10.0'}
 
+  iconv-lite@0.7.0:
+    resolution: {integrity: sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==}
+    engines: {node: '>=0.10.0'}
+
+  iconv-lite@0.7.2:
+    resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
+    engines: {node: '>=0.10.0'}
+
   ieee754@1.1.13:
     resolution: {integrity: sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==}
 
@@ -5354,16 +6271,16 @@ packages:
   immediate@3.3.0:
     resolution: {integrity: sha512-HR7EVodfFUdQCTIeySw+WDRFJlPcLOJbXfwwZ7Oom6tjsvZ3bOkCDJHehQC3nxJrv7+f9XecwazynjU8e4Vw3Q==}
 
-  import-fresh@2.0.0:
-    resolution: {integrity: sha512-eZ5H8rcgYazHbKC3PG4ClHNykCSxtAhxSSEM+2mb+7evD2CKF5V7c0dNum7AdpDh0ZdICwZY9sRSn8f+KH96sg==}
-    engines: {node: '>=4'}
-
   import-fresh@3.3.1:
     resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
     engines: {node: '>=6'}
 
-  import-in-the-middle@1.14.0:
-    resolution: {integrity: sha512-g5zLT0HaztRJWysayWYiUq/7E5H825QIiecMD2pI5QO7Wzr847l6GDvPvmZaDIdrDtS2w7qRczywxiK6SL5vRw==}
+  import-in-the-middle@1.15.0:
+    resolution: {integrity: sha512-bpQy+CrsRmYmoPMAE/0G33iwRqwW4ouqdRg8jgbH3aKuCtOc8lxgmYXg2dMM92CRiGP660EtBcymH/eVUpCSaA==}
+
+  import-without-cache@0.2.5:
+    resolution: {integrity: sha512-B6Lc2s6yApwnD2/pMzFh/d5AVjdsDXjgkeJ766FmFuJELIGHNycKRj+l3A39yZPM4CchqNCB4RITEAYB1KUM6A==}
+    engines: {node: '>=20.19.0'}
 
   imurmurhash@0.1.4:
     resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
@@ -5390,19 +6307,19 @@ packages:
   ini@1.3.8:
     resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
 
-  internal-slot@1.1.0:
-    resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
-    engines: {node: '>= 0.4'}
-
-  interpret@2.2.0:
-    resolution: {integrity: sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==}
-    engines: {node: '>= 0.10'}
+  ini@7.0.0:
+    resolution: {integrity: sha512-ifK0CgjALofS5bkrcTy4RaQ9Vx2Knf/eLeIO+NaswQEpH1UblrtTSCIvN71qQDMq0PeQ/SSPojvEJp9vvvfr+w==}
+    engines: {node: ^22.22.2 || ^24.15.0 || >=26.0.0}
 
   invariant@2.2.4:
     resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}
 
-  ip-address@9.0.5:
-    resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
+  ip-address@10.1.0:
+    resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
+    engines: {node: '>= 12'}
+
+  ip-address@10.2.0:
+    resolution: {integrity: sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==}
     engines: {node: '>= 12'}
 
   ipaddr.js@1.9.1:
@@ -5417,33 +6334,10 @@ packages:
     resolution: {integrity: sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==}
     engines: {node: '>= 0.4'}
 
-  is-array-buffer@3.0.5:
-    resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
-    engines: {node: '>= 0.4'}
-
-  is-arrayish@0.2.1:
-    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
-
-  is-async-function@2.1.1:
-    resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
-    engines: {node: '>= 0.4'}
-
-  is-bigint@1.1.0:
-    resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==}
-    engines: {node: '>= 0.4'}
-
   is-binary-path@2.1.0:
     resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
     engines: {node: '>=8'}
 
-  is-boolean-object@1.2.2:
-    resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==}
-    engines: {node: '>= 0.4'}
-
-  is-builtin-module@3.2.1:
-    resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==}
-    engines: {node: '>=6'}
-
   is-callable@1.2.7:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
@@ -5452,23 +6346,16 @@ packages:
     resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
     engines: {node: '>= 0.4'}
 
-  is-data-view@1.0.2:
-    resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==}
-    engines: {node: '>= 0.4'}
-
-  is-date-object@1.1.0:
-    resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
-    engines: {node: '>= 0.4'}
-
-  is-directory@0.3.1:
-    resolution: {integrity: sha512-yVChGzahRFvbkscn2MlwGismPO12i9+znNruC5gVEntG3qu0xQMzsGg/JFbrsqDOHtHFPci+V5aP5T9I+yeKqw==}
-    engines: {node: '>=0.10.0'}
-
   is-docker@2.2.1:
     resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
     engines: {node: '>=8'}
     hasBin: true
 
+  is-docker@3.0.0:
+    resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    hasBin: true
+
   is-error@2.2.2:
     resolution: {integrity: sha512-IOQqts/aHWbiisY5DuPJQ0gcbvaLFCa7fBa9xoLfxBZvQ+ZI/Zh9xoI7Gk+G64N0FdK4AbibytHht2tWgpJWLg==}
 
@@ -5476,10 +6363,6 @@ packages:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
 
-  is-finalizationregistry@1.1.1:
-    resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==}
-    engines: {node: '>= 0.4'}
-
   is-fullwidth-code-point@3.0.0:
     resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
     engines: {node: '>=8'}
@@ -5488,29 +6371,26 @@ packages:
     resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
     engines: {node: '>=12'}
 
-  is-generator-function@1.1.0:
-    resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==}
+  is-fullwidth-code-point@5.1.0:
+    resolution: {integrity: sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==}
+    engines: {node: '>=18'}
+
+  is-generator-function@1.1.2:
+    resolution: {integrity: sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==}
     engines: {node: '>= 0.4'}
 
   is-glob@4.0.3:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
 
+  is-inside-container@1.0.0:
+    resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
+    engines: {node: '>=14.16'}
+    hasBin: true
+
   is-lambda@1.0.1:
     resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==}
 
-  is-map@2.0.3:
-    resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==}
-    engines: {node: '>= 0.4'}
-
-  is-negative-zero@2.0.3:
-    resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==}
-    engines: {node: '>= 0.4'}
-
-  is-number-object@1.1.1:
-    resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==}
-    engines: {node: '>= 0.4'}
-
   is-number@7.0.0:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
@@ -5523,9 +6403,6 @@ packages:
     resolution: {integrity: sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==}
     engines: {node: '>=0.10.0'}
 
-  is-promise@2.2.2:
-    resolution: {integrity: sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==}
-
   is-promise@4.0.0:
     resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
 
@@ -5536,26 +6413,10 @@ packages:
     resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
     engines: {node: '>= 0.4'}
 
-  is-set@2.0.3:
-    resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==}
-    engines: {node: '>= 0.4'}
-
-  is-shared-array-buffer@1.0.4:
-    resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==}
-    engines: {node: '>= 0.4'}
-
   is-stream@3.0.0:
     resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
-  is-string@1.1.1:
-    resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==}
-    engines: {node: '>= 0.4'}
-
-  is-symbol@1.1.1:
-    resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==}
-    engines: {node: '>= 0.4'}
-
   is-typed-array@1.1.15:
     resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
     engines: {node: '>= 0.4'}
@@ -5564,32 +6425,17 @@ packages:
     resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==}
     engines: {node: '>=12'}
 
-  is-weakmap@2.0.2:
-    resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==}
-    engines: {node: '>= 0.4'}
-
-  is-weakref@1.1.1:
-    resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==}
-    engines: {node: '>= 0.4'}
-
-  is-weakset@2.0.4:
-    resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==}
-    engines: {node: '>= 0.4'}
-
-  is-what@4.1.16:
-    resolution: {integrity: sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==}
-    engines: {node: '>=12.13'}
-
   is-wsl@2.2.0:
     resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
     engines: {node: '>=8'}
 
+  is-wsl@3.1.0:
+    resolution: {integrity: sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==}
+    engines: {node: '>=16'}
+
   isarray@1.0.0:
     resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
 
-  isarray@2.0.5:
-    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
-
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
@@ -5612,9 +6458,6 @@ packages:
     resolution: {integrity: sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==}
     engines: {node: 20 || >=22}
 
-  javascript-natural-sort@0.7.1:
-    resolution: {integrity: sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==}
-
   jest-environment-node@29.7.0:
     resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -5654,6 +6497,10 @@ packages:
   jimp-compact@0.16.1:
     resolution: {integrity: sha512-dZ6Ra7u1G8c4Letq/B5EzAxj4tLFHL+cGtdpR+PVm4yzPDj+lCk+AbivWt1eOM+ikzkowtyV7qSqX6qr3t71Ww==}
 
+  jiti@2.6.1:
+    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
+    hasBin: true
+
   jmespath@0.16.0:
     resolution: {integrity: sha512-9FzQjJ7MATs1tSpnco1K6ayiYE3figslrXA72G2HQ/n76RzvYlofyi5QM+iX4YRs/pu3yzxlVQSST23+dMDknw==}
     engines: {node: '>= 0.6.0'}
@@ -5664,12 +6511,18 @@ packages:
   jose@5.2.3:
     resolution: {integrity: sha512-KUXdbctm1uHVL8BYhnyHkgp3zDX5KW8ZhAKVFEfUbU2P8Alpzjb+48hHvjOdQIyPshoblhzsuqOwEEAbtHVirA==}
 
+  jose@6.2.3:
+    resolution: {integrity: sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==}
+
   joycon@3.1.1:
     resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
     engines: {node: '>=10'}
 
-  js-base64@3.7.7:
-    resolution: {integrity: sha512-7rCnleh0z2CkXhH67J8K1Ytz0b2Y+yxTPL+/KOJoa20hfnVQ/3/T6W/KflYI4bRHRagNeXeU2bkNGI3v1oS/lw==}
+  js-base64@3.7.8:
+    resolution: {integrity: sha512-hNngCeKxIUQiEUN3GPJOkz4wF/YvdUdbNL9hsBcMQTkKzboD7T/q3OYOuuPZLUE6dBxSGpwhk5mwuDud7JVAow==}
+
+  js-md4@0.3.2:
+    resolution: {integrity: sha512-/GDnfQYsltsjRswQhN9fhv3EMw2sCpUdrdxyWDOUK7eyD++r3gRhzgiQgc/x4MAv2i1iuQ4lxO5mvqM3vj4bwA==}
 
   js-string-escape@1.0.1:
     resolution: {integrity: sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==}
@@ -5678,16 +6531,16 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
-  js-yaml@3.14.1:
-    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+  js-yaml@3.14.2:
+    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
     hasBin: true
 
-  js-yaml@4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
-  jsbn@1.1.0:
-    resolution: {integrity: sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==}
+  jsbi@4.3.2:
+    resolution: {integrity: sha512-9fqMSQbhJykSeii05nxKl4m6Eqn2P6rOlYiS+C5Dr/HPIU/7yZxu5qzbs40tgaFORiw2Amd0mirjxatXYMkIew==}
 
   jsc-safe-url@0.2.4:
     resolution: {integrity: sha512-0wM3YBWtYePOjfyXQH5MWQ8H7sdk5EXSwZvmSLKk2RboVQ2Bu239jycHDz5J/8Blf3K0Qnoy2b6xD+z10MFB+Q==}
@@ -5696,15 +6549,6 @@ packages:
     resolution: {integrity: sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==}
     engines: {node: '>= 10.16.0'}
 
-  jsesc@0.5.0:
-    resolution: {integrity: sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==}
-    hasBin: true
-
-  jsesc@3.0.2:
-    resolution: {integrity: sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==}
-    engines: {node: '>=6'}
-    hasBin: true
-
   jsesc@3.1.0:
     resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
     engines: {node: '>=6'}
@@ -5713,20 +6557,10 @@ packages:
   json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
-  json-diff@0.9.0:
-    resolution: {integrity: sha512-cVnggDrVkAAA3OvFfHpFEhOnmcsUpleEKq4d4O8sQWWSH40MBrWstKigVB1kGrgLWzuom+7rRdaCsnBD6VyObQ==}
-    hasBin: true
-
   json-diff@1.0.6:
     resolution: {integrity: sha512-tcFIPRdlc35YkYdGxcamJjllUhXWv4n2rK9oJ2RsAzV4FBkuV4ojKEDgcZ+kpKxDmJKv+PFK65+1tVVOnSeEqA==}
     hasBin: true
 
-  json-parse-better-errors@1.0.2:
-    resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
-
-  json-parse-even-better-errors@2.3.1:
-    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
-
   json-rules-engine@7.3.1:
     resolution: {integrity: sha512-NyRTQZllvAt7AQ3g9P7/t4nIwlEB+EyZV7y8/WgXfZWSlpcDryt1UH9CsoU+Z+MDvj8umN9qqEcbE6qnk9JAHw==}
     engines: {node: '>=18.0.0'}
@@ -5734,21 +6568,20 @@ packages:
   json-schema-traverse@0.4.1:
     resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
 
+  json-schema-traverse@1.0.0:
+    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+
+  json-schema-typed@8.0.2:
+    resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
+
   json-stable-stringify-without-jsonify@1.0.1:
     resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
 
-  json5@1.0.2:
-    resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==}
-    hasBin: true
-
   json5@2.2.3:
     resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
     engines: {node: '>=6'}
     hasBin: true
 
-  jsonfile@6.1.0:
-    resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
-
   jsonparse@1.3.1:
     resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==}
     engines: {'0': node >= 0.2.0}
@@ -5763,15 +6596,25 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  jsonwebtoken@9.0.2:
+    resolution: {integrity: sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==}
+    engines: {node: '>=12', npm: '>=6'}
+
   junk@4.0.1:
     resolution: {integrity: sha512-Qush0uP+G8ZScpGMZvHUiRfI0YBWuB3gVBYlI0v0vvOJt5FLicco+IkP0a50LqTTQhmts/m6tP5SWE+USyIvcQ==}
     engines: {node: '>=12.20'}
 
+  jwa@1.4.2:
+    resolution: {integrity: sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==}
+
+  jws@3.2.2:
+    resolution: {integrity: sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==}
+
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
-  keyv@5.3.3:
-    resolution: {integrity: sha512-Rwu4+nXI9fqcxiEHtbkvoes2X+QfkTRo1TMkPfwzipGsJlJO/z69vqB4FNl9xJ3xCpAcbkvmEabZfPzrwN3+gQ==}
+  keyv@5.5.4:
+    resolution: {integrity: sha512-eohl3hKTiVyD1ilYdw9T0OiB4hnjef89e3dMYKz+mVKDzj+5IteTseASUsOB+EU9Tf6VNTCjDePcP6wkDGmLKQ==}
 
   kleur@3.0.3:
     resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
@@ -5781,37 +6624,8 @@ packages:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
 
-  knex@2.5.1:
-    resolution: {integrity: sha512-z78DgGKUr4SE/6cm7ku+jHvFT0X97aERh/f0MUKAKgFnwCYBEW4TFBqtHWFYiJFid7fMrtpZ/gxJthvz5mEByA==}
-    engines: {node: '>=12'}
-    hasBin: true
-    peerDependencies:
-      better-sqlite3: '*'
-      mysql: '*'
-      mysql2: '*'
-      pg: '*'
-      pg-native: '*'
-      sqlite3: '*'
-      tedious: '*'
-    peerDependenciesMeta:
-      better-sqlite3:
-        optional: true
-      mysql:
-        optional: true
-      mysql2:
-        optional: true
-      pg:
-        optional: true
-      pg-native:
-        optional: true
-      sqlite3:
-        optional: true
-      tedious:
-        optional: true
-
-  kysely@0.25.0:
-    resolution: {integrity: sha512-srn0efIMu5IoEBk0tBmtGnoUss4uwvxtbFQWG/U2MosfqIace1l43IFP1PmEpHRDp+Z79xIcKEqmHH3dAvQdQA==}
-    engines: {node: '>=14.0.0'}
+  kubernetes-types@1.30.0:
+    resolution: {integrity: sha512-Dew1okvhM/SQcIa2rcgujNndZwU8VnSapDgdxlYoB84ZlpAD43U6KLAFqYo17ykSFGHNPrg0qry0bP+GJd9v7Q==}
 
   lan-network@0.1.7:
     resolution: {integrity: sha512-mnIlAEMu4OyEvUNdzco9xpuB9YVcPkQec+QsgycBCtPZvEqWPCDPfbAE4OJMdBBWpZWtpCn1xw9jJYlwjWI5zQ==}
@@ -5827,73 +6641,85 @@ packages:
 
   libsql@0.4.7:
     resolution: {integrity: sha512-T9eIRCs6b0J1SHKYIvD8+KCJMcWZ900iZyxdnSCdqxN12Z1ijzT+jY5nrk72Jw4B0HGzms2NgpryArlJqvc3Lw==}
+    cpu: [x64, arm64, wasm32]
+    os: [darwin, linux, win32]
+
+  libsql@0.5.29:
+    resolution: {integrity: sha512-8lMP8iMgiBzzoNbAPQ59qdVcj6UaE/Vnm+fiwX4doX4Narook0a4GPKWBEv+CR8a1OwbfkgL18uBfBjWdF0Fzg==}
+    cpu: [x64, arm64, wasm32, arm]
     os: [darwin, linux, win32]
 
   lighthouse-logger@1.4.2:
     resolution: {integrity: sha512-gPWxznF6TKmUHrOQjlVo2UbaL2EJ71mb2CCeRs/2qBpi4L/g4LUVc9+3lKQ6DTUZwJswfM7ainGrLO1+fOqa2g==}
 
-  lightningcss-darwin-arm64@1.27.0:
-    resolution: {integrity: sha512-Gl/lqIXY+d+ySmMbgDf0pgaWSqrWYxVHoc88q+Vhf2YNzZ8DwoRzGt5NZDVqqIW5ScpSnmmjcgXP87Dn2ylSSQ==}
+  lightningcss-android-arm64@1.30.2:
+    resolution: {integrity: sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.30.2:
+    resolution: {integrity: sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [darwin]
 
-  lightningcss-darwin-x64@1.27.0:
-    resolution: {integrity: sha512-0+mZa54IlcNAoQS9E0+niovhyjjQWEMrwW0p2sSdLRhLDc8LMQ/b67z7+B5q4VmjYCMSfnFi3djAAQFIDuj/Tg==}
+  lightningcss-darwin-x64@1.30.2:
+    resolution: {integrity: sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [darwin]
 
-  lightningcss-freebsd-x64@1.27.0:
-    resolution: {integrity: sha512-n1sEf85fePoU2aDN2PzYjoI8gbBqnmLGEhKq7q0DKLj0UTVmOTwDC7PtLcy/zFxzASTSBlVQYJUhwIStQMIpRA==}
+  lightningcss-freebsd-x64@1.30.2:
+    resolution: {integrity: sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [freebsd]
 
-  lightningcss-linux-arm-gnueabihf@1.27.0:
-    resolution: {integrity: sha512-MUMRmtdRkOkd5z3h986HOuNBD1c2lq2BSQA1Jg88d9I7bmPGx08bwGcnB75dvr17CwxjxD6XPi3Qh8ArmKFqCA==}
+  lightningcss-linux-arm-gnueabihf@1.30.2:
+    resolution: {integrity: sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm]
     os: [linux]
 
-  lightningcss-linux-arm64-gnu@1.27.0:
-    resolution: {integrity: sha512-cPsxo1QEWq2sfKkSq2Bq5feQDHdUEwgtA9KaB27J5AX22+l4l0ptgjMZZtYtUnteBofjee+0oW1wQ1guv04a7A==}
+  lightningcss-linux-arm64-gnu@1.30.2:
+    resolution: {integrity: sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
 
-  lightningcss-linux-arm64-musl@1.27.0:
-    resolution: {integrity: sha512-rCGBm2ax7kQ9pBSeITfCW9XSVF69VX+fm5DIpvDZQl4NnQoMQyRwhZQm9pd59m8leZ1IesRqWk2v/DntMo26lg==}
+  lightningcss-linux-arm64-musl@1.30.2:
+    resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
 
-  lightningcss-linux-x64-gnu@1.27.0:
-    resolution: {integrity: sha512-Dk/jovSI7qqhJDiUibvaikNKI2x6kWPN79AQiD/E/KeQWMjdGe9kw51RAgoWFDi0coP4jinaH14Nrt/J8z3U4A==}
+  lightningcss-linux-x64-gnu@1.30.2:
+    resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
 
-  lightningcss-linux-x64-musl@1.27.0:
-    resolution: {integrity: sha512-QKjTxXm8A9s6v9Tg3Fk0gscCQA1t/HMoF7Woy1u68wCk5kS4fR+q3vXa1p3++REW784cRAtkYKrPy6JKibrEZA==}
+  lightningcss-linux-x64-musl@1.30.2:
+    resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
 
-  lightningcss-win32-arm64-msvc@1.27.0:
-    resolution: {integrity: sha512-/wXegPS1hnhkeG4OXQKEMQeJd48RDC3qdh+OA8pCuOPCyvnm/yEayrJdJVqzBsqpy1aJklRCVxscpFur80o6iQ==}
+  lightningcss-win32-arm64-msvc@1.30.2:
+    resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [win32]
 
-  lightningcss-win32-x64-msvc@1.27.0:
-    resolution: {integrity: sha512-/OJLj94Zm/waZShL8nB5jsNj3CfNATLCTyFxZyouilfTmSoLDX7VlVAmhPHoZWVFp4vdmoiEbPEYC8HID3m6yw==}
+  lightningcss-win32-x64-msvc@1.30.2:
+    resolution: {integrity: sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [win32]
 
-  lightningcss@1.27.0:
-    resolution: {integrity: sha512-8f7aNmS1+etYSLHht0fQApPc2kNO8qGRutifN5rVIc6Xo6ABsEbqOr758UwI7ALVbTt4x1fllKt0PYgzD9S3yQ==}
+  lightningcss@1.30.2:
+    resolution: {integrity: sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==}
     engines: {node: '>= 12.0.0'}
 
   lilconfig@3.1.3:
@@ -5903,6 +6729,15 @@ packages:
   lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
+  lint-staged@16.2.7:
+    resolution: {integrity: sha512-lDIj4RnYmK7/kXMya+qJsmkRFkGolciXjrsZ6PC25GdTfWOAWetR0ZbsNXRAj1EHHImRSalc+whZFg56F5DVow==}
+    engines: {node: '>=20.17'}
+    hasBin: true
+
+  listr2@9.0.5:
+    resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==}
+    engines: {node: '>=20.0.0'}
+
   load-json-file@7.0.1:
     resolution: {integrity: sha512-Gnxj3ev3mB5TkVBGad0JM6dmLiQL+o0t23JPBZ9sd+yvSLk05mFoqKBw5N8gbbkU4TNXyqCgIrl/VM17OgUIgQ==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -5929,11 +6764,29 @@ packages:
   lodash.debounce@4.0.8:
     resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}
 
+  lodash.includes@4.3.0:
+    resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==}
+
+  lodash.isboolean@3.0.3:
+    resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==}
+
+  lodash.isinteger@4.0.4:
+    resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==}
+
+  lodash.isnumber@3.0.3:
+    resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==}
+
+  lodash.isplainobject@4.0.6:
+    resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
+
+  lodash.isstring@4.0.1:
+    resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==}
+
   lodash.merge@4.6.2:
     resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
 
-  lodash.sortby@4.7.0:
-    resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==}
+  lodash.once@4.1.1:
+    resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==}
 
   lodash.throttle@4.1.1:
     resolution: {integrity: sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==}
@@ -5945,6 +6798,10 @@ packages:
     resolution: {integrity: sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==}
     engines: {node: '>=4'}
 
+  log-update@6.1.0:
+    resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
+    engines: {node: '>=18'}
+
   long@5.3.2:
     resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==}
 
@@ -5952,17 +6809,14 @@ packages:
     resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
     hasBin: true
 
-  loupe@2.3.7:
-    resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==}
-
-  loupe@3.1.3:
-    resolution: {integrity: sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==}
+  loupe@3.2.1:
+    resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==}
 
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.1.0:
-    resolution: {integrity: sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==}
+  lru-cache@11.2.2:
+    resolution: {integrity: sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -5976,15 +6830,19 @@ packages:
     resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==}
     engines: {node: '>=12'}
 
-  lru-queue@0.1.0:
-    resolution: {integrity: sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ==}
+  lru.min@1.1.3:
+    resolution: {integrity: sha512-Lkk/vx6ak3rYkRR0Nhu4lFUT2VDnQSxBe8Hbl7f36358p6ow8Bnvr8lrLt98H8J1aGxfhbX4Fs5tYg2+FTwr5Q==}
+    engines: {bun: '>=1.0.0', deno: '>=1.30.0', node: '>=8.0.0'}
 
-  lru.min@1.1.2:
-    resolution: {integrity: sha512-Nv9KddBcQSlQopmBHXSsZVY5xsdlZkdH/Iey0BlcBYggMd4two7cZnKOK9vmy3nY0O5RGH99z1PCeTpPqszUYg==}
+  lru.min@1.1.4:
+    resolution: {integrity: sha512-DqC6n3QQ77zdFpCMASA1a3Jlb64Hv2N2DciFGkO/4L9+q/IpIAuRlKOvCXabtRW6cQf8usbmM6BE/TOPysCdIA==}
     engines: {bun: '>=1.0.0', deno: '>=1.30.0', node: '>=8.0.0'}
 
-  magic-string@0.30.17:
-    resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==}
+  lz4js@0.2.0:
+    resolution: {integrity: sha512-gY2Ia9Lm7Ep8qMiuGRhvUq0Q7qUereeldZPP1PMEJxPtEWHJLqw9pgX68oHajBH0nzJK4MaZEA/YNV3jT8u8Bg==}
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
   make-error@1.3.6:
     resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
@@ -5996,6 +6854,9 @@ packages:
   make-synchronized@0.4.2:
     resolution: {integrity: sha512-EwEJSg8gSGLicKXp/VzNi1tvzhdmNBxOzslkkJSoNUCQFZKH/NIUIp7xlfN+noaHrz4BJDN73gne8IHnjl/F/A==}
 
+  make-synchronized@0.8.0:
+    resolution: {integrity: sha512-DZu4lwc0ffoFz581BSQa/BJl+1ZqIkoRQ+VejMlH0VrP4E86StAODnZujZ4sepumQj8rcP7wUnUBGM8Gu+zKUA==}
+
   makeerror@1.0.12:
     resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==}
 
@@ -6003,23 +6864,14 @@ packages:
     resolution: {integrity: sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==}
     engines: {node: '>=6'}
 
-  map-stream@0.1.0:
-    resolution: {integrity: sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g==}
-
-  marked-terminal@6.2.0:
-    resolution: {integrity: sha512-ubWhwcBFHnXsjYNsu+Wndpg0zhY4CahSpPlA70PlO0rR9r2sZpkyU+rkCsOWH+KMEkx847UpALON+HWgxowFtw==}
-    engines: {node: '>=16.0.0'}
-    peerDependencies:
-      marked: '>=1 <12'
-
-  marked-terminal@7.3.0:
-    resolution: {integrity: sha512-t4rBvPsHc57uE/2nJOLmMbZCQ4tgAccAED3ngXQqW6g+TxA488JzJ+FK3lQkzBQOI1mRV/r/Kq+1ZlJ4D0owQw==}
+  marked-terminal@7.1.0:
+    resolution: {integrity: sha512-+pvwa14KZL74MVXjYdPR3nSInhGhNvPce/3mqLVZT2oUvt654sL1XImFuLZ1pkA866IYZ3ikDTOFUIC7XzpZZg==}
     engines: {node: '>=16.0.0'}
     peerDependencies:
-      marked: '>=1 <16'
+      marked: '>=1 <14'
 
-  marked@9.1.6:
-    resolution: {integrity: sha512-jcByLnIFkd5gSXZmjNvS1TlmRhCXZjIzHYlaGkPlLIekG55JDR2Z4va9tZwCiP+/RDERiNhMOFu01xd6O5ct1Q==}
+  marked@9.1.2:
+    resolution: {integrity: sha512-qoKMJqK0w6vkLk8+KnKZAH6neUZSNaQqVZ/h2yZ9S7CbLuFHyS2viB0jnqcWF9UKjwsAbMrQtnQhdmdvOVOw9w==}
     engines: {node: '>= 16'}
     hasBin: true
 
@@ -6049,10 +6901,6 @@ packages:
   memoize-one@5.2.1:
     resolution: {integrity: sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==}
 
-  memoizee@0.4.17:
-    resolution: {integrity: sha512-DGqD7Hjpi/1or4F/aYAspXKNm5Yili0QDAFAY4QYvpqpgiY6+1jOfqpmByzjxbWd/T9mChbCArXAbDAsTm5oXA==}
-    engines: {node: '>=0.12'}
-
   meow@12.1.1:
     resolution: {integrity: sha512-BhXM0Au22RwUneMPwSCnyhTOizdWoIEPU9sp0Aqa1PnDMR5Wv2FGXYDjuzJEIX+Eo2Rb8xuYe5jrnm5QowQFkw==}
     engines: {node: '>=16.10'}
@@ -6068,62 +6916,120 @@ packages:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
 
-  metro-babel-transformer@0.82.4:
-    resolution: {integrity: sha512-4juJahGRb1gmNbQq48lNinB6WFNfb6m0BQqi/RQibEltNiqTCxew/dBspI2EWA4xVCd3mQWGfw0TML4KurQZnQ==}
-    engines: {node: '>=18.18'}
+  metro-babel-transformer@0.83.2:
+    resolution: {integrity: sha512-rirY1QMFlA1uxH3ZiNauBninwTioOgwChnRdDcbB4tgRZ+bGX9DiXoh9QdpppiaVKXdJsII932OwWXGGV4+Nlw==}
+    engines: {node: '>=20.19.4'}
+
+  metro-babel-transformer@0.83.3:
+    resolution: {integrity: sha512-1vxlvj2yY24ES1O5RsSIvg4a4WeL7PFXgKOHvXTXiW0deLvQr28ExXj6LjwCCDZ4YZLhq6HddLpZnX4dEdSq5g==}
+    engines: {node: '>=20.19.4'}
+
+  metro-cache-key@0.83.2:
+    resolution: {integrity: sha512-3EMG/GkGKYoTaf5RqguGLSWRqGTwO7NQ0qXKmNBjr0y6qD9s3VBXYlwB+MszGtmOKsqE9q3FPrE5Nd9Ipv7rZw==}
+    engines: {node: '>=20.19.4'}
+
+  metro-cache-key@0.83.3:
+    resolution: {integrity: sha512-59ZO049jKzSmvBmG/B5bZ6/dztP0ilp0o988nc6dpaDsU05Cl1c/lRf+yx8m9WW/JVgbmfO5MziBU559XjI5Zw==}
+    engines: {node: '>=20.19.4'}
+
+  metro-cache@0.83.2:
+    resolution: {integrity: sha512-Z43IodutUZeIS7OTH+yQFjc59QlFJ6s5OvM8p2AP9alr0+F8UKr8ADzFzoGKoHefZSKGa4bJx7MZJLF6GwPDHQ==}
+    engines: {node: '>=20.19.4'}
+
+  metro-cache@0.83.3:
+    resolution: {integrity: sha512-3jo65X515mQJvKqK3vWRblxDEcgY55Sk3w4xa6LlfEXgQ9g1WgMh9m4qVZVwgcHoLy0a2HENTPCCX4Pk6s8c8Q==}
+    engines: {node: '>=20.19.4'}
+
+  metro-config@0.83.2:
+    resolution: {integrity: sha512-1FjCcdBe3e3D08gSSiU9u3Vtxd7alGH3x/DNFqWDFf5NouX4kLgbVloDDClr1UrLz62c0fHh2Vfr9ecmrOZp+g==}
+    engines: {node: '>=20.19.4'}
+
+  metro-config@0.83.3:
+    resolution: {integrity: sha512-mTel7ipT0yNjKILIan04bkJkuCzUUkm2SeEaTads8VfEecCh+ltXchdq6DovXJqzQAXuR2P9cxZB47Lg4klriA==}
+    engines: {node: '>=20.19.4'}
+
+  metro-core@0.83.2:
+    resolution: {integrity: sha512-8DRb0O82Br0IW77cNgKMLYWUkx48lWxUkvNUxVISyMkcNwE/9ywf1MYQUE88HaKwSrqne6kFgCSA/UWZoUT0Iw==}
+    engines: {node: '>=20.19.4'}
+
+  metro-core@0.83.3:
+    resolution: {integrity: sha512-M+X59lm7oBmJZamc96usuF1kusd5YimqG/q97g4Ac7slnJ3YiGglW5CsOlicTR5EWf8MQFxxjDoB6ytTqRe8Hw==}
+    engines: {node: '>=20.19.4'}
+
+  metro-file-map@0.83.2:
+    resolution: {integrity: sha512-cMSWnEqZrp/dzZIEd7DEDdk72PXz6w5NOKriJoDN9p1TDQ5nAYrY2lHi8d6mwbcGLoSlWmpPyny9HZYFfPWcGQ==}
+    engines: {node: '>=20.19.4'}
+
+  metro-file-map@0.83.3:
+    resolution: {integrity: sha512-jg5AcyE0Q9Xbbu/4NAwwZkmQn7doJCKGW0SLeSJmzNB9Z24jBe0AL2PHNMy4eu0JiKtNWHz9IiONGZWq7hjVTA==}
+    engines: {node: '>=20.19.4'}
 
-  metro-cache-key@0.82.4:
-    resolution: {integrity: sha512-2JCTqcpF+f2OghOpe/+x+JywfzDkrHdAqinPFWmK2ezNAU/qX0jBFaTETogPibFivxZJil37w9Yp6syX8rFUng==}
-    engines: {node: '>=18.18'}
+  metro-minify-terser@0.83.2:
+    resolution: {integrity: sha512-zvIxnh7U0JQ7vT4quasKsijId3dOAWgq+ip2jF/8TMrPUqQabGrs04L2dd0haQJ+PA+d4VvK/bPOY8X/vL2PWw==}
+    engines: {node: '>=20.19.4'}
 
-  metro-cache@0.82.4:
-    resolution: {integrity: sha512-vX0ylSMGtORKiZ4G8uP6fgfPdDiCWvLZUGZ5zIblSGylOX6JYhvExl0Zg4UA9pix/SSQu5Pnp9vdODMFsNIxhw==}
-    engines: {node: '>=18.18'}
+  metro-minify-terser@0.83.3:
+    resolution: {integrity: sha512-O2BmfWj6FSfzBLrNCXt/rr2VYZdX5i6444QJU0fFoc7Ljg+Q+iqebwE3K0eTvkI6TRjELsXk1cjU+fXwAR4OjQ==}
+    engines: {node: '>=20.19.4'}
 
-  metro-config@0.82.4:
-    resolution: {integrity: sha512-Ki3Wumr3hKHGDS7RrHsygmmRNc/PCJrvkLn0+BWWxmbOmOcMMJDSmSI+WRlT8jd5VPZFxIi4wg+sAt5yBXAK0g==}
-    engines: {node: '>=18.18'}
+  metro-resolver@0.83.2:
+    resolution: {integrity: sha512-Yf5mjyuiRE/Y+KvqfsZxrbHDA15NZxyfg8pIk0qg47LfAJhpMVEX+36e6ZRBq7KVBqy6VDX5Sq55iHGM4xSm7Q==}
+    engines: {node: '>=20.19.4'}
 
-  metro-core@0.82.4:
-    resolution: {integrity: sha512-Xo4ozbxPg2vfgJGCgXZ8sVhC2M0lhTqD+tsKO2q9aelq/dCjnnSb26xZKcQO80CQOQUL7e3QWB7pLFGPjZm31A==}
-    engines: {node: '>=18.18'}
+  metro-resolver@0.83.3:
+    resolution: {integrity: sha512-0js+zwI5flFxb1ktmR///bxHYg7OLpRpWZlBBruYG8OKYxeMP7SV0xQ/o/hUelrEMdK4LJzqVtHAhBm25LVfAQ==}
+    engines: {node: '>=20.19.4'}
 
-  metro-file-map@0.82.4:
-    resolution: {integrity: sha512-eO7HD1O3aeNsbEe6NBZvx1lLJUrxgyATjnDmb7bm4eyF6yWOQot9XVtxTDLNifECuvsZ4jzRiTInrbmIHkTdGA==}
-    engines: {node: '>=18.18'}
+  metro-runtime@0.83.2:
+    resolution: {integrity: sha512-nnsPtgRvFbNKwemqs0FuyFDzXLl+ezuFsUXDbX8o0SXOfsOPijqiQrf3kuafO1Zx1aUWf4NOrKJMAQP5EEHg9A==}
+    engines: {node: '>=20.19.4'}
 
-  metro-minify-terser@0.82.4:
-    resolution: {integrity: sha512-W79Mi6BUwWVaM8Mc5XepcqkG+TSsCyyo//dmTsgYfJcsmReQorRFodil3bbJInETvjzdnS1mCsUo9pllNjT1Hg==}
-    engines: {node: '>=18.18'}
+  metro-runtime@0.83.3:
+    resolution: {integrity: sha512-JHCJb9ebr9rfJ+LcssFYA2x1qPYuSD/bbePupIGhpMrsla7RCwC/VL3yJ9cSU+nUhU4c9Ixxy8tBta+JbDeZWw==}
+    engines: {node: '>=20.19.4'}
 
-  metro-resolver@0.82.4:
-    resolution: {integrity: sha512-uWoHzOBGQTPT5PjippB8rRT3iI9CTgFA9tRiLMzrseA5o7YAlgvfTdY9vFk2qyk3lW3aQfFKWkmqENryPRpu+Q==}
-    engines: {node: '>=18.18'}
+  metro-source-map@0.83.2:
+    resolution: {integrity: sha512-5FL/6BSQvshIKjXOennt9upFngq2lFvDakZn5LfauIVq8+L4sxXewIlSTcxAtzbtjAIaXeOSVMtCJ5DdfCt9AA==}
+    engines: {node: '>=20.19.4'}
 
-  metro-runtime@0.82.4:
-    resolution: {integrity: sha512-vVyFO7H+eLXRV2E7YAUYA7aMGBECGagqxmFvC2hmErS7oq90BbPVENfAHbUWq1vWH+MRiivoRxdxlN8gBoF/dw==}
-    engines: {node: '>=18.18'}
+  metro-source-map@0.83.3:
+    resolution: {integrity: sha512-xkC3qwUBh2psVZgVavo8+r2C9Igkk3DibiOXSAht1aYRRcztEZNFtAMtfSB7sdO2iFMx2Mlyu++cBxz/fhdzQg==}
+    engines: {node: '>=20.19.4'}
 
-  metro-source-map@0.82.4:
-    resolution: {integrity: sha512-9jzDQJ0FPas1FuQFtwmBHsez2BfhFNufMowbOMeG3ZaFvzeziE8A0aJwILDS3U+V5039ssCQFiQeqDgENWvquA==}
-    engines: {node: '>=18.18'}
+  metro-symbolicate@0.83.2:
+    resolution: {integrity: sha512-KoU9BLwxxED6n33KYuQQuc5bXkIxF3fSwlc3ouxrrdLWwhu64muYZNQrukkWzhVKRNFIXW7X2iM8JXpi2heIPw==}
+    engines: {node: '>=20.19.4'}
+    hasBin: true
 
-  metro-symbolicate@0.82.4:
-    resolution: {integrity: sha512-LwEwAtdsx7z8rYjxjpLWxuFa2U0J6TS6ljlQM4WAATKa4uzV8unmnRuN2iNBWTmRqgNR77mzmI2vhwD4QSCo+w==}
-    engines: {node: '>=18.18'}
+  metro-symbolicate@0.83.3:
+    resolution: {integrity: sha512-F/YChgKd6KbFK3eUR5HdUsfBqVsanf5lNTwFd4Ca7uuxnHgBC3kR/Hba/RGkenR3pZaGNp5Bu9ZqqP52Wyhomw==}
+    engines: {node: '>=20.19.4'}
     hasBin: true
 
-  metro-transform-plugins@0.82.4:
-    resolution: {integrity: sha512-NoWQRPHupVpnDgYguiEcm7YwDhnqW02iWWQjO2O8NsNP09rEMSq99nPjARWfukN7+KDh6YjLvTIN20mj3dk9kw==}
-    engines: {node: '>=18.18'}
+  metro-transform-plugins@0.83.2:
+    resolution: {integrity: sha512-5WlW25WKPkiJk2yA9d8bMuZrgW7vfA4f4MBb9ZeHbTB3eIAoNN8vS8NENgG/X/90vpTB06X66OBvxhT3nHwP6A==}
+    engines: {node: '>=20.19.4'}
+
+  metro-transform-plugins@0.83.3:
+    resolution: {integrity: sha512-eRGoKJU6jmqOakBMH5kUB7VitEWiNrDzBHpYbkBXW7C5fUGeOd2CyqrosEzbMK5VMiZYyOcNFEphvxk3OXey2A==}
+    engines: {node: '>=20.19.4'}
+
+  metro-transform-worker@0.83.2:
+    resolution: {integrity: sha512-G5DsIg+cMZ2KNfrdLnWMvtppb3+Rp1GMyj7Bvd9GgYc/8gRmvq1XVEF9XuO87Shhb03kFhGqMTgZerz3hZ1v4Q==}
+    engines: {node: '>=20.19.4'}
+
+  metro-transform-worker@0.83.3:
+    resolution: {integrity: sha512-Ztekew9t/gOIMZX1tvJOgX7KlSLL5kWykl0Iwu2cL2vKMKVALRl1hysyhUw0vjpAvLFx+Kfq9VLjnHIkW32fPA==}
+    engines: {node: '>=20.19.4'}
 
-  metro-transform-worker@0.82.4:
-    resolution: {integrity: sha512-kPI7Ad/tdAnI9PY4T+2H0cdgGeSWWdiPRKuytI806UcN4VhFL6OmYa19/4abYVYF+Cd2jo57CDuwbaxRfmXDhw==}
-    engines: {node: '>=18.18'}
+  metro@0.83.2:
+    resolution: {integrity: sha512-HQgs9H1FyVbRptNSMy/ImchTTE5vS2MSqLoOo7hbDoBq6hPPZokwJvBMwrYSxdjQZmLXz2JFZtdvS+ZfgTc9yw==}
+    engines: {node: '>=20.19.4'}
+    hasBin: true
 
-  metro@0.82.4:
-    resolution: {integrity: sha512-/gFmw3ux9CPG5WUmygY35hpyno28zi/7OUn6+OFfbweA8l0B+PPqXXLr0/T6cf5nclCcH0d22o+02fICaShVxw==}
-    engines: {node: '>=18.18'}
+  metro@0.83.3:
+    resolution: {integrity: sha512-+rP+/GieOzkt97hSJ0MrPOuAH/jpaS21ZDvL9DJ35QYRDlQcwzcvUlGUf79AnQxq/2NPiS/AULhhM4TKutIt8Q==}
+    engines: {node: '>=20.19.4'}
     hasBin: true
 
   micromatch@4.0.8:
@@ -6142,9 +7048,9 @@ packages:
     resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
     engines: {node: '>= 0.6'}
 
-  mime-types@3.0.1:
-    resolution: {integrity: sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==}
-    engines: {node: '>= 0.6'}
+  mime-types@3.0.2:
+    resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
+    engines: {node: '>=18'}
 
   mime@1.6.0:
     resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
@@ -6159,16 +7065,16 @@ packages:
     resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
     engines: {node: '>=12'}
 
+  mimic-function@5.0.1:
+    resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
+    engines: {node: '>=18'}
+
   mimic-response@3.1.0:
     resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
     engines: {node: '>=10'}
 
-  min-indent@1.0.1:
-    resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
-    engines: {node: '>=4'}
-
-  minimatch@10.0.1:
-    resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==}
+  minimatch@10.1.1:
+    resolution: {integrity: sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==}
     engines: {node: 20 || >=22}
 
   minimatch@3.1.2:
@@ -6229,8 +7135,8 @@ packages:
     resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
     engines: {node: '>= 8'}
 
-  minizlib@3.0.2:
-    resolution: {integrity: sha512-oG62iEk+CYt5Xj2YqI5Xi9xWUeZhDI8jjQmC5oThVH5JGCTgIjr7ciJDzC7MBzYd//WvR1OTmP5Q38Q8ShQtVA==}
+  minizlib@3.1.0:
+    resolution: {integrity: sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==}
     engines: {node: '>= 18'}
 
   mkdirp-classic@0.5.3:
@@ -6241,13 +7147,8 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
-  mkdirp@3.0.1:
-    resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==}
-    engines: {node: '>=10'}
-    hasBin: true
-
-  mlly@1.7.4:
-    resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==}
+  mlly@1.8.0:
+    resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==}
 
   module-details-from-path@1.0.4:
     resolution: {integrity: sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w==}
@@ -6256,23 +7157,45 @@ packages:
     resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
     engines: {node: '>=4'}
 
-  mrmime@2.0.1:
-    resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
-    engines: {node: '>=10'}
-
   ms@2.0.0:
     resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
 
-  ms@2.1.2:
-    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
-
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
+  msgpackr-extract@3.0.4:
+    resolution: {integrity: sha512-4kmO/MdyUIkLIvTPr8VHLil4AtoKIoniWPIEk5+CDy0xnWC84azhSFmuJ7PxZdsYtiP5kEeQsORAVIeMgxT+Hw==}
+    hasBin: true
+
+  msgpackr@1.11.9:
+    resolution: {integrity: sha512-FkoAAyyA6HM8wL882EcEyFZ9s7hVADSwG9xrVx3dxxNQAtgADTrJoEWivID82Iv1zWDsv/OtbrrcZAzGzOMdNw==}
+
+  msgpackr@2.0.4:
+    resolution: {integrity: sha512-o1C5KRmuRt+apqMr1HuGSqWStZoRBUpEsCsl15uM9VdAF1qHLtvMOU2En747EnTyEl6c4pzPewRMFF31s1CNbA==}
+
+  mssql@11.0.1:
+    resolution: {integrity: sha512-KlGNsugoT90enKlR8/G36H0kTxPthDhmtNUCwEHvgRza5Cjpjoj+P2X6eMpFUDN7pFrJZsKadL4x990G8RBE1w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  mssql@12.1.1:
+    resolution: {integrity: sha512-nUTXi0unU6p72YKe6KDR9vW2mSQWsmy1KZqV0JkaT2v3RSkxlwx4Y4srjYmH+DZNbyA53Ijp6o2OaLnLc4F2Qg==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  multipasta@0.2.7:
+    resolution: {integrity: sha512-KPA58d68KgGil15oDqXjkUBEBYc00XvbPj5/X+dyzeo/lWm9Nc25pQRlf1D+gv4OpK7NM0J1odrbu9JNNGvynA==}
+
   mysql2@3.14.1:
     resolution: {integrity: sha512-7ytuPQJjQB8TNAYX/H2yhL+iQOnIBjAMam361R7UAL0lOVXWjtdrmoL9HYKqKoLp/8UUTRcvo1QPvK9KL7wA8w==}
     engines: {node: '>= 8.0'}
 
+  mysql2@3.22.3:
+    resolution: {integrity: sha512-uWWxvZSRvRhtBdh2CdcuK83YcOfPdmEeEYB069bAmPnV93QApDGVPuvCQOLjlh7tYHEWdgQPrn6kosDxHBVLkA==}
+    engines: {node: '>= 8.0'}
+    peerDependencies:
+      '@types/node': '>= 8'
+
   mz@2.7.0:
     resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
 
@@ -6280,8 +7203,16 @@ packages:
     resolution: {integrity: sha512-eLoBxg6wE/rZkJPhU/xRX1WTpkFEwDJEN96oxFrTsqBdbT5ec295Q+CoHrL9IT0DipqKhmGcaZmwOt8OON5x1w==}
     engines: {node: '>=12.0.0'}
 
-  nan@2.22.2:
-    resolution: {integrity: sha512-DANghxFkS1plDdRsX0X9pm0Z6SJNN6gBdtXfanwoZ8hooC5gosGFSBGRYHUVPz1asKA/kMRqDRdHrluZ61SpBQ==}
+  named-placeholders@1.1.6:
+    resolution: {integrity: sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==}
+    engines: {node: '>=8.0.0'}
+
+  nan@2.23.1:
+    resolution: {integrity: sha512-r7bBUGKzlqk8oPBDYxt6Z0aEdF1G1rwlMcLk8LCOMbOzf0mG+JUfUzG4fIMWwHWP0iyaLWEQZJmtB7nOHEm/qw==}
+
+  nano-spawn@2.0.0:
+    resolution: {integrity: sha512-tacvGzUY5o2D8CBh2rrwxyNojUsZNU2zjNTzKQrkgGJQTbGAfArVWXSKMBokBeeg6C7OLRGUEyoFlYbfeWQIqw==}
+    engines: {node: '>=20.17'}
 
   nanoid@3.3.11:
     resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
@@ -6291,6 +7222,9 @@ packages:
   napi-build-utils@2.0.0:
     resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
 
+  native-duplexpair@1.0.0:
+    resolution: {integrity: sha512-E7QQoM+3jvNtlmyfqRZ0/U75VFgCls+fSkbml2MpgWkWyz3ox8Y58gNhfuziuQYGNNQAbFZJQck55LHCnCK6CA==}
+
   natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
@@ -6312,11 +7246,8 @@ packages:
   nested-error-stacks@2.1.1:
     resolution: {integrity: sha512-9iN1ka/9zmX1ZvLV9ewJYEk9h7RyRRtqdK0woXcqohu8EWIerfPUjYJPg0ULy0UqP7cslmdGc8xKDJcojlKiaw==}
 
-  next-tick@1.1.0:
-    resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==}
-
-  node-abi@3.75.0:
-    resolution: {integrity: sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==}
+  node-abi@3.85.0:
+    resolution: {integrity: sha512-zsFhmbkAzwhTft6nd3VxcG0cvJsT70rL+BIGHWVq5fi6MwGrHwzqKaxXE+Hl2GmnGItnDKPPkO5/LQqjVkIdFg==}
     engines: {node: '>=10'}
 
   node-addon-api@7.1.1:
@@ -6331,18 +7262,18 @@ packages:
     resolution: {integrity: sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==}
     engines: {node: '>=18'}
 
-  node-fetch@3.3.1:
-    resolution: {integrity: sha512-cRVc/kyto/7E5shrWca1Wsea4y6tL9iYJE5FBCius3JQfb/4P4I295PfhgbJQBLTx6lATE4z+wK0rPM4VS2uow==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-
   node-fetch@3.3.2:
     resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
-  node-forge@1.3.1:
-    resolution: {integrity: sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==}
+  node-forge@1.3.2:
+    resolution: {integrity: sha512-6xKiQ+cph9KImrRh0VsjH2d8/GXA4FIMlgU4B757iI1ApvcyA9VlouP0yZJha01V+huImO+kKMU7ih+2+E14fw==}
     engines: {node: '>= 6.13.0'}
 
+  node-gyp-build-optional-packages@5.2.2:
+    resolution: {integrity: sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==}
+    hasBin: true
+
   node-gyp-build@4.8.4:
     resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
     hasBin: true
@@ -6355,8 +7286,8 @@ packages:
   node-int64@0.4.0:
     resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
 
-  node-releases@2.0.19:
-    resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==}
+  node-releases@2.0.27:
+    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
 
   nofilter@3.1.0:
     resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==}
@@ -6370,9 +7301,6 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
-  normalize-package-data@2.5.0:
-    resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
-
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -6396,9 +7324,13 @@ packages:
   nullthrows@1.1.1:
     resolution: {integrity: sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==}
 
-  ob1@0.82.4:
-    resolution: {integrity: sha512-n9S8e4l5TvkrequEAMDidl4yXesruWTNTzVkeaHSGywoTOIwTzZzKw7Z670H3eaXDZui5MJXjWGNzYowVZIxCA==}
-    engines: {node: '>=18.18'}
+  ob1@0.83.2:
+    resolution: {integrity: sha512-XlK3w4M+dwd1g1gvHzVbxiXEbUllRONEgcF2uEO0zm4nxa0eKlh41c6N65q1xbiDOeKKda1tvNOAD33fNjyvCg==}
+    engines: {node: '>=20.19.4'}
+
+  ob1@0.83.3:
+    resolution: {integrity: sha512-egUxXCDwoWG06NGCS5s5AdcpnumHKJlfd3HH06P3m9TEMwwScfcY35wpQxbm9oHof+dM/lVH9Rfyu1elTVelSA==}
+    engines: {node: '>=20.19.4'}
 
   object-assign@4.1.1:
     resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
@@ -6412,35 +7344,18 @@ packages:
     resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
     engines: {node: '>= 0.4'}
 
-  object-keys@1.1.1:
-    resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
-    engines: {node: '>= 0.4'}
-
-  object.assign@4.1.7:
-    resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
-    engines: {node: '>= 0.4'}
-
-  object.fromentries@2.0.8:
-    resolution: {integrity: sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==}
-    engines: {node: '>= 0.4'}
-
-  object.groupby@1.0.3:
-    resolution: {integrity: sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==}
-    engines: {node: '>= 0.4'}
-
-  object.values@1.2.1:
-    resolution: {integrity: sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==}
-    engines: {node: '>= 0.4'}
-
   obuf@1.1.2:
     resolution: {integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==}
 
-  ohm-js@17.1.0:
-    resolution: {integrity: sha512-xc3B5dgAjTBQGHaH7B58M2Pmv6WvzrJ/3/7LeUzXNg0/sY3jQPdSd/S2SstppaleO77rifR1tyhdfFGNIwxf2Q==}
+  obug@2.1.1:
+    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
+
+  ohm-js@17.2.1:
+    resolution: {integrity: sha512-4cXF0G09fAYU9z61kTfkNbKK1Kz/sGEZ5NbVWHoe9Qi7VB7y+Spwk051CpUTfUENdlIr+vt8tMV4/LosTE2cDQ==}
     engines: {node: '>=0.12.1'}
 
-  oidc-token-hash@5.1.0:
-    resolution: {integrity: sha512-y0W+X7Ppo7oZX6eovsRkuzcSM40Bicg2JEJkDJ4irIt1wsYAP5MLSNv+QAogO8xivMffw/9OvV3um1pxXgt1uA==}
+  oidc-token-hash@5.2.0:
+    resolution: {integrity: sha512-6gj2m8cJZ+iSW8bm0FXdGF0YhIQbKrfP4yWTNzxc31U6MOjfEmB1rHvlYvxI1B7t7BCi1F2vYTT6YhtQRG4hxw==}
     engines: {node: ^10.13.0 || >=12.0.0}
 
   on-finished@2.3.0:
@@ -6451,8 +7366,8 @@ packages:
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
     engines: {node: '>= 0.8'}
 
-  on-headers@1.0.2:
-    resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==}
+  on-headers@1.1.0:
+    resolution: {integrity: sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==}
     engines: {node: '>= 0.8'}
 
   once@1.4.0:
@@ -6466,6 +7381,14 @@ packages:
     resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
     engines: {node: '>=12'}
 
+  onetime@7.0.0:
+    resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
+    engines: {node: '>=18'}
+
+  open@10.2.0:
+    resolution: {integrity: sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==}
+    engines: {node: '>=18'}
+
   open@7.4.2:
     resolution: {integrity: sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==}
     engines: {node: '>=8'}
@@ -6489,9 +7412,15 @@ packages:
     resolution: {integrity: sha512-eNwHudNbO1folBP3JsZ19v9azXWtQZjICdr3Q0TDPIaeBQ3mXLrh54wM+er0+hSp+dWKf+Z8KM58CYzEyIYxYg==}
     engines: {node: '>=6'}
 
-  own-keys@1.0.1:
-    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
-    engines: {node: '>= 0.4'}
+  oxlint@1.30.0:
+    resolution: {integrity: sha512-6Mcpj7Gn26QNRUpue9kRZKQg623mH10kLPl597sNCOfXeUZHTglrc2O54eskHMRA+tR7c0u73nW4GPwSFePLkA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      oxlint-tsgolint: '>=0.8.1'
+    peerDependenciesMeta:
+      oxlint-tsgolint:
+        optional: true
 
   p-defer@1.0.0:
     resolution: {integrity: sha512-wB3wfAxZpk2AzOfUMJNL+d36xothRSyj8EXOa4f6GMqYDN9BJaaSISbsk+wS9abmnebVw95C2Kb5t85UmpCxuw==}
@@ -6549,8 +7478,8 @@ packages:
     resolution: {integrity: sha512-T8BatKGY+k5rU+Q/GTYgrEf2r4xRMevAN5mtXc2aPc4rS1j3s+vWTaO2Wag94neXuCAUAs8cxBL9EeB5EA6diw==}
     engines: {node: '>=16'}
 
-  p-map@7.0.3:
-    resolution: {integrity: sha512-VkndIv2fIB99swvQoA65bm+fsmt6UNdGeIB0oxBs+WhAhdh08QA04JXpI7rbB9r08/nkbysKoya9rtDERYOYMA==}
+  p-map@7.0.4:
+    resolution: {integrity: sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==}
     engines: {node: '>=18'}
 
   p-timeout@5.1.0:
@@ -6572,14 +7501,6 @@ packages:
     resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
     engines: {node: '>=6'}
 
-  parse-json@4.0.0:
-    resolution: {integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==}
-    engines: {node: '>=4'}
-
-  parse-json@5.2.0:
-    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
-    engines: {node: '>=8'}
-
   parse-ms@3.0.0:
     resolution: {integrity: sha512-Tpb8Z7r7XbbtBTrM9UhpkzzaMrqA2VXMT3YChzYltwV3P3pM6t8wl7TvpMnSTosz1aQAdVib7kdoys7vYOPerw==}
     engines: {node: '>=12'}
@@ -6634,13 +7555,12 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
 
-  path-scurry@2.0.0:
-    resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==}
+  path-scurry@2.0.1:
+    resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}
     engines: {node: 20 || >=22}
 
-  path-to-regexp@8.2.0:
-    resolution: {integrity: sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==}
-    engines: {node: '>=16'}
+  path-to-regexp@8.3.0:
+    resolution: {integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==}
 
   path-type@4.0.0:
     resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
@@ -6656,21 +7576,26 @@ packages:
   pathe@2.0.3:
     resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
 
-  pathval@2.0.0:
-    resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==}
+  pathval@2.0.1:
+    resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==}
     engines: {node: '>= 14.16'}
 
-  pause-stream@0.0.11:
-    resolution: {integrity: sha512-e3FBlXLmN/D1S+zHzanP4E/4Z60oFAa3O051qt1pxa7DEJWKAyil6upYVXCWadEnuoqa4Pkc9oUx9zsxYeRv8A==}
+  pg-cloudflare@1.2.7:
+    resolution: {integrity: sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==}
+
+  pg-cloudflare@1.3.0:
+    resolution: {integrity: sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==}
 
-  pg-cloudflare@1.2.5:
-    resolution: {integrity: sha512-OOX22Vt0vOSRrdoUPKJ8Wi2OpE/o/h9T8X1s4qSkCedbNah9ei2W2765be8iMVxQUsvgT7zIAT2eIa9fs5+vtg==}
+  pg-connection-string@2.12.0:
+    resolution: {integrity: sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==}
 
-  pg-connection-string@2.6.1:
-    resolution: {integrity: sha512-w6ZzNu6oMmIzEAYVw+RLK0+nqHPt8K3ZnknKi+g48Ak2pr3dtljJW3o+D/n2zzCG07Zoe9VOX3aiKpj+BN0pjg==}
+  pg-connection-string@2.9.1:
+    resolution: {integrity: sha512-nkc6NpDcvPVpZXxrreI/FOtX3XemeLl8E0qFr6F2Lrm/I8WOnaWNhIPK2Z7OHpw7gh5XJThi6j6ppgNoaT1w4w==}
 
-  pg-connection-string@2.9.0:
-    resolution: {integrity: sha512-P2DEBKuvh5RClafLngkAuGe9OUlFV7ebu8w1kmaaOgPcpJd1RIFh7otETfI6hAR8YupOLFTY7nuvvIn7PLciUQ==}
+  pg-cursor@2.19.0:
+    resolution: {integrity: sha512-J5cF1MUz7LRJ9emOqF/06QjabMHMZy587rSPF0UuA8rCwKeeYl2co8Pp+6k5UU9YrAYHMzWkLxilfZB0hqsWWw==}
+    peerDependencies:
+      pg: ^8
 
   pg-int8@1.0.1:
     resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==}
@@ -6680,25 +7605,42 @@ packages:
     resolution: {integrity: sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw==}
     engines: {node: '>=4'}
 
-  pg-pool@3.10.0:
-    resolution: {integrity: sha512-DzZ26On4sQ0KmqnO34muPcmKbhrjmyiO4lCCR0VwEd7MjmiKf5NTg/6+apUEu0NF7ESa37CGzFxH513CoUmWnA==}
+  pg-pool@3.10.1:
+    resolution: {integrity: sha512-Tu8jMlcX+9d8+QVzKIvM/uJtp07PKr82IUOYEphaWcoBhIYkoHpLXN3qO59nAI11ripznDsEzEv8nUxBVWajGg==}
+    peerDependencies:
+      pg: '>=8.0'
+
+  pg-pool@3.13.0:
+    resolution: {integrity: sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==}
     peerDependencies:
       pg: '>=8.0'
 
-  pg-protocol@1.10.0:
-    resolution: {integrity: sha512-IpdytjudNuLv8nhlHs/UrVBhU0e78J0oIS/0AVdTbWxSOkFUVdsHC/NrorO6nXsQNDTT1kzDSOMJubBQviX18Q==}
+  pg-protocol@1.10.3:
+    resolution: {integrity: sha512-6DIBgBQaTKDJyxnXaLiLR8wBpQQcGWuAESkRBX/t6OwA8YsqP+iVSiond2EDy6Y/dsGk8rh/jtax3js5NeV7JQ==}
+
+  pg-protocol@1.13.0:
+    resolution: {integrity: sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==}
 
   pg-types@2.2.0:
     resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==}
     engines: {node: '>=4'}
 
-  pg-types@4.0.2:
-    resolution: {integrity: sha512-cRL3JpS3lKMGsKaWndugWQoLOCoP+Cic8oseVcbr0qhPzYD5DWXK+RZ9LY9wxRf7RQia4SCwQlXk0q6FCPrVng==}
+  pg-types@4.1.0:
+    resolution: {integrity: sha512-o2XFanIMy/3+mThw69O8d4n1E5zsLhdO+OPqswezu7Z5ekP4hYDqlDjlmOpYMbzY2Br0ufCwJLdDIXeNVwcWFg==}
     engines: {node: '>=10'}
 
-  pg@8.16.0:
-    resolution: {integrity: sha512-7SKfdvP8CTNXjMUzfcVTaI+TDzBEeaUnVwiVGZQD1Hh33Kpev7liQba9uLd4CfN8r9mCVsD0JIpq03+Unpz+kg==}
-    engines: {node: '>= 8.0.0'}
+  pg@8.16.3:
+    resolution: {integrity: sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==}
+    engines: {node: '>= 16.0.0'}
+    peerDependencies:
+      pg-native: '>=3.0.1'
+    peerDependenciesMeta:
+      pg-native:
+        optional: true
+
+  pg@8.20.0:
+    resolution: {integrity: sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==}
+    engines: {node: '>= 16.0.0'}
     peerDependencies:
       pg-native: '>=3.0.1'
     peerDependenciesMeta:
@@ -6719,10 +7661,15 @@ packages:
     resolution: {integrity: sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==}
     engines: {node: '>=10'}
 
-  picomatch@4.0.2:
-    resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==}
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
     engines: {node: '>=12'}
 
+  pidtree@0.6.0:
+    resolution: {integrity: sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==}
+    engines: {node: '>=0.10'}
+    hasBin: true
+
   pirates@4.0.7:
     resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
     engines: {node: '>= 6'}
@@ -6731,6 +7678,10 @@ packages:
     resolution: {integrity: sha512-ZBmhE1C9LcPoH9XZSdwiPtbPHZROwAnMy+kIFQVrnMCxY4Cudlz3gBOpzilgc0jOgRaiT3sIWfpMomW2ar2orQ==}
     engines: {node: '>=16.20.0'}
 
+  pkce-challenge@5.0.1:
+    resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==}
+    engines: {node: '>=16.20.0'}
+
   pkg-conf@4.0.0:
     resolution: {integrity: sha512-7dmgi4UY4qk+4mj5Cd8v/GExPo0K+SlY+hulOSdfZ/T6jVH6//y7NtzZo5WrfhDBxuQ0jCa7fLZmNaNh7EWL/w==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -6780,8 +7731,8 @@ packages:
     resolution: {integrity: sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==}
     engines: {node: ^10 || ^12 || >=14}
 
-  postcss@8.5.4:
-    resolution: {integrity: sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==}
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
     engines: {node: ^10 || ^12 || >=14}
 
   postgres-array@2.0.0:
@@ -6829,21 +7780,23 @@ packages:
   prebuild-install@7.1.3:
     resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
     engines: {node: '>=10'}
+    deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
     hasBin: true
 
   prelude-ls@1.2.1:
     resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
     engines: {node: '>= 0.8.0'}
 
-  prettier-linter-helpers@1.0.0:
-    resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==}
-    engines: {node: '>=6.0.0'}
-
   prettier@3.5.3:
     resolution: {integrity: sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==}
     engines: {node: '>=14'}
     hasBin: true
 
+  prettier@3.6.2:
+    resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==}
+    engines: {node: '>=14'}
+    hasBin: true
+
   pretty-bytes@5.6.0:
     resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==}
     engines: {node: '>=6'}
@@ -6865,6 +7818,10 @@ packages:
     resolution: {integrity: sha512-g8+OnU/L2v+wyiVK+D5fA34J7EH8jZ8DDlvwhRCMxmMj7UCBvxiO1mGeN+36JXIKF4zevU4kRBd8lVgG9vLelA==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
+  process@0.11.10:
+    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
+    engines: {node: '>= 0.6.0'}
+
   progress@2.0.3:
     resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
     engines: {node: '>=0.4.0'}
@@ -6891,21 +7848,16 @@ packages:
     resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
     engines: {node: '>= 6'}
 
-  protobufjs@7.5.3:
-    resolution: {integrity: sha512-sildjKwVqOI2kmFDiXQ6aEB0fjYTafpEvIBs8tOR8qI4spuL9OPROLVu2qZqi/xgCfsHIwVqlaF8JBjWFHnKbw==}
+  protobufjs@7.5.4:
+    resolution: {integrity: sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==}
     engines: {node: '>=12.0.0'}
 
   proxy-addr@2.0.7:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
 
-  ps-tree@1.2.0:
-    resolution: {integrity: sha512-0VnamPPYHl4uaU/nSFeZZpR21QAWRz+sRv4iW9+v/GS/J5U5iZB5BNN6J0RMoOvdx2gWM2+ZFMIm58q24e4UYA==}
-    engines: {node: '>= 0.10'}
-    hasBin: true
-
-  pump@3.0.2:
-    resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==}
+  pump@3.0.3:
+    resolution: {integrity: sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==}
 
   punycode@1.3.2:
     resolution: {integrity: sha512-RofWgt/7fL5wP1Y7fxE7/EmTLzQVnB0ycyibJ0OOHIlJqTNzglYFxVwETOcIoJqJmpDXJ9xImDv+Fq34F/d4Dw==}
@@ -6917,6 +7869,9 @@ packages:
   pure-rand@6.1.0:
     resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==}
 
+  pure-rand@8.0.0:
+    resolution: {integrity: sha512-7rgWlxG2gAvFPIQfUreo1XYlNvrQ9VnQPFWdncPkdl3icucLK0InOxsaafbvxGTnI6Bk/Rxmslg0lQlRCuzOXw==}
+
   qrcode-terminal@0.11.0:
     resolution: {integrity: sha512-Uu7ii+FQy4Qf82G4xu7ShHhjhGahEpCWc3x8UavY3CTcWV+ufmmCtwkr7ZKsX42jdL0kr1B5FKUeqJvAn51jzQ==}
     hasBin: true
@@ -6925,6 +7880,9 @@ packages:
     resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
     engines: {node: '>=0.6'}
 
+  quansync@1.0.0:
+    resolution: {integrity: sha512-5xZacEEufv3HSTPQuchrvV6soaiACMFnq1H8wkVioctoH3TRha9Sz66lOxRwPK/qZj7HPiSveih9yAyh98gvqA==}
+
   querystring@0.2.0:
     resolution: {integrity: sha512-X/xY82scca2tau62i9mDyU9K+I+djTMUsvwf7xnUX5GLvVzgJybOJf4Y6o9Zx3oJK/LSXg5tTZBjwzqVPaPO2g==}
     engines: {node: '>=0.4.x'}
@@ -6936,40 +7894,47 @@ packages:
   queue@6.0.2:
     resolution: {integrity: sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==}
 
-  randombytes@2.1.0:
-    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
-
   range-parser@1.2.1:
     resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
     engines: {node: '>= 0.6'}
 
-  raw-body@3.0.0:
-    resolution: {integrity: sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==}
-    engines: {node: '>= 0.8'}
+  raw-body@3.0.2:
+    resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
+    engines: {node: '>= 0.10'}
 
   rc@1.2.8:
     resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
     hasBin: true
 
-  react-devtools-core@6.1.2:
-    resolution: {integrity: sha512-ldFwzufLletzCikNJVYaxlxMLu7swJ3T2VrGfzXlMsVhZhPDKXA38DEROidaYZVgMAmQnIjymrmqto5pyfrwPA==}
+  react-devtools-core@6.1.5:
+    resolution: {integrity: sha512-ePrwPfxAnB+7hgnEr8vpKxL9cmnp7F322t8oqcPshbIQQhDKgFDW4tjhF2wjVbdXF9O/nyuy3sQWd9JGpiLPvA==}
 
   react-is@18.3.1:
     resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
 
-  react-native-edge-to-edge@1.6.0:
-    resolution: {integrity: sha512-2WCNdE3Qd6Fwg9+4BpbATUxCLcouF6YRY7K+J36KJ4l3y+tWN6XCqAC4DuoGblAAbb2sLkhEDp4FOlbOIot2Og==}
+  react-native-quick-base64@2.2.2:
+    resolution: {integrity: sha512-WLHSifHLoamr2kF00Gov0W9ud6CfPshe1rmqWTquVIi9c62qxOaJCFVDrXFZhEBU8B8PvGLVuOlVKH78yhY0Fg==}
     peerDependencies:
       react: '*'
       react-native: '*'
 
-  react-native@0.79.2:
-    resolution: {integrity: sha512-AnGzb56JvU5YCL7cAwg10+ewDquzvmgrMddiBM0GAWLwQM/6DJfGd2ZKrMuKKehHerpDDZgG+EY64gk3x3dEkw==}
-    engines: {node: '>=18'}
+  react-native-tcp-socket@6.3.0:
+    resolution: {integrity: sha512-NthR04myL5IGL4q+2oCjmAx7OMqEgcjUJk8RExAwNjK/164upCP7Pn2Msno5ZTGd3wL6HuEG8d7T2d8f22N+0A==}
+    peerDependencies:
+      react-native: '>=0.60.0'
+
+  react-native-url-polyfill@3.0.0:
+    resolution: {integrity: sha512-aA5CiuUCUb/lbrliVCJ6lZ17/RpNJzvTO/C7gC/YmDQhTUoRD5q5HlJfwLWcxz4VgAhHwXKzhxH+wUN24tAdqg==}
+    peerDependencies:
+      react-native: '*'
+
+  react-native@0.82.1:
+    resolution: {integrity: sha512-tFAqcU7Z4g49xf/KnyCEzI4nRTu1Opcx05Ov2helr8ZTg1z7AJR/3sr2rZ+AAVlAs2IXk+B0WOxXGmdD3+4czA==}
+    engines: {node: '>= 20.19.4'}
     hasBin: true
     peerDependencies:
-      '@types/react': ^19.0.0
-      react: ^19.0.0
+      '@types/react': ^19.1.1
+      react: ^19.1.1
     peerDependenciesMeta:
       '@types/react':
         optional: true
@@ -6982,18 +7947,14 @@ packages:
     resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==}
     engines: {node: '>=0.10.0'}
 
-  read-pkg-up@7.0.1:
-    resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
-    engines: {node: '>=8'}
-
-  read-pkg@5.2.0:
-    resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==}
-    engines: {node: '>=8'}
-
   readable-stream@3.6.2:
     resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
     engines: {node: '>= 6'}
 
+  readable-stream@4.7.0:
+    resolution: {integrity: sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
   readdirp@3.6.0:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
@@ -7006,19 +7967,8 @@ packages:
     resolution: {integrity: sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==}
     engines: {node: '>= 4'}
 
-  rechoir@0.8.0:
-    resolution: {integrity: sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==}
-    engines: {node: '>= 10.13.0'}
-
-  redeyed@2.1.1:
-    resolution: {integrity: sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==}
-
-  reflect.getprototypeof@1.0.10:
-    resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
-    engines: {node: '>= 0.4'}
-
-  regenerate-unicode-properties@10.2.0:
-    resolution: {integrity: sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==}
+  regenerate-unicode-properties@10.2.2:
+    resolution: {integrity: sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==}
     engines: {node: '>=4'}
 
   regenerate@1.4.2:
@@ -7027,27 +7977,15 @@ packages:
   regenerator-runtime@0.13.11:
     resolution: {integrity: sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==}
 
-  regexp-tree@0.1.27:
-    resolution: {integrity: sha512-iETxpjK6YoRWJG5o6hXLwvjYAoW+FEZn9os0PD/b6AP6xQwsa/Y7lCVgIixBbUPMfhu+i2LtdeAqVTgGlQarfA==}
-    hasBin: true
-
-  regexp.prototype.flags@1.5.4:
-    resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
-    engines: {node: '>= 0.4'}
-
-  regexpu-core@6.2.0:
-    resolution: {integrity: sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==}
+  regexpu-core@6.4.0:
+    resolution: {integrity: sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==}
     engines: {node: '>=4'}
 
   regjsgen@0.8.0:
     resolution: {integrity: sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==}
 
-  regjsparser@0.10.0:
-    resolution: {integrity: sha512-qx+xQGZVsy55CH0a1hiVwHmqjLryfh7wQyF5HO07XJ9f7dQMY/gPQHhlyDkIzJKC+x2fUCpCcUODUUUFrm7SHA==}
-    hasBin: true
-
-  regjsparser@0.12.0:
-    resolution: {integrity: sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==}
+  regjsparser@0.13.0:
+    resolution: {integrity: sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==}
     hasBin: true
 
   require-directory@2.1.1:
@@ -7066,10 +8004,6 @@ packages:
     resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==}
     engines: {node: '>=8'}
 
-  resolve-from@3.0.0:
-    resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==}
-    engines: {node: '>=4'}
-
   resolve-from@4.0.0:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
@@ -7078,6 +8012,10 @@ packages:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
     engines: {node: '>=8'}
 
+  resolve-global@1.0.0:
+    resolution: {integrity: sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==}
+    engines: {node: '>=8'}
+
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
@@ -7094,8 +8032,8 @@ packages:
     resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==}
     engines: {node: '>=10'}
 
-  resolve@1.22.10:
-    resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==}
+  resolve@1.22.11:
+    resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}
     engines: {node: '>= 0.4'}
     hasBin: true
 
@@ -7106,6 +8044,10 @@ packages:
     resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==}
     engines: {node: '>=4'}
 
+  restore-cursor@5.1.0:
+    resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
+    engines: {node: '>=18'}
+
   retry@0.12.0:
     resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
     engines: {node: '>= 4'}
@@ -7118,22 +8060,45 @@ packages:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
   rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
     deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
 
-  rimraf@5.0.10:
-    resolution: {integrity: sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==}
+  rolldown-plugin-dts@0.22.5:
+    resolution: {integrity: sha512-M/HXfM4cboo+jONx9Z0X+CUf3B5tCi7ni+kR5fUW50Fp9AlZk0oVLesibGWgCXDKFp5lpgQ9yhKoImUFjl3VZw==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@ts-macro/tsc': ^0.3.6
+      '@typescript/native-preview': '>=7.0.0-dev.20250601.1'
+      rolldown: ^1.0.0-rc.3
+      typescript: ^5.0.0 || ^6.0.0-beta
+      vue-tsc: ~3.2.0
+    peerDependenciesMeta:
+      '@ts-macro/tsc':
+        optional: true
+      '@typescript/native-preview':
+        optional: true
+      typescript:
+        optional: true
+      vue-tsc:
+        optional: true
+
+  rolldown@1.0.0-rc.3:
+    resolution: {integrity: sha512-Po/YZECDOqVXjIXrtC5h++a5NLvKAQNrd9ggrIG3sbDfGO5BqTUsrI6l8zdniKRp3r5Tp/2JTrXqx4GIguFCMw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
-  rollup@3.29.5:
-    resolution: {integrity: sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w==}
-    engines: {node: '>=14.18.0', npm: '>=8.0.0'}
+  rolldown@1.0.0-rc.9:
+    resolution: {integrity: sha512-9EbgWge7ZH+yqb4d2EnELAntgPTWbfL8ajiTW+SyhJEC4qhBbkCKbqFV4Ge4zmu5ziQuVbWxb/XwLZ+RIO7E8Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
 
-  rollup@4.41.1:
-    resolution: {integrity: sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw==}
+  rollup@4.53.3:
+    resolution: {integrity: sha512-w8GmOxZfBmKknvdXU1sdM9NHcoQejwF/4mNgj2JuEEdRaHwwF12K7e9eXn1nLZ07ad+du76mkVsyeb2rKGllsA==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
@@ -7141,6 +8106,10 @@ packages:
     resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
     engines: {node: '>= 18'}
 
+  run-applescript@7.1.0:
+    resolution: {integrity: sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==}
+    engines: {node: '>=18'}
+
   run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
@@ -7151,17 +8120,9 @@ packages:
     resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
     engines: {node: '>=6'}
 
-  safe-array-concat@1.1.3:
-    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
-    engines: {node: '>=0.4'}
-
   safe-buffer@5.2.1:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
 
-  safe-push-apply@1.0.0:
-    resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==}
-    engines: {node: '>= 0.4'}
-
   safe-regex-test@1.1.0:
     resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
     engines: {node: '>= 0.4'}
@@ -7172,22 +8133,23 @@ packages:
   sax@1.2.1:
     resolution: {integrity: sha512-8I2a3LovHTOpm7NV5yOyO8IHqgVsfK4+UuySrXU8YXkSRX7k6hCV9b3HrkKCr3nMpgj+0bmocaJJWpvp1oc7ZA==}
 
-  sax@1.4.1:
-    resolution: {integrity: sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==}
-
-  scheduler@0.25.0:
-    resolution: {integrity: sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==}
+  sax@1.4.3:
+    resolution: {integrity: sha512-yqYn1JhPczigF94DMS+shiDMjDowYO6y9+wB/4WgO0Y19jWYk0lQ4tuG5KI7kj4FTp1wxPj5IFfcrz/s1c3jjQ==}
 
-  semver@5.7.2:
-    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
-    hasBin: true
+  scheduler@0.26.0:
+    resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==}
 
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
-  semver@7.7.2:
-    resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==}
+  semver@7.7.3:
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  semver@7.7.4:
+    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -7214,9 +8176,6 @@ packages:
     resolution: {integrity: sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==}
     engines: {node: '>=10'}
 
-  serialize-javascript@6.0.2:
-    resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
-
   serve-static@1.16.2:
     resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==}
     engines: {node: '>= 0.8.0'}
@@ -7228,21 +8187,13 @@ packages:
   set-blocking@2.0.0:
     resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
 
-  set-cookie-parser@2.7.1:
-    resolution: {integrity: sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==}
+  set-cookie-parser@2.7.2:
+    resolution: {integrity: sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==}
 
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
 
-  set-function-name@2.0.2:
-    resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==}
-    engines: {node: '>= 0.4'}
-
-  set-proto@1.0.0:
-    resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==}
-    engines: {node: '>= 0.4'}
-
   setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
@@ -7293,10 +8244,6 @@ packages:
   simple-plist@1.3.1:
     resolution: {integrity: sha512-iMSw5i0XseMnrhtIzRb7XpQEXepa9xhWxGUojHBL43SIpQuDQkh3Wpy67ZbDzZVr6EKxvwVChnVpdl8hEVLDiw==}
 
-  sirv@2.0.4:
-    resolution: {integrity: sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==}
-    engines: {node: '>= 10'}
-
   sisteransi@1.0.5:
     resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
 
@@ -7320,6 +8267,10 @@ packages:
     resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
     engines: {node: '>=12'}
 
+  slice-ansi@7.1.2:
+    resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
+    engines: {node: '>=18'}
+
   slugify@1.6.6:
     resolution: {integrity: sha512-h+z7HKHYXj6wJU+AnS/+IH8Uh9fdcX1Lrhg1/VMdf9PwoBQXFcXiAdsy2tSK0P6gKwJLXp02r90ahUCqHk9rrw==}
     engines: {node: '>=8.0.0'}
@@ -7328,15 +8279,20 @@ packages:
     resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
     engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
 
-  smob@1.5.0:
-    resolution: {integrity: sha512-g6T+p7QO8npa+/hNx9ohv1E5pVCmWrVCUzUXJyLdMmftX6ER0oiWY/w9knEonLpnOp6b6FenKnMfR8gqwWdwig==}
+  socket.io-client@4.8.1:
+    resolution: {integrity: sha512-hJVXfu3E28NmzGk8o1sHhN3om52tRvwYeidbj7xKy2eIIse5IoKX3USlS6Tqt3BHAtflLIkCQBkzVrEEfWUyYQ==}
+    engines: {node: '>=10.0.0'}
+
+  socket.io-parser@4.2.4:
+    resolution: {integrity: sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew==}
+    engines: {node: '>=10.0.0'}
 
   socks-proxy-agent@6.2.1:
     resolution: {integrity: sha512-a6KW9G+6B3nWZ1yB8G7pJwL3ggLy1uTzKAgCb7ttblwqdz9fMGJUuTy3uFzEP48FAs9FLILlmzDlE2JJhVQaXQ==}
     engines: {node: '>= 10'}
 
-  socks@2.8.4:
-    resolution: {integrity: sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==}
+  socks@2.8.7:
+    resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
   source-map-js@1.2.1:
@@ -7354,25 +8310,13 @@ packages:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
-  source-map@0.8.0-beta.0:
-    resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==}
-    engines: {node: '>= 8'}
+  source-map@0.7.6:
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
 
   spawn-command@0.0.2:
     resolution: {integrity: sha512-zC8zGoGkmc8J9ndvml8Xksr1Amk9qBujgbF0JAIWO7kXr43w0h/0GJNM/Vustixu+YE8N/MTrQ7N31FvHUACxQ==}
 
-  spdx-correct@3.2.0:
-    resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==}
-
-  spdx-exceptions@2.5.0:
-    resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==}
-
-  spdx-expression-parse@3.0.1:
-    resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
-
-  spdx-license-ids@3.0.21:
-    resolution: {integrity: sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==}
-
   split-ca@1.0.1:
     resolution: {integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==}
 
@@ -7383,15 +8327,16 @@ packages:
     resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
     engines: {node: '>= 10.x'}
 
-  split@0.3.3:
-    resolution: {integrity: sha512-wD2AeVmxXRBoX44wAycgjVpMhvbwdI2aZjCkvfNcH1YqHQvJVa1duWc73OyVGJUc05fhFaTZeQ/PYsrmyH0JVA==}
-
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
   sprintf-js@1.1.3:
     resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
 
+  sql-escaper@1.3.3:
+    resolution: {integrity: sha512-BsTCV265VpTp8tm1wyIm1xqQCS+Q9NHx2Sr+WcnUrgLrQ6yiDIvHYJV5gHxsj1lMBy2zm5twLaZao8Jd+S8JJw==}
+    engines: {bun: '>=1.0.0', deno: '>=2.0.0', node: '>=12.0.0'}
+
   sql.js@1.13.0:
     resolution: {integrity: sha512-RJbVP1HRDlUUXahJ7VMTcu9Rm1Nzw+EBpoPr94vnbD4LwR715F3CcxE2G2k45PewcaZ57pjetYa+LoSJLAASgA==}
 
@@ -7402,56 +8347,56 @@ packages:
     resolution: {integrity: sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==}
     engines: {node: '>= 0.6'}
 
-  ssh2@1.16.0:
-    resolution: {integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg==}
+  ssh2@1.17.0:
+    resolution: {integrity: sha512-wPldCk3asibAjQ/kziWQQt1Wh3PgDFpC0XpwclzKcdT1vql6KeYxf5LIt4nlFkUeR8WuphYMKqUA56X4rjbfgQ==}
     engines: {node: '>=10.16.0'}
 
   ssri@8.0.1:
     resolution: {integrity: sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==}
     engines: {node: '>= 8'}
 
-  sst-darwin-arm64@3.17.0:
-    resolution: {integrity: sha512-ybtElazNZxkxZcArgfzUrnMz62wVDHP4HNpElqfAi+3xNyYVnrEzXPBOPf7ru5IaM1abpP7jV/Asat/+ahA94A==}
+  sst-darwin-arm64@3.17.23:
+    resolution: {integrity: sha512-R6kvmF+rUideOoU7KBs2SdvrIupoE+b+Dor/eq9Uo4Dojj7KvYDZI/EDm8sSCbbcx/opiWeyNqKtlnLEdCxE6g==}
     cpu: [arm64]
     os: [darwin]
 
-  sst-darwin-x64@3.17.0:
-    resolution: {integrity: sha512-RW3wCcXMp9IU7KzSkAQ7HxzmjEbB2PuC6OVPK5HDHKz6Y9O2Lm7cXTDWBnbOIvX80iGGCnusafGx58fPfdH/dA==}
+  sst-darwin-x64@3.17.23:
+    resolution: {integrity: sha512-WW4P1S35iYCifQXxD+sE3wuzcN+LHLpuKMaNoaBqEcWGZnH3IPaDJ7rpLF0arkDAo/z3jZmWWzOCkr0JuqJ8vQ==}
     cpu: [x64]
     os: [darwin]
 
-  sst-linux-arm64@3.17.0:
-    resolution: {integrity: sha512-6elAgGwMslxMOAx+Y1HZ5oJelZlQGUy31H3V1if/RWrgRMNmmvqvTtTotsTKFCmq4RxNOfuAGYEHt3Y3xBFeLQ==}
+  sst-linux-arm64@3.17.23:
+    resolution: {integrity: sha512-TjtNqgIh7RlAWgPLFCAt0mXvIB+J7WjmRvIRrAdX0mXsndOiBJ/DMOgXSLVsIWHCfPj8MIEot/hWpnJgXgIeag==}
     cpu: [arm64]
     os: [linux]
 
-  sst-linux-x64@3.17.0:
-    resolution: {integrity: sha512-z2GrRpJtcKKPmhvjTcbElXE0XH1n5VwiHyAAwX03d+HGobi4s3Ej463b0H778j1GrOCg0+tCt7l/4+26HN+t9w==}
+  sst-linux-x64@3.17.23:
+    resolution: {integrity: sha512-qdqJiEbYfCjZlI3F/TA6eoIU7JXVkEEI/UMILNf2JWhky0KQdCW2Xyz+wb6c0msVJCWdUM/uj+1DaiP2eXvghw==}
     cpu: [x64]
     os: [linux]
 
-  sst-linux-x86@3.17.0:
-    resolution: {integrity: sha512-4z0BW289+lf9GNuH5DY1rEwxN/cSFmiVCz62ZsLI5b2DLtkTy4NNbyQsEo7U3fB90hj/asgTGt8VQwoItr7+ag==}
+  sst-linux-x86@3.17.23:
+    resolution: {integrity: sha512-aGmUujIvoNlmAABEGsOgfY1rxD9koC6hN8bnTLbDI+oI/u/zjHYh50jsbL0p3TlaHpwF/lxP3xFSuT6IKp+KgA==}
     cpu: [x86]
     os: [linux]
 
-  sst-win32-arm64@3.17.0:
-    resolution: {integrity: sha512-6911kVnt9rF8P3X98A/VbdKvu1ZQYGdWr/uZek5LUnyKo2o4FNQalGgX6aqEnw7zBPCadqjqKIITXZDytA/q4Q==}
+  sst-win32-arm64@3.17.23:
+    resolution: {integrity: sha512-ZxdkGqYDrrZGz98rijDCN+m5yuCcwD6Bc9/6hubLsvdpNlVorUqzpg801Ec97xSK0nIC9g6pNiRyxAcsQQstUg==}
     cpu: [arm64]
     os: [win32]
 
-  sst-win32-x64@3.17.0:
-    resolution: {integrity: sha512-dvdeC3w4buOywtmwx4m5m6WidQNJnwXtkSE6ZSMV0emYWl7rSlbDYlv5sA6f9rBs7b+EcfY7SxZ7SmW/pgD/zA==}
+  sst-win32-x64@3.17.23:
+    resolution: {integrity: sha512-yc9cor4MS49Ccy2tQCF1tf6M81yLeSGzGL+gjhUxpVKo2pN3bxl3w70eyU/mTXSEeyAmG9zEfbt6FNu4sy5cUA==}
     cpu: [x64]
     os: [win32]
 
-  sst-win32-x86@3.17.0:
-    resolution: {integrity: sha512-nzLGpAjNJK0zYQXr58txhkEAmJnpbAN9QFHje68nPgbvLjuae10FKHEwooJiUTspzs4rB6RV/apEi/TZbu1JjQ==}
+  sst-win32-x86@3.17.23:
+    resolution: {integrity: sha512-DIp3s54IpNAfdYjSRt6McvkbEPQDMxUu6RUeRAd2C+FcTJgTloon/ghAPQBaDgu2VoVgymjcJARO/XyfKcCLOQ==}
     cpu: [x86]
     os: [win32]
 
-  sst@3.17.0:
-    resolution: {integrity: sha512-nATAmKHLX/ubT3mkC4/LBDSeLUEnJxFELDL/F4sdUpALO2t94RK3Bk8y1RFIVaNY1mcFBLu4V+zz4BnPjxK0FQ==}
+  sst@3.17.23:
+    resolution: {integrity: sha512-TwKgUgDnZdc1Swe+bvCNeyO4dQnYz5cTodMpYj3jlXZdK9/KNz0PVxT1f0u5E76i1pmilXrUBL/f7iiMPw4RDg==}
     hasBin: true
 
   stack-utils@2.0.6:
@@ -7476,24 +8421,25 @@ packages:
     resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
     engines: {node: '>= 0.8'}
 
-  std-env@3.9.0:
-    resolution: {integrity: sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==}
+  statuses@2.0.2:
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
 
-  stop-iteration-iterator@1.1.0:
-    resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
-    engines: {node: '>= 0.4'}
+  std-env@3.10.0:
+    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
 
   stream-buffers@2.2.0:
     resolution: {integrity: sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg==}
     engines: {node: '>= 0.10.0'}
 
-  stream-combiner@0.0.4:
-    resolution: {integrity: sha512-rT00SPnTVyRsaSz5zgSPma/aHSOic5U1prhYdRy5HS2kTZviFpmDgzilbtsJsxiroqACmayynDN/9VzIbX5DOw==}
-
   streamsearch@1.1.0:
     resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==}
     engines: {node: '>=10.0.0'}
 
+  string-argv@0.3.2:
+    resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
+    engines: {node: '>=0.6.19'}
+
   string-width@4.2.3:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -7502,17 +8448,13 @@ packages:
     resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
     engines: {node: '>=12'}
 
-  string.prototype.trim@1.2.10:
-    resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==}
-    engines: {node: '>= 0.4'}
-
-  string.prototype.trimend@1.0.9:
-    resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==}
-    engines: {node: '>= 0.4'}
+  string-width@7.2.0:
+    resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
+    engines: {node: '>=18'}
 
-  string.prototype.trimstart@1.0.8:
-    resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
-    engines: {node: '>= 0.4'}
+  string-width@8.1.0:
+    resolution: {integrity: sha512-Kxl3KJGb/gxkaUMOjRsQ8IrXiGW75O4E3RPjFIINOVH8AMl2SQ/yWdTzWwF3FevIX9LcMAjJW+GRwAlAbTSXdg==}
+    engines: {node: '>=20'}
 
   string_decoder@1.3.0:
     resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
@@ -7525,22 +8467,14 @@ packages:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
 
-  strip-ansi@7.1.0:
-    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
+  strip-ansi@7.1.2:
+    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
     engines: {node: '>=12'}
 
-  strip-bom@3.0.0:
-    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
-    engines: {node: '>=4'}
-
   strip-final-newline@3.0.0:
     resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
     engines: {node: '>=12'}
 
-  strip-indent@3.0.0:
-    resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
-    engines: {node: '>=8'}
-
   strip-json-comments@2.0.1:
     resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
     engines: {node: '>=0.10.0'}
@@ -7549,8 +8483,8 @@ packages:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
 
-  strnum@1.1.2:
-    resolution: {integrity: sha512-vrN+B7DBIoTTZjnPNewwhx6cBA/H+IS7rfW68n7XxC1y7uoiGQBxaKzqucGUgavX15dJgiGztLJ8vxuEzwqBdA==}
+  strnum@2.1.1:
+    resolution: {integrity: sha512-7ZvoFTiCnGxBtDqJ//Cu6fWtZtc7Y3x+QOirG15wztbdngGSkht27o2pyGWrVy0b4WAy3jbKmnoK6g5VlVNUUw==}
 
   structured-headers@0.4.1:
     resolution: {integrity: sha512-0MP/Cxx5SzeeZ10p/bZI0S6MpgD+yxAhi1BOQ34jgnMXsCq3j1t6tQnZu+KdlL7dvJTLT3g9xN8tl10TqgFMcg==}
@@ -7560,9 +8494,10 @@ packages:
     engines: {node: '>=16 || 14 >=14.17'}
     hasBin: true
 
-  superjson@2.2.2:
-    resolution: {integrity: sha512-5JRxVqC8I8NuOUjzBbvVJAKNM8qoVuH0O77h4WInc/qC2q5IreqKxYwgkga3PfA22OayK2ikceb/B26dztPl+Q==}
-    engines: {node: '>=16'}
+  sucrase@3.35.1:
+    resolution: {integrity: sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
 
   supertap@3.0.1:
     resolution: {integrity: sha512-u1ZpIBCawJnO+0QePsEiOknOfCRq0yERxiAchT0i4li0WHNUJbf0evXXSXOcCAR4M8iMDoajXYmstm/qO81Isw==}
@@ -7592,12 +8527,8 @@ packages:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
-  synckit@0.11.8:
-    resolution: {integrity: sha512-+XZ+r1XGIJGeQk3VvXhT6xx/VpbHsRzsTkGgF6E5RX9TTXD0118l87puaEBZ566FhqblC6U0d4XnubznJDm30A==}
-    engines: {node: ^14.18.0 || >=16.0.0}
-
-  tar-fs@2.1.3:
-    resolution: {integrity: sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==}
+  tar-fs@2.1.4:
+    resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
 
   tar-stream@2.2.0:
     resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
@@ -7606,15 +8537,25 @@ packages:
   tar@6.2.1:
     resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
     engines: {node: '>=10'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
-  tar@7.4.3:
-    resolution: {integrity: sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw==}
+  tar@7.5.2:
+    resolution: {integrity: sha512-7NyxrTE4Anh8km8iEy7o0QYPs+0JKBTj5ZaqHg6B39erLg0qYXN3BijtShwbsNSvQ+LN75+KV+C4QR/f6Gwnpg==}
     engines: {node: '>=18'}
+    deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   tarn@3.0.2:
     resolution: {integrity: sha512-51LAVKUSZSVfI05vjPESNc5vwqqZpbXCsU+/+wxlOrUjk2SnFTt97v9ZgQrD4YmxYW1Px6w2KjaDitCfkvgxMQ==}
     engines: {node: '>=8.0.0'}
 
+  tedious@18.6.2:
+    resolution: {integrity: sha512-g7jC56o3MzLkE3lHkaFe2ZdOVFBahq5bsB60/M4NYUbocw/MCrS89IOEQUFr+ba6pb8ZHczZ/VqCyYeYq0xBAg==}
+    engines: {node: '>=18'}
+
+  tedious@19.1.3:
+    resolution: {integrity: sha512-6O6efTeYtcnar3Cqf/ptqJs+U10fYYjp/SHRNm3VGuCTUDys+AUgIbxWbT2kzl4baXAzuy9byV3qCgOimrRfTA==}
+    engines: {node: '>=18.17'}
+
   temp-dir@2.0.0:
     resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==}
     engines: {node: '>=8'}
@@ -7627,8 +8568,8 @@ packages:
     resolution: {integrity: sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==}
     engines: {node: '>=8'}
 
-  terser@5.40.0:
-    resolution: {integrity: sha512-cfeKl/jjwSR5ar7d0FGmave9hFGJT8obyo0z+CrQOylLDbk7X81nPU6vq9VORa5jU30SkDnT2FXjLbR8HLP+xA==}
+  terser@5.44.1:
+    resolution: {integrity: sha512-t/R3R/n0MSwnnazuPpPNVO60LX0SKL45pyl9YlvxIdkH0Of7D5qM2EVe+yASRIlY5pZ73nclYJfNANGWPwFDZw==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -7652,21 +8593,10 @@ packages:
   through2@4.0.2:
     resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==}
 
-  through@2.3.8:
-    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
-
-  tildify@2.0.0:
-    resolution: {integrity: sha512-Cc+OraorugtXNfs50hU9KS369rFXCfgGLpfCfvlc+Ud5u6VWmUQsOAa9HbTvheQdYnrdJqqv1e5oIqXppMYnSw==}
-    engines: {node: '>=8'}
-
   time-zone@1.0.0:
     resolution: {integrity: sha512-TIsDdtKo6+XrPtiTm1ssmMngN1sAhyKnTO2kunQWqNPWIVvCm15Wmw4SWInwTVgJ5u/Tr04+8Ei9TNcw4x4ONA==}
     engines: {node: '>=4'}
 
-  timers-ext@0.1.8:
-    resolution: {integrity: sha512-wFH7+SEAcKfJpfLPkrgMPvvwnEtj8W4IurvEyrKsDleXnKLCDw71w8jltvfLa8Rm4qQxxT4jmDBYbJG/z7qoww==}
-    engines: {node: '>=0.12'}
-
   tiny-invariant@1.3.3:
     resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
 
@@ -7679,20 +8609,28 @@ packages:
   tinyexec@0.3.2:
     resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
 
-  tinyglobby@0.2.14:
-    resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
+  tinyexec@1.0.4:
+    resolution: {integrity: sha512-u9r3uZC0bdpGOXtlxUIdwf9pkmvhqJdrVCH9fapQtgy/OeTTMZ1nqH7agtvEfmGui6e1XxjcdrlxvxJvc3sMqw==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
     engines: {node: '>=12.0.0'}
 
-  tinypool@1.1.0:
-    resolution: {integrity: sha512-7CotroY9a8DKsKprEy/a14aCCm8jYVmR7aFy4fpkZM8sdpNJbKkixuNjgM50yCmip2ezc8z4N7k3oe2+rfRJCQ==}
+  tinypool@1.1.1:
+    resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==}
     engines: {node: ^18.0.0 || >=20.0.0}
 
-  tinyrainbow@2.0.0:
-    resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==}
+  tinyrainbow@1.2.0:
+    resolution: {integrity: sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==}
+    engines: {node: '>=14.0.0'}
+
+  tinyrainbow@3.0.3:
+    resolution: {integrity: sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==}
     engines: {node: '>=14.0.0'}
 
-  tinyspy@4.0.3:
-    resolution: {integrity: sha512-t2T/WLB2WRgZ9EpE4jgPJ9w+i66UZfDc8wHh0xrwiRNN+UwH98GIJkTeZqX9rg0i0ptwzqW+uYeIF0T4F8LR7A==}
+  tinyspy@3.0.2:
+    resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==}
     engines: {node: '>=14.0.0'}
 
   tmpl@1.0.5:
@@ -7706,12 +8644,13 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
-  totalist@3.0.1:
-    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
-    engines: {node: '>=6'}
+  toml@4.1.1:
+    resolution: {integrity: sha512-EBJnVBr3dTXdA89WVFoAIPUqkBjxPMwRqsfuo1r240tKFHXv3zgca4+NJib/h6TyvGF7vOawz0jGuryJCdNHrw==}
+    engines: {node: '>=20'}
 
-  tr46@1.0.1:
-    resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==}
+  tr46@5.1.1:
+    resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
+    engines: {node: '>=18'}
 
   tree-kill@1.2.2:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
@@ -7727,8 +8666,8 @@ packages:
     peerDependencies:
       typescript: '>=4.2.0'
 
-  ts-expose-internals-conditionally@1.0.0-empty.0:
-    resolution: {integrity: sha512-F8m9NOF6ZhdOClDVdlM8gj3fDCav4ZIFSs/EI3ksQbAAXVSCN/Jh5OCJDDZWBuBy9psFc6jULGDlPwjMYMhJDw==}
+  ts-expose-internals@5.6.3:
+    resolution: {integrity: sha512-reb+7TXGaC0odGjywnLocM4f2i8mBhSEjc3gnKqdM21wDy8FcGGVjKbtMNjn17hka34CrwvqNREs0R7CGIeH3w==}
 
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
@@ -7760,17 +8699,36 @@ packages:
       typescript:
         optional: true
 
-  tsconfig-paths@3.15.0:
-    resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==}
-
-  tslib@1.14.1:
-    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+  tsdown@0.20.3:
+    resolution: {integrity: sha512-qWOUXSbe4jN8JZEgrkc/uhJpC8VN2QpNu3eZkBWwNuTEjc/Ik1kcc54ycfcQ5QPRHeu9OQXaLfCI3o7pEJgB2w==}
+    engines: {node: '>=20.19.0'}
+    hasBin: true
+    peerDependencies:
+      '@arethetypeswrong/core': ^0.18.1
+      '@vitejs/devtools': '*'
+      publint: ^0.3.0
+      typescript: ^5.0.0
+      unplugin-lightningcss: ^0.4.0
+      unplugin-unused: ^0.5.0
+    peerDependenciesMeta:
+      '@arethetypeswrong/core':
+        optional: true
+      '@vitejs/devtools':
+        optional: true
+      publint:
+        optional: true
+      typescript:
+        optional: true
+      unplugin-lightningcss:
+        optional: true
+      unplugin-unused:
+        optional: true
 
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
-  tsup@8.5.0:
-    resolution: {integrity: sha512-VmBp77lWNQq6PfuMqCHD3xWl22vEoWsKajkF8t+yMBawlUS8JzEI+vOVMeuNZIuMML8qXRizFKi9oD5glKQVcQ==}
+  tsup@8.5.1:
+    resolution: {integrity: sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing==}
     engines: {node: '>=18'}
     hasBin: true
     peerDependencies:
@@ -7788,56 +8746,50 @@ packages:
       typescript:
         optional: true
 
-  tsutils@3.21.0:
-    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
-    engines: {node: '>= 6'}
-    peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
-
   tsx@3.14.0:
     resolution: {integrity: sha512-xHtFaKtHxM9LOklMmJdI3BEnQq/D5F73Of2E1GDrITi9sgoVkvIsrQUTY1G8FlmGtA+awCI4EBlTRRYxkL2sRg==}
     hasBin: true
 
-  tsx@4.19.4:
-    resolution: {integrity: sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==}
+  tsx@4.20.6:
+    resolution: {integrity: sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==}
     engines: {node: '>=18.0.0'}
     hasBin: true
 
   tunnel-agent@0.6.0:
     resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
 
-  turbo-darwin-64@2.5.4:
-    resolution: {integrity: sha512-ah6YnH2dErojhFooxEzmvsoZQTMImaruZhFPfMKPBq8sb+hALRdvBNLqfc8NWlZq576FkfRZ/MSi4SHvVFT9PQ==}
+  turbo-darwin-64@2.6.1:
+    resolution: {integrity: sha512-Dm0HwhyZF4J0uLqkhUyCVJvKM9Rw7M03v3J9A7drHDQW0qAbIGBrUijQ8g4Q9Cciw/BXRRd8Uzkc3oue+qn+ZQ==}
     cpu: [x64]
     os: [darwin]
 
-  turbo-darwin-arm64@2.5.4:
-    resolution: {integrity: sha512-2+Nx6LAyuXw2MdXb7pxqle3MYignLvS7OwtsP9SgtSBaMlnNlxl9BovzqdYAgkUW3AsYiQMJ/wBRb7d+xemM5A==}
+  turbo-darwin-arm64@2.6.1:
+    resolution: {integrity: sha512-U0PIPTPyxdLsrC3jN7jaJUwgzX5sVUBsKLO7+6AL+OASaa1NbT1pPdiZoTkblBAALLP76FM0LlnsVQOnmjYhyw==}
     cpu: [arm64]
     os: [darwin]
 
-  turbo-linux-64@2.5.4:
-    resolution: {integrity: sha512-5May2kjWbc8w4XxswGAl74GZ5eM4Gr6IiroqdLhXeXyfvWEdm2mFYCSWOzz0/z5cAgqyGidF1jt1qzUR8hTmOA==}
+  turbo-linux-64@2.6.1:
+    resolution: {integrity: sha512-eM1uLWgzv89bxlK29qwQEr9xYWBhmO/EGiH22UGfq+uXr+QW1OvNKKMogSN65Ry8lElMH4LZh0aX2DEc7eC0Mw==}
     cpu: [x64]
     os: [linux]
 
-  turbo-linux-arm64@2.5.4:
-    resolution: {integrity: sha512-/2yqFaS3TbfxV3P5yG2JUI79P7OUQKOUvAnx4MV9Bdz6jqHsHwc9WZPpO4QseQm+NvmgY6ICORnoVPODxGUiJg==}
+  turbo-linux-arm64@2.6.1:
+    resolution: {integrity: sha512-MFFh7AxAQAycXKuZDrbeutfWM5Ep0CEZ9u7zs4Hn2FvOViTCzIfEhmuJou3/a5+q5VX1zTxQrKGy+4Lf5cdpsA==}
     cpu: [arm64]
     os: [linux]
 
-  turbo-windows-64@2.5.4:
-    resolution: {integrity: sha512-EQUO4SmaCDhO6zYohxIjJpOKRN3wlfU7jMAj3CgcyTPvQR/UFLEKAYHqJOnJtymbQmiiM/ihX6c6W6Uq0yC7mA==}
+  turbo-windows-64@2.6.1:
+    resolution: {integrity: sha512-buq7/VAN7KOjMYi4tSZT5m+jpqyhbRU2EUTTvp6V0Ii8dAkY2tAAjQN1q5q2ByflYWKecbQNTqxmVploE0LVwQ==}
     cpu: [x64]
     os: [win32]
 
-  turbo-windows-arm64@2.5.4:
-    resolution: {integrity: sha512-oQ8RrK1VS8lrxkLriotFq+PiF7iiGgkZtfLKF4DDKsmdbPo0O9R2mQxm7jHLuXraRCuIQDWMIw6dpcr7Iykf4A==}
+  turbo-windows-arm64@2.6.1:
+    resolution: {integrity: sha512-7w+AD5vJp3R+FB0YOj1YJcNcOOvBior7bcHTodqp90S3x3bLgpr7tE6xOea1e8JkP7GK6ciKVUpQvV7psiwU5Q==}
     cpu: [arm64]
     os: [win32]
 
-  turbo@2.5.4:
-    resolution: {integrity: sha512-kc8ZibdRcuWUG1pbYSBFWqmIjynlD8Lp7IB6U3vIzvOv9VG+6Sp8bzyeBWE3Oi8XV5KsQrznyRTBPvrf99E4mA==}
+  turbo@2.6.1:
+    resolution: {integrity: sha512-qBwXXuDT3rA53kbNafGbT5r++BrhRgx3sAo0cHoDAeG9g1ItTmUMgltz3Hy7Hazy1ODqNpR+C7QwqL6DYB52yA==}
     hasBin: true
 
   tweetnacl@0.14.5:
@@ -7863,62 +8815,32 @@ packages:
     resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
     engines: {node: '>=10'}
 
-  type-fest@0.6.0:
-    resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==}
-    engines: {node: '>=8'}
-
   type-fest@0.7.1:
     resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==}
     engines: {node: '>=8'}
 
-  type-fest@0.8.1:
-    resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==}
-    engines: {node: '>=8'}
-
   type-is@2.0.1:
     resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
     engines: {node: '>= 0.6'}
 
-  type@2.7.3:
-    resolution: {integrity: sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==}
-
-  typed-array-buffer@1.0.3:
-    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
-    engines: {node: '>= 0.4'}
-
-  typed-array-byte-length@1.0.3:
-    resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==}
-    engines: {node: '>= 0.4'}
-
-  typed-array-byte-offset@1.0.4:
-    resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
-    engines: {node: '>= 0.4'}
-
-  typed-array-length@1.0.7:
-    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
-    engines: {node: '>= 0.4'}
-
-  typescript@5.3.3:
-    resolution: {integrity: sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==}
-    engines: {node: '>=14.17'}
-    hasBin: true
+  typebox@1.1.6:
+    resolution: {integrity: sha512-O2iWCF+RboQfDqr6n83eOq0dKCjVchMWklKgdwKFeR01MGTskILHYEFi9n3lQvfuua4CtvG/EJEIg3P8H9eBcw==}
 
   typescript@5.6.1-rc:
     resolution: {integrity: sha512-E3b2+1zEFu84jB0YQi9BORDjz9+jGbwwy1Zi3G0LUNw7a7cePUrHMRNy8aPh53nXpkFGVHSxIZo5vKTfYaFiBQ==}
     engines: {node: '>=14.17'}
     hasBin: true
 
-  typescript@5.6.3:
-    resolution: {integrity: sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==}
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
     hasBin: true
 
   ufo@1.6.1:
     resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==}
 
-  unbox-primitive@1.1.0:
-    resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
-    engines: {node: '>= 0.4'}
+  unconfig-core@7.5.0:
+    resolution: {integrity: sha512-Su3FauozOGP44ZmKdHy2oE6LPjk51M/TRRjHv2HNCWiDvfvCoxC2lno6jevMA91MYAdCdwP05QnWdWpSbncX/w==}
 
   uncrypto@0.1.3:
     resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==}
@@ -7926,18 +8848,21 @@ packages:
   undici-types@5.26.5:
     resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
 
-  undici-types@6.19.8:
-    resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==}
-
   undici-types@6.21.0:
     resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
+  undici-types@7.16.0:
+    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
+
+  undici-types@7.18.2:
+    resolution: {integrity: sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==}
+
   undici@5.28.4:
     resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==}
     engines: {node: '>=14.0'}
 
-  undici@6.21.3:
-    resolution: {integrity: sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw==}
+  undici@6.22.0:
+    resolution: {integrity: sha512-hU/10obOIu62MGYjdskASR3CUAiYaFTtC9Pa6vHyf//mAipSvSQg6od2CnJswq7fvzNS3zJhxoRkgNVaHurWKw==}
     engines: {node: '>=18.17'}
 
   unicode-canonical-property-names-ecmascript@2.0.1:
@@ -7952,12 +8877,12 @@ packages:
     resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==}
     engines: {node: '>=4'}
 
-  unicode-match-property-value-ecmascript@2.2.0:
-    resolution: {integrity: sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==}
+  unicode-match-property-value-ecmascript@2.2.1:
+    resolution: {integrity: sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==}
     engines: {node: '>=4'}
 
-  unicode-property-aliases-ecmascript@2.1.0:
-    resolution: {integrity: sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==}
+  unicode-property-aliases-ecmascript@2.2.0:
+    resolution: {integrity: sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==}
     engines: {node: '>=4'}
 
   unicorn-magic@0.3.0:
@@ -7974,16 +8899,22 @@ packages:
     resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==}
     engines: {node: '>=8'}
 
-  universalify@2.0.1:
-    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
-    engines: {node: '>= 10.0.0'}
-
   unpipe@1.0.0:
     resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
     engines: {node: '>= 0.8'}
 
-  update-browserslist-db@1.1.3:
-    resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==}
+  unrun@0.2.32:
+    resolution: {integrity: sha512-opd3z6791rf281JdByf0RdRQrpcc7WyzqittqIXodM/5meNWdTwrVxeyzbaCp4/Rgls/um14oUaif1gomO8YGg==}
+    engines: {node: '>=20.19.0'}
+    hasBin: true
+    peerDependencies:
+      synckit: ^0.11.11
+    peerDependenciesMeta:
+      synckit:
+        optional: true
+
+  update-browserslist-db@1.1.4:
+    resolution: {integrity: sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==}
     hasBin: true
     peerDependencies:
       browserslist: '>= 4.21.0'
@@ -8013,18 +8944,35 @@ packages:
 
   uuid@10.0.0:
     resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
+    hasBin: true
+
+  uuid@11.1.0:
+    resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==}
+    hasBin: true
+
+  uuid@14.0.0:
+    resolution: {integrity: sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==}
     hasBin: true
 
   uuid@7.0.3:
     resolution: {integrity: sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   uuid@8.0.0:
     resolution: {integrity: sha512-jOXGuXZAWdsTH7eZLtyXMqUb9EcWMGZNbL9YcGBJl4MH4nrxHmZJhEHvyLFrkxo+28uLb/NYRcStH48fnD0Vzw==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
+    hasBin: true
+
+  uuid@8.3.2:
+    resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   uuid@9.0.1:
     resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   uvu@0.5.6:
@@ -8043,9 +8991,6 @@ packages:
       typescript:
         optional: true
 
-  validate-npm-package-license@3.0.4:
-    resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
-
   validate-npm-package-name@4.0.0:
     resolution: {integrity: sha512-mzR0L8ZDktZjpX4OB46KT+56MAhl4EIazWP/+G/HPGuvfdaqg4YsCdtOm6U9+LOFyYDoh4dpnpxZRB9MQQns5Q==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
@@ -8058,9 +9003,9 @@ packages:
     resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
     engines: {node: '>= 0.8'}
 
-  vite-node@3.2.0:
-    resolution: {integrity: sha512-8Fc5Ko5Y4URIJkmMF/iFP1C0/OJyY+VGVe9Nw6WAdZyw4bTO+eVg9mwxWkQp/y8NnAoQY3o9KAvE1ZdA2v+Vmg==}
-    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+  vite-node@2.1.9:
+    resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
     hasBin: true
 
   vite-tsconfig-paths@4.3.2:
@@ -8071,19 +9016,50 @@ packages:
       vite:
         optional: true
 
-  vite@6.3.5:
-    resolution: {integrity: sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==}
-    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+  vite@5.4.21:
+    resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}
+    engines: {node: ^18.0.0 || >=20.0.0}
     hasBin: true
     peerDependencies:
-      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
-      jiti: '>=1.21.0'
+      '@types/node': ^18.0.0 || >=20.0.0
       less: '*'
       lightningcss: ^1.21.0
       sass: '*'
       sass-embedded: '*'
       stylus: '*'
       sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  vite@7.2.4:
+    resolution: {integrity: sha512-NL8jTlbo0Tn4dUEXEsUg8KeyG/Lkmc4Fnzb8JXN/Ykm9G4HNImjtABMJgkQoVjOBN/j2WAwDTRytdqJbZsah7w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
       terser: ^5.16.0
       tsx: ^4.8.1
       yaml: ^2.4.2
@@ -8111,26 +9087,60 @@ packages:
       yaml:
         optional: true
 
-  vitest@3.2.0:
-    resolution: {integrity: sha512-P7Nvwuli8WBNmeMHHek7PnGW4oAZl9za1fddfRVidZar8wDZRi7hpznLKQePQ8JPLwSBEYDK11g+++j7uFJV8Q==}
-    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+  vitest@2.1.9:
+    resolution: {integrity: sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@types/node': ^18.0.0 || >=20.0.0
+      '@vitest/browser': 2.1.9
+      '@vitest/ui': 2.1.9
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  vitest@4.0.13:
+    resolution: {integrity: sha512-QSD4I0fN6uZQfftryIXuqvqgBxTvJ3ZNkF6RWECd82YGAYAfhcppBLFXzXJHQAAhVFyYEuFTrq6h0hQqjB7jIQ==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
       '@types/debug': ^4.1.12
-      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
-      '@vitest/browser': 3.2.0
-      '@vitest/ui': 3.2.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.0.13
+      '@vitest/browser-preview': 4.0.13
+      '@vitest/browser-webdriverio': 4.0.13
+      '@vitest/ui': 4.0.13
       happy-dom: '*'
       jsdom: '*'
     peerDependenciesMeta:
       '@edge-runtime/vm':
         optional: true
+      '@opentelemetry/api':
+        optional: true
       '@types/debug':
         optional: true
       '@types/node':
         optional: true
-      '@vitest/browser':
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
         optional: true
       '@vitest/ui':
         optional: true
@@ -8152,16 +9162,13 @@ packages:
     resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
     engines: {node: '>= 8'}
 
-  webidl-conversions@4.0.2:
-    resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
-
   webidl-conversions@5.0.0:
     resolution: {integrity: sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==}
     engines: {node: '>=8'}
 
-  webpod@0.0.2:
-    resolution: {integrity: sha512-cSwwQIeg8v4i3p4ajHhwgR7N6VyxAf+KYSSsY6Pd3aETE+xEU4vbitz7qQkB0I321xnhDdgtxuiSfk5r/FVtjg==}
-    hasBin: true
+  webidl-conversions@7.0.0:
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
 
   well-known-symbols@2.0.0:
     resolution: {integrity: sha512-ZMjC3ho+KXo0BfJb7JgtQ5IBuvnShdlACNkKkdsqBmYw3bPAaJfPeYUo6tLUaT5tG/Gkh7xkpBhKRQ9e7pyg9Q==}
@@ -8174,20 +9181,9 @@ packages:
     resolution: {integrity: sha512-HoKuzZrUlgpz35YO27XgD28uh/WJH4B0+3ttFqRo//lmq+9T/mIOJ6kqmINI9HpUpz1imRC/nR/lxKpJiv0uig==}
     engines: {node: '>=10'}
 
-  whatwg-url@7.1.0:
-    resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
-
-  which-boxed-primitive@1.1.1:
-    resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==}
-    engines: {node: '>= 0.4'}
-
-  which-builtin-type@1.2.1:
-    resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==}
-    engines: {node: '>= 0.4'}
-
-  which-collection@1.0.2:
-    resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
-    engines: {node: '>= 0.4'}
+  whatwg-url@14.2.0:
+    resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
+    engines: {node: '>=18'}
 
   which-typed-array@1.1.19:
     resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
@@ -8198,11 +9194,6 @@ packages:
     engines: {node: '>= 8'}
     hasBin: true
 
-  which@3.0.1:
-    resolution: {integrity: sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==}
-    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
-    hasBin: true
-
   which@4.0.0:
     resolution: {integrity: sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==}
     engines: {node: ^16.13.0 || >=18.0.0}
@@ -8234,6 +9225,10 @@ packages:
     resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
     engines: {node: '>=12'}
 
+  wrap-ansi@9.0.2:
+    resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==}
+    engines: {node: '>=18'}
+
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
@@ -8280,8 +9275,20 @@ packages:
       utf-8-validate:
         optional: true
 
-  ws@8.18.2:
-    resolution: {integrity: sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==}
+  ws@8.17.1:
+    resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  ws@8.18.3:
+    resolution: {integrity: sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -8292,6 +9299,10 @@ packages:
       utf-8-validate:
         optional: true
 
+  wsl-utils@0.1.0:
+    resolution: {integrity: sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==}
+    engines: {node: '>=18'}
+
   xcode@3.0.1:
     resolution: {integrity: sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA==}
     engines: {node: '>=10.0.0'}
@@ -8312,6 +9323,10 @@ packages:
     resolution: {integrity: sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==}
     engines: {node: '>=8.0'}
 
+  xmlhttprequest-ssl@2.1.2:
+    resolution: {integrity: sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ==}
+    engines: {node: '>=0.4.0'}
+
   xtend@4.0.2:
     resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
     engines: {node: '>=0.4'}
@@ -8330,8 +9345,13 @@ packages:
     resolution: {integrity: sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==}
     engines: {node: '>=18'}
 
-  yaml@2.8.0:
-    resolution: {integrity: sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ==}
+  yaml@2.8.1:
+    resolution: {integrity: sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==}
+    engines: {node: '>= 14.6'}
+    hasBin: true
+
+  yaml@2.9.0:
+    resolution: {integrity: sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==}
     engines: {node: '>= 14.6'}
     hasBin: true
 
@@ -8359,8 +9379,8 @@ packages:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
 
-  yocto-queue@1.2.1:
-    resolution: {integrity: sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg==}
+  yocto-queue@1.2.2:
+    resolution: {integrity: sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==}
     engines: {node: '>=12.20'}
 
   zod-to-json-schema@3.24.3:
@@ -8368,61 +9388,48 @@ packages:
     peerDependencies:
       zod: ^3.24.1
 
+  zod-to-json-schema@3.25.0:
+    resolution: {integrity: sha512-HvWtU2UG41LALjajJrML6uQejQhNJx+JBO9IflpSja4R03iNWfKXrj6W2h7ljuLyc1nKS+9yDyL/9tD1U/yBnQ==}
+    peerDependencies:
+      zod: ^3.25 || ^4
+
+  zod-to-json-schema@3.25.2:
+    resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==}
+    peerDependencies:
+      zod: ^3.25.28 || ^4
+
   zod@3.24.2:
     resolution: {integrity: sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==}
 
   zod@3.25.1:
     resolution: {integrity: sha512-bkxUGQiqWDTXHSgqtevYDri5ee2GPC9szPct4pqpzLEpswgDQmuseDz81ZF0AnNu1xsmnBVmbtv/t/WeUIHlpg==}
 
-  zx@7.2.3:
-    resolution: {integrity: sha512-QODu38nLlYXg/B/Gw7ZKiZrvPkEsjPN3LQ5JFXM7h0JvwhEdPNNl+4Ao1y4+o3CLNiDUNcwzQYZ4/Ko7kKzCMA==}
-    engines: {node: '>= 16.0.0'}
-    hasBin: true
+  zod@3.25.76:
+    resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+  zod@4.3.4:
+    resolution: {integrity: sha512-Zw/uYiiyF6pUT1qmKbZziChgNPRu+ZRneAsMUDU6IwmXdWt5JwcUfy2bvLOCUtz5UniaN/Zx5aFttZYbYc7O/A==}
 
-  zx@8.5.4:
-    resolution: {integrity: sha512-44oKea9Sa8ZnOkTnS6fRJpg3quzgnbB43nLrVfYnqE86J4sxgZMUDLezzKET/FdOAVkF4X+Alm9Bume+W+RW9Q==}
+  zx@8.8.5:
+    resolution: {integrity: sha512-SNgDF5L0gfN7FwVOdEFguY3orU5AkfFZm9B5YSHog/UDHv+lvmd82ZAsOenOkQixigwH2+yyH198AwNdKhj+RA==}
     engines: {node: '>= 12.17.0'}
     hasBin: true
 
 snapshots:
 
-  '@0no-co/graphql.web@1.1.2': {}
-
-  '@ampproject/remapping@2.3.0':
-    dependencies:
-      '@jridgewell/gen-mapping': 0.3.8
-      '@jridgewell/trace-mapping': 0.3.25
+  '@0no-co/graphql.web@1.2.0': {}
 
   '@andrewbranch/untar.js@1.0.3': {}
 
-  '@arethetypeswrong/cli@0.15.3':
-    dependencies:
-      '@arethetypeswrong/core': 0.15.1
-      chalk: 4.1.2
-      cli-table3: 0.6.5
-      commander: 10.0.1
-      marked: 9.1.6
-      marked-terminal: 6.2.0(marked@9.1.6)
-      semver: 7.7.2
-
   '@arethetypeswrong/cli@0.16.4':
     dependencies:
       '@arethetypeswrong/core': 0.16.4
       chalk: 4.1.2
       cli-table3: 0.6.5
       commander: 10.0.1
-      marked: 9.1.6
-      marked-terminal: 7.3.0(marked@9.1.6)
-      semver: 7.7.2
-
-  '@arethetypeswrong/core@0.15.1':
-    dependencies:
-      '@andrewbranch/untar.js': 1.0.3
-      fflate: 0.8.2
-      semver: 7.7.2
-      ts-expose-internals-conditionally: 1.0.0-empty.0
-      typescript: 5.3.3
-      validate-npm-package-name: 5.0.1
+      marked: 9.1.2
+      marked-terminal: 7.1.0(marked@9.1.2)
+      semver: 7.7.3
 
   '@arethetypeswrong/core@0.16.4':
     dependencies:
@@ -8430,53 +9437,66 @@ snapshots:
       cjs-module-lexer: 1.4.3
       fflate: 0.8.2
       lru-cache: 10.4.3
-      semver: 7.7.2
+      semver: 7.7.4
       typescript: 5.6.1-rc
       validate-npm-package-name: 5.0.1
 
-  '@ark/attest@0.45.11(typescript@5.6.3)':
+  '@ark/attest@0.56.0(typescript@5.9.3)':
     dependencies:
-      '@ark/fs': 0.45.10
-      '@ark/util': 0.45.10
-      '@prettier/sync': 0.5.5(prettier@3.5.3)
+      '@ark/fs': 0.56.0
+      '@ark/util': 0.56.0
+      '@prettier/sync': 0.6.1(prettier@3.6.2)
       '@typescript/analyze-trace': 0.10.1
-      '@typescript/vfs': 1.6.1(typescript@5.6.3)
-      arktype: 2.1.19
-      prettier: 3.5.3
-      typescript: 5.6.3
+      '@typescript/vfs': 1.6.1(typescript@5.9.3)
+      arktype: 2.1.28
+      prettier: 3.6.2
+      typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@ark/fs@0.45.10': {}
+  '@ark/fs@0.46.0': {}
 
-  '@ark/schema@0.45.9':
-    dependencies:
-      '@ark/util': 0.45.9
+  '@ark/fs@0.56.0': {}
 
   '@ark/schema@0.46.0':
     dependencies:
       '@ark/util': 0.46.0
 
-  '@ark/util@0.45.10': {}
-
-  '@ark/util@0.45.9': {}
+  '@ark/schema@0.56.0':
+    dependencies:
+      '@ark/util': 0.56.0
 
   '@ark/util@0.46.0': {}
 
+  '@ark/util@0.56.0': {}
+
+  '@arktype/attest@0.46.0(typescript@5.9.3)':
+    dependencies:
+      '@ark/fs': 0.46.0
+      '@ark/util': 0.46.0
+      '@prettier/sync': 0.5.5(prettier@3.5.3)
+      '@typescript/analyze-trace': 0.10.1
+      '@typescript/vfs': 1.6.1(typescript@5.9.3)
+      arktype: 2.1.20
+      prettier: 3.5.3
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   '@aws-crypto/sha256-browser@5.2.0':
     dependencies:
       '@aws-crypto/sha256-js': 5.2.0
       '@aws-crypto/supports-web-crypto': 5.2.0
       '@aws-crypto/util': 5.2.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-locate-window': 3.804.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-locate-window': 3.893.0
       '@smithy/util-utf8': 2.3.0
       tslib: 2.8.1
 
   '@aws-crypto/sha256-js@5.2.0':
     dependencies:
       '@aws-crypto/util': 5.2.0
-      '@aws-sdk/types': 3.821.0
+      '@aws-sdk/types': 3.936.0
       tslib: 2.8.1
 
   '@aws-crypto/supports-web-crypto@5.2.0':
@@ -8485,402 +9505,574 @@ snapshots:
 
   '@aws-crypto/util@5.2.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
+      '@aws-sdk/types': 3.936.0
       '@smithy/util-utf8': 2.3.0
       tslib: 2.8.1
 
-  '@aws-sdk/client-cognito-identity@3.821.0':
+  '@aws-sdk/client-cognito-identity@3.940.0':
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/credential-provider-node': 3.821.0
-      '@aws-sdk/middleware-host-header': 3.821.0
-      '@aws-sdk/middleware-logger': 3.821.0
-      '@aws-sdk/middleware-recursion-detection': 3.821.0
-      '@aws-sdk/middleware-user-agent': 3.821.0
-      '@aws-sdk/region-config-resolver': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-endpoints': 3.821.0
-      '@aws-sdk/util-user-agent-browser': 3.821.0
-      '@aws-sdk/util-user-agent-node': 3.821.0
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/core': 3.5.1
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/hash-node': 4.0.4
-      '@smithy/invalid-dependency': 4.0.4
-      '@smithy/middleware-content-length': 4.0.4
-      '@smithy/middleware-endpoint': 4.1.9
-      '@smithy/middleware-retry': 4.1.10
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/middleware-stack': 4.0.4
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-body-length-browser': 4.0.0
-      '@smithy/util-body-length-node': 4.0.0
-      '@smithy/util-defaults-mode-browser': 4.0.17
-      '@smithy/util-defaults-mode-node': 4.0.17
-      '@smithy/util-endpoints': 3.0.6
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-retry': 4.0.5
-      '@smithy/util-utf8': 4.0.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/credential-provider-node': 3.940.0
+      '@aws-sdk/middleware-host-header': 3.936.0
+      '@aws-sdk/middleware-logger': 3.936.0
+      '@aws-sdk/middleware-recursion-detection': 3.936.0
+      '@aws-sdk/middleware-user-agent': 3.940.0
+      '@aws-sdk/region-config-resolver': 3.936.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-endpoints': 3.936.0
+      '@aws-sdk/util-user-agent-browser': 3.936.0
+      '@aws-sdk/util-user-agent-node': 3.940.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/core': 3.18.5
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/hash-node': 4.2.5
+      '@smithy/invalid-dependency': 4.2.5
+      '@smithy/middleware-content-length': 4.2.5
+      '@smithy/middleware-endpoint': 4.3.12
+      '@smithy/middleware-retry': 4.4.12
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/middleware-stack': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-body-length-browser': 4.2.0
+      '@smithy/util-body-length-node': 4.2.1
+      '@smithy/util-defaults-mode-browser': 4.3.11
+      '@smithy/util-defaults-mode-node': 4.2.14
+      '@smithy/util-endpoints': 3.2.5
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-retry': 4.2.5
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/client-rds-data@3.821.0':
+  '@aws-sdk/client-rds-data@3.940.0':
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/credential-provider-node': 3.821.0
-      '@aws-sdk/middleware-host-header': 3.821.0
-      '@aws-sdk/middleware-logger': 3.821.0
-      '@aws-sdk/middleware-recursion-detection': 3.821.0
-      '@aws-sdk/middleware-user-agent': 3.821.0
-      '@aws-sdk/region-config-resolver': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-endpoints': 3.821.0
-      '@aws-sdk/util-user-agent-browser': 3.821.0
-      '@aws-sdk/util-user-agent-node': 3.821.0
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/core': 3.5.1
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/hash-node': 4.0.4
-      '@smithy/invalid-dependency': 4.0.4
-      '@smithy/middleware-content-length': 4.0.4
-      '@smithy/middleware-endpoint': 4.1.9
-      '@smithy/middleware-retry': 4.1.10
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/middleware-stack': 4.0.4
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-body-length-browser': 4.0.0
-      '@smithy/util-body-length-node': 4.0.0
-      '@smithy/util-defaults-mode-browser': 4.0.17
-      '@smithy/util-defaults-mode-node': 4.0.17
-      '@smithy/util-endpoints': 3.0.6
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-retry': 4.0.5
-      '@smithy/util-utf8': 4.0.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/credential-provider-node': 3.940.0
+      '@aws-sdk/middleware-host-header': 3.936.0
+      '@aws-sdk/middleware-logger': 3.936.0
+      '@aws-sdk/middleware-recursion-detection': 3.936.0
+      '@aws-sdk/middleware-user-agent': 3.940.0
+      '@aws-sdk/region-config-resolver': 3.936.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-endpoints': 3.936.0
+      '@aws-sdk/util-user-agent-browser': 3.936.0
+      '@aws-sdk/util-user-agent-node': 3.940.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/core': 3.18.5
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/hash-node': 4.2.5
+      '@smithy/invalid-dependency': 4.2.5
+      '@smithy/middleware-content-length': 4.2.5
+      '@smithy/middleware-endpoint': 4.3.12
+      '@smithy/middleware-retry': 4.4.12
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/middleware-stack': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-body-length-browser': 4.2.0
+      '@smithy/util-body-length-node': 4.2.1
+      '@smithy/util-defaults-mode-browser': 4.3.11
+      '@smithy/util-defaults-mode-node': 4.2.14
+      '@smithy/util-endpoints': 3.2.5
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-retry': 4.2.5
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/client-sso@3.821.0':
+  '@aws-sdk/client-sso@3.940.0':
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/middleware-host-header': 3.821.0
-      '@aws-sdk/middleware-logger': 3.821.0
-      '@aws-sdk/middleware-recursion-detection': 3.821.0
-      '@aws-sdk/middleware-user-agent': 3.821.0
-      '@aws-sdk/region-config-resolver': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-endpoints': 3.821.0
-      '@aws-sdk/util-user-agent-browser': 3.821.0
-      '@aws-sdk/util-user-agent-node': 3.821.0
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/core': 3.5.1
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/hash-node': 4.0.4
-      '@smithy/invalid-dependency': 4.0.4
-      '@smithy/middleware-content-length': 4.0.4
-      '@smithy/middleware-endpoint': 4.1.9
-      '@smithy/middleware-retry': 4.1.10
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/middleware-stack': 4.0.4
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-body-length-browser': 4.0.0
-      '@smithy/util-body-length-node': 4.0.0
-      '@smithy/util-defaults-mode-browser': 4.0.17
-      '@smithy/util-defaults-mode-node': 4.0.17
-      '@smithy/util-endpoints': 3.0.6
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-retry': 4.0.5
-      '@smithy/util-utf8': 4.0.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/middleware-host-header': 3.936.0
+      '@aws-sdk/middleware-logger': 3.936.0
+      '@aws-sdk/middleware-recursion-detection': 3.936.0
+      '@aws-sdk/middleware-user-agent': 3.940.0
+      '@aws-sdk/region-config-resolver': 3.936.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-endpoints': 3.936.0
+      '@aws-sdk/util-user-agent-browser': 3.936.0
+      '@aws-sdk/util-user-agent-node': 3.940.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/core': 3.18.5
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/hash-node': 4.2.5
+      '@smithy/invalid-dependency': 4.2.5
+      '@smithy/middleware-content-length': 4.2.5
+      '@smithy/middleware-endpoint': 4.3.12
+      '@smithy/middleware-retry': 4.4.12
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/middleware-stack': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-body-length-browser': 4.2.0
+      '@smithy/util-body-length-node': 4.2.1
+      '@smithy/util-defaults-mode-browser': 4.3.11
+      '@smithy/util-defaults-mode-node': 4.2.14
+      '@smithy/util-endpoints': 3.2.5
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-retry': 4.2.5
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/core@3.821.0':
-    dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/core': 3.5.1
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/property-provider': 4.0.4
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/signature-v4': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/util-middleware': 4.0.4
-      fast-xml-parser: 4.4.1
+  '@aws-sdk/core@3.940.0':
+    dependencies:
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/xml-builder': 3.930.0
+      '@smithy/core': 3.18.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/signature-v4': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-cognito-identity@3.821.0':
+  '@aws-sdk/credential-provider-cognito-identity@3.940.0':
     dependencies:
-      '@aws-sdk/client-cognito-identity': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/client-cognito-identity': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-env@3.821.0':
+  '@aws-sdk/credential-provider-env@3.940.0':
     dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-http@3.821.0':
-    dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/property-provider': 4.0.4
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/util-stream': 4.2.2
+  '@aws-sdk/credential-provider-http@3.940.0':
+    dependencies:
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/util-stream': 4.5.6
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-ini@3.821.0':
-    dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/credential-provider-env': 3.821.0
-      '@aws-sdk/credential-provider-http': 3.821.0
-      '@aws-sdk/credential-provider-process': 3.821.0
-      '@aws-sdk/credential-provider-sso': 3.821.0
-      '@aws-sdk/credential-provider-web-identity': 3.821.0
-      '@aws-sdk/nested-clients': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/credential-provider-imds': 4.0.6
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+  '@aws-sdk/credential-provider-ini@3.940.0':
+    dependencies:
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/credential-provider-env': 3.940.0
+      '@aws-sdk/credential-provider-http': 3.940.0
+      '@aws-sdk/credential-provider-login': 3.940.0
+      '@aws-sdk/credential-provider-process': 3.940.0
+      '@aws-sdk/credential-provider-sso': 3.940.0
+      '@aws-sdk/credential-provider-web-identity': 3.940.0
+      '@aws-sdk/nested-clients': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/credential-provider-imds': 4.2.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - aws-crt
+
+  '@aws-sdk/credential-provider-login@3.940.0':
+    dependencies:
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/nested-clients': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-node@3.821.0':
-    dependencies:
-      '@aws-sdk/credential-provider-env': 3.821.0
-      '@aws-sdk/credential-provider-http': 3.821.0
-      '@aws-sdk/credential-provider-ini': 3.821.0
-      '@aws-sdk/credential-provider-process': 3.821.0
-      '@aws-sdk/credential-provider-sso': 3.821.0
-      '@aws-sdk/credential-provider-web-identity': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/credential-provider-imds': 4.0.6
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+  '@aws-sdk/credential-provider-node@3.940.0':
+    dependencies:
+      '@aws-sdk/credential-provider-env': 3.940.0
+      '@aws-sdk/credential-provider-http': 3.940.0
+      '@aws-sdk/credential-provider-ini': 3.940.0
+      '@aws-sdk/credential-provider-process': 3.940.0
+      '@aws-sdk/credential-provider-sso': 3.940.0
+      '@aws-sdk/credential-provider-web-identity': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/credential-provider-imds': 4.2.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-process@3.821.0':
+  '@aws-sdk/credential-provider-process@3.940.0':
     dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-sso@3.821.0':
+  '@aws-sdk/credential-provider-sso@3.940.0':
     dependencies:
-      '@aws-sdk/client-sso': 3.821.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/token-providers': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/client-sso': 3.940.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/token-providers': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-web-identity@3.821.0':
+  '@aws-sdk/credential-provider-web-identity@3.940.0':
     dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/nested-clients': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/nested-clients': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-providers@3.821.0':
-    dependencies:
-      '@aws-sdk/client-cognito-identity': 3.821.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/credential-provider-cognito-identity': 3.821.0
-      '@aws-sdk/credential-provider-env': 3.821.0
-      '@aws-sdk/credential-provider-http': 3.821.0
-      '@aws-sdk/credential-provider-ini': 3.821.0
-      '@aws-sdk/credential-provider-node': 3.821.0
-      '@aws-sdk/credential-provider-process': 3.821.0
-      '@aws-sdk/credential-provider-sso': 3.821.0
-      '@aws-sdk/credential-provider-web-identity': 3.821.0
-      '@aws-sdk/nested-clients': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/core': 3.5.1
-      '@smithy/credential-provider-imds': 4.0.6
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/property-provider': 4.0.4
-      '@smithy/types': 4.3.1
+  '@aws-sdk/credential-providers@3.940.0':
+    dependencies:
+      '@aws-sdk/client-cognito-identity': 3.940.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/credential-provider-cognito-identity': 3.940.0
+      '@aws-sdk/credential-provider-env': 3.940.0
+      '@aws-sdk/credential-provider-http': 3.940.0
+      '@aws-sdk/credential-provider-ini': 3.940.0
+      '@aws-sdk/credential-provider-login': 3.940.0
+      '@aws-sdk/credential-provider-node': 3.940.0
+      '@aws-sdk/credential-provider-process': 3.940.0
+      '@aws-sdk/credential-provider-sso': 3.940.0
+      '@aws-sdk/credential-provider-web-identity': 3.940.0
+      '@aws-sdk/nested-clients': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/core': 3.18.5
+      '@smithy/credential-provider-imds': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/middleware-host-header@3.821.0':
+  '@aws-sdk/middleware-host-header@3.936.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
+      '@aws-sdk/types': 3.936.0
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-logger@3.821.0':
+  '@aws-sdk/middleware-logger@3.936.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/types': 4.3.1
+      '@aws-sdk/types': 3.936.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-recursion-detection@3.821.0':
+  '@aws-sdk/middleware-recursion-detection@3.936.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
+      '@aws-sdk/types': 3.936.0
+      '@aws/lambda-invoke-store': 0.2.1
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-user-agent@3.821.0':
+  '@aws-sdk/middleware-user-agent@3.940.0':
     dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-endpoints': 3.821.0
-      '@smithy/core': 3.5.1
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-endpoints': 3.936.0
+      '@smithy/core': 3.18.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/nested-clients@3.821.0':
+  '@aws-sdk/nested-clients@3.940.0':
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/middleware-host-header': 3.821.0
-      '@aws-sdk/middleware-logger': 3.821.0
-      '@aws-sdk/middleware-recursion-detection': 3.821.0
-      '@aws-sdk/middleware-user-agent': 3.821.0
-      '@aws-sdk/region-config-resolver': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@aws-sdk/util-endpoints': 3.821.0
-      '@aws-sdk/util-user-agent-browser': 3.821.0
-      '@aws-sdk/util-user-agent-node': 3.821.0
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/core': 3.5.1
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/hash-node': 4.0.4
-      '@smithy/invalid-dependency': 4.0.4
-      '@smithy/middleware-content-length': 4.0.4
-      '@smithy/middleware-endpoint': 4.1.9
-      '@smithy/middleware-retry': 4.1.10
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/middleware-stack': 4.0.4
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-body-length-browser': 4.0.0
-      '@smithy/util-body-length-node': 4.0.0
-      '@smithy/util-defaults-mode-browser': 4.0.17
-      '@smithy/util-defaults-mode-node': 4.0.17
-      '@smithy/util-endpoints': 3.0.6
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-retry': 4.0.5
-      '@smithy/util-utf8': 4.0.0
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/middleware-host-header': 3.936.0
+      '@aws-sdk/middleware-logger': 3.936.0
+      '@aws-sdk/middleware-recursion-detection': 3.936.0
+      '@aws-sdk/middleware-user-agent': 3.940.0
+      '@aws-sdk/region-config-resolver': 3.936.0
+      '@aws-sdk/types': 3.936.0
+      '@aws-sdk/util-endpoints': 3.936.0
+      '@aws-sdk/util-user-agent-browser': 3.936.0
+      '@aws-sdk/util-user-agent-node': 3.940.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/core': 3.18.5
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/hash-node': 4.2.5
+      '@smithy/invalid-dependency': 4.2.5
+      '@smithy/middleware-content-length': 4.2.5
+      '@smithy/middleware-endpoint': 4.3.12
+      '@smithy/middleware-retry': 4.4.12
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/middleware-stack': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-body-length-browser': 4.2.0
+      '@smithy/util-body-length-node': 4.2.1
+      '@smithy/util-defaults-mode-browser': 4.3.11
+      '@smithy/util-defaults-mode-node': 4.2.14
+      '@smithy/util-endpoints': 3.2.5
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-retry': 4.2.5
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/region-config-resolver@3.821.0':
+  '@aws-sdk/region-config-resolver@3.936.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/types': 4.3.1
-      '@smithy/util-config-provider': 4.0.0
-      '@smithy/util-middleware': 4.0.4
+      '@aws-sdk/types': 3.936.0
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@aws-sdk/token-providers@3.821.0':
+  '@aws-sdk/token-providers@3.940.0':
     dependencies:
-      '@aws-sdk/core': 3.821.0
-      '@aws-sdk/nested-clients': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+      '@aws-sdk/core': 3.940.0
+      '@aws-sdk/nested-clients': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/types@3.821.0':
+  '@aws-sdk/types@3.936.0':
+    dependencies:
+      '@smithy/types': 4.9.0
+      tslib: 2.8.1
+
+  '@aws-sdk/util-endpoints@3.936.0':
+    dependencies:
+      '@aws-sdk/types': 3.936.0
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-endpoints': 3.2.5
+      tslib: 2.8.1
+
+  '@aws-sdk/util-locate-window@3.893.0':
+    dependencies:
+      tslib: 2.8.1
+
+  '@aws-sdk/util-user-agent-browser@3.936.0':
+    dependencies:
+      '@aws-sdk/types': 3.936.0
+      '@smithy/types': 4.9.0
+      bowser: 2.13.0
+      tslib: 2.8.1
+
+  '@aws-sdk/util-user-agent-node@3.940.0':
+    dependencies:
+      '@aws-sdk/middleware-user-agent': 3.940.0
+      '@aws-sdk/types': 3.936.0
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/types': 4.9.0
+      tslib: 2.8.1
+
+  '@aws-sdk/xml-builder@3.930.0':
+    dependencies:
+      '@smithy/types': 4.9.0
+      fast-xml-parser: 5.2.5
+      tslib: 2.8.1
+
+  '@aws/lambda-invoke-store@0.2.1': {}
+
+  '@azure-rest/core-client@2.5.1':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-rest-pipeline': 1.22.2
+      '@azure/core-tracing': 1.3.1
+      '@typespec/ts-http-runtime': 0.3.2
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/abort-controller@2.1.2':
+    dependencies:
+      tslib: 2.8.1
+
+  '@azure/core-auth@1.10.1':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-util': 1.13.1
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-client@1.10.1':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-rest-pipeline': 1.22.2
+      '@azure/core-tracing': 1.3.1
+      '@azure/core-util': 1.13.1
+      '@azure/logger': 1.3.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-http-compat@2.3.1':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-client': 1.10.1
+      '@azure/core-rest-pipeline': 1.22.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-lro@2.7.2':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-util': 1.13.1
+      '@azure/logger': 1.3.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/core-paging@1.6.2':
+    dependencies:
+      tslib: 2.8.1
+
+  '@azure/core-rest-pipeline@1.22.2':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-tracing': 1.3.1
+      '@azure/core-util': 1.13.1
+      '@azure/logger': 1.3.0
+      '@typespec/ts-http-runtime': 0.3.2
       tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
 
-  '@aws-sdk/util-endpoints@3.821.0':
+  '@azure/core-tracing@1.3.1':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/types': 4.3.1
-      '@smithy/util-endpoints': 3.0.6
       tslib: 2.8.1
 
-  '@aws-sdk/util-locate-window@3.804.0':
+  '@azure/core-util@1.13.1':
     dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@typespec/ts-http-runtime': 0.3.2
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/identity@4.13.0':
+    dependencies:
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-client': 1.10.1
+      '@azure/core-rest-pipeline': 1.22.2
+      '@azure/core-tracing': 1.3.1
+      '@azure/core-util': 1.13.1
+      '@azure/logger': 1.3.0
+      '@azure/msal-browser': 4.26.2
+      '@azure/msal-node': 3.8.3
+      open: 10.2.0
       tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
 
-  '@aws-sdk/util-user-agent-browser@3.821.0':
+  '@azure/keyvault-common@2.0.0':
     dependencies:
-      '@aws-sdk/types': 3.821.0
-      '@smithy/types': 4.3.1
-      bowser: 2.11.0
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-client': 1.10.1
+      '@azure/core-rest-pipeline': 1.22.2
+      '@azure/core-tracing': 1.3.1
+      '@azure/core-util': 1.13.1
+      '@azure/logger': 1.3.0
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/keyvault-keys@4.10.0':
+    dependencies:
+      '@azure-rest/core-client': 2.5.1
+      '@azure/abort-controller': 2.1.2
+      '@azure/core-auth': 1.10.1
+      '@azure/core-http-compat': 2.3.1
+      '@azure/core-lro': 2.7.2
+      '@azure/core-paging': 1.6.2
+      '@azure/core-rest-pipeline': 1.22.2
+      '@azure/core-tracing': 1.3.1
+      '@azure/core-util': 1.13.1
+      '@azure/keyvault-common': 2.0.0
+      '@azure/logger': 1.3.0
       tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
 
-  '@aws-sdk/util-user-agent-node@3.821.0':
+  '@azure/logger@1.3.0':
     dependencies:
-      '@aws-sdk/middleware-user-agent': 3.821.0
-      '@aws-sdk/types': 3.821.0
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/types': 4.3.1
+      '@typespec/ts-http-runtime': 0.3.2
       tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@azure/msal-browser@4.26.2':
+    dependencies:
+      '@azure/msal-common': 15.13.2
+
+  '@azure/msal-common@15.13.2': {}
+
+  '@azure/msal-node@3.8.3':
+    dependencies:
+      '@azure/msal-common': 15.13.2
+      jsonwebtoken: 9.0.2
+      uuid: 8.3.2
 
   '@babel/code-frame@7.10.4':
     dependencies:
@@ -8888,626 +10080,845 @@ snapshots:
 
   '@babel/code-frame@7.27.1':
     dependencies:
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/compat-data@7.27.3': {}
+  '@babel/compat-data@7.28.5': {}
 
-  '@babel/core@7.27.4':
+  '@babel/core@7.28.5':
     dependencies:
-      '@ampproject/remapping': 2.3.0
       '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.27.3
+      '@babel/generator': 7.28.5
       '@babel/helper-compilation-targets': 7.27.2
-      '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4)
-      '@babel/helpers': 7.27.4
-      '@babel/parser': 7.27.4
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.5)
+      '@babel/helpers': 7.28.4
+      '@babel/parser': 7.28.5
       '@babel/template': 7.27.2
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
+      '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
-      debug: 4.4.1
+      debug: 4.4.3
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/generator@7.27.3':
+  '@babel/generator@7.28.5':
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
+  '@babel/generator@8.0.0-rc.2':
     dependencies:
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
-      '@jridgewell/gen-mapping': 0.3.8
-      '@jridgewell/trace-mapping': 0.3.25
+      '@babel/parser': 8.0.0-rc.2
+      '@babel/types': 8.0.0-rc.2
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      '@types/jsesc': 2.5.1
       jsesc: 3.1.0
 
   '@babel/helper-annotate-as-pure@7.27.3':
     dependencies:
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
 
   '@babel/helper-compilation-targets@7.27.2':
     dependencies:
-      '@babel/compat-data': 7.27.3
+      '@babel/compat-data': 7.28.5
       '@babel/helper-validator-option': 7.27.1
-      browserslist: 4.25.0
+      browserslist: 4.28.0
       lru-cache: 5.1.1
       semver: 6.3.1
 
-  '@babel/helper-create-class-features-plugin@7.27.1(@babel/core@7.27.4)':
+  '@babel/helper-create-class-features-plugin@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-member-expression-to-functions': 7.27.1
+      '@babel/helper-member-expression-to-functions': 7.28.5
       '@babel/helper-optimise-call-expression': 7.27.1
-      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.27.4)
+      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.5)
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
-      '@babel/traverse': 7.27.4
+      '@babel/traverse': 7.28.5
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-create-regexp-features-plugin@7.27.1(@babel/core@7.27.4)':
+  '@babel/helper-create-regexp-features-plugin@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      regexpu-core: 6.2.0
+      regexpu-core: 6.4.0
       semver: 6.3.1
 
-  '@babel/helper-define-polyfill-provider@0.6.4(@babel/core@7.27.4)':
+  '@babel/helper-define-polyfill-provider@0.6.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-compilation-targets': 7.27.2
       '@babel/helper-plugin-utils': 7.27.1
-      debug: 4.4.1
+      debug: 4.4.3
       lodash.debounce: 4.0.8
-      resolve: 1.22.10
+      resolve: 1.22.11
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-member-expression-to-functions@7.27.1':
+  '@babel/helper-globals@7.28.0': {}
+
+  '@babel/helper-member-expression-to-functions@7.28.5':
     dependencies:
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-module-imports@7.27.1':
     dependencies:
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.27.3(@babel/core@7.27.4)':
+  '@babel/helper-module-transforms@7.28.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-module-imports': 7.27.1
-      '@babel/helper-validator-identifier': 7.27.1
-      '@babel/traverse': 7.27.4
+      '@babel/helper-validator-identifier': 7.28.5
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-optimise-call-expression@7.27.1':
     dependencies:
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
 
   '@babel/helper-plugin-utils@7.27.1': {}
 
-  '@babel/helper-remap-async-to-generator@7.27.1(@babel/core@7.27.4)':
+  '@babel/helper-remap-async-to-generator@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-wrap-function': 7.27.1
-      '@babel/traverse': 7.27.4
+      '@babel/helper-wrap-function': 7.28.3
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-replace-supers@7.27.1(@babel/core@7.27.4)':
+  '@babel/helper-replace-supers@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-member-expression-to-functions': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/helper-member-expression-to-functions': 7.28.5
       '@babel/helper-optimise-call-expression': 7.27.1
-      '@babel/traverse': 7.27.4
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-skip-transparent-expression-wrappers@7.27.1':
     dependencies:
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-string-parser@7.27.1': {}
 
-  '@babel/helper-validator-identifier@7.27.1': {}
+  '@babel/helper-string-parser@8.0.0-rc.2': {}
+
+  '@babel/helper-validator-identifier@7.28.5': {}
+
+  '@babel/helper-validator-identifier@8.0.0-rc.2': {}
 
   '@babel/helper-validator-option@7.27.1': {}
 
-  '@babel/helper-wrap-function@7.27.1':
+  '@babel/helper-wrap-function@7.28.3':
     dependencies:
       '@babel/template': 7.27.2
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helpers@7.27.4':
+  '@babel/helpers@7.28.4':
     dependencies:
       '@babel/template': 7.27.2
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
 
   '@babel/highlight@7.25.9':
     dependencies:
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
       chalk: 2.4.2
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/parser@7.27.4':
+  '@babel/parser@7.28.5':
+    dependencies:
+      '@babel/types': 7.28.5
+
+  '@babel/parser@8.0.0-rc.2':
     dependencies:
-      '@babel/types': 7.27.3
+      '@babel/types': 8.0.0-rc.2
 
-  '@babel/plugin-proposal-decorators@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-proposal-decorators@7.28.0(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/plugin-syntax-decorators': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-syntax-decorators': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-proposal-export-default-from@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-proposal-export-default-from@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-decorators@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-decorators@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-export-default-from@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-export-default-from@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-flow@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-flow@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-import-attributes@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-import-attributes@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-jsx@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-jsx@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-syntax-typescript@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-syntax-typescript@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-arrow-functions@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-arrow-functions@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-async-generator-functions@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-async-generator-functions@7.28.0(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.27.4)
-      '@babel/traverse': 7.27.4
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-async-to-generator@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-async-to-generator@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-module-imports': 7.27.1
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.27.4)
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-block-scoping@7.27.3(@babel/core@7.27.4)':
+  '@babel/plugin-transform-block-scoping@7.28.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/helper-plugin-utils': 7.27.1
+
+  '@babel/plugin-transform-class-properties@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/plugin-transform-class-properties@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-class-static-block@7.28.3(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-classes@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-classes@7.28.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
       '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-globals': 7.28.0
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.27.4)
-      '@babel/traverse': 7.27.4
-      globals: 11.12.0
+      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-computed-properties@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-computed-properties@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/template': 7.27.2
 
-  '@babel/plugin-transform-destructuring@7.27.3(@babel/core@7.27.4)':
+  '@babel/plugin-transform-destructuring@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
+      '@babel/traverse': 7.28.5
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/plugin-transform-export-namespace-from@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-export-namespace-from@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-flow-strip-types@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-flow-strip-types@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/plugin-syntax-flow': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-syntax-flow': 7.27.1(@babel/core@7.28.5)
 
-  '@babel/plugin-transform-for-of@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-for-of@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-function-name@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-function-name@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-compilation-targets': 7.27.2
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/traverse': 7.27.4
+      '@babel/traverse': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-literals@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-literals@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-logical-assignment-operators@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-logical-assignment-operators@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-modules-commonjs@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-modules-commonjs@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-module-transforms': 7.27.3(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-named-capturing-groups-regex@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-named-capturing-groups-regex@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-create-regexp-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-nullish-coalescing-operator@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-nullish-coalescing-operator@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-numeric-separator@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-numeric-separator@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-object-rest-spread@7.27.3(@babel/core@7.27.4)':
+  '@babel/plugin-transform-object-rest-spread@7.28.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-compilation-targets': 7.27.2
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/plugin-transform-destructuring': 7.27.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-parameters': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-transform-destructuring': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/traverse': 7.28.5
+    transitivePeerDependencies:
+      - supports-color
 
-  '@babel/plugin-transform-optional-catch-binding@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-optional-catch-binding@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-optional-chaining@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-optional-chaining@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-parameters@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-parameters@7.27.7(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-private-methods@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-private-methods@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-private-property-in-object@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-private-property-in-object@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-react-display-name@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-display-name@7.28.0(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-react-jsx-development@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-jsx-development@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-react-jsx-source@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-jsx-source@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-react-jsx@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-jsx@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
       '@babel/helper-module-imports': 7.27.1
       '@babel/helper-plugin-utils': 7.27.1
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.27.4)
-      '@babel/types': 7.27.3
+      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.5)
+      '@babel/types': 7.28.5
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-react-pure-annotations@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-react-pure-annotations@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-regenerator@7.27.4(@babel/core@7.27.4)':
+  '@babel/plugin-transform-regenerator@7.28.4(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-runtime@7.27.4(@babel/core@7.27.4)':
+  '@babel/plugin-transform-runtime@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-module-imports': 7.27.1
       '@babel/helper-plugin-utils': 7.27.1
-      babel-plugin-polyfill-corejs2: 0.4.13(@babel/core@7.27.4)
-      babel-plugin-polyfill-corejs3: 0.11.1(@babel/core@7.27.4)
-      babel-plugin-polyfill-regenerator: 0.6.4(@babel/core@7.27.4)
+      babel-plugin-polyfill-corejs2: 0.4.14(@babel/core@7.28.5)
+      babel-plugin-polyfill-corejs3: 0.13.0(@babel/core@7.28.5)
+      babel-plugin-polyfill-regenerator: 0.6.5(@babel/core@7.28.5)
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-shorthand-properties@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-shorthand-properties@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-spread@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-spread@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-sticky-regex@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-sticky-regex@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/plugin-transform-typescript@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-typescript@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-annotate-as-pure': 7.27.3
-      '@babel/helper-create-class-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/helper-create-class-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
-      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/plugin-transform-unicode-regex@7.27.1(@babel/core@7.27.4)':
+  '@babel/plugin-transform-unicode-regex@7.27.1(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-create-regexp-features-plugin': 7.28.5(@babel/core@7.28.5)
       '@babel/helper-plugin-utils': 7.27.1
 
-  '@babel/preset-react@7.27.1(@babel/core@7.27.4)':
+  '@babel/preset-react@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-validator-option': 7.27.1
-      '@babel/plugin-transform-react-display-name': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-jsx-development': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-pure-annotations': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-transform-react-display-name': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-development': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-pure-annotations': 7.27.1(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/preset-typescript@7.27.1(@babel/core@7.27.4)':
+  '@babel/preset-typescript@7.28.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@babel/helper-plugin-utils': 7.27.1
       '@babel/helper-validator-option': 7.27.1
-      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-typescript': 7.27.1(@babel/core@7.27.4)
+      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-typescript': 7.28.5(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/runtime@7.27.4': {}
+  '@babel/runtime@7.28.4': {}
 
   '@babel/template@7.27.2':
     dependencies:
       '@babel/code-frame': 7.27.1
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
 
-  '@babel/traverse@7.27.4':
+  '@babel/traverse@7.28.5':
     dependencies:
       '@babel/code-frame': 7.27.1
-      '@babel/generator': 7.27.3
-      '@babel/parser': 7.27.4
+      '@babel/generator': 7.28.5
+      '@babel/helper-globals': 7.28.0
+      '@babel/parser': 7.28.5
       '@babel/template': 7.27.2
-      '@babel/types': 7.27.3
-      debug: 4.4.1
-      globals: 11.12.0
+      '@babel/types': 7.28.5
+      debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/types@7.27.3':
+  '@babel/types@7.28.5':
     dependencies:
       '@babel/helper-string-parser': 7.27.1
-      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
+
+  '@babel/types@8.0.0-rc.2':
+    dependencies:
+      '@babel/helper-string-parser': 8.0.0-rc.2
+      '@babel/helper-validator-identifier': 8.0.0-rc.2
 
   '@balena/dockerignore@1.0.2': {}
 
-  '@cloudflare/workers-types@4.20250603.0': {}
+  '@braidai/lang@1.1.2': {}
+
+  '@cloudflare/workers-types@4.20251126.0': {}
+
+  '@cloudflare/workers-types@4.20260621.1': {}
 
   '@colors/colors@1.5.0':
     optional: true
 
+  '@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+    dependencies:
+      ieee754: 1.2.1
+      react-native-quick-base64: 2.2.2(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+    transitivePeerDependencies:
+      - react
+      - react-native
+
+  '@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+    dependencies:
+      ieee754: 1.2.1
+      react-native-quick-base64: 2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+    transitivePeerDependencies:
+      - react
+      - react-native
+
   '@cspotcode/source-map-support@0.8.1':
     dependencies:
       '@jridgewell/trace-mapping': 0.3.9
 
-  '@dprint/darwin-arm64@0.46.3':
+  '@dprint/darwin-arm64@0.50.2':
+    optional: true
+
+  '@dprint/darwin-x64@0.50.2':
+    optional: true
+
+  '@dprint/linux-arm64-glibc@0.50.2':
     optional: true
 
-  '@dprint/darwin-x64@0.46.3':
+  '@dprint/linux-arm64-musl@0.50.2':
     optional: true
 
-  '@dprint/linux-arm64-glibc@0.46.3':
+  '@dprint/linux-riscv64-glibc@0.50.2':
     optional: true
 
-  '@dprint/linux-arm64-musl@0.46.3':
+  '@dprint/linux-x64-glibc@0.50.2':
     optional: true
 
-  '@dprint/linux-x64-glibc@0.46.3':
+  '@dprint/linux-x64-musl@0.50.2':
     optional: true
 
-  '@dprint/linux-x64-musl@0.46.3':
+  '@dprint/win32-arm64@0.50.2':
     optional: true
 
-  '@dprint/win32-x64@0.46.3':
+  '@dprint/win32-x64@0.50.2':
     optional: true
 
   '@drizzle-team/brocli@0.10.2': {}
 
-  '@drizzle-team/studio@0.0.5': {}
+  '@drizzle-team/brocli@0.12.0': {}
+
+  '@duckdb/node-api@1.5.0-r.1':
+    dependencies:
+      '@duckdb/node-bindings': 1.5.0-r.1
+
+  '@duckdb/node-bindings-darwin-arm64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings-darwin-x64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings-linux-arm64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings-linux-x64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings-win32-arm64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings-win32-x64@1.5.0-r.1':
+    optional: true
+
+  '@duckdb/node-bindings@1.5.0-r.1':
+    optionalDependencies:
+      '@duckdb/node-bindings-darwin-arm64': 1.5.0-r.1
+      '@duckdb/node-bindings-darwin-x64': 1.5.0-r.1
+      '@duckdb/node-bindings-linux-arm64': 1.5.0-r.1
+      '@duckdb/node-bindings-linux-x64': 1.5.0-r.1
+      '@duckdb/node-bindings-win32-arm64': 1.5.0-r.1
+      '@duckdb/node-bindings-win32-x64': 1.5.0-r.1
+
+  '@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)':
+    dependencies:
+      '@effect/platform': 0.93.5(effect@4.0.0-beta.83)
+      effect: 4.0.0-beta.83
+      uuid: 11.1.0
+
+  '@effect/platform@0.93.5(effect@4.0.0-beta.83)':
+    dependencies:
+      effect: 4.0.0-beta.83
+      find-my-way-ts: 0.1.6
+      msgpackr: 1.11.9
+      multipasta: 0.2.7
+
+  '@effect/sql-d1@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      '@cloudflare/workers-types': 4.20260621.1
+      effect: 4.0.0-beta.83
+
+  '@effect/sql-libsql@4.0.0-beta.83(bufferutil@4.0.8)(effect@4.0.0-beta.83)(utf-8-validate@6.0.3)':
+    dependencies:
+      '@libsql/client': 0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      effect: 4.0.0-beta.83
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  '@effect/sql-mysql2@4.0.0-beta.83(@types/node@25.5.0)(effect@4.0.0-beta.83)':
+    dependencies:
+      effect: 4.0.0-beta.83
+      mysql2: 3.22.3(@types/node@25.5.0)
+    transitivePeerDependencies:
+      - '@types/node'
+
+  '@effect/sql-pg@0.49.7(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(@effect/sql@0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)':
+    dependencies:
+      '@effect/experimental': 0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
+      '@effect/platform': 0.93.5(effect@4.0.0-beta.83)
+      '@effect/sql': 0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
+      effect: 4.0.0-beta.83
+      pg: 8.20.0
+      pg-connection-string: 2.9.1
+      pg-cursor: 2.19.0(pg@8.20.0)
+      pg-pool: 3.13.0(pg@8.20.0)
+      pg-types: 4.1.0
+    transitivePeerDependencies:
+      - pg-native
+    optional: true
+
+  '@effect/sql-pg@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      effect: 4.0.0-beta.83
+      pg: 8.20.0
+      pg-connection-string: 2.12.0
+      pg-cursor: 2.19.0(pg@8.20.0)
+      pg-pool: 3.13.0(pg@8.20.0)
+      pg-types: 4.1.0
+    transitivePeerDependencies:
+      - pg-native
+
+  '@effect/sql-pglite@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      '@electric-sql/pglite': 0.4.6
+      effect: 4.0.0-beta.83
+
+  '@effect/sql-sqlite-bun@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      effect: 4.0.0-beta.83
+
+  '@effect/sql-sqlite-do@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      effect: 4.0.0-beta.83
+
+  '@effect/sql-sqlite-node@4.0.0-beta.83(effect@4.0.0-beta.83)':
+    dependencies:
+      better-sqlite3: 12.10.0
+      effect: 4.0.0-beta.83
+
+  '@effect/sql-sqlite-wasm@4.0.0-beta.83(@effect/wa-sqlite@0.1.2)(effect@4.0.0-beta.83)':
+    dependencies:
+      '@effect/wa-sqlite': 0.1.2
+      effect: 4.0.0-beta.83
+
+  '@effect/sql@0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)':
+    dependencies:
+      '@effect/experimental': 0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
+      '@effect/platform': 0.93.5(effect@4.0.0-beta.83)
+      effect: 4.0.0-beta.83
+      uuid: 11.1.0
+
+  '@effect/vitest@4.0.0-beta.58(effect@4.0.0-beta.83)(vitest@4.0.13(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))':
+    dependencies:
+      effect: 4.0.0-beta.83
+      vitest: 4.0.13(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
+
+  '@effect/wa-sqlite@0.1.2': {}
+
+  '@electric-sql/pglite-postgis@0.0.8(@electric-sql/pglite@0.4.6)':
+    dependencies:
+      '@electric-sql/pglite': 0.4.6
+
+  '@electric-sql/pglite@0.4.6': {}
+
+  '@emnapi/core@1.7.1':
+    dependencies:
+      '@emnapi/wasi-threads': 1.1.0
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/core@1.8.1':
+    dependencies:
+      '@emnapi/wasi-threads': 1.1.0
+      tslib: 2.8.1
+
+  '@emnapi/runtime@1.7.1':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/runtime@1.8.1':
+    dependencies:
+      tslib: 2.8.1
 
-  '@electric-sql/pglite@0.2.12': {}
+  '@emnapi/wasi-threads@1.1.0':
+    dependencies:
+      tslib: 2.8.1
 
   '@esbuild-kit/core-utils@3.3.2':
     dependencies:
@@ -9517,102 +10928,135 @@ snapshots:
   '@esbuild-kit/esm-loader@2.6.5':
     dependencies:
       '@esbuild-kit/core-utils': 3.3.2
-      get-tsconfig: 4.10.1
+      get-tsconfig: 4.13.6
+
+  '@esbuild/aix-ppc64@0.21.5':
+    optional: true
 
-  '@esbuild/aix-ppc64@0.19.12':
+  '@esbuild/aix-ppc64@0.25.12':
     optional: true
 
-  '@esbuild/aix-ppc64@0.25.5':
+  '@esbuild/aix-ppc64@0.27.0':
     optional: true
 
   '@esbuild/android-arm64@0.18.20':
     optional: true
 
-  '@esbuild/android-arm64@0.19.12':
+  '@esbuild/android-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm64@0.25.12':
     optional: true
 
-  '@esbuild/android-arm64@0.25.5':
+  '@esbuild/android-arm64@0.27.0':
     optional: true
 
   '@esbuild/android-arm@0.18.20':
     optional: true
 
-  '@esbuild/android-arm@0.19.12':
+  '@esbuild/android-arm@0.21.5':
+    optional: true
+
+  '@esbuild/android-arm@0.25.12':
     optional: true
 
-  '@esbuild/android-arm@0.25.5':
+  '@esbuild/android-arm@0.27.0':
     optional: true
 
   '@esbuild/android-x64@0.18.20':
     optional: true
 
-  '@esbuild/android-x64@0.19.12':
+  '@esbuild/android-x64@0.21.5':
+    optional: true
+
+  '@esbuild/android-x64@0.25.12':
     optional: true
 
-  '@esbuild/android-x64@0.25.5':
+  '@esbuild/android-x64@0.27.0':
     optional: true
 
   '@esbuild/darwin-arm64@0.18.20':
     optional: true
 
-  '@esbuild/darwin-arm64@0.19.12':
+  '@esbuild/darwin-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.25.12':
     optional: true
 
-  '@esbuild/darwin-arm64@0.25.5':
+  '@esbuild/darwin-arm64@0.27.0':
     optional: true
 
   '@esbuild/darwin-x64@0.18.20':
     optional: true
 
-  '@esbuild/darwin-x64@0.19.12':
+  '@esbuild/darwin-x64@0.21.5':
+    optional: true
+
+  '@esbuild/darwin-x64@0.25.12':
     optional: true
 
-  '@esbuild/darwin-x64@0.25.5':
+  '@esbuild/darwin-x64@0.27.0':
     optional: true
 
   '@esbuild/freebsd-arm64@0.18.20':
     optional: true
 
-  '@esbuild/freebsd-arm64@0.19.12':
+  '@esbuild/freebsd-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.25.12':
     optional: true
 
-  '@esbuild/freebsd-arm64@0.25.5':
+  '@esbuild/freebsd-arm64@0.27.0':
     optional: true
 
   '@esbuild/freebsd-x64@0.18.20':
     optional: true
 
-  '@esbuild/freebsd-x64@0.19.12':
+  '@esbuild/freebsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.25.12':
     optional: true
 
-  '@esbuild/freebsd-x64@0.25.5':
+  '@esbuild/freebsd-x64@0.27.0':
     optional: true
 
   '@esbuild/linux-arm64@0.18.20':
     optional: true
 
-  '@esbuild/linux-arm64@0.19.12':
+  '@esbuild/linux-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm64@0.25.12':
     optional: true
 
-  '@esbuild/linux-arm64@0.25.5':
+  '@esbuild/linux-arm64@0.27.0':
     optional: true
 
   '@esbuild/linux-arm@0.18.20':
     optional: true
 
-  '@esbuild/linux-arm@0.19.12':
+  '@esbuild/linux-arm@0.21.5':
+    optional: true
+
+  '@esbuild/linux-arm@0.25.12':
     optional: true
 
-  '@esbuild/linux-arm@0.25.5':
+  '@esbuild/linux-arm@0.27.0':
     optional: true
 
   '@esbuild/linux-ia32@0.18.20':
     optional: true
 
-  '@esbuild/linux-ia32@0.19.12':
+  '@esbuild/linux-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ia32@0.25.12':
     optional: true
 
-  '@esbuild/linux-ia32@0.25.5':
+  '@esbuild/linux-ia32@0.27.0':
     optional: true
 
   '@esbuild/linux-loong64@0.14.54':
@@ -9621,133 +11065,181 @@ snapshots:
   '@esbuild/linux-loong64@0.18.20':
     optional: true
 
-  '@esbuild/linux-loong64@0.19.12':
+  '@esbuild/linux-loong64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-loong64@0.25.12':
     optional: true
 
-  '@esbuild/linux-loong64@0.25.5':
+  '@esbuild/linux-loong64@0.27.0':
     optional: true
 
   '@esbuild/linux-mips64el@0.18.20':
     optional: true
 
-  '@esbuild/linux-mips64el@0.19.12':
+  '@esbuild/linux-mips64el@0.21.5':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.25.12':
     optional: true
 
-  '@esbuild/linux-mips64el@0.25.5':
+  '@esbuild/linux-mips64el@0.27.0':
     optional: true
 
   '@esbuild/linux-ppc64@0.18.20':
     optional: true
 
-  '@esbuild/linux-ppc64@0.19.12':
+  '@esbuild/linux-ppc64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.25.12':
     optional: true
 
-  '@esbuild/linux-ppc64@0.25.5':
+  '@esbuild/linux-ppc64@0.27.0':
     optional: true
 
   '@esbuild/linux-riscv64@0.18.20':
     optional: true
 
-  '@esbuild/linux-riscv64@0.19.12':
+  '@esbuild/linux-riscv64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.25.12':
     optional: true
 
-  '@esbuild/linux-riscv64@0.25.5':
+  '@esbuild/linux-riscv64@0.27.0':
     optional: true
 
   '@esbuild/linux-s390x@0.18.20':
     optional: true
 
-  '@esbuild/linux-s390x@0.19.12':
+  '@esbuild/linux-s390x@0.21.5':
+    optional: true
+
+  '@esbuild/linux-s390x@0.25.12':
     optional: true
 
-  '@esbuild/linux-s390x@0.25.5':
+  '@esbuild/linux-s390x@0.27.0':
     optional: true
 
   '@esbuild/linux-x64@0.18.20':
     optional: true
 
-  '@esbuild/linux-x64@0.19.12':
+  '@esbuild/linux-x64@0.21.5':
+    optional: true
+
+  '@esbuild/linux-x64@0.25.12':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.0':
     optional: true
 
-  '@esbuild/linux-x64@0.25.5':
+  '@esbuild/netbsd-arm64@0.25.12':
     optional: true
 
-  '@esbuild/netbsd-arm64@0.25.5':
+  '@esbuild/netbsd-arm64@0.27.0':
     optional: true
 
   '@esbuild/netbsd-x64@0.18.20':
     optional: true
 
-  '@esbuild/netbsd-x64@0.19.12':
+  '@esbuild/netbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.25.12':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.0':
     optional: true
 
-  '@esbuild/netbsd-x64@0.25.5':
+  '@esbuild/openbsd-arm64@0.25.12':
     optional: true
 
-  '@esbuild/openbsd-arm64@0.25.5':
+  '@esbuild/openbsd-arm64@0.27.0':
     optional: true
 
   '@esbuild/openbsd-x64@0.18.20':
     optional: true
 
-  '@esbuild/openbsd-x64@0.19.12':
+  '@esbuild/openbsd-x64@0.21.5':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.25.12':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.0':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.25.12':
     optional: true
 
-  '@esbuild/openbsd-x64@0.25.5':
+  '@esbuild/openharmony-arm64@0.27.0':
     optional: true
 
   '@esbuild/sunos-x64@0.18.20':
     optional: true
 
-  '@esbuild/sunos-x64@0.19.12':
+  '@esbuild/sunos-x64@0.21.5':
+    optional: true
+
+  '@esbuild/sunos-x64@0.25.12':
     optional: true
 
-  '@esbuild/sunos-x64@0.25.5':
+  '@esbuild/sunos-x64@0.27.0':
     optional: true
 
   '@esbuild/win32-arm64@0.18.20':
     optional: true
 
-  '@esbuild/win32-arm64@0.19.12':
+  '@esbuild/win32-arm64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-arm64@0.25.12':
     optional: true
 
-  '@esbuild/win32-arm64@0.25.5':
+  '@esbuild/win32-arm64@0.27.0':
     optional: true
 
   '@esbuild/win32-ia32@0.18.20':
     optional: true
 
-  '@esbuild/win32-ia32@0.19.12':
+  '@esbuild/win32-ia32@0.21.5':
+    optional: true
+
+  '@esbuild/win32-ia32@0.25.12':
     optional: true
 
-  '@esbuild/win32-ia32@0.25.5':
+  '@esbuild/win32-ia32@0.27.0':
     optional: true
 
   '@esbuild/win32-x64@0.18.20':
     optional: true
 
-  '@esbuild/win32-x64@0.19.12':
+  '@esbuild/win32-x64@0.21.5':
+    optional: true
+
+  '@esbuild/win32-x64@0.25.12':
     optional: true
 
-  '@esbuild/win32-x64@0.25.5':
+  '@esbuild/win32-x64@0.27.0':
     optional: true
 
-  '@eslint-community/eslint-utils@4.7.0(eslint@8.57.1)':
+  '@eslint-community/eslint-utils@4.9.0(eslint@8.57.1)':
     dependencies:
       eslint: 8.57.1
       eslint-visitor-keys: 3.4.3
 
-  '@eslint-community/regexpp@4.12.1': {}
+  '@eslint-community/regexpp@4.12.2': {}
 
   '@eslint/eslintrc@2.1.4':
     dependencies:
       ajv: 6.12.6
-      debug: 4.4.1
+      debug: 4.4.3
       espree: 9.6.1
       globals: 13.24.0
       ignore: 5.3.2
       import-fresh: 3.3.1
-      js-yaml: 4.1.0
+      js-yaml: 4.1.1
       minimatch: 3.1.2
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
@@ -9759,28 +11251,30 @@ snapshots:
     dependencies:
       heap: 0.2.7
 
-  '@expo/cli@0.24.13(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+  '@expo/cli@54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
     dependencies:
-      '@0no-co/graphql.web': 1.1.2
-      '@babel/runtime': 7.27.4
+      '@0no-co/graphql.web': 1.2.0
       '@expo/code-signing-certificates': 0.0.5
-      '@expo/config': 11.0.10
-      '@expo/config-plugins': 10.0.2
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
       '@expo/devcert': 1.2.0
-      '@expo/env': 1.0.5
-      '@expo/image-utils': 0.7.4
-      '@expo/json-file': 9.1.4
-      '@expo/metro-config': 0.20.14
-      '@expo/osascript': 2.2.4
-      '@expo/package-manager': 1.8.4
-      '@expo/plist': 0.3.4
-      '@expo/prebuild-config': 9.0.6
+      '@expo/env': 2.0.7
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@expo/mcp-tunnel': 0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/osascript': 2.3.7
+      '@expo/package-manager': 1.9.8
+      '@expo/plist': 0.4.7
+      '@expo/prebuild-config': 54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
+      '@expo/schema-utils': 0.1.7
       '@expo/spawn-async': 1.7.2
       '@expo/ws-tunnel': 1.0.6
       '@expo/xcpretty': 4.3.2
-      '@react-native/dev-middleware': 0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@urql/core': 5.1.1
-      '@urql/exchange-retry': 1.3.1(@urql/core@5.1.1)
+      '@react-native/dev-middleware': 0.81.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@urql/core': 5.2.0
+      '@urql/exchange-retry': 1.3.2(@urql/core@5.2.0)
       accepts: 1.3.8
       arg: 5.0.2
       better-opn: 3.0.2
@@ -9788,16 +11282,18 @@ snapshots:
       bplist-parser: 0.3.2
       chalk: 4.1.2
       ci-info: 3.9.0
-      compression: 1.8.0
+      compression: 1.8.1
       connect: 3.7.0
-      debug: 4.4.1
+      debug: 4.4.3
       env-editor: 0.4.2
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-server: 1.0.4
       freeport-async: 2.0.0
-      getenv: 1.0.0
-      glob: 10.4.5
+      getenv: 2.0.0
+      glob: 10.5.0
       lan-network: 0.1.7
       minimatch: 9.0.5
-      node-forge: 1.3.1
+      node-forge: 1.3.2
       npm-package-arg: 11.0.3
       ora: 3.4.0
       picomatch: 3.0.1
@@ -9808,65 +11304,222 @@ snapshots:
       qrcode-terminal: 0.11.0
       require-from-string: 2.0.2
       requireg: 0.2.2
-      resolve: 1.22.10
+      resolve: 1.22.11
       resolve-from: 5.0.0
       resolve.exports: 2.0.3
-      semver: 7.7.2
+      semver: 7.7.4
       send: 0.19.1
       slugify: 1.6.6
       source-map-support: 0.5.21
       stacktrace-parser: 0.1.11
       structured-headers: 0.4.1
-      tar: 7.4.3
+      tar: 7.5.2
       terminal-link: 2.1.1
-      undici: 6.21.3
+      undici: 6.22.0
       wrap-ansi: 7.0.0
-      ws: 8.18.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+    optionalDependencies:
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
+      - '@modelcontextprotocol/sdk'
       - bufferutil
       - graphql
       - supports-color
       - utf-8-validate
 
-  '@expo/code-signing-certificates@0.0.5':
-    dependencies:
-      node-forge: 1.3.1
-      nullthrows: 1.1.1
-
-  '@expo/config-plugins@10.0.2':
+  '@expo/cli@54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
     dependencies:
-      '@expo/config-types': 53.0.4
-      '@expo/json-file': 9.1.4
-      '@expo/plist': 0.3.4
-      '@expo/sdk-runtime-versions': 1.0.0
-      chalk: 4.1.2
-      debug: 4.4.1
-      getenv: 1.0.0
-      glob: 10.4.5
-      resolve-from: 5.0.0
-      semver: 7.7.2
-      slash: 3.0.0
-      slugify: 1.6.6
-      xcode: 3.0.1
+      '@0no-co/graphql.web': 1.2.0
+      '@expo/code-signing-certificates': 0.0.5
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/devcert': 1.2.0
+      '@expo/env': 2.0.7
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@expo/mcp-tunnel': 0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/osascript': 2.3.7
+      '@expo/package-manager': 1.9.8
+      '@expo/plist': 0.4.7
+      '@expo/prebuild-config': 54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
+      '@expo/schema-utils': 0.1.7
+      '@expo/spawn-async': 1.7.2
+      '@expo/ws-tunnel': 1.0.6
+      '@expo/xcpretty': 4.3.2
+      '@react-native/dev-middleware': 0.81.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@urql/core': 5.2.0
+      '@urql/exchange-retry': 1.3.2(@urql/core@5.2.0)
+      accepts: 1.3.8
+      arg: 5.0.2
+      better-opn: 3.0.2
+      bplist-creator: 0.1.0
+      bplist-parser: 0.3.2
+      chalk: 4.1.2
+      ci-info: 3.9.0
+      compression: 1.8.1
+      connect: 3.7.0
+      debug: 4.4.3
+      env-editor: 0.4.2
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-server: 1.0.4
+      freeport-async: 2.0.0
+      getenv: 2.0.0
+      glob: 10.5.0
+      lan-network: 0.1.7
+      minimatch: 9.0.5
+      node-forge: 1.3.2
+      npm-package-arg: 11.0.3
+      ora: 3.4.0
+      picomatch: 3.0.1
+      pretty-bytes: 5.6.0
+      pretty-format: 29.7.0
+      progress: 2.0.3
+      prompts: 2.4.2
+      qrcode-terminal: 0.11.0
+      require-from-string: 2.0.2
+      requireg: 0.2.2
+      resolve: 1.22.11
+      resolve-from: 5.0.0
+      resolve.exports: 2.0.3
+      semver: 7.7.4
+      send: 0.19.1
+      slugify: 1.6.6
+      source-map-support: 0.5.21
+      stacktrace-parser: 0.1.11
+      structured-headers: 0.4.1
+      tar: 7.5.2
+      terminal-link: 2.1.1
+      undici: 6.22.0
+      wrap-ansi: 7.0.0
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+    optionalDependencies:
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - '@modelcontextprotocol/sdk'
+      - bufferutil
+      - graphql
+      - supports-color
+      - utf-8-validate
+    optional: true
+
+  '@expo/cli@54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
+    dependencies:
+      '@0no-co/graphql.web': 1.2.0
+      '@expo/code-signing-certificates': 0.0.5
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/devcert': 1.2.0
+      '@expo/env': 2.0.7
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@expo/mcp-tunnel': 0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/osascript': 2.3.7
+      '@expo/package-manager': 1.9.8
+      '@expo/plist': 0.4.7
+      '@expo/prebuild-config': 54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
+      '@expo/schema-utils': 0.1.7
+      '@expo/spawn-async': 1.7.2
+      '@expo/ws-tunnel': 1.0.6
+      '@expo/xcpretty': 4.3.2
+      '@react-native/dev-middleware': 0.81.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@urql/core': 5.2.0
+      '@urql/exchange-retry': 1.3.2(@urql/core@5.2.0)
+      accepts: 1.3.8
+      arg: 5.0.2
+      better-opn: 3.0.2
+      bplist-creator: 0.1.0
+      bplist-parser: 0.3.2
+      chalk: 4.1.2
+      ci-info: 3.9.0
+      compression: 1.8.1
+      connect: 3.7.0
+      debug: 4.4.3
+      env-editor: 0.4.2
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-server: 1.0.4
+      freeport-async: 2.0.0
+      getenv: 2.0.0
+      glob: 10.5.0
+      lan-network: 0.1.7
+      minimatch: 9.0.5
+      node-forge: 1.3.2
+      npm-package-arg: 11.0.3
+      ora: 3.4.0
+      picomatch: 3.0.1
+      pretty-bytes: 5.6.0
+      pretty-format: 29.7.0
+      progress: 2.0.3
+      prompts: 2.4.2
+      qrcode-terminal: 0.11.0
+      require-from-string: 2.0.2
+      requireg: 0.2.2
+      resolve: 1.22.11
+      resolve-from: 5.0.0
+      resolve.exports: 2.0.3
+      semver: 7.7.4
+      send: 0.19.1
+      slugify: 1.6.6
+      source-map-support: 0.5.21
+      stacktrace-parser: 0.1.11
+      structured-headers: 0.4.1
+      tar: 7.5.2
+      terminal-link: 2.1.1
+      undici: 6.22.0
+      wrap-ansi: 7.0.0
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+    optionalDependencies:
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - '@modelcontextprotocol/sdk'
+      - bufferutil
+      - graphql
+      - supports-color
+      - utf-8-validate
+    optional: true
+
+  '@expo/code-signing-certificates@0.0.5':
+    dependencies:
+      node-forge: 1.3.2
+      nullthrows: 1.1.1
+
+  '@expo/config-plugins@54.0.2':
+    dependencies:
+      '@expo/config-types': 54.0.8
+      '@expo/json-file': 10.0.7
+      '@expo/plist': 0.4.7
+      '@expo/sdk-runtime-versions': 1.0.0
+      chalk: 4.1.2
+      debug: 4.4.3
+      getenv: 2.0.0
+      glob: 10.5.0
+      resolve-from: 5.0.0
+      semver: 7.7.4
+      slash: 3.0.0
+      slugify: 1.6.6
+      xcode: 3.0.1
       xml2js: 0.6.0
     transitivePeerDependencies:
       - supports-color
 
-  '@expo/config-types@53.0.4': {}
+  '@expo/config-types@54.0.8': {}
 
-  '@expo/config@11.0.10':
+  '@expo/config@12.0.10':
     dependencies:
       '@babel/code-frame': 7.10.4
-      '@expo/config-plugins': 10.0.2
-      '@expo/config-types': 53.0.4
-      '@expo/json-file': 9.1.4
+      '@expo/config-plugins': 54.0.2
+      '@expo/config-types': 54.0.8
+      '@expo/json-file': 10.0.7
       deepmerge: 4.3.1
-      getenv: 1.0.0
-      glob: 10.4.5
+      getenv: 2.0.0
+      glob: 10.5.0
       require-from-string: 2.0.2
       resolve-from: 5.0.0
       resolve-workspace-root: 2.0.0
-      semver: 7.7.2
+      semver: 7.7.4
       slugify: 1.6.6
       sucrase: 3.35.0
     transitivePeerDependencies:
@@ -9876,111 +11529,287 @@ snapshots:
     dependencies:
       '@expo/sudo-prompt': 9.3.2
       debug: 3.2.7
-      glob: 10.4.5
+      glob: 10.5.0
     transitivePeerDependencies:
       - supports-color
 
-  '@expo/env@1.0.5':
+  '@expo/devtools@0.1.7(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+    dependencies:
+      chalk: 4.1.2
+    optionalDependencies:
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  '@expo/devtools@0.1.7(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+    dependencies:
+      chalk: 4.1.2
+    optionalDependencies:
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
+
+  '@expo/env@2.0.7':
     dependencies:
       chalk: 4.1.2
-      debug: 4.4.1
+      debug: 4.4.3
       dotenv: 16.4.7
       dotenv-expand: 11.0.7
-      getenv: 1.0.0
+      getenv: 2.0.0
     transitivePeerDependencies:
       - supports-color
 
-  '@expo/fingerprint@0.12.4':
+  '@expo/fingerprint@0.15.3':
     dependencies:
       '@expo/spawn-async': 1.7.2
       arg: 5.0.2
       chalk: 4.1.2
-      debug: 4.4.1
-      find-up: 5.0.0
-      getenv: 1.0.0
+      debug: 4.4.3
+      getenv: 2.0.0
+      glob: 10.5.0
+      ignore: 5.3.2
       minimatch: 9.0.5
       p-limit: 3.1.0
       resolve-from: 5.0.0
-      semver: 7.7.2
+      semver: 7.7.4
     transitivePeerDependencies:
       - supports-color
 
-  '@expo/image-utils@0.7.4':
+  '@expo/image-utils@0.8.7':
     dependencies:
       '@expo/spawn-async': 1.7.2
       chalk: 4.1.2
-      getenv: 1.0.0
+      getenv: 2.0.0
       jimp-compact: 0.16.1
       parse-png: 2.1.0
       resolve-from: 5.0.0
-      semver: 7.7.2
+      resolve-global: 1.0.0
+      semver: 7.7.4
       temp-dir: 2.0.0
       unique-string: 2.0.0
 
-  '@expo/json-file@9.1.4':
+  '@expo/json-file@10.0.7':
     dependencies:
       '@babel/code-frame': 7.10.4
       json5: 2.2.3
 
-  '@expo/metro-config@0.20.14':
+  '@expo/mcp-tunnel@0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    optionalDependencies:
+      '@modelcontextprotocol/sdk': 1.29.0(zod@3.25.1)
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  '@expo/mcp-tunnel@0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    optionalDependencies:
+      '@modelcontextprotocol/sdk': 1.29.0(zod@3.25.76)
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+    optional: true
+
+  '@expo/mcp-tunnel@0.1.0(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
+    optionalDependencies:
+      '@modelcontextprotocol/sdk': 1.29.0(zod@4.3.4)
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+    optional: true
+
+  '@expo/metro-config@54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      '@expo/json-file': 10.0.7
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/spawn-async': 1.7.2
+      browserslist: 4.28.0
+      chalk: 4.1.2
+      debug: 4.4.3
+      dotenv: 16.4.7
+      dotenv-expand: 11.0.7
+      getenv: 2.0.0
+      glob: 10.5.0
+      hermes-parser: 0.29.1
+      jsc-safe-url: 0.2.4
+      lightningcss: 1.30.2
+      minimatch: 9.0.5
+      postcss: 8.4.49
+      resolve-from: 5.0.0
+    optionalDependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@expo/metro-config@54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/generator': 7.27.3
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
-      '@expo/config': 11.0.10
-      '@expo/env': 1.0.5
-      '@expo/json-file': 9.1.4
+      '@babel/code-frame': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      '@expo/json-file': 10.0.7
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       '@expo/spawn-async': 1.7.2
+      browserslist: 4.28.0
       chalk: 4.1.2
-      debug: 4.4.1
+      debug: 4.4.3
       dotenv: 16.4.7
       dotenv-expand: 11.0.7
-      getenv: 1.0.0
-      glob: 10.4.5
+      getenv: 2.0.0
+      glob: 10.5.0
+      hermes-parser: 0.29.1
       jsc-safe-url: 0.2.4
-      lightningcss: 1.27.0
+      lightningcss: 1.30.2
       minimatch: 9.0.5
       postcss: 8.4.49
       resolve-from: 5.0.0
+    optionalDependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
+      - bufferutil
       - supports-color
+      - utf-8-validate
+    optional: true
 
-  '@expo/osascript@2.2.4':
+  '@expo/metro-config@54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)':
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      '@expo/json-file': 10.0.7
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/spawn-async': 1.7.2
+      browserslist: 4.28.0
+      chalk: 4.1.2
+      debug: 4.4.3
+      dotenv: 16.4.7
+      dotenv-expand: 11.0.7
+      getenv: 2.0.0
+      glob: 10.5.0
+      hermes-parser: 0.29.1
+      jsc-safe-url: 0.2.4
+      lightningcss: 1.30.2
+      minimatch: 9.0.5
+      postcss: 8.4.49
+      resolve-from: 5.0.0
+    optionalDependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    optional: true
+
+  '@expo/metro@54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      metro: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-babel-transformer: 0.83.2
+      metro-cache: 0.83.2
+      metro-cache-key: 0.83.2
+      metro-config: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-core: 0.83.2
+      metro-file-map: 0.83.2
+      metro-resolver: 0.83.2
+      metro-runtime: 0.83.2
+      metro-source-map: 0.83.2
+      metro-transform-plugins: 0.83.2
+      metro-transform-worker: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@expo/osascript@2.3.7':
     dependencies:
       '@expo/spawn-async': 1.7.2
       exec-async: 2.2.0
 
-  '@expo/package-manager@1.8.4':
+  '@expo/package-manager@1.9.8':
     dependencies:
-      '@expo/json-file': 9.1.4
+      '@expo/json-file': 10.0.7
       '@expo/spawn-async': 1.7.2
       chalk: 4.1.2
       npm-package-arg: 11.0.3
       ora: 3.4.0
       resolve-workspace-root: 2.0.0
 
-  '@expo/plist@0.3.4':
+  '@expo/plist@0.4.7':
     dependencies:
-      '@xmldom/xmldom': 0.8.10
+      '@xmldom/xmldom': 0.8.11
       base64-js: 1.5.1
       xmlbuilder: 15.1.1
 
-  '@expo/prebuild-config@9.0.6':
+  '@expo/prebuild-config@54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))':
     dependencies:
-      '@expo/config': 11.0.10
-      '@expo/config-plugins': 10.0.2
-      '@expo/config-types': 53.0.4
-      '@expo/image-utils': 0.7.4
-      '@expo/json-file': 9.1.4
-      '@react-native/normalize-colors': 0.79.2
-      debug: 4.4.1
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/config-types': 54.0.8
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@react-native/normalize-colors': 0.81.5
+      debug: 4.4.3
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
       resolve-from: 5.0.0
-      semver: 7.7.2
+      semver: 7.7.4
       xml2js: 0.6.0
     transitivePeerDependencies:
       - supports-color
 
+  '@expo/prebuild-config@54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))':
+    dependencies:
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/config-types': 54.0.8
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@react-native/normalize-colors': 0.81.5
+      debug: 4.4.3
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      resolve-from: 5.0.0
+      semver: 7.7.4
+      xml2js: 0.6.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@expo/prebuild-config@54.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))':
+    dependencies:
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/config-types': 54.0.8
+      '@expo/image-utils': 0.8.7
+      '@expo/json-file': 10.0.7
+      '@react-native/normalize-colors': 0.81.5
+      debug: 4.4.3
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      resolve-from: 5.0.0
+      semver: 7.7.4
+      xml2js: 0.6.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@expo/schema-utils@0.1.7': {}
+
   '@expo/sdk-runtime-versions@1.0.0': {}
 
   '@expo/spawn-async@1.7.2':
@@ -9989,17 +11818,24 @@ snapshots:
 
   '@expo/sudo-prompt@9.3.2': {}
 
-  '@expo/vector-icons@14.1.0(expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@expo/vector-icons@15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+    dependencies:
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  '@expo/vector-icons@15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
-      expo-font: 13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
 
-  '@expo/vector-icons@14.1.0(expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@expo/vector-icons@15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
-      expo-font: 13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     optional: true
 
   '@expo/websql@1.0.1':
@@ -10017,38 +11853,49 @@ snapshots:
       '@babel/code-frame': 7.10.4
       chalk: 4.1.2
       find-up: 5.0.0
-      js-yaml: 4.1.0
+      js-yaml: 4.1.1
 
   '@fastify/busboy@2.1.1': {}
 
   '@gar/promisify@1.1.3':
     optional: true
 
-  '@grpc/grpc-js@1.13.4':
+  '@grpc/grpc-js@1.14.1':
     dependencies:
-      '@grpc/proto-loader': 0.7.15
+      '@grpc/proto-loader': 0.8.0
       '@js-sdsl/ordered-map': 4.4.2
 
   '@grpc/proto-loader@0.7.15':
     dependencies:
       lodash.camelcase: 4.3.0
       long: 5.3.2
-      protobufjs: 7.5.3
+      protobufjs: 7.5.4
       yargs: 17.7.2
 
-  '@hono/node-server@1.14.3(hono@4.7.11)':
+  '@grpc/proto-loader@0.8.0':
     dependencies:
-      hono: 4.7.11
+      lodash.camelcase: 4.3.0
+      long: 5.3.2
+      protobufjs: 7.5.4
+      yargs: 17.7.2
 
-  '@hono/zod-validator@0.2.2(hono@4.7.11)(zod@3.25.1)':
+  '@hono/node-server@1.19.14(hono@4.12.27)':
     dependencies:
-      hono: 4.7.11
-      zod: 3.25.1
+      hono: 4.12.27
+
+  '@hono/node-server@1.19.6(hono@4.10.7)':
+    dependencies:
+      hono: 4.10.7
+
+  '@hono/zod-validator@0.2.2(hono@4.10.7)(zod@3.25.76)':
+    dependencies:
+      hono: 4.10.7
+      zod: 3.25.76
 
   '@humanwhocodes/config-array@0.13.0':
     dependencies:
       '@humanwhocodes/object-schema': 2.0.3
-      debug: 4.4.1
+      debug: 4.4.3
       minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
@@ -10059,11 +11906,17 @@ snapshots:
 
   '@iarna/toml@2.2.5': {}
 
+  '@isaacs/balanced-match@4.0.1': {}
+
+  '@isaacs/brace-expansion@5.0.0':
+    dependencies:
+      '@isaacs/balanced-match': 4.0.1
+
   '@isaacs/cliui@8.0.2':
     dependencies:
       string-width: 5.1.2
       string-width-cjs: string-width@4.2.3
-      strip-ansi: 7.1.0
+      strip-ansi: 7.1.2
       strip-ansi-cjs: strip-ansi@6.0.1
       wrap-ansi: 8.1.0
       wrap-ansi-cjs: wrap-ansi@7.0.0
@@ -10079,7 +11932,7 @@ snapshots:
       camelcase: 5.3.1
       find-up: 4.1.0
       get-package-type: 0.1.0
-      js-yaml: 3.14.1
+      js-yaml: 3.14.2
       resolve-from: 5.0.0
 
   '@istanbuljs/schema@0.1.3': {}
@@ -10092,14 +11945,14 @@ snapshots:
     dependencies:
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       jest-mock: 29.7.0
 
   '@jest/fake-timers@29.7.0':
     dependencies:
       '@jest/types': 29.6.3
       '@sinonjs/fake-timers': 10.3.0
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       jest-message-util: 29.7.0
       jest-mock: 29.7.0
       jest-util: 29.7.0
@@ -10110,9 +11963,9 @@ snapshots:
 
   '@jest/transform@29.7.0':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@jest/types': 29.6.3
-      '@jridgewell/trace-mapping': 0.3.25
+      '@jridgewell/trace-mapping': 0.3.31
       babel-plugin-istanbul: 6.1.1
       chalk: 4.1.2
       convert-source-map: 2.0.0
@@ -10133,39 +11986,47 @@ snapshots:
       '@jest/schemas': 29.6.3
       '@types/istanbul-lib-coverage': 2.0.6
       '@types/istanbul-reports': 3.0.4
-      '@types/node': 20.17.57
-      '@types/yargs': 17.0.33
+      '@types/node': 24.10.1
+      '@types/yargs': 17.0.35
       chalk: 4.1.2
 
-  '@jridgewell/gen-mapping@0.3.8':
+  '@jridgewell/gen-mapping@0.3.13':
     dependencies:
-      '@jridgewell/set-array': 1.2.1
-      '@jridgewell/sourcemap-codec': 1.5.0
-      '@jridgewell/trace-mapping': 0.3.25
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
 
-  '@jridgewell/resolve-uri@3.1.2': {}
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
 
-  '@jridgewell/set-array@1.2.1': {}
+  '@jridgewell/resolve-uri@3.1.2': {}
 
-  '@jridgewell/source-map@0.3.6':
+  '@jridgewell/source-map@0.3.11':
     dependencies:
-      '@jridgewell/gen-mapping': 0.3.8
-      '@jridgewell/trace-mapping': 0.3.25
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
 
-  '@jridgewell/sourcemap-codec@1.5.0': {}
+  '@jridgewell/sourcemap-codec@1.5.5': {}
 
-  '@jridgewell/trace-mapping@0.3.25':
+  '@jridgewell/trace-mapping@0.3.31':
     dependencies:
       '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
 
   '@jridgewell/trace-mapping@0.3.9':
     dependencies:
       '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@js-joda/core@5.6.5': {}
 
   '@js-sdsl/ordered-map@4.4.2': {}
 
+  '@js-temporal/polyfill@0.5.1':
+    dependencies:
+      jsbi: 4.3.2
+
   '@jsep-plugin/assignment@1.3.0(jsep@1.4.0)':
     dependencies:
       jsep: 1.4.0
@@ -10174,41 +12035,68 @@ snapshots:
     dependencies:
       jsep: 1.4.0
 
-  '@keyv/serialize@1.0.3':
-    dependencies:
-      buffer: 6.0.3
+  '@keyv/serialize@1.1.1': {}
 
   '@libsql/client-wasm@0.10.0':
     dependencies:
       '@libsql/core': 0.10.0
-      js-base64: 3.7.7
+      js-base64: 3.7.8
 
   '@libsql/client@0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
     dependencies:
       '@libsql/core': 0.10.0
       '@libsql/hrana-client': 0.6.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      js-base64: 3.7.7
+      js-base64: 3.7.8
       libsql: 0.4.7
       promise-limit: 2.7.0
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
 
+  '@libsql/client@0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      '@libsql/core': 0.17.3
+      '@libsql/hrana-client': 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      js-base64: 3.7.8
+      libsql: 0.5.29
+      promise-limit: 2.7.0
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
   '@libsql/core@0.10.0':
     dependencies:
-      js-base64: 3.7.7
+      js-base64: 3.7.8
+
+  '@libsql/core@0.17.3':
+    dependencies:
+      js-base64: 3.7.8
 
   '@libsql/darwin-arm64@0.4.7':
     optional: true
 
+  '@libsql/darwin-arm64@0.5.29':
+    optional: true
+
   '@libsql/darwin-x64@0.4.7':
     optional: true
 
+  '@libsql/darwin-x64@0.5.29':
+    optional: true
+
+  '@libsql/hrana-client@0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      '@libsql/isomorphic-ws': 0.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      js-base64: 3.7.8
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
   '@libsql/hrana-client@0.6.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
     dependencies:
       '@libsql/isomorphic-fetch': 0.2.5
       '@libsql/isomorphic-ws': 0.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      js-base64: 3.7.7
+      js-base64: 3.7.8
       node-fetch: 3.3.2
     transitivePeerDependencies:
       - bufferutil
@@ -10219,26 +12107,51 @@ snapshots:
   '@libsql/isomorphic-ws@0.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
     dependencies:
       '@types/ws': 8.18.1
-      ws: 8.18.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      ws: 8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
 
+  '@libsql/linux-arm-gnueabihf@0.5.29':
+    optional: true
+
+  '@libsql/linux-arm-musleabihf@0.5.29':
+    optional: true
+
   '@libsql/linux-arm64-gnu@0.4.7':
     optional: true
 
+  '@libsql/linux-arm64-gnu@0.5.29':
+    optional: true
+
   '@libsql/linux-arm64-musl@0.4.7':
     optional: true
 
+  '@libsql/linux-arm64-musl@0.5.29':
+    optional: true
+
   '@libsql/linux-x64-gnu@0.4.7':
     optional: true
 
+  '@libsql/linux-x64-gnu@0.5.29':
+    optional: true
+
   '@libsql/linux-x64-musl@0.4.7':
     optional: true
 
+  '@libsql/linux-x64-musl@0.5.29':
+    optional: true
+
   '@libsql/win32-x64-msvc@0.4.7':
     optional: true
 
+  '@libsql/win32-x64-msvc@0.5.29':
+    optional: true
+
+  '@loaderkit/resolve@1.0.4':
+    dependencies:
+      '@braidai/lang': 1.1.2
+
   '@miniflare/core@2.14.4':
     dependencies:
       '@iarna/toml': 2.2.5
@@ -10248,7 +12161,7 @@ snapshots:
       busboy: 1.6.0
       dotenv: 10.0.0
       kleur: 4.1.5
-      set-cookie-parser: 2.7.1
+      set-cookie-parser: 2.7.2
       undici: 5.28.4
       urlpattern-polyfill: 4.0.3
 
@@ -10272,20 +12185,119 @@ snapshots:
     dependencies:
       '@miniflare/shared': 2.14.4
 
+  '@modelcontextprotocol/sdk@1.29.0(zod@3.25.1)':
+    dependencies:
+      '@hono/node-server': 1.19.14(hono@4.12.27)
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      content-type: 1.0.5
+      cors: 2.8.5
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.6
+      express: 5.2.1
+      express-rate-limit: 8.5.2(express@5.2.1)
+      hono: 4.12.27
+      jose: 6.2.3
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.1
+      raw-body: 3.0.2
+      zod: 3.25.1
+      zod-to-json-schema: 3.25.2(zod@3.25.1)
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  '@modelcontextprotocol/sdk@1.29.0(zod@3.25.76)':
+    dependencies:
+      '@hono/node-server': 1.19.14(hono@4.12.27)
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      content-type: 1.0.5
+      cors: 2.8.5
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.6
+      express: 5.2.1
+      express-rate-limit: 8.5.2(express@5.2.1)
+      hono: 4.12.27
+      jose: 6.2.3
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.1
+      raw-body: 3.0.2
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.2(zod@3.25.76)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@modelcontextprotocol/sdk@1.29.0(zod@4.3.4)':
+    dependencies:
+      '@hono/node-server': 1.19.14(hono@4.12.27)
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      content-type: 1.0.5
+      cors: 2.8.5
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.6
+      express: 5.2.1
+      express-rate-limit: 8.5.2(express@5.2.1)
+      hono: 4.12.27
+      jose: 6.2.3
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.1
+      raw-body: 3.0.2
+      zod: 4.3.4
+      zod-to-json-schema: 3.25.2(zod@4.3.4)
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
   '@modelcontextprotocol/sdk@1.6.1':
     dependencies:
       content-type: 1.0.5
       cors: 2.8.5
       eventsource: 3.0.7
       express: 5.1.0
-      express-rate-limit: 7.5.0(express@5.1.0)
+      express-rate-limit: 7.5.1(express@5.1.0)
       pkce-challenge: 4.1.0
-      raw-body: 3.0.0
-      zod: 3.25.1
-      zod-to-json-schema: 3.24.3(zod@3.25.1)
+      raw-body: 3.0.2
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.0(zod@3.25.76)
     transitivePeerDependencies:
       - supports-color
 
+  '@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.4':
+    optional: true
+
+  '@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.4':
+    optional: true
+
+  '@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.4':
+    optional: true
+
+  '@msgpackr-extract/msgpackr-extract-linux-arm@3.0.4':
+    optional: true
+
+  '@msgpackr-extract/msgpackr-extract-linux-x64@3.0.4':
+    optional: true
+
+  '@msgpackr-extract/msgpackr-extract-win32-x64@3.0.4':
+    optional: true
+
+  '@napi-rs/wasm-runtime@1.0.7':
+    dependencies:
+      '@emnapi/core': 1.8.1
+      '@emnapi/runtime': 1.8.1
+      '@tybys/wasm-util': 0.10.1
+
+  '@napi-rs/wasm-runtime@1.1.1':
+    dependencies:
+      '@emnapi/core': 1.7.1
+      '@emnapi/runtime': 1.7.1
+      '@tybys/wasm-util': 0.10.1
+    optional: true
+
   '@neon-rs/load@0.0.4': {}
 
   '@neondatabase/serverless@0.10.0':
@@ -10296,9 +12308,10 @@ snapshots:
     dependencies:
       '@types/pg': 8.6.6
 
-  '@neondatabase/serverless@0.9.5':
+  '@neondatabase/serverless@1.0.2':
     dependencies:
-      '@types/pg': 8.11.6
+      '@types/node': 22.19.1
+      '@types/pg': 8.15.6
 
   '@noble/hashes@1.8.0': {}
 
@@ -10317,7 +12330,7 @@ snapshots:
   '@npmcli/fs@1.1.1':
     dependencies:
       '@gar/promisify': 1.1.3
-      semver: 7.7.2
+      semver: 7.7.4
     optional: true
 
   '@npmcli/move-file@1.1.2':
@@ -10326,15 +12339,15 @@ snapshots:
       rimraf: 3.0.2
     optional: true
 
-  '@op-engineering/op-sqlite@2.0.22(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@op-engineering/op-sqlite@2.0.22(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
 
-  '@op-engineering/op-sqlite@2.0.22(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@op-engineering/op-sqlite@2.0.22(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     optional: true
 
   '@opentelemetry/api@1.9.0': {}
@@ -10343,26 +12356,56 @@ snapshots:
     dependencies:
       esbuild: 0.14.54
 
-  '@paralleldrive/cuid2@2.2.2':
+  '@oxc-project/types@0.112.0': {}
+
+  '@oxc-project/types@0.115.0': {}
+
+  '@oxlint/darwin-arm64@1.30.0':
+    optional: true
+
+  '@oxlint/darwin-x64@1.30.0':
+    optional: true
+
+  '@oxlint/linux-arm64-gnu@1.30.0':
+    optional: true
+
+  '@oxlint/linux-arm64-musl@1.30.0':
+    optional: true
+
+  '@oxlint/linux-x64-gnu@1.30.0':
+    optional: true
+
+  '@oxlint/linux-x64-musl@1.30.0':
+    optional: true
+
+  '@oxlint/win32-arm64@1.30.0':
+    optional: true
+
+  '@oxlint/win32-x64@1.30.0':
+    optional: true
+
+  '@paralleldrive/cuid2@2.3.1':
     dependencies:
       '@noble/hashes': 1.8.0
 
-  '@petamoriken/float16@3.9.2': {}
+  '@petamoriken/float16@3.9.3':
+    optional: true
 
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
-  '@pkgr/core@0.2.7': {}
-
   '@planetscale/database@1.19.0': {}
 
-  '@polka/url@1.0.0-next.29': {}
-
   '@prettier/sync@0.5.5(prettier@3.5.3)':
     dependencies:
       make-synchronized: 0.4.2
       prettier: 3.5.3
 
+  '@prettier/sync@0.6.1(prettier@3.6.2)':
+    dependencies:
+      make-synchronized: 0.8.0
+      prettier: 3.6.2
+
   '@prisma/client@5.14.0(prisma@5.14.0)':
     optionalDependencies:
       prisma: 5.14.0
@@ -10417,100 +12460,140 @@ snapshots:
 
   '@protobufjs/utf8@1.1.0': {}
 
-  '@react-native/assets-registry@0.79.2': {}
+  '@quansync/fs@1.0.0':
+    dependencies:
+      quansync: 1.0.0
+
+  '@react-native/assets-registry@0.82.1': {}
 
-  '@react-native/babel-plugin-codegen@0.79.2(@babel/core@7.27.4)':
+  '@react-native/babel-plugin-codegen@0.81.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/traverse': 7.27.4
-      '@react-native/codegen': 0.79.2(@babel/core@7.27.4)
+      '@babel/traverse': 7.28.5
+      '@react-native/codegen': 0.81.5(@babel/core@7.28.5)
     transitivePeerDependencies:
       - '@babel/core'
       - supports-color
 
-  '@react-native/babel-preset@0.79.2(@babel/core@7.27.4)':
-    dependencies:
-      '@babel/core': 7.27.4
-      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-arrow-functions': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-async-generator-functions': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-async-to-generator': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-block-scoping': 7.27.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-class-properties': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-classes': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-computed-properties': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-destructuring': 7.27.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-for-of': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-function-name': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-literals': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-logical-assignment-operators': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-named-capturing-groups-regex': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-nullish-coalescing-operator': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-numeric-separator': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-object-rest-spread': 7.27.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-optional-catch-binding': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-optional-chaining': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-parameters': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-display-name': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-regenerator': 7.27.4(@babel/core@7.27.4)
-      '@babel/plugin-transform-runtime': 7.27.4(@babel/core@7.27.4)
-      '@babel/plugin-transform-shorthand-properties': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-spread': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-sticky-regex': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-typescript': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-unicode-regex': 7.27.1(@babel/core@7.27.4)
+  '@react-native/babel-preset@0.81.5(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-transform-arrow-functions': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-async-generator-functions': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-transform-async-to-generator': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-block-scoping': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-class-properties': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-classes': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-computed-properties': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-destructuring': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-for-of': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-function-name': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-literals': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-logical-assignment-operators': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-nullish-coalescing-operator': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-numeric-separator': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-optional-catch-binding': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-optional-chaining': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-display-name': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-regenerator': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-shorthand-properties': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-spread': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-sticky-regex': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-typescript': 7.28.5(@babel/core@7.28.5)
+      '@babel/plugin-transform-unicode-regex': 7.27.1(@babel/core@7.28.5)
       '@babel/template': 7.27.2
-      '@react-native/babel-plugin-codegen': 0.79.2(@babel/core@7.27.4)
-      babel-plugin-syntax-hermes-parser: 0.25.1
-      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.27.4)
+      '@react-native/babel-plugin-codegen': 0.81.5(@babel/core@7.28.5)
+      babel-plugin-syntax-hermes-parser: 0.29.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
       react-refresh: 0.14.2
     transitivePeerDependencies:
       - supports-color
 
-  '@react-native/codegen@0.79.2(@babel/core@7.27.4)':
+  '@react-native/codegen@0.81.5(@babel/core@7.28.5)':
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.5
       glob: 7.2.3
-      hermes-parser: 0.25.1
+      hermes-parser: 0.29.1
       invariant: 2.2.4
       nullthrows: 1.1.1
       yargs: 17.7.2
 
-  '@react-native/community-cli-plugin@0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+  '@react-native/codegen@0.82.1(@babel/core@7.28.5)':
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.5
+      glob: 7.2.3
+      hermes-parser: 0.32.0
+      invariant: 2.2.4
+      nullthrows: 1.1.1
+      yargs: 17.7.2
+
+  '@react-native/community-cli-plugin@0.82.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+    dependencies:
+      '@react-native/dev-middleware': 0.82.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      debug: 4.4.3
+      invariant: 2.2.4
+      metro: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-config: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-core: 0.83.3
+      semver: 7.7.4
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@react-native/debugger-frontend@0.81.5': {}
+
+  '@react-native/debugger-frontend@0.82.1': {}
+
+  '@react-native/debugger-shell@0.82.1':
+    dependencies:
+      cross-spawn: 7.0.6
+      fb-dotslash: 0.5.8
+
+  '@react-native/dev-middleware@0.81.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
     dependencies:
-      '@react-native/dev-middleware': 0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      chalk: 4.1.2
-      debug: 2.6.9
+      '@isaacs/ttlcache': 1.4.1
+      '@react-native/debugger-frontend': 0.81.5
+      chrome-launcher: 0.15.2
+      chromium-edge-launcher: 0.2.0
+      connect: 3.7.0
+      debug: 4.4.3
       invariant: 2.2.4
-      metro: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      metro-config: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      metro-core: 0.82.4
-      semver: 7.7.2
+      nullthrows: 1.1.1
+      open: 7.4.2
+      serve-static: 1.16.2
+      ws: 6.2.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - bufferutil
       - supports-color
       - utf-8-validate
 
-  '@react-native/debugger-frontend@0.79.2': {}
-
-  '@react-native/dev-middleware@0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
+  '@react-native/dev-middleware@0.82.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)':
     dependencies:
       '@isaacs/ttlcache': 1.4.1
-      '@react-native/debugger-frontend': 0.79.2
+      '@react-native/debugger-frontend': 0.82.1
+      '@react-native/debugger-shell': 0.82.1
       chrome-launcher: 0.15.2
       chromium-edge-launcher: 0.2.0
       connect: 3.7.0
-      debug: 2.6.9
+      debug: 4.4.3
       invariant: 2.2.4
       nullthrows: 1.1.1
       open: 7.4.2
@@ -10521,119 +12604,191 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  '@react-native/gradle-plugin@0.79.2': {}
+  '@react-native/gradle-plugin@0.82.1': {}
+
+  '@react-native/js-polyfills@0.82.1': {}
 
-  '@react-native/js-polyfills@0.79.2': {}
+  '@react-native/normalize-colors@0.81.5': {}
 
-  '@react-native/normalize-colors@0.79.2': {}
+  '@react-native/normalize-colors@0.82.1': {}
 
-  '@react-native/virtualized-lists@0.79.2(@types/react@18.3.23)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@react-native/virtualized-lists@0.82.1(@types/react@18.3.27)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
       invariant: 2.2.4
       nullthrows: 1.1.1
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     optionalDependencies:
-      '@types/react': 18.3.23
+      '@types/react': 18.3.27
 
-  '@react-native/virtualized-lists@0.79.2(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
+  '@react-native/virtualized-lists@0.82.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)':
     dependencies:
       invariant: 2.2.4
       nullthrows: 1.1.1
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  '@rolldown/binding-android-arm64@1.0.0-rc.3':
     optional: true
 
-  '@rollup/plugin-terser@0.4.4(rollup@3.29.5)':
-    dependencies:
-      serialize-javascript: 6.0.2
-      smob: 1.5.0
-      terser: 5.40.0
-    optionalDependencies:
-      rollup: 3.29.5
+  '@rolldown/binding-android-arm64@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-darwin-arm64@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-darwin-x64@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-darwin-x64@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-freebsd-x64@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.3':
+    optional: true
 
-  '@rollup/plugin-typescript@11.1.6(rollup@3.29.5)(tslib@2.8.1)(typescript@5.6.3)':
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-musl@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-s390x-gnu@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-linux-x64-gnu@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-linux-x64-musl@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-openharmony-arm64@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.3':
     dependencies:
-      '@rollup/pluginutils': 5.1.4(rollup@3.29.5)
-      resolve: 1.22.10
-      typescript: 5.6.3
-    optionalDependencies:
-      rollup: 3.29.5
-      tslib: 2.8.1
+      '@napi-rs/wasm-runtime': 1.1.1
+    optional: true
 
-  '@rollup/pluginutils@5.1.4(rollup@3.29.5)':
+  '@rolldown/binding-wasm32-wasi@1.0.0-rc.9':
     dependencies:
-      '@types/estree': 1.0.7
-      estree-walker: 2.0.2
-      picomatch: 4.0.2
-    optionalDependencies:
-      rollup: 3.29.5
+      '@napi-rs/wasm-runtime': 1.1.1
+    optional: true
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.3':
+    optional: true
+
+  '@rolldown/binding-win32-x64-msvc@1.0.0-rc.9':
+    optional: true
+
+  '@rolldown/pluginutils@1.0.0-rc.3': {}
 
-  '@rollup/rollup-android-arm-eabi@4.41.1':
+  '@rolldown/pluginutils@1.0.0-rc.9': {}
+
+  '@rollup/rollup-android-arm-eabi@4.53.3':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.53.3':
     optional: true
 
-  '@rollup/rollup-android-arm64@4.41.1':
+  '@rollup/rollup-darwin-arm64@4.53.3':
     optional: true
 
-  '@rollup/rollup-darwin-arm64@4.41.1':
+  '@rollup/rollup-darwin-x64@4.53.3':
     optional: true
 
-  '@rollup/rollup-darwin-x64@4.41.1':
+  '@rollup/rollup-freebsd-arm64@4.53.3':
     optional: true
 
-  '@rollup/rollup-freebsd-arm64@4.41.1':
+  '@rollup/rollup-freebsd-x64@4.53.3':
     optional: true
 
-  '@rollup/rollup-freebsd-x64@4.41.1':
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-arm-gnueabihf@4.41.1':
+  '@rollup/rollup-linux-arm-musleabihf@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-arm-musleabihf@4.41.1':
+  '@rollup/rollup-linux-arm64-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-arm64-gnu@4.41.1':
+  '@rollup/rollup-linux-arm64-musl@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-arm64-musl@4.41.1':
+  '@rollup/rollup-linux-loong64-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-loongarch64-gnu@4.41.1':
+  '@rollup/rollup-linux-ppc64-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-powerpc64le-gnu@4.41.1':
+  '@rollup/rollup-linux-riscv64-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-gnu@4.41.1':
+  '@rollup/rollup-linux-riscv64-musl@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-riscv64-musl@4.41.1':
+  '@rollup/rollup-linux-s390x-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-s390x-gnu@4.41.1':
+  '@rollup/rollup-linux-x64-gnu@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-x64-gnu@4.41.1':
+  '@rollup/rollup-linux-x64-musl@4.53.3':
     optional: true
 
-  '@rollup/rollup-linux-x64-musl@4.41.1':
+  '@rollup/rollup-openharmony-arm64@4.53.3':
     optional: true
 
-  '@rollup/rollup-win32-arm64-msvc@4.41.1':
+  '@rollup/rollup-win32-arm64-msvc@4.53.3':
     optional: true
 
-  '@rollup/rollup-win32-ia32-msvc@4.41.1':
+  '@rollup/rollup-win32-ia32-msvc@4.53.3':
     optional: true
 
-  '@rollup/rollup-win32-x64-msvc@4.41.1':
+  '@rollup/rollup-win32-x64-gnu@4.53.3':
     optional: true
 
-  '@rtsao/scc@1.1.0': {}
+  '@rollup/rollup-win32-x64-msvc@4.53.3':
+    optional: true
 
   '@sinclair/typebox@0.27.8': {}
 
-  '@sinclair/typebox@0.34.33': {}
+  '@sinclair/typebox@0.34.48': {}
 
   '@sindresorhus/is@4.6.0': {}
 
@@ -10647,194 +12802,196 @@ snapshots:
     dependencies:
       '@sinonjs/commons': 3.0.1
 
-  '@smithy/abort-controller@4.0.4':
+  '@smithy/abort-controller@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/config-resolver@4.1.4':
+  '@smithy/config-resolver@4.4.3':
     dependencies:
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/types': 4.3.1
-      '@smithy/util-config-provider': 4.0.0
-      '@smithy/util-middleware': 4.0.4
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-config-provider': 4.2.0
+      '@smithy/util-endpoints': 3.2.5
+      '@smithy/util-middleware': 4.2.5
       tslib: 2.8.1
 
-  '@smithy/core@3.5.1':
-    dependencies:
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-body-length-browser': 4.0.0
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-stream': 4.2.2
-      '@smithy/util-utf8': 4.0.0
+  '@smithy/core@3.18.5':
+    dependencies:
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-body-length-browser': 4.2.0
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-stream': 4.5.6
+      '@smithy/util-utf8': 4.2.0
+      '@smithy/uuid': 1.1.0
       tslib: 2.8.1
 
-  '@smithy/credential-provider-imds@4.0.6':
+  '@smithy/credential-provider-imds@4.2.5':
     dependencies:
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/property-provider': 4.0.4
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
       tslib: 2.8.1
 
-  '@smithy/fetch-http-handler@5.0.4':
+  '@smithy/fetch-http-handler@5.3.6':
     dependencies:
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/querystring-builder': 4.0.4
-      '@smithy/types': 4.3.1
-      '@smithy/util-base64': 4.0.0
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/querystring-builder': 4.2.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-base64': 4.3.0
       tslib: 2.8.1
 
-  '@smithy/hash-node@4.0.4':
+  '@smithy/hash-node@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
-      '@smithy/util-buffer-from': 4.0.0
-      '@smithy/util-utf8': 4.0.0
+      '@smithy/types': 4.9.0
+      '@smithy/util-buffer-from': 4.2.0
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/invalid-dependency@4.0.4':
+  '@smithy/invalid-dependency@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
   '@smithy/is-array-buffer@2.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/is-array-buffer@4.0.0':
+  '@smithy/is-array-buffer@4.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/middleware-content-length@4.0.4':
+  '@smithy/middleware-content-length@4.2.5':
     dependencies:
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/middleware-endpoint@4.1.9':
+  '@smithy/middleware-endpoint@4.3.12':
     dependencies:
-      '@smithy/core': 3.5.1
-      '@smithy/middleware-serde': 4.0.8
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
-      '@smithy/url-parser': 4.0.4
-      '@smithy/util-middleware': 4.0.4
+      '@smithy/core': 3.18.5
+      '@smithy/middleware-serde': 4.2.6
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
+      '@smithy/url-parser': 4.2.5
+      '@smithy/util-middleware': 4.2.5
       tslib: 2.8.1
 
-  '@smithy/middleware-retry@4.1.10':
+  '@smithy/middleware-retry@4.4.12':
     dependencies:
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/service-error-classification': 4.0.5
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-retry': 4.0.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/service-error-classification': 4.2.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-retry': 4.2.5
+      '@smithy/uuid': 1.1.0
       tslib: 2.8.1
-      uuid: 9.0.1
 
-  '@smithy/middleware-serde@4.0.8':
+  '@smithy/middleware-serde@4.2.6':
     dependencies:
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/middleware-stack@4.0.4':
+  '@smithy/middleware-stack@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/node-config-provider@4.1.3':
+  '@smithy/node-config-provider@4.3.5':
     dependencies:
-      '@smithy/property-provider': 4.0.4
-      '@smithy/shared-ini-file-loader': 4.0.4
-      '@smithy/types': 4.3.1
+      '@smithy/property-provider': 4.2.5
+      '@smithy/shared-ini-file-loader': 4.4.0
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/node-http-handler@4.0.6':
+  '@smithy/node-http-handler@4.4.5':
     dependencies:
-      '@smithy/abort-controller': 4.0.4
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/querystring-builder': 4.0.4
-      '@smithy/types': 4.3.1
+      '@smithy/abort-controller': 4.2.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/querystring-builder': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/property-provider@4.0.4':
+  '@smithy/property-provider@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/protocol-http@5.1.2':
+  '@smithy/protocol-http@5.3.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/querystring-builder@4.0.4':
+  '@smithy/querystring-builder@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
-      '@smithy/util-uri-escape': 4.0.0
+      '@smithy/types': 4.9.0
+      '@smithy/util-uri-escape': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/querystring-parser@4.0.4':
+  '@smithy/querystring-parser@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/service-error-classification@4.0.5':
+  '@smithy/service-error-classification@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
 
-  '@smithy/shared-ini-file-loader@4.0.4':
+  '@smithy/shared-ini-file-loader@4.4.0':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/signature-v4@5.1.2':
+  '@smithy/signature-v4@5.3.5':
     dependencies:
-      '@smithy/is-array-buffer': 4.0.0
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
-      '@smithy/util-hex-encoding': 4.0.0
-      '@smithy/util-middleware': 4.0.4
-      '@smithy/util-uri-escape': 4.0.0
-      '@smithy/util-utf8': 4.0.0
+      '@smithy/is-array-buffer': 4.2.0
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-hex-encoding': 4.2.0
+      '@smithy/util-middleware': 4.2.5
+      '@smithy/util-uri-escape': 4.2.0
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/smithy-client@4.4.1':
+  '@smithy/smithy-client@4.9.8':
     dependencies:
-      '@smithy/core': 3.5.1
-      '@smithy/middleware-endpoint': 4.1.9
-      '@smithy/middleware-stack': 4.0.4
-      '@smithy/protocol-http': 5.1.2
-      '@smithy/types': 4.3.1
-      '@smithy/util-stream': 4.2.2
+      '@smithy/core': 3.18.5
+      '@smithy/middleware-endpoint': 4.3.12
+      '@smithy/middleware-stack': 4.2.5
+      '@smithy/protocol-http': 5.3.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-stream': 4.5.6
       tslib: 2.8.1
 
-  '@smithy/types@4.3.1':
+  '@smithy/types@4.9.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/url-parser@4.0.4':
+  '@smithy/url-parser@4.2.5':
     dependencies:
-      '@smithy/querystring-parser': 4.0.4
-      '@smithy/types': 4.3.1
+      '@smithy/querystring-parser': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-base64@4.0.0':
+  '@smithy/util-base64@4.3.0':
     dependencies:
-      '@smithy/util-buffer-from': 4.0.0
-      '@smithy/util-utf8': 4.0.0
+      '@smithy/util-buffer-from': 4.2.0
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/util-body-length-browser@4.0.0':
+  '@smithy/util-body-length-browser@4.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/util-body-length-node@4.0.0':
+  '@smithy/util-body-length-node@4.2.1':
     dependencies:
       tslib: 2.8.1
 
@@ -10843,66 +13000,65 @@ snapshots:
       '@smithy/is-array-buffer': 2.2.0
       tslib: 2.8.1
 
-  '@smithy/util-buffer-from@4.0.0':
+  '@smithy/util-buffer-from@4.2.0':
     dependencies:
-      '@smithy/is-array-buffer': 4.0.0
+      '@smithy/is-array-buffer': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/util-config-provider@4.0.0':
+  '@smithy/util-config-provider@4.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/util-defaults-mode-browser@4.0.17':
+  '@smithy/util-defaults-mode-browser@4.3.11':
     dependencies:
-      '@smithy/property-provider': 4.0.4
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
-      bowser: 2.11.0
+      '@smithy/property-provider': 4.2.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-defaults-mode-node@4.0.17':
+  '@smithy/util-defaults-mode-node@4.2.14':
     dependencies:
-      '@smithy/config-resolver': 4.1.4
-      '@smithy/credential-provider-imds': 4.0.6
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/property-provider': 4.0.4
-      '@smithy/smithy-client': 4.4.1
-      '@smithy/types': 4.3.1
+      '@smithy/config-resolver': 4.4.3
+      '@smithy/credential-provider-imds': 4.2.5
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/property-provider': 4.2.5
+      '@smithy/smithy-client': 4.9.8
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-endpoints@3.0.6':
+  '@smithy/util-endpoints@3.2.5':
     dependencies:
-      '@smithy/node-config-provider': 4.1.3
-      '@smithy/types': 4.3.1
+      '@smithy/node-config-provider': 4.3.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-hex-encoding@4.0.0':
+  '@smithy/util-hex-encoding@4.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/util-middleware@4.0.4':
+  '@smithy/util-middleware@4.2.5':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-retry@4.0.5':
+  '@smithy/util-retry@4.2.5':
     dependencies:
-      '@smithy/service-error-classification': 4.0.5
-      '@smithy/types': 4.3.1
+      '@smithy/service-error-classification': 4.2.5
+      '@smithy/types': 4.9.0
       tslib: 2.8.1
 
-  '@smithy/util-stream@4.2.2':
+  '@smithy/util-stream@4.5.6':
     dependencies:
-      '@smithy/fetch-http-handler': 5.0.4
-      '@smithy/node-http-handler': 4.0.6
-      '@smithy/types': 4.3.1
-      '@smithy/util-base64': 4.0.0
-      '@smithy/util-buffer-from': 4.0.0
-      '@smithy/util-hex-encoding': 4.0.0
-      '@smithy/util-utf8': 4.0.0
+      '@smithy/fetch-http-handler': 5.3.6
+      '@smithy/node-http-handler': 4.4.5
+      '@smithy/types': 4.9.0
+      '@smithy/util-base64': 4.3.0
+      '@smithy/util-buffer-from': 4.2.0
+      '@smithy/util-hex-encoding': 4.2.0
+      '@smithy/util-utf8': 4.2.0
       tslib: 2.8.1
 
-  '@smithy/util-uri-escape@4.0.0':
+  '@smithy/util-uri-escape@4.2.0':
     dependencies:
       tslib: 2.8.1
 
@@ -10911,27 +13067,59 @@ snapshots:
       '@smithy/util-buffer-from': 2.2.0
       tslib: 2.8.1
 
-  '@smithy/util-utf8@4.0.0':
+  '@smithy/util-utf8@4.2.0':
     dependencies:
-      '@smithy/util-buffer-from': 4.0.0
+      '@smithy/util-buffer-from': 4.2.0
       tslib: 2.8.1
 
-  '@tidbcloud/serverless@0.1.1': {}
+  '@smithy/uuid@1.1.0':
+    dependencies:
+      tslib: 2.8.1
 
-  '@tootallnate/once@1.1.2':
-    optional: true
+  '@socket.io/component-emitter@3.1.2': {}
 
-  '@trivago/prettier-plugin-sort-imports@5.2.2(prettier@3.5.3)':
+  '@sqlitecloud/drivers@1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)':
     dependencies:
-      '@babel/generator': 7.27.3
-      '@babel/parser': 7.27.4
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
-      javascript-natural-sort: 0.7.1
-      lodash: 4.17.21
-      prettier: 3.5.3
+      '@craftzdog/react-native-buffer': 6.1.1(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      buffer: 6.0.3
+      eventemitter3: 5.0.1
+      lz4js: 0.2.0
+      react-native-quick-base64: 2.2.2(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      react-native-tcp-socket: 6.3.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      react-native-url-polyfill: 3.0.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      socket.io-client: 4.8.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      whatwg-url: 14.2.0
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  '@sqlitecloud/drivers@1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)':
+    dependencies:
+      '@craftzdog/react-native-buffer': 6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      buffer: 6.0.3
+      eventemitter3: 5.0.1
+      lz4js: 0.2.0
+      react-native-quick-base64: 2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      react-native-tcp-socket: 6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      react-native-url-polyfill: 3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      socket.io-client: 4.8.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      whatwg-url: 14.2.0
     transitivePeerDependencies:
+      - bufferutil
       - supports-color
+      - utf-8-validate
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@tediousjs/connection-string@0.5.0': {}
+
+  '@tediousjs/connection-string@0.6.0': {}
+
+  '@tidbcloud/serverless@0.1.1': {}
+
+  '@tootallnate/once@1.1.2':
+    optional: true
 
   '@ts-morph/common@0.26.1':
     dependencies:
@@ -10941,7 +13129,7 @@ snapshots:
 
   '@tsconfig/bun@1.0.7': {}
 
-  '@tsconfig/node10@1.0.11': {}
+  '@tsconfig/node10@1.0.12': {}
 
   '@tsconfig/node12@1.0.11': {}
 
@@ -10949,71 +13137,182 @@ snapshots:
 
   '@tsconfig/node16@1.0.4': {}
 
+  '@tursodatabase/database-common@0.5.3':
+    optional: true
+
+  '@tursodatabase/database-common@0.6.0-pre.28': {}
+
+  '@tursodatabase/database-common@0.6.1': {}
+
+  '@tursodatabase/database-darwin-arm64@0.5.3':
+    optional: true
+
+  '@tursodatabase/database-darwin-arm64@0.6.0-pre.28':
+    optional: true
+
+  '@tursodatabase/database-linux-arm64-gnu@0.5.3':
+    optional: true
+
+  '@tursodatabase/database-linux-arm64-gnu@0.6.0-pre.28':
+    optional: true
+
+  '@tursodatabase/database-linux-x64-gnu@0.5.3':
+    optional: true
+
+  '@tursodatabase/database-linux-x64-gnu@0.6.0-pre.28':
+    optional: true
+
+  '@tursodatabase/database-wasm-common@0.5.3':
+    dependencies:
+      '@emnapi/core': 1.8.1
+      '@emnapi/runtime': 1.8.1
+      '@napi-rs/wasm-runtime': 1.0.7
+    optional: true
+
+  '@tursodatabase/database-wasm-common@0.6.0-pre.28':
+    dependencies:
+      '@emnapi/core': 1.8.1
+      '@emnapi/runtime': 1.8.1
+      '@napi-rs/wasm-runtime': 1.0.7
+
+  '@tursodatabase/database-wasm@0.5.3':
+    dependencies:
+      '@tursodatabase/database-common': 0.5.3
+      '@tursodatabase/database-wasm-common': 0.5.3
+    optional: true
+
+  '@tursodatabase/database-wasm@0.6.0-pre.28':
+    dependencies:
+      '@tursodatabase/database-common': 0.6.0-pre.28
+      '@tursodatabase/database-wasm-common': 0.6.0-pre.28
+
+  '@tursodatabase/database-win32-x64-msvc@0.5.3':
+    optional: true
+
+  '@tursodatabase/database-win32-x64-msvc@0.6.0-pre.28':
+    optional: true
+
+  '@tursodatabase/database@0.5.3':
+    dependencies:
+      '@tursodatabase/database-common': 0.5.3
+    optionalDependencies:
+      '@tursodatabase/database-darwin-arm64': 0.5.3
+      '@tursodatabase/database-linux-arm64-gnu': 0.5.3
+      '@tursodatabase/database-linux-x64-gnu': 0.5.3
+      '@tursodatabase/database-win32-x64-msvc': 0.5.3
+    optional: true
+
+  '@tursodatabase/database@0.6.0-pre.28':
+    dependencies:
+      '@tursodatabase/database-common': 0.6.0-pre.28
+    optionalDependencies:
+      '@tursodatabase/database-darwin-arm64': 0.6.0-pre.28
+      '@tursodatabase/database-linux-arm64-gnu': 0.6.0-pre.28
+      '@tursodatabase/database-linux-x64-gnu': 0.6.0-pre.28
+      '@tursodatabase/database-win32-x64-msvc': 0.6.0-pre.28
+
+  '@tursodatabase/serverless@0.2.4': {}
+
+  '@tursodatabase/serverless@1.1.3': {}
+
+  '@tursodatabase/serverless@1.2.0-pre.1': {}
+
+  '@tursodatabase/sync-common@0.6.1':
+    dependencies:
+      '@tursodatabase/database-common': 0.6.1
+      '@tursodatabase/serverless': 0.2.4
+
+  '@tursodatabase/sync-darwin-arm64@0.6.0':
+    optional: true
+
+  '@tursodatabase/sync-linux-arm64-gnu@0.6.0':
+    optional: true
+
+  '@tursodatabase/sync-linux-x64-gnu@0.6.0':
+    optional: true
+
+  '@tursodatabase/sync-win32-x64-msvc@0.6.0':
+    optional: true
+
+  '@tursodatabase/sync@0.6.0':
+    dependencies:
+      '@tursodatabase/database-common': 0.6.1
+      '@tursodatabase/sync-common': 0.6.1
+    optionalDependencies:
+      '@tursodatabase/sync-darwin-arm64': 0.6.0
+      '@tursodatabase/sync-linux-arm64-gnu': 0.6.0
+      '@tursodatabase/sync-linux-x64-gnu': 0.6.0
+      '@tursodatabase/sync-win32-x64-msvc': 0.6.0
+
+  '@tybys/wasm-util@0.10.1':
+    dependencies:
+      tslib: 2.8.1
+
   '@types/async-retry@1.4.9':
     dependencies:
       '@types/retry': 0.12.5
 
   '@types/babel__core@7.20.5':
     dependencies:
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
       '@types/babel__generator': 7.27.0
       '@types/babel__template': 7.4.4
-      '@types/babel__traverse': 7.20.7
+      '@types/babel__traverse': 7.28.0
 
   '@types/babel__generator@7.27.0':
     dependencies:
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
 
   '@types/babel__template@7.4.4':
     dependencies:
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
 
-  '@types/babel__traverse@7.20.7':
+  '@types/babel__traverse@7.28.0':
     dependencies:
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
 
   '@types/better-sqlite3@7.6.13':
     dependencies:
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
 
   '@types/braces@3.0.5': {}
 
-  '@types/chai@5.2.2':
+  '@types/bun@1.3.3':
+    dependencies:
+      bun-types: 1.3.3
+
+  '@types/chai@5.2.3':
     dependencies:
       '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
 
   '@types/deep-eql@4.0.2': {}
 
   '@types/docker-modem@3.0.6':
     dependencies:
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
       '@types/ssh2': 1.15.5
 
-  '@types/dockerode@3.3.39':
+  '@types/dockerode@3.3.47':
     dependencies:
       '@types/docker-modem': 3.0.6
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
       '@types/ssh2': 1.15.5
 
-  '@types/emscripten@1.40.1': {}
-
-  '@types/estree@1.0.7': {}
+  '@types/emscripten@1.41.5': {}
 
-  '@types/fs-extra@11.0.4':
-    dependencies:
-      '@types/jsonfile': 6.1.4
-      '@types/node': 18.19.110
+  '@types/estree@1.0.8': {}
 
   '@types/glob@8.1.0':
     dependencies:
       '@types/minimatch': 5.1.2
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
 
   '@types/graceful-fs@4.1.9':
     dependencies:
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
 
   '@types/istanbul-lib-coverage@2.0.6': {}
 
@@ -11025,79 +13324,96 @@ snapshots:
     dependencies:
       '@types/istanbul-lib-report': 3.0.3
 
+  '@types/jsesc@2.5.1': {}
+
   '@types/json-diff@1.0.3': {}
 
   '@types/json-schema@7.0.15': {}
 
-  '@types/json5@0.0.29': {}
-
-  '@types/jsonfile@6.1.4':
+  '@types/marked-terminal@3.1.3':
     dependencies:
-      '@types/node': 18.19.110
+      '@types/marked': 3.0.4
+      chalk: 2.4.2
 
-  '@types/micromatch@4.0.9':
+  '@types/marked@3.0.4': {}
+
+  '@types/micromatch@4.0.10':
     dependencies:
       '@types/braces': 3.0.5
 
   '@types/minimatch@5.1.2': {}
 
-  '@types/minimist@1.2.5': {}
+  '@types/mssql@9.1.8':
+    dependencies:
+      '@types/node': 24.10.1
+      tarn: 3.0.2
+      tedious: 19.1.3
+    transitivePeerDependencies:
+      - supports-color
 
-  '@types/node@18.19.110':
+  '@types/node@18.19.130':
     dependencies:
       undici-types: 5.26.5
 
-  '@types/node@20.17.57':
+  '@types/node@20.19.25':
     dependencies:
-      undici-types: 6.19.8
+      undici-types: 6.21.0
 
-  '@types/node@22.15.29':
+  '@types/node@22.19.1':
     dependencies:
       undici-types: 6.21.0
 
-  '@types/normalize-package-data@2.4.4': {}
+  '@types/node@24.10.1':
+    dependencies:
+      undici-types: 7.16.0
+
+  '@types/node@25.5.0':
+    dependencies:
+      undici-types: 7.18.2
 
   '@types/pg@8.11.6':
     dependencies:
-      '@types/node': 18.19.110
-      pg-protocol: 1.10.0
-      pg-types: 4.0.2
+      '@types/node': 24.10.1
+      pg-protocol: 1.10.3
+      pg-types: 4.1.0
 
-  '@types/pg@8.15.4':
+  '@types/pg@8.15.6':
     dependencies:
-      '@types/node': 18.19.110
-      pg-protocol: 1.10.0
+      '@types/node': 24.10.1
+      pg-protocol: 1.10.3
       pg-types: 2.2.0
 
   '@types/pg@8.6.6':
     dependencies:
-      '@types/node': 18.19.110
-      pg-protocol: 1.10.0
+      '@types/node': 24.10.1
+      pg-protocol: 1.13.0
       pg-types: 2.2.0
 
   '@types/pluralize@0.0.33': {}
 
-  '@types/prop-types@15.7.14': {}
+  '@types/prop-types@15.7.15': {}
 
-  '@types/ps-tree@1.1.6': {}
+  '@types/react@18.3.27':
+    dependencies:
+      '@types/prop-types': 15.7.15
+      csstype: 3.2.3
 
-  '@types/react@18.3.23':
+  '@types/readable-stream@4.0.22':
     dependencies:
-      '@types/prop-types': 15.7.14
-      csstype: 3.1.3
+      '@types/node': 24.10.1
 
   '@types/retry@0.12.5': {}
 
-  '@types/semver@7.7.0': {}
+  '@types/semver@7.7.1': {}
 
   '@types/sql.js@1.4.9':
     dependencies:
-      '@types/emscripten': 1.40.1
-      '@types/node': 20.17.57
+      '@types/emscripten': 1.41.5
+      '@types/node': 24.10.1
 
   '@types/ssh2@1.15.5':
     dependencies:
-      '@types/node': 18.19.110
+      '@types/node': 18.19.130
 
   '@types/stack-utils@2.0.3': {}
 
@@ -11105,247 +13421,85 @@ snapshots:
 
   '@types/uuid@9.0.8': {}
 
-  '@types/which@3.0.4': {}
+  '@types/validate-npm-package-name@4.0.2': {}
 
   '@types/ws@8.18.1':
     dependencies:
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
 
   '@types/yargs-parser@21.0.3': {}
 
-  '@types/yargs@17.0.33':
+  '@types/yargs@17.0.35':
     dependencies:
       '@types/yargs-parser': 21.0.3
 
-  '@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@eslint-community/regexpp': 4.12.1
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/type-utils': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.4.1
-      eslint: 8.57.1
-      graphemer: 1.4.0
-      ignore: 5.3.2
-      natural-compare: 1.4.0
-      semver: 7.7.2
-      ts-api-utils: 1.4.3(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/eslint-plugin@7.18.0(@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@eslint-community/regexpp': 4.12.1
-      '@typescript-eslint/parser': 7.18.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/scope-manager': 7.18.0
-      '@typescript-eslint/type-utils': 7.18.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.6.3)
-      '@typescript-eslint/visitor-keys': 7.18.0
-      eslint: 8.57.1
-      graphemer: 1.4.0
-      ignore: 5.3.2
-      natural-compare: 1.4.0
-      ts-api-utils: 1.4.3(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/experimental-utils@5.62.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@5.6.3)
-      eslint: 8.57.1
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-
-  '@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3)':
+  '@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/scope-manager': 6.21.0
       '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.6.3)
+      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
       '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.4.1
-      eslint: 8.57.1
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/scope-manager': 7.18.0
-      '@typescript-eslint/types': 7.18.0
-      '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.6.3)
-      '@typescript-eslint/visitor-keys': 7.18.0
-      debug: 4.4.1
+      debug: 4.4.3
       eslint: 8.57.1
     optionalDependencies:
-      typescript: 5.6.3
+      typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/rule-tester@6.21.0(@eslint/eslintrc@2.1.4)(eslint@8.57.1)(typescript@5.6.3)':
+  '@typescript-eslint/rule-tester@6.21.0(@eslint/eslintrc@2.1.4)(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
       '@eslint/eslintrc': 2.1.4
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.6.3)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
+      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
+      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
       ajv: 6.12.6
       eslint: 8.57.1
       lodash.merge: 4.6.2
-      semver: 7.7.2
+      semver: 7.7.3
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/scope-manager@5.62.0':
-    dependencies:
-      '@typescript-eslint/types': 5.62.0
-      '@typescript-eslint/visitor-keys': 5.62.0
-
   '@typescript-eslint/scope-manager@6.21.0':
     dependencies:
       '@typescript-eslint/types': 6.21.0
       '@typescript-eslint/visitor-keys': 6.21.0
 
-  '@typescript-eslint/scope-manager@7.18.0':
-    dependencies:
-      '@typescript-eslint/types': 7.18.0
-      '@typescript-eslint/visitor-keys': 7.18.0
-
-  '@typescript-eslint/type-utils@6.21.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.6.3)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-      debug: 4.4.1
-      eslint: 8.57.1
-      ts-api-utils: 1.4.3(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/type-utils@7.18.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.6.3)
-      '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.6.3)
-      debug: 4.4.1
-      eslint: 8.57.1
-      ts-api-utils: 1.4.3(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/types@5.62.0': {}
-
   '@typescript-eslint/types@6.21.0': {}
 
-  '@typescript-eslint/types@7.18.0': {}
-
-  '@typescript-eslint/typescript-estree@5.62.0(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/types': 5.62.0
-      '@typescript-eslint/visitor-keys': 5.62.0
-      debug: 4.4.1
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.7.2
-      tsutils: 3.21.0(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/typescript-estree@6.21.0(typescript@5.6.3)':
+  '@typescript-eslint/typescript-estree@6.21.0(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/types': 6.21.0
       '@typescript-eslint/visitor-keys': 6.21.0
-      debug: 4.4.1
+      debug: 4.4.3
       globby: 11.1.0
       is-glob: 4.0.3
       minimatch: 9.0.3
-      semver: 7.7.2
-      ts-api-utils: 1.4.3(typescript@5.6.3)
-    optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/typescript-estree@7.18.0(typescript@5.6.3)':
-    dependencies:
-      '@typescript-eslint/types': 7.18.0
-      '@typescript-eslint/visitor-keys': 7.18.0
-      debug: 4.4.1
-      globby: 11.1.0
-      is-glob: 4.0.3
-      minimatch: 9.0.5
-      semver: 7.7.2
-      ts-api-utils: 1.4.3(typescript@5.6.3)
+      semver: 7.7.4
+      ts-api-utils: 1.4.3(typescript@5.9.3)
     optionalDependencies:
-      typescript: 5.6.3
-    transitivePeerDependencies:
-      - supports-color
-
-  '@typescript-eslint/utils@5.62.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@eslint-community/eslint-utils': 4.7.0(eslint@8.57.1)
-      '@types/json-schema': 7.0.15
-      '@types/semver': 7.7.0
-      '@typescript-eslint/scope-manager': 5.62.0
-      '@typescript-eslint/types': 5.62.0
-      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.6.3)
-      eslint: 8.57.1
-      eslint-scope: 5.1.1
-      semver: 7.7.2
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-
-  '@typescript-eslint/utils@6.21.0(eslint@8.57.1)(typescript@5.6.3)':
-    dependencies:
-      '@eslint-community/eslint-utils': 4.7.0(eslint@8.57.1)
-      '@types/json-schema': 7.0.15
-      '@types/semver': 7.7.0
-      '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/types': 6.21.0
-      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.6.3)
-      eslint: 8.57.1
-      semver: 7.7.2
+      typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
-      - typescript
 
-  '@typescript-eslint/utils@7.18.0(eslint@8.57.1)(typescript@5.6.3)':
+  '@typescript-eslint/utils@6.21.0(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.7.0(eslint@8.57.1)
-      '@typescript-eslint/scope-manager': 7.18.0
-      '@typescript-eslint/types': 7.18.0
-      '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.6.3)
+      '@eslint-community/eslint-utils': 4.9.0(eslint@8.57.1)
+      '@types/json-schema': 7.0.15
+      '@types/semver': 7.7.1
+      '@typescript-eslint/scope-manager': 6.21.0
+      '@typescript-eslint/types': 6.21.0
+      '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
       eslint: 8.57.1
+      semver: 7.7.3
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/visitor-keys@5.62.0':
-    dependencies:
-      '@typescript-eslint/types': 5.62.0
-      eslint-visitor-keys: 3.4.3
-
   '@typescript-eslint/visitor-keys@6.21.0':
     dependencies:
       '@typescript-eslint/types': 6.21.0
       eslint-visitor-keys: 3.4.3
 
-  '@typescript-eslint/visitor-keys@7.18.0':
-    dependencies:
-      '@typescript-eslint/types': 7.18.0
-      eslint-visitor-keys: 3.4.3
-
   '@typescript/analyze-trace@0.10.1':
     dependencies:
       chalk: 4.1.2
@@ -11357,29 +13511,37 @@ snapshots:
       treeify: 1.1.0
       yargs: 16.2.0
 
-  '@typescript/vfs@1.6.1(typescript@5.6.3)':
+  '@typescript/vfs@1.6.1(typescript@5.9.3)':
+    dependencies:
+      debug: 4.4.3
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typespec/ts-http-runtime@0.3.2':
     dependencies:
-      debug: 4.4.1
-      typescript: 5.6.3
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      tslib: 2.8.1
     transitivePeerDependencies:
       - supports-color
 
   '@ungap/structured-clone@1.3.0': {}
 
-  '@upstash/redis@1.35.0':
+  '@upstash/redis@1.35.7':
     dependencies:
       uncrypto: 0.1.3
 
-  '@urql/core@5.1.1':
+  '@urql/core@5.2.0':
     dependencies:
-      '@0no-co/graphql.web': 1.1.2
+      '@0no-co/graphql.web': 1.2.0
       wonka: 6.3.5
     transitivePeerDependencies:
       - graphql
 
-  '@urql/exchange-retry@1.3.1(@urql/core@5.1.1)':
+  '@urql/exchange-retry@1.3.2(@urql/core@5.2.0)':
     dependencies:
-      '@urql/core': 5.1.1
+      '@urql/core': 5.2.0
       wonka: 6.3.5
 
   '@vercel/postgres@0.8.0':
@@ -11389,102 +13551,90 @@ snapshots:
       utf-8-validate: 6.0.3
       ws: 8.14.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
 
-  '@vitest/expect@3.2.0':
+  '@vitest/expect@2.1.9':
     dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      tinyrainbow: 2.0.0
+      '@vitest/spy': 2.1.9
+      '@vitest/utils': 2.1.9
+      chai: 5.3.3
+      tinyrainbow: 1.2.0
 
-  '@vitest/mocker@3.2.0(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))':
+  '@vitest/expect@4.0.13':
     dependencies:
-      '@vitest/spy': 3.2.0
-      estree-walker: 3.0.3
-      magic-string: 0.30.17
-    optionalDependencies:
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.0.13
+      '@vitest/utils': 4.0.13
+      chai: 6.2.1
+      tinyrainbow: 3.0.3
 
-  '@vitest/mocker@3.2.0(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))':
+  '@vitest/mocker@2.1.9(vite@5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1))':
     dependencies:
-      '@vitest/spy': 3.2.0
+      '@vitest/spy': 2.1.9
       estree-walker: 3.0.3
-      magic-string: 0.30.17
+      magic-string: 0.30.21
     optionalDependencies:
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      vite: 5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1)
 
-  '@vitest/mocker@3.2.0(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))':
+  '@vitest/mocker@4.0.13(vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))':
     dependencies:
-      '@vitest/spy': 3.2.0
+      '@vitest/spy': 4.0.13
       estree-walker: 3.0.3
-      magic-string: 0.30.17
+      magic-string: 0.30.21
     optionalDependencies:
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
+      vite: 7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
 
-  '@vitest/mocker@3.2.0(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))':
+  '@vitest/pretty-format@2.1.9':
     dependencies:
-      '@vitest/spy': 3.2.0
-      estree-walker: 3.0.3
-      magic-string: 0.30.17
-    optionalDependencies:
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      tinyrainbow: 1.2.0
 
-  '@vitest/mocker@3.2.0(vite@6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))':
+  '@vitest/pretty-format@4.0.13':
     dependencies:
-      '@vitest/spy': 3.2.0
-      estree-walker: 3.0.3
-      magic-string: 0.30.17
-    optionalDependencies:
-      vite: 6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      tinyrainbow: 3.0.3
 
-  '@vitest/pretty-format@3.2.0':
+  '@vitest/runner@2.1.9':
     dependencies:
-      tinyrainbow: 2.0.0
+      '@vitest/utils': 2.1.9
+      pathe: 1.1.2
 
-  '@vitest/runner@3.2.0':
+  '@vitest/runner@4.0.13':
     dependencies:
-      '@vitest/utils': 3.2.0
+      '@vitest/utils': 4.0.13
       pathe: 2.0.3
 
-  '@vitest/snapshot@3.2.0':
+  '@vitest/snapshot@2.1.9':
     dependencies:
-      '@vitest/pretty-format': 3.2.0
-      magic-string: 0.30.17
-      pathe: 2.0.3
+      '@vitest/pretty-format': 2.1.9
+      magic-string: 0.30.21
+      pathe: 1.1.2
 
-  '@vitest/spy@3.2.0':
+  '@vitest/snapshot@4.0.13':
     dependencies:
-      tinyspy: 4.0.3
+      '@vitest/pretty-format': 4.0.13
+      magic-string: 0.30.21
+      pathe: 2.0.3
 
-  '@vitest/ui@1.6.1(vitest@3.2.0)':
+  '@vitest/spy@2.1.9':
     dependencies:
-      '@vitest/utils': 1.6.1
-      fast-glob: 3.3.3
-      fflate: 0.8.2
-      flatted: 3.3.3
-      pathe: 1.1.2
-      picocolors: 1.1.1
-      sirv: 2.0.4
-      vitest: 3.2.0(@types/node@20.17.57)(@vitest/ui@1.6.1)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      tinyspy: 3.0.2
+
+  '@vitest/spy@4.0.13': {}
 
-  '@vitest/utils@1.6.1':
+  '@vitest/utils@2.1.9':
     dependencies:
-      diff-sequences: 29.6.3
-      estree-walker: 3.0.3
-      loupe: 2.3.7
-      pretty-format: 29.7.0
+      '@vitest/pretty-format': 2.1.9
+      loupe: 3.2.1
+      tinyrainbow: 1.2.0
 
-  '@vitest/utils@3.2.0':
+  '@vitest/utils@4.0.13':
     dependencies:
-      '@vitest/pretty-format': 3.2.0
-      loupe: 3.1.3
-      tinyrainbow: 2.0.0
+      '@vitest/pretty-format': 4.0.13
+      tinyrainbow: 3.0.3
 
-  '@xata.io/client@0.29.5(typescript@5.6.3)':
+  '@xata.io/client@0.29.5(typescript@5.9.3)':
     dependencies:
-      typescript: 5.6.3
+      typescript: 5.9.3
 
-  '@xmldom/xmldom@0.8.10': {}
+  '@xmldom/xmldom@0.8.11': {}
 
   abbrev@1.1.1:
     optional: true
@@ -11500,31 +13650,31 @@ snapshots:
 
   accepts@2.0.0:
     dependencies:
-      mime-types: 3.0.1
+      mime-types: 3.0.2
       negotiator: 1.0.0
 
-  acorn-import-attributes@1.9.5(acorn@8.14.1):
+  acorn-import-attributes@1.9.5(acorn@8.15.0):
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
-  acorn-jsx@5.3.2(acorn@8.14.1):
+  acorn-jsx@5.3.2(acorn@8.15.0):
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
   acorn-walk@8.3.4:
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
 
-  acorn@8.14.1: {}
+  acorn@8.15.0: {}
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
     optional: true
 
-  agent-base@7.1.3: {}
+  agent-base@7.1.4: {}
 
   agentkeepalive@4.6.0:
     dependencies:
@@ -11542,6 +13692,10 @@ snapshots:
       clean-stack: 4.2.0
       indent-string: 5.0.0
 
+  ajv-formats@3.0.1(ajv@8.20.0):
+    optionalDependencies:
+      ajv: 8.20.0
+
   ajv@6.12.6:
     dependencies:
       fast-deep-equal: 3.1.3
@@ -11549,6 +13703,13 @@ snapshots:
       json-schema-traverse: 0.4.1
       uri-js: 4.4.1
 
+  ajv@8.20.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-uri: 3.1.2
+      json-schema-traverse: 1.0.0
+      require-from-string: 2.0.2
+
   anser@1.4.10: {}
 
   ansi-colors@4.1.3: {}
@@ -11557,9 +13718,7 @@ snapshots:
     dependencies:
       type-fest: 0.21.3
 
-  ansi-escapes@6.2.1: {}
-
-  ansi-escapes@7.0.0:
+  ansi-escapes@7.2.0:
     dependencies:
       environment: 1.1.0
 
@@ -11567,7 +13726,7 @@ snapshots:
 
   ansi-regex@5.0.1: {}
 
-  ansi-regex@6.1.0: {}
+  ansi-regex@6.2.2: {}
 
   ansi-styles@3.2.1:
     dependencies:
@@ -11579,9 +13738,9 @@ snapshots:
 
   ansi-styles@5.2.0: {}
 
-  ansi-styles@6.2.1: {}
+  ansi-styles@6.2.3: {}
 
-  ansicolors@0.3.2: {}
+  ansis@4.2.0: {}
 
   any-promise@1.3.0: {}
 
@@ -11590,7 +13749,7 @@ snapshots:
       normalize-path: 3.0.0
       picomatch: 2.3.1
 
-  aproba@2.0.0:
+  aproba@2.1.0:
     optional: true
 
   are-we-there-yet@3.0.1:
@@ -11611,69 +13770,34 @@ snapshots:
 
   argsarray@0.0.1: {}
 
-  arktype@2.1.19:
+  arkregex@0.0.4:
+    dependencies:
+      '@ark/util': 0.56.0
+
+  arkregex@0.0.5:
     dependencies:
-      '@ark/schema': 0.45.9
-      '@ark/util': 0.45.9
+      '@ark/util': 0.56.0
 
   arktype@2.1.20:
     dependencies:
       '@ark/schema': 0.46.0
       '@ark/util': 0.46.0
 
-  array-buffer-byte-length@1.0.2:
-    dependencies:
-      call-bound: 1.0.4
-      is-array-buffer: 3.0.5
-
-  array-find-index@1.0.2: {}
-
-  array-includes@3.1.9:
+  arktype@2.1.28:
     dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
-      get-intrinsic: 1.3.0
-      is-string: 1.1.1
-      math-intrinsics: 1.1.0
-
-  array-union@2.1.0: {}
-
-  array.prototype.findlastindex@1.2.6:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-errors: 1.3.0
-      es-object-atoms: 1.1.1
-      es-shim-unscopables: 1.1.0
+      '@ark/schema': 0.56.0
+      '@ark/util': 0.56.0
+      arkregex: 0.0.4
 
-  array.prototype.flat@1.3.3:
+  arktype@2.2.0:
     dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-shim-unscopables: 1.1.0
+      '@ark/schema': 0.56.0
+      '@ark/util': 0.56.0
+      arkregex: 0.0.5
 
-  array.prototype.flatmap@1.3.3:
-    dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-shim-unscopables: 1.1.0
+  array-find-index@1.0.2: {}
 
-  arraybuffer.prototype.slice@1.0.4:
-    dependencies:
-      array-buffer-byte-length: 1.0.2
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-errors: 1.3.0
-      get-intrinsic: 1.3.0
-      is-array-buffer: 3.0.5
+  array-union@2.1.0: {}
 
   arrgv@1.0.2: {}
 
@@ -11687,12 +13811,16 @@ snapshots:
 
   assertion-error@2.0.1: {}
 
+  ast-kit@3.0.0-beta.1:
+    dependencies:
+      '@babel/parser': 8.0.0-rc.2
+      estree-walker: 3.0.3
+      pathe: 2.0.3
+
   ast-types@0.16.1:
     dependencies:
       tslib: 2.8.1
 
-  async-function@1.0.0: {}
-
   async-limiter@1.0.1: {}
 
   async-retry@1.3.3:
@@ -11701,14 +13829,14 @@ snapshots:
 
   ava@5.3.1:
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
       acorn-walk: 8.3.4
-      ansi-styles: 6.2.1
+      ansi-styles: 6.2.3
       arrgv: 1.0.2
       arrify: 3.0.0
       callsites: 4.2.0
       cbor: 8.1.0
-      chalk: 5.4.1
+      chalk: 5.6.2
       chokidar: 3.6.0
       chunkd: 2.0.1
       ci-info: 3.9.0
@@ -11719,8 +13847,8 @@ snapshots:
       common-path-prefix: 3.0.0
       concordance: 5.0.4
       currently-unhandled: 0.4.1
-      debug: 4.4.1
-      emittery: 1.1.0
+      debug: 4.4.3
+      emittery: 1.2.0
       figures: 5.0.0
       globby: 13.2.2
       ignore-by-default: 2.1.0
@@ -11739,7 +13867,7 @@ snapshots:
       pretty-ms: 8.0.0
       resolve-cwd: 3.0.0
       stack-utils: 2.0.6
-      strip-ansi: 7.1.0
+      strip-ansi: 7.1.2
       supertap: 3.0.1
       temp-dir: 3.0.0
       write-file-atomic: 5.0.1
@@ -11768,13 +13896,13 @@ snapshots:
 
   aws4fetch@1.0.18: {}
 
-  babel-jest@29.7.0(@babel/core@7.27.4):
+  babel-jest@29.7.0(@babel/core@7.28.5):
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       '@jest/transform': 29.7.0
       '@types/babel__core': 7.20.5
       babel-plugin-istanbul: 6.1.1
-      babel-preset-jest: 29.6.3(@babel/core@7.27.4)
+      babel-preset-jest: 29.6.3(@babel/core@7.28.5)
       chalk: 4.1.2
       graceful-fs: 4.2.11
       slash: 3.0.0
@@ -11794,102 +13922,183 @@ snapshots:
   babel-plugin-jest-hoist@29.6.3:
     dependencies:
       '@babel/template': 7.27.2
-      '@babel/types': 7.27.3
+      '@babel/types': 7.28.5
       '@types/babel__core': 7.20.5
-      '@types/babel__traverse': 7.20.7
+      '@types/babel__traverse': 7.28.0
 
-  babel-plugin-polyfill-corejs2@0.4.13(@babel/core@7.27.4):
+  babel-plugin-polyfill-corejs2@0.4.14(@babel/core@7.28.5):
     dependencies:
-      '@babel/compat-data': 7.27.3
-      '@babel/core': 7.27.4
-      '@babel/helper-define-polyfill-provider': 0.6.4(@babel/core@7.27.4)
+      '@babel/compat-data': 7.28.5
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-polyfill-corejs3@0.11.1(@babel/core@7.27.4):
+  babel-plugin-polyfill-corejs3@0.13.0(@babel/core@7.28.5):
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-define-polyfill-provider': 0.6.4(@babel/core@7.27.4)
-      core-js-compat: 3.42.0
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
+      core-js-compat: 3.47.0
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-polyfill-regenerator@0.6.4(@babel/core@7.27.4):
+  babel-plugin-polyfill-regenerator@0.6.5(@babel/core@7.28.5):
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/helper-define-polyfill-provider': 0.6.4(@babel/core@7.27.4)
+      '@babel/core': 7.28.5
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.5)
     transitivePeerDependencies:
       - supports-color
 
-  babel-plugin-react-native-web@0.19.13: {}
+  babel-plugin-react-compiler@1.0.0:
+    dependencies:
+      '@babel/types': 7.28.5
+
+  babel-plugin-react-native-web@0.21.2: {}
+
+  babel-plugin-syntax-hermes-parser@0.29.1:
+    dependencies:
+      hermes-parser: 0.29.1
+
+  babel-plugin-syntax-hermes-parser@0.32.0:
+    dependencies:
+      hermes-parser: 0.32.0
+
+  babel-plugin-transform-flow-enums@0.0.2(@babel/core@7.28.5):
+    dependencies:
+      '@babel/plugin-syntax-flow': 7.27.1(@babel/core@7.28.5)
+    transitivePeerDependencies:
+      - '@babel/core'
 
-  babel-plugin-syntax-hermes-parser@0.25.1:
+  babel-preset-current-node-syntax@1.2.0(@babel/core@7.28.5):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.28.5)
+      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.28.5)
+      '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.28.5)
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.5)
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.28.5)
+      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.28.5)
+
+  babel-preset-expo@54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2):
     dependencies:
-      hermes-parser: 0.25.1
+      '@babel/helper-module-imports': 7.27.1
+      '@babel/plugin-proposal-decorators': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-class-static-block': 7.28.3(@babel/core@7.28.5)
+      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-react': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-typescript': 7.28.5(@babel/core@7.28.5)
+      '@react-native/babel-preset': 0.81.5(@babel/core@7.28.5)
+      babel-plugin-react-compiler: 1.0.0
+      babel-plugin-react-native-web: 0.21.2
+      babel-plugin-syntax-hermes-parser: 0.29.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
+      debug: 4.4.3
+      react-refresh: 0.14.2
+      resolve-from: 5.0.0
+    optionalDependencies:
+      '@babel/runtime': 7.28.4
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - '@babel/core'
+      - supports-color
 
-  babel-plugin-transform-flow-enums@0.0.2(@babel/core@7.27.4):
+  babel-preset-expo@54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2):
     dependencies:
-      '@babel/plugin-syntax-flow': 7.27.1(@babel/core@7.27.4)
+      '@babel/helper-module-imports': 7.27.1
+      '@babel/plugin-proposal-decorators': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-class-static-block': 7.28.3(@babel/core@7.28.5)
+      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-react': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-typescript': 7.28.5(@babel/core@7.28.5)
+      '@react-native/babel-preset': 0.81.5(@babel/core@7.28.5)
+      babel-plugin-react-compiler: 1.0.0
+      babel-plugin-react-native-web: 0.21.2
+      babel-plugin-syntax-hermes-parser: 0.29.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
+      debug: 4.4.3
+      react-refresh: 0.14.2
+      resolve-from: 5.0.0
+    optionalDependencies:
+      '@babel/runtime': 7.28.4
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - '@babel/core'
+      - supports-color
+    optional: true
 
-  babel-preset-current-node-syntax@1.1.0(@babel/core@7.27.4):
-    dependencies:
-      '@babel/core': 7.27.4
-      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.27.4)
-      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.27.4)
-      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.27.4)
-      '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.27.4)
-      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.27.4)
-      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.27.4)
-      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.27.4)
-      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.27.4)
-      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.27.4)
-
-  babel-preset-expo@13.1.11(@babel/core@7.27.4):
+  babel-preset-expo@54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2):
     dependencies:
       '@babel/helper-module-imports': 7.27.1
-      '@babel/plugin-proposal-decorators': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-object-rest-spread': 7.27.3(@babel/core@7.27.4)
-      '@babel/plugin-transform-parameters': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.27.4)
-      '@babel/plugin-transform-runtime': 7.27.4(@babel/core@7.27.4)
-      '@babel/preset-react': 7.27.1(@babel/core@7.27.4)
-      '@babel/preset-typescript': 7.27.1(@babel/core@7.27.4)
-      '@react-native/babel-preset': 0.79.2(@babel/core@7.27.4)
-      babel-plugin-react-native-web: 0.19.13
-      babel-plugin-syntax-hermes-parser: 0.25.1
-      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.27.4)
-      debug: 4.4.1
+      '@babel/plugin-proposal-decorators': 7.28.0(@babel/core@7.28.5)
+      '@babel/plugin-proposal-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-syntax-export-default-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-class-static-block': 7.28.3(@babel/core@7.28.5)
+      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-flow-strip-types': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-object-rest-spread': 7.28.4(@babel/core@7.28.5)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.28.5)
+      '@babel/plugin-transform-runtime': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-react': 7.28.5(@babel/core@7.28.5)
+      '@babel/preset-typescript': 7.28.5(@babel/core@7.28.5)
+      '@react-native/babel-preset': 0.81.5(@babel/core@7.28.5)
+      babel-plugin-react-compiler: 1.0.0
+      babel-plugin-react-native-web: 0.21.2
+      babel-plugin-syntax-hermes-parser: 0.29.1
+      babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.28.5)
+      debug: 4.4.3
       react-refresh: 0.14.2
       resolve-from: 5.0.0
+    optionalDependencies:
+      '@babel/runtime': 7.28.4
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - '@babel/core'
       - supports-color
+    optional: true
 
-  babel-preset-jest@29.6.3(@babel/core@7.27.4):
+  babel-preset-jest@29.6.3(@babel/core@7.28.5):
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       babel-plugin-jest-hoist: 29.6.3
-      babel-preset-current-node-syntax: 1.1.0(@babel/core@7.27.4)
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.5)
 
   balanced-match@1.0.2: {}
 
   base64-js@1.5.1: {}
 
+  baseline-browser-mapping@2.8.31: {}
+
   bcrypt-pbkdf@1.0.2:
     dependencies:
       tweetnacl: 0.14.5
@@ -11903,6 +14112,11 @@ snapshots:
       bindings: 1.5.0
       prebuild-install: 7.1.3
 
+  better-sqlite3@12.10.0:
+    dependencies:
+      bindings: 1.5.0
+      prebuild-install: 7.1.3
+
   big-integer@1.6.52: {}
 
   binary-extensions@2.3.0: {}
@@ -11911,29 +14125,38 @@ snapshots:
     dependencies:
       file-uri-to-path: 1.0.0
 
+  birpc@4.0.0: {}
+
   bl@4.1.0:
     dependencies:
       buffer: 5.7.1
       inherits: 2.0.4
       readable-stream: 3.6.2
 
+  bl@6.1.5:
+    dependencies:
+      '@types/readable-stream': 4.0.22
+      buffer: 6.0.3
+      inherits: 2.0.4
+      readable-stream: 4.7.0
+
   blueimp-md5@2.19.0: {}
 
-  body-parser@2.2.0:
+  body-parser@2.2.1:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
-      debug: 4.4.1
-      http-errors: 2.0.0
-      iconv-lite: 0.6.3
+      debug: 4.4.3
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
       on-finished: 2.4.1
       qs: 6.14.0
-      raw-body: 3.0.0
+      raw-body: 3.0.2
       type-is: 2.0.1
     transitivePeerDependencies:
       - supports-color
 
-  bowser@2.11.0: {}
+  bowser@2.13.0: {}
 
   bplist-creator@0.1.0:
     dependencies:
@@ -11947,12 +14170,12 @@ snapshots:
     dependencies:
       big-integer: 1.6.52
 
-  brace-expansion@1.1.11:
+  brace-expansion@1.1.12:
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
 
-  brace-expansion@2.0.1:
+  brace-expansion@2.0.2:
     dependencies:
       balanced-match: 1.0.2
 
@@ -11960,17 +14183,20 @@ snapshots:
     dependencies:
       fill-range: 7.1.1
 
-  browserslist@4.25.0:
+  browserslist@4.28.0:
     dependencies:
-      caniuse-lite: 1.0.30001720
-      electron-to-chromium: 1.5.162
-      node-releases: 2.0.19
-      update-browserslist-db: 1.1.3(browserslist@4.25.0)
+      baseline-browser-mapping: 2.8.31
+      caniuse-lite: 1.0.30001757
+      electron-to-chromium: 1.5.260
+      node-releases: 2.0.27
+      update-browserslist-db: 1.1.4(browserslist@4.28.0)
 
   bser@2.1.1:
     dependencies:
       node-int64: 0.4.0
 
+  buffer-equal-constant-time@1.0.1: {}
+
   buffer-from@1.1.2: {}
 
   buffer@4.9.2:
@@ -11993,24 +14219,24 @@ snapshots:
     dependencies:
       node-gyp-build: 4.8.4
 
-  buildcheck@0.0.6:
+  buildcheck@0.0.7:
     optional: true
 
-  builtin-modules@3.3.0: {}
-
   builtins@5.1.0:
     dependencies:
-      semver: 7.7.2
+      semver: 7.7.4
 
-  bun-types@0.6.14: {}
+  bun-types@1.3.3:
+    dependencies:
+      '@types/node': 24.10.1
 
-  bun-types@1.2.15:
+  bundle-name@4.1.0:
     dependencies:
-      '@types/node': 20.17.57
+      run-applescript: 7.1.0
 
-  bundle-require@5.1.0(esbuild@0.25.5):
+  bundle-require@5.1.0(esbuild@0.27.0):
     dependencies:
-      esbuild: 0.25.5
+      esbuild: 0.27.0
       load-tsconfig: 0.2.5
 
   busboy@1.6.0:
@@ -12062,16 +14288,6 @@ snapshots:
       call-bind-apply-helpers: 1.0.2
       get-intrinsic: 1.3.0
 
-  caller-callsite@2.0.0:
-    dependencies:
-      callsites: 2.0.0
-
-  caller-path@2.0.0:
-    dependencies:
-      caller-callsite: 2.0.0
-
-  callsites@2.0.0: {}
-
   callsites@3.1.0: {}
 
   callsites@4.2.0: {}
@@ -12082,24 +14298,21 @@ snapshots:
 
   camelcase@7.0.1: {}
 
-  caniuse-lite@1.0.30001720: {}
-
-  cardinal@2.1.1:
-    dependencies:
-      ansicolors: 0.3.2
-      redeyed: 2.1.1
+  caniuse-lite@1.0.30001757: {}
 
   cbor@8.1.0:
     dependencies:
       nofilter: 3.1.0
 
-  chai@5.2.0:
+  chai@5.3.3:
     dependencies:
       assertion-error: 2.0.1
       check-error: 2.1.1
       deep-eql: 5.0.2
-      loupe: 3.1.3
-      pathval: 2.0.0
+      loupe: 3.2.1
+      pathval: 2.0.1
+
+  chai@6.2.1: {}
 
   chalk@2.4.2:
     dependencies:
@@ -12112,7 +14325,7 @@ snapshots:
       ansi-styles: 4.3.0
       supports-color: 7.2.0
 
-  chalk@5.4.1: {}
+  chalk@5.6.2: {}
 
   char-regex@1.0.2: {}
 
@@ -12142,7 +14355,7 @@ snapshots:
 
   chrome-launcher@0.15.2:
     dependencies:
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       escape-string-regexp: 4.0.0
       is-wsl: 2.2.0
       lighthouse-logger: 1.4.2
@@ -12151,7 +14364,7 @@ snapshots:
 
   chromium-edge-launcher@0.2.0:
     dependencies:
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       escape-string-regexp: 4.0.0
       is-wsl: 2.2.0
       lighthouse-logger: 1.4.2
@@ -12170,10 +14383,6 @@ snapshots:
 
   cjs-module-lexer@1.4.3: {}
 
-  clean-regexp@1.0.0:
-    dependencies:
-      escape-string-regexp: 1.0.5
-
   clean-stack@2.2.0:
     optional: true
 
@@ -12183,18 +14392,14 @@ snapshots:
 
   clean-yaml-object@0.1.0: {}
 
-  cli-color@2.0.4:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-      es6-iterator: 2.0.3
-      memoizee: 0.4.17
-      timers-ext: 0.1.8
-
   cli-cursor@2.1.0:
     dependencies:
       restore-cursor: 2.0.0
 
+  cli-cursor@5.0.0:
+    dependencies:
+      restore-cursor: 5.1.0
+
   cli-highlight@2.1.11:
     dependencies:
       chalk: 4.1.2
@@ -12217,6 +14422,11 @@ snapshots:
       slice-ansi: 5.0.0
       string-width: 5.1.2
 
+  cli-truncate@5.1.1:
+    dependencies:
+      slice-ansi: 7.1.2
+      string-width: 8.1.0
+
   cliui@7.0.4:
     dependencies:
       string-width: 4.2.3
@@ -12254,35 +14464,37 @@ snapshots:
   color-support@1.1.3:
     optional: true
 
-  colorette@2.0.19: {}
+  colorette@2.0.20: {}
 
   colors@1.4.0: {}
 
   commander@10.0.1: {}
 
+  commander@11.1.0: {}
+
   commander@12.1.0: {}
 
+  commander@14.0.2: {}
+
   commander@2.20.3: {}
 
   commander@4.1.1: {}
 
   commander@7.2.0: {}
 
-  commander@9.5.0: {}
-
   common-path-prefix@3.0.0: {}
 
   compressible@2.0.18:
     dependencies:
       mime-db: 1.54.0
 
-  compression@1.8.0:
+  compression@1.8.1:
     dependencies:
       bytes: 3.1.2
       compressible: 2.0.18
       debug: 2.6.9
       negotiator: 0.6.4
-      on-headers: 1.0.2
+      on-headers: 1.1.0
       safe-buffer: 5.2.1
       vary: 1.1.2
     transitivePeerDependencies:
@@ -12298,7 +14510,7 @@ snapshots:
       js-string-escape: 1.0.1
       lodash: 4.17.21
       md5-hex: 3.0.1
-      semver: 7.7.2
+      semver: 7.7.3
       well-known-symbols: 2.0.0
 
   concurrently@8.2.2:
@@ -12329,9 +14541,7 @@ snapshots:
   console-control-strings@1.1.0:
     optional: true
 
-  content-disposition@1.0.0:
-    dependencies:
-      safe-buffer: 5.2.1
+  content-disposition@1.0.1: {}
 
   content-type@1.0.5: {}
 
@@ -12343,31 +14553,20 @@ snapshots:
 
   cookie@0.7.2: {}
 
-  copy-anything@3.0.5:
-    dependencies:
-      is-what: 4.1.16
-
-  copy-file@11.0.0:
+  copy-file@11.1.0:
     dependencies:
       graceful-fs: 4.2.11
       p-event: 6.0.1
 
-  core-js-compat@3.42.0:
+  core-js-compat@3.47.0:
     dependencies:
-      browserslist: 4.25.0
+      browserslist: 4.28.0
 
   cors@2.8.5:
     dependencies:
       object-assign: 4.1.1
       vary: 1.1.2
 
-  cosmiconfig@5.2.1:
-    dependencies:
-      import-fresh: 2.0.0
-      is-directory: 0.3.1
-      js-yaml: 3.14.1
-      parse-json: 4.0.0
-
   cp-file@10.0.0:
     dependencies:
       graceful-fs: 4.2.11
@@ -12376,8 +14575,8 @@ snapshots:
 
   cpu-features@0.0.10:
     dependencies:
-      buildcheck: 0.0.6
-      nan: 2.22.2
+      buildcheck: 0.0.7
+      nan: 2.23.1
     optional: true
 
   cpy-cli@5.0.0:
@@ -12398,12 +14597,12 @@ snapshots:
 
   cpy@11.1.0:
     dependencies:
-      copy-file: 11.0.0
+      copy-file: 11.1.0
       globby: 14.1.0
       junk: 4.0.1
       micromatch: 4.0.8
       p-filter: 4.1.0
-      p-map: 7.0.3
+      p-map: 7.0.4
 
   create-require@1.1.1: {}
 
@@ -12419,40 +14618,17 @@ snapshots:
 
   crypto-random-string@2.0.0: {}
 
-  csstype@3.1.3: {}
+  csstype@3.2.3: {}
 
   currently-unhandled@0.4.1:
     dependencies:
       array-find-index: 1.0.2
 
-  d@1.0.2:
-    dependencies:
-      es5-ext: 0.10.64
-      type: 2.7.3
-
   data-uri-to-buffer@4.0.1: {}
 
-  data-view-buffer@1.0.2:
-    dependencies:
-      call-bound: 1.0.4
-      es-errors: 1.3.0
-      is-data-view: 1.0.2
-
-  data-view-byte-length@1.0.2:
-    dependencies:
-      call-bound: 1.0.4
-      es-errors: 1.3.0
-      is-data-view: 1.0.2
-
-  data-view-byte-offset@1.0.1:
-    dependencies:
-      call-bound: 1.0.4
-      es-errors: 1.3.0
-      is-data-view: 1.0.2
-
   date-fns@2.30.0:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
 
   date-time@3.1.0:
     dependencies:
@@ -12466,11 +14642,11 @@ snapshots:
     dependencies:
       ms: 2.1.3
 
-  debug@4.3.4:
+  debug@4.3.7:
     dependencies:
-      ms: 2.1.2
+      ms: 2.1.3
 
-  debug@4.4.1:
+  debug@4.4.3:
     dependencies:
       ms: 2.1.3
 
@@ -12486,6 +14662,13 @@ snapshots:
 
   deepmerge@4.3.1: {}
 
+  default-browser-id@5.0.1: {}
+
+  default-browser@5.4.0:
+    dependencies:
+      bundle-name: 4.1.0
+      default-browser-id: 5.0.1
+
   defaults@1.0.4:
     dependencies:
       clone: 1.0.4
@@ -12498,11 +14681,9 @@ snapshots:
 
   define-lazy-prop@2.0.0: {}
 
-  define-properties@1.2.1:
-    dependencies:
-      define-data-property: 1.1.4
-      has-property-descriptors: 1.0.2
-      object-keys: 1.1.1
+  define-lazy-prop@3.0.0: {}
+
+  defu@6.1.4: {}
 
   delegates@1.0.0:
     optional: true
@@ -12515,178 +14696,208 @@ snapshots:
 
   destroy@1.2.0: {}
 
-  detect-libc@1.0.3: {}
-
   detect-libc@2.0.2: {}
 
-  detect-libc@2.0.4: {}
-
-  diff-sequences@29.6.3: {}
+  detect-libc@2.1.2: {}
 
   diff@4.0.2: {}
 
   diff@5.2.0: {}
 
-  difflib@0.2.4:
-    dependencies:
-      heap: 0.2.7
-
   dir-glob@3.0.1:
     dependencies:
       path-type: 4.0.0
 
   docker-modem@5.0.6:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       readable-stream: 3.6.2
       split-ca: 1.0.1
-      ssh2: 1.16.0
+      ssh2: 1.17.0
     transitivePeerDependencies:
       - supports-color
 
-  dockerode@4.0.6:
+  dockerode@4.0.9:
     dependencies:
       '@balena/dockerignore': 1.0.2
-      '@grpc/grpc-js': 1.13.4
+      '@grpc/grpc-js': 1.14.1
       '@grpc/proto-loader': 0.7.15
       docker-modem: 5.0.6
-      protobufjs: 7.5.3
-      tar-fs: 2.1.3
+      protobufjs: 7.5.4
+      tar-fs: 2.1.4
       uuid: 10.0.0
     transitivePeerDependencies:
       - supports-color
 
-  doctrine@2.1.0:
-    dependencies:
-      esutils: 2.0.3
-
   doctrine@3.0.0:
     dependencies:
       esutils: 2.0.3
 
   dotenv-expand@11.0.7:
     dependencies:
-      dotenv: 16.5.0
+      dotenv: 16.6.1
 
   dotenv@10.0.0: {}
 
   dotenv@16.4.7: {}
 
-  dotenv@16.5.0: {}
+  dotenv@16.6.1: {}
 
-  dprint@0.46.3:
+  dprint@0.50.2:
     optionalDependencies:
-      '@dprint/darwin-arm64': 0.46.3
-      '@dprint/darwin-x64': 0.46.3
-      '@dprint/linux-arm64-glibc': 0.46.3
-      '@dprint/linux-arm64-musl': 0.46.3
-      '@dprint/linux-x64-glibc': 0.46.3
-      '@dprint/linux-x64-musl': 0.46.3
-      '@dprint/win32-x64': 0.46.3
+      '@dprint/darwin-arm64': 0.50.2
+      '@dprint/darwin-x64': 0.50.2
+      '@dprint/linux-arm64-glibc': 0.50.2
+      '@dprint/linux-arm64-musl': 0.50.2
+      '@dprint/linux-riscv64-glibc': 0.50.2
+      '@dprint/linux-x64-glibc': 0.50.2
+      '@dprint/linux-x64-musl': 0.50.2
+      '@dprint/win32-arm64': 0.50.2
+      '@dprint/win32-x64': 0.50.2
 
   dreamopt@0.8.0:
     dependencies:
       wordwrap: 1.0.0
 
-  drizzle-kit@0.19.13:
-    dependencies:
-      '@drizzle-team/studio': 0.0.5
-      '@esbuild-kit/esm-loader': 2.6.5
-      camelcase: 7.0.1
-      chalk: 5.4.1
-      commander: 9.5.0
-      esbuild: 0.18.20
-      esbuild-register: 3.6.0(esbuild@0.18.20)
-      glob: 8.1.0
-      hanji: 0.0.5
-      json-diff: 0.9.0
-      minimatch: 7.4.6
-      zod: 3.25.1
-    transitivePeerDependencies:
-      - supports-color
-
-  drizzle-kit@0.25.0-b1faa33:
+  drizzle-kit@0.31.7:
     dependencies:
       '@drizzle-team/brocli': 0.10.2
       '@esbuild-kit/esm-loader': 2.6.5
-      esbuild: 0.19.12
-      esbuild-register: 3.6.0(esbuild@0.19.12)
+      esbuild: 0.25.12
+      esbuild-register: 3.6.0(esbuild@0.25.12)
     transitivePeerDependencies:
       - supports-color
 
-  drizzle-orm@0.27.2(@aws-sdk/client-rds-data@3.821.0)(@cloudflare/workers-types@4.20250603.0)(@libsql/client@0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3))(@neondatabase/serverless@0.10.0)(@opentelemetry/api@1.9.0)(@planetscale/database@1.19.0)(@types/better-sqlite3@7.6.13)(@types/pg@8.15.4)(@types/sql.js@1.4.9)(@vercel/postgres@0.8.0)(better-sqlite3@11.9.1)(bun-types@1.2.15)(knex@2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7))(kysely@0.25.0)(mysql2@3.14.1)(pg@8.16.0)(postgres@3.4.7)(sql.js@1.13.0)(sqlite3@5.1.7):
+  drizzle-orm@0.27.2(@aws-sdk/client-rds-data@3.940.0)(@cloudflare/workers-types@4.20260621.1)(@libsql/client@0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3))(@neondatabase/serverless@1.0.2)(@opentelemetry/api@1.9.0)(@planetscale/database@1.19.0)(@types/better-sqlite3@7.6.13)(@types/pg@8.15.6)(@types/sql.js@1.4.9)(@vercel/postgres@0.8.0)(better-sqlite3@12.10.0)(bun-types@1.3.3)(mysql2@3.22.3(@types/node@25.5.0))(pg@8.20.0)(postgres@3.4.7)(sql.js@1.13.0)(sqlite3@5.1.7):
     optionalDependencies:
-      '@aws-sdk/client-rds-data': 3.821.0
-      '@cloudflare/workers-types': 4.20250603.0
-      '@libsql/client': 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@neondatabase/serverless': 0.10.0
+      '@aws-sdk/client-rds-data': 3.940.0
+      '@cloudflare/workers-types': 4.20260621.1
+      '@libsql/client': 0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@neondatabase/serverless': 1.0.2
       '@opentelemetry/api': 1.9.0
       '@planetscale/database': 1.19.0
       '@types/better-sqlite3': 7.6.13
-      '@types/pg': 8.15.4
+      '@types/pg': 8.15.6
       '@types/sql.js': 1.4.9
       '@vercel/postgres': 0.8.0
-      better-sqlite3: 11.9.1
-      bun-types: 1.2.15
-      knex: 2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7)
-      kysely: 0.25.0
-      mysql2: 3.14.1
-      pg: 8.16.0
+      better-sqlite3: 12.10.0
+      bun-types: 1.3.3
+      mysql2: 3.22.3(@types/node@25.5.0)
+      pg: 8.20.0
       postgres: 3.4.7
       sql.js: 1.13.0
       sqlite3: 5.1.7
 
-  drizzle-orm@0.44.1(202f5f917ad7b147b6fd5e02d382b3b3):
+  drizzle-orm@0.44.1(79be78f2eb1aa75d0ee8731ec8070b23):
     optionalDependencies:
-      '@aws-sdk/client-rds-data': 3.821.0
-      '@cloudflare/workers-types': 4.20250603.0
-      '@electric-sql/pglite': 0.2.12
+      '@aws-sdk/client-rds-data': 3.940.0
+      '@cloudflare/workers-types': 4.20251126.0
+      '@electric-sql/pglite': 0.4.6
       '@libsql/client': 0.10.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       '@libsql/client-wasm': 0.10.0
-      '@neondatabase/serverless': 0.9.5
-      '@op-engineering/op-sqlite': 2.0.22(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@neondatabase/serverless': 1.0.2
+      '@op-engineering/op-sqlite': 2.0.22(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       '@opentelemetry/api': 1.9.0
       '@planetscale/database': 1.19.0
       '@prisma/client': 5.14.0(prisma@5.14.0)
       '@tidbcloud/serverless': 0.1.1
       '@types/better-sqlite3': 7.6.13
-      '@types/pg': 8.15.4
+      '@types/pg': 8.15.6
       '@types/sql.js': 1.4.9
-      '@upstash/redis': 1.35.0
+      '@upstash/redis': 1.35.7
       '@vercel/postgres': 0.8.0
-      '@xata.io/client': 0.29.5(typescript@5.6.3)
+      '@xata.io/client': 0.29.5(typescript@5.9.3)
       better-sqlite3: 11.9.1
-      bun-types: 0.6.14
-      expo-sqlite: 14.0.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
-      gel: 2.1.0
-      knex: 2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7)
-      kysely: 0.25.0
+      bun-types: 1.3.3
+      expo-sqlite: 14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
+      gel: 2.2.0
       mysql2: 3.14.1
-      pg: 8.16.0
+      pg: 8.16.3
       postgres: 3.4.7
       prisma: 5.14.0
       sql.js: 1.13.0
       sqlite3: 5.1.7
 
+  drizzle-orm@1.0.0-beta.21(9ac8cbab502f04e357d42ee4dc553962):
+    dependencies:
+      '@types/mssql': 9.1.8
+      mssql: 12.1.1
+    optionalDependencies:
+      '@aws-sdk/client-rds-data': 3.940.0
+      '@cloudflare/workers-types': 4.20260621.1
+      '@effect/sql': 0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
+      '@effect/sql-pg': 0.49.7(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(@effect/sql@0.48.5(@effect/experimental@0.57.8(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(@effect/platform@0.93.5(effect@4.0.0-beta.83))(effect@4.0.0-beta.83))(effect@4.0.0-beta.83)
+      '@electric-sql/pglite': 0.4.6
+      '@libsql/client': 0.17.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@libsql/client-wasm': 0.10.0
+      '@neondatabase/serverless': 1.0.2
+      '@op-engineering/op-sqlite': 2.0.22(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@opentelemetry/api': 1.9.0
+      '@planetscale/database': 1.19.0
+      '@sinclair/typebox': 0.34.48
+      '@sqlitecloud/drivers': 1.0.653(@craftzdog/react-native-buffer@6.1.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(bufferutil@4.0.8)(react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)))(utf-8-validate@6.0.3)
+      '@tidbcloud/serverless': 0.1.1
+      '@tursodatabase/database': 0.5.3
+      '@tursodatabase/database-common': 0.6.1
+      '@tursodatabase/database-wasm': 0.5.3
+      '@types/better-sqlite3': 7.6.13
+      '@types/pg': 8.15.6
+      '@types/sql.js': 1.4.9
+      '@upstash/redis': 1.35.7
+      '@vercel/postgres': 0.8.0
+      '@xata.io/client': 0.29.5(typescript@5.9.3)
+      arktype: 2.2.0
+      better-sqlite3: 12.10.0
+      bun-types: 1.3.3
+      expo-sqlite: 14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))
+      gel: 2.2.0
+      mysql2: 3.22.3(@types/node@25.5.0)
+      pg: 8.20.0
+      postgres: 3.4.7
+      sql.js: 1.13.0
+      sqlite3: 5.1.7
+      typebox: 1.1.6
+      valibot: 1.0.0-beta.7(typescript@5.9.3)
+      zod: 4.3.4
+
   drizzle-prisma-generator@0.1.7:
     dependencies:
       '@prisma/generator-helper': 5.22.0
 
+  dts-resolver@2.1.3: {}
+
   dunder-proto@1.0.1:
     dependencies:
       call-bind-apply-helpers: 1.0.2
       es-errors: 1.3.0
       gopd: 1.2.0
 
-  duplexer@0.1.2: {}
-
   eastasianwidth@0.2.0: {}
 
+  ecdsa-sig-formatter@1.0.11:
+    dependencies:
+      safe-buffer: 5.2.1
+
   ee-first@1.1.1: {}
 
-  electron-to-chromium@1.5.162: {}
+  effect@4.0.0-beta.83:
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      fast-check: 4.8.0
+      find-my-way-ts: 0.1.6
+      ini: 7.0.0
+      kubernetes-types: 1.30.0
+      msgpackr: 2.0.4
+      multipasta: 0.2.7
+      toml: 4.1.1
+      uuid: 14.0.0
+      yaml: 2.9.0
+
+  electron-to-chromium@1.5.260: {}
+
+  emittery@1.2.0: {}
 
-  emittery@1.1.0: {}
+  emoji-regex@10.6.0: {}
 
   emoji-regex@8.0.0: {}
 
@@ -12694,6 +14905,8 @@ snapshots:
 
   emojilib@2.4.0: {}
 
+  empathic@2.0.0: {}
+
   encodeurl@1.0.2: {}
 
   encodeurl@2.0.0: {}
@@ -12703,10 +14916,24 @@ snapshots:
       iconv-lite: 0.6.3
     optional: true
 
-  end-of-stream@1.4.4:
+  end-of-stream@1.4.5:
     dependencies:
       once: 1.4.0
 
+  engine.io-client@6.6.3(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    dependencies:
+      '@socket.io/component-emitter': 3.1.2
+      debug: 4.3.7
+      engine.io-parser: 5.2.3
+      ws: 8.17.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      xmlhttprequest-ssl: 2.1.2
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  engine.io-parser@5.2.3: {}
+
   env-editor@0.4.2: {}
 
   env-paths@2.2.1:
@@ -12719,71 +14946,10 @@ snapshots:
   err-code@2.0.3:
     optional: true
 
-  error-ex@1.3.2:
-    dependencies:
-      is-arrayish: 0.2.1
-
   error-stack-parser@2.1.4:
     dependencies:
       stackframe: 1.3.4
 
-  es-abstract@1.24.0:
-    dependencies:
-      array-buffer-byte-length: 1.0.2
-      arraybuffer.prototype.slice: 1.0.4
-      available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      data-view-buffer: 1.0.2
-      data-view-byte-length: 1.0.2
-      data-view-byte-offset: 1.0.1
-      es-define-property: 1.0.1
-      es-errors: 1.3.0
-      es-object-atoms: 1.1.1
-      es-set-tostringtag: 2.1.0
-      es-to-primitive: 1.3.0
-      function.prototype.name: 1.1.8
-      get-intrinsic: 1.3.0
-      get-proto: 1.0.1
-      get-symbol-description: 1.1.0
-      globalthis: 1.0.4
-      gopd: 1.2.0
-      has-property-descriptors: 1.0.2
-      has-proto: 1.2.0
-      has-symbols: 1.1.0
-      hasown: 2.0.2
-      internal-slot: 1.1.0
-      is-array-buffer: 3.0.5
-      is-callable: 1.2.7
-      is-data-view: 1.0.2
-      is-negative-zero: 2.0.3
-      is-regex: 1.2.1
-      is-set: 2.0.3
-      is-shared-array-buffer: 1.0.4
-      is-string: 1.1.1
-      is-typed-array: 1.1.15
-      is-weakref: 1.1.1
-      math-intrinsics: 1.1.0
-      object-inspect: 1.13.4
-      object-keys: 1.1.1
-      object.assign: 4.1.7
-      own-keys: 1.0.1
-      regexp.prototype.flags: 1.5.4
-      safe-array-concat: 1.1.3
-      safe-push-apply: 1.0.0
-      safe-regex-test: 1.1.0
-      set-proto: 1.0.0
-      stop-iteration-iterator: 1.1.0
-      string.prototype.trim: 1.2.10
-      string.prototype.trimend: 1.0.9
-      string.prototype.trimstart: 1.0.8
-      typed-array-buffer: 1.0.3
-      typed-array-byte-length: 1.0.3
-      typed-array-byte-offset: 1.0.4
-      typed-array-length: 1.0.7
-      unbox-primitive: 1.1.0
-      which-typed-array: 1.1.19
-
   es-define-property@1.0.1: {}
 
   es-errors@1.3.0: {}
@@ -12794,48 +14960,6 @@ snapshots:
     dependencies:
       es-errors: 1.3.0
 
-  es-set-tostringtag@2.1.0:
-    dependencies:
-      es-errors: 1.3.0
-      get-intrinsic: 1.3.0
-      has-tostringtag: 1.0.2
-      hasown: 2.0.2
-
-  es-shim-unscopables@1.1.0:
-    dependencies:
-      hasown: 2.0.2
-
-  es-to-primitive@1.3.0:
-    dependencies:
-      is-callable: 1.2.7
-      is-date-object: 1.1.0
-      is-symbol: 1.1.1
-
-  es5-ext@0.10.64:
-    dependencies:
-      es6-iterator: 2.0.3
-      es6-symbol: 3.1.4
-      esniff: 2.0.1
-      next-tick: 1.1.0
-
-  es6-iterator@2.0.3:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-      es6-symbol: 3.1.4
-
-  es6-symbol@3.1.4:
-    dependencies:
-      d: 1.0.2
-      ext: 1.7.0
-
-  es6-weak-map@2.0.3:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-      es6-iterator: 2.0.3
-      es6-symbol: 3.1.4
-
   esbuild-android-64@0.14.54:
     optional: true
 
@@ -12881,32 +15005,13 @@ snapshots:
   esbuild-netbsd-64@0.14.54:
     optional: true
 
-  esbuild-node-externals@1.18.0(esbuild@0.25.5):
-    dependencies:
-      esbuild: 0.25.5
-      find-up: 5.0.0
-
   esbuild-openbsd-64@0.14.54:
     optional: true
 
-  esbuild-register@3.6.0(esbuild@0.18.20):
+  esbuild-register@3.6.0(esbuild@0.25.12):
     dependencies:
-      debug: 4.4.1
-      esbuild: 0.18.20
-    transitivePeerDependencies:
-      - supports-color
-
-  esbuild-register@3.6.0(esbuild@0.19.12):
-    dependencies:
-      debug: 4.4.1
-      esbuild: 0.19.12
-    transitivePeerDependencies:
-      - supports-color
-
-  esbuild-register@3.6.0(esbuild@0.25.5):
-    dependencies:
-      debug: 4.4.1
-      esbuild: 0.25.5
+      debug: 4.4.3
+      esbuild: 0.25.12
     transitivePeerDependencies:
       - supports-color
 
@@ -12971,59 +15076,89 @@ snapshots:
       '@esbuild/win32-ia32': 0.18.20
       '@esbuild/win32-x64': 0.18.20
 
-  esbuild@0.19.12:
+  esbuild@0.21.5:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  esbuild@0.25.12:
     optionalDependencies:
-      '@esbuild/aix-ppc64': 0.19.12
-      '@esbuild/android-arm': 0.19.12
-      '@esbuild/android-arm64': 0.19.12
-      '@esbuild/android-x64': 0.19.12
-      '@esbuild/darwin-arm64': 0.19.12
-      '@esbuild/darwin-x64': 0.19.12
-      '@esbuild/freebsd-arm64': 0.19.12
-      '@esbuild/freebsd-x64': 0.19.12
-      '@esbuild/linux-arm': 0.19.12
-      '@esbuild/linux-arm64': 0.19.12
-      '@esbuild/linux-ia32': 0.19.12
-      '@esbuild/linux-loong64': 0.19.12
-      '@esbuild/linux-mips64el': 0.19.12
-      '@esbuild/linux-ppc64': 0.19.12
-      '@esbuild/linux-riscv64': 0.19.12
-      '@esbuild/linux-s390x': 0.19.12
-      '@esbuild/linux-x64': 0.19.12
-      '@esbuild/netbsd-x64': 0.19.12
-      '@esbuild/openbsd-x64': 0.19.12
-      '@esbuild/sunos-x64': 0.19.12
-      '@esbuild/win32-arm64': 0.19.12
-      '@esbuild/win32-ia32': 0.19.12
-      '@esbuild/win32-x64': 0.19.12
-
-  esbuild@0.25.5:
+      '@esbuild/aix-ppc64': 0.25.12
+      '@esbuild/android-arm': 0.25.12
+      '@esbuild/android-arm64': 0.25.12
+      '@esbuild/android-x64': 0.25.12
+      '@esbuild/darwin-arm64': 0.25.12
+      '@esbuild/darwin-x64': 0.25.12
+      '@esbuild/freebsd-arm64': 0.25.12
+      '@esbuild/freebsd-x64': 0.25.12
+      '@esbuild/linux-arm': 0.25.12
+      '@esbuild/linux-arm64': 0.25.12
+      '@esbuild/linux-ia32': 0.25.12
+      '@esbuild/linux-loong64': 0.25.12
+      '@esbuild/linux-mips64el': 0.25.12
+      '@esbuild/linux-ppc64': 0.25.12
+      '@esbuild/linux-riscv64': 0.25.12
+      '@esbuild/linux-s390x': 0.25.12
+      '@esbuild/linux-x64': 0.25.12
+      '@esbuild/netbsd-arm64': 0.25.12
+      '@esbuild/netbsd-x64': 0.25.12
+      '@esbuild/openbsd-arm64': 0.25.12
+      '@esbuild/openbsd-x64': 0.25.12
+      '@esbuild/openharmony-arm64': 0.25.12
+      '@esbuild/sunos-x64': 0.25.12
+      '@esbuild/win32-arm64': 0.25.12
+      '@esbuild/win32-ia32': 0.25.12
+      '@esbuild/win32-x64': 0.25.12
+
+  esbuild@0.27.0:
     optionalDependencies:
-      '@esbuild/aix-ppc64': 0.25.5
-      '@esbuild/android-arm': 0.25.5
-      '@esbuild/android-arm64': 0.25.5
-      '@esbuild/android-x64': 0.25.5
-      '@esbuild/darwin-arm64': 0.25.5
-      '@esbuild/darwin-x64': 0.25.5
-      '@esbuild/freebsd-arm64': 0.25.5
-      '@esbuild/freebsd-x64': 0.25.5
-      '@esbuild/linux-arm': 0.25.5
-      '@esbuild/linux-arm64': 0.25.5
-      '@esbuild/linux-ia32': 0.25.5
-      '@esbuild/linux-loong64': 0.25.5
-      '@esbuild/linux-mips64el': 0.25.5
-      '@esbuild/linux-ppc64': 0.25.5
-      '@esbuild/linux-riscv64': 0.25.5
-      '@esbuild/linux-s390x': 0.25.5
-      '@esbuild/linux-x64': 0.25.5
-      '@esbuild/netbsd-arm64': 0.25.5
-      '@esbuild/netbsd-x64': 0.25.5
-      '@esbuild/openbsd-arm64': 0.25.5
-      '@esbuild/openbsd-x64': 0.25.5
-      '@esbuild/sunos-x64': 0.25.5
-      '@esbuild/win32-arm64': 0.25.5
-      '@esbuild/win32-ia32': 0.25.5
-      '@esbuild/win32-x64': 0.25.5
+      '@esbuild/aix-ppc64': 0.27.0
+      '@esbuild/android-arm': 0.27.0
+      '@esbuild/android-arm64': 0.27.0
+      '@esbuild/android-x64': 0.27.0
+      '@esbuild/darwin-arm64': 0.27.0
+      '@esbuild/darwin-x64': 0.27.0
+      '@esbuild/freebsd-arm64': 0.27.0
+      '@esbuild/freebsd-x64': 0.27.0
+      '@esbuild/linux-arm': 0.27.0
+      '@esbuild/linux-arm64': 0.27.0
+      '@esbuild/linux-ia32': 0.27.0
+      '@esbuild/linux-loong64': 0.27.0
+      '@esbuild/linux-mips64el': 0.27.0
+      '@esbuild/linux-ppc64': 0.27.0
+      '@esbuild/linux-riscv64': 0.27.0
+      '@esbuild/linux-s390x': 0.27.0
+      '@esbuild/linux-x64': 0.27.0
+      '@esbuild/netbsd-arm64': 0.27.0
+      '@esbuild/netbsd-x64': 0.27.0
+      '@esbuild/openbsd-arm64': 0.27.0
+      '@esbuild/openbsd-x64': 0.27.0
+      '@esbuild/openharmony-arm64': 0.27.0
+      '@esbuild/sunos-x64': 0.27.0
+      '@esbuild/win32-arm64': 0.27.0
+      '@esbuild/win32-ia32': 0.27.0
+      '@esbuild/win32-x64': 0.27.0
 
   escalade@3.2.0: {}
 
@@ -13037,101 +15172,6 @@ snapshots:
 
   escape-string-regexp@5.0.0: {}
 
-  eslint-config-prettier@9.1.0(eslint@8.57.1):
-    dependencies:
-      eslint: 8.57.1
-
-  eslint-import-resolver-node@0.3.9:
-    dependencies:
-      debug: 3.2.7
-      is-core-module: 2.16.1
-      resolve: 1.22.10
-    transitivePeerDependencies:
-      - supports-color
-
-  eslint-module-utils@2.12.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint@8.57.1):
-    dependencies:
-      debug: 3.2.7
-    optionalDependencies:
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-      eslint: 8.57.1
-      eslint-import-resolver-node: 0.3.9
-    transitivePeerDependencies:
-      - supports-color
-
-  eslint-plugin-import@2.31.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1):
-    dependencies:
-      '@rtsao/scc': 1.1.0
-      array-includes: 3.1.9
-      array.prototype.findlastindex: 1.2.6
-      array.prototype.flat: 1.3.3
-      array.prototype.flatmap: 1.3.3
-      debug: 3.2.7
-      doctrine: 2.1.0
-      eslint: 8.57.1
-      eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint-import-resolver-node@0.3.9)(eslint@8.57.1)
-      hasown: 2.0.2
-      is-core-module: 2.16.1
-      is-glob: 4.0.3
-      minimatch: 3.1.2
-      object.fromentries: 2.0.8
-      object.groupby: 1.0.3
-      object.values: 1.2.1
-      semver: 6.3.1
-      string.prototype.trimend: 1.0.9
-      tsconfig-paths: 3.15.0
-    optionalDependencies:
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.6.3)
-    transitivePeerDependencies:
-      - eslint-import-resolver-typescript
-      - eslint-import-resolver-webpack
-      - supports-color
-
-  eslint-plugin-no-instanceof@1.0.1: {}
-
-  eslint-plugin-prettier@5.4.1(eslint-config-prettier@9.1.0(eslint@8.57.1))(eslint@8.57.1)(prettier@3.5.3):
-    dependencies:
-      eslint: 8.57.1
-      prettier: 3.5.3
-      prettier-linter-helpers: 1.0.0
-      synckit: 0.11.8
-    optionalDependencies:
-      eslint-config-prettier: 9.1.0(eslint@8.57.1)
-
-  eslint-plugin-unicorn@48.0.1(eslint@8.57.1):
-    dependencies:
-      '@babel/helper-validator-identifier': 7.27.1
-      '@eslint-community/eslint-utils': 4.7.0(eslint@8.57.1)
-      ci-info: 3.9.0
-      clean-regexp: 1.0.0
-      eslint: 8.57.1
-      esquery: 1.6.0
-      indent-string: 4.0.0
-      is-builtin-module: 3.2.1
-      jsesc: 3.1.0
-      lodash: 4.17.21
-      pluralize: 8.0.0
-      read-pkg-up: 7.0.1
-      regexp-tree: 0.1.27
-      regjsparser: 0.10.0
-      semver: 7.7.2
-      strip-indent: 3.0.0
-
-  eslint-plugin-unused-imports@3.2.0(@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1):
-    dependencies:
-      eslint: 8.57.1
-      eslint-rule-composer: 0.3.0
-    optionalDependencies:
-      '@typescript-eslint/eslint-plugin': 6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@5.6.3)
-
-  eslint-rule-composer@0.3.0: {}
-
-  eslint-scope@5.1.1:
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 4.3.0
-
   eslint-scope@7.2.2:
     dependencies:
       esrecurse: 4.3.0
@@ -13141,8 +15181,8 @@ snapshots:
 
   eslint@8.57.1:
     dependencies:
-      '@eslint-community/eslint-utils': 4.7.0(eslint@8.57.1)
-      '@eslint-community/regexpp': 4.12.1
+      '@eslint-community/eslint-utils': 4.9.0(eslint@8.57.1)
+      '@eslint-community/regexpp': 4.12.2
       '@eslint/eslintrc': 2.1.4
       '@eslint/js': 8.57.1
       '@humanwhocodes/config-array': 0.13.0
@@ -13152,7 +15192,7 @@ snapshots:
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.6
-      debug: 4.4.1
+      debug: 4.4.3
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
       eslint-scope: 7.2.2
@@ -13170,7 +15210,7 @@ snapshots:
       imurmurhash: 0.1.4
       is-glob: 4.0.3
       is-path-inside: 3.0.3
-      js-yaml: 4.1.0
+      js-yaml: 4.1.1
       json-stable-stringify-without-jsonify: 1.0.1
       levn: 0.4.1
       lodash.merge: 4.6.2
@@ -13182,19 +15222,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  esm@3.2.25: {}
-
-  esniff@2.0.1:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-      event-emitter: 0.3.5
-      type: 2.7.3
-
   espree@9.6.1:
     dependencies:
-      acorn: 8.14.1
-      acorn-jsx: 5.3.2(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
       eslint-visitor-keys: 3.4.3
 
   esprima@4.0.1: {}
@@ -13207,46 +15238,33 @@ snapshots:
     dependencies:
       estraverse: 5.3.0
 
-  estraverse@4.3.0: {}
-
   estraverse@5.3.0: {}
 
-  estree-walker@2.0.2: {}
-
   estree-walker@3.0.3:
     dependencies:
-      '@types/estree': 1.0.7
+      '@types/estree': 1.0.8
 
   esutils@2.0.3: {}
 
   etag@1.8.1: {}
 
-  event-emitter@0.3.5:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-
-  event-stream@3.3.4:
-    dependencies:
-      duplexer: 0.1.2
-      from: 0.1.7
-      map-stream: 0.1.0
-      pause-stream: 0.0.11
-      split: 0.3.3
-      stream-combiner: 0.0.4
-      through: 2.3.8
-
   event-target-shim@5.0.1: {}
 
   eventemitter2@6.4.9: {}
 
+  eventemitter3@4.0.7: {}
+
+  eventemitter3@5.0.1: {}
+
   events@1.1.1: {}
 
-  eventsource-parser@3.0.2: {}
+  events@3.3.0: {}
+
+  eventsource-parser@3.0.6: {}
 
   eventsource@3.0.7:
     dependencies:
-      eventsource-parser: 3.0.2
+      eventsource-parser: 3.0.6
 
   exec-async@2.2.0: {}
 
@@ -13266,190 +15284,298 @@ snapshots:
 
   expand-template@2.0.3: {}
 
-  expect-type@1.2.1: {}
+  expect-type@1.2.2: {}
 
-  expo-asset@11.1.5(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-asset@12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      '@expo/image-utils': 0.7.4
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      expo-constants: 17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      '@expo/image-utils': 0.8.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - supports-color
 
-  expo-asset@11.1.5(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-asset@12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      '@expo/image-utils': 0.7.4
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      expo-constants: 17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      '@expo/image-utils': 0.8.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - supports-color
     optional: true
 
-  expo-constants@17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-asset@12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+    dependencies:
+      '@expo/image-utils': 0.8.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  expo-constants@18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    transitivePeerDependencies:
+      - supports-color
+
+  expo-constants@18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
-      '@expo/config': 11.0.10
-      '@expo/env': 1.0.5
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - supports-color
+    optional: true
 
-  expo-constants@17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-constants@18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
-      '@expo/config': 11.0.10
-      '@expo/env': 1.0.5
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      '@expo/config': 12.0.10
+      '@expo/env': 2.0.7
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     transitivePeerDependencies:
       - supports-color
     optional: true
 
-  expo-file-system@18.1.10(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-file-system@19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  expo-file-system@19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
 
-  expo-file-system@18.1.10(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-file-system@19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     optional: true
 
-  expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+    dependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      fontfaceobserver: 2.3.0
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
       fontfaceobserver: 2.3.0
       react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
 
-  expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
       fontfaceobserver: 2.3.0
       react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
     optional: true
 
-  expo-keep-awake@14.1.4(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-keep-awake@15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+    dependencies:
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      react: 18.3.1
+
+  expo-keep-awake@15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
       react: 18.3.1
+    optional: true
 
-  expo-keep-awake@14.1.4(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  expo-keep-awake@15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
       react: 18.3.1
     optional: true
 
-  expo-modules-autolinking@2.1.10:
+  expo-modules-autolinking@3.0.22:
     dependencies:
       '@expo/spawn-async': 1.7.2
       chalk: 4.1.2
       commander: 7.2.0
-      find-up: 5.0.0
-      glob: 10.4.5
       require-from-string: 2.0.2
       resolve-from: 5.0.0
 
-  expo-modules-core@2.3.13:
+  expo-modules-core@3.0.26(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
       invariant: 2.2.4
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  expo-modules-core@3.0.26(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+    dependencies:
+      invariant: 2.2.4
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
+
+  expo-server@1.0.4: {}
+
+  expo-sqlite@14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      '@expo/websql': 1.0.1
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
 
-  expo-sqlite@14.0.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-sqlite@14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
       '@expo/websql': 1.0.1
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
 
-  expo-sqlite@14.0.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)):
+  expo-sqlite@14.0.6(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)):
     dependencies:
       '@expo/websql': 1.0.1
-      expo: 53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
-    optional: true
-
-  expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3):
-    dependencies:
-      '@babel/runtime': 7.27.4
-      '@expo/cli': 0.24.13(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@expo/config': 11.0.10
-      '@expo/config-plugins': 10.0.2
-      '@expo/fingerprint': 0.12.4
-      '@expo/metro-config': 0.20.14
-      '@expo/vector-icons': 14.1.0(expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      babel-preset-expo: 13.1.11(@babel/core@7.27.4)
-      expo-asset: 11.1.5(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-constants: 17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
-      expo-file-system: 18.1.10(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
-      expo-font: 13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-keep-awake: 14.1.4(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-modules-autolinking: 2.1.10
-      expo-modules-core: 2.3.13
+      expo: 54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3)
+    optional: true
+
+  expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3):
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@expo/cli': 54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/devtools': 0.1.7(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@expo/fingerprint': 0.15.3
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/vector-icons': 15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@ungap/structured-clone': 1.3.0
+      babel-preset-expo: 54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2)
+      expo-asset: 12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-file-system: 19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-keep-awake: 15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.1))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-modules-autolinking: 3.0.22
+      expo-modules-core: 3.0.26(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      pretty-format: 29.7.0
+      react: 18.3.1
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-refresh: 0.14.2
+      whatwg-url-without-unicode: 8.0.0-3
+    transitivePeerDependencies:
+      - '@babel/core'
+      - '@modelcontextprotocol/sdk'
+      - bufferutil
+      - expo-router
+      - graphql
+      - supports-color
+      - utf-8-validate
+
+  expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3):
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@expo/cli': 54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/devtools': 0.1.7(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@expo/fingerprint': 0.15.3
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/vector-icons': 15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@ungap/structured-clone': 1.3.0
+      babel-preset-expo: 54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2)
+      expo-asset: 12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-file-system: 19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-keep-awake: 15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@3.25.76))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-modules-autolinking: 3.0.22
+      expo-modules-core: 3.0.26(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      pretty-format: 29.7.0
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native-edge-to-edge: 1.6.0(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-refresh: 0.14.2
       whatwg-url-without-unicode: 8.0.0-3
     transitivePeerDependencies:
       - '@babel/core'
-      - babel-plugin-react-compiler
+      - '@modelcontextprotocol/sdk'
       - bufferutil
+      - expo-router
       - graphql
       - supports-color
       - utf-8-validate
+    optional: true
 
-  expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3):
-    dependencies:
-      '@babel/runtime': 7.27.4
-      '@expo/cli': 0.24.13(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@expo/config': 11.0.10
-      '@expo/config-plugins': 10.0.2
-      '@expo/fingerprint': 0.12.4
-      '@expo/metro-config': 0.20.14
-      '@expo/vector-icons': 14.1.0(expo-font@13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      babel-preset-expo: 13.1.11(@babel/core@7.27.4)
-      expo-asset: 11.1.5(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-constants: 17.1.6(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
-      expo-file-system: 18.1.10(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
-      expo-font: 13.3.1(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-keep-awake: 14.1.4(expo@53.0.9(@babel/core@7.27.4)(bufferutil@4.0.8)(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
-      expo-modules-autolinking: 2.1.10
-      expo-modules-core: 2.3.13
+  expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3):
+    dependencies:
+      '@babel/runtime': 7.28.4
+      '@expo/cli': 54.0.16(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/config': 12.0.10
+      '@expo/config-plugins': 54.0.2
+      '@expo/devtools': 0.1.7(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@expo/fingerprint': 0.15.3
+      '@expo/metro': 54.1.0(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@expo/metro-config': 54.0.9(bufferutil@4.0.8)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(utf-8-validate@6.0.3)
+      '@expo/vector-icons': 15.0.3(expo-font@14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@ungap/structured-clone': 1.3.0
+      babel-preset-expo: 54.0.7(@babel/core@7.28.5)(@babel/runtime@7.28.4)(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-refresh@0.14.2)
+      expo-asset: 12.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-constants: 18.0.10(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-file-system: 19.0.19(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))
+      expo-font: 14.0.9(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-keep-awake: 15.0.7(expo@54.0.25(@babel/core@7.28.5)(@modelcontextprotocol/sdk@1.29.0(zod@4.3.4))(bufferutil@4.0.8)(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      expo-modules-autolinking: 3.0.22
+      expo-modules-core: 3.0.26(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      pretty-format: 29.7.0
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
-      react-native-edge-to-edge: 1.6.0(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-refresh: 0.14.2
       whatwg-url-without-unicode: 8.0.0-3
     transitivePeerDependencies:
       - '@babel/core'
-      - babel-plugin-react-compiler
+      - '@modelcontextprotocol/sdk'
       - bufferutil
+      - expo-router
       - graphql
       - supports-color
       - utf-8-validate
     optional: true
 
-  exponential-backoff@3.1.2: {}
+  exponential-backoff@3.1.3: {}
 
-  express-rate-limit@7.5.0(express@5.1.0):
+  express-rate-limit@7.5.1(express@5.1.0):
     dependencies:
       express: 5.1.0
 
+  express-rate-limit@8.5.2(express@5.2.1):
+    dependencies:
+      express: 5.2.1
+      ip-address: 10.2.0
+
   express@5.1.0:
     dependencies:
       accepts: 2.0.0
-      body-parser: 2.2.0
-      content-disposition: 1.0.0
+      body-parser: 2.2.1
+      content-disposition: 1.0.1
       content-type: 1.0.5
       cookie: 0.7.2
       cookie-signature: 1.2.2
-      debug: 4.4.1
+      debug: 4.4.3
       encodeurl: 2.0.0
       escape-html: 1.0.3
       etag: 1.8.1
       finalhandler: 2.1.0
       fresh: 2.0.0
-      http-errors: 2.0.0
+      http-errors: 2.0.1
       merge-descriptors: 2.0.0
-      mime-types: 3.0.1
+      mime-types: 3.0.2
       on-finished: 2.4.1
       once: 1.4.0
       parseurl: 1.3.3
@@ -13459,15 +15585,48 @@ snapshots:
       router: 2.2.0
       send: 1.2.0
       serve-static: 2.2.0
-      statuses: 2.0.1
+      statuses: 2.0.2
+      type-is: 2.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  express@5.2.1:
+    dependencies:
+      accepts: 2.0.0
+      body-parser: 2.2.1
+      content-disposition: 1.0.1
+      content-type: 1.0.5
+      cookie: 0.7.2
+      cookie-signature: 1.2.2
+      debug: 4.4.3
+      depd: 2.0.0
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 2.1.0
+      fresh: 2.0.0
+      http-errors: 2.0.1
+      merge-descriptors: 2.0.0
+      mime-types: 3.0.2
+      on-finished: 2.4.1
+      once: 1.4.0
+      parseurl: 1.3.3
+      proxy-addr: 2.0.7
+      qs: 6.14.0
+      range-parser: 1.2.1
+      router: 2.2.0
+      send: 1.2.0
+      serve-static: 2.2.0
+      statuses: 2.0.2
       type-is: 2.0.1
       vary: 1.1.2
     transitivePeerDependencies:
       - supports-color
 
-  ext@1.7.0:
+  fast-check@4.8.0:
     dependencies:
-      type: 2.7.3
+      pure-rand: 8.0.0
 
   fast-deep-equal@3.1.3: {}
 
@@ -13493,21 +15652,25 @@ snapshots:
 
   fast-levenshtein@2.0.6: {}
 
-  fast-xml-parser@4.4.1:
+  fast-uri@3.1.2: {}
+
+  fast-xml-parser@5.2.5:
     dependencies:
-      strnum: 1.1.2
+      strnum: 2.1.1
 
   fastq@1.19.1:
     dependencies:
       reusify: 1.1.0
 
+  fb-dotslash@0.5.8: {}
+
   fb-watchman@2.0.2:
     dependencies:
       bser: 2.1.1
 
-  fdir@6.4.5(picomatch@4.0.2):
+  fdir@6.5.0(picomatch@4.0.3):
     optionalDependencies:
-      picomatch: 4.0.2
+      picomatch: 4.0.3
 
   fetch-blob@3.2.0:
     dependencies:
@@ -13545,15 +15708,17 @@ snapshots:
 
   finalhandler@2.1.0:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
       parseurl: 1.3.3
-      statuses: 2.0.1
+      statuses: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
+  find-my-way-ts@0.1.6: {}
+
   find-up@4.1.0:
     dependencies:
       locate-path: 5.0.0
@@ -13571,9 +15736,9 @@ snapshots:
 
   fix-dts-default-cjs-exports@1.0.1:
     dependencies:
-      magic-string: 0.30.17
-      mlly: 1.7.4
-      rollup: 4.41.1
+      magic-string: 0.30.21
+      mlly: 1.8.0
+      rollup: 4.53.3
 
   flat-cache@3.2.0:
     dependencies:
@@ -13608,16 +15773,8 @@ snapshots:
 
   fresh@2.0.0: {}
 
-  from@0.1.7: {}
-
   fs-constants@1.0.0: {}
 
-  fs-extra@11.3.0:
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 6.1.0
-      universalify: 2.0.1
-
   fs-minipass@2.1.0:
     dependencies:
       minipass: 3.3.6
@@ -13629,22 +15786,9 @@ snapshots:
 
   function-bind@1.1.2: {}
 
-  function.prototype.name@1.1.8:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      functions-have-names: 1.2.3
-      hasown: 2.0.2
-      is-callable: 1.2.7
-
-  functions-have-names@1.2.3: {}
-
-  fx@36.0.3: {}
-
   gauge@4.0.4:
     dependencies:
-      aproba: 2.0.0
+      aproba: 2.1.0
       color-support: 1.1.3
       console-control-strings: 1.1.0
       has-unicode: 2.0.1
@@ -13654,26 +15798,29 @@ snapshots:
       wide-align: 1.1.5
     optional: true
 
-  gel@2.1.0:
+  gel@2.2.0:
     dependencies:
-      '@petamoriken/float16': 3.9.2
-      debug: 4.4.1
+      '@petamoriken/float16': 3.9.3
+      debug: 4.4.3
       env-paths: 3.0.0
-      semver: 7.7.2
+      semver: 7.7.4
       shell-quote: 1.8.3
       which: 4.0.0
     transitivePeerDependencies:
       - supports-color
+    optional: true
 
   generate-function@2.3.1:
     dependencies:
       is-property: 1.0.2
 
+  generator-function@2.0.1: {}
+
   gensync@1.0.0-beta.2: {}
 
   get-caller-file@2.0.5: {}
 
-  get-func-name@2.0.2: {}
+  get-east-asian-width@1.4.0: {}
 
   get-intrinsic@1.3.0:
     dependencies:
@@ -13701,19 +15848,15 @@ snapshots:
 
   get-stream@6.0.1: {}
 
-  get-symbol-description@1.1.0:
+  get-tsconfig@4.13.0:
     dependencies:
-      call-bound: 1.0.4
-      es-errors: 1.3.0
-      get-intrinsic: 1.3.0
+      resolve-pkg-maps: 1.0.0
 
-  get-tsconfig@4.10.1:
+  get-tsconfig@4.13.6:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
-  getenv@1.0.0: {}
-
-  getopts@2.3.0: {}
+  getenv@2.0.0: {}
 
   github-from-package@0.0.0: {}
 
@@ -13725,7 +15868,7 @@ snapshots:
     dependencies:
       is-glob: 4.0.3
 
-  glob@10.4.5:
+  glob@10.5.0:
     dependencies:
       foreground-child: 3.3.1
       jackspeak: 3.4.3
@@ -13734,14 +15877,14 @@ snapshots:
       package-json-from-dist: 1.0.1
       path-scurry: 1.11.1
 
-  glob@11.0.2:
+  glob@11.1.0:
     dependencies:
       foreground-child: 3.3.1
       jackspeak: 4.1.1
-      minimatch: 10.0.1
+      minimatch: 10.1.1
       minipass: 7.1.2
       package-json-from-dist: 1.0.1
-      path-scurry: 2.0.0
+      path-scurry: 2.0.1
 
   glob@7.2.3:
     dependencies:
@@ -13760,17 +15903,14 @@ snapshots:
       minimatch: 5.1.6
       once: 1.4.0
 
-  globals@11.12.0: {}
+  global-dirs@0.1.1:
+    dependencies:
+      ini: 1.3.8
 
   globals@13.24.0:
     dependencies:
       type-fest: 0.20.2
 
-  globalthis@1.0.4:
-    dependencies:
-      define-properties: 1.2.1
-      gopd: 1.2.0
-
   globby@11.1.0:
     dependencies:
       array-union: 2.1.0
@@ -13805,13 +15945,11 @@ snapshots:
 
   graphemer@1.4.0: {}
 
-  hanji@0.0.5:
+  hanji@0.0.8:
     dependencies:
       lodash.throttle: 4.1.1
       sisteransi: 1.0.5
 
-  has-bigints@1.1.0: {}
-
   has-flag@3.0.0: {}
 
   has-flag@4.0.0: {}
@@ -13820,10 +15958,6 @@ snapshots:
     dependencies:
       es-define-property: 1.0.1
 
-  has-proto@1.2.0:
-    dependencies:
-      dunder-proto: 1.0.1
-
   has-symbols@1.1.0: {}
 
   has-tostringtag@1.0.2:
@@ -13833,7 +15967,7 @@ snapshots:
   has-unicode@2.0.1:
     optional: true
 
-  hash-it@6.0.0: {}
+  hash-it@6.0.1: {}
 
   hasown@2.0.2:
     dependencies:
@@ -13841,25 +15975,29 @@ snapshots:
 
   heap@0.2.7: {}
 
-  hermes-estree@0.25.1: {}
+  hermes-compiler@0.0.0: {}
 
-  hermes-estree@0.28.1: {}
+  hermes-estree@0.29.1: {}
 
-  hermes-parser@0.25.1:
+  hermes-estree@0.32.0: {}
+
+  hermes-parser@0.29.1:
     dependencies:
-      hermes-estree: 0.25.1
+      hermes-estree: 0.29.1
 
-  hermes-parser@0.28.1:
+  hermes-parser@0.32.0:
     dependencies:
-      hermes-estree: 0.28.1
+      hermes-estree: 0.32.0
 
   highlight.js@10.7.3: {}
 
-  hono@4.7.11: {}
+  hono@4.10.7: {}
+
+  hono@4.12.27: {}
 
   hono@4.7.4: {}
 
-  hosted-git-info@2.8.9: {}
+  hookable@6.0.1: {}
 
   hosted-git-info@7.0.2:
     dependencies:
@@ -13876,27 +16014,42 @@ snapshots:
       statuses: 2.0.1
       toidentifier: 1.0.1
 
+  http-errors@2.0.1:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.2
+      toidentifier: 1.0.1
+
   http-proxy-agent@4.0.1:
     dependencies:
       '@tootallnate/once': 1.1.2
       agent-base: 6.0.2
-      debug: 4.4.1
+      debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
     optional: true
 
+  http-proxy-agent@7.0.2:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.1
+      debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
     optional: true
 
   https-proxy-agent@7.0.6:
     dependencies:
-      agent-base: 7.1.3
-      debug: 4.4.1
+      agent-base: 7.1.4
+      debug: 4.4.3
     transitivePeerDependencies:
       - supports-color
 
@@ -13907,10 +16060,20 @@ snapshots:
       ms: 2.1.3
     optional: true
 
+  husky@9.1.7: {}
+
   iconv-lite@0.6.3:
     dependencies:
       safer-buffer: 2.1.2
 
+  iconv-lite@0.7.0:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  iconv-lite@0.7.2:
+    dependencies:
+      safer-buffer: 2.1.2
+
   ieee754@1.1.13: {}
 
   ieee754@1.2.1: {}
@@ -13927,26 +16090,24 @@ snapshots:
 
   immediate@3.3.0: {}
 
-  import-fresh@2.0.0:
-    dependencies:
-      caller-path: 2.0.0
-      resolve-from: 3.0.0
-
   import-fresh@3.3.1:
     dependencies:
       parent-module: 1.0.1
       resolve-from: 4.0.0
 
-  import-in-the-middle@1.14.0:
+  import-in-the-middle@1.15.0:
     dependencies:
-      acorn: 8.14.1
-      acorn-import-attributes: 1.9.5(acorn@8.14.1)
+      acorn: 8.15.0
+      acorn-import-attributes: 1.9.5(acorn@8.15.0)
       cjs-module-lexer: 1.4.3
       module-details-from-path: 1.0.4
 
+  import-without-cache@0.2.5: {}
+
   imurmurhash@0.1.4: {}
 
-  indent-string@4.0.0: {}
+  indent-string@4.0.0:
+    optional: true
 
   indent-string@5.0.0: {}
 
@@ -13962,24 +16123,17 @@ snapshots:
 
   ini@1.3.8: {}
 
-  internal-slot@1.1.0:
-    dependencies:
-      es-errors: 1.3.0
-      hasown: 2.0.2
-      side-channel: 1.1.0
-
-  interpret@2.2.0: {}
+  ini@7.0.0: {}
 
   invariant@2.2.4:
     dependencies:
       loose-envify: 1.4.0
 
-  ip-address@9.0.5:
-    dependencies:
-      jsbn: 1.1.0
-      sprintf-js: 1.1.3
+  ip-address@10.1.0:
     optional: true
 
+  ip-address@10.2.0: {}
+
   ipaddr.js@1.9.1: {}
 
   irregular-plurals@3.5.0: {}
@@ -13989,75 +16143,36 @@ snapshots:
       call-bound: 1.0.4
       has-tostringtag: 1.0.2
 
-  is-array-buffer@3.0.5:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      get-intrinsic: 1.3.0
-
-  is-arrayish@0.2.1: {}
-
-  is-async-function@2.1.1:
-    dependencies:
-      async-function: 1.0.0
-      call-bound: 1.0.4
-      get-proto: 1.0.1
-      has-tostringtag: 1.0.2
-      safe-regex-test: 1.1.0
-
-  is-bigint@1.1.0:
-    dependencies:
-      has-bigints: 1.1.0
-
   is-binary-path@2.1.0:
     dependencies:
-      binary-extensions: 2.3.0
-
-  is-boolean-object@1.2.2:
-    dependencies:
-      call-bound: 1.0.4
-      has-tostringtag: 1.0.2
-
-  is-builtin-module@3.2.1:
-    dependencies:
-      builtin-modules: 3.3.0
-
-  is-callable@1.2.7: {}
-
-  is-core-module@2.16.1:
-    dependencies:
-      hasown: 2.0.2
-
-  is-data-view@1.0.2:
-    dependencies:
-      call-bound: 1.0.4
-      get-intrinsic: 1.3.0
-      is-typed-array: 1.1.15
-
-  is-date-object@1.1.0:
-    dependencies:
-      call-bound: 1.0.4
-      has-tostringtag: 1.0.2
+      binary-extensions: 2.3.0
+
+  is-callable@1.2.7: {}
 
-  is-directory@0.3.1: {}
+  is-core-module@2.16.1:
+    dependencies:
+      hasown: 2.0.2
 
   is-docker@2.2.1: {}
 
+  is-docker@3.0.0: {}
+
   is-error@2.2.2: {}
 
   is-extglob@2.1.1: {}
 
-  is-finalizationregistry@1.1.1:
-    dependencies:
-      call-bound: 1.0.4
-
   is-fullwidth-code-point@3.0.0: {}
 
   is-fullwidth-code-point@4.0.0: {}
 
-  is-generator-function@1.1.0:
+  is-fullwidth-code-point@5.1.0:
+    dependencies:
+      get-east-asian-width: 1.4.0
+
+  is-generator-function@1.1.2:
     dependencies:
       call-bound: 1.0.4
+      generator-function: 2.0.1
       get-proto: 1.0.1
       has-tostringtag: 1.0.2
       safe-regex-test: 1.1.0
@@ -14066,26 +16181,19 @@ snapshots:
     dependencies:
       is-extglob: 2.1.1
 
+  is-inside-container@1.0.0:
+    dependencies:
+      is-docker: 3.0.0
+
   is-lambda@1.0.1:
     optional: true
 
-  is-map@2.0.3: {}
-
-  is-negative-zero@2.0.3: {}
-
-  is-number-object@1.1.1:
-    dependencies:
-      call-bound: 1.0.4
-      has-tostringtag: 1.0.2
-
   is-number@7.0.0: {}
 
   is-path-inside@3.0.3: {}
 
   is-plain-object@5.0.0: {}
 
-  is-promise@2.2.2: {}
-
   is-promise@4.0.0: {}
 
   is-property@1.0.2: {}
@@ -14097,62 +16205,35 @@ snapshots:
       has-tostringtag: 1.0.2
       hasown: 2.0.2
 
-  is-set@2.0.3: {}
-
-  is-shared-array-buffer@1.0.4:
-    dependencies:
-      call-bound: 1.0.4
-
   is-stream@3.0.0: {}
 
-  is-string@1.1.1:
-    dependencies:
-      call-bound: 1.0.4
-      has-tostringtag: 1.0.2
-
-  is-symbol@1.1.1:
-    dependencies:
-      call-bound: 1.0.4
-      has-symbols: 1.1.0
-      safe-regex-test: 1.1.0
-
   is-typed-array@1.1.15:
     dependencies:
       which-typed-array: 1.1.19
 
   is-unicode-supported@1.3.0: {}
 
-  is-weakmap@2.0.2: {}
-
-  is-weakref@1.1.1:
-    dependencies:
-      call-bound: 1.0.4
-
-  is-weakset@2.0.4:
-    dependencies:
-      call-bound: 1.0.4
-      get-intrinsic: 1.3.0
-
-  is-what@4.1.16: {}
-
   is-wsl@2.2.0:
     dependencies:
       is-docker: 2.2.1
 
-  isarray@1.0.0: {}
+  is-wsl@3.1.0:
+    dependencies:
+      is-inside-container: 1.0.0
 
-  isarray@2.0.5: {}
+  isarray@1.0.0: {}
 
   isexe@2.0.0: {}
 
-  isexe@3.1.1: {}
+  isexe@3.1.1:
+    optional: true
 
   istanbul-lib-coverage@3.2.2: {}
 
   istanbul-lib-instrument@5.2.1:
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/parser': 7.27.4
+      '@babel/core': 7.28.5
+      '@babel/parser': 7.28.5
       '@istanbuljs/schema': 0.1.3
       istanbul-lib-coverage: 3.2.2
       semver: 6.3.1
@@ -14169,14 +16250,12 @@ snapshots:
     dependencies:
       '@isaacs/cliui': 8.0.2
 
-  javascript-natural-sort@0.7.1: {}
-
   jest-environment-node@29.7.0:
     dependencies:
       '@jest/environment': 29.7.0
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       jest-mock: 29.7.0
       jest-util: 29.7.0
 
@@ -14186,7 +16265,7 @@ snapshots:
     dependencies:
       '@jest/types': 29.6.3
       '@types/graceful-fs': 4.1.9
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       anymatch: 3.1.3
       fb-watchman: 2.0.2
       graceful-fs: 4.2.11
@@ -14213,7 +16292,7 @@ snapshots:
   jest-mock@29.7.0:
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       jest-util: 29.7.0
 
   jest-regex-util@29.6.3: {}
@@ -14221,7 +16300,7 @@ snapshots:
   jest-util@29.7.0:
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       chalk: 4.1.2
       ci-info: 3.9.0
       graceful-fs: 4.2.11
@@ -14238,89 +16317,74 @@ snapshots:
 
   jest-worker@29.7.0:
     dependencies:
-      '@types/node': 20.17.57
+      '@types/node': 24.10.1
       jest-util: 29.7.0
       merge-stream: 2.0.0
       supports-color: 8.1.1
 
   jimp-compact@0.16.1: {}
 
+  jiti@2.6.1: {}
+
   jmespath@0.16.0: {}
 
   jose@4.15.9: {}
 
   jose@5.2.3: {}
 
+  jose@6.2.3: {}
+
   joycon@3.1.1: {}
 
-  js-base64@3.7.7: {}
+  js-base64@3.7.8: {}
+
+  js-md4@0.3.2: {}
 
   js-string-escape@1.0.1: {}
 
   js-tokens@4.0.0: {}
 
-  js-yaml@3.14.1:
+  js-yaml@3.14.2:
     dependencies:
       argparse: 1.0.10
       esprima: 4.0.1
 
-  js-yaml@4.1.0:
+  js-yaml@4.1.1:
     dependencies:
       argparse: 2.0.1
 
-  jsbn@1.1.0:
-    optional: true
+  jsbi@4.3.2: {}
 
   jsc-safe-url@0.2.4: {}
 
   jsep@1.4.0: {}
 
-  jsesc@0.5.0: {}
-
-  jsesc@3.0.2: {}
-
   jsesc@3.1.0: {}
 
   json-buffer@3.0.1: {}
 
-  json-diff@0.9.0:
-    dependencies:
-      cli-color: 2.0.4
-      difflib: 0.2.4
-      dreamopt: 0.8.0
-
   json-diff@1.0.6:
     dependencies:
       '@ewoudenberg/difflib': 0.1.0
       colors: 1.4.0
       dreamopt: 0.8.0
 
-  json-parse-better-errors@1.0.2: {}
-
-  json-parse-even-better-errors@2.3.1: {}
-
   json-rules-engine@7.3.1:
     dependencies:
       clone: 2.1.2
       eventemitter2: 6.4.9
-      hash-it: 6.0.0
+      hash-it: 6.0.1
       jsonpath-plus: 10.3.0
 
   json-schema-traverse@0.4.1: {}
 
-  json-stable-stringify-without-jsonify@1.0.1: {}
+  json-schema-traverse@1.0.0: {}
 
-  json5@1.0.2:
-    dependencies:
-      minimist: 1.2.8
+  json-schema-typed@8.0.2: {}
 
-  json5@2.2.3: {}
+  json-stable-stringify-without-jsonify@1.0.1: {}
 
-  jsonfile@6.1.0:
-    dependencies:
-      universalify: 2.0.1
-    optionalDependencies:
-      graceful-fs: 4.2.11
+  json5@2.2.3: {}
 
   jsonparse@1.3.1: {}
 
@@ -14335,45 +16399,45 @@ snapshots:
       jsonparse: 1.3.1
       through2: 4.0.2
 
+  jsonwebtoken@9.0.2:
+    dependencies:
+      jws: 3.2.2
+      lodash.includes: 4.3.0
+      lodash.isboolean: 3.0.3
+      lodash.isinteger: 4.0.4
+      lodash.isnumber: 3.0.3
+      lodash.isplainobject: 4.0.6
+      lodash.isstring: 4.0.1
+      lodash.once: 4.1.1
+      ms: 2.1.3
+      semver: 7.7.4
+
   junk@4.0.1: {}
 
+  jwa@1.4.2:
+    dependencies:
+      buffer-equal-constant-time: 1.0.1
+      ecdsa-sig-formatter: 1.0.11
+      safe-buffer: 5.2.1
+
+  jws@3.2.2:
+    dependencies:
+      jwa: 1.4.2
+      safe-buffer: 5.2.1
+
   keyv@4.5.4:
     dependencies:
       json-buffer: 3.0.1
 
-  keyv@5.3.3:
+  keyv@5.5.4:
     dependencies:
-      '@keyv/serialize': 1.0.3
+      '@keyv/serialize': 1.1.1
 
   kleur@3.0.3: {}
 
   kleur@4.1.5: {}
 
-  knex@2.5.1(better-sqlite3@11.9.1)(mysql2@3.14.1)(pg@8.16.0)(sqlite3@5.1.7):
-    dependencies:
-      colorette: 2.0.19
-      commander: 10.0.1
-      debug: 4.3.4
-      escalade: 3.2.0
-      esm: 3.2.25
-      get-package-type: 0.1.0
-      getopts: 2.3.0
-      interpret: 2.2.0
-      lodash: 4.17.21
-      pg-connection-string: 2.6.1
-      rechoir: 0.8.0
-      resolve-from: 5.0.0
-      tarn: 3.0.2
-      tildify: 2.0.0
-    optionalDependencies:
-      better-sqlite3: 11.9.1
-      mysql2: 3.14.1
-      pg: 8.16.0
-      sqlite3: 5.1.7
-    transitivePeerDependencies:
-      - supports-color
-
-  kysely@0.25.0: {}
+  kubernetes-types@1.30.0: {}
 
   lan-network@0.1.7: {}
 
@@ -14397,6 +16461,21 @@ snapshots:
       '@libsql/linux-x64-musl': 0.4.7
       '@libsql/win32-x64-msvc': 0.4.7
 
+  libsql@0.5.29:
+    dependencies:
+      '@neon-rs/load': 0.0.4
+      detect-libc: 2.0.2
+    optionalDependencies:
+      '@libsql/darwin-arm64': 0.5.29
+      '@libsql/darwin-x64': 0.5.29
+      '@libsql/linux-arm-gnueabihf': 0.5.29
+      '@libsql/linux-arm-musleabihf': 0.5.29
+      '@libsql/linux-arm64-gnu': 0.5.29
+      '@libsql/linux-arm64-musl': 0.5.29
+      '@libsql/linux-x64-gnu': 0.5.29
+      '@libsql/linux-x64-musl': 0.5.29
+      '@libsql/win32-x64-msvc': 0.5.29
+
   lighthouse-logger@1.4.2:
     dependencies:
       debug: 2.6.9
@@ -14404,55 +16483,78 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  lightningcss-darwin-arm64@1.27.0:
+  lightningcss-android-arm64@1.30.2:
+    optional: true
+
+  lightningcss-darwin-arm64@1.30.2:
     optional: true
 
-  lightningcss-darwin-x64@1.27.0:
+  lightningcss-darwin-x64@1.30.2:
     optional: true
 
-  lightningcss-freebsd-x64@1.27.0:
+  lightningcss-freebsd-x64@1.30.2:
     optional: true
 
-  lightningcss-linux-arm-gnueabihf@1.27.0:
+  lightningcss-linux-arm-gnueabihf@1.30.2:
     optional: true
 
-  lightningcss-linux-arm64-gnu@1.27.0:
+  lightningcss-linux-arm64-gnu@1.30.2:
     optional: true
 
-  lightningcss-linux-arm64-musl@1.27.0:
+  lightningcss-linux-arm64-musl@1.30.2:
     optional: true
 
-  lightningcss-linux-x64-gnu@1.27.0:
+  lightningcss-linux-x64-gnu@1.30.2:
     optional: true
 
-  lightningcss-linux-x64-musl@1.27.0:
+  lightningcss-linux-x64-musl@1.30.2:
     optional: true
 
-  lightningcss-win32-arm64-msvc@1.27.0:
+  lightningcss-win32-arm64-msvc@1.30.2:
     optional: true
 
-  lightningcss-win32-x64-msvc@1.27.0:
+  lightningcss-win32-x64-msvc@1.30.2:
     optional: true
 
-  lightningcss@1.27.0:
+  lightningcss@1.30.2:
     dependencies:
-      detect-libc: 1.0.3
+      detect-libc: 2.1.2
     optionalDependencies:
-      lightningcss-darwin-arm64: 1.27.0
-      lightningcss-darwin-x64: 1.27.0
-      lightningcss-freebsd-x64: 1.27.0
-      lightningcss-linux-arm-gnueabihf: 1.27.0
-      lightningcss-linux-arm64-gnu: 1.27.0
-      lightningcss-linux-arm64-musl: 1.27.0
-      lightningcss-linux-x64-gnu: 1.27.0
-      lightningcss-linux-x64-musl: 1.27.0
-      lightningcss-win32-arm64-msvc: 1.27.0
-      lightningcss-win32-x64-msvc: 1.27.0
+      lightningcss-android-arm64: 1.30.2
+      lightningcss-darwin-arm64: 1.30.2
+      lightningcss-darwin-x64: 1.30.2
+      lightningcss-freebsd-x64: 1.30.2
+      lightningcss-linux-arm-gnueabihf: 1.30.2
+      lightningcss-linux-arm64-gnu: 1.30.2
+      lightningcss-linux-arm64-musl: 1.30.2
+      lightningcss-linux-x64-gnu: 1.30.2
+      lightningcss-linux-x64-musl: 1.30.2
+      lightningcss-win32-arm64-msvc: 1.30.2
+      lightningcss-win32-x64-msvc: 1.30.2
 
   lilconfig@3.1.3: {}
 
   lines-and-columns@1.2.4: {}
 
+  lint-staged@16.2.7:
+    dependencies:
+      commander: 14.0.2
+      listr2: 9.0.5
+      micromatch: 4.0.8
+      nano-spawn: 2.0.0
+      pidtree: 0.6.0
+      string-argv: 0.3.2
+      yaml: 2.8.1
+
+  listr2@9.0.5:
+    dependencies:
+      cli-truncate: 5.1.1
+      colorette: 2.0.20
+      eventemitter3: 5.0.1
+      log-update: 6.1.0
+      rfdc: 1.4.1
+      wrap-ansi: 9.0.2
+
   load-json-file@7.0.1: {}
 
   load-tsconfig@0.2.5: {}
@@ -14473,9 +16575,21 @@ snapshots:
 
   lodash.debounce@4.0.8: {}
 
+  lodash.includes@4.3.0: {}
+
+  lodash.isboolean@3.0.3: {}
+
+  lodash.isinteger@4.0.4: {}
+
+  lodash.isnumber@3.0.3: {}
+
+  lodash.isplainobject@4.0.6: {}
+
+  lodash.isstring@4.0.1: {}
+
   lodash.merge@4.6.2: {}
 
-  lodash.sortby@4.7.0: {}
+  lodash.once@4.1.1: {}
 
   lodash.throttle@4.1.1: {}
 
@@ -14485,21 +16599,25 @@ snapshots:
     dependencies:
       chalk: 2.4.2
 
+  log-update@6.1.0:
+    dependencies:
+      ansi-escapes: 7.2.0
+      cli-cursor: 5.0.0
+      slice-ansi: 7.1.2
+      strip-ansi: 7.1.2
+      wrap-ansi: 9.0.2
+
   long@5.3.2: {}
 
   loose-envify@1.4.0:
     dependencies:
       js-tokens: 4.0.0
 
-  loupe@2.3.7:
-    dependencies:
-      get-func-name: 2.0.2
-
-  loupe@3.1.3: {}
+  loupe@3.2.1: {}
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.1.0: {}
+  lru-cache@11.2.2: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -14511,15 +16629,15 @@ snapshots:
 
   lru-cache@7.18.3: {}
 
-  lru-queue@0.1.0:
-    dependencies:
-      es5-ext: 0.10.64
+  lru.min@1.1.3: {}
+
+  lru.min@1.1.4: {}
 
-  lru.min@1.1.2: {}
+  lz4js@0.2.0: {}
 
-  magic-string@0.30.17:
+  magic-string@0.30.21:
     dependencies:
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
 
   make-error@1.3.6: {}
 
@@ -14548,6 +16666,8 @@ snapshots:
 
   make-synchronized@0.4.2: {}
 
+  make-synchronized@0.8.0: {}
+
   makeerror@1.0.12:
     dependencies:
       tmpl: 1.0.5
@@ -14556,30 +16676,17 @@ snapshots:
     dependencies:
       p-defer: 1.0.0
 
-  map-stream@0.1.0: {}
-
-  marked-terminal@6.2.0(marked@9.1.6):
+  marked-terminal@7.1.0(marked@9.1.2):
     dependencies:
-      ansi-escapes: 6.2.1
-      cardinal: 2.1.1
-      chalk: 5.4.1
-      cli-table3: 0.6.5
-      marked: 9.1.6
-      node-emoji: 2.2.0
-      supports-hyperlinks: 3.2.0
-
-  marked-terminal@7.3.0(marked@9.1.6):
-    dependencies:
-      ansi-escapes: 7.0.0
-      ansi-regex: 6.1.0
-      chalk: 5.4.1
+      ansi-escapes: 7.2.0
+      chalk: 5.6.2
       cli-highlight: 2.1.11
       cli-table3: 0.6.5
-      marked: 9.1.6
+      marked: 9.1.2
       node-emoji: 2.2.0
       supports-hyperlinks: 3.2.0
 
-  marked@9.1.6: {}
+  marked@9.1.2: {}
 
   marky@1.3.0: {}
 
@@ -14602,17 +16709,6 @@ snapshots:
 
   memoize-one@5.2.1: {}
 
-  memoizee@0.4.17:
-    dependencies:
-      d: 1.0.2
-      es5-ext: 0.10.64
-      es6-weak-map: 2.0.3
-      event-emitter: 0.3.5
-      is-promise: 2.2.2
-      lru-queue: 0.1.0
-      next-tick: 1.1.0
-      timers-ext: 0.1.8
-
   meow@12.1.1: {}
 
   merge-descriptors@2.0.0: {}
@@ -14621,52 +16717,109 @@ snapshots:
 
   merge2@1.4.1: {}
 
-  metro-babel-transformer@0.82.4:
+  metro-babel-transformer@0.83.2:
+    dependencies:
+      '@babel/core': 7.28.5
+      flow-enums-runtime: 0.0.6
+      hermes-parser: 0.32.0
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-babel-transformer@0.83.3:
     dependencies:
-      '@babel/core': 7.27.4
+      '@babel/core': 7.28.5
       flow-enums-runtime: 0.0.6
-      hermes-parser: 0.28.1
+      hermes-parser: 0.32.0
       nullthrows: 1.1.1
     transitivePeerDependencies:
       - supports-color
 
-  metro-cache-key@0.82.4:
+  metro-cache-key@0.83.2:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+
+  metro-cache-key@0.83.3:
     dependencies:
       flow-enums-runtime: 0.0.6
 
-  metro-cache@0.82.4:
+  metro-cache@0.83.2:
     dependencies:
-      exponential-backoff: 3.1.2
+      exponential-backoff: 3.1.3
       flow-enums-runtime: 0.0.6
       https-proxy-agent: 7.0.6
-      metro-core: 0.82.4
+      metro-core: 0.83.2
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-cache@0.83.3:
+    dependencies:
+      exponential-backoff: 3.1.3
+      flow-enums-runtime: 0.0.6
+      https-proxy-agent: 7.0.6
+      metro-core: 0.83.3
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-config@0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    dependencies:
+      connect: 3.7.0
+      flow-enums-runtime: 0.0.6
+      jest-validate: 29.7.0
+      metro: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-cache: 0.83.2
+      metro-core: 0.83.2
+      metro-runtime: 0.83.2
+      yaml: 2.9.0
     transitivePeerDependencies:
+      - bufferutil
       - supports-color
+      - utf-8-validate
 
-  metro-config@0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+  metro-config@0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3):
     dependencies:
       connect: 3.7.0
-      cosmiconfig: 5.2.1
       flow-enums-runtime: 0.0.6
       jest-validate: 29.7.0
-      metro: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      metro-cache: 0.82.4
-      metro-core: 0.82.4
-      metro-runtime: 0.82.4
+      metro: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-cache: 0.83.3
+      metro-core: 0.83.3
+      metro-runtime: 0.83.3
+      yaml: 2.9.0
     transitivePeerDependencies:
       - bufferutil
       - supports-color
       - utf-8-validate
 
-  metro-core@0.82.4:
+  metro-core@0.83.2:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      lodash.throttle: 4.1.1
+      metro-resolver: 0.83.2
+
+  metro-core@0.83.3:
     dependencies:
       flow-enums-runtime: 0.0.6
       lodash.throttle: 4.1.1
-      metro-resolver: 0.82.4
+      metro-resolver: 0.83.3
+
+  metro-file-map@0.83.2:
+    dependencies:
+      debug: 4.4.3
+      fb-watchman: 2.0.2
+      flow-enums-runtime: 0.0.6
+      graceful-fs: 4.2.11
+      invariant: 2.2.4
+      jest-worker: 29.7.0
+      micromatch: 4.0.8
+      nullthrows: 1.1.1
+      walker: 1.0.8
+    transitivePeerDependencies:
+      - supports-color
 
-  metro-file-map@0.82.4:
+  metro-file-map@0.83.3:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       fb-watchman: 2.0.2
       flow-enums-runtime: 0.0.6
       graceful-fs: 4.2.11
@@ -14678,112 +16831,230 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  metro-minify-terser@0.82.4:
+  metro-minify-terser@0.83.2:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      terser: 5.44.1
+
+  metro-minify-terser@0.83.3:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+      terser: 5.44.1
+
+  metro-resolver@0.83.2:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+
+  metro-resolver@0.83.3:
     dependencies:
       flow-enums-runtime: 0.0.6
-      terser: 5.40.0
 
-  metro-resolver@0.82.4:
+  metro-runtime@0.83.2:
     dependencies:
+      '@babel/runtime': 7.28.4
       flow-enums-runtime: 0.0.6
 
-  metro-runtime@0.82.4:
+  metro-runtime@0.83.3:
     dependencies:
-      '@babel/runtime': 7.27.4
+      '@babel/runtime': 7.28.4
       flow-enums-runtime: 0.0.6
 
-  metro-source-map@0.82.4:
+  metro-source-map@0.83.2:
+    dependencies:
+      '@babel/traverse': 7.28.5
+      '@babel/traverse--for-generate-function-map': '@babel/traverse@7.28.5'
+      '@babel/types': 7.28.5
+      flow-enums-runtime: 0.0.6
+      invariant: 2.2.4
+      metro-symbolicate: 0.83.2
+      nullthrows: 1.1.1
+      ob1: 0.83.2
+      source-map: 0.5.7
+      vlq: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-source-map@0.83.3:
+    dependencies:
+      '@babel/traverse': 7.28.5
+      '@babel/traverse--for-generate-function-map': '@babel/traverse@7.28.5'
+      '@babel/types': 7.28.5
+      flow-enums-runtime: 0.0.6
+      invariant: 2.2.4
+      metro-symbolicate: 0.83.3
+      nullthrows: 1.1.1
+      ob1: 0.83.3
+      source-map: 0.5.7
+      vlq: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-symbolicate@0.83.2:
     dependencies:
-      '@babel/traverse': 7.27.4
-      '@babel/traverse--for-generate-function-map': '@babel/traverse@7.27.4'
-      '@babel/types': 7.27.3
       flow-enums-runtime: 0.0.6
       invariant: 2.2.4
-      metro-symbolicate: 0.82.4
+      metro-source-map: 0.83.2
       nullthrows: 1.1.1
-      ob1: 0.82.4
       source-map: 0.5.7
       vlq: 1.0.1
     transitivePeerDependencies:
       - supports-color
 
-  metro-symbolicate@0.82.4:
+  metro-symbolicate@0.83.3:
     dependencies:
       flow-enums-runtime: 0.0.6
       invariant: 2.2.4
-      metro-source-map: 0.82.4
+      metro-source-map: 0.83.3
       nullthrows: 1.1.1
       source-map: 0.5.7
       vlq: 1.0.1
     transitivePeerDependencies:
       - supports-color
 
-  metro-transform-plugins@0.82.4:
+  metro-transform-plugins@0.83.2:
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@babel/template': 7.27.2
+      '@babel/traverse': 7.28.5
+      flow-enums-runtime: 0.0.6
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-transform-plugins@0.83.3:
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/generator': 7.27.3
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
       '@babel/template': 7.27.2
-      '@babel/traverse': 7.27.4
+      '@babel/traverse': 7.28.5
+      flow-enums-runtime: 0.0.6
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  metro-transform-worker@0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
+      flow-enums-runtime: 0.0.6
+      metro: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-babel-transformer: 0.83.2
+      metro-cache: 0.83.2
+      metro-cache-key: 0.83.2
+      metro-minify-terser: 0.83.2
+      metro-source-map: 0.83.2
+      metro-transform-plugins: 0.83.2
+      nullthrows: 1.1.1
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  metro-transform-worker@0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    dependencies:
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
       flow-enums-runtime: 0.0.6
+      metro: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-babel-transformer: 0.83.3
+      metro-cache: 0.83.3
+      metro-cache-key: 0.83.3
+      metro-minify-terser: 0.83.3
+      metro-source-map: 0.83.3
+      metro-transform-plugins: 0.83.3
       nullthrows: 1.1.1
     transitivePeerDependencies:
+      - bufferutil
       - supports-color
+      - utf-8-validate
 
-  metro-transform-worker@0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+  metro@0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3):
     dependencies:
-      '@babel/core': 7.27.4
-      '@babel/generator': 7.27.3
-      '@babel/parser': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/code-frame': 7.27.1
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@babel/parser': 7.28.5
+      '@babel/template': 7.27.2
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
+      accepts: 1.3.8
+      chalk: 4.1.2
+      ci-info: 2.0.0
+      connect: 3.7.0
+      debug: 4.4.3
+      error-stack-parser: 2.1.4
       flow-enums-runtime: 0.0.6
-      metro: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      metro-babel-transformer: 0.82.4
-      metro-cache: 0.82.4
-      metro-cache-key: 0.82.4
-      metro-minify-terser: 0.82.4
-      metro-source-map: 0.82.4
-      metro-transform-plugins: 0.82.4
+      graceful-fs: 4.2.11
+      hermes-parser: 0.32.0
+      image-size: 1.2.1
+      invariant: 2.2.4
+      jest-worker: 29.7.0
+      jsc-safe-url: 0.2.4
+      lodash.throttle: 4.1.1
+      metro-babel-transformer: 0.83.2
+      metro-cache: 0.83.2
+      metro-cache-key: 0.83.2
+      metro-config: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-core: 0.83.2
+      metro-file-map: 0.83.2
+      metro-resolver: 0.83.2
+      metro-runtime: 0.83.2
+      metro-source-map: 0.83.2
+      metro-symbolicate: 0.83.2
+      metro-transform-plugins: 0.83.2
+      metro-transform-worker: 0.83.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      mime-types: 2.1.35
       nullthrows: 1.1.1
+      serialize-error: 2.1.0
+      source-map: 0.5.7
+      throat: 5.0.0
+      ws: 7.5.10(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      yargs: 17.7.2
     transitivePeerDependencies:
       - bufferutil
       - supports-color
       - utf-8-validate
 
-  metro@0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+  metro@0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3):
     dependencies:
       '@babel/code-frame': 7.27.1
-      '@babel/core': 7.27.4
-      '@babel/generator': 7.27.3
-      '@babel/parser': 7.27.4
+      '@babel/core': 7.28.5
+      '@babel/generator': 7.28.5
+      '@babel/parser': 7.28.5
       '@babel/template': 7.27.2
-      '@babel/traverse': 7.27.4
-      '@babel/types': 7.27.3
+      '@babel/traverse': 7.28.5
+      '@babel/types': 7.28.5
       accepts: 1.3.8
       chalk: 4.1.2
       ci-info: 2.0.0
       connect: 3.7.0
-      debug: 4.4.1
+      debug: 4.4.3
       error-stack-parser: 2.1.4
       flow-enums-runtime: 0.0.6
       graceful-fs: 4.2.11
-      hermes-parser: 0.28.1
+      hermes-parser: 0.32.0
       image-size: 1.2.1
       invariant: 2.2.4
       jest-worker: 29.7.0
       jsc-safe-url: 0.2.4
       lodash.throttle: 4.1.1
-      metro-babel-transformer: 0.82.4
-      metro-cache: 0.82.4
-      metro-cache-key: 0.82.4
-      metro-config: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      metro-core: 0.82.4
-      metro-file-map: 0.82.4
-      metro-resolver: 0.82.4
-      metro-runtime: 0.82.4
-      metro-source-map: 0.82.4
-      metro-symbolicate: 0.82.4
-      metro-transform-plugins: 0.82.4
-      metro-transform-worker: 0.82.4(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-babel-transformer: 0.83.3
+      metro-cache: 0.83.3
+      metro-cache-key: 0.83.3
+      metro-config: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      metro-core: 0.83.3
+      metro-file-map: 0.83.3
+      metro-resolver: 0.83.3
+      metro-runtime: 0.83.3
+      metro-source-map: 0.83.3
+      metro-symbolicate: 0.83.3
+      metro-transform-plugins: 0.83.3
+      metro-transform-worker: 0.83.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       mime-types: 2.1.35
       nullthrows: 1.1.1
       serialize-error: 2.1.0
@@ -14809,7 +17080,7 @@ snapshots:
     dependencies:
       mime-db: 1.52.0
 
-  mime-types@3.0.1:
+  mime-types@3.0.2:
     dependencies:
       mime-db: 1.54.0
 
@@ -14819,33 +17090,33 @@ snapshots:
 
   mimic-fn@4.0.0: {}
 
-  mimic-response@3.1.0: {}
+  mimic-function@5.0.1: {}
 
-  min-indent@1.0.1: {}
+  mimic-response@3.1.0: {}
 
-  minimatch@10.0.1:
+  minimatch@10.1.1:
     dependencies:
-      brace-expansion: 2.0.1
+      '@isaacs/brace-expansion': 5.0.0
 
   minimatch@3.1.2:
     dependencies:
-      brace-expansion: 1.1.11
+      brace-expansion: 1.1.12
 
   minimatch@5.1.6:
     dependencies:
-      brace-expansion: 2.0.1
+      brace-expansion: 2.0.2
 
   minimatch@7.4.6:
     dependencies:
-      brace-expansion: 2.0.1
+      brace-expansion: 2.0.2
 
   minimatch@9.0.3:
     dependencies:
-      brace-expansion: 2.0.1
+      brace-expansion: 2.0.2
 
   minimatch@9.0.5:
     dependencies:
-      brace-expansion: 2.0.1
+      brace-expansion: 2.0.2
 
   minimist@1.2.8: {}
 
@@ -14891,7 +17162,7 @@ snapshots:
       minipass: 3.3.6
       yallist: 4.0.0
 
-  minizlib@3.0.2:
+  minizlib@3.1.0:
     dependencies:
       minipass: 7.1.2
 
@@ -14899,11 +17170,9 @@ snapshots:
 
   mkdirp@1.0.4: {}
 
-  mkdirp@3.0.1: {}
-
-  mlly@1.7.4:
+  mlly@1.8.0:
     dependencies:
-      acorn: 8.14.1
+      acorn: 8.15.0
       pathe: 2.0.3
       pkg-types: 1.3.1
       ufo: 1.6.1
@@ -14912,13 +17181,52 @@ snapshots:
 
   mri@1.2.0: {}
 
-  mrmime@2.0.1: {}
-
   ms@2.0.0: {}
 
-  ms@2.1.2: {}
+  ms@2.1.3: {}
+
+  msgpackr-extract@3.0.4:
+    dependencies:
+      node-gyp-build-optional-packages: 5.2.2
+    optionalDependencies:
+      '@msgpackr-extract/msgpackr-extract-darwin-arm64': 3.0.4
+      '@msgpackr-extract/msgpackr-extract-darwin-x64': 3.0.4
+      '@msgpackr-extract/msgpackr-extract-linux-arm': 3.0.4
+      '@msgpackr-extract/msgpackr-extract-linux-arm64': 3.0.4
+      '@msgpackr-extract/msgpackr-extract-linux-x64': 3.0.4
+      '@msgpackr-extract/msgpackr-extract-win32-x64': 3.0.4
+    optional: true
+
+  msgpackr@1.11.9:
+    optionalDependencies:
+      msgpackr-extract: 3.0.4
+
+  msgpackr@2.0.4:
+    optionalDependencies:
+      msgpackr-extract: 3.0.4
+
+  mssql@11.0.1:
+    dependencies:
+      '@tediousjs/connection-string': 0.5.0
+      commander: 11.1.0
+      debug: 4.4.3
+      rfdc: 1.4.1
+      tarn: 3.0.2
+      tedious: 18.6.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mssql@12.1.1:
+    dependencies:
+      '@tediousjs/connection-string': 0.6.0
+      commander: 11.1.0
+      debug: 4.4.3
+      tarn: 3.0.2
+      tedious: 19.1.3
+    transitivePeerDependencies:
+      - supports-color
 
-  ms@2.1.3: {}
+  multipasta@0.2.7: {}
 
   mysql2@3.14.1:
     dependencies:
@@ -14927,11 +17235,23 @@ snapshots:
       generate-function: 2.3.1
       iconv-lite: 0.6.3
       long: 5.3.2
-      lru.min: 1.1.2
+      lru.min: 1.1.3
       named-placeholders: 1.1.3
       seq-queue: 0.0.5
       sqlstring: 2.3.3
 
+  mysql2@3.22.3(@types/node@25.5.0):
+    dependencies:
+      '@types/node': 25.5.0
+      aws-ssl-profiles: 1.1.2
+      denque: 2.1.0
+      generate-function: 2.3.1
+      iconv-lite: 0.7.2
+      long: 5.3.2
+      lru.min: 1.1.4
+      named-placeholders: 1.1.6
+      sql-escaper: 1.3.3
+
   mz@2.7.0:
     dependencies:
       any-promise: 1.3.0
@@ -14942,13 +17262,21 @@ snapshots:
     dependencies:
       lru-cache: 7.18.3
 
-  nan@2.22.2:
+  named-placeholders@1.1.6:
+    dependencies:
+      lru.min: 1.1.4
+
+  nan@2.23.1:
     optional: true
 
+  nano-spawn@2.0.0: {}
+
   nanoid@3.3.11: {}
 
   napi-build-utils@2.0.0: {}
 
+  native-duplexpair@1.0.0: {}
+
   natural-compare@1.4.0: {}
 
   negotiator@0.6.3: {}
@@ -14961,11 +17289,9 @@ snapshots:
 
   nested-error-stacks@2.1.1: {}
 
-  next-tick@1.1.0: {}
-
-  node-abi@3.75.0:
+  node-abi@3.85.0:
     dependencies:
-      semver: 7.7.2
+      semver: 7.7.4
 
   node-addon-api@7.1.1: {}
 
@@ -14978,19 +17304,18 @@ snapshots:
       emojilib: 2.4.0
       skin-tone: 2.0.0
 
-  node-fetch@3.3.1:
-    dependencies:
-      data-uri-to-buffer: 4.0.1
-      fetch-blob: 3.2.0
-      formdata-polyfill: 4.0.10
-
   node-fetch@3.3.2:
     dependencies:
       data-uri-to-buffer: 4.0.1
       fetch-blob: 3.2.0
       formdata-polyfill: 4.0.10
 
-  node-forge@1.3.1: {}
+  node-forge@1.3.2: {}
+
+  node-gyp-build-optional-packages@5.2.2:
+    dependencies:
+      detect-libc: 2.1.2
+    optional: true
 
   node-gyp-build@4.8.4: {}
 
@@ -15003,7 +17328,7 @@ snapshots:
       nopt: 5.0.0
       npmlog: 6.0.2
       rimraf: 3.0.2
-      semver: 7.7.2
+      semver: 7.7.4
       tar: 6.2.1
       which: 2.0.2
     transitivePeerDependencies:
@@ -15013,7 +17338,7 @@ snapshots:
 
   node-int64@0.4.0: {}
 
-  node-releases@2.0.19: {}
+  node-releases@2.0.27: {}
 
   nofilter@3.1.0: {}
 
@@ -15024,20 +17349,13 @@ snapshots:
       abbrev: 1.1.1
     optional: true
 
-  normalize-package-data@2.5.0:
-    dependencies:
-      hosted-git-info: 2.8.9
-      resolve: 1.22.10
-      semver: 5.7.2
-      validate-npm-package-license: 3.0.4
-
   normalize-path@3.0.0: {}
 
   npm-package-arg@11.0.3:
     dependencies:
       hosted-git-info: 7.0.2
       proc-log: 4.2.0
-      semver: 7.7.2
+      semver: 7.7.4
       validate-npm-package-name: 5.0.1
 
   npm-run-path@5.3.0:
@@ -15056,12 +17374,16 @@ snapshots:
     dependencies:
       execa: 6.1.0
       parse-package-name: 1.0.0
-      semver: 7.7.2
+      semver: 7.7.4
       validate-npm-package-name: 4.0.0
 
   nullthrows@1.1.1: {}
 
-  ob1@0.82.4:
+  ob1@0.83.2:
+    dependencies:
+      flow-enums-runtime: 0.0.6
+
+  ob1@0.83.3:
     dependencies:
       flow-enums-runtime: 0.0.6
 
@@ -15071,42 +17393,13 @@ snapshots:
 
   object-inspect@1.13.4: {}
 
-  object-keys@1.1.1: {}
-
-  object.assign@4.1.7:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      es-object-atoms: 1.1.1
-      has-symbols: 1.1.0
-      object-keys: 1.1.1
-
-  object.fromentries@2.0.8:
-    dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
-
-  object.groupby@1.0.3:
-    dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-
-  object.values@1.2.1:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      es-object-atoms: 1.1.1
-
   obuf@1.1.2: {}
 
-  ohm-js@17.1.0: {}
+  obug@2.1.1: {}
+
+  ohm-js@17.2.1: {}
 
-  oidc-token-hash@5.1.0: {}
+  oidc-token-hash@5.2.0: {}
 
   on-finished@2.3.0:
     dependencies:
@@ -15116,7 +17409,7 @@ snapshots:
     dependencies:
       ee-first: 1.1.1
 
-  on-headers@1.0.2: {}
+  on-headers@1.1.0: {}
 
   once@1.4.0:
     dependencies:
@@ -15130,6 +17423,17 @@ snapshots:
     dependencies:
       mimic-fn: 4.0.0
 
+  onetime@7.0.0:
+    dependencies:
+      mimic-function: 5.0.1
+
+  open@10.2.0:
+    dependencies:
+      default-browser: 5.4.0
+      define-lazy-prop: 3.0.0
+      is-inside-container: 1.0.0
+      wsl-utils: 0.1.0
+
   open@7.4.2:
     dependencies:
       is-docker: 2.2.1
@@ -15156,7 +17460,7 @@ snapshots:
       jose: 4.15.9
       lru-cache: 6.0.0
       object-hash: 2.2.0
-      oidc-token-hash: 5.1.0
+      oidc-token-hash: 5.2.0
 
   optionator@0.9.4:
     dependencies:
@@ -15176,11 +17480,16 @@ snapshots:
       strip-ansi: 5.2.0
       wcwidth: 1.0.1
 
-  own-keys@1.0.1:
-    dependencies:
-      get-intrinsic: 1.3.0
-      object-keys: 1.1.1
-      safe-push-apply: 1.0.0
+  oxlint@1.30.0:
+    optionalDependencies:
+      '@oxlint/darwin-arm64': 1.30.0
+      '@oxlint/darwin-x64': 1.30.0
+      '@oxlint/linux-arm64-gnu': 1.30.0
+      '@oxlint/linux-arm64-musl': 1.30.0
+      '@oxlint/linux-x64-gnu': 1.30.0
+      '@oxlint/linux-x64-musl': 1.30.0
+      '@oxlint/win32-arm64': 1.30.0
+      '@oxlint/win32-x64': 1.30.0
 
   p-defer@1.0.0: {}
 
@@ -15198,7 +17507,7 @@ snapshots:
 
   p-filter@4.1.0:
     dependencies:
-      p-map: 7.0.3
+      p-map: 7.0.4
 
   p-limit@2.3.0:
     dependencies:
@@ -15210,7 +17519,7 @@ snapshots:
 
   p-limit@4.0.0:
     dependencies:
-      yocto-queue: 1.2.1
+      yocto-queue: 1.2.2
 
   p-locate@4.1.0:
     dependencies:
@@ -15235,7 +17544,7 @@ snapshots:
 
   p-map@6.0.0: {}
 
-  p-map@7.0.3: {}
+  p-map@7.0.4: {}
 
   p-timeout@5.1.0: {}
 
@@ -15249,18 +17558,6 @@ snapshots:
     dependencies:
       callsites: 3.1.0
 
-  parse-json@4.0.0:
-    dependencies:
-      error-ex: 1.3.2
-      json-parse-better-errors: 1.0.2
-
-  parse-json@5.2.0:
-    dependencies:
-      '@babel/code-frame': 7.27.1
-      error-ex: 1.3.2
-      json-parse-even-better-errors: 2.3.1
-      lines-and-columns: 1.2.4
-
   parse-ms@3.0.0: {}
 
   parse-package-name@1.0.0: {}
@@ -15298,12 +17595,12 @@ snapshots:
       lru-cache: 10.4.3
       minipass: 7.1.2
 
-  path-scurry@2.0.0:
+  path-scurry@2.0.1:
     dependencies:
-      lru-cache: 11.1.0
+      lru-cache: 11.2.2
       minipass: 7.1.2
 
-  path-to-regexp@8.2.0: {}
+  path-to-regexp@8.3.0: {}
 
   path-type@4.0.0: {}
 
@@ -15313,28 +17610,37 @@ snapshots:
 
   pathe@2.0.3: {}
 
-  pathval@2.0.0: {}
+  pathval@2.0.1: {}
 
-  pause-stream@0.0.11:
-    dependencies:
-      through: 2.3.8
+  pg-cloudflare@1.2.7:
+    optional: true
 
-  pg-cloudflare@1.2.5:
+  pg-cloudflare@1.3.0:
     optional: true
 
-  pg-connection-string@2.6.1: {}
+  pg-connection-string@2.12.0: {}
+
+  pg-connection-string@2.9.1: {}
 
-  pg-connection-string@2.9.0: {}
+  pg-cursor@2.19.0(pg@8.20.0):
+    dependencies:
+      pg: 8.20.0
 
   pg-int8@1.0.1: {}
 
   pg-numeric@1.0.2: {}
 
-  pg-pool@3.10.0(pg@8.16.0):
+  pg-pool@3.10.1(pg@8.16.3):
+    dependencies:
+      pg: 8.16.3
+
+  pg-pool@3.13.0(pg@8.20.0):
     dependencies:
-      pg: 8.16.0
+      pg: 8.20.0
+
+  pg-protocol@1.10.3: {}
 
-  pg-protocol@1.10.0: {}
+  pg-protocol@1.13.0: {}
 
   pg-types@2.2.0:
     dependencies:
@@ -15344,7 +17650,7 @@ snapshots:
       postgres-date: 1.0.7
       postgres-interval: 1.2.0
 
-  pg-types@4.0.2:
+  pg-types@4.1.0:
     dependencies:
       pg-int8: 1.0.1
       pg-numeric: 1.0.2
@@ -15354,15 +17660,25 @@ snapshots:
       postgres-interval: 3.0.0
       postgres-range: 1.1.4
 
-  pg@8.16.0:
+  pg@8.16.3:
+    dependencies:
+      pg-connection-string: 2.9.1
+      pg-pool: 3.10.1(pg@8.16.3)
+      pg-protocol: 1.10.3
+      pg-types: 2.2.0
+      pgpass: 1.0.5
+    optionalDependencies:
+      pg-cloudflare: 1.2.7
+
+  pg@8.20.0:
     dependencies:
-      pg-connection-string: 2.9.0
-      pg-pool: 3.10.0(pg@8.16.0)
-      pg-protocol: 1.10.0
+      pg-connection-string: 2.12.0
+      pg-pool: 3.13.0(pg@8.20.0)
+      pg-protocol: 1.13.0
       pg-types: 2.2.0
       pgpass: 1.0.5
     optionalDependencies:
-      pg-cloudflare: 1.2.5
+      pg-cloudflare: 1.3.0
 
   pgpass@1.0.5:
     dependencies:
@@ -15374,12 +17690,16 @@ snapshots:
 
   picomatch@3.0.1: {}
 
-  picomatch@4.0.2: {}
+  picomatch@4.0.3: {}
+
+  pidtree@0.6.0: {}
 
   pirates@4.0.7: {}
 
   pkce-challenge@4.1.0: {}
 
+  pkce-challenge@5.0.1: {}
+
   pkg-conf@4.0.0:
     dependencies:
       find-up: 6.3.0
@@ -15388,12 +17708,12 @@ snapshots:
   pkg-types@1.3.1:
     dependencies:
       confbox: 0.1.8
-      mlly: 1.7.4
+      mlly: 1.8.0
       pathe: 2.0.3
 
   plist@3.1.0:
     dependencies:
-      '@xmldom/xmldom': 0.8.10
+      '@xmldom/xmldom': 0.8.11
       base64-js: 1.5.1
       xmlbuilder: 15.1.1
 
@@ -15407,21 +17727,14 @@ snapshots:
 
   possible-typed-array-names@1.1.0: {}
 
-  postcss-load-config@6.0.1(postcss@8.5.4)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      lilconfig: 3.1.3
-    optionalDependencies:
-      postcss: 8.5.4
-      tsx: 3.14.0
-      yaml: 2.8.0
-
-  postcss-load-config@6.0.1(postcss@8.5.4)(tsx@4.19.4)(yaml@2.8.0):
+  postcss-load-config@6.0.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(yaml@2.9.0):
     dependencies:
       lilconfig: 3.1.3
     optionalDependencies:
-      postcss: 8.5.4
-      tsx: 4.19.4
-      yaml: 2.8.0
+      jiti: 2.6.1
+      postcss: 8.5.6
+      tsx: 4.20.6
+      yaml: 2.9.0
 
   postcss@8.4.49:
     dependencies:
@@ -15429,7 +17742,7 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
-  postcss@8.5.4:
+  postcss@8.5.6:
     dependencies:
       nanoid: 3.3.11
       picocolors: 1.1.1
@@ -15463,27 +17776,25 @@ snapshots:
 
   prebuild-install@7.1.3:
     dependencies:
-      detect-libc: 2.0.4
+      detect-libc: 2.1.2
       expand-template: 2.0.3
       github-from-package: 0.0.0
       minimist: 1.2.8
       mkdirp-classic: 0.5.3
       napi-build-utils: 2.0.0
-      node-abi: 3.75.0
-      pump: 3.0.2
+      node-abi: 3.85.0
+      pump: 3.0.3
       rc: 1.2.8
       simple-get: 4.0.1
-      tar-fs: 2.1.3
+      tar-fs: 2.1.4
       tunnel-agent: 0.6.0
 
   prelude-ls@1.2.1: {}
 
-  prettier-linter-helpers@1.0.0:
-    dependencies:
-      fast-diff: 1.3.0
-
   prettier@3.5.3: {}
 
+  prettier@3.6.2: {}
+
   pretty-bytes@5.6.0: {}
 
   pretty-format@29.7.0:
@@ -15502,6 +17813,8 @@ snapshots:
 
   proc-log@4.2.0: {}
 
+  process@0.11.10: {}
+
   progress@2.0.3: {}
 
   promise-inflight@1.0.1:
@@ -15524,7 +17837,7 @@ snapshots:
       kleur: 3.0.3
       sisteransi: 1.0.5
 
-  protobufjs@7.5.3:
+  protobufjs@7.5.4:
     dependencies:
       '@protobufjs/aspromise': 1.1.2
       '@protobufjs/base64': 1.1.2
@@ -15536,7 +17849,7 @@ snapshots:
       '@protobufjs/path': 1.1.2
       '@protobufjs/pool': 1.1.0
       '@protobufjs/utf8': 1.1.0
-      '@types/node': 18.19.110
+      '@types/node': 24.10.1
       long: 5.3.2
 
   proxy-addr@2.0.7:
@@ -15544,13 +17857,9 @@ snapshots:
       forwarded: 0.2.0
       ipaddr.js: 1.9.1
 
-  ps-tree@1.2.0:
+  pump@3.0.3:
     dependencies:
-      event-stream: 3.3.4
-
-  pump@3.0.2:
-    dependencies:
-      end-of-stream: 1.4.4
+      end-of-stream: 1.4.5
       once: 1.4.0
 
   punycode@1.3.2: {}
@@ -15559,12 +17868,16 @@ snapshots:
 
   pure-rand@6.1.0: {}
 
+  pure-rand@8.0.0: {}
+
   qrcode-terminal@0.11.0: {}
 
   qs@6.14.0:
     dependencies:
       side-channel: 1.1.0
 
+  quansync@1.0.0: {}
+
   querystring@0.2.0: {}
 
   queue-microtask@1.2.3: {}
@@ -15573,17 +17886,13 @@ snapshots:
     dependencies:
       inherits: 2.0.4
 
-  randombytes@2.1.0:
-    dependencies:
-      safe-buffer: 5.2.1
-
   range-parser@1.2.1: {}
 
-  raw-body@3.0.0:
+  raw-body@3.0.2:
     dependencies:
       bytes: 3.1.2
-      http-errors: 2.0.0
-      iconv-lite: 0.6.3
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
       unpipe: 1.0.0
 
   rc@1.2.8:
@@ -15593,7 +17902,7 @@ snapshots:
       minimist: 1.2.8
       strip-json-comments: 2.0.1
 
-  react-devtools-core@6.1.2(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+  react-devtools-core@6.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3):
     dependencies:
       shell-quote: 1.8.3
       ws: 7.5.10(bufferutil@4.0.8)(utf-8-validate@6.0.3)
@@ -15603,100 +17912,120 @@ snapshots:
 
   react-is@18.3.1: {}
 
-  react-native-edge-to-edge@1.6.0(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
 
-  react-native-edge-to-edge@1.6.0(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
+  react-native-quick-base64@2.2.2(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1):
     dependencies:
       react: 18.3.1
-      react-native: 0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
-    optional: true
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      buffer: 5.7.1
+      eventemitter3: 4.0.7
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  react-native-tcp-socket@6.3.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      buffer: 5.7.1
+      eventemitter3: 4.0.7
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+
+  react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      react-native: 0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      whatwg-url-without-unicode: 8.0.0-3
+
+  react-native-url-polyfill@3.0.0(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)):
+    dependencies:
+      react-native: 0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3)
+      whatwg-url-without-unicode: 8.0.0-3
 
-  react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3):
+  react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3):
     dependencies:
       '@jest/create-cache-key-function': 29.7.0
-      '@react-native/assets-registry': 0.79.2
-      '@react-native/codegen': 0.79.2(@babel/core@7.27.4)
-      '@react-native/community-cli-plugin': 0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@react-native/gradle-plugin': 0.79.2
-      '@react-native/js-polyfills': 0.79.2
-      '@react-native/normalize-colors': 0.79.2
-      '@react-native/virtualized-lists': 0.79.2(@types/react@18.3.23)(react-native@0.79.2(@babel/core@7.27.4)(@types/react@18.3.23)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@react-native/assets-registry': 0.82.1
+      '@react-native/codegen': 0.82.1(@babel/core@7.28.5)
+      '@react-native/community-cli-plugin': 0.82.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@react-native/gradle-plugin': 0.82.1
+      '@react-native/js-polyfills': 0.82.1
+      '@react-native/normalize-colors': 0.82.1
+      '@react-native/virtualized-lists': 0.82.1(@types/react@18.3.27)(react-native@0.82.1(@babel/core@7.28.5)(@types/react@18.3.27)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       abort-controller: 3.0.0
       anser: 1.4.10
       ansi-regex: 5.0.1
-      babel-jest: 29.7.0(@babel/core@7.27.4)
-      babel-plugin-syntax-hermes-parser: 0.25.1
+      babel-jest: 29.7.0(@babel/core@7.28.5)
+      babel-plugin-syntax-hermes-parser: 0.32.0
       base64-js: 1.5.1
-      chalk: 4.1.2
       commander: 12.1.0
-      event-target-shim: 5.0.1
       flow-enums-runtime: 0.0.6
       glob: 7.2.3
+      hermes-compiler: 0.0.0
       invariant: 2.2.4
       jest-environment-node: 29.7.0
       memoize-one: 5.2.1
-      metro-runtime: 0.82.4
-      metro-source-map: 0.82.4
+      metro-runtime: 0.83.3
+      metro-source-map: 0.83.3
       nullthrows: 1.1.1
       pretty-format: 29.7.0
       promise: 8.3.0
       react: 18.3.1
-      react-devtools-core: 6.1.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      react-devtools-core: 6.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       react-refresh: 0.14.2
       regenerator-runtime: 0.13.11
-      scheduler: 0.25.0
-      semver: 7.7.2
+      scheduler: 0.26.0
+      semver: 7.7.4
       stacktrace-parser: 0.1.11
       whatwg-fetch: 3.6.20
       ws: 6.2.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       yargs: 17.7.2
     optionalDependencies:
-      '@types/react': 18.3.23
+      '@types/react': 18.3.27
     transitivePeerDependencies:
       - '@babel/core'
       - '@react-native-community/cli'
+      - '@react-native/metro-config'
       - bufferutil
       - supports-color
       - utf-8-validate
 
-  react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3):
+  react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3):
     dependencies:
       '@jest/create-cache-key-function': 29.7.0
-      '@react-native/assets-registry': 0.79.2
-      '@react-native/codegen': 0.79.2(@babel/core@7.27.4)
-      '@react-native/community-cli-plugin': 0.79.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
-      '@react-native/gradle-plugin': 0.79.2
-      '@react-native/js-polyfills': 0.79.2
-      '@react-native/normalize-colors': 0.79.2
-      '@react-native/virtualized-lists': 0.79.2(react-native@0.79.2(@babel/core@7.27.4)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
+      '@react-native/assets-registry': 0.82.1
+      '@react-native/codegen': 0.82.1(@babel/core@7.28.5)
+      '@react-native/community-cli-plugin': 0.82.1(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      '@react-native/gradle-plugin': 0.82.1
+      '@react-native/js-polyfills': 0.82.1
+      '@react-native/normalize-colors': 0.82.1
+      '@react-native/virtualized-lists': 0.82.1(react-native@0.82.1(@babel/core@7.28.5)(bufferutil@4.0.8)(react@18.3.1)(utf-8-validate@6.0.3))(react@18.3.1)
       abort-controller: 3.0.0
       anser: 1.4.10
       ansi-regex: 5.0.1
-      babel-jest: 29.7.0(@babel/core@7.27.4)
-      babel-plugin-syntax-hermes-parser: 0.25.1
+      babel-jest: 29.7.0(@babel/core@7.28.5)
+      babel-plugin-syntax-hermes-parser: 0.32.0
       base64-js: 1.5.1
-      chalk: 4.1.2
       commander: 12.1.0
-      event-target-shim: 5.0.1
       flow-enums-runtime: 0.0.6
       glob: 7.2.3
+      hermes-compiler: 0.0.0
       invariant: 2.2.4
       jest-environment-node: 29.7.0
       memoize-one: 5.2.1
-      metro-runtime: 0.82.4
-      metro-source-map: 0.82.4
+      metro-runtime: 0.83.3
+      metro-source-map: 0.83.3
       nullthrows: 1.1.1
       pretty-format: 29.7.0
       promise: 8.3.0
       react: 18.3.1
-      react-devtools-core: 6.1.2(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      react-devtools-core: 6.1.5(bufferutil@4.0.8)(utf-8-validate@6.0.3)
       react-refresh: 0.14.2
       regenerator-runtime: 0.13.11
-      scheduler: 0.25.0
-      semver: 7.7.2
+      scheduler: 0.26.0
+      semver: 7.7.4
       stacktrace-parser: 0.1.11
       whatwg-fetch: 3.6.20
       ws: 6.2.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
@@ -15704,10 +18033,10 @@ snapshots:
     transitivePeerDependencies:
       - '@babel/core'
       - '@react-native-community/cli'
+      - '@react-native/metro-config'
       - bufferutil
       - supports-color
       - utf-8-validate
-    optional: true
 
   react-refresh@0.14.2: {}
 
@@ -15715,25 +18044,20 @@ snapshots:
     dependencies:
       loose-envify: 1.4.0
 
-  read-pkg-up@7.0.1:
-    dependencies:
-      find-up: 4.1.0
-      read-pkg: 5.2.0
-      type-fest: 0.8.1
-
-  read-pkg@5.2.0:
-    dependencies:
-      '@types/normalize-package-data': 2.4.4
-      normalize-package-data: 2.5.0
-      parse-json: 5.2.0
-      type-fest: 0.6.0
-
   readable-stream@3.6.2:
     dependencies:
       inherits: 2.0.4
       string_decoder: 1.3.0
       util-deprecate: 1.0.2
 
+  readable-stream@4.7.0:
+    dependencies:
+      abort-controller: 3.0.0
+      buffer: 6.0.3
+      events: 3.3.0
+      process: 0.11.10
+      string_decoder: 1.3.0
+
   readdirp@3.6.0:
     dependencies:
       picomatch: 2.3.1
@@ -15748,26 +18072,7 @@ snapshots:
       tiny-invariant: 1.3.3
       tslib: 2.8.1
 
-  rechoir@0.8.0:
-    dependencies:
-      resolve: 1.22.10
-
-  redeyed@2.1.1:
-    dependencies:
-      esprima: 4.0.1
-
-  reflect.getprototypeof@1.0.10:
-    dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-errors: 1.3.0
-      es-object-atoms: 1.1.1
-      get-intrinsic: 1.3.0
-      get-proto: 1.0.1
-      which-builtin-type: 1.2.1
-
-  regenerate-unicode-properties@10.2.0:
+  regenerate-unicode-properties@10.2.2:
     dependencies:
       regenerate: 1.4.2
 
@@ -15775,35 +18080,20 @@ snapshots:
 
   regenerator-runtime@0.13.11: {}
 
-  regexp-tree@0.1.27: {}
-
-  regexp.prototype.flags@1.5.4:
-    dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-errors: 1.3.0
-      get-proto: 1.0.1
-      gopd: 1.2.0
-      set-function-name: 2.0.2
-
-  regexpu-core@6.2.0:
+  regexpu-core@6.4.0:
     dependencies:
       regenerate: 1.4.2
-      regenerate-unicode-properties: 10.2.0
+      regenerate-unicode-properties: 10.2.2
       regjsgen: 0.8.0
-      regjsparser: 0.12.0
+      regjsparser: 0.13.0
       unicode-match-property-ecmascript: 2.0.0
-      unicode-match-property-value-ecmascript: 2.2.0
+      unicode-match-property-value-ecmascript: 2.2.1
 
   regjsgen@0.8.0: {}
 
-  regjsparser@0.10.0:
+  regjsparser@0.13.0:
     dependencies:
-      jsesc: 0.5.0
-
-  regjsparser@0.12.0:
-    dependencies:
-      jsesc: 3.0.2
+      jsesc: 3.1.0
 
   require-directory@2.1.1: {}
 
@@ -15819,26 +18109,28 @@ snapshots:
     dependencies:
       resolve-from: 5.0.0
 
-  resolve-from@3.0.0: {}
-
   resolve-from@4.0.0: {}
 
   resolve-from@5.0.0: {}
 
+  resolve-global@1.0.0:
+    dependencies:
+      global-dirs: 0.1.1
+
   resolve-pkg-maps@1.0.0: {}
 
-  resolve-tspaths@0.8.23(typescript@5.6.3):
+  resolve-tspaths@0.8.23(typescript@5.9.3):
     dependencies:
       ansi-colors: 4.1.3
       commander: 12.1.0
       fast-glob: 3.3.2
-      typescript: 5.6.3
+      typescript: 5.9.3
 
   resolve-workspace-root@2.0.0: {}
 
   resolve.exports@2.0.3: {}
 
-  resolve@1.22.10:
+  resolve@1.22.11:
     dependencies:
       is-core-module: 2.16.1
       path-parse: 1.0.7
@@ -15853,6 +18145,11 @@ snapshots:
       onetime: 2.0.1
       signal-exit: 3.0.7
 
+  restore-cursor@5.1.0:
+    dependencies:
+      onetime: 7.0.0
+      signal-exit: 4.1.0
+
   retry@0.12.0:
     optional: true
 
@@ -15860,54 +18157,109 @@ snapshots:
 
   reusify@1.1.0: {}
 
+  rfdc@1.4.1: {}
+
   rimraf@3.0.2:
     dependencies:
       glob: 7.2.3
 
-  rimraf@5.0.10:
-    dependencies:
-      glob: 10.4.5
-
-  rollup@3.29.5:
+  rolldown-plugin-dts@0.22.5(rolldown@1.0.0-rc.3)(typescript@5.9.3):
+    dependencies:
+      '@babel/generator': 8.0.0-rc.2
+      '@babel/helper-validator-identifier': 8.0.0-rc.2
+      '@babel/parser': 8.0.0-rc.2
+      '@babel/types': 8.0.0-rc.2
+      ast-kit: 3.0.0-beta.1
+      birpc: 4.0.0
+      dts-resolver: 2.1.3
+      get-tsconfig: 4.13.6
+      obug: 2.1.1
+      rolldown: 1.0.0-rc.3
     optionalDependencies:
-      fsevents: 2.3.3
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - oxc-resolver
 
-  rollup@4.41.1:
+  rolldown@1.0.0-rc.3:
     dependencies:
-      '@types/estree': 1.0.7
+      '@oxc-project/types': 0.112.0
+      '@rolldown/pluginutils': 1.0.0-rc.3
+    optionalDependencies:
+      '@rolldown/binding-android-arm64': 1.0.0-rc.3
+      '@rolldown/binding-darwin-arm64': 1.0.0-rc.3
+      '@rolldown/binding-darwin-x64': 1.0.0-rc.3
+      '@rolldown/binding-freebsd-x64': 1.0.0-rc.3
+      '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.3
+      '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.3
+      '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.3
+      '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.3
+      '@rolldown/binding-linux-x64-musl': 1.0.0-rc.3
+      '@rolldown/binding-openharmony-arm64': 1.0.0-rc.3
+      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.3
+      '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.3
+      '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.3
+
+  rolldown@1.0.0-rc.9:
+    dependencies:
+      '@oxc-project/types': 0.115.0
+      '@rolldown/pluginutils': 1.0.0-rc.9
+    optionalDependencies:
+      '@rolldown/binding-android-arm64': 1.0.0-rc.9
+      '@rolldown/binding-darwin-arm64': 1.0.0-rc.9
+      '@rolldown/binding-darwin-x64': 1.0.0-rc.9
+      '@rolldown/binding-freebsd-x64': 1.0.0-rc.9
+      '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.9
+      '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.9
+      '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.9
+      '@rolldown/binding-linux-ppc64-gnu': 1.0.0-rc.9
+      '@rolldown/binding-linux-s390x-gnu': 1.0.0-rc.9
+      '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.9
+      '@rolldown/binding-linux-x64-musl': 1.0.0-rc.9
+      '@rolldown/binding-openharmony-arm64': 1.0.0-rc.9
+      '@rolldown/binding-wasm32-wasi': 1.0.0-rc.9
+      '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.9
+      '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.9
+
+  rollup@4.53.3:
+    dependencies:
+      '@types/estree': 1.0.8
     optionalDependencies:
-      '@rollup/rollup-android-arm-eabi': 4.41.1
-      '@rollup/rollup-android-arm64': 4.41.1
-      '@rollup/rollup-darwin-arm64': 4.41.1
-      '@rollup/rollup-darwin-x64': 4.41.1
-      '@rollup/rollup-freebsd-arm64': 4.41.1
-      '@rollup/rollup-freebsd-x64': 4.41.1
-      '@rollup/rollup-linux-arm-gnueabihf': 4.41.1
-      '@rollup/rollup-linux-arm-musleabihf': 4.41.1
-      '@rollup/rollup-linux-arm64-gnu': 4.41.1
-      '@rollup/rollup-linux-arm64-musl': 4.41.1
-      '@rollup/rollup-linux-loongarch64-gnu': 4.41.1
-      '@rollup/rollup-linux-powerpc64le-gnu': 4.41.1
-      '@rollup/rollup-linux-riscv64-gnu': 4.41.1
-      '@rollup/rollup-linux-riscv64-musl': 4.41.1
-      '@rollup/rollup-linux-s390x-gnu': 4.41.1
-      '@rollup/rollup-linux-x64-gnu': 4.41.1
-      '@rollup/rollup-linux-x64-musl': 4.41.1
-      '@rollup/rollup-win32-arm64-msvc': 4.41.1
-      '@rollup/rollup-win32-ia32-msvc': 4.41.1
-      '@rollup/rollup-win32-x64-msvc': 4.41.1
+      '@rollup/rollup-android-arm-eabi': 4.53.3
+      '@rollup/rollup-android-arm64': 4.53.3
+      '@rollup/rollup-darwin-arm64': 4.53.3
+      '@rollup/rollup-darwin-x64': 4.53.3
+      '@rollup/rollup-freebsd-arm64': 4.53.3
+      '@rollup/rollup-freebsd-x64': 4.53.3
+      '@rollup/rollup-linux-arm-gnueabihf': 4.53.3
+      '@rollup/rollup-linux-arm-musleabihf': 4.53.3
+      '@rollup/rollup-linux-arm64-gnu': 4.53.3
+      '@rollup/rollup-linux-arm64-musl': 4.53.3
+      '@rollup/rollup-linux-loong64-gnu': 4.53.3
+      '@rollup/rollup-linux-ppc64-gnu': 4.53.3
+      '@rollup/rollup-linux-riscv64-gnu': 4.53.3
+      '@rollup/rollup-linux-riscv64-musl': 4.53.3
+      '@rollup/rollup-linux-s390x-gnu': 4.53.3
+      '@rollup/rollup-linux-x64-gnu': 4.53.3
+      '@rollup/rollup-linux-x64-musl': 4.53.3
+      '@rollup/rollup-openharmony-arm64': 4.53.3
+      '@rollup/rollup-win32-arm64-msvc': 4.53.3
+      '@rollup/rollup-win32-ia32-msvc': 4.53.3
+      '@rollup/rollup-win32-x64-gnu': 4.53.3
+      '@rollup/rollup-win32-x64-msvc': 4.53.3
       fsevents: 2.3.3
 
   router@2.2.0:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       depd: 2.0.0
       is-promise: 4.0.0
       parseurl: 1.3.3
-      path-to-regexp: 8.2.0
+      path-to-regexp: 8.3.0
     transitivePeerDependencies:
       - supports-color
 
+  run-applescript@7.1.0: {}
+
   run-parallel@1.2.0:
     dependencies:
       queue-microtask: 1.2.3
@@ -15920,21 +18272,8 @@ snapshots:
     dependencies:
       mri: 1.2.0
 
-  safe-array-concat@1.1.3:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      get-intrinsic: 1.3.0
-      has-symbols: 1.1.0
-      isarray: 2.0.5
-
   safe-buffer@5.2.1: {}
 
-  safe-push-apply@1.0.0:
-    dependencies:
-      es-errors: 1.3.0
-      isarray: 2.0.5
-
   safe-regex-test@1.1.0:
     dependencies:
       call-bound: 1.0.4
@@ -15945,15 +18284,15 @@ snapshots:
 
   sax@1.2.1: {}
 
-  sax@1.4.1: {}
+  sax@1.4.3: {}
 
-  scheduler@0.25.0: {}
-
-  semver@5.7.2: {}
+  scheduler@0.26.0: {}
 
   semver@6.3.1: {}
 
-  semver@7.7.2: {}
+  semver@7.7.3: {}
+
+  semver@7.7.4: {}
 
   send@0.19.0:
     dependencies:
@@ -15993,17 +18332,17 @@ snapshots:
 
   send@1.2.0:
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       encodeurl: 2.0.0
       escape-html: 1.0.3
       etag: 1.8.1
       fresh: 2.0.0
-      http-errors: 2.0.0
-      mime-types: 3.0.1
+      http-errors: 2.0.1
+      mime-types: 3.0.2
       ms: 2.1.3
       on-finished: 2.4.1
       range-parser: 1.2.1
-      statuses: 2.0.1
+      statuses: 2.0.2
     transitivePeerDependencies:
       - supports-color
 
@@ -16015,10 +18354,6 @@ snapshots:
     dependencies:
       type-fest: 0.13.1
 
-  serialize-javascript@6.0.2:
-    dependencies:
-      randombytes: 2.1.0
-
   serve-static@1.16.2:
     dependencies:
       encodeurl: 2.0.0
@@ -16040,7 +18375,7 @@ snapshots:
   set-blocking@2.0.0:
     optional: true
 
-  set-cookie-parser@2.7.1: {}
+  set-cookie-parser@2.7.2: {}
 
   set-function-length@1.2.2:
     dependencies:
@@ -16051,19 +18386,6 @@ snapshots:
       gopd: 1.2.0
       has-property-descriptors: 1.0.2
 
-  set-function-name@2.0.2:
-    dependencies:
-      define-data-property: 1.1.4
-      es-errors: 1.3.0
-      functions-have-names: 1.2.3
-      has-property-descriptors: 1.0.2
-
-  set-proto@1.0.0:
-    dependencies:
-      dunder-proto: 1.0.1
-      es-errors: 1.3.0
-      es-object-atoms: 1.1.1
-
   setprototypeof@1.2.0: {}
 
   shebang-command@2.0.0:
@@ -16122,12 +18444,6 @@ snapshots:
       bplist-parser: 0.3.1
       plist: 3.1.0
 
-  sirv@2.0.4:
-    dependencies:
-      '@polka/url': 1.0.0-next.29
-      mrmime: 2.0.1
-      totalist: 3.0.1
-
   sisteransi@1.0.5: {}
 
   skin-tone@2.0.0:
@@ -16142,28 +18458,49 @@ snapshots:
 
   slice-ansi@5.0.0:
     dependencies:
-      ansi-styles: 6.2.1
+      ansi-styles: 6.2.3
       is-fullwidth-code-point: 4.0.0
 
+  slice-ansi@7.1.2:
+    dependencies:
+      ansi-styles: 6.2.3
+      is-fullwidth-code-point: 5.1.0
+
   slugify@1.6.6: {}
 
   smart-buffer@4.2.0:
     optional: true
 
-  smob@1.5.0: {}
+  socket.io-client@4.8.1(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    dependencies:
+      '@socket.io/component-emitter': 3.1.2
+      debug: 4.3.7
+      engine.io-client: 6.6.3(bufferutil@4.0.8)(utf-8-validate@6.0.3)
+      socket.io-parser: 4.2.4
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
+  socket.io-parser@4.2.4:
+    dependencies:
+      '@socket.io/component-emitter': 3.1.2
+      debug: 4.3.7
+    transitivePeerDependencies:
+      - supports-color
 
   socks-proxy-agent@6.2.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.1
-      socks: 2.8.4
+      debug: 4.4.3
+      socks: 2.8.7
     transitivePeerDependencies:
       - supports-color
     optional: true
 
-  socks@2.8.4:
+  socks@2.8.7:
     dependencies:
-      ip-address: 9.0.5
+      ip-address: 10.1.0
       smart-buffer: 4.2.0
     optional: true
 
@@ -16178,26 +18515,10 @@ snapshots:
 
   source-map@0.6.1: {}
 
-  source-map@0.8.0-beta.0:
-    dependencies:
-      whatwg-url: 7.1.0
+  source-map@0.7.6: {}
 
   spawn-command@0.0.2: {}
 
-  spdx-correct@3.2.0:
-    dependencies:
-      spdx-expression-parse: 3.0.1
-      spdx-license-ids: 3.0.21
-
-  spdx-exceptions@2.5.0: {}
-
-  spdx-expression-parse@3.0.1:
-    dependencies:
-      spdx-exceptions: 2.5.0
-      spdx-license-ids: 3.0.21
-
-  spdx-license-ids@3.0.21: {}
-
   split-ca@1.0.1: {}
 
   split2@3.2.2:
@@ -16206,14 +18527,11 @@ snapshots:
 
   split2@4.2.0: {}
 
-  split@0.3.3:
-    dependencies:
-      through: 2.3.8
-
   sprintf-js@1.0.3: {}
 
-  sprintf-js@1.1.3:
-    optional: true
+  sprintf-js@1.1.3: {}
+
+  sql-escaper@1.3.3: {}
 
   sql.js@1.13.0: {}
 
@@ -16231,44 +18549,44 @@ snapshots:
 
   sqlstring@2.3.3: {}
 
-  ssh2@1.16.0:
+  ssh2@1.17.0:
     dependencies:
       asn1: 0.2.6
       bcrypt-pbkdf: 1.0.2
     optionalDependencies:
       cpu-features: 0.0.10
-      nan: 2.22.2
+      nan: 2.23.1
 
   ssri@8.0.1:
     dependencies:
       minipass: 3.3.6
     optional: true
 
-  sst-darwin-arm64@3.17.0:
+  sst-darwin-arm64@3.17.23:
     optional: true
 
-  sst-darwin-x64@3.17.0:
+  sst-darwin-x64@3.17.23:
     optional: true
 
-  sst-linux-arm64@3.17.0:
+  sst-linux-arm64@3.17.23:
     optional: true
 
-  sst-linux-x64@3.17.0:
+  sst-linux-x64@3.17.23:
     optional: true
 
-  sst-linux-x86@3.17.0:
+  sst-linux-x86@3.17.23:
     optional: true
 
-  sst-win32-arm64@3.17.0:
+  sst-win32-arm64@3.17.23:
     optional: true
 
-  sst-win32-x64@3.17.0:
+  sst-win32-x64@3.17.23:
     optional: true
 
-  sst-win32-x86@3.17.0:
+  sst-win32-x86@3.17.23:
     optional: true
 
-  sst@3.17.0:
+  sst@3.17.23:
     dependencies:
       aws-sdk: 2.1692.0
       aws4fetch: 1.0.18
@@ -16276,14 +18594,14 @@ snapshots:
       opencontrol: 0.0.6
       openid-client: 5.6.4
     optionalDependencies:
-      sst-darwin-arm64: 3.17.0
-      sst-darwin-x64: 3.17.0
-      sst-linux-arm64: 3.17.0
-      sst-linux-x64: 3.17.0
-      sst-linux-x86: 3.17.0
-      sst-win32-arm64: 3.17.0
-      sst-win32-x64: 3.17.0
-      sst-win32-x86: 3.17.0
+      sst-darwin-arm64: 3.17.23
+      sst-darwin-x64: 3.17.23
+      sst-linux-arm64: 3.17.23
+      sst-linux-x64: 3.17.23
+      sst-linux-x86: 3.17.23
+      sst-win32-arm64: 3.17.23
+      sst-win32-x64: 3.17.23
+      sst-win32-x86: 3.17.23
     transitivePeerDependencies:
       - supports-color
 
@@ -16303,21 +18621,16 @@ snapshots:
 
   statuses@2.0.1: {}
 
-  std-env@3.9.0: {}
+  statuses@2.0.2: {}
 
-  stop-iteration-iterator@1.1.0:
-    dependencies:
-      es-errors: 1.3.0
-      internal-slot: 1.1.0
+  std-env@3.10.0: {}
 
   stream-buffers@2.2.0: {}
 
-  stream-combiner@0.0.4:
-    dependencies:
-      duplexer: 0.1.2
-
   streamsearch@1.1.0: {}
 
+  string-argv@0.3.2: {}
+
   string-width@4.2.3:
     dependencies:
       emoji-regex: 8.0.0
@@ -16328,30 +18641,18 @@ snapshots:
     dependencies:
       eastasianwidth: 0.2.0
       emoji-regex: 9.2.2
-      strip-ansi: 7.1.0
-
-  string.prototype.trim@1.2.10:
-    dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-data-property: 1.1.4
-      define-properties: 1.2.1
-      es-abstract: 1.24.0
-      es-object-atoms: 1.1.1
-      has-property-descriptors: 1.0.2
+      strip-ansi: 7.1.2
 
-  string.prototype.trimend@1.0.9:
+  string-width@7.2.0:
     dependencies:
-      call-bind: 1.0.8
-      call-bound: 1.0.4
-      define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      emoji-regex: 10.6.0
+      get-east-asian-width: 1.4.0
+      strip-ansi: 7.1.2
 
-  string.prototype.trimstart@1.0.8:
+  string-width@8.1.0:
     dependencies:
-      call-bind: 1.0.8
-      define-properties: 1.2.1
-      es-object-atoms: 1.1.1
+      get-east-asian-width: 1.4.0
+      strip-ansi: 7.1.2
 
   string_decoder@1.3.0:
     dependencies:
@@ -16365,46 +18666,46 @@ snapshots:
     dependencies:
       ansi-regex: 5.0.1
 
-  strip-ansi@7.1.0:
+  strip-ansi@7.1.2:
     dependencies:
-      ansi-regex: 6.1.0
-
-  strip-bom@3.0.0: {}
+      ansi-regex: 6.2.2
 
   strip-final-newline@3.0.0: {}
 
-  strip-indent@3.0.0:
-    dependencies:
-      min-indent: 1.0.1
-
   strip-json-comments@2.0.1: {}
 
   strip-json-comments@3.1.1: {}
 
-  strnum@1.1.2: {}
+  strnum@2.1.1: {}
 
   structured-headers@0.4.1: {}
 
   sucrase@3.35.0:
     dependencies:
-      '@jridgewell/gen-mapping': 0.3.8
+      '@jridgewell/gen-mapping': 0.3.13
       commander: 4.1.1
-      glob: 10.4.5
+      glob: 10.5.0
       lines-and-columns: 1.2.4
       mz: 2.7.0
       pirates: 4.0.7
       ts-interface-checker: 0.1.13
 
-  superjson@2.2.2:
+  sucrase@3.35.1:
     dependencies:
-      copy-anything: 3.0.5
+      '@jridgewell/gen-mapping': 0.3.13
+      commander: 4.1.1
+      lines-and-columns: 1.2.4
+      mz: 2.7.0
+      pirates: 4.0.7
+      tinyglobby: 0.2.15
+      ts-interface-checker: 0.1.13
 
   supertap@3.0.1:
     dependencies:
       indent-string: 5.0.0
-      js-yaml: 3.14.1
+      js-yaml: 3.14.2
       serialize-error: 7.0.1
-      strip-ansi: 7.1.0
+      strip-ansi: 7.1.2
 
   supports-color@5.5.0:
     dependencies:
@@ -16430,21 +18731,17 @@ snapshots:
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
-  synckit@0.11.8:
-    dependencies:
-      '@pkgr/core': 0.2.7
-
-  tar-fs@2.1.3:
+  tar-fs@2.1.4:
     dependencies:
       chownr: 1.1.4
       mkdirp-classic: 0.5.3
-      pump: 3.0.2
+      pump: 3.0.3
       tar-stream: 2.2.0
 
   tar-stream@2.2.0:
     dependencies:
       bl: 4.1.0
-      end-of-stream: 1.4.4
+      end-of-stream: 1.4.5
       fs-constants: 1.0.0
       inherits: 2.0.4
       readable-stream: 3.6.2
@@ -16458,17 +18755,46 @@ snapshots:
       mkdirp: 1.0.4
       yallist: 4.0.0
 
-  tar@7.4.3:
+  tar@7.5.2:
     dependencies:
       '@isaacs/fs-minipass': 4.0.1
       chownr: 3.0.0
       minipass: 7.1.2
-      minizlib: 3.0.2
-      mkdirp: 3.0.1
+      minizlib: 3.1.0
       yallist: 5.0.0
 
   tarn@3.0.2: {}
 
+  tedious@18.6.2:
+    dependencies:
+      '@azure/core-auth': 1.10.1
+      '@azure/identity': 4.13.0
+      '@azure/keyvault-keys': 4.10.0
+      '@js-joda/core': 5.6.5
+      '@types/node': 24.10.1
+      bl: 6.1.5
+      iconv-lite: 0.6.3
+      js-md4: 0.3.2
+      native-duplexpair: 1.0.0
+      sprintf-js: 1.1.3
+    transitivePeerDependencies:
+      - supports-color
+
+  tedious@19.1.3:
+    dependencies:
+      '@azure/core-auth': 1.10.1
+      '@azure/identity': 4.13.0
+      '@azure/keyvault-keys': 4.10.0
+      '@js-joda/core': 5.6.5
+      '@types/node': 24.10.1
+      bl: 6.1.5
+      iconv-lite: 0.7.0
+      js-md4: 0.3.2
+      native-duplexpair: 1.0.0
+      sprintf-js: 1.1.3
+    transitivePeerDependencies:
+      - supports-color
+
   temp-dir@2.0.0: {}
 
   temp-dir@3.0.0: {}
@@ -16478,10 +18804,10 @@ snapshots:
       ansi-escapes: 4.3.2
       supports-hyperlinks: 2.3.0
 
-  terser@5.40.0:
+  terser@5.44.1:
     dependencies:
-      '@jridgewell/source-map': 0.3.6
-      acorn: 8.14.1
+      '@jridgewell/source-map': 0.3.11
+      acorn: 8.15.0
       commander: 2.20.3
       source-map-support: 0.5.21
 
@@ -16507,17 +18833,8 @@ snapshots:
     dependencies:
       readable-stream: 3.6.2
 
-  through@2.3.8: {}
-
-  tildify@2.0.0: {}
-
   time-zone@1.0.0: {}
 
-  timers-ext@0.1.8:
-    dependencies:
-      es5-ext: 0.10.64
-      next-tick: 1.1.0
-
   tiny-invariant@1.3.3: {}
 
   tiny-queue@0.2.1: {}
@@ -16526,16 +18843,20 @@ snapshots:
 
   tinyexec@0.3.2: {}
 
-  tinyglobby@0.2.14:
+  tinyexec@1.0.4: {}
+
+  tinyglobby@0.2.15:
     dependencies:
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tinypool@1.1.1: {}
 
-  tinypool@1.1.0: {}
+  tinyrainbow@1.2.0: {}
 
-  tinyrainbow@2.0.0: {}
+  tinyrainbow@3.0.3: {}
 
-  tinyspy@4.0.3: {}
+  tinyspy@3.0.2: {}
 
   tmpl@1.0.5: {}
 
@@ -16545,9 +18866,9 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
-  totalist@3.0.1: {}
+  toml@4.1.1: {}
 
-  tr46@1.0.1:
+  tr46@5.1.1:
     dependencies:
       punycode: 2.3.1
 
@@ -16555,11 +18876,11 @@ snapshots:
 
   treeify@1.1.0: {}
 
-  ts-api-utils@1.4.3(typescript@5.6.3):
+  ts-api-utils@1.4.3(typescript@5.9.3):
     dependencies:
-      typescript: 5.6.3
+      typescript: 5.9.3
 
-  ts-expose-internals-conditionally@1.0.0-empty.0: {}
+  ts-expose-internals@5.6.3: {}
 
   ts-interface-checker@0.1.13: {}
 
@@ -16568,112 +18889,97 @@ snapshots:
       '@ts-morph/common': 0.26.1
       code-block-writer: 13.0.3
 
-  ts-node@10.9.2(@types/node@20.17.57)(typescript@5.6.3):
+  ts-node@10.9.2(@types/node@25.5.0)(typescript@5.9.3):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
-      '@tsconfig/node10': 1.0.11
+      '@tsconfig/node10': 1.0.12
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 20.17.57
-      acorn: 8.14.1
+      '@types/node': 25.5.0
+      acorn: 8.15.0
       acorn-walk: 8.3.4
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 5.6.3
+      typescript: 5.9.3
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
-  tsconfck@3.1.6(typescript@5.6.3):
+  tsconfck@3.1.6(typescript@5.9.3):
     optionalDependencies:
-      typescript: 5.6.3
-
-  tsconfig-paths@3.15.0:
-    dependencies:
-      '@types/json5': 0.0.29
-      json5: 1.0.2
-      minimist: 1.2.8
-      strip-bom: 3.0.0
-
-  tslib@1.14.1: {}
-
-  tslib@2.8.1: {}
+      typescript: 5.9.3
 
-  tsup@8.5.0(postcss@8.5.4)(tsx@3.14.0)(typescript@5.6.3)(yaml@2.8.0):
+  tsdown@0.20.3(typescript@5.9.3):
     dependencies:
-      bundle-require: 5.1.0(esbuild@0.25.5)
+      ansis: 4.2.0
       cac: 6.7.14
-      chokidar: 4.0.3
-      consola: 3.4.2
-      debug: 4.4.1
-      esbuild: 0.25.5
-      fix-dts-default-cjs-exports: 1.0.1
-      joycon: 3.1.1
-      picocolors: 1.1.1
-      postcss-load-config: 6.0.1(postcss@8.5.4)(tsx@3.14.0)(yaml@2.8.0)
-      resolve-from: 5.0.0
-      rollup: 4.41.1
-      source-map: 0.8.0-beta.0
-      sucrase: 3.35.0
-      tinyexec: 0.3.2
-      tinyglobby: 0.2.14
+      defu: 6.1.4
+      empathic: 2.0.0
+      hookable: 6.0.1
+      import-without-cache: 0.2.5
+      obug: 2.1.1
+      picomatch: 4.0.3
+      rolldown: 1.0.0-rc.3
+      rolldown-plugin-dts: 0.22.5(rolldown@1.0.0-rc.3)(typescript@5.9.3)
+      semver: 7.7.4
+      tinyexec: 1.0.4
+      tinyglobby: 0.2.15
       tree-kill: 1.2.2
+      unconfig-core: 7.5.0
+      unrun: 0.2.32
     optionalDependencies:
-      postcss: 8.5.4
-      typescript: 5.6.3
+      typescript: 5.9.3
     transitivePeerDependencies:
-      - jiti
-      - supports-color
-      - tsx
-      - yaml
+      - '@ts-macro/tsc'
+      - '@typescript/native-preview'
+      - oxc-resolver
+      - synckit
+      - vue-tsc
 
-  tsup@8.5.0(postcss@8.5.4)(tsx@4.19.4)(typescript@5.6.3)(yaml@2.8.0):
+  tslib@2.8.1: {}
+
+  tsup@8.5.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(typescript@5.9.3)(yaml@2.9.0):
     dependencies:
-      bundle-require: 5.1.0(esbuild@0.25.5)
+      bundle-require: 5.1.0(esbuild@0.27.0)
       cac: 6.7.14
       chokidar: 4.0.3
       consola: 3.4.2
-      debug: 4.4.1
-      esbuild: 0.25.5
+      debug: 4.4.3
+      esbuild: 0.27.0
       fix-dts-default-cjs-exports: 1.0.1
       joycon: 3.1.1
       picocolors: 1.1.1
-      postcss-load-config: 6.0.1(postcss@8.5.4)(tsx@4.19.4)(yaml@2.8.0)
+      postcss-load-config: 6.0.1(jiti@2.6.1)(postcss@8.5.6)(tsx@4.20.6)(yaml@2.9.0)
       resolve-from: 5.0.0
-      rollup: 4.41.1
-      source-map: 0.8.0-beta.0
-      sucrase: 3.35.0
+      rollup: 4.53.3
+      source-map: 0.7.6
+      sucrase: 3.35.1
       tinyexec: 0.3.2
-      tinyglobby: 0.2.14
+      tinyglobby: 0.2.15
       tree-kill: 1.2.2
     optionalDependencies:
-      postcss: 8.5.4
-      typescript: 5.6.3
+      postcss: 8.5.6
+      typescript: 5.9.3
     transitivePeerDependencies:
       - jiti
       - supports-color
       - tsx
       - yaml
 
-  tsutils@3.21.0(typescript@5.6.3):
-    dependencies:
-      tslib: 1.14.1
-      typescript: 5.6.3
-
   tsx@3.14.0:
     dependencies:
       esbuild: 0.18.20
-      get-tsconfig: 4.10.1
+      get-tsconfig: 4.13.6
       source-map-support: 0.5.21
     optionalDependencies:
       fsevents: 2.3.3
 
-  tsx@4.19.4:
+  tsx@4.20.6:
     dependencies:
-      esbuild: 0.25.5
-      get-tsconfig: 4.10.1
+      esbuild: 0.25.12
+      get-tsconfig: 4.13.0
     optionalDependencies:
       fsevents: 2.3.3
 
@@ -16681,32 +18987,32 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
-  turbo-darwin-64@2.5.4:
+  turbo-darwin-64@2.6.1:
     optional: true
 
-  turbo-darwin-arm64@2.5.4:
+  turbo-darwin-arm64@2.6.1:
     optional: true
 
-  turbo-linux-64@2.5.4:
+  turbo-linux-64@2.6.1:
     optional: true
 
-  turbo-linux-arm64@2.5.4:
+  turbo-linux-arm64@2.6.1:
     optional: true
 
-  turbo-windows-64@2.5.4:
+  turbo-windows-64@2.6.1:
     optional: true
 
-  turbo-windows-arm64@2.5.4:
+  turbo-windows-arm64@2.6.1:
     optional: true
 
-  turbo@2.5.4:
+  turbo@2.6.1:
     optionalDependencies:
-      turbo-darwin-64: 2.5.4
-      turbo-darwin-arm64: 2.5.4
-      turbo-linux-64: 2.5.4
-      turbo-linux-arm64: 2.5.4
-      turbo-windows-64: 2.5.4
-      turbo-windows-arm64: 2.5.4
+      turbo-darwin-64: 2.6.1
+      turbo-darwin-arm64: 2.6.1
+      turbo-linux-64: 2.6.1
+      turbo-linux-arm64: 2.6.1
+      turbo-windows-64: 2.6.1
+      turbo-windows-arm64: 2.6.1
 
   tweetnacl@0.14.5: {}
 
@@ -16722,81 +19028,42 @@ snapshots:
 
   type-fest@0.21.3: {}
 
-  type-fest@0.6.0: {}
-
   type-fest@0.7.1: {}
 
-  type-fest@0.8.1: {}
-
   type-is@2.0.1:
     dependencies:
       content-type: 1.0.5
       media-typer: 1.1.0
-      mime-types: 3.0.1
-
-  type@2.7.3: {}
-
-  typed-array-buffer@1.0.3:
-    dependencies:
-      call-bound: 1.0.4
-      es-errors: 1.3.0
-      is-typed-array: 1.1.15
-
-  typed-array-byte-length@1.0.3:
-    dependencies:
-      call-bind: 1.0.8
-      for-each: 0.3.5
-      gopd: 1.2.0
-      has-proto: 1.2.0
-      is-typed-array: 1.1.15
-
-  typed-array-byte-offset@1.0.4:
-    dependencies:
-      available-typed-arrays: 1.0.7
-      call-bind: 1.0.8
-      for-each: 0.3.5
-      gopd: 1.2.0
-      has-proto: 1.2.0
-      is-typed-array: 1.1.15
-      reflect.getprototypeof: 1.0.10
-
-  typed-array-length@1.0.7:
-    dependencies:
-      call-bind: 1.0.8
-      for-each: 0.3.5
-      gopd: 1.2.0
-      is-typed-array: 1.1.15
-      possible-typed-array-names: 1.1.0
-      reflect.getprototypeof: 1.0.10
+      mime-types: 3.0.2
 
-  typescript@5.3.3: {}
+  typebox@1.1.6: {}
 
   typescript@5.6.1-rc: {}
 
-  typescript@5.6.3: {}
+  typescript@5.9.3: {}
 
   ufo@1.6.1: {}
 
-  unbox-primitive@1.1.0:
+  unconfig-core@7.5.0:
     dependencies:
-      call-bound: 1.0.4
-      has-bigints: 1.1.0
-      has-symbols: 1.1.0
-      which-boxed-primitive: 1.1.1
+      '@quansync/fs': 1.0.0
+      quansync: 1.0.0
 
   uncrypto@0.1.3: {}
 
   undici-types@5.26.5: {}
 
-  undici-types@6.19.8: {}
-
   undici-types@6.21.0: {}
 
+  undici-types@7.16.0: {}
+
+  undici-types@7.18.2: {}
+
   undici@5.28.4:
     dependencies:
       '@fastify/busboy': 2.1.1
 
-  undici@6.21.3: {}
+  undici@6.22.0: {}
 
   unicode-canonical-property-names-ecmascript@2.0.1: {}
 
@@ -16805,11 +19072,11 @@ snapshots:
   unicode-match-property-ecmascript@2.0.0:
     dependencies:
       unicode-canonical-property-names-ecmascript: 2.0.1
-      unicode-property-aliases-ecmascript: 2.1.0
+      unicode-property-aliases-ecmascript: 2.2.0
 
-  unicode-match-property-value-ecmascript@2.2.0: {}
+  unicode-match-property-value-ecmascript@2.2.1: {}
 
-  unicode-property-aliases-ecmascript@2.1.0: {}
+  unicode-property-aliases-ecmascript@2.2.0: {}
 
   unicorn-magic@0.3.0: {}
 
@@ -16827,13 +19094,15 @@ snapshots:
     dependencies:
       crypto-random-string: 2.0.0
 
-  universalify@2.0.1: {}
-
   unpipe@1.0.0: {}
 
-  update-browserslist-db@1.1.3(browserslist@4.25.0):
+  unrun@0.2.32:
+    dependencies:
+      rolldown: 1.0.0-rc.9
+
+  update-browserslist-db@1.1.4(browserslist@4.28.0):
     dependencies:
-      browserslist: 4.25.0
+      browserslist: 4.28.0
       escalade: 3.2.0
       picocolors: 1.1.1
 
@@ -16858,7 +19127,7 @@ snapshots:
     dependencies:
       inherits: 2.0.4
       is-arguments: 1.2.0
-      is-generator-function: 1.1.0
+      is-generator-function: 1.1.2
       is-typed-array: 1.1.15
       which-typed-array: 1.1.19
 
@@ -16866,10 +19135,16 @@ snapshots:
 
   uuid@10.0.0: {}
 
+  uuid@11.1.0: {}
+
+  uuid@14.0.0: {}
+
   uuid@7.0.3: {}
 
   uuid@8.0.0: {}
 
+  uuid@8.3.2: {}
+
   uuid@9.0.1: {}
 
   uvu@0.5.6:
@@ -16881,14 +19156,9 @@ snapshots:
 
   v8-compile-cache-lib@3.0.1: {}
 
-  valibot@1.0.0-beta.7(typescript@5.6.3):
+  valibot@1.0.0-beta.7(typescript@5.9.3):
     optionalDependencies:
-      typescript: 5.6.3
-
-  validate-npm-package-license@3.0.4:
-    dependencies:
-      spdx-correct: 3.2.0
-      spdx-expression-parse: 3.0.1
+      typescript: 5.9.3
 
   validate-npm-package-name@4.0.0:
     dependencies:
@@ -16898,100 +19168,15 @@ snapshots:
 
   vary@1.1.2: {}
 
-  vite-node@3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      cac: 6.7.14
-      debug: 4.4.1
-      es-module-lexer: 1.7.0
-      pathe: 2.0.3
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - '@types/node'
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vite-node@3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      cac: 6.7.14
-      debug: 4.4.1
-      es-module-lexer: 1.7.0
-      pathe: 2.0.3
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - '@types/node'
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vite-node@3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      cac: 6.7.14
-      debug: 4.4.1
-      es-module-lexer: 1.7.0
-      pathe: 2.0.3
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - '@types/node'
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vite-node@3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      cac: 6.7.14
-      debug: 4.4.1
-      es-module-lexer: 1.7.0
-      pathe: 2.0.3
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - '@types/node'
-      - jiti
-      - less
-      - lightningcss
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vite-node@3.2.0(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
+  vite-node@2.1.9(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.1
+      debug: 4.4.3
       es-module-lexer: 1.7.0
-      pathe: 2.0.3
-      vite: 6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      pathe: 1.1.2
+      vite: 5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1)
     transitivePeerDependencies:
       - '@types/node'
-      - jiti
       - less
       - lightningcss
       - sass
@@ -17000,286 +19185,100 @@ snapshots:
       - sugarss
       - supports-color
       - terser
-      - tsx
-      - yaml
 
-  vite-tsconfig-paths@4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)):
+  vite-tsconfig-paths@4.3.2(typescript@5.9.3)(vite@7.2.4(@types/node@22.19.1)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)):
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.6.3)
+      tsconfck: 3.1.6(typescript@5.9.3)
     optionalDependencies:
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
+      vite: 7.2.4(@types/node@22.19.1)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  vite-tsconfig-paths@4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)):
+  vite-tsconfig-paths@4.3.2(typescript@5.9.3)(vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)):
     dependencies:
-      debug: 4.4.1
+      debug: 4.4.3
       globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.6.3)
+      tsconfck: 3.1.6(typescript@5.9.3)
     optionalDependencies:
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      vite: 7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  vite-tsconfig-paths@4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)):
+  vite@5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1):
     dependencies:
-      debug: 4.4.1
-      globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.6.3)
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.53.3
     optionalDependencies:
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
+      '@types/node': 25.5.0
+      fsevents: 2.3.3
+      lightningcss: 1.30.2
+      terser: 5.44.1
 
-  vite-tsconfig-paths@4.3.2(typescript@5.6.3)(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)):
+  vite@7.2.4(@types/node@22.19.1)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0):
     dependencies:
-      debug: 4.4.1
-      globrex: 0.1.2
-      tsconfck: 3.1.6(typescript@5.6.3)
+      esbuild: 0.25.12
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.53.3
+      tinyglobby: 0.2.15
     optionalDependencies:
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
+      '@types/node': 22.19.1
+      fsevents: 2.3.3
+      jiti: 2.6.1
+      lightningcss: 1.30.2
+      terser: 5.44.1
+      tsx: 4.20.6
+      yaml: 2.9.0
+    optional: true
 
-  vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
+  vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0):
     dependencies:
-      esbuild: 0.25.5
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
-      postcss: 8.5.4
-      rollup: 4.41.1
-      tinyglobby: 0.2.14
-    optionalDependencies:
-      '@types/node': 18.19.110
-      fsevents: 2.3.3
-      lightningcss: 1.27.0
-      terser: 5.40.0
-      tsx: 3.14.0
-      yaml: 2.8.0
-
-  vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      esbuild: 0.25.5
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
-      postcss: 8.5.4
-      rollup: 4.41.1
-      tinyglobby: 0.2.14
-    optionalDependencies:
-      '@types/node': 18.19.110
-      fsevents: 2.3.3
-      lightningcss: 1.27.0
-      terser: 5.40.0
-      tsx: 4.19.4
-      yaml: 2.8.0
-
-  vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      esbuild: 0.25.5
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
-      postcss: 8.5.4
-      rollup: 4.41.1
-      tinyglobby: 0.2.14
-    optionalDependencies:
-      '@types/node': 20.17.57
-      fsevents: 2.3.3
-      lightningcss: 1.27.0
-      terser: 5.40.0
-      tsx: 3.14.0
-      yaml: 2.8.0
-
-  vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      esbuild: 0.25.5
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
-      postcss: 8.5.4
-      rollup: 4.41.1
-      tinyglobby: 0.2.14
+      esbuild: 0.25.12
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.53.3
+      tinyglobby: 0.2.15
     optionalDependencies:
-      '@types/node': 20.17.57
+      '@types/node': 25.5.0
       fsevents: 2.3.3
-      lightningcss: 1.27.0
-      terser: 5.40.0
-      tsx: 4.19.4
-      yaml: 2.8.0
-
-  vite@6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      esbuild: 0.25.5
-      fdir: 6.4.5(picomatch@4.0.2)
-      picomatch: 4.0.2
-      postcss: 8.5.4
-      rollup: 4.41.1
-      tinyglobby: 0.2.14
-    optionalDependencies:
-      '@types/node': 22.15.29
-      fsevents: 2.3.3
-      lightningcss: 1.27.0
-      terser: 5.40.0
-      tsx: 4.19.4
-      yaml: 2.8.0
-
-  vitest@3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/expect': 3.2.0
-      '@vitest/mocker': 3.2.0(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))
-      '@vitest/pretty-format': 3.2.0
-      '@vitest/runner': 3.2.0
-      '@vitest/snapshot': 3.2.0
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      debug: 4.4.1
-      expect-type: 1.2.1
-      magic-string: 0.30.17
-      pathe: 2.0.3
-      picomatch: 4.0.2
-      std-env: 3.9.0
-      tinybench: 2.9.0
-      tinyexec: 0.3.2
-      tinyglobby: 0.2.14
-      tinypool: 1.1.0
-      tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-      vite-node: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-      why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@types/node': 18.19.110
-    transitivePeerDependencies:
-      - jiti
-      - less
-      - lightningcss
-      - msw
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vitest@3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/expect': 3.2.0
-      '@vitest/mocker': 3.2.0(vite@6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      '@vitest/pretty-format': 3.2.0
-      '@vitest/runner': 3.2.0
-      '@vitest/snapshot': 3.2.0
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      debug: 4.4.1
-      expect-type: 1.2.1
-      magic-string: 0.30.17
-      pathe: 2.0.3
-      picomatch: 4.0.2
-      std-env: 3.9.0
-      tinybench: 2.9.0
-      tinyexec: 0.3.2
-      tinyglobby: 0.2.14
-      tinypool: 1.1.0
-      tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      vite-node: 3.2.0(@types/node@18.19.110)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@types/node': 18.19.110
-    transitivePeerDependencies:
-      - jiti
-      - less
-      - lightningcss
-      - msw
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vitest@3.2.0(@types/node@20.17.57)(@vitest/ui@1.6.1)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/expect': 3.2.0
-      '@vitest/mocker': 3.2.0(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      '@vitest/pretty-format': 3.2.0
-      '@vitest/runner': 3.2.0
-      '@vitest/snapshot': 3.2.0
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      debug: 4.4.1
-      expect-type: 1.2.1
-      magic-string: 0.30.17
-      pathe: 2.0.3
-      picomatch: 4.0.2
-      std-env: 3.9.0
-      tinybench: 2.9.0
-      tinyexec: 0.3.2
-      tinyglobby: 0.2.14
-      tinypool: 1.1.0
-      tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      vite-node: 3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      why-is-node-running: 2.3.0
-    optionalDependencies:
-      '@types/node': 20.17.57
-      '@vitest/ui': 1.6.1(vitest@3.2.0)
-    transitivePeerDependencies:
-      - jiti
-      - less
-      - lightningcss
-      - msw
-      - sass
-      - sass-embedded
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - yaml
-
-  vitest@3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0):
-    dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/expect': 3.2.0
-      '@vitest/mocker': 3.2.0(vite@6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0))
-      '@vitest/pretty-format': 3.2.0
-      '@vitest/runner': 3.2.0
-      '@vitest/snapshot': 3.2.0
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      debug: 4.4.1
-      expect-type: 1.2.1
-      magic-string: 0.30.17
-      pathe: 2.0.3
-      picomatch: 4.0.2
-      std-env: 3.9.0
+      jiti: 2.6.1
+      lightningcss: 1.30.2
+      terser: 5.44.1
+      tsx: 4.20.6
+      yaml: 2.9.0
+
+  vitest@2.1.9(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1):
+    dependencies:
+      '@vitest/expect': 2.1.9
+      '@vitest/mocker': 2.1.9(vite@5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1))
+      '@vitest/pretty-format': 2.1.9
+      '@vitest/runner': 2.1.9
+      '@vitest/snapshot': 2.1.9
+      '@vitest/spy': 2.1.9
+      '@vitest/utils': 2.1.9
+      chai: 5.3.3
+      debug: 4.4.3
+      expect-type: 1.2.2
+      magic-string: 0.30.21
+      pathe: 1.1.2
+      std-env: 3.10.0
       tinybench: 2.9.0
       tinyexec: 0.3.2
-      tinyglobby: 0.2.14
-      tinypool: 1.1.0
-      tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
-      vite-node: 3.2.0(@types/node@20.17.57)(lightningcss@1.27.0)(terser@5.40.0)(tsx@3.14.0)(yaml@2.8.0)
+      tinypool: 1.1.1
+      tinyrainbow: 1.2.0
+      vite: 5.4.21(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1)
+      vite-node: 2.1.9(@types/node@25.5.0)(lightningcss@1.30.2)(terser@5.44.1)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 20.17.57
+      '@types/node': 25.5.0
     transitivePeerDependencies:
-      - jiti
       - less
       - lightningcss
       - msw
@@ -17289,36 +19288,32 @@ snapshots:
       - sugarss
       - supports-color
       - terser
-      - tsx
-      - yaml
 
-  vitest@3.2.0(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0):
-    dependencies:
-      '@types/chai': 5.2.2
-      '@vitest/expect': 3.2.0
-      '@vitest/mocker': 3.2.0(vite@6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0))
-      '@vitest/pretty-format': 3.2.0
-      '@vitest/runner': 3.2.0
-      '@vitest/snapshot': 3.2.0
-      '@vitest/spy': 3.2.0
-      '@vitest/utils': 3.2.0
-      chai: 5.2.0
-      debug: 4.4.1
-      expect-type: 1.2.1
-      magic-string: 0.30.17
+  vitest@4.0.13(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0):
+    dependencies:
+      '@vitest/expect': 4.0.13
+      '@vitest/mocker': 4.0.13(vite@7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0))
+      '@vitest/pretty-format': 4.0.13
+      '@vitest/runner': 4.0.13
+      '@vitest/snapshot': 4.0.13
+      '@vitest/spy': 4.0.13
+      '@vitest/utils': 4.0.13
+      debug: 4.4.3
+      es-module-lexer: 1.7.0
+      expect-type: 1.2.2
+      magic-string: 0.30.21
       pathe: 2.0.3
-      picomatch: 4.0.2
-      std-env: 3.9.0
+      picomatch: 4.0.3
+      std-env: 3.10.0
       tinybench: 2.9.0
       tinyexec: 0.3.2
-      tinyglobby: 0.2.14
-      tinypool: 1.1.0
-      tinyrainbow: 2.0.0
-      vite: 6.3.5(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
-      vite-node: 3.2.0(@types/node@22.15.29)(lightningcss@1.27.0)(terser@5.40.0)(tsx@4.19.4)(yaml@2.8.0)
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 7.2.4(@types/node@25.5.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.20.6)(yaml@2.9.0)
       why-is-node-running: 2.3.0
     optionalDependencies:
-      '@types/node': 22.15.29
+      '@opentelemetry/api': 1.9.0
+      '@types/node': 25.5.0
     transitivePeerDependencies:
       - jiti
       - less
@@ -17345,11 +19340,9 @@ snapshots:
 
   web-streams-polyfill@3.3.3: {}
 
-  webidl-conversions@4.0.2: {}
-
   webidl-conversions@5.0.0: {}
 
-  webpod@0.0.2: {}
+  webidl-conversions@7.0.0: {}
 
   well-known-symbols@2.0.0: {}
 
@@ -17361,42 +19354,10 @@ snapshots:
       punycode: 2.3.1
       webidl-conversions: 5.0.0
 
-  whatwg-url@7.1.0:
-    dependencies:
-      lodash.sortby: 4.7.0
-      tr46: 1.0.1
-      webidl-conversions: 4.0.2
-
-  which-boxed-primitive@1.1.1:
-    dependencies:
-      is-bigint: 1.1.0
-      is-boolean-object: 1.2.2
-      is-number-object: 1.1.1
-      is-string: 1.1.1
-      is-symbol: 1.1.1
-
-  which-builtin-type@1.2.1:
+  whatwg-url@14.2.0:
     dependencies:
-      call-bound: 1.0.4
-      function.prototype.name: 1.1.8
-      has-tostringtag: 1.0.2
-      is-async-function: 2.1.1
-      is-date-object: 1.1.0
-      is-finalizationregistry: 1.1.1
-      is-generator-function: 1.1.0
-      is-regex: 1.2.1
-      is-weakref: 1.1.1
-      isarray: 2.0.5
-      which-boxed-primitive: 1.1.1
-      which-collection: 1.0.2
-      which-typed-array: 1.1.19
-
-  which-collection@1.0.2:
-    dependencies:
-      is-map: 2.0.3
-      is-set: 2.0.3
-      is-weakmap: 2.0.2
-      is-weakset: 2.0.4
+      tr46: 5.1.1
+      webidl-conversions: 7.0.0
 
   which-typed-array@1.1.19:
     dependencies:
@@ -17412,13 +19373,10 @@ snapshots:
     dependencies:
       isexe: 2.0.0
 
-  which@3.0.1:
-    dependencies:
-      isexe: 2.0.0
-
   which@4.0.0:
     dependencies:
       isexe: 3.1.1
+    optional: true
 
   why-is-node-running@2.3.0:
     dependencies:
@@ -17444,9 +19402,15 @@ snapshots:
 
   wrap-ansi@8.1.0:
     dependencies:
-      ansi-styles: 6.2.1
+      ansi-styles: 6.2.3
       string-width: 5.1.2
-      strip-ansi: 7.1.0
+      strip-ansi: 7.1.2
+
+  wrap-ansi@9.0.2:
+    dependencies:
+      ansi-styles: 6.2.3
+      string-width: 7.2.0
+      strip-ansi: 7.1.2
 
   wrappy@1.0.2: {}
 
@@ -17477,11 +19441,20 @@ snapshots:
       bufferutil: 4.0.8
       utf-8-validate: 6.0.3
 
-  ws@8.18.2(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+  ws@8.17.1(bufferutil@4.0.8)(utf-8-validate@6.0.3):
+    optionalDependencies:
+      bufferutil: 4.0.8
+      utf-8-validate: 6.0.3
+
+  ws@8.18.3(bufferutil@4.0.8)(utf-8-validate@6.0.3):
     optionalDependencies:
       bufferutil: 4.0.8
       utf-8-validate: 6.0.3
 
+  wsl-utils@0.1.0:
+    dependencies:
+      is-wsl: 3.1.0
+
   xcode@3.0.1:
     dependencies:
       simple-plist: 1.3.1
@@ -17489,7 +19462,7 @@ snapshots:
 
   xml2js@0.6.0:
     dependencies:
-      sax: 1.4.1
+      sax: 1.4.3
       xmlbuilder: 11.0.1
 
   xml2js@0.6.2:
@@ -17501,6 +19474,8 @@ snapshots:
 
   xmlbuilder@15.1.1: {}
 
+  xmlhttprequest-ssl@2.1.2: {}
+
   xtend@4.0.2: {}
 
   y18n@5.0.8: {}
@@ -17511,7 +19486,9 @@ snapshots:
 
   yallist@5.0.0: {}
 
-  yaml@2.8.0: {}
+  yaml@2.8.1: {}
+
+  yaml@2.9.0: {}
 
   yargs-parser@20.2.9: {}
 
@@ -17541,36 +19518,36 @@ snapshots:
 
   yocto-queue@0.1.0: {}
 
-  yocto-queue@1.2.1: {}
+  yocto-queue@1.2.2: {}
 
   zod-to-json-schema@3.24.3(zod@3.24.2):
     dependencies:
       zod: 3.24.2
 
-  zod-to-json-schema@3.24.3(zod@3.25.1):
+  zod-to-json-schema@3.25.0(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
+  zod-to-json-schema@3.25.2(zod@3.25.1):
     dependencies:
       zod: 3.25.1
+    optional: true
+
+  zod-to-json-schema@3.25.2(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
+  zod-to-json-schema@3.25.2(zod@4.3.4):
+    dependencies:
+      zod: 4.3.4
+    optional: true
 
   zod@3.24.2: {}
 
   zod@3.25.1: {}
 
-  zx@7.2.3:
-    dependencies:
-      '@types/fs-extra': 11.0.4
-      '@types/minimist': 1.2.5
-      '@types/node': 18.19.110
-      '@types/ps-tree': 1.1.6
-      '@types/which': 3.0.4
-      chalk: 5.4.1
-      fs-extra: 11.3.0
-      fx: 36.0.3
-      globby: 13.2.2
-      minimist: 1.2.8
-      node-fetch: 3.3.1
-      ps-tree: 1.2.0
-      webpod: 0.0.2
-      which: 3.0.1
-      yaml: 2.8.0
+  zod@3.25.76: {}
+
+  zod@4.3.4: {}
 
-  zx@8.5.4: {}
+  zx@8.8.5: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 81c66b18e4..64e0b52acb 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,13 +1,12 @@
 packages:
+  - attw-fork
   - drizzle-orm
   - drizzle-kit
-  - drizzle-zod
-  - drizzle-typebox
-  - drizzle-valibot
-  - drizzle-arktype
   - drizzle-seed
   - integration-tests
+  - typeperf-test
   - eslint-plugin-drizzle
+
 onlyBuiltDependencies:
   - '@contrast/fn-inspect'
   - '@newrelic/native-metrics'
@@ -17,8 +16,10 @@ onlyBuiltDependencies:
   - bufferutil
   - cpu-features
   - dprint
+  - duckdb
   - es5-ext
   - esbuild
+  - msgpackr-extract
   - prisma
   - protobufjs
   - sqlite3
diff --git a/scripts/setup-runners.sh b/scripts/setup-runners.sh
new file mode 100755
index 0000000000..aa71cdac63
--- /dev/null
+++ b/scripts/setup-runners.sh
@@ -0,0 +1,222 @@
+#!/bin/bash
+set -e
+
+# ============================================
+# CONFIGURATION - Edit these values or pass as env vars
+# ============================================
+GITHUB_TOKEN="${GITHUB_TOKEN:-YOUR_RUNNER_TOKEN_HERE}"
+GITHUB_URL="${GITHUB_URL:-https://github.com/drizzle-team/drizzle-orm}"
+RUNNER_COUNT="${RUNNER_COUNT:-10}"
+RUNNER_PREFIX="${RUNNER_PREFIX:-beelink}"
+RUNNER_LABELS="${RUNNER_LABELS:-self-hosted,linux,x64}"
+
+BASE_DIR="${BASE_DIR:-/opt/actions-runner}"
+SHARED_CACHE_DIR="$BASE_DIR/cache"
+RUNNER_TARBALL="$BASE_DIR/runner.tar.gz"
+
+# ============================================
+# Validation
+# ============================================
+if [[ "$GITHUB_TOKEN" == "YOUR_RUNNER_TOKEN_HERE" ]]; then
+    echo "ERROR: Please set GITHUB_TOKEN environment variable or edit this script"
+    echo "Usage: GITHUB_TOKEN=xxx ./setup-runners.sh"
+    exit 1
+fi
+
+if [[ ! -f "$RUNNER_TARBALL" ]]; then
+    echo "ERROR: Runner tarball not found at $RUNNER_TARBALL"
+    echo "Download it from: https://github.com/actions/runner/releases"
+    exit 1
+fi
+
+# ============================================
+# Install global dependencies
+# ============================================
+echo "Checking global dependencies..."
+
+# Check for Node.js
+if ! command -v node &> /dev/null; then
+    echo "ERROR: Node.js is not installed. Please install Node.js 20+ first."
+    echo "  curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -"
+    echo "  sudo apt-get install -y nodejs"
+    exit 1
+fi
+
+# Install pnpm globally if not present
+if ! command -v pnpm &> /dev/null; then
+    echo "Installing pnpm globally..."
+    npm install -g pnpm
+fi
+
+# Install bun globally if not present
+if ! command -v bun &> /dev/null; then
+    echo "Installing bun globally..."
+    curl -fsSL https://bun.sh/install | bash
+    export BUN_INSTALL="$HOME/.bun"
+    export PATH="$BUN_INSTALL/bin:$PATH"
+fi
+
+echo "Node: $(node --version)"
+echo "pnpm: $(pnpm --version)"
+echo "bun: $(bun --version)"
+
+# ============================================
+# Create shared directories
+# ============================================
+sudo mkdir -p "$BASE_DIR"
+sudo chown "$(whoami):$(id -gn)" "$BASE_DIR"
+
+mkdir -p "$SHARED_CACHE_DIR/pnpm-store"
+mkdir -p "$SHARED_CACHE_DIR/npm"
+mkdir -p "$SHARED_CACHE_DIR/bun"
+mkdir -p "$SHARED_CACHE_DIR/node"
+mkdir -p "$SHARED_CACHE_DIR/turbo"
+mkdir -p "$SHARED_CACHE_DIR/artifacts"
+
+ENV_FILE="$BASE_DIR/runner.env"
+
+# Auto-detect paths for node, pnpm, bun
+# Check for Volta first (manages node, npm, pnpm, yarn from one bin)
+VOLTA_BIN="${HOME}/.volta/bin"
+NODE_BIN="$(dirname "$(which node 2>/dev/null)" || echo '')"
+PNPM_BIN="$(dirname "$(which pnpm 2>/dev/null)" || echo '')"
+BUN_BIN="${HOME}/.bun/bin"
+
+# Build PATH with all necessary directories
+RUNNER_PATH=""
+[ -d "$VOLTA_BIN" ] && RUNNER_PATH="$VOLTA_BIN"
+[ -n "$NODE_BIN" ] && [[ ":$RUNNER_PATH:" != *":$NODE_BIN:"* ]] && RUNNER_PATH="$RUNNER_PATH:$NODE_BIN"
+[ -n "$PNPM_BIN" ] && [[ ":$RUNNER_PATH:" != *":$PNPM_BIN:"* ]] && RUNNER_PATH="$RUNNER_PATH:$PNPM_BIN"
+[ -d "$BUN_BIN" ] && [[ ":$RUNNER_PATH:" != *":$BUN_BIN:"* ]] && RUNNER_PATH="$RUNNER_PATH:$BUN_BIN"
+RUNNER_PATH="$RUNNER_PATH:/usr/local/bin:/usr/bin:/bin"
+# Remove leading colon if present
+RUNNER_PATH="${RUNNER_PATH#:}"
+
+echo "Detected paths:"
+echo "  VOLTA_BIN: $VOLTA_BIN"
+echo "  NODE_BIN: $NODE_BIN"
+echo "  PNPM_BIN: $PNPM_BIN"
+echo "  BUN_BIN: $BUN_BIN"
+echo "  RUNNER_PATH: $RUNNER_PATH"
+
+cat > "$ENV_FILE" << EOF
+# PATH - include node, pnpm, bun paths
+PATH=$RUNNER_PATH
+
+# pnpm
+PNPM_HOME=$SHARED_CACHE_DIR/pnpm
+PNPM_STORE_DIR=$SHARED_CACHE_DIR/pnpm-store
+
+# npm
+npm_config_cache=$SHARED_CACHE_DIR/npm
+
+# Bun
+BUN_INSTALL=$HOME/.bun
+BUN_INSTALL_CACHE_DIR=$SHARED_CACHE_DIR/bun
+
+# Node.js
+NODE_COMPILE_CACHE=$SHARED_CACHE_DIR/node
+
+# Turbo
+TURBO_CACHE_DIR=$SHARED_CACHE_DIR/turbo
+
+# Local artifacts (for CI)
+LOCAL_ARTIFACTS_DIR=$SHARED_CACHE_DIR/artifacts
+EOF
+
+echo "Created environment file at $ENV_FILE"
+
+for i in $(seq 1 $RUNNER_COUNT); do
+    RUNNER_NAME="${RUNNER_PREFIX}-${i}"
+    RUNNER_DIR="$BASE_DIR/$RUNNER_NAME"
+    WORK_DIR="$BASE_DIR/work-$i"
+    
+    # Create work directory
+    mkdir -p "$WORK_DIR"
+    
+    if [ -d "$RUNNER_DIR" ] && [ -f "$RUNNER_DIR/.runner" ]; then
+        echo "Runner $RUNNER_NAME already configured, skipping setup..."
+    else
+        echo "Setting up runner $RUNNER_NAME..."
+        mkdir -p "$RUNNER_DIR"
+        
+        # Extract runner
+        tar -xzf "$RUNNER_TARBALL" -C "$RUNNER_DIR"
+        
+        # Configure runner - each runner gets its own work directory to avoid git lock conflicts
+        cd "$RUNNER_DIR"
+        ./config.sh \
+            --url "$GITHUB_URL" \
+            --token "$GITHUB_TOKEN" \
+            --name "$RUNNER_NAME" \
+            --labels "$RUNNER_LABELS" \
+            --work "$WORK_DIR" \
+            --unattended \
+            --replace
+    fi
+done
+
+echo "All runners configured!"
+
+echo "Creating systemd service files..."
+
+for i in $(seq 1 $RUNNER_COUNT); do
+    RUNNER_NAME="${RUNNER_PREFIX}-${i}"
+    RUNNER_DIR="$BASE_DIR/$RUNNER_NAME"
+    SERVICE_FILE="/etc/systemd/system/github-runner-${RUNNER_NAME}.service"
+    
+    sudo tee "$SERVICE_FILE" > /dev/null << EOF
+[Unit]
+Description=GitHub Actions Runner ($RUNNER_NAME)
+After=network.target
+
+[Service]
+Type=simple
+User=$(whoami)
+WorkingDirectory=$RUNNER_DIR
+EnvironmentFile=$BASE_DIR/runner.env
+ExecStart=$RUNNER_DIR/run.sh
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+    echo "Created service: github-runner-${RUNNER_NAME}"
+done
+
+echo "Reloading systemd and starting runners..."
+sudo systemctl daemon-reload
+
+for i in $(seq 1 $RUNNER_COUNT); do
+    RUNNER_NAME="${RUNNER_PREFIX}-${i}"
+    sudo systemctl enable "github-runner-${RUNNER_NAME}"
+    sudo systemctl start "github-runner-${RUNNER_NAME}"
+    echo "Started github-runner-${RUNNER_NAME}"
+done
+
+echo ""
+echo "============================================"
+echo "Setup complete! Runner status:"
+echo "============================================"
+for i in $(seq 1 $RUNNER_COUNT); do
+    RUNNER_NAME="${RUNNER_PREFIX}-${i}"
+    STATUS=$(sudo systemctl is-active "github-runner-${RUNNER_NAME}" 2>/dev/null || echo "unknown")
+    echo "  $RUNNER_NAME: $STATUS"
+done
+
+echo ""
+echo "Shared directories:"
+echo "  Work:      $BASE_DIR/work-{1..$RUNNER_COUNT} (one per runner)"
+echo "  Cache:     $SHARED_CACHE_DIR"
+echo "  Artifacts: $SHARED_CACHE_DIR/artifacts"
+echo ""
+echo "Environment file: $ENV_FILE"
+echo ""
+echo "Useful commands:"
+echo "  View logs:    journalctl -u github-runner-${RUNNER_PREFIX}-1 -f"
+echo "  Stop all:     for i in \$(seq 1 $RUNNER_COUNT); do sudo systemctl stop github-runner-${RUNNER_PREFIX}-\$i; done"
+echo "  Start all:    for i in \$(seq 1 $RUNNER_COUNT); do sudo systemctl start github-runner-${RUNNER_PREFIX}-\$i; done"
+echo "  Restart all:  for i in \$(seq 1 $RUNNER_COUNT); do sudo systemctl restart github-runner-${RUNNER_PREFIX}-\$i; done"
+echo "  Status all:   for i in \$(seq 1 $RUNNER_COUNT); do sudo systemctl status github-runner-${RUNNER_PREFIX}-\$i --no-pager; done"
diff --git a/src/db-ops/mocks.ts b/src/db-ops/mocks.ts
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tsconfig.json b/tsconfig.json
index 0b23000856..0f989f7cc9 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -34,8 +34,7 @@
 		"allowUnreachableCode": false, /* Disable error reporting for unreachable code. */
 		"skipLibCheck": true, /* Skip type checking all .d.ts files. */
 		"noErrorTruncation": true, /* Disable truncating types in error messages. */
-		"checkJs": true,
-		"allowImportingTsExtensions": true
+		"checkJs": true
 	},
 	"exclude": ["**/dist"]
 }
diff --git a/turbo.json b/turbo.json
index 706cb691e0..e108bc52fc 100644
--- a/turbo.json
+++ b/turbo.json
@@ -3,8 +3,7 @@
 	"tasks": {
 		"//#lint": {
 			"dependsOn": [
-				"^test:types",
-				"drizzle-orm#build"
+				"^test:types"
 			],
 			"inputs": [
 				"**/*.ts",
@@ -16,9 +15,7 @@
 		},
 		"test:types": {
 			"dependsOn": [
-				"^test:types",
-				"drizzle-orm#build",
-				"drizzle-seed#build"
+				"drizzle-orm#build"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -29,6 +26,22 @@
 			],
 			"outputLogs": "new-only"
 		},
+		"build": {
+			"dependsOn": [
+				"drizzle-orm#build"
+			],
+			"outputLogs": "new-only"
+		},
+		"attw-fork#build": {
+			"inputs": [],
+			"outputs": [],
+			"outputLogs": "none"
+		},
+		"typeperf-tests#build": {
+			"inputs": [],
+			"outputs": [],
+			"outputLogs": "none"
+		},
 		"drizzle-orm#build": {
 			"inputs": [
 				"src/**/*.ts",
@@ -48,7 +61,7 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"@drizzle-team/drizzle-kit#build": {
+		"drizzle-kit#build": {
 			"dependsOn": [
 				"drizzle-orm#build"
 			],
@@ -70,7 +83,7 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"drizzle-zod#build": {
+		"eslint-plugin-drizzle#build": {
 			"dependsOn": [
 				"drizzle-orm#build"
 			],
@@ -92,7 +105,7 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"drizzle-typebox#build": {
+		"drizzle-seed#build": {
 			"dependsOn": [
 				"drizzle-orm#build"
 			],
@@ -114,9 +127,10 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"drizzle-valibot#build": {
+		"integration-tests#build": {
 			"dependsOn": [
-				"drizzle-orm#build"
+				"drizzle-orm#build",
+				"drizzle-seed#build"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -136,9 +150,38 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"drizzle-arktype#build": {
+		"attw-fork#build:artifact": {
+			"inputs": [],
+			"outputs": [],
+			"outputLogs": "none"
+		},
+		"typeperf-tests#build:artifact": {
+			"inputs": [],
+			"outputs": [],
+			"outputLogs": "none"
+		},
+		"drizzle-orm#build:artifact": {
+			"inputs": [
+				"src/**/*.ts",
+				"package.json",
+				"README.md",
+				"../README.md",
+				"tsconfig.json",
+				"tsconfig.*.json",
+				"tsup.config.ts",
+				"scripts/build.ts",
+				"scripts/fix-imports.ts",
+				"../tsconfig.json"
+			],
+			"outputs": [
+				"dist/**",
+				"dist-dts/**"
+			],
+			"outputLogs": "new-only"
+		},
+		"drizzle-kit#build:artifact": {
 			"dependsOn": [
-				"drizzle-orm#build"
+				"drizzle-orm#build:artifact"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -158,9 +201,9 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"eslint-plugin-drizzle#build": {
+		"eslint-plugin-drizzle#build:artifact": {
 			"dependsOn": [
-				"drizzle-orm#build"
+				"drizzle-orm#build:artifact"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -180,9 +223,9 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"drizzle-seed#build": {
+		"drizzle-seed#build:artifact": {
 			"dependsOn": [
-				"drizzle-orm#build"
+				"drizzle-orm#build:artifact"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -202,10 +245,10 @@
 			],
 			"outputLogs": "new-only"
 		},
-		"integration-tests#build": {
+		"integration-tests#build:artifact": {
 			"dependsOn": [
-				"drizzle-orm#build",
-				"drizzle-seed#build"
+				"drizzle-orm#build:artifact",
+				"drizzle-seed#build:artifact"
 			],
 			"inputs": [
 				"src/**/*.ts",
@@ -238,6 +281,18 @@
 			],
 			"outputLogs": "new-only"
 		},
+		"pack:artifact": {
+			"dependsOn": [
+				"build:artifact"
+			],
+			"inputs": [
+				"dist/**"
+			],
+			"outputs": [
+				"package.tgz"
+			],
+			"outputLogs": "new-only"
+		},
 		"test": {
 			"dependsOn": [
 				"build",
diff --git a/typeperf-test/benches/beta/pg-columns.bench.ts b/typeperf-test/benches/beta/pg-columns.bench.ts
new file mode 100644
index 0000000000..569c8c7f72
--- /dev/null
+++ b/typeperf-test/benches/beta/pg-columns.bench.ts
@@ -0,0 +1,293 @@
+/**
+ * PostgreSQL columns type performance benchmarks - BETA VERSION
+ *
+ * This is a mirror of ../pg-columns.bench.ts but using drizzle-beta.
+ * Run this to capture/update baseline values for the main benchmark.
+ *
+ * Run with: tsx benches/beta/pg-columns.bench.ts
+ */
+import { bench } from '@ark/attest';
+import type { InferInsertModel, InferSelectModel } from 'drizzle-beta';
+import { eq } from 'drizzle-beta';
+import { drizzle } from 'drizzle-beta/node-postgres';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-beta/pg-core';
+
+// Baseline expression - warm up the type checker
+pgTable('baseline', { id: integer() });
+
+// --- Table Definition Benchmarks ---
+
+bench('pg table - 5 columns with modifiers', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as typeof users;
+}).types([471, 'instantiations']);
+
+bench('pg table - 10 columns', () => {
+	const table = pgTable('table_10_cols', {
+		id: integer().primaryKey(),
+		uuid: uuid().notNull(),
+		name: text().notNull(),
+		email: varchar({ length: 255 }).notNull(),
+		bio: text(),
+		active: boolean().default(true),
+		role: text().default('user'),
+		createdAt: timestamp().defaultNow(),
+		updatedAt: timestamp(),
+		deletedAt: timestamp(),
+	});
+	return {} as typeof table;
+}).types([907, 'instantiations']);
+
+// --- Type Inference Benchmarks ---
+
+bench('infer select model - 5 columns', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as InferSelectModel<typeof users>;
+}).types([5418, 'instantiations']);
+
+bench('infer insert model - 5 columns', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as InferInsertModel<typeof users>;
+}).types([5478, 'instantiations']);
+
+// --- Query Benchmarks ---
+
+bench('select query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.select().from(users);
+}).types([7132, 'instantiations']);
+
+bench('insert query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.insert(users).values({ id: 1, name: 'test', email: 'test@test.com' });
+}).types([8176, 'instantiations']);
+
+bench('update query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.update(users).set({ name: 'updated' }).where(eq(users.id, 1));
+}).types([7518, 'instantiations']);
+
+// --- Relational Query Benchmarks ---
+
+// Schema for relational queries
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+});
+
+const posts = pgTable('posts', {
+	id: integer().primaryKey(),
+	title: text().notNull(),
+	content: text(),
+	authorId: integer().notNull(),
+});
+
+const comments = pgTable('comments', {
+	id: integer().primaryKey(),
+	text: text().notNull(),
+	postId: integer().notNull(),
+	authorId: integer().notNull(),
+});
+
+// Define relations
+import { defineRelations } from 'drizzle-beta';
+
+const schema = { users, posts, comments };
+
+const relations = defineRelations(schema, (r) => ({
+	users: {
+		posts: r.many.posts({
+			from: r.users.id,
+			to: r.posts.authorId,
+		}),
+		comments: r.many.comments({
+			from: r.users.id,
+			to: r.comments.authorId,
+		}),
+	},
+	posts: {
+		author: r.one.users({
+			from: r.posts.authorId,
+			to: r.users.id,
+		}),
+		comments: r.many.comments({
+			from: r.posts.id,
+			to: r.comments.postId,
+		}),
+	},
+	comments: {
+		post: r.one.posts({
+			from: r.comments.postId,
+			to: r.posts.id,
+		}),
+		author: r.one.users({
+			from: r.comments.authorId,
+			to: r.users.id,
+		}),
+	},
+}));
+
+bench('rqb - findMany simple', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany();
+}).types([1430, 'instantiations']);
+
+bench('rqb - findMany with columns', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+	});
+}).types([1532, 'instantiations']);
+
+bench('rqb - findMany with one relation', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.posts.findMany({
+		with: {
+			author: true,
+		},
+	});
+}).types([3491, 'instantiations']);
+
+bench('rqb - findMany with nested relations', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+}).types([2713, 'instantiations']);
+
+bench('rqb - findFirst with where', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: true,
+		},
+	});
+}).types([2547, 'instantiations']);
+
+// --- Relational Query Benchmarks (with inline table definitions) ---
+
+bench('rqb inline - findMany simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+	});
+
+	const posts = pgTable('posts', {
+		id: integer().primaryKey(),
+		title: text().notNull(),
+		content: text(),
+		authorId: integer().notNull(),
+	});
+
+	const schema = { users, posts };
+
+	const relations = defineRelations(schema, (r) => ({
+		users: {
+			posts: r.many.posts({
+				from: r.users.id,
+				to: r.posts.authorId,
+			}),
+		},
+		posts: {
+			author: r.one.users({
+				from: r.posts.authorId,
+				to: r.users.id,
+			}),
+		},
+	}));
+
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany();
+}).types([5130, 'instantiations']);
+
+bench('rqb inline - findMany with relation', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+	});
+
+	const posts = pgTable('posts', {
+		id: integer().primaryKey(),
+		title: text().notNull(),
+		content: text(),
+		authorId: integer().notNull(),
+	});
+
+	const schema = { users, posts };
+
+	const relations = defineRelations(schema, (r) => ({
+		users: {
+			posts: r.many.posts({
+				from: r.users.id,
+				to: r.posts.authorId,
+			}),
+		},
+		posts: {
+			author: r.one.users({
+				from: r.posts.authorId,
+				to: r.users.id,
+			}),
+		},
+	}));
+
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.posts.findMany({
+		with: {
+			author: true,
+		},
+	});
+}).types([7168, 'instantiations']);
diff --git a/typeperf-test/benches/pg-columns.bench.ts b/typeperf-test/benches/pg-columns.bench.ts
new file mode 100644
index 0000000000..85c21a55dc
--- /dev/null
+++ b/typeperf-test/benches/pg-columns.bench.ts
@@ -0,0 +1,296 @@
+/**
+ * PostgreSQL columns type performance benchmarks
+ *
+ * These benchmarks measure the type instantiation cost of various drizzle-orm operations.
+ * Run with: tsx benches/pg-columns.bench.ts
+ *
+ * Baselines reflect optimized drizzle-orm with:
+ * - Direct property access in RequiredKeyOnly/OptionalKeyOnly
+ * - Variance annotations (out keyword) on Column, ColumnBuilder, PgColumn, PgColumnBuilder, Table, PgTable
+ */
+import { bench } from '@ark/attest';
+import type { InferInsertModel, InferSelectModel } from 'drizzle-orm';
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+
+// Baseline expression - warm up the type checker with a minimal import
+// This ensures subsequent benchmarks don't include initial module resolution costs
+pgTable('baseline', { id: integer() });
+
+// --- Table Definition Benchmarks ---
+
+bench('pg table - 5 columns with modifiers', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as typeof users;
+}).types([126, 'instantiations']);
+
+bench('pg table - 10 columns', () => {
+	const table = pgTable('table_10_cols', {
+		id: integer().primaryKey(),
+		uuid: uuid().notNull(),
+		name: text().notNull(),
+		email: varchar({ length: 255 }).notNull(),
+		bio: text(),
+		active: boolean().default(true),
+		role: text().default('user'),
+		createdAt: timestamp().defaultNow(),
+		updatedAt: timestamp(),
+		deletedAt: timestamp(),
+	});
+	return {} as typeof table;
+}).types([202, 'instantiations']);
+
+// --- Type Inference Benchmarks ---
+
+bench('infer select model - 5 columns', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as InferSelectModel<typeof users>;
+}).types([541, 'instantiations']);
+
+bench('infer insert model - 5 columns', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	return {} as InferInsertModel<typeof users>;
+}).types([1078, 'instantiations']);
+
+// --- Query Benchmarks ---
+
+bench('select query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.select().from(users);
+}).types([915, 'instantiations']);
+
+bench('insert query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.insert(users).values({ id: 1, name: 'test', email: 'test@test.com' });
+}).types([1411, 'instantiations']);
+
+bench('update query - simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+		active: boolean().default(true),
+		createdAt: timestamp().defaultNow(),
+	});
+	const db = drizzle({ connection: 'postgres://...' });
+	return db.update(users).set({ name: 'updated' }).where(eq(users.id, 1));
+}).types([2043, 'instantiations']);
+
+// --- Relational Query Benchmarks ---
+
+// Schema for relational queries
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+});
+
+const posts = pgTable('posts', {
+	id: integer().primaryKey(),
+	title: text().notNull(),
+	content: text(),
+	authorId: integer().notNull(),
+});
+
+const comments = pgTable('comments', {
+	id: integer().primaryKey(),
+	text: text().notNull(),
+	postId: integer().notNull(),
+	authorId: integer().notNull(),
+});
+
+// Define relations
+import { defineRelations } from 'drizzle-orm';
+
+const schema = { users, posts, comments };
+
+const relations = defineRelations(schema, (r) => ({
+	users: {
+		posts: r.many.posts({
+			from: r.users.id,
+			to: r.posts.authorId,
+		}),
+		comments: r.many.comments({
+			from: r.users.id,
+			to: r.comments.authorId,
+		}),
+	},
+	posts: {
+		author: r.one.users({
+			from: r.posts.authorId,
+			to: r.users.id,
+		}),
+		comments: r.many.comments({
+			from: r.posts.id,
+			to: r.comments.postId,
+		}),
+	},
+	comments: {
+		post: r.one.posts({
+			from: r.comments.postId,
+			to: r.posts.id,
+		}),
+		author: r.one.users({
+			from: r.comments.authorId,
+			to: r.users.id,
+		}),
+	},
+}));
+
+bench('rqb - findMany simple', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany();
+}).types([1387, 'instantiations']);
+
+bench('rqb - findMany with columns', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany({
+		columns: {
+			id: true,
+			name: true,
+		},
+	});
+}).types([1443, 'instantiations']);
+
+bench('rqb - findMany with one relation', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.posts.findMany({
+		with: {
+			author: true,
+		},
+	});
+}).types([1540, 'instantiations']);
+
+bench('rqb - findMany with nested relations', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany({
+		with: {
+			posts: {
+				with: {
+					comments: true,
+				},
+			},
+		},
+	});
+}).types([1455, 'instantiations']);
+
+bench('rqb - findFirst with where', () => {
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findFirst({
+		where: {
+			id: 1,
+		},
+		with: {
+			posts: true,
+		},
+	});
+}).types([1630, 'instantiations']);
+
+// --- Relational Query Benchmarks (with inline table definitions) ---
+
+bench('rqb inline - findMany simple', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+	});
+
+	const posts = pgTable('posts', {
+		id: integer().primaryKey(),
+		title: text().notNull(),
+		content: text(),
+		authorId: integer().notNull(),
+	});
+
+	const schema = { users, posts };
+
+	const relations = defineRelations(schema, (r) => ({
+		users: {
+			posts: r.many.posts({
+				from: r.users.id,
+				to: r.posts.authorId,
+			}),
+		},
+		posts: {
+			author: r.one.users({
+				from: r.posts.authorId,
+				to: r.users.id,
+			}),
+		},
+	}));
+
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.users.findMany();
+}).types([1812, 'instantiations']);
+
+bench('rqb inline - findMany with relation', () => {
+	const users = pgTable('users', {
+		id: integer().primaryKey(),
+		name: text().notNull(),
+		email: text().notNull(),
+	});
+
+	const posts = pgTable('posts', {
+		id: integer().primaryKey(),
+		title: text().notNull(),
+		content: text(),
+		authorId: integer().notNull(),
+	});
+
+	const schema = { users, posts };
+
+	const relations = defineRelations(schema, (r) => ({
+		users: {
+			posts: r.many.posts({
+				from: r.users.id,
+				to: r.posts.authorId,
+			}),
+		},
+		posts: {
+			author: r.one.users({
+				from: r.posts.authorId,
+				to: r.users.id,
+			}),
+		},
+	}));
+
+	const db = drizzle({ connection: 'postgres://...', relations });
+	return db.query.posts.findMany({
+		with: {
+			author: true,
+		},
+	});
+}).types([1965, 'instantiations']);
diff --git a/typeperf-test/benches/type-cache.bench.ts b/typeperf-test/benches/type-cache.bench.ts
new file mode 100644
index 0000000000..96761db6fa
--- /dev/null
+++ b/typeperf-test/benches/type-cache.bench.ts
@@ -0,0 +1,128 @@
+/**
+ * Type cache performance benchmarks
+ *
+ * These benchmarks test whether type inference is properly cached when using a same table multiple times.
+ * Run with: tsx benches/type-cache.bench.ts
+ */
+import { bench } from '@ark/attest';
+import { integer, pgTable, text } from 'drizzle-orm/pg-core';
+import { drizzle } from 'drizzle-orm/postgres-js';
+
+const db = drizzle.mock();
+
+// Define a table once
+const cachedTable = pgTable('cached', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+});
+
+bench('same table - 3 references', () => {
+	return {
+		t1: {} as typeof cachedTable,
+		t2: {} as typeof cachedTable,
+		t3: {} as typeof cachedTable,
+	};
+}).types([24, 'instantiations']);
+
+bench('same table - 5 references', () => {
+	return {
+		t1: {} as typeof cachedTable,
+		t2: {} as typeof cachedTable,
+		t3: {} as typeof cachedTable,
+		t4: {} as typeof cachedTable,
+		t5: {} as typeof cachedTable,
+	};
+}).types([24, 'instantiations']);
+
+bench('inline tables - 1 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text().notNull() });
+	return {
+		table: {} as typeof t1,
+	};
+}).types([41, 'instantiations']);
+
+bench('inline tables - 1 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text({ enum: ['one', 'two'] }).notNull() });
+	return {
+		table: {} as typeof t1,
+	};
+}).types([168, 'instantiations']);
+
+bench('inline tables - 2 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text().notNull() });
+	const t2 = pgTable('t2', { id: integer().primaryKey(), name: text().notNull() });
+	return {
+		t1: {} as typeof t1,
+		t2: {} as typeof t2,
+	};
+}).types([63, 'instantiations']);
+
+bench('inline tables - 3 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text().notNull() });
+	const t2 = pgTable('t2', { id: integer().primaryKey(), name: text().notNull() });
+	const t3 = pgTable('t3', { id: integer().primaryKey(), name: text().notNull() });
+	return {
+		t1: {} as typeof t1,
+		t2: {} as typeof t2,
+		t3: {} as typeof t3,
+	};
+}).types([85, 'instantiations']);
+
+bench('inferSelect once', () => {
+	return {} as typeof cachedTable.$inferSelect;
+}).types([60, 'instantiations']);
+
+bench('inferSelect+select', () => {
+	const _ = {} as typeof cachedTable.$inferSelect;
+	const res2 = db.select().from(cachedTable);
+	return {};
+}).types([514, 'instantiations']); // 617
+
+bench('inferSelect+select2', () => {
+	const _ = {} as typeof cachedTable.$inferSelect;
+	const res2 = db.select().from(cachedTable).where(undefined).limit(10).offset(10);
+	return {};
+}).types([1534, 'instantiations']); // 1666
+
+// hmm, it's indeed cached
+bench('inferSelect+select3', () => {
+	const _ = {} as typeof cachedTable.$inferSelect;
+	const res1 = db.select().from(cachedTable);
+	const res2 = db.select().from(cachedTable).where(undefined).limit(10).offset(10);
+	return {};
+}).types([1534, 'instantiations']);
+
+bench('access inferInsert', () => {
+	return {
+		ins: {} as typeof cachedTable.$inferInsert,
+	};
+}).types([378, 'instantiations']); // down from 445
+
+bench('access inferInsert', () => {
+	return {
+		in: {} as typeof cachedTable.$inferInsert,
+		ins: {} as typeof cachedTable.$inferInsert,
+	};
+}).types([378, 'instantiations']); // down from 445
+
+bench('inline $ - 1 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text().notNull() });
+	return {
+		table: {} as typeof t1,
+		sel: {} as typeof t1.$inferSelect,
+		ins: {} as typeof t1.$inferInsert,
+	};
+}).types([430, 'instantiations']); // from 494
+
+bench('inline $ - 2 times', () => {
+	const t1 = pgTable('t1', { id: integer().primaryKey(), name: text().notNull() });
+	const t2 = pgTable('t2', { id: integer().primaryKey(), name: text().notNull() });
+	return {
+		t1: {} as typeof t1,
+		t1Sel: {} as typeof t1.$inferSelect,
+		t1Ins: {} as typeof t1.$inferInsert,
+		t2: {} as typeof t2,
+		t2Sel: {} as typeof t2.$inferSelect,
+		t2Ins: {} as typeof t2.$inferInsert,
+	};
+}).types([658, 'instantiations']); // from 733
diff --git a/typeperf-test/cases/column/access-builder-config.ts b/typeperf-test/cases/column/access-builder-config.ts
new file mode 100644
index 0000000000..a88e8fe60f
--- /dev/null
+++ b/typeperf-test/cases/column/access-builder-config.ts
@@ -0,0 +1,5 @@
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = typeof column._.dataType;
diff --git a/typeperf-test/cases/column/access-config.ts b/typeperf-test/cases/column/access-config.ts
new file mode 100644
index 0000000000..8a81dbda8c
--- /dev/null
+++ b/typeperf-test/cases/column/access-config.ts
@@ -0,0 +1,8 @@
+import type { BuildColumn } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column, 'pg'>;
+
+export type Config = Col['_'];
diff --git a/typeperf-test/cases/column/base.ts b/typeperf-test/cases/column/base.ts
new file mode 100644
index 0000000000..2c1c113c32
--- /dev/null
+++ b/typeperf-test/cases/column/base.ts
@@ -0,0 +1,3 @@
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
diff --git a/typeperf-test/cases/column/build-col.ts b/typeperf-test/cases/column/build-col.ts
new file mode 100644
index 0000000000..7a8c470ffd
--- /dev/null
+++ b/typeperf-test/cases/column/build-col.ts
@@ -0,0 +1,6 @@
+import type { BuildColumn } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column, 'pg'>;
diff --git a/typeperf-test/cases/column/builderless-extends-col-optimized.ts b/typeperf-test/cases/column/builderless-extends-col-optimized.ts
new file mode 100644
index 0000000000..b230325564
--- /dev/null
+++ b/typeperf-test/cases/column/builderless-extends-col-optimized.ts
@@ -0,0 +1,26 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { text } from 'drizzle-orm/pg-core';
+import type { Column, PgColumn } from '../../lib/optimized-columns';
+
+export const column = text('text');
+
+export type Col = PgColumn<{
+	name: 'a';
+	columnType: 'string';
+	data: string;
+	dataType: 'string';
+	driverParam: string;
+	enumValues: string[];
+	hasDefault: false;
+	hasRuntimeDefault: false;
+	isAutoincrement: false;
+	isPrimaryKey: false;
+	notNull: true;
+	tableName: 't';
+}>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp = Check<Col>;
+
+export type Data = Col['dataType'];
diff --git a/typeperf-test/cases/column/builderless-extends-col.ts b/typeperf-test/cases/column/builderless-extends-col.ts
new file mode 100644
index 0000000000..cfec2e45c2
--- /dev/null
+++ b/typeperf-test/cases/column/builderless-extends-col.ts
@@ -0,0 +1,34 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import type { Column } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = Column<
+	{
+		name: 'a';
+		columnType: 'string';
+		data: string;
+		dataType: 'string';
+		driverParam: string;
+		enumValues: string[];
+		hasDefault: false;
+		hasRuntimeDefault: false;
+		isAutoincrement: false;
+		isPrimaryKey: false;
+		notNull: true;
+		tableName: 't';
+	},
+	{
+		c: 'str';
+	},
+	{
+		d: 'str';
+	}
+>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp = Check<Col>;
+
+export type Data = Col['_']['dataType'];
diff --git a/typeperf-test/cases/column/col-extends-col-optimized.ts b/typeperf-test/cases/column/col-extends-col-optimized.ts
new file mode 100644
index 0000000000..4516cca539
--- /dev/null
+++ b/typeperf-test/cases/column/col-extends-col-optimized.ts
@@ -0,0 +1,11 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { text } from 'drizzle-orm/pg-core';
+import type { BuildColumn, Column } from '../../lib/optimized-columns';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp = Check<Col>;
diff --git a/typeperf-test/cases/column/col-extends-col.ts b/typeperf-test/cases/column/col-extends-col.ts
new file mode 100644
index 0000000000..cbd9e5e4df
--- /dev/null
+++ b/typeperf-test/cases/column/col-extends-col.ts
@@ -0,0 +1,10 @@
+import type { BuildColumn, Column } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column, 'pg'>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp1 = Check<Col>;
diff --git a/typeperf-test/cases/columns/base.ts b/typeperf-test/cases/columns/base.ts
new file mode 100644
index 0000000000..442dcdaf62
--- /dev/null
+++ b/typeperf-test/cases/columns/base.ts
@@ -0,0 +1,7 @@
+import { integer, text, uuid } from 'drizzle-orm/pg-core';
+
+export const rawColumns = {
+	text: text('text'),
+	int: integer('number'),
+	id: uuid(),
+};
diff --git a/typeperf-test/cases/columns/build-10-cols.ts b/typeperf-test/cases/columns/build-10-cols.ts
new file mode 100644
index 0000000000..3f1df8922f
--- /dev/null
+++ b/typeperf-test/cases/columns/build-10-cols.ts
@@ -0,0 +1,17 @@
+import type { BuildColumns } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const rawColumns = {
+	text0: text('text'),
+	text1: text('text'),
+	text2: text('text'),
+	text3: text('text'),
+	text4: text('text'),
+	text5: text('text'),
+	text6: text('text'),
+	text7: text('text'),
+	text8: text('text'),
+	text9: text('text'),
+};
+
+export type Columns = BuildColumns<'t', typeof rawColumns, 'pg'>;
diff --git a/typeperf-test/cases/columns/build-cols.ts b/typeperf-test/cases/columns/build-cols.ts
new file mode 100644
index 0000000000..d9a0517fa4
--- /dev/null
+++ b/typeperf-test/cases/columns/build-cols.ts
@@ -0,0 +1,10 @@
+import type { BuildColumns } from 'drizzle-orm';
+import { integer, text, uuid } from 'drizzle-orm/pg-core';
+
+export const rawColumns = {
+	text: text('text'),
+	int: integer('number'),
+	id: uuid(),
+};
+
+export type Columns = BuildColumns<'t', typeof rawColumns, 'pg'>;
diff --git a/typeperf-test/cases/columns/check-10-cols.ts b/typeperf-test/cases/columns/check-10-cols.ts
new file mode 100644
index 0000000000..db71759421
--- /dev/null
+++ b/typeperf-test/cases/columns/check-10-cols.ts
@@ -0,0 +1,23 @@
+import type { BuildColumns, Column } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const rawColumns = {
+	text0: text('text'),
+	text1: text('text'),
+	text2: text('text'),
+	text3: text('text'),
+	text4: text('text'),
+	text5: text('text'),
+	text6: text('text'),
+	text7: text('text'),
+	text8: text('text'),
+	text9: text('text'),
+};
+
+export type Columns = BuildColumns<'t', typeof rawColumns, 'pg'>;
+
+export type Check<TColumns extends Record<string, Column>> = {
+	[K in keyof TColumns]: TColumns[K]['_']['dataType'];
+};
+
+export type Tmp = Check<Columns>;
diff --git a/typeperf-test/cases/columns/col-extends-col-optimized.ts b/typeperf-test/cases/columns/col-extends-col-optimized.ts
new file mode 100644
index 0000000000..4516cca539
--- /dev/null
+++ b/typeperf-test/cases/columns/col-extends-col-optimized.ts
@@ -0,0 +1,11 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { text } from 'drizzle-orm/pg-core';
+import type { BuildColumn, Column } from '../../lib/optimized-columns';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp = Check<Col>;
diff --git a/typeperf-test/cases/columns/col-extends-col.ts b/typeperf-test/cases/columns/col-extends-col.ts
new file mode 100644
index 0000000000..cbd9e5e4df
--- /dev/null
+++ b/typeperf-test/cases/columns/col-extends-col.ts
@@ -0,0 +1,10 @@
+import type { BuildColumn, Column } from 'drizzle-orm';
+import { text } from 'drizzle-orm/pg-core';
+
+export const column = text('text');
+
+export type Col = BuildColumn<'t', typeof column, 'pg'>;
+
+export type Check<TColumn extends Column> = TColumn;
+
+export type Tmp1 = Check<Col>;
diff --git a/typeperf-test/cases/columns/cols-extends-cols-optimized.ts b/typeperf-test/cases/columns/cols-extends-cols-optimized.ts
new file mode 100644
index 0000000000..9c4c9fd768
--- /dev/null
+++ b/typeperf-test/cases/columns/cols-extends-cols-optimized.ts
@@ -0,0 +1,17 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import { integer, text, uuid } from 'drizzle-orm/pg-core';
+import type { BuildColumns, Column } from '../../lib/optimized-columns';
+
+export const rawColumns = {
+	text: text('text'),
+	int: integer('number'),
+	id: uuid(),
+};
+
+export type Columns = BuildColumns<'t', typeof rawColumns>;
+
+export type Check<TColumns extends Record<string, Column>> = {
+	[K in keyof TColumns]: TColumns[K];
+};
+
+export type Tmp = Check<Columns>;
diff --git a/typeperf-test/cases/columns/cols-extends-cols.ts b/typeperf-test/cases/columns/cols-extends-cols.ts
new file mode 100644
index 0000000000..314f251140
--- /dev/null
+++ b/typeperf-test/cases/columns/cols-extends-cols.ts
@@ -0,0 +1,14 @@
+import type { BuildColumns, Column } from 'drizzle-orm';
+import { integer, text, uuid } from 'drizzle-orm/pg-core';
+
+export const rawColumns = {
+	text: text('text'),
+	int: integer('number'),
+	id: uuid(),
+};
+
+export type Columns = BuildColumns<'t', typeof rawColumns, 'pg'>;
+
+export type Check<TColumns extends Record<string, Column>> = TColumns;
+
+export type Tmp = Check<Columns>;
diff --git a/typeperf-test/cases/custom-column-test.ts b/typeperf-test/cases/custom-column-test.ts
new file mode 100644
index 0000000000..8bfd938cb3
--- /dev/null
+++ b/typeperf-test/cases/custom-column-test.ts
@@ -0,0 +1,40 @@
+import { customType, pgTable } from 'drizzle-orm/pg-core';
+
+// Define custom column types
+const myInteger = customType<{ data: number; driverData: number }>({
+	dataType() {
+		return 'integer';
+	},
+});
+
+const myText = customType<{ data: string; driverData: string }>({
+	dataType() {
+		return 'text';
+	},
+});
+
+const myBoolean = customType<{ data: boolean; driverData: boolean }>({
+	dataType() {
+		return 'boolean';
+	},
+});
+
+const myTimestamp = customType<{ data: Date; driverData: string }>({
+	dataType() {
+		return 'timestamp';
+	},
+	fromDriver(value: string) {
+		return new Date(value);
+	},
+});
+
+// Create table with custom columns
+const users = pgTable('users', {
+	id: myInteger().notNull().primaryKey(),
+	name: myText().notNull(),
+	email: myText().notNull(),
+	active: myBoolean().default(true),
+	createdAt: myTimestamp().defaultNow(),
+});
+
+export type UsersTable = typeof users;
diff --git a/typeperf-test/cases/pg-columns/base.ts b/typeperf-test/cases/pg-columns/base.ts
new file mode 100644
index 0000000000..9948b8a641
--- /dev/null
+++ b/typeperf-test/cases/pg-columns/base.ts
@@ -0,0 +1,6 @@
+// Baseline: minimal imports, no type operations
+import { integer, pgTable } from 'drizzle-orm/pg-core';
+
+export const t = pgTable('t', {
+	id: integer(),
+});
diff --git a/typeperf-test/cases/pg-columns/infer.ts b/typeperf-test/cases/pg-columns/infer.ts
new file mode 100644
index 0000000000..89115d862d
--- /dev/null
+++ b/typeperf-test/cases/pg-columns/infer.ts
@@ -0,0 +1,44 @@
+// Test: type inference
+import type { InferInsertModel, InferSelectModel } from 'drizzle-orm';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table5ColsModifiers = pgTable('table_5_cols_modifiers', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table10Cols = pgTable('table_10_cols', {
+	id: integer().primaryKey(),
+	uuid: uuid().notNull(),
+	name: text().notNull(),
+	email: varchar({ length: 255 }).notNull(),
+	bio: text(),
+	active: boolean().default(true),
+	role: text().default('user'),
+	createdAt: timestamp().defaultNow(),
+	updatedAt: timestamp(),
+	deletedAt: timestamp(),
+});
+
+// Infer from users table
+export type User = InferSelectModel<typeof users>;
+export type NewUser = InferInsertModel<typeof users>;
+
+// Infer from table with modifiers
+export type Table5Select = InferSelectModel<typeof table5ColsModifiers>;
+export type Table5Insert = InferInsertModel<typeof table5ColsModifiers>;
+
+// Infer from large table
+export type Table10Select = InferSelectModel<typeof table10Cols>;
+export type Table10Insert = InferInsertModel<typeof table10Cols>;
diff --git a/typeperf-test/cases/pg-columns/insert.ts b/typeperf-test/cases/pg-columns/insert.ts
new file mode 100644
index 0000000000..e4807af583
--- /dev/null
+++ b/typeperf-test/cases/pg-columns/insert.ts
@@ -0,0 +1,51 @@
+// Test: insert queries
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table5ColsModifiers = pgTable('table_5_cols_modifiers', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table10Cols = pgTable('table_10_cols', {
+	id: integer().primaryKey(),
+	uuid: uuid().notNull(),
+	name: text().notNull(),
+	email: varchar({ length: 255 }).notNull(),
+	bio: text(),
+	active: boolean().default(true),
+	role: text().default('user'),
+	createdAt: timestamp().defaultNow(),
+	updatedAt: timestamp(),
+	deletedAt: timestamp(),
+});
+
+const db = drizzle({ connection: 'postgres://...' });
+
+// Simple insert
+export const insertOne = db.insert(users).values({ id: 1, name: 'test', email: 'test@test.com' });
+
+// Insert with returning
+export const insertReturning = db.insert(users).values({ id: 1, name: 'test', email: 'test@test.com' }).returning();
+
+// Insert into table with modifiers (uses defaults)
+export const insertModifiers = db.insert(table5ColsModifiers).values({ id: 1, name: 'test', email: 'test@test.com' });
+
+// Insert into large table
+export const insertLarge = db.insert(table10Cols).values({
+	id: 1,
+	uuid: '123e4567-e89b-12d3-a456-426614174000',
+	name: 'test',
+	email: 'test@test.com',
+});
diff --git a/typeperf-test/cases/pg-columns/select.ts b/typeperf-test/cases/pg-columns/select.ts
new file mode 100644
index 0000000000..c92664be12
--- /dev/null
+++ b/typeperf-test/cases/pg-columns/select.ts
@@ -0,0 +1,50 @@
+// Test: select queries
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table5ColsModifiers = pgTable('table_5_cols_modifiers', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table10Cols = pgTable('table_10_cols', {
+	id: integer().primaryKey(),
+	uuid: uuid().notNull(),
+	name: text().notNull(),
+	email: varchar({ length: 255 }).notNull(),
+	bio: text(),
+	active: boolean().default(true),
+	role: text().default('user'),
+	createdAt: timestamp().defaultNow(),
+	updatedAt: timestamp(),
+	deletedAt: timestamp(),
+});
+
+const db = drizzle({ connection: 'postgres://...' });
+
+// Simple select
+export const selectAll = db.select().from(users);
+
+// Select with where
+export const selectWhere = db.select().from(users).where(eq(users.id, 1));
+
+// Select from larger table
+export const selectLarge = db.select().from(table10Cols).where(eq(table10Cols.id, 1));
+
+// Select specific columns
+export const selectCols = db.select({ id: users.id, name: users.name }).from(users);
+
+// Select from table with modifiers
+export const selectModifiers = db.select().from(table5ColsModifiers);
diff --git a/typeperf-test/cases/pg-columns/update.ts b/typeperf-test/cases/pg-columns/update.ts
new file mode 100644
index 0000000000..c8e291ccf0
--- /dev/null
+++ b/typeperf-test/cases/pg-columns/update.ts
@@ -0,0 +1,51 @@
+// Test: update queries
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { boolean, integer, pgTable, text, timestamp, uuid, varchar } from 'drizzle-orm/pg-core';
+
+const users = pgTable('users', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table5ColsModifiers = pgTable('table_5_cols_modifiers', {
+	id: integer().primaryKey(),
+	name: text().notNull(),
+	email: text().notNull(),
+	active: boolean().default(true),
+	createdAt: timestamp().defaultNow(),
+});
+
+const table10Cols = pgTable('table_10_cols', {
+	id: integer().primaryKey(),
+	uuid: uuid().notNull(),
+	name: text().notNull(),
+	email: varchar({ length: 255 }).notNull(),
+	bio: text(),
+	active: boolean().default(true),
+	role: text().default('user'),
+	createdAt: timestamp().defaultNow(),
+	updatedAt: timestamp(),
+	deletedAt: timestamp(),
+});
+
+const db = drizzle({ connection: 'postgres://...' });
+
+// Simple update
+export const updateOne = db.update(users).set({ name: 'updated' }).where(eq(users.id, 1));
+
+// Update with returning
+export const updateReturning = db.update(users).set({ name: 'updated' }).where(eq(users.id, 1)).returning();
+
+// Update table with modifiers
+export const updateModifiers = db.update(table5ColsModifiers).set({ name: 'updated' }).where(
+	eq(table5ColsModifiers.id, 1),
+);
+
+// Update large table
+export const updateLarge = db.update(table10Cols).set({ name: 'updated', email: 'new@test.com' }).where(
+	eq(table10Cols.id, 1),
+);
diff --git a/typeperf-test/cases/rqb/base.ts b/typeperf-test/cases/rqb/base.ts
new file mode 100644
index 0000000000..50f517e9a3
--- /dev/null
+++ b/typeperf-test/cases/rqb/base.ts
@@ -0,0 +1,8 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { drizzle } from 'drizzle-orm/node-postgres';
+import * as schema from '../../lib/big-schema.ts';
+
+export const db = drizzle({
+	connection: 'postgres:/...',
+});
diff --git a/typeperf-test/cases/rqb/bypass-attempt.ts b/typeperf-test/cases/rqb/bypass-attempt.ts
new file mode 100644
index 0000000000..2c32eb7326
--- /dev/null
+++ b/typeperf-test/cases/rqb/bypass-attempt.ts
@@ -0,0 +1,15 @@
+import type { ExtractTablesFromSchema, RelationsBuilder, RelationsBuilderConfig } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import type * as schema from '../../lib/big-schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+// This works without flooding instances
+export type Tables = ExtractTablesFromSchema<typeof schema.tables>;
+export type Config = RelationsBuilderConfig<typeof schema.tables>;
+export type Builder = RelationsBuilder<typeof schema.tables>;
+
+// However this doesn't - extracting tables from schema is a mandatory step
+// export type Tables = ExtractTablesFromSchema<typeof schema>;
+// export type Config = RelationsBuilderConfig<Tables>;
+// export type Builder = RelationsBuilder<Tables>;
diff --git a/typeperf-test/cases/rqb/extract-tables.ts b/typeperf-test/cases/rqb/extract-tables.ts
new file mode 100644
index 0000000000..bca26f9421
--- /dev/null
+++ b/typeperf-test/cases/rqb/extract-tables.ts
@@ -0,0 +1,9 @@
+import type { ExtractTablesFromSchema } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import type * as schema from '../../lib/big-schema.ts';
+
+export const db = drizzle({
+	connection: 'postgres:/...',
+});
+
+export type Tables = ExtractTablesFromSchema<typeof schema.tables>;
diff --git a/typeperf-test/cases/rqb/relations-empty-unused.ts b/typeperf-test/cases/rqb/relations-empty-unused.ts
new file mode 100644
index 0000000000..dda07232e7
--- /dev/null
+++ b/typeperf-test/cases/rqb/relations-empty-unused.ts
@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable unused-imports/no-unused-imports */
+import { defineRelations } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import * as schema from '../../lib/big-schema.ts';
+
+export const relations = defineRelations(schema);
+
+export const db = drizzle({ connection: 'postgres:/...' });
diff --git a/typeperf-test/cases/rqb/relations-empty-used.ts b/typeperf-test/cases/rqb/relations-empty-used.ts
new file mode 100644
index 0000000000..139d33d881
--- /dev/null
+++ b/typeperf-test/cases/rqb/relations-empty-used.ts
@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable unused-imports/no-unused-imports */
+import { defineRelations } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import * as schema from '../../lib/big-schema.ts';
+
+export const relations = defineRelations(schema);
+
+export const db = drizzle({ connection: 'postgres:/...', relations });
diff --git a/typeperf-test/cases/rqb/relations-queries.ts b/typeperf-test/cases/rqb/relations-queries.ts
new file mode 100644
index 0000000000..16b2204b3e
--- /dev/null
+++ b/typeperf-test/cases/rqb/relations-queries.ts
@@ -0,0 +1,126 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { relations } from '../../lib/big-schema-rels.ts';
+
+export const db = drizzle({
+	connection: 'postgres:/...',
+	relations,
+});
+
+export const q1 = await db.query.user.findMany({
+	with: {
+		featurePermissionTiers: true,
+		referrals: {
+			columns: {
+				id: true,
+				inviteeEmail: true,
+				isLegacyReferral: true,
+				skipReferrerCredit: false,
+			},
+		},
+	},
+	where: {
+		apiDisabled: true,
+		createdTime: {
+			lt: new Date().toISOString(),
+		},
+		bookingLinksViaInviteeBooking: true,
+		bookingLinksCreatedByUserId: false,
+		emailAccounts: {
+			email: 'somemail@example.com',
+			users: true,
+		},
+		RAW: (t, { sql }) => sql`${t} = 5`,
+	},
+	columns: {
+		createdTime: false,
+	},
+	extras: {
+		count: (t, { sql }) => sql`SELECT COUNT(*) FROM ${t}`,
+	},
+	limit: 5,
+	offset: 3,
+	orderBy: {
+		id: 'desc',
+		name: 'asc',
+	},
+});
+
+export const q2 = await db.query.user.findFirst({
+	with: {
+		featurePermissionTiers: true,
+		referrals: {
+			columns: {
+				id: true,
+				inviteeEmail: true,
+				isLegacyReferral: true,
+				skipReferrerCredit: false,
+			},
+		},
+	},
+	where: {
+		apiDisabled: true,
+		createdTime: {
+			lt: new Date().toISOString(),
+		},
+		bookingLinksViaInviteeBooking: true,
+		bookingLinksCreatedByUserId: false,
+		emailAccounts: {
+			email: 'somemail@example.com',
+			users: true,
+		},
+		RAW: (t, { sql }) => sql`${t} = 5`,
+	},
+	columns: {
+		createdTime: false,
+	},
+	extras: {
+		count: (t, { sql }) => sql`SELECT COUNT(*) FROM ${t}`,
+	},
+	offset: 3,
+	orderBy: {
+		id: 'desc',
+		name: 'asc',
+	},
+});
+
+export const q3 = await db.query.calendarEventExtensions.findMany({
+	columns: {
+		bookingLinkId: false,
+	},
+	where: {
+		bookingLinkId: '10',
+		AND: [
+			{
+				createdTime: {
+					lte: new Date(Date.now() - 1500000).toISOString(),
+				},
+			},
+			{
+				createdTime: {
+					gt: new Date(1500000).toISOString(),
+				},
+			},
+		],
+	},
+	orderBy: {
+		id: 'asc',
+		bookingLinkId: 'desc',
+	},
+	limit: 20,
+	offset: 35,
+	extras: {
+		count: (t) => db.$count(t),
+	},
+	with: {
+		calendar: {
+			with: {
+				calendarEventExtensions: true,
+			},
+			columns: {
+				accessRole: true,
+				status: true,
+				colorId: false,
+			},
+		},
+	},
+});
diff --git a/typeperf-test/cases/rqb/relations-query.ts b/typeperf-test/cases/rqb/relations-query.ts
new file mode 100644
index 0000000000..3dc3ba8d14
--- /dev/null
+++ b/typeperf-test/cases/rqb/relations-query.ts
@@ -0,0 +1,33 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { relations } from '../../lib/big-schema-rels.ts';
+
+export const db = drizzle({
+	connection: 'postgres:/...',
+	relations,
+});
+
+export const usersWithPosts = await db.query.user.findMany({
+	with: {
+		featurePermissionTiers: true,
+		referrals: {
+			columns: {
+				id: true,
+				inviteeEmail: true,
+				isLegacyReferral: true,
+				skipReferrerCredit: false,
+			},
+		},
+	},
+	columns: {
+		createdTime: false,
+	},
+	extras: {
+		count: (t, { sql }) => sql`SELECT COUNT(*) FROM ${t}`,
+	},
+	limit: 5,
+	offset: 3,
+	orderBy: {
+		id: 'desc',
+		name: 'asc',
+	},
+});
diff --git a/typeperf-test/cases/rqb/relations.ts b/typeperf-test/cases/rqb/relations.ts
new file mode 100644
index 0000000000..40e5deba79
--- /dev/null
+++ b/typeperf-test/cases/rqb/relations.ts
@@ -0,0 +1,7 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { relations } from '../../lib/big-schema-rels.ts';
+
+export const db = drizzle({
+	connection: 'postgres:/...',
+	relations,
+});
diff --git a/typeperf-test/cases/table-bypass/base.ts b/typeperf-test/cases/table-bypass/base.ts
new file mode 100644
index 0000000000..ed51aa96ca
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/base.ts
@@ -0,0 +1,3 @@
+import type * as tables from '../../lib/big-schema.ts';
+
+export type Schema = typeof tables;
diff --git a/typeperf-test/cases/table-bypass/step0.ts b/typeperf-test/cases/table-bypass/step0.ts
new file mode 100644
index 0000000000..8500b7e02c
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/step0.ts
@@ -0,0 +1,4 @@
+import type * as tables from '../../lib/big-schema.ts';
+
+export type Schema = typeof tables;
+export type A = Schema['user']['_']['columns']['apiDisabled']['_'];
diff --git a/typeperf-test/cases/table-bypass/step1.ts b/typeperf-test/cases/table-bypass/step1.ts
new file mode 100644
index 0000000000..936fceb103
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/step1.ts
@@ -0,0 +1,15 @@
+// import type { ExtractTablesFromSchema } from 'drizzle-orm';
+import type { Table, View } from 'drizzle-orm';
+import type * as schema from '../../lib/big-schema.ts';
+
+type KeysOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+// 2. Pick only those keys
+type PickByValue<T, V> = Pick<T, KeysOfType<T, V>>;
+
+// 3. Your TrimSchema is then
+type TrimSchema<U> = PickByValue<U, Table | View>;
+
+export type Tables = TrimSchema<typeof schema>;
+
+export type A = Tables['apiWebhook']['_'];
diff --git a/typeperf-test/cases/table-bypass/step2.ts b/typeperf-test/cases/table-bypass/step2.ts
new file mode 100644
index 0000000000..755930a1af
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/step2.ts
@@ -0,0 +1,26 @@
+import type { RelationsBuilderEntry, Table } from 'drizzle-orm';
+import type * as schema from '../../lib/big-schema.ts';
+
+// export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
+// 	[K in keyof TSchema & string as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? TSchema[K]
+// 		: never;
+// };
+
+type TrimSchema<U extends Record<string, unknown>> = {
+	[
+		K in keyof U as U[K] extends { '~brand': 'Table' } ? K : never
+	]: U[K] & Table;
+};
+
+export type RelationsBuilderConfig<TTables extends Record<string, Table>> = {
+	[TTableName in keyof TTables & string]: Record<
+		string,
+		RelationsBuilderEntry<TTables, TTableName>
+	>;
+};
+
+export type Step1 = TrimSchema<typeof schema>;
+export type Step2 = RelationsBuilderConfig<Step1>;
+
+// export type Config = RelationsBuilderConfig<ExtractTablesFromSchema<typeof schema>>;
+// export type Config = RelationsBuilderConfig<TrimSchema<typeof schema>>;
diff --git a/typeperf-test/cases/table-bypass/step3.ts b/typeperf-test/cases/table-bypass/step3.ts
new file mode 100644
index 0000000000..1cdfe22ca5
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/step3.ts
@@ -0,0 +1,6 @@
+import type { ExtractTablesFromSchema, RelationsBuilder } from 'drizzle-orm';
+import type * as schema from '../../lib/big-schema.ts';
+
+export type r = RelationsBuilder<ExtractTablesFromSchema<typeof schema>>;
+
+export type tmp = r['_']['tables']['apiWebhook'];
diff --git a/typeperf-test/cases/table-bypass/step4.ts b/typeperf-test/cases/table-bypass/step4.ts
new file mode 100644
index 0000000000..5e82890c1f
--- /dev/null
+++ b/typeperf-test/cases/table-bypass/step4.ts
@@ -0,0 +1,49 @@
+import {
+	defineRelations,
+	type ExtractTablesWithRelations,
+	type RelationsFilter,
+	sql,
+	type Table,
+	type View,
+} from 'drizzle-orm';
+import { pgTable, text } from 'drizzle-orm/pg-core';
+import { drizzle } from 'drizzle-orm/pglite';
+
+export const apiWebhook = pgTable('ApiWebhook', {
+	failures: text(),
+});
+
+export const user = pgTable('user', {
+	id: text(),
+});
+
+const schema = {
+	apiWebhook,
+	user,
+};
+
+const relations = defineRelations(schema);
+
+export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
+	[
+		K in keyof TSchema as TSchema[K] extends { '~brand': 'Table' | 'View'; _: any } ? K : never
+	]: TSchema[K] & (Table | View);
+};
+
+type Extracted = ExtractTablesFromSchema<typeof schema>;
+
+export type A = Extracted['apiWebhook']['_']['columns'];
+
+const db = drizzle({
+	relations,
+});
+
+db.query.apiWebhook.findMany({
+	where: {
+		failures: sql.placeholder(''),
+	},
+});
+
+type TRCfg = ExtractTablesWithRelations<typeof relations>;
+
+export type F = RelationsFilter<TRCfg['apiWebhook'], TRCfg>;
diff --git a/typeperf-test/cases/table/base.ts b/typeperf-test/cases/table/base.ts
new file mode 100644
index 0000000000..872150537d
--- /dev/null
+++ b/typeperf-test/cases/table/base.ts
@@ -0,0 +1,6 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
diff --git a/typeperf-test/cases/table/extract-and-check-columns.ts b/typeperf-test/cases/table/extract-and-check-columns.ts
new file mode 100644
index 0000000000..5a19f3a37f
--- /dev/null
+++ b/typeperf-test/cases/table/extract-and-check-columns.ts
@@ -0,0 +1,23 @@
+import type { AnyColumn } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, unknown>> = {
+	[K in keyof TTables as TTables[K] extends { _: { brand: 'Table'; name: string; columns: any } } ? K : never]:
+		TTables[K] extends { _: { columns: infer Columns } } ? Columns : never;
+};
+
+type TextColumnsOnly<TColumns extends Record<string, unknown>> = {
+	[
+		K in keyof TColumns
+	]: TColumns[K] extends AnyColumn<{
+		data: infer Data;
+	}> ? Data
+		: never;
+};
+
+export type Tmp = TextColumnsOnly<Check<typeof schema>['apiWebhook']>;
diff --git a/typeperf-test/cases/table/extract-columns.ts b/typeperf-test/cases/table/extract-columns.ts
new file mode 100644
index 0000000000..333c241608
--- /dev/null
+++ b/typeperf-test/cases/table/extract-columns.ts
@@ -0,0 +1,13 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, unknown>> = {
+	[K in keyof TTables as TTables[K] extends { _: { brand: 'Table'; name: string; columns: any } } ? K : never]:
+		TTables[K] extends { _: { columns: infer Columns } } ? Columns : never;
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/table/extract-data-from-table.ts b/typeperf-test/cases/table/extract-data-from-table.ts
new file mode 100644
index 0000000000..72e858809a
--- /dev/null
+++ b/typeperf-test/cases/table/extract-data-from-table.ts
@@ -0,0 +1,20 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, unknown>> = {
+	[K in keyof TTables as TTables[K] extends { _: { brand: 'Table'; name: string; columns: any } } ? K : never]:
+		TTables[K] extends { _: { columns: infer Columns } } ? Columns : never;
+};
+
+export type Tmp = Check<typeof schema>;
+
+export const tmp = {} as Tmp;
+
+export const idData = tmp.apiWebhook.id._.dataType;
+export const configData = tmp.apiWebhook.cfg._.dataType;
+export const createdData = tmp.apiWebhook.createdBy._.dataType;
+export const timeData = tmp.apiWebhook.createdAt._.dataType;
diff --git a/typeperf-test/cases/table/pgtable-check.ts b/typeperf-test/cases/table/pgtable-check.ts
new file mode 100644
index 0000000000..2423da76f9
--- /dev/null
+++ b/typeperf-test/cases/table/pgtable-check.ts
@@ -0,0 +1,11 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, PgTable>> = TTables;
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/table/table-check-minimized.ts b/typeperf-test/cases/table/table-check-minimized.ts
new file mode 100644
index 0000000000..f77be58e69
--- /dev/null
+++ b/typeperf-test/cases/table/table-check-minimized.ts
@@ -0,0 +1,12 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, { _: { brand: 'Table' } }>> = {
+	[K in keyof TTables]: TTables[K]['_'];
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/table/table-check-optimized.ts b/typeperf-test/cases/table/table-check-optimized.ts
new file mode 100644
index 0000000000..574f61861e
--- /dev/null
+++ b/typeperf-test/cases/table/table-check-optimized.ts
@@ -0,0 +1,14 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { Table } from '../../lib/optimized-tables.ts';
+import type { schema } from '../../lib/schema-optimized.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+// type Check<TTables extends Record<string, Table>> = {
+// 	[K in keyof TTables]: TTables[K]['_'];
+// };
+type Check<TTable extends Table> = TTable;
+
+export type Tmp = Check<typeof schema['user']>;
diff --git a/typeperf-test/cases/table/table-check.ts b/typeperf-test/cases/table/table-check.ts
new file mode 100644
index 0000000000..7c05855b03
--- /dev/null
+++ b/typeperf-test/cases/table/table-check.ts
@@ -0,0 +1,13 @@
+import type { Table } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, Table>> = {
+	[K in keyof TTables]: TTables[K]['_'];
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/base.ts b/typeperf-test/cases/tables/base.ts
new file mode 100644
index 0000000000..8cd30f4430
--- /dev/null
+++ b/typeperf-test/cases/tables/base.ts
@@ -0,0 +1,8 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export type Schema = typeof schema;
+
+export const db = drizzle({ connection: 'postgres:/...' });
diff --git a/typeperf-test/cases/tables/no-columns.ts b/typeperf-test/cases/tables/no-columns.ts
new file mode 100644
index 0000000000..a7a2d1453c
--- /dev/null
+++ b/typeperf-test/cases/tables/no-columns.ts
@@ -0,0 +1,47 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { AnyTable, Assume, SQLWrapper, View } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+interface MinimalTable<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'Table';
+		name: TName;
+		schema: TSchema;
+		columns: Record<string, any>;
+		// inferSelect: Record<string, any>;
+	};
+}
+
+interface MinimalView<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'View';
+		name: TName;
+		schema?: TSchema;
+		selectedFields: Record<string, any>;
+	};
+
+	$inferSelect: Record<string, any>;
+}
+
+interface Container<TName extends string, T extends MinimalTable | MinimalView> {
+	table: T;
+	columns: T extends MinimalTable ? T['_']['columns'] : Assume<T, MinimalView>['_']['selectedFields'];
+	name: TName;
+	remapped: T extends MinimalTable ? AnyTable<{ name: TName }> : View<TName>;
+}
+
+type Check<TTables extends Record<string, MinimalTable | MinimalView>> = {
+	[K in keyof TTables & string]: TTables[K] extends MinimalTable<infer Name, infer Schema> | MinimalView<infer Name>
+		? Container<Assume<K, string>, TTables[K]>
+		: never;
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/pgtable-check.ts b/typeperf-test/cases/tables/pgtable-check.ts
new file mode 100644
index 0000000000..997a89fbbb
--- /dev/null
+++ b/typeperf-test/cases/tables/pgtable-check.ts
@@ -0,0 +1,9 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, PgTable>> = TTables;
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/schema-optimized.ts b/typeperf-test/cases/tables/schema-optimized.ts
new file mode 100644
index 0000000000..e31668addf
--- /dev/null
+++ b/typeperf-test/cases/tables/schema-optimized.ts
@@ -0,0 +1,21 @@
+import { text } from 'drizzle-orm/pg-core';
+import { pgTable } from '../../lib/optimized-tables.ts';
+
+export const apiWebhook = pgTable('ApiWebhook', {
+	id: text(),
+	createdTime: text(),
+	updatedTime: text(),
+	url: text(),
+	createdByUserId: text(),
+	workspaceId: text(),
+	disabled: text(),
+	failures: text(),
+	configuration: text(),
+});
+
+export const user = pgTable('user', {
+	id: text(),
+	createdTime: text(),
+	updatedTime: text(),
+	name: text(),
+});
diff --git a/typeperf-test/cases/tables/simple-cols-cfg.ts b/typeperf-test/cases/tables/simple-cols-cfg.ts
new file mode 100644
index 0000000000..fb1fddc302
--- /dev/null
+++ b/typeperf-test/cases/tables/simple-cols-cfg.ts
@@ -0,0 +1,63 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { AnyTable, Assume, SQL, SQLWrapper, View } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+interface MinimalColumn<TName extends string = string, TTableName extends string = string> {
+	_: {
+		// brand: 'Column';
+		// name: TName;
+		// data: any;
+		// columnType: string;
+	};
+
+	name: string;
+	dataType: any;
+	columnType: string;
+	// table: MinimalTable<TTableName> | MinimalView<TTableName>;
+	mapFromDriverValue(value: any): any;
+	mapToDriverValue(value: any): any;
+}
+
+interface MinimalTable<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'Table';
+		name: TName;
+		schema: TSchema;
+		columns: Record<string, MinimalColumn>;
+		// inferSelect: Record<string, any>;
+	};
+}
+
+interface MinimalView<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'View';
+		name: TName;
+		schema?: TSchema;
+		selectedFields: Record<string, MinimalColumn | SQLWrapper | SQL.Aliased>;
+	};
+
+	$inferSelect: Record<string, any>;
+}
+
+interface Container<TName extends string, T extends MinimalTable | MinimalView> {
+	table: T;
+	columns: T extends MinimalTable ? T['_']['columns'] : Assume<T, MinimalView>['_']['selectedFields'];
+	name: TName;
+	remapped: T extends MinimalTable ? AnyTable<{ name: TName }> : View<TName>;
+}
+
+type Check<TTables extends Record<string, MinimalTable | MinimalView>> = {
+	[K in keyof TTables & string]: TTables[K] extends MinimalTable<infer Name, infer Schema> | MinimalView<infer Name>
+		? Container<Assume<K, string>, TTables[K]>
+		: never;
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/simple-cols-nocfg.ts b/typeperf-test/cases/tables/simple-cols-nocfg.ts
new file mode 100644
index 0000000000..121fde0e79
--- /dev/null
+++ b/typeperf-test/cases/tables/simple-cols-nocfg.ts
@@ -0,0 +1,63 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { AnyTable, Assume, SQL, SQLWrapper, View } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+interface MinimalColumn<TName extends string = string, TTableName extends string = string> {
+	// _: {
+	// 	brand: 'Column';
+	// 	name: TName;
+	// 	data: any;
+	// 	columnType: string;
+	// };
+
+	name: string;
+	dataType: any;
+	columnType: string;
+	// table: MinimalTable<TTableName> | MinimalView<TTableName>;
+	mapFromDriverValue(value: any): any;
+	mapToDriverValue(value: any): any;
+}
+
+interface MinimalTable<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'Table';
+		name: TName;
+		schema: TSchema;
+		columns: Record<string, MinimalColumn>;
+		// inferSelect: Record<string, any>;
+	};
+}
+
+interface MinimalView<TName extends string = string, TSchema extends string | undefined = string | undefined>
+	extends SQLWrapper
+{
+	_: {
+		brand: 'View';
+		name: TName;
+		schema?: TSchema;
+		selectedFields: Record<string, MinimalColumn | SQLWrapper | SQL.Aliased>;
+	};
+
+	$inferSelect: Record<string, any>;
+}
+
+interface Container<TName extends string, T extends MinimalTable | MinimalView> {
+	table: T;
+	columns: T extends MinimalTable ? T['_']['columns'] : Assume<T, MinimalView>['_']['selectedFields'];
+	name: TName;
+	remapped: T extends MinimalTable ? AnyTable<{ name: TName }> : View<TName>;
+}
+
+type Check<TTables extends Record<string, MinimalTable | MinimalView>> = {
+	[K in keyof TTables & string]: TTables[K] extends MinimalTable<infer Name, infer Schema> | MinimalView<infer Name>
+		? Container<Assume<K, string>, TTables[K]>
+		: never;
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/table-check-minimized.ts b/typeperf-test/cases/tables/table-check-minimized.ts
new file mode 100644
index 0000000000..29424e1b49
--- /dev/null
+++ b/typeperf-test/cases/tables/table-check-minimized.ts
@@ -0,0 +1,47 @@
+/* eslint-disable unused-imports/no-unused-imports */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { SQLWrapper } from 'drizzle-beta';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+interface MinimalColumn<TName extends string = string, TTableName extends string = string> {
+	_: {
+		brand: 'Column';
+		name: TName;
+		data: any;
+		columnType: string;
+	};
+
+	name: string;
+	dataType: any;
+	columnType: string;
+	// table: MinimalTable<TTableName>;
+	mapFromDriverValue(value: any): any;
+	mapToDriverValue(value: any): any;
+}
+
+interface MinimalTable<TName extends string = string, TSchema extends string | undefined = string | undefined> // extends SQLWrapper
+{
+	_: {
+		brand: 'Table';
+		name: TName;
+		schema: TSchema;
+		columns: Record<string, MinimalColumn>;
+		// inferSelect: Record<string, any>;
+	};
+}
+
+// interface Container<TName extends string, T extends MinimalTable> {
+// 	table: T;
+// 	columns: T extends MinimalTable ? T['_']['columns'] : never;
+// 	name: TName;
+// 	remapped: T extends MinimalTable ? AnyTable<{ name: TName }> : View<TName>;
+// }
+
+type Check<TTables extends Record<string, MinimalTable>> = {
+	[K in keyof TTables]: TTables[K]['_'];
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/table-check-optimized-cut.ts b/typeperf-test/cases/tables/table-check-optimized-cut.ts
new file mode 100644
index 0000000000..04c187234d
--- /dev/null
+++ b/typeperf-test/cases/tables/table-check-optimized-cut.ts
@@ -0,0 +1,9 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+// import type { Table } from '../../lib/optimized-tables-cut.ts';
+import type * as schema from '../../lib/schema-optimized-cut.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+export type Check<TTables> = TTables;
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/table-check-optimized.ts b/typeperf-test/cases/tables/table-check-optimized.ts
new file mode 100644
index 0000000000..e591d9d7c9
--- /dev/null
+++ b/typeperf-test/cases/tables/table-check-optimized.ts
@@ -0,0 +1,11 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { Table } from '../../lib/optimized-tables.ts';
+import type { schema } from '../../lib/schema-optimized.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, Table>> = {
+	[K in keyof TTables]: TTables[K]['_'];
+};
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tables/table-check.ts b/typeperf-test/cases/tables/table-check.ts
new file mode 100644
index 0000000000..277540e6ef
--- /dev/null
+++ b/typeperf-test/cases/tables/table-check.ts
@@ -0,0 +1,9 @@
+import type { Table } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { schema } from '../../lib/schema.ts';
+
+export const db = drizzle({ connection: 'postgres:/...' });
+
+type Check<TTables extends Record<string, Table>> = TTables;
+
+export type Tmp = Check<typeof schema>;
diff --git a/typeperf-test/cases/tmp/base.ts b/typeperf-test/cases/tmp/base.ts
new file mode 100644
index 0000000000..c1ee7b3e68
--- /dev/null
+++ b/typeperf-test/cases/tmp/base.ts
@@ -0,0 +1,10 @@
+import { integer, pgTable, text } from 'drizzle-orm/pg-core';
+
+const colBuilders = {
+	id1: text(),
+	id2: integer(),
+};
+
+const table = pgTable('n', colBuilders);
+
+export type Tbl = typeof table;
diff --git a/typeperf-test/cases/tmp/step1.ts b/typeperf-test/cases/tmp/step1.ts
new file mode 100644
index 0000000000..315b2dca29
--- /dev/null
+++ b/typeperf-test/cases/tmp/step1.ts
@@ -0,0 +1,13 @@
+import { integer, pgTable, text } from 'drizzle-orm/pg-core';
+
+const colBuilders = {
+	id1: text(),
+	id2: integer(),
+};
+
+const table = pgTable('n', colBuilders);
+
+export type Tbl = typeof table;
+
+export type Id1Config = Tbl['_']['columns']['id1']['config'];
+export type Id2Config = Tbl['_']['columns']['id2']['config'];
diff --git a/typeperf-test/cases/tmp/step2.ts b/typeperf-test/cases/tmp/step2.ts
new file mode 100644
index 0000000000..2c6294116e
--- /dev/null
+++ b/typeperf-test/cases/tmp/step2.ts
@@ -0,0 +1,19 @@
+import type { ColumnRuntimeConfig } from 'drizzle-beta';
+import { integer, pgTable, text } from 'drizzle-beta/pg-core';
+
+const colBuilders = {
+	id1: text(),
+	id2: integer(),
+};
+
+const table = pgTable('n', colBuilders);
+
+export type Tbl = typeof table;
+
+export type Id1Config = Tbl['_']['columns']['id1']['config'];
+export type Id2Config = Tbl['_']['columns']['id2']['config'];
+
+export type Check6<T extends ColumnRuntimeConfig<any, object>> = T;
+
+export type Tmp1 = Check6<Id1Config>;
+export type Tmp2 = Check6<Id2Config>;
diff --git a/typeperf-test/lib/optimized-columns.ts b/typeperf-test/lib/optimized-columns.ts
new file mode 100644
index 0000000000..9d7c5f156f
--- /dev/null
+++ b/typeperf-test/lib/optimized-columns.ts
@@ -0,0 +1,234 @@
+/* eslint-disable drizzle-internal/require-entity-kind */
+import {
+	type ColumnBuilderBase,
+	// type ColumnBuilderRuntimeConfig,
+	type ColumnDataType,
+	type DriverValueMapper,
+	entityKind,
+	type GeneratedColumnConfig,
+	type GeneratedIdentityConfig,
+	type MakeColumnConfig,
+	type SQL,
+	// sql,
+	type SQLWrapper,
+	// type Table,
+} from 'drizzle-orm';
+// import type { PgTable } from './optimized-tables.ts';
+
+export interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
+	name: string;
+	dataType: TDataType;
+	columnType: TColumnType;
+	data: unknown;
+	driverParam: unknown;
+	enumValues: string[] | undefined;
+}
+
+export interface ColumnBaseConfig<
+	TDataType extends ColumnDataType = ColumnDataType,
+	TColumnType extends string = string,
+> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+	tableName: string;
+	notNull: boolean;
+	hasDefault: boolean;
+	isPrimaryKey: boolean;
+	isAutoincrement: boolean;
+	hasRuntimeDefault: boolean;
+}
+
+// export interface ColumnBaseConfig<
+// 	TDataType extends ColumnDataType = ColumnDataType,
+// 	TColumnType extends string = string,
+// > {
+// 	name: string;
+// 	dataType: TDataType;
+// 	columnType: TColumnType;
+// 	data: unknown;
+// 	driverParam: unknown;
+// 	enumValues: string[] | undefined;
+// 	tableName: string;
+// 	notNull: boolean;
+// 	hasDefault: boolean;
+// 	isPrimaryKey: boolean;
+// 	isAutoincrement: boolean;
+// 	hasRuntimeDefault: boolean;
+// }
+
+export interface ColumnTypeConfig<T extends ColumnBaseConfig> {
+	dialect: 'pg';
+	brand: 'Column';
+	tableName: T['tableName'];
+	name: T['name'];
+	dataType: T['dataType'];
+	columnType: T['columnType'];
+	data: T['data'];
+	driverParam: T['driverParam'];
+	notNull: T['notNull'];
+	hasDefault: T['hasDefault'];
+	isPrimaryKey: T['isPrimaryKey'];
+	isAutoincrement: T['isAutoincrement'];
+	hasRuntimeDefault: T['hasRuntimeDefault'];
+	enumValues: T['enumValues'];
+	baseColumn: T extends {
+		baseColumn: infer U;
+	} ? U
+		: unknown;
+	generated: GeneratedColumnConfig<T['data']> | undefined;
+	identity: undefined | 'always' | 'byDefault';
+}
+
+export interface ColumnBuilderRuntimeConfig<TData> {
+	name: string;
+	keyAsName: boolean;
+	notNull: boolean;
+	default: TData | SQL | undefined;
+	defaultFn: (() => TData | SQL) | undefined;
+	onUpdateFn: (() => TData | SQL) | undefined;
+	hasDefault: boolean;
+	primaryKey: boolean;
+	isUnique: boolean;
+	uniqueName: string | undefined;
+	uniqueType: string | undefined;
+	dataType: string;
+	columnType: string;
+	generated: GeneratedColumnConfig<TData> | undefined;
+	generatedIdentity: GeneratedIdentityConfig | undefined;
+}
+
+export interface Column<
+	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+> // eslint-disable-next-line @typescript-eslint/no-unused-vars
+	extends
+		// TTypeConfig extends object = object,
+		DriverValueMapper<T['data'], T['driverParam']>,
+		SQLWrapper
+{}
+
+export abstract class Column<
+	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+> implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+	static readonly [entityKind]: string = 'Column';
+
+	declare readonly _: ColumnTypeConfig<T>;
+	// declare readonly _: T;
+
+	// readonly name: T['name'];
+	// readonly keyAsName: boolean;
+	// readonly primary: T['isPrimaryKey'];
+	// readonly notNull: T['notNull'];
+	// readonly default: T['data'] | SQL | undefined;
+	// readonly defaultFn: (() => T['data'] | SQL) | undefined;
+	// readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
+	// readonly hasDefault: T['hasDefault'];
+	// declare readonly hasRuntimeDefault: T['hasRuntimeDefault'];
+	// readonly isUnique: boolean;
+	// readonly uniqueName: string | undefined;
+	// readonly uniqueType: string | undefined;
+	// readonly dataType: T['dataType'];
+	// readonly columnType: T['columnType'];
+	// readonly enumValues: T['enumValues'];
+	// readonly generated: GeneratedColumnConfig<T['data']> | undefined = undefined;
+	// readonly generatedIdentity: GeneratedIdentityConfig | undefined = undefined;
+
+	readonly name: string;
+	readonly keyAsName: boolean;
+	readonly primary: boolean;
+	readonly notNull: boolean;
+	readonly default: T['data'] | SQL | undefined;
+	readonly defaultFn: (() => T['data'] | SQL) | undefined;
+	readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
+	readonly hasDefault: boolean;
+	readonly isUnique: boolean;
+	readonly uniqueName: string | undefined;
+	readonly uniqueType: string | undefined;
+	readonly dataType: T['dataType'];
+	readonly columnType: T['columnType'];
+	readonly enumValues: T['enumValues'] = undefined;
+	readonly generated: GeneratedColumnConfig<T['data']> | undefined = undefined;
+	readonly generatedIdentity: GeneratedIdentityConfig | undefined = undefined;
+
+	protected config: ColumnBuilderRuntimeConfig<T['data']>;
+
+	constructor(
+		// table: Table,
+		config: ColumnBuilderRuntimeConfig<T['data']>,
+	) {
+		this.config = config;
+		this.name = config.name;
+		this.keyAsName = config.keyAsName;
+		this.notNull = config.notNull;
+		this.default = config.default;
+		this.defaultFn = config.defaultFn;
+		this.onUpdateFn = config.onUpdateFn;
+		this.hasDefault = config.hasDefault;
+		this.primary = config.primaryKey;
+		this.isUnique = config.isUnique;
+		this.uniqueName = config.uniqueName;
+		this.uniqueType = config.uniqueType;
+		this.dataType = config.dataType as T['dataType'];
+		this.columnType = config.columnType;
+		this.generated = config.generated;
+		this.generatedIdentity = config.generatedIdentity;
+		this.enumValues = ('enumValues' in config ? config.enumValues : undefined) as T['enumValues'];
+	}
+
+	abstract getSQLType(): string;
+
+	// getSQL(): SQL {
+	// 	return sql`${sql.identifier(this._.tableName)}.${sql.identifier(this._.name)}`;
+	// }
+
+	mapFromDriverValue(value: unknown): unknown {
+		return value;
+	}
+
+	mapToDriverValue(value: unknown): unknown {
+		return value;
+	}
+
+	/** @internal */
+	shouldDisableInsert(): boolean {
+		// return this.config.generated !== undefined && this.config.generated.type !== 'byDefault';
+		return true;
+	}
+}
+
+export abstract class PgColumn<
+	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
+> extends Column<T> {
+	static override readonly [entityKind]: string = 'PgColumn';
+
+	constructor(
+		// /*readonly*/ table: PgTable,
+		config: ColumnBuilderRuntimeConfig<T['data']>,
+	) {
+		super(/*table,*/ config);
+	}
+}
+
+export type BuildColumn<TTableName extends string, TBuilder extends ColumnBuilderBase> = PgColumn<
+	MakeColumnConfig<TBuilder['_'], TTableName>
+> // TBuilder['_']
+;
+export type BuildColumns<
+	TTableName extends string,
+	TConfigMap extends Record<string, ColumnBuilderBase>,
+> // TDialect extends Dialect,
+ =
+	& {
+		[Key in keyof TConfigMap]: BuildColumn<
+			TTableName,
+			TConfigMap[Key]
+		>;
+	}
+	& {};
+
+export type Update<T, TUpdate> =
+	& {
+		[K in Exclude<keyof T, keyof TUpdate>]: T[K];
+	}
+	& TUpdate;
+
+export type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<
+	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+>;
diff --git a/typeperf-test/lib/optimized-tables-cut.ts b/typeperf-test/lib/optimized-tables-cut.ts
new file mode 100644
index 0000000000..9fec8f7ec2
--- /dev/null
+++ b/typeperf-test/lib/optimized-tables-cut.ts
@@ -0,0 +1,245 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable drizzle-internal/require-entity-kind */
+// import type { BuildExtraConfigColumns, Simplify, SQLWrapper } from 'drizzle-orm';
+// import type { PgColumnBuilderBase } from 'drizzle-orm/pg-core';
+// import type { PgColumnsBuilders } from 'drizzle-orm/pg-core/columns/all';
+// import type { AnyColumn, BuildColumns, Column } from './optimized-columns.ts';
+
+export interface TableConfig<TColumns extends Record<string, any> = Record<string, any>> {
+	name: string;
+	schema: string | undefined;
+	// columns: TColumns;
+	dialect: string;
+}
+
+// export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+// 	notNull: true;
+// 	hasDefault: false;
+// }> ? TKey
+// 	: never;
+
+// export type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> =
+// 	TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+// 		_: {
+// 			generated: undefined;
+// 		};
+// 	} ? (T extends {
+// 			_: {
+// 				identity: undefined;
+// 			};
+// 		} ? TKey
+// 			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
+// 			: TKey)
+// 	: never;
+
+// export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> =
+// 	// dprint-ignore
+// 	TInferMode extends 'raw' // Raw mode
+//         ? TColumn['_']['data'] // Just return the underlying type
+//         : TColumn['_']['notNull'] extends true // Query mode
+//         ? TColumn['_']['data'] // Query mode, not null
+//         : TColumn['_']['data'] | null; // Query mode, nullable
+
+// export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> =
+// 	TDBColumNames extends true ? TColumn['_']['name']
+// 		: TName;
+
+// export type InferModelFromColumns<
+// 	TColumns extends Record<string, Column>,
+// 	TInferMode extends 'select' | 'insert' = 'select',
+// 	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+// > = Simplify<
+// 	TInferMode extends 'insert' ?
+// 			& {
+// 				[
+// 					Key in keyof TColumns & string as RequiredKeyOnly<
+// 						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+// 						TColumns[Key]
+// 					>
+// 				]: GetColumnData<TColumns[Key], 'query'>;
+// 			}
+// 			& {
+// 				[
+// 					Key in keyof TColumns & string as OptionalKeyOnly<
+// 						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+// 						TColumns[Key],
+// 						TConfig['override']
+// 					>
+// 				]?: GetColumnData<TColumns[Key], 'query'> | undefined;
+// 			}
+// 		: {
+// 			[
+// 				Key in keyof TColumns & string as MapColumnName<
+// 					Key,
+// 					TColumns[Key],
+// 					TConfig['dbColumnNames']
+// 				>
+// 			]: GetColumnData<TColumns[Key], 'query'>;
+// 		}
+// >;
+
+// export type InferModel<
+// 	TTable extends Table,
+// 	TInferMode extends 'select' | 'insert' = 'select',
+// 	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+// > = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
+
+// export type InferSelectModel<
+// 	TTable extends Table,
+// 	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+// > = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+
+// export type InferInsertModel<
+// 	TTable extends Table,
+// 	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+// > = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+
+// export interface Table<
+// 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+// 	T extends TableConfig = TableConfig,
+// > extends SQLWrapper {
+// 	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+// }
+
+export class Table<T extends TableConfig = TableConfig> {
+	declare readonly _: {
+		readonly brand: 'Table';
+		readonly config: T;
+		readonly name: T['name'];
+		readonly schema: T['schema'];
+		// readonly columns: T['columns'];
+		// readonly inferSelect: InferSelectModel<Table<T>>;
+		// readonly inferInsert: InferInsertModel<Table<T>>;
+	};
+
+	// declare readonly $inferSelect: InferSelectModel<Table<T>>;
+	// declare readonly $inferInsert: InferInsertModel<Table<T>>;
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	constructor(name: string, schema: string | undefined, baseName: string) {
+	}
+}
+
+export class PgTable<T extends TableConfig = TableConfig> extends Table<T> {}
+
+// export type PgTableWithColumns<T extends TableConfig> =
+// 	& PgTable<T>
+// & {
+// 	[Key in keyof T['columns']]: T['columns'][Key];
+// }
+// & {
+// 	enableRLS: () => Omit<
+// 		PgTableWithColumns<T>,
+// 		'enableRLS'
+// 	>;
+// };
+
+// export function pgTableWithSchema<
+// 	TTableName extends string,
+// 	TSchemaName extends string | undefined,
+// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+// >(
+// 	name: TTableName,
+// 	columns: TColumnsMap | ((columnTypes: PgColumnsBuilders) => TColumnsMap),
+// 	schema: TSchemaName,
+// 	baseName = name,
+// ): PgTableWithColumns<{
+// 	name: TTableName;
+// 	schema: TSchemaName;
+// 	columns: BuildColumns<TTableName, TColumnsMap>;
+// 	dialect: 'pg';
+// }> {
+// 	const rawTable = new PgTable<{
+// 		name: TTableName;
+// 		schema: TSchemaName;
+// 		columns: BuildColumns<TTableName, TColumnsMap>;
+// 		dialect: 'pg';
+// 	}>(name, schema, baseName);
+
+// 	const parsedColumns: TColumnsMap = columns as TColumnsMap;
+
+// 	const builtColumns = Object.fromEntries(
+// 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+// 			return [name, undefined];
+// 		}),
+// 	) as unknown as BuildColumns<TTableName, TColumnsMap>;
+
+// 	const builtColumnsForExtraConfig = Object.fromEntries(
+// 		Object.entries(parsedColumns).map(([name, colBuilderBase]) => {
+// 			return [name, undefined];
+// 		}),
+// 	) as unknown as BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>;
+
+// 	const table = Object.assign(rawTable, builtColumns);
+
+// 	return Object.assign(table, {
+// 		enableRLS: () => {
+// 			return table as PgTableWithColumns<{
+// 				name: TTableName;
+// 				schema: TSchemaName;
+// 				columns: BuildColumns<TTableName, TColumnsMap>;
+// 				dialect: 'pg';
+// 			}>;
+// 		},
+// 	});
+// }
+
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: TColumnsMap,
+	// 	// extraConfig?: (
+	// 	// 	self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+	// 	// ) => PgTableExtraConfigValue[],
+	// ): PgTableWithColumns<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	columns: BuildColumns<TTableName, TColumnsMap>;
+	// 	dialect: 'pg';
+	// }>;
+
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+	// ): // extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfigValue[],
+	// PgTableWithColumns<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	columns: BuildColumns<TTableName, TColumnsMap>;
+	// 	dialect: 'pg';
+	// }>;
+
+	<
+		TTableName extends string,
+	>(
+		name: TTableName,
+		columns: any,
+	): Table<{
+		name: TTableName;
+		schema: TSchema;
+		dialect: 'pg';
+	}>;
+
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, any>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+	// ): PgTable<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	dialect: 'pg';
+	// }>;
+}
+
+export const pgTable: PgTableFn = (name, columns) => {
+	// return pgTableWithSchema(name, columns, undefined) as any;
+	return {} as any;
+};
diff --git a/typeperf-test/lib/optimized-tables.old.ts b/typeperf-test/lib/optimized-tables.old.ts
new file mode 100644
index 0000000000..58d67fe7c8
--- /dev/null
+++ b/typeperf-test/lib/optimized-tables.old.ts
@@ -0,0 +1,237 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable drizzle-internal/require-entity-kind */
+import type { BuildExtraConfigColumns, Simplify, SQLWrapper } from 'drizzle-orm';
+import type { PgColumnBuilderBase, /* PgTableExtraConfig,*/ PgTableExtraConfigValue } from 'drizzle-orm/pg-core';
+import type { PgColumnsBuilders } from 'drizzle-orm/pg-core/columns/all';
+import type { AnyColumn, BuildColumns, Column } from './optimized-columns.ts';
+
+export interface TableConfig<TColumns extends Record<string, Column> = Record<string, Column>> {
+	name: string;
+	schema: string | undefined;
+	columns: TColumns;
+	dialect: string;
+}
+
+export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+	notNull: true;
+	hasDefault: false;
+}> ? TKey
+	: never;
+export type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> =
+	TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+		_: {
+			generated: undefined;
+		};
+	} ? (T extends {
+			_: {
+				identity: undefined;
+			};
+		} ? TKey
+			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
+			: TKey)
+	: never;
+
+export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> =
+	// dprint-ignore
+	TInferMode extends 'raw' // Raw mode
+        ? TColumn['_']['data'] // Just return the underlying type
+        : TColumn['_']['notNull'] extends true // Query mode
+        ? TColumn['_']['data'] // Query mode, not null
+        : TColumn['_']['data'] | null; // Query mode, nullable
+
+export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> =
+	TDBColumNames extends true ? TColumn['_']['name']
+		: TName;
+
+export type InferModelFromColumns<
+	TColumns extends Record<string, Column>,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = Simplify<
+	TInferMode extends 'insert' ?
+			& {
+				[
+					Key in keyof TColumns & string as RequiredKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key]
+					>
+				]: GetColumnData<TColumns[Key], 'query'>;
+			}
+			& {
+				[
+					Key in keyof TColumns & string as OptionalKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key],
+						TConfig['override']
+					>
+				]?: GetColumnData<TColumns[Key], 'query'> | undefined;
+			}
+		: {
+			[
+				Key in keyof TColumns & string as MapColumnName<
+					Key,
+					TColumns[Key],
+					TConfig['dbColumnNames']
+				>
+			]: GetColumnData<TColumns[Key], 'query'>;
+		}
+>;
+
+export type InferModel<
+	TTable extends Table,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
+
+export type InferSelectModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+
+export type InferInsertModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+
+export type InferSelectModelConfig<
+	TTableConfig extends TableConfig,
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTableConfig['columns'], 'select', TConfig>;
+
+export type InferInsertModelConfig<
+	TTableConfig extends TableConfig,
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = InferModelFromColumns<TTableConfig['columns'], 'insert', TConfig>;
+
+export interface Table<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends TableConfig = TableConfig,
+> extends SQLWrapper, InferTableModels<T> {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+
+export interface TableTypeConfig<T extends TableConfig> {
+	readonly brand: 'Table';
+	// readonly config: T;
+	readonly name: T['name'];
+	readonly schema: T['schema'];
+	readonly columns: T['columns'];
+	readonly inferSelect: Record<string, unknown>;
+	readonly inferInsert: Record<string, unknown>;
+}
+
+export interface InferTableModels<TConfig extends TableConfig> {
+	readonly $inferSelect: InferSelectModelConfig<TConfig>;
+	readonly $inferInsert: InferInsertModelConfig<TConfig>;
+}
+
+export interface Table<T extends TableConfig = TableConfig> extends SQLWrapper, InferTableModels<T> {
+}
+
+export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
+	declare readonly _: TableTypeConfig<T>;
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	constructor(name: string, schema: string | undefined, baseName: string) {
+	}
+}
+
+export class PgTable<T extends TableConfig = TableConfig> extends Table<T> {}
+
+export type PgTableWithColumns<
+	T extends TableConfig,
+	TTable extends PgTable<T & InferTableModels<T>> = PgTable<T & InferTableModels<T>>,
+> =
+	& TTable
+	& T['columns']
+	& InferTableModels<T>
+	& {
+		enableRLS: () => Omit<
+			PgTableWithColumns<T>,
+			'enableRLS'
+		>;
+	};
+
+export function pgTableWithSchema<
+	TTableName extends string,
+	TSchemaName extends string | undefined,
+	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+>(
+	name: TTableName,
+	columns: TColumnsMap | ((columnTypes: PgColumnsBuilders) => TColumnsMap),
+	schema: TSchemaName,
+	baseName = name,
+): PgTableWithColumns<{
+	name: TTableName;
+	schema: TSchemaName;
+	columns: BuildColumns<TTableName, TColumnsMap>;
+	dialect: 'pg';
+}> {
+	return {} as any;
+}
+
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig?: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+		) => PgTableExtraConfigValue[],
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap>;
+		dialect: 'pg';
+	}>;
+
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+	// 	extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>) => PgTableExtraConfigValue[],
+	// ): PgTableWithColumns<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	columns: BuildColumns<TTableName, TColumnsMap>;
+	// 	dialect: 'pg';
+	// }>;
+
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: TColumnsMap,
+	// 	extraConfig: (
+	// 		self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+	// 	) => PgTableExtraConfig,
+	// ): PgTableWithColumns<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	columns: BuildColumns<TTableName, TColumnsMap>;
+	// 	dialect: 'pg';
+	// }>;
+
+	// <
+	// 	TTableName extends string,
+	// 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	// >(
+	// 	name: TTableName,
+	// 	columns: (columnTypes: PgColumnsBuilders) => TColumnsMap,
+	// ): PgTableWithColumns<{
+	// 	name: TTableName;
+	// 	schema: TSchema;
+	// 	columns: BuildColumns<TTableName, TColumnsMap>;
+	// 	dialect: 'pg';
+	// }>;
+}
+
+export const pgTable: PgTableFn = (name, columns) => {
+	// return pgTableWithSchema(name, columns, undefined) as any;
+	return {} as any;
+};
diff --git a/typeperf-test/lib/optimized-tables.ts b/typeperf-test/lib/optimized-tables.ts
new file mode 100644
index 0000000000..620def5de0
--- /dev/null
+++ b/typeperf-test/lib/optimized-tables.ts
@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable drizzle-internal/require-entity-kind */
+import type { BuildExtraConfigColumns, Simplify, SQLWrapper } from 'drizzle-orm';
+import type { PgColumnBuilderBase, /* PgTableExtraConfig,*/ PgTableExtraConfigValue } from 'drizzle-orm/pg-core';
+import type { PgColumnsBuilders } from 'drizzle-orm/pg-core/columns/all';
+import type { AnyColumn, BuildColumns, Column } from './optimized-columns.ts';
+
+export interface TableConfig<TColumns extends Record<string, Column> = Record<string, Column>> {
+	name: string;
+	schema: string | undefined;
+	columns: TColumns;
+	dialect: string;
+}
+
+export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+	notNull: true;
+	hasDefault: false;
+}> ? TKey
+	: never;
+export type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> =
+	TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+		_: {
+			generated: undefined;
+		};
+	} ? (T extends {
+			_: {
+				identity: undefined;
+			};
+		} ? TKey
+			: T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never
+			: TKey)
+	: never;
+
+export type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> =
+	// dprint-ignore
+	TInferMode extends 'raw' // Raw mode
+        ? TColumn['_']['data'] // Just return the underlying type
+        : TColumn['_']['notNull'] extends true // Query mode
+        ? TColumn['_']['data'] // Query mode, not null
+        : TColumn['_']['data'] | null; // Query mode, nullable
+
+export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> =
+	TDBColumNames extends true ? TColumn['_']['name']
+		: TName;
+
+export type InferModelFromColumns<
+	TColumns extends Record<string, Column>,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = Simplify<
+	TInferMode extends 'insert' ?
+			& {
+				[
+					Key in keyof TColumns & string as RequiredKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key]
+					>
+				]: GetColumnData<TColumns[Key], 'query'>;
+			}
+			& {
+				[
+					Key in keyof TColumns & string as OptionalKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key],
+						TConfig['override']
+					>
+				]?: GetColumnData<TColumns[Key], 'query'> | undefined;
+			}
+		: {
+			[
+				Key in keyof TColumns & string as MapColumnName<
+					Key,
+					TColumns[Key],
+					TConfig['dbColumnNames']
+				>
+			]: GetColumnData<TColumns[Key], 'query'>;
+		}
+>;
+
+export type InferModel<
+	TTable extends Table,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
+
+export type InferSelectModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+
+export type InferInsertModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+
+export type InferSelectModelConfig<
+	TTableConfig extends TableConfig,
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTableConfig['columns'], 'select', TConfig>;
+
+export type InferInsertModelConfig<
+	TTableConfig extends TableConfig,
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = InferModelFromColumns<TTableConfig['columns'], 'insert', TConfig>;
+
+export interface Table<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends TableConfig = TableConfig,
+> extends SQLWrapper, InferTableModels<T> {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+
+export interface TableTypeConfig<T extends TableConfig> {
+	readonly brand: 'Table';
+	// readonly config: T;
+	readonly name: T['name'];
+	readonly schema: T['schema'];
+	readonly columns: T['columns'];
+	readonly inferSelect: Record<string, unknown>;
+	readonly inferInsert: Record<string, unknown>;
+}
+
+export interface InferTableModels<TConfig extends TableConfig> {
+	readonly $inferSelect: InferSelectModelConfig<TConfig>;
+	readonly $inferInsert: InferInsertModelConfig<TConfig>;
+}
+
+export interface Table<T extends TableConfig = TableConfig> extends SQLWrapper, InferTableModels<T> {
+}
+
+export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
+	declare readonly _: TableTypeConfig<T>;
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	constructor(name: string, schema: string | undefined, baseName: string) {
+	}
+}
+
+export class PgTable<T extends TableConfig = TableConfig> extends Table<T> {}
+
+export type PgTableWithColumns<
+	T extends TableConfig,
+	TTable extends PgTable<T & InferTableModels<T>> = PgTable<T & InferTableModels<T>>,
+> =
+	& TTable
+	& T['columns']
+	& InferTableModels<T>
+	& {
+		enableRLS: () => Omit<
+			PgTableWithColumns<T>,
+			'enableRLS'
+		>;
+	};
+
+export function pgTableWithSchema<
+	TTableName extends string,
+	TSchemaName extends string | undefined,
+	TColumnsMap extends Record<string, PgColumnBuilderBase>,
+>(
+	name: TTableName,
+	columns: TColumnsMap | ((columnTypes: PgColumnsBuilders) => TColumnsMap),
+	schema: TSchemaName,
+	baseName = name,
+): PgTableWithColumns<{
+	name: TTableName;
+	schema: TSchemaName;
+	columns: BuildColumns<TTableName, TColumnsMap>;
+	dialect: 'pg';
+}> {
+	return {} as any;
+}
+
+export interface PgTableFn<TSchema extends string | undefined = undefined> {
+	<
+		TTableName extends string,
+		TColumnsMap extends Record<string, PgColumnBuilderBase>,
+	>(
+		name: TTableName,
+		columns: TColumnsMap,
+		extraConfig?: (
+			self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>,
+		) => PgTableExtraConfigValue[],
+	): PgTableWithColumns<{
+		name: TTableName;
+		schema: TSchema;
+		columns: BuildColumns<TTableName, TColumnsMap>;
+		dialect: 'pg';
+	}>;
+}
+
+export const pgTable: PgTableFn = (name, columns) => {
+	// return pgTableWithSchema(name, columns, undefined) as any;
+	return {} as any;
+};
diff --git a/typeperf-test/lib/schema-optimized-cut.ts b/typeperf-test/lib/schema-optimized-cut.ts
new file mode 100644
index 0000000000..b9ba03a226
--- /dev/null
+++ b/typeperf-test/lib/schema-optimized-cut.ts
@@ -0,0 +1,20 @@
+import { pgTable } from './optimized-tables-cut.ts';
+
+export const apiWebhook = pgTable('hook', {
+	// id: text(),
+	// createdAt: text(),
+	// updatedAt: text(),
+	// url: text(),
+	// createdBy: text(),
+	// workspace: text(),
+	// data: text(),
+	// errors: text(),
+	// cfg: text(),
+});
+
+export const user = pgTable('user', {
+	// id: text(),
+	// createdAt: text(),
+	// updatedAt: text(),
+	// name: text(),
+});
diff --git a/typeperf-test/lib/schema-optimized.ts b/typeperf-test/lib/schema-optimized.ts
new file mode 100644
index 0000000000..3664b879e4
--- /dev/null
+++ b/typeperf-test/lib/schema-optimized.ts
@@ -0,0 +1,26 @@
+import { text } from 'drizzle-orm/pg-core';
+import { pgTable } from './optimized-tables.ts';
+
+export const apiWebhook = pgTable('hook', {
+	id: text(),
+	createdAt: text(),
+	updatedAt: text(),
+	url: text(),
+	createdBy: text(),
+	workspace: text(),
+	data: text(),
+	errors: text(),
+	cfg: text(),
+});
+
+export const user = pgTable('user', {
+	id: text(),
+	createdAt: text(),
+	updatedAt: text(),
+	name: text(),
+});
+
+export const schema = {
+	apiWebhook,
+	user,
+};
diff --git a/typeperf-test/lib/schema.ts b/typeperf-test/lib/schema.ts
new file mode 100644
index 0000000000..fb13fb6dcc
--- /dev/null
+++ b/typeperf-test/lib/schema.ts
@@ -0,0 +1,25 @@
+import { pgTable, text } from 'drizzle-orm/pg-core';
+
+export const apiWebhook = pgTable('hook', {
+	id: text(),
+	createdAt: text(),
+	updatedAt: text(),
+	url: text(),
+	createdBy: text(),
+	workspace: text(),
+	data: text(),
+	errors: text(),
+	cfg: text(),
+});
+
+export const user = pgTable('user', {
+	id: text(),
+	createdTime: text(),
+	updatedTime: text(),
+	name: text(),
+});
+
+export const schema = {
+	apiWebhook,
+	user,
+};
diff --git a/typeperf-test/package.json b/typeperf-test/package.json
new file mode 100644
index 0000000000..523b8da754
--- /dev/null
+++ b/typeperf-test/package.json
@@ -0,0 +1,33 @@
+{
+	"name": "typeperf-tests",
+	"version": "1.0.0",
+	"description": "Type performance tests for drizzle-orm",
+	"type": "module",
+	"scripts": {
+		"test": "vitest run",
+		"test:update": "vitest run --update",
+		"bench": "tsx benches/pg-columns.bench.ts",
+		"bench:beta": "tsx benches/beta/pg-columns.bench.ts",
+		"build": "echo skip...",
+		"build:artifact": "pnpm run build",
+		"pack": "echo skip...",
+		"pack:artifact": "pnpm run pack",
+		"test:types": "tsc --noEmit"
+	},
+	"keywords": [],
+	"author": "Drizzle Team",
+	"license": "Apache-2.0",
+	"private": true,
+	"devDependencies": {
+		"@ark/attest": "^0.56.0",
+		"tsx": "^4.19.0",
+		"vitest": "^2.1.8"
+	},
+	"dependencies": {
+		"drizzle-beta": "npm:drizzle-orm@1.0.0-beta.21",
+		"drizzle-seed": "workspace:../drizzle-seed/dist",
+		"drizzle-typebox": "workspace:../drizzle-typebox/dist",
+		"drizzle-valibot": "workspace:../drizzle-valibot/dist",
+		"drizzle-zod": "workspace:../drizzle-zod/dist"
+	}
+}
diff --git a/typeperf-test/test/bench.ts b/typeperf-test/test/bench.ts
new file mode 100644
index 0000000000..ef20314d54
--- /dev/null
+++ b/typeperf-test/test/bench.ts
@@ -0,0 +1,105 @@
+/* eslint-disable no-instanceof/no-instanceof */
+import fs from 'fs';
+import * as childProcess from 'node:child_process';
+import { parseDiagOutput, type TSCDiagOutput } from './utils.ts';
+
+export function swapDrizzleVersion(path: string, version: 'beta' | 'current') {
+	const [targetLib, desiredLib] = version === 'beta'
+		? ['drizzle-orm', 'drizzle-beta']
+		: ['drizzle-beta', 'drizzle-orm'];
+
+	const content = fs.readFileSync(path).toString();
+	fs.writeFileSync(
+		path,
+		content.replaceAll(`'${targetLib}'`, `'${desiredLib}'`).replaceAll(`'${targetLib}/`, `'${desiredLib}/`),
+	);
+}
+
+export function runTsDiagnostics(folder: string, file: string, ormVer: 'beta' | 'current', tsVer: 'latest' | 'next') {
+	const targetPath = `./cases/${folder}/${file}.ts`;
+
+	fs.writeFileSync(
+		'./tmp.tsconfig.json',
+		JSON.stringify({
+			extends: './tsconfig.json',
+			include: [targetPath],
+			exclude: ['./test/*', './lib/*'],
+			compilerOptions: {
+				allowImportingTsExtensions: true,
+			},
+		}),
+	);
+
+	swapDrizzleVersion(targetPath, ormVer);
+
+	return childProcess.execSync(
+		`pnpm ./node_modules/ts${tsVer}/bin/tsc --diagnostics --incremental false --noEmit true -p ./tmp.tsconfig.json`,
+	);
+}
+
+export function listTestFiles(folder: string) {
+	return fs.readdirSync(`./cases/${folder}`).filter((p) => p.endsWith('.ts')).map((p) => p.slice(0, -3));
+}
+
+export function listLibFiles() {
+	return fs.readdirSync(`./lib/`).filter((p) => p.endsWith('.ts')).map((p) => p.slice(0, -3));
+}
+
+export type DiagnosticsResult = {
+	name: string;
+	data: TSCDiagOutput;
+};
+
+export function bench(folder: string, ormVer: 'beta' | 'current', tsVer: 'latest' | 'next' = 'latest') {
+	let baseCase: TSCDiagOutput | undefined;
+	const rawCases = [] as DiagnosticsResult[];
+	const errCases: string[] = [];
+
+	for (const libName of listLibFiles()) {
+		swapDrizzleVersion(`./lib/${libName}.ts`, ormVer);
+	}
+
+	for (const name of listTestFiles(folder)) {
+		try {
+			const raw = runTsDiagnostics(folder, name, ormVer, tsVer);
+			const parsed = parseDiagOutput(raw);
+
+			if (name === 'base') {
+				baseCase = parsed;
+			} else {
+				rawCases.push({
+					name,
+					data: parsed,
+				});
+			}
+		} catch (e) {
+			if (typeof e === 'object') {
+				console.error(
+					(<{ output: (Buffer | undefined)[] }> <any> e).output.filter((e) => !!e).map((e) =>
+						`Case: ${name}\nError: ${e.toString()}`
+					).join('\n'),
+				);
+			}
+
+			errCases.push(name);
+		}
+	}
+
+	if (errCases.length) {
+		console.warn(`Errors in case${errCases.length > 1 ? 's' : ''} ${errCases.map((e) => `'${e}'`).join(', ')}`);
+	}
+
+	if (!baseCase) throw new Error('Missing baseline case!');
+
+	return [
+		{ name: 'baseline', data: baseCase! },
+		...rawCases.map((c) => ({
+			name: c.name,
+			data: Object.fromEntries(
+				Object.entries(c.data).map((
+					[k, v],
+				) => [k, <number> v - baseCase[k as keyof TSCDiagOutput]]),
+			) as TSCDiagOutput,
+		})) as DiagnosticsResult[],
+	];
+}
diff --git a/typeperf-test/test/index.ts b/typeperf-test/test/index.ts
new file mode 100644
index 0000000000..42d4d58070
--- /dev/null
+++ b/typeperf-test/test/index.ts
@@ -0,0 +1,24 @@
+import { bench } from './bench.ts';
+import { capitalize } from './utils.ts';
+
+const folder = process.argv[2] ?? 'rqb';
+const tsVer = (['latest', 'next'].includes(process.argv[3] ?? '') ? process.argv[3] : 'latest') as 'latest' | 'next';
+
+const beta: Record<string, string> = {};
+const current: Record<string, string> = {};
+
+for (const { data, name } of bench(folder, 'beta', tsVer)) {
+	beta[name.split('-').map((e) => capitalize(e)).join(' ')] = `${data.instantiations}`;
+}
+
+for (const { data, name } of bench(folder, 'current', tsVer)) {
+	current[name.split('-').map((e) => capitalize(e)).join(' ')] = `${data.instantiations}`;
+}
+
+const compiled = {
+	beta,
+	current,
+};
+
+console.log(`typescript@${tsVer}`);
+console.table(compiled);
diff --git a/typeperf-test/test/utils.ts b/typeperf-test/test/utils.ts
new file mode 100644
index 0000000000..161fff1240
--- /dev/null
+++ b/typeperf-test/test/utils.ts
@@ -0,0 +1,54 @@
+/* eslint-disable no-instanceof/no-instanceof */
+export function capitalize(str: string) {
+	return str.length ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+}
+
+export function uncapitalize(str: string) {
+	return str.length ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+}
+
+export type TSCDiagOutput = {
+	files: number;
+	lines: number;
+	identifiers: number;
+	symbols: number;
+	types: number;
+	instantiations: number;
+	/** Memory in kilobytes */
+	memoryUsed: number;
+	ioRead: number;
+	ioWrite: number;
+	parseTime: number;
+	bindTime: number;
+	checkTime: number;
+	emitTime: number;
+	totalTime: number;
+};
+
+export function parseDiagOutput(output: Buffer | string) {
+	const outStr = output instanceof Buffer ? output.toString() : output as string;
+
+	const lines = outStr.split('\n').filter(Boolean);
+
+	const spacers = /:[\t ]*/;
+	const notLetter = /[^A-Za-z]/;
+
+	return Object.fromEntries(lines.map((l) => {
+		const [k, v] = l.split(spacers) as [string, string];
+
+		// Form key
+		const kParts = k.split(notLetter);
+		const kStart = kParts.shift()!;
+		const camelCaseKey = `${uncapitalize(kStart)}${
+			kParts.map((p) => p.length > 1 ? capitalize(p) : p.toLowerCase()).join('')
+		}`;
+
+		// Form value
+		const sanitized = v.endsWith('s') || v.endsWith('K')
+			? v.slice(0, -1)
+			: v;
+		const numberValue = Number(sanitized);
+
+		return [camelCaseKey, numberValue];
+	})) as TSCDiagOutput;
+}
diff --git a/typeperf-test/tsconfig.json b/typeperf-test/tsconfig.json
new file mode 100644
index 0000000000..a6884a5357
--- /dev/null
+++ b/typeperf-test/tsconfig.json
@@ -0,0 +1,15 @@
+{
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"checkJs": false,
+		"noEmit": true,
+		"allowImportingTsExtensions": true,
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"target": "ES2022",
+		"strict": true,
+		"skipLibCheck": true
+	},
+	"include": ["./benches"],
+	"exclude": ["./cases", "./test", "./lib"]
+}
diff --git a/typeperf-test/vitest.config.ts b/typeperf-test/vitest.config.ts
new file mode 100644
index 0000000000..c2bc295b8e
--- /dev/null
+++ b/typeperf-test/vitest.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+	test: {
+		globalSetup: ['./vitest.setup.ts'],
+		include: ['./benches/**/*.bench.ts'],
+		testTimeout: 60000,
+	},
+});
diff --git a/typeperf-test/vitest.setup.ts b/typeperf-test/vitest.setup.ts
new file mode 100644
index 0000000000..97c0081bd0
--- /dev/null
+++ b/typeperf-test/vitest.setup.ts
@@ -0,0 +1,6 @@
+import { setup } from '@ark/attest';
+
+export default () =>
+	setup({
+		tsconfig: './tsconfig.json',
+	});